This patch should be applied to an un-modified XFree86 version 4.2.0
source tree.  It is the first of four patches that will will convert the
source tree to XFree86 version 4.3.0.

To apply this patch, run the following from the directory containing your
'xc' directory:

     patch -p0 -E < 4.2.0-4.3.0.diff1
     patch -p0 -E < 4.2.0-4.3.0.diff2
     patch -p0 -E < 4.2.0-4.3.0.diff3
     patch -p0 -E < 4.2.0-4.3.0.diff4

     rm -f xc/doc/hardcopy/Xext/mit-shm.PS.gz
     rm -f xc/doc/hardcopy/saver/saver.PS.gz
     rm -fr xc/fonts/scaled/Ethiopic
     rm -fr xc/fonts/scaled/Meltho
     rm -fr xc/programs/Xserver/hw/darwin/bundle
     rm -f xc/programs/Xserver/hw/hp/input/drivers/XHPKeymaps
     rm -f xc/programs/Xserver/hw/hp/ngle/ngledoblt.o.8.07
     rm -f xc/programs/Xserver/hw/xwin/X.ico
     rm -fr xc/programs/xcursorgen/redglass
     rm -fr xc/programs/xcursorgen/whiteglass
     touch xc/extras/Mesa/src/Trace/tr_attrib.c
     touch xc/lib/fontconfig/NEWS

     gzip -d < 4.3.0.tgz | tar vxf -


-------------------------------------------------------------------------------

Prereq: 4.2.0

Index: xc/programs/Xserver/hw/xfree86/CHANGELOG
diff -u xc/programs/Xserver/hw/xfree86/CHANGELOG:3.2144 xc/programs/Xserver/hw/xfree86/CHANGELOG:3.2588
--- xc/programs/Xserver/hw/xfree86/CHANGELOG:3.2144	Fri Jan 18 15:09:22 2002
+++ xc/programs/Xserver/hw/xfree86/CHANGELOG	Wed Feb 26 23:56:44 2003
@@ -1,3 +1,1984 @@
+XFree86 4.3.0 (27 February 2003)
+ 964. Add an imake option to allow the glibc21-style setjmp() behaviour
+      to be forced when auto-detecting it fails (this is needed for RH 7.0).
+ 963. Add missing raise/lower volume key descriptions for the "hpxe3gc"
+      XKB map (#A.1651, Paul Pacheco).
+ 962. Fix some typos in the Syriac XKB map (#5654, Emil Soleyman-Zomalan).
+ 961. Add documentation about using XKB for the XFree86 server's special
+      key sequences and the HandleSpecialKeys config option (#5653, Joe Moss).
+ 960. Move the XF86_DATE definition to a separate file so that bumping it
+      doesn't trigger almost everything to be rebuilt (David Dawes).
+ 959. Xterm patch #174 (Thomas Dickey).
+ 958. Fix a bug that was preventing DGA2 acceleration from being advertised
+      by the i810 driver (David Dawes).
+ 957. Fix an "xtt" font backend module crash that shows up on Linux/PPC,
+      related to an invalid code converter module being loaded because of
+      a broken string comparison in xttconv.c (#A.1647, Chisato Yamauchi,
+      Daisuke MASATSUNA).
+ 956. Fix a NULL dereference that can happen in lcGenConv.c (#A.1646,
+      Anthony Fok Tung-Ling).
+ 955. Bump the libXft minor revision for the UTF-16 APIs that were added
+      after rev 2.0 (#A.1643, A.1644, Keith Packard, 5652, Mike Harris).
+ 954. Fix a typo in the "freetype" font backend that prevents "ttc" fonts
+      from working (#5651, Mike Fabian).
+ 953. Fix atimisc bug in restoring colourmaps after a VT switch
+      (Marc La France).
+ 952. A more complete set of dead accent/space compose sequences, add
+      <Multi_key> <slash> for letters with a "stroke", and add some
+      combos for exponent characters, katakana voiced sounds, etc to
+      the en_US.UTF-8 compose file (#5646, David Monniaux).
+ 951. Reinstate the VBEInit() call in the savage driver's PreInit().  This
+      appears to fix a problem on some Savage MX platforms (#5649,
+      Mike Harris).
+ 950. Restore the radeon driver's unconditional RADEONPreInt10Save() call
+      on Alpha platforms because this is needed for Radeon cards where the
+      BIOS ROM can't be read after it's been run once (by the firmware)
+      without this (#5648, Jeff Wiedemeier).
+ 949. Update Newport driver doc (#5647, Guido Guenther).
+ 948. Fix reversed logic for VGA locking/unlocking (Nat Ersoz).
+ 947. Luit fixes:
+       - Fix a bug with --encoding being too strict with the syntax.
+       - Add a -x flag that causes luit to exit as soon as the child does.
+       - Update the man page to synchronise with Tomohiro's work on XTerm.
+      (#5643, Juliusz Chroboczek).
+ 946. Fix some endianness bugs in the r200 DRI driver, and guard a debugging
+      print message (Michel Dänzer).
+ 945. Fix radeon HW cursor artifacts when switching between 2-color and
+      ARGB cursors by always using the ARGB mode (#A.1639, Michel Dänzer and
+      Fredrik Höglund).
+ 944. Fix rootless XDarwin crash when trying to GetImage with a rectangle
+      bigger then the associated top level window (Apple).
+ 943. Add support for multi-head on ZX1-based Itanium2 systems  (Marc La France
+      with documentation and assistance from Hewlett-Packard).
+ 942. Correctly initialize the RE_LINE_PATTERN register in the radeon
+      and r200 DRI drivers (Keith Whitwell).
+ 941. Fix a problem where a malformed Ximage can cause Xcursor to step
+      outside the image data (#A.1636, Keith Packard, reported by
+      Michel Dänzer).
+ 940. Allow xf86setjmp/xf86setlongjmp to work with platforms where
+      setjmp() isn't directly available as a function, specifically Linux
+      platforms that use glibc 2.0 and 2.1. (David Dawes, Keith Packard).
+ 939. Check pScrn->vtSema before calling xf86SetCursor() from
+      xf86CursorCloseScreen().  This avoids a segfault at exit with some
+      drivers (Alan Hourihane).
+ 938. Fix adding FP native mode for Radeon (Hui Yu@ATI, Kevin Martin).
+ 937. Initialize I2C when primary head has an invalid DDC type for the
+      Radeon driver (Hui Yu@ATI).
+ 936. Video fixes for TV and TVOverscan for the nsc driver (Sarma Kolluru).
+ 935. Fix to prevent ShadowComposite() to try to update the framebuffer
+      when server is switched away (Egbert Eich).
+ 934. Fix problems where the ThirdLevel key and Alt modifiers don't work
+      when a map that uses the ThirdLevel virtual modifier is not the first
+      layout in a multi-layout configuration (#5642, Ivan Pascal).
+ 933. Use safe values in the Thai XIM which should work regardless of
+      the signedness of XIMStringConversionPosition (#A.1628,
+      Theppitak Karoonboonyanan).
+ 932. Replace xf86setjmp/xf86setlongjmp with symbol aliases that resolve
+      directly to the native libc versions so that they can operate in
+      modules, and make xf86jmp_buf much larger so that should be big enough
+      for any reasonable CPU/OS combination.  This should fix problems
+      with the Freetype2-based freetype font module (#A.1625, Keith Packard).
+ 931. Change the default base symbols map from pc104 to pc105, which should
+      fix most cases where the <LSGT> key isn't defined.  Also change the
+      default XkbModel from pc101 to pc105 (Ivan Pascal).
+ 930. Fix run-time enabling/disabling of VT switching via xf86EnableVTSwitch()
+      (David Dawes).
+ 929. Add a "DontVTSwitch" option to allow VT switching to be disabled
+      (on platforms where the X server initiates VT switches) (#5640,
+      Branden Robinson).
+ 928. Fix a memory leak in _XimExtension() (#5638, MINAMI Hirokazu).
+ 927. Fix hard-coded ProjectRoot paths in the proxymngr man page (#5634,
+      Branden Robinson).
+ 926. Fix a NULL pointer dereference in the fontenc library (#5633, Debian).
+ 925. Update the neomagic man page to document the OverlayMem option (#5632,
+      Diego Santa Cruz and Branden Robinson).
+ 924. Fix a memory leak in XCloseDisplay, and a potential race condition
+      when multiple threads attempt to initialize the Xcursor library
+      simultaneously (#A.1623, Keith Packard).
+ 923. Fix xvidtune to pop up a info window if mode on chipset is
+      not tuneable (Egbert Eich).
+ 922. Fix a NULL pointer in a var_arg list in xfd which causes problems
+      on 64 bit systems (Egbert Eich).
+ 921. Fix a typo in the nsc Imakefile when installing the linkkit 
+      (#A.1624, Stanislav Brabec).
+ 920. Remove a dependency on how Xlib buffers requests internally for
+      xtest's test 2 of XSync (Keith Packard).
+ 919. Fix a bug in the way the bitmap font code calculates mix/max bounds
+      (it was ignoring empty characters), which fixes some xtest fonts
+      bounds check failures (Keith Packard).
+ 918. Check that the HW cursor has been setup before calling
+      xf86ForceHWCursor() in the radeon (and r128) driver.  This fixes
+      crashes when using only the SW cursor (#5628, Michel Dänzer).
+ 917. Fix duplicate arguments for xf86MatchPciInstances() in the DESIGN doc
+      (#5627, Guido Guenther).
+ 916. Miscellaneous 64-bit and warning fixes to mfb, xf1bpp and xf4bpp
+      (Marc La France).
+ 915. Fix a bug in beforelight that was preventing it from being restarted 
+      and could cause random X clients to be killed. (Matthieu Herrb)
+ 914. Add a means by which a motherboard chipset driver can prevent the common
+      layer's check for mis-configured PCI-to-PCI bridges (Marc La France).
+ 913. Fix bug that would sometimes cause an extra hardware cursor to re-appear
+      on a secondary head after a server reset (Marc La France).
+ 912. Protect "cvl" references in recent changes to _XEventsQueued() with
+      '#ifdef XTHREADS' (reported by Dan Holm).
+
+XFree86 4.2.99.902 (17 February 2003)
+ 911. Change the newport driver to use ShadowFBInit2 to fix the broken
+      "switching back from the console" issue, and update the driver's man
+      page (#5625, Guido Guenther).
+ 910. SCO doc update (#5624, J. Kean Johnston).
+ 909. Fix X11.tmpl so that Fontconfig works correctly if an OS.cf file
+      sets HasFontconfig, and do this in sco5.cf (#5624, J. Kean Johnston).
+ 908. Move the vbe module from xfree86/os-support/ to xfree86/ (David Dawes).
+ 907. Some changes to the os-support kbd driver layer's calling conventions
+      to provide more flexibility (#A.1615, Zephaniah E. Hull).
+ 906. Fix a crash in the "xtt" font module caused by a NULL dereference
+      when the font cache becomes full (#A.1611, Chisato Yamauchi and
+      tokeijikakenoringo).
+ 905. Update the list of DRI-supported Radeon hardware (#A.1610,
+      Knut J Bjuland).
+ 904. Fix a problem in _XEventsQueued() that causes an event reader lock
+      of another thread to be released.  This can cause a hang and keyboard
+      lockup in KDE (#5619, Ewald Snel).
+ 903. Fix some bugs with Xft drawing to non-Render enabled servers:
+       - Drawing monochrome glyphs had an infinite loop.
+       - XftGlyphSpecCore failed to render some glyphs, leading to application
+         crashes from uninitialized values.
+       (#A.1608, Keith Packard, reported by Nalin Dahyabhai).
+ 902. Fix the <BKSL> key in the "winkeys" variants of the Russian and
+      Ukrainian XKB maps (#5624, Leon Kanter).
+ 901. Install the XKB README files (#5623, Ivan Pascal).
+ 900. Add the numeric keys row to the pc/us symbols map (#5622, Ivan Pascal).
+ 899. Resync with DRI mesa-4-0-4 branch:
+       - Fix DOT3 texture combine env in the r200 driver (Ian Romanick).
+       - Fix SW TCL path in the radeon driver (Felix Kühling).
+       - Don't assert for FLUSH_STORED_VERTICES if a glBegin hasn't been
+         emitted (Alan Hourihane).
+ 898. Another update to the fix for the client-side DRI cleanup code that
+      should fix references to freed data, an fix a potential memory leak
+      (Leif Delgass).
+ 897. Fix the behaviour of XLookupString() when XKB is enabled in Xlib
+      but not the server.  This fixes an xtest XRebindKeysym() failure
+      (David Dawes).
+ 896. Added radeon driver options documentation to the Options file
+      (#5621, Michel Dänzer).
+ 895. Fix the return value of SetFontPath() when a font path element is bad
+      (David Dawes).
+ 894. Add some more HP keyboard layouts (Peter Soos).
+ 893. Remove XFree86-specific keysyms that already have generic equivalents
+      (Menu, Redo, Print, Undo).
+ 892. Add keyboard layout information for the HP 5181 Internet/Multimedia
+      keyboard (#A.1603, John Mitchell).
+ 891. Fix a problem where two-color render cursors have extra pixels set
+      (#A.1607, Keith Packard).
+ 890. Fix for corruption when using video modes requiring more than 2MB on
+      S3 968 cards (#A.1602, Justin T. Gibbs).
+ 889. Fix TVoverscan problems on the NSC SC1200 chip (Sarma Kolluru).
+ 888. Cure cursor artifacts by setting HARDWARE_CURSOR_SHOW_TRANSPARENT and
+      HARDWARE_CURSOR_UPDATE_UNHIDDEN in the r128 and radeon drivers.  The
+      wait-for-VSync nonsense the Radeon's currently do can, and should, be
+      ripped out later.  (Marc La France).
+ 887. Extend HARDWARE_CURSOR_SHOW_TRANSPARENT to make hardware cursors
+      transparent, rather than disabling them, when a switch to a software
+      cursor is needed.  This removes recently introduced cursor artifacts
+      in the atimisc driver.  (Marc La France).
+ 886. Cancel repeat for switch screen XKB actions, which fixes a VT
+      switching problem that has just become visible (Ivan Pascal).
+ 885. Added reinitialization of screen layout after RandR size change
+      on a multihead setup. This keeps cursor movement beween screens
+      working (Egbert Eich).
+ 884. Remove Xcms.txt entries that have server-side equivalents.  It looks
+      like the slightly different resulting colour definitions from the
+      Xcms.txt entries were responsible for an xtest failure.
+ 883. Fix some problems with using pre-existing version of fontconfig,
+      freetype2 and expat (#A.1600, Keith Packard).
+ 882. Add missing zero-sized check to one of Xft's core rendering routines
+      (#A.1599, Keith Packard).
+ 881. Add a missing symbol reference to the radeon driver (#5618, Mike Harris).
+ 880. Fix the Xcursor include path in the man page (#5617, Kevin Brosius).
+ 879. Update ViRGE documentation (#5617, Kevin Brosius).
+ 878. Fix mkfontscale so that it doesn't include characters forbidden in XLFD
+      in the names it generates (#5616, Mike Fabian and Juliusz Chroboczek).
+ 877. Fix a rounding problem in the "freetype" module, which fixes the problem
+      worked around in entry 864 below (#5615, Juliusz Chroboczek).
+ 876. Fix incorrect alias for lv_LV.iso885913, and add some missing lv_LV
+      aliases (#5614, Aivils Stoss).
+ 875. Fix a bug where xauth may write an incomplete authority file and delete
+      the old one if there is insufficient disk space (#5612, Harald Hoyer).
+ 874. DPMSClose() wasn't correctly setting its devPrivate to NULL (based
+      on #A.1594, Denis Zaitsev).
+ 873. Fix scanpci's printing of routing information for PCI-to-PCI bridges
+      (Marc La France).
+ 872. Bring Cygwin/XFree86 up-to-date (#5613)
+       - Multiwindow Window Manager (Kensuke Matsuzaki).
+       - Clipboard integration (Harold Hunt).
+       - Remove unnecessary redefines of fchown/fchmod (Takashi Sawanaka)
+       - Fix some NULL pointer problems on screen changes (Alexander Gottwald).
+ 871. Fix some problems when noaccel is used in the nsc driver (Sarma Kolluru).
+ 870. Fix acceleration bugs in the nsc driver (Sarma Kolluru).
+ 869. Change initMouseHW() to always return TRUE, which restores the older
+      more graceful behaviour (Egbert Eich).
+ 868. Revert the DestroyContext, GarbageCollectDrawables reording in
+      dri_util.c, and instead check if the drawable is known to the DRI
+      client code before calling XF86DRIGetDrawableInfo (Egbert Eich).
+ 867. Fix some scaling problems with the updated whiteglass cursor icons,
+      fixing some incorrect hotspots (Kevin Puetz).
+ 866. The sunffb driver was treating a function with a void return value
+      as if it had a Bool return value.  This causes the driver to fail
+      in some cases (#A.1588, Ferris McCormick).
+ 865. Add private keysyms for the new XKB actions (XFree86 special keys),
+      and move those actions to an XKB compatibility map.  This fixes
+      side-effects (loss of auto-repeat and mousekeys functionality) of
+      the way this was implemented previously (#5610, Ivan Pascal).
+ 864. Fix an X server crash with the "freetype" module when displaying
+      kochi-mincho.ttf at a size of 18 pixels or higher (Chisato Yamauchi).
+ 863. Fix segfault in XkbInitKeyboardDeviceStruct() (David Dawes).
+ 862. Add a ServerFlags/ServerLayout option for disabling the RandR extension
+      (David Dawes).
+ 861. Resync with DRI mesa-4-0-4 branch:
+       - Correct RADEON_MAX_TCL_VERTSIZE and set MaxArrayLockSize
+         (Keith Whitwell).
+       - Fix EAGAIN handling in radeon_cp_dispatch_texture(), which fixes
+         corruption of large textures (Michel Dänzer).
+       - Fix bufferSize and alphaMask for DRI in several drivers (Brian Paul,
+         Leif Delgass).
+       - Avoid a loop on validating destroyed drawable (Keith Whitwell).
+       - Reorder DestroyContext, GarbageCollectDrawables to avoid error
+         (Egbert Eich).
+       - Remove untested BSD DRM vlank signal code (Eric Anholt).
+       - Update Radeon PCI IDs for BSD drm driver (Eric Anholt).
+       - Uninitialize mutexes on cleanup in the BSD drm driver, which
+         fixes panics with FreeBSD-5.0 with WITNESS (Eric Anholt).
+       - Remove the untested/unused gamma DRM driver for BSD (Eric Anholt).
+ 860. Fix byte swapping of the refresh rate argument to RandR's
+      SetScreenConfig request, and fix a 1.0 client compatibility problem
+      with SetScreenConfig (#A.1574, Keith Packard).
+ 859. The i810 driver wasn't releasing control of the agpgart when VT switching
+      away for the 830M and later (David Dawes).
+ 858. Update Rage 128 and Radeon PCI IDs (Mike Harris).
+ 857. Fix vertical retrace to not interfere with interrupt handling
+      (#5608, Michel Dänzer).
+ 856. Add M9 DRI support (Hui Yu@ATI).
+ 855. Update Radeon man page (Michel Dänzer).
+ 854. Add Radeon man page (Hui Yu@ATI).
+ 853. Use strtol instead of atoi in xf86cfg 'expert' mode. Make pauses
+      when printing keyboard models in xf86config (#5609, Chisato Yamauchi).
+ 852. Xterm patch #173 (Thomas Dickey).
+ 851. Don't use XkbGetKeyboard() in xset, just use XkbAllocKeyboard()
+      (Ivan Pascal).
+ 850. Fixes for the nsc driver for HW cursor hotspots and GX2 video
+      clipping issues (Sarma Kolluru, NSC).
+ 849. Fix HW cursor on CRTC2 for SiS650+301B (Thomas Winischhofer).
+ 848. Update the i810/i830 driver to recognise the 865G integrated graphics
+      chipset (David Dawes).
+ 847. Updates for the nsc driver (Sarma Kolluru, NSC).
+ 846. Fixed dual head for 1400x1050 displays (Thomas Winischhofer).
+ 845. Initializing clock ranges in several drivers to get rid of the
+      annoying 'scaled from 0.0 MHz' message in xf86PrintModes()
+      (Egbert Eich).
+
+XFree86 4.2.99.901 (4 February 2003)
+ 844. Fixing a double free in libXRandr (Egbert Eich).
+ 843. The microsoft-win3.1 encoding file wasn't being installed (#A.1569,
+      Mike Harris).
+ 842. Sync the FIFO in the vmware driver after defining an ARGB cursor
+      (#5607, Nolan Leake).
+ 841. Add missing Num_Lock and Scroll_Lock modifiers to the jp XKB map
+      (Chisato Yamauchi).
+ 840. Change the default cursor theme to "core".
+ 839. Fix some keys in the Slovenian (si) XKB map (David Balazic,
+      Henrik Nordström).
+ 838. Add a check to xset for a NULL return from XkbGetKeyboard()
+      (Tapani Utriainen).
+ 837. Resync with DRI mesa-4-0-4 branch:
+       - radeon DRM: only acknowledge interrupts we handle -- others could
+         be used outside the DRM (Michel Dänzer).
+       - Fix PCI and AGP posting problems (based on testing by Chris Ison
+         and suggestions by Benjamin Herrenschmidt and Arjan van de Ven).
+       - Remove radeon_flush_write_combine() which has been unused for a while
+         (Michel Dänzer).
+       - Disable strict aliasing when building the DRM (Michel Dänzer).
+ 836. Fix xfs crash on Darwin by making libXfont a flat namespace image
+      (Torrey T. Lyons).
+ 835. Avoid endless loop when initializing an PS/2 mouse behind a 
+      repeater (Egbert Eich).
+ 834. Radeon driver: make sure  RADEONCPStop() is only called when
+      RADEONCPStart() has been called before. Failing to do so may
+      make the kernel driver oops (Egbert Eich).
+ 833. Disabling MMX, 3DNow and SSE support for x86-64 as the function
+      call sequence is hardcoded to ia32 (Egbert Eich).
+ 832. Fix a hang in multi-thread mode caused by a missing UnlockDisplay() in
+      XkbGetMapChanges() (Jose Luu).
+ 831. Resync with DRI mesa-4-0-4 branch:
+       - Don't inflate relative vblank sequence numbers on repeated calls
+         (e.g., when interrupted by a signal) (Michel Dänzer).
+       - Fix size of VERTEX2 ioctl struct (Egbert Eich).
+ 830. SiS driver fixes:
+       - Mode restoration fix.
+       - Xv Hue and Saturation property fixes (310/325 series).
+       - Built-in mode fixes.
+       - Revert wrong bus width assumptions from previous patch.
+      (Thomas Winischhofer).
+ 829. R128 build fix on big endian platforms (#A.1565, George Staikos).
+ 828. Updated whiteglass cursor icons that fix the resizing glitches in the
+      existing ones (#A.1563, Kevin Puetz).
+ 827. Include server control definitions in some XKB maps that were missing
+      them (based on #A.1562, Jens Petersen).
+ 826. Define Alt/Meta modifiers for the jp106 XKB layout, and include
+      server control definitions (#A.1562, Jens Petersen).
+ 825. Add some locales required for the OpenI18N compliance test (#A.1550,
+      Leon Ho).
+ 824. s3virge driver updates:
+       - 320x240 doublescan support with mouse adjust.
+       - Power management printouts, DAC error printout fix.
+       - Log XVideo status based on chipset, and preliminary support for
+         disabling XV when a mode doesn't support it.
+      (#A.1550, Kevin Brosius).
+ 823. Add an Ethiopic TTF and OTF font (#A.1549, Daniel Yacob).
+ 822. Add a phonetic layout to the Bengali XKB map (#5606, Taneem Ahmed).
+ 821. Work around an AGP bug in the AlphaServer ES45 by padding each ring
+      buffer packet in the radeon drm with NOPs to cache line boundaries.
+      This is only done for Alpha platforms (#5605, Jeff Wiedemeier).
+ 820. Add missing domain decoding to DRM(irq_busid) for Alpha (#5604,
+      Jeff Wiedemeier).
+ 819. Build fix for the DRM on FreeBSD 5.0-current (#5603, Eric Anholt).
+ 818. xaaStateChange.c was not calling RestoreAccelState before doing
+      CPUToScreenTexture and CPUToScreenAlphaTexture, which seems to be the
+      reason why RENDER acceleration was broken on some dual-monitor MGA cards
+      (#5602, Nolan Leake).
+ 817. Make the vmware driver a little more conservative about supporting
+      HW RGBA cursors in 8-bit modes (#5606, Nolan Leake).
+ 816. Work around a problem with the vmware driver's interaction with the
+      offscreen memory manager (#5606, Nolan Leake).
+ 815. Fix fb's rotation of tiles and stipples when using non-zero PixOrigin
+      macros (Torrey T. Lyons).
+ 814. Fix Radeon native FP mode initializion (Hui Yu@ATI).
+ 813. Resync with DRI mesa-4-0-4 branch:
+       - Fix Q3A mode change prolbem in thr r200 driver (Keith Whitwell).
+       - Add a missing break to prevent spurious GL_INVALID_ENUM
+         (Leif Delgass).
+       - Fix __FUNCTION__ usage in the ffb 3D driver (Leif Delgass).
+       - Limit the number of pending vblank signals to 100 to prevent
+         a DoS (Michel Dänzer).
+       - Fix a void * arithmetic warning in the radeon DRM driver
+         (Leif Delgass).
+ 812. Fix a typo in the "pl2" XKB map (#A.1553, Piotr Xurek).
+ 811. Fix a null dereference in Mesa that can cause an X server crash at
+      client exit (#A.1548, Ezra Peisach).
+ 810. Improve the XTT code that prevents unexpected data to be passed to
+      XAA (#5600, Chisato Yamauchi).
+ 809. xkbcomp/rules/xfree86.xml wasn't being installed (#5599, Ivan Pascal).
+ 808. Add knowledge about two Korean foundries to mkfontscale (#5598,
+      Jungshik Shin).
+ 807. Disable the INREG fallbackup in the radeon 3D driver on Alpha because
+      it references a function that's not availalbe (#5596, Jeff Wiedemeier).
+ 806. Fixed patch 760: VBEInit takes entity index, not screen index 
+      (Egbert Eich).
+ 805. Card name changes/fixes (Hui Yu@ATI).
+ 804. Panel color channel depth fix for Radeons (Hui Yu@ATI).
+ 803. Include list_for_each_safe define for kernels that do not have it
+      (Kevin Martin).
+ 802. Fix 2D corruption around 3D window, when 3D window is moving and using
+      Radeon page flipping code (Michel Dänzer).
+ 801. Big endian fixes for Rage 128 and Radeon video and Radeon cursor code
+      (Michel Dänzer).
+ 800. Enable PCI GART for all architectures (still gated by ForcePCIMode, if
+      on an AGP card) (Michel Dänzer).
+ 799. Fix for Radeon's CP accelerated 2D sync routine (Michel Dänzer).
+ 798. SiS driver fixes:
+	- Fix for SiS730+LVDS machines (display modes restricted due to 
+	  hardware limits; LCD text mode restoration fixed)
+	- Fix for SiS300 bus width detection
+	- Fix for Fn+Fx output device switching on some machines (still 
+	  does not work on all)
+	- Numerous Dual Head fixes
+	- Added color hardware cursor support on 300/310/325/330 series
+	- Added PAL-M and PAL-N support for Chrontel 701x
+	- Added ModeLine handling for 300/310/325/330 series (CRT1 only)
+        (Thomas Winischhofer).
+ 797. Fix for memory fences on PowerPC (Marc La France).
+ 796. Work-around for Radeon int10 problems (Marc La France).
+ 795. Fix XDarwin crash in rootless mode with 16-bit color by ensuring that
+      window pixmap pointers are 32-bit aligned (Apple, Torrey T. Lyons).
+ 794. Update the i810 2D driver and i830 3D drivers to recognise and handle
+      the Intel 852GM/855GM integrated graphics chipsets (David Dawes,
+      Keith Whitwell).
+ 793. Force extension-generated mode switches always occur (Marc La France).
+ 792. Fix OS/2 library build problem (Frank Giessler).
+ 791. Fix bug that at times prevented recognition of resources decoded on PCI
+      root busses (Marc La France).
+ 790. Fix XDarwin's spurious transparent regions in rootless windows
+      (Torrey T. Lyons).
+ 789. Fix bug in recognition of certain ix86 Host-to-PCI bridges
+      (Marc La France).
+ 788. Fix for breakage in reading the serial PnP mouse ID string (David Dawes).
+ 787. Add "core" theme to Xcursor to force old behaviour (Keith Packard).
+ 786. Increase the default font cache size so that it works better for
+      iso10646 (#A.1541, Hidetoshi Yamanouchi, Chisato Yamauchi).
+ 785. Fix an XTT problem where garbage is displayed when there are undefined
+      glyphs for fixed width fonts, and fix some other potential problems
+      (#A.1541, Hidetoshi Yamanouchi, Chisato Yamauchi).
+ 784. Resync symbols/fi with symbols/pc/fi (#A.1532, Marko Myllynen,
+      #5589, Linus Torvalds).
+ 783. Resync xkb/rules/xfree86.xml with xfree86.lst (#5595, Ivan Pascal).
+ 782. ISO_Level3_Shift was breaking compose sequences because Xlib wasn't
+      recognising it as a modifier key (#5594, Ivan Pascal).
+ 781. Add a Lao (lo) XKB map (#5592, Anousak Souphavanh).
+ 780. Add a multi-layout version of the Malayalam keymap (#5593, Ivan Pascal).
+ 779. Add some missing entries to the xkb rules $oldlayouts and $nonlatin
+      sets (#5593, Ivan Pascal).
+ 778. Prevent mkfontscale from looking at bitmap fonts, and ensure that it
+      doesn't crash if a font happens to have no head (#5591,
+      Juliusz Chroboczek).
+ 777. Document that DVI the mga_hal module may be necessary to use the DVI
+      output with the G550 and other cards (#5590, Andrew Aitchison).
+ 776. Fixes for a few "nodeadkeys" XKB maps (David Dawes).
+ 775. Protect magic cookie from short-lived exposure on command line in 
+      startx (Christian Biere).
+ 774. Fix ELF loader to ignore -g debugging information
+      (#A.1539, Juergen Keil).
+ 773. Fix artifacts left by XDarwin when reshaping a shaped window (reported
+      by Adrian Umpleby).
+ 772. Fix XDarwin rootless crash when resizing a window (Apple).
+ 771. Fix vbe module to not assume BIOS call results are zero-extended
+      (Paulo Cesar Pereira de Andrade).
+ 770. Fix improper initialisation of pciConfigRec's.  Reported by Marcel
+      Moolenaar (Marc La France).
+ 769. Fix intermittent XDarwin crash on Mac OS X 10.1.x when changing cursors
+      on dual processor machines (Torrey T. Lyons).
+ 768. Correction to 'is' keymap (reported by Richard Allen).
+ 767. Fix GLX library mis-use of LockDisplay()/UnlockDisplay() sequences
+      (reported by Alexis Vartanian).
+
+XFree86 4.2.99.4 (20 January 2003)
+ 766. Fix XDarwin's rootless mode with 16-bit color (Apple).
+ 765. Allow UTF8 conversion to work for Japanese locales (#A.1527,
+      Etsushi Kato).
+ 764. Add a method for working around a problem that can show up when
+      running setxkbmap from a machine with a different version of XKB
+      than the X server.  The workaround method is documented in
+      the setxkbmap(1) man page (#5588, Ivan Pascal).
+ 763. Add some new keys and key combinations that can be used for switching
+      between XKB groups (#5587, Ivan Pascal).
+ 762. Fix typos in the README.fonts document (#5585, John Himpel,
+      Juliusz Chroboczek).
+ 761. Fix the pc/fi and pc/il XKB maps after recent changes made them
+      non-compliant with the multi-layout scheme (#5581, Ivan Pascal).
+ 760. Allow the mga driver to fallback to using VBE for DDC when using
+      the native method fails.  This allows DDC to work for DVI output
+      on Matrox cards (#5580, Andrew Aitchison).
+ 759. Add block handler for XDarwin's quartz modes to clean up any
+      autoreleased objects in the server thread (Torrey T. Lyons).
+ 758. Fix use of uninitliazed variable in xmag/xmag.c (A.1525, Keith Packard).
+ 757. Fix typo in Radeon Mono8x8 code (#A.1526, Juergen Keil).
+ 756. PS/2 mice initialization sequence changed: rerun entire sequence
+      when something goes wrong - this needs to be rewritten completely
+      after 4.3 is out (Egbert Eich).
+ 755. Savage driver: disable HW cursor on stretched LCD displays,
+      let SaveScreen and DGA test if HW cursor is on before 
+      disabling/reenabling it (Egbert Eich).
+ 754. Fixed VBE EDID read: due to a missing register setting read
+      ended in endless loop on certain systems (Egbert Eich).
+ 753. Changed the default mouse device for FreeBSD to sysmouse and the
+      protocol to auto when running X -configure (#5584, Eric Anholt).
+ 752. Changed the default mouse device for xf86cfg and xf86config to
+      /dev/sysmouse for FreeBSD (#5582, #5583, Eric Anholt).
+ 751. Fix for Mono8x8 patterns on Radeon (#A.1520, Juergen Keil, Kevin Martin).
+ 750. Fix for Radeon mode validation (#A.1330, #A.1380, #A.1393, #A.1522,
+      #A.1523, Wayne Whitney, Hui Yu@ATI, Juergen Keil).
+ 749. Workaround for flickering problem with switching between ARGB and mono
+      cursors on Radeons (#A.1380, Hui Yu@ATI).
+ 748. DDCMode fix for VidMode extension (#A.1380, Kevin Martin, Hui Yu@ATI).
+ 747. Panel detection bug fix for Radeon (#A.1380, Hui Yu@ATI).
+ 746. Add Xv overlay support for dual headed Radeons (#A.1380, Hui Yu@ATI).
+ 745. Fix Radeon driver's 24-bit support for flat panels (#A.1380, Hui Yu@ATI).
+ 744. Add Radeon 9500/Pro support (#A.1380, Hui Yu@ATI).
+ 743. Disable CGWorkaround for non-A11 rev R300s (Kevin Martin, Hui Yu@ATI).
+ 742. Radeon solid/dashed line fix for RV200 and newer card (Kevin Martin).
+ 741. Radeon overlay gamma fix (Hui Yu@ATI).
+ 740. Radeon LG panel fix (Hui Yu@ATI).
+ 739. Change makedepend to warn about any whitespace it finds in front of
+      pre-processor directives (Marc La France).
+ 738. Missing deadkeys in UTF-8 compose table (Mike Fabian).
+ 737. Build fix for SPARC (Thorsten Kukuk).
+ 736. Fixed integer address value in vesa driver to be large enough
+      to hold a 64 bit memory address (Andreas Schwab).
+ 735. Disabled RENDER accel on Matrox when used in multihead mode 
+      (Stefan Dirsch).
+ 734. Added FireGL 8700/8800 to the list of supported cards or RADEON
+      driver (Stefan Dirsch).
+ 733. Added -mcmodel=kernel to DRM Makefile for x86_64 (Stefan Dirsch). 
+ 732. Added vesa and fbdev driver to x86_64, removed nsc driver for ia64 build
+      (Stefan Dirsch).
+ 731. Fixing comments in th_TH.UTF-8 (Stefan Dirsch).
+ 730. Fixes from the DRI CVS:
+       - Don't segfault when spec or fog stride is 0.
+       - Don't set RADEON_SURF_TRANSLATION_DIS for framebuffer aperture
+         byte swapping on big endian machines; doesn't work with R200 and
+         later chips.
+       - Improve AGP workaround for pre-R200 chips.
+      (Michel Dänzer).
+ 729. Remove inappropriate __linux__ ifdef in the tdfx client-side DRI driver
+      (#5579, Eric Anholt).
+ 728. Allow makedepend handle whitespace in front of the '#' in preprocessor
+      directives (ISO C permits this) (#A.1516, Alexander Stohr).
+ 727. Add zh_TW.UTF-8 locale support (#A.1514, Leon Ho).
+ 726. Add recognition of wacom "XD-xxxx" models to the wacom input driver,
+      and treat them the same as "GD-xxxx" models (#A.1505, Rene Rask).
+ 725. Fix some missing render extension big-req compatibility (#A.1493,
+      Keith Packard).
+ 724. Fix a missing initialisation in the calcomp input driver that makes
+      the driver unusable and crashes the X server at startup (#A.1492,
+      Martin Kroeker).
+ 723. Work around for a bug in the i740 driver's XVideo support where the
+      video output would sometimes stop updating (#5578, Stephen Blackheath).
+ 722. Make DRM signal-on-vblank request return EINVAL on BSD since it's
+      not been ported yet (#5576, Eric Anholt).
+ 721. Remove the no longer used bsd/drm/kernel/r128/*.[ch] files (#5576,
+      Eric Anholt).
+ 720. drmFreeBufs was missing from the r128 driver's referenced symbols list
+      (#5574, Eric Anholt).
+ 719. Allow all of the extended mouse button bits for the "sysmouse" protocol
+      to be passed through (#5573, Eric Anholt).
+ 718. Update the XFree86 server special key handling so that by default
+      there is a fallback to the the hard-coded keys when there is no
+      Terminate action binding in the XKB map.  A new global option is
+      added to allow the fallback mechanism to be used never, when needed,
+      or always, with "when needed" the default (#5572, Joe Moss).
+ 717. Update the README.fonts document (#5570, Juliusz Chroboczek).
+ 716. Build the loader's libc wrapper with -DHAVE_SYSV_IPC on FreeBSD
+      since NVIDIA's binary driver uses it (#5569, Eric Anholt).
+ 715. Reduce the stack usage from 64k to 8k in imLcPrs.c, which fixes
+      a problem with Java for FreeBSD (#5568, Eric Anholt).
+ 714. Gcc 3 deprecated the #pragma weak method for weak links (#5567,
+      Motoyuki Konno).
+ 713. FreeBSD.cf updates:
+       - Sparc64 support
+       - Recent 5.0-current doesn't need libXThrStub
+       - Disable SharedLibXdmGreet, fixing xdm on alpha
+      (#5566, Eric Anholt).
+ 712. XDarwin now loads GLX support dynamically. Current options are Apple's
+      OpenGL framework or Mesa (Torrey T. Lyons).
+ 711. GeForceFX support in the nv driver (Mark Vojkovich).
+ 710. DPMS support in the nv driver.  CRTs only at this time (Mark Vojkovich).
+ 709. Fix for recognition of non-existent PCI devices (Marc La France).
+ 708. Fix for when firmware/BIOS initialisation does not enable the extra
+      command FIFO entries available on second-generation integrated Mach64
+      variants (Marc La France).
+ 707. Copying Syriac OTF fonts to directory OTF instead of TTF.
+      The xtt font renderer cannot handle OTF fonts causing the
+      entire directory to be ignored (Egbert Eich).
+ 706. Disabling MIT-SHM extensions for Xnest, fixing pixmap private
+      code in Xnest, thus cleaning out bogus patch 137. 
+      NOTE: The MIT-SHM presently *does* *not* work with Xnest. 
+      I have code to make it work but it is not well tested therefore 
+      MIT-SHM is disabled for now! (Egbert Eich).
+ 705. Fix the misnaming of three of the redglass cursors (#A.1491,
+      Keith Packard).
+ 704. Fix for two problems where the combination of xtt and XAA could result
+      in a crash.  The first problem was xtt returning a NULL pointer for
+      the bitmap even though the height was non-zero.  The second problem
+      was glyph ascent/descent exceeding the range of maxbounds.ascent/
+      maxbounds.descent (A.1484, Chisato Yamauchi, Masanori Shimada).
+ 703. Eliminate locale-dependent behaviour in fontconfig's setfontdirs
+      script (#A.1483, Markus Kuhn).
+ 702. Fix a bug in previous Thai XIM changes (#5563,
+      Theppitak Karoonboonyanan).
+ 701. Updates for the Israeli XKB map, including:
+       - Implement parens mirroring.
+       - Add two additional variants: "lyx", replacing shifted Hebrew
+         letters with Hebrew point marks, and "si1452", implementing the
+         Standard of Israel no. 1452 mapping.
+      (#5562, Tzafrir Cohen).
+ 700. BuildServersOnly fix when building on a system with no installed
+      X headers or libraries (#5559, ISHIKAWA Mutsumi).
+ 699. Add extended symbols for the "Logitech Cordless Desktop Navigator"
+      keyboard (#A.1480, Gilbert Fridgen).
+ 698. Fix xdm resource's font references to match actual bitmap fonts (#A.1477,
+      Göran Uddeborg).
+ 697. Update the xcursorgen man page (#A.1475, Keith Packard).
+ 696. Add a Mongolian XKB map (#5557, Sanlig Badral).
+ 695. Fixes for the Turkish XKB map (#5556, Nilgün Belma Bugüner).
+ 694. Thai XIM fixes:
+       - Fix the arguments in calling to StringConversionCallback in Thai XIM
+         filter, according to Hideki Hiura's explanation on the protocol.
+       - Add input sequence correction capability to the Thai XIM by
+         exploiting the XIMStringConversionSubstitution operation.
+      (#5553, Theppitak Karoonboonyanan).
+ 693. Resync the pc/fi XKB map with the previous map (#5552, Marko Myllynen).
+ 692. Workaround for parsing of Layout sections caused by recent changes
+      (#5558, Andrew Aitchison, Paulo César Pereira de Andrade).
+ 691. Fix the enabling of the Glint Gamma for use on an Appian Graphics
+      Jeronimo 2000 board which uses two Permedia3's (#5448, Sven Luther).
+ 690. Fix a problem in the trident driver for older chipsets and using
+      16bit clock programming, manifested itself on a Thinkpad 760EL,
+      but there are probably lots of others. (Alan Hourihane).
+ 689. On Darwin add Mac font directories to fonts.conf (Torrey T. Lyons).
+ 688. Post XDarwin mouse events in Quartz mode where they happen rather than
+      where the cursor currently is (Adrian Umpleby).
+ 687. Enable Freetype Mac FOND support on Mac OS X (Torrey T. Lyons).
+ 686. Add an "lswitch" option to the group xkb map, allowing the left Alt
+      key to be used for AltGr (#A.1463, Andreas Tobler).
+ 685. Add some locales for OpenI18N1.2 (LI18NUX2000) level.1 conformance,
+      and change zh_HK to point to zh_HK.big5hkscs which conforms to
+      glibc's default for zh_HK (#A.1457, Leon Ho).
+ 684. Updates for the Irish and Ogham XKB maps (#5549, 5550,
+      Séamus Ó Ciardhuáin).
+ 683. Xterm patch #172 (Thomas Dickey).
+
+XFree86 4.2.99.3 (21 December 2002)
+ 682. Add a request to XFree86-VidModeExtension to get the read/write
+      permissions so that clients can check if they have permission to
+      change parameters (David Dawes).
+ 681. Fix read-only XFree86-VidModeExtension requests for remote connections
+      (David Dawes, reported by Jamie Zawinski).
+ 680. Correct problem when the server prints the name of a 'private
+      xkb action' in a format that xkbcomp cannot understand, and
+      was causing problems when calling XkbGetKeyboard (Ivan Pascal).
+ 679. Fix animated cursor problem with multiple screens (#A.1454,
+      Keith Packard).
+ 678. gtf.c build fix for LynxOS 4.0 (#A.1453, Stuart Lissaman).
+ 677. Fix a segfault in fontconfig (#A.1450, Keith Packard).
+ 676. If some LEDs are lighting when one reloads the XKB keyboard map
+      (using setxkbmap or xf86cfg) the LEDs become 'frozen' and can't
+      be switched off. The patch fixes this bug. (#5544, Ivan Pascal).
+ 675. Fix some problems with the addition of multi-layout scheme to
+      xkb: some keys that aren't 'alphabetic' should be treated as
+      such to allow CapsLock+Shift working as expected; sometimes it
+      is required to load an include file more than once due to
+      multi-layout configuration, also fix some typos
+      (#5545, Ivan Pascal).
+ 674. XKB programable 'special combinations' (such as Ctrl+Alt+<key>)
+      also send usual key evants (press and release).  Although the
+      keysym generated in this case is NoSymbol such events can confuse
+      some applications (#5546, Ivan Pascal).
+ 673. Fix some remaining memory leaks in xkb initialization code
+      (Paulo César Pereira de Andrade).
+ 672. Temporarily enable the hard-coded Ctrl-Alt-Backspace terminate sequence
+      until a better fallback mechanism is implemented (Egbert Eich).
+ 671. Allow XKB-remappable hot keys to work with the "kbd" driver
+      (Egbert Eich).
+ 670. Export xf86inSuspend as needed by the "kbd" driver (Egbert Eich).
+ 669. SiS driver updates, including:
+       - support for SiS 330 Xabre (untested)
+       - Bugfix for boxes with two VGA connectors (tested)
+       - Autodetection of second monitor (tested)
+       - TV detection improved (tested)
+       - fixed error in 1280x1024 panel support (yet untested)
+       - Fixed bug in TV output on SiS30xB/30xLV (PAL still only BW, not
+         even the Windows driver can display PAL in color)
+       - Fixed positioning of TV picture. Works now for all video bridges
+         except Chrontel 7019 (still untested).
+      (Thomas Winischhofer).
+ 668. Add an alternative French XKB layout (fr-latin9) (#A.1446, Guylhem Aznar,
+      Rene Cougnenc, Nicolas Mailhot).
+ 667. Add bar and brokenbar to default <LSGT> definition for pc102 and
+      pc105 xkb maps (based on #A.1445, Göran Uddeborg).
+ 666. Change the keypad "decimal" key to KP_Separator in the dk, fi, no, se
+      xkb maps (#A.1440, Robin Rosenberg).
+ 665. Fixes and cleanups for the ISO8859-14 Compose table (#5543, 
+      Séamus Ó Ciardhuáin).
+ 664. Update the Ogham xkb map, including full support for the IS434 standard
+      and laptops (#5542, Séamus Ó Ciardhuáin).
+ 663. Update the Irish xkb map, including adding support for laptops (#5541,
+      Séamus Ó Ciardhuáin).
+ 662. Add "Inet" key definitions for the Honeywell Euroboard keyboard (#A.810,
+      Scott Penrose).
+ 661. Add "Inet" key definitions for the Trust Direct Access keyboard (#A.897,
+      Raphaël Poss).
+ 660. Add draglock support to the mouse driver, for aiding trackball use
+      by people with low dexterity (#A.1224, Paul Elliott).
+ 659. Fix bad includes in the xkb "level3" symbols file (A.1444,
+      Göran Uddeborg).
+ 658. Fix atimisc panel support bug that occurs when the mode on server entry
+      is a VGA mode with large horizontal and/or vertical blanking pulses
+      (Marc La France).
+ 657. Fix small documentation error in config/imake/imakemdep.h (#A.1052,
+      Linus Almstrom).
+ 656. Small change to find_mesa_visual() in xf86glx.c to avoid
+      branch misprediction on x86 (#A.1057, lompik at voila.fr).
+ 655. Clear memory allocated in xtWidgetAlloc() to avoid garbage from
+      malloc() being referenced later (#A.1114, Adam J. Richter).
+ 656. Make SysRq generate the same keycode as PrtScrn, and Break the same
+      keycode as Pause (#A.1160, Owen Taylor).
+ 655. Add "Inet" key definitions for some HP and Toshiba laptops (#A.1213,
+      Peter Soos).
+ 654. "Inet" key definitions for the Brother Internet keyboard (#A.1242,
+      Diego Iastrubni).
+ 653. "Inet" key definitions for the Ennyah model DKB-1008 keyboard (#A.1256,
+      Lionel Landwerlin).
+ 652. Apply i830 DRM driver cleanups to the i810 driver (#A.1438,
+      David Airlie).
+ 651. Add XI18NOBJS files for the ko_KR.UTF-8 and ja_JP.UTF-8 locales
+      (#5538, 5539, Jungshik Shin).
+ 650. Add FIRSTINDEX to the gb2312.1980-0.enc, gbk-0.enc and jis0212.1990-0.enc
+      encoding files (#5537, Jungshik Shin).
+ 649. Increment shared libraries major revisions on OpenBSD if gcc with 
+      stack protector is used (Matthieu Herrb, Todd Fries). 
+ 648. Resync with DRI (mesa-4-0-4-branch).
+ 647. Update XDarwin's IOKit mode to work with new event handling code
+      (Torrey T. Lyons).
+ 646. Add some more aliases for some German locales (#A.1263, Thomas Koeller).
+ 645. Update kio8-r encoded Cyrillic BDF fonts (#A.1267, Andrey A. Chernov).
+ 644. Fix Xtrans TLI code to handle a port scan and not fill the log file
+      with error messages from _XSERVTransTLIAccept() (#A.1333, Fiel Cabral).
+ 643. Only free cbs.data.text when cbs.type is XIMTextType in
+      _XimStatusDrawCallback() (#A.1342, Owen Taylor).
+ 642. Allow mouse pointer movement to be rotated (#A.1346, Joost Buelens).
+ 641. Add xkb layouts for Indian scripts (Kannada, Telugu, and Oriya) (#A.1436,
+      Guntupalli Karunakar).
+ 640. Enable MMX, SSE and 3DNow! for NetBSD 1.6 and later (#5536,
+      Matthias Scheler).
+ 639. Merge the xkb 'lt' layouts into pc/lt (#5535, Nerijus Baliunas).
+ 638. Set the default fa_IR character set to UTF-8 instead of
+      ISIRI-3342 (#A.1356, Roozbeh Pournader).
+ 637. Fixes and updates for building under LynxOS/PowerPC 4.0 (#A.1386,
+      Stuart Lissaman).
+ 636. Update the ClearlyU fonts to version 1.9 (#A.1386, Mark Leisher).
+ 635. Fix for drmOpenDevice() ignoring success on its second attempt at
+      opening the drm device (#A.1394, Alexander Stohr).
+ 634. Add support for a "-include" command line option to makedepend, similar
+      to the same GNU C option (#A.1396, Alexander Stohr).
+ 633. Perform country-independent matching for Chinese languages in fontconfig
+      (#A.1406, Keith Packard).
+ 632. Finish off the UTF-16 APIs in Xft, and fix the UTF-16 conversion
+      code in fontconfig (#A.1411, Keith Packard, Jungshik Shin).
+ 631. Make XIM locale checking case-independent (based on #A.1422, Leon Ho).
+ 630. Fix incorrect datatype for the pixmap width in
+      fbCompositeSrcAdd_8000x8000(), and add some small optimisations
+      (#A.1423, Keith Packard).
+ 629. Update the se xkb map to allow the older AltGr+5 method of entering
+      the Euro sign (#A.1433, Christian Rose).
+ 628. Add validation for the screen number parameter received over the wire
+      by the X server's DRI extension code, and fix some similar checks in
+      the GLX code.  This fixes X server segfaults when an invalid screen
+      value is provided (#A.1434, Felix Kühling)..
+ 627. Fix some bugs in the Iranian xkb layout (#A.1135, Roozbeh Pournader).
+ 626. Add a Bosnian xkb layout (#A.1398, Amila Akagic).
+ 625. Fix for Hungarian xkb layout (#A.1175, Peter Soos).
+ 624. Update the Maltese xkb layouts (#A.1243, Ramon Casha).
+ 623. Add EuroSign to the xkb "gb" layout (#A.901, Dermot McNally).
+ 622. Various updates for the xkb "xfree86" keymap list (including #A.777,
+      Andriy Rysin).
+ 621. Let kbd driver test if Xserver is in suspend before handling any
+      input events (Egbert Eich).
+ 620. Fixed agp version checking to accept minor versions >= the specified
+      number (Leif Delgass).
+ 619. Update referenced symbols lists for the mga, vesa, i810 and vmware
+      drivers (David Dawes).
+ 618. Add missing symbol to the mga driver's referenced symbols lists
+      (#5534, Mike Harris).
+ 617. Add some utf8 locale aliases (#5533, Mike Harris).
+ 616. Fix some Linux/Alpha (with domain support) build and runtime
+      problems (#5532, Jeff Wiedemeier).
+ 615. Add some missing symbols to the radeon driver's referenced symbols
+      lists (#5531, Mike Harris).
+ 614. Restore the Alt/Meta mappings for pc104/pc105 keyboards in the
+      multi-layout maps (David Dawes).
+ 613. Add UTF-8 locale entries for Amharic-Ethiopian, Tigrinya-Eritrean
+      and Tigrinya-Ethiopian (#5529, Daniel Yacob).
+ 612. Restore the "\|" key in the GB multi-layout keyboard layout (#5528,
+      Andrew Aitchison).
+ 611. Updates for the auto-generated UTF-8 Compose file (#5527,
+      David Monniaux).
+ 610. Updates/fixes for the Korean font encoding file (#5525, Jungshik Shin).
+ 609. Fix some problems with the multilayout version of the Turkish layout
+      (#5521, Nilgün Belma Bugüner).
+ 608. DRM vertical blank ioctl can send a signal as an alternative to
+      blocking (r200 and radeon only so far) (#5523, Michel Dänzer).
+ 607. Build fix for Linux/Alpha (#5515, Mike Harris).
+ 606. Change CppCmd on Linux to /usr/bin/cpp (#5514, Mike Harris).
+ 605. Fix an incorrect check for the "StrangeLockups" option in the
+      neomagic driver (#5505, Mike Harris).
+ 604. Rename geode driver to nsc and add GX2 support (Sarma Kolluru, NatSemi).
+ 603. Add the missing XKB definition for keysym "ISO_Level3_Lock" (#5526,
+      Séamus Ó Ciardhuáin).
+ 602. XkbSetControls should return True when successful, not False (#A.1385,
+      Stephen Montgomery-Smith).
+ 601. The functions XGetXlibControls and XSetXlibControls must work even if
+      the X server doesn't have the XKB extensions (#5513, Ivan Pascal).
+ 600. Add en_ZA locales (#5512, Berend De Schouwer).
+ 599. Fix shadowfb to not make update callbacks for operations that don't
+      touch offscreen memory, and to not double (or more) update glyph
+      rendering (#5509, Nolan Leake).
+ 598. Change XAA to not sync when it sees RENDER operations that don't
+      touch VRAM, and to try to accelerate Glyphs with Composite if it
+      seems likely that will work (#5509, Nolan Leake).
+ 597. VMware driver updates, including:
+       - Fixed vmwareGetImage to correctly calculate the region to be gotten.
+       - Small cursor bypass optimization.
+       - Fixed race between writing normal registers and writing HWcursor
+         registers.
+       - Fixed small race in the FIFO wrap code that could cause FIFO
+         corruption.
+       - Added temporary offscreen memory manager.
+       - Added compositing (RENDER) acceleration.
+      (#5509, Nolan Leake).
+ 596. Newport driver updates, including:
+       - Add hardware cursor support.
+       - Workaround blank console after VT switch on some newports
+         (based on a patch from Dominik Behr).
+       - Support for the Indigo2 XL (based on a patch from Adrian Schroeter).
+      (#5507, Guido Guenther).
+ 595. Add SGML versions of the XKB config and enhancing docs (#5506,
+      Kamil Toman).
+ 594. Enable SSE, MMX, 3DNow support by default for Linux/x86_64 (#5502,
+      Mike Harris).
+ 593. Replace hard-coded "lib" directory names with LibDirName in Imake.tmpl
+      (#5480, Mike Harris).
+ 592. DRI shouldn't have been enabled for Linux/s390 (#5500, Mike Harris).
+ 591. Numerous bug, stability, and correctness fixes for the Intel 830/845G
+      3D support (#5517, Keith Whitwell).
+ 590. Numerous bug and stability fixes for the Intel 830/845G 2D and Xv
+      support (#5517, David Dawes).
+ 589. Move IOKit-specific global variables out of generic XDarwin code
+      (Torrey T. Lyons).
+ 588. Add a new interface for registration of core font renderers that allows
+      priorities to be assigned.  This allows multiple renderers for the
+      same extension to be registered, with the one with the highest priority
+      being the one that gets used (#5435, 5437, Juliusz Chroboczek).
+ 587. Fix 640x480 modes in neomagic driver (Egbert Eich).
+ 586. Fix reporting of G400/G450 in MGA driver (Andrew C. Aitchison).
+ 585. Don't change the authorization data (and in particular, don't
+      enable local host access) if the X server's authority file
+      is removed or becomes unreadable while the server is running
+      (David Dawes, reported by Dietmar Schröter).
+ 584. Xterm patch #171 (Thomas Dickey).
+ 583. Fix uninitialized buffer-count in luit (Semen A. Ustimenko).
+ 582. Various xdm updates from Debian and Suse (#5358, Branden Robinson, 
+      #5511, Sebastian Krahmer).
+ 581. Flesh out suncg6's SaveScreen() function (Moritz Bunkus).
+ 580. lib/Xaw/MultiSrc.c improperly checks open() return value
+      (A.1415, Jaromir Dolecek), Fix provided by Hideo Saito in NetBSD.
+ 579. Add DPMS and screen blanking support in the sunffb driver
+      (Ferris McCormick).
+ 578. Fix SEGV that occurs when Xsun* runs into an unrecognized framebuffer
+      type (Marc La France).
+ 577. When the mode on server entry is found to be using composite sync on a
+      Mach64 variant, turn on the "compositesync" option (Marc La France).
+ 576. Plug SIGIO hole while the server is switching back into its VT
+      (reported by Michel Lespinasse).
+ 575. Use shadowfb in XDarwin fullscreen Quartz mode (Torrey T. Lyons).
+ 574. Make RENDER optional for Xvfb. When RENDER is enabled add depth 32 
+      pixmap format  to list of supported pixmaps (Egbert Eich).
+ 573. Fix va_args glitches for xterm/libfontconfig: 0 == (void*)0 isn't true   
+      for all platforms (Egbert Eich).
+ 572. Fix lbxproxy to also build on platforms that don't have snprintf()    
+      (Egbert Eich).
+ 571. Fix va_args glitches in mkfontscale: arg stack isn't preserved after
+      calling va_arg on all platforms (Egbert Eich).
+ 570. Fixed x11perf aa benchmarks to support non-default visuals/colormaps
+      (Egbert Eich).
+ 569. Use -Os to build on Darwin PPC with Gcc 3.x (Torrey T. Lyons).
+ 568. XEditResCheckMessages trashed XtMalloced memory on some widget
+      hierarchies, due to using incorrect indexes when removing
+      duplicates (A.1409, Rob Arthan).
+ 567. xprop updates (Mihael Hategan).
+ 566. Fix SEGV in ICE library (Petter Reinholdtsen).
+ 565. Fix interaction between backing store and miext/shadow (adapted from
+      Paulo César Pereira de Andrade).
+ 564. Add new key descriptions for XFree86 special keys (i.e. for terminating
+      and VT switching the Xserver) (#5510, Ivan Pascal).
+ 563. #define DEALLOCATE_LOCAL as "do {} while(0)" instead of nothing to
+      eliminate GCC warnings caused by code that does not assume
+      DEALLOCATE_LOCAL can deal with null pointers (suggested by Kevin Martin).
+ 562. -
+ 561. Fix bug in kldload() call on FreeBSD (reported by Joy Ganguly).
+ 560. Adding int10 symbols to the list of possibly unresolved symbols in
+      Rage128 driver (Egbert Eich).
+ 559. Allowing scanpci to be build on Ppc (Egbert Eich).
+ 558. Updating SiS driver. Lots of new features, supported chipsets and
+      LCD panels, bug fixes. For details please check:
+      http://www.winischhofer.net/linuxsis630.shtml 
+      (Thomas Winischhofer).
+ 557. Changed MGA driver to query fb_offset for DRI from kernel instead
+      of taking the driver's FBAddress - this is required by platforms
+      like Alpha (Egbert Eich).
+ 556. Fix Xmu memory leak (reported by Michael Vogt).
+ 555. Deal with Creative SBlive devices that mis-identify themselves as
+      "prehistoric" VGA's (Marc La France).
+ 554. Allow -configure to setup Unknown Vendor/Boards removing the requirement
+      of xf86PciInfo information (Alan Hourihane).
+ 553. Hardware alpha blended cursors in the "nv" driver, new PCI IDs, and
+      a fix for a problem on PowerPC (Mark Vojkovich).
+ 552. "nv" driver workaround needed to let Xv continue to work after a 
+      suspend on some laptops (Pierre Lombard).
+ 551. Restore '--assembler-with-cpp' in AsCmd for Linux/mips, fixing the build
+      on that platform (#5499, Guido Guenther).
+ 550. An alternative update for alphabetic four level cz, sk XKB maps.
+      This is compatible with the way MS Windows behaves (#5498, Kamil Toman).
+ 549. Clarify the difference between characters and bytes in xev (#5497,
+      Markus Kuhn).
+ 548. Add an Irish (ie) XKB keyboard map (#5496, Seamus O Ciardhuain).
+ 547. Replace the UTF-8 compose map with one automatically generated from
+      the official Unicode documentation, with the addition of some
+      handwritten rules (#5495, David Monniaux).
+ 546. Document the "nomtrr" option in the XF86Config man page (#5494,
+      Mike Harris).
+ 545. Some fixes for the Icelandic xkb map (#5493, Olafur Osvaldsson).
+ 544. Add French Canadian keyboard description to xfree86.lst (#5492,
+      Mike Harris).
+ 543. Add a new file for descriptions of XkbModel, XkbLayout, XkbVariant
+      and XkbOption names, using an XML format.  Includes a DTD file
+      and perl script to convert from the new format to the old (.lst)
+      format (#5491, Ivan Pascal).
+ 542. Add missing "dvorak" single-group XKB layout (#5490, Ivan Pascal).
+ 541. Change the xkbfile library to allow some names to be grouped into
+      a named list, which allows the rules file to be simplified (#5490,
+      Ivan Pascal).
+ 540. Make the new single-group XKB symbols maps used by default (#5490,
+      Ivan Pascal).
+ 539. Fix a crash that can happen when some apps are run in CJK locales
+      (#5489, Havoc Pennington).
+ 538. Make xdm check the full password string (on Linux) for locked accounts
+      rather than just the first character (#5485, Mike Harris,
+      Nalin Dahyabhai).
+ 537. Fix a few cases where the transport endpoints would be removed
+      even if NOUNLINK is specified in the flags (#5484, J. Kean Johnston).
+ 536. Attempt to fix bitblt problems when doing offscreen pixmaps in
+      i810 (Egbert Eich).
+ 535. Change Build rule so that x86 assembler code for MESA can be completely
+      disabled on i386 (Egbert Eich).
+ 534. Added IEEE Optimization for x86-64 (Egbert Eich).
+ 533. Initialized fullscreen in DRIscreenPrivate to a vaild value 
+      (Egbert Eich).
+ 532. Fixed module loader to map memory in the low 32bit address space on
+      x86-64 (Egbert Eich).
+ 531. Shifted Keypad delete: added KP_Separator for de_DE and de_CH keyboard.
+ 530. Added sanity checks to various scripts (Egbert Eich).
+ 529. Fixed Trident RGB16 video playback mode (Alastair Robinsion).
+ 528. i810 only set OVRACT register when TVout isn't enabled 
+      (Sebastien BASTARD, Matthew J. Sottek, Egbert Eich).
+ 527. Record changes of BusMaster state so that pciDisable/Enable/Mem/Io
+      don't override these (Egbert Eich).
+ 526. Fixed RAC code: when no resources are shared chips may still need
+      RAC for bus access if both require non overlapping parts of the
+      VGA resources (Egbert Eich).
+ 525. Fix for resource registration of C&T and Tdfx driver (Egbert Eich).
+ 524. Prevent   core dumps in Xutf8Reset/Lookup code of Xlib (Masaru Yokoi).
+ 523. Added support for BE systems for C&T driver (Michael Stephen Hanni). 
+ 522. Added support for special keys found on many ACPI control, Easy Access
+      Keyboards, Internet keyboards, laptops, notebooks and PDA (via
+      xkb/symbols/inet). Added new key symbols for these keyboards 
+      (Stanislav Brabec).
+ 521. Fixed some problems with ininite loops which where introduced 
+      with the host bridge specific code (Egbert Eich).
+ 520. AXP domain support (Jeff Wiedemeier).
+ 519. Added -m32 flag to c++ when build on ia32 (Egbert Eich).
+ 518. -
+ 517. Added rule to be able to use Numlock key on broken IBM keyboards
+      (Stefan Dirsch).
+ 516. Fixed Xlib build rules so it builds a truly static library again 
+      (Egbert Eich).
+ 515. When compiled with GCC, force imake to generate Makefile's using GCC's
+      preprocessor rather than a system-provided one (Marc La France).
+ 514. Replace hard-coded "lib" directory names with LibDirName in X11.tmpl
+      (#5480, Mike Harris).
+ 513. Add some README files for XKB and it's configuration files (#5479, 5483,
+      Kamil Toman).
+ 512. Fixes for the "pc" cz and sk XKB maps:
+       - readded cz_qwerty (but new pc/ style) map
+       - added bskl variant missing in cz_qwerty and sk, sk_qwerty
+       - fixed keypad decimal key definition to affect only defined group
+         in cz, cz_qwerty
+       - missing SPCE definition readded to sk, sk_qwerty
+      (#5478, Kamil Toman).
+ 511. Union Reality UR-F98 headtracker input driver (Linux-only) (#5476, 5477,
+      Alan Cox).
+ 510. Palmax PD1100 touch screen driver (#5475, 5477, Alan Cox).
+ 509. Fujitsu Stylistic input driver (#5474, 5477, Rob Tsuk, John Apfelbaum,
+      Richard Miller-Smith, Alan Cox).
+ 508. Initialise ProgramName in xterm's main before referencing it (#5473,
+      Peter Valchev).
+ 507. Add an Ogham XKB keyboard map (#5472, Seamus O Ciardhuain).
+ 506. Handle Alt+Ctrl+Shift+SPECIAL differently from Alt+Ctrl+SPECIAL
+      where SPECIAL is one of the fallback built-in XFree86 hot keys
+      (#5468, J. Kean Johnston).
+ 505. Add Syriac XKB keyboard maps (#5467, Emil Soleyman-Zomalan).
+ 504. Rename HasKatmaiSupport to HasSSESupport (#5461-5463, 5465, Mike Harris).
+ 503. Add mouse wheel support for SCO OpenServer (#5460, J. Kean Johnston).
+ 502. Fix i18n problem in xmessage due to use of the useStringInPlace
+      resource (A.1381, Chisato Yamauchi).
+ 501. Fix xnest build on file systems that are not case sensitive
+      (Torrey T. Lyons).
+ 500. Use unique local Imake define for fonts.conf dir (#5482, Mike A. Harris)
+ 499. Fix xc/lib/Imakefile to not break HasFontconfig (#5481, Mike A. Harris)
+ 498. Refresh screen after wake from sleep in XDarwin full screen mode
+      (Torrey T. Lyons).
+ 497. Fixes and updates for the SCO OpenServer port (#5459, J. Kean Johnston).
+ 496. Add PCI ID defines for some ATI R300 chipsets (#5458,
+      Vladimir Dergachev).
+ 495. Fix error message typo in MakeRootTile() (#5451, Mike Harris).
+ 494. Redirect hostname's stderr in the xon script (#5450, Mike Harris).
+ 493. Add a request to the XFree86-Misc extension for querying the
+      X server's config file, module path, and log file name (#5456, Joe Moss).
+ 492. Add support for using the XKEYBOARD extension's action handlers
+      for the XFree86 X server hot keys.  This provides control over
+      the mapping of these hot keys (#A.1334, 5454, Joe Moss).
+ 491. Reinstate the X server -xkbdir option, but only when the X server's
+      real and effective uids are the same (based on #A.1132, Ivan Popov).
+ 490. Fix an xkbcomp bug that prevents a later definition from specifying
+      actions if the previous definition didn't (#5471, Joe Moss).
+ 489. Add a stub handler to xkbcomp for the DeviceValuator action (#A.1341,
+      Joe Moss).
+ 488. Fix broken software cursor with XDarwin's new event handling
+      (Torrey T.  Lyons).
+ 487. Change imake so that, when compiled with GCC, it invokes the pre-
+      processor through the gcc front-end, passing it imake's -v flag
+      (Marc La France).
+ 486. xf86cfg and xf86config patches, includind 1400x1050 mode, update list
+      of modules, auto inclusion of the xtt module when running X -configure
+      (A.1363, A.1364, A.1365, Chisato Yamauchi).
+ 485. Fix unbalanced paranthesis in linuxPci.c (#5466, Ishikawa Mutsumi).
+ 484. Remove "Option VideoRam" from savage driver, there's no need for it,
+      and utilize the entities given VideoRam size (Alan Hourihane).
+ 483. Fix fontconfig to obey NothingOutsideProjectRoot, so that the directory
+      /usr/share/fonts is ignored in this case (#A.1325, Joe Moss).
+ 482. Fix a segfault when using xkbcomp's -I option, and update the man
+      page to correctly document the way this option works (#5447, Joe Moss).
+ 481. Don't assume mmap returns the pointer hint requested.  This is in
+      the DENSE map code for Linux/alpha (#5439, Ray Strode).
+ 480. Build fix for r128_accel on PPC when DRI is disabled (based on
+      #5438, Mike Harris and #5449, Matthieu Herrb).
+ 479. Updates to bdf/misc UCS fonts (#5446, 5453, Markus Kuhn).
+ 478. Fix Thai glyphs in the 6x13 UCS font (#5427, Theppitak Karoonboonyanan).
+ 477. Add Thai glyphs to 7x13, 7x13B, 7x13O, 7x14, 7x14B UCS fonts
+      (#5445, Theppitak Karoonboonyanan).
+ 476. Add Thai subfont generation based on the ISO8859-11 map from unicode.org
+      (#5434, 5445, Theppitak Karoonboonyanan).
+ 475. Update the multilayout version of the Greek (el) xkb symbols (#5425,
+      Vasilis Vasaitis).
+ 474. On XDarwin startup, do not send events to the X server thread until it
+      is ready to receive them (Torrey T. Lyons).
+ 473. Add a utility (called gtf) for calculating VESA GTF mode lines
+      (Andy Ritger).
+ 472. Add an input driver for KB-Gear's Jamstudio pentablet (A.1328, 
+      Brian Goines).
+ 471. Add a Tektronix 4957 input driver (#A.1211, Olivier Danet).
+ 470. Fix backing store in Rage 128 and Radeon drivers (Kevin Martin).
+ 469. Fix Mono8x8 code in savage driver, needed ROP_NEEDS_SOURCE, also
+      add NO_PLANEMASK to ScreenToScreen as code doesn't handle that case
+      (Alan Hourihane).
+ 468. Add a little utility to read and write I/O ports, for those host
+      architectures that have them (Marc La France).
+ 467. Ignore (with messages) any HorizSync and VertRefresh specifications for
+      panels when using ATI LT, LTPro, XL and Mobility M1 (Marc La France).
+ 466. Fix a build failure when BuildServersOnly is defined and XnestServer
+      is not defined, and when /usr/X11R6 is not installed. (#A.1145,
+      Valeriy E. Ushakov).
+ 465. Fix panel support bug for ATI LTPro, XL and Mobility M1 chips
+      (Marc La France).
+ 464. Fix mode validation to deal with video memory sizes 256MB or greater
+      (Marc La France).
+ 463. Add ARGB cursors support to the vmware driver (#5442, Nolan Leake).
+ 462. Add more query options to glxinfo (#5441, Brian Paul).
+ 461. Fix a typo in glxinfo (#5440, D. Hageman).
+ 460. Fix a memory leak in Cygwin/XFree86 server (#5444, Kensuke Matsuzaki).
+ 459. Missing fallback to miPolyArc in fbarc.c (#A.1339, Ralf Klingebiel).
+ 458. Fix the cyrix driver support for the 5510, 5520 and 5530. This driver
+      only works with VSA1 based chips (#A.1260, Alan Cox).
+ 457. When building with gcc >= 2.8, generate Makefiles with `imake -Wundef`
+      (Marc La France).
+ 456. Re-instate changes clobbered by DRI merge (Marc La France).
+ 455. Fix a typo in shadowfb support from #5413 (#5430, Nolan Leake).
+ 454. Fix a bug in vmware's HW cursor support which conditionally hid the
+      cursor (#5430, Nolan Leake).
+ 453. Fix an initialization problem in the calcomp input driver (#A.1056,
+      Josef Walzer).
+ 452. Add command line and XF86Config options to control Render color
+      allocation on dynamic indexed visuals (Olivier Chapuis, Keith Packard)
+ 451. Keep track of whether the 830/845G HW cursor should be visible or
+      hidden so that it doesn't get turned on when it shouldn't (David Dawes).
+ 450. Fix for DGA offset inconsistency in the 830/845G driver (based on
+      a patch from Edgar Toernig).
+ 449. Fix a memory leak when calling _XCloseLC and removing the loadable
+      locales (#A.855 Mark Robinson).
+ 448. Fix input size of character strings used in lib/X11/lcGetConv.c (#A.828,
+      Yong-Jhen Hong).
+ 447. Add Shape extension support to Cygwin/XFree86 rootless mode (#5431,
+      Matsuzaki Kensuke).
+ 446. Fix a typo in the s3 driver which prevented virtual display sizes.
+      (#A.965, Stef Voltz).
+ 445. Fix a server crash that can happen when a DGA client frees its colormap
+      before setting the mode back to the original mode (David Dawes).
+ 444. Modify Type1 font RAM allocation heuristics to allow for larger fonts.
+      (#A.1121, Melchior Franz).
+ 443. Add new relocation entries for Alpha architecture to the loader which
+      are used when compiling with gcc >3.1 (#A.819, Thorsten Kranzkowski).
+ 442. Fix server crash when using Xinerama when application closes. 
+      (#A.808, Tsukahara Ken).
+ 441. Import Mesa-4.0.4, and resync with the DRI trunk (DRI Project).
+ 440. Server support for the alpha architecture on OpenBSD 3.2. 
+      (Matthieu Herrb, Arthur Grabowski). 
+ 439. Workaround for <linux/input.h> conflict (Marc La France).
+
+XFree86 4.2.99.2 (21 October 2002)
+ 438. Fix some memory leaks in libX11 i18n code (#A.1314, Olivier Chapuis).
+ 437. Add DGA and Xvideo support to the i740 driver (#A.1307, Kopecek Tomas).
+ 436. Fix the number of beeps when using AccessX and XKB 
+      (#A.1302, Alan Coopersmith).
+ 435. Add twelve hour format to xclock's digital format
+      (#A.1285, Brian L. Matthews).
+ 434. Fix application crash when using DPS client libraries 
+      (#A.1282, Frank Giessler).
+ 433. Fix pixmap cache corruption on VT switches in mga driver
+      (#A.1279, Ross Mikosh).
+ 432. Add missing Increment option in Summa input driver (#A.1276, G.P.Halkes).
+ 431. Missing semicolon in twm/gram.y (#A.1307, Jim Gifford).
+ 430. Cygwin/XFree86 updates
+      - Add X.ico, an icon for Windows (Harold Hunt, Jehan Bing)
+      - Include a preliminary pseudo-rootless mode (Matsuzaki Kensuke)
+      - XF86Config file support (Alexander Gottwald)
+      - Scrollbars support (Jehan Bing, Harold Hunt)
+      (#5424, Cygwin/XFree86 developers).
+ 429. Add ko_KR.UTF-8 and ja_JP.UTF-8 XLC_LOCALE files (#5421, Jungshik Shin).
+ 428. Add TCVN support to luit (#5416, Tomohiro KUBOTA).
+ 427. Expand luit to support several major non-ISO-2022-compliant
+      encodings such as GBK and Shift_JIS (#5416, Tomohiro KUBOTA).
+ 426. Add support for double-buffering to the tdfx driver's XVideo overlay
+      support (#5415, Stephen Davies).
+ 425. Add a -strftime option for xclock's digital mode (#5414, George Belotsky).
+ 424. README.fonts update (#5409, 5410, Khoda Hafez).
+ 423. Major update for VMware driver
+      - recoded to use XAA, offscreen memory support, and color expansion code
+      - Add RENDER support
+      - Optimization of HWcursor
+      - Bug fixes for HWcursor in 8bit mode and VT switching
+      (#5423, Nolan Leake, VMware).
+ 422. Updates for shadowfb code
+      - Add RENDER support
+      - support for pre-fb modifications
+      - support for real framebuffers rather than memory based framebuffer
+      - Removal of old fullscreen update code (when VT switching)
+      - fix bug in FillSpans
+      (#5411, #5413, Nolan Leake, VMware).
+ 421. Clear the list of registered renderers at the start of each new server
+      generation, and only print warnings about suffixes with more than
+      one registered renderer for the first generation (David Dawes).
+ 420. Make xf86PrintModes() show which modes are hot-key switchable
+      (David Dawes).
+ 419. Fix the vesa driver's misuse of virtualX for displayWidth (David Dawes).
+ 418. Fix the VBE module's depth/bpp matching, which fixes some 24/32 problems
+      as well as some 15/16 problems (David Dawes).
+ 417. Fix black cursor images on Mac OS X 10.2.2 (Joseph Maurer).
+ 416. Fix hotkey switching for user-specified modes, and fix hotkey switching
+      between all valid modes when no specific modes are specified in the
+      config file (David Dawes).
+ 415. Trival input drivers Imakefile cleanup (#5299, Mike Harris).
+ 414. Use INSTDATFLAGS when installing X server modules (#5292,
+      Branden Robinson).
+ 413. Fix the iso8859-15 Compose map -- there is no diaeresis codepoint
+      in iso8859-15 (#5389, Wolfgang Sourdeau, Rüdiger Kuhlman).
+ 412. Acute/apostrophe fix for nodeadkeys section of XKB German symbols
+      (#5388, Andreas Metzler).
+ 411. Fix Cards file typo (#5387, Branden Robinson).
+ 410. Cleanup the XKB Macinosh US keyboard symbols, and remove those that
+      should be in other country maps (#5386, Branden Robinson).
+ 409. Add a user-configurable throttle on xconsole's number of saved lines
+      (#5379, Branden Robinson).
+ 408. Fix missing declaration of XShmGetEventBase() in XShm.h (#5375,
+      Branden Robinson).
+ 407. Remove inconsistencies in the way extension headers are referred to
+      in most extension libraries (David Dawes).
+ 406. Install extension struct/protocol headers that weren't already
+      being installed (#5369, Branden Robinson).
+ 405. Fix long-standing colour map bug in ATI driver (Marc La France).
+ 404. Enable imake.c to perform correct C library version detection on hppa
+      machines (#5372, Ben Collins).
+ 403. Add new Imake rules to handle C++ programs that don't have man pages
+      (#5371, Branden Robinson).
+ 402. Add a -color app-defaults file for xmessage that exercises some
+      features of Xaw7, and fix the base app-defaults to not use the no
+      longer supported "whenNeeded" value for the "Scroll" resource (#5370,
+      Branden Robinson).
+ 401. Stop the drm module from creating a world-writable directory in /dev.
+      Since dev nodes can only be created by root, there's no need for
+      anyone else to be able to write to /dev/dri (#5367, Brendan O'Dea,
+      #5380, 5422, Mike Harris).
+ 400. Fix a SEGV in lbxproxy because it's ResizeReverseMap() makes assumptions
+      about the atom numbers that can lead to unallocated memory being
+      accessed (#5366, Branden Robinson and Anthony DeRobertis).
+ 399. Increase the wacom driver's timeout for reading data after a request.
+      This is needed for PalmWac (Wacom emulation for PalmOS) (#5364,
+      Mathieu Clabaut).
+ 398. Add Big5-HKSCS to locale.dir, and fix a missing portion in X-TT's
+      Big5HKSCS-Unicode table (#5362, Branden Robinson and ThizLinux
+      Laboratory Ltd).
+ 397. Handle vetoed APM suspend events properly on Linux (#5362,
+      Branden Robinson).
+ 396. Handle ARM and HP-PA separately from m68k and PowerPC in xfree86.cf,
+      and some cleanups (#5360, Branden Robinson).
+ 395. xfs updates and cleanups (#5359, Branden Robinson).
+ 394. Fix for random crashes when a screen fails to initialise (Marc La France).
+ 393. Update RandR to include refresh rates (v1.1) (Keith Packard)
+ 392. Numerous man pages fixes, add some missing manpages (#5365, #5373,
+      #5376, #5377, #5382-5385, #5390, #5391, #5393, #5295 Branden Robinson
+      #5374, Jonathan Amery, #5378, Jochen Voss)
+ 391. Install bdftruncate and ucs2any without the .pl extension
+      (#5391, Branden Robinson) 
+ 390. Rewrite Radeon DDC/DFP mode detection and management (Kevin Martin).
+ 389. Integrate ATI patch:
+      - Add 2D support for Radeon 9000 (RV250), Mobility M9 (RV250 mobile)
+        and Radeon 9700 (R300)
+      - Clone mode fixes and improvements
+      - Dell VE card fixes
+      - Dual-head VT switching fixes
+      - General code clean up
+      (#A.1217, Hui Yu@ATI).
+ 388. Rewrite XDarwin's event handling to fix some bugs and to use
+      SetInputCheck() for a performance boost (Torrey T. Lyons).
+ 387. Add a little utility to write files through mmap() (Marc La France).
+ 386. Add National Semiconductor Geode driver, support for the 5530, SC1200
+      and SC1400 chipsets (NSC, Alan Hourihane).
+ 385. linux.cf updates:
+       - Resync the DebianMaintainer #define and the stuff in the
+         corresponding if block to meet Debian's current needs.
+       - Sort long chains of architecture-dependent #if-#elif directives in
+         ASCII order.
+       - Add explicit recongition of several architectures to the #ifndef
+         BuildXF86DRI block.
+       - Define a fallback CplusplusCmd (g++) if we don't recongize the
+         platform we're on.
+       - Turn off the loadable server on MIPS and SuperH platforms, where it
+         doesn't (yet) work.
+       - Trash some unneeded #defines in the Mc68020Architecture compilation
+         environment.
+       - Remove the block that #defines HasXserver NO for the s390 and s390x
+         architectures (things like Xvfb build fine on these platforms).
+      (#5357, Branden Robinson).
+ 384. Fix an error in the Finnish XKB keyboard map (#5356, Marko Myllynen).
+ 383. Add a Malayalam XKB keyboard map (#5355, Baiju M).
+ 382. Add a "kbd" driver module that can eventually replace the built-in
+      "keyboard" driver (#5344, Ivan Pascal).
+ 381. Add os-support level support for a loadable keyboard driver for BSD
+      and Linux (#5344, Ivan Pascal).
+ 380. Add some new common layer functions for supporting a loadable keyboard
+      driver (#5344, Ivan Pascal).
+ 379. Move the XkbDisable option to a global server flag rather than
+      keyboard driver flag, since it really is a global setting (#5344,
+      Ivan Pascal).
+ 378. Fix RenderCreateCursor's conversion from an ARGB cursor to a 2-color
+      cursor when the cursor is wider than 8 pixels (#5353, Greg Parker).
+ 377. Fix 24bpp displays with the fbdev driver when not using shadowfb
+      (#5351, Michel Lanners).
+ 376. Fixes and improvements for the en_US.UTF8 compose rules (#5346,
+      Alexandre Oliva).
+ 375. Fix compose rules for some dead accents for iso8859-1 and iso8859-15
+      (#5338, 5339, Alexandre Oliva).
+ 374. Add support for th_TH.UTF-8. with XIM (#5336, Theppitak Karoonboonyanan).
+ 373. Fix some bugs in the Thai XIM:
+       - excessive '(' char when switching XKB keyboard group
+       - ineffective Ctrl-<key> and Alt-<key>
+      (#5335, Theppitak Karoonboonyanan).
+ 372. Add an X server command line flag (-br) to make the default root window
+      solid black (#5334, Jens Owen).
+ 371. Add support for th_TH.ISO-8859-11 (#5327, Theppitak Karoonboonyanan).
+ 370. Use pci_alloc_consistent/pci_free_consistent instead of the
+      local page alloc/free functions in the i810 and i830 DRM drivers
+      (#5323, Arjan van de Ven).
+ 369. Fix some non-POSIX usage of tail, expand and sort (#5322, Paul Eggert).
+ 368. Fix bug in PCI code for Solaris/SPARC (Marc La France).
+ 367. When enabling PCI adapters, also enable their bus mastering capability;
+      Consequently, deprecate xf86EnablePciBusMaster() (Marc La France).
+ 366. Fix lndir's handling of relative symbolic links, and update the man page
+      to document the -withrevinfo flag (H. J. Lu, Marc La France).
+ 365. Xdm patches: realloc usage, zero malloc()ated memory, enable 
+      /dev/urandom on NetBSD 1.4 and later, OpenBSD patches (#5345, 
+      Mike A. Harris, #5401, Matthias Scheler, Matthieu Herrb)
+ 364. Xterm patches #168, #169 (Thomas Dickey).
+ 363. In certain circumstances, allow VGA-rerouting through Simba bridges.
+      This only affects UltraSPARC-IIi systems.  This is a small but
+      necessary step in eradicating SparcArchitecture's need to compile the ati
+      dribver with -DAVOID_CPIO (Marc La France).
+ 362. In int10, ignore interrupts whose simulation isn't yet implemented.
+      Previously, such interrupts caused the emulation to stop.  (Egbert Eich,
+      Marc La France).
+ 361. Add full support for multi-head on 460GX-based Itanium systems
+      (Marc La France, with documentation loaned by Intel under NDA).
+ 360. Fix Darwin build problems with libXrandr and the new FreeType2 backend
+      (Torrey T. Lyons).
+ 359. Savage driver updates.
+      - Support for ProSavage DDR (PCI ID 0x8D04)
+      - TV output fixes
+      - support for -pixmap24 flag
+      - XAA fixes to cure lockups
+      (#5412, Tim Roberts).
+ 358. Enable version controlled .dll's on Cygwin/XFree86 (Alexander Gottwald).
+ 357. Some build fixes for Cygwin/XFree86 (Alan Hourihane).
+ 356. Add new FreeType2 backend which fixes a bug with -c- fonts
+      (#5347, #5348, Juliusz Chroboczek).
+ 355. Add new command line options to glxinfo for more detailed output
+      (#5354, Brian Paul).
+ 354. Support for 24bpp, fix screen blanking and bug fixes for newport driver
+      (#5329, #5349, Guido Guenther).
+ 353. Add RandR support to XFree86 DDX. (Keith Packard)
+ 352. Update RandR extension to 1.0.  Eliminate depth switching 
+      (Keith Packard, Jim Gettys)
+ 351. Fix XDarwin rootless crash when window resizing with complex bit
+      gravity (Greg Parker).
+ 350. Fix some incorrect mappings in the gbk-0.enc encodings file (#5313,
+      Tomohiro KUBOTA).
+ 349. Fix C precedence bug in mfb (#5309, Tassia St. Germain).
+ 348. Updates to mkfontscale (#5307, Juliusz Chroboczek).
+ 347. Add SharedXcursorReqs to Cygwin build (#5405, Harold Hunt).
+ 346. Add image transformation and subpixel order to Render (Keith Packard)
+ 345. Add Xcursor-def.cpp to Xcursor library (#5350, Alexander Gottwald).
+ 344. Update to pci.ids to 2002-09-24 snapshot (Marc La France).
+ 343. Add a little utility to read files through mmap() (Marc La France).
+ 342. Implement a means to ignore certain host bridges while determining PCI
+      bus topology (not yet used) (Marc La France).
+ 341. Bridge driver interface fixups for host bridges (Marc La France).
+ 340. Change makedepend to recognise invocations of parameter'ed macros
+      (Marc La France).
+ 339. Major redesign in the Xedit syntax highlight code. Now there isn't
+      anymore the builtin C mode, but a new version using the xedit lisp
+      interpreter, as well as several new modes, including Lisp/Scheme,
+      Imakefile, X Resource files, Makefile, Manpage source, Sgml and
+      Html (Paulo César Pereira de Andrade).
+ 338. Print a warning if more than one renderer is registered for a font type
+      (#5305, Juliusz Chroboczek).
+ 337. Fix a double free() that can cause a crash in XCloseIM() (based one
+      #5303, Mo DeJong).
+ 336. Allow xman's MANCONF definition to be specified in the Imakefile
+      (based on #5302, Mike Harris).
+ 335. Config typo and update for Linux on Hitachi SuperH architecture (#5301,
+      ISHIKAWA Mutsumi).
+ 334. Add a "DefaultRefresh" option to the vesa driver (David Dawes).
+ 333. Fix build problem when calling GNU make with "--" prefixed options
+      (#5291, Toomas (toomas at tklabor.ee)).
+ 332. Avoid noise from hostname call in startx (#5270, Mike Harris).
+ 331. xwd ignores the -frame option if the -id option is used (#5251,
+      Mike Harris).
+ 330. Fix problem where DRIUnlock was called when DRI fails to load
+      (Kevin Martin)
+ 329. Fix erroneous warnings about removing DRM signal handler when DRI
+      fails to load (Kevin Martin)
+ 328. Add LINE_LIMIT_COORDS option to XAA to work around limited coordinate
+      space for lines on Radeons (Kevin Martin)
+ 327. Fix Radeon DGA code to use XAA sync function (Michel Dänzer)
+ 326. Major rework of Radeon accel code:
+      - Merge CP and MMIO code (Kevin Martin and Michel Dänzer)
+      - Fix indirect buffer CP code (Kevin Martin and Michel Dänzer)
+      - Add CP support for scanline color expansion and image writes
+        (Michel Dänzer)
+      - Fix Mono8x8 problems (Kevin Martin and Michel Dänzer)
+      - Fix clipping routine to properly set transparency and
+        dp_gui_master_cntl reg (Kevin Martin and Michel Dänzer)
+      - Fix clipping calculation errors (Kevin Martin)
+      - Properly set line bias so that sw rendered solid and dashed lines
+        match the accel TwoPoint lines (Kevin Martin)
+      - Fix drawing last point for solid and dashed lines (Kevin Martin)
+      - Remove NoLineAccel option since two point lines work (Kevin Martin)
+ 325. Export some more Xft symbols (Cygwin) that are needed for qt 3.x
+      (#5285, Ralf Habacker).
+ 324. Don't sleep on Cygwin for ICE directory mode problems (#5284,
+      Ralf Habacker).
+ 323. Fix a bug in XtGetDisplays() with more than 1 open display (#5282,
+      Kip Rugger).
+ 322. Second part of xkb multi-layout keyboard map support (#5321,
+      Ivan Pascal).
+ 321. Allow the Record extension to report logical coordinated with Xinerama
+      (#5231, Paul Stewart).
+ 320. Allow the XTrap extension to report logical coordinated with Xinerama
+      (#5230, Paul Stewart).
+ 319. Moved LdPreLib define after the vendor/OS specific config files
+      as it may depend on setting done there (Egbert Eich).
+ 318. Several fixes for cross compile environment (Egbert Eich).
+ 317. Added code to allow for building of static only libraries with
+      -fPIC for platforms which require it (Egbert Eich).
+ 316. Added '-m32' to gcc flags as default for ia32 builds when gcc version
+      is >= 3.1. This allows building a 32 bit Version of X on 64bit x86-64
+      (Egbert Eich).
+ 315. Changed direct calls of ld to 'gcc -nostdlib' for Linux (Egbert Eich). 
+ 314. Changed calls to as to 'gcc -c -x assembler-with-cpp' for Linux
+      (Egbert Eich).
+ 313. Added '-fno-strict-aliasing' flag to gcc version >= 3.1 (Egbert Eich).
+      Strict requires that one address must not contain pointers to
+      different types - a feature heavily used by X (Egbert Eich).
+ 312. Fixed a core dump problem in libXtt (?) (Egbert Eich).
+ 311. Removed '#pragma pack' from structures that contain function pointers
+      in x86emu. This causes problems on gcc 3.1 for ia64 (Egbert Eich).
+ 310. Added defines for missing X types to saverproto.h (Egbert Eich).
+ 309. Fixed compiler warings generated by gcc >= 3.1 in mesa drivers 
+      (Egbert Eich).
+ 308. For platforms that allow both 32 and 64 bit libraries to be executed
+      split Xlib i18n modules path into 
+      <libpath>/X11R6/lib/X11/locale/lib/common and
+      <libpath>/X11R6/lib/X11/locale/lib64/common. 'lib64' has been defined
+      to be the default path for 64bit shared libraries on these platforms
+      (Egbert Eich).
+ 307. Fixed obvious typo in OMlib (Egbert Eich).
+ 306. Fixed code in cfb that didn't comply with C sequence rules.
+      Modern C compilers tend to be more aggressive on code reordering 
+      (Egbert Eich).
+ 305. Changed arguments of NoopDDA() from VarArgs to void. Handling
+      of VarArgs by gcc isn't compatible with the way it was used
+      on certain platforms (Egbert Eich).
+ 304. Added support for 32bit pixmaps for 24bit overlay framebuffers in 
+      fb overlay code (Egbert Eich).
+ 303. Fixed kdrive to print a meaningful error message instead of just
+      core dump when no matching graphics cards is found (Egbert Eich).
+ 302. fixed portability bug in xwd (Andreas Schwab <schwab@suse.de>)
+ 301. fixed X Server crash, which happended each time a proportional iso10646
+      font was loaded with xtt backend (Yong Li <rigel863@yahoo.com>)
+ 300. Added some ARM specific fixes to compiler.h (Uli Hecht).
+ 299. Added a virtual 'dummy' driver (Egbert Eich).
+ 298. Fixed core dump when certain access functions are not set in
+      xf86Bus.c (Egbert Eich).
+ 297. Fixed problem where SIGIO could be disabled after a server reset.
+ 296. Added configurable list of devices the xf86Misc extension is allowed
+      to change the mouse device to (Egbert Eich).
+ 295. Changed default mouse type to 'auto' when generating config file
+      with '-configure' (Egbert Eich).
+ 294. Made sure keyboard modifier settings are consistent after exit 
+      from DGA when the xkb extension is used (Egbert Eich).
+ 293. Disabled keyboard processing when Xserver is suspended by power 
+      management.
+      This allows effective locking of laptops when stolen (Egbert Eich).
+ 292. Added/improved options for lockfile syncing (Egbert Eich).
+ 291.  Added support for backup copy of Xserver logfile (Egbert Eich).
+ 290. Fixed GetTimeInMillis() to use deltas instead of absolute time
+      returend by gettimeofday(). This ensures time is monotonic in X
+      (Egbert Eich).
+ 289. Fixed xf86Misc extension to allow modification of Expps2 mice 
+      (Egbert Eich).
+ 288. Made code in xf86MiscExt.c more readable (Egbert Eich).
+ 287. Fixed PCI CardBus bridge handling (Egbert Eich).
+ 286. Added code to reenable PCI bus mastering after coming back from a 
+      VT switch to radeon driver (Charl P. Botha <http://cpbotha.net/>) 
+      (Egbert Eich).
+ 285. Dito for r128 driver (M. Harris).
+ 284. Dito for glint and mga driver (Egbert Eich).
+ 283. Fixed double scan issues for low res modes in C&T driver (Egbert Eich).
+ 282. Set rgbBits to 8 for all HiQV chips in chips driver (Egbert Eich).
+ 281. Moved initialization of accel funtions past initialization of
+      offscreen fb manager in chips driver (Egbert Eich).
+ 280. Fixed initialization of video in chips driver (?).
+ 279. Fixed HALlib problem restoring text mode on G550 (Egbert Eich).
+ 278. Restructured and included Matrox's Merged Framebuffer changes
+      to mga driver (Egbert Eich).
+ 277. G450/550 clockchip programming fixes (Matrox).
+ 276. Fixed HW Cursor for HALlib frame granularity (Egbert Eich).
+ 275. Enabling 2D accel in 24-bit for neomagic 2360 and 2380 (Egbert Eich).
+ 274. Added support for builtin 1024x480 mode of Sony subnotebooks for
+      Neomagic driver (Egbert Eich).
+ 273. Fixed support for lowRes (320x240) modes in neomagic driver 
+      (Egbert Eich).
+ 272. Fixed RAC function registration in S3 driver (Egbert Eich).
+ 271. Added some voodoo to screen initialization of S3 driver (Egbert Eich).
+ 270. Fixed vbe/int10 support in SMI driver. It used to core dump
+      when BIOS was not usable (Egbert Eich).
+ 269. Separated BRIGHTNESS and and CAPTURE_BRIGNTESS video attributes
+      in smi driver: CAPTURE_BRIGHTNESS refers to the capture chip 
+      (ie. Philips SAA7110) while BRIGHTNESS controls the video overlay
+      of the SMI chip itself (Egbert Eich).
+ 268. Disable automatic loading of DRI when running SUN ffb as this is
+      inconsistent with other drivers (Thorsten Kukuk).
+ 267. Fixed Gamma/Brightness code in trident driver (Egbert Eich).
+ 266. Added FpDelay debugging option (Egbert Eich).
+ 260. Fixed video support for Trident 9397 (Egbert Eich).
+ 265. Fixed Cursor/VT switch support for vmware driver (Egbert Eich).
+ 264. Fixed Blit problems in vmware driver when running KDE (Egbert Eich).
+ 263. Added RENDER support to vmware driver (Egbert Eich).
+ 262. Added C&T 69030 to extrapci.ids (Egbert Eich).
+ 261. Improved mouse autodetection code (Egbert Eich).
+ 260. Restructured int10 code so that vm86 and x86emu support can be loaded
+      as modules. Implemented heuristic to try vm86 first and fall back to
+      x86emu. This allows 32 bit Xservers to run on x86_64 on 64-bit kernel
+      without vm86 support (Egbert Eich).
+ 259. Restructured elf loader: determine which section to load from elfheader
+      flags (Egbert Eich).
+ 258. Adding RENDER Support to RAC (Egbert Eich).
+ 257. Using borderClip instead of borderSize region for redisplay function
+      in miext/shadow code to avoid core dumps when vt switched away 
+      (Egbert Eich).
+ 256. Replacing sprintf() by snprintf() in lbxproxy to eliminate possible
+      buffer overrun exploits (Egbert Eich).
+ 255. KP_Decimal fixes to Czech and Slovak keybards 
+      (Jan Holesovsky <kendy@suse.cz>) (Egbert Eich).
+ 254. Treat PCI-to-MCA and PCI-to_EISA bridges as PCI-to-ISA (Marc La France).
+ 253. Correct the server's understanding of CardBus resource ranges
+      (Marc La France).
+ 252. Ignore unconfigured (and mis-configured) PCI-to-PCI and PCI-to-CardBus
+      bridges (Marc La France).
+ 251. Prevent infinite loops during VGA re-routing (Marc La France).
+ 250. Add a framework for bus bridge drivers and use it to rework the handling
+      of Sun's Simba P2P bridges (Marc La France).
+ 249. Fix bdftopcf memory leak (Marc La France).
+ 248. XVideo support for the i830 and i845G (David Dawes, Alan Hourihane).
+ 247. Fix various bugs in the DRI support for the i830 and i845G
+      (Keith Whitwell).
+ 246. Major rework of the 2D i830/i845G support, including:
+       - Improve VESA mode selection, and fix refresh rate selection.
+       - Don't duplicate functions provided in the vbe modules.
+       - Don't duplicate functions provided in the vgahw module.
+       - Rewrite memory allocation.
+       - Rewrite initialisation and save/restore state handling.
+       - Decouple the i810 support from i830 and later.
+       - Remove various unnecessary hacks and workarounds.
+       - Fix an 845G problem with the ring buffer not in pre-allocated
+         memory.
+       - Fix screen blanking.
+       - Fix some HW cursor glitches, and turn HW cursor off at VT switch
+         and exit.
+       - Don't attempt to use the i830's function 1 entity.
+       - Fix problems with option handling.
+      (David Dawes).
+ 245. A "hammer" approach at ensuring font properties are freed properly
+      (Marc La France).
+ 244. Fix 'su' usage for FreeBSD in the default xdm config (Eric Anholt).
+ 243. Fix a FreeBSD scrollwheel problem that shows up with gcc 3.1
+      (Eric Anholt).
+ 242. Make C++ libraries on FreeBSD get linked with $(CXX), fixing libGLU
+      (Eric Anholt).
+ 241. FreeBSD.cf updates, including enabling SSE/3DNow support (Eric Anholt).
+ 240. Intel 830 and 845G DRI support, including i830 support updated for
+      Mesa 4.x (#5288, Jeff Hartmann, 2D3D).
+ 239. [SECURITY] Fix an Xlib problem that made it possible to load arbitrary
+      code into privileged clients.
+ 238. Add Xcursor library.  Make Xlib use it. (Keith Packard)
+ 237. Fix threaded libraries on Mac OS X 10.2 (A.1229, Marko Karppinen).
+ 236. Add hardware accelerated GLX to XDarwin (Greg Parker).
+ 235. Use Imake custom version variables in XDarwin startup message
+      (Torrey T. Lyons).
+ 234. Attempt to prevent PCI scans on non-PCI ix86 systems (Marc La France).
+ 233. Allow master aborts on CardBus buses to complete normally during PCI
+      scans (Marc La France).
+ 232. Fix bug that prevented the server from restoring CardBus data properly
+      (Marc La France).
+ 231. Fix DEVID define and make it more generally available (Marc La France).
+ 230. Fix bug in NetBSD PCI code (Marc La France).
+ 229. Add an option to completely disable PCI scans (Marc La France).
+ 228. Xterm patch #167 (Thomas Dickey).
+ 227. Add CreateCursor request to Render extension (Keith Packard)
+ 226. Change scanpci to not disable I/O too early (Marc La France).
+ 225. Better error handling in xfs -ls argument parsing (Mordy Ovits).
+ 224. Make loader ignore ELF objects that don't define any symbols (H. J. Lu)
+ 223. Add a HasGcc3 imake symbol (Marc La France).
+ 222. Enable threaded libraries on Darwin (Jeff Whitaker and Torrey T. Lyons).
+ 221. Xaw documentation fixes (A.1218, Paul Vojta).
+ 220. Add some mode collection/handling interfaces to the vbe module,
+      which makes it easier for drivers to set modes via the video BIOS
+      (David Dawes).
+ 219. I830/845 Workaround for BIOSes which force 1MB stolen memory, and
+      agpgart related fix (#5300, Abraham vd Merwe).
+ 218. Add NetBSD specific PCI access functions for powerpc and alpha 
+      platforms (Charles Hannum). 
+ 217. Split bsd_video.c into architecture specific files, and merge NetBSD
+      alpha and powerpc support there. (Matthieu Herrb, Simon Burge, 
+      Charles Hannum & other NetBSD developers). 
+ 216. Define CSRG_BASED for Darwin and fix xman so it works on Darwin
+      (Torrey T. Lyons).
+ 215. On Darwin, fix imake to find Gcc and correct config for RawCppCmd
+      (Torrey T. Lyons).
+ 214. Add functions to allow modules to query the core X server version
+      and the version of its sub modules (David Dawes).
+ 213. Fix scanpci's printing of 64-bit PCI bases (Marc La France).
+ 212. Add missing dependency and regenerate xf86PciStdIds.h accordingly
+      (Marc La France).
+ 211. A more flexible way of dealing with ix86 motherboard chipsets that can
+      only implement less than the full 256 PCI buses (Marc La France).
+ 210. RAC-related fixups to ATI drivers and xf86SetOperatingState() call
+      cleanups in most drivers (Marc La France).
+ 209. Fix int10 miscompilation glitch on IA-64 (Marc La France).
+ 208. Add support for Permedia3 (rev C) chips that use slightly different
+      clock programming techniques (Jay Estabrook).
+ 207. Fix Finder warnings about XDarwin plist format on Jaguar
+      (Torrey T. Lyons).
+ 206. Fix XDarwin build issues on Jaguar (Sean Fagan).
+ 205. Fix Radeon DDC for non-Dell cards, and fix a radeon pci id-related
+      build problem (#5326, Andrew C Aitchison).
+ 204. Change the X server (and scanpci) to use the pci.ids file (from
+      pciids.sf.net) for vendor/device descriptions (David Dawes).
+ 203. Change XDarwin to use NSQuickDrawView instead of Carbon windows to
+      get a QuickDraw graphics port for rootless windows (Torrey T. Lyons).
+ 202. Add support for some missing 32-bit address modes to x86emu.  Some
+      video BIOSes use them, especially those for some of the integrated
+      Intel chipsets, and this fixes int10/vbe support for these on
+      platforms that use the emulator (David Dawes).
+ 201. Add PCI ID for ATI Radeon Mobility M7 'LX' (#5233, Mike Harris).
+ 200. Fix CrossCompile environment for Cygwin/XFree86 
+      (#5324, Alexander Gottwald, Harold Hunt).
+ 199. ATI patch to:
+      - Fix Dell OEM VE card support
+      - Add better clone mode support
+      - Fix large panel (>= 1600x1200) detection and initialization problems
+      - Remove "PanelSize" and "CrtScreen" options since they are no longer
+        needed with new CloneMode and improved flat panel support
+      - Add "DDCMode" option to detect and use DDC modes
+      - Add "PanelOff" option to disable panel on laptops
+      - Fix corrupted console problem
+      - Other misc fixes
+      (#A.1043, Hui Yu@ATI).
+ 198. Remove -DNO_TCP_H from cygwin.cf for Cygwin/XFree86 (#5320, Harold Hunt).
+ 197. Major updates to Cygwin/XFree86.
+       - fix depth 24 issues.
+       - fix the handling of the DirectDraw module.
+       - disable the use of the LAYER/RANDR extension.
+       - lots of bug fixes. 
+      (#5318, #5317, Harold L. Hunt, Alan Hourihane).
+ 196. When using the vesa driver and the DisplaySize option the server
+      would crash with a floating point exception due to a divide by zero
+      in miscreeninit() (#5298, Mike A. Harris).
+ 195. The function MoveLine in lib/Xaw/TextAction.c sometimes attempts to
+      read uninitialized memory when hit ctrl-N in a Text widget to move to
+      the next line (#5245, Johnathan Kamens).
+ 194. Adjust -probe for change in default stderr verbosity (Marc La France).
+ 193. Radeon patch for Xv on all known Radeon devices (James Ralston and
+      Keith Packard).
+ 192. New XDarwin application icon (Michael Oland).
+ 191. Dead strip unneeded code in rootlessValTree.c and other miscellaneous
+      XDarwin code cleanup (Greg Parker and Torrey T. Lyons).
+ 190. Lots of Cygwin/XFree86 cleanups and fixes (#5304, Harold Hunt)
+ 189. Fix rootless XDarwin crash when resizing a window with negative x
+      coordinate (Torrey T. Lyons).
+
+XFree86 4.2.99.1 (7 June 2002)
+ 188. Fix some build problems when building with shared libraries disabled
+      (David Dawes).
+ 187. Update the magellan input driver and turn it on in the build process
+      (#A.1024, Christoph Koulen).
+ 186. Add Peritek Borealis support to the I128 driver (Robin Cutshaw).
+ 185. Modify the r128 and radeon drivers to use fbdev's DPMS support when
+      fbdev is enabled (#5219, Michel Dänzer).
+ 184. Add support for the composite sync mode flag to the radeon driver
+      (#5219, Michel Dänzer).
+ 183. Add a mkfontscale utility for creating fonts.scale files (#5213, 5214,
+      Juliusz Chroboczek).
+ 182. Add a 1152x768 mode suitable for Titanium PowerBooks to the set of
+      build-in modes (#5212, Michel Dänzer).
+ 181. Add support to xkbcomp and libxkbfile for composing multi-layout
+      keyboard maps from partial "single layout" files.  This allows
+      the XkbLayout to be specified as a comma-separated list of single
+      layout names.  Note: new "single layout" symbol maps aren't available
+      yet. (#5210, Ivan Pascal).
+ 180. Fix Xv endianess problem with the Radeon driver (#5207, Guido Guenther).
+ 179. Updates to the Finnish xkb map, including:
+       - add ISO-8859-15 missing symbols ([zZsS]caron)
+       - reorganize some special symbols (such as paragraph, cent, division)
+       - map AltGr+SPCE as space, nobreakspace comes way too often by accident
+       - minor white space/comment cleanups
+      (#5197, Marko Myllynen).
+ 178. Add an option to the r128 driver for enabling DMA for Xv image transfers
+      (#5195, Michel Dänzer).
+ 177. Make the 'distclean' target remove depend files (#5194,
+      Carlos A M dos Santos).
+ 176. Fix bad usage of "UseInstalled" in FreeBSD.cf (#5192,
+      Carlos A M dos Santos).
+ 175. Several xkb layout updates:
+       - Added other Armenian layouts.
+       - Added Swedish dvorak layout.
+       - Fixed typo in "la" file.
+       - Added EuroSign in Dutch keyboard.
+       - Added a "comma" variant for "ro" keyboard allowing to type real comma
+         below Romanian letters.
+       - New file "ro2" with the real Romanian layout (the file "ro" is not a
+         Romanian keyboard, but a modified US one that has been hacked to
+         include Romanian letters).
+      (#5191, Pablo Saratxaga).
+ 174. Fix makedepend so that it can parse a unary '+' operator (#5185,
+      Mark Snitily).
+ 173. Fix a typo in Xvesa's emulation of instructions forbidden in vm86
+      mode (#5184, Juliusz Chroboczek)
+ 172. Fix a bounds check in Xlib's Region code (#5183, Owen Taylor).
+ 171. Fix LIBXML2LIBDIR name clash in lib/Imakefile (#5180, ISHIKAWA Mutsumi).
+ 170. Avoid a problem with setfontdirs when run in some locales (#5179,
+      ISHIKAWA Mutsumi).
+ 169. A little tuning for XtAppPeekEvent() (#5178, Dan McNichol).
+ 168. Add a command line option to luit to specify the encoding (#5177, 5181,
+      Tomohiro Kubota).
+ 167. A fix for luit's command line argument handling (#5173, Tomohiro Kubota).
+ 166. Add support to luit for some more 8-bit encodings (#5171,
+      Juliusz Chroboczek).
+ 165. Add an option to luit to enable using GL codes instead of GR codes
+      after a single shift for keyboard input (#5170-5172, Tomohiro Kubota
+      and Juliusz Chroboczek).
+ 164. Fix an fbdev driver crash when the VT isn't active (#5169,
+      Michel Dänzer).
+ 163. Fix a bug that resulted in XwcTextPropertyToTextList() storing an
+      incomplete list (#5168, Tassia St. Germain, for X.Org).
+ 162. Add "ISO8859-16" to the registry (#5167, Tassia St. Germain, for X.Org).
+ 161. A revised Greek xkb layout, including a three-level "extended"
+      variant, and a "polytonic" variant (#5165, Vasilis Vasaitis).
+ 160. Add support for an el_GR.UTF-8 locale, including a compose file with
+      support for polytonic Greek text (#5165, Vasilis Vasaitis).
+ 159. Add missing zh_CN XI18N_OBJS file (#5164, Yong Li).
+ 158. Make xfs chdir to "/" before fork()ing (#5162, Mike Harris).
+ 157. Add some reference counting for Xlib's i18n modules, preventing
+      a module getting unloaded while it's still in use (#5160, Owen Taylor).
+ 156. Update for SCO OpenServer support (#5158, Kean Johnston).
+ 155. Add aliases for the Brazilian Portuguese locale as defined on FreeBSD
+      (#5157, Carlos A M dos Santos).
+ 154. Recognise the en_UK.ISO8859-15 and en_US.ISO8859-15 locales (#5156, 5186,
+      Matthias Scheler).
+ 153. Some cleanups for the UTF-8 Compose file, including:
+       - Better support for Greek
+       - Typo fixes, including incorrect character literals and keysyms.
+      (#5154, Vasilis Vasaitis).
+ 152. Modify Xt's default fallback font pattern to work better in locales
+      where the current one fails to find a useful font (#5152,
+      Tomohiro KUBOTA).
+ 151. Updates to bdf/misc UCS fonts, and generate ISO8859-16 subsets
+      (#5147, Markus Kuhn).
+ 150. Fix some empty delay loops and jiffie wrap bugs in the i830 drm driver
+      (#5149, Arjan Van de Ven).
+ 149. Fix a potential NULL dereference in the drm kernel module (#5148,
+      Andreas Schwab).
+ 148. Major OS/2 support update (#5119, Holger Veit).
+ 147. Fix mode setting in DGA on the Rage128 & Radeon drivers (Alan Hourihane).
+ 146. Build libXt as a flat namespace image on Darwin (Torrey T. Lyons).
+ 145. Install the bitmap file xc/programs/bitmap/Stipple as Stippler on file
+      systems that are not case sensitive (Torrey T. Lyons).
+ 144. Fix enabling of MMIO window on BladeXP desktop chips (Alan Hourihane).
+ 143. Due to bugs in the CyberBladei7/i1 series that cause offset problems,
+      we're disabling the hardware cursor (for now) (Alan Hourihane).
+ 142. Fix Xft-def.cpp file for Cygwin/XFree86 (#5283, Harold Hunt).
+ 141. Server support for OpenBSD/sparc64 (Jason Wright, Matthieu Herrb).
+ 140. Alignment fixes for Xvideo on the Permedia3 (Alan Hourihane).
+ 139. lndir fix for paths containing '//' (H. J. Lu).
+ 138. Fix blank display problem in trident driver for older TGUI series
+      chips, and a few Xv cleanups too (Alan Hourihane).
+ 137. Enable MIT-SHM extension in Xnest server (#A.795, Steve Schwarz).
+ 136. Fix typo in Rage128 DGA driver (#5187. Charles M. Hannum).
+ 135. Fix enabling of DRI when XvMC is disabled (#5208, Matthew Sottek, Intel).
+ 134. Fix HW Cursor handling in vmware driver (#5193, Jeremy, VMWare).
+ 133. YUV handling updates for v4l module. Can now handle multiple formats
+      and find common format for both videocard and kernel.(#5196, Gerd Knorr).
+ 132. Savage driver updates (#5203, Tim Roberts).
+ 131. Drop the indirect buffer after ScreenInit, fixes corruption and
+      kernel error messages. (#5199, Michel Dänzer).
+ 130. Add Polygon support to Render extension (Carl Worth, Keith Packard)
+ 129. Add Intel i845G 2D support to the i8x0 driver, DRI is disabled. 
+      (#A.1062, Graeme Fisher, 2D3D).
+ 128. Fix RGB/BGR inversion problem and screen blanking in the glint
+      driver (Alan Hourihane).
+ 127. Add MIT-SCREEN-SAVER extension docs (Alan Coopersmith).
+ 126. Fix problems opening /dev/fb0 in fbdevhw layer (#5229, Michel Dänzer).
+ 125. Update the apm driver (#5227, Loic Grenie).
+ 124. Update the Japanese localization of XDarwin (Toshimitsu Tanaka).
+ 123. Symbol table cleanup, leaving xf86GetPointerScreenFuncs() as the only
+      common/xf86Cursor.c entry available to modules (Marc La France).
+ 122. Fix VidMode-generated mode switches by making them go through (almost)
+      the same code path as keyboard-generated mode switches (Marc La France).
+ 121. Allow AGP apertures to overlap with other BIOS-assigned PCI resources
+      (Marc La France).
+ 120. Indent'd most of xterm's C code (Thomas Dickey).
+ 119. Major Radeon driver code cleanup (Kevin Martin).
+ 118. Radeon Xv fixes and video key support added (Keith Packard).
+ 117. DPMS support for DFP/LCD and second head added for Radeon (Hui Yu@ATI).
+ 116. Option to disable line acceleration added since Radeon only has 14 bits
+      for lines and clipping.  This will be changed to an XAA option for 14
+      bit support in the future (Hui Yu@ATI, Kevin Martin).
+ 115. Radeon DDC and DFP handling improvements (Hui Yu@ATI).
+ 114. Fixes for DRI lockup problems with Radeon 7500/VE and the AMD 761
+      chipset (Hui Yu@ATI).
+ 113. Radeon PLL routines rewritten with ATOMIC_UPDATE enabled (Hui Yu@ATI).
+ 112. Clone mode added to Radeon driver (not yet functional and disabled
+      by default) (Hui Yu@ATI, Kevin Martin).
+ 111. Fix usage of BuildBinTop in Cygwin/XFree86 (#5223, Harold Hunt).
+ 110. Implement WarpCursor for Cygwin/XFree86, and use GetProcAddress
+      instead of relying on ddraw.dll (#5220-#5222, Harold Hunt).
+ 109. Fix bug that prevented the vesa driver from accessing VGA CRTC registers
+      (Marc La France).
+ 108. New pre-processor files for expat, fontconfig and rename of
+      OSmesa-def.cpp to OSMesa-def.cpp (#5215-#5218, Alexander Gottwald).
+ 107. Rework ati, atimisc, r128 and radeon module versioning (Marc La France).
+ 106. Code clean up for the original Rage LT (Marc La France).
+ 105. An attempt at disabling display switches while the server is running on
+      an LT Pro or Mobility M1 (Marc La France).
+ 104. Make atimisc, r128 and radeon modules register the symbols they reference
+      at module load time, rather than PreInit() (Marc La France).
+ 103. Fix rounding error in Mach64 DSP calculation (Marc La France).
+ 102. Convert xmh to ANSI C (Thomas Dickey).
+ 101. Xterm patch #166 (Thomas Dickey).
+ 100. Fix keyboard beeps on Cygwin/XFree86 (#5211, Harold Hunt).
+  99. Fixed i810 crash on vt switch due to call to Sync() while switched away
+      (Andris Pavenis).
+  98. Fixed MGAG550 HW Cursor (Laure-Amelie Couturie).
+  97. Added Xv support to neomagic driver (Shigehiro Nomura).
+  96. Implemented cross compile environment (Egbert Eich).
+  95. Added AMD x86-64 architecture support (Egbert Eich).
+  94. Fixed memory leaks in xkb code (Egbert Eich).
+  93. Fixed several memory leaks in the config file parser and initialization
+      routines (Egbert Eich).
+  92. Added CardBus bridge support (Egbert Eich).
+  91. Fixed strdup() define in glx (Egbert Eich).
+  90. Extended xf86misc extension to support changing the mouse device
+      (Egbert Eich).
+  89. Replaced strdup() in xf86Configure.c with xalloc()/strcpy() to avoid
+      conflicts when using internal malloc (Egbert Eich).
+  88. Extended memory debugging: Added signal handler to trigger a memory
+      debugger dump on SIGUSR2 when compiled with memleak support
+      (Egbert Eich).
+  87. Set vtSema to FALSE when suspended by APM to catch calls to 2D accel
+      functions (Egbert Eich).
+  86. Implemented mouse protocol detection by analyzing data stream
+      (Egbert Eich).
+  85. Added PnP mouse detection for PS/2, ImPS/2 and older MS serial mice
+      (Egbert Eich).
+  84. Fixed gamma correction code for Trident 9397 (Alan Hourihane).
+  83. Fixed C&T driver to avoid initialization of video in non-linear mode
+      (Egbert Eich).
+  82. Changed C&T driver to allow video even if acceleration is disabled
+      (Egbert Eich).
+  81. Attempt to implement a more consistent handling of HW cursor in C&T
+      driver (Egbert Eich).
+  80. Fixed MGA driver to make HALlib work with VESA framebuffer modes
+      (Egbert Eich).
+  79. Reworked Rendition driver (Egbert Eich).
+  78. S3 Virge driver: added minimal gap between SyncStart and HDisplay to
+      avoid video lockups (Egbert Eich).
+  77. Fixed memory leaks in S3 Savage driver (Egbert Eich).
+  76. Modified several drivers to do int10 initialization using the
+      VBE functions instead of calling int10 directly (Egbert Eich).
+  75. Fixed video support and mode initialization in Silicon Motion driver,
+      removed wait for v-retrace (Egbert Eich).
+  74. Misc fixes to SiS driver (Thomas Winischhofer).
+  73. Added support for 1400x1050 screen in Trident driver (Egbert Eich).
+  72. Fixed several video issues for Trident CyberBladeXP chips (Egbert Eich).
+  71. Added probe for Tseng ISA chips (Egbert Eich).
+  70. Added 'KGAUniversal' option to generic vga driver which changes handling
+      left overscan to work also on chips with C&T core (ie all C&T and Intel
+      graphics chips) (Egbert Eich).
+  69. Modified int10 code to map area between V_BIOS and SYS_BIOS instead of
+      copying it. Copying causes problems if legacy devices map MMIO
+      registers there (Egbert Eich).
+  68. Implemented an extended int10 init function to allow passing flags
+      (Egbert Eich).
+  67. Implemented optional handling of BIOS video mode scratch area in int10
+      code (Egbert Eich).
+  66. Again modified MTRR range splitting (Egbert Eich).
+  65. Added funtions to VBE to save and restore a video mode (Egbert Eich).
+  64. Added missing commas to symbols/us_intl (Hans Lunsing).
+  63. Added Ungherese (qwerty) support (Koblinger Egmont).
+  62. Added Euro symbol for hungarian kbd layout (Koblinger Egmont).
+  61. Build with libcurses on Darwin for forward compatibility
+      (Jordan Hubbard).
+  60. Add Trident CyberBladeXP acceleration (Alan Hourihane).
+  59. Major XDarwin rootless mode rewrite:
+       - Use Carbon to draw directly to windows' backing buffers, rather
+         than "triple" buffering with Core Graphics.
+       - Reorganized Xserver/hw/darwin directory structure to separate out
+         legacy support for Mac OS X 10.0.x.
+      (Torrey T. Lyons and Greg Parker).
+  58. Fix RGB/BGR inversion problem on Permedia3 chips (Alan Hourihane).
+  57. Fix server link problem that shows up on ppc (#5205, Guido Guenther).
+  56. Restore effect of option "NoSilkenMouse" (Marc La France).
+  55. Fix some nForce graphics regressions caused by recent flat panel and
+      Mac updates to the nv driver (Mark Vojkovich).
+  54. Recognise the "Absolute" keyword that was documented in the
+      XF86Config man page (David Dawes).
+  53. Fix the man page information about Absolute screen positioning in
+      the ServerLayout section (David Dawes).
+  52. SunOS changes to xedit's lisp interpreter (Marc La France).
+  51. Support the Ti 3026 ramdac with 3DLabs Permedia found on some
+      AccelStar boards (Alan Hourihane).
+  50. Move int10 softbooting furthur up in the glint driver to post
+      much earlier (Alan Hourihane).
+  49. Fix bug that sometimes caused makedepend to forget #define'd symbols
+      (Marc La France).
+  48. MIT-SHM updates (Roberto Zunino, Matthieu Herrb).
+  47. Import Mesa-4.0.1, and resync with the DRI trunk which is now based
+      on this (Keith Whitwell, Brian Paul, Alan Hourihane, David Dawes).
+  46. Mga driver updates:
+       - Don't try dual-head mode with the G400 unless the mga_hal module
+         is loaded.
+       - Distinguish between the G400 and G450 when showing the chipset in
+         the log.
+       - Update the mga man page for supported hardware and dual-head
+         support.  Futher updates are needed to document all of the
+         drivers's options.
+      (David Dawes).
+  45. Add -Wundef when compiling the tree with GCC >= 2.8 (Marc La France).
+  44. Macintosh flat panel fix in the "nv" driver (Mark Vojkovich).
+  43. XDarwin fixes and improvements for full screen Quartz mode:
+       - Pull full screen specific code out of generic Quartz support.
+       - Install new colormaps correctly with PseudoColor.
+       - Release the screen immediately when closing down.
+       - Do not try to release the screen when closing down in rootless mode.
+      (Torrey T. Lyons).
+  42. Reimplement Xft library on top of new fontconfig library (Keith Packard).
+  41. Resync with the final Mesa-3.4.x-based DRI trunk.
+  40. Add support for wscons bell (Jason Wright).
+  39. Fix IBM-reported bug that could cause PCI bus lockouts with second
+      generation integrated Mach64 controllers (Marc La France).
+  38. Rework ATI driver's registration of symbols with the loader
+      (Marc La France).
+  37. In the ATI driver, add option "CrtDisplay" to force CRT display in a
+      dual display situation (Marc La France).
+  36. In the ATI driver, rename option "CrtScreen" to "NoPanelDisplay", keeping
+      "CrtScreen" as a private option for compatibility (Marc La France).
+  35. Document X_NOT_IMPLEMENTED (Marc La France).
+  34. NetBSD teeny OS version handling improvement in imake (#5176,
+      Matthias Scheler).
+  33. Build I2C support before building drivers (Marc La France).
+  32. Fix a problem related to reserving the overlay key in the default
+      colormap in 24+8 mode.  This caused some clients using the 8-bit
+      visuals to fail (David Dawes).
+  31. [SECURITY] Zlib error handling fix (Mark Adler).
+  30. Put back XDarwin's byte-ordering fix for reading keymappings on
+      Darwin x86 that was inadvertently dropped (Rob Braun).
+  29. Fix Big Endian hardware cursor bug on GeForce3 (Mark Vojkovich).
+  28. Experimental flat panel support in the "nv" driver.  GeForce2 Go
+      should work now (Mark Vojkovich).
+  27. XDarwinStartup improvements:
+       - Auto-detect proper mode to run XDarwin.
+       - Find XDarwin.app with Launch Services.
+       - Add XDarwinStartup man page.
+      (Torrey T. Lyons).
+  26. Localize XDarwin credits in French (Olivier Verdier) and Portuguese
+      (Fabr’cio L. de Castro).
+  25. Turn off XFree86-Misc and VidMode extensions for XDarwin
+      (Torrey T. Lyons).
+  24. Localize a few missing strings in XDarwin preferences (Torrey T. Lyons).
+  23. GeForce4 support (Mark Vojkovich).
+  22. Add IA-64 460GX PCI IDs (Marc La France).
+  21. Some vesa driver updates:
+       - Use the common layer's mode validation functions, which gives
+         mode selection behaviour more consistent with other drivers.
+       - Don't force the depth 24 framebuffer bpp.  Instead check what
+         framebuffer layouts are supported by VBE, and and choose the
+         layout appropriately.
+       - fb handles 24/32 fb/pixmap layout conversion, so don't use
+         the xf24_32bpp module.
+       - shadow + fb at depth 4 needs the bpp set to 8.
+      (David Dawes).
+  20. Fix some misleading messages about why modes aren't available
+      (David Dawes).
+  19. Fix for `hostname` issue on Linux (Marc La France).
+  18. Fix startx script for ksh (Phillip B. Bruce).
+  17. Fix Emulate3Buttons for wsmouse protocol on NetBSD and OpenBSD
+      (Matthieu Herrb).
+  16. Add Portuguese localization of XDarwin front end
+      (Fabr’cio L. de Castro).
+  15. Fix mouse Protocol "Auto" for SunOS (Marc La France).
+  14. Relocate all driver low memory accesses (atimisc module not yet done)
+      (Marc La France).
+  13. Make driver I/O relocatable (atimisc, s3, sis and tseng not yet done)
+      (Marc La France).
+  12. PCI domain changes for SunOS/SPARC64 (Marc La France).
+  11. PCI domain changes for Linux/SPARC64 (#4653, David S. Miller,
+      Marc La France).
+  10. Temporary workaround for IA-64 (Marc La France).
+   9. Fix SIGSEGV when printing modes that have no modifiers (Marc La France).
+   8. Revert the ATI driver's composite sync default to off (Marc La France).
+   7. Add a note to the messages that get printed when a signal is caught
+      during initialization (which includes X -configure) that reported
+      unresolved symbols might not be the reason for the server aborting
+      (David Dawes).
+   6. Fix symbol registration in some drivers, which reduces the number of
+      symbols reported as "unresolved" when 'X -configure' crashes
+      (David Dawes).
+   5. Fill in names for BIOS modes in the vesa driver's mode pool that weren't
+      otherwise assigned names (David Dawes).
+   4. Fix an unresolved symbol in libGLU.so that shows up when building it
+      with gcc-3 (David Dawes).
+   3. Fix invalid code caused by a memcpy() macro being split by a directive
+      (#5150, Sami Farin).
+   2. Fix incorrect symbol prefixing with Xlib's i18n modules on Solaris
+      (Keith Packard, David Dawes).
+   1. Don't try to print mode names when the name is NULL (David Dawes).
+
 XFree86 4.2.0 (18 January 2002)
  690. Workaround for hardware bug that prevents older ATI 3D Rage adapters from
       being assigned to XF86Config device sections (Marc La France).
@@ -60,8 +2041,8 @@
       Juliusz Chroboczek).
  656. Fix unresolved symbol and loader symbol registration problems in the
       i810 driver that were introduced with the i830 support (David Dawes,
-      Abraham vd Merwe).   
- 655. Fix sparklies problem for other Trident *BladeXP chipsets 
+      Abraham vd Merwe).
+ 655. Fix sparklies problem for other Trident *BladeXP chipsets
       (Alan Hourihane).
  654. In XDarwin IOKit mode, ignore screens that can not provide the requested
       size, depth, or refresh rate instead of generating a fatal error
@@ -192,7 +2173,7 @@
  588. Fix the SiS drm driver (#5084, Torsten Duwe).
  588. Fix Trident driver pitch values when accelerator is in use, applies
       to Image and Blade series chips (Alan Hourihane).
- 586. Minor bugfix to SiS driver, restructured VT switching code 
+ 586. Minor bugfix to SiS driver, restructured VT switching code
       (Egbert Eich).
  585. Attempt to fix flickering in 24bpp on Trident CyberBladeXPAi1
       (Egbert Eich).
@@ -280,23 +2261,23 @@
       Xvideo window for the trident driver (Geoffrey Hausheer, Alan Hourihane).
  542. Fixed xkb to avoid setting of AccessXTimeout to 0 (Egbert Eich).
  541. Added option to sync the logfile after every line written (Egbert Eich).
- 540. Improved APM handling: 
+ 540. Improved APM handling:
       - Added disable of Input Handlers.
       - Added support for undo on failed APM requests.
       - Set vtSema to false (Egbert Eich).
  539. Improved detection of primary device especially for non-PC platforms
       (Egbert Eich).
- 538. Silicon Motion driver Fixes: 
+ 538. Silicon Motion driver Fixes:
       - Removed separate loading of int10 code.
       - Added reset of graphics engine on EnterVT (Egbert Eich).
  537. Set flag ROP_NEEDS_SOURCE for CPUToScreenColorExpand for all
       S3 Savage chips (Egbert Eich).
- 536. SiS driver: 
+ 536. SiS driver:
       - Added fix to restore fbdev mode properly on VT switch/exit.
       - Improved LCD handling on SiS 630.
-      - fixed screen blanking in SiS driver to properly blank LCDs 
+      - fixed screen blanking in SiS driver to properly blank LCDs
         (Egbert Eich).
- 535. Trident driver: 
+ 535. Trident driver:
       - Fixed screen centering for 640x480 Modes.
       - Fixed video playback for BladeAi1.
       - Fixed hotkey internal/external switching for XPm8/16.
@@ -382,7 +2363,7 @@
  490. Don't interfere with ATI panel support when using DDC information for
       monitor tolerance defaults (Marc La France).
  489. Add Dutch localization of XDarwin help file (Paul Edens).
- 488. Add stub functions needed by libGL to libXThrStubs. Link libGL against 
+ 488. Add stub functions needed by libGL to libXThrStubs. Link libGL against
       libXthrStubs on systems that build it. (#4997, Matthieu Herrb).
  487. Fix building and loading of I18N modules by Xlib on NetBSD and OpenBSD
       (#5049, Matthieu Herrb).
@@ -434,7 +2415,7 @@
  459. Fix buffer problems used by xrdb to build command line, noticed on
       systems with a large amount of visuals (#5016, Alan Coopersmith).
  458. Fix bug regarding signal handling in x11perf by inserting an abort
-      test after each run (#5015, Mark W. Snitily, from X11R6.6). 
+      test after each run (#5015, Mark W. Snitily, from X11R6.6).
  457. Add improved diagnostic messages and error checking to libXfont
       which is used by bdftopcf command (#5014, Chris Bare, from X11R6.6).
  456. Fix advertised surfaces for the i810 Motion Compensation driver and
@@ -443,7 +2424,7 @@
       fbdevhw layer (#5004, Michel Dänzer).
  454. Add Rage128 Pro PP detection to ati driver (#5025, Alfred Perlstein,
       Mike Harris).
- 453. Add CyberBladeXPAi1 recognition to the trident driver (#A.658, 
+ 453. Add CyberBladeXPAi1 recognition to the trident driver (#A.658,
       Jani Jaakkola).
  452. Fix typo in PCI bus scanning that caused a hang when there was more than
       one PCI bus (#A.652, Uwe Dannowski).
@@ -555,7 +2536,7 @@
  374. Cygwin/XFree86 cleanups and fixes (#4992, #4993, #4999 Harold Hunt).
  373. Fix i830 VT switching problems which hang the ring buffer (#4987,
       #4989, Abraham vd Merwe).
- 372. fix a format string problem in lbxproxy, apparently not exploitable 
+ 372. fix a format string problem in lbxproxy, apparently not exploitable
       (r0gue@vertarmy.org,  Matthieu Herrb).
  371. Fix disappearing cursor in XDarwin rootless mode by falling back to
       system cursor for cursors bigger than 16x16 (Torrey T. Lyons).
@@ -564,9 +2545,9 @@
  368. Fix calculation of DPI when Xinerama in use (#4986, Andrew C Aitchison).
  367. Update XDarwin preferences GUI to match current features
       (Torrey T. Lyons).
- 366. Xkb fixes for international keyboards (Matthieu Herrb). 
- 365. Add client side sparc64 support for NetBSD and OpenBSD (Eduardo Horvath, 
-      Matthieu Herrb). 
+ 366. Xkb fixes for international keyboards (Matthieu Herrb).
+ 365. Add client side sparc64 support for NetBSD and OpenBSD (Eduardo Horvath,
+      Matthieu Herrb).
  364. Allow xkbcomp to be used in a cross-compile environment (Alan Hourihane).
  363. Update documention for the SiS driver, the Options file
       (Ademar de Souza Reis Jr.).
@@ -583,7 +2564,7 @@
  356. Add CaseSensitiveFileSystem definition, which defaults to YES, except
       on Darwin, Cygwin, and OS/2. Fix another case problem spotted by
       NAKAHASHI Ichiro (Torrey T. Lyons).
- 355. Enable Vendor specific FatalError for Cygwin/XFree86 and create 
+ 355. Enable Vendor specific FatalError for Cygwin/XFree86 and create
       the Xserver as a windows executable (#4967, Harold Hunt).
  354. Add i830 2D and DRI driver (#A.604, VA Linux Systems, 2D3D).
  353. Use the -no-cpp-precomp compiler option on Darwin, rather than the
@@ -591,19 +2572,19 @@
  352. Reverting patch #340, fixing type (Egbert Eich).
  351. Fix rotation in fbdev driver (#4958, #4959, Michel Dänzer).
  350. Resync with DRI CVS trunk (DRI Project).
- 349. Move ati driver out of DevelDrivers on PPC platforms (#4952, 
+ 349. Move ati driver out of DevelDrivers on PPC platforms (#4952,
       Michel Dänzer).
- 348. SECURITY: set default value of authComplain resource in xdm to true. 
-      This closes a hole where anyone can connect to the X server if 
+ 348. SECURITY: set default value of authComplain resource in xdm to true.
+      This closes a hole where anyone can connect to the X server if
       the xdm auth dir doesn't exist (Galen Hancock).
  347. SECURITY: don't let a non-root user halt the machine by having X
       send SIGUSR1 to init (Thomas Moestl).
  346. Changed int10 module to stub on Sparc (Egbert Eich).
  345. Added hyperpen driver (Roland Jansen et. al.).
  344. Fixed alignments of x86emu-structures for AXP (Jay Estabrook).
- 343. Fixed XLoadQueryFont() and XLoadFont() to support locales 
+ 343. Fixed XLoadQueryFont() and XLoadFont() to support locales
       (required for Euro support) (Markus Kuhn).
- 342. Modified XtCvtStringToFont() to match any ISO8859 instead of 
+ 342. Modified XtCvtStringToFont() to match any ISO8859 instead of
       latin1 as fallback. Required for Euro Support (Markus Kuhn).
  341. Added acute to compose key list for iso8859-15 (Markus Kuhn).
  340. Modified XV Xinerama support to recognize adaptors if screen 0
@@ -620,7 +2601,7 @@
         is enabled.
       - added FP_mode flag to C&T driver which allows to override the detected
         state of the flat panel (Egbert Eich).
-      - fixed driver to act appropriately if the BIOS switches to the 
+      - fixed driver to act appropriately if the BIOS switches to the
         external monitor it detects when doing DDC.
       - Set IOBase correctly for MMIO when detection 65545 PCI.
       - fixed text screen restauration on 69030 (Egbert Eich).
@@ -631,14 +2612,14 @@
       - added double buffering to video support.
       - fixed register settings to prevent flickering during video playback.
        (Egbert Eich).
- 334. Fixed bug in C&T driver that caused interlaced mode not to work 
+ 334. Fixed bug in C&T driver that caused interlaced mode not to work
       (Claus Hulstrøm).
  333. Added full MMIO support for C&T 69030 chips (Gregg H. Burman).
  332. Fixed MMIO accel code in Cirrus Alpine driver, got PIO accel code to
       work (Egbert Eich).
  331. Fixed fbdev to obtain 24 bit framebuffer format from the kernel, added
       more failure messages to fbdev driver (Egbert Eich).
- 330. Added calls to vbeFree() to rendition, savage, silicon motion, 
+ 330. Added calls to vbeFree() to rendition, savage, silicon motion,
       i740 and i810 driver (Egbert Eich).
  329. Modified MGA driver for new Sparse allocation sceme (Jay Estabrook).
  328. Modified handling of sparse addresses on AXP: The code now no longer
@@ -650,23 +2631,23 @@
  325. Disabled accel functions that cause lockups on certain neomagic
       systems by default. They can be reenabled by setting the option
       "StrangeLockups" to "no" (Egbert Eich).
- 324. Did a further fix on ScreenToScreenCopy() for Neomagic 2200 
+ 324. Did a further fix on ScreenToScreenCopy() for Neomagic 2200
       (Egbert Eich).
  323. Added experimental support for Toshiba Libretto. This can be enabled
       by the option "DisplayHeight480" (Egbert Eich).
- 322. Fixed clipping in Savage driver, update to version 1.1.1.19 
+ 322. Fixed clipping in Savage driver, update to version 1.1.1.19
       (Tim Roberts).
  321. fixed calls to BLTSync() on SiS driver (Egbert Eich).
  320. Fixed Mono8x8PatternFill(): Moving SETROPFG behind SETROPBG did the
       trick (Egbert Eich).
- 319. Setting 24 bpp pximap flags correctly in SiS driver dependening 
+ 319. Setting 24 bpp pximap flags correctly in SiS driver dependening
       on chipset (Egbert Eich).
  318. Setting depth and bpp of framebuffer correctly for suncg14 and sunleo
       driver (Thorsten Kukuk).
  317. Tseng driver not longer ignores results of TsengDoMemLimit() which
-      tests for certain restrictions on the usable framebuffer size 
+      tests for certain restrictions on the usable framebuffer size
       (Egbert Eich).
- 316. Vesa driver: adding calls to vbeFree() before exiting PreInit(). 
+ 316. Vesa driver: adding calls to vbeFree() before exiting PreInit().
       Reinit vbe in ScreenInit() (Egbert Eich).
  315. Adding int10 initialization to generic vga driver (Egbert Eich).
  314. Modified generic vga driver to use shadow fb for vga16 on AXP.
@@ -676,19 +2657,19 @@
       (Egbert Eich).
  312. Removing message output from xf86WcmPlug() which causes -configure
       to core dump (Egbert Eich).
- 311. Modified int10 Pci code to be able to use new version of 
+ 311. Modified int10 Pci code to be able to use new version of
       xf86ReadPciBIOS() (Egbert Eich).
  310. Modified int10 int1A handler to return valid when an unimplemented int10
       call is encountered. This allows fallback to system BIOS (Egbert Eich).
  309. Modified xf86ReadPciBIOS() to check for valid i386 PC signature.
-      Added functions xf86GetAvailablePciBIOSTypes() and 
-      xf86ReadPciBIOSByType() to obtain available PCI BIOS types and 
+      Added functions xf86GetAvailablePciBIOSTypes() and
+      xf86ReadPciBIOSByType() to obtain available PCI BIOS types and
       retrieve a certain BIOS by type (Egbert Eich).
  308. Reversed bogus patch 1050 of version 4.0.2. The graphics engine will
       *never* be called after receiving an APM suspend and before receiving
       an APM resume. If the neomagic locks up on resume this has a different
       reason (Egbert Eich).
- 307. Change  real/effective user ID to 0/0 before calling modprobe in 
+ 307. Change  real/effective user ID to 0/0 before calling modprobe in
       xf86LoadKernelModule() on Linux so user can also load drm modules. Fixed
       PATH environment variable to /sbin (Stefan Dirsch, Egbert Eich).
  306. Removed disable/enable interrupt code on ia64 as interrupts cannot
@@ -704,28 +2685,28 @@
  300. Fixed core dump in twm if no locales are present (Egbert Eich).
  299. Modified xterm app default to use LFD fontnames instead of old type
       (Michael Schroeder).
- 298. Add a f.startwm function to twm to start another manager. 
+ 298. Add a f.startwm function to twm to start another manager.
       (Matthieu Herrb).
- 297. Disable MIT-SHM in Xnest, caused a segfault (Matthieu Herrb). 
+ 297. Disable MIT-SHM in Xnest, caused a segfault (Matthieu Herrb).
  296. Update wskbd keyboard protocol handling for OpenBSD/macppc
       (Matthieu Herrb).
  295. Fix problems starting XDarwin from the Finder and pasting with
       multi-button mouse emulation (Torrey T. Lyons).
  294. S3 driver updates. Restore console for 964 with Ti3025 and Trio64, and
       support for Aurora64V+ (#4953, Ani Joshi).
- 293. Fix USB Keyboard access when no PS/2 controller present 
+ 293. Fix USB Keyboard access when no PS/2 controller present
       (#4948, Pontus Lidman).
- 292. Add i810 XvMC (Motion Compensation) driver (#4946, #4964, #4966, 
+ 292. Add i810 XvMC (Motion Compensation) driver (#4946, #4964, #4966,
       Matthew Sottek, Intel).
  291. When using XKB and LEDs are switched on/off by external application
       the keyboard module doesn't change phisycal LEDs state immediately
       (#4951, Ivan Pascal).
  290. Clean up Cygwin/XFree86 keyboard files (#4949 Harold Hunt).
  289. Add Matrox G550 support (#4947, Luugi Marson, Matrox).
- 288. Remove SuperProbe.man definition for manual page 
+ 288. Remove SuperProbe.man definition for manual page
       (#4944, Ishikawa Mutsumi).
  287. Ark driver updates (#4943, Ani Joshi).
- 286. Fix xterm when XIM is disabled - caused a segfault 
+ 286. Fix xterm when XIM is disabled - caused a segfault
       (#4942, Tomohiro Kubota).
  285. Add Big Endian support (PowerPC) to radeon driver (#4934, Ani Joshi).
  284. Fix support for legacy Windows TrueType fonts in Big5 encoding
@@ -755,7 +2736,7 @@
  272. Rework XDarwin front end to start X clients in the user's normal
       environment and fix issues while quitting (Torrey T. Lyons).
  271. SECURITY: fix glyph clipping for large origin (Keith Packard).
-      Reported to be remotly exploitable through konqueror or netscape 
+      Reported to be remotly exploitable through konqueror or netscape
       by Georgi Guninski.
  270. Fix setting of memPhysBase in a few drivers (#4937, Gerd Knorr).
  269. Finish merging freetype-2-0-4 into trunk by resolving conflicts. This
@@ -787,8 +2768,8 @@
  256. Add entry to initialise framebuffer manager by area (allowing for a
       possible extra partial scanline) and make it print all largest areas
       (Marc La France).
- 255. Make xdm use BSD authentification on OpenBSD and use setproctitle() 
-      instead of home grown version where available (enabled on 
+ 255. Make xdm use BSD authentification on OpenBSD and use setproctitle()
+      instead of home grown version where available (enabled on
       OpenBSD and NetBSD only) (Matthieu Herrb).
  254. Make -configure generate the DisplaySize from the acquired DDC
       information (#4897, Andrew C Aitchison).
@@ -962,7 +2943,7 @@
       (Marc La France).
  162. Make imake pass its -W* flags to cpp (Marc La France).
  161. More accomodations for newer GCC's (Mike A. Harris).
- 160. Remove a CYGWIN define from Xserver/include/windowstr.h 
+ 160. Remove a CYGWIN define from Xserver/include/windowstr.h
       (#4832, Harold Hunt).
  159. Fix a casting problem which causes bdftopcf to write corrupted
       fonts on buffer boundaries (#A.522, Jakub Bogusz).
@@ -1035,7 +3016,7 @@
  118. Add MagicTouch driver (A.482, Mauro Ziliani)
  117. Fix side effect in XFree86 of the recent changes to libxf86config
       (A.486, Knuts Andy).
- 116. Define Xutf8LookupString in X11-def.cpp for Cygwin/XFree86 
+ 116. Define Xutf8LookupString in X11-def.cpp for Cygwin/XFree86
       (#4790, Suhaib Siddiqi).
  115. Turn on RandR build for Cygwin/XFree86 (#4789, Harold Hunt).
  114. Import of Gregory Parker's rootless code for Mac OS X. The code has
@@ -1083,16 +3064,16 @@
       (splite at purdue.edu).
   91. Fix glide driver that causes -configure to fail for all drivers
       (Alan Hourihane).
-  90. Don't define SVR4 on Cygwin/XFree86 (#4751, Suhaib Siddiqi,  
+  90. Don't define SVR4 on Cygwin/XFree86 (#4751, Suhaib Siddiqi,
       Alan Hourihane).
   89. Don't override system commands specified in host.def on Cygwin/XFree86
       (#4753, Alexander Gottwald).
-  88. Fix cursor problem in server respawn's on Cygwin/XFree86 
+  88. Fix cursor problem in server respawn's on Cygwin/XFree86
       (#4750, Harold Hunt).
-  87. Fix typo definition of CplusplusCmd in cygwin.cf 
+  87. Fix typo definition of CplusplusCmd in cygwin.cf
       (#4752, Alexander Gottwald).
   86. Fix makedepend for use on Cygwin/XFree86.
-      Use makedepend on Cygwin/XFree86. 
+      Use makedepend on Cygwin/XFree86.
       Fix SharedDepLibraryTarget so that build dependencies are correct,
       this fixes libGLU's build problem (Alan Hourihane).
   85. Don't define MKSTEMP on Cygwin/XFree86 (#4725, Harold Hunt).
@@ -1111,7 +3092,7 @@
       flags. (#4743, Harold Hunt).
   75. Fix some build issues on Cygwin/XFree86 (#4736, #4737, Suhaib Siddiqi).
   74. Some Cygwin/XFree86 cleanups (#4735, Harold Hunt).
-  73. Fix XAA's incorrect acceleration of X-Render's repeated sources and 
+  73. Fix XAA's incorrect acceleration of X-Render's repeated sources and
       masks (Mark Vojkovich).
   72. Disable PCI resource conflict checking for Linux/Alpha (Jay Estabrook).
   71. Fix Linux xf86GetPciSizeFromOS() parsing when the kernel is 64 bit
@@ -1290,13 +3271,13 @@
       (#4654, Harold Hunt).
  536. Add an option to the SiS driver to turn off Xvideo support
       (Ademar de Souza Reis Jr.)
- 535. Fix FreeType bug, use MAXFONTNAMELEN (#4652, Janusz Gorycki, 
+ 535. Fix FreeType bug, use MAXFONTNAMELEN (#4652, Janusz Gorycki,
       Juliusz Chroboczek).
  534. Fix hw/vfb for compilation on Cygwin/XFree86 (#4655, Harold Hunt).
  533. Fix some Sparc platform issues with Pci resources and the glint
       driver (#4641-4641,4644-4648 David S. Miller).
  532. Update glide, imstt, newport, rendition, suncg14, suncg3, suncg6,
-      sunleo, suntcx, vga and vmware to use fb and support Render 
+      sunleo, suntcx, vga and vmware to use fb and support Render
       (Keith Packard).
  531. XDarwin fixes:
        - Turn off building non-functional RENDER support.
@@ -1305,14 +3286,14 @@
          switching from Aqua.
       (Torrey Lyons).
  530. Update freetype2 bits to 2.0.2 version (Keith Packard).
- 529. Re-fix the Trident Video scaler support for Blade series chips 
+ 529. Re-fix the Trident Video scaler support for Blade series chips
       (Alan Hourihane).
  528. Fixed lbx to handle endian swapping without core dump (Egbert Eich).
  527. Fixed MTRR region splitting (Egbert Eich).
  526. Cleaned up option handling in int10 code (Egbert Eich).
- 525. Added options to specify the Video BIOS to use for POSTing a 
-      chipset (Egbert Eich). 
- 524. Trident driver: added call to BIOS to enable unstretched mode when 
+ 525. Added options to specify the Video BIOS to use for POSTing a
+      chipset (Egbert Eich).
+ 524. Trident driver: added call to BIOS to enable unstretched mode when
       display is stretched. This should make the option "CyberShadow"
       obsolete. (Egbert Eich).
  523. Attempt to fix video Support on Trident driver (Egbert Eich).
@@ -1326,17 +3307,17 @@
  518. Cleanded up DDC code in mga driver (Egbert Eich).
  517. Fixed KGA handling in i740 driver (Egbert Eich).
  516. Converted i740 and Silicon Motion drivers to fb (Egbert Eich).
- 515. Added calls to vbeFree() or xf86FreeInt10() to C&T, glint, 
-      mga, neomagic, nv, s3v, tdfx and trident drivers to clean up 
+ 515. Added calls to vbeFree() or xf86FreeInt10() to C&T, glint,
+      mga, neomagic, nv, s3v, tdfx and trident drivers to clean up
       shared memory segments (Egbert Eich).
  514. Reworked video support in C&T driver, cleaned up block handler
       (Egbert Eich).
- 513. C&T driver: introduced a delay when setting the cursor image for 
+ 513. C&T driver: introduced a delay when setting the cursor image for
       the first time after a mode change (Egbert Eich).
  512. Fixed R128CCE_RESET in r128 driver to do a reset only when dri
       is enabled (Egbert Eich).
  511. Rewrote readPciBIOS() and getValidBIOSBase() (Egbert Eich).
- 510. Fixed xf86Info structure in xf86Globals.c to match prototype 
+ 510. Fixed xf86Info structure in xf86Globals.c to match prototype
       (Egbert Eich).
  509. -
  508. Fix XDarwin install problems with DESTDIR handling and with soft links
@@ -1346,7 +3327,7 @@
       later (#A.401, #A.402, #A.403, Rainer Orth).
  505. Add Croatian keyboard for xkbcomp from Slovenian keyboard layout
       (#A.405, Vlatko Kosturjak).
- 504. Fix XvQueryAdaptors when there is no adaptors found 
+ 504. Fix XvQueryAdaptors when there is no adaptors found
       (#A.394, Jamie Strachan).
  503. Remove a stray INCLUDES in Xmuu/Imakefile when snprintf isn't used.
       Set the Permedia2 DAC Mask to 0xFF.
@@ -1842,13 +3823,13 @@
       in their -f flag (Marc La France).
  274. Bump the video and input driver ABI minor numbers.
  273. Add xf86SetRealOption() (Huver).
- 272. Change Xdarwin do that it processes all pending events instead of 
+ 272. Change Xdarwin do that it processes all pending events instead of
       just the oldest one on ProcessInputEvents() call ,
       Quit Xdarwin cleanly, wether from the Xserve or from Cocoa front end,
-      Fix a case typp which cases the Xdarwin server not to start if 
-      installed on a case sensitive file system like UFS. 
-      (#4504, #4507, #45011, Gregory Parker, Torrey T. Lyons). 
- 271. Move Section DRI/Endsection into the DRI function to be consistant with 
+      Fix a case typp which cases the Xdarwin server not to start if
+      installed on a case sensitive file system like UFS.
+      (#4504, #4507, #45011, Gregory Parker, Torrey T. Lyons).
+ 271. Move Section DRI/Endsection into the DRI function to be consistant with
       all of the other sections. (Quentin Neill)
  270. Made xf4bpp code moer 64bit clean (still doesn't work on Alphas)
       (Egbert Eich).
@@ -1896,11 +3877,11 @@
  245. Add support to splitting WC MTRR regions on Linux when the regions is
       not aligned on a size boudary (#A.238, _Usul John Obscurant).
  244. Add Acecad support to the "summa" input driver (#A.237, Arpad Gereoffy).
- 243. Don't try to map 64K blit window aperture on older trident chips 
+ 243. Don't try to map 64K blit window aperture on older trident chips
       (Alan Hourihane).
  242. V4L driver cleanups and Xineramification (#4502, Gerd Knorr).
  241. Make the X server and the Mac OS X front end run in a single process.
-      Other build fixes for Darwin (#4500, #4501, the XonX team). 
+      Other build fixes for Darwin (#4500, #4501, the XonX team).
  240. Don't build xf86config under BuildServersOnly (Marc La France).
  239. Potential fix for DGA apps that set colourmaps the normal way rather than
       through DGA (Mark Vojkovich, Marc La France, Pontus Lidman).
@@ -1909,7 +3890,7 @@
  236. Plug kernel security hole in Linux int10 (Marc La France).
  235. Fix Xnest build for newest gcc versions (Marc La France).
  234. Fix typo in Xv Xinerama support (Gerd Knorr).
- 233. Fix a problem with multi-thread support on OpenBSD (released OpenBSD 
+ 233. Fix a problem with multi-thread support on OpenBSD (released OpenBSD
       versions don't have getpwuid_r) (Matthieu Herrb)
  232. Allow to compile on OpenBSD-current which has completly removed PCVT
       from its installation. (Matthieu Herrb)
@@ -2004,11 +3985,11 @@
       (Egbert Eich).
  199. Modified memory debugger script to retieve backtrace information
       with an unmodified version of gdb (Egbert Eich).
- 198. Modified memory debugger to print out backtrace of call where 
-      a referenced freed pointer was once allocated (Egbert Eich). 
+ 198. Modified memory debugger to print out backtrace of call where
+      a referenced freed pointer was once allocated (Egbert Eich).
  197. Several more fixes for memory leaks and several "referenced freed"
-      to keep memory debugger quiet (Egbert Eich). 
- 196. Fixed "referenced freed" memory debugger message in xf8_24bpp code 
+      to keep memory debugger quiet (Egbert Eich).
+ 196. Fixed "referenced freed" memory debugger message in xf8_24bpp code
       (Egbert Eich).
  195. Add a new rule for building DRI (client) modules, so that only the
       relevant symbols are exported (#4454, Red Hat).
@@ -2017,16 +3998,16 @@
       it when leaving SETUP state (Egbert Eich).
  192. Add type of option argument as comment to config file.
       (xf86cfg might need some fixing) (Egbert Eich).
-      (Hopefully) fixed reordering of chips so primary comes first 
+      (Hopefully) fixed reordering of chips so primary comes first
       (Egbert Eich).
- 191. Fixed bug that caused server to crash when a DGA private colormap 
-      was freed as miSprite still had a pointer to this colormap 
+ 191. Fixed bug that caused server to crash when a DGA private colormap
+      was freed as miSprite still had a pointer to this colormap
       (Egbert Eich).
  190. Fixed savage driver for altered vbe functionality (Egbert Eich).
- 189. Moved bulk of generic VBE functionality from VESA driver into 
+ 189. Moved bulk of generic VBE functionality from VESA driver into
       the vbe module (Egbert Eich).
  188. Fixed some bugs in vesa driver (Egbert Eich).
- 187. Fixed memleaks in parser code as well as several referenced freed 
+ 187. Fixed memleaks in parser code as well as several referenced freed
       pointers which pollute output of memory debugger and obsucre debugging
       (Egbert Eich).
  186. Fixed ChangeWindowAttributes() in cfb8_16 code (Egbert Eich).
@@ -2034,7 +4015,7 @@
       os-level code (Egbert Eich).
  184. Added option to int10 softbooter to POST even primary device.
  183. Fixed memory leak in linux int10 code (Egbert Eich).
- 182. Modified vm86 trap code not to fail on a #LOCK prefix byte 
+ 182. Modified vm86 trap code not to fail on a #LOCK prefix byte
       (Egbert Eich).
  181. Fixed memory leak in posix_tty.c (Egbert Eich).
  180. Added support to generic driver to POST even primary devices
@@ -2045,8 +4026,8 @@
  177. Fixed problems with Xv code in C&T driver (Egbert Eich).
  176. Fixed a vertical and horizontal offsets on HiQV chips due to
       non-"standard" handling of H/VBlankEnd registers (Egbert Eich).
- 175. Removed code that sets a chipset into graphics mode when 
-      saving/restoring fonts in standard vga code. This causes problems 
+ 175. Removed code that sets a chipset into graphics mode when
+      saving/restoring fonts in standard vga code. This causes problems
       on some trident chipsets (Egbert Eich). [EXPERIMENTAL!]
  174. Moved KGA code that handles the H/VBlankEnd code that overscans remain
       invisible to separate functions. This way drivers have better control
@@ -2056,7 +4037,7 @@
       (Egbert Eich).
  171. Added option to swap heads on a matrox G400 dual head (Stefan Dirsch).
  170. Added handling of broken planemask support on different models of
-      matrox G100 cards (Egbert Eich). 
+      matrox G100 cards (Egbert Eich).
  169. Fixed minor memory leak in ati driver (Egbert Eich).
  168. Fixed resource registration in TDFX driver (Egbert Eich).
  167. Set new modelines for Trident LCD modes (Egbert Eich).
@@ -2069,13 +4050,13 @@
  160. Attempt to fix various other issues on rendition - driver remains
       to be broken though (Egbert Eich)!
  159. Fixed false linear size for NeoMagic 2380 (Egbert Eich).
- 158. Modified calulation of aperture size in NeoMagic driver to use the 
+ 158. Modified calulation of aperture size in NeoMagic driver to use the
       available video memory instead of the map size (Egbert Eich).
- 157. Added a delay to prevent rare cases of lockups when starting 
+ 157. Added a delay to prevent rare cases of lockups when starting
       X on NeoMagic 2160 (Miles Lane).
  156. Added DGA to Cirrus driver (Egbert Eich).
  155. Missing symbols added to Cirrus driver (Egbert Eich).
- 154. Fixed acceleration on Alpine (Cirrus) driver. PIO and MMIO versions of 
+ 154. Fixed acceleration on Alpine (Cirrus) driver. PIO and MMIO versions of
       the accelerator driver now support the same functionality (Egbert Eich).
  153. Removed unneededed call to xfree() in ddc code (Egbert Eich).
  152. -
@@ -2179,7 +4160,7 @@
       (#4413, Frido Garritsen).
  113. Change the Thai charset and locale description to a form agreed to
       by some Thai developers (#4412, Chanop Silpa-Anan).
- 112. [SECURITY] Fix temp files vulnerabilites in xman on systems with 
+ 112. [SECURITY] Fix temp files vulnerabilites in xman on systems with
       mkstemp(). (Matthieu Herrb).
  111. Major improvement to the Xmaster UI on Mac OS X. (#4447, XonX team).
  110. 8 bit DAC support for the NVIDIA Riva-128 (Mark Vojkovich).
@@ -2205,7 +4186,7 @@
 	- Fix pm2v/pm3 text restoration problems.
 	- Re-arranged structure to accomodate multi-chips per screen.
 	- Removed dualmx files and incorporated changes into standalone versions
-	- Allow -configure to only configure VGA based Glint chips, works 
+	- Allow -configure to only configure VGA based Glint chips, works
 	  around multichip boards (for now).
       (Alan Hourihane).
  100. Add XaaNoWriteBitmap and XaaNoWritePixmap options to XAA (Alan Hourihane).
@@ -2221,7 +4202,7 @@
   91. Rework the memory detection code for Permedia3, now correctly detects
       boards which aren't 32MB (Alan Hourihane).
   90. Write ScanlineCPUToScreen, ScanlineImageWrite functions for Permedia3
-      which write directly to the FIFO, and remove obsolete functions 
+      which write directly to the FIFO, and remove obsolete functions
       (Alan Hourihane).
   89. Fix ordering of writes in pm2v/pm3 ramdac functions in the glint driver,
       thus fixing the R/B inversion problems (Jay Estabrook).
@@ -2231,8 +4212,8 @@
       from that single set of values (David Dawes).
   86. [SECURITY] Fix temp vulnerabilities in Xaw/MultiSrc.c using the technique
       in patch #4279 (Branden Robinson). Fix temp file vulnerability in
-      gccmakedep based on report from Alan Cox. Fix temp file vulnerability 
-      in Imake.rules, InstallManPageAliases (Matthieu Herrb). 
+      gccmakedep based on report from Alan Cox. Fix temp file vulnerability
+      in Imake.rules, InstallManPageAliases (Matthieu Herrb).
   85. Support vertical sub-pixel glyph rasterization in Xft
       (Keith Packard)
   84. Allow xf86ClaimPciSlot to be called with a NULL GDevPtr, as it was
@@ -2296,11 +4277,11 @@
   60. Change identification of Trident 8400(CyberBlade/i7) so that it is not
       a Cyber chipset (integrated Desktop version) (Alan Hourihane).
   59. Use the wsmouse protocol in XFree86 -configure if wsmouse is available
-      (Matthieu Herrb, lha at stacken.kth.se). 
+      (Matthieu Herrb, lha at stacken.kth.se).
   58. Sync Xdarwin with XonX version (#4428 Torrey T. Lyons):
       - add a working WarpCursor
       - add 15 bit pixel depth to the Quartz mode.
-  57. New version of Xmaster, a Mac OS X application that controls the 
+  57. New version of Xmaster, a Mac OS X application that controls the
       X server (#4427, Torrey T. Lyons, Andreas Monitzer).
   56. Add external CRT support for the Rage 128 Mobility (Kevin Martin
       and ATI).
@@ -2334,13 +4315,13 @@
   50. Add compressed man page functionality to the rules in Imake.rules,
       so it should be usable on most platforms (David Dawes).
   49. Make acceleration work on the Trident Cyber9388 (Alan Hourihane).
-  48. - Various small changes to accomodate Mac OS X support and fix a 
-        problem people were having with uninitialized globals in X 
+  48. - Various small changes to accomodate Mac OS X support and fix a
+        problem people were having with uninitialized globals in X
         libraries,
       - Allow XFree86 to run on Mac OS X as a full screen client of
         CoreGraphics,
-      - Add a Mac OS X application that controls the X server and feeds it 
-        events when running on Mac OS X. Currently must be built by 
+      - Add a Mac OS X application that controls the X server and feeds it
+        events when running on Mac OS X. Currently must be built by
         ProjectBuilder (#4409, #4410, #4411, Torrey T. Lyons).
   47. Fix Mach64 Mono 8x8 Pattern acceleration (Marc La France).
   46. Experiment with setting the server's "vendor release" value from
@@ -2398,7 +4379,7 @@
   23. Switch savage driver to fb (+Render), correct maxHValue (Keith Packard).
   22. Add font property caching in Xft (Keith Packard).
   21. Xterm patch #150 (Thomas Dickey).
-  20. Fix 24/8 Overlay support on Permedia2v and Permedia3 chipsets 
+  20. Fix 24/8 Overlay support on Permedia2v and Permedia3 chipsets
       (Alan Hourihane).
   19. Add CyberStretch option to the trident driver for Cyber chipsets that
       allows Graphics modes to stretch to the full display (Alan Hourihane).
@@ -2415,7 +4396,7 @@
   12. Enable ImageWrites on Rage128 and Radeon (Alan Hourihane).
   11. Add DRIMoveBuffersHelper function to prevent code duplication in
       the drivers (Mark Vojkovich).
-  10. Bug fixes for endianness problems in Permedia3 driver 
+  10. Bug fixes for endianness problems in Permedia3 driver
       (#4404, Sven Luther).
    9. Add Appian Jeronimo 4x8Mb (PM2v) support to the glint driver
       (Alan Hourihane).
@@ -2499,7 +4480,7 @@
       is selected during boot up (#4377, Frido Garritsen).
 1181. Install and RELNOTES updates for Darwin (#4375, 4376, Torrey T. Lyons).
 1180. s3virge patch to get Xft/Xrender working (#4374, Kevin Brosius).
-1179. Improve aperture driver related error messages on OpenBSD 
+1179. Improve aperture driver related error messages on OpenBSD
       (Matthieu Herrb).
 1178. Workaround for IA-64 loader bug (Marc La France).
 1177. Fix recognition of valid depth/fbbpp combinations in ATI driver
@@ -2600,7 +4581,7 @@
 1133. Change xfs to drop privs after daemonising so that the pid file can
       be written (#4346, Frederic Lepied).
 1132. Miscellaneous fixups to the trident driver (Alan Hourihane).
-1131. Add Xv support to the trident driver. Works for Blade and Image series 
+1131. Add Xv support to the trident driver. Works for Blade and Image series
       chips, but zooming currently doesn't work on Image series.
       (Alan Hourihane).
 1130. Don't perform a software reset on the Graphics Engine for Trident
@@ -2634,7 +4615,7 @@
 1114. Changed name of server binary to call by xf86cfg back to "XFree86
       (Egbert Eich).
 1113. Modified handling of memory alloctaion in TDFX driver (Egbert Eich).
-1112. Attempt to fix the 'UseModes' directive in the Monitor section 
+1112. Attempt to fix the 'UseModes' directive in the Monitor section
       (Egbert Eich).
 1111. Added debugging output for BIOS base address search (Egbert Eich).
 1110. Changed neomagic driver to treat disable stretching for each mode
@@ -2750,7 +4731,7 @@
       a zero keycode keypress event is received (#4322, HIBINO Kei).
 1072. NetBSD doesn't have perl in its default install (Matthieu Herrb).
 1071. Add Xft support to xditview with #ifdefs (Keith Packard)
-1070. Add a MIT-MAGIC-COOKIE-1 generator to startx for NetBSD 1.5 and OpenBSD 
+1070. Add a MIT-MAGIC-COOKIE-1 generator to startx for NetBSD 1.5 and OpenBSD
       and FreeBSD and make mkcookie support more generic (Matthieu Herrb).
 1069. Update OpenBSD and NetBSD docs (Matthieu Herrb).
 1068. Clean up r128_video.c again (Marc La France).
@@ -2933,7 +4914,7 @@
       when the -authfile command line flag isn't given (#4250,
       Branden Robinson).
  979. Add Debian-specific settings to linux.cf (#4249, Branden Robinson).
- 978. Rename Trident Cyber9540 to CyberBlade/e4 and make appropriate 
+ 978. Rename Trident Cyber9540 to CyberBlade/e4 and make appropriate
       changes in driver (Alan Hourihane).
  977. Fix Trident Cyber series to only detect SDRAM (Alan Hourihane).
  976. Make xf86SoundKbdBell() available to modules (for citron driver)
@@ -2944,7 +4925,7 @@
  973. Fix int10 debugging and reading in all segments between 0x0C0000 and
       0x0F0000 (Marc La France).
  972. Fix typo in imake.c (Marc La France).
- 971. Turn off SGRAM optimization for Trident Blade chips, causes some 
+ 971. Turn off SGRAM optimization for Trident Blade chips, causes some
       problems. (Alan Hourihane).
  970. Ignore various ".stab.*" sections for Solaris (Marc La France).
  969. Fix ENXIO errors on Linux BIOS retrievals by removing restriction on
@@ -3087,16 +5068,16 @@
  898. xf86cfg has a new option for a server path (Egbert Eich).
  897. xf86cfg can now handle more than one command line argument (Egbert Eich).
  895. Added a delay to dac code in neomagic driver (Egbert Eich).
- 894. Changed shadowfb to use delayed updates in neomagic 
+ 894. Changed shadowfb to use delayed updates in neomagic
        driver (Egbert Eich).
  893. Rewrote ddc code in nv driver (Egbert Eich).
  892. Rewrote ddc code in neomagic driver (Egbert Eich).
- 891. Fixed problems with enter/leave/closeScreen in nv 
+ 891. Fixed problems with enter/leave/closeScreen in nv
        driver (Egbert Eich).
  890. Fixed a bug in the fixed modelines in trident driver (Egbert Eich).
- 889. Added reinitialization of blitter on enterVT in trident 
+ 889. Added reinitialization of blitter on enterVT in trident
        driver (Egbert Eich).
- 888. Fixed a typo which caused wrong register to be set in trident 
+ 888. Fixed a typo which caused wrong register to be set in trident
        driver (Egbert Eich).
  887. Added loader symbol handling to tseng driver (Egbert Eich).
  886. Changed tseng driver to use fb instead of cfb (Egbert Eich).
@@ -3106,7 +5087,7 @@
  882. Added render extension support to nv driver (Egbert Eich).
  881. Modified helper_mem.c to map everything between video bios and
        system bios on PC-like platforms (Egbert Eich).
- 880. Modified Linux mapVidMem() to map memory on page boundaries 
+ 880. Modified Linux mapVidMem() to map memory on page boundaries
        (Egbert Eich).
  879. Changed BIOS_SIZE (Sys BIOS) from 0x10000 to 0xffff to make
        int10 work un DGUX (Takis Psarogiannakopoulos).
@@ -3379,7 +5360,7 @@
  727. Added missing symbols to mga driver (Stefan Dirsch).
  726. Fixed a ia64 loader problem that caused SIGV when PLT was present
       (Andreas Schwab).
- 725. Fixed ia64 build rules (Andreas Schwab).     
+ 725. Fixed ia64 build rules (Andreas Schwab).
  724. Fix DGA library to only swap events for DGA 2.0 X servers
  723. Fix locale parsing code in Xlib and Xt (Matthieu Herrb)
  722. Fix X Test Suite to work on 800x600 screens (Keith Packard)
@@ -3404,7 +5385,7 @@
       - Set correct virtual desktop size limits for 2160 and older chips.
       - Preliminary man page.
       - Enable burst modes by default.
-      - Accelerate ImageWrite support for 2097/2160.  
+      - Accelerate ImageWrite support for 2097/2160.
  713. Fix some depth 32 problems in XAA (Mark Vojkovich).
  712. Add Silken Mouse to Rage 128 driver (Alan Hourihane).
  711. Resync DRI code/drivers with the DRI CVS (VA Linux).
@@ -3423,7 +5404,7 @@
  609. Fixed Macintosh keyboard layouts (Olaf Hering).
  608. Fixed build when BuildServer defined NO (Egbert Eich).
  607. Fixes for C&T 69030 (David Bateman).
- 606. Fix for locale setting in Xlib and Xt using getlocale() 
+ 606. Fix for locale setting in Xlib and Xt using getlocale()
       from glibc5 (Egbert Eich).
  605. Added handling of i5/686 and k6 compiler defines to Imake.cf
       (Philipp Thomas).
@@ -3433,25 +5414,25 @@
  601. Rudimentary S390 support (Ruediger Oertel, Bernhard Kaindl).
  600. Enabled support for compressed xpm-files (Stefan Dirsch).
  599. Added support for Czech querty keyboard (Jan Holesovsky).
-      Some fixes for ia64 (). 
+      Some fixes for ia64 ().
  598. Added CPU to Screen Color expansion to Neomagic driver (Egbert Eich).
  597. Added support for hotkey display output switch for Neomagic
       driver (Egbert Eich).
  596. Add "xvinfo" client for querying Xv adaptors (Mark Vojkovich).
  595. Fix DGA support in the i810 driver (Mark Vojkovich).
- 594. Enlarge the i810 pixmap cache and have the YUV overlay use that memory 
+ 594. Enlarge the i810 pixmap cache and have the YUV overlay use that memory
       rather than allocate dedicated memory for overlay data (Mark Vojkovich).
  593. Add/fix support for the Rage 128 Mobility chips (M3/M4) (Kevin Martin).
- 592. Fix RegisterResources for multiple heads in glint driver 
+ 592. Fix RegisterResources for multiple heads in glint driver
       (#4143, Berend Ozceri).
  591. Update Permedia3's hw cursor to match the Permedia2v's they are
       the same (Alan Hourihane).
  590. Fix glint driver to use colorKey rather than fixed value (Alan Hourihane).
  589. Add ScreenToScreenCopies for Permedia3 (Alan Hourihane).
  588. Add SilkenMouse support to the i810 driver (Mark Vojkovich).
- 587. Disable DRI acceleration in depth 15 on the i810 because it doesn't 
+ 587. Disable DRI acceleration in depth 15 on the i810 because it doesn't
       work (Mark Vojkovich).
- 586. Fix some ordering problems in the I810ScreenInit that broke the 
+ 586. Fix some ordering problems in the I810ScreenInit that broke the
       software cursor and backing store (Mark Vojkovich).
  585. Convert the i810 driver from cfb to fb (Mark Vojkovich).
  584. Fix some depth/bpp confusion in the i810 driver.  Depth 15 works now
@@ -3463,7 +5444,7 @@
  579. Set $(SHELL) to '/bin/sh -e' on Linux to allow builds/installs stop
       immediately on errors as on other platforms (Brandon Robinson).
  578. Update i810 driver for -configure to work (Alan Hourihane).
- 577. Have Xv silently ignore client requests with zero sized primitives 
+ 577. Have Xv silently ignore client requests with zero sized primitives
       (Mark Vojkovich).
  576. Disable gamma correction and DirectColor visuals on the i810 because
       they don't work (Mark Vojkovich).
@@ -3477,7 +5458,7 @@
  570. IA-64 changes resulting from a source cross-check with Alpha support
       for 64-bit dependencies (Marc La France).
  569. Fix in ATI drivber for DPMS support on panels (Marc La France).
- 568. I810 bugs fixes and enhancements relating to Xv (#4121, 4117, 4123, 
+ 568. I810 bugs fixes and enhancements relating to Xv (#4121, 4117, 4123,
       4128, Jonathan Bian).
 
 XFree86 4.0.1c (28 August 2000)
@@ -3538,7 +5519,7 @@
  530. Use $(CC) instead of $(LD) when building modules (Bill Nottingham).
  529. When building with MakeDllModules, generate both dynamic and static
       libraries (Bill Nottingham, Marc La France).
- 528. Fix detection problem with ramdac for Glint Permedia1's 
+ 528. Fix detection problem with ramdac for Glint Permedia1's
       (Alan Hourihane).
  527. Fix minor symbol resoltion problem in dlopen() loader (Marc La France).
  526. Alpha changes that fell out of RadHat's IA-64 changes (Marc La France).
@@ -3623,7 +5604,7 @@
       - Implement a compilation option that produces an MMIO-only version of
         the driver.  Intended for non-Intel architectures.  See the driver's
         Imakefile for details.
- 491. fixed handling of backwards compatibility in xvmode (Egbert Eich). 
+ 491. fixed handling of backwards compatibility in xvmode (Egbert Eich).
  490. fixed changing mouse protocol with xf86misc extensions (Egbert Eich).
  489. added code to sanitize uninitialized PCI config space
       base addresses (Egbert Eich).
@@ -3646,7 +5627,7 @@
  480. fixed a fg/bg color problem in SiS driver (Egbert Eich).
  479. attempt to address some problems with Cyber LCD chipsets in
       Trident driver (Egbert Eich).
- 478. tseng driver: Implemented correct MMIO handling (Egbert Eich). 
+ 478. tseng driver: Implemented correct MMIO handling (Egbert Eich).
  477. tseng driver: made accel driver multi screen capable (Egbert Eich).
  476. fixed vgaHW driver to use forground color for readability
       test of pallette registers. This prevents annoying flashing
@@ -3725,8 +5706,8 @@
  433. For IA64, compile everything, except PEX, that is also compiled for IA32
       (Marc La France).
  432. Fix Cyrix driver for -configure (Alan Hourihane).
- 431. Fix Glint PM3 memory detect when only 1MB of videoram (Alan Hourihane). 
- 430. Fix DAC colour problem and blank out issue in glint driver 
+ 431. Fix Glint PM3 memory detect when only 1MB of videoram (Alan Hourihane).
+ 430. Fix DAC colour problem and blank out issue in glint driver
       (Alan Hourihane).
  429. Add missing clock values to the trident driver (Alan Hourihane).
  428. Fix Glint driver's SaveScreen function (#4057, Michel Danzer).
@@ -3754,7 +5735,7 @@
  415. Doc updates (Georgina Economou).
  414. Fix some palette and fbdev problems, and add a missing break to the
       video memory type detection code for the r128 (#4043, Benjamin
-      Herrenschmidt). 
+      Herrenschmidt).
 
 XFree86 4.0Z (30 June 2000)
  413. README updates (Georgina Economou).
@@ -3792,9 +5773,9 @@
  398. Disable SilkenMouse for the s3virge GX2 to avoid some lockup problems
       (#4039, Kevin Brosius).
  397. Some mga DRI updates to improve stability (Jeff Hartmann).
- 396. Fix some DRI offscreen memory calculations in the Matrox driver 
+ 396. Fix some DRI offscreen memory calculations in the Matrox driver
       (Mark Vojkovich).
- 395. IA64 workarounds - should compile and run right out of the box now 
+ 395. IA64 workarounds - should compile and run right out of the box now
       (Mark Vojkovich).
  394. LBX, X-TrueType and Xnest warning fixes (Marc La France).
  393. Remove unused xf86MapDisplay() and xf86UnMapDisplay() os-support entry
@@ -3846,7 +5827,7 @@
       MX (but they're commented out for the MX because it hasn't been tested
       yet) (#4027, Kevin Brosius).
  373. Fixes for lib/GL Imakefiles (Marc La France).
- 372. Update DRI drivers sunffb,mga,i810,glint,r128,tdfx to check for 
+ 372. Update DRI drivers sunffb,mga,i810,glint,r128,tdfx to check for
       DRIQueryVersion, overcomes an older libdri issue (Alan Hourihane).
  371. Change tdfx driver to use fb instead of cfb (Alan Hourihane).
  370. Make using libpthread optional for OpenBSD 2.7.
@@ -4122,7 +6103,7 @@
  233. Separate offscreen memory manager API from implementation to facilitate
       driver replacement of the default manager (Mark Vojkovich).
  232. Add Option "TexturedVideo" to have the Matrox driver optionally use
-      YUV textures instead of the video overlay for XvImage support 
+      YUV textures instead of the video overlay for XvImage support
       (Mark Vojkovich).
  232. Add Xv functions for allocating/freeing XvVideoAdaptorRecs to shield
       drivers from structure size changes (Mark Vojkovich).
@@ -4143,7 +6124,7 @@
       directly to avoid problems with certain notebook bioses (Egbert Eich).
  223. Fixed mouse driver to flush pending button press events on
       protocol change (Egbert Eich).
- 222. Fixed DDC support and sync flags handling in trident driver 
+ 222. Fixed DDC support and sync flags handling in trident driver
       (Egbert Eich).
  221. Added PAM support to xdm, ANSIfied prototypes (Werner Fink).
  220. Added ServerFlag to force the use of OS PCI config space
@@ -4159,7 +6140,7 @@
  215. Fix a typo in the glint driver (#3943, Michael Schimek).
  214. Fix multithread bug in Xlib big font support (Mark Vojkovich).
  213. Fix a window class initialization problem in Xinerama (Mark Vojkovich).
- 212. Fix some multithreading related problems in the Xv client library 
+ 212. Fix some multithreading related problems in the Xv client library
       (Mark Vojkovich).
 
 XFree86 4.0b (23 May 2000)
@@ -4242,7 +6223,7 @@
       (#3895, Andrew Aitchison).
  164. Fix a window unmapping bug in the mioverlay code (Mark Vojkovich).
  163. Attempt to improve memory detection reliability in the Matrox driver
-      (Mark Vojkovich). 
+      (Mark Vojkovich).
  162. Fix possible SEGV in generic int10 module (Marc La France).
  161. Fix *BSD aperture driver to allow for int10 (Bernd Ernesti,
       Marc La France).
@@ -4290,7 +6271,7 @@
  135. Fixed CyberShadow option in Trident driver (Egbert Eich).
  134. Fix bug where the cursor is not put back after a failed DGA mode
       initialization attempt (Mark Vojkovich).
- 133. Add a missing symbol "AllocateColormapPrivateIndex" (Mark Vojkovich). 
+ 133. Add a missing symbol "AllocateColormapPrivateIndex" (Mark Vojkovich).
  132. Remove Intel 440BX-specific resources from os-support layer
       (Marc La France).
  131. Change ATI driver to mark VGA resources as unused in operating state when
@@ -4327,7 +6308,7 @@
       Changed int10 code to always map/allocate entire 1Meg. (Egbert Eich)
  109. Let int10 code try harder to locate a video bios to work
       around some system bios bugs. (Holger Veit, Egbert Eich)
- 108. Modified fbdevProbe() to return the name string representing 
+ 108. Modified fbdevProbe() to return the name string representing
       the chipset. (Egbert Eich)
  107. Minor fixes to i810 driver (Egbert Eich)
  106. Fixed format of float numbers in C&T driver. (Jens Taprogge)
@@ -4385,7 +6366,7 @@
   78. Fix an infinite loop problem that can show up in makedepend (#3838, A.10,
       Jeremy Buhler).
   77. Fix Overlay support in the TI ramdac module (Alan Hourihane).
-  76. Fix mixup between TVP3026/3030 ramdacs in the ramdac module 
+  76. Fix mixup between TVP3026/3030 ramdacs in the ramdac module
       (Alan Hourihane).
   75. Increase usage of ReadPixmap within XAA (Mark Vojkovich).
   74. Allow the v4l driver to use offscreen YUV surfaces exported by the
@@ -4494,7 +6475,7 @@
   24. Fix some man page formatting problems that show up on some platforms
       (David Dawes).
   23. Fix an 8+24 bug that occured when shared memory pixmaps were used as
-      tiles (Mark Vojkovich). 
+      tiles (Mark Vojkovich).
   22. Support for the Trident CyberBlade/DSTN/i1 (Alan Hourihane).
   21. Fix Xinerama problems that occured when screen zero was not at (0,0)
       (Mark Vojkovich).
@@ -5058,13 +7039,13 @@
       keycodes file (David Dawes).
 3683. Allow the passing of all extended keycodes, which makes it possible
       to access keys on "Internet" keyboards (David Dawes).
-3682. Added support for saving/restoring access state during 
+3682. Added support for saving/restoring access state during
       asynchronous events. Added code to make xf86EnableAccess()
       atomic for asynchronous events. (Egbert Eich)
 3681. Modified xf86EnterServerState() to avoid any unnecessary
       disabling of resources during state transition. (Egbert Eich)
 3680. Added function callback registration. Drivers can register
-      callback functions to be notified of the start/end of a 
+      callback functions to be notified of the start/end of a
       resource transition. (Egbert Eich)
 3679. Added support for OS specific Pci address windows. (Egbert Eich)
 3678. Added more debug traps to xalloc.c. Added support to peek/poke
@@ -5079,7 +7060,7 @@
 3674. Modified mapping of V_RAM in int10/generic.c. (Egbert Eich)
 3673. Updated INT10.HOWTO. (Egbert Eich)
 3672. Added support for VBE DDC read out to s3v driver. (Egbert Eich)
-3671. Added xf86SetDDCProperties() to glint, chips, neomagic, s3v 
+3671. Added xf86SetDDCProperties() to glint, chips, neomagic, s3v
       and r128 driver. (Egbert Eich)
 3670. Fixed problems with virtual screen size != real screen size
       when using shadow fb in mga driver. (Egbert Eich)
@@ -5108,7 +7089,7 @@
       (Egbert Eich)
 3655. Fixed xf86HWCurs.c to handle 32-bit cursors on 64-bit machines
       correctly. (Egbert Eich)
-3654. Added rotate support to neomagic, s3v, chips and cirrus 
+3654. Added rotate support to neomagic, s3v, chips and cirrus
       driver (Egbert Eich)
 3653. Added shadow fb support to s3v and cirrus driver (Egbert Eich)
 3652. Fixed sig11 problem after server reset caused by the new
@@ -5319,14 +7300,14 @@
 3534. Fix for various compilation glitches (Marc La France).
 3533. Fix some Segmentation faults with NULL pointers in xf86Config.c
       (Alan Hourihane).
-3532. Update some drivers to respect the PROBE_DETECT flag and update 
+3532. Update some drivers to respect the PROBE_DETECT flag and update
       xf86DoProbe to print out the supported chipset list (Alan Hourihane).
 3531. Update Trident driver to fix Clock source for 9440 chips and allow
       linear framebuffer mapping for nommio (Alan Hourihane).
 3530. Fix fb for module compiling and ifdef fbcmap for now (Alan Hourihane).
 3529. Add Cyber9397 and Cyber9397DVD PCI ID detection to trident driver
       (Alan Hourihane).
-3528. Fix Multiple MX RegisterResources with RAC in glint 
+3528. Fix Multiple MX RegisterResources with RAC in glint
       driver (Alan Hourihane).
 3527. Update loader for Xinerama changes (Alan Hourihane).
 3526. Massive Xinerama rewrite (Mark Vojkovich).
@@ -5334,7 +7315,7 @@
       - Remove broken Xinerama code from the multibuf extension.
       - Add support for shared memory pixmaps.
       - Lessen Xinerama's impact on DIX.
-3525. Point and arc acceleration improvements for the NVIDIA driver 
+3525. Point and arc acceleration improvements for the NVIDIA driver
       (Mark Vojkovich).
 3524. MGA acceleration modifications to prevent pci retries during
       color expansions (Mark Vojkovich).
@@ -5433,7 +7414,7 @@
       Xprint (#3432, Thomas Dickey).
 3363. Add proper clock checking for VidMode extension, add SDK fixes for
       missing files, add SilkenMouse for C&T driver (#3424, David Bateman).
-3362. Sync v4l and glint drivers with the new Xv changes (Mark Vojkovich). 
+3362. Sync v4l and glint drivers with the new Xv changes (Mark Vojkovich).
 3361. Add XvImage support to the MGA driver - G200/400 only (Mark Vojkovich).
 3360. Xv changes/additions (Mark Vojkovich)
       - XvImage support in the Xv DDX, DIX, client libs and header files.
@@ -5450,7 +7431,7 @@
 XFree86 3.9.16e (5 December 1999)
 3355. Fix a problem with the bitmap font module (#3421, Matthieu Herrb).
 3354. Misc. bug/typo fixes. (Egbert Eich)
-3353. Fixed scanpci to generate better output on Alphas (Harald Koenig, 
+3353. Fixed scanpci to generate better output on Alphas (Harald Koenig,
       Egbert Eich)
 3352. Added initial VESA VBE support. This includes initialization
       and DDC. (Egbert Eich)
@@ -5462,7 +7443,7 @@
 3348. Added a function to check if any resource needs to share memory.
       Required for DGA. (Egbert Eich)
 3347. Added copyright messages to int10 code. Fixed int10 code to
-      run on Alphas. 
+      run on Alphas.
 3346. Changed some byte and word access to MMIO registers in drivers
       to use MMIO_READ/WRITE8/16(). Made attempt to make some drivers
       64 bit (and Alpha!) clean: s3virge, chips, gling, neomagic.
@@ -5471,8 +7452,8 @@
 3344. Cleanups in the C&T driver. (Egbert Eich)
 3343. Clearified meaning of VIDMEM_MMIO and VIDMEM_MMIO_32BIT. (Egbert Eich)
 3342. Added support for host-PCI bridges. (Egbert Eich)
-3341. Changed policy for removing resource overlaps. 
-      Removed a bug in findIntersect() (xf86Bus.c). 
+3341. Changed policy for removing resource overlaps.
+      Removed a bug in findIntersect() (xf86Bus.c).
       Added function that enables/disables all resources of a given
       screen. Added a config file option to set overlap removal
       aggressiveness.(Egbert Eich)
@@ -5499,13 +7480,13 @@
       output or both. Add support for Graphire models. Change wacom init
       phase to use new Xoff option (#3391, Frederic Lepied).
 3326. Change the SwapAxes option to SwapXY in elographics/microtouch driver
-      to match an already existing option in the Dynapro driver. Add a Focus 
+      to match an already existing option in the Dynapro driver. Add a Focus
       class capability to the elographics driver (#3395, Patrick Lecoanet).
 3325. Update mouse rate handling (#3388, Harald Koenig).
 3324. Fix NULL pointer dereference in misprite.c (#3380, Edward Wang).
 3323. Add FBDev and ShadowFB support to glint driver. Add new option
       "NoWriteBitmap" (#3383, Michel Daenzer).
-3322. Update SuperProbe to handle S3 Savage4, Savage200 and clean up 
+3322. Update SuperProbe to handle S3 Savage4, Savage200 and clean up
       Trio3D/Savage3D detection (#3382,3384 Harald Koenig).
 3321. Add new framebuffer code and tiny X DDX architecture (#3379,
       Keith Packard).
@@ -5536,7 +7517,7 @@
 3300. Enable SIGIO support on LynxOS (#3339, Thomas Mueller).
 3299. Get TRUE defined in sigio.c. Fix xterm compile problem on ISC
       (#3338, Michael Rohleder).
-3298. Correct DPMS suspend/standby modes for 3dfx driver (#3336, 
+3298. Correct DPMS suspend/standby modes for 3dfx driver (#3336,
       Henrik Harmsen)
 3297. Xterm patch #119 (#3335, Thomas Dickey).
 3296. ATI LCD changes to add interlaced mode support and near-final rework of
@@ -5545,7 +7526,7 @@
       so they can be displayed by xf86PrintModes() (Marc La France).
 3294. Add sync polarities to VESA modes (Marc La France).
 3293. Fix VESA mode typos and some warnings (Marc La France).
-3292. Add GeForce/Quadro support to the NVIDIA driver (Chas Inman, 
+3292. Add GeForce/Quadro support to the NVIDIA driver (Chas Inman,
       Mark Vojkovich).
 3291. Fix a DGA colormap problem (Mark Vojkovich).
 3290. Disable the Double-Buffer extension in Xinerama mode since it
@@ -5577,7 +7558,7 @@
 3276. NVIDIA driver changes (Mark Vojkovich):
       - Improved shadowfb support (screen rotation).
       - Improved acceleration (color expansion, lines).
-      - Fixed some rendering correctness issues. 
+      - Fixed some rendering correctness issues.
       - Full DGA 2.0 support including changing depth on the fly.
 3275. Make usage of hardware clipping in XAA more consistent (Mark Vojkovich).
 3274. Limit MGA driver to using 16 Meg of ram to workaround some hardware
@@ -6042,7 +8023,7 @@
 2931. Add SuperProbe for NetBSD 1.4 wscons (#3083, Matthias Drochner).
 2930. Fix button and modifier key state problems in DGA (#3082,
       Mark Vojkovich).
-2929. Avoid a possible segmentation fault in "xsm" which, for example, 
+2929. Avoid a possible segmentation fault in "xsm" which, for example,
       occurs local hostname can't be resolved (#3073, Matthias Scheler).
 2928. ATI driver updates, including:
         - Add preliminary panel support.
@@ -7262,7 +9243,7 @@
       Brown).
 
 XFree86 3.9Pb (20 February 1999)
-2265. Allow YaccCmd to be overridden in host.def (#2474-2476, 
+2265. Allow YaccCmd to be overridden in host.def (#2474-2476,
       Christopher Sekiya).
 2264. Implement null overscans in VGA, minor fixups to VGA generic
       default mode, re-add #ifndef's in VGA generic driver erroneously
@@ -7280,7 +9261,7 @@
 2257. Correct some typos/grammatical problems with the DESIGN doc (Ivan Bach).
 2256. Fix a crash when PciAccInfo isn't initialized (#2468, Alan Hourihane).
 2255. Add SiS530 detection to the SiS driver. Clock programming,
-      acceleration and hw cursor are not implemented, yet (Dirk Hohndel). 
+      acceleration and hw cursor are not implemented, yet (Dirk Hohndel).
 2254. Fix some bugs related to hardware clipping of spans. XAA
       WideLine speedups when hardware clipping is available (#2467
       Mark Vojkovich).
@@ -7291,10 +9272,10 @@
       base needs more work (Dirk Hohndel).
 2251. Remove obsolete xf86[GS]etDefaultColorVisualClass() and fix some
       small typos and comments; make type of BIOS, Memory and I/O
-      bases consistent (#2460,2465 Marc LaFrance). 
+      bases consistent (#2460,2465 Marc LaFrance).
 2250. Add ScanlineCPUToScreen for TX/MX and older Permedia chipsets
-      for when PCI retries are not enabled (#2459,2461,2462,2463 
-      Alan Hourihane). 
+      for when PCI retries are not enabled (#2459,2461,2462,2463
+      Alan Hourihane).
 2249. Add 24/8 overlay support for 3Dlabs chipsets and switch to MMIO
       for vga access (#2459, Alan Hourihane).
 2248. Add 24/8 overlay support to IBM526 and IBM640 ramdacs, fix IBM640 hw
@@ -8158,7 +10139,7 @@
       problems that can show up when using more than 4MB.
 1788. Fix an extraneous pixel drawn for some H/V two point lines with
       a Millennium I (Mark Vojkovich).
-1787. Make the BuildLinuxDoc* symbols default to YES when HasSgmlFmt is YES 
+1787. Make the BuildLinuxDoc* symbols default to YES when HasSgmlFmt is YES
       (Marc La France).
 1786. Add a resize function to the offscreen memory manager (#1937,
       Mark Vojkovich).
@@ -8176,7 +10157,7 @@
         - add configure test to infer if xterm should be installed setuid
           based on previously installed xterm (reported by Stephen Marley).
         - integrate/extend patch by Jason Bacon to implement quasi-continuous
-          mouse reporting. 
+          mouse reporting.
         - correct control sequences transmitted by function keys F1 to F4
           when sunFunctionKeys resource is true (it was still using the
           VT100 control sequences).
@@ -8403,7 +10384,7 @@
       m68k's XF68_FBDev to use backing store low-level functions to
       save/restore the screen during VT switches. Minor fixup to loader
       message. (#1719, Marc La France).
-1688. Fixes for 24bpp and 32bpp on Matrox Millenium II. This fixes the 
+1688. Fixes for 24bpp and 32bpp on Matrox Millenium II. This fixes the
       horizontal stripe for modes using > 4MB (#1715,1716, Doug Merritt).
 1687. Fix build problems on LynxOS and enable keyboard LEDs on LynxOS 2.5.1
       (1712, Thomas Mueller).
@@ -8425,7 +10406,7 @@
 1679. Fix hw cursor on CT65555 and fix loader problem (#1688,1689 Nozomi Ytow).
 1678. Fix freeing of names when removing modes (#1685, Matthieu Herrb).
 1677. Enable ImageWrite in 24 bpp for C&T HiQV (#1684,1687 Nozomi Ytow).
-1676. Fix unknown symbol type 1e message in a.out loader (#1683, 
+1676. Fix unknown symbol type 1e message in a.out loader (#1683,
       Matthieu Herrb).
 1675. xterm patches 75 and 76. Fix for print-window function, minor cleanups,
       lots of fixes from other people (see xterm.log.html) (#1681,1682,
@@ -8436,7 +10417,7 @@
 1673. Change PIC code to print names of ALL devices capable of displaying
       video. Return pointer to the last card instead of the first (#1662,
       Dejan Ilic).
-1672. Add skeleton driver for Tritech Pyramid 3D (#1661, Dejan Ilic, 
+1672. Add skeleton driver for Tritech Pyramid 3D (#1661, Dejan Ilic,
       Mark Vojkovich).
 1671. Check additional pci bus in scanpci (Robin Cutshaw).
 
@@ -8519,7 +10500,7 @@
       some of the warnings produced by gcc by default. Resync ATI driver with
       the version found in XFree86 3.3.2. Fix loader bug in dealing with XAA.
       (#1614, Marc La France).
-1630. Don't abort a static server if the Driver statement in the Device 
+1630. Don't abort a static server if the Driver statement in the Device
       section is missing (#1613, Kazutaka Yokota).
 1629. Fix typo in #1606 and improve printing of mouse related messages
       (#1613, Kazutaka Yokota).
@@ -8554,12 +10535,12 @@
       documentation nits. correct the problem in xterm with utmp by removing
       the reset of setuid/setgid before the main event loop (#1525,1571,1599,
       Thomas Dickey).
-1616. Change s3/svga from using 8x8 pattern fills to 8x8 color expand fills. 
+1616. Change s3/svga from using 8x8 pattern fills to 8x8 color expand fills.
       Add support for S3's type planar 8x8 pattern fills to XAA. Add support
       for S3's planar 8x8 fills to the XAA stippled trapezoid stuff
       (#1594,1595,1596,1597, Mark Vojkovich).
 1615. Ensure the correct message for lines at startup (#1591, Alan Hourihane).
-1614. Fix XAA to allow vertical lines using TwoPointLine (#1590, 
+1614. Fix XAA to allow vertical lines using TwoPointLine (#1590,
       Alan Hourihane).
 1613. Change the xf86orect.c code to always use a hardware filled rect rather
       than a software one when drawing vertical lines (#1589, Mark Vojkovich).
@@ -8570,10 +10551,10 @@
       twopoint line problems with XAA dashed lines. Make sure we alway check
       for one rect situations when using XAA polygon code (#1575,1576,1577,
       1578,1579,1580,1581, Mark Vojkovich).
-1611. Add new MGA acceleration, including image writes and 8x8 pattern trap 
-      fills. Go back to two point lines. Add solid filled span replacement. 
-      Make PCI retries off for mga by default (need Option "pci_retry" to turn 
-      them on).  Make hardware cursor work better in doublescan modes.  And 
+1611. Add new MGA acceleration, including image writes and 8x8 pattern trap
+      fills. Go back to two point lines. Add solid filled span replacement.
+      Make PCI retries off for mga by default (need Option "pci_retry" to turn
+      them on).  Make hardware cursor work better in doublescan modes.  And
       turn hw cursor on by default (#1582,1583,1592 Mark Vojkovich).
 1610. Removes assumption that we have a Trapezoid function (#1573,
       Alan Hourihane).
@@ -8602,10 +10583,10 @@
       Remove dependence on TimingTab. Include VGA DAC registers in verbose
       output. Skip sparse I/O probes when PCI configuration space indicates a
       device has registered a block I/O base. Virtual X rounding adjustments
-      for packed modes. Documentation updates (#1430, Marc La France). 
+      for packed modes. Documentation updates (#1430, Marc La France).
 1601. Clean up ScrnInfo, make vgaCloseScreen call the framebuffer's
       CloseScreen() function, determine more pricely whether the virtual
-      resolution fits in video memory, minor optimization of cfb's 
+      resolution fits in video memory, minor optimization of cfb's
       ImageGlyphBlt entry (#1428,1429, Marc La France).
 1600. Fix typo in mga.h (#1418, Tim Rowley).
 1599. Fix some baserom/_baserom confusion (#1407, Gary Barton/Concurrent).
@@ -8618,7 +10599,7 @@
 1593. Build fixes to loader directory (#1388, Alan Hourihane).
 1592. Some Link Kit fixes (#1384, David Bateman).
 1591. Add zoom initialization and fix blits on T2R (Robin Cutshaw).
-1590. Add support for several new mice, including Kensington ThinkingMouse, 
+1590. Add support for several new mice, including Kensington ThinkingMouse,
       ALPS GlidePoint, Genius NetScroll, Genius NetMouse, Genius NetMouse,
       ASCII MieMouse, Logitech MouseMan+, Logitech FirstMouse+ (#1380,
       Kazutaka Yokota).
@@ -8637,7 +10618,7 @@
 1590. Reinstate Xserver/hw/ibm for reference purposes.
 1589. Cirrus and vga256 driver changes to support the PowerPC machines.
       (1357, Gary Barton/Concurrent).
-1588. Organize xf86_ansic.h/xf86_libc.h/xf86_OSlib.h, and de-mangle xf86* 
+1588. Organize xf86_ansic.h/xf86_libc.h/xf86_OSlib.h, and de-mangle xf86*
       libc calls. Move Probe routine to the beginning of the ScrnInfoRec to
       match the vgaVideoChipRec. Make the mach32, mach64, mach8, i128, and
       ibm8514 servers loadable. Use one global byte_reversed array. When
@@ -8664,7 +10645,7 @@
       Kevin Martin).
 1579. Fix 16bpp for the Permedia 2 (#1373, Alan Hourihane).
 1578. Fix DPMS for Trident cards (#1372, Alan Hourihane).
-1577. Add Option "no_pci_retry" to option code and the MGA driver (#1370,1371, 
+1577. Add Option "no_pci_retry" to option code and the MGA driver (#1370,1371,
       Mark Vojkovich).
 1576. Add back CyberCont that was removed from Trident driver in 3.9Ac by
       mistake (#1369, Alan Hourihane).
@@ -8672,7 +10653,7 @@
       of bad alignment (#1368, Mark Vojkovich).
 1574. xterm updates (#1366,1378 Thomas Dickey) including:
       - change the terminfo entry so that rs1 does a hard reset
-      - modify treatment of hard reset by the xterm program to reset the saved 
+      - modify treatment of hard reset by the xterm program to reset the saved
         lines
       - correct hard reset by also resetting user-defined keys.
       - change the way highlihting is implemented
@@ -8783,7 +10764,7 @@
       newer chips. Support for AGP RagePro cards. Block write mode for
       RagePro chips. 1600x1200 mode support for VT and newer chips. Use the
       auxilliary register aperture on chips that support it. Use 16MB memory
-      aperture on PCI Mach64s with integrated controllers. 
+      aperture on PCI Mach64s with integrated controllers.
       (#1288, Kevin Martin).
 1519. New code for the glint server. Preliminary support for the Permedia 2
       hardware cursor. Preliminary support for panning the display with
@@ -8791,7 +10772,7 @@
       Cleanup of glint_init.c. Fix DGA when using software cursor. Addition
       of code to not save VGA state if the VGA core is disabled.
       (#1285,1286,1287, Alan Hourihane).
-1518. Fix the "invalid depth" problem with packed 24 (#1284, Andrew Aitchison). 
+1518. Fix the "invalid depth" problem with packed 24 (#1284, Andrew Aitchison).
 1517. Fixes to finish keyboard layout (Johan Myreen).
 
 XFree86 3.9z (14 December 1997)
@@ -8800,7 +10781,7 @@
       to test the first 8MB, only (#1280, Mark Vojkovich).
 1515. Fix XF86Setup to create a (symbolic) link of /usr/X11R6/bin/X when it
       doesn't exist (#1279, Matthieu Herrb).
-1514. Fix solid trap/rect fill bugain the mga server for the Millennium II 
+1514. Fix solid trap/rect fill bugain the mga server for the Millennium II
       that was hurting performance severely (#1277, Mark Vojkovich).
 1513. Reenable BitBlt accelerations for Millennium II (#1271, Mark Montague).
 1512. Fix mmap memory leak in IGS driver. ARM32/NetBSD specific fix for
@@ -8858,7 +10839,7 @@
        mistake from the s3/svga acceleration code (#1237, Mark Vojkovich).
 1478. Switch the MGA driver over to XAA Hardware Cursor. Only support for
       TVP3026 is included (#1236,1239, Mark Vojkovich).
-1477. Add delayed syncing abd faster arcs ub 8bpp to mga driver (#1235, 
+1477. Add delayed syncing abd faster arcs ub 8bpp to mga driver (#1235,
       Mark Vojkovich).
 1476. Fix another SIGSEGV in xterm, where wrong assumptions about the type of
       widget passed to an action handler were made (#1234, Thomas Dickey,
@@ -8867,7 +10848,7 @@
       pixels to the possible width of the cursor (#1232, Bryan Feir).
 1474. Remove vga256/vgainit (#1231, Mark La France).
 1473. Fix a namespace collision in Mach8 server (#1230, Mark La France).
-1472. Fix SIGSEGV when some internal xterm buffers overflowed (#1228, 
+1472. Fix SIGSEGV when some internal xterm buffers overflowed (#1228,
       Thomas Dickey).
 1471. Fix HiQV version of ImageWrite in the C&T driver (#1222,1223,
       David Bateman).
@@ -8878,7 +10859,7 @@
       (#1215, Koen Gadeyne).
 1467. Complete initial support for Permedia 2 and add some acceleration for it
       (Alan Hourihane).
-1466. Some more code for supporting the IBM RGB640 in the glint server 
+1466. Some more code for supporting the IBM RGB640 in the glint server
       (Dirk Hohndel).
 
 XFree86 3.9x (23 November 1997)
@@ -8904,7 +10885,7 @@
       Alan Hourihane).
 1452. Cleanups and preliminary support for the Trident 3DImage975 and
       3DImage985 (#1206, Alan Hourihane).
-1451. Add stipple acceleration to the tseng driver (#1192, Koen Gadeyne, 
+1451. Add stipple acceleration to the tseng driver (#1192, Koen Gadeyne,
       Mark Vojkovich).
 1450. Add better text acceleration to the tseng driver (#1190, Koen Gadeyne).
 1449. Fix HiQV image writes (#1191, David Bateman).
@@ -8992,9 +10973,9 @@
 1395. Fix references to LINE_MAX in Xos_r.h (#1182, Sekhar Makkapati).
 
 XFree86 3.9v (9 November 1997)
-1394. Add unrolled text code for the 9 pixel width fonts (#1147, 
+1394. Add unrolled text code for the 9 pixel width fonts (#1147,
       Mark Vojkovich).
-1393. Fix planemask/transparency problems in tseng driver (#1146, 
+1393. Fix planemask/transparency problems in tseng driver (#1146,
       Harald Nordgard Hansen).
 1392. Add Fire GL 3000 option for glint server (#1139, Bart van den Broek).
 1391. Remove unnecessary ARM32 code (#1138, Katrina Maffey).
@@ -9019,12 +11000,12 @@
 1378. Fix a problem with setting the maximum clock value on s3 cards at depths
       other than 8bpp (#1123, Steve Forsythe).
 1377. Fix dashed lines for matrox driver (#1122, Radek Kapitan).
-1376. Use correct arguments to xf86ImageWrite when uploading cursor image to 
+1376. Use correct arguments to xf86ImageWrite when uploading cursor image to
       videoram. Units of pixels instead of bytes (#1120, Mark Vojkovich).
 1375. Fix s3/svga cursor location computation error (#1119, Mark Vojkovich).
 1374. Improve GC validation code in XAA (#1117,1118,1121, Mark Vojkovich,
       David Bateman).
-1373. Add accelerated color expansion for all color depths and for all 
+1373. Add accelerated color expansion for all color depths and for all
       W32-style chips (#1116, Koen Gadeyne).
 1372. Add Warpnext/Warpprev to twm (#1114, Benjamin Gras).
 1371. One more fix to restore changes to variable types made in change 1347.
@@ -9039,8 +11020,8 @@
 1367. Compile fixes for ARM32/NetBSD (#1099, Katrina Maffey).
 1366. Change mga to use bresenham lines instead of two point (#1098,
       Radek Kapitan).
-1365. Add mga stipple code so that it is 256K pixels barrier sensible and 
-      even faster than current XAA stipple code (#1097, Mark Vojkovich, 
+1365. Add mga stipple code so that it is 256K pixels barrier sensible and
+      even faster than current XAA stipple code (#1097, Mark Vojkovich,
       Radek Kapitan).
 1364. Move C&T hw cursor into XAA. Re-enable ImageWrite on C&T. Rewrite 32bpp
       HiQV code (should be almost usable) (#1096, David Bateman).
@@ -9048,12 +11029,12 @@
       setting (#1095, George Krajcsovits).
 1362. Changes to XAA hw cursor code to better support switching between hw
       and sw cursor (#1094, David Bateman).
-1361. Fix incorrect parenthesis placement caused by hand-applying part of 
+1361. Fix incorrect parenthesis placement caused by hand-applying part of
       change 1347 (#1092, Mark Vojkovich).
 1360. Resync PC98 Imakefiles (#1091, Takaaki Nomura).
 1359. Build fix for PANIX (#1090, Takaaki Nomura).
-1358. Fix a duplicate inclusion of <sys/termio.h> on ISC inside xterm/screen.c 
-      and update the help text for xterm to correspond with the appropriate 
+1358. Fix a duplicate inclusion of <sys/termio.h> on ISC inside xterm/screen.c
+      and update the help text for xterm to correspond with the appropriate
       commandline switches (#1089, Michael Rohleder).
 1357. Fix some incorrect type modifications in change 1347 (#1087,1088
       Alan Hourihane, Michael Rohleder).
@@ -9103,21 +11084,21 @@
       Extension and XF86Setup (#1063,1064, Takaaki Nomura, Joe Moss).
 1328. Add Scanline ImageWrite support to XAA (#1062, Alan Hourihane).
 1327. Missing Millennium II AGP fixes (#1058, Brian Wainscott).
-1326. XAA hw cursor fix. Delay cursor restoration until after the saved screen 
+1326. XAA hw cursor fix. Delay cursor restoration until after the saved screen
       is restored (#1057, Mark Vojkovich).
 1325. Fix server to print the clock scale instead of effective clocks when
       using a clockchip (#1056, Krajcsovits Gyorgy).
 1324. Correct eraser/stylus detection in wacom driver (#1055, Frederic Lepied).
 1323. Fixes for APM driver. HW lines/HW clipping. ROP support. Text accel now
-      uses PAD_DWORD. Bugfix for WaitForFifo() (lost serial interrupts) and 
-      ApmSync() (various errors). HW cursor now uses XAA interface. Combined 
+      uses PAD_DWORD. Bugfix for WaitForFifo() (lost serial interrupts) and
+      ApmSync() (various errors). HW cursor now uses XAA interface. Combined
       write for many registers (x+y in one longword etc.) (#1054, Henrik
       Harmsen).
 1322. xterm fixes. Correct a minor placement problem with the right scrollbar.
       Implement a new set of control sequences for switching between the
       normal and alternate VT100 screens. Implement the alternate-screen menu
       entry (#1053, Thomas Dickey).
-1321. Add some reasonable limit for when a trapezoid fill is used rather than 
+1321. Add some reasonable limit for when a trapezoid fill is used rather than
       using spans (#1051, Mark Vojkovich).
 1320. Add bindist description files for an OpenBSD/sparc binary distribution
       (#1045, Todd Fries).
@@ -9135,15 +11116,15 @@
       right-scrollbar to xterm (#1037, Thomas Dickey, Michael Rohleder).
 1312. Add GD7555 to vgaPCI.h and fix XF98_SVGA (#1036, Shuichi Ueno).
 1311. Fix a bug with Qword pad support in ImageWrite (#1033, Mark Vojkovich).
-1310. Fix mystique driver and build problem on SVR4.0 (#1029, Takaaki Nomura, 
+1310. Fix mystique driver and build problem on SVR4.0 (#1029, Takaaki Nomura,
       Isao Ohishi).
 1309. Fix SuperProbe to correctly detect memory on the Trident 9685 (#1023,
       Alan Hourihane).
-1308. Add hardware clipping and transparency for the trident chips that 
+1308. Add hardware clipping and transparency for the trident chips that
       support it. Partially implement the 'set_mclk' option, not yet
       complete, remove the tgui_mclk_66 option, clean up the TV output for
       9685 boards. Documentation updates (#1022, Alan Hourihane).
-1307. Add accelerated ImageWrite and a WriteBitmap replacement to the tseng 
+1307. Add accelerated ImageWrite and a WriteBitmap replacement to the tseng
       driver (#1021, Mark Vojkovich, Koen Gadeyne).
 1306. Documentation update for tseng driver (#1020, Koen Gadeyne).
 1305. Clear disallowed flags in Options bitmap (#1019, Alan Hourihane).
@@ -9181,7 +11162,7 @@
       cursors need to be implemented/verified. S3 builtin curser seems
       to work in 8bpp, but fails in other depths (#992, Mark Vojkovich).
 1283. Some fixes for Unixware 2.1.2 (#989, Steve Forsythe).
-1282. Fix the remaining line drawing problems for the CL-GD5428 and CL-GD754x 
+1282. Fix the remaining line drawing problems for the CL-GD5428 and CL-GD754x
       chips (#985, Corin Anderson).
 1281. Fix build problem (982, Takaaki Nomura).
 1280. Add more acceleration for Permedia (this is partly producing drawing
@@ -9198,20 +11179,20 @@
 1274. Add XF98_SVGA server, update XF98Conf.cpp, VideoBoard98, fix mga driver
       for PC98 (#980,981, Michio "Karl" Jinbo, Shuichirou Urata).
 1273. Some fixes to glint server (Helmut Fahrion, Stefan Dirsch, Dirk Hohndel).
-1272. Fix for glint_dump_regs and disable accelerated lines for glint 
+1272. Fix for glint_dump_regs and disable accelerated lines for glint
       (Stefan Dirsch).
-1271. Add XAA hw cursor support and update trident and glint drivers to use it 
+1271. Add XAA hw cursor support and update trident and glint drivers to use it
       (#973-976,979, Alan Hourihane).
-1270. Several fixes to xterm: fix redraw errors after font changes or resizes, 
+1270. Several fixes to xterm: fix redraw errors after font changes or resizes,
       add sunKeyboard resource, correct fg/bg test in the control sequence
       that replies with the current SGR settings ((#972, Thomas Dickey).
-1269. Several fixes to the xterm standalone configure script (#972, 
+1269. Several fixes to the xterm standalone configure script (#972,
       Thomas Dickey).
 1268. Fix to pointer movement constraints (#968, Stuart Anderson).
 
 XFree86 3.9p (15 September 1997)
 1267. Disable Image Write for HiQV chips in C&T driver (#966, David Bateman).
-1266. Add stipple accelerated functions through the ScanlineScreenToScreen 
+1266. Add stipple accelerated functions through the ScanlineScreenToScreen
       function (#965, Alan Hourihane).
 1255. Add ImageWrite support for the Laguna chips in cirrus driver (#964,
       Corin Anderson).
@@ -9221,7 +11202,7 @@
 1251. Fix Linux-axp xdm build problem.
 1250. Fix stripping of extension from module names (so that it works OK
       when there is a '.' in the module directory pathname).
-1249. Fix some problems in the trident driver with the 9685 programmable clock 
+1249. Fix some problems in the trident driver with the 9685 programmable clock
       and disable the GE when too little memory is available (#950,
       Alan Hourihane).
 1248. Fix build problem with non gcc compilers (#948,949, Takaaki Nomura,
@@ -9232,7 +11213,7 @@
 1245. Fix saving video memory for glint server (Helmut Fahrion).
 
 XFree86 3.9o (9 September 1997)
-1244. Yet another fix for the problems around installing xkbcomp 
+1244. Yet another fix for the problems around installing xkbcomp
       (Michael Rohleder, David Dawes, Dirk Hohndel).
 1243. Add more acceleration for 500TX to glint server (Alan Hourihane).
 1242. Add initial acceleration for Permedia to glint server (Dirk Hohndel).
@@ -9250,8 +11231,8 @@
 1235. Fix 24bpp XAA NonTE image text with RGB_EQUAL (#942, David Bateman).
 1234. Fix BIOS layout issues in matrox drivers. This might make Millennium
       Rev 3 cards work (#941, Andrew van der Stock).
-1233. Improve the performance of the 24bpp fills on the 6554x machines and 
-      hopefully implements a solid fill at 32bpp for the 6555x machines 
+1233. Improve the performance of the 24bpp fills on the 6554x machines and
+      hopefully implements a solid fill at 32bpp for the 6555x machines
       (untested). Some cosmetic changes (#940,944, David Bateman).
 1232. Turn off CPU_TRANSFER_BASE_FIXED in SVGA/S3 driver (#939, Mark Vojkovich).
 1231. Add the correct Enable/DisableIO Ports back into the glint driver (#938,
@@ -9265,11 +11246,11 @@
 1227. Fix MClk limits for matrox driver (#931, Andrew van der Stock).
 1226. Fix build problem on Solaris (#929, Matthieu Herrb).
 1225. Add DacSpeed to C&T driver (#930, David Bateman).
-1224. Disable acceleration for IMA bus chips in tseng driver (#928, 
+1224. Disable acceleration for IMA bus chips in tseng driver (#928,
       David Bateman)
 1223. Turn Record extension into module and fix problems in XInput joystick
       module (#927,933, Matthieu Herrb).
-1222. Add support for the ch8398 and ch8398a clockchips to the tseng driver 
+1222. Add support for the ch8398 and ch8398a clockchips to the tseng driver
       (#913,914 Gyorgy Krajcsovits).
 
 XFree86 3.9n (26 August 1997)
@@ -9279,13 +11260,13 @@
       cards with IMA bus. Modify linear memory code (#910, Koen Gadeyne).
 1218. Fix locale in R6.3, Fix PC98 XKB, Remove xf86ClearIOPortList() and
       xf86AddIOPorts() from PEGC driver (#908, Takaaki Nomura, Isao Ohishi).
-1217. Remove xf86ClearIOPortList() and xf86AddIOPorts() (#907,909 
+1217. Remove xf86ClearIOPortList() and xf86AddIOPorts() (#907,909
       Matthieu Herrb).
 1216. Add ET6100 support to tseng driver (#906, Koen Gadeyne).
 1215. Add wide lines to XAA (#904, Mark Vojkovich).
 1214. Add Chrontel8391CalcClock function (#903, Gyorgy Krajcsovits).
 1213. Fix output of hex numbers in chip revision (#902, Dejan Ilic).
-1212. Add accelerated Bresenham lines to tseng driver at 8bpp (#901, 
+1212. Add accelerated Bresenham lines to tseng driver at 8bpp (#901,
       Koen Gadeyne).
 1211. Xlib: XIMStringConversionRetrival should be XIMStringConversionRetrieval
       (#905, Kaleb Keithley).
@@ -9297,7 +11278,7 @@
 1206. Fix SPARCcompiler CCompilerMajorVersion (#896, Kaleb Keithley).
 1205. Parse junk from export lists better (#895, Kaleb Keithley).
 1204. Removes some dead or unused code in os-support (#893,  Matthieu Herrb).
-1203. Remove xf86tmpnam() from libc_wrapper and rewrites xf86tmpfile() to 
+1203. Remove xf86tmpnam() from libc_wrapper and rewrites xf86tmpfile() to
       use tmpfile() (#892,  Matthieu Herrb).
 1202. Add a separate README.OpenBSD for 3.9 (#890, Matthieu Herrb).
 1201. Move most common extensions into a module (#889, Matthieu Herrb).
@@ -9311,7 +11292,7 @@
 1196. Bring the 3.3.1 Trident fixes into 3.9 (#882, Alan Hourihane).
 1195. Add incomplete Rendition detection code to SuperProbe (Dirk Hohndel).
 1194. Add Rendition detection to PCI code (#881, Marc Langenbach, Dirk Hohndel).
-1193. Fix to only build *.dir file for xkbcomp on make install (#880, 
+1193. Fix to only build *.dir file for xkbcomp on make install (#880,
       Michael Rohleder).
 1192. Add ImageWrites for s3/svga (#879, Mark Vojkovich).
 1191. Rename dashed pattern flags (#878, Mark Vojkovich).
@@ -9385,30 +11366,30 @@
 1154. Add code to fine tune memory access on ET6000 boards and cleanup some
       W32 specific code that would write to illegal registers on ET6000 cards
       (#818, Harald Nordgard Hansen).
-1153. Ensure accelerator CRTC registers are unlocked before writing them and 
+1153. Ensure accelerator CRTC registers are unlocked before writing them and
       horizontal & vertical syncs are not disabled on mode switches (#817,
       Marc La France).
-1152. Change xsetroot -mod option to count pixels from left to right within 
-      each 16-pixel slice, instead of right to left (#817, Marc La France). 
-1151. Cleanup declarations for xf86Verbose, xf86ProbeOnly & xf86ProbeFailed, 
-      make VGABase XF86Config option recognized by more servers, HSkew wasn't 
-      being dealt with correctly in matching modes to clocks, fixup default 
+1152. Change xsetroot -mod option to count pixels from left to right within
+      each 16-pixel slice, instead of right to left (#817, Marc La France).
+1151. Cleanup declarations for xf86Verbose, xf86ProbeOnly & xf86ProbeFailed,
+      make VGABase XF86Config option recognized by more servers, HSkew wasn't
+      being dealt with correctly in matching modes to clocks, fixup default
       mode for the generic VGA driver (#817, Marc La France).
 1150. Fix a few bugs in ATI driver, break it up in multiple files, add
       support for Mach64 accelerator CTRC, which now is used by default, and
-      generic VGA (untested) (#817, Marc La France). 
+      generic VGA (untested) (#817, Marc La France).
 1149. Fix build problem on Solaris (#810, Dirk Hohndel).
 1148. Re-enable LEFT_EDGE_CLIPPING_NEGATIVE for the HiQV chips and tidy up the
       ScreenToScreenColorExpand stuff (#808, David Bateman).
 1147. Enable the sw_cursor option and add support for the no_accel option (#806,
       Joe Moss).
 1146. Avoid source overruns in xf86DrawStippleScanline() and remove the
-      restrictions on TRIPLE_BITS_24BPP, LEFT_EDGE_CLIPPING 
+      restrictions on TRIPLE_BITS_24BPP, LEFT_EDGE_CLIPPING
       and LEFT_EDGE_CLIPPING_NEGATIVE_X (#805, David Bateman).
 1145. Allow keywords with underscores in XF86Setup (#802, Harald Koenig).
 1144. Explicitly enable hsync and vsync on Mach64 boards (#799, Marc La France).
 1143. Small fix for norwegian keyboard in xkb (#797, Harald Nordgard Hansen).
-1142. Add 32bpp to HiQV driver and get CopyArea and Solid Fills accelerated 
+1142. Add 32bpp to HiQV driver and get CopyArea and Solid Fills accelerated
       in 32bpp (#790,796, David Bateman).
 1141. Fix clock calculation on HiQV chips (#783, David Bateman).
 1140. Fix hardware clipping and get closer to a working 8x8pattern color expand
@@ -9417,7 +11398,7 @@
 1138. Change how patterns are packed for LINE_PATTERN_MSBFIRST_INCREASING
       (#779, Mark Vojkovich).
 1137. SVGA/S3 acceleration improvements (#778, Mark Vojkovich).
-1136. Fix xclock problem that shows up on Cirrus 542x chips 
+1136. Fix xclock problem that shows up on Cirrus 542x chips
       (#777, Corin Anderson).
 1135. Small fix for C&T driver (#775,776 David Bateman).
 1134. Merge missing ViRGE code from 3.3* into 3.9* (#773, Harald Koenig).
@@ -9427,12 +11408,12 @@
 1130. Make XF86Setup's keyword matching the same as the Xservers (ie,
       ignore '_', ' ', '\t' in keywords).
 1129. Tseng documentation update (#800, 803, Koen Gadeyne).
-1128. Update to imake's auto GCC PostIncDir detection for OpenBSD 
+1128. Update to imake's auto GCC PostIncDir detection for OpenBSD
       (#794, Matthieu Herrb).
 1127. Fix I128 problems (#792, 809, Robin Cutshaw).
 1126. Fix some errors in the symbols/th XKB file (Poonlap Veeratanabutr).
 1125. Don't use EXTRA_DEFINES in Xserver/xkb/Imakefile (#786, Kaleb Keithley).
-1124. Alternate way of fixing the "./" problem in Imake.rules 
+1124. Alternate way of fixing the "./" problem in Imake.rules
       (#785, Kaleb Keithley).
 1123. Install full path in dynamic libraries for SCO (#782, J. Kean Johnston).
 1122. Fix remaining problems with SCO OpenServer 5 support (#772,
@@ -9472,7 +11453,7 @@
 1099. Add handling for AST onboard Mach32 card (#754, Bryan Feir).
 1098. Fix a problem in Imake.rules that shows up when using Motif.rules.
 1097. Fix MGA lockup on SVR4.0.
-1096. Add missing for Japanese "small TSU" character to the XKB 
+1096. Add missing for Japanese "small TSU" character to the XKB
       symbols/jp file (#751, Shigehiko Sasaki).
 1095. Fix ET4000/W32i acceleration at 16 and 24bpp, and accelerate colour
       expansion at 16bpp and 24bpp for the W32p (#747, Koen Gadeyne).
@@ -9567,21 +11548,21 @@
       MHz on AT3D, various bugfixes and cleanups (#702, Henrik Harmsen).
 1045. Fix problems with displaying card READMEs in XF86Setup (#701, Dirk
       Hohndel).
-1044. Add left-edge clipping to s3_newmmio. There's bug in both the scanline 
-      screen->screen and CPU->screen stipple fallback routines though.  Both 
-      break certain patterns and the screen->screen bug is worse than the 
+1044. Add left-edge clipping to s3_newmmio. There's bug in both the scanline
+      screen->screen and CPU->screen stipple fallback routines though.  Both
+      break certain patterns and the screen->screen bug is worse than the
       CPU->screen one (#694, Mark Vojkovich).
-1043. Enables the XInput modules from 3.2 to be loaded as modules in 
+1043. Enables the XInput modules from 3.2 to be loaded as modules in
       XF86_LOADER (#693, Matthieu Herrb).
 1042. Add code to have XAA check to see if a stipple can be reduced to an 8x8
-      pattern before banishing it from the pixmap cache on account of it's 
+      pattern before banishing it from the pixmap cache on account of it's
       size (#692, Mark Vojkovich).
 1041. Fix CapNotLast problem in dashed line code (#686, Mark Vojkovich).
 1040. Add stippled fill fallback for SVGA/S3 if the pixmap cache is too small
       (#685, Mark Vojkovich)
-1039. Fix for xf86initac,c so that drivers can specify their own WriteBitmap 
+1039. Fix for xf86initac,c so that drivers can specify their own WriteBitmap
       functions and fallbacks for non-cachable stippled fills. This also
-      allows usage of both CPU->screen and scanline screen->screen color 
+      allows usage of both CPU->screen and scanline screen->screen color
       expansion instead of one or the other (#684, Mark Vojkovich).
 1038. Some Xlib fixes (#687-690, 695-699, Kaleb Keithley).
 1037. XKB updates (#674, 675, 709, Kaleb Keithley).
@@ -9657,7 +11638,7 @@
       Marc Aurele La France).
 1004. Fix duplicate target in drivers/s3/Imakefile (#658, Robin Cutshaw).
 1003. Fix some Xprt problems (#655-657, Kevin Samborn).
-1002. Fix some DPMS problems, including problems when the DPMS timeouts  
+1002. Fix some DPMS problems, including problems when the DPMS timeouts
       are smaller than the screensaver cycle time, and problems with the
       various DPMS setting not being re-initialised at server reset.
 1001. Fix an InfoRec initialisation problem in xfree68/fbdev (#652,
@@ -9930,7 +11911,7 @@
  834. Add detection of other variants of the Cyber9385 to the trident
       driver and SuperProbe (Arthur Tateishi and Alan Hourihane).
  833. Change the SVGA server to tell DGA clients that the memory available
-      is InfoRec.videoRam rather than ChipLinearSize (which is often 
+      is InfoRec.videoRam rather than ChipLinearSize (which is often
       too large).
  832. Cards db updates (#511, Harm Hanemaayer).
  831. Fix LynxOS inconsistent TERMCAP use by xterm and resize ($504,
@@ -10083,7 +12064,7 @@
         lib/X11: When doing XSetICValues and IMS returns ERROR, library core
           dump (#358).
  749. Clean up the GLX for the static-linked servers (#351, Henry Worth).
- 748. Fix SCO Open Server build problem (#348, J. Kean Johnston). 
+ 748. Fix SCO Open Server build problem (#348, J. Kean Johnston).
  747. Add an option to allow VClk1 to be used as the programmable clock
       with C&T 65550 and 65554 chips (#346 Daniel Bischof, Andreas Heitmann
       and Thomas Landgraf).
@@ -10192,7 +12173,7 @@
  691. Fix NonTE fonts in XAA (#292,309 David Bateman).
  690. Disable XAA matchcommon logic to fix problem with grayed out fonts
       (#291, David Bateman).
- 689. Fix sis driver for 8x8 color expand pattern fill pattern flags and XAA's  
+ 689. Fix sis driver for 8x8 color expand pattern fill pattern flags and XAA's
       new synching policy (#290, Xavier Ducoin).
  688. LynxOS updates (#289, Thomas Mueller).
  687. Enable 1bpp and 4bpp for the chips driver (#288, David Bateman).
@@ -10213,7 +12194,7 @@
       Tseng's recommendations (=much lower than we had before). fix a BUG in
       the ET4000 "standard set-of-clocks" code. Use ChipClockScaleFactor.
       (#282, Koen Gadeyne).
- 680. Fix and re-enable 8x8 pattern color expansion (!=24bpp) for Alpine cards 
+ 680. Fix and re-enable 8x8 pattern color expansion (!=24bpp) for Alpine cards
       Fix CPUToScreen color expansion for 24bpp mode, fix determining the BG
       color in 24bpp color expansion routines (#281,285, Corin Anderson).
  679. Various Cirrus fixes and additions. Fix HAVE_546X() macro for Laguna
@@ -10229,15 +12210,15 @@
  676. Fix loader under SVR4.0.4 (lstat,fstat,mknod)(#277, Richard Coley).
  675. Speedups for dashed lines in SVGA/S3 (#276, Mark Vojkovich).
  674. Allow building Xnest with BuildServersOnly (#275, Marc Aurele La France).
- 673. Fix vga16 and banked vga2 without also breaking either of the loader or 
+ 673. Fix vga16 and banked vga2 without also breaking either of the loader or
       static servers. Remove obsolete directories and other extraneous junk.
-      Remove mi's dependence on mfb. LoaderFixups is no longer needed. Add 
+      Remove mi's dependence on mfb. LoaderFixups is no longer needed. Add
       xf86InitViewport to the symbol table. Combine vga2/mfb & vga2/mfb.banked.
       (#274 Marc Aurele La France).
  672. More layout cleanups in matrox driver (#273, Radek Kapitan).
  671. Fix LinkKit to build loader (#272, Takaaki Nomura).
  670. Fix some Alpha problems (#270, Robin Cutshaw).
- 669. Add MemClk field to all drivers (#270,271 Robin Cutshaw, Sebastien 
+ 669. Add MemClk field to all drivers (#270,271 Robin Cutshaw, Sebastien
       Marineau).
  668. Fix server crashes in C&T driver caused by delayed syncing (#269, David
       Bateman).
@@ -10254,11 +12235,11 @@
 
 XFree86 3.2As (09 April 1997)
  658. Several fixes and enhancements for the cirrus driver. Fix the crash that
-      showed up in 3.2A with MMIO on some chips at 16bpp. Enable the 8x8 
-      pattern fill code for different chips. Reorganize the BitBLT feature 
-      checks in the accelerated driver, and make it compatible with the new 
-      delayed syncing in XAA.Fix the > 85 MHz dot clock mode on the 
-      CL-GD5436/46. Detect all DRAM configurations that are possible on the 
+      showed up in 3.2A with MMIO on some chips at 16bpp. Enable the 8x8
+      pattern fill code for different chips. Reorganize the BitBLT feature
+      checks in the accelerated driver, and make it compatible with the new
+      delayed syncing in XAA.Fix the > 85 MHz dot clock mode on the
+      CL-GD5436/46. Detect all DRAM configurations that are possible on the
       CL-GD5446. Add code to handle the 7555 (no detection).
       (#258, Harm Hanemaayer).
  657. Fix Bresenham line bug in trident/9440 driver (#257, Alan Hourihane).
@@ -10268,11 +12249,11 @@
  655. Add mga dashed lines (#255, Andrew Vanderstock).
  654. Add more flexible way of loading and initializing extensions (#253,
       Matthieu Herrb).
- 653. Fix bugs in the S3V server concerning rectfill with scan line width of 
+ 653. Fix bugs in the S3V server concerning rectfill with scan line width of
       2048 and with lines (#251,252, Harald Koenig).
  652. Add option "set_memclk" (#249, Sebastien Marineau).
  651. Fix hangs in svga/s3v server, fix some bugs, add planemask support to
-      most accelerated primitives and start accelerated lines (#249, Sebastien 
+      most accelerated primitives and start accelerated lines (#249, Sebastien
       Marineau).
  650. Fix XAA to force ROP to GXcopy for XDrawImageString (#249, Sebastien
       Marineau).
@@ -10286,8 +12267,8 @@
  644. Add dashed line support for XAA (#242,244, Mark Vojkovich).
  643. Fix some fill problems in S3V server (#241, Harald Koenig).
  642. Several fixes to C&T driver that rearrange code in XAA FillRect code to
-      work around bug in HW cursor, add ImageWrite function, use the 8x8 
-      pattern where possible to simulate a planemask, add preliminary support 
+      work around bug in HW cursor, add ImageWrite function, use the 8x8
+      pattern where possible to simulate a planemask, add preliminary support
       for vga2 and vga16 and temporary fix for Syncing problems in new XAA code
       (#239, David Bateman).
  641. Further LinkKit changes (#238, Takaaki Nomura).
@@ -10321,7 +12302,7 @@
       Make LinkKit use the same default CCOPTIONS as the main build.
       Remove redundancy in svr4.cf (#215, Marc Aurele La France).
  619. Add newer ATI chipsets to SuperProbe (#214, Marc Aurele La France).
- 618. Fix color expansion and pixmap cache in trident driver (#212,213, 
+ 618. Fix color expansion and pixmap cache in trident driver (#212,213,
       Alan Hourihane).
  617. Change XAA to delay syncing (#211, Mark Vojkovich).
  616. Fix OS/2 naming problem in Xserver Imakefile and XAA 8x8 pattern
@@ -10332,7 +12313,7 @@
       Harald Koenig).
  612. Fix building XF98_EGC (#207, Takaaki Nomura).
  611. Add ImageWrite to s3/svga and prepare driver for upcoming XAA changes;
-      the s3/svga server no longer does cursor blocking, users of Xqueue 
+      the s3/svga server no longer does cursor blocking, users of Xqueue
       might have to use the Option "sw_cursor" (#206, Mark Vojkovich).
  610. Fix 8 bit DAC handling in SVGA server (#205, Mark Vojkovich).
  609. Add better support for linear memory on W32i cards (#204, Koen Gadeyne).
@@ -10351,7 +12332,7 @@
  599. Fix SuperProbe for W32 chipsets (#191, Koen Gadeyne).
  598. Fix building the static S3 server (#188-190, Harald Koenig).
  597. Fix undefined symbols in the pex5 module (#187, Matthieu Herrb).
- 596. Fix autoloading modules in the S3 server for PC98 (#186,197 Takaaki 
+ 596. Fix autoloading modules in the S3 server for PC98 (#186,197 Takaaki
       Nomura).
 
 XFree86 3.2Aq (23 March 1997)
@@ -10368,7 +12349,7 @@
  587. Fixes to blitter and hw cursor handling in C&T driver (#176, David
       Bateman, Egbert Eich).
  586. Add Elsa handling to S3/SVGA and Trio64V2/DX/GX, ViRGE/DX/GX and PLATO/PX
-      to SuperProbe, scanpci, S3, S3V and S3/SVGA servers (#174,175, 
+      to SuperProbe, scanpci, S3, S3V and S3/SVGA servers (#174,175,
       Harald Koenig).
  585. Build fix for Xprt, Xnest and Xvfb (#172, Takaaki Nomura).
 
@@ -10384,7 +12365,7 @@
  579. Tseng documentation updates (#165, Koen Gadeyne).
  578. Fix unresolved strlen in PEX and XIE (#164, Takaaki Nomura).
  577. Fix changes of NEC480 to PEGC (#163, Michio "Karl" Jinbo).
- 576. Fix building of XF98_LOADER (#163,169, Michio "Karl" Jinbo, 
+ 576. Fix building of XF98_LOADER (#163,169, Michio "Karl" Jinbo,
       Takaaki Nomura).
  575. Fix building of normal X servers for PC98 (#163, Takaaki Nomura).
  574. Fix building P9000 module (#160, Takaaki Nomura).
@@ -10511,7 +12492,7 @@
       used to get the initial ScrnInfoRec; change all modules to follow these
       naming conventions (Dirk Hohndel).
  500. Fix missing fsetpos/fgetpos in ISC (#78, Michael Rohleder).
- 499. Fix elfloader to recognize .data1 and .rodata1 sections 
+ 499. Fix elfloader to recognize .data1 and .rodata1 sections
       (#82, Steve Forsythe).
  498. Add readdir family of functions to libc_wrapper (#81, Holger Veit).
  497. Add crosscompilation support for OS/2 (#81, Holger Veit).
@@ -10554,7 +12535,7 @@
  471. Fix problems with ISC and the Mach32 module (#55, Michael Rohleder).
  470. Fix Xnest and Xvfb when DoLoadableServer is YES (Dirk Hohndel).
  469. Clear up multiplex support on 96xx and display error message when
-      requested resolution exceeds available memory with the accelerator 
+      requested resolution exceeds available memory with the accelerator
       engine (#52, Alan Hourihane).
  468. Let Trio64V2 use newmmio driver (#49, Tom Angert).
  467. First cut for ET6000 hardware cursor (#48, Dejan Ilic).
@@ -10579,7 +12560,7 @@
  454. Start Elf loader for Linux/Alpha; doesn't work, yet (#44, Alan Hourihane).
  453. Hide cursor in S3/SVGA when DGA is active (#43, Mark Vojkovich).
  452. a.out loader for module loading (#42, Matthieu Herrb).
- 451. Extend OS support layer to cover some libc functions and update all 
+ 451. Extend OS support layer to cover some libc functions and update all
       drivers to use the internal functions (Dirk Hohndel).
 
 XFree86 3.2Ae (16 February 1997)
@@ -10605,7 +12586,7 @@
       David Bateman).
 
 XFree86 3.2Ad (14 February 1997)
- 434. Merge Metro Link loader code and make all SVGA drivers and S3, S3V 
+ 434. Merge Metro Link loader code and make all SVGA drivers and S3, S3V
       server loadable (Metro Link, Dirk Hohndel).
  433. Avoid installing CVS admin files when doing 'make install' for rstart
       (#25).
@@ -10615,7 +12596,7 @@
 XFree86 3.2Ac (12 February 1997)
  430. Fix problem with system #define Control on LynxOS (Thomas Mueller).
  429. FreeBSD 2.2 doesn't need libz (Takaaki Nomura).
- 428. Another attempt at left edge clipping for HiQV chips (still disabled 
+ 428. Another attempt at left edge clipping for HiQV chips (still disabled
       by default) (David Bateman).
  427. DPMS in C&T is now enabled even when no monitor is detect (David Bateman).
  426. Additional fixes for 65530/35 linear addressing (untested) (Egbert Eich).
@@ -10656,7 +12637,7 @@
  396. Add memory bandwidth as a concept to the W32 RAMDAC code (Koen Gadeyne).
  395. Move W32/ET6k clock setting functions into tseng_clock.c. This together
       with change 394 breaks the W32 server and the et4000 driver in the
-      VGA2 and VGA16 server (all those are disabled by default for now) 
+      VGA2 and VGA16 server (all those are disabled by default for now)
       (Koen Gadeyne).
  394. Move RAMDAC support from W32 server in SVGA server and added
       accelerated 16/24/32 bpp support for ET4000/W32p (Koen Gadeyne).
@@ -11321,7 +13302,7 @@
 1058. Chips&Tech doc updates (David Bateman).
 1057. Cards db update for Chips&Tech (David Bateman).
 1056. Some updates to the "supported" contrib clients (Harald Koenig).
-1055. VGADriver doc updates (Stuart Lamble). 
+1055. VGADriver doc updates (Stuart Lamble).
 1054. LynxOS doc updates (Thomas Mueller).
 1053. Fix a problem in mgaFillBoxSolid() (Radoslaw Kapitan).
 1052. Fix a serious probe bug in the MGA driver which causes a crash on
@@ -11502,7 +13483,7 @@
      (Michio "Karl" Jinbo).
 956. ViRGE/VX update (Harald Koenig).
 955. Add power_saver support to the TGA server (Alan Hourihane).
-954. Some more line/seg updates for S3V (Harald Koenig). 
+954. Some more line/seg updates for S3V (Harald Koenig).
 953. Fix some problems with the previous S3V planemask patch (Harald Koenig).
 952. Add code to read the MGA card information from the BIOS.  This
      allows the RAMDAC type/speed to be determined (Andrew E. Mileski).
@@ -11690,7 +13671,7 @@
 833. Don't reference uninitialised s3MmioMem in ViRGE server (Harald Koenig
      and Dirk Hohndel).
 832. Don't do S3 bug tests for 928 and earlier (Harald Koenig).
-831. ViRGE fixes, including BITBLT and text clipping (Harald Koenig). 
+831. ViRGE fixes, including BITBLT and text clipping (Harald Koenig).
 830. Updates to the Cards file for Cirrus and Ark (Harm Hanemaayer).
 829. xf86config updates, including 24bpp support, and making "virtual"
      optional (Harm Hanemaayer).
@@ -11986,7 +13967,7 @@
      enabled (Thomas E. Dickey).
 633. Reduce flickering during resize for ReverseVideo in xterm
      (Thomas E. Dickey).
-632. Fix xterm core dump problem on IRIX 5.2 (Thomas E. Dickey). 
+632. Fix xterm core dump problem on IRIX 5.2 (Thomas E. Dickey).
 631. Update scanpci to detect the #9 I128 series II (Robin Cutshaw).
 630. Preliminary Mach32 ramdac support updates (Bryan Feir).
 629. Document new xterm control sequences (Thomas E. Dickey).
@@ -14024,7 +16005,7 @@
 356. Enable 32bpp for Ti3025+964.
 355. Change font cache and pixmap expansion allocation policy for S3
      server.  This allows better performance when there isn't much
-     offscreen memory available (Hans Nasten). 
+     offscreen memory available (Hans Nasten).
 354. Fix for banked ImageFill for bpp>8 (Hans Nasten).
 353. Updates to XF86_Accel man page.
 352. Remove references to 'Xconfig' in source code.
@@ -14238,7 +16219,7 @@
 210. P9000 updates.  Includes updates to sysconfig code, Orchid and PCI
      support now enabled by default (Erik Nygren).
 209. SuperProbe and ModeDB updates (David Wexelblat).
-208. Support for the S3 805i and 16-bit RAMDACS (including ATT20C498, 
+208. Support for the S3 805i and 16-bit RAMDACS (including ATT20C498,
      STG1700, SDAC) (Bernhard Bender).
 207. Support for the S3 SDAC with S3 864 (Bernhard Bender).
 206. Basic support for ET4000W32 chipsets in the VGA servers.  Includes
@@ -14555,4 +16536,4 @@
 XFree86 3.0 (26 April 1994)
 
 
-$XFree86: xc/programs/Xserver/hw/xfree86/CHANGELOG,v 3.2144 2002/01/18 20:09:22 dawes Exp $
+$XFree86: xc/programs/Xserver/hw/xfree86/CHANGELOG,v 3.2588 2003/02/27 04:56:44 dawes Exp $
Index: xc/Imakefile
diff -u xc/Imakefile:3.25 xc/Imakefile:3.29
--- xc/Imakefile:3.25	Wed Mar 21 12:36:43 2001
+++ xc/Imakefile	Wed Feb 26 04:21:31 2003
@@ -3,12 +3,17 @@
 
 
 
-XCOMM $XFree86: xc/Imakefile,v 3.25 2001/03/21 17:36:43 dawes Exp $
+XCOMM $XFree86: xc/Imakefile,v 3.29 2003/02/26 09:21:31 dawes Exp $
 
 #define IHaveSubdirs
 #define PassCDebugFlags CDEBUGFLAGS="$(CDEBUGFLAGS)"
 
 RELEASE = XOrgReleaseString
+
+#ifdef XFree86VersionString
+VERSTRING = " "version XFree86VersionString "("XFree86DateString")"
+#endif
+
 #ifndef OSName
 #define OSName Unknown Operating System!
 #endif
@@ -46,9 +51,13 @@
 #define IHaveSpecialMakefileTarget
 
 #ifndef Win32Architecture
-#ifndef OS2Architecture
+#ifdef XFree86VersionString
 VerifyOS::
 	@echo ""
+	@echo Building XFree86 version XFree86VersionString "("XFree86DateString")."
+#endif
+VerifyOS::
+	@echo ""
 	@echo Building on OSName "("OSMajorVersion"."OSMinorVersion"."OSTeenyVersion")."
 	@echo ""
 #ifdef LinuxArchitecture
@@ -64,12 +73,18 @@
 	@echo ""
 #endif
 
-#ifdef XFree86Version
+#ifndef OS2Architecture
 version.def::
 	$(RM) $(IRULESRC)/version.def
+	$(RM) $(IRULESRC)/date.def
 	$(LN) ../../$(XF86SRC)/xf86Version.h $(IRULESRC)/version.def
-#else
+	$(LN) ../../$(XF86SRC)/xf86Date.h $(IRULESRC)/date.def
+#else /*OS2Architecture*/
 version.def::
+	$(RM) $(IRULESRC)/version.def
+	$(RM) $(IRULESRC)/date.def
+	$(CP) $(XF86SRC)/xf86Version.h $(IRULESRC)/version.def
+	$(CP) $(XF86SRC)/xf86Date.h $(IRULESRC)/date.def
 #endif
 
 includes::
@@ -91,7 +106,7 @@
 
 Everything::
 	@echo ""
-	@echo Rebuilding $(RELEASE) of the X Window System.
+	@echo Rebuilding XFree86$(VERSTRING).
 	@echo ""
 	@date
 	@echo ""
@@ -109,7 +124,7 @@
 	@echo ""
 	@date
 	@echo ""
-	@echo Rebuild of $(RELEASE) of the X Window System complete.
+	@echo Rebuild of XFree86$(VERSTRING) complete.
 	@echo ""
 
 XCOMM clean out link tree looking for stuff that should get checked in
@@ -118,53 +133,6 @@
 	find . -type l -exec rm {} \;
 	find . \( \! -type d \) -print
 
-#else /* OS2Architecture */
-VerifyOS::
-	@echo :
-	@echo Building on OSName.
-	@echo :
-
-includes::
-	MakeDir($(subst /,\,$(BUILDINCDIR)))
-
-XCOMM
-XCOMM Watch out!!!  Make sure you do make includes after removing X11....
-XCOMM
-clean::
-	$(RM) -r $(BUILDINCDIR)
-	$(RM) -r $(BUILDLIBDIR)
-
-Everything::
-	@echo :
-	@echo Building $(RELEASE) of the X Window System on OS/2
-	@echo :
-	@echo :
-	\indir $(IMAKESRC) $(MAKE) $(MFLAGS) SHELL= -f Makefile.ini BOOTSTRAPCFLAGS=-Zexe
-	if exist Makefile.bak del Makefile.bak
-	if exist Makefile ren Makefile Makefile.bak
-	$(MAKE) $(MFLAGS) -f Makefile.bak Makefile
-	$(MAKE) $(MFLAGS) SHELL= VerifyOS
-	$(MAKE) $(MFLAGS) SHELL= Makefiles
-	$(MAKE) $(MFLAGS) SHELL= clean
-	$(MAKE) $(MFLAGS) SHELL= includes
-	$(MAKE) $(MFLAGS) SHELL= depend
-	$(MAKE) $(MFLAGS)
-	@echo :
-	@echo :
-	@echo Rebuild of $(RELEASE) of the X Window System complete.
-	@echo :
-
-#ifdef ProjectRoot
-install::
-	MakeDir($(subst /,\,$(PROJECTROOT)))
-#endif
-
-install::
-	MakeDir($(subst /,\,$(INCROOT)))
-	MakeDir($(subst /,\,$(USRLIBDIR)))
-	MakeDir($(subst /,\,$(LIBDIR)))
-
-#endif
 #else /* not Win32Architecture else */
 VerifyOS::
 	@echo :
@@ -183,7 +151,7 @@
 
 Everything::
 	@echo :
-	@echo Rebuilding $(RELEASE) of the X Window System.
+	@echo Rebuilding XFree86$(VERSTRING).
 	@echo :
 	@echo :
 	cd $(IMAKESRC)
@@ -197,7 +165,7 @@
 	$(MAKE) $(MFLAGS) $(MAKE_OPTS) $(WORLDOPTS)
 	@echo :
 	@echo :
-	@echo Rebuild of $(RELEASE) of the X Window System complete.
+	@echo Rebuild of XFree86$(VERSTRING) complete.
 	@echo :
 
 #ifdef ProjectRoot
Index: xc/Makefile
diff -u xc/Makefile:3.22 xc/Makefile:3.27
--- xc/Makefile:3.22	Wed Dec 19 16:37:26 2001
+++ xc/Makefile	Wed Feb 26 04:21:31 2003
@@ -2,7 +2,7 @@
 
 
 
-# $XFree86: xc/Makefile,v 3.22 2001/12/19 21:37:26 dawes Exp $
+# $XFree86: xc/Makefile,v 3.27 2003/02/26 09:21:31 dawes Exp $
 
 # Luna users will need to either run make as "make MAKE=make"
 # or add "MAKE = make" to this file.
@@ -26,6 +26,9 @@
 MAKE_OPTS = -f xmakefile
 MAKE_CMD = $(MAKE) $(MAKE_OPTS)
 FLAGS = $(MFLAGS) -f Makefile.ini BOOTSTRAPCFLAGS="$(BOOTSTRAPCFLAGS)" CC="$(CC)"
+VERSINC = -Iprograms/Xserver/hw/xfree86
+VERSSRC = $(CONFIGSRC)/util/printver.c
+VERSPROG = $(CONFIGSRC)/util/printver.exe
 
 all:
 	@$(MAKE_CMD) xmakefile-exists || $(MAKE) all-initial
@@ -39,9 +42,12 @@
 	@echo Do not name your log file make.log or it will be deleted.
 
 World:
+	@$(RM) $(VERSPROG)
+	@$(CC) $(VERSINC) -o $(VERSPROG) $(VERSSRC)
 	@echo ""
-	@echo Building $(RELEASE) of the X Window System.
+	@echo Building XFree86`$(VERSPROG)`.
 	@echo ""
+	@$(RM) $(VERSPROG)
 	@case "x$(BOOTSTRAPCFLAGS)" in x) \
 	echo I hope you checked the configuration parameters in $(IRULESRC) ; \
 	echo to see if you need to pass BOOTSTRAPCFLAGS. ; \
@@ -68,10 +74,14 @@
 	@if [ ! -f $(IRULESRC)/version.def ]; then \
 	    echo "" > $(IRULESRC)/version.def; \
 	fi
+	@if [ ! -f $(IRULESRC)/date.def ]; then \
+	    echo "" > $(IRULESRC)/date.def; \
+	fi
 	cd $(IMAKESRC) && $(MAKE) $(FLAGS) clean
 	$(MAKE) $(MFLAGS) Makefile.boot
-	$(MAKE_CMD) $(MFLAGS) VerifyOS
 	$(MAKE_CMD) $(MFLAGS) version.def
+	$(MAKE) $(MFLAGS) Makefile.boot
+	$(MAKE_CMD) $(MFLAGS) VerifyOS
 	$(MAKE_CMD) $(MFLAGS) Makefiles
 	$(MAKE_CMD) $(MFLAGS) BOOTSTRAPSUBDIRS= clean
 	$(MAKE_CMD) $(MFLAGS) includes
@@ -80,7 +90,10 @@
 	@echo ""
 	@date
 	@echo ""
-	@echo Full build of $(RELEASE) of the X Window System complete.
+	@$(RM) $(VERSPROG)
+	@$(CC) $(VERSINC) -o $(VERSPROG) $(VERSSRC)
+	@echo Full build of XFree86`$(VERSPROG)` complete.
+	@$(RM) $(VERSPROG)
 	@echo ""
 
 .PRECIOUS: Makefile
@@ -124,7 +137,7 @@
 
 World.Win32:
 	@echo :
-	@echo Building $(RELEASE) of the X Window System.
+	@echo Building XFree86.
 	@echo :
 	@echo :
 	-@if not exist $(IRULESRC)\host.def echo > $(IRULESRC)\host.def
@@ -146,12 +159,12 @@
 	$(MAKE_CMD) $(MFLAGS) $(WIN32WORLDOPTS)
 	@echo :
 	@echo :
-	@echo Full build of $(RELEASE) of the X Window System complete.
+	@echo Full build of XFree86 complete.
 	@echo :
 
 World.OS2:
 	@echo :
-	@echo Building $(RELEASE) of the X Window System on OS/2.
+	@echo Building XFree86 on OS/2.
 	@echo :
 	@echo :
 	-@if not exist $(IRULESRC)\host.def echo > $(IRULESRC)\host.def
@@ -168,7 +181,7 @@
 	$(MAKE) $(MFLAGS)  
 	@echo :
 	@echo :
-	@echo Full build of $(RELEASE) of the X Window System complete.
+	@echo Full build of XFree86 on OS/2 complete.
 	@echo :
 
 # don't allow any default rules in this Makefile
@@ -184,7 +197,7 @@
 	    $(MAKE_CMD) $@
 distclean:
 	    $(MAKE_CMD) $@
-	    $(RM) xmakefile $(IRULESRC)/version.def
+	    $(RM) xmakefile $(IRULESRC)/version.def $(IRULESRC)/date.def
 depend:
 	    $(MAKE_CMD) $@
 Everything:
Index: xc/RELNOTES
diff -u xc/RELNOTES:1.6 xc/RELNOTES:1.17
--- xc/RELNOTES:1.6	Thu Jan 17 18:27:41 2002
+++ xc/RELNOTES	Wed Feb 26 20:44:02 2003
@@ -1,222 +1,203 @@
-                     Release Notes for XFree86[tm] 4.2.0
+                     Release Notes for XFree86[tm] 4.3.0
 
                           The XFree86 Project, Inc
 
-                               17 January 2002
+                              26 February 2003
 
                                   Abstract
 
      This document contains some information about features present in
-     XFree86 4.2.0 and their status.
+     XFree86 4.3.0 and their status.
 
 1.  Introduction to the 4.x Release Series
 
 XFree86 4.0 was the first official release of the new XFree86 4 series.  The
-current release (4.2.0) is the latest in that series.  XFree86 4 represents a
+current release (4.3.0) is the latest in that series.  XFree86 4 represents a
 significant redesign of the XFree86 X server.  Not all of the hardware
-drivers from 3.3.x have been ported to 4.x yet, but conversely, 4.x has some
-hardware support not present in 3.3.x.  Our Driver Status document summarizes
-how the hardware driver support compares between 3.3.6 and 4.2.0.  Please
-check there first before downloading 4.2.0.
+drivers from 3.3.x have been ported to 4.x yet, but conversely, 4.x has sup-
+port for a lot of hardware that is not supported in 3.3.x.  Our Driver Status
+document summarizes how the hardware driver support compares between 3.3.6
+and 4.3.0.  Please check there first before downloading 4.3.0.
 
 The 4.0.1 release introduced a new graphical configuration tool, "xf86cfg",
-and a text mode interface was added to it for the 4.0.2 release.  It is work
-in progress, but definitely worth trying out.  The trusty old text-based tool
-"xf86config" can also be used for generating X server config files.  In addi-
-tion to these tools, we've been working on a configuration tool that is
-built-in to the X server.  It is included in the release, and it works well
-for some hardware.  To try it out, just run (as root) "XFree86 -configure".
+and a text mode interface was added to it for the 4.0.2 release.  It is the
+preferred configuration tool provided by with XFree86.  The trusty old text-
+based tool "xf86config" can also be used for generating X server config
+files.  In addition to these tools, the XFree86 server has some built in
+capabilities for generating a base config file.  This works well for most
+hardware, and in most cases is the easiest way to get an initial config file.
+To try it out, just run (as root):
+
+     XFree86 -configure
+
 Each of these configuration options will give you a reasonable starting point
 for a suitable configuration file.  We've put some effort into documenting
-the 4.2.0 config file format, and you can find that information in the
-XF86Config manual page. Check that, the driver manual pages and the related
-documentation for further information.
+the 4.3.0 config file format, and you can find that information in the
+XF86Config manual page.  Check there and the driver-specific manual pages and
+the related documentation for further information.  References to this
+driver-specific information can be found in the tables below (section 3.,
+page 1).
+
+We have plans to make the configuration file optional in a future release.
+The XFree86 server is close to being able to automatically determine a com-
+plete base configuration for most popular hardware configurations.
 
 Before you go to download and install the binary distributions for this
 release, please have a quick read through the Installation Document.  It may
 save you some time and help you figure out which of the binary releases you
 need.
 
-The next section describes what is new in the latest version (4.2.0) compared
-with the previous full release (4.1.0).  The other sections below describe
+The next section describes what is new in the latest version (4.3.0) compared
+with the previous full release (4.2.0).  The other sections below describe
 some of the new features and changes between 3.3.x and 4.0.  There are lot's
 of new features, and we definitely don't have enough space to cover them all
 here.
 
-2.  Summary of new features in 4.2.0.
+2.  Summary of new features in 4.3.0.
 
 2.1  Video Driver Enhancements
-
-   o  An s3 driver is added, which provides support for many of the older
-     non-ViRGE and non-Savage S3 chipsets.
-
-   o  Some vmware driver problems are fixed, and the driver is updated to
-     take advantage of VMWare Workstation 3.0 features.  These include
-     improved hardware cursor handling and support for 8 bit emulation.
-
-   o  Support added for Trident *BladeXP chipsets (currently not-acceler-
-     ated).
-
-   o  Xv support added for Trident TGUI series chips (not 9440 though).
-
-   o  Support added for the older Trident chipsets again for ISA/VLBus (not
-     tested)
-
-   o  Support added to the glint driver for 3DLabs Permedia4, GLINT R4 and
-     Gamma 2 chipsets.
 
-   o  Support added to the i810 driver for Intel i830 (tested on Linux only).
+   o  ATI Radeon 9x00 2D support added, and 3D support added for the Radeon
+     8500, 9000, 9100, and M9.  The 3D support for the Radeon now includes
+     hardware TCL.
 
-   o  Support added to the ATI radeon driver for Radeon 7500 (2D and 3D),
-     Radeon 8500 (2D only), and Rage128ProII.
+   o  Support added to the i810 driver for Intel 845G, 852GM, 855GM and 865G
+     integrated graphics chipsets, including 2D, 3D (DRI) and XVideo.  Sup-
+     port for the 830M has been improved, and XVideo support added.
 
-   o  Support added for the Matrox G550 support.  This included dual-head
-     support.
+   o  National Semiconductor SC1x00, GX1, and GX2 chipset support added with
+     the "nsc" driver.
 
-   o  Support added for NVIDIA nForce integrated graphics.
+   o  Support added for the NVIDIA nForce2 integrated graphics, GeForce 4,
+     and GeForce FX.
 
-   o  The NVIDIA nv driver now has preliminary powerpc support for the NV11
-     and NV20.
+   o  Major SiS driver updates for some of the latest chipsets.  Unfortu-
+     nately the SiS 3D driver has had to be disabled because no one has yet
+     taken up the challenge to port it to Mesa 4.x.
 
-   o  Support added to the NVIDIA nv driver for interlaced modes on hardware
-     that supports this, and support for resolutions higher than 1600x1200.
+   o  The s3virge driver now has support for double scan modes on the DX
+     (with XVideo disabled).
 
-   o  Fixes for the savage driver on 64-bit platforms, XVideo support for the
-     SuperSavage, and other savage driver updates.
+   o  Updates to the savage driver, including fixing problems with the
+     TwisterK, and problems with incorrect memory size detection.
 
-   o  The ATI r128 driver now uses the CCE DMA engine for 2D acceleration
-     when direct rendering is enabled, which reduces context switching over-
-     head and improves stability and performance for XVideo and some 2D oper-
-     ations.
+   o  2D acceleration added for the Trident CyberBladeXP/Ai1 chipsets.
 
-   o  The fbdev driver now supports rotation.
+   o  Support for big endian architectures has been added to the C&T driver.
 
-   o  Various updates to the apm, ark, chips (C&T), cirrus, i128, neomagic,
-     newport, s3virge, siliconmotion, sis, tdfx, tseng, vesa, and vga
-     drivers.
+   o  Various updates and bug fixes have been made to most other drivers.
 
 2.2  Input Driver Enhancements
 
-   o  The mouse driver now has support for mouse wheel emulation.
+   o  The mouse driver now has automatic protocol detection for PS/2 mice.
 
-   o  The mouse driver can now handle replug events on Linux for PS/2 mice.
+   o  Several new input drivers have been added, including tek4957, jamstudio
+     (js_x), fpit, palmax, and ur98 (Linux only).
 
-   o  The "Min/Max X/Y Position" options in the elographics and mutouch
-     drivers are changed to "Min/Max X/Y" to be consistent with the other
-     input drivers.
-
-   o  Linux USB keyboard access is fixed when no PS/2 controller is present.
-
-   o  Added calcomp input driver.
-
-   o  Added DMC input driver.
-
-   o  Added hyperpen input driver.
-
 2.3  X Server and Extension Updates
-
-   o  Resynced with X.Org's X11R6.6.
-
-   o  Mesa updated to the post-3.4.2 3.4 branch version as of November 2001.
-
-   o  DRI drivers resynced with the latest from the DRI project.
 
-   o  Various updates to the Xft library.
-
-   o  The DEC-XTRAP extension is now available.
-
-   o  The PEX and XIE extensions are no longer built/distributed by default.
-
-   o  A security problem related to glyph clipping for large origins is
-     fixed.
+   o  Support for the RandR extension has been partially integrated into the
+     XFree86 server, providing support for resizing the root window at run-
+     time.
 
-   o  An i810 XvMC (motion compensation) driver is now available (Linux
-     only).
+   o  The Mesa version used for OpenGL® 1.3 and DRI driver support has been
+     updated to 4.0.4.
 
-   o  A fatal bug XVideo Xineramification bug is fixed.
+   o  The XFree86 server's hot keys (including those for switching modes and
+     virtual terminals) can now be configured via XKB.  Previously they were
+     hard coded.  An X server configuration option has been added to allow
+     the VT switching hot keys to be disabled.
 
 2.4  Client and Library Updates
 
-   o  FreeType2 updated to version 2.0.6.
+   o  An Xcursor library providing support for alpha blended (ARGB) and ani-
+     mated cursors.  Two Xcursor themes are provided (redglass and white-
+     glass), as well as the default "core" theme (the traditional cursors).
 
-   o  Added libGL man pages.
+   o  Xterm updated to patch level 173, including the following bugfixes:
 
-   o  Xload now has support for displaying the load of remote hosts.
+        o  Fix two infinite loops (special cases of mouse hilite tracking,
+          DECUDK parsing).
 
-   o  Xterm updated to patch level 165.
+        o  Make repainting of the 256-color example work properly.
 
-   o  SuperProbe is removed.
+        o  Modify parser tables to improve detection of malformed control
+          sequences, making xterm behave more like a real DEC terminal.
 
-   o  Sample xtrap clients added.
+        o  Fix a problem with the blinking cursor which occasionally caused
+          xterm to pause until a key was pressed.
 
-2.5  I18N and Font Updates
-
-   o  New Luxi scalable fonts (TrueType and Type 1) from Bigelow & Holmes.
-     These fonts are original designs by Kris Holmes and Charles Bigelow.
-     See below (section 4.22, page 1) for further information.
+        o  Fix improper parsing of multiple items in the ttyModes resource.
 
-   o  More locale/international keyboards supported.
+     and the following improvements:
 
-   o  Modularized I18N support in Xlib is included from X11R6.6.
+        o  Modify xterm to invoke luit.
 
-   o  A problem that caused bdftopcf to sometimes write corrupted fonts is
-     fixed.
+        o  Add simple session management client capabilities.
 
-   o  Some problem with Xlib's handling of CTEXT and multi-byte characters
-     are fixed.
+        o  Add a modifyCursorKeys resource to control how the shift- and sim-
+          ilar modifiers are used to make a cursor escape sequence.
 
-   o  The fontenc layer is updated, and the fontenc library is now installed
-     and available for other applications.
+        o  Check if the printerCommand resource string is empty, and use this
+          to allow the user to disable printer function.
 
-   o  Improvements to the input method framework in Xlib for UTF-8 locales.
+        o  Sort the options list which is displayed in help- and syntax-mes-
+          sages at runtime to simplify maintenance.
 
-   o  A filter called ``luit'' is added, which provides locale and ISO 2022
-     support to any Unicode terminal, notably xterm.  Use of luit is still
-     experimental in this release.
-
-2.6  OS Support Updates
-
-   o  Build problems on both QNX4 and QNX6 are fixed.
-
-   o  VT switching problems with the i810 driver on FreeBSD are worked
-     around.
-
-   o  Problems building modules with some enhanced versions of gcc are fixed.
+2.5  I18N and Font Updates
 
-   o  Lots of updates for Darwin/Mac OS X, including:
+   o  FreeType2 updated to version 2.1.1.
 
-        o  On Mac OS X, a new rootless mode is added to the XDarwin X server.
-          This allows X clients to display windows on the Aqua desktop.
+   o  The "freetype" X server font backend has undergone a partial rewrite.
+     The new version is based on FreeType 2, and handles TrueType (including
+     OpenType/TTF), OpenType/CFF and Type 1 fonts.  The old "type1" backend
+     is now deprecated, and is only used for CIDFonts by default.
+
+   o  A new utility called "mkfontscale", which builds fonts.scale files, has
+     been added.
+
+   o  The Xft library has undergone a major restructuring, and is now split
+     into fontconfig (which deals with font discovery and configuration and
+     is independent from X), and Xft itself (which uses fontconfig and deals
+     with font rasterisation and rendering.  The format of the Xft font con-
+     figuration files has changed in an incompatible manner.
+
+   o  Support has been added to the Xft library to do rendering with the core
+     X11 protocol.  This allows clients using this library to render to X
+     servers that don't have support for the RENDER extension.
+
+   o  There has been a significant reworking of the XKB support to allow
+     multi-layout configurations.  Multi-layout configurations provide a
+     flexible way of supporting multiple language layouts and switching
+     between them.
 
-        o  Xinerama support added to XDarwin
+2.6  OS Support Updates
 
-        o  With XDarwin in full screen mode, the depth, size, and refresh
-          rate can now be chosen to be different from the settings used by
-          Aqua.
+   o  Updates for Darwin/Mac OS X, including:
 
-        o  GLX support added for Darwin and Mac OS X with software rendering.
+        o  Indirect GLX acceleration added.
 
-        o  Keymap setup in XDarwin is improved, particularly for interna-
-          tional keyboards.
+        o  Smaller memory footprint and faster 2-D drawing in rootless mode.
 
-        o  In addition to English and Japanese, the XDarwin user interface is
-          now localized in Dutch, French, German, Spanish, and Korean.
+        o  Full screen mode now uses shadowfb for much faster 2-D drawing.
 
-   o  Lots of Cygwin support updates.
+        o  Native fonts can be used on MacOS X.
 
-   o  Support added for OpenBSD/powerpc.
+   o  Various Cygwin support updates, including an experimental rootless X
+     server for Cygwin/XFree86.
 
-   o  Build support added for Linux on IBM S/390.
+   o  AMD x86-64 support (primarily for Linux so far) has been added.
 
-   o  Removed stale support for Amoeba and Minix.
+   o  Support added for OpenBSD/sparc64.
 
-   o  Client-side support added for sparc64 on NetBSD and OpenBSD.
+   o  Major OS/2 support updates.
 
-   o  Support added for building the X server on Linux/m68k.
+   o  Major SCO OpenServer updates.
 
-   o  Support added for building on Linux/arm32.
+   o  Multi-head support has been added for 460GX-based Itanium systems, and
+     for ZX1-based Itanium2 systems.
 
-   o  Updates to Linux/mips support.
+   o  Experimental support for SunOS/Solaris on UltraSPARC systems.
 
 A more complete list of changes can be found in the CHANGELOG that is part of
 the XFree86 source tree.  It can also be viewed online at our CVSweb server
@@ -227,49 +208,50 @@
 
 3.1  Video Drivers
 
-XFree86 4.2.0 includes the following video drivers:
+XFree86 4.3.0 includes the following video drivers:
 
-+--------------+--------------------------+----------------------------------+
-|Driver Name   | Description              | Further Information              |
-+--------------+--------------------------+----------------------------------+
-|apm           | Alliance Pro Motion      | README.apm                       |
-|ark           | Ark Logic                |                                  |
-|ati           | ATI                      | README.ati, README.r128, r128(4) |
-|chips         | Chips & Technologies     | README.chips, chips(4)           |
-|cirrus        | Cirrus Logic             |                                  |
-|cyrix (*)     | Cyrix MediaGX            | README.cyrix                     |
-|fbdev         | Linux framebuffer device | fbdev(4)                         |
-|glide         | Glide2x (3Dfx)           | glide(4)                         |
-|glint         | 3Dlabs, TI               | glint(4)                         |
-|i128          | Number Nine              | README.I128, i128(4)             |
-|i740          | Intel i740               | README.i740                      |
-|i810          | Intel i810               | README.i810, i810(4)             |
-|imstt         | Integrated Micro Solns   |                                  |
-|mga           | Matrox                   | mga(4)                           |
-|neomagic      | NeoMagic                 | neomagic(4)                      |
-|newport (-)   | SGI Newport              | README.newport, newport(4)       |
-|nv            | NVIDIA                   | nv(4)                            |
-|rendition     | Rendition                | README.rendition, rendition(4)   |
-|s3            | S3 (not ViRGE or Savage) |                                  |
-|s3virge       | S3 ViRGE                 | README.s3virge, s3virge(4)       |
-|savage        | S3 Savage                | savage(4)                        |
-|siliconmotion | Silicon Motion           | siliconmotion(4)                 |
-|sis           | SiS                      | README.SiS                       |
-|sunbw2 (+)    | Sun bw2                  |                                  |
-|suncg14 (+)   | Sun cg14                 |                                  |
-|suncg3 (+)    | Sun cg3                  |                                  |
-|suncg6 (+)    | Sun GX and Turbo GX      |                                  |
-|sunffb (+)    | Sun Creator/3D, Elite 3D |                                  |
-|sunleo (+)    | Sun Leo (ZX)             |                                  |
-|suntcx (+)    | Sun TCX                  |                                  |
-|tdfx          | 3Dfx                     |                                  |
-|tga           | DEC TGA                  | README.DECtga                    |
-|trident       | Trident                  | trident(4)                       |
-|tseng         | Tseng Labs               |                                  |
-|vesa          | VESA                     | vesa(4)                          |
-|vga           | Generic VGA              | vga(4)                           |
-|vmware        | VMWare guest OS          | vmware(4)                        |
-+--------------+--------------------------+----------------------------------+
++--------------+--------------------------+---------------------------------------------+
+|Driver Name   | Description              | Further Information                         |
++--------------+--------------------------+---------------------------------------------+
+|apm           | Alliance Pro Motion      | README.apm                                  |
+|ark           | Ark Logic                |                                             |
+|ati           | ATI                      | README.ati, README.r128, r128(4), radeon(4) |
+|chips         | Chips & Technologies     | README.chips, chips(4)                      |
+|cirrus        | Cirrus Logic             |                                             |
+|cyrix (*)     | Cyrix MediaGX            | README.cyrix                                |
+|fbdev         | Linux framebuffer device | fbdev(4)                                    |
+|glide         | Glide2x (3Dfx)           | glide(4)                                    |
+|glint         | 3Dlabs, TI               | glint(4)                                    |
+|i128          | Number Nine              | README.I128, i128(4)                        |
+|i740          | Intel i740               | README.i740                                 |
+|i810          | Intel i8xx               | README.i810, i810(4)                        |
+|imstt         | Integrated Micro Solns   |                                             |
+|mga           | Matrox                   | mga(4)                                      |
+|neomagic      | NeoMagic                 | neomagic(4)                                 |
+|newport (-)   | SGI Newport              | README.newport, newport(4)                  |
+|nsc           | National Semiconductor   | nsc(4)                                      |
+|nv            | NVIDIA                   | nv(4)                                       |
+|rendition     | Rendition                | README.rendition, rendition(4)              |
+|s3            | S3 (not ViRGE or Savage) |                                             |
+|s3virge       | S3 ViRGE                 | README.s3virge, s3virge(4)                  |
+|savage        | S3 Savage                | savage(4)                                   |
+|siliconmotion | Silicon Motion           | siliconmotion(4)                            |
+|sis           | SiS                      | README.SiS, sis(4)                          |
+|sunbw2 (+)    | Sun bw2                  |                                             |
+|suncg14 (+)   | Sun cg14                 |                                             |
+|suncg3 (+)    | Sun cg3                  |                                             |
+|suncg6 (+)    | Sun GX and Turbo GX      |                                             |
+|sunffb (+)    | Sun Creator/3D, Elite 3D |                                             |
+|sunleo (+)    | Sun Leo (ZX)             |                                             |
+|suntcx (+)    | Sun TCX                  |                                             |
+|tdfx          | 3Dfx                     | tdfx(4)                                     |
+|tga           | DEC TGA                  | README.DECtga                               |
+|trident       | Trident                  | trident(4)                                  |
+|tseng         | Tseng Labs               |                                             |
+|vesa          | VESA                     | vesa(4)                                     |
+|vga           | Generic VGA              | vga(4)                                      |
+|vmware        | VMWare guest OS          | vmware(4)                                   |
++--------------+--------------------------+---------------------------------------------+
 
 Drivers marked with (*) are present in a preliminary form in this release,
 but are not complete and/or stable yet.
@@ -281,40 +263,49 @@
 Darwin/Mac OS X uses IOKit drivers and does not use the module loader drivers
 listed above. Further information can be found in README.Darwin.
 
-XFree86 4.2.0 includes the following input drivers:
+XFree86 4.3.0 includes the following input drivers:
 
 3.2  Input Drivers
+
+   +------------+----------------------------------+---------------------+
+   |Driver Name | Description                      | Further Information |
+   +------------+----------------------------------+---------------------+
+   |calcomp     | Calcomp                          |                     |
+   |citron      | Citron                           | citron(4)           |
+   |digitaledge | DigitalEdge                      |                     |
+   |dmc         | DMC                              | dmc(4)              |
+   |dynapro     | Dynapro                          |                     |
+   |elographics | EloGraphics                      |                     |
+   |elographics | EloGraphics                      |                     |
+   |fpit        | Fujitsu Stylistic Tablet PCs     | fpit(4)             |
+   |hyperpen    | HyperPen                         |                     |
+   |js_x        | JamStudio pentablet              | js_x(4)             |
+   |kbd         | generic keyboards (alternate)    | kbd(4)              |
+   |keyboard    | generic keyboards                | keyboard(4)         |
+   |microtouch  | MicroTouch                       |                     |
+   |mouse       | most mouse devices               | mouse(4)            |
+   |mutouch     | MicroTouch                       |                     |
+   |palmax      | Palmax PD1000/PD1100             | palmax(4)           |
+   |penmount    | PenMount                         |                     |
+   |spaceorb    | SpaceOrb                         |                     |
+   |summa       | SummaGraphics                    |                     |
+   |tek4957     | Tektronix 4957 tablet            | tek4957(4)          |
+   |ur98(*)     | Union Reality UR-F98 headtracker | ur98(4)             |
+   |void        | dummy device                     | void(4)             |
+   |wacom       | Wacom tablets                    | wacom(4)            |
+   +------------+----------------------------------+---------------------+
 
-          +------------+--------------------+---------------------+
-          |Driver Name | Description        | Further Information |
-          +------------+--------------------+---------------------+
-          |calcomp     | Calcomp            |                     |
-          |citron      | Citron             | citron(4)           |
-          |digitaledge | DigitalEdge        |                     |
-          |dmc         | DMC                | dmc(4)              |
-          |dynapro     | Dynapro            |                     |
-          |elographics | EloGraphics        |                     |
-          |hyperpen    | HyperPen           |                     |
-          |keyboard    | generic keyboards  | keyboard(4)         |
-          |microtouch  | MicroTouch         |                     |
-          |mouse       | most mouse devices | mouse(4)            |
-          |mutouch     | MicroTouch         |                     |
-          |penmount    | PenMount           |                     |
-          |spaceorb    | SpaceOrb           |                     |
-          |summa       | SummaGraphics      |                     |
-          |void        | dummy device       | void(4)             |
-          |wacom       | Wacom tablets      | wacom(4)            |
-          +------------+--------------------+---------------------+
+Drivers marked with (*) are available for Linux only.
 
 4.  Overview of XFree86 4.x.
 
 Unlike XFree86 3.3.x where there are multiple X server binaries, each of
-which drive different hardware, XFree86 4.2.0 has a single X server binary
+which drive different hardware, XFree86 4.3.0 has a single X server binary
 called XFree86.  This binary can either have one or more video drivers linked
 in statically, or, more usually, dynamically load the video drivers and other
 modules that are needed.
 
-XFree86 4.2.0 has X server support for most UNIX(R) and UNIX-like operating
+XFree86 4.3.0 has X server support for most UNIX(R) and UNIX-like operating
 systems on Intel/x86 platforms, plus support for Linux on Alpha, PowerPC,
 IA-64, Sparc, and Mips platforms, and for Darwin on PowerPC.  Work on support
 for additional architectures and operating systems is in progress, and is
@@ -336,7 +327,7 @@
 the future we plan to take advantage of this to provide more frequent driver
 module updates in between major releases.
 
-The loader in version 4.2.0 has support for Intel (x86), Alpha and PowerPC
+The loader in version 4.3.0 has support for Intel (x86), Alpha and PowerPC
 platforms.  It also has preliminary support for Sparc platforms.
 
 The X server makes use of modules for video drivers, X server extensions,
@@ -442,7 +433,7 @@
 
      The new option AllowDeactivateGrabs allows deactivating any active grab
      with the key sequence Ctrl+Alt+Keypad-Divide and the new option Allow-
-     ClosedownGrabs allows closing the conection to the grabbing client with
+     ClosedownGrabs allows closing the connection to the grabbing client with
      the key sequence Ctrl+Alt+Keypad-Multiply. Note that these options are
      off by default as they allow users to remove the grab used by screen
      saver/locker programs.
@@ -517,8 +508,8 @@
                    Option      "BlankTime"  "5"
                EndSection
 
-     See the XF86Config man page for a more detailed explanation of the for-
-     mat of the new ServerLayout section.
+     See the XF86Config(5) man page for a more detailed explanation of the
+     format of the new ServerLayout section.
 
 The config file search patch has been extended, with the directories /etc/X11
 and /usr/X11R6/etc/X11 being added.  The full search path details are docu-
@@ -684,7 +675,7 @@
 
 4.7  DGA version 2
 
-DGA 2.0 is included in 4.2.0, but is not implemented by all drivers.  Prelim-
+DGA 2.0 is included in 4.3.0, but is not implemented by all drivers.  Prelim-
 inary documentation for the client libraries can be found in the README.DGA
 document.  A good degree of backwards compatibility with version 1.0 is pro-
 vided.
@@ -753,7 +744,7 @@
 overlays and other image operations not possible with the core X rendering
 system.
 
-XFree86 4.2.0 provides a partial implementation of Render sufficient for
+XFree86 4.3.0 provides a partial implementation of Render sufficient for
 drawing anti-aliased text and image composition.  Still to be implemented are
 geometric primitives and affine transformation of images.
 
@@ -784,43 +775,25 @@
 The Xft library uses a configuration file, XftConfig, which contains informa-
 tion about which directories contain font files and also provides a sophisti-
 cated font aliasing mechanism.  Documentation for that file is included in
-the Xft man page.
+the Xft(3) man page.
 
 4.11.2  FreeType support in Xft
 
-XFree86 4.2.0 includes sources for FreeType version 2.0.1, and, by default,
+XFree86 4.3.0 includes sources for FreeType version 2.1.1, and, by default,
 they are built and installed automatically.
 
-If you prefer, you can configure XFree86 4.2.0 to use an existing Freetype2
-installation by telling XFree86 not to build the internal copy and indicating
-where that external version has been installed. Edit (or create) con-
-fig/cf/host.def to include:
-
-   o #define BuildFreetype2Library NO
-
-   o #define Freetype2Dir /usr/local
-
-Note that XFree86 assumes you'll be using a release FreeType no older than
-version 2.0.1.  Early FreeType version 2 releases used a different header
-file installation and aren't compatible with XFree86. Instructions for build-
-ing and installing FreeType can be found in the INSTALL file included with
-the FreeType release.
-
 4.11.3  Application Support For Anti-Aliased Text
 
-Only three applications have been modified in XFree86 4.2.0 to work with the
+Only three applications have been modified in XFree86 4.3.0 to work with the
 Render extension and the Xft and FreeType libraries to provide anti-aliased
 text.  Xterm, xditview and x11perf.  Migration of other applications may
 occur in future releases.
 
-By default, xterm uses core fonts through the standard core API.  It has two
-command line options and associated resources to direct it to use Xft
-instead:
+By default, xterm uses core fonts through the standard core API.  It has a
+command line option and associated resource to direct it to use Xft instead:
 
    o -fa family / .VT100.faceName: family.  Selects the font family to use.
 
-   o -fs pointsize / .VT100.faceSize: pointsize.  Selects the pointsize.
-
 Xditview will use Xft instead of the core API by default.  X11perf includes
 tests to measure the performance of text rendered in three ways, anti-
 aliased, anti-aliased with sub-pixel sampling and regular chunky text, but
@@ -839,121 +812,32 @@
 The xgamma utility makes use of this feature.  Compatibility with the 3.3.x
 version of the extension is provided.  The missing parts of this extension
 and some new features should be completed in a future release.
-
-4.13  Xaw
-
-Two versions of the Xaw library are provided with XFree86 4.x. A version with
-bug fixes and a few binary compatible improvements and a new version with
-several new features.
-
-New features:
-
-   o A displayList resource is available to all Xaw widgets. It basically
-     consists of a list of drawing commands, fully described in the Xaw(3)
-     manual page, that enables a integration of Xaw programs with the new
-     window/desktop managers that allows for configurable themes.
-
-   o Some new actions were added to all Xaw widgets, to allow more config-
-     urable control of the widgets, and to allow setting resources at run
-     time.
-
-   o Since Xpm was integrated into XFree86, programs linked with the new Xaw
-     library     will also link with Xpm. This allows for color background
-     pixmaps, and also for shaped widgets.
-
-   o The text widget is the widget that will present more changes. These
-     include:
-
-        o Block cursor.
-
-        o Compile time limit of 16384 undo/redo levels (that will automati-
-          cally grow if the text is not saved when this mark is reached).
-
-        o Overwrite mode.
-
-        o Text killed is inserted in a kill ring list, this text is not for-
-          gotten, pressing M-y allows traversing the kill ring list.
-
-        o International support for latin languages is available even if the
-          international resource is not set. Users will need to properly set
-          the locale environment to make complete use of this feature.
-
-        o A better multiply interface is provided. Pressing C-u,<number>
-          (where number can be negative) allows passing parameters for text
-          actions.
-
-        o Text can be formatted to have left, right, center or full justifi-
-          cation.
-
-        o Text indentation support is also available.
-
-Bug fixes:
-
-   o The simple menu widget geometry management code was improved to solve
-     problems with menu entries not visible in the screen.
-
-   o The form widget geometry code was changed to solve problems with integer
-     round problems in the child widgets geometry when resizing the parent
-     form widget.
-
-   o Several bugs were fixed in the text code, while some code was rewritten
-     from scratch.
-
-4.14  Xpm
-
-Version 3.4k of the Xpm (X pixmap) library is now integrated into XFree86.
-
-4.15  xedit
-
-Xedit have been changed to use most of the new features added to the new ver-
-sion of the Xaw library, and some xedit only features were added. Emacs users
-will find that several of the emacs key bindings work with the new version of
-xedit. These include:
-
-   o File name tab completion. Including a Emacs dired like window, that will
-     be shown when there are more than one match, when C-x,d is pressed, or
-     when a directory name is specified.
-
-   o An unlimited number of files can be edited at the same time. Including
-     multiple views of the same or different files.
-
-   o The line number of the cursor position is always visible. It can also be
-     customized to show the column number, the position offset and the cur-
-     rent size of the file.
-
-   o There is an autoReplace resource, that enables automatic text replace-
-     ment at the time text is typed. This feature is useful to create simple
-     macros, or to correct common spelling errors.
-
-   o A fully featured ispell interface is also available. This interface is
-     expected to provide most of the features of the terminal interface of
-     the ispell program, with some extra features that include:
 
-        o A compile time limit of 16 undo levels.
+4.13  xedit
 
-        o Terse mode switch.
+Xedit has several new features, including:
 
-        o Dictionary change.
+   o An embedded lisp interpreter that allows easier extension of the editor.
 
-        o The interface also checks for repeated words.
+   o Several new syntax highlight modes, and indentation rules for C and
+     Lisp.
 
-   o A first tentative to add programming modes was done. Currently, there is
-     one mode:
+   o Flexible search/replace interface that allows regex matches.
 
-        o C-mode: this mode is expected to be stable, and fully usable.
+   o Please refer to xedit(1) for more details.
 
-4.16  Font support
+4.14  Font support
 
 Details about the font support in XFree86 4.x can be found in the
 README.fonts document.
 
-4.17  TrueType support
+4.15  TrueType support
 
 XFree86 4.x comes with two TrueType backends, known as `xfsft' (the
 "freetype" module) and `X-TrueType' (the "xtt" module).  Both of these back-
 ends are based on the FreeType library.
 
-4.18  CID font support
+4.16  CID font support
 
 Support for CID-keyed fonts is included in XFree86 4.x.  The CID-keyed font
 format was designed by Adobe Systems <URL:http://www.adobe.com> for fonts
@@ -961,7 +845,7 @@
 by SGI <URL:http://www.sgi.com>.  See the LICENSE document for a copy of the
 CID Font Code Public License.
 
-4.19  Internationalisation of the scalable font backends
+4.17  Internationalisation of the scalable font backends
 
 XFree86 4.x has a ``fontenc'' layer to allow the scalable font backends to
 use a common method of font re-encoding.  This re-encoding makes it possible
@@ -970,14 +854,14 @@
 TrueType backend.  The `X-TrueType' version of the TrueType backend uses a
 different re-encoding method based on loadable encoding modules.
 
-4.20  Large font optimisation
+4.18  Large font optimisation
 
 The glyph metrics array, which all the X clients using a particular font have
 access to, is placed in shared memory, so as to reduce redundant memory con-
 sumption.  For non-local clients, the glyph metrics array is transmitted in a
 compressed format.
 
-4.21  Unicode/ISO 10646 support
+4.19  Unicode/ISO 10646 support
 
 What is included in 4.x:
 
@@ -1010,7 +894,7 @@
    o Both the xfsft (the "freetype" module) and the X-TrueType (the "xtt"
      module) TrueType font backends support Unicode-encoded fonts.
 
-4.22  Luxi fonts from Bigelow and Holmes
+4.20  Luxi fonts from Bigelow and Holmes
 
 XFree86 now includes the ``Luxi'' family of Type 1 fonts and TrueType fonts.
 This family consists of the fonts ``Luxi Serif'', ``Luxi Sans'' and
@@ -1035,7 +919,7 @@
 <design@bigelowandholmes.com> or <info@urwpp.de>, or consult the URW++ web
 site <URL:http://www.urwpp.de>.
 
-4.23  Directory rearrangements
+4.21  Directory rearrangements
 
 Some changes to the installed XFree86 directory structure have been imple-
 mented for 4.x.  One important change is a modified search path for the X
@@ -1046,7 +930,7 @@
 located under the appropriate subdirectories of /var, again with the relevant
 symbolic links in the old location.
 
-     Generated from XFree86: xc/programs/Xserver/hw/xfree86/doc/sgml/RELNOTES.sgml,v 1.70 2002/01/17 18:14:59 dawes Exp $
+     Generated from XFree86: xc/programs/Xserver/hw/xfree86/doc/sgml/RELNOTES.sgml,v 1.81 2003/02/27 00:45:05 dawes Exp $
 
 
-$XFree86: xc/RELNOTES,v 1.6 2002/01/17 23:27:41 dawes Exp $
+$XFree86: xc/RELNOTES,v 1.17 2003/02/27 01:44:02 dawes Exp $
Index: xc/registry
diff -u xc/registry:1.5 xc/registry:1.7
--- xc/registry:1.5	Mon Aug 13 15:34:49 2001
+++ xc/registry	Sun Jun 30 22:25:51 2002
@@ -725,6 +725,8 @@
 	ISO Latin alphabet No. 8
 "ISO8859-15"					[15],[12]
 	ISO Latin alphabet No. 9
+"ISO8859-16"					[15],[12]
+	ISO Latin alphabet No. 10
 "FCD8859-15"					[7]
 	(deprecated)
 	ISO Latin alphabet No. 9, Final Committee Draft
@@ -1119,7 +1121,7 @@
 	Todd Brunhoff, Tektronix
 
 [15]	ISO 8859, Information technology -- 8-bit single-byte coded graphic
-	character sets, Parts 1 through 10, 13, 14, and 15
+	character sets, Parts 1 through 10, 13, 14, 15, and 16
 
 [16]	Inter-Client Communication Conventions Manual
 	The X.Org Group
@@ -1683,3 +1685,5 @@
 [134]   In R6.6 X.Org is reserving the string UTF8_STRING for use as an ICCCM
         property type and selection target.  The ICCCM spec will be updated
         in a future release to fully specify UTF8_STRING.
+
+/* $XFree86: xc/registry,v 1.7 2002/07/01 02:25:51 tsi Exp $ */
Index: xc/config/cf/Amoeba.cf
diff -u xc/config/cf/Amoeba.cf:3.10 xc/config/cf/Amoeba.cf:3.11
--- xc/config/cf/Amoeba.cf:3.10	Wed Jan 17 11:22:29 2001
+++ xc/config/cf/Amoeba.cf	Thu Nov 14 16:01:13 2002
@@ -1,5 +1,5 @@
 XCOMM platform:  $Xorg: Amoeba.cf,v 1.3 2000/08/17 19:41:45 cpqbld Exp $
-XCOMM platform:  $XFree86: xc/config/cf/Amoeba.cf,v 3.10 2001/01/17 16:22:29 dawes Exp $
+XCOMM platform:  $XFree86: xc/config/cf/Amoeba.cf,v 3.11 2002/11/14 21:01:13 tsi Exp $
 
 /*  The presence of this configuration file in the X distribution
  *  does not imply full support for the system it describes.
@@ -253,7 +253,7 @@
 
 
 #ifndef Concat
-#if (__STDC__ && !defined(UnixCpp)) || defined(AnsiCpp)
+#if (defined(__STDC__) && !defined(UnixCpp)) || defined(AnsiCpp)
 #define Concat(a,b)a##b
 #else
 #define Concat(a,b)a/**/b
Index: xc/config/cf/FreeBSD.cf
diff -u xc/config/cf/FreeBSD.cf:3.112 xc/config/cf/FreeBSD.cf:3.128
--- xc/config/cf/FreeBSD.cf:3.112	Thu Jan  3 11:33:49 2002
+++ xc/config/cf/FreeBSD.cf	Tue Jan 14 21:52:12 2003
@@ -2,7 +2,7 @@
 XCOMM
 XCOMM
 XCOMM
-XCOMM platform:  $XFree86: xc/config/cf/FreeBSD.cf,v 3.112 2002/01/03 16:33:49 tsi Exp $
+XCOMM platform:  $XFree86: xc/config/cf/FreeBSD.cf,v 3.128 2003/01/15 02:52:12 dawes Exp $
 
 #ifndef UseElfFormat
 #define UseElfFormat		DefaultToElfFormat
@@ -48,6 +48,9 @@
 #define HasSnprintf		YES
 #define HasBSD44Sockets 	YES
 #define HasDlopen		YES
+#if ((OSRelVersion >= 410002) && OSRelVersion < 500000) || (OSRelVersion >= 500012)
+#define HasSetProcTitle		YES
+#endif
 #ifndef HasLibCrypt
 # define HasLibCrypt		YES
 #endif
@@ -60,6 +63,15 @@
 #define HasVarRun		YES
 #define HasVarDb		YES
 
+#if (OSMajorVersion >= 3)
+#define HasIssetugid		YES
+#define HasPoll			YES
+#endif
+
+#if OSMajorVersion >= 4
+#define HasGetIfAddrs		YES
+#endif
+
 #if (OSMajorVersion > 1)
 #define InstallXloadSetGID	NO
 #else
@@ -77,9 +89,6 @@
 # endif
 # define HasPosixThreads	YES
 # define ThreadedX		YES
-/*
- * math.h uses _REENTRANT and stdio.h uses _THREAD_SAFE, so define both.
- */
 # define SystemMTDefines	-D_REENTRANT -D_THREAD_SAFE
 /*
  * FreeBSD has tread-safe api but no getpwnam_r yet.
@@ -89,10 +98,18 @@
 # if HasLibPthread
 #  define ThreadsLibraries	-lpthread
 # else
-#  define BuildThreadStubLibrary  YES 
-#  define NeedUIThrStubs          YES 
-#  define ThreadsCompileFlags	-pthread
-#  define ThreadsLibraries 	-pthread
+#  if OSRelVersion >= 500043
+#   define BuildThreadStubLibrary  NO
+#   define NeedUIThrStubs          NO
+#  else
+#   define BuildThreadStubLibrary  YES
+#   define NeedUIThrStubs          YES
+#  endif
+#  if (OSRelVersion >= 500016)
+#   define ThreadsLibraries	-lc_r
+#  else
+#   define ThreadsLibraries	-pthread
+#  endif
 #  define SharedX11Reqs		$(LDPRELIB) $(XTHRSTUBLIB)
 #  define SharedXtReqs		$(LDPRELIB) $(XLIBONLY) $(SMLIB) $(ICELIB) $(XTHRSTUBLIB)
 # endif
@@ -144,7 +161,7 @@
  *
  *    ld: warning: libXThrStub.so.6, needed by libX11.so, not found
  */
-#if BuildThreadStubLibrary && !UseInstalled
+#if BuildThreadStubLibrary && (!defined(UseInstalledX11) || !UseInstalledX11)
 # define CcCmd			$(CLIENTENVSETUP) cc
 # define CplusplusCmd		$(CLIENTENVSETUP) c++
 #else
@@ -187,6 +204,10 @@
 #define HasSetUserContext	YES
 #endif
 
+#if OSMajorVersion >= 5 || (OSMajorVersion == 4 && OSMinorVersion >= 6)
+#define HasGetpeereid		YES
+#endif
+
 /* 3.3(?) and later has support for setting MTRRs */
 #ifndef HasMTRRSupport
 #if OSMajorVersion > 3 || (OSMajorVersion == 3 && OSMinorVersion >= 3)
@@ -216,6 +237,23 @@
 #endif
 #endif
 
+/*
+ * SSE and 3DNow will be autodetected, so binutils is the only 
+ * requirement for enabling this.  By 4.2 they were all supported.
+ */
+#if defined(i386Architecture) && \
+	(OSMajorVersion >= 5 || (OSMajorVersion == 4 && OSMinorVersion >= 2))
+# define HasX86Support          YES
+# define HasMMXSupport		YES
+# define Has3DNowSupport	YES
+# define HasSSESupport		YES
+#else
+# define HasX86Support	        NO
+# define HasMMXSupport		NO
+# define Has3DNowSupport	NO
+# define HasSSESupport		NO
+#endif
+
 /* 
  * This doesn't work the way it does on every other system. On FreeBSD it's
  * only a "hint, not a demand", whatever that means. Note that this is not 
@@ -420,6 +458,9 @@
 #ifdef AlphaArchitecture
 #define ServerExtraDefines GccGasOption XFree86ServerDefines -D_XSERVER64
 #endif
+#ifdef Sparc64Architecture
+#define ServerExtraDefines GccGasOption XFree86ServerDefines -D_XSERVER64
+#endif
 
 #define StandardDefines	-DCSRG_BASED
 
@@ -507,6 +548,10 @@
 #define PamLibraries		-lpam DlLibrary
 #endif
 
+#ifndef SharedLibXdmGreet
+# define SharedLibXdmGreet		NO
+#endif
+
 /*
  * On FreeBSD, the run-time loader will use the built-in "rpath" before
  * LD_LIBRARY_PATH.  This means that utilities like mkfontdir will load
@@ -521,8 +566,8 @@
 #ifndef PreloadFontSetup
 #define PreloadFontSetup	LD_PRELOAD="`(cd $(XENVLIBDIR); echo libXfont*.so.?)`"
 #endif
-#ifndef PreloadSetup
-#define PreloadSetup		LD_PRELOAD="`(cd $(XENVLIBDIR); echo lib[A-f]*.so.? | grep -v Xfont)`"
+#ifndef PreloadXFTSetup
+#define PreloadXFTSetup		LD_PRELOAD="`(cd $(XENVLIBDIR); echo libfreetype.so.? libXft.so.? libXrender.so.? libfontconfig.so.?)`"
 #endif
 #endif
 
@@ -538,9 +583,9 @@
 #endif
 
 /*
- * A hack to work around an optimization problem with gcc 2.95.2
+ * A hack to work around an optimization problem with gcc 2.95.2 - 2.95.4
  */
-#if OSMajorVersion >= 4
+#if OSMajorVersion == 4
 #define GccOptBug295
 #endif
 
Index: xc/config/cf/Imake.cf
diff -u xc/config/cf/Imake.cf:3.74 xc/config/cf/Imake.cf:3.81
--- xc/config/cf/Imake.cf:3.74	Fri Nov 16 11:47:50 2001
+++ xc/config/cf/Imake.cf	Tue Feb 18 11:51:45 2003
@@ -17,7 +17,7 @@
  *
  *     4.  Create a .cf file with the name given by MacroFile.
  */
-XCOMM $XFree86: xc/config/cf/Imake.cf,v 3.74 2001/11/16 16:47:50 dawes Exp $
+XCOMM $XFree86: xc/config/cf/Imake.cf,v 3.81 2003/02/18 16:51:45 tsi Exp $
 
 #if defined(__APPLE__)
 # undef __APPLE__
@@ -47,6 +47,9 @@
 #define cygwinArchitecture
 #define i386Architecture
 #undef i386
+#undef i486
+#undef i586
+#undef i686
 #undef __i386__
 #undef _X86_
 #undef __CYGWIN__
@@ -126,9 +129,10 @@
 #   endif
 #   undef mips
 # endif
-# ifdef __alpha__
+# if defined(__alpha__) || defined(alpha)
 #   define AlphaArchitecture
 #   undef __alpha__
+#   undef alpha
 # endif
 # ifdef mc68020
 #  define Mc68020Architecture
@@ -157,6 +161,8 @@
 # ifdef __powerpc__
 #  define PpcArchitecture
 #  undef __powerpc__
+#  undef __macppc__
+#  undef macppc
 # endif
 #endif /* OpenBSD */
 
@@ -187,6 +193,7 @@
 # endif
 # ifdef __alpha__
 #   define AlphaArchitecture
+#   define AlphaBsdArchitecture
 #   undef __alpha__
 # endif
 # ifdef mc68000
@@ -221,6 +228,10 @@
 #  define AlphaArchitecture
 #  undef __alpha__
 # endif
+# ifdef __sparc64__
+#  define Sparc64Architecture
+#  undef __sparc64__
+# endif
 #endif /* __FreeBSD__ */
 
 #ifdef AMOEBA
@@ -706,6 +717,12 @@
 #  endif
 #  undef __k6
 # endif /* __k6 */
+/* Keep this order! s390x has also __s390__ defined */
+# if defined(__s390x__)
+#  define s390xArchitecture
+#  undef __s390x__
+#  undef __s390__
+# endif
 # ifdef __s390__
 #   define s390Architecture
 #  undef __s390__
@@ -807,13 +824,23 @@
 #  endif
 #  undef __SH4__
 # endif /* __SH4__ */
-XCOMM  for compatibility with 3.3.x 
+/* for compatibility with 3.3.x */
 # ifdef PpcArchitecture
 #  define PowerPCArchitecture
 # endif
 # if defined(__s390x__)
 #  define s390xArchitecture
 #  undef __s390x__
+# endif
+# if defined(__x86_64__)
+#  undef __x86_64__
+#  define x86_64Architecture
+# endif
+# if defined(x86_64__)
+#  undef x86_64__
+#  ifndef x86_64Architecture
+#   define x86_64Architecture
+#  endif
 # endif
 #endif /* linux */
 
Index: xc/config/cf/Imake.rules
diff -u xc/config/cf/Imake.rules:3.102 xc/config/cf/Imake.rules:3.113
--- xc/config/cf/Imake.rules:3.102	Mon Dec 17 15:00:37 2001
+++ xc/config/cf/Imake.rules	Mon Dec  9 18:00:42 2002
@@ -5,7 +5,7 @@
 XCOMM
 XCOMM
 XCOMM
-XCOMM rules:  $XFree86: xc/config/cf/Imake.rules,v 3.102 2001/12/17 20:00:37 dawes Exp $
+XCOMM rules:  $XFree86: xc/config/cf/Imake.rules,v 3.113 2002/12/09 23:00:42 dawes Exp $
 
 /*
  *		   MACHINE-INDEPENDENT RULES; DO NOT MODIFY
@@ -44,6 +44,7 @@
  * ProofCleanTarget		()
  * RemoveTargetProgram		(program)
  * MakeDir			(dir)
+ * InstallDirectory		(dir)
  * BuildIncludesTop		(srclist)
  * BuildIncludes		(srclist,dstsubdir,dstupdir)
  * LinkRule			(program,options,objects,libraries)
@@ -118,6 +119,7 @@
  * ObjectCompile		(options)
  * NormalLibObjCompile		(options)
  * NormalSharedLibObjCompile	(options)
+ * NormalRelocLibObjCompile	(options)
  * LibObjCompile		(dir,options)
  * DebuggedLibObjCompile	(options)
  * ProfiledLibObjCompile	(options)
@@ -233,7 +235,7 @@
  * Concat - concatenates two strings.
  */
 #ifndef Concat
-#if (__STDC__ && !defined(UnixCpp)) || defined(AnsiCpp)
+#if (defined(__STDC__) && !defined(UnixCpp)) || defined(AnsiCpp)
 #define Concat(a,b)a##b
 #else
 #define Concat(a,b)a/**/b
@@ -244,7 +246,7 @@
  * Concat3 - concatenates three strings.
  */
 #ifndef Concat3
-#if (__STDC__ && !defined(UnixCpp)) || defined(AnsiCpp)
+#if (defined(__STDC__) && !defined(UnixCpp)) || defined(AnsiCpp)
 #define Concat3(a,b,c)a##b##c
 #else
 #define Concat3(a,b,c)a/**/b/**/c
@@ -255,7 +257,7 @@
  * Concat4 - concatenates four strings.
  */
 #ifndef Concat4
-#if (__STDC__ && !defined(UnixCpp)) || defined(AnsiCpp)
+#if (defined(__STDC__) && !defined(UnixCpp)) || defined(AnsiCpp)
 #define Concat4(a,b,c,d)a##b##c##d
 #else
 #define Concat4(a,b,c,d)a/**/b/**/c/**/d
@@ -285,7 +287,7 @@
  *           exists to avoid problems with some preprocessors
  */
 #ifndef _XUseCat
-# if (__STDC__ && !defined(UnixCpp)) || defined(AnsiCpp)
+# if (defined(__STDC__) && !defined(UnixCpp)) || defined(AnsiCpp)
 #  if defined(UseInstalled) || UseInstalledX11
 #   define _XUseCat(a,b,c) a##c
 #  else
@@ -525,6 +527,12 @@
 	fi
 #endif /* MakeDir */
 
+#ifndef InstallDirectory
+#define InstallDirectory(dir)						@@\
+install::								@@\
+	MakeDir(dir)
+#endif /* InstallDirectory */
+
 #ifndef BuildIncludesTop
 #define BuildIncludesTop(srclist)					@@\
 includes:: srclist							@@\
@@ -778,6 +786,20 @@
 InstallManPage(program,$(MANDIR))
 #endif /* CplusplusProgramTargetHelper */
 
+#ifndef CplusplusProgramTargetHelperNoMan
+#define	CplusplusProgramTargetHelperNoMan(program,srcs,objs,deplib,locallib,syslib) @@\
+ProgramTargetName(program): $(objs) $(deplib)				@@\
+	RemoveTargetProgram($@)						@@\
+	CplusplusLinkRule($@,$(CXXLDOPTIONS),$(objs),locallib $(LDLIBS) syslib) @@\
+									@@\
+CenterProgramTarget(program,$(srcs),$(objs),locallib,syslib)		@@\
+SentinelCplusplusProgramTarget(program,$(objs) $(deplib),$(objs) locallib $(LDLIBS) syslib) @@\
+PurifyCplusplusProgramTarget(program,$(objs) $(deplib),$(objs) locallib $(LDLIBS) syslib) @@\
+ProofCplusplusProgramTarget(program,$(objs) $(deplib),$(objs) locallib $(LDLIBS) syslib) @@\
+									@@\
+InstallProgram(program,$(BINDIR))					@@
+#endif /* CplusplusProgramTargetHelperNoMan */
+
 /*
  * ComplexProgramTarget - generate rules for compiling and linking the 
  * program specified by $(OBJS) and $(SRCS), installing the program and its
@@ -786,9 +808,9 @@
  */
 #ifndef ComplexProgramTarget
 #define	ComplexProgramTarget(program)					@@\
-        PROGRAM = program						@@\
+        PROGRAM = ProgramTargetName(program)				@@\
 									@@\
-AllTarget(program)							@@\
+AllTarget(ProgramTargetName(program))					@@\
 									@@\
 ProgramTargetHelper(program,SRCS,OBJS,DEPLIBS,$(LOCAL_LIBRARIES),NullParameter) @@\
 									@@\
@@ -801,9 +823,9 @@
 
 #ifndef ComplexCplusplusProgramTarget
 #define	ComplexCplusplusProgramTarget(program)				@@\
-        PROGRAM = program						@@\
+        PROGRAM = ProgramTargetName(program)				@@\
 									@@\
-AllTarget(program)							@@\
+AllTarget(ProgramTargetName(program))					@@\
 									@@\
 CplusplusProgramTargetHelper(program,SRCS,OBJS,DEPLIBS,$(LOCAL_LIBRARIES),NullParameter) @@\
 									@@\
@@ -818,13 +840,13 @@
  * ComplexProgramTargetNoMan - generate rules for compiling and linking
  * the program specified by $(OBJS) and $(SRCS), installing the program 
  * and generating dependencies.  It should only be used in Imakefiles
- * that describe a single program.
+ * that describe a single program, and have no manual page.
  */
 #ifndef ComplexProgramTargetNoMan
 #define ComplexProgramTargetNoMan(program)				@@\
-        PROGRAM = program						@@\
+        PROGRAM = ProgramTargetName(program)				@@\
 									@@\
-AllTarget(program)							@@\
+AllTarget(ProgramTargetName(program))					@@\
 									@@\
 ProgramTargetHelperNoMan(program,SRCS,OBJS,DEPLIBS,$(LOCAL_LIBRARIES),NullParameter) @@\
 									@@\
@@ -835,6 +857,21 @@
 	RemoveFile(ProgramTargetName(program))
 #endif /* ComplexProgramTargetNoMan */
 
+#ifndef ComplexCplusplusProgramTarget
+#define	ComplexCplusplusProgramTarget(program)				@@\
+        PROGRAM = program						@@\
+									@@\
+AllTarget(program)							@@\
+									@@\
+CplusplusProgramTargetHelperNoMan(program,SRCS,OBJS,DEPLIBS,$(LOCAL_LIBRARIES),NullParameter) @@\
+									@@\
+DependTarget()								@@\
+LintTarget()								@@\
+									@@\
+clean::									@@\
+	RemoveFile(ProgramTargetName(program))
+#endif /* ComplexCplusplusProgramTarget */
+
 /*
  * ComplexProgramTarget_1 - generate rules for compiling and linking the
  * program specified by $(OBJS1) and $(SRCS1), installing the program and its
@@ -1376,8 +1413,8 @@
 NoCmpScript(ProgramTargetName($(RMAN)))					@@\
 									@@\
 ProgramTargetName($(RMAN)):						@@\
-	@echo "checking $@ over in $(TOP)/config/util first..."; \	@@\
-	cd $(TOP)/config/util && $(MAKE) rman; \			@@\
+	@echo "checking $(RMANBASENAME) over in $(TOP)/config/util first..."; \	@@\
+	cd $(TOP)/config/util && $(MAKE) $(RMANBASENAME); \		@@\
 	echo "okay, continuing in $(CURRENT_DIR)"
 
 #endif /* UseInstalled */
@@ -1588,7 +1625,7 @@
 #ifndef MakeFlagsToShellFlags
 #define MakeFlagsToShellFlags(makeflags,shellcmd)\
 	for flag in ${MAKEFLAGS} ''; do \				@@\
-	  case "$$flag" in *=*) ;; *[makeflags]*) shellcmd;; esac; done
+	  case "$$flag" in *=*) ;; --*) ;; *[makeflags]*) shellcmd;; esac; done
 #endif
 
 /*
@@ -1640,6 +1677,10 @@
 #if UseSeparateConfDir && HasSymLinks
 #define LinkConfDirectoryLong(mdir,cdir,rdir,ldir,opath,npath)		@@\
 install::								@@\
+	@MakeFlagsToShellFlags(i,set +e); \				@@\
+	if [ -h Concat($(DESTDIR),npath/mdir) ]; then \			@@\
+	  $(RM) Concat($(DESTDIR),npath/mdir); \			@@\
+	fi								@@\
 	MakeDir(Concat($(DESTDIR),opath/cdir))				@@\
 	MakeDir(Concat($(DESTDIR),npath/mdir))				@@\
 	@MakeFlagsToShellFlags(i,set +e); \				@@\
@@ -2129,6 +2170,14 @@
 #define NormalLibObjCompile(options) ObjectCompile(options)
 #endif
 
+#ifndef NormalRelocLibObjCompile
+# if !StaticNeedsPicForShared
+#  define NormalRelocLibObjCompile(options) NormalLibObjCompile(options)
+# else 
+#  define NormalRelocLibObjCompile(options) NormalLibObjCompile(options $(PICFLAGS))
+# endif
+#endif
+
 #ifndef NormalLibObjCplusplusCompile
 #define NormalLibObjCplusplusCompile(options) ObjectCplusplusCompile(options)
 #endif
@@ -3078,7 +3127,8 @@
 #ifdef UseInstalled
 #define ImakeSubCmdHelper $(IMAKE_CMD)
 #else
-#define ImakeSubCmdHelper $(IMAKEPREFIX)$(IMAKE) -I$(IMAKEPREFIX)$(IRULESRC) $(IMAKE_DEFINES)
+#define ImakeSubCmdHelper $(IMAKEPREFIX)$(IMAKE) -I$(IMAKEPREFIX)$(IRULESRC) \
+			  $(IMAKE_DEFINES) $(IMAKE_WARNINGS)
 #endif
 
 #endif /* MakeMakeSubdirs */
@@ -3352,7 +3402,7 @@
 									@@\
 install:: module							@@\
 	MakeDir($(DESTDIR)dest/subdir)					@@\
-	$(INSTALL) -c module $(DESTDIR)dest/subdir
+	$(INSTALL) -c $(INSTDATFLAGS) module $(DESTDIR)dest/subdir
 #endif
 
 #ifndef InstallDynamicNamedModule
@@ -3362,7 +3412,7 @@
 									@@\
 install:: module							@@\
 	MakeDir($(DESTDIR)dest/subdir)					@@\
-	$(INSTALL) -c module $(DESTDIR)dest/subdir/instname
+	$(INSTALL) -c $(INSTDATFLAGS) module $(DESTDIR)dest/subdir/instname
 #endif
 
 #ifndef InstallObjectModule
Index: xc/config/cf/Imake.tmpl
diff -u xc/config/cf/Imake.tmpl:3.116 xc/config/cf/Imake.tmpl:3.139
--- xc/config/cf/Imake.tmpl:3.116	Tue Jan 15 16:22:33 2002
+++ xc/config/cf/Imake.tmpl	Tue Jan 28 17:06:08 2003
@@ -5,7 +5,7 @@
 XCOMM
 XCOMM
 XCOMM
-XCOMM $XFree86: xc/config/cf/Imake.tmpl,v 3.116 2002/01/15 21:22:33 keithp Exp $
+XCOMM $XFree86: xc/config/cf/Imake.tmpl,v 3.139 2003/01/28 22:06:08 alanh Exp $
 XCOMM ----------------------------------------------------------------------
 
 /*
@@ -45,10 +45,20 @@
 #include <site.def>
 #undef BeforeVendorCF
 
+#if defined(HasGcc3) && !defined(HasGcc2)
+# define HasGcc2 HasGcc3
+#endif
 #if defined(HasGcc2) && !defined(HasGcc)
 # define HasGcc HasGcc2
 #endif
 
+#ifndef HasCenterLineC
+#define HasCenterLineC NO
+#endif
+#ifndef HasCenterLineCplusplus
+#define HasCenterLineCplusplus NO
+#endif
+
 #ifndef HasClearmake
 # define HasClearmake NO
 #endif
@@ -116,6 +126,13 @@
 #ifndef UseEtcX11
 #define UseEtcX11		YES
 #endif
+#ifndef UseInstalledX11
+# define UseInstalledX11        NO
+#endif
+#ifdef UseInstalled
+# undef UseInstalledX11
+# define UseInstalledX11        YES
+#endif
 #if NothingOutsideProjectRoot
 #undef UseEtcX11
 #define UseEtcX11		NO
@@ -255,6 +272,10 @@
 #endif
 #endif
 
+#ifndef CompressManPages
+#define CompressManPages NO
+#endif
+
 #ifndef HasGroff
 #define HasGroff NO
 #endif
@@ -263,6 +284,19 @@
 #define HasCookieMaker	NO
 #endif
 
+#ifndef DoLoadableServer
+#define DoLoadableServer NO
+#endif
+#ifndef MakeDllModules
+#define MakeDllModules NO
+#endif
+#ifndef StripInstalledPrograms
+#define StripInstalledPrograms NO	/* leave symbol table just in case */
+#endif
+#ifndef StaticNeedsPicForShared
+#define StaticNeedsPicForShared NO
+#endif
+
 #include <Imake.rules>
 
 #ifndef HasSharedLibraries
@@ -301,6 +335,7 @@
 
 #ifndef CrossCompiling
 #define CrossCompiling		NO
+#undef  CrossCompileDir
 #endif
 #ifndef BourneShell			/* to force shell in makefile */
 #define BourneShell		/bin/sh
@@ -321,6 +356,13 @@
 #define HasLargeTmp		NO	/* be paranoid */
 #endif
 
+#ifndef HasMotif
+#define HasMotif		NO
+#endif
+#ifndef HasBSDAuth
+#define HasBSDAuth		NO
+#endif
+
 #ifndef HasBSD44Sockets
 #define HasBSD44Sockets		NO
 #endif
@@ -359,6 +401,10 @@
 #ifndef HasPutenv
 #define HasPutenv		NO	/* assume not */
 #endif
+/* setenv(3) and unsetenv(3) */
+#ifndef HasSetenv
+#define HasSetenv		YES	/* assume yes */
+#endif
 #ifndef HasVoidSignalReturn
 #define HasVoidSignalReturn	YES	/* assume yes */
 #endif
@@ -371,12 +417,21 @@
 #ifndef HasDlopen
 #define HasDlopen		NO	/* assume not */
 #endif
+#ifndef HasIssetugid
+#define HasIssetugid		NO	/* assume not */
+#endif
+#ifndef HasGetresuid
+#define HasGetresuid		NO	/* assume not */
+#endif
 #ifndef HasMkstemp
 #define HasMkstemp		NO	/* assume not */
 #endif
 #ifndef HasUsableFileMmap
 #define HasUsableFileMmap	NO	/* assume not */
 #endif
+#ifndef HasGetIfAddrs
+#define HasGetIfAddrs		NO	/* assume not */
+#endif
 #ifndef HasStickyDirBit
 #define HasStickyDirBit		YES
 #endif
@@ -389,6 +444,12 @@
 #ifndef HasPamMisc
 #define HasPamMisc		NO
 #endif
+#ifndef HasGetpeereid
+#define HasGetpeereid		NO
+#endif
+#ifndef NoStrstr
+#define NoStrstr		NO
+#endif
 /* byte-order defaults */
 #ifndef ByteOrder
 #if defined(VaxArchitecture)
@@ -401,6 +462,8 @@
 #define ByteOrder		X_LITTLE_ENDIAN
 #elif defined(ia64Architecture)
 #define ByteOrder		X_LITTLE_ENDIAN
+#elif defined(x86_64Architecture)
+#define ByteOrder		X_LITTLE_ENDIAN
 #elif defined(SparcArchitecture) || defined(Sparc64Architecture)
 #define ByteOrder		X_BIG_ENDIAN
 #elif defined(AlphaArchitecture)
@@ -430,6 +493,9 @@
 #ifndef HasFortran
 #define HasFortran		NO
 #endif
+#ifndef HasGcc2ForCplusplus
+#define HasGcc2ForCplusplus	NO
+#endif
 #ifndef HasCplusplus
 #if HasGcc2ForCplusplus
 #define HasCplusplus		YES
@@ -484,12 +550,19 @@
 #ifndef HasFreetype2
 #define HasFreetype2		NO
 #endif
+/* If the system has the Fontconfig library */
+#ifndef HasFontconfig
+#define HasFontconfig		NO
+#endif
+#ifndef HasLibpng
+#define HasLibpng		NO
+#endif
 #if HasKrbIV
 #ifndef KrbIVIncludes
 #define KrbIVIncludes /**/
 #endif
 #ifndef KrbIVLibraries
-#define KrbIVLibraries -lkafs -lkrb -ldes
+#define KrbIVLibraries -lkrb -ldes
 #endif
 #endif
 #if HasKrb5
@@ -640,6 +713,9 @@
 #define TclLibrary
 #endif
 #endif
+#ifndef HasTsLib
+#define HasTsLib NO
+#endif
 /*
  * Libtool has two different behaviours for version numbers.
  * On platforms which support a minor number, the library
@@ -667,9 +743,6 @@
 #define NeedWidePrototypes	YES	/* mix and match ANSI-C, non-ANSI */
 #endif
 
-#ifndef StripInstalledPrograms
-#define StripInstalledPrograms NO	/* leave symbol table just in case */
-#endif
 #ifndef UseCCMakeDepend			/* use slow cc -E script */
 #define UseCCMakeDepend NO
 #endif
@@ -688,14 +761,18 @@
 #define	DefaultUsrBin /usr/bin
 #endif
 
+#ifndef LibDirName
+# define LibDirName lib
+#endif
+
 #ifndef UsrLibDir
 #ifdef ProjectRoot
-#define UsrLibDir Concat(ProjectRoot,/lib)
+#define UsrLibDir Concat3(ProjectRoot,/,LibDirName)
 #ifndef AlternateUsrLibDir
 #define AlternateUsrLibDir YES
 #endif
 #else
-#define UsrLibDir /usr/lib
+#define UsrLibDir Concat3(/usr,/,LibDirName)
 #ifndef AlternateUsrLibDir
 #define AlternateUsrLibDir NO
 #endif
@@ -722,7 +799,7 @@
  * various standards (e.g., Linux/OpenGL).
  */
 #ifndef SystemUsrLibDir
-#define SystemUsrLibDir /usr/lib
+#define SystemUsrLibDir /usr/LibDirName
 #endif
 #ifndef SystemUsrIncDir
 #define SystemUsrIncDir /usr/include
@@ -789,6 +866,9 @@
 #ifndef AppLoadDefs
 #define AppLoadDefs -D__apploaddir__=$(XAPPLOADDIR)
 #endif
+#ifndef LibManDefs
+#define LibManDefs -D__libmansuffix__=$(LIBMANSUFFIX)
+#endif
 #ifndef FileManDefs
 #define FileManDefs -D__filemansuffix__=$(FILEMANSUFFIX)
 #endif
@@ -802,11 +882,6 @@
 #define ProjectManDefs -D__projectroot__=$(PROJECTROOT)
 #endif
 
-
-#ifndef CompressManPages
-#define CompressManPages NO
-#endif
-
 #ifndef CompressManCmd
 #define CompressManCmd gzip -n
 #endif
@@ -948,24 +1023,18 @@
 #ifndef BootstrapCFlags
 #define BootstrapCFlags /**/
 #endif
+#ifndef HasGcc3
+#define HasGcc3 NO
+#endif
 #ifndef HasGcc2
-#define HasGcc2 NO
+#define HasGcc2 HasGcc3
 #endif
 #ifndef HasGcc
 #define HasGcc HasGcc2
 #endif
-#ifndef HasGcc2ForCplusplus
-#define HasGcc2ForCplusplus NO
-#endif
 #ifndef HasBrokenCCForLink
 #define HasBrokenCCForLink NO
 #endif
-#ifndef HasCenterLineC
-#define HasCenterLineC NO
-#endif
-#ifndef HasCenterLineCplusplus
-#define HasCenterLineCplusplus NO
-#endif
 #ifndef CcCmd
 #if HasGcc2
 #define CcCmd gcc -fpcc-struct-return 
@@ -1036,7 +1105,7 @@
 #define GzipCmd gzip
 #endif
 #ifndef CppCmd
-#define CppCmd /lib/cpp
+#define CppCmd /LibDirName/cpp
 #endif
 #ifndef RawCppCmd
 #define RawCppCmd CppCmd -undef
@@ -1166,6 +1235,9 @@
 #define ModuleRanlibCmd RanlibCmd
 #endif
 
+#ifndef HostCcCmd
+#define HostCcCmd cc
+#endif
 #ifndef StandardIncludes	/* for platform-specifics */
 #define StandardIncludes /**/
 #endif
@@ -1208,19 +1280,18 @@
 #define NdbmDefines /**/
 #endif
 #endif
-#ifndef LdPreLib
-#if !defined(UseInstalled)
-#if !BuildLibraries && AlternateUsrLibDir
-#define LdPreLib -L$(BUILDLIBDIR) -L$(USRLIBDIR)
-#else
-#define LdPreLib -L$(BUILDLIBDIR)
-#endif
-#else
-#if AlternateUsrLibDir
-#define LdPreLib -L$(USRLIBDIR)
-#else
-#define LdPreLib /**/
+#ifndef HasLdRunPath
+#define HasLdRunPath NO
 #endif
+#ifndef LdPreLib
+# if !defined(UseInstalled)
+#  define LdPreLib -L$(BUILDLIBDIR)
+# else
+# if AlternateUsrLibDir
+#  define LdPreLib -L$(USRLIBDIR)
+# else
+# define LdPreLib /**/
+# endif
 #endif
 #endif
 #ifndef LdPostLib
@@ -1279,6 +1350,9 @@
 #define ImakeCmd $(IMAKESRC)/imake
 #endif
 #endif
+#ifndef ImakeWarningFlags
+#define ImakeWarningFlags	/* Nothing */
+#endif
 #ifndef DependCmd
 #if UseGccMakeDepend
 #ifdef UseInstalled		/* assume BINDIR in path */
@@ -1301,7 +1375,7 @@
 #endif
 #endif
 #ifndef DependDefines
-# if UseCCMakedepend || UseGccMakedepend
+# if UseCCMakeDepend || UseGccMakeDepend
 #  define DependDefines /**/
 # else
 #  define DependDefines -DUSE_MAKEDEPEND
@@ -1472,6 +1546,59 @@
 #define FilesToClean *.CKP *.ln *.BAK *.bak *.Osuf core errs ,* *~ *.a .emacs_* tags TAGS make.log MakeOut 
 #endif
 
+#ifdef CrossCompileDir
+# ifndef StripPath
+#  define StripPath(x) `echo x|sed "s%.*/%%"`
+# endif
+# ifndef CrossArCmd
+#  define CrossArCmd Concat3(CrossCompileDir,/,StripPath(ArCmd))
+# endif
+# ifndef CrossCcCmd
+#  define CrossCcCmd Concat3(CrossCompileDir,/,StripPath(CcCmd))
+# endif
+# ifndef CrossAsCmd
+#  define CrossAsCmd Concat3(CrossCompileDir,/,StripPath(AsCmd))
+# endif
+# ifdef HasFortran
+#  ifndef CrossFortranCmd
+#   define CrossFortranCmd Concat3(CrossCompileDir,/,StripPath(FortranCmd))
+#  endif
+# endif
+# ifndef CrossCplusplusCmd
+#  define CrossCplusplusCmd Concat3(CrossCompileDir,/,StripPath(CplusplusCmd))
+# endif
+# ifndef CrossCppCmd
+#  define CrossCppCmd Concat3(CrossCompileDir,/,StripPath(CppCmd))
+# endif
+# ifndef CrossRawCppCmdCmd
+#  define CrossRawCppCmd Concat3(CrossCompileDir,/,StripPath(RawCppCmd))
+# endif
+# ifndef CrossPreProcessCmd
+#  define CrossPreProcessCmd Concat3(CrossCompileDir,/,StripPath(PreProcessCmd))
+# endif
+# ifndef CrossAsCmd
+#  define CrossAsCmd Concat3(CrossCompileDir,/,StripPath(AsCmd))
+# endif
+# ifndef CrossLdCmd
+#  define CrossLdCmd Concat3(CrossCompileDir,/,StripPath(LdCmd))
+# endif
+# ifndef CrossModuleLdCmd
+#  define CrossModuleLdCmd CrossLdCmd
+# endif
+# ifndef CrossLintCmd
+#  define CrossLintCmd Concat3(CrossCompileDir,/,StripPath(LintCmd))
+# endif
+# ifndef CrossRanlibCmd
+#  define CrossRanlibCmd Concat3(CrossCompileDir,/,StripPath(RanlibCmd))
+# endif
+# ifndef CrossModuleCcCmd
+#  define CrossModuleCcCmd Concat3(CrossCompileDir,/,StripPath(ModuleCcCmd))
+# endif
+# ifndef CrossAsCmd
+#  define CrossAsCmd Concat3(CrossCompileDir,/,StripPath(AsCmd))
+# endif
+#endif
+
           PATHSEP = PathSeparator
             SHELL = BourneShell
 
@@ -1484,6 +1611,7 @@
           REVPATH = RevPathCmd
     EXPORTLISTGEN = ExportListCmd
              RMAN = RmanCmd
+     RMANBASENAME = HostProgramTargetName(rman)
       RMANOPTIONS = RmanOptions
         CONFIGSRC = ConfigSrc
          IMAKESRC = $(CONFIGSRC)/imake
@@ -1511,13 +1639,27 @@
 #ifdef VarDbDirectory
          VARDBDIR = VarDbDirectory	/* OS location of db/state files */
 #endif
-
+#ifdef CrossCompileDir
+               AR = CrossArCmd
+#else
                AR = ArCmd
+#endif
+XCOMM Nice try but useless: make will inherit BOOTSTRAPCFLAGS 
+XCOMM from  top Makefile
   BOOTSTRAPCFLAGS = BootstrapCFlags	/* set if cpp does not have uniq sym */
+#ifdef CrossCompileDir
+               CC = CrossCcCmd
+               AS = CrossAsCmd
+#else
                CC = CcCmd
                AS = AsCmd
+#endif
 #if HasFortran
+# ifdef CrossCompileDir
+               FC = CrossFortranCmd
+# else
                FC = FortranCmd
+# endif
       FDEBUGFLAGS = FortranDebugFlags
           FCFLAGS = FortranFlags $(FDEBUGFLAGS)
 #endif
@@ -1525,7 +1667,11 @@
 
 .SUFFIXES: .CCsuf
 
+#ifdef CrossCompileDir
+              CXX = CrossCplusplusCmd
+#else
               CXX = CplusplusCmd
+#endif
           CXXFILT = CplusplusFilt
            CXXLIB = CplusplusLibC
     CXXDEBUGFLAGS = DefaultCplusplusDebugFlags
@@ -1538,26 +1684,35 @@
        CXXDEFINES = $(CXXINCLUDES) $(CXXSTD_DEFINES) $(THREADS_CXXDEFINES) $(DEFINES) $(CXXEXTRA_DEFINES)
          CXXFLAGS = $(CXXDEBUGFLAGS) $(CXXOPTIONS) $(THREADS_CXXFLAGS) $(CXXDEFINES)
 #endif
-
-#if !BuildLibraries && AlternateIncRoot
-INSTALLED_INCLUDES = -I$(INCROOT)
-#endif
-
          COMPRESS = CompressCmd
           GZIPCMD = GzipCmd
+#ifdef CrossCompileDir
+              CPP = CrossCppCmd $(STD_CPP_DEFINES)
+           RAWCPP = CrossRawCppCmd $(STD_CPP_OPTIONS)
+    PREPROCESSCMD = CrossPreProcessCmd $(STD_CPP_DEFINES)
+#else
               CPP = CppCmd $(STD_CPP_DEFINES)		/* simple filters */
            RAWCPP = RawCppCmd $(STD_CPP_OPTIONS)
     PREPROCESSCMD = PreProcessCmd $(STD_CPP_DEFINES)	/* prefered; mdep */
+#endif
           INSTALL = InstallCmd
      INSTALLFLAGS = InstallFlags
+#ifdef CrossCompileDir
+               LD = CrossLdCmd
+#else
                LD = LdCmd
+#endif
               LEX = LexCmd
                M4 = M4Cmd
           M4FLAGS = M4Flags
            LEXLIB = LexLib
              YACC = YaccCmd
            CCYACC = CplusplusYaccCmd
+#ifdef CrossCompileDir
+             LINT = CrossLintCmd
+#else
              LINT = LintCmd
+#endif
       LINTLIBFLAG = LintLibFlag
          LINTOPTS = LintOpts
                LN = LnCmd
@@ -1565,7 +1720,11 @@
                MV = MvCmd
                CP = CpCmd
 #if DoRanlibCmd
+#ifdef CrossCompileDir
+           RANLIB = CrossCompileDir/RanlibCmd
+#else
            RANLIB = RanlibCmd
+#endif
   RANLIBINSTFLAGS = RanlibInstFlags
 #endif
                RM = RmCmd
@@ -1578,7 +1737,7 @@
   DRIVERMANSUFFIX = DriverManSuffix	/* suffix for driver man pages */
      MANSRCSUFFIX = ManSrcSuffix	/* suffix for man page source */
      MANNEWSUFFIX = ManNewSuffix	/* suffix for preprocessed man source */
-          MANDEFS = AppLoadDefs FileManDefs MiscManDefs DriverManDefs ProjectManDefs $(XORGMANDEFS) $(VENDORMANDEFS)
+          MANDEFS = AppLoadDefs FileManDefs LibManDefs MiscManDefs DriverManDefs ProjectManDefs $(XORGMANDEFS) $(VENDORMANDEFS)
 
    COMPRESSMANCMD = CompressManCmd
 
@@ -1591,16 +1750,28 @@
              NEQN = NeqnCmd
               COL = ColCmd
          COLFLAGS = ColFlags
+#ifdef CrossCompileDir
+	    MODCC = CrossModuleCcCmd
+#else
             MODCC = ModuleCcCmd
+#endif
            MODCPP = ModuleCppCmd
         MODCFLAGS = ModuleCFlags
             MODAS = ModuleAsCmd
        MODASFLAGS = ModuleAsFlags
+#ifdef CrossCompileDir
+	    MODLD = CrossModuleLdCmd
+#else
             MODLD = ModuleLdCmd
+#endif
        MODLDFLAGS = ModuleLdFlags
 MODLDCOMBINEFLAGS = ModuleLdCombineFlags
             MODAR = ModuleArCmd
+#ifdef CrossCompileDir
+        MODRANLIB = CrossCompileDir/ModuleRanlibCmd
+#else
         MODRANLIB = ModuleRanlibCmd
+#endif
 #if HasLatex
             DVIPS = DvipsCmd
             LATEX = LatexCmd
@@ -1617,6 +1788,9 @@
            PROOF = ProofCmd
     PROOFOPTIONS = ProofOptions
 #endif
+#if CrossCompiling
+          HOST_CC = HostCcCmd
+#endif
      STD_INCLUDES = StandardIncludes
   STD_CPP_OPTIONS = StandardCppOptions
   STD_CPP_DEFINES = StandardCppOptions StandardCppDefines $(PROJECT_DEFINES)
@@ -1636,7 +1810,7 @@
     SHAREDCODEDEF = SharedCodeDef
          SHLIBDEF = SharedLibraryDef
 #ifdef SharedLibraryLoadFlags
-     SHLIBLDFLAGS = SharedLibraryLoadFlags
+     SHLIBLDFLAGS = SharedLibraryLoadFlags $(SHLIBGLOBALSFLAGS)
 #endif
 /*
  * Here we set up flags needed to produce position-independent code 
@@ -1725,6 +1899,7 @@
 #else
 # define TopInclude	-I$(TOP)
 #endif
+
       CDEBUGFLAGS = DefaultCDebugFlags
         CCOPTIONS = DefaultCCOptions	/* to distinguish from param flags */
 /*
@@ -1738,7 +1913,7 @@
        ALLDEFINES = $(ALLINCLUDES) $(STD_DEFINES) $(PROTO_DEFINES) $(THREADS_DEFINES) $(MODULE_DEFINES) $(DEFINES) $(EXTRA_DEFINES)
            CFLAGS = $(CDEBUGFLAGS) $(CCOPTIONS) $(THREADS_CFLAGS) $(MODULE_CFLAGS) $(ALLDEFINES)
         LINTFLAGS = $(LINTOPTS) -DLINT $(ALLDEFINES) $(DEPEND_DEFINES)
-         LDPRELIB = LdPreLib
+         LDPRELIB = LdPreLib $(INSTALLED_LIBS)
         LDPOSTLIB = LdPostLib
         LDOPTIONS = $(CDEBUGFLAGS) $(CCOPTIONS)  $(EXTRA_LDOPTIONS) $(THREADS_LDFLAGS) $(LOCAL_LDFLAGS) $(LDPRELIBS)
      CXXLDOPTIONS = $(CXXDEBUGFLAGS) $(CXXOPTIONS) $(EXTRA_LDOPTIONS) $(THREADS_CXXLDFLAGS) $(LOCAL_LDFLAGS) $(LDPRELIBS)
@@ -1779,12 +1954,14 @@
            RM_CMD = $(RM)
 
     IMAKE_DEFINES = /* leave blank, for command line use only */
+   IMAKE_WARNINGS = ImakeWarningFlags
 #ifdef UseInstalled
          IRULESRC = $(CONFIGDIR)	/* used in rules file */
-        IMAKE_CMD = $(IMAKE) -DUseInstalled -I$(IRULESRC) $(IMAKE_DEFINES)
+        IMAKE_CMD = $(IMAKE) -DUseInstalled -I$(IRULESRC) $(IMAKE_DEFINES) \
+		    $(IMAKE_WARNINGS)
 #else
          IRULESRC = $(CONFIGSRC)/cf
-        IMAKE_CMD = $(IMAKE) -I$(IRULESRC) $(IMAKE_DEFINES)
+        IMAKE_CMD = $(IMAKE) -I$(IRULESRC) $(IMAKE_DEFINES) $(IMAKE_WARNINGS)
 #endif
 #if !HasClearmake
      /* clearmake records relevant defines and flags in the build script,
@@ -1822,6 +1999,14 @@
 #endif
 #include LocalTmplFile
 
+#if !BuildLibraries && AlternateIncRoot
+INSTALLED_INCLUDES = -I$(INCROOT)
+#endif
+
+#if !defined(UseInstalled) && !BuildLibraries && AlternateUsrLibDir
+INSTALLED_LIBS = -L$(USRLIBDIR)
+#endif
+
 #ifdef FixupLibReferences
 FixupLibReferences()
 #endif
@@ -1832,7 +2017,7 @@
            OSNAME = OSName
 #endif
     USRLIBDIRPATH = UsrLibDirPath
-        LDPRELIBS = LdPreLibs
+        LDPRELIBS = LdPreLibs $(INSTALLED_LIBS)
        LDPOSTLIBS = LdPostLibs
      TOP_INCLUDES = TopIncludes
   PROJECT_DEFINES = ProjectDefines
@@ -1914,11 +2099,17 @@
 #endif
 
 /* must be after all install.man rules that install anything */
+#ifndef MakeManKeywords
+#define MakeManKeywords		NO
+#endif
 #if MakeManKeywords		/* typically only at top level */
 install.man:: man_keywords
 #endif
 
 /* must be after all install.man rules that install anything */
+#ifndef MakeHtmlManIndex
+#define MakeHtmlManIndex	NO
+#endif
 #if MakeHtmlManIndex		/* typically only at top level */
 install.man:: html_index
 #endif
@@ -1945,9 +2136,9 @@
 #endif /* if subdirectory rules are needed */
 
 #ifndef IHaveSpecialMakefileTarget
-/* "distclean" also removes the Makefile */
+/* "distclean" also removes the Makefile and the depend file */
 distclean::
-	RemoveFile(Makefile)
+	RemoveFiles(Makefile DependFileName)
 #endif
 
 XCOMM ----------------------------------------------------------------------
Index: xc/config/cf/Imakefile
diff -u xc/config/cf/Imakefile:3.27 xc/config/cf/Imakefile:3.30
--- xc/config/cf/Imakefile:3.27	Mon Aug 27 13:40:55 2001
+++ xc/config/cf/Imakefile	Wed Feb 26 04:21:32 2003
@@ -1,5 +1,5 @@
 XCOMM $Xorg: Imakefile,v 1.3 2000/08/17 19:41:46 cpqbld Exp $
-XCOMM $XFree86: xc/config/cf/Imakefile,v 3.27 2001/08/27 17:40:55 dawes Exp $
+XCOMM $XFree86: xc/config/cf/Imakefile,v 3.30 2003/02/26 09:21:32 dawes Exp $
 
 XCOMM Some compilers generate fatal errors if an -L directory does
 XCOMM not exist.  Since BUILDLIBDIR may not exist yet suppress its use.
@@ -17,6 +17,7 @@
 
 DEFFILES = \
 xf86site.def \
+date.def \
 version.def \
 $(HOSTDEFFILES) \
 site.def
@@ -24,11 +25,12 @@
 RULEFILES = \
 Imake.rules \
 Motif.rules \
-cygwin.rules \
 Win32.rules \
 X11.rules \
 bsdLib.rules \
 cde.rules \
+cygwin.rules \
+darwinLib.rules \
 gnuLib.rules \
 hpLib.rules \
 ibmLib.rules \
@@ -57,11 +59,12 @@
 Server.tmpl \
 ServerLib.tmpl \
 Threads.tmpl \
-cygwin.tmpl \
 WinLib.tmpl \
 X11.tmpl \
 bsdLib.tmpl \
 cde.tmpl \
+cygwin.tmpl \
+darwinLib.tmpl \
 hpLib.tmpl \
 gnuLib.tmpl \
 ibmLib.tmpl \
@@ -151,7 +154,7 @@
 	RemoveFile($${TMP}); \
 	echo "" > $${TMP}; \
 	$(INSTALL) $(INSTALLFLAGS) $(INSTDATFLAGS) $${TMP} \
-		$(DESTDIR)$(DRIVERSDKDIRDIR)/config/cf/host.def; \
+		$(DESTDIR)$(DRIVERSDKDIR)/config/cf/host.def; \
 	RemoveFile($${TMP}))
 #endif
 #endif
Index: xc/config/cf/Library.tmpl
diff -u xc/config/cf/Library.tmpl:3.15 xc/config/cf/Library.tmpl:3.21
--- xc/config/cf/Library.tmpl:3.15	Mon Aug 27 13:40:55 2001
+++ xc/config/cf/Library.tmpl	Fri Jan  3 21:48:24 2003
@@ -19,8 +19,39 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/Library.tmpl,v 3.15 2001/08/27 17:40:55 dawes Exp $
+XCOMM $XFree86: xc/config/cf/Library.tmpl,v 3.21 2003/01/04 02:48:24 dawes Exp $
 
+#ifndef DoNormalLib
+#define DoNormalLib NO
+#endif
+#ifndef DoSharedLib
+#define DoSharedLib NO
+#endif
+#ifndef DoDebugLib
+#define DoDebugLib NO
+#endif
+#ifndef DoProfileLib
+#define DoProfileLib NO
+#endif
+#ifndef DoExtraLib
+#define DoExtraLib NO
+#endif
+
+#ifndef HasSharedData
+#define HasSharedData NO
+#endif
+#ifndef HugeLibrary
+#define HugeLibrary NO
+#endif
+
+#ifndef ShlibBindGlobals
+#define ShlibBindGlobals NO
+#endif
+
+#if ShlibBindGlobals && defined(ShlibGlobalsFlags)
+SHLIBGLOBALSFLAGS = ShlibGlobalsFlags
+#endif
+
 #ifndef LibraryCplusplusOptions
 # if DoSharedLib && defined(SharedLibraryCplusplusOptions)
 #  define LibraryCplusplusOptions SharedLibraryCplusplusOptions
@@ -46,6 +77,12 @@
 # define SeparateSharedCompile YES
 #endif
 
+#ifdef CrossCompileDir
+# ifndef StripPath
+#  define StripPath(x) `echo x|sed "s%.*/%%"`
+# endif
+#endif 
+
 #ifndef CplusplusSource
 # ifndef LibraryCcCmd
 #  if DoSharedLib && defined(SharedLibraryCcCmd)
@@ -62,7 +99,17 @@
 #  endif
 # endif
 
+#ifdef CrossCompileDir
+# ifndef CrossLibraryCcCmd
+#  define CrossLibraryCcCmd Concat3(CrossCompileDir,/,StripPath(LibraryCcCmd))
+# endif
+#endif
+
+#ifdef CrossCompileDir
+         CC = CrossLibraryCcCmd
+#else
          CC = LibraryCcCmd
+#endif
   CCOPTIONS = LibraryCCOptions
 STD_DEFINES = LibraryDefines $(PROJECT_DEFINES)
 CDEBUGFLAGS = LibraryCDebugFlags
@@ -72,13 +119,24 @@
    PICFLAGS = LargePositionIndependentCFlags
 # endif
 #else
-# ifndef LibraryCplusplusCmd
-#  if DoSharedLib && defined(SharedLibraryCplusplusCmd)
-#   define LibraryCplusplusCmd SharedLibraryCplusplusCmd
-#  else
-#   define LibraryCplusplusCmd CplusplusCmd
+# ifndef CrossCompileDir
+#  ifndef LibraryCplusplusCmd
+#   if DoSharedLib && defined(SharedLibraryCplusplusCmd)
+#    define LibraryCplusplusCmd SharedLibraryCplusplusCmd
+#   else
+#    define LibraryCplusplusCmd CplusplusCmd
+#   endif
 #  endif
+# else 
+#  ifndef CrossLibraryCplusplusCmd
+#   if DoSharedLib && defined(SharedLibraryCplusplusCmd)
+#    define CrossLibraryCplusplusCmd Concat3(CrossCompileDir,/,StripPath(SharedLibraryCplusplusCmd))
+#   else
+#    define CrossLibraryCplusplusCmd Concat3(CrossCompileDir,/,StripPath(CplusplusCmd))
+#   endif
+#  endif
 # endif
+
 # ifndef LibraryCplusplusOptions
 #  if DoSharedLib && defined(SharedLibraryCplusplusOptions)
 #   define LibraryCplusplusOptions SharedLibraryCplusplusOptions
@@ -87,7 +145,11 @@
 #  endif
 # endif
 
+#ifdef CrossCompileDir
+          CXX = CrossLibraryCplusplusCmd
+#else
           CXX = LibraryCplusplusCmd
+#endif
    CXXOPTIONS = LibraryCplusplusOptions
   STD_DEFINES = LibraryDefines $(PROJECT_DEFINES)
 CXXDEBUGFLAGS = LibraryCplusplusDebugFlags
@@ -147,7 +209,11 @@
 #  define _NormalCleanDir() LibCleanDir(unshared)
 # else
 #  define _NormalLibMkdir() $(_NULLCMD_)
-#  define _NormalObjCompile(options) NormalLibObjCompile(options)
+#  if !DoSharedLib &&  defined(IncludeSharedObjectInNormalLib)
+#   define _NormalObjCompile(options) NormalRelocLibObjCompile(options)
+#  else
+#   define _NormalObjCompile(options) NormalLibObjCompile(options)
+#  endif
 #  define _NormalObjCplusplusCompile(options) NormalLibObjCplusplusCompile(options)
 #  define _NormalCleanDir() $(_NULLCMD_)
 # endif
@@ -166,10 +232,6 @@
 #endif
 #endif
 
-#ifndef DoExtraLib
-#define DoExtraLib NO
-#endif
-
 #ifndef LibInstallBuild
 #define LibInstallBuild NO
 #endif
@@ -203,6 +265,19 @@
 	_ExtraObjCompile(options)					@@\
 	_SharedObjCompile(options)
 
+#ifndef SeparateSharedCompile
+# define _CompileObjSeparateOpts(target,staticopts,sharedopts) \
+	_CompileObj(target,sharedopts)
+#else
+# define _CompileObjSeparateOpts(target,staticopts,sharedopts)		@@\
+target									@@\
+	_DebuggedObjCompile(staticopts)					@@\
+	_ProfiledObjCompile(staticopts)					@@\
+	_NormalObjCompile(staticopts)					@@\
+	_ExtraObjCompile(staticopts)					@@\
+	_SharedObjCompile(sharedopts)	
+#endif
+
 #ifdef CplusplusSource
 # define _CompileObjCplusplus(target, options)				@@\
 target									@@\
@@ -255,6 +330,16 @@
 CenterLoadTarget(debug_src,basename.SRCsuf,NullParameter,$(ALLDEFINES) options)
 #endif /* SpecialCLibObjectRule */
 
+#ifndef SpecialCLibObjectRuleSeparateOpts
+# define SpecialCLibObjectRuleSeparateOpts(basename,depends,staticopts,shopts) @@\
+_CompileObjSeparateOpts(basename.Osuf: basename.SRCsuf depends,staticopts,shopts)	@@\
+									@@\
+basename.i: basename.SRCsuf depends					@@\
+	CPPOnlyCompile(basename.SRCsuf,sharedopts)			@@\
+									@@\
+CenterLoadTarget(debug_src,basename.SRCsuf,NullParameter,$(ALLDEFINES) options)
+#endif /* SpecialCLibObjectRuleSepareateOpts */
+
 #ifndef SpecialCplusplusLibObjectRule
 # define SpecialCplusplusLibObjectRule(basename,depends,options)	@@\
 _CompileObjCplusplus(basename.Osuf: basename.SRCsuf depends,options)	@@\
@@ -372,9 +457,9 @@
 # if !defined(LibCreate) || LibCreate
 #  if DoSharedLib
 #   if HugeLibrary && defined(SharedLibraryTarget3)
-SharedLibraryTarget3($(LIBNAME),$(SoRev),$(OBJS1),$(OBJS2),$(OBJS3),.,.)
+SharedLibraryTarget3($(LIBNAME),$(SoRev),$(OBJS1),$(OBJS2),$(OBJS3) $(EXTRASHAREDOBJS),.,.)
 #   else
-SharedLibraryTarget($(LIBNAME),$(SoRev),$(OBJS),.,.)
+SharedLibraryTarget($(LIBNAME),$(SoRev),$(OBJS) $(EXTRASHAREDOBJS),.,.)
 #   endif
 #   if !defined(LibInstall) || LibInstall
 InstallSharedLibrary($(LIBNAME),$(SoRev),$(SHLIBDIR))
@@ -389,15 +474,15 @@
 #  if DoNormalLib
 #   if HugeLibrary
 #    if DoSharedLib && SeparateSharedCompile
-UnsharedLibraryTarget3($(LIBNAME),$(OBJS1),$(OBJS2),$(OBJS3),unshared,..)
+UnsharedLibraryTarget3($(LIBNAME),$(OBJS1),$(OBJS2),$(OBJS3) $(EXTRAUNSHAREDOBJS),unshared,..)
 #    else
-NormalLibraryTarget3($(LIBNAME),$(OBJS1),$(OBJS2),$(OBJS3))
+NormalLibraryTarget3($(LIBNAME),$(OBJS1),$(OBJS2),$(OBJS3) $(EXTRAUNSHAREDOBJS))
 #    endif
 #   else
 #    if DoSharedLib && SeparateSharedCompile
-UnsharedLibraryTarget($(LIBNAME),$(OBJS),unshared,..)
+UnsharedLibraryTarget($(LIBNAME),$(OBJS) $(EXTRAUNSHAREDOBJS),unshared,..)
 #    else
-NormalLibraryTarget($(LIBNAME),$(OBJS))
+NormalLibraryTarget($(LIBNAME),$(OBJS) $(EXTRAUNSHAREDOBJS))
 #    endif
 #   endif
 #   if !defined(LibInstall) || LibInstall
@@ -405,19 +490,19 @@
 #   endif
 #  endif
 #  if DoProfileLib
-ProfiledLibraryTarget($(LIBNAME),$(OBJS))
+ProfiledLibraryTarget($(LIBNAME),$(OBJS) $(EXTRAUNSHAREDOBJS))
 #   if !defined(LibInstall) || LibInstall
 InstallLibrary($(LIBNAME)_p,$(USRLIBDIR))
 #   endif
 #  endif
 #  if DoDebugLib
-DebuggedLibraryTarget($(LIBNAME),$(OBJS))
+DebuggedLibraryTarget($(LIBNAME),$(OBJS) $(EXTRAUNSHAREDOBJS))
 #   if !defined(LibInstall) || LibInstall
 InstallLibrary($(LIBNAME)_d,$(USRLIBDIR))
 #   endif
 #  endif
 #  if DoExtraLib && defined(ExtraLibRules)
-ExtraLibraryTarget($(LIBNAME),$(SoRev),$(OBJS))
+ExtraLibraryTarget($(LIBNAME),$(SoRev),$(OBJS) $(EXTRAUNSHAREDOBJS))
 #   if !defined(LibInstall) || LibInstall
 ExtraInstallLibrary($(LIBNAME),$(SoRev))
 #   endif
@@ -435,6 +520,12 @@
 AllTarget($(OBJS3))
 #   else
 AllTarget($(OBJS))
+#   endif
+#   if DoSharedLib
+AllTarget($(EXTRASHAREDOBJS))
+#   endif
+#   if DoNormalLib
+AllTarget($(EXTRAUNSHAREDOBJS))
 #   endif
 #  endif /* LibBuild */
 # endif /* LibCreate */
Index: xc/config/cf/NetBSD.cf
diff -u xc/config/cf/NetBSD.cf:3.102 xc/config/cf/NetBSD.cf:3.108
--- xc/config/cf/NetBSD.cf:3.102	Thu Jan  3 11:33:49 2002
+++ xc/config/cf/NetBSD.cf	Sat Dec 14 17:36:03 2002
@@ -2,7 +2,7 @@
 
 
 
-XCOMM platform:  $XFree86: xc/config/cf/NetBSD.cf,v 3.102 2002/01/03 16:33:49 tsi Exp $
+XCOMM platform:  $XFree86: xc/config/cf/NetBSD.cf,v 3.108 2002/12/14 22:36:03 dawes Exp $
 
 
 #ifndef OSName
@@ -75,6 +75,16 @@
 # define HasMktemp		YES
 #endif
 
+#ifndef HasIssetugid
+# if (OSMajorVersion > 1 || (OSMajorVersion == 1 && OSMinorVersion >= 5))
+#  define HasIssetugid          YES
+# endif
+#endif
+
+#if (OSMajorVersion == 1 && OSMinorVersion >= 5 || OSMajorVersion > 1) 
+#define HasGetIfAddrs		YES
+#endif
+
 #define HasUsableFileMmap	YES
 
 #define HasVarRun		YES
@@ -92,6 +102,9 @@
 #define SystemMTDefines		-D_REENTRANT PthreadHLocation
 #define ThreadsLibraries	LibPthreadLocation -Wl,-rpath,/usr/local/lib -lpthread
 #define SharedX11Reqs		ThreadsLibraries
+#else 
+#define HasPosixThreads		NO
+#define ThreadedX		NO
 #endif
 
 /*
@@ -109,16 +122,6 @@
 
 #define MkdirHierCmd		mkdir -p
 
-#if OSMajorVersion < 1 || OSMajorVersion == 1 && OSMinorVersion < 5
-#define CppCmd          	/usr/libexec/cpp
-#else
-#define CppCmd			/usr/bin/cpp
-#endif
-#define StandardCppOptions	-traditional
-#define StandardCppDefines	/**/
-#define PreProcessCmd   	CppCmd
-#define PreIncDir		/usr/include
-
 #undef CcCmd
 #define CcCmd 			gcc
 #ifndef DefaultCCOptions
@@ -127,13 +130,25 @@
 #else
 #ifdef Arm32Architecture
 #define DefaultCCOptions 	-ansi -Dasm=__asm -fsigned-char \
-				-fomit-frame-pointer GccWarningOptions
+				-fomit-frame-pointer
+#elif defined(PpcArchitecture)
+# define DefaultCCOptions	-ansi -Dasm=__asm -fsigned-char
 #else
 #define DefaultCCOptions 	-ansi -Dasm=__asm GccWarningOptions
 #endif
 #endif
 #endif
 
+#ifndef UseGccMakeDepend
+#define UseGccMakeDepend	YES
+#endif
+
+#define CppCmd			cpp
+#define StandardCppOptions	-traditional
+#define StandardCppDefines	/**/
+#define PreProcessCmd   	CcCmd -E
+#define PostIncDir		/usr/include
+
 #define GccGasOption 		-DGCCUSESGAS
 #define AsmDefines 		-DUSE_GAS
 
@@ -181,17 +196,19 @@
 # endif
 # define OptimizedCDebugFlags 	DefaultGcc2i386Opt
 # if OSMajorVersion < 1
-#  define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DXNO_SYSCONF
+#  define ServerOSDefines	XFree86ServerOSDefines -DXNO_SYSCONF
 # else
-#  define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME
+#  define ServerOSDefines	XFree86ServerOSDefines
 # endif
 # if OSMajorVersion == 1 && OSMinorVersion >= 1 || OSMajorVersion >= 2
 #  define ServerExtraSysLibs	-li386
 # endif
 #else
 # define OptimizedCDebugFlags 	-O2
-# if defined(SparcArchitecture) || defined(AlphaArchitecture)
+# if defined(SparcArchitecture)
 #  define ServerOSDefines 	-DDDXOSINIT
+# elif defined(AlphaArchitecture)
+#  define ServerOSDefines 	XFree86ServerOSDefines
 # elif defined(Arm32Architecture)
 #   define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME
 # elif defined(PpcArchitecture)
@@ -199,7 +216,11 @@
 # else
 #  define ServerOSDefines 	/**/
 # endif
-# define ServerExtraSysLibs	/**/
+# if defined(AlphaArchitecture)
+#  define ServerExtraSysLibs	-lalpha
+# else
+#  define ServerExtraSysLibs	/**/
+# endif
 #endif
 #ifdef i386Architecture
 # define ServerExtraDefines GccGasOption XFree86ServerDefines
@@ -218,6 +239,12 @@
 #  else
 #   define ServerExtraDefines XFree86ServerDefines
 #  endif
+# elif defined(AlphaArchitecture)
+	/* XXX for the following */
+#  define ServerExtraDefines GccGasOption XFree86ServerDefines -D_XSERVER64
+#  ifndef XFree86ConsoleDefines
+#   define XFree86ConsoleDefines -DWSCONS_SUPPORT -DPCCONS_SUPPORT -DPCVT_SUPPORT
+#  endif
 #elif defined(AlphaArchitecture)
 #   define ServerExtraDefines GccGasOption -D_XSERVER64
 #elif defined(Arm32Architecture)
@@ -327,11 +354,7 @@
  */
 #if defined(i386Architecture)
 # ifndef HasNetBSDApertureDriver
-#  define HasNetBSDApertureDriver	NO
-   /* Where the aperture driver is installed */
-#  ifndef NetBSDApertureDir
-#   define NetBSDApertureDir		/usr/local/aperture
-#  endif
+#  define HasNetBSDApertureDriver	YES
 # endif
 
 /*
@@ -366,6 +389,23 @@
 # endif
 #endif
 
+/*
+ * MMX, SSE and 3DNow will be autodetected. NetBSD 1.6 and up have the
+ * necessary kernel and toolchain support.
+ */
+#if defined(i386Architecture) &&  \
+	((OSMajorVersion > 1) || (OSMajorVersion == 1 && OSMinorVersion > 5))
+# define HasX86Support          YES
+# define HasMMXSupport          YES
+# define Has3DNowSupport        YES
+# define HasSSESupport          YES
+#else
+# define HasX86Support          NO
+# define HasMMXSupport          NO
+# define Has3DNowSupport        NO
+# define HasSSESupport          NO
+#endif
+
 #ifndef HasCookieMaker
 # if OSMajorVersion == 1 && OSMinorVersion >= 5 || OSMajorVersion >= 2
    /* NetBSD 1.5 and later have /dev/urandom */
@@ -512,7 +552,10 @@
 #include <bsdLib.rules>
 #endif /* HasSharedLibraries */
 
-#if defined(i386Architecture) || defined(Arm32Architecture) || defined(PpcArchitecture) 
+/* Always build the XInput library, regardless of server support on this plattform */
+#define BuildXInputLib          YES
+
+#if defined(i386Architecture) || defined(Arm32Architecture) || defined(AlphaArchitecture) || defined(PpcArchitecture)
 # include <xfree86.cf>
 #endif
 
@@ -521,17 +564,18 @@
  */
 #ifdef SparcArchitecture
 #ifndef Xsun24Server
-#define Xsun24Server	NO
+#define Xsun24Server	YES
 #endif
 #ifndef XsunServer
 #define XsunServer	YES
 #endif
 #ifndef XsunMonoServer
-#define XsunMonoServer	YES
+#define XsunMonoServer	NO	/* XXX: does not link */
 #endif
 #ifndef BuildScreenSaverLibrary
 #define BuildScreenSaverLibrary	YES
 #endif
+
 /*
  * XFree86 uses its own (more portable) database routines to speed up 
  * the RGB database lookups
@@ -562,8 +606,8 @@
  * Definition for compiling on Alpha machines
  */
 #ifdef AlphaArchitecture
-#define	BuildServer	NO
-/* Build the shared XDM greeter on Alph if it supports shared libs */
+
+/* Build the shared XDM greeter on Alpha if it supports shared libs */
 #define SharedLibXdmGreet HasSharedLibraries
 #endif
 
@@ -596,7 +640,11 @@
 #ifndef SharedLibXdmGreet
 #define SharedLibXdmGreet NO
 #endif
+
+#ifndef BuildHtmlManPages
+#define BuildHtmlManPages NO	/* We don't want HTML manpages */
+#endif
 
-#ifndef BuildHtmlManPages 
-#define BuildHtmlManPages NO /* We don't want HTML manpages */ 
+#ifndef UseSeparateConfDir
+#define UseSeparateConfDir NO	/* We don't want appdefs in "/etc/X11". */
 #endif
Index: xc/config/cf/OpenBSD.cf
diff -u xc/config/cf/OpenBSD.cf:3.66 xc/config/cf/OpenBSD.cf:3.79
--- xc/config/cf/OpenBSD.cf:3.66	Thu Jan  3 11:33:49 2002
+++ xc/config/cf/OpenBSD.cf	Sun Jan 12 12:03:23 2003
@@ -1,4 +1,4 @@
-XCOMM platform:  $XFree86: xc/config/cf/OpenBSD.cf,v 3.66 2002/01/03 16:33:49 tsi Exp $
+XCOMM platform:  $XFree86: xc/config/cf/OpenBSD.cf,v 3.79 2003/01/12 17:03:23 herrb Exp $
 XCOMM
 
 #ifndef OSName
@@ -56,6 +56,7 @@
 #define HasKrbIV		YES
 #endif
 #define HasUsableFileMmap	YES
+#define HasShadowPasswd		NO
 
 #define HasNCurses		YES
 #define NCursesLibName		-lcurses
@@ -66,6 +67,7 @@
 
 #define HasVarRun		YES
 #define HasVarDb		YES
+#define VarLibDir		VarDbDirectory
 
 #define InstallXloadSetGID	NO
 
@@ -73,6 +75,12 @@
 #define HasLibPthread		NO
 #endif
 
+#ifndef HasIssetugid
+# if (OSMajorVersion >= 2)
+#  define HasIssetugid		YES
+# endif
+#endif
+
 #ifndef HasMktemp
 # if (OSMajorVersion > 2) || (OSMajorVersion == 2 && OSMinorVersion >= 1)
 #  define HasMktemp		YES
@@ -81,6 +89,11 @@
 # endif
 #endif
 
+/* OpenBSD >= 2.7 has getifaddrs() */
+#if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion >= 7)
+#define HasGetIfAddrs		YES
+#endif
+
 /* OpenBSD >= 2.8 has setusercontext() */
 #if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion > 7)
 #define HasSetUserContext	YES
@@ -91,6 +104,11 @@
 # define HasBSDAuth		YES
 #endif
 
+/* OpenBSD 3.0 and later has getpeereid() */
+#if OSMajorVersion >= 3
+# define HasGetpeereid		YES
+#endif
+
 /* OpenBSD 3.0 has APM with kqueue interface */
 #if OSMajorVersion >= 3
 # define HasApmKqueue		YES
@@ -100,7 +118,7 @@
 #if OSMajorVersion >= 3 
 # define HasLibUsb		YES
 # ifndef HasLibUsbHid
-#  if OSMajorVersion == 3 && OsMinorVersion > 0 || OSMajorVersion > 3
+#  if OSMajorVersion == 3 && OSMinorVersion > 0 || OSMajorVersion > 3
 #   define HasLibUsbHid		YES
 #   define UsbHidLib 		-lusbhid
 #  else
@@ -117,6 +135,11 @@
 #define UseGas			YES
 #define GnuCpp			YES
 
+#ifndef HasGccStackProtector	
+#define HasGccStackProtector	NO
+#endif
+
+#define UseGnuMalloc		NO
 
 #define NeedConstPrototypes	YES
 #define NeedFunctionPrototypes	YES
@@ -126,23 +149,25 @@
 
 #define MkdirHierCmd		mkdir -p
 
+#ifndef CppCmd
 #define CppCmd          	/usr/libexec/cpp
+#endif
 #define StandardCppOptions	-traditional
 #define StandardCppDefines	/**/
 #define PreProcessCmd   	CppCmd
 #define PreIncDir		DefaultGccIncludeDir
 
-#undef CcCmd
-#define CcCmd 			gcc
+#ifndef CcCmd
+#define CcCmd 			cc
+#endif
 #ifndef DefaultCCOptions
 #if defined(UseInstalled)
 #define DefaultCCOptions 	/**/
 #else
 #  ifdef  PpcArchitecture
-#    define DefaultCCOptions	-ansi -fsigned-char -Dasm=__asm \
-				GccWarningOptions
+#    define DefaultCCOptions	-ansi -fsigned-char GccWarningOptions
 #  else
-#    define DefaultCCOptions 	-ansi -Dasm=__asm GccWarningOptions
+#    define DefaultCCOptions 	-ansi GccWarningOptions
 #  endif
 #endif
 #endif
@@ -150,13 +175,28 @@
 #define GccGasOption 		-DGCCUSESGAS
 #define AsmDefines 		-DUSE_GAS
 
+/* UseElfFormat defaults to YES if __ELF__ set */
+#ifndef UseElfFormat
+# ifdef __ELF__
+#  undef __ELF__			/* other imake files shouldn't care */
+#  define UseElfFormat YES
+# else
+#  define UseElfFormat NO
+# endif
+#endif
+
+/*
+ * Increment shared libraries major numbers if using Gcc Stack Protector
+ * (This introduces an ABI change)
+ */
+#ifndef OverrideShlibRevs
+# define OverrideShlibRevs     HasGccStackProtector
+#endif
+
+
 #define StandardDefines	-DCSRG_BASED
 #define XawI18nDefines	-DUSE_XWCHAR_STRING -DUSE_XMBTOWC
 
-#ifndef ExtraLibraries
-#define ExtraLibraries		/**/
-#endif
-#define UseGnuMalloc		NO
 
 #define	AdmDir			/var/log
 
@@ -194,9 +234,6 @@
 #define NroffCmd		nroff -Tlatin1
 #define	EqnCmd 			eqn -Tps
 #define HasGroff		YES
-/* Don't build HTML manual pages */
-#define BuildRman		NO
-#define BuildHtmlManPages	NO
 
 #ifndef HasCookieMaker
 #  define HasCookieMaker	YES
@@ -315,7 +352,7 @@
  */
 #ifndef LocalConfigFiles
 #define LocalConfigFiles \
-	OpenBSDLib.rules
+	OpenBSDLib.rules OpenBSDLib.tmpl
 #endif
 
 /*
@@ -329,36 +366,52 @@
  */
 #ifdef AlphaArchitecture
 
-# define OptimizedCDebugFlags	-O2
+# if OSMajorVersion == 3 && OSMinorVersion > 1 || OSMajorVersion > 3
+#  define HasWeakSymbols		YES
+# endif
 
-# define HasWeakSymbols		NO
+/* XXX Xvfb currently causes a linker error: */
+/* XXX crtbegin.c(.fini+0x10): relocation truncated to fit: BRADDR text */
+# ifdef XVirtualFramebufferServer
+#  undef XVirtualFramebufferServer
+# endif
+# define XVirtualFramebufferServer	NO
+# ifdef XnestServer
+#  undef XnestServer
+# endif
+# define XnestServer	NO
 
-# if (OSMajorVersion >= 3)
-#  define UseElfFormat		YES
-# else
+# if (OSMajorVersion < 3)
 #  define HasSharedLibraries	NO
 #  define SharedLibXThrStub	NO
 # endif
 
-# define XF86Server		NO
+# ifndef XF86Server
+#  if OSMajorVersion == 3 && OSMinorVersion >= 2 || OSMajorVersion > 3
+#    define XF86Server		YES
+#  else
+#    define XF86Server		NO
+#  endif
+# endif
 
 /* Definitions for building the XFree86 server */
 # if XF86Server
+#   ifndef HasNetBSDApertureDriver
+#     define HasNetBSDApertureDriver	YES
+#   endif
 #   define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DDDXOSINIT
 #   define ServerExtraDefines	GccGasOption -D_XSERVER64 XFree86ServerDefines
+#   define ServerExtraSysLibs	-lalpha
 #   ifndef DoLoadableServer
 #     define DoLoadableServer	YES
 #   endif
 #   ifndef XFree86ConsoleDefines
-#     define XFree86ConsoleDefines -DWSCONS_SUPPORT
+#     define XFree86ConsoleDefines -DWSCONS_SUPPORT -DPCVT_SUPPORT
 #   endif
+#   define UseMatroxHal		NO	/* Matrox HAL is i386 only */
 
 # endif /* XF86Server */
 
-/* FreeType2 don't work on 64bit machines */
-# define BuildFreetype2Library  NO
-# define BuildXftLibrary	NO
-
 # include <xfree86.cf>
 
 #endif /* AlphaArchitecture */
@@ -373,6 +426,8 @@
 #  define DoLoadableServer	YES
 # endif
 
+#define HasWeakSymbols		YES
+
 /* To use the NetBSD Aperture driver */
 # ifndef HasNetBSDApertureDriver
 #  define HasNetBSDApertureDriver	YES
@@ -387,6 +442,16 @@
 #  endif
 # endif
 
+/* 
+ * agpgart support (OpenBSD 3.2 and up) 
+ */ 
+# if OSMajorVersion > 3 || (OSMajorVersion == 3 && OSMinorVersion > 1)
+#  ifndef HasAgpGart 
+#   define HasAgpGart   YES 
+#  endif 
+# endif 
+ 
+
 # ifndef DefaultGcc2i386Opt
 #   if (OSMajorVersion == 2 && OSMinorVersion >= 3) || OSMajorVersion > 2
       /* The GCC strength-reduce bug is fixed for OpenBSD 2.3 and later */
@@ -417,6 +482,11 @@
 #  define GccOptBug295
 # endif
 
+/* No MMX support in OpenBSD/a.out gas */
+# if !UseElfFormat
+#   define HasMMXSupport	NO
+# endif
+
 # include <xfree86.cf>
 
 #endif /* i386Architecture */
@@ -518,7 +588,6 @@
 
 # include <xf86.rules>
 
-# define OptimizedCDebugFlags  -O2
 # define ServerOSDefines       -DDDXOSINIT
 # define BootstrapCFlags       -Dsun3
 # define UnalignedReferencesAllowed	YES /* changes _XtCopyArgs() */
@@ -596,28 +665,29 @@
  */
 #ifdef PpcArchitecture
 
-# define OptimizedCDebugFlags 	-O2
 # define XkbServerDefines	-DXKB_ALWAYS_USES_SOFT_REPEAT
 # ifndef XFree86ConsoleDefines
 #   define XFree86ConsoleDefines	-DWSCONS_SUPPORT
 # endif
 
-# define UseElfFormat		YES
-# define HasWeakSymbols		NO
-
-# if XFree86Devel
+# if OSMajorVersion == 3 && OSMinorVersion > 1 || OSMajorVersion > 3
+#  define HasWeakSymbols	YES
+# endif
+# ifndef GccWarningOptions
+#  if XFree86Devel
 #   define GccWarningOptions -Wall -Wpointer-arith -Wstrict-prototypes \
 			  -Wmissing-prototypes -Wmissing-declarations \
 			  -Wnested-externs
-# else
+#  else
 #   define GccWarningOptions -Wall -Wpointer-arith
+#  endif
 # endif
 
 # ifndef XF86Server
 #   define XF86Server		YES
 # endif
 
-/* Definitions for building the XFree86 server */
+/* Definitions for building the X server */
 # if XF86Server
 #   define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DDDXOSINIT
 #   define ServerExtraDefines	GccGasOption XFree86ServerDefines
@@ -650,7 +720,6 @@
  */
 #ifdef SparcArchitecture
 
-# define OptimizedCDebugFlags	-O2
 # define ServerOSDefines 	-DDDXOSINIT
 # define ServerExtraDefines	-DAVOID_GLYPHBLT -DPIXPRIV  -DXFree86Server \
 				ServerSnprintfDefines DebugDefines \
@@ -658,15 +727,27 @@
 # define BuildXF86MiscExt	NO
 # define BuildMITMiscExt	NO
 
-# ifndef Xsun24Server
-#  define Xsun24Server		YES
-# endif
-# ifndef XsunServer
-#  define XsunServer		YES
-# endif
-# ifndef XsunMonoServer
-#  define XsunMonoServer	YES
-# endif
+# if OSMajorVersion == 2 || OSMajorVersion == 3 && OSMinorVersion < 2
+#  ifndef Xsun24Server
+#   define Xsun24Server		YES
+#  endif
+#  ifndef XsunServer
+#   define XsunServer		YES
+#  endif
+#  ifndef XsunMonoServer
+#   define XsunMonoServer	YES
+#  endif
+# else 
+#  ifndef Xsun24Server
+#   define Xsun24Server		NO
+#  endif
+#  ifndef XsunServer
+#   define XsunServer		NO
+#  endif
+#  ifndef XsunMonoServer
+#   define XsunMonoServer	NO
+#  endif
+#endif
 
 # define XkbServerDefines	-DXKB_ALWAYS_USES_SOFT_REPEAT
 
@@ -687,21 +768,24 @@
 
 #ifdef Sparc64Architecture
 
-# define OptimizedCDebugFlags	-O2
-
-# define HasWeakSymbols		NO
-# define UseElfFormat		YES
+# if OSMajorVersion == 3 && OSMinorVersion > 1 || OSMajorVersion > 3
+#  define HasWeakSymbols	YES
+# endif
 
 # ifndef XF86Server
-#  define XF86Server		NO
+#  define XF86Server		YES
 # endif
 
 # define ServerExtraDefines	GccGasOption -D_XSERVER64 XFree86ServerDefines
-# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME
+# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DDDXOSINIT
+# define XkbServerDefines  -DXKB_ALWAYS_USES_SOFT_REPEAT
 
-/* FreeType2 don't work on 64bit machines */
-# define BuildFreetype2Library  NO
-# define BuildXftLibrary	NO
+# if XF86Server
+#   ifndef DoLoadableServer
+#     define DoLoadableServer	NO
+#   endif
+#   define XFree86ConsoleDefines -DWSCONS_SUPPORT
+# endif
 
 # include <xfree86.cf>
 
@@ -714,6 +798,10 @@
  * which can be overridden by architecture specific sections above
  */
 
+#if !defined(OptimizedCDebugFlags)
+# define OptimizedCDebugFlags	-O2
+#endif
+
 #ifndef ServerOSDefines
 #  define ServerOSDefines 	/**/
 #endif
@@ -722,40 +810,37 @@
 #  define ServerExtraDefines GccGasOption
 #endif
 
-#ifndef BuildCyrillicFonts
-# define BuildCyrillicFonts	YES
-#endif
-#ifndef BuildLatin2Fonts
-# define BuildLatin2Fonts	YES
-#endif
-#ifndef UseKoi8RForCyrillic
-# define UseKoi8RForCyrillic	YES
-#endif
-
 #ifndef HasWeakSymbols
-# define HasWeakSymbols YES
+# define HasWeakSymbols			NO
 #endif
 
 /*
  * Multi-thread safe libs 
  */	
 #if HasWeakSymbols == YES && (OSMajorVersion == 2 && OSMinorVersion >= 6 || OSMajorVersion >= 3)
-# define HasPosixThreads	YES
-# define ThreadedX		YES
-# define SystemMTDefines	-D_REENTRANT
-# if HasLibPthread
-#  define ThreadsLibraries	-lpthread
+/* For now only on a.out */
+# if !UseElfFormat
+#  define HasPosixThreads		YES
+#  define ThreadedX			YES
+#  define SystemMTDefines		-D_REENTRANT
+#  define BuildThreadStubLibrary		YES 
+#  define NeedUIThrStubs			YES 
+#  define ThreadsCompileFlag		-pthread
+#  define ThreadsLibraries		-pthread
 # else
-#  define BuildThreadStubLibrary  YES 
-#  define NeedUIThrStubs          YES 
-#  define ThreadsCompileFlags	-pthread
-#  define ThreadsLibraries	-pthread
-# endif
+#  define ThreadedX			NO
+# endif 
 #endif
 
 /* Set this to YES when getpwuid_r is added to libc_r */
+#define HasThreadSafeAPI		NO
+
+/* Set this to YES when getpwuid_r is added to libc_r */
 #define HasThreadSafeAPI	NO
 
+#ifndef ExtraLibraries
+# define ExtraLibraries		/**/
+#endif
 
 #ifndef DoLoadableServer
 #define DoLoadableServer	NO
@@ -812,7 +897,7 @@
 #endif
 
 #ifndef DlLibrary
-# if (OSMajorVersion < 3 || OSMajorVersion == 3 && OsMinorVersion == 0)\
+# if (OSMajorVersion < 3 || OSMajorVersion == 3 && OSMinorVersion == 0)\
     && UseElfFormat
 #  define DlLibrary -ldl
 # else
Index: xc/config/cf/OpenBSDLib.rules
diff -u xc/config/cf/OpenBSDLib.rules:1.3 xc/config/cf/OpenBSDLib.rules:1.5
--- xc/config/cf/OpenBSDLib.rules:1.3	Thu Jan 17 18:29:05 2002
+++ xc/config/cf/OpenBSDLib.rules	Mon Feb 17 16:46:44 2003
@@ -7,7 +7,7 @@
  * OpenBSD shared library rules
  */
 
-XCOMM $XFree86: xc/config/cf/OpenBSDLib.rules,v 1.3 2002/01/17 23:29:05 dawes Exp $
+XCOMM $XFree86: xc/config/cf/OpenBSDLib.rules,v 1.5 2003/02/17 21:46:44 herrb Exp $
 
 #ifndef UseElfFormat
 #define UseElfFormat NO
@@ -34,7 +34,7 @@
 #define SharedLibraryDef /**/
 #endif
 #ifndef ShLibIncludeFile
-#define ShLibIncludeFile <bsdLib.tmpl>
+#define ShLibIncludeFile <OpenBSDLib.tmpl>
 #endif
 #ifndef SharedLibraryLoadFlags
 #define SharedLibraryLoadFlags -shared PositionIndependentCFlags -Wl,-rpath,$(USRLIBDIR)
@@ -54,6 +54,7 @@
 #endif
 #endif
 #endif
+
 /*
  * InstallSharedLibrary - generate rules to install the shared library.
  * NOTE: file must be executable, hence "INSTBINFLAGS"
Index: xc/config/cf/OpenBSDLib.tmpl
diff -u /dev/null xc/config/cf/OpenBSDLib.tmpl:1.1
--- /dev/null	Thu Feb 27 12:13:00 2003
+++ xc/config/cf/OpenBSDLib.tmpl	Mon Dec 16 17:48:27 2002
@@ -0,0 +1,156 @@
+XCOMM platform:	$OpenBSD: OpenBSDLib.tmpl,v 1.2 2002/12/04 03:49:30 todd Exp $
+XCOMM platform: $XFree86: xc/config/cf/OpenBSDLib.tmpl,v 1.1 2002/12/16 22:48:27 herrb Exp $
+XCOMM
+/* Shared Library Revisions. Crank major on API Changes */
+
+#if OverrideShlibRevs
+
+/*
+ * Don't build libXaw.6 - the major numbering scheme on OpenBSD
+ * makes it useless
+ */
+#ifndef BuildXaw6
+#  define BuildXaw6	NO
+#endif 
+
+#if OSMajorVersion > 3 || ( OSMajorVersion == 3 && OSMinorVersion > 1)
+# ifndef SharedX11Rev
+#  define SharedX11Rev 7.0
+# endif
+# ifndef SharedXThrStubRev
+#  define SharedXThrStubRev 7.0
+# endif
+# ifndef SharedXextRev
+#  define SharedXextRev 7.0
+# endif
+# ifndef SharedXssRev
+#  define SharedXssRev 2.0
+# endif
+# ifndef SharedXf86miscRev
+#  define SharedXf86miscRev 2.0
+# endif
+# ifndef SharedXxf86vmRev
+#  define SharedXxf86vmRev 2.0
+# endif
+# ifndef SharedXxf86dgaRev
+#  define SharedXxf86dgaRev 2.0
+# endif
+# ifndef SharedXxf86rushRev
+#  define SharedXxf86rushRev 2.0
+# endif
+# ifndef SharedXvRev
+#  define SharedXvRev 2.0
+# endif
+# ifndef SharedXvMCRev
+#  define SharedXvMCRev 2.0
+# endif
+# ifndef SharedXineramaRev
+#  define SharedXineramaRev 2.0
+# endif
+# ifndef SharedDpsRev
+#  define SharedDpsRev 2.0
+# endif
+# ifndef SharedDpsTkRev
+#  define SharedDpsTkRev 2.0
+# endif
+# ifndef SharedPSResRev
+#  define SharedPSResRev 2.0
+# endif
+# ifndef SharedGluRev
+#  define SharedGluRev 2.0
+# endif
+# ifndef SharedGlxRev
+#  define SharedGlxRev 2.0
+# endif
+# ifndef SharedGLwRev
+#  define SharedGLwRev 2.0
+# endif
+# ifndef SharedXrenderRev
+#  define SharedXrenderRev 2.0
+# endif
+# ifndef SharedXrandrRev
+#  define SharedXrandrRev 2.0
+# endif
+# ifndef SharedXfontcacheRev
+#  define SharedXfontcacheRev 2.0
+# endif
+# ifndef SharedXauRev
+#  define SharedXauRev 7.0
+# endif
+# ifndef SharedXdmcpRev
+#  define SharedXdmcpRev 7.0
+# endif
+# ifndef SharedXmuRev
+#  define SharedXmuRev 7.0
+# endif
+# ifndef SharedXmuuRev
+#  define SharedXmuuRev 2.0
+# endif
+# ifndef SharedOldXRev
+#  define SharedOldXRev 7.0
+# endif
+# ifndef SharedXpRev
+#  define SharedXpRev 7.0
+# endif
+# ifndef SharedXtRev
+#  define SharedXtRev 7.0
+# endif
+# ifndef SharedXaRev
+#  define SharedXaRev 2.0
+# endif
+# ifndef SharedXawRev
+#  define SharedXawRev 8.0
+# endif
+# ifndef SharedXiRev
+#  define SharedXiRev 7.0
+# endif
+# ifndef SharedXtstRev
+#  define SharedXtstRev 7.0
+# endif
+# ifndef SharedPexRev
+#  define SharedPexRev 7.0
+# endif
+# ifndef SharedXieRev
+#  define SharedXieRev 7.0
+# endif
+# ifndef SharedPhigsRev
+#  define SharedPhigsRev 7.0
+# endif
+# ifndef SharedICERev
+#  define SharedICERev 7.0
+# endif
+# ifndef SharedSMRev
+#  define SharedSMRev 7.0
+# endif
+# ifndef SharedXkeyRev
+#  define SharedXkeyRev 7.0
+# endif
+# ifndef SharedFSRev
+#  define SharedFSRev 7.0
+# endif
+# ifndef SharedFontRev
+#  define SharedFontRev 2.0
+# endif
+# ifndef SharedFontEncRev
+#  define SharedFontEncRev 2.0
+# endif
+# ifndef SharedXpmRev
+#  define SharedXpmRev 5.0
+# endif
+# ifndef SharedFreetype2Rev
+#  define SharedFreetype2Rev 9.0
+# endif
+# ifndef SharedXftRev
+#  define SharedXftRev 2.0
+# endif
+# ifndef SharedXTrapRev
+#  define SharedXTrapRev 7.0
+# endif
+# ifndef SharedPSResRev
+#  define SharedPSResRev 2.0
+# endif
+#endif /* OSMajorVersion .. */
+
+#endif /* OverrideShlibRevs */
+
+#include <bsdLib.tmpl>
Index: xc/config/cf/README
diff -u xc/config/cf/README:1.15 xc/config/cf/README:1.19
--- xc/config/cf/README:1.15	Sat Sep 29 13:38:41 2001
+++ xc/config/cf/README	Fri Jan  3 21:48:24 2003
@@ -3,7 +3,7 @@
 
 
 
-$XFree86: xc/config/cf/README,v 1.15 2001/09/29 17:38:41 herrb Exp $
+$XFree86: xc/config/cf/README,v 1.19 2003/01/04 02:48:24 dawes Exp $
 
 The easiest way to write an Imakefile is to find another one that does
 something similar and copy/modify it!
@@ -90,6 +90,8 @@
 	HasVFork		boolean for system has vfork()
 	HasVoidSignalReturn	boolean for POSIX signal() procs
 	HasZlib			boolean for system has libz
+	IncludeSharedObjectInNormalLib define for static libs to include
+				       -fPIC objects on relevant archs
 	IncRoot			parent of X11 include directory
 	InstBinFlags		install flags for binaries
 	InstDatFlags		install flags for data files
@@ -213,6 +215,7 @@
 	DebugLibXtst		build libXtst_d.a
 	DebugLibXag		build libXag_d.a
 	DebugOldX		build liboldX_d.a
+	DefaultCursorTheme      name of default cursor theme
 	DefaultFSConfigFile	default font server config file
 	DefaultFontPath		default server font path
 	DefaultRGBDatabase	default server rgb color database
@@ -659,6 +662,8 @@
 InstallProgram		install a program.
 
 InstallManPage		install a manual page.
+
+InstallDirectory	install a directory.
 
 DependTarget()		include once at end of Imakefile with
 			NormalProgramTarget rules or that uses Library.tmpl.
Index: xc/config/cf/Server.tmpl
diff -u xc/config/cf/Server.tmpl:3.18 xc/config/cf/Server.tmpl:3.20
--- xc/config/cf/Server.tmpl:3.18	Fri Apr 20 11:51:15 2001
+++ xc/config/cf/Server.tmpl	Tue Nov 19 23:32:55 2002
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/config/cf/Server.tmpl,v 3.18 2001/04/20 15:51:15 tsi Exp $
+XCOMM $XFree86: xc/config/cf/Server.tmpl,v 3.20 2002/11/20 04:32:55 dawes Exp $
 /*
  * Server imakefile info  - this contains any special redefinitions, etc.
  * that Imakefiles in the server subtree will need.
@@ -25,16 +25,19 @@
 #ifndef DoThreadedServer
 #define DoThreadedServer NO
 #endif
-#ifndef DoLoadableServer
-#define DoLoadableServer NO
-#endif
-#ifndef MakeDllModules
-#define MakeDllModules NO
-#endif
 #ifndef InstallServerSetUID
 #define InstallServerSetUID NO
 #endif
 
+#ifdef CrossCompileDir
+# ifndef StripPath
+#  define StripPath(x) `echo x|sed "s%.*/%%"`
+# endif
+# ifndef CrossServerCcCmd
+#  define CrossServerCcCmd Concat3(CrossCompileDir,/,StripPath(ServerCcCmd))
+# endif
+#endif
+
 /*
  * SetUIDServerTarget - compile, link, and relink a setuid server
  */
@@ -47,7 +50,11 @@
 #endif
 #endif /* SetUIDServerTarget */
 
+#ifdef CrossCompileDir
+         CC = CrossServerCcCmd
+#else
          CC = ServerCcCmd
+#endif
   CCOPTIONS = ServerCCOptions
 #if DoThreadedServer
 SERVER_THREAD_DEFINES = XThreadsDefines ThreadTypeDefines
Index: xc/config/cf/Threads.tmpl
diff -u xc/config/cf/Threads.tmpl:3.3 xc/config/cf/Threads.tmpl:3.4
--- xc/config/cf/Threads.tmpl:3.3	Wed Jan 17 11:22:31 2001
+++ xc/config/cf/Threads.tmpl	Thu Nov 14 16:01:14 2002
@@ -2,7 +2,7 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/Threads.tmpl,v 3.3 2001/01/17 16:22:31 dawes Exp $
+XCOMM $XFree86: xc/config/cf/Threads.tmpl,v 3.4 2002/11/14 21:01:14 tsi Exp $
 
 /*
  * For a multi-threaded application or library,
@@ -25,6 +25,10 @@
 #else
 #define LocalThreads YES
 #endif
+#endif
+
+#ifndef HasCThreads
+#define HasCThreads NO
 #endif
 
 #ifndef ThreadTypeDefines
Index: xc/config/cf/Win32.rules
diff -u xc/config/cf/Win32.rules:1.4 xc/config/cf/Win32.rules:1.5
--- xc/config/cf/Win32.rules:1.4	Wed Jan 17 11:22:31 2001
+++ xc/config/cf/Win32.rules	Tue Nov  5 12:46:06 2002
@@ -1,5 +1,10 @@
 XCOMM platform:  $Xorg: Win32.rules,v 1.3 2000/08/17 19:41:46 cpqbld Exp $
 
+
+
+
+XCOMM $XFree86: xc/config/cf/Win32.rules,v 1.5 2002/11/05 17:46:06 tsi Exp $
+
 #define HasSharedLibraries YES
 #define NeedLibInsideFlag YES
 #define SharedLibXaw NO
@@ -323,7 +328,8 @@
 #ifdef UseInstalled
 # define ImakeSubCmdHelper $(IMAKE_CMD)
 #else
-# define ImakeSubCmdHelper ..\$(IMAKE) -I../$(IRULESRC) $(IMAKE_DEFINES)
+# define ImakeSubCmdHelper ..\$(IMAKE) -I../$(IRULESRC) \
+			   $(IMAKE_DEFINES) $(IMAKE_WARNINGS)
 #endif
 
 #define NamedTargetSubdirs(name,dirs,verb,flags,subname)		@@\
Index: xc/config/cf/X11.tmpl
diff -u xc/config/cf/X11.tmpl:1.141 xc/config/cf/X11.tmpl:1.196
--- xc/config/cf/X11.tmpl:1.141	Tue Jan 15 17:55:26 2002
+++ xc/config/cf/X11.tmpl	Tue Feb 25 16:57:52 2003
@@ -5,7 +5,7 @@
 XCOMM
 XCOMM
 XCOMM
-XCOMM $XFree86: xc/config/cf/X11.tmpl,v 1.141 2002/01/15 22:55:26 herrb Exp $
+XCOMM $XFree86: xc/config/cf/X11.tmpl,v 1.196 2003/02/25 21:57:52 dawes Exp $
 
 /***************************************************************************
  *                                                                         *
@@ -23,12 +23,12 @@
  * InstallAppDefaults		(class)
  * InstallAppDefaultsLong	(file,class)
  * MakeFontsDir			(deplist)
- * MakeXftCache			(deplist)
+ * MakeFcCache			(deplist)
  * MakeFonts			()
  * InstallFontObjs		(objs,dest)
  * InstallFonts			(dest)
  * InstallFontAliases		(dest)
- * InstallXftCache		(dest)
+ * InstallFcCache		(dest)
  * FontSrc			(basename)
  * FontBaseObj			(basename)
  * InstallFontScale		(dest)
@@ -72,6 +72,12 @@
 /*
  * X-specific things
  */
+#if CrossCompiling
+# if defined UseInstalled && !defined UseInstalledOnCrossCompile
+#  define UseInstalledOnCrossCompile YES
+# endif
+#endif
+
 #ifndef HasXServer
 #define HasXServer		YES
 #endif
@@ -114,6 +120,9 @@
 #ifndef BuildXTrueType
 #define BuildXTrueType		NO
 #endif
+#ifndef XTTInLibFont
+#define XTTInLibFont		NO
+#endif
 #ifndef BuildBuiltinFonts
 #define BuildBuiltinFonts	NO
 #endif
@@ -138,10 +147,12 @@
 #ifndef BuildTrueTypeFonts
 #define BuildTrueTypeFonts	YES
 #endif
-/* Not used now */
-#ifndef BuildLatin2Fonts
-#define BuildLatin2Fonts	NO
+#ifndef BuildBethMarduthoFonts
+#define BuildBethMarduthoFonts	NO
 #endif
+#ifndef BuildEthiopicFonts
+#define BuildEthiopicFonts	NO
+#endif
 #ifndef BuildCyrillicFonts
 #define BuildCyrillicFonts	YES
 #endif
@@ -202,6 +213,12 @@
 #ifndef BuildISO8859_10Fonts
 #define BuildISO8859_10Fonts	YES
 #endif
+#ifndef BuildThaiFonts
+#define BuildThaiFonts		YES
+#endif
+#ifndef BuildISO8859_11Fonts
+#define BuildISO8859_11Fonts	BuildThaiFonts
+#endif
 #ifndef BuildISO8859_13Fonts
 #define BuildISO8859_13Fonts	YES
 #endif
@@ -211,6 +228,9 @@
 #ifndef BuildISO8859_15Fonts
 #define BuildISO8859_15Fonts	YES
 #endif
+#ifndef BuildISO8859_16Fonts
+#define BuildISO8859_16Fonts	YES
+#endif
 #ifndef BuildKOI8_RFonts
 #define BuildKOI8_RFonts	BuildCyrillicFonts
 #endif
@@ -226,6 +246,9 @@
 #ifndef BuildChineseFonts
 #define BuildChineseFonts	YES
 #endif
+#ifndef MakeLocalFontDir
+#define MakeLocalFontDir	YES
+#endif
 #ifndef HasXAudio
 #define HasXAudio		NO
 #endif
@@ -239,20 +262,38 @@
 #define BuildXAServer		(HasXAServer & HasCplusplus)
 #endif
 #ifndef BuildX11Lib
-#define BuildX11Lib		(BuildLibraries || (BuildLibrariesForXServers && XnestServer))
+#define BuildX11Lib		BuildLibraries
 #endif
+
 #ifndef BuildLoadableXlibI18n
 #define BuildLoadableXlibI18n	(HasDlopen && SharedLibX11)
 #endif
+#ifndef InstallXcmsTxt
+#define InstallXcmsTxt		YES
+#endif
+/*
+ * This disables XLOCALEDIR.  Set it if you're using BuildLoadableXlibI18n,
+ * don't have either issetugid() or getresuid(), and you need to protect
+ * clients that are setgid or setuid to an id other than 0.
+ */
+#ifndef DisableXLocaleDirEnv
+#define DisableXLocaleDirEnv	BuildLoadableXlibI18n && \
+					!(HasIssetugid || HasGetresuid)
+#endif
+#ifndef BuildLoadableXlibXcursor
+#define BuildLoadableXlibXcursor (HasDlopen && SharedLibX11)
+#endif
 #ifndef BuildXextLib
-#define BuildXextLib		(BuildLibraries || (BuildLibrariesForXServers && XnestServer))
+#define BuildXextLib		BuildLibraries
 #endif
 #ifndef BuildXauLib
 #define BuildXauLib		(BuildLibraries || BuildLibrariesForXServers)
 #endif
+#define UseInstalledXauLib	(defined(UseInstalled) || !BuildXauLib)
 #ifndef BuildXdmcpLib
 #define BuildXdmcpLib		(BuildLibraries || BuildLibrariesForXServers)
 #endif
+#define UseInstalledXdmcpLib	(defined(UseInstalled) || !BuildXdmcpLib)
 #ifndef BuildMITMiscExt
 #define BuildMITMiscExt		YES
 #endif
@@ -457,6 +498,12 @@
 #ifndef BuildXF86DGALibrary
 #define BuildXF86DGALibrary	(BuildXF86DGA && !BuildServersOnly)
 #endif
+#ifndef BuildXResExt
+#define BuildXResExt            NO 
+#endif
+#ifndef BuildXResLibrary
+#define BuildXResLibrary        (BuildXResExt && !BuildServersOnly)
+#endif
 #ifndef BuildXvExt
 #define BuildXvExt		NO
 #endif
@@ -484,11 +531,15 @@
 #ifndef BuildGLXLibrary
 #define BuildGLXLibrary		(BuildGlxExt && !BuildServersOnly)
 #endif
+#ifndef BuildOSMesaLib
+#define BuildOSMesaLib		(BuildGlxExt && defined(XFree86Version))
+#endif
 #ifndef BuildGLULibrary
-#define BuildGLULibrary		(BuildGLXLibrary && HasCplusplus)
+#define BuildGLULibrary		(BuildGLXLibrary && BuildLibraries && \
+				 HasCplusplus)
 #endif
 #ifndef BuildGLwLibrary
-#define BuildGLwLibrary		(BuildGlxExt || BuildGLXLibrary)
+#define BuildGLwLibrary		(BuildGLXLibrary && BuildLibraries)
 #endif
 #ifndef BuildXF86RushExt
 #define BuildXF86RushExt	NO
@@ -512,7 +563,7 @@
 #define BuildDPSClients         BuildDPSLibraries
 #endif
 #ifndef BuildRender
-#define BuildRender		NO
+#define BuildRender		YES
 #endif
 #ifndef BuildRenderLibrary
 #define BuildRenderLibrary	!BuildServersOnly
@@ -520,20 +571,50 @@
 #ifndef BuildXftLibrary
 #define BuildXftLibrary		BuildRenderLibrary
 #endif
+#ifndef BuildXft1Library
+#define BuildXft1Library	BuildRenderLibrary
+#endif
+#ifndef UseFontconfig
+#define UseFontconfig		BuildXftLibrary
+#endif
+#ifndef BuildFontconfigLibrary
+#define BuildFontconfigLibrary	(UseFontconfig && !HasFontconfig)
+#endif
 #ifndef UseFreetype2
-#define UseFreetype2		BuildXftLibrary
+#define UseFreetype2		(BuildXftLibrary || BuildXft1Library || UseFontconfig)
+#endif
+#ifndef HasExpat
+#define HasExpat		NO
+#endif
+#ifndef UseExpat
+#define UseExpat		(UseFontconfig)
+#endif
+#ifndef BuildExpatLibrary
+#define BuildExpatLibrary	(UseExpat && !HasExpat)
 #endif
 #ifndef BuildFreetype2Library
 #define BuildFreetype2Library	(UseFreetype2 && !HasFreetype2)
 #endif
 
 #ifndef BuildRandR
-#define BuildRandR		NO
+#define BuildRandR		BuildRender
 #endif
 #ifndef BuildRandRLibrary
 #define BuildRandRLibrary	!BuildServersOnly
 #endif
 
+#ifndef BuildXcursorLibrary
+#define BuildXcursorLibrary	BuildRenderLibrary
+#endif
+
+#ifndef BuildXcursorgen
+#define BuildXcursorgen		HasLibpng
+#endif
+
+#ifndef DefaultCursorTheme
+#define DefaultCursorTheme	core
+#endif
+
 #ifndef BuildMiscDocs
 #define BuildMiscDocs		NO
 #endif
@@ -606,6 +687,9 @@
 #ifndef BuildThreadStubLibrary
 #define BuildThreadStubLibrary	NO
 #endif
+#ifndef NeedUIThrStubs
+#define NeedUIThrStubs		NO
+#endif
 #ifndef HasWChar32
 #define HasWChar32		SystemV4
 #endif
@@ -940,6 +1024,14 @@
 #endif
 #endif
 
+#ifndef XResExtensionDefines
+#if BuildXResExt
+#define XResExtensionDefines -DRES
+#else
+#define XResExtensionDefines /**/
+#endif
+#endif
+
 #ifndef RECORDDefines
 #if BuildRECORD
 #define RECORDDefines -DXRECORD
@@ -1033,7 +1125,8 @@
 	PexDefines ShmDefines XieDefines BigReqDefines VidModeExtensionDefines \
 	XF86MiscExtensionDefines DBEDefines DPMSDefines EVIDefines \
 	ScreenSaverExtensionDefines XvExtensionDefines XvMCExtensionDefines \
-	GlxDefines FontCacheExtensionDefines SiteExtensionDefines
+	GlxDefines FontCacheExtensionDefines SiteExtensionDefines \
+        XResExtensionDefines
 #endif
 #define ExtensionDefines BaseExtensionDefines ExtensionOSDefines
 #endif /* ExtensionDefines */
@@ -1116,6 +1209,14 @@
 #endif
 #endif
 
+#ifndef MesaUseX86Asm
+# if HasX86Support
+#  define MesaUseX86Asm YES
+# else
+#  define MesaUseX86Asm NO
+# endif
+#endif
+
 #ifndef MesaUseMMX
 #ifdef HasMMXSupport
 #define MesaUseMMX HasMMXSupport
@@ -1132,14 +1233,26 @@
 #endif
 #endif
 
-#ifndef MesaUseKatmai
-#ifdef HasKatmaiSupport
-#define MesaUseKatmai HasKatmaiSupport
+#ifndef MesaUseSSE
+#ifdef HasSSESupport
+#define MesaUseSSE HasSSESupport
 #else
-#define MesaUseKatmai NO
+#define MesaUseSSE NO
 #endif
 #endif
 
+/* For compatibility */
+#ifdef HasSSESupport
+#undef HasKatmaiSupport
+#define HasKatmaiSupport HasSSESupport
+#endif
+#undef MesaUseKatmai
+#define MesaUseKatmai MesaUseSSE
+
+#ifndef UsbMouseSupport
+# define UsbMouseSupport NO
+#endif
+
 #ifndef DefaultFSConfigFile
 #define DefaultFSConfigFile $(LIBDIR)/fs/config
 #endif
@@ -1244,7 +1357,11 @@
 #define BuildModuleTop $(BUILDLIBTOP)/..
 #endif
 #ifndef LibDir
-#define LibDir $(USRLIBDIR)/X11
+# ifdef ProjectRoot
+#  define LibDir Concat(ProjectRoot,/lib/X11)
+# else
+#  define LibDir /usr/lib/X11
+# endif
 #endif
 #ifndef ModuleDir
 #define ModuleDir $(USRLIBDIR)/modules
@@ -1453,21 +1570,27 @@
               RGB = $(BINDIR)/rgb
             FONTC = $(BINDIR)/bdftopcf
         MKFONTDIR = $(BINDIR)/mkfontdir
-         XFTCACHE = $(BINDIR)/xftcache
       MKHTMLINDEX = $(BINDIR)/mkhtmlindex
-          UCS2ANY = $(BINDIR)/ucs2any.pl
-      BDFTRUNCATE = $(BINDIR)/bdftruncate.pl
+          UCS2ANY = $(BINDIR)/ucs2any
+      BDFTRUNCATE = $(BINDIR)/bdftruncate
      UCSMAPPREFIX = $(FONTDIR)/util/map-
+       XCURSORGEN = $(BINDIR)/xcursorgen
 #else
               RGB = $(CLIENTENVSETUP) $(XBUILDBINDIR)/rgb
+# if !CrossCompiling
             FONTC = $(CLIENTENVSETUP) $(PRELOADFONTSETUP) $(XBUILDBINDIR)/bdftopcf
         MKFONTDIR = $(CLIENTENVSETUP) $(PRELOADFONTSETUP) $(XBUILDBINDIR)/mkfontdir
-         XFTCACHE = $(CLIENTENVSETUP) $(PRELOADSETUP) XFT_CONFIG=$(XFTLIBSRC)/XftConfig $(XBUILDBINDIR)/xftcache
-#if HasPerl
+       XCURSORGEN = $(CLIENTENVSETUP) $(PRELOADSETUP) $(XBUILDBINDIR)/xcursorgen
+# elif UseInstalledOnCrossCompile
+        MKFONTDIR = $(BINDIR)/mkfontdir
+            FONTC = $(BINDIR)/bdftopcf
+       XCURSORGEN = $(BINDIR)/xcursorgen
+# endif
+# if HasPerl
       MKHTMLINDEX = RunPerlScript($(CONFIGSRC)/util/mkhtmlindex.pl,)
-#else
+# else
       MKHTMLINDEX = $(SHELL) $(CONFIGSRC)/util/mkhtmlindex.sh
-#endif
+# endif
           UCS2ANY = $(FONTSRC)/util/ucs2any.pl
       BDFTRUNCATE = $(FONTSRC)/util/bdftruncate.pl
      UCSMAPPREFIX = $(FONTSRC)/util/map-
@@ -1534,6 +1657,9 @@
 #ifdef PreloadFontSetup
  PRELOADFONTSETUP = PreloadFontSetup
 #endif
+#ifdef PreloadXFTSetup
+     PRELOADXFTSETUP = PreloadXFTSetup
+#endif
 
 #ifndef ShLibIncludeFile
 /* need this to make ANSI-style preprocessors happy */
@@ -1546,6 +1672,10 @@
 # define XBuildLibDir	BuildLibDir
 #endif
 
+#ifndef NeedLibInsideFlag
+#define NeedLibInsideFlag	NO
+#endif
+
 #ifndef SharedLibX11
 #define SharedLibX11 HasSharedLibraries
 #endif
@@ -1571,16 +1701,16 @@
 
 #if BuildThreadStubLibrary
 #ifndef SharedLibXThrStub
-#define SharedLibXThrStub YES
+#define SharedLibXThrStub	YES
 #endif
 #ifndef NormalLibXThrStub
-#define NormalLibXThrStub NO
+#define NormalLibXThrStub	NO
 #endif
 #ifndef DebugLibXThrStub
-#define DebugLibXThrStub NO
+#define DebugLibXThrStub	NO
 #endif
 #ifndef ProfileLibXThrStub
-#define ProfileLibXThrStub NO
+#define ProfileLibXThrStub	NO
 #endif
    XTHRSTUBLIBSRC = $(LIBSRC)/XThrStub
 #if SharedLibXThrStub
@@ -1591,6 +1721,15 @@
 #else
 ProjectUnsharedLibReferences(XTHRSTUB,XThrStub,$(XTHRSTUBSRC),XBuildLibDir)
 #endif
+#else
+#undef  SharedLibXThrStub
+#define SharedLibXThrStub	NO
+#undef  NormalLibXThrStub
+#define NormalLibXThrStub	NO
+#undef  DebugLibXThrStub
+#define DebugLibXThrStub	NO
+#undef  ProfileLibXThrStub
+#define ProfileLibXThrStub	NO
 #endif
 
 #if BuildScreenSaverLibrary
@@ -1606,6 +1745,15 @@
 #ifndef ProfileLibXss
 #define ProfileLibXss	NO
 #endif
+#else
+#undef  SharedLibXss
+#define SharedLibXss	NO
+#undef  NormalLibXss
+#define NormalLibXss	NO
+#undef  DebugLibXss
+#define DebugLibXss	NO
+#undef  ProfileLibXss
+#define ProfileLibXss	NO
 #endif
 
 #if BuildXF86MiscLibrary
@@ -1621,6 +1769,15 @@
 #ifndef ProfileLibXxf86misc
 #define ProfileLibXxf86misc	NO
 #endif
+#else
+#undef  SharedLibXxf86misc
+#define SharedLibXxf86misc	NO
+#undef  NormalLibXxf86misc
+#define NormalLibXxf86misc	NO
+#undef  DebugLibXxf86misc
+#define DebugLibXxf86misc	NO
+#undef  ProfileLibXxf86misc
+#define ProfileLibXxf86misc	NO
 #endif
 
 #if BuildXF86VidModeLibrary
@@ -1636,6 +1793,15 @@
 #ifndef ProfileLibXxf86vm
 #define ProfileLibXxf86vm	NO
 #endif
+#else
+#undef  SharedLibXxf86vm
+#define SharedLibXxf86vm	NO
+#undef  NormalLibXxf86vm
+#define NormalLibXxf86vm	NO
+#undef  DebugLibXxf86vm
+#define DebugLibXxf86vm		NO
+#undef  ProfileLibXxf86vm
+#define ProfileLibXxf86vm	NO
 #endif
 
 #if BuildXF86DGALibrary
@@ -1651,6 +1817,15 @@
 #ifndef ProfileLibXxf86dga
 #define ProfileLibXxf86dga	NO
 #endif
+#else
+#undef  SharedLibXxf86dga
+#define SharedLibXxf86dga	NO
+#undef  NormalLibXxf86dga
+#define NormalLibXxf86dga	NO
+#undef  DebugLibXxf86dga
+#define DebugLibXxf86dga	NO
+#undef  ProfileLibXxf86dga
+#define ProfileLibXxf86dga	NO
 #endif
 
 #if BuildXF86RushLibrary
@@ -1666,11 +1841,20 @@
 #ifndef ProfileLibXxf86rush
 #define ProfileLibXxf86rush	NO
 #endif
+#else
+#undef  SharedLibXxf86rush
+#define SharedLibXxf86rush	NO
+#undef  NormalLibXxf86rush
+#define NormalLibXxf86rush	NO
+#undef  DebugLibXxf86rush
+#define DebugLibXxf86rush	NO
+#undef  ProfileLibXxf86rush
+#define ProfileLibXxf86rush	NO
 #endif
 
 #if BuildXvLibrary
 #ifndef SharedLibXv
-#define SharedLibXv		NO
+#define SharedLibXv		YES
 #endif
 #ifndef NormalLibXv
 #define NormalLibXv		YES
@@ -1681,6 +1865,15 @@
 #ifndef ProfileLibXv
 #define ProfileLibXv		NO
 #endif
+#else
+#undef  SharedLibXv
+#define SharedLibXv		NO
+#undef  NormalLibXv
+#define NormalLibXv		NO
+#undef  DebugLibXv
+#define DebugLibXv		NO
+#undef  ProfileLibXv
+#define ProfileLibXv		NO
 #endif
 
 #if BuildXvMCLibrary
@@ -1696,6 +1889,15 @@
 #ifndef ProfileLibXvMC
 #define ProfileLibXvMC		NO
 #endif
+#else
+#undef  SharedLibXvMC
+#define SharedLibXvMC		NO
+#undef  NormalLibXvMC
+#define NormalLibXvMC		NO
+#undef  DebugLibXvMC
+#define DebugLibXvMC		NO
+#undef  ProfileLibXvMC
+#define ProfileLibXvMC		NO
 #endif
 
 #if BuildXineramaLibrary
@@ -1711,8 +1913,40 @@
 #ifndef ProfileLibXinerama
 #define ProfileLibXinerama	NO
 #endif
+#else
+#undef  SharedLibXinerama
+#define SharedLibXinerama	NO
+#undef  NormalLibXinerama
+#define NormalLibXinerama	NO
+#undef  DebugLibXinerama
+#define DebugLibXinerama	NO
+#undef  ProfileLibXinerama
+#define ProfileLibXinerama	NO
 #endif
 
+#if BuildXResLibrary
+#ifndef SharedLibXRes
+#define SharedLibXRes           NO
+#endif
+#ifndef NormalLibXRes
+#define NormalLibXRes           YES
+#endif
+#ifndef DebugLibXRes
+#define DebugLibXRes            NO
+#endif
+#ifndef ProfileLibXRes
+#define ProfileLibXRes          NO
+#endif
+#else
+#undef  SharedLibXRes
+#define SharedLibXRes		NO
+#undef  NormalLibXRes
+#define NormalLibXRes		NO
+#undef  DebugLibXRes
+#define DebugLibXRes		NO
+#undef  ProfileLibXRes
+#define ProfileLibXRes		NO
+#endif
 
 #if BuildDPSLibrary
 #ifndef SharedLibDps
@@ -1727,6 +1961,15 @@
 #ifndef ProfileLibDps
 #define ProfileLibDps		NO
 #endif
+#else
+#undef  SharedLibDps
+#define SharedLibDps		NO
+#undef  NormalLibDps
+#define NormalLibDps		NO
+#undef  DebugLibDps
+#define DebugLibDps		NO
+#undef  ProfileLibDps
+#define ProfileLibDps		NO
 #endif
 
 #if BuildDPSTkLibrary
@@ -1742,6 +1985,15 @@
 #ifndef ProfileLibDpsTk
 #define ProfileLibDpsTk		NO
 #endif
+#else
+#undef  SharedLibDpsTk
+#define SharedLibDpsTk		NO
+#undef  NormalLibDpsTk
+#define NormalLibDpsTk		NO
+#undef  DebugLibDpsTk
+#define DebugLibDpsTk		NO
+#undef  ProfileLibDpsTk
+#define ProfileLibDpsTk		NO
 #endif
 
 #if BuildPSResLibrary
@@ -1757,6 +2009,15 @@
 #ifndef ProfileLibPSRes
 #define ProfileLibPSRes		NO
 #endif
+#else
+#undef  SharedLibPSRes
+#define SharedLibPSRes		NO
+#undef  NormalLibPSRes
+#define NormalLibPSRes		NO
+#undef  DebugLibPSRes
+#define DebugLibPSRes		NO
+#undef  ProfileLibPSRes
+#define ProfileLibPSRes		NO
 #endif
 
 #if BuildRenderLibrary
@@ -1772,6 +2033,15 @@
 #ifndef ProfileLibXrender
 #define ProfileLibXrender	NO
 #endif
+#else
+#undef  SharedLibXrender
+#define SharedLibXrender	NO
+#undef  NormalLibXrender
+#define NormalLibXrender	NO
+#undef  DebugLibXrender
+#define DebugLibXrender		NO
+#undef  ProfileLibXrender
+#define ProfileLibXrender	NO
 #endif
 
 #if BuildRandRLibrary
@@ -1787,6 +2057,39 @@
 #ifndef ProfileLibXrandr
 #define ProfileLibXrandr	NO
 #endif
+#else
+#undef  SharedLibXrandr
+#define SharedLibXrandr		NO
+#undef  NormalLibXrandr
+#define NormalLibXrandr		NO
+#undef  DebugLibXrandr
+#define DebugLibXrandr		NO
+#undef  ProfileLibXrandr
+#define ProfileLibXrandr	NO
+#endif
+
+#if BuildXcursorLibrary
+#ifndef SharedLibXcursor
+#define SharedLibXcursor	HasSharedLibraries
+#endif
+#ifndef NormalLibXcursor
+#define NormalLibXcursor	YES
+#endif
+#ifndef DebugLibXcursor
+#define DebugLibXcursor		NO
+#endif
+#ifndef ProfileLibXcursor
+#define ProfileLibXcursor	NO
+#endif
+#else
+#undef  SharedLibXcursor
+#define SharedLibXcursor	NO
+#undef  NormalLibXcursor
+#define NormalLibXcursor	NO
+#undef  DebugLibXcursor
+#define DebugLibXcursor		NO
+#undef  ProfileLibXcursor
+#define ProfileLibXcursor	NO
 #endif
 
 #if BuildGLULibrary
@@ -1802,6 +2105,15 @@
 #ifndef ProfileLibGlu
 #define ProfileLibGlu		NO
 #endif
+#else
+#undef  SharedLibGlu
+#define SharedLibGlu		NO
+#undef  NormalLibGlu
+#define NormalLibGlu		NO
+#undef  DebugLibGlu
+#define DebugLibGlu		NO
+#undef  ProfileLibGlu
+#define ProfileLibGlu		NO
 #endif
 
 #if BuildGLXLibrary
@@ -1822,6 +2134,8 @@
 #endif
 #if BuildLibGlxWithoutPIC && SharedLibGlx
 #define SharedLibGlxWithoutPIC	YES
+#else
+#define SharedLibGlxWithoutPIC	NO
 #endif
 #ifndef LinkGLToUsrLib
 #define LinkGLToUsrLib		NO
@@ -1837,9 +2151,20 @@
 #undef LinkGLToUsrInclude
 #define LinkGLToUsrInclude	NO
 #endif
+#else
+#undef  SharedLibGlx
+#define SharedLibGlx		NO
+#undef  NormalLibGlx
+#define NormalLibGlx		NO
+#undef  DebugLibGlx
+#define DebugLibGlx		NO
+#undef  ProfileLibGlx
+#define ProfileLibGlx		NO
+#endif
 /*
  * Don't make a shared GLw library because is would depend on Motif.
  */
+#if BuildGLwLibrary
 #ifndef SharedLibGLw
 #define SharedLibGLw		NO	/* HasSharedLibraries */
 #endif
@@ -1854,8 +2179,17 @@
 #endif
 #ifndef GLwUseXmStubs
 #define GLwUseXmStubs		NO	/* create stub (weak) Motif symbols */
+#endif
+#else
+#undef  SharedLibGlw
+#define SharedLibGlw		NO
+#undef  NormalLibGlw
+#define NormalLibGlw		NO
+#undef  DebugLibGlw
+#define DebugLibGlw		NO
+#undef  ProfileLibGlw
+#define ProfileLibGlw		NO
 #endif
-#endif /* BuildGLXLibrary */
 
 #ifndef SharedLibXext
 #define SharedLibXext HasSharedLibraries
@@ -1966,6 +2300,17 @@
 ProjectUnsharedLibReferences(XINERAMA,Xinerama,$(XINERAMALIBSRC),XBuildLibDir)
 #endif
 
+    XRESLIBSRC = $(LIBSRC)/XRes
+#if SharedLibXRes
+#ifndef SharedXResRev
+#define SharedXResRev 1.0
+#endif
+SharedLibReferences(XRES,XRes,$(XRESLIBSRC),SOXRESREV,SharedXResRev)
+#else
+ProjectUnsharedLibReferences(XRES,XRes,$(XRESLIBSRC),XBuildLibDir)
+#endif
+
+
     DPSLIBSRC = $(LIBSRC)/dps
 #if SharedLibDps
 #ifndef SharedDpsRev
@@ -2028,7 +2373,7 @@
     XRENDERLIBSRC = $(LIBSRC)/Xrender
 #if SharedLibXrender
 #ifndef SharedXrenderRev
-#define SharedXrenderRev 1.1
+#define SharedXrenderRev 1.2
 #endif
 SharedLibReferences(XRENDER,Xrender,$(XRENDERLIBSRC),SOXRENDERREV,SharedXrenderRev)
 #else
@@ -2038,13 +2383,23 @@
     XRANDRRLIBSRC = $(LIBSRC)/Xrandr
 #if SharedLibXrandr
 #ifndef SharedXrandrRev
-#define SharedXrandrRev 1.0
+#define SharedXrandrRev 2.0
 #endif
 SharedLibReferences(XRANDR,Xrandr,$(XRANDRLIBSRC),SOXRANDRREV,SharedXrandrRev)
 #else
 ProjectUnsharedLibReferences(XRANDR,Xrandr,$(XRANDRLIBSRC),XBuildLibDir)
 #endif
 
+   XCURSORRLIBSRC = $(LIBSRC)/Xcursor
+#if SharedLibXcursor
+#ifndef SharedXcursorRev
+#define SharedXcursorRev 1.0
+#endif
+SharedLibReferences(XCURSOR,Xcursor,$(XCURSORLIBSRC),SOXCURSORREV,SharedXcursorRev)
+#else
+ProjectUnsharedLibReferences(XCURSOR,Xcursor,$(XCURSORLIBSRC),XBuildLibDir)
+#endif
+
 # ifndef SharedLibXfontcache
 #  define SharedLibXfontcache	NO
 # endif
@@ -2087,8 +2442,12 @@
 #endif
 SharedLibReferences(XAUTH,Xau,$(XAUTHSRC),SOXAUTHREV,SharedXauRev)
 #else
+#if !UseInstalledXauLib
 ProjectUnsharedLibReferences(XAUTH,Xau,$(XAUTHSRC),XBuildLibDir)
+#else
+ProjectUnsharedLibReferences(XAUTH,Xau,$(XAUTHSRC),$(USRLIBDIR))
 #endif
+#endif
 
 #ifndef SharedLibXdmcp
 #define SharedLibXdmcp NO	/* don't need shared form */
@@ -2109,7 +2468,11 @@
 #endif
 SharedLibReferences(XDMCP,Xdmcp,$(XDMCPLIBSRC),SOXDMCPREV,SharedXdmcpRev)
 #else
+#if !UseInstalledXdmcpLib
 ProjectUnsharedLibReferences(XDMCP,Xdmcp,$(XDMCPLIBSRC),XBuildLibDir)
+#else
+ProjectUnsharedLibReferences(XDMCP,Xdmcp,$(XDMCPLIBSRC),$(USRLIBDIR))
+#endif
 #endif
 
 #ifndef SharedLibXmu
@@ -2516,10 +2879,26 @@
 XCOMM ProjectUnsharedLibReferences(XFONT,Xfont,$(FONTLIBSRC),XBuildLibDir)
 #endif
 
+/*
+ * There's no reason to use the statically built FreeType unless
+ * you're using a loadable server.
+ */
+ 
+#ifndef FontLibSharedFreeType
+#if BuildFreeType && UseFreetype2 && !DoLoadableServer 
+#define FontLibSharedFreeType YES
+#else
+#define FontLibSharedFreeType NO
+#endif
+#endif
+
+#if FontLibSharedFreeType
+         FONTFT2LIB = $(FREETYPE2LIB)
+#endif
      FONTSTUBLIBSRC = $(FONTLIBSRC)/stubs
 ProjectUnsharedLibReferences(FONTSTUB,fntstubs,$(FONTSUBLIBSRC),XBuildLibDir)
          DEPFONTLIB = $(DEPXFONTLIB) $(DEPFONTSTUBLIB)
-            FONTLIB = $(XFONTLIB) $(FONTSTUBLIB)
+            FONTLIB = $(XFONTLIB) $(FONTSTUBLIB) $(FONTFT2LIB)
 
 
 #ifndef SharedLibFontEnc
@@ -2566,6 +2945,10 @@
 ProjectUnsharedLibReferences(XPM,Xpm,$(XPMLIBSRC),XBuildLibDir)
 #endif
 
+#if UseFreetype2
+
+#if BuildFreetype2Library
+
 #ifndef SharedLibFreetype2
 #define SharedLibFreetype2 HasSharedLibraries
 #endif
@@ -2580,40 +2963,53 @@
 #endif
           FREETYPE2LIBSRC = $(LIBSRC)/freetype2
 
-/* FreeType 2.0.6, version_info 8:0:2 */
+/* FreeType 2.0.9, version_info 9:0:3 */
 #ifndef Freetype2Version
-#define Freetype2Version 8.0.2
+#define Freetype2Version 9.0.3
 #endif
 
 #if SharedLibFreetype2
 #ifndef SharedFreetype2Rev
 #if LibtoolMinorVersions
-#define SharedFreetype2Rev 6.2
+#define SharedFreetype2Rev 6.3
 #else
-#define SharedFreetype2Rev 8.0
+#define SharedFreetype2Rev 9.0
 #endif
 #endif
 SharedLibReferences(FREETYPE2,freetype,$(FREETYPE2LIBSRC),SOFREETYPE2REV,SharedFreetype2Rev)
 #else
 ProjectUnsharedLibReferences(FREETYPE2,freetype,$(FREETYPE2LIBSRC),XBuildLibDir)
 #endif
-
-#if UseFreetype2
 
-#if BuildFreetype2Library
-FREETYPE2INCLUDES=$(TOP_X_INCLUDES)/freetype2
-FREETYPE2DEFINES=-DFREETYPE2
+#ifdef UseInstalled
+FREETYPE2INCDIR=$(INCDIR)/freetype2
 #else
+FREETYPE2INCDIR=$(BUILDINCDIR)/freetype2
+#endif
+
+#else /* BuildFreetype2Library */
 
 #if HasFreetype2
 
 #ifndef Freetype2Dir
 #define Freetype2Dir /usr
+#ifndef Freetype2DirStandard
+# define Freetype2DirStandard YES
 #endif
+#endif
+#ifndef Freetype2DirStandard
+#define Freetype2DirStandard NO
+#endif
 
 #ifndef Freetype2LibDir
-#define Freetype2LibDir Freetype2Dir/lib
+#define Freetype2LibDir Freetype2Dir/LibDirName
+# if Freetype2DirStandard
+#  define Freetype2LibDirStandard YES
+# endif
 #endif
+#ifndef Freetype2LibDirStandard
+# define Freetype2LibDirStandard NO
+#endif
 
 #ifndef Freetype2IncDir
 #define Freetype2IncDir Freetype2Dir/include/freetype2
@@ -2622,14 +3018,148 @@
 FREETYPE2DIR = Freetype2Dir
 FREETYPE2LIBDIR = Freetype2LibDir
 FREETYPE2INCDIR = Freetype2IncDir
-FREETYPE2INCLUDES = -I$(FREETYPE2INCDIR)
+#if Freetype2LibDirStandard
+FREETYPE2LIB = -lfreetype
+#else
 FREETYPE2LIB = -L$(FREETYPE2LIBDIR) -lfreetype
+#endif
+
+#endif /* HasFreetype2 */
+
+#endif /* else BuildFreetype2Library */
+
+#if BuildFreetype2Library || HasFreetype2
+FREETYPE2INCLUDES = -I$(FREETYPE2INCDIR)
 FREETYPE2DEFINES = -DFREETYPE2
 #endif
 
+#endif /* UseFreetype2 */
+
+#ifndef SharedLibExpat
+#define SharedLibExpat HasSharedLibraries
+#endif
+#ifndef NormalLibExpat
+#define NormalLibExpat (!SharedLibExpat | ForceNormalLib)
+#endif
+#ifndef DebugLibExpat
+#define DebugLibExpat		NO
+#endif
+#ifndef ProfileLibExpat
+#define ProfileLibExpat		NO
+#endif
+          EXPATLIBSRC = $(LIBSRC)/expat
+
+/* Expat 1.95.2 */
+#ifndef ExpatVersion
+#define ExpatVersion 1.95.2
+#endif
+
+#if SharedLibExpat
+#ifndef SharedExpatRev
+#define SharedExpatRev 1.0
+#endif
+SharedLibReferences(EXPAT,expat,$(EXPATLIBSRC),SOEXPATREV,SharedExpatRev)
+#else
+ProjectUnsharedLibReferences(EXPAT,expat,$(EXPATLIBSRC),XBuildLibDir)
+#endif
+
+#if UseExpat
+
+#if BuildExpatLibrary
+EXPATINCLUDES=$(TOP_X_INCLUDES)
+EXPATDEFINES=-DEXPAT
+#else	/* BuildExpatLibrary */
+
+#if HasExpat
+
+#ifndef ExpatDir
+#define ExpatDir /usr
+#define ExpatDirStandard YES
+#endif
+#ifndef ExpatDirStandard
+#define ExpatDirStandard NO
+#endif
+
+#ifndef ExpatLibDir
+#define ExpatLibDir ExpatDir/LibDirName
+# if ExpatDirStandard
+#  define ExpatLibDirStandard YES
+# endif
+#endif
+#ifndef ExpatLibDirStandard
+#define ExpatLibDirStandard NO
+#endif
+
+#ifndef ExpatIncDir
+#define ExpatIncDir ExpatDir/include
+# if ExpatDirStandard
+#  define ExpatIncDirStandard YES
+# endif
 #endif
+#ifndef ExpatIncDirStandard
+#define ExpatIncDirStandard NO
+#endif
+
+EXPATDIR = ExpatDir
+EXPATLIBDIR = ExpatLibDir
+EXPATINCDIR = ExpatIncDir
+#if ExpatIncDirStandard
+EXPATINCLUDES =
+#else
+EXPATINCLUDES = -I$(EXPATINCDIR)
+#endif
+#if ExpatLibDirStandard
+EXPATLIB = -lexpat
+#else
+EXPATLIB = -L$(EXPATLIBDIR) -lexpat
 #endif
+EXPATDEFINES = -DEXPAT
+#endif /* HasExpat */
 
+#endif /* else BuildExpatLibrary */
+
+#define ExpatClientLibs $(EXPATLIB)
+#define ExpatClientDepLibs $(DEPEXPATLIB)
+
+#endif /* UseExpat */
+
+#ifndef SharedLibXft1
+#define SharedLibXft1 HasSharedLibraries
+#endif
+#ifndef NormalLibXft1
+#define NormalLibXft1 		NO
+#endif
+#ifndef DebugLibXft1
+#define DebugLibXft1		NO
+#endif
+#ifndef ProfileLibXft1
+#define ProfileLibXft1		NO
+#endif
+          XFT1LIBSRC = $(LIBSRC)/Xft1
+#if SharedLibXft1
+#ifndef SharedXft1Rev
+#define SharedXft1Rev 1.1
+#endif
+SharedLibReferences(XFT1,Xft,$(XFT1LIBSRC),SOXFT1REV,SharedXft1Rev)
+#else
+ProjectUnsharedLibReferences(XFT1,Xft,$(XFT1LIBSRC),XBuildLibDir)
+#endif
+
+#ifndef Xft1ClientDepLibs
+#if UseFreetype2
+#define Xft1ClientDepLibs $(DEPXFT1LIB) $(DEPFREETYPE2LIB) $(DEPXRENDERLIB)
+#else
+#define Xft1ClientDepLibs $(DEPXFT1LIB) $(DEPXRENDERLIB)
+#endif
+#endif
+#ifndef Xft1ClientLibs
+#if UseFreetype2
+#define Xft1ClientLibs $(XFT1LIB) $(FREETYPE2LIB) $(XRENDERLIB)
+#else
+#define Xft1ClientLibs $(XFT1LIB) $(XRENDERLIB)
+#endif
+#endif
+
 #ifndef SharedLibXft
 #define SharedLibXft HasSharedLibraries
 #endif
@@ -2645,7 +3175,7 @@
           XFTLIBSRC = $(LIBSRC)/Xft
 #if SharedLibXft
 #ifndef SharedXftRev
-#define SharedXftRev 1.1
+#define SharedXftRev 2.1
 #endif
 SharedLibReferences(XFT,Xft,$(XFTLIBSRC),SOXFTREV,SharedXftRev)
 #else
@@ -2653,20 +3183,195 @@
 #endif
 
 #ifndef XftClientDepLibs
-#if UseFreetype2
-#define XftClientDepLibs $(DEPXFTLIB) $(DEPFREETYPE2LIB) $(DEPXRENDERLIB)
+#define XftClientDepLibs $(DEPXFTLIB) FontconfigClientDepLibs $(DEPXRENDERLIB)
+#endif
+#ifndef XftClientLibs
+#define XftClientLibs $(XFTLIB) FontconfigClientLibs $(XRENDERLIB)
+#endif
+
+XFTINCLUDES=$(FONTCONFIGINCLUDES) $(FREETYPE2INCLUDES)
+
+#if UseFontconfig
+
+#if BuildFontconfigLibrary
+
+#ifndef SharedLibFontconfig
+#define SharedLibFontconfig HasSharedLibraries
+#endif
+#ifndef NormalLibFontconfig
+#define NormalLibFontconfig (!SharedLibFontconfig | ForceNormalLib)
+#endif
+#ifndef DebugLibFontconfig
+#define DebugLibFontconfig		NO
+#endif
+#ifndef ProfileLibFontconfig
+#define ProfileLibFontconfig		NO
+#endif
+          FONTCONFIGLIBSRC = $(LIBSRC)/fontconfig
+#if SharedLibFontconfig
+#ifndef SharedFontconfigRev
+#define SharedFontconfigRev 1.0
+#endif
+SharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGLIBSRC),SOFONTCONFIGREV,SharedFontconfigRev)
 #else
-#define XftClientDepLibs $(DEPXFTLIB) $(DEPXRENDERLIB)
+ProjectUnsharedLibReferences(FONTCONFIG,fontconfig,$(FONTCONFIGLIBSRC),XBuildLibDir)
 #endif
+
+#ifdef UseInstalled
+FONTCONFIGINCDIR=$(INCDIR)
+#else
+FONTCONFIGINCDIR=$(BUILDINCDIR)
 #endif
-#ifndef XftClientLibs
-#if UseFreetype2
-#define XftClientLibs $(XFTLIB) $(FREETYPE2LIB) $(XRENDERLIB)
+
+FONTCONFIGINCLUDES = -I$(FONTCONFIGINCDIR)
+
+#if UseInstalledX11
+FCCACHE = $(BINDIR)/fc-cache
 #else
-#define XftClientLibs $(XFTLIB) $(XRENDERLIB)
+FCCACHE = set -x; $(CLIENTENVSETUP) $(PRELOADXFTSETUP) FONTCONFIG_PATH=$(FONTCONFIGLIBSRC) $(XBUILDBINDIR)/fc-cache
 #endif
+	  
+#else /* BuildFontconfigLibrary */
+
+#if HasFontconfig
+
+#ifndef FontconfigDir
+# define FontconfigDir /usr
+# ifndef FontconfigDirStandard
+#  define FontconfigDirStandard YES
+# endif
 #endif
 
+#ifndef FontconfigDirStandard
+# define FontconfigDirStandard NO
+#endif
+
+#ifndef FontconfigLibDir
+# define FontconfigLibDir FontconfigDir/LibDirName
+# if FontconfigDirStandard
+#  define FontconfigLibDirStandard YES
+# endif
+#endif
+#ifndef FontconfigLibDirStandard
+# define FontconfigLibDirStandard NO
+#endif
+
+#ifndef FontconfigBinDir
+# define FontconfigBinDir FontconfigDir/bin
+#endif
+
+#ifndef FontconfigIncDir
+# define FontconfigIncDir FontconfigDir/include
+# if FontconfigDirStandard
+#  define FontconfigIncDirStandard YES
+# endif
+#endif
+
+#ifndef FontconfigIncDirStandard
+# define FontconfigIncDirStandard NO
+#endif
+
+FONTCONFIGDIR = FontconfigDir
+FONTCONFIGLIBDIR = FontconfigLibDir
+FONTCONFIGINCDIR = FontconfigIncDir
+FONTCONFIGBINDIR = FontconfigBinDir
+#if FontconfigLibDirStandard
+FONTCONFIGLIB = -lfontconfig
+#else
+FONTCONFIGLIB = -L$(FONTCONFIGLIBDIR) -lfontconfig
+#endif
+
+#if FontconfigIncDirStandard
+FONTCONFIGINCLUDES =
+#else
+FONTCONFIGINCLUDES = -I$(FONTCONFIGINCDIR)
+#endif
+
+FCCACHE = $(FONTCONFIGBINDIR)/fc-cache
+
+#endif /* HasFontconfig */
+
+#endif /* else BuildFontconfigLibrary */
+
+#if BuildFontconfigLibrary || HasFontconfig
+FONTCONFIGDEFINES = -DFONTCONFIG
+#endif
+
+#ifndef FontconfigClientDepLibs
+#define FontconfigClientDepLibs $(DEPFONTCONFIGLIB) $(DEPFREETYPE2LIB) ExpatClientDepLibs
+#endif
+#ifndef FontconfigClientLibs
+#define FontconfigClientLibs $(FONTCONFIGLIB) $(FREETYPE2LIB) ExpatClientLibs
+#endif
+
+#endif /* UseFontconfig */
+
+#ifdef HasLibpng
+
+/*
+ * Libpng controls:
+ *
+ *	LibpngDir		prefix for all libpng files
+ *	LibpngDirStandard	Boolean - whether png headers/libs are
+ *				in default compile/link paths
+ *	LibpngLibDir		Directory holding png library
+ *	LibpngLibDirStandard	Boolean - whether png libs are
+ *				in default link path
+ *	LibpngIncDir		Directory holding png includes
+ *	LibpngIncDirStandard	Boolean - whether png includes are
+ *				in default compile path
+ *
+ * Make sure that *Standard is set correctly, if not, the
+ * standard compile/link paths will be added *before* the
+ * local X directorys and installed versions of the standard
+ * X headers will end up getting used.
+ */
+
+#ifndef LibpngDir
+#define LibpngDir /usr
+#define LibpngDirStandard YES
+#endif
+#ifndef LibpngDirStandard
+#define LibpngDirStandard NO
+#endif
+
+#ifndef LibpngLibDir
+#define LibpngLibDir LibpngDir/LibDirName
+#if LibpngDirStandard
+#define LibpngLibDirStandard YES
+#endif
+#endif
+#ifndef LibpngLibDirStandard
+#define LibpngLibDirStandard NO
+#endif
+
+#ifndef LibpngIncDir
+#define LibpngIncDir LibpngDir/include
+#if LibpngDirStandard
+#define LibpngIncDirStandard YES
+#endif
+#endif
+#ifndef LibpngIncDirStandard
+#define LibpngIncDirStandard NO
+#endif
+
+LIBPNGINCDIR = LibpngIncDir
+#if LibpngIncDirStandard
+LIBPNGINC=
+#else
+LIBPNGINC = -I$(LIBPNGINCDIR)
+#endif
+LIBPNGDIR = LibpngDir
+LIBPNGLIBDIR = LibpngLibDir
+LIBPNGINCDIR = LibpngIncDir
+#if LibpngLibDirStandard
+LIBPNGLIB = -lpng
+#else
+LIBPNGLIB = -L$(LIBPNGLIBDIR) -lpng
+#endif
+
+#endif
+
 #ifndef XmuuClientDepLibs
 #define XmuuClientDepLibs $(DEPXMUULIB) $(DEPXLIB)
 #endif
@@ -2695,7 +3400,7 @@
 #define XkbClientLibs /**/
 #endif
 #endif
-#if defined(UseInstalled) || defined(OS2Architecture)
+#if defined(UseInstalled) || (CrossCompiling &&  UseInstalledOnCrossCompile)
      XKBCOMPCMD = $(BINDIR)/XkbComp
 #else
      XKBCOMPSRC = $(PROGRAMSRC)/XkbComp
@@ -2812,45 +3517,46 @@
 #endif /* InstallAppDefaultsLong */
 
 /*
- * MakeXftCache - generate rules to build XftCache database
+ * MakeFcCache - generate rules to build fontconfig cache database
  */
 
-#ifdef UseFreetype2
+#if defined UseFreetype2 && !CrossCompiling
 
-#ifndef MakeXftCache
-#define MakeXftCache(deplist)						@@\
-all:: XftCache								@@\
+# ifndef MakeFcCache
+#  define MakeFcCache(deplist)						@@\
+all:: fonts.cache							@@\
 									@@\
-XftCache: deplist							@@\
-	RunProgram(XFTCACHE, $(XFTCACHEOPTS) .)				@@\
+fonts.cache: deplist							@@\
+	RunProgram(FCCACHE, $(FCCACHEOPTS) .)				@@\
 									@@\
 clean::									@@\
-	RemoveFile(XftCache)
-#endif /* MakeXftCache */
+	RemoveFiles(fonts.cache*)
+# endif /* MakeFcCache */
 
-#ifndef InstallXftCache
-#define InstallXftCache(dest)						@@\
-InstallTarget(install,XftCache,$(INSTDATFLAGS),dest)
-#endif /* InstallXftCache */
+# ifndef InstallFcCache
+#  define InstallFcCache(dest)						@@\
+install::								@@\
+	RunProgram(FCCACHE, $(FCCACHEOPTS) $(DESTDIR)dest)
+# endif /* InstallFcCache */
 
 #else
 
-#ifndef MakeXftCache
-#define MakeXftCache(deplist)
+#ifndef MakeFcCache
+#define MakeFcCache(deplist)
 #endif
 
-#ifndef InstallXftCache
-#define InstallXftCache(dest)
+#ifndef InstallFcCache
+#define InstallFcCache(dest)
 #endif
 
 #endif
 
-
 /*
  * MakeFontsDir - generate rules to build fonts.dir database.
  */
 #ifndef MakeFontsDir
-#define MakeFontsDir(deplist)						@@\
+# if !CrossCompiling ||  UseInstalledOnCrossCompile
+#  define MakeFontsDir(deplist)						@@\
 all:: fonts.dir								@@\
 									@@\
 fonts.dir:  deplist							@@\
@@ -2858,6 +3564,11 @@
 									@@\
 clean::									@@\
 	RemoveFile(fonts.dir)
+# else
+#  define MakeFontsDir(deplist)						@@\
+clean::									@@\
+	RemoveFile(fonts.dir)
+# endif
 #endif /* MakeFontsDir */
 
 
@@ -2865,13 +3576,21 @@
  * MakeFonts - generate rules to build font database.
  */
 #ifndef MakeFonts
-#define MakeFonts()							@@\
+# if !CrossCompiling || UseInstalledOnCrossCompile
+#  define MakeFonts()							@@\
 all::  $(OBJS)								@@\
 									@@\
 MakeFontsDir($(OBJS))							@@\
 									@@\
 clean::									@@\
 	RemoveFiles(*.pcf *.pcf.Z *.pcf.gz)
+# else
+#  define MakeFonts()							@@\
+MakeFontsDir($(OBJS))							@@\
+									@@\
+clean::									@@\
+	RemoveFiles(*.pcf *.pcf.Z *.pcf.gz)
+# endif
 #endif /* MakeFonts */
 
 
@@ -2879,10 +3598,14 @@
  * InstallFontObjs - generate rules to install font files
  */
 #ifndef InstallFontObjs
-#define InstallFontObjs(objs,dest)					@@\
+# if !CrossCompiling || UseInstalledOnCrossCompile
+#  define InstallFontObjs(objs,dest)					@@\
 InstallMultipleFlags(objs,dest,$(INSTDATFLAGS))				@@\
 									@@\
 InstallTarget(install,fonts.dir,$(INSTDATFLAGS),dest)
+# else
+#  define InstallFontObjs(objs,dest)
+# endif
 #endif /* InstallFontObjs */
 
 
@@ -2927,11 +3650,17 @@
 /*
  * UncompressedFontTargetLong
  */
-#ifndef UncompressedFontTargetLong
-#define UncompressedFontTargetLong(sname,tname)				@@\
+#if ! CrossCompiling || UseInstalledOnCrossCompile
+# ifndef UncompressedFontTargetLong
+#  define UncompressedFontTargetLong(sname,tname)			@@\
 FontBaseObj(tname):  FontSrc(sname)					@@\
 	RunProgram(FONTC,$(FONTCFLAGS) $? -o $@)
-#endif /* UncompressedFontTargetLong */
+# endif /* UncompressedFontTargetLong */
+#else
+# ifndef UncompressedFontTargetLong
+#  define UncompressedFontTargetLong(sname,tname)
+# endif
+#endif
 
 /*
  * CompressedFontTarget
@@ -2940,17 +3669,21 @@
 #define GzipFontCompression NO
 #endif
 
-#ifndef CompressedFontTargetLong
-#if GzipFontCompression
-#define CompressedFontTargetLong(sname,tname)				@@\
+#if ! CrossCompiling || UseInstalledOnCrossCompile
+# ifndef CompressedFontTargetLong
+#  if GzipFontCompression
+#   define CompressedFontTargetLong(sname,tname)			@@\
 FontBaseObj(tname).gz:  FontSrc(sname)					@@\
 	RunProgram(FONTC,$(FONTCFLAGS) $?) | $(GZIPCMD) > $@
-#else
-#define CompressedFontTargetLong(sname,tname)				@@\
+#  else
+#   define CompressedFontTargetLong(sname,tname)			@@\
 FontBaseObj(tname).Z:  FontSrc(sname)					@@\
 	RunProgram(FONTC,$(FONTCFLAGS) $?) | $(COMPRESS) > $@
+#  endif
+# endif /* CompressedFontTargetLong */
+#else
+#   define CompressedFontTargetLong(sname,tname)
 #endif
-#endif /* CompressedFontTargetLong */
 
 /*
  * UncompressedFontTarget
@@ -3008,7 +3741,8 @@
 #endif
 
 #ifndef MakeEncDir
-#define MakeEncDir(deplist,inst,dirlist )				@@\
+# if !CrossCompiling || UseInstalledOnCrossCompile
+#  define MakeEncDir(deplist,inst,dirlist )				@@\
 AllTarget(encodings.dir)						@@\
 									@@\
 encodings.dir: deplist							@@\
@@ -3020,6 +3754,11 @@
 									@@\
 clean::									@@\
 	RemoveFiles(fonts.dir encodings.dir)
+# else
+#  define MakeEncDir(deplist,inst,dirlist )				@@\
+clean::									@@\
+	RemoveFiles(fonts.dir encodings.dir)
+# endif
 #endif
 
 #ifndef MakeEncodings
@@ -3032,10 +3771,14 @@
 #endif /* MakeEncodings */
 
 #ifndef InstallEncObjs
-#define InstallEncObjs(objs,dest)					@@\
+# if !CrossCompiling || UseInstalledOnCrossCompile
+#  define InstallEncObjs(objs,dest)					@@\
 InstallMultipleFlags(objs,dest,$(INSTDATFLAGS))				@@\
 									@@\
 InstallTarget(install,encodings.dir,$(INSTDATFLAGS),dest)
+# else
+#  define InstallEncObjs(objs,dest)
+# endif
 #endif /* InstallEncObjs */
 
 #ifndef InstallEncodings
@@ -3044,8 +3787,12 @@
 #endif /* InstallEncodings */
 
 #ifndef InstallEncodingsDir
-#define InstallEncodingsDir(edir,fdir)					@@\
+# if !CrossCompiling || UseInstalledOnCrossCompile
+#  define InstallEncodingsDir(edir,fdir)				@@\
 InstallNamedTarget(install,edir/encodings.dir,$(INSTDATFLAGS),fdir,encodings.dir)
+# else
+#  define InstallEncodingsDir(edir,fdir)
+# endif
 #endif
 
 
@@ -3082,7 +3829,8 @@
  * MakeXkbDir
  */
 #ifndef MakeXkbDir
-#define MakeXkbDir(basedir,subdir)					@@\
+# if !CrossCompiling || UseInstalledOnCrossCompile
+#  define MakeXkbDir(basedir,subdir)					@@\
 all::   Concat(subdir,.dir)						@@\
 									@@\
 Concat(subdir,.dir):							@@\
@@ -3093,6 +3841,11 @@
 									@@\
 clean::									@@\
 	RemoveFile(Concat(subdir,.dir))
+# else
+#  define MakeXkbDir(basedir,subdir)					@@\
+clean::									@@\
+	RemoveFile(Concat(subdir,.dir))
+# endif
 #endif
 
 /*
@@ -3120,7 +3873,7 @@
 	$(RM) index.raw file.nPS file.PS file.txt
 #endif
 
-#ifndef MakeSimpleDoc(file,srcs)
+#ifndef MakeSimpleDoc
 #define MakeSimpleDoc(file,srcs) MakeDepSimpleDoc(file,srcs,srcs)
 #endif
 
@@ -3163,8 +3916,8 @@
 all:: file.idx.PS							@@\
 									@@\
 file.idx.PS: srcs index.raw						@@\
-	tail -1 index.raw > index.pageno				@@\
-	grep '^[1-9]' index.raw | sort -f '-t:' +1 -3 +0n -1n | awk -f $(DOCUTILSRC)/fixindex.awk | awk -f $(DOCUTILSRC)/block.awk > index.troff @@\
+	sed -n '$$p' index.raw > index.pageno				@@\
+	grep '^[1-9]' index.raw | (sort -f '-t:' -k1,1n 2>/dev/null || sort -f '-t:' +1 -3 +0n -1n) | awk -f $(DOCUTILSRC)/fixindex.awk | awk -f $(DOCUTILSRC)/block.awk > index.troff @@\
 	cat srcs $(XIDXMACROS) index.troff | $(TROFF) -me > file.idx.nPS \@@\
 	&& $(MV) file.idx.nPS $@					@@\
 	$(RM) index.troff index.pageno					@@\
Index: xc/config/cf/bsdLib.rules
diff -u xc/config/cf/bsdLib.rules:3.18 xc/config/cf/bsdLib.rules:3.20
--- xc/config/cf/bsdLib.rules:3.18	Thu Jan 17 18:29:05 2002
+++ xc/config/cf/bsdLib.rules	Mon Nov 18 17:47:25 2002
@@ -4,7 +4,7 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/bsdLib.rules,v 3.18 2002/01/17 23:29:05 dawes Exp $
+XCOMM $XFree86: xc/config/cf/bsdLib.rules,v 3.20 2002/11/18 22:47:25 dawes Exp $
 /*
  * NetBSD/FreeBSD shared library rules
  */
@@ -201,6 +201,10 @@
 #endif
 #endif
 
+#if !defined(ShlibGlobalsFlags)
+#define ShlibGlobalsFlags -Wl,-Bsymbolic
+#endif
+
 /*
  * InstallSharedLibrary - generate rules to install the shared library.
  * NOTE: file must be executable, hence "INSTBINFLAGS"
@@ -305,6 +309,34 @@
 	$(RM) Concat(lib,libname.so.rev)
 
 #endif /* SharedDepLibraryTarget */
+
+/*
+ * SharedDepCplusplusLibraryTarget - generate rules to create a shared library.
+ */
+#ifndef SharedDepCplusplusLibraryTarget
+#define SharedDepCplusplusLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
+AllTarget(Concat(lib,libname.so.rev))					@@\
+									@@\
+Concat(lib,libname.so.rev):  deplist					@@\
+	$(RM) $@~							@@\
+	@SONAME=`echo $@ | sed 's/\.[^\.]*$$//'`; set -x; \		@@\
+		(cd down; $(CXX) -o up/$@~ $(SHLIBLDFLAGS) -Wl,-soname,$$SONAME solist $(REQUIREDLIBS) BaseShLibReqs); \ @@\
+		$(RM) $$SONAME; $(LN) $@ $$SONAME; \			@@\
+		LinkBuildSonameLibrary($$SONAME)			@@\
+	$(RM) $@							@@\
+	$(MV) $@~ $@							@@\
+	$(RM) Concat(lib,libname.so)					@@\
+	$(LN) $@ Concat(lib,libname.so)					@@\
+	LinkBuildLibrary($@)						@@\
+	LinkBuildLibrary(Concat(lib,libname.so))			@@\
+									@@\
+clean::									@@\
+	@SONAME=`echo Concat(lib,libname.so.rev) | sed 's/\.[^\.]*$$//'`; \ @@\
+	set -x; $(RM) $$SONAME						@@\
+	$(RM) Concat(lib,libname.so)					@@\
+	$(RM) Concat(lib,libname.so.rev)
+
+#endif /* SharedDepCplusplusLibraryTarget */
 
 #ifndef SharedDepModuleTarget
 #define SharedDepModuleTarget(name,deps,solist)				@@\
Index: xc/config/cf/bsdLib.tmpl
diff -u xc/config/cf/bsdLib.tmpl:3.9 xc/config/cf/bsdLib.tmpl:3.12
--- xc/config/cf/bsdLib.tmpl:3.9	Thu May 24 12:34:49 2001
+++ xc/config/cf/bsdLib.tmpl	Sat Jan 11 21:44:25 2003
@@ -1,5 +1,5 @@
 XCOMM $Xorg: bsdLib.tmpl,v 1.3 2000/08/17 19:41:47 cpqbld Exp $
-XCOMM $XFree86: xc/config/cf/bsdLib.tmpl,v 3.9 2001/05/24 16:34:49 dawes Exp $
+XCOMM $XFree86: xc/config/cf/bsdLib.tmpl,v 3.12 2003/01/12 02:44:25 dawes Exp $
 
 /*
  * NetBSD/FreeBSD/OpenBSD shared library template
@@ -25,7 +25,7 @@
 #else /* UseElfFormat */
 
 /*
- * NetBSD/FreeBSD (ELF) shared library template
+ * NetBSD/FreeBSD/OpenBSD (ELF) shared library template
  * Cloned from Linux ELF rules, but with a minor number.
  */
 
@@ -40,7 +40,6 @@
 #endif
 
 #define CplusplusLibC
-#define FrescoSysLibs	CplusplusLibC MathLibrary
 
 /* Allow for libpthread, as overridden by OS definitions */
 #if !defined(SharedX11Reqs)
@@ -53,13 +52,25 @@
 #define SharedXawReqs	$(LDPRELIBS) $(XMULIB) $(XTOOLLIB) $(XPMLIB) $(XLIB)
 #define SharedXaw6Reqs	$(LDPRELIBS) $(XMULIB) $(XTOOLLIB) $(XLIB)
 #define SharedXmuReqs	$(LDPRELIBS) $(XTOOLLIB) $(XLIB)
+#define SharedXmuuReqs	$(LDPRELIB) $(XTOOLLIB) $(XLIB)
 #define SharedXextReqs	$(LDPRELIBS) $(XLIBONLY)
 #define SharedXiReqs	$(LDPRELIBS) $(XLIB)
+#define SharedXpReqs	$(LDPRELIB) $(XAUTHLIB) $(EXTENSIONLIB) $(XLIBONLY)
+#define SharedXpmReqs   $(LDPRELIB) $(XLIB)
 #define SharedPexReqs	$(LDPRELIBS) $(XLIBONLY) MathLibrary
+#define SharedXrandrReqs  $(LDPRELIB) $(XRENDERLIB) $(XLIB)
+#define SharedXrenderReqs $(LDPRELIB) $(EXTENSIONLIB) $(XLIB)
+#define SharedXssReqs	$(LDPRELIB) $(XLIB) $(EXTENSIONLIB) $(XTOOLLIB)
 #define SharedXtstReqs	$(LDPRELIBS) $(XLIB)
 #define SharedXieReqs	$(LDPRELIBS) $(XLIBONLY)
+#define SharedXvReqs	$(LDPRELIB) $(XLIB)
 #define SharedSMReqs	$(LDPRELIBS) $(ICELIB)
-#define SharedFrescoReqs	$(LDPRELIBS) $(XLIBONLY) FrescoSysLibs
-#define SharedXtfReqs	$(LDPRELIBS) $(FRESCOLIB) $(XTOOLLIB) $(XLIB) FrescoSysLibs
+#define SharedGLReqs	$(LDPRELIBS) $(XLIB) -lc
+#define SharedGLUReqs	$(LDPRELIB) $(XLIB) $(GLXLIB)
+#define SharedXcursorReqs   $(LDPRELIB) $(XRENDERLIB) $(XLIB)
+
+#define SharedDPSReqs	$(LDPRELIB) $(SMLIB) $(ICELIB) $(XTOOLLIB) $(XLIB)
+#define SharedDPSTKReqs	$(LDPRELIB) $(SMLIB) $(ICELIB) $(XTOOLLIB) $(DPSLIB) $(XLIB)
+#define SharedpsresReqs	$(LDPRELIB) $(SMLIB) $(ICELIB) $(XTOOLLIB) $(XLIB)
 
 #endif /* UseElfFormat */
Index: xc/config/cf/cross.def
diff -u xc/config/cf/cross.def:1.2 xc/config/cf/cross.def:1.3
--- xc/config/cf/cross.def:1.2	Thu Mar 29 21:15:17 2001
+++ xc/config/cf/cross.def	Thu Apr  4 09:05:33 2002
@@ -1,10 +1,11 @@
-/* $XFree86: xc/config/cf/cross.def,v 1.2 2001/03/30 02:15:17 keithp Exp $ */
+/* $XFree86: xc/config/cf/cross.def,v 1.3 2002/04/04 14:05:33 eich Exp $ */
 /*
  * This file contains redefinitions of some symbols to enable
  * cross compilation: e.g. paths for include files and paths to
  * compiler images.  It will have to be edited to reflect these
  * given your local configuration.
  */
+#if 0
 #undef i386Architecture
 #define Arm32Architecture
 
@@ -39,4 +40,6 @@
 
 #define ServerXdmcpDefines	/**/
 
+#define HostCcCmd  cc
+#endif
 #include <cross.rules>
Index: xc/config/cf/cross.rules
diff -u xc/config/cf/cross.rules:1.6 xc/config/cf/cross.rules:1.8
--- xc/config/cf/cross.rules:1.6	Thu Nov 15 18:15:55 2001
+++ xc/config/cf/cross.rules	Sun Jul 14 13:08:15 2002
@@ -1,10 +1,10 @@
-XCOMM $XFree86: xc/config/cf/cross.rules,v 1.6 2001/11/15 23:15:55 alanh Exp $
+XCOMM $XFree86: xc/config/cf/cross.rules,v 1.8 2002/07/14 17:08:15 alanh Exp $
 
 #ifndef HostCcCmd
 #define HostCcCmd cc
 #endif
 
-#define HostLinkRule(target, flags, src, libs)  HostCcCmd -I$(BUILDINCDIR) -o target src libs
+#define HostLinkRule(target,flags,objs,libs)  HostCcCmd -I$(BUILDINCDIR) -o target flags objs libs
 
 /* ComplexHostProgramTarget - Compile a program such that we can run
  * it on this host, i.e., don't use the default cross compiler.
@@ -13,7 +13,8 @@
 #define	ComplexHostProgramTarget(program)				@@\
               CC=HostCcCmd							@@\
     STD_INCLUDES=							@@\
-          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)		@@\
+          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)\	@@\
+		$(CROSSCOMPILEDEFINES) $(CROSSCOMPILEBOOTSTRAPDEFINES)	@@\
 EXTRA_LOAD_FLAGS=							@@\
         PROGRAM = program						@@\
 									@@\
@@ -38,7 +39,8 @@
 									@@\
               CC=HostCcCmd					@@\
     STD_INCLUDES=							@@\
-          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)		@@\
+          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)\	@@\
+		$(CROSSCOMPILEDEFINES) $(CROSSCOMPILEBOOTSTRAPDEFINES)	@@\
 EXTRA_LOAD_FLAGS=							@@\
         PROGRAM = program						@@\
 									@@\
@@ -60,9 +62,10 @@
 #define SimpleHostProgramTarget_1(program)				@@\
            SRCS = program.c						@@\
 									@@\
-              CC=cc							@@\
+              CC=HostCcCmd						@@\
     STD_INCLUDES=							@@\
-          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)		@@\
+          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)\	@@\
+		$(CROSSCOMPILEDEFINES) $(CROSSCOMPILEBOOTSTRAPDEFINES)	@@\
 EXTRA_LOAD_FLAGS=							@@\
         PROGRAM = program						@@\
 									@@\
@@ -84,9 +87,10 @@
 #define SimpleHostProgramTarget_2(program)				@@\
            SRCS = program.c						@@\
 									@@\
-              CC=cc							@@\
+              CC=HostCcCmd						@@\
     STD_INCLUDES=							@@\
-          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)		@@\
+          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)\	@@\
+		$(CROSSCOMPILEDEFINES) $(CROSSCOMPILEBOOTSTRAPDEFINES)	@@\
 EXTRA_LOAD_FLAGS=							@@\
         PROGRAM = program						@@\
 									@@\
@@ -104,9 +108,10 @@
 #define SimpleHostProgramTarget_3(program)				@@\
            SRCS = program.c						@@\
 									@@\
-              CC=cc							@@\
+              CC=HostCcCmd						@@\
     STD_INCLUDES=							@@\
-          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)		@@\
+          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)\	@@\
+		$(CROSSCOMPILEDEFINES) $(CROSSCOMPILEBOOTSTRAPDEFINES)	@@\
 EXTRA_LOAD_FLAGS=							@@\
         PROGRAM = program						@@\
 									@@\
@@ -124,9 +129,10 @@
 #define SimpleHostProgramTarget_4(program)				@@\
            SRCS = program.c						@@\
 									@@\
-              CC=cc							@@\
+              CC=HostCcCmd						@@\
     STD_INCLUDES=							@@\
-          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)		@@\
+          CFLAGS=$(TOP_INCLUDES) $(INCLUDES) $(BOOTSTRAPCFLAGS)\	@@\
+		$(CROSSCOMPILEDEFINES) $(CROSSCOMPILEBOOTSTRAPDEFINES)	@@\
 EXTRA_LOAD_FLAGS=							@@\
         PROGRAM = program						@@\
 									@@\
Index: xc/config/cf/cygwin.cf
diff -u xc/config/cf/cygwin.cf:3.34 xc/config/cf/cygwin.cf:3.49
--- xc/config/cf/cygwin.cf:3.34	Mon Dec 10 11:22:37 2001
+++ xc/config/cf/cygwin.cf	Tue Dec 31 14:48:42 2002
@@ -1,19 +1,19 @@
-XCOMM platform:  $XFree86: xc/config/cf/cygwin.cf,v 3.34 2001/12/10 16:22:37 alanh Exp $
+XCOMM platform:  $XFree86: xc/config/cf/cygwin.cf,v 3.49 2002/12/31 19:48:42 alanh Exp $
 
 #ifndef OSName
-#define OSName                  Cygwin
+# define OSName                 Cygwin
 #endif
 #ifndef OSVendor
-#define OSVendor                Red Hat Inc.
+# define OSVendor               Red Hat Inc.
 #endif
 #ifndef OSMajorVersion
-#define OSMajorVersion          1
+# define OSMajorVersion		DefaultOSMajorVersion
 #endif
 #ifndef OSMinorVersion
-#define OSMinorVersion          3
+# define OSMinorVersion		DefaultOSMinorVersion
 #endif
 #ifndef OSTeenyVersion
-#define OSTeenyVersion		6
+# define OSTeenyVersion		DefaultOSTeenyVersion
 #endif
 
 #define ProjectRoot 		/usr/X11R6
@@ -24,21 +24,23 @@
 #define UnixCpp
 #endif
 
+#if !CrossCompiling
+#define HasGcc2			YES
+#endif /* !CrossCompiling */
 #define HasGcc2ForCplusplus     YES
 #define GccUsesGas              YES
 #define UseGas                  YES
 #define GnuCpp                  YES
 
-#if !CrossCompiling
-#define BootstrapCFlags		-L/lib/automode.o
-#endif
-
 #define ExtraLoadFlags		-Wl,--enable-auto-import
 
 #define HasShadowPasswd         NO
 #define HasLibCrypt             YES
 #define HasPutenv               YES
 #define HasPoll			NO
+#ifndef UseCygIPC
+#define UseCygIPC		NO
+#endif
 #if UseCygIPC
 # define HasShm			YES
 # define ServerExtraSysLibs	-lcygipc
@@ -70,7 +72,7 @@
  * /lib/libtermcap.a doesn't have tgetent, which is needed for
  * xc/programs/xterm/resize.exe
  */
-#define TermcapLibrary -lncurses.dll
+#define TermcapLibrary		-lncurses.dll
 
 #define AvoidNullMakeCommand    YES
 #define StripInstalledPrograms  YES
@@ -82,7 +84,7 @@
 #define NeedVarargsPrototypes   YES
 #define NeedWidePrototypes      NO
 #define SetTtyGroup             YES
-#define ExpandManNames          NO
+#define ExpandManNames          YES
 #define HasDlopen	        NO
 #define HasGnuMake		YES
 #define UseGccMakeDepend	NO
@@ -103,7 +105,7 @@
 #define GccGasOption	        -DGCCUSESGAS
 #define AsmDefines	        -DUSE_GAS -DGCCUSESGAS
 #ifndef LdCmd
-#define LdCmd                   ld
+#define LdCmd                   gcc -lautomode
 #endif /* LdCmd */
 #define MkdirHierCmd            mkdir -p
 #ifndef CppCmd
@@ -116,6 +118,20 @@
 #define LexLib                  -lfl
 #define HasFlex			YES
 
+/*
+ * Cygwin-specific Windows resource compiler command
+ */
+
+#ifdef CrossCompileDir
+# ifndef WindresCmd
+#  define WindresCmd		Concat3(CrossCompileDir,/,windres)
+# endif
+#else
+# ifndef WindresCmd
+#  define WindresCmd		windres
+# endif
+#endif
+
 #define PreProcessCmd           CcCmd -E
 
 #ifndef PostIncDir
@@ -127,22 +143,32 @@
 
 #define LdCombineFlags          -r
 
-/* We don't define -ansi yet as newlib (which is cygwin's library) doesn't
- * define some needed prototypes when -ansi is set, when that's fixed
- * we can remove these lines and use the default XFree86 options. */
+/*
+ * We do not define -ansi yet as newlib (which is Cygwin's library) does not
+ * define some needed prototypes when -ansi is set, when that is fixed
+ * we can remove these lines and use the default XFree86 options.
+ */
 #ifndef DefaultCCOptions
-# define DefaultCCOptions /* -ansi -pedantic */ GccWarningOptions
+# define DefaultCCOptions	/* -ansi -pedantic */ GccWarningOptions
 #endif
 
 # ifndef OptimizedCDebugFlags
 #  define OptimizedCDebugFlags	DefaultGcc2i386Opt
 # endif
 
-#define StandardDefines         -D__i386__ -DWIN32_LEAN_AND_MEAN -DX_LOCALE -D_X86_ -D__STDC__ -DNO_TCP_H -D__CYGWIN__ -D_XOPEN_SOURCE -D_POSIX_C_SOURCE=199309L -D_BSD_SOURCE -D_SVID_SOURCE -D_GNU_SOURCE
+#define StandardDefines         -D__i386__ -DWIN32_LEAN_AND_MEAN -DX_LOCALE \
+				-D_X86_ -D__CYGWIN__ -D_XOPEN_SOURCE \
+				-D_POSIX_C_SOURCE=199309L -D_BSD_SOURCE \
+				-D_SVID_SOURCE -D_GNU_SOURCE -DNO_ALLOCA
 
 #define XawI18nDefines          -DUSE_XWCHAR_STRING -DUSE_XMBTOWC
 #define HasWChar32              YES
 #define StandardCppOptions	-traditional
+
+/*
+ * Cygwin only has shared memory support when using the cygipc package,
+ * or the newer cygserver package.
+ */
 #if UseCygIPC
 # if ThreadedX
 #  define StandardCppDefines      -DHAS_THREADS -DHAS_SHM StandardDefines
@@ -156,9 +182,29 @@
 #  define StandardCppDefines      StandardDefines
 # endif
 #endif
-#define ServerOSDefines         XFree86ServerDefines -DDDXTIME -DFD_SETSIZE=256 -DDDXOSINIT -DDDXOSVERRORF -DDDXOSFATALERROR
+
+/*
+ * Do not use XFree86ServerDefines here because it always defines
+ * XFree86Server.  Defining XFree86Server causes fb to not expose its
+ * fbSetVisualTypesAndMasks.  Instead, we create a local
+ * XWinServerDefines, which has everything that XFree86ServerDefines
+ * has in it, but it allows us to easily remove the XFree86Server
+ * define for experimental development purposes.
+ */
+#define XWinServerDefines	-DAVOID_GLYPHBLT -DPIXPRIV -DSINGLEDEPTH \
+				XFree86DGADefines XFree86XvDefines \
+				XFree86LoaderDefines -DXFree86Server \
+				VidModeExtensionDefines \
+				XFree86XvMCDefines \
+				ServerSnprintfDefines \
+				SmartScheduleDefines \
+				DebugDefines XFree86XResDefines \
+				-DX_BYTE_ORDER=ByteOrder
+#define ServerOSDefines         XWinServerDefines \
+				-DDDXTIME -DFD_SETSIZE=256 -DDDXOSINIT \
+				-DDDXOSVERRORF -DDDXOSFATALERROR
 #define XkbServerDefines        -DXKB_ALWAYS_USES_SOFT_REPEAT
-#define ServerExtraDefines      -DGCCUSESGAS XFree86ServerDefines
+#define ServerExtraDefines      -DGCCUSESGAS XWinServerDefines
 #define ConnectionFlags         -DTCPCONN -DUNIXCONN
 #define ExtraLibraries          
 #define InstUidFlags            -m 4711
@@ -206,12 +252,12 @@
 
 #define BuildGlxExt             YES
 #define BuildXInputExt		YES
-#define BuildXF86VidModeExt     YES
+#define BuildXF86VidModeExt     NO
 #define BuildXF86DGA		NO	/* No direct access to hardware */
 #define BuildXvExt		YES
 #define BuildXF86MiscExt	NO
 #define BuildRender		YES
-#define BuildRandR		YES
+#define BuildRandR		NO
 #define BuildXF86DRI		NO	/* No direct access to hardware */
 #define BuildXF86DRM		NO	/* No direct access to hardware */
 #define BuildXKB		YES
@@ -280,38 +326,20 @@
 
 #define XF86CardDrivers		/**/
 
-
-/*
- * These man rules were ganked from linux.cf, verbatim.
- * I am not convinced that we need them.
- */
-#if 0
-/* Some of these man page defaults are overriden in the above OS sections */
-#ifndef ManSuffix
-# define ManSuffix      1x
-#endif
-#ifndef ManDir
-# define ManDir         $(MANSOURCEPATH)1
-#endif
-#ifndef LibManSuffix
-# define LibManSuffix   3x
-#endif
-#ifndef LibmanDir
-# define LibmanDir      $(MANSOURCEPATH)3
-#endif
-#ifndef FileManSuffix
-# define FileManSuffix  5x
-#endif
-#ifndef FileManDir
-# define FileManDir     $(MANSOURCEPATH)5
-#endif
-#endif
-
 /* Server build rules */
+#ifndef XnestServer
 #define XnestServer			YES
+#endif
+#ifndef BuildXprint
 #define BuildXprint			YES
+#endif
+#ifndef XprtServer
 #define XprtServer			YES
+#endif
+#ifndef XVirtualFramebufferServer
 #define XVirtualFramebufferServer	YES
+#endif
+
 #define XWinServer			YES
 
 /*
Index: xc/config/cf/cygwin.rules
diff -u xc/config/cf/cygwin.rules:3.18 xc/config/cf/cygwin.rules:3.23
--- xc/config/cf/cygwin.rules:3.18	Thu Nov 15 18:15:55 2001
+++ xc/config/cf/cygwin.rules	Sat Dec 28 12:32:00 2002
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/config/cf/cygwin.rules,v 3.18 2001/11/15 23:15:55 alanh Exp $
+XCOMM $XFree86: xc/config/cf/cygwin.rules,v 3.23 2002/12/28 17:32:00 alanh Exp $
 
 /*
  * Cygwin shared library rules (DLL versions)
@@ -7,9 +7,11 @@
 #define HasSharedLibraries	YES
 #define NeedLibInsideFlag	NO
 #define ForceNormalLib		NO
-#define SharedLibXaw		NO
-#define SharedLibXmu		NO 
+#define SharedLibXaw		NO /* For these we need new binutils */
+#define SharedLibXmu		NO
 #define SharedLibXt		NO
+#define SharedLibFont		NO
+#define SharedLibXaw6		NO
 #define SharedLibSM		YES
 #define SharedLibICE		YES
 #define SharedLibXext		YES
@@ -20,9 +22,6 @@
 #define SharedOldX		YES
 #define SharedLibXp		YES
 #define SharedLibGlx		YES
-#define SharedLibFont		NO
-#define SharedLibXaw6		NO
-#define SharedLibgetsurf	NO 
 #define SharedLibDps		YES
 #define SharedLibDpsTk		YES
 #define SharedLibGlu		YES
@@ -52,6 +51,14 @@
 #define UseExportLists YES
 #endif
 
+#define SharedLibraryName(libname, rev) \
+Concat3(cyg,libname,-$(shell echo rev|sed s=\\..*==).dll)    
+
+#define ImportLibraryName(libname, rev) \
+Concat3(lib,libname,-$(shell echo rev|sed s=\\..*==).dll.a)    
+
+#define ShortImportLibraryName(libname, rev) \
+Concat3(lib,libname,.dll.a)    
 
 /*
  * SharedDepLibraryTarget - generate rules to create a shared library.
@@ -75,22 +82,23 @@
  */
 
 #define SharedDepLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
-AllTarget(Concat3(lib,libname,.dll))                                    @@\
+AllTarget(SharedLibraryName(libname,rev))                             @@\
 									@@\
 CppFileTarget(libname.def,libname-def.cpp,-DLIBRARY_VERSION=rev,$(ICONFIGFILES)) @@\
 									@@\
                                                                         @@\
 									@@\
-Concat3(lib,libname,.dll): deplist libname.def				@@\
-	RemoveFile(LibraryTargetName(libname))				@@\
-	RemoveFile(Concat3(lib,libname,.dll))				@@\
-	MakeDLL(libname,solist)						@@\
-	LinkBuildLibrary(Concat3(lib,libname,.a))			@@\
-	LinkBuildDLL(Concat3(lib,libname,.dll))				@@\
+SharedLibraryName(libname,rev): deplist libname.def		        @@\
+	RemoveFile(ImportLibraryName(libname,rev))			@@\
+	RemoveFile(SharedLibraryName(libname,rev))			@@\
+	MakeDLL(libname,solist,rev)	                		@@\
+	LinkBuildLibrary(ImportLibraryName(libname,rev))		@@\
+	LinkImportLibrary(ImportLibraryName(libname,rev),LibraryTargetName(libname))	@@\
+	LinkBuildDLL(SharedLibraryName(libname,rev))			@@\
 									@@\
 clean::									@@\
-	RemoveFile(LibraryTargetName(libname))				@@\
-	RemoveFile(Concat3(lib,libname,.dll))				@@\
+	RemoveFile(ImportLibraryName(libname,rev))				@@\
+	RemoveFile(SharedLibraryName(libname,rev))			@@\
 
 #endif /* SharedDepLibraryTarget */
 
@@ -116,22 +124,23 @@
  */
 
 #define SharedDepCplusplusLibraryTarget(libname,rev,deplist,solist,down,up) @@\
-AllTarget(Concat3(lib,libname,.dll))                                        @@\
+AllTarget(SharedLibraryName(libname,rev))                             @@\
                                                                             @@\
 CppFileTarget(libname.def,libname-def.cpp,-DLIBRARY_VERSION=rev,$(ICONFIGFILES)) @@\
                                                                             @@\
                                                                             @@\
                                                                             @@\
-Concat3(lib,libname,.dll): deplist libname.def                              @@\
-	RemoveFile(LibraryTargetName(libname))                                  @@\
-	RemoveFile(Concat3(lib,libname,.dll))                                   @@\
-	MakeCplusplusDLL(libname,solist)                                        @@\
-	LinkBuildLibrary(Concat3(lib,libname,.a))                               @@\
-	LinkBuildDLL(Concat3(lib,libname,.dll))                                 @@\
-                                                                            @@\
-clean::                                                                     @@\
-	RemoveFile(LibraryTargetName(libname))                                  @@\
-	RemoveFile(Concat3(lib,libname,.dll))                                   @@\
+SharedLibraryName(libname,rev): deplist libname.def                     @@\
+	RemoveFile(ImportLibraryName(libname,rev))                      @@\
+	RemoveFile(SharedLibraryName(libname,rev))                      @@\
+	MakeCplusplusDLL(libname,solist,rev)                            @@\
+	LinkBuildLibrary(ImportLibraryName(libname,rev))                @@\
+	LinkImportLibrary(ImportLibraryName(libname,rev),LibraryTargetName(libname))	@@\
+	LinkBuildDLL(SharedLibraryName(libname,rev))                    @@\
+                                                                        @@\
+clean::                                                                 @@\
+	RemoveFile(ImportLibraryName(libname,rev))                      @@\
+	RemoveFile(SharedLibraryName(libname,rev))                      @@\
 
 #endif /* SharedDepCplusplusLibraryTarget */
 
@@ -173,22 +182,22 @@
  * MakeDllProg
  */ 
     
-#define MakeDLLProg(libname,solist,prog)			@@\
-	prog -shared -Wl,--out-implib=Concat3(lib,libname,.a) -Wl,--enable-auto-import --def libname.def -o Concat3(lib,libname,.dll) solist $(REQUIREDLIBS)
+#define MakeDLLProg(libname,solist,prog,rev)			        @@\
+	prog -shared -Wl,--out-implib=ImportLibraryName(libname,rev) -Wl,--enable-auto-import --def libname.def -Wl,--exclude-libs,ALL -o SharedLibraryName(libname,rev) solist $(REQUIREDLIBS)
     
 /*
  * MakeDll
  */
 
-#define MakeDLL(libname,solist)						@@\
-    MakeDLLProg(libname,solist,$(CC))
+#define MakeDLL(libname,solist,rev)					@@\
+    MakeDLLProg(libname,solist,$(CC),rev)
 
 /*
  * MakeCplusplusDll
  */
 
-#define MakeCplusplusDLL(libname,solist)						@@\
-    MakeDLLProg(libname,solist,$(CXX))
+#define MakeCplusplusDLL(libname,solist,rev)				@@\
+    MakeDLLProg(libname,solist,$(CXX),rev)
 
 
 
@@ -197,29 +206,42 @@
  */
 
 #define SharedLibraryTarget(libname,rev,solist,down,up)                 @@\
-AllTarget(Concat3(lib,libname,.dll))                                    @@\
+AllTarget(SharedLibraryName(libname,rev))                             @@\
 									@@\
 CppFileTarget(libname.def,libname-def.cpp,-DLIBRARY_VERSION=rev,$(ICONFIGFILES)) @@\
 									@@\
                                                                         @@\
-Concat3(lib,libname,.dll): solist libname.def				@@\
-	RemoveFile(LibraryTargetName(libname))				@@\
-	RemoveFile(Concat3(lib,libname,.dll))				@@\
-	MakeDLL(libname,solist)						@@\
-	LinkBuildLibrary(Concat3(lib,libname,.a))			@@\
-	LinkBuildDLL(Concat3(lib,libname,.dll))				@@\
-clean::									@@\
-	RemoveFile(LibraryTargetName(libname))				@@\
-	RemoveFile(Concat3(lib,libname,.dll))				@@\
+SharedLibraryName(libname,rev): solist libname.def	        	@@\
+	RemoveFile(ImportLibraryName(libname,rev))	               	@@\
+	RemoveFile(SharedLibraryName(libname,rev))	            	@@\
+	MakeDLL(libname,solist,rev)		        		@@\
+	LinkBuildLibrary(ImportLibraryName(libname,rev))       		@@\
+	LinkImportLibrary(ImportLibraryName(libname,rev),LibraryTargetName(libname))	@@\
+	LinkBuildDLL(SharedLibraryName(libname,rev))	      		@@\
+clean::							              	@@\
+	RemoveFile(ImportLibraryName(libname,rev))	                @@\
+	RemoveFile(SharedLibraryName(libname,rev))	                @@\
 
 
 /*
+ * InstallLink
+ */
+    
+#ifndef InstallLink
+#define InstallLink(step, file, link, dest)                             @@\
+step::                                                                  @@\
+	MakeDir($(DESTDIR)dest)                                         @@\
+	$(LN) -sf file $(DESTDIR)dest/link
+#endif   
+    
+/*
  * InstallSharedLibrary
  */
 
 #define InstallSharedLibrary(libname,rev,dest)                          @@\
-InstallTarget(install,LibraryTargetName(libname),$(INSTLIBFLAGS),$(USRLIBDIR)) @@\
-InstallTarget(install,Concat3(lib,libname,.dll),$(INSTLIBFLAGS),$(BINDIR))
+InstallTarget(install,ImportLibraryName(libname,rev),$(INSTLIBFLAGS),$(USRLIBDIR)) @@\
+InstallTarget(install,SharedLibraryName(libname,rev),$(INSTBINFLAGS),$(BINDIR)) @@\
+InstallLink(install,ImportLibraryName(libname,rev),ShortImportLibraryName(libname,rev),$(USRLIBDIR))    
 
 
 /*
@@ -264,6 +286,16 @@
 	cd $(BUILDBINDIR) && $(CP) $(BUILDBINTOP)/$(CURRENT_DIR)/lib .
 #endif
 
+#ifndef LinkImportLibrary
+#ifdef UseInstalled 
+#define LinkImportLibrary(lib, importlib) $(_NULLCMD_)
+#else
+#define LinkImportLibrary(lib, importlib) MakeDir($(BUILDLIBDIR))     @@\
+	RemoveFile($(BUILDLIBDIR)/importlib)                            @@\
+	cd $(BUILDLIBDIR) && $(LN) lib importlib
+#endif
+#endif /* LinkImportLibrary */
+
 
 /*
  * LinkBuildBinary - This rule normally creates a link in xc/exports/bin
@@ -286,7 +318,7 @@
 all:: binary								@@\
 	MakeDir($(BUILDBINDIR))						@@\
 	RemoveFile($(BUILDBINDIR)/binary)				@@\
-	$(CP) $(BUILDBINTOP)/$(CURRENT_DIR)/binary $(BUILDBINDIR)
+	cd $(BUILDBINDIR) && $(CP) $(BUILDBINTOP)/$(CURRENT_DIR)/binary .
 #endif /* LinkBuildBinary */
 
 
@@ -305,6 +337,7 @@
 	RemoveFile(ProgramTargetName(program))
 
 
+#if CrossCompiling
 /*
  * ComplexProgramTarget_1 - Imake.rules doesn't wrap the program names
  * with ProgramTargetName(), so we need this rule for Cygwin.
@@ -326,6 +359,7 @@
 									@@\
 clean::									@@\
 	RemoveFiles($(PROGS_EXE))
+#endif
 
 
 /*
@@ -429,3 +463,19 @@
 	echo "okay, continuing in $(CURRENT_DIR)")
 #endif /* UseInstalled */
 #endif /* ImakeDependency */
+
+
+/*
+ * ResourceObjectRule - Build a Windows resouce file (.res) into
+ * an object file (.o) that can be linked in with the executable
+ * or library being built.
+ */
+
+#ifndef ResourceObjectRule
+#define ResourceObjectRule(basename,depends,options) 			@@\
+AllTarget(basename.RESsuf)						@@\
+basename.RESsuf: basename.RCsuf depends					@@\
+	RemoveFile($@)							@@\
+	ClearmakeOSName \
+	WindresCmd basename.RCsuf options -O coff -o basename.RESsuf
+#endif /* ResourceObjectRule */
Index: xc/config/cf/cygwin.tmpl
diff -u xc/config/cf/cygwin.tmpl:3.9 xc/config/cf/cygwin.tmpl:3.14
--- xc/config/cf/cygwin.tmpl:3.9	Thu Nov 15 19:52:27 2001
+++ xc/config/cf/cygwin.tmpl	Sat Jan 11 21:44:25 2003
@@ -1,5 +1,5 @@
 XCOMM $XConsortium: WinLib.tmpl,v 1.1 94/01/08 18:32:51 rws Exp $
-XCOMM $XFree86: xc/config/cf/cygwin.tmpl,v 3.9 2001/11/16 00:52:27 dawes Exp $
+XCOMM $XFree86: xc/config/cf/cygwin.tmpl,v 3.14 2003/01/12 02:44:25 dawes Exp $
 
 #if UseCygIPC
 #define SharedX11Reqs -lcygipc
@@ -33,8 +33,10 @@
 #define SharedXrenderReqs $(LDPRELIB) $(EXTENSIONLIB) $(XLIB)
 #define SharedpsresReqs $(LDPRELIB) $(SMLIB) $(ICELIB) $(XTOOLLIB) $(XLIB)
 #define SharedXmuuReqs $(LDPRELIB) $(XTOOLLIB) $(XLIB)
-#define SharedXrandrReqs $(LDPRELIB) $(XLIB)
+#define SharedXrandrReqs $(LDPRELIB) $(XRENDERLIB) $(XLIB)
+#define SharedXcursorReqs $(LDPRELIB) $(XRENDERLIB) $(XLIB) 
 
+
 #ifndef FixupLibReferences
 #define FixupLibReferences()						@@\
 XMULIBONLY = -lXmu							@@\
@@ -43,4 +45,21 @@
 
 #ifndef XawClientLibs
 #define XawClientLibs $(XAWLIB) $(XMULIBONLY) $(XTOOLLIB) $(XPMLIB) $(XLIB)
+#endif
+
+
+/*
+ * Suffix for Windows resource source files
+ */
+
+#ifndef RCsuf
+#define RCsuf rc
+#endif
+
+/*
+ * Suffix for Windows resource compiled files
+ */
+
+#ifndef RESsuf
+#define RESsuf res
 #endif
Index: xc/config/cf/darwin.cf
diff -u xc/config/cf/darwin.cf:1.21 xc/config/cf/darwin.cf:1.34
--- xc/config/cf/darwin.cf:1.21	Tue Jan 15 16:22:31 2002
+++ xc/config/cf/darwin.cf	Tue Dec  3 23:40:15 2002
@@ -1,4 +1,4 @@
-XCOMM platform:  $XFree86: xc/config/cf/darwin.cf,v 1.21 2002/01/15 21:22:31 keithp Exp $
+XCOMM platform:  $XFree86: xc/config/cf/darwin.cf,v 1.34 2002/12/04 04:40:15 torrey Exp $
 
 /* Darwin / Mac OS X configuration by John Carmack <johnc@idsoftware.com> */
 
@@ -6,6 +6,9 @@
 #ifndef OSName
 #define OSName                  DefaultOSName
 #endif
+#ifndef OSVendor
+#define OSVendor                Apple Computer, Inc.
+#endif
 #ifndef OSMajorVersion
 #define OSMajorVersion          DefaultOSMajorVersion
 #endif
@@ -24,17 +27,37 @@
 #define HasSnprintf             YES
 #define HasPutenv               YES
 #define HasBSD44Sockets         YES
+#define Malloc0ReturnsNull      NO
+#define HasShadowPasswd         NO
 #define HasUsableFileMmap       YES
 #define HasZlib                 YES
 #ifndef HasShm
 # define HasShm                 YES
 #endif
 #define HasNdbm                 YES
-
+#if OSMajorVersion >= 6
+# define HasNCurses             YES
+#else
+# define HasNCurses             NO
+#endif
 #ifndef HasGroff
 # define HasGroff               YES
 #endif
+#ifndef HasGcc3
+# define HasGcc3                NO
+#endif
 
+/* Thread support */
+#define HasPosixThreads         YES
+#define SystemMTDefines         -D_REENTRANT
+#if OSMajorVersion >= 6
+# define HasThreadSafeAPI       YES
+# define MTSafeAPIDefines       -DXUSE_MTSAFE_API -DXNO_MTSAFE_UNISTDAPI
+#else
+# define HasThreadSafeAPI       NO
+# define MTSafeAPIDefines       -DXOS_USE_MTSAFE_NETDBAPI
+#endif
+
 /* Libtool on Darwin always uses minor numbers */
 #define LibtoolMinorVersions	YES
 
@@ -58,20 +81,53 @@
 # define DarwinQuartzSupport    YES
 #endif
 
+#if DarwinQuartzSupport
+
+# ifndef GlxUseAqua
+#  define GlxUseAqua            YES
+# endif
+
+/*
+ * Before Mac OS X 10.1 a number of features were missing or broken.
+ */
+# if (OSMajorVersion == 1 && OSMinorVersion >= 4) || OSMajorVersion >= 5
+#  ifndef HasNSCarbonWindow
+#   define HasNSCarbonWindow    YES
+#  endif
+#  ifndef HasCGMachPort
+#   define HasCGMachPort        YES
+#  endif
+# else
+/* NSWindow(NSCarbonExtensions) is broken. */
+#  ifndef HasNSCarbonWindow
+#   define HasNSCarbonWindow    NO
+#  endif
+/* CGWindowServerCFMachPort() does not exist. */
+#  ifndef HasCGMachPort
+#   define HasCGMachPort        NO
+#  endif
+# endif
+
+#endif  /* DarwinQuartzSupport */
+
 /* we don't need -lm */
 #define MathLibrary             /**/
 
-/* we don't have a termcap library */
-#define TermcapLibrary          /**/
+#define TermcapLibrary          -lcurses
+#define SetTtyGroup             YES             /* for xterm */
 
 /* we don't have a dbm library */
 #define DBMLibrary              /**/
 
 #define MkdirHierCmd            mkdir -p
 
-/* our cpp isn't in /lib/cpp and it doesn't like -undef */
+/* our cpp isn't in /lib/cpp and early versions don't like -undef */
 #define CppCmd                  /usr/bin/cpp
-#define RawCppCmd               CppCmd
+#if HasGcc3
+# define RawCppCmd              CppCmd -undef
+#else
+# define RawCppCmd              CppCmd
+#endif
 
 /* we have a gcc compatible compiler, but its not called gcc */
 #define CcCmd                   /usr/bin/cc
@@ -96,13 +152,21 @@
 
 #ifdef PpcDarwinArchitecture
 # define DarwinMachineDefines   -D__powerpc__
-# define OptimizedCDebugFlags   -O2
+# if HasGcc3
+#  define OptimizedCDebugFlags   -Os
+# else
+#  define OptimizedCDebugFlags   -O2
+# endif
 # define ByteOrder              X_BIG_ENDIAN
 #endif /* PpcDarwinArchitecture */
 
 #ifdef i386DarwinArchitecture
 # define DarwinMachineDefines   -D__i386__
-# define OptimizedCDebugFlags   -O2 -fno-strength-reduce
+# if HasGcc3
+#  define OptimizedCDebugFlags   -Os
+# else
+#  define OptimizedCDebugFlags   -O2 -fno-strength-reduce
+# endif
 # define ByteOrder              X_LITTLE_ENDIAN
 #endif /* i386DarwinArchitecture */
 
@@ -116,16 +180,18 @@
  * Darwin's setlocale() doesn't work properly, so use X11's instead.
  */
 #define StandardDefines         DarwinMachineDefines -D__DARWIN__ \
-                                -DNO_ALLOCA -DX_LOCALE
+                                -DNO_ALLOCA -DX_LOCALE -DCSRG_BASED
 
 /*
  * Set this to NO to just build the client libs, which should work without
  * having to write any platform specific code.
  */
-#define BuildServer             YES
+#ifndef BuildServer
+# define BuildServer            YES
 
 /* our custom X server */
-#define XDarwinServer           YES
+# define XDarwinServer          YES
+#endif
 
 /* Thanks to the IOKit, the X server does not have to be SetUID. */
 #ifndef InstallXserverSetUID
@@ -141,6 +207,12 @@
 
 /* no Display Power Management extension */
 #define BuildDPMSExt            NO
+
+/* no XFree86-Misc extension */
+#define BuildXF86MiscExt        NO
+
+/* no XFree86-VidMode extension */
+#define BuildXF86VidModeExt	NO
 
 #define BuildLibPathVar         DYLD_LIBRARY_PATH
 
Index: xc/config/cf/darwinLib.rules
diff -u xc/config/cf/darwinLib.rules:1.4 xc/config/cf/darwinLib.rules:1.5
--- xc/config/cf/darwinLib.rules:1.4	Tue Jan 15 19:39:59 2002
+++ xc/config/cf/darwinLib.rules	Tue Jul 16 21:06:04 2002
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/config/cf/darwinLib.rules,v 1.4 2002/01/16 00:39:59 keithp Exp $
+XCOMM $XFree86: xc/config/cf/darwinLib.rules,v 1.5 2002/07/17 01:06:04 torrey Exp $
 /*
  * Darwin/Mac OS X shared library rules
  */
@@ -57,14 +57,14 @@
  * the library gone for long periods.
  */
 #ifndef SharedLibraryTarget
-#ifdef UseInstalled
-#define LinkBuildSonameLibrary(lib) true
-#else
-#define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
+# ifdef UseInstalled
+#  define LinkBuildSonameLibrary(lib) true
+# else
+#  define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
 	cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/lib .)
-#endif
+# endif
 
-#define SharedLibraryTarget(libname,rev,solist,down,up)			@@\
+# define SharedLibraryTarget(libname,rev,solist,down,up)		@@\
 AllTarget(Concat(lib,libname.rev.dylib))				@@\
 									@@\
 Concat(lib,libname.rev.dylib):  solist $(EXTRALIBRARYDEPS)		@@\
@@ -93,18 +93,18 @@
  * SharedDepLibraryTarget - generate rules to create a shared library.
  */
 #ifndef SharedDepLibraryTarget
-#ifdef UseInstalled
-#ifndef LinkBuildSonameLibrary
-#define LinkBuildSonameLibrary(lib) true
-#endif
-#else
-#ifndef LinkBuildSonameLibrary
-#define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
+# ifdef UseInstalled
+#  ifndef LinkBuildSonameLibrary
+#   define LinkBuildSonameLibrary(lib) true
+#  endif
+# else
+#  ifndef LinkBuildSonameLibrary
+#   define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
 	cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/lib .)
-#endif
-#endif
+#  endif
+# endif
 
-#define SharedDepLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
+# define SharedDepLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
 AllTarget(Concat(lib,libname.rev.dylib))				@@\
 									@@\
 Concat(lib,libname.rev.dylib):  deplist $(EXTRALIBRARYDEPS)		@@\
@@ -128,6 +128,46 @@
 	$(RM) Concat(lib,libname.rev.dylib) Concat(lib,libname.dylib)
 
 #endif /* SharedDepLibraryTarget */
+
+/*
+ * SharedDepCplusplusLibraryTarget - generate rules to create a shared library.
+ */
+#ifndef SharedDepCplusplusLibraryTarget
+# ifdef UseInstalled
+#  ifndef LinkBuildSonameLibrary
+#   define LinkBuildSonameLibrary(lib) true
+#  endif
+# else
+#  ifndef LinkBuildSonameLibrary
+#   define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
+	cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/lib .)
+#  endif
+# endif
+
+# define SharedDepCplusplusLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
+AllTarget(Concat(lib,libname.rev.dylib))				@@\
+									@@\
+Concat(lib,libname.rev.dylib):  deplist $(EXTRALIBRARYDEPS)		@@\
+	$(RM) $@~							@@\
+	@MAJREV=`expr rev : '\([^.]*\)'`; \				@@\
+	  INSTALLNAME=Concat(lib,libname.$$MAJREV.dylib); \		@@\
+	  set -x; (cd down; $(CXX) -o up/$@~ $(SHLIBLDFLAGS) -install_name $(USRLIBDIR)/$$INSTALLNAME -current_version rev -compatibility_version rev solist $(REQUIREDLIBS)); \ @@\
+	  $(RM) $$INSTALLNAME; $(LN) $@ $$INSTALLNAME; \		@@\
+	  LinkBuildSonameLibrary($$INSTALLNAME)				@@\
+	$(RM) $@							@@\
+	$(MV) $@~ $@							@@\
+	@if $(SOSYMLINK); then (set -x; \				@@\
+	  $(RM) Concat(lib,libname.dylib); \				@@\
+	  $(LN) $@ Concat(lib,libname.dylib)); fi			@@\
+	LinkBuildLibrary($@)						@@\
+	LinkBuildLibraryMaybe(Concat(lib,libname.dylib),$(SOSYMLINK))	@@\
+									@@\
+clean::									@@\
+	@MAJREV=`expr rev : '\([^.]*\)'`; \				@@\
+	set -x; $(RM) Concat(lib,libname.$$MAJREV.dylib)		@@\
+	$(RM) Concat(lib,libname.rev.dylib) Concat(lib,libname.dylib)
+
+#endif /* SharedDepCplusplusLibraryTarget */
 
 #ifndef SharedDepModuleTarget
 #define SharedDepModuleTarget(name,deps,solist)				@@\
Index: xc/config/cf/darwinLib.tmpl
diff -u xc/config/cf/darwinLib.tmpl:1.2 xc/config/cf/darwinLib.tmpl:1.10
--- xc/config/cf/darwinLib.tmpl:1.2	Wed Sep 12 21:28:57 2001
+++ xc/config/cf/darwinLib.tmpl	Tue Feb  4 18:04:59 2003
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/config/cf/darwinLib.tmpl,v 1.2 2001/09/13 01:28:57 torrey Exp $
+XCOMM $XFree86: xc/config/cf/darwinLib.tmpl,v 1.10 2003/02/04 23:04:59 torrey Exp $
 /*
  * Darwin/Mac OS X shared library template
  */
@@ -18,25 +18,35 @@
 #define SharedX11Reqs
 #endif
 
+#ifndef FontLibSharedFreeType
+#define FontLibSharedFreeType YES
+#endif
+#if FontLibSharedFreeType
+#define SharedXfontReqs     $(LDPRELIB) $(FONTSTUBLIB) GzipLibrary $(FREETYPE2LIB) -flat_namespace
+#else
+#define SharedXfontReqs     $(LDPRELIB) $(FONTSTUBLIB) GzipLibrary -flat_namespace
+#endif
+
 #define SharedGLReqs        $(LDPRELIB) $(XLIB)
 #define SharedGLUReqs       $(LDPRELIB) $(XLIB) $(GLXLIB)
 #define SharedSMReqs        $(LDPRELIB) $(ICELIB)
 #define SharedXawReqs       $(LDPRELIB) $(XMULIB) $(XTOOLLIB) $(XPMLIB) $(XLIB)
 #define SharedXaw6Reqs      $(LDPRELIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
+#define SharedXcursorReqs   $(LDPRELIB) $(XRENDERLIB) $(XLIB)
 #define SharedXextReqs      $(LDPRELIB) $(XLIBONLY)
-#define SharedXfontReqs     $(LDPRELIB) $(FONTSTUBLIB) GzipLibrary
 #define SharedXiReqs        $(LDPRELIB) $(XLIB)
 #define SharedXmuReqs       $(LDPRELIB) $(XTOOLLIB) $(XLIB)
 #define SharedXmuuReqs      $(LDPRELIB) $(XTOOLLIB) $(XLIB)
 #define SharedXpReqs        $(LDPRELIB) $(XAUTHLIB) $(EXTENSIONLIB) $(XLIBONLY)
 #define SharedXpmReqs       $(LDPRELIB) $(XLIB)
-#define SharedXrandrReqs    $(LDPRELIB) $(XLIB)
+#define SharedXrandrReqs    $(LDPRELIB) $(XRENDERLIB) $(XLIB)
 #define SharedXrenderReqs   $(LDPRELIB) $(EXTENSIONLIB) $(XLIB)
 #define SharedXssReqs       $(LDPRELIB) $(XLIB) $(EXTENSIONLIB) $(XTOOLLIB)
-#define SharedXtReqs        $(LDPRELIB) $(XLIBONLY) $(SMLIB) $(ICELIB)
+#define SharedXtReqs        $(LDPRELIB) $(XLIBONLY) $(SMLIB) $(ICELIB) -flat_namespace
 #define SharedXtstReqs      $(LDPRELIB) $(XLIB)
 #define SharedXvReqs        $(LDPRELIB) $(XLIB)
 #define SharedDPSReqs       $(LDPRELIB) $(SMLIB) $(ICELIB) $(XTOOLLIB) $(XLIB)
 #define SharedDPSTKReqs     $(LDPRELIB) $(SMLIB) $(ICELIB) $(XTOOLLIB) $(DPSLIB) $(XLIB)
 #define SharedOldXReqs      $(LDPRELIB) $(XLIBONLY)
 #define SharedpsresReqs     $(LDPRELIB) $(SMLIB) $(ICELIB) $(XTOOLLIB) $(XLIB)
+
Index: xc/config/cf/linux.cf
diff -u xc/config/cf/linux.cf:3.175 xc/config/cf/linux.cf:3.201
--- xc/config/cf/linux.cf:3.175	Tue Jan 15 16:22:31 2002
+++ xc/config/cf/linux.cf	Mon Feb 17 12:07:32 2003
@@ -4,7 +4,7 @@
 
 
 
-XCOMM platform:  $XFree86: xc/config/cf/linux.cf,v 3.175 2002/01/15 21:22:31 keithp Exp $
+XCOMM platform:  $XFree86: xc/config/cf/linux.cf,v 3.201 2003/02/17 17:07:32 dawes Exp $
 
 #ifndef LinuxElfDefault
 # define LinuxElfDefault	YES
@@ -123,51 +123,57 @@
 /*
  *
  *
-# define DebianMaintainer	"xfree86@packages.debian.org"
+# define DebianMaintainer	YES
  *
  *
  */
 
 # ifdef DebianMaintainer
-#  define BuilderEMailAddr	"submit@bugs.debian.org"
-#  define XFree86Devel		YES
-#  define BuildAllSpecsDocs	YES
-# define InstallXinitConfig	YES
-# define InstallXdmConfig	YES
-# define InstallFSConfig	YES
-# define DebuggableLibraries	YES
-# define ForceNormalLib		YES
-# define BuildSpecsDocs		YES
-# define SpecsDocDirs		CTEXT GL ICCCM X11 Xext Xv i18n xterm
-# define BuildRman		NO
-# define BuildHtmlManPages	NO
+#  ifndef XFree86CustomVersion
+#   define XFree86CustomVersion		"Debian"
+#  endif
+#  ifndef BuilderEMailAddr
+#   define BuilderEMailAddr		"debian-x@lists.debian.org"
+#  endif
+#  define XFree86Devel			YES
+#  define BuildAllSpecsDocs		YES
+#  define InstallXinitConfig		YES
+#  define InstallXdmConfig		YES
+#  define InstallFSConfig		YES
+#  define DebuggableLibraries		YES
+#  define ForceNormalLib		YES
+#  define BuildSpecsDocs		YES
+#  define SpecsDocDirs			CTEXT GL ICCCM X11 Xext Xv i18n xterm
+#  define BuildRman			NO
+#  define BuildHtmlManPages		NO
 
 /* we build-depend on libfreetype6-dev (FreeType 2.x) */
-#  define BuildFreetype2Library	NO
-#  define HasFreetype2		YES
+#   define BuildFreetype2Library	NO
+#   define HasFreetype2			YES
 /* m68k has no 2.4 kernel yet */
-#  ifndef Mc68020Architecture
-#   define HasLinuxInput	YES
-#  endif
-#  define HasXdmAuth		YES
-#  define HasLatex		YES
+#   ifndef Mc68020Architecture
+#    define HasLinuxInput		YES
+#   endif
+#   define HasXdmAuth			YES
+#   define HasLatex			YES
 /* at present, glide2 only works on i386 */
-#  ifdef i386Architecture
-#   define HasGlide2		YES
-#   define Glide2IncDir		/usr/include/glide
-#  endif /* i386Architecture */
+#   ifdef i386Architecture
+#    define HasGlide2			YES
+#    define Glide2IncDir		/usr/include/glide
+#   endif /* i386Architecture */
 /* at present, glide3 only works on alpha and i386 */
-#  if defined(i386Architecture) || defined(AlphaArchitecture)
-#   define HasGlide3		YES
-#   define Glide3IncDir		/usr/include/glide3
-#  endif /* i386Architecture || AlphaArchitecture */
+#   if defined(i386Architecture) || defined(AlphaArchitecture)
+#    define HasGlide3			YES
+#    define Glide3IncDir		/usr/include/glide3
+#   endif /* i386Architecture || AlphaArchitecture */
 /* extended instruction set support */
-#  ifdef i386Architecture
-#   define HasMMXSupport	YES
-#   define Has3DNowSupport	YES
+#   ifdef i386Architecture
+#   define HasX86Support		YES
+#    define HasMMXSupport		YES
+#    define Has3DNowSupport		YES
 /* 2.4 is not yet the official (or predominant) kernel in unstable */
-#   define HasKatmaiSupport	NO
-#  endif /* i386Architecture */
+#    define HasSSESupport		NO
+#   endif /* i386Architecture */
 # endif /* DebianMaintainer */
 #endif /* LinuxDebian */
 
@@ -249,7 +255,7 @@
 
 /* On x86, determine whether to build with MTRR support */
 #ifndef HasMTRRSupport
-# ifdef i386Architecture
+# if defined (i386Architecture) || defined (x86_64Architecture)
 /* There is no certain way to know if <asm/mtrr.h> is available,
    but it made it into kernel 2.2, so... */
 #  if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion >= 2)
@@ -263,10 +269,10 @@
 #endif
 
 #ifndef XF86INT10_BUILD
-# ifdef i386Architecture
+# if defined (i386Architecture)
 #  define XF86INT10_BUILD	X86VM
-# elif defined SparcArchitecture
-#  define XF86INT10_BUILD	X86INT10_STUB
+# elif defined (x86_64Architecture)
+#  define XF86INT10_BUILD	X86EMU_OS
 # else
 #  define XF86INT10_BUILD	X86EMU_GENERIC
 # endif
@@ -275,22 +281,34 @@
 /* The DRM module requires kernel services that appeared in late 2.1.x
    kernels and are known to be present in 2.2.x kernels. */
 #ifndef BuildXF86DRI
-#  if defined(i386Architecture) || defined(ia64Architecture)
+#  if defined(AlphaArchitecture)
+#    define BuildXF86DRI	YES
+#  elif defined(Arm32Architecture)
+#    define BuildXF86DRI	NO
+#  elif defined(HPArchitecture)
+#    define BuildXF86DRI	NO
+#  elif defined(i386Architecture)
 #    if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion >= 2)
 #      define BuildXF86DRI	YES
 #    else
 #      define BuildXF86DRI	NO
 #    endif
-#  elif defined(SparcArchitecture)
-#    define BuildXF86DRI	YES
-#  elif defined(AlphaArchitecture)
+#  elif defined(ia64Architecture)
 #    define BuildXF86DRI	YES
+#  elif defined(Mc68020Architecture)
+#    define BuildXF86DRI	NO
+#  elif defined(MipsArchitecture)
+#    define BuildXF86DRI	NO
 #  elif defined(PpcArchitecture)
 #    define BuildXF86DRI	YES
-#  elif defined(Mc68020Architecture)
+#  elif defined(s390Architecture) || defined(s390xArchitecture)
 #    define BuildXF86DRI	NO
-#  elif defined(Arm32Architecture)
+#  elif defined(SparcArchitecture)
+#    define BuildXF86DRI	YES
+#  elif defined(SuperHArchitecture)
 #    define BuildXF86DRI	NO
+#  elif defined(x86_64Architecture)
+#    define BuildXF86DRI	YES
 #  else
 #    define BuildXF86DRI	NO
 #  endif
@@ -306,13 +324,19 @@
 # endif
 #endif
 
+#if 0
+/*
+ * Building the DRM module requires kernel source be installed.  It's safest
+ * to just not enable it by default.
+ */
+
 /* The DRM module requires kernel services that appeared in late 2.1.x
    kernels and are known to be present in 2.2.x kernels.  Unfortunately,
    the kernel API is a moving target and the module may break with new
    kernel revisions.  So, we'll only build the module for kernels that are
    known to be supported by the module. */
 #ifndef BuildXF86DRM
-#  if defined(i386Architecture) || defined(ia64Architecture) || defined(SparcArchitecture) || defined(AlphaArchitecture)
+#  if defined(i386Architecture) || defined(ia64Architecture) || defined(SparcArchitecture) || defined(AlphaArchitecture) || defined(x86_64Architecture)
 #    if OSMajorVersion == 2
        /* Only tested for Linux 2.2.0 through 2.2.12 */
 #      if OSMinorVersion == 2 && OSTeenyVersion <= 12
@@ -334,9 +358,10 @@
 #    define BuildXF86DRM	NO
 #  endif
 #endif
+#endif
 
 #ifndef HasAgpGart
-#  if defined(i386Architecture) || defined(ia64Architecture)
+#  if defined(i386Architecture) || defined(ia64Architecture) || defined(x86_64Architecture)
      /* The AGPGART header file is included in os-support/linux, which
         allows all drivers that depend on AGP to build properly. */
 #    define HasAgpGart	YES
@@ -345,18 +370,19 @@
 #  endif
 #endif
 
-/* Support for Intel's Katmai Native Instructions, also known as the
+/*
+ * Support for Intel's SSE Native Instructions, also known as the
  * Streaming SIMD Extensions, was introduced in the 2.4.x kernels.
  */
-#ifndef HasKatmaiSupport
-#  ifdef i386Architecture
+#ifndef HasSSESupport
+#  if defined(i386Architecture)
 #    if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion >= 4)
-#      define HasKatmaiSupport		YES
+#      define HasSSESupport		YES
 #    else
-#      define HasKatmaiSupport		NO
+#      define HasSSESupport		NO
 #    endif
 #  else
-#    define HasKatmaiSupport		NO
+#    define HasSSESupport		NO
 #  endif
 #endif
 
@@ -365,7 +391,7 @@
  * don't enable it for libc5 as a reasonable default.
  */
 #ifndef HasMMXSupport
-#  ifdef i386Architecture
+#  if defined(i386Architecture)
 #    if (LinuxCLibMajorVersion > 5)
 #      define HasMMXSupport		YES
 #    else
@@ -383,7 +409,7 @@
  * XXX This is preliminary.
  */
 #ifndef Has3DNowSupport
-#  ifdef i386Architecture
+#  if defined(i386Architecture)
 #    if (LinuxCLibMajorVersion > 5)
 #      define Has3DNowSupport		YES
 #    else
@@ -420,7 +446,9 @@
 #define UseGas			YES
 #define GnuCpp			YES
 #if UseElfFormat
-# define HasDlopen		YES
+# ifndef HasDlopen
+#  define HasDlopen		YES
+# endif
 #endif
 #ifndef HasShadowPasswd
 # if UseElfFormat
@@ -436,6 +464,11 @@
 #define HasSnprintf		YES
 #define HasMkstemp		YES
 #endif
+/* getresuid() appeared in 2.1.4, and getresgid in 2.1.44 */
+#if !defined(HasGetresuid) && \
+ (((OSMajorVersion*100000) + (OSMinorVersion*1000) + OSTeenyVersion) >= 201044)
+#define HasGetresuid		YES
+#endif
 #if OSMajorVersion >= 2
 #define HasUsableFileMmap	YES
 #endif
@@ -447,6 +480,10 @@
 #define HasGroff		YES
 #endif
 
+#ifndef HasLibpng
+#define HasLibpng		YES
+#endif
+
 #define AvoidNullMakeCommand	YES
 #ifndef DebuggableLibraries
 #define DebuggableLibraries	NO
@@ -481,6 +518,30 @@
 
 #define MkdirHierCmd		mkdir -p
 
+#ifndef HaveLib64
+# if defined (x86_64Architecture) || defined (s390xArchitecture)
+#  define HaveLib64	YES
+# else
+#  define HaveLib64	NO
+# endif
+#endif
+
+#if UseElfFormat
+# ifndef DoLoadableServer
+#  if defined(HPArchitecture) || defined(MipsArchitecture) || defined(SuperHArchitecture)
+#   define DoLoadableServer	NO
+#  else
+#   define DoLoadableServer	YES
+#  endif
+# endif
+#endif
+
+#if  (GccMajorVersion == 3) &&  (GccMinorVersion >= 1)
+# define GccAliasingArgs      -fno-strict-aliasing
+#else
+# define GccAliasingArgs      /* */
+#endif
+
 #if LinuxElfDefault
 # if UseElfFormat
 #  ifdef MipsArchitecture
@@ -491,17 +552,26 @@
 #     define MakeDllModules	YES
 #   endif
 #  endif /* MipsArchitecure */
+#  if defined (i386Architecture) && ((GccMajorVersion >3) \
+   || ((GccMajorVersion == 3) &&  (GccMinorVersion >= 1)))
+#   ifndef CcCmd
+#    define CcCmd		gcc -m32
+#   endif
+#   ifndef CplusplusCmd
+#    define CplusplusCmd		c++ -m32
+#   endif
+#  endif
 #  ifndef CcCmd
 #   define CcCmd		gcc
+#   define CplusplusCmd		c++
 #  endif
 #  ifndef AsCmd
-#   define AsCmd		as
+#   define AsCmd		CcCmd -c -x assembler
 #  endif
+#  define AsmDefines		-D__ELF__
 #  ifndef LdCmd
-#   define LdCmd		ld
+#   define LdCmd		CcCmd -nostdlib
 #  endif
-#  define AsmDefines		-D__ELF__
-#  define CplusplusCmd		c++
 #  ifndef LinuxUsesNcurses
 #   if LinuxCLibMajorVersion >= 6 || (LinuxDistribution == LinuxSuSE)
 #    define LinuxUsesNcurses	YES
@@ -512,9 +582,17 @@
 #  ifndef TermcapLibrary
 #   if UseStaticTermcapLib
 #    if LinuxUsesNcurses
-#     define TermcapLibrary	StaticLibrary(/usr/lib,ncurses)
+#     if !HaveLib64
+#      define TermcapLibrary	StaticLibrary(/usr/lib,ncurses)
+#     else
+#      define TermcapLibrary	StaticLibrary(/usr/lib64,ncurses)
+#     endif
 #    else
-#     define TermcapLibrary	StaticLibrary(/usr/lib/termcap,termcap)
+#     if !HaveLib64
+#      define TermcapLibrary	StaticLibrary(/usr/lib/termcap,termcap)
+#     else
+#      define TermcapLibrary	StaticLibrary(/usr/lib64/termcap,termcap)
+#     endif
 #    endif
 #   else
 #    if LinuxUsesNcurses
@@ -528,84 +606,99 @@
 #  ifdef AlphaArchitecture
 #   define CcCmd		gcc -b alpha-linuxecoff
 #   define CplusplusCmd		g++ -b alpha-linuxecoff
-#   define AsCmd		/usr/alpha-linuxecoff/bin/as
-#   define LdCmd		/usr/alpha-linuxecoff/bin/ld -m alpha
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib -Wl,"-m alpha"
 #   define AsmDefines		-DUSE_GAS -U__ELF__
 #  endif /* AlphaArchitecture */
 #  ifdef HPArchitecture
 #   define CcCmd		gcc
 #   define CplusplusCmd		g++
-#   define AsCmd		as
-#   define LdCmd		ld
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib
 #   define AsmDefines		-DUSE_GAS -U__ELF__
 #  endif /* HPArchitecture */
-#  ifdef ia64Architecture
-#   define CcCmd		gcc
-#   define CplusplusCmd		g++
-#   define AsCmd		as
-#   define LdCmd		ld
-#   define AsmDefines		-DUSE_GAS -U__ELF__
-#  endif /* ia64Architecture */
 #  ifdef i386Architecture
 #   define CcCmd		gcc -b i486-linuxaout
 #   define CplusplusCmd		g++ -b i486-linuxaout
-#   define AsCmd		/usr/i486-linuxaout/bin/as
-#   define LdCmd		/usr/i486-linuxaout/bin/ld -m i386linux
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib -Wl,"-m i386linux"
 #   define AsmDefines		-DUSE_GAS -U__ELF__
 #  endif /* i386Architecture */
+#  ifdef ia64Architecture
+#   define CcCmd		gcc
+#   define CplusplusCmd		g++
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib
+#   define AsmDefines		-DUSE_GAS -U__ELF__
+#  endif /* ia64Architecture */
 #  ifdef Mc68020Architecture
 #   define CcCmd		gcc -b m68k-linuxaout
 #   define CplusplusCmd		g++ -b m68k-linuxaout
-#   define AsCmd		/usr/m68k-linuxaout/bin/as
-#   define LdCmd		/usr/m68k-linuxaout/bin/ld -m m68klinux
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib -Wl,"-m m68klinux"
 #   define AsmDefines		-DUSE_GAS -U__ELF__
 #  endif /* Mc68020Architecture */
-# endif
+#  ifdef x86_64Architecture
+#   define CcCmd		gcc
+#   define CplusplusCmd		g++
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib
+#   define AsmDefines		-DUSE_GAS -U__ELF__
+#  endif /* x86_64Architecture */
+# endif /* UseElfFormat */
 #else
 # if UseElfFormat
 #  ifdef AlphaArchitecture
 #   define CcCmd		gcc -b alpha-linux
-#   define AsCmd		/usr/alpha-linux/bin/as
-#   define LdCmd		ld -m elf64alpha
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib -Wl,"-m elf64alpha"
 #   define AsmDefines		-D__ELF__
 #   define CplusplusCmd		c++ -b alpha-linux
 #  endif /* AlphaArchitecture */
-#  ifdef ia64Architecture
-#   define CcCmd		gcc
-#   define CplusplusCmd		g++
-#   define AsCmd		as
-#   define LdCmd		ld
-#   define AsmDefines		-D__ELF__
-#  endif /* ia64Architecture */
 #  ifdef HPArchitecture
 #   define CcCmd		gcc
 #   define CplusplusCmd		g++
-#   define AsCmd		as
-#   define LdCmd		ld
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib
 #   define AsmDefines		-D__ELF__
 #   define SharedLibXau		YES
 #  endif /* HPArchitecture */
 #  ifdef i386Architecture
 #   define CcCmd		gcc -b i486-linux
-#   define AsCmd		/usr/i486-linux/bin/as
-#   define LdCmd		ld -m elf_i386
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nosdlib -Wl,"-m elf_i386"
 #   define AsmDefines		-D__ELF__
 #   define CplusplusCmd		c++ -b i486-linux
 #  endif /* i386Architecture */
+#  ifdef ia64Architecture
+#   define CcCmd		gcc
+#   define CplusplusCmd		g++
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib
+#   define AsmDefines		-D__ELF__
+#  endif /* ia64Architecture */
 #  ifdef Mc68020Architecture
 #   define CcCmd		gcc -b m68k-linux
-#   define AsCmd		/usr/m68k-linux/bin/as
-#   define LdCmd		ld -m m68kelf
+#   define AsCmd		CcCmd -c -x assembler
+#   define LdCmd		CcCmd -nostdlib -W,l"-m m68kelf"
 #   define AsmDefines		-D__ELF__
 #   define CplusplusCmd		c++ -b m68k-linux
 #  endif /* Mc68020Architecture */
+#  ifdef x86_64Architecture
+#   define CcCmd                 gcc
+#   define CplusplusCmd          g++
+#   define AsCmd                 CcCmd -c -x assembler
+#   define LdCmd                 CcCmd -nostdlib
+#   define AsmDefines            -D__ELF__
+#  endif /* x86_64Architecture */
 # else
 #  define CcCmd			gcc
-#  define AsCmd			as
-#  define LdCmd			ld
+#  define AsCmd			CcCmd -c -x assembler
+#  define LdCmd			CcCmd -nostdlib
 #  define AsmDefines		-DUSE_GAS
 # endif
 #endif
+
 #if UseElfFormat
 # ifndef DoLoadableServer
 #  ifdef HPArchitecture
@@ -616,7 +709,7 @@
 # endif
 #endif
 #ifndef CppCmd
-# define CppCmd			/lib/cpp
+# define CppCmd			/usr/bin/cpp
 #endif
 /* Some Linux distributions have yacc, some don't. All have bison. */
 #define YaccCmd			bison -y
@@ -634,43 +727,23 @@
 #define StandardCppDefines	StandardDefines
 
 #define HasVarRun		YES
-#define VarDbDirectory		$(VARDIR)/lib
+#ifndef VarDbDirectory
+# define VarDbDirectory		$(VARDIR)/lib
+#endif
 
 #ifndef XF86OSCardDrivers
 # define XF86OSCardDrivers	v4l
 #endif
 
+#ifndef OSXinputDrivers
+# define OSXinputDrivers	ur98
+#endif
+
 #if UseElfFormat
 # define HasPlugin			YES
 # define VendorHasX11R6_3libXext	YES	/* XC or XFree86 >= 3.3.1 */
 #endif
 
-#ifdef i386Architecture
-# ifndef OptimizedCDebugFlags
-#  define OptimizedCDebugFlags	DefaultGcc2i386Opt
-# endif
-# define LinuxMachineDefines	-D__i386__
-# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
-# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
-#endif /* i386Architecture */
-
-#ifdef s390Architecture
-# ifndef OptimizedCDebugFlags
-#  define OptimizedCDebugFlags	-O2
-# endif
-# define LinuxMachineDefines	-D__s390__
-# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
-# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
-#endif /* s390Architecture */
-
-#ifdef s390xArchitecture
-/*#define DefaultCCOptions	-fsigned-char */
-#define OptimizedCDebugFlags	-O3
-#define LinuxMachineDefines	-D__s390x__
-#define ServerOSDefines		XFree86ServerOSDefines -DDDXTIME -DPART_NET
-#define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines -D_XSERVER64
-#endif /* s390xArchitecture */
-
 #ifdef AlphaArchitecture
 # ifndef OptimizedCDebugFlags
 #  define OptimizedCDebugFlags	DefaultGcc2AxpOpt
@@ -693,9 +766,25 @@
 # define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
 #endif /* Arm32Achitecture */
 
+#ifdef HPArchitecture
+# define OptimizedCDebugFlags	-O2  GccAliasingArgs
+# define LinuxMachineDefines	-D__hppa__
+# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
+# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
+#endif
+
+#ifdef i386Architecture
+# ifndef OptimizedCDebugFlags
+#  define OptimizedCDebugFlags	DefaultGcc2i386Opt
+# endif
+# define LinuxMachineDefines	-D__i386__
+# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
+# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
+#endif /* i386Architecture */
+
 #ifdef ia64Architecture
 # ifndef OptimizedCDebugFlags
-#  define OptimizedCDebugFlags	-O2
+#  define OptimizedCDebugFlags	-O2  GccAliasingArgs
 # endif
 # define LinuxMachineDefines	-D__ia64__
 # define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
@@ -704,15 +793,22 @@
 
 #ifdef Mc68020Architecture
 # ifndef OptimizedCDebugFlags
-#  define OptimizedCDebugFlags	-O2
+#  define OptimizedCDebugFlags	-O2  GccAliasingArgs
 # endif
-# define LinuxMachineDefines 	-D__mc68000__
+# define LinuxMachineDefines	-D__mc68000__
 # define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
 # define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
-# define PositionIndependentCFlags -fpic
-# define PositionIndependentCplusplusFlags -fpic
 #endif /* Mc68020Architecture */
 
+#ifdef MipsArchitecture
+# ifndef OptimizedCDebugFlags
+#  define OptimizedCDebugFlags	-O2  GccAliasingArgs
+# endif
+# define LinuxMachineDefines	-D__mips__
+# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
+# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
+#endif
+
 #ifdef PpcArchitecture
 # define DefaultCCOptions	-fsigned-char
 # ifndef OptimizedCDebugFlags
@@ -723,9 +819,26 @@
 # define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
 #endif /* PpcArchitecture */
 
+#ifdef s390Architecture
+# ifndef OptimizedCDebugFlags
+#  define OptimizedCDebugFlags	-O2 -fomit-frame-pointer GccAliasingArgs
+# endif
+# define LinuxMachineDefines	-D__s390__
+# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
+# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
+#endif /* s390Architecture */
+
+#ifdef s390xArchitecture
+/*#define DefaultCCOptions	-fsigned-char */
+#define OptimizedCDebugFlags	-O3 -fomit-frame-pointer
+#define LinuxMachineDefines	-D__s390x__
+#define ServerOSDefines		XFree86ServerOSDefines -DDDXTIME -DPART_NET
+#define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines -D_XSERVER64
+#endif /* s390xArchitecture */
+
 #ifdef SparcArchitecture
 # ifndef OptimizedCDebugFlags
-#  define OptimizedCDebugFlags	-O2
+#  define OptimizedCDebugFlags	-O2  GccAliasingArgs
 # endif
 # define LinuxMachineDefines	-D__sparc__
 # define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
@@ -738,27 +851,11 @@
 # endif
 #endif
 
-#ifdef MipsArchitecture
-# ifndef OptimizedCDebugFlags
-#  define OptimizedCDebugFlags	-O2
-# endif
-# define LinuxMachineDefines	-D__mips__
-# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
-# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
-#endif
-
-#ifdef HPArchitecture
-# define OptimizedCDebugFlags	-O2
-# define LinuxMachineDefines	-D__hppa__
-# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
-# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
-#endif
-
 #ifdef SuperHArchitecture
 # ifndef SuperHArchOptFlags
 #  ifdef SuperH4Architecture
 #   define SuperHArchOptFlags	-m4
-#  elifdef SuperH4NOFPUArchitecture
+#  elif defined(SuperH4NOFPUArchitecture)
 #   define SuperHArchOptFlags	-m4-nofpu
 #  else
 #   define SuperHArchOptFlags	-m3
@@ -772,13 +869,25 @@
 #  endif
 # endif
 # ifndef OptimizedCDebugFlags
-#  define OptimizedCDebugFlags	-O2 SuperHArchOptFlags SuperHEndianFlags
+#  define OptimizedCDebugFlags	-O2 SuperHArchOptFlags SuperHEndianFlags  GccAliasingArgs
 # endif
 # define LinuxMachineDefines	-D__sh__
 # define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
 # define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
+# ifndef DoLoadableServer
+#  define DoLoadableServer NO
+# endif
 #endif
 
+#ifdef x86_64Architecture
+# ifndef OptimizedCDebugFlags
+#  define OptimizedCDebugFlags	DefaultGcc2x86_64Opt
+# endif
+# define LinuxMachineDefines   -D__x86_64__
+# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
+# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines -D_XSERVER64
+#endif /* x86_64Architecture */
+
 #ifndef StandardDefines
 # define StandardDefines	-Dlinux LinuxMachineDefines LinuxSourceDefines
 #endif
@@ -799,6 +908,9 @@
 #define PamMiscLibraries	-lpam_misc
 #endif
 
+#ifndef HasDECnet
+#define HasDECnet		NO
+#endif
 #if HasDECnet
 # define ConnectionFlags	-DUNIXCONN -DTCPCONN -DDNETCONN
 # define ExtraLibraries		-ldnet
@@ -848,8 +960,16 @@
 #define TtClientLibs $(TTLIB) $(XTOOLLIB) $(XLIB)
 #define TtClientDepLibs $(DEPTTLIB) $(DEPXTOOLLIB) $(DEPXLIB)
 
-#if (defined s390Architecture) || (defined s390xArchitecture)
-# define HasXServer	NO
+#if HaveLib64
+# ifndef LibDirName
+#  define LibDirName		lib64
+# endif
+# ifndef SystemUsrLibDir
+#  define SystemUsrLibDir	/usr/lib64
+# endif
+# ifndef TkLibDir
+#  define TkLibDir		/usr/lib64
+# endif
 #endif
 
 #include <lnxLib.rules>
Index: xc/config/cf/lnxLib.rules
diff -u xc/config/cf/lnxLib.rules:3.42 xc/config/cf/lnxLib.rules:3.44
--- xc/config/cf/lnxLib.rules:3.42	Tue Jan 15 19:39:59 2002
+++ xc/config/cf/lnxLib.rules	Mon Nov 18 17:47:25 2002
@@ -1,34 +1,34 @@
 XCOMM $Xorg: lnxLib.rules,v 1.3 2000/08/17 19:41:47 cpqbld Exp $
-XCOMM $XFree86: xc/config/cf/lnxLib.rules,v 3.42 2002/01/16 00:39:59 keithp Exp $
+XCOMM $XFree86: xc/config/cf/lnxLib.rules,v 3.44 2002/11/18 22:47:25 dawes Exp $
 
 /*
  * Linux shared library rules (DLL & ELF versions)
  */
 #ifndef HasSharedLibraries
-#define HasSharedLibraries YES
+# define HasSharedLibraries YES
 #endif
 #ifndef ForceNormalLib
-#define ForceNormalLib NO
+# define ForceNormalLib NO
 #endif
 
 #ifndef SharedOldX
-#define SharedOldX NO
+# define SharedOldX NO
 #endif
 
 #if UseElfFormat
 
-#if (LinuxCLibMajorVersion >= 5 && LinuxCLibMinorVersion >= 4) || LinuxCLibMajorVersion >= 6
-#ifndef SpecialMalloc
-#define SpecialMalloc NO
-#endif
+# if (LinuxCLibMajorVersion >= 5 && LinuxCLibMinorVersion >= 4) || LinuxCLibMajorVersion >= 6
+#  ifndef SpecialMalloc
+#   define SpecialMalloc NO
+#  endif
 #if 0
-#ifndef UseInternalMalloc
-#define UseInternalMalloc NO
-#endif
-#endif
+#  ifndef UseInternalMalloc
+#   define UseInternalMalloc NO
+#  endif
 #endif
+# endif
 
-#if LinuxCLibMajorVersion <= 5
+# if LinuxCLibMajorVersion <= 5
 /*
  *	#define BaseShLibReqs	-lc
  *
@@ -45,53 +45,57 @@
  * ELF EXECUTABLES LINKED WITH libg.a OR libc_p.a. H.J.
  *
  */
-#define BaseShLibReqs
-#else
+#  define BaseShLibReqs
+# else
 /* With GNU libc 2 this works fine. */
-#define BaseShLibReqs	-lc
-#endif
+#  define BaseShLibReqs	-lc
+# endif
 
-#ifndef SharedDataSeparation
-#define SharedDataSeparation NO
-#endif
-#ifndef SharedCodeDef
-#define SharedCodeDef /**/
-#endif
-#ifndef SharedLibraryDef
-#define SharedLibraryDef /**/
-#endif
-#ifndef ShLibIncludeFile
-#define ShLibIncludeFile <lnxLib.tmpl>
-#endif
-#ifndef SharedLibraryLoadFlags
-#define SharedLibraryLoadFlags -shared
-#endif
-#ifndef PositionIndependentCFlags
-#define PositionIndependentCFlags -fPIC
-#endif
-#ifndef PositionIndependentCplusplusFlags
-#define PositionIndependentCplusplusFlags -fPIC
-#endif
-#ifndef ExtraLoadFlags
-#if LinuxBinUtilsMajorVersion >= 26
-#ifdef UseInstalled
-#if LinuxBinUtilsMajorVersion < 27
-#define ExtraLoadFlags -Wl,-rpath-link,$(USRLIBDIRPATH)
-#endif
-#else
-#define ExtraLoadFlags -Wl,-rpath-link,$(BUILDLIBDIR)
-#endif
-#else
-#define ExtraLoadFlags -Wl,-rpath,$(USRLIBDIRPATH)
-#endif
-#endif
+# ifndef SharedDataSeparation
+#  define SharedDataSeparation NO
+# endif
+# ifndef SharedCodeDef
+#  define SharedCodeDef /**/
+# endif
+# ifndef SharedLibraryDef
+#  define SharedLibraryDef /**/
+# endif
+# ifndef ShLibIncludeFile
+#  define ShLibIncludeFile <lnxLib.tmpl>
+# endif
+# ifndef SharedLibraryLoadFlags
+#  define SharedLibraryLoadFlags -shared
+# endif
+# ifndef PositionIndependentCFlags
+#  define PositionIndependentCFlags -fPIC
+# endif
+# ifndef PositionIndependentCplusplusFlags
+#  define PositionIndependentCplusplusFlags -fPIC
+# endif
+# ifndef ExtraLoadFlags
+#  if LinuxBinUtilsMajorVersion >= 26
+#   ifdef UseInstalled
+#    if LinuxBinUtilsMajorVersion < 27
+#     define ExtraLoadFlags -Wl,-rpath-link,$(USRLIBDIRPATH)
+#    endif
+#   else
+#    define ExtraLoadFlags -Wl,-rpath-link,$(BUILDLIBDIR)
+#   endif
+#  else
+#   define ExtraLoadFlags -Wl,-rpath,$(USRLIBDIRPATH)
+#  endif
+# endif
+
+# if !defined(ShlibGlobalsFlags)
+#  define ShlibGlobalsFlags -Wl,-Bsymbolic
+# endif
 
 /*
  * InstallSharedLibrary - generate rules to install the shared library.
  * NOTE: file must be executable, hence "INSTBINFLAGS"
  */
-#ifndef InstallSharedLibrary
-#define	InstallSharedLibrary(libname,rev,dest)				@@\
+# ifndef InstallSharedLibrary
+#  define	InstallSharedLibrary(libname,rev,dest)			@@\
 install:: Concat(lib,libname.so.rev) 					@@\
 	MakeDir($(DESTDIR)dest)						@@\
 	$(INSTALL) $(INSTALLFLAGS) $(INSTBINFLAGS) Concat(lib,libname.so.rev) $(DESTDIR)dest @@\
@@ -100,14 +104,14 @@
 	@if $(SOSYMLINK); then (set -x; \
 	  $(RM) Concat($(DESTDIR)dest/lib,libname.so); \		@@\
 	  $(LN) Concat(lib,libname.so.rev) Concat($(DESTDIR)dest/lib,libname.so)); fi
-#endif /* InstallSharedLibrary */
+# endif /* InstallSharedLibrary */
 
 /*
  * InstallSharedLibraryData - generate rules to install the shared library data
  */
-#ifndef InstallSharedLibraryData
-#define	InstallSharedLibraryData(libname,rev,dest)
-#endif /* InstallSharedLibraryData */
+# ifndef InstallSharedLibraryData
+#  define	InstallSharedLibraryData(libname,rev,dest)
+# endif /* InstallSharedLibraryData */
 
 
 /*
@@ -115,15 +119,15 @@
  * build it into a different name so that we do not hose people by having
  * the library gone for long periods.
  */
-#ifndef SharedLibraryTarget
-#ifdef UseInstalled
-#define LinkBuildSonameLibrary(lib) true
-#else
-#define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
+# ifndef SharedLibraryTarget
+#  ifdef UseInstalled
+#   define LinkBuildSonameLibrary(lib) true
+#  else
+#   define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
 	cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/lib .)
-#endif
+#  endif
 
-#define SharedLibraryTarget(libname,rev,solist,down,up)			@@\
+#  define SharedLibraryTarget(libname,rev,solist,down,up)		@@\
 AllTarget(Concat(lib,libname.so.rev))					@@\
 									@@\
 Concat(lib,libname.so.rev):  solist $(EXTRALIBRARYDEPS)			@@\
@@ -145,24 +149,24 @@
 	set -x; $(RM) Concat(lib,libname.so.$$MAJREV)			@@\
 	$(RM) Concat(lib,libname.so.rev) Concat(lib,libname.so)
 
-#endif /* SharedLibraryTarget */
+# endif /* SharedLibraryTarget */
 
 /*
  * SharedDepLibraryTarget - generate rules to create a shared library.
  */
-#ifndef SharedDepLibraryTarget
-#ifdef UseInstalled
-#ifndef LinkBuildSonameLibrary
-#define LinkBuildSonameLibrary(lib) true
-#endif
-#else
-#ifndef LinkBuildSonameLibrary
-#define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
+# ifndef SharedDepLibraryTarget
+#  ifdef UseInstalled
+#   ifndef LinkBuildSonameLibrary
+#    define LinkBuildSonameLibrary(lib) true
+#   endif
+#  else
+#   ifndef LinkBuildSonameLibrary
+#    define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
 	cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/lib .)
-#endif
-#endif
+#   endif
+#  endif
 
-#define SharedDepLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
+#   define SharedDepLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
 AllTarget(Concat(lib,libname.so.rev))					@@\
 									@@\
 Concat(lib,libname.so.rev):  deplist $(EXTRALIBRARYDEPS)		@@\
@@ -225,8 +229,8 @@
 
 #endif /* SharedDepCplusplusLibraryTarget */
 
-#ifndef SharedDepModuleTarget
-#define SharedDepModuleTarget(name,deps,solist)				@@\
+# ifndef SharedDepModuleTarget
+#  define SharedDepModuleTarget(name,deps,solist)			@@\
 AllTarget(name)								@@\
 									@@\
 name: deps								@@\
@@ -238,10 +242,10 @@
 clean::									@@\
 	$(RM) name
 
-#endif /* SharedDepModuleTarget */
+# endif /* SharedDepModuleTarget */
 
-#ifndef SharedDriModuleTarget
-#define SharedDriModuleTarget(name,deps,solist)				@@\
+# ifndef SharedDriModuleTarget
+#  define SharedDriModuleTarget(name,deps,solist)			@@\
 AllTarget(name)								@@\
 									@@\
 name: deps								@@\
@@ -255,35 +259,35 @@
 	$(RM) name							@@\
 	$(RM) name.map
 
-#endif /* SharedDriModuleTarget */
+# endif /* SharedDriModuleTarget */
 
 /*
  * SharedLibraryDataTarget - generate rules to create shlib data file;
  */
-#ifndef SharedLibraryDataTarget
-#define SharedLibraryDataTarget(libname,rev,salist)
-#endif /* SharedLibraryTarget */
+# ifndef SharedLibraryDataTarget
+#  define SharedLibraryDataTarget(libname,rev,salist)
+# endif /* SharedLibraryTarget */
 
 #else /* UseElfFormat */
 
-#ifndef SharedDataSeparation
-#define SharedDataSeparation NO
-#endif
-#ifndef SharedCodeDef
-#define SharedCodeDef /**/
-#endif
-#ifndef SharedLibraryDef
-#define SharedLibraryDef /**/
-#endif
-#ifndef ShLibIncludeFile
-#define ShLibIncludeFile <lnxLib.tmpl>
-#endif
-#ifndef SharedLibraryLoadFlags
-#define SharedLibraryLoadFlags /**/
-#endif
-#ifndef PositionIndependentCFlags
-#define PositionIndependentCFlags -B/usr/bin/jump
-#endif
+# ifndef SharedDataSeparation
+#  define SharedDataSeparation NO
+# endif
+# ifndef SharedCodeDef
+#  define SharedCodeDef /**/
+# endif
+# ifndef SharedLibraryDef
+#  define SharedLibraryDef /**/
+# endif
+# ifndef ShLibIncludeFile
+#  define ShLibIncludeFile <lnxLib.tmpl>
+# endif
+# ifndef SharedLibraryLoadFlags
+#  define SharedLibraryLoadFlags /**/
+# endif
+# ifndef PositionIndependentCFlags
+#  define PositionIndependentCFlags -B/usr/bin/jump
+# endif
 
 /*
  * These definitions are now extended to work with the X sources and
@@ -330,16 +334,16 @@
  * files in the shared subdirectory into jump_xxx files.
  */
 
-#ifndef UseInstalled
+# ifndef UseInstalled
 XCOMM These are only needed to build the server
 
-#if LinuxElfDefault
+#  if LinuxElfDefault
 LIBC_SA = /usr/i486-linuxaout/lib/libc.sa
 LIBM_SA = /usr/i486-linuxaout/lib/libm.sa
-#else
+#  else
 LIBC_SA = /usr/lib/libc.sa
 LIBM_SA = /usr/lib/libm.sa
-#endif
+#  endif
 
 JUMP_LDLIBS_libc = `$(CC) --print-libgcc-file-name` -lc
 
@@ -482,14 +486,14 @@
 JUMP_STUBS_IMPORT_XIE = $(JUMP_STUBS_IMPORT_X11) $(LIBM_SA)
 JUMP_LDLIBS_XIE = $(JUMP_ROOT_X11)/libX11.sa $(JUMP_LDLIBS_libc) -lm
 
-#endif /* !UseInstalled */
+# endif /* !UseInstalled */
 
 /*
  * SharedLibraryDataTarget - generate rules to create shared data file
  */
-#ifndef SharedLibraryDataTarget
-#define SharedLibraryDataTarget(libname,rev,salist)
-#endif
+# ifndef SharedLibraryDataTarget
+#  define SharedLibraryDataTarget(libname,rev,salist)
+# endif
 
 /*
  * SharedLibraryTarget - generate rules to create a shared library;
@@ -497,8 +501,8 @@
  * their own (and possibly other) libs, and hosted, which rely on another
  * lib for all the work.
  */
-#ifndef SharedLibraryTarget
-#define SharedLibraryTarget(libname,rev,solist,down,up)			@@\
+# ifndef SharedLibraryTarget
+#  define SharedLibraryTarget(libname,rev,solist,down,up)		@@\
 XCOMM This logic is such to compile the libs in their proper order,	@@\
 XCOMM remain dependent on subsidiary libs, and yet minimize local work	@@\
 									@@\
@@ -646,13 +650,13 @@
 jumpclean_1:								@@\
 	$(RM) -r $(JUMP_SO) $(Concat(JUMP_DIR_,libname)) \		@@\
 		down/mk_JUMP_SA_1 down/mk_JUMP_SO_1 down/mk_JUMP_SO_2
-#endif /* SharedLibraryTarget */
+# endif /* SharedLibraryTarget */
 
 /*
  * InstallSharedLibrary - generate rules to install the shared library.
  */
-#ifndef InstallSharedLibrary
-#define	InstallSharedLibrary(libname,rev,dest)				@@\
+# ifndef InstallSharedLibrary
+#  define	InstallSharedLibrary(libname,rev,dest)			@@\
 install:: $(JUMP_SA) $(JUMP_SO)						@@\
 	MakeDir($(DESTDIR)dest)						@@\
 	@if [ "$(JUMP_IS_HOST)" = YES ]; then \
@@ -661,13 +665,13 @@
 		$(INSTALL) -s -c $(INSTSOLIBFLAGS) $(JUMP_SO) $(DESTDIR)dest; \
 		$(RM) $$T && $(LN) $(JUMP_SO) $$T); fi			@@\
 	$(INSTALL) -c $(INSTLIBFLAGS) $(JUMP_SA) $(DESTDIR)dest
-#endif /* InstallSharedLibrary */
+# endif /* InstallSharedLibrary */
 
 /*
  * InstallSharedLibraryData - generate rules to install the shared library data
  */
-#ifndef InstallSharedLibraryData
-#define	InstallSharedLibraryData(libname,rev,dest)
-#endif /* InstallSharedLibraryData */
+# ifndef InstallSharedLibraryData
+#  define	InstallSharedLibraryData(libname,rev,dest)
+# endif /* InstallSharedLibraryData */
 
 #endif /* UseElfFormat */
Index: xc/config/cf/lnxdoc.rules
diff -u xc/config/cf/lnxdoc.rules:3.26 xc/config/cf/lnxdoc.rules:3.27
--- xc/config/cf/lnxdoc.rules:3.26	Wed Dec 19 18:07:24 2001
+++ xc/config/cf/lnxdoc.rules	Tue Jan 14 22:17:29 2003
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/config/cf/lnxdoc.rules,v 3.26 2001/12/19 23:07:24 dawes Exp $
+XCOMM $XFree86: xc/config/cf/lnxdoc.rules,v 3.27 2003/01/15 03:17:29 dawes Exp $
 XCOMM
 XCOMM Rules for formatting Linuxdoc-SGML documentation
 XCOMM
@@ -80,33 +80,38 @@
  * source tree.  Use with care.
  */
 
-#ifndef UpdateFormattedDoc
-#define UpdateFormattedDoc(textfile,dstdir)				@@\
+#ifndef UpdateFormattedDocLong
+#define UpdateFormattedDocLong(textfile,dstdir,dstfile)			@@\
 update.docs:: textfile							@@\
-	-@if [ -f dstdir/textfile ]; then \				@@\
+	-@if [ -f dstdir/dstfile ]; then \				@@\
 	    if [ "$(FORCEUPDATE)" = yes ]; then set -x; \		@@\
 		if [ "$(FOLLOWLINK)" = no ]; then \			@@\
-			$(RM) dstdir/textfile; \			@@\
+			$(RM) dstdir/dstfile; \				@@\
 		fi; \							@@\
-		cp textfile dstdir/textfile; \				@@\
-		echo "" >> dstdir/textfile; \				@@\
-		echo "\$$XFree86\$$" >> dstdir/textfile; \		@@\
+		cp textfile dstdir/dstfile; \				@@\
+		echo "" >> dstdir/dstfile; \				@@\
+		echo "\$$XFree86\$$" >> dstdir/dstfile; \		@@\
 	    else \							@@\
 		$(RM) __tmp1__ __tmp2__; \				@@\
 		fgrep -v "\$$XFree86:" textfile > __tmp1__; \		@@\
-		fgrep -v "\$$XFree86:" dstdir/textfile > __tmp2__; \	@@\
+		fgrep -v "\$$XFree86:" dstdir/dstfile > __tmp2__; \	@@\
 		if diff -B __tmp1__ __tmp2__ > /dev/null 2>&1; then :; \	@@\
 		else set -x; \						@@\
 			if [ "$(FOLLOWLINK)" = no ]; then \		@@\
-				$(RM) dstdir/textfile; \		@@\
+				$(RM) dstdir/dstfile; \			@@\
 			fi; \						@@\
-			cp textfile dstdir/textfile ; \			@@\
-			echo "" >> dstdir/textfile; \			@@\
-			echo "\$$XFree86"": \$$" >> dstdir/textfile; \	@@\
+			cp textfile dstdir/dstfile ; \			@@\
+			echo "" >> dstdir/dstfile; \			@@\
+			echo "\$$XFree86"": \$$" >> dstdir/dstfile; \	@@\
 		fi; \							@@\
 	    fi; \							@@\
 	fi								@@\
 	@$(RM) __tmp1__ __tmp2__
+#endif
+
+#ifndef UpdateFormattedDoc
+#define UpdateFormattedDoc(textfile,dstdir)				@@\
+UpdateFormattedDocLong(textfile,dstdir,textfile)
 #endif
 
 /*
Index: xc/config/cf/lynx.cf
diff -u xc/config/cf/lynx.cf:3.45 xc/config/cf/lynx.cf:3.46
--- xc/config/cf/lynx.cf:3.45	Thu Jan  3 11:33:49 2002
+++ xc/config/cf/lynx.cf	Fri Dec 13 23:41:11 2002
@@ -3,14 +3,14 @@
 
 
 
-XCOMM platform:  $XFree86: xc/config/cf/lynx.cf,v 3.45 2002/01/03 16:33:49 tsi Exp $
+XCOMM platform:  $XFree86: xc/config/cf/lynx.cf,v 3.46 2002/12/14 04:41:11 dawes Exp $
 
 
 #ifndef OSName
 #define OSName			DefaultOSName
 #endif
 #ifndef OSVendor
-#define OSVendor		(LYNX Real-Time Systems, Inc)
+#define OSVendor		(LynuxWorks Inc.)
 #endif
 #ifndef OSMajorVersion
 #define OSMajorVersion		DefaultOSMajorVersion
@@ -23,9 +23,18 @@
 #endif
 XCOMM operating system:  OSName (OSMajorVersion./**/OSMinorVersion./**/OSTeenyVersion)
 
+#ifndef HasSetenv
+#define HasSetenv		NO
+#endif
+
+#if  OSMajorVersion > 2
+#define HasGcc2			YES
+#endif
+
 #ifndef HasGcc2
 #define HasGcc2			NO
 #endif
+
 #if  OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion > 2)
 # ifndef HasGcc2ForCplusplus
 #  define HasGcc2ForCplusplus	YES
@@ -55,8 +64,13 @@
 #endif
 #ifndef HasPerl
 #define HasPerl			NO
+#endif
+
+#if OSMajorVersion <= 2
+# define USE_MACHINE_ABSOLUTE
 #endif
-#if OSMajorVersion == 3 && OSMinorVersion == 1
+
+#if OSMajorVersion > 3 || (OSMajorVersion == 3 && OSMinorVersion == 1)
 # ifndef UseSmartScheduler
 #  define UseSmartScheduler	NO
 # endif
@@ -84,7 +98,7 @@
 # define ThreadPreStdAPIDefines	-DXPRE_STANDARD_API
 #endif
 #define AvoidNullMakeCommand	YES
-#if OSMajorVersion > 2 || OSMinorVersion > 2
+#if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion > 2)
 #define StripInstalledPrograms	YES
 #else
 /* under LynxOS AT V2.x /bin/strip will leave file.unstripped around
@@ -110,7 +124,7 @@
 #  define CplusplusCmd		g++
 #  define CcCmd			gcc
 # endif
-# if OSMajorVersion > 2 || OSMinorVersion == 5
+# if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion == 5)
 #  define DefaultCCOptions	-ansi -pedantic -fcommon GccWarningOptions
 # endif
 #else
@@ -122,13 +136,17 @@
 #define AsCmd			as
 #define LdCmd			ld
 #define AsmDefines		-DUSE_GAS
-#define CppCmd			/lib/cpp
+#if OSMajorVersion < 4
+# define CppCmd			/lib/cpp
+#else
+# define CppCmd			/bin/cpp
+#endif
 #if !CrossCompiling
 #define YaccCmd			bison -y
 /* make sure we take the right flex on 2.3.0 and 2.4.0 */
 #define LexCmd			/bin/flex
 #endif
-#if OSMajorVersion > 2 || OSMinorVersion >= 5
+#if OSMajorVersion > 2 || (OSMajorVersion == 2 && OSMinorVersion >= 5)
 # define LexLib			-lfl
 #else
 # define LexLib			/**/
@@ -165,17 +183,25 @@
 #else
 # if defined(i386Architecture)
 /* need __i386__ for 2.5.0 AT and higher */
-#  define StandardDefines		-DLynx -DX_LOCALE -D__i386__
+#  if OSMajorVersion <= 3
+#   define StandardDefines		-DLynx -DX_LOCALE -D__i386__ -DNO_MMAP
+#  else
+#   define StandardDefines		-DLynx -DX_LOCALE -D__i386__
+#  endif
 # else
-#  define StandardDefines		-DLynx -DX_LOCALE
+#  if OSMajorVersion <= 3
+#   define StandardDefines		-DLynx -DX_LOCALE -DNO_MMAP
+#  else
+#   define StandardDefines		-DLynx -DX_LOCALE
+#  endif
 # endif
 #endif
 
 #define StandardCppOptions	-traditional
 #define StandardCppDefines	StandardDefines
 #if defined(i386Architecture) || defined(PpcArchitecture)
-# define ServerOSDefines	XFree86ServerOSDefines -DNO_MMAP -DDDXTIME -DPART_NET
-# define ServerExtraDefines	-DGCCUSESGAS -DNO_MMAP XFree86ServerDefines
+# define ServerOSDefines	XFree86ServerOSDefines -DDDXTIME -DPART_NET
+# define ServerExtraDefines	-DGCCUSESGAS XFree86ServerDefines
 # if OSMajorVersion == 2 && OSMinorVersion < 5
 #  define XkbServerDefines      -DNEED_POPEN_WORKAROUND
 # endif
@@ -239,7 +265,22 @@
 # endif
 #endif
 
+#if OSMajorVersion == 4
+# ifndef TkLibName
+#  define TkLibName		tk8.0
+# endif
+# ifndef TkLibDir
+#  define TkLibDir              /usr/lib
+# endif
+# ifndef TclLibName
+#  define TclLibName		tcl8.0
+# endif
+# ifndef TclLibDir
+#  define TclLibDir             /usr/lib
+# endif
 
+#endif /* OSMajorVersion == 4 */
+
 /* define HasMotif to YES for LynxOS with Motif
  * installed according to the notes in README.LynxOS.
  */
@@ -391,6 +432,10 @@
 
 #if !defined(i386Architecture) && !defined(PpcArchitecture)
 # define BuildXF86DGA NO
+#endif
+
+#if 0
+#include <lynxLib.rules>
 #endif
 
 #include <xfree86.cf>
Index: xc/config/cf/os2.cf
diff -u xc/config/cf/os2.cf:3.36 xc/config/cf/os2.cf:3.37
--- xc/config/cf/os2.cf:3.36	Wed Nov  7 21:09:06 2001
+++ xc/config/cf/os2.cf	Fri May 31 12:31:18 2002
@@ -2,59 +2,28 @@
 
 
 
-XCOMM platform:  $XFree86: xc/config/cf/os2.cf,v 3.36 2001/11/08 02:09:06 tsi Exp $
+XCOMM platform:  $XFree86: xc/config/cf/os2.cf,v 3.37 2002/05/31 16:31:18 dawes Exp $
 
-#define OSName           OS/2
-#define OSVendor	 IBM
-#define OSMajorVersion    4
-#define OSMinorVersion    0
+XCOMM hv: This file will now require a compiler that defines
+XCOMM hv: the symbol __UNIXOS2__ (currently a modified EMX gcc,
+XCOMM hv: but in future a separate system)
+
+#define OSName	OS/2
+#define OSVendor	IBM
+#define OSMajorVersion	4
+#define OSMinorVersion	5
+#define OSTeenyVersion	1
 
-/*
- * C library features
- */
-#ifdef __EMX__
-
-/* set this to what you like (almost :-) 
- * OS/2 does a nonstandard bootstrap of imake 
- */
 #define BootstrapCFlags   -DBSD43
 
 #define StandardDefines   -DX_LOCALE -DX_WCHAR
 #define XawI18nDefines    -DUSE_XWCHAR_STRING -DUSE_XMBTOWC
 
-/* This will redirect everything to /XFree86
- * Care will be taken that programs that need a file from this tree
- * will add the environment variable X11ROOT to the search path
- * so you can redirect the stuff to a different drive
- */
-#ifdef ProjectRoot
-#undef ProjectRoot
-#endif
-/* This will be mangled with a drive letter in most OS/2 rules ... */
-#define ProjectRoot	/XFree86
-
-/* ... but not when a user tries to compile something from a different drive 
- * Please report any directories missed to Holger.Veit@gmd.de 
-*/
-#ifdef UseInstalled
-/*#define IncRoot $(X11ROOT)/XFree86/include*/
-#define ConfigDir $(X11ROOT)$(LIBDIR)/config
-#define LdPreLib -L$(X11ROOT)/XFree86/lib
-#endif
-
-/* more directories */
-#define AdmDir		        $(LIBDIR)/adm
-        DESTDIR = $(X11ROOT)
-
 /* for the man pages */
 #define BookFormatManPages	YES
-#define ManDirectoryRoot /XFree86/man/man
-#define ManSuffix	1
-#define LibManSuffix	3
-#define FileManSuffix	4
-#define XmanSearchPath	/XFree86/man/man
-#define ManSourcePath	$(MANPATH)
-#define DontUseLibPAthVar YES
+#define ManSuffix 1
+#define FileManSuffix 4
+#define DontUseLibPathVar YES
 
 /* you must have installed groff! */
 #define TblCmd		tbl
@@ -67,13 +36,11 @@
         NROFF = NroffCmd
 
 /* A set of standard defines: */
-#define OSDefines		-D__EMX__ -D__i386__ -Demxos2 -D_POSIX_SOURCE \
-				-D_BSD_SOURCE -D_GNU_SOURCE
+#define OSDefines		-D_POSIX_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE
 
 #ifndef BuildXKB
 #define BuildXKB		YES
 #endif
-#define BuildImplibs		YES
 #ifndef BuildLBX
 #define BuildLBX		YES
 #endif
@@ -82,6 +49,9 @@
 #endif
 #undef MakeDLLModules
 #define MakeDLLModules          NO
+#ifndef BuildModuleInSubdir
+#define BuildModuleInSubdir	YES
+#endif
 
 
 /* some more properties of the OS/2 implementation */
@@ -89,6 +59,14 @@
 #define HasPutenv       	YES
 #define HasSockets		YES
 #define HasSnprintf		YES
+#define HasWChar32		NO
+#define HasUsableFileMap	NO
+#define HasNCurses		NO
+#define HasVarRun		NO
+#define HasLibPthread		NO
+#define HasPosixThreads		NO
+#define HasVarDb		NO
+#define HasDlopen		NO
 #define HasBsearch		NO
 #define HasFchown		NO
 #define HasLargeTmp		NO
@@ -98,7 +76,7 @@
 #define	HasSymLinks		NO
 #define HasVFork		NO
 #define HasVarDirectory		NO
-#define HasStrcasecmp		NO
+#define HasStrcasecmp		YES
 #define StrcasecmpDefines	-DNEED_STRCASECMP -Dstrcasecmp=stricmp -Dstrncasecmp=strnicmp
 #define Malloc0ReturnsNull	YES
 #define SetTtyGroup     	NO
@@ -108,10 +86,14 @@
 #ifndef HasShm
 # define HasShm          	YES
 #endif
-#define ConnectionFlags		-DTCPCONN -DOS2PIPECONN
-#define StdIncDir $(C_INCLUDE_PATH)
+#define ConnectionFlags		-DTCPCONN 
+/*-DOS2PIPECONN excluded*/
+#define StdIncDir	/usr/include
 #define HasStickyDirBit		NO
 #define HasMkstemp		NO
+#define BuildThreadStubLibrary	NO
+
+
 
 /* XF86Setup stuff - does not work yet! */
 #define HasTcl			NO
@@ -127,7 +109,10 @@
 /*
  * Compiler Features
  */
+#define DefaultGcc2i386Opt	-O2 -fstrength-reduce
+#define UseGccMakeDepend	YES
 #define HasCplusplus		YES
+#define HasGnuMake		YES
 #define GccUsesGas		YES
 #define UseGas			YES
 #define GnuCpp			YES
@@ -138,7 +123,11 @@
 #define NeedVarargsPrototypes	YES
 #define NeedWidePrototypes	NO
 
+#define HasPlugin		NO
+#define VendorHasX11R6_3libExt	YES
+
 #define CppCmd	cpp
+#define YaccCmd	bison -y
 #define StandardCppOptions	-traditional
 #define StandardCppDefines	/**/
 #define PreProcessCmd	CppCmd
@@ -150,19 +139,19 @@
 
 #define ModuleCcCmd		gcc_elf
 #define ModuleCppCmd		cpp_elf
-#define ModuleCFlags $(CDEBUGFLAGS) $(THREADS_CFLAGS) $(ALLDEFINES)
+#define ModuleCFlags -D__UNIXOS2__ $(CDEBUGFLAGS) $(THREADS_CFLAGS) $(ALLDEFINES)
 #define ModuleAsCmd		as_elf
 #define ModuleLdCmd		ld_elf
 #define ModuleLdCombineFlags	-X -r
 #define ModuleArCmd		ar_elf cq 
 #define NeedModuleRanlib	YES
 #define ModuleRanlibCmd		ranlib_elf
+#define HasPerl5		YES
 
 #define CplusplusCmd	g++
 #define CplusplusOptions	-Zmtd -Zsysv-signals
 
-#define MakeCmd x11make 
-#define AsCmd	gcc -S
+#define AsCmd	as
 #define GccGasOption	-DGCCUSESGAS
 #define AsmDefines	-DUSE_GAS
 
@@ -170,40 +159,28 @@
 
 #define LdCmd	ld
 #define ExtraLoadFlags	-Zbin-files
-#define ExtraLibraries	-lsocket -lbsd
-#if HasShm
-# define ServerExtraSysLibs     -lregex -lshm
-#endif
+#define ExtraLibraries	-lshm -lemxfix -lsocket -lbsd
+#define ServerExtraSysLibs     -lregex -lshm -lemxfix -lsocket
 
 /* quite a number of programs you need, most of them the same as
  * with Unix, but listed here for completeness
  */
 #define ArCmd	ar cq
 #define RanlibCmd	ar s
-#define BourneShell	/**/
+#define BourneShell	/bin/sh
 #define LexCmd	flex -l
 #define HasFlex YES
 #define LexLib	-lfl
-#define YaccCmd	yacc
 #define LintCmd	/**/
 #define MvCmd	mv
 #define CompressCmd	compress
 #define GzipCmd	gzip
 #define LnCmd cp
 #define CpCmd cp
-#define RmCmd	ImakeHelper 4 
-
-#ifndef UseInstalled
-#define ImakeCmd \imake
-#define MkdirHierCmd \mkdirhier
-#define DependCmd \makedepend
-#else
-/* imake and mkdirhier come from Imake.tmpl, but DependCmd must be overriden */
-#define DependCmd makedepend
-#endif
+#define RmCmd	rm -f
 
 /* "shell scripts" in OS/2 have this extension */
-#define SHsuf cmd
+#define SHsuf sh
 
 #define InstPgmFlags /**/
 #define InstBinFlags /**/
@@ -223,51 +200,26 @@
  */
 
 #define AvoidNullMakeCommand 	YES
-_NULLCMD_ = @ rem
-#define NullMakeCommand	@ rem
+_NULLCMD_ = 
+#define NullMakeCommand
 #define StripInstalledPrograms	NO
 #define CompressAllFonts	YES
 #define CompressManPages	YES
 #define GzipFontCompression	YES
-#define DefaultUserPath		.;/os2;/emx/bin;/tcpip/bin;$(BINDIR)
-#define DefaultSystemPath	/os2;/emx/bin;$(BINDIR)
+#define DefaultUserPath		$(BINDIR)
+#define DefaultSystemPath	$(BINDIR)
 #define CaseSensitiveFileSystem	NO
 
 #ifndef ExtraFilesToClean
 # define ExtraFilesToClean 	*.~* *.exe *.dll *.obj *.lib *.map
 #endif
 
-#define ProgramTargetName(target)target.exe
+#define ProgramTargetName(target) Concat(target,.exe)
+#define HostProgramTargetName(target) ProgramTargetName(target)
 
-/* we don't name libraries lib*.a */
-#define LibraryTargetName(libname) libname.a
-#define LibraryTargetNameSuffix(libname,suffix)Concat(libname,suffix.a)
-
-/* ... and we even don't do it in rules that should have used the above
- * LibraryTargetName macro
- */
-#ifndef UnSharedLibReferences
-#define UnsharedLibReferences(varname,libname,libsource)		@@\
-Concat3(DEP,varname,LIB) = _UseCat($(USRLIBDIR)/,$(BUILDLIBDIR)/,libname.a)	@@\
-Concat(varname,LIB) = LoaderLibPrefix Concat(-l,libname)		@@\
-LintLibReferences(varname,libname,libsource)
-#endif
-
-#ifndef SharedLibReferences
-#define SharedLibReferences(varname,libname,libsource,revname,rev)	@@\
-Concat3(DEP,varname,LIB) = SharedLibDependencies(libname,libsource,revname) @@\
-Concat(varname,LIB) = LoaderLibPrefix Concat(-l,libname)		@@\
-LintLibReferences(varname,libname,libsource)
-#endif
-
-#define XFileSearchPathBase Concat4($(LIBDIR)/;L/;T/;N;C,;S:$(LIBDIR)/;l/;T/;N;C,;S:$(LIBDIR)/;T/;N;C,;S:$(LIBDIR)/;L/;T/;N;S:$(LIBDIR)/;l/;T/;N;S:$(LIBDIR)/;T/;N;S)
-
-
 #include <os2.rules>
 #include <os2Lib.rules>
 
 # include <xfree86.cf>
 
-#else
-#error You must edit os2.cf for your (non-EMX) OS/2 dev system
-#endif
+	
Index: xc/config/cf/os2.rules
diff -u xc/config/cf/os2.rules:3.22 xc/config/cf/os2.rules:3.23
--- xc/config/cf/os2.rules:3.22	Wed Jan 17 11:22:32 2001
+++ xc/config/cf/os2.rules	Fri May 31 12:31:19 2002
@@ -2,7 +2,7 @@
 
 
 
-XCOMM platform:  $XFree86: xc/config/cf/os2.rules,v 3.22 2001/01/17 16:22:32 dawes Exp $
+XCOMM platform:  $XFree86: xc/config/cf/os2.rules,v 3.23 2002/05/31 16:31:19 dawes Exp $
 
 .SUFFIXES: .Osuf .c .CCsuf
 
@@ -15,563 +15,98 @@
 #endif
 
 #ifndef UseInstalled
-#define ImakeHelper \imakesvc
-#define IMmode n
-#define ImakeIndir \indir
-#define ImakeSubCmdHelper \imake -I$(IRULESRC) $(IMAKE_DEFINES)
-#define Fontc \bdftopcf
-#define MkFontDir \mkfontdir
-#define XkbComp \xkbcomp
-#define PsWrap \pswrap
+#define XkbComp /xkbcomp
 #else
-#define ImakeHelper imakesvc
-#define IMmode u
-#define ImakeIndir indir
-#define ImakeSubCmdHelper $(IMAKE_CMD)
-#define Fontc bdftopcf
-#define MkFontDir mkfontdir
 #define XkbComp xkbcomp
-#define PsWrap pswrap
 #endif
 
-#define echo ImakeHelper 8 
-#define RunProgram(progvar,options) $(subst /,\,$(progvar)) options
-#define RemoveFile(file) $(RM) file
-#define RemoveFiles(files) $(RM) files
-#define NeedLdLibraryPathForXkbComp NO
-
-#define LibObjCompile(dir,options) RemoveFiles($@ dir\$@)		@@\
-	$(CC) $(CCOPTIONS) $(ALLDEFINES) options -c  $*.c		@@\
-	$(MV) $@ dir\$@
-
-#define MakeDir(dir) $(MKDIRHIER) dir
-
-#define BuildIncludesTop(srclist)					@@\
-includes:: srclist							@@\
-	MakeDir($(BUILDINCDIR))						@@\
-	@for %i in (srclist) do ImakeHelper 2 $(BUILDINCDIR) $(BUILDINCTOP) $(CURRENT_DIR) %i
-
-#define	ProgramTargetHelper(program,srcs,objs,deplib,locallib,syslib)	@@\
-ProgramTargetName(program): $(objs) 					@@\
-	RemoveTargetProgram($@)						@@\
-	LinkRule($@,$(LDOPTIONS),$(objs),locallib $(LDLIBS) syslib)	@@\
-									@@\
-InstallProgram(program,$(BINDIR))					@@\
-InstallManPage(program,$(MANDIR))
-
-#if 0
-#define	ProgramTargetHelperNoMan(program,srcs,objs,deplib,locallib,syslib)	@@\
-ProgramTargetName(program): $(objs) 					@@\
-	RemoveTargetProgram($@)						@@\
-	LinkRule($@,$(LDOPTIONS),$(objs),locallib $(LDLIBS) syslib)	@@\
-									@@\
-InstallProgram(program,$(BINDIR))
-#endif
-
-
-#define BuildIncludes(srclist,dstsubdir,dstupdir)			@@\
-includes:: srclist							@@\
-	MakeDir($(BUILDINCDIR)/dstsubdir)				@@\
-	@for %i in (srclist) do ImakeHelper 3 $(BUILDINCTOP)/dstupdir/$(CURRENT_DIR) $(BUILDINCDIR)/dstsubdir %i
-
-#define LinkFileList(step,list,dir,sub)					@@\
-step::  list								@@\
-	@for %i in (list) do ImakeHelper 3 sub dir %i
-
-#define ComplexProgramTarget(program)					@@\
-PROGRAM = ProgramTargetName(program)					@@\
-									@@\
-AllTarget(ProgramTargetName(program))					@@\
-									@@\
-ProgramTargetHelper(program,SRCS,OBJS,DEPLIBS,$(LOCAL_LIBRARIES),NullParameter) @@\
-									@@\
-DependTarget()								@@\
-LintTarget()								@@\
-									@@\
-clean::									@@\
-	RemoveFile($(PROGRAM))
-
-#define ComplexProgramTarget_1(program,locallib,syslib)			@@\
-OBJS = $(OBJS1) $(OBJS2) $(OBJS3)					@@\
-SRCS = $(SRCS1) $(SRCS2) $(SRCS3)					@@\
-PROGRAM1 = ProgramTargetName(program)					@@\
-									@@\
-AllTarget($(PROGRAM1) $(PROGRAM2) $(PROGRAM3))				@@\
-									@@\
-ProgramTargetHelper(program,SRCS1,OBJS1,DEPLIBS1,locallib,syslib)	@@\
-									@@\
-DependTarget()								@@\
-LintTarget()								@@\
-									@@\
-clean::									@@\
-	RemoveFiles($(PROGRAMS))
-
-#define ComplexProgramTarget_2(program,locallib,syslib)			@@\
-PROGRAM2 = ProgramTargetName(program)					@@\
-									@@\
-ProgramTargetHelper(program,SRCS2,OBJS2,DEPLIBS2,locallib,syslib)
-
-#define ComplexProgramTarget_3(program,locallib,syslib)			@@\
-PROGRAM3 = ProgramTargetName(program)					@@\
-									@@\
-ProgramTargetHelper(program,SRCS3,OBJS3,DEPLIBS3,locallib,syslib)
-
-#define NormalProgramTarget(program,objects,deplibs,locallibs,syslibs)	@@\
-ProgramTargetName(program): objects 					@@\
-	RemoveTargetProgram($@)						@@\
-	LinkRule($@,$(LDOPTIONS),objects,locallibs $(LDLIBS) syslibs)	@@\
-									@@\
-clean::									@@\
-	RemoveFile(ProgramTargetName(program))
-
-#if 0
-#define ComplexProgramTargetNoMan(program)				@@\
-PROGRAM = ProgramTargetName(program)					@@\
-									@@\
-AllTarget(ProgramTargetName(program))					@@\
-									@@\
-ProgramTargetHelperNoMan(program,SRCS,OBJS,DEPLIBS,$(LOCAL_LIBRARIES),NullParameter) @@\
-									@@\
-DependTarget()								@@\
-LintTarget()								@@\
-									@@\
-clean::									@@\
-	RemoveFile($(PROGRAM))
+/*
+ * same problem as with cygwin...
+ * DependDependencyStatement - Imake.rules wraps $(DEPEND) in
+ * ProgramTargetName(), which causes cross compiling to think that
+ * $(DEPEND) hasn't been built, as $(DEPEND) is a host tool, and should
+ * not be wrapped with ProgramTargetName().  Perhaps there should be
+ * a HostProgramTargetName()...
+ */
+#ifndef DependDependencyStatement
+#define DependDependencyStatement()                                     @@\
+depend:: $(DEPEND)
 #endif
-
-#define MoveToBakFile(file) ImakeHelper 5 file
-
-#define RMoveToBakFile(file) ImakeHelper 6 file
-
-#define InstallMultipleDestFlags(step,list,dest,flags)			@@\
-step:: list								@@\
-	MakeDir($(DESTDIR)dest)							@@\
-	$(INSTALL) $(INSTALLFLAGS) flags list $(subst /,\,$(DESTDIR)dest)
+	DEPEND2 = $(SHELL) $(DEPEND)
 
-#define	CleanTarget()							@@\
-clean::									@@\
-	RemoveFiles(FilesToClean ExtraFilesToClean)
-
-#define LinkSourceFile(src,dir)						@@\
-src:									@@\
-	ImakeHelper 3 dir . src						@@\
-									@@\
-includes:: src								@@\
-									@@\
-depends:: src								@@\
-									@@\
-clean::									@@\
-	RemoveFile(src)
+/*
+ * DependDependency - Imake.rules wraps $(DEPEND) in ProgramTargetName().
+ * This doesn't work when cross compiling, see the locally defined
+ * DependDependencyStatement comment (above) for more information.
+ */
 
-#define LinkFile(tofile,fromfile)					@@\
-tofile:: fromfile							@@\
-	ImakeHelper 7 fromfile tofile					@@\
-									@@\
-includes:: tofile							@@\
+#ifndef DependDependency
+#ifdef UseInstalled
+#define DependDependency() /**/
+#else
+#define DependDependency() 						@@\
+DependDependencyStatement()						@@\
 									@@\
-depend:: tofile								@@\
+NoCmpScript($(DEPEND))							@@\
 									@@\
-clean::									@@\
-	RemoveFile(tofile)
+$(DEPEND):								@@\
+	@echo "checking $@ over in $(DEPENDSRC) first..."; \		@@\
+	cd $(DEPENDSRC) && $(MAKE); \					@@\
+	echo "okay, continuing in $(CURRENT_DIR)"
 
-#ifndef UseInstalled
-#define ImakeDependency(target)						@@\
-target:: ProgramTargetName($(IMAKE))					@@\
-									@@\
-ProgramTargetName($(IMAKE)):						@@\
-	@ImakeIndir $(IMAKESRC) if exist Makefile $(MAKE) SHELL= MAKE=x11make all		@@\
-	@ImakeIndir $(IMAKESRC) if not exist Makefile $(MAKE) SHELL= MAKE=x11make -f Makefile.ini BOOTSTRAPCFLAGS="$(BOOTSTRAPCFLAGS)"
-#endif
+#endif /* UseInstalled */
+#endif /* DependDependency */
 
-#ifndef UseInstalled
-#define DependDependency() 						@@\
-depend:: ProgramTargetName($(DEPEND))					@@\
-									@@\
-ProgramTargetName($(DEPEND)):						@@\
-	@ImakeIndir $(DEPENDSRC) $(MAKE) SHELL= MAKE=x11make 
+/*
+ * HostLinkRule - link a utility to be used on the build host
+ * (differs from LinkRule if cross compiling)
+ */
+#ifndef HostLinkRule
+#define HostLinkRule(program,options,objects,libraries) \
+$(CCLINK) -Zmtd -o program options objects libraries $(EXTRA_LOAD_FLAGS)
 #endif
 
-#if 0
+#ifndef DependTarget
 #define	DependTarget()							@@\
 DependDependency()							@@\
 									@@\
 depend::								@@\
-	$(subst /,\,$(DEPEND)) $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- $(SRCS)
+	$(SHELL) $(DEPEND) $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- $(SRCS)
+#endif /* DependTarget */
 
+/*
+ * DependTarget3 - generate rules to compute dependencies for all files given.
+ */
+#ifndef DependTarget3
 #define	DependTarget3(srcs1,srcs2,srcs3)				@@\
 DependDependency()							@@\
-
-/* Currently this stuff doesn't work correctly for libX11
-depend::								@@\
-	$(subst /,\,$(DEPEND)) $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- srcs1 @@\
-	$(subst /,\,$(DEPEND)) $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- srcs2 @@\
-	$(subst /,\,$(DEPEND)) $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- srcs3
-*/
-#endif
-
-#define DependTarget()							@@\
-depend::
-
-#define DependTarget3(src1,src2,src3)					@@\
-depend::
-
-#define ForceSubdirs(dirs)						@@\
-dirs: DONE								@@\
-									@@\
-DONE:									@@\
-	@for %i in (dirs) do ImakeIndir %i $(MAKE) SHELL= MAKE=x11make $(MFLAGS) PassCDebugFlags all @@\
-	touch DONE							@@\
-									@@\
-clean::									@@\
-	RemoveFile(DONE)
-
-#define MakeMakeSubdirs(dirs,target)					@@\
-MMSDIRS = dirs								@@\
-MMSTOP = $(TOP)								@@\
-MMSRULES = $(IRULESRC)							@@\
-MMSCUR = $(CURRENT_DIR)							@@\
-target::								@@\
-	@for %i in ($(subst /,\,$(MMSDIRS))) do ImakeHelper 1 IMmode %i $(MMSRULES) $(MMSTOP) $(MMSCUR)
-
-#define NamedTargetSubdirs(name,dirs,verb,flags,subname)		@@\
-Concat(SUBST,name) = dirs						@@\
-name::									@@\
-	@for %i in ($(subst /,\,$(Concat(SUBST,name)))) do ImakeIndir %i $(MAKE) SHELL= MAKE=x11make $(MFLAGS) flags subname
-
-#define InstallNamedTarget(step,srcname,flags,dest,dstname)		@@\
-step:: srcname								@@\
-	MakeDir($(DESTDIR)dest)						@@\
-	$(INSTALL) $(INSTALLFLAGS) flags srcname $(subst \,/,$(DESTDIR)dest)/dstname
-
-#define	BuildMakefileTarget(notused,imakeflags)				@@\
-ImakeDependency(Makefile)						@@\
-									@@\
-Makefile:: 								@@\
-	RMoveToBakFile(Makefile)					@@\
-	ImakeSubCmdHelper -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT_DIR) imakeflags
-
-#define AssembleObject(flags) RemoveFile($@)                            @@\
-	$(CPP) AsmDefines $(DEFINES) $(INCLUDES) flags $*.S | grep -v '^\#' > _tmp_.s @@\
-	$(CC) $(CFLAGS) -o $*.Osuf -c _tmp_.s                           @@\
-	RemoveFile(_tmp_.s)
-
-#define NormalAsmObjectRule()                                           @@\
-.S.Osuf:                                                                @@\
-	AssembleObject($(_NOOP_))
-
-#define ObjectMapIncludeFromSpecialSource(dst,src,flags)		@@\
-dst.c: src.c								@@\
-	ImakeHelper 9 $@ mfbmap.h $?					@@\
 									@@\
-SpecialCObjectRule(dst,NullParameter,flags)				@@\
-									@@\
-depend:: dst.c								@@\
-									@@\
-clean::									@@\
-	RemoveFile(dst.c)
-
-#define FontBaseObj(basename)basename.pcf
-/*
- * UncompressedFontTarget
- */
-#define UncompressedFontTarget(basename)				@@\
-FontBaseObj(basename):  FontSrc(basename)				@@\
-	Fontc $(FONTCFLAGS) $? -o $@
+depend::								@@\
+	$(SHELL) $(DEPEND) $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- srcs1	@@\
+	$(SHELL) $(DEPEND) -a $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- srcs2	@@\
+	$(SHELL) $(DEPEND) -a $(DEPENDFLAGS) -- $(ALLDEFINES) $(DEPEND_DEFINES) -- srcs3
+#endif /* DependTarget3 */
 
-/*
- * CompressedFontTarget
- */
-#ifndef CompressedFontTarget
-#if GzipFontCompression
-#define CompressedFontTarget(basename)					@@\
-FontBaseObj(basename).gz:  FontSrc(basename)				@@\
-	Fontc $(FONTCFLAGS) $? | $(GZIPCMD) > $@
+#ifdef UseInstalled
+#define RmanDependency() /**/
 #else
-#define CompressedFontTarget(basename)					@@\
-FontBaseObj(basename).Z:  FontSrc(basename)				@@\
-	Fontc $(FONTCFLAGS) $? | $(COMPRESS) > $@
-#endif
-#endif
-
-/*
- * MakeFontsDir - generate rules to build fonts.dir database.
- */
-#define MakeFontsDir(deplist)						@@\
-all:: fonts.dir								@@\
-									@@\
-fonts.dir:  deplist							@@\
-	MkFontDir .							@@\
-									@@\
-clean::									@@\
-	RemoveFile(fonts.dir)
-
-/* OS/2 scripts are based on REXX
- * it is just the SHELL variable that is messed up that forces me to
- * modify this rule
- */
-#define ConfigTargetLong(target,dep,script,args,extra)			@@\
-all:: Configure								@@\
-									@@\
-Configure:: target.o							@@\
-									@@\
-target.c: script dep							@@\
-	$(MAKE) SHELL= MAKE=x11make $(MFLAGS) extra Concat(Build,target)			@@\
-									@@\
-Concat(Build,target):							@@\
-	RemoveFile(target.c)						@@\
-	script args							@@\
-									@@\
-clean::									@@\
-	RemoveFile(target.c)
-
-#ifndef ServerTargetWithFlags
-#define	ServerTargetWithFlags(server,subdirs,objects,libs,syslibs,flags) @@\
-AllTarget(ProgramTargetName(server))					@@\
-ProgramTargetName(server): subdirs objects libs				@@\
-	MoveToBakFile($@)						@@\
-	LinkRule($@,$(LDOPTIONS),objects,libs $(LDLIBS) syslibs)	@@\
-	emxbind -a ProgramTargetName(server) -h255			@@\
-									@@\
-Concat(load,server):							@@\
-	MoveToBakFile(ProgramTargetName(server))			@@\
-	LinkRule(ProgramTargetName(server),$(LDOPTIONS),objects,libs $(LDLIBS) syslibs) @@\
-									@@\
-loadX:: Concat(load,server)						@@\
-									@@\
-SentinelProgramTarget(server,subdirs objects libs,objects libs $(LDLIBS) syslibs) @@\
-SentinelLinkTarget(Concat(load,server),server,objects libs $(LDLIBS) syslibs) @@\
-PurifyProgramTarget(server,subdirs objects libs,objects libs $(LDLIBS) syslibs) @@\
-PurifyLinkTarget(Concat(load,server),server,objects libs $(LDLIBS) syslibs) @@\
-ProofProgramTarget(server,subdirs objects libs,objects libs $(LDLIBS) syslibs) @@\
-ProofLinkTarget(Concat(load,server),server,objects libs $(LDLIBS) syslibs) @@\
-									@@\
-InstallProgramWithFlags(server,$(BINDIR),flags)				@@\
+#define RmanDependency() 						@@\
+NoCmpScript(ProgramTargetName($(RMAN)))					@@\
 									@@\
-clean::									@@\
-	RemoveFile(ProgramTargetName(server))
-#endif /* ServerTargetWithFlags */
-
-/*
- * ServerTarget - rules to compile, link, and relink a normal server
- * Need a .def file for OS/2
- */
-#ifndef ServerTarget
-#define	ServerTarget(server,subdirs,objects,libs,syslibs)		@@\
-ServerTargetWithFlags(server,subdirs,objects,libs,syslibs server.def,$(_NOOP_)) @@\
-									@@\
-ProgramTargetName(server): server.def
-#endif /* ServerTarget */
-
-/*
- * ToolkitMakeStrings generates a string-table, i.e., a C source
- * file and the matching header(s), e.g., Xt's StringDefs.c, StringDefs.h,
- * and Shell.h files; or Motif's XmStrDefs.c and XmStrDefs.h files.
- *
- * The 'files' argument is the list of files that will be produced by
- * this rule, e.g., for Xt they would be "Shell.h StringDefs.c StringDefs.h"
- * and for Motif they would be "XmStrDefs.c XmStrDefs.h".
- *
- * The 'source' argument is the string-list file to be parsed, e.g., in
- * Xt that would be "util/string.list".  For Motif 2.0 it would be
- * "../../tools/makestr/xmstring.list", and for Motif-CDE1 it would be
- * "util/xmstring.list".
- *
- * The 'options' argument is passed by the library's Imakefile, see the
- * Xt Imakefile for an example.  Typically this would be nothing, -intelabi,
- * or -sparcabi; there are other choices, but these are typical.
- *
- * The 'depends' argument names additional files the target files
- * depend on.  It should name the #ctmpl and #htmpl files from the
- * 'source' file.
- *
- * The 'dest' argument is the C source output file.  For Xt this should
- * be "StringDefs.c", and for all versions of Motif it would be "XmStrDefs.c"
- *
- * Headers are generated and named according to data in the 'source'
- * file.
- */
-
-#ifndef ToolkitMakeStrings
-#define ToolkitMakeStrings(files,source,options,depends,dest)		@@\
-MAKESTRS = $(CONFIGSRC)/util/makestrs					@@\
-MAKESTRS1 = /makestrs.exe						@@\
-									@@\
-ProgramTargetName($(MAKESTRS)): $(MAKESTRS).c				@@\
-	ImakeIndir $(CONFIGSRC)/util make SHELL= ProgramTargetName(makestrs)	@@\
-	ImakeHelper 7 $(CONFIGSRC)/util/makestrs.exe /			@@\
-									@@\
-files: ProgramTargetName($(MAKESTRS)) source depends			@@\
-	RemoveFiles(files)						@@\
-	RunProgram(MAKESTRS1,options < source > dest)			@@\
-									@@\
-AllTarget(files)							@@\
-									@@\
-includes:: files							@@\
-									@@\
-depend:: files								@@\
-									@@\
-clean::									@@\
-	RemoveFiles(files)
-
-#endif /* ToolkitMakeStrings */
-
-/*#define CppSedMagic SedMagic*/
-#define CppSedMagic sed -e '/^#  *[0-9][0-9]*  *.*$$/d' -e 's/^XCOMM/#/g' -e 's/^XCOMM[^a-zA-Z0-9_]/#/g'
-
-#ifndef InstallNamedTargetNoClobber
-#define InstallNamedTargetNoClobber(step,srcname,flags,dest,dstname)	@@\
-step:: srcname								@@\
-	MakeDir($(DESTDIR)dest)						@@\
-	if not exist $(subst /,\,$(DESTDIR)dest)\dstname $(INSTALL) $(INSTALLFLAGS) flags srcname $(DESTDIR)dest/dstname
-
-#endif /* InstallNamedTargetNoClobber */
+ProgramTargetName($(RMAN)):						@@\
+	@echo "checking $@ over in $(TOP)/config/util first..."; \	@@\
+	echo "okay, continuing in $(CURRENT_DIR)"
 
-#if CompressManPages
+#endif /* UseInstalled */
 
-#ifndef InstallManPageLong
-#define InstallManPageLong(file,destdir,dest)                           @@\
-install.man:: file.man                                                  @@\
-	MakeDir($(DESTDIR)destdir)					@@\
-	ImakeHelper 12 file $(DESTDIR)destdir dest
-#endif
-
-#ifndef InstallManPageAliases
-#define InstallManPageAliases(file,destdir,aliases)                     @@\
-install.man::                                                           @@\
-	MakeDir($(DESTDIR)destdir)					@@\
-	for %i in (aliases) do $(INSTALL) $(DESTDIR)destdir/file.gz $(DESTDIR)destdir/%i.gz
-#endif
-
-#ifndef InstallGenManPageLong
-#define InstallGenManPageLong(file,destdir,dest,suffix)                 @@\
-install.man:: file.man                                                  @@\
-	MakeDir($(DESTDIR)destdir)					@@\
-	ImakeHelper 12 file $(DESTDIR)destdir dest
-#endif
-
-#ifndef InstallMultipleMan
-#define InstallMultipleMan(list,dest)                                   @@\
-install.man:: list                                                      @@\
-	MakeDir($(DESTDIR)dest)						@@\
-	ImakeHelper 14 $(DESTDIR)dest list
-#endif
-
-#else /* CompressManPages */
-
-#ifndef InstallManPageLong
-#define InstallManPageLong(file,destdir,dest)                           @@\
-install.man:: file.man                                                  @@\
-	MakeDir($(DESTDIR)destdir)					@@\
-	ImakeHelper 10 file $(DESTDIR)destdir dest $(MANSUFFIX)
-#endif
-
-#ifndef InstallManPageAliases
-#define InstallManPageAliases(file,destdir,aliases)                     @@\
-install.man::                                                           @@\
-	MakeDir($(DESTDIR)destdir)					@@\
-	for %i in (aliases) do $(INSTALL) $(DESTDIR)destdir/file.$(MANSUFFIX) $(DESTDIR)destdir/%i.$(MANSUFFIX) 
-#endif
-
-#ifndef InstallGenManPageLong
-#define InstallGenManPageLong(file,destdir,dest,suffix)                 @@\
-install.man:: file.man                                                  @@\
-	MakeDir($(DESTDIR)destdir)					@@\
-	ImakeHelper 10 file $(DESTDIR)destdir dest suffix
-#endif
-
-#ifndef InstallMultipleMan
-#define InstallMultipleMan(list,dest)                                   @@\
-install.man:: list                                                      @@\
-	MakeDir($(DESTDIR)dest)						@@\
-	ImakeHelper 15 $(DESTDIR)dest $(MANSUFFIX) list
-#endif
-
-#endif
-
-#ifndef NormalLintTarget
-#define NormalLintTarget(srclist)
-#endif /* NormalLintTarget */
-
-#ifndef MakeDirectories
-#define MakeDirectories(step,dirs)					@@\
-step::									@@\
-	-for %i in (dirs) do $(MKDIRHIER) $(DESTDIR)%i
-#endif /* MakeDirectories */
-
-#ifndef YaccFile
-#define YaccFile(file,flags)						@@\
-depend:: file.c								@@\
-									@@\
-file.h file.c: file.y							@@\
-	$(YACC) flags file.y						@@\
-	$(MV) y.tab.c file.c						@@\
-	@if exist y.tab.h $(MV) y.tab.h file.h				@@\
-									@@\
-clean::									@@\
-	RemoveFiles(y.tab.c y.tab.h file.h file.c)
-#endif /* YaccFile */
-
-#ifndef StaticLibrary
-#define StaticLibrary(libpath,libname) Concat4(libpath,/,libname,_s.a)
-#endif
-
-#ifndef MakeXkbDir
 #define MakeXkbDir(basedir,subdir)					@@\
-all::	Concat(subdir,.dir)						@@\
+all::   Concat(subdir,.dir)						@@\
 									@@\
 Concat(subdir,.dir):							@@\
+	RemoveFile(Concat(subdir,.dir))					@@\
 	XkbComp -lfhlpR -o Concat(subdir,.dir) *			@@\
 									@@\
-InstallTarget(install,Concat(subdir,.dir),$(INSTDATFLAGS),basedir)
-#endif
-
-/* This is to replace an ugly hack in /xc/nls/XLC_LOCALE */
-/* the corresponding Imake.rules rule would be:
-   define LinkFileSpecial(gotodir,tofile,fromfile)	@@\
-        @MakeFlagsToShellFlags(i,set +e); \		@@\
-	cd dir && (set -x; RemoveFile(tofile); $(LN) fromfile tofile)
- */
-#ifndef LinkFileSpecial
-#define LinkFileSpecial(gotodir,tofile,fromfile)			@@\
-	ImakeHelper 13 gotodir fromfile tofile
-#endif
-
-#ifndef LinkBuildBinary
-#define LinkBuildBinary(binary)						@@\
-all:: $(BUILDBINDIR)/binary binary					@@\
+InstallTarget(install,Concat(subdir,.dir),$(INSTDATFLAGS),basedir)	@@\
 									@@\
-$(BUILDBINDIR)/binary: binary						@@\
-	ImakeHelper 13 $(BUILDBINDIR) $(BUILDBINTOP)/$(CURRENT_DIR)/binary binary @@\
-	$(CP) binary /
-#endif /* LinkBuildBinary */
-
-/* And this replaces a similarlry ugly hack in InstallDynamicModule */
-
-#ifndef LinkBuildModule
-#ifdef UseInstalled
-#define LinkBuildModule(module,subdir) $(_NULLCMD_)
-#else
-#define LinkBuildModule(module,subdir) 					@@\
-	MakeDir($(BUILDMODULEDIR)/subdir) 			 	@@\
-	RemoveFile($(BUILDMODULEDIR)/subdir/module)                            @@\
-	ImakeHelper 13 $(BUILDMODULEDIR)/subdir $(BUILDMODULETOP)/$(CURRENT_DIR)/module module
-#endif
-#endif /* LinkBuildModule */
-
-#ifndef LinkBuildNamedModule
-#define LinkBuildNamedModule(module,name) MakeDir($(BUILDMODULEDIR))    @@\
-	RemoveFile($(BUILDMODULEDIR)/module)                            @@\
-	ImakeHelper 13 $(BUILDMODULEDIR) $(BUILDMODULETOP)/$(CURRENT_DIR)/module name
-#endif /* LinkBuildNamedModule */
-
-#ifndef MakeEncDir
-#define MakeEncDir(deplist,inst,dirlist )				@@\
-AllTarget(encodings.dir)						@@\
-									@@\
-encodings.dir: deplist							@@\
-	RemoveFiles(encodings.dir fonts.dir)				@@\
-	ImakeHelper 16 MkFontDir dirlist				@@\
-									@@\
 clean::									@@\
-	RemoveFiles(fonts.dir encodings.dir)
-#endif
+	RemoveFile(Concat(subdir,.dir))
Index: xc/config/cf/os2Lib.rules
diff -u xc/config/cf/os2Lib.rules:3.12 xc/config/cf/os2Lib.rules:3.14
--- xc/config/cf/os2Lib.rules:3.12	Wed Jan 17 11:22:32 2001
+++ xc/config/cf/os2Lib.rules	Tue Jan 28 15:52:26 2003
@@ -2,186 +2,113 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/os2Lib.rules,v 3.12 2001/01/17 16:22:32 dawes Exp $
+XCOMM $XFree86: xc/config/cf/os2Lib.rules,v 3.14 2003/01/28 20:52:26 tsi Exp $
 
 /*
  * OS2/EMX shared library rules (DLL version)
  */
-#ifndef __EMX__
-#error You must edit os2Lib.rules for your (non-EMX) OS/2 dev system
+#ifndef __UNIXOS2__
+#error You must edit os2Lib.rules for your OS/2 dev system
 #endif
 
-#ifndef HasSharedLibraries
 #define HasSharedLibraries YES
-#endif
-#ifndef ForceNormalLib
 #define ForceNormalLib NO
-#endif
-
 #define SharedOldX NO
-
-#ifndef SharedDataSeparation
 #define SharedDataSeparation NO
-#endif
-#ifndef SharedCodeDef
 #define SharedCodeDef /**/
-#endif
-#ifndef SharedLibraryDef
 #define SharedLibraryDef /**/
-#endif
-#ifndef ShLibIncludeFile
 #define ShLibIncludeFile <os2Lib.tmpl>
-#endif
-#ifndef SharedLibraryLoadFlags
 #define SharedLibraryLoadFlags /**/
-#endif
-#ifndef PositionIndependentCFlags
-#define PositionIndependentCFlags -Zdll -Zomf -Zmtd
-#endif
+#define PositionIndependentCFlags -Zmtd
 
-#ifndef NormalSharedLibObjCompile
 #define NormalSharedLibObjCompile(options) RemoveFile($@)                       @@\
-	$(CC) -c $(CFLAGS) options $(SHLIBDEF) $(SHAREDCODEDEF) $(PICFLAGS) $*.c @@\
-	touch $*.o
-#endif
+	$(CC) -c $(CFLAGS) options $(SHLIBDEF) $(SHAREDCODEDEF) $(PICFLAGS) $*.c
 
-#ifndef InstallSharedLibrary
-#ifdef BuildImplibs
 #define InstallSharedLibrary(libname,rev,dest)				@@\
-install:: libname.dll libname.a	libname.lib				@@\
+install:: libname.dll LibraryTargetName(libname) libname.lib		@@\
 	MakeDir($(DESTDIR)dest)						@@\
 	$(INSTALL) -c $(INSTLIBFLAGS) libname.dll $(DESTDIR)dest 	@@\
-	$(INSTALL) -c $(INSTLIBFLAGS) libname.a $(DESTDIR)dest 		@@\
+	$(INSTALL) -c $(INSTLIBFLAGS) LibraryTargetName(libname) $(DESTDIR)dest 		@@\
 	$(INSTALL) -c $(INSTLIBFLAGS) libname.lib $(DESTDIR)dest
-#else
-#define InstallSharedLibrary(libname,rev,dest)				@@\
-install:: libname.dll libname.a						@@\
-	MakeDir($(DESTDIR)dest)						@@\
-	$(INSTALL) -c $(INSTLIBFLAGS) libname.a $(DESTDIR)dest		@@\
-	$(INSTALL) -c $(INSTLIBFLAGS) libname.dll $(DESTDIR)dest
-#endif
-#endif /* InstallSharedLibrary */
 
-/*#ifdef UseInstalled
-#define LinkBuildLibrary(lib) $(_NULLCMD_)
-#else*/
-#define LinkBuildLibrary(lib) MakeDir($(BUILDLIBDIR))			@@\
-	RemoveFile($(BUILDLIBDIR)/lib)					@@\
-	ImakeIndir $(BUILDLIBDIR) $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/lib .
-/*#endif*/
+#define LinkBuildLibrary2(slib,ext) MakeDir($(BUILDLIBDIR))		@@\
+	RemoveFile($(BUILDLIBDIR)/slib.ext)				@@\
+	(cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/slib.ext .)
+
+#define LinkBuildLibrary3(slib,rev,ext) MakeDir($(BUILDLIBDIR))	@@\
+	RemoveFile($(BUILDLIBDIR)/Concat3(slib,rev,ext))		@@\
+	(cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/Concat3(slib,rev,ext) .)
+
+#define LinkBuildLibrary4(pre,slib,rev,ext) MakeDir($(BUILDLIBDIR))	@@\
+	RemoveFile($(BUILDLIBDIR)/Concat4(pre,slib,rev,ext))		@@\
+	(cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/Concat4(pre,slib,rev,ext) .)
 
         EMXIMP = emximp
-        EMXOMF = emxomf
-          SHLD = gcc -Zomf -Zdll -Zmtd
-     SHADDLIBS = -lbsd -lsocket -lc_import
-#ifndef BuildDllSupportLibs
-/*#ifdef UseInstalled
-#define BuildDllSupportLibs(slib) $(_NULLCMD_)
-#else*/
-#define BuildDllSupportLibs(slib)					@@\
-	$(EMXIMP) -o slib.imp slib.def					@@\
-	$(EMXIMP) -o slib.a slib.imp					@@\
-	$(EMXOMF) -s -l slib.a 						@@\
-	LinkBuildLibrary(slib.a)					@@\
-	LinkBuildLibrary(slib.lib)
-/*#endif*/
-#endif
+        EMXOMF = emxomf -p 32
+          SHLD = gcc -Zdll -Zmtd -Zmap -Zbin-files
+     SHADDLIBS = ExtraLibraries -lc_import
+
+#define BuildDllSupportLibs3(slib,rev)					@@\
+	$(EMXIMP) -o Concat3(slib,rev,.imp) Concat3(slib,os2,.def)	@@\
+	$(EMXIMP) -o Concat4(lib,slib,rev,.a) Concat3(slib,rev,.imp)	@@\
+	$(EMXIMP) -o Concat3(slib,rev,_o.imp) Concat3(slib,o_os2,.def) @@\
+	$(EMXIMP) -o Concat3(slib,rev,.a) Concat3(slib,rev,_o.imp)	@@\
+	LinkBuildLibrary4(lib,slib,rev,.a)				@@\
 
-#ifndef BuildDllSupportLibs2
-/*#ifdef UseInstalled
-#define BuildDllSupportLibs2(slib) $(_NULLCMD_)
-#else*/
-#define BuildDllSupportLibs2(slib)					@@\
-	$(EMXIMP) -o slib.imp Concat3(slib,os2,.def)			@@\
-	$(EMXIMP) -o slib.a slib.imp					@@\
-	$(EMXOMF) -s -l slib.a 						@@\
-	LinkBuildLibrary(slib.a)					@@\
-	LinkBuildLibrary(slib.lib)
-/*#endif*/
-#endif
-
-#ifndef BuildLibSupportLibs
-/*#ifdef UseInstalled
-#define BuildLibSupportLibs(slib) $(_NULLCMD_)
-#else*/
 #define BuildLibSupportLibs(slib)					@@\
-	$(EMXOMF) -s -l slib.a 						@@\
-	LinkBuildLibrary(slib.a)					@@\
-	LinkBuildLibrary(slib.lib)
-/*#endif*/
-#endif
+	$(EMXOMF) -s -l -o Concat(slib,.lib) Concat(slib,.a) 		@@\
+	LinkBuildLibrary3(lib,slib,.a)					@@\
+
+#define BuildLibSupportLibs2(slib)					@@\
+	$(EMXOMF) -s -l -o Concat(slib,.lib) Concat3(lib,slib,.a) 		@@\
+	LinkBuildLibrary3(lib,slib,.a)					@@\
 
-#ifndef SharedLibraryTarget
 #define SharedLibraryTarget(libname,rev,solist,down,up)			@@\
 AllTarget(Concat3(libname,rev,.dll))					@@\
-.SUFFIXES: .obj .rsp .def						@@\
-        LBRPATH = $(subst /,\,$(LIBRARY_PATH))				@@\
-        LBRDEF = Concat4(libname,rev,os2,.def)				@@\
-	LBRCPPDEF = Concat4(libname,rev,os2,-def.cpp)			@@\
-	LBRRSP = Concat4(libname,rev,os2,.rsp)				@@\
-									@@\
-link.rsp: $(LBRRSP) $(LBRDEF)						@@\
-	@echo $(LBRPATH)\\dll0.obj+ >link.rsp				@@\
-	@cat $(LBRRSP) >>link.rsp					@@\
-	@echo $(LBRPATH)\\mt\\ $(LBRPATH)\\ $(REQUIREDLIBS) bsd socket c_alias c_static c_import os2 emx2 end >>link.rsp	@@\
-	@echo $(LBRDEF) >>link.rsp					@@\
-									@@\
-Concat3(libname,rev,.dll):  $(OBJS) link.rsp				@@\
-	link386 @link.rsp >nul						@@\
-	BuildDllSupportLibs2(Concat(libname,rev))			@@\
-	LinkBuildLibrary(Concat3(libname,rev,.dll))			@@\
+.SUFFIXES: .def								@@\
 									@@\
+Concat(libname,os2.def): Concat(libname,-def.cpp)			@@\
+	cmd /c $(subst /,\\,$(CONFIGSRC)/util/makedef.cmd) $(CONFIGSRC)/cf/os2def.db libname @@\
+	cmd /c $(subst /,\\,$(CONFIGSRC)/util/makedef.cmd) -O1 $(CONFIGSRC)/cf/os2def.db libname @@\
+									@@\
+Concat3(libname,rev,.dll):  solist Concat(libname,os2.def)		@@\
+	$(SHLD) -o $@ solist $(REQUIREDLIBS) $(SHADDLIBS) Concat(libname,o_os2.def)	@@\
+	BuildDllSupportLibs3(libname,rev)				@@\
+	LinkBuildLibrary3(libname,rev,.dll)				@@\
+									@@\
 clean::									@@\
-	RemoveFiles(Concat3(libname,rev,.lib) Concat3(libname,rev,.imp) *.obj link.rsp)
-#endif /* SharedLibraryTarget */
+	RemoveFiles(Concat3(libname,rev,.imp) Concat3(libname,rev,_o.imp) Concat(libname,os2.def) Concat(libname,o_os2.def))
 
-#ifndef NormalLibraryTarget
 #define	NormalLibraryTarget(libname,objlist)				@@\
 AllTarget(LibraryTargetName(libname))					@@\
 									@@\
 LibraryTargetName(libname): objlist					@@\
 	RemoveFile($@)							@@\
 	MakeLibrary($@,objlist)						@@\
-	RanLibrary($@)							@@\
-	BuildLibSupportLibs($*)
-#endif /* NormalLibraryTarget */
-
-#ifndef NormalDepLibraryTarget
-#define	NormalDepLibraryTarget(libname,deplist,objlist)			@@\
-AllTarget(Concat(libname,_baselibtarget) LibraryTargetName(libname))	@@\
-									@@\
-Concat(libname,_baselibtarget):: deplist				@@\
-	rm -rf baseobjs/?*						@@\
-	ImakeHelper 11 baseobjs						@@\
-	$(CP) objlist baseobjs						@@\
-									@@\
-LibraryTargetName(libname): 						@@\
-	RemoveFile($@)							@@\
-	MakeLibrary($@,baseobjs/?*.o)					@@\
-	RanLibrary($@)							@@\
-	BuildLibSupportLibs($*)
-#endif /* NormalDepLibraryTarget */
+	BuildLibSupportLibs2(libname)
 
-/*
- * SharedDepLibraryTarget - generate rules to create a shared library.
- */
-#ifndef SharedDepLibraryTarget
 #ifdef UseInstalled
-#ifndef LinkBuildSonameLibrary
 #define LinkBuildSonameLibrary(lib)
-#endif
 #else
-#ifndef LinkBuildSonameLibrary
 #define LinkBuildSonameLibrary(lib) (RemoveFile($(BUILDLIBDIR)/lib); \
 	cd $(BUILDLIBDIR); $(LN) $(BUILDINCTOP)/$(CURRENT_DIR)/lib .)
 #endif
-#endif
 
 #define SharedDepLibraryTarget(libname,rev,deplist,solist,down,up)	@@\
-SharedLibraryTarget(libname,rev,solist,down,up)
-#endif /* SharedDepLibraryTarget */
+AllTarget(Concat3(libname,rev,.dll))					@@\
+									@@\
+Concat(libname,os2.def): deplist $(EXTRALIBRARYDEPS) Concat(libname,-def.cpp) @@\
+	cmd /c $(subst /,\\,$(CONFIGSRC)/util/makedef.cmd) $(CONFIGSRC)/cf/os2def.db libname @@\
+	cmd /c $(subst /,\\,$(CONFIGSRC)/util/makedef.cmd) -O1 $(CONFIGSRC)/cf/os2def.db libname @@\
+									@@\
+Concat3(libname,rev,.dll):  Concat(libname,os2.def)		@@\
+	(cd down; $(SHLD) -o up/$@ solist $(REQUIREDLIBS) $(SHADDLIBS) Concat(libname,o_os2.def)) @@\
+	BuildDllSupportLibs3(libname,rev)				@@\
+	LinkBuildLibrary3(libname,rev,.dll)				@@\
+									@@\
+clean::									@@\
+	RemoveFiles(Concat3(libname,rev,.imp) Concat3(libname,rev,_o.imp) Concat(libname,os2.def) Concat(libname,o_os2.def))
 
-#ifndef SharedDepModuleTarget
 #define SharedDepModuleTarget(name,deps,solist)				@@\
 AllTarget(name)								@@\
 									@@\
@@ -190,139 +117,65 @@
 									@@\
 clean::									@@\
 	RemoveFile(name)
-#endif /* SharedDepModuleTarget */
 
-#ifndef SharedLibraryDataTarget
 #define SharedLibraryDataTarget(libname,rev,salist)
-#endif /* SharedLibraryDataTarget */
 
-#ifndef InstallSharedLibraryData
 #define InstallSharedLibraryData(libname,rev,dest)
-#endif /* InstallSharedLibraryData */
 
-#ifndef InstallLibrary
 #define	InstallLibrary(libname,dest)					@@\
 install:: LibraryTargetName(libname)					@@\
 	MakeDir($(DESTDIR)dest)						@@\
 	$(INSTALL) $(INSTALLFLAGS) $(INSTLIBFLAGS) LibraryTargetName(libname) $(DESTDIR)dest @@\
 	$(INSTALL) $(INSTALLFLAGS) $(INSTLIBFLAGS) Concat(libname,.lib) $(DESTDIR)dest @@\
 	RanLibrary($(RANLIBINSTFLAGS) $(DESTDIR)dest/LibraryTargetName(libname))
-#endif /* InstallLibrary */
-
-#ifndef LibMkdir
-#define LibMkdir(dir) ImakeHelper 11 dir
-#endif
 
-#ifndef LibCleanDir
-#define LibCleanDir(dir) 						@@\
-	ImakeIndir dir call RemoveFiles(*.Osuf)
-#endif
-
 #define MakeStaticLibrary(libname) $(AR) libname *.o
 
-#ifndef UnsharedLibraryTarget
 #define	UnsharedLibraryTarget(libname,objlist,down,up)			@@\
-AllTarget(LibraryTargetName(Concat(libname,_s)))			@@\
+AllTarget(LibraryTargetNameSuffix(libname,_s))				@@\
 									@@\
-LibraryTargetName(Concat(libname,_s)): objlist				@@\
+LibraryTargetNameSuffix(libname,_s): objlist				@@\
 	RemoveFile($@)							@@\
-	ImakeIndir down MakeStaticLibrary(up/$@)			@@\
+	(cd down; MakeStaticLibrary(up/$@))				@@\
 	RanLibrary($@)							@@\
 	_LinkBuildLibrary($@)						@@\
 									@@\
-install::	LibraryTargetName(Concat(libname,_s))			@@\
-	$(INSTALL) $(INSTALLFLAGS) $(INSTLIBFLAGS) LibraryTargetName(Concat(libname,_s)) $(DESTDIR)$(SHLIBDIR)
-#endif
+install::	Concat3(lib,libname,_s))				@@\
+	$(INSTALL) $(INSTALLFLAGS) $(INSTLIBFLAGS) Concat3(lib,libname,_s) $(DESTDIR)$(SHLIBDIR)
 
-#ifndef UnsharedLibraryTarget3
 #define	UnsharedLibraryTarget3(libname,objlist1,objlist2,objlist3,down,up) @@\
-AllTarget(LibraryTargetName(Concat(libname,_s)))			@@\
+AllTarget(LibraryTargetNameSuffix(libname,_s))				@@\
 									@@\
-LibraryTargetName(Concat(libname,_s)): objlist1 objlist2 objlist3	@@\
+LibraryTargetNameSuffix(libname,_s): objlist1 objlist2 objlist3		@@\
 	RemoveFile($@)							@@\
-	ImakeIndir down MakeStaticLibrary(up/$@)			@@\
+	(cd down; MakeStaticLibrary(up/$@))				@@\
 	RanLibrary($@)							@@\
 	_LinkBuildLibrary($@)						@@\
 									@@\
-install::	LibraryTargetName(Concat(libname,_s))			@@\
-	$(INSTALL) $(INSTALLFLAGS) $(INSTLIBFLAGS) LibraryTargetName(Concat(libname,_s)) $(DESTDIR)$(SHLIBDIR)
-#endif /* UnsharedLibraryTarget3 */
+install::	LibraryTargetNameSuffix(libname,_s)			@@\
+	$(INSTALL) $(INSTALLFLAGS) $(INSTLIBFLAGS) LibraryTargetNameSuffix(libname,_s) $(DESTDIR)$(SHLIBDIR)
 
-/*
- * DebuggedLibraryTarget - generate rules to create a debuggable library.
- */
-#ifndef DebuggedLibraryTarget
 #define	DebuggedLibraryTarget(libname,objlist)				@@\
 AllTarget(LibraryTargetNameSuffix(libname,_d))				@@\
 									@@\
 LibraryTargetNameSuffix(libname,_d): objlist $(EXTRALIBRARYDEPS)	@@\
-	RemoveFile($@)							@@\
-	ImakeIndir debugger MakeStaticLibrary(../$@)			@@\
-	RanLibrary($@)							@@\
-	_LinkBuildLibrary($@)
-
-#endif /* DebuggedLibraryTarget */
-
-/*
- * DebuggedDepLibraryTarget - generate rules to create a debuggable library.
- */
-#ifndef DebuggedDepLibraryTarget
-
-#define	DebuggedDepLibraryTarget2(libname,deplist,objlist)		@@\
-AllTarget(Concat(libname,_dbglibtarget) LibraryTargetNameSuffix(libname,_d))		@@\
-									@@\
-Concat(libname,_dbglibtarget):: deplist							@@\
-	rm -rf debugged/?*						@@\
-	ImakeHelper 11 debugged						@@\
-	$(CP) objlist debugged						@@\
-									@@\
-LibraryTargetNameSuffix(libname,_d): $(EXTRALIBRARYDEPS)		@@\
 	RemoveFile($@)							@@\
-	ImakeIndir debugger MakeStaticLibrary(../$@)			@@\
+	(cd debugger; MakeStaticLibrary(../$@))				@@\
 	RanLibrary($@)							@@\
 	_LinkBuildLibrary($@)
 
-#endif /* DebuggedDepLibraryTarget */
-
-/*
- * ProfiledLibraryTarget - generate rules to create a profiled library.
- */
-#ifndef ProfiledLibraryTarget
 #define	ProfiledLibraryTarget(libname,objlist)				@@\
 AllTarget(LibraryTargetNameSuffix(libname,_p))				@@\
 									@@\
 LibraryTargetNameSuffix(libname,_p): objlist $(EXTRALIBRARYDEPS)	@@\
 	RemoveFile($@)							@@\
-	ImakeIndir profiled MakeStaticLibrary(../$@)			@@\
+	(cd profiled; MakeStaticLibrary(../$@))				@@\
 	RanLibrary($@)							@@\
 	_LinkBuildLibrary($@)
 
-#endif /* ProfiledLibraryTarget */
-
-/*
- * ProfiledDepLibraryTarget - generate rules to create a profiled library.
- */
-#ifndef ProfiledDepLibraryTarget
-#define	ProfiledDepLibraryTarget(libname,deplist,objlist)		@@\
-AllTarget(Concat(libname,_prflibtarget) LibraryTargetNameSuffix(libname,_p))		@@\
-									@@\
-Concat(libname,_prflibtarget):: deplist							@@\
-	rm -rf profiled/?*						@@\
-	ImakeHelper 11 profiled						@@\
-	$(CP) objlist profiled						@@\
+#define	LibraryModuleTarget(module,objlist)				@@\
+AllTarget(LibraryTargetName(module))					@@\
 									@@\
-LibraryTargetNameSuffix(libname,_p): $(EXTRALIBRARYDEPS)		@@\
+LibraryTargetName(module): objlist					@@\
 	RemoveFile($@)							@@\
-	ImakeIndir profiled MakeStaticLibrary(../$@)			@@\
-	RanLibrary($@)							@@\
-	_LinkBuildLibrary($@)
-
-#endif /* ProfiledDepLibraryTarget */
-
-/*
- * DepLibraryModuleTarget
- */
-#ifndef DepLibraryModuleTarget
-#define DepLibraryModuleTarget(module,deplist,objects)			@@\
-NormalDepLibraryTarget(module, deplist, objects)
-#endif
+	MakeLibrary($@,objlist)
Index: xc/config/cf/os2Lib.tmpl
diff -u xc/config/cf/os2Lib.tmpl:3.11 xc/config/cf/os2Lib.tmpl:3.12
--- xc/config/cf/os2Lib.tmpl:3.11	Wed Jan 17 11:22:32 2001
+++ xc/config/cf/os2Lib.tmpl	Fri May 31 12:31:19 2002
@@ -2,57 +2,40 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/os2Lib.tmpl,v 3.11 2001/01/17 16:22:32 dawes Exp $
+XCOMM $XFree86: xc/config/cf/os2Lib.tmpl,v 3.12 2002/05/31 16:31:19 dawes Exp $
 
 /*
  * OS2/EMX shared library template
  */
-#ifndef __EMX__
+#ifndef __UNIXOS2__
 #error You must edit os2Lib.tmpl for your (non-EMX) OS/2 dev system
 #endif
 
-/* note these are special because of linking with link386 */
-#ifdef NOT_EMX
-#define SharedX11Libs $(LDPRELIB) $(SHM)
-#define SharedXtReqs $(LDPRELIB) $(XLIBONLY)
+#define SharedLibFont NO
+
+#define SharedX11Reqs $(LDPRELIB) -lshm
+#define SharedOldXReqs $(LDPRELIB) $(XLIBONLY)
+#define SharedXtReqs $(LDPRELIB) $(XLIBONLY) $(SMLIB) $(ICELIB)
 #define SharedXaw6Reqs $(LDPRELIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
 #define SharedXawReqs $(LDPRELIB) $(XMULIB) $(XTOOLLIB) $(XPMLIB) $(XLIB)
 #define SharedXmuReqs $(LDPRELIB) $(XTOOLLIB) $(XLIB)
-#define SharedSMReqs $(LDPRELIB) $(ICELIB)
+#define SharedXmuuReqs $(LDPRELIB) $(XTOOLLIB) $(XLIB)
 #define SharedXextReqs $(LDPRELIB) $(XLIBONLY)
 #define SharedXiReqs $(LDPRELIB) $(XLIB)
-#define SharedXieReqs $(LDPRELIB) $(XLIB)
-#define SharedXtstReqs $(LDPRELIB) $(XLIB)
-#define SharedOldXReqs $(LDPRELIB) $(XLIBONLY)
+#define SharedXrenderReqs $(LDPRELIB) $(EXTENSIONLIB) $(XLIB)
 #define SharedPexReqs $(LDPRELIB) $(XLIBONLY) MathLibrary
-#define SharedXpReqs $(LDPRELIBS) $(XLIB)
-#define SharedXvReqs $(LDPRELIBS) $(XLIB)
-#define SharedGLReqs $(LDPRELIBS) $(XLIB)
-#define SharedXfontReqs $(LDPRELIBS) $(XLIB)
-#define SharedXpmReqs $(LDPRELIBS) $(XLIB)
-#define SharedDPSReqs $(LDPRELIBS) $(XMULIB) $(XTOOLLIB) $(XLIB)
-#define SharedDPSTKReqs $(LDPRELIBS) $(DPSLIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
-#else
-#define SharedX11Reqs shm
-#define SharedXtReqs ..\\..\\exports\\lib\\ ICE SM X11
-#define SharedXawReqs ..\\..\\exports\\lib\\ Xmu Xt Xpm X11 Xext
-#define SharedXaw6Reqs ..\\..\\exports\\lib\\ Xmu Xt Xpm X11 Xext
-#define SharedXmuReqs ..\\..\\exports\\lib\\ Xt X11 Xext
-#define SharedSMReqs ..\\..\\exports\\lib\\ ICE
-#define SharedXextReqs ..\\..\\exports\\lib\\ X11
-#define SharedXiReqs ..\\..\\exports\\lib\\ X11 Xext
-#define SharedXieReqs ..\\..\\exports\\lib\\ X11 Xext
-#define SharedXtstReqs ..\\..\\exports\\lib\\ X11 Xext
-#define SharedOldXReqs ..\\..\\exports\\lib\\ X11 Xext
-#define SharedPexReqs ..\\..\\exports\\lib\\ X11 m
-#define SharedXpReqs ..\\..\\exports\\lib\\ X11 Xext
-#define SharedXvReqs ..\\..\\exports\\lib\\ X11 Xext
-#define SharedGLReqs ..\\..\\exports\\lib\\ X11 Xext
-#define SharedXfontReqs ..\\..\\exports\\lib\\ X11
-#define SharedXpmReqs ..\\..\\exports\\lib\\ X11
-#define SharedDPSReqs ..\\..\\exports\\lib\\ Xmu Xt X11
-#define SharedDPSTKReqs ..\\..\\exports\\lib\\ DPS Xmu Xt X11
-#endif
+#define SharedXtstReqs $(LDPRELIB) $(XLIB)
+#define SharedSMReqs $(LDPRELIB) $(ICELIB) 
+#define SharedXieReqs $(LDPRELIB) $(XLIB)
+#define SharedXpReqs $(LDPRELIB) $(XLIB)
+#define SharedXvReqs $(LDPRELIB) $(XLIB)
+#define SharedGLReqs $(LDPRELIB) $(XLIB)
+#define SharedXfontReqs $(LDPRELIB) $(XLIB)
+#define SharedXpmReqs $(LDPRELIB) $(XLIB)
+#define SharedDPSReqs $(LDPRELIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
+#define SharedDPSTKReqs $(LDPRELIB) $(DPSLIB) $(XMULIB) $(XTOOLLIB) $(XLIB)
+#define SharedGLUReqs $(LDPRELIB) $(XLIB) $(GLXLIB)
+#define SharedXrandrReqs $(LDPRELIB) $(XLIB)
 
 /* library revisions, these are typically empty! */
 #define SharedX11Rev /**/
@@ -73,6 +56,7 @@
 #define SharedXauRev /**/
 #define SharedXdmcpRev /**/
 #define SharedXmuRev /**/
+#define SharedXmuuRev /**/
 #define SharedOldXRev /**/
 #define SharedXpRev /**/
 #define SharedXtRev /**/
@@ -90,6 +74,12 @@
 #define SharedFSRev /**/
 #define SharedFontRev /**/
 #define SharedXpmRev /**/
+#define SharedGluRev /**/
+#define SharedXrenderRev /**/
+#define SharedXrandrRev /**/
+#define SharedXftRev /**/
+#define SharedFreetype2Rev /**/
+#define SharedXTrapRev /**/
 
 /*
  * By setting this in your Imakefile, you can force using static libraries
@@ -200,3 +190,4 @@
     DEPDPSTKLIB = 
        DPSTKLIB = _Use(SDlibDPSTK,-L$(EXTENSIONSRC)/lib SDlibDPSTK)
 #endif
+
Index: xc/config/cf/os2def.db
diff -u /dev/null xc/config/cf/os2def.db:1.1
--- /dev/null	Thu Feb 27 12:13:02 2003
+++ xc/config/cf/os2def.db	Fri May 31 12:31:19 2002
@@ -0,0 +1,5406 @@
+; This table is the central conversion table for symbols exported
+; by OS/2 DLLs. It replaces the old *os2.def files. It requires a
+; WinNT *-def.cpp file, though, and the script xc/config/util/makedef.cmd.
+; If you want to add a new symbol use a new ordinal number,
+; don't replace existing ones, because this would introduce incompatibilities
+; with existing code.
+;
+; ATTENTION! When adding new items, the field delimiter is expected to
+; be TAB, not a nice looking number of spaces! Don't try to beautify this
+; file!!!!
+;
+; $XFree86: xc/config/cf/os2def.db,v 1.1 2002/05/31 16:31:19 dawes Exp $
+;
+LIBRARY	PEX5 PEX5
+PEX5	PEXAccumulateState	1
+PEX5	PEXAddToNameSet	2
+PEX5	PEXAnnotationText	3
+PEX5	PEXAnnotationText2D	4
+PEX5	PEXApplicationData	5
+PEX5	PEXBeginPickAll	6
+PEX5	PEXBeginPickOne	7
+PEX5	PEXBeginRendering	8
+PEX5	PEXBeginStructure	9
+PEX5	PEXBuildTransform	10
+PEX5	PEXBuildTransform2D	11
+PEX5	PEXCellArray	12
+PEX5	PEXCellArray2D	13
+PEX5	PEXChangeNameSet	14
+PEX5	PEXChangePickDevice	15
+PEX5	PEXChangePipelineContext	16
+PEX5	PEXChangeRenderer	17
+PEX5	PEXChangeSearchContext	18
+PEX5	PEXChangeStructureRefs	19
+PEX5	PEXCopyBytesToOC	20
+PEX5	PEXCopyElements	21
+PEX5	PEXCopyLookupTable	22
+PEX5	PEXCopyNameSet	23
+PEX5	PEXCopyPipelineContext	24
+PEX5	PEXCopySearchContext	25
+PEX5	PEXCopyStructure	26
+PEX5	PEXCountOCs	27
+PEX5	PEXCreateLookupTable	28
+PEX5	PEXCreateNameSet	29
+PEX5	PEXCreatePickMeasure	30
+PEX5	PEXCreatePipelineContext	31
+PEX5	PEXCreateRenderer	32
+PEX5	PEXCreateSearchContext	33
+PEX5	PEXCreateStructure	34
+PEX5	PEXCreateWorkstation	35
+PEX5	PEXDecodeOCs	36
+PEX5	PEXDeleteBetweenLabels	37
+PEX5	PEXDeleteElements	38
+PEX5	PEXDeleteTableEntries	39
+PEX5	PEXDeleteToLabel	40
+PEX5	PEXDestroyStructures	41
+PEX5	PEXElementSearch	42
+PEX5	PEXEncodeOCs	43
+PEX5	PEXEncodedAnnoText	44
+PEX5	PEXEncodedAnnoText2D	45
+PEX5	PEXEncodedText	46
+PEX5	PEXEncodedText2D	47
+PEX5	PEXEndPickAll	48
+PEX5	PEXEndPickOne	49
+PEX5	PEXEndRendering	50
+PEX5	PEXEndStructure	51
+PEX5	PEXEscape	52
+PEX5	PEXEscapeWithReply	53
+PEX5	PEXExecuteDeferredActions	54
+PEX5	PEXExecuteStructure	55
+PEX5	PEXExtendedCellArray	56
+PEX5	PEXFetchElements	57
+PEX5	PEXFetchElementsAndSend	58
+PEX5	PEXFillArea	59
+PEX5	PEXFillArea2D	60
+PEX5	PEXFillAreaSet	61
+PEX5	PEXFillAreaSet2D	62
+PEX5	PEXFillAreaSetWithData	63
+PEX5	PEXFillAreaWithData	64
+PEX5	PEXFinishOCs	65
+PEX5	PEXFreeEnumInfo	66
+PEX5	PEXFreeFontInfo	67
+PEX5	PEXFreeFontNames	68
+PEX5	PEXFreeLookupTable	69
+PEX5	PEXFreeNameSet	70
+PEX5	PEXFreeOCData	71
+PEX5	PEXFreePCAttributes	72
+PEX5	PEXFreePDAttributes	73
+PEX5	PEXFreePMAttributes	74
+PEX5	PEXFreePickMeasure	75
+PEX5	PEXFreePickPaths	76
+PEX5	PEXFreePipelineContext	77
+PEX5	PEXFreeRenderer	78
+PEX5	PEXFreeRendererAttributes	79
+PEX5	PEXFreeSCAttributes	80
+PEX5	PEXFreeSearchContext	81
+PEX5	PEXFreeStructurePaths	82
+PEX5	PEXFreeTableEntries	83
+PEX5	PEXFreeWorkstation	84
+PEX5	PEXFreeWorkstationAttributes	85
+PEX5	PEXGDP	86
+PEX5	PEXGDP2D	87
+PEX5	PEXGSE	88
+PEX5	PEXGeoNormFillArea	89
+PEX5	PEXGeoNormFillAreaSet	90
+PEX5	PEXGeoNormQuadrilateralMesh	91
+PEX5	PEXGeoNormSetOfFillAreaSets	92
+PEX5	PEXGeoNormTriangleStrip	93
+PEX5	PEXGetAncestors	94
+PEX5	PEXGetDefinedIndices	95
+PEX5	PEXGetDescendants	96
+PEX5	PEXGetElementInfo	97
+PEX5	PEXGetEnumTypeInfo	98
+PEX5	PEXGetExtensionInfo	99
+PEX5	PEXGetImpDepConstants	100
+PEX5	PEXGetNameSet	101
+PEX5	PEXGetOCAddr	102
+PEX5	PEXGetPickDevice	103
+PEX5	PEXGetPickMeasure	104
+PEX5	PEXGetPipelineContext	105
+PEX5	PEXGetPredefinedEntries	106
+PEX5	PEXGetProtocolFloatFormat	107
+PEX5	PEXGetRendererAttributes	108
+PEX5	PEXGetRendererDynamics	109
+PEX5	PEXGetSearchContext	110
+PEX5	PEXGetSizeOCs	111
+PEX5	PEXGetStructureInfo	112
+PEX5	PEXGetStructuresInNetwork	113
+PEX5	PEXGetTableEntries	114
+PEX5	PEXGetTableEntry	115
+PEX5	PEXGetTableInfo	116
+PEX5	PEXGetWorkstationAttributes	117
+PEX5	PEXGetWorkstationDynamics	118
+PEX5	PEXGetWorkstationPostings	119
+PEX5	PEXGetWorkstationViewRep	120
+PEX5	PEXIdentityMatrix	121
+PEX5	PEXIdentityMatrix2D	122
+PEX5	PEXInitialize	123
+PEX5	PEXInvertMatrix	124
+PEX5	PEXInvertMatrix2D	125
+PEX5	PEXLabel	126
+PEX5	PEXListFonts	127
+PEX5	PEXListFontsWithInfo	128
+PEX5	PEXLoadFont	129
+PEX5	PEXLookAtViewMatrix	130
+PEX5	PEXMapDCToWC	131
+PEX5	PEXMapWCToDC	132
+PEX5	PEXMapXCToNPC	133
+PEX5	PEXMapXCToNPC2D	134
+PEX5	PEXMarkers	135
+PEX5	PEXMarkers2D	136
+PEX5	PEXMatchRenderingTargets	137
+PEX5	PEXMatrixMult	138
+PEX5	PEXMatrixMult2D	139
+PEX5	PEXNPCToXCTransform	140
+PEX5	PEXNPCToXCTransform2D	141
+PEX5	PEXNURBCurve	142
+PEX5	PEXNURBSurface	143
+PEX5	PEXNoop	144
+PEX5	PEXNormalizeVectors	145
+PEX5	PEXNormalizeVectors2D	146
+PEX5	PEXOrthoProjMatrix	147
+PEX5	PEXPerspProjMatrix	148
+PEX5	PEXPickAll	149
+PEX5	PEXPickOne	150
+PEX5	PEXPolarViewMatrix	151
+PEX5	PEXPolyline	152
+PEX5	PEXPolyline2D	153
+PEX5	PEXPolylineSetWithData	154
+PEX5	PEXPostStructure	155
+PEX5	PEXQuadrilateralMesh	156
+PEX5	PEXQueryEncodedTextExtents	157
+PEX5	PEXQueryFont	158
+PEX5	PEXQueryTextExtents	159
+PEX5	PEXRedrawAllStructures	160
+PEX5	PEXRedrawClipRegion	161
+PEX5	PEXRemoveFromNameSet	162
+PEX5	PEXRenderElements	163
+PEX5	PEXRenderNetwork	164
+PEX5	PEXRestoreModelClipVolume	165
+PEX5	PEXRotate	166
+PEX5	PEXRotate2D	167
+PEX5	PEXRotateGeneral	168
+PEX5	PEXScale	169
+PEX5	PEXScale2D	170
+PEX5	PEXSearchNetwork	171
+PEX5	PEXSendOCs	172
+PEX5	PEXSetATextAlignment	173
+PEX5	PEXSetATextHeight	174
+PEX5	PEXSetATextPath	175
+PEX5	PEXSetATextStyle	176
+PEX5	PEXSetATextUpVector	177
+PEX5	PEXSetBFInteriorStyle	178
+PEX5	PEXSetBFInteriorStyleIndex	179
+PEX5	PEXSetBFReflectionAttributes	180
+PEX5	PEXSetBFReflectionModel	181
+PEX5	PEXSetBFSurfaceColor	182
+PEX5	PEXSetBFSurfaceColorIndex	183
+PEX5	PEXSetBFSurfaceInterpMethod	184
+PEX5	PEXSetCharExpansion	185
+PEX5	PEXSetCharHeight	186
+PEX5	PEXSetCharSpacing	187
+PEX5	PEXSetCharUpVector	188
+PEX5	PEXSetColorApproxIndex	189
+PEX5	PEXSetCurveApprox	190
+PEX5	PEXSetDepthCueIndex	191
+PEX5	PEXSetEchoColor	192
+PEX5	PEXSetEdgeBundleIndex	193
+PEX5	PEXSetEditingMode	194
+PEX5	PEXSetElementPtr	195
+PEX5	PEXSetElementPtrAtLabel	196
+PEX5	PEXSetFacetCullingMode	197
+PEX5	PEXSetFacetDistinguishFlag	198
+PEX5	PEXSetGlobalTransform	199
+PEX5	PEXSetGlobalTransform2D	200
+PEX5	PEXSetHLHSRID	201
+PEX5	PEXSetIndividualASF	202
+PEX5	PEXSetInteriorBundleIndex	203
+PEX5	PEXSetInteriorStyle	204
+PEX5	PEXSetInteriorStyleIndex	205
+PEX5	PEXSetLightSourceState	206
+PEX5	PEXSetLineBundleIndex	207
+PEX5	PEXSetLineColor	208
+PEX5	PEXSetLineColorIndex	209
+PEX5	PEXSetLineType	210
+PEX5	PEXSetLineWidth	211
+PEX5	PEXSetLocalTransform	212
+PEX5	PEXSetLocalTransform2D	213
+PEX5	PEXSetMarkerBundleIndex	214
+PEX5	PEXSetMarkerColor	215
+PEX5	PEXSetMarkerColorIndex	216
+PEX5	PEXSetMarkerScale	217
+PEX5	PEXSetMarkerType	218
+PEX5	PEXSetModelClipFlag	219
+PEX5	PEXSetModelClipVolume	220
+PEX5	PEXSetModelClipVolume2D	221
+PEX5	PEXSetOfFillAreaSets	222
+PEX5	PEXSetParaSurfCharacteristics	223
+PEX5	PEXSetPatternAttributes	224
+PEX5	PEXSetPatternAttributes2D	225
+PEX5	PEXSetPatternSize	226
+PEX5	PEXSetPickID	227
+PEX5	PEXSetPolylineInterpMethod	228
+PEX5	PEXSetReflectionAttributes	229
+PEX5	PEXSetReflectionModel	230
+PEX5	PEXSetRenderingColorModel	231
+PEX5	PEXSetSurfaceApprox	232
+PEX5	PEXSetSurfaceColor	233
+PEX5	PEXSetSurfaceColorIndex	234
+PEX5	PEXSetSurfaceEdgeColor	235
+PEX5	PEXSetSurfaceEdgeColorIndex	236
+PEX5	PEXSetSurfaceEdgeFlag	237
+PEX5	PEXSetSurfaceEdgeType	238
+PEX5	PEXSetSurfaceEdgeWidth	239
+PEX5	PEXSetSurfaceInterpMethod	240
+PEX5	PEXSetTableEntries	241
+PEX5	PEXSetTextAlignment	242
+PEX5	PEXSetTextBundleIndex	243
+PEX5	PEXSetTextColor	244
+PEX5	PEXSetTextColorIndex	245
+PEX5	PEXSetTextFontIndex	246
+PEX5	PEXSetTextPath	247
+PEX5	PEXSetTextPrecision	248
+PEX5	PEXSetViewIndex	249
+PEX5	PEXSetWorkstationBufferMode	250
+PEX5	PEXSetWorkstationDisplayUpdateMode	251
+PEX5	PEXSetWorkstationHLHSRMode	252
+PEX5	PEXSetWorkstationViewPriority	253
+PEX5	PEXSetWorkstationViewRep	254
+PEX5	PEXSetWorkstationViewport	255
+PEX5	PEXSetWorkstationWindow	256
+PEX5	PEXStartOCs	257
+PEX5	PEXText	258
+PEX5	PEXText2D	259
+PEX5	PEXTransformPoints	260
+PEX5	PEXTransformPoints2D	261
+PEX5	PEXTransformPoints2DH	262
+PEX5	PEXTransformPoints4D	263
+PEX5	PEXTransformVectors	264
+PEX5	PEXTransformVectors2D	265
+PEX5	PEXTranslate	266
+PEX5	PEXTranslate2D	267
+PEX5	PEXTriangleStrip	268
+PEX5	PEXUnloadFont	269
+PEX5	PEXUnpostAllStructures	270
+PEX5	PEXUnpostStructure	271
+PEX5	PEXUpdatePickMeasure	272
+PEX5	PEXUpdateWorkstation	273
+PEX5	PEXViewMappingMatrix	274
+PEX5	PEXViewMappingMatrix2D	275
+PEX5	PEXViewOrientationMatrix	276
+PEX5	PEXViewOrientationMatrix2D	277
+PEX5	PEXXCToNPCTransform	278
+PEX5	PEXXCToNPCTransform2D	279
+PEX5	_PEXDecodeEnumType	280
+PEX5	_PEXDecodeTableIndex	281
+PEX5	_PEXDecodeColor	282
+PEX5	_PEXDecodeFloat	283
+PEX5	_PEXDecodeCARD16	284
+PEX5	_PEXDecodeVector2D	285
+PEX5	_PEXDecodeTextAlignment	286
+PEX5	_PEXDecodeCurveApprox	287
+PEX5	_PEXDecodeReflectionAttr	288
+PEX5	_PEXDecodeSurfaceApprox	289
+PEX5	_PEXDecodeCullMode	290
+PEX5	_PEXDecodeSwitch	291
+PEX5	_PEXDecodePatternSize	292
+PEX5	_PEXDecodePatternAttr2D	293
+PEX5	_PEXDecodePatternAttr	294
+PEX5	_PEXDecodeASF	295
+PEX5	_PEXDecodeLocalTransform	296
+PEX5	_PEXDecodeLocalTransform2D	297
+PEX5	_PEXDecodeGlobalTransform	298
+PEX5	_PEXDecodeGlobalTransform2D	299
+PEX5	_PEXDecodeModelClipVolume	300
+PEX5	_PEXDecodeModelClipVolume2D	301
+PEX5	_PEXDecodeRestoreModelClip	302
+PEX5	_PEXDecodeLightSourceState	303
+PEX5	_PEXDecodeID	304
+PEX5	_PEXDecodePSC	305
+PEX5	_PEXDecodeNameSet	306
+PEX5	_PEXDecodeExecuteStructure	307
+PEX5	_PEXDecodeLabel	308
+PEX5	_PEXDecodeApplicationData	309
+PEX5	_PEXDecodeGSE	310
+PEX5	_PEXDecodeMarkers	311
+PEX5	_PEXDecodeMarkers2D	312
+PEX5	_PEXDecodePolyline	313
+PEX5	_PEXDecodePolyline2D	314
+PEX5	_PEXDecodeText	315
+PEX5	_PEXDecodeText2D	316
+PEX5	_PEXDecodeAnnoText	317
+PEX5	_PEXDecodeAnnoText2D	318
+PEX5	_PEXDecodePolylineSet	319
+PEX5	_PEXDecodeNURBCurve	320
+PEX5	_PEXDecodeFillArea	321
+PEX5	_PEXDecodeFillArea2D	322
+PEX5	_PEXDecodeFillAreaWithData	323
+PEX5	_PEXDecodeFillAreaSet	324
+PEX5	_PEXDecodeFillAreaSet2D	325
+PEX5	_PEXDecodeFillAreaSetWithData	326
+PEX5	_PEXDecodeTriangleStrip	327
+PEX5	_PEXDecodeQuadMesh	328
+PEX5	_PEXDecodeSOFA	329
+PEX5	_PEXDecodeNURBSurface	330
+PEX5	_PEXDecodeCellArray	331
+PEX5	_PEXDecodeCellArray2D	332
+PEX5	_PEXDecodeExtendedCellArray	333
+PEX5	_PEXDecodeGDP	334
+PEX5	_PEXDecodeGDP2D	335
+PEX5	_PEXDecodeNoop	336
+PEX5	_PEXEncodeEnumType	337
+PEX5	_PEXEncodeTableIndex	338
+PEX5	_PEXEncodeColor	339
+PEX5	_PEXEncodeFloat	340
+PEX5	_PEXEncodeCARD16	341
+PEX5	_PEXEncodeVector2D	342
+PEX5	_PEXEncodeTextAlignment	343
+PEX5	_PEXEncodeCurveApprox	344
+PEX5	_PEXEncodeReflectionAttr	345
+PEX5	_PEXEncodeSurfaceApprox	346
+PEX5	_PEXEncodeCullMode	347
+PEX5	_PEXEncodeSwitch	348
+PEX5	_PEXEncodePatternSize	349
+PEX5	_PEXEncodePatternAttr2D	350
+PEX5	_PEXEncodePatternAttr	351
+PEX5	_PEXEncodeASF	352
+PEX5	_PEXEncodeLocalTransform	353
+PEX5	_PEXEncodeLocalTransform2D	354
+PEX5	_PEXEncodeGlobalTransform	355
+PEX5	_PEXEncodeGlobalTransform2D	356
+PEX5	_PEXEncodeModelClipVolume	357
+PEX5	_PEXEncodeModelClipVolume2D	358
+PEX5	_PEXEncodeRestoreModelClip	359
+PEX5	_PEXEncodeLightSourceState	360
+PEX5	_PEXEncodeID	361
+PEX5	_PEXEncodePSC	362
+PEX5	_PEXEncodeNameSet	363
+PEX5	_PEXEncodeExecuteStructure	364
+PEX5	_PEXEncodeLabel	365
+PEX5	_PEXEncodeApplicationData	366
+PEX5	_PEXEncodeGSE	367
+PEX5	_PEXEncodeMarkers	368
+PEX5	_PEXEncodePolyline	369
+PEX5	_PEXEncodeMarkers2D	370
+PEX5	_PEXEncodePolyline2D	371
+PEX5	_PEXEncodeText	372
+PEX5	_PEXEncodeText2D	373
+PEX5	_PEXEncodeAnnoText	374
+PEX5	_PEXEncodeAnnoText2D	375
+PEX5	_PEXEncodePolylineSet	376
+PEX5	_PEXEncodeNURBCurve	377
+PEX5	_PEXEncodeFillArea	378
+PEX5	_PEXEncodeFillArea2D	379
+PEX5	_PEXEncodeFillAreaWithData	380
+PEX5	_PEXEncodeFillAreaSet	381
+PEX5	_PEXEncodeFillAreaSet2D	382
+PEX5	_PEXEncodeFillAreaSetWithData	383
+PEX5	_PEXEncodeTriangleStrip	384
+PEX5	_PEXEncodeQuadMesh	385
+PEX5	_PEXEncodeSOFA	386
+PEX5	_PEXEncodeNURBSurface	387
+PEX5	_PEXEncodeCellArray	388
+PEX5	_PEXEncodeCellArray2D	389
+PEX5	_PEXEncodeExtendedCellArray	390
+PEX5	_PEXEncodeGDP	391
+PEX5	_PEXEncodeGDP2D	392
+PEX5	_PEXEncodeNoop	393
+PEX5	_PEXSendBytesToOC	394
+PEX5	_PEXCopyPaddedBytesToOC	395
+PEX5	_PEXGenOCBadLengthError	396
+PEX5	_PEXConvertMaxHitsEvent	397
+PEX5	_PEXConvertOCError	398
+PEX5	_PEXPrintOCError	399
+PEX5	_PEXCloseDisplay	400
+PEX5	_PEXIEEE32toDECF	401
+PEX5	_PEXDECFtoIEEE32	402
+PEX5	_PEXOCFacet	403
+PEX5	_PEXOCListOfFacet	404
+PEX5	_PEXOCListOfVertex	405
+PEX5	_PEXOCListOfColor	406
+PEX5	_PEXStoreFacet	407
+PEX5	_PEXStoreListOfFacet	408
+PEX5	_PEXStoreListOfVertex	409
+PEX5	_PEXStoreListOfColor	410
+PEX5	_PEXExtractFacet	411
+PEX5	_PEXExtractListOfFacet	412
+PEX5	_PEXExtractListOfVertex	413
+PEX5	_PEXExtractListOfColor	414
+PEX5	PEXDisplayInfoHeader	415
+PEX5	PEXPickCache	416
+PEX5	PEXPickCacheSize	417
+PEX5	PEXPickCacheInUse	418
+PEX5	PEX_encode_oc_funcs	419
+PEX5	PEX_decode_oc_funcs	420
+PEX5	PEX_fp_convert	421
+LIBRARY	X11 X11
+X11	XSaveContext	1
+X11	XFindContext	2
+X11	XDeleteContext	3
+X11	XListDepths	4
+X11	XrmParseCommand	5
+X11	Xpermalloc	6
+X11	_XrmInternalStringToQuark	7
+X11	XrmStringToQuark	8
+X11	XrmPermStringToQuark	9
+X11	XrmUniqueQuark	10
+X11	XrmQuarkToString	11
+X11	XAllocColorCells	12
+X11	XAllocColorPlanes	13
+X11	XAllowEvents	14
+X11	XAutoRepeatOn	15
+X11	XAutoRepeatOff	16
+X11	XSetWindowBackground	17
+X11	XSetWindowBorderWidth	18
+X11	XBell	19
+X11	XSetWindowBorder	20
+X11	XEnableAccessControl	21
+X11	XDisableAccessControl	22
+X11	XSetAccessControl	23
+X11	XSetCloseDownMode	24
+X11	XChangeActivePointerGrab	25
+X11	XSetWindowColormap	26
+X11	XChangeGC	27
+X11	XChangeKeyboardControl	28
+X11	XChangePointerControl	29
+X11	XChangeProperty	30
+X11	XChangeSaveSet	31
+X11	XAddToSaveSet	32
+X11	XRemoveFromSaveSet	33
+X11	XChangeWindowAttributes	34
+X11	XResizeWindow	35
+X11	XCheckIfEvent	36
+X11	XCheckMaskEvent	37
+X11	XCheckWindowEvent	38
+X11	XCheckTypedEvent	39
+X11	XCheckTypedWindowEvent	40
+X11	XCirculateSubwindows	41
+X11	XCirculateSubwindowsDown	42
+X11	XCirculateSubwindowsUp	43
+X11	XCloseDisplay	44
+X11	XClearWindow	45
+X11	XClearArea	46
+X11	XMoveResizeWindow	47
+X11	_XConnectDisplay	48
+X11	_XDisconnectDisplay	49
+X11	_XSendClientPrefix	50
+X11	XSetAuthorization	51
+X11	XConvertSelection	52
+X11	XCopyArea	53
+X11	XCopyColormapAndFree	54
+X11	XCopyGC	55
+X11	XCopyPlane	56
+X11	XCreateBitmapFromData	57
+X11	XCreateColormap	58
+X11	XCreatePixmapCursor	59
+X11	XCreateGC	60
+X11	_XUpdateGCCache	61
+X11	_XFlushGCCache	62
+X11	XFlushGC	63
+X11	XGContextFromGC	64
+X11	XCreateGlyphCursor	65
+X11	XCreatePixmapFromBitmapData	66
+X11	XCreatePixmap	67
+X11	XCreateSimpleWindow	68
+X11	XCreateFontCursor	69
+X11	XDefineCursor	70
+X11	XDeleteProperty	71
+X11	XDestroySubwindows	72
+X11	XDestroyWindow	73
+X11	XDisplayName	74
+X11	XDrawArc	75
+X11	XDrawArcs	76
+X11	XDrawLine	77
+X11	XDrawLines	78
+X11	XDrawPoint	79
+X11	XDrawPoints	80
+X11	XDrawRectangle	81
+X11	XDrawRectangles	82
+X11	XDrawSegments	83
+X11	XGetErrorText	84
+X11	XGetErrorDatabaseText	85
+X11	XSetErrorHandler	86
+X11	XSetIOErrorHandler	87
+X11	_XEventToWire	88
+X11	XFetchName	89
+X11	XGetIconName	90
+X11	XFillArc	91
+X11	XFillArcs	92
+X11	XFillPolygon	93
+X11	XFillRectangle	94
+X11	XFillRectangles	95
+X11	XFlush	96
+X11	XLoadQueryFont	97
+X11	XFreeFont	98
+X11	XQueryFont	99
+X11	XListFonts	100
+X11	XFreeFontNames	101
+X11	XListFontsWithInfo	102
+X11	XFreeFontInfo	103
+X11	XFreeColormap	104
+X11	XFreeColors	105
+X11	XFreeCursor	106
+X11	_XFreeExtData	107
+X11	XFreeGC	108
+X11	XFreePixmap	109
+X11	XActivateScreenSaver	110
+X11	XResetScreenSaver	111
+X11	XForceScreenSaver	112
+X11	XSetArcMode	113
+X11	XSetFillRule	114
+X11	XSetFillStyle	115
+X11	XSetGraphicsExposures	116
+X11	XSetSubwindowMode	117
+X11	XGeometry	118
+X11	XGetAtomName	119
+X11	XAllocNamedColor	120
+X11	XGetDefault	121
+X11	XGetFontPath	122
+X11	XFreeFontPath	123
+X11	XGetFontProperty	124
+X11	XGetGeometry	125
+X11	XAllocColor	126
+X11	XGetSizeHints	127
+X11	XGetWMHints	128
+X11	XGetZoomHints	129
+X11	XGetNormalHints	130
+X11	XGetIconSizes	131
+X11	XGetCommand	132
+X11	XGetTransientForHint	133
+X11	XGetClassHint	134
+X11	XGetInputFocus	135
+X11	XGetImage	136
+X11	XGetSubImage	137
+X11	XGetKeyboardControl	138
+X11	XGetMotionEvents	139
+X11	XGetPointerControl	140
+X11	XGetPointerMapping	141
+X11	XGetKeyboardMapping	142
+X11	XGetWindowProperty	143
+X11	XGetSelectionOwner	144
+X11	XGetScreenSaver	145
+X11	XGetStandardColormap	146
+X11	XGetWindowAttributes	147
+X11	XGrabButton	148
+X11	XGrabKey	149
+X11	XGrabKeyboard	150
+X11	XGrabPointer	151
+X11	XGrabServer	152
+X11	XAddHost	153
+X11	XRemoveHost	154
+X11	XAddHosts	155
+X11	XRemoveHosts	156
+X11	XIfEvent	157
+X11	_XGetScanlinePad	158
+X11	_XGetBitsPerPixel	159
+X11	XCreateImage	160
+X11	_XSetImage	161
+X11	_XInitImageFuncPtrs	162
+X11	XDrawImageString	163
+X11	XDrawImageString16	164
+X11	XInitExtension	165
+X11	XAddExtension	166
+X11	XEHeadOfExtensionList	167
+X11	XAddToExtensionList	168
+X11	XFindOnExtensionList	169
+X11	XESetCreateGC	170
+X11	XESetCopyGC	171
+X11	XESetFlushGC	172
+X11	XESetFreeGC	173
+X11	XESetCreateFont	174
+X11	XESetFreeFont	175
+X11	XESetCloseDisplay	176
+X11	XESetWireToEvent	177
+X11	XESetEventToWire	178
+X11	XESetWireToError	179
+X11	XESetError	180
+X11	XESetErrorString	181
+X11	XESetPrintErrorValues	182
+X11	XInstallColormap	183
+X11	XInternAtom	184
+X11	XKeycodeToKeysym	185
+X11	XKeysymToKeycode	186
+X11	XLookupKeysym	187
+X11	XRefreshKeyboardMapping	188
+X11	XLookupString	189
+X11	XRebindKeysym	190
+X11	XKeysymToString	191
+X11	XKillClient	192
+X11	XListHosts	193
+X11	XListInstalledColormaps	194
+X11	XListProperties	195
+X11	XListExtensions	196
+X11	XFreeExtensionList	197
+X11	XLoadFont	198
+X11	XLookupColor	199
+X11	XLowerWindow	200
+X11	XConnectionNumber	942
+X11	XRootWindow	943
+X11	XDefaultScreen	201
+X11	XDefaultRootWindow	202
+X11	XDefaultVisual	203
+X11	XDefaultGC	204
+X11	XBlackPixel	205
+X11	XWhitePixel	206
+X11	XAllPlanes	207
+X11	XQLength	208
+X11	XDisplayWidth	209
+X11	XDisplayHeight	210
+X11	XDisplayWidthMM	211
+X11	XDisplayHeightMM	212
+X11	XDisplayPlanes	213
+X11	XDisplayCells	214
+X11	XScreenCount	215
+X11	XServerVendor	216
+X11	XProtocolVersion	217
+X11	XProtocolRevision	218
+X11	XVendorRelease	219
+X11	XDisplayString	220
+X11	XDefaultDepth	221
+X11	XDefaultColormap	222
+X11	XBitmapUnit	223
+X11	XBitmapBitOrder	224
+X11	XBitmapPad	225
+X11	XImageByteOrder	226
+X11	XNextRequest	227
+X11	XLastKnownRequestProcessed	228
+X11	XScreenOfDisplay	229
+X11	XDefaultScreenOfDisplay	230
+X11	XDisplayOfScreen	231
+X11	XRootWindowOfScreen	232
+X11	XBlackPixelOfScreen	233
+X11	XWhitePixelOfScreen	234
+X11	XDefaultColormapOfScreen	235
+X11	XDefaultDepthOfScreen	236
+X11	XDefaultGCOfScreen	237
+X11	XDefaultVisualOfScreen	238
+X11	XWidthOfScreen	239
+X11	XHeightOfScreen	240
+X11	XWidthMMOfScreen	241
+X11	XHeightMMOfScreen	242
+X11	XPlanesOfScreen	243
+X11	XCellsOfScreen	244
+X11	XMinCmapsOfScreen	245
+X11	XMaxCmapsOfScreen	246
+X11	XDoesSaveUnders	247
+X11	XDoesBackingStore	248
+X11	XEventMaskOfScreen	249
+X11	XScreenNumberOfScreen	250
+X11	XDestroyImage	251
+X11	XGetPixel	252
+X11	XPutPixel	253
+X11	XSubImage	254
+X11	XAddPixel	255
+X11	XNoOp	256
+X11	XMapRaised	257
+X11	XMapSubwindows	258
+X11	XMapWindow	259
+X11	XMaskEvent	260
+X11	XMaxRequestSize	261
+X11	XResourceManagerString	262
+X11	XDisplayMotionBufferSize	263
+X11	XDisplayKeycodes	264
+X11	XVisualIDFromVisual	265
+X11	XGetModifierMapping	266
+X11	XSetModifierMapping	267
+X11	XNewModifiermap	268
+X11	XFreeModifiermap	269
+X11	XInsertModifiermapEntry	270
+X11	XDeleteModifiermapEntry	271
+X11	XMoveWindow	272
+X11	XNextEvent	273
+X11	XOpenDisplay	274
+X11	_XFreeDisplayStructure	275
+X11	XParseColor	276
+X11	XParseGeometry	277
+X11	XPeekEvent	278
+X11	XPeekIfEvent	279
+X11	XEventsQueued	280
+X11	XPending	281
+X11	XSetWindowBackgroundPixmap	282
+X11	XSetWindowBorderPixmap	283
+X11	XPolygonRegion	284
+X11	XDrawText	285
+X11	XDrawText16	286
+X11	XPutBackEvent	287
+X11	_XReverse_Bytes	288
+X11	XPutImage	289
+X11	XQueryBestSize	290
+X11	XQueryColor	291
+X11	XQueryColors	292
+X11	XQueryBestCursor	293
+X11	XQueryExtension	294
+X11	XQueryKeymap	295
+X11	XQueryPointer	296
+X11	XQueryBestStipple	297
+X11	XQueryTextExtents16	298
+X11	XQueryTextExtents	299
+X11	XQueryBestTile	300
+X11	XQueryTree	301
+X11	XRaiseWindow	302
+X11	XReadBitmapFile	303
+X11	XRecolorCursor	304
+X11	XConfigureWindow	305
+X11	XCreateRegion	306
+X11	XClipBox	307
+X11	XUnionRectWithRegion	308
+X11	XSetRegion	309
+X11	XDestroyRegion	310
+X11	XOffsetRegion	311
+X11	XShrinkRegion	312
+X11	XIntersectRegion	313
+X11	XUnionRegion	314
+X11	XSubtractRegion	315
+X11	XXorRegion	316
+X11	XEmptyRegion	317
+X11	XEqualRegion	318
+X11	XPointInRegion	319
+X11	XRectInRegion	320
+X11	XReparentWindow	321
+X11	XRestackWindows	322
+X11	XRotateWindowProperties	323
+X11	XScreenResourceString	324
+X11	XSelectInput	325
+X11	XSendEvent	326
+X11	XSetBackground	327
+X11	XSetClipRectangles	328
+X11	_XSetClipRectangles	329
+X11	XSetClipMask	330
+X11	XSetClipOrigin	331
+X11	XSetDashes	332
+X11	XSetFontPath	333
+X11	XSetFont	334
+X11	XSetForeground	335
+X11	XSetFunction	336
+X11	XSetSizeHints	337
+X11	XSetWMHints	338
+X11	XSetZoomHints	339
+X11	XSetNormalHints	340
+X11	XSetIconSizes	341
+X11	XSetCommand	342
+X11	XSetStandardProperties	343
+X11	XSetTransientForHint	344
+X11	XSetClassHint	345
+X11	XSetInputFocus	346
+X11	XSetLineAttributes	347
+X11	XSetPlaneMask	348
+X11	XSetPointerMapping	349
+X11	XChangeKeyboardMapping	350
+X11	XSetSelectionOwner	351
+X11	XSetScreenSaver	352
+X11	XSetState	353
+X11	XSetStipple	354
+X11	XSetStandardColormap	355
+X11	XSetTile	356
+X11	XSetTSOrigin	357
+X11	XRotateBuffers	358
+X11	XFetchBuffer	359
+X11	XFetchBytes	360
+X11	XStoreBuffer	361
+X11	XStoreBytes	362
+X11	XStoreColor	363
+X11	XStoreColors	364
+X11	XStoreNamedColor	365
+X11	XStoreName	366
+X11	XSetIconName	367
+X11	_XInitKeysymDB	368
+X11	XStringToKeysym	369
+X11	XSync	370
+X11	_XSyncFunction	371
+X11	XSynchronize	372
+X11	XSetAfterFunction	373
+X11	XDrawString	374
+X11	XDrawString16	375
+X11	XTextExtents	376
+X11	XTextWidth	377
+X11	XTextExtents16	378
+X11	XTextWidth16	379
+X11	XTranslateCoordinates	380
+X11	XUndefineCursor	381
+X11	XUngrabButton	382
+X11	XUngrabKeyboard	383
+X11	XUngrabKey	384
+X11	XUngrabPointer	385
+X11	XUngrabServer	386
+X11	XUninstallColormap	387
+X11	XUnloadFont	388
+X11	XUnmapSubwindows	389
+X11	XUnmapWindow	390
+X11	XGetVisualInfo	391
+X11	XMatchVisualInfo	392
+X11	XWarpPointer	393
+X11	XWindowEvent	394
+X11	XCreateWindow	395
+X11	_XProcessWindowAttributes	396
+X11	XWriteBitmapFile	397
+X11	_XFlush	398
+X11	_XEventsQueued	399
+X11	_XReadEvents	400
+X11	_XRead	401
+X11	_XReadPad	402
+X11	_XSend	403
+X11	_XAllocID	404
+X11	_XSetLastRequestRead	405
+X11	_XReply	406
+X11	_XEatData	407
+X11	_XEnq	408
+X11	_XUnknownWireEvent	409
+X11	_XUnknownNativeEvent	410
+X11	_XWireToEvent	411
+X11	_XDefaultIOError	412
+X11	_XDefaultError	413
+X11	_XDefaultWireError	414
+X11	_XError	415
+X11	_XIOError	416
+X11	_XAllocScratch	417
+X11	_XVIDtoVisual	418
+X11	XFree	419
+X11	_XGetHostname	420
+X11	_XScreenOfWindow	421
+X11	_XAllocIDs	423
+X11	_XAllocTemp	424
+X11	_XFreeTemp	425
+X11	XrmInitialize	426
+X11	XrmGetDatabase	427
+X11	XrmSetDatabase	428
+X11	XrmStringToQuarkList	429
+X11	XrmStringToBindingQuarkList	430
+X11	XrmCombineDatabase	431
+X11	XrmMergeDatabases	432
+X11	XrmQPutResource	433
+X11	XrmPutResource	434
+X11	XrmQPutStringResource	435
+X11	XrmPutStringResource	436
+X11	XrmPutLineResource	437
+X11	XrmGetStringDatabase	438
+X11	XrmGetFileDatabase	439
+X11	XrmCombineFileDatabase	440
+X11	XrmEnumerateDatabase	441
+X11	XrmPutFileDatabase	442
+X11	XrmQGetSearchList	443
+X11	XrmQGetSearchResource	444
+X11	XrmQGetResource	445
+X11	XrmGetResource	446
+X11	XrmLocaleOfDatabase	447
+X11	XrmDestroyDatabase	448
+X11	XGetGCValues	449
+X11	XGetWMSizeHints	450
+X11	XGetWMNormalHints	451
+X11	XGetRGBColormaps	452
+X11	XGetTextProperty	453
+X11	XGetWMName	454
+X11	XGetWMIconName	455
+X11	XGetWMClientMachine	456
+X11	XGetWMColormapWindows	457
+X11	XGetWMProtocols	458
+X11	XIconifyWindow	459
+X11	XListPixmapFormats	460
+X11	XAllocSizeHints	461
+X11	XAllocStandardColormap	462
+X11	XAllocWMHints	463
+X11	XAllocClassHint	464
+X11	XAllocIconSize	465
+X11	XReconfigureWMWindow	466
+X11	XSetWMSizeHints	467
+X11	XSetWMNormalHints	468
+X11	XSetRGBColormaps	469
+X11	XSetTextProperty	470
+X11	XSetWMName	471
+X11	XSetWMIconName	472
+X11	XSetWMClientMachine	473
+X11	XSetWMColormapWindows	474
+X11	XSetWMProperties	475
+X11	XSetWMProtocols	476
+X11	XStringListToTextProperty	477
+X11	XTextPropertyToStringList	478
+X11	XFreeStringList	479
+X11	XWMGeometry	480
+X11	XWithdrawWindow	481
+X11	XauDisposeAuth	482
+X11	XauGetBestAuthByAddr	483
+X11	XauFileName	484
+X11	XauReadAuth	485
+X11	XcmsCIELabToCIEXYZ	486
+X11	XcmsCIEXYZToCIELab	487
+X11	XcmsCIELabClipab	488
+X11	XcmsCIELabClipL	489
+X11	XcmsCIELabClipLab	490
+X11	XcmsCIELabQueryMinL	491
+X11	XcmsCIELabQueryMaxC	492
+X11	XcmsCIELabQueryMaxL	493
+X11	_XcmsCIELabQueryMaxLCRGB	494
+X11	XcmsCIELabQueryMaxLC	495
+X11	XcmsCIELabWhiteShiftColors	496
+X11	XcmsCIELuvToCIEuvY	497
+X11	XcmsCIEuvYToCIELuv	498
+X11	XcmsCIELuvClipuv	499
+X11	XcmsCIELuvClipL	500
+X11	XcmsCIELuvClipLuv	501
+X11	XcmsCIELuvQueryMinL	502
+X11	XcmsCIELuvQueryMaxC	503
+X11	XcmsCIELuvQueryMaxL	504
+X11	_XcmsCIELuvQueryMaxLCRGB	505
+X11	XcmsCIELuvQueryMaxLC	506
+X11	XcmsCIELuvWhiteShiftColors	507
+X11	XcmsCIEuvYToCIEXYZ	508
+X11	XcmsCIEXYZToCIEuvY	509
+X11	XcmsCIExyYToCIEXYZ	510
+X11	XcmsCIEXYZToCIExyY	511
+X11	XcmsTekHVCToCIEuvY	512
+X11	XcmsCIEuvYToTekHVC	513
+X11	_XcmsTekHVC_CheckModify	514
+X11	XcmsTekHVCClipC	515
+X11	XcmsTekHVCClipV	516
+X11	XcmsTekHVCClipVC	517
+X11	XcmsTekHVCQueryMinV	518
+X11	XcmsTekHVCQueryMaxC	519
+X11	XcmsTekHVCQueryMaxV	520
+X11	_XcmsTekHVCQueryMaxVCRGB	521
+X11	XcmsTekHVCQueryMaxVC	522
+X11	XcmsTekHVCQueryMaxVSamples	523
+X11	XcmsTekHVCWhiteShiftColors	524
+X11	XcmsAddColorSpace	525
+X11	XcmsAddFunctionSet	526
+X11	XcmsAllocNamedColor	527
+X11	XcmsAllocColor	528
+X11	XcmsCreateCCC	529
+X11	XcmsDefaultCCC	530
+X11	XcmsFreeCCC	531
+X11	_XcmsAddCmapRec	532
+X11	_XcmsCopyCmapRecAndFree	533
+X11	_XcmsDeleteCmapRec	534
+X11	XcmsCCCOfColormap	535
+X11	_XcmsCopyISOLatin1Lowered	536
+X11	_XcmsResolveColorString	537
+X11	_XcmsConvertColorsWithWhitePt	538
+X11	_XcmsEqualWhitePts	539
+X11	_XcmsDIConvertColors	540
+X11	_XcmsDDConvertColors	541
+X11	XcmsConvertColors	542
+X11	_XcmsRegFormatOfPrefix	543
+X11	XcmsFormatOfPrefix	544
+X11	_XcmsCopyPointerArray	545
+X11	_XcmsFreePointerArray	546
+X11	_XcmsPushPointerArray	547
+X11	_XcmsInitDefaultCCCs	548
+X11	_XcmsInitScrnInfo	549
+X11	_XcmsFreeIntensityMaps	550
+X11	_XcmsGetIntensityMap	551
+X11	_XcmsGetTableType0	552
+X11	_XcmsGetTableType1	553
+X11	_XcmsValueCmp	554
+X11	_XcmsIntensityCmp	555
+X11	_XcmsValueInterpolation	556
+X11	_XcmsIntensityInterpolation	557
+X11	_XcmsTableSearch	558
+X11	_XcmsMatVec	559
+X11	XcmsCIEXYZToRGBi	560
+X11	XcmsRGBiToCIEXYZ	561
+X11	XcmsRGBiToRGB	562
+X11	XcmsRGBToRGBi	563
+X11	_XcmsLRGB_InitScrnDefault	564
+X11	XcmsLookupColor	565
+X11	_XcmsCubeRoot	566
+X11	_XcmsSquareRoot	567
+X11	XcmsDisplayOfCCC	568
+X11	XcmsVisualOfCCC	569
+X11	XcmsScreenNumberOfCCC	570
+X11	XcmsScreenWhitePointOfCCC	571
+X11	XcmsClientWhitePointOfCCC	572
+X11	XcmsPrefixOfFormat	573
+X11	_XcmsGetElement	574
+X11	_XcmsGetProperty	575
+X11	XcmsQueryBlack	576
+X11	XcmsQueryBlue	577
+X11	XcmsQueryGreen	578
+X11	XcmsQueryRed	579
+X11	XcmsQueryWhite	580
+X11	XcmsQueryColor	581
+X11	XcmsQueryColors	582
+X11	XcmsSetWhitePoint	583
+X11	XcmsSetCompressionProc	584
+X11	XcmsSetWhiteAdjustProc	585
+X11	_XcmsSetGetColors	586
+X11	XcmsStoreColor	587
+X11	XcmsStoreColors	588
+X11	_XcmsCosine	589
+X11	_XcmsSine	590
+X11	_XcmsArcTangent	591
+X11	_XcmsRGB_to_XColor	592
+X11	_XColor_to_XcmsRGB	593
+X11	_XcmsResolveColor	594
+X11	_XcmsUnresolveColor	595
+X11	_XUnresolveColor	596
+X11	_XParseBaseFontNameList	597
+X11	XCreateFontSet	598
+X11	XFontsOfFontSet	599
+X11	XBaseFontNameListOfFontSet	941
+X11	XLocaleOfFontSet	600
+X11	XContextDependentDrawing	601
+X11	XExtentsOfFontSet	602
+X11	XFreeFontSet	603
+X11	XVaCreateNestedList	604
+X11	XGetIMValues	605
+X11	XCreateIC	606
+X11	XDestroyIC	607
+X11	XGetICValues	608
+X11	XSetICValues	609
+X11	XSetICFocus	610
+X11	XUnsetICFocus	611
+X11	XIMOfIC	612
+X11	XmbResetIC	613
+X11	XwcResetIC	614
+X11	XmbLookupString	615
+X11	XwcLookupString	616
+X11	_XIMCompileResourceList	617
+X11	_XCopyToArg	618
+X11	XOpenIM	619
+X11	XCloseIM	620
+X11	XDisplayOfIM	621
+X11	XLocaleOfIM	622
+X11	XSetLocaleModifiers	623
+X11	XSupportsLocale	624
+X11	_XlcValidModSyntax	625
+X11	_XlcDefaultMapModifiers	626
+X11	_XlcAddLoader	627
+X11	_XlcCurrentLC	628
+X11	XmbSetWMProperties	629
+X11	XmbDrawText	630
+X11	XmbDrawString	631
+X11	XmbDrawImageString	632
+X11	XmbTextEscapement	633
+X11	XmbTextExtents	634
+X11	XmbTextPerCharExtents	635
+X11	XwcDrawText	636
+X11	XwcDrawString	637
+X11	XwcDrawImageString	638
+X11	XwcTextEscapement	639
+X11	XwcTextExtents	640
+X11	XwcTextPerCharExtents	641
+X11	XFilterEvent	642
+X11	_XRegisterFilterByMask	643
+X11	_XRegisterFilterByType	644
+X11	_XUnregisterFilter	645
+X11	_Xsetlocale	646
+X11	XDefaultString	647
+X11	_XlcDefaultLoader	648
+X11	_XrmInitParseInfo	649
+X11	XmbTextPropertyToTextList	650
+X11	XmbTextListToTextProperty	651
+X11	XwcTextPropertyToTextList	652
+X11	XwcFreeStringList	653
+X11	XwcTextListToTextProperty	654
+X11	_X11TransConnectDisplay	655
+X11	XGetAtomNames	656
+X11	XInitImage	657
+X11	XESetBeforeFlush	658
+X11	_XFreeAtomTable	659
+X11	_XUpdateAtomCache	660
+X11	XInternAtoms	661
+X11	_XKeyInitialize	662
+X11	XConvertCase	663
+X11	_XTranslateKey	664
+X11	_XTranslateKeySym	665
+X11	_XKeysymToModifiers	666
+X11	XExtendedMaxRequestSize	667
+X11	XReadBitmapFileData	668
+X11	_XAsyncErrorHandler	669
+X11	_XDeqAsyncHandler	670
+X11	_XGetAsyncReply	671
+X11	_XGetAsyncData	672
+X11	_XPollfdCacheInit	673
+X11	_XPollfdCacheAdd	674
+X11	_XPollfdCacheDel	675
+X11	_XRegisterInternalConnection	676
+X11	_XUnregisterInternalConnection	677
+X11	XInternalConnectionNumbers	678
+X11	XProcessInternalConnection	679
+X11	XAddConnectionWatch	680
+X11	XRemoveConnectionWatch	681
+X11	_XDeq	682
+X11	_XcmsCIEXYZ_ValidSpec	683
+X11	_XcmsCIEuvY_ValidSpec	684
+X11	XcmsSetCCCOfColormap	685
+X11	XDirectionalDependentDrawing	686
+X11	XContextualDrawing	687
+X11	XSetIMValues	688
+X11	XRegisterIMInstantiateCallback	689
+X11	XUnregisterIMInstantiateCallback	690
+X11	XCreateOC	691
+X11	XDestroyOC	692
+X11	XOMOfOC	693
+X11	XSetOCValues	694
+X11	XGetOCValues	695
+X11	XOpenOM	696
+X11	XCloseOM	697
+X11	XSetOMValues	698
+X11	XGetOMValues	699
+X11	XDisplayOfOM	700
+X11	XLocaleOfOM	701
+X11	_XlcRemoveLoader	702
+X11	_XOpenLC	703
+X11	_XCloseLC	704
+X11	_XlcCopyFromArg	705
+X11	_XlcCopyToArg	706
+X11	_XlcCountVaList	707
+X11	_XlcVaToArgList	708
+X11	_XlcCompileResourceList	709
+X11	_XlcGetValues	710
+X11	_XlcSetValues	711
+X11	XInitThreads	712
+X11	XLockDisplay	713
+X11	XUnlockDisplay	714
+X11	_X11TransFreeConnInfo	715
+X11	_X11TransOpenCOTSClient	716
+X11	_X11TransOpenCLTSClient	717
+X11	_X11TransSetOption	718
+X11	_X11TransConnect	719
+X11	_X11TransBytesReadable	720
+X11	_X11TransRead	721
+X11	_X11TransWrite	722
+X11	_X11TransReadv	723
+X11	_X11TransWritev	724
+X11	_X11TransDisconnect	725
+X11	_X11TransClose	726
+X11	_X11TransCloseForCloning	727
+X11	_X11TransIsLocal	728
+X11	_X11TransGetMyAddr	729
+X11	_X11TransGetPeerAddr	730
+X11	_X11TransGetConnectionNumber	731
+X11	_X11TransGetHostname	732
+X11	_X11TransConvertAddress	733
+X11	_XimCbDispatch	734
+X11	_XimLookupMBText	735
+X11	_XimLookupWCText	736
+X11	_XimRegisterFilter	737
+X11	_XimUnregisterFilter	738
+X11	_XimReregisterFilter	739
+X11	_XimRegisterServerFilter	740
+X11	_XimUnregisterServerFilter	741
+X11	_XimProtoCreateIC	742
+X11	_XimCheckDataSize	743
+X11	_XimSetHeader	744
+X11	_XimProtoIMFree	745
+X11	_XimProtoOpenIM	746
+X11	_XimICOfXICID	747
+X11	_XimSetEventMaskCallback	748
+X11	_XimSync	749
+X11	_XimProcSyncReply	750
+X11	_XimRespSyncReply	751
+X11	_XimSyncCallback	752
+X11	_XimForwardEvent	753
+X11	_XimForwardEventCallback	754
+X11	_XimRegisterTriggerKeysCallback	755
+X11	_XimGetWindowEventmask	756
+X11	_XimTriggerNotify	757
+X11	_XimFreeCommitInfo	758
+X11	_XimCommitCallback	759
+X11	_XimProcError	760
+X11	_XimErrorCallback	761
+X11	_XimError	762
+X11	_Ximctstombs	763
+X11	_Ximctstowcs	764
+X11	_XimProtoMbLookupString	765
+X11	_XimProtoWcLookupString	766
+X11	_XimRegProtoIntrCallback	767
+X11	_XimFreeProtoIntrCallback	768
+X11	_XimDispatchInit	769
+X11	_XimProtoEventToWire	770
+X11	_XimProtoWireToEvent	771
+X11	_XimExtension	772
+X11	_XimRegisterIMInstantiateCallback	773
+X11	_XimUnRegisterIMInstantiateCallback	774
+X11	_XimResetIMInstantiateCallback	775
+X11	_XimDestroyIMStructureList	776
+X11	_XimServerDestroy	777
+X11	_XInitIM	779
+X11	_XimLocalFilter	780
+X11	_XimLocalGetICValues	781
+X11	_XimLocalCreateIC	782
+X11	_XimCheckIfLocalProcessing	783
+X11	_XimLocalIMFree	784
+X11	_XimLocalGetIMValues	785
+X11	_XimLocalSetIMValues	786
+X11	_XimLocalOpenIM	787
+X11	_XimLocalMbLookupString	788
+X11	_XimLocalWcLookupString	789
+X11	_XimParseStringFile	790
+X11	_XimSetICValueData	791
+X11	_XimLocalSetICValues	792
+X11	_XimSetIMResourceList	793
+X11	_XimSetICResourceList	794
+X11	_XimSetInnerIMResourceList	795
+X11	_XimSetInnerICResourceList	796
+X11	_XimCheckCreateICValues	797
+X11	_XimGetResourceListRec	798
+X11	_XimSetIMMode	799
+X11	_XimCheckIMMode	800
+X11	_XimSetICMode	801
+X11	_XimCheckICMode	802
+X11	_XimSetLocalIMDefaults	944
+X11	_XimSetICDefaults	803
+X11	_XimDecodeLocalIMAttr	804
+X11	_XimDecodeLocalICAttr	805
+X11	_XimCheckLocalInputStyle	806
+X11	_XimEncodeLocalIMAttr	807
+X11	_XimEncodeLocalICAttr	808
+X11	_XimGetCurrentIMValues	809
+X11	_XimSetCurrentIMValues	810
+X11	_XimGetCurrentICValues	811
+X11	_XimSetCurrentICValues	812
+X11	_XimInitialResourceInfo	813
+X11	_XimDecodeIMATTRIBUTE	814
+X11	_XimDecodeICATTRIBUTE	815
+X11	_XimEncodeIMATTRIBUTE	816
+X11	_XimEncodeICATTRIBUTE	817
+X11	_XimGetAttributeID	818
+X11	_XimThaiFilter	819
+X11	_XimThaiCreateIC	820
+X11	_XimCheckIfThaiProcessing	821
+X11	_XimThaiOpenIM	822
+X11	_XimThaiIMFree	823
+X11	_XimThaiCloseIM	824
+X11	_XimXConf	825
+X11	_XimConnect	826
+X11	_XimShutdown	827
+X11	_XimFlush	828
+X11	_XimFilterWaitEvent	829
+X11	_XimFreeTransIntrCallback	830
+X11	_XimTransFilterWaitEvent	831
+X11	_XimTransInternalConnection	832
+X11	_XimTransFlush	833
+X11	_XimTransConf	834
+X11	_XlcParseCharSet	835
+X11	_XlcInitCTInfo	836
+X11	_XlcGetCSValues	837
+X11	_XlcGetCharSet	838
+X11	_XlcAddCharSet	839
+X11	_XlcCreateDefaultCharSet	840
+X11	_XlcSetConverter	841
+X11	_XlcOpenConverter	842
+X11	_XlcCloseConverter	843
+X11	_XlcConvert	844
+X11	_XlcResetConverter	845
+X11	_XlcGetResource	846
+X11	_XlcGetLocaleDataBase	847
+X11	_XlcDestroyLocaleDataBase	848
+X11	_XlcCreateLocaleDataBase	849
+X11	_XlcEucLoader	850
+X11	_XlcFileName	851
+X11	_XlcResolveLocaleName	852
+X11	_XlcResolveDBName	853
+X11	_XlcResolveI18NPath	854
+X11	_XlcGenericLoader	855
+X11	_XlcInitLoader	856
+X11	_XmbTextPropertyToTextList	857
+X11	_XwcTextPropertyToTextList	858
+X11	_XwcFreeStringList	859
+X11	_XGetLCValues	860
+X11	_XlcDestroyLC	861
+X11	_XlcCreateLC	862
+X11	_XrmDefaultInitParseInfo	863
+X11	_XlcSjisLoader	864
+X11	_Xlcmbtowc	865
+X11	_Xlcwctomb	866
+X11	_Xlcmbstowcs	867
+X11	_Xlcwcstombs	868
+X11	_Xmbtowc	869
+X11	_Xwctomb	870
+X11	_Xmbstowcs	871
+X11	_Xwcstombs	872
+X11	_Xwcscpy	873
+X11	_Xwcsncpy	874
+X11	_Xwcslen	875
+X11	_Xwcscmp	876
+X11	_Xwcsncmp	877
+X11	_XmbTextListToTextProperty	878
+X11	_XwcTextListToTextProperty	879
+X11	_XlcUtfLoader	880
+X11	_XlcCompareISOLatin1	881
+X11	_XlcNCompareISOLatin1	882
+X11	_XmbDefaultTextEscapement	883
+X11	_XwcDefaultTextEscapement	884
+X11	_XmbDefaultTextExtents	885
+X11	_XwcDefaultTextExtents	886
+X11	_XmbDefaultTextPerCharExtents	887
+X11	_XwcDefaultTextPerCharExtents	888
+X11	_XmbDefaultDrawString	889
+X11	_XwcDefaultDrawString	890
+X11	_XmbDefaultDrawImageString	891
+X11	_XwcDefaultDrawImageString	892
+X11	_XomGenericOpenOM	893
+X11	_XInitOM	894
+X11	_XmbGenericDrawImageString	895
+X11	_XwcGenericDrawImageString	896
+X11	_XomGenericDrawString	897
+X11	_XmbGenericDrawString	898
+X11	_XwcGenericDrawString	899
+X11	_XmbGenericTextEscapement	900
+X11	_XwcGenericTextEscapement	901
+X11	_XomGenericTextExtents	902
+X11	_XmbGenericTextExtents	903
+X11	_XwcGenericTextExtents	904
+X11	_XmbGenericTextPerCharExtents	905
+X11	_XwcGenericTextPerCharExtents	906
+X11	_XomConvert	907
+X11	_XomInitConverter	908
+X11	_Xmblen	909
+X11	_XimGetResourceName	910
+X11	_XimGetResourceListRecByQuark	911
+X11	_XimSetIMValueData	912
+X11	_XimGetIMValueData	913
+X11	_XimGetICValueData	914
+X11	_XimMakeIMAttrIDList	915
+X11	_XimMakeICAttrIDList	916
+X11	_XimWrite	917
+X11	_XimRead	918
+X11	_XimRegisterDispatcher	919
+X11	_XimTransRegisterDispatcher	920
+X11	_XimTransCallDispatcher	921
+X11	_XimTransWrite	922
+X11	_XimTransRead	923
+X11	_XimXTransFreeConnInfo	924
+X11	_XimXTransOpenCOTSClient	925
+X11	_XimXTransOpenCLTSClient	926
+X11	_XimXTransSetOption	927
+X11	_XimXTransConnect	928
+X11	_XimXTransBytesReadable	929
+X11	_XimXTransRead	930
+X11	_XimXTransWrite	931
+X11	_XimXTransReadv	932
+X11	_XimXTransWritev	933
+X11	_XimXTransDisconnect	934
+X11	_XimXTransClose	935
+X11	_XimXTransCloseForCloning	936
+X11	_XimXTransIsLocal	937
+X11	_XimXTransGetMyAddr	938
+X11	_XimXTransGetPeerAddr	939
+X11	_XimXTransGetConnectionNumber	940
+X11	_XimXTransGetHostname	945
+X11	_Xdebug	946
+X11	__XOS2RedirRoot	950
+X11	__XOS2RedirRoot1	951
+X11	XkbIgnoreExtension	1000
+X11	XkbOpenDisplay	1001
+X11	XkbQueryExtension	1002
+X11	XkbUseExtension	1003
+X11	XkbLibraryVersion	1004
+X11	XkbSetXlibControls	1005
+X11	XkbGetXlibControls	1006
+X11	XkbSetAtomFuncs	1007
+X11	XkbKeycodeToKeysym	1008
+X11	XkbKeysymToModifiers	1009
+X11	XkbLookupKeySym	1010
+X11	XkbLookupKeyBinding	1011
+X11	XkbTranslateKeyCode	1012
+X11	XkbTranslateKeySym	1013
+X11	XkbSetAutoRepeatRate	1014
+X11	XkbGetAutoRepeatRate	1015
+X11	XkbChangeEnabledControls	1016
+X11	XkbDeviceBell	1017
+X11	XkbForceDeviceBell	1018
+X11	XkbDeviceBellEvent	1019
+X11	XkbBell	1020
+X11	XkbForceBell	1021
+X11	XkbBellEvent	1022
+X11	XkbSelectEvents	1023
+X11	XkbSelectEventDetails	1024
+X11	XkbNoteMapChanges	1025
+X11	XkbNoteNameChanges	1026
+X11	XkbGetIndicatorState	1027
+X11	XkbGetIndicatorMap	1029
+X11	XkbSetIndicatorMap	1030
+X11	XkbGetNamedIndicator	1031
+X11	XkbGetNamedDeviceIndicator	1032
+X11	XkbSetNamedIndicator	1033
+X11	XkbSetNamedDeviceIndicator	1034
+X11	XkbLockModifiers	1035
+X11	XkbLatchModifiers	1036
+X11	XkbLockGroup	1037
+X11	XkbLatchGroup	1038
+X11	XkbSetServerInternalMods	1039
+X11	XkbSetIgnoreLockMods	1040
+X11	XkbVirtualModsToReal	1041
+X11	XkbComputeEffectiveMap	1042
+X11	XkbInitCanonicalKeyTypes	1043
+X11	XkbAllocKeyboard	1044
+X11	XkbFreeKeyboard	1045
+X11	XkbAllocClientMap	1046
+X11	XkbAllocServerMap	1047
+X11	XkbFreeClientMap	1048
+X11	XkbFreeServerMap	1049
+X11	XkbAddKeyType	1050
+X11	XkbAllocIndicatorMaps	1051
+X11	XkbFreeIndicatorMaps	1052
+X11	XkbGetMap	1053
+X11	XkbGetUpdatedMap	1054
+X11	XkbGetMapChanges	1055
+X11	XkbRefreshKeyboardMapping	1056
+X11	XkbGetKeyTypes	1057
+X11	XkbGetKeySyms	1058
+X11	XkbGetKeyActions	1059
+X11	XkbGetKeyBehaviors	1060
+X11	XkbGetVirtualMods	1061
+X11	XkbGetKeyExplicitComponents	1062
+X11	XkbGetKeyModifierMap	1063
+X11	XkbAllocControls	1064
+X11	XkbFreeControls	1065
+X11	XkbGetControls	1066
+X11	XkbSetControls	1067
+X11	XkbAllocCompatMap	1069
+X11	XkbFreeCompatMap	1070
+X11	XkbGetCompatMap	1071
+X11	XkbSetCompatMap	1072
+X11	XkbAllocNames	1073
+X11	XkbGetNames	1074
+X11	XkbSetNames	1075
+X11	XkbChangeNames	1076
+X11	XkbFreeNames	1077
+X11	XkbGetState	1078
+X11	XkbSetMap	1079
+X11	XkbChangeMap	1080
+X11	XkbSetDetectableAutoRepeat	1081
+X11	XkbGetDetectableAutoRepeat	1082
+X11	XkbSetAutoResetControls	1083	
+X11	XkbGetAutoResetControls	1084
+X11	XkbCopyKeyType	1085
+X11	XkbCopyKeyTypes	1086
+X11	XkbResizeKeyType	1087
+X11	XkbResizeKeySyms	1088
+X11	XkbResizeKeyActions	1089
+X11	XkbChangeTypesOfKey	1090
+X11	XkbListComponents	1091
+X11	XkbFreeComponentList	1092
+X11	XkbGetKeyboard	1093
+X11	XkbGetKeyboardByName	1094
+X11	XkbAddDeviceLedInfo	1098
+X11	XkbResizeDeviceButtonActions	1099
+X11	XkbAllocDeviceInfo	1100
+X11	XkbFreeDeviceInfo	1101
+X11	XkbNoteDeviceChanges	1102
+X11	XkbGetDeviceInfo	1103
+X11	XkbGetDeviceInfoChanges	1104
+X11	XkbGetDeviceButtonActions	1105
+X11	XkbGetDeviceLedInfo	1106
+X11	XkbSetDeviceInfo	1107
+X11	XkbChangeDeviceInfo	1108
+X11	XkbSetDeviceLedInfo	1109
+X11	XkbSetDeviceButtonActions	1110
+X11	XkbToControl	1111
+X11	XkbSetDebuggingFlags	1112
+X11	_XkbInternAtomFunc	1113
+X11	_XkbGetAtomNameFunc	1114
+X11	_XkbReloadDpy	1115
+X11	_XKeycodeToKeysym	1116
+X11	_XKeysymToKeycode	1117
+X11	_XLookupKeysym	1118
+X11	_XRefreshKeyboardMapping	1119
+X11	_XLookupString	1120
+X11	_XkbNoteCoreMapChanges	1121
+X11	_XkbInitReadBuffer	1122
+X11	_XkbSkipReadBufferData	1123
+X11	_XkbCopyFromReadBuffer	1124
+X11	_XkbReadCopyKeySyms	1125
+X11	_XkbWriteCopyKeySyms	1126
+X11	_XkbReadBufferCopyKeySyms	1127
+X11	_XkbPeekAtReadBuffer	1128
+X11	_XkbGetReadBufferPtr	1129
+X11	_XkbFreeReadBuffer	1130
+X11	_XkbGetReadBufferCountedString	1131
+X11	_XkbGetCharset	1132
+X11	_XkbGetConverters	1133
+X11	XkbGetGeometry	1134
+X11	XkbAddGeomShape	1135
+X11	XkbAddGeomOutline	1136
+X11	XkbComputeShapeBounds	1137
+X11	XkbAddGeomDoodad	1138
+X11	XkbAddGeomColor	1139
+X11	XkbAddGeomOverlayRow	1140
+X11	XkbAddGeomSection	1141
+X11	XkbAddGeomRow	1142
+X11	XkbAddGeomKey	1143
+X11	XkbComputeSectionBounds	1144
+X11	XkbAllocGeometry	1145
+X11	XkbAddGeomProperty	1146
+X11	XkbAddGeomOverlay	1147
+X11	XkbComputeShapeTop	1148
+X11	XkbFindOverlayForKey	1149
+X11	XkbAllocGeomKeyAliases	1150
+X11	XkbSetGeometry	1151
+X11	XkbXlibControlsImplemented	1152
+X11	XkbTranslateKey	1153
+X11	XkbAddGeomOverlayKey	1154
+X11	XkbNoteControlsChanges	1155
+X11	XkbGetKeyVirtualModMap	1156
+X11	XkbComputeRowBounds	1157
+X11	XkbGetNamedGeometry	1158
+X11	XkbKeyTypesForCoreSymbols	1159
+X11	XkbApplyCompatMapToKey	1160
+X11	XkbUpdateMapFromCore	1161
+X11	XkbUpdateActionVirtualMods	1162
+X11	XkbUpdateKeyTypeVirtualMods	1163
+X11	XkbApplyVirtualModChanges	1164
+X11	XkbFreeGeomProperties	1165
+X11	XkbFreeGeomKeyAliases	1166
+X11	XkbFreeGeomColors	1167
+X11	XkbFreeGeomPoints	1168
+X11	XkbFreeGeomOutlines	1169
+X11	XkbFreeGeomShapes	1170
+X11	XkbFreeGeomOverlayKeys	1171
+X11	XkbFreeGeomOverlayRows	1172
+X11	XkbFreeGeomOverlays	1173
+X11	XkbFreeGeomKeys	1174
+X11	XkbFreeGeomRows	1175
+X11	XkbFreeGeomSections	1176
+X11	XkbFreeGeomDoodads	1177
+X11	XkbFreeGeometry	1178
+X11	XkbAllocGeomProps	1179
+X11	XkbAllocGeomColors	1180
+X11	XkbAllocGeomShapes	1181
+X11	XkbAllocGeomSections	1182
+X11	XkbAllocGeomOverlays	1183
+X11	XkbAllocGeomOverlayRows	1184
+X11	XkbAllocGeomOverlayKeys	1185
+X11	XkbAllocGeomDoodads	1186
+X11	XkbAllocGeomSectionDoodads	1187
+X11	XkbAllocGeomOutlines	1188
+X11	XkbAllocGeomRows	1189
+X11	XkbAllocGeomPoints	1190
+X11	XkbAllocGeomKeys	1191
+X11	XkbAddGeomKeyAlias	1192
+X11	_XkeyTable	1200
+X11	_Xevent_to_mask	1201
+X11	_qfree	1202
+X11	_XIOErrorFunction	1203
+X11	_XErrorFunction	1204
+X11	_XHeadOfDisplayList	1205
+X11	XcmsCIELabColorSpace	1206
+X11	XcmsCIELuvColorSpace	1207
+X11	XcmsCIEXYZColorSpace	1208
+X11	XcmsCIEuvYColorSpace	1209
+X11	XcmsCIExyYColorSpace	1210
+X11	XcmsTekHVCColorSpace	1211
+X11	XcmsUNDEFINEDColorSpace	1212
+X11	_XcmsDIColorSpacesInit	1213
+X11	_XcmsDIColorSpaces	1214
+X11	_XcmsDDColorSpacesInit	1215
+X11	_XcmsDDColorSpaces	1216
+X11	_XcmsSCCFuncSetsInit	1217
+X11	_XcmsSCCFuncSets	1218
+X11	_XcmsCIEXYZ_prefix	1219
+X11	_XcmsCIEuvY_prefix	1220
+X11	_XcmsCIExyY_prefix	1221
+X11	_XcmsCIELab_prefix	1222
+X11	_XcmsCIELuv_prefix	1223
+X11	_XcmsTekHVC_prefix	1224
+X11	_XcmsRGBi_prefix	1225
+X11	_XcmsRGB_prefix	1226
+X11	_XcmsRegColorSpaces	1227
+X11	XcmsRGBiColorSpace	1228
+X11	XcmsRGBColorSpace	1229
+X11	XcmsLinearRGBFunctionSet	1230
+X11	_X11TransSocketINETFuncs	1231
+X11	_X11TransSocketTCPFuncs	1232
+X11	_XimXTransSocketINETFuncs	1233
+X11	_XimXTransSocketTCPFuncs	1234
+X11	_XimImSportRec	1235
+X11	_XimTransportRec	1236
+X11	_XlcGenericMethods	1237
+X11	_XlcPublicMethods	1238
+; 4.x exports starting from 1300
+X11	_XFlushIt	1300
+X11	_Xthread_init	1301
+X11	_Xthread_waiter	1302
+X11	XkbGetPerClientControls	1303
+X11	XkbSetPerClientControls	1304
+X11	Xutf8TextPropertyToTextList	1305
+X11	Xutf8TextListToTextProperty	1306
+X11	_XCreateMutex_fn	1307
+X11	_XFreeMutex_fn	1308
+X11	_XLockMutex_fn	1309
+X11	_XUnlockMutex_fn	1310
+X11	_Xglobal_lock	1311
+X11	Xutf8LookupString	1312
+LIBRARY XIE XIE
+XIE	XieAbort	1
+XIE	XieAllocatePhotofloGraph	2
+XIE	XieAwait	3
+XIE	XieCreateColorList	4
+XIE	XieCreateLUT	5
+XIE	XieCreatePhotoflo	6
+XIE	XieCreatePhotomap	7
+XIE	XieCreatePhotospace	8
+XIE	XieCreateROI	9
+XIE	XieDestroyColorList	10
+XIE	XieDestroyLUT	11
+XIE	XieDestroyPhotoflo	12
+XIE	XieDestroyPhotomap	13
+XIE	XieDestroyPhotospace	14
+XIE	XieDestroyROI	15
+XIE	XieExecuteImmediate	16
+XIE	XieExecutePhotoflo	17
+XIE	XieFloArithmetic	18
+XIE	XieFloBandCombine	19
+XIE	XieFloBandExtract	20
+XIE	XieFloBandSelect	21
+XIE	XieFloBlend	22
+XIE	XieFloCompare	23
+XIE	XieFloConstrain	24
+XIE	XieFloConvertFromIndex	25
+XIE	XieFloConvertFromRGB	26
+XIE	XieFloConvertToIndex	27
+XIE	XieFloConvertToRGB	28
+XIE	XieFloConvolve	29
+XIE	XieFloDither	30
+XIE	XieFloExportClientHistogram	31
+XIE	XieFloExportClientLUT	32
+XIE	XieFloExportClientPhoto	33
+XIE	XieFloExportClientROI	34
+XIE	XieFloExportDrawable	35
+XIE	XieFloExportDrawablePlane	36
+XIE	XieFloExportLUT	37
+XIE	XieFloExportPhotomap	38
+XIE	XieFloExportROI	39
+XIE	XieFloGeometry	40
+XIE	XieFloImportClientLUT	41
+XIE	XieFloImportClientPhoto	42
+XIE	XieFloImportClientROI	43
+XIE	XieFloImportDrawable	44
+XIE	XieFloImportDrawablePlane	45
+XIE	XieFloImportLUT	46
+XIE	XieFloImportPhotomap	47
+XIE	XieFloImportROI	48
+XIE	XieFloLogical	49
+XIE	XieFloMatchHistogram	50
+XIE	XieFloMath	51
+XIE	XieFloPasteUp	52
+XIE	XieFloPoint	53
+XIE	XieFloUnconstrain	54
+XIE	XieFreeEncodeJPEGBaseline	55
+XIE	XieFreeEncodeJPEGLossless	56
+XIE	XieFreePasteUpTiles	57
+XIE	XieFreePhotofloGraph	58
+XIE	XieFreeTechniques	59
+XIE	XieGetClientData	60
+XIE	XieInitialize	61
+XIE	XieModifyPhotoflo	62
+XIE	XiePurgeColorList	63
+XIE	XiePutClientData	64
+XIE	XieQueryColorList	65
+XIE	XieQueryPhotoflo	66
+XIE	XieQueryPhotomap	67
+XIE	XieQueryTechniques	68
+XIE	XieRedefinePhotoflo	69
+XIE	XieTecCIELabToRGB	70
+XIE	XieTecCIEXYZToRGB	71
+XIE	XieTecClipScale	72
+XIE	XieTecColorAllocAll	73
+XIE	XieTecColorAllocMatch	74
+XIE	XieTecColorAllocRequantize	75
+XIE	XieTecConvolveConstant	76
+XIE	XieTecDecodeG31D	77
+XIE	XieTecDecodeG32D	78
+XIE	XieTecDecodeG42D	79
+XIE	XieTecDecodeJPEGBaseline	80
+XIE	XieTecDecodeJPEGLossless	81
+XIE	XieTecDecodeTIFF2	82
+XIE	XieTecDecodeTIFFPackBits	83
+XIE	XieTecDecodeUncompressedSingle	84
+XIE	XieTecDecodeUncompressedTriple	85
+XIE	XieTecDitherOrderedParam	86
+XIE	XieTecEncodeG31D	87
+XIE	XieTecEncodeG32D	88
+XIE	XieTecEncodeG42D	89
+XIE	XieTecEncodeJPEGBaseline	90
+XIE	XieTecEncodeJPEGLossless	91
+XIE	XieTecEncodeServerChoice	92
+XIE	XieTecEncodeTIFF2	93
+XIE	XieTecEncodeTIFFPackBits	94
+XIE	XieTecEncodeUncompressedSingle	95
+XIE	XieTecEncodeUncompressedTriple	96
+XIE	XieTecGeomAntialiasByArea	97
+XIE	XieTecGeomAntialiasByLowpass	98
+XIE	XieTecGeomGaussian	99
+XIE	XieTecGeomNearestNeighbor	100
+XIE	XieTecHistogramGaussian	101
+XIE	XieTecHistogramHyperbolic	102
+XIE	XieTecRGBToCIELab	103
+XIE	XieTecRGBToCIEXYZ	104
+XIE	XieTecRGBToYCC	105
+XIE	XieTecRGBToYCbCr	106
+XIE	XieTecWhiteAdjustCIELabShift	107
+XIE	XieTecYCCToRGB	108
+XIE	XieTecYCbCrToRGB	109
+XIE	_XiePhotofloSize	110
+XIE	_XieElemImportClientLUT	111
+XIE	_XieElemImportClientPhoto	112
+XIE	_XieElemImportClientROI	113
+XIE	_XieElemImportDrawable	114
+XIE	_XieElemImportDrawablePlane	115
+XIE	_XieElemImportLUT	116
+XIE	_XieElemImportPhotomap	117
+XIE	_XieElemImportROI	118
+XIE	_XieElemArithmetic	119
+XIE	_XieElemBandCombine	120
+XIE	_XieElemBandExtract	121
+XIE	_XieElemBandSelect	122
+XIE	_XieElemBlend	123
+XIE	_XieElemCompare	124
+XIE	_XieElemConstrain	125
+XIE	_XieElemConvertFromIndex	126
+XIE	_XieElemConvertFromRGB	127
+XIE	_XieElemConvertToIndex	128
+XIE	_XieElemConvertToRGB	129
+XIE	_XieElemConvolve	130
+XIE	_XieElemDither	131
+XIE	_XieElemGeometry	132
+XIE	_XieElemLogical	133
+XIE	_XieElemMatchHistogram	134
+XIE	_XieElemMath	135
+XIE	_XieElemPasteUp	136
+XIE	_XieElemPoint	137
+XIE	_XieElemUnconstrain	138
+XIE	_XieElemExportClientHistogram	139
+XIE	_XieElemExportClientLUT	140
+XIE	_XieElemExportClientPhoto	141
+XIE	_XieElemExportClientROI	142
+XIE	_XieElemExportDrawable	143
+XIE	_XieElemExportDrawablePlane	144
+XIE	_XieElemExportLUT	145
+XIE	_XieElemExportPhotomap	146
+XIE	_XieElemExportROI	147
+XIE	_XieFloError	148
+XIE	_XieColorAllocEvent	149
+XIE	_XieDecodeNotifyEvent	150
+XIE	_XieExportAvailableEvent	151
+XIE	_XieImportObscuredEvent	152
+XIE	_XiePhotofloDoneEvent	153
+XIE	_XieConvertToIEEE	154
+XIE	_XieCloseDisplay	155
+XIE	_XiePrintError	156
+XIE	_XieTechniqueLength	157
+XIE	_XieEncodeTechnique	158
+XIE	_XieColorAllocAllParam	159
+XIE	_XieColorAllocMatchParam	160
+XIE	_XieColorAllocRequantizeParam	161
+XIE	_XieRGBToCIELabParam	162
+XIE	_XieRGBToYCbCrParam	163
+XIE	_XieRGBToYCCParam	164
+XIE	_XieYCbCrToRGBParam	165
+XIE	_XieYCCToRGBParam	166
+XIE	_XieCIELabToRGBParam	167
+XIE	_XieConvolveConstantParam	168
+XIE	_XieClipScaleParam	169
+XIE	_XieDecodeUncompressedSingleParam	170
+XIE	_XieDecodeUncompressedTripleParam	171
+XIE	_XieDecodeG31DParam	172
+XIE	_XieDecodeTIFFPackBitsParam	173
+XIE	_XieDecodeJPEGBaselineParam	174
+XIE	_XieDitherOrderedParam	175
+XIE	_XieEncodeUncompressedSingleParam	176
+XIE	_XieEncodeUncompressedTripleParam	177
+XIE	_XieEncodeG31DParam	178
+XIE	_XieEncodeTIFFPackBitsParam	179
+XIE	_XieEncodeServerChoiceParam	180
+XIE	_XieEncodeG32DParam	181
+XIE	_XieEncodeG42DParam	182
+XIE	_XieEncodeJPEGBaselineParam	183
+XIE	_XieEncodeJPEGLosslessParam	184
+XIE	_XieEncodeTIFF2Param	185
+XIE	_XieGeomAntialiasByAreaParam	186
+XIE	_XieGeomAntialiasByLowpassParam	187
+XIE	_XieGeomGaussianParam	188
+XIE	_XieGeomNearestNeighborParam	189
+XIE	_XieHistogramGaussianParam	190
+XIE	_XieHistogramHyperbolicParam	191
+XIE	_XieWhiteAdjustCIELabShiftParam	192
+XIE	_XieInitTechFuncTable	193
+XIE	_XieRegisterTechFunc	194
+XIE	_XieLookupTechFunc	195
+XIE	_XieExtInfoHeader	196
+XIE	_XieElemFuncs	197
+XIE	_XieTechFuncsInitialized	198
+XIE	_XieTechFuncs	199
+LIBRARY Xaw Xaw INITINSTANCE TERMINSTANCE
+Xaw	XawAsciiSourceFreeString	1
+Xaw	XawAsciiSave	2
+Xaw	XawAsciiSaveAsFile	3
+Xaw	XawAsciiSourceChanged	4
+Xaw	XawDialogAddButton	5
+Xaw	XawDialogGetValueString	6
+Xaw	XawFormDoLayout	7	
+Xaw	XawListChange	8
+Xaw	XawListUnhighlight	9
+Xaw	XawListHighlight	10
+Xaw	XawListShowCurrent	11
+Xaw	XawPanedSetMinMax	13
+Xaw	XawPanedGetMinMax	14
+Xaw	XawPanedSetRefigureMode	15
+Xaw	XawPanedGetNumSub	16
+Xaw	XawScrollbarSetThumb	18
+Xaw	XawSimpleMenuAddGlobalActions	19
+Xaw	XawSimpleMenuGetActiveEntry	20
+Xaw	XawSimpleMenuClearActiveEntry	21
+Xaw	XawTextDisplay	22
+Xaw	XawTextEnableRedisplay	23
+Xaw	XawTextDisableRedisplay	24
+Xaw	XawTextSetSelectionArray	25
+Xaw	XawTextGetSelectionPos	26
+Xaw	XawTextSetSource	27
+Xaw	XawTextReplace	28
+Xaw	XawTextTopPosition	29
+Xaw	XawTextSetInsertionPoint	30
+Xaw	XawTextGetInsertionPoint	31
+Xaw	XawTextUnsetSelection	32
+Xaw	XawTextSetSelection	33
+Xaw	XawTextInvalidate	34
+Xaw	XawTextGetSource	35
+Xaw	XawTextSearch	36
+Xaw	XawTextDisplayCaret	37
+Xaw	XawTextSinkDisplayText	38
+Xaw	XawTextSinkInsertCursor	39
+Xaw	XawTextSinkClearToBackground	40
+Xaw	XawTextSinkFindPosition	41
+Xaw	XawTextSinkFindDistance	42
+Xaw	XawTextSinkResolve	43
+Xaw	XawTextSinkMaxLines	44
+Xaw	XawTextSinkMaxHeight	45
+Xaw	XawTextSinkSetTabs	46
+Xaw	XawTextSinkGetCursorBounds	47
+Xaw	XawTextSourceRead	48
+Xaw	XawTextSourceReplace	49
+Xaw	XawTextSourceScan	50
+Xaw	XawTextSourceSearch	51
+Xaw	XawTextSourceConvertSelection	52
+Xaw	XawTextSourceSetSelection	53
+Xaw	XawToggleChangeRadioGroup	54
+Xaw	XawToggleGetCurrent	55
+Xaw	XawToggleSetCurrent	56
+Xaw	XawToggleUnsetCurrent	57
+Xaw	XawTreeForceLayout	58
+Xaw	XawViewportSetLocation	59
+Xaw	XawViewportSetCoordinates	60
+Xaw	_XawMultiSinkPosToXY	61
+Xaw	_XawMultiSave	62
+Xaw	_XawMultiSaveAsFile	63
+Xaw	_XawMultiSourceFreeString	64
+Xaw	_XawTextFormat	65
+Xaw	_XawTextBuildLineTable	66
+Xaw	_XawTextGetSTRING	67
+Xaw	_XawTextSaltAwaySelection	68
+Xaw	_XawTextPosToXY	69
+Xaw	_XawTextWCToMB	70
+Xaw	_XawTextMBToWC	71
+Xaw	_Xaw_atowc	72
+Xaw	_XawImResizeVendorShell	73
+Xaw	_XawImGetShellHeight	74
+Xaw	_XawImRealize	75
+Xaw	_XawImInitialize	76
+Xaw	_XawImReconnect	77
+Xaw	_XawImRegister	78
+Xaw	_XawImUnregister	79
+Xaw	_XawImSetValues	80
+Xaw	_XawImSetFocusValues	82
+Xaw	_XawImUnsetFocus	84
+Xaw	_XawImWcLookupString	85
+Xaw	_XawImGetImAreaHeight	86
+Xaw	_XawImCallVendorShellExtResize	87
+Xaw	_XawImDestroy	88
+Xaw	_XawTextZapSelection	89
+Xaw	_XawTextInsertFileAction	90
+Xaw	_XawTextInsertFile	91
+Xaw	_XawTextDoSearchAction	92
+Xaw	_XawTextPopdownSearchAction	93
+Xaw	_XawTextSearch	94
+Xaw	_XawTextDoReplaceAction	95
+Xaw	_XawTextSetField	96
+Xaw	asciiSrcObjectClass	100
+Xaw	asciiSrcClassRec	101
+Xaw	dialogWidgetClass	102
+Xaw	dialogClassRec	103
+Xaw	formWidgetClass	104
+Xaw	formClassRec	105
+Xaw	listWidgetClass	106
+Xaw	listClassRec	107
+Xaw	multiSinkObjectClass	108
+Xaw	multiSinkClassRec	109
+Xaw	multiSrcObjectClass	110
+Xaw	multiSrcClassRec	111
+Xaw	panedWidgetClass	112
+Xaw	panedClassRec	113
+Xaw	scrollbarWidgetClass	114
+Xaw	scrollbarClassRec	115
+Xaw	simpleMenuWidgetClass	116
+Xaw	simpleMenuClassRec	117
+Xaw	FMT8BIT	118
+Xaw	XawFmt8Bit	119
+Xaw	XawFmtWide	120
+Xaw	_XawTextActionsTable	121
+Xaw	_XawTextActionsTableCount	122
+Xaw	textWidgetClass	123
+Xaw	textClassRec	124
+Xaw	textSinkObjectClass	125
+Xaw	textSinkClassRec	126
+Xaw	toggleWidgetClass	127
+Xaw	toggleClassRec	128
+Xaw	treeWidgetClass	129
+Xaw	treeClassRec	130
+Xaw	viewportWidgetClass	131
+Xaw	viewportClassRec	132
+Xaw	menuButtonClassRec	133
+Xaw	menuButtonWidgetClass	134
+Xaw	smeBSBClassRec	135
+Xaw	smeBSBObjectClass	136
+Xaw	smeLineClassRec	137
+Xaw	smeLineObjectClass	138
+Xaw	labelClassRec	139
+Xaw	labelWidgetClass	140
+Xaw	commandClassRec	141
+Xaw	commandWidgetClass	142
+Xaw	boxClassRec	143
+Xaw	boxWidgetClass	144
+Xaw	simpleClassRec	145
+Xaw	simpleWidgetClass	146
+Xaw	XawInitializeWidgetSet	147
+Xaw	asciiTextClassRec	148
+Xaw	asciiTextWidgetClass	149
+Xaw	portholeClassRec	150
+Xaw	portholeWidgetClass	151
+Xaw	pannerClassRec	152
+Xaw	pannerWidgetClass	153
+Xaw	textSrcClassRec	154
+Xaw	textSrcObjectClass	155
+Xaw	gripWidgetClass	156
+Xaw	XawWidgetArray	157
+Xaw	XawWidgetCount	158
+Xaw	XawPanedAllowResize	159
+Xaw	_XawTextNeedsUpdating	160
+Xaw	_XawTextGetText	161
+Xaw	_XawTextSetScrollBars	162
+Xaw	_XawTextVScroll	163
+Xaw	_XawTextReplace	164
+Xaw	_XawTextClearAndCenterDisplay	165
+Xaw	_XawTextCheckResize	166
+Xaw	_XawTextSelectionList	167
+Xaw	_XawTextSetSelection	168
+Xaw	_XawTextAlterSelection	169
+Xaw	_XawTextPrepareToUpdate	170
+Xaw	_XawTextShowPosition	171
+Xaw	_XawTextExecuteUpdate	172
+Xaw	XawVendorShellExtResize	173
+Xaw	asciiSinkClassRec	174
+Xaw	asciiSinkObjectClass	175
+Xaw	gripClassRec	176
+Xaw	vPanedWidgetClass	177
+Xaw	repeaterClassRec	178
+Xaw	repeaterWidgetClass	179
+Xaw	smeClassRec	180
+Xaw	smeObjectClass	181
+Xaw	stripChartClassRec	182
+Xaw	stripChartWidgetClass	183
+Xaw	_XawDefaultTextTranslations1	184
+Xaw	_XawDefaultTextTranslations2	185
+Xaw	_XawDefaultTextTranslations3	186
+Xaw	vendorShellClassRec	187
+Xaw	_XawVendorShellClassRec	187
+Xaw	vendorShellWidgetClass	188
+Xaw	_XawDefaultTextTranslations4	189
+Xaw	_XawDefaultTextTranslations	190
+Xaw	_XawTextSrcUndo	191
+Xaw	tipClassRec	192
+Xaw	tipWidgetClass	193
+Xaw	XawTipEnable	194
+Xaw	XawTipDisable	195
+Xaw	XawTextSinkConvertPropertyList	196
+Xaw	XawTextGetSink	197
+Xaw	XawTextSourceClearEntities	198
+Xaw	XawTextSourceFindAnchor	199
+Xaw	XawTextSourcePrevAnchor	200
+Xaw	XawTextSourceNextAnchor	201
+Xaw	XawTextSourceAnchorAndEntity	202
+Xaw	XawTextSourceAddEntity	203
+;4.x export starting from 250
+Xaw	xawvendorShellExtClassRec 250
+Xaw	xawvendorShellExtWidgetClass 251
+Xaw	XawTextSinkCopyProperty	252
+Xaw	XawTextSinkGetProperty	253
+Xaw	XawTextSinkCombineProperty	254
+Xaw	XawTextSinkAddProperty	255
+
+LIBRARY Xaw6 Xaw6 INITINSTANCE TERMINSTANCE
+Xaw6	XawAsciiSourceFreeString	1
+Xaw6	XawAsciiSave	2
+Xaw6	XawAsciiSaveAsFile	3
+Xaw6	XawAsciiSourceChanged	4
+Xaw6	XawDialogAddButton	5
+Xaw6	XawDialogGetValueString	6
+Xaw6	XawFormDoLayout	7	
+Xaw6	XawListChange	8
+Xaw6	XawListUnhighlight	9
+Xaw6	XawListHighlight	10
+Xaw6	XawListShowCurrent	11
+Xaw6	XawPanedSetMinMax	13
+Xaw6	XawPanedGetMinMax	14
+Xaw6	XawPanedSetRefigureMode	15
+Xaw6	XawPanedGetNumSub	16
+Xaw6	XawScrollbarSetThumb	18
+Xaw6	XawSimpleMenuAddGlobalActions	19
+Xaw6	XawSimpleMenuGetActiveEntry	20
+Xaw6	XawSimpleMenuClearActiveEntry	21
+Xaw6	XawTextDisplay	22
+Xaw6	XawTextEnableRedisplay	23
+Xaw6	XawTextDisableRedisplay	24
+Xaw6	XawTextSetSelectionArray	25
+Xaw6	XawTextGetSelectionPos	26
+Xaw6	XawTextSetSource	27
+Xaw6	XawTextReplace	28
+Xaw6	XawTextTopPosition	29
+Xaw6	XawTextSetInsertionPoint	30
+Xaw6	XawTextGetInsertionPoint	31
+Xaw6	XawTextUnsetSelection	32
+Xaw6	XawTextSetSelection	33
+Xaw6	XawTextInvalidate	34
+Xaw6	XawTextGetSource	35
+Xaw6	XawTextSearch	36
+Xaw6	XawTextDisplayCaret	37
+Xaw6	XawTextSinkDisplayText	38
+Xaw6	XawTextSinkInsertCursor	39
+Xaw6	XawTextSinkClearToBackground	40
+Xaw6	XawTextSinkFindPosition	41
+Xaw6	XawTextSinkFindDistance	42
+Xaw6	XawTextSinkResolve	43
+Xaw6	XawTextSinkMaxLines	44
+Xaw6	XawTextSinkMaxHeight	45
+Xaw6	XawTextSinkSetTabs	46
+Xaw6	XawTextSinkGetCursorBounds	47
+Xaw6	XawTextSourceRead	48
+Xaw6	XawTextSourceReplace	49
+Xaw6	XawTextSourceScan	50
+Xaw6	XawTextSourceSearch	51
+Xaw6	XawTextSourceConvertSelection	52
+Xaw6	XawTextSourceSetSelection	53
+Xaw6	XawToggleChangeRadioGroup	54
+Xaw6	XawToggleGetCurrent	55
+Xaw6	XawToggleSetCurrent	56
+Xaw6	XawToggleUnsetCurrent	57
+Xaw6	XawTreeForceLayout	58
+Xaw6	XawViewportSetLocation	59
+Xaw6	XawViewportSetCoordinates	60
+Xaw6	_XawMultiSinkPosToXY	61
+Xaw6	_XawMultiSave	62
+Xaw6	_XawMultiSaveAsFile	63
+Xaw6	_XawMultiSourceFreeString	64
+Xaw6	_XawTextFormat	65
+Xaw6	_XawTextBuildLineTable	66
+Xaw6	_XawTextGetSTRING	67
+Xaw6	_XawTextSaltAwaySelection	68
+Xaw6	_XawTextPosToXY	69
+Xaw6	_XawTextWCToMB	70
+Xaw6	_XawTextMBToWC	71
+Xaw6	_Xaw_atowc	72
+Xaw6	_XawImResizeVendorShell	73
+Xaw6	_XawImGetShellHeight	74
+Xaw6	_XawImRealize	75
+Xaw6	_XawImInitialize	76
+Xaw6	_XawImReconnect	77
+Xaw6	_XawImRegister	78
+Xaw6	_XawImUnregister	79
+Xaw6	_XawImSetValues	80
+Xaw6	_XawImSetFocusValues	82
+Xaw6	_XawImUnsetFocus	84
+Xaw6	_XawImWcLookupString	85
+Xaw6	_XawImGetImAreaHeight	86
+Xaw6	_XawImCallVendorShellExtResize	87
+Xaw6	_XawImDestroy	88
+Xaw6	_XawTextZapSelection	89
+Xaw6	_XawTextInsertFileAction	90
+Xaw6	_XawTextInsertFile	91
+Xaw6	_XawTextDoSearchAction	92
+Xaw6	_XawTextPopdownSearchAction	93
+Xaw6	_XawTextSearch	94
+Xaw6	_XawTextDoReplaceAction	95
+Xaw6	_XawTextSetField	96
+Xaw6	asciiSrcObjectClass	100
+Xaw6	asciiSrcClassRec	101
+Xaw6	dialogWidgetClass	102
+Xaw6	dialogClassRec	103
+Xaw6	formWidgetClass	104
+Xaw6	formClassRec	105
+Xaw6	listWidgetClass	106
+Xaw6	listClassRec	107
+Xaw6	multiSinkObjectClass	108
+Xaw6	multiSinkClassRec	109
+Xaw6	multiSrcObjectClass	110
+Xaw6	multiSrcClassRec	111
+Xaw6	panedWidgetClass	112
+Xaw6	panedClassRec	113
+Xaw6	scrollbarWidgetClass	114
+Xaw6	scrollbarClassRec	115
+Xaw6	simpleMenuWidgetClass	116
+Xaw6	simpleMenuClassRec	117
+Xaw6	FMT8BIT	118
+Xaw6	XawFmt8Bit	119
+Xaw6	XawFmtWide	120
+Xaw6	_XawTextActionsTable	121
+Xaw6	_XawTextActionsTableCount	122
+Xaw6	textWidgetClass	123
+Xaw6	textClassRec	124
+Xaw6	textSinkObjectClass	125
+Xaw6	textSinkClassRec	126
+Xaw6	toggleWidgetClass	127
+Xaw6	toggleClassRec	128
+Xaw6	treeWidgetClass	129
+Xaw6	treeClassRec	130
+Xaw6	viewportWidgetClass	131
+Xaw6	viewportClassRec	132
+Xaw6	menuButtonClassRec	133
+Xaw6	menuButtonWidgetClass	134
+Xaw6	smeBSBClassRec	135
+Xaw6	smeBSBObjectClass	136
+Xaw6	smeLineClassRec	137
+Xaw6	smeLineObjectClass	138
+Xaw6	labelClassRec	139
+Xaw6	labelWidgetClass	140
+Xaw6	commandClassRec	141
+Xaw6	commandWidgetClass	142
+Xaw6	boxClassRec	143
+Xaw6	boxWidgetClass	144
+Xaw6	simpleClassRec	145
+Xaw6	simpleWidgetClass	146
+Xaw6	XawInitializeWidgetSet	147
+Xaw6	asciiTextClassRec	148
+Xaw6	asciiTextWidgetClass	149
+Xaw6	portholeClassRec	150
+Xaw6	portholeWidgetClass	151
+Xaw6	pannerClassRec	152
+Xaw6	pannerWidgetClass	153
+Xaw6	textSrcClassRec	154
+Xaw6	textSrcObjectClass	155
+Xaw6	gripWidgetClass	156
+Xaw6	XawWidgetArray	157
+Xaw6	XawWidgetCount	158
+Xaw6	XawPanedAllowResize	159
+Xaw6	_XawTextNeedsUpdating	160
+Xaw6	_XawTextGetText	161
+Xaw6	_XawTextSetScrollBars	162
+Xaw6	_XawTextVScroll	163
+Xaw6	_XawTextReplace	164
+Xaw6	_XawTextClearAndCenterDisplay	165
+Xaw6	_XawTextCheckResize	166
+Xaw6	_XawTextSelectionList	167
+Xaw6	_XawTextSetSelection	168
+Xaw6	_XawTextAlterSelection	169
+Xaw6	_XawTextPrepareToUpdate	170
+Xaw6	_XawTextShowPosition	171
+Xaw6	_XawTextExecuteUpdate	172
+Xaw6	XawVendorShellExtResize	173
+Xaw6	asciiSinkClassRec	174
+Xaw6	asciiSinkObjectClass	175
+Xaw6	gripClassRec	176
+Xaw6	vPanedWidgetClass	177
+Xaw6	repeaterClassRec	178
+Xaw6	repeaterWidgetClass	179
+Xaw6	smeClassRec	180
+Xaw6	smeObjectClass	181
+Xaw6	stripChartClassRec	182
+Xaw6	stripChartWidgetClass	183
+Xaw6	_XawDefaultTextTranslations1	184
+Xaw6	_XawDefaultTextTranslations2	185
+Xaw6	_XawDefaultTextTranslations3	186
+Xaw6	vendorShellClassRec	187
+Xaw6	_XawVendorShellClassRec	187
+Xaw6	vendorShellWidgetClass	188
+Xaw6	_XawDefaultTextTranslations4	189
+Xaw6	_XawDefaultTextTranslations	190
+Xaw6	_XawTextSrcUndo	191
+Xaw6	tipClassRec	192
+Xaw6	tipWidgetClass	193
+Xaw6	XawTipEnable	194
+Xaw6	XawTipDisable	195
+Xaw6	XawTextSinkConvertPropertyList	196
+Xaw6	XawTextGetSink	197
+Xaw6	XawTextSourceClearEntities	198
+Xaw6	XawTextSourceFindAnchor	199
+Xaw6	XawTextSourcePrevAnchor	200
+Xaw6	XawTextSourceNextAnchor	201
+Xaw6	XawTextSourceAnchorAndEntity	202
+Xaw6	XawTextSourceAddEntity	203
+LIBRARY Xext Xext 
+Xext	XMITMiscGetBugMode	1
+Xext	XMITMiscQueryExtension	2
+Xext	XMITMiscSetBugMode	3
+Xext	XMissingExtension	4
+Xext	XSetExtensionErrorHandler	5
+Xext	XShapeCombineMask	6
+Xext	XShapeCombineRectangles	7
+Xext	XShapeCombineRegion	8
+Xext	XShapeCombineShape	9
+Xext	XShapeGetRectangles	10
+Xext	XShapeInputSelected	11
+Xext	XShapeOffsetShape	12
+Xext	XShapeQueryExtension	13
+Xext	XShapeQueryExtents	14
+Xext	XShapeQueryVersion	15
+Xext	XShapeSelectInput	16
+Xext	XSyncAwait	17
+Xext	XSyncChangeAlarm	18
+Xext	XSyncChangeCounter	19
+Xext	XSyncCreateAlarm	20
+Xext	XSyncCreateCounter	21
+Xext	XSyncDestroyAlarm	22
+Xext	XSyncDestroyCounter	23
+Xext	XSyncFreeSystemCounterList	24
+Xext	XSyncGetPriority	25
+Xext	XSyncInitialize	26
+Xext	XSyncIntToValue	27
+Xext	XSyncIntsToValue	28
+Xext	XSyncListSystemCounters	29
+Xext	XSyncMaxValue	30
+Xext	XSyncMinValue	31
+Xext	XSyncQueryAlarm	32
+Xext	XSyncQueryCounter	33
+Xext	XSyncQueryExtension	34
+Xext	XSyncSetCounter	35
+Xext	XSyncSetPriority	36
+Xext	XSyncValueAdd	37
+Xext	XSyncValueEqual	38
+Xext	XSyncValueGreaterOrEqual	39
+Xext	XSyncValueGreaterThan	40
+Xext	XSyncValueHigh32	41
+Xext	XSyncValueIsNegative	42
+Xext	XSyncValueIsPositive	43
+Xext	XSyncValueIsZero	44
+Xext	XSyncValueLessOrEqual	45
+Xext	XSyncValueLessThan	46
+Xext	XSyncValueLow32	47
+Xext	XSyncValueSubtract	48
+Xext	XTestFakeInput	49
+Xext	XTestFlush	50
+Xext	XTestGetInput	51
+Xext	XTestMovePointer	52
+Xext	XTestPressButton	53
+Xext	XTestPressKey	54
+Xext	XTestQueryInputSize	55
+Xext	XTestReset	56
+Xext	XTestStopInput	57
+Xext	XextAddDisplay	58
+Xext	XextCreateExtension	59
+Xext	XextDestroyExtension	60
+Xext	XextFindDisplay	61
+Xext	XextRemoveDisplay	62
+Xext	XmbufChangeBufferAttributes	63
+Xext	XmbufChangeWindowAttributes	64
+Xext	XmbufClearBufferArea	65
+Xext	XmbufCreateBuffers	66
+Xext	XmbufCreateStereoWindow	67
+Xext	XmbufDestroyBuffers	68
+Xext	XmbufDisplayBuffers	69
+Xext	XmbufGetBufferAttributes	70
+Xext	XmbufGetScreenInfo	71
+Xext	XmbufGetVersion	72
+Xext	XmbufGetWindowAttributes	73
+Xext	XmbufQueryExtension	74
+Xext	XdbeQueryExtension	75
+Xext	XdbeAllocateBackBufferName	76
+Xext	XdbeDeallocateBackBufferName	77
+Xext	XdbeSwapBuffers	78
+Xext	XdbeBeginIdiom	79
+Xext	XdbeEndIdiom	80
+Xext	XdbeGetVisualInfo	81
+Xext	XdbeFreeVisualInfo	82
+Xext	XdbeGetBackBufferAttributes	83
+Xext	XSecurityQueryExtension	84
+Xext	XSecurityAllocXauth	85
+Xext	XSecurityFreeXauth	86
+Xext	XSecurityGenerateAuthorization	87
+Xext	XSecurityRevokeAuthorization	88
+Xext	XagQueryVersion	89
+Xext	XagCreateEmbeddedApplicationGroup	90
+Xext	XagCreateNonembeddedApplicationGroup	91
+Xext	XagDestroyApplicationGroup	92
+Xext	XagGetApplicationGroupAttributes	93
+Xext	XagQueryApplicationGroup	94
+Xext	XagCreateAssociation	95
+Xext	XagDestroyAssociation	96
+Xext	XLbxQueryExtension	97
+Xext	XLbxGetEventBase	98
+Xext	XLbxQueryVersion	99
+Xext	XShmQueryExtension	100
+Xext	XShmGetEventBase	101
+Xext	XShmQueryVersion	102
+Xext	XShmPixmapFormat	103
+Xext	XShmAttach	104
+Xext	XShmDetach	105
+Xext	XShmCreateImage	106
+Xext	XShmPutImage	107
+Xext	XShmGetImage	108
+Xext	XShmCreatePixmap	109
+Xext	XcupGetReservedColormapEntries	110
+Xext	XcupQueryVersion	111
+Xext	XcupStoreColors	112
+Xext	XPanoramiXQueryVersion	113
+Xext	XPanoramiXAllocInfo	114
+Xext	XPanoramiXGetScreenCount	115
+Xext	XPanoramiXGetScreenSize	116
+Xext	XPanoramiXGetState	117
+Xext	XPanoramiXQueryExtension	118
+Xext	DPMSQueryExtension	119
+Xext	DPMSGetVersion	120
+Xext	DPMSCapable	121
+Xext	DPMSSetTimeouts	122
+Xext	DPMSGetTimeouts	123
+Xext	DPMSEnable	124
+Xext	DPMSDisable	125
+Xext	DPMSForceLevel	126
+Xext	DPMSInfo	127
+Xext	XeviQueryExtension	128
+Xext	XeviQueryVersion	129
+Xext	XeviGetVisualInfo	130
+LIBRARY Xi Xi
+Xi	XAllowDeviceEvents	1
+Xi	XChangeDeviceControl	2
+Xi	XChangeDeviceDontPropagateList	3
+Xi	XChangeDeviceKeyMapping	4
+Xi	XChangeFeedbackControl	5
+Xi	XChangeKeyboardDevice	6
+Xi	XChangePointerDevice	7
+Xi	XCloseDevice	8
+Xi	XDeviceBell	9
+Xi	XFreeDeviceControl	10
+Xi	XFreeDeviceList	11
+Xi	XFreeDeviceMotionEvents	12
+Xi	XFreeDeviceState	13
+Xi	XFreeFeedbackList	14
+Xi	XGetDeviceButtonMapping	15
+Xi	XGetDeviceControl	16
+Xi	XGetDeviceDontPropagateList	17
+Xi	XGetDeviceFocus	18
+Xi	XGetDeviceKeyMapping	19
+Xi	XGetDeviceModifierMapping	20
+Xi	XGetDeviceMotionEvents	21
+Xi	XGetExtensionVersion	22
+Xi	XGetFeedbackControl	23
+Xi	XGetSelectedExtensionEvents	24
+Xi	XGrabDevice	25
+Xi	XGrabDeviceButton	26
+Xi	XGrabDeviceKey	27
+Xi	XListInputDevices	28
+Xi	XOpenDevice	29
+Xi	XQueryDeviceState	30
+Xi	XSelectExtensionEvent	31
+Xi	XSendExtensionEvent	32
+Xi	XSetDeviceButtonMapping	33
+Xi	XSetDeviceFocus	34
+Xi	XSetDeviceMode	35
+Xi	XSetDeviceModifierMapping	36
+Xi	XSetDeviceValuators	37
+Xi	XUngrabDevice	38
+Xi	XUngrabDeviceButton	39
+Xi	XUngrabDeviceKey	40
+Xi	_xibadclass	41
+Xi	_xibaddevice	42
+Xi	_xibadevent	43
+Xi	_xibadmode	44
+Xi	_xidevicebusy	45
+LIBRARY Xmu Xmu
+Xmu	XmuGetAtomName	1
+Xmu	XmuInternAtom	2
+Xmu	XmuInternStrings	3
+Xmu	XmuMakeAtom	4
+Xmu	XmuNameOfAtom	5
+Xmu	XmuCopyISOLatin1Lowered	6
+Xmu	XmuCopyISOLatin1Uppered	7
+Xmu	XmuCompareISOLatin1	8
+Xmu	XmuAddCloseDisplayHook	9
+Xmu	XmuLookupCloseDisplayHook	10
+Xmu	XmuRemoveCloseDisplayHook	11
+Xmu	XmuCvtFunctionToCallback	12
+Xmu	XmuCvtStringToBackingStore	13
+Xmu	XmuCvtStringToCursor	14
+Xmu	XmuCvtStringToColorCursor	15
+Xmu	XmuCvtStringToGravity	16
+Xmu	XmuCvtStringToJustify	17
+Xmu	XmuCvtStringToLong	18
+Xmu	XmuCvtStringToOrientation	19
+Xmu	XmuCvtStringToBitmap	20
+Xmu	XmuCvtStringToShapeStyle	21
+Xmu	XmuReshapeWidget	22
+Xmu	XmuCvtStringToWidget	23
+Xmu	XmuNewCvtStringToWidget	24
+Xmu	XmuCursorNameToIndex	25
+Xmu	XmuDQCreate	26
+Xmu	XmuDQDestroy	27
+Xmu	XmuDQLookupDisplay	28
+Xmu	XmuDQAddDisplay	29
+Xmu	XmuDQRemoveDisplay	30
+Xmu	XmuDrawRoundedRectangle	31
+Xmu	XmuFillRoundedRectangle	32
+Xmu	XmuDrawLogo	33
+Xmu	XmuCreatePixmapFromBitmap	34
+Xmu	XmuCreateStippledPixmap	35
+Xmu	XmuReleaseStippledPixmap	36
+Xmu	XmuLocateBitmapFile	37
+Xmu	XmuLocatePixmapFile	38
+Xmu	XmuReadBitmapData	39
+Xmu	XmuReadBitmapDataFromFile	40
+Xmu	XmuPrintDefaultErrorMessage	41
+Xmu	XmuSimpleErrorHandler	42
+Xmu	XmuRegisterExternalAgent	43
+Xmu	XmuCallInitializers	44
+Xmu	XmuAddInitializer	45
+Xmu	XmuAllStandardColormaps	46
+Xmu	XmuCreateColormap	47
+Xmu	XmuDeleteStandardColormap	48
+Xmu	XmuGetColormapAllocation	49
+Xmu	XmuLookupStandardColormap	50
+Xmu	XmuStandardColormap	51
+Xmu	XmuVisualStandardColormaps	52
+Xmu	XmuConvertStandardSelection	53
+Xmu	XmuGetHostname	54
+Xmu	XmuWnInitializeNodes	55
+Xmu	XmuWnFetchResources	56
+Xmu	XmuWnCountOwnedResources	57
+Xmu	XmuWnNameToNode	58
+Xmu	XmuClientWindow	59
+Xmu	XmuUpdateMapHints	60
+Xmu	XmuScreenOfWindow	61
+Xmu	XctCreate	62
+Xmu	XctNextItem	63
+Xmu	XctFree	64
+Xmu	XctReset	65
+Xmu	_XmuCCLookupDisplay	66
+Xmu	_XEditResCheckMessages	67 
+Xmu	_XEditResPutString8	68
+Xmu	_XEditResPut8	69
+Xmu	_XEditResPut16	70
+Xmu	_XEditResPut32	71
+Xmu	_XEditResPutWidgetInfo	72
+Xmu	_XEditResResetStream	74
+Xmu	_XEditResGet8	75
+Xmu	_XEditResGet16	76
+Xmu	_XEditResGetSigned16	77
+Xmu	_XEditResGet32	78
+Xmu	_XEditResGetString8	79
+Xmu	_XEditResGetWidgetInfo	80
+Xmu	_XA_ATOM_PAIR	81
+Xmu	_XA_CHARACTER_POSITION	82
+Xmu	_XA_CLASS	83
+Xmu	_XA_CLIENT_WINDOW	84
+Xmu	_XA_CLIPBOARD	85
+Xmu	_XA_COMPOUND_TEXT	86
+Xmu	_XA_DECNET_ADDRESS	87
+Xmu	_XA_DELETE	88
+Xmu	_XA_FILENAME	89
+Xmu	_XA_HOSTNAME	90
+Xmu	_XA_IP_ADDRESS	91
+Xmu	_XA_LENGTH	92
+Xmu	_XA_LIST_LENGTH	93
+Xmu	_XA_NAME	94
+Xmu	_XA_NET_ADDRESS	95
+Xmu	_XA_NULL	96
+Xmu	_XA_OWNER_OS	97
+Xmu	_XA_SPAN	98
+Xmu	_XA_TARGETS	99
+Xmu	_XA_TEXT	100
+Xmu	_XA_TIMESTAMP	101
+Xmu	_XA_USER	102
+Xmu	XmuDistinguishableColors	103
+Xmu	XmuDistinguishablePixels	104
+Xmu	XmuCvtWidgetToString	105
+Xmu	XmuCvtGravityToString	106
+Xmu	XmuDestroySegmentList	107
+Xmu	XmuCvtJustifyToString	108
+Xmu	XmuSnprintf	109
+Xmu	XmuAreaOrXor	110
+Xmu	XmuDestroyScanlineList	111
+Xmu	XmuScanlineXor	112
+Xmu	XmuNewScanline	113
+Xmu	XmuNCopyISOLatin1Lowered	114
+Xmu	XmuNCopyISOLatin1Uppered	115
+Xmu	XmuCvtShapeStyleToString	116
+Xmu	XmuCvtOrientationToString	117
+Xmu	XmuCvtBackingStoreToString	118
+Xmu	XmuNewArea	119
+Xmu	XmuScanlineOrSegment	120
+Xmu	XmuOptimizeScanline	121
+; 4.x export starting from	150
+Xmu	_XmuStringToBitmapFreeCache 150
+Xmu	_XmuStringToBitmapInitCache 151
+Xmu	XmuLookupAPL	152
+Xmu	XmuLookupArabic	153
+Xmu	XmuLookupCyrillic	154
+Xmu	XmuLookupGreek	155
+Xmu	XmuLookupHebrew	156
+Xmu	XmuLookupJISX0201	157
+Xmu	XmuLookupKana	158
+Xmu	XmuLookupLatin1	159
+Xmu	XmuLookupLatin2	160
+Xmu	XmuLookupLatin3	161
+Xmu	XmuLookupLatin4	162
+Xmu	XmuLookupString	163
+Xmu	_XA_UTF8_STRING	164
+Xmu	XmuScanlineNot	165
+Xmu	XmuScanlineAnd	166
+Xmu	XmuScanlineOr	167
+LIBRARY Xp Xp
+Xp	XpCancelDoc	1
+Xp	XpCancelJob	2
+Xp	XpCancelPage	3
+Xp	XpCreateContext	4
+Xp	XpDestroyContext	5
+Xp	XpEndDoc	6
+Xp	XpEndJob	7
+Xp	XpEndPage	8
+Xp	XpFreePrinterList	9
+Xp	XpGetAttributes	10
+Xp	XpGetAuthParams	11
+Xp	XpGetContext	12
+Xp	XpGetDocumentData	13
+Xp	XpGetLocaleHinter	14
+Xp	XpGetLocaleNetString	15
+Xp	XpGetOneAttribute	16
+Xp	XpGetPageDimensions	17
+Xp	XpGetPdmStartParams	18
+Xp	XpGetPrinterList	19
+Xp	XpGetScreenOfContext	20
+Xp	XpInputSelected	21
+Xp	XpNotifyPdm	22
+Xp	XpPutDocumentData	23
+Xp	XpQueryExtension	24
+Xp	XpQueryScreens	25
+Xp	XpQueryVersion	26
+Xp	XpRehashPrinterList	27
+Xp	XpSelectInput	28
+Xp	XpSendAuth	29
+Xp	XpSendOneTicket	30
+Xp	XpSetAttributes	31
+Xp	XpSetContext	32
+Xp	XpSetLocaleHinter	33
+Xp	XpStartDoc	34
+Xp	XpStartJob	35
+Xp	XpStartPage	36
+; 4.x exports starting from 40
+Xp	XpSetImageResolution 40
+LIBRARY Xpm Xpm
+Xpm	XpmCreatePixmapFromData	1
+Xpm	XpmCreateDataFromPixmap	2
+Xpm	XpmReadFileToPixmap	3
+Xpm	XpmWriteFileFromPixmap	4
+Xpm	XpmCreateImageFromData	5
+Xpm	XpmCreateDataFromImage	6
+Xpm	XpmReadFileToImage	7
+Xpm	XpmWriteFileFromImage	8
+Xpm	XpmCreateImageFromBuffer	9
+Xpm	XpmCreatePixmapFromBuffer	10
+Xpm	XpmCreateBufferFromImage	11
+Xpm	XpmCreateBufferFromPixmap	12
+Xpm	XpmReadFileToBuffer	13
+Xpm	XpmWriteFileFromBuffer	14
+Xpm	XpmReadFileToData	15
+Xpm	XpmWriteFileFromData	16
+Xpm	XpmAttributesSize	17
+Xpm	XpmFreeAttributes	18
+Xpm	XpmFreeExtensions	19
+Xpm	XpmFreeXpmImage	20
+Xpm	XpmFreeXpmInfo	21
+Xpm	XpmGetErrorString	22
+Xpm	XpmLibraryVersion	23
+Xpm	XpmReadFileToXpmImage	24
+Xpm	XpmWriteFileFromXpmImage	25
+Xpm	XpmCreatePixmapFromXpmImage	26
+Xpm	XpmCreateImageFromXpmImage	27
+Xpm	XpmCreateXpmImageFromImage	28
+Xpm	XpmCreateXpmImageFromPixmap	29
+Xpm	XpmCreateDataFromXpmImage	30
+Xpm	XpmCreateXpmImageFromData	31
+Xpm	XpmCreateXpmImageFromBuffer	32
+Xpm	XpmCreateBufferFromXpmImage	33
+; 4.x exports starting from 40
+Xpm	XpmFree	40
+LIBRARY Xss Xss
+Xss	XScreenSaverQueryExtension	1
+Xss	XScreenSaverQueryVersion	2
+Xss	XScreenSaverAllocInfo	3
+Xss	XScreenSaverQueryInfo	4
+Xss	XScreenSaverSelectInput	5
+Xss	XScreenSaverSetAttributes	6
+Xss	XScreenSaverUnsetAttributes	7
+Xss	XScreenSaverRegister	8
+Xss	XScreenSaverUnregister	9
+Xss	XScreenSaverGetRegistered	10
+LIBRARY Xt Xt INITINSTANCE TERMINSTANCE
+Xt	XtAppAddActionHook	1
+Xt	XtRemoveActionHook	2
+Xt	XtMalloc	3
+Xt	XtRealloc	4
+Xt	XtCalloc	5
+Xt	XtFree	6
+Xt	XtMergeArgLists	7
+Xt	XtAddCallback	8
+Xt	XtAddCallbacks	9
+Xt	XtRemoveCallback	10
+Xt	XtRemoveCallbacks	11
+Xt	XtRemoveAllCallbacks	12
+Xt	XtCallCallbacks	13
+Xt	XtHasCallbacks	14
+Xt	XtCallCallbackList	15
+Xt	XtSetMultiClickTime	16
+Xt	XtGetMultiClickTime	17
+Xt	XtSetTypeConverter	18
+Xt	XtAppSetTypeConverter	19
+Xt	XtAddConverter	20
+Xt	XtAppAddConverter	21
+Xt	XtCallConverter	22
+Xt	XtConvert	23
+Xt	XtConvertAndStore	24
+Xt	XtAppReleaseCacheRefs	25
+Xt	XtCallbackReleaseCacheRefList	26
+Xt	XtCallbackReleaseCacheRef	27
+Xt	XtDisplayStringConversionWarning	28
+Xt	XtStringConversionWarning	29
+Xt	XtCvtIntToBoolean	30
+Xt	XtCvtIntToShort	31
+Xt	XtCvtStringToBoolean	32 
+Xt	XtCvtIntToBool	33
+Xt	XtCvtStringToBool	34 
+Xt	XtCvtIntToColor	35
+Xt	XtCvtStringToPixel	36
+Xt	XtCvtStringToCursor	37
+Xt	XtCvtStringToDisplay	38
+Xt	XtCvtStringToFile	39
+Xt	XtCvtIntToFloat	40
+Xt	XtCvtStringToFloat	41
+Xt	XtCvtStringToFont	42
+Xt	XtCvtIntToFont	43
+Xt	XtCvtStringToFontSet	44
+Xt	XtCvtStringToFontStruct	45
+Xt	XtCvtStringToInt	46
+Xt	XtCvtStringToShort	47
+Xt	XtCvtStringToDimension	48
+Xt	XtCvtIntToUnsignedChar	49
+Xt	XtCvtStringToUnsignedChar	50
+Xt	XtCvtColorToPixel	51
+Xt	XtCvtIntToPixel	52
+Xt	XtCvtIntToPixmap	53
+Xt	XtCvtStringToInitialState	54
+Xt	XtCvtStringToVisual	55
+Xt	XtCvtStringToAtom	56
+Xt	XtCvtStringToDirectoryString	57
+Xt	XtCvtStringToCommandArgArray	58
+Xt	XtInitializeWidgetClass	59
+Xt	XtCreateWidget	60
+Xt	XtCreateManagedWidget	61
+Xt	XtCreatePopupShell	62
+Xt	XtAppCreateShell	63
+Xt	XtCreateApplicationShell	64
+Xt	XtDestroyWidget	65
+Xt	XtOpenDisplay	66
+Xt	XtDisplayInitialize	67
+Xt	XtCreateApplicationContext	68
+Xt	XtDestroyApplicationContext	69
+Xt	XtDatabase	70
+Xt	XtDisplayToApplicationContext	71
+Xt	XtCloseDisplay	72
+Xt	XtWidgetToApplicationContext	73
+Xt	XtGetApplicationNameAndClass	74
+Xt	XtGetErrorDatabase	75
+Xt	XtAppGetErrorDatabase	76
+Xt	XtGetErrorDatabaseText	77
+Xt	XtAppGetErrorDatabaseText	78
+Xt	XtErrorMsg	79
+Xt	XtAppErrorMsg	80
+Xt	XtWarningMsg	81
+Xt	XtAppWarningMsg	82
+Xt	XtSetErrorMsgHandler	83
+Xt	XtAppSetErrorMsgHandler	84
+Xt	XtSetWarningMsgHandler	85
+Xt	XtAppSetWarningMsgHandler	86
+Xt	XtError	87
+Xt	XtAppError	88
+Xt	XtWarning	89
+Xt	XtAppWarning	90
+Xt	XtSetErrorHandler	91
+Xt	XtAppSetErrorHandler	92
+Xt	XtSetWarningHandler	93
+Xt	XtAppSetWarningHandler	94
+Xt	XtBuildEventMask	95
+Xt	XtRemoveEventHandler	96
+Xt	XtAddEventHandler	97
+Xt	XtInsertEventHandler	98
+Xt	XtRemoveRawEventHandler	99
+Xt	XtInsertRawEventHandler	100
+Xt	XtAddRawEventHandler	101
+Xt	XtWindowToWidget	102
+Xt	XtDispatchEvent	103
+Xt	XtAddGrab	104
+Xt	XtRemoveGrab	105
+Xt	XtMainLoop	106
+Xt	XtAppMainLoop	107
+Xt	XtAddExposureToRegion	108
+Xt	XtLastTimestampProcessed	109
+Xt	XtIsRectObj	110
+Xt	XtIsWidget	111
+Xt	XtIsComposite	112
+Xt	XtIsConstraint	113
+Xt	XtIsShell	114
+Xt	XtIsOverrideShell	115
+Xt	XtIsWMShell	116
+Xt	XtIsVendorShell	117
+Xt	XtIsTransientShell	118
+Xt	XtIsTopLevelShell	119
+Xt	XtIsApplicationShell	120
+Xt	XtMapWidget	121
+Xt	XtUnmapWidget	122
+Xt	XtNewString	123
+Xt	XtIsSessionShell	124
+Xt	XtAllocateGC	125
+Xt	XtGetGC	126
+Xt	XtReleaseGC	127
+Xt	XtDestroyGC	128
+Xt	XtMakeGeometryRequest	129
+Xt	XtMakeResizeRequest	130
+Xt	XtResizeWindow	131
+Xt	XtResizeWidget	132
+Xt	XtConfigureWidget	133
+Xt	XtMoveWidget	134
+Xt	XtTranslateCoords	135
+Xt	XtQueryGeometry	136
+Xt	XtGetActionKeysym	137
+Xt	XtGetResourceList	138
+Xt	XtGetConstraintResourceList	139
+Xt	XtGetValues	140
+Xt	XtGetSubvalues	141
+Xt	XtToolkitInitialize	142
+Xt	XtSetLanguageProc	143
+Xt	XtScreenDatabase	144
+Xt	XtAppSetFallbackResources	145
+Xt	XtAppInitialize	146
+Xt	XtInitialize	147
+Xt	XtOpenApplication	148
+Xt	XtIsSubclass	149
+Xt	XtRealizeWidget	150
+Xt	XtUnrealizeWidget	151
+Xt	XtCreateWindow	152
+Xt	XtNameToWidget	153
+Xt	XtDisplayOfObject	154
+Xt	XtDisplay	155
+Xt	XtScreenOfObject	156
+Xt	XtScreen	157
+Xt	XtWindowOfObject	158
+Xt	XtWindow	159
+Xt	XtSuperclass	160
+Xt	XtClass	161
+Xt	XtIsManaged	162
+Xt	XtIsRealized	163
+Xt	XtIsSensitive	164
+Xt	XtParent	165
+Xt	XtName	166
+Xt	XtIsObject	167
+Xt	XtFindFile	168
+Xt	XtResolvePathname	169
+Xt	XtCallAcceptFocus	170
+Xt	XtSetKeyboardFocus	171
+Xt	XtUnmanageChildren	172
+Xt	XtUnmanageChild	173
+Xt	XtManageChildren	174
+Xt	XtManageChild	175
+Xt	XtSetMappedWhenManaged	176
+Xt	XtAddTimeOut	177
+Xt	XtAppAddTimeOut	178
+Xt	XtRemoveTimeOut	179
+Xt	XtAddWorkProc	180
+Xt	XtAppAddWorkProc	181
+Xt	XtRemoveWorkProc	182
+Xt	XtAddInput	183
+Xt	XtAppAddInput	184
+Xt	XtRemoveInput	185
+Xt	XtNextEvent	186
+Xt	XtAppNextEvent	187
+Xt	XtProcessEvent	188
+Xt	XtAppProcessEvent	189
+Xt	XtPending	190
+Xt	XtAppPending	191
+Xt	XtPeekEvent	192
+Xt	XtAppPeekEvent	193
+Xt	XtGrabKey	194
+Xt	XtGrabButton	195
+Xt	XtUngrabKey	196
+Xt	XtUngrabButton	197
+Xt	XtGrabKeyboard	198
+Xt	XtUngrabKeyboard	199
+Xt	XtGrabPointer	200
+Xt	XtUngrabPointer	201
+Xt	XtPopup	202
+Xt	XtPopupSpringLoaded	203
+Xt	XtPopdown	204
+Xt	XtCallbackPopdown	205
+Xt	XtCallbackNone	206
+Xt	XtCallbackNonexclusive	207
+Xt	XtCallbackExclusive	208
+Xt	XtGetSubresources	209
+Xt	XtGetApplicationResources	210
+Xt	XtSetSelectionTimeout	211
+Xt	XtAppSetSelectionTimeout	212
+Xt	XtGetSelectionTimeout	213
+Xt	XtAppGetSelectionTimeout	214
+Xt	XtOwnSelection	215
+Xt	XtOwnSelectionIncremental	216
+Xt	XtDisownSelection	217
+Xt	XtGetSelectionValue	218
+Xt	XtGetSelectionValueIncremental	219
+Xt	XtGetSelectionValues	220
+Xt	XtGetSelectionValuesIncremental	221
+Xt	XtGetSelectionRequest	222
+Xt	XtSetSensitive	223
+Xt	XtSetSubvalues	224
+Xt	XtSetValues	225
+Xt	XtSetWMColormapWindows	226
+Xt	XtAddActions	227
+Xt	XtAppAddActions	228
+Xt	XtGetActionList	229
+Xt	XtMenuPopupAction	230
+Xt	XtCallActionProc	231
+Xt	XtRegisterGrabAction	232
+Xt	XtConvertCase	233
+Xt	XtTranslateKeycode	234
+Xt	XtTranslateKey	235
+Xt	XtSetKeyTranslator	236
+Xt	XtRegisterCaseConverter	237
+Xt	XtGetKeysymTable	238
+Xt	XtKeysymToKeycodeList	239
+Xt	XtCvtStringToAcceleratorTable	240
+Xt	XtCvtStringToTranslationTable	241
+Xt	XtParseAcceleratorTable	242
+Xt	XtParseTranslationTable	243
+Xt	XtUninstallTranslations	244
+Xt	XtInstallAccelerators	245
+Xt	XtInstallAllAccelerators	246
+Xt	XtAugmentTranslations	247
+Xt	XtOverrideTranslations	248
+Xt	XtVaCreateWidget	249
+Xt	XtVaCreateManagedWidget	250
+Xt	XtVaAppCreateShell	251
+Xt	XtVaCreatePopupShell	252
+Xt	XtVaSetValues	253
+Xt	XtVaSetSubvalues	254
+Xt	XtVaAppInitialize	255
+Xt	XtVaOpenApplication	256
+Xt	XtVaGetSubresources	257
+Xt	XtVaGetApplicationResources	258
+Xt	XtVaGetValues	259
+Xt	XtVaGetSubvalues	260
+Xt	XtVaCreateArgsList	261
+Xt	XtCvtStringToRestartStyle	262
+Xt	XtCvtStringToGravity	263
+Xt	XtAppSetExitFlag	264
+Xt	XtAppGetExitFlag	265
+Xt	XtGetDisplays	266
+Xt	XtRemoveEventTypeHandler	267
+Xt	XtInsertEventTypeHandler	268
+Xt	XtRegisterDrawable	269
+Xt	XtUnregisterDrawable	270
+Xt	XtDispatchEventToWidget	271
+Xt	XtLastEventProcessed	272
+Xt	XtSetEventDispatcher	273
+Xt	XtRegisterExtensionSelector	274
+Xt	XtAppAddBlockHook	275
+Xt	XtRemoveBlockHook	276
+Xt	XtHooksOfDisplay	277
+Xt	XtGetClassExtension	278
+Xt	XtGetKeyboardFocusWidget	279
+Xt	XtChangeManagedSet	280
+Xt	XtAddSignal	281
+Xt	XtAppAddSignal	282
+Xt	XtRemoveSignal	283
+Xt	XtNoticeSignal	284
+Xt	XtReservePropertyAtom	285
+Xt	XtReleasePropertyAtom	286
+Xt	XtCreateSelectionRequest	287
+Xt	XtSendSelectionRequest	288
+Xt	XtCancelSelectionRequest	289
+Xt	XtSetSelectionParameters	290
+Xt	XtGetSelectionParameters	291
+Xt	XtSessionGetToken	292
+Xt	XtSessionReturnToken	293
+Xt	XtAppLock	294
+Xt	XtAppUnlock	295
+Xt	XtProcessLock	296
+Xt	XtProcessUnlock	297
+Xt	XtToolkitThreadInitialize	298
+Xt	_XtDoFreeBindings	299
+Xt	_XtAllocError	300
+Xt	_XtHeapInit	301
+Xt	_XtHeapAlloc	302
+Xt	_XtHeapFree	303
+Xt	_XtAddCallback	304
+Xt	_XtAddCallbackOnce	305
+Xt	_XtRemoveCallback	306
+Xt	_XtRemoveAllCallbacks	307
+Xt	_XtCompileCallbackList	308
+Xt	_XtGetCallbackList	309
+Xt	_XtCallConditionalCallbackList	310
+Xt	_XtSetDefaultConverterTable	311
+Xt	_XtFreeConverterTable	312
+Xt	_XtTableAddConverter	313
+Xt	_XtCacheFlushTag	314
+Xt	_XtConvert	315
+Xt	_XtConvertInitialize	316
+Xt	_XtAddDefaultConverters	317
+Xt	_XtCreateWidget	318
+Xt	_XtCreatePopupShell	319
+Xt	_XtAppCreateShell	320
+Xt	_XtDoPhase2Destroy	321
+Xt	_XtGetProcessContext	322
+Xt	_XtDefaultAppContext	323
+Xt	_XtAppInit	324
+Xt	_XtDestroyAppContexts	325
+Xt	_XtSortPerDisplayList	326
+Xt	_XtCloseDisplays	327
+Xt	_XtDefaultErrorMsg	328
+Xt	_XtDefaultWarningMsg	329
+Xt	_XtDefaultError	330
+Xt	_XtDefaultWarning	331
+Xt	_XtSetDefaultErrorHandlers	332
+Xt	_XtAllocWWTable	333
+Xt	_XtFreeWWTable	334
+Xt	_XtConvertTypeToMask	335
+Xt	_XtOnGrabList	336
+Xt	_XtEventInitialize	337
+Xt	_XtFreeEventTable	338
+Xt	_XtSendFocusEvent	339
+Xt	_XtFreePerWidgetInput	340
+Xt	_XtGetPerWidgetInput	341
+Xt	_XtFillAncestorList	342
+Xt	_XtFindRemapWidget	343
+Xt	_XtUngrabBadGrabs	344
+Xt	_XtGClistFree	345
+Xt	_XtMakeGeometryRequest	346
+Xt	_XtInherit	347
+Xt	_XtPreparseCommandLine	348
+Xt	_XtDisplayInitialize	349
+Xt	_XtCheckSubclassFlag	350
+Xt	_XtIsSubclassOf	351
+Xt	_XtWindowedAncestor	352
+Xt	_XtProcessKeyboardEvent	353
+Xt	_XtHandleFocus	354
+Xt	_XtRemoveAllInputs	355
+Xt	_XtRefreshMapping	356
+Xt	_XtDestroyServerGrabs	357
+Xt	_XtCheckServerGrabsOnWidget	358
+Xt	_XtProcessPointerEvent	359
+Xt	_XtPopup	360
+Xt	_XtCopyFromParent	361
+Xt	_XtCopyFromArg	362
+Xt	_XtCopyToArg	363
+Xt	_XtCompileResourceList	364
+Xt	_XtDependencies	365
+Xt	_XtResourceDependencies	366
+Xt	_XtConstraintResDependencies	367
+Xt	_XtCreateIndirectionTable	368
+Xt	_XtGetResources	369
+Xt	_XtResourceListInitialize	370
+Xt	_XtSetDefaultSelectionTimeout	371
+Xt	_XtShellGetCoordinates	372
+Xt	_XtInitializeActionData	373
+Xt	_XtBindActions	374
+Xt	_XtUnbindActions	375
+Xt	_XtFreeActions	376
+Xt	_XtRegisterGrabs	377
+Xt	_XtGrabInitialize	378
+Xt	_XtComputeLateBindings	379
+Xt	_XtAllocTMContext	380
+Xt	_XtMatchUsingDontCareMods	381
+Xt	_XtMatchUsingStandardMods	382
+Xt	_XtBuildKeysymTables	383
+Xt	_XtTranslateInitialize	384
+Xt	_XtAddTMConverters	385
+Xt	_XtPrintXlations	386
+Xt	_XtDisplayTranslations	387
+Xt	_XtDisplayAccelerators	388
+Xt	_XtDisplayInstalledAccelerators	389
+Xt	_XtPrintActions	390
+Xt	_XtPrintState	391
+Xt	_XtPrintEventSeq	392
+Xt	_XtGetQuarkIndex	393
+Xt	_XtGetTypeIndex	394
+Xt	_XtGetModifierIndex	395
+Xt	_XtRegularMatch	396
+Xt	_XtMatchAtom	397
+Xt	_XtTranslateEvent	398
+Xt	_XtTraverseStateTree	399
+Xt	_XtInstallTranslations	400
+Xt	_XtRemoveTranslations	401
+Xt	_XtDestroyTMData	402
+Xt	_XtCreateXlations	403
+Xt	_XtParseTreeToStateTree	404
+Xt	_XtAddEventSeqToStateTree	405
+Xt	_XtCvtMergeTranslations	406
+Xt	_XtGetTranslationValue	407
+Xt	_XtRemoveStateTreeByIndex	408
+Xt	_XtFreeTranslations	409
+Xt	_XtMergeTranslations	410
+Xt	_XtUnmergeTranslations	411
+Xt	_XtPopupInitialize	412
+Xt	_XtVaAppInitialize	413
+Xt	_XtVaOpenApplication	414
+Xt	_XtCountVaList	415
+Xt	_XtVaCreateTypedArgList	416
+Xt	_XtVaToArgList	417
+Xt	_XtVaToTypedArgList	418
+Xt	_XtPeekCallback	419
+Xt	_XtCreateHookObj	420
+Xt	_XtGetPerDisplay	421
+Xt	_XtGetPerDisplayInput	422
+Xt	_XtExtensionSelect	423
+Xt	_XtAddShellToHookObj	424
+Xt	_XtIsHookObject	425
+Xt	_XtGetUserName	426
+Xt	_XtWaitForSomething	427
+Xt	XtDirectConvert	433
+Xt	colorConvertArgs	435
+Xt	screenConvertArg	436
+Xt	XtCXtToolkitError	437
+Xt	_XtQString	438
+Xt	_XtAppDestroyCount	439
+Xt	_XtperDisplayList	440
+Xt	_XtGlobalTM	444
+Xt	XtStrings	445
+Xt	overrideShellClassRec	446
+Xt	overrideShellWidgetClass	447
+Xt	constraintClassRec	448
+Xt	constraintWidgetClass	449
+Xt	objectClassRec	450
+Xt	objectClass	451
+Xt	widgetClassRec	452
+Xt	widgetClass	453
+Xt	rectObjClassRec	454
+Xt	rectObjClass	455
+Xt	coreWidgetClass	457
+Xt	wmShellClassRec	458
+Xt	wmShellWidgetClass	459
+Xt	XtShellStrings	460
+Xt	topLevelShellClassRec	461
+Xt	topLevelShellWidgetClass	462
+Xt	transientShellClassRec	463
+Xt	transientShellWidgetClass	464
+Xt	shellClassRec	465
+Xt	shellWidgetClass	466
+Xt	compositeClassRec	467
+Xt	compositeWidgetClass	468
+Xt	applicationShellClassRec	469
+Xt	applicationShellWidgetClass	470
+Xt	_XtInheritTranslations	471
+Xt	sessionShellClassRec	472
+Xt	sessionShellWidgetClass	473
+Xt	vendorShellClassRec	474
+Xt	vendorShellWidgetClass	475
+Xt	hookObjClassRec	476
+Xt	hookObjectClass	477
+LIBRARY Xtst Xtst
+Xtst	XTestCompareCurrentCursorWithWindow	1
+Xtst	XTestCompareCursorWithWindow	2
+Xtst	XTestDiscard	3
+Xtst	XTestFakeButtonEvent	4
+Xtst	XTestFakeDeviceButtonEvent	5
+Xtst	XTestFakeDeviceKeyEvent	6
+Xtst	XTestFakeDeviceMotionEvent	7
+Xtst	XTestFakeKeyEvent	8
+Xtst	XTestFakeMotionEvent	9
+Xtst	XTestFakeProximityEvent	10
+Xtst	XTestFakeRelativeMotionEvent	11
+Xtst	XTestGrabControl	12
+Xtst	XTestQueryExtension	13
+Xtst	XTestSetGContextOfGC	14
+Xtst	XTestSetVisualIDOfVisual	15
+Xtst	XRecordIdBaseMask	16
+Xtst	XRecordQueryVersion	17
+Xtst	XRecordCreateContext	18
+Xtst	XRecordAllocRange	19
+Xtst	XRecordRegisterClients	20
+Xtst	XRecordUnregisterClients	21
+Xtst	XRecordGetContext	22
+Xtst	XRecordFreeState	23
+Xtst	XRecordFreeData	24
+Xtst	XRecordEnableContext	25
+Xtst	XRecordEnableContextAsync	26
+Xtst	XRecordProcessReplies	27
+Xtst	XRecordDisableContext	28
+Xtst	XRecordFreeContext	29
+LIBRARY Xxf86DGA Xxf86DGA
+Xxf86DGA	XF86DGAQueryExtension	1
+Xxf86DGA	XF86DGAQueryVersion	2
+Xxf86DGA	XF86DGAGetVideoLL	3
+Xxf86DGA	XF86DGADirectVideoLL	4
+Xxf86DGA	XF86DGAGetViewPort	5
+Xxf86DGA	XF86DGASetViewPort	6
+Xxf86DGA	XF86DGAGetVidPage	7
+Xxf86DGA	XF86DGASetVidPage	8
+Xxf86DGA	XF86DGADirectVideo	9
+Xxf86DGA	XF86DGAGetVideo	10
+; 4.x exports starting from 20
+Xxf86DGA	XF86DGAQueryDirectVideo 20
+Xxf86DGA	XF86DGAInstallColormap  21 
+LIBRARY Xxf86MISC Xf86MISC
+Xxf86Misc	XF86MiscQueryExtension	1
+Xxf86Misc	XF86MiscQueryVersion	2
+Xxf86Misc	XF86MiscSetSaver	3
+Xxf86Misc	XF86MiscGetSaver	4
+LIBRARY Xxf86VM Xxf86VM
+Xxf86VM	XF86VidModeQueryExtension	1
+Xxf86VM	XF86VidModeQueryVersion	2
+Xxf86VM	XF86VidModeGetModeLine	3
+Xxf86VM	XF86VidModeModModeLine	4
+Xxf86VM	XF86VidModeSwitchMode	5
+Xxf86VM	XF86VidModeLockModeSwitch	6
+Xxf86VM	XF86VidModeGetMonitor	7
+LIBRARY dps dps
+dps	CSDPSInit	1 
+dps	CSDPSHeadOfDpyExt	2
+dps	DPSCAPChangeGC	3
+dps	DPSCAPCreate	4 
+dps	DPSCAPDestroy	5 
+dps	DPSCAPOpenAgent	6 
+dps	DPSCAPStartUp	8 
+dps	DPSCAPWrite	9 
+dps	DPSCAPCloseDisplayProc	10
+dps	DPSCAPCloseAgent	13
+dps	DPSclientsync	14
+dps	DPScurrentXgcdrawable	15
+dps	DPScurrentXgcdrawablecolor	16
+dps	DPScurrentXoffset	17
+dps	DPSsetXgcdrawable	18
+dps	DPSsetXgcdrawablecolor	19
+dps	DPSsetXoffset	20
+dps	DPSsetXrgbactual	21
+dps	DPSclientXready	22
+dps	DPSsetXdrawingfunction	23
+dps	DPScurrentXdrawingfunction	24
+dps	DPSWarnProc	25
+dps	DPSFatalProc	26
+dps	DPSCantHappen	27
+dps	DPScolorimage	28
+dps	DPScurrentblackgeneration	29
+dps	DPScurrentcmykcolor	30
+dps	DPScurrentcolorscreen	31
+dps	DPScurrentcolortransfer	32
+dps	DPScurrentundercolorremoval	33
+dps	DPSsetblackgeneration	34
+dps	DPSsetcmykcolor	35
+dps	DPSsetcolorscreen	36
+dps	DPSsetcolortransfer	37
+dps	DPSsetundercolorremoval	38
+dps	DPSeq	39
+dps	DPSexit	40
+dps	DPSfalse	41
+dps	DPSfor	42
+dps	DPSforall	43
+dps	DPSge	44
+dps	DPSgt	45
+dps	DPSif	46
+dps	DPSifelse	47
+dps	DPSle	48
+dps	DPSloop	49
+dps	DPSlt	50
+dps	DPSne	51
+dps	DPSnot	52
+dps	DPSor	53
+dps	DPSrepeat	54
+dps	DPSstop	55
+dps	DPSstopped	56
+dps	DPStrue	57
+dps	DPSUserObjects	58
+dps	DPScondition	59
+dps	DPScurrentcontext	60
+dps	DPScurrentobjectformat	61
+dps	DPSdefineusername	62
+dps	DPSdefineuserobject	63
+dps	DPSdetach	64
+dps	DPSexecuserobject	65
+dps	DPSfork	66
+dps	DPSjoin	67
+dps	DPSlock	68
+dps	DPSmonitor	69
+dps	DPSnotify	70
+dps	DPSsetobjectformat	71
+dps	DPSsetvmthreshold	72
+dps	DPSundefineuserobject	73
+dps	DPSwait	74
+dps	DPSyield	75
+dps	DPSaload	76
+dps	DPSanchorsearch	77
+dps	DPSarray	78
+dps	DPSastore	79
+dps	DPSbegin	80
+dps	DPSclear	81
+dps	DPScleartomark	82
+dps	DPScopy	83
+dps	DPScount	84
+dps	DPScounttomark	85
+dps	DPScvi	86
+dps	DPScvlit	87
+dps	DPScvn	88
+dps	DPScvr	89
+dps	DPScvrs	90
+dps	DPScvs	91
+dps	DPScvx	92
+dps	DPSdef	93
+dps	DPSdict	94
+dps	DPSdictstack	95
+dps	DPSdup	96
+dps	DPSend	97
+dps	DPSexch	98
+dps	DPSexecstack	99
+dps	DPSexecuteonly	100
+dps	DPSget	101
+dps	DPSgetinterval	102
+dps	DPSindex	103
+dps	DPSknown	104
+dps	DPSlength	105
+dps	DPSload	106
+dps	DPSmark	107
+dps	DPSmatrix	108
+dps	DPSmaxlength	109
+dps	DPSnoaccess	110
+dps	DPSnull	111
+dps	DPSpackedarray	112
+dps	DPSpop	113
+dps	DPSput	114
+dps	DPSputinterval	115
+dps	DPSrcheck	116
+dps	DPSreadonly	117
+dps	DPSroll	118
+dps	DPSscheck	119
+dps	DPSsearch	120
+dps	DPSshareddict	121
+dps	DPSstatusdict	122
+dps	DPSstore	123
+dps	DPSstring	124
+dps	DPSstringwidth	125
+dps	DPSsystemdict	126
+dps	DPSuserdict	127
+dps	DPSwcheck	128
+dps	DPSwhere	129
+dps	DPSxcheck	130
+dps	DPSCreatePSWDict	131
+dps	DPSDestroyPSWDict	132
+dps	DPSWDictLookup	133
+dps	DPSWDictEnter	134
+dps	DPSWDictRemove	135
+dps	DPSMakeAtom	136
+dps	DPSFontDirectory	137
+dps	DPSISOLatin1Encoding	138
+dps	DPSSharedFontDirectory	139
+dps	DPSStandardEncoding	140
+dps	DPScachestatus	141
+dps	DPScurrentcacheparams	142
+dps	DPScurrentfont	143
+dps	DPSdefinefont	144
+dps	DPSfindfont	145
+dps	DPSmakefont	146
+dps	DPSscalefont	147
+dps	DPSselectfont	148
+dps	DPSsetcachedevice	149
+dps	DPSsetcachelimit	150
+dps	DPSsetcacheparams	151
+dps	DPSsetcharwidth	152
+dps	DPSsetfont	153
+dps	DPSundefinefont	154
+dps	DPSconcat	155
+dps	DPScurrentdash	156
+dps	DPScurrentflat	157
+dps	DPScurrentgray	158
+dps	DPScurrentgstate	159
+dps	DPScurrenthalftone	160
+dps	DPScurrenthalftonephase	161
+dps	DPScurrenthsbcolor	162
+dps	DPScurrentlinecap	163
+dps	DPScurrentlinejoin	164
+dps	DPScurrentlinewidth	165
+dps	DPScurrentmatrix	166
+dps	DPScurrentmiterlimit	167
+dps	DPScurrentpoint	168
+dps	DPScurrentrgbcolor	169
+dps	DPScurrentscreen	170
+dps	DPScurrentstrokeadjust	171
+dps	DPScurrenttransfer	172
+dps	DPSdefaultmatrix	173
+dps	DPSgrestore	174
+dps	DPSgrestoreall	175
+dps	DPSgsave	176
+dps	DPSgstate	177
+dps	DPSinitgraphics	178
+dps	DPSinitmatrix	179
+dps	DPSrotate	180
+dps	DPSscale	181
+dps	DPSsetdash	182
+dps	DPSsetflat	183
+dps	DPSsetgray	184
+dps	DPSsetgstate	185
+dps	DPSsethalftone	186
+dps	DPSsethalftonephase	187
+dps	DPSsethsbcolor	188
+dps	DPSsetlinecap	189
+dps	DPSsetlinejoin	190
+dps	DPSsetlinewidth	191
+dps	DPSsetmatrix	192
+dps	DPSsetmiterlimit	193
+dps	DPSsetrgbcolor	194
+dps	DPSsetscreen	195
+dps	DPSsetstrokeadjust	196
+dps	DPSsettransfer	197
+dps	DPStranslate	198
+dps	DPSclientPrintProc	199
+dps	DPSinnerProcWriteData	200
+dps	DPSSafeSetLastNameIndex	201
+dps	DPSCheckInitClientGlobals  202
+dps	DPSPrivateCheckWait	203
+dps	DPSPrivateDestroyContext	204
+dps	DPSPrivateDestroySpace	205
+dps	DPSCheckShared	206
+dps	DPSDefaultPrivateHandler	207
+dps	DPSCreateContext	208
+dps	DPSInitCommonTextContextProcs	209
+dps	DPSInitCommonContextProcs	210
+dps	DPSInitPrivateContextProcs	211
+dps	DPSInitPrivateContextFields	212
+dps	DPSInitPrivateTextContextFields	213
+dps	DPSInitCommonSpaceProcs	214
+dps	DPSInitPrivateSpaceFields	215
+dps	DPSequals	216
+dps	DPSequalsequals	217
+dps	DPSbytesavailable	218
+dps	DPSclosefile	219
+dps	DPScurrentfile	220
+dps	DPSdeletefile	221
+dps	DPSecho	222
+dps	DPSfile	223
+dps	DPSfilenameforall	224
+dps	DPSfileposition	225
+dps	DPSflush	226
+dps	DPSflushfile	227
+dps	DPSprint	228
+dps	DPSprintobject	229
+dps	DPSpstack	230
+dps	DPSread	231
+dps	DPSreadhexstring	232
+dps	DPSreadline	233
+dps	DPSreadstring	234
+dps	DPSrenamefile	235
+dps	DPSresetfile	236
+dps	DPSsetfileposition	237
+dps	DPSstack	238
+dps	DPSstatus	239
+dps	DPStoken	240
+dps	DPSwrite	241
+dps	DPSwritehexstring	242
+dps	DPSwriteobject	243
+dps	DPSwritestring	244
+dps	DPSleftbracket	245
+dps	DPSrightbracket	246
+dps	DPSleftleft	247
+dps	DPSrightright	248
+dps	DPScshow	249
+dps	DPScurrentcolor	250
+dps	DPScurrentcolorrendering	251
+dps	DPScurrentcolorspace	252
+dps	DPScurrentdevparams	253
+dps	DPScurrentglobal	254
+dps	DPScurrentoverprint	255
+dps	DPScurrentpagedevice	256
+dps	DPScurrentsystemparams	257
+dps	DPScurrentuserparams	258
+dps	DPSdefineresource	259
+dps	DPSexecform	260
+dps	DPSfilter	261
+dps	DPSfindencoding	262
+dps	DPSfindresource	263
+dps	DPSgcheck	264
+dps	DPSglobaldict	265
+dps	DPSGlobalFontDirectory	266
+dps	DPSglyphshow	267
+dps	DPSlanguagelevel	268
+dps	DPSmakepattern	269
+dps	DPSproduct	270
+dps	DPSresourceforall	271
+dps	DPSresourcestatus	272
+dps	DPSrevision	273
+dps	DPSrootfont	274
+dps	DPSserialnumber	275
+dps	DPSsetcolor	276
+dps	DPSsetcolorrendering	277
+dps	DPSsetcolorspace	278
+dps	DPSsetdevparams	279
+dps	DPSsetglobal	280
+dps	DPSsetoverprint	281
+dps	DPSsetpagedevice	282
+dps	DPSsetpattern	283
+dps	DPSsetsystemparams	284
+dps	DPSsetuserparams	285
+dps	DPSstartjob	286
+dps	DPSundefineresource	287
+dps	DPSabs	288
+dps	DPSadd	289
+dps	DPSand	290
+dps	DPSatan	291
+dps	DPSbitshift	292
+dps	DPSceiling	293
+dps	DPScos	294
+dps	DPSdiv	295
+dps	DPSexp	296
+dps	DPSfloor	297
+dps	DPSidiv	298
+dps	DPSln	299
+dps	DPSlog	300
+dps	DPSmod	301
+dps	DPSmul	302
+dps	DPSneg	303
+dps	DPSround	304
+dps	DPSsin	305
+dps	DPSsqrt	306
+dps	DPSsub	307
+dps	DPStruncate	308
+dps	DPSxor	309
+dps	DPSbanddevice	310
+dps	DPSframedevice	311
+dps	DPSnulldevice	312
+dps	DPSrenderbands	313
+dps	DPSconcatmatrix	314
+dps	DPSdtransform	315
+dps	DPSidentmatrix	316
+dps	DPSidtransform	317
+dps	DPSinvertmatrix	318
+dps	DPSitransform	319
+dps	DPStransform	320
+dps	DPSgetboolean	321
+dps	DPSgetchararray	322
+dps	DPSgetfloat	323
+dps	DPSgetfloatarray	324
+dps	DPSgetint	325
+dps	DPSgetintarray	326
+dps	DPSgetstring	327
+dps	DPSsendboolean	328
+dps	DPSsendchararray	329
+dps	DPSsendfloat	330
+dps	DPSsendfloatarray	331
+dps	DPSsendint	332
+dps	DPSsendintarray	333
+dps	DPSsendstring	334
+dps	DPSarc	335
+dps	DPSarcn	336
+dps	DPSarct	337
+dps	DPSarcto	338
+dps	DPScharpath	339
+dps	DPSclip	340
+dps	DPSclippath	341
+dps	DPSclosepath	342
+dps	DPScurveto	343
+dps	DPSeoclip	344
+dps	DPSeoviewclip	345
+dps	DPSflattenpath	346
+dps	DPSinitclip	347
+dps	DPSinitviewclip	348
+dps	DPSlineto	349
+dps	DPSmoveto	350
+dps	DPSnewpath	351
+dps	DPSpathbbox	352
+dps	DPSpathforall	353
+dps	DPSrcurveto	354
+dps	DPSrectclip	355
+dps	DPSrectviewclip	356
+dps	DPSreversepath	357
+dps	DPSrlineto	358
+dps	DPSrmoveto	359
+dps	DPSsetbbox	360
+dps	DPSsetucacheparams	361
+dps	DPSuappend	362
+dps	DPSucache	363
+dps	DPSucachestatus	364
+dps	DPSupath	365
+dps	DPSviewclip	366
+dps	DPSviewclippath	367
+dps	DPSashow	368
+dps	DPSawidthshow	369
+dps	DPScopypage	370
+dps	DPSeofill	371
+dps	DPSerasepage	372
+dps	DPSfill	373
+dps	DPSimage	374
+dps	DPSimagemask	375
+dps	DPSkshow	376
+dps	DPSrectfill	377
+dps	DPSrectstroke	378
+dps	DPSshow	379
+dps	DPSshowpage	380
+dps	DPSstroke	381
+dps	DPSstrokepath	382
+dps	DPSueofill	383
+dps	DPSufill	384
+dps	DPSustroke	385
+dps	DPSustrokepath	386
+dps	DPSwidthshow	387
+dps	DPSxshow	388
+dps	DPSxyshow	389
+dps	DPSyshow	390
+dps	DPSInitClient	391
+dps	DPSIncludePrivContext	392
+dps	DPSSendPostScript	393
+dps	DPSSendInterrupt	394
+dps	DPSSendEOF	395
+dps	DPSSendTerminate	396
+dps	DPSSendDestroySpace	397
+dps	DPSCheckRaiseError	399
+dps	DPSInitSysNames	400
+dps	DPSSetWh	401
+dps	DPSOutOfMemory	402
+dps	DPSbind	403
+dps	DPScleardictstack	404
+dps	DPScountdictstack	405
+dps	DPScountexecstack	406
+dps	DPScurrentdict	407
+dps	DPScurrentpacking	408
+dps	DPScurrentshared	409
+dps	DPSdeviceinfo	410
+dps	DPSerrordict	411
+dps	DPSexec	412
+dps	DPSprompt	413
+dps	DPSquit	414
+dps	DPSrand	415
+dps	DPSrealtime	416
+dps	DPSrestore	417
+dps	DPSrrand	418
+dps	DPSrun	419
+dps	DPSsave	420
+dps	DPSsetpacking	421
+dps	DPSsetshared	422
+dps	DPSsrand	423
+dps	DPSstart	424
+dps	DPStype	425
+dps	DPSundef	426
+dps	DPSusertime	427
+dps	DPSversion	428
+dps	DPSvmreclaim	429
+dps	DPSvmstatus	430
+dps	DPSineofill	431
+dps	DPSinfill	432
+dps	DPSinstroke	433
+dps	DPSinueofill	434
+dps	DPSinufill	435
+dps	DPSinustroke	436
+dps	DPSwtranslation	437
+dps	PSclientsync	438
+dps	PScurrentXgcdrawable	439
+dps	PScurrentXgcdrawablecolor	440
+dps	PScurrentXoffset	441
+dps	PSsetXgcdrawable	442
+dps	PSsetXgcdrawablecolor	443
+dps	PSsetXoffset	444
+dps	PSsetXrgbactual	445
+dps	PSclientXready	446
+dps	PSsetXdrawingfunction	447
+dps	PScurrentXdrawingfunction	448
+dps	PScolorimage	449
+dps	PScurrentblackgeneration	450
+dps	PScurrentcmykcolor	451
+dps	PScurrentcolorscreen	452
+dps	PScurrentcolortransfer	453
+dps	PScurrentundercolorremoval	454
+dps	PSsetblackgeneration	455
+dps	PSsetcmykcolor	456
+dps	PSsetcolorscreen	457
+dps	PSsetcolortransfer	458
+dps	PSsetundercolorremoval	459
+dps	PSeq	460
+dps	PSexit	461
+dps	PSfalse	462
+dps	PSfor	463
+dps	PSforall	464
+dps	PSge	465
+dps	PSgt	466
+dps	PSif	467
+dps	PSifelse	468
+dps	PSle	469
+dps	PSloop	470
+dps	PSlt	471
+dps	PSne	472
+dps	PSnot	473
+dps	PSor	474
+dps	PSrepeat	475
+dps	PSstop	476
+dps	PSstopped	477
+dps	PStrue	478
+dps	PSUserObjects	479
+dps	PScondition	480
+dps	PScurrentcontext	481
+dps	PScurrentobjectformat	482
+dps	PSdefineusername	483
+dps	PSdefineuserobject	484
+dps	PSdetach	485
+dps	PSexecuserobject	486
+dps	PSfork	487
+dps	PSjoin	488
+dps	PSlock	489
+dps	PSmonitor	490
+dps	PSnotify	491
+dps	PSsetobjectformat	492
+dps	PSsetvmthreshold	493
+dps	PSundefineuserobject	494
+dps	PSwait	495
+dps	PSyield	496
+dps	PSaload	497
+dps	PSanchorsearch	498
+dps	PSarray	499
+dps	PSastore	500
+dps	PSbegin	501
+dps	PSclear	502
+dps	PScleartomark	503
+dps	PScopy	504
+dps	PScount	505
+dps	PScounttomark	506
+dps	PScvi	507
+dps	PScvlit	508
+dps	PScvn	509
+dps	PScvr	510
+dps	PScvrs	511
+dps	PScvs	512
+dps	PScvx	513
+dps	PSdef	514
+dps	PSdict	515
+dps	PSdictstack	516
+dps	PSdup	517
+dps	PSend	518
+dps	PSexch	519
+dps	PSexecstack	520
+dps	PSexecuteonly	521
+dps	PSget	522
+dps	PSgetinterval	523
+dps	PSindex	524
+dps	PSknown	525
+dps	PSlength	526
+dps	PSload	527
+dps	PSmark	528
+dps	PSmatrix	529
+dps	PSmaxlength	530
+dps	PSnoaccess	531
+dps	PSnull	532
+dps	PSpackedarray	533
+dps	PSpop	534
+dps	PSput	535
+dps	PSputinterval	536
+dps	PSrcheck	537
+dps	PSreadonly	538
+dps	PSroll	539
+dps	PSscheck	540
+dps	PSsearch	541
+dps	PSshareddict	542
+dps	PSstatusdict	543
+dps	PSstore	544
+dps	PSstring	545
+dps	PSstringwidth	546
+dps	PSsystemdict	547
+dps	PSuserdict	548
+dps	PSwcheck	549
+dps	PSwhere	550
+dps	PSxcheck	551
+dps	PSFontDirectory	552
+dps	PSISOLatin1Encoding	553
+dps	PSSharedFontDirectory	554
+dps	PSStandardEncoding	555
+dps	PScachestatus	556
+dps	PScurrentcacheparams	557
+dps	PScurrentfont	558
+dps	PSdefinefont	559
+dps	PSfindfont	560
+dps	PSmakefont	561
+dps	PSscalefont	562
+dps	PSselectfont	563
+dps	PSsetcachedevice	564
+dps	PSsetcachelimit	565
+dps	PSsetcacheparams	566
+dps	PSsetcharwidth	567
+dps	PSsetfont	568
+dps	PSundefinefont	569
+dps	PSconcat	570
+dps	PScurrentdash	571
+dps	PScurrentflat	572
+dps	PScurrentgray	573
+dps	PScurrentgstate	574
+dps	PScurrenthalftone	575
+dps	PScurrenthalftonephase	576
+dps	PScurrenthsbcolor	577
+dps	PScurrentlinecap	578
+dps	PScurrentlinejoin	579
+dps	PScurrentlinewidth	580
+dps	PScurrentmatrix	581
+dps	PScurrentmiterlimit	582
+dps	PScurrentpoint	583
+dps	PScurrentrgbcolor	584
+dps	PScurrentscreen	585
+dps	PScurrentstrokeadjust	586
+dps	PScurrenttransfer	587
+dps	PSdefaultmatrix	588
+dps	PSgrestore	589
+dps	PSgrestoreall	590
+dps	PSgsave	591
+dps	PSgstate	592
+dps	PSinitgraphics	593
+dps	PSinitmatrix	594
+dps	PSrotate	595
+dps	PSscale	596
+dps	PSsetdash	597
+dps	PSsetflat	598
+dps	PSsetgray	599
+dps	PSsetgstate	600
+dps	PSsethalftone	601
+dps	PSsethalftonephase	602
+dps	PSsethsbcolor	603
+dps	PSsetlinecap	604
+dps	PSsetlinejoin	605
+dps	PSsetlinewidth	606
+dps	PSsetmatrix	607
+dps	PSsetmiterlimit	608
+dps	PSsetrgbcolor	609
+dps	PSsetscreen	610
+dps	PSsetstrokeadjust	611
+dps	PSsettransfer	612
+dps	PStranslate	613
+dps	PSequals	614
+dps	PSequalsequals	615
+dps	PSbytesavailable	616
+dps	PSclosefile	617
+dps	PScurrentfile	618
+dps	PSdeletefile	619
+dps	PSecho	620
+dps	PSfile	621
+dps	PSfilenameforall	622
+dps	PSfileposition	623
+dps	PSflush	624
+dps	PSflushfile	625
+dps	PSprint	626
+dps	PSprintobject	627
+dps	PSpstack	628
+dps	PSread	629
+dps	PSreadhexstring	630
+dps	PSreadline	631
+dps	PSreadstring	632
+dps	PSrenamefile	633
+dps	PSresetfile	634
+dps	PSsetfileposition	635
+dps	PSstack	636
+dps	PSstatus	637
+dps	PStoken	638
+dps	PSwrite	639
+dps	PSwritehexstring	640
+dps	PSwriteobject	641
+dps	PSwritestring	642
+dps	PSleftbracket	643
+dps	PSrightbracket	644
+dps	PSleftleft	645
+dps	PSrightright	646
+dps	PScshow	647
+dps	PScurrentcolor	648
+dps	PScurrentcolorrendering	649
+dps	PScurrentcolorspace	650
+dps	PScurrentdevparams	651
+dps	PScurrentglobal	652
+dps	PScurrentoverprint	653
+dps	PScurrentpagedevice	654
+dps	PScurrentsystemparams	655
+dps	PScurrentuserparams	656
+dps	PSdefineresource	657
+dps	PSexecform	658
+dps	PSfilter	659
+dps	PSfindencoding	660
+dps	PSfindresource	661
+dps	PSgcheck	662
+dps	PSglobaldict	663
+dps	PSGlobalFontDirectory	664
+dps	PSglyphshow	665
+dps	PSlanguagelevel	666
+dps	PSmakepattern	667
+dps	PSproduct	668
+dps	PSresourceforall	669
+dps	PSresourcestatus	670
+dps	PSrevision	671
+dps	PSrootfont	672
+dps	PSserialnumber	673
+dps	PSsetcolor	674
+dps	PSsetcolorrendering	675
+dps	PSsetcolorspace	676
+dps	PSsetdevparams	677
+dps	PSsetglobal	678
+dps	PSsetoverprint	679
+dps	PSsetpagedevice	680
+dps	PSsetpattern	681
+dps	PSsetsystemparams	682
+dps	PSsetuserparams	683
+dps	PSstartjob	684
+dps	PSundefineresource	685
+dps	PSabs	686
+dps	PSadd	687
+dps	PSand	688
+dps	PSatan	689
+dps	PSbitshift	690
+dps	PSceiling	691
+dps	PScos	692
+dps	PSdiv	693
+dps	PSexp	694
+dps	PSfloor	695
+dps	PSidiv	696
+dps	PSln	697
+dps	PSlog	698
+dps	PSmod	699
+dps	PSmul	700
+dps	PSneg	701
+dps	PSround	702
+dps	PSsin	703
+dps	PSsqrt	704
+dps	PSsub	705
+dps	PStruncate	706
+dps	PSxor	707
+dps	PSbanddevice	708
+dps	PSframedevice	709
+dps	PSnulldevice	710
+dps	PSrenderbands	711
+dps	PSconcatmatrix	712
+dps	PSdtransform	713
+dps	PSidentmatrix	714
+dps	PSidtransform	715
+dps	PSinvertmatrix	716
+dps	PSitransform	717
+dps	PStransform	718
+dps	PSgetboolean	719
+dps	PSgetchararray	720
+dps	PSgetfloat	721
+dps	PSgetfloatarray	722
+dps	PSgetint	723
+dps	PSgetintarray	724
+dps	PSgetstring	725
+dps	PSsendboolean	726
+dps	PSsendchararray	727
+dps	PSsendfloat	728
+dps	PSsendfloatarray	729
+dps	PSsendint	730
+dps	PSsendintarray	731
+dps	PSsendstring	732
+dps	PSarc	733
+dps	PSarcn	734
+dps	PSarct	735
+dps	PSarcto	736
+dps	PScharpath	737
+dps	PSclip	738
+dps	PSclippath	739
+dps	PSclosepath	740
+dps	PScurveto	741
+dps	PSeoclip	742
+dps	PSeoviewclip	743
+dps	PSflattenpath	744
+dps	PSinitclip	745
+dps	PSinitviewclip	746
+dps	PSlineto	747
+dps	PSmoveto	748
+dps	PSnewpath	749
+dps	PSpathbbox	750
+dps	PSpathforall	751
+dps	PSrcurveto	752
+dps	PSrectclip	753
+dps	PSrectviewclip	754
+dps	PSreversepath	755
+dps	PSrlineto	756
+dps	PSrmoveto	757
+dps	PSsetbbox	758
+dps	PSsetucacheparams	759
+dps	PSuappend	760
+dps	PSucache	761
+dps	PSucachestatus	762
+dps	PSupath	763
+dps	PSviewclip	764
+dps	PSviewclippath	765
+dps	PSashow	766
+dps	PSawidthshow	767
+dps	PScopypage	768
+dps	PSeofill	769
+dps	PSerasepage	770
+dps	PSfill	771
+dps	PSimage	772
+dps	PSimagemask	773
+dps	PSkshow	774
+dps	PSrectfill	775
+dps	PSrectstroke	776
+dps	PSshow	777
+dps	PSshowpage	778
+dps	PSstroke	779
+dps	PSstrokepath	780
+dps	PSueofill	781
+dps	PSufill	782
+dps	PSustroke	783
+dps	PSustrokepath	784
+dps	PSwidthshow	785
+dps	PSxshow	786
+dps	PSxyshow	787
+dps	PSyshow	788
+dps	PSbind	789
+dps	PScleardictstack	790
+dps	PScountdictstack	791
+dps	PScountexecstack	792
+dps	PScurrentdict	793
+dps	PScurrentpacking	794
+dps	PScurrentshared	795
+dps	PSdeviceinfo	796
+dps	PSerrordict	797
+dps	PSexec	798
+dps	PSprompt	799
+dps	PSquit	800
+dps	PSrand	801
+dps	PSrealtime	802
+dps	PSrestore	803
+dps	PSrrand	804
+dps	PSrun	805
+dps	PSsave	806
+dps	PSsetpacking	807
+dps	PSsetshared	808
+dps	PSsrand	809
+dps	PSstart	810
+dps	PStype	811
+dps	PSundef	812
+dps	PSusertime	813
+dps	PSversion	814
+dps	PSvmreclaim	815
+dps	PSvmstatus	816
+dps	PSineofill	817
+dps	PSinfill	818
+dps	PSinstroke	819
+dps	PSinueofill	820
+dps	PSinufill	821
+dps	PSinustroke	822
+dps	PSwtranslation	823
+dps	XDPSLInit	824
+dps	DPSWriteStringChars	825
+dps	XDPSUnfreezeContext	826
+dps	DPSGetCurrentContext	827
+dps	DPSAwaitReturnValues	828
+dps	DPSNewUserObjectIndex	829
+dps	XDPSGetContextStatus	830
+dps	XDPSRegisterStatusProc	831
+dps	DPSDefaultTextBackstop	832
+dps	DPSMapNames	833
+dps	XDPSGetDefaultColorMaps	834
+dps	XDPSCreateSimpleContext	835
+dps	DPSGenerateExtensionRecID	836
+dps	DPSWaitContext	837
+dps	DPSAddContextExtensionRec	838
+dps	DPSGetContextExtensionRec	839
+dps	DPSChainContext	840
+dps	DPSDestroySpace	841
+dps	DPSUnchainContext	842
+dps	DPSBinObjSeqWrite	843
+dps	DPSSetResultTable	844
+dps	XDPSSetStatusMask	845
+dps	XDPSXIDFromContext	846
+dps	DPSWritePostScript	847
+dps	DPSRemoveContextExtensionRec	848
+dps	DPSDefaultErrorProc	849
+dps	DPSCreateTextContext	850
+;4.x exports from 900
+dps	DPSDestroyContext	900
+dps	DPSFlushContext	901
+dps	DPSGetContextType	902
+dps	DPSGetCurrentErrorBackstop 903
+dps	DPSGetCurrentTextBackstop 904
+dps	DPSInitialize	905
+dps	DPSInterruptContext	906
+dps	DPSKnownContext	907
+dps	DPSKnownSpace	908
+dps	DPSNameFromIndex	909
+dps	DPSPrivCurrentContext	910
+dps	DPSResetContext	911
+dps	DPSSetAbbrevMode	912
+dps	DPSSetContext	913
+dps	DPSSetErrorBackstop	914
+dps	DPSSetNumStringConversion 915
+dps	DPSSetTextBackstop	916
+dps	DPSSetWrapSynchronization	917
+dps	DPSSuppressBinaryConversion 918
+dps	DPSUpdateNameMap	919
+dps	DPSWriteData	920
+dps	DPSWriteNumString	921
+dps	DPSWriteTypedObjectArray	922
+dps	DPScalloc	923
+dps	DPSPrintf	924
+dps	DPSRaise	925
+dps	DPSFetchAbbrevList	926
+dps	DPSGetOperatorAbbrev	927
+dps	DPSGetSysnameAbbrev	928
+dps	DPSChangeEncoding	929
+dps	DPSContextFromContextID	930
+dps	DPSHandleBogusError	931
+dps	DPSServicePostScript	932
+dps	XDPSContextFromSharedID	933
+dps	XDPSContextFromXID	934
+dps	XDPSCreateContext	935
+dps	XDPSCreateSecureContext	936
+dps	XDPSDispatchEvent	937
+dps	XDPSFindContext	938
+dps	XDPSGetProtocolVersion	939
+dps	XDPSIsDPSEvent	940
+dps	XDPSIsOutputEvent	941
+dps	XDPSIsReadyEvent	942
+dps	XDPSIsStatusEvent	943
+dps	XDPSNotifyWhenReady	944
+dps	XDPSReadyEventHandler	945
+dps	XDPSRegisterReadyProc	946
+dps	XDPSSetEventDelivery	947
+dps	XDPSSetProcs	948
+dps	XDPSSpaceFromSharedID	949
+dps	XDPSSpaceFromXID	950
+dps	XDPSStatusEventHandler	951
+dps	XDPSXIDFromSpace	952
+dps	DPSCreatePrivContext	953
+dps	XDPSCreatePrivContextRec 954
+dps	XDPSForceEvents	955
+dps	XDPSNumFormat	956
+dps	XDPSPrivZapDpy	957
+dps	XDPSSendUnfreeze	958
+dps	XDPSSetContextEncoding	959
+dps	XDPSLCAPNotify	960
+dps	XDPSLCallOutputEventHandler	961
+dps	XDPSLCallReadyEventHandler 962
+dps	XDPSLCallStatusEventHandler 963
+dps	XDPSLCleanAll	964
+dps	XDPSLCleanContext	965
+dps	XDPSLContextFromXID	966
+dps	XDPSLCreateContext	967
+dps	XDPSLCreateContextAndSpace	968
+dps	XDPSLCreateContextFromID	969
+dps	XDPSLCreateSpace	970
+dps	XDPSLDestroySpace	971
+dps	XDPSLDispatchCSDPSFakeEvent	972
+dps	XDPSLFlush	973
+dps	XDPSLFlushGC	974
+dps	XDPSLGetCSDPSFakeEventType	975
+dps	XDPSLGetCSDPSReady	976
+dps	XDPSLGetCSDPSStatus	977
+dps	XDPSLGetCodes	978	
+dps	XDPSLGetGCFlushMode	979
+dps	XDPSLGetPassEventsFlag	980
+dps	XDPSLGetShunt	981
+dps	XDPSLGetStatus	982
+dps	XDPSLGetSyncMask	983
+dps	XDPSLGetVersion	984
+dps	XDPSLGetWrapWaitingFlag 985
+dps	XDPSLGiveInput	986
+dps	XDPSLIDFromContext	987
+dps	XDPSLInitDisplayFlags	988
+dps	XDPSLNotifyContext	989
+dps	XDPSLNotifyWhenReady	990
+dps	XDPSLReconcileRequests  991
+dps	XDPSLReset	992
+dps	XDPSLSetAfterProc	993
+dps	XDPSLSetAgentArg	994
+dps	XDPSLSetAgentName	995
+dps	XDPSLSetClientMessageHandler 996
+dps	XDPSLSetCodes	997
+dps	XDPSLSetGCFlushMode 998
+dps	XDPSLSetPassEventsFlag 999
+dps	XDPSLSetReadyEventHandler 1000
+dps	XDPSLSetShunt	1001
+dps	XDPSLSetStatusEventHandler	1002
+dps	XDPSLSetStatusMask	1003
+dps	XDPSLSetSyncMask	1004
+dps	XDPSLSetTextEventHandler	1005
+dps	XDPSLSetVersion	1006
+dps	XDPSLSetWrapWaitingFlag	1007
+dps	XDPSLSync	1008
+dps	XDPSLSyncGCClip	1009
+dps	XDPSLTestErrorCode	1010
+dps	XDPSLUpdateAgentArgs	1011
+dps	XDPSSetXtEventDispatching	1012
+dps	DPSCAPCopyGCProc	1013
+dps	DPSCAPFlushGCProc	1014
+dps	DPSCAPFreeGCProc	1015
+dps	XDPSFlushGC	1016
+dps	XDPSNXSetAgentArg	1017
+dps	XDPSReconcileRequests	1018
+dps	XDPSSyncGCClip	1019
+dps	DPSCAPConnect	1020
+dps	N_XDisconnectDisplay	1021
+dps	N_XWaitForReadable	1022
+dps	N_XWaitForWritable	1023
+dps	StartXDPSNX	1024
+dps	XDPSNXRecommendPort	1025
+dps	XDPSGetNXArg	1026
+dps	XDPSNXFindNX	1027
+dps	XDPSNXSetClientArg	1028
+dps	NXProcData	1029
+dps	N_XANYSET	1030
+dps	N_XFlush	1031
+dps	N_XGetHostname	1032
+dps	N_XRead	1033
+dps	N_XReadPad	1034
+dps	N_XReply	1035
+dps	N_XSend	1036
+dps	N_XUnknownNativeEvent	1037
+dps	N_XUnknownWireEvent	1038
+LIBRARY dpstk dpstk
+dpstk	XDPSSetFileFunctions	1
+dpstk	XDPSFileRewindFunc	2
+dpstk	XDPSFileGetsFunc	3
+dpstk	XDPSEmbeddedEPSFRewindFunc	4
+dpstk	XDPSEmbeddedGetsFunc	5
+dpstk	XDPSCreatePixmapForEPSF	6
+dpstk	XDPSPixelsPerPoint	7
+dpstk	XDPSSetImagingTimeout	8
+dpstk	XDPSCheckImagingResults	9
+dpstk	XDPSImageFileIntoDrawable  10
+dpstk	_DPSPSetMatrix	11
+dpstk	_DPSPClearArea	12
+dpstk	_DPSPSetMaskTransfer	13
+dpstk	_DPSPDefineExecFunction	14
+dpstk	_DPSPSaveBeforeExec	15
+dpstk	_DPSPCheckForError	16
+dpstk	_XDPSSetComponentInitialized	17
+dpstk	_XDPSTestComponentInitialized	18
+dpstk	XDPSSetContextDepth	19
+dpstk	XDPSSetContextDrawable	20
+dpstk	XDPSSetContextRGBMap	21
+dpstk	XDPSSetContextGrayMap	22
+dpstk	XDPSSetContextParameters	23
+dpstk	XDPSPushContextParameters	24
+dpstk	XDPSPopContextParameters	25
+dpstk	XDPSCaptureContextGState	26
+dpstk	XDPSUpdateContextGState	27
+dpstk	XDPSFreeContextGState	28
+dpstk	XDPSSetContextGState	29
+dpstk	XDPSPushContextGState	30
+dpstk	XDPSPopContextGState	31
+dpstk	XDPSRegisterContext	32
+dpstk	XDPSGetSharedContext	33
+dpstk	XDPSDestroySharedContext	34
+dpstk	XDPSUnregisterContext	35
+dpstk	XDPSFreeDisplayInfo	36
+dpstk	XDPSChainTextContext	37
+dpstk	XDPSExtensionPresent	38
+dpstk	PSDefineAsUserObj	39
+dpstk	PSRedefineUserObj	40
+dpstk	PSUndefineUserObj	41
+dpstk	DPSDefineAsUserObj	42
+dpstk	DPSRedefineUserObj	43
+dpstk	DPSUndefineUserObj	44
+dpstk	PSReserveUserObjIndices	45
+dpstk	DPSReserveUserObjIndices	46
+dpstk	PSReturnUserObjIndices	47
+dpstk	DPSReturnUserObjIndices	48
+dpstk	_DPSSSetContextParameters	49
+dpstk	_DPSSSetContextDrawable	50
+dpstk	_DPSSInstallDPSlibDict	51
+dpstk	_DPSSCaptureGState	52
+dpstk	_DPSSUpdateGState	53
+dpstk	_DPSSRestoreGState	54
+dpstk	_DPSSDefineUserObject	55
+dpstk	_DPSSUndefineUserObject	56
+dpstk	PSDoUserPath	57
+dpstk	DPSDoUserPath	58
+dpstk	PSHitUserPath	59
+dpstk	DPSHitUserPath	60
+LIBRARY psres psres
+psres	CheckPSResourceTime	1
+psres	EnumeratePSResourceFiles	2
+psres	FreePSResourceStorage	3
+psres	InSavedList	4
+psres	ListPSResourceFiles	5
+psres	ListPSResourceTypes	6
+psres	PSResEncoding	7
+psres	PSResFileWarningHandler	8
+psres	PSResFontAFM	9
+psres	PSResFontBDF	10
+psres	PSResFontBDFSizes	11
+psres	PSResFontFamily	12
+psres	PSResFontOutline	13
+psres	PSResFontPrebuilt	14 
+psres	PSResForm	15
+psres	PSResFree	16
+psres	PSResMalloc	17
+psres	PSResPattern	18
+psres	PSResProcSet	19
+psres	PSResRealloc	20
+psres	SetPSResourcePolicy	21
+LIBRARY Xrender Xrender 
+Xrender	XRenderComposite	1 
+Xrender	XRenderFillRectangle	2
+Xrender	XRenderFillRectangles	3
+Xrender	XRenderAddGlyphs	4
+Xrender	XRenderCompositeString16	5
+Xrender	XRenderCompositeString32	6
+Xrender	XRenderCompositeString8	7	
+Xrender	XRenderCreateGlyphSet	8
+Xrender	XRenderFreeGlyphSet	9
+Xrender	XRenderFreeGlyphs	10
+Xrender	XRenderReferenceGlyphSet	11
+Xrender	XRenderChangePicture	12
+Xrender	XRenderCreatePicture	13
+Xrender	XRenderFreePicture	14
+;	_XRenderProcessPictureAttributes
+Xrender	XRenderFindDisplay	15
+Xrender	XRenderFindFormat	16
+Xrender	XRenderFindVisualFormat	17
+Xrender	XRenderQueryExtension	18
+Xrender	XRenderQueryFormats	19
+Xrender	XRenderQueryVersion	20
+;	_XRenderFindFormat
+;	_XRenderFindVisual
+Xrender	XRenderSetPictureClipRegion	21	
+LIBRARY GL GL
+GL	glClearIndex  1 
+GL	glClearColor  2 
+GL	glClear  3 
+GL	glIndexMask  4 
+GL	glColorMask  5 
+GL	glAlphaFunc  6 
+GL	glBlendFunc  7 
+GL	glLogicOp  8 
+GL	glCullFace  9 
+GL	glFrontFace  10 
+GL	glPointSize  11 
+GL	glLineWidth  12 
+GL	glLineStipple  13 
+GL	glPolygonMode  14 
+GL	glPolygonStipple  15 
+GL	glGetPolygonStipple  16 
+GL	glEdgeFlag  17 
+GL	glEdgeFlagv  18 
+GL	glScissor  19 
+GL	glClipPlane  20 
+GL	glGetClipPlane  21 
+GL	glDrawBuffer  22 
+GL	glReadBuffer  23 
+GL	glEnable  24 
+GL	glDisable  25 
+GL	glIsEnabled  26 
+GL	glGetBooleanv  27 
+GL	glGetDoublev  28 
+GL	glGetFloatv  29 
+GL	glGetIntegerv  30 
+GL	glPushAttrib  31 
+GL	glPopAttrib  32 
+GL	glRenderMode  33 
+GL	glGetError  34 
+GL	glGetString  35 
+GL	glFinish  36 
+GL	glFlush  37 
+GL	glHint  38 
+GL	glClearDepth  39 
+GL	glDepthFunc  40 
+GL	glDepthMask  41 
+GL	glDepthRange  42 
+GL	glClearAccum  43 
+GL	glAccum  44 
+GL	glMatrixMode  45 
+GL	glOrtho  46 
+GL	glFrustum  47 
+GL	glViewport  48 
+GL	glPushMatrix  49 
+GL	glPopMatrix  50 
+GL	glLoadIdentity  51 
+GL	glLoadMatrixd  52 
+GL	glLoadMatrixf  53 
+GL	glMultMatrixd  54 
+GL	glMultMatrixf  55 
+GL	glRotated  56 
+GL	glRotatef  57 
+GL	glScaled  58 
+GL	glScalef  59 
+GL	glTranslated  60 
+GL	glTranslatef  61 
+GL	glIsList  62 
+GL	glDeleteLists  63 
+GL	glGenLists  64 
+GL	glNewList  65 
+GL	glEndList  66 
+GL	glCallList  67 
+GL	glCallLists  68 
+GL	glListBase  69 
+GL	glBegin  70 
+GL	glEnd  71 
+GL	glVertex2d  72 
+GL	glVertex2f  73 
+GL	glVertex2i  74 
+GL	glVertex2s  75 
+GL	glVertex3d  76 
+GL	glVertex3f  77 
+GL	glVertex3i  78 
+GL	glVertex3s  79 
+GL	glVertex4d  80 
+GL	glVertex4f  81 
+GL	glVertex4i  82 
+GL	glVertex4s  83 
+GL	glVertex2dv  84 
+GL	glVertex2fv  85 
+GL	glVertex2iv  86 
+GL	glVertex2sv  87 
+GL	glVertex3dv  88 
+GL	glVertex3fv  89 
+GL	glVertex3iv  90 
+GL	glVertex3sv  91 
+GL	glVertex4dv  92 
+GL	glVertex4fv  93 
+GL	glVertex4iv  94 
+GL	glVertex4sv  95 
+GL	glNormal3b  96 
+GL	glNormal3d  97 
+GL	glNormal3f  98 
+GL	glNormal3i  99 
+GL	glNormal3s  100 
+GL	glNormal3bv  101 
+GL	glNormal3dv  102 
+GL	glNormal3fv  103 
+GL	glNormal3iv  104 
+GL	glNormal3sv  105 
+GL	glIndexd  106 
+GL	glIndexf  107 
+GL	glIndexi  108 
+GL	glIndexs  109 
+GL	glIndexdv  110 
+GL	glIndexfv  111 
+GL	glIndexiv  112 
+GL	glIndexsv  113 
+GL	glColor3b  114 
+GL	glColor3d  115 
+GL	glColor3f  116 
+GL	glColor3i  117 
+GL	glColor3s  118 
+GL	glColor3ub  119 
+GL	glColor3ui  120 
+GL	glColor3us  121 
+GL	glColor4b  122 
+GL	glColor4d  123 
+GL	glColor4f  124 
+GL	glColor4i  125 
+GL	glColor4s  126 
+GL	glColor4ub  127 
+GL	glColor4ui  128 
+GL	glColor4us  129 
+GL	glColor3bv  130 
+GL	glColor3dv  131 
+GL	glColor3fv  132 
+GL	glColor3iv  133 
+GL	glColor3sv  134 
+GL	glColor3ubv  135 
+GL	glColor3uiv  136 
+GL	glColor3usv  137 
+GL	glColor4bv  138 
+GL	glColor4dv  139 
+GL	glColor4fv  140 
+GL	glColor4iv  141 
+GL	glColor4sv  142 
+GL	glColor4ubv  143 
+GL	glColor4uiv  144 
+GL	glColor4usv  145 
+GL	glTexCoord1d  146 
+GL	glTexCoord1f  147 
+GL	glTexCoord1i  148 
+GL	glTexCoord1s  149 
+GL	glTexCoord2d  150 
+GL	glTexCoord2f  151 
+GL	glTexCoord2i  152 
+GL	glTexCoord2s  153 
+GL	glTexCoord3d  154 
+GL	glTexCoord3f  155 
+GL	glTexCoord3i  156 
+GL	glTexCoord3s  157 
+GL	glTexCoord4d  158 
+GL	glTexCoord4f  159 
+GL	glTexCoord4i  160 
+GL	glTexCoord4s  161 
+GL	glTexCoord1dv  162 
+GL	glTexCoord1fv  163 
+GL	glTexCoord1iv  164 
+GL	glTexCoord1sv  165 
+GL	glTexCoord2dv  166 
+GL	glTexCoord2fv  167 
+GL	glTexCoord2iv  168 
+GL	glTexCoord2sv  169 
+GL	glTexCoord3dv  170 
+GL	glTexCoord3fv  171 
+GL	glTexCoord3iv  172 
+GL	glTexCoord3sv  173 
+GL	glTexCoord4dv  174 
+GL	glTexCoord4fv  175 
+GL	glTexCoord4iv  176 
+GL	glTexCoord4sv  177 
+GL	glRasterPos2d  178 
+GL	glRasterPos2f  179 
+GL	glRasterPos2i  180 
+GL	glRasterPos2s  181 
+GL	glRasterPos3d  182 
+GL	glRasterPos3f  183 
+GL	glRasterPos3i  184 
+GL	glRasterPos3s  185 
+GL	glRasterPos4d  186 
+GL	glRasterPos4f  187 
+GL	glRasterPos4i  188 
+GL	glRasterPos4s  189 
+GL	glRasterPos2dv  190 
+GL	glRasterPos2fv  191 
+GL	glRasterPos2iv  192 
+GL	glRasterPos2sv  193 
+GL	glRasterPos3dv  194 
+GL	glRasterPos3fv  195 
+GL	glRasterPos3iv  196 
+GL	glRasterPos3sv  197 
+GL	glRasterPos4dv  198 
+GL	glRasterPos4fv  199 
+GL	glRasterPos4iv  200 
+GL	glRasterPos4sv  201 
+GL	glRectd  202 
+GL	glRectf  203 
+GL	glRecti  204 
+GL	glRects  205 
+GL	glRectdv  206 
+GL	glRectfv  207 
+GL	glRectiv  208 
+GL	glRectsv  209 
+GL	glShadeModel  210 
+GL	glLightf  211 
+GL	glLighti  212 
+GL	glLightfv  213 
+GL	glLightiv  214 
+GL	glGetLightfv  215 
+GL	glGetLightiv  216 
+GL	glLightModelf  217 
+GL	glLightModeli  218 
+GL	glLightModelfv  219 
+GL	glLightModeliv  220 
+GL	glMaterialf  221 
+GL	glMateriali  222 
+GL	glMaterialfv  223 
+GL	glMaterialiv  224 
+GL	glGetMaterialfv  225 
+GL	glGetMaterialiv  226 
+GL	glColorMaterial  227 
+GL	glPixelZoom  228 
+GL	glPixelStoref  229 
+GL	glPixelStorei  230 
+GL	glPixelTransferf  231 
+GL	glPixelTransferi  232 
+GL	glPixelMapfv  233 
+GL	glPixelMapuiv  234 
+GL	glPixelMapusv  235 
+GL	glGetPixelMapfv  236 
+GL	glGetPixelMapuiv  237 
+GL	glGetPixelMapusv  238 
+GL	glBitmap  239 
+GL	glReadPixels  240 
+GL	glDrawPixels  241 
+GL	glCopyPixels  242 
+GL	glStencilFunc  243 
+GL	glStencilMask  244 
+GL	glStencilOp  245 
+GL	glClearStencil  246 
+GL	glTexGend  247 
+GL	glTexGenf  248 
+GL	glTexGeni  249 
+GL	glTexGendv  250 
+GL	glTexGenfv  251 
+GL	glTexGeniv  252 
+GL	glGetTexGendv  253 
+GL	glGetTexGenfv  254 
+GL	glGetTexGeniv  255 
+GL	glTexEnvf  256 
+GL	glTexEnvi  257 
+GL	glTexEnvfv  258 
+GL	glTexEnviv  259 
+GL	glGetTexEnvfv  260 
+GL	glGetTexEnviv  261 
+GL	glTexParameterf  262 
+GL	glTexParameteri  263 
+GL	glTexParameterfv  264 
+GL	glTexParameteriv  265 
+GL	glGetTexParameterfv  266 
+GL	glGetTexParameteriv  267 
+GL	glGetTexLevelParameterfv  268 
+GL	glGetTexLevelParameteriv  269 
+GL	glTexImage1D  270 
+GL	glTexImage2D  271 
+GL	glGetTexImage  272 
+GL	glMap1d  273 
+GL	glMap1f  274 
+GL	glMap2d  275 
+GL	glMap2f  276 
+GL	glGetMapdv  277 
+GL	glGetMapfv  278 
+GL	glGetMapiv  279 
+GL	glEvalCoord1d  280 
+GL	glEvalCoord1f  281 
+GL	glEvalCoord1dv  282 
+GL	glEvalCoord1fv  283 
+GL	glEvalCoord2d  284 
+GL	glEvalCoord2f  285 
+GL	glEvalCoord2dv  286 
+GL	glEvalCoord2fv  287 
+GL	glMapGrid1d  288 
+GL	glMapGrid1f  289 
+GL	glMapGrid2d  290 
+GL	glMapGrid2f  291 
+GL	glEvalPoint1  292 
+GL	glEvalPoint2  293 
+GL	glEvalMesh1  294 
+GL	glEvalMesh2  295 
+GL	glFogf  296 
+GL	glFogi  297 
+GL	glFogfv  298 
+GL	glFogiv  299 
+GL	glFeedbackBuffer  300 
+GL	glPassThrough  301 
+GL	glSelectBuffer  302 
+GL	glInitNames  303 
+GL	glLoadName  304 
+GL	glPushName  305 
+GL	glPopName  306 
+;	glBlendEquationEXT  307 
+;	glBlendColorEXT  308 
+GL	glPolygonOffset  309 
+;	glVertexPointerEXT  310 
+;	glNormalPointerEXT  311 
+;	glColorPointerEXT  312 
+;	glIndexPointerEXT  313 
+;	glTexCoordPointerEXT  314 
+;	glEdgeFlagPointerEXT  315 
+;	glGetPointervEXT  316 
+;	glArrayElementEXT  317 
+;	glDrawArraysEXT  318 
+;	OSMesaCreateContext  319 
+;	OSMesaDestroyContext  320 
+;	OSMesaMakeCurrent  321 
+;	XMesaCreateContext  322 
+;	XMesaDestroyContext  323 
+;	XMesaMakeCurrent  326 
+;	XMesaGetCurrentContext  327 
+;	XMesaSwapBuffers  328 
+;	XMesaGetBackBuffer  329 
+GL	glXChooseVisual  330 
+GL	glXCreateContext  331 
+GL	glXDestroyContext  332 
+GL	glXMakeCurrent  333 
+GL	glXCopyContext  334 
+GL	glXSwapBuffers  335 
+GL	glXCreateGLXPixmap  336 
+GL	glXDestroyGLXPixmap  337 
+GL	glXQueryExtension  338 
+GL	glXQueryVersion  339 
+GL	glXIsDirect  340 
+GL	glXGetConfig  341 
+GL	glXGetCurrentContext  342 
+GL	glXGetCurrentDrawable  343 
+GL	glXWaitGL  344 
+GL	glXWaitX  345 
+GL	glXUseXFont  346 
+GL	glXQueryExtensionsString  347 
+GL	glXQueryServerString  348 
+GL	glXGetClientString  349 
+GL	glPushClientAttrib  350 
+GL	glPopClientAttrib  351 
+GL	glIndexub  352 
+GL	glIndexubv  353 
+GL	glVertexPointer  354 
+GL	glNormalPointer  355 
+GL	glColorPointer  356 
+GL	glIndexPointer  357 
+GL	glTexCoordPointer  358 
+GL	glEdgeFlagPointer  359 
+GL	glGetPointerv  360 
+GL	glArrayElement  361 
+GL	glDrawArrays  362 
+GL	glDrawElements  363 
+GL	glInterleavedArrays  364 
+GL	glGenTextures  365 
+GL	glDeleteTextures  366 
+GL	glBindTexture  367 
+GL	glPrioritizeTextures  368 
+GL	glAreTexturesResident  369 
+GL	glIsTexture  370 
+GL	glTexSubImage1D  371 
+GL	glTexSubImage2D  372 
+GL	glCopyTexImage1D  373 
+GL	glCopyTexImage2D  374 
+GL	glCopyTexSubImage1D  375 
+GL	glCopyTexSubImage2D  376 
+;	glWindowPos2iMESA  377 
+;	glWindowPos2sMESA  378 
+;	glWindowPos2fMESA  379 
+;	glWindowPos2dMESA  380 
+;	glWindowPos2ivMESA  381 
+;	glWindowPos2svMESA  382 
+;	glWindowPos2fvMESA  383 
+;	glWindowPos2dvMESA  384 
+;	glWindowPos3iMESA  385 
+;	glWindowPos3sMESA  386 
+;	glWindowPos3fMESA  387 
+;	glWindowPos3dMESA  388 
+;	glWindowPos3ivMESA  389 
+;	glWindowPos3svMESA  390 
+;	glWindowPos3fvMESA  391 
+;	glWindowPos3dvMESA  392 
+;	glWindowPos4iMESA  393 
+;	glWindowPos4sMESA  394 
+;	glWindowPos4fMESA  395 
+;	glWindowPos4dMESA  396 
+;	glWindowPos4ivMESA  397 
+;	glWindowPos4svMESA  398 
+;	glWindowPos4fvMESA  399 
+;	glWindowPos4dvMESA  400 
+;	glXCreateGLXPixmapMESA  401 
+;	glXReleaseBuffersMESA  402 
+;	OSMesaGetCurrentContext  403 
+;	OSMesaPixelStore  404 
+;	OSMesaGetIntegerv  405 
+;	XMesaCreateVisual  406 
+;	XMesaDestroyVisual  407 
+;	XMesaCreateWindowBuffer  408 
+;	XMesaCreatePixmapBuffer  409 
+;	XMesaDestroyBuffer  410 
+;	XMesaGetCurrentBuffer  411 
+;	XMesaFlush  412 
+;	XMesaGetString  413 
+;	glPolygonOffsetEXT  414 
+GL	glDisableClientState  450
+GL	glEnableClientState  451
+GL	glXFreeContextEXT  452
+GL	glXGetContextIDEXT  453
+GL	glXGetCurrentDisplay  454
+GL	glXImportContextEXT  455
+GL	glXQueryContextInfoEXT  456
+GL	glXGetCurrentDrawableEXT  457
+GL	glCopyTexSubImage3D  458
+GL	glDrawRangeElements  459
+GL	glTexSubImage3D  460
+GL	glBlendColorEXT  461
+GL	glBlendEquationEXT  462
+GL	glTexImage3D  463
+LIBRARY ICE ICE
+ICE	IceAcceptConnection	1 
+ICE	IceAddConnectionWatch	2 
+ICE	IceAllocScratch	3 
+ICE	IceAppLockConn	4 
+ICE	IceAppUnlockConn	5 
+ICE	IceAuthFileName	6 
+ICE	IceCheckShutdownNegotiation	7 
+ICE	IceCloseConnection	8 
+ICE	IceComposeNetworkIdList	9 
+ICE	IceConnectionNumber	10 
+ICE	IceConnectionStatus	11 
+ICE	IceConnectionString	12 
+ICE	IceFlush	13 
+ICE	IceFreeAuthFileEntry	14 
+ICE	IceFreeListenObjs	15 
+ICE	IceGenerateMagicCookie	16 
+ICE	IceGetAuthFileEntry	17 
+ICE	IceGetConnectionContext	18 
+ICE	IceGetInBufSize	19 
+ICE	IceGetListenConnectionNumber	20 
+ICE	IceGetListenConnectionString	21 
+ICE	IceGetOutBufSize	22 
+ICE	IceInitThreads	23 
+ICE	IceLastReceivedSequenceNumber	24 
+ICE	IceLastSentSequenceNumber	25 
+ICE	IceListenForConnections	26 
+ICE	IceLockAuthFile	27 
+ICE	IceOpenConnection	28 
+ICE	IcePing	29 
+ICE	IceProcessMessages	30 
+ICE	IceProtocolRevision	31 
+ICE	IceProtocolSetup	32 
+ICE	IceProtocolShutdown	33 
+ICE	IceProtocolVersion	34 
+ICE	IceReadAuthFileEntry	35 
+ICE	IceRegisterForProtocolReply	36 
+ICE	IceRegisterForProtocolSetup	37 
+ICE	IceRelease	38 
+ICE	IceRemoveConnectionWatch	39 
+ICE	IceSetErrorHandler	40 
+ICE	IceSetHostBasedAuthProc	41 
+ICE	IceSetIOErrorHandler	42 
+ICE	IceSetPaAuthData	43 
+ICE	IceSetShutdownNegotiation	44 
+ICE	IceSwapping	45 
+ICE	IceUnlockAuthFile	46 
+ICE	IceVendor	47 
+ICE	IceWriteAuthFileEntry	48 
+ICE	_IceTransGetPeerAddr	49 
+ICE	_IceTransGetPeerNetworkId	50 
+ICE	_IceErrorBadMinor	51 
+ICE	_IceErrorBadLength	52 
+ICE	_IceErrorBadState	53 
+ICE	_IceErrorBadValue	54 
+ICE	_IcePaMagicCookie1Proc	55 
+ICE	_IcePoMagicCookie1Proc	56 
+ICE	_IceRead	57 
+ICE	_IceReadSkip	58 
+ICE	_IceWrite	59 
+ICE	_IceErrorNoAuthentication	60 
+ICE	_IceErrorNoVersion	61 
+ICE	_IceErrorAuthenticationRejected	62 
+ICE	_IceErrorAuthenticationFailed	63 
+ICE	_IceErrorProtocolDuplicate	64 
+ICE	_IceErrorMajorOpcodeDuplicate	65 
+ICE	_IceErrorUnknownProtocol	66 
+ICE	_IceErrorBadMajor	67 
+ICE	_IceDefaultErrorHandler	68 
+ICE	_IceDefaultIOErrorHandler	69 
+ICE	_IceGetPoValidAuthIndices	70 
+ICE	_IceGetPaValidAuthIndices	71 
+ICE	_IceAddOpcodeMapping	72 
+ICE	_IceGetPeerName	73 
+ICE	_IceProcessCoreMessage	74 
+ICE	_IceAddReplyWait	75 
+ICE	_IceSearchReplyWaits	76 
+ICE	_IceCheckReplyReady	77 
+ICE	_IceFreeConnection	78 
+ICE	_IceConnectionOpened	79 
+ICE	_IceConnectionClosed	80 
+ICE	_IceErrorSetupFailed	81 
+ICE	_IceGetPoAuthData	82 
+ICE	_IceGetPaAuthData	83 
+ICE	_IceTransOpenCOTSClient	84 
+ICE	_IceTransOpenCOTSServer	85 
+ICE	_IceTransOpenCLTSClient	86 
+ICE	_IceTransOpenCLTSServer	87 
+ICE	_IceTransSetOption	88 
+ICE	_IceTransCreateListener	89 
+ICE	_IceTransResetListener	90 
+ICE	_IceTransAccept	91 
+ICE	_IceTransConnect	92 
+ICE	_IceTransBytesReadable	93 
+ICE	_IceTransRead	94 
+ICE	_IceTransWrite	95 
+ICE	_IceTransReadv	96 
+ICE	_IceTransWritev	97 
+ICE	_IceTransDisconnect	98 
+ICE	_IceTransClose	99 
+ICE	_IceTransCloseForCloning	100 
+ICE	_IceTransIsLocal	101 
+ICE	_IceTransGetMyAddr	102 
+ICE	_IceTransGetConnectionNumber	103 
+ICE	_IceTransMakeAllCOTSServerListeners	104 
+ICE	_IceTransMakeAllCLTSServerListeners	105 
+ICE	_IceTransGetHostname	106 
+ICE	_IceTransGetMyNetworkId	107 
+ICE	_IceConnectionCount	108 
+ICE	_IceLastMajorOpcode	109 
+ICE	_IceAuthCount	110 
+ICE	_IceAuthNames	111 
+ICE	_IcePoAuthProcs	112 
+ICE	_IcePaAuthProcs	113 
+ICE	_IcePaAuthDataEntryCount	114 
+ICE	_IceVersionCount	115 
+ICE	_IceVersions	116 
+ICE	_IceWatchProcs	117 
+ICE	_IceErrorHandler	118 
+ICE	_IceIOErrorHandler	119 
+ICE	_IceConnectionObjs	120 
+ICE	_IceConnectionStrings	121 
+ICE	_IceProtocols	122 
+ICE	_IcePaAuthDataEntries	123 
+ICE	_IceTransSocketINETFuncs	124 
+ICE	_IceTransSocketTCPFuncs	125 
+ICE	IceListenForWellKnownConnections	126 
+LIBRARY SM SM
+SM	SmFreeProperty	1 
+SM	SmFreeReasons	2 
+SM	SmcClientID	3 
+SM	SmcCloseConnection	4 
+SM	SmcDeleteProperties	5 
+SM	SmcGetIceConnection	6 
+SM	SmcGetProperties	7 
+SM	SmcInteractDone	8 
+SM	SmcInteractRequest	9 
+SM	SmcModifyCallbacks	10 
+SM	SmcOpenConnection	11 
+SM	SmcProtocolRevision	12 
+SM	SmcProtocolVersion	13 
+SM	SmcRelease	14 
+SM	SmcRequestSaveYourself	15 
+SM	SmcRequestSaveYourselfPhase2	16 
+SM	SmcSaveYourselfDone	17 
+SM	SmcSetErrorHandler	18 
+SM	SmcSetProperties	19 
+SM	SmcVendor	20 
+SM	SmsCleanUp	21 
+SM	SmsClientHostName	22 
+SM	SmsClientID	23 
+SM	SmsDie		24 
+SM	SmsGenerateClientID	25 
+SM	SmsGetIceConnection	26 
+SM	SmsInitialize	27 
+SM	SmsInteract	28 
+SM	SmsProtocolRevision	29 
+SM	SmsProtocolVersion	30 
+SM	SmsRegisterClientReply	31 
+SM	SmsReturnProperties	32 
+SM	SmsSaveComplete	33 
+SM	SmsSaveYourself	34 
+SM	SmsSaveYourselfPhase2	35 
+SM	SmsSetErrorHandler	36 
+SM	SmsShutdownCancelled	37 
+SM	_SmcProcessMessage	38 
+SM	_SmsProcessMessage	39 
+SM	_SmcDefaultErrorHandler	40 
+SM	_SmsDefaultErrorHandler	41 
+SM	_SmsProtocolSetupProc	42 
+SM	_SmcOpcode	43 
+SM	_SmsOpcode	44 
+SM	_SmVersionCount	45 
+SM	_SmcVersions	46 
+SM	_SmsVersions	47 
+SM	_SmAuthCount	48 
+SM	_SmAuthNames	49 
+SM	_SmcAuthProcs	50 
+SM	_SmsAuthProcs	51 
+SM	_SmcErrorHandler	52 
+SM	_SmsErrorHandler	53 
+SM	_SmsNewClientProc	54 
+SM	_SmsNewClientData	55 
+LIBRARY Xft Xft
+Xft	XftConfigAddDir	1
+Xft	XftConfigAddEdit	2
+Xft	XftConfigGetCache	3
+Xft	XftConfigSetCache	4
+Xft	XftConfigSubstitute	5
+Xft	_XftConfigCompareValue	6
+Xft	XftColorAllocName	7
+Xft	XftColorAllocValue	8
+Xft	XftColorFree	9
+Xft	XftCoreConvert16	10
+Xft	XftCoreConvert32	11
+Xft	XftCoreConvertUtf8	12
+Xft	XftCoreExtents16	13
+Xft	XftCoreExtents32	14
+Xft	XftCoreExtents8	15
+Xft	XftCoreExtentsUtf8	16
+Xft	XftCoreGlyphExists	17
+Xft	XftEditPrint	18
+Xft	XftExprPrint	19
+Xft	XftFontSetPrint	20
+Xft	XftOpPrint	21
+Xft	XftPatternPrint	22
+Xft	XftSubstPrint	23
+Xft	XftTestPrint	24
+Xft	XftValueListPrint	25
+Xft	XftValuePrint	26
+Xft	XftDefaultGetBool	27
+Xft	XftDefaultGetDouble	28
+Xft	XftDefaultGetInteger	29
+Xft	XftDefaultHasRender	30
+Xft	XftDefaultParseBool	31
+Xft	XftDefaultSet	32
+Xft	XftDefaultSubstitute	33
+Xft	XftDisplayGetFontSet	34
+Xft	XftDrawChange	35
+Xft	XftDrawCorePrepare	36
+Xft	XftDrawCreate	37
+Xft	XftDrawCreateBitmap	38
+Xft	XftDrawDestroy	39
+Xft	XftDrawRect	40
+Xft	XftDrawRenderPrepare	41
+Xft	XftDrawSetClip	42
+Xft	XftDrawString16	43
+Xft	XftDrawString32	44
+Xft	XftDrawString8	45
+Xft	XftDrawStringUtf8	46
+Xft	XftTextExtents16	47
+Xft	XftTextExtents32	48
+Xft	XftTextExtents8	49
+Xft	XftTextExtentsUtf8	50
+Xft	XftFontClose	51
+Xft	XftFontMatch	52
+Xft	XftFontOpen	53
+Xft	XftFontOpenName	54
+Xft	XftFontOpenPattern	55
+Xft	XftFontOpenXlfd	56
+Xft	XftGlyphExists	57
+Xft	_XftFontDebug	58
+Xft	XftFontSetAdd	59
+Xft	XftFontSetCreate	60
+Xft	XftFontSetDestroy	61
+Xft	XftConfigSaveField	62
+Xft	XftConfigerror	63
+Xft	XftConfigparse	64
+Xft	XftConfigwrap	65
+Xft	XftEditCreate	66
+Xft	XftEditDestroy	67
+Xft	XftExprCreateBool	68
+Xft	XftExprCreateDouble	69
+Xft	XftExprCreateField	70
+Xft	XftExprCreateInteger	71
+Xft	XftExprCreateNil	72
+Xft	XftExprCreateOp	73
+Xft	XftExprCreateString	74
+Xft	XftExprDestroy	75
+Xft	XftTestCreate	76
+Xft	XftInit	77
+Xft	XftConfigLexFile	78
+Xft	XftConfigPushInput	79
+Xft	XftConfig_create_buffer	80
+Xft	XftConfig_delete_buffer	81
+Xft	XftConfig_flush_buffer	82
+Xft	XftConfig_init_buffer	83
+Xft	XftConfig_load_buffer_state	84
+Xft	XftConfig_scan_buffer	85
+Xft	XftConfig_scan_bytes	86
+Xft	XftConfig_scan_string	87
+Xft	XftConfig_switch_to_buffer	88
+Xft	XftConfiglex	89
+Xft	XftConfigrestart	90
+Xft	XftListAppend	91
+Xft	XftListFontSets	92
+Xft	XftListFonts	93
+Xft	XftListFontsPatternObjects	94
+Xft	XftListMatch	95
+Xft	XftListValueCompare	96
+Xft	XftListValueListCompare	97
+Xft	XftObjectSetAdd	98
+Xft	XftObjectSetBuild	99
+Xft	XftObjectSetCreate	100
+Xft	XftObjectSetDestroy	101
+Xft	XftObjectSetVaBuild	102
+Xft	XftFontSetMatch	103
+Xft	XftNameConstant	104
+Xft	XftNameParse	105
+Xft	XftNameUnparse	106
+Xft	XftPatternAdd	107
+Xft	XftPatternAddBool	108
+Xft	XftPatternAddDouble	109
+Xft	XftPatternAddInteger	110
+Xft	XftPatternAddString	111
+Xft	XftPatternBuild	112
+Xft	XftPatternCreate	113
+Xft	XftPatternDel	114
+Xft	XftPatternDestroy	115
+Xft	XftPatternDuplicate	116
+Xft	XftPatternFind	117
+Xft	XftPatternGet	118
+Xft	XftPatternGetBool	119
+Xft	XftPatternGetDouble	120
+Xft	XftPatternGetInteger	121
+Xft	XftPatternGetString	122
+Xft	XftPatternVaBuild	123
+Xft	XftValueDestroy	124
+Xft	XftValueListDestroy	125
+Xft	XftUtf8Len	126
+Xft	XftUtf8ToUcs4	127
+Xft	_XftDownStr	128
+Xft	_XftGetInt	129
+Xft	_XftMatchSymbolic	130
+Xft	_XftSaveString	131
+Xft	_XftSplitField	132
+Xft	_XftSplitStr	133
+Xft	_XftSplitValue	134
+Xft	_XftStrCmpIgnoreCase	135
+Xft	XftCoreAddFonts	136
+Xft	XftCoreClose	137
+Xft	XftCoreOpen	138
+Xft	XftXlfdParse	139
+Xft	XftInitFtLibrary	140
+Xft	XftConfigDirs	141
+Xft	XftDirScan	142
+Xft	XftDirSave	143
+LIBRARY Xmuu
+Xmuu	XmuClientWindow	1
+Xmuu	XmuCursorNameToIndex	2
+Xmuu	XmuPrintDefaultErrorMessage	3
+Xmuu	XmuSimpleErrorHandler	4
+Xmuu	XmuGetHostname	5
+Xmuu	XmuCompareISOLatin1	6
+Xmuu	XmuCopyISOLatin1Lowered	7
+Xmuu	XmuCopyISOLatin1Uppered	8
+Xmuu	XmuNCopyISOLatin1Lowered	9
+Xmuu	XmuNCopyISOLatin1Uppered	10
+Xmuu	XmuSnprintf	11
+LIBRARY	GLU
+GLU	bezierPatchDelete	1
+GLU	bezierPatchDeleteList	2
+GLU	bezierPatchDraw	3
+GLU	bezierPatchEval	4
+GLU	bezierPatchEvalNormal	5
+GLU	bezierPatchInsert	6
+GLU	bezierPatchListDraw	7
+GLU	bezierPatchMake	8
+GLU	bezierPatchMake2	9	
+GLU	bezierPatchPrint	10
+GLU	bezierPatchPrintList	11
+GLU	bezierPatchMeshBeginStrip	12
+GLU	bezierPatchMeshDelDeg	13
+GLU	bezierPatchMeshDelete	14
+GLU	bezierPatchMeshDraw	15
+GLU	bezierPatchMeshEndStrip	16
+GLU	bezierPatchMeshEval	17
+GLU	bezierPatchMeshInsertUV	18
+GLU	bezierPatchMeshListCollect	19
+GLU	bezierPatchMeshListDelDeg	20
+GLU	bezierPatchMeshListDelete	21
+GLU	bezierPatchMeshListDraw	22
+GLU	bezierPatchMeshListEval	23
+GLU	bezierPatchMeshListInsert	24
+GLU	bezierPatchMeshListNumTriangles	25
+GLU	bezierPatchMeshListPrint	26
+GLU	bezierPatchMeshListReverse	27
+GLU	bezierPatchMeshListTotalStrips	28
+GLU	bezierPatchMeshListTotalVert	29
+GLU	bezierPatchMeshMake	30
+GLU	bezierPatchMeshMake2	31
+GLU	bezierPatchMeshNumTriangles	32
+GLU	bezierPatchMeshPrint	33
+GLU	bezierPatchMeshPutPatch	34
+GLU	drawStrips	35
+GLU	gluBeginCurve	36
+GLU	gluBeginSurface	37
+GLU	gluBeginTrim	38
+GLU	gluDeleteNurbsRenderer	39
+GLU	gluDeleteNurbsTessellatorEXT	40
+GLU	gluEndCurve	41
+GLU	gluEndSurface	42
+GLU	gluEndTrim	43
+GLU	gluGetNurbsProperty	44
+GLU	gluLoadSamplingMatrices	45
+GLU	gluNewNurbsRenderer	46
+GLU	gluNurbsCallback	47
+GLU	gluNurbsCallbackData	48
+GLU	gluNurbsCallbackDataEXT	49
+GLU	gluNurbsCurve	50
+GLU	gluNurbsProperty	51
+GLU	gluNurbsSurface	52
+GLU	gluPwlCurve	53
+GLU	glu_LOD_eval_list	54
+GLU	__gl_dictListDelete	55
+GLU	__gl_dictListDeleteDict	56
+GLU	__gl_dictListInsertBefore	57
+GLU	__gl_dictListNewDict	58
+GLU	__gl_dictListSearch	59
+GLU	__gl_edgeEval	60
+GLU	__gl_edgeIntersect	61
+GLU	__gl_edgeSign	62
+GLU	__gl_transEval	63
+GLU	__gl_transSign	64
+GLU	__gl_vertCCW	65
+GLU	__gl_vertLeq	66
+GLU	__gl_memInit	67
+GLU	__gl_meshAddEdgeVertex	68
+GLU	__gl_meshConnect	69
+GLU	__gl_meshDelete	70
+GLU	__gl_meshDeleteMesh	71
+GLU	__gl_meshMakeEdge	72
+GLU	__gl_meshNewMesh	73
+GLU	__gl_meshSplice	74
+GLU	__gl_meshSplitEdge	75
+GLU	__gl_meshUnion	76
+GLU	__gl_meshZapFace	77
+GLU	__gl_projectPolygon	78
+GLU	__gl_pqHeapDelete	79
+GLU	__gl_pqHeapDeletePriorityQ	80
+GLU	__gl_pqHeapExtractMin	81
+GLU	__gl_pqHeapInit	82
+GLU	__gl_pqHeapInsert	83
+GLU	__gl_pqHeapNewPriorityQ	84
+GLU	__gl_pqSortDelete	85
+GLU	__gl_pqSortDeletePriorityQ	86
+GLU	__gl_pqSortExtractMin	87
+GLU	__gl_pqSortInit	88
+GLU	__gl_pqSortInsert	89
+GLU	__gl_pqSortIsEmpty	90
+GLU	__gl_pqSortMinimum	91
+GLU	__gl_pqSortNewPriorityQ	92
+GLU	__gl_renderBoundary	93
+GLU	__gl_renderCache	94
+GLU	__gl_renderMesh	95
+GLU	__gl_computeInterior	96
+GLU	__gl_noBeginData	97
+GLU	__gl_noCombineData	98
+GLU	__gl_noEdgeFlagData	99
+GLU	__gl_noEndData	100
+GLU	__gl_noErrorData	101
+GLU	__gl_noVertexData	102
+GLU	gluBeginPolygon	103
+GLU	gluDeleteTess	104
+GLU	gluEndPolygon	105
+GLU	gluGetTessProperty	106
+GLU	gluNewTess	107
+GLU	gluNextContour	108
+GLU	gluTessBeginContour	109
+GLU	gluTessBeginPolygon	110
+GLU	gluTessCallback	111
+GLU	gluTessEndContour	112
+GLU	gluTessEndPolygon	113
+GLU	gluTessNormal	114
+GLU	gluTessProperty	115
+GLU	gluTessVertex	116
+GLU	__gl_meshDiscardExterior	117
+GLU	__gl_meshSetWindingNumber	118
+GLU	__gl_meshTessellateInterior	119
+GLU	__gl_meshTessellateMonoRegion	120
+GLU	gluErrorString	121
+GLU	gluBuild1DMipmapLevels	122
+GLU	gluBuild1DMipmaps	123
+GLU	gluBuild2DMipmapLevels	124
+GLU	gluBuild2DMipmaps	125
+GLU	gluBuild3DMipmapLevels	126
+GLU	gluBuild3DMipmaps	127
+GLU	gluScaleImage	128
+GLU	gluScaleImage3D	129
+GLU	gluLookAt	130
+GLU	gluOrtho2D	131
+GLU	gluPerspective	132
+GLU	gluPickMatrix	133
+GLU	gluProject	134
+GLU	gluUnProject	135
+GLU	gluUnProject4	136
+GLU	gluCylinder	137
+GLU	gluDeleteQuadric	138
+GLU	gluDisk	139
+GLU	gluNewQuadric	140
+GLU	gluPartialDisk	141
+GLU	gluQuadricCallback	142
+GLU	gluQuadricDrawStyle	143
+GLU	gluQuadricNormals	144
+GLU	gluQuadricOrientation	145
+GLU	gluQuadricTexture	146
+GLU	gluSphere	147
+GLU	gluCheckExtension	148
+GLU	gluGetString	149
+LIBRARY	Xrandr Xrandr
+Xrandr	XRRCurrentConfig	1
+Xrandr	XRRFindDisplay	2
+Xrandr	XRRFreeScreenInfo	3
+Xrandr	XRRGetScreenInfo	4
+Xrandr	XRRQueryExtension	5
+Xrandr	XRRQueryVersion	6
+Xrandr	XRRRootToScreen	7
+Xrandr	XRRRotations	8
+Xrandr	XRRScreenChangeSelectInput	9
+Xrandr	XRRSetScreenConfig	10
+Xrandr	XRRSizes	11
+Xrandr	XRRTimes	12
+Xrandr	XRRVisualIDToVisual	13
+Xrandr	XRRVisualToDepth	14
+LIBRARY freetype freetype
+freetype	ah_arctan	1
+freetype	autohint_module_class	2
+freetype	autohinter_interface	3
+freetype	cff_driver_class	4
+freetype	FT_Access_Frame	5
+freetype	FT_Add64	6
+freetype	FT_Add_Module	7
+freetype	FT_Alloc	8
+freetype	FT_Attach_File	9
+freetype	FT_Attach_Stream	10
+freetype	FT_Create_Extensions	11
+freetype	FT_Destroy_Extensions	12
+freetype	FT_Div64by32	13
+freetype	FT_DivFix	14
+freetype	FT_Done_Extensions	15
+freetype	FT_Done_Face	16
+freetype	FT_Done_GlyphSlot	17
+freetype	FT_Done_Library	18
+freetype	FT_Done_Size	19
+freetype	FT_Done_Stream	20
+freetype	FT_Extract_Frame	21
+freetype	FT_Forget_Frame	22
+freetype	FT_Free	23
+freetype	FT_Get_Char	24
+freetype	FT_Get_Char_Index	25
+freetype	FT_Get_Extension	26
+freetype	FT_Get_Glyph_Name	27
+freetype	FT_Get_Kerning	28
+freetype	FT_Get_Long	29
+freetype	FT_Get_LongLE	30
+freetype	FT_Get_Module	31
+freetype	FT_Get_Module_Interface	32
+freetype	FT_Get_Offset	33
+freetype	FT_Get_Renderer	34
+freetype	FT_Get_Sfnt_Name	35
+freetype	FT_Get_Sfnt_Name_Count	36
+freetype	FT_Get_Sfnt_Table	37
+freetype	FT_Get_Short	38
+freetype	FT_Get_ShortLE	39
+freetype	FT_GlyphLoader_Add	40
+freetype	FT_GlyphLoader_Check_Points	41
+freetype	FT_GlyphLoader_Check_Subglyphs	42
+freetype	FT_GlyphLoader_Copy_Points	43
+freetype	FT_GlyphLoader_Create_Extra	44
+freetype	FT_GlyphLoader_Done	45
+freetype	FT_GlyphLoader_New	46
+freetype	FT_GlyphLoader_Prepare	47
+freetype	FT_GlyphLoader_Reset	48
+freetype	FT_GlyphLoader_Rewind	49
+freetype	FT_Init_Extensions	50
+freetype	FT_List_Add	51
+freetype	FT_List_Finalize	52
+freetype	FT_List_Find	53
+freetype	FT_List_Insert	54
+freetype	FT_List_Iterate	55
+freetype	FT_List_Remove	56
+freetype	FT_List_Up	57
+freetype	FT_Load_Char	58
+freetype	FT_Load_Glyph	59
+freetype	FT_Lookup_Renderer	60
+freetype	FT_MulDiv	61
+freetype	FT_MulFix	62
+freetype	FT_MulTo64	63
+freetype	FT_New_Face	64
+freetype	FT_New_GlyphSlot	65
+freetype	FT_New_Library	66	
+freetype	FT_New_Memory_Face	67
+freetype	FT_New_Memory_Stream	68
+freetype	FT_New_Size	69
+freetype	FT_Open_Face	70
+freetype	FT_Outline_Copy	71
+freetype	FT_Outline_Decompose	72
+freetype	FT_Outline_Done	73
+freetype	FT_Outline_Done_Internal	74
+freetype	FT_Outline_Get_Bitmap	75
+freetype	FT_Outline_Get_CBox	76
+freetype	FT_Outline_New	77
+freetype	FT_Outline_New_Internal	78
+freetype	FT_Outline_Render	79
+freetype	FT_Outline_Reverse	80
+freetype	FT_Outline_Transform	81
+freetype	FT_Outline_Translate	82
+freetype	FT_Read_Char	83
+freetype	FT_Read_Fields	84
+freetype	FT_Read_Long	85
+freetype	FT_Read_LongLE	86
+freetype	FT_Read_Offset	87
+freetype	FT_Read_Short	88
+freetype	FT_Read_ShortLE	89
+freetype	FT_Read_Stream	90
+freetype	FT_Read_Stream_At	91
+freetype	FT_Realloc	92
+freetype	FT_Register_Extension	93
+freetype	FT_Release_Frame	94
+freetype	FT_Remove_Module	95
+freetype	FT_Render_Glyph	96
+freetype	FT_Render_Glyph_Internal	97
+freetype	FT_Seek_Stream	98
+freetype	FT_Select_Charmap	99
+freetype	FT_Set_Char_Size	100
+freetype	FT_Set_Charmap	101
+freetype	FT_Set_Debug_Hook	102
+freetype	FT_Set_Pixel_Sizes	103
+freetype	FT_Set_Renderer	104
+freetype	FT_Set_Transform	105
+freetype	FT_Skip_Stream	106
+freetype	FT_Sqrt64	107
+freetype	FT_SqrtFixed	108
+freetype	FT_Stream_Pos	109
+freetype	FT_Vector_Transform	110
+freetype	FT_Outline_Get_BBox	111
+freetype	FT_Done_Glyph	112
+freetype	FT_Get_Glyph	113
+freetype	FT_Glyph_Copy	114
+freetype	FT_Glyph_Get_CBox	115
+freetype	FT_Glyph_To_Bitmap	116
+freetype	FT_Glyph_Transform	117
+freetype	FT_Matrix_Invert	118
+freetype	FT_Matrix_Multiply	119
+freetype	ft_bitmap_glyph_class	120
+freetype	ft_outline_glyph_class	121
+freetype	FT_Add_Default_Modules	122
+freetype	FT_Done_FreeType	123
+freetype	FT_Init_FreeType	124
+freetype	FT_Get_Multi_Master	125
+freetype	FT_Set_MM_Blend_Coordinates	126
+freetype	FT_Set_MM_Design_Coordinates	127
+freetype	FT_Done_Memory	128
+freetype	FT_New_Memory	129
+freetype	FT_New_Stream	130
+freetype	ps_table_funcs	131
+freetype	psaux_module_class	132
+freetype	t1_builder_funcs	133
+freetype	t1_decoder_funcs	134
+freetype	t1_parser_funcs	135
+freetype	psnames_module_class	136
+freetype	ft_raster1_renderer_class	137
+freetype	ft_raster5_renderer_class	138
+freetype	ft_standard_raster	139
+freetype	sbit_metrics_fields	140
+freetype	sfnt_module_class	141
+freetype	ft_grays_raster	142
+freetype	ft_smooth_renderer_class	143
+freetype	grays_raster_render	144
+freetype	TT_New_Context	145
+freetype	TT_RunIns	146
+freetype	tt_default_graphics_state	147
+freetype	tt_driver_class	148
+freetype	t1_driver_class	149
+freetype	t1cid_driver_class	150
+freetype	winfnt_driver_class	151
+LIBRARY	XTrap	XTrap
+XTrap	XEAddEventCB	1
+XTrap	XEAddEventCBs	2
+XTrap	XEAddRequestCB	3
+XTrap	XEAddRequestCBs	4
+XTrap	XERemoveAllEventCBs	5
+XTrap	XERemoveAllRequestCBs	6
+XTrap	XERemoveEventCB	7
+XTrap	XERemoveEventCBs	8
+XTrap	XERemoveRequestCB	9
+XTrap	XERemoveRequestCBs	10
+XTrap	XEChangeTC	11
+XTrap	XECreateTC	12
+XTrap	XEFreeTC	13
+XTrap	XESetCmdGateState	14
+XTrap	XETrapSetColorReplies	15
+XTrap	XETrapSetCommandKey	16
+XTrap	XETrapSetCursor	17
+XTrap	XETrapSetEvents	18
+XTrap	XETrapSetGrabServer	19
+XTrap	XETrapSetMaxPacket	20
+XTrap	XETrapSetRequests	21
+XTrap	XETrapSetStatistics	22
+XTrap	XETrapSetTimestamps	23
+XTrap	XETrapSetWinXY	24
+XTrap	XETrapSetXInput	25
+XTrap	XETrapDispatchXLib	26
+XTrap	XEPrintAvail	27
+XTrap	XEPrintAvailFlags	28
+XTrap	XEPrintAvailPktSz	29
+XTrap	XEPrintCfgFlags	30
+XTrap	XEPrintCmdKey	31
+XTrap	XEPrintCurPktSz	32
+XTrap	XEPrintCurXY	33
+XTrap	XEPrintCurrent	34
+XTrap	XEPrintEvents	35
+XTrap	XEPrintEvtStats	36
+XTrap	XEPrintLastTime	37
+XTrap	XEPrintMajOpcode	38
+XTrap	XEPrintPlatform	39
+XTrap	XEPrintRelease	40
+XTrap	XEPrintReqStats	41
+XTrap	XEPrintRequests	42
+XTrap	XEPrintStateFlags	43
+XTrap	XEPrintStatistics	44
+XTrap	XEPrintTkFlags	45
+XTrap	XEPrintTkRelease	46
+XTrap	XEPrintTkState	47
+XTrap	XEFlushConfig	48
+XTrap	XEGetAvailableRequest	49
+XTrap	XEGetCurrentRequest	50
+XTrap	XEGetLastInpTimeRequest	51
+XTrap	XEGetStatisticsRequest	52
+XTrap	XEGetVersionRequest	53
+XTrap	XEResetRequest	54
+XTrap	XESimulateXEventRequest	55
+XTrap	XEStartTrapRequest	56
+XTrap	XEStopTrapRequest	57
+XTrap	XEEventIDToString	58
+XTrap	XEEventStringToID	59
+XTrap	XEPlatformIDToString	60
+XTrap	XEPlatformStringToID	61
+XTrap	XERequestIDToExtString	62
+XTrap	XERequestIDToString	63
+XTrap	XERequestStringToID	64
+XTrap	XETrapQueryExtension	65
+XTrap	XETrapAppMainLoop	66
+XTrap	XETrapAppPending	67
+XTrap	XETrapAppWhileLoop	68
+XTrap	XETrapDispatchEvent	69
+XTrap	XETrapGetEventHandler	70
+XTrap	XETrapSetEventHandler	71
+XTrap	XETrapWaitForSomething	72
Index: xc/config/cf/sco5.cf
diff -u xc/config/cf/sco5.cf:3.8 xc/config/cf/sco5.cf:3.12
--- xc/config/cf/sco5.cf:3.8	Sat Jun 30 18:41:43 2001
+++ xc/config/cf/sco5.cf	Mon Feb 17 13:57:46 2003
@@ -1,14 +1,22 @@
-XCOMM $XFree86: xc/config/cf/sco5.cf,v 3.8 2001/06/30 22:41:43 tsi Exp $
+XCOMM $XFree86: xc/config/cf/sco5.cf,v 3.12 2003/02/17 18:57:46 dawes Exp $
 
 /*
- * This is for SCO Open Server 5.0.6A or later.
+ * This is for SCO Open Server 5.0.6A or later. You must have the
+ * Execution Environment update (OSS646) installed on 5.0.6 (it
+ * ships standard in 5.0.7 and later), as well as the Graphics,
+ * Web and X11 (gwxlibs) package OSS631 installed, which also ships
+ * standard with 5.0.7 and later.
+ *
+ * It is suggested that you use the GNU Development Tools for compiling
+ * XFree86. Almost no testing has been done with the native development
+ * system.
  */
 
 #ifndef OSName
 #define OSName                  UNIX System V/386 Open Server Release 5
 #endif
 #ifndef OSVendor
-#define OSVendor                Caldera
+#define OSVendor                SCO-Group
 #endif
 #ifndef OSMajorVersion
 #define OSMajorVersion          5
@@ -17,7 +25,7 @@
 #define OSMinorVersion          0
 #endif
 #ifndef OSTeenyVersion
-#define OSTeenyVersion          6
+#define OSTeenyVersion          7
 #endif
 
 /*
@@ -29,29 +37,46 @@
  * Note 2: We also define _SVID3, as this seems to enable more Streams
  * based options which are closer to the "desired" state for X11. A by-
  * product of this is that we get better signals too.
+ *
+ * Note 3: We fool Xfree into thinking we have NCURSES. Thats becuase the
+ * system curses is close enough for Xfree86's purposes. Actually xf86cfg
+ * is poorly constructed, it should not depend on the NCURSES package but
+ * rather on a "capable curses", of which NCURSES is just one.
  */
 
-#define StandardDefines         -Dsco -DSCO -DSYSV -Di386 -DSCO325 -DFD_SETSIZE=256 -D_NO_STATIC -DMAXPATHLEN=1024
+#if 1
+#ifndef HasGcc2
+# define HasGcc2		YES
+#endif
+#ifndef HasGcc2ForCplusplus
+# define HasGcc2ForCplusplus	YES
+#endif
+#endif
+
+#define StandardDefines		-Dsco -DSCO -DSCO5 -DSYSV -Di386 -DSCO325 -DFD_SETSIZE=256 -D_NO_STATIC -DMAXPATHLEN=1024
 #ifdef HasGcc2
-# define DefaultCCOptions       -melf GccWarningOptions
-# define CcCmd                  gcc
-# define ExtraLoadOptions       -melf
-# define DefaultCDebugFlags     -O
-# define OptimizedCDebugFlags   -O
+# define DefaultCCOptions       GccWarningOptions
+# define CcCmd			gcc
+# define DefaultCDebugFlags	-O2
+# define OptimizedCDebugFlags	-O2
 #else
-# define DefaultCCOptions       -dy
-# define CcCmd                  cc
-# define ExtraLoadOptions       -b elf
-# define DefaultCDebugFlags     -O
-# define OptimizedCDebugFlags   -O
+# define DefaultCCOptions	-dy
+# define CcCmd			cc -belf
+# define DefaultCDebugFlags	-O2
+# define OptimizedCDebugFlags	-O2
 #endif
 
+#define	HasNCurses		YES
+#define NCursesLibName		-lcurses
+
+#define LogDirectory		/var/adm
+
 #ifndef PexDynamicModule
-#define PexDynamicModule        NO
+#define PexDynamicModule        YES
 #endif
 
 #ifndef XieDynamicModule
-#define XieDynamicModule        NO
+#define XieDynamicModule        YES
 #endif
 
 #ifndef HasSymLinks
@@ -64,6 +89,7 @@
 # define SCODynamicFlags	/**/
 #endif
 
+#define AsmDefines		-D__ELF__ -D__PIC__
 #define XawI18nDefines          -DHAS_WCHAR_H -DHAS_ISW_FUNCS
 #define ServerExtraSysLibs      $(CBRT) -lm -levent SCODynamicFlags
 #define ExtraLibraries          -lsocket
@@ -76,12 +102,13 @@
 #define HasVFork                YES
 #define HasPutenv               YES
 #define HasSnprintf             YES
+#define HasSetenv		NO
 #define ExecableScripts         YES
 #define HasShadowPasswd         YES
-#define ManSourcePath           $(MANPATH)/cat.
+#define ManSourcePath           $(MANPATH)/man
 #define Malloc0ReturnsNull      YES
 #define RemoveDSDENroffMacros   NO
-#define CompressManPages        YES
+#define CompressManPages        NO
 
 #ifndef HasLibCrypt
 # define HasLibCrypt            YES
@@ -90,40 +117,57 @@
 #define PosixLibraries          /**/
 
 #ifndef ForceNormalLib
-# define ForceNormalLib         YES 
+# define ForceNormalLib         NO 
 #endif
+
+#define HasExpat		YES
+#define HasFreetype2		YES
+#define HasLibpng		YES
+#define HasPerl5		YES
+#define HasDlopen		YES
+#define HasShm			YES
+#define HasStrcasecmp		YES
+#define HasZlib			YES
+#define HasFontconfig		YES
 
-#define SharedLibXmu            NO
+#define SharedLibXmu            YES
 #define SystemV                 YES
 #define LdCombineFlags          -r 
 
 #define HasLdRunPath            YES
 #define HasPoll                 YES
-#define PatheticCpp             YES
+#define PatheticCpp		YES
 
 #define ArCmdBase               ar
-#define AsCmd                   as
-#define CppCmd                  /lib/cpp
+#define AsCmd                   CcCmd
+#define CppCmd			/lib/cpp
+#define RawCppCmd		CppCmd
 #define LdCmd                   ld
 #define LexCmd                  flex
 #define MakeCmd	                make
 #define YaccCmd                 yacc
+#define InstallCmd		/usr/gnu/bin/ginstall
+
+#ifndef UseSeparateConfDir
+#define UseSeparateConfDir	NO
+#endif
+
+#ifndef BuildHtmlManPages
+#define BuildHtmlManPages	NO
+#endif
 
-#define DefaultUserPath         /bin:/usr/bin:$(BINDIR):/usr/bin/X11:/usr/local/bin:/etc
+#define DefaultUserPath         /bin:/usr/bin:$(BINDIR):/usr/bin/X11:/usr/gnu/bin:/usr/local/bin:/etc
 #define DefaultSystemPath       /etc:/bin:/usr/bin:$(BINDIR):/usr/bin/X11
 
 #define ConnectionFlags         -DLOCALCONN -DTCPCONN -DUNIXCONN 
 
 #define SharedGLUReqs           $(LDPRELIB) $(XLIB) $(GLXLIB)
 
-#define InstallManPageAliases(file,destdir,aliases)                     @@\
-install.man::                                                           @@\
-        @(SUFFIX=`echo $(DESTDIR)destdir/file.* | cut -f3,4 -d.`; \     @@\
-        for i in aliases; do (set -x; \                                 @@\
-        $(RM) $(DESTDIR)destdir/$$i.*; \                                @@\
-        (cd $(DESTDIR)destdir; $(LN) file.$${SUFFIX} \                  @@\
-        $$i.$${SUFFIX})); \                                             @@\
-        done)
+#define ObjectFromAsmSource(src,flags)					@@\
+									@@\
+src.o: src.S								@@\
+	RemoveFile(src.o)						@@\
+	$(CC) -c AsmDefines $(DEFINES) $(INCLUDES) flags src.S
 
 #include <scoLib.rules>  /* minor changes to sv4Lib.rules */
 #include <sv4Lib.rules>
Index: xc/config/cf/scoLib.rules
diff -u xc/config/cf/scoLib.rules:1.7 xc/config/cf/scoLib.rules:1.9
--- xc/config/cf/scoLib.rules:1.7	Sat Jun 30 18:41:43 2001
+++ xc/config/cf/scoLib.rules	Wed Nov 20 18:00:34 2002
@@ -1,6 +1,10 @@
 XCOMM $Xorg: scoLib.rules,v 1.3 2000/08/17 19:41:48 cpqbld Exp $
-XCOMM $XFree86: xc/config/cf/scoLib.rules,v 1.7 2001/06/30 22:41:43 tsi Exp $
+XCOMM $XFree86: xc/config/cf/scoLib.rules,v 1.9 2002/11/20 23:00:34 dawes Exp $
 
+#ifndef ExtraLoadFlags
+#define ExtraLoadFlags -R $(USRLIBDIRPATH)
+#endif
+
 /*
  * SharedLibraryTarget3 - generate rules to create a shared library;
  * build it into a different name so that we do not hose people by having
@@ -14,7 +18,7 @@
 									@@\
 Concat(lib,libname.so.rev): solist1 solist2 solist3 $(EXTRALIBRARYDEPS)	@@\
 	$(RM) $@~							@@\
-	echo -n $(LD) -o up/$@~ $(SHLIBLDFLAGS) -h $(DESTDIR)$(SHLIBDIR)/$@ solist1 " " > Concat(down/lib,cmd) 	@@\
+	echo -n $(LD) -o up/$@~ $(SHLIBLDFLAGS) -R $(DESTDIR)$(SHLIBDIR) -h $@ solist1 " " > Concat(down/lib,cmd) 	@@\
 	echo -n solist2 " " >> Concat(down/lib,cmd)			@@\
 	echo -n solist3  >> Concat(down/lib,cmd)			@@\
 	(cd down; $(SHELL) Concat(./lib,cmd))				@@\
@@ -34,7 +38,7 @@
 #ifndef LinkWithExports
 # if UseExportLists
 #  define LinkWithExports(libname,rev,solist,down,up) \
-	(cd down; $(CCENVSETUP) $(LD) -o up/$@~ $(SHLIBLDFLAGS) -h $(DESTDIR)$(SHLIBDIR)/$@ solist $(REQUIREDLIBS))	@@\
+	(cd down; $(CCENVSETUP) $(LD) -o up/$@~ $(SHLIBLDFLAGS) -R $(DESTDIR)$(SHLIBDIR) -h $@ solist $(REQUIREDLIBS))	@@\
 	if [ -f Concat(lib,libname.elist) ]; then \			@@\
 	    $(RM) down/$@.exports $@.list; \				@@\
 	    $(CPP) $(ALLINCLUDES) $(EXTRA_DEFINES) $(PROTO_DEFINES) $(THREADS_DEFINES) $(DEFINES) Concat(lib,libname.elist) | CppSedMagic >$@.list; \	@@\
@@ -44,18 +48,6 @@
 	fi;
 # else
 #  define LinkWithExports(libname,rev,solist,down,up) \
-	(cd down; $(CCENVSETUP) $(LD) -o up/$@~ $(SHLIBLDFLAGS) -h $(DESTDIR)$(SHLIBDIR)/$@ solist $(REQUIREDLIBS))
+	(cd down; $(CCENVSETUP) $(LD) -o up/$@~ $(SHLIBLDFLAGS) -R $(DESTDIR)$(SHLIBDIR) -h $@ solist $(REQUIREDLIBS))
 # endif
 #endif
-
-/*
- * Redefine this so we can drop -b elf and build COFF objects for the
- * archived library.  This assumes -b elf is hanging out in CCOPTIONS
- */
-#ifndef UnsharedLibObjCompile
-#define UnsharedLibObjCompile(options) RemoveFile($@)                  @@\
-        ClearmakeOSName                                                  \
-        $(CC) -c $(CDEBUGFLAGS) $(CLIBDEBUGFLAGS) $(THREADS_CFLAGS) $(ALLDEFINES) options $*.c @@\
-        $(MV) $@ unshared/$@
-#endif
-
Index: xc/config/cf/site.def
diff -u xc/config/cf/site.def:3.24 xc/config/cf/site.def:3.25
--- xc/config/cf/site.def:3.24	Sun Jun 25 16:17:29 2000
+++ xc/config/cf/site.def	Tue Feb 26 19:51:12 2002
@@ -21,7 +21,7 @@
  * .cf file, not overridden in site.def.                                   *
  *                                                                         *
  ***************************************************************************/
-XCOMM site:  $XFree86: xc/config/cf/site.def,v 3.24 2000/06/25 20:17:29 dawes Exp $
+XCOMM site:  $XFree86: xc/config/cf/site.def,v 3.25 2002/02/27 00:51:12 dawes Exp $
 
 /* if you want host-specific customization, this is one way to do it */
 /*
@@ -34,19 +34,7 @@
 
 #ifdef BeforeVendorCF
 
-#if defined(NetBSDArchitecture) && defined(Arm32Architecture)
 /*
- * Our kernel is 1.2C, but at user-level we're still 1.2 -JJK
- */
-#define OSTeenyVersion 0
-
-/*
- * This causes a problem with the X server, so I'm disabling it for now. -JJK
- */
-#define BuildXKB              NO
-#endif
-
-/*
  * Include this for easy XFree86 customisations
  */
 #ifndef SiteIConfigFiles
@@ -57,7 +45,7 @@
 
 #include <xf86site.def>
 
-/* On systems where cpp doesn't expand correctly macros in include directives
+/* On systems where cpp doesn't correctly expand macros in include directives
  * the two following macros need to be defined directly (where "X11" is
  * really whatever the TopLevelProject macro is defined to be).
  */
Index: xc/config/cf/sun.cf
diff -u xc/config/cf/sun.cf:3.61 xc/config/cf/sun.cf:3.67
--- xc/config/cf/sun.cf:3.61	Thu Jan  3 11:33:49 2002
+++ xc/config/cf/sun.cf	Fri Nov 22 17:55:56 2002
@@ -3,7 +3,7 @@
 
 
 
-XCOMM platform:  $XFree86: xc/config/cf/sun.cf,v 3.61 2002/01/03 16:33:49 tsi Exp $
+XCOMM platform:  $XFree86: xc/config/cf/sun.cf,v 3.67 2002/11/22 22:55:56 tsi Exp $
 
 #ifndef OSName
 # define OSName		DefaultOSName
@@ -29,7 +29,7 @@
  *
  * For SunPro C, define HasSunC to YES in site.def.  
  * For CenterLine C, define HasCenterLineC to YES in site.def
- * For gcc or gcc2, define HasGcc or HasGcc2 to YES in site.def
+ * For gcc, gcc2 or gcc3, define HasGcc, HasGcc2 or HasGcc3 to YES in site.def
  * For other compilers, define HasSunC to NO in site.def, then 
  *    provide appropriate values for the various compiler related
  *    configuration varibles used here.
@@ -55,15 +55,18 @@
  *
  */
 
+#ifndef HasGcc3
+#define HasGcc3 NO
+#endif
 #ifndef HasGcc2
-#define HasGcc2 NO
+#define HasGcc2 HasGcc3
 #endif
 #ifndef HasGcc
 #define HasGcc HasGcc2
 #endif
 
 #ifndef HasSunC
-# if (HasCenterLineC || HasGcc || HasGcc2 || OSMajorVersion < 5)
+# if HasCenterLineC || HasGcc || HasGcc2 || HasGcc3 || (OSMajorVersion < 5)
 #  define HasSunC NO
 # else
 #  define HasSunC YES
@@ -91,6 +94,9 @@
  * #endif
  */
 
+#ifndef HasSunCplusplus
+# define HasSunCplusplus HasSunC	/* ??? */
+#endif
 #if HasSunCplusplus
 # ifndef HasCplusplus
 #  define HasCplusplus YES
@@ -296,6 +302,9 @@
 #define HasSecureRPC	  YES
 #define SetTtyGroup	  YES
 #define HasPutenv	  YES
+#if (OSMajorVersion > 5) || ((OSMajorVersion == 5) && (OSMinorVersion >= 9))
+# define HasIssetugid	  YES
+#endif
 #ifndef i386Architecture
 # ifndef Xsun24Server
 #  define Xsun24Server	  NO		/* color, mono, multiple depths */
@@ -344,7 +353,7 @@
 #if HasGcc
 # if OSMajorVersion > 4
 #  ifndef DefaultCCOptions
-#   if UseInstalled
+#   ifdef UseInstalled
 #    define DefaultCCOptions -DNO_ASM
 #   elif OSMinorVersion > 6
 #    define DefaultCCOptions -DNO_ASM GccWarningOptions
@@ -359,6 +368,9 @@
 #  ifndef CcCmd
 #   define CcCmd gcc
 #  endif
+#  ifndef AsCmd
+#   define AsCmd CcCmd -c -x assembler
+#  endif
 #  ifndef OptimizedCDebugFlags
 #   ifdef i386Architecture
 #    define OptimizedCDebugFlags DefaultGcc2i386Opt
@@ -490,3 +502,19 @@
 	-DMULTIBYTE -DNLS16 -DMESSAGE_CAT -D_XOPEN_VERSION=4 \
 	-D_XOPEN_SOURCE -D__EXTENSIONS__ \
 	-DOSMAJORVERSION=OSMajorVersion -DOSMINORVERSION=OSMinorVersion
+
+
+/*
+ * Turn off HTML manpages like we do under NetBSD.
+ */
+#ifndef	BuildHtmlManPages
+#define	BuildHtmlManPages	NO
+#endif
+
+/*
+ * Turn off seperate configuration directories.
+ */
+#ifndef	UseSeparateConfDir
+#define	UseSeparateConfDir	NO
+#endif
+
Index: xc/config/cf/sv3Lib.rules
diff -u xc/config/cf/sv3Lib.rules:3.4 xc/config/cf/sv3Lib.rules:3.5
--- xc/config/cf/sv3Lib.rules:3.4	Wed Jan 17 11:38:49 2001
+++ xc/config/cf/sv3Lib.rules	Fri Nov 22 17:55:56 2002
@@ -2,7 +2,7 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/sv3Lib.rules,v 3.4 2001/01/17 16:38:49 dawes Exp $
+XCOMM $XFree86: xc/config/cf/sv3Lib.rules,v 3.5 2002/11/22 22:55:56 tsi Exp $
 /*
  * SVR3 shared library rules
  * Copyright (c) 1992, 1993 by Thomas Wolfram, Berlin, Germany
@@ -96,6 +96,10 @@
 # else
 #  define PositionIndependentCplusplusFlags /**/
 # endif
+#endif
+
+#ifndef StripInstalledPrograms
+# define StripInstalledPrograms NO
 #endif
 
 #if 0
Index: xc/config/cf/sv4Lib.rules
diff -u xc/config/cf/sv4Lib.rules:3.8 xc/config/cf/sv4Lib.rules:3.9
--- xc/config/cf/sv4Lib.rules:3.8	Sun May 27 22:42:25 2001
+++ xc/config/cf/sv4Lib.rules	Fri Nov 22 17:55:56 2002
@@ -4,7 +4,7 @@
  * SVR4 shared library rules
  */
 
-XCOMM $XFree86: xc/config/cf/sv4Lib.rules,v 3.8 2001/05/28 02:42:25 tsi Exp $
+XCOMM $XFree86: xc/config/cf/sv4Lib.rules,v 3.9 2002/11/22 22:55:56 tsi Exp $
 
 #ifndef HasSharedLibraries
 # define HasSharedLibraries YES
@@ -12,6 +12,9 @@
 #ifndef SharedDataSeparation
 # define SharedDataSeparation NO
 #endif
+#ifndef HasGcc2ForCplusplus
+# define HasGcc2ForCplusplus HasGcc2
+#endif
 #ifndef SharedCodeDef
 # define SharedCodeDef /**/
 #endif
@@ -40,6 +43,9 @@
 #endif
 #ifndef UseExportLists
 # define UseExportLists NO
+#endif
+#ifndef StripInstalledPrograms
+# define StripInstalledPrograms NO
 #endif
 
 /*
Index: xc/config/cf/sv4Lib.tmpl
diff -u xc/config/cf/sv4Lib.tmpl:3.5 xc/config/cf/sv4Lib.tmpl:3.6
--- xc/config/cf/sv4Lib.tmpl:3.5	Wed Jan 17 11:38:50 2001
+++ xc/config/cf/sv4Lib.tmpl	Fri Nov 22 17:55:56 2002
@@ -4,7 +4,7 @@
  * SVR4 shared library template
  */
 
-XCOMM $XFree86: xc/config/cf/sv4Lib.tmpl,v 3.5 2001/01/17 16:38:50 dawes Exp $
+XCOMM $XFree86: xc/config/cf/sv4Lib.tmpl,v 3.6 2002/11/22 22:55:56 tsi Exp $
 
 /* SVR4 shared libraries are deficient in link semantics */
 XMULIBONLY = -lXmu
@@ -75,3 +75,11 @@
 # define IafSysLib	-liaf
 #endif
 IAFSYSLIB = IafSysLib
+
+#ifndef SharedGLUReqs
+# if HasGcc2ForCplusplus
+#  define SharedGLUReqs $(LDPRELIBS) $(XLIB) $(GLXLIB) -lstdc++
+# else
+#  define SharedGLUReqs $(LDPRELIBS) $(XLIB) $(GLXLIB)
+# endif
+#endif
Index: xc/config/cf/svr3.cf
diff -u xc/config/cf/svr3.cf:3.14 xc/config/cf/svr3.cf:3.15
--- xc/config/cf/svr3.cf:3.14	Wed Jan 17 11:38:50 2001
+++ xc/config/cf/svr3.cf	Sun Aug 18 23:16:31 2002
@@ -2,13 +2,16 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/svr3.cf,v 3.14 2001/01/17 16:38:50 dawes Exp $
+XCOMM $XFree86: xc/config/cf/svr3.cf,v 3.15 2002/08/19 03:16:31 tsi Exp $
 
 #ifndef HasGcc
 #define HasGcc      YES
 #endif
 #ifndef HasGcc2
 #define HasGcc2     YES
+#endif
+#ifndef HasGcc3
+#define HasGcc3     NO
 #endif
 #ifndef GccUsesGas
 #define GccUsesGas  NO
Index: xc/config/cf/svr4.cf
diff -u xc/config/cf/svr4.cf:3.46 xc/config/cf/svr4.cf:3.49
--- xc/config/cf/svr4.cf:3.46	Tue Jan 15 17:59:23 2002
+++ xc/config/cf/svr4.cf	Sun Aug 18 23:16:31 2002
@@ -2,7 +2,7 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/svr4.cf,v 3.46 2002/01/15 22:59:23 dawes Exp $
+XCOMM $XFree86: xc/config/cf/svr4.cf,v 3.49 2002/08/19 03:16:31 tsi Exp $
 /*
  * A default OS name
  */
@@ -136,6 +136,11 @@
 #endif
 #endif
 
+/* SVR4 (including Solaris) doesn't have setenv() and unsetenv() */
+#ifndef HasSetenv
+#define HasSetenv		NO
+#endif
+
 #ifndef SunArchitecture
 #if (OSMinorVersion == 0)
 #ifndef XawI18nDefines
@@ -155,8 +160,11 @@
 #endif
 #endif
 
+#ifndef HasGcc3
+#define HasGcc3 NO
+#endif
 #ifndef HasGcc2
-#define HasGcc2 NO
+#define HasGcc2 HasGcc3
 #endif
 #ifndef HasGcc
 #define HasGcc HasGcc2
@@ -240,7 +248,7 @@
 #endif
 
 #ifndef SharedLibXdmGreet
-#define SharedLibXdmGreet	YES
+#define SharedLibXdmGreet	HasSharedLibraries
 #endif
 
 /*
Index: xc/config/cf/ultrix.cf
diff -u xc/config/cf/ultrix.cf:1.1.1.4 xc/config/cf/ultrix.cf:1.2
--- xc/config/cf/ultrix.cf:1.1.1.4	Tue Jan 16 16:54:33 2001
+++ xc/config/cf/ultrix.cf	Thu Nov 14 16:01:14 2002
@@ -1,5 +1,9 @@
 XCOMM platform:  $Xorg: ultrix.cf,v 1.3 2000/08/17 19:41:48 cpqbld Exp $
 
+
+
+XCOMM $XFree86: xc/config/cf/ultrix.cf,v 1.2 2002/11/14 21:01:14 tsi Exp $
+
 #ifndef OSName
 # define OSName		DefaultOSName
 #endif
@@ -17,6 +21,9 @@
 #define LintLibFlag -o
 #define LintOpts -ax
 
+#ifndef HasDECnet
+#define HasDECnet	NO
+#endif
 #if HasDECnet
 #define ExtraLibraries -ldnet
 #endif
Index: xc/config/cf/xf86.tmpl
diff -u xc/config/cf/xf86.tmpl:3.30 xc/config/cf/xf86.tmpl:3.33
--- xc/config/cf/xf86.tmpl:3.30	Thu Nov 15 19:41:47 2001
+++ xc/config/cf/xf86.tmpl	Mon Dec 16 18:01:43 2002
@@ -2,7 +2,7 @@
 
 
 
-XCOMM $XFree86: xc/config/cf/xf86.tmpl,v 3.30 2001/11/16 00:41:47 dawes Exp $
+XCOMM $XFree86: xc/config/cf/xf86.tmpl,v 3.33 2002/12/16 23:01:43 herrb Exp $
 
 #ifdef BuilderEMailAddr
 BUILDERADDR = BuilderEMailAddr
@@ -11,25 +11,27 @@
 #endif
 BUGMSG = -DBUILDERADDR='$(BUILDERADDR)'
 
-#if XF86DriverSDK
+#if defined(XF86DriverSDK)
     BUILDMODULEDIR = $(DRIVERSDKMODULEDIR)
     BUILDMODULETOP = ..
     TOP_INCLUDES = TopIncludes
    IMAKE_DEFINES = -DXF86DriverSDK=1
 #ifdef UseInstalled
        IMAKE_CMD = $(IMAKE) -DUseInstalled -I$(TOP) -I$(IRULESRC) \
-		   $(IMAKE_DEFINES)
+		   $(IMAKE_DEFINES) $(IMAKE_WARNINGS)
 #else
-       IMAKE_CMD = $(IMAKE) -I$(TOP) -I$(IRULESRC) $(IMAKE_DEFINES)
+       IMAKE_CMD = $(IMAKE) -I$(TOP) -I$(IRULESRC) \
+		   $(IMAKE_DEFINES) $(IMAKE_WARNINGS)
 #endif
 
 #undef ImakeSubCmdHelper
 #ifdef UseInstalled
 #define ImakeSubCmdHelper $(IMAKE) -DUseInstalled -I$(IMAKETOP) \
-			  -I$(IRULESRC) $(IMAKE_DEFINES)
+			  -I$(IRULESRC) $(IMAKE_DEFINES) $(IMAKE_WARNINGS)
 #else
 #define ImakeSubCmdHelper $(IMAKEPREFIX)$(IMAKE) -I$(IMAKETOP) \
-			  -I$(IMAKEPREFIX)$(IRULESRC) $(IMAKE_DEFINES)
+			  $(IMAKE_DEFINES) $(IMAKE_WARNINGS) \
+			  -I$(IMAKEPREFIX)$(IRULESRC)
 #endif
 #endif
 
@@ -43,13 +45,23 @@
  * of Imakefile (include <Server.tmpl>)
  */
 
+#ifndef HasGccStackProtector
+#define HasGccStackProtector	NO
+#endif
+
+#if HasGccStackProtector
+MODULE_GCC_FLAGS1 = -fno-stack-protector
+#endif 
+
 #ifndef HasGccMergeConstants
 #define HasGccMergeConstants	NO
 #endif
 
 #if HasGccMergeConstants && DoLoadableServer && !MakeDllModules
-MODULE_GCC_FLAGS = -fno-merge-constants
+MODULE_GCC_FLAGS2 = -fno-merge-constants
 #endif
+
+MODULE_GCC_FLAGS = $(MODULE_GCC_FLAGS1) $(MODULE_GCC_FLAGS2)
 
 #if defined(IHaveModules) && MakeDllModules
 MODULE_PIC_FLAGS = $(PICFLAGS)
Index: xc/config/cf/xf86site.def
diff -u xc/config/cf/xf86site.def:3.179 xc/config/cf/xf86site.def:3.182
--- xc/config/cf/xf86site.def:3.179	Wed Jan 16 13:36:00 2002
+++ xc/config/cf/xf86site.def	Thu Oct 10 21:40:22 2002
@@ -1,19 +1,31 @@
-XCOMM $XFree86: xc/config/cf/xf86site.def,v 3.179 2002/01/16 18:36:00 dawes Exp $
+XCOMM $XFree86: xc/config/cf/xf86site.def,v 3.182 2002/10/11 01:40:22 dawes Exp $
 /******************************************************************************/
 /*
  * This file is to provide a quick method for most people to change the
  * behaviour of their XFree86 installation without having to fully
  * understand the workings of site.def and all the various '.cf' files.
  *
- * These are the most common settings you would choose for compiling and
- * installing XFree86 on the systems supported by it.
+ * In the vast majority of cases, it should not be necessary to use this
+ * file at all or change it in any way.
  *
+ * This file is divided into two sections.  The first contains settings
+ * that end-users might reasonably change.  The second contains settings
+ * that developers might want to change.
+ *
+ * IMPORTANT NOTE:  In all cases changing the defaults may cause problems
+ * and/or unexpected side-effects.  If you don't understand what a setting
+ * does, then it's best to not change it.  If you make changes and have
+ * problems, verify that those problems are also present when using an
+ * empty host.def file and unchanged version of this file before reporting
+ * them.
+ *
  * A good way to use this file is to copy it to host.def, and make the
  * changes there.  That way, future patches to this file won't fail.
  * The host.def file will never be patched.
  *
- * The distributed version of this file should contain no uncommented
- * definitions.  Such default definitions belong in xfree86.cf.
+ * The distributed version of this file MUST contain no uncommented
+ * definitions.  Default definitions belong in xfree86.cf, or <vendor>.cf
+ * files.
  */
 /******************************************************************************/
 
@@ -26,474 +38,516 @@
  */
 
 /*
- * If you want to enable some developer settings, like more verbose
- * compiler warnings, uncomment this.
+ * Which servers to build.  There is now only one XFree86 server.
+ * It can be disabled by the following.
  *
-#define XFree86Devel	YES
-*/
+#define XF86Server		NO
+ */
 
 /*
- * If using GCC 2.x on a system where it isn't the default, uncomment
- * the following
+ * To disable building the Xnest server, uncomment this.
  *
-#define HasGcc2		YES
-#define HasGcc		YES
+#define XnestServer		NO
  */
 
 /*
- * If using GCC 2.x with C++ on a system where it isn't the default, uncomment
- * the following.
+ * To disable building Xvfb, uncomment this.
  *
-#define HasGcc2ForCplusplus	YES
+#define XVirtualFramebufferServer	NO
  */
 
 /*
- * The default optimisation flags for GCC 2.x.  -fno-strength-reduce is
- * here to work around a bug in -O2 for GCC 2.x on i386 platforms.
- * If you are using a version that doesn't have this bug, you can
- * uncomment the following line, and remove '-fno-strength-reduce'
- * If you are building binaries for a 486, it may be beneficial to add
- * -m486
+ * To disable building Xprt, uncomment this.
  *
-#define DefaultGcc2i386Opt	-O2 -fno-strength-reduce
+#define XprtServer NO
  */
 
 /*
- * This allows the GCC warning flags to be set.  The default is shown here.
+ * Set the default server (ie the one that gets the sym-link to "X")
  *
-#define GccWarningOptions -Wall -Wpointer-arith -Wstrict-prototypes \
-                          -Wmissing-prototypes -Wmissing-declarations \
-                          -Wredundant-decls -Wnested-externs
+#define ServerToInstall		XFree86
  */
 
-/* 
- * Sun Compiler stuff.. 
+/*
+ * If you only run the X server under xdm the X servers don't need to be
+ * installed SetUID, and you may comment out the lines below.  If you run
+ * the servers by hand (with xinit or startx), then they do need to be
+ * installed SetUID on most platforms.
  *
-#define HasSunC                         YES
-#define HasSunCplusplus                 YES
-#define CplusplusCompilerMajorVersion   5
-#define CplusplusCompilerMinorVersion   0
-#define CCompilerMajorVersion           5
-#define CCompilerMinorVersion           0
+ * Consult your system administrator before making the X server setuid.
+ *
+#define InstallXserverSetUID	NO
  */
 
+
 /*
- * Optimized Sun Compiler Build.
- *
-#define DefaultCDebugFlags              -xO4 -xtarget=pentium_pro
-#define OptimizedCDebugFlags            -xO4 -xtarget=pentium_pro
+ * Server configuration parameters.  The defaults are shown here:
  */
 
-/* 
- * Debuggable Sun Compiler Build. 
- * Note: This builds _EVERYTHING_ as debuggable
+/*
+ * Which drivers to build.  When building a static server, each of these
+ * will be included in it.  When building the loadable server each of these
+ * modules will be built.
  *
-#define DefaultCDebugFlags              -g -xs
-#define OptimizedCDebugFlags            -g -xs
+#define XF86CardDrivers		mga glint nv tga s3virge sis rendition \
+				neomagic i740 tdfx savage \
+				cirrus vmware tseng trident chips apm \
+				GlideDriver fbdev i128 \
+				ati AgpGartDrivers DevelDrivers ark cyrix \
+				siliconmotion \
+				vesa vga XF86OSCardDrivers XF86ExtraCardDrivers
  */
 
 /*
- * For Linux, this should match the Binutils version you have.  This example
- * is for 2.6.0.7.  See linux.cf for the default setting.
+ * To add third party drivers to the standard driver list, set the
+ * following.
  *
- * This should automatically get set correctly by imake.
+#define XF86ExtraCardDrivers	extradriver1 extradriver2 ...
+ */
+
+/*
+ * Select the XInput devices you want by uncommenting this.
  *
-#define LinuxBinUtilsMajorVersion	26
+#define XInputDrivers		mouse keyboard acecad calcomp citron \
+				digitaledge dmc dynapro elographics \
+				microtouch mutouch penmount spaceorb summa \
+				wacom void magictouch
  */
 
 /*
- * For Linux, these should match the libc version you have.  This example
- * is for libc.5.4.x.  See linux.cf for the default setting.
+ * There are three parameters that determine where and how the Matrox HAL
+ * library is used:
  *
- * This should automatically get set correctly by imake.
+ *   HaveMatroxHal  -- You have the HALlib.a binary library installed
+ *                     in xfree86/drivers/mga/HALlib, and you want it to
+ *                     be used.
+ *                     Default: NO
  *
-#define LinuxCLibMajorVersion	5
-#define LinuxClibMinorVersion	4
+ *   BuildMatroxHal -- You have the source for the HALlib library (installed
+ *                     in xfree86/drivers/mga/hallib), and want to build and
+ *                     use it.
+ *                     Default: NO
+ *
+ *   UseMatroxHal   -- You want to build support for loading/using the HAL
+ *                     library into the mga driver.  For module server builds
+ *                     you don't need to have the HALlib library to do this.
+ *                     but you want to build support for loading it and using
+ *                     it into the mga driver module.
+ *                     Default: YES for loadable server build
+ *                              (HaveMatroxHal || BuildMatroxHal) for static
  */
 
 /*
- * If you want to use the GNU malloc library, uncomment this
+ * To disable use of the Matrox HAL library, uncomment this:
  *
-#define UseGnuMalloc		YES
+#define UseMatroxHal		NO
  */
 
 /*
- * Set this to whatever is required to access the GNU malloc library.
- * The default is '-lgmalloc' unless is specified in the OS's .cf file.
+ * If you have the HALlib.a binary installed in xfree86/drivers/mga/HALlib,
+ * uncomment this:
  *
-#define GnuMallocLibrary	-L/usr/local/lib -lgmalloc
+#define HaveMatroxHal		YES
  */
 
 /*
- * To enable the internal Xserver malloc, uncomment this
- *
-#define UseInternalMalloc	YES
+ * If you have the HALlib source code installed in xfree86/drivers/mga/hallib,
+ * uncomment this:
+#define BuildMatroxHal		YES
  */
 
 /*
- * Some Linux releases don't have a libtermcap.  In this case you may need
- * to uncomment the following
+ * To disable building the font server, uncomment this.
  *
-#define TermcapLibrary		-lncurses
+#define BuildFontServer		NO
  */
 
 /*
- * If you have Tk (which is required to build XF86Setup), uncomment this
- * Note: version 4.0 or 4.1 is required, and XF86Setup links it statically by
- * default.
+ * To disable support for Speedo fonts, uncomment this.
  *
-#define HasTk			YES
+#define BuildSpeedo		NO
  */
 
 /*
- * Set the paths and names for your Tk library if they don't match the
- * defaults (check your OS .cf file or Imake.tmpl for the defaults).
- *
- * Common values for TkLibName are tk4.0, tk4.1, etc.
- *
- * Some Linux releases need TkIncDir set to /usr/include/tcl, and some
- * need it set to /usr/X11R6/include.
- *
- * Some Linux releases need TkLibDir set to /usr/X11R6/lib
+ * To disable support for Type1 fonts, uncomment this.
  *
-#define TkLibDir		/usr/local/lib
-#define TkIncDir		/usr/local/include
-#define TkLibName		tk
+#define BuildType1		NO
  */
 
 /*
- * By default, XF86Setup is linked with a static Tk library.  To change
- * that, uncomment the following line.
+ * To disable support for CID fonts, uncomment this.
  *
-#define XF86SetupUsesStaticTk	NO
+#define BuildCID		NO
  */
 
 /*
- * If you have Tcl (which is required to build XF86Setup), uncomment this
- * Note: version 7.4 or 7.5 is required, and XF86Setup links it statically by
- * default.
+ * To disable support for TrueType fonts, uncomment these.
  *
-#define HasTcl			YES
+#define BuildFreeType		NO
+#define BuildXTrueType		NO
  */
 
 /*
- * Set the paths and names for your Tcl library if they don't match the
- * defaults (check your OS .cf file or Imake.tmpl for the defaults).
- *
- * Common values for TclLibName are tcl7.4, tcl7.5, etc.
- *
- * Some Linux releases need TclIncDir set to /usr/include/tcl.
+ * Do you want to Build Fonts (Usually you only want to build and install
+ * fonts once, if this is a first time install you will want to build the
+ * fonts)
  *
-#define TclLibDir		/usr/local/lib
-#define TclIncDir		/usr/local/include
-#define TclLibName		tcl
+#define BuildFonts		NO
  */
 
 /*
- * By default, XF86Setup is linked with a static Tcl library.  To change
- * that, uncomment the following line.
+ * To not build/install the 75dpi fonts, uncomment the following
  *
-#define XF86SetupUsesStaticTcl	NO
+#define Build75DpiFonts		NO
  */
 
 /*
- * Build a server that dynamically loads the modules by setting
- * this to YES.  This defaults to YES on most platforms.  A static server
- * can be built by setting this to NO.
+ * To not build/install the 100dpi fonts, uncomment the following
  *
-#define DoLoadableServer	NO
+#define Build100DpiFonts	NO
  */
 
 /*
- * Build dlopen() style modules instead of the standard loader modules.
+ * To not build/install the Speedo fonts, uncomment the following
  *
-#define MakeDllModules		YES
+#define BuildSpeedoFonts	NO
  */
 
 /*
- * Which servers to build.  There is now only one XFree86 server.
- * It can be disabled by the following.
+ * To not build/install the Type1 fonts, uncomment the following
  *
-#define XF86Server		NO
+#define BuildType1Fonts		NO
  */
 
 /*
- * To disable building the Xnest server, uncomment this.
+ * To not build/install the CID fonts, uncomment the following
  *
-#define XnestServer		NO
+#define BuildCIDFonts		NO
  */
 
 /*
- * To disable building Xvfb, uncomment this.
+ * To not build/install the True Type fonts, uncomment the following
  *
-#define XVirtualFramebufferServer	NO
+#define BuildTrueTypeFonts	NO
  */
 
 /*
- * To disable building Xprt, uncomment this.
+ * To not build/install the Cyrillic fonts, uncomment the following
  *
-#define XprtServer NO
+#define BuildCyrillicFonts	NO
  */
 
 /*
- * Set the default server (ie the one that gets the sym-link to "X")
+ * To not install the local font directory, uncomment the following
  *
-#define ServerToInstall		XFree86
+#define MakeLocalFontDir	NO
  */
 
-
 /*
- * Server configuration parameters.  The defaults are shown here:
+ * To build only the servers with a cut-down source tree, uncomment
+ * this.
+ *
+#define BuildServersOnly	YES
  */
 
 /*
- * Which drivers to build.  When building a static server, each of these
- * will be included in it.  When building the loadable server each of these
- * modules will be built.
+ * By default, the sample config files for xinit, xdm and xfs are installed
+ * only when there is no pre-existing version installed.  Uncommenting the
+ * following lines will force the sample versions to be installed even if
+ * it means over-writing existing versions.
  *
-#define XF86CardDrivers		mga glint nv tga s3virge sis rendition \
-				neomagic i740 tdfx savage \
-				cirrus vmware tseng trident chips apm \
-				GlideDriver fbdev i128 \
-				ati AgpGartDrivers DevelDrivers ark cyrix \
-				siliconmotion \
-				vesa vga XF86OSCardDrivers XF86ExtraCardDrivers
+#define InstallXinitConfig	YES
+#define InstallXdmConfig	YES
+#define InstallFSConfig		YES
  */
 
 /*
- * To add third party drivers to the standard driver list, set the
- * following.
+ * By default the application defaults files are always installed.
+ * Uncommenting the the following will prevent exising application
+ * defaults files from being over-written.
  *
-#define XF86ExtraCardDrivers	extradriver1 extradriver2 ...
+#define InstallAppDefFiles	NO
  */
 
 /*
- * There are three parameters that determine where and how the Matrox HAL
- * library is used:
+ * Undefine the following if you don't want to have config files and
+ * app-defaults installed in a separate directory (i.e. /etc/X11).
  *
- *   HaveMatroxHal  -- You have the HALlib.a binary library installed
- *                     in xfree86/drivers/mga/HALlib, and you want it to
- *                     be used.
- *                     Default: NO
+#define UseSeparateConfDir NO
+ */
+
+/* 
+ * To enable building the glide driver, you need to define 
+ * HasGlide2 to YES and set the Glide2IncDir variable. 
+ * HasGlide2 is per default NO.
  *
- *   BuildMatroxHal -- You have the source for the HALlib library (installed
- *                     in xfree86/drivers/mga/hallib), and want to build and
- *                     use it.
- *                     Default: NO
+#define HasGlide2 YES
+ */
+
+/*
+ * Set the path to your Glide include files.
  *
- *   UseMatroxHal   -- You want to build support for loading/using the HAL
- *                     library into the mga driver.  For module server builds
- *                     you don't need to have the HALlib library to do this.
- *                     but you want to build support for loading it and using
- *                     it into the mga driver module.
- *                     Default: YES for loadable server build
- *                              (HaveMatroxHal || BuildMatroxHal) for static
+#define Glide2IncDir /usr/include/glide
  */
 
-/*
- * To disable use of the Matrox HAL library, uncomment this:
+/* 
+ * Have glide 3?
  *
-#define UseMatroxHal		NO
+#define HasGlide3 YES
  */
 
 /*
- * If you have the HALlib.a binary installed in xfree86/drivers/mga/HALlib,
- * uncomment this:
+ * Set the path to your Glide 3 include files.
  *
-#define HaveMatroxHal		YES
+#define Glide3IncDir /usr/include/glide3
  */
 
+
+
 /*
- * If you have the HALlib source code installed in xfree86/drivers/mga/hallib,
- * uncomment this:
-#define BuildMatroxHal		YES
+ * Unless you're a developer you shouldn't need to change anything
+ * beyond this point.
  */
 
 /*
- * Build XAA.  This can be disabled with:
+ * If you want to enable some developer settings, like more verbose
+ * compiler warnings, uncomment this.
  *
-#define XF86XAA			NO
- */
+#define XFree86Devel	YES
+*/
 
 /*
- * Build vgahw.  This can be disabled with:
+ * The default optimisation flags for GCC 2.x.  -fno-strength-reduce is
+ * here to work around a bug in -O2 for GCC 2.x on i386 platforms.
+ * If you are using a version that doesn't have this bug, you can
+ * uncomment the following line, and remove '-fno-strength-reduce'
+ * If you are building binaries for a 486, it may be beneficial to add
+ * -m486
  *
-#define XF86VgaHw		NO
+#define DefaultGcc2i386Opt	-O2 -fno-strength-reduce
  */
 
 /*
- * Build xf1bpp.  This can be disabled with:
+ * This allows the GCC warning flags to be set.  The default is shown here.
  *
-#define XF1Bpp			NO
+#define GccWarningOptions -Wall -Wpointer-arith -Wstrict-prototypes \
+                          -Wmissing-prototypes -Wmissing-declarations \
+                          -Wredundant-decls -Wnested-externs
+ */
+
+/* 
+ * Sun Compiler stuff.. 
+ *
+#define HasSunC                         YES
+#define HasSunCplusplus                 YES
+#define CplusplusCompilerMajorVersion   5
+#define CplusplusCompilerMinorVersion   0
+#define CCompilerMajorVersion           5
+#define CCompilerMinorVersion           0
  */
 
 /*
- * Build xf4bpp.  This can be disabled with:
+ * Optimized Sun Compiler Build.
  *
-#define XF4Bpp			NO
+#define DefaultCDebugFlags              -xO4 -xtarget=pentium_pro
+#define OptimizedCDebugFlags            -xO4 -xtarget=pentium_pro
  */
 
+/* 
+ * Debuggable Sun Compiler Build. 
+ * Note: This builds _EVERYTHING_ as debuggable
+ *
+#define DefaultCDebugFlags              -g -xs
+#define OptimizedCDebugFlags            -g -xs
+ */
 
 /*
- * BSD Console driver support (for FreeBSD and NetBSD).
- *
- * By default, support is included for pccons and pcvt for NetBSD, and
- * pccons, syscons and pcvt for FreeBSD.
+ * For Linux, this should match the Binutils version you have.  This example
+ * is for 2.6.0.7.  See linux.cf for the default setting.
  *
- * To change the list of supported drivers, set the following parameter.
- * Possible values are -DPCCONS_SUPPORT, -DSYSCONS_SUPPORT, -DPCVT_SUPPORT.
- * The following example includes support for syscons and pcvt only.
+ * This should automatically get set correctly by imake.
  *
-#define XFree86ConsoleDefines	-DSYSCONS_SUPPORT -DPCVT_SUPPORT
+#define LinuxBinUtilsMajorVersion	26
  */
 
 /*
- * If you only run the X server under xdm the X servers don't need to be
- * installed SetUID, and you may comment out the lines below.  If you run
- * the servers by hand (with xinit or startx), then they do need to be
- * installed SetUID on most OSs.
- * Consult your system administrator before making the X server setuid.
+ * For Linux, these should match the libc version you have.  This example
+ * is for libc.5.4.x.  See linux.cf for the default setting.
  *
-#define InstallXserverSetUID	NO
+ * This should automatically get set correctly by imake.
+ *
+#define LinuxCLibMajorVersion	5
+#define LinuxClibMinorVersion	4
  */
 
 /*
- * To link the X server with a dynamic version of the Xfont library,
- * uncomment this.
+ * If you want to use the GNU malloc library, uncomment this
  *
-#define XserverStaticFontLib	NO
+#define UseGnuMalloc		YES
  */
 
 /*
- * To disable building the font server, uncomment this.
+ * Set this to whatever is required to access the GNU malloc library.
+ * The default is '-lgmalloc' unless is specified in the OS's .cf file.
  *
-#define BuildFontServer		NO
+#define GnuMallocLibrary	-L/usr/local/lib -lgmalloc
  */
 
 /*
- * To disable support for Speedo fonts, uncomment this.
+ * To enable the internal Xserver malloc, uncomment this
  *
-#define BuildSpeedo		NO
+#define UseInternalMalloc	YES
  */
 
 /*
- * To disable support for Type1 fonts, uncomment this.
+ * Some Linux releases don't have a libtermcap.  In this case you may need
+ * to uncomment the following
  *
-#define BuildType1		NO
+#define TermcapLibrary		-lncurses
  */
 
 /*
- * To disable support for CID fonts, uncomment this.
+ * If you have Tk (which is required to build XF86Setup), uncomment this
+ * Notes:
+ *   - version 4.0 or 4.1 is required, and XF86Setup links it statically by
+ *     default.
+ *   - XF86Setup is not built or supported with XFree86 4.x
  *
-#define BuildCID		NO
+#define HasTk			YES
  */
 
 /*
- * To disable support for TrueType fonts, uncomment these.
+ * Set the paths and names for your Tk library if they don't match the
+ * defaults (check your OS .cf file or Imake.tmpl for the defaults).
  *
-#define BuildFreeType		NO
-#define BuildXTrueType		NO
+ * Common values for TkLibName are tk4.0, tk4.1, etc.
+ *
+ * Some Linux releases need TkIncDir set to /usr/include/tcl, and some
+ * need it set to /usr/X11R6/include.
+ *
+ * Some Linux releases need TkLibDir set to /usr/X11R6/lib
+ *
+#define TkLibDir		/usr/local/lib
+#define TkIncDir		/usr/local/include
+#define TkLibName		tk
  */
 
 /*
- * To enable binary compatibility with previous versions of the font
- * encoding support, uncomment this.
+ * By default, XF86Setup is linked with a static Tk library.  To change
+ * that, uncomment the following line.
  *
-#define FontencCompatibility    YES
+#define XF86SetupUsesStaticTk	NO
  */
 
 /*
- * Do you want to Build Fonts (Usually you only want to build and install
- * fonts once, if this is a first time install you will want to build the
- * fonts)
+ * If you have Tcl (which is required to build XF86Setup), uncomment this
+ * Note: version 7.4 or 7.5 is required, and XF86Setup links it statically by
+ * default.
  *
-#define BuildFonts		NO
+#define HasTcl			YES
  */
 
 /*
- * To not build/install the 75dpi fonts, uncomment the following
+ * Set the paths and names for your Tcl library if they don't match the
+ * defaults (check your OS .cf file or Imake.tmpl for the defaults).
  *
-#define Build75DpiFonts		NO
+ * Common values for TclLibName are tcl7.4, tcl7.5, etc.
+ *
+ * Some Linux releases need TclIncDir set to /usr/include/tcl.
+ *
+#define TclLibDir		/usr/local/lib
+#define TclIncDir		/usr/local/include
+#define TclLibName		tcl
  */
 
 /*
- * To not build/install the 100dpi fonts, uncomment the following
+ * By default, XF86Setup is linked with a static Tcl library.  To change
+ * that, uncomment the following line.
  *
-#define Build100DpiFonts	NO
+#define XF86SetupUsesStaticTcl	NO
  */
 
 /*
- * To not build/install the Speedo fonts, uncomment the following
+ * Build a server that dynamically loads the modules by setting
+ * this to YES.  This defaults to YES on most platforms.  A static server
+ * can be built by setting this to NO.
  *
-#define BuildSpeedoFonts	NO
+#define DoLoadableServer	NO
  */
 
 /*
- * To not build/install the Type1 fonts, uncomment the following
+ * Build dlopen() style modules instead of the standard loader modules.
+ * Don't enable this unless you have specific development reasons for
+ * doing so and understand how to deal with the problems you'll run in to.
  *
-#define BuildType1Fonts		NO
+ * Enabling this for regular use is NOT supported, and will almost
+ * certainly cause you problems.
+ *
+#define MakeDllModules		YES
  */
 
 /*
- * To not build/install the CID fonts, uncomment the following
+ * Build XAA.  This can be disabled with:
  *
-#define BuildCIDFonts		NO
+#define XF86XAA			NO
  */
 
 /*
- * To not build/install the True Type fonts, uncomment the following
+ * Build vgahw.  This can be disabled with:
  *
-#define BuildTrueTypeFonts	NO
+#define XF86VgaHw		NO
  */
 
 /*
- * To not build/install the Cyrillic fonts, uncomment the following
+ * Build xf1bpp.  This can be disabled with:
  *
-#define BuildCyrillicFonts	NO
+#define XF1Bpp			NO
  */
 
 /*
- * To not build/install the Latin2 fonts, uncomment the following
+ * Build xf4bpp.  This can be disabled with:
  *
-#define BuildLatin2Fonts	NO
+#define XF4Bpp			NO
  */
 
+
 /*
- * To not install the local font directory, uncomment the following
+ * BSD Console driver support (for FreeBSD and NetBSD).
  *
-#define MakeLocalFontDir	NO
+ * By default, support is included for pccons and pcvt for NetBSD, and
+ * pccons, syscons and pcvt for FreeBSD.
+ *
+ * To change the list of supported drivers, set the following parameter.
+ * Possible values are -DPCCONS_SUPPORT, -DSYSCONS_SUPPORT, -DPCVT_SUPPORT.
+ * The following example includes support for syscons and pcvt only.
+ *
+#define XFree86ConsoleDefines	-DSYSCONS_SUPPORT -DPCVT_SUPPORT
  */
 
 /*
- * To build only the servers with a cut-down source tree, uncomment
- * this.
+ * To link the X server with a dynamic version of the Xfont library,
+ * uncomment this.
  *
-#define BuildServersOnly	YES
+#define XserverStaticFontLib	NO
  */
 
 /*
- * To disable building XInput support, uncomment this
+ * To enable binary compatibility with previous versions of the font
+ * encoding support, uncomment this.
  *
-#define BuildXInputExt		NO
+#define FontencCompatibility    YES
  */
 
 /*
- * Select the XInput devices you want by uncommenting this.
+ * To disable building XInput support, uncomment this
  *
-#define XInputDrivers		mouse acecad calcomp citron \
-				digitaledge dmc dynapro elographics \
-				microtouch mutouch penmount spaceorb summa \
-				wacom void magictouch
+#define BuildXInputExt		NO
  */
 
 /*
  * Uncomment this for joystick support.
  *
- * Note: Joystick support is only included for Linux and FreeBSD at the
- * moment.  For Linux it requires the Joystick module to be installed (it
- * isn't part of the standard kernel distribution).  For FreeBSD, a kernel
- * will need to be built with the Joystick driver in order to be able to
- * use this.
+ * Note: Joystick support is broken, so don't enable this.
  *
 #define JoystickSupport YES
  */
@@ -505,9 +559,9 @@
  */
 
 /*
- * If you don't want to build PEX, uncomment this.
+ * If you want to build PEX, uncomment this.
  *
-#define BuildPexExt		NO
+#define BuildPexExt		YES
  */
 
 /* 
@@ -541,9 +595,9 @@
  */
 
 /*
- * If you don't want to build XIE, uncomment this.
+ * If you want to build XIE, uncomment this.
  *
-#define BuildXIE		NO
+#define BuildXIE		YES
  */
 
 /*
@@ -554,38 +608,20 @@
  */
 
 /*
- * If you don't want to build the xf86rush extension, uncomment this line.
+ * If you want to build the xf86rush extension, uncomment this line.
+ * This isn't recommended.
  *
-#define BuildXF86RushExt	NO
+#define BuildXF86RushExt	YES
  */
 
 /*
- * If you don't want to build the client library for the xf86rush extension,
- * uncomment this line.
+ * If you want to build the client library for the xf86rush extension,
+ * uncomment this line.  This isn't recommended.
  *
 #define BuildXF86RushLibrary	NO
  */
 
 /*
- * By default, the sample config files for xinit, xdm and xfs are installed
- * only when there is no pre-existing version installed.  Uncommenting the
- * following lines will force the sample versions to be installed even if
- * it means over-writing existing versions.
- *
-#define InstallXinitConfig	YES
-#define InstallXdmConfig	YES
-#define InstallFSConfig		YES
- */
-
-/*
- * By default the application defaults files are always installed.
- * Uncommenting the the following will prevent exising application
- * defaults files from being over-written.
- *
-#define InstallAppDefFiles	NO
- */
-
-/*
  * If you are running NetBSD 0.9C or later, and have the aperture driver
  * installed, uncomment this.
  *
@@ -721,39 +757,6 @@
  * the following.
  *
 #define BuildAllSpecsDocs	YES
- */
-
-/* 
- * To enable building the glide driver, you need to define 
- * HasGlide2 to YES and set the Glide2IncDir variable. 
- * HasGlide2 is per default NO.
- *
-#define HasGlide2 YES
- */
-
-/*
- * Set the path to your Glide include files.
- *
-#define Glide2IncDir /usr/include/glide
- */
-
-/* 
- * The 3Dfx 3D DRI driver requires glide 3.
- *
-#define HasGlide3 YES
- */
-
-/*
- * Set the path to your Glide 3 include files.
- *
-#define Glide3IncDir /usr/include/glide3
- */
-
-/*
- * Undefine the following if you don't want to have config files and
- * app-defaults installed in a separate directory (i.e. /etc/X11).
- *
-#define UseSeparateConfDir NO
  */
 
 /*
Index: xc/config/cf/xfree86.cf
diff -u xc/config/cf/xfree86.cf:3.388 xc/config/cf/xfree86.cf:3.439
--- xc/config/cf/xfree86.cf:3.388	Thu Jan  3 17:51:54 2002
+++ xc/config/cf/xfree86.cf	Wed Feb 26 15:07:59 2003
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/config/cf/xfree86.cf,v 3.388 2002/01/03 22:51:54 alanh Exp $
+XCOMM $XFree86: xc/config/cf/xfree86.cf,v 3.439 2003/02/26 20:07:59 dawes Exp $
 /*
  * This configuration file contains all of the configuration
  * information for the XFree86 based X Servers.
@@ -12,6 +12,7 @@
 /* Get and set version information. */
 
 #include "version.def"
+#include "date.def"
 /*
  * As of the development trunk after 4.0.2, XFree86 versions are
  * M.m.P.s, and XFree86Version is:
@@ -32,30 +33,43 @@
  *
  */
 #ifndef XFree86Version
-#ifdef XF86_VERSION_CURRENT
-# define XFree86Version XF86_VERSION_CURRENT
-#endif
+# ifdef XF86_VERSION_CURRENT
+#  define XFree86Version	XF86_VERSION_CURRENT
+# else	/* Must be defined for bootstrapping purposes */
+#  define XFree86Version	0
+# endif
 #endif
 
-#ifndef XFree86VersionString
-#ifdef XF86_VERSION_MAJOR
-#if XF86_VERSION_SNAP == 0
+#if !defined(XFree86VersionString) && \
+    defined(XF86_VERSION_MAJOR) && defined(XF86_VERSION_MINOR) && \
+    defined(XF86_VERSION_PATCH) && defined(XF86_VERSION_SNAP)
+# if XF86_VERSION_SNAP == 0
 #define XFree86VersionString `echo XF86_VERSION_MAJOR XF86_VERSION_MINOR XF86_VERSION_PATCH | sed 's/ /./g'`
 #else
 #define XFree86VersionString `echo XF86_VERSION_MAJOR XF86_VERSION_MINOR XF86_VERSION_PATCH XF86_VERSION_SNAP | sed 's/ /./g'`
-#endif
+# endif
 #endif
+
+#if !defined(XFree86ManVersionString) && \
+    defined(XF86_VERSION_MAJOR) && defined(XF86_VERSION_MINOR) && \
+    defined(XF86_VERSION_PATCH) && defined(XF86_VERSION_SNAP)
+# if XF86_VERSION_SNAP == 0
+#define XFree86ManVersionString `echo XF86_VERSION_MAJOR XF86_VERSION_MINOR XF86_VERSION_PATCH | sed -e 's/ /./g' -e 's/^/Version /'`
+#else
+#define XFree86ManVersionString `echo XF86_VERSION_MAJOR XF86_VERSION_MINOR XF86_VERSION_PATCH XF86_VERSION_SNAP | sed -e 's/ /./g' -e 's/^/Version\\\ /'`
+# endif
 #endif
 
-#ifndef XFree86DateString
-#ifdef XF86_DATE
-#define XFree86DateString XF86_DATE
+#if !defined(XFree86DateString) && defined(XF86_DATE)
+# define XFree86DateString XF86_DATE
 #endif
+
+#ifndef BuildDateCmd
+# define BuildDateCmd	date +%Y%m%d
 #endif
 
-/* This must be defined here for boostrapping purposes */
-#ifndef XFree86Version
-# define XFree86Version	0
+#if !defined(BuildDate)
+# define BuildDate 	`BuildDateCmd`
 #endif
 
 #ifndef XVendorString
@@ -67,7 +81,7 @@
 #endif
 
 #ifndef XVendorManVersionString
-#define XVendorManVersionString Version XFree86VersionString
+#define XVendorManVersionString XFree86ManVersionString
 #endif
 
 #ifndef XVendorManNameString
@@ -79,10 +93,14 @@
  */
 
 #ifndef XFree86Devel
-# if (XFree86Version % 1000)
-#  define XFree86Devel		YES
+# if !defined(PatheticCpp) || !PatheticCpp
+#  if (XFree86Version % 1000)
+#   define XFree86Devel		YES
+#  else
+#   define XFree86Devel		NO
+#  endif
 # else
-#  define XFree86Devel		NO
+#  define XFree86Devel		NO	/* Assume the worst */
 # endif
 #endif
 
@@ -134,15 +152,43 @@
 #endif
 
 /*
+ * When this is set, modules are always built separately from the libraries
+ * that statically link into an Xserver.  This is for platforms where the
+ * module and native object formats are different (e.g., OS/2).
+ */
+#ifndef BuildModuleInSubdir
+#define BuildModuleInSubdir	NO
+#endif
+
+#ifndef MakeDllModules
+#define MakeDllModules		NO
+#endif
+#ifndef DoLoadableServer
+#define DoLoadableServer	NO
+#endif 
+
+/*
  * Default settings for which X Servers to build.
  */
 
+/* OS.cf files may set this for OS-specific input drivers */
+#ifndef OSXInputDrivers
+#define OSXInputDrivers /**/
+#endif
+
+/* This may be set in host.def for 3rd party input drivers */
+#ifndef ExtraXInputDrivers
+#define ExtraXInputDrivers /**/
+#endif
+
 /* XInput drivers */
 #ifndef XInputDrivers
-#define XInputDrivers		mouse /* acecad */ calcomp citron \
-				digitaledge dmc dynapro elographics \
+#define XInputDrivers		mouse keyboard /* acecad */ calcomp citron \
+				digitaledge dmc dynapro elographics tek4957 \
 				microtouch mutouch penmount spaceorb summa \
-				wacom void /* magictouch */ hyperpen
+				wacom void magellan /* magictouch */ hyperpen \
+				jamstudio fpit \
+				palmax OSXInputDrivers ExtraXInputDrivers
 #endif
 
 /* <linux/input.h> support mainly for USB support */
@@ -166,6 +212,9 @@
 #endif
 
 /* The glide driver only works for the loadable server at the moment */
+#ifndef HasGlide2
+#define HasGlide2 NO
+#endif
 #if HasGlide2 && DoLoadableServer
 #define GlideDriver glide
 #else
@@ -203,7 +252,7 @@
 #define BuildMatroxHal NO
 #endif
 
-#ifndef UseMatroxHal 
+#ifndef UseMatroxHal
 #if DoLoadableServer
 #define UseMatroxHal YES
 #else
@@ -271,25 +320,24 @@
 # ifndef XF86RAC
 #  define XF86RAC		YES
 # endif
-
 /* int10 module */
 # ifndef XF86Int10
 #  define XF86Int10		YES
 # endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
 
 /*
  * Amiga framebuffer module.
- * This is for build testing only.  It isn't actually used on this platform.
+ * This is mostly for build testing, but the vesa driver references it.
  */
 # ifndef XF86AFB
 #  define XF86AFB		YES
 # endif
 
-# if HasAgpGart || XFree86Devel
-#  define AgpGartDrivers	i810
-# else
-#  define AgpGartDrivers	/**/
-# endif
+# define AgpGartDrivers	/**/
 
 /*
  * Drivers under development, but not ready for binary releases, or
@@ -305,36 +353,144 @@
 
 /* Pure PCI drivers should go first */
 # ifndef XF86CardDrivers
-#  define XF86CardDrivers	mga glint nv tga s3 s3virge sis rendition \
+#  ifdef ia64Architecture /* removed nsc driver */
+#   define XF86CardDrivers	mga glint nv tga s3 s3virge sis rendition \
 				neomagic i740 tdfx savage \
 				cirrus vmware tseng trident chips apm \
 				GlideDriver fbdev i128 \
-				ati AgpGartDrivers DevelDrivers ark cyrix \
-				siliconmotion \
-				vesa vga XF86OSCardDrivers XF86ExtraCardDrivers
+				ati i810 AgpGartDrivers DevelDrivers ark \
+				cyrix siliconmotion \
+				vesa vga \
+				dummy XF86OSCardDrivers XF86ExtraCardDrivers
+#  else
+#   define XF86CardDrivers	mga glint nv tga s3 s3virge sis rendition \
+				neomagic i740 tdfx savage \
+				cirrus vmware tseng trident chips apm \
+				GlideDriver fbdev i128 nsc \
+				ati i810 AgpGartDrivers DevelDrivers ark \
+				cyrix siliconmotion \
+				vesa vga \
+				dummy XF86OSCardDrivers XF86ExtraCardDrivers
+#  endif
 # endif
-# if HasGlide3
-#  define TdfxDriDriver		tdfx
-# else
-#  define TdfxDriDriver		/**/
+
+/*
+ * DRI drivers under development, or drivers included on this platform
+ * only for build testing.
+ */
+# ifndef DevelDRIDrivers
+#  if XFree86Devel
+#   define DevelDRIDrivers	ffb
+#  else
+#   define DevelDRIDrivers	/**/
+#  endif
 # endif
+
 # ifndef DriDrivers
-#  define DriDrivers		gamma TdfxDriDriver mga i810 i830 r128 radeon sis
+#  define DriDrivers		gamma i810 i830 mga r128 radeon r200 \
+				/*sis*/ tdfx DevelDRIDrivers
 # endif
 #endif
 
-/* Sparc drivers */
+#if defined(x86_64Architecture)
+# ifndef XF86Server
+#  define XF86Server		YES
+# endif
+/* 1bpp module */
+# ifndef XF1Bpp
+#  define XF1Bpp		YES
+# endif
+/* 4bpp module */
+# ifndef XF4Bpp
+#  define XF4Bpp		YES
+# endif
+/* 8/32bpp overlay module */
+# ifndef XF8_32Bpp
+#  define XF8_32Bpp		YES
+# endif
+/* 8/16bpp dual fb module */
+# ifndef XF8_16Bpp
+#  define XF8_16Bpp		YES
+# endif
+/* 24/32bpp conversion module */
+# ifndef XF24_32Bpp
+#  define XF24_32Bpp		YES
+# endif
+/* shadow fb module */
+# ifndef XFShadowFB
+#  define XFShadowFB		YES
+# endif
+/* vgahw module */
+# ifndef XF86VgaHw
+#  define XF86VgaHw		YES
+# endif
+/* fbdevhw module */
+# ifndef XF86FBDevHw
+#  define XF86FBDevHw		YES
+# endif
+/* XAA module */
+# ifndef XF86XAA
+#  define XF86XAA		YES
+# endif
+/* ramdac module */
+# ifndef XF86Ramdac
+#  define XF86Ramdac		YES
+# endif
+/* I2C module */
+# ifndef XF86I2C
+#  define XF86I2C		YES
+# endif
+/* DDC module */
+# ifndef XF86DDC
+#  define XF86DDC		YES
+# endif
+/* RAC (Resource Access Control) module */
+# ifndef XF86RAC
+#  define XF86RAC		YES
+# endif
 
+/* int10 module */
+# ifndef XF86Int10
+#  define XF86Int10		YES
+# endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
+
+# define AgpGartDrivers	/**/
+
+# define DevelDrivers		/**/
+
+/* Pure PCI drivers should go first */
+# ifndef XF86CardDrivers
+#  define XF86CardDrivers	mga glint nv tga s3 s3virge sis rendition \
+				neomagic tdfx savage cirrus tseng trident \
+				chips apm i128 ati ark cyrix siliconmotion \
+				vga dummy fbdev vesa
+# endif
+
+/* DRI tdfx driver needs Glide, which is not available for x86_64 */
+# define TdfxDriDriver		/**/
+
+# define DevelDRIDrivers	/**/
+
+# define DriDrivers		gamma i810 mga r128 radeon r200 \
+				TdfxDriDriver DevelDRIDrivers
+#endif /*x86_64Arcitecture*/
+
+/* SPARC and UltraSPARC drivers */
+
 #if  defined(SparcArchitecture) && \
     !defined(LynxOSArchitecture) && \
     !defined(NetBSDArchitecture) && \
-    !defined(OpenBSDArchitecture) 
+    !defined(OpenBSDArchitecture)
 # ifndef XF86Server
-#  define XF86Server            YES
+#  define XF86Server		YES
 # endif
 /* 1bpp module */
 # ifndef XF1Bpp
-#  define XF1Bpp                YES
+#  define XF1Bpp		YES
 # endif
 /* 4bpp module */
 # ifndef XF4Bpp
@@ -360,13 +516,17 @@
 # ifndef XFShadowFB
 #  define XFShadowFB		YES
 # endif
+/* vgahw module */
+# ifndef XF86VgaHw
+#  define XF86VgaHw		YES
+# endif
 /* fbdevhw module */
 # ifndef XF86FBDevHw
 #  define XF86FBDevHw		YES
 # endif
 /* XAA module */
 # ifndef XF86XAA
-#  define XF86XAA               YES
+#  define XF86XAA		YES
 # endif
 /* ramdac module */
 # ifndef XF86Ramdac
@@ -388,21 +548,135 @@
 # ifndef XF86Int10
 #  define XF86Int10		YES
 # endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
+
+# ifndef DevelDrivers
+#  if XFree86Devel
+   /*
+    * Some of these are compiled just for the fun of it.  Undoubtedly some
+    * require changes (or even removal) for things like endianness, etc.  Move
+    * those known to work into the main XF86CardDrivers #define.
+    */
+#   define DevelDrivers		apm ark chips cirrus i128 i740 i810 imstt \
+				neomagic newport nv rendition s3virge savage \
+				siliconmotion tga trident vmware dummy
+#  else
+#   define DevelDrivers		/* */
+#  endif
+# endif
 
 /* Pure SBUS and PCI drivers should go first */
 # ifndef XF86CardDrivers
 #  define XF86CardDrivers	sunffb sunleo suncg6 suncg3 suncg14 suntcx \
-				sunbw2 ati glint fbdev \
-				XF86OSCardDrivers XF86ExtraCardDrivers
+				sunbw2 glint mga tdfx ati vesa vga fbdev \
+				XF86OSCardDrivers XF86ExtraCardDrivers \
+				DevelDrivers
 # endif
 # ifndef DriDrivers
 #  define DriDrivers		ffb
 # endif
 
 #endif
+
+/* Sparc64 Drivers */
+#if defined(OpenBSDArchitecture) && defined(Sparc64Architecture)
+# ifndef XF86Server
+#  define XF86Server		YES
+# endif
+/* Amiga framebuffer module */
+# ifndef XF86AFB
+#  define XF86AFB		NO
+# endif
+/* 1bpp module */
+# ifndef XF1Bpp
+#  define XF1Bpp		YES
+# endif
+/* 4bpp module */
+# ifndef XF4Bpp
+#  define XF4Bpp		YES
+# endif
+/* 8/32bpp overlay module */
+# ifndef XF8_32Bpp
+#  define XF8_32Bpp		YES
+# endif
+/* 8/16bpp dual fb module */
+# ifndef XF8_16Bpp
+#  define XF8_16Bpp		YES
+# endif
+/* 24/32bpp conversion module */
+# ifndef XF24_32Bpp
+#  define XF24_32Bpp		YES
+# endif
+/* shadow fb module */
+# ifndef XFShadowFB
+#  define XFShadowFB		YES
+# endif
+/* vgahw module */
+# ifndef XF86VgaHw
+#  define XF86VgaHw		YES
+# endif
+/* fbdevhw module */
+# ifndef XF86FBDevHw
+#  define XF86FBDevHw		YES
+# endif
+/* XAA module */
+# ifndef XF86XAA
+#  define XF86XAA		YES
+# endif
+/* ramdac module */
+# ifndef XF86Ramdac
+#  define XF86Ramdac		YES
+# endif
+/* I2C module */
+# ifndef XF86I2C
+#  define XF86I2C		YES
+# endif
+/* DDC module */
+# ifndef XF86DDC
+#  define XF86DDC		YES
+# endif
+/* RAC (Resource Access Control) module */
+# ifndef XF86RAC
+#  define XF86RAC		YES
+# endif
 
-/* Mips drivers */
+/* int10 module */
+# ifndef XF86Int10
+#  define XF86Int10		YES
+# endif
+# ifndef UseX86Emu
+#  define UseX86Emu		NO
+# endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
 
+# ifndef DevelDrivers
+#  if XFree86Devel
+#   define DevelDrivers		/* */
+#  else
+#   define DevelDrivers		/* */
+#  endif
+# endif
+
+/* Pure PCI drivers should go first */
+# ifndef XF86CardDrivers
+#  define XF86CardDrivers	ati \
+				DevelDrivers \
+				XF86OSCardDrivers XF86ExtraCardDrivers
+# endif
+# define TdfxDriDriver		/**/
+# ifndef DriDrivers
+#  define DriDrivers		/**/
+# endif
+#endif
+
+/* MIPS drivers */
+
 #ifdef MipsArchitecture
 # ifndef XF86Server
 #  define XF86Server		YES
@@ -464,6 +738,10 @@
 # ifndef XF86Int10
 #  define XF86Int10		YES
 # endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
 
 # ifndef DevelDrivers
 #  if XFree86Devel
@@ -482,8 +760,7 @@
 #endif
 
 /*
- * For Digital Alpha platforms, the default is to build all modules which
- * are supported on this platform.
+ * DEC Alpha drivers
  */
 #ifdef AlphaArchitecture
 # ifndef XF86Server
@@ -541,11 +818,14 @@
 # ifndef XF86RAC
 #  define XF86RAC		YES
 # endif
-
 /* int10 module */
 # ifndef XF86Int10
 #  define XF86Int10		YES
 # endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
 
 # ifndef DevelDrivers
 #  if XFree86Devel
@@ -558,25 +838,18 @@
 /* Pure PCI drivers should go first */
 # ifndef XF86CardDrivers
 #  define XF86CardDrivers	mga tdfx glint s3 s3virge rendition tga ati \
-				savage nv DevelDrivers siliconmotion vga \
-				XF86OSCardDrivers XF86ExtraCardDrivers
-# endif
-# if HasGlide3
-#  define TdfxDriDriver		tdfx
-# else
-#  define TdfxDriDriver		/**/
+				savage nv cirrus DevelDrivers siliconmotion  \
+				vga XF86OSCardDrivers XF86ExtraCardDrivers
 # endif
 # ifndef DriDrivers
-#  define DriDrivers		gamma TdfxDriDriver mga r128 radeon sis
+#  define DriDrivers		gamma tdfx mga r128 radeon r200 /*sis*/
 # endif
 #endif
 
 /*
- * For Motorola 68k and PPC (currently Linux, LynxOS and Net/OpenBSD)
- * and Intel StrongARM (currently Linux, maybe NetBSD)
+ * Motorola 68k and PowerPC drivers
  */
-#if defined(PpcArchitecture) || defined(Mc68020Architecture) || \
-    defined(Arm32Architecture) || defined(HPArchitecture)
+#if defined(PpcArchitecture) || defined(Mc68020Architecture)
 # ifndef XF86Server
 #  define XF86Server		YES
 # endif
@@ -636,11 +909,14 @@
 # ifndef XF86RAC
 #  define XF86RAC		YES
 # endif
-
 /* int10 module */
 # ifndef XF86Int10
 #  define XF86Int10		YES
 # endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
 
 # ifndef DevelDrivers
 #  if XFree86Devel
@@ -657,86 +933,176 @@
 				DevelDrivers vga \
 				XF86OSCardDrivers XF86ExtraCardDrivers
 # endif
+# ifndef DriDrivers
+#  define DriDrivers		gamma tdfx mga r128 radeon r200
+# endif
+#endif
+
+/*
+ * Intel StrongARM and Hewlett-Packard PA-RISC
+ */
+#if defined(Arm32Architecture) || defined(HPArchitecture)
+# ifndef XF86Server
+#  define XF86Server		YES
+# endif
+/* 1bpp module */
+# ifndef XF1Bpp
+#  define XF1Bpp		YES
+# endif
+/* 4bpp module */
+# ifndef XF4Bpp
+#  define XF4Bpp		YES
+# endif
+/* 8/32bpp overlay module */
+# ifndef XF8_32Bpp
+#  define XF8_32Bpp		YES
+# endif
+/* 8/16bpp dual fb module */
+# ifndef XF8_16Bpp
+#  define XF8_16Bpp		YES
+# endif
+/* 24/32bpp conversion module */
+# ifndef XF24_32Bpp
+#  define XF24_32Bpp		YES
+# endif
+/* shadow fb module */
+# ifndef XFShadowFB
+#  define XFShadowFB		YES
+# endif
+/* vgahw module */
+# ifndef XF86VgaHw
+#  define XF86VgaHw		YES
+# endif
+/* fbdevhw module */
+# ifndef XF86FBDevHw
+#  define XF86FBDevHw		YES
+# endif
+/* XAA module */
+# ifndef XF86XAA
+#  define XF86XAA		YES
+# endif
+/* ramdac module */
+# ifndef XF86Ramdac
+#  define XF86Ramdac		YES
+# endif
+/* I2C module */
+# ifndef XF86I2C
+#  define XF86I2C		YES
+# endif
+/* DDC module */
+# ifndef XF86DDC
+#  define XF86DDC		YES
+# endif
+/* RAC (Resource Access Control) module */
+# ifndef XF86RAC
+#  define XF86RAC		YES
+# endif
+/* int10 module */
+# ifndef XF86Int10
+#  define XF86Int10		YES
+# endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
+# endif
+
+# ifndef DevelDrivers
+#  if XFree86Devel
+#   define DevelDrivers		/* */
+#  else
+#   define DevelDrivers		/* */
+#  endif
+# endif
+
+/* Pure PCI drivers should go first */
+# ifndef XF86CardDrivers
+#  define XF86CardDrivers	ati mga glint nv s3 s3virge sis savage\
+				trident chips tdfx fbdev \
+				DevelDrivers vga \
+				XF86OSCardDrivers XF86ExtraCardDrivers
+# endif
 # if HasGlide3
 #  define TdfxDriDriver		tdfx
 # else
 #  define TdfxDriDriver		/**/
 # endif
 # ifndef DriDrivers
-#  define DriDrivers		gamma TdfxDriDriver mga r128 radeon
+#  define DriDrivers		gamma tdfx mga r128 radeon r200
 # endif
 #endif
 
-
 /* SuperH drivers */
 
 #if defined(SuperHArchitecture)
 # ifndef XF86Server
-#  define XF86Server           YES
+#  define XF86Server		YES
 # endif
 /* 1bpp module */
 # ifndef XF1Bpp
-#  define XF1Bpp               YES
+#  define XF1Bpp		YES
 # endif
 /* 4bpp module */
 # ifndef XF4Bpp
-#  define XF4Bpp               YES
+#  define XF4Bpp		YES
 # endif
 /* 8/32bpp overlay module */
 # ifndef XF8_32Bpp
-#  define XF8_32Bpp            YES
+#  define XF8_32Bpp		YES
 # endif
 /* 8/16bpp dual fb module */
 # ifndef XF8_16Bpp
-#  define XF8_16Bpp            YES
+#  define XF8_16Bpp		YES
 # endif
 /* 24/32bpp conversion module */
 # ifndef XF24_32Bpp
-#  define XF24_32Bpp           YES
+#  define XF24_32Bpp		YES
 # endif
 /* shadow fb module */
 # ifndef XFShadowFB
-#  define XFShadowFB           YES
+#  define XFShadowFB		YES
 # endif
 /* fbdevhw module */
 # ifndef XF86FBDevHw
-#  define XF86FBDevHw          YES
+#  define XF86FBDevHw		YES
 # endif
 /* XAA module */
 # ifndef XF86XAA
-#  define XF86XAA              YES
+#  define XF86XAA		YES
 # endif
 /* ramdac module */
 # ifndef XF86Ramdac
-#  define XF86Ramdac           YES
+#  define XF86Ramdac		YES
 # endif
 /* I2C module */
 # ifndef XF86I2C
-#  define XF86I2C              YES
+#  define XF86I2C		YES
 # endif
 /* DDC module */
 # ifndef XF86DDC
-#  define XF86DDC              YES
+#  define XF86DDC		YES
 # endif
 /* RAC (Resource Access Control) module */
 # ifndef XF86RAC
-#  define XF86RAC              YES
+#  define XF86RAC		YES
 # endif
-
 /* int10 module */
 # ifndef XF86Int10
-#  define XF86Int10            YES
+#  define XF86Int10		YES
+# endif
+/* vbe module */
+# ifndef XF86VBE
+#  define XF86VBE		YES
 # endif
 
 # ifndef XF86CardDrivers
-#  define XF86CardDrivers              fbdev XF86OSCardDrivers XF86ExtraCardDrivers
+#  define XF86CardDrivers		fbdev XF86OSCardDrivers XF86ExtraCardDrivers
 # endif
 #endif
 
 
-/* 
+/*
  * For Mips/Arc platforms, the default is to build all modules which
- * are supported on this platform. 
+ * are supported on this platform.
  */
 #ifdef ArcArchitecture
 # ifndef XF86Server
@@ -763,19 +1129,19 @@
  * on different architectures.
  */
 #ifndef XF86AFB
-# define XF86AFB NO
+# define XF86AFB		NO
 #endif
 #ifndef XF86ILBM
-# define XF86ILBM NO
+# define XF86ILBM		NO
 #endif
 #ifndef XF86IPLAN2P2
-# define XF86IPLAN2P2 NO
+# define XF86IPLAN2P2		NO
 #endif
 #ifndef XF86IPLAN2P4
-# define XF86IPLAN2P4 NO
+# define XF86IPLAN2P4		NO
 #endif
 #ifndef XF86IPLAN2P8
-# define XF86IPLAN2P8 NO
+# define XF86IPLAN2P8		NO
 #endif
 #if XF86AFB
 AFB_DEFS = -DUSE_AFB
@@ -811,7 +1177,11 @@
  * The server-side of PEX is not 64-bit clean.
  */
 #if !defined(BuildPexExt)
-# if XF86Server && !defined(AlphaArchitecture) && !defined(ia64Architecture) && !defined(s390xArchitecture)
+# if XF86Server \
+  && !defined(AlphaArchitecture) \
+  && !defined(ia64Architecture) \
+  && !defined(s390xArchitecture) \
+  && !defined (x86_64Architecture)
 #  define BuildPexExt		NO	/* But we turn off PEX anyway now */
 # else
 #  define BuildPexExt		NO
@@ -823,17 +1193,33 @@
  *   --- Doesn't work for 1-bit and 4-bit servers
  */
 #ifndef BuildGlxExt
-#  define BuildGlxExt    YES
+#  define BuildGlxExt	YES
 #endif
 
 #ifndef BuildXF86DRI
 #define BuildXF86DRI	NO
 #endif
 
+#ifndef BuildXF86DRM
+#define BuildXF86DRM	NO
+#endif
+
+#ifndef GlxStubLib
+#define GlxStubLib	NO
+#endif
+
+#ifndef GlxUseSGISI
+#define GlxUseSGISI	NO
+#endif
+
 #if BuildXF86DRI
 
 #ifndef BuildGLXLibrary
-#define BuildGLXLibrary	YES
+#  if defined (BuildServersOnly) && BuildServersOnly
+#    define BuildGLXLibrary	NO
+#  else
+#    define BuildGLXLibrary	YES
+#  endif
 #endif
 
 /*
@@ -841,12 +1227,22 @@
  * If more than one are defined, the compilation will fail with multiply
  * defined references of GLX and OpenGL functions.
  */
+
+/*
+ * The first is a built-in driver that does software rendering client-side
+ * and renders to the X server via Xlib.
+ */
+
+#  ifndef GlxBuiltInXMesa
+#    define GlxBuiltInXMesa         NO
+#  endif
+
+/*
+ * The rest are hardware-specific DRI drivers.
+ */
 #  ifndef GlxBuiltInGamma
 #    define GlxBuiltInGamma        NO
 #  endif
-#  ifndef GlxBuiltInMesa
-#    define GlxBuiltInMesa         NO
-#  endif
 #  ifndef GlxBuiltInTdfx
 #    define GlxBuiltInTdfx         NO
 #  endif
@@ -865,6 +1261,9 @@
 #  ifndef GlxBuiltInRadeon
 #    define GlxBuiltInRadeon       NO
 #  endif
+#  ifndef GlxBuiltInR200
+#    define GlxBuiltInR200         NO
+#  endif
 #  ifndef GlxBuiltInFfb
 #    define GlxBuiltInFfb          NO
 #  endif
@@ -878,9 +1277,12 @@
       GlxBuiltInI830 || \
       GlxBuiltInR128 || \
       GlxBuiltInRadeon || \
-      GlxBuildInFfb || \
+      GlxBuiltInR200 || \
+      GlxBuiltInFfb || \
       GlxBuiltInSIS
 #    define GlxDriverUsesMesa      YES
+#  else
+#    define GlxDriverUsesMesa      NO
 #  endif
 
 #  if GlxBuiltInGamma || \
@@ -890,9 +1292,9 @@
       GlxBuiltInI830 || \
       GlxBuiltInR128 || \
       GlxBuiltInRadeon || \
+      GlxBuiltInR200 || \
       GlxBuiltInFfb || \
-      GlxBuiltInSIS || \
-      GlxBuiltInMesa
+      GlxBuiltInSIS
 #    define GlxUseBuiltInDRIDriver YES
 #    define DRIDynLoadDefines /**/
 #  else
@@ -923,6 +1325,9 @@
 #    if GlxBuiltInRadeon
 #      define DriDrivers radeon
 #    endif
+#    if GlxBuiltInR200
+#      define DriDrivers r200
+#    endif
 #    if GlxBuiltInSIS
 #      define DriDrivers sis
 #    endif
@@ -963,7 +1368,11 @@
 #    define GlxCoreLibDefines /**/
 #  endif
 
-#  if defined(SparcArchitecture)  || defined(ia64Architecture) || defined(s390xArchitecture)
+#  if defined(SparcArchitecture)  \
+   || defined (Sparc64Architecture) \
+   || defined(ia64Architecture) \
+   || defined(s390xArchitecture) \
+   || defined(x86_64Architecture)
 #    define GlxArchDefines -D__GLX_ALIGN64
 #  elif defined(AlphaArchitecture)
 /* On the Alpha we need to ensure floating point accuracy for 3D */
@@ -989,6 +1398,10 @@
 
 #endif
 
+#if !BuildXF86DRI
+# define GlxUseBuiltInDRIDriver NO	/* For libOSmesa */
+#endif
+
 # ifndef UseX86Emu
 #  define UseX86Emu		YES
 # endif
@@ -1089,6 +1502,9 @@
 #ifndef BuildGLXLibrary
 # define BuildGLXLibrary	YES
 #endif
+#ifndef BuildXResLibrary
+# define BuildXResLibrary       YES
+#endif
 #endif
 
 /*
@@ -1152,7 +1568,7 @@
 #endif
 
 /*
- * Build the X Video Extension 
+ * Build the X Video Extension
  */
 #ifndef BuildXvExt
 # define BuildXvExt			YES
@@ -1165,6 +1581,12 @@
 # define BuildXvMCExt			YES
 #endif
 
+/*
+ * Build the X-Resource Extension 
+ */
+#ifndef BuildXResExt
+# define BuildXResExt                   YES
+#endif
 
 #if Malloc0ReturnsNull
 # ifndef XtMalloc0ReturnsNullDefines
@@ -1254,19 +1676,17 @@
 #endif
 
 /*
- * By default, create the local font directory
- */
-#ifndef MakeLocalFontDir
-# define MakeLocalFontDir	YES
-#endif
-
-/*
  * Build scanpci?
  */
+#ifndef SystemV
+#define SystemV			NO
+#endif
+#ifndef SystemV4
+#define SystemV4		NO
+#endif
 #ifndef BuildScanpci
 # if SystemV || SystemV4 || \
-    (defined(LinuxArchitecture) && !defined(Mc68020Architecture) && \
-     !defined(PpcArchitecture)) || \
+    (defined(LinuxArchitecture) && !defined(Mc68020Architecture)) || \
     defined(i386BsdArchitecture) || defined(LynxOSArchitecture) || \
     defined(OS2Architecture) || defined(GNUMachArchitecture)
 #   define BuildScanpci		YES
@@ -1310,6 +1730,12 @@
 # define XFree86XvMCDefines	/**/
 #endif
 
+#if BuildXResExt
+# define XFree86XResDefines     -DXResExtension
+#else
+# define XFree86XResDefines     /**/
+#endif
+
 #ifndef DlopenHack
 # define DlopenHack		-DDLOPEN_HACK
 #endif
@@ -1328,6 +1754,10 @@
 # define XFree86LoaderDefines	/**/
 #endif
 
+#ifndef HasBsdMake
+#define HasBsdMake		NO
+#endif
+
 #ifndef MakeHasPosixVariableSubstitutions
 # if !HasBsdMake && !defined(SunArchitecture)
 #  define MakeHasPosixVariableSubstitutions	NO
@@ -1361,7 +1791,7 @@
 				XFree86XvMCDefines \
 				ServerSnprintfDefines \
 				SmartScheduleDefines \
-				DebugDefines \
+				DebugDefines XFree86XResDefines \
 				-DX_BYTE_ORDER=ByteOrder
 #endif
 
@@ -1464,8 +1894,11 @@
 /*
  * GNU Compiler stuff
  */
+#ifndef HasGcc3
+# define HasGcc3 NO
+#endif
 #ifndef HasGcc2
-# define HasGcc2 NO
+# define HasGcc2 HasGcc3
 #endif
 #ifndef HasGcc
 # define HasGcc HasGcc2
@@ -1475,13 +1908,21 @@
 #endif
 
 #if HasGcc
+# ifndef Gcc28Warnings
+#  if (GccMajorVersion > 2) || \
+      ((GccMajorVersion == 2) && (GccMinorVersion >= 8))
+#   define Gcc28Warnings -Wundef
+#  else
+#   define Gcc28Warnings /* */
+#  endif
+# endif
 # ifndef GccWarningOptions
 #  if XFree86Devel
 #   define GccWarningOptions -Wall -Wpointer-arith -Wstrict-prototypes \
 			  -Wmissing-prototypes -Wmissing-declarations \
-			  -Wredundant-decls -Wnested-externs
+			  -Wredundant-decls -Wnested-externs Gcc28Warnings
 #  else
-#   define GccWarningOptions -Wall -Wpointer-arith
+#   define GccWarningOptions -Wall -Wpointer-arith Gcc28Warnings
 #  endif
 # endif
 # ifndef DefaultCCOptions
@@ -1498,21 +1939,40 @@
 # endif
 #endif
 
+/* Make imake noisier.  Note that this is ineffective for 3.0 <= GCC <= 3.2 */
+#ifndef ImakeWarningFlags
+# ifdef Gcc28Warnings
+#  define ImakeWarningFlags Gcc28Warnings
+# else
+#  define ImakeWarningFlags /* */
+# endif
+#endif
+
+#ifndef GccAliasingArgs
+#define GccAliasingArgs /* */
+#endif
+
 #if HasGcc2 && defined(i386Architecture)
 # ifndef DefaultGcc2i386Opt
-#  define DefaultGcc2i386Opt -O2 -fno-strength-reduce
+#  define DefaultGcc2i386Opt -O2 -fno-strength-reduce GccAliasingArgs
+# endif
+#endif
+
+#if HasGcc2 && defined(x86_64Architecture)
+# ifndef DefaultGcc2x86_64Opt
+#  define DefaultGcc2x86_64Opt -O2 -fno-strength-reduce GccAliasingArgs
 # endif
 #endif
 
 #if HasGcc2 && defined(AlphaArchitecture)
 # ifndef DefaultGcc2AxpOpt
-#  define DefaultGcc2AxpOpt -O2
+#  define DefaultGcc2AxpOpt -O2 GccAliasingArgs
 # endif
 #endif
 
 #if HasGcc2 && defined(PpcArchitecture)
 # ifndef DefaultGcc2PpcOpt
-#  define DefaultGcc2PpcOpt -O2
+#  define DefaultGcc2PpcOpt -O2 GccAliasingArgs
 # endif
 #endif
 
@@ -1520,6 +1980,10 @@
 # define DefaultGcc2DebugOpt -g
 #endif
 
+#ifndef DebuggableLibraries
+# define DebuggableLibraries NO
+#endif
+
 #if HasGcc2 && DebuggableLibraries
 # define LibraryDebugOpt DefaultGcc2DebugOpt
 #endif
@@ -1530,34 +1994,84 @@
  */
 
 #ifndef Egcs112Bug
-# if HasGcc2 && defined(i386Architecture)
+  /* Not exactly precise, but it'll do for now... */
+# if HasGcc2 && defined(i386Architecture) && \
+     (GccMajorVersion == 2) && (GccMinorVersion > 8)
 #  define Egcs112Bug YES
 # else
 #  define Egcs112Bug NO
 # endif
 #endif
 
+/*
+ * Some Linux distributions (like RH 7.0) use glibc 2.1-style setjmp,
+ * but have the glibc version set to 2.2.  This can be set it host.def
+ * to handle these cases.
+ */
+#ifndef HasGlibc21Sigsetjmp
+#define HasGlibc21Sigsetjmp NO
+#endif
+
 #ifdef i386Architecture
+# ifndef HasX86Support
+#  define HasX86Support YES
+# endif
 # ifndef HasMMXSupport
 #  define HasMMXSupport YES
 # endif
-# ifndef HasKatmaiSupport
-#  define HasKatmaiSupport NO
+# ifndef HasSSESupport
+#  define HasSSESupport NO
 # endif
 # ifndef Has3DNowSupport
 #  define Has3DNowSupport NO
 # endif
-#else
+#elif defined (x86_64Architecture)
+# ifndef HasX86Support
+#  define HasX86Support NO
+# endif
 # ifndef HasMMXSupport
 #  define HasMMXSupport NO
 # endif
-# ifndef HasKatmaiSupport
-#  define HasKatmaiSupport NO
+# ifndef HasSSESupport
+#  define HasSSESupport NO
 # endif
 # ifndef Has3DNowSupport
 #  define Has3DNowSupport NO
 # endif
+#else 
+# ifndef HasX86Support
+#  define HasX86Support NO
+# endif
+# ifndef HasMMXSupport
+#  define HasMMXSupport NO
+# endif
+# ifndef HasSSESupport
+#  define HasSSESupport NO
+# endif
+# ifndef Has3DNowSupport
+#  define Has3DNowSupport NO
+# endif
+#endif
+
+#ifndef StaticNeedsPicForShared
+# if defined (x86_64Architecture)\
+  || defined (AlphaArchitecture) \
+  || defined (ia64Architecture) \
+  || defined (PpcArchitecture) \
+  || defined (SparcArchitecture) \
+  || defined (s390xArchitecture) 
+#  define StaticNeedsPicForShared YES
+# else
+#  define StaticNeedsPicForShared NO
+# endif
 #endif
 
+#ifndef XF8_32Wid
+# define XF8_32Wid		NO
+#endif
+
+#if CrossCompiling
+#include <cross.def>
+#endif
 #include <xf86.rules>
 
Index: xc/config/imake/Imakefile
diff -u xc/config/imake/Imakefile:3.12 xc/config/imake/Imakefile:3.17
--- xc/config/imake/Imakefile:3.12	Thu Nov 15 19:45:05 2001
+++ xc/config/imake/Imakefile	Wed Nov 20 16:48:46 2002
@@ -3,7 +3,7 @@
 XCOMM
 XCOMM
 XCOMM
-XCOMM $XFree86: xc/config/imake/Imakefile,v 3.12 2001/11/16 00:45:05 dawes Exp $
+XCOMM $XFree86: xc/config/imake/Imakefile,v 3.17 2002/11/20 21:48:46 herrb Exp $
 
 XCOMM Some compilers generate fatal errors if an -L directory does
 XCOMM not exist.  Since BUILDLIBDIR may not exist yet suppress its use.
@@ -17,15 +17,38 @@
 CPP_DEFINES = -DCPP_PROGRAM="\"$(CPP_PROGRAM)\""
 GCC_COMMAND = $(CC) -fmerge-constants -xc /dev/null -S -o /dev/null 2> /dev/null 1> /dev/null
 GCC_DEFINES = -DHAS_MERGE_CONSTANTS=`if $(GCC_COMMAND); then echo 1; else echo 0; fi`
-DEFINES = $(SIGNAL_DEFINES) $(BOOTSTRAPCFLAGS) $(CPP_DEFINES) $(GCC_DEFINES)
 
+#ifdef CrossCompileDir
+CROSSCOMPILEDIR = CrossCompileDir
+CROSSCOMPILEDEFINES=-DCROSSCOMPILE -DCROSSCOMPILEDIR=\"$(CROSSCOMPILEDIR)\"
+#else
+CROSSCOMPILEDIR =
+CROSSCOMPILEDEFINES=
+BOOTSTRAPDEFINES =
+#endif
+
+DEFINES = $(SIGNAL_DEFINES) $(BOOTSTRAPCFLAGS) $(CPP_DEFINES) $(GCC_DEFINES) \
+	 $(CROSSCOMPILEDEFINES)
+EXTRAMANDEFS = -D__cpp__=CppCmd
+
 #if defined(MacIIArchitecture) || defined(SequentArchitecture) || defined(i386ScoArchitecture)
 XBSDLIB = /**/
 #endif
+
+#ifdef CrossCompileDir
+# ifdef TargetPreProcessCmd
+CPP = TargetPreProcessCmd 
+# else
+CPP = CrossCompileDir/cc -E -
+# endif
+IMAKEMDEFS_CPPDEFINES = $(DEFINES) -DCROSSCOMPILE_CPP
+CppFileTarget(imakemdep_cpp.h,imakemdep.h,$(IMAKEMDEFS_CPPDEFINES),\
+	NullParameter)
+#endif
 
-#if !defined(OS2Architecture)
 #undef ImakeDependency
 #define ImakeDependency(dummy) @@\
+imake.o: imakemdep_cpp.h @@\
 Makefile::  ProgramTargetName(imake)
 
 #if CrossCompiling
@@ -34,16 +57,6 @@
 SimpleProgramTarget(imake)
 #endif
 InstallDriverSDKNamedProg(imake,imake,$(DRIVERSDKDIR)/config/imake)
-#else /* OS2Architecture */
-all::
-
-CCOPTIONS = -Zsysv-signals
-EXTRA_LIBRARIES = /*nothing*/
-SimpleProgramTarget(imake)
-InstallDriverSDKNamedProg(imake,imake,$(DRIVERSDKDIR)/config/imake)
-InstallNamedProg(imakesvc.cmd,imakesvc.cmd,$(BINDIR))
-InstallDriverSDKNamedProg(imakesvc.cmd,imakesvc.cmd,$(DRIVERSDKTDIR)/config/imake)
-#endif
 
 #if HasClearmake
 bootstrapdepend: depend
@@ -54,4 +67,5 @@
 clean::
 	RemoveFile(ProgramTargetName(ccimake))
 	RemoveFile(Makefile.proto)
+	RemoveFile(imakemdep_cpp.h)
 	$(RM) -r bootstrap
Index: xc/config/imake/Makefile.ini
diff -u xc/config/imake/Makefile.ini:3.10 xc/config/imake/Makefile.ini:3.11
--- xc/config/imake/Makefile.ini:3.10	Wed Jan 17 11:38:55 2001
+++ xc/config/imake/Makefile.ini	Thu Apr  4 09:05:34 2002
@@ -7,13 +7,17 @@
 # may be given at the top of the build tree for systems that do not define
 # any machine-specific preprocessor symbols.
 #
-# $XFree86: xc/config/imake/Makefile.ini,v 3.10 2001/01/17 16:38:55 dawes Exp $
+# $XFree86: xc/config/imake/Makefile.ini,v 3.11 2002/04/04 14:05:34 eich Exp $
 
+CROSSCOMPILEDIR =
+CROSSCOMPILEFLAGS = -DCROSSCOMPILEDIR=\"$(CROSSCOMPILEDIR)\"
 BOOTSTRAPCFLAGS = 
 CC = cc
+PREPROCESS_CMD = cc -E
 CDEBUGFLAGS = -O
 INCLUDES = -I../../include -I../../imports/x11/include/X11
 CFLAGS = $(BOOTSTRAPCFLAGS) $(CDEBUGFLAGS) $(INCLUDES)
+IMAKEMDEP_CROSSCOMPILE = -DCROSSCOMPILE_CPP
 SHELL = /bin/sh
 RM = rm -f
 MV = mv
@@ -23,17 +27,23 @@
 NPROC = 1
 
 imake::
-	@echo "making imake with BOOTSTRAPCFLAGS=$(BOOTSTRAPCFLAGS) in config/imake"
+	@echo "making imake with BOOTSTRAPCFLAGS=$(BOOTSTRAPCFLAGS) and CROSSCOMPILEFLAGS=$(CROSSCOMPILEFLAGS) in config/imake"
 
 imake:: imake.o
 	$(CC) -o imake $(CFLAGS) imake.o
 
-imake.o: ccimake imake.c
+imake.o: ccimake imake.c imakemdep_cpp.h
 	$(CC) -c $(CFLAGS) `./ccimake` imake.c
 
 ccimake: ccimake.c
-	$(CC) -o ccimake $(CFLAGS) ccimake.c
+	$(CC) -o ccimake $(CROSSCOMPILEFLAGS) $(CFLAGS) ccimake.c
 
+imakemdep_cpp.h: ccimake imakemdep.h
+	if [ -n "$(CROSSCOMPILEDIR)" ] ; then \
+	$(CROSSCOMPILEDIR)/$(PREPROCESS_CMD) `./ccimake` \
+	$(IMAKEMDEP_CROSSCOMPILE) imakemdep.h > imakemdep_cpp.h; \
+	else touch imakemdep_cpp.h; fi
+
 # a derived object erroneously would get shared across platforms by clearmake
 .NO_CONFIG_REC: ccimake
 
@@ -51,6 +61,7 @@
 	$(RM) ccimake imake.o imake
 	$(RM_CMD) \#*
 	$(RM) -r Makefile.proto Makefile Makefile.dep bootstrap
+	$(RM) imakemdep_cpp.h
 
 depend:
 
Index: xc/config/imake/ccimake.c
diff -u xc/config/imake/ccimake.c:1.3 xc/config/imake/ccimake.c:1.4
--- xc/config/imake/ccimake.c:1.3	Fri Dec 14 14:53:18 2001
+++ xc/config/imake/ccimake.c	Thu Apr  4 09:05:34 2002
@@ -24,10 +24,10 @@
 in this Software without prior written authorization from The Open Group .
 
 */
-/* $XFree86: xc/config/imake/ccimake.c,v 1.3 2001/12/14 19:53:18 dawes Exp $ */
+/* $XFree86: xc/config/imake/ccimake.c,v 1.4 2002/04/04 14:05:34 eich Exp $ */
 
 /* 
- * Warning:  This file must be kept as simple as posible so that it can 
+ * Warning:  This file must be kept as simple as possible so that it can 
  * compile without any special flags on all systems.  Do not touch it unless
  * you *really* know what you're doing.  Make changes in imakemdep.h, not here.
  */
@@ -36,12 +36,26 @@
 #include "imakemdep.h"		/* things to set when porting imake */
 
 #ifndef imake_ccflags
-#define imake_ccflags "-O"
+# define imake_ccflags "-O"
 #endif
 
+#ifndef CROSSCOMPILEDIR
+# define CROSSCOMPILEDIR "" 
+#endif
+
+#define crosscompile_ccflags " -DCROSSCOMPILE "
+#define crosscompiledir_str "-DCROSSCOMPILEDIR="
+
 int
 main()
 {
+        if (CROSSCOMPILEDIR[0] != '\0') {
+	    write(1, crosscompiledir_str, sizeof(crosscompiledir_str) - 1);
+	    write(1,"\"",1);
+	    write(1, CROSSCOMPILEDIR, sizeof(CROSSCOMPILEDIR) - 1);
+	    write(1,"\"",1);
+	    write(1, crosscompile_ccflags, sizeof(crosscompile_ccflags) - 1);
+	}
 	write(1, imake_ccflags, sizeof(imake_ccflags) - 1);
 	return 0;
 }
Index: xc/config/imake/imake.c
diff -u xc/config/imake/imake.c:3.48 xc/config/imake/imake.c:3.63
--- xc/config/imake/imake.c:3.48	Fri Dec 14 14:53:18 2001
+++ xc/config/imake/imake.c	Mon Dec 16 17:48:27 2002
@@ -7,11 +7,11 @@
  * be passed to the template file.                                         *
  *                                                                         *
  ***************************************************************************/
-/* $XFree86: xc/config/imake/imake.c,v 3.48 2001/12/14 19:53:18 dawes Exp $ */
+/* $XFree86: xc/config/imake/imake.c,v 3.63 2002/12/16 22:48:27 herrb Exp $ */
 
 /*
- * 
-Copyright (c) 1985, 1986, 1987, 1998 The Open Group  
+ *
+Copyright (c) 1985, 1986, 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
@@ -32,7 +32,7 @@
 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.
- * 
+ *
  * Original Author:
  *	Todd Brunhoff
  *	Tektronix, inc.
@@ -57,11 +57,11 @@
  *		-s[F]	show.  Show the produced makefile on the standard
  *			output.  Make is not run is this case.  If a file
  *			argument is provided, the output is placed there.
- *              -e[F]   execute instead of show; optionally name Makefile F
+ *		-e[F]	execute instead of show; optionally name Makefile F
  *		-v	verbose.  Show the make command line executed.
  *
  * Environment variables:
- *		
+ *
  *		IMAKEINCLUDE	Include directory to use in addition to "."
  *		IMAKECPP	Cpp to use instead of /lib/cpp
  *		IMAKEMAKE	make program to use other than what is
@@ -104,15 +104,15 @@
  *	- If DEFAULT_OS_TEENY_REV is defined, format the utsname struct
  *	  and call the result <defaultOsTeenyVersion>.  Add:
  *		#define DefaultOSTeenyVersion <defaultOsTeenyVersion>
- *      - If DEFAULT_MACHINE_ARCITECTURE is defined, format the utsname struct
- *        and define the corresponding macro. (For example on the amiga,
- *        this will define amiga in addition to m68k).    
+ *	- If DEFAULT_MACHINE_ARCITECTURE is defined, format the utsname struct
+ *	  and define the corresponding macro.  (For example on the amiga,
+ *	  this will define amiga in addition to m68k).
  *	- If the file "localdefines" is readable in the current
- *	  directory, print a warning message to stderr and add: 
+ *	  directory, print a warning message to stderr and add:
  *		#define IMAKE_LOCAL_DEFINES	"localdefines"
  *		#include IMAKE_LOCAL_DEFINES
  *	- If the file "admindefines" is readable in the current
- *	  directory, print a warning message to stderr and add: 
+ *	  directory, print a warning message to stderr and add:
  *		#define IMAKE_ADMIN_DEFINES	"admindefines"
  *		#include IMAKE_ADMIN_DEFINES
  *	- The following lines:
@@ -120,11 +120,11 @@
  *		#define IMAKE_TEMPLATE		" <template> "
  *		#include IMAKE_TEMPLATE
  *	- If the file "adminmacros" is readable in the current
- *	  directory, print a warning message to stderr and add: 
+ *	  directory, print a warning message to stderr and add:
  *		#define IMAKE_ADMIN_MACROS	"adminmacros"
  *		#include IMAKE_ADMIN_MACROS
  *	- If the file "localmacros" is readable in the current
- *	  directory, print a warning message to stderr and add: 
+ *	  directory, print a warning message to stderr and add:
  *		#define IMAKE_LOCAL_MACROS	"localmacros"
  *		#include IMAKE_LOCAL_MACROS
  *   5. Start up cpp and provide it with this file.
@@ -227,7 +227,7 @@
 #  define WIFEXITED(w) waitCode(w)
 # endif
 #endif /* X_NOT_POSIX */
-#include <stdlib.h>
+# include <stdlib.h>
 #if defined(macII) && !defined(__STDC__)  /* stdlib.h fails to define these */
 char *malloc(), *realloc();
 #endif /* macII */
@@ -239,9 +239,6 @@
 #if !((defined(sun) && !defined(SVR4)) || defined(macII))
 #define USE_STRERROR		1
 #endif
-#ifdef __EMX__
-#define USE_STRERROR		1
-#endif
 #ifndef WIN32
 #include <sys/utsname.h>
 #else
@@ -262,8 +259,6 @@
 #include <unix.h>
 #endif
 
-#include "imakemdep.h"
-
 /*
  * This define of strerror is copied from (and should be identical to)
  * Xos.h, which we don't want to include here for bootstrapping reasons.
@@ -281,56 +276,61 @@
 #include <sys/utsname.h>
 #endif
 
-#if !(defined(Lynx) || defined(__Lynx__) || (defined(SVR4) && !defined(sun))) && !defined(__CYGWIN__)
+#if !(defined(Lynx) || defined(__Lynx__) || (defined(SVR4) && !defined(sun))) && !defined (__CYGWIN__)
 #define HAS_MKSTEMP
 #endif
 
-#define	TRUE		1
-#define	FALSE		0
+typedef unsigned char boolean;
+#define TRUE		1
+#define FALSE		0
 
-#ifdef FIXUP_CPP_WHITESPACE
-int	InRule = FALSE;
-# ifdef INLINE_SYNTAX
-int	InInline = 0;
-# endif
+# include "imakemdep.h"
+#ifdef CROSSCOMPILE
+# include "imakemdep_cpp.h"
+#endif
+
+#if defined CROSSCOMPILE || defined FIXUP_CPP_WHITESPACE
+int InRule = FALSE;
 #endif
-#ifdef MAGIC_MAKE_VARS
+#if defined CROSSCOMPILE || defined INLINE_SYNTAX
+int InInline = 0;
+#endif
+#if defined CROSSCOMPILE || defined MAGIC_MAKE_VARS
 int xvariable = 0;
 int xvariables[10];
 #endif
 
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+
 /*
  * Some versions of cpp reduce all tabs in macro expansion to a single
  * space.  In addition, the escaped newline may be replaced with a
  * space instead of being deleted.  Blech.
  */
-#ifdef FIXUP_CPP_WHITESPACE
 void KludgeOutputLine(char **), KludgeResetRule(void);
-#else
-# define KludgeOutputLine(arg)
-# define KludgeResetRule()
-#endif
-
-typedef	unsigned char	boolean;
 
-#ifdef USE_CC_E
-# ifndef DEFAULT_CC
-#  define DEFAULT_CC "cc"
-# endif
-#else
-# ifndef DEFAULT_CPP
-#  ifdef CPP_PROGRAM
-#   define DEFAULT_CPP CPP_PROGRAM
-#  else
-#   define DEFAULT_CPP "/lib/cpp"
+#ifndef CROSSCOMPILE
+# ifdef USE_CC_E
+#  ifndef DEFAULT_CC
+#   define DEFAULT_CC "cc"
+#  endif
+# else
+#  ifndef DEFAULT_CPP
+#   ifdef CPP_PROGRAM
+#    define DEFAULT_CPP CPP_PROGRAM
+#   else
+#    define DEFAULT_CPP "/lib/cpp"
+#   endif
 #  endif
 # endif
 #endif
 
 char *cpp = NULL;
 
-char	*tmpMakefile    = "/tmp/Imf.XXXXXX";
-char	*tmpImakefile    = "/tmp/IIf.XXXXXX";
+char	*tmpMakefile = "/tmp/Imf.XXXXXX";
+char	*tmpImakefile = "/tmp/IIf.XXXXXX";
 char	*make_argv[ ARGUMENTS ] = {
 #ifdef WIN32
     "nmake"
@@ -353,35 +353,48 @@
 char	*CleanCppInput(char *imakefile);
 char	*Strdup(char *cp);
 char	*Emalloc(int size);
-void	LogFatalI(char *s, int i), LogFatal(char *x0, char *x1), 
-        LogMsg(char *x0, char *x1);
+void	LogFatalI(char *s, int i), LogFatal(char *x0, char *x1),
+	LogMsg(char *x0, char *x1);
 
 void	showit(FILE *fd);
 void	wrapup(void);
 void	init(void);
 void	AddMakeArg(char *arg);
 void	AddCppArg(char *arg);
+#ifdef CROSSCOMPILE
+char	*CrossCompileCPP(void);
+#endif
 void	SetOpts(int argc, char **argv);
 void	CheckImakefileC(char *masterc);
-void	cppit(char *imakefile, char *template, char *masterc, 
+void	cppit(char *imakefile, char *template, char *masterc,
 	      FILE *outfd, char *outfname);
 void	makeit(void);
 void	CleanCppOutput(FILE *tmpfd, char *tmpfname);
-boolean	isempty(char *line);
+boolean isempty(char *line);
 void	writetmpfile(FILE *fd, char *buf, int cnt, char *fname);
 #ifdef SIGNALRETURNSINT
-int     catch(int sig);
+int	catch(int sig);
 #else
-void    catch(int sig);
+void	catch(int sig);
 #endif
-void    showargs(char **argv);
+void	showargs(char **argv);
 boolean optional_include(FILE *inFile, char *defsym, char *fname);
-void    doit(FILE *outfd, char *cmd, char **argv);
+void	  doit(FILE *outfd, char *cmd, char **argv);
 boolean define_os_defaults(FILE *inFile);
+#ifdef CROSSCOMPILE
+static void get_cross_compile_dir(FILE *inFile);
+#endif
+#ifdef CROSSCOMPILEDIR
+char *CrossCompileDir = CROSSCOMPILEDIR;
+#else
+char *CrossCompileDir = "";
+#endif
+boolean CrossCompiling = FALSE;
+
 
 
-boolean	verbose = FALSE;
-boolean	show = TRUE;
+boolean verbose = FALSE;
+boolean show = TRUE;
 
 int
 main(int argc, char *argv[])
@@ -389,20 +402,30 @@
 	FILE	*tmpfd = NULL;
 	char	makeMacro[ BUFSIZ ];
 	char	makefileMacro[ BUFSIZ ];
+	int	lenCrossCompileDir = 0;
 
 	program = argv[0];
 	init();
-	SetOpts(argc, argv);
 
+	lenCrossCompileDir = strlen(CrossCompileDir);
+	if (lenCrossCompileDir) {
+	    if (lenCrossCompileDir > (PATH_MAX - 20))
+	      LogFatal("Cross compile directory path too long %s\n",
+		       CrossCompileDir);
+	    else
+		CrossCompiling = TRUE;
+	}
+
+	SetOpts(argc, argv);
 	Imakefile = FindImakefile(Imakefile);
 	CheckImakefileC(ImakefileC);
 	if (Makefile) {
-                tmpMakefile = Makefile;
-                if ((tmpfd = fopen(tmpMakefile, "w+")) == NULL)
-                   LogFatal("Cannot create temporary file %s.", tmpMakefile);
+		tmpMakefile = Makefile;
+		if ((tmpfd = fopen(tmpMakefile, "w+")) == NULL)
+		   LogFatal("Cannot create temporary file %s.", tmpMakefile);
 	} else {
 #ifdef HAS_MKSTEMP
-	        int fd;
+		int fd;
 #endif
 		tmpMakefile = Strdup(tmpMakefile);
 #ifndef HAS_MKSTEMP
@@ -411,8 +434,8 @@
 		   LogFatal("Cannot create temporary file %s.", tmpMakefile);
 		}
 #else
-	        fd = mkstemp(tmpMakefile);
-	        if (fd == -1 || (tmpfd = fdopen(fd, "w+")) == NULL) {
+		fd = mkstemp(tmpMakefile);
+		if (fd == -1 || (tmpfd = fdopen(fd, "w+")) == NULL) {
 		   if (fd != -1) {
 		      unlink(tmpMakefile); close(fd);
 		   }
@@ -489,7 +512,13 @@
 	while (cpp_argv[ cpp_argindex ] != NULL)
 		cpp_argindex++;
 
-#if defined(__NetBSD__)
+#if defined CROSSCOMPILE
+	if (sys == netBSD)
+	  if (CrossCompiling) {
+	    LogFatal("fix imake to do crosscompiling for NetBSD\n","");
+	  } else
+#endif
+#if defined(__NetBSD__) || defined CROSSCOMPILE
 	{
 		struct utsname uts;
 		static char argument[512];
@@ -561,6 +590,7 @@
 void
 SetOpts(int argc, char **argv)
 {
+
 	errno = 0;
 	/*
 	 * Now gather the arguments for make
@@ -627,16 +657,27 @@
 	    } else
 		AddMakeArg(argv[0]);
 	}
-#ifdef USE_CC_E
-	if (!cpp)
-	{
+
+#ifndef CROSSCOMPILE
+# ifdef USE_CC_E
+	    if (!cpp)
+	    {
 		AddCppArg("-E");
+#ifdef __GNUC__
+		if (verbose)
+		    AddCppArg("-v");
+#endif
 		cpp = DEFAULT_CC;
-	}
-#else
-	if (!cpp)
+	    }
+# else
+	    if (!cpp)
 		cpp = DEFAULT_CPP;
+# endif
+#else
+	    if (!cpp)
+		cpp = CrossCompileCPP();
 #endif
+
 	cpp_argv[0] = cpp;
 	AddCppArg(ImakefileC);
 }
@@ -669,7 +710,7 @@
 void
 LogFatal(char *x0, char *x1)
 {
-	static boolean	entered = FALSE;
+	static boolean entered = FALSE;
 
 	if (entered)
 		return;
@@ -716,7 +757,7 @@
 		if (inFile == NULL)
 			LogFatal("Refuse to overwrite: %s", masterc);
 		if ((fgets(mkcbuf, sizeof(mkcbuf), inFile) &&
-		     strncmp(mkcbuf, ImakefileCHeader, 
+		     strncmp(mkcbuf, ImakefileCHeader,
 			     sizeof(ImakefileCHeader)-1)))
 		{
 			fclose(inFile);
@@ -730,7 +771,7 @@
 #define IncludeFmt	"#include %s\n"
 #define ImakeDefSym	"INCLUDE_IMAKEFILE"
 #define ImakeTmplSym	"IMAKE_TEMPLATE"
-#define OverrideWarning	"Warning: local file \"%s\" overrides global macros."
+#define OverrideWarning "Warning: local file \"%s\" overrides global macros."
 
 boolean
 optional_include(FILE *inFile, char *defsym, char *fname)
@@ -747,7 +788,7 @@
 void
 doit(FILE *outfd, char *cmd, char **argv)
 {
-	int	pid;
+	int		pid;
 	waitType	status;
 
 	/*
@@ -785,7 +826,7 @@
 #endif
 }
 
-#ifndef WIN32
+#if !defined WIN32
 static void
 parse_utsname(struct utsname *name, char *fmt, char *result, char *msg)
 {
@@ -793,6 +834,9 @@
   char *ptr = buf;
   int arg;
 
+  if (!name)
+      LogFatal(msg,fmt);
+
   /* Assemble all the pieces into a buffer. */
   for (arg = 0; fmt[arg] != ' '; arg++)
     {
@@ -855,7 +899,7 @@
    the number to be interpreted as octal numbers.  Some version strings
    have the potential for different numbers of .'s in them.
  */
-	
+
 static char *
 trim_version(char *p)
 {
@@ -869,19 +913,15 @@
 }
 #endif
 
-#ifdef linux
+#if defined linux
 const char *libc_c=
 "#include <stdio.h>\n"
 "#include <ctype.h>\n"
 "\n"
-"#if 0\n"
+"#if 1\n"
 "#pragma weak gnu_get_libc_version\n"
 "#pragma weak __libc_version\n"
 "#pragma weak __linux_C_lib_version\n"
-"#else\n"
-"asm (\".weak gnu_get_libc_version\");\n"
-"asm (\".weak __libc_version\");\n"
-"asm (\".weak __linux_C_lib_version\");\n"
 "#endif\n"
 "\n"
 "extern const char * gnu_get_libc_version (void);\n"
@@ -892,34 +932,30 @@
 "main ()\n"
 "{\n"
 "  int libcmajor = 0, libcminor = 0, libcteeny = 0;\n"
+"  const char * ptr = NULL;\n"
+"  int glibcmajor = 0;\n"
 "\n"
-"  if (((&__linux_C_lib_version != 0)\n"
-"       && ((&__libc_version != 0) || (gnu_get_libc_version != 0)))\n"
-"      || (!(&__linux_C_lib_version != 0) && !(&__libc_version != 0)\n"
-"	  && !(gnu_get_libc_version != 0)))\n"
+"  if (gnu_get_libc_version != 0)\n"
 "  {\n"
-"    libcmajor = 0;\n"
-"    libcminor = 0;\n"
-"    libcteeny = 0;\n"
+"    ptr = gnu_get_libc_version ();\n"
+"    glibcmajor = 4;\n"
 "  }\n"
+"  else if (&__libc_version != 0)\n"
+"  {\n"
+"    ptr = __libc_version;\n"
+"    glibcmajor = 4;\n"
+"  }\n"
+"  else if (&__linux_C_lib_version != 0)\n"
+"  {\n"
+"    ptr = __linux_C_lib_version;\n"
+"  }\n"
 "  else\n"
 "  {\n"
-"    const char * ptr;\n"
-"    int glibcmajor = 0;\n"
-"\n"
-"    if (gnu_get_libc_version != 0)\n"
-"    {\n"
-"      ptr = gnu_get_libc_version ();\n"
-"      glibcmajor = 4;\n"
-"    }\n"
-"    else if (&__libc_version != 0)\n"
-"    {\n"
-"      ptr = __libc_version;\n"
-"      glibcmajor = 4;\n"
-"    }\n"
-"    else\n"
-"      ptr = __linux_C_lib_version;\n"
+"    libcmajor = 0; libcminor = 0; libcteeny = 0;\n"
+"  }\n"
 "\n"
+"  if (ptr)\n"
+"  {\n"
 "    while (!isdigit (*ptr))\n"
 "      ptr++;\n"
 "\n"
@@ -936,53 +972,6 @@
 ;
 
 static void
-get_distrib(FILE *inFile)
-{
-  struct stat sb;
-
-  static char* yast = "/sbin/YaST";
-  static char* redhat = "/etc/redhat-release";
-  static char* debian = "/etc/debian_version";
-
-  fprintf (inFile, "%s\n", "#define LinuxUnknown    0");
-  fprintf (inFile, "%s\n", "#define LinuxSuSE       1");
-  fprintf (inFile, "%s\n", "#define LinuxCaldera    2");
-  fprintf (inFile, "%s\n", "#define LinuxCraftworks 3");
-  fprintf (inFile, "%s\n", "#define LinuxDebian     4");
-  fprintf (inFile, "%s\n", "#define LinuxInfoMagic  5");
-  fprintf (inFile, "%s\n", "#define LinuxKheops     6");
-  fprintf (inFile, "%s\n", "#define LinuxPro        7");
-  fprintf (inFile, "%s\n", "#define LinuxRedHat     8");
-  fprintf (inFile, "%s\n", "#define LinuxSlackware  9");
-  fprintf (inFile, "%s\n", "#define LinuxTurbo      10");
-  fprintf (inFile, "%s\n", "#define LinuxWare       11");
-  fprintf (inFile, "%s\n", "#define LinuxYggdrasil  12");
-
-  if (lstat (yast, &sb) == 0) {
-    fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxSuSE");
-    fprintf (inFile, "%s\n", "#define DefaultLinuxDistName SuSE");
-    return;
-  }
-  if (lstat (redhat, &sb) == 0) {
-    fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxRedHat");
-    fprintf (inFile, "%s\n", "#define DefaultLinuxDistName RedHat");
-    return;
-  }
-  if (lstat (debian, &sb) == 0) {
-    fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxDebian");
-    fprintf (inFile, "%s\n", "#define DefaultLinuxDistName Debian");
-    /* You could also try to get the version of the Debian distrib by looking
-     * at the content of /etc/debian_version */
-    return;
-  }
-  /* what's the definitive way to tell what any particular distribution is? */
-
-  fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxUnknown");
-  fprintf (inFile, "%s\n", "#define DefaultLinuxDistName Unknown");
-  /* would like to know what version of the distribution it is */
-}
-
-static void
 get_libc_version(FILE *inFile)
 {
   char aout[] = "/tmp/imakeXXXXXX";
@@ -1023,19 +1012,116 @@
 
   while (fgets (command, len, fp))
     fprintf (inFile, command);
-  
+
   len = pclose (fp);
   remove (aout);
   if (len)
     abort ();
 }
+#endif
+
+#if defined(__OpenBSD__) 
+static void
+get_stackprotector(FILE *inFile)
+{
+  FILE *fp;
+  char *cc;
+  char command[1024], buf[1024];
+  
+  cc = getenv("CC");
+  if (cc == NULL) {
+    cc = "cc";
+  }
+  snprintf(command, sizeof(command), "%s -v 2>&1", cc);
+  fp = popen(command, "r");
+  if (fp == NULL) 
+    abort();
+  while (fgets(buf, sizeof(buf), fp)) {
+    if (strstr(buf, "propolice") != NULL) {
+      fprintf(inFile, "#define HasGccStackProtector YES\n");
+      break;
+    }
+  }
+  if (pclose(fp)) 
+    abort();
+}
+#endif
+	
+
+#if defined CROSSCOMPILE || defined linux
+static void
+get_distrib(FILE *inFile)
+{
+  struct stat sb;
+
+  static char* suse = "/etc/SuSE-release";
+  static char* redhat = "/etc/redhat-release";
+  static char* debian = "/etc/debian_version";
+
+  fprintf (inFile, "%s\n", "#define LinuxUnknown    0");
+  fprintf (inFile, "%s\n", "#define LinuxSuSE       1");
+  fprintf (inFile, "%s\n", "#define LinuxCaldera    2");
+  fprintf (inFile, "%s\n", "#define LinuxCraftworks 3");
+  fprintf (inFile, "%s\n", "#define LinuxDebian     4");
+  fprintf (inFile, "%s\n", "#define LinuxInfoMagic  5");
+  fprintf (inFile, "%s\n", "#define LinuxKheops     6");
+  fprintf (inFile, "%s\n", "#define LinuxPro        7");
+  fprintf (inFile, "%s\n", "#define LinuxRedHat     8");
+  fprintf (inFile, "%s\n", "#define LinuxSlackware  9");
+  fprintf (inFile, "%s\n", "#define LinuxTurbo      10");
+  fprintf (inFile, "%s\n", "#define LinuxWare       11");
+  fprintf (inFile, "%s\n", "#define LinuxYggdrasil  12");
+
+#ifdef CROSSCOMPILE
+  if (CrossCompiling) {
+      fprintf (inFile, "%s\n",
+	       "#define DefaultLinuxDistribution LinuxUnknown");
+      fprintf (inFile, "%s\n", "#define DefaultLinuxDistName Unknown");
+      return;
+  }
+#endif
+  if (lstat (suse, &sb) == 0) {
+    fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxSuSE");
+    fprintf (inFile, "%s\n", "#define DefaultLinuxDistName SuSE");
+    return;
+  }
+  if (lstat (redhat, &sb) == 0) {
+    fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxRedHat");
+    fprintf (inFile, "%s\n", "#define DefaultLinuxDistName RedHat");
+    return;
+  }
+  if (lstat (debian, &sb) == 0) {
+    fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxDebian");
+    fprintf (inFile, "%s\n", "#define DefaultLinuxDistName Debian");
+    /* You could also try to get the version of the Debian distrib by looking
+     * at the content of /etc/debian_version */
+    return;
+  }
+  /* what's the definitive way to tell what any particular distribution is? */
+
+  fprintf (inFile, "%s\n", "#define DefaultLinuxDistribution LinuxUnknown");
+  fprintf (inFile, "%s\n", "#define DefaultLinuxDistName Unknown");
+  /* would like to know what version of the distribution it is */
+}
 
 static void
 get_ld_version(FILE *inFile)
 {
-  FILE* ldprog = popen ("ld -v", "r");
+  FILE* ldprog;
   signed char c;
   int ldmajor, ldminor;
+  const char *ld = "ld -v";
+
+#ifdef CROSSCOMPILE
+  if (CrossCompiling) {
+      char cmd[PATH_MAX];
+      strcpy (cmd, CrossCompileDir);
+      strcat (cmd,"/");
+      strcat (cmd,ld);
+      ldprog = popen (cmd, "r");
+  } else
+#endif
+      ldprog = popen (ld, "r");
 
   if (ldprog) {
     do {
@@ -1048,14 +1134,15 @@
 	ldmajor *= 100;
     else
 	ldmajor *= 10;
-    fprintf(inFile, "#define DefaultLinuxBinUtilsMajorVersion %d\n", 
-	    ldmajor + ldminor);    
+
+    fprintf(inFile, "#define DefaultLinuxBinUtilsMajorVersion %d\n",
+	    ldmajor + ldminor);
     pclose (ldprog);
   }
 }
 #endif
 
-#ifdef __FreeBSD__
+#if defined __FreeBSD__
 static void
 get_binary_format(FILE *inFile)
 {
@@ -1065,13 +1152,21 @@
   FILE *objprog = NULL;
   int iself = 0;
   char buf[10];
+  char cmd[PATH_MAX];
 
   mib[0] = CTL_KERN;
   mib[1] = KERN_OSRELDATE;
   len = sizeof(osrel);
   sysctl(mib, 2, &osrel, &len, NULL, 0);
+  if (CrossCompiling) {
+      strcpy (cmd, CrossCompileDir);
+      strcat (cmd, "/");
+      strcat (cmd,"objformat");
+  } else
+      strcpy (cmd, "objformat");
+
   if (osrel >= 300004 &&
-      (objprog = popen("objformat", "r")) != NULL &&
+      (objprog = popen(cmd, "r")) != NULL &&
       fgets(buf, sizeof(buf), objprog) != NULL &&
       strncmp(buf, "elf", 3) == 0)
     iself = 1;
@@ -1082,10 +1177,6 @@
 }
 #endif
 
-#ifndef PATH_MAX
-#define PATH_MAX 1024
-#endif
-
 #if defined(sun) && defined(__SVR4)
 static void
 get_sun_compiler_versions (FILE *inFile)
@@ -1099,6 +1190,18 @@
   struct stat sb;
   FILE* ccproc;
 
+#if defined CROSSCOMPILE
+  if (CrossCompiling) {
+      int len = strlen(CrossCompileDir);
+      len += 3;
+      sunpro_cc = (char *) malloc(len);
+      sunpro_CC = (char *) malloc(len);
+      strcpy(sunpro_cc,CrossCompileDir);
+      strcpy(sunpro_CC,CrossCompileDir);
+      strcat(sunpro_cc,"/cc");
+      strcat(sunpro_CC,"/CC");
+  }
+#endif
   if (lstat (sunpro_cc, &sb) == 0) {
     strcpy (cmd, sunpro_cc);
     strcat (cmd, " -V 2>&1");
@@ -1107,10 +1210,10 @@
 	vptr = strrchr (buf, 'C');
 	for (; !isdigit(*vptr); vptr++);
 	(void) sscanf (vptr, "%d.%d", &cmajor, &cminor);
-	fprintf (inFile, 
+	fprintf (inFile,
 		 "#define DefaultSunProCCompilerMajorVersion %d\n",
 		 cmajor);
-	fprintf (inFile, 
+	fprintf (inFile,
 		 "#define DefaultSunProCCompilerMinorVersion %d\n",
 		 cminor);
       }
@@ -1126,10 +1229,10 @@
 	vptr = strrchr (buf, 'C');
 	for (; !isdigit(*vptr); vptr++);
 	(void) sscanf (vptr, "%d.%d", &cmajor, &cminor);
-	fprintf (inFile, 
+	fprintf (inFile,
 		 "#define DefaultSunProCplusplusCompilerMajorVersion %d\n",
 		 cmajor);
-	fprintf (inFile, 
+	fprintf (inFile,
 		 "#define DefaultSunProCplusplusCompilerMinorVersion %d\n",
 		 cminor);
       }
@@ -1140,160 +1243,374 @@
 }
 #endif
 
-#ifdef __GNUC__
+#if defined CROSSCOMPILE || defined  __GNUC__
 static void
-get_gcc_version(FILE *inFile)
+get_gcc_version(FILE *inFile, char *name)
 {
-   fprintf (inFile, "#define HasGcc 1\n");
+    fprintf (inFile, "#define HasGcc 1\n");
+#ifdef CROSSCOMPILE
+    if (CrossCompiling)
+    {
+	if (gnu_c > 1) {
+	    fprintf (inFile, "#define HasGcc2 1\n");
+	    if (gnu_c > 2)
+		fprintf (inFile, "#define HasGcc3 1\n");
+	}
+	fprintf (inFile, "#define GccMajorVersion %d\n", gnu_c);
+	fprintf (inFile, "#define GccMinorVersion %d\n", gnu_c_minor);
+    } else
+#endif
+    {
 #if __GNUC__ > 1
-   fprintf (inFile, "#define HasGcc2 1\n");
+	fprintf (inFile, "#define HasGcc2 1\n");
+# if __GNUC__ > 2
+	fprintf (inFile, "#define HasGcc3 1\n");
+# endif
 #endif
-   fprintf (inFile, "#define GccMajorVersion %d\n", __GNUC__);
-   fprintf (inFile, "#define GccMinorVersion %d\n", __GNUC_MINOR__);
+	fprintf (inFile, "#define GccMajorVersion %d\n", __GNUC__);
+	fprintf (inFile, "#define GccMinorVersion %d\n", __GNUC_MINOR__);
+    }
 #if defined(HAS_MERGE_CONSTANTS)
-   fprintf (inFile, "#define HasGccMergeConstants %d\n", HAS_MERGE_CONSTANTS);
+    fprintf (inFile, "#define HasGccMergeConstants %d\n", HAS_MERGE_CONSTANTS);
 #endif
 }
 #endif
 
-#ifndef __EMX__
-static void
-get_gcc_incdir(FILE *inFile)
+static boolean
+get_gcc(char *cmd)
 {
-  static char* gcc_path[] = {
-#if defined(linux) || defined(__OpenBSD__) || defined (__GNU__)
-    "/usr/bin/cc",	/* for Linux PostIncDir */
-#endif
-    "/usr/local/bin/gcc",
-    "/opt/gnu/bin/gcc"
-  };
   struct stat sb;
-  int i;
+    static char* gcc_path[] = {
+# if defined(linux) || \
+     defined(__NetBSD__) || \
+     defined(__OpenBSD__) || \
+     defined(__FreeBSD__) || \
+     defined(__APPLE__) || \
+     defined(__GNU__)
+	"/usr/bin/cc",	/* for Linux PostIncDir */
+# endif
+	"/usr/local/bin/gcc",
+	"/opt/gnu/bin/gcc",
+	"/usr/pkg/bin/gcc"
+    };
+
+#ifdef CROSSCOMPILE
+    static char* cross_cc_name[] = {
+	"cc",
+	"gcc"
+    };
+
+    if (CrossCompiling) {
+	int i;
+	for (i = 0; i < sizeof (cross_cc_name) / sizeof cross_cc_name[0]; i++){
+	    strcpy (cmd, CrossCompileDir);
+	    strcat (cmd, "/");
+	    strcat (cmd, cross_cc_name[i]);
+	    if (lstat (cmd, &sb) == 0) {
+		return TRUE;
+		break;
+	    }
+	}
+    } else
+#endif
+      {
+	int i;
+	for (i = 0; i < sizeof (gcc_path) / sizeof gcc_path[0]; i++) {
+	    if (lstat (gcc_path[i], &sb) == 0) {
+		strcpy (cmd, gcc_path[i]);
+		return TRUE;
+	    }
+	}
+      }
+    return FALSE;
+}
+
+#if defined CROSSCOMPILE || !defined __UNIXOS2__
+static void
+get_gcc_incdir(FILE *inFile, char* name)
+{
   FILE* gccproc;
   char buf[PATH_MAX];
   char cmd[PATH_MAX];
   char* ptr;
 
+  strcpy(cmd,name);
+
   buf[0] = '\0';
-  for (i = 0; i < sizeof gcc_path / sizeof gcc_path[0]; i++) {
-    if (lstat (gcc_path[i], &sb) == 0) {
-      strcpy (cmd, gcc_path[i]);
-      strcat (cmd, " --print-libgcc-file-name");
-      if ((gccproc = popen (cmd, "r")) != NULL) {
-	if (fgets (buf, PATH_MAX, gccproc) != NULL) {
+  strcat (cmd, " --print-libgcc-file-name");
+  if ((gccproc = popen (cmd, "r")) != NULL) {
+      if (fgets (buf, PATH_MAX, gccproc) != NULL) {
 	  ptr = strstr (buf, "libgcc.a");
 	  if (ptr) strcpy (ptr, "include");
-	}
-	(void) pclose (gccproc);
-	break;
       }
-    }
+      (void) pclose (gccproc);
   }
+
   if (buf[0])
-    fprintf (inFile, "#define DefaultGccIncludeDir \"%s\"\n", buf);
+      fprintf (inFile, "#define DefaultGccIncludeDir \"%s\"\n", buf);
 }
 #endif
 
 boolean
 define_os_defaults(FILE *inFile)
 {
-#if !defined(WIN32) && !defined(__EMX__)
-#if (defined(DEFAULT_OS_NAME) || defined(DEFAULT_OS_MAJOR_REV) || \
+#if defined CROSSCOMPILE || ( !defined(WIN32) && !defined(__UNIXOS2__) )
+#ifdef CROSSCOMPILE
+  if ((sys != win32) && (sys != emx))
+#endif
+    {
+# if (defined(DEFAULT_OS_NAME) || defined(DEFAULT_OS_MAJOR_REV) || \
      defined(DEFAULT_OS_MINOR_REV) || defined(DEFAULT_OS_TEENY_REV))
-	struct utsname name;
+	struct utsname *name = NULL;
+	struct utsname uts_name;
 	char buf[SYS_NMLN * 5 + 1];
 
 	/* Obtain the system information. */
-	if (uname(&name) < 0)
-		LogFatal("Cannot invoke uname", "");
+#ifdef CROSSCOMPILE
+      if (!CrossCompiling)
+#endif
+      {
+	  if (uname(&uts_name) < 0)
+	      LogFatal("Cannot invoke uname", "");
+	  else
+	      name = &uts_name;
+      }
+#if defined CROSSCOMPILE && defined linux
+      else {
+	  strncpy(uts_name.sysname,cross_uts_sysname,SYS_NMLN);
+	  strncpy(uts_name.release,cross_uts_release,SYS_NMLN);
+	  strncpy(uts_name.version,cross_uts_version,SYS_NMLN);
+	  strncpy(uts_name.machine,cross_uts_machine,SYS_NMLN);
+	  name = &uts_name;
+      }
+#endif
 
-# ifdef DEFAULT_OS_NAME
-	parse_utsname(&name, DEFAULT_OS_NAME, buf, 
-		      "Bad DEFAULT_OS_NAME syntax %s");
-#  ifdef DEFAULT_OS_NAME_FROB
-	DEFAULT_OS_NAME_FROB(buf, sizeof buf);
+#  if defined DEFAULT_OS_NAME
+#   if defined CROSSCOMPILE
+      if (!CrossCompiling)
+#   endif
+	{
+	  parse_utsname(name, DEFAULT_OS_NAME, buf,
+			"Bad DEFAULT_OS_NAME syntax %s");
+#   ifdef DEFAULT_OS_NAME_FROB
+	  DEFAULT_OS_NAME_FROB(buf, sizeof buf);
+#   endif
+	  if (buf[0] != '\0')
+	    fprintf(inFile, "#define DefaultOSName %s\n", buf);
+	}
 #  endif
-	if (buf[0] != '\0')
-		fprintf(inFile, "#define DefaultOSName %s\n", buf);
-# endif
 
-# ifdef DEFAULT_OS_MAJOR_REV
-	parse_utsname(&name, DEFAULT_OS_MAJOR_REV, buf,
-		      "Bad DEFAULT_OS_MAJOR_REV syntax %s");
-#  ifdef DEFAULT_OS_MAJOR_REV_FROB
-	DEFAULT_OS_MAJOR_REV_FROB(buf, sizeof buf);
+#  if defined CROSSCOMPILE
+	if (CrossCompiling && defaultOsName) {
+	  parse_utsname(name, defaultOsName, buf,
+			"Bad DEFAULT_OS_NAME syntax %s");
+	  if (defaultOsNameFrob)
+	    defaultOsNameFrob(buf, sizeof buf);
+	  if (buf[0] != '\0')
+	    fprintf(inFile, "#define DefaultOSName %s\n", buf);
+	}
 #  endif
-	fprintf(inFile, "#define DefaultOSMajorVersion %s\n",
-		*buf ? trim_version(buf) : "0");
-# endif
 
-# ifdef DEFAULT_OS_MINOR_REV
-	parse_utsname(&name, DEFAULT_OS_MINOR_REV, buf,
-		      "Bad DEFAULT_OS_MINOR_REV syntax %s");
-#  ifdef DEFAULT_OS_MINOR_REV_FROB
-	DEFAULT_OS_MINOR_REV_FROB(buf, sizeof buf);
+#  ifdef DEFAULT_OS_MAJOR_REV
+#   if defined CROSSCOMPILE
+	if (!CrossCompiling)
+#   endif
+	  {
+	    parse_utsname(name, DEFAULT_OS_MAJOR_REV, buf,
+			  "Bad DEFAULT_OS_MAJOR_REV syntax %s");
+#   ifdef DEFAULT_OS_MAJOR_REV_FROB
+	    DEFAULT_OS_MAJOR_REV_FROB(buf, sizeof buf);
+#   endif
+	    fprintf(inFile, "#define DefaultOSMajorVersion %s\n",
+		    *buf ? trim_version(buf) : "0");
+	  }
 #  endif
-	fprintf(inFile, "#define DefaultOSMinorVersion %s\n",
-		*buf ? trim_version(buf) : "0");
-# endif
+
+#  if defined CROSSCOMPILE
+	if (CrossCompiling && defaultOsMajorRev) {
+	  parse_utsname(name, defaultOsMajorRev, buf,
+			"Bad defaultOsMajorRev syntax %s");
+	  if (defaultOsMajorRevFrob)
+	    defaultOsMajorRevFrob(buf, sizeof buf);
+	  fprintf(inFile, "#define DefaultOSMajorVersion %s\n",
+		  *buf ? trim_version(buf) : "0");
+	}
+#  endif
+
+#  ifdef DEFAULT_OS_MINOR_REV
+#   if defined CROSSCOMPILE
+	if (!CrossCompiling)
+#   endif
+	  {
+	    parse_utsname(name, DEFAULT_OS_MINOR_REV, buf,
+			  "Bad DEFAULT_OS_MINOR_REV syntax %s");
+#   ifdef DEFAULT_OS_MINOR_REV_FROB
+	    DEFAULT_OS_MINOR_REV_FROB(buf, sizeof buf);
+#   endif
+	    fprintf(inFile, "#define DefaultOSMinorVersion %s\n",
+		    *buf ? trim_version(buf) : "0");
+	  }
+#  endif
+
+#  if defined CROSSCOMPILE
+	if (CrossCompiling && defaultOsMinorRev) {
+	  parse_utsname(name, defaultOsMinorRev, buf,
+			"Bad defaultOsMinorRev syntax %s");
+	  if (defaultOsMinorRevFrob)
+	    defaultOsMinorRevFrob(buf, sizeof buf);
+	  fprintf(inFile, "#define DefaultOSMinorVersion %s\n",
+		  *buf ? trim_version(buf) : "0");
+	}
+#  endif
 
-# ifdef DEFAULT_OS_TEENY_REV
-	parse_utsname(&name, DEFAULT_OS_TEENY_REV, buf,
-		      "Bad DEFAULT_OS_TEENY_REV syntax %s");
-#  ifdef DEFAULT_OS_TEENY_REV_FROB
-	DEFAULT_OS_TEENY_REV_FROB(buf, sizeof buf);
+#  ifdef DEFAULT_OS_TEENY_REV
+#   if defined CROSSCOMPILE
+	if (!CrossCompiling)
+#   endif
+	  {
+	    parse_utsname(name, DEFAULT_OS_TEENY_REV, buf,
+			  "Bad DEFAULT_OS_TEENY_REV syntax %s");
+#   ifdef DEFAULT_OS_TEENY_REV_FROB
+	    DEFAULT_OS_TEENY_REV_FROB(buf, sizeof buf);
+#   endif
+	    fprintf(inFile, "#define DefaultOSTeenyVersion %s\n",
+		    *buf ? trim_version(buf) : "0");
+	  }
+#  endif
+
+#  if defined CROSSCOMPILE
+	if (CrossCompiling && defaultOsTeenyRev) {
+	  parse_utsname(name, defaultOsTeenyRev, buf,
+			"Bad defaultOsTeenyRev syntax %s");
+	  if (defaultOsTeenyRevFrob)
+	    defaultOsTeenyRevFrob(buf, sizeof buf);
+	  fprintf(inFile, "#define DefaultOSTeenyVersion %s\n",
+		  *buf ? trim_version(buf) : "0");
+	}
 #  endif
-	fprintf(inFile, "#define DefaultOSTeenyVersion %s\n",
-		*buf ? trim_version(buf) : "0");
+
+#  ifdef DEFAULT_MACHINE_ARCHITECTURE
+#   if defined CROSSCOMPILE
+	if (!CrossCompiling)
+#   endif
+	  {
+	    parse_utsname(name, DEFAULT_MACHINE_ARCHITECTURE, buf,
+			  "Bad DEFAULT_MACHINE_ARCHITECTURE %s");
+	    fprintf(inFile, "#ifndef %s\n# define %s\n#endif\n", buf, buf);
+	  }
+#  endif
+
+#  if defined CROSSCOMPILE
+	if (CrossCompiling && defaultMachineArchitecture) {
+	  parse_utsname(name, defaultMachineArchitecture, buf,
+			"Bad defaultMachineArchitecture syntax %s");
+	  fprintf(inFile, "#ifndef %s\n# define %s\n#endif\n", buf, buf);
+	}
+#  endif
 # endif
-# ifdef DEFAULT_MACHINE_ARCHITECTURE
-	parse_utsname(&name, DEFAULT_MACHINE_ARCHITECTURE, buf, 
-		      "Bad DEFAULT_MACHINE_ARCHITECTURE %s");
-	fprintf(inFile, "#ifndef %s\n# define %s\n#endif\n", buf, buf);
+# if defined CROSSCOMPILE
+      if (CrossCompiling)
+	get_cross_compile_dir(inFile);
+      else
 # endif
-#endif
-#ifdef linux
-    get_distrib (inFile);
-    get_libc_version (inFile);
-    get_ld_version(inFile);
-#endif
-    get_gcc_incdir(inFile);
-#if defined (sun) && defined(SVR4)
-    get_sun_compiler_versions (inFile);
-#endif
-#ifdef __GNUC__
-    get_gcc_version (inFile);
-#endif
-#ifdef __FreeBSD__
-    get_binary_format(inFile);
+	  fprintf(inFile, "#define CrossCompiling NO\n");
+# if defined CROSSCOMPILE
+      if (CrossCompiling && sys == LinuX)
+# endif
+# if defined CROSSCOMPILE || defined linux
+#  ifdef CROSSCOMPILE
+	if (sys == LinuX)
+#  endif
+	  get_distrib (inFile);
+# endif
+# if defined linux
+#  if defined CROSSCOMPILE
+      if (!CrossCompiling)
+#  endif
+	  get_libc_version (inFile);
+#  if defined CROSSCOMPILE
+      else {
+	  fprintf(inFile,"#define DefaultLinuxCLibMajorVersion %d\n",
+		  glibc_major);
+	  fprintf(inFile,"#define DefaultLinuxCLibMinorVersion %d\n",
+		  glibc_minor);
+	  fprintf(inFile,"#define DefaultLinuxCLibTeenyVersion 0\n");
+      }
+#  endif
+# endif /* linux */
+# if defined CROSSCOMPILE || defined linux
+#  if defined CROSSCOMPILE
+      if (sys == LinuX)
+#  endif
+	  get_ld_version(inFile);
+# endif
+# if defined (sun) && defined(SVR4)
+      get_sun_compiler_versions (inFile);
+# endif
+# if defined CROSSCOMPILE || defined __GNUC__
+#  if defined CROSSCOMPILE
+      if (gnu_c)
+#  endif
+	{
+	  char name[PATH_MAX];
+	  if (get_gcc(name)) {
+	      get_gcc_version (inFile,name);
+#  if defined CROSSCOMPILE || !defined __UNIXOS2__
+#   if defined CROSSCOMPILE
+	      if (sys != emx)
+#   endif
+		  get_gcc_incdir(inFile,name);
+#  endif
+	  }
+	}
+# endif
+# if defined __FreeBSD__
+#  if defined CROSSCOMPILE
+      if (sys == freeBSD)
+#  endif
+	  get_binary_format(inFile);
+# endif
+    }
+#endif /* !WIN32 && !__UNIXOS2__*/
+#if defined WIN32
+# ifdef CROSSCOMPILE
+  else if (sys == win32 && !CrossCompiling)
+# endif
+    {
+      OSVERSIONINFO osvi;
+      static char* os_names[] = { "Win32s", "Windows 95", "Windows NT" };
+
+      memset(&osvi, 0, sizeof(OSVERSIONINFO));
+      osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
+      GetVersionEx (&osvi);
+
+      fprintf (inFile, "#define DefaultOSName Microsoft %s\n",
+	       os_names[osvi.dwPlatformId]);
+
+      fprintf(inFile, "#define DefaultOSMajorVersion %d\n", osvi.dwMajorVersion);
+      fprintf(inFile, "#define DefaultOSMinorVersion %d\n", osvi.dwMinorVersion);
+      fprintf(inFile, "#define DefaultOSTeenyVersion %d\n",
+	      osvi.dwBuildNumber & 0xFFFF);
+    }
+#endif /* WIN32 */
+#ifdef CROSSCOMPILE
+  else if (sys == emx)
 #endif
-#else /* WIN32 */
-#ifndef __EMX__
-   OSVERSIONINFO osvi;
-   static char* os_names[] = { "Win32s", "Windows 95", "Windows NT" };
-
-   memset(&osvi, 0, sizeof(OSVERSIONINFO));
-   osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
-   GetVersionEx (&osvi);
-
-   fprintf (inFile, "#define DefaultOSName Microsoft %s\n", 
-	    os_names[osvi.dwPlatformId]);
-
-   fprintf(inFile, "#define DefaultOSMajorVersion %d\n", osvi.dwMajorVersion);
-   fprintf(inFile, "#define DefaultOSMinorVersion %d\n", osvi.dwMinorVersion);
-   fprintf(inFile, "#define DefaultOSTeenyVersion %d\n", 
-	   osvi.dwBuildNumber & 0xFFFF);
-#else /* EMX */
-   fprintf(inFile, "#define DefaultOSMajorVersion 4\n");
-   fprintf(inFile, "#define DefaultOSMinorVersion 0\n");
-   fprintf(inFile, "#define DefaultOSTeenyVersion 0\n");
+#if defined CROSSCOMPILE || defined __UNIXOS2__
+    {
+      fprintf(inFile, "#define DefaultOSMajorVersion 4\n");
+      fprintf(inFile, "#define DefaultOSMinorVersion 0\n");
+      fprintf(inFile, "#define DefaultOSTeenyVersion 0\n");
+    }
 #endif /* EMX */
-#endif /* WIN32 */
-   return FALSE;
+#if defined(__OpenBSD__)
+  get_stackprotector(inFile);
+#endif
+  return FALSE;
 }
 
 void
-cppit(char *imakefile, char *template, char *masterc, 
+cppit(char *imakefile, char *template, char *masterc,
       FILE *outfd, char *outfname)
 {
 	FILE	*inFile;
@@ -1311,7 +1628,7 @@
 	    fprintf(inFile, IncludeFmt, ImakeTmplSym) < 0 ||
 	    optional_include(inFile, "IMAKE_ADMIN_MACROS", "adminmacros") ||
 	    optional_include(inFile, "IMAKE_LOCAL_MACROS", "localmacros") ||
-	    fflush(inFile) || 
+	    fflush(inFile) ||
 	    fclose(inFile))
 		LogFatal("Cannot write to %s.", masterc);
 	/*
@@ -1350,7 +1667,7 @@
 		LogFatal("Cannot stat %s for size.", imakefile);
 	buf = Emalloc((int)st.st_size+3);
 	count = fread(buf + 2, 1, st.st_size, inFile);
-	if (count == 0  &&  st.st_size != 0)
+	if (count == 0 && st.st_size != 0)
 		LogFatal("Cannot read %s:", imakefile);
 	fclose(inFile);
 	buf[0] = '\n';
@@ -1365,7 +1682,7 @@
 		while (*ptoken == ' ' || *ptoken == '\t')
 			ptoken++;
 		pend = ptoken;
-		while (*pend && *pend != ' ' && *pend != '\t' && *pend != '\n')
+		while (*pend && *pend != ' ' && *pend != '\t' && *pend != '\n' && *pend != '\r')
 			pend++;
 		savec = *pend;
 		*pend = '\0';
@@ -1383,7 +1700,7 @@
 		    strcmp(ptoken, "undef")) {
 		    if (outFile == NULL) {
 #ifdef HAS_MKSTEMP
-		        int fd;
+			int fd;
 #endif
 			tmpImakefile = Strdup(tmpImakefile);
 #ifndef HAS_MKSTEMP
@@ -1420,6 +1737,7 @@
 	if (outFile) {
 	    writetmpfile(outFile, punwritten, pbuf-punwritten, tmpImakefile);
 	    fclose(outFile);
+
 	    return tmpImakefile;
 	}
 
@@ -1436,10 +1754,20 @@
 		if (isempty(input)) {
 			if (blankline++)
 				continue;
-			KludgeResetRule();
+#ifdef CROSSCOMPILE
+			if (fixup_whitespace)
+#endif
+#if defined CROSSCOMPILE || defined FIXUP_CPP_WHITESPACE
+			    KludgeResetRule();
+#endif
 		} else {
 			blankline = 0;
-			KludgeOutputLine(&input);
+#ifdef CROSSCOMPILE
+			if (fixup_whitespace)
+#endif
+#if defined CROSSCOMPILE || defined FIXUP_CPP_WHITESPACE
+			    KludgeOutputLine(&input);
+#endif
 			writetmpfile(tmpfd, input, strlen(input), tmpfname);
 		}
 		writetmpfile(tmpfd, "\n", 1, tmpfname);
@@ -1479,7 +1807,7 @@
 		    pend[3] == 'e' && pend[4] == ' ')
 			pend += 5;
 		if (isdigit(*pend)) {
-		    	do {
+			do {
 			    pend++;
 			} while (isdigit(*pend));
 			if (*pend == '\n' || *pend == '\0')
@@ -1493,41 +1821,46 @@
 	    for (pend = line; *pend; pend++) {
 		if (*pend == 'X' && pend[1] == 'C' && pend[2] == 'O' &&
 		    pend[3] == 'M' && pend[4] == 'M' &&
-		    (pend == line || pend[-1] == ' ' || pend[-1] == '\t') &&
-		    (pend[5] == ' ' || pend[5] == '\t' || pend[5] == '\0'))
+		    (pend == line || pend[-1] == ' ' || pend[-1] == '\t' || pend[-1] == '\r') &&
+		    (pend[5] == ' ' || pend[5] == '\t' || pend[5] == '\r' || pend[5] == '\0'))
 		{
 		    *pend = '#';
 		    strcpy(pend+1, pend+5);
 		}
-#ifdef MAGIC_MAKE_VARS
-		if (*pend == 'X' && pend[1] == 'V' && pend[2] == 'A' &&
-		    pend[3] == 'R')
-		{
-		    char varbuf[5];
-		    int i;
-
-		    if (pend[4] == 'd' && pend[5] == 'e' && pend[6] == 'f' &&
-			pend[7] >= '0' && pend[7] <= '9')
-		    {
-			i = pend[7] - '0';
-			sprintf(varbuf, "%0.4d", xvariable);
-			strncpy(pend+4, varbuf, 4);
-			xvariables[i] = xvariable;
-			xvariable = (xvariable + 1) % 10000;
-		    }
-		    else if (pend[4] == 'u' && pend[5] == 's' &&
-			     pend[6] == 'e' && pend[7] >= '0' &&
-			     pend[7] <= '9')
+#ifdef CROSSCOMPILE
+		if (magic_make_vars)
+#endif
+		  {
+#if defined CROSSCOMPILE || defined MAGIC_MAKE_VARS
+		    if (*pend == 'X' && pend[1] == 'V' && pend[2] == 'A' &&
+			pend[3] == 'R')
 		    {
-			i = pend[7] - '0';
-			sprintf(varbuf, "%0.4d", xvariables[i]);
-			strncpy(pend+4, varbuf, 4);
+			char varbuf[5];
+			int i;
+
+			if (pend[4] == 'd' && pend[5] == 'e' && pend[6] == 'f' &&
+			    pend[7] >= '0' && pend[7] <= '9')
+			{
+			    i = pend[7] - '0';
+			    sprintf(varbuf, "%0.4d", xvariable);
+			    strncpy(pend+4, varbuf, 4);
+			    xvariables[i] = xvariable;
+			    xvariable = (xvariable + 1) % 10000;
+			}
+			else if (pend[4] == 'u' && pend[5] == 's' &&
+				 pend[6] == 'e' && pend[7] >= '0' &&
+				 pend[7] <= '9')
+			{
+			    i = pend[7] - '0';
+			    sprintf(varbuf, "%0.4d", xvariables[i]);
+			    strncpy(pend+4, varbuf, 4);
+			}
 		    }
-		}
 #endif
+		}
 	    }
 	}
-	while (--pend >= line && (*pend == ' ' || *pend == '\t')) ;
+	while (--pend >= line && (*pend == ' ' || *pend == '\t' || *pend == '\r')) ;
 	pend[1] = '\0';
 	return (*line == '\0');
 }
@@ -1544,8 +1877,8 @@
 #ifdef WIN32
 		FILE *fp = tmpfd;
 #endif
-		int	total_red;
-		struct stat	st;
+		int total_red;
+		struct stat st;
 
 		/*
 		 * Slurp it all up.
@@ -1555,7 +1888,7 @@
 			LogFatal("cannot stat %s for size", tmpMakefile);
 		pline = buf = Emalloc((int)st.st_size+1);
 		total_red = fread(buf, 1, st.st_size, tmpfd);
-		if (total_red == 0  &&  st.st_size != 0)
+		if (total_red == 0 && st.st_size != 0)
 			LogFatal("cannot read %s", tmpMakefile);
 		end = buf + total_red;
 		*end = '\0';
@@ -1587,9 +1920,14 @@
 			break;
 		}
 		else if (*p1 == '\n') { /* real EOL */
-#ifdef WIN32
+#if defined CROSSCOMPILE || defined WIN32
+# if defined CROSSCOMPILE
+		  if (sys == win32)
+# endif
+		    {
 			if (p1 > pline && p1[-1] == '\r')
 				p1[-1] = '\0';
+		    }
 #endif
 			*p1++ = '\0';
 			break;
@@ -1621,7 +1959,7 @@
 	return(p);
 }
 
-#ifdef FIXUP_CPP_WHITESPACE
+#if defined CROSSCOMPILE || defined FIXUP_CPP_WHITESPACE
 void
 KludgeOutputLine(char **pline)
 {
@@ -1632,29 +1970,38 @@
 	    case '#':	/*Comment - ignore*/
 		break;
 	    case '\t':	/*Already tabbed - ignore it*/
-	    	break;
+		break;
 	    case ' ':	/*May need a tab*/
 	    default:
-# ifdef INLINE_SYNTAX
-		if (*p == '<' && p[1] == '<') { /* inline file close */
-		    InInline--;
-		    InRule = TRUE;
-		    break;
+#ifdef CROSSCOMPILE
+		if (inline_syntax)
+#endif
+#if defined CROSSCOMPILE || defined INLINE_SYNTAX
+		{
+		    if (*p == '<' && p[1] == '<') { /* inline file close */
+			InInline--;
+			InRule = TRUE;
+			break;
+		    }
 		}
-# endif
+#endif
 		/*
-		 * The following cases should not be treated as beginning of 
+		 * The following cases should not be treated as beginning of
 		 * rules:
-		 * variable := name	(GNU make)
-		 * variable = .*:.*	(':' should be allowed as value)
-		 *	sed 's:/a:/b:'	(: used in quoted values)
+		 * variable := name (GNU make)
+		 * variable = .*:.* (':' should be allowed as value)
+		 * sed 's:/a:/b:'   (: used in quoted values)
 		 */
 		for (; *p; p++) {
 		    if (quotechar) {
 			if (quotechar == '\\' ||
 			    (*p == quotechar &&
-# ifdef WIN32
-			     quotechar != ')' &&
+# if defined CROSSCOMPILE || defined WIN32
+			     (
+#  if defined CROSSCOMPILE
+			      (sys == win32) &&
+#  endif
+			      quotechar != ')') &&
 # endif
 			     p[-1] != '\\'))
 			    quotechar = '\0';
@@ -1676,19 +2023,26 @@
 			quotechar = ']';
 			break;
 		    case '=':
-# ifdef REMOVE_CPP_LEADSPACE
-			if (!InRule && **pline == ' ') {
-			    while (**pline == ' ')
-				(*pline)++;
+#ifdef CROSSCOMPILE
+			if (remove_cpp_leadspace)
+#endif
+#if defined CROSSCOMPILE || defined REMOVE_CPP_LEADSPACE
+			{
+			    if (!InRule && **pline == ' ') {
+				while (**pline == ' ')
+				    (*pline)++;
+			    }
 			}
-# endif
+#endif
 			goto breakfor;
-# ifdef INLINE_SYNTAX
+#if defined CROSSCOMPILE || defined INLINE_SYNTAX
 		    case '<':
-			if (p[1] == '<') /* inline file start */
-			    InInline++;
+			if (inline_syntax) {
+			    if (p[1] == '<') /* inline file start */
+				InInline++;
+			}
 			break;
-# endif
+#endif
 		    case ':':
 			if (p[1] == '=')
 			    goto breakfor;
@@ -1710,8 +2064,7 @@
 {
 	InRule = FALSE;
 }
-#endif /* FIXUP_CPP_WHITESPACE */
-
+#endif
 char *
 Strdup(char *cp)
 {
@@ -1720,3 +2073,38 @@
 	strcpy(new, cp);
 	return new;
 }
+
+#ifdef CROSSCOMPILE
+char*
+CrossCompileCPP(void)
+{
+    char *cpp, *c;
+    int len ;
+    if (crosscompile_use_cc_e)
+	AddCppArg("-E");
+
+    cpp = strrchr(crosscompile_cpp,'/');
+    if (!cpp)
+	cpp = crosscompile_cpp;
+    else
+	cpp++;
+
+    len = strlen(cpp) + strlen(CrossCompileDir) + 2;
+    c = Emalloc(len);
+
+    (void)snprintf(c, len,"%s/%s",CrossCompileDir,cpp);
+
+    return c;
+}
+
+#endif
+
+#ifdef CROSSCOMPILE
+static void
+get_cross_compile_dir(FILE *inFile)
+{
+	fprintf(inFile, "#define CrossCompileDir %s\n",
+		CrossCompileDir);
+	fprintf(inFile, "#define CrossCompiling YES\n");
+}
+#endif
Index: xc/config/imake/imake.man
diff -u xc/config/imake/imake.man:1.8 xc/config/imake/imake.man:1.9
--- xc/config/imake/imake.man:1.8	Fri Dec 14 14:53:19 2001
+++ xc/config/imake/imake.man	Wed Nov 20 16:48:46 2002
@@ -23,7 +23,7 @@
 .\" other dealings in this Software without prior written authorization
 .\" from The Open Group.
 .\"
-.\" $XFree86: xc/config/imake/imake.man,v 1.8 2001/12/14 19:53:19 dawes Exp $
+.\" $XFree86: xc/config/imake/imake.man,v 1.9 2002/11/20 21:48:46 herrb Exp $
 .\"
 .TH IMAKE 1 __xorgversion__
 .SH NAME
@@ -224,7 +224,7 @@
 .br
 /tmp/IIf.XXXXXX	temporary Imakefile if specified Imakefile uses # comments
 .br
-/lib/cpp	default C preprocessor
+__cpp__	default C preprocessor
 .DT
 .SH "SEE ALSO"
 make(1), xmkmf(1)
@@ -246,7 +246,7 @@
 E.g., ``/usr/local/cpp''.
 By default,
 .I imake
-will use /lib/cpp.
+will use cc -E or __cpp__, depending on the OS specific configuration.
 .TP 5
 .B IMAKEMAKE
 If defined, this should be a valid path to a make program,
Index: xc/config/imake/imakemdep.h
diff -u xc/config/imake/imakemdep.h:3.56 xc/config/imake/imakemdep.h:3.68
--- xc/config/imake/imakemdep.h:3.56	Fri Dec 14 14:53:19 2001
+++ xc/config/imake/imakemdep.h	Tue Dec 24 12:42:58 2002
@@ -24,7 +24,7 @@
 in this Software without prior written authorization from The Open Group.
 
 */
-/* $XFree86: xc/config/imake/imakemdep.h,v 3.56 2001/12/14 19:53:19 dawes Exp $ */
+/* $XFree86: xc/config/imake/imakemdep.h,v 3.68 2002/12/24 17:42:58 tsi Exp $ */
 
 
 /* 
@@ -86,7 +86,6 @@
 #endif
 #endif
 #endif
-
 #ifdef _CRAY
 #define imake_ccflags "-DSYSV -DUSG"
 #endif
@@ -175,8 +174,8 @@
 #define imake_ccflags "-DNOSTDHDRS"
 #endif
 
-/* this is for OS/2 under EMX. This won't work with DOS */
-#if defined(__EMX__)
+/* this is for OS/2 under UNIXOS2. This won't work with DOS */
+#if defined(__UNIXOS2__)
 #define imake_ccflags "-DBSD43"
 #endif
 
@@ -204,14 +203,14 @@
 
 /*
  * Step 3:  FIXUP_CPP_WHITESPACE
- *     If your cpp collapses tabs macro expansions into a single space and
+ *     If your cpp collapses tabs in macro expansions into a single space and
  *     replaces escaped newlines with a space, define this symbol.  This will
  *     cause imake to attempt to patch up the generated Makefile by looking
  *     for lines that have colons in them (this is why the rules file escapes
  *     all colons).  One way to tell if you need this is to see whether or not
  *     your Makefiles have no tabs in them and lots of @@ strings.
  */
-#if defined(sun) || defined(SYSV) || defined(SVR4) || defined(hcx) || defined(WIN32) || defined(sco) || (defined(AMOEBA) && defined(CROSS_COMPILE)) || defined(__QNX__) || defined(__sgi)
+#if defined(sun) || defined(SYSV) || defined(SVR4) || defined(hcx) || defined(WIN32) || defined(sco) || (defined(AMOEBA) && defined(CROSS_COMPILE)) || defined(__QNX__) || defined(__sgi) || defined(__UNIXOS2__)
 #define FIXUP_CPP_WHITESPACE
 #endif
 #ifdef WIN32
@@ -238,8 +237,11 @@
  *     If use cc -E but want a different compiler, define DEFAULT_CC.
  *     If the cpp you need is not in /lib/cpp, define DEFAULT_CPP.
  */
+#if !defined (CROSSCOMPILE) || defined (CROSSCOMPILE_CPP) 
+
 #if defined(__APPLE__)
 #define DEFAULT_CPP "/usr/bin/cpp"
+#define DEFAULT_CC "cc"
 #endif
 #if defined(Lynx) || defined(__Lynx__)
 #define DEFAULT_CC "gcc"
@@ -291,7 +293,7 @@
 #ifdef __minix_vmd
 #define DEFAULT_CPP "/usr/lib/cpp"
 #endif
-#if defined(__EMX__)
+#if defined(__UNIXOS2__)
 /* expects cpp in PATH */
 #define DEFAULT_CPP "cpp"
 #endif
@@ -306,6 +308,14 @@
 #define DEFAULT_CPP "/usr/X11R6/bin/cpp"
 #endif
 #endif
+#if defined(__GNUC__) && !defined(USE_CC_E)
+#define USE_CC_E
+#ifndef DEFAULT_CC
+#define DEFAULT_CC "gcc"
+#endif
+#endif
+
+#endif /* !defined (CROSSCOMPILE) || defined (CROSSCOMPILE_CPP) */
 /*
  * Step 5:  cpp_argv
  *     The following table contains the flags that should be passed
@@ -313,7 +323,7 @@
  *     doesn't predefine any unique symbols, choose one and add it to the
  *     end of this table.  Then, do the following:
  * 
- *         a.  Use this symbol in Imake.tmpl when setting MacroFile.
+ *         a.  Use this symbol in Imake.cf when setting MacroFile.
  *         b.  Put this symbol in the definition of BootstrapCFlags in your
  *             <platform>.cf file.
  *         c.  When doing a make World, always add "BOOTSTRAPCFLAGS=-Dsymbol" 
@@ -324,6 +334,7 @@
  */
 
 #define	ARGUMENTS 50	/* number of arguments in various arrays */
+#if !defined (CROSSCOMPILE) || defined (CROSSCOMPILE_CPP) 
 char *cpp_argv[ARGUMENTS] = {
 	"cc",		/* replaced by the actual program to exec */
 	"-I.",		/* add current directory to include path */
@@ -332,9 +343,14 @@
 	"-Uunix",	/* remove unix symbol so that filename unix.c okay */
 #endif
 #endif
-#if defined(__386BSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(MACH) || defined(linux) || defined(__GNU__) || defined(__bsdi__)
+#if defined(__386BSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \
+    defined(__FreeBSD__) || defined(MACH) || defined(linux) || \
+    defined(__GNU__) || defined(__bsdi__) || defined(__GNUC__)
 # ifdef __i386__
 	"-D__i386__",
+#  if defined(__GNUC__) && (__GNUC__ >= 3)
+	"-m32",
+#  endif
 # endif
 # ifdef __i486__
 	"-D__i486__",
@@ -351,6 +367,9 @@
 # ifdef __ia64__
 	"-D__ia64__",
 # endif
+# ifdef __x86_64__
+	"-D__x86_64__",
+# endif
 # ifdef __s390__
 	"-D__s390__",
 # endif
@@ -641,7 +660,7 @@
 	"-Dminix",
 #endif
 
-#if defined(__EMX__)
+#if defined(__UNIXOS2__)
 	"-traditional",
 	"-Demxos2",
 #endif
@@ -689,14 +708,14 @@
         "-D__i386__",
 # endif
 #endif
-
 };
+#endif /* CROSSCOMPILE */
 
 
 /*
  * Step 6: DEFAULT_OS_MAJOR_REV, DEFAULT_OS_MINOR_REV, DEFAULT_OS_TEENY_REV,
  *	and DEFAULT_OS_NAME.
- *	If your systems provides a way to generate the default major,
+ *	If your system provides a way to generate the default major,
  *	minor, teeny, or system names at runtime add commands below.
  *	The syntax of the _REV strings is 'f fmt' where 'f' is an argument
  *	you would give to uname, and "fmt" is a scanf() format string.
@@ -708,74 +727,91 @@
  *	DEFAULT_OS_TEENY_REV_FROB, and DEFAULT_OS_NAME_FROB can be used to
  *	modify the results of the use of the various strings.
  */
-#if defined(aix)
+#if !defined CROSSCOMPILE || defined CROSSCOMPILE_CPP
+# if defined(aix)
 /* uname -v returns "x" (e.g. "4"), and uname -r returns "y" (e.g. "1") */
-# define DEFAULT_OS_MAJOR_REV	"v %[0-9]"
-# define DEFAULT_OS_MINOR_REV	"r %[0-9]"
+#  define DEFAULT_OS_MAJOR_REV	"v %[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %[0-9]"
 /* No information available to generate default OSTeenyVersion value. */
-# define DEFAULT_OS_NAME	"srvm %[^\n]"
-#elif defined(sun) || defined(sgi) || defined(ultrix) || defined(__uxp__) || defined(sony)
+#  define DEFAULT_OS_NAME	"srvm %[^\n]"
+# elif defined(sun) || defined(sgi) || defined(ultrix) || defined(__uxp__) || defined(sony)
 /* uname -r returns "x.y[.z]", e.g. "5.4" or "4.1.3" */
-# define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
-# define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV	"r %*d.%*d.%[0-9]"
-# define DEFAULT_OS_NAME	"srvm %[^\n]"
-#elif defined(hpux)
+#  define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV	"r %*d.%*d.%[0-9]"
+#  define DEFAULT_OS_NAME	"srvm %[^\n]"
+# elif defined(hpux)
 /* uname -r returns "W.x.yz", e.g. "B.10.01" */
-# define DEFAULT_OS_MAJOR_REV	"r %*[^.].%[0-9]"
-# define DEFAULT_OS_MINOR_REV	"r %*[^.].%*d.%1s"
-# define DEFAULT_OS_TEENY_REV	"r %*[^.].%*d.%*c%[0-9]"
-# define DEFAULT_OS_NAME	"srvm %[^\n]"
-#elif defined(USL) || defined(__USLC__)
+#  define DEFAULT_OS_MAJOR_REV	"r %*[^.].%[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %*[^.].%*d.%1s"
+#  define DEFAULT_OS_TEENY_REV	"r %*[^.].%*d.%*c%[0-9]"
+#  define DEFAULT_OS_NAME	"srvm %[^\n]"
+# elif defined(USL) || defined(__USLC__)
 /* uname -v returns "x.yz" or "x.y.z", e.g. "2.02" or "2.1.2". */
-# define DEFAULT_OS_MAJOR_REV	"v %[0-9]"
-# define DEFAULT_OS_MINOR_REV	"v %*d.%1s"
-# define DEFAULT_OS_TEENY_REV	"v %*d.%*c%[.0-9]"
-# define DEFAULT_OS_NAME	"srvm %[^\n]"
-#elif defined(__APPLE__)
+#  define DEFAULT_OS_MAJOR_REV	"v %[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"v %*d.%1s"
+#  define DEFAULT_OS_TEENY_REV	"v %*d.%*c%[.0-9]"
+#  define DEFAULT_OS_NAME	"srvm %[^\n]"
+# elif defined(__APPLE__)
 /* uname -v returns "x.yz" or "x.y.z", e.g. "2.02" or "2.1.2". */
-# define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
-# define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV	"r %*d.%*d.%[0-9]" /* this will just get 0 */
-# define DEFAULT_OS_NAME	"s %[^\n]"
-#elif defined(__osf__)
+#  define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV	"r %*d.%*d.%[0-9]" /* this will just get 0 */
+#  define DEFAULT_OS_NAME	"s %[^\n]"
+# elif defined(__osf__)
 /* uname -r returns "Wx.y", e.g. "V3.2" or "T4.0" */
-# define DEFAULT_OS_MAJOR_REV	"r %*[^0-9]%[0-9]"
-# define DEFAULT_OS_MINOR_REV	"r %*[^.].%[0-9]"
-# define DEFAULT_OS_NAME	"srvm %[^\n]"
-#elif defined(__uxp__)
+#  define DEFAULT_OS_MAJOR_REV	"r %*[^0-9]%[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %*[^.].%[0-9]"
+#  define DEFAULT_OS_NAME	"srvm %[^\n]"
+# elif defined(__uxp__)
 /* NOTE: "x.y[.z]" above handles UXP/DF.  This is a sample alternative. */
 /* uname -v returns "VxLy Yzzzzz ....", e.g. "V20L10 Y95021 Increment 5 ..." */
-# define DEFAULT_OS_MAJOR_REV	"v V%[0-9]"
-# define DEFAULT_OS_MINOR_REV	"v V%*dL%[0-9]"
-# define DEFAULT_OS_NAME	"srvm %[^\n]"
-#elif defined(linux) || defined(__bsdi__)
-# define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
-# define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV	"r %*d.%*d.%[0-9]"
-# define DEFAULT_OS_NAME	"srm %[^\n]"
-#elif defined(__GNU__)
-# define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
-# define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
-# define DEFAULT_OS_NAME	"srm %[^\n]"
-#elif defined(ISC)
+#  define DEFAULT_OS_MAJOR_REV	"v V%[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"v V%*dL%[0-9]"
+#  define DEFAULT_OS_NAME	"srvm %[^\n]"
+# elif defined(linux) || defined(__bsdi__)
+#  define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV	"r %*d.%*d.%[0-9]"
+#  define DEFAULT_OS_NAME	"srm %[^\n]"
+#  if defined(linux) && defined  (CROSSCOMPILE_CPP)
+#   define CROSS_UTS_SYSNAME "Linux"
+#   include <linux/version.h>
+#   define CROSS_UTS_RELEASE UTS_RELEASE
+# endif
+# elif defined(__CYGWIN__)
+#  define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV	"r %*d.%*d.%[0-9]"
+#  define DEFAULT_OS_NAME	"srm %[^\n]"
+#  if defined(__CYGWIN__) && defined  (CROSSCOMPILE_CPP)
+#   define CROSS_UTS_SYSNAME "Cygwin"
+#   include <cygwin/version.h>
+#   define CROSS_UTS_RELEASE "1.3.12"
+#  endif
+# elif defined(__GNU__)
+#  define DEFAULT_OS_MAJOR_REV	"r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"r %*d.%[0-9]"
+#  define DEFAULT_OS_NAME	"srm %[^\n]"
+# elif defined(ISC)
 /* ISC all Versions ? */
 /* uname -r returns "x.y", e.g. "3.2" ,uname -v returns "x" e.g. "2" */
-# define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
-# define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV   "v %[0-9]" 
+#  define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV   "v %[0-9]" 
 /* # define DEFAULT_OS_NAME        "srm %[^\n]" */ /* Not useful on ISC */
-#elif defined(__FreeBSD__) || defined(__OpenBSD__)
+# elif defined(__FreeBSD__) || defined(__OpenBSD__)
 /* BSD/OS too? */
 /* uname -r returns "x.y[.z]-mumble", e.g. "2.1.5-RELEASE" or "2.2-0801SNAP" */
-# define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
-# define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV   "r %*d.%*d.%[0-9]" 
-# define DEFAULT_OS_NAME        "srm %[^\n]"
-# if defined(__FreeBSD__)
+#  define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV   "r %*d.%*d.%[0-9]" 
+#  define DEFAULT_OS_NAME        "srm %[^\n]"
+#  if defined(__FreeBSD__)
 /* Use an alternate way to find the teeny version for -STABLE, -SNAP versions */
-#  define DEFAULT_OS_TEENY_REV_FROB(buf, size)				\
-    do {								\
+#   ifndef CROSSCOMPILE_CPP
+#    define DEFAULT_OS_TEENY_REV_FROB(buf, size)			\
+      do {								\
 	if (*buf == 0) {						\
 		int __mib[2];						\
 		size_t __len;						\
@@ -799,12 +835,13 @@
 		}							\
 		buf[1] = 0;						\
 	}								\
-    } while (0)
-# else
+     } while (0)
+#   endif
+#  else
    /* OpenBSD - Add DEFAULT_MACHINE_ARCHITECTURE */
-#  define DEFAULT_MACHINE_ARCHITECTURE "m %[^\n]"
-# endif
-#elif defined(__NetBSD__)
+#   define DEFAULT_MACHINE_ARCHITECTURE "m %[^\n]"
+#  endif
+# elif defined(__NetBSD__)
 /*
  * uname -r returns "x.y([ABCD...]|_mumble)", e.g.:
  *	1.2	1.2_BETA	1.2A	1.2B
@@ -817,38 +854,115 @@
  * 'standard' NetBSD name for the version, e.g. "NetBSD/i386 1.2B" for
  * NetBSD 1.2B on an i386.
  */
-# define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
-# define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV   "r %*d.%*d%[A-Z]" 
-# define DEFAULT_OS_TEENY_REV_FROB(buf, size)				\
+#  define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV   "r %*d.%*d%[A-Z]" 
+#  define DEFAULT_OS_TEENY_REV_FROB(buf, size)				\
     do {								\
-	if (*(buf) >= 'A' && *(buf) <= 'Z') /* sanity check */		\
-		snprintf((buf), (size), "%d", *(buf) - 'A' + 1);	\
-	else								\
-	    *(buf) = '\0';						\
+	int	teeny = 0;						\
+	char	*ptr = (buf);						\
+									\
+	while (*ptr >= 'A' && *ptr <= 'Z') /* sanity check */		\
+	    teeny = teeny * 26 + (int)(*ptr++ - 'A');			\
+									\
+	snprintf((buf), (size), "%d", teeny + 1);			\
     } while (0)
-# define DEFAULT_OS_NAME        "smr %[^\n]"
-# define DEFAULT_OS_NAME_FROB(buf, size)				\
+#  define DEFAULT_OS_NAME        "smr %[^\n]"
+#  define DEFAULT_OS_NAME_FROB(buf, size)				\
     do {								\
 	char *__sp;							\
 	if ((__sp = strchr((buf), ' ')) != NULL)			\
 		*__sp = '/';						\
     } while (0)
-#elif defined(__Lynx__) || defined(Lynx)
+# elif defined(__Lynx__) || defined(Lynx)
 /* Lynx 2.4.0 /bin/cc doesn't like #elif */
-# define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
-# define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV   "r %*d.%*d.%[0-9]" 
-# define DEFAULT_OS_NAME        "srm %[^\n]"
-#elif defined(_SEQUENT_)
+#  define DEFAULT_OS_MAJOR_REV   "r %[0-9]"
+#  define DEFAULT_OS_MINOR_REV   "r %*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV   "r %*d.%*d.%[0-9]" 
+#  define DEFAULT_OS_NAME        "srm %[^\n]"
+# elif defined(_SEQUENT_)
 /* uname -v returns 'Vx.y.z', e.g. 'V4.4.2' */
-# define DEFAULT_OS_MAJOR_REV	"v V%[0-9]"
-# define DEFAULT_OS_MINOR_REV	"v V%*d.%[0-9]"
-# define DEFAULT_OS_TEENY_REV	"v V%*d.%*d.%[0-9]"
-# define DEFAULT_OS_NAME	"s %[^\n]"
-#endif
+#  define DEFAULT_OS_MAJOR_REV	"v V%[0-9]"
+#  define DEFAULT_OS_MINOR_REV	"v V%*d.%[0-9]"
+#  define DEFAULT_OS_TEENY_REV	"v V%*d.%*d.%[0-9]"
+#  define DEFAULT_OS_NAME	"s %[^\n]"
+# endif
+#endif /* !defined CROSSCOMPILE || defined CROSSCOMPILE_CPP */
+
+# if defined (CROSSCOMPILE_CPP) 
+#  ifndef CROSS_UTS_SYSNAME
+char *cross_uts_sysname = "";
+#  else
+char *cross_uts_sysname = CROSS_UTS_SYSNAME;
+#  endif
+#  ifndef CROSS_UTS_RELEASE
+char* cross_uts_release = "";
+#  else
+char* cross_uts_release = CROSS_UTS_RELEASE;
+#  endif
+#  ifndef CROSS_UTS_MACHINE
+char *cross_uts_machine = "";
+#  else
+char *cross_uts_machine = CROSS_UTS_MACHINE;
+#  endif
+#  ifndef CROSS_UTS_VERSION
+char * cross_uts_version = "";
+#  else
+char * cross_uts_version = CROSS_UTS_VERSION;
+#  endif
+#  ifdef DEFAULT_OS_NAME
+char *defaultOsName = DEFAULT_OS_NAME;
+#  else 
+char *defaultOsName = NULL;
+# endif
+#  ifdef DEFAULT_OS_MAJOR_REV
+char *defaultOsMajorRev = DEFAULT_OS_MAJOR_REV;
+#  else 
+char *defaultOsMajorRev = NULL;
+# endif
+#  ifdef DEFAULT_OS_MINOR_REV
+char *defaultOsMinorRev = DEFAULT_OS_MINOR_REV;
+#  else 
+char *defaultOsMinorRev = NULL;
+#  endif
+#  ifdef DEFAULT_OS_TEENY_REV
+char *defaultOsTeenyRev = DEFAULT_OS_TEENY_REV;
+#  else 
+char *defaultOsTeenyRev = NULL;
+#  endif
+#  ifdef DEFAULT_MACHINE_ARCHITECTURE
+char *defaultMachineArchitecture = DEFAULT_MACHINE_ARCHITECTURE;
+#  else 
+char *defaultMachineArchitecture = NULL;
+#  endif
+# ifdef DEFAULT_OS_NAME_FROB
+void defaultOsNameFrob(char *buf, int size)
+{DEFAULT_OS_NAME_FROB(buf,size)}
+# else
+void (*defaultOsNameFrob)(char *buf, int size) = NULL;
+# endif
+# ifdef DEFAULT_OS_MAJOR_REV_FROB
+void defaultOsMajorRevFrob(char *buf, int size)
+{DEFAULT_OS_MAJOR_REV_FROB(buf,size)}
+# else
+void (*defaultOsMajorRevFrob)(char *buf, int size) = NULL;
+# endif
+# ifdef DEFAULT_OS_MINOR_REV_FROB
+void defaultOsMinorRevFrob(char *buf, int size)
+{DEFAULT_OS_MINOR_REV_FROB(buf,size)}
+# else
+void (*defaultOsMinorRevFrob)(char *buf, int size) = NULL;
+# endif
+# ifdef DEFAULT_OS_TEENY_REV_FROB
+void defaultOsTeenyRevFrob(char *buf, int size)
+{DEFAULT_OS_TEENY_REV_FROB(buf,size)}
+# else
+void (*defaultOsTeenyRevFrob)(char *buf, int size) = NULL;
+# endif
+# endif /* CROSSCOMPILE_CPP */
 
 #else /* else MAKEDEPEND */
+#if !defined (CROSSCOMPILE) || defined (CROSSCOMPILE_CPP) 
 /*
  * Step 7:  predefs
  *     If your compiler and/or preprocessor define any specific symbols, add
@@ -943,15 +1057,23 @@
 #ifdef __GNUC__
 # if __GNUC__ == 1
 	{"__GNUC__", "1"},
-# else
+# elif __GNUC__ == 2
 	{"__GNUC__", "2"},
+# elif __GNUC__ == 3
+	{"__GNUC__", "3"},
 # endif
 #endif
 #ifdef __STRICT_ANSI__
 	{"__STRICT_ANSI__", "1"},
 #endif
-#if __STDC__
+#ifdef __STDC__
+# if __STDC__ == 0
+	{"__STDC__", "0"},
+# elif __STDC__ == 1
 	{"__STDC__", "1"},
+# elif __STDC__ == 2
+	{"__STDC__", "2"},
+# endif
 #endif
 #ifdef __HIGHC__
 	{"__HIGHC__", "1"},
@@ -1095,8 +1217,8 @@
 #ifdef __ELF__
 	{"__ELF__", "1"},
 #endif
-#ifdef __EMX__
-	{"__EMX__", "1"},
+#ifdef __UNIXOS2__
+	{"__UNIXOS2__", "1"},
 #endif
 #if defined(__QNX__)
         {"__QNX__", "1"},
@@ -1116,6 +1238,12 @@
 # ifdef __ia64__
 	{"__ia64__", "1"},
 # endif
+# ifdef x86_64
+	{"x86_64", "1"},
+# endif
+# ifdef __x86_64__
+	{"__x86_64__", "1"},
+# endif
 # ifdef __i386__
 	{"__i386__", "1"},
 # endif
@@ -1146,6 +1274,12 @@
 # ifdef k6
 	{"k6", "1"},
 # endif
+# ifdef sparc
+	{"sparc", "1"},
+# endif
+# ifdef __sparc__
+	{"__sparc__", "1"},
+# endif
 # ifdef __s390__
 	{"__s390__", "1"},
 # endif
@@ -1178,6 +1312,87 @@
 	/* add any additional symbols before this line */
 	{NULL, NULL}
 };
-
+#endif /* CROSSCOMPILE */
 #endif /* MAKEDEPEND */
+
+# ifndef MAKEDEPEND
+#  if  defined (CROSSCOMPILE_CPP) 
+#   ifdef USE_CC_E
+boolean crosscompile_use_cc_e = TRUE;
+#    ifdef DEFAULT_CC
+char* crosscompile_cpp = DEFAULT_CC;
+#    else
+char* crosscompile_cpp = "cc";
+#    endif
+#   else
+boolean crosscompile_use_cc_e = FALSE;
+#    ifdef DEFAULT_CPP
+char* crosscompile_cpp = DEFAULT_CPP;
+#    else
+char* crosscompile_cpp = "cpp";
+#    endif
+#   endif
+#   ifdef FIXUP_CPP_WHITESPACE
+boolean fixup_whitespace = TRUE;
+#   else
+boolean fixup_whitespace = FALSE;
+#   endif
+#   ifdef REMOVE_CPP_LEADSPACE
+boolean remove_cpp_leadspace = TRUE;
+#   else
+boolean remove_cpp_leadspace = FALSE;
+#   endif
+#   ifdef INLINE_SYNTAX
+boolean inline_syntax = TRUE;
+#   else
+boolean inline_syntax = FALSE;
+#   endif
+#   ifdef MAGIC_MAKE_VARS
+boolean magic_make_vars = TRUE;
+#   else
+boolean magic_make_vars = FALSE;
+#   endif
+
+typedef enum {
+  unknown,
+  freeBSD,
+  netBSD,
+  LinuX,
+  emx,
+  win32
+} System;
+
+#   ifdef linux
+System sys = LinuX;
+#   elif defined __FreeBSD__
+System sys = freebsd;
+#   elif defined __NetBSD__
+System sys = netBSD;
+#   elif defined __EMX__
+System sys = emx;
+#   elif defined WIN32
+System sys = win32;
+#   else
+System sys = unknown;
+#   endif
+
+#   if defined __GNUC__
+int gnu_c = __GNUC__;
+int gnu_c_minor = __GNUC_MINOR__;
+#   else 
+int gnu_c = 0;
+int gnu_c_minor = -1;
+#   endif
+#   if defined linux
+#    include <features.h>
+int glibc_major = __GLIBC__ + 4;
+int glibc_minor = __GLIBC_MINOR__;
+#   else
+int glibc_major = 0;
+int glibc_minor = -1;
+#   endif
+#  endif /* !CROSSCOMPILE || CROSSCOMPILE_CPP */
+
+# endif /* MAKEDEPEND */
+
 #endif /* CCIMAKE */
Index: xc/config/makedepend/Imakefile
diff -u xc/config/makedepend/Imakefile:3.11 xc/config/makedepend/Imakefile:3.12
--- xc/config/makedepend/Imakefile:3.11	Tue Oct  9 17:40:21 2001
+++ xc/config/makedepend/Imakefile	Fri May 31 12:31:20 2002
@@ -3,7 +3,7 @@
 XCOMM
 XCOMM
 XCOMM
-XCOMM $XFree86: xc/config/makedepend/Imakefile,v 3.11 2001/10/09 21:40:21 alanh Exp $
+XCOMM $XFree86: xc/config/makedepend/Imakefile,v 3.12 2002/05/31 16:31:20 dawes Exp $
 
     SRCS = include.c main.c parse.c pr.c cppsetup.c ifparser.c 
     OBJS = include.o main.o parse.o pr.o cppsetup.o ifparser.o 
@@ -88,10 +88,5 @@
 SpecialCObjectRule(main,$(ICONFIGFILES),$(MAIN_DEFINES))
 
 InstallManPageLong(mkdepend,$(MANDIR),makedepend)
-
-#ifdef OS2Architecture
-all::
-	$(CP) ProgramTargetName(makedepend) /
-#endif
 
 InstallDriverSDKNamedProg(makedepend,makedepend,$(DRIVERSDKDIR)/config/makedepend)
Index: xc/config/makedepend/def.h
diff -u xc/config/makedepend/def.h:3.12 xc/config/makedepend/def.h:3.14
--- xc/config/makedepend/def.h:3.12	Mon Dec 17 15:52:22 2001
+++ xc/config/makedepend/def.h	Fri Jan 17 12:09:49 2003
@@ -24,7 +24,7 @@
 in this Software without prior written authorization from The Open Group.
 
 */
-/* $XFree86: xc/config/makedepend/def.h,v 3.12 2001/12/17 20:52:22 dawes Exp $ */
+/* $XFree86: xc/config/makedepend/def.h,v 3.14 2003/01/17 17:09:49 tsi Exp $ */
 
 #include "Xos.h"
 #include "Xfuncproto.h"
@@ -45,6 +45,7 @@
 
 #define MAXDEFINES	512
 #define MAXFILES	1024
+#define MAXINCFILES	128	/* "-include" files */
 #define MAXDIRS		64
 #define SYMTABINC	10	/* must be > 1 for define() to work right */
 #define	TRUE		1
@@ -120,11 +121,15 @@
 };
 
 struct filepointer {
+	char	*f_name;
 	char	*f_p;
 	char	*f_base;
 	char	*f_end;
 	long	f_len;
 	long	f_line;
+	long	cmdinc_count;
+	char	**cmdinc_list;
+	long	cmdinc_line;
 };
 
 #include <stdlib.h>
Index: xc/config/makedepend/ifparser.c
diff -u xc/config/makedepend/ifparser.c:3.9 xc/config/makedepend/ifparser.c:3.11
--- xc/config/makedepend/ifparser.c:3.9	Sun Apr 29 19:25:02 2001
+++ xc/config/makedepend/ifparser.c	Sun Sep 22 21:48:08 2002
@@ -36,6 +36,7 @@
  *     VALUE		:=	'('  EXPRESSION  ')'
  * 			 |	'!'  VALUE
  * 			 |	'-'  VALUE
+ * 			 |	'+'  VALUE
  *			 |	'~'  VALUE
  * 			 |	'defined'  '('  variable  ')'
  * 			 |	'defined'  variable
@@ -58,7 +59,7 @@
  * 
  *     ParseIfExpression		parse a string for #if
  */
-/* $XFree86: xc/config/makedepend/ifparser.c,v 3.9 2001/04/29 23:25:02 tsi Exp $ */
+/* $XFree86: xc/config/makedepend/ifparser.c,v 3.11 2002/09/23 01:48:08 tsi Exp $ */
 
 #include "ifparser.h"
 #include <ctype.h>
@@ -170,7 +171,7 @@
 static const char *
 parse_value (IfParser *g, const char *cp, long *valp)
 {
-    const char *var;
+    const char *var, *varend;
 
     *valp = 0;
 
@@ -197,6 +198,10 @@
 	*valp = -(*valp);
 	return cp;
 
+      case '+':
+	DO (cp = parse_value (g, cp + 1, valp));
+	return cp;
+
       case '~':
 	DO (cp = parse_value (g, cp + 1, valp));
 	*valp = ~(*valp);
@@ -250,7 +255,24 @@
 	return CALLFUNC(g, handle_error) (g, cp, "variable or number");
     else {
 	DO (cp = parse_variable (g, cp, &var));
-	*valp = (*(g->funcs.eval_variable)) (g, var, cp - var);
+	varend = cp;
+	SKIPSPACE(cp);
+	if (*cp != '(') {
+	    *valp = (*(g->funcs.eval_variable)) (g, var, varend - var);
+	} else {
+	    do {
+		long dummy;
+		DO (cp = ParseIfExpression (g, cp + 1, &dummy));
+		SKIPSPACE(cp);
+		if (*cp == ')')
+		    break;
+		if (*cp != ',')
+		    return CALLFUNC(g, handle_error) (g, cp, ",");
+	    } while (1);
+
+	    *valp = 1;	/* XXX */
+	    cp++;
+	}
     }
     
     return cp;
Index: xc/config/makedepend/main.c
diff -u xc/config/makedepend/main.c:3.27 xc/config/makedepend/main.c:3.31
--- xc/config/makedepend/main.c:3.27	Thu Dec 20 11:14:06 2001
+++ xc/config/makedepend/main.c	Fri Jan 17 12:09:49 2003
@@ -24,7 +24,7 @@
 in this Software without prior written authorization from The Open Group.
 
 */
-/* $XFree86: xc/config/makedepend/main.c,v 3.27 2001/12/20 16:14:06 tsi Exp $ */
+/* $XFree86: xc/config/makedepend/main.c,v 3.31 2003/01/17 17:09:49 tsi Exp $ */
 
 #include "def.h"
 #ifdef hpux
@@ -55,6 +55,16 @@
 int	_debugmask;
 #endif
 
+/* #define DEBUG_DUMP */
+#ifdef DEBUG_DUMP
+#define DBG_PRINT(args...)   fprintf(args)
+#else
+#define DBG_PRINT(args...)   /* empty */
+#endif
+
+#define DASH_INC_PRE    "#include \""
+#define DASH_INC_POST   "\""
+
 char *ProgramName;
 
 char	*directives[] = {
@@ -87,20 +97,24 @@
 		*inclistnext = inclist,
 		maininclist;
 
-char	*filelist[ MAXFILES ];
-char	*includedirs[ MAXDIRS + 1 ],
-	**includedirsnext = includedirs;
-char	*notdotdot[ MAXDIRS ];
-char	*objprefix = "";
-char	*objsuffix = OBJSUFFIX;
-char	*startat = "# DO NOT DELETE";
-int	width = 78;
-boolean	append = FALSE;
-boolean	printed = FALSE;
-boolean	verbose = FALSE;
-boolean	show_where_not = FALSE;
-boolean warn_multiple = FALSE;	/* Warn on multiple includes of same file */
+static char	*filelist[ MAXFILES ];
+char		*includedirs[ MAXDIRS + 1 ],
+		**includedirsnext = includedirs;
+char		*notdotdot[ MAXDIRS ];
+static int	cmdinc_count = 0;
+static char	*cmdinc_list[ 2 * MAXINCFILES ];
+char		*objprefix = "";
+char		*objsuffix = OBJSUFFIX;
+static char	*startat = "# DO NOT DELETE";
+int		width = 78;
+static boolean	append = FALSE;
+boolean		printed = FALSE;
+boolean		verbose = FALSE;
+boolean		show_where_not = FALSE;
+/* Warn on multiple includes of same file */
+boolean 	warn_multiple = FALSE;
 
+static void setfile_cmdinc(struct filepointer *filep, long count, char **list);
 static void redirect(char *line, char *makefile);
 
 static
@@ -115,7 +129,7 @@
 	fatalerr ("got signal %d\n", sig);
 }
 
-#if defined(USG) || (defined(i386) && defined(SYSV)) || defined(WIN32) || defined(__EMX__) || defined(Lynx_22) || defined(__CYGWIN__)
+#if defined(USG) || (defined(i386) && defined(SYSV)) || defined(WIN32) || defined(__UNIXOS2__) || defined(Lynx_22) || defined(__CYGWIN__)
 #define USGISH
 #endif
 
@@ -324,6 +338,28 @@
 		case 'O':
 		case 'g':
 			break;
+		case 'i':
+			if (strcmp(&argv[0][1],"include") == 0) {
+				char *buf;
+				if (argc<2)
+					fatalerr("option -include is a "
+						 "missing its parameter\n");
+				if (cmdinc_count >= MAXINCFILES)
+					fatalerr("Too many -include flags.\n");
+				argc--;
+				argv++;
+				buf = malloc(strlen(DASH_INC_PRE) +
+					     strlen(argv[0]) +
+					     strlen(DASH_INC_POST) + 1);
+                		if(!buf)
+					fatalerr("out of memory at "
+						 "-include string\n");
+				cmdinc_list[2 * cmdinc_count + 0] = argv[0];
+				cmdinc_list[2 * cmdinc_count + 1] = buf;
+				cmdinc_count++;
+				break;
+			}
+			/* intentional fall through */
 		default:
 			if (endmarker) break;
 	/*		fatalerr("unknown opt = %s\n", argv[0]); */
@@ -342,7 +378,7 @@
 		fatalerr("Too many -I flags.\n");
 	    *incp++ = PREINCDIR;
 #endif
-#ifdef __EMX__
+#ifdef __UNIXOS2__
 	    {
 		char *emxinc = getenv("C_INCLUDE_PATH");
 		/* can have more than one component */
@@ -360,7 +396,7 @@
 		    }
 		}
 	    }
-#else /* !__EMX__, does not use INCLUDEDIR at all */
+#else /* !__UNIXOS2__, does not use INCLUDEDIR at all */
 	    if (incp >= includedirs + MAXDIRS)
 		fatalerr("Too many -I flags.\n");
 	    *incp++ = INCLUDEDIR;
@@ -454,7 +490,9 @@
 	 * now peruse through the list of files.
 	 */
 	for(fp=filelist; *fp; fp++) {
+		DBG_PRINT(stderr,"file: %s\n",*fp);
 		filecontent = getfile(*fp);
+		setfile_cmdinc(filecontent, cmdinc_count, cmdinc_list);
 		ip = newinclude(*fp, (char *)NULL);
 
 		find_includes(filecontent, ip, ip, 0, FALSE);
@@ -467,7 +505,7 @@
 	return 0;
 }
 
-#ifdef __EMX__
+#ifdef __UNIXOS2__
 /*
  * eliminate \r chars from file
  */
@@ -491,6 +529,7 @@
 	struct stat	st;
 
 	content = (struct filepointer *)malloc(sizeof(struct filepointer));
+	content->f_name = file;
 	if ((fd = open(file, O_RDONLY)) < 0) {
 		warning("cannot open \"%s\"\n", file);
 		content->f_p = content->f_base = content->f_end = (char *)malloc(1);
@@ -503,7 +542,7 @@
 		fatalerr("cannot allocate mem\n");
 	if ((st.st_size = read(fd, content->f_base, st.st_size)) < 0)
 		fatalerr("failed to read %s\n", file);
-#ifdef __EMX__
+#ifdef __UNIXOS2__
 	st.st_size = elim_cr(content->f_base,st.st_size);
 #endif
 	close(fd);
@@ -512,10 +551,21 @@
 	content->f_end = content->f_base + st.st_size;
 	*content->f_end = '\0';
 	content->f_line = 0;
+	content->cmdinc_count = 0;
+	content->cmdinc_list = NULL;
+	content->cmdinc_line = 0;
 	return(content);
 }
 
 void
+setfile_cmdinc(struct filepointer* filep, long count, char** list)
+{
+	filep->cmdinc_count = count;
+	filep->cmdinc_list = list;
+	filep->cmdinc_line = 0;
+}
+
+void
 freefile(struct filepointer *fp)
 {
 	free(fp->f_base);
@@ -551,6 +601,20 @@
 		*eof,	/* end of file pointer */
 		*bol;	/* beginning of line pointer */
 	int	lineno;	/* line number */
+	boolean whitespace = FALSE;
+
+	/*
+	 * Fake the "-include" line files in form of #include to the
+	 * start of each file.
+	 */
+	if (filep->cmdinc_line < filep->cmdinc_count) {
+		char *inc = filep->cmdinc_list[2 * filep->cmdinc_line + 0];
+		char *buf = filep->cmdinc_list[2 * filep->cmdinc_line + 1];
+		filep->cmdinc_line++;
+		sprintf(buf,"%s%s%s",DASH_INC_PRE,inc,DASH_INC_POST);
+		DBG_PRINT(stderr,"%s\n",buf);
+		return(buf);
+	}
 
 	p = filep->f_p;
 	eof = filep->f_end;
@@ -558,7 +622,18 @@
 		return((char *)NULL);
 	lineno = filep->f_line;
 
-	for(bol = p--; ++p < eof; ) {
+	for (bol = p--; ++p < eof; ) {
+		if ((bol == p) && ((*p == ' ') || (*p == '\t')))
+		{
+			/* Consume leading white-spaces for this line */
+			while (((p+1) < eof) && ((*p == ' ') || (*p == '\t')))
+			{
+				p++;
+				bol++;
+			}
+			whitespace = TRUE;
+		}
+        
 		if (*p == '/' && (p+1) < eof && *(p+1) == '*') {
 			/* Consume C comments */
 			*(p++) = ' ';
@@ -628,13 +703,22 @@
 				--p;
 			}
 			bol = p+1;
+			whitespace = FALSE;
 		}
 	}
 	if (*bol != '#')
 		bol = NULL;
 done:
+	if (bol && whitespace) {
+		warning("%s:  non-portable whitespace encountered at line %d\n",
+			filep->f_name, lineno);
+	}
 	filep->f_p = p;
 	filep->f_line = lineno;
+#ifdef DEBUG_DUMP
+	if (bol)
+		DBG_PRINT(stderr,"%s\n",bol);
+#endif
 	return(bol);
 }
 
@@ -654,7 +738,7 @@
 	return(file);
 }
 
-#if defined(USG) && !defined(CRAY) && !defined(SVR4) && !defined(__EMX__) && !defined(clipper) && !defined(__clipper__)
+#if defined(USG) && !defined(CRAY) && !defined(SVR4) && !defined(__UNIXOS2__) && !defined(clipper) && !defined(__clipper__)
 int rename (char *from, char *to)
 {
     (void) unlink (to);
@@ -702,12 +786,12 @@
 		fatalerr("cannot open \"%s\"\n", makefile);
 	sprintf(backup, "%s.bak", makefile);
 	unlink(backup);
-#if defined(WIN32) || defined(__EMX__) || defined(__CYGWIN__)
+#if defined(WIN32) || defined(__UNIXOS2__) || defined(__CYGWIN__)
 	fclose(fdin);
 #endif
 	if (rename(makefile, backup) < 0)
 		fatalerr("cannot rename %s to %s\n", makefile, backup);
-#if defined(WIN32) || defined(__EMX__) || defined(__CYGWIN__)
+#if defined(WIN32) || defined(__UNIXOS2__) || defined(__CYGWIN__)
 	if ((fdin = fopen(backup, "r")) == NULL)
 		fatalerr("cannot open \"%s\"\n", backup);
 #endif
Index: xc/config/makedepend/mkdepend.man
diff -u xc/config/makedepend/mkdepend.man:1.6 xc/config/makedepend/mkdepend.man:1.7
--- xc/config/makedepend/mkdepend.man:1.6	Mon Dec 17 15:52:22 2001
+++ xc/config/makedepend/mkdepend.man	Fri Dec 13 21:39:45 2002
@@ -23,7 +23,7 @@
 .\" dealing in this Software without prior written authorization from The
 .\" Open Group.
 .\"
-.\" $XFree86: xc/config/makedepend/mkdepend.man,v 1.6 2001/12/17 20:52:22 dawes Exp $
+.\" $XFree86: xc/config/makedepend/mkdepend.man,v 1.7 2002/12/14 02:39:45 dawes Exp $
 .\"
 .TH MAKEDEPEND 1 __xorgversion__
 .UC 4
@@ -44,6 +44,8 @@
 ] [
 .BI \-f makefile
 ] [
+.BI \-include \ file
+] [
 .BI \-o objsuffix
 ] [
 .BI \-p objprefix
@@ -201,6 +203,12 @@
 can place its output.
 Specifying ``\-'' as the file name (i.e., \fB\-f\-\fP) sends the
 output to standard output instead of modifying an existing file.
+.TP 5
+.B \-include \fIfile\fP
+Process file as input, and include all the resulting output
+before processing the regular input file. This has the same
+affect as if the specified file is an include statement that
+appears before the very first line of the regular input file.
 .TP 5
 .B \-o\fIobjsuffix\fP
 Object file suffix.
Index: xc/config/makedepend/parse.c
diff -u xc/config/makedepend/parse.c:1.11 xc/config/makedepend/parse.c:1.12
--- xc/config/makedepend/parse.c:1.11	Mon Dec 17 15:52:22 2001
+++ xc/config/makedepend/parse.c	Tue Feb 26 00:09:10 2002
@@ -24,7 +24,7 @@
 in this Software without prior written authorization from The Open Group.
 
 */
-/* $XFree86: xc/config/makedepend/parse.c,v 1.11 2001/12/17 20:52:22 dawes Exp $ */
+/* $XFree86: xc/config/makedepend/parse.c,v 1.12 2002/02/26 05:09:10 tsi Exp $ */
 
 #include "def.h"
 
@@ -196,9 +196,16 @@
 			(ret == INCLUDE) ? "" : "_next", p));
 
 		/* Support ANSI macro substitution */
-		{
-		    struct symtab **sym = isdefined(p, file_red, NULL);
-		    while (sym) {
+		while (1) {
+			struct symtab **sym;
+
+			if (!*p || *p == '"' || *p == '<')
+				break;
+
+		    	sym = isdefined(p, file_red, NULL);
+			if (!sym)
+				break;
+
 			p = (*sym)->s_value;
 			debug(3,("%s : #includes SYMBOL %s = %s\n",
 			       file->i_incstring,
@@ -206,8 +213,6 @@
 			       (*sym) -> s_value));
 			/* mark file as having included a 'soft include' */
 			file->i_flags |= INCLUDED_SYM; 
-			sym = isdefined(p, file_red, NULL);
-		    }
 		}
 
 		/*
@@ -264,22 +269,20 @@
 
 	if (file->i_flags & DEFCHECKED)
 		return(NULL);
+	debug(2,("Looking for %s in %s\n", symbol, file->i_file));
 	file->i_flags |= DEFCHECKED;
 	if ((val = slookup(symbol, file)))
 		debug(1,("%s defined in %s as %s\n",
 			 symbol, file->i_file, (*val)->s_value));
 	if (val == NULL && file->i_list)
-		{
+	{
 		for (ip = file->i_list, i=0; i < file->i_listlen; i++, ip++)
 			if (file->i_merged[i]==FALSE) {
 				val = fdefined(symbol, *ip, srcfile);
-				if ((*ip)->i_flags & FINISHED) {
-					merge2defines(file,*ip);
-					file->i_merged[i]=TRUE;
-				    }
+				file->i_merged[i]=merge2defines(file,*ip);
 				if (val!=NULL) break;
 			}
-		}
+	}
 	else if (val != NULL && srcfile != NULL) *srcfile = file;
 	recurse_lvl--;
 	file->i_flags &= ~DEFCHECKED;
@@ -379,6 +382,8 @@
        just replace its s_value */
     if (sp != NULL)
     {
+	debug(1,("redefining %s from %s to %s in file %s\n",
+		name, (*sp)->s_value, val, file->i_file));
 	free((*sp)->s_value);
 	(*sp)->s_value = copy(val);
 	return;
@@ -395,6 +400,7 @@
     if (stab == NULL)
 	fatalerr("malloc()/realloc() failure in insert_defn()\n");
 
+    debug(1,("defining %s to %s in file %s\n", name, val, file->i_file));
     stab->s_name = copy(name);
     stab->s_value = copy(val);
     *sp = stab;
@@ -461,8 +467,17 @@
 static int 
 merge2defines(struct inclist *file1, struct inclist *file2)
 {
-	if ((file1!=NULL) && (file2!=NULL)) 
-        {
+	int i;
+
+	if ((file1==NULL) || (file2==NULL) ||
+	    !(file2->i_flags & FINISHED))
+		return 0;
+
+	for (i=0; i < file2->i_listlen; i++)
+		if (file2->i_merged[i]==FALSE)
+			return 0;
+
+	{
 		int first1 = 0;
 		int last1 = file1->i_ndefs - 1;
 
@@ -473,6 +488,9 @@
                 struct symtab** i_defs = NULL;
 		int deflen=file1->i_ndefs+file2->i_ndefs;
 
+		debug(2,("merging %s into %s\n",
+			file2->i_file, file1->i_file));
+
                 if (deflen>0)
                 { 
                 	/* make sure deflen % SYMTABINC == 0 is still true */
@@ -512,7 +530,6 @@
                 
 		return 1;
   	}
-	return 0;
 }
 
 void
@@ -627,6 +644,8 @@
 		case INCLUDENEXTDOT:
 			inclistp = inclistnext;
 			includedirsp = includedirsnext;
+			debug(2,("%s, reading %s, includes %s\n",
+				file_red->i_file, file->i_file, line));
 			add_include(filep, file, file_red, line, type, failOK);
 			inclistnext = inclistp;
 			includedirsnext = includedirsp;
@@ -662,5 +681,6 @@
 		}
 	}
 	file->i_flags |= FINISHED;
+	debug(2,("finished with %s\n", file->i_file));
 	return(-1);
 }
Index: xc/config/pswrap/Imakefile
diff -u xc/config/pswrap/Imakefile:1.7 xc/config/pswrap/Imakefile:1.8
--- xc/config/pswrap/Imakefile:1.7	Wed Feb 28 20:23:55 2001
+++ xc/config/pswrap/Imakefile	Fri May 31 12:31:21 2002
@@ -1,9 +1,10 @@
-XCOMM $XFree86: xc/config/pswrap/Imakefile,v 1.7 2001/03/01 01:23:55 dawes Exp $
+XCOMM $XFree86: xc/config/pswrap/Imakefile,v 1.8 2002/05/31 16:31:21 dawes Exp $
 
-   FRIENDSDEF = -DFRIENDSFILE='"<DPS/dpsfriends.h>"'
-      DEFINES = -DXENVIRONMENT
-      DEPLIBS =
-       YFLAGS = -d
+     FRIENDSDEF = -DFRIENDSFILE='"<DPS/dpsfriends.h>"'
+        DEFINES = -DXENVIRONMENT
+        DEPLIBS =
+         YFLAGS = -d
+EXTRA_LIBRARIES = LexLib
 
 SRCS = main.c pswdict.c pswfile.c \
 	systemnames.c psw.c pswstring.c pswsemantics.c
@@ -22,9 +23,3 @@
 LexFile(lexer)
 
 YaccFile(pswparser,$(YFLAGS))
-
-#ifdef OS2Architecture
-all::
-	$(CP) ProgramTargetName(pswrap) /
-#endif
-
Index: xc/config/pswrap/lexer.l
diff -u xc/config/pswrap/lexer.l:1.10 xc/config/pswrap/lexer.l:1.11
--- xc/config/pswrap/lexer.l:1.10	Sat Oct 27 23:32:03 2001
+++ xc/config/pswrap/lexer.l	Fri May 31 12:31:21 2002
@@ -36,7 +36,7 @@
  * 
  * Author:  Adobe Systems Incorporated
  */
-/* $XFree86: xc/config/pswrap/lexer.l,v 1.10 2001/10/28 03:32:03 tsi Exp $ */
+/* $XFree86: xc/config/pswrap/lexer.l,v 1.11 2002/05/31 16:31:21 dawes Exp $ */
 
 #include <ctype.h>
 #include <stdlib.h>
@@ -46,7 +46,7 @@
 #include "pswparser.h"
 
 /* flex of EMX seems to be too old */
-#if defined(FLEX_SCANNER) && !defined(YY_FLEX_LEX_COMPAT) && !defined(__EMX__)
+#if defined(FLEX_SCANNER) && !defined(YY_FLEX_LEX_COMPAT) && !defined(__UNIXOS2__)
 int yylineno = 1;
 #endif
 
Index: xc/config/util/Imakefile
diff -u xc/config/util/Imakefile:3.42 xc/config/util/Imakefile:3.47
--- xc/config/util/Imakefile:3.42	Mon Jan  7 15:38:21 2002
+++ xc/config/util/Imakefile	Sat Oct 12 12:06:40 2002
@@ -2,7 +2,7 @@
 
 
 
-XCOMM $XFree86: xc/config/util/Imakefile,v 3.42 2002/01/07 20:38:21 dawes Exp $
+XCOMM $XFree86: xc/config/util/Imakefile,v 3.47 2002/10/12 16:06:40 herrb Exp $
 
 #if UseCCMakeDepend
 CCMDEP_PROG = ccmakedep
@@ -12,24 +12,25 @@
 EXPORTLISTGEN = exportlistgen
 #endif
 
-#ifdef Win32Architecture
+#if defined(Win32Architecture)
 CMKDIRHIER = mkdirhier.exe
 #endif
 
-#ifndef OS2Architecture
 GCCMDEP_PROG = gccmakedep
+#if HasSymLinks
 #if CrossCompiling
 LNDIR_PROG = HostProgramTargetName(lndir)
 #else
-LNDIR_PROG = lndir
+LNDIR_PROG = ProgramTargetName(lndir)
 #endif
 #endif
 
 #if BuildRman
-RMAN_PROG = rman
+RMAN_PROG = HostProgramTargetName(rman)
 #endif
 
-PROGRAMS = $(RMAN_PROG) $(LNDIR_PROG) makestrs revpath $(EXPORTLISTGEN) $(CMKDIRHIER)
+PROGRAMS = $(RMAN_PROG) $(LNDIR_PROG) ProgramTargetName(makestrs) \
+	   ProgramTargetName(revpath) $(EXPORTLISTGEN) $(CMKDIRHIER)
 DEPLIBS =
 #ifndef Win32Architecture
   EXTRA_LIBRARIES =
@@ -71,22 +72,20 @@
 CppScriptTarget(xmkmf,xmkmf.cpp,-DCONFIGDIRSPEC='"'"-I$(CONFIGDIR)"'"',$(ICONFIGFILES))
 CppScriptTarget(ccmakedep,mdepend.cpp,-DPREPROC='"'"$(PREPROCESSCMD_MKDEPEND)"'"',$(ICONFIGFILES))
 CppScriptTarget(mergelib,mergelib.cpp,"-DARCMD=$(AR)" "-DRANLIB=$(RANLIB)",$(ICONFIGFILES))
-#ifndef OS2Architecture
 CppScriptTarget(gccmakedep,gccmdep.cpp,-DCCCMD='"'"$(GCCCMD)"'"' -DRMCMD='"'"$(RM)"'"' -DLNCMD='"'"$(LN)"'"' -DMVCMD='"'"$(MV)"'"',$(ICONFIGFILES))
-#endif
 
 #ifndef OpenBSDArchitecture
 #if HasSymLinks
 #if CrossCompiling
 SimpleHostProgramTarget_2(lndir)
 #else
-AllTarget($(LNDIR_PROG))
+AllTarget(lndir)
 SimpleProgramTarget_2(lndir)
 #endif
 #endif
 #endif
 
-#ifdef Win32Architecture
+#if defined(Win32Architecture)
 AllTarget(ProgramTargetName(mkdirhier))
 SimpleProgramTarget_3(mkdirhier)
 #endif
@@ -122,39 +121,30 @@
 
 InstallManPage(xmkmf,$(MANDIR))
 
-#if defined(OS2Architecture)
-includes:: makestrs.exe
-	ImakeHelper 7 makestrs.exe /makestrs.exe
-
-InstallNamedProg(mkdirhier.cmd,mkdirhier.cmd,$(BINDIR))
-InstallNamedProg(indir.cmd,indir.cmd,$(BINDIR))
-InstallNamedProg(os2inst.cmd,os2inst.cmd,$(BINDIR))
-InstallNamedProg(xmkmf.cmd,xmkmf.cmd,$(BINDIR))
-InstallNamedProg(xmake.cmd,make.cmd,$(BINDIR))
-InstallDriverSDKNamedProg(mkdirhier.cmd,mkdirhier.cmd,$(DRIVERSDKDIR)/config/util)
-InstallDriverSDKNamedProg(indir.cmd,indir.cmd,$(DRIVERSDKDIR)/config/util)
-InstallDriverSDKNamedProg(os2inst.cmd,os2inst.cmd,$(DRIVERSDKDIR)/config/util)
-#else
 InstallNamedProg(xmkmf,xmkmf,$(BINDIR))
 InstallNamedProg(mkdirhier.sh,mkdirhier,$(BINDIR))
+InstallManPage(mkdirhier,$(MANDIR))
 InstallNamedProg(gccmakedep,gccmakedep,$(BINDIR))
+InstallManPage(gccmakedep,$(MANDIR))
 #if defined(QNX4Architecture) || defined(NTOArchitecture)
 InstallNamedProg(install.sh,install,$(BINDIR))
 #endif
 InstallDriverSDKNamedProg(mkdirhier.sh,mkdirhier.sh,$(DRIVERSDKDIR)/config/util)
 InstallDriverSDKNamedProg(gccmakedep,gccmakedep,$(DRIVERSDKDIR)/config/util)
 InstallNamedProg(mergelib,mergelib,$(BINDIR))
+InstallManPage(mergelib,$(MANDIR))
 InstallNamedProg(makeg.sh,makeg,$(BINDIR))
 InstallManPage(makeg,$(MANDIR))
 InstallNamedProg(cleanlinks.sh,cleanlinks,$(BINDIR))
+InstallManPage(cleanlinks,$(MANDIR))
 #if HasPerl
 InstallNamedProg(mkhtmlindex.pl,mkhtmlindex,$(BINDIR))
 #else
 InstallNamedProg(mkhtmlindex.sh,mkhtmlindex,$(BINDIR))
 #endif
-#endif
-InstallManPage(mkdirhier,$(MANDIR))
+InstallManPage(mkhtmlindex,$(MANDIR))
 InstallNamedProg(ccmakedep,ccmakedep,$(BINDIR))
+InstallManPage(ccmakedep,$(MANDIR))
 InstallDriverSDKNamedProg(ccmakedep,ccmakedep,$(DRIVERSDKDIR)/config/util)
 #if SystemV || SystemV4
 InstallNamedProg(bsdinst.sh,bsdinst,$(BINDIR))
@@ -162,3 +152,6 @@
 #endif
 
 InstallDriverSDKNamedProg(revpath,revpath,$(DRIVERSDKDIR)/config/util)
+#ifdef OS2Architecture
+InstallNamedProg(gccmakedep.cmd,gccmakedep.cmd,$(BINDIR))
+#endif
Index: xc/config/util/added.cmd
diff -u xc/config/util/added.cmd:3.0 xc/config/util/added.cmd:removed
--- xc/config/util/added.cmd:3.0	Thu Oct 20 02:01:00 1994
+++ xc/config/util/added.cmd	Thu Feb 27 12:13:05 2003
@@ -1,23 +0,0 @@
-/* OS/2 REXX script to create nonexisting directories
- * run with 'added dirlist_file'
- * where dirlist_file is a XFree86 added-* file
- *
- * $XFree86: xc/config/util/added.cmd,v 3.0 1994/10/20 06:01:00 dawes Exp $
- */
-
-file = arg(1)
-linein(file,1,0)
-curdir = directory()
-do while lines(file)=1
-  fs = strip(filespec("path",linein(file)),'t','/')
-  newdir = directory(fs)
-  if newdir='' then do
-    say 'create directory='fs
-    call directory(curdir)
-    call 'xc\config\util\mkdirhier.cmd' fs
-  end 
-  else do
-    say 'found directory='newdir
-    call directory(curdir)
-  end
-end
Index: xc/config/util/buildos2.cmd
diff -u xc/config/util/buildos2.cmd:3.10 xc/config/util/buildos2.cmd:3.11
--- xc/config/util/buildos2.cmd:3.10	Wed Apr  5 14:13:12 2000
+++ xc/config/util/buildos2.cmd	Fri May 31 12:31:21 2002
@@ -1,110 +1 @@
-/* REXX */
-/* $XFree86: xc/config/util/buildos2.cmd,v 3.10 2000/04/05 18:13:12 dawes Exp $
- * this file is supposed to run from the xc/ dir.
- * you must copy it manually to there before using. It is just here
- * in order not to be in the root dir.
- *
- * copy some essential files to a location where we find them again
- */
-'@echo off'
-env = 'OS2ENVIRONMENT'
-'copy config\util\indir.cmd \ > nul 2>&1'
-'copy config\util\mkdirhier.cmd \ > nul 2>&1'
-'copy config\imake\imakesvc.cmd \ > nul 2>&1'
-
-IF \ exists('config\cf\host.def') THEN
-    CALL LINEOUT 'config\cf\host.def',' '
-
-CALL create_makefile
-
-CALL VALUE 'GCCOPT','-pipe',env
-CALL VALUE 'EMXLOAD',5,env
-CALL VALUE 'MAKEFLAGS','--no-print-directory',env
-'emxload -e x11make.exe rm.exe mv.exe'
-'emxload -e -gcc -omf'
-
-'x11make MAKE=x11make SHELL= MFLAGS="MAKE=x11make CC=gcc BOOTSTRAPCFLAGS=-DBSD43 SHELL= " World.OS2 2>&1 | tee buildos2.log'
-
-EXIT
-
-/* returns 1, if file exists */
-exists:
-	IF STREAM(arg(1), 'C', 'QUERY EXISTS') = '' THEN
-		RETURN 0
-	ELSE
-		RETURN 1
-
-create_makefile:
-IF exists(Makefile) THEN del Makefile
-CALL LINEOUT 'Makefile','RELEASE = "Release 6.4"',1
-CALL LINEOUT 'Makefile','SHELL = /bin/sh'
-CALL LINEOUT 'Makefile','RM = rm -f'
-CALL LINEOUT 'Makefile','MV = mv'
-CALL LINEOUT 'Makefile','WORLDOPTS = -k'
-CALL LINEOUT 'Makefile','TOP = .'
-CALL LINEOUT 'Makefile','CURRENT_DIR = .'
-CALL LINEOUT 'Makefile','CONFIGSRC = $(TOP)/config'
-CALL LINEOUT 'Makefile','IMAKESRC = $(CONFIGSRC)/imake'
-CALL LINEOUT 'Makefile','DEPENDSRC = $(CONFIGSRC)/makedepend'
-CALL LINEOUT 'Makefile','DEPENDTOP = ../..'
-CALL LINEOUT 'Makefile','IMAKETOP = ../..'
-CALL LINEOUT 'Makefile','IRULESRC = $(CONFIGSRC)/cf'
-CALL LINEOUT 'Makefile','IMAKE = $(IMAKESRC)/imake'
-CALL LINEOUT 'Makefile','IMAKE_CMD = $(IMAKE) -I$(IRULESRC) $(IMAKE_DEFINES)'
-CALL LINEOUT 'Makefile','MAKE_OPTS = '
-CALL LINEOUT 'Makefile','MAKE_CMD = $(MAKE) $(MAKE_OPTS)'
-CALL LINEOUT 'Makefile','FLAGS = $(MFLAGS) -f Makefile.ini BOOTSTRAPCFLAGS="$(BOOTSTRAPCFLAGS)"'
-CALL LINEOUT 'Makefile',' '
-CALL LINEOUT 'Makefile','World.OS2:'
-CALL LINEOUT 'Makefile','	@echo :'
-CALL LINEOUT 'Makefile','	@echo Building $(RELEASE) of the X Window System on OS/2.'
-CALL LINEOUT 'Makefile','	@echo :'
-CALL LINEOUT 'Makefile','	@echo :'
-CALL LINEOUT 'Makefile','	\indir $(IMAKESRC) $(MAKE) SHELL= -f Makefile.ini clean.os2'
-CALL LINEOUT 'Makefile','	\indir $(IMAKESRC) $(MAKE) SHELL= CC=gcc -f Makefile.ini imake.os2'
-CALL LINEOUT 'Makefile','	-if exist Makefile.bak del Makefile.bak'
-CALL LINEOUT 'Makefile','	-if exist Makefile ren Makefile Makefile.bak'
-CALL LINEOUT 'Makefile','	$(subst /,\,$(IMAKE)) -I$(IRULESRC) $(IMAKE_DEFINES) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT_DIR)'
-CALL LINEOUT 'Makefile','	$(MAKE) $(MFLAGS) VerifyOS'
-CALL LINEOUT 'Makefile','	$(MAKE) $(MFLAGS) Makefiles'
-CALL LINEOUT 'Makefile','	$(MAKE) $(MFLAGS) clean'
-CALL LINEOUT 'Makefile','	$(MAKE) $(MFLAGS) includes'
-CALL LINEOUT 'Makefile','	$(MAKE) $(MFLAGS) depend'
-CALL LINEOUT 'Makefile','	$(MAKE) $(MFLAGS)  '
-CALL LINEOUT 'Makefile','	@echo :'
-CALL LINEOUT 'Makefile','	@echo :'
-CALL LINEOUT 'Makefile','	@echo Full build of $(RELEASE) of the X Window System complete.'
-CALL LINEOUT 'Makefile','	@echo :'
-CALL LINEOUT 'Makefile',' '
-CALL LINEOUT 'Makefile','# dont allow any default rules in this Makefile'
-CALL LINEOUT 'Makefile','.SUFFIXES:'
-CALL LINEOUT 'Makefile','# quiet "make" programs that display a message if suffix list empty'
-CALL LINEOUT 'Makefile','.SUFFIXES: .Dummy'
-CALL LINEOUT 'Makefile',' '
-CALL LINEOUT 'Makefile','# a copy of every rule that might be invoked at top level'
-CALL LINEOUT 'Makefile',' '
-CALL LINEOUT 'Makefile','clean:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','dangerous_strip_clean:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','depend:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','Everything:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','includes:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','install.man:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','install:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','Makefiles:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','man_keywords:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','tags:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile','VerifyOS:'
-CALL LINEOUT 'Makefile','	    $(MAKE_CMD) $@'
-CALL LINEOUT 'Makefile',' '
-CALL STREAM 'Makefile','c','close'
-RETURN
+make CC=gcc BOOTSTRAPCFLAGS=-Zexe World 2>&1 | tee World.log
Index: xc/config/util/ccmakedep.man
diff -u /dev/null xc/config/util/ccmakedep.man:1.1
--- /dev/null	Thu Feb 27 12:13:05 2003
+++ xc/config/util/ccmakedep.man	Sat Oct 12 12:06:40 2002
@@ -0,0 +1,142 @@
+.TH ccmakedep 1 __xorgversion__
+.SH NAME
+ccmakedep \- create dependencies in makefiles using a C compiler
+.SH SYNOPSIS
+.B ccmakedep
+[
+.BI cpp-flags
+] [
+.BI \-w width
+] [
+.BI \-s magic-string
+] [
+.BI \-f makefile
+] [
+.BI \-o object-suffix
+] [
+.B \-v
+] [
+.B \-a
+] [
+.BI \-cc compiler
+] [
+\-\^\-
+.I options
+\-\^\-
+]
+.I sourcefile
+\^.\|.\|.
+.SH DESCRIPTION
+The
+.B ccmakedep
+program calls a C compiler to preprocess each
+.IR sourcefile ,
+and uses the output to construct
+.I makefile
+rules describing their dependencies.
+These rules instruct
+.BR make (1)
+on which object files must be recompiled when a dependency has changed.
+.PP
+By default,
+.B ccmakedep
+places its output in the file named
+.I makefile
+if it exists, otherwise
+.I Makefile.
+An alternate makefile may be specified with the
+.B \-f
+option.
+It first searches the makefile for a line beginning with
+.sp
+\&    # DO NOT DELETE
+.sp
+or one provided with the
+.B \-s
+option, as a delimiter for the dependency output.
+If it finds it, it will delete everything following this up to the end of
+the makefile and put the output after this line.
+If it doesn't find it, the program will append the string to the makefile
+and place the output after that.
+.SH EXAMPLE
+Normally,
+.B ccmakedep
+will be used in a makefile target so that typing 'make depend' will bring
+the dependencies up to date for the makefile.
+For example,
+.nf
+    SRCS\0=\0file1.c\0file2.c\0.\|.\|.
+    CFLAGS\0=\0\-O\0\-DHACK\0\-I\^.\^.\^/foobar\0\-xyz
+    depend:
+            ccmakedep\0\-\^\-\0$(CFLAGS)\0\-\^\-\0$(SRCS)
+.fi
+.SH OPTIONS
+The program will ignore any option that it does not understand, so you may
+use the same arguments that you would for
+.BR cc (1),
+including
+.B \-D
+and
+.B \-U
+options to define and undefine symbols and
+.B \-I
+to set the include path.
+.TP
+.B \-a
+Append the dependencies to the file instead of replacing existing
+dependencies.
+.TP
+.BI \-cc compiler
+Use this compiler to generate dependencies.
+.TP
+.BI \-f makefile
+Filename.
+This allows you to specify an alternate makefile in which
+.B ccmakedep
+can place its output.
+Specifying \(lq\-\(rq as the file name (that is,
+.BR \-f\- )
+sends the output to standard output instead of modifying an existing file.
+.TP
+.BI \-s string
+Starting string delimiter.
+This option permits you to specify a different string for
+.B ccmakedep
+to look for in the makefile.
+The default is \(lq# DO NOT DELETE\(rq.
+.TP
+.BI \-v
+Be verbose: display the C compiler command before running it.
+.TP
+.BI \-\^\- " options " \-\^\-
+If
+.B ccmakedep
+encounters a double hyphen (\-\^\-) in the argument list, then any
+unrecognized arguments following it will be silently ignored.
+A second double hyphen terminates this special treatment.
+In this way,
+.B ccmakedep
+can be made to safely ignore esoteric compiler arguments that might
+normally be found in a CFLAGS
+.B make
+macro (see the
+.B EXAMPLE
+section above).
+.BR \-D ,
+.BR \-I ,
+and
+.B \-U
+options appearing between the pair of double hyphens are still processed
+normally.
+.SH "SEE ALSO"
+.BR cc (1),
+.BR make (1),
+.BR makedepend (1),
+.BR ccmakedep (1).
+.SH AUTHOR
+.B ccmakedep
+was written by the X Consortium.
+.PP
+Colin Watson wrote this manual page, originally for the Debian Project,
+based partly on the manual page for
+.BR makedepend (1).
Index: xc/config/util/cleanlinks.man
diff -u /dev/null xc/config/util/cleanlinks.man:1.1
--- /dev/null	Thu Feb 27 12:13:06 2003
+++ xc/config/util/cleanlinks.man	Sat Oct 12 12:06:40 2002
@@ -0,0 +1,28 @@
+.TH cleanlinks 1 __vendorversion__
+.SH NAME
+cleanlinks \- remove dangling symbolic links and empty directories
+.SH SYNOPSIS
+.B cleanlinks
+.SH DESCRIPTION
+The
+.I cleanlinks
+program searches the directory tree descended from the current directory for
+symbolic links whose targets do not exist, and removes them.
+It then removes all empty directories in that directory tree.
+.PP
+.I cleanlinks
+is useful for cleaning up a shadow link tree created with
+.BR lndir (1)
+after files have been removed from the real directory.
+.SH DIAGNOSTICS
+A message will be printed upon encountering each dangling symlink and empty
+directory.
+.SH SEE ALSO
+.BR lndir (1).
+.SH AUTHOR
+.PP
+David Dawes wrote the
+.I cleanlinks
+program for XFree86.
+.PP
+Colin Watson wrote this manual page, originally for the Debian Project.
Index: xc/config/util/elistgen.sun
diff -u xc/config/util/elistgen.sun:1.7 xc/config/util/elistgen.sun:1.8
--- xc/config/util/elistgen.sun:1.7	Wed Jan 17 11:39:01 2001
+++ xc/config/util/elistgen.sun	Tue Oct  8 19:07:42 2002
@@ -15,13 +15,13 @@
 XCOMM
 XCOMM ########################################################################
 XCOMM
-XCOMM $XFree86: xc/config/util/elistgen.sun,v 1.7 2001/01/17 16:39:01 dawes Exp $
+XCOMM $XFree86: xc/config/util/elistgen.sun,v 1.8 2002/10/08 23:07:42 dawes Exp $
 
 XCOMM Utility programs
 FILTER=CXXFILT			# C++ symbol demangler
 AWK=nawk			# Awk
 
-XCOMM For nm, cat, pr, expand, awk, c++filt
+XCOMM For nm, cat, pr, sed, awk, c++filt
 PATH=/usr/bin:/bin:/usr/ccs/bin:/usr/ucb:$PATH
 
 XCOMM Try to detect broken versions of c++filt.
@@ -144,7 +144,7 @@
 XCOMM of NMLIST and FILTLIST are used to construct a symbol lookup table.
 XCOMM The contents of EXPORTLIST are converted with the help of this table.
 XCOMM Use ";" as a delimiter in the symbol lookup table.
-(pr -m -s";" -t -w1024 $NMLIST $FILTLIST | expand -1; cat $EXPORTLIST) | $AWK '
+(pr -m -s";" -t -w1024 $NMLIST $FILTLIST | sed 's/     / /g'; cat $EXPORTLIST) | $AWK '
     BEGIN {
 	FS = ";";
 	implicit = 0;
Index: xc/config/util/elistgen.usl
diff -u xc/config/util/elistgen.usl:1.1.1.2 xc/config/util/elistgen.usl:1.2
--- xc/config/util/elistgen.usl:1.1.1.2	Tue Jan 16 16:54:42 2001
+++ xc/config/util/elistgen.usl	Tue Oct  8 19:07:42 2002
@@ -22,12 +22,14 @@
 XCOMM (c) Copyright 1996 Hitachi.
 XCOMM
 XCOMM #########################################################################
+XCOMM
+XCOMM $XFree86: xc/config/util/elistgen.usl,v 1.2 2002/10/08 23:07:42 dawes Exp $
 
 XCOMM Utility programs
 FILTER=CXXFILT			# C++ symbol demangler
 AWK=awk				# awk
 
-XCOMM For nm, cat, pr, expand, awk, c++filt
+XCOMM For nm, cat, pr, sed, awk, c++filt
 PATH=/usr/bin:/bin:/usr/ucb:/usr/ccs/bin
 
 XCOMM Temporary files
@@ -126,7 +128,7 @@
 XCOMM of NMLIST and FILTLIST are used to construct a symbol lookup table.
 XCOMM The contents of EXPORTLIST are converted with the help of this table.
 XCOMM Use ";" as a delimiter in the symbol lookup table.
-(pr -m -s";" -t -w1024 $NMLIST $FILTLIST | expand -1; cat $EXPORTLIST) | $AWK '
+(pr -m -s";" -t -w1024 $NMLIST $FILTLIST | sed 's/      / /g'; cat $EXPORTLIST) | $AWK '
     BEGIN {
 	FS = ";";
 	implicit = 0;
Index: xc/config/util/gccmakedep.man
diff -u /dev/null xc/config/util/gccmakedep.man:1.1
--- /dev/null	Thu Feb 27 12:13:06 2003
+++ xc/config/util/gccmakedep.man	Sat Oct 12 12:06:40 2002
@@ -0,0 +1,124 @@
+.TH gccmakedep 1 __vendorversion__
+.SH NAME
+gccmakedep \- create dependencies in makefiles using 'gcc -M'
+.SH SYNOPSIS
+.B gccmakedep
+[
+.BI \-s separator
+] [
+.BI \-f makefile
+] [
+.BI \-a
+] [
+\-\^\-
+.I options
+\-\^\-
+]
+.I sourcefile
+\&.\|.\|.
+.SH DESCRIPTION
+The
+.B gccmakedep
+program calls 'gcc -M' to output
+.I makefile
+rules describing the dependencies of each
+.IR sourcefile ,
+so that
+.BR make (1)
+knows which object files must be recompiled when a dependency has changed.
+.PP
+By default,
+.B gccmakedep
+places its output in the file named
+.I makefile
+if it exists, otherwise
+.I Makefile.
+An alternate makefile may be specified with the
+.B \-f
+option.
+It first searches the makefile for a line beginning with
+.sp
+\&    # DO NOT DELETE
+.sp
+or one provided with the
+.B \-s
+option, as a delimiter for the dependency output.
+If it finds it, it will delete everything following this up to the end of
+the makefile and put the output after this line.
+If it doesn't find it, the program will append the string to the makefile
+and place the output after that.
+.SH EXAMPLE
+Normally,
+.B gccmakedep
+will be used in a makefile target so that typing 'make depend' will bring
+the dependencies up to date for the makefile.
+For example,
+.nf
+    SRCS\0=\0file1.c\0file2.c\0.\|.\|.
+    CFLAGS\0=\0\-O\0\-DHACK\0\-I\^.\^.\^/foobar\0\-xyz
+    depend:
+            gccmakedep\0\-\^\-\0$(CFLAGS)\0\-\^\-\0$(SRCS)
+.fi
+.SH OPTIONS
+The program will ignore any option that it does not understand, so you may
+use the same arguments that you would for
+.BR gcc (1),
+including
+.B \-D
+and
+.B \-U
+options to define and undefine symbols and
+.B \-I
+to set the include path.
+.TP
+.B \-a
+Append the dependencies to the file instead of replacing existing
+dependencies.
+.TP
+.BI \-f makefile
+Filename.
+This allows you to specify an alternate makefile in which
+.B gccmakedep
+can place its output.
+Specifying \(lq\-\(rq as the file name (that is,
+.BR \-f\- )
+sends the output to standard output instead of modifying an existing file.
+.TP
+.BI \-s string
+Starting string delimiter.
+This option permits you to specify a different string for
+.B gccmakedep
+to look for in the makefile.
+The default is \(lq# DO NOT DELETE\(rq.
+.TP
+.BI \-\^\- " options " \-\^\-
+If
+.B gccmakedep
+encounters a double hyphen (\-\^\-) in the argument list, then any
+unrecognized arguments following it will be silently ignored.
+A second double hyphen terminates this special treatment.
+In this way,
+.B gccmakedep
+can be made to safely ignore esoteric compiler arguments that might
+normally be found in a CFLAGS
+.B make
+macro (see the
+.B EXAMPLE
+section above).
+.BR \-D ,
+.BR \-I ,
+and
+.B \-U
+options appearing between the pair of double hyphens are still processed
+normally.
+.SH "SEE ALSO"
+.BR gcc (1),
+.BR make (1),
+.BR makedepend (1).
+.SH AUTHOR
+.B gccmakedep
+was written by the XFree86 Project based on code supplied by Hongjiu Lu.
+.PP
+Colin Watson wrote this manual page, originally for the Debian Project,
+based partly on the manual page for
+.BR makedepend (1).
Index: xc/config/util/gccmdep.cpp
diff -u xc/config/util/gccmdep.cpp:3.9 xc/config/util/gccmdep.cpp:3.10
--- xc/config/util/gccmdep.cpp:3.9	Tue May 22 09:29:17 2001
+++ xc/config/util/gccmdep.cpp	Mon Nov 25 09:04:48 2002
@@ -3,16 +3,26 @@
 XCOMM
 XCOMM makedepend which uses 'gcc -M'
 XCOMM
-XCOMM $XFree86: xc/config/util/gccmdep.cpp,v 3.9 2001/05/22 13:29:17 dawes Exp $
+XCOMM $XFree86: xc/config/util/gccmdep.cpp,v 3.10 2002/11/25 14:04:48 eich Exp $
 XCOMM
 XCOMM Based on mdepend.cpp and code supplied by Hongjiu Lu <hjl@nynexst.com>
 XCOMM
 
-TMP=`pwd`/.mdep$$
+TMP=${TMPDIR-/tmp}/mdep$$
 CC=CCCMD
 RM=RMCMD
 LN=LNCMD
 MV=MVCMD
+
+XCOMM Security: if $tmp exists exit immediately
+rm -f ${TMP}
+if [ -e ${TMP} ] ; then
+    echo "$0: ${TMP} exists already, exit." 1>&2
+    exit 1;
+fi
+if [ -n "`type -p mktemp`" ] ; then
+    TMP="`mktemp ${TMP}.XXXXXX`" || exit 1
+fi
 
 trap "$RM ${TMP}*; exit 1" 1 2 15
 trap "$RM ${TMP}*; exit 0" 1 2 13
Index: xc/config/util/instos2.cmd
diff -u xc/config/util/instos2.cmd:3.0 xc/config/util/instos2.cmd:removed
--- xc/config/util/instos2.cmd:3.0	Wed Jan 24 16:56:14 1996
+++ xc/config/util/instos2.cmd	Thu Feb 27 12:13:06 2003
@@ -1,13 +0,0 @@
-@echo off
-rem $XFree86: xc/config/util/instos2.cmd,v 3.0 1996/01/24 21:56:14 dawes Exp $
-rem this file is supposed to run from the xc/ dir.
-rem you must copy it manually to there before using. It is just here
-rem in order not to be in the root dir.
-rem
-set GCCOPT=-pipe
-set EMXLOAD=5
-emxload make.exe gcc.exe rm.exe mv.exe
-make SHELL= MFLAGS="CC=gcc" install 2>&1 | tee instxc.log
-rem
-rem
-echo INSTALL OF XFREE86/OS2 IS FINISHED
Index: xc/config/util/lndir.c
diff -u xc/config/util/lndir.c:3.15 xc/config/util/lndir.c:3.17
--- xc/config/util/lndir.c:3.15	Fri Dec 14 14:53:22 2001
+++ xc/config/util/lndir.c	Mon Oct  7 11:28:51 2002
@@ -26,7 +26,7 @@
 in this Software without prior written authorization from The Open Group.
 
 */
-/* $XFree86: xc/config/util/lndir.c,v 3.15 2001/12/14 19:53:22 dawes Exp $ */
+/* $XFree86: xc/config/util/lndir.c,v 3.17 2002/10/07 15:28:51 tsi Exp $ */
 
 /* From the original /bin/sh script:
 
@@ -126,15 +126,17 @@
 
 
 static int 
-equivalent(char *lname, char *rname)
+equivalent(char *lname, char *rname, char **p)
 {
     char *s;
 
     if (!strcmp(lname, rname))
 	return 1;
     for (s = lname; *s && (s = strchr(s, '/')); s++) {
-	while (s[1] == '/')
+	while (s[1] == '/') {
 	    strcpy(s+1, s+2);
+	    if (*p) (*p)--;
+	}
     }
     return !strcmp(lname, rname);
 }
@@ -267,10 +269,58 @@
 
 	if (symlen >= 0) {
 	    /* Link exists in new tree.  Print message if it doesn't match. */
-	    if (!equivalent (basesymlen>=0 ? basesym : buf, symbuf))
+	    if (!equivalent (basesymlen>=0 ? basesym : buf, symbuf,
+			     basesymlen>=0 ? (char **) 0 : &p))
 		msg ("%s: %s", dp->d_name, symbuf);
 	} else {
-	    if (symlink (basesymlen>=0 ? basesym : buf, dp->d_name) < 0)
+	    char *sympath;
+
+	    if (basesymlen>=0) {
+		if ((buf[0] == '.') && (buf[1] == '.') && (buf[2] == '/') &&
+		    (basesym[0] == '.') && (basesym[1] == '.') &&
+		    (basesym[2] == '/')) {
+		    /* It becomes very tricky here. We have
+		       ../../bar/foo symlinked to ../xxx/yyy. We
+		       can't just use ../xxx/yyy. We have to use
+		       ../../bar/foo/../xxx/yyy.  */
+
+		    int i;
+		    char *start, *end;
+
+		    strcpy (symbuf, buf);
+		    /* Find the first char after "../" in symbuf.  */
+		    start = symbuf;
+		    do {
+			start += 3;
+		    } while ((start[0] == '.') && (start[1] == '.') &&
+			     (start[2] == '/'));
+
+		    /* Then try to eliminate "../"s in basesym.  */
+		    i = 0;
+		    end = strrchr (symbuf, '/');
+		    if (start < end) {
+			do {
+			    i += 3;
+			    end--;
+			    while ((*end != '/') && (end != start))
+				end--;
+			    if (end == start)
+				break;
+			} while ((basesym[i] == '.') &&
+				 (basesym[i + 1] == '.') &&
+				 (basesym[i + 2] == '/'));
+		    }
+		    if (*end == '/')
+			end++;
+		    strcpy (end, &basesym[i]);
+		    sympath = symbuf;
+		}
+		else
+		    sympath = basesym;
+	    }
+	    else
+		sympath = buf;
+	    if (symlink (sympath, dp->d_name) < 0)
 		mperror (dp->d_name);
 	}
     }
Index: xc/config/util/lndir.man
diff -u xc/config/util/lndir.man:1.3 xc/config/util/lndir.man:1.4
--- xc/config/util/lndir.man:1.3	Fri Dec 14 14:53:22 2001
+++ xc/config/util/lndir.man	Mon Oct  7 11:28:51 2002
@@ -25,7 +25,7 @@
 .\" from The Open Group.
 .\" 
 .\"
-.\" $XFree86: xc/config/util/lndir.man,v 1.3 2001/12/14 19:53:22 dawes Exp $
+.\" $XFree86: xc/config/util/lndir.man,v 1.4 2002/10/07 15:28:51 tsi Exp $
 .\"
 .TH LNDIR 1 __xorgversion__
 .SH NAME
@@ -36,6 +36,8 @@
 .B \-silent
 ] [
 .B \-ignorelinks
+] [
+.B \-withrevinfo
 ]
 .I \|fromdir\|
 [
@@ -74,7 +76,8 @@
 (not the current directory).
 .PP 
 .\" CVS.adm is used by the Concurrent Versions System.
-Note that RCS, SCCS, CVS and CVS.adm directories are not shadowed.
+Note that RCS, SCCS, CVS and CVS.adm directories are shadowed only if
+the \fB\-withrevinfo\fP flag is specified.
 .PP
 If you add files, simply run
 .I lndir
@@ -101,6 +104,9 @@
 .IP
 This option exists mostly to emulate the behavior the C version of
 \fIlndir\fP had in X11R6.  Its use is not recommended.
+.IP \-withrevinfo
+Causes any RCS, SCCS, CVS and CVS.adm subdirectories to be treated as any other
+directory, rather than ignored.
 .SH DIAGNOSTICS
 The program displays the name of each subdirectory it enters, followed
 by a colon.  The \fB\-silent\fP option suppresses these messages.
@@ -111,20 +117,3 @@
 .PP
 If the link already exists but doesn't point to the correct file, the
 program prints the link name and the location where it does point.
-.SH BUGS
-The
-.I patch
-program gets upset if it cannot change the files.  You should never run
-.I patch
-from a shadow directory anyway.
-.PP
-You need to use something like
-.nf
-	find todir \|\-type l \|\-print \||\| xargs rm
-.fi
-to clear out all files before you can relink (if fromdir moved, for instance).
-Something like
-.nf
-	 find . \|\\! \|\-type d \|\-print
-.fi
-will find all files that are not directories.
Index: xc/config/util/makedef.cmd
diff -u /dev/null xc/config/util/makedef.cmd:1.1
--- /dev/null	Thu Feb 27 12:13:06 2003
+++ xc/config/util/makedef.cmd	Fri May 31 12:31:21 2002
@@ -0,0 +1,613 @@
+/* This is OS/2 REXX */
+/* $XFree86: xc/config/util/makedef.cmd,v 1.1 2002/05/31 16:31:21 dawes Exp $
+ *
+ * This file was taken from Odin32 project and modified to suit
+ * XFree86 4.x build process
+ *
+ * Generate *os2.def linker definition files for OS/2
+ */
+
+if RxFuncQuery('SysLoadFuncs')=1 THEN
+DO
+  call RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs';
+  call SysLoadFuncs;
+END
+  
+/*
+ * Set default parameter values.
+ */
+sLibrary      = '';
+sDBFile     = '';
+sOrdinals       = 0;
+sASDFeatureId   = '';
+sCountryCode    = '';
+sDateTime       = left(' 'date()' 'time(), 26);
+sDescription    = 'XFree86 4.2';
+sFixPakVer      = '';
+sHostname       = strip(substr(VALUE('HOSTNAME',,'OS2ENVIRONMENT'), 1, 11));
+sLanguageCode   = '';
+sMiniVer        = '';
+sVendor         = 'XFree86';
+sVersion        = '4.2.0';
+
+
+/*
+ * Parse parameters.
+ */
+parse arg  sArgs
+if (sArgs = '') then
+do
+    call syntax;
+    exit(1);
+end
+
+do while (sArgs <> '')
+    sArgs = strip(sArgs);
+    if (substr(sArgs, 1, 1) = '-' | substr(sArgs, 1, 1) = '/') then
+    do  /*
+         * Option.
+         */
+        ch = translate(substr(sArgs, 2, 1));
+        if (pos(ch, 'ACDHLMNOPRTV') < 1) then
+        do
+            say 'invalid option:' substr(sArgs, 1, 2);
+            call syntax;
+            exit(2);
+        end
+
+        /* get value and advance sArgs to next or to end. */
+        if (substr(sArgs, 3, 1) = '"') then
+        do
+            iNext = pos('"', sArgs, 4);
+            fQuote = 1;
+        end
+        else
+        do
+            iNext = pos(' ', sArgs, 3);
+            if (iNext <= 0) then
+                iNext = length(sArgs);
+            fQuote = 0;
+        end
+
+        if (iNext > 3 | ch = 'R') then
+        do
+            sValue = substr(sArgs, 3 + fQuote, iNext - 3 - fQuote);
+            sArgs = strip(substr(sArgs, iNext+1));
+            /*say 'iNext:' iNext  'sValue:' sValue  'sArgs:' sArgs; */
+
+            /* check if we're gonna search for something in an file. */
+            if (sValue <> '' & pos('#define=', sValue) > 0) then
+                sValue = LookupDefine(sValue);
+        end
+        else
+        do
+            say 'syntax error near' substr(sArgs, 1, 2)'.';
+            call syntax;
+            exit(3);
+        end
+
+
+        /* set value */
+        select
+            when (ch = 'A') then /* ASD Feature Id */
+                sASDFeatureId   = sValue;
+
+            when (ch = 'C') then /* Country code */
+                sCountryCode    = sValue;
+
+            when (ch = 'D') then /* Description */
+                sDescription    = sValue;
+
+            when (ch = 'H') then /* Hostname */
+                sHostname       = sValue;
+
+            when (ch = 'L') then /* Language code */
+                sLanguageCode   = sValue;
+
+            when (ch = 'M') then /* MiniVer */
+                sMiniVer        = sValue;
+
+            when (ch = 'N') then /* Vendor */
+                sVendor         = sValue;
+
+            when (ch = 'O') then /* Ordinals */
+                sOrdinals        = 1;
+                
+            when (ch = 'R') then /* Vendor */
+                sDescription    = ReadDescription(sValue, sDefFile);
+
+            when (ch = 'P') then /* Fixpak version */
+                sFixPakVer      = sValue;
+
+            when (ch = 'T') then /* Date Time */
+                sDateTime       = sValue;
+
+            when (ch = 'V') then /* Version */
+                sVersion        = sValue;
+
+            /* Otherwise it's an illegal option */
+            otherwise:
+                say 'invalid option:' substr(sArgs, 1, 2);
+                call syntax;
+                exit(2);
+        end /* select */
+    end
+    else
+    do  /*
+         * Table file name, typically xc/config/cf/os2def.db
+         */
+        if (sLibrary <> '') then
+        do
+            say 'Syntax error: Can''t specify more than two files!';
+            exit(4);
+        end
+        if (sDBFile = '') then
+            parse value sArgs with sDBFile' 'sArgs
+        else
+            parse value sArgs with sLibrary' 'sArgs
+        sArgs = strip(sArgs);
+    end
+end
+
+/* check that a definition file was specified. */
+if (sLibrary = '') then
+do
+    say 'Syntax error: Will have to specify a library stem.';
+    call syntax;
+    exit(5);
+end
+
+
+/*
+ * Trim strings to correct lengths.
+ */
+sVendor         = strip(substr(sVendor, 1, 31));
+if (substr(sDateTime, 1, 1) <> ' ') then
+    sDateTime = ' ' || sDateTime;
+sDateTime       = left(sDateTime, 26);
+sHostname       = strip(substr(sHostname, 1, 11));
+sMiniVer        = strip(substr(sMiniVer, 1, 11));
+sDescription    = strip(substr(sDescription, 1, 80));
+sCountryCode    = strip(substr(sCountryCode, 1, 4));
+sLanguageCode   = strip(substr(sLanguageCode, 1, 4));
+sASDFeatureId   = strip(substr(sASDFeatureId, 1, 11));
+sFixPakVer      = strip(substr(sFixPakVer, 1, 11));
+
+/* load database file, only accept lines for the specified sLibrary */
+ordHash.0 = 0
+sRealName = ''
+sInitTerm = 0
+
+rc = LoadDBFile(sDBFile,sLibrary)
+
+/* engage gcc to parse the corresponding -def.cpp file */
+'@gcc -E -D__UNIXOS2__ 'sLibrary'-def.cpp >tmpos2.def'
+
+/* Signature */
+sEnhSign = '##1##'
+
+/*
+ * Build description string.
+ */
+sDescription =  '@#'sVendor':'sVersion'#@'sEnhSign||,
+                sDateTime||sHostname||,
+                ':'sASDFeatureId':'sLanguageCode':'sCountryCode':'sMiniVer||,
+                '::'sFixPakVer'@@'sDescription;
+
+/*
+ * Update .def-file.
+ */
+rc = UpdateDefFile(sLibrary,sDescription,sRealName,sOrdinals,sInitTerm);
+call SysFileDelete('tmpos2.def')
+
+exit(rc);
+
+LoadDBFile: procedure expose ordHash. sRealname sInitTerm
+    parse arg dbfile,libname;
+
+    rc = stream(dbfile, 'c', 'open read');
+    if (pos('READY', rc) <> 1) then
+    do
+        say 'error: failed to open 'dbfile;
+        exit(-1);
+    end
+    do while (lines(dbfile) > 0)
+      line = translate(strip(linein(dbfile)),' ','	');
+      if pos(';',line) > 0 then iterate;
+      if pos('LIBRARY',line) > 0 then do
+        if word(line,2) = libname then do
+          sRealname = word(line,3)
+	  if word(line,4) <> '' then
+	    sInitTerm = 1
+	end
+        iterate
+      end
+      if word(line,1) = libname then do
+	name = word(line,2)
+	ordHash.name = word(line,3)
+      end
+    end      
+    rc = stream(dbfile,'c','close')
+    return rc
+
+/**
+ * Display script syntax.
+ */
+syntax: procedure
+    say 'Syntax: MakeDef.cmd [options] <dbfile> <libname> [options]'
+    say '   <dbfile>   Ordinals database.'
+    say '   <libname>  Library stem'
+    say 'Options:'
+    say '   -A<string>  ASD Feature Id.'
+    say '   -C<string>  Country code.'
+    say '   -D<string>  Description.'
+    say '   -O<string>  Ordinals definition file.'    
+    say '   -R[deffile] Read description from .def file.'
+    say '   -H<string>  Hostname.'
+    say '   -L<string>  Language code.'
+    say '   -M<string>  MiniVer.'
+    say '   -N<string>  Vendor.'
+    say '   -P<string>  Fixpak version.'
+    say '   -T<string>  Date Time.'
+    say '   -V<string>  Version.'
+    say '<string> could be a double quoted string or a single word.'
+    say '       You could also reference #defines in C/C++ include files.'
+    say '       The string should then have this form:'
+    say '           "#define=<DEFINE_NAME>,<includefile.h>"'
+    say '';
+
+    return;
+
+
+/**
+ * Search for a #define in an C/C++ header or source file.
+ *
+ * @returns String containing the defined value
+ *          found for the define in the header file.
+ *          Quits on fatal errors.
+ * @param   A string on the form: "#define=DEFINETOFIND,includefile.h"
+ * @remark  Write only code... - let's hope it works.
+ */
+LookupDefine: procedure
+    parse arg '#'sDefine'='sMacro','sIncludeFile
+
+    /*
+     * Validate parameters.
+     */
+    sMacro = strip(sMacro);
+    sIncludeFile = strip(sIncludeFile);
+    if (sMacro = '') then
+    do
+        say 'syntax error: #define=<DEFINE_NAME>,<includefile.h>.';
+        say '    <DEFINE_NAME> was empty.';
+        exit(-20);
+    end
+    if (sIncludeFile = '') then
+    do
+        say 'syntax error: #define=<DEFINE_NAME>,<includefile.h>.';
+        say '    <includefile.h> was empty.';
+        exit(-20);
+    end
+
+
+    sIllegal = translate(translate(sMacro),,
+                         '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!',,
+                         'ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890_');
+
+    if (strip(translate(sIllegal, ' ', '!')) <> '') then
+    do
+        say 'syntax error: #define=<DEFINE_NAME>,<includefile.h>.';
+        say '    <DEFINE_NAME> contains illegal charater(s).'
+        say '        'sMacro;
+        say '        'translate(sIllegal, ' ', '!');
+        exit(-20);
+    end
+
+    /*
+     * Open include file.
+     */
+    sRc = stream(sIncludeFile, 'c', 'open read');
+    if (pos('READY', sRc) <> 1) then
+    do  /* search INCLUDE variable */
+        sFile = SysSearchPath('INCLUDE', sIncludeFile);
+        if (sFile = '') then
+        do
+            say 'Can''t find include file 'sIncludeFile'.';
+            exit(-20);
+        end
+        sIncludeFile = sFile;
+
+        sRc = stream(sIncludeFile, 'c', 'open read');
+        if (pos('READY', sRc) <> 1) then
+        do
+            say 'Failed to open include file' sIncludeFile'.';
+            exit(-20);
+        end
+    end
+
+    /*
+     * Search the file line by line.
+     *  We'll check for lines starting with a hash (#) char.
+     *  Then check that the word after the hash is 'define'.
+     *  Then match the next word with the macro name.
+     *  Then then get the next rest of the line to comment or continuation char.
+     *      (continuation is not supported)
+     *  Finally strip quotes.
+     */
+    sValue = '';
+    do while (lines(sIncludeFile) > 0)
+        sLine = strip(linein(sIncludeFile));
+        if (sLine = '') then
+            iterate;
+        if (substr(sLine, 1, 1) <> '#') then
+            iterate;
+        sLine = substr(sLine, 2);
+        if (word(sLine, 1) <> 'define') then
+            iterate;
+        sLine = strip(substr(sLine, wordpos(sLine, 1) + length('define')+1));
+        if (  substr(sLine, 1, length(sMacro)) <> sMacro,
+            | substr(sLine, length(sMacro)+1, 1) <> ' ') then
+            iterate;
+        sLine = strip(substr(sLine, length(sMacro) + 1));
+        if (sLine = '') then
+        do
+            say 'error: #define' sMacro' is empty.';
+            call stream sIncludeFile, 'c', 'close';
+            exit(-20);
+        end
+
+        chQuote = substr(sLine, 1, 1);
+        if (chQuote = '"' | chQuote = "'") then
+        do  /* quoted string */
+            iLastQuote = 0;
+            do forever
+                iLast = pos(chQuote, sLine, 2);
+                if (iLast <= 0) then
+                    leave;
+                if (substr(sLine, iLast, 1) = '\') then
+                    iterate;
+                iLastQuote = iLast;
+                leave;
+            end
+
+            if (iLastQuote <= 0) then
+            do
+                say 'C/C++ syntax error in 'sIncludefile': didn''t find end quote.';
+                call stream sIncludeFile, 'c', 'close';
+                exit(-20);
+            end
+
+            call stream sIncludeFile, 'c', 'close';
+            sValue = substr(sLine, 2, iLastQuote - 2);
+            say 'Found 'sMacro'='sValue;
+            return sValue;
+        end
+        else
+        do
+            iCommentCPP = pos('//',sLine);
+            iCommentC   = pos('/*',sLine);
+            if (iCommentC > 0 & iCommentCPP > 0 & iCommentC > iCommentCPP) then
+                iComment = iCommentCPP;
+            else if (iCommentC > 0 & iCommentCPP > 0 & iCommentC < iCommentCPP) then
+                iComment = iCommentC;
+            else if (iCommentCPP > 0) then
+                iComment = iCommentCPP;
+            else if (iCommentC > 0) then
+                iComment = iCommentC;
+            else
+                iComment = 0;
+
+            if (iComment > 0) then
+                sValue = strip(substr(sLine, 1, iComment-1));
+            else
+                sValue = strip(sLine);
+
+            if (sValue <> '') then
+            do
+                if (substr(sValue, length(sValue)) = '\') then
+                do
+                    say 'Found continuation char: Multiline definitions are not supported!\n';
+                    call stream sIncludeFile, 'c', 'close';
+                    exit(-20);
+                end
+            end
+
+            if (sValue = '') then
+                say 'warning: The #define has no value.';
+
+            call stream sIncludeFile, 'c', 'close';
+            say 'Found 'sMacro'='sValue;
+            return sValue;
+        end
+    end
+
+    call stream sIncludeFile, 'c', 'close';
+    say 'error: didn''t find #define' sMacro'.';
+    exit(-20);
+
+
+
+/**
+ * Reads the description line for a .def-file.
+ * @returns The Description string, with quotes removed.
+ *          Empty string is acceptable.
+ *          On error we'll terminate the script.
+ * @param   sDefFile    Filename of .def-file to read the description from.
+ * @param   sDefFile2   Used if sDefFile is empty.
+ * @author  knut st. osmundsen (knut.stange.osmundsen@mynd.no)
+ */
+ReadDescription: procedure;
+    parse arg sDefFile, sDefFile2
+
+    /*
+     * Validate parameters.
+     */
+    if (sDefFile = '') then
+        sDefFile = sDefFile2;
+    if (sDefFile = '') then
+    do
+        say 'error: no definition file to get description from.'
+        exit(-1);
+    end
+
+    /*
+     * Open file
+     */
+    rc = stream(sDefFile, 'c', 'open read');
+    if (pos('READY', rc) <> 1) then
+    do
+        say 'error: failed to open deffile file.';
+        exit(-1);
+    end
+
+
+    /*
+     * Search for the 'DESCRIPTION' line.
+     */
+    do while (lines(sDefFile) > 0)
+        sLine = strip(linein(sDefFile));
+        if (sLine = '') then
+            iterate;
+        if (translate(word(sLine, 1)) <> 'DESCRIPTION') then
+            iterate;
+        sLine = strip(substr(sLine, wordpos(sLine, 1) + length('DESCRIPTION')+1));
+
+        ch = substr(sLine, 1, 1);
+        if (ch <> "'" & ch <> '"') then
+        do
+            say 'syntax error: description line in' sDefFile 'is misformed.';
+            call stream sDefFile, 'c', 'close';
+            exit(-10);
+        end
+
+        iEnd = pos(ch, sLine, 2);
+        if (iEnd <= 0) then
+        do
+            say 'syntax error: description line in' sDefFile 'is misformed.';
+            call stream sDefFile, 'c', 'close';
+            exit(-10);
+        end
+
+        call stream sDefFile, 'c', 'close';
+        sValue = substr(sLine, 2, iEnd - 2);
+        say 'Found Description:' sValue;
+        return sValue;
+    end
+
+    call stream sDefFile, 'c', 'close';
+    say 'info: Didn''t find description line in' sDefFile'.';
+    return '';
+
+AddCodeDataSection: procedure 
+    parse arg outfile;
+    call lineout outfile,"CODE PRELOAD";
+    call lineout outfile,"DATA MULTIPLE NONSHARED";
+    return '';
+     
+findOrdinal: procedure expose ordHash.
+    parse arg line,sOrdinal;
+    line = strip(line,,'	');
+    line = word(translate(strip(line),' ','='),1)
+    if (sOrdinal) then do
+        ordinal = ordHash.line;
+        if (ordinal = 'ORDHASH.'line) then do
+            say 'Oops: DB lacks ordinal for symbol "'line'" Create one!'
+            return '	'line
+        end
+        else
+            return '	'line' @ 'ordinal
+    end
+    else
+      return '	'line
+/**
+ * This is a function which reads sLibrary into an
+ * internal array and changes the DESCRIPTION text if found.
+ * If DESCRIPTION isn't found, it is added at the end.
+ * The array is written to sDBFile.
+ * @returns 0 on succes.
+ *          Errorcode on error.
+ * @param   sLibrary	library stem
+ * @param   sDescription    New description string.
+ * @param   sRealname	real 8.3 name of library
+ * @param   sOrdinals	flag to denote generation of ordinals
+ * @param   sInitTerm	flag to denote adding INITINSTANCE/TERM... qualifiers
+ * @author  knut st. osmundsen (knut.stange.osmundsen@mynd.no)
+ * @author  heavily modified by Platon & Holger
+ */
+UpdateDefFile: procedure expose ordHash.;
+    parse arg sLibrary, sDescription, sRealname, sOrdinals, sInitTerm
+
+    initterm = ''
+    if sInitTerm = 1 then initterm = 'INITINSTANCE TERMINSTANCE'
+
+    /* Open input file. */
+    infile = 'tmpos2.def'
+    rc = stream(infile, 'c', 'open read');
+    if (pos('READY', rc) <> 1) then do
+        say 'error: failed to open' infile 'file.';
+        return 110;
+    end
+    /* open output file. */
+    if sOrdinals = 1 then
+      outfile = sLibrary'o_os2.def'
+    else
+      outfile = sLibrary'os2.def'
+    call SysFileDelete(outfile)
+    rc = stream(outfile, 'c', 'open write');
+    if (pos('READY', rc) <> 1) then do
+        say 'error: failed to open outputfile' outfile 'file.';
+        return 110;
+    end
+    call lineout outfile, '; Created by makedef.cmd on' date() time()'. Do not edit.', 1;
+ 
+    /*
+     * Search for the specific lines.
+     */
+    fDescription = 0;
+    fExports = 0;
+    fWinLib = 0;
+    do while (lines(infile) > 0)
+	line = strip(linein(infile));
+        line = strip(line,,'	');
+	if line = '' then iterate;
+	if pos('#',line) = 1 then iterate;
+	if pos(';',line) = 1 then iterate;	
+	if pos('/*',line) = 1 then iterate;
+        
+	firstsym = translate(word(line,1))
+	if firstsym = 'LIBRARY' then do
+	    call lineout outfile,'LIBRARY 'sRealName' 'initterm
+	    iterate
+	end
+        if firstsym = 'VERSION' then do
+          call lineout outfile, 'DESCRIPTION "'sDescription sRealName'"'
+          fDescription = 1;
+          AddCodeDataSection(outfile);
+	end   
+       	if (firstsym = 'EXPORTS') then do
+	  call lineout outfile,'EXPORTS'
+          fExports = 1;
+	  iterate;
+	end   
+        if (fExports) then do
+          call lineout outfile, findOrdinal(line,sOrdinals);
+          iterate;
+        end
+    end
+
+    /*
+     * Add description is none was found.
+     */
+    if (\fDescription) then
+    do
+        call lineout outfile,"DESCRIPTION '"||sDescription libName||"'";
+        AddCodeDataSection(outfile);
+    end
+
+    /*
+     * Close input file and open output file.
+     */
+    call stream outfile, 'c', 'close';
+    call stream infile, 'c', 'close';
+    return 0;
+
Index: xc/config/util/mergelib.cpp
diff -u xc/config/util/mergelib.cpp:1.2 xc/config/util/mergelib.cpp:1.3
--- xc/config/util/mergelib.cpp:1.2	Fri Dec 14 14:53:22 2001
+++ xc/config/util/mergelib.cpp	Mon Nov 25 09:04:48 2002
@@ -61,9 +61,14 @@
 tmpdir=tmp.$$
 origdir=..
 
+XCOMM Remove directory if we fail
+trap "rm -rf $tmpdir; exit 1" 1 2 15
+trap "rm -rf $tmpdir; exit 0" 1 2 13
+
 mkdir $tmpdir
 
-if [ ! -d $tmpdir ]; then
+XCOMM Security: if $tmpdir exists before mkdir exit immediately
+if [ $? -gt 0 -o ! -d $tmpdir ]; then
     echo "$0:  unable to create temporary directory $tmpdir" 1>&2
     exit 1
 fi
@@ -83,7 +88,7 @@
 XCOMM In the temp directory, extract all of the object files and prefix
 XCOMM them with some symbol to avoid name clashes with the base library.
 XCOMM
-cd $tmpdir
+cd $tmpdir || exit 1
 ar x ${upfrom}$fromlib
 for i in *.o; do
     mv $i ${objprefix}$i
@@ -97,6 +102,4 @@
 RANLIB ${upto}$tolib
 cd $origdir
 rm -rf $tmpdir
-
-
 
Index: xc/config/util/mergelib.man
diff -u /dev/null xc/config/util/mergelib.man:1.1
--- /dev/null	Thu Feb 27 12:13:07 2003
+++ xc/config/util/mergelib.man	Sat Oct 12 12:06:40 2002
@@ -0,0 +1,25 @@
+.TH mergelib 1 __xorgversion__
+.SH NAME
+mergelib \- merge one library into another
+.SH SYNOPSIS
+.B mergelib
+.I to-library
+.I from-library
+.RI [ object-filename-prefix ]
+.SH DESCRIPTION
+The
+.I mergelib
+program merges objects from one library into another.
+The names of object files in
+.I from-library
+will be prefixed by
+.I object-filename-prefix
+(\(oq_\(cq by default) to avoid name clashes.
+The merged library will be left in
+.IR to-library .
+.SH AUTHOR
+Jim Fulton wrote the
+.I mergelib
+program for the X Consortium.
+.PP
+Colin Watson wrote this manual page, originally for the Debian Project.
Index: xc/config/util/mkdirhier.c
diff -u xc/config/util/mkdirhier.c:1.5 xc/config/util/mkdirhier.c:1.7
--- xc/config/util/mkdirhier.c:1.5	Fri Dec 14 14:53:22 2001
+++ xc/config/util/mkdirhier.c	Sun Jun 30 22:25:51 2002
@@ -26,14 +26,19 @@
 from The Open Group.
 
 */
+/* $XFree86: xc/config/util/mkdirhier.c,v 1.7 2002/07/01 02:25:51 tsi Exp $ */
 
 /*
  * Simple mkdirhier program for Windows NT
  */
 #include <sys/types.h>
 #include <sys/stat.h>
+#ifndef __UNIXOS2__
 #include <direct.h>
-#include <stdlib.h>
+#else
+#include <dirent.h>
+#endif
+#include <stdlib.h>
 #include <string.h>
 
 char *
Index: xc/config/util/mkdirhier.sh
diff -u xc/config/util/mkdirhier.sh:1.1.1.2 xc/config/util/mkdirhier.sh:1.2
--- xc/config/util/mkdirhier.sh:1.1.1.2	Tue Jan 16 16:54:48 2001
+++ xc/config/util/mkdirhier.sh	Mon Nov 25 09:04:48 2002
@@ -51,7 +51,7 @@
 			paths=$path
 			for filename
 			do
-				if [ "$filename" != "." ]; then
+				if [ -n "$filename" -a "$filename" != "." ]; then
 					path=$path/$filename
 					paths=$paths$newline$path
 				fi
Index: xc/config/util/mkhtmlindex.man
diff -u /dev/null xc/config/util/mkhtmlindex.man:1.1
--- /dev/null	Thu Feb 27 12:13:07 2003
+++ xc/config/util/mkhtmlindex.man	Sat Oct 12 12:06:40 2002
@@ -0,0 +1,32 @@
+.TH mkhtmlindex 1 __vendorversion__
+.SH NAME
+mkhtmlindex \- generate index files for HTML man pages
+.SH SYNOPSIS
+.B mkhtmlindex
+.I htmlmandir
+.SH DESCRIPTION
+The
+.I mkhtmlindex
+program generates index files for a directory of HTML-formatted manual
+pages.
+It searches for files whose names are of the form \(lqname.1.html\(rq,
+and outputs index files \(lqmanindex1.html\(rq, \(lqmanindex.2.html\(rq,
+and so on, one for each manual volume.
+Empty index files will be removed.
+Names and descriptions are found by scanning the first
+.I <H2>
+section of each page.
+.SH OPTIONS
+.I mkhtmlindex
+takes only one argument: the directory to process.
+.SH NOTES
+This utility is currently rather specific to XFree86.
+In particular, the format of the index files it outputs is not configurable,
+nor is the HTML formatting it expects of manual pages.
+.SH AUTHOR
+.PP
+David Dawes wrote the
+.I mkhtmlindex
+program for XFree86.
+.PP
+Colin Watson wrote this manual page, originally for the Debian Project.
Index: xc/config/util/os2inst.cmd
diff -u xc/config/util/os2inst.cmd:3.1 xc/config/util/os2inst.cmd:removed
--- xc/config/util/os2inst.cmd:3.1	Mon Feb 19 07:16:52 1996
+++ xc/config/util/os2inst.cmd	Thu Feb 27 12:13:07 2003
@@ -1,50 +0,0 @@
-/* OS/2 REXX SCRIPT */
-
-/* $XFree86: xc/config/util/os2inst.cmd,v 3.1 1996/02/19 12:16:52 dawes Exp $
- *
- * This is a wrapper for the install command. As any utility, 
- * install could have been lifted from the BSD sources, but I just wanted
- * to play with Rexx a bit :-)  (hv)
- * Note the similarity to the Unix shell scripts
- */
-
-dst=""
-src=""
-
-'@ECHO OFF'
-PARSE ARG all
-DO i=1 TO WORDS(all)
-	w = WORD(all,i)
-	SELECT
-	WHEN w = "-c" THEN NOP
-	WHEN w = "-m" THEN
-		i = i + 1
-		/* ignore mode */
-	WHEN w = "-o" THEN
-		i = i + 1
-		/* ignore owner */
-	WHEN w = "-g" THEN
-		i = i + 1
-		/* ignore group */
-	WHEN w = "-s" THEN NOP
-	OTHERWISE
-		IF src = "" THEN
-			src = w
-		ELSE
-			dst = w
-	END
-END
-
-IF src = "" THEN DO
-	SAY "os2inst:  no input file specified"
-	EXIT 1
-END
-
-IF dst = "" THEN DO
-	SAY "os2inst:  no destination specified"
-	EXIT 1
-END
-
-ADDRESS CMD 'copy' src dst '> nul'
-
-EXIT
Index: xc/config/util/printver.c
diff -u /dev/null xc/config/util/printver.c:1.2
--- /dev/null	Thu Feb 27 12:13:07 2003
+++ xc/config/util/printver.c	Wed Feb 26 04:21:33 2003
@@ -0,0 +1,27 @@
+
+/*
+ * A simple program to make it possible to print the XFree86 version and
+ * date info as defined in xf86Version.h and xf86Date.h very early in the
+ * build process.
+ */
+
+/* $XFree86: xc/config/util/printver.c,v 1.2 2003/02/26 09:21:33 dawes Exp $ */
+
+#include <stdio.h>
+#include "xf86Version.h"
+#include "xf86Date.h"
+
+main()
+{
+#ifdef XF86_VERSION_MAJOR
+	printf(" version %d.%d.%d", XF86_VERSION_MAJOR, XF86_VERSION_MINOR,
+		XF86_VERSION_PATCH);
+	if (XF86_VERSION_SNAP != 0)
+		printf(".%d", XF86_VERSION_SNAP);
+#ifdef XF86_DATE
+	printf(" (%s)", XF86_DATE);
+#endif
+#endif
+	exit(0);
+}
+
Index: xc/config/util/remove.cmd
diff -u xc/config/util/remove.cmd:3.0 xc/config/util/remove.cmd:removed
--- xc/config/util/remove.cmd:3.0	Thu Oct 20 02:01:04 1994
+++ xc/config/util/remove.cmd	Thu Feb 27 12:13:07 2003
@@ -1,14 +0,0 @@
-/* OS/2 REXX script to remove cleaned files
- * run with 'remove dirlist_file'
- * where dirlist_file is be a XFree86 removed-* file
- *
- * $XFree86: xc/config/util/remove.cmd,v 3.0 1994/10/20 06:01:04 dawes Exp $
- */
-'@echo off'
-file = arg(1)
-linein(file,1,0)
-curdir = directory()
-do while lines(file)=1
-  fs = translate(linein(file),'\','/')
-  del fs
-end
Index: xc/config/util/xmkmf.cmd
diff -u xc/config/util/xmkmf.cmd:3.1 xc/config/util/xmkmf.cmd:removed
--- xc/config/util/xmkmf.cmd:3.1	Mon Apr 15 07:14:27 1996
+++ xc/config/util/xmkmf.cmd	Thu Feb 27 12:13:08 2003
@@ -1,81 +0,0 @@
-/* OS/2 REXX */
-/* make a Makefile from an Imakefile from inside or outside the sources
- * 
- * $XFree86: xc/config/util/xmkmf.cmd,v 3.1 1996/04/15 11:14:27 dawes Exp $
- */
-'@ECHO OFF'
-
-/* this is actually used here */
-x11root = getenv('X11ROOT')
-
-/* these ones are checked only, because later scripts rely on their existance */
-libpath = getenv('LIBRARY_PATH')
-incpath = getenv('C_INCLUDE_PATH')
-
-/* get args */
-PARSE ARG arg0 arg1 arg2 arg3
-
-/* from here almost everything is the same as in the xmkmf sh script */
-topdir = ''
-curdir = '.'
-do_all = 0
-
-IF arg0 = '-a' THEN DO
-	do_all = 1
-	arg0 = arg1
-	arg1 = arg2
-	arg2 = arg3
-END
-ELSE DO
-	do_all = 0
-END
-
-IF \(arg0 = '') THEN DO
-	IF \(arg1 = '') THEN
-		curdir = arg1
-	topdir = arg0
-END
-IF \(arg2 = '') | SUBSTR(topdir,1,1) = '-' THEN DO
-	SAY 'usage:  xmkmf [-a] [top_of_sources_pathname [current_directory]]'
-	EXIT
-END
-
-IF exists('Makefile') THEN DO
-	SAY 'mv -f Makefile Makefile.bak'
-	'COPY Makefile Makefile.bak >nul 2>&1'
-	'DEL Makefile >nul 2>&1'
-END
-
-IF topdir = '' THEN
-	iargs = '-DUseInstalled -I'x11root'/XFree86/lib/X11/config'
-ELSE
-	iargs = '-I'topdir'/config/cf -DTOPDIR='topdir' -DCURDIR='curdir
-
-SAY 'imake 'iargs
-IF do_all = 1 THEN DO
-	'imake 'iargs
-	SAY 'make Makefiles'
-	CALL make 'Makefiles'
-	SAY 'make includes'
-	CALL make 'includes'
-	SAY 'make depend'
-	CALL make 'depend'
-END
-ELSE
-	'imake 'iargs
-
-EXIT
-
-exists:
-'DIR "'ARG(1)'" > nul 2>nul'
-IF rc = 0 THEN RETURN 1
-RETURN 0
-
-getenv:
-x = VALUE(ARG(1),,'OS2ENVIRONMENT')
-
-IF x = '' THEN DO
-	SAY 'No 'ARG(1)' environment variable set!'
-	EXIT
-END
-RETURN x
Index: xc/doc/man/X11/Imakefile
diff -u xc/doc/man/X11/Imakefile:1.4 xc/doc/man/X11/Imakefile:1.5
--- xc/doc/man/X11/Imakefile:1.4	Sun Dec 16 22:04:40 2001
+++ xc/doc/man/X11/Imakefile	Sat Feb 15 12:48:39 2003
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/doc/man/X11/Imakefile,v 1.4 2001/12/17 03:04:40 dawes Exp $
+XCOMM $XFree86: xc/doc/man/X11/Imakefile,v 1.5 2003/02/15 17:48:39 dawes Exp $
 
 MANDIR = $(LIBMANDIR)
 MANSUFFIX = $(LIBMANSUFFIX)
@@ -157,7 +157,7 @@
 InstallManPageLong(XLoadFont,$(MANDIR),XLoadFont)
 InstallManPageAliases(XLoadFont,$(MANDIR),XQueryFont XLoadQueryFont XFreeFont XGetFontProperty XUnloadFont XCharStruct XFontProp XChar2b XFontStruct)
 InstallManPageLong(XLookKsym,$(MANDIR),XLookupKeysym)
-InstallManPageAliases(XLookupKeysym,$(MANDIR),XRefreshKeyboardMapping XLookupString XRebindKeySym)
+InstallManPageAliases(XLookupKeysym,$(MANDIR),XRefreshKeyboardMapping XLookupString XRebindKeysym)
 InstallManPageLong(XMDBases,$(MANDIR),XrmMergeDatabases)
 InstallManPageAliases(XrmMergeDatabases,$(MANDIR),XrmCombineDatabase XrmCombineFileDatabase)
 InstallManPageLong(XMEvent,$(MANDIR),XMapEvent)
Index: xc/doc/man/X11/XLookKsym.man
diff -u xc/doc/man/X11/XLookKsym.man:1.3 xc/doc/man/X11/XLookKsym.man:1.4
--- xc/doc/man/X11/XLookKsym.man:1.3	Thu Feb  8 22:47:45 2001
+++ xc/doc/man/X11/XLookKsym.man	Sat Feb 15 12:48:39 2003
@@ -40,7 +40,7 @@
 .\" of this documentation for any purpose.
 .\" It is provided ``as is'' without express or implied warranty.
 .\" 
-.\" $XFree86: xc/doc/man/X11/XLookKsym.man,v 1.3 2001/02/09 03:47:45 tsi Exp $
+.\" $XFree86: xc/doc/man/X11/XLookKsym.man,v 1.4 2003/02/15 17:48:39 dawes Exp $
 .\"
 .ds xT X Toolkit Intrinsics \- C Language Interface
 .ds xW Athena X Widgets \- C Language X Toolkit Interface
@@ -142,7 +142,7 @@
 .ny0
 .TH XLookupKeysym 3X11 __xorgversion__ "XLIB FUNCTIONS"
 .SH NAME
-XLookupKeysym, XRefreshKeyboardMapping, XLookupString, XRebindKeySym \- handle keyboard input events in Latin-1
+XLookupKeysym, XRefreshKeyboardMapping, XLookupString, XRebindKeysym \- handle keyboard input events in Latin-1
 .SH SYNTAX
 KeySym XLookupKeysym(\^\fIkey_event\fP, \fIindex\fP\^)
 .br
Index: xc/doc/man/X11/XmbDStr.man
diff -u xc/doc/man/X11/XmbDStr.man:1.3 xc/doc/man/X11/XmbDStr.man:1.4
--- xc/doc/man/X11/XmbDStr.man:1.3	Sat Jan 27 13:20:07 2001
+++ xc/doc/man/X11/XmbDStr.man	Tue Apr 30 12:45:02 2002
@@ -41,7 +41,7 @@
 .\" of this documentation for any purpose.
 .\" It is provided ``as is'' without express or implied warranty.
 .\"
-.\" $XFree86: xc/doc/man/X11/XmbDStr.man,v 1.3 2001/01/27 18:20:07 dawes Exp $
+.\" $XFree86: xc/doc/man/X11/XmbDStr.man,v 1.4 2002/04/30 16:45:02 tsi Exp $
 .\" 
 .ds xT X Toolkit Intrinsics \- C Language Interface
 .ds xW Athena X Widgets \- C Language X Toolkit Interface
@@ -177,7 +177,7 @@
 .br
       int \fInum_wchars\fP\^;
 .LP
-void Xuf8DrawString\^(\^\fIdisplay\fP\^, \fId\fP\^, \fIfont_set\fP\^, \fIgc\fP\^, \fIx\fP\^, \fIy\fP\^, \fIstring\fP\^, \fInum_bytes\fP\^)
+void Xutf8DrawString\^(\^\fIdisplay\fP\^, \fId\fP\^, \fIfont_set\fP\^, \fIgc\fP\^, \fIx\fP\^, \fIy\fP\^, \fIstring\fP\^, \fInum_bytes\fP\^)
 .br
       Display *\fIdisplay\fP\^;
 .br
Index: xc/doc/man/Xt/XtFindF.man
diff -u xc/doc/man/Xt/XtFindF.man:1.3 xc/doc/man/Xt/XtFindF.man:1.4
--- xc/doc/man/Xt/XtFindF.man:1.3	Thu Feb  8 22:47:50 2001
+++ xc/doc/man/Xt/XtFindF.man	Sat Oct 12 12:06:41 2002
@@ -25,7 +25,7 @@
 .\" dealing in this Software without prior written authorization from the 
 .\" X Consortium.
 .\"
-.\" $XFree86: xc/doc/man/Xt/XtFindF.man,v 1.3 2001/02/09 03:47:50 tsi Exp $
+.\" $XFree86: xc/doc/man/Xt/XtFindF.man,v 1.4 2002/10/12 16:06:41 herrb Exp $
 .\"
 .ds tk X Toolkit
 .ds xT X Toolkit Intrinsics \- C Language Interface
@@ -159,7 +159,7 @@
 character that does not introduce a substitution; the sequence is
 replaced by a single percent character.  If a percent character is
 followed by any other character,
-.PN XtFindFile
+.ZN XtFindFile
 looks through the
 specified \fIsubstitutions\fP for that character in the \fImatch\fP field and if
 found replaces the percent and match characters with the string in the
@@ -167,29 +167,29 @@
 is equivalent to a pointer to an empty string.  If the operating
 system does not interpret multiple embedded name separators in the
 path (i.e., ``/'' in POSIX) the same way as a single separator,
-.PN XtFindFile
+.ZN XtFindFile
 will collapse multiple separators into a single one after performing
 all string substitutions.  Except for collapsing embedded separators,
 the contents of the string substitutions are not interpreted by
-.PN XtFindFile
+.ZN XtFindFile
 and may therefore contain any operating-system-dependent
 characters, including additional name separators.  Each resulting
 string is passed to the predicate procedure until a string is found for
 which the procedure returns
-.PN True ;
+.ZN True ;
 this string is the return value for
-.PN XtFindFile .
+.ZN XtFindFile .
 If no string yields a
-.PN True
+.ZN True
 return from the predicate,
-.PN XtFindFile
+.ZN XtFindFile
 returns NULL.
 .LP
 If the \fIpredicate\fP parameter is NULL, an internal procedure that checks
 if the file exists, is readable, and is not a directory will be used.
 .LP
 It is the responsibility of the caller to free the returned string using
-.PN XtFree
+.ZN XtFree
 when it is no longer needed.
 .SH "SEE ALSO"
 .br
Index: xc/doc/man/Xt/XtResPath.man
diff -u xc/doc/man/Xt/XtResPath.man:1.3 xc/doc/man/Xt/XtResPath.man:1.4
--- xc/doc/man/Xt/XtResPath.man:1.3	Thu Feb  8 22:47:52 2001
+++ xc/doc/man/Xt/XtResPath.man	Sat Oct 12 12:06:41 2002
@@ -25,7 +25,7 @@
 .\" dealing in this Software without prior written authorization from the 
 .\" X Consortium.
 .\"
-.\" $XFree86: xc/doc/man/Xt/XtResPath.man,v 1.3 2001/02/09 03:47:52 tsi Exp $
+.\" $XFree86: xc/doc/man/Xt/XtResPath.man,v 1.4 2002/10/12 16:06:41 herrb Exp $
 .\"
 .ds tk X Toolkit
 .ds xT X Toolkit Intrinsics \- C Language Interface
@@ -247,22 +247,20 @@
 .LP
 A suggested value for the default path on POSIX-based systems is
 .IP
-<XRoot>/lib/X11/%L/%T/%N%C%S:<XRoot>/lib/X11/%l/%T/%N%C%S:\\
+__projectroot__/lib/X11/%L/%T/%N%C%S:__projectroot__/lib/X11/%l/%T/%N%C%S:\\
 .br
-<XRoot>/lib/X11/%T/%N%C%S:<XRoot>/lib/X11/%L/%T/%N%S:\\
+__projectroot__/lib/X11/%T/%N%C%S:__projectroot__/lib/X11/%L/%T/%N%S:\\
 .br
-<XRoot>/lib/X11/%l/%T/%N%S:<XRoot>/lib/X11/%T/%N%S
+__projectroot__/lib/X11/%l/%T/%N%S:__projectroot__/lib/X11/%T/%N%S
 .LP
-where <XRoot> is replaced by the root of the X11 installation tree
-(/usr/X11R6, for example).
-.LP
 Using this example, if the user has specified a language, it will be
-used as a subdirectory of <XRoot>/lib/X11 that will be searched for other
-files.  If the desired file is not found there, the lookup will be
-tried again using just the language part of the specification.  If the
-file is not there, it will be looked for in <XRoot>/lib/X11.  The \fItype\fP
-parameter is used as a subdirectory of the language directory or of
-<XRoot>/lib/X11, and \fIsuffix\fP is appended to the file name.
+used as a subdirectory of __projectroot__/lib/X11 that will be searched
+for other files.  If the desired file is not found there, the lookup
+will be tried again using just the language part of the specification.
+If the file is not there, it will be looked for in
+__projectroot__/lib/X11.  The \fItype\fP parameter is used as a
+subdirectory of the language directory or of __projectroot__/lib/X11,
+and \fIsuffix\fP is appended to the file name.
 .LP
 The %D substitution allows the addition of path
 elements to the implementation-specific default path, typically to
Index: xc/doc/man/Xt/XtSetKFoc.man
diff -u xc/doc/man/Xt/XtSetKFoc.man:1.2 xc/doc/man/Xt/XtSetKFoc.man:1.3
--- xc/doc/man/Xt/XtSetKFoc.man:1.2	Sat Jan 27 13:20:29 2001
+++ xc/doc/man/Xt/XtSetKFoc.man	Sat Oct 12 12:06:41 2002
@@ -26,7 +26,7 @@
 .\" other dealings in this Software without prior written authorization
 .\" from the X Consortium.
 .\"
-.\" $XFree86: xc/doc/man/Xt/XtSetKFoc.man,v 1.2 2001/01/27 18:20:29 dawes Exp $
+.\" $XFree86: xc/doc/man/Xt/XtSetKFoc.man,v 1.3 2002/10/12 16:06:41 herrb Exp $
 .\"
 .ds tk X Toolkit
 .ds xT X Toolkit Intrinsics \- C Language Interface
@@ -131,11 +131,11 @@
 .SH NAME
 XtSetKeyboardFocus \- focus events on a child widget
 .SH SYNTAX
-XtSetKeyboardFocus(\fIsubtree\fP\, \fIdescendant\fP)
+XtSetKeyboardFocus(\fIsubtree\fP, \fIdescendant\fP)
 .br
      Widget \fIsubtree\fP, \fIdescendant\fP;
 .SH ARGUMENTS
-.IP \fIdescendant\fP 1i
+.IP \fIsubtree\fP 1i
 Specifies either the widget in the subtree structure which is to receive the 
 keyboard event, or 
 .ZN None .
@@ -143,7 +143,7 @@
 .ZN None
 when no input focus was previously set.
 .ds Wi for which the keyboard focus is to be set
-.IP \fIw\fP 1i
+.IP \fIdescendant\fP 1i
 Specifies the widget \*(Wi.
 .SH DESCRIPTION
 If a future 
Index: xc/doc/man/general/X.man
diff -u xc/doc/man/general/X.man:1.7 xc/doc/man/general/X.man:1.8
--- xc/doc/man/general/X.man:1.7	Mon Oct  1 09:43:56 2001
+++ xc/doc/man/general/X.man	Sat Oct 12 12:06:41 2002
@@ -25,7 +25,7 @@
 .\" dealing in this Software without prior written authorization from the 
 .\" X Consortium.
 .\"
-.\" $XFree86: xc/doc/man/general/X.man,v 1.7 2001/10/01 13:43:56 eich Exp $
+.\" $XFree86: xc/doc/man/general/X.man,v 1.8 2002/10/12 16:06:41 herrb Exp $
 .\"
 .TH X __miscmansuffix__ __vendorversion__
 .SH NAME
@@ -505,8 +505,7 @@
 If the name is not found, the color is looked up in the
 X server's database.
 The text form of this database is commonly stored in the file
-\fI<XRoot>/lib/X11/rgb.txt\fP, where <XRoot> is replaced by the 
-root of the X11 install tree.
+\fI__projectroot__/lib/X11/rgb.txt\fP.
 .PP
 A numerical color specification
 consists of a color space name and a set of values in the following syntax:
@@ -877,11 +876,11 @@
 Directories named by the environment variable XUSERFILESEARCHPATH
 or the environment variable XAPPLRESDIR (which names a single
 directory and should end with a '/' on POSIX systems), plus directories in a
-standard place (usually under <XRoot>/lib/X11/,
+standard place (usually under __projectroot__/lib/X11/,
 but this can be overridden with the XFILESEARCHPATH environment variable)
 are searched for for application-specific resources.
 For example, application default resources are usually kept in
-<XRoot>/lib/X11/app-defaults/.
+__projectroot__/lib/X11/app-defaults/.
 See the \fIX Toolkit Intrinsics - C Language Interface\fP manual for
 details.
 .TP 8
@@ -1017,12 +1016,12 @@
 .B XLOCALEDIR
 This must point to a directory containing the locale.alias file and
 Compose and XLC_LOCALE file hierarchies for all locales. The default value
-is \fI<XRoot>/lib/X11/locale\fP, i.e. normally /usr/X11R6/lib/X11/locale.
+is \fI__projectroot__/lib/X11/locale\fP.
 .TP
 .SM
 .B XENVIRONMENT
 This must point to a file containing X resources. The default is
-\fI$HOME/.Xdefaults-<hostname>\fP. Unlike \fI<XRoot>/lib/X11/Xresources\fP,
+\fI$HOME/.Xdefaults-<hostname>\fP. Unlike \fI__projectroot__/lib/X11/Xresources\fP,
 it is consulted each time an X application starts.
 .TP
 .SM
@@ -1031,23 +1030,12 @@
 will search for resource files. The default value consists of
 .sp
 .nf
-    <XRoot>/lib/X11/%L/%T/%N%C%S:\\
-    <XRoot>/lib/X11/%l/%T/%N%C%S:\\
-    <XRoot>/lib/X11/%T/%N%C%S:\\
-    <XRoot>/lib/X11/%L/%T/%N%S:\\
-    <XRoot>/lib/X11/%l/%T/%N%S:\\
-    <XRoot>/lib/X11/%T/%N%S
-.fi
-.sp
-i.e. normally
-.sp
-.nf
-    /usr/X11R6/lib/X11/%L/%T/%N%C%S:\\
-    /usr/X11R6/lib/X11/%l/%T/%N%C%S:\\
-    /usr/X11R6/lib/X11/%T/%N%C%S:\\
-    /usr/X11R6/lib/X11/%L/%T/%N%S:\\
-    /usr/X11R6/lib/X11/%l/%T/%N%S:\\
-    /usr/X11R6/lib/X11/%T/%N%S
+    __projectroot__/lib/X11/%L/%T/%N%C%S:\\
+    __projectroot__/lib/X11/%l/%T/%N%C%S:\\
+    __projectroot__/lib/X11/%T/%N%C%S:\\
+    __projectroot__/lib/X11/%L/%T/%N%S:\\
+    __projectroot__/lib/X11/%l/%T/%N%S:\\
+    __projectroot__/lib/X11/%T/%N%S
 .fi
 .sp
 A path template is transformed to a pathname by substituting:
@@ -1106,19 +1094,17 @@
 .SM
 .B XKEYSYMDB
 This must point to a file containing nonstandard keysym definitions.
-The default value is \fI<XRoot>/lib/X11/XKeysymDB\fP, i.e. normally
-/usr/X11R6/lib/X11/XKeysymDB.
+The default value is \fI__projectroot__/lib/X11/XKeysymDB\fP.
 .TP
 .SM
 .B XCMSDB
 This must point to a color name database file. The default value is
-\fI<XRoot>/lib/X11/Xcms.txt\fP, i.e. normally /usr/X11R6/lib/X11/Xcms.txt.
+\fI__projectroot__/lib/X11/Xcms.txt\fP.
 .TP
 .SM
 .B XFT_CONFIG
 This must point to a configuration file for the Xft library. The default
-value is \fI<XRoot>/lib/X11/XftConfig\fP, i.e. normally
-/usr/X11R6/lib/X11/XftConfig.
+value is \fI__projectroot__/lib/X11/XftConfig\fP.
 .TP
 .SM
 .B RESOURCE_NAME
@@ -1199,8 +1185,9 @@
 A wide variety of error messages are generated from various programs.
 The default error handler in \fIXlib\fP (also used by many toolkits) uses
 standard resources to construct diagnostic messages when errors occur.  The
-defaults for these messages are usually stored in \fI<XRoot>/lib/X11/XErrorDB\fP.
-If this file is not present, error messages will be rather terse and cryptic.
+defaults for these messages are usually stored in
+\fI__projectroot__/lib/X11/XErrorDB\fP.  If this file is not present,
+error messages will be rather terse and cryptic.
 .PP
 When the X Toolkit Intrinsics encounter errors converting resource strings to
 the
Index: xc/doc/man/misc/Imakefile
diff -u xc/doc/man/misc/Imakefile:1.3 xc/doc/man/misc/Imakefile:1.4
--- xc/doc/man/misc/Imakefile:1.3	Wed Mar 28 09:11:13 2001
+++ xc/doc/man/misc/Imakefile	Tue Feb 25 16:16:08 2003
@@ -1,4 +1,4 @@
-XCOMM $XFree86: xc/doc/man/misc/Imakefile,v 1.3 2001/03/28 14:11:13 dawes Exp $
+XCOMM $XFree86: xc/doc/man/misc/Imakefile,v 1.4 2003/02/25 21:16:08 dawes Exp $
 
 /*
  * This Imakefile is intended to make it possible to install man pages
@@ -10,6 +10,7 @@
  * XFree86 Linux/sparc:	sunbw2, suncg14, suncg3, suncg6, sunffb, sunleo,
  *			suntcx
  * XFree86 Linux/ix86:	v4l, glide
+ * XFree86 Linux:       ur98
  * XFree86 Darwin:      XDarwin, dumpkeymap
  * XFree86 Kdrive:	Xkdrive, Xvesa, Xfbdev
  */
@@ -24,6 +25,7 @@
 InstallGenManPage(suntcx,$(DRIVERMANDIR),$(DRIVERMANSUFFIX))
 InstallGenManPage(v4l,$(DRIVERMANDIR),$(DRIVERMANSUFFIX))
 InstallGenManPage(glide,$(DRIVERMANDIR),$(DRIVERMANSUFFIX))
+InstallGenManPage(ur98,$(DRIVERMANDIR),$(DRIVERMANSUFFIX))
 InstallGenManPage(XDarwin,$(MANDIR),$(MANSUFFIX))
 InstallGenManPage(dumpkeymap,$(MANDIR),$(MANSUFFIX))
 InstallGenManPage(Xkdrive,$(MANDIR),$(MANSUFFIX))
@@ -40,6 +42,7 @@
 LinkSourceFile(suntcx.man,$(XF86DRIVERSRC)/suntcx)
 LinkSourceFile(v4l.man,$(XF86DRIVERSRC)/v4l)
 LinkSourceFile(glide.man,$(XF86DRIVERSRC)/glide)
+LinkSourceFile(ur98.man,$(XF86SRC)/input/ur98)
 LinkSourceFile(XDarwin.man,$(SERVERSRC)/hw/darwin)
 LinkSourceFile(dumpkeymap.man,$(SERVERSRC)/hw/darwin/utils)
 LinkSourceFile(Xkdrive.man,$(SERVERSRC)/hw/kdrive)
Index: xc/doc/specs/PEX5/PEX5.1/SI/Arch_Spec/Imakefile
diff -u xc/doc/specs/PEX5/PEX5.1/SI/Arch_Spec/Imakefile:1.1.1.2 xc/doc/specs/PEX5/PEX5.1/SI/Arch_Spec/Imakefile:1.2
--- xc/doc/specs/PEX5/PEX5.1/SI/Arch_Spec/Imakefile:1.1.1.2	Tue Jan 16 16:59:22 2001
+++ xc/doc/specs/PEX5/PEX5.1/SI/Arch_Spec/Imakefile	Tue Oct  8 19:07:43 2002
@@ -23,6 +23,8 @@
 XCOMM USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 XCOMM OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 XCOMM PERFORMANCE OF THIS SOFTWARE.
+XCOMM
+XCOMM $XFree86: xc/doc/specs/PEX5/PEX5.1/SI/Arch_Spec/Imakefile,v 1.2 2002/10/08 23:07:43 dawes Exp $
 
 DOCBIN=..
 
@@ -54,7 +56,7 @@
 index.PS:
 	grep '^\.IE' slush.file | \
 	(cat $(PEXMACROS) ; echo .UH INDEX ; $(INDEXER)) | \
-	$(TROFF) -rF1 -rM1 -rP`tail -1 slush.file` > index.PS 2>>slush.file
+	$(TROFF) -rF1 -rM1 -rP`sed -n '$$p' slush.file` > index.PS 2>>slush.file
 
 contents.PS:
 	(cat $(PEXMACROS) ; echo .UH CONTENTS ; \
@@ -63,11 +65,11 @@
 
 tables.PS:
 	(cat $(PEXMACROS) ; echo .UH TABLES; grep '^\.CE T' slush.file) | \
-	$(TROFF) -rF1 -rM1 -rP`tail -1 slush.file` >tables.PS 2>>slush.file
+	$(TROFF) -rF1 -rM1 -rP`sed -n '$$p' slush.file` >tables.PS 2>>slush.file
 
 figures.PS:
 	(cat $(PEXMACROS) ; echo .UH FIGURES; grep '^\.CE F' slush.file) | \
-	$(TROFF) -rF1 -rM1 -rP`tail -1 slush.file` >figures.PS 2>>slush.file
+	$(TROFF) -rF1 -rM1 -rP`sed -n '$$p' slush.file` >figures.PS 2>>slush.file
 
 cover.PS:
 	$(TROFF) $(MSMACROS) cover.irm > cover.PS
Index: xc/doc/specs/PEX5/PEX5.1/SI/User_Guide/Imakefile
diff -u xc/doc/specs/PEX5/PEX5.1/SI/User_Guide/Imakefile:1.1.1.2 xc/doc/specs/PEX5/PEX5.1/SI/User_Guide/Imakefile:1.2
--- xc/doc/specs/PEX5/PEX5.1/SI/User_Guide/Imakefile:1.1.1.2	Tue Jan 16 16:59:26 2001
+++ xc/doc/specs/PEX5/PEX5.1/SI/User_Guide/Imakefile	Tue Oct  8 19:07:43 2002
@@ -23,6 +23,8 @@
 XCOMM USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 XCOMM OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 XCOMM PERFORMANCE OF THIS SOFTWARE.
+XCOMM
+XCOMM $XFree86: xc/doc/specs/PEX5/PEX5.1/SI/User_Guide/Imakefile,v 1.2 2002/10/08 23:07:43 dawes Exp $
 
 PIC = pic
 
@@ -54,7 +56,7 @@
 index.PS:
 	grep '^\.IE' slush.file | \
 	(cat $(PEXMACROS) ; echo .UH INDEX ; $(INDEXER)) | \
-	$(TROFF) -rF1 -rM1 -rP`tail -1 slush.file` >index.PS 2>> slush.file
+	$(TROFF) -rF1 -rM1 -rP`sed -n '$$p' slush.file` >index.PS 2>> slush.file
 
 contents.PS:
 	(cat $(PEXMACROS) ; echo .UH CONTENTS ; \
@@ -63,11 +65,11 @@
 
 tables.PS:
 	(cat $(PEXMACROS) ; echo .UH TABLES; grep '^\.CE T' slush.file) | \
-	$(TROFF) -rF1 -rM1 -rP`tail -1 slush.file` >tables.PS 2>>slush.file
+	$(TROFF) -rF1 -rM1 -rP`sed -n '$$p' slush.file` >tables.PS 2>>slush.file
 
 figures.PS:
 	(cat $(PEXMACROS) ; echo .UH FIGURES; grep '^\.CE F' slush.file) | \
-	$(TROFF) -rF1 -rM1 -rP`tail -1 slush.file` >figures.PS 2>>slush.file
+	$(TROFF) -rF1 -rM1 -rP`sed -n '$$p'  slush.file` >figures.PS 2>>slush.file
 
 cover.PS:
 	$(TROFF) $(MSMACROS) cover.ug > cover.PS
Index: xc/doc/specs/Randr/protocol.txt
diff -u /dev/null xc/doc/specs/Randr/protocol.txt:1.2
--- /dev/null	Thu Feb 27 12:14:10 2003
+++ xc/doc/specs/Randr/protocol.txt	Mon Oct 14 14:01:39 2002
@@ -0,0 +1,519 @@
+	The X Resize, Rotate and Reflect Extension
+		      Version 1.0
+		      2002-10-4
+
+		      Jim Gettys
+	          Jim.Gettys@hp.com
+
+	            Keith Packard
+	         keithp@xfree86.org
+
+	     Cambridge Research Laboratory
+		      HP Labs
+	       Hewlett Packard Company
+
+1. Introduction
+
+The X Resize, Rotate and Reflect Extension, called RandR for short,
+brings the ability to resize, rotate and reflect the root window of a
+screen.  It is based on the X Resize and Rotate Extension as specified
+in the Proceedings of the 2001 Usenix Technical Conference [RANDR].
+
+RandR as implemented and integrated into the XFree86 server differs in
+one substantial fashion from the design discussed in that paper: that
+is, RandR 1.0 does not implement the depth switching described in that
+document, and the support described for that in the protocol in that
+document and in the XFree86 implementationhas been removed from the
+protocol described here, as it has been overtaken by events.
+
+These events include:
+      o Modern toolkits (in this case, GTK+ 2.x) have progressed to the point
+        of implementing migration between screens of arbitrary depths
+      o The continued advance of Moore's law has made limited amounts of VRAM
+        less of an issue, reducing the pressure to implement depth switching
+	on laptops or desktop systems
+      o The continued decline of legacy toolkits whose design would have
+        required depth switching to support migration
+      o The lack of depth switchin implementation experience in the 
+        intervening time, due to events beyond our control
+
+Additionally, the requirement to support depth switching might
+complicate other re-engineering of the device independent part of the
+X server that is currently being contemplated.
+	
+Rather than further delaying RandR's widespread deployment for a
+feature long wanted by the community (resizing of screens,
+particularly on laptops), or the deployment of a protocol design that
+might be flawed due to lack of implementation experience, we decided
+to remove depth switching from the protocol.  It may be implementated
+at a later time if resources and interests permit as a revision to the
+protocol described here, which will remain a stable base for
+applications.  The protocol described here has been implemented in the
+main XFree86 server, and more fully in the TinyX implementation in the
+XFree86 distribution, which fully implements resizing, rotation and
+reflection.
+
+2. Acknowlegements
+
+Our thanks to the contributors to the design found on the xpert mailing list.
+
+2. Screen change model
+
+Screens may change dynamically, either under control of this
+extension, or due to external events. Examples include: monitors being
+swapped, you pressing a button to switch from internal display to an
+external monitor on a laptop, or, eventually, the hotplug of a display
+card entirely on busses such as Cardbus which permit hot-swap (which
+will require other work in addition to this extension).
+
+Since the screen configuration is dynamic and asynchronous to the
+client and may change at any time RandR provides mechanisms to ensure
+that your clients view is up to date with the configuration
+possibilities of the moment and enforces applications that wish to
+control the configuration to prove that their information is up to
+date before honoring requests to change the screen configuration (by
+requiring a timestamp on the request).
+
+Interested applications are notified whenever the screen configuration
+changes, providing the current size of the screen and subpixel order
+(see the Render extension [RENDER]), to enabel proper rendering of
+subpixel decimated client text to continue, along with a time stamp of
+the configuration change.  A client must refresh its knowledge of the
+screen configuration before attempting to change the configuration
+after a notification, or the request will fail.
+
+To avoid multiplicative explosion between orientation, reflection
+and sizes, the sizes are only those sizes in the normal (0) rotation.
+
+Rotation and reflection and how they interact can be confusing.  In
+Randr, the coordinate system is rotated in a counter-clockwise
+direction relative to the normal orientation.  Reflection is along the
+window system coordinate system, not the physical screen X and Y axis,
+so that rotation and reflection do not interact.  The other way to
+consider reflection is to is specified in the "normal" orientation,
+before rotation, if you find the other way confusing.
+
+We expect that most clients and toolkits will be oblivious to changes
+to the screen stucture, as they generally use the values in the
+connections Display structure directly.  By toolkits updating the
+values on the fly, we believe pop-up menus and other pop up windows
+will position themselves correctly in the face of screen configuration
+changes (the issue is ensuring that pop-ups are visible on the
+reconfigured screen).
+
+3. Data Types
+
+The subpixel order is shared with the Render extension, and is
+documented there.  The only datatype defined is the screen size,
+defined in the normal (0 degree) orientation.
+
+
+4. Errors
+
+There are no new error types defined by this extension.
+
+5. Protocol Types
+
+ROTATION {
+	 RR_rotate_0
+	 RR_rotate_90
+	 RR_rotate_180
+	 RR_rotate_270
+	 RR-Reflect_X
+	 RR_Reflect_Y }
+
+RRSELECTMASK { RRScreenChangeNotifyMask }
+
+SIZEID { CARD16 }
+
+SUBPIXELORDER { SubPixelUnknown		The subpixel order uses the Render
+	      SubPixelHorizontalRGB	extensions definitions; they are here
+	      SubPixelHorizontalBGR	only for convenience.
+	      SubPixelVerticalRGB
+	      SubPixelVerticalBGR
+	      SubPixelNone }
+
+
+6. Extension Initialization
+
+The name of this extension is "RANDR".
+
+RRQueryVersion
+	client-major-version:	CARD32
+	client-minor-version:	CARD32
+	->
+	major-version:		CARD32
+	minor-version:		CARD32
+
+	The client sends the highest supported version to the server
+	and the server sends the highest version it supports, but no
+	higher than the requested version.  Major versions changes can
+	introduce incompatibilities in existing functionality, minor
+	version changes introduce only backward compatible changes.
+	It is the clients responsibility to ensure that the server
+	supports a version which is compatible with its expectations.
+
+7. Extension Requests
+
+RRSelectInput
+	window: WINDOW
+	enable: SETofRRSELECTMASK
+
+	Errors: BadWindow, BadValue
+
+	If enable is RRScreenChangeNotifyMask, RRScreenChangeNotify
+	events will be sent anytime the screen configuration changes,
+	either from this protocol extension, or due to detected
+	external screen configuration changes. RRScreenChangeNotify
+	may also be sent immediately if the screen configuration has
+	changed since the client connected, to avoid race conditions.
+
+RRSetScreenConfig
+	drawable: DRAWABLE
+	timestamp: TIMESTAMP
+	config-timestamp: TIMESTAMP
+	sizeID: SIZEID
+	rotation: ROTATION
+	rate: CARD16
+
+	->
+
+	new-timestamp: TIMESTAMP
+	config-timestamp: TIMESTAMP
+	root: WINDOW
+	subpixelOrder: SUBPIXELORDER
+
+	Errors: BadValue, BadMatch
+
+	If the timestamp in this request is less than the time when
+	the configuration was last successfully set, the request is
+	ignored and False returned in success.  If the
+	config-timestamp in this request is not equal to when the
+	server's screen configurations last changed, the request is
+	ignored and False returned in success.  This could occur if
+	the screen changed since you last made a RRGetScreenInfo
+	request, perhaps by a different piece of display hardware
+	being installed.  Rather than allowing an incorrect call to be
+	executed based on stale data, the server will ignore the
+	request.
+
+	If rate is zero, the server selects an appropriate rate.
+
+	If the request succeeds, this request sets the screen to the
+	specified size, rate, rotation and reflection. If the requests
+	succeeds, the new-time-stamp is returned containing the time
+	when the screen configuration was changed and config-timestamp
+	is returned to indicate when the possible screen
+	configurations were last changed, and success is set to True.
+	The root window for the screen indicated by the drawable
+	argument is also returned, along with the subpixel order, to
+	allow correct subpixel rendering.
+
+	BadValue errors are generated if the rotation is not an
+	allowed rotation. BadValue errors are generated, if, when the
+	timestamps would allow the operation to succeed, or size-index
+	are not possible (out of range).
+
+
+RRGetScreenInfo
+	window: WINDOW
+
+	->	
+
+	rotations: SETofROTATION
+	root: WINDOW
+	timestamp: TIMESTAMP
+	config-timestamp: TIMESTAMP
+	nSizes: CARD16
+	sizeID: SIZEID
+	rotation: ROTATION
+	rate: CARD16
+	sizes: LISTofSCREENSIZE
+	refresh: LISTofREFRESH
+
+	where:
+
+	SCREENSIZE {    
+		 widthInPixels, heightInPixels: CARD16
+		  widthInMillimeters, heightInMillimeters: CARD16 }
+
+	REFRESH {
+		rates: LISTofCARD16
+	}
+
+	Errors: BadWindow
+
+	This event is delivered to clients selecting for notification
+	with RRSelectInput requests using a RRScreenChangeNotifyMask.
+
+	Size-index indicates which size is active.  The returned
+	window is the window requsting notification.
+
+	This call returns the root window of the screen which has changed.
+
+	Rotations contains the set of rotations and reflections
+	supported by the screen of the window requested. The root
+	window of that screen is reported. The number of current sizes
+	supported is returned, along with which size rotation and
+	reflection the screen is currently set to.
+
+	The config-timestamp indicates when the screen configuration
+	information last changed: requests to set the screen will fail
+	unless the timestamp indicates that the information the client
+	is using is up to date, to ensure clients can be well behaved
+	in the face of race conditions. Similarly, timestamp indicates
+	when the configuration was last set, and must both must be up
+	to date in a call to RRSetScreenConfig for it to succeed.
+	
+	Rate is the current refresh rate.  This is zero when the refresh
+	rate is unknown or on devices for which refresh is not relevant.
+
+	Sizes is the list of possible frame buffer sizes (at the
+	normal orientation, each provide both the linear physical size
+	of the screen and the pixel size.
+
+	Refresh is the list of refresh rates for each size, each element
+	of sizes has a cooresponding element in refresh.  An empty list
+	indicates no known rates, or a device for which refresh is not
+	relevant.
+
+	The default size of the screen (the size that would become the
+	current size when the server resets) is the first size in the
+	list.  The potential screen sizes themselves are also
+	returned.
+
+	Toolkits SHOULD use RRScreenChangeSelectInput to be notified
+	via a RRScreenChangeNotify event, so that they can adapt to
+	screen size changes.
+
+
+8. Extension Events
+
+Clients MAY select for ConfigureNotify on the root window to be
+informed of screen changes.  This may be advantageous if all your
+clients need to know is the size of the root window, as it avoids
+round trips to set up the extension.
+
+RRScreenChangeNotify is sent if RRSelectInput has requested it
+whenever properties of the screen change, which may be due to external
+factors, such as recabling a monitor, etc.
+
+RRScreenChangeNotify
+
+	rotation: ROTATION;		new rotation
+	sequenceNumber: CARD16		low 16 bits of request's seq. number
+	timestamp: TIMESTAMP		time screen was changed
+	configTimestamp: TIMESTAMP	time config data was changed
+	root: WINDOW			root window of screen
+	window: WINDOW			window requesting notification
+	sizeID: SIZEID			new ID of size
+	subpixelOrder: SUBPIXELORDER	order of subpixels
+	widthInPixels: INT16
+	heightInPixels: INT16
+	widthInMillimeters: INT16
+	heightInMillimeters: INT16
+
+	This event is generated whenever the screen configuration is
+	changed and sent to requesting clients. The timestamp included
+	indicates when the screen configuration was changed, and
+	configTimestamp says when the last time the configuration was
+	changed. The root is the root of the screen the change
+	occurred on, and the event window is also returned.  SizeID
+	contains an index indicating which size is current.
+
+	This event is sent whenever the screen's configuration changes
+	or if a new screen configuration becomes available that was
+	not available in the past.  In this case (config-timestamp in
+	the event not being equal to the config-timestamp returned in
+	the last call to RRGetScreenInfo), the client MUST call
+	RRGetScreenInfo to update its view of possible screen
+	configurations to have a correct view of possible screen
+	organizations. Timestamp is set to when the active screen
+	configuration was changed.
+
+	Clients which select screen change notification events may be
+	sent an event immediately if the screen configuration was
+	changed between when they connected to the X server and
+	selected for notification.  This is to prevent a common race
+	that might occur on log-in, where many applications start up
+	just at the time when a display manager or log in script might
+	be changing the screen size or configuration.
+
+
+9. Extension Versioning
+
+The RandR extension was developed in parallel with the implementation
+to ensure the feasibility of various portions of the design.  As
+portions of the extension are implemented, the version number of the
+extension has changed to reflect the portions of the standard provied.
+This document describes the version 1.0 of the specification, the
+partial implementations have version numbers less than that.  Here's a
+list of what each version before 1.0 implemented:
+
+	0.0: This prototype implemented resize and rotation in the
+	     TinyX server Used approximately the protocol described in
+	     the Usenix paper.  Appeared in the TinyX server in
+	     XFree86 4.2, but not in the XFree86 main server.
+
+	0.1: Added subpixel order, added an event for subpixel order.
+	     This version was never checked in to XFree86 CVS.
+
+	1.0: Implements resize, rotation, and reflection.  Implemented
+	     both in the XFree86 main server (size change only at this
+	     date), and fully (size change, rotation, and reflection)
+	     in XFree86's TinyX server.
+
+	1.1: Added refresh rates
+
+Compatibility between 0.0 and 1.0 was *NOT* preserved, and 0.0 clients
+will fail against 1.0 servers.  The wire encoding op-codes were
+changed for GetScreenInfo to ensure this failure in a relatively
+graceful way.  Version 1.1 servers and clients are cross compatible with
+1.0.  Version 1.1 is considered to be stable and we intend upward
+compatibility from this point.
+
+
+Appendix A. Protocol Encoding
+
+Syntactic Conventions
+
+This document uses the same syntactic conventions as the core X
+protocol encoding document.
+
+
+A.1 Common Types
+
+	SETofROTATION
+
+	0x0001	RR_Rotate_0
+	0x0002	RR_Rotate_90
+	0x0004	RR_Rotate_180
+	0x0008	RR_Rotate_270
+	0x0010	RR_Reflect_X
+	0x0020	RR_Reflect_Y
+
+
+	SETofRRSELECTMASK
+
+	0x0001	RRScreenChangeNotifyMask
+
+
+A.2 Protocol Requests
+
+
+Opcodes 0x1 and 0x3 were used in the 0.0 protocols, and will return
+errors if used in version 1.0.
+
+	RRQueryVersion
+
+	1	CARD8			major opcode
+	1	0x01			RandR opcode
+	2	3			length
+	4	CARD32			major version
+	4	CARD32			minor version
+	->
+	1	1			Reply
+        1				unused
+	2	CARD16			sequence number
+	4	0			reply length
+	1	CARD32			major version
+        1	CARD32			minor version
+
+	RRSetScreenConfig
+
+	1	CARD8			major opcode
+	1	0x02			RandR opcode
+	2	5			length
+	4	DRAWABLE		drawable on screen to be configured
+	4	TIMESTAMP		timestamp
+	2	SIZEID			size id
+	2	ROTATION		rotation/reflection
+	2	CARD16			refresh rate (1.1 only)
+	2	CARD16			pad
+	->
+	1	1			Reply
+	1	CARD8			status
+		0x0 RRSetConfigSuccess
+		0x1 RRSetConfigInvalidConfigTime
+		0x2 RRSetConfigInvalidTime
+		0x3 RRSetConfigFailed
+	2	CARD16			sequence number
+	4	0			reply length
+	4	TIMESTAMP		new timestamp
+	4	TIMESTAMP		new configuration timestamp
+	4	WINDOW			root
+	2	SUBPIXELORDER		subpixel order defined in Render
+	2	CARD16			pad4
+	4	CARD32			pad5
+	4	CARD32			pad6
+
+	
+	RRSelectInput
+
+	1	CARD8			major opcode
+	1	0x04			RandR opcode
+	2	3			length
+	4	WINDOW			window
+	2	SETofRRSELECTMASK	enable
+	2	CARD16			pad
+
+
+	RRGetScreenInfo
+
+	1	CARD8			major opcode
+	1	0x05			RandR opcode
+	2	2			length
+	4	WINDOW			window
+	->
+	1	1			Reply
+	1	CARD8			set of Rotations
+	2	CARD16			sequence number
+	4	0			reply length
+	4	WINDOW			root window
+	4	TIMESTAMP		timestamp
+	4	TIMESTAMP		config timestamp
+	2	CARD16			number of SIZE following
+	2	SIZEID			sizeID
+	2	ROTATION		current rotation and reflection
+	2	CARD16			rate (1.1)
+	2	CARD16			length of rate info (number of CARD16s)
+	2	CARD16			pad
+
+	SIZE
+	2	CARD16			width in pixels
+	2	CARD16			height in pixels
+	2	CARD16			width in millimeters
+	2	CARD16			height in millimeters
+
+	REFRESH
+	2	CARD16			number of rates (n)
+	2n	CARD16			rates
+
+A.2 Protocol Event
+
+	RRScreenChangeNotify
+
+	1	Base + 0		code
+	1	ROTATION		new rotation and reflection
+	2	CARD16			sequence number
+	4	TIMESTAMP		timestamp
+	4	TIMESTAMP		configuration timestamp
+	4	WINDOW			root window
+	4	WINDOW			request window
+	2	SIZEID			size ID
+	2	SUBPIXELORDER		subpixel order defined in Render
+	2	CARD16			width in pixels
+	2	CARD16			height in pixels
+	2	CARD16			width in millimeters
+	2	CARD16			height in millimeters
+
+
+Bibliography
+
+[RANDR] Gettys, Jim and Keith Packard, "The X Resize and Rotate
+	Extension - RandR", Proceedings of the 2001 USENIX Annual
+	Technical Conference, Boston, MA
+
+[RENDER] 
+	Packard, Keith, "The X Rendering Extension", work in progress,
+	documents found in xc/specs/Render.
Index: xc/doc/specs/Render/library
diff -u /dev/null xc/doc/specs/Render/library:1.2
--- /dev/null	Thu Feb 27 12:14:11 2003
+++ xc/doc/specs/Render/library	Wed Nov 27 00:36:00 2002
@@ -0,0 +1,600 @@
+                         The Xrender Library
+			    Version 0.7
+			      2002-11-6
+			    Keith Packard
+			  keithp@xfree86.org
+
+1. Introduction
+
+The Xrender library is designed as a lightweight library interface to the
+Render extension.  This document describes how the library maps to the
+protocol without duplicating the semantics described by that document.
+
+2. Data Types
+
+2.1 Primitive Types
+
+For resources represented as CARD32 or XID on the wire, Xrender exposes them
+using an 'unsigned long' type as is the norm for 32-bit data objects in an
+Xlib compatible API.
+
+	typedef unsigned long	Glyph;
+	typedef unsigned long	GlyphSet;
+	typedef unsigned long	Picture;
+	typedef unsigned long	PictFormat;
+
+Glyphs are just CARD32 objects, while GlyphSet, Picture and PictFormat
+values are XIDs.
+
+	typedef int XFixed;
+
+Fixed point numbers buck the Xlib convention by being represented as ints.
+Machines for which 'int' is smaller than 32 bits cannot support the Xrender
+library.
+
+2.2 PictFormat descriptions.
+
+The definition of a PictFormat is exposed by two data structures:
+
+	typedef struct {
+	    short   red;
+	    short   redMask;
+	    short   green;
+	    short   greenMask;
+	    short   blue;
+	    short   blueMask;
+	    short   alpha;
+	    short   alphaMask;
+	} XRenderDirectFormat;
+
+	typedef struct {
+	    PictFormat		id;
+	    int			type;
+	    int			depth;
+	    XRenderDirectFormat	direct;
+	    Colormap		colormap;
+	} XRenderPictFormat;
+
+These serve both as a description of the available formats and as patterns
+against which available formats are matched.
+
+2.3 Picture Attributes
+
+When creating or changing Picture objects, attributes are passed much as
+they are for XCreateWindow/XChangeWindowAttributes.  A structure capable of
+holding all of the attributes has the relevant ones set and a bitmask passed
+as a separate argument which marks the valid entries.
+
+	typedef struct _XRenderPictureAttributes {
+	    Bool		repeat;
+	    Picture		alpha_map;
+	    int			alpha_x_origin;
+	    int			alpha_y_origin;
+	    int			clip_x_origin;
+	    int			clip_y_origin;
+	    Pixmap		clip_mask;
+	    Bool		graphics_exposures;
+	    int			subwindow_mode;
+	    int			poly_edge;
+	    int			poly_mode;
+	    Atom		dither;
+	    Bool		component_alpha;
+	} XRenderPictureAttributes;
+
+2.4 Colors
+
+The core protocol XColor type doesn't include an alpha component, so Xrender
+has a separate type.
+
+	typedef struct {
+	    unsigned short   red;
+	    unsigned short   green;
+	    unsigned short   blue;
+	    unsigned short   alpha;
+	} XRenderColor;
+
+2.5 Glyph Types
+
+Glyphs are stored in the server, so these definitions are passed from the
+client to the library and on to the server as glyphs are rasterized and
+transmitted over the wire.
+
+	typedef struct _XGlyphInfo {
+	    unsigned short  width;
+	    unsigned short  height;
+	    short	    x;
+	    short	    y;
+	    short	    xOff;
+	    short	    yOff;
+	} XGlyphInfo;
+
+2.6 Glyph Rendering types
+
+Glyph rendering can either take a single string of glyph indices or an array
+of one of the following structures.
+
+	typedef struct _XGlyphElt8 {
+	    GlyphSet		    glyphset;
+	    _Xconst char	    *chars;
+	    int			    nchars;
+	    int			    xOff;
+	    int			    yOff;
+	} XGlyphElt8;
+	
+	typedef struct _XGlyphElt16 {
+	    GlyphSet		    glyphset;
+	    _Xconst unsigned short  *chars;
+	    int			    nchars;
+	    int			    xOff;
+	    int			    yOff;
+	} XGlyphElt16;
+	
+	typedef struct _XGlyphElt32 {
+	    GlyphSet		    glyphset;
+	    _Xconst unsigned int    *chars;
+	    int			    nchars;
+	    int			    xOff;
+	    int			    yOff;
+	} XGlyphElt32;
+	
+2.7 Geometric Types
+
+Geometric operations directly expose the available protocol datatypes
+
+	typedef struct _XPointFixed {
+	    XFixed  x, y;
+	} XPointFixed;
+	
+	typedef struct _XLineFixed {
+	    XPointFixed	p1, p2;
+	} XLineFixed;
+	
+	typedef struct _XTriangle {
+	    XPointFixed	p1, p2, p3;
+	} XTriangle;
+	
+	typedef struct _XTrapezoid {
+	    XFixed  top, bottom;
+	    XLineFixed	left, right;
+	} XTrapezoid;
+
+	typedef struct _XTransform {
+	    XFixed  matrix[3][3];
+	} XTransform;
+
+2.8 Transformation Filters
+
+All of the filters are named simultaneously; Xrender provides no convenience
+functions for dealing with them.
+
+	typedef struct _XFilters {
+	    int	    nfilter;
+	    char    **filter;
+	    int	    nalias;
+	    short   *alias;
+	} XFilters;
+
+2.9 Index type PictFormat colors
+
+PictFormats of Index type advertise which colors will be used for drawing
+through this type.
+
+	typedef struct _XIndexValue {
+	    unsigned long    pixel;
+	    unsigned short   red, green, blue, alpha;
+	} XIndexValue;
+
+
+3 Application Startup Functions
+
+3.1 Initialization functions
+
+	Bool XRenderQueryExtension (Display *dpy, 
+			            int     *event_basep, 
+				    int     *error_basep)
+
+This function returns True if the Render extension is available on dpy.
+event_basep and error_basep will be filled in with the first event and error
+numbers used by the extension (note that Render currently uses no events).
+
+	Status XRenderQueryVersion (Display *dpy,
+				    int     *major_versionp,
+				    int     *minor_versionp)
+
+XRenderQueryVersion returns zero if the Render extension is not present or
+some error occurred while attempting to discover the current Render version
+number.  Otherwise, XRenderQueryVersion returns 1 and stores the version
+number returned by the server in *major_versionp and *minor_versionp, which
+will be less than or equal to the library version numbers RENDER_MAJOR and
+RENDER_MINOR.
+
+	Status XRenderQueryFormats (Display *dpy)
+
+XRenderQueryFormats returns 1 if it successfully fetches the available
+PictFormat information from the X server, 0 otherwise.  Applications needn't
+invoke this function directly (hmm, perhaps it should be removed from the
+external interfaces then).
+
+3.2 Subpixel Order
+
+	int XRenderQuerySubpixelOrder (Display *dpy, int screen)
+
+	Bool XRenderSetSubpixelOrder (Display *dpy, int screen, int subpixel)
+
+Applications interested in the geometry of the elements making up a single
+pixel on the screen should use XRenderQuerySubpixelOrder and not cache the
+return value.  XRenderSetSubpixelOrder is used by the XRandR library to
+update the value stored by Xrender when the subpixel order changes as a
+result of screen reconfiguration.
+
+3.3 PictFormat matching
+
+Xrender provides these APIs to help locate appropriate PictFormats; they are
+intended to work much like the Visual matching APIs in Xlib.  The
+application provides a specification including the necessary PictFormat
+characteristics and Xrender returns a matching XRenderPictFormat structure
+which describes the PictFormat.
+
+	XRenderPictFormat *
+	XRenderFindFormat (Display			*dpy,
+			   unsigned long		mask,
+			   _Xconst XRenderPictFormat	*templ,
+			   int				count)
+    
+	#define PictFormatID	    (1 << 0)
+	#define PictFormatType	    (1 << 1)
+	#define PictFormatDepth	    (1 << 2)
+	#define PictFormatRed	    (1 << 3)
+	#define PictFormatRedMask   (1 << 4)
+	#define PictFormatGreen	    (1 << 5)
+	#define PictFormatGreenMask (1 << 6)
+	#define PictFormatBlue	    (1 << 7)
+	#define PictFormatBlueMask  (1 << 8)
+	#define PictFormatAlpha	    (1 << 9)
+	#define PictFormatAlphaMask (1 << 10)
+	#define PictFormatColormap  (1 << 11)
+	
+XRenderFindFormat locates a PictFormat matching the characteristics provided
+in the templ.  Only elements whose associated bit in mask are compared.
+
+	XRenderPictFormat *
+	XRenderFindVisualFormat (Display *dpy, _Xconst Visual *visual)
+
+Finds the PictFormat suitable for use with the specified visual.
+
+	XRenderPictFormat *
+	XRenderFindStandardFormat (Display		*dpy,
+				   int			format)
+
+	#define PictStandardARGB32  0
+	#define PictStandardRGB24   1
+	#define PictStandardA8	    2
+	#define PictStandardA4	    3
+	#define PictStandardA1	    4
+	#define PictStandardNUM	    5
+
+As a convenience, this function locates PictFormats that coorespond to
+commonly used formats.
+
+	ARGB32		depth 32, bits 31-24 A, 23-16 R, 15-8 G, 7-0 B
+	RGB24		depth 24, bits 23-16 R, 15-8 G, 7-0 B
+	A8		depth 8, bits 7-0 A
+	A4		depth 4, bits 3-0 A
+	A1		depth 1, bits 0 A
+
+Any server supporting Render must have a PictFormat cooresponding to each of
+these standard formats.
+
+3.4 Index type PictFormat color values
+
+	XIndexValue *
+	XRenderQueryPictIndexValues(Display			*dpy,
+				    _Xconst XRenderPictFormat	*format,
+				    int				*num)
+
+If format refers to an Index type PictFormat, XRenderQueryPictIndexValues
+returns the set of pixel values and their associated colors used when
+drawing to Pictures created with that format.  Otherwise,
+XRenderQueryPictIndexValues generates a BadMatch error.
+
+3.5 Querying available filters
+
+	XFilters *
+	XRenderQueryFilters (Display *dpy, Drawable drawable);
+
+Filters are used with non-identity transformation matrices, this function
+returns a datastructure identifying the available filters on display that
+can be associated with pictures for the screen associated with drawable.
+
+Free this structure with XFree.
+
+4 Picture Functions
+
+	Picture
+	XRenderCreatePicture (Display				*dpy,
+			      Drawable				drawable,
+			      _Xconst XRenderPictFormat		*format,
+			      unsigned long			valuemask,
+			      _Xconst XRenderPictureAttributes	*attributes)
+	
+	#define CPRepeat			    (1 << 0)
+	#define CPAlphaMap			    (1 << 1)
+	#define CPAlphaXOrigin			    (1 << 2)
+	#define CPAlphaYOrigin			    (1 << 3)
+	#define CPClipXOrigin			    (1 << 4)
+	#define CPClipYOrigin			    (1 << 5)
+	#define CPClipMask			    (1 << 6)
+	#define CPGraphicsExposure		    (1 << 7)
+	#define CPSubwindowMode			    (1 << 8)
+	#define CPPolyEdge			    (1 << 9)
+	#define CPPolyMode			    (1 << 10)
+	#define CPDither			    (1 << 11)
+	#define CPComponentAlpha		    (1 << 12)
+	#define CPLastBit			    11
+
+Creates a picture for drawable in the specified format.  Any values
+specified in 'attributes' and 'valuemask' are used in place of the default
+values.
+
+	void
+	XRenderChangePicture (Display				*dpy,
+			      Picture				picture,
+			      unsigned long			valuemask,
+			      _Xconst XRenderPictureAttributes  *attributes)
+
+Change values in picture to those specified by valuemask and attributes.
+			      
+
+	void
+	XRenderSetPictureClipRectangles (Display	    *dpy,
+					 Picture	    picture,
+					 int		    xOrigin,
+					 int		    yOrigin,
+					 _Xconst XRectangle *rects,
+					 int		    n)
+
+Sets the clip mask in picture to the union of rects offset by
+xOrigin/yOrigin.
+
+	void
+	XRenderSetPictureClipRegion (Display	    *dpy,
+				     Picture	    picture,
+				     Region	    r)
+
+Sets the clip mask in picture to r.
+
+	void
+	XRenderSetPictureTransform (Display	    *dpy,
+				    Picture	    picture,
+				    XTransform	    *transform)
+
+Sets the projective transformation matrix of picture to transform.
+
+	void
+	XRenderFreePicture (Display                   *dpy,
+			    Picture                   picture)
+	
+Instructs the server to free picture.
+
+5 GlyphSet functions
+
+	GlyphSet
+	XRenderCreateGlyphSet (Display *dpy, _Xconst XRenderPictFormat *format)
+	
+Creates a glyphset, every glyph in the set will use PictFormat format.
+
+	GlyphSet
+	XRenderReferenceGlyphSet (Display *dpy, GlyphSet existing)
+	
+Creates a new GlyphSet ID which references an existing GlyphSet.  The
+two IDs refer to the same object so that changes using one ID will be
+visible through the other ID.  This is designed to allow multiple clients to
+share the same GlyphSet so that it doesn't get destroyed when the first
+client exits.
+
+	void
+	XRenderFreeGlyphSet (Display *dpy, GlyphSet glyphset)
+	
+Frees the glyphset ID.  If no other GlyphSet IDs refer to the underlying
+GlyphSet, it will be destroyed.
+
+	void
+	XRenderAddGlyphs (Display		*dpy,
+			  GlyphSet		glyphset,
+			  _Xconst Glyph		*gids,
+			  _Xconst XGlyphInfo	*glyphs,
+			  int			nglyphs,
+			  _Xconst char		*images,
+			  int			nbyte_images)
+	
+Add glyphs to glyphset.  The images are packed together in Z-pixmap format
+according to the depth of the PictFormat used in creating glyphset.
+
+	void
+	XRenderFreeGlyphs (Display	    *dpy,
+			   GlyphSet	    glyphset,
+			   _Xconst Glyph    *gids,
+			   int		    nglyphs)
+
+Free some glyphs from glyphset.
+
+6 Glyph Drawing Routines
+
+Xrender provides two parallel APIs for glyph rendering, a simple API which
+accepts a single string similar to XDrawString and a more complex API which
+accepts an array of XGlyphElt{8,16,32} structures, each of which includes a
+glyphset, string and x/y offsets which parallel the XDrawText API.  Xrender
+also provides glyphs in three sizes, 8 16 and 32 bits.  The simple API is
+just a convenience for the user as both forms generate the same underlying
+Render protocol.
+
+6.1 Simple single-string glyph drawing functions
+
+These are identical except for the format of the glyph ids.
+
+	void
+	XRenderCompositeString8 (Display		    *dpy,
+				 int			    op,
+				 Picture		    src,
+				 Picture		    dst,
+				 _Xconst XRenderPictFormat  *maskFormat,
+				 GlyphSet		    glyphset,
+				 int			    xSrc,
+				 int			    ySrc,
+				 int			    xDst,
+				 int			    yDst,
+				 _Xconst char		    *string,
+				 int			    nchar)
+	
+	void
+	XRenderCompositeString16 (Display		    *dpy,
+				  int			    op,
+				  Picture		    src,
+				  Picture		    dst,
+				  _Xconst XRenderPictFormat *maskFormat,
+				  GlyphSet		    glyphset,
+				  int			    xSrc,
+				  int			    ySrc,
+				  int			    xDst,
+				  int			    yDst,
+				  _Xconst unsigned short    *string,
+				  int			    nchar)
+	
+	void
+	XRenderCompositeString32 (Display		    *dpy,
+				  int			    op,
+				  Picture		    src,
+				  Picture		    dst,
+				  _Xconst XRenderPictFormat *maskFormat,
+				  GlyphSet		    glyphset,
+				  int			    xSrc,
+				  int			    ySrc,
+				  int			    xDst,
+				  int			    yDst,
+				  _Xconst unsigned int	    *string,
+				  int			    nchar)
+	
+6.2 Complete glyph drawing functions 
+
+As with the simple functions above, these differ only in the type of the
+underlying glyph id storage type.
+
+	void
+	XRenderCompositeText8 (Display			    *dpy,
+			       int			    op,
+			       Picture			    src,
+			       Picture			    dst,
+			       _Xconst XRenderPictFormat    *maskFormat,
+			       int			    xSrc,
+			       int			    ySrc,
+			       int			    xDst,
+			       int			    yDst,
+			       _Xconst XGlyphElt8	    *elts,
+			       int			    nelt)
+	
+	void
+	XRenderCompositeText16 (Display			    *dpy,
+				int			    op,
+				Picture			    src,
+				Picture			    dst,
+				_Xconst XRenderPictFormat   *maskFormat,
+				int			    xSrc,
+				int			    ySrc,
+				int			    xDst,
+				int			    yDst,
+				_Xconst XGlyphElt16	    *elts,
+				int			    nelt)
+	
+	void
+	XRenderCompositeText32 (Display			    *dpy,
+				int			    op,
+				Picture			    src,
+				Picture			    dst,
+				_Xconst XRenderPictFormat   *maskFormat,
+				int			    xSrc,
+				int			    ySrc,
+				int			    xDst,
+				int			    yDst,
+				_Xconst XGlyphElt32	    *elts,
+				int			    nelt)
+	
+7 Basic Graphics Functions
+
+These are the simplest graphics functions upon which the other functions are
+conceptually built.
+
+7.1 Composite
+
+XRenderComposite exposes the RenderComposite protocol request directly.
+
+	void
+	XRenderComposite (Display   *dpy,
+			  int	    op,
+			  Picture   src,
+			  Picture   mask,
+			  Picture   dst,
+			  int	    src_x,
+			  int	    src_y,
+			  int	    mask_x,
+			  int	    mask_y,
+			  int	    dst_x,
+			  int	    dst_y,
+			  unsigned int	width,
+			  unsigned int	height)
+	
+
+7.2 Rectangles
+
+These functions composite rectangles of the specified color, they differ
+only in that XRenderFillRectangles draws more than one at a time.
+
+	void
+	XRenderFillRectangle (Display		    *dpy,
+			      int		    op,
+			      Picture		    dst,
+			      _Xconst XRenderColor  *color,
+			      int		    x,
+			      int		    y,
+			      unsigned int	    width,
+			      unsigned int	    height)
+	
+	void
+	XRenderFillRectangles (Display		    *dpy,
+			       int		    op,
+			       Picture		    dst,
+			       _Xconst XRenderColor *color,
+			       _Xconst XRectangle   *rectangles,
+			       int		    n_rects)
+	
+8 Geometric Objects
+
+All geometric drawing with Render is performed with sequences of trapezoids
+or triangles; the client is responsible for breaking more complex figures
+into these simple shapes.
+
+8.1 Trapezoids
+
+	void
+	XRenderCompositeTrapezoids (Display		*dpy,
+				    int			op,
+				    Picture		src,
+				    Picture		dst,
+				    _Xconst XRenderPictFormat	*maskFormat,
+				    int			xSrc,
+				    int			ySrc,
+				    _Xconst XTrapezoid	*traps,
+				    int			ntrap)
+
+XRenderCompositeTrapezoids builds RenderTrapezoids requests to composite the
+specified list of trapezoids to dst.  XRenderCompositeTrapezoids will split
+the list of trapezoids to build requests no larger than the maximum request
+size supported by the server.  This can create rendering artifacts as the
+precompositing done by RenderTrapezoids when a maskFormat is specified
+cannot span multiple requests.
+
+8.2 Triangles
+
+Render provides three different ways of encoding triangles on the wire,
+Xrender exposes those with three separate triangle drawing routines.  As
+with trapezoids above, Xrender will split the arguments to fit requests into
+the servers limits, but this may cause rendering artifacts.
Index: xc/doc/specs/Render/protocol
diff -u xc/doc/specs/Render/protocol:1.1 xc/doc/specs/Render/protocol:1.7
--- xc/doc/specs/Render/protocol:1.1	Fri Dec 15 13:33:53 2000
+++ xc/doc/specs/Render/protocol	Wed Nov 27 00:36:25 2002
@@ -1,6 +1,6 @@
 			The X Rendering Extension
-			      Version 0.0.15
-			        2000-11-19
+			      Version 0.7
+			        2002-11-6
 			      Keith Packard
 			    keithp@xfree86.org
 
@@ -28,6 +28,14 @@
  +	Jon Leech, Brad Grantham and Allen Akin for patiently explaining
 	how OpenGL works.
 
+ +	Carl Worth for providing the sample implementation of
+ 	trapezoid rendering
+
+ +	Sam Pottle and Jamey Sharp for helping demonstrate the correctness
+ 	of the trapezoid specification.
+
+ +	Owen Taylor for helping specify projective transformations
+
 3. Rendering Model
 
 Render provides a single rendering operation which can be used in a variety of
@@ -58,15 +66,25 @@
  +	The OP to use
 
  +	Whether the source should be repeated to cover the destination
-   	rectangle or whether rendering should be clipped by the source
+ 	rectangle, extended with a constant pixel value or extended by
+	using the nearest available source pixel.
 
  +	Whether the mask should be repeated to cover the destination
- 	rectangle or whether rendering should be clipped by the mask
+ 	rectangle, extended with a constant pixel value or extended by
+	using the nearest available mask pixel.
 
  +	Whether the mask has a single alpha value for all four channels or
  	whether each mask channel should affect the associated source/dest
 	channels.
+
+ +	Whether the source should be reshaped with a projective
+        transformation, and if so, what filter to apply while
+	resampling the data.
 	
+ +	Whether the mask should be reshaped with a projective
+        transformation, and if so, what filter to apply while
+	resampling the data.
+	
 These parameters are variously attached to the operands or included in each
 rendering request.
 
@@ -113,7 +131,18 @@
 PICTFORMAT	32-bit value (top three bits guaranteed to be zero)
 PICTTYPE	{ Indexed, Direct }
 PICTOP		{ Clear, Src, Dst, Over, OverReverse, In, InReverse,
-		  Out, OutReverse, Atop, AtopReverse, Xor, Add, Saturate }
+		  Out, OutReverse, Atop, AtopReverse, Xor, Add, Saturate,
+		  DisjointClear, DisjointSrc, DisjointDst, DisjointOver,
+		  DisjointOverReverse, DisjointIn, DisjointInReverse,
+		  DisjointOut, DisjointOutReverse, DisjointAtop,
+		  DisjointAtopReverse, DisjointXor,
+		  ConjointClear, ConjointSrc, ConjointDst, ConjointOver,
+		  ConjointOverReverse, ConjointIn, ConjointInReverse,
+		  ConjointOut, ConjointOutReverse, ConjointAtop,
+		  ConjointAtopReverse, ConjointXor }
+SUBPIXEL	{ Unknown, HorizontalRGB, HorizontalBGR, 
+		  VerticalRGB, VerticalBGR, None
+		}
 COLOR		[	
 			red, green, blue, alpha: CARD16
 		]
@@ -147,14 +176,12 @@
 
 PICTSCREEN	LISTofPICTDEPTH
 
-DITHERINFO	[
-			name:		ATOM
-			format:		PICTFORMAT
-			width:		CARD16
-			height:		CARD16
+FIXED		32-bit value (top 16 are integer portion, bottom 16 are fraction)
+TRANSFORM	[
+			p11, p12, p13:	FIXED
+			p21, p22, p23:	FIXED
+			p31, p32, p33:	FIXED
 		]
-
-FIXED		32-bit value (top 24 are integer portion, bottom 8 are fraction)
 POINTFIX	[
 			x, y: FIXED
 		]
@@ -177,8 +204,12 @@
 TRIANGLE	[
 			p1, p2, p3:	POINTFIX
 		]
+LINEFIX		[
+			p1, p2:		POINTFIX
+		]
 TRAP		[
-			top, bottom:	SPANFIX
+			top, bottom:	FIXED
+			left, right:	LINEFIX
 		]
 COLORTRIANGLE	[
 			p1, p2, p3:	COLORPOINT
@@ -234,7 +265,11 @@
 
 Indexed PictFormats never have alpha channels and the direct component is all
 zeros.  Indexed PictFormats always have a colormap in which the specified
-colors are allocated read-only and are therefore screen dependent.
+colors are allocated read-only and are therefore screen dependent.  Drawing
+to in Indexed Picture uses only pixel values listed by QueryPictIndexValues.
+Reading from an Indexed Picture uses red, green and blue values from the
+colormap and alpha values from those listed by QueryPictIndexValues.  Pixel
+values not present in QueryPictIndexValues are given alpha values of 1.
 
 8. Compositing Operators
 
@@ -244,46 +279,94 @@
 
 where C, Ca, Cb are the values of the respective channels and Fa and Fb
 come from the following table:
-
-	PictOp		Fa			Fb
-	------------------------------------------
-	Clear		0			0
-	Src		1			0
-	Dst		0			1
-	Over		1			1-Aa
-	OverReverse	1-Ab			1
-	In		Ab			0
-	InReverse	0			Aa
-	Out		1-Ab			0
-	OutReverse	0			1-Aa
-	Atop		Ab			1-Aa
-	AtopReverse	1-Ab			Aa
-	Xor		1-Ab			1-Aa
-	Add		1			1
-	Saturate	min(1,(1-Ab)/Aa)	1
-
----
 
-Saturate matches GL with FUNC_ADD, SRC_ALPHA_SATURATE, ONE, except
-that it uses premultiplied alphas while GL uses non-premultiplied alphas.
+	PictOp			Fa			Fb
+	--------------------------------------------------
+	Clear			0			0
+	Src			1			0
+	Dst			0			1
+	Over			1			1-Aa
+	OverReverse		1-Ab			1
+	In			Ab			0
+	InReverse		0			Aa
+	Out			1-Ab			0
+	OutReverse		0			1-Aa
+	Atop			Ab			1-Aa
+	AtopReverse		1-Ab			Aa
+	Xor			1-Ab			1-Aa
+	Add			1			1
+	Saturate		min(1,(1-Ab)/Aa)	1
+	DisjointClear		0			0
+	DisjointSrc		1			0
+	DisjointDst		0			1
+	DisjointOver		1			min(1,(1-Aa)/Ab)
+	DisjointOverReverse	min(1,(1-Ab)/Aa)	1
+	DisjointIn		max(1-(1-Ab)/Aa,0)	0
+	DisjointInReverse	0			max(1-(1-Aa)/Ab,0)
+	DisjointOut		min(1,(1-Ab)/Aa)	0
+	DisjointOutReverse	0			min(1,(1-Aa)/Ab)
+	DisjointAtop		max(1-(1-Ab)/Aa,0)	min(1,(1-Aa)/Ab)
+	DisjointAtopReverse	min(1,(1-Ab)/Aa)	max(1-(1-Aa)/Ab,0)
+	DisjointXor		min(1,(1-Ab)/Aa)	min(1,(1-Aa)/Ab)
+	ConjointClear		0			0
+	ConjointSrc		1			0
+	ConjointDst		0			1
+	ConjointOver		1			max(1-Aa/Ab,0)
+	ConjointOverReverse	max(1-Ab/Aa,0)		1
+	ConjointIn		min(1,Ab/Aa)		0
+	ConjointInReverse	0			min(Aa/Ab,1)
+	ConjointOut		max(1-Ab/Aa,0)		0
+	ConjointOutReverse	0			max(1-Aa/Ab,0)
+	ConjointAtop		min(1,Ab/Aa)		max(1-Aa/Ab,0)
+	ConjointAtopReverse	max(1-Ab/Aa,0)		min(1,Aa/Ab)
+	ConjointXor		max(1-Ab/Aa,0)		max(1-Aa/Ab,0)
+
+Saturate and DisjointOverReverse are the same.  They match OpenGL
+compositing with FUNC_ADD, SRC_ALPHA_SATURATE, ONE, except that Render uses
+premultiplied alpha while Open GL uses non-premultiplied alpha.
 
-Remember the idea is to apply (src In mask) Saturate Dst so that
-computing (src In mask) effectively applies alpha values of 'mask' to
-src; the server could 'short circuit' that computation by only multiplying
-the alpha channel and then applying the regular GL SRC_ALPHA_SATURATE
-operator.
-
----
-
 The result of any compositing operator is always limited to the range
 [0,1] for each component.  Components whose value would be greater than 1
 are set to 1.
 
+For operations involving division, when the divisor is zero, define the
+quotient to be positive infinity.  The result is always well defined
+because the division is surrounded with a max or min operator which will
+give a finite result.
+
 When the mask contains separate alpha values for each channel, the
 alpha value resulting from the combination of that value with the source
 alpha channel is used in the final image composition.
+
+9. Source and Mask Transformations
+
+When fetching pixels from the source or mask pictures, Render provides three
+options for pixel values which fall outside the drawable (this includes
+pixels within a window geometry obscured by other windows).
+
+ +	Transparent.  Missing values are replaced with transparent.
+ 
+ +	Nearest.  Replace missing pixels with the nearest available
+ 	pixel.  Where multiple pixels are equidistant, select
+	those with smallest Y and then smallest X coordinates
+
+ +	Tile.  Select the pixel which would appear were the
+ 	drawable tiled to enclose the missing coordinate.  If
+	the tiling doesn't cover the coordinate, use the
+	selected Constant or Nearest mode.
+
+When GraphicsExposures are selected in the destination picture, a region
+containing at least the union of all destination pixel values affected by
+data replaced as above is delivered after each compositing operation.  If
+the resulting region is empty, a NoExpose event is delivered instead.
+
+To construct the source and mask operands, the computed pixels values are
+transformed through a homogeneous matrix, filtered and then used in the
+fundemental rendering operator described above.  Each screen provides a list
+of supported filter names. There are a few required filters, and several
+required filter alias which must map to one of the available filters.
 
-9. Polygon Rasterization
+10. Polygon Rasterization
 
 All polygons must be convex.  Rendering of concave polygons is unspecified
 except that the result must obey the clipping rules.
@@ -307,16 +390,25 @@
 	tmp = Rasterize (polygon)
 	Composite (op, dst, src, tmp)
 
-When rasterized with Sharp edges, the mask is generated by setting pixels
-inside the polygon to 1 and pixels outside the mask to 0.
+When rasterized with Sharp edges, the mask is computed with a depth of 1 so
+that all of the mask values are either 0 or 1.
 
 When rasterized with Smooth edges, the mask is generated by creating a square
 around each pixel coordinate and computing the amount of that square covered
-by the polygon.  Yes, this ignores sampling theory but it provides a precise
+by the polygon.  This ignores sampling theory but it provides a precise
 definition which is close to the right answer.  This value is truncated to
 the alpha width in the fallback format before application of the compositing
 operator.
 
+---
+
+This needs rewriting to match current trapezoid specification and
+base other polygons on that.  I suspect imprecise polygons will need
+to have a relaxed specification as well; hardware is unlikely to
+meet the "sum to one" constraint.
+
+---
+
 When rasterized in Precise mode, the pixelization will match this
 specification exactly.
 
@@ -349,9 +441,39 @@
 interpolated from a triangle containing the pixel which is formed from any
 three polygon vertices.  Any interpolated color value can err up to 1 lsb in
 each channel.
+
+11. Image Filtering
+
+When computing pixels from source and mask images, a filter may be applied
+to the data.  This is usually used with a non-identity transformation
+matrix, but filtering may be applied with an identity transformation.
+
+Each filter is given a unique name encoded as an ISO Latin-1 string.
+Filters may be configured with a list of fixed point values; the number of
+parameters and their interpretation is currently left to conventions passed
+outside of the protocol.  A set of standard filters are required to be
+provided:
+
+	Filter Name	Description
 
-10. Glyph Rendering
+	Nearest		Nearest neighbor filtering
+	Bilinear	Linear interpolation in two dimensions
 
+Additional names may be provided for any filter as aliases.  A set of
+standard alias names are required to be mapped to a provided filter so that
+applications can use the alias names without checking for availability.
+
+	Alias name	Intended interpretation
+	
+	Fast		High performance, quality similar to Nearest
+	Good		Reasonable performance, quality similar to Bilinear
+	Best		Highest quality available, performance may not
+			be suitable for interactive use
+
+Aliases must map directly to a non-aliased filter name.
+
+12. Glyph Rendering
+
 Glyphs are small alpha masks which can be stored in the X server and
 rendered by referring to them by name.  A set of glyphs can be rendered in a
 single request.  Glyphs are positioned by subtracting the x, y elements of
@@ -364,29 +486,9 @@
 
 Glyphs can be stored in any PictFormat supported by the server.  All glyphs
 in a GlyphSet are stored in the same format.
-
-11. Dithering
 
-Each screen supports a list of dithers.  There are several standard dithers
-with defined pixelization, the server is free to offer others as well.  The
-width and height of the dither are a hint about the size of the matrix used
-if the dither is ordered.  An unordered dither will have zero in these
-fields.
-
-The standard dithers are:
-
-	"Standard2x2"
-	"Standard4x4"
-	"Standard128x128"
+13. Extension Initialization
 
----
-
-Need a notation for specifying pixelization of dithers.
-
----
-
-12. Extension Initialization
-
 The client must negotiate the version of the extension before executing
 extension requests.  Behavior of the server is undefined otherwise.
 
@@ -415,6 +517,10 @@
 	fallback:	PICTFORMAT
 	formats:	LISTofPICTFORMINFO
 	screens:	LISTofPICTSCREEN
+	subpixels:	LISTofSUBPIXEL
+
+	Errors:
+		<none>
 
 	The server responds with a list of supported PictFormats and
 	a list of which PictFormat goes with each visual on each screen.
@@ -424,6 +530,13 @@
 	The fallback format is used as an intermediate representation
 	in cases where there is no ideal choice.
 
+	The relationship between the red, green and blue elements making
+	up each pixel indexed by screen is returned in subpixels.
+	This list is not present in servers advertising protocol
+	versions earlier than 0.6.  This list may be shorter than
+	the number of screens, in which case the remaining screens
+	are given sub pixel order Unknown.
+
 QueryPictIndexValues
 
 	format:		PICTFORMAT
@@ -439,18 +552,17 @@
 	specified Indexed PictFormat.  If 'format' does not refer to
 	an Indexed PictFormat a Match error is generated.
 
-QueryDithers
+QueryFilters
 
 	drawable:	DRAWABLE
 
 	->
 
-	dithers:	LISTofDITHERINFO
+	filters:	LISTofSTRING8
+	aliases:	LISTofCARD16
 
-	Returns all of the supported dithers on the screen specified by
-	drawable.
-
-13. Extension Requests
+	
+14. Extension Requests
 
 CreatePicture
 
@@ -476,6 +588,7 @@
 	are to be explicitly initialized.  The possible values are:
 	
 	repeat:			BOOL
+	fill-nearest:		BOOL
 	alpha-map:		PICTURE or None
 	alpha-x-origin:		INT16
 	alpha-y-origin:		INT16
@@ -489,11 +602,21 @@
 	dither:			ATOM or None
 	component-alpha:	BOOL
 	
-	The repeat value controls whether the image is replicated
-	when used as the source or mask in a rendering operation.  When
-	True, the contents are tiled over the destination instead of clipping
-	to the geometry of the drawable.
-
+	When used as a source or mask operand, the repeat and fill-constant
+	values control how pixels outside the geometry of the drawable are
+	computed.
+	
+	Fill-nearest indicates that pixel values outside of the drawable
+	geometry should be replaced the nearest available pixel within the
+	drawable geometry is used.  When multiple pixels are equidistant,
+	those with smaller Y and then X values are preferred.  Otherwise,
+	missing pixels are replaced with transparent.
+
+	Repeat indicates that the drawable contents should be treated
+	as if tiled in both directions.  Pixels falling in missing
+	areas of this tile are replaced according to the fill-nearest
+	rule.
+	
 	The alpha channel of alpha-map is used in place of any alpha channel
 	contained within the drawable for all rendering operations.  The
 	alpha-mask origin is interpreted relative to the origin of drawable.
@@ -524,8 +647,8 @@
 	extension.
 
 	The graphics-exposures flag controls GraphicsExposure event
-	generation for Composite and Transform requests (and any similar
-	requests defined by additional extensions).
+	generation for Composite requests (and any similar requests
+	defined by additional extensions).
 
 	Poly-edge and poly-mode control the rasterization of polygons
 	as described above.
@@ -541,8 +664,8 @@
 
 		Component		Default
 		-------------------------------
-		op			Over
 		repeat			False
+		fill-nearest:		False
 		clip-x-origin        	0
 		clip-y-origin          	0
 		clip-mask		None
@@ -588,6 +711,42 @@
 	Note that output is clipped to the union of all of the rectangles
 	and that no particular ordering among the rectangles is required.
 
+SetPictureTransform
+
+	picture:	PICTURE
+	transform:	TRANSFORM
+
+	Errors:
+		Alloc, Value, Picture
+
+	This request changes the projective transformation used to
+	map coordinates when 'picture' is used as the source or
+	mask in any compositing operation.  The transform
+	maps from destination pixel geometry back to the source pixel
+	geometry.
+
+	The matrix must be invertable, else a Value error is generated.
+
+SetPictureFilter
+
+	picture:	PICTURE
+	filter:		STRING8
+	values:		LISTofFIXED
+
+	Errors:
+		Value, Match, Picture
+
+	This request sets the current filter used when picture is a source
+	or mask operand.  Filter must be one of the filters supported
+	for the screen associated with picture, else a Match error
+	is generated.  If the filter accepts additional parameters,
+	they can be provided in values, incorrect values generate Value
+	errors, too many values generate Match errors.  Too few values
+	cause the filter to assume default values for the missing
+	parameters.
+
+	When created, Pictures are set to the Nearest filter.
+
 FreePicture
 
 	pid:		PICTURE
@@ -596,7 +755,8 @@
 		Picture
 
 	This request deletes the association between the resource ID and the
-	picture and destroys the picture.
+	picture.  The picture storage will be freed when no other resource
+	references it.
 
 Composite
 
@@ -609,22 +769,15 @@
 	dst-x, dst-y:	INT16
 	width, height:	CARD16
 
-	This request combines the specified rectangle of src and mask with
-	the specified rectangle of dst using op as the compositing
-	operator.  The coordinates are relative their respective drawable's
-	origin.  Rendering is clipped to the geometry of the dst drawable
-	and then to the dst clip-list, the src clip-list and the mask
-	clip-list.
-
-	If the specified rectangle extends beyond src, then if src has
-	the repeat attribute set, the src picture will be tiled to
-	fill the specified rectangle, otherwise rendering is clipped to
-	the src geometry.
-
-        If the specified rectangle extends beyond mask, then if mask has
-	the repeat attribute set, the mask picture will be tiled to
-	fill the specified rectangle, otherwise rendering is clipped to
-	the mask geometry.
+	This request combines the specified rectangle of the transformed
+	src and mask operands with the specified rectangle of dst using op
+	as the compositing operator.  The coordinates are relative their
+	respective (transformed) drawable's origin.  Rendering is clipped
+	to the geometry of the dst drawable and then to the dst clip-list.
+
+	Pixels outside the geometry of src or mask needed for this
+	computation are substituted as described in the Source and Mask
+	Transformations section above.
 	
 	If src, mask and dst are not in the same format, and one of their
 	formats can hold all without loss of precision, they are converted
@@ -633,39 +786,11 @@
 
 	If mask is None, it is replaced by a constant alpha value of 1.
 
-	When dst has clip-notify set, a NoExpose event is sent if the
-	rendering operation was not clipped by either src or mask, otherwise
-	a sequence of GraphicsExpose events are sent covering areas in dst
-	where rendering was clipped by src or mask.
-
-Scale
-
-	color-scale:	CARD32
-	alpha-scale:	CARD32
-        src:            PICTURE
-        dst:            PICTURE
-        src-x, src-y:   INT16
-        dst-x, dst-y:   INT16
-        width, height:  CARD16
-
-	This request replaces the specified rectangle in dst with
-	the specified rectangle of src with the components multiplied
-	in the following fashion:
-
-		dst-red   = src-red   * color-scale / 65536
-		dst-green = src-green * color-scale / 65536
-		dst-blue  = src-blue  * color-scale / 65536
-		dst-alpha = src-alpha * alpha-scale / 65536
-
-	The coordinates are relative their respective drawable's
-        origin.  Rendering is clipped to the geometry of the dst drawable
-        and then to the dst clip-list, the src clip-list and the mask
-        clip-list.
-
-        If the specified rectangle extends beyond src, then if src has
-        the repeat attribute set, the src picture will be tiled to
-        fill the specified rectangle, otherwise rendering is clipped to
-        the src geometry.
+	When dst has graphics-exposures true, a region covering all dst
+	pixels affected by substitutions performed on src or mask pixels
+	outside their respective geometries is computed.  If that region is
+	empty, a NoExpose event is sent.  Otherwise, a sequence of
+	GraphicsExpose events are sent covering that region.
 
 FillRectangles
 
@@ -686,30 +811,65 @@
 	src:		PICTURE
 	src-x, src-y:   INT16
 	dst:		PICTURE
+	mask-format:	PICTFORMAT or None
 	traps:		LISTofTRAP
+
+	This request rasterizes the list of trapezoids.  For each trap, the
+	area between the left and right edges is filled from the top to the
+	bottom.  src-x and src-y register the pattern to the floor of the
+	top x and y coordinate of the left edge of the first trapezoid, they
+	are adjusted for subsequent trapezoids so that the pattern remains
+	globally aligned within the destination.
+
+	When mask-format is not None, trapezoids are rendered in the
+	following way with the effective mask computed in mask-format:
+
+		tmp = temporary alpha picture (in mask-format)
+		Combine (Zero, tmp, tmp, None)
+		for each trapezoid
+			Combine (Add, tmp, trapezoid, None)
+		Combine (op, dst, source, tmp)
 
-	This request rasterizes the list of trapezoids.  For each span, the
-	left coordinate must be less than or equal to the right coordinate.
-	The y coordinate of the top span must be less than or equal to the 
-	y coordinate of the bottom span.  Results are undefined otherwise.
+	When mask-format is None, trapezoids are rendered in the order
+	specified directly to the destination:
 
+		for each trapezoid
+			Combine (op, dst, source, trapezoid)
+
 Triangles
 
 	op:		PICTOP
 	src:		PICTURE
 	src-x, src-y:   INT16
 	dst:		PICTURE
-	traps:		LISTofTRIANGLE
+	mask-format:	PICTFORMAT or None
+	triangles:	LISTofTRIANGLE
 
 	This request rasterizes the list of triangles in the order they
 	occur in the list.
 
+	When mask-format is not None, triangles are rendered in the
+	following way with the effective mask computed in mask-format:
+
+		tmp = temporary alpha picture (in mask-format)
+		Combine (Zero, tmp, tmp, None)
+		for each triangle
+			Combine (Add, tmp, triangle, None)
+		Combine (op, dst, source, tmp)
+
+	When mask-format is None, triangles are rendered in the order
+	specified directly to the destination:
+
+		for each triangle
+			Combine (op, dst, source, triangle)
+
 TriStrip
 
 	op:		PICTOP
 	src:		PICTURE
 	src-x, src-y:   INT16
 	dst:		PICTURE
+	mask-format:	PICTFORMAT or None
 	points:		LISTofPOINTFIX
 
 	Triangles are formed by initially using the first three points and
@@ -717,11 +877,27 @@
 	the list. If fewer than three points are provided, this request does
 	nothing.
 
+	When mask-format is not None, triangles are rendered in the
+	following way with the effective mask computed in mask-format:
+
+		tmp = temporary alpha picture (in mask-format)
+		Combine (Zero, tmp, tmp, None)
+		for each triangle
+			Combine (Add, tmp, triangle, None)
+		Combine (op, dst, source, tmp)
+
+	When mask-format is None, triangles are rendered in the order
+	specified directly to the destination:
+
+		for each triangle
+			Combine (op, dst, source, triangle)
+
 TriFan
 	op:		PICTOP
 	src:		PICTURE
 	src-x, src-y:   INT16
 	dst:		PICTURE
+	mask-format:	PICTFORMAT or None
 	points:		LISTofPOINTFIX
 
 	Triangles are formed by initially using the first three points and
@@ -729,17 +905,26 @@
 	int the list. If fewer than three points are provided, this request
 	does nothing.
 
-???
+	When mask-format is not None, triangles are rendered in the
+	following way with the effective mask computed in mask-format:
 
-Should I bother with these two compressed triangle representations?
+		tmp = temporary alpha picture (in mask-format)
+		Combine (Zero, tmp, tmp, None)
+		for each triangle
+			Combine (Add, tmp, triangle, None)
+		Combine (op, dst, source, tmp)
 
-???
+	When mask-format is None, triangles are rendered in the order
+	specified directly to the destination:
 
+		for each triangle
+			Combine (op, dst, source, triangle)
+
 ColorTrapezoids
 
 	op:		PICTOP
 	dst:		PICTURE
-	triangles:	LISTofCOLORTRAP
+	trapezoids:	LISTofCOLORTRAP
 
 	The geometry of the trapezoids must meet the same requirements as
 	for the Trapezoids request.  The trapezoids are filled in the order
@@ -760,84 +945,6 @@
 
 ???
 
-Transform
-
-	op:		PICTOP
-	src:            PICTURE
-	dst:            PICTURE
-	src-quad:	QUAD
-	dst-quad:	QUAD
-	filter:		{ Nearest, ... }
-
-	Errors:
-		Picture, Value
-
-	This request combines the specified quadrilateral of src with the
-	specified quadrilateral of dst using op as the compositing operator.
-	The coordinates are relative their respective drawable's origin.
-	Rendering is clipped to the geometry of the dst drawable and then to
-	the dst clip-list and the src clip-list.
-
-	If the specified rectangle extends beyond src, then if src has
-	the repeat attribute set, the src picture will be tiled to
-	fill the specified rectangle, otherwise rendering is clipped to
-	the src geometry.
-
-        If the specified rectangle extends beyond mask, then if mask has
-	the repeat attribute set, the mask picture will be tiled to
-	fill the specified rectangle, otherwise rendering is clipped to
-	the mask geometry.
-	
-	The effect of this request is:
-
-		tmp_image = affine-transform (src, src-quad * dst-quad)
-		tmp_mask = render (dst-quad)
-		Composite (op, dst, tmp_image, tmp_mask)
-
-	That is, the entire transformed source image is masked by an
-	image of the destination quadrilateral and rendered using the Composite
-	operator.
-
-	If the specified quadrilateral extends beyond src, then if src has
-	the repeat attribute set, the src picture will be tiled to
-	fill the specified rectangle, otherwise rendering is clipped to
-	the src geometry.
-	
-	It is a Value error to specify a self intersecting quadrilateral for
-	either src-quad or dst-quad.
-	
-	If src and dst are not in the same format, and one of their formats
-	can hold both without loss of precision, they are converted to that
-	format.  Alternatively, the server will convert each operand to the
-	fallback format.
-
-	The compositing operator from the src picture is used to merge the
-	images together.
-
-	If filter is Nearest, then the nearest (converted) pixel values to
-	each destination pixel is used without averaging.
-
-	When dst has clip-notify set, a NoExpose event is sent if the
-	rendering operation was not clipped by src, otherwise a sequence of
-	GraphicsExpose events are sent covering areas in dst where rendering
-	was clipped by src.
-
-???
-
-	What (small) set of filters should be included
-
-???
-
----
-
-	Need to describe in more detail the semantics here
-
-	Looks like the geometric extension needs to be tied to the
-	compositing extension (sigh).
-
----
-
-
 CreateGlyphSet
 
 	gsid:		GLYPHSET
@@ -962,3 +1069,75 @@
 		for each glyph
 			Combine (op, dst, source, glyph)
 
+CreateCursor
+
+	cid:		CURSOR
+	source:		PICTURE
+	x, y:		CARD16
+
+	Errors:		Alloc, IDChoice, Match, Picture
+
+	This request creates a cursor and associates identifier cid with it.
+	The x and y coordinates define the hotspot relative to the source's
+	origin and must be a point within the source (or a Match error
+	results).  The resulting picture will nominally be drawn to the
+	screen with PictOpOver. 
+	
+	The components of the cursor may be transformed arbitrarily to meet
+	display limitations.  In particular, if the display supports only
+	two colors cursors without translucency, the cursor will be
+	transformed so that areas less than .5 alpha will be transparent,
+	else opaque, and areas darker than 50% gray will be black else white.
+
+	The source picture can be freed immediately if no further explicit
+	references to it are to be made.
+
+	Subsequent drawing in the source has an undefined effect on the
+	cursor.  The server might or might not make a copy of the picture.
+
+15. Extension Versioning
+
+The Render extension was developed in parallel with the implementation to
+ensure the feasibility of various portions of the design.  As portions of
+the extension are implemented, the version number of the extension has
+changed to reflect the portions of the standard provied.  This document
+describes the intent for version 1.0 of the specification, the partial
+implementations have version numbers less than that.  Here's a list of
+what each version before 1.0 implemented:
+
+	0.0:	
+		No disjoint/conjoint operators
+		No component alpha
+		Composite
+		CreateGlyphSet
+		FreeGlyphSet
+		AddGlyphs
+		CompositeGlyphs
+
+	0.1:
+		Component alpha
+		FillRectangles
+
+	0.2:
+		Disjoint/Conjoint operators
+
+	0.3:
+		FreeGlyphs
+
+	0.4:
+		Trapezoids
+		Triangles
+		TriStrip
+		TriFan
+
+	0.5:
+		CreateCursor
+
+	0.6:
+		SetPictureTransform
+		QueryFilters
+		SetPictureFilter
+		subpixels member of QueryPictFormats
+
+	0.7:
+		QueryPictIndexValues
Index: xc/doc/specs/Xaw/AsciiSource
diff -u xc/doc/specs/Xaw/AsciiSource:1.1.1.3 xc/doc/specs/Xaw/AsciiSource:1.2
--- xc/doc/specs/Xaw/AsciiSource:1.1.1.3	Tue Jan 16 17:02:43 2001
+++ xc/doc/specs/Xaw/AsciiSource	Wed Aug 14 17:52:34 2002
@@ -69,7 +69,7 @@
 it is not updated as the user types input into the text buffer.
 This copy is freed upon the next call to XtGetValues to 
 retrieve the string resource; however, to conserve memory,
-there is a convenience routine, \fBXawAsciiSrcFreeString\fP, allowing the
+there is a convenience routine, \fBXawAsciiSourceFreeString\fP, allowing the
 application programmer to direct the widget to free the copy.
 .LP
 When the resource \fBuseStringInPlace\fP is true and the AsciiSrc object
@@ -135,7 +135,7 @@
 requested with a call to \fBXtGetValues\fP.  This memory is allocated on the
 fly, and remains valid until the next time a string needs to be allocated.
 You may save memory by freeing this string as soon as you are done
-with it by calling \fBXawAsciiSrcFreeString\fP.
+with it by calling \fBXawAsciiSourceFreeString\fP.
 .FD 0
 void XawAsciiSourceFreeString(\fIw\fP)
 .IN "XawAsciiSourceFreeString" "" @DEF@
Index: xc/doc/specs/Xaw/AsciiText
diff -u xc/doc/specs/Xaw/AsciiText:1.1.1.3 xc/doc/specs/Xaw/AsciiText:1.2
--- xc/doc/specs/Xaw/AsciiText:1.1.1.3	Tue Jan 16 17:02:43 2001
+++ xc/doc/specs/Xaw/AsciiText	Wed Aug 14 17:52:34 2002
@@ -25,7 +25,7 @@
 .sp 1
 .LP
 For the ease of internationalization, the AsciiText widget class name has not
-been changed, although it is actually able support non-ASCII locales.
+been changed, although it is actually able to support non-ASCII locales.
 The AsciiText widget is really a collection of smaller parts.  It
 includes the Text widget itself, a ``Source'' (which supports memory management),
 and a ``Sink'' (which handles the display).  There are currently two supported
Index: xc/doc/specs/Xaw/Form
diff -u xc/doc/specs/Xaw/Form:1.1.1.3 xc/doc/specs/Xaw/Form:1.2
--- xc/doc/specs/Xaw/Form:1.1.1.3	Tue Jan 16 17:02:47 2001
+++ xc/doc/specs/Xaw/Form	Wed Aug 14 17:52:34 2002
@@ -40,7 +40,7 @@
 .NH 3
 Resources
 .LP
-When creating an Form widget instance, the following resources are
+When creating a Form widget instance, the following resources are
 retrieved from the argument list or from the resource database:
 .LP
 .IN "Form widget" "resources"
Index: xc/doc/specs/Xaw/Text
diff -u xc/doc/specs/Xaw/Text:1.1.1.3 xc/doc/specs/Xaw/Text:1.2
--- xc/doc/specs/Xaw/Text:1.1.1.3	Tue Jan 16 17:02:54 2001
+++ xc/doc/specs/Xaw/Text	Wed Aug 14 17:52:34 2002
@@ -31,7 +31,7 @@
 .NH 3
 Resources
 .LP
-When creating an Text widget instance, the following resources are
+When creating a Text widget instance, the following resources are
 retrieved from the argument list or from the resource database:
 .LP
 .IN "Text widget" "resources"
Index: xc/doc/specs/Xaw/TextSource
diff -u xc/doc/specs/Xaw/TextSource:1.1.1.3 xc/doc/specs/Xaw/TextSource:1.2
--- xc/doc/specs/Xaw/TextSource:1.1.1.3	Tue Jan 16 17:02:55 2001
+++ xc/doc/specs/Xaw/TextSource	Thu Jul  4 13:04:19 2002
@@ -122,8 +122,9 @@
 Specifies the maximum number of characters the TextSrc should
 return to the application in \fItext_return\fP.
 .LP
-This function returns the actual number of characters read from the
-text buffer.  The function is not required to return \fIlength\fP
+This function returns the text position immediately after the
+characters read from the
+text buffer.  The function is not required to read \fIlength\fP
 characters if that many characters are in the file, it may break at
 any point that is convenient to the internal structure of the
 source.  It may take several calls to \fBRead\fP before the desired
Index: xc/doc/specs/Xaw/Toggle
diff -u xc/doc/specs/Xaw/Toggle:1.1.1.3 xc/doc/specs/Xaw/Toggle:1.2
--- xc/doc/specs/Xaw/Toggle:1.1.1.3	Tue Jan 16 17:02:56 2001
+++ xc/doc/specs/Xaw/Toggle	Wed Aug 14 17:52:34 2002
@@ -46,7 +46,7 @@
 .IN "Radio groups" ""
 .IN "Radio button" ""
 .IN "Toggle widget" "used in radio groups"
-list of at least two Toggle widget in which no more than one Toggle may 
+list of at least two Toggle widgets in which no more than one Toggle may 
 be set at
 any time.  A radio group is identified by the widget ID of any one of
 its members.  The convenience routine \fBXawToggleGetCurrent\fP will
Index: xc/doc/specs/Xaw/strings.xaw
diff -u xc/doc/specs/Xaw/strings.xaw:1.1.1.3 xc/doc/specs/Xaw/strings.xaw:1.2
--- xc/doc/specs/Xaw/strings.xaw:1.1.1.3	Tue Jan 16 17:02:59 2001
+++ xc/doc/specs/Xaw/strings.xaw	Wed Aug 14 17:52:34 2002
@@ -227,7 +227,7 @@
 .el .IP label 1.5i
 Specifies the text string to be displayed in the widget's window
 if no bitmap is specified.  The default is the name of this widget.
-Irregardless of the value of \fBencoding\fP or \fBinternational\fP,
+Regardless of the value of \fBencoding\fP or \fBinternational\fP,
 a single newline character (1 byte) will cause a line break.
 ..
 .de Ll \" Label leftBitmap
@@ -670,7 +670,7 @@
 When the \fBstring\fP resource is queried, using \fBXtGetValues\fP, and
 \fBuseStringInPlace\fP is false, the value returned is valid until
 the next time the \fBstring\fP resource is queried, or until the application 
-writer calls \fBXawAsciiSrcFreeString\fP.  If \fBuseStringInPlace\fP is
+writer calls \fBXawAsciiSourceFreeString\fP.  If \fBuseStringInPlace\fP is
 true, a pointer to the actual string is returned.  See also section 5.6.
 ..
 .de Ot \" AsciiSrc type
Index: xc/doc/specs/Xext/mit-shm.ms
diff -u xc/doc/specs/Xext/mit-shm.ms:1.1.1.1 xc/doc/specs/Xext/mit-shm.ms:1.2
--- xc/doc/specs/Xext/mit-shm.ms:1.1.1.1	Wed Apr 27 03:25:28 1994
+++ xc/doc/specs/Xext/mit-shm.ms	Wed Apr  3 15:42:43 2002
@@ -213,6 +213,13 @@
 shminfo structure.  The server will need that ID to attach itself to the
 segment.
 .LP
+Also note that, on many systems for security reasons, the X server
+will only accept to attach to the shared memory segment if it's
+readable and writeable by ``other''. On systems where the X server is
+able to determine the uid of the X client over a local transport, the
+shared memory segment can be readable and writeable only by the uid of
+the client.
+.LP
 Next, attach this shared memory segment to your process:
 .Cs
 shminfo.shmaddr = image->data = shmat (shminfo.shmid, 0, 0);
Index: xc/doc/specs/XvMC/XvMC_API.txt
diff -u xc/doc/specs/XvMC/XvMC_API.txt:1.1 xc/doc/specs/XvMC/XvMC_API.txt:1.2
--- xc/doc/specs/XvMC/XvMC_API.txt:1.1	Wed Jan 16 13:36:00 2002
+++ xc/doc/specs/XvMC/XvMC_API.txt	Sat Mar 30 15:38:28 2002
@@ -528,15 +528,15 @@
 
             Field structure:
 
-                vector[0][0][1:0] -> PMV[0][0][1:0]
-                vector[2][0][1:0] -> PMV[0][1][1:0]
+                PMV[0][0][1:0]  from same parity
+                PMV[0][1][1:0]  from opposite parity
 
             Frame structure:
  
-                vector[0][0][1:0] -> PMV[0][0][1:0]  top from top
-                vector[0][0][1:0] -> PMV[0][1][1:0]  bottom from bottom
-                vector[2][0][1:0] -> PMV[1][0][1:0]  top from bottom
-                vector[3][0][1:0] -> PMV[1][1][1:0]  bottom from top
+                PMV[0][0][1:0]  top from top
+                PMV[0][1][1:0]  bottom from bottom
+                PMV[1][0][1:0]  top from bottom
+                PMV[1][1][1:0]  bottom from top
 
 
     index -  The offset in units of (64 * sizeof(short)) from the start of
Index: xc/doc/specs/programs/Imakefile
diff -u xc/doc/specs/programs/Imakefile:1.14 xc/doc/specs/programs/Imakefile:1.17
--- xc/doc/specs/programs/Imakefile:1.14	Mon Jan 14 20:22:47 2002
+++ xc/doc/specs/programs/Imakefile	Mon Feb 17 22:01:42 2003
@@ -2,7 +2,7 @@
 
 
 
-XCOMM $XFree86: xc/doc/specs/programs/Imakefile,v 1.14 2002/01/15 01:22:47 dawes Exp $
+XCOMM $XFree86: xc/doc/specs/programs/Imakefile,v 1.17 2003/02/18 03:01:42 dawes Exp $
 
 /* does not include manual pages under util (not X programs)
    or any of the library function manual pages under doc/man */
@@ -15,6 +15,8 @@
   $(TOP)/programs/Xserver/hw/xfree86/reconfig/reconfig.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/apm/apm.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/ati/ati.man \
+  $(TOP)/programs/Xserver/hw/xfree86/drivers/ati/r128.man \
+  $(TOP)/programs/Xserver/hw/xfree86/drivers/ati/radeon.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/chips/chips.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/cirrus/cirrus.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/cyrix/cyrix.man \
@@ -28,6 +30,7 @@
   $(TOP)/programs/Xserver/hw/xfree86/drivers/mga/mga.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/neomagic/neomagic.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/newport/newport.man \
+  $(TOP)/programs/Xserver/hw/xfree86/drivers/nsc/nsc.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/nv/nv.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/rendition/rendition.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/s3virge/s3virge.man \
@@ -48,6 +51,7 @@
   $(TOP)/programs/Xserver/hw/xfree86/drivers/vesa/vesa.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/vga/vga.man \
   $(TOP)/programs/Xserver/hw/xfree86/drivers/vmware/vmware.man \
+  $(TOP)/programs/Xserver/hw/xfree86/etc/gtf.man \
   $(TOP)/programs/Xserver/hw/xfree86/etc/kbd_mode.man \
   $(TOP)/programs/Xserver/hw/xfree86/etc/pcitweak.man \
   $(TOP)/programs/Xserver/hw/xfree86/etc/scanpci.man \
@@ -58,19 +62,28 @@
   $(TOP)/programs/Xserver/hw/xfree86/input/dmc/dmc.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/dynapro/dynapro.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/elographics/elographics.man \
+  $(TOP)/programs/Xserver/hw/xfree86/input/fpit/fpit.man \
+  $(TOP)/programs/Xserver/hw/xfree86/input/jamstudio/js_x.man \
+  $(TOP)/programs/Xserver/hw/xfree86/input/keyboard/kbd.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/keyboard/keyboard.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/magictouch/magictouch.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/microtouch/microtouch.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/mouse/mouse.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/mutouch/mutouch.man \
+  $(TOP)/programs/Xserver/hw/xfree86/input/palmax/palmax.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/penmount/penmount.man \
+  $(TOP)/programs/Xserver/hw/xfree86/input/tek4957/tek4957.man \
+  $(TOP)/programs/Xserver/hw/xfree86/input/ur98/ur98.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/void/void.man \
   $(TOP)/programs/Xserver/hw/xfree86/input/wacom/wacom.man \
   $(TOP)/programs/Xserver/hw/darwin/XDarwin.man \
   $(TOP)/programs/Xserver/hw/darwin/utils/dumpkeymap.man \
   $(TOP)/programs/Xserver/hw/kdrive/Xkdrive.man \
   $(TOP)/programs/Xserver/hw/kdrive/vesa/Xvesa.man \
-  $(TOP)/programs/Xserver/hw/kdrive/fbdev/Xfbdev.man
+  $(TOP)/programs/Xserver/hw/kdrive/fbdev/Xfbdev.man \
+  $(TOP)/programs/Xserver/hw/xfree86/doc/man/XF86DGA.man \
+  $(TOP)/programs/Xserver/hw/xfree86/doc/man/XF86Misc.man \
+  $(TOP)/programs/Xserver/hw/xfree86/doc/man/XF86VM.man
 
 
 MANUALS = \
@@ -80,59 +93,106 @@
   $(TOP)/doc/man/general/security.man \
   $(TOP)/programs/appres/appres.man \
   $(TOP)/programs/bdftopcf/bdftopcf.man \
+  $(TOP)/fonts/util/bdftruncate.man \
+  $(TOP)/programs/beforelight/b4light.man \
   $(TOP)/programs/bitmap/bitmap.man \
+  $(TOP)/config/util/ccmakedep.man \
+  $(TOP)/config/util/cleanlinks.man \
   $(TOP)/programs/Xserver/hw/sun/constype.man \
+  $(TOP)/programs/cxpm/cxpm.man \
+  $(TOP)/programs/xf86dga/dga.man \
+  $(TOP)/programs/dpsexec/dpsexec.man \
+  $(TOP)/programs/dpsinfo/dpsinfo.man \
   $(TOP)/programs/editres/editres.man \
-  $(TOP)/programs/xfsinfo/xfsinfo.man \
+  $(TOP)/lib/fontconfig/fc-cache/fc-cache.man \
+  $(TOP)/lib/fontconfig/fc-lang/fc-lang.man \
+  $(TOP)/lib/fontconfig/fc-list/fc-list.man \
+  $(TOP)/lib/fontconfig/src/fontconfig.man \
   $(TOP)/programs/fslsfonts/fslsfonts.man \
   $(TOP)/programs/fstobdf/fstobdf.man \
-  $(TOP)/programs/glxinfo/glxinfo.man \
+  $(TOP)/config/util/gccmakedep.man \
   $(TOP)/programs/glxgears/glxgears.man \
+  $(TOP)/programs/glxinfo/glxinfo.man \
   $(TOP)/programs/iceauth/iceauth.man \
+  $(TOP)/programs/ico/ico.man \
   $(TOP)/config/imake/imake.man \
   $(TOP)/programs/Xserver/hw/sun/kbd_mode.man \
+  $(TOP)/programs/lbxproxy/lbxproxy.man \
+  $(TOP)/programs/xrx/plugin/libxrx.man \
+  $(TOP)/programs/listres/listres.man \
   $(TOP)/config/util/lndir.man \
-  $(TOP)/config/makedepend/mkdepend.man \
+  $(TOP)/programs/luit/luit.man \
   $(TOP)/config/util/makeg.man \
+  $(TOP)/programs/makepsres/makepsres.man \
   $(TOP)/config/util/makestrs.man \
+  $(TOP)/config/util/mergelib.man \
+  $(TOP)/config/makedepend/mkdepend.man \
+  $(TOP)/programs/mkcfm/mkcfm.man \
   $(TOP)/config/util/mkdirhier.man \
   $(TOP)/programs/mkfontdir/mkfontdir.man \
+  $(TOP)/programs/mkfontscale/mkfontscale.man \
+  $(TOP)/config/util/mkhtmlindex.man \
   $(TOP)/programs/oclock/oclock.man \
+  $(TOP)/programs/proxymngr/proxymngr.man \
+  $(TOP)/config/pswrap/pswrap.man \
   $(TOP)/programs/xterm/resize.man \
+  $(TOP)/config/util/revpath.man \
+  $(TOP)/config/util/rman.man \
   $(TOP)/programs/rstart/rstart.man \
   $(TOP)/programs/rstart/rstartd.man \
   $(TOP)/programs/xdm/sessreg.man \
+  $(TOP)/programs/setxkbmap/setxkbmap.man \
+  $(TOP)/programs/showfont/showfont.man \
   $(TOP)/programs/rgb/showrgb.man \
   $(TOP)/programs/smproxy/smproxy.man \
   $(TOP)/programs/xinit/startx.man \
+  $(TOP)/programs/sxpm/sxpm.man \
+  $(TOP)/programs/xrx/testplugin/testplugin.man \
+  $(TOP)/programs/texteroids/texteroids.man \
   $(TOP)/programs/twm/twm.man \
+  $(TOP)/fonts/util/ucs2any.man \
+  $(TOP)/programs/viewres/viewres.man \
   $(TOP)/programs/x11perf/x11perf.man \
   $(TOP)/programs/x11perf/x11pcomp.man \
   $(TOP)/programs/xauth/xauth.man \
+  $(TOP)/programs/xbiff/xbiff.man \
+  $(TOP)/programs/xcalc/xcalc.man \
   $(TOP)/programs/xclipboard/xclipboard.man \
   $(TOP)/programs/xclock/xclock.man \
   $(TOP)/programs/xcmsdb/xcmsdb.man \
   $(TOP)/programs/xconsole/xconsole.man \
+  $(TOP)/programs/xcursorgen/xcursorgen.man \
   $(TOP)/programs/xclipboard/xcutsel.man \
-  $(TOP)/programs/Xserver/hw/dec/ws/Xdec.man \
+  $(TOP)/programs/xditview/xditview.man \
   $(TOP)/programs/xdm/xdm.man \
   $(TOP)/programs/xdpyinfo/xdpyinfo.man \
+  $(TOP)/programs/xedit/xedit.man \
+  $(TOP)/programs/xev/xev.man \
+  $(TOP)/programs/xeyes/xeyes.man \
   $(XFREE86_MANUALS) \
   $(TOP)/programs/xfd/xfd.man \
+  $(TOP)/programs/xfindproxy/xfindproxy.man \
+  $(TOP)/programs/xfontsel/xfontsel.man \
   $(TOP)/programs/xfs/xfs.man \
+  $(TOP)/programs/xfsinfo/xfsinfo.man \
+  $(TOP)/programs/xfwp/xfwp.man \
+  $(TOP)/programs/xgamma/xgamma.man \
+  $(TOP)/programs/xgc/xgc.man \
   $(TOP)/programs/xhost/xhost.man \
-  $(TOP)/programs/Xserver/hw/hp/Xhp.man \
   $(TOP)/programs/xieperf/xieperf.man \
   $(TOP)/programs/xinit/xinit.man \
   $(TOP)/programs/xkbcomp/xkbcomp.man \
   $(TOP)/programs/xkbevd/xkbevd.man \
   $(TOP)/programs/xkbprint/xkbprint.man \
   $(TOP)/programs/xkill/xkill.man \
+  $(TOP)/programs/xload/xload.man \
   $(TOP)/programs/xlogo/xlogo.man \
   $(TOP)/programs/xlsatoms/xlsatoms.man \
   $(TOP)/programs/xlsclients/xlscli.man \
   $(TOP)/programs/xlsfonts/xlsfonts.man \
   $(TOP)/programs/xmag/xmag.man \
+  $(TOP)/programs/xman/xman.man \
+  $(TOP)/programs/xmessage/xmessage.man \
   $(TOP)/programs/xmh/xmh.man \
   $(TOP)/config/util/xmkmf.man \
   $(TOP)/programs/xmodmap/xmodmap.man \
@@ -142,14 +202,19 @@
   $(TOP)/programs/xrandr/xrandr.man \
   $(TOP)/programs/xrdb/xrdb.man \
   $(TOP)/programs/xrefresh/xrefresh.man \
+  $(TOP)/programs/xrx/helper/xrx.man \
   $(TOP)/programs/Xserver/Xserver.man \
   $(TOP)/programs/xset/xset.man \
+  $(TOP)/programs/xsetmode/xsetmode.man \
+  $(TOP)/programs/xsetpointer/xsetpnt.man \
   $(TOP)/programs/xsetroot/xsetroot.man \
   $(TOP)/programs/xsm/xsm.man \
   $(TOP)/programs/xstdcmap/xstdcmap.man \
   $(TOP)/programs/Xserver/hw/sun/Xsun.man \
   $(TOP)/programs/xterm/xterm.man \
   $(TOP)/programs/xtrap/xtrap.man \
+  $(TOP)/programs/xvidtune/xvidtune.man \
+  $(TOP)/programs/xvinfo/xvinfo.man \
   $(TOP)/programs/Xserver/hw/vfb/Xvfb.man \
   $(TOP)/programs/xwd/xwd.man \
   $(TOP)/programs/xwininfo/xwininfo.man \
Index: xc/doc/specs/saver/Imakefile
diff -u /dev/null xc/doc/specs/saver/Imakefile:1.1
--- /dev/null	Thu Feb 27 12:14:25 2003
+++ xc/doc/specs/saver/Imakefile	Tue May  7 16:08:25 2002
@@ -0,0 +1,6 @@
+XCOMM $XFree86: xc/doc/specs/saver/Imakefile,v 1.1 2002/05/07 20:08:25 tsi Exp $
+
+MakeSimpleDoc(saver,saver.ms)
+
+InstallRoffDoc(saver)
+
Index: xc/doc/specs/saver/saver.ms
diff -u /dev/null xc/doc/specs/saver/saver.ms:1.1
--- /dev/null	Thu Feb 27 12:14:26 2003
+++ xc/doc/specs/saver/saver.ms	Tue May  7 16:08:25 2002
@@ -0,0 +1,881 @@
+.\" Use tbl, -ms
+.\" $XConsortium: saver.ms,v 1.5 92/02/11 17:05:26 keith Exp $
+.\" $NCDId: @(#)screensaver.ms,v 1.24 1992/02/22 14:00:00 jim Exp jim $
+.EH ''''
+.OH ''''
+.EF ''''
+.OF ''''
+.\" Change the contents of the following of Pp to PP to have it indent
+.de Pp
+.LP
+..
+.de PN
+\\fB\\^\\$1\^\\fR\\$2
+..
+.de Pn
+\\$1\\fB\\^\\$2\^\\fR\\$3
+..
+.de Rq
+.sp
+.LP
+.\" .in +.50i
+.PN \\$1
+.in +.33i
+.sp .5v
+.\".LP
+..
+.de Sm
+.\".in -.50i
+.in -.33i
+.Pp
+..
+.de Ar
+.br
+\\fI\\$1\\fP\\^: \\$2
+..
+.de Rp
+.in -.2i
+.br
+.sp .5v
+\(->
+.br
+.sp .5v
+.in +.2i
+..
+.de Rv
+.br
+\\$1: \\$2
+..
+.ps 11
+.nr PS 11
+.nr PD 1v
+\&
+.sp 8
+.ce 1
+\s+2\fBX11 SCREEN SAVER EXTENSION\fP\s-2
+.sp 3
+.ce 3
+Version 1.0
+MIT X Consortium Proposed Standard
+X Version 11, Release 5
+.sp 6
+.ce 4
+\s-1Jim Fulton
+.sp 6p
+Network Computing Devices, Inc.\s+1
+.sp 3
+.ce 4
+\s-1Keith Packard
+.sp 6p
+X Consortium
+Laboratory for Computer Science
+Massachusetts Institute of Technology\s+1
+.ps 9
+.nr PS 9
+.sp 8
+.LP
+Copyright \(co 1992 by the Massachusetts Institute of Technology and 
+Network Computing Devices, Inc.
+.LP
+Permission to use, copy, modify, and distribute this documentation for any
+purpose and without fee is hereby granted, provided that the above copyright
+notice and this permission notice appear in all copies.  MIT and
+Network Computing Devices, Inc. make no
+representations about the suitability for any purpose of the information in
+this document.  This documentation is provided ``as is'' without express or
+implied warranty.
+.ps 11
+.nr PS 11
+.bp 1
+.EH ''\s10X11 Screen Saver Extension\s0''
+.OH ''\s10X11 Screen Saver Extension\s0''
+.EF ''\s10\fB % \fP\s0''
+.OF ''\s10\fB % \fP\s0''
+.NH 1
+Introduction
+.Pp
+The X Window System provides support for changing the image on a display screen
+after a user-settable period of inactivity to avoid burning the cathode ray
+tube phosphors.  However, no interfaces are provided for the user to control
+the image that is drawn.  This extension allows an external ``screen saver''
+client to detect when the alternate image is to be displayed and to provide the
+graphics.
+.Pp
+Current X server implementations typically provide at least one form of
+``screen saver'' image.  Historically, this has been a copy of the X logo
+drawn against the root background pattern.  However, many users have asked
+for the mechanism to allow them to write screen saver programs that provide
+capabilities similar to those provided by other window systems.  In
+particular, such users often wish to be able to display corporate logos,
+instructions on how to reactivate the screen, and automatic screen-locking
+utilities.  This extension provides a means for writing such clients.
+.NH 1
+Assumptions
+.Pp
+This extension exports the notion of a special screen saver window that is
+mapped above all other windows on a display.  This window has the
+\fIoverride-redirect\fP attribute set so that it is not subject to manipulation by
+the window manager.  Furthermore, the X identifier for the window is never
+returned by \fBQueryTree\fP requests on the root window, so it is typically
+not visible to other clients.  
+.NH 1
+Overview
+.Pp
+The core
+.PN SetScreenSaver
+request can be used to set the length of time without
+activity on any input devices after which the screen saver should ``activate''
+and alter the image on the screen.  This image periodically ``cycles'' to 
+reduce
+the length of time that any particular pixel is illuminated.  Finally, the
+screen saver is ``deactivated'' in response to activity on any of the input 
+devices
+or particular X requests.
+.Pp
+Screen saving is typically done by disabling video output to the display tube
+or by drawing a changing pattern onto the display.  If the server chooses the
+latter approach, a window with a special identifier is created and mapped at
+the top of the stacking order where it remains until the screen saver
+deactivates.  At this time, the window is unmapped and is not accessible to any
+client requests.
+.Pp
+The server's default mechanism is refered to as the \fIinternal\fP screen 
+saver.  An \fIexternal\fP
+screen saver client requires a means of determining the window
+id for the screen saver window and setting the attributes (e.g. size,
+location, visual, colormap) to be used when the window is mapped.  These
+requirements form the basis of this extension.
+.NH 1
+Issues
+.Pp
+This extension raises several interesting issues.  First is the question of
+what should be done if some other client has the server grabbed when the screen
+saver is supposed to activate?  This commonly occurs with window managers that
+automatically ask the user to position a window when it is first mapped by
+grabbing the server and drawing XORed lines on the root window.
+.Pp
+Second, a screen saver program must control the actual RGB values sent to the
+display tube to ensure that the values change periodically to avoid phosphor
+burn in.  Thus, the client must have a known colormap installed whenever the
+screen saver window is displayed.  To prevent screen flashing, the visual type
+of the screen saver window should also be controlable.
+.Pp
+Third, some implementations may wish to destroy the screen saver window when
+it is not mapped so that it need not be avoided during event delivery.  Thus,
+screen saver clients may find that the requests that reference the screen 
+saver window may fail when the window is not displayed.
+.NH 1
+Protocol
+.Pp
+The Screen Saver extension is as follows:
+.NH 2
+Types
+.Pp
+In adition to the comon types described in the core protocol, the following
+type is used in the request and event definitions in subsequent sections.
+.Pp
+.TS
+lw(2i) lw(3.75i).
+_
+.sp 6p
+.B
+Name	Value
+.sp 6p
+_
+.sp 6p
+.R
+SCREENSAVEREVENT	T{
+.Pn { ScreenSaverNotify ,
+.PN ScreenSaverCycle }
+T}
+.TE
+.NH 2
+Errors
+.Pp
+The Screen Saver extension adds no errors beyond the core protocol.
+.NH 2
+Requests
+.Pp
+The Screen Saver extension adds the following requests:
+.Rq ScreenSaverQueryVersion
+.Ar client-major-version CARD8
+.Ar client-minor-version CARD8
+.Rp
+.Rv server-major-version CARD8
+.Rv server-minor-version CARD8
+.Sm
+This request allows the client and server to determine which version of
+the protocol should be used.  The client sends the version that it
+prefers; if the server understands that
+version, it returns the same values and interprets subsequent requests
+for this extension according to the specified version.  Otherwise,
+the server returns the closest version of the protocol that it can
+support and interprets subsequent requests according to that version.
+This document describes major version 1, minor version 0; the major
+and minor revision numbers should only be incremented in response to
+incompatible and compatible changes, respectively.
+.Rq ScreenSaverQueryInfo
+.Ar drawable DRAWABLE
+.Rp
+.Rv saver-window WINDOW
+.Rv state 
+.Pn { Disabled ,
+.PN Off ,
+.PN On }
+.Rv kind
+.Pn { Blanked ,
+.PN Internal ,
+.PN External }
+.Rv til-or-since CARD32
+.Rv idle CARD32
+.Rv event-mask SETofSCREENSAVEREVENT
+.LP
+.Rv Errors
+.PN Drawable
+.Sm
+This request returns information about the state of the screen
+saver on the screen associated with \fIdrawable\fP.  The \fIsaver-window\fP 
+is the XID that is associated with the screen saver window.  This
+window is not guaranteed to exist
+except when external screen saver is active.  Although it is a 
+child of the root, this window is not returned by
+.PN QueryTree
+requests on the root.  Whenever this window is mapped, it is always above
+any of its siblings in the stacking order.  XXX - TranslateCoords?
+.Pp
+The \fIstate\fP field specifies whether or not the screen saver is currently
+active and how the \fItil-or-since\fP value should be interpretted:
+.in +.5i
+.TS
+lw(1.5i) lw(3.5i).
+T{
+.PN Off
+T}	T{
+The screen is not currently being saved; \fItil-or-since\fP
+specifies the number of milliseconds until the screen saver is expected to
+activate.
+T}
+.sp
+T{
+.PN On
+T}	T{
+The screen is currently being saved; \fItil-or-since\fP specifies
+the number of milliseconds since the screen saver activated.
+T}
+.sp
+T{
+.PN Disabled
+T}	T{
+The screen saver is currently disabled; \fItil-or-since\fP is zero.
+T}
+.TE
+.in -.5i
+.Pp
+The \fIkind\fP field specifies the mechanism that either is currently being
+used or would have been were the screen being saved:
+.in +.5i
+.TS
+lw(1.5i) lw(3.5i).
+T{
+.PN Blanked
+T}	T{
+The video signal to the display monitor was disabled.
+T}
+.sp
+T{
+.PN Internal
+T}	T{
+A server-dependent, built-in screen saver image was displayed; either no
+client had set the screen saver window attributes or a different client 
+had the server grabbed when the screen saver activated.
+T}
+.sp
+T{
+.PN External
+T}	T{
+The screen saver window was mapped with attributes set by a
+client using the \fBScreenSaverSetAttributes\fP request.
+T}
+.TE
+.in -.5i
+.Pp
+The \fIidle\fP field specifies the number of milliseconds since the last
+input was received from the user on any of the input devices.
+.Pp
+The \fIevent-mask\fP field specifies which, if any, screen saver
+events this client has requested using \fBScreenSaverSelectInput\fP.
+.Pp
+If \fIdrawable\fP is not a valid drawable identifier, a Drawable
+error is returned and the request is ignored.
+.Rq ScreenSaverSelectInput
+.Ar drawable DRAWABLE
+.Ar event-mask SETofSCREENSAVEREVENT
+.LP
+Errors:
+.PN Drawable ,
+.PN Match
+.Sm
+This request specifies which Screen Saver extension events on the screen 
+associated with \fIdrawable\fP should be generated for this client.  If
+no bits are set in \fIevent-mask\fP, then no events will be generated.
+Otherwise, any combination of the following bits may be set:
+.in +.5i
+.TS
+lw(1.5i) lw(3.5i).
+T{
+.PN ScreenSaverNotify
+T}	T{
+If this bit is set, \fBScreenSaverNotify\fP events are generated whenever
+the screen saver is activated or deactivated.
+T}
+.sp
+T{
+.PN ScreenSaverCycle
+T}	T{
+If this bit is set, \fBScreenSaverNotify\fP events are generated whenever
+the screen saver cycle interval passes.
+T}
+.TE
+.in -.5i
+.Pp
+If \fIdrawable\fP is not a valid drawable identifier, a Drawable
+error is returned.  If any undefined bits are set in \fIevent-mask\fP,
+a Value error is returned.  If an error is returned,
+the request is ignored.
+.Rq ScreenSaverSetAttributes
+.Ar drawable DRAWABLE
+.Ar class 
+.Pn { InputOutput , 
+.PN InputOnly , 
+.PN CopyFromParent }
+.Ar depth CARD8
+.Ar visual "VISUALID or"
+.PN CopyFromParent
+.Ar "x, y" INT16
+.Ar "width, height, border-width" CARD16
+.Ar value-mask BITMASK
+.Ar value-list LISTofVALUE
+.LP
+.Rv Errors
+.PN Access ,
+.PN Window ,
+.PN Pixmap ,
+.PN Colormap ,
+.PN Cursor ,
+.PN Match ,
+.PN Value ,
+.PN Alloc
+.Sm
+This request sets the attributes that this client would like to see
+used in creating the screen saver window on the screen associated
+with \fIdrawable\fP.  If another client currently has the attributes set,
+an Access error is generated and the request is ignored.
+.Pp
+Otherwise, the specified window attributes are checked as if
+they were used in a core \fBCreateWindow\fP request whose
+parent is the root.  The \fIoverride-redirect\fP field is ignored as
+it is implicitly set to True.  If the window attributes result in an
+error according to the rules for \fBCreateWindow\fP, the request is
+ignored.
+.Pp
+Otherwise, the attributes are stored and will take effect on the next 
+activation that occurs when the server is not grabbed by another client.
+Any resources specified for the
+\fIbackground-pixmap\fP or \fIcursor\fP attributes may be
+freed immediately.  The server is free to copy the \fIbackground-pixmap\fP
+or \fIcursor\fP resources or to use them in place; therefore, the effect of
+changing the contents of those resources is undefined.  If the 
+specified \fIcolormap\fP no longer exists when the screen saver activates,
+the parent's colormap is used instead.  If no errors are generated by this
+request, any previous
+screen saver window attributes set by this client are released.
+.Pp
+When the screen saver next activates and the server is not grabbed by 
+another client, the screen saver window is 
+created, if necessary, and set to the specified attributes and events
+are generated as usual.  The colormap
+associated with the screen saver window is 
+installed.  Finally, the screen saver window is mapped.
+.Pp
+The window remains mapped and at the top of the stacking order
+until the screen saver is deactivated in response to activity on
+any of the user input devices, a \fBForceScreenSaver\fP request with
+a value of Reset, or any request that would cause the window to be
+unmapped.
+.Pp
+If the screen saver activates while the server is grabbed by another
+client, the internal saver mechanism is used.  The \fBForceScreenSaver\fP 
+request may be used with a value of Active to 
+deactivate the internal saver and activate the external saver.
+.Pp
+If the screen saver client's connection to the server is broken
+while the screen saver is activated and the client's close down mode has not
+been RetainPermanent or RetainTemporary, the current screen saver
+is deactivated and the internal screen saver is immediately activated.
+.Pp
+When the screen saver deactivates, the screen saver window's colormap
+is uninstalled and the window is unmapped (except as described below).
+The screen saver XID is disassociated
+with the window and the server may, but is not required to,
+destroy the window along with any children.
+.Pp
+When the screen saver is being deactivated and then immediately
+reactivated (such as when switching screen savers), the server
+may leave the screen saver window mapped (typically to avoid 
+generating exposures).
+.Rq ScreenSaverUnsetAttributes
+.Ar drawble DRAWABLE
+.LP
+.Rv Errors
+.PN Drawable
+.Sm
+This request notifies the server that this client no longer
+wishes to control the screen saver window.  Any screen saver
+attributes set by this client and any descendents of the screen
+saver window created by this client should be released
+immediately if the screen saver is not active, else upon
+deactivation.
+.Pp
+This request is ignored if the client has not previously set the screen saver
+window attributes.
+.NH 2
+Events
+.Pp
+The Screen Saver extension adds one event:
+.Rq ScreenSaverNotify
+.Ar root WINDOW
+.Ar window WINDOW
+.Ar state
+.Pn { Off ,
+.PN On ,
+.PN Cycle }
+.Ar kind 
+.Pn { Blanked ,
+.PN Internal ,
+.PN External }
+.Ar forced BOOL
+.Ar time TIMESTAMP
+.Sm
+This event is delivered to clients that have requested
+ScreenSaverNotify events using the \fBScreenSaverSelectInput\fP request
+whenever the screen saver activates or deactivates.
+.Pp
+The \fIroot\fP field specifies root window of the screen for
+which the event was generated.  The \fIwindow\fP field specifies
+the value that is returned by \fBScreenSaverQueryInfo\fP as
+the identifier for the screen saver window.  This window is not
+required to exist if the external screen saver is not active.
+.Pp
+The \fIstate\fP field specifies the cause of the event:
+.in +.5i
+.TS
+lw(1.5i) lw(3.5i).
+T{
+.PN Off
+T}	T{
+The screen saver deactivated; this event is sent if the client has set the
+ScreenSaverNotify bit in its event mask.
+T}
+.sp
+T{
+.PN On
+T}	T{
+The screen saver activated.  This event is sent if the client has set the
+ScreenSaverNotify bit in its event mask.
+T}
+.sp
+T{
+.PN Cycle
+T}	T{
+The cycle interval passed and the client is expected to change the image on
+the screen.  This event is sent if the client has set the
+ScreenSaverCycle bit in its event mask.
+T}
+.TE
+.in -.5i
+.LP
+If \fIstate\fP is set to 
+.PN On 
+or
+.PN Off
+then \fIforced\fP indicates whether or not activation or
+deactivation was caused by a core
+.PN ForceScreenSaver
+request; otherwise, \fIforced\fP is set to False.
+.Pp
+The \fIkind\fP field specifies mechanism that was used to save the screen
+when the screen saver was activated, as described in 
+\fBScreenSaverQueryInfo\fP.
+.Pp
+The \fItime\fP field indicates the server time when the 
+event was generated.
+.NH 1
+Encoding
+.Pp
+Please refer to the X11 Protocol Encoding document as this document uses
+conventions established there.
+.Pp
+The name of this extension is ``SCREEN-SAVER''.
+.LP
+.NH 2
+Common Types
+.LP
+.TA .75i 1.75i
+.ta .75i 1.75i
+.nf
+.R
+SETofSCREENSAVEREVENT
+	#x00000001	ScreenSaverNotifyMask
+	#x00000002	ScreenSaverCycleMask
+.fi
+.NH 2
+Requests
+.de En
+.LP
+.PN \\$1
+.TA .5i 1.5i 2.5i
+.ta .5i 1.5i 2.5i
+.in +.33i
+.nf
+..
+.de Ee
+.in -.33i
+.fi
+..
+.En ScreenSaverQueryVersion
+1	CARD8		screen saver opcode
+1	0		minor opcode
+2   	2		request length
+1	CARD8		client major version
+1	CARD8		client minor version
+2			unused
+.Rp
+1	1		Reply
+1			unused
+2	CARD16		sequence number
+4	0		reply length
+1	CARD8		server major version
+1	CARD8		server minor version
+22			unused
+.Ee
+.En ScreenSaverQueryInfo
+1	CARD8		screen saver opcode
+1	1		minor opcode
+2	2		request length
+4	DRAWABLE		drawable associated with screen
+.Rp
+1	1		Reply
+1	CARD8		state
+	0	Off
+	1	On
+	3	Disabled
+2	CARD16		sequence number
+4	0		reply length
+4	WINDOW		saver window
+4	CARD32		milliseconds until saver or since saver
+4	CARD32		milliseconds since last user device input
+4	SETofSCREENSAVEREVENT		event mask
+1	CARD8		kind
+	0	Blanked
+	1	Internal
+	2	External
+10			unused
+.Ee
+.En ScreenSaverSelectInput
+1	CARD8		screen saver opcode
+1	2		minor opcode
+2	3		request length
+4	DRAWABLE		drawable associated with screen
+4	SETofSCREENSAVEREVENT		event mask
+.Ee
+.En ScreenSaverSetAttributes
+1	CARD8		screen saver opcode
+1	3		minor opcode
+2	6+n		request length
+4	DRAWABLE		drawable associated with screen
+2	INT16		x
+2	INT16		y
+2	CARD16		width
+2	CARD16		height
+2	CARD16		border-width
+1			class
+	0	CopyFromParent
+	1	InputOutput
+	2	InputOnly
+1	CARD8		depth
+4	VISUALID		visual
+	0	CopyFromParent
+4	BITMASK			value-mask (has n bits set to 1)
+	encodings are the same as for core CreateWindow
+4n	LISTofVALUE		value-list
+	encodings are the same as for core CreateWindow
+.Ee
+.En ScreenSaverUnsetAttributes
+1	CARD8		screen saver opcode
+1	4		minor opcode
+2	3		request length
+4	DRAWABLE		drawable associated with screen
+.Ee
+.NH 2
+Events
+.En ScreenSaverNotify
+1	CARD8		code assigned by core
+1	CARD8		state
+	0	Off
+	1	On
+	2	Cycle
+2	CARD16		sequence number
+4	TIMESTAMP		time
+4	WINDOW		root
+4	WINDOW		screen saver window
+1	CARD8		kind
+	0	Blanked
+	1	Internal
+	2	External
+1	BOOL		forced
+14			unused
+.Ee
+.NH 1
+Inter-Client Communications Conventions
+.Pp
+Screen saver clients should create at least one resource value whose
+identifier can be stored in a property named
+.PN _SCREEN_SAVER_ID
+on the root of each screen it is managing.
+This property should have one 32-bit value corresponding to the resource
+identifier; the type of the property should indicate the type of the
+resource and should be one of the following: 
+.PN WINDOW ,
+.PN PIXMAP ,
+.PN CURSOR ,
+.PN FONT , or
+.PN COLORMAP .
+.NH 1
+C language binding
+.Pp
+The C binding for this extension simply provide access to the protocol; they
+add no semantics beyond what is described above.
+.Pp
+The include file for this extension is
+.Pn < X11/extensions/scrnsaver.h >.
+.LP
+Bool
+.br
+XScreenSaverQueryExtension (display, event_base, error_base)
+.RS
+Display *display;
+.br
+int *event_base; /* RETURN */
+.br
+int *error_base; /* RETURN */
+.RE
+.IP
+This routine returns
+.PN True
+if the specified \fIdisplay\fP supports the SCREEN-SAVER extension; 
+otherwise it returns
+.PN False .
+If the extension is supported, the event number for 
+.PN ScreenSaverNotify
+events is returned in the value pointed to by \fIevent_base\fP.  Since
+no additional errors are defined by this extension, the results
+of \fIerror_base\fP are not defined.
+.LP
+Status
+.br
+XScreenSaverQueryVersion (display, major, minor)
+.RS
+Display *display;
+.br
+int *major; /* RETURN */
+.br
+int *minor; /* RETURN */
+.RE
+.IP
+If the specified \fIdisplay\fP supports the extension,
+the version numbers of the protocol
+expected by the server are returned in \fImajor\fP and \fIminor\fP and
+a non-zero value is returned.  Otherwise, the arguments are not 
+set and 0 is returned.
+.LP
+XScreenSaverInfo *
+.br
+XScreenSaverAllocInfo ()
+.IP
+This routine allocates and returns an \fBXScreenSaverInfo\fP structure
+for use in calls to \fBXScreenSaverQueryInfo\fP.  All fields in the
+structure are initialized to zero.  If insufficient memory is available,
+NULL is returned.  The results of this routine can be released
+using \fIXFree\fP.
+.LP
+Status
+.br
+XScreenSaverQueryInfo (display, drawable, saver_info)
+.RS
+Display *display;
+.br
+Drawable drawable;
+.br
+XScreenSaverInfo *saver_info; /* RETURN */
+.RE
+.IP
+If the specified \fIdisplay\fP supports the extension,
+information about the current state of the
+screen server is returned in \fIsaver_info\fP and a non-zero value is
+returned.  The \fBXScreenSaverInfo\fP structure is defined as follows:
+.sp
+.in +.5i
+.TA 4i
+.ta 4i
+typedef struct {
+    Window window;                /* screen saver window */
+    int state;                    /* ScreenSaver{Off,On,Disabled} */
+    int kind;                     /* ScreenSaver{Blanked,Internal,External} */
+    unsigned long til_or_since;   /* milliseconds */
+    unsigned long idle;           /* milliseconds */
+    unsigned long event_mask;     /* events */
+.br
+} XScreenSaverInfo;
+.in -.5i
+.sp
+See the \fBScreenSaverQueryInfo\fP request for a description of the fields.
+If the extension is not supported, \fIsaver_info\fP is not changed and 0
+is returned.
+.LP
+void
+.br
+XScreenSaverSelectInput (display, drawable, event_mask)
+.RS
+Display *display;
+.br
+Drawable drawable;
+.br
+unsigned long event_mask;
+.RE
+.IP
+If the specified \fIdisplay\fP supports the extension,
+this routine asks that events related to 
+the screen saver be generated for this client.
+The format of the events generated is:
+.sp
+.in +.5i
+.TA 4i
+.ta 4i
+typedef struct {
+    int type;               /* of event */
+    unsigned long serial;   /* # of last request processed by server */
+    Bool send_event;        /* true if this came frome a SendEvent request */
+    Display *display;       /* Display the event was read from */
+    Window window;          /* screen saver window */
+    Window root;            /* root window of event screen */
+    int state;              /* ScreenSaver{Off,On,Cycle} */
+    int kind;               /* ScreenSaver{Blanked,Internal,External} */
+    Bool forced;            /* extents of new region */
+    Time time;              /* event timestamp */
+.br
+} XScreenSaverNotifyEvent;
+.in -.5i
+.sp
+See the
+definition of the \fBScreenSaverSelectInput\fP request for descriptions
+of the allowed event masks.  
+.LP
+void
+.br
+XScreenSaverSetAttributes (display, drawable, x, y, width, height, border_width, depth, class, visual, valuemask, attributes)
+.RS
+Display *dpy;
+.br
+Drawable drawable;
+.br
+int x;
+.br
+int y;
+.br
+unsigned int width;
+.br
+unsigned int height;
+.br
+unsigned int border_width;
+.br
+int depth;
+.br
+unsigned int class;
+.br
+Visual *visual;
+.br
+unsigned long valuemask;
+.br
+XSetWindowAttributes *attributes;
+.RE
+.IP
+If the specified \fIdisplay\fP supports the extension,
+this routine sets the attributes to be used
+the next time the external screen saver is activated.  See the definition
+of the \fBScreenSaverSetAttributes\fP request for a description of each of
+the arguments.
+.LP
+void
+.br
+XScreenSaverUnsetAttributes (display, drawable)
+.RS
+Display *display;
+.br
+Drawable drawable;
+.RE
+.IP
+If the specified \fIdisplay\fP supports the extension,
+this routine instructs the server to discard
+any previous screen saver window attributes set by this client.
+.LP
+Status
+.br
+XScreenSaverRegister (display, screen, xid, type)
+.RS
+Display *display;
+.br
+int screen;
+.br
+XID xid;
+.br
+Atom type;
+.RE
+.IP
+This routine stores the given \fIXID\fP in the \fB_SCREEN_SAVER_ID\fP 
+property (of the given \fItype\fP) on the
+root window of the specified \fIscreen\fP.  It returns zero if an error
+is encountered and the property is not changed, otherwise it returns 
+non-zero.
+.LP
+Status
+.br
+XScreenSaverUnregister (display, screen)
+.RS
+Display *display;
+.br
+int screen;
+.RE
+.IP
+This routine removes any \fB_SCREEN_SAVER_ID\fP from the 
+root window of the specified \fIscreen\fP.  It returns zero if an error
+is encountered and the property is changed, otherwise it returns 
+non-zero.
+.LP
+Status
+.br
+XScreenSaverGetRegistered (display, screen, xid, type)
+.RS
+Display *display;
+.br
+int screen;
+.br
+XID *xid; /* RETURN */
+.br
+Atom *type; /* RETURN */
+.RE
+.IP
+This routine returns the \fIXID\fP and \fItype\fP stored in
+the \fB_SCREEN_SAVER_ID\fP property on the
+root window of the specified \fIscreen\fP.  It returns zero if an error
+is encountered or if the property does not exist or is not of the correct
+format; otherwise it returns non-zero.
Index: xc/doc/specs/xterm/ctlseqs.ms
diff -u xc/doc/specs/xterm/ctlseqs.ms:3.44 xc/doc/specs/xterm/ctlseqs.ms:3.48
--- xc/doc/specs/xterm/ctlseqs.ms:3.44	Sat Jan  5 16:55:11 2002
+++ xc/doc/specs/xterm/ctlseqs.ms	Fri Dec 27 14:30:24 2002
@@ -5,10 +5,10 @@
 .\"
 .\"
 .\"
-.\" $XFree86: xc/doc/specs/xterm/ctlseqs.ms,v 3.44 2002/01/05 21:55:11 dickey Exp $
+.\" $XFree86: xc/doc/specs/xterm/ctlseqs.ms,v 3.48 2002/12/27 19:30:24 dickey Exp $
 .\"
 .\"
-.\" Copyright 1996,1997,1998,1999,2000,2001,2002 by Thomas E. Dickey
+.\" Copyright 1996-2001,2002 by Thomas E. Dickey
 .\"
 .\"                         All Rights Reserved
 .\"
@@ -128,9 +128,17 @@
 .[] AP \v'-1p'\s\nsAPC\s0\v'1p'
 .[] Bs \v'-1p'\s\nsBS\s0\v'1p'
 .[] Cs \v'-1p'\s\nsCSI\s0\v'1p'
+.[] S2 \v'-1p'\s\nsSS2\s0\v'1p'
 .[] S3 \v'-1p'\s\nsSS3\s0\v'1p'
+.[] SS \v'-1p'\s\nsSOS\s0\v'1p'
+.[] Eg \v'-1p'\s\nsEPA\s0\v'1p'
+.[] Sg \v'-1p'\s\nsSPA\s0\v'1p'
 .[] Dc \v'-1p'\s\nsDCS\s0\v'1p'
+.[] Ht \v'-1p'\s\nsHTS\s0\v'1p'
+.[] ID \v'-1p'\s\nsIND\s0\v'1p'
+.[] Nl \v'-1p'\s\nsNEL\s0\v'1p'
 .[] Os \v'-1p'\s\nsOSC\s0\v'1p'
+.[] RI \v'-1p'\s\nsRI\s0\v'1p'
 .[] PM \v'-1p'\s\nsPM\s0\v'1p'
 .[] ST \v'-1p'\s\nsST\s0\v'1p'
 .[] Ta \v'-1p'\*T\v'1p'
@@ -158,6 +166,9 @@
 .[] ) )
 .[] * *
 .[] + +
+.[] , ,
+.[] - -
+.[] . .
 .[] 0 0
 .[] 1 1
 .[] 2 2
@@ -209,7 +220,7 @@
 .[] & &
 .[] ^ ^
 .[] _ _
-.[] qu \'
+.[] qu \&'
 .[] ` \`
 .[] a a
 .[] b b
@@ -311,37 +322,37 @@
 The following pairs of 7-bit and 8-bit control characters are equivalent:
 .St
 .IP \\*(Es\\*D
-Index (IND: 0x84)
+Index (\*(ID is 0x84)
 .IP \\*(Es\\*E
-Next Line (NEL: 0x85)
+Next Line (\*(Nl is 0x85)
 .IP \\*(Es\\*H
-Tab Set (HTS: 0x88)
+Tab Set (\*(Ht is 0x88)
 .IP \\*(Es\\*M
-Reverse Index (RI: 0x8d)
+Reverse Index (\*(RI is 0x8d)
 .IP \\*(Es\\*N
-Single Shift Select of G2 Character Set (SS2: 0x8e): affects next character only
+Single Shift Select of G2 Character Set (\*(S2 is 0x8e): affects next character only
 .IP \\*(Es\\*O
-Single Shift Select of G3 Character Set (SS3: 0x8f): affects next character only
+Single Shift Select of G3 Character Set (\*(S3 is 0x8f): affects next character only
 .IP \\*(Es\\*P
-Device Control String (DCS: 0x90)
+Device Control String (\*(Dc is 0x90)
 .IP \\*(Es\\*V
-Start of Guarded Area (SPA: 0x96)
+Start of Guarded Area (\*(Sg is 0x96)
 .IP \\*(Es\\*W
-End of Guarded Area (EPA: 0x97)
-.IP \\*(Es\\(*X
-Start of String (SOS: 0x98)
+End of Guarded Area (\*(Eg is 0x97)
+.IP \\*(Es\\*(XX
+Start of String (\*(SS is 0x98)
 .IP \\*(Es\\*Z
-Return Terminal ID (DECID: 0x9a).  Obsolete form of \*(Cs\*c (DA).
+Return Terminal ID (DECID is 0x9a).  Obsolete form of \*(Cs\*c (DA).
 .IP \\*(Es\\*([[
-Control Sequence Introducer (CSI: 0x9b)
+Control Sequence Introducer (\*(Cs is 0x9b)
 .IP \\*(Es\\*(bS
-String Terminator (ST: 0x9c)
+String Terminator (\*(ST is 0x9c)
 .IP \\*(Es\\*(]]
-Operating System Command (OSC: 0x9d)
+Operating System Command (\*(Os is 0x9d)
 .IP \\*(Es\\*^
-Privacy Message (PM: 0x9e)
+Privacy Message (\*(PM is 0x9e)
 .IP \\*(Es\\*_
-Application Program Command (APC: 0x9f)
+Application Program Command (\*(AP is 0x9f)
 .Ed
 .sp
 .LP
@@ -380,7 +391,7 @@
 .
 .IP \\*(En
 Return Terminal Status (Ctrl-E).
-Default response is the terminal name, e.g., "xterm", but may be overridden
+Default response is an empty string, but may be overridden
 by a resource \fIanswerbackString\fP.
 .
 .IP \\*(Ff
@@ -421,13 +432,13 @@
 8-bit controls (S8C1T).
 .
 .IP \\*(Es\\*(Sp\\*L
-Set ANSI conformance level 1 (vt100, 7-bit controls).
+Set ANSI conformance level 1 (VT100, 7-bit controls).
 .
 .IP \\*(Es\\*(Sp\\*M
-Set ANSI conformance level 2 (vt200).
+Set ANSI conformance level 2 (VT200).
 .
 .IP \\*(Es\\*(Sp\\*N
-Set ANSI conformance level 3 (vt300).
+Set ANSI conformance level 3 (VT300).
 .
 .IP \\*(Es\\*#\\*3
 DEC double-height line, top half (DECDHL)
@@ -523,7 +534,7 @@
 .B
 Application Program-Control functions
 .IP \\*(AP\\*(Pt\\*s\\*(ST
-\fIxterm\fP implements no APC functions; \*(Pt is ignored.
+\fIxterm\fP implements no \*(AP functions; \*(Pt is ignored.
 \*(Pt need not be printable characters.
 .Ed
 .
@@ -581,7 +592,7 @@
 .St
 .LP
 .B
-Functions using CSI, ordered by the final character(s)
+Functions using \*(Cs, ordered by the final character(s)
 .IP \\*(Cs\\*(Ps\\*s\\*@
 Insert \*(Ps (Blank) Character(s) (default = 1) (ICH)
 .
@@ -672,7 +683,7 @@
 .IP \\*(Cs\\*(Ps\\*s\\*c
 Send Device Attributes (Primary DA)
   \*(Ps = \*0, 1 or omitted \(-> request attributes from terminal.
-The response depends on the \fBdecTerminalId\fP resource setting.
+The response depends on the \fBdecTerminalID\fP resource setting.
   \(-> \*(Cs\*?\*1\*;\*2\*c (``VT100 with Advanced Video Option'')
   \(-> \*(Cs\*?\*1\*;\*0\*c (``VT101 with No Options'')
   \(-> \*(Cs\*?\*6\*c (``VT102'')
@@ -686,13 +697,15 @@
   \(-> \*8 User-defined keys
   \(-> \*9 National replacement character sets
   \(-> \*1\*5 Technical characters
+  \(-> \*2\*2 ANSI color, e.g., VT525
+  \(-> \*2\*9 ANSI text locator (i.e., DEC Locator mode)
 .
 .IP \\*(Cs\\*>\\*(Ps\\*s\\*c
 Send Device Attributes (Secondary DA)
   \*(Ps = \*0, 1 or omitted \(-> request the terminal's identification code.
-The response depends on the \fBdecTerminalId\fP resource setting.
+The response depends on the \fBdecTerminalID\fP resource setting.
 It should apply only to VT220 and up, but \fIxterm\fP extends this to VT100.
-  \(-> \*(Cs\*(Pp\*s\*;\*(Pv\*s\*;\*(Pc\*s\*c
+  \(-> \*(Cs\*s\*>\*(Pp\*s\*;\*(Pv\*s\*;\*(Pc\*s\*c
 .br
 where \*(Pp denotes the terminal type
   \(-> \*0 (``VT100'')
@@ -853,12 +866,12 @@
   \*(Ps = \*4 \(-> Underlined
   \*(Ps = \*5 \(-> Blink (appears as Bold)
   \*(Ps = \*7 \(-> Inverse
-  \*(Ps = \*8 \(-> Invisible (hidden)
+  \*(Ps = \*8 \(-> Invisible, i.e., hidden (VT300)
   \*(Ps = \*2\*2 \(-> Normal (neither bold nor faint)
   \*(Ps = \*2\*4 \(-> Not underlined
   \*(Ps = \*2\*5 \(-> Steady (not blinking)
   \*(Ps = \*2\*7 \(-> Positive (not inverse)
-  \*(Ps = \*2\*8 \(-> Visible (not hidden)
+  \*(Ps = \*2\*8 \(-> Visible, i.e., not hidden (VT300)
   \*(Ps = \*3\*0 \(-> Set foreground color to Black
   \*(Ps = \*3\*1 \(-> Set foreground color to Red
   \*(Ps = \*3\*2 \(-> Set foreground color to Green
@@ -932,6 +945,9 @@
 .br
 \*(Cs\*?\*2\*7\*s\*;\*s\*1\*s\*;\*s\*0\*s\*;\*s\*0\*s\*n (North American)
 .br
+The last two parameters apply to VT400 & up, and denote keyboard ready and LK01 respectively.
+  \*(Ps = \*5\*3 \(-> Report Locator status as
+.br
 \*(Cs\*?\*5\*3\*s\*n Locator available, if compiled-in, or
 .br
 \*(Cs\*?\*5\*0\*s\*n No Locator, if not.
@@ -1019,6 +1035,17 @@
 .
 .IP \\*(Cs\\*(Ps\\*s\\*x
 Request Terminal Parameters (DECREQTPARM)
+.br
+if \*(Ps is a "0" (default) or "1", and \fBxterm\fR is emulating VT100,
+the control sequence elicits a response of the same form
+whose parameters describe the terminal:
+  \*(Ps \(-> the given \*(Ps incremented by 2.
+  \*1 \(-> no parity
+  \*1 \(-> eight bits
+  \*1 \*2 \*8 \(-> transmit 38.4k baud
+  \*1 \*2 \*8 \(-> receive 38.4k baud
+  \*1 \(-> clock multiplier
+  \*0 \(-> STP flags
 .
 .IP \\*(Cs\\*(Ps\\*s\\*;\\*(Pu\\*s\\*(qu\\*z
 Enable Locator Reporting (DECELR)
@@ -1107,18 +1134,45 @@
   \*(Ps = \*2 \(-> Change Window Title to \*(Pt
   \*(Ps = \*3 \(-> Set X property on top-level window. \*(Pt should be in the form
 "\fIprop=value\fP", or just "\fIprop\fP" to delete the property
-  \*(Ps = \*4 ; \fIc ; name\fP \(-> Change Color #\fIc\fP to \fIcname\fP.  Any
-number of \fIc name\fP pairs may be given.
-  \*(Ps = \*1\*0 \(-> Change color names starting with text foreground to \*(Pt
-(a list of one or more color names or RGB specifications, separated by
-semicolon, up to eight, as per \fIXParseColor\fP).
-  \*(Ps = \*1\*1 \(-> Change colors starting with text background to \*(Pt
-  \*(Ps = \*1\*2 \(-> Change colors starting with text cursor to \*(Pt
-  \*(Ps = \*1\*3 \(-> Change colors starting with mouse foreground to \*(Pt
-  \*(Ps = \*1\*4 \(-> Change colors starting with mouse background to \*(Pt
-  \*(Ps = \*1\*5 \(-> Change colors starting with Tek foreground to \*(Pt
-  \*(Ps = \*1\*6 \(-> Change colors starting with Tek background to \*(Pt
-  \*(Ps = \*1\*7 \(-> Change colors starting with highlight to \*(Pt
+  \*(Ps = \*4 ; \fIc ; spec\fP \(-> Change Color Number \fIc\fP to
+the color specified by \fIspec\fP,
+i.e., a name or RGB specification as per \fIXParseColor\fP.
+Any number of \fIc name\fP pairs may be given.
+The color numbers correspond to the ANSI colors 0-7,
+their bright versions 8-15,
+and if supported, the remainder of the 88-color or 256-color table.
+.sp
+If a "?" is given rather than a name or RGB specification,
+xterm replies with a control sequence of the same form which can be used
+to set the corresponding color.
+Because more than one pair of color number and specification can
+be given in one control sequence, \fBxterm\fR can make more than one reply.
+.sp
+The 8 colors which may be set using \*1\*0 through \*1\*7 are
+denoted \fIdynamic colors\fR, since the corresponding control sequences
+were the first means for setting \fBxterm\fR's colors dynamically,
+i.e., after it was started.
+They are not the same as the ANSI colors.
+One or more parameters is expected for \*(Pt.
+Each succesive parameter changes the next color in the list.
+The value of \*(Ps tells the starting point in the list.
+The colors are specified by name or RGB specification as per \fIXParseColor\fP.
+.sp
+If a "?" is given rather than a name or RGB specification,
+xterm replies with a control sequence of the same form which can be used
+to set the corresponding dynamic color.
+Because more than one pair of color number and specification can
+be given in one control sequence, \fBxterm\fR can make more than one reply.
+.sp
+  \*(Ps = \*1\*0 \(-> Change vt100 text foreground color to \*(Pt
+  \*(Ps = \*1\*1 \(-> Change vt100 text background color to \*(Pt
+  \*(Ps = \*1\*2 \(-> Change text cursor color to \*(Pt
+  \*(Ps = \*1\*3 \(-> Change mouse foreground color to \*(Pt
+  \*(Ps = \*1\*4 \(-> Change mouse background color to \*(Pt
+  \*(Ps = \*1\*5 \(-> Change Tektronix foreground color to \*(Pt
+  \*(Ps = \*1\*6 \(-> Change Tektronix background color to \*(Pt
+  \*(Ps = \*1\*7 \(-> Change highlight color to \*(Pt
+.sp
   \*(Ps = \*4\*6 \(-> Change Log File to \*(Pt (normally disabled by a
 compile-time option)
   \*(Ps = \*5\*0 \(-> Set Font to \*(Pt
@@ -1133,7 +1187,7 @@
 .B
 Privacy Message
 .IP \\*(PM\\*(Pt\\*s\\*(ST
-\fIxterm\fP implements no PM functions; \*(Pt is ignored.
+\fIxterm\fP implements no \*(PM functions; \*(Pt is ignored.
 \*(Pt need not be printable characters.
 .Ed
 .
@@ -1186,23 +1240,23 @@
 PF2	\*(S3\*Q	\*(S3\*Q	kf2	k2
 PF3	\*(S3\*R	\*(S3\*R	kf3	k3
 PF4	\*(S3\*S	\*(S3\*S	kf4	k4
-* \f1(multiply)\fP	*	\*(S3\*j	-	-
-+ \f1(add)\fP	+	\*(S3\*k	-	-
-, \f1(comma)\fP	,	\*(S3\*l	-	-
-- \f1(minus)\fP	-	\*(S3\*m	-	-
-\. \f1(Delete)\fP	\.	\*(S3\*3\*(c~	-	-
-/ \f1(divide)\fP	/	\*(S3\*o	-	-
-0 \f1(Insert)\fP	0	\*(Cs\*2\*(c~	-	-
-1 \f1(End)\fP	1	\*(Cs\*4\*(c~	kc1	K4
-2 \f1(DownArrow)\fP	2	\*(Cs\*(cB	-	-
-3 \f1(PageDown)\fP	3	\*(Cs\*5\*(c~	kc3	K5
-4 \f1(LeftArrow)\fP	4	\*(Cs\*D	-	-
-5 \f1(Begin)\fP	5	\*(Cs\*E	kb2	K2
-6 \f1(RightArrow)\fP	6	\*(Cs\*C	-	-
-7 \f1(Home)\fP	7	\*(Cs\*1\*(c~	ka1	K1
-8 \f1(UpArrow)\fP	8	\*(Cs\*A	-	-
-9 \f1(PageUp)\fP	9	\*(Cs\*5\*(c~	ka3	K3
-= (equal)	\&=	\*(S3\*(XX	-	-
+* \f1(multiply)\fP	\**	\*(S3\*j	-	-
++ \f1(add)\fP	\*+	\*(S3\*k	-	-
+, \f1(comma)\fP	\*,	\*(S3\*l	-	-
+- \f1(minus)\fP	\*-	\*(S3\*m	-	-
+\&. \f1(Delete)\fP	\*.	\*(S3\*3\*(c~	-	-
+/ \f1(divide)\fP	\*/	\*(S3\*o	-	-
+0 \f1(Insert)\fP	\*0	\*(Cs\*2\*(c~	-	-
+1 \f1(End)\fP	\*1	\*(Cs\*4\*(c~	kc1	K4
+2 \f1(DownArrow)\fP	\*2	\*(Cs\*(cB	-	-
+3 \f1(PageDown)\fP	\*3	\*(Cs\*5\*(c~	kc3	K5
+4 \f1(LeftArrow)\fP	\*4	\*(Cs\*D	-	-
+5 \f1(Begin)\fP	\*5	\*(Cs\*E	kb2	K2
+6 \f1(RightArrow)\fP	\*6	\*(Cs\*C	-	-
+7 \f1(Home)\fP	\*7	\*(Cs\*1\*(c~	ka1	K1
+8 \f1(UpArrow)\fP	\*8	\*(Cs\*A	-	-
+9 \f1(PageUp)\fP	\*9	\*(Cs\*5\*(c~	ka3	K3
+= (equal)	\*=	\*(S3\*(XX	-	-
 .TE
 They also provide 12 function keys, as well as a few other special-purpose keys.
 .TS
@@ -1279,30 +1333,30 @@
 lf3w(2c)	lf3w(2c)	lf3w(2c) .
 Key	Numeric	Application
 _
-Space	Space	\*(S3\*(Sp
-Tab	Tab	\*(S3\*I
-Enter	CR	\*(S3\*M
+Space	\*(Sp	\*(S3\*(Sp
+Tab	\*(Ta	\*(S3\*I
+Enter	\*(Cr	\*(S3\*M
 PF1	\*(S3\*P	\*(S3\*P
 PF2	\*(S3\*Q	\*(S3\*Q
 PF3	\*(S3\*R	\*(S3\*R
 PF4	\*(S3\*S	\*(S3\*S
-* \f1(multiply)\fP	*	\*(S3\*j
-+ \f1(add)\fP	+	\*(S3\*k
-, \f1(comma)\fP	,	\*(S3\*l
-- \f1(minus)\fP	-	\*(S3\*m
-\. \f1(period)\fP	\.	\*(S3\*n
-/ \f1(divide)\fP	/	\*(S3\*o
-0	0	\*(S3\*p
-1	1	\*(S3\*q
-2	2	\*(S3\*r
-3	3	\*(S3\*(cs
-4	4	\*(S3\*t
-5	5	\*(S3\*u
-6	6	\*(S3\*v
-7	7	\*(S3\*w
-8	8	\*(S3\*x
-9	9	\*(S3\*y
-= (equal)	\&=	\*(S3\*(XX
+* \f1(multiply)\fP	\**	\*(S3\*j
++ \f1(add)\fP	\*+	\*(S3\*k
+, \f1(comma)\fP	\*,	\*(S3\*l
+- \f1(minus)\fP	\*-	\*(S3\*m
+\&. \f1(period)\fP	\*.	\*(S3\*n
+/ \f1(divide)\fP	\*/	\*(S3\*o
+0	\*0	\*(S3\*p
+1	\*1	\*(S3\*q
+2	\*2	\*(S3\*r
+3	\*3	\*(S3\*(cs
+4	\*4	\*(S3\*t
+5	\*5	\*(S3\*u
+6	\*6	\*(S3\*v
+7	\*7	\*(S3\*w
+8	\*8	\*(S3\*x
+9	\*9	\*(S3\*y
+= (equal)	\*=	\*(S3\*(XX
 .TE
 .LP
 The VT220 provides 8 additional function keys.
@@ -1346,37 +1400,37 @@
 lf3w(2c)	lf3w(2c)	lf3w(2c) .
 Key	Numeric	Application
 _
-Space	Space	\*(Es\*?\*(Sp
-Tab	Tab	\*(Es\*?\*I
-Enter	CR	\*(Es\*?\*M
+Space	\*(Sp	\*(Es\*?\*(Sp
+Tab	\*(Ta	\*(Es\*?\*I
+Enter	\*(Cr	\*(Es\*?\*M
 PF1	\*(Es\*P	\*(Es\*P
 PF2	\*(Es\*Q	\*(Es\*Q
 PF3	\*(Es\*R	\*(Es\*R
 PF4	\*(Es\*S	\*(Es\*S
-* \f1(multiply)\fP	*	\*(Es\*?\*j
-+ \f1(add)\fP	+	\*(Es\*?\*k
-, \f1(comma)\fP	,	\*(Es\*?\*l
-- \f1(minus)\fP	-	\*(Es\*?\*m
-\. \f1(period)\fP	\.	\*(Es\*?\*n
-/ \f1(divide)\fP	/	\*(Es\*?\*o
-0	0	\*(Es\*?\*p
-1	1	\*(Es\*?\*q
-2	2	\*(Es\*?\*r
-3	3	\*(Es\*?\*(cs
-4	4	\*(Es\*?\*t
-5	5	\*(Es\*?\*u
-6	6	\*(Es\*?\*v
-7	7	\*(Es\*?\*w
-8	8	\*(Es\*?\*x
-9	9	\*(Es\*?\*y
-= (equal)	\&=	\*(Es\*?\*(XX
+* \f1(multiply)\fP	\**	\*(Es\*?\*j
++ \f1(add)\fP	\*+	\*(Es\*?\*k
+, \f1(comma)\fP	\*,	\*(Es\*?\*l
+- \f1(minus)\fP	\*-	\*(Es\*?\*m
+\&. \f1(period)\fP	\*.	\*(Es\*?\*n
+/ \f1(divide)\fP	\*/	\*(Es\*?\*o
+0	\*0	\*(Es\*?\*p
+1	\*1	\*(Es\*?\*q
+2	\*2	\*(Es\*?\*r
+3	\*3	\*(Es\*?\*(cs
+4	\*4	\*(Es\*?\*t
+5	\*5	\*(Es\*?\*u
+6	\*6	\*(Es\*?\*v
+7	\*7	\*(Es\*?\*w
+8	\*8	\*(Es\*?\*x
+9	\*9	\*(Es\*?\*y
+= (equal)	\*=	\*(Es\*?\*(XX
 .TE
 .SH
 Sun-Style Function Keys
 .LP
 The \fIxterm\fP program provides support for Sun keyboards more directly, by
 a menu toggle that causes it to send Sun-style function key codes rather than VT220.
-Note, however, that the \fIsun\fP and \fIvt100\fP emulations are not really
+Note, however, that the \fIsun\fP and \fIVt100\fP emulations are not really
 compatible.  For example, their wrap-margin behavior differs.
 .LP
 Only function keys are altered; keypad and cursor keys are the same.
@@ -1396,9 +1450,12 @@
 editors and other full-screen applications that want to make use of
 the mouse.
 
-There are six mutually exclusive modes.  One is DEC Locator mode, enabled by the
+There are six mutually exclusive modes.
+One is DEC Locator mode, enabled by the
 DECELR \*(Cs\*(Ps\*s\*;\*(Ps\*s\*s\*'\*s\*z
-control sequence, and is not described here.  The remaining five
+control sequence, and is not described here
+(control sequences are summarized above).
+The remaining five
 modes are each enabled (or disabled) by a different parameter in
 DECSET \*(Cs\*?\*(Pm\*s\*h
 or
@@ -1454,7 +1511,10 @@
 in X10 mode.
 
 Wheel mice may return buttons 4 and 5.
-Those buttons are represented by adding 64 to the event code.
+Those buttons are represented by the same event codes
+as buttons 1 and 2 respectively,
+except that 64 is added to the event code.
+Release events for the wheel buttons are not reported.
 
 Mouse hilite tracking notifies a program of a button press, receives a
 range of lines from the program, highlights the region covered by
@@ -1503,8 +1563,8 @@
 down is reported as \*(Cs\*M\*(cB\*(Cx\*(Cy.
 ( \*(cB = 32 + 2 (button 3) + 32 (motion indicator) ).
 
-Any-event mode is the same as button-event mode, except that all motion
-events are reported instead of just those that enter a new character cell.
+Any-event mode is the same as button-event mode, except that all motion  
+events are reported, even if no mouse button is down.
 It is enabled by specifying 1003 to DECSET.
 .
 .br
Index: xc/extras/FreeType/contrib/ftos2/ifi/32ifimet.h
diff -u xc/extras/FreeType/contrib/ftos2/ifi/32ifimet.h:1.1.1.1 xc/extras/FreeType/contrib/ftos2/ifi/32ifimet.h:1.2
--- xc/extras/FreeType/contrib/ftos2/ifi/32ifimet.h:1.1.1.1	Sat Jan 23 22:21:51 1999
+++ xc/extras/FreeType/contrib/ftos2/ifi/32ifimet.h	Sat Jan 11 22:55:43 2003
@@ -10,6 +10,7 @@
 * This file is included by FDSTRUCS.H
 *
 \*********************************************************************/
+/* $XFree86: xc/extras/FreeType/contrib/ftos2/ifi/32ifimet.h,v 1.2 2003/01/12 03:55:43 tsi Exp $ */
 #ifndef     __32IFIMET_H__
 #define     __32IFIMET_H__
 
@@ -52,9 +53,9 @@
 #define IFIMETRICS_HOLLOW      0x0800   /*Outline (hollow) */
 
 #if defined(__IBMCPP__) || defined(__IBMC__)
-    #pragma pack(1)
+#    pragma pack(1)
 #else
-    #pragma Align_members(1)
+#    pragma Align_members(1)
 #endif
 
 typedef struct _IFIMETRICS    /* ifim */
@@ -110,9 +111,9 @@
 } IFIMETRICS;
 typedef IFIMETRICS FAR *PIFIMETRICS;
 #if defined(__IBMCPP__) || defined(__IBMC__)
-    #pragma pack()
+#    pragma pack()
 #else
-    #pragma Align_members()
+#    pragma Align_members()
 #endif
 
 #endif
Index: xc/extras/FreeType/contrib/ftos2/ifi/ftifi.c
diff -u xc/extras/FreeType/contrib/ftos2/ifi/ftifi.c:1.1.1.1 xc/extras/FreeType/contrib/ftos2/ifi/ftifi.c:1.2
--- xc/extras/FreeType/contrib/ftos2/ifi/ftifi.c:1.1.1.1	Sat Jan 23 22:21:51 1999
+++ xc/extras/FreeType/contrib/ftos2/ifi/ftifi.c	Sat Jan 11 22:55:43 2003
@@ -51,11 +51,12 @@
 /*   number can be set via entry in OS2.INI.                               */
 /*                                                                         */
 /* For Intelligent Font Interface (IFI) specification please see IFI32.TXT */
+/* $XFree86: xc/extras/FreeType/contrib/ftos2/ifi/ftifi.c,v 1.2 2003/01/12 03:55:43 tsi Exp $ */
 
 #ifndef  __IBMC__
-   #ifndef __WATCOMC__
-      #error "This source requires IBM VisualAge C++ or Watcom C/C++"
-   #endif
+#   ifndef __WATCOMC__
+#       error "This source requires IBM VisualAge C++ or Watcom C/C++"
+#   endif
 #endif
 
 /* Defining the following uses UCONV.DLL instead of the built-in  */
@@ -193,19 +194,19 @@
     return buffer;
 }
 
-  #define  COPY(s)     strcpy(log, s)
-  #define  CAT(s)      strcat(log, s)
-  #define  CATI(v)     strcat(log, itoa10( (int)v, buf ))
-  #define  WRITE       DosWrite(LogHandle, log, strlen(log), &Written)
+#  define  COPY(s)     strcpy(log, s)
+#  define  CAT(s)      strcat(log, s)
+#  define  CATI(v)     strcat(log, itoa10( (int)v, buf ))
+#  define  WRITE       DosWrite(LogHandle, log, strlen(log), &Written)
 
-  #define  ERET1(label) { COPY("Error at ");  \
+#  define  ERET1(label) { COPY("Error at ");  \
                           CATI(__LINE__);    \
                           CAT("\r\n");       \
                           WRITE;             \
                           goto label;        \
                        }
 
-  #define  ERRRET(e)   { COPY("Error at ");  \
+#  define  ERRRET(e)   { COPY("Error at ");  \
                           CATI(__LINE__);    \
                           CAT("\r\n");       \
                           WRITE;             \
@@ -215,14 +216,14 @@
 
 #else
 
-  #define  COPY(s)
-  #define  CAT(s)
-  #define  CATI(v)
-  #define  WRITE
+#  define  COPY(s)
+#  define  CAT(s)
+#  define  CATI(v)
+#  define  WRITE
 
-  #define  ERET1(label)  goto label;
+#  define  ERET1(label)  goto label;
 
-  #define  ERRRET(e)  return(e);
+#  define  ERRRET(e)  return(e);
 
 #endif /* DEBUG */
 
@@ -1561,7 +1562,7 @@
       ERRRET(-1) /* error, invalid handle */
 
    if (cMetricLen == 0) {   /* only number of faces is requested */
-      #ifdef  FAKE_TNR
+#     ifdef  FAKE_TNR
       /* create an alias for Times New Roman */
       pface = &(file->faces[0]);
       name = LookupName(pface->face, TT_NAME_ID_FONT_FAMILY);
@@ -1569,7 +1570,7 @@
          file->flags |= FL_FLAG_FAKE_ROMAN;
          return 2;
       }
-      #endif
+#     endif
       if (file->flags & FL_FLAG_DBCS_FILE)
          return file->numFaces * 2;
       else
@@ -1779,7 +1780,7 @@
          pifi2->szFacename[0] = '@';
          ifiCount += cMetricLen;
       }
-      #ifdef  FAKE_TNR
+#     ifdef  FAKE_TNR
       if ((file->flags & FL_FLAG_FAKE_ROMAN) && (index + 1 >= cStart) &&
           (index + 1 < (cStart + cFontCount))) {
          pifi2 = (PIFIMETRICS) (((PBYTE) pifiMetrics) + ifiCount);
@@ -1802,7 +1803,7 @@
          }
          ifiCount += cMetricLen;
       }
-      #endif
+#     endif
    }
 
 Exit:
@@ -1839,11 +1840,11 @@
    /* calculate real face index in font file */
    faceIndex = file->flags & FL_FLAG_DBCS_FILE ? ulFont / 2 : ulFont;
 
-   #ifdef  FAKE_TNR
+#  ifdef  FAKE_TNR
    if (file->flags & FL_FLAG_FAKE_ROMAN)
       /* This font isn't real! */
       faceIndex = 0;
-   #endif
+#  endif
 
    if (faceIndex > file->numFaces)
       ERRRET((HFC)-1)
@@ -2575,10 +2576,8 @@
    LONG   lReqCount;
    ULONG  ulCurMaxFH;
 
-   #ifdef DEBUG
+#  ifdef DEBUG
       ULONG Action;
-   #endif /* DEBUG */
-   #ifdef DEBUG
       DosOpen("C:\\FTIFI.LOG", &LogHandle, &Action, 0, FILE_NORMAL,
               OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_REPLACE_IF_EXISTS,
               OPEN_FLAGS_NO_CACHE | OPEN_FLAGS_WRITE_THROUGH |
@@ -2586,7 +2585,7 @@
               NULL);
       COPY("FreeType/2 loaded.\r\n");
       WRITE;
-   #endif /* DEBUG */
+#  endif /* DEBUG */
 
    /* increase # of file handles by five to be on the safe side */
    lReqCount = 5;
@@ -2636,11 +2635,11 @@
    /* turn off engine */
    TT_Done_FreeType(engine);
 
-   #ifdef DEBUG
+#  ifdef DEBUG
       COPY("FreeType/2 terminated.\r\n");
       WRITE;
       DosClose(LogHandle);
-   #endif
+#  endif
    return 1;
 }
 /****************************************************************************/
@@ -2661,9 +2660,9 @@
       case 1:  {          /* terminating */
          int   i;
          /* clean UCONV cache */
-         #ifdef USE_UCONV
+#        ifdef USE_UCONV
             CleanUCONVCache();
-         #endif
+#        endif
          if(--ulProcessCount == 0)
             return FinalTerm();
          else
Index: xc/extras/FreeType/contrib/ftos2/ifi/test.c
diff -u xc/extras/FreeType/contrib/ftos2/ifi/test.c:1.1.1.1 xc/extras/FreeType/contrib/ftos2/ifi/test.c:1.2
--- xc/extras/FreeType/contrib/ftos2/ifi/test.c:1.1.1.1	Sat Jan 23 22:21:51 1999
+++ xc/extras/FreeType/contrib/ftos2/ifi/test.c	Sat Jan 11 22:55:43 2003
@@ -1,3 +1,4 @@
+/* $XFree86: xc/extras/FreeType/contrib/ftos2/ifi/test.c,v 1.2 2003/01/12 03:55:43 tsi Exp $ */
 
 #include <os2.h>
 
@@ -8,13 +9,13 @@
 
 //#define USE_ORIG
 #ifdef USE_ORIG
-   #pragma import (fdhdr, "FONT_DRIVER_DISPATCH_TABLE", "TRUETYPE", 0)
+#  pragma import (fdhdr, "FONT_DRIVER_DISPATCH_TABLE", "TRUETYPE", 0)
 #else
-  #if defined USE_ATM
-    #pragma import (fdhdr, "FONT_DRIVER_DISPATCH_TABLE", "PMATM", 0)
-  #else
-    #pragma import (fdhdr, "FONT_DRIVER_DISPATCH_TABLE", "FREETYPE", 0)
-  #endif
+#  if defined USE_ATM
+#    pragma import (fdhdr, "FONT_DRIVER_DISPATCH_TABLE", "PMATM", 0)
+#  else
+#    pragma import (fdhdr, "FONT_DRIVER_DISPATCH_TABLE", "FREETYPE", 0)
+#  endif
 #endif
 
 extern FDHEADER fdhdr;
@@ -42,9 +43,9 @@
 
 #define FNTNAME1 "\\PSFONTS\\TIMES.TTF"
 #ifdef USE_ATM
-   #define FNTNAME2 "\\PSFONTS\\helv.ofm"
+#  define FNTNAME2 "\\PSFONTS\\helv.ofm"
 #else
-   #define FNTNAME2 "\\PSFONTS\\symbol.tTf"
+#  define FNTNAME2 "\\PSFONTS\\symbol.tTf"
 #endif
 
 #define BUFSIZE 32768
Index: xc/extras/FreeType/contrib/ftos2/lib/ttmemory.c
diff -u xc/extras/FreeType/contrib/ftos2/lib/ttmemory.c:1.1.1.1 xc/extras/FreeType/contrib/ftos2/lib/ttmemory.c:1.2
--- xc/extras/FreeType/contrib/ftos2/lib/ttmemory.c:1.1.1.1	Sat Jan 23 22:21:52 1999
+++ xc/extras/FreeType/contrib/ftos2/lib/ttmemory.c	Sat Jan 11 22:55:44 2003
@@ -30,6 +30,7 @@
  *         Font Driver (FreeType/2).
  *
  ******************************************************************/
+/* $XFree86: xc/extras/FreeType/contrib/ftos2/lib/ttmemory.c,v 1.2 2003/01/12 03:55:44 tsi Exp $ */
 
 #include "ttdebug.h"
 #include "ttmemory.h"
@@ -111,13 +112,13 @@
   return buffer;
 }
 
-  #define  COPY(s)     strcpy(log, s)
-  #define  CAT(s)      strcat(log, s)
-  #define  CATI(v)     strcat(log, itoa10( (int)v, buf ))
-  #define  CATH(v)     strcat(log, itohex4( (long)v, buf ))
-  #define  CATW(v)     strcat(log, itohex2( (short)v, buf ))
-  #define  WRITE       DosWrite(MemLogHandle, log, strlen(log), &Written)
-  #define  ERRRET(e)   { COPY("Error at ");  \
+#   define  COPY(s)     strcpy(log, s)
+#   define  CAT(s)      strcat(log, s)
+#   define  CATI(v)     strcat(log, itoa10( (int)v, buf ))
+#   define  CATH(v)     strcat(log, itohex4( (long)v, buf ))
+#   define  CATW(v)     strcat(log, itohex2( (short)v, buf ))
+#   define  WRITE       DosWrite(MemLogHandle, log, strlen(log), &Written)
+#   define  ERRRET(e)   { COPY("Error at ");  \
                           CATI(__LINE__);    \
                           CAT("\r\n");       \
                           WRITE;             \
@@ -126,13 +127,13 @@
 
 #else
 
-  #define  COPY(s)
-  #define  CAT(s)
-  #define  CATI(v)
-  #define  CATH(v)
-  #define  CATW(v)
-  #define  WRITE
-  #define  ERRRET(e)  return(e);
+#   define  COPY(s)
+#   define  CAT(s)
+#   define  CATI(v)
+#   define  CATH(v)
+#   define  CATW(v)
+#   define  WRITE
+#   define  ERRRET(e)  return(e);
 
 #endif /* DEBUG_MEM */
 
@@ -143,7 +144,7 @@
 
 #ifdef TRACK_MEM
    /* name of shared memory used for memory usage reporting  */
-   #define MEM_NAME  "\\sharemem\\freetype"
+#  define MEM_NAME  "\\sharemem\\freetype"
 
    /* structure containing memory usage information */
    typedef struct _INFOSTRUCT {
@@ -199,11 +200,11 @@
     }
     *head = size;
     base  = (void*)(head + 1);
-    #ifdef TRACK_MEM
+#   ifdef TRACK_MEM
        meminfo->used += size;
        if (meminfo->used > meminfo->maxused)
           meminfo->maxused = meminfo->used;
-    #endif
+#   endif
     return base;
   }
 
@@ -238,9 +239,9 @@
       CAT ( "\r\n" );
       WRITE;
     }
-    #ifdef TRACK_MEM
+#   ifdef TRACK_MEM
        meminfo->used -= size;
-    #endif
+#   endif
     return rc;
   }
 
@@ -267,9 +268,9 @@
     {
       *P = ft2_malloc( Size );
       if (!*P) {
-        #ifdef TRACK_MEM
+#       ifdef TRACK_MEM
            meminfo->num_err++;
-        #endif
+#       endif
         return TT_Err_Out_Of_Memory;
       }
 
@@ -302,9 +303,9 @@
       return TT_Err_Ok;
 
     if (ft2_free( *P )) {
-        #ifdef TRACK_MEM
+#       ifdef TRACK_MEM
            meminfo->num_err++;
-        #endif
+#       endif
     }
     *P = NULL;
     return TT_Err_Ok;
@@ -325,7 +326,7 @@
   {
     int  rc;
 
-    #ifdef DEBUG_MEM
+#   ifdef DEBUG_MEM
        ULONG  Action;
 
        DosOpen("C:\\FTMEM.LOG", &MemLogHandle, &Action, 0, FILE_NORMAL,
@@ -337,9 +338,9 @@
        COPY("FTMEM Init.\r\n");
        WRITE;
 
-    #endif /* DEBUG */
+#   endif /* DEBUG */
 
-    #ifdef TRACK_MEM
+#   ifdef TRACK_MEM
     /* allocate named shared memory and global shared memory */
 
        SSAllocMem(&meminfo, 4096, 0);
@@ -348,7 +349,7 @@
        meminfo->signature = 0x46524545;   /* 'FREE' */
        meminfo->maxused = 0;
        meminfo->used = 0;
-    #endif /* TRACK */
+#   endif /* TRACK */
 
     return TT_Err_Ok;
   }
@@ -369,15 +370,15 @@
     /* Never called by the font driver (beats me why). We do not
        release the heaps */
 
-    #ifdef TRACK_MEM
+#   ifdef TRACK_MEM
        DosFreeMem(memptr);  /* free shared memory */
        SSFreeMem(meminfo);
-    #endif
-    #ifdef DEBUG_MEM
+#   endif
+#   ifdef DEBUG_MEM
        COPY("FTMEM Done.\r\n");
        WRITE;
        DosClose(MemLogHandle);
-    #endif
+#   endif
     return TT_Err_Ok;
   }
 
Index: xc/extras/FreeType/contrib/win32/testw32.h
diff -u xc/extras/FreeType/contrib/win32/testw32.h:1.1.1.1 xc/extras/FreeType/contrib/win32/testw32.h:1.2
--- xc/extras/FreeType/contrib/win32/testw32.h:1.1.1.1	Sat Feb 12 23:55:23 2000
+++ xc/extras/FreeType/contrib/win32/testw32.h	Sat Jan 11 22:55:44 2003
@@ -1,5 +1,6 @@
 // testw32.h : main header file for the TESTW32 application
 //
+// $XFree86: xc/extras/FreeType/contrib/win32/testw32.h,v 1.2 2003/01/12 03:55:44 tsi Exp $
 
 #if !defined(AFX_TESTW32_H__70F52CA9_06A4_11D2_9AC4_0060978849F3__INCLUDED_)
 #define AFX_TESTW32_H__70F52CA9_06A4_11D2_9AC4_0060978849F3__INCLUDED_
@@ -9,7 +10,7 @@
 #endif // _MSC_VER >= 1000
 
 #ifndef __AFXWIN_H__
-	#error include 'stdafx.h' before including this file for PCH
+#	error include 'stdafx.h' before including this file for PCH
 #endif
 
 #include "resource.h"		// main symbols
Index: xc/extras/FreeType/contrib/win32/res/testw32.rc2
diff -u xc/extras/FreeType/contrib/win32/res/testw32.rc2:1.1.1.1 xc/extras/FreeType/contrib/win32/res/testw32.rc2:1.2
--- xc/extras/FreeType/contrib/win32/res/testw32.rc2:1.1.1.1	Sat Feb 12 23:55:23 2000
+++ xc/extras/FreeType/contrib/win32/res/testw32.rc2	Sat Jan 11 22:55:44 2003
@@ -1,9 +1,10 @@
 //
 // TESTW32.RC2 - resources Microsoft Visual C++ does not edit directly
 //
+// $XFree86: xc/extras/FreeType/contrib/win32/res/testw32.rc2,v 1.2 2003/01/12 03:55:44 tsi Exp $
 
 #ifdef APSTUDIO_INVOKED
-	#error this file is not editable by Microsoft Visual C++
+#	error this file is not editable by Microsoft Visual C++
 #endif //APSTUDIO_INVOKED
 
 
Index: xc/extras/FreeType/lib/ttcalc.c
diff -u xc/extras/FreeType/lib/ttcalc.c:1.4 xc/extras/FreeType/lib/ttcalc.c:1.6
--- xc/extras/FreeType/lib/ttcalc.c:1.4	Sun Feb 13 00:03:51 2000
+++ xc/extras/FreeType/lib/ttcalc.c	Sun Jun 30 22:25:52 2002
@@ -14,6 +14,7 @@
  *  understand and accept it fully.
  *
  ******************************************************************/
+/* $XFree86: xc/extras/FreeType/lib/ttcalc.c,v 1.6 2002/07/01 02:25:52 tsi Exp $ */
 
 #include "ttcalc.h"
 #include "ttdebug.h"
@@ -84,7 +85,7 @@
 
     while ( z )
     {
-      z = (unsigned INT64)z >> 1;
+      z = (CARD64)z >> 1;
       j++;
     }
     return j - 1;
Index: xc/extras/FreeType/test/ftdump.c
diff -u xc/extras/FreeType/test/ftdump.c:1.1.1.3 xc/extras/FreeType/test/ftdump.c:1.2
--- xc/extras/FreeType/test/ftdump.c:1.1.1.3	Sat Feb 12 23:56:16 2000
+++ xc/extras/FreeType/test/ftdump.c	Sat Jan 11 22:55:44 2003
@@ -15,6 +15,7 @@
 /*         debug the current engine.                                        */
 /*                                                                          */
 /****************************************************************************/
+/* $XFree86: xc/extras/FreeType/test/ftdump.c,v 1.2 2003/01/12 03:55:44 tsi Exp $ */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -89,7 +90,7 @@
   /*                                                            */
   /* We thus avoid the external reference on these compilers.   */
 
-  #define TTMemory_Allocated  0L
+# define TTMemory_Allocated  0L
 
 #else
   extern long  TTMemory_Allocated;
Index: xc/extras/Mesa/docs/RELNOTES-3.4.1
diff -u xc/extras/Mesa/docs/RELNOTES-3.4.1:1.1.1.1 xc/extras/Mesa/docs/RELNOTES-3.4.1:removed
--- xc/extras/Mesa/docs/RELNOTES-3.4.1:1.1.1.1	Tue Mar 20 21:37:06 2001
+++ xc/extras/Mesa/docs/RELNOTES-3.4.1	Thu Feb 27 12:14:57 2003
@@ -1,22 +0,0 @@
-
-                         Mesa 3.4.1 release notes
-
-                             February 9, 2001
-
-                              PLEASE READ!!!!
-
-
-
-Introduction
-------------
-
-Mesa uses an even/odd version number scheme like the Linux kernel.
-Odd numbered versions (such as 3.3) designate new developmental releases.
-Even numbered versions (such as 3.4) designate stable releases.
-
-Mesa 3.4.1 is a maintenance release that simply fixes bugs found since
-the Mesa 3.4 release.  For details, see the VERSIONS file.
-
-
-----------------------------------------------------------------------
-$Id: RELNOTES-3.4.1,v 1.1.2.2 2001/02/07 22:54:04 brianp Exp $
Index: xc/extras/Mesa/docs/RELNOTES-3.4.2
diff -u xc/extras/Mesa/docs/RELNOTES-3.4.2:1.1.1.1 xc/extras/Mesa/docs/RELNOTES-3.4.2:removed
--- xc/extras/Mesa/docs/RELNOTES-3.4.2:1.1.1.1	Fri May 18 11:49:29 2001
+++ xc/extras/Mesa/docs/RELNOTES-3.4.2	Thu Feb 27 12:14:57 2003
@@ -1,22 +0,0 @@
-
-                         Mesa 3.4.2 release notes
-
-                               May 17, 2001
-
-                              PLEASE READ!!!!
-
-
-
-Introduction
-------------
-
-Mesa uses an even/odd version number scheme like the Linux kernel.
-Odd numbered versions (such as 3.3) designate new developmental releases.
-Even numbered versions (such as 3.4) designate stable releases.
-
-Mesa 3.4.2 is a maintenance release that simply fixes bugs found since
-the Mesa 3.4.1 release.  For details, see the VERSIONS file.
-
-
-----------------------------------------------------------------------
-$Id: RELNOTES-3.4.2,v 1.1.2.2 2001/05/16 22:29:07 brianp Exp $
Index: xc/extras/Mesa/docs/RELNOTES-4.0
diff -u /dev/null xc/extras/Mesa/docs/RELNOTES-4.0:1.2
--- /dev/null	Thu Feb 27 12:14:57 2003
+++ xc/extras/Mesa/docs/RELNOTES-4.0	Mon Dec 16 11:18:25 2002
@@ -0,0 +1,162 @@
+
+                           Mesa 4.0 release notes
+
+                             October 18, 2001
+
+                              PLEASE READ!!!!
+
+
+
+Introduction
+------------
+
+Mesa uses an even/odd version number scheme like the Linux kernel.
+Odd numbered versions (such as 3.3) designate new developmental releases.
+Even numbered versions (such as 3.4) designate stable releases.
+
+Mesa version 4.0 signifies two things:
+
+  1. A stabilization of the 3.5 development release
+  2. Implementation of the OpenGL 1.3 specification
+
+
+Note that the Mesa major version number is incremented with the OpenGL
+minor version number:
+
+   Mesa 1.x  ==  OpenGL 1.0
+   Mesa 2.x  ==  OpenGL 1.1
+   Mesa 3.x  ==  OpenGL 1.2
+   Mesa 4.x  ==  OpenGL 1.3
+
+
+
+New Features
+------------
+
+Mesa 3.5 already had all the new features of OpenGL 1.3, implemented as
+extensions.  These extensions were simply promoted to standard features:
+
+   GL_ARB_multisample
+   GL_ARB_multitexture
+   GL_ARB_texture_border_clamp
+   GL_ARB_texture_compression
+   GL_ARB_texture_cube_map
+   GL_ARB_texture_env_add
+   GL_ARB_texture_env_combine
+   GL_ARB_texture_env_dot3
+   GL_ARB_transpose_matrix
+
+In Mesa 4.0 the functions defined by these extensions are now available
+without the "ARB" suffix.  For example, glLoadTransposeMatrixf() is now
+a standard API function.  The new functions in OpenGL 1.3 and Mesa 4.0 are:
+
+   glActiveTexture
+   glClientActiveTexture
+   glCompressedTexImage1D
+   glCompressedTexImage2D
+   glCompressedTexImage3D
+   glCompressedTexSubImage1D
+   glCompressedTexSubImage2D
+   glCompressedTexSubImage3D
+   glGetCompressedTexImage
+   glLoadTransposeMatrixd
+   glLoadTransposeMatrixf
+   glMultiTexCoord1d
+   glMultiTexCoord1dv
+   glMultiTexCoord1f
+   glMultiTexCoord1fv
+   glMultiTexCoord1i
+   glMultiTexCoord1iv
+   glMultiTexCoord1s
+   glMultiTexCoord1sv
+   glMultiTexCoord2d
+   glMultiTexCoord2dv
+   glMultiTexCoord2f
+   glMultiTexCoord2fv
+   glMultiTexCoord2i
+   glMultiTexCoord2iv
+   glMultiTexCoord2s
+   glMultiTexCoord2sv
+   glMultiTexCoord3d
+   glMultiTexCoord3dv
+   glMultiTexCoord3f
+   glMultiTexCoord3fv
+   glMultiTexCoord3i
+   glMultiTexCoord3iv
+   glMultiTexCoord3s
+   glMultiTexCoord3sv
+   glMultiTexCoord4d
+   glMultiTexCoord4dv
+   glMultiTexCoord4f
+   glMultiTexCoord4fv
+   glMultiTexCoord4i
+   glMultiTexCoord4iv
+   glMultiTexCoord4s
+   glMultiTexCoord4sv
+   glMultTransposeMatrixd
+   glMultTransposeMatrixf
+   glSampleCoverage
+   glSamplePass
+
+
+GLX 1.4 is the companion to OpenGL 1.3.  The only new features in GLX 1.4
+are support for multisampling and the GLX_ARB_get_proc_address extension.
+glXGetProcAddress() is the only new function in GLX 1.4.
+
+
+
+Multisample and Texture Compression
+-----------------------------------
+
+The OpenGL 1.3 specification allows the multisample and texture compression
+features to essentially be no-ops.  For example, if you query for multisample
+support you'll find none, but the API functions work.
+
+Similarly, texture compression is not implemented by any of the software
+drivers but you can specify a generic compressed texture format (like
+GL_COMPRESSED_RGBA) to glTexImage2D and it'll be accepted.
+
+
+
+Device Drivers
+--------------
+
+Mesa advertises itself as either OpenGL 1.2 or OpenGL 1.3 depending on the
+device driver.  If the driver enables all the ARB extensions which are part
+of OpenGL 1.3 then glGetString(GL_VERSION) will return "1.3".  Otherwise,
+it'll return "1.2".
+
+A number of Mesa's software drivers haven't been actively maintained for
+some time.  We rely on volunteers to maintain many of the drivers.
+Here's the current status of all included drivers:
+
+
+Driver			Status
+----------------------	---------------------
+XMesa (Xlib)		implements OpenGL 1.3
+OSMesa (off-screen)	implements OpenGL 1.3
+FX (3dfx Voodoo1/2)	implements OpenGL 1.3
+SVGA			implements OpenGL 1.3
+Wind River UGL		implements OpenGL 1.3
+Windows/Win32		implements OpenGL 1.3
+GGI			needs updating
+DOS/DJGPP		needs updating
+BeOS			needs updating
+Allegro			needs updating
+D3D			needs updating
+DOS			needs updating
+
+Special thanks go to Karl Schultz for updating the Windows driver.
+
+The XFree86/DRI drivers	have not yet been updated to use Mesa 4.0 as of
+September 2001, but that should happen eventually.
+
+
+
+Other Changes
+-------------
+
+See the VERSIONS file for more details about bug fixes, etc. in Mesa 4.0.
+
+
+----------------------------------------------------------------------
Index: xc/extras/Mesa/docs/RELNOTES-4.0.1
diff -u /dev/null xc/extras/Mesa/docs/RELNOTES-4.0.1:1.2
--- /dev/null	Thu Feb 27 12:14:57 2003
+++ xc/extras/Mesa/docs/RELNOTES-4.0.1	Mon Dec 16 11:18:25 2002
@@ -0,0 +1,21 @@
+
+                          Mesa 4.0.1 release notes
+
+                             December 17, 2001
+
+                              PLEASE READ!!!!
+
+
+
+Introduction
+------------
+
+Mesa uses an even/odd version number scheme like the Linux kernel.
+Odd numbered versions (such as 3.3) designate new developmental releases.
+Even numbered versions (such as 3.4) designate stable releases.
+
+Mesa 4.0.1 only contains bug fixes since version 4.0.
+
+See the docs/VERSIONS file for the list of bug fixes.
+
+----------------------------------------------------------------------
Index: xc/extras/Mesa/docs/RELNOTES-4.0.2
diff -u /dev/null xc/extras/Mesa/docs/RELNOTES-4.0.2:1.2
--- /dev/null	Thu Feb 27 12:14:57 2003
+++ xc/extras/Mesa/docs/RELNOTES-4.0.2	Mon Dec 16 11:18:25 2002
@@ -0,0 +1,50 @@
+
+                          Mesa 4.0.2 release notes
+
+                               April 2, 2002
+
+                              PLEASE READ!!!!
+
+
+
+Introduction
+------------
+
+Mesa uses an even/odd version number scheme like the Linux kernel.
+Odd numbered versions (such as 3.3) designate new developmental releases.
+Even numbered versions (such as 3.4) designate stable releases.
+
+Mesa 4.0.2 only contains bug fixes and a new DOS driver since version 4.0.1.
+
+See the docs/VERSIONS file for the list of bug fixes.
+
+
+Device Drivers
+--------------
+
+Mesa advertises itself as either OpenGL 1.2 or OpenGL 1.3 depending on the
+device driver.  If the driver enables all the ARB extensions which are part
+of OpenGL 1.3 then glGetString(GL_VERSION) will return "1.3".  Otherwise,
+it'll return "1.2".
+
+A number of Mesa's software drivers haven't been actively maintained for
+some time.  We rely on volunteers to maintain many of the drivers.
+Here's the current status of all included drivers:
+
+Driver			Status
+----------------------	---------------------
+XMesa (Xlib)		implements OpenGL 1.3
+OSMesa (off-screen)	implements OpenGL 1.3
+FX (3dfx Voodoo1/2)	implements OpenGL 1.3
+SVGA			implements OpenGL 1.3
+Wind River UGL		implements OpenGL 1.3
+Windows/Win32		implements OpenGL 1.3
+DOS/DJGPP		implements OpenGL 1.3 (new in Mesa 4.0.2)
+GGI			needs updating
+BeOS			needs updating
+Allegro			needs updating
+D3D			needs updating
+
+
+----------------------------------------------------------------------
+$Id: RELNOTES-4.0.2,v 1.3 2002/10/22 23:38:06 alanh Exp $
Index: xc/extras/Mesa/docs/RELNOTES-4.0.3
diff -u /dev/null xc/extras/Mesa/docs/RELNOTES-4.0.3:1.2
--- /dev/null	Thu Feb 27 12:14:57 2003
+++ xc/extras/Mesa/docs/RELNOTES-4.0.3	Mon Dec 16 11:18:25 2002
@@ -0,0 +1,52 @@
+
+                          Mesa 4.0.3 release notes
+
+                               June 25, 2002
+
+                              PLEASE READ!!!!
+
+
+
+Introduction
+------------
+
+Mesa uses an even/odd version number scheme like the Linux kernel.
+Odd numbered versions (such as 3.3) designate new developmental releases.
+Even numbered versions (such as 3.4) designate stable releases.
+
+Mesa 4.0.3 basically just contains bug fixes version 4.0.2.
+
+See the docs/VERSIONS file for the list of bug fixes.
+
+The GGI driver has been updated, thanks to Filip Spacek.
+
+
+Device Drivers
+--------------
+
+Mesa advertises itself as either OpenGL 1.2 or OpenGL 1.3 depending on the
+device driver.  If the driver enables all the ARB extensions which are part
+of OpenGL 1.3 then glGetString(GL_VERSION) will return "1.3".  Otherwise,
+it'll return "1.2".
+
+A number of Mesa's software drivers haven't been actively maintained for
+some time.  We rely on volunteers to maintain many of the drivers.
+Here's the current status of all included drivers:
+
+Driver			Status
+----------------------	---------------------
+XMesa (Xlib)		implements OpenGL 1.3
+OSMesa (off-screen)	implements OpenGL 1.3
+FX (3dfx Voodoo1/2)	implements OpenGL 1.3
+SVGA			implements OpenGL 1.3
+Wind River UGL		implements OpenGL 1.3
+Windows/Win32		implements OpenGL 1.3
+DOS/DJGPP		implements OpenGL 1.3 (new in Mesa 4.0.2)
+GGI			implements OpenGL 1.3
+BeOS			needs updating
+Allegro			needs updating
+D3D			needs updating
+
+
+----------------------------------------------------------------------
+$Id: RELNOTES-4.0.3,v 1.1.1.1 2002/10/22 13:07:03 alanh Exp $
Index: xc/extras/Mesa/docs/RELNOTES-4.0.4
diff -u /dev/null xc/extras/Mesa/docs/RELNOTES-4.0.4:1.1.1.1
--- /dev/null	Thu Feb 27 12:14:57 2003
+++ xc/extras/Mesa/docs/RELNOTES-4.0.4	Tue Oct 29 12:32:41 2002
@@ -0,0 +1,73 @@
+
+                          Mesa 4.0.4 release notes
+
+                             October 3, 2002
+
+                              PLEASE READ!!!!
+
+
+
+Introduction
+------------
+
+Mesa uses an even/odd version number scheme like the Linux kernel.
+Odd numbered versions (such as 3.3) designate new developmental releases.
+Even numbered versions (such as 3.4) designate stable releases.
+
+Mesa 4.0.4 contains bug fixes since version 4.0.3 and a few new extensions
+needed for DRI drivers.
+
+See the docs/VERSIONS file for the list of bug fixes.
+
+
+
+New Extensions
+--------------
+
+GL_NV_texture_rectangle was back-ported from the Mesa 4.1 branch so
+that it could be incorporated into the DRI R200 driver.
+
+GL_MESA_ycbcr_texture supports texture images in the YCbCr video format.
+
+GL_APPLE_client_storage extension (for some DRI drivers only) allows the
+caller to say that copying the texture image is not needed.
+
+GL_MESA_pack_invert allows glReadPixels and glGetTexImage() to store images
+in upside-down order, which better matches conventional image file formats.
+
+
+
+Device Drivers
+--------------
+
+Mesa advertises itself as either OpenGL 1.2 or OpenGL 1.3 depending on the
+device driver.  If the driver enables all the ARB extensions which are part
+of OpenGL 1.3 then glGetString(GL_VERSION) will return "1.3".  Otherwise,
+it'll return "1.2".
+
+A number of Mesa's software drivers haven't been actively maintained for
+some time.  We rely on volunteers to maintain many of the drivers.
+Here's the current status of all included drivers:
+
+Driver			Status
+----------------------	---------------------
+XMesa (Xlib)		implements OpenGL 1.3
+OSMesa (off-screen)	implements OpenGL 1.3
+FX (3dfx Voodoo1/2)	implements OpenGL 1.3
+SVGA			implements OpenGL 1.3
+Wind River UGL		implements OpenGL 1.3
+Windows/Win32		implements OpenGL 1.3
+DOS/DJGPP		implements OpenGL 1.3 (new in Mesa 4.0.2)
+GGI			implements OpenGL 1.3
+BeOS			needs updating
+Allegro			needs updating
+D3D			needs updating
+
+
+The DOS driver has been updated by Daniel Borca for Mesa 4.0.4.
+
+
+
+
+----------------------------------------------------------------------
+$Id: RELNOTES-4.0.4,v 1.1.2.2 2002/10/02 17:35:40 brianp Exp $
Index: xc/extras/Mesa/docs/VERSIONS
diff -u /dev/null xc/extras/Mesa/docs/VERSIONS:1.3
--- /dev/null	Thu Feb 27 12:14:57 2003
+++ xc/extras/Mesa/docs/VERSIONS	Mon Dec 16 11:18:25 2002
@@ -0,0 +1,1011 @@
+
+
+Mesa Version History
+====================
+
+1.0 beta   February 1995
+    Initial release
+
+1.1 beta   March 4, 1995
+    Changes:
+	faster point and line drawing (2x faster)
+	more systems supported, better Makefiles
+	Renamed lib*.a files to avoid collisions
+	many small bug fixes
+    New:
+	pseudo-GLX functions added
+	new implementation of evaluators (eval2.c)
+	GLUT support
+
+1.1.1 beta   March 7, 1995
+    Changes:
+	Reverted from eval2.c to eval.c due to FPE on Linux
+	more speed improvements
+	more Makefile changes
+
+1.1.2 beta   March 14, 1995
+    New:
+	implementation of SGI's blending extensions
+	glXUseXFont implemented
+	added MESA_DEBUG environment variable support
+    Changes:
+	Using eval2.c again
+	more FPE-prevention checks (0-length normals are OK)
+	a few small bug fixes
+	much faster pixel logic ops!
+	faster transformation arithmetic
+
+1.1.3 beta   March 31, 1995
+    New:
+	gluScaleImage() and gluBuild2DMipMaps() implemented
+	Mesa widgets for Xt/Motif
+	blendEXT demos
+	added environment variables for selecting visuals
+    Changes:
+	almost all GLUT demos work correctly now
+	faster X device driver functions
+	more bug fixes
+
+1.1.4 beta   April 20, 1995
+    Bug fixes:
+	- missing #define SEEK_SET in src-tk/image.c
+	- compile glShadeModel into display lists
+	- fixed pow() domain error in src/light.c
+	- fixed "flickering bitmaps" in double buffer mode
+	- fixed tk.h and aux.h for C++
+	- state of LIGHT_MODEL_LOCAL_VIEWER was inverted
+    New features:
+	- MUCH, MUCH nicer dithering in 8-bit RGB mode
+	- updated widgets and widget demos
+	- Implemented GLXPixmap functions
+	- Added GLU 1.1 and GLX 1.1 functions
+	- Changed the X/Mesa interface API, more versatile
+	- Implemented gluPartialDisk()
+
+1.2   May 22, 1995
+    Bug fixes:
+	- IRIX 4.x makefile problem
+	- modified tk to share root colormap as needed
+	- gluLookAt normalization problem
+	- suppress Expose, NoExpose events in swapbuffers
+	- glBitmap() and glDrawPixels() clipping
+    New features:
+	- GL_BLEND, GL_MODULATE, GL_DECAL, and GL_REPLACE_EXT texture
+	      modes implemented
+	- texture maps stored more efficiently
+	- texture maps can be compiled into display lists
+	- Bogdan Sikorski's GLU polygon tesselation code
+	- Linas Vepstas's sweep and extrusion library
+	- glXCreateContext()'s shareList parameter works as it's supposed to.
+	      XMesaCreateContext() updated to accept a shareList parameter too.
+	- Mesa can be compiled with real OpenGL .h files
+	- MESA_BACK_BUFFER environment variable
+	- better GLX error checking
+
+1.2.1   June 22, 1995
+    Bug fixes:
+	- X/Mesa double buffer window resize crash
+	- widgets now pass PointerMotion events
+	- X/Mesa incorrect default clear color and drawing color
+	- more robust X MIT-SHM support in X/Mesa
+	- glTexImage( format=GL_LUMINANCE ) didn't work
+	- GL_LINE mode polygons with line width > 1.0 could cause a crash
+	- numerous feedback bugs
+	- glReadPixels() from depth buffer was wrong
+	- error prone depth and stencil buffer allocation
+    New features:
+	- Preliminary Microsoft Windows driver
+	- Implemented a number of missing functions: glEvalCoord[12][df]v(),
+	    glGet...(), etc.
+	- Added a few missing symbols to gl.h and glu.h
+	- Faster rendering of smooth-shaded, RGBA, depth-buffered polygons.
+	- Faster rendering of lines when width=2.0
+	- Stencil-related functions now work in display lists
+    Changes:
+	- renamed aux.h as glaux.h (MS-DOS names can't start with aux)
+	- most filenames are in 8.3 format to accomodate MS-DOS
+	- use GLubytes to store arrays of colors instead of GLints
+
+1.2.2   August 2, 1995
+    New features:
+	- texture mapped points and lines
+	- NURBS! (but not 100% complete)
+	- viewports may safely extend beyond window boundaries
+	- MESA_PRIVATE_CMAP environment variable
+	- Grayscale X display support
+	- two new demos:  demos/gears.c and demos/shadow.c
+	- MachTen for Macintosh configuration
+    Bug fixes:
+	- glGet*(GL_DEPTH_BITS) returned bytes, not bits
+	- point, line, and bitmap rasterization suffered from roundoff errors
+	- fixed a division by zero error in line clippping
+	- occasional wrong default background color really fixed!
+	- glDepthFunc(GL_ALWAYS) with glDepthMask(GL_FALSE) didn't work
+	- gluBuild2DMipmaps malloc problem fixed
+	- view volume clipping of smooth shaded lines resulted in bad colors
+    Changes:
+	- new visual selection method in glXChooseVisual()
+	- improved GLU quadric functions
+	- call XSync for glFinish and XFlush for glFlush
+	- glVertex() calls now use a function pointer to avoid conditionals
+	- removed contrib directory from Mesa tar file (available on ftp site)
+	- AIX shared library support
+	- Removed GLUenum type as it's not in OpenGL
+
+1.2.3   September 26, 1995
+    New features:
+	- Mesa header files now equivalent to SGI OpenGL headers
+	- Support for HP's Color Recovery dithering displays
+	- Faster vertex transformation
+	- Faster raster operations into X windows under certain conditions
+	- New configurations:  HP w/ shared libs, Ultrix w/ GCC, Data General
+	- 4-bit visuals now supported
+    Bug fixes:
+	- glScissor bug fixed
+	- round-off errors in clipping lines against clip planes fixed
+	- byte swapping between hosts and display servers implemented
+	- glGetError() can be called without a current rendering context
+	- problem with accidentally culled polygons is fixed
+	- fixed some widget compilation problems
+
+1.2.4   November 17, 1995
+    New features:
+	- More speed improvements (lighting, fogging, polygon drawing)
+	- Window system and OS-independent off-screen rendering
+	- Preliminary Fortran bindings
+	- glPolygonOffsetEXT implemented
+	- glColorMask and glIndexMask now fully implemented
+	- glPixelZoom implemented
+	- display lists fully implemented
+	- gamma correction
+	- dithering in 8-bit TrueColor/DirectColor visuals
+    Changes:
+	- Improved device driver interface
+	- tk.h renamed to gltk.h to avoid conflicts with Tcl's Tk
+	- Dithering support moved from core into device driver
+    Bug fixes:
+	- glEnable/Disable( GL_LIGHTING ) didn't always take effect
+	- glReadPixels byte swapping was broken
+	- glMaterial with pname==GL_AMBIENT_AND_DIFFUSE was broken
+	- duplicate glColor4b() prototype in GL/gl.h removed
+	- stripes in wave -ci demo fixed
+	- GL_LINEAR_MIPMAP_NEAREST had wrong value
+	- bugs in HP Color Recovery support fixed
+	- fixed bug when blending lines, points, bitmaps outside of window
+
+1.2.5   November 30, 1995
+    New Features:
+	- updated MS Windows driver
+	- new implementation of StaticGray/GrayScale visual support
+    Bug fixes:
+	- pixelzooming with gamma correction or blending didn't work
+	- HP color recovery visual wasn't being picked by glXChooseVisual
+	- glClear didn't always observe glColorMask changes
+	- olympic and offset demos didn't compile on some Suns
+	- texcoord clamping wasn't correct
+	- a polygon optimization introduced an occasional sampling problem
+
+1.2.6   January 26, 1996
+    New Features:
+	- faster line and polygon rendering under certain conditions.  See
+	  Performance Tips 9 and 10 in README
+	- profiling
+	- lighting is a bit faster
+	- better perspective corrected texture mapping
+	- Amiga AmiWin (X11) support
+	- preliminary Linux SVGA driver
+    Changes:
+	- now using a 16-bit depth buffer, faster, smaller
+	- GL_NORMALIZE is disabled by default
+    Bug fixes:
+	- projective texture mapping
+	- fixed a memory leak in the context destroy function
+	- GL_POLYGON with less than 3 vertices caused a crash
+	- glGet*() returned wrong result for GL_INDEX_MODE
+	- reading pixels from an unmapped X window caused a BadMatch error
+
+1.2.7   March 5, 1996
+    New:
+	- faster lighting
+	- faster 16-bit TrueColor rendering on Linux
+	- faster 32-bit TrueColor rendering on Linux, HP, IBM
+	- non-depth-buffered XImage polygons are faster
+	- vertex array extension
+	- software alpha planes
+	- updated Macintosh driver
+	- new NeXT driver
+	- GLU quadric functions generate texture coordinates
+	- reflect.c demo - reflective, textured surface demo
+    Changes:
+	- gamma correction code moved into the X driver for better performance
+    Bug fixes:
+	- multiple glClipPlane()'s didn't work reliably
+	- glPolygonMode() didn't always work
+	- glCullFace( GL_FRONT_AND_BACK ) didn't work
+	- texture mapping with gamma correction was buggy
+	- floating point exceptions in texture coordinate interpolation
+	- XImage byte swapping didn't always work
+	- polygon edge flags weren't always used correctly
+
+1.2.8   May 22, 1996
+    New:
+	- overlay planes on X servers with the SERVER_OVERLAY_VISUALS property
+	- better monochrome output
+	- more IRIX 6.x configurations
+	- more robust RGB mode color allocation
+	- added MESA_XSYNC environment variable
+	- GLX_MESA_pixmap_colormap and GLX_EXT_visual_info extensions
+	- GL_MESA_window_pos extension
+	- faster glReadPixels/glDrawPixels for GL_DEPTH and GL_UNSIGNED_SHORT
+	  and GL_UNSIGNED_INT
+        - driver for prototype Cirrus Mondello 3-D board
+	- updated AmigaDOS driver
+        - a few small speed optimizations in polygon rendering
+    Changes:
+	- internal device driver interface modified to simplify device
+	  driver implementations and to support hardware Z buffers
+	- several changes to the X/Mesa interface (xmesa.h)
+    Bug fixes:
+	- fixed pow(0,0) domain error triggered on some systems
+	- glStencilClear() in a display list caused an infinite loop
+	- glRasterPos*() was sometimes off by +/-0.5 in X and Y
+	- color masking and blending were performed in wrong order
+	- auxSolidCylinder() sometimes drew a wire-frame cylinder
+	- fixed file writing bug in osdemo.c
+	- pixel mapping didn't always work
+	- the GL_GEQUAL stencil func didn't work
+	- the GL_INVERT stencil op didn't work
+	- the stencil write mask didn't work
+	- glPush/PopAttrib() didn't do enough error checking
+	- glIsList() didn't always work correctly
+
+2.0  October 10, 1996
+    New:
+	- Implements OpenGL 1.1 API functions
+	- all texture filtering modes supported (mipmapping)
+	- faster texture mapping, see Performance Tip 11 in README
+	- antialiased RGB points
+	- X support for line and polygon stippling
+	- glDrawBuffer( GL_FRONT_AND_BACK ) works
+	- util/ directory of useful stuff
+	- demos/texobj demo of texture objects
+    Changes:
+	- major internal changes for thread-safeness
+	- new device driver interface
+	- MESA_ALPHA env variable removed
+	- triangle rasterizer replaces polygon rasterizer
+    Bug fixes:
+	- glPopAttrib() bug
+	- glDrawBuffer(GL_NONE) works now
+
+2.1  December 14, 1996
+    New:
+	- VMS support
+	- MS-DOS driver
+	- OpenStep support
+	- updated, combined Windows 95/NT driver
+	- implemented glGetLighti() and glGetTexGen*()
+	- GLX does garbage collection of ancillary buffers
+    Bug fixes:
+	- removed unused _EXT constants from gl.h
+	- fixed polygon offset bugs
+	- Z coordinates of clipped lines were incorrect
+	- glEdgeFlag() in display lists didn't always work
+	- glLight*() in display lists didn't work
+	- fixed X line stipple bugs (Michael Pichler)
+	- glXUseXfonts XFreeFont/XFreeFontInfo bug fixed
+	- fixed a feedback bug
+	- glTexGen*() now transforms GL_EYE_PLANE by inverse modelview matrix
+	- polygons were sometimes culled instead of clipped
+	- triangle rasterizer suffered from float/int overflow exceptions
+	- fixed FP underflow exception in lighting (specular exponent)
+	- glEnable/glDisable of GL_EXT_vertex_array enums didn't work
+	- fixed free(NULL) in GLU tesselator code
+	- using 24-bit color on some X servers resulted in garbage rendering
+	- 32-bit per pixel mode for XFree86 now works
+	- glRotate(a,0,0,0) gave unpredictable results
+	- GL_LINE_STRIP with > 480 vertices had occasional clipping problems
+	- 8-bit TrueColor GLXPixmap rendering incorrectly required a colormap
+	- glMaterial() wasn't ignored when GL_COLOR_MATERIAL was enabled
+	- glEnable(GL_COLOR_MATERIAL) followed by glColor() didn't work right
+	- accumulation buffer was limited to positive values
+	- projective textures didn't work
+	- selection buffer overflows weren't handled correctly
+    Changes:
+	- restored the GL_EXT_polygon_offset extension
+	- slightly faster RGB dithering
+	- the SVGA driver works again
+	- Amiga driver now distributed separately
+	- NeXT driver updated for Mesa 2.x
+
+2.2  March 14, 1997
+    New:
+	- better color selection when dithering
+	- added GL_EXT_texture_object extension
+	- updated MS-DOS driver for DJGPP
+	- added openbsd make configuration
+	- faster dithered flat-shaded triangles
+	- various compilation problems with Motif widgets fixed
+	- gl.h, glx.h and glu.h name mangling option
+	- BeOS driver
+	- 3D texture mapping extension
+	- GL_MESA_resize_buffers extension
+	- morph3d, stex3d and spectex demos
+	- 3Dfx support
+    Bug fixes:
+	- glColorMaterial should finally work right in all respects
+	- linear interpolation of mipmap levels was incorrectly weighted
+	- readpix.c didn't compile on Macintosh
+	- GL_INVERT and related logic ops didn't work right
+	- glTexImage[12]D() didn't check its parameters consistantly
+	- fixed a memory leak in glTexImage[12]D()
+	- kludged around a SunOS 5.x/GCC compiler bug in the feedback code
+	- glReadPixels aborted instead of normally catching some errors
+	- a few 1.1 constants were missing or misnamed in gl.h
+	- glBegin(p); glBegin(q); didn't generate an error
+	- fixed a memory leak in GLX code
+	- clipping of concave polygons could cause a core dump
+	- 1-component alpha texture maps didn't work
+	- fixed a GLU polygon tesselator bug
+	- polygons with colinear vertices were sometimes culled
+	- feedback triangle colors were wrong when using smooth shading
+	- textures with borders didn't work correctly
+	- colors returned in feedback mode were wrong when using lighting
+	- spotlights didn't effect ambient lighting correctly
+	- gluPartialDisk() had a few bugs
+    Changes:
+	- device driver interface expanded to support texture mapping
+	- faster matrix inversion subroutine
+	- commented out #include "wmesa_extend.h" from src/wmesa.c
+	- fixed many compiler warnings in the demo programs
+
+2.3  June 30, 1997
+    New:
+	- Mesa distribution divided into two pieces:  library code and demos
+	- faster vertex transformation, clip testing, lighting
+	- faster line drawing
+	- TrueColor visuals how have dithering (for depths < 24 bits)
+	- added MESA_NO_DITHER environment variable
+	- new device driver function: NearFar(), RenderVB(), RasterSetup()
+	- added LynxOS configuration
+	- added cygnus Win32 configuration
+	- added texcyl.c GLUT demo
+	- added XMesaDitherColor() to X/Mesa interface
+	- new NURBS code from Bogdan Sikorski
+	- added demos/shape.c (non-rectangular X window!)
+    Bug fixes:
+	- glEnable/DisableClientState() were missing from GL/gl.h
+	- GL_SPHERE_MAP texcoord generation didn't work correctly
+	- glXGetConfig() returned wrong number of depth, stencil, accum bits
+	- glDrawPixels feedback/selection didn't examine RasterPos valid bit
+	- black and white were reversed on some monochrome displays
+	- fixed potential image memory leak (wasn't setting reference counter)
+	- glDrawPixels sometimes didn't recognize some GL state changes
+	- gluProject/UnProject() didn't check for divide by zero
+	- stex3d demo called random() and srandom(), not portable
+	- fixed memory leaks in context.c and drawpix.c
+	- fixed NULL dereferencing problem in gl_update_texture_state()
+	- glReadPixels between glBegin/glEnd didn't generate an error.
+	- fixed memory leak in polygon tesselator (Randy Frank)
+	- fixed seg fault bug drawing flat-shaded, depth-tested lines
+	- clipped GL_TRIANGLE_STRIPs sometimes had wrong color when flat-shaded
+	- glBindTexture sometimes didn't work
+	- fixed a bug deep in glXReleaseBuffersMESA()
+	- fog was mistakenly applied to alpha
+	- glPopMatrix didn't set "dirty matrix" flag
+	- glPolygonStipple pattern was sometimes wrong
+	- glClear wasn't disabled during feedback and selection
+	- fixed memory leak in glTexSubImage[123]D
+    Changes:
+	- many library source files reorganized
+	- faster X color allocation, colors also freed when finished with them
+	- new texture sampling function pointer in texture objects
+	- incorporated 3Dfx VooDoo driver v0.16 into main source tree
+	- many 3Dfx driver updates
+	- cygnus Makefiles now included
+	- updated DOS driver
+	- made a few changes to dosmesa.c and wmesa.c (VB->Unclipped)
+	- internally, colors now stored in GLubytes, not GLfixed
+	- optimized changing of GL_SHININESS parameter
+
+2.4  September 18, 1997
+    New:
+	- updated 3Dfx Glide driver
+	- hacks for 3Dfx rendering into an X window or fullscreen
+	- added depth buffer access functions to X/Mesa and OS/Mesa interfaces
+    Bug fixes:
+	- pixel buffer could overflow with long, wide lines
+	- fixed FP underflow problems in lighting
+	- glTexSubImage1D() had an unitialized variable
+	- incomplete texture objects could cause a segfault
+	- glDrawPixels with GL_COMPILE_AND_EXECUTE caused infinite loop
+	- flat-shaded quads in a strip were miscolored if clipped
+	- mipmapped triangle lod computation now works correctly
+	- fixed a few under/overflow bugs in triangle rasterizer
+	- glArrayElement() assigned bad normal if normal array disabled
+	- changed argument to glXReleaseBuffersMESA()
+	- fixed small triangle underflow bugs in tritemp.h (hopefully)
+	- glBindTexture(target, 0) caused a crash
+	- glTexImage[123]D() with NULL image pointer caused crash
+	- glPixelStore parameters are now ignored during display list execution
+	- fixed a two-sided lighting w/ clipping bug (black vertices)
+	- textures with width!=height were sometimes mis-rendered
+	- "weird" projection matrices could cause div by 0, other fp errors
+    Changes:
+	- changed precompiled header symbol from PCH to PC_HEADER
+	- split api.c into api1.c and api2.c
+	- added hash.c source file (but not used yet)
+	- a few Sun and HP configuration file changes
+	- MESA_GLX_FX env var replaces MESA_FX_WINDOW and MESA_FX_FULLSCREEN
+	- fixed a few cygnus build problems (src/Makefile.cygnus, src/wmesa.c)
+
+2.5  November 20, 1997
+    New:
+	- updated 3Dfx driver (v20) for GLQuake
+	- added GL_EXT_paletted_texture extension
+	- added GL_EXT_shared_texture_palette extension
+	- added GL_EXT_point_parameters extension
+	- now including Mark Kilgard's GLUT library v3.6
+	- new GLUT-based demos in gdemos/
+	- added a few more Unix config targets
+	- added Intel X86 assembly language vertex transformation code
+	- 3Dfx/Glide driver for Mesa now recognizes SST_SCREENREFRESH env var
+	- Windows 95 S3 Virge driver
+    Bug fixes:
+	- glCopyTexImage?D would crash due to uninitialized variable
+	- glColor w/ glColorMaterial in a display list caused a bug
+	- fixed several glDrawPixels() and ReadPixels() bugs in 3Dfx driver
+	- glVertex4*() vertices weren't always projected correctly
+	- trying to use mipmapped textured points or lines caused crash
+	- glColor[34][fd]() values now clamped to [0,1] before int conversion
+    Changes:
+	- new device driver functions for texture mapping
+	- hash tables used for display list and texture object lookup
+	- fixed GLX visual handling code to avoid saving redundant visuals
+	- 3Dfx Glide libraries automatically linked to libMesaGL.so
+	- dropped the Cirrus Logic Mondello code since it's obsolete
+	- updated Cygnus Makefiles (Stephane Rehel)
+	- updated Windows MSVC++ Makefiles (Oleg Letsinsky)
+	- procedure for making library files has changed: scripts now take
+	  a major and minor version arguments.  Make-config changed a lot.
+	- new implementation of glTexSubImage2D()
+	- updated widgets-mesa directory to create libMesaGLwM.a (Motif widget)
+	- separate linux-glide and linux-386-glide configurations
+
+2.6  February 12, 1998
+    New:
+	- Windows WGL functions
+	- updated VMS, DOS, Windows, Cygnus, BeOS, Amiga compilation support
+	- v0.22 of 3Dfx Glide driver
+	- more X86 assembly language optimizations
+	- faster blending for some modes
+	- XMesaSetFXmode() to switch between 3Dfx window and full-screen mode 
+	- added preliminary thread support
+	- added GLX_MESA_copy_sub_buffer extension
+	- some clipping optimizations
+    Bug fixes:
+	- fixed shading/material bug when drawing long primitive strips
+	- fixed clipping problem in long primitive strips
+	- fixed clipping bug when using 3Dfx driver
+	- fixed a problem when trying to use X fonts w/ 3Dfx driver
+	- fixed a texture filter bug in 3Dfx/Glide driver
+	- fixed bug in 3Dfx/Glide driver involving depth mask & clearing
+	- glLoadMatrix to set projection matrix confused the 3Dfx driver
+	- non-identity texture matrices didn't work with linux-386 configs
+	- glGenTextures() didn't reserve the returned texture IDs
+	- NULL proxy image sent to glTexImageXD() caused crash
+	- added texture state validation optimization (Henk Kok)
+	- fixed colormap reuse problem when using both RGB and CI windows
+	- 32bpp True/DirectColor X visuals weren't recognized
+	- fixed potential problem in evaluators memory allocation
+	- fixed assorted demo compilation bugs
+    Changes:
+	- replaced old Mesa/windows/ directory with Mesa/WIN32/ directory
+	- converted a few old glaux/gltk demos to GLUT
+	- renamed directories:  demos -> xdemos,  gdemos -> demos
+
+
+3.0  September 17, 1998
+    New:
+	- OpenGL 1.2 API
+	- GL_EXT_abgr pixel format extension
+	- GL_SGIS_texture_edge_clamp extension
+	- GL_SGIS_multitexture extension (to be replaced by GL_ARB_multitex)
+	- GL_EXT_multitexture extension (to be replaced by GL_ARB_multitex)
+	- GL_EXT_rescale_normal extension and renormal.c demo
+	- GLX_SGI_video_sync extension (a no-op)
+	- antialiased lines
+	- glGetTexImage() now implemented
+	- glDraw/Copy/ReadPixels() optimizations
+	- optimized textured triangle code (Marten Stromberg)
+	- more optimization of dithered TrueColor triangles in X driver
+	- Linux GGI driver
+	- updated MGL driver
+    Bug fixes:
+	- lots of assorted compilation fixes
+	- glInitNames didn't write initial hit record
+	- glBitmap didn't always check for invalid raster position
+	- switching between GLX and OSMesa contexts caused a crash
+	- fixed uninitialized variable in Mesa widget code
+	- fixed typo in texture code which caused book/texgen to crash
+	- fixed texture sampling bug when filter=GL_LINEAR and wrap=GL_CLAMP
+	- gluDisk() in POINT or LINE mode sometimes failed
+	- fixed texture + fog bug
+	- GL_COMPILE_AND_EXECUTE mode didn't work reliably
+	- glMultMatrix in projection matrix mode w/ 3Dfx driver could fail
+	- glDrawPixels(color index pixels) weren't converted to RGBA
+	- fixed possible getenv() buffer overflow security bug
+	- glBitmap in feedback mode was offset by xOrig, yOrig params
+	- device driver's DrawPixels hook was never used
+	- glDrawPixels with zoomY!=1 and top/bottom clipping didn't work
+	- glDrawPixels optimized for GL_LUMINANCE, GL_LUMINANCE_ALPHA, GLubyte
+	- fixed MakeCurrent bug in GLwRedrawObjects() in MesaWorkstation.c
+	- glCopyTexSubImage2D() didn't work with 3Dfx driver
+	- lines with width = 2 could cause crash
+	- glClear with scissor rect sometimes cleared whole buffer
+	- glTexSubImage2D( .. GL_COLOR_INDEX .. ) didn't work
+	- glTexImageXD( .. GL_ABGR_EXT .. ) didn't work
+	- computation of inverse modelview matrix sometimes failed
+	- fixed GL_CLAMP mode texture sampling bug
+	- textured line interpolation was somewhat broken
+	- textured triangle interpolation was also somewhat broken
+	- glGet(MODELVIEW/PROJECTION/TEXTURE_MATRIX_STACK_DEPTH) off by one
+	- evaluator state wasn't fully initialized
+	- texture coordinate clipping was buggy
+	- evaluator surfaces could be mis-colored
+	- glAccum(GL_RETURN, s) didn't obey glColorMask() settings
+	- zero area polygons shouldn't be culled if polygon mode is point/line
+	- clipped width and height of glReadPixels was sometimes off by one
+	- blending with alpha = 0 or 1.0 wasn't always exact
+	- reading of pixels from clipped region was buggy
+	- minor tweaking of X visual management in GLX emulator
+	- glPolygonStipple now obeys pixel unpacking parameters
+	- glGetPolygonStipple now obeys pixel packing parameters
+	- interleaved vertex array texture coordinates were broken
+	- query of proxy texture internal format was broken
+	- alpha channel wasn't reliably cleared
+	- fixed divide by zero error in gluScaleImage if dest size = 1 x 1
+    Conformance bug fixes:
+	- GL_SELECTION_BUFFER_POINTER and GL_SELECTION_BUFFER_SIZE were missing
+	- GL_TEXTURE_INTERNAL_FORMAT was missing
+	- glGet*(GL_POLYGON_STIPPLE) was broken
+	- glPush/PopAttrib() didn't save/restore all texture state
+	- glBitmap in feedback mode didn't work
+	- feedback of texture coords didn't always work
+	- glDrawPixels w/ format=GL_DEPTH_COMPONENT, type=GLbyte was broke
+	- glDrawPixels w/ format=GL_DEPTH_COMPONENT, type=GLubyte was broke
+	- glDrawPixels w/ format=GL_STENCIL_INDEX, type=GL_BITMAP was broke
+    Changes:
+	- upgraded GLUT to version 3.7
+	- only GL and GLU library code included in MesaLib.tar.gz
+	- GLUT and all demos now in MesaDemos.tar.gz
+	- glaux and gltk libraries removed
+	- IRIX -n32 and -64 libs go in lib32/ and lib64/ directories
+
+
+3.1 beta 1  November 19, 1998
+    New:
+	- GL_EXT_stencil_wrap extension
+	- GL_INGR_blend_func_separate extension
+	- GL_ARB_multitexture extension
+	- GL_NV_texgen_reflection extension
+	- newly optimized vertex transformation code
+	- updated GLUT 3.7 code
+	- better precision when using 32-bit Z buffer
+	- Allegro DJGPP driver
+    Bug fixes:
+	- glCopyPixels between front/back buffers didn't copy alpha correctly
+	- fixed out-of-bounds memory access in optimized 2-D texture code
+	- glPixelStorei didn't accept GL_PACK/UNPACK_IMAGE_HEIGHT parameter
+	- glGet*() didn't accept GL_MAX_3D_TEXTURE_SIZE parameter
+	- clipping of texture coordinates sometimes had bad R,Q values
+	- GL_CLAMP_TO_EDGE texture sampling was off by 0.5 texels
+	- glEdgeFlagPointer() now takes a GLvoid * instead of GLboolean *
+	- texture was sometimes applied twice with 3Dfx driver
+	- glPush/PopAttrib() fouled up texture object reference counts
+	- glDeleteLists(0, n) caused assertion failure
+	- bilinear texture sampling wasn't accurate enough
+	- glClear w/ glDepthMask(GL_FALSE) didn't work right on 3Dfx
+	- color components were reversed on big endian 32 bpp X visuals
+    Changes:
+	- removed GL_EXT_multitexture extension
+
+
+3.1 beta 2  May 24, 1999
+    New:
+	- multi-textured points and lines (mjk@nvidia.com)
+	- optimized 24bpp X rendering (bernd.paysan@gmx.de)
+	- added allegro support (bernie-t@geocities.com)
+	- cleaned-up Windows-related stuff (Ted Jump)
+	- minor stereo changes (KendallB@scitechsoft.com)
+	- new BeOS driver which implements BGLView class
+	- new Direct3D driver (see src/D3D)
+	- more efficient filled gluCylinder() function
+	- utilities:  util/showbuffer.[ch] and util/glstate.[ch]
+	- fixed some IRIX compiler warnings
+	- added support for building Mesa in XFree86 with
+	    SGI's GLX (kevin@precisioninsight.com)
+    Bug fixes:
+	- a variety of Windows/Mesa bug fixes (mjk@nvidia.com)
+	- packed pixel images weren't unpacked correctly
+	- patches some win32 files in GLUT (mjk@nvidia.com)
+	- glTexImage[123]D() didn't accept internalFormat == GL_COLOR_INDEX
+	- fixed lighting bug in Keith's new shading code
+	- fixed texture segfault seen in Lament screensaver
+	- fixed miscellaneous low-memory bugs
+	- glClear(GL_COLOR_BUFFER_BIT) with RGBA or CI masking was broken
+	- GL_LINEAR sampling of 3D textures was broken
+	- fixed SVR4 'cc' compiler macro problem (dawes@xfree86.org)
+	- added GL_TEXTURE_PRIORITY fix (keithh@netcomuk.co.uk)
+	- fixed wide point and wide line conformance bugs (brianp)
+    Changes:
+	- some device driver changes (see src/dd.h)
+	- new copyright on core Mesa code
+
+
+3.1 beta 3  September 17, 1999
+    New:
+	- optimized glAccum function
+	- optimized 24bpp rendering in XMesa driver
+	- GLU 1.2 polygon tessellator
+    Bug Fixes:
+	- glGetTexLevelParameter wasn't fully implemented
+	- glXUseXFont now handles multi-byte fonts
+	- glIsEnabled(GL_TEXTURE_2D / 3D) returned wrong result
+	- alpha channel of blending points, lines was sometimes incorrect
+    Changes:
+	- New library names:  "libGL" instead of "libMesaGL"
+	- New library numbering: libGL.so.1.2.310
+	- New subdirectories:  docs/ and bin/
+	- New Makefile-system (autoconf,automake,libtool)
+
+
+3.1 final  December 14, 1999
+    New:
+	- added demos/gloss.c
+	- added xdemos/glxdpyinfo.c
+	- added GLX_ARB_get_proc_address extension
+	- rewritten glTexImage code paths (faster, less memory, bug fixes)
+    Bug Fixes:
+	- several vertex array bug fixes
+	- overlapping glCopyPixels with pixel zooming now works
+	- glXUseXFont() bitmaps were vertically shifted by one pixel
+	- glCopyPixels with pixel zooming now works
+
+
+3.2 final  April 24, 2000
+    Bug fixes:
+	- fixed memcpy bugs in span.c
+	- fixed missing glEnd problem in demos/tessdemo.c
+	- fixed bug when clearing 24bpp Ximages
+	- fixed clipping problem found in Unreal Tournament
+	- fixed Loki's "ice bug" and "crazy triangles" seen in Heretic2
+	- fixed Loki's 3dfx RGB vs BGR bug
+	- fixed Loki's 3dfx smooth/flat shading bug in SoF
+    Changes:
+	- updated docs/README file
+	- use bcopy() optimizations on FreeBSD
+	- re-enabled the optimized persp_textured_triangle() function
+
+
+3.2.1  July 19, 2000
+    Bug fixes:
+	- gluBuild2DMipmaps() didn't accept GL_BGRA
+	- Fixed compile/makefile problems on IRIX
+	- fixed segfault in 3dfx driver when using GL selection/feedback
+	- no longer cull very, very tiny triangles
+	- blending w/ drawbuffer==GL_FRONT_BACK caused segfault (sw rendering)
+	- fixed Motif detection code in widgets-mesa/configure.in
+	- glColorMaterial and glMaterial updates to emissive and ambient
+	  didn't always work right
+	- Specular highlights weren't always in the right place
+	- clipped GL_LINE mode polygons had interior lines appear
+	- blend term GL_ONE_MINUS_CONSTANT_ALPHA was broken
+	- GL_NICEST fog didn't always work with flat shading
+	- glRect commands in display lists were sometimes miscolored
+	- Line Z offset didn't always work
+	- fixed texgen normal vector problem (gloss's teapot)
+	- numerous GL conformance bugs fixed
+    Changes:
+	- glColorMask(false, false, false, false) handled better/faster
+	- reverted to old GLU polygon tessellator, GLU 1.1
+	- updated Win32 build files
+
+
+3.3  July 21, 2000
+    New:
+	- antialiased triangles now implemented
+	- GL_EXT_texture_env_add texture mode extension
+	- GLX 1.3 API
+	- support for separate draw/read buffers (ie GL_SGI_make_current_read)
+	- thread-safe API dispath
+	- improved glxinfo program
+	- demos/texdown program to measure texture download performance
+	- glext.h header file
+	- demos/geartrain program
+	- GL_EXT_texture_lod_bias extension
+	- demos/lodbias program
+	- further optimized glRead/DrawPixels for 16-bit TrueColor X visuals
+	- GLX_EXT_visual_rating extension (a no-op, however)
+	- GL_HP_occlusion_test extension (for X and OS/Mesa drivers)
+	- demos/occlude program
+	- GL_SGIS_pixel_texture and GL_SGIX_pixel_texture extensions
+	- demos/pixeltex program
+	- GL_SGI_color_matrix extension
+	- GL_SGI_color_table extension
+	- GL_EXT_histogram extension
+	- GL_ARB_texture_cube_map extension
+	- added xdemos/glxheads and xdemos/manywin
+	- demos/texenv.c demo
+	- GL_EXT_texture_env_combine extension (by Holger Waechtler)
+	- Xlib driver is now thread-safe (see xdemos/glthreads)
+    Bug Fixes:
+	- various GL conformance failures fixed since 3.2.1
+    Changes:
+	- gl.h now uses #defines instead of C enums for all tokens
+	- glu.h now uses #defines instead of C enums for all tokens
+	- moved programs from 3Dfx/demos/ into demos/ directory
+
+
+3.4  November 3, 2000
+    New:
+	- optimized glDrawPixels for glPixelZoom(1,-1)
+    Bug Fixes:
+	- widgets-mesa/src/*.c files were missing from 3.3 distro
+	- include/GL/mesa_wgl.h file was missing from 3.3 distro
+	- fixed some Win32 compile problems
+	- texture object priorities weren't getting initialized to 1.0
+	- glAreTexturesResident return value was wrong when using hardware
+	- glXUseXFont segfaulted when using 3dfx driver (via MESA_GLX_FX)
+	- glReadPixels with GLushort packed types was broken
+	- fixed a few bugs in the GL_EXT_texture_env_combine texture code
+	- glPush/PopAttrib(GL_ENABLE_BIT) mishandled multi-texture enables
+	- fixed some typos/bugs in the VB code
+	- glDrawPixels(GL_COLOR_INDEX) to RGB window didn't work
+	- optimized glDrawPixels paths weren't being used
+	- per-fragment fog calculation didn't work without a Z buffer
+	- improved blending accuracy, fixes Glean blendFunc test failures
+	- glPixelStore(GL_PACK/UNPACK_SKIP_IMAGES) wasn't handled correctly
+	- glXGetProcAddressARB() didn't always return the right address
+	- gluBuild[12]DMipmaps() didn't grok the GL_BGR pixel format
+	- texture matrix changes weren't always detected (GLUT projtex demo)
+	- fixed random color problem in vertex fog code
+	- fixed Glide-related bug that let Quake get a 24-bit Z buffer
+    Changes:
+	- finished internal support for compressed textures for DRI
+
+
+3.4.1  February 14, 2001
+    New:
+	- fixed some Linux build problems
+	- fixed some Windows build problems
+	- GL_EXT_texture_env_dot3 extension (Gareth Hughes)
+    Bug fixes:
+	- added RENDER_START/RENDER_FINISH macros for glCopyTexImage in DRI
+	- various state-update code changes needed for DRI bugs
+	- disabled pixel transfer ops in glColorTable commands, not needed
+	- fixed bugs in glCopyConvolutionFilter1D/2D, glGetConvolutionFilter
+	- updated sources and fixed compile problems in widgets-mesa/
+	- GLX_PBUFFER enum value was wrong in glx.h
+	- fixed a glColorMaterial lighting bug
+	- fixed bad args to Read/WriteStencilSpan in h/w stencil clear function
+	- glXCopySubBufferMESA() Y position was off by one
+	- Error checking of glTexSubImage3D() was broken (bug 128775)
+	- glPopAttrib() didn't restore all derived Mesa state correctly
+	- Better glReadPixels accuracy for 16bpp color - fixes lots of OpenGL
+	  conformance problems at 16bpp.
+	- clearing depth buffer with scissoring was broken, would segfault
+	- OSMesaGetDepthBuffer() returned bad bytesPerValue value
+	- fixed a line clipping bug (reported by Craig McDaniel)
+	- fixed RGB color over/underflow bug for very tiny triangles
+    Known problems:
+	- NURBS or evaluator surfaces inside display lists don't always work
+
+
+3.4.2  May 17, 2001
+    Bug fixes:
+	- deleting the currently bound texture could cause bad problems
+	- using fog could result in random vertex alpha values
+	- AA triangle rendering could touch pixels outside right window bound
+	- fixed byteswapping problem in clear_32bit_ximage() function
+	- fixed bugs in wglUseFontBitmapsA(), by Frank Warmerdam
+	- fixed memory leak in glXUseXFont()
+	- fragment sampling in AA triangle function was off by 1/2 pixel
+	- Windows: reading pixels from framebuffer didn't always work
+	- glConvolutionFilter2D could segfault or cause FP exception
+	- fixed segfaults in FX and X drivers when using tex unit 1 but not 0
+	- GL_NAND logicop didn't work right in RGBA mode
+	- fixed a memory corruption bug in vertex buffer reset code
+	- clearing the softwara alpha buffer with scissoring was broken
+	- fixed a few color index mode fog bugs
+	- fixed some bad assertions in color index mode
+	- fixed FX line 'stipple' bug #420091
+	- fixed stencil buffer clear width/height typo
+	- fixed GL error glitches in gl[Client]ActiveTextureARB()
+	- fixed Windows compilation problem in texutil.c
+	- fixed 1/8-pixel AA triangle sampling error
+    Changes:
+	- optimized writing mono-colored pixel spans to X pixmaps
+	- increased max viewport size to 2048 x 2048
+
+
+3.5  June 21, 2001
+    New:
+	- internals of Mesa divided into modular pieces (Keith Whitwell)
+	- 100% OpenGL 1.2 conformance (passes all conformance tests)
+	- new AA line algorithm
+	- GL_EXT_convolution extension
+	- GL_ARB_imaging subset
+	- OSMesaCreateContextExt() function
+	- GL_ARB_texture_env_add extension (same as GL_EXT_texture_env_add)
+	- GL_MAX_TEXTURE_UNITS_ARB now defaults to eight
+	- GL_EXT_fog_coord extension (Keith Whitwell)
+	- GL_EXT_secondary_color extension (Keith Whitwell)
+	- GL_ARB_texture_env_add extension (same as GL_EXT_texture_env_add)
+	- GL_SGIX_depth_texture extension
+	- GL_SGIX_shadow and GL_SGIX_shadow_ambient extensions
+	- demos/shadowtex.c demo of GL_SGIX_depth_texture and GL_SGIX_shadow
+	- GL_ARB_texture_env_combine extension
+	- GL_ARB_texture_env_dot3 extension
+	- GL_ARB_texture_border_clamp (aka GL_SGIS_texture_border_clamp)
+	- OSMesaCreateContextExt() function
+	- libOSMesa.so library, contains the OSMesa driver interface
+	- GL/glxext.h header file for GLX extensions
+	- somewhat faster software texturing, fogging, depth testing
+	- all color-index conformance tests now pass (only 8bpp tested)
+	- SPARC assembly language TCL optimizations (David Miller)
+	- GL_SGIS_generate_mipmap extension
+    Bug Fixes:
+	- fbiRev and tmuRev were unitialized when using Glide3
+	- fixed a few color index mode conformance failures; all pass now
+	- now appling antialiasing coverage to alpha after texturing
+	- colors weren't getting clamped to [0,1] before color table lookup
+	- fixed RISC alignment errors caused by COPY_4UBV macro
+	- drawing wide, flat-shaded lines could cause a segfault
+	- vertices now snapped to 1/16 pixel to fix rendering of tiny triangles
+    Changes:
+	- SGI's Sample Implementation (SI) 1.3 GLU library replaces Mesa GLU
+	- new libOSMesa.so library, contains the OSMesa driver interface
+
+
+4.0  October 22, 2001
+    New:
+	- Mesa 4.0 implements the OpenGL 1.3 specification
+	- GL_IBM_rasterpos_clip extension
+	- GL_EXT_texture_edge_clamp extension (aka GL_SGIS_texture_edge_clamp)
+	- GL_ARB_texture_mirrored_repeat extension
+	- WindML UGL driver (Stephane Raimbault)
+	- added OSMESA_MAX_WIDTH/HEIGHT queries
+	- attempted compiliation fixes for Solaris 5, 7 and 8
+	- updated glext.h and glxext.h files
+	- updated Windows driver (Karl Schultz)
+    Bug fixes:
+	- added some missing GLX 1.3 tokens to include/GL/glx.h
+	- GL_COLOR_MATRIX changes weren't recognized by teximage functions
+	- glCopyPixels with scale and bias was broken
+	- glRasterPos with lighting could segfault
+	- glDeleteTextures could leave a dangling pointer
+	- Proxy textures for cube maps didn't work
+	- fixed a number of 16-bit color channel bugs
+	- fixed a few minor memory leaks
+	- GLX context sharing was broken in 3.5
+	- fixed state-update bugs in glPopClientAttrib()
+	- fixed glDrawRangeElements() bug
+	- fixed a glPush/PopAttrib() bug related to texture binding
+	- flat-shaded, textured lines were broken
+	- fixed a dangling pointer problem in the XMesa code (Chris Burghart)
+	- lighting didn't always produce the correct alpha value
+	- fixed 3DNow! code to not read past end of arrays (Andrew Lewycky)
+
+
+4.0.1  December 17, 2001
+    New:
+	- better sub-pixel sample positions for AA triangles (Ray Tice)
+	- slightly faster blending for (GL_ZERO, GL_ONE) and (GL_ONE, GL_ZERO)
+    Bug fixes:
+	- added missing break statements in glGet*() for multisample cases
+	- fixed uninitialized hash table mutex bug (display lists / texobjs)
+	- fixed bad teximage error check conditional (bug 476846)
+	- fixed demos readtex.c compilation problem on Windows (Karl Schultz)
+	- added missing glGet() query for GL_MAX_TEXTURE_LOD_BIAS_EXT
+	- silence some compiler warnings (gcc 2.96)
+	- enable the #define GL_VERSION_1_3 in GL/gl.h
+	- added GL 1.3 and GLX 1.4 entries to gl_mangle.h and glx_mangle.h
+	- fixed glu.h typedef problem found with MSDev 6.0
+	- build libGL.so with -Bsymbolic (fixes bug found with Chromium)
+	- added missing 'const' to glXGetContextIDEXT() in glxext.h
+	- fixed a few glXGetProcAddress() errors (texture compression, etc)
+	- fixed start index bug in compiled vertex arrays (Keith)
+	- fixed compilation problems in src/SPARC/glapi_sparc.S
+	- fixed triangle strip "parity" bug found in VTK medical1 demo (Keith)
+	- use glXGetProcAddressARB in GLUT to avoid extension linking problems
+	- provoking vertex of flat-shaded, color-index triangles was wrong
+	- fixed a few display list bugs (GLUT walker, molecule, etc) (Keith)
+	- glTexParameter didn't flush the vertex buffer (Ray Tice)
+	- feedback attributes for glDraw/CopyPixels and glBitmap were wrong
+	- fixed bug in normal length caching (ParaView lighting bug)
+	- fixed separate_specular color bug found in Chimera (18 Dec 2001)
+
+
+4.0.2  April 2, 2002
+    New:
+	- New DOS (DJGPP) driver written by Daniel Borca
+	- New driver interface functions for TCL drivers (such as Radeon DRI)
+	- GL_RENDERER string returns "Mesa Offscreen16" or "Mesa Offscreen32"
+	  if using deep color channels
+	- latest GL/glext.h and GL/glxext.h headers from SGI
+    Bug fixes:
+	- GL_BLEND with non-black texture env color wasn't always correct
+	- GL_REPLACE with GL_RGB texture format wasn't always correct (alpha)
+	- glTexEnviv( pname != GL_TEXTURE_ENV_COLOR ) was broken
+	- glReadPixels was sometimes mistakenly clipped by the scissor box
+	- glDraw/ReadPixels didn't catch all the errors that they should have
+	- Fixed 24bpp rendering problem in Windows driver (Karl Schultz)
+	- 16-bit GLchan mode fixes (m_trans_tmp.h, s_triangle.c)
+	- Fixed 1-bit float->int conversion bug in glDrawPixels(GL_DEPTH_COMP)
+	- glColorMask as sometimes effecting glXSwapBuffers()
+	- fixed a potential bug in XMesaGarbageCollect()
+	- N threads rendering into one window didn't work reliably
+	- glCopyPixels didn't work for deep color channels
+	- improved 8 -> 16bit/channel texture image conversion (Gerk Huisma)
+	- glPopAttrib() didn't correctly restore user clip planes
+	- user clip planes failed for some perspective projections (Chromium)
+    Known bugs:
+	- mipmap LOD computation
+
+
+4.0.3  June 25, 2002
+    New:
+	- updated GL/glext.h file (version 15)
+	- corrected MMX blend code (Jose Fonseca)
+	- support for software-based alpha planes in Windows driver
+	- updated GGI driver (Filip Spacek)
+    Bug fixes:
+	- glext.h had wrong values for GL_DOT3_RGB[A]_EXT tokens
+	- OSMesaMakeCurrent() didn't recognize buffer size changes
+	- assorted conformance fixes for 16-bit/channel rendering
+	- texcombine alpha subtraction mode was broken
+	- fixed lighting bug with non-uniform scaling and display lists
+	- fixed bug when deleting shared display lists
+	- disabled SPARC cliptest assembly code (Mesa bug 544665)
+	- fixed a couple Solaris compilation/link problems
+	- blending clipped glDrawPixels didn't always work
+	- glGetTexImage() didn't accept packed pixel types
+	- glPixelMapu[is]v() could explode given too large of pixelmap
+	- glGetTexParameter[if]v() didn't accept GL_TEXTURE_MAX_ANISOTROPY_EXT
+	- glXCopyContext() could lead to segfaults
+	- glCullFace(GL_FRONT_AND_BACK) didn't work (bug 572665)
+    Changes:
+	- lots of C++ (g++) code clean-ups
+	- lots of T&L updates for the Radeon DRI driver
+    Known bugs:
+	- mipmap LOD computation (fixed for Mesa 4.1)
+
+
+4.0.4  October 3, 2002
+    New:
+	- GL_NV_texture_rectangle extension
+	- updated glext.h header (version 17)
+	- updated DOS driver (Daniel Borca)
+	- updated BeOS R5 driver (Philippe Houdoin)
+	- added GL_IBM_texture_mirror_repeat
+	- glxinfo now takes -l option to print interesting OpenGL limits info
+	- GL_MESA_ycbcr_texture extension
+	- GL_APPLE_client_storage extension (for some DRI drivers only)
+	- GL_MESA_pack_invert extension
+    Bug fixes:
+	- fixed GL_LINEAR fog bug by adding clamping
+	- fixed FP exceptions found using Alpha CPU
+	- 3dfx MESA_GLX_FX=window (render to window) didn't work
+	- fixed memory leak in wglCreateContest (Karl Schultz)
+	- define GLAPIENTRY and GLAPI if undefined in glu.h
+	- wglGetProcAddress didn't handle all API functions
+	- when testing for OpenGL 1.2 vs 1.3, check for GL_ARB_texture_cube_map
+	- removed GL_MAX_CONVOLUTION_WIDTH/HEIGHT from glGetInteger/Float/etc()
+	- error checking in compressed tex image functions had some glitches
+	- fixed AIX compile problem in src/config.c
+	- glGetTexImage was using pixel unpacking instead of packing params
+	- auto-mipmap generation for cube maps was incorrect
+    Changes:
+	- max texture units reduced to six to accomodate texture rectangles
+	- removed unfinished GL_MESA_sprite_point extension code
Index: xc/extras/Mesa/include/GL/gl.h
diff -u xc/extras/Mesa/include/GL/gl.h:1.10 xc/extras/Mesa/include/GL/gl.h:1.16
--- xc/extras/Mesa/include/GL/gl.h:1.10	Fri May 18 13:10:12 2001
+++ xc/extras/Mesa/include/GL/gl.h	Mon Dec 16 11:18:25 2002
@@ -1,9 +1,10 @@
+/* $Id: gl.h,v 1.26 2002/09/23 17:26:11 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -62,6 +63,10 @@
 #  define GLAPIENTRY
 #endif /* WIN32 / CYGWIN bracket */
 
+#if (defined(__BEOS__) && defined(__POWERPC__)) || defined(__QUICKDRAW__)
+#  define PRAGMA_EXPORT_SUPPORTED		1
+#endif
+
 #if defined(_WIN32) && !defined(_WINGDI_) && !defined(_GNU_H_WINDOWS32_DEFINES) && !defined(OPENSTEP) && !defined(__CYGWIN__)
 #include <gl/mesa_wgl.h>
 #endif
@@ -83,9 +88,10 @@
 
 #define GL_VERSION_1_1   1
 #define GL_VERSION_1_2   1
+#define GL_VERSION_1_3   1
+#define GL_ARB_imaging   1
 
 
-
 /*
  *
  * Datatypes
@@ -324,12 +330,12 @@
 #define GL_ONE					0x1
 #define GL_SRC_COLOR				0x0300
 #define GL_ONE_MINUS_SRC_COLOR			0x0301
-#define GL_DST_COLOR				0x0306
-#define GL_ONE_MINUS_DST_COLOR			0x0307
 #define GL_SRC_ALPHA				0x0302
 #define GL_ONE_MINUS_SRC_ALPHA			0x0303
 #define GL_DST_ALPHA				0x0304
 #define GL_ONE_MINUS_DST_ALPHA			0x0305
+#define GL_DST_COLOR				0x0306
+#define GL_ONE_MINUS_DST_COLOR			0x0307
 #define GL_SRC_ALPHA_SATURATE			0x0308
 #define GL_CONSTANT_COLOR			0x8001
 #define GL_ONE_MINUS_CONSTANT_COLOR		0x8002
@@ -636,7 +642,46 @@
 #define GL_TEXTURE_GEN_R			0x0C62
 #define GL_TEXTURE_GEN_Q			0x0C63
 
-/* GL 1.1 texturing */
+/* Utility */
+#define GL_VENDOR				0x1F00
+#define GL_RENDERER				0x1F01
+#define GL_VERSION				0x1F02
+#define GL_EXTENSIONS				0x1F03
+
+/* Errors */
+#define GL_NO_ERROR 				0x0
+#define GL_INVALID_VALUE			0x0501
+#define GL_INVALID_ENUM				0x0500
+#define GL_INVALID_OPERATION			0x0502
+#define GL_STACK_OVERFLOW			0x0503
+#define GL_STACK_UNDERFLOW			0x0504
+#define GL_OUT_OF_MEMORY			0x0505
+
+/* glPush/PopAttrib bits */
+#define GL_CURRENT_BIT				0x00000001
+#define GL_POINT_BIT				0x00000002
+#define GL_LINE_BIT				0x00000004
+#define GL_POLYGON_BIT				0x00000008
+#define GL_POLYGON_STIPPLE_BIT			0x00000010
+#define GL_PIXEL_MODE_BIT			0x00000020
+#define GL_LIGHTING_BIT				0x00000040
+#define GL_FOG_BIT				0x00000080
+#define GL_DEPTH_BUFFER_BIT			0x00000100
+#define GL_ACCUM_BUFFER_BIT			0x00000200
+#define GL_STENCIL_BUFFER_BIT			0x00000400
+#define GL_VIEWPORT_BIT				0x00000800
+#define GL_TRANSFORM_BIT			0x00001000
+#define GL_ENABLE_BIT				0x00002000
+#define GL_COLOR_BUFFER_BIT			0x00004000
+#define GL_HINT_BIT				0x00008000
+#define GL_EVAL_BIT				0x00010000
+#define GL_LIST_BIT				0x00020000
+#define GL_TEXTURE_BIT				0x00040000
+#define GL_SCISSOR_BIT				0x00080000
+#define GL_ALL_ATTRIB_BITS			0x000FFFFF
+
+
+/* OpenGL 1.1 */
 #define GL_PROXY_TEXTURE_1D			0x8063
 #define GL_PROXY_TEXTURE_2D			0x8064
 #define GL_TEXTURE_PRIORITY			0x8066
@@ -644,20 +689,6 @@
 #define GL_TEXTURE_BINDING_1D			0x8068
 #define GL_TEXTURE_BINDING_2D			0x8069
 #define GL_TEXTURE_INTERNAL_FORMAT		0x1003
-
-/* GL 1.2 texturing */
-#define GL_PACK_SKIP_IMAGES			0x806B
-#define GL_PACK_IMAGE_HEIGHT			0x806C
-#define GL_UNPACK_SKIP_IMAGES			0x806D
-#define GL_UNPACK_IMAGE_HEIGHT			0x806E
-#define GL_TEXTURE_3D				0x806F
-#define GL_PROXY_TEXTURE_3D			0x8070
-#define GL_TEXTURE_DEPTH			0x8071
-#define GL_TEXTURE_WRAP_R			0x8072
-#define GL_MAX_3D_TEXTURE_SIZE			0x8073
-#define GL_TEXTURE_BINDING_3D			0x806A
-
-/* Internal texture formats (GL 1.1) */
 #define GL_ALPHA4				0x803B
 #define GL_ALPHA8				0x803C
 #define GL_ALPHA12				0x803D
@@ -691,21 +722,10 @@
 #define GL_RGB10_A2				0x8059
 #define GL_RGBA12				0x805A
 #define GL_RGBA16				0x805B
-
-/* Utility */
-#define GL_VENDOR				0x1F00
-#define GL_RENDERER				0x1F01
-#define GL_VERSION				0x1F02
-#define GL_EXTENSIONS				0x1F03
-
-/* Errors */
-#define GL_NO_ERROR 				0x0
-#define GL_INVALID_VALUE			0x0501
-#define GL_INVALID_ENUM				0x0500
-#define GL_INVALID_OPERATION			0x0502
-#define GL_STACK_OVERFLOW			0x0503
-#define GL_STACK_UNDERFLOW			0x0504
-#define GL_OUT_OF_MEMORY			0x0505
+#define GL_CLIENT_PIXEL_STORE_BIT		0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT		0x00000002
+#define GL_ALL_CLIENT_ATTRIB_BITS 		0xFFFFFFFF
+#define GL_CLIENT_ALL_ATTRIB_BITS 		0xFFFFFFFF
 
 
 /* OpenGL 1.2 */
@@ -740,11 +760,20 @@
 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY	0x0B23
 #define GL_ALIASED_POINT_SIZE_RANGE		0x846D
 #define GL_ALIASED_LINE_WIDTH_RANGE		0x846E
-
+#define GL_PACK_SKIP_IMAGES			0x806B
+#define GL_PACK_IMAGE_HEIGHT			0x806C
+#define GL_UNPACK_SKIP_IMAGES			0x806D
+#define GL_UNPACK_IMAGE_HEIGHT			0x806E
+#define GL_TEXTURE_3D				0x806F
+#define GL_PROXY_TEXTURE_3D			0x8070
+#define GL_TEXTURE_DEPTH			0x8071
+#define GL_TEXTURE_WRAP_R			0x8072
+#define GL_MAX_3D_TEXTURE_SIZE			0x8073
+#define GL_TEXTURE_BINDING_3D			0x806A
 
 
 /*
- * OpenGL 1.2 imaging subset (NOT IMPLEMENTED BY MESA)
+ * OpenGL 1.2 imaging subset
  */
 /* GL_EXT_color_table */
 #define GL_COLOR_TABLE				0x80D0
@@ -821,41 +850,117 @@
 #define GL_FUNC_ADD				0x8006
 #define GL_FUNC_SUBTRACT			0x800A
 #define GL_FUNC_REVERSE_SUBTRACT		0x800B
-#define	GL_BLEND_COLOR				0x8005
+#define GL_BLEND_COLOR				0x8005
 
 
-/* glPush/PopAttrib bits */
-#define GL_CURRENT_BIT				0x00000001
-#define GL_POINT_BIT				0x00000002
-#define GL_LINE_BIT				0x00000004
-#define GL_POLYGON_BIT				0x00000008
-#define GL_POLYGON_STIPPLE_BIT			0x00000010
-#define GL_PIXEL_MODE_BIT			0x00000020
-#define GL_LIGHTING_BIT				0x00000040
-#define GL_FOG_BIT				0x00000080
-#define GL_DEPTH_BUFFER_BIT			0x00000100
-#define GL_ACCUM_BUFFER_BIT			0x00000200
-#define GL_STENCIL_BUFFER_BIT			0x00000400
-#define GL_VIEWPORT_BIT				0x00000800
-#define GL_TRANSFORM_BIT			0x00001000
-#define GL_ENABLE_BIT				0x00002000
-#define GL_COLOR_BUFFER_BIT			0x00004000
-#define GL_HINT_BIT				0x00008000
-#define GL_EVAL_BIT				0x00010000
-#define GL_LIST_BIT				0x00020000
-#define GL_TEXTURE_BIT				0x00040000
-#define GL_SCISSOR_BIT				0x00080000
-#define GL_ALL_ATTRIB_BITS			0x000FFFFF
+/* OpenGL 1.3 */
+/* multitexture */
+#define GL_TEXTURE0				0x84C0
+#define GL_TEXTURE1				0x84C1
+#define GL_TEXTURE2				0x84C2
+#define GL_TEXTURE3				0x84C3
+#define GL_TEXTURE4				0x84C4
+#define GL_TEXTURE5				0x84C5
+#define GL_TEXTURE6				0x84C6
+#define GL_TEXTURE7				0x84C7
+#define GL_TEXTURE8				0x84C8
+#define GL_TEXTURE9				0x84C9
+#define GL_TEXTURE10				0x84CA
+#define GL_TEXTURE11				0x84CB
+#define GL_TEXTURE12				0x84CC
+#define GL_TEXTURE13				0x84CD
+#define GL_TEXTURE14				0x84CE
+#define GL_TEXTURE15				0x84CF
+#define GL_TEXTURE16				0x84D0
+#define GL_TEXTURE17				0x84D1
+#define GL_TEXTURE18				0x84D2
+#define GL_TEXTURE19				0x84D3
+#define GL_TEXTURE20				0x84D4
+#define GL_TEXTURE21				0x84D5
+#define GL_TEXTURE22				0x84D6
+#define GL_TEXTURE23				0x84D7
+#define GL_TEXTURE24				0x84D8
+#define GL_TEXTURE25				0x84D9
+#define GL_TEXTURE26				0x84DA
+#define GL_TEXTURE27				0x84DB
+#define GL_TEXTURE28				0x84DC
+#define GL_TEXTURE29				0x84DD
+#define GL_TEXTURE30				0x84DE
+#define GL_TEXTURE31				0x84DF
+#define GL_ACTIVE_TEXTURE			0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE		0x84E1
+#define GL_MAX_TEXTURE_UNITS			0x84E2
+/* texture_cube_map */
+#define GL_NORMAL_MAP				0x8511
+#define GL_REFLECTION_MAP			0x8512
+#define GL_TEXTURE_CUBE_MAP			0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP		0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X		0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X		0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y		0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y		0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z		0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z		0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP		0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE		0x851C
+/* texture_compression */
+#define GL_COMPRESSED_ALPHA			0x84E9
+#define GL_COMPRESSED_LUMINANCE			0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA		0x84EB
+#define GL_COMPRESSED_INTENSITY			0x84EC
+#define GL_COMPRESSED_RGB			0x84ED
+#define GL_COMPRESSED_RGBA			0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT		0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE	0x86A0
+#define GL_TEXTURE_COMPRESSED			0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS	0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS		0x86A3
+/* multisample */
+#define GL_MULTISAMPLE				0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE		0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE			0x809F
+#define GL_SAMPLE_COVERAGE			0x80A0
+#define GL_SAMPLE_BUFFERS			0x80A8
+#define GL_SAMPLES				0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE		0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT		0x80AB
+#define GL_MULTISAMPLE_BIT			0x20000000
+/* transpose_matrix */
+#define GL_TRANSPOSE_MODELVIEW_MATRIX		0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX		0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX		0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX		0x84E6
+/* texture_env_combine */
+#define GL_COMBINE				0x8570
+#define GL_COMBINE_RGB				0x8571
+#define GL_COMBINE_ALPHA			0x8572
+#define GL_SOURCE0_RGB				0x8580
+#define GL_SOURCE1_RGB				0x8581
+#define GL_SOURCE2_RGB				0x8582
+#define GL_SOURCE0_ALPHA			0x8588
+#define GL_SOURCE1_ALPHA			0x8589
+#define GL_SOURCE2_ALPHA			0x858A
+#define GL_OPERAND0_RGB				0x8590
+#define GL_OPERAND1_RGB				0x8591
+#define GL_OPERAND2_RGB				0x8592
+#define GL_OPERAND0_ALPHA			0x8598
+#define GL_OPERAND1_ALPHA			0x8599
+#define GL_OPERAND2_ALPHA			0x859A
+#define GL_RGB_SCALE				0x8573
+#define GL_ADD_SIGNED				0x8574
+#define GL_INTERPOLATE				0x8575
+#define GL_SUBTRACT				0x84E7
+#define GL_CONSTANT				0x8576
+#define GL_PRIMARY_COLOR			0x8577
+#define GL_PREVIOUS				0x8578
+/* texture_env_dot3 */
+#define GL_DOT3_RGB				0x86AE
+#define GL_DOT3_RGBA				0x86AF
+/* texture_border_clamp */
+#define GL_CLAMP_TO_BORDER			0x812D
 
 
-#define GL_CLIENT_PIXEL_STORE_BIT		0x00000001
-#define GL_CLIENT_VERTEX_ARRAY_BIT		0x00000002
-#define GL_ALL_CLIENT_ATTRIB_BITS 		0xFFFFFFFF
 
-
-
-
-
 #if defined(__BEOS__) || defined(__QUICKDRAW__)
 #pragma export on
 #endif
@@ -867,17 +972,13 @@
 
 GLAPI void GLAPIENTRY glClearIndex( GLfloat c );
 
-GLAPI void GLAPIENTRY glClearColor( GLclampf red,
-			  GLclampf green,
-			  GLclampf blue,
-			  GLclampf alpha );
+GLAPI void GLAPIENTRY glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
 
 GLAPI void GLAPIENTRY glClear( GLbitfield mask );
 
 GLAPI void GLAPIENTRY glIndexMask( GLuint mask );
 
-GLAPI void GLAPIENTRY glColorMask( GLboolean red, GLboolean green,
-			 GLboolean blue, GLboolean alpha );
+GLAPI void GLAPIENTRY glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
 
 GLAPI void GLAPIENTRY glAlphaFunc( GLenum func, GLclampf ref );
 
@@ -907,8 +1008,7 @@
 
 GLAPI void GLAPIENTRY glEdgeFlagv( const GLboolean *flag );
 
-GLAPI void GLAPIENTRY glScissor( GLint x, GLint y,
-                                   GLsizei width, GLsizei height);
+GLAPI void GLAPIENTRY glScissor( GLint x, GLint y, GLsizei width, GLsizei height);
 
 GLAPI void GLAPIENTRY glClipPlane( GLenum plane, const GLdouble *equation );
 
@@ -980,8 +1080,7 @@
  * Accumulation Buffer
  */
 
-GLAPI void GLAPIENTRY glClearAccum( GLfloat red, GLfloat green,
-                                      GLfloat blue, GLfloat alpha );
+GLAPI void GLAPIENTRY glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
 
 GLAPI void GLAPIENTRY glAccum( GLenum op, GLfloat value );
 
@@ -1269,7 +1368,7 @@
 
 GLAPI void GLAPIENTRY glEdgeFlagPointer( GLsizei stride, const GLvoid *ptr );
 
-GLAPI void GLAPIENTRY glGetPointerv( GLenum pname, void **params );
+GLAPI void GLAPIENTRY glGetPointerv( GLenum pname, GLvoid **params );
 
 GLAPI void GLAPIENTRY glArrayElement( GLint i );
 
@@ -1590,7 +1689,7 @@
 	GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
 
 GLAPI void GLAPIENTRY glTexImage3D( GLenum target, GLint level,
-                                      GLint internalFormat,
+                                      GLenum internalFormat,
                                       GLsizei width, GLsizei height,
                                       GLsizei depth, GLint border,
                                       GLenum format, GLenum type,
@@ -1722,6 +1821,105 @@
 
 
 
+/* 1.3 functions */
+
+GLAPI void GLAPIENTRY glActiveTexture( GLenum texture );
+
+GLAPI void GLAPIENTRY glClientActiveTexture( GLenum texture );
+
+GLAPI void GLAPIENTRY glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data );
+
+GLAPI void GLAPIENTRY glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data );
+
+GLAPI void GLAPIENTRY glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data );
+
+GLAPI void GLAPIENTRY glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data );
+
+GLAPI void GLAPIENTRY glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data );
+
+GLAPI void GLAPIENTRY glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data );
+
+GLAPI void GLAPIENTRY glGetCompressedTexImage( GLenum target, GLint lod, GLvoid *img );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1d( GLenum target, GLdouble s );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1dv( GLenum target, const GLdouble *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1f( GLenum target, GLfloat s );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1fv( GLenum target, const GLfloat *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1i( GLenum target, GLint s );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1iv( GLenum target, const GLint *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1s( GLenum target, GLshort s );
+
+GLAPI void GLAPIENTRY glMultiTexCoord1sv( GLenum target, const GLshort *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2dv( GLenum target, const GLdouble *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2fv( GLenum target, const GLfloat *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2i( GLenum target, GLint s, GLint t );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2iv( GLenum target, const GLint *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2s( GLenum target, GLshort s, GLshort t );
+
+GLAPI void GLAPIENTRY glMultiTexCoord2sv( GLenum target, const GLshort *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3dv( GLenum target, const GLdouble *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3fv( GLenum target, const GLfloat *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3iv( GLenum target, const GLint *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r );
+
+GLAPI void GLAPIENTRY glMultiTexCoord3sv( GLenum target, const GLshort *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4dv( GLenum target, const GLdouble *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4fv( GLenum target, const GLfloat *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4iv( GLenum target, const GLint *v );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+
+GLAPI void GLAPIENTRY glMultiTexCoord4sv( GLenum target, const GLshort *v );
+
+
+GLAPI void GLAPIENTRY glLoadTransposeMatrixd( const GLdouble m[16] );
+
+GLAPI void GLAPIENTRY glLoadTransposeMatrixf( const GLfloat m[16] );
+
+GLAPI void GLAPIENTRY glMultTransposeMatrixd( const GLdouble m[16] );
+
+GLAPI void GLAPIENTRY glMultTransposeMatrixf( const GLfloat m[16] );
+
+GLAPI void GLAPIENTRY glSampleCoverage( GLclampf value, GLboolean invert );
+
+
+#if defined(GL_GLEXT_LEGACY)
+
+
 /*
  * GL_ARB_multitexture (ARB extension 1 and OpenGL 1.2.1)
  */
@@ -1798,14 +1996,45 @@
 GLAPI void GLAPIENTRY glMultiTexCoord4ivARB(GLenum target, const GLint *v);
 GLAPI void GLAPIENTRY glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
 GLAPI void GLAPIENTRY glMultiTexCoord4svARB(GLenum target, const GLshort *v);
-
-#endif /* GL_ARB_multitexture */
 
+typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
 
+#endif /* GL_ARB_multitexture */
 
 
-#if defined(GL_GLEXT_LEGACY)
-
 
 /*
  * 1. GL_EXT_abgr
@@ -1970,7 +2199,7 @@
 
 GLAPI void GLAPIENTRY glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean *ptr );
 
-GLAPI void GLAPIENTRY glGetPointervEXT( GLenum pname, void **params );
+GLAPI void GLAPIENTRY glGetPointervEXT( GLenum pname, GLvoid **params );
 
 GLAPI void GLAPIENTRY glArrayElementEXT( GLint i );
 
@@ -2179,8 +2408,6 @@
 
 
 
-
-
 /*
  * 197. GL_MESA_window_pos
  */
@@ -2248,10 +2475,97 @@
 
 
 
+/*
+ * ???. GL_MESA_trace
+ * XXX this should go into glext.h at some point
+ */
+#ifndef GL_MESA_trace
+#define GL_MESA_trace 1
+
+#define GL_TRACE_ALL_BITS_MESA			0xFFFF
+#define GL_TRACE_OPERATIONS_BIT_MESA		0x0001
+#define GL_TRACE_PRIMITIVES_BIT_MESA		0x0002
+#define GL_TRACE_ARRAYS_BIT_MESA		0x0004
+#define GL_TRACE_TEXTURES_BIT_MESA		0x0008
+#define GL_TRACE_PIXELS_BIT_MESA		0x0010
+#define GL_TRACE_ERRORS_BIT_MESA		0x0020
+#define GL_TRACE_MASK_MESA			0x8755
+#define GL_TRACE_NAME_MESA			0x8756
+
+GLAPI void GLAPIENTRY glEnableTraceMESA( GLbitfield mask );
+GLAPI void GLAPIENTRY glDisableTraceMESA( GLbitfield mask );
+GLAPI void GLAPIENTRY glNewTraceMESA( GLbitfield mask, const GLubyte * traceName );
+GLAPI void GLAPIENTRY glEndTraceMESA( void );
+GLAPI void GLAPIENTRY glTraceAssertAttribMESA( GLbitfield attribMask );
+GLAPI void GLAPIENTRY glTraceCommentMESA( const GLubyte * comment );
+GLAPI void GLAPIENTRY glTraceTextureMESA( GLuint name, const GLubyte* comment );
+GLAPI void GLAPIENTRY glTraceListMESA( GLuint name, const GLubyte* comment );
+GLAPI void GLAPIENTRY glTracePointerMESA( GLvoid* pointer, const GLubyte* comment );
+GLAPI void GLAPIENTRY glTracePointerRangeMESA( const GLvoid* first, const GLvoid* last, const GLubyte* comment );
+
+#endif /* GL_MESA_trace */
+
+
+/*
+ * ???. GL_MESA_packed_depth_stencil
+ * XXX this will be in glext.h someday
+ */
+#ifndef GL_MESA_packed_depth_stencil
+#define GL_MESA_packed_depth_stencil 1
+
+#define GL_DEPTH_STENCIL_MESA			0x8750
+#define GL_UNSIGNED_INT_24_8_MESA		0x8751
+#define GL_UNSIGNED_INT_8_24_REV_MESA		0x8752
+#define GL_UNSIGNED_SHORT_15_1_MESA		0x8753
+#define GL_UNSIGNED_SHORT_1_15_REV_MESA		0x8754
+
+#endif /* GL_MESA_packed_depth_stencil */
+
+
+
+#ifndef GL_MESA_ycbcr_texture
+#define GL_MESA_ycbcr_texture 1
+
+#define GL_YCBCR_MESA				0x8757
+#define GL_UNSIGNED_SHORT_8_8_MESA		0x85BA /* same as Apple */
+#define GL_UNSIGNED_SHORT_8_8_REV_MESA		0x85BB /* same as Apple */
+
+#endif /* GL_MESA_texture_ycbcr */
+
+
+
+#ifndef GL_MESA_pack_invert
+#define GL_MESA_pack_invert 1
+
+#define GL_PACK_INVERT_MESA                     0x8758
+
+#endif /* GL_MESA_pack_invert */
+
+
+
+#ifndef GL_APPLE_client_storage
+#define GL_APPLE_client_storage 1
+
+#define GL_UNPACK_CLIENT_STORAGE_APPLE          0x85B2
+
+#endif /* GL_APPLE_client_storage */
+
+
+
+#ifndef GL_APPLE_ycbcr_422
+#define GL_APPLE_ycbcr_422 1
+
+#define GL_YCBCR_422_APPLE			0x85B9
+#define GL_UNSIGNED_SHORT_8_8_APPLE		0x85BA
+#define GL_UNSIGNED_SHORT_8_8_REV_APPLE		0x85BB
+
+#endif /* GL_APPLE_ycbcr_422 */
+
+
 /**********************************************************************
  * Begin system-specific stuff
  */
-#if defined(__BEOS__) || defined(__QUICKDRAW__)
+#if defined(PRAGMA_EXPORT_SUPPORTED)
 #pragma export off
 #endif
 
Index: xc/extras/Mesa/include/GL/glext.h
diff -u xc/extras/Mesa/include/GL/glext.h:1.7 xc/extras/Mesa/include/GL/glext.h:1.11
--- xc/extras/Mesa/include/GL/glext.h:1.7	Tue Mar 20 21:48:39 2001
+++ xc/extras/Mesa/include/GL/glext.h	Mon Sep  9 17:51:55 2002
@@ -13,21 +13,21 @@
 ** this file except in compliance with the License. You may obtain a copy
 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
-**
+** 
 ** http://oss.sgi.com/projects/FreeB
-**
+** 
 ** Note that, as provided in the License, the Software is distributed on an
 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
-**
+** 
 ** Original Code. The Original Code is: OpenGL Sample Implementation,
 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
-** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Inc. The Original Code is Copyright (c) 1991-2002 Silicon Graphics, Inc.
 ** Copyright in any portions created by third parties is as indicated
 ** elsewhere herein. All Rights Reserved.
-**
+** 
 ** Additional Notice Provisions: This software was created using the
 ** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
 ** not been independently verified as being compliant with the OpenGL(R)
@@ -42,13 +42,62 @@
 #ifndef APIENTRY
 #define APIENTRY
 #endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
 
 /*************************************************************/
 
 /* Header file version number, required by OpenGL ABI for Linux */
-#define GL_GLEXT_VERSION 7
+/* glext.h last updated 2002/08/21 */
+/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+#define GL_GLEXT_VERSION 17
 
 #ifndef GL_VERSION_1_2
+#define GL_UNSIGNED_BYTE_3_3_2            0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_INT_8_8_8_8           0x8035
+#define GL_UNSIGNED_INT_10_10_10_2        0x8036
+#define GL_RESCALE_NORMAL                 0x803A
+#define GL_TEXTURE_BINDING_3D             0x806A
+#define GL_PACK_SKIP_IMAGES               0x806B
+#define GL_PACK_IMAGE_HEIGHT              0x806C
+#define GL_UNPACK_SKIP_IMAGES             0x806D
+#define GL_UNPACK_IMAGE_HEIGHT            0x806E
+#define GL_TEXTURE_3D                     0x806F
+#define GL_PROXY_TEXTURE_3D               0x8070
+#define GL_TEXTURE_DEPTH                  0x8071
+#define GL_TEXTURE_WRAP_R                 0x8072
+#define GL_MAX_3D_TEXTURE_SIZE            0x8073
+#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#define GL_BGR                            0x80E0
+#define GL_BGRA                           0x80E1
+#define GL_MAX_ELEMENTS_VERTICES          0x80E8
+#define GL_MAX_ELEMENTS_INDICES           0x80E9
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_TEXTURE_MIN_LOD                0x813A
+#define GL_TEXTURE_MAX_LOD                0x813B
+#define GL_TEXTURE_BASE_LEVEL             0x813C
+#define GL_TEXTURE_MAX_LEVEL              0x813D
+#define GL_LIGHT_MODEL_COLOR_CONTROL      0x81F8
+#define GL_SINGLE_COLOR                   0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR        0x81FA
+#define GL_SMOOTH_POINT_SIZE_RANGE        0x0B12
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY  0x0B13
+#define GL_SMOOTH_LINE_WIDTH_RANGE        0x0B22
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY  0x0B23
+#define GL_ALIASED_POINT_SIZE_RANGE       0x846D
+#define GL_ALIASED_LINE_WIDTH_RANGE       0x846E
+#endif
+
+#ifndef GL_ARB_imaging
 #define GL_CONSTANT_COLOR                 0x8001
 #define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
 #define GL_CONSTANT_ALPHA                 0x8003
@@ -94,19 +143,6 @@
 #define GL_MINMAX_FORMAT                  0x802F
 #define GL_MINMAX_SINK                    0x8030
 #define GL_TABLE_TOO_LARGE                0x8031
-#define GL_UNSIGNED_BYTE_3_3_2            0x8032
-#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
-#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
-#define GL_UNSIGNED_INT_8_8_8_8           0x8035
-#define GL_UNSIGNED_INT_10_10_10_2        0x8036
-#define GL_RESCALE_NORMAL                 0x803A
-#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
-#define GL_UNSIGNED_SHORT_5_6_5           0x8363
-#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
-#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
-#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
-#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
-#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
 #define GL_COLOR_MATRIX                   0x80B1
 #define GL_COLOR_MATRIX_STACK_DEPTH       0x80B2
 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH   0x80B3
@@ -117,6 +153,7 @@
 #define GL_POST_COLOR_MATRIX_RED_BIAS     0x80B8
 #define GL_POST_COLOR_MATRIX_GREEN_BIAS   0x80B9
 #define GL_POST_COLOR_MATRIX_BLUE_BIAS    0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS   0x80BB
 #define GL_COLOR_TABLE                    0x80D0
 #define GL_POST_CONVOLUTION_COLOR_TABLE   0x80D1
 #define GL_POST_COLOR_MATRIX_COLOR_TABLE  0x80D2
@@ -133,11 +170,151 @@
 #define GL_COLOR_TABLE_ALPHA_SIZE         0x80DD
 #define GL_COLOR_TABLE_LUMINANCE_SIZE     0x80DE
 #define GL_COLOR_TABLE_INTENSITY_SIZE     0x80DF
-#define GL_CLAMP_TO_EDGE                  0x812F
-#define GL_TEXTURE_MIN_LOD                0x813A
-#define GL_TEXTURE_MAX_LOD                0x813B
-#define GL_TEXTURE_BASE_LEVEL             0x813C
-#define GL_TEXTURE_MAX_LEVEL              0x813D
+#define GL_CONSTANT_BORDER                0x8151
+#define GL_REPLICATE_BORDER               0x8153
+#define GL_CONVOLUTION_BORDER_COLOR       0x8154
+#endif
+
+#ifndef GL_VERSION_1_3
+#define GL_TEXTURE0                       0x84C0
+#define GL_TEXTURE1                       0x84C1
+#define GL_TEXTURE2                       0x84C2
+#define GL_TEXTURE3                       0x84C3
+#define GL_TEXTURE4                       0x84C4
+#define GL_TEXTURE5                       0x84C5
+#define GL_TEXTURE6                       0x84C6
+#define GL_TEXTURE7                       0x84C7
+#define GL_TEXTURE8                       0x84C8
+#define GL_TEXTURE9                       0x84C9
+#define GL_TEXTURE10                      0x84CA
+#define GL_TEXTURE11                      0x84CB
+#define GL_TEXTURE12                      0x84CC
+#define GL_TEXTURE13                      0x84CD
+#define GL_TEXTURE14                      0x84CE
+#define GL_TEXTURE15                      0x84CF
+#define GL_TEXTURE16                      0x84D0
+#define GL_TEXTURE17                      0x84D1
+#define GL_TEXTURE18                      0x84D2
+#define GL_TEXTURE19                      0x84D3
+#define GL_TEXTURE20                      0x84D4
+#define GL_TEXTURE21                      0x84D5
+#define GL_TEXTURE22                      0x84D6
+#define GL_TEXTURE23                      0x84D7
+#define GL_TEXTURE24                      0x84D8
+#define GL_TEXTURE25                      0x84D9
+#define GL_TEXTURE26                      0x84DA
+#define GL_TEXTURE27                      0x84DB
+#define GL_TEXTURE28                      0x84DC
+#define GL_TEXTURE29                      0x84DD
+#define GL_TEXTURE30                      0x84DE
+#define GL_TEXTURE31                      0x84DF
+#define GL_ACTIVE_TEXTURE                 0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE          0x84E1
+#define GL_MAX_TEXTURE_UNITS              0x84E2
+#define GL_TRANSPOSE_MODELVIEW_MATRIX     0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX    0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX       0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX         0x84E6
+#define GL_MULTISAMPLE                    0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE            0x809F
+#define GL_SAMPLE_COVERAGE                0x80A0
+#define GL_SAMPLE_BUFFERS                 0x80A8
+#define GL_SAMPLES                        0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE          0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT         0x80AB
+#define GL_MULTISAMPLE_BIT                0x20000000
+#define GL_NORMAL_MAP                     0x8511
+#define GL_REFLECTION_MAP                 0x8512
+#define GL_TEXTURE_CUBE_MAP               0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP       0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP         0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE      0x851C
+#define GL_COMPRESSED_ALPHA               0x84E9
+#define GL_COMPRESSED_LUMINANCE           0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA     0x84EB
+#define GL_COMPRESSED_INTENSITY           0x84EC
+#define GL_COMPRESSED_RGB                 0x84ED
+#define GL_COMPRESSED_RGBA                0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT       0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE  0x86A0
+#define GL_TEXTURE_COMPRESSED             0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS     0x86A3
+#define GL_CLAMP_TO_BORDER                0x812D
+#define GL_CLAMP_TO_BORDER_SGIS           0x812D
+#define GL_COMBINE                        0x8570
+#define GL_COMBINE_RGB                    0x8571
+#define GL_COMBINE_ALPHA                  0x8572
+#define GL_SOURCE0_RGB                    0x8580
+#define GL_SOURCE1_RGB                    0x8581
+#define GL_SOURCE2_RGB                    0x8582
+#define GL_SOURCE0_ALPHA                  0x8588
+#define GL_SOURCE1_ALPHA                  0x8589
+#define GL_SOURCE2_ALPHA                  0x858A
+#define GL_OPERAND0_RGB                   0x8590
+#define GL_OPERAND1_RGB                   0x8591
+#define GL_OPERAND2_RGB                   0x8592
+#define GL_OPERAND0_ALPHA                 0x8598
+#define GL_OPERAND1_ALPHA                 0x8599
+#define GL_OPERAND2_ALPHA                 0x859A
+#define GL_RGB_SCALE                      0x8573
+#define GL_ADD_SIGNED                     0x8574
+#define GL_INTERPOLATE                    0x8575
+#define GL_SUBTRACT                       0x84E7
+#define GL_CONSTANT                       0x8576
+#define GL_PRIMARY_COLOR                  0x8577
+#define GL_PREVIOUS                       0x8578
+#define GL_DOT3_RGB                       0x86AE
+#define GL_DOT3_RGBA                      0x86AF
+#endif
+
+#ifndef GL_VERSION_1_4
+#define GL_BLEND_DST_RGB                  0x80C8
+#define GL_BLEND_SRC_RGB                  0x80C9
+#define GL_BLEND_DST_ALPHA                0x80CA
+#define GL_BLEND_SRC_ALPHA                0x80CB
+#define GL_POINT_SIZE_MIN                 0x8126
+#define GL_POINT_SIZE_MAX                 0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE      0x8128
+#define GL_POINT_DISTANCE_ATTENUATION     0x8129
+#define GL_GENERATE_MIPMAP                0x8191
+#define GL_GENERATE_MIPMAP_HINT           0x8192
+#define GL_DEPTH_COMPONENT16              0x81A5
+#define GL_DEPTH_COMPONENT24              0x81A6
+#define GL_DEPTH_COMPONENT32              0x81A7
+#define GL_MIRRORED_REPEAT                0x8370
+#define GL_FOG_COORDINATE_SOURCE          0x8450
+#define GL_FOG_COORDINATE                 0x8451
+#define GL_FRAGMENT_DEPTH                 0x8452
+#define GL_CURRENT_FOG_COORDINATE         0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE      0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE    0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER   0x8456
+#define GL_FOG_COORDINATE_ARRAY           0x8457
+#define GL_COLOR_SUM                      0x8458
+#define GL_CURRENT_SECONDARY_COLOR        0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE     0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE     0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE   0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER  0x845D
+#define GL_SECONDARY_COLOR_ARRAY          0x845E
+#define GL_MAX_TEXTURE_LOD_BIAS           0x84FD
+#define GL_TEXTURE_FILTER_CONTROL         0x8500
+#define GL_TEXTURE_LOD_BIAS               0x8501
+#define GL_INCR_WRAP                      0x8507
+#define GL_DECR_WRAP                      0x8508
+#define GL_TEXTURE_DEPTH_SIZE             0x884A
+#define GL_DEPTH_TEXTURE_MODE             0x884B
+#define GL_TEXTURE_COMPARE_MODE           0x884C
+#define GL_TEXTURE_COMPARE_FUNC           0x884D
+#define GL_COMPARE_R_TO_TEXTURE           0x884E
 #endif
 
 #ifndef GL_ARB_multitexture
@@ -197,6 +374,9 @@
 #define GL_MULTISAMPLE_BIT_ARB            0x20000000
 #endif
 
+#ifndef GL_ARB_texture_env_add
+#endif
+
 #ifndef GL_ARB_texture_cube_map
 #define GL_NORMAL_MAP_ARB                 0x8511
 #define GL_REFLECTION_MAP_ARB             0x8512
@@ -226,6 +406,17 @@
 #define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
 #endif
 
+#ifndef GL_ARB_texture_border_clamp
+#define GL_CLAMP_TO_BORDER_ARB            0x812D
+#endif
+
+#ifndef GL_ARB_point_parameters
+#define GL_POINT_SIZE_MIN_ARB             0x8126
+#define GL_POINT_SIZE_MAX_ARB             0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_ARB  0x8128
+#define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129
+#endif
+
 #ifndef GL_ARB_vertex_blend
 #define GL_MAX_VERTEX_UNITS_ARB           0x86A4
 #define GL_ACTIVE_VERTEX_UNITS_ARB        0x86A5
@@ -271,6 +462,159 @@
 #define GL_MODELVIEW31_ARB                0x873F
 #endif
 
+#ifndef GL_ARB_matrix_palette
+#define GL_MATRIX_PALETTE_ARB             0x8840
+#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841
+#define GL_MAX_PALETTE_MATRICES_ARB       0x8842
+#define GL_CURRENT_PALETTE_MATRIX_ARB     0x8843
+#define GL_MATRIX_INDEX_ARRAY_ARB         0x8844
+#define GL_CURRENT_MATRIX_INDEX_ARB       0x8845
+#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB    0x8846
+#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB    0x8847
+#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB  0x8848
+#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849
+#endif
+
+#ifndef GL_ARB_texture_env_combine
+#define GL_COMBINE_ARB                    0x8570
+#define GL_COMBINE_RGB_ARB                0x8571
+#define GL_COMBINE_ALPHA_ARB              0x8572
+#define GL_SOURCE0_RGB_ARB                0x8580
+#define GL_SOURCE1_RGB_ARB                0x8581
+#define GL_SOURCE2_RGB_ARB                0x8582
+#define GL_SOURCE0_ALPHA_ARB              0x8588
+#define GL_SOURCE1_ALPHA_ARB              0x8589
+#define GL_SOURCE2_ALPHA_ARB              0x858A
+#define GL_OPERAND0_RGB_ARB               0x8590
+#define GL_OPERAND1_RGB_ARB               0x8591
+#define GL_OPERAND2_RGB_ARB               0x8592
+#define GL_OPERAND0_ALPHA_ARB             0x8598
+#define GL_OPERAND1_ALPHA_ARB             0x8599
+#define GL_OPERAND2_ALPHA_ARB             0x859A
+#define GL_RGB_SCALE_ARB                  0x8573
+#define GL_ADD_SIGNED_ARB                 0x8574
+#define GL_INTERPOLATE_ARB                0x8575
+#define GL_SUBTRACT_ARB                   0x84E7
+#define GL_CONSTANT_ARB                   0x8576
+#define GL_PRIMARY_COLOR_ARB              0x8577
+#define GL_PREVIOUS_ARB                   0x8578
+#endif
+
+#ifndef GL_ARB_texture_env_crossbar
+#endif
+
+#ifndef GL_ARB_texture_env_dot3
+#define GL_DOT3_RGB_ARB                   0x86AE
+#define GL_DOT3_RGBA_ARB                  0x86AF
+#endif
+
+#ifndef GL_ARB_texture_mirrored_repeat
+#define GL_MIRRORED_REPEAT_ARB            0x8370
+#endif
+
+#ifndef GL_ARB_depth_texture
+#define GL_DEPTH_COMPONENT16_ARB          0x81A5
+#define GL_DEPTH_COMPONENT24_ARB          0x81A6
+#define GL_DEPTH_COMPONENT32_ARB          0x81A7
+#define GL_TEXTURE_DEPTH_SIZE_ARB         0x884A
+#define GL_DEPTH_TEXTURE_MODE_ARB         0x884B
+#endif
+
+#ifndef GL_ARB_shadow
+#define GL_TEXTURE_COMPARE_MODE_ARB       0x884C
+#define GL_TEXTURE_COMPARE_FUNC_ARB       0x884D
+#define GL_COMPARE_R_TO_TEXTURE_ARB       0x884E
+#endif
+
+#ifndef GL_ARB_shadow_ambient
+#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF
+#endif
+
+#ifndef GL_ARB_window_pos
+#endif
+
+#ifndef GL_ARB_vertex_program
+#define GL_VERTEX_PROGRAM_ARB             0x8620
+#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB  0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB    0x8643
+#define GL_COLOR_SUM_ARB                  0x8458
+#define GL_PROGRAM_FORMAT_ASCII_ARB       0x8875
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB   0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB   0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A
+#define GL_CURRENT_VERTEX_ATTRIB_ARB      0x8626
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645
+#define GL_PROGRAM_LENGTH_ARB             0x8627
+#define GL_PROGRAM_FORMAT_ARB             0x8876
+#define GL_PROGRAM_BINDING_ARB            0x8677
+#define GL_PROGRAM_INSTRUCTIONS_ARB       0x88A0
+#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB   0x88A1
+#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2
+#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3
+#define GL_PROGRAM_TEMPORARIES_ARB        0x88A4
+#define GL_MAX_PROGRAM_TEMPORARIES_ARB    0x88A5
+#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6
+#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7
+#define GL_PROGRAM_PARAMETERS_ARB         0x88A8
+#define GL_MAX_PROGRAM_PARAMETERS_ARB     0x88A9
+#define GL_PROGRAM_NATIVE_PARAMETERS_ARB  0x88AA
+#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB
+#define GL_PROGRAM_ATTRIBS_ARB            0x88AC
+#define GL_MAX_PROGRAM_ATTRIBS_ARB        0x88AD
+#define GL_PROGRAM_NATIVE_ATTRIBS_ARB     0x88AE
+#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF
+#define GL_PROGRAM_ADDRESS_REGISTERS_ARB  0x88B0
+#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1
+#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2
+#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3
+#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4
+#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5
+#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6
+#define GL_PROGRAM_STRING_ARB             0x8628
+#define GL_PROGRAM_ERROR_POSITION_ARB     0x864B
+#define GL_CURRENT_MATRIX_ARB             0x8641
+#define GL_TRANSPOSE_CURRENT_MATRIX_ARB   0x88B7
+#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640
+#define GL_MAX_VERTEX_ATTRIBS_ARB         0x8869
+#define GL_MAX_PROGRAM_MATRICES_ARB       0x862F
+#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E
+#define GL_PROGRAM_ERROR_STRING_ARB       0x8874
+#define GL_MATRIX0_ARB                    0x88C0
+#define GL_MATRIX1_ARB                    0x88C1
+#define GL_MATRIX2_ARB                    0x88C2
+#define GL_MATRIX3_ARB                    0x88C3
+#define GL_MATRIX4_ARB                    0x88C4
+#define GL_MATRIX5_ARB                    0x88C5
+#define GL_MATRIX6_ARB                    0x88C6
+#define GL_MATRIX7_ARB                    0x88C7
+#define GL_MATRIX8_ARB                    0x88C8
+#define GL_MATRIX9_ARB                    0x88C9
+#define GL_MATRIX10_ARB                   0x88CA
+#define GL_MATRIX11_ARB                   0x88CB
+#define GL_MATRIX12_ARB                   0x88CC
+#define GL_MATRIX13_ARB                   0x88CD
+#define GL_MATRIX14_ARB                   0x88CE
+#define GL_MATRIX15_ARB                   0x88CF
+#define GL_MATRIX16_ARB                   0x88D0
+#define GL_MATRIX17_ARB                   0x88D1
+#define GL_MATRIX18_ARB                   0x88D2
+#define GL_MATRIX19_ARB                   0x88D3
+#define GL_MATRIX20_ARB                   0x88D4
+#define GL_MATRIX21_ARB                   0x88D5
+#define GL_MATRIX22_ARB                   0x88D6
+#define GL_MATRIX23_ARB                   0x88D7
+#define GL_MATRIX24_ARB                   0x88D8
+#define GL_MATRIX25_ARB                   0x88D9
+#define GL_MATRIX26_ARB                   0x88DA
+#define GL_MATRIX27_ARB                   0x88DB
+#define GL_MATRIX28_ARB                   0x88DC
+#define GL_MATRIX29_ARB                   0x88DD
+#define GL_MATRIX30_ARB                   0x88DE
+#define GL_MATRIX31_ARB                   0x88DF
+#endif
+
 #ifndef GL_EXT_abgr
 #define GL_ABGR_EXT                       0x8000
 #endif
@@ -336,23 +680,14 @@
 #endif
 
 #ifndef GL_EXT_texture3D
-#define GL_PACK_SKIP_IMAGES               0x806B
 #define GL_PACK_SKIP_IMAGES_EXT           0x806B
-#define GL_PACK_IMAGE_HEIGHT              0x806C
 #define GL_PACK_IMAGE_HEIGHT_EXT          0x806C
-#define GL_UNPACK_SKIP_IMAGES             0x806D
 #define GL_UNPACK_SKIP_IMAGES_EXT         0x806D
-#define GL_UNPACK_IMAGE_HEIGHT            0x806E
 #define GL_UNPACK_IMAGE_HEIGHT_EXT        0x806E
-#define GL_TEXTURE_3D                     0x806F
 #define GL_TEXTURE_3D_EXT                 0x806F
-#define GL_PROXY_TEXTURE_3D               0x8070
 #define GL_PROXY_TEXTURE_3D_EXT           0x8070
-#define GL_TEXTURE_DEPTH                  0x8071
 #define GL_TEXTURE_DEPTH_EXT              0x8071
-#define GL_TEXTURE_WRAP_R                 0x8072
 #define GL_TEXTURE_WRAP_R_EXT             0x8072
-#define GL_MAX_3D_TEXTURE_SIZE            0x8073
 #define GL_MAX_3D_TEXTURE_SIZE_EXT        0x8073
 #endif
 
@@ -610,10 +945,6 @@
 #define GL_CLAMP_TO_EDGE_SGIS             0x812F
 #endif
 
-#ifndef GL_SGIS_texture_border_clamp
-#define GL_CLAMP_TO_BORDER_SGIS           0x812D
-#endif
-
 #ifndef GL_EXT_blend_minmax
 #define GL_FUNC_ADD_EXT                   0x8006
 #define GL_MIN_EXT                        0x8007
@@ -683,14 +1014,17 @@
 #define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E
 #endif
 
-#ifndef GL_SGIS_point_parameters
+#ifndef GL_EXT_point_parameters
 #define GL_POINT_SIZE_MIN_EXT             0x8126
-#define GL_POINT_SIZE_MIN_SGIS            0x8126
 #define GL_POINT_SIZE_MAX_EXT             0x8127
-#define GL_POINT_SIZE_MAX_SGIS            0x8127
 #define GL_POINT_FADE_THRESHOLD_SIZE_EXT  0x8128
-#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
 #define GL_DISTANCE_ATTENUATION_EXT       0x8129
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_POINT_SIZE_MIN_SGIS            0x8126
+#define GL_POINT_SIZE_MAX_SGIS            0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
 #define GL_DISTANCE_ATTENUATION_SGIS      0x8129
 #endif
 
@@ -842,14 +1176,6 @@
 #define GL_COLOR_INDEX8_EXT               0x80E5
 #define GL_COLOR_INDEX12_EXT              0x80E6
 #define GL_COLOR_INDEX16_EXT              0x80E7
-#define GL_COLOR_TABLE_FORMAT_EXT         0x80D8
-#define GL_COLOR_TABLE_WIDTH_EXT          0x80D9
-#define GL_COLOR_TABLE_RED_SIZE_EXT       0x80DA
-#define GL_COLOR_TABLE_GREEN_SIZE_EXT     0x80DB
-#define GL_COLOR_TABLE_BLUE_SIZE_EXT      0x80DC
-#define GL_COLOR_TABLE_ALPHA_SIZE_EXT     0x80DD
-#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE
-#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
 #define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
 #endif
 
@@ -986,6 +1312,16 @@
 #define GL_ALPHA_MAX_SGIX                 0x8321
 #endif
 
+#ifndef GL_SGIX_impact_pixel_texture
+#define GL_PIXEL_TEX_GEN_Q_CEILING_SGIX   0x8184
+#define GL_PIXEL_TEX_GEN_Q_ROUND_SGIX     0x8185
+#define GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX     0x8186
+#define GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX 0x8187
+#define GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX 0x8188
+#define GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX    0x8189
+#define GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX    0x818A
+#endif
+
 #ifndef GL_EXT_bgra
 #define GL_BGR_EXT                        0x80E0
 #define GL_BGRA_EXT                       0x80E1
@@ -1114,35 +1450,15 @@
 #define GL_SOURCE0_RGB_EXT                0x8580
 #define GL_SOURCE1_RGB_EXT                0x8581
 #define GL_SOURCE2_RGB_EXT                0x8582
-#define GL_SOURCE3_RGB_EXT                0x8583
-#define GL_SOURCE4_RGB_EXT                0x8584
-#define GL_SOURCE5_RGB_EXT                0x8585
-#define GL_SOURCE6_RGB_EXT                0x8586
-#define GL_SOURCE7_RGB_EXT                0x8587
 #define GL_SOURCE0_ALPHA_EXT              0x8588
 #define GL_SOURCE1_ALPHA_EXT              0x8589
 #define GL_SOURCE2_ALPHA_EXT              0x858A
-#define GL_SOURCE3_ALPHA_EXT              0x858B
-#define GL_SOURCE4_ALPHA_EXT              0x858C
-#define GL_SOURCE5_ALPHA_EXT              0x858D
-#define GL_SOURCE6_ALPHA_EXT              0x858E
-#define GL_SOURCE7_ALPHA_EXT              0x858F
 #define GL_OPERAND0_RGB_EXT               0x8590
 #define GL_OPERAND1_RGB_EXT               0x8591
 #define GL_OPERAND2_RGB_EXT               0x8592
-#define GL_OPERAND3_RGB_EXT               0x8593
-#define GL_OPERAND4_RGB_EXT               0x8594
-#define GL_OPERAND5_RGB_EXT               0x8595
-#define GL_OPERAND6_RGB_EXT               0x8596
-#define GL_OPERAND7_RGB_EXT               0x8597
 #define GL_OPERAND0_ALPHA_EXT             0x8598
 #define GL_OPERAND1_ALPHA_EXT             0x8599
 #define GL_OPERAND2_ALPHA_EXT             0x859A
-#define GL_OPERAND3_ALPHA_EXT             0x859B
-#define GL_OPERAND4_ALPHA_EXT             0x859C
-#define GL_OPERAND5_ALPHA_EXT             0x859D
-#define GL_OPERAND6_ALPHA_EXT             0x859E
-#define GL_OPERAND7_ALPHA_EXT             0x859F
 #endif
 
 #ifndef GL_APPLE_specular_vector
@@ -1169,9 +1485,9 @@
 #endif
 
 #ifndef GL_SUN_triangle_list
-#define GL_RESTART_SUN                    0x01
-#define GL_REPLACE_MIDDLE_SUN             0x02
-#define GL_REPLACE_OLDEST_SUN             0x03
+#define GL_RESTART_SUN                    0x0001
+#define GL_REPLACE_MIDDLE_SUN             0x0002
+#define GL_REPLACE_OLDEST_SUN             0x0003
 #define GL_TRIANGLE_LIST_SUN              0x81D7
 #define GL_REPLACEMENT_CODE_SUN           0x81D8
 #define GL_REPLACEMENT_CODE_ARRAY_SUN     0x85C0
@@ -1267,7 +1583,7 @@
 #define GL_MODELVIEW0_STACK_DEPTH_EXT     GL_MODELVIEW_STACK_DEPTH
 #define GL_MODELVIEW1_STACK_DEPTH_EXT     0x8502
 #define GL_MODELVIEW0_MATRIX_EXT          GL_MODELVIEW_MATRIX
-#define GL_MODELVIEW_MATRIX1_EXT          0x8506
+#define GL_MODELVIEW1_MATRIX_EXT          0x8506
 #define GL_VERTEX_WEIGHTING_EXT           0x8509
 #define GL_MODELVIEW0_EXT                 GL_MODELVIEW
 #define GL_MODELVIEW1_EXT                 0x850A
@@ -1468,6 +1784,7 @@
 #define GL_SAMPLE_MASK_VALUE_EXT          0x80AA
 #define GL_SAMPLE_MASK_INVERT_EXT         0x80AB
 #define GL_SAMPLE_PATTERN_EXT             0x80AC
+#define GL_MULTISAMPLE_BIT_EXT            0x20000000
 #endif
 
 #ifndef GL_SGIX_vertex_preclip
@@ -1507,50 +1824,649 @@
 #define GL_DOT3_RGBA_EXT                  0x8741
 #endif
 
+#ifndef GL_ATI_texture_mirror_once
+#define GL_MIRROR_CLAMP_ATI               0x8742
+#define GL_MIRROR_CLAMP_TO_EDGE_ATI       0x8743
+#endif
+
+#ifndef GL_NV_fence
+#define GL_ALL_COMPLETED_NV               0x84F2
+#define GL_FENCE_STATUS_NV                0x84F3
+#define GL_FENCE_CONDITION_NV             0x84F4
+#endif
+
+#ifndef GL_IBM_texture_mirrored_repeat
+#define GL_MIRRORED_REPEAT_IBM            0x8370
+#endif
+
+#ifndef GL_NV_evaluators
+#define GL_EVAL_2D_NV                     0x86C0
+#define GL_EVAL_TRIANGULAR_2D_NV          0x86C1
+#define GL_MAP_TESSELLATION_NV            0x86C2
+#define GL_MAP_ATTRIB_U_ORDER_NV          0x86C3
+#define GL_MAP_ATTRIB_V_ORDER_NV          0x86C4
+#define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5
+#define GL_EVAL_VERTEX_ATTRIB0_NV         0x86C6
+#define GL_EVAL_VERTEX_ATTRIB1_NV         0x86C7
+#define GL_EVAL_VERTEX_ATTRIB2_NV         0x86C8
+#define GL_EVAL_VERTEX_ATTRIB3_NV         0x86C9
+#define GL_EVAL_VERTEX_ATTRIB4_NV         0x86CA
+#define GL_EVAL_VERTEX_ATTRIB5_NV         0x86CB
+#define GL_EVAL_VERTEX_ATTRIB6_NV         0x86CC
+#define GL_EVAL_VERTEX_ATTRIB7_NV         0x86CD
+#define GL_EVAL_VERTEX_ATTRIB8_NV         0x86CE
+#define GL_EVAL_VERTEX_ATTRIB9_NV         0x86CF
+#define GL_EVAL_VERTEX_ATTRIB10_NV        0x86D0
+#define GL_EVAL_VERTEX_ATTRIB11_NV        0x86D1
+#define GL_EVAL_VERTEX_ATTRIB12_NV        0x86D2
+#define GL_EVAL_VERTEX_ATTRIB13_NV        0x86D3
+#define GL_EVAL_VERTEX_ATTRIB14_NV        0x86D4
+#define GL_EVAL_VERTEX_ATTRIB15_NV        0x86D5
+#define GL_MAX_MAP_TESSELLATION_NV        0x86D6
+#define GL_MAX_RATIONAL_EVAL_ORDER_NV     0x86D7
+#endif
+
+#ifndef GL_NV_packed_depth_stencil
+#define GL_DEPTH_STENCIL_NV               0x84F9
+#define GL_UNSIGNED_INT_24_8_NV           0x84FA
+#endif
+
+#ifndef GL_NV_register_combiners2
+#define GL_PER_STAGE_CONSTANTS_NV         0x8535
+#endif
+
+#ifndef GL_NV_texture_compression_vtc
+#endif
+
+#ifndef GL_NV_texture_rectangle
+#define GL_TEXTURE_RECTANGLE_NV           0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE_NV   0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE_NV     0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV  0x84F8
+#endif
+
+#ifndef GL_NV_texture_shader
+#define GL_OFFSET_TEXTURE_RECTANGLE_NV    0x864C
+#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D
+#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E
+#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9
+#define GL_UNSIGNED_INT_S8_S8_8_8_NV      0x86DA
+#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV  0x86DB
+#define GL_DSDT_MAG_INTENSITY_NV          0x86DC
+#define GL_SHADER_CONSISTENT_NV           0x86DD
+#define GL_TEXTURE_SHADER_NV              0x86DE
+#define GL_SHADER_OPERATION_NV            0x86DF
+#define GL_CULL_MODES_NV                  0x86E0
+#define GL_OFFSET_TEXTURE_MATRIX_NV       0x86E1
+#define GL_OFFSET_TEXTURE_SCALE_NV        0x86E2
+#define GL_OFFSET_TEXTURE_BIAS_NV         0x86E3
+#define GL_OFFSET_TEXTURE_2D_MATRIX_NV    GL_OFFSET_TEXTURE_MATRIX_NV
+#define GL_OFFSET_TEXTURE_2D_SCALE_NV     GL_OFFSET_TEXTURE_SCALE_NV
+#define GL_OFFSET_TEXTURE_2D_BIAS_NV      GL_OFFSET_TEXTURE_BIAS_NV
+#define GL_PREVIOUS_TEXTURE_INPUT_NV      0x86E4
+#define GL_CONST_EYE_NV                   0x86E5
+#define GL_PASS_THROUGH_NV                0x86E6
+#define GL_CULL_FRAGMENT_NV               0x86E7
+#define GL_OFFSET_TEXTURE_2D_NV           0x86E8
+#define GL_DEPENDENT_AR_TEXTURE_2D_NV     0x86E9
+#define GL_DEPENDENT_GB_TEXTURE_2D_NV     0x86EA
+#define GL_DOT_PRODUCT_NV                 0x86EC
+#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV   0x86ED
+#define GL_DOT_PRODUCT_TEXTURE_2D_NV      0x86EE
+#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0
+#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1
+#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2
+#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3
+#define GL_HILO_NV                        0x86F4
+#define GL_DSDT_NV                        0x86F5
+#define GL_DSDT_MAG_NV                    0x86F6
+#define GL_DSDT_MAG_VIB_NV                0x86F7
+#define GL_HILO16_NV                      0x86F8
+#define GL_SIGNED_HILO_NV                 0x86F9
+#define GL_SIGNED_HILO16_NV               0x86FA
+#define GL_SIGNED_RGBA_NV                 0x86FB
+#define GL_SIGNED_RGBA8_NV                0x86FC
+#define GL_SIGNED_RGB_NV                  0x86FE
+#define GL_SIGNED_RGB8_NV                 0x86FF
+#define GL_SIGNED_LUMINANCE_NV            0x8701
+#define GL_SIGNED_LUMINANCE8_NV           0x8702
+#define GL_SIGNED_LUMINANCE_ALPHA_NV      0x8703
+#define GL_SIGNED_LUMINANCE8_ALPHA8_NV    0x8704
+#define GL_SIGNED_ALPHA_NV                0x8705
+#define GL_SIGNED_ALPHA8_NV               0x8706
+#define GL_SIGNED_INTENSITY_NV            0x8707
+#define GL_SIGNED_INTENSITY8_NV           0x8708
+#define GL_DSDT8_NV                       0x8709
+#define GL_DSDT8_MAG8_NV                  0x870A
+#define GL_DSDT8_MAG8_INTENSITY8_NV       0x870B
+#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV   0x870C
+#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D
+#define GL_HI_SCALE_NV                    0x870E
+#define GL_LO_SCALE_NV                    0x870F
+#define GL_DS_SCALE_NV                    0x8710
+#define GL_DT_SCALE_NV                    0x8711
+#define GL_MAGNITUDE_SCALE_NV             0x8712
+#define GL_VIBRANCE_SCALE_NV              0x8713
+#define GL_HI_BIAS_NV                     0x8714
+#define GL_LO_BIAS_NV                     0x8715
+#define GL_DS_BIAS_NV                     0x8716
+#define GL_DT_BIAS_NV                     0x8717
+#define GL_MAGNITUDE_BIAS_NV              0x8718
+#define GL_VIBRANCE_BIAS_NV               0x8719
+#define GL_TEXTURE_BORDER_VALUES_NV       0x871A
+#define GL_TEXTURE_HI_SIZE_NV             0x871B
+#define GL_TEXTURE_LO_SIZE_NV             0x871C
+#define GL_TEXTURE_DS_SIZE_NV             0x871D
+#define GL_TEXTURE_DT_SIZE_NV             0x871E
+#define GL_TEXTURE_MAG_SIZE_NV            0x871F
+#endif
+
+#ifndef GL_NV_texture_shader2
+#define GL_DOT_PRODUCT_TEXTURE_3D_NV      0x86EF
+#endif
+
+#ifndef GL_NV_vertex_array_range2
+#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533
+#endif
+
+#ifndef GL_NV_vertex_program
+#define GL_VERTEX_PROGRAM_NV              0x8620
+#define GL_VERTEX_STATE_PROGRAM_NV        0x8621
+#define GL_ATTRIB_ARRAY_SIZE_NV           0x8623
+#define GL_ATTRIB_ARRAY_STRIDE_NV         0x8624
+#define GL_ATTRIB_ARRAY_TYPE_NV           0x8625
+#define GL_CURRENT_ATTRIB_NV              0x8626
+#define GL_PROGRAM_LENGTH_NV              0x8627
+#define GL_PROGRAM_STRING_NV              0x8628
+#define GL_MODELVIEW_PROJECTION_NV        0x8629
+#define GL_IDENTITY_NV                    0x862A
+#define GL_INVERSE_NV                     0x862B
+#define GL_TRANSPOSE_NV                   0x862C
+#define GL_INVERSE_TRANSPOSE_NV           0x862D
+#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E
+#define GL_MAX_TRACK_MATRICES_NV          0x862F
+#define GL_MATRIX0_NV                     0x8630
+#define GL_MATRIX1_NV                     0x8631
+#define GL_MATRIX2_NV                     0x8632
+#define GL_MATRIX3_NV                     0x8633
+#define GL_MATRIX4_NV                     0x8634
+#define GL_MATRIX5_NV                     0x8635
+#define GL_MATRIX6_NV                     0x8636
+#define GL_MATRIX7_NV                     0x8637
+#define GL_CURRENT_MATRIX_STACK_DEPTH_NV  0x8640
+#define GL_CURRENT_MATRIX_NV              0x8641
+#define GL_VERTEX_PROGRAM_POINT_SIZE_NV   0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_NV     0x8643
+#define GL_PROGRAM_PARAMETER_NV           0x8644
+#define GL_ATTRIB_ARRAY_POINTER_NV        0x8645
+#define GL_PROGRAM_TARGET_NV              0x8646
+#define GL_PROGRAM_RESIDENT_NV            0x8647
+#define GL_TRACK_MATRIX_NV                0x8648
+#define GL_TRACK_MATRIX_TRANSFORM_NV      0x8649
+#define GL_VERTEX_PROGRAM_BINDING_NV      0x864A
+#define GL_PROGRAM_ERROR_POSITION_NV      0x864B
+#define GL_VERTEX_ATTRIB_ARRAY0_NV        0x8650
+#define GL_VERTEX_ATTRIB_ARRAY1_NV        0x8651
+#define GL_VERTEX_ATTRIB_ARRAY2_NV        0x8652
+#define GL_VERTEX_ATTRIB_ARRAY3_NV        0x8653
+#define GL_VERTEX_ATTRIB_ARRAY4_NV        0x8654
+#define GL_VERTEX_ATTRIB_ARRAY5_NV        0x8655
+#define GL_VERTEX_ATTRIB_ARRAY6_NV        0x8656
+#define GL_VERTEX_ATTRIB_ARRAY7_NV        0x8657
+#define GL_VERTEX_ATTRIB_ARRAY8_NV        0x8658
+#define GL_VERTEX_ATTRIB_ARRAY9_NV        0x8659
+#define GL_VERTEX_ATTRIB_ARRAY10_NV       0x865A
+#define GL_VERTEX_ATTRIB_ARRAY11_NV       0x865B
+#define GL_VERTEX_ATTRIB_ARRAY12_NV       0x865C
+#define GL_VERTEX_ATTRIB_ARRAY13_NV       0x865D
+#define GL_VERTEX_ATTRIB_ARRAY14_NV       0x865E
+#define GL_VERTEX_ATTRIB_ARRAY15_NV       0x865F
+#define GL_MAP1_VERTEX_ATTRIB0_4_NV       0x8660
+#define GL_MAP1_VERTEX_ATTRIB1_4_NV       0x8661
+#define GL_MAP1_VERTEX_ATTRIB2_4_NV       0x8662
+#define GL_MAP1_VERTEX_ATTRIB3_4_NV       0x8663
+#define GL_MAP1_VERTEX_ATTRIB4_4_NV       0x8664
+#define GL_MAP1_VERTEX_ATTRIB5_4_NV       0x8665
+#define GL_MAP1_VERTEX_ATTRIB6_4_NV       0x8666
+#define GL_MAP1_VERTEX_ATTRIB7_4_NV       0x8667
+#define GL_MAP1_VERTEX_ATTRIB8_4_NV       0x8668
+#define GL_MAP1_VERTEX_ATTRIB9_4_NV       0x8669
+#define GL_MAP1_VERTEX_ATTRIB10_4_NV      0x866A
+#define GL_MAP1_VERTEX_ATTRIB11_4_NV      0x866B
+#define GL_MAP1_VERTEX_ATTRIB12_4_NV      0x866C
+#define GL_MAP1_VERTEX_ATTRIB13_4_NV      0x866D
+#define GL_MAP1_VERTEX_ATTRIB14_4_NV      0x866E
+#define GL_MAP1_VERTEX_ATTRIB15_4_NV      0x866F
+#define GL_MAP2_VERTEX_ATTRIB0_4_NV       0x8670
+#define GL_MAP2_VERTEX_ATTRIB1_4_NV       0x8671
+#define GL_MAP2_VERTEX_ATTRIB2_4_NV       0x8672
+#define GL_MAP2_VERTEX_ATTRIB3_4_NV       0x8673
+#define GL_MAP2_VERTEX_ATTRIB4_4_NV       0x8674
+#define GL_MAP2_VERTEX_ATTRIB5_4_NV       0x8675
+#define GL_MAP2_VERTEX_ATTRIB6_4_NV       0x8676
+#define GL_MAP2_VERTEX_ATTRIB7_4_NV       0x8677
+#define GL_MAP2_VERTEX_ATTRIB8_4_NV       0x8678
+#define GL_MAP2_VERTEX_ATTRIB9_4_NV       0x8679
+#define GL_MAP2_VERTEX_ATTRIB10_4_NV      0x867A
+#define GL_MAP2_VERTEX_ATTRIB11_4_NV      0x867B
+#define GL_MAP2_VERTEX_ATTRIB12_4_NV      0x867C
+#define GL_MAP2_VERTEX_ATTRIB13_4_NV      0x867D
+#define GL_MAP2_VERTEX_ATTRIB14_4_NV      0x867E
+#define GL_MAP2_VERTEX_ATTRIB15_4_NV      0x867F
+#endif
+
+#ifndef GL_SGIX_texture_coordinate_clamp
+#define GL_TEXTURE_MAX_CLAMP_S_SGIX       0x8369
+#define GL_TEXTURE_MAX_CLAMP_T_SGIX       0x836A
+#define GL_TEXTURE_MAX_CLAMP_R_SGIX       0x836B
+#endif
+
+#ifndef GL_SGIX_scalebias_hint
+#define GL_SCALEBIAS_HINT_SGIX            0x8322
+#endif
+
+#ifndef GL_OML_interlace
+#define GL_INTERLACE_OML                  0x8980
+#define GL_INTERLACE_READ_OML             0x8981
+#endif
+
+#ifndef GL_OML_subsample
+#define GL_FORMAT_SUBSAMPLE_24_24_OML     0x8982
+#define GL_FORMAT_SUBSAMPLE_244_244_OML   0x8983
+#endif
+
+#ifndef GL_OML_resample
+#define GL_PACK_RESAMPLE_OML              0x8984
+#define GL_UNPACK_RESAMPLE_OML            0x8985
+#define GL_RESAMPLE_REPLICATE_OML         0x8986
+#define GL_RESAMPLE_ZERO_FILL_OML         0x8987
+#define GL_RESAMPLE_AVERAGE_OML           0x8988
+#define GL_RESAMPLE_DECIMATE_OML          0x8989
+#endif
+
+#ifndef GL_NV_copy_depth_to_color
+#define GL_DEPTH_STENCIL_TO_RGBA_NV       0x886E
+#define GL_DEPTH_STENCIL_TO_BGRA_NV       0x886F
+#endif
+
+#ifndef GL_ATI_envmap_bumpmap
+#define GL_BUMP_ROT_MATRIX_ATI            0x8775
+#define GL_BUMP_ROT_MATRIX_SIZE_ATI       0x8776
+#define GL_BUMP_NUM_TEX_UNITS_ATI         0x8777
+#define GL_BUMP_TEX_UNITS_ATI             0x8778
+#define GL_DUDV_ATI                       0x8779
+#define GL_DU8DV8_ATI                     0x877A
+#define GL_BUMP_ENVMAP_ATI                0x877B
+#define GL_BUMP_TARGET_ATI                0x877C
+#endif
+
+#ifndef GL_ATI_fragment_shader
+#define GL_FRAGMENT_SHADER_ATI            0x8920
+#define GL_REG_0_ATI                      0x8921
+#define GL_REG_1_ATI                      0x8922
+#define GL_REG_2_ATI                      0x8923
+#define GL_REG_3_ATI                      0x8924
+#define GL_REG_4_ATI                      0x8925
+#define GL_REG_5_ATI                      0x8926
+#define GL_REG_6_ATI                      0x8927
+#define GL_REG_7_ATI                      0x8928
+#define GL_REG_8_ATI                      0x8929
+#define GL_REG_9_ATI                      0x892A
+#define GL_REG_10_ATI                     0x892B
+#define GL_REG_11_ATI                     0x892C
+#define GL_REG_12_ATI                     0x892D
+#define GL_REG_13_ATI                     0x892E
+#define GL_REG_14_ATI                     0x892F
+#define GL_REG_15_ATI                     0x8930
+#define GL_REG_16_ATI                     0x8931
+#define GL_REG_17_ATI                     0x8932
+#define GL_REG_18_ATI                     0x8933
+#define GL_REG_19_ATI                     0x8934
+#define GL_REG_20_ATI                     0x8935
+#define GL_REG_21_ATI                     0x8936
+#define GL_REG_22_ATI                     0x8937
+#define GL_REG_23_ATI                     0x8938
+#define GL_REG_24_ATI                     0x8939
+#define GL_REG_25_ATI                     0x893A
+#define GL_REG_26_ATI                     0x893B
+#define GL_REG_27_ATI                     0x893C
+#define GL_REG_28_ATI                     0x893D
+#define GL_REG_29_ATI                     0x893E
+#define GL_REG_30_ATI                     0x893F
+#define GL_REG_31_ATI                     0x8940
+#define GL_CON_0_ATI                      0x8941
+#define GL_CON_1_ATI                      0x8942
+#define GL_CON_2_ATI                      0x8943
+#define GL_CON_3_ATI                      0x8944
+#define GL_CON_4_ATI                      0x8945
+#define GL_CON_5_ATI                      0x8946
+#define GL_CON_6_ATI                      0x8947
+#define GL_CON_7_ATI                      0x8948
+#define GL_CON_8_ATI                      0x8949
+#define GL_CON_9_ATI                      0x894A
+#define GL_CON_10_ATI                     0x894B
+#define GL_CON_11_ATI                     0x894C
+#define GL_CON_12_ATI                     0x894D
+#define GL_CON_13_ATI                     0x894E
+#define GL_CON_14_ATI                     0x894F
+#define GL_CON_15_ATI                     0x8950
+#define GL_CON_16_ATI                     0x8951
+#define GL_CON_17_ATI                     0x8952
+#define GL_CON_18_ATI                     0x8953
+#define GL_CON_19_ATI                     0x8954
+#define GL_CON_20_ATI                     0x8955
+#define GL_CON_21_ATI                     0x8956
+#define GL_CON_22_ATI                     0x8957
+#define GL_CON_23_ATI                     0x8958
+#define GL_CON_24_ATI                     0x8959
+#define GL_CON_25_ATI                     0x895A
+#define GL_CON_26_ATI                     0x895B
+#define GL_CON_27_ATI                     0x895C
+#define GL_CON_28_ATI                     0x895D
+#define GL_CON_29_ATI                     0x895E
+#define GL_CON_30_ATI                     0x895F
+#define GL_CON_31_ATI                     0x8960
+#define GL_MOV_ATI                        0x8961
+#define GL_ADD_ATI                        0x8963
+#define GL_MUL_ATI                        0x8964
+#define GL_SUB_ATI                        0x8965
+#define GL_DOT3_ATI                       0x8966
+#define GL_DOT4_ATI                       0x8967
+#define GL_MAD_ATI                        0x8968
+#define GL_LERP_ATI                       0x8969
+#define GL_CND_ATI                        0x896A
+#define GL_CND0_ATI                       0x896B
+#define GL_DOT2_ADD_ATI                   0x896C
+#define GL_SECONDARY_INTERPOLATOR_ATI     0x896D
+#define GL_NUM_FRAGMENT_REGISTERS_ATI     0x896E
+#define GL_NUM_FRAGMENT_CONSTANTS_ATI     0x896F
+#define GL_NUM_PASSES_ATI                 0x8970
+#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI  0x8971
+#define GL_NUM_INSTRUCTIONS_TOTAL_ATI     0x8972
+#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973
+#define GL_NUM_LOOPBACK_COMPONENTS_ATI    0x8974
+#define GL_COLOR_ALPHA_PAIRING_ATI        0x8975
+#define GL_SWIZZLE_STR_ATI                0x8976
+#define GL_SWIZZLE_STQ_ATI                0x8977
+#define GL_SWIZZLE_STR_DR_ATI             0x8978
+#define GL_SWIZZLE_STQ_DQ_ATI             0x8979
+#define GL_SWIZZLE_STRQ_ATI               0x897A
+#define GL_SWIZZLE_STRQ_DQ_ATI            0x897B
+#define GL_RED_BIT_ATI                    0x00000001
+#define GL_GREEN_BIT_ATI                  0x00000002
+#define GL_BLUE_BIT_ATI                   0x00000004
+#define GL_2X_BIT_ATI                     0x00000001
+#define GL_4X_BIT_ATI                     0x00000002
+#define GL_8X_BIT_ATI                     0x00000004
+#define GL_HALF_BIT_ATI                   0x00000008
+#define GL_QUARTER_BIT_ATI                0x00000010
+#define GL_EIGHTH_BIT_ATI                 0x00000020
+#define GL_SATURATE_BIT_ATI               0x00000040
+#define GL_COMP_BIT_ATI                   0x00000002
+#define GL_NEGATE_BIT_ATI                 0x00000004
+#define GL_BIAS_BIT_ATI                   0x00000008
+#endif
+
+#ifndef GL_ATI_pn_triangles
+#define GL_PN_TRIANGLES_ATI               0x87F0
+#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1
+#define GL_PN_TRIANGLES_POINT_MODE_ATI    0x87F2
+#define GL_PN_TRIANGLES_NORMAL_MODE_ATI   0x87F3
+#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4
+#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5
+#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6
+#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7
+#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8
+#endif
+
+#ifndef GL_ATI_vertex_array_object
+#define GL_STATIC_ATI                     0x8760
+#define GL_DYNAMIC_ATI                    0x8761
+#define GL_PRESERVE_ATI                   0x8762
+#define GL_DISCARD_ATI                    0x8763
+#define GL_OBJECT_BUFFER_SIZE_ATI         0x8764
+#define GL_OBJECT_BUFFER_USAGE_ATI        0x8765
+#define GL_ARRAY_OBJECT_BUFFER_ATI        0x8766
+#define GL_ARRAY_OBJECT_OFFSET_ATI        0x8767
+#endif
+
+#ifndef GL_EXT_vertex_shader
+#define GL_VERTEX_SHADER_EXT              0x8780
+#define GL_VERTEX_SHADER_BINDING_EXT      0x8781
+#define GL_OP_INDEX_EXT                   0x8782
+#define GL_OP_NEGATE_EXT                  0x8783
+#define GL_OP_DOT3_EXT                    0x8784
+#define GL_OP_DOT4_EXT                    0x8785
+#define GL_OP_MUL_EXT                     0x8786
+#define GL_OP_ADD_EXT                     0x8787
+#define GL_OP_MADD_EXT                    0x8788
+#define GL_OP_FRAC_EXT                    0x8789
+#define GL_OP_MAX_EXT                     0x878A
+#define GL_OP_MIN_EXT                     0x878B
+#define GL_OP_SET_GE_EXT                  0x878C
+#define GL_OP_SET_LT_EXT                  0x878D
+#define GL_OP_CLAMP_EXT                   0x878E
+#define GL_OP_FLOOR_EXT                   0x878F
+#define GL_OP_ROUND_EXT                   0x8790
+#define GL_OP_EXP_BASE_2_EXT              0x8791
+#define GL_OP_LOG_BASE_2_EXT              0x8792
+#define GL_OP_POWER_EXT                   0x8793
+#define GL_OP_RECIP_EXT                   0x8794
+#define GL_OP_RECIP_SQRT_EXT              0x8795
+#define GL_OP_SUB_EXT                     0x8796
+#define GL_OP_CROSS_PRODUCT_EXT           0x8797
+#define GL_OP_MULTIPLY_MATRIX_EXT         0x8798
+#define GL_OP_MOV_EXT                     0x8799
+#define GL_OUTPUT_VERTEX_EXT              0x879A
+#define GL_OUTPUT_COLOR0_EXT              0x879B
+#define GL_OUTPUT_COLOR1_EXT              0x879C
+#define GL_OUTPUT_TEXTURE_COORD0_EXT      0x879D
+#define GL_OUTPUT_TEXTURE_COORD1_EXT      0x879E
+#define GL_OUTPUT_TEXTURE_COORD2_EXT      0x879F
+#define GL_OUTPUT_TEXTURE_COORD3_EXT      0x87A0
+#define GL_OUTPUT_TEXTURE_COORD4_EXT      0x87A1
+#define GL_OUTPUT_TEXTURE_COORD5_EXT      0x87A2
+#define GL_OUTPUT_TEXTURE_COORD6_EXT      0x87A3
+#define GL_OUTPUT_TEXTURE_COORD7_EXT      0x87A4
+#define GL_OUTPUT_TEXTURE_COORD8_EXT      0x87A5
+#define GL_OUTPUT_TEXTURE_COORD9_EXT      0x87A6
+#define GL_OUTPUT_TEXTURE_COORD10_EXT     0x87A7
+#define GL_OUTPUT_TEXTURE_COORD11_EXT     0x87A8
+#define GL_OUTPUT_TEXTURE_COORD12_EXT     0x87A9
+#define GL_OUTPUT_TEXTURE_COORD13_EXT     0x87AA
+#define GL_OUTPUT_TEXTURE_COORD14_EXT     0x87AB
+#define GL_OUTPUT_TEXTURE_COORD15_EXT     0x87AC
+#define GL_OUTPUT_TEXTURE_COORD16_EXT     0x87AD
+#define GL_OUTPUT_TEXTURE_COORD17_EXT     0x87AE
+#define GL_OUTPUT_TEXTURE_COORD18_EXT     0x87AF
+#define GL_OUTPUT_TEXTURE_COORD19_EXT     0x87B0
+#define GL_OUTPUT_TEXTURE_COORD20_EXT     0x87B1
+#define GL_OUTPUT_TEXTURE_COORD21_EXT     0x87B2
+#define GL_OUTPUT_TEXTURE_COORD22_EXT     0x87B3
+#define GL_OUTPUT_TEXTURE_COORD23_EXT     0x87B4
+#define GL_OUTPUT_TEXTURE_COORD24_EXT     0x87B5
+#define GL_OUTPUT_TEXTURE_COORD25_EXT     0x87B6
+#define GL_OUTPUT_TEXTURE_COORD26_EXT     0x87B7
+#define GL_OUTPUT_TEXTURE_COORD27_EXT     0x87B8
+#define GL_OUTPUT_TEXTURE_COORD28_EXT     0x87B9
+#define GL_OUTPUT_TEXTURE_COORD29_EXT     0x87BA
+#define GL_OUTPUT_TEXTURE_COORD30_EXT     0x87BB
+#define GL_OUTPUT_TEXTURE_COORD31_EXT     0x87BC
+#define GL_OUTPUT_FOG_EXT                 0x87BD
+#define GL_SCALAR_EXT                     0x87BE
+#define GL_VECTOR_EXT                     0x87BF
+#define GL_MATRIX_EXT                     0x87C0
+#define GL_VARIANT_EXT                    0x87C1
+#define GL_INVARIANT_EXT                  0x87C2
+#define GL_LOCAL_CONSTANT_EXT             0x87C3
+#define GL_LOCAL_EXT                      0x87C4
+#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5
+#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6
+#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7
+#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8
+#define GL_MAX_VERTEX_SHADER_LOCALS_EXT   0x87C9
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CC
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INARIANTS_EXT 0x87CD
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE
+#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF
+#define GL_VERTEX_SHADER_VARIANTS_EXT     0x87D0
+#define GL_VERTEX_SHADER_INVARIANTS_EXT   0x87D1
+#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2
+#define GL_VERTEX_SHADER_LOCALS_EXT       0x87D3
+#define GL_VERTEX_SHADER_OPTIMIZED_EXT    0x87D4
+#define GL_X_EXT                          0x87D5
+#define GL_Y_EXT                          0x87D6
+#define GL_Z_EXT                          0x87D7
+#define GL_W_EXT                          0x87D8
+#define GL_NEGATIVE_X_EXT                 0x87D9
+#define GL_NEGATIVE_Y_EXT                 0x87DA
+#define GL_NEGATIVE_Z_EXT                 0x87DB
+#define GL_NEGATIVE_W_EXT                 0x87DC
+#define GL_ZERO_EXT                       0x87DD
+#define GL_ONE_EXT                        0x87DE
+#define GL_NEGATIVE_ONE_EXT               0x87DF
+#define GL_NORMALIZED_RANGE_EXT           0x87E0
+#define GL_FULL_RANGE_EXT                 0x87E1
+#define GL_CURRENT_VERTEX_EXT             0x87E2
+#define GL_MVP_MATRIX_EXT                 0x87E3
+#define GL_VARIANT_VALUE_EXT              0x87E4
+#define GL_VARIANT_DATATYPE_EXT           0x87E5
+#define GL_VARIANT_ARRAY_STRIDE_EXT       0x87E6
+#define GL_VARIANT_ARRAY_TYPE_EXT         0x87E7
+#define GL_VARIANT_ARRAY_EXT              0x87E8
+#define GL_VARIANT_ARRAY_POINTER_EXT      0x87E9
+#define GL_INVARIANT_VALUE_EXT            0x87EA
+#define GL_INVARIANT_DATATYPE_EXT         0x87EB
+#define GL_LOCAL_CONSTANT_VALUE_EXT       0x87EC
+#define GL_LOCAL_CONSTANT_DATATYPE_EXT    0x87ED
+#endif
+
+#ifndef GL_ATI_vertex_streams
+#define GL_MAX_VERTEX_STREAMS_ATI         0x876B
+#define GL_VERTEX_STREAM0_ATI             0x876C
+#define GL_VERTEX_STREAM1_ATI             0x876D
+#define GL_VERTEX_STREAM2_ATI             0x876E
+#define GL_VERTEX_STREAM3_ATI             0x876F
+#define GL_VERTEX_STREAM4_ATI             0x8770
+#define GL_VERTEX_STREAM5_ATI             0x8771
+#define GL_VERTEX_STREAM6_ATI             0x8772
+#define GL_VERTEX_STREAM7_ATI             0x8773
+#define GL_VERTEX_SOURCE_ATI              0x8774
+#endif
+
+#ifndef GL_ATI_element_array
+#define GL_ELEMENT_ARRAY_ATI              0x8768
+#define GL_ELEMENT_ARRAY_TYPE_ATI         0x8769
+#define GL_ELEMENT_ARRAY_POINTER_ATI      0x876A
+#endif
+
+#ifndef GL_SUN_mesh_array
+#define GL_QUAD_MESH_SUN                  0x8614
+#define GL_TRIANGLE_MESH_SUN              0x8615
+#endif
+
+#ifndef GL_SUN_slice_accum
+#define GL_SLICE_ACCUM_SUN                0x85CC
+#endif
+
+#ifndef GL_NV_multisample_filter_hint
+#define GL_MULTISAMPLE_FILTER_HINT_NV     0x8534
+#endif
+
+#ifndef GL_NV_depth_clamp
+#define GL_DEPTH_CLAMP_NV                 0x864F
+#endif
+
+#ifndef GL_NV_occlusion_query
+#define GL_PIXEL_COUNTER_BITS_NV          0x8864
+#define GL_CURRENT_OCCLUSION_QUERY_ID_NV  0x8865
+#define GL_PIXEL_COUNT_NV                 0x8866
+#define GL_PIXEL_COUNT_AVAILABLE_NV       0x8867
+#endif
+
+#ifndef GL_NV_point_sprite
+#define GL_POINT_SPRITE_NV                0x8861
+#define GL_COORD_REPLACE_NV               0x8862
+#define GL_POINT_SPRITE_R_MODE_NV         0x8863
+#endif
+
+#ifndef GL_NV_texture_shader3
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853
+#define GL_OFFSET_HILO_TEXTURE_2D_NV      0x8854
+#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857
+#define GL_DEPENDENT_HILO_TEXTURE_2D_NV   0x8858
+#define GL_DEPENDENT_RGB_TEXTURE_3D_NV    0x8859
+#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A
+#define GL_DOT_PRODUCT_PASS_THROUGH_NV    0x885B
+#define GL_DOT_PRODUCT_TEXTURE_1D_NV      0x885C
+#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D
+#define GL_HILO8_NV                       0x885E
+#define GL_SIGNED_HILO8_NV                0x885F
+#define GL_FORCE_BLUE_TO_ONE_NV           0x8860
+#endif
+
+#ifndef GL_NV_vertex_program1_1
+#endif
+
+#ifndef GL_EXT_shadow_funcs
+#endif
+
+#ifndef GL_EXT_stencil_two_side
+#define GL_STENCIL_TEST_TWO_SIDE_EXT      0x8910
+#define GL_ACTIVE_STENCIL_FACE_EXT        0x8911
+#endif
+
 
 /*************************************************************/
 
 #ifndef GL_VERSION_1_2
 #define GL_VERSION_1_2 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf);
-extern void APIENTRY glBlendEquation (GLenum);
-extern void APIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
-extern void APIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloat *);
-extern void APIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint *);
-extern void APIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei);
-extern void APIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *);
-extern void APIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei);
-extern void APIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat);
-extern void APIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLfloat *);
-extern void APIENTRY glConvolutionParameteri (GLenum, GLenum, GLint);
-extern void APIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint *);
-extern void APIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei);
-extern void APIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
-extern void APIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *);
-extern void APIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
-extern void APIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
-extern void APIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *);
-extern void APIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *);
-extern void APIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean);
-extern void APIENTRY glMinmax (GLenum, GLenum, GLboolean);
-extern void APIENTRY glResetHistogram (GLenum);
-extern void APIENTRY glResetMinmax (GLenum);
-extern void APIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+GLAPI void APIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf);
+GLAPI void APIENTRY glBlendEquation (GLenum);
+GLAPI void APIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+GLAPI void APIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei);
+GLAPI void APIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei);
+GLAPI void APIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat);
+GLAPI void APIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glConvolutionParameteri (GLenum, GLenum, GLint);
+GLAPI void APIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei);
+GLAPI void APIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+GLAPI void APIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+GLAPI void APIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+GLAPI void APIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean);
+GLAPI void APIENTRY glMinmax (GLenum, GLenum, GLboolean);
+GLAPI void APIENTRY glResetHistogram (GLenum);
+GLAPI void APIENTRY glResetMinmax (GLenum);
+GLAPI void APIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
 typedef void (APIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode);
@@ -1592,43 +2508,237 @@
 typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
 #endif
 
+#ifndef GL_VERSION_1_3
+#define GL_VERSION_1_3 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glActiveTexture (GLenum);
+GLAPI void APIENTRY glClientActiveTexture (GLenum);
+GLAPI void APIENTRY glMultiTexCoord1d (GLenum, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord1dv (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord1f (GLenum, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord1fv (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord1i (GLenum, GLint);
+GLAPI void APIENTRY glMultiTexCoord1iv (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord1s (GLenum, GLshort);
+GLAPI void APIENTRY glMultiTexCoord1sv (GLenum, const GLshort *);
+GLAPI void APIENTRY glMultiTexCoord2d (GLenum, GLdouble, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord2dv (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord2f (GLenum, GLfloat, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord2fv (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord2i (GLenum, GLint, GLint);
+GLAPI void APIENTRY glMultiTexCoord2iv (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord2s (GLenum, GLshort, GLshort);
+GLAPI void APIENTRY glMultiTexCoord2sv (GLenum, const GLshort *);
+GLAPI void APIENTRY glMultiTexCoord3d (GLenum, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord3dv (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord3f (GLenum, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord3fv (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord3i (GLenum, GLint, GLint, GLint);
+GLAPI void APIENTRY glMultiTexCoord3iv (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord3s (GLenum, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glMultiTexCoord3sv (GLenum, const GLshort *);
+GLAPI void APIENTRY glMultiTexCoord4d (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord4dv (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord4f (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord4fv (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord4i (GLenum, GLint, GLint, GLint, GLint);
+GLAPI void APIENTRY glMultiTexCoord4iv (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord4s (GLenum, GLshort, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glMultiTexCoord4sv (GLenum, const GLshort *);
+GLAPI void APIENTRY glLoadTransposeMatrixf (const GLfloat *);
+GLAPI void APIENTRY glLoadTransposeMatrixd (const GLdouble *);
+GLAPI void APIENTRY glMultTransposeMatrixf (const GLfloat *);
+GLAPI void APIENTRY glMultTransposeMatrixd (const GLdouble *);
+GLAPI void APIENTRY glSampleCoverage (GLclampf, GLboolean);
+GLAPI void APIENTRY glCompressedTexImage3D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexImage2D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexImage1D (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexSubImage2D (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexSubImage1D (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glGetCompressedTexImage (GLenum, GLint, void *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLACTIVETEXTUREPROC) (GLenum texture);
+typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m);
+typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m);
+typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m);
+typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m);
+typedef void (APIENTRY * PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, void *img);
+#endif
+
+#ifndef GL_VERSION_1_4
+#define GL_VERSION_1_4 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncSeparate (GLenum, GLenum, GLenum, GLenum);
+GLAPI void APIENTRY glFogCoordf (GLfloat);
+GLAPI void APIENTRY glFogCoordfv (const GLfloat *);
+GLAPI void APIENTRY glFogCoordd (GLdouble);
+GLAPI void APIENTRY glFogCoorddv (const GLdouble *);
+GLAPI void APIENTRY glFogCoordPointer (GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glMultiDrawArrays (GLenum, GLint *, GLsizei *, GLsizei);
+GLAPI void APIENTRY glMultiDrawElements (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei);
+GLAPI void APIENTRY glPointParameterf (GLenum, GLfloat);
+GLAPI void APIENTRY glPointParameterfv (GLenum, const GLfloat *);
+GLAPI void APIENTRY glPointParameteri (GLenum, GLint);
+GLAPI void APIENTRY glPointParameteriv (GLenum, const GLint *);
+GLAPI void APIENTRY glSecondaryColor3b (GLbyte, GLbyte, GLbyte);
+GLAPI void APIENTRY glSecondaryColor3bv (const GLbyte *);
+GLAPI void APIENTRY glSecondaryColor3d (GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glSecondaryColor3dv (const GLdouble *);
+GLAPI void APIENTRY glSecondaryColor3f (GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glSecondaryColor3fv (const GLfloat *);
+GLAPI void APIENTRY glSecondaryColor3i (GLint, GLint, GLint);
+GLAPI void APIENTRY glSecondaryColor3iv (const GLint *);
+GLAPI void APIENTRY glSecondaryColor3s (GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glSecondaryColor3sv (const GLshort *);
+GLAPI void APIENTRY glSecondaryColor3ub (GLubyte, GLubyte, GLubyte);
+GLAPI void APIENTRY glSecondaryColor3ubv (const GLubyte *);
+GLAPI void APIENTRY glSecondaryColor3ui (GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glSecondaryColor3uiv (const GLuint *);
+GLAPI void APIENTRY glSecondaryColor3us (GLushort, GLushort, GLushort);
+GLAPI void APIENTRY glSecondaryColor3usv (const GLushort *);
+GLAPI void APIENTRY glSecondaryColorPointer (GLint, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glWindowPos2d (GLdouble, GLdouble);
+GLAPI void APIENTRY glWindowPos2dv (const GLdouble *);
+GLAPI void APIENTRY glWindowPos2f (GLfloat, GLfloat);
+GLAPI void APIENTRY glWindowPos2fv (const GLfloat *);
+GLAPI void APIENTRY glWindowPos2i (GLint, GLint);
+GLAPI void APIENTRY glWindowPos2iv (const GLint *);
+GLAPI void APIENTRY glWindowPos2s (GLshort, GLshort);
+GLAPI void APIENTRY glWindowPos2sv (const GLshort *);
+GLAPI void APIENTRY glWindowPos3d (GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glWindowPos3dv (const GLdouble *);
+GLAPI void APIENTRY glWindowPos3f (GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glWindowPos3fv (const GLfloat *);
+GLAPI void APIENTRY glWindowPos3i (GLint, GLint, GLint);
+GLAPI void APIENTRY glWindowPos3iv (const GLint *);
+GLAPI void APIENTRY glWindowPos3s (GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glWindowPos3sv (const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (APIENTRY * PFNGLFOGCOORDFPROC) (GLfloat coord);
+typedef void (APIENTRY * PFNGLFOGCOORDFVPROC) (const GLfloat *coord);
+typedef void (APIENTRY * PFNGLFOGCOORDDPROC) (GLdouble coord);
+typedef void (APIENTRY * PFNGLFOGCOORDDVPROC) (const GLdouble *coord);
+typedef void (APIENTRY * PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2DVPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FVPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IPROC) (GLint x, GLint y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IVPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SVPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DVPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FVPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IVPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SVPROC) (const GLshort *v);
+#endif
+
 #ifndef GL_ARB_multitexture
 #define GL_ARB_multitexture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glActiveTextureARB (GLenum);
-extern void APIENTRY glClientActiveTextureARB (GLenum);
-extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
-extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
-extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
-extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
-extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
-extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
-extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
-extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
-extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
-extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
-extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
-extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
-extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
-extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
-extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
-extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
-extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
-extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
-extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
-extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
-extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
-extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
-extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
-extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
-extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
-extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
-extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
-extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
-extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
-extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
+GLAPI void APIENTRY glActiveTextureARB (GLenum);
+GLAPI void APIENTRY glClientActiveTextureARB (GLenum);
+GLAPI void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
+GLAPI void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
+GLAPI void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
+GLAPI void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
+GLAPI void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
+GLAPI void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
+GLAPI void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
+GLAPI void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
+GLAPI void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
+GLAPI void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
+GLAPI void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
+GLAPI void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
+GLAPI void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
 typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
@@ -1669,10 +2779,10 @@
 #ifndef GL_ARB_transpose_matrix
 #define GL_ARB_transpose_matrix 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *);
-extern void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *);
-extern void APIENTRY glMultTransposeMatrixfARB (const GLfloat *);
-extern void APIENTRY glMultTransposeMatrixdARB (const GLdouble *);
+GLAPI void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *);
+GLAPI void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *);
+GLAPI void APIENTRY glMultTransposeMatrixfARB (const GLfloat *);
+GLAPI void APIENTRY glMultTransposeMatrixdARB (const GLdouble *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat *m);
 typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble *m);
@@ -1683,11 +2793,9 @@
 #ifndef GL_ARB_multisample
 #define GL_ARB_multisample 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glSampleCoverageARB (GLclampf, GLboolean);
-extern void APIENTRY glSamplePassARB (GLenum);
+GLAPI void APIENTRY glSampleCoverageARB (GLclampf, GLboolean);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert);
-typedef void (APIENTRY * PFNGLSAMPLEPASSARBPROC) (GLenum pass);
 #endif
 
 #ifndef GL_ARB_texture_env_add
@@ -1701,13 +2809,13 @@
 #ifndef GL_ARB_texture_compression
 #define GL_ARB_texture_compression 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
-extern void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
-extern void APIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *);
-extern void APIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
-extern void APIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
-extern void APIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *);
-extern void APIENTRY glGetCompressedTexImageARB (GLenum, GLint, void *);
+GLAPI void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glGetCompressedTexImageARB (GLenum, GLint, void *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
 typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
@@ -1718,6 +2826,258 @@
 typedef void (APIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint level, void *img);
 #endif
 
+#ifndef GL_ARB_texture_border_clamp
+#define GL_ARB_texture_border_clamp 1
+#endif
+
+#ifndef GL_ARB_point_parameters
+#define GL_ARB_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPointParameterfARB (GLenum, GLfloat);
+GLAPI void APIENTRY glPointParameterfvARB (GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_ARB_vertex_blend
+#define GL_ARB_vertex_blend 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glWeightbvARB (GLint, const GLbyte *);
+GLAPI void APIENTRY glWeightsvARB (GLint, const GLshort *);
+GLAPI void APIENTRY glWeightivARB (GLint, const GLint *);
+GLAPI void APIENTRY glWeightfvARB (GLint, const GLfloat *);
+GLAPI void APIENTRY glWeightdvARB (GLint, const GLdouble *);
+GLAPI void APIENTRY glWeightubvARB (GLint, const GLubyte *);
+GLAPI void APIENTRY glWeightusvARB (GLint, const GLushort *);
+GLAPI void APIENTRY glWeightuivARB (GLint, const GLuint *);
+GLAPI void APIENTRY glWeightPointerARB (GLint, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glVertexBlendARB (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLWEIGHTBVARBPROC) (GLint size, const GLbyte *weights);
+typedef void (APIENTRY * PFNGLWEIGHTSVARBPROC) (GLint size, const GLshort *weights);
+typedef void (APIENTRY * PFNGLWEIGHTIVARBPROC) (GLint size, const GLint *weights);
+typedef void (APIENTRY * PFNGLWEIGHTFVARBPROC) (GLint size, const GLfloat *weights);
+typedef void (APIENTRY * PFNGLWEIGHTDVARBPROC) (GLint size, const GLdouble *weights);
+typedef void (APIENTRY * PFNGLWEIGHTUBVARBPROC) (GLint size, const GLubyte *weights);
+typedef void (APIENTRY * PFNGLWEIGHTUSVARBPROC) (GLint size, const GLushort *weights);
+typedef void (APIENTRY * PFNGLWEIGHTUIVARBPROC) (GLint size, const GLuint *weights);
+typedef void (APIENTRY * PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLVERTEXBLENDARBPROC) (GLint count);
+#endif
+
+#ifndef GL_ARB_matrix_palette
+#define GL_ARB_matrix_palette 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCurrentPaletteMatrixARB (GLint);
+GLAPI void APIENTRY glMatrixIndexubvARB (GLint, const GLubyte *);
+GLAPI void APIENTRY glMatrixIndexusvARB (GLint, const GLushort *);
+GLAPI void APIENTRY glMatrixIndexuivARB (GLint, const GLuint *);
+GLAPI void APIENTRY glMatrixIndexPointerARB (GLint, GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index);
+typedef void (APIENTRY * PFNGLMATRIXINDEXUBVARBPROC) (GLint size, const GLubyte *indices);
+typedef void (APIENTRY * PFNGLMATRIXINDEXUSVARBPROC) (GLint size, const GLushort *indices);
+typedef void (APIENTRY * PFNGLMATRIXINDEXUIVARBPROC) (GLint size, const GLuint *indices);
+typedef void (APIENTRY * PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_ARB_texture_env_combine
+#define GL_ARB_texture_env_combine 1
+#endif
+
+#ifndef GL_ARB_texture_env_crossbar
+#define GL_ARB_texture_env_crossbar 1
+#endif
+
+#ifndef GL_ARB_texture_env_dot3
+#define GL_ARB_texture_env_dot3 1
+#endif
+
+#ifndef GL_ARB_texture_mirror_repeat
+#define GL_ARB_texture_mirror_repeat 1
+#endif
+
+#ifndef GL_ARB_depth_texture
+#define GL_ARB_depth_texture 1
+#endif
+
+#ifndef GL_ARB_shadow
+#define GL_ARB_shadow 1
+#endif
+
+#ifndef GL_ARB_shadow_ambient
+#define GL_ARB_shadow_ambient 1
+#endif
+
+#ifndef GL_ARB_window_pos
+#define GL_ARB_window_pos 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glWindowPos2dARB (GLdouble, GLdouble);
+GLAPI void APIENTRY glWindowPos2dvARB (const GLdouble *);
+GLAPI void APIENTRY glWindowPos2fARB (GLfloat, GLfloat);
+GLAPI void APIENTRY glWindowPos2fvARB (const GLfloat *);
+GLAPI void APIENTRY glWindowPos2iARB (GLint, GLint);
+GLAPI void APIENTRY glWindowPos2ivARB (const GLint *);
+GLAPI void APIENTRY glWindowPos2sARB (GLshort, GLshort);
+GLAPI void APIENTRY glWindowPos2svARB (const GLshort *);
+GLAPI void APIENTRY glWindowPos3dARB (GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glWindowPos3dvARB (const GLdouble *);
+GLAPI void APIENTRY glWindowPos3fARB (GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glWindowPos3fvARB (const GLfloat *);
+GLAPI void APIENTRY glWindowPos3iARB (GLint, GLint, GLint);
+GLAPI void APIENTRY glWindowPos3ivARB (const GLint *);
+GLAPI void APIENTRY glWindowPos3sARB (GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glWindowPos3svARB (const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2DVARBPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FVARBPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IVARBPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SVARBPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DVARBPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FVARBPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IVARBPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SVARBPROC) (const GLshort *v);
+#endif
+
+#ifndef GL_ARB_vertex_program
+#define GL_ARB_vertex_program 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexAttrib1dARB (GLuint, GLdouble);
+GLAPI void APIENTRY glVertexAttrib1dvARB (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib1fARB (GLuint, GLfloat);
+GLAPI void APIENTRY glVertexAttrib1fvARB (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib1sARB (GLuint, GLshort);
+GLAPI void APIENTRY glVertexAttrib1svARB (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib2dARB (GLuint, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexAttrib2dvARB (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib2fARB (GLuint, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexAttrib2fvARB (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib2sARB (GLuint, GLshort, GLshort);
+GLAPI void APIENTRY glVertexAttrib2svARB (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib3dARB (GLuint, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexAttrib3dvARB (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib3fARB (GLuint, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexAttrib3fvARB (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib3sARB (GLuint, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glVertexAttrib3svARB (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib4NbvARB (GLuint, const GLbyte *);
+GLAPI void APIENTRY glVertexAttrib4NivARB (GLuint, const GLint *);
+GLAPI void APIENTRY glVertexAttrib4NsvARB (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib4NubARB (GLuint, GLubyte, GLubyte, GLubyte, GLubyte);
+GLAPI void APIENTRY glVertexAttrib4NubvARB (GLuint, const GLubyte *);
+GLAPI void APIENTRY glVertexAttrib4NuivARB (GLuint, const GLuint *);
+GLAPI void APIENTRY glVertexAttrib4NusvARB (GLuint, const GLushort *);
+GLAPI void APIENTRY glVertexAttrib4bvARB (GLuint, const GLbyte *);
+GLAPI void APIENTRY glVertexAttrib4dARB (GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexAttrib4dvARB (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib4fARB (GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexAttrib4fvARB (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib4ivARB (GLuint, const GLint *);
+GLAPI void APIENTRY glVertexAttrib4sARB (GLuint, GLshort, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glVertexAttrib4svARB (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib4ubvARB (GLuint, const GLubyte *);
+GLAPI void APIENTRY glVertexAttrib4uivARB (GLuint, const GLuint *);
+GLAPI void APIENTRY glVertexAttrib4usvARB (GLuint, const GLushort *);
+GLAPI void APIENTRY glVertexAttribPointerARB (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glEnableVertexAttribArrayARB (GLuint);
+GLAPI void APIENTRY glDisableVertexAttribArrayARB (GLuint);
+GLAPI void APIENTRY glProgramStringARB (GLenum, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glBindProgramARB (GLenum, GLuint);
+GLAPI void APIENTRY glDeleteProgramsARB (GLsizei, const GLuint *);
+GLAPI void APIENTRY glGenProgramsARB (GLsizei, GLuint *);
+GLAPI void APIENTRY glProgramEnvParameter4dARB (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glProgramEnvParameter4dvARB (GLenum, GLuint, const GLdouble *);
+GLAPI void APIENTRY glProgramEnvParameter4fARB (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glProgramEnvParameter4fvARB (GLenum, GLuint, const GLfloat *);
+GLAPI void APIENTRY glProgramLocalParameter4dARB (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glProgramLocalParameter4dvARB (GLenum, GLuint, const GLdouble *);
+GLAPI void APIENTRY glProgramLocalParameter4fARB (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glProgramLocalParameter4fvARB (GLenum, GLuint, const GLfloat *);
+GLAPI void APIENTRY glGetProgramEnvParameterdvARB (GLenum, GLuint, GLdouble *);
+GLAPI void APIENTRY glGetProgramEnvParameterfvARB (GLenum, GLuint, GLfloat *);
+GLAPI void APIENTRY glGetProgramLocalParameterdvARB (GLenum, GLuint, GLdouble *);
+GLAPI void APIENTRY glGetProgramLocalParameterfvARB (GLenum, GLuint, GLfloat *);
+GLAPI void APIENTRY glGetProgramivARB (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetProgramStringARB (GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetVertexAttribdvARB (GLuint, GLenum, GLdouble *);
+GLAPI void APIENTRY glGetVertexAttribfvARB (GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetVertexAttribivARB (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetVertexAttribPointervARB (GLuint, GLenum, GLvoid* *);
+GLAPI GLboolean APIENTRY glIsProgramARB (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index);
+typedef void (APIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index);
+typedef void (APIENTRY * PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string);
+typedef void (APIENTRY * PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program);
+typedef void (APIENTRY * PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRY * PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid* *pointer);
+typedef GLboolean (APIENTRY * PFNGLISPROGRAMARBPROC) (GLuint program);
+#endif
+
 #ifndef GL_EXT_abgr
 #define GL_EXT_abgr 1
 #endif
@@ -1725,7 +3085,7 @@
 #ifndef GL_EXT_blend_color
 #define GL_EXT_blend_color 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf);
+GLAPI void APIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
 #endif
@@ -1733,7 +3093,7 @@
 #ifndef GL_EXT_polygon_offset
 #define GL_EXT_polygon_offset 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glPolygonOffsetEXT (GLfloat, GLfloat);
+GLAPI void APIENTRY glPolygonOffsetEXT (GLfloat, GLfloat);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias);
 #endif
@@ -1745,8 +3105,8 @@
 #ifndef GL_EXT_texture3D
 #define GL_EXT_texture3D 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
 typedef void (APIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
@@ -1755,8 +3115,8 @@
 #ifndef GL_SGIS_texture_filter4
 #define GL_SGIS_texture_filter4 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *);
+GLAPI void APIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat *weights);
 typedef void (APIENTRY * PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights);
@@ -1765,8 +3125,8 @@
 #ifndef GL_EXT_subtexture
 #define GL_EXT_subtexture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
 typedef void (APIENTRY * PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
@@ -1775,11 +3135,11 @@
 #ifndef GL_EXT_copy_texture
 #define GL_EXT_copy_texture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint);
-extern void APIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
-extern void APIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei);
-extern void APIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
-extern void APIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+GLAPI void APIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint);
+GLAPI void APIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
+GLAPI void APIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei);
+GLAPI void APIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+GLAPI void APIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
 typedef void (APIENTRY * PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
@@ -1791,16 +3151,16 @@
 #ifndef GL_EXT_histogram
 #define GL_EXT_histogram 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *);
-extern void APIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);
-extern void APIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);
-extern void APIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean);
-extern void APIENTRY glResetHistogramEXT (GLenum);
-extern void APIENTRY glResetMinmaxEXT (GLenum);
+GLAPI void APIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);
+GLAPI void APIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean);
+GLAPI void APIENTRY glResetHistogramEXT (GLenum);
+GLAPI void APIENTRY glResetMinmaxEXT (GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
 typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
@@ -1817,19 +3177,19 @@
 #ifndef GL_EXT_convolution
 #define GL_EXT_convolution 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);
-extern void APIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *);
-extern void APIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint);
-extern void APIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GLint *);
-extern void APIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei);
-extern void APIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
-extern void APIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *);
-extern void APIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
-extern void APIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+GLAPI void APIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);
+GLAPI void APIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint);
+GLAPI void APIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei);
+GLAPI void APIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+GLAPI void APIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+GLAPI void APIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
 typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
@@ -1853,13 +3213,13 @@
 #ifndef GL_SGI_color_table
 #define GL_SGI_color_table 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *);
-extern void APIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLint *);
-extern void APIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei);
-extern void APIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei);
+GLAPI void APIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
 typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params);
@@ -1873,7 +3233,7 @@
 #ifndef GL_SGIX_pixel_texture
 #define GL_SGIX_pixel_texture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glPixelTexGenSGIX (GLenum);
+GLAPI void APIENTRY glPixelTexGenSGIX (GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode);
 #endif
@@ -1881,12 +3241,12 @@
 #ifndef GL_SGIS_pixel_texture
 #define GL_SGIS_pixel_texture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint);
-extern void APIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *);
-extern void APIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat);
-extern void APIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *);
-extern void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *);
-extern void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);
+GLAPI void APIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint);
+GLAPI void APIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *);
+GLAPI void APIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat);
+GLAPI void APIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *);
+GLAPI void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *);
+GLAPI void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname, GLint param);
 typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, const GLint *params);
@@ -1899,8 +3259,8 @@
 #ifndef GL_SGIS_texture4D
 #define GL_SGIS_texture4D 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
 typedef void (APIENTRY * PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels);
@@ -1917,12 +3277,12 @@
 #ifndef GL_EXT_texture_object
 #define GL_EXT_texture_object 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *);
-extern void APIENTRY glBindTextureEXT (GLenum, GLuint);
-extern void APIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *);
-extern void APIENTRY glGenTexturesEXT (GLsizei, GLuint *);
-extern GLboolean APIENTRY glIsTextureEXT (GLuint);
-extern void APIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *);
+GLAPI GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *);
+GLAPI void APIENTRY glBindTextureEXT (GLenum, GLuint);
+GLAPI void APIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *);
+GLAPI void APIENTRY glGenTexturesEXT (GLsizei, GLuint *);
+GLAPI GLboolean APIENTRY glIsTextureEXT (GLuint);
+GLAPI void APIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef GLboolean (APIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint *textures, GLboolean *residences);
 typedef void (APIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture);
@@ -1935,8 +3295,8 @@
 #ifndef GL_SGIS_detail_texture
 #define GL_SGIS_detail_texture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
-extern void APIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *);
+GLAPI void APIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+GLAPI void APIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
 typedef void (APIENTRY * PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
@@ -1945,8 +3305,8 @@
 #ifndef GL_SGIS_sharpen_texture
 #define GL_SGIS_sharpen_texture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
-extern void APIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *);
+GLAPI void APIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+GLAPI void APIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
 typedef void (APIENTRY * PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
@@ -1963,8 +3323,8 @@
 #ifndef GL_SGIS_multisample
 #define GL_SGIS_multisample 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glSampleMaskSGIS (GLclampf, GLboolean);
-extern void APIENTRY glSamplePatternSGIS (GLenum);
+GLAPI void APIENTRY glSampleMaskSGIS (GLclampf, GLboolean);
+GLAPI void APIENTRY glSamplePatternSGIS (GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert);
 typedef void (APIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern);
@@ -1977,15 +3337,15 @@
 #ifndef GL_EXT_vertex_array
 #define GL_EXT_vertex_array 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glArrayElementEXT (GLint);
-extern void APIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
-extern void APIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei);
-extern void APIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *);
-extern void APIENTRY glGetPointervEXT (GLenum, GLvoid* *);
-extern void APIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
-extern void APIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
-extern void APIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
-extern void APIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glArrayElementEXT (GLint);
+GLAPI void APIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei);
+GLAPI void APIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *);
+GLAPI void APIENTRY glGetPointervEXT (GLenum, GLvoid* *);
+GLAPI void APIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i);
 typedef void (APIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
@@ -2025,7 +3385,7 @@
 #ifndef GL_EXT_blend_minmax
 #define GL_EXT_blend_minmax 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glBlendEquationEXT (GLenum);
+GLAPI void APIENTRY glBlendEquationEXT (GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);
 #endif
@@ -2053,10 +3413,10 @@
 #ifndef GL_SGIX_sprite
 #define GL_SGIX_sprite 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glSpriteParameterfSGIX (GLenum, GLfloat);
-extern void APIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *);
-extern void APIENTRY glSpriteParameteriSGIX (GLenum, GLint);
-extern void APIENTRY glSpriteParameterivSGIX (GLenum, const GLint *);
+GLAPI void APIENTRY glSpriteParameterfSGIX (GLenum, GLfloat);
+GLAPI void APIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *);
+GLAPI void APIENTRY glSpriteParameteriSGIX (GLenum, GLint);
+GLAPI void APIENTRY glSpriteParameterivSGIX (GLenum, const GLint *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param);
 typedef void (APIENTRY * PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, const GLfloat *params);
@@ -2071,13 +3431,19 @@
 #ifndef GL_EXT_point_parameters
 #define GL_EXT_point_parameters 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glPointParameterfEXT (GLenum, GLfloat);
-extern void APIENTRY glPointParameterfvEXT (GLenum, const GLfloat *);
-extern void APIENTRY glPointParameterfSGIS (GLenum, GLfloat);
-extern void APIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *);
+GLAPI void APIENTRY glPointParameterfEXT (GLenum, GLfloat);
+GLAPI void APIENTRY glPointParameterfvEXT (GLenum, const GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param);
 typedef void (APIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_SGIS_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPointParameterfSGIS (GLenum, GLfloat);
+GLAPI void APIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLfloat param);
 typedef void (APIENTRY * PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params);
 #endif
@@ -2085,12 +3451,12 @@
 #ifndef GL_SGIX_instruments
 #define GL_SGIX_instruments 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern GLint APIENTRY glGetInstrumentsSGIX (void);
-extern void APIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *);
-extern GLint APIENTRY glPollInstrumentsSGIX (GLint *);
-extern void APIENTRY glReadInstrumentsSGIX (GLint);
-extern void APIENTRY glStartInstrumentsSGIX (void);
-extern void APIENTRY glStopInstrumentsSGIX (GLint);
+GLAPI GLint APIENTRY glGetInstrumentsSGIX (void);
+GLAPI void APIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *);
+GLAPI GLint APIENTRY glPollInstrumentsSGIX (GLint *);
+GLAPI void APIENTRY glReadInstrumentsSGIX (GLint);
+GLAPI void APIENTRY glStartInstrumentsSGIX (void);
+GLAPI void APIENTRY glStopInstrumentsSGIX (GLint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef GLint (APIENTRY * PFNGLGETINSTRUMENTSSGIXPROC) (void);
 typedef void (APIENTRY * PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GLint *buffer);
@@ -2107,7 +3473,7 @@
 #ifndef GL_SGIX_framezoom
 #define GL_SGIX_framezoom 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glFrameZoomSGIX (GLint);
+GLAPI void APIENTRY glFrameZoomSGIX (GLint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor);
 #endif
@@ -2115,7 +3481,7 @@
 #ifndef GL_SGIX_tag_sample_buffer
 #define GL_SGIX_tag_sample_buffer 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTagSampleBufferSGIX (void);
+GLAPI void APIENTRY glTagSampleBufferSGIX (void);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void);
 #endif
@@ -2123,10 +3489,10 @@
 #ifndef GL_SGIX_polynomial_ffd
 #define GL_SGIX_polynomial_ffd 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glDeformationMap3dSGIX (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *);
-extern void APIENTRY glDeformationMap3fSGIX (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *);
-extern void APIENTRY glDeformSGIX (GLbitfield);
-extern void APIENTRY glLoadIdentityDeformationMapSGIX (GLbitfield);
+GLAPI void APIENTRY glDeformationMap3dSGIX (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *);
+GLAPI void APIENTRY glDeformationMap3fSGIX (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *);
+GLAPI void APIENTRY glDeformSGIX (GLbitfield);
+GLAPI void APIENTRY glLoadIdentityDeformationMapSGIX (GLbitfield);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLDEFORMATIONMAP3DSGIXPROC) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points);
 typedef void (APIENTRY * PFNGLDEFORMATIONMAP3FSGIXPROC) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points);
@@ -2137,7 +3503,7 @@
 #ifndef GL_SGIX_reference_plane
 #define GL_SGIX_reference_plane 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glReferencePlaneSGIX (const GLdouble *);
+GLAPI void APIENTRY glReferencePlaneSGIX (const GLdouble *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equation);
 #endif
@@ -2145,7 +3511,7 @@
 #ifndef GL_SGIX_flush_raster
 #define GL_SGIX_flush_raster 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glFlushRasterSGIX (void);
+GLAPI void APIENTRY glFlushRasterSGIX (void);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void);
 #endif
@@ -2157,11 +3523,11 @@
 #ifndef GL_SGIS_fog_function
 #define GL_SGIS_fog_function 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glFogFuncSGIS (GLsizei, const GLfloat *);
-extern void APIENTRY glGetFogFuncSGIS (const GLfloat *);
+GLAPI void APIENTRY glFogFuncSGIS (GLsizei, const GLfloat *);
+GLAPI void APIENTRY glGetFogFuncSGIS (GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *points);
-typedef void (APIENTRY * PFNGLGETFOGFUNCSGISPROC) (const GLfloat *points);
+typedef void (APIENTRY * PFNGLGETFOGFUNCSGISPROC) (GLfloat *points);
 #endif
 
 #ifndef GL_SGIX_fog_offset
@@ -2171,12 +3537,12 @@
 #ifndef GL_HP_image_transform
 #define GL_HP_image_transform 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint);
-extern void APIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat);
-extern void APIENTRY glImageTransformParameterivHP (GLenum, GLenum, const GLint *);
-extern void APIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *);
-extern void APIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLint *);
-extern void APIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint);
+GLAPI void APIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat);
+GLAPI void APIENTRY glImageTransformParameterivHP (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, GLint param);
 typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, GLfloat param);
@@ -2197,8 +3563,8 @@
 #ifndef GL_EXT_color_subtable
 #define GL_EXT_color_subtable 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei);
+GLAPI void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
 typedef void (APIENTRY * PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
@@ -2211,7 +3577,7 @@
 #ifndef GL_PGI_misc_hints
 #define GL_PGI_misc_hints 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glHintPGI (GLenum, GLint);
+GLAPI void APIENTRY glHintPGI (GLenum, GLint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLHINTPGIPROC) (GLenum target, GLint mode);
 #endif
@@ -2219,10 +3585,10 @@
 #ifndef GL_EXT_paletted_texture
 #define GL_EXT_paletted_texture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
-extern void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint *);
-extern void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+GLAPI void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
+GLAPI void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
 typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data);
@@ -2237,12 +3603,12 @@
 #ifndef GL_SGIX_list_priority
 #define GL_SGIX_list_priority 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);
-extern void APIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *);
-extern void APIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat);
-extern void APIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat *);
-extern void APIENTRY glListParameteriSGIX (GLuint, GLenum, GLint);
-extern void APIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *);
+GLAPI void APIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat);
+GLAPI void APIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat *);
+GLAPI void APIENTRY glListParameteriSGIX (GLuint, GLenum, GLint);
+GLAPI void APIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, GLfloat *params);
 typedef void (APIENTRY * PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, GLint *params);
@@ -2275,7 +3641,7 @@
 #ifndef GL_EXT_index_material
 #define GL_EXT_index_material 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glIndexMaterialEXT (GLenum, GLenum);
+GLAPI void APIENTRY glIndexMaterialEXT (GLenum, GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode);
 #endif
@@ -2283,7 +3649,7 @@
 #ifndef GL_EXT_index_func
 #define GL_EXT_index_func 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glIndexFuncEXT (GLenum, GLclampf);
+GLAPI void APIENTRY glIndexFuncEXT (GLenum, GLclampf);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref);
 #endif
@@ -2295,8 +3661,8 @@
 #ifndef GL_EXT_compiled_vertex_array
 #define GL_EXT_compiled_vertex_array 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glLockArraysEXT (GLint, GLsizei);
-extern void APIENTRY glUnlockArraysEXT (void);
+GLAPI void APIENTRY glLockArraysEXT (GLint, GLsizei);
+GLAPI void APIENTRY glUnlockArraysEXT (void);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
 typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
@@ -2305,8 +3671,8 @@
 #ifndef GL_EXT_cull_vertex
 #define GL_EXT_cull_vertex 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glCullParameterdvEXT (GLenum, GLdouble *);
-extern void APIENTRY glCullParameterfvEXT (GLenum, GLfloat *);
+GLAPI void APIENTRY glCullParameterdvEXT (GLenum, GLdouble *);
+GLAPI void APIENTRY glCullParameterfvEXT (GLenum, GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble *params);
 typedef void (APIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat *params);
@@ -2319,24 +3685,24 @@
 #ifndef GL_SGIX_fragment_lighting
 #define GL_SGIX_fragment_lighting 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum);
-extern void APIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat);
-extern void APIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *);
-extern void APIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint);
-extern void APIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *);
-extern void APIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat);
-extern void APIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *);
-extern void APIENTRY glFragmentLightModeliSGIX (GLenum, GLint);
-extern void APIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *);
-extern void APIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);
-extern void APIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *);
-extern void APIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint);
-extern void APIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *);
-extern void APIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);
-extern void APIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *);
-extern void APIENTRY glLightEnviSGIX (GLenum, GLint);
+GLAPI void APIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum);
+GLAPI void APIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat);
+GLAPI void APIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint);
+GLAPI void APIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat);
+GLAPI void APIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *);
+GLAPI void APIENTRY glFragmentLightModeliSGIX (GLenum, GLint);
+GLAPI void APIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *);
+GLAPI void APIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);
+GLAPI void APIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint);
+GLAPI void APIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glLightEnviSGIX (GLenum, GLint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode);
 typedef void (APIENTRY * PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param);
@@ -2369,7 +3735,7 @@
 #ifndef GL_EXT_draw_range_elements
 #define GL_EXT_draw_range_elements 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+GLAPI void APIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
 #endif
@@ -2385,9 +3751,9 @@
 #ifndef GL_EXT_light_texture
 #define GL_EXT_light_texture 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glApplyTextureEXT (GLenum);
-extern void APIENTRY glTextureLightEXT (GLenum);
-extern void APIENTRY glTextureMaterialEXT (GLenum, GLenum);
+GLAPI void APIENTRY glApplyTextureEXT (GLenum);
+GLAPI void APIENTRY glTextureLightEXT (GLenum);
+GLAPI void APIENTRY glTextureMaterialEXT (GLenum, GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode);
 typedef void (APIENTRY * PFNGLTEXTURELIGHTEXTPROC) (GLenum pname);
@@ -2405,12 +3771,12 @@
 #ifndef GL_SGIX_async
 #define GL_SGIX_async 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glAsyncMarkerSGIX (GLuint);
-extern GLint APIENTRY glFinishAsyncSGIX (GLuint *);
-extern GLint APIENTRY glPollAsyncSGIX (GLuint *);
-extern GLuint APIENTRY glGenAsyncMarkersSGIX (GLsizei);
-extern void APIENTRY glDeleteAsyncMarkersSGIX (GLuint, GLsizei);
-extern GLboolean APIENTRY glIsAsyncMarkerSGIX (GLuint);
+GLAPI void APIENTRY glAsyncMarkerSGIX (GLuint);
+GLAPI GLint APIENTRY glFinishAsyncSGIX (GLuint *);
+GLAPI GLint APIENTRY glPollAsyncSGIX (GLuint *);
+GLAPI GLuint APIENTRY glGenAsyncMarkersSGIX (GLsizei);
+GLAPI void APIENTRY glDeleteAsyncMarkersSGIX (GLuint, GLsizei);
+GLAPI GLboolean APIENTRY glIsAsyncMarkerSGIX (GLuint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLASYNCMARKERSGIXPROC) (GLuint marker);
 typedef GLint (APIENTRY * PFNGLFINISHASYNCSGIXPROC) (GLuint *markerp);
@@ -2431,10 +3797,10 @@
 #ifndef GL_INTEL_parallel_arrays
 #define GL_INTEL_parallel_arrays 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *);
-extern void APIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *);
-extern void APIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *);
-extern void APIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *);
+GLAPI void APIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *);
+GLAPI void APIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *);
+GLAPI void APIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *);
+GLAPI void APIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
 typedef void (APIENTRY * PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const GLvoid* *pointer);
@@ -2449,10 +3815,10 @@
 #ifndef GL_EXT_pixel_transform
 #define GL_EXT_pixel_transform 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint);
-extern void APIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat);
-extern void APIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *);
-extern void APIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint);
+GLAPI void APIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat);
+GLAPI void APIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param);
 typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param);
@@ -2475,23 +3841,23 @@
 #ifndef GL_EXT_secondary_color
 #define GL_EXT_secondary_color 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);
-extern void APIENTRY glSecondaryColor3bvEXT (const GLbyte *);
-extern void APIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);
-extern void APIENTRY glSecondaryColor3dvEXT (const GLdouble *);
-extern void APIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glSecondaryColor3fvEXT (const GLfloat *);
-extern void APIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint);
-extern void APIENTRY glSecondaryColor3ivEXT (const GLint *);
-extern void APIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort);
-extern void APIENTRY glSecondaryColor3svEXT (const GLshort *);
-extern void APIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);
-extern void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *);
-extern void APIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);
-extern void APIENTRY glSecondaryColor3uivEXT (const GLuint *);
-extern void APIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort);
-extern void APIENTRY glSecondaryColor3usvEXT (const GLushort *);
-extern void APIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, GLvoid *);
+GLAPI void APIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);
+GLAPI void APIENTRY glSecondaryColor3bvEXT (const GLbyte *);
+GLAPI void APIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glSecondaryColor3dvEXT (const GLdouble *);
+GLAPI void APIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glSecondaryColor3fvEXT (const GLfloat *);
+GLAPI void APIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint);
+GLAPI void APIENTRY glSecondaryColor3ivEXT (const GLint *);
+GLAPI void APIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glSecondaryColor3svEXT (const GLshort *);
+GLAPI void APIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);
+GLAPI void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *);
+GLAPI void APIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glSecondaryColor3uivEXT (const GLuint *);
+GLAPI void APIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort);
+GLAPI void APIENTRY glSecondaryColor3usvEXT (const GLushort *);
+GLAPI void APIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
 typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v);
@@ -2509,13 +3875,13 @@
 typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v);
 typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue);
 typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v);
-typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
 #endif
 
 #ifndef GL_EXT_texture_perturb_normal
 #define GL_EXT_texture_perturb_normal 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTextureNormalEXT (GLenum);
+GLAPI void APIENTRY glTextureNormalEXT (GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode);
 #endif
@@ -2523,8 +3889,8 @@
 #ifndef GL_EXT_multi_draw_arrays
 #define GL_EXT_multi_draw_arrays 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei);
-extern void APIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei);
+GLAPI void APIENTRY glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei);
+GLAPI void APIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
 typedef void (APIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
@@ -2533,11 +3899,11 @@
 #ifndef GL_EXT_fog_coord
 #define GL_EXT_fog_coord 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glFogCoordfEXT (GLfloat);
-extern void APIENTRY glFogCoordfvEXT (const GLfloat *);
-extern void APIENTRY glFogCoorddEXT (GLdouble);
-extern void APIENTRY glFogCoorddvEXT (const GLdouble *);
-extern void APIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glFogCoordfEXT (GLfloat);
+GLAPI void APIENTRY glFogCoordfvEXT (const GLfloat *);
+GLAPI void APIENTRY glFogCoorddEXT (GLdouble);
+GLAPI void APIENTRY glFogCoorddvEXT (const GLdouble *);
+GLAPI void APIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord);
 typedef void (APIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord);
@@ -2553,28 +3919,28 @@
 #ifndef GL_EXT_coordinate_frame
 #define GL_EXT_coordinate_frame 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte);
-extern void APIENTRY glTangent3bvEXT (const GLbyte *);
-extern void APIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble);
-extern void APIENTRY glTangent3dvEXT (const GLdouble *);
-extern void APIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTangent3fvEXT (const GLfloat *);
-extern void APIENTRY glTangent3iEXT (GLint, GLint, GLint);
-extern void APIENTRY glTangent3ivEXT (const GLint *);
-extern void APIENTRY glTangent3sEXT (GLshort, GLshort, GLshort);
-extern void APIENTRY glTangent3svEXT (const GLshort *);
-extern void APIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte);
-extern void APIENTRY glBinormal3bvEXT (const GLbyte *);
-extern void APIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble);
-extern void APIENTRY glBinormal3dvEXT (const GLdouble *);
-extern void APIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glBinormal3fvEXT (const GLfloat *);
-extern void APIENTRY glBinormal3iEXT (GLint, GLint, GLint);
-extern void APIENTRY glBinormal3ivEXT (const GLint *);
-extern void APIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort);
-extern void APIENTRY glBinormal3svEXT (const GLshort *);
-extern void APIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *);
-extern void APIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte);
+GLAPI void APIENTRY glTangent3bvEXT (const GLbyte *);
+GLAPI void APIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glTangent3dvEXT (const GLdouble *);
+GLAPI void APIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTangent3fvEXT (const GLfloat *);
+GLAPI void APIENTRY glTangent3iEXT (GLint, GLint, GLint);
+GLAPI void APIENTRY glTangent3ivEXT (const GLint *);
+GLAPI void APIENTRY glTangent3sEXT (GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glTangent3svEXT (const GLshort *);
+GLAPI void APIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte);
+GLAPI void APIENTRY glBinormal3bvEXT (const GLbyte *);
+GLAPI void APIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glBinormal3dvEXT (const GLdouble *);
+GLAPI void APIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glBinormal3fvEXT (const GLfloat *);
+GLAPI void APIENTRY glBinormal3iEXT (GLint, GLint, GLint);
+GLAPI void APIENTRY glBinormal3ivEXT (const GLint *);
+GLAPI void APIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glBinormal3svEXT (const GLshort *);
+GLAPI void APIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLbyte tz);
 typedef void (APIENTRY * PFNGLTANGENT3BVEXTPROC) (const GLbyte *v);
@@ -2619,7 +3985,7 @@
 #ifndef GL_SUNX_constant_data
 #define GL_SUNX_constant_data 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glFinishTextureSUNX (void);
+GLAPI void APIENTRY glFinishTextureSUNX (void);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLFINISHTEXTURESUNXPROC) (void);
 #endif
@@ -2627,14 +3993,14 @@
 #ifndef GL_SUN_global_alpha
 #define GL_SUN_global_alpha 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glGlobalAlphaFactorbSUN (GLbyte);
-extern void APIENTRY glGlobalAlphaFactorsSUN (GLshort);
-extern void APIENTRY glGlobalAlphaFactoriSUN (GLint);
-extern void APIENTRY glGlobalAlphaFactorfSUN (GLfloat);
-extern void APIENTRY glGlobalAlphaFactordSUN (GLdouble);
-extern void APIENTRY glGlobalAlphaFactorubSUN (GLubyte);
-extern void APIENTRY glGlobalAlphaFactorusSUN (GLushort);
-extern void APIENTRY glGlobalAlphaFactoruiSUN (GLuint);
+GLAPI void APIENTRY glGlobalAlphaFactorbSUN (GLbyte);
+GLAPI void APIENTRY glGlobalAlphaFactorsSUN (GLshort);
+GLAPI void APIENTRY glGlobalAlphaFactoriSUN (GLint);
+GLAPI void APIENTRY glGlobalAlphaFactorfSUN (GLfloat);
+GLAPI void APIENTRY glGlobalAlphaFactordSUN (GLdouble);
+GLAPI void APIENTRY glGlobalAlphaFactorubSUN (GLubyte);
+GLAPI void APIENTRY glGlobalAlphaFactorusSUN (GLushort);
+GLAPI void APIENTRY glGlobalAlphaFactoruiSUN (GLuint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor);
 typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor);
@@ -2649,13 +4015,13 @@
 #ifndef GL_SUN_triangle_list
 #define GL_SUN_triangle_list 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glReplacementCodeuiSUN (GLuint);
-extern void APIENTRY glReplacementCodeusSUN (GLushort);
-extern void APIENTRY glReplacementCodeubSUN (GLubyte);
-extern void APIENTRY glReplacementCodeuivSUN (const GLuint *);
-extern void APIENTRY glReplacementCodeusvSUN (const GLushort *);
-extern void APIENTRY glReplacementCodeubvSUN (const GLubyte *);
-extern void APIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *);
+GLAPI void APIENTRY glReplacementCodeuiSUN (GLuint);
+GLAPI void APIENTRY glReplacementCodeusSUN (GLushort);
+GLAPI void APIENTRY glReplacementCodeubSUN (GLubyte);
+GLAPI void APIENTRY glReplacementCodeuivSUN (const GLuint *);
+GLAPI void APIENTRY glReplacementCodeusvSUN (const GLushort *);
+GLAPI void APIENTRY glReplacementCodeubvSUN (const GLubyte *);
+GLAPI void APIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code);
 typedef void (APIENTRY * PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code);
@@ -2669,46 +4035,46 @@
 #ifndef GL_SUN_vertex
 #define GL_SUN_vertex 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat);
-extern void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *);
-extern void APIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *);
-extern void APIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *);
-extern void APIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *);
-extern void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *);
-extern void APIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *);
-extern void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *);
-extern void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLenum *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLenum, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLenum *, const GLubyte *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
-extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat);
+GLAPI void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *);
+GLAPI void APIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *);
+GLAPI void APIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *);
+GLAPI void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLuint *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLuint *, const GLubyte *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
 typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c, const GLfloat *v);
@@ -2734,32 +4100,40 @@
 typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
 typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLenum rc, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLenum rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLenum *rc, const GLubyte *c, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *c, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *n, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLuint *rc, const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
 #endif
 
 #ifndef GL_EXT_blend_func_separate
 #define GL_EXT_blend_func_separate 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum);
+GLAPI void APIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
 #endif
 
+#ifndef GL_INGR_blend_func_separate
+#define GL_INGR_blend_func_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncSeparateINGR (GLenum, GLenum, GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDFUNCSEPARATEINGRPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#endif
+
 #ifndef GL_INGR_color_clamp
 #define GL_INGR_color_clamp 1
 #endif
@@ -2799,9 +4173,9 @@
 #ifndef GL_EXT_vertex_weighting
 #define GL_EXT_vertex_weighting 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glVertexWeightfEXT (GLfloat);
-extern void APIENTRY glVertexWeightfvEXT (const GLfloat *);
-extern void APIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glVertexWeightfEXT (GLfloat);
+GLAPI void APIENTRY glVertexWeightfvEXT (const GLfloat *);
+GLAPI void APIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight);
 typedef void (APIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight);
@@ -2815,29 +4189,29 @@
 #ifndef GL_NV_vertex_array_range
 #define GL_NV_vertex_array_range 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glFlushVertexArrayRangeNV (void);
-extern void APIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *);
+GLAPI void APIENTRY glFlushVertexArrayRangeNV (void);
+GLAPI void APIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void);
-typedef void (APIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei size, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, const GLvoid *pointer);
 #endif
 
 #ifndef GL_NV_register_combiners
 #define GL_NV_register_combiners 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *);
-extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
-extern void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);
-extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
-extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
-extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
-extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
-extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
-extern void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *);
-extern void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *);
+GLAPI void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
+GLAPI void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);
+GLAPI void APIENTRY glCombinerParameteriNV (GLenum, GLint);
+GLAPI void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
+GLAPI void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
+GLAPI void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
+GLAPI void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params);
 typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param);
@@ -2873,7 +4247,7 @@
 #ifndef GL_MESA_resize_buffers
 #define GL_MESA_resize_buffers 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glResizeBuffersMESA (void);
+GLAPI void APIENTRY glResizeBuffersMESA (void);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void);
 #endif
@@ -2881,30 +4255,30 @@
 #ifndef GL_MESA_window_pos
 #define GL_MESA_window_pos 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glWindowPos2dMESA (GLdouble, GLdouble);
-extern void APIENTRY glWindowPos2dvMESA (const GLdouble *);
-extern void APIENTRY glWindowPos2fMESA (GLfloat, GLfloat);
-extern void APIENTRY glWindowPos2fvMESA (const GLfloat *);
-extern void APIENTRY glWindowPos2iMESA (GLint, GLint);
-extern void APIENTRY glWindowPos2ivMESA (const GLint *);
-extern void APIENTRY glWindowPos2sMESA (GLshort, GLshort);
-extern void APIENTRY glWindowPos2svMESA (const GLshort *);
-extern void APIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);
-extern void APIENTRY glWindowPos3dvMESA (const GLdouble *);
-extern void APIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glWindowPos3fvMESA (const GLfloat *);
-extern void APIENTRY glWindowPos3iMESA (GLint, GLint, GLint);
-extern void APIENTRY glWindowPos3ivMESA (const GLint *);
-extern void APIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort);
-extern void APIENTRY glWindowPos3svMESA (const GLshort *);
-extern void APIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble);
-extern void APIENTRY glWindowPos4dvMESA (const GLdouble *);
-extern void APIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat);
-extern void APIENTRY glWindowPos4fvMESA (const GLfloat *);
-extern void APIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint);
-extern void APIENTRY glWindowPos4ivMESA (const GLint *);
-extern void APIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort);
-extern void APIENTRY glWindowPos4svMESA (const GLshort *);
+GLAPI void APIENTRY glWindowPos2dMESA (GLdouble, GLdouble);
+GLAPI void APIENTRY glWindowPos2dvMESA (const GLdouble *);
+GLAPI void APIENTRY glWindowPos2fMESA (GLfloat, GLfloat);
+GLAPI void APIENTRY glWindowPos2fvMESA (const GLfloat *);
+GLAPI void APIENTRY glWindowPos2iMESA (GLint, GLint);
+GLAPI void APIENTRY glWindowPos2ivMESA (const GLint *);
+GLAPI void APIENTRY glWindowPos2sMESA (GLshort, GLshort);
+GLAPI void APIENTRY glWindowPos2svMESA (const GLshort *);
+GLAPI void APIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glWindowPos3dvMESA (const GLdouble *);
+GLAPI void APIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glWindowPos3fvMESA (const GLfloat *);
+GLAPI void APIENTRY glWindowPos3iMESA (GLint, GLint, GLint);
+GLAPI void APIENTRY glWindowPos3ivMESA (const GLint *);
+GLAPI void APIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glWindowPos3svMESA (const GLshort *);
+GLAPI void APIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glWindowPos4dvMESA (const GLdouble *);
+GLAPI void APIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glWindowPos4fvMESA (const GLfloat *);
+GLAPI void APIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint);
+GLAPI void APIENTRY glWindowPos4ivMESA (const GLint *);
+GLAPI void APIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glWindowPos4svMESA (const GLshort *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y);
 typedef void (APIENTRY * PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v);
@@ -2939,8 +4313,8 @@
 #ifndef GL_IBM_multimode_draw_arrays
 #define GL_IBM_multimode_draw_arrays 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glMultiModeDrawArraysIBM (GLenum, const GLint *, const GLsizei *, GLsizei, GLint);
-extern void APIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* *, GLsizei, GLint);
+GLAPI void APIENTRY glMultiModeDrawArraysIBM (GLenum, const GLint *, const GLsizei *, GLsizei, GLint);
+GLAPI void APIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* *, GLsizei, GLint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLMULTIMODEDRAWARRAYSIBMPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride);
 typedef void (APIENTRY * PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, GLint modestride);
@@ -2949,14 +4323,14 @@
 #ifndef GL_IBM_vertex_array_lists
 #define GL_IBM_vertex_array_lists 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
-extern void APIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
-extern void APIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint);
-extern void APIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
-extern void APIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
-extern void APIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
-extern void APIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
-extern void APIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+GLAPI void APIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+GLAPI void APIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+GLAPI void APIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint);
+GLAPI void APIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+GLAPI void APIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+GLAPI void APIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+GLAPI void APIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+GLAPI void APIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
 typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
@@ -2995,7 +4369,7 @@
 #ifndef GL_3DFX_tbuffer
 #define GL_3DFX_tbuffer 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTbufferMask3DFX (GLuint);
+GLAPI void APIENTRY glTbufferMask3DFX (GLuint);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);
 #endif
@@ -3003,15 +4377,15 @@
 #ifndef GL_EXT_multisample
 #define GL_EXT_multisample 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glSampleMaskEXT (GLclampf, GLboolean);
-extern void APIENTRY glSamplePatternEXT (GLenum);
+GLAPI void APIENTRY glSampleMaskEXT (GLclampf, GLboolean);
+GLAPI void APIENTRY glSamplePatternEXT (GLenum);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert);
 typedef void (APIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern);
 #endif
 
-#ifndef GL_SGI_vertex_preclip
-#define GL_SGI_vertex_preclip 1
+#ifndef GL_SGIX_vertex_preclip
+#define GL_SGIX_vertex_preclip 1
 #endif
 
 #ifndef GL_SGIX_convolution_accuracy
@@ -3029,7 +4403,7 @@
 #ifndef GL_SGIS_texture_color_mask
 #define GL_SGIS_texture_color_mask 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean);
+GLAPI void APIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
 #endif
@@ -3037,13 +4411,609 @@
 #ifndef GL_SGIX_igloo_interface
 #define GL_SGIX_igloo_interface 1
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glIglooInterfaceSGIX (GLenum, const GLvoid *);
+GLAPI void APIENTRY glIglooInterfaceSGIX (GLenum, const GLvoid *);
 #endif /* GL_GLEXT_PROTOTYPES */
 typedef void (APIENTRY * PFNGLIGLOOINTERFACESGIXPROC) (GLenum pname, const GLvoid *params);
 #endif
 
 #ifndef GL_EXT_texture_env_dot3
 #define GL_EXT_texture_env_dot3 1
+#endif
+
+#ifndef GL_ATI_texture_mirror_once
+#define GL_ATI_texture_mirror_once 1
+#endif
+
+#ifndef GL_NV_fence
+#define GL_NV_fence 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDeleteFencesNV (GLsizei, const GLuint *);
+GLAPI void APIENTRY glGenFencesNV (GLsizei, GLuint *);
+GLAPI GLboolean APIENTRY glIsFenceNV (GLuint);
+GLAPI GLboolean APIENTRY glTestFenceNV (GLuint);
+GLAPI void APIENTRY glGetFenceivNV (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glFinishFenceNV (GLuint);
+GLAPI void APIENTRY glSetFenceNV (GLuint, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint *fences);
+typedef void (APIENTRY * PFNGLGENFENCESNVPROC) (GLsizei n, GLuint *fences);
+typedef GLboolean (APIENTRY * PFNGLISFENCENVPROC) (GLuint fence);
+typedef GLboolean (APIENTRY * PFNGLTESTFENCENVPROC) (GLuint fence);
+typedef void (APIENTRY * PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLFINISHFENCENVPROC) (GLuint fence);
+typedef void (APIENTRY * PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition);
+#endif
+
+#ifndef GL_NV_evaluators
+#define GL_NV_evaluators 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glMapControlPointsNV (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, const GLvoid *);
+GLAPI void APIENTRY glMapParameterivNV (GLenum, GLenum, const GLint *);
+GLAPI void APIENTRY glMapParameterfvNV (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glGetMapControlPointsNV (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, GLvoid *);
+GLAPI void APIENTRY glGetMapParameterivNV (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glGetMapParameterfvNV (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetMapAttribParameterivNV (GLenum, GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetMapAttribParameterfvNV (GLenum, GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glEvalMapsNV (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
+typedef void (APIENTRY * PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);
+typedef void (APIENTRY * PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode);
+#endif
+
+#ifndef GL_NV_packed_depth_stencil
+#define GL_NV_packed_depth_stencil 1
+#endif
+
+#ifndef GL_NV_register_combiners2
+#define GL_NV_register_combiners2 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glCombinerStageParameterfvNV (GLenum, GLenum, const GLfloat *);
+GLAPI void APIENTRY glGetCombinerStageParameterfvNV (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_NV_texture_compression_vtc
+#define GL_NV_texture_compression_vtc 1
+#endif
+
+#ifndef GL_NV_texture_rectangle
+#define GL_NV_texture_rectangle 1
+#endif
+
+#ifndef GL_NV_texture_shader
+#define GL_NV_texture_shader 1
+#endif
+
+#ifndef GL_NV_texture_shader2
+#define GL_NV_texture_shader2 1
+#endif
+
+#ifndef GL_NV_vertex_array_range2
+#define GL_NV_vertex_array_range2 1
+#endif
+
+#ifndef GL_NV_vertex_program
+#define GL_NV_vertex_program 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLboolean APIENTRY glAreProgramsResidentNV (GLsizei, const GLuint *, GLboolean *);
+GLAPI void APIENTRY glBindProgramNV (GLenum, GLuint);
+GLAPI void APIENTRY glDeleteProgramsNV (GLsizei, const GLuint *);
+GLAPI void APIENTRY glExecuteProgramNV (GLenum, GLuint, const GLfloat *);
+GLAPI void APIENTRY glGenProgramsNV (GLsizei, GLuint *);
+GLAPI void APIENTRY glGetProgramParameterdvNV (GLenum, GLuint, GLenum, GLdouble *);
+GLAPI void APIENTRY glGetProgramParameterfvNV (GLenum, GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetProgramivNV (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetProgramStringNV (GLuint, GLenum, GLubyte *);
+GLAPI void APIENTRY glGetTrackMatrixivNV (GLenum, GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetVertexAttribdvNV (GLuint, GLenum, GLdouble *);
+GLAPI void APIENTRY glGetVertexAttribfvNV (GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetVertexAttribivNV (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetVertexAttribPointervNV (GLuint, GLenum, GLvoid* *);
+GLAPI GLboolean APIENTRY glIsProgramNV (GLuint);
+GLAPI void APIENTRY glLoadProgramNV (GLenum, GLuint, GLsizei, const GLubyte *);
+GLAPI void APIENTRY glProgramParameter4dNV (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glProgramParameter4dvNV (GLenum, GLuint, const GLdouble *);
+GLAPI void APIENTRY glProgramParameter4fNV (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glProgramParameter4fvNV (GLenum, GLuint, const GLfloat *);
+GLAPI void APIENTRY glProgramParameters4dvNV (GLenum, GLuint, GLuint, const GLdouble *);
+GLAPI void APIENTRY glProgramParameters4fvNV (GLenum, GLuint, GLuint, const GLfloat *);
+GLAPI void APIENTRY glRequestResidentProgramsNV (GLsizei, const GLuint *);
+GLAPI void APIENTRY glTrackMatrixNV (GLenum, GLuint, GLenum, GLenum);
+GLAPI void APIENTRY glVertexAttribPointerNV (GLuint, GLint, GLenum, GLsizei, const GLvoid *);
+GLAPI void APIENTRY glVertexAttrib1dNV (GLuint, GLdouble);
+GLAPI void APIENTRY glVertexAttrib1dvNV (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib1fNV (GLuint, GLfloat);
+GLAPI void APIENTRY glVertexAttrib1fvNV (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib1sNV (GLuint, GLshort);
+GLAPI void APIENTRY glVertexAttrib1svNV (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib2dNV (GLuint, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexAttrib2dvNV (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib2fNV (GLuint, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexAttrib2fvNV (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib2sNV (GLuint, GLshort, GLshort);
+GLAPI void APIENTRY glVertexAttrib2svNV (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib3dNV (GLuint, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexAttrib3dvNV (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib3fNV (GLuint, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexAttrib3fvNV (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib3sNV (GLuint, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glVertexAttrib3svNV (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib4dNV (GLuint, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexAttrib4dvNV (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVertexAttrib4fNV (GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexAttrib4fvNV (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVertexAttrib4sNV (GLuint, GLshort, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glVertexAttrib4svNV (GLuint, const GLshort *);
+GLAPI void APIENTRY glVertexAttrib4ubNV (GLuint, GLubyte, GLubyte, GLubyte, GLubyte);
+GLAPI void APIENTRY glVertexAttrib4ubvNV (GLuint, const GLubyte *);
+GLAPI void APIENTRY glVertexAttribs1dvNV (GLuint, GLsizei, const GLdouble *);
+GLAPI void APIENTRY glVertexAttribs1fvNV (GLuint, GLsizei, const GLfloat *);
+GLAPI void APIENTRY glVertexAttribs1svNV (GLuint, GLsizei, const GLshort *);
+GLAPI void APIENTRY glVertexAttribs2dvNV (GLuint, GLsizei, const GLdouble *);
+GLAPI void APIENTRY glVertexAttribs2fvNV (GLuint, GLsizei, const GLfloat *);
+GLAPI void APIENTRY glVertexAttribs2svNV (GLuint, GLsizei, const GLshort *);
+GLAPI void APIENTRY glVertexAttribs3dvNV (GLuint, GLsizei, const GLdouble *);
+GLAPI void APIENTRY glVertexAttribs3fvNV (GLuint, GLsizei, const GLfloat *);
+GLAPI void APIENTRY glVertexAttribs3svNV (GLuint, GLsizei, const GLshort *);
+GLAPI void APIENTRY glVertexAttribs4dvNV (GLuint, GLsizei, const GLdouble *);
+GLAPI void APIENTRY glVertexAttribs4fvNV (GLuint, GLsizei, const GLfloat *);
+GLAPI void APIENTRY glVertexAttribs4svNV (GLuint, GLsizei, const GLshort *);
+GLAPI void APIENTRY glVertexAttribs4ubvNV (GLuint, GLsizei, const GLubyte *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLboolean (APIENTRY * PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint *programs, GLboolean *residences);
+typedef void (APIENTRY * PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id);
+typedef void (APIENTRY * PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRY * PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRY * PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte *program);
+typedef void (APIENTRY * PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid* *pointer);
+typedef GLboolean (APIENTRY * PFNGLISPROGRAMNVPROC) (GLuint id);
+typedef void (APIENTRY * PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
+typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble *v);
+typedef void (APIENTRY * PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRY * PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRY * PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei count, const GLshort *v);
+typedef void (APIENTRY * PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei count, const GLubyte *v);
+#endif
+
+#ifndef GL_SGIX_texture_coordinate_clamp
+#define GL_SGIX_texture_coordinate_clamp 1
+#endif
+
+#ifndef GL_SGIX_scalebias_hint
+#define GL_SGIX_scalebias_hint 1
+#endif
+
+#ifndef GL_OML_interlace
+#define GL_OML_interlace 1
+#endif
+
+#ifndef GL_OML_subsample
+#define GL_OML_subsample 1
+#endif
+
+#ifndef GL_OML_resample
+#define GL_OML_resample 1
+#endif
+
+#ifndef GL_NV_copy_depth_to_color
+#define GL_NV_copy_depth_to_color 1
+#endif
+
+#ifndef GL_ATI_envmap_bumpmap
+#define GL_ATI_envmap_bumpmap 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glTexBumpParameterivATI (GLenum, const GLint *);
+GLAPI void APIENTRY glTexBumpParameterfvATI (GLenum, const GLfloat *);
+GLAPI void APIENTRY glGetTexBumpParameterivATI (GLenum, GLint *);
+GLAPI void APIENTRY glGetTexBumpParameterfvATI (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, const GLint *param);
+typedef void (APIENTRY * PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, const GLfloat *param);
+typedef void (APIENTRY * PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param);
+typedef void (APIENTRY * PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param);
+#endif
+
+#ifndef GL_ATI_fragment_shader
+#define GL_ATI_fragment_shader 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLuint APIENTRY glGenFragmentShadersATI (GLuint);
+GLAPI void APIENTRY glBindFragmentShaderATI (GLuint);
+GLAPI void APIENTRY glDeleteFragmentShaderATI (GLuint);
+GLAPI void APIENTRY glBeginFragmentShaderATI (void);
+GLAPI void APIENTRY glEndFragmentShaderATI (void);
+GLAPI void APIENTRY glPassTexCoordATI (GLuint, GLuint, GLenum);
+GLAPI void APIENTRY glSampleMapATI (GLuint, GLuint, GLenum);
+GLAPI void APIENTRY glColorFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glColorFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glColorFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glAlphaFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glAlphaFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glAlphaFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glSetFragmentShaderConstantATI (GLuint, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLuint (APIENTRY * PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range);
+typedef void (APIENTRY * PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id);
+typedef void (APIENTRY * PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id);
+typedef void (APIENTRY * PFNGLBEGINFRAGMENTSHADERATIPROC) (void);
+typedef void (APIENTRY * PFNGLENDFRAGMENTSHADERATIPROC) (void);
+typedef void (APIENTRY * PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coord, GLenum swizzle);
+typedef void (APIENTRY * PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp, GLenum swizzle);
+typedef void (APIENTRY * PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY * PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY * PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY * PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY * PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY * PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY * PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint dst, const GLfloat *value);
+#endif
+
+#ifndef GL_ATI_pn_triangles
+#define GL_ATI_pn_triangles 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPNTrianglesiATI (GLenum, GLint);
+GLAPI void APIENTRY glPNTrianglesfATI (GLenum, GLfloat);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat param);
+#endif
+
+#ifndef GL_ATI_vertex_array_object
+#define GL_ATI_vertex_array_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLuint APIENTRY glNewObjectBufferATI (GLsizei, const GLvoid *, GLenum);
+GLAPI GLboolean APIENTRY glIsObjectBufferATI (GLuint);
+GLAPI void APIENTRY glUpdateObjectBufferATI (GLuint, GLuint, GLsizei, const GLvoid *, GLenum);
+GLAPI void APIENTRY glGetObjectBufferfvATI (GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetObjectBufferivATI (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glDeleteObjectBufferATI (GLuint);
+GLAPI void APIENTRY glArrayObjectATI (GLenum, GLint, GLenum, GLsizei, GLuint, GLuint);
+GLAPI void APIENTRY glGetArrayObjectfvATI (GLenum, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetArrayObjectivATI (GLenum, GLenum, GLint *);
+GLAPI void APIENTRY glVariantArrayObjectATI (GLuint, GLenum, GLsizei, GLuint, GLuint);
+GLAPI void APIENTRY glGetVariantArrayObjectfvATI (GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetVariantArrayObjectivATI (GLuint, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLuint (APIENTRY * PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, const GLvoid *pointer, GLenum usage);
+typedef GLboolean (APIENTRY * PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer);
+typedef void (APIENTRY * PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, GLenum preserve);
+typedef void (APIENTRY * PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLDELETEOBJECTBUFFERATIPROC) (GLuint buffer);
+typedef void (APIENTRY * PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY * PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY * PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_EXT_vertex_shader
+#define GL_EXT_vertex_shader 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBeginVertexShaderEXT (void);
+GLAPI void APIENTRY glEndVertexShaderEXT (void);
+GLAPI void APIENTRY glBindVertexShaderEXT (GLuint);
+GLAPI GLuint APIENTRY glGenVertexShadersEXT (GLuint);
+GLAPI void APIENTRY glDeleteVertexShaderEXT (GLuint);
+GLAPI void APIENTRY glShaderOp1EXT (GLenum, GLuint, GLuint);
+GLAPI void APIENTRY glShaderOp2EXT (GLenum, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glShaderOp3EXT (GLenum, GLuint, GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glSwizzleEXT (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum);
+GLAPI void APIENTRY glWriteMaskEXT (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum);
+GLAPI void APIENTRY glInsertComponentEXT (GLuint, GLuint, GLuint);
+GLAPI void APIENTRY glExtractComponentEXT (GLuint, GLuint, GLuint);
+GLAPI GLuint APIENTRY glGenSymbolsEXT (GLenum, GLenum, GLenum, GLuint);
+GLAPI void APIENTRY glSetInvariantEXT (GLuint, GLenum, const void *);
+GLAPI void APIENTRY glSetLocalConstantEXT (GLuint, GLenum, const void *);
+GLAPI void APIENTRY glVariantbvEXT (GLuint, const GLbyte *);
+GLAPI void APIENTRY glVariantsvEXT (GLuint, const GLshort *);
+GLAPI void APIENTRY glVariantivEXT (GLuint, const GLint *);
+GLAPI void APIENTRY glVariantfvEXT (GLuint, const GLfloat *);
+GLAPI void APIENTRY glVariantdvEXT (GLuint, const GLdouble *);
+GLAPI void APIENTRY glVariantubvEXT (GLuint, const GLubyte *);
+GLAPI void APIENTRY glVariantusvEXT (GLuint, const GLushort *);
+GLAPI void APIENTRY glVariantuivEXT (GLuint, const GLuint *);
+GLAPI void APIENTRY glVariantPointerEXT (GLuint, GLenum, GLuint, const void *);
+GLAPI void APIENTRY glEnableVariantClientStateEXT (GLuint);
+GLAPI void APIENTRY glDisableVariantClientStateEXT (GLuint);
+GLAPI GLuint APIENTRY glBindLightParameterEXT (GLenum, GLenum);
+GLAPI GLuint APIENTRY glBindMaterialParameterEXT (GLenum, GLenum);
+GLAPI GLuint APIENTRY glBindTexGenParameterEXT (GLenum, GLenum, GLenum);
+GLAPI GLuint APIENTRY glBindTextureUnitParameterEXT (GLenum, GLenum);
+GLAPI GLuint APIENTRY glBindParameterEXT (GLenum);
+GLAPI GLboolean APIENTRY glIsVariantEnabledEXT (GLuint, GLenum);
+GLAPI void APIENTRY glGetVariantBooleanvEXT (GLuint, GLenum, GLboolean *);
+GLAPI void APIENTRY glGetVariantIntegervEXT (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetVariantFloatvEXT (GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetVariantPointervEXT (GLuint, GLenum, GLvoid* *);
+GLAPI void APIENTRY glGetInvariantBooleanvEXT (GLuint, GLenum, GLboolean *);
+GLAPI void APIENTRY glGetInvariantIntegervEXT (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetInvariantFloatvEXT (GLuint, GLenum, GLfloat *);
+GLAPI void APIENTRY glGetLocalConstantBooleanvEXT (GLuint, GLenum, GLboolean *);
+GLAPI void APIENTRY glGetLocalConstantIntegervEXT (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetLocalConstantFloatvEXT (GLuint, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBEGINVERTEXSHADEREXTPROC) (void);
+typedef void (APIENTRY * PFNGLENDVERTEXSHADEREXTPROC) (void);
+typedef void (APIENTRY * PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id);
+typedef GLuint (APIENTRY * PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range);
+typedef void (APIENTRY * PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id);
+typedef void (APIENTRY * PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GLuint arg1);
+typedef void (APIENTRY * PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
+typedef void (APIENTRY * PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
+typedef void (APIENTRY * PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRY * PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRY * PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef void (APIENTRY * PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef GLuint (APIENTRY * PFNGLGENSYMBOLSEXTPROC) (GLenum datatype, GLenum storagetype, GLenum range, GLuint components);
+typedef void (APIENTRY * PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type, const void *addr);
+typedef void (APIENTRY * PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum type, const void *addr);
+typedef void (APIENTRY * PFNGLVARIANTBVEXTPROC) (GLuint id, const GLbyte *addr);
+typedef void (APIENTRY * PFNGLVARIANTSVEXTPROC) (GLuint id, const GLshort *addr);
+typedef void (APIENTRY * PFNGLVARIANTIVEXTPROC) (GLuint id, const GLint *addr);
+typedef void (APIENTRY * PFNGLVARIANTFVEXTPROC) (GLuint id, const GLfloat *addr);
+typedef void (APIENTRY * PFNGLVARIANTDVEXTPROC) (GLuint id, const GLdouble *addr);
+typedef void (APIENTRY * PFNGLVARIANTUBVEXTPROC) (GLuint id, const GLubyte *addr);
+typedef void (APIENTRY * PFNGLVARIANTUSVEXTPROC) (GLuint id, const GLushort *addr);
+typedef void (APIENTRY * PFNGLVARIANTUIVEXTPROC) (GLuint id, const GLuint *addr);
+typedef void (APIENTRY * PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum type, GLuint stride, const void *addr);
+typedef void (APIENTRY * PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id);
+typedef void (APIENTRY * PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id);
+typedef GLuint (APIENTRY * PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light, GLenum value);
+typedef GLuint (APIENTRY * PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face, GLenum value);
+typedef GLuint (APIENTRY * PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit, GLenum coord, GLenum value);
+typedef GLuint (APIENTRY * PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum unit, GLenum value);
+typedef GLuint (APIENTRY * PFNGLBINDPARAMETEREXTPROC) (GLenum value);
+typedef GLboolean (APIENTRY * PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GLenum cap);
+typedef void (APIENTRY * PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRY * PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenum value, GLvoid* *data);
+typedef void (APIENTRY * PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRY * PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+#endif
+
+#ifndef GL_ATI_vertex_streams
+#define GL_ATI_vertex_streams 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glVertexStream1sATI (GLenum, GLshort);
+GLAPI void APIENTRY glVertexStream1svATI (GLenum, const GLshort *);
+GLAPI void APIENTRY glVertexStream1iATI (GLenum, GLint);
+GLAPI void APIENTRY glVertexStream1ivATI (GLenum, const GLint *);
+GLAPI void APIENTRY glVertexStream1fATI (GLenum, GLfloat);
+GLAPI void APIENTRY glVertexStream1fvATI (GLenum, const GLfloat *);
+GLAPI void APIENTRY glVertexStream1dATI (GLenum, GLdouble);
+GLAPI void APIENTRY glVertexStream1dvATI (GLenum, const GLdouble *);
+GLAPI void APIENTRY glVertexStream2sATI (GLenum, GLshort, GLshort);
+GLAPI void APIENTRY glVertexStream2svATI (GLenum, const GLshort *);
+GLAPI void APIENTRY glVertexStream2iATI (GLenum, GLint, GLint);
+GLAPI void APIENTRY glVertexStream2ivATI (GLenum, const GLint *);
+GLAPI void APIENTRY glVertexStream2fATI (GLenum, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexStream2fvATI (GLenum, const GLfloat *);
+GLAPI void APIENTRY glVertexStream2dATI (GLenum, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexStream2dvATI (GLenum, const GLdouble *);
+GLAPI void APIENTRY glVertexStream3sATI (GLenum, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glVertexStream3svATI (GLenum, const GLshort *);
+GLAPI void APIENTRY glVertexStream3iATI (GLenum, GLint, GLint, GLint);
+GLAPI void APIENTRY glVertexStream3ivATI (GLenum, const GLint *);
+GLAPI void APIENTRY glVertexStream3fATI (GLenum, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexStream3fvATI (GLenum, const GLfloat *);
+GLAPI void APIENTRY glVertexStream3dATI (GLenum, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexStream3dvATI (GLenum, const GLdouble *);
+GLAPI void APIENTRY glVertexStream4sATI (GLenum, GLshort, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glVertexStream4svATI (GLenum, const GLshort *);
+GLAPI void APIENTRY glVertexStream4iATI (GLenum, GLint, GLint, GLint, GLint);
+GLAPI void APIENTRY glVertexStream4ivATI (GLenum, const GLint *);
+GLAPI void APIENTRY glVertexStream4fATI (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glVertexStream4fvATI (GLenum, const GLfloat *);
+GLAPI void APIENTRY glVertexStream4dATI (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glVertexStream4dvATI (GLenum, const GLdouble *);
+GLAPI void APIENTRY glNormalStream3bATI (GLenum, GLbyte, GLbyte, GLbyte);
+GLAPI void APIENTRY glNormalStream3bvATI (GLenum, const GLbyte *);
+GLAPI void APIENTRY glNormalStream3sATI (GLenum, GLshort, GLshort, GLshort);
+GLAPI void APIENTRY glNormalStream3svATI (GLenum, const GLshort *);
+GLAPI void APIENTRY glNormalStream3iATI (GLenum, GLint, GLint, GLint);
+GLAPI void APIENTRY glNormalStream3ivATI (GLenum, const GLint *);
+GLAPI void APIENTRY glNormalStream3fATI (GLenum, GLfloat, GLfloat, GLfloat);
+GLAPI void APIENTRY glNormalStream3fvATI (GLenum, const GLfloat *);
+GLAPI void APIENTRY glNormalStream3dATI (GLenum, GLdouble, GLdouble, GLdouble);
+GLAPI void APIENTRY glNormalStream3dvATI (GLenum, const GLdouble *);
+GLAPI void APIENTRY glClientActiveVertexStreamATI (GLenum);
+GLAPI void APIENTRY glVertexBlendEnviATI (GLenum, GLint);
+GLAPI void APIENTRY glVertexBlendEnvfATI (GLenum, GLfloat);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1SATIPROC) (GLenum stream, GLshort x);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1IATIPROC) (GLenum stream, GLint x);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1FATIPROC) (GLenum stream, GLfloat x);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1DATIPROC) (GLenum stream, GLdouble x);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM1DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLshort x, GLshort y);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint x, GLint y);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdouble x, GLdouble y);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, const GLbyte *coords);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLshort nx, GLshort ny, GLshort nz);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint nx, GLint ny, GLint nz);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, const GLint *coords);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz);
+typedef void (APIENTRY * PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords);
+typedef void (APIENTRY * PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum stream);
+typedef void (APIENTRY * PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLfloat param);
+#endif
+
+#ifndef GL_ATI_element_array
+#define GL_ATI_element_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glElementPointerATI (GLenum, const GLvoid *);
+GLAPI void APIENTRY glDrawElementArrayATI (GLenum, GLsizei);
+GLAPI void APIENTRY glDrawRangeElementArrayATI (GLenum, GLuint, GLuint, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLELEMENTPOINTERATIPROC) (GLenum type, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsizei count);
+typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
+#endif
+
+#ifndef GL_SUN_mesh_array
+#define GL_SUN_mesh_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawMeshArraysSUN (GLenum, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLDRAWMESHARRAYSSUNPROC) (GLenum mode, GLint first, GLsizei count, GLsizei width);
+#endif
+
+#ifndef GL_SUN_slice_accum
+#define GL_SUN_slice_accum 1
+#endif
+
+#ifndef GL_NV_multisample_filter_hint
+#define GL_NV_multisample_filter_hint 1
+#endif
+
+#ifndef GL_NV_depth_clamp
+#define GL_NV_depth_clamp 1
+#endif
+
+#ifndef GL_NV_occlusion_query
+#define GL_NV_occlusion_query 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glGenOcclusionQueriesNV (GLsizei, GLuint *);
+GLAPI void APIENTRY glDeleteOcclusionQueriesNV (GLsizei, const GLuint *);
+GLAPI GLboolean APIENTRY glIsOcclusionQueryNV (GLuint);
+GLAPI void APIENTRY glBeginOcclusionQueryNV (GLuint);
+GLAPI void APIENTRY glEndOcclusionQueryNV (void);
+GLAPI void APIENTRY glGetOcclusionQueryivNV (GLuint, GLenum, GLint *);
+GLAPI void APIENTRY glGetOcclusionQueryuivNV (GLuint, GLenum, GLuint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRY * PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (APIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id);
+typedef void (APIENTRY * PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id);
+typedef void (APIENTRY * PFNGLENDOCCLUSIONQUERYNVPROC) (void);
+typedef void (APIENTRY * PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint *params);
+#endif
+
+#ifndef GL_NV_point_sprite
+#define GL_NV_point_sprite 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPointParameteriNV (GLenum, GLint);
+GLAPI void APIENTRY glPointParameterivNV (GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_NV_texture_shader3
+#define GL_NV_texture_shader3 1
+#endif
+
+#ifndef GL_NV_vertex_program1_1
+#define GL_NV_vertex_program1_1 1
+#endif
+
+#ifndef GL_EXT_shadow_funcs
+#define GL_EXT_shadow_funcs 1
+#endif
+
+#ifndef GL_EXT_stencil_two_side
+#define GL_EXT_stencil_two_side 1
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glActiveStencilFaceEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face);
 #endif
 
 
Index: xc/extras/Mesa/include/GL/glxext.h
diff -u /dev/null xc/extras/Mesa/include/GL/glxext.h:1.1.1.4
--- /dev/null	Thu Feb 27 12:15:00 2003
+++ xc/extras/Mesa/include/GL/glxext.h	Tue Oct 29 12:32:46 2002
@@ -0,0 +1,618 @@
+#ifndef __glxext_h_
+#define __glxext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+/*************************************************************/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+/* glxext.h last updated 2002/03/22 */
+/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+#define GLX_GLXEXT_VERSION 5
+
+#ifndef GLX_VERSION_1_3
+#define GLX_WINDOW_BIT                     0x00000001
+#define GLX_PIXMAP_BIT                     0x00000002
+#define GLX_PBUFFER_BIT                    0x00000004
+#define GLX_RGBA_BIT                       0x00000001
+#define GLX_COLOR_INDEX_BIT                0x00000002
+#define GLX_PBUFFER_CLOBBER_MASK           0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT          0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT         0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT           0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT          0x00000008
+#define GLX_AUX_BUFFERS_BIT                0x00000010
+#define GLX_DEPTH_BUFFER_BIT               0x00000020
+#define GLX_STENCIL_BUFFER_BIT             0x00000040
+#define GLX_ACCUM_BUFFER_BIT               0x00000080
+#define GLX_CONFIG_CAVEAT                  0x20
+#define GLX_X_VISUAL_TYPE                  0x22
+#define GLX_TRANSPARENT_TYPE               0x23
+#define GLX_TRANSPARENT_INDEX_VALUE        0x24
+#define GLX_TRANSPARENT_RED_VALUE          0x25
+#define GLX_TRANSPARENT_GREEN_VALUE        0x26
+#define GLX_TRANSPARENT_BLUE_VALUE         0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE        0x28
+#define GLX_DONT_CARE                      0xFFFFFFFF
+#define GLX_NONE                           0x8000
+#define GLX_SLOW_CONFIG                    0x8001
+#define GLX_TRUE_COLOR                     0x8002
+#define GLX_DIRECT_COLOR                   0x8003
+#define GLX_PSEUDO_COLOR                   0x8004
+#define GLX_STATIC_COLOR                   0x8005
+#define GLX_GRAY_SCALE                     0x8006
+#define GLX_STATIC_GRAY                    0x8007
+#define GLX_TRANSPARENT_RGB                0x8008
+#define GLX_TRANSPARENT_INDEX              0x8009
+#define GLX_VISUAL_ID                      0x800B
+#define GLX_SCREEN                         0x800C
+#define GLX_NON_CONFORMANT_CONFIG          0x800D
+#define GLX_DRAWABLE_TYPE                  0x8010
+#define GLX_RENDER_TYPE                    0x8011
+#define GLX_X_RENDERABLE                   0x8012
+#define GLX_FBCONFIG_ID                    0x8013
+#define GLX_RGBA_TYPE                      0x8014
+#define GLX_COLOR_INDEX_TYPE               0x8015
+#define GLX_MAX_PBUFFER_WIDTH              0x8016
+#define GLX_MAX_PBUFFER_HEIGHT             0x8017
+#define GLX_MAX_PBUFFER_PIXELS             0x8018
+#define GLX_PRESERVED_CONTENTS             0x801B
+#define GLX_LARGEST_PBUFFER                0x801C
+#define GLX_WIDTH                          0x801D
+#define GLX_HEIGHT                         0x801E
+#define GLX_EVENT_MASK                     0x801F
+#define GLX_DAMAGED                        0x8020
+#define GLX_SAVED                          0x8021
+#define GLX_WINDOW                         0x8022
+#define GLX_PBUFFER                        0x8023
+#define GLX_PBUFFER_HEIGHT                 0x8040
+#define GLX_PBUFFER_WIDTH                  0x8041
+#endif
+
+#ifndef GLX_VERSION_1_4
+#define GLX_SAMPLE_BUFFERS                 100000
+#define GLX_SAMPLES                        100001
+#endif
+
+#ifndef GLX_ARB_get_proc_address
+#endif
+
+#ifndef GLX_ARB_multisample
+#define GLX_SAMPLE_BUFFERS_ARB             100000
+#define GLX_SAMPLES_ARB                    100001
+#endif
+
+#ifndef GLX_SGIS_multisample
+#define GLX_SAMPLE_BUFFERS_SGIS            100000
+#define GLX_SAMPLES_SGIS                   100001
+#endif
+
+#ifndef GLX_EXT_visual_info
+#define GLX_X_VISUAL_TYPE_EXT              0x22
+#define GLX_TRANSPARENT_TYPE_EXT           0x23
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT    0x24
+#define GLX_TRANSPARENT_RED_VALUE_EXT      0x25
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT    0x26
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT     0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT    0x28
+#define GLX_NONE_EXT                       0x8000
+#define GLX_TRUE_COLOR_EXT                 0x8002
+#define GLX_DIRECT_COLOR_EXT               0x8003
+#define GLX_PSEUDO_COLOR_EXT               0x8004
+#define GLX_STATIC_COLOR_EXT               0x8005
+#define GLX_GRAY_SCALE_EXT                 0x8006
+#define GLX_STATIC_GRAY_EXT                0x8007
+#define GLX_TRANSPARENT_RGB_EXT            0x8008
+#define GLX_TRANSPARENT_INDEX_EXT          0x8009
+#endif
+
+#ifndef GLX_SGI_swap_control
+#endif
+
+#ifndef GLX_SGI_video_sync
+#endif
+
+#ifndef GLX_SGI_make_current_read
+#endif
+
+#ifndef GLX_SGIX_video_source
+#endif
+
+#ifndef GLX_EXT_visual_rating
+#define GLX_VISUAL_CAVEAT_EXT              0x20
+#define GLX_SLOW_VISUAL_EXT                0x8001
+#define GLX_NON_CONFORMANT_VISUAL_EXT      0x800D
+/* reuse GLX_NONE_EXT */
+#endif
+
+#ifndef GLX_EXT_import_context
+#define GLX_SHARE_CONTEXT_EXT              0x800A
+#define GLX_VISUAL_ID_EXT                  0x800B
+#define GLX_SCREEN_EXT                     0x800C
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+#define GLX_WINDOW_BIT_SGIX                0x00000001
+#define GLX_PIXMAP_BIT_SGIX                0x00000002
+#define GLX_RGBA_BIT_SGIX                  0x00000001
+#define GLX_COLOR_INDEX_BIT_SGIX           0x00000002
+#define GLX_DRAWABLE_TYPE_SGIX             0x8010
+#define GLX_RENDER_TYPE_SGIX               0x8011
+#define GLX_X_RENDERABLE_SGIX              0x8012
+#define GLX_FBCONFIG_ID_SGIX               0x8013
+#define GLX_RGBA_TYPE_SGIX                 0x8014
+#define GLX_COLOR_INDEX_TYPE_SGIX          0x8015
+/* reuse GLX_SCREEN_EXT */
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+#define GLX_PBUFFER_BIT_SGIX               0x00000004
+#define GLX_BUFFER_CLOBBER_MASK_SGIX       0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX     0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX    0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT_SGIX      0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX     0x00000008
+#define GLX_AUX_BUFFERS_BIT_SGIX           0x00000010
+#define GLX_DEPTH_BUFFER_BIT_SGIX          0x00000020
+#define GLX_STENCIL_BUFFER_BIT_SGIX        0x00000040
+#define GLX_ACCUM_BUFFER_BIT_SGIX          0x00000080
+#define GLX_SAMPLE_BUFFERS_BIT_SGIX        0x00000100
+#define GLX_MAX_PBUFFER_WIDTH_SGIX         0x8016
+#define GLX_MAX_PBUFFER_HEIGHT_SGIX        0x8017
+#define GLX_MAX_PBUFFER_PIXELS_SGIX        0x8018
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX     0x8019
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX    0x801A
+#define GLX_PRESERVED_CONTENTS_SGIX        0x801B
+#define GLX_LARGEST_PBUFFER_SGIX           0x801C
+#define GLX_WIDTH_SGIX                     0x801D
+#define GLX_HEIGHT_SGIX                    0x801E
+#define GLX_EVENT_MASK_SGIX                0x801F
+#define GLX_DAMAGED_SGIX                   0x8020
+#define GLX_SAVED_SGIX                     0x8021
+#define GLX_WINDOW_SGIX                    0x8022
+#define GLX_PBUFFER_SGIX                   0x8023
+#endif
+
+#ifndef GLX_SGI_cushion
+#endif
+
+#ifndef GLX_SGIX_video_resize
+#define GLX_SYNC_FRAME_SGIX                0x00000000
+#define GLX_SYNC_SWAP_SGIX                 0x00000001
+#endif
+
+#ifndef GLX_SGIX_dmbuffer
+#define GLX_DIGITAL_MEDIA_PBUFFER_SGIX     0x8024
+#endif
+
+#ifndef GLX_SGIX_swap_group
+#endif
+
+#ifndef GLX_SGIX_swap_barrier
+#endif
+
+#ifndef GLX_SGIS_blended_overlay
+#define GLX_BLENDED_RGBA_SGIS              0x8025
+#endif
+
+#ifndef GLX_SGIS_shared_multisample
+#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026
+#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027
+#endif
+
+#ifndef GLX_SUN_get_transparent_index
+#endif
+
+#ifndef GLX_3DFX_multisample
+#define GLX_SAMPLE_BUFFERS_3DFX            0x8050
+#define GLX_SAMPLES_3DFX                   0x8051
+#endif
+
+#ifndef GLX_MESA_copy_sub_buffer
+#endif
+
+#ifndef GLX_MESA_pixmap_colormap
+#endif
+
+#ifndef GLX_MESA_release_buffers
+#endif
+
+#ifndef GLX_MESA_agp_offset
+#endif
+
+#ifndef GLX_MESA_set_3dfx_mode
+#define GLX_3DFX_WINDOW_MODE_MESA          0x1
+#define GLX_3DFX_FULLSCREEN_MODE_MESA      0x2
+#endif
+
+#ifndef GLX_SGIX_visual_select_group
+#define GLX_VISUAL_SELECT_GROUP_SGIX       0x8028
+#endif
+
+#ifndef GLX_OML_swap_method
+#define GLX_SWAP_METHOD_OML                0x8060
+#define GLX_SWAP_EXCHANGE_OML              0x8061
+#define GLX_SWAP_COPY_OML                  0x8062
+#define GLX_SWAP_UNDEFINED_OML             0x8063
+#endif
+
+#ifndef GLX_OML_sync_control
+#endif
+
+
+/*************************************************************/
+
+#ifndef GLX_ARB_get_proc_address
+typedef void (*__GLXextFuncPtr)(void);
+#endif
+
+#ifndef GLX_SGIX_video_source
+typedef XID GLXVideoSourceSGIX;
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+typedef XID GLXFBConfigIDSGIX;
+typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+typedef XID GLXPbufferSGIX;
+typedef struct {
+    int type;
+    unsigned long serial;	  /* # of last request processed by server */
+    Bool send_event;		  /* true if this came for SendEvent request */
+    Display *display;		  /* display the event was read from */
+    GLXDrawable drawable;	  /* i.d. of Drawable */
+    int event_type;		  /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
+    int draw_type;		  /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
+    unsigned int mask;	  /* mask indicating which buffers are affected*/
+    int x, y;
+    int width, height;
+    int count;		  /* if nonzero, at least this many more */
+} GLXBufferClobberEventSGIX;
+#endif
+
+#ifndef GLX_VERSION_1_3
+#define GLX_VERSION_1_3 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXFBConfig * glXGetFBConfigs (Display *, int, int *);
+extern GLXFBConfig * glXChooseFBConfig (Display *, int, const int *, int *);
+extern int glXGetFBConfigAttrib (Display *, GLXFBConfig, int, int *);
+extern XVisualInfo * glXGetVisualFromFBConfig (Display *, GLXFBConfig);
+extern GLXWindow glXCreateWindow (Display *, GLXFBConfig, Window, const int *);
+extern void glXDestroyWindow (Display *, GLXWindow);
+extern GLXPixmap glXCreatePixmap (Display *, GLXFBConfig, Pixmap, const int *);
+extern void glXDestroyPixmap (Display *, GLXPixmap);
+extern GLXPbuffer glXCreatePbuffer (Display *, GLXFBConfig, const int *);
+extern void glXDestroyPbuffer (Display *, GLXPbuffer);
+extern void glXQueryDrawable (Display *, GLXDrawable, int, unsigned int *);
+extern GLXContext glXCreateNewContext (Display *, GLXFBConfig, int, GLXContext, Bool);
+extern Bool glXMakeContextCurrent (Display *, GLXDrawable, GLXDrawable, GLXContext);
+extern GLXDrawable glXGetCurrentReadDrawable (void);
+extern Display * glXGetCurrentDisplay (void);
+extern int glXQueryContext (Display *, GLXContext, int, int *);
+extern void glXSelectEvent (Display *, GLXDrawable, unsigned long);
+extern void glXGetSelectedEvent (Display *, GLXDrawable, unsigned long *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXFBConfig * ( * PFNGLXGETFBCONFIGSPROC) (Display *dpy, int screen, int *nelements);
+typedef GLXFBConfig * ( * PFNGLXCHOOSEFBCONFIGPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements);
+typedef int ( * PFNGLXGETFBCONFIGATTRIBPROC) (Display *dpy, GLXFBConfig config, int attribute, int *value);
+typedef XVisualInfo * ( * PFNGLXGETVISUALFROMFBCONFIGPROC) (Display *dpy, GLXFBConfig config);
+typedef GLXWindow ( * PFNGLXCREATEWINDOWPROC) (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
+typedef void ( * PFNGLXDESTROYWINDOWPROC) (Display *dpy, GLXWindow win);
+typedef GLXPixmap ( * PFNGLXCREATEPIXMAPPROC) (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
+typedef void ( * PFNGLXDESTROYPIXMAPPROC) (Display *dpy, GLXPixmap pixmap);
+typedef GLXPbuffer ( * PFNGLXCREATEPBUFFERPROC) (Display *dpy, GLXFBConfig config, const int *attrib_list);
+typedef void ( * PFNGLXDESTROYPBUFFERPROC) (Display *dpy, GLXPbuffer pbuf);
+typedef void ( * PFNGLXQUERYDRAWABLEPROC) (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+typedef GLXContext ( * PFNGLXCREATENEWCONTEXTPROC) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
+typedef Bool ( * PFNGLXMAKECONTEXTCURRENTPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+typedef GLXDrawable ( * PFNGLXGETCURRENTREADDRAWABLEPROC) (void);
+typedef Display * ( * PFNGLXGETCURRENTDISPLAYPROC) (void);
+typedef int ( * PFNGLXQUERYCONTEXTPROC) (Display *dpy, GLXContext ctx, int attribute, int *value);
+typedef void ( * PFNGLXSELECTEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long event_mask);
+typedef void ( * PFNGLXGETSELECTEDEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long *event_mask);
+#endif
+
+#ifndef GLX_VERSION_1_4
+#define GLX_VERSION_1_4 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern __GLXextFuncPtr glXGetProcAddress (const GLubyte *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef __GLXextFuncPtr ( * PFNGLXGETPROCADDRESSPROC) (const GLubyte *procName);
+#endif
+
+#ifndef GLX_ARB_get_proc_address
+#define GLX_ARB_get_proc_address 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern __GLXextFuncPtr glXGetProcAddressARB (const GLubyte *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef __GLXextFuncPtr ( * PFNGLXGETPROCADDRESSARBPROC) (const GLubyte *procName);
+#endif
+
+#ifndef GLX_ARB_multisample
+#define GLX_ARB_multisample 1
+#endif
+
+#ifndef GLX_SGIS_multisample
+#define GLX_SGIS_multisample 1
+#endif
+
+#ifndef GLX_EXT_visual_info
+#define GLX_EXT_visual_info 1
+#endif
+
+#ifndef GLX_SGI_swap_control
+#define GLX_SGI_swap_control 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXSwapIntervalSGI (int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int ( * PFNGLXSWAPINTERVALSGIPROC) (int interval);
+#endif
+
+#ifndef GLX_SGI_video_sync
+#define GLX_SGI_video_sync 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetVideoSyncSGI (unsigned int *);
+extern int glXWaitVideoSyncSGI (int, int, unsigned int *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int ( * PFNGLXGETVIDEOSYNCSGIPROC) (unsigned int *count);
+typedef int ( * PFNGLXWAITVIDEOSYNCSGIPROC) (int divisor, int remainder, unsigned int *count);
+#endif
+
+#ifndef GLX_SGI_make_current_read
+#define GLX_SGI_make_current_read 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXMakeCurrentReadSGI (Display *, GLXDrawable, GLXDrawable, GLXContext);
+extern GLXDrawable glXGetCurrentReadDrawableSGI (void);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool ( * PFNGLXMAKECURRENTREADSGIPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+typedef GLXDrawable ( * PFNGLXGETCURRENTREADDRAWABLESGIPROC) (void);
+#endif
+
+#ifdef _VL_H
+#ifndef GLX_SGIX_video_source
+#define GLX_SGIX_video_source 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX (Display *, int, VLServer, VLPath, int, VLNode);
+extern void glXDestroyGLXVideoSourceSGIX (Display *, GLXVideoSourceSGIX);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXVideoSourceSGIX ( * PFNGLXCREATEGLXVIDEOSOURCESGIXPROC) (Display *display, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode);
+typedef void ( * PFNGLXDESTROYGLXVIDEOSOURCESGIXPROC) (Display *dpy, GLXVideoSourceSGIX glxvideosource);
+#endif
+
+#endif /* _VL_H */
+#ifndef GLX_EXT_visual_rating
+#define GLX_EXT_visual_rating 1
+#endif
+
+#ifndef GLX_EXT_import_context
+#define GLX_EXT_import_context 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Display * glXGetCurrentDisplayEXT (void);
+extern int glXQueryContextInfoEXT (Display *, GLXContext, int, int *);
+extern GLXContextID glXGetContextIDEXT (const GLXContext);
+extern GLXContext glXImportContextEXT (Display *, GLXContextID);
+extern void glXFreeContextEXT (Display *, GLXContext);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Display * ( * PFNGLXGETCURRENTDISPLAYEXTPROC) (void);
+typedef int ( * PFNGLXQUERYCONTEXTINFOEXTPROC) (Display *dpy, GLXContext context, int attribute, int *value);
+typedef GLXContextID ( * PFNGLXGETCONTEXTIDEXTPROC) (const GLXContext context);
+typedef GLXContext ( * PFNGLXIMPORTCONTEXTEXTPROC) (Display *dpy, GLXContextID contextID);
+typedef void ( * PFNGLXFREECONTEXTEXTPROC) (Display *dpy, GLXContext context);
+#endif
+
+#ifndef GLX_SGIX_fbconfig
+#define GLX_SGIX_fbconfig 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXGetFBConfigAttribSGIX (Display *, GLXFBConfigSGIX, int, int *);
+extern GLXFBConfigSGIX * glXChooseFBConfigSGIX (Display *, int, int *, int *);
+extern GLXPixmap glXCreateGLXPixmapWithConfigSGIX (Display *, GLXFBConfigSGIX, Pixmap);
+extern GLXContext glXCreateContextWithConfigSGIX (Display *, GLXFBConfigSGIX, int, GLXContext, Bool);
+extern XVisualInfo * glXGetVisualFromFBConfigSGIX (Display *, GLXFBConfigSGIX);
+extern GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX (Display *, XVisualInfo *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int ( * PFNGLXGETFBCONFIGATTRIBSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
+typedef GLXFBConfigSGIX * ( * PFNGLXCHOOSEFBCONFIGSGIXPROC) (Display *dpy, int screen, int *attrib_list, int *nelements);
+typedef GLXPixmap ( * PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
+typedef GLXContext ( * PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
+typedef XVisualInfo * ( * PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config);
+typedef GLXFBConfigSGIX ( * PFNGLXGETFBCONFIGFROMVISUALSGIXPROC) (Display *dpy, XVisualInfo *vis);
+#endif
+
+#ifndef GLX_SGIX_pbuffer
+#define GLX_SGIX_pbuffer 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXPbufferSGIX glXCreateGLXPbufferSGIX (Display *, GLXFBConfigSGIX, unsigned int, unsigned int, int *);
+extern void glXDestroyGLXPbufferSGIX (Display *, GLXPbufferSGIX);
+extern int glXQueryGLXPbufferSGIX (Display *, GLXPbufferSGIX, int, unsigned int *);
+extern void glXSelectEventSGIX (Display *, GLXDrawable, unsigned long);
+extern void glXGetSelectedEventSGIX (Display *, GLXDrawable, unsigned long *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXPbufferSGIX ( * PFNGLXCREATEGLXPBUFFERSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
+typedef void ( * PFNGLXDESTROYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf);
+typedef int ( * PFNGLXQUERYGLXPBUFFERSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
+typedef void ( * PFNGLXSELECTEVENTSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long mask);
+typedef void ( * PFNGLXGETSELECTEDEVENTSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long *mask);
+#endif
+
+#ifndef GLX_SGI_cushion
+#define GLX_SGI_cushion 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXCushionSGI (Display *, Window, float);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void ( * PFNGLXCUSHIONSGIPROC) (Display *dpy, Window window, float cushion);
+#endif
+
+#ifndef GLX_SGIX_video_resize
+#define GLX_SGIX_video_resize 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern int glXBindChannelToWindowSGIX (Display *, int, int, Window);
+extern int glXChannelRectSGIX (Display *, int, int, int, int, int, int);
+extern int glXQueryChannelRectSGIX (Display *, int, int, int *, int *, int *, int *);
+extern int glXQueryChannelDeltasSGIX (Display *, int, int, int *, int *, int *, int *);
+extern int glXChannelRectSyncSGIX (Display *, int, int, GLenum);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef int ( * PFNGLXBINDCHANNELTOWINDOWSGIXPROC) (Display *display, int screen, int channel, Window window);
+typedef int ( * PFNGLXCHANNELRECTSGIXPROC) (Display *display, int screen, int channel, int x, int y, int w, int h);
+typedef int ( * PFNGLXQUERYCHANNELRECTSGIXPROC) (Display *display, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
+typedef int ( * PFNGLXQUERYCHANNELDELTASSGIXPROC) (Display *display, int screen, int channel, int *x, int *y, int *w, int *h);
+typedef int ( * PFNGLXCHANNELRECTSYNCSGIXPROC) (Display *display, int screen, int channel, GLenum synctype);
+#endif
+
+#ifdef _DM_BUFFER_H_
+#ifndef GLX_SGIX_dmbuffer
+#define GLX_SGIX_dmbuffer 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXAssociateDMPbufferSGIX (Display *, GLXPbufferSGIX, DMparams *, DMbuffer);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool ( * PFNGLXASSOCIATEDMPBUFFERSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer);
+#endif
+
+#endif /* _DM_BUFFER_H_ */
+#ifndef GLX_SGIX_swap_group
+#define GLX_SGIX_swap_group 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXJoinSwapGroupSGIX (Display *, GLXDrawable, GLXDrawable);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void ( * PFNGLXJOINSWAPGROUPSGIXPROC) (Display *dpy, GLXDrawable drawable, GLXDrawable member);
+#endif
+
+#ifndef GLX_SGIX_swap_barrier
+#define GLX_SGIX_swap_barrier 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXBindSwapBarrierSGIX (Display *, GLXDrawable, int);
+extern Bool glXQueryMaxSwapBarriersSGIX (Display *, int, int *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void ( * PFNGLXBINDSWAPBARRIERSGIXPROC) (Display *dpy, GLXDrawable drawable, int barrier);
+typedef Bool ( * PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) (Display *dpy, int screen, int *max);
+#endif
+
+#ifndef GLX_SUN_get_transparent_index
+#define GLX_SUN_get_transparent_index 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Status glXGetTransparentIndexSUN (Display *, Window, Window, long *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Status ( * PFNGLXGETTRANSPARENTINDEXSUNPROC) (Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
+#endif
+
+#ifndef GLX_MESA_copy_sub_buffer
+#define GLX_MESA_copy_sub_buffer 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern void glXCopySubBufferMESA (Display *, GLXDrawable, int, int, int, int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef void ( * PFNGLXCOPYSUBBUFFERMESAPROC) (Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
+#endif
+
+#ifndef GLX_MESA_pixmap_colormap
+#define GLX_MESA_pixmap_colormap 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLXPixmap glXCreateGLXPixmapMESA (Display *, XVisualInfo *, Pixmap, Colormap);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLXPixmap ( * PFNGLXCREATEGLXPIXMAPMESAPROC) (Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
+#endif
+
+#ifndef GLX_MESA_release_buffers
+#define GLX_MESA_release_buffers 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXReleaseBuffersMESA (Display *, GLXDrawable);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool ( * PFNGLXRELEASEBUFFERSMESAPROC) (Display *dpy, GLXDrawable drawable);
+#endif
+
+#ifndef GLX_MESA_set_3dfx_mode
+#define GLX_MESA_set_3dfx_mode 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXSet3DfxModeMESA (int);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool ( * PFNGLXSET3DFXMODEMESAPROC) (int mode);
+#endif
+
+#ifndef GLX_MESA_agp_offset
+#define GLX_MESA_agp_offset 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern GLuint glXGetAGPOffsetMESA (const GLvoid *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef GLuint ( * PFNGLXGETAGPOFFSETMESAPROC) (const GLvoid *);
+#endif
+
+#ifndef GLX_SGIX_visual_select_group
+#define GLX_SGIX_visual_select_group 1
+#endif
+
+#ifndef GLX_OML_swap_method
+#define GLX_OML_swap_method 1
+#endif
+
+#if defined(__STDC_VERSION__)
+#if __STDC_VERSION__ >= 199901L
+/* Include ISO C99 integer types for OML_sync_control; need a better test */
+#include <inttypes.h>
+
+#ifndef GLX_OML_sync_control
+#define GLX_OML_sync_control 1
+#ifdef GLX_GLXEXT_PROTOTYPES
+extern Bool glXGetSyncValuesOML (Display *, GLXDrawable, int64_t *, int64_t *, int64_t *);
+extern Bool glXGetMscRateOML (Display *, GLXDrawable, int32_t *, int32_t *);
+extern int64_t glXSwapBuffersMscOML (Display *, GLXDrawable, int64_t, int64_t, int64_t);
+extern Bool glXWaitForMscOML (Display *, GLXDrawable, int64_t, int64_t, int64_t, int64_t *, int64_t *, int64_t *);
+extern Bool glXWaitForSbcOML (Display *, GLXDrawable, int64_t, int64_t *, int64_t *, int64_t *);
+#endif /* GLX_GLXEXT_PROTOTYPES */
+typedef Bool ( * PFNGLXGETSYNCVALUESOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool ( * PFNGLXGETMSCRATEOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
+typedef int64_t ( * PFNGLXSWAPBUFFERSMSCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
+typedef Bool ( * PFNGLXWAITFORMSCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool ( * PFNGLXWAITFORSBCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
+#endif
+
+#endif /* C99 version test */
+#endif /* STDC test */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
Index: xc/extras/Mesa/include/GL/osmesa.h
diff -u xc/extras/Mesa/include/GL/osmesa.h:1.3 xc/extras/Mesa/include/GL/osmesa.h:1.5
--- xc/extras/Mesa/include/GL/osmesa.h:1.3	Sat Oct 27 23:32:06 2001
+++ xc/extras/Mesa/include/GL/osmesa.h	Mon Sep  9 17:29:28 2002
@@ -1,9 +1,8 @@
-/* $XFree86: xc/extras/Mesa/include/GL/osmesa.h,v 1.3 2001/10/28 03:32:06 tsi Exp $ */
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  4.0.3
  * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -61,8 +60,9 @@
 #include <GL/gl.h>
 
 
-#define OSMESA_MAJOR_VERSION 3
-#define OSMESA_MINOR_VERSION 3
+#define OSMESA_MAJOR_VERSION 4
+#define OSMESA_MINOR_VERSION 0
+#define OSMESA_PATCH_VERSION 3
 
 
 
@@ -76,6 +76,7 @@
 #define OSMESA_ARGB		0x2
 #define OSMESA_RGB		GL_RGB
 #define OSMESA_BGR		0x4
+#define OSMESA_RGB_565		0x5
 
 
 /*
@@ -93,6 +94,8 @@
 #define OSMESA_HEIGHT		0x21
 #define OSMESA_FORMAT		0x22
 #define OSMESA_TYPE		0x23
+#define OSMESA_MAX_WIDTH	0x24  /* new in 4.0 */
+#define OSMESA_MAX_HEIGHT	0x25  /* new in 4.0 */
 
 
 typedef struct osmesa_context *OSMesaContext;
@@ -113,18 +116,31 @@
  *                     display lists.  NULL indicates no sharing.
  * Return:  an OSMesaContext or 0 if error
  */
-GLAPI OSMesaContext GLAPIENTRY OSMesaCreateContext( GLenum format,
-                                                    OSMesaContext sharelist );
+GLAPI OSMesaContext GLAPIENTRY
+OSMesaCreateContext( GLenum format, OSMesaContext sharelist );
 
 
 
+/*
+ * Create an Off-Screen Mesa rendering context and specify desired
+ * size of depth buffer, stencil buffer and accumulation buffer.
+ * If you specify zero for depthBits, stencilBits, accumBits you
+ * can save some memory.
+ *
+ * New in Mesa 3.5
+ */
+GLAPI OSMesaContext GLAPIENTRY
+OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
+                        GLint accumBits, OSMesaContext sharelist);
 
+
 /*
  * Destroy an Off-Screen Mesa rendering context.
  *
  * Input:  ctx - the context to destroy
  */
-GLAPI void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx );
+GLAPI void GLAPIENTRY
+OSMesaDestroyContext( OSMesaContext ctx );
 
 
 
@@ -155,9 +171,9 @@
  *          invalid buffer address, type!=GL_UNSIGNED_BYTE, width<1, height<1,
  *          width>internal limit or height>internal limit.
  */
-GLAPI GLboolean GLAPIENTRY OSMesaMakeCurrent( OSMesaContext ctx,
-                                              void *buffer, GLenum type,
-                                              GLsizei width, GLsizei height );
+GLAPI GLboolean GLAPIENTRY
+OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type,
+                   GLsizei width, GLsizei height );
 
 
 
@@ -165,7 +181,8 @@
 /*
  * Return the current Off-Screen Mesa rendering context handle.
  */
-GLAPI OSMesaContext GLAPIENTRY OSMesaGetCurrentContext( void );
+GLAPI OSMesaContext GLAPIENTRY
+OSMesaGetCurrentContext( void );
 
 
 
@@ -182,7 +199,8 @@
  *
  * New in version 2.0.
  */
-GLAPI void GLAPIENTRY OSMesaPixelStore( GLint pname, GLint value );
+GLAPI void GLAPIENTRY
+OSMesaPixelStore( GLint pname, GLint value );
 
 
 
@@ -197,7 +215,8 @@
  *                 OSMESA_Y_UP returns 1 or 0 to indicate Y axis direction
  *         value - pointer to integer in which to return result.
  */
-GLAPI void GLAPIENTRY OSMesaGetIntegerv( GLint pname, GLint *value );
+GLAPI void GLAPIENTRY
+OSMesaGetIntegerv( GLint pname, GLint *value );
 
 
 
@@ -211,10 +230,10 @@
  *
  * New in Mesa 2.4.
  */
-GLAPI GLboolean GLAPIENTRY OSMesaGetDepthBuffer( OSMesaContext c,
-                                                 GLint *width, GLint *height,
-                                                 GLint *bytesPerValue,
-                                                 void **buffer );
+GLAPI GLboolean GLAPIENTRY
+OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint *height,
+                      GLint *bytesPerValue, void **buffer );
+
 
 
 /*
@@ -227,10 +246,10 @@
  *
  * New in Mesa 3.3.
  */
-GLAPI GLboolean GLAPIENTRY OSMesaGetColorBuffer( OSMesaContext c,
-                                                 GLint *width, GLint *height,
-                                                 GLint *format,
-                                                 void **buffer );
+GLAPI GLboolean GLAPIENTRY
+OSMesaGetColorBuffer( OSMesaContext c, GLint *width, GLint *height,
+                      GLint *format, void **buffer );
+
 
 
 #if defined(__BEOS__) || defined(__QUICKDRAW__)
Index: xc/extras/Mesa/include/GL/vms_x_fix.h
diff -u xc/extras/Mesa/include/GL/vms_x_fix.h:1.1.1.1 xc/extras/Mesa/include/GL/vms_x_fix.h:removed
--- xc/extras/Mesa/include/GL/vms_x_fix.h:1.1.1.1	Tue Mar 20 21:37:09 2001
+++ xc/extras/Mesa/include/GL/vms_x_fix.h	Thu Feb 27 12:15:01 2003
@@ -1,880 +0,0 @@
-/***************************************************************************
- *                                                                         *
- * Repair definitions of Xlib when compileing with /name=(as_is) on VMS    *
- *                                                                         *
- * Author : Jouk Jansen (joukj@hrem.stm.tudelft.nl)                        *
- *                                                                         *
- * Last revision : 22 August 2000                                          *
- *                                                                         *
- ***************************************************************************/
-
-#ifndef VMS_X_FIX
-#define VMS_X_FIX
-
-#define _XRegisterFilterByType _XREGISTERFILTERBYTYPE 
-#define XAllocClassHint XALLOCCLASSHINT
-#define XAllocColor XALLOCCOLOR
-#define XAllocColorCells XALLOCCOLORCELLS
-#define XAllocSizeHints XALLOCSIZEHINTS
-#define XAllocWMHints XALLOCWMHINTS
-#define XAutoRepeatOff XAUTOREPEATOFF
-#define XAutoRepeatOn XAUTOREPEATON
-#define XBaseFontNameListOfFontSet XBASEFONTNAMELISTOFFONTSET
-#define XBell XBELL
-#define XBitmapPad XBITMAPPAD
-#define XChangeActivePointerGrab XCHANGEACTIVEPOINTERGRAB
-#define XChangeGC XCHANGEGC
-#define XChangeProperty XCHANGEPROPERTY
-#define XChangeWindowAttributes XCHANGEWINDOWATTRIBUTES
-#define XCheckIfEvent XCHECKIFEVENT
-#define XCheckMaskEvent XCHECKMASKEVENT
-#define XCheckTypedWindowEvent XCHECKTYPEDWINDOWEVENT
-#define XCheckWindowEvent XCHECKWINDOWEVENT
-#define XClearArea XCLEARAREA
-#define XClearWindow XCLEARWINDOW
-#define XClipBox XCLIPBOX
-#define XCloseDisplay XCLOSEDISPLAY
-#define XCloseIM XCLOSEIM
-#define XConfigureWindow XCONFIGUREWINDOW
-#define XConvertSelection XCONVERTSELECTION
-#define XCopyArea XCOPYAREA
-#define XCopyGC XCOPYGC
-#define XCopyPlane XCOPYPLANE
-#define XCreateBitmapFromData XCREATEBITMAPFROMDATA
-#define XCreateColormap XCREATECOLORMAP
-#define XCreateFontCursor XCREATEFONTCURSOR
-#define XCreateFontSet XCREATEFONTSET
-#define XCreateGC XCREATEGC
-#define XCreateIC XCREATEIC
-#define XCreateImage XCREATEIMAGE
-#define XCreatePixmap XCREATEPIXMAP
-#define XCreatePixmapCursor XCREATEPIXMAPCURSOR
-#define XCreatePixmapFromBitmapData XCREATEPIXMAPFROMBITMAPDATA
-#define XCreateRegion XCREATEREGION
-#define XCreateSimpleWindow XCREATESIMPLEWINDOW
-#define XCreateWindow XCREATEWINDOW
-#define XDefaultScreenOfDisplay XDEFAULTSCREENOFDISPLAY
-#define XDefineCursor XDEFINECURSOR
-#define XDeleteProperty XDELETEPROPERTY
-#define XDestroyIC XDESTROYIC
-#define XDestroyRegion XDESTROYREGION
-#define XDestroyWindow XDESTROYWINDOW
-#define XDisplayName XDISPLAYNAME
-#define XDisplayOfScreen XDISPLAYOFSCREEN
-#define XDrawArc XDRAWARC
-#define XDrawImageString XDRAWIMAGESTRING
-#define XDrawImageString16 XDRAWIMAGESTRING16
-#define XDrawLine XDRAWLINE
-#define XDrawLines XDRAWLINES
-#define XDrawPoint XDRAWPOINT
-#define XDrawPoints XDRAWPOINTS
-#define XDrawRectangle XDRAWRECTANGLE
-#define XDrawSegments XDRAWSEGMENTS
-#define XDrawString XDRAWSTRING
-#define XDrawString16 XDRAWSTRING16
-#define XEmptyRegion XEMPTYREGION
-#define XEqualRegion XEQUALREGION
-#define XEventsQueued XEVENTSQUEUED
-#define XExtentsOfFontSet XEXTENTSOFFONTSET
-#define XFillArc XFILLARC
-#define XFillPolygon XFILLPOLYGON
-#define XFillRectangle XFILLRECTANGLE
-#define XFillRectangles XFILLRECTANGLES
-#define XFilterEvent XFILTEREVENT
-#define XFlush XFLUSH
-#define XFontsOfFontSet XFONTSOFFONTSET
-#define XFree XFREE
-#define XFreeColormap XFREECOLORMAP
-#define XFreeColors XFREECOLORS
-#define XFreeCursor XFREECURSOR
-#define XFreeFont XFREEFONT
-#define XFreeFontInfo XFREEFONTINFO
-#define XFreeFontNames XFREEFONTNAMES
-#define XFreeFontSet XFREEFONTSET
-#define XFreeGC XFREEGC
-#define XFreeModifiermap XFREEMODIFIERMAP
-#define XFreePixmap XFREEPIXMAP
-#define XFreeStringList XFREESTRINGLIST
-#define XGetAtomName XGETATOMNAME
-#define XGetDefault XGETDEFAULT
-#define XGetErrorDatabaseText XGETERRORDATABASETEXT
-#define XGetErrorText XGETERRORTEXT
-#define XGetFontProperty XGETFONTPROPERTY
-#define XGetGCValues XGETGCVALUES
-#define XGetGeometry XGETGEOMETRY
-#define XGetICValues XGETICVALUES
-#define XGetIMValues XGETIMVALUES
-#define XGetImage XGETIMAGE
-#define XGetKeyboardControl XGETKEYBOARDCONTROL
-#define XGetModifierMapping XGETMODIFIERMAPPING
-#define XGetMotionEvents XGETMOTIONEVENTS
-#define XGetNormalHints XGETNORMALHINTS
-#define XGetSelectionOwner XGETSELECTIONOWNER
-#define XGetSubImage XGETSUBIMAGE
-#define XGetVisualInfo XGETVISUALINFO
-#define XGetWMColormapWindows XGETWMCOLORMAPWINDOWS
-#define XGetWMHints XGETWMHINTS
-#define XGetWMName XGETWMNAME
-#define XGetWMNormalHints XGETWMNORMALHINTS
-#define XGetWindowAttributes XGETWINDOWATTRIBUTES
-#define XGetWindowProperty XGETWINDOWPROPERTY
-#define XGrabKeyboard XGRABKEYBOARD
-#define XGrabPointer XGRABPOINTER
-#define XGrabServer XGRABSERVER
-#define XHeightOfScreen XHEIGHTOFSCREEN
-#define XIfEvent XIFEVENT
-#define XInternAtom XINTERNATOM
-#define XIntersectRegion XINTERSECTREGION
-#define XKeycodeToKeysym XKEYCODETOKEYSYM
-#define XKeysymToKeycode XKEYSYMTOKEYCODE
-#define XKeysymToString XKEYSYMTOSTRING
-#define XListFonts XLISTFONTS
-#define XListFontsWithInfo XLISTFONTSWITHINFO
-#define XListPixmapFormats XLISTPIXMAPFORMATS
-#define XListProperties XLISTPROPERTIES
-#define XLoadQueryFont XLOADQUERYFONT
-#define XLookupString XLOOKUPSTRING
-#define XLowerWindow XLOWERWINDOW
-#define XMapRaised XMAPRAISED
-#define XMapWindow XMAPWINDOW
-#define XMatchVisualInfo XMATCHVISUALINFO
-#define XMoveResizeWindow XMOVERESIZEWINDOW
-#define XMoveWindow XMOVEWINDOW
-#define XNextEvent XNEXTEVENT
-#define XOffsetRegion XOFFSETREGION
-#define XOpenDisplay XOPENDISPLAY
-#define XOpenIM XOPENIM
-#define XParseColor XPARSECOLOR
-#define XParseGeometry XPARSEGEOMETRY
-#define XPeekEvent XPEEKEVENT
-#define XPending XPENDING
-#define XPointInRegion XPOINTINREGION
-#define XPolygonRegion XPOLYGONREGION
-#define XPutBackEvent XPUTBACKEVENT
-#define XPutImage XPUTIMAGE
-#define XQueryColor XQUERYCOLOR
-#define XQueryColors XQUERYCOLORS
-#define XQueryExtension XQUERYEXTENSION
-#define XQueryPointer XQUERYPOINTER
-#define XQueryTree XQUERYTREE
-#define XRaiseWindow XRAISEWINDOW
-#define XReconfigureWMWindow XRECONFIGUREWMWINDOW
-#define XRectInRegion XRECTINREGION
-#define XRefreshKeyboardMapping XREFRESHKEYBOARDMAPPING
-#define XReparentWindow XREPARENTWINDOW
-#define XResizeWindow XRESIZEWINDOW
-#define XRestackWindows XRESTACKWINDOWS
-#define XRootWindowOfScreen XROOTWINDOWOFSCREEN
-#define XScreenNumberOfScreen XSCREENNUMBEROFSCREEN
-#define XSelectAsyncEvent XSELECTASYNCEVENT
-#define XSelectAsyncInput XSELECTASYNCINPUT
-#define XSelectInput XSELECTINPUT
-#define XSendEvent XSENDEVENT
-#define XServerVendor XSERVERVENDOR
-#define XSetBackground XSETBACKGROUND
-#define XSetClassHint XSETCLASSHINT
-#define XSetClipMask XSETCLIPMASK
-#define XSetClipOrigin XSETCLIPORIGIN
-#define XSetClipRectangles XSETCLIPRECTANGLES
-#define XSetCloseDownMode XSETCLOSEDOWNMODE
-#define XSetCommand XSETCOMMAND
-#define XSetDashes XSETDASHES
-#define XSetErrorHandler XSETERRORHANDLER
-#define XSetFillStyle XSETFILLSTYLE
-#define XSetFont XSETFONT
-#define XSetForeground XSETFOREGROUND
-#define XSetFunction XSETFUNCTION
-#define XSetGraphicsExposures XSETGRAPHICSEXPOSURES
-#define XSetICFocus XSETICFOCUS
-#define XSetICValues XSETICVALUES
-#define XSetIOErrorHandler XSETIOERRORHANDLER
-#define XSetInputFocus XSETINPUTFOCUS
-#define XSetLineAttributes XSETLINEATTRIBUTES
-#define XSetLocaleModifiers XSETLOCALEMODIFIERS
-#define XSetNormalHints XSETNORMALHINTS
-#define XSetRegion XSETREGION
-#define XSetSelectionOwner XSETSELECTIONOWNER
-#define XSetStipple XSETSTIPPLE
-#define XSetSubwindowMode XSETSUBWINDOWMODE
-#define XSetTSOrigin XSETTSORIGIN
-#define XSetTile XSETTILE
-#define XSetTransientForHint XSETTRANSIENTFORHINT
-#define XSetWMColormapWindows XSETWMCOLORMAPWINDOWS
-#define XSetWMHints XSETWMHINTS
-#define XSetWMIconName XSETWMICONNAME
-#define XSetWMName XSETWMNAME
-#define XSetWMNormalHints XSETWMNORMALHINTS
-#define XSetWMProperties XSETWMPROPERTIES
-#define XSetWMProtocols XSETWMPROTOCOLS
-#define XSetWindowBackground XSETWINDOWBACKGROUND
-#define XSetWindowBackgroundPixmap XSETWINDOWBACKGROUNDPIXMAP
-#define XSetWindowColormap XSETWINDOWCOLORMAP
-#define XShapeCombineMask XSHAPECOMBINEMASK
-#define XShapeCombineRectangles XSHAPECOMBINERECTANGLES
-#define XShapeGetRectangles XSHAPEGETRECTANGLES
-#define XShrinkRegion XSHRINKREGION
-#define XStoreColor XSTORECOLOR
-#define XStoreColors XSTORECOLORS
-#define XStoreName XSTORENAME
-#define XStringToKeysym XSTRINGTOKEYSYM
-#define XSubtractRegion XSUBTRACTREGION
-#define XSupportsLocale XSUPPORTSLOCALE
-#define XSync XSYNC
-#define XSynchronize XSYNCHRONIZE
-#define XTextExtents XTEXTEXTENTS
-#define XTextExtents16 XTEXTEXTENTS16
-#define XTextWidth XTEXTWIDTH
-#define XTextWidth16 XTEXTWIDTH16
-#define XTranslateCoordinates XTRANSLATECOORDINATES
-#define XUndefineCursor XUNDEFINECURSOR
-#define XUngrabKeyboard XUNGRABKEYBOARD
-#define XUngrabPointer XUNGRABPOINTER
-#define XUngrabServer XUNGRABSERVER
-#define XUnionRectWithRegion XUNIONRECTWITHREGION
-#define XUnionRegion XUNIONREGION
-#define XUnmapWindow XUNMAPWINDOW
-#define _XUnregisterFilter _XUNREGISTERFILTER
-#define XUnsetICFocus XUNSETICFOCUS
-#define XVaCreateNestedList XVACREATENESTEDLIST
-#define XVisualIDFromVisual XVISUALIDFROMVISUAL
-#define XWidthOfScreen XWIDTHOFSCREEN
-#define XWindowEvent XWINDOWEVENT
-#define XWithdrawWindow XWITHDRAWWINDOW
-#define XXorRegion XXORREGION
-#define XmAddProtocolCallback XMADDPROTOCOLCALLBACK
-#define XmAddProtocols XMADDPROTOCOLS
-#define XmChangeColor XMCHANGECOLOR
-#define XmClipboardCopy XMCLIPBOARDCOPY
-#define XmClipboardEndCopy XMCLIPBOARDENDCOPY
-#define XmClipboardInquireLength XMCLIPBOARDINQUIRELENGTH
-#define XmClipboardLock XMCLIPBOARDLOCK
-#define XmClipboardRetrieve XMCLIPBOARDRETRIEVE
-#define XmClipboardStartCopy XMCLIPBOARDSTARTCOPY
-#define XmClipboardUnlock XMCLIPBOARDUNLOCK
-#define XmCreateArrowButton XMCREATEARROWBUTTON
-#define XmCreateArrowButtonGadget XMCREATEARROWBUTTONGADGET
-#define XmCreateCascadeButton XMCREATECASCADEBUTTON
-#define XmCreateDialogShell XMCREATEDIALOGSHELL
-#define XmCreateDragIcon XMCREATEDRAGICON
-#define XmCreateDrawingArea XMCREATEDRAWINGAREA
-#define XmCreateDrawnButton XMCREATEDRAWNBUTTON
-#define XmCreateFileSelectionBox XMCREATEFILESELECTIONBOX
-#define XmCreateFileSelectionDialog XMCREATEFILESELECTIONDIALOG
-#define XmCreateForm XMCREATEFORM
-#define XmCreateFormDialog XMCREATEFORMDIALOG
-#define XmCreateFrame XMCREATEFRAME
-#define XmCreateInformationDialog XMCREATEINFORMATIONDIALOG
-#define XmCreateLabelGadget XMCREATELABELGADGET
-#define XmCreateMainWindow XMCREATEMAINWINDOW
-#define XmCreateMenuBar XMCREATEMENUBAR
-#define XmCreateMessageBox XMCREATEMESSAGEBOX
-#define XmCreateMessageDialog XMCREATEMESSAGEDIALOG
-#define XmCreateOptionMenu XMCREATEOPTIONMENU
-#define XmCreatePanedWindow XMCREATEPANEDWINDOW
-#define XmCreatePopupMenu XMCREATEPOPUPMENU
-#define XmCreatePromptDialog XMCREATEPROMPTDIALOG
-#define XmCreatePulldownMenu XMCREATEPULLDOWNMENU
-#define XmCreatePushButton XMCREATEPUSHBUTTON
-#define XmCreatePushButtonGadget XMCREATEPUSHBUTTONGADGET
-#define XmCreateQuestionDialog XMCREATEQUESTIONDIALOG
-#define XmCreateRadioBox XMCREATERADIOBOX
-#define XmCreateRowColumn XMCREATEROWCOLUMN
-#define XmCreateScale XMCREATESCALE
-#define XmCreateScrollBar XMCREATESCROLLBAR
-#define XmCreateScrolledList XMCREATESCROLLEDLIST
-#define XmCreateScrolledText XMCREATESCROLLEDTEXT
-#define XmCreateScrolledWindow XMCREATESCROLLEDWINDOW
-#define XmCreateSelectionDialog XMCREATESELECTIONDIALOG
-#define XmCreateSeparator XMCREATESEPARATOR
-#define XmCreateSeparatorGadget XMCREATESEPARATORGADGET
-#define XmCreateTemplateDialog XMCREATETEMPLATEDIALOG
-#define XmCreateText XMCREATETEXT
-#define XmCreateTextField XMCREATETEXTFIELD
-#define XmCreateToggleButton XMCREATETOGGLEBUTTON
-#define XmCreateToggleButtonGadget XMCREATETOGGLEBUTTONGADGET
-#define XmDragStart XMDRAGSTART
-#define XmDropSiteRegister XMDROPSITEREGISTER
-#define XmDropSiteUnregister XMDROPSITEUNREGISTER
-#define XmDropSiteUpdate XMDROPSITEUPDATE
-#define XmDropTransferStart XMDROPTRANSFERSTART
-#define XmFileSelectionBoxGetChild XMFILESELECTIONBOXGETCHILD
-#define XmFileSelectionDoSearch XMFILESELECTIONDOSEARCH
-#define XmFontListAppendEntry XMFONTLISTAPPENDENTRY
-#define XmFontListCopy XMFONTLISTCOPY
-#define XmFontListCreate XMFONTLISTCREATE
-#define XmFontListEntryCreate XMFONTLISTENTRYCREATE
-#define XmFontListEntryFree XMFONTLISTENTRYFREE
-#define XmFontListEntryGetFont XMFONTLISTENTRYGETFONT
-#define XmFontListEntryGetTag XMFONTLISTENTRYGETTAG
-#define XmFontListEntryLoad XMFONTLISTENTRYLOAD
-#define XmFontListFree XMFONTLISTFREE
-#define XmFontListFreeFontContext XMFONTLISTFREEFONTCONTEXT
-#define XmFontListGetNextFont XMFONTLISTGETNEXTFONT
-#define XmFontListInitFontContext XMFONTLISTINITFONTCONTEXT
-#define XmFontListNextEntry XMFONTLISTNEXTENTRY
-#define XmGetColors XMGETCOLORS
-#define XmGetFocusWidget XMGETFOCUSWIDGET
-#define XmGetMenuCursor XMGETMENUCURSOR
-#define XmGetPixmapByDepth XMGETPIXMAPBYDEPTH
-#define XmGetTearOffControl XMGETTEAROFFCONTROL
-#define XmGetXmDisplay XMGETXMDISPLAY
-#define XmImMbLookupString XMIMMBLOOKUPSTRING
-#define XmImRegister XMIMREGISTER
-#define XmImSetFocusValues XMIMSETFOCUSVALUES
-#define XmImSetValues XMIMSETVALUES
-#define XmImUnregister XMIMUNREGISTER
-#define XmImUnsetFocus XMIMUNSETFOCUS
-#define XmInternAtom XMINTERNATOM
-#define XmIsMotifWMRunning XMISMOTIFWMRUNNING
-#define XmListAddItem XMLISTADDITEM
-#define XmListAddItemUnselected XMLISTADDITEMUNSELECTED
-#define XmListAddItemsUnselected XMLISTADDITEMSUNSELECTED
-#define XmListDeleteAllItems XMLISTDELETEALLITEMS
-#define XmListDeleteItemsPos XMLISTDELETEITEMSPOS
-#define XmListDeletePos XMLISTDELETEPOS
-#define XmListDeselectAllItems XMLISTDESELECTALLITEMS
-#define XmListDeselectPos XMLISTDESELECTPOS
-#define XmListGetKbdItemPos XMLISTGETKBDITEMPOS
-#define XmListGetMatchPos XMLISTGETMATCHPOS
-#define XmListGetSelectedPos XMLISTGETSELECTEDPOS
-#define XmListPosSelected XMLISTPOSSELECTED
-#define XmListSelectItem XMLISTSELECTITEM
-#define XmListSelectPos XMLISTSELECTPOS
-#define XmListSetBottomPos XMLISTSETBOTTOMPOS
-#define XmListSetItem XMLISTSETITEM
-#define XmListSetKbdItemPos XMLISTSETKBDITEMPOS
-#define XmListSetPos XMLISTSETPOS
-#define XmMainWindowSetAreas XMMAINWINDOWSETAREAS
-#define XmMenuPosition XMMENUPOSITION
-#define XmMessageBoxGetChild XMMESSAGEBOXGETCHILD
-#define XmOptionButtonGadget XMOPTIONBUTTONGADGET
-#define XmOptionLabelGadget XMOPTIONLABELGADGET
-#define XmProcessTraversal XMPROCESSTRAVERSAL
-#define XmQmotif XMQMOTIF
-#define XmRemoveProtocolCallback XMREMOVEPROTOCOLCALLBACK
-#define XmRepTypeGetId XMREPTYPEGETID
-#define XmRepTypeGetRecord XMREPTYPEGETRECORD
-#define XmRepTypeRegister XMREPTYPEREGISTER
-#define XmRepTypeValidValue XMREPTYPEVALIDVALUE
-#define XmScrollBarSetValues XMSCROLLBARSETVALUES
-#define XmScrolledWindowSetAreas XMSCROLLEDWINDOWSETAREAS
-#define XmSelectionBoxGetChild XMSELECTIONBOXGETCHILD
-#define XmStringByteCompare XMSTRINGBYTECOMPARE
-#define XmStringCompare XMSTRINGCOMPARE
-#define XmStringConcat XMSTRINGCONCAT
-#define XmStringCopy XMSTRINGCOPY
-#define XmStringCreate XMSTRINGCREATE
-#define XmStringCreateLocalized XMSTRINGCREATELOCALIZED
-#define XmStringCreateLtoR XMSTRINGCREATELTOR
-#define XmStringCreateSimple XMSTRINGCREATESIMPLE
-#define XmStringDraw XMSTRINGDRAW
-#define XmStringDrawUnderline XMSTRINGDRAWUNDERLINE
-#define XmStringExtent XMSTRINGEXTENT
-#define XmStringFree XMSTRINGFREE
-#define XmStringFreeContext XMSTRINGFREECONTEXT
-#define XmStringGetLtoR XMSTRINGGETLTOR
-#define XmStringGetNextComponent XMSTRINGGETNEXTCOMPONENT
-#define XmStringGetNextSegment XMSTRINGGETNEXTSEGMENT
-#define XmStringInitContext XMSTRINGINITCONTEXT
-#define XmStringLength XMSTRINGLENGTH
-#define XmStringLtoRCreate XMSTRINGLTORCREATE
-#define XmStringNConcat XMSTRINGNCONCAT
-#define XmStringSegmentCreate XMSTRINGSEGMENTCREATE
-#define XmStringWidth XMSTRINGWIDTH
-#define XmTextClearSelection XMTEXTCLEARSELECTION
-#define XmTextFieldGetEditable XMTEXTFIELDGETEDITABLE
-#define XmTextFieldGetInsertionPosition XMTEXTFIELDGETINSERTIONPOSITION
-#define XmTextFieldGetLastPosition XMTEXTFIELDGETLASTPOSITION
-#define XmTextFieldGetSelection XMTEXTFIELDGETSELECTION
-#define XmTextFieldGetString XMTEXTFIELDGETSTRING
-#define XmTextFieldInsert XMTEXTFIELDINSERT
-#define XmTextFieldRemove XMTEXTFIELDREMOVE
-#define XmTextFieldSetSelection XMTEXTFIELDSETSELECTION
-#define XmTextFieldSetString XMTEXTFIELDSETSTRING
-#define XmTextGetCursorPosition XMTEXTGETCURSORPOSITION
-#define XmTextGetInsertionPosition XMTEXTGETINSERTIONPOSITION
-#define XmTextGetLastPosition XMTEXTGETLASTPOSITION
-#define XmTextGetMaxLength XMTEXTGETMAXLENGTH
-#define XmTextGetSelection XMTEXTGETSELECTION
-#define XmTextGetSelectionPosition XMTEXTGETSELECTIONPOSITION
-#define XmTextGetString XMTEXTGETSTRING
-#define XmTextInsert XMTEXTINSERT
-#define XmTextRemove XMTEXTREMOVE
-#define XmTextReplace XMTEXTREPLACE
-#define XmTextSetCursorPosition XMTEXTSETCURSORPOSITION
-#define XmTextSetHighlight XMTEXTSETHIGHLIGHT
-#define XmTextSetInsertionPosition XMTEXTSETINSERTIONPOSITION
-#define XmTextSetSelection XMTEXTSETSELECTION
-#define XmTextSetString XMTEXTSETSTRING
-#define XmToggleButtonGadgetGetState XMTOGGLEBUTTONGADGETGETSTATE
-#define XmToggleButtonGadgetSetState XMTOGGLEBUTTONGADGETSETSTATE
-#define XmToggleButtonGetState XMTOGGLEBUTTONGETSTATE
-#define XmToggleButtonSetState XMTOGGLEBUTTONSETSTATE
-#define XmUpdateDisplay XMUPDATEDISPLAY
-#define XmVaCreateSimpleRadioBox XMVACREATESIMPLERADIOBOX
-#define XmbDrawString XMBDRAWSTRING
-#define XmbLookupString XMBLOOKUPSTRING
-#define XmbResetIC XMBRESETIC
-#define XmbSetWMProperties XMBSETWMPROPERTIES
-#define XmbTextEscapement XMBTEXTESCAPEMENT
-#define XmbTextExtents XMBTEXTEXTENTS
-#define XmbTextListToTextProperty XMBTEXTLISTTOTEXTPROPERTY
-#define XmbTextPropertyToTextList XMBTEXTPROPERTYTOTEXTLIST
-#define XmuClientWindow XMUCLIENTWINDOW
-#define XmuPrintDefaultErrorMessage XMUPRINTDEFAULTERRORMESSAGE
-#define XrmGetDatabase XRMGETDATABASE
-#define XrmGetResource XRMGETRESOURCE
-#define XrmPutStringResource XRMPUTSTRINGRESOURCE
-#define XrmQuarkToString XRMQUARKTOSTRING
-#define XrmStringToQuark XRMSTRINGTOQUARK
-#define XtAddCallback XTADDCALLBACK
-#define XtAddCallbacks XTADDCALLBACKS
-#define XtAddEventHandler XTADDEVENTHANDLER
-#define XtAddGrab XTADDGRAB
-#define XtAllocateGC XTALLOCATEGC
-#define XtAppAddActions XTAPPADDACTIONS
-#define XtAppAddInput XTAPPADDINPUT
-#define XtAppAddTimeOut XTAPPADDTIMEOUT
-#define XtAppCreateShell XTAPPCREATESHELL
-#define XtAppInitialize XTAPPINITIALIZE
-#define XtAppNextEvent XTAPPNEXTEVENT
-#define XtAppPeekEvent XTAPPPEEKEVENT
-#define XtAppPending XTAPPPENDING
-#define XtAppProcessEvent XTAPPPROCESSEVENT
-#define XtAppSetErrorHandler XTAPPSETERRORHANDLER
-#define XtAppSetFallbackResources XTAPPSETFALLBACKRESOURCES
-#define XtAppSetWarningHandler XTAPPSETWARNINGHANDLER
-#define XtAppSetWarningMsgHandler XTAPPSETWARNINGMSGHANDLER
-#define XtAppWarning XTAPPWARNING
-#define XtCallActionProc XTCALLACTIONPROC
-#define XtCallCallbackList XTCALLCALLBACKLIST
-#define XtCallCallbacks XTCALLCALLBACKS
-#define XtConfigureWidget XTCONFIGUREWIDGET
-#define XtConvertAndStore XTCONVERTANDSTORE
-#define XtCreateApplicationContext XTCREATEAPPLICATIONCONTEXT
-#define XtCreateManagedWidget XTCREATEMANAGEDWIDGET
-#define XtCreatePopupShell XTCREATEPOPUPSHELL
-#define XtCreateWidget XTCREATEWIDGET
-#define XtDatabase XTDATABASE
-#define XtDestroyWidget XTDESTROYWIDGET
-#define XtDisownSelection XTDISOWNSELECTION
-#define XtDispatchEvent XTDISPATCHEVENT
-#define XtDisplayOfObject XTDISPLAYOFOBJECT
-#define XtDisplayStringConvWarning XTDISPLAYSTRINGCONVWARNING
-#define XtDisplayToApplicationContext XTDISPLAYTOAPPLICATIONCONTEXT
-#define XtAppAddWorkProc XTAPPADDWORKPROC
-#define XtRemoveWorkProc XTREMOVEWORKPROC
-#define XtFree XTFREE
-#define XtGetActionKeysym XTGETACTIONKEYSYM
-#define XtGetActionList XTGETACTIONLIST
-#define XtGetApplicationNameAndClass XTGETAPPLICATIONNAMEANDCLASS
-#define XtGetApplicationResources XTGETAPPLICATIONRESOURCES
-#define XtGetGC XTGETGC
-#define XtGetMultiClickTime XTGETMULTICLICKTIME
-#define XtGetSelectionValue XTGETSELECTIONVALUE
-#define XtGetSelectionValues XTGETSELECTIONVALUES
-#define XtGetSubresources XTGETSUBRESOURCES
-#define XtGetValues XTGETVALUES
-#define XtGrabKeyboard XTGRABKEYBOARD
-#define XtGrabPointer XTGRABPOINTER
-#define XtHasCallbacks XTHASCALLBACKS
-#define XtInitializeWidgetClass XTINITIALIZEWIDGETCLASS
-#define XtInsertEventHandler XTINSERTEVENTHANDLER
-#define XtIsManaged XTISMANAGED
-#define XtIsObject XTISOBJECT
-#define XtIsSensitive XTISSENSITIVE
-#define XtIsSubclass XTISSUBCLASS
-#define XtLastTimestampProcessed XTLASTTIMESTAMPPROCESSED
-#define XtMakeGeometryRequest XTMAKEGEOMETRYREQUEST
-#define XtMakeResizeRequest XTMAKERESIZEREQUEST
-#define XtMalloc XTMALLOC
-#define XtManageChild XTMANAGECHILD
-#define XtManageChildren XTMANAGECHILDREN
-#define XtMergeArgLists XTMERGEARGLISTS
-#define XtMoveWidget XTMOVEWIDGET
-#define XtName XTNAME
-#define XtNameToWidget XTNAMETOWIDGET
-#define XtOpenDisplay XTOPENDISPLAY
-#define XtOverrideTranslations XTOVERRIDETRANSLATIONS
-#define XtOwnSelection XTOWNSELECTION
-#define XtParseTranslationTable XTPARSETRANSLATIONTABLE
-#define XtPopdown XTPOPDOWN
-#define XtPopup XTPOPUP
-#define XtQueryGeometry XTQUERYGEOMETRY
-#define XtRealizeWidget XTREALIZEWIDGET
-#define XtRealloc XTREALLOC
-#define XtReleaseGC XTRELEASEGC
-#define XtRemoveAllCallbacks XTREMOVEALLCALLBACKS
-#define XtRemoveCallback XTREMOVECALLBACK
-#define XtRemoveEventHandler XTREMOVEEVENTHANDLER
-#define XtRemoveGrab XTREMOVEGRAB
-#define XtRemoveInput XTREMOVEINPUT
-#define XtRemoveTimeOut XTREMOVETIMEOUT
-#define XtResizeWidget XTRESIZEWIDGET
-#define XtResolvePathname XTRESOLVEPATHNAME
-#define XtSetKeyboardFocus XTSETKEYBOARDFOCUS
-#define XtSetMappedWhenManaged XTSETMAPPEDWHENMANAGED
-#define XtSetSensitive XTSETSENSITIVE
-#define XtSetTypeConverter XTSETTYPECONVERTER
-#define XtSetValues XTSETVALUES
-#define XtShellStrings XTSHELLSTRINGS
-#define XtStrings XTSTRINGS
-#define XtToolkitInitialize XTTOOLKITINITIALIZE
-#define XtTranslateCoords XTTRANSLATECOORDS
-#define XtTranslateKeycode XTTRANSLATEKEYCODE
-#define XtUngrabKeyboard XTUNGRABKEYBOARD
-#define XtUngrabPointer XTUNGRABPOINTER
-#define XtUnmanageChild XTUNMANAGECHILD
-#define XtUnmanageChildren XTUNMANAGECHILDREN
-#define XtUnrealizeWidget XTUNREALIZEWIDGET
-#define XtVaCreateManagedWidget XTVACREATEMANAGEDWIDGET
-#define XtVaCreateWidget XTVACREATEWIDGET
-#define XtVaGetValues XTVAGETVALUES
-#define XtVaSetValues XTVASETVALUES
-#define XtWarning XTWARNING
-#define XtWidgetToApplicationContext XTWIDGETTOAPPLICATIONCONTEXT
-#define XtWindowOfObject XTWINDOWOFOBJECT
-#define XtWindowToWidget XTWINDOWTOWIDGET
-#define XwcDrawString XWCDRAWSTRING
-#define XwcFreeStringList XWCFREESTRINGLIST
-#define XwcTextEscapement XWCTEXTESCAPEMENT
-#define XwcTextExtents XWCTEXTEXTENTS
-#define XwcTextListToTextProperty XWCTEXTLISTTOTEXTPROPERTY
-#define XwcTextPropertyToTextList XWCTEXTPROPERTYTOTEXTLIST
-#define _XmBottomShadowColorDefault _XMBOTTOMSHADOWCOLORDEFAULT
-#define _XmClearBorder _XMCLEARBORDER
-#define _XmConfigureObject _XMCONFIGUREOBJECT
-#define _XmDestroyParentCallback _XMDESTROYPARENTCALLBACK
-#define _XmDrawArrow _XMDRAWARROW
-#define _XmDrawShadows _XMDRAWSHADOWS
-#define _XmFontListGetDefaultFont _XMFONTLISTGETDEFAULTFONT
-#define _XmFromHorizontalPixels _XMFROMHORIZONTALPIXELS
-#define _XmFromVerticalPixels _XMFROMVERTICALPIXELS
-#define _XmGetClassExtensionPtr _XMGETCLASSEXTENSIONPTR
-#define _XmGetDefaultFontList _XMGETDEFAULTFONTLIST
-#define _XmGetTextualDragIcon _XMGETTEXTUALDRAGICON
-#define _XmGetWidgetExtData _XMGETWIDGETEXTDATA
-#define _XmGrabKeyboard _XMGRABKEYBOARD
-#define _XmGrabPointer _XMGRABPOINTER
-#define _XmInheritClass _XMINHERITCLASS
-#define _XmInputInGadget _XMINPUTINGADGET
-#define _XmMakeGeometryRequest _XMMAKEGEOMETRYREQUEST
-#define _XmMenuPopDown _XMMENUPOPDOWN
-#define _XmMoveObject _XMMOVEOBJECT
-#define _XmNavigChangeManaged _XMNAVIGCHANGEMANAGED
-#define _XmOSBuildFileList _XMOSBUILDFILELIST
-#define _XmOSFileCompare _XMOSFILECOMPARE
-#define _XmOSFindPatternPart _XMOSFINDPATTERNPART
-#define _XmOSQualifyFileSpec _XMOSQUALIFYFILESPEC
-#define _XmPostPopupMenu _XMPOSTPOPUPMENU
-#define _XmPrimitiveEnter _XMPRIMITIVEENTER
-#define _XmPrimitiveLeave _XMPRIMITIVELEAVE
-#define _XmRedisplayGadgets _XMREDISPLAYGADGETS
-#define _XmShellIsExclusive _XMSHELLISEXCLUSIVE
-#define _XmStringDraw _XMSTRINGDRAW
-#define _XmStringGetTextConcat _XMSTRINGGETTEXTCONCAT
-#define _XmStrings _XMSTRINGS
-#define _XmToHorizontalPixels _XMTOHORIZONTALPIXELS
-#define _XmToVerticalPixels _XMTOVERTICALPIXELS
-#define _XmTopShadowColorDefault _XMTOPSHADOWCOLORDEFAULT
-#define _Xm_fastPtr _XM_FASTPTR
-#define _XtCheckSubclassFlag _XTCHECKSUBCLASSFLAG
-#define _XtInherit _XTINHERIT
-#define _XtInheritTranslations _XTINHERITTRANSLATIONS
-#define applicationShellWidgetClass APPLICATIONSHELLWIDGETCLASS
-#define compositeWidgetClass COMPOSITEWIDGETCLASS
-#define overrideShellWidgetClass OVERRIDESHELLWIDGETCLASS
-#define shellWidgetClass SHELLWIDGETCLASS
-#define topLevelShellClassRec TOPLEVELSHELLCLASSREC
-#define topLevelShellWidgetClass TOPLEVELSHELLWIDGETCLASS
-#define transientShellWidgetClass TRANSIENTSHELLWIDGETCLASS
-#define vendorShellClassRec VENDORSHELLCLASSREC
-#define vendorShellWidgetClass VENDORSHELLWIDGETCLASS
-#define wmShellWidgetClass WMSHELLWIDGETCLASS
-#define xmArrowButtonWidgetClass XMARROWBUTTONWIDGETCLASS
-#define xmCascadeButtonClassRec XMCASCADEBUTTONCLASSREC
-#define xmCascadeButtonGadgetClass XMCASCADEBUTTONGADGETCLASS
-#define xmCascadeButtonWidgetClass XMCASCADEBUTTONWIDGETCLASS
-#define xmDialogShellWidgetClass XMDIALOGSHELLWIDGETCLASS
-#define xmDrawingAreaWidgetClass XMDRAWINGAREAWIDGETCLASS
-#define xmDrawnButtonWidgetClass XMDRAWNBUTTONWIDGETCLASS
-#define xmFileSelectionBoxWidgetClass XMFILESELECTIONBOXWIDGETCLASS
-#define xmFormWidgetClass XMFORMWIDGETCLASS
-#define xmFrameWidgetClass XMFRAMEWIDGETCLASS
-#define xmGadgetClass XMGADGETCLASS
-#define xmLabelGadgetClass XMLABELGADGETCLASS
-#define xmLabelWidgetClass XMLABELWIDGETCLASS
-#define xmListWidgetClass XMLISTWIDGETCLASS
-#define xmMainWindowWidgetClass XMMAINWINDOWWIDGETCLASS
-#define xmManagerClassRec XMMANAGERCLASSREC
-#define xmManagerWidgetClass XMMANAGERWIDGETCLASS
-#define xmMenuShellWidgetClass XMMENUSHELLWIDGETCLASS
-#define xmMessageBoxWidgetClass XMMESSAGEBOXWIDGETCLASS
-#define xmPrimitiveClassRec XMPRIMITIVECLASSREC
-#define xmPrimitiveWidgetClass XMPRIMITIVEWIDGETCLASS
-#define xmPushButtonClassRec XMPUSHBUTTONCLASSREC
-#define xmPushButtonGadgetClass XMPUSHBUTTONGADGETCLASS
-#define xmPushButtonWidgetClass XMPUSHBUTTONWIDGETCLASS
-#define xmRowColumnWidgetClass XMROWCOLUMNWIDGETCLASS
-#define xmSashWidgetClass XMSASHWIDGETCLASS
-#define xmScrollBarWidgetClass XMSCROLLBARWIDGETCLASS
-#define xmScrolledWindowClassRec XMSCROLLEDWINDOWCLASSREC
-#define xmScrolledWindowWidgetClass XMSCROLLEDWINDOWWIDGETCLASS
-#define xmSeparatorGadgetClass XMSEPARATORGADGETCLASS
-#define xmSeparatorWidgetClass XMSEPARATORWIDGETCLASS
-#define xmTextFieldWidgetClass XMTEXTFIELDWIDGETCLASS
-#define xmTextWidgetClass XMTEXTWIDGETCLASS
-#define xmToggleButtonGadgetClass XMTOGGLEBUTTONGADGETCLASS
-#define xmToggleButtonWidgetClass XMTOGGLEBUTTONWIDGETCLASS
-#define XtRegisterDrawable _XTREGISTERWINDOW
-#define XtUnregisterDrawable _XTUNREGISTERWINDOW
-#define XQueryFont XQUERYFONT
-#define XSetPlaneMask XSETPLANEMASK
-#define XChangeKeyboardControl XCHANGEKEYBOARDCONTROL
-#define XDestroySubwindows XDESTROYSUBWINDOWS
-#define XFreeDeviceList XFREEDEVICELIST
-#define XFreeDeviceState XFREEDEVICESTATE
-#define XGetExtensionVersion XGETEXTENSIONVERSION
-#define XGetRGBColormaps XGETRGBCOLORMAPS
-#define XIconifyWindow XICONIFYWINDOW
-#define XInstallColormap XINSTALLCOLORMAP
-#define XListInputDevices XLISTINPUTDEVICES
-#define XLookupKeysym XLOOKUPKEYSYM
-#define XOpenDevice XOPENDEVICE
-#define XQueryDeviceState XQUERYDEVICESTATE
-#define XSelectExtensionEvent XSELECTEXTENSIONEVENT
-#define XWarpPointer XWARPPOINTER
-#define XmuLookupStandardColormap XMULOOKUPSTANDARDCOLORMAP
-#define XAllocNamedColor XALLOCNAMEDCOLOR
-#define XBlackPixelOfScreen XBLACKPIXELOFSCREEN
-#define XDefaultColormap XDEFAULTCOLORMAP
-#define XDefaultColormapOfScreen XDEFAULTCOLORMAPOFSCREEN
-#define XDefaultDepth XDEFAULTDEPTH
-#define XDefaultScreen XDEFAULTSCREEN
-#define XDefaultVisual XDEFAULTVISUAL
-#define XSetIconName XSETICONNAME
-#define XtInitialize XTINITIALIZE
-#define XtMainLoop XTMAINLOOP
-#define DtSaverGetWindows DTSAVERGETWINDOWS
-#define XAddHosts XADDHOSTS
-#define XDisableAccessControl XDISABLEACCESSCONTROL
-#define XEnableAccessControl XENABLEACCESSCONTROL
-#define XFillArcs XFILLARCS
-#define XForceScreenSaver XFORCESCREENSAVER
-#define XGetScreenSaver XGETSCREENSAVER
-#define XListHosts XLISTHOSTS
-#define XReadBitmapFile XREADBITMAPFILE
-#define XRemoveHosts XREMOVEHOSTS
-#define XResetScreenSaver XRESETSCREENSAVER
-#define XResourceManagerString XRESOURCEMANAGERSTRING
-#define XSetScreenSaver XSETSCREENSAVER
-#define XStringListToTextProperty XSTRINGLISTTOTEXTPROPERTY
-#define XrmDestroyDatabase XRMDESTROYDATABASE
-#define XrmGetFileDatabase XRMGETFILEDATABASE
-#define XrmGetStringDatabase XRMGETSTRINGDATABASE
-#define XrmInitialize XRMINITIALIZE
-#define XrmMergeDatabases XRMMERGEDATABASES
-#define XrmParseCommand XRMPARSECOMMAND
-#define XrmPutLineResource XRMPUTLINERESOURCE
-#define XrmQPutStringResource XRMQPUTSTRINGRESOURCE
-#define XrmStringToBindingQuarkList XRMSTRINGTOBINDINGQUARKLIST
-#define XrmStringToQuark XRMSTRINGTOQUARK
-#define XmCreateLabel XMCREATELABEL
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-extern void XtFree(char*);
-#ifdef __cplusplus
-}
-#endif
-
-#define pthread_attr_create PTHREAD_ATTR_CREATE
-#define pthread_attr_delete PTHREAD_ATTR_DELETE
-#define pthread_attr_destroy PTHREAD_ATTR_DESTROY
-#define pthread_attr_getdetach_np PTHREAD_ATTR_GETDETACH_NP
-#define pthread_attr_getguardsize_np PTHREAD_ATTR_GETGUARDSIZE_NP
-#define pthread_attr_getinheritsched PTHREAD_ATTR_GETINHERITSCHED
-#define pthread_attr_getprio PTHREAD_ATTR_GETPRIO
-#define pthread_attr_getsched PTHREAD_ATTR_GETSCHED
-#define pthread_attr_getschedparam PTHREAD_ATTR_GETSCHEDPARAM
-#define pthread_attr_getstacksize PTHREAD_ATTR_GETSTACKSIZE
-#define pthread_attr_init PTHREAD_ATTR_INIT
-#define pthread_attr_setdetach_np PTHREAD_ATTR_SETDETACH_NP
-#define pthread_attr_setdetachstate PTHREAD_ATTR_SETDETACHSTATE
-#define pthread_attr_setguardsize_np PTHREAD_ATTR_SETGUARDSIZE_NP
-#define pthread_attr_setinheritsched PTHREAD_ATTR_SETINHERITSCHED
-#define pthread_attr_setprio PTHREAD_ATTR_SETPRIO
-#define pthread_attr_setsched PTHREAD_ATTR_SETSCHED
-#define pthread_attr_setschedparam PTHREAD_ATTR_SETSCHEDPARAM
-#define pthread_attr_setschedpolicy PTHREAD_ATTR_SETSCHEDPOLICY
-#define pthread_attr_setstacksize PTHREAD_ATTR_SETSTACKSIZE
-#define pthread_cancel PTHREAD_CANCEL
-#define pthread_cancel_e PTHREAD_CANCEL_E
-#define pthread_cond_broadcast PTHREAD_COND_BROADCAST
-#define pthread_cond_destroy PTHREAD_COND_DESTROY
-#define pthread_cond_init PTHREAD_COND_INIT
-#define pthread_cond_sig_preempt_int_np PTHREAD_COND_SIG_PREEMPT_INT_NP
-#define pthread_cond_signal PTHREAD_COND_SIGNAL
-#define pthread_cond_signal_int_np PTHREAD_COND_SIGNAL_INT_NP
-#define pthread_cond_timedwait PTHREAD_COND_TIMEDWAIT
-#define pthread_cond_wait PTHREAD_COND_WAIT
-#define pthread_condattr_create PTHREAD_CONDATTR_CREATE
-#define pthread_condattr_delete PTHREAD_CONDATTR_DELETE
-#define pthread_condattr_init PTHREAD_CONDATTR_INIT
-#define pthread_create PTHREAD_CREATE
-#define pthread_delay_np PTHREAD_DELAY_NP
-#define pthread_detach PTHREAD_DETACH
-#define pthread_equal PTHREAD_EQUAL
-#define pthread_exc_fetch_fp_np PTHREAD_EXC_FETCH_FP_NP
-#define pthread_exc_handler_np PTHREAD_EXC_HANDLER_NP
-#define pthread_exc_pop_ctx_np PTHREAD_EXC_POP_CTX_NP
-#define pthread_exc_push_ctx_np PTHREAD_EXC_PUSH_CTX_NP
-#define pthread_exc_savecontext_np PTHREAD_EXC_SAVECONTEXT_NP
-#define pthread_exit PTHREAD_EXIT
-#define pthread_get_expiration_np PTHREAD_GET_EXPIRATION_NP
-#define pthread_getprio PTHREAD_GETPRIO
-#define pthread_getschedparam PTHREAD_GETSCHEDPARAM
-#define pthread_getscheduler PTHREAD_GETSCHEDULER
-#define pthread_getspecific PTHREAD_GETSPECIFIC
-#define pthread_getunique_np PTHREAD_GETUNIQUE_NP
-#define pthread_join PTHREAD_JOIN
-#define pthread_join32 PTHREAD_JOIN32
-#define pthread_keycreate PTHREAD_KEYCREATE
-#define pthread_key_create PTHREAD_KEY_CREATE
-#define pthread_kill PTHREAD_KILL
-#define pthread_lock_global_np PTHREAD_LOCK_GLOBAL_NP
-#define pthread_mutex_destroy PTHREAD_MUTEX_DESTROY
-#define pthread_mutex_init PTHREAD_MUTEX_INIT
-#define pthread_mutex_lock PTHREAD_MUTEX_LOCK
-#define pthread_mutex_trylock PTHREAD_MUTEX_TRYLOCK
-#define pthread_mutex_unlock PTHREAD_MUTEX_UNLOCK
-#define pthread_mutexattr_create PTHREAD_MUTEXATTR_CREATE
-#define pthread_mutexattr_delete PTHREAD_MUTEXATTR_DELETE
-#define pthread_mutexattr_destroy PTHREAD_MUTEXATTR_DESTROY
-#define pthread_mutexattr_getkind_np PTHREAD_MUTEXATTR_GETKIND_NP
-#define pthread_mutexattr_init PTHREAD_MUTEXATTR_INIT
-#define pthread_mutexattr_setkind_np PTHREAD_MUTEXATTR_SETKIND_NP
-#define pthread_mutexattr_settype_np PTHREAD_MUTEXATTR_SETTYPE_NP
-#define pthread_once PTHREAD_ONCE
-#define pthread_resume_np PTHREAD_RESUME_NP
-#define pthread_self PTHREAD_SELF
-#define pthread_setasynccancel PTHREAD_SETASYNCCANCEL
-#define pthread_setcancel PTHREAD_SETCANCEL
-#define pthread_setcancelstate PTHREAD_SETCANCELSTATE
-#define pthread_setprio PTHREAD_SETPRIO
-#define pthread_setschedparam PTHREAD_SETSCHEDPARAM
-#define pthread_setscheduler PTHREAD_SETSCHEDULER
-#define pthread_setspecific PTHREAD_SETSPECIFIC
-#define pthread_suspend_np PTHREAD_SUSPEND_NP
-#define pthread_testcancel PTHREAD_TESTCANCEL
-#define pthread_unlock_global_np PTHREAD_UNLOCK_GLOBAL_NP
-#define pthread_yield PTHREAD_YIELD
-#define pthread_yield_np PTHREAD_YIELD_NP
-#define XDefaultRootWindow XDEFAULTROOTWINDOW
-#define XDisplayCells XDISPLAYCELLS
-#define XMaxRequestSize XMAXREQUESTSIZE
-#define XScreenOfDisplay XSCREENOFDISPLAY
-#define XSetFillRule XSETFILLRULE
-#define XmActivateProtocol XMACTIVATEPROTOCOL
-#define XmCreateBulletinBoardDialog XMCREATEBULLETINBOARDDIALOG
-#define XmCreateErrorDialog XMCREATEERRORDIALOG
-#define XmCreateWarningDialog XMCREATEWARNINGDIALOG
-#define XmCvtCTToXmString XMCVTCTTOXMSTRING
-#define XmDestroyPixmap XMDESTROYPIXMAP
-#define XmGetPixmap XMGETPIXMAP
-#define XmInstallImage XMINSTALLIMAGE
-#define XmListAddItems XMLISTADDITEMS
-#define XmListDeleteItem XMLISTDELETEITEM
-#define XmListItemExists XMLISTITEMEXISTS
-#define XmListItemPos XMLISTITEMPOS
-#define XmListReplaceItems XMLISTREPLACEITEMS
-#define XmListReplaceItemsPos XMLISTREPLACEITEMSPOS
-#define XmRemoveProtocols XMREMOVEPROTOCOLS
-#define XmRemoveTabGroup XMREMOVETABGROUP
-#define XmSetColorCalculation XMSETCOLORCALCULATION
-#define XmTextCopy XMTEXTCOPY
-#define XmTextCut XMTEXTCUT
-#define XmTextFieldClearSelection XMTEXTFIELDCLEARSELECTION
-#define XmTextFieldCopy XMTEXTFIELDCOPY
-#define XmTextFieldCut XMTEXTFIELDCUT
-#define XmTextFieldGetMaxLength XMTEXTFIELDGETMAXLENGTH
-#define XmTextFieldGetSelectionPosition XMTEXTFIELDGETSELECTIONPOSITION
-#define XmTextFieldPaste XMTEXTFIELDPASTE
-#define XmTextFieldReplace XMTEXTFIELDREPLACE
-#define XmTextFieldSetAddMode XMTEXTFIELDSETADDMODE
-#define XmTextFieldSetHighlight XMTEXTFIELDSETHIGHLIGHT
-#define XmTextFieldSetInsertionPosition XMTEXTFIELDSETINSERTIONPOSITION
-#define XmTextFieldSetMaxLength XMTEXTFIELDSETMAXLENGTH
-#define XmTextFieldShowPosition XMTEXTFIELDSHOWPOSITION
-#define XmTextGetEditable XMTEXTGETEDITABLE
-#define XmTextPaste XMTEXTPASTE
-#define XmTextPosToXY XMTEXTPOSTOXY
-#define XmTextSetEditable XMTEXTSETEDITABLE
-#define XmTextShowPosition XMTEXTSHOWPOSITION
-#define XmUninstallImage XMUNINSTALLIMAGE
-#define XmuCvtStringToBitmap XMUCVTSTRINGTOBITMAP
-#define XrmPutFileDatabase XRMPUTFILEDATABASE
-#define XtAddConverter XTADDCONVERTER
-#define XtError XTERROR
-#define XtVaCreatePopupShell XTVACREATEPOPUPSHELL
-#define pthread_attr_getschedpolicy PTHREAD_ATTR_GETSCHEDPOLICY
-#define pthread_key_delete PTHREAD_KEY_DELETE
-#define xmBulletinBoardWidgetClass XMBULLETINBOARDWIDGETCLASS
-#define xmScaleWidgetClass XMSCALEWIDGETCLASS
-#define XtDisplay XTDISPLAY
-#define XtScreen XTSCREEN
-#define XAllocIconSize XALLOCICONSIZE
-#define XAllocStandardColormap XALLOCSTANDARDCOLORMAP
-#define XAllowEvents XALLOWEVENTS
-#define XBlackPixel XBLACKPIXEL
-#define XCopyColormapAndFree XCOPYCOLORMAPANDFREE
-#define XDefaultGC XDEFAULTGC
-#define XDisplayHeight XDISPLAYHEIGHT
-#define XDisplayWidth XDISPLAYWIDTH
-#define XGetCommand XGETCOMMAND
-#define XGetIconSizes XGETICONSIZES
-#define XKillClient XKILLCLIENT
-#define XListInstalledColormaps XLISTINSTALLEDCOLORMAPS
-#define XRootWindow XROOTWINDOW
-#define XWMGeometry XWMGEOMETRY
-#define XWhitePixel XWHITEPIXEL
-#define XrmCombineDatabase XRMCOMBINEDATABASE
-#define XrmCombineFileDatabase XRMCOMBINEFILEDATABASE
-#define XSetStandardProperties XSETSTANDARDPROPERTIES
-#define XSetState XSETSTATE
-#define XDrawRectangles XDRAWRECTANGLES
-#define XGrabButton XGRABBUTTON
-#define XLookupColor XLOOKUPCOLOR
-#define XMapSubwindows XMAPSUBWINDOWS
-#define XRecolorCursor XRECOLORCURSOR
-#define XStoreBytes XSTOREBYTES
-#define XUngrabButton XUNGRABBUTTON
-#define XUninstallColormap XUNINSTALLCOLORMAP
-#define lib$wait LIB$WAIT
-#define lib$find_file LIB$FIND_FILE
-#define lib$find_file_end LIB$FIND_FILE_END
-#define lib$set_symbol LIB$SET_SYMBOL
-#define lib$sfree1_dd LIB$SFREE1_DD
-#define lib$spawn LIB$SPAWN
-#define sys$assign SYS$ASSIGN
-#define sys$crembx SYS$CREMBX
-#define sys$dassgn SYS$DASSGN
-#define sys$dclexh SYS$DCLEXH
-#define sys$getdviw SYS$GETDVIW
-#define sys$getsyiw SYS$GETSYIW
-#define sys$qio SYS$QIO
-#define sys$qiow SYS$QIOW
-#define sys$setef SYS$SETEF
-#define sys$synch SYS$SYNCH
-#define XDrawText XDRAWTEXT
-#define XtCloseDisplay XTCLOSEDISPLAY
-#define XtDestroyApplicationContext XTDESTROYAPPLICATIONCONTEXT
-#define lib$ediv LIB$EDIV
-#define lib$subx LIB$SUBX
-#define sys$bintim SYS$BINTIM
-#define sys$gettim SYS$GETTIM
-#define XFetchName XFETCHNAME
-#define XPeekIfEvent XPEEKIFEVENT
-#define XQueryKeymap XQUERYKEYMAP
-#endif
Index: xc/extras/Mesa/include/GL/xmesa.h
diff -u xc/extras/Mesa/include/GL/xmesa.h:1.4 xc/extras/Mesa/include/GL/xmesa.h:1.8
--- xc/extras/Mesa/include/GL/xmesa.h:1.4	Mon Nov 13 16:55:31 2000
+++ xc/extras/Mesa/include/GL/xmesa.h	Mon Dec 16 11:18:25 2002
@@ -1,8 +1,9 @@
+
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  4.0.3
  * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -56,7 +57,6 @@
 
 8. Before exiting, call XMesaDestroyVisual and XMesaDestroyContext.
 
-See the demos/xdemo.c and xmesa1.c files for examples.
 */
 
 
@@ -65,12 +65,14 @@
 #ifndef XMESA_H
 #define XMESA_H
 
+#ifdef __VMS
+#include <GL/vms_x_fix.h>
+#endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 #ifdef XFree86Server
 #include "xmesa_xf86.h"
 #else
@@ -86,8 +88,8 @@
 #endif
 
 
-#define XMESA_MAJOR_VERSION 3
-#define XMESA_MINOR_VERSION 4
+#define XMESA_MAJOR_VERSION 4
+#define XMESA_MINOR_VERSION 0
 
 
 
@@ -360,6 +362,15 @@
  */
 extern GLboolean XMesaSetFXmode( GLint mode );
 
+
+
+/*
+ * Reallocate the back/depth/stencil/accum/etc/ buffers associated with
+ * buffer <b> if its size has changed.
+ *
+ * New in Mesa 4.0.2
+ */
+extern void XMesaResizeBuffers( XMesaBuffer b );
 
 
 #ifdef __cplusplus
Index: xc/extras/Mesa/src/KNOWN_BUGS
diff -u /dev/null xc/extras/Mesa/src/KNOWN_BUGS:1.3
--- /dev/null	Thu Feb 27 12:15:29 2003
+++ xc/extras/Mesa/src/KNOWN_BUGS	Wed Dec 11 16:13:18 2002
@@ -0,0 +1,22 @@
+$Id: KNOWN_BUGS,v 1.3 2000/07/19 15:08:55 brianp Exp $
+
+
+Performance issues with EXT_point_parameters & quake2
+
+
+
+Using glPolygonMode() where the front and back modes aren't the
+same causes poor performance on 3Dfx.
+
+
+
+Broken drivers: some of the Mesa device drivers (such as BeOS, D3D,
+etc) haven't been updated for Mesa 3.3's device driver changes.
+
+
+
+glDrawRangeElements() should use vertex array locking to improve performance
+but trying to do so causes a rendering error.  Reported by Scott McMillan.
+Fixed by disabling locking in glDrawRangeElements (varray.c) but that's
+really just hiding a bug in array locking.
+
Index: xc/extras/Mesa/src/aatriangle.c
diff -u xc/extras/Mesa/src/aatriangle.c:1.3 xc/extras/Mesa/src/aatriangle.c:removed
--- xc/extras/Mesa/src/aatriangle.c:1.3	Tue Dec 11 04:18:54 2001
+++ xc/extras/Mesa/src/aatriangle.c	Thu Feb 27 12:15:30 2003
@@ -1,423 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/aatriangle.c,v 1.3 2001/12/11 09:18:54 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Antialiased Triangle rasterizers
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "aatriangle.h"
-#include "span.h"
-#include "types.h"
-#include "vb.h"
-#include "mmath.h"
-#endif
-
-
-/*
- * Compute coefficients of a plane using the X,Y coords of the v0, v1, v2
- * vertices and the given Z values.
- */
-static INLINE void
-compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
-              GLfloat z0, GLfloat z1, GLfloat z2, GLfloat plane[4])
-{
-   const GLfloat px = v1[0] - v0[0];
-   const GLfloat py = v1[1] - v0[1];
-   const GLfloat pz = z1 - z0;
-
-   const GLfloat qx = v2[0] - v0[0];
-   const GLfloat qy = v2[1] - v0[1];
-   const GLfloat qz = z2 - z0;
-
-   const GLfloat a = py * qz - pz * qy;
-   const GLfloat b = pz * qx - px * qz;
-   const GLfloat c = px * qy - py * qx;
-   const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);
-
-   plane[0] = a;
-   plane[1] = b;
-   plane[2] = c;
-   plane[3] = d;
-}
-
-
-/*
- * Compute coefficients of a plane with a constant Z value.
- */
-static INLINE void
-constant_plane(GLfloat value, GLfloat plane[4])
-{
-   plane[0] = 0.0;
-   plane[1] = 0.0;
-   plane[2] = -1.0;
-   plane[3] = value;
-}
-
-#define CONSTANT_PLANE(VALUE, PLANE)	\
-do {					\
-   PLANE[0] = 0.0F;			\
-   PLANE[1] = 0.0F;			\
-   PLANE[2] = -1.0F;			\
-   PLANE[3] = VALUE;			\
-} while (0)
-
-
-
-/*
- * Solve plane equation for Z at (X,Y).
- */
-static INLINE GLfloat
-solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
-   return z;
-}
-
-
-#define SOLVE_PLANE(X, Y, PLANE) \
-   ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])
-
-
-/*
- * Return 1 / solve_plane().
- */
-static INLINE GLfloat
-solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   GLfloat z = -plane[2] / (plane[3] + plane[0] * x + plane[1] * y);
-   return z;
-}
-
-
-
-/*
- * Solve plane and return clamped GLubyte value.
- */
-static INLINE GLubyte
-solve_plane_0_255(GLfloat x, GLfloat y, const GLfloat plane[4])
-{
-   GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2] + 0.5F;
-   if (z < 0.0F)
-      return 0;
-   else if (z > 255.0F)
-      return 255;
-   return (GLubyte) (GLint) z;
-}
-
-
-
-/*
- * Compute how much (area) of the given pixel is inside the triangle.
- * Vertices MUST be specified in counter-clockwise order.
- * Return:  coverage in [0, 1].
- */
-static GLfloat
-compute_coveragef(const GLfloat v0[3], const GLfloat v1[3],
-                  const GLfloat v2[3], GLint winx, GLint winy)
-{
-#define B 0.125
-   static const GLfloat samples[16][2] = {
-      /* start with the four corners */
-      { 0.00+B, 0.00+B },
-      { 0.75+B, 0.00+B },
-      { 0.00+B, 0.75+B },
-      { 0.75+B, 0.75+B },
-      /* continue with interior samples */
-      { 0.25+B, 0.00+B },
-      { 0.50+B, 0.00+B },
-      { 0.00+B, 0.25+B },
-      { 0.25+B, 0.25+B },
-      { 0.50+B, 0.25+B },
-      { 0.75+B, 0.25+B },
-      { 0.00+B, 0.50+B },
-      { 0.25+B, 0.50+B },
-      { 0.50+B, 0.50+B },
-      { 0.75+B, 0.50+B },
-      { 0.25+B, 0.75+B },
-      { 0.50+B, 0.75+B }
-   };
-   const GLfloat x = (GLfloat) winx;
-   const GLfloat y = (GLfloat) winy;
-   const GLfloat dx0 = v1[0] - v0[0];
-   const GLfloat dy0 = v1[1] - v0[1];
-   const GLfloat dx1 = v2[0] - v1[0];
-   const GLfloat dy1 = v2[1] - v1[1];
-   const GLfloat dx2 = v0[0] - v2[0];
-   const GLfloat dy2 = v0[1] - v2[1];
-   GLint stop = 4, i;
-   GLfloat insideCount = 16.0F;
-
-#ifdef DEBUG
-   {
-      const GLfloat area = dx0 * dy1 - dx1 * dy0;
-      assert(area >= 0.0);
-   }
-#endif
-
-   for (i = 0; i < stop; i++) {
-      const GLfloat sx = x + samples[i][0];
-      const GLfloat sy = y + samples[i][1];
-      const GLfloat fx0 = sx - v0[0];
-      const GLfloat fy0 = sy - v0[1];
-      const GLfloat fx1 = sx - v1[0];
-      const GLfloat fy1 = sy - v1[1];
-      const GLfloat fx2 = sx - v2[0];
-      const GLfloat fy2 = sy - v2[1];
-      /* cross product determines if sample is inside or outside each edge */
-      GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
-      GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
-      GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
-      /* Check if the sample is exactly on an edge.  If so, let cross be a
-       * positive or negative value depending on the direction of the edge.
-       */
-      if (cross0 == 0.0F)
-         cross0 = dx0 + dy0;
-      if (cross1 == 0.0F)
-         cross1 = dx1 + dy1;
-      if (cross2 == 0.0F)
-         cross2 = dx2 + dy2;
-      if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
-         /* point is outside triangle */
-         insideCount -= 1.0F;
-         stop = 16;
-      }
-   }
-   if (stop == 4)
-      return 1.0F;
-   else
-      return insideCount * (1.0F / 16.0F);
-}
-
-
-
-/*
- * Compute how much (area) of the given pixel is inside the triangle.
- * Vertices MUST be specified in counter-clockwise order.
- * Return:  coverage in [0, 15].
- */
-static GLint
-compute_coveragei(const GLfloat v0[3], const GLfloat v1[3],
-                  const GLfloat v2[3], GLint winx, GLint winy)
-{
-   /* NOTE: 15 samples instead of 16.
-    * A better sample distribution could be used.
-    */
-   static const GLfloat samples[15][2] = {
-      /* start with the four corners */
-      { 0.00+B, 0.00+B },
-      { 0.75+B, 0.00+B },
-      { 0.00+B, 0.75+B },
-      { 0.75+B, 0.75+B },
-      /* continue with interior samples */
-      { 0.25+B, 0.00+B },
-      { 0.50+B, 0.00+B },
-      { 0.00+B, 0.25+B },
-      { 0.25+B, 0.25+B },
-      { 0.50+B, 0.25+B },
-      { 0.75+B, 0.25+B },
-      { 0.00+B, 0.50+B },
-      { 0.25+B, 0.50+B },
-      /*{ 0.50, 0.50 },*/
-      { 0.75+B, 0.50+B },
-      { 0.25+B, 0.75+B },
-      { 0.50+B, 0.75+B }
-   };
-   const GLfloat x = (GLfloat) winx;
-   const GLfloat y = (GLfloat) winy;
-   const GLfloat dx0 = v1[0] - v0[0];
-   const GLfloat dy0 = v1[1] - v0[1];
-   const GLfloat dx1 = v2[0] - v1[0];
-   const GLfloat dy1 = v2[1] - v1[1];
-   const GLfloat dx2 = v0[0] - v2[0];
-   const GLfloat dy2 = v0[1] - v2[1];
-   GLint stop = 4, i;
-   GLint insideCount = 15;
-
-#ifdef DEBUG
-   {
-      const GLfloat area = dx0 * dy1 - dx1 * dy0;
-      assert(area >= 0.0);
-   }
-#endif
-
-   for (i = 0; i < stop; i++) {
-      const GLfloat sx = x + samples[i][0];
-      const GLfloat sy = y + samples[i][1];
-      const GLfloat fx0 = sx - v0[0];
-      const GLfloat fy0 = sy - v0[1];
-      const GLfloat fx1 = sx - v1[0];
-      const GLfloat fy1 = sy - v1[1];
-      const GLfloat fx2 = sx - v2[0];
-      const GLfloat fy2 = sy - v2[1];
-      /* cross product determines if sample is inside or outside each edge */
-      GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
-      GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
-      GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
-      /* Check if the sample is exactly on an edge.  If so, let cross be a
-       * positive or negative value depending on the direction of the edge.
-       */
-      if (cross0 == 0.0F)
-         cross0 = dx0 + dy0;
-      if (cross1 == 0.0F)
-         cross1 = dx1 + dy1;
-      if (cross2 == 0.0F)
-         cross2 = dx2 + dy2;
-      if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
-         /* point is outside triangle */
-         insideCount--;
-         stop = 15;
-      }
-   }
-   if (stop == 4)
-      return 15;
-   else
-      return insideCount;
-}
-
-
-
-static void
-rgba_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
-{
-#define DO_Z
-#define DO_RGBA
-#include "aatritemp.h"
-}
-
-
-static void
-index_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
-{
-#define DO_Z
-#define DO_INDEX
-#include "aatritemp.h"
-}
-
-
-/*
- * Compute mipmap level of detail.
- */
-static INLINE GLfloat
-compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4],
-               GLfloat invQ, GLfloat width, GLfloat height)
-{
-   GLfloat dudx = sPlane[0] / sPlane[2] * invQ * width;
-   GLfloat dudy = sPlane[1] / sPlane[2] * invQ * width;
-   GLfloat dvdx = tPlane[0] / tPlane[2] * invQ * height;
-   GLfloat dvdy = tPlane[1] / tPlane[2] * invQ * height;
-   GLfloat r1 = dudx * dudx + dudy * dudy;
-   GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
-   GLfloat rho2 = r1 + r2;
-   /* return log base 2 of rho */
-   return log(rho2) * 1.442695 * 0.5;       /* 1.442695 = 1/log(2) */
-}
-
-
-static void
-tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
-{
-#define DO_Z
-#define DO_RGBA
-#define DO_STUV0
-#include "aatritemp.h"
-}
-
-
-static void
-spec_tex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
-{
-#define DO_Z
-#define DO_RGBA
-#define DO_STUV0
-#define DO_SPEC
-#include "aatritemp.h"
-}
-
-
-static void
-multitex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
-{
-#define DO_Z
-#define DO_RGBA
-#define DO_STUV0
-#define DO_STUV1
-#include "aatritemp.h"
-}
-
-static void
-spec_multitex_aa_tri(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv)
-{
-#define DO_Z
-#define DO_RGBA
-#define DO_STUV0
-#define DO_STUV1
-#define DO_SPEC
-#include "aatritemp.h"
-}
-
-
-/*
- * Examine GL state and set ctx->Driver.TriangleFunc to an
- * appropriate antialiased triangle rasterizer function.
- */
-void
-_mesa_set_aa_triangle_function(GLcontext *ctx)
-{
-   ASSERT(ctx->Polygon.SmoothFlag);
-   if (ctx->Texture.ReallyEnabled) {
-      if (ctx->Light.Enabled &&
-          ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) {
-         if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-            ctx->Driver.TriangleFunc = spec_multitex_aa_tri;
-         }
-         else {
-            ctx->Driver.TriangleFunc = spec_tex_aa_tri;
-         }
-      }
-      else {
-         if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-            ctx->Driver.TriangleFunc = multitex_aa_tri;
-         }
-         else {
-            ctx->Driver.TriangleFunc = tex_aa_tri;
-         }
-      }
-   }
-   else {
-      if (ctx->Visual->RGBAflag) {
-         ctx->Driver.TriangleFunc = rgba_aa_tri;
-      }
-      else {
-         ctx->Driver.TriangleFunc = index_aa_tri;
-      }
-   }
-   ASSERT(ctx->Driver.TriangleFunc);
-}
Index: xc/extras/Mesa/src/aatriangle.h
diff -u xc/extras/Mesa/src/aatriangle.h:1.1 xc/extras/Mesa/src/aatriangle.h:removed
--- xc/extras/Mesa/src/aatriangle.h:1.1	Fri Jun 16 20:02:06 2000
+++ xc/extras/Mesa/src/aatriangle.h	Thu Feb 27 12:15:30 2003
@@ -1,38 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef AATRIANGLE_H
-#define AATRIANGLE_H
-
-
-#include "types.h"
-
-
-extern void
-_mesa_set_aa_triangle_function(GLcontext *ctx);
-
-
-#endif
Index: xc/extras/Mesa/src/aatritemp.h
diff -u xc/extras/Mesa/src/aatritemp.h:1.5 xc/extras/Mesa/src/aatritemp.h:removed
--- xc/extras/Mesa/src/aatritemp.h:1.5	Tue Dec 11 04:18:54 2001
+++ xc/extras/Mesa/src/aatritemp.h	Thu Feb 27 12:15:30 2003
@@ -1,498 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/aatritemp.h,v 1.5 2001/12/11 09:18:54 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Antialiased Triangle Rasterizer Template
- *
- * This file is #include'd to generate custom AA triangle rasterizers.
- * NOTE: this code hasn't been optimized yet.  That'll come after it
- * works correctly.
- *
- * The following macros may be defined to indicate what auxillary information
- * must be copmuted across the triangle:
- *    DO_Z      - if defined, compute Z values
- *    DO_RGBA   - if defined, compute RGBA values
- *    DO_INDEX  - if defined, compute color index values
- *    DO_SPEC   - if defined, compute specular RGB values
- *    DO_STUV0  - if defined, compute unit 0 STRQ texcoords
- *    DO_STUV1  - if defined, compute unit 1 STRQ texcoords
- */
-
-/*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/
-{
-   const struct vertex_buffer *VB = ctx->VB;
-   const GLfloat *p0 = VB->Win.data[v0];
-   const GLfloat *p1 = VB->Win.data[v1];
-   const GLfloat *p2 = VB->Win.data[v2];
-   GLint vMin, vMid, vMax;
-   GLint iyMin, iyMax;
-   GLfloat yMin, yMax;
-   GLboolean ltor;
-   GLfloat majDx, majDy;
-#ifdef DO_Z
-   GLfloat zPlane[4];                                       /* Z (depth) */
-   GLdepth z[MAX_WIDTH];
-#endif
-#ifdef DO_RGBA
-   GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];      /* color */
-   GLubyte rgba[MAX_WIDTH][4];
-#endif
-#ifdef DO_INDEX
-   GLfloat iPlane[4];                                       /* color index */
-   GLuint index[MAX_WIDTH];
-#endif
-#ifdef DO_SPEC
-   GLfloat srPlane[4], sgPlane[4], sbPlane[4];              /* spec color */
-   GLubyte spec[MAX_WIDTH][4];
-#endif
-#ifdef DO_STUV0
-   GLfloat s0Plane[4], t0Plane[4], u0Plane[4], v0Plane[4];  /* texture 0 */
-   GLfloat width0, height0;
-   GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH];
-   GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH];
-   GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH];
-   GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];
-#endif
-#ifdef DO_STUV1
-   GLfloat s1Plane[4], t1Plane[4], u1Plane[4], v1Plane[4];  /* texture 1 */
-   GLfloat width1, height1;
-#endif
-   GLfloat bf = ctx->backface_sign;
-
-   /* determine bottom to top order of vertices */
-   {
-      GLfloat y0 = VB->Win.data[v0][1];
-      GLfloat y1 = VB->Win.data[v1][1];
-      GLfloat y2 = VB->Win.data[v2][1];
-      if (y0 <= y1) {
-	 if (y1 <= y2) {
-	    vMin = v0;   vMid = v1;   vMax = v2;   /* y0<=y1<=y2 */
-	 }
-	 else if (y2 <= y0) {
-	    vMin = v2;   vMid = v0;   vMax = v1;   /* y2<=y0<=y1 */
-	 }
-	 else {
-	    vMin = v0;   vMid = v2;   vMax = v1;  bf = -bf; /* y0<=y2<=y1 */
-	 }
-      }
-      else {
-	 if (y0 <= y2) {
-	    vMin = v1;   vMid = v0;   vMax = v2;  bf = -bf; /* y1<=y0<=y2 */
-	 }
-	 else if (y2 <= y1) {
-	    vMin = v2;   vMid = v1;   vMax = v0;  bf = -bf; /* y2<=y1<=y0 */
-	 }
-	 else {
-	    vMin = v1;   vMid = v2;   vMax = v0;   /* y1<=y2<=y0 */
-	 }
-      }
-   }
-
-   majDx = VB->Win.data[vMax][0] - VB->Win.data[vMin][0];
-   majDy = VB->Win.data[vMax][1] - VB->Win.data[vMin][1];
-
-   {
-      const GLfloat botDx = VB->Win.data[vMid][0] - VB->Win.data[vMin][0];
-      const GLfloat botDy = VB->Win.data[vMid][1] - VB->Win.data[vMin][1];
-      const GLfloat area = majDx * botDy - botDx * majDy;
-      ltor = (GLboolean) (area < 0.0F);
-      /* Do backface culling */
-      if (area * bf < 0 || area == 0 || IS_INF_OR_NAN(area) )
-	 return;
-   }
-
-#ifndef DO_OCCLUSION_TEST
-   ctx->OcclusionResult = GL_TRUE;
-#endif
-
-   /* plane setup */
-#ifdef DO_Z
-   compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane);
-#endif
-#ifdef DO_RGBA
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      GLubyte (*rgba)[4] = VB->ColorPtr->data;
-      compute_plane(p0, p1, p2, rgba[v0][0], rgba[v1][0], rgba[v2][0], rPlane);
-      compute_plane(p0, p1, p2, rgba[v0][1], rgba[v1][1], rgba[v2][1], gPlane);
-      compute_plane(p0, p1, p2, rgba[v0][2], rgba[v1][2], rgba[v2][2], bPlane);
-      compute_plane(p0, p1, p2, rgba[v0][3], rgba[v1][3], rgba[v2][3], aPlane);
-   }
-   else {
-      constant_plane(VB->ColorPtr->data[pv][RCOMP], rPlane);
-      constant_plane(VB->ColorPtr->data[pv][GCOMP], gPlane);
-      constant_plane(VB->ColorPtr->data[pv][BCOMP], bPlane);
-      constant_plane(VB->ColorPtr->data[pv][ACOMP], aPlane);
-   }
-#endif
-#ifdef DO_INDEX
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      compute_plane(p0, p1, p2, VB->IndexPtr->data[v0],
-                    VB->IndexPtr->data[v1], VB->IndexPtr->data[v2], iPlane);
-   }
-   else {
-      constant_plane(VB->IndexPtr->data[pv], iPlane);
-   }
-#endif
-#ifdef DO_SPEC
-   {
-      GLubyte (*spec)[4] = VB->Specular;
-      compute_plane(p0, p1, p2, spec[v0][0], spec[v1][0], spec[v2][0],srPlane);
-      compute_plane(p0, p1, p2, spec[v0][1], spec[v1][1], spec[v2][1],sgPlane);
-      compute_plane(p0, p1, p2, spec[v0][2], spec[v1][2], spec[v2][2],sbPlane);
-   }
-#endif
-#ifdef DO_STUV0
-   {
-      const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current;
-      const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
-      const GLint tSize = 3;
-      const GLfloat invW0 = VB->Win.data[v0][3];
-      const GLfloat invW1 = VB->Win.data[v1][3];
-      const GLfloat invW2 = VB->Win.data[v2][3];
-      GLfloat (*texCoord)[4] = VB->TexCoordPtr[0]->data;
-      const GLfloat s0 = texCoord[v0][0] * invW0;
-      const GLfloat s1 = texCoord[v1][0] * invW1;
-      const GLfloat s2 = texCoord[v2][0] * invW2;
-      const GLfloat t0 = (tSize > 1) ? texCoord[v0][1] * invW0 : 0.0F;
-      const GLfloat t1 = (tSize > 1) ? texCoord[v1][1] * invW1 : 0.0F;
-      const GLfloat t2 = (tSize > 1) ? texCoord[v2][1] * invW2 : 0.0F;
-      const GLfloat r0 = (tSize > 2) ? texCoord[v0][2] * invW0 : 0.0F;
-      const GLfloat r1 = (tSize > 2) ? texCoord[v1][2] * invW1 : 0.0F;
-      const GLfloat r2 = (tSize > 2) ? texCoord[v2][2] * invW2 : 0.0F;
-      const GLfloat q0 = (tSize > 3) ? texCoord[v0][3] * invW0 : invW0;
-      const GLfloat q1 = (tSize > 3) ? texCoord[v1][3] * invW1 : invW1;
-      const GLfloat q2 = (tSize > 3) ? texCoord[v2][3] * invW2 : invW2;
-      compute_plane(p0, p1, p2, s0, s1, s2, s0Plane);
-      compute_plane(p0, p1, p2, t0, t1, t2, t0Plane);
-      compute_plane(p0, p1, p2, r0, r1, r2, u0Plane);
-      compute_plane(p0, p1, p2, q0, q1, q2, v0Plane);
-      width0 = (GLfloat) texImage->Width;
-      height0 = (GLfloat) texImage->Height;
-   }
-#endif
-#ifdef DO_STUV1
-   {
-      const struct gl_texture_object *obj = ctx->Texture.Unit[1].Current;
-      const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
-      const GLint tSize = VB->TexCoordPtr[1]->size;
-      const GLfloat invW0 = VB->Win.data[v0][3];
-      const GLfloat invW1 = VB->Win.data[v1][3];
-      const GLfloat invW2 = VB->Win.data[v2][3];
-      GLfloat (*texCoord)[4] = VB->TexCoordPtr[1]->data;
-      const GLfloat s0 = texCoord[v0][0] * invW0;
-      const GLfloat s1 = texCoord[v1][0] * invW1;
-      const GLfloat s2 = texCoord[v2][0] * invW2;
-      const GLfloat t0 = (tSize > 1) ? texCoord[v0][1] * invW0 : 0.0F;
-      const GLfloat t1 = (tSize > 1) ? texCoord[v1][1] * invW1 : 0.0F;
-      const GLfloat t2 = (tSize > 1) ? texCoord[v2][1] * invW2 : 0.0F;
-      const GLfloat r0 = (tSize > 2) ? texCoord[v0][2] * invW0 : 0.0F;
-      const GLfloat r1 = (tSize > 2) ? texCoord[v1][2] * invW1 : 0.0F;
-      const GLfloat r2 = (tSize > 2) ? texCoord[v2][2] * invW2 : 0.0F;
-      const GLfloat q0 = (tSize > 3) ? texCoord[v0][3] * invW0 : invW0;
-      const GLfloat q1 = (tSize > 3) ? texCoord[v1][3] * invW1 : invW1;
-      const GLfloat q2 = (tSize > 3) ? texCoord[v2][3] * invW2 : invW2;
-      compute_plane(p0, p1, p2, s0, s1, s2, s1Plane);
-      compute_plane(p0, p1, p2, t0, t1, t2, t1Plane);
-      compute_plane(p0, p1, p2, r0, r1, r2, u1Plane);
-      compute_plane(p0, p1, p2, q0, q1, q2, v1Plane);
-      width1 = (GLfloat) texImage->Width;
-      height1 = (GLfloat) texImage->Height;
-   }
-#endif
-
-   yMin = VB->Win.data[vMin][1];
-   yMax = VB->Win.data[vMax][1];
-   iyMin = (int) yMin;
-   iyMax = (int) yMax + 1;
-
-   if (ltor) {
-      /* scan left to right */
-      const float *pMin = VB->Win.data[vMin];
-      const float *pMid = VB->Win.data[vMid];
-      const float *pMax = VB->Win.data[vMax];
-      const float dxdy = majDx / majDy;
-      const float xAdj = dxdy < 0.0F ? -dxdy : 0.0F;
-      float x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy;
-      int iy;
-      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
-         GLint ix, startX = (GLint) (x - xAdj);
-         GLuint count, n;
-         GLfloat coverage = 0.0F;
-         /* skip over fragments with zero coverage */
-         while (startX < MAX_WIDTH) {
-            coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
-            if (coverage > 0.0F)
-               break;
-            startX++;
-         }
-
-         /* enter interior of triangle */
-         ix = startX;
-         count = 0;
-         while (coverage > 0.0F) {
-            /* (cx,cy) = center of fragment */
-            GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
-#ifdef DO_Z
-            z[count] = (GLdepth) solve_plane(cx, cy, zPlane);
-#endif
-#ifdef DO_RGBA
-            rgba[count][RCOMP] = solve_plane_0_255(cx, cy, rPlane);
-            rgba[count][GCOMP] = solve_plane_0_255(cx, cy, gPlane);
-            rgba[count][BCOMP] = solve_plane_0_255(cx, cy, bPlane);
-            rgba[count][ACOMP] = (GLubyte) (solve_plane_0_255(cx, cy, aPlane) * coverage);
-#endif
-#ifdef DO_INDEX
-            {
-               GLint frac = compute_coveragei(pMin, pMid, pMax, ix, iy);
-               GLint indx = (GLint) solve_plane(cx, cy, iPlane);
-               index[count] = (indx & ~0xf) | frac;
-            }
-#endif
-#ifdef DO_SPEC
-            spec[count][RCOMP] = solve_plane_0_255(cx, cy, srPlane);
-            spec[count][GCOMP] = solve_plane_0_255(cx, cy, sgPlane);
-            spec[count][BCOMP] = solve_plane_0_255(cx, cy, sbPlane);
-#endif
-#ifdef DO_STUV0
-            {
-               const GLfloat invQ = solve_plane_recip(cx, cy, v0Plane);
-               s[0][count] = solve_plane(cx, cy, s0Plane) * invQ;
-               t[0][count] = solve_plane(cx, cy, t0Plane) * invQ;
-               u[0][count] = solve_plane(cx, cy, u0Plane) * invQ;
-               lambda[0][count] = compute_lambda(s0Plane, t0Plane, invQ,
-                                                 width0, height0);
-            }
-#endif
-#ifdef DO_STUV1
-            {
-               const GLfloat invQ = solve_plane_recip(cx, cy, v1Plane);
-               s[1][count] = solve_plane(cx, cy, s1Plane) * invQ;
-               t[1][count] = solve_plane(cx, cy, t1Plane) * invQ;
-               u[1][count] = solve_plane(cx, cy, u1Plane) * invQ;
-               lambda[1][count] = compute_lambda(s1Plane, t1Plane, invQ,
-                                                 width1, height1);
-            }
-#endif
-            ix++;
-            count++;
-            coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
-         }
-
-         n = (GLuint) ix - (GLuint) startX;
-#ifdef DO_STUV1
-#  ifdef DO_SPEC
-         gl_write_multitexture_span(ctx, 2, n, startX, iy, z,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) s,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) t,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) u,
-                                    (GLfloat (*)[MAX_WIDTH]) lambda,
-                                    rgba, (CONST GLubyte (*)[4]) spec,
-                                    GL_POLYGON);
-#  else
-         gl_write_multitexture_span(ctx, 2, n, startX, iy, z,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) s,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) t,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) u,
-                                    lambda, rgba, NULL, GL_POLYGON);
-#  endif
-#elif defined(DO_STUV0)
-#  ifdef DO_SPEC
-         gl_write_texture_span(ctx, n, startX, iy, z,
-                               s[0], t[0], u[0], lambda[0], rgba,
-                               (CONST GLubyte (*)[4]) spec, GL_POLYGON);
-#  else
-         gl_write_texture_span(ctx, n, startX, iy, z,
-                               s[0], t[0], u[0], lambda[0],
-                               rgba, NULL, GL_POLYGON);
-#  endif
-#elif defined(DO_RGBA)
-         gl_write_rgba_span(ctx, n, startX, iy, z, rgba, GL_POLYGON);
-#elif defined(DO_INDEX)
-         gl_write_index_span(ctx, n, startX, iy, z, index, GL_POLYGON);
-#endif
-      }
-   }
-   else {
-      /* scan right to left */
-      const GLfloat *pMin = VB->Win.data[vMin];
-      const GLfloat *pMid = VB->Win.data[vMid];
-      const GLfloat *pMax = VB->Win.data[vMax];
-      const GLfloat dxdy = majDx / majDy;
-      const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;
-      GLfloat x = VB->Win.data[vMin][0] - (yMin - iyMin) * dxdy;
-      GLint iy;
-      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
-         GLint ix, left, startX = (GLint) (x + xAdj);
-         GLuint count, n;
-         GLfloat coverage = 0.0F;
-         /* skip fragments with zero coverage */
-         while (startX >= 0) {
-            coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);
-            if (coverage > 0.0F)
-               break;
-            startX--;
-         }
-
-         if (startX > ctx->DrawBuffer->Xmax) {
-            startX = ctx->DrawBuffer->Xmax;
-         }
-
-         /* enter interior of triangle */
-         ix = startX;
-         count = 0;
-         while (coverage > 0.0F) {
-            /* (cx,cy) = center of fragment */
-            const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
-#ifdef DO_Z
-            z[ix] = (GLdepth) solve_plane(cx, cy, zPlane);
-#endif
-#ifdef DO_RGBA
-            rgba[ix][RCOMP] = solve_plane_0_255(cx, cy, rPlane);
-            rgba[ix][GCOMP] = solve_plane_0_255(cx, cy, gPlane);
-            rgba[ix][BCOMP] = solve_plane_0_255(cx, cy, bPlane);
-            rgba[ix][ACOMP] = (GLubyte) (solve_plane_0_255(cx, cy, aPlane) * coverage);
-#endif
-#ifdef DO_INDEX
-            {
-               GLint frac = compute_coveragei(pMin, pMax, pMid, ix, iy);
-               GLint indx = (GLint) solve_plane(cx, cy, iPlane);
-               index[ix] = (indx & ~0xf) | frac;
-            }
-#endif
-#ifdef DO_SPEC
-            spec[ix][RCOMP] = solve_plane_0_255(cx, cy, srPlane);
-            spec[ix][GCOMP] = solve_plane_0_255(cx, cy, sgPlane);
-            spec[ix][BCOMP] = solve_plane_0_255(cx, cy, sbPlane);
-#endif
-#ifdef DO_STUV0
-            {
-               const GLfloat invQ = solve_plane_recip(cx, cy, v0Plane);
-               s[0][ix] = solve_plane(cx, cy, s0Plane) * invQ;
-               t[0][ix] = solve_plane(cx, cy, t0Plane) * invQ;
-               u[0][ix] = solve_plane(cx, cy, u0Plane) * invQ;
-               lambda[0][ix] = compute_lambda(s0Plane, t0Plane, invQ,
-                                              width0, height0);
-            }
-#endif
-#ifdef DO_STUV1
-            {
-               const GLfloat invQ = solve_plane_recip(cx, cy, v1Plane);
-               s[1][ix] = solve_plane(cx, cy, s1Plane) * invQ;
-               t[1][ix] = solve_plane(cx, cy, t1Plane) * invQ;
-               u[1][ix] = solve_plane(cx, cy, u1Plane) * invQ;
-               lambda[1][ix] = compute_lambda(s1Plane, t1Plane, invQ,
-                                              width1, height1);
-            }
-#endif
-            ix--;
-            count++;
-            coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
-         }
-
-         n = (GLuint) startX - (GLuint) ix;
-         left = ix + 1;
-#ifdef DO_STUV1
-         {
-            GLuint j;
-            for (j = 0; j < n; j++) {
-               s[0][j] = s[0][j + left];
-               t[0][j] = t[0][j + left];
-               u[0][j] = u[0][j + left];
-               s[1][j] = s[1][j + left];
-               t[1][j] = t[1][j + left];
-               u[1][j] = u[1][j + left];
-               lambda[0][j] = lambda[0][j + left];
-               lambda[1][j] = lambda[1][j + left];
-            }
-         }
-#  ifdef DO_SPEC
-         gl_write_multitexture_span(ctx, 2, n, left, iy, z + left,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) s,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) t,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) u,
-                                    lambda, rgba + left,
-                                    (CONST GLubyte (*)[4]) (spec + left),
-                                    GL_POLYGON);
-#  else
-         gl_write_multitexture_span(ctx, 2, n, left, iy, z + left,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) s,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) t,
-                                    (CONST GLfloat (*)[MAX_WIDTH]) u,
-                                    lambda,
-                                    rgba + left, NULL, GL_POLYGON);
-#  endif
-#elif defined(DO_STUV0)
-#  ifdef DO_SPEC
-         gl_write_texture_span(ctx, n, left, iy, z + left,
-                               s[0] + left, t[0] + left, u[0] + left,
-                               lambda[0] + left, rgba + left,
-                               (CONST GLubyte (*)[4]) (spec + left),
-                               GL_POLYGON);
-#  else
-         gl_write_texture_span(ctx, n, left, iy, z + left,
-                               s[0] + left, t[0] + left,
-                               u[0] + left, lambda[0] + left,
-                               rgba + left, NULL, GL_POLYGON);
-#  endif
-#elif defined(DO_RGBA)
-         gl_write_rgba_span(ctx, n, left, iy, z + left,
-                            rgba + left, GL_POLYGON);
-#elif defined(DO_INDEX)
-         gl_write_index_span(ctx, n, left, iy, z + left,
-                             index + left, GL_POLYGON);
-#endif
-      }
-   }
-}
-
-
-#ifdef DO_Z
-#undef DO_Z
-#endif
-
-#ifdef DO_RGBA
-#undef DO_RGBA
-#endif
-
-#ifdef DO_INDEX
-#undef DO_INDEX
-#endif
-
-#ifdef DO_SPEC
-#undef DO_SPEC
-#endif
-
-#ifdef DO_STUV0
-#undef DO_STUV0
-#endif
-
-#ifdef DO_STUV1
-#undef DO_STUV1
-#endif
-
-#ifdef DO_OCCLUSION_TEST
-#undef DO_OCCLUSION_TEST
-#endif
Index: xc/extras/Mesa/src/accum.c
diff -u xc/extras/Mesa/src/accum.c:1.9 xc/extras/Mesa/src/accum.c:1.10
--- xc/extras/Mesa/src/accum.c:1.9	Mon Nov 13 18:30:40 2000
+++ xc/extras/Mesa/src/accum.c	Fri Feb 22 14:25:22 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -30,143 +30,50 @@
 #include "glheader.h"
 #include "accum.h"
 #include "context.h"
+#include "macros.h"
 #include "mem.h"
-#include "masking.h"
-#include "span.h"
 #include "state.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
-/*
- * Accumulation buffer notes
- *
- * Normally, accumulation buffer values are GLshorts with values in
- * [-32767, 32767] which represent floating point colors in [-1, 1],
- * as suggested by the OpenGL specification.
- *
- * We optimize for the common case used for full-scene antialiasing:
- *    // start with accum buffer cleared to zero
- *    glAccum(GL_LOAD, w);   // or GL_ACCUM the first image
- *    glAccum(GL_ACCUM, w);
- *    ...
- *    glAccum(GL_ACCUM, w);
- *    glAccum(GL_RETURN, 1.0);
- * That is, we start with an empty accumulation buffer and accumulate
- * n images, each with weight w = 1/n.
- * In this scenario, we can simply store unscaled integer values in
- * the accum buffer instead of scaled integers.  We'll also keep track
- * of the w value so when we do GL_RETURN we simply divide the accumulated
- * values by n (=1/w).
- * This lets us avoid _many_ int->float->int conversions.
- */
-
-
-#define USE_OPTIMIZED_ACCUM   /* enable the optimization */
 
 
-
 void
-_mesa_alloc_accum_buffer( GLcontext *ctx )
-{
-   GLint n;
-
-   if (ctx->DrawBuffer->Accum) {
-      FREE( ctx->DrawBuffer->Accum );
-      ctx->DrawBuffer->Accum = NULL;
-   }
-
-   /* allocate accumulation buffer if not already present */
-   n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height * 4 * sizeof(GLaccum);
-   ctx->DrawBuffer->Accum = (GLaccum *) MALLOC( n );
-   if (!ctx->DrawBuffer->Accum) {
-      /* unable to setup accumulation buffer */
-      gl_error( ctx, GL_OUT_OF_MEMORY, "glAccum" );
-   }
-#ifdef USE_OPTIMIZED_ACCUM
-   ctx->IntegerAccumMode = GL_TRUE;
-#else
-   ctx->IntegerAccumMode = GL_FALSE;
-#endif
-   ctx->IntegerAccumScaler = 0.0;
-}
-
-
-
-void
 _mesa_ClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
 {
+   GLfloat tmp[4];
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glAccum");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ctx->Accum.ClearColor[0] = CLAMP( red, -1.0, 1.0 );
-   ctx->Accum.ClearColor[1] = CLAMP( green, -1.0, 1.0 );
-   ctx->Accum.ClearColor[2] = CLAMP( blue, -1.0, 1.0 );
-   ctx->Accum.ClearColor[3] = CLAMP( alpha, -1.0, 1.0 );
-}
+   tmp[0] = CLAMP( red,   -1.0F, 1.0F );
+   tmp[1] = CLAMP( green, -1.0F, 1.0F );
+   tmp[2] = CLAMP( blue,  -1.0F, 1.0F );
+   tmp[3] = CLAMP( alpha, -1.0F, 1.0F );
 
-
-
-/*
- * This is called when we fall out of optimized/unscaled accum buffer mode.
- * That is, we convert each unscaled accum buffer value into a scaled value
- * representing the range[-1, 1].
- */
-static void rescale_accum( GLcontext *ctx )
-{
-   const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height * 4;
-   const GLfloat fChanMax = (1 << (sizeof(GLchan) * 8)) - 1;
-   const GLfloat s = ctx->IntegerAccumScaler * (32767.0 / fChanMax);
-   GLaccum *accum = ctx->DrawBuffer->Accum;
-   GLuint i;
-
-   assert(ctx->IntegerAccumMode);
-   assert(accum);
-
-   for (i = 0; i < n; i++) {
-      accum[i] = (GLaccum) (accum[i] * s);
-   }
+   if (TEST_EQ_4V(tmp, ctx->Accum.ClearColor))
+      return;
 
-   ctx->IntegerAccumMode = GL_FALSE;
+   FLUSH_VERTICES(ctx, _NEW_ACCUM);
+   COPY_4FV( ctx->Accum.ClearColor, tmp );
 }
 
-
-
+/* Should really be a driver-supplied function?
+ */
 void
 _mesa_Accum( GLenum op, GLfloat value )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLuint xpos, ypos, width, height, width4;
-   GLfloat acc_scale;
-   GLubyte rgba[MAX_WIDTH][4];
-   const GLint iChanMax = (1 << (sizeof(GLchan) * 8)) - 1;
-   const GLfloat fChanMax = (1 << (sizeof(GLchan) * 8)) - 1;
-   
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glAccum");
+   GLuint xpos, ypos, width, height;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->Visual->AccumRedBits == 0 || ctx->DrawBuffer != ctx->ReadBuffer) {
-      gl_error(ctx, GL_INVALID_OPERATION, "glAccum");
+   if (ctx->Visual.accumRedBits == 0 || ctx->DrawBuffer != ctx->ReadBuffer) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glAccum");
       return;
    }
 
-   if (!ctx->DrawBuffer->Accum) {
-      gl_warning(ctx, "Calling glAccum() without an accumulation buffer (low memory?)");
-      return;
-   }
-
-   if (sizeof(GLaccum)==1) {
-      acc_scale = 127.0;
-   }
-   else if (sizeof(GLaccum)==2) {
-      acc_scale = 32767.0;
-   }
-   else {
-      /* sizeof(GLaccum) > 2 (Cray) */
-      acc_scale = (float) SHRT_MAX;
-   }
-
    if (ctx->NewState)
-      gl_update_state( ctx );
+      _mesa_update_state( ctx );
 
    /* Determine region to operate upon. */
    if (ctx->Scissor.Enabled) {
@@ -182,353 +89,6 @@
       width = ctx->DrawBuffer->Width;
       height = ctx->DrawBuffer->Height;
    }
-
-   width4 = 4 * width;
-
-   switch (op) {
-      case GL_ADD:
-         if (value != 0.0F) {
-	    const GLaccum intVal = (GLaccum) (value * acc_scale);
-	    GLuint j;
-            /* Leave optimized accum buffer mode */
-            if (ctx->IntegerAccumMode)
-               rescale_accum(ctx);
-	    for (j = 0; j < height; j++) {
-	       GLaccum * acc = ctx->DrawBuffer->Accum + ypos * width4 + 4 * xpos;
-               GLuint i;
-	       for (i = 0; i < width4; i++) {
-                  acc[i] += intVal;
-	       }
-	       ypos++;
-	    }
-	 }
-	 break;
-
-      case GL_MULT:
-         if (value != 1.0F) {
-	    GLuint j;
-            /* Leave optimized accum buffer mode */
-            if (ctx->IntegerAccumMode)
-               rescale_accum(ctx);
-	    for (j = 0; j < height; j++) {
-	       GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + 4 * xpos;
-               GLuint i;
-	       for (i = 0; i < width4; i++) {
-                  acc[i] = (GLaccum) ( (GLfloat) acc[i] * value );
-	       }
-	       ypos++;
-	    }
-	 }
-	 break;
-
-      case GL_ACCUM:
-         if (value == 0.0F)
-            return;
-
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                       ctx->Pixel.DriverReadBuffer );
-
-         /* May have to leave optimized accum buffer mode */
-         if (ctx->IntegerAccumScaler == 0.0 && value > 0.0 && value <= 1.0)
-            ctx->IntegerAccumScaler = value;
-         if (ctx->IntegerAccumMode && value != ctx->IntegerAccumScaler)
-            rescale_accum(ctx);
-            
-         RENDER_START(ctx);
-
-         if (ctx->IntegerAccumMode) {
-            /* simply add integer color values into accum buffer */
-            GLuint j;
-            GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
-            assert(ctx->IntegerAccumScaler > 0.0);
-            assert(ctx->IntegerAccumScaler <= 1.0);
-            for (j = 0; j < height; j++) {
-               
-               GLuint i, i4;
-               gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
-               for (i = i4 = 0; i < width; i++, i4+=4) {
-                  acc[i4+0] += rgba[i][RCOMP];
-                  acc[i4+1] += rgba[i][GCOMP];
-                  acc[i4+2] += rgba[i][BCOMP];
-                  acc[i4+3] += rgba[i][ACOMP];
-               }
-               acc += width4;
-               ypos++;
-            }
-         }
-         else {
-            /* scaled integer accum buffer */
-            const GLfloat rscale = value * acc_scale / fChanMax;
-            const GLfloat gscale = value * acc_scale / fChanMax;
-            const GLfloat bscale = value * acc_scale / fChanMax;
-            const GLfloat ascale = value * acc_scale / fChanMax;
-            GLuint j;
-            for (j=0;j<height;j++) {
-               GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
-               GLuint i;
-               gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
-               for (i=0;i<width;i++) {
-                  *acc += (GLaccum) ( (GLfloat) rgba[i][RCOMP] * rscale );  acc++;
-                  *acc += (GLaccum) ( (GLfloat) rgba[i][GCOMP] * gscale );  acc++;
-                  *acc += (GLaccum) ( (GLfloat) rgba[i][BCOMP] * bscale );  acc++;
-                  *acc += (GLaccum) ( (GLfloat) rgba[i][ACOMP] * ascale );  acc++;
-               }
-               ypos++;
-            }
-         }
-         /* restore read buffer = draw buffer (the default) */
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                       ctx->Color.DriverDrawBuffer );
-         RENDER_FINISH(ctx);
-	 break;
-
-      case GL_LOAD:
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                       ctx->Pixel.DriverReadBuffer );
-
-         /* This is a change to go into optimized accum buffer mode */
-         if (value > 0.0 && value <= 1.0) {
-#ifdef USE_OPTIMIZED_ACCUM
-            ctx->IntegerAccumMode = GL_TRUE;
-#else
-            ctx->IntegerAccumMode = GL_FALSE;
-#endif
-            ctx->IntegerAccumScaler = value;
-         }
-         else {
-            ctx->IntegerAccumMode = GL_FALSE;
-            ctx->IntegerAccumScaler = 0.0;
-         }
-
-         RENDER_START(ctx);
-         if (ctx->IntegerAccumMode) {
-            /* just copy values into accum buffer */
-            GLuint j;
-            GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
-            assert(ctx->IntegerAccumScaler > 0.0);
-            assert(ctx->IntegerAccumScaler <= 1.0);
-            for (j = 0; j < height; j++) {
-               GLuint i, i4;
-               gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
-               for (i = i4 = 0; i < width; i++, i4 += 4) {
-                  acc[i4+0] = rgba[i][RCOMP];
-                  acc[i4+1] = rgba[i][GCOMP];
-                  acc[i4+2] = rgba[i][BCOMP];
-                  acc[i4+3] = rgba[i][ACOMP];
-               }
-               acc += width4;
-               ypos++;
-            }
-         }
-         else {
-            /* scaled integer accum buffer */
-            const GLfloat rscale = value * acc_scale / fChanMax;
-            const GLfloat gscale = value * acc_scale / fChanMax;
-            const GLfloat bscale = value * acc_scale / fChanMax;
-            const GLfloat ascale = value * acc_scale / fChanMax;
-            const GLfloat d = 3.0 / acc_scale;
-            GLuint i, j;
-            for (j = 0; j < height; j++) {
-               GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
-               gl_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
-               for (i=0;i<width;i++) {
-                  *acc++ = (GLaccum) ((GLfloat) rgba[i][RCOMP] * rscale + d);
-                  *acc++ = (GLaccum) ((GLfloat) rgba[i][GCOMP] * gscale + d);
-                  *acc++ = (GLaccum) ((GLfloat) rgba[i][BCOMP] * bscale + d);
-                  *acc++ = (GLaccum) ((GLfloat) rgba[i][ACOMP] * ascale + d);
-               }
-               ypos++;
-            }
-         }
-
-         /* restore read buffer = draw buffer (the default) */
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                       ctx->Color.DriverDrawBuffer );
-         RENDER_FINISH(ctx);
-	 break;
-
-      case GL_RETURN:
-         /* May have to leave optimized accum buffer mode */
-         if (ctx->IntegerAccumMode && value != 1.0)
-            rescale_accum(ctx);
-
-         RENDER_START(ctx);
-         if (ctx->IntegerAccumMode && ctx->IntegerAccumScaler > 0) {
-            /* build lookup table to avoid many floating point multiplies */
-            const GLfloat mult = ctx->IntegerAccumScaler;
-            static GLchan multTable[32768];
-            static GLfloat prevMult = 0.0;
-            GLuint j;
-            GLint k;
-            const GLint max = MIN2((GLuint) (256 / mult), 32767);
-            if (mult != prevMult) {
-               for (k = 0; k < max; k++)
-                  multTable[k] = (GLint) ((GLfloat) k * mult + 0.5F);
-               prevMult = mult;
-            }
-
-            assert(ctx->IntegerAccumScaler > 0.0);
-            assert(ctx->IntegerAccumScaler <= 1.0);
-            for (j = 0; j < height; j++) {
-               const GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos*4;
-               GLuint i, i4;
-               for (i = i4 = 0; i < width; i++, i4 += 4) {
-                  ASSERT(acc[i4+0] < max);
-                  ASSERT(acc[i4+1] < max);
-                  ASSERT(acc[i4+2] < max);
-                  ASSERT(acc[i4+3] < max);
-                  rgba[i][RCOMP] = multTable[acc[i4+0]];
-                  rgba[i][GCOMP] = multTable[acc[i4+1]];
-                  rgba[i][BCOMP] = multTable[acc[i4+2]];
-                  rgba[i][ACOMP] = multTable[acc[i4+3]];
-               }
-               if (ctx->Color.SWmasking) {
-                  _mesa_mask_rgba_span( ctx, width, xpos, ypos, rgba );
-               }
-               (*ctx->Driver.WriteRGBASpan)( ctx, width, xpos, ypos, 
-                                          (CONST GLubyte (*)[4]) rgba, NULL );
-               ypos++;
-            }
-         }
-         else {
-            const GLfloat rscale = value / acc_scale * fChanMax;
-            const GLfloat gscale = value / acc_scale * fChanMax;
-            const GLfloat bscale = value / acc_scale * fChanMax;
-            const GLfloat ascale = value / acc_scale * fChanMax;
-            GLuint i, j;
-            for (j=0;j<height;j++) {
-               const GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos*4;
-               for (i=0;i<width;i++) {
-                  GLint r, g, b, a;
-                  r = (GLint) ( (GLfloat) (*acc++) * rscale + 0.5F );
-                  g = (GLint) ( (GLfloat) (*acc++) * gscale + 0.5F );
-                  b = (GLint) ( (GLfloat) (*acc++) * bscale + 0.5F );
-                  a = (GLint) ( (GLfloat) (*acc++) * ascale + 0.5F );
-                  rgba[i][RCOMP] = CLAMP( r, 0, iChanMax );
-                  rgba[i][GCOMP] = CLAMP( g, 0, iChanMax );
-                  rgba[i][BCOMP] = CLAMP( b, 0, iChanMax );
-                  rgba[i][ACOMP] = CLAMP( a, 0, iChanMax );
-               }
-               if (ctx->Color.SWmasking) {
-                  _mesa_mask_rgba_span( ctx, width, xpos, ypos, rgba );
-               }
-               (*ctx->Driver.WriteRGBASpan)( ctx, width, xpos, ypos, 
-                                          (CONST GLubyte (*)[4]) rgba, NULL );
-               ypos++;
-            }
-	 }
-         RENDER_FINISH(ctx);
-	 break;
-
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glAccum" );
-   }
-}
-
-
-
-/*
- * Clear the accumulation Buffer.
- */
-void
-_mesa_clear_accum_buffer( GLcontext *ctx )
-{
-   GLuint buffersize;
-   GLfloat acc_scale;
-
-   if (ctx->Visual->AccumRedBits==0) {
-      /* No accumulation buffer! */
-      return;
-   }
 
-   if (sizeof(GLaccum)==1) {
-      acc_scale = 127.0;
-   }
-   else if (sizeof(GLaccum)==2) {
-      acc_scale = 32767.0;
-   }
-   else {
-      /* sizeof(GLaccum) > 2 (Cray) */
-      acc_scale = (float) SHRT_MAX;
-   }
-
-   /* number of pixels */
-   buffersize = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-
-   if (!ctx->DrawBuffer->Accum) {
-      /* try to alloc accumulation buffer */
-      ctx->DrawBuffer->Accum = (GLaccum *)
-	                   MALLOC( buffersize * 4 * sizeof(GLaccum) );
-   }
-
-   if (ctx->DrawBuffer->Accum) {
-      if (ctx->Scissor.Enabled) {
-	 /* Limit clear to scissor box */
-	 GLaccum r, g, b, a;
-	 GLint i, j;
-         GLint width, height;
-         GLaccum *row;
-	 r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale);
-	 g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale);
-	 b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale);
-	 a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale);
-         /* size of region to clear */
-         width = 4 * (ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1);
-         height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
-         /* ptr to first element to clear */
-         row = ctx->DrawBuffer->Accum
-               + 4 * (ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width
-                      + ctx->DrawBuffer->Xmin);
-         for (j=0;j<height;j++) {
-            for (i=0;i<width;i+=4) {
-               row[i+0] = r;
-               row[i+1] = g;
-               row[i+2] = b;
-               row[i+3] = a;
-	    }
-            row += 4 * ctx->DrawBuffer->Width;
-	 }
-      }
-      else {
-	 /* clear whole buffer */
-	 if (ctx->Accum.ClearColor[0]==0.0 &&
-	     ctx->Accum.ClearColor[1]==0.0 &&
-	     ctx->Accum.ClearColor[2]==0.0 &&
-	     ctx->Accum.ClearColor[3]==0.0) {
-	    /* Black */
-	    BZERO( ctx->DrawBuffer->Accum, buffersize * 4 * sizeof(GLaccum) );
-	 }
-	 else {
-	    /* Not black */
-	    GLaccum *acc, r, g, b, a;
-	    GLuint i;
-
-	    acc = ctx->DrawBuffer->Accum;
-	    r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale);
-	    g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale);
-	    b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale);
-	    a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale);
-	    for (i=0;i<buffersize;i++) {
-	       *acc++ = r;
-	       *acc++ = g;
-	       *acc++ = b;
-	       *acc++ = a;
-	    }
-	 }
-      }
-
-      /* update optimized accum state vars */
-      if (ctx->Accum.ClearColor[0] == 0.0 && ctx->Accum.ClearColor[1] == 0.0 &&
-          ctx->Accum.ClearColor[2] == 0.0 && ctx->Accum.ClearColor[3] == 0.0) {
-#ifdef USE_OPTIMIZED_ACCUM
-         ctx->IntegerAccumMode = GL_TRUE;
-#else
-         ctx->IntegerAccumMode = GL_FALSE;
-#endif
-         ctx->IntegerAccumScaler = 0.0;  /* denotes empty accum buffer */
-      }
-      else {
-         ctx->IntegerAccumMode = GL_FALSE;
-      }
-   }
+   ctx->Driver.Accum( ctx, op, value, xpos, ypos, width, height );
 }
Index: xc/extras/Mesa/src/accum.h
diff -u xc/extras/Mesa/src/accum.h:1.3 xc/extras/Mesa/src/accum.h:1.4
--- xc/extras/Mesa/src/accum.h:1.3	Tue Feb 15 02:12:00 2000
+++ xc/extras/Mesa/src/accum.h	Fri Feb 22 14:25:22 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,15 +28,7 @@
 #define ACCUM_H
 
 
-#include "types.h"
-
-
-extern void
-_mesa_alloc_accum_buffer( GLcontext *ctx );
-
-
-extern void
-_mesa_clear_accum_buffer( GLcontext *ctx );
+#include "mtypes.h"
 
 
 extern void
Index: xc/extras/Mesa/src/all.h
diff -u xc/extras/Mesa/src/all.h:1.4 xc/extras/Mesa/src/all.h:1.5
--- xc/extras/Mesa/src/all.h:1.4	Fri Jun 16 20:02:07 2000
+++ xc/extras/Mesa/src/all.h	Fri Feb 22 14:25:22 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -45,23 +45,16 @@
 #endif
 
 #include "glheader.h"
-#include "aatriangle.h"
 #include "accum.h"
-#include "alpha.h"
-#include "alphabuf.h"
 #include "attrib.h"
-#include "bbox.h"
-#include "bitmap.h"
 #include "blend.h"
 #include "buffers.h"
 #include "clip.h"
 #include "colortab.h"
 #include "config.h"
 #include "context.h"
-#include "copypix.h"
-#include "cva.h"
+#include "convolve.h"
 #include "dd.h"
-#include "debug_xform.h"
 #include "depth.h"
 #include "dlist.h"
 #include "drawpix.h"
@@ -70,58 +63,32 @@
 #include "eval.h"
 #include "extensions.h"
 #include "feedback.h"
-#include "fixed.h"
 #include "fog.h"
 #include "get.h"
 #include "glapi.h"
-#include "glapinoop.h"
 #include "glthread.h"
 #include "hash.h"
 #include "hint.h"
+#include "histogram.h"
 #include "image.h"
-#include "imaging.h"
 #include "light.h"
 #include "lines.h"
-#include "logic.h"
 #include "macros.h"
-#include "masking.h"
 #include "matrix.h"
 #include "mem.h"
 #include "mmath.h"
-#include "pb.h"
 #include "pixel.h"
-#include "pipeline.h"
 #include "points.h"
 #include "polygon.h"
-#include "quads.h"
 #include "rastpos.h"
-#include "readpix.h"
-#include "rect.h"
-#include "scissor.h"
-#include "shade.h"
-#include "span.h"
-#include "stages.h"
 #include "state.h"
 #include "stencil.h"
 #include "teximage.h"
 #include "texobj.h"
 #include "texstate.h"
-#include "texture.h"
-#include "translate.h"
-#include "triangle.h"
-#include "types.h"
+#include "texstore.h"
+#include "mtypes.h"
 #include "varray.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbfill.h"
-#include "vbindirect.h"
-#include "vbrender.h"
-#include "vbxform.h"
-#include "vector.h"
-#include "vertices.h"
-#include "winpos.h"
-#include "xform.h"
-#include "zoom.h"
 
 
 #endif /*SRC_ALL_H*/
Index: xc/extras/Mesa/src/alpha.c
diff -u xc/extras/Mesa/src/alpha.c:1.3 xc/extras/Mesa/src/alpha.c:removed
--- xc/extras/Mesa/src/alpha.c:1.3	Tue Feb 15 02:12:01 2000
+++ xc/extras/Mesa/src/alpha.c	Thu Feb 27 12:15:30 2003
@@ -1,133 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "alpha.h"
-#include "context.h"
-#include "types.h"
-#include "macros.h"
-#include "mmath.h"
-#endif
-
-
-
-void
-_mesa_AlphaFunc( GLenum func, GLclampf ref )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glAlphaFunc");
-
-   switch (func) {
-      case GL_NEVER:
-      case GL_LESS:
-      case GL_EQUAL:
-      case GL_LEQUAL:
-      case GL_GREATER:
-      case GL_NOTEQUAL:
-      case GL_GEQUAL:
-      case GL_ALWAYS:
-         ctx->Color.AlphaFunc = func;
-         if (ref <= 0.0)
-            ctx->Color.AlphaRef = (GLubyte) 0;
-         else if (ref >= 1.0)
-            ctx->Color.AlphaRef = (GLubyte) 255;
-         else
-            CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(ctx->Color.AlphaRef, ref);
-         if (ctx->Driver.AlphaFunc) {
-            (*ctx->Driver.AlphaFunc)(ctx, func, ctx->Color.AlphaRef);
-         }
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glAlphaFunc(func)" );
-         break;
-   }
-}
-
-
-
-/*
- * Apply the alpha test to a span of pixels.
- * In:  rgba - array of pixels
- * In/Out:  mask - current pixel mask.  Pixels which fail the alpha test
- *                 will set the corresponding mask flag to 0.
- * Return:  0 = all pixels in the span failed the alpha test.
- *          1 = one or more pixels passed the alpha test.
- */
-GLint
-_mesa_alpha_test( const GLcontext *ctx,
-                  GLuint n, CONST GLubyte rgba[][4], GLubyte mask[] )
-{
-   GLuint i;
-   GLubyte ref = ctx->Color.AlphaRef;
-
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Color.AlphaFunc) {
-      case GL_LESS:
-         for (i=0;i<n;i++) {
-	    mask[i] &= (rgba[i][ACOMP] < ref);
-	 }
-	 return 1;
-      case GL_LEQUAL:
-         for (i=0;i<n;i++) {
-	    mask[i] &= (rgba[i][ACOMP] <= ref);
-	 }
-	 return 1;
-      case GL_GEQUAL:
-         for (i=0;i<n;i++) {
-	    mask[i] &= (rgba[i][ACOMP] >= ref);
-	 }
-	 return 1;
-      case GL_GREATER:
-         for (i=0;i<n;i++) {
-	    mask[i] &= (rgba[i][ACOMP] > ref);
-	 }
-	 return 1;
-      case GL_NOTEQUAL:
-         for (i=0;i<n;i++) {
-	    mask[i] &= (rgba[i][ACOMP] != ref);
-	 }
-	 return 1;
-      case GL_EQUAL:
-         for (i=0;i<n;i++) {
-	    mask[i] &= (rgba[i][ACOMP] == ref);
-	 }
-	 return 1;
-      case GL_ALWAYS:
-	 /* do nothing */
-	 return 1;
-      case GL_NEVER:
-         /* caller should check for zero! */
-	 return 0;
-      default:
-	 gl_problem( ctx, "Invalid alpha test in gl_alpha_test" );
-         return 0;
-   }
-   /* Never get here */
-   /*return 1;*/
-}
Index: xc/extras/Mesa/src/alpha.h
diff -u xc/extras/Mesa/src/alpha.h:1.3 xc/extras/Mesa/src/alpha.h:removed
--- xc/extras/Mesa/src/alpha.h:1.3	Tue Feb 15 02:12:01 2000
+++ xc/extras/Mesa/src/alpha.h	Thu Feb 27 12:15:30 2003
@@ -1,43 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef ALPHA_H
-#define ALPHA_H
-
-
-#include "types.h"
-
-
-extern GLint
-_mesa_alpha_test( const GLcontext *ctx, GLuint n,
-                  CONST GLubyte rgba[][4], GLubyte mask[] );
-
-
-extern void
-_mesa_AlphaFunc( GLenum func, GLclampf ref );
-
-
-#endif
Index: xc/extras/Mesa/src/alphabuf.c
diff -u xc/extras/Mesa/src/alphabuf.c:1.5 xc/extras/Mesa/src/alphabuf.c:removed
--- xc/extras/Mesa/src/alphabuf.c:1.5	Fri May 18 12:59:53 2001
+++ xc/extras/Mesa/src/alphabuf.c	Thu Feb 27 12:15:30 2003
@@ -1,311 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Software alpha planes.  Many frame buffers don't have alpha bits so
- * we simulate them in software.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "alphabuf.h"
-#include "context.h"
-#include "mem.h"
-#include "types.h"
-#endif
-
-
-
-#define ALPHA_DRAW_ADDR(X,Y) \
-   (ctx->DrawBuffer->Alpha + (Y) * ctx->DrawBuffer->Width + (X))
-
-#define ALPHA_READ_ADDR(X,Y) \
-   (ctx->ReadBuffer->Alpha + (Y) * ctx->ReadBuffer->Width + (X))
-
-
-
-/*
- * Allocate new front/back/left/right alpha buffers.
- * Input: ctx - the context
- *
- */
-static void 
-alloc_alpha_buffers( GLcontext *ctx, GLframebuffer *buf )
-{
-   GLint bytes = buf->Width * buf->Height * sizeof(GLubyte);
-
-   ASSERT(ctx->DrawBuffer->UseSoftwareAlphaBuffers);
-
-   if (buf->FrontLeftAlpha) {
-      FREE( buf->FrontLeftAlpha );
-   }
-   buf->FrontLeftAlpha = (GLubyte *) MALLOC( bytes );
-   if (!buf->FrontLeftAlpha) {
-      /* out of memory */
-      gl_error( ctx, GL_OUT_OF_MEMORY,
-                "Couldn't allocate front-left alpha buffer" );
-   }
-
-   if (ctx->Visual->DBflag) {
-      if (buf->BackLeftAlpha) {
-         FREE( buf->BackLeftAlpha );
-      }
-      buf->BackLeftAlpha = (GLubyte *) MALLOC( bytes );
-      if (!buf->BackLeftAlpha) {
-         /* out of memory */
-         gl_error( ctx, GL_OUT_OF_MEMORY,
-                      "Couldn't allocate back-left alpha buffer" );
-      }
-   }
-
-   if (ctx->Visual->StereoFlag) {
-      if (buf->FrontRightAlpha) {
-         FREE( buf->FrontRightAlpha );
-      }
-      buf->FrontRightAlpha = (GLubyte *) MALLOC( bytes );
-      if (!buf->FrontRightAlpha) {
-         /* out of memory */
-         gl_error( ctx, GL_OUT_OF_MEMORY,
-                   "Couldn't allocate front-right alpha buffer" );
-      }
-
-      if (ctx->Visual->DBflag) {
-         if (buf->BackRightAlpha) {
-            FREE( buf->BackRightAlpha );
-         }
-         buf->BackRightAlpha = (GLubyte *) MALLOC( bytes );
-         if (!buf->BackRightAlpha) {
-            /* out of memory */
-            gl_error( ctx, GL_OUT_OF_MEMORY,
-                      "Couldn't allocate back-right alpha buffer" );
-         }
-      }
-   }
-
-   if (ctx->Color.DriverDrawBuffer == GL_FRONT_LEFT)
-      buf->Alpha = buf->FrontLeftAlpha;
-   else if (ctx->Color.DriverDrawBuffer == GL_BACK_LEFT)
-      buf->Alpha = buf->BackLeftAlpha;
-   else if (ctx->Color.DriverDrawBuffer == GL_FRONT_RIGHT)
-      buf->Alpha = buf->FrontRightAlpha;
-   else if (ctx->Color.DriverDrawBuffer == GL_BACK_RIGHT)
-      buf->Alpha = buf->BackRightAlpha;
-}
-
-
-/*
- * Allocate a new front and back alpha buffer.
- */
-void
-_mesa_alloc_alpha_buffers( GLcontext *ctx )
-{
-   alloc_alpha_buffers( ctx, ctx->DrawBuffer );
-   if (ctx->ReadBuffer != ctx->DrawBuffer) {
-      alloc_alpha_buffers( ctx, ctx->ReadBuffer );
-   }
-}
-
-
-/*
- * Clear all the alpha buffers
- */
-void
-_mesa_clear_alpha_buffers( GLcontext *ctx )
-{
-   const GLubyte aclear = (GLint) (ctx->Color.ClearColor[3] * 255.0F);
-   GLuint bufferBit;
-
-   ASSERT(ctx->DrawBuffer->UseSoftwareAlphaBuffers);
-   ASSERT(ctx->Color.ColorMask[ACOMP]);
-
-   /* loop over four possible alpha buffers */
-   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
-      if (bufferBit & ctx->Color.DrawDestMask) {
-         GLubyte *buffer;
-         if (bufferBit == FRONT_LEFT_BIT) {
-            buffer = ctx->DrawBuffer->FrontLeftAlpha;
-         }
-         else if (bufferBit == FRONT_RIGHT_BIT) {
-            buffer = ctx->DrawBuffer->FrontRightAlpha;
-         }
-         else if (bufferBit == BACK_LEFT_BIT) {
-            buffer = ctx->DrawBuffer->BackLeftAlpha;
-         }
-         else {
-            buffer = ctx->DrawBuffer->BackRightAlpha;
-         }
-
-         if (ctx->Scissor.Enabled) {
-            /* clear scissor region */
-            GLint j;
-            GLint rowLen = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-            GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
-            GLint width = ctx->DrawBuffer->Width;
-            GLubyte *aptr = buffer
-                          + ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width
-                          + ctx->DrawBuffer->Xmin;
-            for (j = 0; j < rows; j++) {
-               MEMSET( aptr, aclear, rowLen );
-               aptr += width;
-            }
-         }
-         else {
-            /* clear whole buffer */
-            GLuint bytes = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-            MEMSET( buffer, aclear, bytes );
-         }
-      }
-   }
-}
-
-
-
-void
-_mesa_write_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                        CONST GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLubyte *aptr = ALPHA_DRAW_ADDR( x, y );
-   GLuint i;
-
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            *aptr = rgba[i][ACOMP];
-         }
-         aptr++;
-      }
-   }
-   else {
-      for (i=0;i<n;i++) {
-         *aptr++ = rgba[i][ACOMP];
-      }
-   }
-}
-
-
-void
-_mesa_write_mono_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                             GLubyte alpha, const GLubyte mask[] )
-{
-   GLubyte *aptr = ALPHA_DRAW_ADDR( x, y );
-   GLuint i;
-
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            *aptr = alpha;
-         }
-         aptr++;
-      }
-   }
-   else {
-      for (i=0;i<n;i++) {
-         *aptr++ = alpha;
-      }
-   }
-}
-
-
-void
-_mesa_write_alpha_pixels( GLcontext *ctx,
-                          GLuint n, const GLint x[], const GLint y[],
-                          CONST GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLuint i;
-
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
-            *aptr = rgba[i][ACOMP];
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++) {
-         GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
-         *aptr = rgba[i][ACOMP];
-      }
-   }
-}
-
-
-void
-_mesa_write_mono_alpha_pixels( GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-                               GLubyte alpha, const GLubyte mask[] )
-{
-   GLuint i;
-
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
-            *aptr = alpha;
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++) {
-         GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
-         *aptr = alpha;
-      }
-   }
-}
-
-
-
-void
-_mesa_read_alpha_span( GLcontext *ctx,
-                       GLuint n, GLint x, GLint y, GLubyte rgba[][4] )
-{
-   GLubyte *aptr = ALPHA_READ_ADDR( x, y );
-   GLuint i;
-   for (i=0;i<n;i++) {
-      rgba[i][ACOMP] = *aptr++;
-   }
-}
-
-
-void
-_mesa_read_alpha_pixels( GLcontext *ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         GLubyte *aptr = ALPHA_READ_ADDR( x[i], y[i] );
-         rgba[i][ACOMP] = *aptr;
-      }
-   }
-}
-
-
-
Index: xc/extras/Mesa/src/alphabuf.h
diff -u xc/extras/Mesa/src/alphabuf.h:1.4 xc/extras/Mesa/src/alphabuf.h:removed
--- xc/extras/Mesa/src/alphabuf.h:1.4	Fri Jun 16 20:02:07 2000
+++ xc/extras/Mesa/src/alphabuf.h	Thu Feb 27 12:15:30 2003
@@ -1,80 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef ALPHABUF_H
-#define ALPHABUF_H
-
-
-#include "types.h"
-
-
-extern void
-_mesa_alloc_alpha_buffers( GLcontext *ctx );
-
-
-extern void
-_mesa_clear_alpha_buffers( GLcontext *ctx );
-
-
-extern void
-_mesa_write_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                        CONST GLubyte rgba[][4], const GLubyte mask[] );
-
-
-extern void
-_mesa_write_mono_alpha_span( GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             GLubyte alpha, const GLubyte mask[] );
-
-
-
-extern void
-_mesa_write_alpha_pixels( GLcontext* ctx,
-                          GLuint n, const GLint x[], const GLint y[],
-                          CONST GLubyte rgba[][4],
-                          const GLubyte mask[] );
-
-
-extern void
-_mesa_write_mono_alpha_pixels( GLcontext* ctx,
-                               GLuint n, const GLint x[],
-                               const GLint y[], GLubyte alpha,
-                               const GLubyte mask[] );
-
-
-extern void
-_mesa_read_alpha_span( GLcontext* ctx,
-                       GLuint n, GLint x, GLint y, GLubyte rgba[][4] );
-
-
-extern void
-_mesa_read_alpha_pixels( GLcontext* ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         GLubyte rgba[][4], const GLubyte mask[] );
-
-
-#endif
-
Index: xc/extras/Mesa/src/api_arrayelt.c
diff -u /dev/null xc/extras/Mesa/src/api_arrayelt.c:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_arrayelt.c	Mon Dec 16 11:18:25 2002
@@ -0,0 +1,364 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/* Author:
+ *    Keith Whitwell <keith_whitwell@yahoo.com>
+ */
+
+#include "glheader.h"
+#include "api_arrayelt.h"
+#include "context.h"
+#include "glapi.h"
+#include "mem.h"
+#include "macros.h"
+#include "mtypes.h"
+
+
+typedef void (*texarray_func)( GLenum, const void * );
+
+typedef struct {
+   GLint unit;
+   struct gl_client_array *array;
+   texarray_func func;
+} AEtexarray;
+
+typedef void (*array_func)( const void * );
+
+typedef struct {
+   struct gl_client_array *array;
+   array_func func;
+} AEarray;
+
+typedef struct {
+   AEtexarray texarrays[MAX_TEXTURE_UNITS+1];
+   AEarray arrays[32];
+   GLuint NewState;
+} AEcontext;
+
+#define AE_CONTEXT(ctx) ((AEcontext *)(ctx)->aelt_context)
+#define TYPE_IDX(t) ((t) & 0xf)
+
+static void (*colorfuncs[2][8])( const void * ) = {
+   { (array_func)glColor3bv,
+     (array_func)glColor3ubv,
+     (array_func)glColor3sv,
+     (array_func)glColor3usv,
+     (array_func)glColor3iv,
+     (array_func)glColor3uiv,
+     (array_func)glColor3fv,
+     (array_func)glColor3dv },
+
+   { (array_func)glColor4bv,
+     (array_func)glColor4ubv,
+     (array_func)glColor4sv,
+     (array_func)glColor4usv,
+     (array_func)glColor4iv,
+     (array_func)glColor4uiv,
+     (array_func)glColor4fv,
+     (array_func)glColor4dv }
+};
+
+static void (*vertexfuncs[3][8])( const void * ) = {
+   { 0,
+     0,
+     (array_func)glVertex2sv,
+     0,
+     (array_func)glVertex2iv,
+     0,
+     (array_func)glVertex2fv,
+     (array_func)glVertex2dv },
+
+   { 0,
+     0,
+     (array_func)glVertex3sv,
+     0,
+     (array_func)glVertex3iv,
+     0,
+     (array_func)glVertex3fv,
+     (array_func)glVertex3dv },
+
+   { 0,
+     0,
+     (array_func)glVertex4sv,
+     0,
+     (array_func)glVertex4iv,
+     0,
+     (array_func)glVertex4fv,
+     (array_func)glVertex4dv }
+};
+
+
+static void (*multitexfuncs[4][8])( GLenum, const void * ) = {
+   { 0,
+     0,
+     (texarray_func)glMultiTexCoord1svARB,
+     0,
+     (texarray_func)glMultiTexCoord1ivARB,
+     0,
+     (texarray_func)glMultiTexCoord1fvARB,
+     (texarray_func)glMultiTexCoord1dvARB },
+
+   { 0,
+     0,
+     (texarray_func)glMultiTexCoord2svARB,
+     0,
+     (texarray_func)glMultiTexCoord2ivARB,
+     0,
+     (texarray_func)glMultiTexCoord2fvARB,
+     (texarray_func)glMultiTexCoord2dvARB },
+
+   { 0,
+     0,
+     (texarray_func)glMultiTexCoord3svARB,
+     0,
+     (texarray_func)glMultiTexCoord3ivARB,
+     0,
+     (texarray_func)glMultiTexCoord3fvARB,
+     (texarray_func)glMultiTexCoord3dvARB },
+
+   { 0,
+     0,
+     (texarray_func)glMultiTexCoord4svARB,
+     0,
+     (texarray_func)glMultiTexCoord4ivARB,
+     0,
+     (texarray_func)glMultiTexCoord4fvARB,
+     (texarray_func)glMultiTexCoord4dvARB }
+};
+
+static void (*indexfuncs[8])( const void * ) = {
+   0,
+   (array_func)glIndexubv,
+   (array_func)glIndexsv,
+   0,
+   (array_func)glIndexiv,
+   0,
+   (array_func)glIndexfv,
+   (array_func)glIndexdv
+};
+
+
+static void (*normalfuncs[8])( const void * ) = {
+   (array_func)glNormal3bv,
+   0,
+   (array_func)glNormal3sv,
+   0,
+   (array_func)glNormal3iv,
+   0,
+   (array_func)glNormal3fv,
+   (array_func)glNormal3dv,
+};
+
+
+/* Wrapper functions in case glSecondaryColor*EXT doesn't exist */
+static void SecondaryColor3bvEXT(const GLbyte *c)
+{
+   _glapi_Dispatch->SecondaryColor3bvEXT(c);
+}
+
+static void SecondaryColor3ubvEXT(const GLubyte *c)
+{
+   _glapi_Dispatch->SecondaryColor3ubvEXT(c);
+}
+
+static void SecondaryColor3svEXT(const GLshort *c)
+{
+   _glapi_Dispatch->SecondaryColor3svEXT(c);
+}
+
+static void SecondaryColor3usvEXT(const GLushort *c)
+{
+   _glapi_Dispatch->SecondaryColor3usvEXT(c);
+}
+
+static void SecondaryColor3ivEXT(const GLint *c)
+{
+   _glapi_Dispatch->SecondaryColor3ivEXT(c);
+}
+
+static void SecondaryColor3uivEXT(const GLuint *c)
+{
+   _glapi_Dispatch->SecondaryColor3uivEXT(c);
+}
+
+static void SecondaryColor3fvEXT(const GLfloat *c)
+{
+   _glapi_Dispatch->SecondaryColor3fvEXT(c);
+}
+
+static void SecondaryColor3dvEXT(const GLdouble *c)
+{
+   _glapi_Dispatch->SecondaryColor3dvEXT(c);
+}
+
+static void (*secondarycolorfuncs[8])( const void * ) = {
+   (array_func) SecondaryColor3bvEXT,
+   (array_func) SecondaryColor3ubvEXT,
+   (array_func) SecondaryColor3svEXT,
+   (array_func) SecondaryColor3usvEXT,
+   (array_func) SecondaryColor3ivEXT,
+   (array_func) SecondaryColor3uivEXT,
+   (array_func) SecondaryColor3fvEXT,
+   (array_func) SecondaryColor3dvEXT,
+};
+
+
+/* Again, wrapper functions in case glSecondaryColor*EXT doesn't exist */
+static void FogCoordfvEXT(const GLfloat *f)
+{
+   _glapi_Dispatch->FogCoordfvEXT(f);
+}
+
+static void FogCoorddvEXT(const GLdouble *f)
+{
+   _glapi_Dispatch->FogCoorddvEXT(f);
+}
+
+static void (*fogcoordfuncs[8])( const void * ) = {
+   0,
+   0,
+   0,
+   0,
+   0,
+   0,
+   (array_func) FogCoordfvEXT,
+   (array_func) FogCoorddvEXT
+};
+
+
+
+GLboolean _ae_create_context( GLcontext *ctx )
+{
+   ctx->aelt_context = MALLOC( sizeof(AEcontext) );
+   if (!ctx->aelt_context) 
+      return GL_FALSE;
+
+   AE_CONTEXT(ctx)->NewState = ~0;
+   return GL_TRUE;
+}
+
+
+void _ae_destroy_context( GLcontext *ctx )
+{
+   if ( AE_CONTEXT( ctx ) ) {
+      FREE( ctx->aelt_context );
+      ctx->aelt_context = 0;
+   }
+}
+
+
+static void _ae_update_state( GLcontext *ctx )
+{
+   AEcontext *actx = AE_CONTEXT(ctx);
+   AEtexarray *ta = actx->texarrays;
+   AEarray *aa = actx->arrays;
+   GLuint i;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+      if (ctx->Array.TexCoord[i].Enabled) {
+	 ta->unit = i;
+	 ta->array = &ctx->Array.TexCoord[i];
+	 ta->func = multitexfuncs[ta->array->Size-1][TYPE_IDX(ta->array->Type)];
+	 ta++;
+      }
+
+   ta->func = 0;
+
+   if (ctx->Array.Color.Enabled) {
+      aa->array = &ctx->Array.Color;
+      aa->func = colorfuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)];
+      aa++;
+   }
+
+   if (ctx->Array.Normal.Enabled) {
+      aa->array = &ctx->Array.Normal;
+      aa->func = normalfuncs[TYPE_IDX(aa->array->Type)];
+      aa++;
+   }
+
+   if (ctx->Array.Index.Enabled) {
+      aa->array = &ctx->Array.Index;
+      aa->func = indexfuncs[TYPE_IDX(aa->array->Type)];
+      aa++;
+   }
+
+   if (ctx->Array.EdgeFlag.Enabled) {
+      aa->array = &ctx->Array.EdgeFlag;
+      aa->func = (array_func) glEdgeFlagv;
+      aa++;
+   }
+
+   if (ctx->Array.FogCoord.Enabled) {
+      aa->array = &ctx->Array.FogCoord;
+      aa->func = fogcoordfuncs[TYPE_IDX(aa->array->Type)];
+      aa++;
+   }
+
+   if (ctx->Array.SecondaryColor.Enabled) {
+      aa->array = &ctx->Array.SecondaryColor;
+      aa->func = secondarycolorfuncs[TYPE_IDX(aa->array->Type)];
+      aa++;
+   }
+
+   /* Must be last
+    */
+   if (ctx->Array.Vertex.Enabled) {
+      aa->array = &ctx->Array.Vertex;
+      aa->func = vertexfuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)];
+      aa++;
+   }
+
+   aa->func = 0;
+   actx->NewState = 0;
+}
+
+
+void _ae_loopback_array_elt( GLint elt )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   AEcontext *actx = AE_CONTEXT(ctx);
+   AEtexarray *ta;
+   AEarray *aa;
+
+   if (actx->NewState)
+      _ae_update_state( ctx );
+
+   for (ta = actx->texarrays ; ta->func ; ta++) {
+      ta->func( ta->unit + GL_TEXTURE0_ARB, (char *)ta->array->Ptr + elt * ta->array->StrideB );
+   }
+
+   /* Must be last
+    */
+   for (aa = actx->arrays ; aa->func ; aa++) {
+      aa->func( (char *)aa->array->Ptr + elt * aa->array->StrideB );
+   }
+}
+
+
+
+void _ae_invalidate_state( GLcontext *ctx, GLuint new_state )
+{
+   AE_CONTEXT(ctx)->NewState |= new_state;
+}
Index: xc/extras/Mesa/src/api_arrayelt.h
diff -u /dev/null xc/extras/Mesa/src/api_arrayelt.h:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_arrayelt.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,37 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef API_ARRAYELT_H
+#define API_ARRAYELT_H
+
+#include "mtypes.h"
+
+extern GLboolean _ae_create_context( GLcontext *ctx );
+extern void _ae_destroy_context( GLcontext *ctx );
+extern void _ae_invalidate_state( GLcontext *ctx, GLuint new_state );
+extern void _ae_loopback_array_elt( GLint elt );
+
+#endif
Index: xc/extras/Mesa/src/api_eval.c
diff -u /dev/null xc/extras/Mesa/src/api_eval.c:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_eval.c	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,323 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "api_eval.h"
+#include "context.h"
+#include "macros.h"
+#include "mmath.h"
+#include "math/m_eval.h"
+
+static void do_EvalCoord1f(GLcontext* ctx, GLfloat u)
+{
+
+   /** Color Index **/
+   if (ctx->Eval.Map1Index) 
+   {
+      GLfloat findex;
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
+      glIndexi( (GLint) findex );
+   }
+
+   /** Color **/
+   if (ctx->Eval.Map1Color4) {
+      GLfloat fcolor[4];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
+      glColor4fv( fcolor );
+   }
+
+   /** Normal Vector **/
+   if (ctx->Eval.Map1Normal) {
+      GLfloat normal[3];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
+      glNormal3fv( normal );
+   }
+
+   /** Texture Coordinates **/
+   if (ctx->Eval.Map1TextureCoord4) {
+      GLfloat texcoord[4];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
+      glTexCoord4fv( texcoord );
+   }
+   else if (ctx->Eval.Map1TextureCoord3) {
+      GLfloat texcoord[4];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
+      glTexCoord3fv( texcoord );
+   }
+   else if (ctx->Eval.Map1TextureCoord2) {
+      GLfloat texcoord[4];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
+      glTexCoord2fv( texcoord );
+   }
+   else if (ctx->Eval.Map1TextureCoord1) {
+      GLfloat texcoord[4];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
+      glTexCoord1fv( texcoord );
+   }
+  
+   /** Vertex **/
+   if (ctx->Eval.Map1Vertex4) 
+   {
+      GLfloat vertex[4];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
+      glVertex4fv( vertex );
+   }
+   else if (ctx->Eval.Map1Vertex3) 
+   {
+      GLfloat vertex[4];
+      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
+      GLfloat uu = (u - map->u1) * map->du;
+      _math_horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
+      glVertex3fv( vertex );
+   }
+}
+
+#define CROSS_PROD(n, u, v) \
+  (n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
+  (n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
+  (n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
+
+
+static void do_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v )
+{   
+   /** Color Index **/
+   if (ctx->Eval.Map2Index) {
+      GLfloat findex;
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      _math_horner_bezier_surf(map->Points, &findex, uu, vv, 1,
+                         map->Uorder, map->Vorder);
+      glIndexi( (GLuint) (GLint) findex );
+   }
+
+   /** Color **/
+   if (ctx->Eval.Map2Color4) {
+      GLfloat fcolor[4];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      _math_horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
+                         map->Uorder, map->Vorder);
+      glColor4fv( fcolor );
+   }
+
+   /** Normal **/
+   if (ctx->Eval.Map2Normal &&
+       (!ctx->Eval.AutoNormal || (!ctx->Eval.Map2Vertex3 && 
+				  !ctx->Eval.Map2Vertex4))) {
+      GLfloat normal[3];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      _math_horner_bezier_surf(map->Points, normal, uu, vv, 3,
+			 map->Uorder, map->Vorder);
+      glNormal3fv( normal );
+   }
+
+   /** Texture Coordinates **/
+   if (ctx->Eval.Map2TextureCoord4) {
+      GLfloat texcoord[4];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      _math_horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
+                         map->Uorder, map->Vorder);
+      glTexCoord4fv( texcoord );
+   }
+   else if (ctx->Eval.Map2TextureCoord3) {
+      GLfloat texcoord[4];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      _math_horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
+                         map->Uorder, map->Vorder);
+      glTexCoord3fv( texcoord );
+   }
+   else if (ctx->Eval.Map2TextureCoord2) {
+      GLfloat texcoord[4];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      _math_horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
+                         map->Uorder, map->Vorder);
+      glTexCoord2fv( texcoord );
+   }
+   else if (ctx->Eval.Map2TextureCoord1) {
+      GLfloat texcoord[4];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      _math_horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
+                         map->Uorder, map->Vorder);
+      glTexCoord1fv( texcoord );
+   }
+
+   /** Vertex **/
+   if(ctx->Eval.Map2Vertex4) {
+      GLfloat vertex[4];
+      GLfloat normal[3];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+
+      if (ctx->Eval.AutoNormal) {
+         GLfloat du[4], dv[4];
+
+         _math_de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
+				 map->Uorder, map->Vorder);
+
+         CROSS_PROD(normal, du, dv);
+         NORMALIZE_3FV(normal);
+      }
+      else {
+         _math_horner_bezier_surf(map->Points, vertex, uu, vv, 4,
+                            map->Uorder, map->Vorder);
+      }
+   }
+   else if (ctx->Eval.Map2Vertex3) {
+      GLfloat vertex[4];
+      struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
+      GLfloat uu = (u - map->u1) * map->du;
+      GLfloat vv = (v - map->v1) * map->dv;
+      if (ctx->Eval.AutoNormal) {
+         GLfloat du[3], dv[3];
+	 GLfloat normal[3];
+         _math_de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
+				 map->Uorder, map->Vorder);
+         CROSS_PROD(normal, du, dv);
+         NORMALIZE_3FV(normal);
+	 glNormal3fv( normal );
+	 glVertex3fv( vertex );
+      }
+      else {
+         _math_horner_bezier_surf(map->Points, vertex, uu, vv, 3,
+                            map->Uorder, map->Vorder);
+	 glVertex3fv( vertex );
+      }
+   }
+}
+
+
+void _mesa_EvalPoint1( GLint i )
+{
+   GET_CURRENT_CONTEXT( ctx );
+   GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) /
+		 (GLfloat) ctx->Eval.MapGrid1un);
+   GLfloat u = i * du + ctx->Eval.MapGrid1u1;
+
+   glEvalCoord1f( u );
+}
+
+
+void _mesa_EvalPoint2( GLint i, GLint j )
+{
+   GET_CURRENT_CONTEXT( ctx );
+   GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) / 
+		 (GLfloat) ctx->Eval.MapGrid2un);
+   GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) / 
+		 (GLfloat) ctx->Eval.MapGrid2vn);
+   GLfloat u = i * du + ctx->Eval.MapGrid2u1;
+   GLfloat v = j * dv + ctx->Eval.MapGrid2v1;
+
+   glEvalCoord2f( u, v );
+}
+
+/* Wierd thing about eval is that it doesn't affect 'current' values.
+ * This technique of saving and resetting current values requires
+ * that: 
+ *
+ *   1) Current values are updated immediately in the glColor,
+ *   etc. functions.
+ *
+ *   2) Hardware color values are stored seperately from ctx->Current, 
+ *      for example in dma buffers, or direct emit to registers.
+ */
+void _mesa_EvalCoord1f( GLfloat u )
+{
+   GET_CURRENT_CONTEXT( ctx );
+   GLfloat normal[3], texcoord[4], color[4];
+   GLuint index;
+
+   COPY_3FV( normal, ctx->Current.Normal );
+   COPY_4FV( texcoord, ctx->Current.Texcoord[0] );
+   COPY_4FV( color, ctx->Current.Color );
+   index = ctx->Current.Index;
+
+   do_EvalCoord1f( ctx, u );
+
+   COPY_3FV( ctx->Current.Normal, normal );
+   COPY_4FV( ctx->Current.Texcoord[0], texcoord );
+   COPY_4FV( ctx->Current.Color, color );
+   ctx->Current.Index = index;
+}
+
+void _mesa_EvalCoord2f( GLfloat u, GLfloat v )
+{
+   GET_CURRENT_CONTEXT( ctx );
+   GLfloat normal[3], texcoord[4], color[4];
+   GLuint index;
+
+   COPY_3FV( normal, ctx->Current.Normal );
+   COPY_4FV( texcoord, ctx->Current.Texcoord[0] );
+   COPY_4FV( color, ctx->Current.Color );
+   index = ctx->Current.Index;
+
+   do_EvalCoord2f( ctx, u, v );
+
+   COPY_3FV( ctx->Current.Normal, normal );
+   COPY_4FV( ctx->Current.Texcoord[0], texcoord );
+   COPY_4FV( ctx->Current.Color, color );
+   ctx->Current.Index = index;
+}
+
+void _mesa_EvalCoord1fv( const GLfloat *u )
+{
+   glEvalCoord1f( u[0] );
+}
+
+void _mesa_EvalCoord2fv( const GLfloat *u )
+{
+   glEvalCoord2f( u[0], u[1] );
+}
Index: xc/extras/Mesa/src/api_eval.h
diff -u /dev/null xc/extras/Mesa/src/api_eval.h:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_eval.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,42 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef API_EVAL_H
+#define API_EVAL_H
+
+#include "mtypes.h"
+
+extern void _mesa_EvalPoint1( GLint i );
+extern void _mesa_EvalPoint2( GLint i, GLint j );
+extern void _mesa_EvalCoord1f( GLfloat u );
+extern void _mesa_EvalCoord2f( GLfloat u, GLfloat v );
+extern void _mesa_EvalCoord1fv( const GLfloat *u );
+extern void _mesa_EvalCoord2fv( const GLfloat *u );
+
+#endif
+
+
+
Index: xc/extras/Mesa/src/api_loopback.c
diff -u /dev/null xc/extras/Mesa/src/api_loopback.c:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_loopback.c	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,1569 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "glapi.h"
+#include "glapitable.h"
+#include "macros.h"
+#include "colormac.h"
+#include "api_loopback.h"
+
+/* KW: A set of functions to convert unusual Color/Normal/Vertex/etc
+ * calls to a smaller set of driver-provided formats.  Currently just
+ * go back to dispatch to find these (eg. call glNormal3f directly),
+ * hence 'loopback'.
+ *
+ * The driver must supply all of the remaining entry points, which are
+ * listed in dd.h.  The easiest way for a driver to do this is to
+ * install the supplied software t&l module.
+ */
+#define COLORUBV(v)                 glColor4ubv(v)
+#define COLORF(r,g,b,a)             glColor4f(r,g,b,a)
+#define VERTEX2(x,y)	            glVertex2f(x,y)
+#define VERTEX3(x,y,z)	            glVertex3f(x,y,z)
+#define VERTEX4(x,y,z,w)            glVertex4f(x,y,z,w)
+#define NORMAL(x,y,z)               glNormal3f(x,y,z)
+#define TEXCOORD1(s)                glTexCoord1f(s)
+#define TEXCOORD2(s,t)              glTexCoord2f(s,t)
+#define TEXCOORD3(s,t,u)            glTexCoord3f(s,t,u)
+#define TEXCOORD4(s,t,u,v)          glTexCoord4f(s,t,u,v)
+#define INDEX(c)		    glIndexi(c)
+#define MULTI_TEXCOORD1(z,s)	    glMultiTexCoord1fARB(z,s)
+#define MULTI_TEXCOORD2(z,s,t)	    glMultiTexCoord2fARB(z,s,t)
+#define MULTI_TEXCOORD3(z,s,t,u)    glMultiTexCoord3fARB(z,s,t,u)
+#define MULTI_TEXCOORD4(z,s,t,u,v)  glMultiTexCoord4fARB(z,s,t,u,v)
+#define EVALCOORD1(x)               glEvalCoord1f(x)
+#define EVALCOORD2(x,y)             glEvalCoord2f(x,y)
+#define MATERIALFV(a,b,c)           glMaterialfv(a,b,c)
+#define RECTF(a,b,c,d)              glRectf(a,b,c,d)
+
+
+
+#define FOGCOORDF(x)                _glapi_Dispatch->FogCoordfEXT(x)
+#define SECONDARYCOLORUB(a,b,c)     _glapi_Dispatch->SecondaryColor3ubEXT(a,b,c)
+#define SECONDARYCOLORF(a,b,c)      _glapi_Dispatch->SecondaryColor3fEXT(a,b,c)
+
+
+static void
+loopback_Color3b( GLbyte red, GLbyte green, GLbyte blue )
+{
+   GLubyte col[4];
+   col[0] = BYTE_TO_UBYTE(red);
+   col[1] = BYTE_TO_UBYTE(green);
+   col[2] = BYTE_TO_UBYTE(blue);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3d( GLdouble red, GLdouble green, GLdouble blue )
+{
+   GLubyte col[4];
+   GLfloat r = (GLfloat) red;
+   GLfloat g = (GLfloat) green;
+   GLfloat b = (GLfloat) blue;
+   UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
+   col[3] = 255;
+   COLORUBV( col );
+}
+
+static void
+loopback_Color3i( GLint red, GLint green, GLint blue )
+{
+   GLubyte col[4];
+   col[0] = INT_TO_UBYTE(red);
+   col[1] = INT_TO_UBYTE(green);
+   col[2] = INT_TO_UBYTE(blue);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3s( GLshort red, GLshort green, GLshort blue )
+{
+   GLubyte col[4];
+   col[0] = SHORT_TO_UBYTE(red);
+   col[1] = SHORT_TO_UBYTE(green);
+   col[2] = SHORT_TO_UBYTE(blue);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3ui( GLuint red, GLuint green, GLuint blue )
+{
+   GLubyte col[4];
+   col[0] = UINT_TO_UBYTE(red);
+   col[1] = UINT_TO_UBYTE(green);
+   col[2] = UINT_TO_UBYTE(blue);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3us( GLushort red, GLushort green, GLushort blue )
+{
+   GLubyte col[4];
+   col[0] = USHORT_TO_UBYTE(red);
+   col[1] = USHORT_TO_UBYTE(green);
+   col[2] = USHORT_TO_UBYTE(blue);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
+{
+   GLubyte col[4];
+   col[0] = BYTE_TO_UBYTE(red);
+   col[1] = BYTE_TO_UBYTE(green);
+   col[2] = BYTE_TO_UBYTE(blue);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
+{
+   GLubyte col[4];
+   GLfloat r = (GLfloat) red;
+   GLfloat g = (GLfloat) green;
+   GLfloat b = (GLfloat) blue;
+   GLfloat a = (GLfloat) alpha;
+   UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[3], a);
+   COLORUBV( col );
+}
+
+static void
+loopback_Color4i( GLint red, GLint green, GLint blue, GLint alpha )
+{
+   GLubyte col[4];
+   col[0] = INT_TO_UBYTE(red);
+   col[1] = INT_TO_UBYTE(green);
+   col[2] = INT_TO_UBYTE(blue);
+   col[3] = INT_TO_UBYTE(alpha);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4s( GLshort red, GLshort green, GLshort blue,
+			GLshort alpha )
+{
+   GLubyte col[4];
+   col[0] = SHORT_TO_UBYTE(red);
+   col[1] = SHORT_TO_UBYTE(green);
+   col[2] = SHORT_TO_UBYTE(blue);
+   col[3] = SHORT_TO_UBYTE(alpha);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
+{
+   GLubyte col[4];
+   col[0] = UINT_TO_UBYTE(red);
+   col[1] = UINT_TO_UBYTE(green);
+   col[2] = UINT_TO_UBYTE(blue);
+   col[3] = UINT_TO_UBYTE(alpha);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4us( GLushort red, GLushort green, GLushort blue,
+			 GLushort alpha )
+{
+   GLubyte col[4];
+   col[0] = USHORT_TO_UBYTE(red);
+   col[1] = USHORT_TO_UBYTE(green);
+   col[2] = USHORT_TO_UBYTE(blue);
+   col[3] = USHORT_TO_UBYTE(alpha);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3bv( const GLbyte *v )
+{
+   GLubyte col[4];
+   col[0] = BYTE_TO_UBYTE(v[0]);
+   col[1] = BYTE_TO_UBYTE(v[1]);
+   col[2] = BYTE_TO_UBYTE(v[2]);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3dv( const GLdouble *v )
+{
+   GLubyte col[4];
+   GLfloat r = (GLfloat) v[0];
+   GLfloat g = (GLfloat) v[1];
+   GLfloat b = (GLfloat) v[2];
+   UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
+   col[3] = 255;
+   COLORUBV( col );
+}
+
+static void
+loopback_Color3iv( const GLint *v )
+{
+   GLubyte col[4];
+   col[0] = INT_TO_UBYTE(v[0]);
+   col[1] = INT_TO_UBYTE(v[1]);
+   col[2] = INT_TO_UBYTE(v[2]);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3sv( const GLshort *v )
+{
+   GLubyte col[4];
+   col[0] = SHORT_TO_UBYTE(v[0]);
+   col[1] = SHORT_TO_UBYTE(v[1]);
+   col[2] = SHORT_TO_UBYTE(v[2]);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3uiv( const GLuint *v )
+{
+   GLubyte col[4];
+   col[0] = UINT_TO_UBYTE(v[0]);
+   col[1] = UINT_TO_UBYTE(v[1]);
+   col[2] = UINT_TO_UBYTE(v[2]);
+   col[3] = 255;
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3usv( const GLushort *v )
+{
+   GLubyte col[4];
+   col[0] = USHORT_TO_UBYTE(v[0]);
+   col[1] = USHORT_TO_UBYTE(v[1]);
+   col[2] = USHORT_TO_UBYTE(v[2]);
+   col[3] = 255;
+   COLORUBV(col);
+
+}
+
+static void
+loopback_Color4bv( const GLbyte *v )
+{
+   GLubyte col[4];
+   col[0] = BYTE_TO_UBYTE(v[0]);
+   col[1] = BYTE_TO_UBYTE(v[1]);
+   col[2] = BYTE_TO_UBYTE(v[2]);
+   col[3] = BYTE_TO_UBYTE(v[3]);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4dv( const GLdouble *v )
+{
+   GLubyte col[4];
+   GLfloat r = (GLfloat) v[0];
+   GLfloat g = (GLfloat) v[1];
+   GLfloat b = (GLfloat) v[2];
+   GLfloat a = (GLfloat) v[3];
+   UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[3], a);
+   COLORUBV( col );
+}
+
+static void
+loopback_Color4iv( const GLint *v )
+{
+   GLubyte col[4];
+   col[0] = INT_TO_UBYTE(v[0]);
+   col[1] = INT_TO_UBYTE(v[1]);
+   col[2] = INT_TO_UBYTE(v[2]);
+   col[3] = INT_TO_UBYTE(v[3]);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4sv( const GLshort *v)
+{
+   GLubyte col[4];
+   col[0] = SHORT_TO_UBYTE(v[0]);
+   col[1] = SHORT_TO_UBYTE(v[1]);
+   col[2] = SHORT_TO_UBYTE(v[2]);
+   col[3] = SHORT_TO_UBYTE(v[3]);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4uiv( const GLuint *v)
+{
+   GLubyte col[4];
+   col[0] = UINT_TO_UBYTE(v[0]);
+   col[1] = UINT_TO_UBYTE(v[1]);
+   col[2] = UINT_TO_UBYTE(v[2]);
+   col[3] = UINT_TO_UBYTE(v[3]);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color4usv( const GLushort *v)
+{
+   GLubyte col[4];
+   col[0] = USHORT_TO_UBYTE(v[0]);
+   col[1] = USHORT_TO_UBYTE(v[1]);
+   col[2] = USHORT_TO_UBYTE(v[2]);
+   col[3] = USHORT_TO_UBYTE(v[3]);
+   COLORUBV(col);
+}
+
+static void
+loopback_Color3b_f( GLbyte red, GLbyte green, GLbyte blue )
+{
+   COLORF( BYTE_TO_FLOAT(red),
+	   BYTE_TO_FLOAT(green),
+	   BYTE_TO_FLOAT(blue),
+	   1.0 );
+}
+
+static void
+loopback_Color3d_f( GLdouble red, GLdouble green, GLdouble blue )
+{
+   COLORF( (GLfloat) red, (GLfloat) green, (GLfloat) blue, 1.0 );
+}
+
+static void
+loopback_Color3i_f( GLint red, GLint green, GLint blue )
+{
+   COLORF( INT_TO_FLOAT(red), INT_TO_FLOAT(green),
+	   INT_TO_FLOAT(blue), 1.0);
+}
+
+static void
+loopback_Color3s_f( GLshort red, GLshort green, GLshort blue )
+{
+   COLORF( SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
+	   SHORT_TO_FLOAT(blue), 1.0);
+}
+
+static void
+loopback_Color3ui_f( GLuint red, GLuint green, GLuint blue )
+{
+   COLORF( UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
+	   UINT_TO_FLOAT(blue), 1.0 );
+}
+
+static void
+loopback_Color3us_f( GLushort red, GLushort green, GLushort blue )
+{
+   COLORF( USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
+	   USHORT_TO_FLOAT(blue), 1.0 );
+}
+
+
+static void
+loopback_Color3bv_f( const GLbyte *v )
+{
+   COLORF( BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
+	   BYTE_TO_FLOAT(v[2]), 1.0 );
+}
+
+static void
+loopback_Color3dv_f( const GLdouble *v )
+{
+   COLORF( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0 );
+}
+
+static void
+loopback_Color3iv_f( const GLint *v )
+{
+   COLORF( INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
+	   INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
+}
+
+static void
+loopback_Color3sv_f( const GLshort *v )
+{
+   COLORF( SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
+	   SHORT_TO_FLOAT(v[2]), 1.0 );
+}
+
+static void
+loopback_Color3uiv_f( const GLuint *v )
+{
+   COLORF( UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
+	   UINT_TO_FLOAT(v[2]), 1.0 );
+}
+
+static void
+loopback_Color3usv_f( const GLushort *v )
+{
+   COLORF( USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
+	   USHORT_TO_FLOAT(v[2]), 1.0 );
+}
+
+
+static void
+loopback_Color4b_f( GLbyte red, GLbyte green, GLbyte blue,
+			      GLbyte alpha )
+{
+   COLORF( BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
+	   BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
+}
+
+static void
+loopback_Color4d_f( GLdouble red, GLdouble green, GLdouble blue,
+			      GLdouble alpha )
+{
+   COLORF( (GLfloat) red, (GLfloat) green, (GLfloat) blue, (GLfloat) alpha );
+}
+
+static void
+loopback_Color4i_f( GLint red, GLint green, GLint blue, GLint alpha )
+{
+   COLORF( INT_TO_FLOAT(red), INT_TO_FLOAT(green),
+	   INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
+}
+
+static void
+loopback_Color4s_f( GLshort red, GLshort green, GLshort blue,
+			      GLshort alpha )
+{
+   COLORF( SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
+	   SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
+}
+
+static void
+loopback_Color4ui_f( GLuint red, GLuint green, GLuint blue, GLuint alpha )
+{
+   COLORF( UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
+	   UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
+}
+
+static void
+loopback_Color4us_f( GLushort red, GLushort green, GLushort blue, GLushort alpha )
+{
+   COLORF( USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
+	   USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
+}
+
+
+static void
+loopback_Color4iv_f( const GLint *v )
+{
+   COLORF( INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
+	   INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
+}
+
+
+static void
+loopback_Color4bv_f( const GLbyte *v )
+{
+   COLORF( BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
+	   BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
+}
+
+static void
+loopback_Color4dv_f( const GLdouble *v )
+{
+   COLORF( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3] );
+}
+
+
+static void
+loopback_Color4sv_f( const GLshort *v)
+{
+   COLORF( SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
+	   SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
+}
+
+
+static void
+loopback_Color4uiv_f( const GLuint *v)
+{
+   COLORF( UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
+	   UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
+}
+
+static void
+loopback_Color4usv_f( const GLushort *v)
+{
+   COLORF( USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
+	   USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
+}
+
+static void
+loopback_FogCoorddEXT( GLdouble d )
+{
+   FOGCOORDF( (GLfloat) d );
+}
+
+static void
+loopback_FogCoorddvEXT( const GLdouble *v )
+{
+   FOGCOORDF( (GLfloat) *v );
+}
+
+
+static void
+loopback_Indexd( GLdouble c )
+{
+   INDEX( (GLint) c );
+}
+
+static void
+loopback_Indexf( GLfloat c )
+{
+   INDEX( (GLuint) (GLint) c );
+}
+
+static void
+loopback_Indexs( GLshort c )
+{
+   INDEX( (GLint) c );
+}
+
+static void
+loopback_Indexub( GLubyte c )
+{
+   INDEX( (GLint) c );
+}
+
+static void
+loopback_Indexdv( const GLdouble *c )
+{
+   INDEX( (GLint) (GLint) *c );
+}
+
+static void
+loopback_Indexfv( const GLfloat *c )
+{
+   INDEX( (GLint) (GLint) *c );
+}
+
+static void
+loopback_Indexiv( const GLint *c )
+{
+   INDEX( *c );
+}
+
+static void
+loopback_Indexsv( const GLshort *c )
+{
+   INDEX( (GLint) *c );
+}
+
+static void
+loopback_Indexubv( const GLubyte *c )
+{
+   INDEX( (GLint) *c );
+}
+
+static void
+loopback_Normal3b( GLbyte nx, GLbyte ny, GLbyte nz )
+{
+   NORMAL( BYTE_TO_FLOAT(nx), BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
+}
+
+static void
+loopback_Normal3d( GLdouble nx, GLdouble ny, GLdouble nz )
+{
+   NORMAL((GLfloat) nx, (GLfloat) ny, (GLfloat) nz);
+}
+
+static void
+loopback_Normal3i( GLint nx, GLint ny, GLint nz )
+{
+   NORMAL( INT_TO_FLOAT(nx), INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
+}
+
+static void
+loopback_Normal3s( GLshort nx, GLshort ny, GLshort nz )
+{
+   NORMAL( SHORT_TO_FLOAT(nx), SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
+}
+
+static void
+loopback_Normal3bv( const GLbyte *v )
+{
+   NORMAL( BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
+}
+
+static void
+loopback_Normal3dv( const GLdouble *v )
+{
+   NORMAL( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+
+static void
+loopback_Normal3iv( const GLint *v )
+{
+   NORMAL( INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
+}
+
+static void
+loopback_Normal3sv( const GLshort *v )
+{
+   NORMAL( SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
+}
+
+static void
+loopback_TexCoord1d( GLdouble s )
+{
+   TEXCOORD1((GLfloat) s);
+}
+
+static void
+loopback_TexCoord1i( GLint s )
+{
+   TEXCOORD1((GLfloat) s);
+}
+
+static void
+loopback_TexCoord1s( GLshort s )
+{
+   TEXCOORD1((GLfloat) s);
+}
+
+static void
+loopback_TexCoord2d( GLdouble s, GLdouble t )
+{
+   TEXCOORD2((GLfloat) s,(GLfloat) t);
+}
+
+static void
+loopback_TexCoord2s( GLshort s, GLshort t )
+{
+   TEXCOORD2((GLfloat) s,(GLfloat) t);
+}
+
+static void
+loopback_TexCoord2i( GLint s, GLint t )
+{
+   TEXCOORD2((GLfloat) s,(GLfloat) t);
+}
+
+static void
+loopback_TexCoord3d( GLdouble s, GLdouble t, GLdouble r )
+{
+   TEXCOORD3((GLfloat) s,(GLfloat) t,(GLfloat) r);
+}
+
+static void
+loopback_TexCoord3i( GLint s, GLint t, GLint r )
+{
+   TEXCOORD3((GLfloat) s,(GLfloat) t,(GLfloat) r);
+}
+
+static void
+loopback_TexCoord3s( GLshort s, GLshort t, GLshort r )
+{
+   TEXCOORD3((GLfloat) s,(GLfloat) t,(GLfloat) r);
+}
+
+static void
+loopback_TexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
+{
+   TEXCOORD4((GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
+}
+
+static void
+loopback_TexCoord4i( GLint s, GLint t, GLint r, GLint q )
+{
+   TEXCOORD4((GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
+}
+
+static void
+loopback_TexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
+{
+   TEXCOORD4((GLfloat) s,(GLfloat) t,(GLfloat) r,(GLfloat) q);
+}
+
+static void
+loopback_TexCoord1dv( const GLdouble *v )
+{
+   TEXCOORD1((GLfloat) v[0]);
+}
+
+static void
+loopback_TexCoord1iv( const GLint *v )
+{
+   TEXCOORD1((GLfloat) v[0]);
+}
+
+static void
+loopback_TexCoord1sv( const GLshort *v )
+{
+   TEXCOORD1((GLfloat) v[0]);
+}
+
+static void
+loopback_TexCoord2dv( const GLdouble *v )
+{
+   TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
+}
+
+static void
+loopback_TexCoord2iv( const GLint *v )
+{
+   TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
+}
+
+static void
+loopback_TexCoord2sv( const GLshort *v )
+{
+   TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
+}
+
+static void
+loopback_TexCoord3dv( const GLdouble *v )
+{
+   TEXCOORD2((GLfloat) v[0],(GLfloat) v[1]);
+}
+
+static void
+loopback_TexCoord3iv( const GLint *v )
+{
+   TEXCOORD3((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2]);
+}
+
+static void
+loopback_TexCoord3sv( const GLshort *v )
+{
+   TEXCOORD3((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2]);
+}
+
+static void
+loopback_TexCoord4dv( const GLdouble *v )
+{
+   TEXCOORD4((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
+}
+
+static void
+loopback_TexCoord4iv( const GLint *v )
+{
+   TEXCOORD4((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
+}
+
+static void
+loopback_TexCoord4sv( const GLshort *v )
+{
+   TEXCOORD4((GLfloat) v[0],(GLfloat) v[1],(GLfloat) v[2],(GLfloat) v[3]);
+}
+
+static void
+loopback_Vertex2d( GLdouble x, GLdouble y )
+{
+   VERTEX2( (GLfloat) x, (GLfloat) y );
+}
+
+static void
+loopback_Vertex2i( GLint x, GLint y )
+{
+   VERTEX2( (GLfloat) x, (GLfloat) y );
+}
+
+static void
+loopback_Vertex2s( GLshort x, GLshort y )
+{
+   VERTEX2( (GLfloat) x, (GLfloat) y );
+}
+
+static void
+loopback_Vertex3d( GLdouble x, GLdouble y, GLdouble z )
+{
+   VERTEX3( (GLfloat) x, (GLfloat) y, (GLfloat) z );
+}
+
+static void
+loopback_Vertex3i( GLint x, GLint y, GLint z )
+{
+   VERTEX3( (GLfloat) x, (GLfloat) y, (GLfloat) z );
+}
+
+static void
+loopback_Vertex3s( GLshort x, GLshort y, GLshort z )
+{
+   VERTEX3( (GLfloat) x, (GLfloat) y, (GLfloat) z );
+}
+
+static void
+loopback_Vertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
+   VERTEX4( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
+}
+
+static void
+loopback_Vertex4i( GLint x, GLint y, GLint z, GLint w )
+{
+   VERTEX4( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
+}
+
+static void
+loopback_Vertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
+{
+   VERTEX4( (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
+}
+
+static void
+loopback_Vertex2dv( const GLdouble *v )
+{
+   VERTEX2( (GLfloat) v[0], (GLfloat) v[1] );
+}
+
+static void
+loopback_Vertex2iv( const GLint *v )
+{
+   VERTEX2( (GLfloat) v[0], (GLfloat) v[1] );
+}
+
+static void
+loopback_Vertex2sv( const GLshort *v )
+{
+   VERTEX2( (GLfloat) v[0], (GLfloat) v[1] );
+}
+
+static void
+loopback_Vertex3dv( const GLdouble *v )
+{
+   VERTEX3( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+
+static void
+loopback_Vertex3iv( const GLint *v )
+{
+   VERTEX3( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+
+static void
+loopback_Vertex3sv( const GLshort *v )
+{
+   VERTEX3( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+
+static void
+loopback_Vertex4dv( const GLdouble *v )
+{
+   VERTEX4( (GLfloat) v[0], (GLfloat) v[1],
+	    (GLfloat) v[2], (GLfloat) v[3] );
+}
+
+static void
+loopback_Vertex4iv( const GLint *v )
+{
+   VERTEX4( (GLfloat) v[0], (GLfloat) v[1],
+	    (GLfloat) v[2], (GLfloat) v[3] );
+}
+
+static void
+loopback_Vertex4sv( const GLshort *v )
+{
+   VERTEX4( (GLfloat) v[0], (GLfloat) v[1],
+	    (GLfloat) v[2], (GLfloat) v[3] );
+}
+
+static void
+loopback_MultiTexCoord1dARB(GLenum target, GLdouble s)
+{
+   MULTI_TEXCOORD1( target, (GLfloat) s );
+}
+
+static void
+loopback_MultiTexCoord1dvARB(GLenum target, const GLdouble *v)
+{
+   MULTI_TEXCOORD1( target, (GLfloat) v[0] );
+}
+
+static void
+loopback_MultiTexCoord1iARB(GLenum target, GLint s)
+{
+   MULTI_TEXCOORD1( target, (GLfloat) s );
+}
+
+static void
+loopback_MultiTexCoord1ivARB(GLenum target, const GLint *v)
+{
+   MULTI_TEXCOORD1( target, (GLfloat) v[0] );
+}
+
+static void
+loopback_MultiTexCoord1sARB(GLenum target, GLshort s)
+{
+   MULTI_TEXCOORD1( target, (GLfloat) s );
+}
+
+static void
+loopback_MultiTexCoord1svARB(GLenum target, const GLshort *v)
+{
+   MULTI_TEXCOORD1( target, (GLfloat) v[0] );
+}
+
+static void
+loopback_MultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
+{
+   MULTI_TEXCOORD2( target, (GLfloat) s, (GLfloat) t );
+}
+
+static void
+loopback_MultiTexCoord2dvARB(GLenum target, const GLdouble *v)
+{
+   MULTI_TEXCOORD2( target, (GLfloat) v[0], (GLfloat) v[1] );
+}
+
+static void
+loopback_MultiTexCoord2iARB(GLenum target, GLint s, GLint t)
+{
+   MULTI_TEXCOORD2( target, (GLfloat) s, (GLfloat) t );
+}
+
+static void
+loopback_MultiTexCoord2ivARB(GLenum target, const GLint *v)
+{
+   MULTI_TEXCOORD2( target, (GLfloat) v[0], (GLfloat) v[1] );
+}
+
+static void
+loopback_MultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
+{
+   MULTI_TEXCOORD2( target, (GLfloat) s, (GLfloat) t );
+}
+
+static void
+loopback_MultiTexCoord2svARB(GLenum target, const GLshort *v)
+{
+   MULTI_TEXCOORD2( target, (GLfloat) v[0], (GLfloat) v[1] );
+}
+
+static void
+loopback_MultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
+{
+   MULTI_TEXCOORD3( target, (GLfloat) s, (GLfloat) t, (GLfloat) r );
+}
+
+static void
+loopback_MultiTexCoord3dvARB(GLenum target, const GLdouble *v)
+{
+   MULTI_TEXCOORD3( target, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+
+static void
+loopback_MultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
+{
+   MULTI_TEXCOORD3( target, (GLfloat) s, (GLfloat) t, (GLfloat) r );
+}
+
+static void
+loopback_MultiTexCoord3ivARB(GLenum target, const GLint *v)
+{
+   MULTI_TEXCOORD3( target, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+
+static void
+loopback_MultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
+{
+   MULTI_TEXCOORD3( target, (GLfloat) s, (GLfloat) t, (GLfloat) r );
+}
+
+static void
+loopback_MultiTexCoord3svARB(GLenum target, const GLshort *v)
+{
+   MULTI_TEXCOORD3( target, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+
+static void
+loopback_MultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+   MULTI_TEXCOORD4( target, (GLfloat) s, (GLfloat) t, 
+		    (GLfloat) r, (GLfloat) q );
+}
+
+static void
+loopback_MultiTexCoord4dvARB(GLenum target, const GLdouble *v)
+{
+   MULTI_TEXCOORD4( target, (GLfloat) v[0], (GLfloat) v[1], 
+		    (GLfloat) v[2], (GLfloat) v[3] );
+}
+
+static void
+loopback_MultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
+{
+   MULTI_TEXCOORD4( target, (GLfloat) s, (GLfloat) t,
+		    (GLfloat) r, (GLfloat) q );
+}
+
+static void
+loopback_MultiTexCoord4ivARB(GLenum target, const GLint *v)
+{
+   MULTI_TEXCOORD4( target, (GLfloat) v[0], (GLfloat) v[1],
+		    (GLfloat) v[2], (GLfloat) v[3] );
+}
+
+static void
+loopback_MultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
+{
+   MULTI_TEXCOORD4( target, (GLfloat) s, (GLfloat) t,
+		    (GLfloat) r, (GLfloat) q );
+}
+
+static void
+loopback_MultiTexCoord4svARB(GLenum target, const GLshort *v)
+{
+   MULTI_TEXCOORD4( target, (GLfloat) v[0], (GLfloat) v[1],
+		    (GLfloat) v[2], (GLfloat) v[3] );
+}
+
+static void
+loopback_EvalCoord2dv( const GLdouble *u )
+{
+   EVALCOORD2( (GLfloat) u[0], (GLfloat) u[1] );
+}
+
+static void
+loopback_EvalCoord2fv( const GLfloat *u )
+{
+   EVALCOORD2( u[0], u[1] );
+}
+
+static void
+loopback_EvalCoord2d( GLdouble u, GLdouble v )
+{
+   EVALCOORD2( (GLfloat) u, (GLfloat) v );
+}
+
+static void
+loopback_EvalCoord1dv( const GLdouble *u )
+{
+   EVALCOORD1( (GLfloat) *u );
+}
+
+static void
+loopback_EvalCoord1fv( const GLfloat *u )
+{
+   EVALCOORD1( (GLfloat) *u );
+}
+
+static void
+loopback_EvalCoord1d( GLdouble u )
+{
+   EVALCOORD1( (GLfloat) u );
+}
+
+static void
+loopback_Materialf( GLenum face, GLenum pname, GLfloat param )
+{
+   GLfloat fparam[4];
+   fparam[0] = param;
+   MATERIALFV( face, pname, fparam );
+}
+
+static void
+loopback_Materiali(GLenum face, GLenum pname, GLint param )
+{
+   GLfloat p = (GLfloat) param;
+   MATERIALFV(face, pname, &p);
+}
+
+static void
+loopback_Materialiv(GLenum face, GLenum pname, const GLint *params )
+{
+   GLfloat fparam[4];
+   switch (pname) {
+   case GL_AMBIENT:
+   case GL_DIFFUSE:
+   case GL_SPECULAR:
+   case GL_EMISSION:
+   case GL_AMBIENT_AND_DIFFUSE:
+      fparam[0] = INT_TO_FLOAT( params[0] );
+      fparam[1] = INT_TO_FLOAT( params[1] );
+      fparam[2] = INT_TO_FLOAT( params[2] );
+      fparam[3] = INT_TO_FLOAT( params[3] );
+      break;
+   case GL_SHININESS:
+      fparam[0] = (GLfloat) params[0];
+      break;
+   case GL_COLOR_INDEXES:
+      fparam[0] = (GLfloat) params[0];
+      fparam[1] = (GLfloat) params[1];
+      fparam[2] = (GLfloat) params[2];
+      break;
+   default:
+      ;
+   }
+   MATERIALFV(face, pname, fparam);
+}
+
+
+static void
+loopback_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+   RECTF((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
+}
+
+static void
+loopback_Rectdv(const GLdouble *v1, const GLdouble *v2)
+{
+   RECTF((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
+}
+
+static void
+loopback_Rectfv(const GLfloat *v1, const GLfloat *v2)
+{
+   RECTF(v1[0], v1[1], v2[0], v2[1]);
+}
+
+static void
+loopback_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+   RECTF((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
+}
+
+static void
+loopback_Rectiv(const GLint *v1, const GLint *v2)
+{
+   RECTF((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
+}
+
+static void
+loopback_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+   RECTF((GLfloat) x1, (GLfloat) y1, (GLfloat) x2, (GLfloat) y2);
+}
+
+static void
+loopback_Rectsv(const GLshort *v1, const GLshort *v2)
+{
+   RECTF((GLfloat) v1[0], (GLfloat) v1[1], (GLfloat) v2[0], (GLfloat) v2[1]);
+}
+
+static void
+loopback_SecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue )
+{
+   SECONDARYCOLORUB( BYTE_TO_UBYTE(red),
+		     BYTE_TO_UBYTE(green),
+		     BYTE_TO_UBYTE(blue) );
+}
+
+static void
+loopback_SecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue )
+{
+   GLubyte col[3];
+   GLfloat r = (GLfloat) red;
+   GLfloat g = (GLfloat) green;
+   GLfloat b = (GLfloat) blue;
+   UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
+   SECONDARYCOLORUB( col[0], col[1], col[2] );
+}
+
+static void
+loopback_SecondaryColor3iEXT( GLint red, GLint green, GLint blue )
+{
+   SECONDARYCOLORUB( INT_TO_UBYTE(red),
+		     INT_TO_UBYTE(green),
+		     INT_TO_UBYTE(blue));
+}
+
+static void
+loopback_SecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue )
+{
+   SECONDARYCOLORUB(SHORT_TO_UBYTE(red),
+		    SHORT_TO_UBYTE(green),
+		    SHORT_TO_UBYTE(blue));
+}
+
+static void
+loopback_SecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue )
+{
+   SECONDARYCOLORUB(UINT_TO_UBYTE(red),
+		    UINT_TO_UBYTE(green),
+		    UINT_TO_UBYTE(blue));
+}
+
+static void
+loopback_SecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue )
+{
+   SECONDARYCOLORUB(USHORT_TO_UBYTE(red),
+		    USHORT_TO_UBYTE(green),
+		    USHORT_TO_UBYTE(blue));
+}
+
+static void
+loopback_SecondaryColor3bvEXT( const GLbyte *v )
+{
+   const GLfloat a = BYTE_TO_FLOAT(v[0]);
+   const GLfloat b = BYTE_TO_FLOAT(v[1]);
+   const GLfloat c = BYTE_TO_FLOAT(v[2]);
+   SECONDARYCOLORF(a,b,c);
+}
+
+static void
+loopback_SecondaryColor3dvEXT( const GLdouble *v )
+{
+   GLubyte col[3];
+   GLfloat r = (GLfloat) v[0];
+   GLfloat g = (GLfloat) v[1];
+   GLfloat b = (GLfloat) v[2];
+   UNCLAMPED_FLOAT_TO_UBYTE(col[0], r);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[1], g);
+   UNCLAMPED_FLOAT_TO_UBYTE(col[2], b);
+   SECONDARYCOLORUB( col[0], col[1], col[2] );
+}
+
+static void
+loopback_SecondaryColor3ivEXT( const GLint *v )
+{
+   SECONDARYCOLORUB(INT_TO_UBYTE(v[0]),
+		    INT_TO_UBYTE(v[1]),
+		    INT_TO_UBYTE(v[2]));
+}
+
+static void
+loopback_SecondaryColor3svEXT( const GLshort *v )
+{
+   SECONDARYCOLORUB(SHORT_TO_UBYTE(v[0]),
+		    SHORT_TO_UBYTE(v[1]),
+		    SHORT_TO_UBYTE(v[2]));
+}
+
+static void
+loopback_SecondaryColor3uivEXT( const GLuint *v )
+{
+   SECONDARYCOLORUB(UINT_TO_UBYTE(v[0]),
+		    UINT_TO_UBYTE(v[1]),
+		    UINT_TO_UBYTE(v[2]));
+}
+
+static void
+loopback_SecondaryColor3usvEXT( const GLushort *v )
+{
+   SECONDARYCOLORUB(USHORT_TO_UBYTE(v[0]),
+		    USHORT_TO_UBYTE(v[1]),
+		    USHORT_TO_UBYTE(v[2]));
+}
+
+
+static void
+loopback_SecondaryColor3bEXT_f( GLbyte red, GLbyte green, GLbyte blue )
+{
+   SECONDARYCOLORF( BYTE_TO_FLOAT(red),
+		    BYTE_TO_FLOAT(green),
+		    BYTE_TO_FLOAT(blue) );
+}
+
+static void
+loopback_SecondaryColor3dEXT_f( GLdouble red, GLdouble green, GLdouble blue )
+{
+   SECONDARYCOLORF( (GLfloat) red, (GLfloat) green, (GLfloat) blue );
+}
+
+static void
+loopback_SecondaryColor3iEXT_f( GLint red, GLint green, GLint blue )
+{
+   SECONDARYCOLORF( INT_TO_FLOAT(red),
+		    INT_TO_FLOAT(green),
+		    INT_TO_FLOAT(blue));
+}
+
+static void
+loopback_SecondaryColor3sEXT_f( GLshort red, GLshort green, GLshort blue )
+{
+   SECONDARYCOLORF(SHORT_TO_FLOAT(red),
+                   SHORT_TO_FLOAT(green),
+                   SHORT_TO_FLOAT(blue));
+}
+
+static void
+loopback_SecondaryColor3uiEXT_f( GLuint red, GLuint green, GLuint blue )
+{
+   SECONDARYCOLORF(UINT_TO_FLOAT(red),
+                   UINT_TO_FLOAT(green),
+                   UINT_TO_FLOAT(blue));
+}
+
+static void
+loopback_SecondaryColor3usEXT_f( GLushort red, GLushort green, GLushort blue )
+{
+   SECONDARYCOLORF(USHORT_TO_FLOAT(red),
+                   USHORT_TO_FLOAT(green),
+                   USHORT_TO_FLOAT(blue));
+}
+
+static void
+loopback_SecondaryColor3bvEXT_f( const GLbyte *v )
+{
+   SECONDARYCOLORF(BYTE_TO_FLOAT(v[0]),
+                   BYTE_TO_FLOAT(v[1]),
+                   BYTE_TO_FLOAT(v[2]));
+}
+
+static void
+loopback_SecondaryColor3dvEXT_f( const GLdouble *v )
+{
+   SECONDARYCOLORF( (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
+}
+static void
+loopback_SecondaryColor3ivEXT_f( const GLint *v )
+{
+   SECONDARYCOLORF(INT_TO_FLOAT(v[0]),
+                   INT_TO_FLOAT(v[1]),
+                   INT_TO_FLOAT(v[2]));
+}
+
+static void
+loopback_SecondaryColor3svEXT_f( const GLshort *v )
+{
+   SECONDARYCOLORF(SHORT_TO_FLOAT(v[0]),
+                   SHORT_TO_FLOAT(v[1]),
+                   SHORT_TO_FLOAT(v[2]));
+}
+
+static void
+loopback_SecondaryColor3uivEXT_f( const GLuint *v )
+{
+   SECONDARYCOLORF(UINT_TO_FLOAT(v[0]),
+                   UINT_TO_FLOAT(v[1]),
+                   UINT_TO_FLOAT(v[2]));
+}
+
+static void
+loopback_SecondaryColor3usvEXT_f( const GLushort *v )
+{
+   SECONDARYCOLORF(USHORT_TO_FLOAT(v[0]),
+                   USHORT_TO_FLOAT(v[1]),
+                   USHORT_TO_FLOAT(v[2]));
+}
+
+
+
+void
+_mesa_loopback_prefer_float( struct _glapi_table *dest,
+			     GLboolean prefer_float_colors )
+{
+   if (!prefer_float_colors) {
+      dest->Color3b = loopback_Color3b;
+      dest->Color3d = loopback_Color3d;
+      dest->Color3i = loopback_Color3i;
+      dest->Color3s = loopback_Color3s;
+      dest->Color3ui = loopback_Color3ui;
+      dest->Color3us = loopback_Color3us;
+      dest->Color4b = loopback_Color4b;
+      dest->Color4d = loopback_Color4d;
+      dest->Color4i = loopback_Color4i;
+      dest->Color4s = loopback_Color4s;
+      dest->Color4ui = loopback_Color4ui;
+      dest->Color4us = loopback_Color4us;
+      dest->Color3bv = loopback_Color3bv;
+      dest->Color3dv = loopback_Color3dv;
+      dest->Color3iv = loopback_Color3iv;
+      dest->Color3sv = loopback_Color3sv;
+      dest->Color3uiv = loopback_Color3uiv;
+      dest->Color3usv = loopback_Color3usv;
+      dest->Color4bv = loopback_Color4bv;
+      dest->Color4dv = loopback_Color4dv;
+      dest->Color4iv = loopback_Color4iv;
+      dest->Color4sv = loopback_Color4sv;
+      dest->Color4uiv = loopback_Color4uiv;
+      dest->Color4usv = loopback_Color4usv;
+      dest->SecondaryColor3bEXT = loopback_SecondaryColor3bEXT;
+      dest->SecondaryColor3dEXT = loopback_SecondaryColor3dEXT;
+      dest->SecondaryColor3iEXT = loopback_SecondaryColor3iEXT;
+      dest->SecondaryColor3sEXT = loopback_SecondaryColor3sEXT;
+      dest->SecondaryColor3uiEXT = loopback_SecondaryColor3uiEXT;
+      dest->SecondaryColor3usEXT = loopback_SecondaryColor3usEXT;
+      dest->SecondaryColor3bvEXT = loopback_SecondaryColor3bvEXT;
+      dest->SecondaryColor3dvEXT = loopback_SecondaryColor3dvEXT;
+      dest->SecondaryColor3ivEXT = loopback_SecondaryColor3ivEXT;
+      dest->SecondaryColor3svEXT = loopback_SecondaryColor3svEXT;
+      dest->SecondaryColor3uivEXT = loopback_SecondaryColor3uivEXT;
+      dest->SecondaryColor3usvEXT = loopback_SecondaryColor3usvEXT;
+   }
+   else {
+      dest->Color3b = loopback_Color3b_f;
+      dest->Color3d = loopback_Color3d_f;
+      dest->Color3i = loopback_Color3i_f;
+      dest->Color3s = loopback_Color3s_f;
+      dest->Color3ui = loopback_Color3ui_f;
+      dest->Color3us = loopback_Color3us_f;
+      dest->Color4b = loopback_Color4b_f;
+      dest->Color4d = loopback_Color4d_f;
+      dest->Color4i = loopback_Color4i_f;
+      dest->Color4s = loopback_Color4s_f;
+      dest->Color4ui = loopback_Color4ui_f;
+      dest->Color4us = loopback_Color4us_f;
+      dest->Color3bv = loopback_Color3bv_f;
+      dest->Color3dv = loopback_Color3dv_f;
+      dest->Color3iv = loopback_Color3iv_f;
+      dest->Color3sv = loopback_Color3sv_f;
+      dest->Color3uiv = loopback_Color3uiv_f;
+      dest->Color3usv = loopback_Color3usv_f;
+      dest->Color4bv = loopback_Color4bv_f;
+      dest->Color4dv = loopback_Color4dv_f;
+      dest->Color4iv = loopback_Color4iv_f;
+      dest->Color4sv = loopback_Color4sv_f;
+      dest->Color4uiv = loopback_Color4uiv_f;
+      dest->Color4usv = loopback_Color4usv_f;
+      dest->SecondaryColor3bEXT = loopback_SecondaryColor3bEXT_f;
+      dest->SecondaryColor3dEXT = loopback_SecondaryColor3dEXT_f;
+      dest->SecondaryColor3iEXT = loopback_SecondaryColor3iEXT_f;
+      dest->SecondaryColor3sEXT = loopback_SecondaryColor3sEXT_f;
+      dest->SecondaryColor3uiEXT = loopback_SecondaryColor3uiEXT_f;
+      dest->SecondaryColor3usEXT = loopback_SecondaryColor3usEXT_f;
+      dest->SecondaryColor3bvEXT = loopback_SecondaryColor3bvEXT_f;
+      dest->SecondaryColor3dvEXT = loopback_SecondaryColor3dvEXT_f;
+      dest->SecondaryColor3ivEXT = loopback_SecondaryColor3ivEXT_f;
+      dest->SecondaryColor3svEXT = loopback_SecondaryColor3svEXT_f;
+      dest->SecondaryColor3uivEXT = loopback_SecondaryColor3uivEXT_f;
+      dest->SecondaryColor3usvEXT = loopback_SecondaryColor3usvEXT_f;
+   }
+}
+
+/* Passing prefer_float_colors as true will mean that all colors
+ * *except* Color{34}ub{v} are passed as floats.  Setting it false will
+ * mean all colors *except* Color{34}f{v} are passed as ubytes.
+ *
+ * This code never registers handlers for any of the entry points
+ * listed in vtxfmt.h.
+ */
+void
+_mesa_loopback_init_api_table( struct _glapi_table *dest,
+			       GLboolean prefer_float_colors )
+{
+   _mesa_loopback_prefer_float( dest, prefer_float_colors );
+
+   dest->Indexd = loopback_Indexd;
+   dest->Indexf = loopback_Indexf;
+   dest->Indexs = loopback_Indexs;
+   dest->Indexub = loopback_Indexub;
+   dest->Indexdv = loopback_Indexdv;
+   dest->Indexfv = loopback_Indexfv;
+   dest->Indexiv = loopback_Indexiv;
+   dest->Indexsv = loopback_Indexsv;
+   dest->Indexubv = loopback_Indexubv;
+   dest->Normal3b = loopback_Normal3b;
+   dest->Normal3d = loopback_Normal3d;
+   dest->Normal3i = loopback_Normal3i;
+   dest->Normal3s = loopback_Normal3s;
+   dest->Normal3bv = loopback_Normal3bv;
+   dest->Normal3dv = loopback_Normal3dv;
+   dest->Normal3iv = loopback_Normal3iv;
+   dest->Normal3sv = loopback_Normal3sv;
+   dest->TexCoord1d = loopback_TexCoord1d;
+   dest->TexCoord1i = loopback_TexCoord1i;
+   dest->TexCoord1s = loopback_TexCoord1s;
+   dest->TexCoord2d = loopback_TexCoord2d;
+   dest->TexCoord2s = loopback_TexCoord2s;
+   dest->TexCoord2i = loopback_TexCoord2i;
+   dest->TexCoord3d = loopback_TexCoord3d;
+   dest->TexCoord3i = loopback_TexCoord3i;
+   dest->TexCoord3s = loopback_TexCoord3s;
+   dest->TexCoord4d = loopback_TexCoord4d;
+   dest->TexCoord4i = loopback_TexCoord4i;
+   dest->TexCoord4s = loopback_TexCoord4s;
+   dest->TexCoord1dv = loopback_TexCoord1dv;
+   dest->TexCoord1iv = loopback_TexCoord1iv;
+   dest->TexCoord1sv = loopback_TexCoord1sv;
+   dest->TexCoord2dv = loopback_TexCoord2dv;
+   dest->TexCoord2iv = loopback_TexCoord2iv;
+   dest->TexCoord2sv = loopback_TexCoord2sv;
+   dest->TexCoord3dv = loopback_TexCoord3dv;
+   dest->TexCoord3iv = loopback_TexCoord3iv;
+   dest->TexCoord3sv = loopback_TexCoord3sv;
+   dest->TexCoord4dv = loopback_TexCoord4dv;
+   dest->TexCoord4iv = loopback_TexCoord4iv;
+   dest->TexCoord4sv = loopback_TexCoord4sv;
+   dest->Vertex2d = loopback_Vertex2d;
+   dest->Vertex2i = loopback_Vertex2i;
+   dest->Vertex2s = loopback_Vertex2s;
+   dest->Vertex3d = loopback_Vertex3d;
+   dest->Vertex3i = loopback_Vertex3i;
+   dest->Vertex3s = loopback_Vertex3s;
+   dest->Vertex4d = loopback_Vertex4d;
+   dest->Vertex4i = loopback_Vertex4i;
+   dest->Vertex4s = loopback_Vertex4s;
+   dest->Vertex2dv = loopback_Vertex2dv;
+   dest->Vertex2iv = loopback_Vertex2iv;
+   dest->Vertex2sv = loopback_Vertex2sv;
+   dest->Vertex3dv = loopback_Vertex3dv;
+   dest->Vertex3iv = loopback_Vertex3iv;
+   dest->Vertex3sv = loopback_Vertex3sv;
+   dest->Vertex4dv = loopback_Vertex4dv;
+   dest->Vertex4iv = loopback_Vertex4iv;
+   dest->Vertex4sv = loopback_Vertex4sv;
+   dest->MultiTexCoord1dARB = loopback_MultiTexCoord1dARB;
+   dest->MultiTexCoord1dvARB = loopback_MultiTexCoord1dvARB;
+   dest->MultiTexCoord1iARB = loopback_MultiTexCoord1iARB;
+   dest->MultiTexCoord1ivARB = loopback_MultiTexCoord1ivARB;
+   dest->MultiTexCoord1sARB = loopback_MultiTexCoord1sARB;
+   dest->MultiTexCoord1svARB = loopback_MultiTexCoord1svARB;
+   dest->MultiTexCoord2dARB = loopback_MultiTexCoord2dARB;
+   dest->MultiTexCoord2dvARB = loopback_MultiTexCoord2dvARB;
+   dest->MultiTexCoord2iARB = loopback_MultiTexCoord2iARB;
+   dest->MultiTexCoord2ivARB = loopback_MultiTexCoord2ivARB;
+   dest->MultiTexCoord2sARB = loopback_MultiTexCoord2sARB;
+   dest->MultiTexCoord2svARB = loopback_MultiTexCoord2svARB;
+   dest->MultiTexCoord3dARB = loopback_MultiTexCoord3dARB;
+   dest->MultiTexCoord3dvARB = loopback_MultiTexCoord3dvARB;
+   dest->MultiTexCoord3iARB = loopback_MultiTexCoord3iARB;
+   dest->MultiTexCoord3ivARB = loopback_MultiTexCoord3ivARB;
+   dest->MultiTexCoord3sARB = loopback_MultiTexCoord3sARB;
+   dest->MultiTexCoord3svARB = loopback_MultiTexCoord3svARB;
+   dest->MultiTexCoord4dARB = loopback_MultiTexCoord4dARB;
+   dest->MultiTexCoord4dvARB = loopback_MultiTexCoord4dvARB;
+   dest->MultiTexCoord4iARB = loopback_MultiTexCoord4iARB;
+   dest->MultiTexCoord4ivARB = loopback_MultiTexCoord4ivARB;
+   dest->MultiTexCoord4sARB = loopback_MultiTexCoord4sARB;
+   dest->MultiTexCoord4svARB = loopback_MultiTexCoord4svARB;
+   dest->EvalCoord2dv = loopback_EvalCoord2dv;
+   dest->EvalCoord2fv = loopback_EvalCoord2fv;
+   dest->EvalCoord2d = loopback_EvalCoord2d;
+   dest->EvalCoord1dv = loopback_EvalCoord1dv;
+   dest->EvalCoord1fv = loopback_EvalCoord1fv;
+   dest->EvalCoord1d = loopback_EvalCoord1d;
+   dest->Materialf = loopback_Materialf;
+   dest->Materiali = loopback_Materiali;
+   dest->Materialiv = loopback_Materialiv;
+   dest->Rectd = loopback_Rectd;
+   dest->Rectdv = loopback_Rectdv;
+   dest->Rectfv = loopback_Rectfv;
+   dest->Recti = loopback_Recti;
+   dest->Rectiv = loopback_Rectiv;
+   dest->Rects = loopback_Rects;
+   dest->Rectsv = loopback_Rectsv;
+   dest->FogCoorddEXT = loopback_FogCoorddEXT;
+   dest->FogCoorddvEXT = loopback_FogCoorddvEXT;
+}
Index: xc/extras/Mesa/src/api_loopback.h
diff -u /dev/null xc/extras/Mesa/src/api_loopback.h:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_loopback.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef API_LOOPBACK_H
+#define API_LOOPBACK_H
+
+#include "glheader.h"
+
+struct _glapi_table;
+
+extern void _mesa_loopback_prefer_float( struct _glapi_table *dest,
+					 GLboolean prefer_float_colors );
+
+extern void _mesa_loopback_init_api_table( struct _glapi_table *dest,
+					   GLboolean prefer_float_colors );
+
+#endif
Index: xc/extras/Mesa/src/api_noop.c
diff -u /dev/null xc/extras/Mesa/src/api_noop.c:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_noop.c	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,611 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "api_noop.h"
+#include "api_validate.h"
+#include "context.h"
+#include "colormac.h"
+#include "light.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+
+/* In states where certain vertex components are required for t&l or
+ * rasterization, we still need to keep track of the current values.
+ * These functions provide this service by keeping uptodate the
+ * 'ctx->Current' struct for all data elements not included in the
+ * currently enabled hardware vertex.
+ *
+ */
+void _mesa_noop_EdgeFlag( GLboolean b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ctx->Current.EdgeFlag = b;
+}
+
+void _mesa_noop_EdgeFlagv( const GLboolean *b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ctx->Current.EdgeFlag = *b;
+}
+
+void _mesa_noop_FogCoordfEXT( GLfloat a )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ctx->Current.FogCoord = a;
+}
+
+void _mesa_noop_FogCoordfvEXT( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ctx->Current.FogCoord = *v;
+}
+
+void _mesa_noop_Indexi( GLint i )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ctx->Current.Index = i;
+}
+
+void _mesa_noop_Indexiv( const GLint *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ctx->Current.Index = *v;
+}
+
+void _mesa_noop_Normal3f( GLfloat a, GLfloat b, GLfloat c )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Normal;
+   COPY_FLOAT(dest[0], a);
+   COPY_FLOAT(dest[1], b);
+   COPY_FLOAT(dest[2], c);
+}
+
+void _mesa_noop_Normal3fv( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Normal;
+   COPY_FLOAT(dest[0], v[0]);
+   COPY_FLOAT(dest[1], v[1]);
+   COPY_FLOAT(dest[2], v[2]);
+}
+
+void _mesa_noop_Materialfv( GLenum face, GLenum pname, const GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_material mat[2];
+   GLuint bitmask = _mesa_material_bitmask( ctx, face, pname, ~0,
+                                            "_mesa_noop_Materialfv" );
+   if (bitmask == 0)
+      return;
+
+   if (bitmask & FRONT_AMBIENT_BIT) {
+      COPY_4FV( mat[0].Ambient, params );
+   }
+   if (bitmask & BACK_AMBIENT_BIT) {
+      COPY_4FV( mat[1].Ambient, params );
+   }
+   if (bitmask & FRONT_DIFFUSE_BIT) {
+      COPY_4FV( mat[0].Diffuse, params );
+   }
+   if (bitmask & BACK_DIFFUSE_BIT) {
+      COPY_4FV( mat[1].Diffuse, params );
+   }
+   if (bitmask & FRONT_SPECULAR_BIT) {
+      COPY_4FV( mat[0].Specular, params );
+   }
+   if (bitmask & BACK_SPECULAR_BIT) {
+      COPY_4FV( mat[1].Specular, params );
+   }
+   if (bitmask & FRONT_EMISSION_BIT) {
+      COPY_4FV( mat[0].Emission, params );
+   }
+   if (bitmask & BACK_EMISSION_BIT) {
+      COPY_4FV( mat[1].Emission, params );
+   }
+   if (bitmask & FRONT_SHININESS_BIT) {
+      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
+      mat[0].Shininess = shininess;
+   }
+   if (bitmask & BACK_SHININESS_BIT) {
+      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
+      mat[1].Shininess = shininess;
+   }
+   if (bitmask & FRONT_INDEXES_BIT) {
+      mat[0].AmbientIndex = params[0];
+      mat[0].DiffuseIndex = params[1];
+      mat[0].SpecularIndex = params[2];
+   }
+   if (bitmask & BACK_INDEXES_BIT) {
+      mat[1].AmbientIndex = params[0];
+      mat[1].DiffuseIndex = params[1];
+      mat[1].SpecularIndex = params[2];
+   }
+
+   _mesa_update_material( ctx, mat, bitmask );
+}
+
+void _mesa_noop_Color4ub( GLubyte a, GLubyte b, GLubyte c, GLubyte d )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = UBYTE_TO_FLOAT(a);
+   color[1] = UBYTE_TO_FLOAT(b);
+   color[2] = UBYTE_TO_FLOAT(c);
+   color[3] = UBYTE_TO_FLOAT(d);
+}
+
+void _mesa_noop_Color4ubv( const GLubyte *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = UBYTE_TO_FLOAT(v[0]);
+   color[1] = UBYTE_TO_FLOAT(v[1]);
+   color[2] = UBYTE_TO_FLOAT(v[2]);
+   color[3] = UBYTE_TO_FLOAT(v[3]);
+}
+
+void _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = a;
+   color[1] = b;
+   color[2] = c;
+   color[3] = d;
+}
+
+void _mesa_noop_Color4fv( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = v[0];
+   color[1] = v[1];
+   color[2] = v[2];
+   color[3] = v[3];
+}
+
+void _mesa_noop_Color3ub( GLubyte a, GLubyte b, GLubyte c )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = UBYTE_TO_FLOAT(a);
+   color[1] = UBYTE_TO_FLOAT(b);
+   color[2] = UBYTE_TO_FLOAT(c);
+   color[3] = 1.0;
+}
+
+void _mesa_noop_Color3ubv( const GLubyte *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = UBYTE_TO_FLOAT(v[0]);
+   color[1] = UBYTE_TO_FLOAT(v[1]);
+   color[2] = UBYTE_TO_FLOAT(v[2]);
+   color[3] = 1.0;
+}
+
+void _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = a;
+   color[1] = b;
+   color[2] = c;
+   color[3] = 1.0;
+}
+
+void _mesa_noop_Color3fv( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+   color[0] = v[0];
+   color[1] = v[1];
+   color[2] = v[2];
+   color[3] = 1.0;
+}
+
+void _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], a);
+      dest[1] = 0;
+      dest[2] = 0;
+      dest[3] = 1;
+   }
+}
+
+void _mesa_noop_MultiTexCoord1fvARB( GLenum target, const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], v[0]);
+      dest[1] = 0;
+      dest[2] = 0;
+      dest[3] = 1;
+   }
+}
+
+void _mesa_noop_MultiTexCoord2fARB( GLenum target, GLfloat a, GLfloat b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], a);
+      COPY_FLOAT(dest[1], b);
+      dest[2] = 0;
+      dest[3] = 1;
+   }
+}
+
+void _mesa_noop_MultiTexCoord2fvARB( GLenum target, const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], v[0]);
+      COPY_FLOAT(dest[1], v[1]);
+      dest[2] = 0;
+      dest[3] = 1;
+   }
+}
+
+void _mesa_noop_MultiTexCoord3fARB( GLenum target, GLfloat a, GLfloat b, GLfloat c)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], a);
+      COPY_FLOAT(dest[1], b);
+      COPY_FLOAT(dest[2], c);
+      dest[3] = 1;
+   }
+}
+
+void _mesa_noop_MultiTexCoord3fvARB( GLenum target, const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], v[0]);
+      COPY_FLOAT(dest[1], v[1]);
+      COPY_FLOAT(dest[2], v[2]);
+      dest[3] = 1;
+   }
+}
+
+void _mesa_noop_MultiTexCoord4fARB( GLenum target, GLfloat a, GLfloat b,
+			      GLfloat c, GLfloat d )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], a);
+      COPY_FLOAT(dest[1], b);
+      COPY_FLOAT(dest[2], c);
+      dest[3] = d;
+   }
+}
+
+void _mesa_noop_MultiTexCoord4fvARB( GLenum target, const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint unit = target - GL_TEXTURE0_ARB;
+
+   /* unit is unsigned -- cannot be less than zero.
+    */
+   if (unit < MAX_TEXTURE_UNITS)
+   {
+      GLfloat *dest = ctx->Current.Texcoord[unit];
+      COPY_FLOAT(dest[0], v[0]);
+      COPY_FLOAT(dest[1], v[1]);
+      COPY_FLOAT(dest[2], v[2]);
+      COPY_FLOAT(dest[3], v[3]);
+   }
+}
+
+void _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.SecondaryColor;
+   color[0] = UBYTE_TO_FLOAT(a);
+   color[1] = UBYTE_TO_FLOAT(b);
+   color[2] = UBYTE_TO_FLOAT(c);
+   color[3] = 1.0;
+}
+
+void _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.SecondaryColor;
+   color[0] = UBYTE_TO_FLOAT(v[0]);
+   color[1] = UBYTE_TO_FLOAT(v[1]);
+   color[2] = UBYTE_TO_FLOAT(v[2]);
+   color[3] = 1.0;
+}
+
+void _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.SecondaryColor;
+   color[0] = a;
+   color[1] = b;
+   color[2] = c;
+   color[3] = 1.0;
+}
+
+void _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.SecondaryColor;
+   color[0] = v[0];
+   color[1] = v[1];
+   color[2] = v[2];
+   color[3] = 1.0;
+}
+
+void _mesa_noop_TexCoord1f( GLfloat a )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], a);
+   dest[1] = 0;
+   dest[2] = 0;
+   dest[3] = 1;
+}
+
+void _mesa_noop_TexCoord1fv( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], v[0]);
+   dest[1] = 0;
+   dest[2] = 0;
+   dest[3] = 1;
+}
+
+void _mesa_noop_TexCoord2f( GLfloat a, GLfloat b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], a);
+   COPY_FLOAT(dest[1], b);
+   dest[2] = 0;
+   dest[3] = 1;
+}
+
+void _mesa_noop_TexCoord2fv( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], v[0]);
+   COPY_FLOAT(dest[1], v[1]);
+   dest[2] = 0;
+   dest[3] = 1;
+}
+
+void _mesa_noop_TexCoord3f( GLfloat a, GLfloat b, GLfloat c )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], a);
+   COPY_FLOAT(dest[1], b);
+   COPY_FLOAT(dest[2], c);
+   dest[3] = 1;
+}
+
+void _mesa_noop_TexCoord3fv( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], v[0]);
+   COPY_FLOAT(dest[1], v[1]);
+   COPY_FLOAT(dest[2], v[2]);
+   dest[3] = 1;
+}
+
+void _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], a);
+   COPY_FLOAT(dest[1], b);
+   COPY_FLOAT(dest[2], c);
+   COPY_FLOAT(dest[3], d);
+}
+
+void _mesa_noop_TexCoord4fv( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *dest = ctx->Current.Texcoord[0];
+   COPY_FLOAT(dest[0], v[0]);
+   COPY_FLOAT(dest[1], v[1]);
+   COPY_FLOAT(dest[2], v[2]);
+   COPY_FLOAT(dest[3], v[3]);
+}
+
+/* Useful outside begin/end?
+ */
+void _mesa_noop_Vertex2fv( const GLfloat *v )
+{
+   (void) v;
+}
+
+void _mesa_noop_Vertex3fv( const GLfloat *v )
+{
+   (void) v;
+}
+
+void _mesa_noop_Vertex4fv( const GLfloat *v )
+{
+   (void) v;
+}
+
+void _mesa_noop_Vertex2f( GLfloat a, GLfloat b )
+{
+   (void) a; (void) b;
+}
+
+void _mesa_noop_Vertex3f( GLfloat a, GLfloat b, GLfloat c )
+{
+   (void) a; (void) b; (void) c;
+}
+
+void _mesa_noop_Vertex4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
+{
+   (void) a; (void) b; (void) c; (void) d;
+}
+
+
+
+/* Execute a glRectf() function.  This is not suitable for GL_COMPILE
+ * modes (as the test for outside begin/end is not compiled),
+ * but may be useful for drivers in circumstances which exclude
+ * display list interactions.
+ *
+ * (None of the functions in this file are suitable for GL_COMPILE
+ * modes).
+ */
+void _mesa_noop_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+   {
+      GET_CURRENT_CONTEXT(ctx);
+      ASSERT_OUTSIDE_BEGIN_END(ctx);
+   }
+
+   glBegin( GL_QUADS );
+   glVertex2f( x1, y1 );
+   glVertex2f( x2, y1 );
+   glVertex2f( x2, y2 );
+   glVertex2f( x1, y2 );
+   glEnd();
+}
+
+
+/* Some very basic support for arrays.  Drivers without explicit array
+ * support can hook these in, but still need to supply an array-elt
+ * implementation.
+ */
+void _mesa_noop_DrawArrays(GLenum mode, GLint start, GLsizei count)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint i;
+
+   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
+      return;
+
+   glBegin(mode);
+   for (i = start ; i <= count ; i++)
+      glArrayElement( i );
+   glEnd();
+}
+
+
+void _mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
+			     const GLvoid *indices)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint i;
+
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+      return;
+
+   glBegin(mode);
+
+   switch (type) {
+   case GL_UNSIGNED_BYTE:
+      for (i = 0 ; i < count ; i++)
+	 glArrayElement( ((GLubyte *)indices)[i] );
+      break;
+   case GL_UNSIGNED_SHORT:
+      for (i = 0 ; i < count ; i++)
+	 glArrayElement( ((GLushort *)indices)[i] );
+      break;
+   case GL_UNSIGNED_INT:
+      for (i = 0 ; i < count ; i++)
+	 glArrayElement( ((GLuint *)indices)[i] );
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
+      break;
+   }
+
+   glEnd();
+}
+
+void _mesa_noop_DrawRangeElements(GLenum mode,
+				  GLuint start, GLuint end,
+				  GLsizei count, GLenum type,
+				  const GLvoid *indices)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (_mesa_validate_DrawRangeElements( ctx, mode,
+					 start, end,
+					 count, type, indices ))
+      glDrawElements( mode, count, type, indices );
+}
Index: xc/extras/Mesa/src/api_noop.h
diff -u /dev/null xc/extras/Mesa/src/api_noop.h:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_noop.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,148 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef _API_NOOP_H
+#define _API_NOOP_H
+
+
+#include "glheader.h"
+#include "mtypes.h"
+#include "context.h"
+
+/* In states where certain vertex components are required for t&l or
+ * rasterization, we still need to keep track of the current values.
+ * These functions provide this service by keeping uptodate the
+ * 'ctx->Current' struct for all data elements not included in the
+ * currently enabled hardware vertex.
+ *
+ */
+extern void _mesa_noop_EdgeFlag( GLboolean b );
+
+extern void _mesa_noop_EdgeFlagv( const GLboolean *b );
+
+extern void _mesa_noop_FogCoordfEXT( GLfloat a );
+
+extern void _mesa_noop_FogCoordfvEXT( const GLfloat *v );
+
+extern void _mesa_noop_Indexi( GLint i );
+
+extern void _mesa_noop_Indexiv( const GLint *v );
+
+extern void _mesa_noop_Normal3f( GLfloat a, GLfloat b, GLfloat c );
+
+extern void _mesa_noop_Normal3fv( const GLfloat *v );
+
+extern void _mesa_noop_Materialfv(  GLenum face, GLenum pname,  const GLfloat *param );
+
+extern void _mesa_noop_Color4ub( GLubyte a, GLubyte b, GLubyte c, GLubyte d );
+
+extern void _mesa_noop_Color4ubv( const GLubyte *v );
+
+extern void _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d );
+
+extern void _mesa_noop_Color4fv( const GLfloat *v );
+
+extern void _mesa_noop_Color3ub( GLubyte a, GLubyte b, GLubyte c );
+
+extern void _mesa_noop_Color3ubv( const GLubyte *v );
+
+extern void _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c );
+
+extern void _mesa_noop_Color3fv( const GLfloat *v );
+
+extern void _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a );
+
+extern void _mesa_noop_MultiTexCoord1fvARB( GLenum target, const GLfloat *v );
+
+extern void _mesa_noop_MultiTexCoord2fARB( GLenum target, GLfloat a,
+					   GLfloat b );
+
+extern void _mesa_noop_MultiTexCoord2fvARB( GLenum target, const GLfloat *v );
+
+extern void _mesa_noop_MultiTexCoord3fARB( GLenum target, GLfloat a,
+					GLfloat b, GLfloat c);
+
+extern void _mesa_noop_MultiTexCoord3fvARB( GLenum target, const GLfloat *v );
+
+extern void _mesa_noop_MultiTexCoord4fARB( GLenum target, GLfloat a,
+					GLfloat b, GLfloat c, GLfloat d );
+
+extern void _mesa_noop_MultiTexCoord4fvARB( GLenum target, const GLfloat *v );
+
+extern void _mesa_noop_SecondaryColor3ubEXT( GLubyte a, GLubyte b, GLubyte c );
+
+extern void _mesa_noop_SecondaryColor3ubvEXT( const GLubyte *v );
+
+extern void _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c );
+
+extern void _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v );
+
+extern void _mesa_noop_TexCoord1f( GLfloat a );
+
+extern void _mesa_noop_TexCoord1fv( const GLfloat *v );
+
+extern void _mesa_noop_TexCoord2f( GLfloat a, GLfloat b );
+
+extern void _mesa_noop_TexCoord2fv( const GLfloat *v );
+
+extern void _mesa_noop_TexCoord3f( GLfloat a, GLfloat b, GLfloat c );
+
+extern void _mesa_noop_TexCoord3fv( const GLfloat *v );
+
+extern void _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d );
+
+extern void _mesa_noop_TexCoord4fv( const GLfloat *v );
+
+extern void _mesa_noop_Vertex2fv( const GLfloat *v );
+
+extern void _mesa_noop_Vertex3fv( const GLfloat *v );
+
+extern void _mesa_noop_Vertex4fv( const GLfloat *v );
+
+extern void _mesa_noop_Vertex2f( GLfloat a, GLfloat b );
+
+extern void _mesa_noop_Vertex3f( GLfloat a, GLfloat b, GLfloat c );
+
+extern void _mesa_noop_Vertex4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d );
+
+
+/* Not strictly a noop -- translate Rectf down to Begin/End and
+ * vertices.  Closer to the loopback operations, but doesn't meet the
+ * criteria for inclusion there (cannot be used in the Save table).
+ */
+extern void _mesa_noop_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 );
+
+
+extern void _mesa_noop_DrawArrays(GLenum mode, GLint start, GLsizei count);
+extern void _mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
+				    const GLvoid *indices);
+extern void _mesa_noop_DrawRangeElements(GLenum mode,
+					 GLuint start, GLuint end,
+					 GLsizei count, GLenum type,
+					 const GLvoid *indices);
+
+
+
+#endif
Index: xc/extras/Mesa/src/api_validate.c
diff -u /dev/null xc/extras/Mesa/src/api_validate.c:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_validate.c	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,135 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "glheader.h"
+#include "api_validate.h"
+#include "context.h"
+#include "mtypes.h"
+#include "state.h"
+
+
+GLboolean
+_mesa_validate_DrawElements(GLcontext *ctx,
+			    GLenum mode, GLsizei count, GLenum type,
+			    const GLvoid *indices)
+{
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx,  GL_FALSE);
+
+   if (count <= 0) {
+      if (count < 0)
+	 _mesa_error(ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
+      return GL_FALSE;
+   }
+
+   if (mode > GL_POLYGON) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
+      return GL_FALSE;
+   }
+
+   if (type != GL_UNSIGNED_INT &&
+       type != GL_UNSIGNED_BYTE &&
+       type != GL_UNSIGNED_SHORT)
+   {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
+      return GL_FALSE;
+   }
+
+   if (ctx->NewState)
+      _mesa_update_state( ctx );
+
+   if (!ctx->Array.Vertex.Enabled)
+      return GL_FALSE;
+
+   return GL_TRUE;
+}
+
+
+GLboolean
+_mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
+				 GLuint start, GLuint end,
+				 GLsizei count, GLenum type,
+				 const GLvoid *indices)
+{
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+
+   if (count <= 0) {
+      if (count < 0)
+	 _mesa_error(ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
+      return GL_FALSE;
+   }
+
+   if (mode > GL_POLYGON) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
+      return GL_FALSE;
+   }
+
+   if (end < start) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(end<start)");
+      return GL_FALSE;
+   }
+
+   if (type != GL_UNSIGNED_INT &&
+       type != GL_UNSIGNED_BYTE &&
+       type != GL_UNSIGNED_SHORT)
+   {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
+      return GL_FALSE;
+   }
+
+   if (ctx->NewState)
+      _mesa_update_state( ctx );
+
+   if (!ctx->Array.Vertex.Enabled)
+      return GL_FALSE;
+
+   return GL_TRUE;
+}
+
+
+
+GLboolean
+_mesa_validate_DrawArrays(GLcontext *ctx,
+			  GLenum mode, GLint start, GLsizei count)
+{
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+
+   if (count<0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
+      return GL_FALSE;
+   }
+
+   if (mode > GL_POLYGON) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
+      return GL_FALSE;
+   }
+
+   if (ctx->NewState)
+      _mesa_update_state( ctx );
+
+   if (!ctx->Array.Vertex.Enabled)
+      return GL_FALSE;
+
+   return GL_TRUE;
+}
Index: xc/extras/Mesa/src/api_validate.h
diff -u /dev/null xc/extras/Mesa/src/api_validate.h:1.2
--- /dev/null	Thu Feb 27 12:15:31 2003
+++ xc/extras/Mesa/src/api_validate.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,49 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef API_VALIDATE_H
+#define API_VALIDATE_H
+
+
+#include "mtypes.h"
+
+extern GLboolean
+_mesa_validate_DrawArrays(GLcontext *ctx,
+			  GLenum mode, GLint start, GLsizei count);
+
+extern GLboolean
+_mesa_validate_DrawElements(GLcontext *ctx,
+			    GLenum mode, GLsizei count, GLenum type,
+			    const GLvoid *indices);
+
+extern GLboolean
+_mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
+				 GLuint start, GLuint end,
+				 GLsizei count, GLenum type,
+				 const GLvoid *indices);
+
+
+#endif
Index: xc/extras/Mesa/src/attrib.c
diff -u xc/extras/Mesa/src/attrib.c:1.9 xc/extras/Mesa/src/attrib.c:1.15
--- xc/extras/Mesa/src/attrib.c:1.9	Tue Mar 20 21:48:45 2001
+++ xc/extras/Mesa/src/attrib.c	Mon Dec 16 11:18:26 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4.1
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -29,11 +29,10 @@
 #else
 #include "glheader.h"
 #include "accum.h"
-#include "alpha.h"
 #include "attrib.h"
 #include "blend.h"
 #include "buffers.h"
-#include "clip.h"
+#include "colormac.h"
 #include "context.h"
 #include "depth.h"
 #include "enable.h"
@@ -42,17 +41,16 @@
 #include "hint.h"
 #include "light.h"
 #include "lines.h"
-#include "logic.h"
-#include "masking.h"
 #include "matrix.h"
 #include "mem.h"
 #include "points.h"
 #include "polygon.h"
-#include "scissor.h"
 #include "simple_list.h"
 #include "stencil.h"
+#include "texobj.h"
 #include "texstate.h"
-#include "types.h"
+#include "mtypes.h"
+#include "math/m_xform.h"
 #endif
 
 
@@ -73,42 +71,6 @@
 }
 
 
-
-/*
- * Copy texture object state from one texture object to another.
- */
-static void
-copy_texobj_state( struct gl_texture_object *dest,
-                   const struct gl_texture_object *src )
-{
-   /*
-   dest->Name = src->Name;
-   dest->Dimensions = src->Dimensions;
-   */
-   dest->Priority = src->Priority;
-   dest->BorderColor[0] = src->BorderColor[0];
-   dest->BorderColor[1] = src->BorderColor[1];
-   dest->BorderColor[2] = src->BorderColor[2];
-   dest->BorderColor[3] = src->BorderColor[3];
-   dest->WrapS = src->WrapS;
-   dest->WrapT = src->WrapT;
-   dest->WrapR = src->WrapR;
-   dest->MinFilter = src->MinFilter;
-   dest->MagFilter = src->MagFilter;
-   dest->MinLod = src->MinLod;
-   dest->MaxLod = src->MaxLod;
-   dest->BaseLevel = src->BaseLevel;
-   dest->MaxLevel = src->MaxLevel;
-   dest->P = src->P;
-   dest->M = src->M;
-   dest->MinMagThresh = src->MinMagThresh;
-   dest->Palette = src->Palette;
-   dest->Complete = src->Complete;
-   dest->SampleFunc = src->SampleFunc;
-}
-
-
-
 void
 _mesa_PushAttrib(GLbitfield mask)
 {
@@ -116,13 +78,13 @@
    struct gl_attrib_node *head;
 
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPushAttrib");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
       fprintf(stderr, "glPushAttrib %x\n", (int)mask);
 
-   if (ctx->AttribStackDepth>=MAX_ATTRIB_STACK_DEPTH) {
-      gl_error( ctx, GL_STACK_OVERFLOW, "glPushAttrib" );
+   if (ctx->AttribStackDepth >= MAX_ATTRIB_STACK_DEPTH) {
+      _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushAttrib" );
       return;
    }
 
@@ -152,6 +114,7 @@
 
    if (mask & GL_CURRENT_BIT) {
       struct gl_current_attrib *attr;
+      FLUSH_CURRENT( ctx, 0 );
       attr = MALLOC_STRUCT( gl_current_attrib );
       MEMCPY( attr, &ctx->Current, sizeof(struct gl_current_attrib) );
       newnode = new_attrib_node( GL_CURRENT_BIT );
@@ -218,6 +181,7 @@
       attr->Map2Vertex3 = ctx->Eval.Map2Vertex3;
       attr->Map2Vertex4 = ctx->Eval.Map2Vertex4;
       attr->Normalize = ctx->Transform.Normalize;
+      attr->RasterPositionUnclipped = ctx->Transform.RasterPositionUnclipped;
       attr->PixelTexture = ctx->Pixel.PixelTextureEnabled;
       attr->PointSmooth = ctx->Point.SmoothFlag;
       attr->PolygonOffsetPoint = ctx->Polygon.OffsetPoint;
@@ -228,6 +192,11 @@
       attr->RescaleNormals = ctx->Transform.RescaleNormals;
       attr->Scissor = ctx->Scissor.Enabled;
       attr->Stencil = ctx->Stencil.Enabled;
+      attr->MultisampleEnabled = ctx->Multisample.Enabled;
+      attr->SampleAlphaToCoverage = ctx->Multisample.SampleAlphaToCoverage;
+      attr->SampleAlphaToOne = ctx->Multisample.SampleAlphaToOne;
+      attr->SampleCoverage = ctx->Multisample.SampleCoverage;
+      attr->SampleCoverageInvert = ctx->Multisample.SampleCoverageInvert;
       for (i=0; i<MAX_TEXTURE_UNITS; i++) {
          attr->Texture[i] = ctx->Texture.Unit[i].Enabled;
          attr->TexGen[i] = ctx->Texture.Unit[i].TexGenEnabled;
@@ -270,6 +239,7 @@
 
    if (mask & GL_LIGHTING_BIT) {
       struct gl_light_attrib *attr;
+      FLUSH_CURRENT(ctx, 0);	/* flush material changes */
       attr = MALLOC_STRUCT( gl_light_attrib );
       MEMCPY( attr, &ctx->Light, sizeof(struct gl_light_attrib) );
       newnode = new_attrib_node( GL_LIGHTING_BIT );
@@ -361,20 +331,29 @@
    if (mask & GL_TEXTURE_BIT) {
       struct gl_texture_attrib *attr;
       GLuint u;
-      /* Take care of texture object reference counters */
+      /* Bump the texture object reference counts so that they don't
+       * inadvertantly get deleted.
+       */
       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-	 ctx->Texture.Unit[u].CurrentD[1]->RefCount++;
-	 ctx->Texture.Unit[u].CurrentD[2]->RefCount++;
-	 ctx->Texture.Unit[u].CurrentD[3]->RefCount++;
+	 ctx->Texture.Unit[u].Current1D->RefCount++;
+	 ctx->Texture.Unit[u].Current2D->RefCount++;
+	 ctx->Texture.Unit[u].Current3D->RefCount++;
+	 ctx->Texture.Unit[u].CurrentCubeMap->RefCount++;
       }
       attr = MALLOC_STRUCT( gl_texture_attrib );
       MEMCPY( attr, &ctx->Texture, sizeof(struct gl_texture_attrib) );
       /* copy state of the currently bound texture objects */
       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-         copy_texobj_state(&attr->Unit[u].Saved1D, attr->Unit[u].CurrentD[1]);
-         copy_texobj_state(&attr->Unit[u].Saved2D, attr->Unit[u].CurrentD[2]);
-         copy_texobj_state(&attr->Unit[u].Saved3D, attr->Unit[u].CurrentD[3]);
-         copy_texobj_state(&attr->Unit[u].SavedCubeMap, attr->Unit[u].CurrentCubeMap);
+         _mesa_copy_texture_object(&attr->Unit[u].Saved1D,
+                                    attr->Unit[u].Current1D);
+         _mesa_copy_texture_object(&attr->Unit[u].Saved2D,
+                                    attr->Unit[u].Current2D);
+         _mesa_copy_texture_object(&attr->Unit[u].Saved3D,
+                                    attr->Unit[u].Current3D);
+         _mesa_copy_texture_object(&attr->Unit[u].SavedCubeMap,
+                                    attr->Unit[u].CurrentCubeMap);
+         _mesa_copy_texture_object(&attr->Unit[u].SavedRect,
+                                    attr->Unit[u].CurrentRect);
       }
       newnode = new_attrib_node( GL_TEXTURE_BIT );
       newnode->data = attr;
@@ -402,6 +381,17 @@
       head = newnode;
    }
 
+   /* GL_ARB_multisample */
+   if (mask & GL_MULTISAMPLE_BIT_ARB) {
+      struct gl_multisample_attrib *attr;
+      attr = MALLOC_STRUCT( gl_multisample_attrib );
+      MEMCPY( attr, &ctx->Multisample, sizeof(struct gl_multisample_attrib) );
+      newnode = new_attrib_node( GL_MULTISAMPLE_BIT_ARB );
+      newnode->data = attr;
+      newnode->next = head;
+      head = newnode;
+   }
+
    ctx->AttribStack[ctx->AttribStackDepth] = head;
    ctx->AttribStackDepth++;
 }
@@ -419,7 +409,6 @@
 	}
 
    TEST_AND_UPDATE(ctx->Color.AlphaEnabled, enable->AlphaTest, GL_ALPHA_TEST);
-   TEST_AND_UPDATE(ctx->Transform.Normalize, enable->AutoNormal, GL_NORMALIZE);
    TEST_AND_UPDATE(ctx->Color.BlendEnabled, enable->Blend, GL_BLEND);
 
    for (i=0;i<MAX_CLIP_PLANES;i++) {
@@ -478,9 +467,13 @@
                    GL_MAP2_VERTEX_3);
    TEST_AND_UPDATE(ctx->Eval.Map2Vertex4, enable->Map2Vertex4,
                    GL_MAP2_VERTEX_4);
+   TEST_AND_UPDATE(ctx->Eval.AutoNormal, enable->AutoNormal, GL_AUTO_NORMAL);
    TEST_AND_UPDATE(ctx->Transform.Normalize, enable->Normalize, GL_NORMALIZE);
    TEST_AND_UPDATE(ctx->Transform.RescaleNormals, enable->RescaleNormals,
                    GL_RESCALE_NORMAL_EXT);
+   TEST_AND_UPDATE(ctx->Transform.RasterPositionUnclipped,
+                   enable->RasterPositionUnclipped,
+                   GL_RASTER_POSITION_UNCLIPPED_IBM);
    TEST_AND_UPDATE(ctx->Pixel.PixelTextureEnabled, enable->PixelTexture,
                    GL_POINT_SMOOTH);
    TEST_AND_UPDATE(ctx->Point.SmoothFlag, enable->PointSmooth,
@@ -497,6 +490,20 @@
                    GL_POLYGON_STIPPLE);
    TEST_AND_UPDATE(ctx->Scissor.Enabled, enable->Scissor, GL_SCISSOR_TEST);
    TEST_AND_UPDATE(ctx->Stencil.Enabled, enable->Stencil, GL_STENCIL_TEST);
+   TEST_AND_UPDATE(ctx->Multisample.Enabled, enable->MultisampleEnabled,
+                   GL_MULTISAMPLE_ARB);
+   TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToCoverage,
+                   enable->SampleAlphaToCoverage,
+                   GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
+   TEST_AND_UPDATE(ctx->Multisample.SampleAlphaToOne,
+                   enable->SampleAlphaToOne,
+                   GL_SAMPLE_ALPHA_TO_ONE_ARB);
+   TEST_AND_UPDATE(ctx->Multisample.SampleCoverage,
+                   enable->SampleCoverage,
+                   GL_SAMPLE_COVERAGE_ARB);
+   TEST_AND_UPDATE(ctx->Multisample.SampleCoverageInvert,
+                   enable->SampleCoverageInvert,
+                   GL_SAMPLE_COVERAGE_INVERT_ARB);
 #undef TEST_AND_UPDATE
 
    /* texture unit enables */
@@ -513,6 +520,12 @@
                              (GLboolean) (enable->Texture[i] & TEXTURE0_2D) );
             (*ctx->Driver.Enable)( ctx, GL_TEXTURE_3D,
                              (GLboolean) (enable->Texture[i] & TEXTURE0_3D) );
+            if (ctx->Extensions.ARB_texture_cube_map)
+               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_CUBE_MAP_ARB,
+                           (GLboolean) (enable->Texture[i] & TEXTURE0_CUBE) );
+            if (ctx->Extensions.NV_texture_rectangle)
+               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_RECTANGLE_NV,
+                          (GLboolean) (enable->Texture[i] & TEXTURE0_RECT) );
          }
       }
 
@@ -548,23 +561,190 @@
 }
 
 
+static void
+pop_texture_group(GLcontext *ctx, const struct gl_texture_attrib *texAttrib)
+{
+   GLuint u;
+
+   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+      const struct gl_texture_unit *unit = &texAttrib->Unit[u];
+      GLuint i;
+
+      _mesa_ActiveTextureARB(GL_TEXTURE0_ARB + u);
+      _mesa_set_enable(ctx, GL_TEXTURE_1D,
+              (GLboolean) (unit->Enabled & TEXTURE0_1D ? GL_TRUE : GL_FALSE));
+      _mesa_set_enable(ctx, GL_TEXTURE_2D,
+              (GLboolean) (unit->Enabled & TEXTURE0_2D ? GL_TRUE : GL_FALSE));
+      _mesa_set_enable(ctx, GL_TEXTURE_3D,
+              (GLboolean) (unit->Enabled & TEXTURE0_3D ? GL_TRUE : GL_FALSE));
+      if (ctx->Extensions.ARB_texture_cube_map) {
+         _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP_ARB,
+             (GLboolean) (unit->Enabled & TEXTURE0_CUBE ? GL_TRUE : GL_FALSE));
+      }
+      if (ctx->Extensions.NV_texture_rectangle) {
+         _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_NV,
+             (GLboolean) (unit->Enabled & TEXTURE0_RECT ? GL_TRUE : GL_FALSE));
+      }
+      _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->EnvMode);
+      _mesa_TexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, unit->EnvColor);
+      _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenModeS);
+      _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenModeT);
+      _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenModeR);
+      _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenModeQ);
+      _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->ObjectPlaneS);
+      _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->ObjectPlaneT);
+      _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->ObjectPlaneR);
+      _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->ObjectPlaneQ);
+      _mesa_TexGenfv(GL_S, GL_EYE_PLANE, unit->EyePlaneS);
+      _mesa_TexGenfv(GL_T, GL_EYE_PLANE, unit->EyePlaneT);
+      _mesa_TexGenfv(GL_R, GL_EYE_PLANE, unit->EyePlaneR);
+      _mesa_TexGenfv(GL_Q, GL_EYE_PLANE, unit->EyePlaneQ);
+      if (ctx->Extensions.EXT_texture_lod_bias) {
+         _mesa_TexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
+                       GL_TEXTURE_LOD_BIAS_EXT, unit->LodBias);
+      }
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT,
+                       unit->CombineModeRGB);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT,
+                       unit->CombineModeA);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT,
+                       unit->CombineSourceRGB[0]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT,
+                       unit->CombineSourceRGB[1]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT,
+                       unit->CombineSourceRGB[2]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT,
+                       unit->CombineSourceA[0]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT,
+                       unit->CombineSourceA[1]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_EXT,
+                       unit->CombineSourceA[2]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT,
+                       unit->CombineOperandRGB[0]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT,
+                       unit->CombineOperandRGB[1]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT,
+                       unit->CombineOperandRGB[2]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT,
+                       unit->CombineOperandA[0]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT,
+                       unit->CombineOperandA[1]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_EXT,
+                       unit->CombineOperandA[2]);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT,
+                       1 << unit->CombineScaleShiftRGB);
+         _mesa_TexEnvi(GL_TEXTURE_ENV, GL_ALPHA_SCALE,
+                       1 << unit->CombineScaleShiftA);
+      }
+
+      /* Restore texture object state */
+      for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
+         GLenum target = 0;
+         const struct gl_texture_object *obj = NULL;
+         GLfloat bordColor[4];
+
+         switch (i) {
+         case 0:
+            target = GL_TEXTURE_1D;
+            obj = &unit->Saved1D;
+            break;
+         case 1:
+            target = GL_TEXTURE_2D;
+            obj = &unit->Saved2D;
+            break;
+         case 2:
+            target = GL_TEXTURE_3D;
+            obj = &unit->Saved3D;
+            break;
+         case 3:
+            if (!ctx->Extensions.ARB_texture_cube_map)
+               continue;
+            target = GL_TEXTURE_CUBE_MAP_ARB;
+            obj = &unit->SavedCubeMap;
+            break;
+         case 4:
+            if (!ctx->Extensions.NV_texture_rectangle)
+               continue;
+            target = GL_TEXTURE_RECTANGLE_NV;
+            obj = &unit->SavedRect;
+            break;
+         default:
+            ; /* silence warnings */
+         }
+
+         _mesa_BindTexture(target, obj->Name);
+
+         bordColor[0] = CHAN_TO_FLOAT(obj->BorderColor[0]);
+         bordColor[1] = CHAN_TO_FLOAT(obj->BorderColor[1]);
+         bordColor[2] = CHAN_TO_FLOAT(obj->BorderColor[2]);
+         bordColor[3] = CHAN_TO_FLOAT(obj->BorderColor[3]);
+
+         _mesa_TexParameterf(target, GL_TEXTURE_PRIORITY, obj->Priority);
+         _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, bordColor);
+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, obj->WrapS);
+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, obj->WrapT);
+         _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, obj->WrapR);
+         _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, obj->MinFilter);
+         _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, obj->MagFilter);
+         _mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, obj->MinLod);
+         _mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, obj->MaxLod);
+         _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, obj->BaseLevel);
+         _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel);
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+            _mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                                obj->MaxAnisotropy);
+         }
+         if (ctx->Extensions.SGIX_shadow) {
+            _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_SGIX,
+                                obj->CompareFlag);
+            _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_OPERATOR_SGIX,
+                                obj->CompareOperator);
+         }
+         if (ctx->Extensions.SGIX_shadow_ambient) {
+            _mesa_TexParameterf(target, GL_SHADOW_AMBIENT_SGIX,
+                                CHAN_TO_FLOAT(obj->ShadowAmbient));
+         }
+
+      }
+   }
+   _mesa_ActiveTextureARB(GL_TEXTURE0_ARB
+                          + texAttrib->CurrentUnit);
 
+   /* "un-bump" the texture object reference counts.  We did that so they
+    * wouldn't inadvertantly get deleted while they were still referenced
+    * inside the attribute state stack.
+    */
+   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+      ctx->Texture.Unit[u].Current1D->RefCount--;
+      ctx->Texture.Unit[u].Current2D->RefCount--;
+      ctx->Texture.Unit[u].Current3D->RefCount--;
+      ctx->Texture.Unit[u].CurrentCubeMap->RefCount--;
+      ctx->Texture.Unit[u].CurrentRect->RefCount--;
+   }
+}
 
+
 /*
  * This function is kind of long just because we have to call a lot
  * of device driver functions to update device driver state.
+ *
+ * XXX As it is now, most of the pop-code calls immediate-mode Mesa functions
+ * in order to restore GL state.  This isn't terribly efficient but it
+ * ensures that dirty flags and any derived state gets updated correctly.
+ * We could at least check if the value to restore equals the current value
+ * and then skip the Mesa call.
  */
 void
 _mesa_PopAttrib(void)
 {
    struct gl_attrib_node *attr, *next;
    GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPopAttrib");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-
-   if (ctx->AttribStackDepth==0) {
-      gl_error( ctx, GL_STACK_UNDERFLOW, "glPopAttrib" );
+   if (ctx->AttribStackDepth == 0) {
+      _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopAttrib" );
       return;
    }
 
@@ -573,8 +753,10 @@
 
    while (attr) {
 
-      if (MESA_VERBOSE&VERBOSE_API)
-	 fprintf(stderr, "glPopAttrib %s\n", gl_lookup_enum_by_nr(attr->kind));
+      if (MESA_VERBOSE&VERBOSE_API) {
+	 fprintf(stderr, "glPopAttrib %s\n",
+                 _mesa_lookup_enum_by_nr(attr->kind));
+      }
 
       switch (attr->kind) {
          case GL_ACCUM_BUFFER_BIT:
@@ -591,11 +773,11 @@
             {
                const struct gl_colorbuffer_attrib *color;
                color = (const struct gl_colorbuffer_attrib *) attr->data;
-               _mesa_ClearIndex(color->ClearIndex);
-               _mesa_ClearColor(color->ClearColor[0],
-                                color->ClearColor[1],
-                                color->ClearColor[2],
-                                color->ClearColor[3]);
+               _mesa_ClearIndex((GLfloat) color->ClearIndex);
+               _mesa_ClearColor(CHAN_TO_FLOAT(color->ClearColor[0]),
+                                CHAN_TO_FLOAT(color->ClearColor[1]),
+                                CHAN_TO_FLOAT(color->ClearColor[2]),
+                                CHAN_TO_FLOAT(color->ClearColor[3]));
                _mesa_IndexMask(color->IndexMask);
                _mesa_ColorMask((GLboolean) (color->ColorMask[0] != 0),
                                (GLboolean) (color->ColorMask[1] != 0),
@@ -604,7 +786,7 @@
                _mesa_DrawBuffer(color->DrawBuffer);
                _mesa_set_enable(ctx, GL_ALPHA_TEST, color->AlphaEnabled);
                _mesa_AlphaFunc(color->AlphaFunc,
-                               UBYTE_TO_FLOAT(color->AlphaRef));
+                               CHAN_TO_FLOAT(color->AlphaRef));
                _mesa_set_enable(ctx, GL_BLEND, color->BlendEnabled);
                _mesa_BlendFuncSeparateEXT(color->BlendSrcRGB,
                                           color->BlendDstRGB,
@@ -624,6 +806,7 @@
             }
             break;
          case GL_CURRENT_BIT:
+	    FLUSH_CURRENT( ctx, 0 );
             MEMCPY( &ctx->Current, attr->data,
 		    sizeof(struct gl_current_attrib) );
             break;
@@ -635,7 +818,7 @@
                _mesa_ClearDepth(depth->Clear);
                _mesa_set_enable(ctx, GL_DEPTH_TEST, depth->Test);
                _mesa_DepthMask(depth->Mask);
-               if (ctx->Extensions.HaveHpOcclusionTest)
+               if (ctx->Extensions.HP_occlusion_test)
                   _mesa_set_enable(ctx, GL_OCCLUSION_TEST_HP,
                                    depth->OcclusionTest);
             }
@@ -645,11 +828,12 @@
                const struct gl_enable_attrib *enable;
                enable = (const struct gl_enable_attrib *) attr->data;
                pop_enable_group(ctx, enable);
-               _mesa_set_enable(ctx, GL_POINT_SMOOTH, enable->PointSmooth);
+	       ctx->NewState |= _NEW_ALL;
             }
             break;
          case GL_EVAL_BIT:
             MEMCPY( &ctx->Eval, attr->data, sizeof(struct gl_eval_attrib) );
+	    ctx->NewState |= _NEW_EVAL;
             break;
          case GL_FOG_BIT:
             {
@@ -668,8 +852,6 @@
             {
                const struct gl_hint_attrib *hint;
                hint = (const struct gl_hint_attrib *) attr->data;
-               /* XXX this memcpy is temporary: */
-               MEMCPY(&ctx->Hint, hint, sizeof(struct gl_hint_attrib));
                _mesa_Hint(GL_PERSPECTIVE_CORRECTION_HINT,
                           hint->PerspectiveCorrection );
                _mesa_Hint(GL_POINT_SMOOTH_HINT, hint->PointSmooth);
@@ -678,10 +860,9 @@
                _mesa_Hint(GL_FOG_HINT, hint->Fog);
                _mesa_Hint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT,
                           hint->ClipVolumeClipping);
-               if (ctx->Extensions.HaveTextureCompression)
+               if (ctx->Extensions.ARB_texture_compression)
                   _mesa_Hint(GL_TEXTURE_COMPRESSION_HINT_ARB,
                              hint->TextureCompression);
-               /* XXX keep PGI_misc_hints? */
             }
             break;
          case GL_LIGHTING_BIT:
@@ -692,11 +873,30 @@
                /* lighting enable */
                _mesa_set_enable(ctx, GL_LIGHTING, light->Enabled);
                /* per-light state */
+
+	       if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) 
+		  _math_matrix_analyse( &ctx->ModelView );
+	       
                for (i = 0; i < MAX_LIGHTS; i++) {
                   GLenum lgt = (GLenum) (GL_LIGHT0 + i);
-                  _mesa_set_enable(ctx, lgt, light->Light[i].Enabled);
-                  MEMCPY(&ctx->Light.Light[i], &light->Light[i],
-                         sizeof(struct gl_light));
+		  const struct gl_light *l = &light->Light[i];
+		  GLfloat tmp[4];
+                  _mesa_set_enable(ctx, lgt, l->Enabled);
+		  _mesa_Lightfv( lgt, GL_AMBIENT, l->Ambient );
+		  _mesa_Lightfv( lgt, GL_DIFFUSE, l->Diffuse );
+		  _mesa_Lightfv( lgt, GL_SPECULAR, l->Specular );
+		  TRANSFORM_POINT( tmp, ctx->ModelView.inv, l->EyePosition );
+		  _mesa_Lightfv( lgt, GL_POSITION, tmp );
+		  TRANSFORM_POINT( tmp, ctx->ModelView.m, l->EyeDirection );
+		  _mesa_Lightfv( lgt, GL_SPOT_DIRECTION, tmp );
+		  _mesa_Lightfv( lgt, GL_SPOT_EXPONENT, &l->SpotExponent );
+		  _mesa_Lightfv( lgt, GL_SPOT_CUTOFF, &l->SpotCutoff );
+		  _mesa_Lightfv( lgt, GL_CONSTANT_ATTENUATION, 
+				 &l->ConstantAttenuation );
+		  _mesa_Lightfv( lgt, GL_LINEAR_ATTENUATION, 
+				 &l->LinearAttenuation );
+		  _mesa_Lightfv( lgt, GL_QUADRATIC_ATTENUATION, 
+				 &l->QuadraticAttenuation );
                }
                /* light model */
                _mesa_LightModelfv(GL_LIGHT_MODEL_AMBIENT,
@@ -734,6 +934,7 @@
             break;
          case GL_PIXEL_MODE_BIT:
             MEMCPY( &ctx->Pixel, attr->data, sizeof(struct gl_pixel_attrib) );
+	    ctx->NewState |= _NEW_PIXEL;
             break;
          case GL_POINT_BIT:
             {
@@ -741,12 +942,16 @@
                point = (const struct gl_point_attrib *) attr->data;
                _mesa_PointSize(point->Size);
                _mesa_set_enable(ctx, GL_POINT_SMOOTH, point->SmoothFlag);
-               _mesa_PointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT,
-                                         point->Params);
-               _mesa_PointParameterfEXT(GL_POINT_SIZE_MIN_EXT, point->MinSize);
-               _mesa_PointParameterfEXT(GL_POINT_SIZE_MAX_EXT, point->MaxSize);
-               _mesa_PointParameterfEXT(GL_POINT_FADE_THRESHOLD_SIZE_EXT,
-                                        point->Threshold);
+               if (ctx->Extensions.EXT_point_parameters) {
+                  _mesa_PointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT,
+                                            point->Params);
+                  _mesa_PointParameterfEXT(GL_POINT_SIZE_MIN_EXT,
+                                           point->MinSize);
+                  _mesa_PointParameterfEXT(GL_POINT_SIZE_MAX_EXT,
+                                           point->MaxSize);
+                  _mesa_PointParameterfEXT(GL_POINT_FADE_THRESHOLD_SIZE_EXT,
+                                           point->Threshold);
+               }
             }
             break;
          case GL_POLYGON_BIT:
@@ -772,7 +977,8 @@
             break;
 	 case GL_POLYGON_STIPPLE_BIT:
 	    MEMCPY( ctx->PolygonStipple, attr->data, 32*sizeof(GLuint) );
-	    if (ctx->Driver.PolygonStipple) 
+	    ctx->NewState |= _NEW_POLYGONSTIPPLE;
+	    if (ctx->Driver.PolygonStipple)
 	       ctx->Driver.PolygonStipple( ctx, (const GLubyte *) attr->data );
 	    break;
          case GL_SCISSOR_BIT:
@@ -803,16 +1009,27 @@
                const struct gl_transform_attrib *xform;
                xform = (const struct gl_transform_attrib *) attr->data;
                _mesa_MatrixMode(xform->MatrixMode);
-               /* clip planes */
-               MEMCPY(ctx->Transform.EyeUserPlane, xform->EyeUserPlane,
-                      sizeof(xform->EyeUserPlane));
-               MEMCPY(ctx->Transform.ClipUserPlane, xform->ClipUserPlane,
-                      sizeof(xform->EyeUserPlane));
-               /* clip plane enable flags */
+
+               if (ctx->ProjectionMatrix.flags & MAT_DIRTY)
+                  _math_matrix_analyse( &ctx->ProjectionMatrix );
+
+               /* restore clip planes */
                for (i = 0; i < MAX_CLIP_PLANES; i++) {
-                  _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i,
-                                   xform->ClipEnabled[i]);
+                  const GLfloat *eyePlane = xform->EyeUserPlane[i];
+                  COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane);
+                  if (xform->ClipEnabled[i]) {
+                     _mesa_transform_vector( ctx->Transform._ClipUserPlane[i],
+                                             eyePlane,
+                                             ctx->ProjectionMatrix.inv );
+                     _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE );
+                  }
+                  else {
+                     _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE );
+                  }
+                  if (ctx->Driver.ClipPlane)
+                     ctx->Driver.ClipPlane( ctx, GL_CLIP_PLANE0 + i, eyePlane );
                }
+
                /* normalize/rescale */
                _mesa_set_enable(ctx, GL_NORMALIZE, ctx->Transform.Normalize);
                _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT,
@@ -822,44 +1039,31 @@
          case GL_TEXTURE_BIT:
             /* Take care of texture object reference counters */
             {
-               /* XXX call _mesa_Tex*() functions directly? */
-               GLuint u;
-               for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-		  ctx->Texture.Unit[u].CurrentD[1]->RefCount--;
-		  ctx->Texture.Unit[u].CurrentD[2]->RefCount--;
-		  ctx->Texture.Unit[u].CurrentD[3]->RefCount--;
-               }
-               MEMCPY( &ctx->Texture, attr->data,
-                       sizeof(struct gl_texture_attrib) );
-               /* restore state of the currently bound texture objects */
-               for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-                  copy_texobj_state( ctx->Texture.Unit[u].CurrentD[1],
-                                     &(ctx->Texture.Unit[u].Saved1D) );
-                  copy_texobj_state( ctx->Texture.Unit[u].CurrentD[2],
-                                     &(ctx->Texture.Unit[u].Saved2D) );
-                  copy_texobj_state( ctx->Texture.Unit[u].CurrentD[3],
-                                     &(ctx->Texture.Unit[u].Saved3D) );
-                  copy_texobj_state( ctx->Texture.Unit[u].CurrentCubeMap,
-                                     &(ctx->Texture.Unit[u].SavedCubeMap) );
-
-                  gl_put_texobj_on_dirty_list( ctx, ctx->Texture.Unit[u].CurrentD[1] );
-                  gl_put_texobj_on_dirty_list( ctx, ctx->Texture.Unit[u].CurrentD[2] );
-                  gl_put_texobj_on_dirty_list( ctx, ctx->Texture.Unit[u].CurrentD[3] );
-                  gl_put_texobj_on_dirty_list( ctx, ctx->Texture.Unit[u].CurrentCubeMap );
-
-               }
+               const struct gl_texture_attrib *texture;
+               texture = (const struct gl_texture_attrib *) attr->data;
+               pop_texture_group(ctx, texture);
+	       ctx->NewState |= _NEW_TEXTURE;
             }
             break;
-         case GL_VIEWPORT_BIT: 
+         case GL_VIEWPORT_BIT:
             {
                const struct gl_viewport_attrib *vp;
-               vp = (const struct gl_viewport_attrib *)attr->data;
+               vp = (const struct gl_viewport_attrib *) attr->data;
                _mesa_Viewport(vp->X, vp->Y, vp->Width, vp->Height);
                _mesa_DepthRange(vp->Near, vp->Far);
             }
             break;
+         case GL_MULTISAMPLE_BIT_ARB:
+            {
+               const struct gl_multisample_attrib *ms;
+               ms = (const struct gl_multisample_attrib *) attr->data;
+               _mesa_SampleCoverageARB(ms->SampleCoverageValue,
+                                       ms->SampleCoverageInvert);
+            }
+            break;
+
          default:
-            gl_problem( ctx, "Bad attrib flag in PopAttrib");
+            _mesa_problem( ctx, "Bad attrib flag in PopAttrib");
             break;
       }
 
@@ -868,8 +1072,6 @@
       FREE( attr );
       attr = next;
    }
-
-   ctx->NewState = NEW_ALL;
 }
 
 
@@ -884,10 +1086,10 @@
    struct gl_attrib_node *head;
 
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPushClientAttrib");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (ctx->ClientAttribStackDepth>=MAX_CLIENT_ATTRIB_STACK_DEPTH) {
-      gl_error( ctx, GL_STACK_OVERFLOW, "glPushClientAttrib" );
+   if (ctx->ClientAttribStackDepth >= MAX_CLIENT_ATTRIB_STACK_DEPTH) {
+      _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushClientAttrib" );
       return;
    }
 
@@ -935,10 +1137,10 @@
    struct gl_attrib_node *attr, *next;
 
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPopClientAttrib");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->ClientAttribStackDepth==0) {
-      gl_error( ctx, GL_STACK_UNDERFLOW, "glPopClientAttrib" );
+   if (ctx->ClientAttribStackDepth == 0) {
+      _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopClientAttrib" );
       return;
    }
 
@@ -950,17 +1152,20 @@
          case GL_CLIENT_PACK_BIT:
             MEMCPY( &ctx->Pack, attr->data,
                     sizeof(struct gl_pixelstore_attrib) );
+	    ctx->NewState |= _NEW_PACKUNPACK;
             break;
          case GL_CLIENT_UNPACK_BIT:
             MEMCPY( &ctx->Unpack, attr->data,
                     sizeof(struct gl_pixelstore_attrib) );
+	    ctx->NewState |= _NEW_PACKUNPACK;
             break;
          case GL_CLIENT_VERTEX_ARRAY_BIT:
             MEMCPY( &ctx->Array, attr->data,
 		    sizeof(struct gl_array_attrib) );
+	    ctx->NewState |= _NEW_ARRAY;
             break;
          default:
-            gl_problem( ctx, "Bad attrib flag in PopClientAttrib");
+            _mesa_problem( ctx, "Bad attrib flag in PopClientAttrib");
             break;
       }
 
@@ -969,9 +1174,4 @@
       FREE( attr );
       attr = next;
    }
-
-   ctx->NewState = NEW_ALL;
 }
-
-
-
Index: xc/extras/Mesa/src/attrib.h
diff -u xc/extras/Mesa/src/attrib.h:1.3 xc/extras/Mesa/src/attrib.h:1.4
--- xc/extras/Mesa/src/attrib.h:1.3	Tue Feb 15 02:12:02 2000
+++ xc/extras/Mesa/src/attrib.h	Fri Feb 22 14:25:23 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,8 +28,7 @@
 #define ATTRIB_h
 
 
-#include "types.h"
-
+#include "mtypes.h"
 
 extern void
 _mesa_PushAttrib( GLbitfield mask );
Index: xc/extras/Mesa/src/bbox.c
diff -u xc/extras/Mesa/src/bbox.c:1.4 xc/extras/Mesa/src/bbox.c:removed
--- xc/extras/Mesa/src/bbox.c:1.4	Mon Nov 13 18:30:40 2000
+++ xc/extras/Mesa/src/bbox.c	Thu Feb 27 12:15:32 2003
@@ -1,234 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "bbox.h"
-#include "types.h"
-#include "xform.h"
-#endif
-
-
-
-static void cliptest_bounds( GLubyte *orMask, 
-			     GLubyte *andMask,
-			     CONST GLfloat (*bounds)[4],
-			     GLuint count )
-{
-   GLubyte tmpOrMask = 0;
-   GLubyte tmpAndMask = ~0;
-   GLuint i;   
-
-   for (i = 0 ; i < count ; i++) {
-      const GLfloat cx = bounds[i][0];
-      const GLfloat cy = bounds[i][1];
-      const GLfloat cz = bounds[i][2];
-      const GLfloat cw = bounds[i][3];
-      GLubyte mask = 0;
-
-      if (cx > cw)       mask |= CLIP_RIGHT_BIT;
-      else if (cx < -cw) mask |= CLIP_LEFT_BIT;
-      if (cy > cw)       mask |= CLIP_TOP_BIT;
-      else if (cy < -cw) mask |= CLIP_BOTTOM_BIT;
-      if (cz > cw)       mask |= CLIP_FAR_BIT;
-      else if (cz < -cw) mask |= CLIP_NEAR_BIT;
-
-      tmpOrMask |= mask;
-      tmpAndMask &= mask;
-   }
-
-   *orMask = tmpOrMask;
-   *andMask = tmpAndMask;
-}
-
-
-static void transform_bounds3( GLubyte *orMask, GLubyte *andMask,
-			       const GLmatrix *mat,
-			       CONST GLfloat src[][3] )
-{
-   GLuint i;
-   GLfloat dx[4], dy[4], dz[4];
-   GLfloat data[8][4];
-   const GLfloat *m = mat->m;
-
-   /* Do the first transform */
-   gl_transform_point_sz( data[0], mat->m, src[0], 3 );
-
-   for (i = 1 ; i < 8 ; i++)
-      COPY_4FV( data[i], data[0] );
-
-   dx[0] = m[ 0]*src[1][0];
-   dx[1] = m[ 1]*src[1][0];
-   dx[2] = m[ 2]*src[1][0];
-   dx[3] = m[ 3]*src[1][0];
-   
-   for (i = 4 ; i < 8 ; i++)
-      ACC_4V( data[i], dx );
-   
-   dy[0] = m[ 4]*src[1][1];
-   dy[1] = m[ 5]*src[1][1];
-   dy[2] = m[ 6]*src[1][1];
-   dy[3] = m[ 7]*src[1][1];
-
-   ACC_4V( data[2], dy );
-   ACC_4V( data[3], dy );
-   ACC_4V( data[6], dy );
-   ACC_4V( data[7], dy );
-
-   dz[0] = m[ 8]*src[1][2];
-   dz[1] = m[ 9]*src[1][2];
-   dz[2] = m[10]*src[1][2];
-   dz[3] = m[11]*src[1][2];
-
-   for (i = 1 ; i < 8 ; i+=2) 
-      ACC_4V( data[i], dz );
-
-   
-   cliptest_bounds( orMask, andMask, (CONST GLfloat (*)[4])data, 8 );
-}
-
-static void transform_bounds2( GLubyte *orMask, GLubyte *andMask, 
-			       const GLmatrix *mat,
-			       CONST GLfloat src[][3] )
-{
-   GLuint i;
-   GLfloat dx[4], dy[4];
-   GLfloat data[4][4];
-   const GLfloat *m = mat->m;
-
-   /* Do the first transform */
-   gl_transform_point_sz( data[0], mat->m, src[0], 2 );
-
-   for (i = 1 ; i < 4 ; i++)
-      COPY_4FV( data[i], data[0] );
-
-   dx[0] = m[0]*src[1][0];
-   dx[1] = m[1]*src[1][0];
-   dx[2] = m[2]*src[1][0];
-   dx[3] = m[3]*src[1][0];
-   
-   ACC_4V( data[1], dx );
-   ACC_4V( data[3], dx );
-   
-   dy[0] = m[4]*src[1][1];
-   dy[1] = m[5]*src[1][1];
-   dy[2] = m[6]*src[1][1];
-   dy[3] = m[7]*src[1][1];
-
-   ACC_4V( data[2], dy );
-   ACC_4V( data[3], dy );
-
-   cliptest_bounds( orMask, andMask, (CONST GLfloat (*)[4])data, 4 );
-}
-
-/* Dummy
- */
-static void transform_bounds4( GLubyte *orMask, GLubyte *andMask,
-			       const GLmatrix *mat,
-			       CONST GLfloat src[][3] )
-{
-   (void) mat;
-   (void) src;
-   *orMask = ~0;
-   *andMask = 0;
-}
-
-static void calculate_bounds3( GLfloat (*bounds)[3],
-                               const GLvector4f *obj )
-{
-   CONST GLfloat (*data)[4] = (CONST GLfloat (*)[4])obj->start;
-   GLfloat xmin = data[0][0];
-   GLfloat ymin = data[0][1];
-   GLfloat zmin = data[0][2];
-   GLfloat xmax = data[0][0];
-   GLfloat ymax = data[0][1];
-   GLfloat zmax = data[0][2];
-   GLuint i, count = obj->count;
-   
-   for (i = 1 ; i < count ; i++) {
-      GLfloat t;
-      t = data[i][0]; if (t > xmax) xmax = t; else if (t < xmin) xmin = t;
-      t = data[i][1]; if (t > ymax) ymax = t; else if (t < ymin) ymin = t;
-      t = data[i][2]; if (t > zmax) zmax = t; else if (t < zmin) zmin = t;
-   }
-   
-   bounds[0][0] = xmin;
-   bounds[0][1] = ymin;
-   bounds[0][2] = zmin;
-   bounds[1][0] = xmax - xmin;
-   bounds[1][1] = ymax - ymin;
-   bounds[1][2] = zmax - zmin;
-}
-
-static void calculate_bounds2( GLfloat (*bounds)[3],
-                               const GLvector4f *obj )
-{
-   CONST GLfloat (*data)[4] = (CONST GLfloat (*)[4])obj->start;
-   GLfloat xmin = data[0][0];
-   GLfloat ymin = data[0][1];
-   GLfloat xmax = data[0][0];
-   GLfloat ymax = data[0][1];
-   GLuint i, count = obj->count;
-   
-   for (i = 1 ; i < count ; i++) {
-      GLfloat t;
-      t = data[i][0]; if (t > xmax) xmax = t; if (t < xmin) xmin = t;
-      t = data[i][1]; if (t > ymax) ymax = t; if (t < ymin) ymin = t;
-   }
-   
-   bounds[0][0] = xmin;
-   bounds[0][1] = ymin;
-   bounds[0][2] = 0;
-   bounds[1][0] = xmax - xmin;
-   bounds[1][1] = ymax - ymin;
-   bounds[1][2] = 0;
-}
-
-
-calc_bound_func gl_calc_bound_tab[5] = 
-{
-   0,
-   0,
-   calculate_bounds2,
-   calculate_bounds3,
-   0				/* would 4d bounds make sense? */
-};
-
-test_bound_func gl_test_bound_tab[5] = 
-{
-   0,
-   0,
-   transform_bounds2,
-   transform_bounds3,
-   transform_bounds4
-};
-
Index: xc/extras/Mesa/src/bbox.h
diff -u xc/extras/Mesa/src/bbox.h:1.3 xc/extras/Mesa/src/bbox.h:removed
--- xc/extras/Mesa/src/bbox.h:1.3	Tue Feb 15 02:12:03 2000
+++ xc/extras/Mesa/src/bbox.h	Thu Feb 27 12:15:32 2003
@@ -1,48 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifndef _BBOX_H_
-#define _BBOX_H_
-
-#include "types.h"
-
-typedef void (*test_bound_func)( GLubyte *orMask, 
-				 GLubyte *andMask, 
-				 const GLmatrix *mat,
-				 CONST GLfloat src[][3] );
-
-typedef void (*calc_bound_func)( GLfloat (*bounds)[3],
-				 const GLvector4f *obj );
-
-extern test_bound_func gl_test_bound_tab[5];
-extern calc_bound_func gl_calc_bound_tab[5];
-
-
-#endif
Index: xc/extras/Mesa/src/bitmap.c
diff -u xc/extras/Mesa/src/bitmap.c:1.6 xc/extras/Mesa/src/bitmap.c:removed
--- xc/extras/Mesa/src/bitmap.c:1.6	Mon Nov 13 16:55:32 2000
+++ xc/extras/Mesa/src/bitmap.c	Thu Feb 27 12:15:32 2003
@@ -1,213 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "bitmap.h"
-#include "context.h"
-#include "feedback.h"
-#include "image.h"
-#include "macros.h"
-#include "pb.h"
-#include "pixel.h"
-#include "state.h"
-#include "types.h"
-#include "vbrender.h"
-#endif
-
-
-
-/*
- * Render a bitmap.
- */
-static void 
-render_bitmap( GLcontext *ctx, GLint px, GLint py,
-               GLsizei width, GLsizei height,
-               const struct gl_pixelstore_attrib *unpack,
-               const GLubyte *bitmap )
-{
-   struct pixel_buffer *PB = ctx->PB;
-   GLint row, col;
-   GLdepth fragZ;
-
-   ASSERT(ctx->RenderMode == GL_RENDER);
-
-   if (!bitmap) {
-      return;  /* NULL bitmap is legal, a no-op */
-   }
-
-   RENDER_START(ctx);
-
-   /* Set bitmap drawing color */
-   if (ctx->Visual->RGBAflag) {
-      GLint r, g, b, a;
-      r = (GLint) (ctx->Current.RasterColor[0] * 255.0F);
-      g = (GLint) (ctx->Current.RasterColor[1] * 255.0F);
-      b = (GLint) (ctx->Current.RasterColor[2] * 255.0F);
-      a = (GLint) (ctx->Current.RasterColor[3] * 255.0F);
-      PB_SET_COLOR( PB, r, g, b, a );
-   }
-   else {
-      PB_SET_INDEX( PB, ctx->Current.RasterIndex );
-   }
-
-   fragZ = (GLdepth) ( ctx->Current.RasterPos[2] * ctx->Visual->DepthMaxF);
-
-   for (row=0; row<height; row++) {
-      const GLubyte *src = (const GLubyte *) _mesa_image_address( unpack,
-                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
-
-      if (unpack->LsbFirst) {
-         /* Lsb first */
-         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
-         for (col=0; col<width; col++) {
-            if (*src & mask) {
-               PB_WRITE_PIXEL( PB, px+col, py+row, fragZ );
-            }
-            if (mask == 128U) {
-               src++;
-               mask = 1U;
-            }
-            else {
-               mask = mask << 1;
-            }
-         }
-
-         PB_CHECK_FLUSH( ctx, PB );
-
-         /* get ready for next row */
-         if (mask != 1)
-            src++;
-      }
-      else {
-         /* Msb first */
-         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
-         for (col=0; col<width; col++) {
-            if (*src & mask) {
-               PB_WRITE_PIXEL( PB, px+col, py+row, fragZ );
-            }
-            if (mask == 1U) {
-               src++;
-               mask = 128U;
-            }
-            else {
-               mask = mask >> 1;
-            }
-         }
-
-         PB_CHECK_FLUSH( ctx, PB );
-
-         /* get ready for next row */
-         if (mask != 128)
-            src++;
-      }
-   }
-
-   gl_flush_pb(ctx);
-
-   RENDER_FINISH(ctx);
-}
-
-
-
-/*
- * Execute a glBitmap command.
- */
-void
-_mesa_Bitmap( GLsizei width, GLsizei height,
-              GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
-              const GLubyte *bitmap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBitmap");
-
-   /* Error checking */
-   if (width < 0 || height < 0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glBitmap" );
-      return;
-   }
-
-   if (ctx->Current.RasterPosValid == GL_FALSE) {
-      return;    /* do nothing */
-   }
-
-   if (ctx->RenderMode==GL_RENDER) {
-      if (bitmap) {
-         GLint x = (GLint) ( (ctx->Current.RasterPos[0] - xorig) + 0.0F );
-         GLint y = (GLint) ( (ctx->Current.RasterPos[1] - yorig) + 0.0F );
-         GLboolean completed = GL_FALSE;
-
-         if (ctx->NewState) {
-            gl_update_state(ctx);
-            gl_reduced_prim_change( ctx, GL_BITMAP );
-         }
-
-         if (ctx->PB->primitive!=GL_BITMAP) {   /* A.W. 1.1.2000 */
-            gl_reduced_prim_change( ctx, GL_BITMAP );
-         }
-
-         ctx->OcclusionResult = GL_TRUE;
-
-         if (ctx->Driver.Bitmap) {
-            /* let device driver try to render the bitmap */
-            completed = (*ctx->Driver.Bitmap)( ctx, x, y, width, height,
-                                               &ctx->Unpack, bitmap );
-         }
-         if (!completed) {
-            /* use generic function */
-            render_bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
-         }
-      }
-   }
-   else if (ctx->RenderMode==GL_FEEDBACK) {
-      GLfloat color[4], texcoord[4], invq;
-      color[0] = ctx->Current.RasterColor[0];
-      color[1] = ctx->Current.RasterColor[1];
-      color[2] = ctx->Current.RasterColor[2];
-      color[3] = ctx->Current.RasterColor[3];
-      if (ctx->Current.Texcoord[0][3] == 0.0)
-         invq = 1.0F;
-      else
-         invq = 1.0F / ctx->Current.RasterTexCoord[3];
-      texcoord[0] = ctx->Current.RasterTexCoord[0] * invq;
-      texcoord[1] = ctx->Current.RasterTexCoord[1] * invq;
-      texcoord[2] = ctx->Current.RasterTexCoord[2] * invq;
-      texcoord[3] = ctx->Current.RasterTexCoord[3];
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
-      gl_feedback_vertex( ctx,
-                          ctx->Current.RasterPos,
-			  color, ctx->Current.RasterIndex, texcoord );
-   }
-   else if (ctx->RenderMode==GL_SELECT) {
-      /* Bitmaps don't generate selection hits.  See appendix B of 1.1 spec. */
-   }
-
-   /* update raster position */
-   ctx->Current.RasterPos[0] += xmove;
-   ctx->Current.RasterPos[1] += ymove;
-}
Index: xc/extras/Mesa/src/bitmap.h
diff -u xc/extras/Mesa/src/bitmap.h:1.3 xc/extras/Mesa/src/bitmap.h:removed
--- xc/extras/Mesa/src/bitmap.h:1.3	Tue Feb 15 02:12:03 2000
+++ xc/extras/Mesa/src/bitmap.h	Thu Feb 27 12:15:32 2003
@@ -1,41 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef BITMAP_H
-#define BITMAP_H
-
-
-#include "types.h"
-
-
-
-extern void
-_mesa_Bitmap( GLsizei width, GLsizei height,
-              GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
-              const GLubyte *bitmap );
-
-
-#endif
Index: xc/extras/Mesa/src/blend.c
diff -u xc/extras/Mesa/src/blend.c:1.9 xc/extras/Mesa/src/blend.c:1.10
--- xc/extras/Mesa/src/blend.c:1.9	Mon Nov 13 18:30:40 2000
+++ xc/extras/Mesa/src/blend.c	Fri Feb 22 14:25:23 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -24,38 +24,36 @@
  */
 
 
-
 #ifdef PC_HEADER
 #include "all.h"
 #else
 #include "glheader.h"
-#include "alphabuf.h"
 #include "blend.h"
+#include "colormac.h"
 #include "context.h"
 #include "enums.h"
 #include "macros.h"
-#include "pb.h"
-#include "span.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
 void
 _mesa_BlendFunc( GLenum sfactor, GLenum dfactor )
 {
+
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBlendFunc");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
       fprintf(stderr, "glBlendFunc %s %s\n",
-	      gl_lookup_enum_by_nr(sfactor),
-	      gl_lookup_enum_by_nr(dfactor));
+	      _mesa_lookup_enum_by_nr(sfactor),
+	      _mesa_lookup_enum_by_nr(dfactor));
 
    switch (sfactor) {
       case GL_SRC_COLOR:
       case GL_ONE_MINUS_SRC_COLOR:
-         if (!ctx->Extensions.HaveBlendSquare) {
-            gl_error( ctx, GL_INVALID_ENUM, "glBlendFunc(sfactor)" );
+         if (!ctx->Extensions.NV_blend_square) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glBlendFunc(sfactor)" );
             return;
          }
          /* fall-through */
@@ -72,18 +70,17 @@
       case GL_ONE_MINUS_CONSTANT_COLOR:
       case GL_CONSTANT_ALPHA:
       case GL_ONE_MINUS_CONSTANT_ALPHA:
-         ctx->Color.BlendSrcRGB = ctx->Color.BlendSrcA = sfactor;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glBlendFunc(sfactor)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glBlendFunc(sfactor)" );
          return;
    }
 
    switch (dfactor) {
       case GL_DST_COLOR:
       case GL_ONE_MINUS_DST_COLOR:
-         if (!ctx->Extensions.HaveBlendSquare) {
-            gl_error( ctx, GL_INVALID_ENUM, "glBlendFunc(dfactor)" );
+         if (!ctx->Extensions.NV_blend_square) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glBlendFunc(dfactor)" );
             return;
          }
          /* fall-through */
@@ -99,19 +96,24 @@
       case GL_ONE_MINUS_CONSTANT_COLOR:
       case GL_CONSTANT_ALPHA:
       case GL_ONE_MINUS_CONSTANT_ALPHA:
-         ctx->Color.BlendDstRGB = ctx->Color.BlendDstA = dfactor;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glBlendFunc(dfactor)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glBlendFunc(dfactor)" );
          return;
    }
 
-   if (ctx->Driver.BlendFunc) {
-      (*ctx->Driver.BlendFunc)( ctx, sfactor, dfactor );
-   }
+   if (ctx->Color.BlendDstRGB == dfactor &&
+       ctx->Color.BlendSrcRGB == sfactor &&
+       ctx->Color.BlendDstA == dfactor &&
+       ctx->Color.BlendSrcA == sfactor)
+      return;
 
-   ctx->Color.BlendFunc = NULL;
-   ctx->NewState |= NEW_RASTER_OPS;
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.BlendDstRGB = ctx->Color.BlendDstA = dfactor;
+   ctx->Color.BlendSrcRGB = ctx->Color.BlendSrcA = sfactor;
+
+   if (ctx->Driver.BlendFunc)
+      ctx->Driver.BlendFunc( ctx, sfactor, dfactor );
 }
 
 
@@ -121,20 +123,20 @@
                             GLenum sfactorA, GLenum dfactorA )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBlendFuncSeparate");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      fprintf(stderr, "glBlendFuncSeperate %s %s %s %s\n",
-	      gl_lookup_enum_by_nr(sfactorRGB),
-	      gl_lookup_enum_by_nr(dfactorRGB),
-	      gl_lookup_enum_by_nr(sfactorA),
-	      gl_lookup_enum_by_nr(dfactorA));
+      fprintf(stderr, "glBlendFuncSeparate %s %s %s %s\n",
+	      _mesa_lookup_enum_by_nr(sfactorRGB),
+	      _mesa_lookup_enum_by_nr(dfactorRGB),
+	      _mesa_lookup_enum_by_nr(sfactorA),
+	      _mesa_lookup_enum_by_nr(dfactorA));
 
    switch (sfactorRGB) {
       case GL_SRC_COLOR:
       case GL_ONE_MINUS_SRC_COLOR:
-         if (!ctx->Extensions.HaveBlendSquare) {
-            gl_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorRGB)");
+         if (!ctx->Extensions.NV_blend_square) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorRGB)");
             return;
          }
          /* fall-through */
@@ -151,18 +153,17 @@
       case GL_ONE_MINUS_CONSTANT_COLOR:
       case GL_CONSTANT_ALPHA:
       case GL_ONE_MINUS_CONSTANT_ALPHA:
-         ctx->Color.BlendSrcRGB = sfactorRGB;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorRGB)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorRGB)");
          return;
    }
 
    switch (dfactorRGB) {
       case GL_DST_COLOR:
       case GL_ONE_MINUS_DST_COLOR:
-         if (!ctx->Extensions.HaveBlendSquare) {
-            gl_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorRGB)");
+         if (!ctx->Extensions.NV_blend_square) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorRGB)");
             return;
          }
          /* fall-through */
@@ -178,18 +179,17 @@
       case GL_ONE_MINUS_CONSTANT_COLOR:
       case GL_CONSTANT_ALPHA:
       case GL_ONE_MINUS_CONSTANT_ALPHA:
-         ctx->Color.BlendDstRGB = dfactorRGB;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorRGB)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorRGB)");
          return;
    }
 
    switch (sfactorA) {
       case GL_SRC_COLOR:
       case GL_ONE_MINUS_SRC_COLOR:
-         if (!ctx->Extensions.HaveBlendSquare) {
-            gl_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorA)");
+         if (!ctx->Extensions.NV_blend_square) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorA)");
             return;
          }
          /* fall-through */
@@ -206,18 +206,17 @@
       case GL_ONE_MINUS_CONSTANT_COLOR:
       case GL_CONSTANT_ALPHA:
       case GL_ONE_MINUS_CONSTANT_ALPHA:
-         ctx->Color.BlendSrcA = sfactorA;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorA)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(sfactorA)");
          return;
    }
 
    switch (dfactorA) {
       case GL_DST_COLOR:
       case GL_ONE_MINUS_DST_COLOR:
-         if (!ctx->Extensions.HaveBlendSquare) {
-            gl_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorA)");
+         if (!ctx->Extensions.NV_blend_square) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorA)");
             return;
          }
          /* fall-through */
@@ -233,16 +232,25 @@
       case GL_ONE_MINUS_CONSTANT_COLOR:
       case GL_CONSTANT_ALPHA:
       case GL_ONE_MINUS_CONSTANT_ALPHA:
-         ctx->Color.BlendDstA = dfactorA;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorA)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glBlendFuncSeparate(dfactorA)" );
          return;
    }
+
+   if (ctx->Color.BlendSrcRGB == sfactorRGB &&
+       ctx->Color.BlendDstRGB == dfactorRGB &&
+       ctx->Color.BlendSrcA == sfactorA &&
+       ctx->Color.BlendDstA == dfactorA)
+      return;
 
-   ctx->Color.BlendFunc = NULL;
-   ctx->NewState |= NEW_RASTER_OPS;
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
 
+   ctx->Color.BlendSrcRGB = sfactorRGB;
+   ctx->Color.BlendDstRGB = dfactorRGB;
+   ctx->Color.BlendSrcA = sfactorA;
+   ctx->Color.BlendDstA = dfactorA;
+
    if (ctx->Driver.BlendFuncSeparate) {
       (*ctx->Driver.BlendFuncSeparate)( ctx, sfactorRGB, dfactorRGB,
 					sfactorA, dfactorA );
@@ -256,41 +264,56 @@
 _mesa_BlendEquation( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBlendEquation");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
       fprintf(stderr, "glBlendEquation %s\n",
-	      gl_lookup_enum_by_nr(mode));
+	      _mesa_lookup_enum_by_nr(mode));
 
    switch (mode) {
+      case GL_FUNC_ADD_EXT:
+         break;
       case GL_MIN_EXT:
       case GL_MAX_EXT:
+         if (!ctx->Extensions.EXT_blend_minmax &&
+             !ctx->Extensions.ARB_imaging) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");
+            return;
+         }
+         break;
       case GL_LOGIC_OP:
-      case GL_FUNC_ADD_EXT:
+         if (!ctx->Extensions.EXT_blend_logic_op) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");
+            return;
+         }
+         break;
       case GL_FUNC_SUBTRACT_EXT:
       case GL_FUNC_REVERSE_SUBTRACT_EXT:
-         ctx->Color.BlendEquation = mode;
+         if (!ctx->Extensions.EXT_blend_subtract &&
+             !ctx->Extensions.ARB_imaging) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");
+            return;
+         }
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glBlendEquation" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glBlendEquation" );
          return;
    }
 
+   if (ctx->Color.BlendEquation == mode)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.BlendEquation = mode;
+
    /* This is needed to support 1.1's RGB logic ops AND
     * 1.0's blending logicops.
     */
-   if (mode==GL_LOGIC_OP && ctx->Color.BlendEnabled) {
-      ctx->Color.ColorLogicOpEnabled = GL_TRUE;
-   }
-   else {
-      ctx->Color.ColorLogicOpEnabled = GL_FALSE;
-   }
-
-   ctx->Color.BlendFunc = NULL;
-   ctx->NewState |= NEW_RASTER_OPS;
+   ctx->Color.ColorLogicOpEnabled = (mode==GL_LOGIC_OP &&
+				     ctx->Color.BlendEnabled);
 
    if (ctx->Driver.BlendEquation)
-      ctx->Driver.BlendEquation( ctx, mode );
+      (*ctx->Driver.BlendEquation)( ctx, mode );
 }
 
 
@@ -298,631 +321,145 @@
 void
 _mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
 {
+   GLfloat tmp[4];
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Color.BlendColor[0] = CLAMP( red,   0.0F, 1.0F );
-   ctx->Color.BlendColor[1] = CLAMP( green, 0.0F, 1.0F );
-   ctx->Color.BlendColor[2] = CLAMP( blue,  0.0F, 1.0F );
-   ctx->Color.BlendColor[3] = CLAMP( alpha, 0.0F, 1.0F );
-}
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-#ifdef USE_MMX_ASM
-#define _BLENDAPI _ASMAPI
-#else
-#define _BLENDAPI
-#endif
+   tmp[0] = CLAMP( red,   0.0F, 1.0F );
+   tmp[1] = CLAMP( green, 0.0F, 1.0F );
+   tmp[2] = CLAMP( blue,  0.0F, 1.0F );
+   tmp[3] = CLAMP( alpha, 0.0F, 1.0F );
 
-/*
- * Common transparency blending mode.
- */
-static void _BLENDAPI
-blend_transparency( GLcontext *ctx, GLuint n, const GLubyte mask[],
-                    GLubyte rgba[][4], CONST GLubyte dest[][4] )
-{
-   GLuint i;
-   ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
-   ASSERT(ctx->Color.BlendSrcRGB==GL_SRC_ALPHA);
-   ASSERT(ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA);
-   (void) ctx;
-
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         const GLint t = rgba[i][ACOMP];  /* t in [0,255] */
-         if (t == 0) {
-            /* 0% alpha */
-            rgba[i][RCOMP] = dest[i][RCOMP];
-            rgba[i][GCOMP] = dest[i][GCOMP];
-            rgba[i][BCOMP] = dest[i][BCOMP];
-            rgba[i][ACOMP] = dest[i][ACOMP];
-         }
-         else if (t == CHAN_MAX) {
-            /* 100% alpha, no-op */
-         }
-         else {
-#if 0
-            /* This is pretty close, but Glean complains */
-            const GLint s = CHAN_MAX - t;
-            const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s + 1) >> 8;
-            const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s + 1) >> 8;
-            const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s + 1) >> 8;
-            const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s + 1) >> 8;
-#elif 0
-            /* This is slower but satisfies Glean */
-            const GLint s = CHAN_MAX - t;
-            const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) / 255;
-            const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) / 255;
-            const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) / 255;
-            const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) / 255;
-#else
-            /* This satisfies Glean and should be reasonably fast */
-            /* Contributed by Nathan Hand */
-#define DIV255(X)  (((X) << 8) + (X) + 256) >> 16
-            const GLint s = CHAN_MAX - t;
-            const GLint r = DIV255(rgba[i][RCOMP] * t + dest[i][RCOMP] * s);
-            const GLint g = DIV255(rgba[i][GCOMP] * t + dest[i][GCOMP] * s);
-            const GLint b = DIV255(rgba[i][BCOMP] * t + dest[i][BCOMP] * s);
-            const GLint a = DIV255(rgba[i][ACOMP] * t + dest[i][ACOMP] * s);
-#undef DIV255
-#endif
-            ASSERT(r <= CHAN_MAX);
-            ASSERT(g <= CHAN_MAX);
-            ASSERT(b <= CHAN_MAX);
-            ASSERT(a <= CHAN_MAX);
-            rgba[i][RCOMP] = (GLubyte) r;
-            rgba[i][GCOMP] = (GLubyte) g;
-            rgba[i][BCOMP] = (GLubyte) b;
-            rgba[i][ACOMP] = (GLubyte) a;
-         }
-      }
-   }
-}
-
+   if (TEST_EQ_4V(tmp, ctx->Color.BlendColor))
+      return;
 
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_4FV( ctx->Color.BlendColor, tmp );
 
-/*
- * Add src and dest.
- */
-static void _BLENDAPI
-blend_add( GLcontext *ctx, GLuint n, const GLubyte mask[],
-           GLubyte rgba[][4], CONST GLubyte dest[][4] )
-{
-   GLuint i;
-   ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
-   ASSERT(ctx->Color.BlendSrcRGB==GL_ONE);
-   ASSERT(ctx->Color.BlendDstRGB==GL_ONE);
-   (void) ctx;
-
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
-         GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
-         GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
-         GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
-         rgba[i][RCOMP] = (GLubyte) MIN2( r, CHAN_MAX );
-         rgba[i][GCOMP] = (GLubyte) MIN2( g, CHAN_MAX );
-         rgba[i][BCOMP] = (GLubyte) MIN2( b, CHAN_MAX );
-         rgba[i][ACOMP] = (GLubyte) MIN2( a, CHAN_MAX );
-      }
-   }
+   if (ctx->Driver.BlendColor)
+      (*ctx->Driver.BlendColor)(ctx, tmp);
 }
 
 
-
-/*
- * Blend min function  (for GL_EXT_blend_minmax)
- */
-static void _BLENDAPI
-blend_min( GLcontext *ctx, GLuint n, const GLubyte mask[],
-           GLubyte rgba[][4], CONST GLubyte dest[][4] )
+void
+_mesa_AlphaFunc( GLenum func, GLclampf ref )
 {
-   GLuint i;
-   ASSERT(ctx->Color.BlendEquation==GL_MIN_EXT);
-   (void) ctx;
-
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         rgba[i][RCOMP] = (GLubyte) MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
-         rgba[i][GCOMP] = (GLubyte) MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
-         rgba[i][BCOMP] = (GLubyte) MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
-         rgba[i][ACOMP] = (GLubyte) MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
-      }
-   }
-}
-
-
+   GET_CURRENT_CONTEXT(ctx);
+   GLchan cref;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-/*
- * Blend max function  (for GL_EXT_blend_minmax)
- */
-static void _BLENDAPI
-blend_max( GLcontext *ctx, GLuint n, const GLubyte mask[],
-           GLubyte rgba[][4], CONST GLubyte dest[][4] )
-{
-   GLuint i;
-   ASSERT(ctx->Color.BlendEquation==GL_MAX_EXT);
-   (void) ctx;
-
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         rgba[i][RCOMP] = (GLubyte) MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
-         rgba[i][GCOMP] = (GLubyte) MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
-         rgba[i][BCOMP] = (GLubyte) MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
-         rgba[i][ACOMP] = (GLubyte) MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
-      }
-   }
-}
+   switch (func) {
+   case GL_NEVER:
+   case GL_LESS:
+   case GL_EQUAL:
+   case GL_LEQUAL:
+   case GL_GREATER:
+   case GL_NOTEQUAL:
+   case GL_GEQUAL:
+   case GL_ALWAYS:
+      /* convert float alpha ref to GLchan type */
+      UNCLAMPED_FLOAT_TO_CHAN(cref, ref);
 
+      if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRef == cref)
+         return;
 
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.AlphaFunc = func;
+      ctx->Color.AlphaRef = cref;
 
-/*
- * Modulate:  result = src * dest
- */
-static void _BLENDAPI
-blend_modulate( GLcontext *ctx, GLuint n, const GLubyte mask[],
-                GLubyte rgba[][4], CONST GLubyte dest[][4] )
-{
-   GLuint i;
-   (void) ctx;
+      if (ctx->Driver.AlphaFunc)
+         ctx->Driver.AlphaFunc(ctx, func, cref);
+      return;
 
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         GLint r = (rgba[i][RCOMP] * dest[i][RCOMP]) >> 8;
-         GLint g = (rgba[i][GCOMP] * dest[i][GCOMP]) >> 8;
-         GLint b = (rgba[i][BCOMP] * dest[i][BCOMP]) >> 8;
-         GLint a = (rgba[i][ACOMP] * dest[i][ACOMP]) >> 8;
-         rgba[i][RCOMP] = (GLubyte) r;
-         rgba[i][GCOMP] = (GLubyte) g;
-         rgba[i][BCOMP] = (GLubyte) b;
-         rgba[i][ACOMP] = (GLubyte) a;
-      }
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glAlphaFunc(func)" );
+      return;
    }
 }
 
 
-
-/*
- * General case blend pixels.
- * Input:  n - number of pixels
- *         mask - the usual write mask
- * In/Out:  rgba - the incoming and modified pixels
- * Input:  dest - the pixels from the dest color buffer
- */
-static void _BLENDAPI
-blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[],
-               GLubyte rgba[][4], CONST GLubyte dest[][4] )
+void
+_mesa_LogicOp( GLenum opcode )
 {
-   GLfloat rscale = 1.0F / CHAN_MAXF;
-   GLfloat gscale = 1.0F / CHAN_MAXF;
-   GLfloat bscale = 1.0F / CHAN_MAXF;
-   GLfloat ascale = 1.0F / CHAN_MAXF;
-   GLuint i;
-
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         GLint Rs, Gs, Bs, As;  /* Source colors */
-         GLint Rd, Gd, Bd, Ad;  /* Dest colors */
-         GLfloat sR, sG, sB, sA;  /* Source scaling */
-         GLfloat dR, dG, dB, dA;  /* Dest scaling */
-         GLfloat r, g, b, a;
-
-         /* Source Color */
-         Rs = rgba[i][RCOMP];
-         Gs = rgba[i][GCOMP];
-         Bs = rgba[i][BCOMP];
-         As = rgba[i][ACOMP];
-
-         /* Frame buffer color */
-         Rd = dest[i][RCOMP];
-         Gd = dest[i][GCOMP];
-         Bd = dest[i][BCOMP];
-         Ad = dest[i][ACOMP];
-
-         /* Source RGB factor */
-         switch (ctx->Color.BlendSrcRGB) {
-            case GL_ZERO:
-               sR = sG = sB = 0.0F;
-               break;
-            case GL_ONE:
-               sR = sG = sB = 1.0F;
-               break;
-            case GL_DST_COLOR:
-               sR = (GLfloat) Rd * rscale;
-               sG = (GLfloat) Gd * gscale;
-               sB = (GLfloat) Bd * bscale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               sR = 1.0F - (GLfloat) Rd * rscale;
-               sG = 1.0F - (GLfloat) Gd * gscale;
-               sB = 1.0F - (GLfloat) Bd * bscale;
-               break;
-            case GL_SRC_ALPHA:
-               sR = sG = sB = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               sR = sG = sB = (GLfloat) 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               sR = sG = sB = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_SRC_ALPHA_SATURATE:
-               if (As < CHAN_MAX - Ad) {
-                  sR = sG = sB = (GLfloat) As * ascale;
-               }
-               else {
-                  sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
-               }
-               break;
-            case GL_CONSTANT_COLOR:
-               sR = ctx->Color.BlendColor[0];
-               sG = ctx->Color.BlendColor[1];
-               sB = ctx->Color.BlendColor[2];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               sR = 1.0F - ctx->Color.BlendColor[0];
-               sG = 1.0F - ctx->Color.BlendColor[1];
-               sB = 1.0F - ctx->Color.BlendColor[2];
-               break;
-            case GL_CONSTANT_ALPHA:
-               sR = sG = sB = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               sR = sG = sB = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_SRC_COLOR: /* GL_NV_blend_square */
-               sR = (GLfloat) Rs * rscale;
-               sG = (GLfloat) Gs * gscale;
-               sB = (GLfloat) Bs * bscale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
-               sR = 1.0F - (GLfloat) Rs * rscale;
-               sG = 1.0F - (GLfloat) Gs * gscale;
-               sB = 1.0F - (GLfloat) Bs * bscale;
-               break;
-            default:
-               /* this should never happen */
-               gl_problem(ctx, "Bad blend source RGB factor in do_blend");
-	       return;
-         }
-
-         /* Source Alpha factor */
-         switch (ctx->Color.BlendSrcA) {
-            case GL_ZERO:
-               sA = 0.0F;
-               break;
-            case GL_ONE:
-               sA = 1.0F;
-               break;
-            case GL_DST_COLOR:
-               sA = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR:
-               sA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_SRC_ALPHA:
-               sA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               sA = (GLfloat) 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               sA =(GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               sA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_SRC_ALPHA_SATURATE:
-               sA = 1.0;
-               break;
-            case GL_CONSTANT_COLOR:
-               sA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               sA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_CONSTANT_ALPHA:
-               sA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               sA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_SRC_COLOR: /* GL_NV_blend_square */
-               sA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
-               sA = 1.0F - (GLfloat) As * ascale;
-               break;
-            default:
-               /* this should never happen */
-               sA = 0.0F;
-               gl_problem(ctx, "Bad blend source A factor in do_blend");
-         }
-
-         /* Dest RGB factor */
-         switch (ctx->Color.BlendDstRGB) {
-            case GL_ZERO:
-               dR = dG = dB = 0.0F;
-               break;
-            case GL_ONE:
-               dR = dG = dB = 1.0F;
-               break;
-            case GL_SRC_COLOR:
-               dR = (GLfloat) Rs * rscale;
-               dG = (GLfloat) Gs * gscale;
-               dB = (GLfloat) Bs * bscale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               dR = 1.0F - (GLfloat) Rs * rscale;
-               dG = 1.0F - (GLfloat) Gs * gscale;
-               dB = 1.0F - (GLfloat) Bs * bscale;
-               break;
-            case GL_SRC_ALPHA:
-               dR = dG = dB = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               dR = dG = dB = (GLfloat) 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               dR = dG = dB = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               dR = dG = dB = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_CONSTANT_COLOR:
-               dR = ctx->Color.BlendColor[0];
-               dG = ctx->Color.BlendColor[1];
-               dB = ctx->Color.BlendColor[2];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               dR = 1.0F - ctx->Color.BlendColor[0];
-               dG = 1.0F - ctx->Color.BlendColor[1];
-               dB = 1.0F - ctx->Color.BlendColor[2];
-               break;
-            case GL_CONSTANT_ALPHA:
-               dR = dG = dB = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               dR = dG = dB = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_DST_COLOR: /* GL_NV_blend_square */
-               dR = (GLfloat) Rd * rscale;
-               dG = (GLfloat) Gd * gscale;
-               dB = (GLfloat) Bd * bscale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
-               dR = 1.0F - (GLfloat) Rd * rscale;
-               dG = 1.0F - (GLfloat) Gd * gscale;
-               dB = 1.0F - (GLfloat) Bd * bscale;
-               break;
-            default:
-               /* this should never happen */
-               dR = dG = dB = 0.0F;
-               gl_problem(ctx, "Bad blend dest RGB factor in do_blend");
-         }
-
-         /* Dest Alpha factor */
-         switch (ctx->Color.BlendDstA) {
-            case GL_ZERO:
-               dA = 0.0F;
-               break;
-            case GL_ONE:
-               dA = 1.0F;
-               break;
-            case GL_SRC_COLOR:
-               dA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_COLOR:
-               dA = 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_SRC_ALPHA:
-               dA = (GLfloat) As * ascale;
-               break;
-            case GL_ONE_MINUS_SRC_ALPHA:
-               dA = (GLfloat) 1.0F - (GLfloat) As * ascale;
-               break;
-            case GL_DST_ALPHA:
-               dA = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_ALPHA:
-               dA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            case GL_CONSTANT_COLOR:
-               dA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_COLOR:
-               dA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_CONSTANT_ALPHA:
-               dA = ctx->Color.BlendColor[3];
-               break;
-            case GL_ONE_MINUS_CONSTANT_ALPHA:
-               dA = 1.0F - ctx->Color.BlendColor[3];
-               break;
-            case GL_DST_COLOR: /* GL_NV_blend_square */
-               dA = (GLfloat) Ad * ascale;
-               break;
-            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
-               dA = 1.0F - (GLfloat) Ad * ascale;
-               break;
-            default:
-               /* this should never happen */
-               dA = 0.0F;
-               gl_problem(ctx, "Bad blend dest A factor in do_blend");
-	       return;
-         }
-
-         /* Due to round-off problems we have to clamp against zero. */
-         /* Optimization: we don't have to do this for all src & dst factors */
-         if (dA < 0.0F)  dA = 0.0F;
-         if (dR < 0.0F)  dR = 0.0F;
-         if (dG < 0.0F)  dG = 0.0F;
-         if (dB < 0.0F)  dB = 0.0F;
-         if (sA < 0.0F)  sA = 0.0F;
-         if (sR < 0.0F)  sR = 0.0F;
-         if (sG < 0.0F)  sG = 0.0F;
-         if (sB < 0.0F)  sB = 0.0F;
-
-         ASSERT( sR <= 1.0 );
-         ASSERT( sG <= 1.0 );
-         ASSERT( sB <= 1.0 );
-         ASSERT( sA <= 1.0 );
-         ASSERT( dR <= 1.0 );
-         ASSERT( dG <= 1.0 );
-         ASSERT( dB <= 1.0 );
-         ASSERT( dA <= 1.0 );
-
-         /* compute blended color */
-         if (ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-            r = Rs * sR + Rd * dR + 0.5F;
-            g = Gs * sG + Gd * dG + 0.5F;
-            b = Bs * sB + Bd * dB + 0.5F;
-            a = As * sA + Ad * dA + 0.5F;
-         }
-         else if (ctx->Color.BlendEquation==GL_FUNC_SUBTRACT_EXT) {
-            r = Rs * sR - Rd * dR + 0.5F;
-            g = Gs * sG - Gd * dG + 0.5F;
-            b = Bs * sB - Bd * dB + 0.5F;
-            a = As * sA - Ad * dA + 0.5F;
-         }
-         else if (ctx->Color.BlendEquation==GL_FUNC_REVERSE_SUBTRACT_EXT) {
-            r = Rd * dR - Rs * sR + 0.5F;
-            g = Gd * dG - Gs * sG + 0.5F;
-            b = Bd * dB - Bs * sB + 0.5F;
-            a = Ad * dA - As * sA + 0.5F;
-         }
-         else {
-            /* should never get here */
-            r = g = b = a = 0.0F;  /* silence uninitialized var warning */
-            gl_problem(ctx, "unexpected BlendEquation in blend_general()");
-         }
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-         /* final clamping */
-         rgba[i][RCOMP] = (GLubyte) (GLint) CLAMP( r, 0.0F, CHAN_MAXF );
-         rgba[i][GCOMP] = (GLubyte) (GLint) CLAMP( g, 0.0F, CHAN_MAXF );
-         rgba[i][BCOMP] = (GLubyte) (GLint) CLAMP( b, 0.0F, CHAN_MAXF );
-         rgba[i][ACOMP] = (GLubyte) (GLint) CLAMP( a, 0.0F, CHAN_MAXF );
-      }
+   switch (opcode) {
+      case GL_CLEAR:
+      case GL_SET:
+      case GL_COPY:
+      case GL_COPY_INVERTED:
+      case GL_NOOP:
+      case GL_INVERT:
+      case GL_AND:
+      case GL_NAND:
+      case GL_OR:
+      case GL_NOR:
+      case GL_XOR:
+      case GL_EQUIV:
+      case GL_AND_REVERSE:
+      case GL_AND_INVERTED:
+      case GL_OR_REVERSE:
+      case GL_OR_INVERTED:
+	 break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glLogicOp" );
+	 return;
    }
-}
-
-
 
-#if defined(USE_MMX_ASM)
-#include "X86/mmx.h"
-#include "X86/common_x86_asm.h"
-#endif
+   if (ctx->Color.LogicOp == opcode)
+      return;
 
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.LogicOp = opcode;
 
-/*
- * Analyze current blending parameters to pick fastest blending function.
- * Result: the ctx->Color.BlendFunc pointer is updated.
- */
-static void set_blend_function( GLcontext *ctx )
-{
-   const GLenum eq = ctx->Color.BlendEquation;
-   const GLenum srcRGB = ctx->Color.BlendSrcRGB;
-   const GLenum dstRGB = ctx->Color.BlendDstRGB;
-   const GLenum srcA = ctx->Color.BlendSrcA;
-   const GLenum dstA = ctx->Color.BlendDstA;
-
-#if defined(USE_MMX_ASM)
-   /* Hmm.  A table here would have 12^4 == way too many entries.
-    * Provide a hook for MMX instead.
-    */
-   if ( cpu_has_mmx ) {
-      gl_mmx_set_blend_function( ctx );
-   }
-   else
-#endif
-   if (srcRGB != srcA || dstRGB != dstA) {
-      ctx->Color.BlendFunc = blend_general;
-   }
-   else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_SRC_ALPHA
-       && dstRGB==GL_ONE_MINUS_SRC_ALPHA) {
-      ctx->Color.BlendFunc = blend_transparency;
-   }
-   else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_ONE && dstRGB==GL_ONE) {
-      ctx->Color.BlendFunc = blend_add;
-   }
-   else if (((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_REVERSE_SUBTRACT_EXT)
-             && (srcRGB==GL_ZERO && dstRGB==GL_SRC_COLOR))
-            ||
-            ((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_SUBTRACT_EXT)
-             && (srcRGB==GL_DST_COLOR && dstRGB==GL_ZERO))) {
-      ctx->Color.BlendFunc = blend_modulate;
-   }
-   else if (eq==GL_MIN_EXT) {
-      ctx->Color.BlendFunc = blend_min;
-   }
-   else if (eq==GL_MAX_EXT) {
-      ctx->Color.BlendFunc = blend_max;
-   }
-   else {
-      ctx->Color.BlendFunc = blend_general;
-   }
+   if (ctx->Driver.LogicOpcode)
+      ctx->Driver.LogicOpcode( ctx, opcode );
 }
 
 
-
-/*
- * Apply the blending operator to a span of pixels.
- * Input:  n - number of pixels in span
- *         x, y - location of leftmost pixel in span in window coords.
- *         mask - boolean mask indicating which pixels to blend.
- * In/Out:  rgba - pixel values
- */
 void
-_mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                  GLubyte rgba[][4], const GLubyte mask[] )
+_mesa_IndexMask( GLuint mask )
 {
-   GLubyte dest[MAX_WIDTH][4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   /* Check if device driver can do the work */
-   if (ctx->Color.BlendEquation==GL_LOGIC_OP && !ctx->Color.SWLogicOpEnabled) {
+   if (ctx->Color.IndexMask == mask)
       return;
-   }
-
-   /* Read span of current frame buffer pixels */
-   gl_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
 
-   if (!ctx->Color.BlendFunc)
-      set_blend_function(ctx);
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.IndexMask = mask;
 
-   (*ctx->Color.BlendFunc)( ctx, n, mask, rgba, (CONST GLubyte (*)[4])dest );
+   if (ctx->Driver.IndexMask)
+      ctx->Driver.IndexMask( ctx, mask );
 }
 
 
-
-
-
-/*
- * Apply the blending operator to an array of pixels.
- * Input:  n - number of pixels in span
- *         x, y - array of pixel locations
- *         mask - boolean mask indicating which pixels to blend.
- * In/Out:  rgba - pixel values
- */
 void
-_mesa_blend_pixels( GLcontext *ctx,
-                    GLuint n, const GLint x[], const GLint y[],
-                    GLubyte rgba[][4], const GLubyte mask[] )
+_mesa_ColorMask( GLboolean red, GLboolean green,
+                 GLboolean blue, GLboolean alpha )
 {
-   GLubyte dest[PB_SIZE][4];
+   GET_CURRENT_CONTEXT(ctx);
+   GLubyte tmp[4];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   /* Check if device driver can do the work */
-   if (ctx->Color.BlendEquation==GL_LOGIC_OP && !ctx->Color.SWLogicOpEnabled) {
-      return;
-   }
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glColorMask %d %d %d %d\n", red, green, blue, alpha);
 
-   /* Read pixels from current color buffer */
-   (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
-   if (ctx->RasterMask & ALPHABUF_BIT) {
-      _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
-   }
+   /* Shouldn't have any information about channel depth in core mesa
+    * -- should probably store these as the native booleans:
+    */
+   tmp[RCOMP] = red    ? 0xff : 0x0;
+   tmp[GCOMP] = green  ? 0xff : 0x0;
+   tmp[BCOMP] = blue   ? 0xff : 0x0;
+   tmp[ACOMP] = alpha  ? 0xff : 0x0;
+
+   if (TEST_EQ_4UBV(tmp, ctx->Color.ColorMask))
+      return;
 
-   if (!ctx->Color.BlendFunc)
-      set_blend_function(ctx);
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_4UBV(ctx->Color.ColorMask, tmp);
 
-   (*ctx->Color.BlendFunc)( ctx, n, mask, rgba, (CONST GLubyte (*)[4])dest );
+   if (ctx->Driver.ColorMask)
+      ctx->Driver.ColorMask( ctx, red, green, blue, alpha );
 }
Index: xc/extras/Mesa/src/blend.h
diff -u xc/extras/Mesa/src/blend.h:1.4 xc/extras/Mesa/src/blend.h:1.5
--- xc/extras/Mesa/src/blend.h:1.4	Thu Mar  2 11:07:01 2000
+++ xc/extras/Mesa/src/blend.h	Fri Feb 22 14:25:24 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,36 +28,40 @@
 #define BLEND_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
+extern void
+_mesa_BlendFunc( GLenum sfactor, GLenum dfactor );
 
+
 extern void
-_mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                  GLubyte rgba[][4], const GLubyte mask[] );
+_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,
+                            GLenum sfactorA, GLenum dfactorA );
 
 
 extern void
-_mesa_blend_pixels( GLcontext *ctx,
-                    GLuint n, const GLint x[], const GLint y[],
-                    GLubyte rgba[][4], const GLubyte mask[] );
+_mesa_BlendEquation( GLenum mode );
 
 
 extern void
-_mesa_BlendFunc( GLenum sfactor, GLenum dfactor );
+_mesa_BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
 
 
 extern void
-_mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,
-                            GLenum sfactorA, GLenum dfactorA );
+_mesa_AlphaFunc( GLenum func, GLclampf ref );
 
 
 extern void
-_mesa_BlendEquation( GLenum mode );
+_mesa_LogicOp( GLenum opcode );
 
 
 extern void
-_mesa_BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+_mesa_IndexMask( GLuint mask );
+
+extern void
+_mesa_ColorMask( GLboolean red, GLboolean green,
+                 GLboolean blue, GLboolean alpha );
 
 
 #endif
Index: xc/extras/Mesa/src/buffers.c
diff -u xc/extras/Mesa/src/buffers.c:1.7 xc/extras/Mesa/src/buffers.c:1.10
--- xc/extras/Mesa/src/buffers.c:1.7	Fri May 18 12:59:53 2001
+++ xc/extras/Mesa/src/buffers.c	Mon Sep  9 17:29:36 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -29,17 +29,16 @@
 #else
 #include "glheader.h"
 #include "accum.h"
-#include "alphabuf.h"
 #include "buffers.h"
+#include "colormac.h"
 #include "context.h"
 #include "depth.h"
 #include "enums.h"
 #include "macros.h"
-#include "masking.h"
 #include "mem.h"
 #include "stencil.h"
 #include "state.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -48,9 +47,15 @@
 _mesa_ClearIndex( GLfloat c )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClearIndex");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->Color.ClearIndex == (GLuint) c)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
    ctx->Color.ClearIndex = (GLuint) c;
-   if (!ctx->Visual->RGBAflag) {
+
+   if (!ctx->Visual.rgbMode && ctx->Driver.ClearIndex) {
       /* it's OK to call glClearIndex in RGBA mode but it should be a NOP */
       (*ctx->Driver.ClearIndex)( ctx, ctx->Color.ClearIndex );
    }
@@ -59,209 +64,50 @@
 
 
 void
-_mesa_ClearColor( GLclampf red, GLclampf green,
-                  GLclampf blue, GLclampf alpha )
+_mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
 {
+   GLchan tmp[4];
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClearColor");
-
-   ctx->Color.ClearColor[0] = CLAMP( red,   0.0F, 1.0F );
-   ctx->Color.ClearColor[1] = CLAMP( green, 0.0F, 1.0F );
-   ctx->Color.ClearColor[2] = CLAMP( blue,  0.0F, 1.0F );
-   ctx->Color.ClearColor[3] = CLAMP( alpha, 0.0F, 1.0F );
-
-   if (ctx->Visual->RGBAflag) {
-      GLubyte r = (GLint) (ctx->Color.ClearColor[0] * 255.0F);
-      GLubyte g = (GLint) (ctx->Color.ClearColor[1] * 255.0F);
-      GLubyte b = (GLint) (ctx->Color.ClearColor[2] * 255.0F);
-      GLubyte a = (GLint) (ctx->Color.ClearColor[3] * 255.0F);
-      (*ctx->Driver.ClearColor)( ctx, r, g, b, a );
-   }
-}
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[0], red);
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[1], green);
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[2], blue);
+   UNCLAMPED_FLOAT_TO_CHAN(tmp[3], alpha);
 
-
-
-/*
- * Clear the color buffer when glColorMask or glIndexMask is in effect.
- */
-static void
-clear_color_buffer_with_masking( GLcontext *ctx )
-{
-   const GLint x = ctx->DrawBuffer->Xmin;
-   const GLint y = ctx->DrawBuffer->Ymin;
-   const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
-   const GLint width  = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-
-   if (ctx->Visual->RGBAflag) {
-      /* RGBA mode */
-      const GLubyte r = (GLint) (ctx->Color.ClearColor[0] * 255.0F);
-      const GLubyte g = (GLint) (ctx->Color.ClearColor[1] * 255.0F);
-      const GLubyte b = (GLint) (ctx->Color.ClearColor[2] * 255.0F);
-      const GLubyte a = (GLint) (ctx->Color.ClearColor[3] * 255.0F);
-      GLint i;
-      for (i = 0; i < height; i++) {
-         GLubyte rgba[MAX_WIDTH][4];
-         GLint j;
-         for (j=0; j<width; j++) {
-            rgba[j][RCOMP] = r;
-            rgba[j][GCOMP] = g;
-            rgba[j][BCOMP] = b;
-            rgba[j][ACOMP] = a;
-         }
-         _mesa_mask_rgba_span( ctx, width, x, y + i, rgba );
-         (*ctx->Driver.WriteRGBASpan)( ctx, width, x, y + i,
-				       (CONST GLubyte (*)[4])rgba, NULL );
-      }
-   }
-   else {
-      /* Color index mode */
-      GLuint span[MAX_WIDTH];
-      GLubyte mask[MAX_WIDTH];
-      GLint i, j;
-      MEMSET( mask, 1, width );
-      for (i=0;i<height;i++) {
-         for (j=0;j<width;j++) {
-            span[j] = ctx->Color.ClearIndex;
-         }
-         _mesa_mask_index_span( ctx, width, x, y + i, span );
-         (*ctx->Driver.WriteCI32Span)( ctx, width, x, y + i, span, mask );
-      }
-   }
-}
-
-
-
-/*
- * Clear a color buffer without index/channel masking.
- */
-static void
-clear_color_buffer(GLcontext *ctx)
-{
-   const GLint x = ctx->DrawBuffer->Xmin;
-   const GLint y = ctx->DrawBuffer->Ymin;
-   const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
-   const GLint width  = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-
-   if (ctx->Visual->RGBAflag) {
-      /* RGBA mode */
-      const GLubyte r = (GLint) (ctx->Color.ClearColor[0] * 255.0F);
-      const GLubyte g = (GLint) (ctx->Color.ClearColor[1] * 255.0F);
-      const GLubyte b = (GLint) (ctx->Color.ClearColor[2] * 255.0F);
-      const GLubyte a = (GLint) (ctx->Color.ClearColor[3] * 255.0F);
-      GLubyte span[MAX_WIDTH][4];
-      GLint i;
-
-      ASSERT(!ctx->Color.SWmasking);
-
-      for (i = 0; i < width; i++) {
-         span[i][RCOMP] = r;
-         span[i][GCOMP] = g;
-         span[i][BCOMP] = b;
-         span[i][ACOMP] = a;
-      }
-      for (i = 0; i < height; i++) {
-         (*ctx->Driver.WriteRGBASpan)( ctx, width, x, y + i,
-                                       (CONST GLubyte (*)[4]) span, NULL );
-      }
-   }
-   else {
-      /* Color index mode */
-      ASSERT(ctx->Color.IndexMask == ((1 << ctx->Visual->IndexBits) - 1));
-      if (ctx->Visual->IndexBits == 8) {
-         /* 8-bit clear */
-         GLubyte span[MAX_WIDTH];
-         GLint i;
-         MEMSET(span, ctx->Color.ClearIndex, width);
-         for (i = 0; i < height; i++) {
-            (*ctx->Driver.WriteCI8Span)( ctx, width, x, y + i, span, NULL );
-         }
-      }
-      else {
-         /* non 8-bit clear */
-         GLuint span[MAX_WIDTH];
-         GLint i;
-         for (i = 0; i < width; i++) {
-            span[i] = ctx->Color.ClearIndex;
-         }
-         for (i = 0; i < height; i++) {
-            (*ctx->Driver.WriteCI32Span)( ctx, width, x, y + i, span, NULL );
-         }
-      }
-   }
-}
-
-
+   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
+      return;
 
-/*
- * Clear the front/back/left/right color buffers.
- * This function is usually only called if we need to clear the
- * buffers with masking.
- */
-static void
-clear_color_buffers(GLcontext *ctx)
-{
-   GLuint bufferBit;
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_CHAN4(ctx->Color.ClearColor, tmp);
 
-   /* loop over four possible dest color buffers */
-   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
-      if (bufferBit & ctx->Color.DrawDestMask) {
-         if (bufferBit == FRONT_LEFT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
-            (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_LEFT);
-         }
-         else if (bufferBit == FRONT_RIGHT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
-            (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_RIGHT);
-         }
-         else if (bufferBit == BACK_LEFT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
-            (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_LEFT);
-         }
-         else {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
-            (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_RIGHT);
-         }
-         
-         if (ctx->Color.SWmasking) {
-            clear_color_buffer_with_masking(ctx);
-         }
-         else {
-            clear_color_buffer(ctx);
-         }
-      }
+   if (ctx->Visual.rgbMode && ctx->Driver.ClearColor) {
+      /* it's OK to call glClearColor in CI mode but it should be a NOP */
+      (*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);
    }
-
-   /* restore default read/draw buffers */
-   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
-   (void) (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer );
 }
 
 
 
-void 
+void
 _mesa_Clear( GLbitfield mask )
 {
    GET_CURRENT_CONTEXT(ctx);
-#ifdef PROFILE
-   GLdouble t0 = gl_time();
-#endif
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClear");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (MESA_VERBOSE & VERBOSE_API)
       fprintf(stderr, "glClear 0x%x\n", mask);
 
    if (ctx->NewState) {
-      gl_update_state( ctx );
+      _mesa_update_state( ctx );	/* update _Xmin, etc */
    }
 
    if (ctx->RenderMode==GL_RENDER) {
-      const GLint x = ctx->DrawBuffer->Xmin;
-      const GLint y = ctx->DrawBuffer->Ymin;
-      const GLint height = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
-      const GLint width  = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
+      const GLint x = ctx->DrawBuffer->_Xmin;
+      const GLint y = ctx->DrawBuffer->_Ymin;
+      const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+      const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
       GLbitfield ddMask;
-      GLbitfield newMask;
 
       /* don't clear depth buffer if depth writing disabled */
       if (!ctx->Depth.Mask)
@@ -276,45 +122,8 @@
       }
 
       ASSERT(ctx->Driver.Clear);
-      newMask = (*ctx->Driver.Clear)( ctx, ddMask, !ctx->Scissor.Enabled,
-                                      x, y, width, height );
-
-#ifdef DEBUG
-      {
-         GLbitfield legalBits = DD_FRONT_LEFT_BIT |
-                                DD_FRONT_RIGHT_BIT |
-                                DD_BACK_LEFT_BIT |
-                                DD_BACK_RIGHT_BIT |
-                                DD_DEPTH_BIT |
-                                DD_STENCIL_BIT |
-                                DD_ACCUM_BIT;
-         assert((newMask & (~legalBits)) == 0);
-      }
-#endif
-
-      RENDER_START(ctx);
-
-      /* do software clearing here */
-      if (newMask) {
-         if (newMask & ctx->Color.DrawDestMask)   clear_color_buffers(ctx);
-         if (newMask & GL_DEPTH_BUFFER_BIT)    _mesa_clear_depth_buffer(ctx);
-         if (newMask & GL_ACCUM_BUFFER_BIT)    _mesa_clear_accum_buffer(ctx);
-         if (newMask & GL_STENCIL_BUFFER_BIT)  _mesa_clear_stencil_buffer(ctx);
-      }
-
-      /* clear software-based alpha buffer(s) */
-      if ( (mask & GL_COLOR_BUFFER_BIT)
-           && ctx->DrawBuffer->UseSoftwareAlphaBuffers
-           && ctx->Color.ColorMask[ACOMP]) {
-         _mesa_clear_alpha_buffers( ctx );
-      }
-
-      RENDER_FINISH(ctx);
-
-#ifdef PROFILE
-      ctx->ClearTime += gl_time() - t0;
-      ctx->ClearCount++;
-#endif
+      ctx->Driver.Clear( ctx, ddMask, (GLboolean) !ctx->Scissor.Enabled,
+			 x, y, width, height );
    }
 }
 
@@ -323,10 +132,11 @@
 _mesa_DrawBuffer( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDrawBuffer");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex... */
+
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glDrawBuffer %s\n", gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glDrawBuffer %s\n", _mesa_lookup_enum_by_nr(mode));
 
    switch (mode) {
       case GL_AUX0:
@@ -334,67 +144,66 @@
       case GL_AUX2:
       case GL_AUX3:
          /* AUX buffers not implemented in Mesa at this time */
-         gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+         _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
          return;
       case GL_RIGHT:
-         if (!ctx->Visual->StereoFlag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
-            return;
-         }
-         if (ctx->Visual->DBflag)
+         if (!ctx->Visual.stereoMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+            return;}
+         if (ctx->Visual.doubleBufferMode)
             ctx->Color.DrawDestMask = FRONT_RIGHT_BIT | BACK_RIGHT_BIT;
          else
             ctx->Color.DrawDestMask = FRONT_RIGHT_BIT;
          break;
       case GL_FRONT_RIGHT:
-         if (!ctx->Visual->StereoFlag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+         if (!ctx->Visual.stereoMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
             return;
          }
          ctx->Color.DrawDestMask = FRONT_RIGHT_BIT;
          break;
       case GL_BACK_RIGHT:
-         if (!ctx->Visual->StereoFlag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+         if (!ctx->Visual.stereoMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
             return;
          }
-         if (!ctx->Visual->DBflag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+         if (!ctx->Visual.doubleBufferMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
             return;
          }
          ctx->Color.DrawDestMask = BACK_RIGHT_BIT;
          break;
       case GL_BACK_LEFT:
-         if (!ctx->Visual->DBflag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+         if (!ctx->Visual.doubleBufferMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
             return;
          }
          ctx->Color.DrawDestMask = BACK_LEFT_BIT;
          break;
       case GL_FRONT_AND_BACK:
-         if (!ctx->Visual->DBflag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+         if (!ctx->Visual.doubleBufferMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
             return;
          }
-         if (ctx->Visual->StereoFlag)
+         if (ctx->Visual.stereoMode)
             ctx->Color.DrawDestMask = FRONT_LEFT_BIT | BACK_LEFT_BIT
                                     | FRONT_RIGHT_BIT | BACK_RIGHT_BIT;
          else
             ctx->Color.DrawDestMask = FRONT_LEFT_BIT | BACK_LEFT_BIT;
          break;
       case GL_BACK:
-         if (!ctx->Visual->DBflag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
+         if (!ctx->Visual.doubleBufferMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawBuffer" );
             return;
          }
-         if (ctx->Visual->StereoFlag)
+         if (ctx->Visual.stereoMode)
             ctx->Color.DrawDestMask = BACK_LEFT_BIT | BACK_RIGHT_BIT;
          else
             ctx->Color.DrawDestMask = BACK_LEFT_BIT;
          break;
       case GL_LEFT:
          /* never an error */
-         if (ctx->Visual->DBflag)
+         if (ctx->Visual.doubleBufferMode)
             ctx->Color.DrawDestMask = FRONT_LEFT_BIT | BACK_LEFT_BIT;
          else
             ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
@@ -405,7 +214,7 @@
          break;
       case GL_FRONT:
          /* never an error */
-         if (ctx->Visual->StereoFlag)
+         if (ctx->Visual.stereoMode)
             ctx->Color.DrawDestMask = FRONT_LEFT_BIT | FRONT_RIGHT_BIT;
          else
             ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
@@ -415,20 +224,20 @@
          ctx->Color.DrawDestMask = 0;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glDrawBuffer" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glDrawBuffer" );
          return;
    }
 
    /*
     * Make the dest buffer mode more precise if possible
     */
-   if (mode == GL_LEFT && !ctx->Visual->DBflag)
+   if (mode == GL_LEFT && !ctx->Visual.doubleBufferMode)
       ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
-   else if (mode == GL_RIGHT && !ctx->Visual->DBflag)
+   else if (mode == GL_RIGHT && !ctx->Visual.doubleBufferMode)
       ctx->Color.DriverDrawBuffer = GL_FRONT_RIGHT;
-   else if (mode == GL_FRONT && !ctx->Visual->StereoFlag)
+   else if (mode == GL_FRONT && !ctx->Visual.stereoMode)
       ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
-   else if (mode == GL_BACK && !ctx->Visual->StereoFlag)
+   else if (mode == GL_BACK && !ctx->Visual.stereoMode)
       ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
    else
       ctx->Color.DriverDrawBuffer = mode;
@@ -448,26 +257,14 @@
    }
 
    /*
-    * If we get here there can't have been an error.
-    * Now see if device driver can implement the drawing to the target
-    * buffer(s).  The driver may not be able to do GL_FRONT_AND_BACK mode
-    * for example.  We'll take care of that in the core code by looping
-    * over the individual buffers.
+    * If we get here there can't have been an error.  Now tell the
+    * device driver about it.  
     */
    ASSERT(ctx->Driver.SetDrawBuffer);
-   if ( (*ctx->Driver.SetDrawBuffer)(ctx, ctx->Color.DriverDrawBuffer) ) {
-      /* All OK, the driver will do all buffer writes */
-      ctx->Color.MultiDrawBuffer = GL_FALSE;
-   }
-   else {
-      /* We'll have to loop over the multiple draw buffer targets */
-      ctx->Color.MultiDrawBuffer = GL_TRUE;
-      /* Set drawing buffer to front for now */
-      (void) (*ctx->Driver.SetDrawBuffer)(ctx, GL_FRONT_LEFT);
-   }
+   (*ctx->Driver.SetDrawBuffer)(ctx, ctx->Color.DriverDrawBuffer);
 
    ctx->Color.DrawBuffer = mode;
-   ctx->NewState |= NEW_RASTER_OPS;
+   ctx->NewState |= _NEW_COLOR;
 }
 
 
@@ -476,10 +273,10 @@
 _mesa_ReadBuffer( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glReadBuffer");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glReadBuffer %s\n", gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glReadBuffer %s\n", _mesa_lookup_enum_by_nr(mode));
 
    switch (mode) {
       case GL_AUX0:
@@ -487,7 +284,7 @@
       case GL_AUX2:
       case GL_AUX3:
          /* AUX buffers not implemented in Mesa at this time */
-         gl_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
+         _mesa_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
          return;
       case GL_LEFT:
       case GL_FRONT:
@@ -498,75 +295,140 @@
       case GL_BACK:
       case GL_BACK_LEFT:
          /* Back-Left buffer, requires double buffering */
-         if (!ctx->Visual->DBflag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
+         if (!ctx->Visual.doubleBufferMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
             return;
          }
          ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT;
          break;
       case GL_FRONT_RIGHT:
       case GL_RIGHT:
-         if (!ctx->Visual->StereoFlag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
+         if (!ctx->Visual.stereoMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
             return;
          }
          ctx->Pixel.DriverReadBuffer = GL_FRONT_RIGHT;
          break;
       case GL_BACK_RIGHT:
-         if (!ctx->Visual->StereoFlag || !ctx->Visual->DBflag) {
-            gl_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
+         if (!ctx->Visual.stereoMode || !ctx->Visual.doubleBufferMode) {
+            _mesa_error( ctx, GL_INVALID_OPERATION, "glReadBuffer" );
             return;
          }
          ctx->Pixel.DriverReadBuffer = GL_BACK_RIGHT;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glReadBuffer" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glReadBuffer" );
          return;
    }
 
    ctx->Pixel.ReadBuffer = mode;
-   ctx->NewState |= NEW_RASTER_OPS;
+   ctx->NewState |= _NEW_PIXEL;
 }
 
 
 /*
  * GL_MESA_resize_buffers extension
+ * When this function is called, we'll ask the window system how large
+ * the current window is.  If it's not what we expect, we'll have to
+ * resize/reallocate the software accum/stencil/depth/alpha buffers.
  */
 void
 _mesa_ResizeBuffersMESA( void )
 {
-   GLcontext *ctx = gl_get_current_context();
-
-   GLuint buf_width, buf_height;
+   GLcontext *ctx = _mesa_get_current_context();
 
    if (MESA_VERBOSE & VERBOSE_API)
       fprintf(stderr, "glResizeBuffersMESA\n");
 
-   /* ask device driver for size of output buffer */
-   (*ctx->Driver.GetBufferSize)( ctx, &buf_width, &buf_height );
+   if (ctx) {
+      ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );
 
-   /* see if size of device driver's color buffer (window) has changed */
-   if (ctx->DrawBuffer->Width == (GLint) buf_width &&
-       ctx->DrawBuffer->Height == (GLint) buf_height)
-      return;
+      if (ctx->DrawBuffer) {
+         GLuint buf_width, buf_height;
+         GLframebuffer *buffer = ctx->DrawBuffer;
 
-   ctx->NewState |= NEW_RASTER_OPS;  /* to update scissor / window bounds */
+         /* ask device driver for size of output buffer */
+         (*ctx->Driver.GetBufferSize)( buffer, &buf_width, &buf_height );
 
-   /* save buffer size */
-   ctx->DrawBuffer->Width = buf_width;
-   ctx->DrawBuffer->Height = buf_height;
-
-   /* Reallocate other buffers if needed. */
-   if (ctx->DrawBuffer->UseSoftwareDepthBuffer) {
-      _mesa_alloc_depth_buffer( ctx );
-   }
-   if (ctx->DrawBuffer->UseSoftwareStencilBuffer) {
-      _mesa_alloc_stencil_buffer( ctx );
+         /* see if size of device driver's color buffer (window) has changed */
+         if (buffer->Width == buf_width && buffer->Height == buf_height)
+            return; /* size is as expected */
+
+         buffer->Width = buf_width;
+         buffer->Height = buf_height;
+
+         ctx->Driver.ResizeBuffers( buffer );
+      }
+
+      if (ctx->ReadBuffer && ctx->ReadBuffer != ctx->DrawBuffer) {
+         GLuint buf_width, buf_height;
+         GLframebuffer *buffer = ctx->DrawBuffer;
+
+         /* ask device driver for size of output buffer */
+         (*ctx->Driver.GetBufferSize)( buffer, &buf_width, &buf_height );
+
+         /* see if size of device driver's color buffer (window) has changed */
+         if (buffer->Width == buf_width && buffer->Height == buf_height)
+            return; /* size is as expected */
+
+         buffer->Width = buf_width;
+         buffer->Height = buf_height;
+
+         ctx->Driver.ResizeBuffers( buffer );
+      }
+
+      ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */
    }
-   if (ctx->DrawBuffer->UseSoftwareAccumBuffer) {
-      _mesa_alloc_accum_buffer( ctx );
+}
+
+
+void
+_mesa_Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (width < 0 || height < 0) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glScissor" );
+      return;
    }
-   if (ctx->DrawBuffer->UseSoftwareAlphaBuffers) {
-      _mesa_alloc_alpha_buffers( ctx );
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glScissor %d %d %d %d\n", x, y, width, height);
+
+   if (x == ctx->Scissor.X &&
+       y == ctx->Scissor.Y &&
+       width == ctx->Scissor.Width &&
+       height == ctx->Scissor.Height)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_SCISSOR);
+   ctx->Scissor.X = x;
+   ctx->Scissor.Y = y;
+   ctx->Scissor.Width = width;
+   ctx->Scissor.Height = height;
+
+   if (ctx->Driver.Scissor)
+      ctx->Driver.Scissor( ctx, x, y, width, height );
+}
+
+
+/*
+ * XXX move somewhere else someday?
+ */
+void
+_mesa_SampleCoverageARB(GLclampf value, GLboolean invert)
+{
+   GLcontext *ctx = _mesa_get_current_context();
+
+   if (!ctx->Extensions.ARB_multisample) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glSampleCoverageARB");
+      return;
    }
+
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );
+   ctx->Multisample.SampleCoverageValue = (GLfloat) CLAMP(value, 0.0, 1.0);
+   ctx->Multisample.SampleCoverageInvert = invert;
+   ctx->NewState |= _NEW_MULTISAMPLE;
 }
+			   
Index: xc/extras/Mesa/src/buffers.h
diff -u xc/extras/Mesa/src/buffers.h:1.1 xc/extras/Mesa/src/buffers.h:1.2
--- xc/extras/Mesa/src/buffers.h:1.1	Tue Feb 15 09:50:51 2000
+++ xc/extras/Mesa/src/buffers.h	Fri Feb 22 14:25:24 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define BUFFERS_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
@@ -49,6 +49,12 @@
 
 extern void
 _mesa_ResizeBuffersMESA( void );
+
+extern void
+_mesa_Scissor( GLint x, GLint y, GLsizei width, GLsizei height );
+
+extern void
+_mesa_SampleCoverageARB(GLclampf value, GLboolean invert);
 
 
 #endif
Index: xc/extras/Mesa/src/clip.c
diff -u xc/extras/Mesa/src/clip.c:1.5 xc/extras/Mesa/src/clip.c:1.6
--- xc/extras/Mesa/src/clip.c:1.5	Tue Mar 20 21:48:45 2001
+++ xc/extras/Mesa/src/clip.c	Fri Feb 22 14:25:24 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4.1
- * 
+ * Version:  3.5
+ *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -31,131 +31,12 @@
 #include "clip.h"
 #include "context.h"
 #include "macros.h"
-#include "matrix.h"
 #include "mmath.h"
-#include "types.h"
-#include "vb.h"
-#include "xform.h"
-#endif
-
-
-
-
-#define CLIP_RGBA0    0x1
-#define CLIP_RGBA1    0x2
-#define CLIP_TEX0     0x4
-#define CLIP_TEX1     0x8
-#define CLIP_INDEX0   0x10
-#define CLIP_INDEX1   0x20
-#define CLIP_FOG_COORD 0x40
-
-
-/* Linear interpolation between A and B: */
-#define LINTERP( T, A, B )   ( (A) + (T) * ( (B) - (A) ) )
-
-
-
-#define INTERP_SZ( t, vec, to, a, b, sz )			\
-do {								\
-   switch (sz) {						\
-   case 4: vec[to][3] = LINTERP( t, vec[a][3], vec[b][3] );	\
-   case 3: vec[to][2] = LINTERP( t, vec[a][2], vec[b][2] );	\
-   case 2: vec[to][1] = LINTERP( t, vec[a][1], vec[b][1] );	\
-   case 1: vec[to][0] = LINTERP( t, vec[a][0], vec[b][0] );	\
-   }								\
-} while(0)
-   
-
-static clip_interp_func clip_interp_tab[0x80]; 
-
-#define IND 0
-#define NAME clip_nil
-#include "interp_tmp.h"
-
-#define IND (CLIP_RGBA0)
-#define NAME clipRGBA0
-#include "interp_tmp.h"
-
-#define IND (CLIP_RGBA0|CLIP_RGBA1)
-#define NAME clipRGBA0_RGBA1
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX0|CLIP_RGBA0)
-#define NAME clipTEX0_RGBA0
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1)
-#define NAME clipTEX0_RGBA0_RGBA1
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0)
-#define NAME clipTEX1_TEX0_RGBA0
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX0)
-#define NAME clipTEX0
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX1|CLIP_TEX0)
-#define NAME clipTEX1_TEX0
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1)
-#define NAME clipTEX1_TEX0_RGBA0_RGBA1
-#include "interp_tmp.h"
-
-#define IND (CLIP_INDEX0)
-#define NAME clipINDEX0
-#include "interp_tmp.h"
-
-#define IND (CLIP_INDEX0|CLIP_INDEX1)
-#define NAME clipINDEX0_INDEX1
-#include "interp_tmp.h"
-
-#define IND (CLIP_FOG_COORD)
-#define NAME clip_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_RGBA0|CLIP_FOG_COORD)
-#define NAME clipRGBA0_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_RGBA0|CLIP_RGBA1|CLIP_FOG_COORD)
-#define NAME clipRGBA0_RGBA1_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX0|CLIP_RGBA0|CLIP_FOG_COORD)
-#define NAME clipTEX0_RGBA0_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1|CLIP_FOG_COORD)
-#define NAME clipTEX0_RGBA0_RGBA1_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0|CLIP_FOG_COORD)
-#define NAME clipTEX1_TEX0_RGBA0_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX0|CLIP_FOG_COORD)
-#define NAME clipTEX0_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX1|CLIP_TEX0|CLIP_FOG_COORD)
-#define NAME clipTEX1_TEX0_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1|CLIP_FOG_COORD)
-#define NAME clipTEX1_TEX0_RGBA0_RGBA1_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_INDEX0|CLIP_FOG_COORD)
-#define NAME clipINDEX0_FOG
-#include "interp_tmp.h"
-
-#define IND (CLIP_INDEX0|CLIP_INDEX1|CLIP_FOG_COORD)
-#define NAME clipINDEX0_INDEX1_FOG
-#include "interp_tmp.h"
+#include "mtypes.h"
 
+#include "math/m_xform.h"
+#include "math/m_matrix.h"
+#endif
 
 
 
@@ -171,20 +52,19 @@
    GET_CURRENT_CONTEXT(ctx);
    GLint p;
    GLfloat equation[4];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   equation[0] = eq[0];
-   equation[1] = eq[1];
-   equation[2] = eq[2];
-   equation[3] = eq[3];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClipPlane");
-
    p = (GLint) plane - (GLint) GL_CLIP_PLANE0;
-   if (p<0 || p>=MAX_CLIP_PLANES) {
-      gl_error( ctx, GL_INVALID_ENUM, "glClipPlane" );
+   if (p < 0 || p >= (GLint) ctx->Const.MaxClipPlanes) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glClipPlane" );
       return;
    }
 
+   equation[0] = (GLfloat) eq[0];
+   equation[1] = (GLfloat) eq[1];
+   equation[2] = (GLfloat) eq[2];
+   equation[3] = (GLfloat) eq[3];
+
    /*
     * The equation is transformed by the transpose of the inverse of the
     * current modelview matrix and stored in the resulting eye coordinates.
@@ -193,51 +73,45 @@
     * clipping now takes place.  The clip-space equations are recalculated
     * whenever the projection matrix changes.
     */
-   if (ctx->ModelView.flags & MAT_DIRTY_ALL_OVER) {
-      gl_matrix_analyze( &ctx->ModelView );
-   }
-   gl_transform_vector( ctx->Transform.EyeUserPlane[p], equation,
-		        ctx->ModelView.inv );
+   if (ctx->ModelView.flags & MAT_DIRTY)
+      _math_matrix_analyse( &ctx->ModelView );
+
+   _mesa_transform_vector( equation, equation, ctx->ModelView.inv );
 
+   if (TEST_EQ_4V(ctx->Transform.EyeUserPlane[p], equation))
+      return;
 
+   FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+   COPY_4FV(ctx->Transform.EyeUserPlane[p], equation);
+
+   /* Update derived state.  This state also depends on the projection
+    * matrix, and is recalculated on changes to the projection matrix by
+    * code in _mesa_update_state().
+    */
    if (ctx->Transform.ClipEnabled[p]) {
-      ctx->NewState |= NEW_USER_CLIP;
+      if (ctx->ProjectionMatrix.flags & MAT_DIRTY)
+	 _math_matrix_analyse( &ctx->ProjectionMatrix );
 
-      if (ctx->ProjectionMatrix.flags & MAT_DIRTY_ALL_OVER) {
-	 gl_matrix_analyze( &ctx->ProjectionMatrix );
-      }
-      gl_transform_vector( ctx->Transform.ClipUserPlane[p], 
-			   ctx->Transform.EyeUserPlane[p], 
+      _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
+			   ctx->Transform.EyeUserPlane[p],
 			   ctx->ProjectionMatrix.inv );
    }
-}
-
 
-void gl_update_userclip( GLcontext *ctx )
-{
-   GLuint p;
-   
-   for (p = 0 ; p < MAX_CLIP_PLANES ; p++) {
-      if (ctx->Transform.ClipEnabled[p]) {
-	 gl_transform_vector( ctx->Transform.ClipUserPlane[p],
-			      ctx->Transform.EyeUserPlane[p],
-			      ctx->ProjectionMatrix.inv );
-      }
-   }
+   if (ctx->Driver.ClipPlane)
+      ctx->Driver.ClipPlane( ctx, plane, equation );
 }
 
+
 void
 _mesa_GetClipPlane( GLenum plane, GLdouble *equation )
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint p;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetClipPlane");
-
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    p = (GLint) (plane - GL_CLIP_PLANE0);
-   if (p<0 || p>=MAX_CLIP_PLANES) {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetClipPlane" );
+   if (p < 0 || p >= (GLint) ctx->Const.MaxClipPlanes) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetClipPlane" );
       return;
    }
 
@@ -246,262 +120,3 @@
    equation[2] = (GLdouble) ctx->Transform.EyeUserPlane[p][2];
    equation[3] = (GLdouble) ctx->Transform.EyeUserPlane[p][3];
 }
-
-
-
-
-/**********************************************************************/
-/*                         View volume clipping.                      */
-/**********************************************************************/
-
-
-/*
- * Clip a point against the view volume.
- * Input:  v - vertex-vector describing the point to clip
- * Return:  0 = outside view volume
- *          1 = inside view volume
- */
-GLuint gl_viewclip_point( const GLfloat v[] )
-{
-   if (   v[0] > v[3] || v[0] < -v[3]
-       || v[1] > v[3] || v[1] < -v[3]
-       || v[2] > v[3] || v[2] < -v[3] ) {
-      return 0;
-   }
-   else {
-      return 1;
-   }
-}
-
-/*
- * Clip a point against the user clipping planes.
- * Input:  v - vertex-vector describing the point to clip.
- * Return:  0 = point was clipped
- *          1 = point not clipped
- */
-GLuint gl_userclip_point( GLcontext* ctx, const GLfloat v[] )
-{
-   GLuint p;
-
-   for (p=0;p<MAX_CLIP_PLANES;p++) {
-      if (ctx->Transform.ClipEnabled[p]) {
-	 GLfloat dot = v[0] * ctx->Transform.ClipUserPlane[p][0]
-		     + v[1] * ctx->Transform.ClipUserPlane[p][1]
-		     + v[2] * ctx->Transform.ClipUserPlane[p][2]
-		     + v[3] * ctx->Transform.ClipUserPlane[p][3];
-         if (dot < 0.0F) {
-            return 0;
-         }
-      }
-   }
-
-   return 1;
-}
-
-
-
-#define NEGATIVE(x) ((x) < 0.0)
-#define DIFFERENT_SIGNS(a, b) (((a) * (b)) <= 0.0 && ((a) != (b)))
-
-
-static clip_poly_func gl_poly_clip_tab[2][5];
-static clip_line_func gl_line_clip_tab[2][5];
-
-#define W(i) coord[i][3]
-#define Z(i) coord[i][2]
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 4
-#define IND 0
-#define TAG(x) x##_4
-#include "clip_funcs.h"
-
-#define W(i) 1.0
-#define Z(i) coord[i][2]
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 3
-#define IND 0
-#define TAG(x) x##_3
-#include "clip_funcs.h"
-
-#define W(i) 1.0
-#define Z(i) 0.0
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 2
-#define IND 0
-#define TAG(x) x##_2
-#include "clip_funcs.h"
-
-#define W(i) coord[i][3]
-#define Z(i) coord[i][2]
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 4
-#define IND CLIP_TAB_EDGEFLAG
-#define TAG(x) x##_4_edgeflag
-#include "clip_funcs.h"
-
-#define W(i) 1.0
-#define Z(i) coord[i][2]
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 3
-#define IND CLIP_TAB_EDGEFLAG
-#define TAG(x) x##_3_edgeflag
-#include "clip_funcs.h"
-
-#define W(i) 1.0
-#define Z(i) 0.0
-#define Y(i) coord[i][1]
-#define X(i) coord[i][0]
-#define SIZE 2
-#define IND CLIP_TAB_EDGEFLAG
-#define TAG(x) x##_2_edgeflag
-#include "clip_funcs.h"
-
-
-
-
-void gl_update_clipmask( GLcontext *ctx )
-{
-   GLuint mask = 0;
-
-   if (ctx->Visual->RGBAflag) 
-   {
-      mask |= CLIP_RGBA0;
-      
-      if (ctx->TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_SEPERATE_SPECULAR))
-         mask |= CLIP_RGBA1;
-
-      if (ctx->Texture.ReallyEnabled & 0xf0)
-	 mask |= CLIP_TEX1|CLIP_TEX0;
-
-      if (ctx->Texture.ReallyEnabled & 0xf)
-	 mask |= CLIP_TEX0;
-   }
-   else if (ctx->Light.ShadeModel==GL_SMOOTH) 
-   {
-      mask |= CLIP_INDEX0;
-      
-      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) 
-	 mask |= CLIP_INDEX1;
-   }
-
-   if (ctx->FogMode == FOG_FRAGMENT && (ctx->TriangleCaps & DD_CLIP_FOG_COORD))
-      mask |= CLIP_FOG_COORD;
-   
-   ctx->ClipInterpFunc = clip_interp_tab[mask];
-   ctx->poly_clip_tab = gl_poly_clip_tab[0];
-   ctx->line_clip_tab = gl_line_clip_tab[0];
-
-   if (ctx->TriangleCaps & DD_TRI_UNFILLED) {
-      ctx->poly_clip_tab = gl_poly_clip_tab[1];
-      ctx->line_clip_tab = gl_line_clip_tab[0];
-   } 
-}
-
-
-#define USER_CLIPTEST(NAME, SZ)						\
-static void NAME( struct vertex_buffer *VB )				\
-{									\
-   GLcontext *ctx = VB->ctx;						\
-   GLubyte *clipMask = VB->ClipMask;					\
-   GLubyte *userClipMask = VB->UserClipMask;				\
-   GLuint start = VB->Start;						\
-   GLuint count = VB->Count;						\
-   GLuint p, i;								\
-   GLubyte bit;								\
-									\
-									\
-   for (bit = 1, p = 0; p < MAX_CLIP_PLANES ; p++, bit *=2)		\
-      if (ctx->Transform.ClipEnabled[p]) {				\
-	 GLuint nr = 0;							\
-	 const GLfloat a = ctx->Transform.ClipUserPlane[p][0];		\
-	 const GLfloat b = ctx->Transform.ClipUserPlane[p][1];		\
-	 const GLfloat c = ctx->Transform.ClipUserPlane[p][2];		\
-	 const GLfloat d = ctx->Transform.ClipUserPlane[p][3];		\
-         GLfloat *coord = VB->ClipPtr->start;				\
-         GLuint stride = VB->ClipPtr->stride;				\
-									\
-	 for (i = start ; i < count ; i++, STRIDE_F(coord, stride)) {	\
-	    GLfloat dp = coord[0] * a + coord[1] * b;			\
-	    if (SZ > 2) dp += coord[2] * c;				\
-	    if (SZ > 3) dp += coord[3] * d; else dp += d;		\
-									\
-	    if (dp < 0) {						\
-	       clipMask[i] |= CLIP_USER_BIT;				\
-	       userClipMask[i] |= bit;					\
-	       nr++;							\
-	    }								\
-	 }								\
-									\
-	 if (nr > 0) {							\
-	    VB->ClipOrMask |= CLIP_USER_BIT;				\
-	    VB->CullMode |= CLIP_MASK_ACTIVE;				\
-	    if (nr == count - start) {					\
-	       VB->ClipAndMask |= CLIP_USER_BIT;			\
-	       VB->Culled = 1;						\
-	       return;							\
-	    }								\
-	 }								\
-      }									\
-}
-
-
-USER_CLIPTEST(userclip2, 2)		       
-USER_CLIPTEST(userclip3, 3)		       
-USER_CLIPTEST(userclip4, 4)		       
-
-static void (*(usercliptab[5]))( struct vertex_buffer * ) = {
-   0,
-   0,
-   userclip2,
-   userclip3,
-   userclip4
-};
-
-void gl_user_cliptest( struct vertex_buffer *VB )
-{
-   usercliptab[VB->ClipPtr->size]( VB );
-}
-
-
-void gl_init_clip(void)
-{
-   init_clip_funcs_4();
-   init_clip_funcs_3();
-   init_clip_funcs_2();
-
-   init_clip_funcs_4_edgeflag();
-   init_clip_funcs_3_edgeflag();
-   init_clip_funcs_2_edgeflag();
-
-   clip_interp_tab[0] = clip_nil;
-   clip_interp_tab[CLIP_RGBA0] = clipRGBA0;
-   clip_interp_tab[CLIP_RGBA0|CLIP_RGBA1] = clipRGBA0_RGBA1;
-   clip_interp_tab[CLIP_TEX0|CLIP_RGBA0] = clipTEX0_RGBA0;
-   clip_interp_tab[CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1] = clipTEX0_RGBA0_RGBA1;
-   clip_interp_tab[CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0] = clipTEX1_TEX0_RGBA0;
-   clip_interp_tab[CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1] = 
-      clipTEX1_TEX0_RGBA0_RGBA1;
-   clip_interp_tab[CLIP_TEX0] = clipTEX0;
-   clip_interp_tab[CLIP_TEX1|CLIP_TEX0] = clipTEX1_TEX0;
-   clip_interp_tab[CLIP_INDEX0] = clipINDEX0;
-   clip_interp_tab[CLIP_INDEX0|CLIP_INDEX1] = clipINDEX0_INDEX1;
-
-   clip_interp_tab[CLIP_FOG_COORD] = clip_FOG;
-   clip_interp_tab[CLIP_RGBA0|CLIP_FOG_COORD] = clipRGBA0_FOG;
-   clip_interp_tab[CLIP_RGBA0|CLIP_RGBA1|CLIP_FOG_COORD] = clipRGBA0_RGBA1_FOG;
-   clip_interp_tab[CLIP_TEX0|CLIP_RGBA0|CLIP_FOG_COORD] = clipTEX0_RGBA0_FOG;
-   clip_interp_tab[CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1|CLIP_FOG_COORD] = clipTEX0_RGBA0_RGBA1_FOG;
-   clip_interp_tab[CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0|CLIP_FOG_COORD] = clipTEX1_TEX0_RGBA0_FOG;
-   clip_interp_tab[CLIP_TEX1|CLIP_TEX0|CLIP_RGBA0|CLIP_RGBA1|CLIP_FOG_COORD] = 
-      clipTEX1_TEX0_RGBA0_RGBA1_FOG;
-   clip_interp_tab[CLIP_TEX0|CLIP_FOG_COORD] = clipTEX0_FOG;
-   clip_interp_tab[CLIP_TEX1|CLIP_TEX0|CLIP_FOG_COORD] = clipTEX1_TEX0_FOG;
-   clip_interp_tab[CLIP_INDEX0|CLIP_FOG_COORD] = clipINDEX0_FOG;
-   clip_interp_tab[CLIP_INDEX0|CLIP_INDEX1|CLIP_FOG_COORD] = clipINDEX0_INDEX1_FOG;
-}
-
Index: xc/extras/Mesa/src/clip.h
diff -u xc/extras/Mesa/src/clip.h:1.3 xc/extras/Mesa/src/clip.h:1.4
--- xc/extras/Mesa/src/clip.h:1.3	Tue Feb 15 02:12:04 2000
+++ xc/extras/Mesa/src/clip.h	Fri Feb 22 14:25:24 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -30,65 +30,10 @@
 #ifndef CLIP_H
 #define CLIP_H
 
+#include "mtypes.h"
 
-#include "types.h"
-
-
-
-#ifdef DEBUG
-#  define GL_VIEWCLIP_POINT( V )   gl_viewclip_point( V )
-#else
-#  define GL_VIEWCLIP_POINT( V )			\
-     (    (V)[0] <= (V)[3] && (V)[0] >= -(V)[3]		\
-       && (V)[1] <= (V)[3] && (V)[1] >= -(V)[3]		\
-       && (V)[2] <= (V)[3] && (V)[2] >= -(V)[3] )
-#endif
-
-
-
-
-#define CLIP_TAB_EDGEFLAG 1
-
-extern void gl_init_clip(void);
-
-
-extern GLuint gl_viewclip_point( const GLfloat v[] );
-
-
-
-extern GLuint gl_userclip_point( GLcontext* ctx, const GLfloat v[] );
-
-
-extern void gl_user_cliptest( struct vertex_buffer *VB );
-
-
 extern void _mesa_ClipPlane( GLenum plane, const GLdouble *equation );
 
 extern void _mesa_GetClipPlane( GLenum plane, GLdouble *equation );
-
-
-/*
- * Clipping interpolation functions
- */
-
-extern void gl_clip_interp_all( struct vertex_buffer *VB, 
-                                GLuint dst, GLfloat t, GLuint in, GLuint out );
-
-extern void gl_clip_interp_color_tex( struct vertex_buffer *VB,
-                                GLuint dst, GLfloat t, GLuint in, GLuint out );
-
-extern void gl_clip_interp_tex( struct vertex_buffer *VB, 
-                                GLuint dst, GLfloat t, GLuint in, GLuint out );
-
-extern void gl_clip_interp_color( struct vertex_buffer *VB,
-                                GLuint dst, GLfloat t, GLuint in, GLuint out );
-
-extern void gl_clip_interp_none( struct vertex_buffer *VB,
-                                GLuint dst, GLfloat t, GLuint in, GLuint out );
-
-
-extern void gl_update_userclip( GLcontext *ctx );
-
-extern void gl_update_clipmask( GLcontext *ctx );
 
 #endif
Index: xc/extras/Mesa/src/clip_funcs.h
diff -u xc/extras/Mesa/src/clip_funcs.h:1.7 xc/extras/Mesa/src/clip_funcs.h:removed
--- xc/extras/Mesa/src/clip_funcs.h:1.7	Mon Nov 13 18:30:41 2000
+++ xc/extras/Mesa/src/clip_funcs.h	Thu Feb 27 12:15:32 2003
@@ -1,457 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-static GLuint TAG(userclip_line)( struct vertex_buffer *VB, 
-				  GLuint *i, GLuint *j );
-static GLuint TAG(userclip_polygon)( struct vertex_buffer *VB, 
-				     GLuint n, GLuint vlist[] );
-
-
-
-/* This now calls the user clip functions if required.
- */
-static GLuint TAG(viewclip_line)( struct vertex_buffer *VB, 
-				  GLuint *i, GLuint *j,
-				  GLubyte mask )
-{
-   GLfloat (*coord)[4] = VB->ClipPtr->data;
-   GLuint ii = *i, jj = *j;
-   GLuint vlist[2];
-   GLuint n;
-   clip_interp_func interp = VB->ctx->ClipInterpFunc;
-   GLuint vb_free = VB->FirstFree;
-
-/*
- * We use 6 instances of this code to clip agains the 6 planes.
- */
-#define GENERAL_CLIP							\
-   if (mask & PLANE) {							\
-      GLfloat dpI = CLIP_DOTPROD( ii );					\
-      GLfloat dpJ = CLIP_DOTPROD( jj );					\
-									\
-      if (DIFFERENT_SIGNS(dpI, dpJ)) {					\
-	 GLfloat t = dpI / (dpI - dpJ);					\
-	 INTERP_SZ( t, VB->ClipPtr->data, vb_free, ii, jj, SIZE );	\
-	 interp( VB, vb_free, t, ii, jj);				\
-									\
-	 if (NEGATIVE(dpJ)) {						\
-            VB->ClipMask[jj] |= PLANE;					\
-	    jj = vb_free;						\
-            VB->ClipMask[vb_free++] = 0;				\
-	 } else {							\
-            VB->ClipMask[ii] |= PLANE;					\
-	    ii = vb_free;						\
-            VB->ClipMask[vb_free++] = 0;				\
-	 }								\
-      }									\
-      else if (NEGATIVE(dpI))						\
-	 return 0;							\
-   }
-
-#include "general_clip.h"
-
-   VB->Free = vb_free;
-
-   if (mask & CLIP_USER_BIT) {
-      if ( TAG(userclip_line)( VB, &ii, &jj ) == 0 )
-	 return 0;
-   }
-
-   vlist[0] = ii;
-   vlist[1] = jj;
-   n = 2;
-
-   /* Should always be at least one new vertex.
-    */
-   {
-      const GLfloat *m = VB->ctx->Viewport.WindowMap.m;
-      GLfloat sx = m[MAT_SX];
-      GLfloat tx = m[MAT_TX];
-      GLfloat sy = m[MAT_SY];
-      GLfloat ty = m[MAT_TY];
-      GLfloat sz = m[MAT_SZ];
-      GLfloat tz = m[MAT_TZ];
-      GLuint i, j;
-      GLfloat (*win)[4] = VB->Win.data;
-      GLuint start = VB->FirstFree;
-
-      for (i = 0; i < n; i++) {
-	 j = vlist[i];
-	 if (j >= start) {
-	    if (W(j) != 0.0F) {
-	       GLfloat wInv = 1.0F / W(j);
-	       win[j][0] = X(j) * wInv * sx + tx;
-	       win[j][1] = Y(j) * wInv * sy + ty;
-	       win[j][2] = Z(j) * wInv * sz + tz;
-	       win[j][3] = wInv;
-	    } else {
-	       win[j][0] = win[j][1] = win[j][2] = 0.0F;
-	       win[j][3] = 1.0F;
-	    }
-	 }
-      }
-   }
-
-   if (VB->ctx->Driver.RasterSetup)
-      VB->ctx->Driver.RasterSetup(VB, VB->FirstFree, VB->Free);
-
-   *i = ii;
-   *j = jj;
-   return 1;
-}
-
-/* We now clip polygon triangles individually.  This is necessary to
- * avoid artifacts dependent on where the boundary of the VB falls
- * within the polygon.  As a result, there is an upper bound on the
- * number of vertices which may be created, and the test against VB_SIZE
- * is redundant.  
- */
-static GLuint TAG(viewclip_polygon)( struct vertex_buffer *VB, 
-				     GLuint n, GLuint vlist[],
-				     GLubyte mask )
-{
-   GLfloat (*coord)[4] = VB->ClipPtr->data;
-   GLuint vlist2[VB_SIZE-VB_MAX];
-   GLuint *inlist = vlist, *outlist = vlist2;
-   GLuint i;
-   GLuint vb_free = VB->FirstFree;
-   GLubyte *clipmask = VB->ClipMask;
-   clip_interp_func interp = VB->ctx->ClipInterpFunc;
-
-   if (mask & CLIP_ALL_BITS) {
-
-#define GENERAL_CLIP							\
-   if (mask & PLANE) {							\
-      GLuint idxPrev = inlist[0];					\
-      GLfloat dpPrev = CLIP_DOTPROD(idxPrev);				\
-      GLuint outcount = 0;						\
-      GLuint i;								\
-									\
-      inlist[n] = inlist[0];						\
-									\
-      for (i = 1; i < n+1; i++) {					\
-	 GLuint idx = inlist[i];					\
-	 GLfloat dp = CLIP_DOTPROD(idx);				\
-									\
-	 clipmask[idxPrev] |= (PLANE&CLIP_ALL_BITS);			\
-									\
-	 if (!NEGATIVE(dpPrev)) {					\
-	    if (IND&CLIP_TAB_EDGEFLAG) {				\
-	       if (outcount)						\
-		  VB->EdgeFlagPtr->data[outlist[outcount-1]] &= ~2;	\
-	    }								\
-	    outlist[outcount++] = idxPrev;				\
- 	    clipmask[idxPrev] &= ~(PLANE&CLIP_ALL_BITS);		\
-	 }								\
-									\
-	 if (DIFFERENT_SIGNS(dp, dpPrev)) {				\
-	    if (NEGATIVE(dp)) {						\
-	       /* Going out of bounds.  Avoid division by zero as we	\
-		* know dp != dpPrev from DIFFERENT_SIGNS, above.	\
-		*/							\
-	       GLfloat t = dp / (dp - dpPrev);				\
-               INTERP_SZ( t, VB->ClipPtr->data, vb_free,		\
-			  idx, idxPrev, SIZE );				\
-	       interp( VB, vb_free, t, idx, idxPrev );			\
-									\
-	       if (IND&CLIP_TAB_EDGEFLAG)				\
-		      VB->EdgeFlagPtr->data[vb_free] = 3;		\
-	    } else {							\
-	       /* Coming back in.					\
-		*/							\
-	       GLfloat t = dpPrev / (dpPrev - dp);			\
-               INTERP_SZ( t, VB->ClipPtr->data, vb_free,		\
-			  idxPrev, idx, SIZE );				\
-	       interp( VB, vb_free, t, idxPrev, idx );			\
-									\
-	       if (IND&CLIP_TAB_EDGEFLAG) {				\
-		  VB->EdgeFlagPtr->data[vb_free] =			\
-		     VB->EdgeFlagPtr->data[idxPrev];			\
-               }							\
-	    }								\
-									\
-	       /* Demote trailing edge to internal edge.		\
-		*/							\
-	    if (IND&CLIP_TAB_EDGEFLAG) {				\
-	       if (outcount)						\
-		  VB->EdgeFlagPtr->data[outlist[outcount-1]] &= ~2;	\
-	    }								\
-									\
-	    outlist[outcount++] = vb_free;				\
-	    clipmask[vb_free++] = 0;					\
-	 }								\
-									\
-	 idxPrev = idx;							\
-	 dpPrev = dp;							\
-      }									\
-									\
-      if (outcount < 3)							\
-	 return 0;							\
-									\
-									\
-      {									\
-	 GLuint *tmp = inlist;						\
-	 inlist = outlist;						\
-	 outlist = tmp;							\
-	 n = outcount;							\
-      }									\
-   }
-
-#include "general_clip.h"
-
-      if (inlist != vlist) 
-	 for (i = 0 ; i < n ; i++)
-	    vlist[i] = inlist[i];
-   }
-
-   VB->Free = vb_free;
- 
-   /* Clip against user clipping planes in clip space. 
-    */
-   if (mask & CLIP_USER_BIT) {
-      n = TAG(userclip_polygon)( VB, n, vlist );
-      if (n < 3) return 0;
-   }
-
-
-   {
-      const GLfloat *m = VB->ctx->Viewport.WindowMap.m;
-      GLfloat sx = m[MAT_SX];
-      GLfloat tx = m[MAT_TX];
-      GLfloat sy = m[MAT_SY];
-      GLfloat ty = m[MAT_TY];
-      GLfloat sz = m[MAT_SZ];
-      GLfloat tz = m[MAT_TZ];
-      GLuint i;
-      GLfloat (*win)[4] = VB->Win.data;
-      GLuint first = VB->FirstFree;
-
-      for (i = 0; i < n; i++) {
-	 GLuint j = vlist[i];
-	 if (j >= first) {
-	    if (W(j) != 0.0F) {
-	       GLfloat wInv = 1.0F / W(j);
-	       win[j][0] = X(j) * wInv * sx + tx;
-	       win[j][1] = Y(j) * wInv * sy + ty;
-	       win[j][2] = Z(j) * wInv * sz + tz;
-	       win[j][3] = wInv;
-	    } else {
-	       win[j][0] = win[j][1] = win[j][2] = 0.0;
-	       win[j][3] = 1.0F;
-	    }
-	 }
-      }
-   }
-
-   if (VB->ctx->Driver.RasterSetup)
-      VB->ctx->Driver.RasterSetup(VB, VB->FirstFree, VB->Free);
-
-   return n;
-}
-
-
-#define INSIDE( J ) !NEGATIVE(J)
-#define OUTSIDE( J ) NEGATIVE(J)
-
-
-
-
-static GLuint TAG(userclip_line)( struct vertex_buffer *VB, 
-				  GLuint *i, GLuint *j )
-{
-   GLcontext *ctx = VB->ctx;
-   GLfloat (*coord)[4] = VB->ClipPtr->data;
-   clip_interp_func interp = ctx->ClipInterpFunc;
-   GLuint ii = *i;
-   GLuint jj = *j;
-   GLuint p;
-   GLuint vb_free = VB->Free;
-
-   for (p=0;p<MAX_CLIP_PLANES;p++) {
-      if (ctx->Transform.ClipEnabled[p]) {
-	 GLfloat a = ctx->Transform.ClipUserPlane[p][0];
-	 GLfloat b = ctx->Transform.ClipUserPlane[p][1];
-	 GLfloat c = ctx->Transform.ClipUserPlane[p][2];
-	 GLfloat d = ctx->Transform.ClipUserPlane[p][3];
-
-	 GLfloat dpI = d*W(ii) + c*Z(ii) + b*Y(ii) + a*X(ii);
-	 GLfloat dpJ = d*W(jj) + c*Z(jj) + b*Y(jj) + a*X(jj);
-
-         GLuint flagI = OUTSIDE( dpI );
-         GLuint flagJ = OUTSIDE( dpJ );
-
-	 if (flagI & flagJ) 
-	    return 0;
-
-	 if (flagI ^ flagJ) {
-	    GLfloat t = -dpI/(dpJ-dpI);
-
-	    INTERP_SZ( t, coord, vb_free, ii, jj, SIZE );
-	    interp( VB, vb_free, t, ii, jj );
-
-	    if (flagI) {
-	       VB->ClipMask[ii] |= CLIP_USER_BIT;
-	       ii = vb_free;
-	    } else {
-	       VB->ClipMask[jj] |= CLIP_USER_BIT;
-	       jj = vb_free;
-	    }
-	    
-	    VB->ClipMask[vb_free++] = 0;
-         }
-      }
-   }
-
-   VB->Free = vb_free;
-   *i = ii;
-   *j = jj;
-   return 1;
-}
-
-
-static GLuint TAG(userclip_polygon)( struct vertex_buffer *VB, 
-				     GLuint n, GLuint vlist[] )
-{
-   GLcontext *ctx = VB->ctx;
-   GLfloat (*coord)[4] = VB->ClipPtr->data;
-   clip_interp_func interp = ctx->ClipInterpFunc;
-   GLuint vlist2[VB_SIZE];
-   GLuint *inlist = vlist, *outlist = vlist2;
-   GLuint vb_free = VB->Free;
-   GLuint p;
-
-   for (p=0;p<MAX_CLIP_PLANES;p++) {
-      if (ctx->Transform.ClipEnabled[p]) {
-	 register float a = ctx->Transform.ClipUserPlane[p][0];
-	 register float b = ctx->Transform.ClipUserPlane[p][1];
-	 register float c = ctx->Transform.ClipUserPlane[p][2];
-	 register float d = ctx->Transform.ClipUserPlane[p][3];
-
-	 /* initialize prev to be last in the input list */
-	 GLuint prevj = inlist[0];
-	 GLfloat dpJ = d*W(prevj) + c*Z(prevj) + b*Y(prevj) + a*X(prevj);
-	 GLuint flagJ = INSIDE(dpJ);
-	 GLuint outcount = 0;
-	 GLuint curri;
-
-	 inlist[n] = inlist[0];
-
-
-         for (curri=1;curri<n+1;curri++) {
-	    GLuint currj = inlist[curri];
-	    GLfloat dpI = d*W(currj) + c*Z(currj) + b*Y(currj) + a*X(currj);
-            GLuint flagI = INSIDE(dpI);
-
-	    if (flagJ) {
-	       if ((IND&CLIP_TAB_EDGEFLAG) && outcount)
-		  VB->EdgeFlagPtr->data[outlist[outcount-1]] &= ~2;
-	       outlist[outcount++] = prevj;
-	    } else {
-	       VB->ClipMask[prevj] |= CLIP_USER_BIT;
-	    }
-
-	    if (flagI ^ flagJ) {
-	       GLfloat t;
-	       GLuint in;
-	       GLuint out;
-		  
-	       if (flagI) {
-		  out = prevj;
-		  in = currj;
-		  t = dpI/(dpI-dpJ);
-
-		  if (IND&CLIP_TAB_EDGEFLAG) 
-		     VB->EdgeFlagPtr->data[vb_free] = 
-  			VB->EdgeFlagPtr->data[prevj];		  
-	       } else {
-		  in = prevj;
-		  out = currj;
-		  t = dpJ/(dpJ-dpI);
-
-		  if (IND&CLIP_TAB_EDGEFLAG) 
-		     VB->EdgeFlagPtr->data[vb_free] = 3;
-	       }		  
-
-		  /* Demote trailing edge to internal edge.
-		   */
-	       if (IND&CLIP_TAB_EDGEFLAG) {		  
-		  if (outcount)
-		     VB->EdgeFlagPtr->data[outlist[outcount-1]] &= ~2;
-	       }
-	       
-	       INTERP_SZ( t, coord, vb_free, in, out, SIZE );
-	       interp( VB, vb_free, t, in, out);
-	       outlist[outcount++] = vb_free;
-	       VB->ClipMask[vb_free++] = 0;
-	    }
-
-	    prevj = currj;
-	    flagJ = flagI;
-	    dpJ = dpI;
-         } 
-
-	 if (outcount < 3)
-	    return 0;
-	 else {
-            GLuint *tmp;
-            tmp = inlist;
-            inlist = outlist;
-            outlist = tmp;
-            n = outcount;
-         }
-
-      } /* if */
-   } /* for p */
-
-   if (inlist!=vlist) {
-      GLuint i;
-      for (i = 0 ; i < n ; i++) 
-	 vlist[i] = inlist[i];
-   }
-
-   VB->Free = vb_free;
-   return n;
-}
-
-
-static void TAG(init_clip_funcs)(void)
-{
-   gl_poly_clip_tab[IND][SIZE] = TAG(viewclip_polygon);
-   gl_line_clip_tab[IND][SIZE] = TAG(viewclip_line);
-}
-
-#undef W
-#undef Z
-#undef Y
-#undef X
-#undef SIZE
-#undef TAG
-#undef INSIDE
-#undef OUTSIDE
-#undef IND
Index: xc/extras/Mesa/src/clip_tmp.h
diff -u xc/extras/Mesa/src/clip_tmp.h:1.3 xc/extras/Mesa/src/clip_tmp.h:removed
--- xc/extras/Mesa/src/clip_tmp.h:1.3	Tue Feb 15 02:12:04 2000
+++ xc/extras/Mesa/src/clip_tmp.h	Thu Feb 27 12:15:33 2003
@@ -1,174 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-/* KW: a clever asm implementation would nestle integer versions
- * of the outcode calculation underneath the division.  Gcc won't
- * do this, strangely enough, so I only do the divide in
- * the case where the cliptest passes.  This isn't essential,
- * and an asm implementation needn't replicate that behaviour.
- */
-static GLvector4f * _XFORMAPI TAG(cliptest_points4)( GLvector4f *clip_vec, 
-					   GLvector4f *proj_vec, 
-					   GLubyte clipMask[],
-					   GLubyte *orMask, 
-					   GLubyte *andMask )
-{
-   const GLuint stride = clip_vec->stride;
-   const GLfloat *from = (GLfloat *)clip_vec->start;
-   const GLuint count = clip_vec->count;
-   GLuint c = 0;
-   GLfloat (*vProj)[4] = (GLfloat (*)[4])proj_vec->start;
-   GLubyte tmpAndMask = *andMask;
-   GLubyte tmpOrMask = *orMask;
-   GLuint i;
-   STRIDE_LOOP {
-      const GLfloat cx = from[0];
-      const GLfloat cy = from[1];
-      const GLfloat cz = from[2];
-      const GLfloat cw = from[3];
-#if defined(macintosh)
-      /* on powerpc cliptest is 17% faster in this way. */
-      GLuint mask;
-      mask = (((cw < cx) << CLIP_RIGHT_SHIFT));
-      mask |= (((cw < -cx) << CLIP_LEFT_SHIFT));
-      mask |= (((cw < cy) << CLIP_TOP_SHIFT));
-      mask |= (((cw < -cy) << CLIP_BOTTOM_SHIFT));
-      mask |= (((cw < cz) << CLIP_FAR_SHIFT));
-      mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
-#else /* !defined(macintosh)) */
-      GLubyte mask = 0;
-      if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT;
-      if ( cx + cw < 0) mask |= CLIP_LEFT_BIT;
-      if (-cy + cw < 0) mask |= CLIP_TOP_BIT;
-      if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT;
-      if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
-      if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
-#endif /* defined(macintosh) */
-
-      clipMask[i] = mask;
-      if (mask) {
-	 c++;
-	 tmpAndMask &= mask;
-	 tmpOrMask |= mask;
-	 vProj[i][0] = 0;	/* no longer required? */
-	 vProj[i][1] = 0;
-	 vProj[i][2] = 0;
-	 vProj[i][3] = 1;
-      } else {
-	 GLfloat oow = 1.0F / cw;	 
-	 vProj[i][3] = oow;
-	 vProj[i][0] = cx * oow;
-	 vProj[i][1] = cy * oow;
-	 vProj[i][2] = cz * oow;      
-      }	 
-   }
-
-   *orMask = tmpOrMask;
-   *andMask = (GLubyte) (c < count ? 0 : tmpAndMask);
-
-   proj_vec->flags |= VEC_SIZE_4;
-   proj_vec->size = 3;
-   proj_vec->count = clip_vec->count;
-   return proj_vec;
-}
-
-static GLvector4f * _XFORMAPI TAG(cliptest_points3)( GLvector4f *clip_vec, 
-					   GLvector4f *proj_vec, 
-					   GLubyte clipMask[],
-					   GLubyte *orMask, 
-					   GLubyte *andMask )
-{
-   const GLuint stride = clip_vec->stride;
-   const GLuint count = clip_vec->count;
-   const GLfloat *from = (GLfloat *)clip_vec->start;
-
-   GLubyte tmpOrMask = *orMask;
-   GLubyte tmpAndMask = *andMask;
-   GLuint i;
-   STRIDE_LOOP {
-      const GLfloat cx = from[0], cy = from[1], cz = from[2];
-      GLubyte mask = 0;
-      if (cx >  1.0)       mask |= CLIP_RIGHT_BIT;
-      else if (cx < -1.0)  mask |= CLIP_LEFT_BIT;
-      if (cy >  1.0)       mask |= CLIP_TOP_BIT;
-      else if (cy < -1.0)  mask |= CLIP_BOTTOM_BIT;
-      if (cz >  1.0)       mask |= CLIP_FAR_BIT;
-      else if (cz < -1.0)  mask |= CLIP_NEAR_BIT;
-      clipMask[i] = mask;
-      tmpOrMask |= mask;
-      tmpAndMask &= mask;
-   }
-
-   gl_vector4f_clean_elem(proj_vec, count, 3);
-      
-   *orMask = tmpOrMask;
-   *andMask = tmpAndMask;
-   return clip_vec;
-}
-
-static GLvector4f * _XFORMAPI TAG(cliptest_points2)( GLvector4f *clip_vec, 
-					   GLvector4f *proj_vec, 
-					   GLubyte clipMask[],
-					   GLubyte *orMask, 
-					   GLubyte *andMask )
-{
-   const GLuint stride = clip_vec->stride;
-   const GLuint count = clip_vec->count;
-   const GLfloat *from = (GLfloat *)clip_vec->start;
-
-   GLubyte tmpOrMask = *orMask;
-   GLubyte tmpAndMask = *andMask;
-   GLuint i;
-   STRIDE_LOOP {
-      const GLfloat cx = from[0], cy = from[1];
-      GLubyte mask = 0;
-      if (cx >  1.0)       mask |= CLIP_RIGHT_BIT;
-      else if (cx < -1.0)  mask |= CLIP_LEFT_BIT;
-      if (cy >  1.0)       mask |= CLIP_TOP_BIT;
-      else if (cy < -1.0)  mask |= CLIP_BOTTOM_BIT;
-      clipMask[i] = mask;
-      tmpOrMask |= mask;
-      tmpAndMask &= mask;
-   }
-
-   gl_vector4f_clean_elem(proj_vec, count, 3);
-
-   *orMask = tmpOrMask;
-   *andMask = tmpAndMask;
-   return clip_vec;
-}
-
-
-static void TAG(init_c_cliptest)( void )
-{
-   gl_clip_tab[4] = TAG(cliptest_points4);
-   gl_clip_tab[3] = TAG(cliptest_points3);
-   gl_clip_tab[2] = TAG(cliptest_points2);
-}
Index: xc/extras/Mesa/src/colormac.h
diff -u /dev/null xc/extras/Mesa/src/colormac.h:1.2
--- /dev/null	Thu Feb 27 12:15:33 2003
+++ xc/extras/Mesa/src/colormac.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,137 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+
+/*
+ * Color-related macros
+ */
+
+#ifndef COLORMAC_H
+#define COLORMAC_H
+
+
+#include "glheader.h"
+#include "config.h"
+#include "macros.h"
+#include "mmath.h"
+/* Do not reference mtypes.h from this file.
+ */
+
+
+#if CHAN_BITS == 8
+
+#define BYTE_TO_CHAN(b)   ((b) < 0 ? 0 : (GLchan) (b))
+#define UBYTE_TO_CHAN(b)  (b)
+#define SHORT_TO_CHAN(s)  ((s) < 0 ? 0 : (GLchan) ((s) >> 7))
+#define USHORT_TO_CHAN(s) ((GLchan) ((s) >> 8))
+#define INT_TO_CHAN(i)    ((i) < 0 ? 0 : (GLchan) ((i) >> 23))
+#define UINT_TO_CHAN(i)   ((GLchan) ((i) >> 24))
+
+#define CHAN_TO_UBYTE(c)  (c)
+#define CHAN_TO_FLOAT(c)  UBYTE_TO_FLOAT(c)
+
+#define CLAMPED_FLOAT_TO_CHAN(c, f)    CLAMPED_FLOAT_TO_UBYTE(c, f)
+#define UNCLAMPED_FLOAT_TO_CHAN(c, f)  UNCLAMPED_FLOAT_TO_UBYTE(c, f)
+
+#define COPY_CHAN4(DST, SRC)  COPY_4UBV(DST, SRC)
+
+#define CHAN_PRODUCT(a, b)  ((GLubyte) (((GLint)(a) * ((GLint)(b) + 1)) >> 8))
+
+
+#elif CHAN_BITS == 16
+
+#define BYTE_TO_CHAN(b)   ((b) < 0 ? 0 : (((GLchan) (b)) * 516))
+#define UBYTE_TO_CHAN(b)  ((((GLchan) (b)) << 8) | ((GLchan) (b)))
+#define SHORT_TO_CHAN(s)  ((s) < 0 ? 0 : (GLchan) (s))
+#define USHORT_TO_CHAN(s) (s)
+#define INT_TO_CHAN(i)    ((i) < 0 ? 0 : (GLchan) ((i) >> 15))
+#define UINT_TO_CHAN(i)   ((GLchan) ((i) >> 16))
+
+#define CHAN_TO_UBYTE(c)  ((c) >> 8)
+#define CHAN_TO_FLOAT(c)  ((GLfloat) ((c) * (1.0 / CHAN_MAXF)))
+
+#define CLAMPED_FLOAT_TO_CHAN(c, f) \
+   c = ((GLchan) IROUND((f) * CHAN_MAXF))
+#define UNCLAMPED_FLOAT_TO_CHAN(c, f)   \
+   c = ( (GLchan) IROUND( CLAMP(f, 0.0, 1.0) * CHAN_MAXF) )
+
+#define COPY_CHAN4(DST, SRC)  COPY_4V(DST, SRC)
+
+#define CHAN_PRODUCT(a, b) ((GLchan) ((((GLuint) (a)) * ((GLuint) (b))) / 65535))
+
+
+#elif CHAN_BITS == 32
+
+/* XXX floating-point color channels not fully thought-out */
+#define BYTE_TO_CHAN(b)   ((GLfloat) ((b) * (1.0F / 127.0F)))
+#define UBYTE_TO_CHAN(b)  ((GLfloat) ((b) * (1.0F / 255.0F)))
+#define SHORT_TO_CHAN(s)  ((GLfloat) ((s) * (1.0F / 32767.0F)))
+#define USHORT_TO_CHAN(s) ((GLfloat) ((s) * (1.0F / 65535.0F)))
+#define INT_TO_CHAN(i)    ((GLfloat) ((i) * (1.0F / 2147483647.0F)))
+#define UINT_TO_CHAN(i)   ((GLfloat) ((i) * (1.0F / 4294967295.0F)))
+
+#define CHAN_TO_UBYTE(c)  FLOAT_TO_UBYTE(c)
+#define CHAN_TO_FLOAT(c)  (c)
+
+#define CLAMPED_FLOAT_TO_CHAN(c, f)  c = (f)
+#define UNCLAMPED_FLOAT_TO_CHAN(c, f)      c = (f)
+
+#define COPY_CHAN4(DST, SRC)  COPY_4V(DST, SRC)
+
+#define CHAN_PRODUCT(a, b)    ((a) * (b))
+
+#else
+
+#error unexpected CHAN_BITS size
+
+#endif
+
+
+
+/*
+ * Convert 3 channels at once.
+ */
+#define UNCLAMPED_FLOAT_TO_RGB_CHAN(dst, f)	\
+do {						\
+   UNCLAMPED_FLOAT_TO_CHAN(dst[0], f[0]);	\
+   UNCLAMPED_FLOAT_TO_CHAN(dst[1], f[1]);	\
+   UNCLAMPED_FLOAT_TO_CHAN(dst[2], f[2]);	\
+} while (0)
+
+
+/*
+ * Convert 4 channels at once.
+ */
+#define UNCLAMPED_FLOAT_TO_RGBA_CHAN(dst, f)	\
+do {						\
+   UNCLAMPED_FLOAT_TO_CHAN(dst[0], f[0]);	\
+   UNCLAMPED_FLOAT_TO_CHAN(dst[1], f[1]);	\
+   UNCLAMPED_FLOAT_TO_CHAN(dst[2], f[2]);	\
+   UNCLAMPED_FLOAT_TO_CHAN(dst[3], f[3]);	\
+} while (0)
+
+
+#endif /* COLORMAC_H */
Index: xc/extras/Mesa/src/colortab.c
diff -u xc/extras/Mesa/src/colortab.c:1.9 xc/extras/Mesa/src/colortab.c:1.11
--- xc/extras/Mesa/src/colortab.c:1.9	Thu Nov 30 10:39:02 2000
+++ xc/extras/Mesa/src/colortab.c	Mon Sep  9 17:29:36 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -34,7 +34,8 @@
 #include "macros.h"
 #include "mem.h"
 #include "mmath.h"
-#include "span.h"
+#include "state.h"
+#include "swrast/s_span.h" /* XXX SWRAST hack */
 #endif
 
 
@@ -101,25 +102,10 @@
 void
 _mesa_init_colortable( struct gl_color_table *p )
 {
-   p->TableType = GL_UNSIGNED_BYTE;
-   /* allocate a width=1 table by default */
-   p->Table = CALLOC(4 * sizeof(GLubyte));
-   if (p->Table) {
-      GLubyte *t = (GLubyte *) p->Table;
-      t[0] = 255;
-      t[1] = 255;
-      t[2] = 255;
-      t[3] = 255;
-   }
-   p->Size = 1;
+   p->FloatTable = GL_FALSE;
+   p->Table = NULL;
+   p->Size = 0;
    p->IntFormat = GL_RGBA;
-   p->Format = GL_RGBA;
-   p->RedSize = 8;
-   p->GreenSize = 8;
-   p->BlueSize = 8;
-   p->AlphaSize = 8;
-   p->IntensitySize = 0;
-   p->LuminanceSize = 0;
 }
 
 
@@ -145,7 +131,7 @@
          table->RedSize = 0;
          table->GreenSize = 0;
          table->BlueSize = 0;
-         table->AlphaSize = 8;
+         table->AlphaSize = CHAN_BITS;
          table->IntensitySize = 0;
          table->LuminanceSize = 0;
          break;
@@ -155,48 +141,48 @@
          table->BlueSize = 0;
          table->AlphaSize = 0;
          table->IntensitySize = 0;
-         table->LuminanceSize = 8;
+         table->LuminanceSize = CHAN_BITS;
          break;
       case GL_LUMINANCE_ALPHA:
          table->RedSize = 0;
          table->GreenSize = 0;
          table->BlueSize = 0;
-         table->AlphaSize = 8;
+         table->AlphaSize = CHAN_BITS;
          table->IntensitySize = 0;
-         table->LuminanceSize = 8;
+         table->LuminanceSize = CHAN_BITS;
          break;
       case GL_INTENSITY:
          table->RedSize = 0;
          table->GreenSize = 0;
          table->BlueSize = 0;
          table->AlphaSize = 0;
-         table->IntensitySize = 8;
+         table->IntensitySize = CHAN_BITS;
          table->LuminanceSize = 0;
          break;
       case GL_RGB:
-         table->RedSize = 8;
-         table->GreenSize = 8;
-         table->BlueSize = 8;
+         table->RedSize = CHAN_BITS;
+         table->GreenSize = CHAN_BITS;
+         table->BlueSize = CHAN_BITS;
          table->AlphaSize = 0;
          table->IntensitySize = 0;
          table->LuminanceSize = 0;
          break;
       case GL_RGBA:
-         table->RedSize = 8;
-         table->GreenSize = 8;
-         table->BlueSize = 8;
-         table->AlphaSize = 8;
+         table->RedSize = CHAN_BITS;
+         table->GreenSize = CHAN_BITS;
+         table->BlueSize = CHAN_BITS;
+         table->AlphaSize = CHAN_BITS;
          table->IntensitySize = 0;
          table->LuminanceSize = 0;
          break;
       default:
-         gl_problem(NULL, "unexpected format in set_component_sizes");
+         _mesa_problem(NULL, "unexpected format in set_component_sizes");
    }
 }
 
 
 
-void 
+void
 _mesa_ColorTable( GLenum target, GLenum internalFormat,
                   GLsizei width, GLenum format, GLenum type,
                   const GLvoid *data )
@@ -211,20 +197,27 @@
    GLfloat rBias  = 0.0, gBias  = 0.0, bBias  = 0.0, aBias  = 0.0;
    GLboolean floatTable = GL_FALSE;
    GLint comps;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorTable");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */
 
    switch (target) {
       case GL_TEXTURE_1D:
-         texObj = texUnit->CurrentD[1];
+         texObj = texUnit->Current1D;
          table = &texObj->Palette;
          break;
       case GL_TEXTURE_2D:
-         texObj = texUnit->CurrentD[2];
+         texObj = texUnit->Current2D;
          table = &texObj->Palette;
          break;
       case GL_TEXTURE_3D:
-         texObj = texUnit->CurrentD[3];
+         texObj = texUnit->Current3D;
+         table = &texObj->Palette;
+         break;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
+            return;
+         }
+         texObj = texUnit->CurrentCubeMap;
          table = &texObj->Palette;
          break;
       case GL_PROXY_TEXTURE_1D:
@@ -242,6 +235,14 @@
          table = &texObj->Palette;
          proxy = GL_TRUE;
          break;
+      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
+            return;
+         }
+         texObj = ctx->Texture.ProxyCubeMap;
+         table = &texObj->Palette;
+         break;
       case GL_SHARED_TEXTURE_PALETTE_EXT:
          table = &ctx->Texture.Palette;
          break;
@@ -294,7 +295,7 @@
          proxy = GL_TRUE;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(target)");
          return;
    }
 
@@ -302,24 +303,27 @@
 
    if (!_mesa_is_legal_format_and_type(format, type) ||
        format == GL_INTENSITY) {
-      gl_error(ctx, GL_INVALID_ENUM, "glColorTable(format or type)");
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glColorTable(format or type)");
       return;
    }
 
    baseFormat = base_colortab_format(internalFormat);
    if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");
+      _mesa_error(ctx, GL_INVALID_ENUM, "glColorTable(internalFormat)");
       return;
    }
 
-   if (width < 0 || _mesa_bitcount(width) != 1) {
+   if (width < 0 || (width != 0 && _mesa_bitcount(width) != 1)) {
+      /* error */
       if (proxy) {
          table->Size = 0;
          table->IntFormat = (GLenum) 0;
          table->Format = (GLenum) 0;
       }
       else {
-         gl_error(ctx, GL_INVALID_VALUE, "glColorTable(width)");
+         char msg[100];
+         sprintf(msg, "glColorTable(width=%d)", width);
+         _mesa_error(ctx, GL_INVALID_VALUE, msg);
       }
       return;
    }
@@ -331,7 +335,7 @@
          table->Format = (GLenum) 0;
       }
       else {
-         gl_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");
+         _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glColorTable(width)");
       }
       return;
    }
@@ -348,81 +352,84 @@
       /* free old table, if any */
       if (table->Table) {
          FREE(table->Table);
+         table->Table = NULL;
       }
-      if (floatTable) {
-         GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4];
-         GLfloat *tableF;
-         GLint i;
-
-         _mesa_unpack_float_color_span(ctx, width, table->Format,
-                                       tempTab,  /* dest */
-                                       format, type, data,
-                                       &ctx->Unpack, GL_FALSE, GL_FALSE);
-
-         table->TableType = GL_FLOAT;
-         table->Table = MALLOC(comps * width * sizeof(GLfloat));
-         if (!table->Table) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
-            return;
-         }
-
-         tableF = (GLfloat *) table->Table;
-
-         switch (table->Format) {
-            case GL_INTENSITY:
-               for (i = 0; i < width; i++) {
-                  tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
-               }
-               break;
-            case GL_LUMINANCE:
-               for (i = 0; i < width; i++) {
-                  tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
-               }
-               break;
-            case GL_ALPHA:
-               for (i = 0; i < width; i++) {
-                  tableF[i] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F);
-               }
-               break;
-            case GL_LUMINANCE_ALPHA:
-               for (i = 0; i < width; i++) {
-                  tableF[i*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F);
-                  tableF[i*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F);
-               }
-               break;
-            case GL_RGB:
-               for (i = 0; i < width; i++) {
-                  tableF[i*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F);
-                  tableF[i*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F);
-                  tableF[i*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F);
-               }
-               break;
-            case GL_RGBA:
-               for (i = 0; i < width; i++) {
-                  tableF[i*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F);
-                  tableF[i*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F);
-                  tableF[i*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F);
-                  tableF[i*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F);
-               }
-               break;
-            default:
-               gl_problem(ctx, "Bad format in _mesa_ColorTable");
+      if (width > 0) {
+         if (floatTable) {
+            GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4];
+            GLfloat *tableF;
+            GLint i;
+
+            _mesa_unpack_float_color_span(ctx, width, table->Format,
+                                          tempTab,  /* dest */
+                                          format, type, data, &ctx->Unpack,
+                                          0, GL_FALSE);
+
+            table->FloatTable = GL_TRUE;
+            table->Table = MALLOC(comps * width * sizeof(GLfloat));
+            if (!table->Table) {
+               _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
                return;
-         }
-      }
-      else {
-         /* store GLubyte table */
-         table->TableType = GL_UNSIGNED_BYTE;
-         table->Table = MALLOC(comps * width * sizeof(GLubyte));
-         if (!table->Table) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
-            return;
+            }
+
+            tableF = (GLfloat *) table->Table;
+
+            switch (table->Format) {
+               case GL_INTENSITY:
+                  for (i = 0; i < width; i++) {
+                     tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
+                  }
+                  break;
+               case GL_LUMINANCE:
+                  for (i = 0; i < width; i++) {
+                     tableF[i] = CLAMP(tempTab[i] * rScale + rBias, 0.0F, 1.0F);
+                  }
+                  break;
+               case GL_ALPHA:
+                  for (i = 0; i < width; i++) {
+                     tableF[i] = CLAMP(tempTab[i] * aScale + aBias, 0.0F, 1.0F);
+                  }
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i = 0; i < width; i++) {
+                     tableF[i*2+0] = CLAMP(tempTab[i*2+0] * rScale + rBias, 0.0F, 1.0F);
+                     tableF[i*2+1] = CLAMP(tempTab[i*2+1] * aScale + aBias, 0.0F, 1.0F);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i = 0; i < width; i++) {
+                     tableF[i*3+0] = CLAMP(tempTab[i*3+0] * rScale + rBias, 0.0F, 1.0F);
+                     tableF[i*3+1] = CLAMP(tempTab[i*3+1] * gScale + gBias, 0.0F, 1.0F);
+                     tableF[i*3+2] = CLAMP(tempTab[i*3+2] * bScale + bBias, 0.0F, 1.0F);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i = 0; i < width; i++) {
+                     tableF[i*4+0] = CLAMP(tempTab[i*4+0] * rScale + rBias, 0.0F, 1.0F);
+                     tableF[i*4+1] = CLAMP(tempTab[i*4+1] * gScale + gBias, 0.0F, 1.0F);
+                     tableF[i*4+2] = CLAMP(tempTab[i*4+2] * bScale + bBias, 0.0F, 1.0F);
+                     tableF[i*4+3] = CLAMP(tempTab[i*4+3] * aScale + aBias, 0.0F, 1.0F);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "Bad format in _mesa_ColorTable");
+                  return;
+            }
          }
-         _mesa_unpack_ubyte_color_span(ctx, width, table->Format,
-                                       (GLubyte *) table->Table,  /* dest */
-                                       format, type, data,
-                                       &ctx->Unpack, GL_FALSE);
-      } /* floatTable */
+         else {
+            /* store GLchan table */
+            table->FloatTable = GL_FALSE;
+            table->Table = MALLOC(comps * width * sizeof(GLchan));
+            if (!table->Table) {
+               _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorTable");
+               return;
+            }
+            _mesa_unpack_chan_color_span(ctx, width, table->Format,
+                                         (GLchan *) table->Table,  /* dest */
+                                         format, type, data,
+                                         &ctx->Unpack, 0);
+         } /* floatTable */
+      } /* width > 0 */
    } /* proxy */
 
    if (texObj || target == GL_SHARED_TEXTURE_PALETTE_EXT) {
@@ -431,6 +438,8 @@
          (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
       }
    }
+
+   ctx->NewState |= _NEW_PIXEL;
 }
 
 
@@ -447,22 +456,29 @@
    GLfloat rScale = 1.0, gScale = 1.0, bScale = 1.0, aScale = 1.0;
    GLfloat rBias  = 0.0, gBias  = 0.0, bBias  = 0.0, aBias  = 0.0;
    GLint comps;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorSubTable");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    switch (target) {
       case GL_TEXTURE_1D:
-         texObj = texUnit->CurrentD[1];
+         texObj = texUnit->Current1D;
          table = &texObj->Palette;
          break;
       case GL_TEXTURE_2D:
-         texObj = texUnit->CurrentD[2];
+         texObj = texUnit->Current2D;
          table = &texObj->Palette;
          break;
       case GL_TEXTURE_3D:
-         texObj = texUnit->CurrentD[3];
+         texObj = texUnit->Current3D;
          table = &texObj->Palette;
          break;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");
+            return;
+         }
+         texObj = texUnit->CurrentCubeMap;
+         table = &texObj->Palette;
+         break;
       case GL_SHARED_TEXTURE_PALETTE_EXT:
          table = &ctx->Texture.Palette;
          break;
@@ -500,7 +516,7 @@
          aBias = ctx->Pixel.PCMCTbias[3];
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glColorSubTable(target)");
          return;
    }
 
@@ -508,12 +524,12 @@
 
    if (!_mesa_is_legal_format_and_type(format, type) ||
        format == GL_INTENSITY) {
-      gl_error(ctx, GL_INVALID_ENUM, "glColorSubTable(format or type)");
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glColorSubTable(format or type)");
       return;
    }
 
    if (count < 1) {
-      gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
       return;
    }
 
@@ -521,31 +537,31 @@
    assert(comps > 0);  /* error should have been caught sooner */
 
    if (start + count > (GLint) table->Size) {
-      gl_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "glColorSubTable(count)");
       return;
    }
 
    if (!table->Table) {
-      gl_error(ctx, GL_OUT_OF_MEMORY, "glColorSubTable");
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glColorSubTable");
       return;
    }
 
-   if (table->TableType == GL_UNSIGNED_BYTE) {
-      GLubyte *dest = (GLubyte *) table->Table + start * comps * sizeof(GLubyte);
-      _mesa_unpack_ubyte_color_span(ctx, count, table->Format, dest,
-                                   format, type, data, &ctx->Unpack, GL_FALSE);
+   if (!table->FloatTable) {
+      GLchan *dest = (GLchan *) table->Table + start * comps * sizeof(GLchan);
+      _mesa_unpack_chan_color_span(ctx, count, table->Format, dest,
+                                   format, type, data, &ctx->Unpack, 0);
    }
    else {
       GLfloat tempTab[MAX_COLOR_TABLE_SIZE * 4];
       GLfloat *tableF;
       GLint i;
 
-      ASSERT(table->TableType == GL_FLOAT);
+      ASSERT(table->FloatTable);
 
       _mesa_unpack_float_color_span(ctx, count, table->Format,
                                     tempTab,  /* dest */
-                                    format, type, data,
-                                    &ctx->Unpack, GL_FALSE, GL_FALSE);
+                                    format, type, data, &ctx->Unpack,
+                                    0, GL_FALSE);
 
       tableF = (GLfloat *) table->Table;
 
@@ -593,7 +609,7 @@
             }
             break;
          default:
-            gl_problem(ctx, "Bad format in _mesa_ColorSubTable");
+            _mesa_problem(ctx, "Bad format in _mesa_ColorSubTable");
             return;
          }
    }
@@ -604,6 +620,8 @@
          (*ctx->Driver.UpdateTexturePalette)( ctx, texObj );
       }
    }
+
+   ctx->NewState |= _NEW_PIXEL;
 }
 
 
@@ -613,28 +631,11 @@
 _mesa_CopyColorTable(GLenum target, GLenum internalformat,
                      GLint x, GLint y, GLsizei width)
 {
-   GLubyte data[MAX_WIDTH][4];
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorTable");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    /* Select buffer to read from */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                 ctx->Pixel.DriverReadBuffer );
-
-   if (width > MAX_WIDTH)
-      width = MAX_WIDTH;
-
-   /* read the data from framebuffer */
-   RENDER_START(ctx);
-   gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
-   RENDER_FINISH(ctx);
-
-   /* Restore reading from draw buffer (the default) */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                 ctx->Color.DriverDrawBuffer );
-
-   _mesa_ColorTable(target, internalformat, width,
-                    GL_RGBA, GL_UNSIGNED_BYTE, data);
+   ctx->Driver.CopyColorTable( ctx, target, internalformat, x, y, width );
 }
 
 
@@ -644,27 +645,10 @@
 _mesa_CopyColorSubTable(GLenum target, GLsizei start,
                         GLint x, GLint y, GLsizei width)
 {
-   GLubyte data[MAX_WIDTH][4];
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyColorSubTable");
-
-   /* Select buffer to read from */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                 ctx->Pixel.DriverReadBuffer );
-
-   if (width > MAX_WIDTH)
-      width = MAX_WIDTH;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   /* read the data from framebuffer */
-   RENDER_START(ctx);
-   gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
-   RENDER_FINISH(ctx);
-
-   /* Restore reading from draw buffer (the default) */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                 ctx->Color.DriverDrawBuffer );
-
-   _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_UNSIGNED_BYTE, data);
+   ctx->Driver.CopyColorSubTable( ctx, target, start, x, y, width );
 }
 
 
@@ -676,21 +660,30 @@
    GET_CURRENT_CONTEXT(ctx);
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    struct gl_color_table *table = NULL;
-   GLubyte rgba[MAX_COLOR_TABLE_SIZE][4];
-   GLuint i;
+   GLchan rgba[MAX_COLOR_TABLE_SIZE][4];
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTable");
+   if (ctx->NewState) {
+      _mesa_update_state(ctx);
+   }
 
    switch (target) {
       case GL_TEXTURE_1D:
-         table = &texUnit->CurrentD[1]->Palette;
+         table = &texUnit->Current1D->Palette;
          break;
       case GL_TEXTURE_2D:
-         table = &texUnit->CurrentD[2]->Palette;
+         table = &texUnit->Current2D->Palette;
          break;
       case GL_TEXTURE_3D:
-         table = &texUnit->CurrentD[3]->Palette;
+         table = &texUnit->Current3D->Palette;
          break;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");
+            return;
+         }
+         table = &texUnit->CurrentCubeMap->Palette;
+         break;
       case GL_SHARED_TEXTURE_PALETTE_EXT:
          table = &ctx->Texture.Palette;
          break;
@@ -704,7 +697,7 @@
          table = &ctx->PostColorMatrixColorTable;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTable(target)");
          return;
    }
 
@@ -712,17 +705,19 @@
 
    switch (table->Format) {
       case GL_ALPHA:
-         if (table->TableType == GL_FLOAT) {
+         if (table->FloatTable) {
             const GLfloat *tableF = (const GLfloat *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
                rgba[i][RCOMP] = 0;
                rgba[i][GCOMP] = 0;
                rgba[i][BCOMP] = 0;
-               rgba[i][ACOMP] = (GLint) (tableF[i] * 255.0F);
+               rgba[i][ACOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
             }
          }
          else {
-            const GLubyte *tableUB = (const GLubyte *) table->Table;
+            const GLchan *tableUB = (const GLchan *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
                rgba[i][RCOMP] = 0;
                rgba[i][GCOMP] = 0;
@@ -732,37 +727,41 @@
          }
          break;
       case GL_LUMINANCE:
-         if (table->TableType == GL_FLOAT) {
+         if (table->FloatTable) {
             const GLfloat *tableF = (const GLfloat *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
-               rgba[i][RCOMP] = (GLint) (tableF[i] * 255.0F);
-               rgba[i][GCOMP] = (GLint) (tableF[i] * 255.0F);
-               rgba[i][BCOMP] = (GLint) (tableF[i] * 255.0F);
-               rgba[i][ACOMP] = 255;
+               rgba[i][RCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
+               rgba[i][GCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
+               rgba[i][BCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
+               rgba[i][ACOMP] = CHAN_MAX;
             }
          }
          else {
-            const GLubyte *tableUB = (const GLubyte *) table->Table;
+            const GLchan *tableUB = (const GLchan *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
                rgba[i][RCOMP] = tableUB[i];
                rgba[i][GCOMP] = tableUB[i];
                rgba[i][BCOMP] = tableUB[i];
-               rgba[i][ACOMP] = 255;
+               rgba[i][ACOMP] = CHAN_MAX;
             }
          }
          break;
       case GL_LUMINANCE_ALPHA:
-         if (table->TableType == GL_FLOAT) {
+         if (table->FloatTable) {
             const GLfloat *tableF = (const GLfloat *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
-               rgba[i][RCOMP] = (GLint) (tableF[i*2+0] * 255.0F);
-               rgba[i][GCOMP] = (GLint) (tableF[i*2+0] * 255.0F);
-               rgba[i][BCOMP] = (GLint) (tableF[i*2+0] * 255.0F);
-               rgba[i][ACOMP] = (GLint) (tableF[i*2+1] * 255.0F);
+               rgba[i][RCOMP] = IROUND_POS(tableF[i*2+0] * CHAN_MAXF);
+               rgba[i][GCOMP] = IROUND_POS(tableF[i*2+0] * CHAN_MAXF);
+               rgba[i][BCOMP] = IROUND_POS(tableF[i*2+0] * CHAN_MAXF);
+               rgba[i][ACOMP] = IROUND_POS(tableF[i*2+1] * CHAN_MAXF);
             }
          }
          else {
-            const GLubyte *tableUB = (const GLubyte *) table->Table;
+            const GLchan *tableUB = (const GLchan *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
                rgba[i][RCOMP] = tableUB[i*2+0];
                rgba[i][GCOMP] = tableUB[i*2+0];
@@ -772,17 +771,19 @@
          }
          break;
       case GL_INTENSITY:
-         if (table->TableType == GL_FLOAT) {
+         if (table->FloatTable) {
             const GLfloat *tableF = (const GLfloat *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
-               rgba[i][RCOMP] = (GLint) (tableF[i] * 255.0F);
-               rgba[i][GCOMP] = (GLint) (tableF[i] * 255.0F);
-               rgba[i][BCOMP] = (GLint) (tableF[i] * 255.0F);
-               rgba[i][ACOMP] = (GLint) (tableF[i] * 255.0F);
+               rgba[i][RCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
+               rgba[i][GCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
+               rgba[i][BCOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
+               rgba[i][ACOMP] = IROUND_POS(tableF[i] * CHAN_MAXF);
             }
          }
          else {
-            const GLubyte *tableUB = (const GLubyte *) table->Table;
+            const GLchan *tableUB = (const GLchan *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
                rgba[i][RCOMP] = tableUB[i];
                rgba[i][GCOMP] = tableUB[i];
@@ -792,37 +793,41 @@
          }
          break;
       case GL_RGB:
-         if (table->TableType == GL_FLOAT) {
+         if (table->FloatTable) {
             const GLfloat *tableF = (const GLfloat *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
-               rgba[i][RCOMP] = (GLint) (tableF[i*3+0] * 255.0F);
-               rgba[i][GCOMP] = (GLint) (tableF[i*3+1] * 255.0F);
-               rgba[i][BCOMP] = (GLint) (tableF[i*3+2] * 255.0F);
-               rgba[i][ACOMP] = 255;
+               rgba[i][RCOMP] = IROUND_POS(tableF[i*3+0] * CHAN_MAXF);
+               rgba[i][GCOMP] = IROUND_POS(tableF[i*3+1] * CHAN_MAXF);
+               rgba[i][BCOMP] = IROUND_POS(tableF[i*3+2] * CHAN_MAXF);
+               rgba[i][ACOMP] = CHAN_MAX;
             }
          }
          else {
-            const GLubyte *tableUB = (const GLubyte *) table->Table;
+            const GLchan *tableUB = (const GLchan *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
                rgba[i][RCOMP] = tableUB[i*3+0];
                rgba[i][GCOMP] = tableUB[i*3+1];
                rgba[i][BCOMP] = tableUB[i*3+2];
-               rgba[i][ACOMP] = 255;
+               rgba[i][ACOMP] = CHAN_MAX;
             }
          }
          break;
       case GL_RGBA:
-         if (table->TableType == GL_FLOAT) {
+         if (table->FloatTable) {
             const GLfloat *tableF = (const GLfloat *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
-               rgba[i][RCOMP] = (GLint) (tableF[i*4+0] * 255.0F + 0.5F);
-               rgba[i][GCOMP] = (GLint) (tableF[i*4+1] * 255.0F + 0.5F);
-               rgba[i][BCOMP] = (GLint) (tableF[i*4+2] * 255.0F + 0.5F);
-               rgba[i][ACOMP] = (GLint) (tableF[i*4+3] * 255.0F + 0.5F);
+               rgba[i][RCOMP] = IROUND_POS(tableF[i*4+0] * CHAN_MAXF);
+               rgba[i][GCOMP] = IROUND_POS(tableF[i*4+1] * CHAN_MAXF);
+               rgba[i][BCOMP] = IROUND_POS(tableF[i*4+2] * CHAN_MAXF);
+               rgba[i][ACOMP] = IROUND_POS(tableF[i*4+3] * CHAN_MAXF);
             }
          }
          else {
-            const GLubyte *tableUB = (const GLubyte *) table->Table;
+            const GLchan *tableUB = (const GLchan *) table->Table;
+            GLuint i;
             for (i = 0; i < table->Size; i++) {
                rgba[i][RCOMP] = tableUB[i*4+0];
                rgba[i][GCOMP] = tableUB[i*4+1];
@@ -832,11 +837,11 @@
          }
          break;
       default:
-         gl_problem(ctx, "bad table format in glGetColorTable");
+         _mesa_problem(ctx, "bad table format in glGetColorTable");
          return;
    }
 
-   _mesa_pack_rgba_span(ctx, table->Size, (CONST GLubyte (*)[4]) rgba,
+   _mesa_pack_rgba_span(ctx, table->Size, (const GLchan (*)[4]) rgba,
                         format, type, data, &ctx->Pack, GL_FALSE);
 }
 
@@ -846,7 +851,7 @@
 _mesa_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glColorTableParameterfv");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    switch (target) {
       case GL_COLOR_TABLE_SGI:
@@ -863,7 +868,7 @@
             ctx->Pixel.ColorTableBias[3] = params[3];
          }
          else {
-            gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
             return;
          }
          break;
@@ -881,7 +886,7 @@
             ctx->Pixel.PCCTbias[3] = params[3];
          }
          else {
-            gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
             return;
          }
          break;
@@ -899,14 +904,16 @@
             ctx->Pixel.PCMCTbias[3] = params[3];
          }
          else {
-            gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameterfv(pname)");
             return;
          }
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glColorTableParameter(target)");
          return;
    }
+
+   ctx->NewState |= _NEW_PIXEL;
 }
 
 
@@ -939,19 +946,26 @@
    GET_CURRENT_CONTEXT(ctx);
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    struct gl_color_table *table = NULL;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameterfv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (target) {
       case GL_TEXTURE_1D:
-         table = &texUnit->CurrentD[1]->Palette;
+         table = &texUnit->Current1D->Palette;
          break;
       case GL_TEXTURE_2D:
-         table = &texUnit->CurrentD[2]->Palette;
+         table = &texUnit->Current2D->Palette;
          break;
       case GL_TEXTURE_3D:
-         table = &texUnit->CurrentD[3]->Palette;
+         table = &texUnit->Current3D->Palette;
          break;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glGetColorTableParameterfv(target)");
+            return;
+         }
+         table = &texUnit->CurrentCubeMap->Palette;
+         break;
       case GL_PROXY_TEXTURE_1D:
          table = &ctx->Texture.Proxy1D->Palette;
          break;
@@ -961,6 +975,14 @@
       case GL_PROXY_TEXTURE_3D:
          table = &ctx->Texture.Proxy3D->Palette;
          break;
+      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glGetColorTableParameterfv(target)");
+            return;
+         }
+         table = &ctx->Texture.ProxyCubeMap->Palette;
+         break;
       case GL_SHARED_TEXTURE_PALETTE_EXT:
          table = &ctx->Texture.Palette;
          break;
@@ -1025,7 +1047,7 @@
          table = &ctx->ProxyPostColorMatrixColorTable;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(target)");
          return;
    }
 
@@ -1033,10 +1055,10 @@
 
    switch (pname) {
       case GL_COLOR_TABLE_FORMAT:
-         *params = table->IntFormat;
+         *params = (GLfloat) table->IntFormat;
          break;
       case GL_COLOR_TABLE_WIDTH:
-         *params = table->Size;
+         *params = (GLfloat) table->Size;
          break;
       case GL_COLOR_TABLE_RED_SIZE:
          *params = table->RedSize;
@@ -1057,7 +1079,7 @@
          *params = table->IntensitySize;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" );
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameterfv(pname)" );
          return;
    }
 }
@@ -1070,18 +1092,25 @@
    GET_CURRENT_CONTEXT(ctx);
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    struct gl_color_table *table = NULL;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetColorTableParameteriv");
-
    switch (target) {
       case GL_TEXTURE_1D:
-         table = &texUnit->CurrentD[1]->Palette;
+         table = &texUnit->Current1D->Palette;
          break;
       case GL_TEXTURE_2D:
-         table = &texUnit->CurrentD[2]->Palette;
+         table = &texUnit->Current2D->Palette;
          break;
       case GL_TEXTURE_3D:
-         table = &texUnit->CurrentD[3]->Palette;
+         table = &texUnit->Current3D->Palette;
+         break;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glGetColorTableParameteriv(target)");
+            return;
+         }
+         table = &texUnit->CurrentCubeMap->Palette;
          break;
       case GL_PROXY_TEXTURE_1D:
          table = &ctx->Texture.Proxy1D->Palette;
@@ -1092,6 +1121,14 @@
       case GL_PROXY_TEXTURE_3D:
          table = &ctx->Texture.Proxy3D->Palette;
          break;
+      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glGetColorTableParameteriv(target)");
+            return;
+         }
+         table = &ctx->Texture.ProxyCubeMap->Palette;
+         break;
       case GL_SHARED_TEXTURE_PALETTE_EXT:
          table = &ctx->Texture.Palette;
          break;
@@ -1156,7 +1193,7 @@
          table = &ctx->ProxyPostColorMatrixColorTable;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(target)");
          return;
    }
 
@@ -1188,7 +1225,7 @@
          *params = table->IntensitySize;
          break;
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" );
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetColorTableParameteriv(pname)" );
          return;
    }
 }
Index: xc/extras/Mesa/src/colortab.h
diff -u xc/extras/Mesa/src/colortab.h:1.5 xc/extras/Mesa/src/colortab.h:1.6
--- xc/extras/Mesa/src/colortab.h:1.5	Fri Jun 16 20:02:07 2000
+++ xc/extras/Mesa/src/colortab.h	Fri Feb 22 14:25:24 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define COLORTAB_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
Index: xc/extras/Mesa/src/config.c
diff -u xc/extras/Mesa/src/config.c:1.8 xc/extras/Mesa/src/config.c:1.10
--- xc/extras/Mesa/src/config.c:1.8	Mon Nov 13 18:30:41 2000
+++ xc/extras/Mesa/src/config.c	Mon Sep  9 17:51:59 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
  * Copyright (C) 1999 Keith Whitwell.
  *
  * I hate parsers, so I've choosen a lisp-like syntax - extremely easy
- * to parse and potentially very expressive.  
+ * to parse and potentially very expressive.
  */
 
 
@@ -36,13 +36,13 @@
 #include "all.h"
 #else
 #include "glheader.h"
-#include "config.h"
+#include "context.h"
 #include "enums.h"
 #include "extensions.h"
 #include "hint.h"
 #include "simple_list.h"
 #include "mem.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -61,7 +61,7 @@
  */
 static void pad(int n) { putchar('\n'); while(n--) putchar(' '); }
 
-static void print_list( struct cnode *n, int indent ) 
+static void print_list( struct cnode *n, int indent )
 {
    int i = 0;
    printf("( ");
@@ -72,7 +72,7 @@
 	 print_list( n->data.l.head, indent + 2 );
 	 break;
       case word_t:
-	 printf( n->data.l.head->data.w.text );
+	 printf( "%s", n->data.l.head->data.w.text );
 	 break;
       case nil_t:
 	 printf("()");
@@ -89,7 +89,7 @@
 
 /* Accessors to query the contents of a cnode.
  */
-static int is_list( struct cnode *x, struct cnode **h, struct cnode **t) 
+static int is_list( struct cnode *x, struct cnode **h, struct cnode **t)
 {
    if (x->type == list_t) {
       struct cnode *tmp = x;
@@ -100,28 +100,28 @@
    return 0;
 }
 
-static int is_nil( const struct cnode *x ) 
+static int is_nil( const struct cnode *x )
 {
    return x->type == nil_t;
 }
 
-static int is_word( struct cnode *x, const char **s ) 
+static int is_word( struct cnode *x, const char **s )
 {
    if (x->type == word_t) {
       *s = x->data.w.text;
       return 1;
-   } 
+   }
    return 0;
 }
 
-static int match_word( struct cnode *x, const char *s ) 
+static int match_word( struct cnode *x, const char *s )
 {
-   if (x->type == word_t) 
+   if (x->type == word_t)
       return strcmp(s, x->data.w.text) == 0;
    return 0;
 }
 
-/* Build the parsed expression. 
+/* Build the parsed expression.
  */
 static void skip_comment( FILE *file )
 {
@@ -135,10 +135,10 @@
 {
    int sz = 16, len = 0;
    char *text = (char *) MALLOC( sz * sizeof(char) );
-   
+
    while (1) {
       int c = getc(file);
-      if (len == sz)  
+      if (len == sz)
 	 text = (char *) realloc( text, sizeof(char) * (sz *= 2) );
       if (c == EOF || isspace(c) || c == ')') {
 	 struct cnode *n = MALLOC_STRUCT(cnode);
@@ -148,7 +148,7 @@
 	 n->line = line;
 	 n->data.w.text = text;
 	 return n;
-      }   
+      }
       else
 	 text[len++] = c;
    }
@@ -166,19 +166,19 @@
       int c = getc(file);
 
       switch (c) {
-      case EOF: return head; 
+      case EOF: return head;
       case ')': return head;
       case ';': skip_comment( file ); continue;
       case '\n': (*line)++; continue;
-      case '(': 
+      case '(':
 	 n = get_list( line, file );
 	 break;
-      default: 
+      default:
 	 if (isspace(c)) continue;
-	 ungetc(c, file); 
+	 ungetc(c, file);
 	 n = get_word( *line, file );
 	 break;
-      } 
+      }
 
       (*current)->type = list_t;
       (*current)->data.l.head = n;
@@ -201,15 +201,14 @@
    struct cnode *head, *tail;
    const char *c;
 
-   if (is_list(args, &head, &tail) && 
+   if (is_list(args, &head, &tail) &&
        is_nil(tail) &&
-       is_word(head, &c)) 
-   {
-      if (gl_extensions_disable( ctx, c ) != 0)
-	 error( head, "unknown extension" );
+       is_word(head, &c)) {
+      _mesa_disable_extension( ctx, c );
    }
-   else
-      error( args, "bad args for disable-extension" );	    
+   else {
+      error( args, "bad args for disable-extension" );
+   }
 }
 
 
@@ -218,30 +217,28 @@
    struct cnode *hint, *tail, *value;
    const char *hname, *vname;
 
-   if (is_list(args, &hint, &tail) && 
+   if (is_list(args, &hint, &tail) &&
        is_list(tail, &value, &tail) &&
        is_nil(tail) &&
        is_word(hint, &hname) &&
        is_word(value, &vname))
    {
-      GLint h = gl_lookup_enum_by_name(hname);
-      GLint v = gl_lookup_enum_by_name(vname);
+      GLint h = _mesa_lookup_enum_by_name(hname);
+      GLint v = _mesa_lookup_enum_by_name(vname);
       if (h != -1 && v != -1)
       {
-	 printf("calling glHint(%s=%d, %s=%d)\n", hname, h, vname, v);
 	 if (!_mesa_try_Hint( ctx, (GLenum) h, (GLenum) v ))
 	    error( hint, "glHint failed");
-	 printf("allow draw mem: %d\n", ctx->Hint.AllowDrawMem);
 	 return;
       }
       else
 	 error( hint, "unknown or illegal value for default-hint" );
    }
    else
-      error( args, "bad args for default-hint" );	    
+      error( args, "bad args for default-hint" );
 }
 
-/* Use the general-purpose set-variable 
+/* Use the general-purpose set-variable
  */
 static void fx_catch_signals( GLcontext *ctx, struct cnode *args )
 {
@@ -252,7 +249,7 @@
 /*  	  "fx-catch-signals deprecated, use " */
 /*  	  "(set-variable fx-catch-signals ...) instead"); */
 
-   if (is_list(args, &head, &tail) && 
+   if (is_list(args, &head, &tail) &&
        is_nil(tail) &&
        is_word(head, &value)) {
       if (strcmp(value, "false") == 0)
@@ -271,25 +268,25 @@
  * Should environment vars override config vars?
  */
 
-struct var {
-   struct var *next, *prev;
+struct configvar {
+   struct configvar *next, *prev;
    const char *name;
    void (*notify)(const char *value, int line);
 };
 
-static struct var varlist = { &varlist, &varlist, 0, 0 };
+static struct configvar varlist = { &varlist, &varlist, 0, 0 };
 
 static void set_var( GLcontext *ctx, struct cnode *args )
 {
-   struct var *v;
+   struct configvar *v;
    struct cnode *head, *tail;
    const char *variable, *value;
 
-   if (is_list(args, &head, &tail) && 
+   if (is_list(args, &head, &tail) &&
        is_word(head, &variable) &&
        is_list(tail, &head, &tail) &&
        is_word(head, &value) &&
-       is_nil(tail)) 
+       is_nil(tail))
    {
       foreach(v, &varlist) {
 	 if (strcmp(v->name, variable) == 0) {
@@ -297,7 +294,7 @@
 	    return;
 	 }
       }
-      
+
       error( head, "unknown variable" );
    }
    else {
@@ -305,10 +302,11 @@
    }
 }
 
-void gl_register_config_var(const char *name, 
-			    void (*notify)( const char *, int ))
+void
+_mesa_register_config_var(const char *name,
+                          void (*notify)( const char *, int ))
 {
-   struct var *v = MALLOC_STRUCT(var);
+   struct configvar *v = MALLOC_STRUCT(configvar);
    v->name = name;
    v->notify = notify;
    insert_at_tail( &varlist, v );
@@ -323,15 +321,15 @@
       list = head;
       while (is_list(list, &head, &list)) {
 	 if (is_list(head, &func, &args)) {
-	    if (match_word(func, "disable-extension")) 
+	    if (match_word(func, "disable-extension"))
 	       disable_extension( ctx, args );
-	    else if (match_word(func, "default-hint")) 
+	    else if (match_word(func, "default-hint"))
 	       default_hint( ctx, args );
-	    else if (match_word(func, "fx-catch-signals")) 
+	    else if (match_word(func, "fx-catch-signals"))
 	       fx_catch_signals( ctx, args );
             else if (match_word(func, "set-variable"))
                set_var( ctx, args );
-	    else 
+	    else
 	       error( func, "unknown configuration method" );
          }
       }
@@ -348,7 +346,7 @@
 
    /* Uses the first matching init list.
     */
-   while (is_list(list, &head, &list)) 
+   while (is_list(list, &head, &list))
       if (is_list(head, &arg1, &head) &&
 	  is_list(head, &arg2, &head) &&
 	  match_word(arg1, "config-mesa") &&
@@ -358,7 +356,7 @@
 	    do_init( ctx, head );
 	    return 1;
 	 }
-      } 
+      }
       else
 	 error( head, "malformed toplevel configuration" );
 
@@ -367,21 +365,21 @@
 
 
 
-static void free_list( struct cnode *n ) 
+static void free_list( struct cnode *n )
 {
    while (n->type == list_t) {
-      struct cnode *tmp = n;      
+      struct cnode *tmp = n;
       switch (n->data.l.head->type) {
       case list_t:
 	 free_list( n->data.l.head );
 	 break;
       case word_t:
-	 FREE( n->data.l.head->data.w.text ); 
+	 FREE( n->data.l.head->data.w.text );
 	 FREE( n->data.l.head );
 	 break;
       case nil_t:
 	 FREE( n->data.l.head );
-	 break;	
+	 break;
       default:
 	 return;
       }
@@ -397,17 +395,17 @@
 /* How paranoid do you have to be when reading a config file?  I don't
  * know half the ways to exploit this stuff, and given that this may
  * be run with root access, I think we're better off hardcoding the
- * pathname.  Some clever joe can fix this later if they care.  
+ * pathname.  Some clever joe can fix this later if they care.
  */
-void gl_read_config_file( GLcontext *ctx )
+void _mesa_read_config_file( GLcontext *ctx )
 {
    const char *default_config = "mesa3.1beta1";
 
-#if (defined(__WIN32__) && !defined(__CYGWIN__)) || defined(__MSDOS__)
+#if defined(__WIN32__) || defined(__MSDOS__)
    const char *filename = "mesa.cnf";
 #else
-   const char *filename = "/etc/mesa.conf"; 
-#endif   
+   const char *filename = "/etc/mesa.conf";
+#endif
    FILE *file;
    struct cnode *list;
    int line = 1;
@@ -417,12 +415,12 @@
    int f;
    struct stat statbuf;
 
-   if ((f = open(filename, O_RDONLY)) == -1) 
+   if ((f = open(filename, O_RDONLY)) == -1)
       return;
 
-   if (fstat( f, &statbuf ) == -1 || 
+   if (fstat( f, &statbuf ) == -1 ||
        !S_ISREG( statbuf.st_mode ) ||
-       (file = fdopen(f, "r")) == 0) 
+       (file = fdopen(f, "r")) == 0)
    {
       close( f );
       return;
@@ -434,7 +432,7 @@
 
    list = get_list( &line, file );
    fclose( file );
-   
+
    if ((v = getenv("MESA_CONFIG")) != 0 && *v != 0) {
       if (run_init( ctx, v, list )) {
 	 free_list( list );
@@ -443,16 +441,14 @@
       else
 	 fprintf(stderr, "No configuration '%s' in init file\n", v);
    }
-	 
+
 
    if (!run_init( ctx, default_config, list )) {
       if (getenv("MESA_DEBUG")) {
-         fprintf(stderr, "No default configuration '%s' in init file\n", 
+         fprintf(stderr, "No default configuration '%s' in init file\n",
                  default_config);
       }
    }
 
    free_list( list );
 }
-
-
Index: xc/extras/Mesa/src/config.h
diff -u xc/extras/Mesa/src/config.h:1.9 xc/extras/Mesa/src/config.h:1.11
--- xc/extras/Mesa/src/config.h:1.9	Fri May 18 12:59:53 2001
+++ xc/extras/Mesa/src/config.h	Mon Sep  9 17:51:59 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -98,11 +98,20 @@
 /* Max texture palette / color table size */
 #define MAX_COLOR_TABLE_SIZE 256
 
-/* Number of texture levels */
+/* Number of 1D/2D texture mipmap levels */
 #define MAX_TEXTURE_LEVELS 12
 
+/* Number of 3D texture mipmap levels */
+#define MAX_3D_TEXTURE_LEVELS 8
+
+/* Number of cube texture mipmap levels */
+#define MAX_CUBE_TEXTURE_LEVELS 12
+
+/* Maximum rectangular texture size - GL_NV_texture_rectangle */
+#define MAX_TEXTURE_RECT_SIZE 2048
+
 /* Number of texture units - GL_ARB_multitexture */
-#define MAX_TEXTURE_UNITS 2
+#define MAX_TEXTURE_UNITS 6
 
 /* Maximum viewport/image size: */
 #define MAX_WIDTH 2048
@@ -118,31 +127,44 @@
 #define HISTOGRAM_TABLE_SIZE 256
 
 /* Max convolution filter sizes */
-#define MAX_CONVOLUTION_WIDTH 5
-#define MAX_CONVOLUTION_HEIGHT 5
+#define MAX_CONVOLUTION_WIDTH 9
+#define MAX_CONVOLUTION_HEIGHT 9
 
 /* GL_ARB_texture_compression */
 #define MAX_COMPRESSED_TEXTURE_FORMATS 25
 
+/* GL_EXT_texture_filter_anisotropic */
+#define MAX_TEXTURE_MAX_ANISOTROPY 16.0
+
+/* GL_EXT_texture_lod_bias */
+#define MAX_TEXTURE_LOD_BIAS 4.0
 
 
+
 /*
  * Mesa-specific parameters
  */
 
 
 /*
- * Bits per accumulation buffer color component:  8 or 16
+ * Bits per accumulation buffer color component:  8, 16 or 32
  */
 #define ACCUM_BITS 16
 
 
 /*
- * Bits per depth buffer value:  16 or 32 (GLushort or GLuint)
- * gl_create_visual() can select any depth in [0, 32].
+ * Bits per depth buffer value.  Any reasonable value up to 31 will
+ * work.  32 doesn't work because of integer overflow problems in the
+ * rasterizer code.
  */
+#ifndef DEFAULT_SOFTWARE_DEPTH_BITS
 #define DEFAULT_SOFTWARE_DEPTH_BITS 16
+#endif
+#if DEFAULT_SOFTWARE_DEPTH_BITS <= 16
 #define DEFAULT_SOFTWARE_DEPTH_TYPE GLushort
+#else
+#define DEFAULT_SOFTWARE_DEPTH_TYPE GLuint
+#endif
 
 
 
@@ -153,11 +175,11 @@
 
 
 /*
- * Bits per color channel (must be 8 at this time!)
+ * Bits per color channel:  8, 16 or 32
  */
+#ifndef CHAN_BITS
 #define CHAN_BITS 8
-#define CHAN_MAX ((1 << CHAN_BITS) - 1)
-#define CHAN_MAXF ((GLfloat) CHAN_MAX)
+#endif
 
 
 /*
@@ -169,37 +191,5 @@
 #define BCOMP 2
 #define ACOMP 3
 
-
 
-/* Vertex buffer size.  KW: no restrictions on the divisibility of
- * this number, though things may go better for you if you choose a
- * value of 12n + 3.  
- */
-#define VB_START  3
-
-#define VB_MAX (216 + VB_START)
-
-
-
-/*
- * Actual vertex buffer size.
- *
- * Arrays must also accomodate new vertices from clipping, and
- * potential overflow from primitives which don't fit into neatly into
- * VB_MAX vertices.  (This only happens when mixed primitives are
- * sharing the vb).  
- */
-#define VB_MAX_CLIPPED_VERTS ((2 * (6 + MAX_CLIP_PLANES))+1)
-#define VB_SIZE  (VB_MAX + VB_MAX_CLIPPED_VERTS)
-
-
-
-typedef struct gl_context GLcontext;
-
-extern void
-gl_read_config_file( struct gl_context *ctx );
-
-extern void
-gl_register_config_var(const char *name, void (*notify)( const char *, int ));
-
-#endif
+#endif /* CONFIG_H */
Index: xc/extras/Mesa/src/context.c
diff -u xc/extras/Mesa/src/context.c:1.10 xc/extras/Mesa/src/context.c:1.17
--- xc/extras/Mesa/src/context.c:1.10	Mon Apr  9 19:09:02 2001
+++ xc/extras/Mesa/src/context.c	Mon Dec 16 11:18:26 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -28,65 +28,131 @@
 #include "all.h"
 #else
 #include "glheader.h"
-#include "accum.h"
-#include "alphabuf.h"
+#include "buffers.h"
 #include "clip.h"
 #include "colortab.h"
 #include "context.h"
-#include "cva.h"
-#include "depth.h"
 #include "dlist.h"
 #include "eval.h"
 #include "enums.h"
 #include "extensions.h"
 #include "fog.h"
 #include "get.h"
-#include "glapi.h"
-#include "glapinoop.h"
 #include "glthread.h"
 #include "hash.h"
+#include "imports.h"
 #include "light.h"
 #include "macros.h"
-#include "matrix.h"
 #include "mem.h"
 #include "mmath.h"
-#include "pb.h"
-#include "pipeline.h"
-#include "shade.h"
 #include "simple_list.h"
-#include "stencil.h"
-#include "stages.h"
 #include "state.h"
-#include "translate.h"
 #include "teximage.h"
 #include "texobj.h"
 #include "texstate.h"
-#include "texture.h"
-#include "types.h"
+#include "mtypes.h"
 #include "varray.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbrender.h"
-#include "vbxform.h"
-#include "vertices.h"
-#include "xform.h"
+#include "vtxfmt.h"
+
+#include "math/m_translate.h"
+#include "math/m_vertices.h"
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
+#include "math/mathmod.h"
+#endif
+
+#if defined(MESA_TRACE)
+#include "Trace/tr_context.h"
+#include "Trace/tr_wrapper.h"
+#endif
+
+#ifdef USE_SPARC_ASM
+#include "SPARC/sparc.h"
 #endif
 
+#ifndef MESA_VERBOSE
+int MESA_VERBOSE = 0;
+#endif
 
+#ifndef MESA_DEBUG_FLAGS
+int MESA_DEBUG_FLAGS = 0;
+#endif
 
 /**********************************************************************/
-/*****                  Context and Thread management             *****/
+/*****       OpenGL SI-style interface (new in Mesa 3.5)          *****/
 /**********************************************************************/
 
+static GLboolean
+_mesa_DestroyContext(__GLcontext *gc)
+{
+   if (gc) {
+      _mesa_free_context_data(gc);
+      (*gc->imports.free)(gc, gc);
+   }
+   return GL_TRUE;
+}
+
+
+/* exported OpenGL SI interface */
+__GLcontext *
+__glCoreCreateContext(__GLimports *imports, __GLcontextModes *modes)
+{
+    GLcontext *ctx;
+
+    ctx = (GLcontext *) (*imports->calloc)(0, 1, sizeof(GLcontext));
+    if (ctx == NULL) {
+	return NULL;
+    }
+   ctx->Driver.CurrentExecPrimitive=0;
+    ctx->imports = *imports;
+
+    _mesa_initialize_visual(&ctx->Visual,
+                            modes->rgbMode,
+                            modes->doubleBufferMode,
+                            modes->stereoMode,
+                            modes->redBits,
+                            modes->greenBits,
+                            modes->blueBits,
+                            modes->alphaBits,
+                            modes->indexBits,
+                            modes->depthBits,
+                            modes->stencilBits,
+                            modes->accumRedBits,
+                            modes->accumGreenBits,
+                            modes->accumBlueBits,
+                            modes->accumAlphaBits,
+                            0);
+
+    /* KW: was imports->wscx */
+    _mesa_initialize_context(ctx, &ctx->Visual, NULL, imports->other, GL_FALSE);
 
-#if !defined(THREADS)
+    ctx->exports.destroyContext = _mesa_DestroyContext;
 
-struct immediate *_mesa_CurrentInput = NULL;
+    return ctx;
+}
+
 
+/* exported OpenGL SI interface */
+void
+__glCoreNopDispatch(void)
+{
+#if 0
+   /* SI */
+   __gl_dispatch = __glNopDispatchState;
+#else
+   /* Mesa */
+   _glapi_set_dispatch(NULL);
 #endif
+}
 
 
 /**********************************************************************/
+/*****                  Context and Thread management             *****/
+/**********************************************************************/
+
+
+
+/**********************************************************************/
 /***** GL Visual allocation/destruction                           *****/
 /**********************************************************************/
 
@@ -132,7 +198,7 @@
                                    indexBits, depthBits, stencilBits,
                                    accumRedBits, accumGreenBits,
                                    accumBlueBits, accumAlphaBits,
-                                   numSamples )) {
+                                   numSamples)) {
          FREE(vis);
          return NULL;
       }
@@ -165,6 +231,8 @@
                          GLint accumAlphaBits,
                          GLint numSamples )
 {
+   (void) numSamples;
+
    assert(vis);
 
    /* This is to catch bad values from device drivers not updated for
@@ -191,71 +259,27 @@
    if (accumAlphaBits < 0 || accumAlphaBits > (GLint) (8 * sizeof(GLaccum))) {
       return GL_FALSE;
    }
-
-   vis->RGBAflag   = rgbFlag;
-   vis->DBflag     = dbFlag;
-   vis->StereoFlag = stereoFlag;
-   vis->RedBits    = redBits;
-   vis->GreenBits  = greenBits;
-   vis->BlueBits   = blueBits;
-   vis->AlphaBits  = alphaBits;
-
-   vis->IndexBits      = indexBits;
-   vis->DepthBits      = depthBits;
-   vis->AccumRedBits   = (accumRedBits > 0) ? (8 * sizeof(GLaccum)) : 0;
-   vis->AccumGreenBits = (accumGreenBits > 0) ? (8 * sizeof(GLaccum)) : 0;
-   vis->AccumBlueBits  = (accumBlueBits > 0) ? (8 * sizeof(GLaccum)) : 0;
-   vis->AccumAlphaBits = (accumAlphaBits > 0) ? (8 * sizeof(GLaccum)) : 0;
-   vis->StencilBits    = (stencilBits > 0) ? (8 * sizeof(GLstencil)) : 0;
 
-   if (depthBits == 0) {
-      /* Special case.  Even if we don't have a depth buffer we need
-       * good values for DepthMax for Z vertex transformation purposes
-       * and for per-fragment fog computation.
-       */
-      vis->DepthMax = 1 << 16;
-      vis->DepthMaxF = (GLfloat) vis->DepthMax;
-   }
-   else if (depthBits < 32) {
-      vis->DepthMax = (1 << depthBits) - 1;
-      vis->DepthMaxF = (GLfloat) vis->DepthMax;
-   }
-   else {
-      /* Special case since shift values greater than or equal to the
-       * number of bits in the left hand expression's type are
-       * undefined.
-       */
-      vis->DepthMax = 0xffffffff;
-      vis->DepthMaxF = (GLfloat) vis->DepthMax;
-   }
+   vis->rgbMode          = rgbFlag;
+   vis->doubleBufferMode = dbFlag;
+   vis->stereoMode       = stereoFlag;
+   vis->redBits          = redBits;
+   vis->greenBits        = greenBits;
+   vis->blueBits         = blueBits;
+   vis->alphaBits        = alphaBits;
+
+   vis->indexBits      = indexBits;
+   vis->depthBits      = depthBits;
+   vis->accumRedBits   = (accumRedBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->accumGreenBits = (accumGreenBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->accumBlueBits  = (accumBlueBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->accumAlphaBits = (accumAlphaBits > 0) ? (8 * sizeof(GLaccum)) : 0;
+   vis->stencilBits    = (stencilBits > 0) ? (8 * sizeof(GLstencil)) : 0;
 
    return GL_TRUE;
 }
 
 
-/* This function should no longer be used. Use _mesa_create_visual() instead */
-GLvisual *
-gl_create_visual( GLboolean rgbFlag,
-                  GLboolean alphaFlag,
-                  GLboolean dbFlag,
-                  GLboolean stereoFlag,
-                  GLint depthBits,
-                  GLint stencilBits,
-                  GLint accumBits,
-                  GLint indexBits,
-                  GLint redBits,
-                  GLint greenBits,
-                  GLint blueBits,
-                  GLint alphaBits )
-{
-   (void) alphaFlag;
-   return _mesa_create_visual(rgbFlag, dbFlag, stereoFlag,
-                              redBits, greenBits, blueBits, alphaBits,
-                              indexBits, depthBits, stencilBits,
-                              accumBits, accumBits, accumBits, accumBits, 0);
-}
-
-
 void
 _mesa_destroy_visual( GLvisual *vis )
 {
@@ -263,15 +287,6 @@
 }
 
 
-/* obsolete */
-void
-gl_destroy_visual( GLvisual *vis )
-{
-   _mesa_destroy_visual(vis);
-}
-
-
-
 /**********************************************************************/
 /***** GL Framebuffer allocation/destruction                      *****/
 /**********************************************************************/
@@ -281,20 +296,19 @@
  * Create a new framebuffer.  A GLframebuffer is a struct which
  * encapsulates the depth, stencil and accum buffers and related
  * parameters.
- * Input:  visual - a GLvisual pointer
+ * Input:  visual - a GLvisual pointer (we copy the struct contents)
  *         softwareDepth - create/use a software depth buffer?
  *         softwareStencil - create/use a software stencil buffer?
  *         softwareAccum - create/use a software accum buffer?
  *         softwareAlpha - create/use a software alpha buffer?
-
  * Return:  pointer to new GLframebuffer struct or NULL if error.
  */
 GLframebuffer *
-gl_create_framebuffer( GLvisual *visual,
-                       GLboolean softwareDepth,
-                       GLboolean softwareStencil,
-                       GLboolean softwareAccum,
-                       GLboolean softwareAlpha )
+_mesa_create_framebuffer( const GLvisual *visual,
+                          GLboolean softwareDepth,
+                          GLboolean softwareStencil,
+                          GLboolean softwareAccum,
+                          GLboolean softwareAlpha )
 {
    GLframebuffer *buffer = CALLOC_STRUCT(gl_frame_buffer);
    assert(visual);
@@ -309,11 +323,11 @@
 
 /*
  * Initialize a GLframebuffer object.
- * Input:  See gl_create_framebuffer() above.
+ * Input:  See _mesa_create_framebuffer() above.
  */
 void
 _mesa_initialize_framebuffer( GLframebuffer *buffer,
-                              GLvisual *visual,
+                              const GLvisual *visual,
                               GLboolean softwareDepth,
                               GLboolean softwareStencil,
                               GLboolean softwareAccum,
@@ -322,25 +336,27 @@
    assert(buffer);
    assert(visual);
 
+   BZERO(buffer, sizeof(GLframebuffer));
+
    /* sanity checks */
    if (softwareDepth ) {
-      assert(visual->DepthBits > 0);
+      assert(visual->depthBits > 0);
    }
    if (softwareStencil) {
-      assert(visual->StencilBits > 0);
+      assert(visual->stencilBits > 0);
    }
    if (softwareAccum) {
-      assert(visual->RGBAflag);
-      assert(visual->AccumRedBits > 0);
-      assert(visual->AccumGreenBits > 0);
-      assert(visual->AccumBlueBits > 0);
+      assert(visual->rgbMode);
+      assert(visual->accumRedBits > 0);
+      assert(visual->accumGreenBits > 0);
+      assert(visual->accumBlueBits > 0);
    }
    if (softwareAlpha) {
-      assert(visual->RGBAflag);
-      assert(visual->AlphaBits > 0);
+      assert(visual->rgbMode);
+      assert(visual->alphaBits > 0);
    }
 
-   buffer->Visual = visual;
+   buffer->Visual = *visual;
    buffer->UseSoftwareDepthBuffer = softwareDepth;
    buffer->UseSoftwareStencilBuffer = softwareStencil;
    buffer->UseSoftwareAccumBuffer = softwareAccum;
@@ -352,35 +368,55 @@
  * Free a framebuffer struct and its buffers.
  */
 void
-gl_destroy_framebuffer( GLframebuffer *buffer )
+_mesa_destroy_framebuffer( GLframebuffer *buffer )
 {
    if (buffer) {
-      if (buffer->DepthBuffer) {
-         FREE( buffer->DepthBuffer );
-      }
-      if (buffer->Accum) {
-         FREE( buffer->Accum );
-      }
-      if (buffer->Stencil) {
-         FREE( buffer->Stencil );
-      }
-      if (buffer->FrontLeftAlpha) {
-         FREE( buffer->FrontLeftAlpha );
-      }
-      if (buffer->BackLeftAlpha) {
-         FREE( buffer->BackLeftAlpha );
-      }
-      if (buffer->FrontRightAlpha) {
-         FREE( buffer->FrontRightAlpha );
-      }
-      if (buffer->BackRightAlpha) {
-         FREE( buffer->BackRightAlpha );
-      }
+      _mesa_free_framebuffer_data(buffer);
       FREE(buffer);
    }
 }
 
 
+/*
+ * Free the data hanging off of <buffer>, but not <buffer> itself.
+ */
+void
+_mesa_free_framebuffer_data( GLframebuffer *buffer )
+{
+   if (!buffer)
+      return;
+
+   if (buffer->DepthBuffer) {
+      MESA_PBUFFER_FREE( buffer->DepthBuffer );
+      buffer->DepthBuffer = NULL;
+   }
+   if (buffer->Accum) {
+      MESA_PBUFFER_FREE( buffer->Accum );
+      buffer->Accum = NULL;
+   }
+   if (buffer->Stencil) {
+      MESA_PBUFFER_FREE( buffer->Stencil );
+      buffer->Stencil = NULL;
+   }
+   if (buffer->FrontLeftAlpha) {
+      MESA_PBUFFER_FREE( buffer->FrontLeftAlpha );
+      buffer->FrontLeftAlpha = NULL;
+   }
+   if (buffer->BackLeftAlpha) {
+      MESA_PBUFFER_FREE( buffer->BackLeftAlpha );
+      buffer->BackLeftAlpha = NULL;
+   }
+   if (buffer->FrontRightAlpha) {
+      MESA_PBUFFER_FREE( buffer->FrontRightAlpha );
+      buffer->FrontRightAlpha = NULL;
+   }
+   if (buffer->BackRightAlpha) {
+      MESA_PBUFFER_FREE( buffer->BackRightAlpha );
+      buffer->BackRightAlpha = NULL;
+   }
+}
+
+
 
 /**********************************************************************/
 /*****       Context allocation, initialization, destroying       *****/
@@ -407,19 +443,14 @@
       assert( sizeof(GLushort) >= 2 );
       assert( sizeof(GLuint) >= 4 );
 
-      gl_init_clip();
-      gl_init_eval();
-      _mesa_init_fog();
+      _mesa_init_lists();
+
+      _math_init();
       _mesa_init_math();
-      gl_init_lists();
-      gl_init_texture();
-      gl_init_transformation();
-      gl_init_translate();
-      gl_init_shade();
-      gl_init_vbrender();
-      gl_init_vbxform();
-      gl_init_vertices();
 
+#ifdef USE_SPARC_ASM
+      _mesa_init_sparc_glapi_relocs();
+#endif
       if (getenv("MESA_DEBUG")) {
          _glapi_noop_enable_warnings(GL_TRUE);
       }
@@ -444,7 +475,6 @@
 static struct gl_shared_state *
 alloc_shared_state( void )
 {
-   GLuint d;
    struct gl_shared_state *ss;
    GLboolean outOfMemory;
 
@@ -456,27 +486,35 @@
 
    ss->DisplayList = _mesa_NewHashTable();
    ss->TexObjects = _mesa_NewHashTable();
-#ifdef VAO
-   ss->ArrayObjects = _mesa_NewHashTable();
-#endif
 
    /* Default Texture objects */
    outOfMemory = GL_FALSE;
-   for (d = 1 ; d <= 3 ; d++) {
-      ss->DefaultD[d] = gl_alloc_texture_object(ss, 0, d);
-      if (!ss->DefaultD[d]) {
-         outOfMemory = GL_TRUE;
-         break;
-      }
-      ss->DefaultD[d]->RefCount++; /* don't free if not in use */
+
+   ss->Default1D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_1D);
+   if (!ss->Default1D) {
+      outOfMemory = GL_TRUE;
    }
 
-   ss->DefaultCubeMap = gl_alloc_texture_object(ss, 0, 6);
+   ss->Default2D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_2D);
+   if (!ss->Default2D) {
+      outOfMemory = GL_TRUE;
+   }
+
+   ss->Default3D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_3D);
+   if (!ss->Default3D) {
+      outOfMemory = GL_TRUE;
+   }
+
+   ss->DefaultCubeMap = _mesa_alloc_texture_object(ss, 0,
+                                                   GL_TEXTURE_CUBE_MAP_ARB);
    if (!ss->DefaultCubeMap) {
       outOfMemory = GL_TRUE;
    }
-   else {
-      ss->DefaultCubeMap->RefCount++;
+
+   ss->DefaultRect = _mesa_alloc_texture_object(ss, 0,
+                                                GL_TEXTURE_RECTANGLE_NV);
+   if (!ss->DefaultRect) {
+      outOfMemory = GL_TRUE;
    }
 
    if (!ss->DisplayList || !ss->TexObjects || outOfMemory) {
@@ -485,14 +523,16 @@
          _mesa_DeleteHashTable(ss->DisplayList);
       if (ss->TexObjects)
          _mesa_DeleteHashTable(ss->TexObjects);
-      if (ss->DefaultD[1])
-         gl_free_texture_object(ss, ss->DefaultD[1]);
-      if (ss->DefaultD[2])
-         gl_free_texture_object(ss, ss->DefaultD[2]);
-      if (ss->DefaultD[3])
-         gl_free_texture_object(ss, ss->DefaultD[3]);
+      if (ss->Default1D)
+         _mesa_free_texture_object(ss, ss->Default1D);
+      if (ss->Default2D)
+         _mesa_free_texture_object(ss, ss->Default2D);
+      if (ss->Default3D)
+         _mesa_free_texture_object(ss, ss->Default3D);
       if (ss->DefaultCubeMap)
-         gl_free_texture_object(ss, ss->DefaultCubeMap);
+         _mesa_free_texture_object(ss, ss->DefaultCubeMap);
+      if (ss->DefaultRect)
+         _mesa_free_texture_object(ss, ss->DefaultRect);
       FREE(ss);
       return NULL;
    }
@@ -512,7 +552,7 @@
    while (1) {
       GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
       if (list) {
-         gl_destroy_list(ctx, list);
+         _mesa_destroy_list(ctx, list);
       }
       else {
          break;
@@ -521,12 +561,11 @@
    _mesa_DeleteHashTable(ss->DisplayList);
 
    /* Free texture objects */
-   while (ss->TexObjectList)
-   {
+   while (ss->TexObjectList) {
       if (ctx->Driver.DeleteTexture)
          (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
       /* this function removes from linked list too! */
-      gl_free_texture_object(ss, ss->TexObjectList);
+      _mesa_free_texture_object(ss, ss->TexObjectList);
    }
    _mesa_DeleteHashTable(ss->TexObjects);
 
@@ -556,9 +595,9 @@
    ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
    ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
    l->SpotExponent = 0.0;
-   gl_compute_spot_exp_table( l );
+   _mesa_invalidate_spot_exp_table( l );
    l->SpotCutoff = 180.0;
-   l->CosCutoff = 0.0;		/* KW: -ve values not admitted */
+   l->_CosCutoff = 0.0;		/* KW: -ve values not admitted */
    l->ConstantAttenuation = 1.0;
    l->LinearAttenuation = 0.0;
    l->QuadraticAttenuation = 0.0;
@@ -570,7 +609,7 @@
 static void
 init_lightmodel( struct gl_lightmodel *lm )
 {
-   ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 );
+   ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
    lm->LocalViewer = GL_FALSE;
    lm->TwoSide = GL_FALSE;
    lm->ColorControl = GL_SINGLE_COLOR;
@@ -580,10 +619,10 @@
 static void
 init_material( struct gl_material *m )
 {
-   ASSIGN_4V( m->Ambient,  0.2, 0.2, 0.2, 1.0 );
-   ASSIGN_4V( m->Diffuse,  0.8, 0.8, 0.8, 1.0 );
-   ASSIGN_4V( m->Specular, 0.0, 0.0, 0.0, 1.0 );
-   ASSIGN_4V( m->Emission, 0.0, 0.0, 0.0, 1.0 );
+   ASSIGN_4V( m->Ambient,  0.2F, 0.2F, 0.2F, 1.0F );
+   ASSIGN_4V( m->Diffuse,  0.8F, 0.8F, 0.8F, 1.0F );
+   ASSIGN_4V( m->Specular, 0.0F, 0.0F, 0.0F, 1.0F );
+   ASSIGN_4V( m->Emission, 0.0F, 0.0F, 0.0F, 1.0F );
    m->Shininess = 0.0;
    m->AmbientIndex = 0;
    m->DiffuseIndex = 1;
@@ -597,8 +636,6 @@
 {
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 
-   texUnit->Enabled = 0;
-   texUnit->ReallyEnabled = 0;
    texUnit->EnvMode = GL_MODULATE;
    texUnit->CombineModeRGB = GL_MODULATE;
    texUnit->CombineModeA = GL_MODULATE;
@@ -623,10 +660,10 @@
    texUnit->GenModeT = GL_EYE_LINEAR;
    texUnit->GenModeR = GL_EYE_LINEAR;
    texUnit->GenModeQ = GL_EYE_LINEAR;
-   texUnit->GenBitS = TEXGEN_EYE_LINEAR;
-   texUnit->GenBitT = TEXGEN_EYE_LINEAR;
-   texUnit->GenBitR = TEXGEN_EYE_LINEAR;
-   texUnit->GenBitQ = TEXGEN_EYE_LINEAR;
+   texUnit->_GenBitS = TEXGEN_EYE_LINEAR;
+   texUnit->_GenBitT = TEXGEN_EYE_LINEAR;
+   texUnit->_GenBitR = TEXGEN_EYE_LINEAR;
+   texUnit->_GenBitQ = TEXGEN_EYE_LINEAR;
 
    /* Yes, these plane coefficients are correct! */
    ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
@@ -638,62 +675,15 @@
    ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
    ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
 
-   texUnit->CurrentD[1] = ctx->Shared->DefaultD[1];
-   texUnit->CurrentD[2] = ctx->Shared->DefaultD[2];
-   texUnit->CurrentD[3] = ctx->Shared->DefaultD[3];
+   texUnit->Current1D = ctx->Shared->Default1D;
+   texUnit->Current2D = ctx->Shared->Default2D;
+   texUnit->Current3D = ctx->Shared->Default3D;
    texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
+   texUnit->CurrentRect = ctx->Shared->DefaultRect;
 }
 
 
-static void
-init_fallback_arrays( GLcontext *ctx )
-{
-   struct gl_client_array *cl;
-   GLuint i;
 
-   cl = &ctx->Fallback.Normal;
-   cl->Size = 3;
-   cl->Type = GL_FLOAT;
-   cl->Stride = 0;
-   cl->StrideB = 0;
-   cl->Ptr = (void *) ctx->Current.Normal;
-   cl->Enabled = 1;
-
-   cl = &ctx->Fallback.Color;
-   cl->Size = 4;
-   cl->Type = GL_UNSIGNED_BYTE;
-   cl->Stride = 0;
-   cl->StrideB = 0;
-   cl->Ptr = (void *) ctx->Current.ByteColor;
-   cl->Enabled = 1;
-
-   cl = &ctx->Fallback.Index;
-   cl->Size = 1;
-   cl->Type = GL_UNSIGNED_INT;
-   cl->Stride = 0;
-   cl->StrideB = 0;
-   cl->Ptr = (void *) &ctx->Current.Index;
-   cl->Enabled = 1;
-
-   for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
-      cl = &ctx->Fallback.TexCoord[i];
-      cl->Size = 4;
-      cl->Type = GL_FLOAT;
-      cl->Stride = 0;
-      cl->StrideB = 0;
-      cl->Ptr = (void *) ctx->Current.Texcoord[i];
-      cl->Enabled = 1;
-   }
-
-   cl = &ctx->Fallback.EdgeFlag;
-   cl->Size = 1;
-   cl->Type = GL_UNSIGNED_BYTE;
-   cl->Stride = 0;
-   cl->StrideB = 0;
-   cl->Ptr = (void *) &ctx->Current.EdgeFlag;
-   cl->Enabled = 1;
-}
-
 
 /* Initialize a 1-D evaluator map */
 static void
@@ -740,71 +730,75 @@
 
    assert(ctx);
 
+   assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
+   assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
+
    /* Constants, may be overriden by device drivers */
    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
-   ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
-   ctx->Const.MaxCubeTextureSize = ctx->Const.MaxTextureSize;
+   ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
+   ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
+   ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
    ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
+   ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
+   ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
    ctx->Const.MinPointSize = MIN_POINT_SIZE;
    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
-   ctx->Const.PointSizeGranularity = POINT_SIZE_GRANULARITY;
+   ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
-   ctx->Const.LineWidthGranularity = LINE_WIDTH_GRANULARITY;
+   ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
    ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
    ctx->Const.NumCompressedTextureFormats = 0;
+   ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
+   ctx->Const.MaxLights = MAX_LIGHTS;
 
    /* Modelview matrix */
-   gl_matrix_ctr( &ctx->ModelView );
-   gl_matrix_alloc_inv( &ctx->ModelView );
+   _math_matrix_ctr( &ctx->ModelView );
+   _math_matrix_alloc_inv( &ctx->ModelView );
 
    ctx->ModelViewStackDepth = 0;
    for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
-      gl_matrix_ctr( &ctx->ModelViewStack[i] );
-      gl_matrix_alloc_inv( &ctx->ModelViewStack[i] );
+      _math_matrix_ctr( &ctx->ModelViewStack[i] );
+      _math_matrix_alloc_inv( &ctx->ModelViewStack[i] );
    }
 
    /* Projection matrix - need inv for user clipping in clip space*/
-   gl_matrix_ctr( &ctx->ProjectionMatrix );
-   gl_matrix_alloc_inv( &ctx->ProjectionMatrix );
+   _math_matrix_ctr( &ctx->ProjectionMatrix );
+   _math_matrix_alloc_inv( &ctx->ProjectionMatrix );
 
-   gl_matrix_ctr( &ctx->ModelProjectMatrix );
-   gl_matrix_ctr( &ctx->ModelProjectWinMatrix );
-   ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
-
    ctx->ProjectionStackDepth = 0;
-   ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */
-   ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */
-
    for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
-      gl_matrix_ctr( &ctx->ProjectionStack[i] );
-      gl_matrix_alloc_inv( &ctx->ProjectionStack[i] );
+      _math_matrix_ctr( &ctx->ProjectionStack[i] );
+      _math_matrix_alloc_inv( &ctx->ProjectionStack[i] );
    }
 
+   /* Derived ModelProject matrix */
+   _math_matrix_ctr( &ctx->_ModelProjectMatrix );
+
    /* Texture matrix */
    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
-      gl_matrix_ctr( &ctx->TextureMatrix[i] );
+      _math_matrix_ctr( &ctx->TextureMatrix[i] );
       ctx->TextureStackDepth[i] = 0;
       for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
-         gl_matrix_ctr( &ctx->TextureStack[i][j] );
+         _math_matrix_ctr( &ctx->TextureStack[i][j] );
          ctx->TextureStack[i][j].inv = 0;
       }
    }
 
    /* Color matrix */
-   gl_matrix_ctr(&ctx->ColorMatrix);
+   _math_matrix_ctr(&ctx->ColorMatrix);
    ctx->ColorStackDepth = 0;
    for (j = 0; j < MAX_COLOR_STACK_DEPTH - 1; j++) {
-      gl_matrix_ctr(&ctx->ColorStack[j]);
+      _math_matrix_ctr(&ctx->ColorStack[j]);
    }
 
    /* Accumulate buffer group */
@@ -816,9 +810,8 @@
    ctx->Color.ColorMask[1] = 0xff;
    ctx->Color.ColorMask[2] = 0xff;
    ctx->Color.ColorMask[3] = 0xff;
-   ctx->Color.SWmasking = GL_FALSE;
    ctx->Color.ClearIndex = 0;
-   ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
    ctx->Color.DrawBuffer = GL_FRONT;
    ctx->Color.AlphaEnabled = GL_FALSE;
    ctx->Color.AlphaFunc = GL_ALWAYS;
@@ -829,17 +822,14 @@
    ctx->Color.BlendSrcA = GL_ONE;
    ctx->Color.BlendDstA = GL_ZERO;
    ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
-   ctx->Color.BlendFunc = NULL;  /* this pointer set only when needed */
    ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
    ctx->Color.IndexLogicOpEnabled = GL_FALSE;
    ctx->Color.ColorLogicOpEnabled = GL_FALSE;
-   ctx->Color.SWLogicOpEnabled = GL_FALSE;
    ctx->Color.LogicOp = GL_COPY;
    ctx->Color.DitherFlag = GL_TRUE;
-   ctx->Color.MultiDrawBuffer = GL_FALSE;
 
    /* Current group */
-   ASSIGN_4V( ctx->Current.ByteColor, 255, 255, 255, 255);
+   ASSIGN_4V( ctx->Current.Color, 1.0, 1.0, 1.0, 1.0 );
    ctx->Current.Index = 1;
    for (i=0; i<MAX_TEXTURE_UNITS; i++)
       ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 );
@@ -853,12 +843,7 @@
    ctx->Current.RasterPosValid = GL_TRUE;
    ctx->Current.EdgeFlag = GL_TRUE;
    ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
-   ctx->Current.Primitive = (GLenum) (GL_POLYGON + 1);
-
-   ctx->Current.Flag = (VERT_NORM|VERT_INDEX|VERT_RGBA|VERT_EDGE|
-                        VERT_TEX0_1|VERT_TEX1_1|VERT_MATERIAL);
 
-   init_fallback_arrays( ctx );
 
    /* Depth buffer group */
    ctx->Depth.Test = GL_FALSE;
@@ -934,6 +919,8 @@
    ctx->Fog.Density = 1.0;
    ctx->Fog.Start = 0.0;
    ctx->Fog.End = 1.0;
+   ctx->Fog.ColorSumEnabled = GL_FALSE;
+   ctx->Fog.FogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;
 
    /* Hint group */
    ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
@@ -941,22 +928,19 @@
    ctx->Hint.LineSmooth = GL_DONT_CARE;
    ctx->Hint.PolygonSmooth = GL_DONT_CARE;
    ctx->Hint.Fog = GL_DONT_CARE;
-   ctx->Hint.AllowDrawWin = GL_TRUE;
-   ctx->Hint.AllowDrawFrg = GL_TRUE;
-   ctx->Hint.AllowDrawMem = GL_TRUE;
-   ctx->Hint.StrictLighting = GL_TRUE;
    ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
    ctx->Hint.TextureCompression = GL_DONT_CARE;
+   ctx->Hint.GenerateMipmap = GL_DONT_CARE;
 
    /* Histogram group */
    ctx->Histogram.Width = 0;
    ctx->Histogram.Format = GL_RGBA;
    ctx->Histogram.Sink = GL_FALSE;
-   ctx->Histogram.RedSize       = 0xffffffff;
-   ctx->Histogram.GreenSize     = 0xffffffff;
-   ctx->Histogram.BlueSize      = 0xffffffff;
-   ctx->Histogram.AlphaSize     = 0xffffffff;
-   ctx->Histogram.LuminanceSize = 0xffffffff;
+   ctx->Histogram.RedSize       = 0;
+   ctx->Histogram.GreenSize     = 0;
+   ctx->Histogram.BlueSize      = 0;
+   ctx->Histogram.AlphaSize     = 0;
+   ctx->Histogram.LuminanceSize = 0;
    for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
       ctx->Histogram.Count[i][0] = 0;
       ctx->Histogram.Count[i][1] = 0;
@@ -972,16 +956,8 @@
    ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
    ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
 
-
-
-   /* Pipeline */
-   gl_pipeline_init( ctx );
-   gl_cva_init( ctx );
-
    /* Extensions */
-   gl_extensions_ctr( ctx );
-
-   ctx->AllowVertexCull = CLIP_CULLED_BIT;
+   _mesa_extensions_ctr( ctx );
 
    /* Lighting group */
    for (i=0;i<MAX_LIGHTS;i++) {
@@ -996,43 +972,42 @@
    ctx->Light.Enabled = GL_FALSE;
    ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
    ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
-   ctx->Light.ColorMaterialBitmask
-      = gl_material_bitmask( ctx,
-                             GL_FRONT_AND_BACK,
-                             GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
+   ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx,
+                                               GL_FRONT_AND_BACK,
+                                               GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
 
    ctx->Light.ColorMaterialEnabled = GL_FALSE;
 
    /* Lighting miscellaneous */
-   ctx->ShineTabList = MALLOC_STRUCT( gl_shine_tab );
-   make_empty_list( ctx->ShineTabList );
+   ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab );
+   make_empty_list( ctx->_ShineTabList );
    for (i = 0 ; i < 10 ; i++) {
       struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
       s->shininess = -1;
       s->refcount = 0;
-      insert_at_tail( ctx->ShineTabList, s );
+      insert_at_tail( ctx->_ShineTabList, s );
    }
-   for (i = 0 ; i < 4 ; i++) {
-      ctx->ShineTable[i] = ctx->ShineTabList->prev;
-      ctx->ShineTable[i]->refcount++;
-   }
-
-   gl_compute_shine_table( ctx, 0, ctx->Light.Material[0].Shininess );
-   gl_compute_shine_table( ctx, 2, ctx->Light.Material[0].Shininess * .5 );
-   gl_compute_shine_table( ctx, 1, ctx->Light.Material[1].Shininess );
-   gl_compute_shine_table( ctx, 3, ctx->Light.Material[1].Shininess * .5 );
 
 
    /* Line group */
    ctx->Line.SmoothFlag = GL_FALSE;
    ctx->Line.StippleFlag = GL_FALSE;
    ctx->Line.Width = 1.0;
+   ctx->Line._Width = 1.0;
    ctx->Line.StipplePattern = 0xffff;
    ctx->Line.StippleFactor = 1;
 
    /* Display List group */
    ctx->List.ListBase = 0;
 
+   /* Multisample */
+   ctx->Multisample.Enabled = GL_FALSE;
+   ctx->Multisample.SampleAlphaToCoverage = GL_FALSE;
+   ctx->Multisample.SampleAlphaToOne = GL_FALSE;
+   ctx->Multisample.SampleCoverage = GL_FALSE;
+   ctx->Multisample.SampleCoverageValue = 1.0;
+   ctx->Multisample.SampleCoverageInvert = GL_FALSE;
+
    /* Pixel group */
    ctx->Pixel.RedBias = 0.0;
    ctx->Pixel.RedScale = 1.0;
@@ -1042,7 +1017,6 @@
    ctx->Pixel.BlueScale = 1.0;
    ctx->Pixel.AlphaBias = 0.0;
    ctx->Pixel.AlphaScale = 1.0;
-   ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
    ctx->Pixel.DepthBias = 0.0;
    ctx->Pixel.DepthScale = 1.0;
    ctx->Pixel.IndexOffset = 0;
@@ -1100,33 +1074,38 @@
       ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
       ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
    }
+   for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
+      ctx->Convolution1D.Filter[i] = 0.0;
+      ctx->Convolution2D.Filter[i] = 0.0;
+      ctx->Separable2D.Filter[i] = 0.0;
+   }
    ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
    ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
 
    /* Point group */
    ctx->Point.SmoothFlag = GL_FALSE;
-   ctx->Point.UserSize = 1.0;
    ctx->Point.Size = 1.0;
+   ctx->Point._Size = 1.0;
    ctx->Point.Params[0] = 1.0;
    ctx->Point.Params[1] = 0.0;
    ctx->Point.Params[2] = 0.0;
-   ctx->Point.Attenuated = GL_FALSE;
+   ctx->Point._Attenuated = GL_FALSE;
    ctx->Point.MinSize = 0.0;
-   ctx->Point.MaxSize = (GLfloat) MAX_POINT_SIZE;
+   ctx->Point.MaxSize = ctx->Const.MaxPointSize;
    ctx->Point.Threshold = 1.0;
 
    /* Polygon group */
    ctx->Polygon.CullFlag = GL_FALSE;
    ctx->Polygon.CullFaceMode = GL_BACK;
    ctx->Polygon.FrontFace = GL_CCW;
-   ctx->Polygon.FrontBit = 0;
+   ctx->Polygon._FrontBit = 0;
    ctx->Polygon.FrontMode = GL_FILL;
    ctx->Polygon.BackMode = GL_FILL;
-   ctx->Polygon.Unfilled = GL_FALSE;
    ctx->Polygon.SmoothFlag = GL_FALSE;
    ctx->Polygon.StippleFlag = GL_FALSE;
    ctx->Polygon.OffsetFactor = 0.0F;
    ctx->Polygon.OffsetUnits = 0.0F;
+   ctx->Polygon.OffsetMRD = 0.0F;
    ctx->Polygon.OffsetPoint = GL_FALSE;
    ctx->Polygon.OffsetLine = GL_FALSE;
    ctx->Polygon.OffsetFill = GL_FALSE;
@@ -1154,8 +1133,7 @@
 
    /* Texture group */
    ctx->Texture.CurrentUnit = 0;      /* multitexture */
-   ctx->Texture.CurrentTransformUnit = 0; /* multitexture */
-   ctx->Texture.ReallyEnabled = 0;
+   ctx->Texture._ReallyEnabled = 0;
    for (i=0; i<MAX_TEXTURE_UNITS; i++)
       init_texture_unit( ctx, i );
    ctx->Texture.SharedPalette = GL_FALSE;
@@ -1165,11 +1143,12 @@
    ctx->Transform.MatrixMode = GL_MODELVIEW;
    ctx->Transform.Normalize = GL_FALSE;
    ctx->Transform.RescaleNormals = GL_FALSE;
+   ctx->Transform.RasterPositionUnclipped = GL_FALSE;
    for (i=0;i<MAX_CLIP_PLANES;i++) {
       ctx->Transform.ClipEnabled[i] = GL_FALSE;
       ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
    }
-   ctx->Transform.AnyClip = GL_FALSE;
+   ctx->Transform._AnyClip = GL_FALSE;
 
    /* Viewport group */
    ctx->Viewport.X = 0;
@@ -1178,48 +1157,59 @@
    ctx->Viewport.Height = 0;
    ctx->Viewport.Near = 0.0;
    ctx->Viewport.Far = 1.0;
-   gl_matrix_ctr(&ctx->Viewport.WindowMap);
+   _math_matrix_ctr(&ctx->Viewport._WindowMap);
 
 #define Sz 10
 #define Tz 14
-   ctx->Viewport.WindowMap.m[Sz] = 0.5 * ctx->Visual->DepthMaxF;
-   ctx->Viewport.WindowMap.m[Tz] = 0.5 * ctx->Visual->DepthMaxF;
+   ctx->Viewport._WindowMap.m[Sz] = 0.5F * ctx->DepthMaxF;
+   ctx->Viewport._WindowMap.m[Tz] = 0.5F * ctx->DepthMaxF;
 #undef Sz
 #undef Tz
 
-   ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
-   ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT;
+   ctx->Viewport._WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
+   ctx->Viewport._WindowMap.type = MATRIX_3D_NO_ROT;
 
    /* Vertex arrays */
-#ifdef VAO
-   {
-      struct gl_array_object *arrayObj;
-      arrayObj = _mesa_alloc_vertex_array_object(ctx, 0);
-      ctx->Array.Current = arrayObj;
-   }
-#else
    ctx->Array.Vertex.Size = 4;
    ctx->Array.Vertex.Type = GL_FLOAT;
    ctx->Array.Vertex.Stride = 0;
    ctx->Array.Vertex.StrideB = 0;
    ctx->Array.Vertex.Ptr = NULL;
    ctx->Array.Vertex.Enabled = GL_FALSE;
+   ctx->Array.Vertex.Flags = CA_CLIENT_DATA;
    ctx->Array.Normal.Type = GL_FLOAT;
    ctx->Array.Normal.Stride = 0;
    ctx->Array.Normal.StrideB = 0;
    ctx->Array.Normal.Ptr = NULL;
    ctx->Array.Normal.Enabled = GL_FALSE;
+   ctx->Array.Normal.Flags = CA_CLIENT_DATA;
    ctx->Array.Color.Size = 4;
    ctx->Array.Color.Type = GL_FLOAT;
    ctx->Array.Color.Stride = 0;
    ctx->Array.Color.StrideB = 0;
    ctx->Array.Color.Ptr = NULL;
    ctx->Array.Color.Enabled = GL_FALSE;
+   ctx->Array.Color.Flags = CA_CLIENT_DATA;
+   ctx->Array.SecondaryColor.Size = 4;
+   ctx->Array.SecondaryColor.Type = GL_FLOAT;
+   ctx->Array.SecondaryColor.Stride = 0;
+   ctx->Array.SecondaryColor.StrideB = 0;
+   ctx->Array.SecondaryColor.Ptr = NULL;
+   ctx->Array.SecondaryColor.Enabled = GL_FALSE;
+   ctx->Array.SecondaryColor.Flags = CA_CLIENT_DATA;
+   ctx->Array.FogCoord.Size = 1;
+   ctx->Array.FogCoord.Type = GL_FLOAT;
+   ctx->Array.FogCoord.Stride = 0;
+   ctx->Array.FogCoord.StrideB = 0;
+   ctx->Array.FogCoord.Ptr = NULL;
+   ctx->Array.FogCoord.Enabled = GL_FALSE;
+   ctx->Array.FogCoord.Flags = CA_CLIENT_DATA;
    ctx->Array.Index.Type = GL_FLOAT;
    ctx->Array.Index.Stride = 0;
    ctx->Array.Index.StrideB = 0;
    ctx->Array.Index.Ptr = NULL;
    ctx->Array.Index.Enabled = GL_FALSE;
+   ctx->Array.Index.Flags = CA_CLIENT_DATA;
    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
       ctx->Array.TexCoord[i].Size = 4;
       ctx->Array.TexCoord[i].Type = GL_FLOAT;
@@ -1227,13 +1217,14 @@
       ctx->Array.TexCoord[i].StrideB = 0;
       ctx->Array.TexCoord[i].Ptr = NULL;
       ctx->Array.TexCoord[i].Enabled = GL_FALSE;
+      ctx->Array.TexCoord[i].Flags = CA_CLIENT_DATA;
    }
    ctx->Array.TexCoordInterleaveFactor = 1;
    ctx->Array.EdgeFlag.Stride = 0;
    ctx->Array.EdgeFlag.StrideB = 0;
    ctx->Array.EdgeFlag.Ptr = NULL;
    ctx->Array.EdgeFlag.Enabled = GL_FALSE;
-#endif
+   ctx->Array.EdgeFlag.Flags = CA_CLIENT_DATA;
    ctx->Array.ActiveTexture = 0;   /* GL_ARB_multitexture */
 
    /* Pixel transfer */
@@ -1267,10 +1258,6 @@
    ctx->Select.Hits = 0;
    ctx->Select.NameStackDepth = 0;
 
-   /* Optimized Accum buffer */
-   ctx->IntegerAccumMode = GL_TRUE;
-   ctx->IntegerAccumScaler = 0.0;
-
    /* Renderer and client attribute stacks */
    ctx->AttribStackDepth = 0;
    ctx->ClientAttribStackDepth = 0;
@@ -1293,16 +1280,14 @@
    _mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
 
    /* Miscellaneous */
-   ctx->NewState = NEW_ALL;
+   ctx->NewState = _NEW_ALL;
    ctx->RenderMode = GL_RENDER;
-   ctx->StippleCounter = 0;
-   ctx->NeedNormals = GL_FALSE;
-   ctx->DoViewportMapping = GL_TRUE;
-
-   ctx->NeedEyeCoords = GL_FALSE;
-   ctx->NeedEyeNormals = GL_FALSE;
-   ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
+   ctx->_ImageTransferState = 0;
 
+   ctx->_NeedNormals = 0;
+   ctx->_NeedEyeCoords = 0;
+   ctx->_ModelViewInvScale = 1.0;
+
    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
 
    ctx->CatchSignals = GL_TRUE;
@@ -1317,7 +1302,10 @@
    ctx->NoDither = getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
    if (ctx->NoDither) {
       if (getenv("MESA_DEBUG")) {
+	/* XXX This causes an OSMesa build problem on Solaris 2.6 */
+#ifndef SVR4
          fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n");
+#endif
       }
       ctx->Color.DitherFlag = GL_FALSE;
    }
@@ -1337,32 +1325,53 @@
    GLboolean out_of_memory;
    GLint i;
 
-   ctx->Texture.Proxy1D = gl_alloc_texture_object(NULL, 0, 1);
+   ctx->Texture.Proxy1D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_1D);
    if (!ctx->Texture.Proxy1D) {
       return GL_FALSE;
    }
 
-   ctx->Texture.Proxy2D = gl_alloc_texture_object(NULL, 0, 2);
+   ctx->Texture.Proxy2D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_2D);
    if (!ctx->Texture.Proxy2D) {
-      gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
       return GL_FALSE;
    }
 
-   ctx->Texture.Proxy3D = gl_alloc_texture_object(NULL, 0, 3);
+   ctx->Texture.Proxy3D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_3D);
    if (!ctx->Texture.Proxy3D) {
-      gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
-      gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
       return GL_FALSE;
    }
 
+   ctx->Texture.ProxyCubeMap = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_CUBE_MAP_ARB);
+   if (!ctx->Texture.ProxyCubeMap) {
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
+      return GL_FALSE;
+   }
+
+   ctx->Texture.ProxyRect = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_RECTANGLE_NV);
+   if (!ctx->Texture.ProxyRect) {
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
+      _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
+      return GL_FALSE;
+   }
+
    out_of_memory = GL_FALSE;
    for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
       ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
       ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
       ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
+      ctx->Texture.ProxyCubeMap->Image[i] = _mesa_alloc_texture_image();
+      ctx->Texture.ProxyRect->Image[i] = _mesa_alloc_texture_image();
       if (!ctx->Texture.Proxy1D->Image[i]
           || !ctx->Texture.Proxy2D->Image[i]
-          || !ctx->Texture.Proxy3D->Image[i]) {
+          || !ctx->Texture.Proxy3D->Image[i]
+          || !ctx->Texture.ProxyCubeMap->Image[i]
+          || !ctx->Texture.ProxyRect->Image[i]) {
          out_of_memory = GL_TRUE;
       }
    }
@@ -1377,10 +1386,18 @@
          if (ctx->Texture.Proxy3D->Image[i]) {
             _mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
          }
+         if (ctx->Texture.ProxyCubeMap->Image[i]) {
+            _mesa_free_texture_image(ctx->Texture.ProxyCubeMap->Image[i]);
+         }
+         if (ctx->Texture.ProxyRect->Image[i]) {
+            _mesa_free_texture_image(ctx->Texture.ProxyRect->Image[i]);
+         }
       }
-      gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
-      gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
-      gl_free_texture_object(NULL, ctx->Texture.Proxy3D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
+      _mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
+      _mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
+      _mesa_free_texture_object(NULL, ctx->Texture.ProxyRect);
       return GL_FALSE;
    }
    else {
@@ -1389,14 +1406,51 @@
 }
 
 
+static void add_debug_flags( const char *debug )
+{
+#ifdef MESA_DEBUG
+   if (strstr(debug, "varray")) 
+      MESA_VERBOSE |= VERBOSE_VARRAY;
+
+   if (strstr(debug, "tex")) 
+      MESA_VERBOSE |= VERBOSE_TEXTURE;
+
+   if (strstr(debug, "imm")) 
+      MESA_VERBOSE |= VERBOSE_IMMEDIATE;
 
+   if (strstr(debug, "pipe")) 
+      MESA_VERBOSE |= VERBOSE_PIPELINE;
+
+   if (strstr(debug, "driver")) 
+      MESA_VERBOSE |= VERBOSE_DRIVER;
+
+   if (strstr(debug, "state")) 
+      MESA_VERBOSE |= VERBOSE_STATE;
+
+   if (strstr(debug, "api")) 
+      MESA_VERBOSE |= VERBOSE_API;
+
+   if (strstr(debug, "list")) 
+      MESA_VERBOSE |= VERBOSE_DISPLAY_LIST;
+
+   if (strstr(debug, "lighting")) 
+      MESA_VERBOSE |= VERBOSE_LIGHTING;
+   
+   /* Debug flag:
+    */
+   if (strstr(debug, "flush")) 
+      MESA_DEBUG_FLAGS |= DEBUG_ALWAYS_FLUSH;
+#endif
+}
+
+
 /*
  * Initialize a GLcontext struct.  This includes allocating all the
  * other structs and arrays which hang off of the context by pointers.
  */
 GLboolean
 _mesa_initialize_context( GLcontext *ctx,
-                          GLvisual *visual,
+                          const GLvisual *visual,
                           GLcontext *share_list,
                           void *driver_ctx,
                           GLboolean direct )
@@ -1408,33 +1462,27 @@
    /* misc one-time initializations */
    one_time_init();
 
+   /**
+    ** OpenGL SI stuff
+    **/
+   if (!ctx->imports.malloc) {
+      _mesa_InitDefaultImports(&ctx->imports, driver_ctx, NULL);
+   }
+   /* exports are setup by the device driver */
+
    ctx->DriverCtx = driver_ctx;
-   ctx->Visual = visual;
+   ctx->Visual = *visual;
    ctx->DrawBuffer = NULL;
    ctx->ReadBuffer = NULL;
 
-   ctx->VB = gl_vb_create_for_immediate( ctx );
-   if (!ctx->VB) {
-      return GL_FALSE;
-   }
-   ctx->input = ctx->VB->IM;
-
-   ctx->PB = gl_alloc_pb();
-   if (!ctx->PB) {
-      ALIGN_FREE( ctx->VB );
-      return GL_FALSE;
-   }
-
    if (share_list) {
-      /* share the group of display lists of another context */
+      /* share state with another context */
       ctx->Shared = share_list->Shared;
    }
    else {
-      /* allocate new group of display lists */
+      /* allocate new, unshared state */
       ctx->Shared = alloc_shared_state();
       if (!ctx->Shared) {
-         ALIGN_FREE( ctx->VB );
-         FREE( ctx->PB );
          return GL_FALSE;
       }
    }
@@ -1442,12 +1490,16 @@
    ctx->Shared->RefCount++;
    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 
-   init_attrib_groups( ctx );
+   /* Effectively bind the default textures to all texture units */
+   ctx->Shared->Default1D->RefCount += MAX_TEXTURE_UNITS;
+   ctx->Shared->Default2D->RefCount += MAX_TEXTURE_UNITS;
+   ctx->Shared->Default3D->RefCount += MAX_TEXTURE_UNITS;
+   ctx->Shared->DefaultCubeMap->RefCount += MAX_TEXTURE_UNITS;
+   ctx->Shared->DefaultRect->RefCount += MAX_TEXTURE_UNITS;
 
-   gl_reset_vb( ctx->VB );
-   gl_reset_input( ctx );
+   init_attrib_groups( ctx );
 
-   if (visual->DBflag) {
+   if (visual->doubleBufferMode) {
       ctx->Color.DrawBuffer = GL_BACK;
       ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
       ctx->Color.DrawDestMask = BACK_LEFT_BIT;
@@ -1464,8 +1516,6 @@
 
    if (!alloc_proxy_textures(ctx)) {
       free_shared_state(ctx, ctx->Shared);
-      ALIGN_FREE( ctx->VB );
-      FREE( ctx->PB );
       return GL_FALSE;
    }
 
@@ -1492,8 +1542,6 @@
    ctx->Save = (struct _glapi_table *) CALLOC(dispatchSize * sizeof(void*));
    if (!ctx->Exec || !ctx->Save) {
       free_shared_state(ctx, ctx->Shared);
-      ALIGN_FREE( ctx->VB );
-      FREE( ctx->PB );
       if (ctx->Exec)
          FREE( ctx->Exec );
    }
@@ -1501,6 +1549,42 @@
    _mesa_init_dlist_table(ctx->Save, dispatchSize);
    ctx->CurrentDispatch = ctx->Exec;
 
+   ctx->ExecPrefersFloat = GL_FALSE;
+   ctx->SavePrefersFloat = GL_FALSE;
+
+   /* Neutral tnl module stuff */
+   _mesa_init_exec_vtxfmt( ctx );
+   ctx->TnlModule.Current = NULL;
+   ctx->TnlModule.SwapCount = 0;
+
+   /* Z buffer stuff */
+   if (ctx->Visual.depthBits == 0) {
+      /* Special case.  Even if we don't have a depth buffer we need
+       * good values for DepthMax for Z vertex transformation purposes
+       * and for per-fragment fog computation.
+       */
+      ctx->DepthMax = 1 << 16;
+      ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
+   }
+   else if (ctx->Visual.depthBits < 32) {
+      ctx->DepthMax = (1 << ctx->Visual.depthBits) - 1;
+      ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
+   }
+   else {
+      /* Special case since shift values greater than or equal to the
+       * number of bits in the left hand expression's type are undefined.
+       */
+      ctx->DepthMax = 0xffffffff;
+      ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
+   }
+   ctx->MRD = 1.0;  /* Minimum resolvable depth value, for polygon offset */
+
+   if (getenv("MESA_DEBUG"))
+      add_debug_flags(getenv("MESA_DEBUG"));
+
+   if (getenv("MESA_VERBOSE"))
+      add_debug_flags(getenv("MESA_VERBOSE"));
+
    return GL_TRUE;
 }
 
@@ -1508,22 +1592,22 @@
 
 /*
  * Allocate and initialize a GLcontext structure.
- * Input:  visual - a GLvisual pointer
+ * Input:  visual - a GLvisual pointer (we copy the struct contents)
  *         sharelist - another context to share display lists with or NULL
  *         driver_ctx - pointer to device driver's context state struct
- * Return:  pointer to a new gl_context struct or NULL if error.
+ * Return:  pointer to a new __GLcontextRec or NULL if error.
  */
 GLcontext *
-gl_create_context( GLvisual *visual,
-                   GLcontext *share_list,
-                   void *driver_ctx,
-                   GLboolean direct )
+_mesa_create_context( const GLvisual *visual,
+                      GLcontext *share_list,
+                      void *driver_ctx,
+                      GLboolean direct )
 {
    GLcontext *ctx = (GLcontext *) CALLOC( sizeof(GLcontext) );
    if (!ctx) {
       return NULL;
    }
-
+   ctx->Driver.CurrentExecPrimitive = 0;
    if (_mesa_initialize_context(ctx, visual, share_list, driver_ctx, direct)) {
       return ctx;
    }
@@ -1540,37 +1624,37 @@
  * But don't free() the GLcontext struct itself!
  */
 void
-gl_free_context_data( GLcontext *ctx )
+_mesa_free_context_data( GLcontext *ctx )
 {
    struct gl_shine_tab *s, *tmps;
    GLuint i, j;
 
    /* if we're destroying the current context, unbind it first */
-   if (ctx == gl_get_current_context()) {
-      gl_make_current(NULL, NULL);
+   if (ctx == _mesa_get_current_context()) {
+      _mesa_make_current(NULL, NULL);
    }
 
-   gl_matrix_dtr( &ctx->ModelView );
+   _math_matrix_dtr( &ctx->ModelView );
    for (i = 0; i < MAX_MODELVIEW_STACK_DEPTH - 1; i++) {
-      gl_matrix_dtr( &ctx->ModelViewStack[i] );
+      _math_matrix_dtr( &ctx->ModelViewStack[i] );
    }
-   gl_matrix_dtr( &ctx->ProjectionMatrix );
+   _math_matrix_dtr( &ctx->ProjectionMatrix );
    for (i = 0; i < MAX_PROJECTION_STACK_DEPTH - 1; i++) {
-      gl_matrix_dtr( &ctx->ProjectionStack[i] );
+      _math_matrix_dtr( &ctx->ProjectionStack[i] );
    }
    for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
-      gl_matrix_dtr( &ctx->TextureMatrix[i] );
+      _math_matrix_dtr( &ctx->TextureMatrix[i] );
       for (j = 0; j < MAX_TEXTURE_STACK_DEPTH - 1; j++) {
-         gl_matrix_dtr( &ctx->TextureStack[i][j] );
+         _math_matrix_dtr( &ctx->TextureStack[i][j] );
       }
    }
 
-   FREE( ctx->PB );
+   _math_matrix_dtr( &ctx->_ModelProjectMatrix );
 
-   if (ctx->input != ctx->VB->IM)
-      gl_immediate_free( ctx->input );
-
-   gl_vb_free( ctx->VB );
+   _math_matrix_dtr(&ctx->ColorMatrix);
+   for (j = 0; j < MAX_COLOR_STACK_DEPTH - 1; j++) {
+      _math_matrix_dtr(&ctx->ColorStack[j]);
+   }
 
    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
    ctx->Shared->RefCount--;
@@ -1581,15 +1665,17 @@
       free_shared_state( ctx, ctx->Shared );
    }
 
-   foreach_s( s, tmps, ctx->ShineTabList ) {
+   foreach_s( s, tmps, ctx->_ShineTabList ) {
       FREE( s );
    }
-   FREE( ctx->ShineTabList );
+   FREE( ctx->_ShineTabList );
 
    /* Free proxy texture objects */
-   gl_free_texture_object( NULL, ctx->Texture.Proxy1D );
-   gl_free_texture_object( NULL, ctx->Texture.Proxy2D );
-   gl_free_texture_object( NULL, ctx->Texture.Proxy3D );
+   _mesa_free_texture_object( NULL, ctx->Texture.Proxy1D );
+   _mesa_free_texture_object( NULL, ctx->Texture.Proxy2D );
+   _mesa_free_texture_object( NULL, ctx->Texture.Proxy3D );
+   _mesa_free_texture_object( NULL, ctx->Texture.ProxyCubeMap );
+   _mesa_free_texture_object( NULL, ctx->Texture.ProxyRect );
 
    /* Free evaluator data */
    if (ctx->EvalMap.Map1Vertex3.Points)
@@ -1635,14 +1721,10 @@
    _mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
    _mesa_free_colortable_data( &ctx->Texture.Palette );
 
-   /* Free cache of immediate buffers. */
-   while (ctx->nr_im_queued-- > 0) {
-      struct immediate * next = ctx->freed_im_queue->next;
-      ALIGN_FREE( ctx->freed_im_queue );
-      ctx->freed_im_queue = next;
-   }
-   gl_extensions_dtr(ctx);
+   _math_matrix_dtr(&ctx->Viewport._WindowMap);
 
+   _mesa_extensions_dtr(ctx);
+
    FREE(ctx->Exec);
    FREE(ctx->Save);
 }
@@ -1653,10 +1735,10 @@
  * Destroy a GLcontext structure.
  */
 void
-gl_destroy_context( GLcontext *ctx )
+_mesa_destroy_context( GLcontext *ctx )
 {
    if (ctx) {
-      gl_free_context_data(ctx);
+      _mesa_free_context_data(ctx);
       FREE( (void *) ctx );
    }
 }
@@ -1664,129 +1746,181 @@
 
 
 /*
- * Called by the driver after both the context and driver are fully
- * initialized.  Currently just reads the config file.
- */
-void
-gl_context_initialize( GLcontext *ctx )
-{
-   gl_read_config_file( ctx );
-}
-
-
-
-/*
  * Copy attribute groups from one context to another.
  * Input:  src - source context
  *         dst - destination context
  *         mask - bitwise OR of GL_*_BIT flags
  */
 void
-gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
+_mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
 {
    if (mask & GL_ACCUM_BUFFER_BIT) {
-      MEMCPY( &dst->Accum, &src->Accum, sizeof(struct gl_accum_attrib) );
+      /* OK to memcpy */
+      dst->Accum = src->Accum;
    }
    if (mask & GL_COLOR_BUFFER_BIT) {
-      MEMCPY( &dst->Color, &src->Color, sizeof(struct gl_colorbuffer_attrib) );
+      /* OK to memcpy */
+      dst->Color = src->Color;
    }
    if (mask & GL_CURRENT_BIT) {
-      MEMCPY( &dst->Current, &src->Current, sizeof(struct gl_current_attrib) );
+      /* OK to memcpy */
+      dst->Current = src->Current;
    }
    if (mask & GL_DEPTH_BUFFER_BIT) {
-      MEMCPY( &dst->Depth, &src->Depth, sizeof(struct gl_depthbuffer_attrib) );
+      /* OK to memcpy */
+      dst->Depth = src->Depth;
    }
    if (mask & GL_ENABLE_BIT) {
       /* no op */
    }
    if (mask & GL_EVAL_BIT) {
-      MEMCPY( &dst->Eval, &src->Eval, sizeof(struct gl_eval_attrib) );
+      /* OK to memcpy */
+      dst->Eval = src->Eval;
    }
    if (mask & GL_FOG_BIT) {
-      MEMCPY( &dst->Fog, &src->Fog, sizeof(struct gl_fog_attrib) );
+      /* OK to memcpy */
+      dst->Fog = src->Fog;
    }
    if (mask & GL_HINT_BIT) {
-      MEMCPY( &dst->Hint, &src->Hint, sizeof(struct gl_hint_attrib) );
+      /* OK to memcpy */
+      dst->Hint = src->Hint;
    }
    if (mask & GL_LIGHTING_BIT) {
-      MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light_attrib) );
-      /*       gl_reinit_light_attrib( &dst->Light ); */
+      GLuint i;
+      /* begin with memcpy */
+      MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light) );
+      /* fixup linked lists to prevent pointer insanity */
+      make_empty_list( &(dst->Light.EnabledList) );
+      for (i = 0; i < MAX_LIGHTS; i++) {
+         if (dst->Light.Light[i].Enabled) {
+            insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
+         }
+      }
    }
    if (mask & GL_LINE_BIT) {
-      MEMCPY( &dst->Line, &src->Line, sizeof(struct gl_line_attrib) );
+      /* OK to memcpy */
+      dst->Line = src->Line;
    }
    if (mask & GL_LIST_BIT) {
-      MEMCPY( &dst->List, &src->List, sizeof(struct gl_list_attrib) );
+      /* OK to memcpy */
+      dst->List = src->List;
    }
    if (mask & GL_PIXEL_MODE_BIT) {
-      MEMCPY( &dst->Pixel, &src->Pixel, sizeof(struct gl_pixel_attrib) );
+      /* OK to memcpy */
+      dst->Pixel = src->Pixel;
    }
    if (mask & GL_POINT_BIT) {
-      MEMCPY( &dst->Point, &src->Point, sizeof(struct gl_point_attrib) );
+      /* OK to memcpy */
+      dst->Point = src->Point;
    }
    if (mask & GL_POLYGON_BIT) {
-      MEMCPY( &dst->Polygon, &src->Polygon, sizeof(struct gl_polygon_attrib) );
+      /* OK to memcpy */
+      dst->Polygon = src->Polygon;
    }
    if (mask & GL_POLYGON_STIPPLE_BIT) {
       /* Use loop instead of MEMCPY due to problem with Portland Group's
        * C compiler.  Reported by John Stone.
        */
-      int i;
-      for (i=0;i<32;i++) {
+      GLuint i;
+      for (i = 0; i < 32; i++) {
          dst->PolygonStipple[i] = src->PolygonStipple[i];
       }
    }
    if (mask & GL_SCISSOR_BIT) {
-      MEMCPY( &dst->Scissor, &src->Scissor, sizeof(struct gl_scissor_attrib) );
+      /* OK to memcpy */
+      dst->Scissor = src->Scissor;
    }
    if (mask & GL_STENCIL_BUFFER_BIT) {
-      MEMCPY( &dst->Stencil, &src->Stencil, sizeof(struct gl_stencil_attrib) );
+      /* OK to memcpy */
+      dst->Stencil = src->Stencil;
    }
    if (mask & GL_TEXTURE_BIT) {
-      MEMCPY( &dst->Texture, &src->Texture, sizeof(struct gl_texture_attrib) );
+      /* Cannot memcpy because of pointers */
+      _mesa_copy_texture_state(src, dst);
    }
    if (mask & GL_TRANSFORM_BIT) {
-      MEMCPY( &dst->Transform, &src->Transform, sizeof(struct gl_transform_attrib) );
+      /* OK to memcpy */
+      dst->Transform = src->Transform;
    }
    if (mask & GL_VIEWPORT_BIT) {
-      MEMCPY( &dst->Viewport, &src->Viewport, sizeof(struct gl_viewport_attrib) );
+      /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
+      dst->Viewport.X = src->Viewport.X;
+      dst->Viewport.Y = src->Viewport.Y;
+      dst->Viewport.Width = src->Viewport.Width;
+      dst->Viewport.Height = src->Viewport.Height;
+      dst->Viewport.Near = src->Viewport.Near;
+      dst->Viewport.Far = src->Viewport.Far;
+      _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
    }
+
+   /* XXX FIXME:  Call callbacks?
+    */
+   dst->NewState = _NEW_ALL;
 }
 
 
 /*
  * Set the current context, binding the given frame buffer to the context.
  */
-void gl_make_current( GLcontext *newCtx, GLframebuffer *buffer )
+void
+_mesa_make_current( GLcontext *newCtx, GLframebuffer *buffer )
 {
-   gl_make_current2( newCtx, buffer, buffer );
+   _mesa_make_current2( newCtx, buffer, buffer );
 }
 
 
+static void print_info( void )
+{
+   fprintf(stderr, "Mesa GL_VERSION = %s\n",
+	   (char *) _mesa_GetString(GL_VERSION));
+   fprintf(stderr, "Mesa GL_RENDERER = %s\n",
+	   (char *) _mesa_GetString(GL_RENDERER));
+   fprintf(stderr, "Mesa GL_VENDOR = %s\n",
+	   (char *) _mesa_GetString(GL_VENDOR));
+   fprintf(stderr, "Mesa GL_EXTENSIONS = %s\n",
+	   (char *) _mesa_GetString(GL_EXTENSIONS));
+#if defined(THREADS)
+   fprintf(stderr, "Mesa thread-safe: YES\n");
+#else
+   fprintf(stderr, "Mesa thread-safe: NO\n");
+#endif
+#if defined(USE_X86_ASM)
+   fprintf(stderr, "Mesa x86-optimized: YES\n");
+#else
+   fprintf(stderr, "Mesa x86-optimized: NO\n");
+#endif
+#if defined(USE_SPARC_ASM)
+   fprintf(stderr, "Mesa sparc-optimized: YES\n");
+#else
+   fprintf(stderr, "Mesa sparc-optimized: NO\n");
+#endif
+}
+
+
 /*
  * Bind the given context to the given draw-buffer and read-buffer
  * and make it the current context for this thread.
  */
-void gl_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
-                       GLframebuffer *readBuffer )
+void
+_mesa_make_current2( GLcontext *newCtx, GLframebuffer *drawBuffer,
+                     GLframebuffer *readBuffer )
 {
-#if 0
-   GLcontext *oldCtx = gl_get_context();
+   if (MESA_VERBOSE)
+      fprintf(stderr, "_mesa_make_current2()\n");
 
-   /* Flush the old context
+   /* Check that the context's and framebuffer's visuals are compatible.
+    * We could do a lot more checking here but this'll catch obvious
+    * problems.
     */
-   if (oldCtx) {
-      ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(oldCtx, "gl_make_current");
-
-      /* unbind frame buffers from context */
-      if (oldCtx->DrawBuffer) {
-         oldCtx->DrawBuffer = NULL;
-      }
-      if (oldCtx->ReadBuffer) {
-         oldCtx->ReadBuffer = NULL;
+   if (newCtx && drawBuffer && readBuffer) {
+      if (newCtx->Visual.rgbMode != drawBuffer->Visual.rgbMode ||
+          newCtx->Visual.redBits != drawBuffer->Visual.redBits ||
+          newCtx->Visual.depthBits != drawBuffer->Visual.depthBits ||
+          newCtx->Visual.stencilBits != drawBuffer->Visual.stencilBits ||
+          newCtx->Visual.accumRedBits != drawBuffer->Visual.accumRedBits) {
+         return; /* incompatible */
       }
    }
-#endif
 
    /* We call this function periodically (just here for now) in
     * order to detect when multithreading has begun.
@@ -1794,48 +1928,69 @@
    _glapi_check_multithread();
 
    _glapi_set_context((void *) newCtx);
-   ASSERT(gl_get_current_context() == newCtx);
-   if (newCtx) {
-      SET_IMMEDIATE(newCtx, newCtx->input);
-      _glapi_set_dispatch(newCtx->CurrentDispatch);
-   }
-   else {
+   ASSERT(_mesa_get_current_context() == newCtx);
+
+
+   if (!newCtx) {
       _glapi_set_dispatch(NULL);  /* none current */
    }
+   else {
+      _glapi_set_dispatch(newCtx->CurrentDispatch);
 
-   if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n");
+      if (drawBuffer && readBuffer) {
+	 /* TODO: check if newCtx and buffer's visual match??? */
+	 newCtx->DrawBuffer = drawBuffer;
+	 newCtx->ReadBuffer = readBuffer;
+	 newCtx->NewState |= _NEW_BUFFERS;
+
+         if (drawBuffer->Width == 0 && drawBuffer->Height == 0) {
+            /* get initial window size */
+            GLuint bufWidth, bufHeight;
+
+            /* ask device driver for size of output buffer */
+            (*newCtx->Driver.GetBufferSize)( drawBuffer, &bufWidth, &bufHeight );
 
-   if (newCtx && drawBuffer && readBuffer) {
-      /* TODO: check if newCtx and buffer's visual match??? */
-      newCtx->DrawBuffer = drawBuffer;
-      newCtx->ReadBuffer = readBuffer;
-      newCtx->NewState = NEW_ALL;   /* just to be safe */
-      gl_update_state( newCtx );
-   }
+            if (drawBuffer->Width == bufWidth && drawBuffer->Height == bufHeight)
+               return; /* size is as expected */
 
-   /* We can use this to help debug user's problems.  Tell the to set
-    * the MESA_INFO env variable before running their app.  Then the
-    * first time each context is made current we'll print some useful
-    * information.
-    */
-   if (newCtx && newCtx->FirstTimeCurrent) {
-      if (getenv("MESA_INFO")) {
-         fprintf(stderr, "Mesa GL_VERSION = %s\n", (char *) _mesa_GetString(GL_VERSION));
-         fprintf(stderr, "Mesa GL_RENDERER = %s\n", (char *) _mesa_GetString(GL_RENDERER));
-         fprintf(stderr, "Mesa GL_VENDOR = %s\n", (char *) _mesa_GetString(GL_VENDOR));
-         fprintf(stderr, "Mesa GL_EXTENSIONS = %s\n", (char *) _mesa_GetString(GL_EXTENSIONS));
-#if defined(THREADS)
-         fprintf(stderr, "Mesa thread-safe: YES\n");
-#else
-         fprintf(stderr, "Mesa thread-safe: NO\n");
-#endif
-#if defined(USE_X86_ASM)
-         fprintf(stderr, "Mesa x86-optimized: YES\n");
-#else
-         fprintf(stderr, "Mesa x86-optimized: NO\n");
-#endif
+            drawBuffer->Width = bufWidth;
+            drawBuffer->Height = bufHeight;
+
+            newCtx->Driver.ResizeBuffers( drawBuffer );
+         }
+
+         if (readBuffer != drawBuffer &&
+             readBuffer->Width == 0 && readBuffer->Height == 0) {
+            /* get initial window size */
+            GLuint bufWidth, bufHeight;
+
+            /* ask device driver for size of output buffer */
+            (*newCtx->Driver.GetBufferSize)( readBuffer, &bufWidth, &bufHeight );
+
+            if (readBuffer->Width == bufWidth && readBuffer->Height == bufHeight)
+               return; /* size is as expected */
+
+            readBuffer->Width = bufWidth;
+            readBuffer->Height = bufHeight;
+
+            newCtx->Driver.ResizeBuffers( readBuffer );
+         }
       }
-      newCtx->FirstTimeCurrent = GL_FALSE;
+
+      if (newCtx->Driver.MakeCurrent)
+	 newCtx->Driver.MakeCurrent( newCtx, drawBuffer, readBuffer );
+
+      /* We can use this to help debug user's problems.  Tell them to set
+       * the MESA_INFO env variable before running their app.  Then the
+       * first time each context is made current we'll print some useful
+       * information.
+       */
+      if (newCtx->FirstTimeCurrent) {
+	 if (getenv("MESA_INFO")) {
+	    print_info();
+	 }
+	 newCtx->FirstTimeCurrent = GL_FALSE;
+      }
    }
 }
 
@@ -1846,7 +2001,8 @@
  * This isn't the fastest way to get the current context.
  * If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
  */
-GLcontext *gl_get_current_context( void )
+GLcontext *
+_mesa_get_current_context( void )
 {
    return (GLcontext *) _glapi_get_context();
 }
@@ -1860,7 +2016,7 @@
 void
 _mesa_swapbuffers(GLcontext *ctx)
 {
-   FLUSH_VB( ctx, "swap buffers" );
+   FLUSH_VERTICES( ctx, 0 );
 }
 
 
@@ -1887,7 +2043,7 @@
  * This function is called when the Mesa user has stumbled into a code
  * path which may not be implemented fully or correctly.
  */
-void gl_problem( const GLcontext *ctx, const char *s )
+void _mesa_problem( const GLcontext *ctx, const char *s )
 {
    fprintf( stderr, "Mesa implementation error: %s\n", s );
 #ifdef XF86DRI
@@ -1905,23 +2061,10 @@
  * something illogical or if there's likely a bug in their program
  * (like enabled depth testing without a depth buffer).
  */
-void gl_warning( const GLcontext *ctx, const char *s )
+void
+_mesa_warning( const GLcontext *ctx, const char *s )
 {
-   GLboolean debug;
-#ifdef DEBUG
-   debug = GL_TRUE;
-#else
-   if (getenv("MESA_DEBUG")) {
-      debug = GL_TRUE;
-   }
-   else {
-      debug = GL_FALSE;
-   }
-#endif
-   if (debug) {
-      fprintf( stderr, "Mesa warning: %s\n", s );
-   }
-   (void) ctx;
+   (*ctx->imports.warning)((__GLcontext *) ctx, (char *) s);
 }
 
 
@@ -1929,13 +2072,14 @@
 /*
  * Compile an error into current display list.
  */
-void gl_compile_error( GLcontext *ctx, GLenum error, const char *s )
+void
+_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s )
 {
    if (ctx->CompileFlag)
-      gl_save_error( ctx, error, s );
+      _mesa_save_error( ctx, error, s );
 
    if (ctx->ExecuteFlag)
-      gl_error( ctx, error, s );
+      _mesa_error( ctx, error, s );
 }
 
 
@@ -1950,7 +2094,7 @@
  *         where - usually the name of function where error was detected
  */
 void
-gl_error( GLcontext *ctx, GLenum error, const char *where )
+_mesa_error( GLcontext *ctx, GLenum error, const char *where )
 {
    const char *debugEnv = getenv("MESA_DEBUG");
    GLboolean debug;
@@ -2001,6 +2145,9 @@
       fprintf(stderr, "Mesa user error: %s in %s\n", errstr, where);
    }
 
+   if (!ctx)
+      return;
+
    if (ctx->ErrorValue == GL_NO_ERROR) {
       ctx->ErrorValue = error;
    }
@@ -2017,7 +2164,7 @@
 _mesa_Finish( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFinish");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    if (ctx->Driver.Finish) {
       (*ctx->Driver.Finish)( ctx );
    }
@@ -2029,8 +2176,26 @@
 _mesa_Flush( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFlush");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    if (ctx->Driver.Flush) {
       (*ctx->Driver.Flush)( ctx );
    }
 }
+
+
+
+const char *_mesa_prim_name[GL_POLYGON+4] = {
+   "GL_POINTS",
+   "GL_LINES",
+   "GL_LINE_LOOP",
+   "GL_LINE_STRIP",
+   "GL_TRIANGLES",
+   "GL_TRIANGLE_STRIP",
+   "GL_TRIANGLE_FAN",
+   "GL_QUADS",
+   "GL_QUAD_STRIP",
+   "GL_POLYGON",
+   "outside begin/end",
+   "inside unkown primitive",
+   "unknown state"
+};
Index: xc/extras/Mesa/src/context.h
diff -u xc/extras/Mesa/src/context.h:1.4 xc/extras/Mesa/src/context.h:1.5
--- xc/extras/Mesa/src/context.h:1.4	Fri Jun 16 20:02:08 2000
+++ xc/extras/Mesa/src/context.h	Fri Feb 22 14:25:25 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -29,7 +29,7 @@
 
 
 #include "glapi.h"
-#include "types.h"
+#include "mtypes.h"
 
 
 /*
@@ -91,27 +91,9 @@
                          GLint accumAlphaBits,
                          GLint numSamples );
 
-/* this function is obsolete */
-extern GLvisual *
-gl_create_visual( GLboolean rgbFlag,
-                  GLboolean alphaFlag,
-                  GLboolean dbFlag,
-                  GLboolean stereoFlag,
-                  GLint depthBits,
-                  GLint stencilBits,
-                  GLint accumBits,
-                  GLint indexBits,
-                  GLint redBits,
-                  GLint greenBits,
-                  GLint blueBits,
-                  GLint alphaBits );
-
-
 extern void
 _mesa_destroy_visual( GLvisual *vis );
 
-/*obsolete */ extern void gl_destroy_visual( GLvisual *vis );
-
 
 
 /*
@@ -120,22 +102,25 @@
  * single entity.
  */
 extern GLframebuffer *
-gl_create_framebuffer( GLvisual *visual,
-                       GLboolean softwareDepth,
-                       GLboolean softwareStencil,
-                       GLboolean softwareAccum,
-                       GLboolean softwareAlpha );
+_mesa_create_framebuffer( const GLvisual *visual,
+                          GLboolean softwareDepth,
+                          GLboolean softwareStencil,
+                          GLboolean softwareAccum,
+                          GLboolean softwareAlpha );
 
 extern void
 _mesa_initialize_framebuffer( GLframebuffer *fb,
-                              GLvisual *visual,
+                              const GLvisual *visual,
                               GLboolean softwareDepth,
                               GLboolean softwareStencil,
                               GLboolean softwareAccum,
                               GLboolean softwareAlpha );
 
+extern void
+_mesa_free_framebuffer_data( GLframebuffer *buffer );
+
 extern void
-gl_destroy_framebuffer( GLframebuffer *buffer );
+_mesa_destroy_framebuffer( GLframebuffer *buffer );
 
 
 
@@ -144,75 +129,54 @@
  * contains the rendering state.
  */
 extern GLcontext *
-gl_create_context( GLvisual *visual,
-                   GLcontext *share_list,
-                   void *driver_ctx,
-                   GLboolean direct);
+_mesa_create_context( const GLvisual *visual,
+                      GLcontext *share_list,
+                      void *driver_ctx,
+                      GLboolean direct);
 
 extern GLboolean
 _mesa_initialize_context( GLcontext *ctx,
-                          GLvisual *visual,
+                          const GLvisual *visual,
                           GLcontext *share_list,
                           void *driver_ctx,
                           GLboolean direct );
 
 extern void
-gl_free_context_data( GLcontext *ctx );
+_mesa_free_context_data( GLcontext *ctx );
 
 extern void
-gl_destroy_context( GLcontext *ctx );
+_mesa_destroy_context( GLcontext *ctx );
 
 
 extern void
-gl_context_initialize( GLcontext *ctx );
+_mesa_copy_context(const GLcontext *src, GLcontext *dst, GLuint mask);
 
 
 extern void
-gl_copy_context(const GLcontext *src, GLcontext *dst, GLuint mask);
+_mesa_make_current( GLcontext *ctx, GLframebuffer *buffer );
 
 
 extern void
-gl_make_current( GLcontext *ctx, GLframebuffer *buffer );
-
+_mesa_make_current2( GLcontext *ctx, GLframebuffer *drawBuffer,
+                     GLframebuffer *readBuffer );
 
-extern void
-gl_make_current2( GLcontext *ctx, GLframebuffer *drawBuffer,
-                  GLframebuffer *readBuffer );
 
-
 extern GLcontext *
-gl_get_current_context(void);
+_mesa_get_current_context(void);
 
 
 
 /*
- * Macros for fetching current context, input buffer, etc.
+ * Macros for fetching current context.
  */
 #ifdef THREADS
 
 #define GET_CURRENT_CONTEXT(C)	GLcontext *C = (GLcontext *) (_glapi_Context ? _glapi_Context : _glapi_get_context())
 
-#define GET_IMMEDIATE  struct immediate *IM = ((GLcontext *) (_glapi_Context ? _glapi_Context : _glapi_get_context()))->input
-
-#define SET_IMMEDIATE(ctx, im)		\
-do {					\
-   ctx->input = im;			\
-} while (0)
-
 #else
 
-extern struct immediate *_mesa_CurrentInput;
-
 #define GET_CURRENT_CONTEXT(C)  GLcontext *C = (GLcontext *) _glapi_Context
 
-#define GET_IMMEDIATE struct immediate *IM = _mesa_CurrentInput
-
-#define SET_IMMEDIATE(ctx, im)		\
-do {					\
-   ctx->input = im;			\
-   _mesa_CurrentInput = im;		\
-} while (0)
-
 #endif
 
 
@@ -231,16 +195,16 @@
  */
 
 extern void
-gl_problem( const GLcontext *ctx, const char *s );
+_mesa_problem( const GLcontext *ctx, const char *s );
 
 extern void
-gl_warning( const GLcontext *ctx, const char *s );
+_mesa_warning( const GLcontext *ctx, const char *s );
 
 extern void
-gl_error( GLcontext *ctx, GLenum error, const char *s );
+_mesa_error( GLcontext *ctx, GLenum error, const char *s );
 
 extern void
-gl_compile_error( GLcontext *ctx, GLenum error, const char *s );
+_mesa_compile_error( GLcontext *ctx, GLenum error, const char *s );
 
 
 
@@ -250,6 +214,14 @@
 extern void
 _mesa_Flush( void );
 
+
+
+extern void
+_mesa_read_config_file(GLcontext *ctx);
+
+extern void
+_mesa_register_config_var(const char *name,
+                          void (*notify)( const char *, int ));
 
 
 #endif
Index: xc/extras/Mesa/src/convolve.c
diff -u xc/extras/Mesa/src/convolve.c:1.2 xc/extras/Mesa/src/convolve.c:1.4
--- xc/extras/Mesa/src/convolve.c:1.2	Mon Nov 13 18:30:42 2000
+++ xc/extras/Mesa/src/convolve.c	Mon Sep  9 17:07:14 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  4.0.2
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -36,18 +36,865 @@
 #include "all.h"
 #else
 #include "glheader.h"
-#include "types.h"
+#include "colormac.h"
+#include "convolve.h"
+#include "context.h"
+#include "image.h"
+#include "mtypes.h"
+#include "state.h"
+#include "swrast/s_span.h" /* XXX SWRAST hack */
 #endif
 
 
+/*
+ * Given an internalFormat token passed to glConvolutionFilter
+ * or glSeparableFilter, return the corresponding base format.
+ * Return -1 if invalid token.
+ */
+static GLint
+base_filter_format( GLenum format )
+{
+   switch (format) {
+      case GL_ALPHA:
+      case GL_ALPHA4:
+      case GL_ALPHA8:
+      case GL_ALPHA12:
+      case GL_ALPHA16:
+         return GL_ALPHA;
+      case GL_LUMINANCE:
+      case GL_LUMINANCE4:
+      case GL_LUMINANCE8:
+      case GL_LUMINANCE12:
+      case GL_LUMINANCE16:
+         return GL_LUMINANCE;
+      case GL_LUMINANCE_ALPHA:
+      case GL_LUMINANCE4_ALPHA4:
+      case GL_LUMINANCE6_ALPHA2:
+      case GL_LUMINANCE8_ALPHA8:
+      case GL_LUMINANCE12_ALPHA4:
+      case GL_LUMINANCE12_ALPHA12:
+      case GL_LUMINANCE16_ALPHA16:
+         return GL_LUMINANCE_ALPHA;
+      case GL_INTENSITY:
+      case GL_INTENSITY4:
+      case GL_INTENSITY8:
+      case GL_INTENSITY12:
+      case GL_INTENSITY16:
+         return GL_INTENSITY;
+      case GL_RGB:
+      case GL_R3_G3_B2:
+      case GL_RGB4:
+      case GL_RGB5:
+      case GL_RGB8:
+      case GL_RGB10:
+      case GL_RGB12:
+      case GL_RGB16:
+         return GL_RGB;
+      case 4:
+      case GL_RGBA:
+      case GL_RGBA2:
+      case GL_RGBA4:
+      case GL_RGB5_A1:
+      case GL_RGBA8:
+      case GL_RGB10_A2:
+      case GL_RGBA12:
+      case GL_RGBA16:
+         return GL_RGBA;
+      default:
+         return -1;  /* error */
+   }
+}
+
+
+void
+_mesa_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
+{
+   GLint baseFormat;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (target != GL_CONVOLUTION_1D) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(target)");
+      return;
+   }
+
+   baseFormat = base_filter_format(internalFormat);
+   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(internalFormat)");
+      return;
+   }
+
+   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter1D(width)");
+      return;
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glConvolutionFilter1D(format or type)");
+      return;
+   }
+
+   if (format == GL_COLOR_INDEX ||
+       format == GL_STENCIL_INDEX ||
+       format == GL_DEPTH_COMPONENT ||
+       format == GL_INTENSITY ||
+       type == GL_BITMAP) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(format or type)");
+      return;
+   }
+
+   ctx->Convolution1D.Format = format;
+   ctx->Convolution1D.InternalFormat = internalFormat;
+   ctx->Convolution1D.Width = width;
+   ctx->Convolution1D.Height = 1;
+
+   /* unpack filter image */
+   _mesa_unpack_float_color_span(ctx, width, GL_RGBA,
+                                 ctx->Convolution1D.Filter,
+                                 format, type, image, &ctx->Unpack,
+                                 0, GL_FALSE);
+
+   /* apply scale and bias */
+   {
+      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[0];
+      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[0];
+      GLint i;
+      for (i = 0; i < width; i++) {
+         GLfloat r = ctx->Convolution1D.Filter[i * 4 + 0];
+         GLfloat g = ctx->Convolution1D.Filter[i * 4 + 1];
+         GLfloat b = ctx->Convolution1D.Filter[i * 4 + 2];
+         GLfloat a = ctx->Convolution1D.Filter[i * 4 + 3];
+         r = r * scale[0] + bias[0];
+         g = g * scale[1] + bias[1];
+         b = b * scale[2] + bias[2];
+         a = a * scale[3] + bias[3];
+         ctx->Convolution1D.Filter[i * 4 + 0] = r;
+         ctx->Convolution1D.Filter[i * 4 + 1] = g;
+         ctx->Convolution1D.Filter[i * 4 + 2] = b;
+         ctx->Convolution1D.Filter[i * 4 + 3] = a;
+      }
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_ConvolutionFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
+{
+   GLint baseFormat;
+   GLint i, components;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (target != GL_CONVOLUTION_2D) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(target)");
+      return;
+   }
+
+   baseFormat = base_filter_format(internalFormat);
+   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(internalFormat)");
+      return;
+   }
+
+   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter2D(width)");
+      return;
+   }
+   if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter2D(height)");
+      return;
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glConvolutionFilter2D(format or type)");
+      return;
+   }
+   if (format == GL_COLOR_INDEX ||
+       format == GL_STENCIL_INDEX ||
+       format == GL_DEPTH_COMPONENT ||
+       format == GL_INTENSITY ||
+       type == GL_BITMAP) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(format or type)");
+      return;
+   }
+
+   components = _mesa_components_in_format(format);
+   assert(components > 0);  /* this should have been caught earlier */
+
+   ctx->Convolution2D.Format = format;
+   ctx->Convolution2D.InternalFormat = internalFormat;
+   ctx->Convolution2D.Width = width;
+   ctx->Convolution2D.Height = height;
+
+   /* Unpack filter image.  We always store filters in RGBA format. */
+   for (i = 0; i < height; i++) {
+      const GLvoid *src = _mesa_image_address(&ctx->Unpack, image, width,
+                                              height, format, type, 0, i, 0);
+      GLfloat *dst = ctx->Convolution2D.Filter + i * width * 4;
+      _mesa_unpack_float_color_span(ctx, width, GL_RGBA, dst,
+                                    format, type, src, &ctx->Unpack,
+                                    0, GL_FALSE);
+   }
+
+   /* apply scale and bias */
+   {
+      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[1];
+      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[1];
+      for (i = 0; i < width * height; i++) {
+         GLfloat r = ctx->Convolution2D.Filter[i * 4 + 0];
+         GLfloat g = ctx->Convolution2D.Filter[i * 4 + 1];
+         GLfloat b = ctx->Convolution2D.Filter[i * 4 + 2];
+         GLfloat a = ctx->Convolution2D.Filter[i * 4 + 3];
+         r = r * scale[0] + bias[0];
+         g = g * scale[1] + bias[1];
+         b = b * scale[2] + bias[2];
+         a = a * scale[3] + bias[3];
+         ctx->Convolution2D.Filter[i * 4 + 0] = r;
+         ctx->Convolution2D.Filter[i * 4 + 1] = g;
+         ctx->Convolution2D.Filter[i * 4 + 2] = b;
+         ctx->Convolution2D.Filter[i * 4 + 3] = a;
+      }
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint c;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   switch (target) {
+      case GL_CONVOLUTION_1D:
+         c = 0;
+         break;
+      case GL_CONVOLUTION_2D:
+         c = 1;
+         break;
+      case GL_SEPARABLE_2D:
+         c = 2;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(target)");
+         return;
+   }
+
+   switch (pname) {
+      case GL_CONVOLUTION_BORDER_MODE:
+         if (param == (GLfloat) GL_REDUCE ||
+             param == (GLfloat) GL_CONSTANT_BORDER ||
+             param == (GLfloat) GL_REPLICATE_BORDER) {
+            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) param;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(params)");
+            return;
+         }
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(pname)");
+         return;
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_convolution_attrib *conv;
+   GLuint c;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   switch (target) {
+      case GL_CONVOLUTION_1D:
+         c = 0;
+         conv = &ctx->Convolution1D;
+         break;
+      case GL_CONVOLUTION_2D:
+         c = 1;
+         conv = &ctx->Convolution2D;
+         break;
+      case GL_SEPARABLE_2D:
+         c = 2;
+         conv = &ctx->Separable2D;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(target)");
+         return;
+   }
+
+   switch (pname) {
+      case GL_CONVOLUTION_BORDER_COLOR:
+         COPY_4V(ctx->Pixel.ConvolutionBorderColor[c], params);
+         break;
+      case GL_CONVOLUTION_BORDER_MODE:
+         if (params[0] == (GLfloat) GL_REDUCE ||
+             params[0] == (GLfloat) GL_CONSTANT_BORDER ||
+             params[0] == (GLfloat) GL_REPLICATE_BORDER) {
+            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) params[0];
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(params)");
+            return;
+         }
+         break;
+      case GL_CONVOLUTION_FILTER_SCALE:
+         COPY_4V(ctx->Pixel.ConvolutionFilterScale[c], params);
+         break;
+      case GL_CONVOLUTION_FILTER_BIAS:
+         COPY_4V(ctx->Pixel.ConvolutionFilterBias[c], params);
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(pname)");
+         return;
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint c;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   switch (target) {
+      case GL_CONVOLUTION_1D:
+         c = 0;
+         break;
+      case GL_CONVOLUTION_2D:
+         c = 1;
+         break;
+      case GL_SEPARABLE_2D:
+         c = 2;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(target)");
+         return;
+   }
+
+   switch (pname) {
+      case GL_CONVOLUTION_BORDER_MODE:
+         if (param == (GLint) GL_REDUCE ||
+             param == (GLint) GL_CONSTANT_BORDER ||
+             param == (GLint) GL_REPLICATE_BORDER) {
+            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) param;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(params)");
+            return;
+         }
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(pname)");
+         return;
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_convolution_attrib *conv;
+   GLuint c;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   switch (target) {
+      case GL_CONVOLUTION_1D:
+         c = 0;
+         conv = &ctx->Convolution1D;
+         break;
+      case GL_CONVOLUTION_2D:
+         c = 1;
+         conv = &ctx->Convolution2D;
+         break;
+      case GL_SEPARABLE_2D:
+         c = 2;
+         conv = &ctx->Separable2D;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(target)");
+         return;
+   }
+
+   switch (pname) {
+      case GL_CONVOLUTION_BORDER_COLOR:
+	 ctx->Pixel.ConvolutionBorderColor[c][0] = INT_TO_FLOAT(params[0]);
+	 ctx->Pixel.ConvolutionBorderColor[c][1] = INT_TO_FLOAT(params[1]);
+	 ctx->Pixel.ConvolutionBorderColor[c][2] = INT_TO_FLOAT(params[2]);
+	 ctx->Pixel.ConvolutionBorderColor[c][3] = INT_TO_FLOAT(params[3]);
+         break;
+      case GL_CONVOLUTION_BORDER_MODE:
+         if (params[0] == (GLint) GL_REDUCE ||
+             params[0] == (GLint) GL_CONSTANT_BORDER ||
+             params[0] == (GLint) GL_REPLICATE_BORDER) {
+            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) params[0];
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(params)");
+            return;
+         }
+         break;
+      case GL_CONVOLUTION_FILTER_SCALE:
+	 /* COPY_4V(ctx->Pixel.ConvolutionFilterScale[c], params); */
+	 /* need cast to prevent compiler warnings */  
+	 ctx->Pixel.ConvolutionFilterScale[c][0] = (GLfloat) params[0]; 
+	 ctx->Pixel.ConvolutionFilterScale[c][1] = (GLfloat) params[1]; 
+	 ctx->Pixel.ConvolutionFilterScale[c][2] = (GLfloat) params[2]; 
+	 ctx->Pixel.ConvolutionFilterScale[c][3] = (GLfloat) params[3]; 
+         break;
+      case GL_CONVOLUTION_FILTER_BIAS:
+	 /* COPY_4V(ctx->Pixel.ConvolutionFilterBias[c], params); */
+	 /* need cast to prevent compiler warnings */  
+	 ctx->Pixel.ConvolutionFilterBias[c][0] = (GLfloat) params[0]; 
+	 ctx->Pixel.ConvolutionFilterBias[c][1] = (GLfloat) params[1]; 
+	 ctx->Pixel.ConvolutionFilterBias[c][2] = (GLfloat) params[2]; 
+	 ctx->Pixel.ConvolutionFilterBias[c][3] = (GLfloat) params[3]; 
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(pname)");
+         return;
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width)
+{
+   GLint baseFormat;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (target != GL_CONVOLUTION_1D) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter1D(target)");
+      return;
+   }
+
+   baseFormat = base_filter_format(internalFormat);
+   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter1D(internalFormat)");
+      return;
+   }
+
+   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter1D(width)");
+      return;
+   }
+
+   ctx->Driver.CopyConvolutionFilter1D( ctx, target, 
+					internalFormat, x, y, width);
+}
+
+
+void
+_mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+   GLint baseFormat;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (target != GL_CONVOLUTION_2D) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter2D(target)");
+      return;
+   }
+
+   baseFormat = base_filter_format(internalFormat);
+   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter2D(internalFormat)");
+      return;
+   }
+
+   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter2D(width)");
+      return;
+   }
+   if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter2D(height)");
+      return;
+   }
+
+   ctx->Driver.CopyConvolutionFilter2D( ctx, target, internalFormat, x, y, 
+					width, height );
+
+}
+
+
+void
+_mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
+{
+   const struct gl_convolution_attrib *filter;
+   GLuint row;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->NewState) {
+      _mesa_update_state(ctx);
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetConvolutionFilter(format or type)");
+      return;
+   }
+
+   if (format == GL_COLOR_INDEX ||
+       format == GL_STENCIL_INDEX ||
+       format == GL_DEPTH_COMPONENT ||
+       format == GL_INTENSITY ||
+       type == GL_BITMAP) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(format or type)");
+      return;
+   }
+
+   switch (target) {
+      case GL_CONVOLUTION_1D:
+         filter = &(ctx->Convolution1D);
+         break;
+      case GL_CONVOLUTION_2D:
+         filter = &(ctx->Convolution2D);
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(target)");
+         return;
+   }
+
+   for (row = 0; row < filter->Height; row++) {
+      GLvoid *dst = _mesa_image_address( &ctx->Pack, image, filter->Width,
+                                         filter->Height, format, type,
+                                         0, row, 0);
+      const GLfloat *src = filter->Filter + row * filter->Width * 4;
+      _mesa_pack_float_rgba_span(ctx, filter->Width,
+                                 (const GLfloat (*)[4]) src,
+                                 format, type, dst, &ctx->Pack, 0);
+   }
+}
+
+
 void
-_mesa_convolve_1d_reduce(GLint srcWidth, const GLfloat src[][4],
-                         GLint filterWidth, const GLfloat filter[][4],
-                         GLfloat dest[][4])
+_mesa_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-   const GLint dstWidth = srcWidth - (filterWidth - 1);
+   GET_CURRENT_CONTEXT(ctx);
+   const struct gl_convolution_attrib *conv;
+   GLuint c;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   switch (target) {
+      case GL_CONVOLUTION_1D:
+         c = 0;
+         conv = &ctx->Convolution1D;
+         break;
+      case GL_CONVOLUTION_2D:
+         c = 1;
+         conv = &ctx->Convolution2D;
+         break;
+      case GL_SEPARABLE_2D:
+         c = 2;
+         conv = &ctx->Separable2D;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameterfv(target)");
+         return;
+   }
+
+   switch (pname) {
+      case GL_CONVOLUTION_BORDER_COLOR:
+         COPY_4V(params, ctx->Pixel.ConvolutionBorderColor[c]);
+         break;
+      case GL_CONVOLUTION_BORDER_MODE:
+         *params = (GLfloat) ctx->Pixel.ConvolutionBorderMode[c];
+         break;
+      case GL_CONVOLUTION_FILTER_SCALE:
+         COPY_4V(params, ctx->Pixel.ConvolutionFilterScale[c]);
+         break;
+      case GL_CONVOLUTION_FILTER_BIAS:
+         COPY_4V(params, ctx->Pixel.ConvolutionFilterBias[c]);
+         break;
+      case GL_CONVOLUTION_FORMAT:
+         *params = (GLfloat) conv->Format;
+         break;
+      case GL_CONVOLUTION_WIDTH:
+         *params = (GLfloat) conv->Width;
+         break;
+      case GL_CONVOLUTION_HEIGHT:
+         *params = (GLfloat) conv->Height;
+         break;
+      case GL_MAX_CONVOLUTION_WIDTH:
+         *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
+         break;
+      case GL_MAX_CONVOLUTION_HEIGHT:
+         *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameterfv(pname)");
+         return;
+   }
+}
+
+
+void
+_mesa_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const struct gl_convolution_attrib *conv;
+   GLuint c;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   switch (target) {
+      case GL_CONVOLUTION_1D:
+         c = 0;
+         conv = &ctx->Convolution1D;
+         break;
+      case GL_CONVOLUTION_2D:
+         c = 1;
+         conv = &ctx->Convolution2D;
+         break;
+      case GL_SEPARABLE_2D:
+         c = 2;
+         conv = &ctx->Separable2D;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(target)");
+         return;
+   }
+
+   switch (pname) {
+      case GL_CONVOLUTION_BORDER_COLOR:
+         params[0] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][0]);
+         params[1] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][1]);
+         params[2] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][2]);
+         params[3] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][3]);
+         break;
+      case GL_CONVOLUTION_BORDER_MODE:
+         *params = (GLint) ctx->Pixel.ConvolutionBorderMode[c];
+         break;
+      case GL_CONVOLUTION_FILTER_SCALE:
+         params[0] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][0];
+         params[1] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][1];
+         params[2] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][2];
+         params[3] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][3];
+         break;
+      case GL_CONVOLUTION_FILTER_BIAS:
+         params[0] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][0];
+         params[1] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][1];
+         params[2] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][2];
+         params[3] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][3];
+         break;
+      case GL_CONVOLUTION_FORMAT:
+         *params = (GLint) conv->Format;
+         break;
+      case GL_CONVOLUTION_WIDTH:
+         *params = (GLint) conv->Width;
+         break;
+      case GL_CONVOLUTION_HEIGHT:
+         *params = (GLint) conv->Height;
+         break;
+      case GL_MAX_CONVOLUTION_WIDTH:
+         *params = (GLint) ctx->Const.MaxConvolutionWidth;
+         break;
+      case GL_MAX_CONVOLUTION_HEIGHT:
+         *params = (GLint) ctx->Const.MaxConvolutionHeight;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(pname)");
+         return;
+   }
+}
+
+
+void
+_mesa_GetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
+{
+   const GLint colStart = MAX_CONVOLUTION_WIDTH * 4;
+   const struct gl_convolution_attrib *filter;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->NewState) {
+      _mesa_update_state(ctx);
+   }
+
+   if (target != GL_SEPARABLE_2D) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetSeparableFilter(target)");
+      return;
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetConvolutionFilter(format or type)");
+      return;
+   }
+
+   if (format == GL_COLOR_INDEX ||
+       format == GL_STENCIL_INDEX ||
+       format == GL_DEPTH_COMPONENT ||
+       format == GL_INTENSITY ||
+       type == GL_BITMAP) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(format or type)");
+      return;
+   }
+
+   filter = &ctx->Separable2D;
+
+   /* Row filter */
+   {
+      GLvoid *dst = _mesa_image_address( &ctx->Pack, row, filter->Width,
+                                         filter->Height, format, type,
+                                         0, 0, 0);
+      _mesa_pack_float_rgba_span(ctx, filter->Width,
+                                 (const GLfloat (*)[4]) filter->Filter,
+                                 format, type, dst, &ctx->Pack, 0);
+   }
+
+   /* Column filter */
+   {
+      GLvoid *dst = _mesa_image_address( &ctx->Pack, column, filter->Width,
+                                         1, format, type,
+                                         0, 0, 0);
+      const GLfloat *src = filter->Filter + colStart;
+      _mesa_pack_float_rgba_span(ctx, filter->Height,
+                                 (const GLfloat (*)[4]) src,
+                                 format, type, dst, &ctx->Pack, 0);
+   }
+
+   (void) span;  /* unused at this time */
+}
+
+
+void
+_mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
+{
+   const GLint colStart = MAX_CONVOLUTION_WIDTH * 4;
+   GLint baseFormat;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (target != GL_SEPARABLE_2D) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(target)");
+      return;
+   }
+
+   baseFormat = base_filter_format(internalFormat);
+   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(internalFormat)");
+      return;
+   }
+
+   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glSeparableFilter2D(width)");
+      return;
+   }
+   if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glSeparableFilter2D(height)");
+      return;
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glSeparableFilter2D(format or type)");
+      return;
+   }
+
+   if (format == GL_COLOR_INDEX ||
+       format == GL_STENCIL_INDEX ||
+       format == GL_DEPTH_COMPONENT ||
+       format == GL_INTENSITY ||
+       type == GL_BITMAP) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(format or type)");
+      return;
+   }
+
+   ctx->Separable2D.Format = format;
+   ctx->Separable2D.InternalFormat = internalFormat;
+   ctx->Separable2D.Width = width;
+   ctx->Separable2D.Height = height;
+
+   /* unpack row filter */
+   _mesa_unpack_float_color_span(ctx, width, GL_RGBA,
+                                 ctx->Separable2D.Filter,
+                                 format, type, row, &ctx->Unpack,
+                                 0, GL_FALSE);
+
+   /* apply scale and bias */
+   {
+      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[2];
+      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[2];
+      GLint i;
+      for (i = 0; i < width; i++) {
+         GLfloat r = ctx->Separable2D.Filter[i * 4 + 0];
+         GLfloat g = ctx->Separable2D.Filter[i * 4 + 1];
+         GLfloat b = ctx->Separable2D.Filter[i * 4 + 2];
+         GLfloat a = ctx->Separable2D.Filter[i * 4 + 3];
+         r = r * scale[0] + bias[0];
+         g = g * scale[1] + bias[1];
+         b = b * scale[2] + bias[2];
+         a = a * scale[3] + bias[3];
+         ctx->Separable2D.Filter[i * 4 + 0] = r;
+         ctx->Separable2D.Filter[i * 4 + 1] = g;
+         ctx->Separable2D.Filter[i * 4 + 2] = b;
+         ctx->Separable2D.Filter[i * 4 + 3] = a;
+      }
+   }
+
+   /* unpack column filter */
+   _mesa_unpack_float_color_span(ctx, width, GL_RGBA,
+                                 &ctx->Separable2D.Filter[colStart],
+                                 format, type, column, &ctx->Unpack,
+                                 0, GL_FALSE);
+
+   /* apply scale and bias */
+   {
+      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[2];
+      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[2];
+      GLint i;
+      for (i = 0; i < width; i++) {
+         GLfloat r = ctx->Separable2D.Filter[i * 4 + 0 + colStart];
+         GLfloat g = ctx->Separable2D.Filter[i * 4 + 1 + colStart];
+         GLfloat b = ctx->Separable2D.Filter[i * 4 + 2 + colStart];
+         GLfloat a = ctx->Separable2D.Filter[i * 4 + 3 + colStart];
+         r = r * scale[0] + bias[0];
+         g = g * scale[1] + bias[1];
+         b = b * scale[2] + bias[2];
+         a = a * scale[3] + bias[3];
+         ctx->Separable2D.Filter[i * 4 + 0 + colStart] = r;
+         ctx->Separable2D.Filter[i * 4 + 1 + colStart] = g;
+         ctx->Separable2D.Filter[i * 4 + 2 + colStart] = b;
+         ctx->Separable2D.Filter[i * 4 + 3 + colStart] = a;
+      }
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+/**********************************************************************/
+/***                   image convolution functions                  ***/
+/**********************************************************************/
+
+static void
+convolve_1d_reduce(GLint srcWidth, const GLfloat src[][4],
+                   GLint filterWidth, const GLfloat filter[][4],
+                   GLfloat dest[][4])
+{
+   GLint dstWidth;
    GLint i, n;
 
+   if (filterWidth >= 1)
+      dstWidth = srcWidth - (filterWidth - 1);
+   else
+      dstWidth = srcWidth;
+
    if (dstWidth <= 0)
       return;  /* null result */
 
@@ -70,10 +917,11 @@
 }
 
 
-void
-_mesa_convolve_1d_constant(GLint srcWidth, const GLfloat src[][4],
-                           GLint filterWidth, const GLfloat filter[][4],
-                           const GLfloat borderColor[4], GLfloat dest[][4])
+static void
+convolve_1d_constant(GLint srcWidth, const GLfloat src[][4],
+                     GLint filterWidth, const GLfloat filter[][4],
+                     GLfloat dest[][4],
+                     const GLfloat borderColor[4])
 {
    const GLint halfFilterWidth = filterWidth / 2;
    GLint i, n;
@@ -105,10 +953,10 @@
 }
 
 
-void
-_mesa_convolve_1d_replicate(GLint srcWidth, const GLfloat src[][4],
-                            GLint filterWidth, const GLfloat filter[][4],
-                            GLfloat dest[][4])
+static void
+convolve_1d_replicate(GLint srcWidth, const GLfloat src[][4],
+                      GLint filterWidth, const GLfloat filter[][4],
+                      GLfloat dest[][4])
 {
    const GLint halfFilterWidth = filterWidth / 2;
    GLint i, n;
@@ -146,270 +994,433 @@
 }
 
 
-/*
- * <src> is the source image width width = srcWidth, height = filterHeight.
- * <filter> has width <filterWidth> and height <filterHeight>.
- * <dst> is a 1-D image span of width <srcWidth> - (<filterWidth> - 1).
- */
-void
-_mesa_convolve_2d_reduce(GLint srcWidth, GLint srcHeight,
-                         const GLfloat src[][4],
-                         GLint filterWidth, GLint filterHeight,
-                         const GLfloat filter[][4],
-                         GLfloat dest[][4])
+static void
+convolve_2d_reduce(GLint srcWidth, GLint srcHeight,
+                   const GLfloat src[][4],
+                   GLint filterWidth, GLint filterHeight,
+                   const GLfloat filter[][4],
+                   GLfloat dest[][4])
 {
-   const GLint dstWidth = srcWidth - (filterWidth - 1);
-   GLint i, n, m;
+   GLint dstWidth, dstHeight;
+   GLint i, j, n, m;
 
-   if (dstWidth <= 0)
-      return;  /* null result */
-
-   /* XXX todo */
-   for (i = 0; i < dstWidth; i++) {
-      GLfloat sumR = 0.0;
-      GLfloat sumG = 0.0;
-      GLfloat sumB = 0.0;
-      GLfloat sumA = 0.0;
-      for (n = 0; n < filterHeight; n++) {
-         for (m = 0; m < filterWidth; m++) {
-            const GLint k = n * srcWidth + i + m;
-            sumR += src[k][RCOMP] * filter[n][RCOMP];
-            sumG += src[k][GCOMP] * filter[n][GCOMP];
-            sumB += src[k][BCOMP] * filter[n][BCOMP];
-            sumA += src[k][ACOMP] * filter[n][ACOMP];
+   if (filterWidth >= 1)
+      dstWidth = srcWidth - (filterWidth - 1);
+   else
+      dstWidth = srcWidth;
+
+   if (filterHeight >= 1)
+      dstHeight = srcHeight - (filterHeight - 1);
+   else
+      dstHeight = srcHeight;
+
+   if (dstWidth <= 0 || dstHeight <= 0)
+      return;
+
+   for (j = 0; j < dstHeight; j++) {
+      for (i = 0; i < dstWidth; i++) {
+         GLfloat sumR = 0.0;
+         GLfloat sumG = 0.0;
+         GLfloat sumB = 0.0;
+         GLfloat sumA = 0.0;
+         for (m = 0; m < filterHeight; m++) {
+            for (n = 0; n < filterWidth; n++) {
+               const GLint k = (j + m) * srcWidth + i + n;
+               const GLint f = m * filterWidth + n;
+               sumR += src[k][RCOMP] * filter[f][RCOMP];
+               sumG += src[k][GCOMP] * filter[f][GCOMP];
+               sumB += src[k][BCOMP] * filter[f][BCOMP];
+               sumA += src[k][ACOMP] * filter[f][ACOMP];
+            }
          }
+         dest[j * dstWidth + i][RCOMP] = sumR;
+         dest[j * dstWidth + i][GCOMP] = sumG;
+         dest[j * dstWidth + i][BCOMP] = sumB;
+         dest[j * dstWidth + i][ACOMP] = sumA;
       }
-      dest[i][RCOMP] = sumR;
-      dest[i][GCOMP] = sumG;
-      dest[i][BCOMP] = sumB;
-      dest[i][ACOMP] = sumA;
    }
 }
 
 
-void
-_mesa_convolve_2d_constant(GLint srcWidth, GLint srcHeight,
-                           const GLfloat src[][4],
-                           GLint filterWidth, GLint filterHeight,
-                           const GLfloat filter[][4],
-                           GLfloat dest[][4],
-                           const GLfloat borderColor[4])
+static void
+convolve_2d_constant(GLint srcWidth, GLint srcHeight,
+                     const GLfloat src[][4],
+                     GLint filterWidth, GLint filterHeight,
+                     const GLfloat filter[][4],
+                     GLfloat dest[][4],
+                     const GLfloat borderColor[4])
 {
    const GLint halfFilterWidth = filterWidth / 2;
-   GLint i, n, m;
+   const GLint halfFilterHeight = filterHeight / 2;
+   GLint i, j, n, m;
 
-   for (i = 0; i < srcWidth; i++) {
-      GLfloat sumR = 0.0;
-      GLfloat sumG = 0.0;
-      GLfloat sumB = 0.0;
-      GLfloat sumA = 0.0;
-      for (m = 0; m < filterHeight; m++) {
-         const GLfloat (*filterRow)[4] = filter + m * filterWidth;
-         for (n = 0; n < filterWidth; n++) {
-            if (i + n < halfFilterWidth ||
-                i + n - halfFilterWidth >= srcWidth) {
-               sumR += borderColor[RCOMP] * filterRow[n][RCOMP];
-               sumG += borderColor[GCOMP] * filterRow[n][GCOMP];
-               sumB += borderColor[BCOMP] * filterRow[n][BCOMP];
-               sumA += borderColor[ACOMP] * filterRow[n][ACOMP];
-            }
-            else {
-               const GLint k = m * srcWidth + i + n - halfFilterWidth;
-               sumR += src[k][RCOMP] * filterRow[n][RCOMP];
-               sumG += src[k][GCOMP] * filterRow[n][GCOMP];
-               sumB += src[k][BCOMP] * filterRow[n][BCOMP];
-               sumA += src[k][ACOMP] * filterRow[n][ACOMP];
+   for (j = 0; j < srcHeight; j++) {
+      for (i = 0; i < srcWidth; i++) {
+         GLfloat sumR = 0.0;
+         GLfloat sumG = 0.0;
+         GLfloat sumB = 0.0;
+         GLfloat sumA = 0.0;
+         for (m = 0; m < filterHeight; m++) {
+            for (n = 0; n < filterWidth; n++) {
+               const GLint f = m * filterWidth + n;
+               const GLint is = i + n - halfFilterWidth;
+               const GLint js = j + m - halfFilterHeight;
+               if (is < 0 || is >= srcWidth ||
+                   js < 0 || js >= srcHeight) {
+                  sumR += borderColor[RCOMP] * filter[f][RCOMP];
+                  sumG += borderColor[GCOMP] * filter[f][GCOMP];
+                  sumB += borderColor[BCOMP] * filter[f][BCOMP];
+                  sumA += borderColor[ACOMP] * filter[f][ACOMP];
+               }
+               else {
+                  const GLint k = js * srcWidth + is;
+                  sumR += src[k][RCOMP] * filter[f][RCOMP];
+                  sumG += src[k][GCOMP] * filter[f][GCOMP];
+                  sumB += src[k][BCOMP] * filter[f][BCOMP];
+                  sumA += src[k][ACOMP] * filter[f][ACOMP];
+               }
             }
          }
+         dest[j * srcWidth + i][RCOMP] = sumR;
+         dest[j * srcWidth + i][GCOMP] = sumG;
+         dest[j * srcWidth + i][BCOMP] = sumB;
+         dest[j * srcWidth + i][ACOMP] = sumA;
       }
-      dest[i][RCOMP] = sumR;
-      dest[i][GCOMP] = sumG;
-      dest[i][BCOMP] = sumB;
-      dest[i][ACOMP] = sumA;
    }
 }
 
 
-void
-_mesa_convolve_2d_replicate(GLint srcWidth, GLint srcHeight,
-                            const GLfloat src[][4],
-                            GLint filterWidth, GLint filterHeight,
-                            const GLfloat filter[][4],
-                            GLfloat dest[][4])
+static void
+convolve_2d_replicate(GLint srcWidth, GLint srcHeight,
+                      const GLfloat src[][4],
+                      GLint filterWidth, GLint filterHeight,
+                      const GLfloat filter[][4],
+                      GLfloat dest[][4])
 {
    const GLint halfFilterWidth = filterWidth / 2;
-   GLint i, n, m;
+   const GLint halfFilterHeight = filterHeight / 2;
+   GLint i, j, n, m;
 
-   for (i = 0; i < srcWidth; i++) {
-      GLfloat sumR = 0.0;
-      GLfloat sumG = 0.0;
-      GLfloat sumB = 0.0;
-      GLfloat sumA = 0.0;
-      for (m = 0; m < filterHeight; m++) {
-         const GLfloat (*filterRow)[4] = filter + m * filterWidth;
-         for (n = 0; n < filterWidth; n++) {
-            if (i + n < halfFilterWidth) {
-               const GLint k = m * srcWidth + 0;
-               sumR += src[k][RCOMP] * filterRow[n][RCOMP];
-               sumG += src[k][GCOMP] * filterRow[n][GCOMP];
-               sumB += src[k][BCOMP] * filterRow[n][BCOMP];
-               sumA += src[k][ACOMP] * filterRow[n][ACOMP];
+   for (j = 0; j < srcHeight; j++) {
+      for (i = 0; i < srcWidth; i++) {
+         GLfloat sumR = 0.0;
+         GLfloat sumG = 0.0;
+         GLfloat sumB = 0.0;
+         GLfloat sumA = 0.0;
+         for (m = 0; m < filterHeight; m++) {
+            for (n = 0; n < filterWidth; n++) {
+               const GLint f = m * filterWidth + n;
+               GLint is = i + n - halfFilterWidth;
+               GLint js = j + m - halfFilterHeight;
+               GLint k;
+               if (is < 0)
+                  is = 0;
+               else if (is >= srcWidth)
+                  is = srcWidth - 1;
+               if (js < 0)
+                  js = 0;
+               else if (js >= srcHeight)
+                  js = srcHeight - 1;
+               k = js * srcWidth + is;
+               sumR += src[k][RCOMP] * filter[f][RCOMP];
+               sumG += src[k][GCOMP] * filter[f][GCOMP];
+               sumB += src[k][BCOMP] * filter[f][BCOMP];
+               sumA += src[k][ACOMP] * filter[f][ACOMP];
             }
-            else if (i + n - halfFilterWidth >= srcWidth) {
-               const GLint k = m * srcWidth + srcWidth - 1;
-               sumR += src[k][RCOMP] * filterRow[n][RCOMP];
-               sumG += src[k][GCOMP] * filterRow[n][GCOMP];
-               sumB += src[k][BCOMP] * filterRow[n][BCOMP];
-               sumA += src[k][ACOMP] * filterRow[n][ACOMP];
-            }
-            else {
-               const GLint k = m * srcWidth + i + n - halfFilterWidth;
-               sumR += src[k][RCOMP] * filterRow[n][RCOMP];
-               sumG += src[k][GCOMP] * filterRow[n][GCOMP];
-               sumB += src[k][BCOMP] * filterRow[n][BCOMP];
-               sumA += src[k][ACOMP] * filterRow[n][ACOMP];
-            }
          }
+         dest[j * srcWidth + i][RCOMP] = sumR;
+         dest[j * srcWidth + i][GCOMP] = sumG;
+         dest[j * srcWidth + i][BCOMP] = sumB;
+         dest[j * srcWidth + i][ACOMP] = sumA;
       }
-      dest[i][RCOMP] = sumR;
-      dest[i][GCOMP] = sumG;
-      dest[i][BCOMP] = sumB;
-      dest[i][ACOMP] = sumA;
    }
 }
 
 
-void
-_mesa_convolve_sep_constant(GLint srcWidth, GLint srcHeight,
-                            const GLfloat src[][4],
-                            GLint filterWidth, GLint filterHeight,
-                            const GLfloat rowFilt[][4],
-                            const GLfloat colFilt[][4],
-                            GLfloat dest[][4],
-                            const GLfloat borderColor[4])
+static void
+convolve_sep_reduce(GLint srcWidth, GLint srcHeight,
+                    const GLfloat src[][4],
+                    GLint filterWidth, GLint filterHeight,
+                    const GLfloat rowFilt[][4],
+                    const GLfloat colFilt[][4],
+                    GLfloat dest[][4])
 {
-   const GLint halfFilterWidth = filterWidth / 2;
-   GLint i, n, m;
+   GLint dstWidth, dstHeight;
+   GLint i, j, n, m;
 
-   for (i = 0; i < srcWidth; i++) {
-      GLfloat sumR = 0.0;
-      GLfloat sumG = 0.0;
-      GLfloat sumB = 0.0;
-      GLfloat sumA = 0.0;
-      for (m = 0; m < filterHeight; m++) {
-         for (n = 0; n < filterWidth; n++) {
-            if (i + n < halfFilterWidth ||
-                i + n - halfFilterWidth >= srcWidth) {
-               sumR += borderColor[RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
-               sumG += borderColor[GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
-               sumB += borderColor[BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
-               sumA += borderColor[ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
-            }
-            else {
-               const GLint k = m * srcWidth + i + n - halfFilterWidth;
+   if (filterWidth >= 1)
+      dstWidth = srcWidth - (filterWidth - 1);
+   else
+      dstWidth = srcWidth;
+
+   if (filterHeight >= 1)
+      dstHeight = srcHeight - (filterHeight - 1);
+   else
+      dstHeight = srcHeight;
+
+   if (dstWidth <= 0 || dstHeight <= 0)
+      return;
+
+   for (j = 0; j < dstHeight; j++) {
+      for (i = 0; i < dstWidth; i++) {
+         GLfloat sumR = 0.0;
+         GLfloat sumG = 0.0;
+         GLfloat sumB = 0.0;
+         GLfloat sumA = 0.0;
+         for (m = 0; m < filterHeight; m++) {
+            for (n = 0; n < filterWidth; n++) {
+               GLint k = (j + m) * srcWidth + i + n;
                sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
                sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
                sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
                sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
             }
          }
+         dest[j * dstWidth + i][RCOMP] = sumR;
+         dest[j * dstWidth + i][GCOMP] = sumG;
+         dest[j * dstWidth + i][BCOMP] = sumB;
+         dest[j * dstWidth + i][ACOMP] = sumA;
       }
-      dest[i][RCOMP] = sumR;
-      dest[i][GCOMP] = sumG;
-      dest[i][BCOMP] = sumB;
-      dest[i][ACOMP] = sumA;
    }
 }
 
 
-void
-_mesa_convolve_sep_reduce(GLint srcWidth, GLint srcHeight,
-                          const GLfloat src[][4],
-                          GLint filterWidth, GLint filterHeight,
-                          const GLfloat rowFilt[][4],
-                          const GLfloat colFilt[][4],
-                          GLfloat dest[][4])
+static void
+convolve_sep_constant(GLint srcWidth, GLint srcHeight,
+                      const GLfloat src[][4],
+                      GLint filterWidth, GLint filterHeight,
+                      const GLfloat rowFilt[][4],
+                      const GLfloat colFilt[][4],
+                      GLfloat dest[][4],
+                      const GLfloat borderColor[4])
 {
-#if 00
    const GLint halfFilterWidth = filterWidth / 2;
-   GLint i, n, m;
+   const GLint halfFilterHeight = filterHeight / 2;
+   GLint i, j, n, m;
 
-   for (i = 0; i < srcWidth; i++) {
-      GLfloat sumR = 0.0;
-      GLfloat sumG = 0.0;
-      GLfloat sumB = 0.0;
-      GLfloat sumA = 0.0;
-      for (m = 0; m < filterHeight; m++) {
-         for (n = 0; n < filterWidth; n++) {
-            if (i + n < halfFilterWidth ||
-                i + n - halfFilterWidth >= srcWidth) {
-               sumR += borderColor[RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
-               sumG += borderColor[GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
-               sumB += borderColor[BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
-               sumA += borderColor[ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
-            }
-            else {
-               const GLint k = m * srcWidth + i + n - halfFilterWidth;
-               sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
-               sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
-               sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
-               sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
+   for (j = 0; j < srcHeight; j++) {
+      for (i = 0; i < srcWidth; i++) {
+         GLfloat sumR = 0.0;
+         GLfloat sumG = 0.0;
+         GLfloat sumB = 0.0;
+         GLfloat sumA = 0.0;
+         for (m = 0; m < filterHeight; m++) {
+            for (n = 0; n < filterWidth; n++) {
+               const GLint is = i + n - halfFilterWidth;
+               const GLint js = j + m - halfFilterHeight;
+               if (is < 0 || is >= srcWidth ||
+                   js < 0 || js >= srcHeight) {
+                  sumR += borderColor[RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
+                  sumG += borderColor[GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
+                  sumB += borderColor[BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
+                  sumA += borderColor[ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
+               }
+               else {
+                  GLint k = js * srcWidth + is;
+                  sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
+                  sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
+                  sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
+                  sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
+               }
+
             }
          }
+         dest[j * srcWidth + i][RCOMP] = sumR;
+         dest[j * srcWidth + i][GCOMP] = sumG;
+         dest[j * srcWidth + i][BCOMP] = sumB;
+         dest[j * srcWidth + i][ACOMP] = sumA;
       }
-      dest[i][RCOMP] = sumR;
-      dest[i][GCOMP] = sumG;
-      dest[i][BCOMP] = sumB;
-      dest[i][ACOMP] = sumA;
    }
-#endif
 }
 
 
-void
-_mesa_convolve_sep_replicate(GLint srcWidth, GLint srcHeight,
-                             const GLfloat src[][4],
-                             GLint filterWidth, GLint filterHeight,
-                             const GLfloat rowFilt[][4],
-                             const GLfloat colFilt[][4],
-                             GLfloat dest[][4])
+static void
+convolve_sep_replicate(GLint srcWidth, GLint srcHeight,
+                       const GLfloat src[][4],
+                       GLint filterWidth, GLint filterHeight,
+                       const GLfloat rowFilt[][4],
+                       const GLfloat colFilt[][4],
+                       GLfloat dest[][4])
 {
    const GLint halfFilterWidth = filterWidth / 2;
-   GLint i, n, m;
+   const GLint halfFilterHeight = filterHeight / 2;
+   GLint i, j, n, m;
 
-   for (i = 0; i < srcWidth; i++) {
-      GLfloat sumR = 0.0;
-      GLfloat sumG = 0.0;
-      GLfloat sumB = 0.0;
-      GLfloat sumA = 0.0;
-      for (m = 0; m < filterHeight; m++) {
-         for (n = 0; n < filterWidth; n++) {
-            if (i + n < halfFilterWidth) {
-               const GLint k = m * srcWidth + 0;
+   for (j = 0; j < srcHeight; j++) {
+      for (i = 0; i < srcWidth; i++) {
+         GLfloat sumR = 0.0;
+         GLfloat sumG = 0.0;
+         GLfloat sumB = 0.0;
+         GLfloat sumA = 0.0;
+         for (m = 0; m < filterHeight; m++) {
+            for (n = 0; n < filterWidth; n++) {
+               GLint is = i + n - halfFilterWidth;
+               GLint js = j + m - halfFilterHeight;
+               GLint k;
+               if (is < 0)
+                  is = 0;
+               else if (is >= srcWidth)
+                  is = srcWidth - 1;
+               if (js < 0)
+                  js = 0;
+               else if (js >= srcHeight)
+                  js = srcHeight - 1;
+               k = js * srcWidth + is;
                sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
                sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
                sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
                sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
             }
-            else if (i + n - halfFilterWidth >= srcWidth) {
-               const GLint k = m * srcWidth + srcWidth - 1;
-               sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
-               sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
-               sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
-               sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
-            }
-            else {
-               const GLint k = m * srcWidth + i + n - halfFilterWidth;
-               sumR += src[k][RCOMP] * rowFilt[n][RCOMP] * colFilt[m][RCOMP];
-               sumG += src[k][GCOMP] * rowFilt[n][GCOMP] * colFilt[m][GCOMP];
-               sumB += src[k][BCOMP] * rowFilt[n][BCOMP] * colFilt[m][BCOMP];
-               sumA += src[k][ACOMP] * rowFilt[n][ACOMP] * colFilt[m][ACOMP];
-            }
          }
+         dest[j * srcWidth + i][RCOMP] = sumR;
+         dest[j * srcWidth + i][GCOMP] = sumG;
+         dest[j * srcWidth + i][BCOMP] = sumB;
+         dest[j * srcWidth + i][ACOMP] = sumA;
       }
-      dest[i][RCOMP] = sumR;
-      dest[i][GCOMP] = sumG;
-      dest[i][BCOMP] = sumB;
-      dest[i][ACOMP] = sumA;
+   }
+}
+
+
+
+void
+_mesa_convolve_1d_image(const GLcontext *ctx, GLsizei *width,
+                        const GLfloat *srcImage, GLfloat *dstImage)
+{
+   switch (ctx->Pixel.ConvolutionBorderMode[0]) {
+      case GL_REDUCE:
+         convolve_1d_reduce(*width, (const GLfloat (*)[4]) srcImage,
+                            ctx->Convolution1D.Width,
+                            (const GLfloat (*)[4]) ctx->Convolution1D.Filter,
+                            (GLfloat (*)[4]) dstImage);
+         *width = *width - (MAX2(ctx->Convolution1D.Width, 1) - 1);
+         break;
+      case GL_CONSTANT_BORDER:
+         convolve_1d_constant(*width, (const GLfloat (*)[4]) srcImage,
+                              ctx->Convolution1D.Width,
+                              (const GLfloat (*)[4]) ctx->Convolution1D.Filter,
+                              (GLfloat (*)[4]) dstImage,
+                              ctx->Pixel.ConvolutionBorderColor[0]);
+         break;
+      case GL_REPLICATE_BORDER:
+         convolve_1d_replicate(*width, (const GLfloat (*)[4]) srcImage,
+                              ctx->Convolution1D.Width,
+                              (const GLfloat (*)[4]) ctx->Convolution1D.Filter,
+                              (GLfloat (*)[4]) dstImage);
+         break;
+      default:
+         ;
+   }
+}
+
+
+void
+_mesa_convolve_2d_image(const GLcontext *ctx, GLsizei *width, GLsizei *height,
+                        const GLfloat *srcImage, GLfloat *dstImage)
+{
+   switch (ctx->Pixel.ConvolutionBorderMode[1]) {
+      case GL_REDUCE:
+         convolve_2d_reduce(*width, *height,
+                            (const GLfloat (*)[4]) srcImage,
+                            ctx->Convolution2D.Width,
+                            ctx->Convolution2D.Height,
+                            (const GLfloat (*)[4]) ctx->Convolution2D.Filter,
+                            (GLfloat (*)[4]) dstImage);
+         *width = *width - (MAX2(ctx->Convolution2D.Width, 1) - 1);
+         *height = *height - (MAX2(ctx->Convolution2D.Height, 1) - 1);
+         break;
+      case GL_CONSTANT_BORDER:
+         convolve_2d_constant(*width, *height,
+                              (const GLfloat (*)[4]) srcImage,
+                              ctx->Convolution2D.Width,
+                              ctx->Convolution2D.Height,
+                              (const GLfloat (*)[4]) ctx->Convolution2D.Filter,
+                              (GLfloat (*)[4]) dstImage,
+                              ctx->Pixel.ConvolutionBorderColor[1]);
+         break;
+      case GL_REPLICATE_BORDER:
+         convolve_2d_replicate(*width, *height,
+                               (const GLfloat (*)[4]) srcImage,
+                               ctx->Convolution2D.Width,
+                               ctx->Convolution2D.Height,
+                               (const GLfloat (*)[4])ctx->Convolution2D.Filter,
+                               (GLfloat (*)[4]) dstImage);
+         break;
+      default:
+         ;
+      }
+}
+
+
+void
+_mesa_convolve_sep_image(const GLcontext *ctx,
+                         GLsizei *width, GLsizei *height,
+                         const GLfloat *srcImage, GLfloat *dstImage)
+{
+   const GLfloat *rowFilter = ctx->Separable2D.Filter;
+   const GLfloat *colFilter = rowFilter + 4 * MAX_CONVOLUTION_WIDTH;
+
+   switch (ctx->Pixel.ConvolutionBorderMode[2]) {
+      case GL_REDUCE:
+         convolve_sep_reduce(*width, *height,
+                             (const GLfloat (*)[4]) srcImage,
+                             ctx->Separable2D.Width,
+                             ctx->Separable2D.Height,
+                             (const GLfloat (*)[4]) rowFilter,
+                             (const GLfloat (*)[4]) colFilter,
+                             (GLfloat (*)[4]) dstImage);
+         *width = *width - (MAX2(ctx->Separable2D.Width, 1) - 1);
+         *height = *height - (MAX2(ctx->Separable2D.Height, 1) - 1);
+         break;
+      case GL_CONSTANT_BORDER:
+         convolve_sep_constant(*width, *height,
+                               (const GLfloat (*)[4]) srcImage,
+                               ctx->Separable2D.Width,
+                               ctx->Separable2D.Height,
+                               (const GLfloat (*)[4]) rowFilter,
+                               (const GLfloat (*)[4]) colFilter,
+                               (GLfloat (*)[4]) dstImage,
+                               ctx->Pixel.ConvolutionBorderColor[2]);
+         break;
+      case GL_REPLICATE_BORDER:
+         convolve_sep_replicate(*width, *height,
+                                (const GLfloat (*)[4]) srcImage,
+                                ctx->Separable2D.Width,
+                                ctx->Separable2D.Height,
+                                (const GLfloat (*)[4]) rowFilter,
+                                (const GLfloat (*)[4]) colFilter,
+                                (GLfloat (*)[4]) dstImage);
+         break;
+      default:
+         ;
+   }
+}
+
+
+
+/*
+ * This function computes an image's size after convolution.
+ * If the convolution border mode is GL_REDUCE, the post-convolution
+ * image will be smaller than the original.
+ */
+void
+_mesa_adjust_image_for_convolution(const GLcontext *ctx, GLuint dimensions,
+                                   GLsizei *width, GLsizei *height)
+{
+   if (ctx->Pixel.Convolution1DEnabled
+       && dimensions == 1
+       && ctx->Pixel.ConvolutionBorderMode[0] == GL_REDUCE) {
+      *width = *width - (MAX2(ctx->Convolution1D.Width, 1) - 1);
+   }
+   else if (ctx->Pixel.Convolution2DEnabled
+            && dimensions > 1
+            && ctx->Pixel.ConvolutionBorderMode[1] == GL_REDUCE) {
+      *width = *width - (MAX2(ctx->Convolution2D.Width, 1) - 1);
+      *height = *height - (MAX2(ctx->Convolution2D.Height, 1) - 1);
+   }
+   else if (ctx->Pixel.Separable2DEnabled
+            && dimensions > 1
+            && ctx->Pixel.ConvolutionBorderMode[2] == GL_REDUCE) {
+      *width = *width - (MAX2(ctx->Separable2D.Width, 1) - 1);
+      *height = *height - (MAX2(ctx->Separable2D.Height, 1) - 1);
    }
 }
Index: xc/extras/Mesa/src/convolve.h
diff -u /dev/null xc/extras/Mesa/src/convolve.h:1.2
--- /dev/null	Thu Feb 27 12:15:34 2003
+++ xc/extras/Mesa/src/convolve.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,107 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef CONVOLVE_H
+#define CONVOLVE_H
+
+
+#include "mtypes.h"
+
+
+extern void
+_mesa_ConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width,
+                          GLenum format, GLenum type, const GLvoid *image);
+
+extern void
+_mesa_ConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width,
+                          GLsizei height, GLenum format, GLenum type,
+                          const GLvoid *image);
+
+extern void
+_mesa_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
+
+extern void
+_mesa_ConvolutionParameterfv(GLenum target, GLenum pname,
+                             const GLfloat *params);
+
+extern void
+_mesa_ConvolutionParameteri(GLenum target, GLenum pname, GLint params);
+
+extern void
+_mesa_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
+
+extern void
+_mesa_CopyConvolutionFilter1D(GLenum target, GLenum internalformat,
+                              GLint x, GLint y, GLsizei width);
+
+extern void
+_mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalformat,
+                              GLint x, GLint y, GLsizei width, GLsizei height);
+
+extern void
+_mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
+                           GLvoid *image);
+
+extern void
+_mesa_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
+
+extern void
+_mesa_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
+
+extern void
+_mesa_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
+                         GLvoid *row, GLvoid *column, GLvoid *span);
+
+extern void
+_mesa_SeparableFilter2D(GLenum target, GLenum internalformat,
+                        GLsizei width, GLsizei height,
+                        GLenum format, GLenum type,
+                        const GLvoid *row, const GLvoid *column);
+
+
+
+extern void
+_mesa_convolve_1d_image(const GLcontext *ctx, GLsizei *width,
+                        const GLfloat *srcImage, GLfloat *dstImage);
+
+
+extern void
+_mesa_convolve_2d_image(const GLcontext *ctx, GLsizei *width, GLsizei *height,
+                        const GLfloat *srcImage, GLfloat *dstImage);
+
+
+extern void
+_mesa_convolve_sep_image(const GLcontext *ctx,
+                         GLsizei *width, GLsizei *height,
+                         const GLfloat *srcImage, GLfloat *dstImage);
+
+
+extern void
+_mesa_adjust_image_for_convolution(const GLcontext *ctx, GLuint dimensions,
+                                   GLsizei *width, GLsizei *height);
+
+
+#endif
Index: xc/extras/Mesa/src/copy_tmp.h
diff -u xc/extras/Mesa/src/copy_tmp.h:1.6 xc/extras/Mesa/src/copy_tmp.h:removed
--- xc/extras/Mesa/src/copy_tmp.h:1.6	Fri May 18 13:10:13 2001
+++ xc/extras/Mesa/src/copy_tmp.h	Thu Feb 27 12:15:34 2003
@@ -1,126 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#undef COPY_FUNC
-#define COPY_FUNC( BITS )						\
-static void TAG2(copy, BITS)(GLvector4f *to, const GLvector4f *f,	\
-			     const GLubyte mask[] )			\
-{									\
-   GLfloat (*t)[4] = (GLfloat (*)[4])to->start;				\
-   GLfloat *from = f->start;						\
-   GLuint stride = f->stride;				        	\
-   GLuint count = f->count;						\
-   GLuint i;								\
-   (void) mask;								\
-									\
-   if (BITS)								\
-      STRIDE_LOOP {							\
-	 CULL_CHECK {							\
-	    if (BITS&1) t[i][0] = from[0];				\
-	    if (BITS&2) t[i][1] = from[1];				\
-	    if (BITS&4) t[i][2] = from[2];				\
-	    if (BITS&8) t[i][3] = from[3];				\
-	 }								\
-      }									\
-}
-
-
-
-/* static void TAG2(clean, BITS)(GLvector4f *to ) */
-/* { */
-/*    GLfloat (*t)[4] = to->data; */
-/*    GLuint i; */
-
-/*    if (BITS) */
-/*       for (i = 0 ; i < VB_SIZE ; i++) { */
-/*          if (BITS&1) t[i][0] = 0; */
-/* 	 if (BITS&2) t[i][1] = 0; */
-/* 	 if (BITS&4) t[i][2] = 0; */
-/* 	 if (BITS&8) t[i][3] = 1; */
-/*       } */
-/*    to->flags &= ~BITS; */
-/* } */
-
-
-/* We got them all here:
- */
-COPY_FUNC( 0x0 )		/* noop */
-COPY_FUNC( 0x1 )
-COPY_FUNC( 0x2 )
-COPY_FUNC( 0x3 )
-COPY_FUNC( 0x4 )
-COPY_FUNC( 0x5 )
-COPY_FUNC( 0x6 )
-COPY_FUNC( 0x7 )
-COPY_FUNC( 0x8 )
-COPY_FUNC( 0x9 )
-COPY_FUNC( 0xa )
-COPY_FUNC( 0xb )
-COPY_FUNC( 0xc )
-COPY_FUNC( 0xd )
-COPY_FUNC( 0xe )
-COPY_FUNC( 0xf )
-
-static void TAG2(init_copy, 0 ) ( void )
-{
-   gl_copy_tab[IDX][0x0] = TAG2(copy, 0x0);
-   gl_copy_tab[IDX][0x1] = TAG2(copy, 0x1);
-   gl_copy_tab[IDX][0x2] = TAG2(copy, 0x2);
-   gl_copy_tab[IDX][0x3] = TAG2(copy, 0x3);
-   gl_copy_tab[IDX][0x4] = TAG2(copy, 0x4);
-   gl_copy_tab[IDX][0x5] = TAG2(copy, 0x5);
-   gl_copy_tab[IDX][0x6] = TAG2(copy, 0x6);
-   gl_copy_tab[IDX][0x7] = TAG2(copy, 0x7);
-   gl_copy_tab[IDX][0x8] = TAG2(copy, 0x8);
-   gl_copy_tab[IDX][0x9] = TAG2(copy, 0x9);
-   gl_copy_tab[IDX][0xa] = TAG2(copy, 0xa);
-   gl_copy_tab[IDX][0xb] = TAG2(copy, 0xb);
-   gl_copy_tab[IDX][0xc] = TAG2(copy, 0xc);
-   gl_copy_tab[IDX][0xd] = TAG2(copy, 0xd);
-   gl_copy_tab[IDX][0xe] = TAG2(copy, 0xe);
-   gl_copy_tab[IDX][0xf] = TAG2(copy, 0xf);
-
-/*    gl_clean_tab[IDX][0x0] = TAG2(clean, 0x0); */
-/*    gl_clean_tab[IDX][0x1] = TAG2(clean, 0x1); */
-/*    gl_clean_tab[IDX][0x2] = TAG2(clean, 0x2); */
-/*    gl_clean_tab[IDX][0x3] = TAG2(clean, 0x3); */
-/*    gl_clean_tab[IDX][0x4] = TAG2(clean, 0x4); */
-/*    gl_clean_tab[IDX][0x5] = TAG2(clean, 0x5); */
-/*    gl_clean_tab[IDX][0x6] = TAG2(clean, 0x6); */
-/*    gl_clean_tab[IDX][0x7] = TAG2(clean, 0x7); */
-/*    gl_clean_tab[IDX][0x8] = TAG2(clean, 0x8); */
-/*    gl_clean_tab[IDX][0x9] = TAG2(clean, 0x9); */
-/*    gl_clean_tab[IDX][0xa] = TAG2(clean, 0xa); */
-/*    gl_clean_tab[IDX][0xb] = TAG2(clean, 0xb); */
-/*    gl_clean_tab[IDX][0xc] = TAG2(clean, 0xc); */
-/*    gl_clean_tab[IDX][0xd] = TAG2(clean, 0xd); */
-/*    gl_clean_tab[IDX][0xe] = TAG2(clean, 0xe); */
-/*    gl_clean_tab[IDX][0xf] = TAG2(clean, 0xf); */
-}
Index: xc/extras/Mesa/src/copypix.c
diff -u xc/extras/Mesa/src/copypix.c:1.9 xc/extras/Mesa/src/copypix.c:removed
--- xc/extras/Mesa/src/copypix.c:1.9	Thu Nov 30 10:39:03 2000
+++ xc/extras/Mesa/src/copypix.c	Thu Feb 27 12:15:34 2003
@@ -1,682 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "copypix.h"
-#include "depth.h"
-#include "feedback.h"
-#include "imaging.h"
-#include "macros.h"
-#include "mem.h"
-#include "mmath.h"
-#include "pixel.h"
-#include "pixeltex.h"
-#include "span.h"
-#include "state.h"
-#include "stencil.h"
-#include "texture.h"
-#include "types.h"
-#include "zoom.h"
-#endif
-
-
-
-/*
- * Determine if there's overlap in an image copy
- */
-static GLboolean
-regions_overlap(int srcx, int srcy, int dstx, int dsty, int width, int height,
-                float zoomX, float zoomY)
-{
-   if ((srcx > dstx + (width * zoomX) + 1) || (srcx + width + 1 < dstx)) {
-      return GL_FALSE;
-   }
-   else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {
-      return GL_FALSE;
-   }
-   else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {
-      return GL_FALSE;
-   }
-   else {
-      return GL_TRUE;
-   }
-}
-
-
-
-static void copy_rgba_pixels( GLcontext *ctx,
-                              GLint srcx, GLint srcy,
-                              GLint width, GLint height,
-                              GLint destx, GLint desty )
-{
-   GLdepth zspan[MAX_WIDTH];
-   GLubyte rgba[MAX_WIDTH][4];
-   GLubyte *prgba,*p;
-   GLboolean quick_draw;
-   GLint sy, dy, stepy;
-   GLint i, j;
-   GLboolean changeBuffer;
-   GLubyte *saveReadAlpha;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-   GLboolean applyTransferOps;
-
-   /* Determine if copy should be done bottom-to-top or top-to-bottom */
-   if (srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-
-   if (ctx->Depth.Test || ctx->Fog.Enabled) {
-      /* fill in array of z values */
-      GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual->DepthMax);
-      for (i=0;i<width;i++) {
-         zspan[i] = z;
-      }
-   }
-
-   if (ctx->RasterMask == 0
-       && !zoom
-       && destx >= 0
-       && destx + width <= ctx->DrawBuffer->Width) {
-      quick_draw = GL_TRUE;
-   }
-   else {
-      quick_draw = GL_FALSE;
-   }
-
-   /* If read and draw buffer are different we must do buffer switching */
-   saveReadAlpha = ctx->ReadBuffer->Alpha;
-   changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
-                  || ctx->DrawBuffer != ctx->ReadBuffer;
-
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                 ctx->Pixel.DriverReadBuffer );
-
-   if (overlapping) {
-      GLint ssy = sy;
-      prgba = (GLubyte *) MALLOC(width * height * sizeof(GLubyte) * 4);
-      if (!prgba) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = prgba;
-      if (changeBuffer) {
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                       ctx->Pixel.DriverReadBuffer );
-         if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT)
-            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
-         else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT)
-            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
-         else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT)
-            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
-         else
-            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
-      }
-      for (j = 0; j < height; j++, ssy += stepy) {
-         gl_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, ssy,
-                            (GLubyte (*)[4]) p );
-         p += (width * sizeof(GLubyte) * 4);
-      }
-      p = prgba;
-   }
-   else {
-      prgba = NULL;  /* silence compiler warnings */
-      p = NULL;
-   }
-
-   applyTransferOps = ctx->Pixel.ScaleOrBiasRGBA ||
-                      ctx->Pixel.MapColorFlag ||
-                      ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-                      ctx->Pixel.ScaleOrBiasRGBApcm ||
-                      ctx->Pixel.ColorTableEnabled ||
-                      ctx->Pixel.PostColorMatrixColorTableEnabled ||
-                      ctx->Pixel.PostConvolutionColorTableEnabled ||
-                      ctx->Pixel.MinMaxEnabled ||
-                      ctx->Pixel.HistogramEnabled;
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      if (overlapping) {
-         MEMCPY(rgba, p, width * sizeof(GLubyte) * 4);
-         p += (width * sizeof(GLubyte) * 4);
-      }
-      else {
-         if (changeBuffer) {
-            (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                          ctx->Pixel.DriverReadBuffer );
-            if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT) {
-               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
-            }
-            else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT) {
-               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
-            }
-            else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT) {
-               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
-            }
-            else {
-               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
-            }
-         }
-         gl_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, sy, rgba );
-      }
-
-      if (changeBuffer) {
-         /* read from the draw buffer again (in case of blending) */
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                       ctx->Color.DriverDrawBuffer );
-         ctx->ReadBuffer->Alpha = saveReadAlpha;
-      }
-
-      if (applyTransferOps) {
-         const GLfloat scale = (1.0F / 255.0F);
-         GLfloat rgbaFloat[MAX_WIDTH][4];
-         GLint k;
-         /* convert ubyte to float */
-         for (k = 0; k < width; k++) {
-            rgbaFloat[k][RCOMP] = (GLfloat) rgba[k][RCOMP] * scale;
-            rgbaFloat[k][GCOMP] = (GLfloat) rgba[k][GCOMP] * scale;
-            rgbaFloat[k][BCOMP] = (GLfloat) rgba[k][BCOMP] * scale;
-            rgbaFloat[k][ACOMP] = (GLfloat) rgba[k][ACOMP] * scale;
-         }
-         /* scale & bias */
-         if (ctx->Pixel.ScaleOrBiasRGBA) {
-            _mesa_scale_and_bias_rgba(ctx, width, rgbaFloat);
-         }
-         /* color map lookup */
-         if (ctx->Pixel.MapColorFlag) {
-            _mesa_map_rgba(ctx, width, rgbaFloat);
-         }
-         /* GL_COLOR_TABLE lookup */
-         if (ctx->Pixel.ColorTableEnabled) {
-            _mesa_lookup_rgba(&ctx->ColorTable, width, rgbaFloat);
-         }
-         /* XXX convolution here */
-         /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
-         if (ctx->Pixel.PostConvolutionColorTableEnabled) {
-            _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgbaFloat);
-         }
-         /* color matrix */
-         if (ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-             ctx->Pixel.ScaleOrBiasRGBApcm) {
-            _mesa_transform_rgba(ctx, width, rgbaFloat);
-         }
-         /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
-         if (ctx->Pixel.PostColorMatrixColorTableEnabled) {
-            _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgbaFloat);
-         }
-         /* update histogram count */
-         if (ctx->Pixel.HistogramEnabled) {
-            _mesa_update_histogram(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
-         }
-         /* update min/max */
-         if (ctx->Pixel.MinMaxEnabled) {
-            _mesa_update_minmax(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
-         }
-         /* clamp to [0,1] and convert float back to ubyte */
-         for (k = 0; k < width; k++) {
-            GLint r = (GLint) (rgbaFloat[k][RCOMP] * 255.0F);
-            GLint g = (GLint) (rgbaFloat[k][GCOMP] * 255.0F);
-            GLint b = (GLint) (rgbaFloat[k][BCOMP] * 255.0F);
-            GLint a = (GLint) (rgbaFloat[k][ACOMP] * 255.0F);
-            rgba[k][RCOMP] = (GLubyte) CLAMP(r, 0, 255);
-            rgba[k][GCOMP] = (GLubyte) CLAMP(g, 0, 255);
-            rgba[k][BCOMP] = (GLubyte) CLAMP(b, 0, 255);
-            rgba[k][ACOMP] = (GLubyte) CLAMP(a, 0, 255);
-         }
-      }
-
-      if (ctx->Texture.ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
-         GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH];
-         GLubyte primary_rgba[MAX_WIDTH][4];
-         GLuint unit;
-         /* XXX not sure how multitexture is supposed to work here */
-
-         MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLubyte));
-
-         for (unit = 0; unit < MAX_TEXTURE_UNITS; unit++) {
-            _mesa_pixeltexgen(ctx, width, (CONST GLubyte (*)[4]) rgba,
-                              s, t, r, q);
-            gl_texture_pixels(ctx, unit, width, s, t, r, NULL,
-                              primary_rgba, rgba);
-         }
-      }
-
-      if (quick_draw && dy >= 0 && dy < ctx->DrawBuffer->Height) {
-         (*ctx->Driver.WriteRGBASpan)( ctx, width, destx, dy, 
-				       (CONST GLubyte (*)[4])rgba, NULL );
-      }
-      else if (zoom) {
-         gl_write_zoomed_rgba_span( ctx, width, destx, dy, zspan, 
-				    (CONST GLubyte (*)[4])rgba, desty);
-      }
-      else {
-         gl_write_rgba_span( ctx, width, destx, dy, zspan, rgba, GL_BITMAP );
-      }
-   }
-
-   /* Restore pixel source to be the draw buffer (for blending, etc) */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                 ctx->Color.DriverDrawBuffer );
-
-   if (overlapping)
-      FREE(prgba);
-}
-
-
-static void copy_ci_pixels( GLcontext *ctx,
-                            GLint srcx, GLint srcy, GLint width, GLint height,
-                            GLint destx, GLint desty )
-{
-   GLdepth zspan[MAX_WIDTH];
-   GLuint *pci,*p;
-   GLint sy, dy, stepy;
-   GLint i, j;
-   GLboolean changeBuffer;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
-   GLint overlapping;
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (srcy<desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-
-   if (ctx->Depth.Test || ctx->Fog.Enabled) {
-      /* fill in array of z values */
-      GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual->DepthMax);
-      for (i=0;i<width;i++) {
-         zspan[i] = z;
-      }
-   }
-
-   /* If read and draw buffer are different we must do buffer switching */
-   changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
-               || ctx->DrawBuffer != ctx->ReadBuffer;
-
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                 ctx->Pixel.DriverReadBuffer );
-
-   if (overlapping) {
-      GLint ssy = sy;
-      pci = (GLuint *) MALLOC(width * height * sizeof(GLuint));
-      if (!pci) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = pci;
-      if (changeBuffer) {
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                       ctx->Pixel.DriverReadBuffer );
-      }
-      for (j = 0; j < height; j++, ssy += stepy) {
-         gl_read_index_span( ctx, ctx->ReadBuffer, width, srcx, ssy, p );
-         p += width;
-      }
-      p = pci;
-   }
-   else {
-      pci = NULL;  /* silence compiler warning */
-      p = NULL;
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      GLuint indexes[MAX_WIDTH];
-      if (overlapping) {
-         MEMCPY(indexes, p, width * sizeof(GLuint));
-         p += width;
-      }
-      else {
-         if (changeBuffer) {
-            (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                          ctx->Pixel.DriverReadBuffer );
-         }
-         gl_read_index_span( ctx, ctx->ReadBuffer, width, srcx, sy, indexes );
-      }
-
-      if (changeBuffer) {
-         /* set read buffer back to draw buffer (in case of logicops) */
-         (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                       ctx->Color.DriverDrawBuffer );
-      }
-
-      if (shift_or_offset) {
-         _mesa_shift_and_offset_ci( ctx, width, indexes );
-      }
-      if (ctx->Pixel.MapColorFlag) {
-         _mesa_map_ci( ctx, width, indexes );
-      }
-
-      if (zoom) {
-         gl_write_zoomed_index_span( ctx, width, destx, dy, zspan, indexes, desty );
-      }
-      else {
-         gl_write_index_span(ctx, width, destx, dy, zspan, indexes, GL_BITMAP);
-      }
-   }
-
-   /* Restore pixel source to be the draw buffer (for blending, etc) */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                 ctx->Color.DriverDrawBuffer );
-
-   if (overlapping)
-      FREE(pci);
-}
-
-
-
-/*
- * TODO: Optimize!!!!
- */
-static void copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
-                               GLint width, GLint height,
-                               GLint destx, GLint desty )
-{
-   GLfloat depth[MAX_WIDTH];
-   GLdepth zspan[MAX_WIDTH];
-   GLfloat *p,*pdepth;
-   GLuint indexes[MAX_WIDTH];
-   GLubyte rgba[MAX_WIDTH][4];
-   GLint sy, dy, stepy;
-   GLint i, j;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   GLint overlapping;
-
-   if (!ctx->Visual->DepthBits) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
-      return;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (srcy<desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-
-   /* setup colors or indexes */
-   if (ctx->Visual->RGBAflag) {
-      GLuint *rgba32 = (GLuint *) rgba;
-      GLuint color = *(GLuint*)( ctx->Current.ByteColor );
-      for (i = 0; i < width; i++) {
-         rgba32[i] = color;
-      }
-   }
-   else {
-      for (i = 0; i < width; i++) {
-         indexes[i] = ctx->Current.Index;
-      }
-   }
-
-   if (overlapping) {
-      GLint ssy = sy;
-      pdepth = (GLfloat *) MALLOC(width * height * sizeof(GLfloat));
-      if (!pdepth) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = pdepth;
-      for (j = 0; j < height; j++, ssy += stepy) {
-         _mesa_read_depth_span_float(ctx, width, srcx, ssy, p);
-         p += width;
-      }
-      p = pdepth;
-   }
-   else {
-      pdepth = NULL;  /* silence compiler warning */
-      p = NULL;
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      if (overlapping) {
-         MEMCPY(depth, p, width * sizeof(GLfloat));
-         p += width;
-      }
-      else {
-         _mesa_read_depth_span_float(ctx, width, srcx, sy, depth);
-      }
-
-      for (i = 0; i < width; i++) {
-         GLfloat d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
-         zspan[i] = (GLdepth) (CLAMP(d, 0.0F, 1.0F) * ctx->Visual->DepthMax);
-      }
-
-      if (ctx->Visual->RGBAflag) {
-         if (zoom) {
-            gl_write_zoomed_rgba_span( ctx, width, destx, dy, zspan, 
-				       (CONST GLubyte (*)[4])rgba, desty );
-         }
-         else {
-            gl_write_rgba_span( ctx, width, destx, dy, zspan, rgba, GL_BITMAP);
-         }
-      }
-      else {
-         if (zoom) {
-            gl_write_zoomed_index_span( ctx, width, destx, dy,
-                                        zspan, indexes, desty );
-         }
-         else {
-            gl_write_index_span( ctx, width, destx, dy,
-                                 zspan, indexes, GL_BITMAP );
-         }
-      }
-   }
-
-  if (overlapping)
-     FREE(pdepth);
-}
-
-
-
-static void copy_stencil_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
-                                 GLint width, GLint height,
-                                 GLint destx, GLint desty )
-{
-   GLint sy, dy, stepy;
-   GLint j;
-   GLstencil *p, *psten;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
-   const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
-   GLint overlapping;
-
-   if (!ctx->Visual->StencilBits) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
-      return;
-   }
-
-   /* Determine if copy should be bottom-to-top or top-to-bottom */
-   if (srcy < desty) {
-      /* top-down  max-to-min */
-      sy = srcy + height - 1;
-      dy = desty + height - 1;
-      stepy = -1;
-   }
-   else {
-      /* bottom-up  min-to-max */
-      sy = srcy;
-      dy = desty;
-      stepy = 1;
-   }
-
-   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
-                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
-
-   if (overlapping) {
-      GLint ssy = sy;
-      psten = (GLstencil *) MALLOC(width * height * sizeof(GLstencil));
-      if (!psten) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
-         return;
-      }
-      p = psten;
-      for (j = 0; j < height; j++, ssy += stepy) {
-         _mesa_read_stencil_span( ctx, width, srcx, ssy, p );
-         p += width;
-      }
-      p = psten;
-   }
-   else {
-      psten = NULL;  /* silence compiler warning */
-      p = NULL;
-   }
-
-   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
-      GLstencil stencil[MAX_WIDTH];
-
-      if (overlapping) {
-         MEMCPY(stencil, p, width * sizeof(GLstencil));
-         p += width;
-      }
-      else {
-         _mesa_read_stencil_span( ctx, width, srcx, sy, stencil );
-      }
-
-      if (shift_or_offset) {
-         _mesa_shift_and_offset_stencil( ctx, width, stencil );
-      }
-      if (ctx->Pixel.MapStencilFlag) {
-         _mesa_map_stencil( ctx, width, stencil );
-      }
-
-      if (zoom) {
-         gl_write_zoomed_stencil_span( ctx, width, destx, dy, stencil, desty );
-      }
-      else {
-         _mesa_write_stencil_span( ctx, width, destx, dy, stencil );
-      }
-   }
-
-   if (overlapping)
-      FREE(psten);
-}
-
-
-
-
-void
-_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
-                  GLenum type )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint destx, desty;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyPixels");
-
-   if (width < 0 || height < 0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glCopyPixels" );
-      return;
-   }
-
-   if (ctx->NewState) {
-      gl_update_state(ctx);
-   }
-
-   if (ctx->RenderMode==GL_RENDER) {
-      /* Destination of copy: */
-      if (!ctx->Current.RasterPosValid) {
-	 return;
-      }
-      destx = (GLint) (ctx->Current.RasterPos[0] + 0.5F);
-      desty = (GLint) (ctx->Current.RasterPos[1] + 0.5F);
-
-      ctx->OcclusionResult = GL_TRUE;
-
-      RENDER_START(ctx);
-
-      if (ctx->Driver.CopyPixels &&
-          (*ctx->Driver.CopyPixels)( ctx, srcx, srcy, width, height,
-                                     destx, desty, type )) {
-         RENDER_FINISH(ctx);
-         return;
-      }
-
-      if (type == GL_COLOR && ctx->Visual->RGBAflag) {
-         copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );
-      }
-      else if (type == GL_COLOR && !ctx->Visual->RGBAflag) {
-         copy_ci_pixels( ctx, srcx, srcy, width, height, destx, desty );
-      }
-      else if (type == GL_DEPTH) {
-         copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
-      }
-      else if (type == GL_STENCIL) {
-         copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
-      }
-      else {
-	 gl_error( ctx, GL_INVALID_ENUM, "glCopyPixels" );
-      }
-
-      RENDER_FINISH(ctx);
-   }
-   else if (ctx->RenderMode == GL_FEEDBACK) {
-      GLfloat color[4];
-      UBYTE_RGBA_TO_FLOAT_RGBA(color, ctx->Current.ByteColor );
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
-      gl_feedback_vertex( ctx, ctx->Current.RasterPos,
-			  color, ctx->Current.Index,
-			  ctx->Current.Texcoord[0] );
-   }
-   else if (ctx->RenderMode == GL_SELECT) {
-      gl_update_hitflag( ctx, ctx->Current.RasterPos[2] );
-   }
-
-}
Index: xc/extras/Mesa/src/copypix.h
diff -u xc/extras/Mesa/src/copypix.h:1.3 xc/extras/Mesa/src/copypix.h:removed
--- xc/extras/Mesa/src/copypix.h:1.3	Tue Feb 15 02:12:07 2000
+++ xc/extras/Mesa/src/copypix.h	Thu Feb 27 12:15:34 2003
@@ -1,40 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef COPYPIXELS_H
-#define COPYPIXELS_H
-
-
-#include "types.h"
-
-
-extern void
-_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
-                  GLenum type );
-
-
-#endif
-
Index: xc/extras/Mesa/src/cull_tmp.h
diff -u xc/extras/Mesa/src/cull_tmp.h:1.4 xc/extras/Mesa/src/cull_tmp.h:removed
--- xc/extras/Mesa/src/cull_tmp.h:1.4	Mon Nov 13 18:30:42 2000
+++ xc/extras/Mesa/src/cull_tmp.h	Thu Feb 27 12:15:34 2003
@@ -1,176 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-static GLuint TAG(gl_cull_triangles)( struct vertex_buffer *VB,
-				      GLuint start, 
-				      GLuint count, 
-				      GLuint parity, 
-				      CONST GLfloat (*proj)[4])
-{
-   const GLcontext *ctx = VB->ctx;
-   const GLubyte face_bit = ctx->Polygon.FrontBit;
-   const GLubyte cull_faces = ctx->Polygon.CullBits;
-   GLubyte *cullmask = VB->CullMask;
-   GLint i, cullcount = 0;
-   GLint last = count - 3;
-   
-   (void) parity;
-   for (i=start; i <= last ; i+=3 ) {
-      CULL_TRI(DO_CLIP, DO_AREA, i, i+1, i+2, face_bit, 3);
-   }
-
-   if (i != (GLint) count)
-      cullcount += count - i;
-
-   return cullcount;
-}
-
-			  
-
-
-
-
-static GLuint TAG(gl_cull_triangle_fan)( struct vertex_buffer *VB,
-					 GLuint start, 
-					 GLuint count, 
-					 GLuint parity, 
-					 CONST GLfloat (*proj)[4])
-{
-   const GLcontext *ctx = VB->ctx;
-   const GLubyte face_bit = ctx->Polygon.FrontBit;
-   const GLubyte cull_faces = ctx->Polygon.CullBits;
-   GLubyte *cullmask = VB->CullMask;
-   GLint cullcount = 0;
-   GLint i;
-   GLint last = count - 3;
-   GLint nr = 3;
-
-   (void) parity;
-   for (i=start; i <= last ; i++, nr = 1) {
-      CULL_TRI(DO_CLIP, DO_AREA, start, i+1, i+2, face_bit, nr);
-   }
-
-   if (i != (GLint) (last + 1))
-      cullcount += count - i;
-
-   return cullcount;
-}
-
-
-
-static GLuint TAG(gl_cull_triangle_strip)( struct vertex_buffer *VB,
-					   GLuint start, 
-					   GLuint count, 
-					   GLuint parity, 
-					   CONST GLfloat (*proj)[4])
-{
-   const GLcontext *ctx = VB->ctx;
-   const GLubyte face_bit = ctx->Polygon.FrontBit;
-   const GLubyte cull_faces = ctx->Polygon.CullBits;
-   GLubyte *cullmask = VB->CullMask;
-   GLint i;
-   GLint cullcount = 0;
-   GLint last = count - 3;
-   GLint nr = 2;
-
-   parity ^= face_bit;
-
-   for (i = start; i <= last ; i++, parity ^= 1, nr = 1 ) {
-      CULL_TRI(DO_CLIP, DO_AREA, i, i+1, i+2, parity, nr);
-   }
-
-   if (i != last + 1)
-      cullcount += count - i;
-
-   return cullcount;
-}
-
-
-
-
-
-static GLuint TAG(gl_cull_quads)( struct vertex_buffer *VB,
-				  GLuint start, 
-				  GLuint count, 
-				  GLuint parity, 
-				  CONST GLfloat (*proj)[4])
-{
-   const GLcontext *ctx = VB->ctx;
-   const GLubyte face_bit = ctx->Polygon.FrontBit;
-   const GLubyte cull_faces = ctx->Polygon.CullBits;
-   GLubyte *cullmask = VB->CullMask;
-   GLint i,cullcount = 0;
-   GLint last = count - 4;
-
-   (void) parity;
-
-   for (i = start; i <= last ; i += 4) {
-      CULL_QUAD(DO_CLIP, DO_AREA, i, i+1, i+2, i+3, 4);
-   }
-
-   if (i != (GLint) count)
-      cullcount += count - i;
-
-   return cullcount;
-}
-
-
-static GLuint TAG(gl_cull_quad_strip)( struct vertex_buffer *VB,
-				       GLuint start, 
-				       GLuint count, 
-				       GLuint parity, 
-				       CONST GLfloat (*proj)[4])
-{
-   const GLcontext *ctx = VB->ctx;
-   const GLubyte face_bit = ctx->Polygon.FrontBit;
-   const GLubyte cull_faces = ctx->Polygon.CullBits;
-   GLubyte *cullmask = VB->CullMask;
-   GLint i,cullcount = 0;
-   GLint last = count - 4;
-   GLint nr = 4;
-
-   (void) parity;
-
-   for (i = start ; i <= last ; i += 2, nr = 2) {
-      CULL_QUAD(DO_CLIP, DO_AREA, i, i+1, i+3, i+2, nr);
-   }
-
-   if (i != ((GLint) last + 2))
-      cullcount += count - i;
-
-   return cullcount;
-}
-
-
-
-
-#undef DO_CLIP
-#undef DO_AREA
-#undef TAG
Index: xc/extras/Mesa/src/cva.c
diff -u xc/extras/Mesa/src/cva.c:1.7 xc/extras/Mesa/src/cva.c:removed
--- xc/extras/Mesa/src/cva.c:1.7	Fri May 18 12:59:53 2001
+++ xc/extras/Mesa/src/cva.c	Thu Feb 27 12:15:34 2003
@@ -1,881 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/* Mesa CVA implementation.  
- * Copyright (C) 1999 Keith Whitwell
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "types.h"
-#include "cva.h"
-#include "context.h"
-#include "macros.h"
-#include "mem.h"
-#include "pipeline.h"
-#include "varray.h"
-#include "vbcull.h"
-#include "vbrender.h"
-#include "vbxform.h"
-#include "vector.h"
-#endif
-
-
-
-static void copy_clipmask( GLubyte *dest, GLubyte *ormask, GLubyte *andmask,
-			   const GLubyte *src, 
-			   const GLuint *elt, GLuint nr )
-{
-   GLuint i;
-   GLubyte o = *ormask;
-   GLubyte a = *andmask;
-
-   for (i = 0 ; i < nr ; i++) {
-      GLubyte t = src[elt[i]];
-      dest[i] = t;
-      o |= t;
-      a &= t;
-   }  
-
-   *ormask = o;
-   *andmask = a;
-}
-
-static void translate_4f( GLvector4f *dest, 
-			  CONST GLvector4f *src, 
-			  CONST GLuint elt[], 
-			  GLuint nr )
-{
-   GLuint i;
-   GLfloat (*from)[4] = (GLfloat (*)[4])src->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])dest->start;
-   GLuint stride = src->stride;
-   
-   if (stride == 4 * sizeof(GLfloat)) {
-      for (i = 0 ; i < nr ; i++) 
-	 COPY_4FV( to[i], from[elt[i]] );
-   } else {
-      for (i = 0 ; i < nr ; i++) {
-	 CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
-	 COPY_4FV( to[i], (GLfloat *)f );
-      }
-   }      
-
-   dest->size = src->size;
-   dest->flags |= (src->flags & VEC_SIZE_4);
-   dest->count = nr;
-}
-
-static void translate_3f( GLvector3f *dest, 
-			  CONST GLvector3f *src, 
-			  CONST GLuint elt[], 
-			  GLuint nr )
-{
-   GLuint i;
-   GLfloat (*from)[3] = (GLfloat (*)[3])src->start;
-   GLfloat (*to)[3] = (GLfloat (*)[3])dest->start;
-   GLuint stride = src->stride;
-
-   if (stride == 3 * sizeof(GLfloat)) {
-      for (i = 0 ; i < nr ; i++) 
-	 COPY_3FV( to[i], from[elt[i]] );
-   } else {
-      for (i = 0 ; i < nr ; i++) {
-	 CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
-	 COPY_3FV( to[i], (GLfloat *)f );
-      }
-   }
-
-   dest->count = nr;
-}
-
-static void translate_4ub( GLvector4ub *dest, 
-			   CONST GLvector4ub *src,
-			   GLuint elt[], 
-			   GLuint nr )
-{
-   GLuint i;
-   GLubyte (*from)[4] = (GLubyte (*)[4])src->start;
-   GLubyte (*to)[4] = (GLubyte (*)[4])dest->start;
-   GLuint stride = src->stride;
-
-   if (stride == 4 * sizeof(GLubyte)) {
-      for (i = 0 ; i < nr ; i++)
-	 COPY_4UBV( to[i], from[elt[i]]);
-   } else {
-      for (i = 0 ; i < nr ; i++) {
-	 CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
-	 COPY_4UBV( to[i], f );
-      }
-   }
-
-   dest->count = nr;
-}
-
-static void translate_1ui( GLvector1ui *dest, 
-			   GLvector1ui *src, 
-			   GLuint elt[], 
-			   GLuint nr )
-{
-   GLuint i;
-   GLuint *from = src->start;
-   GLuint *to = dest->start;
-   GLuint stride = src->stride;
-
-   if (stride == sizeof(GLuint)) {
-      for (i = 0 ; i < nr ; i++)
-	 to[i] = from[elt[i]];
-   } else {
-      for (i = 0 ; i < nr ; i++) {
-	 CONST GLubyte *f = (GLubyte *)from + elt[i] * stride;
-	 to[i] = *(GLuint *)f;
-      }
-   }
-
-   dest->count = nr;
-}
-
-static void translate_1ub( GLvector1ub *dest, 
-			   GLvector1ub *src, 
-			   GLuint elt[], 
-			   GLuint nr )
-{
-   GLuint i;
-   GLubyte *from = src->start;
-   GLubyte *to = dest->start;
-   GLuint stride = src->stride;
-
-   if (stride == sizeof(GLubyte)) {
-      for (i = 0 ; i < nr ; i++)
-	 to[i] = from[elt[i]];
-   } else {
-      for (i = 0 ; i < nr ; i++) {
-	 CONST GLubyte *f = from + elt[i] * stride;
-	 to[i] = *f;
-      }
-   }
-
-   dest->count = nr;
-}
-
-
-/* The fallback case for handling the merge of cva and immediate
- * data.  This code back-copies data from cva->immediate to build a
- * normal looking immediate struct, which is then sent off to the
- * old raster setup and render routines.
- *
- * The FX driver implements a replacement for this step which merges
- * the new data into the already prepared GrVertex structs.
- *
- * When there is no data to merge, gl_render_vb_indirect is called
- * instead.
- */
-void gl_merge_cva( struct vertex_buffer *VB,
-		   struct vertex_buffer *cvaVB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint *elt = VB->EltPtr->start;
-   GLuint count = VB->Count - VB->Start;
-#ifdef VAO
-   GLuint available = ctx->CVA.pre.outputs | ctx->Array.Current->Summary;
-#else
-   GLuint available = ctx->CVA.pre.outputs | ctx->Array.Summary;
-#endif
-   GLuint required = ctx->CVA.elt.inputs;
-   GLuint flags;
-
-   /* Should attempt to build an or-flag of reduced (ie rasterization)
-    * prims in the VB, so a software points function doesn't screw us
-    * when we're doing hardware triangles.
-    */
-   if ((required & VERT_SETUP_FULL) && 
-       (ctx->IndirectTriangles & DD_SW_SETUP))
-   {
-      if (MESA_VERBOSE & VERBOSE_PIPELINE)
-	 gl_print_vert_flags("extra flags for setup", 
-			     ctx->RenderFlags & available & ~required);
-      required |= ctx->RenderFlags;
-   }
-
-   flags = required & available;
-
-   if ((flags & VERT_DATA) == 0)
-      return;
-   
-   if (MESA_VERBOSE&VERBOSE_PIPELINE)
-      gl_print_vert_flags("cva merge", flags); 
-
-   if (flags & VERT_WIN) {
-      VB->ClipPtr = &VB->Clip;
-      VB->Projected = &VB->Win;
-      VB->CullMode = 0;
-   
-      if (cvaVB->ClipOrMask) {
-
-	 /* Copy clipmask back into VB, build a new clipOrMask */
-	 copy_clipmask( VB->ClipMask + VB->Start, 
-			&VB->ClipOrMask, &VB->ClipAndMask,
-			cvaVB->ClipMask, 
-			elt, 
-			VB->Count - VB->Start );
-	 
-	 /* overkill if !VB->ClipOrMask - should just copy 'copied' verts */
-	 translate_4f( VB->ClipPtr, cvaVB->ClipPtr, elt, count);
-
-	 if (VB->ClipOrMask & CLIP_USER_BIT) {
-	    GLubyte orMask = 0, andMask = ~0;
-
-	    copy_clipmask( VB->UserClipMask + VB->Start,
-			   &orMask, &andMask,
-			   cvaVB->UserClipMask,
-			   elt,
-			   VB->Count - VB->Start);
-	    
-	    if (andMask)
-               VB->ClipAndMask |= CLIP_USER_BIT;
-	 }
-
-	 if (VB->ClipOrMask) 
-	    VB->CullMode |= CLIP_MASK_ACTIVE;      
-
-	 if (VB->ClipAndMask) {
-	    VB->Culled = 1;
-	    gl_dont_cull_vb( VB );   
-	    return;
-	 }
-      }
-
-      translate_4f( &VB->Win, &cvaVB->Win, elt, count );
-
-      /* Can't be precomputed - but may be wasteful to do this now.
-       */
-      if (ctx->IndirectTriangles & DD_ANY_CULL)
-      {
-	 GLuint cullcount = gl_cull_vb( VB );      
-	 if (cullcount) VB->CullMode |= CULL_MASK_ACTIVE;
-	 if (cullcount == VB->Count) { VB->Culled = 2 ; return; }
-      }
-      else 
-	 gl_dont_cull_vb( VB );   
-   } else {
-      VB->ClipPtr = &VB->Clip;
-      VB->Projected = &VB->Win;
-   }
-
-   if (flags & VERT_EYE) 
-   {
-      VB->Unprojected = VB->EyePtr = &VB->Eye;
-      translate_4f( VB->EyePtr, cvaVB->EyePtr, elt, count);
-   }
-
-   if (flags & VERT_OBJ_ANY) 
-   {
-      VB->ObjPtr = &VB->IM->v.Obj;
-      if (!ctx->NeedEyeCoords) VB->Unprojected = VB->ObjPtr;
-      translate_4f( VB->ObjPtr, cvaVB->ObjPtr, elt, count);
-   }
-
-   if (flags & VERT_NORM) 
-   {
-      VB->NormalPtr = &VB->IM->v.Normal;      
-      translate_3f( VB->NormalPtr, cvaVB->NormalPtr, elt, count );
-      VB->CullMode &= ~COMPACTED_NORMALS;
-   }
-
-   if (flags & VERT_RGBA) 
-   {
-      VB->ColorPtr = VB->Color[0] = VB->LitColor[0];
-      translate_4ub( VB->Color[0], cvaVB->Color[0], elt, count );
-
-      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	 VB->Color[1] = VB->LitColor[1];
-	 translate_4ub( VB->Color[1], cvaVB->Color[1], elt, count );
-      }
-   }
-   
-   if (flags & VERT_INDEX) 
-   {
-      VB->IndexPtr = VB->Index[0] = VB->LitIndex[0];
-      translate_1ui( VB->Index[0], cvaVB->Index[0], elt, count );
-
-      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	 VB->Index[1] = VB->LitIndex[1];
-	 translate_1ui( VB->Index[1], cvaVB->Index[1], elt, count );
-      }
-   }
-
-   if (flags & VERT_EDGE) 
-   {
-      VB->EdgeFlagPtr = &VB->IM->v.EdgeFlag;      
-      translate_1ub( VB->EdgeFlagPtr, cvaVB->EdgeFlagPtr, elt, count );
-   }
-
-   if (flags & VERT_TEX0_ANY) 
-   {
-      VB->TexCoordPtr[0] = &VB->IM->v.TexCoord[0];
-      translate_4f( VB->TexCoordPtr[0], cvaVB->TexCoordPtr[0], elt, count);
-   }
-
-   if (flags & VERT_TEX1_ANY) 
-   {
-      VB->TexCoordPtr[1] = &VB->IM->v.TexCoord[1];      
-      translate_4f( VB->TexCoordPtr[1], cvaVB->TexCoordPtr[1], elt, count);
-   }
-}
-
-
-
-
-/* We don't have a good mechanism for dealing with the situation where
- * cva is 'abandoned' midway through a vertex buffer, or indeed any mixing
- * of cva & standard data in a single immediate struct.
- *
- * Basically just abandon CVA even though the precalced data
- * is already there.
- */
-void gl_rescue_cva( GLcontext *ctx, struct immediate *IM )
-{
-   struct vertex_buffer *VB = ctx->VB;
-
-   IM->Start = VB->CopyStart;
-
-   ctx->CompileCVAFlag = 0;
-   gl_build_immediate_pipeline( ctx );
-   gl_exec_array_elements( ctx, IM, IM->Start, IM->Count );
-}
-
-
-
-
-
-/* Transform the array components now, upto the setup call.  When
- * actual draw commands arrive, the data will be merged prior to
- * calling render_vb.  
- */
-void
-_mesa_LockArraysEXT(GLint first, GLsizei count)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "unlock arrays" );
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glLockArrays %d %d\n", first, count);
-
-   /* Can't mix locked & unlocked - if count is too large, just
-    * unlock.  
-    */
-   if (first == 0 && 
-       count > 0 && 
-       count <= (GLint) ctx->Const.MaxArrayLockSize)
-   {   
-      struct gl_cva *cva = &ctx->CVA;
-
-#ifdef VAO
-      if (!ctx->Array.Current->LockCount) {
-	 ctx->Array.NewArrayState = ~0;
-	 ctx->CVA.lock_changed ^= 1;
-	 ctx->NewState |= NEW_CLIENT_STATE;
-      }
-
-      ctx->Array.Current->LockFirst = first;
-      ctx->Array.Current->LockCount = count;     
-      ctx->CompileCVAFlag = !ctx->CompileFlag;
-#else
-      if (!ctx->Array.LockCount) {
-	 ctx->Array.NewArrayState = ~0;
-	 ctx->CVA.lock_changed ^= 1;
-	 ctx->NewState |= NEW_CLIENT_STATE;
-      }
-
-      ctx->Array.LockFirst = first;
-      ctx->Array.LockCount = count;     
-      ctx->CompileCVAFlag = !ctx->CompileFlag;
-#endif
-
-      if (!cva->VB) {
-	 cva->VB = gl_vb_create_for_cva( ctx, ctx->Const.MaxArrayLockSize );
-	 gl_alloc_cva_store( cva, cva->VB->Size );
-	 gl_reset_cva_vb( cva->VB, ~0 );
-      }
-   } 
-   else
-   {
-#ifdef VAO
-      if (ctx->Array.Current->LockCount) {
-#else
-      if (ctx->Array.LockCount) {
-#endif
-	 ctx->CVA.lock_changed ^= 1;
-	 ctx->NewState |= NEW_CLIENT_STATE;
-      }
-
-
-#ifdef VAO
-      ctx->Array.Current->LockFirst = 0;
-      ctx->Array.Current->LockCount = 0;
-#else
-      ctx->Array.LockFirst = 0;
-      ctx->Array.LockCount = 0;
-#endif
-      ctx->CompileCVAFlag = 0;
-   }
-}
-
-
-
-
-void
-_mesa_UnlockArraysEXT( void )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "unlock arrays" );
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glUnlockArrays\n");
-
-#ifdef VAO
-   if (ctx->Array.Current->LockCount) {
-#else
-   if (ctx->Array.LockCount) {
-#endif
-      ctx->CVA.lock_changed ^= 1;
-      ctx->NewState |= NEW_CLIENT_STATE;
-   }
-
-#ifdef VAO
-   ctx->Array.Current->LockFirst = 0;
-   ctx->Array.Current->LockCount = 0;
-#else
-   ctx->Array.LockFirst = 0;
-   ctx->Array.LockCount = 0;
-#endif
-   ctx->CompileCVAFlag = 0;
-}
-
-
-/* This storage used to hold translated client data if type or stride
- * need to be fixed.
- */
-void gl_alloc_cva_store( struct gl_cva *cva, GLuint size )
-{
-   cva->store.Obj = (GLfloat (*)[4])MALLOC( sizeof(GLfloat) * 4 * size );
-   cva->store.Normal = (GLfloat (*)[3])MALLOC( sizeof(GLfloat) * 3 * size );
-   cva->store.Color = (GLubyte (*)[4])MALLOC( sizeof(GLubyte) * 4 * size );
-   cva->store.EdgeFlag = (GLubyte *)MALLOC( sizeof(GLubyte) * size );
-   cva->store.Index = (GLuint *)MALLOC( sizeof(GLuint) * size );
-   cva->store.TexCoord[0] = (GLfloat (*)[4])MALLOC( sizeof(GLfloat) * 4 * size);
-   cva->store.TexCoord[1] = (GLfloat (*)[4])MALLOC( sizeof(GLfloat) * 4 * size);
-   cva->store.Elt = (GLuint *)MALLOC( sizeof(GLuint) * size );
-   cva->elt_size = size;
-}
-
-void gl_free_cva_store( struct gl_cva *cva )
-{
-   FREE( cva->store.Obj );
-   FREE( cva->store.Normal );
-   FREE( cva->store.Color );
-   FREE( cva->store.EdgeFlag );
-   FREE( cva->store.Index );
-   FREE( cva->store.TexCoord[0] );
-   FREE( cva->store.TexCoord[1] );
-   FREE( cva->store.Elt );
-}
-
-
-void gl_prepare_arrays_cva( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   struct gl_cva *cva = &ctx->CVA;
-#ifdef VAO
-   GLuint start = ctx->Array.Current->LockFirst;
-   GLuint n = ctx->Array.Current->LockCount;
-   GLuint enable = ((ctx->Array.NewArrayState & ctx->Array.Current->Summary) |
-		    VB->pipeline->fallback);
-   GLuint disable = ctx->Array.NewArrayState & ~enable;
-#else
-   GLuint start = ctx->Array.LockFirst;
-   GLuint n = ctx->Array.LockCount;
-   GLuint enable = ((ctx->Array.NewArrayState & ctx->Array.Summary) |
-		    VB->pipeline->fallback);
-   GLuint disable = ctx->Array.NewArrayState & ~enable;
-#endif
-   GLuint i;
-
-   if (MESA_VERBOSE&VERBOSE_PIPELINE) {
-      gl_print_vert_flags("*** ENABLE", enable);
-      gl_print_vert_flags("*** DISABLE", disable);
-   }
-
-   if (enable) 
-   {
-      struct gl_client_array *client_data;
-      GLuint fallback = VB->pipeline->fallback;
-   
-      if (enable & VERT_ELT) 
-      {
-	 GLvector1ui *elt = VB->EltPtr = &cva->v.Elt;
-
-	 if (cva->Elt.Type == GL_UNSIGNED_INT)
-	 {
-	    elt->data = (GLuint *) cva->Elt.Ptr;
-	    elt->stride = sizeof(GLuint);
-	    elt->flags = 0;
-	 } else {
-	    elt->data = cva->store.Elt;
-	    elt->stride = sizeof(GLuint);
-
-	    if (cva->elt_count > cva->elt_size) 
-	    {
-	       while (cva->elt_count > (cva->elt_size *= 2)) {};
-	       FREE(cva->store.Elt);
-	       cva->store.Elt = (GLuint *) MALLOC(cva->elt_size * 
-						  sizeof(GLuint));
-	    }
-	    cva->EltFunc( elt->data, &cva->Elt, 0, cva->elt_count );
-	 }	
-	 elt->start = VEC_ELT(elt, GLuint, 0); 
-	 elt->count = cva->elt_count;
-
-#ifdef VAO
-	 fallback |= (cva->pre.new_inputs & ~ctx->Array.Current->Summary);
-#else
-	 fallback |= (cva->pre.new_inputs & ~ctx->Array.Summary);
-#endif
-	 enable |= fallback;
-	 disable &= ~fallback;
-	 if (MESA_VERBOSE&VERBOSE_PIPELINE) {
-	    gl_print_vert_flags("*** NEW INPUTS", cva->pre.new_inputs);
-	    gl_print_vert_flags("*** FALLBACK", fallback);
-	 }
-      }
-
-      if (enable & VERT_RGBA) 
-      {
-	 GLvector4ub *col = &cva->v.Color;
-
-#ifdef VAO
-	 client_data = &ctx->Array.Current->Color;
-#else
-	 client_data = &ctx->Array.Color;
-#endif
-	 if (fallback & VERT_RGBA) client_data = &ctx->Fallback.Color;
-
-	 VB->Color[0] = VB->Color[1] = VB->ColorPtr = &cva->v.Color;
-      
-	 if (client_data->Type != GL_UNSIGNED_BYTE ||
-	     client_data->Size != 4)
-	 {
-	    col->data = cva->store.Color;
-	    col->stride = 4 * sizeof(GLubyte);
-#ifdef VAO
-	    ctx->Array.Current->ColorFunc( col->data, client_data, start, n );
-#else
-	    ctx->Array.ColorFunc( col->data, client_data, start, n );
-#endif
-	    col->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-	 } else {
-	    col->data = (GLubyte (*)[4]) client_data->Ptr;
-	    col->stride = client_data->StrideB;
-	    col->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
-	    if (client_data->StrideB != 4 * sizeof(GLubyte)) 
-	       col->flags ^= VEC_STRIDE_FLAGS;
-	 }	
-	 col->start = VEC_ELT(col, GLubyte, start); 
-	 col->count = n;
-      }
-   
-      if (enable & VERT_INDEX) 
-      {
-	 GLvector1ui *index = VB->IndexPtr = &cva->v.Index; 
-	 VB->Index[0] = VB->Index[1] = VB->IndexPtr = &cva->v.Index;
-
-#ifdef VAO
-	 client_data = &ctx->Array.Current->Index;
-#else
-	 client_data = &ctx->Array.Index;
-#endif
-	 if (fallback & VERT_INDEX) client_data = &ctx->Fallback.Index;
-
-	 if (client_data->Type != GL_UNSIGNED_INT)
-	 {
-	    index->data = cva->store.Index;
-	    index->stride = sizeof(GLuint);
-#ifdef VAO
-	    ctx->Array.Current->IndexFunc( index->data, client_data, start, n );
-#else
-	    ctx->Array.IndexFunc( index->data, client_data, start, n );
-#endif
-	    index->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-	 } else {
-	    index->data = (GLuint *) client_data->Ptr;
-	    index->stride = client_data->StrideB;
-	    index->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE; 
-	    if (index->stride != sizeof(GLuint))
-	       index->flags ^= VEC_STRIDE_FLAGS;
-	 }	
-	 index->count = n;
-	 index->start = VEC_ELT(index, GLuint, start); 
-      }
-
-      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
-	 if (enable & PIPE_TEX(i)) {
-	    GLvector4f *tc = VB->TexCoordPtr[i] = &cva->v.TexCoord[i];
-
-#ifdef VAO
-	    client_data = &ctx->Array.Current->TexCoord[i];
-#else
-	    client_data = &ctx->Array.TexCoord[i];
-#endif
-
-	    if (fallback & PIPE_TEX(i)) {
-	       client_data = &ctx->Fallback.TexCoord[i];
-	       client_data->Size = gl_texcoord_size( ctx->Current.Flag, i );
-	    }
-
-	    /* Writeability and stride handled lazily by
-	     * gl_import_client_data(). 
-	     */
-	    if (client_data->Type == GL_FLOAT)
-	    {
-	       tc->data = (GLfloat (*)[4]) client_data->Ptr;
-	       tc->stride = client_data->StrideB;
-	       tc->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
-	       if (tc->stride != 4 * sizeof(GLfloat)) 
-		  tc->flags ^= VEC_STRIDE_FLAGS;
-	    } else {
-	       tc->data = cva->store.TexCoord[i];
-	       tc->stride = 4 * sizeof(GLfloat);
-#ifdef VAO
-	       ctx->Array.Current->TexCoordFunc[i]( tc->data, client_data, start, n );
-#else
-	       ctx->Array.TexCoordFunc[i]( tc->data, client_data, start, n );
-#endif
-	       tc->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-	    }		 
-	    tc->count = n;
-	    tc->start = VEC_ELT(tc, GLfloat, start); 
-	    tc->size = client_data->Size;
-	 }
-      
-      if (enable & VERT_OBJ_ANY) 
-      {
-	 GLvector4f *obj = VB->ObjPtr = &cva->v.Obj;
-
-#ifdef VAO
-	 if (ctx->Array.Current->Vertex.Type == GL_FLOAT)
-	 {
-	    obj->data = (GLfloat (*)[4]) ctx->Array.Current->Vertex.Ptr;
-	    obj->stride = ctx->Array.Current->Vertex.StrideB;
-	    obj->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
-	    if (obj->stride != 4 * sizeof(GLfloat)) 
-	       obj->flags ^= VEC_STRIDE_FLAGS;
-	 } else {
-	    obj->data = cva->store.Obj;
-	    obj->stride = 4 * sizeof(GLfloat);
-	    ctx->Array.Current->VertexFunc( obj->data, &ctx->Array.Current->Vertex, start, n );
-	    obj->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-	 }
-	 obj->count = n;
-	 obj->start = VEC_ELT(obj, GLfloat, start);
-	 obj->size = ctx->Array.Current->Vertex.Size;
-#else
-	 if (ctx->Array.Vertex.Type == GL_FLOAT)
-	 {
-	    obj->data = (GLfloat (*)[4]) ctx->Array.Vertex.Ptr;
-	    obj->stride = ctx->Array.Vertex.StrideB;
-	    obj->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
-	    if (obj->stride != 4 * sizeof(GLfloat)) 
-	       obj->flags ^= VEC_STRIDE_FLAGS;
-	 } else {
-	    obj->data = cva->store.Obj;
-	    obj->stride = 4 * sizeof(GLfloat);
-	    ctx->Array.VertexFunc( obj->data, &ctx->Array.Vertex, start, n );
-	    obj->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-	 }
-	 obj->count = n;
-	 obj->start = VEC_ELT(obj, GLfloat, start);
-	 obj->size = ctx->Array.Vertex.Size;
-#endif
-      }
-
-      if (enable & VERT_NORM) 
-      {
-	 GLvector3f *norm = VB->NormalPtr = &cva->v.Normal;
-
-#ifdef VAO
-	 client_data = &ctx->Array.Current->Normal;
-#else
-	 client_data = &ctx->Array.Normal;
-#endif
-
-	 if (fallback & VERT_NORM) 
-	    client_data = &ctx->Fallback.Normal;
-
-	 /* Never need to write to normals, and we can always cope with stride.
-	  */
-	 if (client_data->Type == GL_FLOAT) {
-	    norm->data = (GLfloat (*)[3]) client_data->Ptr;
-	    norm->stride = client_data->StrideB;
-	 } else {
-	    norm->data = cva->store.Normal;
-	    norm->stride = 3 * sizeof(GLfloat);
-#ifdef VAO
-	    ctx->Array.Current->NormalFunc( norm->data, client_data, start, n );
-#else
-	    ctx->Array.NormalFunc( norm->data, client_data, start, n );
-#endif
-	 }
-	 norm->flags = 0;
-	 norm->count = n;
-	 norm->start = VEC_ELT(norm, GLfloat, start);
-      }
-
-      if (enable & VERT_EDGE) 
-      {
-	 GLvector1ub *edge = VB->EdgeFlagPtr = &cva->v.EdgeFlag;
-
-#ifdef VAO
-	 client_data = &ctx->Array.Current->EdgeFlag;
-#else
-	 client_data = &ctx->Array.EdgeFlag;
-#endif
-
-	 if (fallback & VERT_EDGE) 
-	    client_data = &ctx->Fallback.EdgeFlag;
-
-	 edge->data = (GLboolean *) client_data->Ptr;
-	 edge->stride = client_data->StrideB;
-	 edge->flags = VEC_NOT_WRITABLE|VEC_GOOD_STRIDE;
-	 if (edge->stride != sizeof(GLubyte))
-	    edge->flags ^= VEC_STRIDE_FLAGS;
-
-	 edge->count = n;
-	 edge->start = VEC_ELT(edge, GLubyte, start);
-      }
-   }
-
-   if (disable) {
-      if (disable & VERT_RGBA) cva->v.Color = *VB->LitColor[0];
-      if (disable & VERT_INDEX) cva->v.Index = *VB->LitIndex[0];
-      if (disable & VERT_NORM) cva->v.Normal = *VB->store.Normal;
-      if (disable & VERT_OBJ_ANY) cva->v.Obj = *VB->store.Obj;
-      if (disable & VERT_TEX0_ANY) cva->v.TexCoord[0]= *(VB->store.TexCoord[0]);
-      if (disable & VERT_TEX1_ANY) cva->v.TexCoord[1]= *(VB->store.TexCoord[1]);
-      if (disable & VERT_EDGE) cva->v.EdgeFlag = *VB->store.EdgeFlag;
-   }
-      
-   VB->Flag[VB->Count] &= ~VERT_END_VB;
-   VB->Count = n;
-      	 
-   if (ctx->Enabled & ENABLE_LIGHT) 
-   {
-#ifdef VAO
-      if (ctx->Array.Current->Flags != VB->Flag[0])
-#else
-      if (ctx->Array.Flags != VB->Flag[0])
-#endif
-	 VB->FlagMax = 0;
-      
-      if (VB->FlagMax < n) {
-	 for (i = VB->FlagMax ; i < n ; i++) 
-#ifdef VAO
-	    VB->Flag[i] = ctx->Array.Current->Flags;
-#else
-	    VB->Flag[i] = ctx->Array.Flags;
-#endif
-	 VB->Flag[i] = 0;
-	 VB->FlagMax = n;
-      }
-
-      VB->Flag[n] |= VERT_END_VB;
-   }
-}
-
-void gl_cva_force_precalc( GLcontext *ctx )
-{
-   struct gl_cva *cva = &ctx->CVA;
-
-   if (cva->pre.changed_ops) 
-      gl_reset_cva_vb( cva->VB, cva->pre.changed_ops );
-
-   gl_run_pipeline( cva->VB );
-
-   ctx->Array.NewArrayState = 0;
-}
-
-
-/* Simplified: just make sure the pipelines are valid.
- */
-void gl_cva_compile_cassette( GLcontext *ctx, struct immediate *IM )
-{
-   struct gl_cva *cva = &ctx->CVA;
-   cva->orflag |= IM->OrFlag;
-
-   /* Allow pipeline recalculation based on inputs received from client.
-    */
-   if (IM->OrFlag & (cva->pre.forbidden_inputs|cva->elt.forbidden_inputs)) 
-   {
-      if (IM->OrFlag & cva->pre.forbidden_inputs) 
-      {
-	 cva->pre.pipeline_valid = 0;
-	 cva->pre.data_valid = 0;
-	 cva->pre.forbidden_inputs = 0;
-      }
-
-      if ((IM->OrFlag & cva->elt.forbidden_inputs))
-      {
-	 cva->elt.forbidden_inputs = 0;
-      }
-
-      cva->elt.pipeline_valid = 0;
-   }
-
-   /* Recalculate CVA data if necessary.
-    */
-   if (ctx->CompileCVAFlag && !cva->pre.data_valid) 
-   {
-      if (!cva->pre.pipeline_valid) 
-	 gl_build_precalc_pipeline( ctx );
-   
-      gl_cva_force_precalc( ctx );
-   }
-
-   /* Build immediate pipeline if necessary.
-    */
-   if (!cva->elt.pipeline_valid)
-      gl_build_immediate_pipeline( ctx );
-
-   gl_fixup_input( ctx, IM );
-   gl_execute_cassette( ctx, IM );      
-}
-
-
-void gl_cva_init( GLcontext *ctx )
-{
-   (void) ctx;
-}
Index: xc/extras/Mesa/src/cva.h
diff -u xc/extras/Mesa/src/cva.h:1.3 xc/extras/Mesa/src/cva.h:removed
--- xc/extras/Mesa/src/cva.h:1.3	Tue Feb 15 02:12:07 2000
+++ xc/extras/Mesa/src/cva.h	Thu Feb 27 12:15:34 2003
@@ -1,59 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifndef _CVA_H_
-#define _CVA_H_
-
-
-extern void gl_merge_cva( struct vertex_buffer *VB,
-			  struct vertex_buffer *cvaVB );
-
-extern void gl_prepare_arrays_cva( struct vertex_buffer *cvaVB );
-
-extern void gl_cva_compile_cassette( GLcontext *ctx, struct immediate *IM );
-
-extern void gl_cva_init( GLcontext *ctx );
-
-extern void gl_alloc_cva_store( struct gl_cva *cva, GLuint size );
-extern void gl_free_cva_store( struct gl_cva *cva );
-
-
-extern void gl_rescue_cva( GLcontext *ctx, struct immediate *IM );
-extern void gl_cva_force_precalc( GLcontext *ctx );
-
-extern void
-_mesa_LockArraysEXT(GLint first, GLsizei count);
-
-extern void
-_mesa_UnlockArraysEXT( void );
-
-
-
-#endif
Index: xc/extras/Mesa/src/dd.h
diff -u xc/extras/Mesa/src/dd.h:1.11 xc/extras/Mesa/src/dd.h:1.17
--- xc/extras/Mesa/src/dd.h:1.11	Sat Oct 27 23:32:06 2001
+++ xc/extras/Mesa/src/dd.h	Mon Sep  9 17:29:37 2002
@@ -1,20 +1,19 @@
-/* $XFree86: xc/extras/Mesa/src/dd.h,v 1.11 2001/10/28 03:32:06 tsi Exp $ */
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,95 +27,12 @@
 #ifndef DD_INCLUDED
 #define DD_INCLUDED
 
+/* THIS FILE ONLY INCLUDED BY mtypes.h !!!!! */
 
 #include "macros.h"
 
-
 struct gl_pixelstore_attrib;
 
-
-struct vertex_buffer;
-struct immediate;
-struct gl_pipeline_stage;
-
-
-/* THIS FILE ONLY INCLUDED BY types.h !!!!! */
-
-
-/*
- *                      Device Driver (DD) interface
- *
- *
- * All device driver functions are accessed through pointers in the
- * dd_function_table struct (defined below) which is stored in the GLcontext
- * struct.  Since the device driver is strictly accessed trough a table of
- * function pointers we can:
- *   1. switch between a number of different device drivers at runtime.
- *   2. use optimized functions dependant on current rendering state or
- *      frame buffer configuration.
- *
- * The function pointers in the dd_function_table struct are divided into
- * two groups:  mandatory and optional.
- * Mandatory functions have to be implemented by every device driver.
- * Optional functions may or may not be implemented by the device driver.
- * The optional functions provide ways to take advantage of special hardware
- * or optimized algorithms.
- *
- * The function pointers in the dd_function_table struct should first be
- * initialized in the driver's "MakeCurrent" function.  The "MakeCurrent"
- * function is a little different in each device driver.  See the X/Mesa,
- * GLX, or OS/Mesa drivers for examples.
- *
- * Later, Mesa may call the dd_function_table's UpdateState() function.
- * This function should initialize the dd_function_table's pointers again.
- * The UpdateState() function is called whenever the core (GL) rendering
- * state is changed in a way which may effect rasterization.  For example,
- * the TriangleFunc() pointer may have to point to different functions
- * depending on whether smooth or flat shading is enabled.
- *
- * Note that the first argument to every device driver function is a
- * GLcontext *.  In turn, the GLcontext->DriverCtx pointer points to
- * the driver-specific context struct.  See the X/Mesa or OS/Mesa interface
- * for an example.
- *
- * For more information about writing a device driver see the ddsample.c
- * file and other device drivers (X/xmesa[1234].c, OSMesa/osmesa.c, etc)
- * for examples.
- *
- *
- * Look below in the dd_function_table struct definition for descriptions
- * of each device driver function.
- * 
- *
- * In the future more function pointers may be added for glReadPixels
- * glCopyPixels, etc.
- *
- *
- * Notes:
- * ------
- *   RGBA = red/green/blue/alpha
- *   CI = color index (color mapped mode)
- *   mono = all pixels have the same color or index
- *
- *   The write_ functions all take an array of mask flags which indicate
- *   whether or not the pixel should be written.  One special case exists
- *   in the write_color_span function: if the mask array is NULL, then
- *   draw all pixels.  This is an optimization used for glDrawPixels().
- *
- * IN ALL CASES:
- *      X coordinates start at 0 at the left and increase to the right
- *      Y coordinates start at 0 at the bottom and increase upward
- *
- */
-
-
-
-
-/* Used by the GetParameteri device driver function */
-#define DD_HAVE_HARDWARE_FOG         3
-
-
-
 /* Mask bits sent to the driver Clear() function */
 #define DD_FRONT_LEFT_BIT  FRONT_LEFT_BIT         /* 1 */
 #define DD_FRONT_RIGHT_BIT FRONT_RIGHT_BIT        /* 2 */
@@ -127,7 +43,6 @@
 #define DD_ACCUM_BIT       GL_ACCUM_BUFFER_BIT    /* 0x00000200 */
 
 
-
 /*
  * Device Driver function table.
  */
@@ -144,187 +59,57 @@
     * NULL can be returned.
     */
 
-   void (*UpdateState)( GLcontext *ctx );
+   void (*UpdateState)( GLcontext *ctx, GLuint new_state );
    /*
-    * UpdateState() is called whenver Mesa thinks the device driver should
-    * update its state and/or the other pointers (such as PointsFunc,
-    * LineFunc, or TriangleFunc).
+    * UpdateState() is called to notify the driver after Mesa has made
+    * some internal state changes.  This is in addition to any
+    * statechange callbacks Mesa may already have made.
     */
 
-   void (*ClearIndex)( GLcontext *ctx, GLuint index );
-   /*
-    * Called whenever glClearIndex() is called.  Set the index for clearing
-    * the color buffer when in color index mode.
-    */
-
-   void (*ClearColor)( GLcontext *ctx, GLubyte red, GLubyte green,
-                                        GLubyte blue, GLubyte alpha );
-   /*
-    * Called whenever glClearColor() is called.  Set the color for clearing
-    * the color buffer when in RGBA mode.
-    */
-
-   GLbitfield (*Clear)( GLcontext *ctx, GLbitfield mask, GLboolean all,
-                        GLint x, GLint y, GLint width, GLint height );
+   void (*Clear)( GLcontext *ctx, GLbitfield mask, GLboolean all,
+		  GLint x, GLint y, GLint width, GLint height );
    /* Clear the color/depth/stencil/accum buffer(s).
     * 'mask' is a bitmask of the DD_*_BIT values defined above that indicates
-    * which buffers need to be cleared.  The driver should clear those
-    * buffers then return a new bitmask indicating which buffers should be
-    * cleared by software Mesa.
+    * which buffers need to be cleared.
     * If 'all' is true then the clear the whole buffer, else clear only the
     * region defined by (x,y,width,height).
     * This function must obey the glColorMask, glIndexMask and glStencilMask
     * settings!  Software Mesa can do masked clears if the device driver can't.
     */
 
-   void (*Index)( GLcontext *ctx, GLuint index );
+   void (*SetDrawBuffer)( GLcontext *ctx, GLenum buffer );
    /*
-    * Sets current color index for drawing flat-shaded primitives.
-    * This index should also be used in the "mono" drawing functions.
-    */
-
-   void (*Color)( GLcontext *ctx,
-                  GLubyte red, GLubyte green, GLubyte glue, GLubyte alpha );
-   /*
-    * Sets current color for drawing flat-shaded primitives.
-    * This color should also be used in the "mono" drawing functions.
-    */
-
-   GLboolean (*SetDrawBuffer)( GLcontext *ctx, GLenum buffer );
-   /*
     * Specifies the current buffer for writing.
     * The following values must be accepted when applicable:
     *    GL_FRONT_LEFT - this buffer always exists
     *    GL_BACK_LEFT - when double buffering
     *    GL_FRONT_RIGHT - when using stereo
     *    GL_BACK_RIGHT - when using stereo and double buffering
-    * The folowing values may optionally be accepted.  Return GL_TRUE
-    * if accepted, GL_FALSE if not accepted.  In practice, only drivers
-    * which can write to multiple color buffers at once should accept
-    * these values.
     *    GL_FRONT - write to front left and front right if it exists
     *    GL_BACK - write to back left and back right if it exists
     *    GL_LEFT - write to front left and back left if it exists
     *    GL_RIGHT - write to right left and back right if they exist
     *    GL_FRONT_AND_BACK - write to all four buffers if they exist
     *    GL_NONE - disable buffer write in device driver.
+    *
+    * Note the driver must organize fallbacks (eg with swrast) if it
+    * cannot implement the requested mode.
     */
 
-   void (*SetReadBuffer)( GLcontext *ctx, GLframebuffer *colorBuffer,
-                          GLenum buffer );
+   void (*GetBufferSize)( GLframebuffer *buffer,
+                          GLuint *width, GLuint *height );
    /*
-    * Specifies the current buffer for reading.
-    * colorBuffer will be one of:
-    *    GL_FRONT_LEFT - this buffer always exists
-    *    GL_BACK_LEFT - when double buffering
-    *    GL_FRONT_RIGHT - when using stereo
-    *    GL_BACK_RIGHT - when using stereo and double buffering
+    * Returns the width and height of the named buffer/window.
+    * Mesa uses this to determine when the driver's window size has changed.
     */
 
-   void (*GetBufferSize)( GLcontext *ctx, GLuint *width, GLuint *height );
+   void (*ResizeBuffers)( GLframebuffer *buffer );
    /*
-    * Returns the width and height of the current color buffer.
-    */
-
-
-   /***
-    *** Functions for writing pixels to the frame buffer:
-    ***/
-
-   void (*WriteRGBASpan)( const GLcontext *ctx,
-                          GLuint n, GLint x, GLint y,
-                          CONST GLubyte rgba[][4], const GLubyte mask[] );
-   void (*WriteRGBSpan)( const GLcontext *ctx,
-                         GLuint n, GLint x, GLint y,
-                         CONST GLubyte rgb[][3], const GLubyte mask[] );
-   /* Write a horizontal run of RGBA or RGB pixels.
-    * If mask is NULL, draw all pixels.
-    * If mask is not null, only draw pixel [i] when mask [i] is true.
-    */
-
-   void (*WriteMonoRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                              const GLubyte mask[] );
-   /* Write a horizontal run of RGBA pixels all with the color last
-    * specified by the Color function.
-    */
-
-   void (*WriteRGBAPixels)( const GLcontext *ctx,
-                            GLuint n, const GLint x[], const GLint y[],
-                            CONST GLubyte rgba[][4], const GLubyte mask[] );
-   /* Write array of RGBA pixels at random locations.
-    */
-
-   void (*WriteMonoRGBAPixels)( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-                                const GLubyte mask[] );
-   /* Write an array of mono-RGBA pixels at random locations.
-    */
-
-   void (*WriteCI32Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                          const GLuint index[], const GLubyte mask[] );
-   void (*WriteCI8Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                         const GLubyte index[], const GLubyte mask[] );
-   /* Write a horizontal run of CI pixels.  One function is for 32bpp
-    * indexes and the other for 8bpp pixels (the common case).  You mus
-    * implement both for color index mode.
-    */
-
-   void (*WriteMonoCISpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                            const GLubyte mask[] );
-   /* Write a horizontal run of color index pixels using the color index
-    * last specified by the Index() function.
+    * Resize the driver's depth/stencil/accum/back buffers to match the
+    * size given in the GLframebuffer struct.  This is typically called
+    * when Mesa detects that a window size has changed.
     */
 
-   void (*WriteCI32Pixels)( const GLcontext *ctx,
-                            GLuint n, const GLint x[], const GLint y[],
-                            const GLuint index[], const GLubyte mask[] );
-   /*
-    * Write a random array of CI pixels.
-    */
-
-   void (*WriteMonoCIPixels)( const GLcontext *ctx,
-                              GLuint n, const GLint x[], const GLint y[],
-                              const GLubyte mask[] );
-   /* Write a random array of color index pixels using the color index
-    * last specified by the Index() function.
-    */
-
-
-   /***
-    *** Functions to read pixels from frame buffer:
-    ***/
-
-   void (*ReadCI32Span)( const GLcontext *ctx,
-                         GLuint n, GLint x, GLint y, GLuint index[] );
-   /* Read a horizontal run of color index pixels.
-    */
-
-   void (*ReadRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                         GLubyte rgba[][4] );
-   /* Read a horizontal run of RGBA pixels.
-    */
-
-   void (*ReadCI32Pixels)( const GLcontext *ctx,
-                           GLuint n, const GLint x[], const GLint y[],
-                           GLuint indx[], const GLubyte mask[] );
-   /* Read a random array of CI pixels.
-    */
-
-   void (*ReadRGBAPixels)( const GLcontext *ctx,
-                           GLuint n, const GLint x[], const GLint y[],
-                           GLubyte rgba[][4], const GLubyte mask[] );
-   /* Read a random array of RGBA pixels.
-    */
-
-
-   /**********************************************************************
-    *** Optional functions:  these functions may or may not be         ***
-    *** implemented by the device driver.  If the device driver        ***
-    *** doesn't implement them it should never touch these pointers    ***
-    *** since Mesa will either set them to NULL or point them at a     ***
-    *** fall-back function.                                            ***
-    **********************************************************************/
-
    void (*Finish)( GLcontext *ctx );
    /*
     * This is called whenever glFinish() is called.
@@ -335,215 +120,91 @@
     * This is called whenever glFlush() is called.
     */
 
-   GLboolean (*IndexMask)( GLcontext *ctx, GLuint mask );
-   /*
-    * Implements glIndexMask() if possible, else return GL_FALSE.
-    */
-
-   GLboolean (*ColorMask)( GLcontext *ctx,
-                           GLboolean rmask, GLboolean gmask,
-                           GLboolean bmask, GLboolean amask );
-   /*
-    * Implements glColorMask() if possible, else return GL_FALSE.
-    */
-
-   GLboolean (*LogicOp)( GLcontext *ctx, GLenum op );
-   /*
-    * Implements glLogicOp() if possible, else return GL_FALSE.
-    */
-
-   void (*Dither)( GLcontext *ctx, GLboolean enable );
-   /*
-    * Enable/disable dithering.
-    * NOTE: This function will be removed in the future in favor
-    * of the "Enable" driver function.
-    */
-
    void (*Error)( GLcontext *ctx );
    /*
     * Called whenever an error is generated.  ctx->ErrorValue contains
     * the error value.
     */
 
-   void (*NearFar)( GLcontext *ctx, GLfloat nearVal, GLfloat farVal );
-   /*
-    * Called from glFrustum and glOrtho to tell device driver the
-    * near and far clipping plane Z values.  The 3Dfx driver, for example,
-    * uses this.
-    */
-
-   GLint (*GetParameteri)( const GLcontext *ctx, GLint param );
-   /* Query the device driver to get an integer parameter.
-    * Current parameters:
-    *     DD_MAX_TEXTURE_SIZE         return maximum texture size
-    *
-    *     DD_MAX_TEXTURES             number of texture sets/stages, usually 1
-    *
-    *     DD_HAVE_HARDWARE_FOG        the driver should return 1 (0 otherwise)
-    *                                 when the hardware support per fragment
-    *                                 fog for free (like the Voodoo Graphics)
-    *                                 so the Mesa core will start to ever use
-    *                                 per fragment fog
-    */
 
-
    /***
-    *** For supporting hardware Z buffers:
-    *** Either ALL or NONE of these functions must be implemented!
-    *** NOTE that Each depth value is a 32-bit GLuint.  If the depth
-    *** buffer is less than 32 bits deep then the extra upperbits are zero.
+    *** For hardware accumulation buffer:
     ***/
-
-   void (*WriteDepthSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                           const GLdepth depth[], const GLubyte mask[] );
-   /* Write a horizontal span of values into the depth buffer.  Only write
-    * depth[i] value if mask[i] is nonzero.
-    */
-
-   void (*ReadDepthSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                          GLdepth depth[] );
-   /* Read a horizontal span of values from the depth buffer.
+   void (*Accum)( GLcontext *ctx, GLenum op, GLfloat value,
+		  GLint xpos, GLint ypos, GLint width, GLint height );
+   /* Execute glAccum command within the given scissor region.
     */
 
 
-   void (*WriteDepthPixels)( GLcontext *ctx, GLuint n,
-                             const GLint x[], const GLint y[],
-                             const GLdepth depth[], const GLubyte mask[] );
-   /* Write an array of randomly positioned depth values into the
-    * depth buffer.  Only write depth[i] value if mask[i] is nonzero.
-    */
-
-   void (*ReadDepthPixels)( GLcontext *ctx, GLuint n,
-                            const GLint x[], const GLint y[],
-                            GLdepth depth[] );
-   /* Read an array of randomly positioned depth values from the depth buffer.
-    */
-
-
-
    /***
-    *** For supporting hardware stencil buffers:
-    *** Either ALL or NONE of these functions must be implemented!
-    ***/
-
-   void (*WriteStencilSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                             const GLstencil stencil[], const GLubyte mask[] );
-   /* Write a horizontal span of stencil values into the stencil buffer.
-    * If mask is NULL, write all stencil values.
-    * Else, only write stencil[i] if mask[i] is non-zero.
-    */
-
-   void (*ReadStencilSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                            GLstencil stencil[] );
-   /* Read a horizontal span of stencil values from the stencil buffer.
-    */
-
-   void (*WriteStencilPixels)( GLcontext *ctx, GLuint n,
-                               const GLint x[], const GLint y[],
-                               const GLstencil stencil[],
-                               const GLubyte mask[] );
-   /* Write an array of stencil values into the stencil buffer.
-    * If mask is NULL, write all stencil values.
-    * Else, only write stencil[i] if mask[i] is non-zero.
-    */
-
-   void (*ReadStencilPixels)( GLcontext *ctx, GLuint n,
-                              const GLint x[], const GLint y[],
-                              GLstencil stencil[] );
-   /* Read an array of stencil values from the stencil buffer.
-    */
-  
-
-   /***
     *** glDraw/Read/CopyPixels and glBitmap functions:
     ***/
 
-   GLboolean (*DrawPixels)( GLcontext *ctx,
-                            GLint x, GLint y, GLsizei width, GLsizei height,
-                            GLenum format, GLenum type,
-                            const struct gl_pixelstore_attrib *unpack,
-                            const GLvoid *pixels );
+   void (*DrawPixels)( GLcontext *ctx,
+		       GLint x, GLint y, GLsizei width, GLsizei height,
+		       GLenum format, GLenum type,
+		       const struct gl_pixelstore_attrib *unpack,
+		       const GLvoid *pixels );
    /* This is called by glDrawPixels.
     * 'unpack' describes how to unpack the source image data.
-    * Return GL_TRUE if the driver succeeds, return GL_FALSE if core Mesa
-    * must do the job.
     */
 
-   GLboolean (*ReadPixels)( GLcontext *ctx,
-                            GLint x, GLint y, GLsizei width, GLsizei height,
-                            GLenum format, GLenum type,
-                            const struct gl_pixelstore_attrib *unpack,
-                            GLvoid *dest );
+   void (*ReadPixels)( GLcontext *ctx,
+		       GLint x, GLint y, GLsizei width, GLsizei height,
+		       GLenum format, GLenum type,
+		       const struct gl_pixelstore_attrib *unpack,
+		       GLvoid *dest );
    /* Called by glReadPixels.
-    * Return GL_TRUE if operation completed, else return GL_FALSE.
-    * This function must respect all glPixelTransfer settings.
     */
 
-   GLboolean (*CopyPixels)( GLcontext *ctx,
+   void (*CopyPixels)( GLcontext *ctx,
                             GLint srcx, GLint srcy,
                             GLsizei width, GLsizei height,
                             GLint dstx, GLint dsty, GLenum type );
-   /* Do a glCopyPixels.  Return GL_TRUE if operation completed, else
-    * return GL_FALSE.  This function must respect all rasterization
+   /* Do a glCopyPixels.  This function must respect all rasterization
     * state, glPixelTransfer, glPixelZoom, etc.
     */
 
-   GLboolean (*Bitmap)( GLcontext *ctx,
-                        GLint x, GLint y, GLsizei width, GLsizei height,
-                        const struct gl_pixelstore_attrib *unpack,
-                        const GLubyte *bitmap );
+   void (*Bitmap)( GLcontext *ctx,
+		   GLint x, GLint y, GLsizei width, GLsizei height,
+		   const struct gl_pixelstore_attrib *unpack,
+		   const GLubyte *bitmap );
    /* This is called by glBitmap.  Works the same as DrawPixels, above.
     */
 
-
    /***
-    *** Texture mapping functions:
+    *** Texture image functions:
     ***/
-
-   void (*TexImage)( GLcontext *ctx, GLenum target,
-                     struct gl_texture_object *tObj, GLint level,
-                     GLint internalFormat,
-                     const struct gl_texture_image *image );
-   /* XXX this function is obsolete */
-   /* Called whenever a texture object's image is changed.
-    *    texObject is the number of the texture object being changed.
-    *    level indicates the mipmap level.
-    *    internalFormat is the format in which the texture is to be stored.
-    *    image is a pointer to a gl_texture_image struct which contains
-    *       the actual image data.
-    */
-
-   void (*TexSubImage)( GLcontext *ctx, GLenum target,
-                        struct gl_texture_object *tObj, GLint level,
-                        GLint xoffset, GLint yoffset,
-                        GLsizei width, GLsizei height,
-                        GLint internalFormat,
-                        const struct gl_texture_image *image );
-   /* XXX this function is obsolete */
-   /* Called from glTexSubImage() to define a sub-region of a texture.
-    */
-
-
-   GLboolean (*TexImage1D)( GLcontext *ctx, GLenum target, GLint level,
-                            GLenum format, GLenum type, const GLvoid *pixels,
-                            const struct gl_pixelstore_attrib *packing,
-                            struct gl_texture_object *texObj,
-                            struct gl_texture_image *texImage,
-                            GLboolean *retainInternalCopy );
-   GLboolean (*TexImage2D)( GLcontext *ctx, GLenum target, GLint level,
-                            GLenum format, GLenum type, const GLvoid *pixels,
-                            const struct gl_pixelstore_attrib *packing,
-                            struct gl_texture_object *texObj,
-                            struct gl_texture_image *texImage,
-                            GLboolean *retainInternalCopy );
-   GLboolean (*TexImage3D)( GLcontext *ctx, GLenum target, GLint level,
-                            GLenum format, GLenum type, const GLvoid *pixels,
-                            const struct gl_pixelstore_attrib *packing,
-                            struct gl_texture_object *texObj,
-                            struct gl_texture_image *texImage,
-                            GLboolean *retainInternalCopy );
+   const struct gl_texture_format *
+   (*ChooseTextureFormat)( GLcontext *ctx, GLint internalFormat,
+                           GLenum srcFormat, GLenum srcType );
+   /* This is called by the _mesa_store_tex[sub]image[123]d() fallback
+    * functions.  The driver should examine <internalFormat> and return a
+    * pointer to an appropriate gl_texture_format.
+    */
+
+   void (*TexImage1D)( GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint border,
+                       GLenum format, GLenum type, const GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage );
+   void (*TexImage2D)( GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint border,
+                       GLenum format, GLenum type, const GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage );
+   void (*TexImage3D)( GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint depth, GLint border,
+                       GLenum format, GLenum type, const GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage );
    /* Called by glTexImage1/2/3D.
-    * Will not be called if any glPixelTransfer operations are enabled.
     * Arguments:
     *   <target>, <level>, <format>, <type> and <pixels> are user specified.
     *   <packing> indicates the image packing of pixels.
@@ -552,37 +213,33 @@
     *      width, height, depth, border and internalFormat information.
     *   <retainInternalCopy> is returned by this function and indicates whether
     *      core Mesa should keep an internal copy of the texture image.
-    * Return GL_TRUE if operation completed, return GL_FALSE if core Mesa
-    * should do the job.  If GL_FALSE is returned, this function will be
-    * called a second time after the texture image has been unpacked into
-    * GLubytes.  It may be easier for the driver to handle then.
-    */
-
-   GLboolean (*TexSubImage1D)( GLcontext *ctx, GLenum target, GLint level,
-                               GLint xoffset, GLsizei width,
-                               GLenum format, GLenum type,
-                               const GLvoid *pixels,
-                               const struct gl_pixelstore_attrib *packing,
-                               struct gl_texture_object *texObj,
-                               struct gl_texture_image *texImage );
-   GLboolean (*TexSubImage2D)( GLcontext *ctx, GLenum target, GLint level,
-                               GLint xoffset, GLint yoffset,
-                               GLsizei width, GLsizei height,
-                               GLenum format, GLenum type,
-                               const GLvoid *pixels,
-                               const struct gl_pixelstore_attrib *packing,
-                               struct gl_texture_object *texObj,
-                               struct gl_texture_image *texImage );
-   GLboolean (*TexSubImage3D)( GLcontext *ctx, GLenum target, GLint level,
-                               GLint xoffset, GLint yoffset, GLint zoffset,
-                               GLsizei width, GLsizei height, GLint depth,
-                               GLenum format, GLenum type,
-                               const GLvoid *pixels,
-                               const struct gl_pixelstore_attrib *packing,
-                               struct gl_texture_object *texObj,
-                               struct gl_texture_image *texImage );
+    * Drivers should call a fallback routine from texstore.c if needed.
+    */
+
+   void (*TexSubImage1D)( GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLsizei width,
+                          GLenum format, GLenum type,
+                          const GLvoid *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage );
+   void (*TexSubImage2D)( GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset,
+                          GLsizei width, GLsizei height,
+                          GLenum format, GLenum type,
+                          const GLvoid *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage );
+   void (*TexSubImage3D)( GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset, GLint zoffset,
+                          GLsizei width, GLsizei height, GLint depth,
+                          GLenum format, GLenum type,
+                          const GLvoid *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage );
    /* Called by glTexSubImage1/2/3D.
-    * Will not be called if any glPixelTransfer operations are enabled.
     * Arguments:
     *   <target>, <level>, <xoffset>, <yoffset>, <zoffset>, <width>, <height>,
     *      <depth>, <format>, <type> and <pixels> are user specified.
@@ -590,56 +247,34 @@
     *   <texObj> is the target texture object.
     *   <texImage> is the target texture image.  It will have the texture
     *      width, height, border and internalFormat information.
-    * Return GL_TRUE if operation completed, return GL_FALSE if core Mesa
-    * should do the job.  If GL_FALSE is returned, then TexImage1/2/3D will
-    * be called with the complete texture image.
+    * The driver should use a fallback routine from texstore.c if needed.
     */
-      
-   GLboolean (*CopyTexImage1D)( GLcontext *ctx, GLenum target, GLint level,
-                                GLenum internalFormat, GLint x, GLint y,
-                                GLsizei width, GLint border );
-   GLboolean (*CopyTexImage2D)( GLcontext *ctx, GLenum target, GLint level,
-                                GLenum internalFormat, GLint x, GLint y,
-                                GLsizei width, GLsizei height, GLint border );
+
+   void (*CopyTexImage1D)( GLcontext *ctx, GLenum target, GLint level,
+                           GLenum internalFormat, GLint x, GLint y,
+                           GLsizei width, GLint border );
+   void (*CopyTexImage2D)( GLcontext *ctx, GLenum target, GLint level,
+                           GLenum internalFormat, GLint x, GLint y,
+                           GLsizei width, GLsizei height, GLint border );
    /* Called by glCopyTexImage1D and glCopyTexImage2D.
-    * Will not be called if any glPixelTransfer operations are enabled.
-    * Return GL_TRUE if operation completed, return GL_FALSE if core Mesa
-    * should do the job.
+    * Drivers should use a fallback routine from texstore.c if needed.
     */
 
-   GLboolean (*CopyTexSubImage1D)( GLcontext *ctx, GLenum target, GLint level,
-                                   GLint xoffset,
-                                   GLint x, GLint y, GLsizei width );
-   GLboolean (*CopyTexSubImage2D)( GLcontext *ctx, GLenum target, GLint level,
-                                   GLint xoffset, GLint yoffset,
-                                   GLint x, GLint y,
-                                   GLsizei width, GLsizei height );
-   GLboolean (*CopyTexSubImage3D)( GLcontext *ctx, GLenum target, GLint level,
-                                   GLint xoffset, GLint yoffset, GLint zoffset,
-                                   GLint x, GLint y,
-                                   GLsizei width, GLsizei height );
+   void (*CopyTexSubImage1D)( GLcontext *ctx, GLenum target, GLint level,
+                              GLint xoffset,
+                              GLint x, GLint y, GLsizei width );
+   void (*CopyTexSubImage2D)( GLcontext *ctx, GLenum target, GLint level,
+                              GLint xoffset, GLint yoffset,
+                              GLint x, GLint y,
+                              GLsizei width, GLsizei height );
+   void (*CopyTexSubImage3D)( GLcontext *ctx, GLenum target, GLint level,
+                              GLint xoffset, GLint yoffset, GLint zoffset,
+                              GLint x, GLint y,
+                              GLsizei width, GLsizei height );
    /* Called by glCopyTexSubImage1/2/3D.
-    * Will not be called if any glPixelTransfer operations are enabled.
-    * Return GL_TRUE if operation completed, return GL_FALSE if core Mesa
-    * should do the job.
+    * Drivers should use a fallback routine from texstore.c if needed.
     */
 
-   GLvoid *(*GetTexImage)( GLcontext *ctx, GLenum target, GLint level,
-                           const struct gl_texture_object *texObj,
-                           GLenum *formatOut, GLenum *typeOut,
-                           GLboolean *freeImageOut );
-   /* Called by glGetTexImage or by core Mesa when a texture image
-    * is needed for software fallback rendering.
-    * Return the address of the texture image or NULL if failure.
-    * The image must be tightly packed (i.e. row stride = image width)
-    * Return the image's format and type in formatOut and typeOut.
-    * The format and type must be values which are accepted by glTexImage.
-    * Set the freeImageOut flag if the returned image should be deallocated
-    * with FREE() when finished.
-    * The size of the image can be deduced from the target and level.
-    * Core Mesa will perform any image format/type conversions that are needed.
-    */
-
    GLboolean (*TestProxyTexImage)(GLcontext *ctx, GLenum target,
                                   GLint level, GLint internalFormat,
                                   GLenum format, GLenum type,
@@ -649,25 +284,30 @@
     * target.  Return GL_TRUE if the proxy test passes, return GL_FALSE
     * if the test fails.
     */
+
+   /***
+    *** Compressed texture functions:
+    ***/
 
-   GLboolean (*CompressedTexImage1D)( GLcontext *ctx, GLenum target,
-                                      GLint level, GLsizei imageSize,
-                                      const GLvoid *data,
-                                      struct gl_texture_object *texObj,
-                                      struct gl_texture_image *texImage,
-                                      GLboolean *retainInternalCopy);
-   GLboolean (*CompressedTexImage2D)( GLcontext *ctx, GLenum target,
-                                      GLint level, GLsizei imageSize,
-                                      const GLvoid *data,
-                                      struct gl_texture_object *texObj,
-                                      struct gl_texture_image *texImage,
-                                      GLboolean *retainInternalCopy);
-   GLboolean (*CompressedTexImage3D)( GLcontext *ctx, GLenum target,
-                                      GLint level, GLsizei imageSize,
-                                      const GLvoid *data,
-                                      struct gl_texture_object *texObj,
-                                      struct gl_texture_image *texImage,
-                                      GLboolean *retainInternalCopy);
+   void (*CompressedTexImage1D)( GLcontext *ctx, GLenum target,
+                                 GLint level, GLint internalFormat,
+                                 GLsizei width, GLint border,
+                                 GLsizei imageSize, const GLvoid *data,
+                                 struct gl_texture_object *texObj,
+                                 struct gl_texture_image *texImage );
+   void (*CompressedTexImage2D)( GLcontext *ctx, GLenum target,
+                                 GLint level, GLint internalFormat,
+                                 GLsizei width, GLsizei height, GLint border,
+                                 GLsizei imageSize, const GLvoid *data,
+                                 struct gl_texture_object *texObj,
+                                 struct gl_texture_image *texImage );
+   void (*CompressedTexImage3D)( GLcontext *ctx, GLenum target,
+                                 GLint level, GLint internalFormat,
+                                 GLsizei width, GLsizei height, GLsizei depth,
+                                 GLint border,
+                                 GLsizei imageSize, const GLvoid *data,
+                                 struct gl_texture_object *texObj,
+                                 struct gl_texture_image *texImage );
    /* Called by glCompressedTexImage1/2/3D.
     * Arguments:
     *   <target>, <level>, <internalFormat>, <data> are user specified.
@@ -680,27 +320,26 @@
     * should do the job.
     */
 
-   GLboolean (*CompressedTexSubImage1D)( GLcontext *ctx, GLenum target,
-                                         GLint level, GLint xoffset,
-                                         GLsizei width, GLenum format,
-                                         GLsizei imageSize, const GLvoid *data,
-                                         struct gl_texture_object *texObj,
-                                         struct gl_texture_image *texImage );
-   GLboolean (*CompressedTexSubImage2D)( GLcontext *ctx, GLenum target,
-                                         GLint level, GLint xoffset,
-                                         GLint yoffset, GLsizei width,
-                                         GLint height, GLenum format,
-                                         GLsizei imageSize, const GLvoid *data,
-                                         struct gl_texture_object *texObj,
-                                         struct gl_texture_image *texImage );
-   GLboolean (*CompressedTexSubImage3D)( GLcontext *ctx, GLenum target,
-                                         GLint level, GLint xoffset,
-                                         GLint yoffset, GLint zoffset,
-                                         GLsizei width, GLint height,
-                                         GLint depth, GLenum format,
-                                         GLsizei imageSize, const GLvoid *data,
-                                         struct gl_texture_object *texObj,
-                                         struct gl_texture_image *texImage );
+   void (*CompressedTexSubImage1D)(GLcontext *ctx, GLenum target, GLint level,
+                                   GLint xoffset, GLsizei width,
+                                   GLenum format,
+                                   GLsizei imageSize, const GLvoid *data,
+                                   struct gl_texture_object *texObj,
+                                   struct gl_texture_image *texImage);
+   void (*CompressedTexSubImage2D)(GLcontext *ctx, GLenum target, GLint level,
+                                   GLint xoffset, GLint yoffset,
+                                   GLsizei width, GLint height,
+                                   GLenum format,
+                                   GLsizei imageSize, const GLvoid *data,
+                                   struct gl_texture_object *texObj,
+                                   struct gl_texture_image *texImage);
+   void (*CompressedTexSubImage3D)(GLcontext *ctx, GLenum target, GLint level,
+                                   GLint xoffset, GLint yoffset, GLint zoffset,
+                                   GLsizei width, GLint height, GLint depth,
+                                   GLenum format,
+                                   GLsizei imageSize, const GLvoid *data,
+                                   struct gl_texture_object *texObj,
+                                   struct gl_texture_image *texImage);
    /* Called by glCompressedTexSubImage1/2/3D.
     * Arguments:
     *   <target>, <level>, <x/z/zoffset>, <width>, <height>, <depth>,
@@ -712,11 +351,29 @@
     * should do the job.
     */
 
+   void (*GetCompressedTexImage)( GLcontext *ctx, GLenum target,
+                                  GLint level, void *image,
+                                  const struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage );
+   /* Called by glGetCompressedTexImageARB.
+    * <target>, <level>, <image> are specified by user.
+    * <texObj> is the source texture object.
+    * <texImage> is the source texture image.
+    */
+
    GLint (*BaseCompressedTexFormat)(GLcontext *ctx,
                                     GLint internalFormat);
    /* Called to compute the base format for a specific compressed
     * format.  Return -1 if the internalFormat is not a specific
-    * compressed format that the driver recognizes.  Note the
+    * compressed format that the driver recognizes.
+    * Example: if internalFormat==GL_COMPRESSED_RGB_FXT1_3DFX, return GL_RGB.
+    */
+
+   GLint (*CompressedTextureSize)(GLcontext *ctx,
+                                  const struct gl_texture_image *texImage);
+
+#if 000
+   /* ... Note the
     * return value differences between this function and
     * SpecificCompressedTexFormat below.
     */
@@ -740,58 +397,28 @@
     * format, then just return the generic format, and Mesa will
     * do the right thing with it.
     */
-
-   GLboolean (*IsCompressedFormat)(GLcontext *ctx, GLint internalFormat);
-   /* Called to tell if a format is a compressed format.
-    */
-
-   GLsizei (*CompressedImageSize)(GLcontext *ctx,
-                                  GLenum internalFormat,
-                                  GLuint numDimensions,
-                                  GLuint width,
-                                  GLuint height,
-                                  GLuint depth);
-   /* Calculate the size of a compressed image, given the image's
-    * format and dimensions.
-    */
 
-   void (*GetCompressedTexImage)( GLcontext *ctx, GLenum target,
-                                  GLint lod, void *image,
-                                  const struct gl_texture_object *texObj,
-                                  struct gl_texture_image *texImage );
-   /* Called by glGetCompressedTexImageARB.
-    * <target>, <lod>, <image> are specified by user.
-    * <texObj> is the source texture object.
-    * <texImage> is the source texture image.
-    */
-
-   void (*TexEnv)( GLcontext *ctx, GLenum target, GLenum pname,
-                   const GLfloat *param );
-   /* Called by glTexEnv*().
-    */
+#endif
 
-   void (*TexParameter)( GLcontext *ctx, GLenum target,
-                         struct gl_texture_object *texObj,
-                         GLenum pname, const GLfloat *params );
-   /* Called by glTexParameter*().
-    *    <target> is user specified
-    *    <texObj> the texture object to modify
-    *    <pname> is one of GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER,
-    *       GL_TEXTURE_WRAP_[STR], or GL_TEXTURE_BORDER_COLOR.
-    *    <params> is user specified.
-    */
+   /***
+    *** Texture object functions:
+    ***/
 
    void (*BindTexture)( GLcontext *ctx, GLenum target,
                         struct gl_texture_object *tObj );
    /* Called by glBindTexture().
     */
 
+   void (*CreateTexture)( GLcontext *ctx, struct gl_texture_object *tObj );
+   /* Called when a texture object is created.
+    */
+
    void (*DeleteTexture)( GLcontext *ctx, struct gl_texture_object *tObj );
    /* Called when a texture object is about to be deallocated.  Driver
     * should free anything attached to the DriverData pointers.
     */
 
-   GLboolean (*IsTextureResident)( GLcontext *ctx, 
+   GLboolean (*IsTextureResident)( GLcontext *ctx,
                                    struct gl_texture_object *t );
    /* Called by glAreTextureResident().
     */
@@ -812,135 +439,52 @@
     * is to be updated.
     */
 
-
-
    /***
-    *** Accelerated point, line, polygon, quad and rect functions:
+    *** Imaging functionality:
     ***/
+   void (*CopyColorTable)( GLcontext *ctx,
+			   GLenum target, GLenum internalformat,
+			   GLint x, GLint y, GLsizei width );
+
+   void (*CopyColorSubTable)( GLcontext *ctx,
+			      GLenum target, GLsizei start,
+			      GLint x, GLint y, GLsizei width );
+
+   void (*CopyConvolutionFilter1D)( GLcontext *ctx, GLenum target,
+				    GLenum internalFormat,
+				    GLint x, GLint y, GLsizei width );
+
+   void (*CopyConvolutionFilter2D)( GLcontext *ctx, GLenum target,
+				    GLenum internalFormat,
+				    GLint x, GLint y,
+				    GLsizei width, GLsizei height );
 
-   points_func   PointsFunc;
-   line_func     LineFunc;
-   triangle_func TriangleFunc;
-   quad_func     QuadFunc;
-   rect_func     RectFunc;    
-   
 
-   /***
-    *** Transformation/Rendering functions
-    ***/
 
-   void (*RenderStart)( GLcontext *ctx );
-   void (*RenderFinish)( GLcontext *ctx );
-    /* KW: These replace Begin and End, and have more relaxed semantics.
-     * They are called prior-to and after one or more vb flush, and are
-     * thus decoupled from the gl_begin/gl_end pairs, which are possibly 
-     * more frequent.  If a begin/end pair covers >1 vertex buffer, these
-     * are called at most once for the pair. (a bit broken at present)
-     */
-
-   void (*RasterSetup)( struct vertex_buffer *VB, GLuint start, GLuint end );
-   /* This function, if not NULL, is called whenever new window coordinates
-    * are put in the vertex buffer.  The vertices in question are those n
-    * such that start <= n < end.
-    * The device driver can convert the window coords to its own specialized
-    * format.  The 3Dfx driver uses this.
-    *
-    * Note: Deprecated in favour of RegisterPipelineStages, below.
-    */
-
-   render_func *RenderVBClippedTab;
-   render_func *RenderVBCulledTab;
-   render_func *RenderVBRawTab;
-   /* These function tables allow the device driver to rasterize an
-    * entire begin/end group of primitives at once.  See the
-    * gl_render_vb() function in vbrender.c for more details.  
-    */
-
-   void (*ReducedPrimitiveChange)( GLcontext *ctx, GLenum primitive );
-   /* If registered, this will be called when rendering transitions between
-    * points, lines and triangles.  It is not called on transitions between 
-    * primtives such as GL_TRIANGLES and GL_TRIANGLE_STRIPS, or between
-    * triangles and quads or triangles and polygons.
-    */
-
-   GLuint TriangleCaps;
-   /* Holds a list of the reasons why we might normally want to call
-    * render_triangle, but which are in fact implemented by the
-    * driver.  The FX driver sets this to DD_TRI_CULL, and will soon
-    * implement DD_TRI_OFFSET.
-    */
-
-   GLboolean (*MultipassFunc)( struct vertex_buffer *VB, GLuint passno );
-   /* Driver may request additional render passes by returning GL_TRUE
-    * when this function is called.  This function will be called
-    * after the first pass, and passes will be made until the function
-    * returns GL_FALSE.  If no function is registered, only one pass
-    * is made.  
-    * 
-    * This function will be first invoked with passno == 1.
-    */
-
    /***
-    *** NEW in Mesa 3.x
+    *** State-changing functions (drawing functions are above)
+    ***
+    *** These functions are called by their corresponding OpenGL API functions.
+    *** They're ALSO called by the gl_PopAttrib() function!!!
+    *** May add more functions like these to the device driver in the future.
     ***/
-
-   void (*RegisterVB)( struct vertex_buffer *VB );
-   void (*UnregisterVB)( struct vertex_buffer *VB );
-   /* Do any processing (eg allocate memory) required to set up a new
-    * vertex_buffer.  
-    */
-
-
-   void (*ResetVB)( struct vertex_buffer *VB );
-   void (*ResetCvaVB)( struct vertex_buffer *VB, GLuint stages );
-   /* Do any reset operations necessary to the driver data associated
-    * with these vertex buffers.
-    */
-
-   GLuint RenderVectorFlags;
-   /* What do the render tables require of the vectors they deal
-    * with?  
-    */
-
-   GLuint (*RegisterPipelineStages)( struct gl_pipeline_stage *out,
-				     const struct gl_pipeline_stage *in,
-				     GLuint nr );
-   /* Register new pipeline stages, or modify existing ones.  See also
-    * the OptimizePipeline() functions.
-    */
-
-
-   GLboolean (*BuildPrecalcPipeline)( GLcontext *ctx );
-   GLboolean (*BuildEltPipeline)( GLcontext *ctx );
-   /* Perform the full pipeline build, or return false.
-    */
-
-
-   void (*OptimizePrecalcPipeline)( GLcontext *ctx, struct gl_pipeline *pipe );
-   void (*OptimizeImmediatePipeline)( GLcontext *ctx, struct gl_pipeline *pipe);
-   /* Check to see if a fast path exists for this combination of stages 
-    * in the precalc and immediate (elt) pipelines.
-    */
-
-
-   /*
-    * State-changing functions (drawing functions are above)
-    *
-    * These functions are called by their corresponding OpenGL API functions.
-    * They're ALSO called by the gl_PopAttrib() function!!!
-    * May add more functions like these to the device driver in the future.
-    * This should reduce the amount of state checking that
-    * the driver's UpdateState() function must do.
-    */
-   void (*AlphaFunc)(GLcontext *ctx, GLenum func, GLclampf ref);
+   void (*AlphaFunc)(GLcontext *ctx, GLenum func, GLchan ref);
+   void (*BlendColor)(GLcontext *ctx, const GLfloat color[4]);
    void (*BlendEquation)(GLcontext *ctx, GLenum mode);
    void (*BlendFunc)(GLcontext *ctx, GLenum sfactor, GLenum dfactor);
-   void (*BlendFuncSeparate)( GLcontext *ctx, GLenum sfactorRGB, 
-			      GLenum dfactorRGB, GLenum sfactorA,
-			      GLenum dfactorA );
+   void (*BlendFuncSeparate)(GLcontext *ctx,
+                             GLenum sfactorRGB, GLenum dfactorRGB,
+                             GLenum sfactorA, GLenum dfactorA);
    void (*BlendConstColor)(GLcontext *ctx, GLfloat red, GLfloat green,
-			   GLfloat blue, GLfloat alpha);
+                           GLfloat blue, GLfloat alpha);
+   void (*ClearColor)(GLcontext *ctx, const GLchan color[4]);
    void (*ClearDepth)(GLcontext *ctx, GLclampd d);
+   void (*ClearIndex)(GLcontext *ctx, GLuint index);
+   void (*ClearStencil)(GLcontext *ctx, GLint s);
+   void (*ClipPlane)(GLcontext *ctx, GLenum plane, const GLfloat *equation );
+   void (*ColorMask)(GLcontext *ctx, GLboolean rmask, GLboolean gmask,
+                     GLboolean bmask, GLboolean amask );
+   void (*ColorMaterial)(GLcontext *ctx, GLenum face, GLenum mode);
    void (*CullFace)(GLcontext *ctx, GLenum mode);
    void (*FrontFace)(GLcontext *ctx, GLenum mode);
    void (*DepthFunc)(GLcontext *ctx, GLenum func);
@@ -949,35 +493,262 @@
    void (*Enable)(GLcontext* ctx, GLenum cap, GLboolean state);
    void (*Fogfv)(GLcontext *ctx, GLenum pname, const GLfloat *params);
    void (*Hint)(GLcontext *ctx, GLenum target, GLenum mode);
+   void (*IndexMask)(GLcontext *ctx, GLuint mask);
    void (*Lightfv)(GLcontext *ctx, GLenum light,
-		   GLenum pname, const GLfloat *params, GLint nparams );
+		   GLenum pname, const GLfloat *params );
    void (*LightModelfv)(GLcontext *ctx, GLenum pname, const GLfloat *params);
    void (*LineStipple)(GLcontext *ctx, GLint factor, GLushort pattern );
    void (*LineWidth)(GLcontext *ctx, GLfloat width);
    void (*LogicOpcode)(GLcontext *ctx, GLenum opcode);
+   void (*PointParameterfv)(GLcontext *ctx, GLenum pname,
+                            const GLfloat *params);
    void (*PointSize)(GLcontext *ctx, GLfloat size);
    void (*PolygonMode)(GLcontext *ctx, GLenum face, GLenum mode);
+   void (*PolygonOffset)(GLcontext *ctx, GLfloat factor, GLfloat units);
    void (*PolygonStipple)(GLcontext *ctx, const GLubyte *mask );
+   void (*RenderMode)(GLcontext *ctx, GLenum mode );
    void (*Scissor)(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h);
    void (*ShadeModel)(GLcontext *ctx, GLenum mode);
-   void (*ClearStencil)(GLcontext *ctx, GLint s);
    void (*StencilFunc)(GLcontext *ctx, GLenum func, GLint ref, GLuint mask);
    void (*StencilMask)(GLcontext *ctx, GLuint mask);
    void (*StencilOp)(GLcontext *ctx, GLenum fail, GLenum zfail, GLenum zpass);
+   void (*TexGen)(GLcontext *ctx, GLenum coord, GLenum pname,
+		  const GLfloat *params);
+   void (*TexEnv)(GLcontext *ctx, GLenum target, GLenum pname,
+                  const GLfloat *param);
+   void (*TexParameter)(GLcontext *ctx, GLenum target,
+                        struct gl_texture_object *texObj,
+                        GLenum pname, const GLfloat *params);
+   void (*TextureMatrix)(GLcontext *ctx, GLuint unit, const GLmatrix *mat);
    void (*Viewport)(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h);
 
-   /* State-query functions
-    *
-    * Return GL_TRUE if query was completed, GL_FALSE otherwise.
-    */
+
+   /***
+    *** Vertex array functions
+    ***
+    *** Called by the corresponding OpenGL functions.
+    ***/
+   void (*VertexPointer)(GLcontext *ctx, GLint size, GLenum type,
+			 GLsizei stride, const GLvoid *ptr);
+   void (*NormalPointer)(GLcontext *ctx, GLenum type,
+			 GLsizei stride, const GLvoid *ptr);
+   void (*ColorPointer)(GLcontext *ctx, GLint size, GLenum type,
+			GLsizei stride, const GLvoid *ptr);
+   void (*FogCoordPointer)(GLcontext *ctx, GLenum type,
+			   GLsizei stride, const GLvoid *ptr);
+   void (*IndexPointer)(GLcontext *ctx, GLenum type,
+			GLsizei stride, const GLvoid *ptr);
+   void (*SecondaryColorPointer)(GLcontext *ctx, GLint size, GLenum type,
+				 GLsizei stride, const GLvoid *ptr);
+   void (*TexCoordPointer)(GLcontext *ctx, GLint size, GLenum type,
+			   GLsizei stride, const GLvoid *ptr);
+   void (*EdgeFlagPointer)(GLcontext *ctx, GLsizei stride, const GLvoid *ptr);
+
+
+   /*** State-query functions
+    ***
+    *** Return GL_TRUE if query was completed, GL_FALSE otherwise.
+    ***/
    GLboolean (*GetBooleanv)(GLcontext *ctx, GLenum pname, GLboolean *result);
    GLboolean (*GetDoublev)(GLcontext *ctx, GLenum pname, GLdouble *result);
    GLboolean (*GetFloatv)(GLcontext *ctx, GLenum pname, GLfloat *result);
    GLboolean (*GetIntegerv)(GLcontext *ctx, GLenum pname, GLint *result);
    GLboolean (*GetPointerv)(GLcontext *ctx, GLenum pname, GLvoid **result);
+
+
+
+   /***
+    *** Support for multiple t&l engines
+    ***/
+
+   GLuint NeedValidate;
+   /* Bitmask of state changes that require the current tnl module to be
+    * validated, using ValidateTnlModule() below.
+    */
+
+   void (*ValidateTnlModule)( GLcontext *ctx, GLuint new_state );
+   /* Validate the current tnl module.  This is called directly after
+    * UpdateState() when a state change that has occured matches the
+    * NeedValidate bitmask above.  This ensures all computed values are
+    * up to date, thus allowing the driver to decide if the current tnl
+    * module needs to be swapped out.
+    *
+    * This must be non-NULL if a driver installs a custom tnl module and
+    * sets the NeedValidate bitmask, but may be NULL otherwise.
+    */
+
+
+#define PRIM_OUTSIDE_BEGIN_END   GL_POLYGON+1
+#define PRIM_INSIDE_UNKNOWN_PRIM GL_POLYGON+2
+#define PRIM_UNKNOWN             GL_POLYGON+3
+
+   GLuint CurrentExecPrimitive;
+   /* Set by the driver-supplied t&l engine.  Set to
+    * PRIM_OUTSIDE_BEGIN_END when outside begin/end.
+    */
+
+   GLuint CurrentSavePrimitive;
+   /* Current state of an in-progress compilation.  May take on any of
+    * the additional values defined above.
+    */
+
+
+#define FLUSH_STORED_VERTICES 0x1
+#define FLUSH_UPDATE_CURRENT  0x2
+   GLuint NeedFlush;
+   /* Set by the driver-supplied t&l engine whenever vertices are
+    * buffered between begin/end objects or ctx->Current is not uptodate.
+    *
+    * The FlushVertices() call below may be used to resolve
+    * these conditions.
+    */
+
+   void (*FlushVertices)( GLcontext *ctx, GLuint flags );
+   /* If inside begin/end, ASSERT(0).
+    * Otherwise,
+    *   if (flags & FLUSH_STORED_VERTICES) flushes any buffered vertices,
+    *   if (flags & FLUSH_UPDATE_CURRENT) updates ctx->Current
+    *                                     and ctx->Light.Material
+    *
+    * Note that the default t&l engine never clears the
+    * FLUSH_UPDATE_CURRENT bit, even after performing the update.
+    */
+
+   void (*LightingSpaceChange)( GLcontext *ctx );
+   /* Notify driver that the special derived value _NeedEyeCoords has
+    * changed.
+    */
+
+   void (*NewList)( GLcontext *ctx, GLuint list, GLenum mode );
+   void (*EndList)( GLcontext *ctx );
+   /* Let the t&l component know what is going on with display lists
+    * in time to make changes to dispatch tables, etc.
+    * Called by glNewList() and glEndList(), respectively.
+    */
+
+   void (*BeginCallList)( GLcontext *ctx, GLuint list );
+   void (*EndCallList)( GLcontext *ctx );
+   /* Notify the t&l component before and after calling a display list.
+    * Called by glCallList(s), but not recursively.
+    */
+
+   void (*MakeCurrent)( GLcontext *ctx, GLframebuffer *drawBuffer,
+			GLframebuffer *readBuffer );
+   /* Let the t&l component know when the context becomes current.
+    */
+
+
+   void (*LockArraysEXT)( GLcontext *ctx, GLint first, GLsizei count );
+   void (*UnlockArraysEXT)( GLcontext *ctx );
+   /* Called by glLockArraysEXT() and glUnlockArraysEXT(), respectively.
+    */
 };
 
 
 
-#endif
+/*
+ * Transform/Clip/Lighting interface
+ */
+typedef struct {
+   void (*ArrayElement)( GLint ); /* NOTE */
+   void (*Color3f)( GLfloat, GLfloat, GLfloat );
+   void (*Color3fv)( const GLfloat * );
+   void (*Color3ub)( GLubyte, GLubyte, GLubyte );
+   void (*Color3ubv)( const GLubyte * );
+   void (*Color4f)( GLfloat, GLfloat, GLfloat, GLfloat );
+   void (*Color4fv)( const GLfloat * );
+   void (*Color4ub)( GLubyte, GLubyte, GLubyte, GLubyte );
+   void (*Color4ubv)( const GLubyte * );
+   void (*EdgeFlag)( GLboolean );
+   void (*EdgeFlagv)( const GLboolean * );
+   void (*EvalCoord1f)( GLfloat );          /* NOTE */
+   void (*EvalCoord1fv)( const GLfloat * ); /* NOTE */
+   void (*EvalCoord2f)( GLfloat, GLfloat ); /* NOTE */
+   void (*EvalCoord2fv)( const GLfloat * ); /* NOTE */
+   void (*EvalPoint1)( GLint );             /* NOTE */
+   void (*EvalPoint2)( GLint, GLint );      /* NOTE */
+   void (*FogCoordfEXT)( GLfloat );
+   void (*FogCoordfvEXT)( const GLfloat * );
+   void (*Indexi)( GLint );
+   void (*Indexiv)( const GLint * );
+   void (*Materialfv)( GLenum face, GLenum pname, const GLfloat * ); /* NOTE */
+   void (*MultiTexCoord1fARB)( GLenum, GLfloat );
+   void (*MultiTexCoord1fvARB)( GLenum, const GLfloat * );
+   void (*MultiTexCoord2fARB)( GLenum, GLfloat, GLfloat );
+   void (*MultiTexCoord2fvARB)( GLenum, const GLfloat * );
+   void (*MultiTexCoord3fARB)( GLenum, GLfloat, GLfloat, GLfloat );
+   void (*MultiTexCoord3fvARB)( GLenum, const GLfloat * );
+   void (*MultiTexCoord4fARB)( GLenum, GLfloat, GLfloat, GLfloat, GLfloat );
+   void (*MultiTexCoord4fvARB)( GLenum, const GLfloat * );
+   void (*Normal3f)( GLfloat, GLfloat, GLfloat );
+   void (*Normal3fv)( const GLfloat * );
+   void (*SecondaryColor3fEXT)( GLfloat, GLfloat, GLfloat );
+   void (*SecondaryColor3fvEXT)( const GLfloat * );
+   void (*SecondaryColor3ubEXT)( GLubyte, GLubyte, GLubyte );
+   void (*SecondaryColor3ubvEXT)( const GLubyte * );
+   void (*TexCoord1f)( GLfloat );
+   void (*TexCoord1fv)( const GLfloat * );
+   void (*TexCoord2f)( GLfloat, GLfloat );
+   void (*TexCoord2fv)( const GLfloat * );
+   void (*TexCoord3f)( GLfloat, GLfloat, GLfloat );
+   void (*TexCoord3fv)( const GLfloat * );
+   void (*TexCoord4f)( GLfloat, GLfloat, GLfloat, GLfloat );
+   void (*TexCoord4fv)( const GLfloat * );
+   void (*Vertex2f)( GLfloat, GLfloat );
+   void (*Vertex2fv)( const GLfloat * );
+   void (*Vertex3f)( GLfloat, GLfloat, GLfloat );
+   void (*Vertex3fv)( const GLfloat * );
+   void (*Vertex4f)( GLfloat, GLfloat, GLfloat, GLfloat );
+   void (*Vertex4fv)( const GLfloat * );
+   void (*CallList)( GLuint );	/* NOTE */
+   void (*Begin)( GLenum );
+   void (*End)( void );
+   /* Drivers present a reduced set of the functions possible in
+    * begin/end objects.  Core mesa provides translation stubs for the
+    * remaining functions to map down to these entrypoints.
+    *
+    * These are the initial values to be installed into dispatch by
+    * mesa.  If the t&l driver wants to modify the dispatch table
+    * while installed, it must do so itself.  It would be possible for
+    * the vertexformat to install it's own initial values for these
+    * functions, but this way there is an obvious list of what is
+    * expected of the driver.
+    *
+    * If the driver wants to hook in entrypoints other than those
+    * listed above, it must restore them to their original values in
+    * the disable() callback, below.
+    */
+
+   void (*Rectf)( GLfloat, GLfloat, GLfloat, GLfloat );
+   /*
+    */
+
+   void (*DrawArrays)( GLenum mode, GLint start, GLsizei count );
+   void (*DrawElements)( GLenum mode, GLsizei count, GLenum type,
+			 const GLvoid *indices );
+   void (*DrawRangeElements)( GLenum mode, GLuint start,
+			      GLuint end, GLsizei count,
+			      GLenum type, const GLvoid *indices );
+   /* These may or may not belong here.  Heuristic: If an array is
+    * enabled, the installed vertex format should support that array and
+    * it's current size natively.
+    */
+
+   void (*EvalMesh1)( GLenum mode, GLint i1, GLint i2 );
+   void (*EvalMesh2)( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
+   /* If you don't support eval, fallback to the default vertex format
+    * on receiving an eval call and use the pipeline mechanism to
+    * provide partial t&l acceleration.
+    *
+    * Mesa will provide a set of helper functions to do eval within
+    * accelerated vertex formats, eventually...
+    */
+
+   GLboolean prefer_float_colors;
+   /* Should core try to send colors to glColor4f or glColor4chan,
+    * where it has a choice?
+    */
+} GLvertexformat;
+
 
+#endif /* DD_INCLUDED */
Index: xc/extras/Mesa/src/ddsample.c
diff -u xc/extras/Mesa/src/ddsample.c:1.4 xc/extras/Mesa/src/ddsample.c:removed
--- xc/extras/Mesa/src/ddsample.c:1.4	Fri Jun 16 20:02:08 2000
+++ xc/extras/Mesa/src/ddsample.c	Thu Feb 27 12:15:34 2003
@@ -1,842 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * This is a sample template for writing new Mesa device drivers.
- * You'll have to rewrite much of the code below.
- *
- * Let's say you're interfacing Mesa to a window/operating system
- * called FOO.  Replace all occurances of FOOMesa with the real name
- * you select for your interface  (i.e. XMesa, WMesa, AmigaMesa).
- *
- * You'll have to design an API for clients to use, defined in a
- * header called Mesa/include/GL/FooMesa.h  Use the sample as an
- * example.  The API should at least have functions for creating
- * rendering contexts, binding rendering contexts to windows/frame
- * buffers, etc.
- * 
- * Next, you'll have to write implementations for the device driver
- * functions described in dd.h
- *
- * Note that you'll usually have to flip Y coordinates since Mesa's
- * window coordinates start at the bottom and increase upward.  Most
- * window system's Y-axis increases downward
- *
- * Functions marked OPTIONAL may be completely omitted by your driver.
- *
- * Your Makefile should compile this module along with the rest of
- * the core Mesa library.
- */
-
-/*
- * XXX XXX
- * THIS FILE IS VERY OUT OF DATE!  LOOK AT OSmesa/osmesa.c FOR A BETTER
- * EXAMPLE DRIVER!
- */
-
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "GL/FooMesa.h"
-#include "context.h"
-#include "matrix.h"
-#include "types.h"
-#include "vb.h"
-#endif
-
-
-
-/*
- * In C++ terms, this class derives from the GLvisual class.
- * Add system-specific fields to it.
- */
-struct foo_mesa_visual {
-   GLvisual *gl_visual;
-   GLboolean db_flag;		/* double buffered? */
-   GLboolean rgb_flag;		/* RGB mode? */
-   GLuint depth;		/* bits per pixel (1, 8, 24, etc) */
-};
-
-
-/*
- * In C++ terms, this class derives from the GLframebuffer class.
- * Add system-specific fields to it.
- */
-struct foo_mesa_buffer {
-   GLframebuffer *gl_buffer;	/* The depth, stencil, accum, etc buffers */
-   void *the_window;		/* your window handle, etc */
-   int Width, Height;
-};
-
-
-
-/*
- * In C++ terms, this class derives from the GLcontext class.
- * Add system-specific fields to it.
- */
-struct foo_mesa_context {
-   GLcontext *gl_ctx;		/* the core library context */
-   FooMesaVisual visual;
-   FooMesaBuffer Buffer;
-   GLuint ClearIndex;
-   GLubyte ClearColor[4];
-   GLuint CurrentIndex;
-   GLubyte CurrentColor[4];
-   /* etc... */
-};
-
-
-static FooMesaContext CurrentContext = 0;
-static FooMesaBuffer CurrentBuffer = 0;
-
-
-
-static void setup_DD_pointers( GLcontext *ctx );
-
-
-/**********************************************************************/
-/*****              Miscellaneous device driver funcs             *****/
-/**********************************************************************/
-
-
-static void finish( GLcontext *ctx )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   /* OPTIONAL FUNCTION: implements glFinish if possible */
-}
-
-
-
-static void flush( GLcontext *ctx )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   /* OPTIONAL FUNCTION: implements glFlush if possible */
-}
-
-
-
-static void clear_index( GLcontext *ctx, GLuint index )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   foo->ClearIndex = index;
-}
-
-
-
-static void clear_color( GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   foo->ClearColor[0] = r;
-   foo->ClearColor[1] = g;
-   foo->ClearColor[2] = b;
-   foo->ClearColor[3] = a;
-}
-
-
-
-static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
-                        GLint x, GLint y, GLint width, GLint height )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-/*
- * Clear the specified region of the buffers indicated by 'mask'
- * using the clear color or index as specified by one of the two
- * functions above.
- * If all==GL_TRUE, clear whole buffer, else just clear region defined
- * by x,y,width,height
- */
-
-   return mask;  /* return mask of buffers remaining to be cleared */
-}
-
-
-
-static void set_index( GLcontext *ctx, GLuint index )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   foo->CurrentIndex = index;
-}
-
-
-
-static void set_color( GLcontext *ctx, GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   foo->CurrentColor[0] = r;
-   foo->CurrentColor[1] = g;
-   foo->CurrentColor[2] = b;
-   foo->CurrentColor[3] = a;
-}
-
-
-
-/*
- * OPTIONAL FUNCTION: implement glIndexMask if possible, else
- * return GL_FALSE
- */
-static GLboolean index_mask( GLcontext *ctx, GLuint mask )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   return GL_FALSE;
-}
-
-
-
-/*
- * OPTIONAL FUNCTION: implement glColorMask if possible, else
- * return GL_FALSE
- */
-static GLboolean color_mask( GLcontext *ctx, 
-                             GLboolean rmask, GLboolean gmask,
-                             GLboolean bmask, GLboolean amask)
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   return GL_FALSE;
-}
-
-
-
-/*
- * OPTIONAL FUNCTION: 
- * Implements glLogicOp if possible.  Return GL_TRUE if the device driver
- * can perform the operation, otherwise return GL_FALSE.  If GL_FALSE
- * is returned, the logic op will be done in software by Mesa.
- */
-static GLboolean logicop( GLcontext *ctx, GLenum op )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   return GL_FALSE;
-}
-
-
-
-/*
- * OPTIONAL FUNCTION: enable/disable dithering if applicable
- */
-static void dither( GLcontext *ctx, GLboolean enable )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-}
-
-
-
-/*
- * Set the current reading buffer.
- */
-static void set_read_buffer( GLcontext *ctx, GLframebuffer *bufer,
-                             GLenum mode )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   setup_DD_pointers( ctx );
-}
-
-
-/*
- * Set the destination/draw buffer.
- */
-static GLboolean set_draw_buffer( GLcontext *ctx, GLenum mode )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   setup_DD_pointers( ctx );
-   return GL_TRUE;
-}
-
-
-
-/*
- * Return the width and height of the current buffer.
- * If anything special has to been done when the buffer/window is
- * resized, do it now.
- */
-static void get_buffer_size( GLcontext *ctx, GLuint *width, GLuint *height )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-
-   *width  = foo->Buffer->Width  = 12345;    /* XXX fix these */
-   *height = foo->Buffer->Height = 12345;
-
-}
-
-
-
-/**********************************************************************/
-/*****            Dummy functions                                 *****/
-/**********************************************************************/
-
-static void WriteCIPixel( GLint x, GLint y, GLuint index )
-{
-}
-
-static void WriteRGBAPixel( GLint x, GLint y, const GLubyte color[4] )
-{
-}
-
-static void WriteRGBPixel( GLint x, GLint y, const GLubyte color[3] )
-{
-}
-
-static GLuint ReadCIPixel( GLint x, GLint y )
-{
-   return 0;
-}
-
-static void ReadRGBAPixel( GLint x, GLint y, GLubyte color[4] )
-{
-}
-
-#define FLIP(y)  foo->Buffer->Height - (y) - 1;
-
-
-/**********************************************************************/
-/*****           Accelerated point, line, triangle rendering      *****/
-/**********************************************************************/
-
-
-/* There may several functions like this, for different screen modes, etc */
-static void fast_points_function( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   struct vertex_buffer *VB = ctx->VB;
-   GLint i;
-
-   for (i=first;i<=last;i++) {
-      if (VB->ClipMask[i]==0) {
-         int x, y;
-         x =       (GLint) VB->Win.data[i][0];
-         y = FLIP( (GLint) VB->Win.data[i][1] );
-         WriteRGBAPixel( x, y, VB->ColorPtr->data[i] );
-      }
-   }
-}
-
-
-
-
-/* There may several functions like this, for different screen modes, etc */
-static void fast_line_function( GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv )
-{
-   /* Render a line by some hardware/OS accerated method */
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   struct vertex_buffer *VB = ctx->VB;
-   int x0, y0, x1, y1;
-   GLubyte *pixel;
-
-   pixel = VB->ColorPtr->data[pv];
-
-   x0 =       (int) VB->Win.data[v0][0];
-   y0 = FLIP( (int) VB->Win.data[v0][1] );
-   x1 =       (int) VB->Win.data[v1][0];
-   y1 = FLIP( (int) VB->Win.data[v1][1] );
-
-   /* Draw line from (x0,y0) to (x1,y1) with current pixel color/index */
-}
-
-
-
-
-/* There may several functions like this, for different screen modes, etc */
-static void fast_triangle_function( GLcontext *ctx, GLuint v0,
-                                    GLuint v1, GLuint v2, GLuint pv )
-{
-   /* Render a triangle by some hardware/OS accerated method */
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   struct vertex_buffer *VB = ctx->VB;
-   GLubyte *pixel;
-
-   pixel = VB->ColorPtr->data[pv];
-
-   /* Draw triangle with current pixel color/index */
-}
-
-
-
-/**********************************************************************/
-/*****            Write spans of pixels                           *****/
-/**********************************************************************/
-
-
-static void write_index8_span( const GLcontext *ctx,
-                               GLuint n, GLint x, GLint y,
-                               const GLubyte index[],
-                               const GLubyte mask[] )
-{
-   GLint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         WriteCIPixel(x+i, y, index[i]);
-      }
-   }
-}
-
-
-static void write_index32_span( const GLcontext *ctx,
-                                GLuint n, GLint x, GLint y,
-                                const GLuint index[],
-                                const GLubyte mask[] )
-{
-   GLint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         WriteCIPixel(x+i, y, index[i]);
-      }
-   }
-}
-
-
-
-static void write_mono_index_span( const GLcontext *ctx,
-                                   GLuint n, GLint x, GLint y,
-                                   const GLubyte mask[] )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         WriteCIPixel(x+i, y, foo->CurrentIndex);
-      }
-   }
-}
-
-
-
-static void write_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                             const GLubyte rgba[][4], const GLubyte mask[] )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   GLuint i;
-   y = FLIP(y);
-   if (mask) {
-      /* draw some pixels */
-      for (i=0; i<n; i++) {
-         if (mask[i]) {
-            WriteRGBAPixel( x+i, y, foo->CurrentColor );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0; i<n; i++) {
-         WriteRGBAPixel( x+i, y, foo->CurrentColor );
-      }
-   }
-}
-
-
-static void write_rgb_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                            const GLubyte rgb[][3], const GLubyte mask[] )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   GLuint i;
-   y = FLIP(y);
-   if (mask) {
-      /* draw some pixels */
-      for (i=0; i<n; i++) {
-         if (mask[i]) {
-            WriteRGBPixel( x+i, y, rgb[i] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0; i<n; i++) {
-         WriteRGBPixel( x+i, y, rgb[i] );
-      }
-   }
-}
-
-
-
-static void write_mono_rgba_span( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-                                  const GLubyte mask[])
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   GLint i;
-   y = FLIP(y);
-   for (i=0; i<n; i++) {
-      if (mask[i]) {
-         WriteRGBAPixel( x+i, y, foo->CurrentColor );
-      }
-   }
-}
-
-
-
-/**********************************************************************/
-/*****                 Read spans of pixels                       *****/
-/**********************************************************************/
-
-
-static void read_index_span( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y, GLuint index[])
-{
-   GLint i;
-   for (i=0; i<n; i++) {
-      index[i] = ReadCIPixel( x+i, y );
-   }
-}
-
-
-
-static void read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                            GLubyte rgba[][4] )
-{
-   int i;
-   for (i=0; i<n; i++) {
-      ReadRGBAPixel( x+i, y, rgba[i] );
-   }
-}
-
-
-
-/**********************************************************************/
-/*****              Write arrays of pixels                        *****/
-/**********************************************************************/
-
-
-static void write_index_pixels( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-                                const GLuint index[], const GLubyte mask[] )
-{
-   GLint i;
-   for (i=0; i<n; i++) {
-      if (mask[i]) {
-         WriteCIPixel( x[i], y[i], index[i] );
-      }
-   }
-}
-
-
-
-static void write_mono_index_pixels( const GLcontext *ctx,
-                                     GLuint n,
-                                     const GLint x[], const GLint y[],
-                                     const GLubyte mask[] )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   GLint i;
-   for (i=0; i<n; i++) {
-      if (mask[i]) {
-         WriteCIPixel( x[i], y[i], foo->CurrentIndex );
-      }
-   }
-}
-
-
-
-static void write_rgba_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-                               const GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLint i;
-   for (i=0; i<n; i++) {
-      if (mask[i]) {
-         WriteRGBAPixel( x[i], y[i], rgba[i] );
-      }
-   }
-}
-
-
-
-static void write_mono_rgba_pixels( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-                                    const GLubyte mask[] )
-{
-   struct foo_mesa_context *foo = (struct foo_mesa_context *) ctx->DriverCtx;
-   GLint i;
-   for (i=0; i<n; i++) {
-      if (mask[i]) {
-         WriteRGBAPixel( x[i], y[i], foo->CurrentColor );
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*****                   Read arrays of pixels                    *****/
-/**********************************************************************/
-
-/* Read an array of color index pixels. */
-static void read_index_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-                               GLuint index[], const GLubyte mask[] )
-{
-   GLint i;
-   for (i=0; i<n; i++) {
-      if (mask[i]) {
-         index[i] = ReadCIPixel( x[i], y[i] );
-      }
-   }
-}
-
-
-
-static void read_rgba_pixels( const GLcontext *ctx,
-                              GLuint n, const GLint x[], const GLint y[],
-                              GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLint i;
-   for (i=0; i<n; i++) {
-      if (mask[i]) {
-         ReadRGBAPixel( x[i], y[i], rgba[i] );
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/**********************************************************************/
-
-
-static void setup_DD_pointers( GLcontext *ctx )
-{
-   /* Initialize all the pointers in the DD struct.  Do this whenever */
-   /* a new context is made current or we change buffers via set_buffer! */
-
-   ctx->Driver.UpdateState = setup_DD_pointers;
-
-   ctx->Driver.ClearIndex = clear_index;
-   ctx->Driver.ClearColor = clear_color;
-   ctx->Driver.Clear = clear;
-
-   ctx->Driver.Index = set_index;
-   ctx->Driver.Color = set_color;
-
-   ctx->Driver.SetDrawBuffer = set_draw_buffer;
-   ctx->Driver.SetReadBuffer = set_read_buffer;
-   ctx->Driver.GetBufferSize = get_buffer_size;
-
-   ctx->Driver.PointsFunc = fast_points_function;
-   ctx->Driver.LineFunc = fast_line_function;
-   ctx->Driver.TriangleFunc = fast_triangle_function;
-
-   /* Pixel/span writing functions: */
-   ctx->Driver.WriteRGBASpan       = write_rgba_span;
-   ctx->Driver.WriteRGBSpan        = write_rgb_span;
-   ctx->Driver.WriteMonoRGBASpan   = write_mono_rgba_span;
-   ctx->Driver.WriteRGBAPixels     = write_rgba_pixels;
-   ctx->Driver.WriteMonoRGBAPixels = write_mono_rgba_pixels;
-
-   ctx->Driver.WriteCI32Span       = write_index32_span;
-   ctx->Driver.WriteCI8Span        = write_index8_span;
-   ctx->Driver.WriteMonoCISpan     = write_mono_index_span;
-   ctx->Driver.WriteCI32Pixels     = write_index_pixels;
-   ctx->Driver.WriteMonoCIPixels   = write_mono_index_pixels;
-
-   /* Pixel/span reading functions: */
-   ctx->Driver.ReadCI32Span        = read_index_span;
-   ctx->Driver.ReadRGBASpan        = read_rgba_span;
-   ctx->Driver.ReadCI32Pixels      = read_index_pixels;
-   ctx->Driver.ReadRGBAPixels      = read_rgba_pixels;
-
-
-   /*
-    * OPTIONAL FUNCTIONS:  these may be left uninitialized if the device
-    * driver can't/needn't implement them.
-    */
-   ctx->Driver.Finish = finish;
-   ctx->Driver.Flush = flush;
-   ctx->Driver.IndexMask = index_mask;
-   ctx->Driver.ColorMask = color_mask;
-   ctx->Driver.LogicOp = logicop;
-   ctx->Driver.Dither = dither;
-}
-
-
-
-/**********************************************************************/
-/*****               FOO/Mesa Public API Functions                *****/
-/**********************************************************************/
-
-
-
-/*
- * The exact arguments to this function will depend on your window system
- */
-FooMesaVisual FooMesaCreateVisual( GLboolean rgb_mode, GLboolean dbFlag,
-                                   GLint depthSize, GLint stencilSize,
-                                   GLint accumSize )
-{
-   FooMesaVisual v;
-   GLint redBits, greenBits, blueBits, alphaBits, indexBits;
-   GLboolean alphaFlag = GL_FALSE;
-
-   v = (FooMesaVisual) calloc( 1, sizeof(struct foo_mesa_visual) );
-   if (!v) {
-      return NULL;
-   }
-
-   if (rgb_mode) {
-      /* RGB(A) mode */
-      redBits = 8;         /* XXX 8 is just an example */
-      greenBits = 8;
-      blueBits = 8;
-      alphaBits = 8;
-      indexBits = 0;
-   }
-   else {
-      /* color index mode */
-      redBits = 0;
-      greenBits = 0;
-      blueBits = 0;
-      alphaBits = 0;
-      indexBits = 8;   /* XXX 8 is just an example */
-   }
-
-   /* Create core visual */
-   v->gl_visual = gl_create_visual( rgb_mode, 
-                                    alphaFlag,
-                                    dbFlag,
-                                    GL_FALSE,  /* stereo */
-                                    depthSize,
-                                    stencilSize,
-                                    accumSize,
-                                    indexBits,
-                                    redBits, greenBits, blueBits, alphaBits );
-
-   return v;
-}
-
-
-
-void FooMesaDestroyVisual( FooMesaVisual v )
-{
-   gl_destroy_visual( v->gl_visual );
-   free( v );
-}
-
-
-
-
-FooMesaBuffer FooMesaCreateBuffer( FooMesaVisual visual,
-                                   void *your_window_id )
-{
-   FooMesaBuffer b;
-
-   b = (FooMesaBuffer) calloc( 1, sizeof(struct foo_mesa_buffer) );
-   if (!b) {
-      return NULL;
-   }
-
-   b->gl_buffer = gl_create_framebuffer( visual->gl_visual,
-                                         visual->gl_visual->DepthBits > 0,
-                                         visual->gl_visual->StencilBits > 0,
-                                         visual->gl_visual->AccumBits > 0,
-                                         visual->gl_visual->AlphaBits > 0 );
-   b->the_window = your_window_id;
-
-   /* other stuff */
-
-   return b;
-}
-
-
-
-void FooMesaDestroyBuffer( FooMesaBuffer b )
-{
-   gl_destroy_framebuffer( b->gl_buffer );
-   free( b );
-}
-
-
-
-
-FooMesaContext FooMesaCreateContext( FooMesaVisual visual,
-                                     FooMesaContext share )
-{
-   FooMesaContext c;
-   GLboolean direct = GL_FALSE;
-
-   c = (FooMesaContext) calloc( 1, sizeof(struct foo_mesa_context) );
-   if (!c) {
-      return NULL;
-   }
-
-   c->gl_ctx = gl_create_context( visual->gl_visual,
-                                  share ? share->gl_ctx : NULL,
-                                  (void *) c, direct );
-
-
-   /* you probably have to do a bunch of other initializations here. */
-
-
-   /* and then, finally let the context examine your initializations */
-   _mesa_initialize_context( c->gl_ctx );
-
-
-   return c;
-}
-
-
-
-void FooMesaDestroyContext( FooMesaContext c )
-{
-   gl_destroy_context( c->gl_ctx );
-   free( c );
-}
-
-
-
-/*
- * Make the specified context and buffer the current one.
- */
-void FooMesaMakeCurrent( FooMesaContext c, FooMesaBuffer b )
-{
-   if (c && b) {
-      gl_make_current( c->gl_ctx, b->gl_buffer );
-      CurrentContext = c;
-      CurrentBuffer = b;
-      if (c->gl_ctx->Viewport.Width==0) {
-         /* initialize viewport to window size */
-         gl_Viewport( c->gl_ctx, 0, 0, c->Buffer->Width, c->Buffer->Height );
-      }
-   }
-   else {
-      /* Detach */
-      gl_make_current( NULL, NULL );
-      CurrentContext = 0;
-      CurrentBuffer = 0;
-   }
-}
-
-
-
-void FooMesaSwapBuffers( FooMesaBuffer b )
-{
-   /* copy/swap back buffer to front if applicable */
-}
-
-
-
-/* you may need to add other FOO/Mesa functions too... */
-
Index: xc/extras/Mesa/src/debug.c
diff -u /dev/null xc/extras/Mesa/src/debug.c:1.2
--- /dev/null	Thu Feb 27 12:15:34 2003
+++ xc/extras/Mesa/src/debug.c	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,84 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "mtypes.h"
+#include "debug.h"
+
+void _mesa_print_state( const char *msg, GLuint state )
+{
+   fprintf(stderr,
+	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
+	   msg,
+	   state,
+	   (state & _NEW_MODELVIEW)       ? "ctx->ModelView, " : "",
+	   (state & _NEW_PROJECTION)      ? "ctx->Projection, " : "",
+	   (state & _NEW_TEXTURE_MATRIX)  ? "ctx->TextureMatrix, " : "",
+	   (state & _NEW_COLOR_MATRIX)    ? "ctx->ColorMatrix, " : "",
+	   (state & _NEW_ACCUM)           ? "ctx->Accum, " : "",
+	   (state & _NEW_COLOR)           ? "ctx->Color, " : "",
+	   (state & _NEW_DEPTH)           ? "ctx->Depth, " : "",
+	   (state & _NEW_EVAL)            ? "ctx->Eval/EvalMap, " : "",
+	   (state & _NEW_FOG)             ? "ctx->Fog, " : "",
+	   (state & _NEW_HINT)            ? "ctx->Hint, " : "",
+	   (state & _NEW_LIGHT)           ? "ctx->Light, " : "",
+	   (state & _NEW_LINE)            ? "ctx->Line, " : "",
+	   (state & _NEW_PIXEL)           ? "ctx->Pixel, " : "",
+	   (state & _NEW_POINT)           ? "ctx->Point, " : "",
+	   (state & _NEW_POLYGON)         ? "ctx->Polygon, " : "",
+	   (state & _NEW_POLYGONSTIPPLE)  ? "ctx->PolygonStipple, " : "",
+	   (state & _NEW_SCISSOR)         ? "ctx->Scissor, " : "",
+	   (state & _NEW_TEXTURE)         ? "ctx->Texture, " : "",
+	   (state & _NEW_TRANSFORM)       ? "ctx->Transform, " : "",
+	   (state & _NEW_VIEWPORT)        ? "ctx->Viewport, " : "",
+	   (state & _NEW_PACKUNPACK)      ? "ctx->Pack/Unpack, " : "",
+	   (state & _NEW_ARRAY)           ? "ctx->Array, " : "",
+	   (state & _NEW_RENDERMODE)      ? "ctx->RenderMode, " : "",
+	   (state & _NEW_BUFFERS)         ? "ctx->Visual, ctx->DrawBuffer,, " : "");
+}
+
+
+
+void _mesa_print_tri_caps( const char *name, GLuint flags )
+{
+   fprintf(stderr,
+	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
+	   name,
+	   flags,
+	   (flags & DD_FLATSHADE)           ? "flat-shade, " : "",
+	   (flags & DD_SEPARATE_SPECULAR)   ? "separate-specular, " : "",
+	   (flags & DD_TRI_LIGHT_TWOSIDE)   ? "tri-light-twoside, " : "",
+	   (flags & DD_TRI_UNFILLED)        ? "tri-unfilled, " : "",
+	   (flags & DD_TRI_STIPPLE)         ? "tri-stipple, " : "",
+	   (flags & DD_TRI_OFFSET)          ? "tri-offset, " : "",
+	   (flags & DD_TRI_SMOOTH)          ? "tri-smooth, " : "",
+	   (flags & DD_LINE_SMOOTH)         ? "line-smooth, " : "",
+	   (flags & DD_LINE_STIPPLE)        ? "line-stipple, " : "",
+	   (flags & DD_LINE_WIDTH)          ? "line-wide, " : "",
+	   (flags & DD_POINT_SMOOTH)        ? "point-smooth, " : "",
+	   (flags & DD_POINT_SIZE)          ? "point-size, " : "",
+	   (flags & DD_POINT_ATTEN)         ? "point-atten, " : "",
+	   (flags & DD_TRI_CULL_FRONT_BACK) ? "cull-all, " : ""
+      );
+}
Index: xc/extras/Mesa/src/debug.h
diff -u /dev/null xc/extras/Mesa/src/debug.h:1.2
--- /dev/null	Thu Feb 27 12:15:34 2003
+++ xc/extras/Mesa/src/debug.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,33 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef _DEBUG_H
+#define _DEBUG_H
+
+void _mesa_print_tri_caps( const char *name, GLuint flags );
+void _mesa_print_enable_flags( const char *msg, GLuint flags );
+void _mesa_print_state( const char *msg, GLuint state );
+
+#endif
Index: xc/extras/Mesa/src/debug_xform.c
diff -u xc/extras/Mesa/src/debug_xform.c:1.7 xc/extras/Mesa/src/debug_xform.c:removed
--- xc/extras/Mesa/src/debug_xform.c:1.7	Mon Nov 13 18:30:43 2000
+++ xc/extras/Mesa/src/debug_xform.c	Thu Feb 27 12:15:34 2003
@@ -1,933 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * Updated for P6 architecture by Gareth Hughes.
- */
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "types.h"
-#include "mem.h"
-#include "xform.h"
-#include "debug_xform.h"
-#endif
-
-
-#ifdef DEBUG  /* This code only used for debugging */
-
-
-/* Comment this out to deactivate the cycle counter.
- * NOTE: it works only on CPUs which know the 'rdtsc' command (586 or higher)
- * (hope, you don't try to debug Mesa on a 386 ;)
- */
-#if defined(__GNUC__) && defined(__i386__) && defined(USE_X86_ASM)
-#define  RUN_XFORM_BENCHMARK
-#endif
-
-#define TEST_COUNT		128	/* size of the tested vector array   */
-
-#define REQUIRED_PRECISION	10	/* allow 4 bits to miss              */
-#define MAX_PRECISION		24	/* max. precision possible           */
-
-
-#ifdef  RUN_XFORM_BENCHMARK
-/* Overhead of profiling counter in cycles.  Automatically adjusted to
- * your machine at run time - counter initialization should give very
- * consistent results.
- */
-static int need_counter = 1;
-static long counter_overhead = 0;
-
-/* Modify the the number of tests if you like.
- * We take the minimum of all results, because every error should be
- * positive (time used by other processes, task switches etc).
- * It is assumed that all calculations are done in the cache.
- */
-
-#if 1 /* PPro, PII, PIII version */
-
-/* Profiling on the P6 architecture requires a little more work, due to
- * the internal out-of-order execution.  We must perform a serializing
- * 'cpuid' instruction before and after the 'rdtsc' instructions to make
- * sure no other uops are executed when we sample the timestamp counter.
- */
-#define  INIT_COUNTER()							\
-   do {									\
-      int cycle_i;							\
-      counter_overhead = LONG_MAX;					\
-      for ( cycle_i = 0 ; cycle_i < 4 ; cycle_i++ ) {			\
-	 long cycle_tmp1 = 0, cycle_tmp2 = 0;				\
-	 __asm__ ( "push %%ebx       \n"				\
-		   "xor %%eax, %%eax \n"				\
-		   "cpuid            \n"				\
-		   "rdtsc            \n"				\
-		   "mov %%eax, %0    \n"				\
-		   "xor %%eax, %%eax \n"				\
-		   "cpuid            \n"				\
-		   "pop %%ebx        \n"				\
-		   "push %%ebx       \n"				\
-		   "xor %%eax, %%eax \n"				\
-		   "cpuid            \n"				\
-		   "rdtsc            \n"				\
-		   "mov %%eax, %1    \n"				\
-		   "xor %%eax, %%eax \n"				\
-		   "cpuid            \n"				\
-		   "pop %%ebx        \n"				\
-		   : "=m" (cycle_tmp1), "=m" (cycle_tmp2)		\
-		   : : "eax", "ecx", "edx" );				\
-	 if ( counter_overhead > (cycle_tmp2 - cycle_tmp1) ) {		\
-	    counter_overhead = cycle_tmp2 - cycle_tmp1;			\
-	 }								\
-      }									\
-   } while (0)
-
-#define  BEGIN_RACE(x)							\
-   x = LONG_MAX;							\
-   for ( cycle_i = 0 ; cycle_i < 10 ; cycle_i++ ) {			\
-      long cycle_tmp1 = 0, cycle_tmp2 = 0;				\
-      __asm__ ( "push %%ebx       \n"					\
-		"xor %%eax, %%eax \n"					\
-		"cpuid            \n"					\
-		"rdtsc            \n"					\
-		"mov %%eax, %0    \n"					\
-		"xor %%eax, %%eax \n"					\
-		"cpuid            \n"					\
-		"pop %%ebx        \n"					\
-		: "=m" (cycle_tmp1)					\
-		: : "eax", "ecx", "edx" );
-
-#define END_RACE(x)							\
-      __asm__ ( "push %%ebx       \n"					\
-		"xor %%eax, %%eax \n"					\
-		"cpuid            \n"					\
-		"rdtsc            \n"					\
-		"mov %%eax, %0    \n"					\
-		"xor %%eax, %%eax \n"					\
-		"cpuid            \n"					\
-		"pop %%ebx        \n"					\
-		: "=m" (cycle_tmp2)					\
-		: : "eax", "ecx", "edx" );				\
-      if ( x > (cycle_tmp2 - cycle_tmp1) ) {				\
-	 x = cycle_tmp2 - cycle_tmp1;					\
-      }									\
-   }									\
-   x -= counter_overhead;
-
-#else /* PPlain, PMMX version */
-
-/* To ensure accurate results, we stall the pipelines with the
- * non-pairable 'cdq' instruction.  This ensures all the code being
- * profiled is complete when the 'rdtsc' instruction executes.
- */
-#define  INIT_COUNTER(x)						\
-   do {									\
-      int cycle_i;							\
-      x = LONG_MAX;							\
-      for ( cycle_i = 0 ; cycle_i < 32 ; cycle_i++ ) {			\
-	 long cycle_tmp1, cycle_tmp2, dummy;				\
-	 __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp1) );		\
-	 __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp2) );		\
-	 __asm__ ( "cdq" );						\
-	 __asm__ ( "cdq" );						\
-	 __asm__ ( "rdtsc" : "=a" (cycle_tmp1), "=d" (dummy) );		\
-	 __asm__ ( "cdq" );						\
-	 __asm__ ( "cdq" );						\
-	 __asm__ ( "rdtsc" : "=a" (cycle_tmp2), "=d" (dummy) );		\
-	 if ( x > (cycle_tmp2 - cycle_tmp1) )				\
-	    x = cycle_tmp2 - cycle_tmp1;				\
-      }									\
-   } while (0)
-
-#define  BEGIN_RACE(x)							\
-   x = LONG_MAX;							\
-   for ( cycle_i = 0 ; cycle_i < 16 ; cycle_i++ ) {			\
-      long cycle_tmp1, cycle_tmp2, dummy;				\
-      __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp1) );			\
-      __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp2) );			\
-      __asm__ ( "cdq" );						\
-      __asm__ ( "cdq" );						\
-      __asm__ ( "rdtsc" : "=a" (cycle_tmp1), "=d" (dummy) );
-
-
-#define END_RACE(x)							\
-      __asm__ ( "cdq" );						\
-      __asm__ ( "cdq" );						\
-      __asm__ ( "rdtsc" : "=a" (cycle_tmp2), "=d" (dummy) );		\
-      if ( x > (cycle_tmp2 - cycle_tmp1) )				\
-	 x = cycle_tmp2 - cycle_tmp1;					\
-   }									\
-   x -= counter_overhead;
-
-#endif
-
-#else
-
-#define INIT_COUNTER(x)
-#define BEGIN_RACE(x)
-#define END_RACE(x)
-
-#endif
-
-
-static char *mesa_profile = NULL;
-
-
-enum { NIL=0, ONE=1, NEG=-1, VAR=2 };
-
-static int m_general[16] = {
-   VAR, VAR, VAR, VAR,
-   VAR, VAR, VAR, VAR,
-   VAR, VAR, VAR, VAR,
-   VAR, VAR, VAR, VAR
-};
-static int m_identity[16] = {
-   ONE, NIL, NIL, NIL,
-   NIL, ONE, NIL, NIL,
-   NIL, NIL, ONE, NIL,
-   NIL, NIL, NIL, ONE
-};
-static int  m_2d[16]  = {
-   VAR, VAR, NIL, VAR,
-   VAR, VAR, NIL, VAR,
-   NIL, NIL, ONE, NIL,
-   NIL, NIL, NIL, ONE
-};
-static int m_2d_no_rot[16] = {
-   VAR, NIL, NIL, VAR,
-   NIL, VAR, NIL, VAR,
-   NIL, NIL, ONE, NIL,
-   NIL, NIL, NIL, ONE
-};
-static int m_3d[16] = {
-   VAR, VAR, VAR, VAR,
-   VAR, VAR, VAR, VAR,
-   VAR, VAR, VAR, VAR,
-   NIL, NIL, NIL, ONE
-};
-static int m_3d_no_rot[16] = {
-   VAR, NIL, NIL, VAR,
-   NIL, VAR, NIL, VAR,
-   NIL, NIL, VAR, VAR,
-   NIL, NIL, NIL, ONE
-};
-static int m_perspective[16] = {
-   VAR, NIL, VAR, NIL,
-   NIL, VAR, VAR, NIL,
-   NIL, NIL, VAR, VAR,
-   NIL, NIL, NEG, NIL
-};
-static int *templates[7] = {
-   m_general,
-   m_identity,
-   m_3d_no_rot,
-   m_perspective,
-   m_2d,
-   m_2d_no_rot,
-   m_3d
-};
-static int mtypes[7] = {
-   MATRIX_GENERAL,
-   MATRIX_IDENTITY,
-   MATRIX_3D_NO_ROT,
-   MATRIX_PERSPECTIVE,
-   MATRIX_2D,
-   MATRIX_2D_NO_ROT,
-   MATRIX_3D
-};
-static char *mstrings[7] = {
-   "MATRIX_GENERAL",
-   "MATRIX_IDENTITY",
-   "MATRIX_3D_NO_ROT",
-   "MATRIX_PERSPECTIVE",
-   "MATRIX_2D",
-   "MATRIX_2D_NO_ROT",
-   "MATRIX_3D"
-};
-
-
-
-static int m_norm_identity[16] = {
-   ONE, NIL, NIL, NIL,
-   NIL, ONE, NIL, NIL,
-   NIL, NIL, ONE, NIL,
-   NIL, NIL, NIL, NIL
-};
-static int m_norm_general[16] = {
-   VAR, VAR, VAR, NIL,
-   VAR, VAR, VAR, NIL,
-   VAR, VAR, VAR, NIL,
-   NIL, NIL, NIL, NIL
-};
-static int m_norm_no_rot[16] = {
-   VAR, NIL, NIL, NIL,
-   NIL, VAR, NIL, NIL,
-   NIL, NIL, VAR, NIL,
-   NIL, NIL, NIL, NIL
-};
-static int *norm_templates[8] = {
-   m_norm_no_rot,
-   m_norm_no_rot,
-   m_norm_no_rot,
-   m_norm_general,
-   m_norm_general,
-   m_norm_general,
-   m_norm_identity,
-   m_norm_identity
-};
-static int norm_types[8] = {
-   NORM_TRANSFORM_NO_ROT,
-   NORM_TRANSFORM_NO_ROT | NORM_RESCALE,
-   NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE,
-   NORM_TRANSFORM,
-   NORM_TRANSFORM | NORM_RESCALE,
-   NORM_TRANSFORM | NORM_NORMALIZE,
-   NORM_RESCALE,
-   NORM_NORMALIZE
-};
-static int norm_scale_types[8] = {               /*  rescale factor          */
-   NIL,                                          /*  NIL disables rescaling  */
-   VAR,
-   NIL,
-   NIL,
-   VAR,
-   NIL,
-   VAR,
-   NIL
-};
-static int norm_normalize_types[8] = {           /*  normalizing ?? (no = 0) */
-   0,
-   0,
-   1,
-   0,
-   0,
-   1,
-   0,
-   1
-};
-static char *norm_strings[8] = {
-   "NORM_TRANSFORM_NO_ROT",
-   "NORM_TRANSFORM_NO_ROT | NORM_RESCALE",
-   "NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE",
-   "NORM_TRANSFORM",
-   "NORM_TRANSFORM | NORM_RESCALE",
-   "NORM_TRANSFORM | NORM_NORMALIZE",
-   "NORM_RESCALE",
-   "NORM_NORMALIZE"
-};
-
-
-
-/* ================================================================
- * Helper functions
- */
-
-static GLfloat rnd( void )
-{
-   GLfloat f = (GLfloat)rand() / (GLfloat)RAND_MAX;
-   GLfloat gran = (GLfloat)(1 << 13);
-
-   f = (GLfloat)(GLint)(f * gran) / gran;
-
-   return f * 2.0 - 1.0;
-}
-
-static int significand_match( GLfloat a, GLfloat b )
-{
-   GLfloat d = a - b;
-   int a_ex, b_ex, d_ex;
-
-   if ( d == 0.0F ) {
-      return MAX_PRECISION;   /* Exact match */
-   }
-
-   if ( a == 0.0F || b == 0.0F ) {
-      /* It would probably be better to check if the
-       * non-zero number is denormalized and return
-       * the index of the highest set bit here.
-       */
-      return 0;
-   }
-
-   frexp( a, &a_ex );
-   frexp( b, &b_ex );
-   frexp( d, &d_ex );
-
-   if ( a_ex < b_ex )
-      return a_ex - d_ex;
-   else
-      return b_ex - d_ex;
-}
-
-
-
-/* ================================================================
- * Reference transformations
- */
-
-static void ref_transform( GLvector4f *dst,
-                           const GLmatrix *mat,
-                           const GLvector4f *src,
-                           const GLubyte *clipmask,
-                           const GLubyte flag )
-{
-   GLuint i;
-   GLfloat *s = (GLfloat *)src->start;
-   GLfloat (*d)[4] = (GLfloat (*)[4])dst->start;
-   const GLfloat *m = mat->m;
-
-   (void) clipmask;
-   (void) flag;
-
-   for ( i = 0 ; i < src->count ; i++ ) {
-      GLfloat x = s[0], y = s[1], z = s[2], w = s[3];
-      d[i][0] = m[0]*x + m[4]*y + m[ 8]*z + m[12]*w;
-      d[i][1] = m[1]*x + m[5]*y + m[ 9]*z + m[13]*w;
-      d[i][2] = m[2]*x + m[6]*y + m[10]*z + m[14]*w;
-      d[i][3] = m[3]*x + m[7]*y + m[11]*z + m[15]*w;
-      s = (GLfloat *)((char *)s + src->stride);
-   }
-}
-
-static void ref_norm_transform_rescale( const GLmatrix *mat,
-					GLfloat scale,
-					const GLvector3f *in,
-					const GLfloat *lengths,
-					const GLubyte mask[],
-					GLvector3f *dest )
-{
-   GLuint i;
-   const GLfloat *s = in->start;
-   const GLfloat *m = mat->inv;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-
-   (void) mask;
-   (void) lengths;
-
-   for ( i = 0 ; i < in->count ; i++ ) {
-      GLfloat x = s[0], y = s[1], z = s[2] ;
-      GLfloat tx = m[0]*x + m[1]*y + m[ 2]*z ;
-      GLfloat ty = m[4]*x + m[5]*y + m[ 6]*z ;
-      GLfloat tz = m[8]*x + m[9]*y + m[10]*z ;
-
-      out[i][0] = tx * scale;
-      out[i][1] = ty * scale;
-      out[i][2] = tz * scale;
-
-      s = (GLfloat *)((char *)s + in->stride);
-   }
-}
-
-static void ref_norm_transform_normalize( const GLmatrix *mat,
-					  GLfloat scale,
-					  const GLvector3f *in,
-					  const GLfloat *lengths,
-					  const GLubyte mask[],
-					  GLvector3f *dest )
-{
-   GLuint i;
-   const GLfloat *s = in->start;
-   const GLfloat *m = mat->inv;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-
-   (void) mask;
-
-   for ( i = 0 ; i < in->count ; i++ ) {
-      GLfloat x = s[0], y = s[1], z = s[2] ;
-      GLfloat tx = m[0]*x + m[1]*y + m[ 2]*z ;
-      GLfloat ty = m[4]*x + m[5]*y + m[ 6]*z ;
-      GLfloat tz = m[8]*x + m[9]*y + m[10]*z ;
-
-      if ( !lengths ) {
-         GLfloat len = tx*tx + ty*ty + tz*tz;
-         if ( len > 1e-20 ) {
-	    /* Hmmm, don't know how we could test the precalculated
-	     * length case...
-	     */
-            scale = 1.0 / sqrt( len );
-            out[i][0] = tx * scale;
-            out[i][1] = ty * scale;
-            out[i][2] = tz * scale;
-         } else {
-            out[i][0] = out[i][1] = out[i][2] = 0;
-         }
-      } else {
-         scale = lengths[i];;
-         out[i][0] = tx * scale;
-         out[i][1] = ty * scale;
-         out[i][2] = tz * scale;
-      }
-
-      s = (GLfloat *)((char *)s + in->stride);
-   }
-}
-
-
-
-/* ================================================================
- * Vertex transformation tests
- */
-
-/* Ensure our arrays are correctly aligned.
- */
-#if defined(__GNUC__)
-#define ALIGN16(x)		x __attribute__ ((aligned (16)))
-#else
-#define ALIGN16(x)		x
-#endif
-static GLfloat ALIGN16(s[TEST_COUNT][5]);
-static GLfloat ALIGN16(d[TEST_COUNT][4]);
-static GLfloat ALIGN16(r[TEST_COUNT][4]);
-
-static int test_transform_function( transform_func func, int psize, int mtype,
-                                    int masked, long *cycles )
-{
-   GLvector4f source[1], dest[1], ref[1];
-   GLmatrix mat[1];
-   GLfloat *m;
-   GLubyte mask[TEST_COUNT];
-   int i, j;
-#ifdef  RUN_XFORM_BENCHMARK
-   int cycle_i;                /* the counter for the benchmarks we run */
-#endif
-
-   (void) cycles;
-
-   if ( psize > 4 ) {
-      gl_problem( NULL, "test_transform_function called with psize > 4\n" );
-      return 0;
-   }
-
-   mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
-   mat->type = mtypes[mtype];
-
-   m = mat->m;
-
-   m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0;
-   m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] =  7.0;
-   m[2] = 44.0; m[6] =  9.0; m[10] =  7.0; m[14] =  3.0;
-   m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] =  9.0;
-
-   for ( i = 0 ; i < 4 ; i++ ) {
-      for ( j = 0 ; j < 4 ; j++ ) {
-         switch ( templates[mtype][i * 4 + j] ) {
-         case NIL:
-            m[j * 4 + i] = 0.0;
-            break;
-         case ONE:
-            m[j * 4 + i] = 1.0;
-            break;
-         case NEG:
-            m[j * 4 + i] = -1.0;
-            break;
-         case VAR:
-            break;
-         default:
-            abort();
-         }
-      }
-   }
-
-   for ( i = 0 ; i < TEST_COUNT ; i++) {
-      mask[i] = i % 2;				/* mask every 2nd element */
-      d[i][0] = s[i][0] = 0.0;
-      d[i][1] = s[i][1] = 0.0;
-      d[i][2] = s[i][2] = 0.0;
-      d[i][3] = s[i][3] = 1.0;
-      for ( j = 0 ; j < psize ; j++ )
-         s[i][j] = rnd();
-   }
-
-   source->data = (GLfloat(*)[4])s;
-   source->start = (GLfloat *)s;
-   source->count = TEST_COUNT;
-   source->stride = sizeof(s[0]);
-   source->size = 4;
-   source->flags = 0;
-
-   dest->data = (GLfloat(*)[4])d;
-   dest->start = (GLfloat *)d;
-   dest->count = TEST_COUNT;
-   dest->stride = sizeof(float[4]);
-   dest->size = 0;
-   dest->flags = 0;
-
-   ref->data = (GLfloat(*)[4])r;
-   ref->start = (GLfloat *)r;
-   ref->count = TEST_COUNT;
-   ref->stride = sizeof(float[4]);
-   ref->size = 0;
-   ref->flags = 0;
-
-   ref_transform( ref, mat, source, NULL, 0 );
-
-   if ( mesa_profile ) {
-      if ( masked ) {
-         BEGIN_RACE( *cycles );
-         func( dest, mat->m, source, mask, 1 );
-         END_RACE( *cycles );
-      } else {
-         BEGIN_RACE( *cycles );
-         func( dest, mat->m, source, NULL, 0 );
-         END_RACE( *cycles );
-     }
-   }
-   else {
-      if ( masked ) {
-         func( dest, mat->m, source, mask, 1 );
-      } else {
-         func( dest, mat->m, source, NULL, 0 );
-      }
-   }
-
-   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
-      if ( masked && (mask[i] & 1) )
-         continue;
-
-      for ( j = 0 ; j < 4 ; j++ ) {
-         if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
-            printf( "-----------------------------\n" );
-            printf( "(i = %i, j = %i)\n", i, j );
-            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
-		    d[i][0], r[i][0], r[i][0]-d[i][0],
-		    MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
-            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
-		    d[i][1], r[i][1], r[i][1]-d[i][1],
-		    MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
-            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
-		    d[i][2], r[i][2], r[i][2]-d[i][2],
-		    MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
-            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
-		    d[i][3], r[i][3], r[i][3]-d[i][3],
-		    MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
-            return 0;
-         }
-      }
-   }
-
-   ALIGN_FREE( mat->m );
-   return 1;
-}
-
-void gl_test_all_transform_functions( char *description )
-{
-   int masked, psize, mtype;
-   long benchmark_tab[2][4][7];
-   static int first_time = 1;
-
-   if ( first_time ) {
-      first_time = 0;
-      mesa_profile = getenv( "MESA_PROFILE" );
-   }
-
-#ifdef RUN_XFORM_BENCHMARK
-   if ( mesa_profile ) {
-      if ( need_counter ) {
-	 need_counter = 0;
-	 INIT_COUNTER();
-	 printf( "counter overhead: %ld cycles\n\n", counter_overhead );
-      }
-      printf( "transform results after hooking in %s functions:\n", description );
-   }
-#endif
-
-   for ( masked = 0 ; masked <= 1 ; masked++ ) {
-      int cma = masked ? CULL_MASK_ACTIVE : 0;
-      char *cmastring = masked ? "CULL_MASK_ACTIVE" : "0";
-
-#ifdef RUN_XFORM_BENCHMARK
-      if ( mesa_profile ) {
-         printf( "\n culling: %s \n", masked ? "CULL_MASK_ACTIVE" : "0" );
-         for ( psize = 1 ; psize <= 4 ; psize++ ) {
-            printf( " p%d\t", psize );
-         }
-         printf( "\n--------------------------------------------------------\n" );
-      }
-#endif
-
-      for ( mtype = 0 ; mtype < 7 ; mtype++ ) {
-         for ( psize = 1 ; psize <= 4 ; psize++ ) {
-            transform_func func = gl_transform_tab[cma][psize][mtypes[mtype]];
-            long *cycles = &(benchmark_tab[cma][psize-1][mtype]);
-
-            if ( test_transform_function( func, psize, mtype,
-					  masked, cycles ) == 0 ) {
-               char buf[100];
-               sprintf( buf, "gl_transform_tab[%s][%d][%s] failed test (%s)",
-                        cmastring, psize, mstrings[mtype], description );
-               gl_problem( NULL, buf );
-            }
-#ifdef RUN_XFORM_BENCHMARK
-            if ( mesa_profile )
-               printf( " %li\t", benchmark_tab[cma][psize-1][mtype] );
-#endif
-         }
-#ifdef RUN_XFORM_BENCHMARK
-         if ( mesa_profile )
-            printf( " | [%s]\n", mstrings[mtype] );
-#endif
-      }
-#ifdef RUN_XFORM_BENCHMARK
-      if ( mesa_profile )
-         printf( "\n" );
-#endif
-   }
-}
-
-
-
-/* ================================================================
- * Normal transformation tests
- */
-
-static int test_norm_function( normal_func func, int mtype,
-			       int masked, long *cycles )
-{
-   GLvector3f source[1], dest[1], dest2[1], ref[1], ref2[1];
-   GLmatrix mat[1];
-   GLfloat s[TEST_COUNT][5], d[TEST_COUNT][3], r[TEST_COUNT][3];
-   GLfloat d2[TEST_COUNT][3], r2[TEST_COUNT][3], length[TEST_COUNT];
-   GLfloat scale;
-   GLfloat *m;
-   GLubyte mask[TEST_COUNT];
-   int i, j;
-#ifdef  RUN_XFORM_BENCHMARK
-   int cycle_i;		/* the counter for the benchmarks we run */
-#endif
-
-   (void) cycles;
-
-   mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
-   mat->inv = m = mat->m;
-
-   m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0;
-   m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] =  7.0;
-   m[2] = 44.0; m[6] =  9.0; m[10] =  7.0; m[14] =  3.0;
-   m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] =  9.0;
-
-   scale = 1.0F + rnd () * norm_scale_types[mtype];
-
-   for ( i = 0 ; i < 4 ; i++ ) {
-      for ( j = 0 ; j < 4 ; j++ ) {
-         switch ( norm_templates[mtype][i * 4 + j] ) {
-         case NIL:
-            m[j * 4 + i] = 0.0;
-            break;
-         case ONE:
-            m[j * 4 + i] = 1.0;
-            break;
-         case NEG:
-            m[j * 4 + i] = -1.0;
-            break;
-         case VAR:
-            break;
-         default:
-            abort();
-         }
-      }
-   }
-
-   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
-      mask[i] = i % 2;				/* mask every 2nd element */
-      d[i][0] = s[i][0] = d2[i][0] = 0.0;
-      d[i][1] = s[i][1] = d2[i][1] = 0.0;
-      d[i][2] = s[i][2] = d2[i][2] = 0.0;
-      for ( j = 0 ; j < 3 ; j++ )
-         s[i][j] = rnd();
-      length[i] = 1 / sqrt( s[i][0]*s[i][0] +
-			    s[i][1]*s[i][1] +
-			    s[i][2]*s[i][2] );
-   }
-
-   source->data = (GLfloat(*)[3])s;
-   source->start = (GLfloat *)s;
-   source->count = TEST_COUNT;
-   source->stride = sizeof(s[0]);
-   source->flags = 0;
-
-   dest->data = (GLfloat(*)[3])d;
-   dest->start = (GLfloat *)d;
-   dest->count = TEST_COUNT;
-   dest->stride = sizeof(float[3]);
-   dest->flags = 0;
-
-   dest2->data = (GLfloat(*)[3])d2;
-   dest2->start = (GLfloat *)d2;
-   dest2->count = TEST_COUNT;
-   dest2->stride = sizeof(float[3]);
-   dest2->flags = 0;
-
-   ref->data = (GLfloat(*)[3])r;
-   ref->start = (GLfloat *)r;
-   ref->count = TEST_COUNT;
-   ref->stride = sizeof(float[3]);
-   ref->flags = 0;
-
-   ref2->data = (GLfloat(*)[3])r2;
-   ref2->start = (GLfloat *)r2;
-   ref2->count = TEST_COUNT;
-   ref2->stride = sizeof(float[3]);
-   ref2->flags = 0;
-
-   if ( norm_normalize_types[mtype] == 0 ) {
-      ref_norm_transform_rescale( mat, scale, source, NULL, NULL, ref );
-   } else {
-      ref_norm_transform_normalize( mat, scale, source, NULL, NULL, ref );
-      ref_norm_transform_normalize( mat, scale, source, length, NULL, ref2 );
-   }
-
-   if ( mesa_profile ) {
-      if ( masked ) {
-         BEGIN_RACE( *cycles );
-         func( mat, scale, source, NULL, mask, dest );
-         END_RACE( *cycles );
-         func( mat, scale, source, length, mask, dest2 );
-      } else {
-         BEGIN_RACE( *cycles );
-         func( mat, scale, source, NULL, NULL, dest );
-         END_RACE( *cycles );
-         func( mat, scale, source, length, NULL, dest2 );
-      }
-   } else {
-      if ( masked ) {
-         func( mat, scale, source, NULL, mask, dest );
-         func( mat, scale, source, length, mask, dest2 );
-      } else {
-         func( mat, scale, source, NULL, NULL, dest );
-         func( mat, scale, source, length, NULL, dest2 );
-      }
-   }
-
-   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
-      if ( masked && !(mask[i] & 1) )
-         continue;
-
-      for ( j = 0 ; j < 3 ; j++ ) {
-         if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
-            printf( "-----------------------------\n" );
-            printf( "(i = %i, j = %i)\n", i, j );
-            printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
-		    d[i][0], r[i][0], r[i][0]/d[i][0],
-		    MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
-            printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
-		    d[i][1], r[i][1], r[i][1]/d[i][1],
-		    MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
-            printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
-		    d[i][2], r[i][2], r[i][2]/d[i][2],
-		    MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
-            return 0;
-         }
-
-         if ( norm_normalize_types[mtype] != 0 ) {
-            if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) {
-               printf( "------------------- precalculated length case ------\n" );
-               printf( "(i = %i, j = %i)\n", i, j );
-               printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
-		       d2[i][0], r2[i][0], r2[i][0]/d2[i][0],
-		       MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) );
-               printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
-		       d2[i][1], r2[i][1], r2[i][1]/d2[i][1],
-		       MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) );
-               printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
-		       d2[i][2], r2[i][2], r2[i][2]/d2[i][2],
-		       MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) );
-               return 0;
-            }
-         }
-      }
-   }
-
-   ALIGN_FREE( mat->m );
-   return 1;
-}
-
-void gl_test_all_normal_transform_functions( char *description )
-{
-   int masked;
-   int mtype;
-   long benchmark_tab[0xf][0x4];
-   static int first_time = 1;
-
-   if ( first_time ) {
-      first_time = 0;
-      mesa_profile = getenv( "MESA_PROFILE" );
-   }
-
-#ifdef RUN_XFORM_BENCHMARK
-   if ( mesa_profile ) {
-      if ( need_counter ) {
-	 need_counter = 0;
-	 INIT_COUNTER();
-	 printf( "counter overhead: %ld cycles\n\n", counter_overhead );
-      }
-      printf( "normal transform results after hooking in %s functions:\n",
-	      description );
-   }
-#endif
-
-   for ( masked = 0 ; masked <= 1 ; masked++ ) {
-      int cma = masked ? CULL_MASK_ACTIVE : 0;
-      char *cmastring = masked ? "CULL_MASK_ACTIVE" : "0";
-
-#ifdef RUN_XFORM_BENCHMARK
-      if ( mesa_profile ) {
-         printf( "\n culling: %s \n", masked ? "CULL_MASK_ACTIVE" : "0" );
-         printf( "\n-------------------------------------------------------\n" );
-      }
-#endif
-
-      for ( mtype = 0 ; mtype < 8 ; mtype++ ) {
-         normal_func func = gl_normal_tab[norm_types[mtype]][cma];
-         long *cycles = &(benchmark_tab[mtype][cma]);
-
-         if ( test_norm_function( func, mtype, masked, cycles ) == 0 ) {
-            char buf[100];
-            sprintf( buf, "gl_normal_tab[%s][%s] failed test (%s)",
-                     cmastring, norm_strings[mtype], description );
-            gl_problem( NULL, buf );
-	 }
-
-#ifdef RUN_XFORM_BENCHMARK
-         if ( mesa_profile ) {
-            printf( " %li\t", benchmark_tab[mtype][cma] );
-            printf( " | [%s]\n", norm_strings[mtype] );
-         }
-      }
-      if ( mesa_profile )
-	 printf( "\n" );
-#else
-      }
-#endif
-   }
-#ifdef RUN_XFORM_BENCHMARK
-   if ( mesa_profile )
-      fflush( stdout );
-#endif
-}
-
-#endif /* DEBUG */
Index: xc/extras/Mesa/src/debug_xform.h
diff -u xc/extras/Mesa/src/debug_xform.h:1.3 xc/extras/Mesa/src/debug_xform.h:removed
--- xc/extras/Mesa/src/debug_xform.h:1.3	Tue Feb 15 02:12:08 2000
+++ xc/extras/Mesa/src/debug_xform.h	Thu Feb 27 12:15:35 2003
@@ -1,36 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef _debug_xform_h
-#define _debug_xform_h
-
-
-extern void gl_test_all_transform_functions( char *description );
-
-extern void gl_test_all_normal_transform_functions( char *description );
-
-#endif
-
Index: xc/extras/Mesa/src/depth.c
diff -u xc/extras/Mesa/src/depth.c:1.6 xc/extras/Mesa/src/depth.c:1.7
--- xc/extras/Mesa/src/depth.c:1.6	Tue Mar 20 21:48:45 2001
+++ xc/extras/Mesa/src/depth.c	Fri Feb 22 14:25:27 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -31,9 +31,9 @@
 #include "context.h"
 #include "enums.h"
 #include "depth.h"
+#include "macros.h"
 #include "mem.h"
-#include "pb.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -48,8 +48,14 @@
 _mesa_ClearDepth( GLclampd depth )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClearDepth");
-   ctx->Depth.Clear = (GLfloat) CLAMP( depth, 0.0, 1.0 );
+   GLfloat tmp = (GLfloat) CLAMP( depth, 0.0, 1.0 );
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->Depth.Clear == tmp)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_DEPTH);
+   ctx->Depth.Clear = tmp;
    if (ctx->Driver.ClearDepth)
       (*ctx->Driver.ClearDepth)( ctx, ctx->Depth.Clear );
 }
@@ -60,41 +66,34 @@
 _mesa_DepthFunc( GLenum func )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDepthFunc");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
-      fprintf(stderr, "glDepthFunc %s\n", gl_lookup_enum_by_nr(func));
+      fprintf(stderr, "glDepthFunc %s\n", _mesa_lookup_enum_by_nr(func));
 
    switch (func) {
-      case GL_LESS:    /* (default) pass if incoming z < stored z */
-      case GL_GEQUAL:
-      case GL_LEQUAL:
-      case GL_GREATER:
-      case GL_NOTEQUAL:
-      case GL_EQUAL:
-      case GL_ALWAYS:
-	 if (ctx->Depth.Func != func) {
-	    ctx->Depth.Func = func;
-	    ctx->NewState |= NEW_RASTER_OPS;
-	    ctx->TriangleCaps &= ~DD_Z_NEVER;
-	    if (ctx->Driver.DepthFunc) {
-	       (*ctx->Driver.DepthFunc)( ctx, func );
-	    }
-	 }
-         break;
-      case GL_NEVER:
-	 if (ctx->Depth.Func != func) {
-	    ctx->Depth.Func = func;
-	    ctx->NewState |= NEW_RASTER_OPS;
-	    ctx->TriangleCaps |= DD_Z_NEVER;
-	    if (ctx->Driver.DepthFunc) {
-	       (*ctx->Driver.DepthFunc)( ctx, func );
-	    }
-	 }
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glDepth.Func" );
+   case GL_LESS:    /* (default) pass if incoming z < stored z */
+   case GL_GEQUAL:
+   case GL_LEQUAL:
+   case GL_GREATER:
+   case GL_NOTEQUAL:
+   case GL_EQUAL:
+   case GL_ALWAYS:
+   case GL_NEVER:
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glDepth.Func" );
+      return;
    }
+
+   if (ctx->Depth.Func == func)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_DEPTH);
+   ctx->Depth.Func = func;
+
+   if (ctx->Driver.DepthFunc)
+      ctx->Driver.DepthFunc( ctx, func );
 }
 
 
@@ -103,7 +102,7 @@
 _mesa_DepthMask( GLboolean flag )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDepthMask");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
       fprintf(stderr, "glDepthMask %d\n", flag);
@@ -112,1614 +111,12 @@
     * GL_TRUE indicates depth buffer writing is enabled (default)
     * GL_FALSE indicates depth buffer writing is disabled
     */
-   if (ctx->Depth.Mask != flag) {
-      ctx->Depth.Mask = flag;
-      ctx->NewState |= NEW_RASTER_OPS;
-      if (ctx->Driver.DepthMask) {
-	 (*ctx->Driver.DepthMask)( ctx, flag );
-      }
-   }
-}
-
-
-
-/**********************************************************************/
-/*****                           Misc                             *****/
-/**********************************************************************/
-
-/*
- * Return address of depth buffer value for given window coord.
- */
-GLvoid *
-_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y)
-{
-   if (ctx->Visual->DepthBits <= 16)
-      return (GLushort *) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width * y + x;
-   else
-      return (GLuint *) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width * y + x;
-}
-
-
-#define Z_ADDRESS16( CTX, X, Y )				\
-            ( ((GLushort *) (CTX)->DrawBuffer->DepthBuffer)	\
-              + (CTX)->DrawBuffer->Width * (Y) + (X) )
-
-#define Z_ADDRESS32( CTX, X, Y )				\
-            ( ((GLuint *) (CTX)->DrawBuffer->DepthBuffer)	\
-              + (CTX)->DrawBuffer->Width * (Y) + (X) )
-
-
-
-/**********************************************************************/
-/*****                   Depth Testing Functions                  *****/
-/**********************************************************************/
-
-
-/*
- * Do depth test for an array of fragments.  This is used both for
- * software and hardware Z buffers.
- * Input:  zbuffer - array of z values in the zbuffer
- *         z - array of fragment z values
- * Return:  number of fragments which pass the test.
- */
-static GLuint
-depth_test_span16( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                   GLushort zbuffer[], const GLdepth z[], GLubyte mask[] )
-{
-   GLuint passed = 0;
-
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  zbuffer[i] = z[i];
-		  passed++;
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	    passed = n;
-	 }
-	 break;
-      case GL_NEVER:
-         BZERO(mask, n * sizeof(GLubyte));
-	 break;
-      default:
-         gl_problem(ctx, "Bad depth func in depth_test_span16");
-   }
-
-   return passed;
-}
-
-
-static GLuint
-depth_test_span32( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                   GLuint zbuffer[], const GLdepth z[], GLubyte mask[] )
-{
-   GLuint passed = 0;
-
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     zbuffer[i] = z[i];
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     /* pass */
-		     passed++;
-		  }
-		  else {
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  zbuffer[i] = z[i];
-		  passed++;
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	    passed = n;
-	 }
-	 break;
-      case GL_NEVER:
-         BZERO(mask, n * sizeof(GLubyte));
-	 break;
-      default:
-         gl_problem(ctx, "Bad depth func in depth_test_span32");
-   }
-
-   return passed;
-}
-
-
-
-/*
- * Apply depth test to span of fragments.  Hardware or software z buffer.
- */
-GLuint
-_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                       const GLdepth z[], GLubyte mask[] )
-{
-   if (ctx->Driver.ReadDepthSpan) {
-      /* hardware-based depth buffer */
-      GLdepth zbuffer[MAX_WIDTH];
-      GLuint passed;
-      (*ctx->Driver.ReadDepthSpan)(ctx, n, x, y, zbuffer);
-      passed = depth_test_span32(ctx, n, x, y, zbuffer, z, mask);
-      assert(ctx->Driver.WriteDepthSpan);
-      (*ctx->Driver.WriteDepthSpan)(ctx, n, x, y, zbuffer, mask);
-      return passed;
-   }
-   else {
-      /* software depth buffer */
-      if (ctx->Visual->DepthBits <= 16) {
-         GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, x, y);
-         GLuint passed = depth_test_span16(ctx, n, x, y, zptr, z, mask);
-         return passed;
-      }
-      else {
-         GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, x, y);
-         GLuint passed = depth_test_span32(ctx, n, x, y, zptr, z, mask);
-         return passed;
-      }
-   }
-}
-
-
-
-
-/*
- * Do depth testing for an array of fragments using software Z buffer.
- */
-static void
-software_depth_test_pixels16( GLcontext *ctx, GLuint n,
-                              const GLint x[], const GLint y[],
-                              const GLdepth z[], GLubyte mask[] )
-{
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
-		  *zptr = z[i];
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	 }
-	 break;
-      case GL_NEVER:
-	 /* depth test never passes */
-         BZERO(mask, n * sizeof(GLubyte));
-	 break;
-      default:
-         gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
-   }
-}
-
-
-
-/*
- * Do depth testing for an array of fragments using software Z buffer.
- */
-static void
-software_depth_test_pixels32( GLcontext *ctx, GLuint n,
-                              const GLint x[], const GLint y[],
-                              const GLdepth z[], GLubyte mask[] )
-{
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] < *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] <= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] >= *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] > *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] != *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		     *zptr = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  if (z[i] == *zptr) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
-		  *zptr = z[i];
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	 }
-	 break;
-      case GL_NEVER:
-	 /* depth test never passes */
-         BZERO(mask, n * sizeof(GLubyte));
-	 break;
-      default:
-         gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
-   }
-}
-
-
-
-/*
- * Do depth testing for an array of pixels using hardware Z buffer.
- * Input/output:  zbuffer - array of depth values from Z buffer
- * Input:  z - array of fragment z values.
- */
-static void
-hardware_depth_test_pixels( GLcontext *ctx, GLuint n, GLdepth zbuffer[],
-                            const GLdepth z[], GLubyte mask[] )
-{
-   /* switch cases ordered from most frequent to less frequent */
-   switch (ctx->Depth.Func) {
-      case GL_LESS:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] < zbuffer[i]) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] <= zbuffer[i]) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] >= zbuffer[i]) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] > zbuffer[i]) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] != zbuffer[i]) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-         if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     /* pass */
-		     zbuffer[i] = z[i];
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  if (z[i] == zbuffer[i]) {
-		     /* pass */
-		  }
-		  else {
-		     /* fail */
-		     mask[i] = 0;
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 if (ctx->Depth.Mask) {
-	    /* Update Z buffer */
-            GLuint i;
-	    for (i=0; i<n; i++) {
-	       if (mask[i]) {
-		  zbuffer[i] = z[i];
-	       }
-	    }
-	 }
-	 else {
-	    /* Don't update Z buffer or mask */
-	 }
-	 break;
-      case GL_NEVER:
-	 /* depth test never passes */
-         BZERO(mask, n * sizeof(GLubyte));
-	 break;
-      default:
-         gl_problem(ctx, "Bad depth func in hardware_depth_test_pixels");
-   }
-}
-
-
-
-void
-_mesa_depth_test_pixels( GLcontext *ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         const GLdepth z[], GLubyte mask[] )
-{
-   if (ctx->Driver.ReadDepthPixels) {
-      /* read depth values from hardware Z buffer */
-      GLdepth zbuffer[PB_SIZE];
-      (*ctx->Driver.ReadDepthPixels)(ctx, n, x, y, zbuffer);
-
-      hardware_depth_test_pixels( ctx, n, zbuffer, z, mask );
-
-      /* update hardware Z buffer with new values */
-      assert(ctx->Driver.WriteDepthPixels);
-      (*ctx->Driver.WriteDepthPixels)(ctx, n, x, y, zbuffer, mask );
-   }
-   else {
-      /* software depth testing */
-      if (ctx->Visual->DepthBits <= 16)
-         software_depth_test_pixels16(ctx, n, x, y, z, mask);
-      else
-         software_depth_test_pixels32(ctx, n, x, y, z, mask);
-   }
-}
-
-
-
-
-
-/**********************************************************************/
-/*****                      Read Depth Buffer                     *****/
-/**********************************************************************/
-
-
-/*
- * Read a span of depth values from the depth buffer.
- * This function does clipping before calling the device driver function.
- */
-void
-_mesa_read_depth_span( GLcontext *ctx,
-                       GLint n, GLint x, GLint y, GLdepth depth[] )
-{
-   if (y < 0 || y >= ctx->DrawBuffer->Height ||
-       x + (GLint) n <= 0 || x >= ctx->DrawBuffer->Width) {
-      /* span is completely outside framebuffer */
-      GLint i;
-      for (i = 0; i < n; i++)
-         depth[i] = 0;
-      return;
-   }
-
-   if (x < 0) {
-      GLint dx = -x;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[i] = 0;
-      x = 0;
-      n -= dx;
-      depth += dx;
-   }
-   if (x + n > ctx->DrawBuffer->Width) {
-      GLint dx = x + n - ctx->DrawBuffer->Width;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[n - i - 1] = 0;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
-
-   if (ctx->DrawBuffer->DepthBuffer) {
-      /* read from software depth buffer */
-      if (ctx->Visual->DepthBits <= 16) {
-         const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
-         GLint i;
-         for (i = 0; i < n; i++) {
-            depth[i] = zptr[i];
-         }
-      }
-      else {
-         const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
-         GLint i;
-         for (i = 0; i < n; i++) {
-            depth[i] = zptr[i];
-         }
-      }
-   }
-   else if (ctx->Driver.ReadDepthSpan) {
-      /* read from hardware depth buffer */
-      (*ctx->Driver.ReadDepthSpan)( ctx, n, x, y, depth );
-   }
-   else {
-      /* no depth buffer */
-      BZERO(depth, n * sizeof(GLfloat));
-   }
-
-}
-
-
-
-
-/*
- * Return a span of depth values from the depth buffer as floats in [0,1].
- * This is used for both hardware and software depth buffers.
- * Input:  n - how many pixels
- *         x,y - location of first pixel
- * Output:  depth - the array of depth values
- */
-void
-_mesa_read_depth_span_float( GLcontext *ctx,
-                             GLint n, GLint x, GLint y, GLfloat depth[] )
-{
-   const GLfloat scale = 1.0F / ctx->Visual->DepthMaxF;
-
-   if (y < 0 || y >= ctx->DrawBuffer->Height ||
-       x + (GLint) n <= 0 || x >= ctx->DrawBuffer->Width) {
-      /* span is completely outside framebuffer */
-      GLint i;
-      for (i = 0; i < n; i++)
-         depth[i] = 0.0F;
+   if (ctx->Depth.Mask == flag)
       return;
-   }
 
-   if (x < 0) {
-      GLint dx = -x;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[i] = 0.0F;
-      n -= dx;
-      x = 0;
-   }
-   if (x + n > ctx->DrawBuffer->Width) {
-      GLint dx = x + n - ctx->DrawBuffer->Width;
-      GLint i;
-      for (i = 0; i < dx; i++)
-         depth[n - i - 1] = 0.0F;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
+   FLUSH_VERTICES(ctx, _NEW_DEPTH);
+   ctx->Depth.Mask = flag;
 
-   if (ctx->DrawBuffer->DepthBuffer) {
-      /* read from software depth buffer */
-      if (ctx->Visual->DepthBits <= 16) {
-         const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
-         GLint i;
-         for (i = 0; i < n; i++) {
-            depth[i] = (GLfloat) zptr[i] * scale;
-         }
-      }
-      else {
-         const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
-         GLint i;
-         for (i = 0; i < n; i++) {
-            depth[i] = (GLfloat) zptr[i] * scale;
-         }
-      }
-   }
-   else if (ctx->Driver.ReadDepthSpan) {
-      /* read from hardware depth buffer */
-      GLdepth d[MAX_WIDTH];
-      GLint i;
-      assert(n <= MAX_WIDTH);
-      (*ctx->Driver.ReadDepthSpan)( ctx, n, x, y, d );
-      for (i = 0; i < n; i++) {
-	 depth[i] = d[i] * scale;
-      }
-   }
-   else {
-      /* no depth buffer */
-      BZERO(depth, n * sizeof(GLfloat));
-   }
-}
-
-
-
-/**********************************************************************/
-/*****                Allocate and Clear Depth Buffer             *****/
-/**********************************************************************/
-
-
-
-/*
- * Allocate a new depth buffer.  If there's already a depth buffer allocated
- * it will be free()'d.  The new depth buffer will be uniniitalized.
- * This function is only called through Driver.alloc_depth_buffer.
- */
-void
-_mesa_alloc_depth_buffer( GLcontext *ctx )
-{
-   /* deallocate current depth buffer if present */
-   if (ctx->DrawBuffer->UseSoftwareDepthBuffer) {
-      GLint bytesPerValue;
-
-      if (ctx->DrawBuffer->DepthBuffer) {
-         FREE(ctx->DrawBuffer->DepthBuffer);
-         ctx->DrawBuffer->DepthBuffer = NULL;
-      }
-
-      /* allocate new depth buffer, but don't initialize it */
-      if (ctx->Visual->DepthBits <= 16)
-         bytesPerValue = sizeof(GLushort);
-      else
-         bytesPerValue = sizeof(GLuint);
-
-      ctx->DrawBuffer->DepthBuffer = MALLOC( ctx->DrawBuffer->Width
-                                             * ctx->DrawBuffer->Height
-                                             * bytesPerValue );
-
-      if (!ctx->DrawBuffer->DepthBuffer) {
-         /* out of memory */
-         ctx->Depth.Test = GL_FALSE;
-         ctx->NewState |= NEW_RASTER_OPS;
-         gl_error( ctx, GL_OUT_OF_MEMORY, "Couldn't allocate depth buffer" );
-      }
-   }
-}
-
-
-
-
-/*
- * Clear the depth buffer.  If the depth buffer doesn't exist yet we'll
- * allocate it now.
- * This function is only called through Driver.clear_depth_buffer.
- */
-void
-_mesa_clear_depth_buffer( GLcontext *ctx )
-{
-   if (ctx->Visual->DepthBits == 0
-       || !ctx->DrawBuffer->DepthBuffer
-       || !ctx->Depth.Mask) {
-      /* no depth buffer, or writing to it is disabled */
-      return;
-   }
-
-   /* The loops in this function have been written so the IRIX 5.3
-    * C compiler can unroll them.  Hopefully other compilers can too!
-    */
-
-   if (ctx->Scissor.Enabled) {
-      /* only clear scissor region */
-      if (ctx->Visual->DepthBits <= 16) {
-         const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual->DepthMax);
-         const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
-         const GLint cols = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-         const GLint rowStride = ctx->DrawBuffer->Width;
-         GLushort *dRow = (GLushort *) ctx->DrawBuffer->DepthBuffer
-            + ctx->DrawBuffer->Ymin * rowStride + ctx->DrawBuffer->Xmin;
-         GLint i, j;
-         for (i = 0; i < rows; i++) {
-            for (j = 0; j < cols; j++) {
-               dRow[j] = clearValue;
-            }
-            dRow += rowStride;
-         }
-      }
-      else {
-         const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual->DepthMax);
-         const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
-         const GLint cols = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-         const GLint rowStride = ctx->DrawBuffer->Width;
-         GLuint *dRow = (GLuint *) ctx->DrawBuffer->DepthBuffer
-            + ctx->DrawBuffer->Ymin * rowStride + ctx->DrawBuffer->Xmin;
-         GLint i, j;
-         for (i = 0; i < rows; i++) {
-            for (j = 0; j < cols; j++) {
-               dRow[j] = clearValue;
-            }
-            dRow += rowStride;
-         }
-      }
-   }
-   else {
-      /* clear whole buffer */
-      if (ctx->Visual->DepthBits <= 16) {
-         const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual->DepthMax);
-         if ((clearValue & 0xff) == (clearValue >> 8)) {
-            if (clearValue == 0) {
-               BZERO(ctx->DrawBuffer->DepthBuffer,
-                     2*ctx->DrawBuffer->Width*ctx->DrawBuffer->Height);
-            }
-            else {
-               /* lower and upper bytes of clear_value are same, use MEMSET */
-               MEMSET( ctx->DrawBuffer->DepthBuffer, clearValue & 0xff,
-                       2 * ctx->DrawBuffer->Width * ctx->DrawBuffer->Height);
-            }
-         }
-         else {
-            GLushort *d = (GLushort *) ctx->DrawBuffer->DepthBuffer;
-            GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-            while (n >= 16) {
-               d[0] = clearValue;    d[1] = clearValue;
-               d[2] = clearValue;    d[3] = clearValue;
-               d[4] = clearValue;    d[5] = clearValue;
-               d[6] = clearValue;    d[7] = clearValue;
-               d[8] = clearValue;    d[9] = clearValue;
-               d[10] = clearValue;   d[11] = clearValue;
-               d[12] = clearValue;   d[13] = clearValue;
-               d[14] = clearValue;   d[15] = clearValue;
-               d += 16;
-               n -= 16;
-            }
-            while (n > 0) {
-               *d++ = clearValue;
-               n--;
-            }
-         }
-      }
-      else {
-         /* >16 bit depth buffer */
-         const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual->DepthMax);
-         if (clearValue == 0) {
-            BZERO(ctx->DrawBuffer->DepthBuffer,
-                ctx->DrawBuffer->Width*ctx->DrawBuffer->Height*sizeof(GLuint));
-         }
-         else {
-            GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-            GLuint *d = (GLuint *) ctx->DrawBuffer->DepthBuffer;
-            while (n >= 16) {
-               d[0] = clearValue;    d[1] = clearValue;
-               d[2] = clearValue;    d[3] = clearValue;
-               d[4] = clearValue;    d[5] = clearValue;
-               d[6] = clearValue;    d[7] = clearValue;
-               d[8] = clearValue;    d[9] = clearValue;
-               d[10] = clearValue;   d[11] = clearValue;
-               d[12] = clearValue;   d[13] = clearValue;
-               d[14] = clearValue;   d[15] = clearValue;
-               d += 16;
-               n -= 16;
-            }
-            while (n > 0) {
-               *d++ = clearValue;
-               n--;
-            }
-         }
-      }
-   }
+   if (ctx->Driver.DepthMask)
+      ctx->Driver.DepthMask( ctx, flag );
 }
Index: xc/extras/Mesa/src/depth.h
diff -u xc/extras/Mesa/src/depth.h:1.4 xc/extras/Mesa/src/depth.h:1.5
--- xc/extras/Mesa/src/depth.h:1.4	Fri Jun 16 20:02:08 2000
+++ xc/extras/Mesa/src/depth.h	Fri Feb 22 14:25:27 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define DEPTH_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 /*
@@ -46,42 +46,6 @@
 extern void
 _mesa_DepthMask( GLboolean flag );
 
-
-
-/*
- * Internal functions
- */
-
-extern GLvoid *
-_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y);
-
-
-extern GLuint
-_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                       const GLdepth z[], GLubyte mask[] );
-
-extern void
-_mesa_depth_test_pixels( GLcontext *ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         const GLdepth z[], GLubyte mask[] );
-
-
-extern void
-_mesa_read_depth_span( GLcontext *ctx,
-                       GLint n, GLint x, GLint y, GLdepth depth[] );
-
-
-extern void
-_mesa_read_depth_span_float( GLcontext *ctx, GLint n, GLint x, GLint y,
-                             GLfloat depth[] );
-
-
-extern void
-_mesa_alloc_depth_buffer( GLcontext* ctx );
-
-
-extern void
-_mesa_clear_depth_buffer( GLcontext* ctx );
 
 
 
Index: xc/extras/Mesa/src/dispatch.c
diff -u xc/extras/Mesa/src/dispatch.c:1.2 xc/extras/Mesa/src/dispatch.c:1.3
--- xc/extras/Mesa/src/dispatch.c:1.2	Tue Feb 15 02:12:09 2000
+++ xc/extras/Mesa/src/dispatch.c	Fri Feb 22 14:25:27 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -27,9 +27,7 @@
 /*
  * This file generates all the gl* function entyrpoints.
  * But if we're using X86-optimized dispatch (X86/glapi_x86.S) then
- * each of the entrypoints will be prefixed with _glapi_fallback_*
- * and will be called by the glapi_x86.S code when we're in thread-
- * safe mode.
+ * we don't use this file's code.
  *
  * Eventually this file may be replaced by automatically generated
  * code from an API spec file.
@@ -40,72 +38,37 @@
  */
 
 
-
 #ifdef PC_HEADER
 #include "all.h"
 #else
 #include "glheader.h"
 #include "glapi.h"
 #include "glapitable.h"
+#include "glthread.h"
 #endif
-
 
+#if !(defined(USE_X86_ASM) || defined(USE_SPARC_ASM))
 
+#if defined(WIN32)
+#define KEYWORD1 GLAPI
+#else
 #define KEYWORD1
+#endif
+
 #define KEYWORD2 GLAPIENTRY
-#if defined(USE_X86_ASM) && !defined(__WIN32__) && !defined(XF86DRI)
-#define NAME(func) _glapi_fallback_##func
-#elif defined(USE_MGL_NAMESPACE)
+
+#if defined(USE_MGL_NAMESPACE)
 #define NAME(func)  mgl##func
 #else
 #define NAME(func)  gl##func
 #endif
 
-#ifdef DEBUG
+#define DISPATCH(FUNC, ARGS, MESSAGE)		\
+   (_glapi_Dispatch->FUNC) ARGS
 
-static int
-trace(void)
-{
-   static int trace = -1;
-   if (trace < 0)
-      trace = getenv("MESA_TRACE") ? 1 : 0;
-   return trace > 0;
-}
-
-#define F stderr
-
-#define DISPATCH(FUNC, ARGS, MESSAGE)					\
-   const struct _glapi_table *dispatch;					\
-   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
-   if (trace()) {							\
-      fprintf MESSAGE;							\
-      fprintf(F, "\n");							\
-   }									\
-   (dispatch->FUNC) ARGS
-
-#define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) 				\
-   const struct _glapi_table *dispatch;					\
-   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
-   if (trace()) {							\
-      fprintf MESSAGE;							\
-      fprintf(F, "\n");							\
-   }									\
-   return (dispatch->FUNC) ARGS
+#define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) 	\
+   return (_glapi_Dispatch->FUNC) ARGS
 
-#else
-
-#define DISPATCH(FUNC, ARGS, MESSAGE)					\
-   const struct _glapi_table *dispatch;					\
-   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
-   (dispatch->FUNC) ARGS
-
-#define RETURN_DISPATCH(FUNC, ARGS, MESSAGE)				\
-   const struct _glapi_table *dispatch;					\
-   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
-   return (dispatch->FUNC) ARGS
-
-#endif
-
 
 #ifndef GLAPIENTRY
 #define GLAPIENTRY
@@ -113,3 +76,5 @@
 
 #include "glapitemp.h"
 
+
+#endif /* USE_X86_ASM */
Index: xc/extras/Mesa/src/dlist.c
diff -u xc/extras/Mesa/src/dlist.c:1.9 xc/extras/Mesa/src/dlist.c:1.12
--- xc/extras/Mesa/src/dlist.c:1.9	Fri Aug 17 14:40:04 2001
+++ xc/extras/Mesa/src/dlist.c	Wed Dec 11 16:13:19 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.5
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,18 +28,17 @@
 #include "all.h"
 #else
 #include "glheader.h"
-#include "accum.h"
+#include "api_loopback.h"
 #include "attrib.h"
-#include "bitmap.h"
-#include "bbox.h"
 #include "blend.h"
 #include "buffers.h"
 #include "clip.h"
+#include "colormac.h"
 #include "colortab.h"
 #include "context.h"
-#include "copypix.h"
-#include "cva.h"
+#include "convolve.h"
 #include "depth.h"
+#include "dlist.h"
 #include "enable.h"
 #include "enums.h"
 #include "eval.h"
@@ -48,31 +47,27 @@
 #include "get.h"
 #include "glapi.h"
 #include "hash.h"
+#include "histogram.h"
 #include "image.h"
-#include "imaging.h"
 #include "light.h"
 #include "lines.h"
 #include "dlist.h"
 #include "macros.h"
 #include "matrix.h"
 #include "mem.h"
-#include "pipeline.h"
 #include "pixel.h"
-#include "pixeltex.h"
 #include "points.h"
 #include "polygon.h"
-#include "readpix.h"
-#include "rect.h"
 #include "state.h"
 #include "texobj.h"
 #include "teximage.h"
 #include "texstate.h"
-#include "types.h"
+#include "mtypes.h"
 #include "varray.h"
-#include "vb.h"
-#include "vbfill.h"
-#include "vbxform.h"
-#include "xform.h"
+
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
+
 #endif
 
 
@@ -82,7 +77,7 @@
 	glIsList
 	glGenLists
 	glDeleteLists
-	glEndList
+	glEndList  --- BUT:  call ctx->Driver.EndList at end of list execution?
 	glFeedbackBuffer
 	glSelectBuffer
 	glRenderMode
@@ -106,10 +101,10 @@
  */
 
 
-/* How many nodes to allocate at a time: 
+/* How many nodes to allocate at a time:
  * - reduced now that we hold vertices etc. elsewhere.
  */
-#define BLOCK_SIZE 64
+#define BLOCK_SIZE 256
 
 
 /*
@@ -118,7 +113,6 @@
  * The fact that these identifiers are assigned consecutive
  * integer values starting at 0 is very important, see InstSize array usage)
  *
- * KW: Commented out opcodes now handled by vertex-cassettes.
  */
 typedef enum {
 	OPCODE_ACCUM,
@@ -166,17 +160,12 @@
 	OPCODE_DRAW_BUFFER,
 	OPCODE_DRAW_PIXELS,
 	OPCODE_ENABLE,
-	OPCODE_EVALCOORD1,
-	OPCODE_EVALCOORD2,
 	OPCODE_EVALMESH1,
 	OPCODE_EVALMESH2,
-	OPCODE_EVALPOINT1,
-	OPCODE_EVALPOINT2,
 	OPCODE_FOG,
 	OPCODE_FRONT_FACE,
 	OPCODE_FRUSTUM,
 	OPCODE_HINT,
-	OPCODE_HINT_PGI,
 	OPCODE_HISTOGRAM,
 	OPCODE_INDEX_MASK,
 	OPCODE_INIT_NAMES,
@@ -214,10 +203,10 @@
 	OPCODE_PUSH_MATRIX,
 	OPCODE_PUSH_NAME,
 	OPCODE_RASTER_POS,
-	OPCODE_RECTF,
 	OPCODE_READ_BUFFER,
         OPCODE_RESET_HISTOGRAM,
         OPCODE_RESET_MIN_MAX,
+        OPCODE_ROTATE,
         OPCODE_SCALE,
 	OPCODE_SCISSOR,
 	OPCODE_SELECT_TEXTURE_SGIS,
@@ -240,7 +229,6 @@
 	OPCODE_WINDOW_POS,
         /* GL_ARB_multitexture */
         OPCODE_ACTIVE_TEXTURE,
-        OPCODE_CLIENT_ACTIVE_TEXTURE,
         /* GL_SGIX/SGIS_pixel_texture */
         OPCODE_PIXEL_TEXGEN_SGIX,
         OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS,
@@ -251,11 +239,13 @@
         OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
         OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
         OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
+        /* GL_ARB_multisample */
+        OPCODE_SAMPLE_COVERAGE,
 	/* The following three are meta instructions */
 	OPCODE_ERROR,	        /* raise compiled-in error */
-	OPCODE_VERTEX_CASSETTE,	/* render prebuilt vertex buffer */
 	OPCODE_CONTINUE,
-	OPCODE_END_OF_LIST
+	OPCODE_END_OF_LIST,
+	OPCODE_DRV_0
 } OpCode;
 
 
@@ -281,7 +271,9 @@
 
 
 
-/* Number of nodes of storage needed for each instruction: */
+/* Number of nodes of storage needed for each instruction.  Sizes for
+ * dynamically allocated opcodes are stored in the context struct.
+ */
 static GLuint InstSize[ OPCODE_END_OF_LIST+1 ];
 
 void mesa_print_display_list( GLuint list );
@@ -292,40 +284,6 @@
 /**********************************************************************/
 
 
-/*
- * Allocate space for a display list instruction.
- * Input:  opcode - type of instruction
- *         argcount - number of arguments following the instruction
- * Return: pointer to first node in the instruction
- */
-static Node *alloc_instruction( GLcontext *ctx, OpCode opcode, GLint argcount )
-{
-   Node *n, *newblock;
-   GLuint count = InstSize[opcode];
-
-   assert( (GLint) count == argcount+1 );
-
-   if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) {
-      /* This block is full.  Allocate a new block and chain to it */
-      n = ctx->CurrentBlock + ctx->CurrentPos;
-      n[0].opcode = OPCODE_CONTINUE;
-      newblock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
-      if (!newblock) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "Building display list" );
-         return NULL;
-      }
-      n[1].next = (Node *) newblock;
-      ctx->CurrentBlock = newblock;
-      ctx->CurrentPos = 0;
-   }
-
-   n = ctx->CurrentBlock + ctx->CurrentPos;
-   ctx->CurrentPos += count;
-
-   n[0].opcode = opcode;
-
-   return n;
-}
 
 
 
@@ -346,7 +304,7 @@
  * Destroy all nodes in a display list.
  * Input:  list - display list number
  */
-void gl_destroy_list( GLcontext *ctx, GLuint list )
+void _mesa_destroy_list( GLcontext *ctx, GLuint list )
 {
    Node *n, *block;
    GLboolean done;
@@ -359,13 +317,16 @@
 
    done = block ? GL_FALSE : GL_TRUE;
    while (!done) {
-      switch (n[0].opcode) {
-	 /* special cases first */
-         case OPCODE_VERTEX_CASSETTE: 
-	    if ( ! -- ((struct immediate *) n[1].data)->ref_count )
-	       gl_immediate_free( (struct immediate *) n[1].data );
-	    n += InstSize[n[0].opcode];
-	    break;
+
+      /* check for extension opcodes first */
+
+      GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0;
+      if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
+	 ctx->listext.opcode[i].destroy(ctx, &n[1]);
+	 n += ctx->listext.opcode[i].size;
+      }
+      else {
+	 switch (n[0].opcode) {
 	 case OPCODE_MAP1:
             FREE(n[6].data);
 	    n += InstSize[n[0].opcode];
@@ -463,6 +424,7 @@
 	    /* Most frequent case */
 	    n += InstSize[n[0].opcode];
 	    break;
+	 }
       }
    }
 
@@ -532,7 +494,7 @@
 /*****                        Public                              *****/
 /**********************************************************************/
 
-void gl_init_lists( void )
+void _mesa_init_lists( void )
 {
    static int init_flag = 0;
 
@@ -582,17 +544,12 @@
       InstSize[OPCODE_DRAW_BUFFER] = 2;
       InstSize[OPCODE_DRAW_PIXELS] = 6;
       InstSize[OPCODE_ENABLE] = 2;
-      InstSize[OPCODE_EVALCOORD1] = 2;
-      InstSize[OPCODE_EVALCOORD2] = 3;
       InstSize[OPCODE_EVALMESH1] = 4;
       InstSize[OPCODE_EVALMESH2] = 6;
-      InstSize[OPCODE_EVALPOINT1] = 2;
-      InstSize[OPCODE_EVALPOINT2] = 3;
       InstSize[OPCODE_FOG] = 6;
       InstSize[OPCODE_FRONT_FACE] = 2;
       InstSize[OPCODE_FRUSTUM] = 7;
       InstSize[OPCODE_HINT] = 3;
-      InstSize[OPCODE_HINT_PGI] = 3;
       InstSize[OPCODE_HISTOGRAM] = 5;
       InstSize[OPCODE_INDEX_MASK] = 2;
       InstSize[OPCODE_INIT_NAMES] = 1;
@@ -630,10 +587,10 @@
       InstSize[OPCODE_PUSH_MATRIX] = 1;
       InstSize[OPCODE_PUSH_NAME] = 2;
       InstSize[OPCODE_RASTER_POS] = 5;
-      InstSize[OPCODE_RECTF] = 5;
       InstSize[OPCODE_READ_BUFFER] = 2;
       InstSize[OPCODE_RESET_HISTOGRAM] = 2;
       InstSize[OPCODE_RESET_MIN_MAX] = 2;
+      InstSize[OPCODE_ROTATE] = 5;
       InstSize[OPCODE_SCALE] = 4;
       InstSize[OPCODE_SCISSOR] = 5;
       InstSize[OPCODE_STENCIL_FUNC] = 4;
@@ -654,7 +611,6 @@
       InstSize[OPCODE_WINDOW_POS] = 5;
       InstSize[OPCODE_CONTINUE] = 2;
       InstSize[OPCODE_ERROR] = 3;
-      InstSize[OPCODE_VERTEX_CASSETTE] = 9;
       InstSize[OPCODE_END_OF_LIST] = 1;
       /* GL_SGIX/SGIS_pixel_texture */
       InstSize[OPCODE_PIXEL_TEXGEN_SGIX] = 2;
@@ -666,26 +622,98 @@
       InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D] = 8;
       InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D] = 10;
       InstSize[OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D] = 12;
+      /* GL_ARB_multisample */
+      InstSize[OPCODE_SAMPLE_COVERAGE] = 3;
       /* GL_ARB_multitexture */
       InstSize[OPCODE_ACTIVE_TEXTURE] = 2;
-      InstSize[OPCODE_CLIENT_ACTIVE_TEXTURE] = 2;
    }
    init_flag = 1;
 }
 
 
 /*
- * Display List compilation functions
+ * Allocate space for a display list instruction.
+ * Input:  opcode - type of instruction
+ *         argcount - size in bytes of data required.
+ * Return: pointer to the usable data area (not including the internal
+ *         opcode).
+ */
+void *
+_mesa_alloc_instruction( GLcontext *ctx, int opcode, GLint sz )
+{
+   Node *n, *newblock;
+   GLuint count = 1 + (sz + sizeof(Node) - 1) / sizeof(Node);
+
+#ifdef DEBUG
+   if (opcode < (int) OPCODE_DRV_0) {
+      assert( count == InstSize[opcode] );
+   }
+#endif
+
+   if (ctx->CurrentPos + count + 2 > BLOCK_SIZE) {
+      /* This block is full.  Allocate a new block and chain to it */
+      n = ctx->CurrentBlock + ctx->CurrentPos;
+      n[0].opcode = OPCODE_CONTINUE;
+      newblock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
+      if (!newblock) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "Building display list" );
+         return NULL;
+      }
+      n[1].next = (Node *) newblock;
+      ctx->CurrentBlock = newblock;
+      ctx->CurrentPos = 0;
+   }
+
+   n = ctx->CurrentBlock + ctx->CurrentPos;
+   ctx->CurrentPos += count;
+
+   n[0].opcode = (OpCode) opcode;
+
+   return (void *)&n[1];
+}
+
+
+/* Allow modules and drivers to get their own opcodes.
  */
+int
+_mesa_alloc_opcode( GLcontext *ctx,
+		    GLuint sz,
+		    void (*execute)( GLcontext *, void * ),
+		    void (*destroy)( GLcontext *, void * ),
+		    void (*print)( GLcontext *, void * ) )
+{
+   if (ctx->listext.nr_opcodes < GL_MAX_EXT_OPCODES) {
+      GLuint i = ctx->listext.nr_opcodes++;
+      ctx->listext.opcode[i].size = 1 + (sz + sizeof(Node) - 1)/sizeof(Node);
+      ctx->listext.opcode[i].execute = execute;
+      ctx->listext.opcode[i].destroy = destroy;
+      ctx->listext.opcode[i].print = print;
+      return i + OPCODE_DRV_0;
+   }
+   return -1;
+}
+
+
+
+/* Mimic the old behaviour of alloc_instruction:
+ *   - sz is in units of sizeof(Node)
+ *   - return value a pointer to sizeof(Node) before the actual
+ *     usable data area.
+ */
+#define ALLOC_INSTRUCTION(ctx, opcode, sz) \
+        ((Node *)_mesa_alloc_instruction(ctx, opcode, sz*sizeof(Node)) - 1)
 
 
 
+/*
+ * Display List compilation functions
+ */
 static void save_Accum( GLenum op, GLfloat value )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_ACCUM, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_ACCUM, 2 );
    if (n) {
       n[1].e = op;
       n[2].f = value;
@@ -700,8 +728,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_ALPHA_FUNC, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_ALPHA_FUNC, 2 );
    if (n) {
       n[1].e = func;
       n[2].f = (GLfloat) ref;
@@ -712,18 +740,12 @@
 }
 
 
-static void save_Begin( GLenum mode )
-{
-   _mesa_Begin(mode);  /* special case */
-}
-
-
 static void save_BindTexture( GLenum target, GLuint texture )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_BIND_TEXTURE, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_BIND_TEXTURE, 2 );
    if (n) {
       n[1].e = target;
       n[2].ui = texture;
@@ -742,8 +764,8 @@
    GET_CURRENT_CONTEXT(ctx);
    GLvoid *image = _mesa_unpack_bitmap( width, height, pixels, &ctx->Unpack );
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_BITMAP, 7 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_BITMAP, 7 );
    if (n) {
       n[1].i = (GLint) width;
       n[2].i = (GLint) height;
@@ -767,8 +789,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_BLEND_EQUATION, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_EQUATION, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -782,8 +804,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_BLEND_FUNC, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC, 2 );
    if (n) {
       n[1].e = sfactor;
       n[2].e = dfactor;
@@ -799,8 +821,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_BLEND_FUNC_SEPARATE, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_FUNC_SEPARATE, 4 );
    if (n) {
       n[1].e = sfactorRGB;
       n[2].e = dfactorRGB;
@@ -819,8 +841,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_BLEND_COLOR, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_BLEND_COLOR, 4 );
    if (n) {
       n[1].f = red;
       n[2].f = green;
@@ -833,12 +855,14 @@
 }
 
 
-static void save_CallList( GLuint list )
+void _mesa_save_CallList( GLuint list )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CALL_LIST, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
+
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST, 1 );
    if (n) {
       n[1].ui = list;
    }
@@ -848,15 +872,16 @@
 }
 
 
-static void save_CallLists( GLsizei n, GLenum type, const GLvoid *lists )
+void _mesa_save_CallLists( GLsizei n, GLenum type, const GLvoid *lists )
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
-   FLUSH_VB(ctx, "dlist");
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
 
    for (i=0;i<n;i++) {
       GLuint list = translate_id( i, type, lists );
-      Node *n = alloc_instruction( ctx, OPCODE_CALL_LIST_OFFSET, 1 );
+      Node *n = ALLOC_INSTRUCTION( ctx, OPCODE_CALL_LIST_OFFSET, 1 );
       if (n) {
          n[1].ui = list;
       }
@@ -871,8 +896,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLEAR, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR, 1 );
    if (n) {
       n[1].bf = mask;
    }
@@ -887,8 +912,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLEAR_ACCUM, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_ACCUM, 4 );
    if (n) {
       n[1].f = red;
       n[2].f = green;
@@ -906,8 +931,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLEAR_COLOR, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_COLOR, 4 );
    if (n) {
       n[1].f = red;
       n[2].f = green;
@@ -924,8 +949,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLEAR_DEPTH, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_DEPTH, 1 );
    if (n) {
       n[1].f = (GLfloat) depth;
    }
@@ -939,8 +964,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLEAR_INDEX, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_INDEX, 1 );
    if (n) {
       n[1].f = c;
    }
@@ -954,8 +979,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLEAR_STENCIL, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLEAR_STENCIL, 1 );
    if (n) {
       n[1].i = s;
    }
@@ -969,14 +994,14 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLIP_PLANE, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CLIP_PLANE, 5 );
    if (n) {
       n[1].e = plane;
-      n[2].f = equ[0];
-      n[3].f = equ[1];
-      n[4].f = equ[2];
-      n[5].f = equ[3];
+      n[2].f = (GLfloat) equ[0];
+      n[3].f = (GLfloat) equ[1];
+      n[4].f = (GLfloat) equ[2];
+      n[5].f = (GLfloat) equ[3];
    }
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->ClipPlane)( plane, equ );
@@ -990,8 +1015,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COLOR_MASK, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MASK, 4 );
    if (n) {
       n[1].b = red;
       n[2].b = green;
@@ -1008,8 +1033,10 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COLOR_MATERIAL, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
+
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_MATERIAL, 2 );
    if (n) {
       n[1].e = face;
       n[2].e = mode;
@@ -1027,7 +1054,8 @@
    GET_CURRENT_CONTEXT(ctx);
    if (target == GL_PROXY_TEXTURE_1D ||
        target == GL_PROXY_TEXTURE_2D ||
-       target == GL_PROXY_TEXTURE_3D) {
+       target == GL_PROXY_TEXTURE_3D ||
+       target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
       /* execute immediately */
       (*ctx->Exec->ColorTable)( target, internalFormat, width,
                                 format, type, table );
@@ -1036,8 +1064,8 @@
       GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, table,
                                          &ctx->Unpack);
       Node *n;
-      FLUSH_VB(ctx, "dlist");
-      n = alloc_instruction( ctx, OPCODE_COLOR_TABLE, 6 );
+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+      n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE, 6 );
       if (n) {
          n[1].e = target;
          n[2].e = internalFormat;
@@ -1064,10 +1092,9 @@
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
 
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glColorTableParameterfv");
-   FLUSH_VB(ctx, "dlist");
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
-   n = alloc_instruction( ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6 );
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -1093,10 +1120,9 @@
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
 
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glColorTableParameterfv");
-   FLUSH_VB(ctx, "dlist");
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
-   n = alloc_instruction( ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6 );
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -1125,8 +1151,8 @@
    GLvoid *image = _mesa_unpack_image(count, 1, 1, format, type, table,
                                       &ctx->Unpack);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COLOR_SUB_TABLE, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COLOR_SUB_TABLE, 6 );
    if (n) {
       n[1].e = target;
       n[2].i = start;
@@ -1151,8 +1177,8 @@
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
 
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5 );
    if (n) {
       n[1].e = target;
       n[2].i = start;
@@ -1173,8 +1199,8 @@
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
 
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_COLOR_TABLE, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_COLOR_TABLE, 5 );
    if (n) {
       n[1].e = target;
       n[2].e = internalformat;
@@ -1196,8 +1222,8 @@
    GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type, filter,
                                       &ctx->Unpack);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CONVOLUTION_FILTER_1D, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_1D, 6 );
    if (n) {
       n[1].e = target;
       n[2].e = internalFormat;
@@ -1225,8 +1251,8 @@
    GLvoid *image = _mesa_unpack_image(width, height, 1, format, type, filter,
                                       &ctx->Unpack);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CONVOLUTION_FILTER_2D, 7 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_FILTER_2D, 7 );
    if (n) {
       n[1].e = target;
       n[2].e = internalFormat;
@@ -1251,8 +1277,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -1269,8 +1295,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -1297,8 +1323,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -1315,8 +1341,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -1338,13 +1364,14 @@
 }
 
 
-static void save_CopyPixels( GLint x, GLint y,
-                             GLsizei width, GLsizei height, GLenum type )
+static void 
+save_CopyPixels( GLint x, GLint y,
+		 GLsizei width, GLsizei height, GLenum type )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_PIXELS, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_PIXELS, 5 );
    if (n) {
       n[1].i = x;
       n[2].i = y;
@@ -1365,8 +1392,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_TEX_IMAGE1D, 7 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE1D, 7 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -1391,8 +1418,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_TEX_IMAGE2D, 8 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_IMAGE2D, 8 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -1418,8 +1445,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -1442,8 +1469,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -1469,8 +1496,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -1494,8 +1521,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CULL_FACE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_CULL_FACE, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -1509,8 +1536,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_DEPTH_FUNC, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_FUNC, 1 );
    if (n) {
       n[1].e = func;
    }
@@ -1524,8 +1551,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_DEPTH_MASK, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_MASK, 1 );
    if (n) {
       n[1].b = mask;
    }
@@ -1539,8 +1566,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_DEPTH_RANGE, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_DEPTH_RANGE, 2 );
    if (n) {
       n[1].f = (GLfloat) nearval;
       n[2].f = (GLfloat) farval;
@@ -1555,8 +1582,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_DISABLE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_DISABLE, 1 );
    if (n) {
       n[1].e = cap;
    }
@@ -1570,8 +1597,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_DRAW_BUFFER, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_BUFFER, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -1589,8 +1616,8 @@
    GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
                                       pixels, &ctx->Unpack);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_DRAW_PIXELS, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_DRAW_PIXELS, 5 );
    if (n) {
       n[1].i = width;
       n[2].i = height;
@@ -1612,8 +1639,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_ENABLE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_ENABLE, 1 );
    if (n) {
       n[1].e = cap;
    }
@@ -1624,12 +1651,12 @@
 
 
 
-static void save_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
+void _mesa_save_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_EVALMESH1, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH1, 3 );
    if (n) {
       n[1].e = mode;
       n[2].i = i1;
@@ -1641,13 +1668,12 @@
 }
 
 
-static void save_EvalMesh2( 
-                        GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
+void _mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_EVALMESH2, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_EVALMESH2, 5 );
    if (n) {
       n[1].e = mode;
       n[2].i = i1;
@@ -1667,8 +1693,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_FOG, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_FOG, 5 );
    if (n) {
       n[1].e = pname;
       n[2].f = params[0];
@@ -1723,8 +1749,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_FRONT_FACE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_FRONT_FACE, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -1740,15 +1766,15 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_FRUSTUM, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_FRUSTUM, 6 );
    if (n) {
-      n[1].f = left;
-      n[2].f = right;
-      n[3].f = bottom;
-      n[4].f = top;
-      n[5].f = nearval;
-      n[6].f = farval;
+      n[1].f = (GLfloat) left;
+      n[2].f = (GLfloat) right;
+      n[3].f = (GLfloat) bottom;
+      n[4].f = (GLfloat) top;
+      n[5].f = (GLfloat) nearval;
+      n[6].f = (GLfloat) farval;
    }
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->Frustum)( left, right, bottom, top, nearval, farval );
@@ -1760,8 +1786,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_HINT, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_HINT, 2 );
    if (n) {
       n[1].e = target;
       n[2].e = mode;
@@ -1772,31 +1798,14 @@
 }
 
 
-/* GL_PGI_misc_hints*/
-static void save_HintPGI( GLenum target, GLint mode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_HINT_PGI, 2 );
-   if (n) {
-      n[1].e = target;
-      n[2].i = mode;
-   }
-   if (ctx->ExecuteFlag) {
-      (*ctx->Exec->HintPGI)( target, mode );
-   }
-}
-
-
 static void
 save_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
 
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_HISTOGRAM, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_HISTOGRAM, 4 );
    if (n) {
       n[1].e = target;
       n[2].i = width;
@@ -1813,8 +1822,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_INDEX_MASK, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_INDEX_MASK, 1 );
    if (n) {
       n[1].ui = mask;
    }
@@ -1827,8 +1836,8 @@
 static void save_InitNames( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
-   (void) alloc_instruction( ctx, OPCODE_INIT_NAMES, 0 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   (void) ALLOC_INSTRUCTION( ctx, OPCODE_INIT_NAMES, 0 );
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->InitNames)();
    }
@@ -1839,8 +1848,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LIGHT, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT, 6 );
    if (OPCODE_LIGHT) {
       GLint i, nParams;
       n[1].e = light;
@@ -1943,8 +1952,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LIGHT_MODEL, 5 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LIGHT_MODEL, 5 );
    if (n) {
       n[1].e = pname;
       n[2].f = params[0];
@@ -1997,8 +2006,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LINE_STIPPLE, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_STIPPLE, 2 );
    if (n) {
       n[1].i = factor;
       n[2].us = pattern;
@@ -2013,8 +2022,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LINE_WIDTH, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LINE_WIDTH, 1 );
    if (n) {
       n[1].f = width;
    }
@@ -2028,8 +2037,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LIST_BASE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LIST_BASE, 1 );
    if (n) {
       n[1].ui = base;
    }
@@ -2042,8 +2051,8 @@
 static void save_LoadIdentity( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
-   (void) alloc_instruction( ctx, OPCODE_LOAD_IDENTITY, 0 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   (void) ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_IDENTITY, 0 );
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->LoadIdentity)();
    }
@@ -2054,8 +2063,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LOAD_MATRIX, 16 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_MATRIX, 16 );
    if (n) {
       GLuint i;
       for (i=0;i<16;i++) {
@@ -2073,7 +2082,7 @@
    GLfloat f[16];
    GLint i;
    for (i = 0; i < 16; i++) {
-      f[i] = m[i];
+      f[i] = (GLfloat) m[i];
    }
    save_LoadMatrixf(f);
 }
@@ -2083,8 +2092,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LOAD_NAME, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LOAD_NAME, 1 );
    if (n) {
       n[1].ui = name;
    }
@@ -2098,8 +2107,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_LOGIC_OP, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_LOGIC_OP, 1 );
    if (n) {
       n[1].e = opcode;
    }
@@ -2114,13 +2123,13 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MAP1, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 );
    if (n) {
-      GLfloat *pnts = gl_copy_map_points1d( target, stride, order, points );
+      GLfloat *pnts = _mesa_copy_map_points1d( target, stride, order, points );
       n[1].e = target;
-      n[2].f = u1;
-      n[3].f = u2;
+      n[2].f = (GLfloat) u1;
+      n[3].f = (GLfloat) u2;
       n[4].i = _mesa_evaluator_components(target);  /* stride */
       n[5].i = order;
       n[6].data = (void *) pnts;
@@ -2135,10 +2144,10 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MAP1, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP1, 6 );
    if (n) {
-      GLfloat *pnts = gl_copy_map_points1f( target, stride, order, points );
+      GLfloat *pnts = _mesa_copy_map_points1f( target, stride, order, points );
       n[1].e = target;
       n[2].f = u1;
       n[3].f = u2;
@@ -2159,16 +2168,16 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MAP2, 10 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 );
    if (n) {
-      GLfloat *pnts = gl_copy_map_points2d( target, ustride, uorder,
+      GLfloat *pnts = _mesa_copy_map_points2d( target, ustride, uorder,
                                             vstride, vorder, points );
       n[1].e = target;
-      n[2].f = u1;
-      n[3].f = u2;
-      n[4].f = v1;
-      n[5].f = v2;
+      n[2].f = (GLfloat) u1;
+      n[3].f = (GLfloat) u2;
+      n[4].f = (GLfloat) v1;
+      n[5].f = (GLfloat) v2;
       /* XXX verify these strides are correct */
       n[6].i = _mesa_evaluator_components(target) * vorder;  /*ustride*/
       n[7].i = _mesa_evaluator_components(target);           /*vstride*/
@@ -2191,10 +2200,10 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MAP2, 10 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAP2, 10 );
    if (n) {
-      GLfloat *pnts = gl_copy_map_points2f( target, ustride, uorder,
+      GLfloat *pnts = _mesa_copy_map_points2f( target, ustride, uorder,
                                             vstride, vorder, points );
       n[1].e = target;
       n[2].f = u1;
@@ -2219,8 +2228,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MAPGRID1, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID1, 3 );
    if (n) {
       n[1].i = un;
       n[2].f = u1;
@@ -2234,7 +2243,7 @@
 
 static void save_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
 {
-   save_MapGrid1f(un, u1, u2);
+   save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
 }
 
 
@@ -2243,8 +2252,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MAPGRID2, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MAPGRID2, 6 );
    if (n) {
       n[1].i = un;
       n[2].f = u1;
@@ -2263,7 +2272,8 @@
 static void save_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
                             GLint vn, GLdouble v1, GLdouble v2 )
 {
-   save_MapGrid2f(un, u1, u2, vn, v1, v2);
+   save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2, 
+		  vn, (GLfloat) v1, (GLfloat) v2);
 }
 
 
@@ -2271,8 +2281,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MATRIX_MODE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MATRIX_MODE, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -2288,8 +2298,8 @@
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
 
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MIN_MAX, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MIN_MAX, 3 );
    if (n) {
       n[1].e = target;
       n[2].e = internalFormat;
@@ -2305,8 +2315,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_MULT_MATRIX, 16 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_MULT_MATRIX, 16 );
    if (n) {
       GLuint i;
       for (i=0;i<16;i++) {
@@ -2324,7 +2334,7 @@
    GLfloat f[16];
    GLint i;
    for (i = 0; i < 16; i++) {
-      f[i] = m[i];
+      f[i] = (GLfloat) m[i];
    }
    save_MultMatrixf(f);
 }
@@ -2334,7 +2344,7 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    /* It's an error to call this function while building a display list */
-   gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
+   _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" );
    (void) list;
    (void) mode;
 }
@@ -2347,15 +2357,15 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_ORTHO, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_ORTHO, 6 );
    if (n) {
-      n[1].f = left;
-      n[2].f = right;
-      n[3].f = bottom;
-      n[4].f = top;
-      n[5].f = nearval;
-      n[6].f = farval;
+      n[1].f = (GLfloat) left;
+      n[2].f = (GLfloat) right;
+      n[3].f = (GLfloat) bottom;
+      n[4].f = (GLfloat) top;
+      n[5].f = (GLfloat) nearval;
+      n[6].f = (GLfloat) farval;
    }
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->Ortho)( left, right, bottom, top, nearval, farval );
@@ -2363,12 +2373,13 @@
 }
 
 
-static void save_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
+static void
+save_PixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PIXEL_MAP, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_MAP, 3 );
    if (n) {
       n[1].e = map;
       n[2].i = mapsize;
@@ -2381,7 +2392,8 @@
 }
 
 
-static void save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
+static void
+save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
 {
    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
    GLint i;
@@ -2399,7 +2411,8 @@
 }
 
 
-static void save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
+static void
+save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
    GLint i;
@@ -2417,12 +2430,13 @@
 }
 
 
-static void save_PixelTransferf( GLenum pname, GLfloat param )
+static void
+save_PixelTransferf( GLenum pname, GLfloat param )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PIXEL_TRANSFER, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TRANSFER, 2 );
    if (n) {
       n[1].e = pname;
       n[2].f = param;
@@ -2433,18 +2447,20 @@
 }
 
 
-static void save_PixelTransferi( GLenum pname, GLint param )
+static void
+save_PixelTransferi( GLenum pname, GLint param )
 {
    save_PixelTransferf( pname, (GLfloat) param );
 }
 
 
-static void save_PixelZoom( GLfloat xfactor, GLfloat yfactor )
+static void
+save_PixelZoom( GLfloat xfactor, GLfloat yfactor )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PIXEL_ZOOM, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_ZOOM, 2 );
    if (n) {
       n[1].f = xfactor;
       n[2].f = yfactor;
@@ -2455,12 +2471,13 @@
 }
 
 
-static void save_PointParameterfvEXT( GLenum pname, const GLfloat *params )
+static void
+save_PointParameterfvEXT( GLenum pname, const GLfloat *params )
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_POINT_PARAMETERS, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_PARAMETERS, 4 );
    if (n) {
       n[1].e = pname;
       n[2].f = params[0];
@@ -2483,8 +2500,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_POINT_SIZE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_POINT_SIZE, 1 );
    if (n) {
       n[1].f = size;
    }
@@ -2498,8 +2515,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_POLYGON_MODE, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_MODE, 2 );
    if (n) {
       n[1].e = face;
       n[2].e = mode;
@@ -2517,8 +2534,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_POLYGON_STIPPLE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_STIPPLE, 1 );
    if (n) {
       void *data;
       n[1].data = MALLOC( 32 * 4 );
@@ -2535,8 +2552,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_POLYGON_OFFSET, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_POLYGON_OFFSET, 2 );
    if (n) {
       n[1].f = factor;
       n[2].f = units;
@@ -2550,15 +2567,15 @@
 static void save_PolygonOffsetEXT( GLfloat factor, GLfloat bias )
 {
    GET_CURRENT_CONTEXT(ctx);
-   save_PolygonOffset(factor, ctx->Visual->DepthMaxF * bias);
+   save_PolygonOffset(factor, ctx->DepthMaxF * bias);
 }
 
 
 static void save_PopAttrib( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
-   (void) alloc_instruction( ctx, OPCODE_POP_ATTRIB, 0 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_ATTRIB, 0 );
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->PopAttrib)();
    }
@@ -2568,8 +2585,9 @@
 static void save_PopMatrix( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
-   (void) alloc_instruction( ctx, OPCODE_POP_MATRIX, 0 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
+   (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_MATRIX, 0 );
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->PopMatrix)();
    }
@@ -2579,8 +2597,8 @@
 static void save_PopName( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
-   (void) alloc_instruction( ctx, OPCODE_POP_NAME, 0 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   (void) ALLOC_INSTRUCTION( ctx, OPCODE_POP_NAME, 0 );
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->PopName)();
    }
@@ -2592,11 +2610,11 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
-   FLUSH_VB(ctx, "dlist");
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
    for (i=0;i<num;i++) {
       Node *n;
-      n = alloc_instruction( ctx,  OPCODE_PRIORITIZE_TEXTURE, 2 );
+      n = ALLOC_INSTRUCTION( ctx,  OPCODE_PRIORITIZE_TEXTURE, 2 );
       if (n) {
          n[1].ui = textures[i];
          n[2].f = priorities[i];
@@ -2612,8 +2630,9 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PUSH_ATTRIB, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_ATTRIB, 1 );
    if (n) {
       n[1].bf = mask;
    }
@@ -2626,8 +2645,8 @@
 static void save_PushMatrix( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
-   (void) alloc_instruction( ctx, OPCODE_PUSH_MATRIX, 0 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   (void) ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_MATRIX, 0 );
    if (ctx->ExecuteFlag) {
       (*ctx->Exec->PushMatrix)();
    }
@@ -2638,8 +2657,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PUSH_NAME, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PUSH_NAME, 1 );
    if (n) {
       n[1].ui = name;
    }
@@ -2653,8 +2672,9 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_RASTER_POS, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_RASTER_POS, 4 );
    if (n) {
       n[1].f = x;
       n[2].f = y;
@@ -2668,7 +2688,7 @@
 
 static void save_RasterPos2d(GLdouble x, GLdouble y)
 {
-   save_RasterPos4f(x, y, 0.0F, 1.0F);
+   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
 }
 
 static void save_RasterPos2f(GLfloat x, GLfloat y)
@@ -2678,7 +2698,7 @@
 
 static void save_RasterPos2i(GLint x, GLint y)
 {
-   save_RasterPos4f(x, y, 0.0F, 1.0F);
+   save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
 }
 
 static void save_RasterPos2s(GLshort x, GLshort y)
@@ -2688,7 +2708,7 @@
 
 static void save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-   save_RasterPos4f(x, y, z, 1.0F);
+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
 }
 
 static void save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
@@ -2698,7 +2718,7 @@
 
 static void save_RasterPos3i(GLint x, GLint y, GLint z)
 {
-   save_RasterPos4f(x, y, z, 1.0F);
+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
 }
 
 static void save_RasterPos3s(GLshort x, GLshort y, GLshort z)
@@ -2708,12 +2728,12 @@
 
 static void save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-   save_RasterPos4f(x, y, z, w);
+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 }
 
 static void save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-   save_RasterPos4f(x, y, z, w);
+   save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 }
 
 static void save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
@@ -2723,7 +2743,7 @@
 
 static void save_RasterPos2dv(const GLdouble *v)
 {
-   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
 }
 
 static void save_RasterPos2fv(const GLfloat *v)
@@ -2733,7 +2753,7 @@
 
 static void save_RasterPos2iv(const GLint *v)
 {
-   save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
 }
 
 static void save_RasterPos2sv(const GLshort *v)
@@ -2743,7 +2763,7 @@
 
 static void save_RasterPos3dv(const GLdouble *v)
 {
-   save_RasterPos4f(v[0], v[1], v[2], 1.0F);
+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
 }
 
 static void save_RasterPos3fv(const GLfloat *v)
@@ -2753,7 +2773,7 @@
 
 static void save_RasterPos3iv(const GLint *v)
 {
-   save_RasterPos4f(v[0], v[1], v[2], 1.0F);
+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
 }
 
 static void save_RasterPos3sv(const GLshort *v)
@@ -2763,7 +2783,8 @@
 
 static void save_RasterPos4dv(const GLdouble *v)
 {
-   save_RasterPos4f(v[0], v[1], v[2], v[3]);
+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 
+		    (GLfloat) v[2], (GLfloat) v[3]);
 }
 
 static void save_RasterPos4fv(const GLfloat *v)
@@ -2773,7 +2794,8 @@
 
 static void save_RasterPos4iv(const GLint *v)
 {
-   save_RasterPos4f(v[0], v[1], v[2], v[3]);
+   save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 
+		    (GLfloat) v[2], (GLfloat) v[3]);
 }
 
 static void save_RasterPos4sv(const GLshort *v)
@@ -2786,8 +2808,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PASSTHROUGH, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PASSTHROUGH, 1 );
    if (n) {
       n[1].f = token;
    }
@@ -2801,8 +2823,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_READ_BUFFER, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_READ_BUFFER, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -2812,66 +2834,13 @@
 }
 
 
-static void save_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_RECTF, 4 );
-   if (n) {
-      n[1].f = x1;
-      n[2].f = y1;
-      n[3].f = x2;
-      n[4].f = y2;
-   }
-   if (ctx->ExecuteFlag) {
-      (*ctx->Exec->Rectf)( x1, y1, x2, y2 );
-   }
-}
-
-static void save_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-   save_Rectf(x1, y1, x2, y2);
-}
-
-static void save_Rectdv(const GLdouble *v1, const GLdouble *v2)
-{
-   save_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
-
-static void save_Rectfv( const GLfloat *v1, const GLfloat *v2 )
-{
-   save_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
- 
-static void save_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-   save_Rectf(x1, y1, x2, y2);
-}
-
-static void save_Rectiv(const GLint *v1, const GLint *v2)
-{
-   save_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
-
-static void save_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-   save_Rectf(x1, y1, x2, y2);
-}
-
-static void save_Rectsv(const GLshort *v1, const GLshort *v2)
-{
-   save_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
-
-
 static void
 save_ResetHistogram(GLenum target)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_RESET_HISTOGRAM, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_HISTOGRAM, 1 );
    if (n) {
       n[1].e = target;
    }
@@ -2886,8 +2855,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_RESET_MIN_MAX, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_RESET_MIN_MAX, 1 );
    if (n) {
       n[1].e = target;
    }
@@ -2899,15 +2868,25 @@
 
 static void save_Rotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
 {
-   GLfloat m[16];
-   gl_rotation_matrix( angle, x, y, z, m );
-   save_MultMatrixf( m );  /* save and maybe execute */
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_ROTATE, 4 );
+   if (n) {
+      n[1].f = angle;
+      n[2].f = x;
+      n[3].f = y;
+      n[4].f = z;
+   }
+   if (ctx->ExecuteFlag) {
+      (*ctx->Exec->Rotatef)( angle, x, y, z );
+   }
 }
 
 
 static void save_Rotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
 {
-   save_Rotatef(angle, x, y, z);
+   save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 }
 
 
@@ -2915,8 +2894,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_SCALE, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_SCALE, 3 );
    if (n) {
       n[1].f = x;
       n[2].f = y;
@@ -2930,7 +2909,7 @@
 
 static void save_Scaled( GLdouble x, GLdouble y, GLdouble z )
 {
-   save_Scalef(x, y, z);
+   save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
 }
 
 
@@ -2938,8 +2917,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_SCISSOR, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_SCISSOR, 4 );
    if (n) {
       n[1].i = x;
       n[2].i = y;
@@ -2956,8 +2935,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_SHADE_MODEL, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_SHADE_MODEL, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -2971,8 +2950,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_STENCIL_FUNC, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_FUNC, 3 );
    if (n) {
       n[1].e = func;
       n[2].i = ref;
@@ -2988,8 +2967,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_STENCIL_MASK, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_MASK, 1 );
    if (n) {
       n[1].ui = mask;
    }
@@ -3003,8 +2982,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_STENCIL_OP, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_STENCIL_OP, 3 );
    if (n) {
       n[1].e = fail;
       n[2].e = zfail;
@@ -3020,8 +2999,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_TEXENV, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXENV, 6 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -3066,8 +3045,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_TEXGEN, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXGEN, 6 );
    if (n) {
       n[1].e = coord;
       n[2].e = pname;
@@ -3085,10 +3064,10 @@
 static void save_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
 {
    GLfloat p[4];
-   p[0] = params[0];
-   p[1] = params[1];
-   p[2] = params[2];
-   p[3] = params[3];
+   p[0] = (GLfloat) params[0];
+   p[1] = (GLfloat) params[1];
+   p[2] = (GLfloat) params[2];
+   p[3] = (GLfloat) params[3];
    save_TexGenfv(coord, pname, p);
 }
 
@@ -3103,10 +3082,10 @@
 static void save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
 {
    GLfloat p[4];
-   p[0] = params[0];
-   p[1] = params[1];
-   p[2] = params[2];
-   p[3] = params[3];
+   p[0] = (GLfloat) params[0];
+   p[1] = (GLfloat) params[1];
+   p[2] = (GLfloat) params[2];
+   p[3] = (GLfloat) params[3];
    save_TexGenfv( coord, pname, p );
 }
 
@@ -3128,8 +3107,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_TEXPARAMETER, 6 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEXPARAMETER, 6 );
    if (n) {
       n[1].e = target;
       n[2].e = pname;
@@ -3150,7 +3129,7 @@
 }
 
 
-static void save_TexParameteri( GLenum target, GLenum pname, const GLint param )
+static void save_TexParameteri( GLenum target, GLenum pname, GLint param )
 {
    GLfloat fparam[4];
    fparam[0] = (GLfloat) param;
@@ -3184,8 +3163,8 @@
       GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
                                          pixels, &ctx->Unpack);
       Node *n;
-      FLUSH_VB(ctx, "dlist");
-      n = alloc_instruction( ctx, OPCODE_TEX_IMAGE1D, 8 );
+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+      n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE1D, 8 );
       if (n) {
          n[1].e = target;
          n[2].i = level;
@@ -3223,8 +3202,8 @@
       GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
                                          pixels, &ctx->Unpack);
       Node *n;
-      FLUSH_VB(ctx, "dlist");
-      n = alloc_instruction( ctx, OPCODE_TEX_IMAGE2D, 9 );
+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+      n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE2D, 9 );
       if (n) {
          n[1].e = target;
          n[2].i = level;
@@ -3248,7 +3227,7 @@
 
 
 static void save_TexImage3D( GLenum target,
-                             GLint level, GLint internalFormat,
+                             GLint level, GLenum internalFormat,
                              GLsizei width, GLsizei height, GLsizei depth,
                              GLint border,
                              GLenum format, GLenum type,
@@ -3264,15 +3243,15 @@
       Node *n;
       GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
                                          pixels, &ctx->Unpack);
-      FLUSH_VB(ctx, "dlist");
-      n = alloc_instruction( ctx, OPCODE_TEX_IMAGE3D, 10 );
+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+      n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_IMAGE3D, 10 );
       if (n) {
          n[1].e = target;
          n[2].i = level;
-         n[3].i = internalFormat;
+         n[3].i = (GLint) internalFormat;
          n[4].i = (GLint) width;
          n[5].i = (GLint) height;
-         n[6].i = (GLint) depth; 
+         n[6].i = (GLint) depth;
          n[7].i = border;
          n[8].e = format;
          n[9].e = type;
@@ -3297,8 +3276,8 @@
    Node *n;
    GLvoid *image = _mesa_unpack_image(width, 1, 1, format, type,
                                       pixels, &ctx->Unpack);
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_TEX_SUB_IMAGE1D, 7 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE1D, 7 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -3328,8 +3307,8 @@
    Node *n;
    GLvoid *image = _mesa_unpack_image(width, height, 1, format, type,
                                       pixels, &ctx->Unpack);
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_TEX_SUB_IMAGE2D, 9 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE2D, 9 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -3361,8 +3340,8 @@
    Node *n;
    GLvoid *image = _mesa_unpack_image(width, height, depth, format, type,
                                       pixels, &ctx->Unpack);
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_TEX_SUB_IMAGE3D, 11 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_TEX_SUB_IMAGE3D, 11 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -3391,8 +3370,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx,  OPCODE_TRANSLATE, 3 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx,  OPCODE_TRANSLATE, 3 );
    if (n) {
       n[1].f = x;
       n[2].f = y;
@@ -3406,7 +3385,7 @@
 
 static void save_Translated( GLdouble x, GLdouble y, GLdouble z )
 {
-   save_Translatef(x, y, z);
+   save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
 }
 
 
@@ -3415,8 +3394,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx,  OPCODE_VIEWPORT, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx,  OPCODE_VIEWPORT, 4 );
    if (n) {
       n[1].i = x;
       n[2].i = y;
@@ -3433,8 +3412,9 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx,  OPCODE_WINDOW_POS, 4 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
+   n = ALLOC_INSTRUCTION( ctx,  OPCODE_WINDOW_POS, 4 );
    if (n) {
       n[1].f = x;
       n[2].f = y;
@@ -3448,7 +3428,7 @@
 
 static void save_WindowPos2dMESA(GLdouble x, GLdouble y)
 {
-   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
 }
 
 static void save_WindowPos2fMESA(GLfloat x, GLfloat y)
@@ -3458,7 +3438,7 @@
 
 static void save_WindowPos2iMESA(GLint x, GLint y)
 {
-   save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
 }
 
 static void save_WindowPos2sMESA(GLshort x, GLshort y)
@@ -3468,7 +3448,7 @@
 
 static void save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
 {
-   save_WindowPos4fMESA(x, y, z, 1.0F);
+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
 }
 
 static void save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
@@ -3478,7 +3458,7 @@
 
 static void save_WindowPos3iMESA(GLint x, GLint y, GLint z)
 {
-   save_WindowPos4fMESA(x, y, z, 1.0F);
+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
 }
 
 static void save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
@@ -3488,12 +3468,12 @@
 
 static void save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-   save_WindowPos4fMESA(x, y, z, w);
+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 }
 
 static void save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
 {
-   save_WindowPos4fMESA(x, y, z, w);
+   save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 }
 
 static void save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
@@ -3503,7 +3483,7 @@
 
 static void save_WindowPos2dvMESA(const GLdouble *v)
 {
-   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
 }
 
 static void save_WindowPos2fvMESA(const GLfloat *v)
@@ -3513,7 +3493,7 @@
 
 static void save_WindowPos2ivMESA(const GLint *v)
 {
-   save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
 }
 
 static void save_WindowPos2svMESA(const GLshort *v)
@@ -3523,7 +3503,7 @@
 
 static void save_WindowPos3dvMESA(const GLdouble *v)
 {
-   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
 }
 
 static void save_WindowPos3fvMESA(const GLfloat *v)
@@ -3533,7 +3513,7 @@
 
 static void save_WindowPos3ivMESA(const GLint *v)
 {
-   save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
 }
 
 static void save_WindowPos3svMESA(const GLshort *v)
@@ -3543,7 +3523,8 @@
 
 static void save_WindowPos4dvMESA(const GLdouble *v)
 {
-   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 
+			(GLfloat) v[2], (GLfloat) v[3]);
 }
 
 static void save_WindowPos4fvMESA(const GLfloat *v)
@@ -3553,7 +3534,8 @@
 
 static void save_WindowPos4ivMESA(const GLint *v)
 {
-   save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
+   save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 
+			(GLfloat) v[2], (GLfloat) v[3]);
 }
 
 static void save_WindowPos4svMESA(const GLshort *v)
@@ -3568,8 +3550,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_ACTIVE_TEXTURE, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_ACTIVE_TEXTURE, 1 );
    if (n) {
       n[1].e = target;
    }
@@ -3579,63 +3561,49 @@
 }
 
 
-/* GL_ARB_multitexture */
-static void save_ClientActiveTextureARB( GLenum target )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_CLIENT_ACTIVE_TEXTURE, 1 );
-   if (n) {
-      n[1].e = target;
-   }
-   if (ctx->ExecuteFlag) {
-      (*ctx->Exec->ClientActiveTextureARB)( target );
-   }
-}
-
-
-
 /* GL_ARB_transpose_matrix */
 
 static void save_LoadTransposeMatrixdARB( const GLdouble m[16] )
 {
-   GLdouble tm[16];
-   gl_matrix_transposed(tm, m);
-   save_LoadMatrixd(tm);
+   GLfloat tm[16];
+   _math_transposefd(tm, m);
+   save_LoadMatrixf(tm);
 }
 
 
 static void save_LoadTransposeMatrixfARB( const GLfloat m[16] )
 {
    GLfloat tm[16];
-   gl_matrix_transposef(tm, m);
+   _math_transposef(tm, m);
    save_LoadMatrixf(tm);
 }
 
 
-static void save_MultTransposeMatrixdARB( const GLdouble m[16] )
+static void
+save_MultTransposeMatrixdARB( const GLdouble m[16] )
 {
-   GLdouble tm[16];
-   gl_matrix_transposed(tm, m);
-   save_MultMatrixd(tm);
+   GLfloat tm[16];
+   _math_transposefd(tm, m);
+   save_MultMatrixf(tm);
 }
 
 
-static void save_MultTransposeMatrixfARB( const GLfloat m[16] )
+static void
+save_MultTransposeMatrixfARB( const GLfloat m[16] )
 {
    GLfloat tm[16];
-   gl_matrix_transposef(tm, m);
+   _math_transposef(tm, m);
    save_MultMatrixf(tm);
 }
 
 
-static void save_PixelTexGenSGIX(GLenum mode)
+static void
+save_PixelTexGenSGIX(GLenum mode)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PIXEL_TEXGEN_SGIX, 1 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_SGIX, 1 );
    if (n) {
       n[1].e = mode;
    }
@@ -3661,15 +3629,15 @@
    else {
       Node *n;
       GLvoid *image;
-      FLUSH_VB(ctx, "dlist");
+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
       /* make copy of image */
       image = MALLOC(imageSize);
       if (!image) {
-         gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
          return;
       }
       MEMCPY(image, data, imageSize);
-      n = alloc_instruction( ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7 );
+      n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7 );
       if (n) {
          n[1].e = target;
          n[2].i = level;
@@ -3705,15 +3673,15 @@
    else {
       Node *n;
       GLvoid *image;
-      FLUSH_VB(ctx, "dlist");
+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
       /* make copy of image */
       image = MALLOC(imageSize);
       if (!image) {
-         gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
          return;
       }
       MEMCPY(image, data, imageSize);
-      n = alloc_instruction( ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8 );
+      n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8 );
       if (n) {
          n[1].e = target;
          n[2].i = level;
@@ -3750,15 +3718,15 @@
    else {
       Node *n;
       GLvoid *image;
-      FLUSH_VB(ctx, "dlist");
+      ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
       /* make copy of image */
       image = MALLOC(imageSize);
       if (!image) {
-         gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
          return;
       }
       MEMCPY(image, data, imageSize);
-      n = alloc_instruction( ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9 );
+      n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9 );
       if (n) {
          n[1].e = target;
          n[2].i = level;
@@ -3790,16 +3758,16 @@
    GLvoid *image;
 
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
    /* make copy of image */
    image = MALLOC(imageSize);
    if (!image) {
-      gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");
       return;
    }
    MEMCPY(image, data, imageSize);
-   n = alloc_instruction( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7 );
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -3829,16 +3797,16 @@
    GLvoid *image;
 
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
    /* make copy of image */
    image = MALLOC(imageSize);
    if (!image) {
-      gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");
       return;
    }
    MEMCPY(image, data, imageSize);
-   n = alloc_instruction( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9 );
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -3870,16 +3838,16 @@
    GLvoid *image;
 
    GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VB(ctx, "dlist");
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
 
    /* make copy of image */
    image = MALLOC(imageSize);
    if (!image) {
-      gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");
       return;
    }
    MEMCPY(image, data, imageSize);
-   n = alloc_instruction( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11 );
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11 );
    if (n) {
       n[1].e = target;
       n[2].i = level;
@@ -3903,14 +3871,33 @@
 }
 
 
+/* GL_ARB_multisample */
+static void
+save_SampleCoverageARB(GLclampf value, GLboolean invert)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_SAMPLE_COVERAGE, 2 );
+   if (n) {
+      n[1].f = value;
+      n[2].b = invert;
+   }
+   if (ctx->ExecuteFlag) {
+      (*ctx->Exec->SampleCoverageARB)( value, invert );
+   }
+}
+
+
 /* GL_SGIS_pixel_texture */
 
-static void save_PixelTexGenParameteriSGIS(GLenum target, GLint value)
+static void
+save_PixelTexGenParameteriSGIS(GLenum target, GLint value)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   FLUSH_VB(ctx, "dlist");
-   n = alloc_instruction( ctx, OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS, 2 );
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_PIXEL_TEXGEN_PARAMETER_SGIS, 2 );
    if (n) {
       n[1].e = target;
       n[2].i = value;
@@ -3921,83 +3908,37 @@
 }
 
 
-static void save_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
+static void
+save_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
 {
    save_PixelTexGenParameteriSGIS(target, (GLint) value);
 }
 
 
-static void save_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
+static void
+save_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
 {
    save_PixelTexGenParameteriSGIS(target, *value);
 }
 
 
-static void save_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
+static void
+save_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
 {
    save_PixelTexGenParameteriSGIS(target, (GLint) *value);
 }
 
-void gl_compile_cassette( GLcontext *ctx )
-{
-   Node *n = alloc_instruction( ctx, OPCODE_VERTEX_CASSETTE, 8 );
-   struct immediate *im = ctx->input;   
-
-   if (!n) 
-      return;
-   
-
-   /* Do some easy optimizations of the cassette.  
-    */
-#if 0
-   if (0 && im->v.Obj.size < 4 && im->Count > 15) {
-      im->Bounds = (GLfloat (*)[3]) MALLOC(6 * sizeof(GLfloat));
-      (gl_calc_bound_tab[im->v.Obj.size])( im->Bounds, &im->v.Obj );
-   }
-#endif
-
-   n[1].data = (void *)im;   
-   n[2].ui = im->Start;
-   n[3].ui = im->Count;
-   n[4].ui = im->BeginState;
-   n[5].ui = im->OrFlag;
-   n[6].ui = im->AndFlag;
-   n[7].ui = im->LastData;
-   n[8].ui = im->LastPrimitive;
-
-   if (im->Count > VB_MAX - 4) {
-
-      struct immediate *new_im = gl_immediate_alloc(ctx);      
-      if (!new_im) return;
-      SET_IMMEDIATE( ctx, new_im );
-      gl_reset_input( ctx );
-
-   } else {
-      im->Count++;;
-      im->Start = im->Count;	/* don't clear anything in reset_input */
-      im->ref_count++;
-
-      im->Primitive[im->Start] = ctx->Current.Primitive;
-      im->LastPrimitive = im->Start;
-      im->BeginState = VERT_BEGIN_0;
-      im->OrFlag = 0;
-      im->AndFlag = ~0;
-
-      if (0)
-	 fprintf(stderr, "in compile_cassette, BeginState is %x\n", 
-	      im->BeginState);
-   }   
-}
 
-/* KW: Compile commands  
- * 
+/* KW: Compile commands
+ *
  * Will appear in the list before the vertex buffer containing the
- * command that provoked the error.  I don't see this as a problem.  
+ * command that provoked the error.  I don't see this as a problem.
  */
-void gl_save_error( GLcontext *ctx, GLenum error, const char *s )
+void
+_mesa_save_error( GLcontext *ctx, GLenum error, const char *s )
 {
    Node *n;
-   n = alloc_instruction( ctx, OPCODE_ERROR, 2 );
+   n = ALLOC_INSTRUCTION( ctx, OPCODE_ERROR, 2 );
    if (n) {
       n[1].e = error;
       n[2].data = (void *) s;
@@ -4030,16 +3971,20 @@
  * the absolute list number, not relative to ListBase.
  * Input:  list - display list number
  */
-static void execute_list( GLcontext *ctx, GLuint list )
+static void
+execute_list( GLcontext *ctx, GLuint list )
 {
    Node *n;
    GLboolean done;
-   OpCode opcode;
 
    if (!islist(ctx,list))
       return;
+
+   if (ctx->Driver.BeginCallList)
+      ctx->Driver.BeginCallList( ctx, list );
 
-/*    mesa_print_display_list( list ); */
+/*     fprintf(stderr, "execute list %d\n", list); */
+/*     mesa_print_display_list( list );  */
 
    ctx->CallDepth++;
 
@@ -4047,49 +3992,18 @@
 
    done = GL_FALSE;
    while (!done) {
-      opcode = n[0].opcode;
-
-      switch (opcode) {
-         case OPCODE_ERROR:
- 	    gl_error( ctx, n[1].e, (const char *) n[2].data ); 
-            break;
-         case OPCODE_VERTEX_CASSETTE: {
-	    struct immediate *IM;
-	    
-	    if (ctx->NewState)
-	       gl_update_state(ctx);
-	    if (ctx->CompileCVAFlag) {
-	       ctx->CompileCVAFlag = 0;
-	       ctx->CVA.elt.pipeline_valid = 0;
-	    }
-	    if (!ctx->CVA.elt.pipeline_valid)
-	       gl_build_immediate_pipeline( ctx );
+      OpCode opcode = n[0].opcode;
+      int i = (int)n[0].opcode - (int)OPCODE_DRV_0;
 
-	    
-	    IM = (struct immediate *) n[1].data;
-	    IM->Start = n[2].ui;
-	    IM->Count = n[3].ui;
-	    IM->BeginState = n[4].ui;
-	    IM->OrFlag = n[5].ui;
-	    IM->AndFlag = n[6].ui;
-	    IM->LastData = n[7].ui;
-	    IM->LastPrimitive = n[8].ui;
-
-	    if ((MESA_VERBOSE & VERBOSE_DISPLAY_LIST) &&
-		(MESA_VERBOSE & VERBOSE_IMMEDIATE))
-	       gl_print_cassette( (struct immediate *) n[1].data );
-
-	    if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST) {
-	       fprintf(stderr, "Run cassette %d, rows %d..%d, beginstate %x ",
-		       IM->id,
-		       IM->Start, IM->Count, IM->BeginState);
-	       gl_print_vert_flags("orflag", IM->OrFlag);
-	    }
-
-	    gl_fixup_cassette( ctx, (struct immediate *) n[1].data ); 
-	    gl_execute_cassette( ctx, (struct immediate *) n[1].data ); 
-            break;
-	 }
+      if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
+	 ctx->listext.opcode[i].execute(ctx, &n[1]);
+	 n += ctx->listext.opcode[i].size;
+      }
+      else {
+	 switch (opcode) {
+	 case OPCODE_ERROR:
+	    _mesa_error( ctx, n[1].e, (const char *) n[2].data );
+	    break;
          case OPCODE_ACCUM:
 	    (*ctx->Exec->Accum)( n[1].e, n[2].f );
 	    break;
@@ -4145,7 +4059,7 @@
 	    (*ctx->Exec->ClearDepth)( (GLclampd) n[1].f );
 	    break;
 	 case OPCODE_CLEAR_INDEX:
-	    (*ctx->Exec->ClearIndex)( n[1].ui );
+	    (*ctx->Exec->ClearIndex)( (GLfloat) n[1].ui );
 	    break;
 	 case OPCODE_CLEAR_STENCIL:
 	    (*ctx->Exec->ClearStencil)( n[1].i );
@@ -4335,9 +4249,6 @@
 	 case OPCODE_HINT:
 	    (*ctx->Exec->Hint)( n[1].e, n[2].e );
 	    break;
-	 case OPCODE_HINT_PGI:
-	    (*ctx->Exec->HintPGI)( n[1].e, n[2].i );
-	    break;
 	 case OPCODE_HISTOGRAM:
 	    (*ctx->Exec->Histogram)( n[1].e, n[2].i, n[3].e, n[4].b );
 	    break;
@@ -4474,7 +4385,7 @@
 		params[0] = n[2].f;
 		params[1] = n[3].f;
 		params[2] = n[4].f;
-		(*ctx->Exec->PointParameterfvEXT)( n[1].e, params ); 
+		(*ctx->Exec->PointParameterfvEXT)( n[1].e, params );
 	    }
 	    break;
 	 case OPCODE_POLYGON_MODE:
@@ -4513,16 +4424,15 @@
 	 case OPCODE_READ_BUFFER:
 	    (*ctx->Exec->ReadBuffer)( n[1].e );
 	    break;
-         case OPCODE_RECTF:
-            (*ctx->Exec->Rectf)( n[1].f, n[2].f, n[3].f, n[4].f );
-	    FLUSH_VB( ctx, "dlist rectf" );
-            break;
          case OPCODE_RESET_HISTOGRAM:
             (*ctx->Exec->ResetHistogram)( n[1].e );
             break;
          case OPCODE_RESET_MIN_MAX:
             (*ctx->Exec->ResetMinmax)( n[1].e );
             break;
+         case OPCODE_ROTATE:
+            (*ctx->Exec->Rotatef)( n[1].f, n[2].f, n[3].f, n[4].f );
+            break;
          case OPCODE_SCALE:
             (*ctx->Exec->Scalef)( n[1].f, n[2].f, n[3].f );
             break;
@@ -4666,9 +4576,6 @@
          case OPCODE_ACTIVE_TEXTURE:  /* GL_ARB_multitexture */
             (*ctx->Exec->ActiveTextureARB)( n[1].e );
             break;
-         case OPCODE_CLIENT_ACTIVE_TEXTURE:  /* GL_ARB_multitexture */
-            (*ctx->Exec->ClientActiveTextureARB)( n[1].e );
-            break;
          case OPCODE_PIXEL_TEXGEN_SGIX:  /* GL_SGIX_pixel_texture */
             (*ctx->Exec->PixelTexGenSGIX)( n[1].e );
             break;
@@ -4700,6 +4607,9 @@
                                         n[4].i, n[5].i, n[6].i, n[7].i, n[8].i,
                                         n[9].e, n[10].i, n[11].data);
             break;
+         case OPCODE_SAMPLE_COVERAGE: /* GL_ARB_multisample */
+            (*ctx->Exec->SampleCoverageARB)(n[1].f, n[2].b);
+            break;
 	 case OPCODE_CONTINUE:
 	    n = (Node *) n[1].next;
 	    break;
@@ -4710,18 +4620,21 @@
             {
                char msg[1000];
                sprintf(msg, "Error in execute_list: opcode=%d", (int) opcode);
-               gl_problem( ctx, msg );
+               _mesa_problem( ctx, msg );
             }
             done = GL_TRUE;
-      }
+	 }
 
-      /* increment n to point to next compiled command */
-      if (opcode!=OPCODE_CONTINUE) {
-	 n += InstSize[opcode];
+	 /* increment n to point to next compiled command */
+	 if (opcode!=OPCODE_CONTINUE) {
+	    n += InstSize[opcode];
+	 }
       }
-
    }
    ctx->CallDepth--;
+
+   if (ctx->Driver.EndCallList)
+      ctx->Driver.EndCallList( ctx );
 }
 
 
@@ -4742,6 +4655,8 @@
 _mesa_IsList( GLuint list )
 {
    GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);	/* must be called before assert */
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
    return islist(ctx, list);
 }
 
@@ -4754,14 +4669,15 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLuint i;
+   FLUSH_VERTICES(ctx, 0);	/* must be called before assert */
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDeleteLists");
    if (range<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glDeleteLists" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glDeleteLists" );
       return;
    }
    for (i=list;i<list+range;i++) {
-      gl_destroy_list( ctx, i );
+      _mesa_destroy_list( ctx, i );
    }
 }
 
@@ -4776,10 +4692,11 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLuint base;
+   FLUSH_VERTICES(ctx, 0);	/* must be called before assert */
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glGenLists", 0);
    if (range<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glGenLists" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glGenLists" );
       return 0;
    }
    if (range==0) {
@@ -4814,25 +4731,25 @@
 _mesa_NewList( GLuint list, GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   struct immediate *IM;
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glNewList");
+   FLUSH_CURRENT(ctx, 0);	/* must be called before assert */
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glNewList %u %s\n", list, gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glNewList %u %s\n", list, _mesa_lookup_enum_by_nr(mode));
 
    if (list==0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glNewList" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glNewList" );
       return;
    }
 
    if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) {
-      gl_error( ctx, GL_INVALID_ENUM, "glNewList" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glNewList" );
       return;
    }
 
    if (ctx->CurrentListPtr) {
       /* already compiling a display list */
-      gl_error( ctx, GL_INVALID_OPERATION, "glNewList" );
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glNewList" );
       return;
    }
 
@@ -4841,15 +4758,11 @@
    ctx->CurrentBlock = (Node *) MALLOC( sizeof(Node) * BLOCK_SIZE );
    ctx->CurrentListPtr = ctx->CurrentBlock;
    ctx->CurrentPos = 0;
-
-   IM = gl_immediate_alloc( ctx );
-   SET_IMMEDIATE( ctx, IM );
-   gl_reset_input( ctx );
-
    ctx->CompileFlag = GL_TRUE;
-   ctx->CompileCVAFlag = GL_FALSE;
    ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
 
+   ctx->Driver.NewList( ctx, list, mode );
+
    ctx->CurrentDispatch = ctx->Save;
    _glapi_set_dispatch( ctx->CurrentDispatch );
 }
@@ -4857,27 +4770,30 @@
 
 
 /*
- * End definition of current display list.
+ * End definition of current display list.  Is the current
+ * ASSERT_OUTSIDE_BEGIN_END strong enough to really guarentee that
+ * we are outside begin/end calls?
  */
 void
 _mesa_EndList( void )
 {
    GET_CURRENT_CONTEXT(ctx);
+   FLUSH_CURRENT(ctx, 0);	/* must be called before assert */
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
    if (MESA_VERBOSE&VERBOSE_API)
       fprintf(stderr, "glEndList\n");
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "glEndList" );
-
    /* Check that a list is under construction */
    if (!ctx->CurrentListPtr) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glEndList" );
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glEndList" );
       return;
    }
 
-   (void) alloc_instruction( ctx, OPCODE_END_OF_LIST, 0 );
+   (void) ALLOC_INSTRUCTION( ctx, OPCODE_END_OF_LIST, 0 );
 
    /* Destroy old list, if any */
-   gl_destroy_list(ctx, ctx->CurrentListNum);
+   _mesa_destroy_list(ctx, ctx->CurrentListNum);
    /* Install the list */
    _mesa_HashInsert(ctx->Shared->DisplayList, ctx->CurrentListNum, ctx->CurrentListPtr);
 
@@ -4889,20 +4805,9 @@
    ctx->CurrentListPtr = NULL;
    ctx->ExecuteFlag = GL_TRUE;
    ctx->CompileFlag = GL_FALSE;
-   /* ctx->CompileCVAFlag = ...; */
-
-   /* KW: Put back the old input pointer.
-    */
-   if (--ctx->input->ref_count == 0)
-      gl_immediate_free( ctx->input );
 
-   SET_IMMEDIATE( ctx, ctx->VB->IM );
-   gl_reset_input( ctx );
+   ctx->Driver.EndList( ctx );
 
-   /* Haven't tracked down why this is needed.
-    */
-   ctx->NewState = ~0;
-
    ctx->CurrentDispatch = ctx->Exec;
    _glapi_set_dispatch( ctx->CurrentDispatch );
 }
@@ -4912,23 +4817,26 @@
 void
 _mesa_CallList( GLuint list )
 {
+   GLboolean save_compile_flag;
    GET_CURRENT_CONTEXT(ctx);
+   FLUSH_CURRENT(ctx, 0);
    /* VERY IMPORTANT:  Save the CompileFlag status, turn it off, */
    /* execute the display list, and restore the CompileFlag. */
-   GLboolean save_compile_flag;
 
-   if (MESA_VERBOSE&VERBOSE_API) {
-      fprintf(stderr, "glCallList %u\n", list);
-      mesa_print_display_list( list ); 
-   }
 
-   save_compile_flag = ctx->CompileFlag;   
-   ctx->CompileFlag = GL_FALSE;
-   
-   FLUSH_VB( ctx, "call list" );
-   execute_list( ctx, list );
-   ctx->CompileFlag = save_compile_flag;
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "_mesa_CallList %d\n", list); 
 
+/*     mesa_print_display_list( list ); */
+
+   save_compile_flag = ctx->CompileFlag;
+   if (save_compile_flag) {
+      ctx->CompileFlag = GL_FALSE;
+   }
+
+   execute_list( ctx, list );
+   ctx->CompileFlag = save_compile_flag;
+
    /* also restore API function pointers to point to "save" versions */
    if (save_compile_flag) {
       ctx->CurrentDispatch = ctx->Save;
@@ -4949,14 +4857,15 @@
    GLint i;
    GLboolean save_compile_flag;
 
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "_mesa_CallLists %d\n", n); 
+
    /* Save the CompileFlag status, turn it off, execute display list,
     * and restore the CompileFlag.
     */
    save_compile_flag = ctx->CompileFlag;
    ctx->CompileFlag = GL_FALSE;
 
-   FLUSH_VB( ctx, "call lists" );
-
    for (i=0;i<n;i++) {
       list = translate_id( i, type, lists );
       execute_list( ctx, ctx->List.ListBase + list );
@@ -4980,30 +4889,666 @@
 _mesa_ListBase( GLuint base )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glListBase");
+   FLUSH_VERTICES(ctx, 0);	/* must be called before assert */
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
    ctx->List.ListBase = base;
 }
 
 
+/* Can no longer assume ctx->Exec->Func is equal to _mesa_Func.
+ */
+static void exec_Finish( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->Finish();
+}
+
+static void exec_Flush( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->Flush( );
+}
+
+static void exec_GetBooleanv( GLenum pname, GLboolean *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetBooleanv( pname, params );
+}
+
+static void exec_GetClipPlane( GLenum plane, GLdouble *equation )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetClipPlane( plane, equation );
+}
+
+static void exec_GetDoublev( GLenum pname, GLdouble *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetDoublev(  pname, params );
+}
+
+static GLenum exec_GetError( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   return ctx->Exec->GetError( );
+}
+
+static void exec_GetFloatv( GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetFloatv( pname, params );
+}
+
+static void exec_GetIntegerv( GLenum pname, GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetIntegerv( pname, params );
+}
+
+static void exec_GetLightfv( GLenum light, GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetLightfv( light, pname, params );
+}
+
+static void exec_GetLightiv( GLenum light, GLenum pname, GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetLightiv( light, pname, params );
+}
+
+static void exec_GetMapdv( GLenum target, GLenum query, GLdouble *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMapdv( target, query, v );
+}
+
+static void exec_GetMapfv( GLenum target, GLenum query, GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMapfv( target, query, v );
+}
+
+static void exec_GetMapiv( GLenum target, GLenum query, GLint *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMapiv( target, query, v );
+}
+
+static void exec_GetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMaterialfv( face, pname, params );
+}
+
+static void exec_GetMaterialiv( GLenum face, GLenum pname, GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMaterialiv( face, pname, params );
+}
+
+static void exec_GetPixelMapfv( GLenum map, GLfloat *values )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetPixelMapfv( map,  values );
+}
+
+static void exec_GetPixelMapuiv( GLenum map, GLuint *values )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetPixelMapuiv( map, values );
+}
+
+static void exec_GetPixelMapusv( GLenum map, GLushort *values )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetPixelMapusv( map, values );
+}
+
+static void exec_GetPolygonStipple( GLubyte *dest )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetPolygonStipple( dest );
+}
+
+static const GLubyte *exec_GetString( GLenum name )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   return ctx->Exec->GetString( name );
+}
+
+static void exec_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexEnvfv( target, pname, params );
+}
+
+static void exec_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexEnviv( target, pname, params );
+}
+
+static void exec_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexGendv( coord, pname, params );
+}
+
+static void exec_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexGenfv( coord, pname, params );
+}
+
+static void exec_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexGeniv( coord, pname, params );
+}
+
+static void exec_GetTexImage( GLenum target, GLint level, GLenum format,
+                   GLenum type, GLvoid *pixels )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexImage( target, level, format, type, pixels );
+}
+
+static void exec_GetTexLevelParameterfv( GLenum target, GLint level,
+                              GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexLevelParameterfv( target, level, pname, params );
+}
+
+static void exec_GetTexLevelParameteriv( GLenum target, GLint level,
+                              GLenum pname, GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexLevelParameteriv( target, level, pname, params );
+}
+
+static void exec_GetTexParameterfv( GLenum target, GLenum pname,
+				    GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexParameterfv( target, pname, params );
+}
+
+static void exec_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetTexParameteriv( target, pname, params );
+}
+
+static GLboolean exec_IsEnabled( GLenum cap )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   return ctx->Exec->IsEnabled( cap );
+}
+
+static void exec_PixelStoref( GLenum pname, GLfloat param )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->PixelStoref( pname, param );
+}
+
+static void exec_PixelStorei( GLenum pname, GLint param )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->PixelStorei( pname, param );
+}
+
+static void exec_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
+		  GLenum format, GLenum type, GLvoid *pixels )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->ReadPixels( x, y, width, height, format, type, pixels );
+}
+
+static GLint exec_RenderMode( GLenum mode )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   return ctx->Exec->RenderMode( mode );
+}
+
+static void exec_FeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->FeedbackBuffer( size, type, buffer );
+}
+
+static void exec_SelectBuffer( GLsizei size, GLuint *buffer )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->SelectBuffer( size, buffer );
+}
+
+static GLboolean exec_AreTexturesResident(GLsizei n, const GLuint *texName,
+					  GLboolean *residences)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   return ctx->Exec->AreTexturesResident( n, texName, residences);
+}
 
+static void exec_ColorPointer(GLint size, GLenum type, GLsizei stride,
+			      const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->ColorPointer( size, type, stride, ptr);
+}
 
+static void exec_DeleteTextures( GLsizei n, const GLuint *texName)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->DeleteTextures( n, texName);
+}
+
+static void exec_DisableClientState( GLenum cap )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->DisableClientState( cap );
+}
+
+static void exec_EdgeFlagPointer(GLsizei stride, const void *vptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->EdgeFlagPointer( stride, vptr);
+}
+
+static void exec_EnableClientState( GLenum cap )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->EnableClientState( cap );
+}
+
+static void exec_GenTextures( GLsizei n, GLuint *texName )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GenTextures( n, texName );
+}
+
+static void exec_GetPointerv( GLenum pname, GLvoid **params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetPointerv( pname, params );
+}
+
+static void exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->IndexPointer( type, stride, ptr);
+}
+
+static void exec_InterleavedArrays(GLenum format, GLsizei stride,
+				   const GLvoid *pointer)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->InterleavedArrays( format, stride, pointer);
+}
+
+static GLboolean exec_IsTexture( GLuint texture )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   return ctx->Exec->IsTexture( texture );
+}
+
+static void exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->NormalPointer( type, stride, ptr );
+}
+
+static void exec_PopClientAttrib(void)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->PopClientAttrib();
+}
+
+static void exec_PushClientAttrib(GLbitfield mask)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->PushClientAttrib( mask);
+}
+
+static void exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
+				 const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->TexCoordPointer( size,  type,  stride, ptr);
+}
+
+static void exec_GetCompressedTexImageARB(GLenum target, GLint level,
+					  GLvoid *img)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetCompressedTexImageARB( target, level, img);
+}
+
+static void exec_VertexPointer(GLint size, GLenum type, GLsizei stride,
+			       const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->VertexPointer( size, type, stride, ptr);
+}
+
+static void exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,
+					 GLint x, GLint y, GLsizei width)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->CopyConvolutionFilter1D( target, internalFormat, x, y, width);
+}
+
+static void exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,
+					 GLint x, GLint y, GLsizei width,
+					 GLsizei height)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->CopyConvolutionFilter2D( target, internalFormat, x, y, width,
+				       height);
+}
+
+static void exec_GetColorTable( GLenum target, GLenum format,
+				GLenum type, GLvoid *data )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetColorTable( target, format, type, data );
+}
+
+static void exec_GetColorTableParameterfv( GLenum target, GLenum pname,
+					   GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetColorTableParameterfv( target, pname, params );
+}
+
+static void exec_GetColorTableParameteriv( GLenum target, GLenum pname,
+					   GLint *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetColorTableParameteriv( target, pname, params );
+}
+
+static void exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
+				      GLvoid *image)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetConvolutionFilter( target, format, type, image);
+}
+
+static void exec_GetConvolutionParameterfv(GLenum target, GLenum pname,
+					   GLfloat *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetConvolutionParameterfv( target, pname, params);
+}
+
+static void exec_GetConvolutionParameteriv(GLenum target, GLenum pname,
+					   GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetConvolutionParameteriv( target, pname, params);
+}
+
+static void exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,
+			      GLenum type, GLvoid *values)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetHistogram( target, reset, format, type, values);
+}
+
+static void exec_GetHistogramParameterfv(GLenum target, GLenum pname,
+					 GLfloat *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetHistogramParameterfv( target, pname, params);
+}
+
+static void exec_GetHistogramParameteriv(GLenum target, GLenum pname,
+					 GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetHistogramParameteriv( target, pname, params);
+}
+
+static void exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,
+			   GLenum type, GLvoid *values)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMinmax( target, reset, format, type, values);
+}
+
+static void exec_GetMinmaxParameterfv(GLenum target, GLenum pname,
+				      GLfloat *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMinmaxParameterfv( target, pname, params);
+}
+
+static void exec_GetMinmaxParameteriv(GLenum target, GLenum pname,
+				      GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetMinmaxParameteriv( target, pname, params);
+}
+
+static void exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
+				    GLvoid *row, GLvoid *column, GLvoid *span)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetSeparableFilter( target, format, type, row, column, span);
+}
+
+static void exec_SeparableFilter2D(GLenum target, GLenum internalFormat,
+				   GLsizei width, GLsizei height, GLenum format,
+				   GLenum type, const GLvoid *row,
+				   const GLvoid *column)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->SeparableFilter2D( target, internalFormat, width, height, format,
+				 type, row, column);
+}
+
+static void exec_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetPixelTexGenParameterivSGIS( target, value);
+}
+
+static void exec_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->GetPixelTexGenParameterfvSGIS( target, value);
+}
+
+static void exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
+				 GLsizei count, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->ColorPointerEXT( size, type, stride, count, ptr);
+}
+
+static void exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count,
+				    const GLboolean *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->EdgeFlagPointerEXT( stride, count, ptr);
+}
+
+static void exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
+                      const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->IndexPointerEXT( type, stride, count, ptr);
+}
+
+static void exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
+                       const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->NormalPointerEXT( type, stride, count, ptr);
+}
+
+static void exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
+				    GLsizei count, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->TexCoordPointerEXT( size, type, stride, count, ptr);
+}
+
+static void exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
+                       GLsizei count, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->VertexPointerEXT( size, type, stride, count, ptr);
+}
+
+static void exec_LockArraysEXT(GLint first, GLsizei count)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->LockArraysEXT( first, count);
+}
+
+static void exec_UnlockArraysEXT( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->UnlockArraysEXT( );
+}
+
+static void exec_ResizeBuffersMESA( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->ResizeBuffersMESA( );
+}
+
+
+static void exec_ClientActiveTextureARB( GLenum target )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->ClientActiveTextureARB(target);
+}
+
+static void exec_SecondaryColorPointerEXT(GLint size, GLenum type,
+			       GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->SecondaryColorPointerEXT( size, type, stride, ptr);
+}
+
+static void exec_FogCoordPointerEXT(GLenum type, GLsizei stride,
+				    const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   FLUSH_VERTICES(ctx, 0);
+   ctx->Exec->FogCoordPointerEXT( type, stride, ptr);
+}
+
+
 /*
  * Assign all the pointers in <table> to point to Mesa's display list
  * building functions.
+ *
+ * This does not include any of the tnl functions - they are
+ * initialized from _mesa_init_api_defaults and from the active vtxfmt
+ * struct.
  */
 void
 _mesa_init_dlist_table( struct _glapi_table *table, GLuint tableSize )
 {
    _mesa_init_no_op_table(table, tableSize);
 
+   _mesa_loopback_init_api_table( table, GL_TRUE );
+
    /* GL 1.0 */
    table->Accum = save_Accum;
    table->AlphaFunc = save_AlphaFunc;
-   table->Begin = save_Begin;
    table->Bitmap = save_Bitmap;
    table->BlendFunc = save_BlendFunc;
-   table->CallList = save_CallList;
-   table->CallLists = save_CallLists;
+   table->CallList = _mesa_save_CallList;
+   table->CallLists = _mesa_save_CallLists;
    table->Clear = save_Clear;
    table->ClearAccum = save_ClearAccum;
    table->ClearColor = save_ClearColor;
@@ -5011,38 +5556,6 @@
    table->ClearIndex = save_ClearIndex;
    table->ClearStencil = save_ClearStencil;
    table->ClipPlane = save_ClipPlane;
-   table->Color3b = _mesa_Color3b;
-   table->Color3bv = _mesa_Color3bv;
-   table->Color3d = _mesa_Color3d;
-   table->Color3dv = _mesa_Color3dv;
-   table->Color3f = _mesa_Color3f;
-   table->Color3fv = _mesa_Color3fv;
-   table->Color3i = _mesa_Color3i;
-   table->Color3iv = _mesa_Color3iv;
-   table->Color3s = _mesa_Color3s;
-   table->Color3sv = _mesa_Color3sv;
-   table->Color3ub = _mesa_Color3ub;
-   table->Color3ubv = _mesa_Color3ubv;
-   table->Color3ui = _mesa_Color3ui;
-   table->Color3uiv = _mesa_Color3uiv;
-   table->Color3us = _mesa_Color3us;
-   table->Color3usv = _mesa_Color3usv;
-   table->Color4b = _mesa_Color4b;
-   table->Color4bv = _mesa_Color4bv;
-   table->Color4d = _mesa_Color4d;
-   table->Color4dv = _mesa_Color4dv;
-   table->Color4f = _mesa_Color4f;
-   table->Color4fv = _mesa_Color4fv;
-   table->Color4i = _mesa_Color4i;
-   table->Color4iv = _mesa_Color4iv;
-   table->Color4s = _mesa_Color4s;
-   table->Color4sv = _mesa_Color4sv;
-   table->Color4ub = _mesa_Color4ub;
-   table->Color4ubv = _mesa_Color4ubv;
-   table->Color4ui = _mesa_Color4ui;
-   table->Color4uiv = _mesa_Color4uiv;
-   table->Color4us = _mesa_Color4us;
-   table->Color4usv = _mesa_Color4usv;
    table->ColorMask = save_ColorMask;
    table->ColorMaterial = save_ColorMaterial;
    table->CopyPixels = save_CopyPixels;
@@ -5054,26 +5567,12 @@
    table->Disable = save_Disable;
    table->DrawBuffer = save_DrawBuffer;
    table->DrawPixels = save_DrawPixels;
-   table->EdgeFlag = _mesa_EdgeFlag;
-   table->EdgeFlagv = _mesa_EdgeFlagv;
    table->Enable = save_Enable;
-   table->End = _mesa_End;
    table->EndList = _mesa_EndList;
-   table->EvalCoord1d = _mesa_EvalCoord1d;
-   table->EvalCoord1dv = _mesa_EvalCoord1dv;
-   table->EvalCoord1f = _mesa_EvalCoord1f;
-   table->EvalCoord1fv = _mesa_EvalCoord1fv;
-   table->EvalCoord2d = _mesa_EvalCoord2d;
-   table->EvalCoord2dv = _mesa_EvalCoord2dv;
-   table->EvalCoord2f = _mesa_EvalCoord2f;
-   table->EvalCoord2fv = _mesa_EvalCoord2fv;
-   table->EvalMesh1 = save_EvalMesh1;
-   table->EvalMesh2 = save_EvalMesh2;
-   table->EvalPoint1 = _mesa_EvalPoint1;
-   table->EvalPoint2 = _mesa_EvalPoint2;
-   table->FeedbackBuffer = _mesa_FeedbackBuffer;
-   table->Finish = _mesa_Finish;
-   table->Flush = _mesa_Flush;
+   table->EvalMesh1 = _mesa_save_EvalMesh1;
+   table->EvalMesh2 = _mesa_save_EvalMesh2;
+   table->Finish = exec_Finish;
+   table->Flush = exec_Flush;
    table->Fogf = save_Fogf;
    table->Fogfv = save_Fogfv;
    table->Fogi = save_Fogi;
@@ -5081,46 +5580,38 @@
    table->FrontFace = save_FrontFace;
    table->Frustum = save_Frustum;
    table->GenLists = _mesa_GenLists;
-   table->GetBooleanv = _mesa_GetBooleanv;
-   table->GetClipPlane = _mesa_GetClipPlane;
-   table->GetDoublev = _mesa_GetDoublev;
-   table->GetError = _mesa_GetError;
-   table->GetFloatv = _mesa_GetFloatv;
-   table->GetIntegerv = _mesa_GetIntegerv;
-   table->GetLightfv = _mesa_GetLightfv;
-   table->GetLightiv = _mesa_GetLightiv;
-   table->GetMapdv = _mesa_GetMapdv;
-   table->GetMapfv = _mesa_GetMapfv;
-   table->GetMapiv = _mesa_GetMapiv;
-   table->GetMaterialfv = _mesa_GetMaterialfv;
-   table->GetMaterialiv = _mesa_GetMaterialiv;
-   table->GetPixelMapfv = _mesa_GetPixelMapfv;
-   table->GetPixelMapuiv = _mesa_GetPixelMapuiv;
-   table->GetPixelMapusv = _mesa_GetPixelMapusv;
-   table->GetPolygonStipple = _mesa_GetPolygonStipple;
-   table->GetString = _mesa_GetString;
-   table->GetTexEnvfv = _mesa_GetTexEnvfv;
-   table->GetTexEnviv = _mesa_GetTexEnviv;
-   table->GetTexGendv = _mesa_GetTexGendv;
-   table->GetTexGenfv = _mesa_GetTexGenfv;
-   table->GetTexGeniv = _mesa_GetTexGeniv;
-   table->GetTexImage = _mesa_GetTexImage;
-   table->GetTexLevelParameterfv = _mesa_GetTexLevelParameterfv;
-   table->GetTexLevelParameteriv = _mesa_GetTexLevelParameteriv;
-   table->GetTexParameterfv = _mesa_GetTexParameterfv;
-   table->GetTexParameteriv = _mesa_GetTexParameteriv;
+   table->GetBooleanv = exec_GetBooleanv;
+   table->GetClipPlane = exec_GetClipPlane;
+   table->GetDoublev = exec_GetDoublev;
+   table->GetError = exec_GetError;
+   table->GetFloatv = exec_GetFloatv;
+   table->GetIntegerv = exec_GetIntegerv;
+   table->GetLightfv = exec_GetLightfv;
+   table->GetLightiv = exec_GetLightiv;
+   table->GetMapdv = exec_GetMapdv;
+   table->GetMapfv = exec_GetMapfv;
+   table->GetMapiv = exec_GetMapiv;
+   table->GetMaterialfv = exec_GetMaterialfv;
+   table->GetMaterialiv = exec_GetMaterialiv;
+   table->GetPixelMapfv = exec_GetPixelMapfv;
+   table->GetPixelMapuiv = exec_GetPixelMapuiv;
+   table->GetPixelMapusv = exec_GetPixelMapusv;
+   table->GetPolygonStipple = exec_GetPolygonStipple;
+   table->GetString = exec_GetString;
+   table->GetTexEnvfv = exec_GetTexEnvfv;
+   table->GetTexEnviv = exec_GetTexEnviv;
+   table->GetTexGendv = exec_GetTexGendv;
+   table->GetTexGenfv = exec_GetTexGenfv;
+   table->GetTexGeniv = exec_GetTexGeniv;
+   table->GetTexImage = exec_GetTexImage;
+   table->GetTexLevelParameterfv = exec_GetTexLevelParameterfv;
+   table->GetTexLevelParameteriv = exec_GetTexLevelParameteriv;
+   table->GetTexParameterfv = exec_GetTexParameterfv;
+   table->GetTexParameteriv = exec_GetTexParameteriv;
    table->Hint = save_Hint;
    table->IndexMask = save_IndexMask;
-   table->Indexd = _mesa_Indexd;
-   table->Indexdv = _mesa_Indexdv;
-   table->Indexf = _mesa_Indexf;
-   table->Indexfv = _mesa_Indexfv;
-   table->Indexi = _mesa_Indexi;
-   table->Indexiv = _mesa_Indexiv;
-   table->Indexs = _mesa_Indexs;
-   table->Indexsv = _mesa_Indexsv;
    table->InitNames = save_InitNames;
-   table->IsEnabled = _mesa_IsEnabled;
+   table->IsEnabled = exec_IsEnabled;
    table->IsList = _mesa_IsList;
    table->LightModelf = save_LightModelf;
    table->LightModelfv = save_LightModelfv;
@@ -5146,31 +5637,17 @@
    table->MapGrid1f = save_MapGrid1f;
    table->MapGrid2d = save_MapGrid2d;
    table->MapGrid2f = save_MapGrid2f;
-   table->Materialf = _mesa_Materialf;
-   table->Materialfv = _mesa_Materialfv;
-   table->Materiali = _mesa_Materiali;
-   table->Materialiv = _mesa_Materialiv;
    table->MatrixMode = save_MatrixMode;
    table->MultMatrixd = save_MultMatrixd;
    table->MultMatrixf = save_MultMatrixf;
    table->NewList = save_NewList;
-   table->Normal3b = _mesa_Normal3b;
-   table->Normal3bv = _mesa_Normal3bv;
-   table->Normal3d = _mesa_Normal3d;
-   table->Normal3dv = _mesa_Normal3dv;
-   table->Normal3f = _mesa_Normal3f;
-   table->Normal3fv = _mesa_Normal3fv;
-   table->Normal3i = _mesa_Normal3i;
-   table->Normal3iv = _mesa_Normal3iv;
-   table->Normal3s = _mesa_Normal3s;
-   table->Normal3sv = _mesa_Normal3sv;
    table->Ortho = save_Ortho;
    table->PassThrough = save_PassThrough;
    table->PixelMapfv = save_PixelMapfv;
    table->PixelMapuiv = save_PixelMapuiv;
    table->PixelMapusv = save_PixelMapusv;
-   table->PixelStoref = _mesa_PixelStoref;
-   table->PixelStorei = _mesa_PixelStorei;
+   table->PixelStoref = exec_PixelStoref;
+   table->PixelStorei = exec_PixelStorei;
    table->PixelTransferf = save_PixelTransferf;
    table->PixelTransferi = save_PixelTransferi;
    table->PixelZoom = save_PixelZoom;
@@ -5209,58 +5686,19 @@
    table->RasterPos4s = save_RasterPos4s;
    table->RasterPos4sv = save_RasterPos4sv;
    table->ReadBuffer = save_ReadBuffer;
-   table->ReadPixels = _mesa_ReadPixels;
-   table->Rectd = save_Rectd;
-   table->Rectdv = save_Rectdv;
-   table->Rectf = save_Rectf;
-   table->Rectfv = save_Rectfv;
-   table->Recti = save_Recti;
-   table->Rectiv = save_Rectiv;
-   table->Rects = save_Rects;
-   table->Rectsv = save_Rectsv;
-   table->RenderMode = _mesa_RenderMode;
+   table->ReadPixels = exec_ReadPixels;
+   table->RenderMode = exec_RenderMode;
    table->Rotated = save_Rotated;
    table->Rotatef = save_Rotatef;
    table->Scaled = save_Scaled;
    table->Scalef = save_Scalef;
    table->Scissor = save_Scissor;
-   table->SelectBuffer = _mesa_SelectBuffer;
+   table->FeedbackBuffer = exec_FeedbackBuffer;
+   table->SelectBuffer = exec_SelectBuffer;
    table->ShadeModel = save_ShadeModel;
    table->StencilFunc = save_StencilFunc;
    table->StencilMask = save_StencilMask;
    table->StencilOp = save_StencilOp;
-   table->TexCoord1d = _mesa_TexCoord1d;
-   table->TexCoord1dv = _mesa_TexCoord1dv;
-   table->TexCoord1f = _mesa_TexCoord1f;
-   table->TexCoord1fv = _mesa_TexCoord1fv;
-   table->TexCoord1i = _mesa_TexCoord1i;
-   table->TexCoord1iv = _mesa_TexCoord1iv;
-   table->TexCoord1s = _mesa_TexCoord1s;
-   table->TexCoord1sv = _mesa_TexCoord1sv;
-   table->TexCoord2d = _mesa_TexCoord2d;
-   table->TexCoord2dv = _mesa_TexCoord2dv;
-   table->TexCoord2f = _mesa_TexCoord2f;
-   table->TexCoord2fv = _mesa_TexCoord2fv;
-   table->TexCoord2i = _mesa_TexCoord2i;
-   table->TexCoord2iv = _mesa_TexCoord2iv;
-   table->TexCoord2s = _mesa_TexCoord2s;
-   table->TexCoord2sv = _mesa_TexCoord2sv;
-   table->TexCoord3d = _mesa_TexCoord3d;
-   table->TexCoord3dv = _mesa_TexCoord3dv;
-   table->TexCoord3f = _mesa_TexCoord3f;
-   table->TexCoord3fv = _mesa_TexCoord3fv;
-   table->TexCoord3i = _mesa_TexCoord3i;
-   table->TexCoord3iv = _mesa_TexCoord3iv;
-   table->TexCoord3s = _mesa_TexCoord3s;
-   table->TexCoord3sv = _mesa_TexCoord3sv;
-   table->TexCoord4d = _mesa_TexCoord4d;
-   table->TexCoord4dv = _mesa_TexCoord4dv;
-   table->TexCoord4f = _mesa_TexCoord4f;
-   table->TexCoord4fv = _mesa_TexCoord4fv;
-   table->TexCoord4i = _mesa_TexCoord4i;
-   table->TexCoord4iv = _mesa_TexCoord4iv;
-   table->TexCoord4s = _mesa_TexCoord4s;
-   table->TexCoord4sv = _mesa_TexCoord4sv;
    table->TexEnvf = save_TexEnvf;
    table->TexEnvfv = save_TexEnvfv;
    table->TexEnvi = save_TexEnvi;
@@ -5279,66 +5717,39 @@
    table->TexParameteriv = save_TexParameteriv;
    table->Translated = save_Translated;
    table->Translatef = save_Translatef;
-   table->Vertex2d = _mesa_Vertex2d;
-   table->Vertex2dv = _mesa_Vertex2dv;
-   table->Vertex2f = _mesa_Vertex2f;
-   table->Vertex2fv = _mesa_Vertex2fv;
-   table->Vertex2i = _mesa_Vertex2i;
-   table->Vertex2iv = _mesa_Vertex2iv;
-   table->Vertex2s = _mesa_Vertex2s;
-   table->Vertex2sv = _mesa_Vertex2sv;
-   table->Vertex3d = _mesa_Vertex3d;
-   table->Vertex3dv = _mesa_Vertex3dv;
-   table->Vertex3f = _mesa_Vertex3f;
-   table->Vertex3fv = _mesa_Vertex3fv;
-   table->Vertex3i = _mesa_Vertex3i;
-   table->Vertex3iv = _mesa_Vertex3iv;
-   table->Vertex3s = _mesa_Vertex3s;
-   table->Vertex3sv = _mesa_Vertex3sv;
-   table->Vertex4d = _mesa_Vertex4d;
-   table->Vertex4dv = _mesa_Vertex4dv;
-   table->Vertex4f = _mesa_Vertex4f;
-   table->Vertex4fv = _mesa_Vertex4fv;
-   table->Vertex4i = _mesa_Vertex4i;
-   table->Vertex4iv = _mesa_Vertex4iv;
-   table->Vertex4s = _mesa_Vertex4s;
-   table->Vertex4sv = _mesa_Vertex4sv;
    table->Viewport = save_Viewport;
 
    /* GL 1.1 */
-   table->AreTexturesResident = _mesa_AreTexturesResident;
-   table->ArrayElement = _mesa_ArrayElement;
+   table->AreTexturesResident = exec_AreTexturesResident;
+   table->AreTexturesResidentEXT = exec_AreTexturesResident;
    table->BindTexture = save_BindTexture;
-   table->ColorPointer = _mesa_ColorPointer;
+   table->ColorPointer = exec_ColorPointer;
    table->CopyTexImage1D = save_CopyTexImage1D;
    table->CopyTexImage2D = save_CopyTexImage2D;
    table->CopyTexSubImage1D = save_CopyTexSubImage1D;
    table->CopyTexSubImage2D = save_CopyTexSubImage2D;
-   table->DeleteTextures = _mesa_DeleteTextures;
-   table->DisableClientState = _mesa_DisableClientState;
-   table->DrawArrays = _mesa_DrawArrays;
-   table->DrawElements = _mesa_DrawElements;
-   table->EdgeFlagPointer = _mesa_EdgeFlagPointer;
-   table->EnableClientState = _mesa_EnableClientState;
-   table->GenTextures = _mesa_GenTextures;
-   table->GetPointerv = _mesa_GetPointerv;
-   table->IndexPointer = _mesa_IndexPointer;
-   table->Indexub = _mesa_Indexub;
-   table->Indexubv = _mesa_Indexubv;
-   table->InterleavedArrays = _mesa_InterleavedArrays;
-   table->IsTexture = _mesa_IsTexture;
-   table->NormalPointer = _mesa_NormalPointer;
-   table->PopClientAttrib = _mesa_PopClientAttrib;
+   table->DeleteTextures = exec_DeleteTextures;
+   table->DisableClientState = exec_DisableClientState;
+   table->EdgeFlagPointer = exec_EdgeFlagPointer;
+   table->EnableClientState = exec_EnableClientState;
+   table->GenTextures = exec_GenTextures;
+   table->GenTexturesEXT = exec_GenTextures;
+   table->GetPointerv = exec_GetPointerv;
+   table->IndexPointer = exec_IndexPointer;
+   table->InterleavedArrays = exec_InterleavedArrays;
+   table->IsTexture = exec_IsTexture;
+   table->IsTextureEXT = exec_IsTexture;
+   table->NormalPointer = exec_NormalPointer;
+   table->PopClientAttrib = exec_PopClientAttrib;
    table->PrioritizeTextures = save_PrioritizeTextures;
-   table->PushClientAttrib = _mesa_PushClientAttrib;
-   table->TexCoordPointer = _mesa_TexCoordPointer;
+   table->PushClientAttrib = exec_PushClientAttrib;
+   table->TexCoordPointer = exec_TexCoordPointer;
    table->TexSubImage1D = save_TexSubImage1D;
    table->TexSubImage2D = save_TexSubImage2D;
-   table->VertexPointer = _mesa_VertexPointer;
+   table->VertexPointer = exec_VertexPointer;
 
    /* GL 1.2 */
    table->CopyTexSubImage3D = save_CopyTexSubImage3D;
-   table->DrawRangeElements = _mesa_DrawRangeElements;
    table->TexImage3D = save_TexImage3D;
    table->TexSubImage3D = save_TexSubImage3D;
 
@@ -5358,29 +5769,42 @@
    table->ConvolutionParameteriv = save_ConvolutionParameteriv;
    table->CopyColorSubTable = save_CopyColorSubTable;
    table->CopyColorTable = save_CopyColorTable;
-   table->CopyConvolutionFilter1D = _mesa_CopyConvolutionFilter1D;
-   table->CopyConvolutionFilter2D = _mesa_CopyConvolutionFilter2D;
-   table->GetColorTable = _mesa_GetColorTable;
-   table->GetColorTableParameterfv = _mesa_GetColorTableParameterfv;
-   table->GetColorTableParameteriv = _mesa_GetColorTableParameteriv;
-   table->GetConvolutionFilter = _mesa_GetConvolutionFilter;
-   table->GetConvolutionParameterfv = _mesa_GetConvolutionParameterfv;
-   table->GetConvolutionParameteriv = _mesa_GetConvolutionParameteriv;
-   table->GetHistogram = _mesa_GetHistogram;
-   table->GetHistogramParameterfv = _mesa_GetHistogramParameterfv;
-   table->GetHistogramParameteriv = _mesa_GetHistogramParameteriv;
-   table->GetMinmax = _mesa_GetMinmax;
-   table->GetMinmaxParameterfv = _mesa_GetMinmaxParameterfv;
-   table->GetMinmaxParameteriv = _mesa_GetMinmaxParameteriv;
-   table->GetSeparableFilter = _mesa_GetSeparableFilter;
+   table->CopyConvolutionFilter1D = exec_CopyConvolutionFilter1D;
+   table->CopyConvolutionFilter2D = exec_CopyConvolutionFilter2D;
+   table->GetColorTable = exec_GetColorTable;
+   table->GetColorTableEXT = exec_GetColorTable;
+   table->GetColorTableParameterfv = exec_GetColorTableParameterfv;
+   table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
+   table->GetColorTableParameteriv = exec_GetColorTableParameteriv;
+   table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
+   table->GetConvolutionFilter = exec_GetConvolutionFilter;
+   table->GetConvolutionFilterEXT = exec_GetConvolutionFilter;
+   table->GetConvolutionParameterfv = exec_GetConvolutionParameterfv;
+   table->GetConvolutionParameterfvEXT = exec_GetConvolutionParameterfv;
+   table->GetConvolutionParameteriv = exec_GetConvolutionParameteriv;
+   table->GetConvolutionParameterivEXT = exec_GetConvolutionParameteriv;
+   table->GetHistogram = exec_GetHistogram;
+   table->GetHistogramEXT = exec_GetHistogram;
+   table->GetHistogramParameterfv = exec_GetHistogramParameterfv;
+   table->GetHistogramParameterfvEXT = exec_GetHistogramParameterfv;
+   table->GetHistogramParameteriv = exec_GetHistogramParameteriv;
+   table->GetHistogramParameterivEXT = exec_GetHistogramParameteriv;
+   table->GetMinmax = exec_GetMinmax;
+   table->GetMinmaxEXT = exec_GetMinmax;
+   table->GetMinmaxParameterfv = exec_GetMinmaxParameterfv;
+   table->GetMinmaxParameterfvEXT = exec_GetMinmaxParameterfv;
+   table->GetMinmaxParameteriv = exec_GetMinmaxParameteriv;
+   table->GetMinmaxParameterivEXT = exec_GetMinmaxParameteriv;
+   table->GetSeparableFilter = exec_GetSeparableFilter;
+   table->GetSeparableFilterEXT = exec_GetSeparableFilter;
    table->Histogram = save_Histogram;
    table->Minmax = save_Minmax;
    table->ResetHistogram = save_ResetHistogram;
    table->ResetMinmax = save_ResetMinmax;
-   table->SeparableFilter2D = _mesa_SeparableFilter2D;
+   table->SeparableFilter2D = exec_SeparableFilter2D;
 
    /* 2. GL_EXT_blend_color */
-#if 0 
+#if 0
    table->BlendColorEXT = save_BlendColorEXT;
 #endif
 
@@ -5402,16 +5826,16 @@
    table->PixelTexGenParameterfSGIS = save_PixelTexGenParameterfSGIS;
    table->PixelTexGenParameterivSGIS = save_PixelTexGenParameterivSGIS;
    table->PixelTexGenParameterfvSGIS = save_PixelTexGenParameterfvSGIS;
-   table->GetPixelTexGenParameterivSGIS = _mesa_GetPixelTexGenParameterivSGIS;
-   table->GetPixelTexGenParameterfvSGIS = _mesa_GetPixelTexGenParameterfvSGIS;
+   table->GetPixelTexGenParameterivSGIS = exec_GetPixelTexGenParameterivSGIS;
+   table->GetPixelTexGenParameterfvSGIS = exec_GetPixelTexGenParameterfvSGIS;
 
    /* 30. GL_EXT_vertex_array */
-   table->ColorPointerEXT = _mesa_ColorPointerEXT;
-   table->EdgeFlagPointerEXT = _mesa_EdgeFlagPointerEXT;
-   table->IndexPointerEXT = _mesa_IndexPointerEXT;
-   table->NormalPointerEXT = _mesa_NormalPointerEXT;
-   table->TexCoordPointerEXT = _mesa_TexCoordPointerEXT;
-   table->VertexPointerEXT = _mesa_VertexPointerEXT;
+   table->ColorPointerEXT = exec_ColorPointerEXT;
+   table->EdgeFlagPointerEXT = exec_EdgeFlagPointerEXT;
+   table->IndexPointerEXT = exec_IndexPointerEXT;
+   table->NormalPointerEXT = exec_NormalPointerEXT;
+   table->TexCoordPointerEXT = exec_TexCoordPointerEXT;
+   table->VertexPointerEXT = exec_VertexPointerEXT;
 
    /* 37. GL_EXT_blend_minmax */
 #if 0
@@ -5422,57 +5846,22 @@
    table->PointParameterfEXT = save_PointParameterfEXT;
    table->PointParameterfvEXT = save_PointParameterfvEXT;
 
-   /* 77. GL_PGI_misc_hints */
-   table->HintPGI = save_HintPGI;
-
    /* 78. GL_EXT_paletted_texture */
 #if 0
    table->ColorTableEXT = save_ColorTable;
    table->ColorSubTableEXT = save_ColorSubTable;
 #endif
-   table->GetColorTableEXT = _mesa_GetColorTable;
-   table->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfv;
-   table->GetColorTableParameterivEXT = _mesa_GetColorTableParameteriv;
+   table->GetColorTableEXT = exec_GetColorTable;
+   table->GetColorTableParameterfvEXT = exec_GetColorTableParameterfv;
+   table->GetColorTableParameterivEXT = exec_GetColorTableParameteriv;
 
    /* 97. GL_EXT_compiled_vertex_array */
-   table->LockArraysEXT = _mesa_LockArraysEXT;
-   table->UnlockArraysEXT = _mesa_UnlockArraysEXT;
+   table->LockArraysEXT = exec_LockArraysEXT;
+   table->UnlockArraysEXT = exec_UnlockArraysEXT;
 
    /* GL_ARB_multitexture */
    table->ActiveTextureARB = save_ActiveTextureARB;
-   table->ClientActiveTextureARB = save_ClientActiveTextureARB;
-   table->MultiTexCoord1dARB = _mesa_MultiTexCoord1dARB;
-   table->MultiTexCoord1dvARB = _mesa_MultiTexCoord1dvARB;
-   table->MultiTexCoord1fARB = _mesa_MultiTexCoord1fARB;
-   table->MultiTexCoord1fvARB = _mesa_MultiTexCoord1fvARB;
-   table->MultiTexCoord1iARB = _mesa_MultiTexCoord1iARB;
-   table->MultiTexCoord1ivARB = _mesa_MultiTexCoord1ivARB;
-   table->MultiTexCoord1sARB = _mesa_MultiTexCoord1sARB;
-   table->MultiTexCoord1svARB = _mesa_MultiTexCoord1svARB;
-   table->MultiTexCoord2dARB = _mesa_MultiTexCoord2dARB;
-   table->MultiTexCoord2dvARB = _mesa_MultiTexCoord2dvARB;
-   table->MultiTexCoord2fARB = _mesa_MultiTexCoord2fARB;
-   table->MultiTexCoord2fvARB = _mesa_MultiTexCoord2fvARB;
-   table->MultiTexCoord2iARB = _mesa_MultiTexCoord2iARB;
-   table->MultiTexCoord2ivARB = _mesa_MultiTexCoord2ivARB;
-   table->MultiTexCoord2sARB = _mesa_MultiTexCoord2sARB;
-   table->MultiTexCoord2svARB = _mesa_MultiTexCoord2svARB;
-   table->MultiTexCoord3dARB = _mesa_MultiTexCoord3dARB;
-   table->MultiTexCoord3dvARB = _mesa_MultiTexCoord3dvARB;
-   table->MultiTexCoord3fARB = _mesa_MultiTexCoord3fARB;
-   table->MultiTexCoord3fvARB = _mesa_MultiTexCoord3fvARB;
-   table->MultiTexCoord3iARB = _mesa_MultiTexCoord3iARB;
-   table->MultiTexCoord3ivARB = _mesa_MultiTexCoord3ivARB;
-   table->MultiTexCoord3sARB = _mesa_MultiTexCoord3sARB;
-   table->MultiTexCoord3svARB = _mesa_MultiTexCoord3svARB;
-   table->MultiTexCoord4dARB = _mesa_MultiTexCoord4dARB;
-   table->MultiTexCoord4dvARB = _mesa_MultiTexCoord4dvARB;
-   table->MultiTexCoord4fARB = _mesa_MultiTexCoord4fARB;
-   table->MultiTexCoord4fvARB = _mesa_MultiTexCoord4fvARB;
-   table->MultiTexCoord4iARB = _mesa_MultiTexCoord4iARB;
-   table->MultiTexCoord4ivARB = _mesa_MultiTexCoord4ivARB;
-   table->MultiTexCoord4sARB = _mesa_MultiTexCoord4sARB;
-   table->MultiTexCoord4svARB = _mesa_MultiTexCoord4svARB;
+   table->ClientActiveTextureARB = exec_ClientActiveTextureARB;
 
    /* GL_EXT_blend_func_separate */
    table->BlendFuncSeparateEXT = save_BlendFuncSeparateEXT;
@@ -5504,7 +5893,7 @@
    table->WindowPos4svMESA = save_WindowPos4svMESA;
 
    /* GL_MESA_resize_buffers */
-   table->ResizeBuffersMESA = _mesa_ResizeBuffersMESA;
+   table->ResizeBuffersMESA = exec_ResizeBuffersMESA;
 
    /* GL_ARB_transpose_matrix */
    table->LoadTransposeMatrixdARB = save_LoadTransposeMatrixdARB;
@@ -5512,6 +5901,9 @@
    table->MultTransposeMatrixdARB = save_MultTransposeMatrixdARB;
    table->MultTransposeMatrixfARB = save_MultTransposeMatrixfARB;
 
+   /* GL_ARB_multisample */
+   table->SampleCoverageARB = save_SampleCoverageARB;
+
    /* ARB 12. GL_ARB_texture_compression */
    table->CompressedTexImage3DARB = save_CompressedTexImage3DARB;
    table->CompressedTexImage2DARB = save_CompressedTexImage2DARB;
@@ -5519,7 +5911,13 @@
    table->CompressedTexSubImage3DARB = save_CompressedTexSubImage3DARB;
    table->CompressedTexSubImage2DARB = save_CompressedTexSubImage2DARB;
    table->CompressedTexSubImage1DARB = save_CompressedTexSubImage1DARB;
-   table->GetCompressedTexImageARB = _mesa_GetCompressedTexImageARB;
+   table->GetCompressedTexImageARB = exec_GetCompressedTexImageARB;
+
+   /* GL_EXT_secondary_color */
+   table->SecondaryColorPointerEXT = exec_SecondaryColorPointerEXT;
+
+   /* GL_EXT_fog_coord */
+   table->FogCoordPointerEXT = exec_FogCoordPointerEXT;
 }
 
 
@@ -5529,7 +5927,7 @@
  ***/
 static const char *enum_string( GLenum k )
 {
-   return gl_lookup_enum_by_nr( k );
+   return _mesa_lookup_enum_by_nr( k );
 }
 
 
@@ -5541,7 +5939,6 @@
 {
    Node *n;
    GLboolean done;
-   OpCode opcode;
 
    if (!glIsList(list)) {
       fprintf(f,"%u is not a display list ID\n",list);
@@ -5554,9 +5951,15 @@
 
    done = n ? GL_FALSE : GL_TRUE;
    while (!done) {
-      opcode = n[0].opcode;
+      OpCode opcode = n[0].opcode;
+      GLint i = (GLint) n[0].opcode - (GLint) OPCODE_DRV_0;
 
-      switch (opcode) {
+      if (i >= 0 && i < (GLint) ctx->listext.nr_opcodes) {
+	 ctx->listext.opcode[i].print(ctx, &n[1]);
+	 n += ctx->listext.opcode[i].size;
+      }
+      else {
+	 switch (opcode) {
          case OPCODE_ACCUM:
             fprintf(f,"accum %s %g\n", enum_string(n[1].e), n[2].f );
 	    break;
@@ -5636,8 +6039,8 @@
 	 case OPCODE_RASTER_POS:
             fprintf(f,"RasterPos %g %g %g %g\n", n[1].f, n[2].f,n[3].f,n[4].f);
 	    break;
-         case OPCODE_RECTF:
-            fprintf( f, "Rectf %g %g %g %g\n", n[1].f, n[2].f, n[3].f, n[4].f);
+         case OPCODE_ROTATE:
+            fprintf(f,"Rotate %g %g %g %g\n", n[1].f, n[2].f, n[3].f, n[4].f );
             break;
          case OPCODE_SCALE:
             fprintf(f,"Scale %g %g %g\n", n[1].f, n[2].f, n[3].f );
@@ -5646,12 +6049,38 @@
             fprintf(f,"Translate %g %g %g\n", n[1].f, n[2].f, n[3].f );
             break;
          case OPCODE_BIND_TEXTURE:
-	    fprintf(f,"BindTexture %s %d\n", gl_lookup_enum_by_nr(n[1].ui), 
+	    fprintf(f,"BindTexture %s %d\n", _mesa_lookup_enum_by_nr(n[1].ui),
 		    n[2].ui);
 	    break;
          case OPCODE_SHADE_MODEL:
-	    fprintf(f,"ShadeModel %s\n", gl_lookup_enum_by_nr(n[1].ui)); 
+	    fprintf(f,"ShadeModel %s\n", _mesa_lookup_enum_by_nr(n[1].ui));
+	    break;
+	 case OPCODE_MAP1:
+	    fprintf(f,"Map1 %s %.3f %.3f %d %d\n", 
+		    _mesa_lookup_enum_by_nr(n[1].ui),
+		    n[2].f, n[3].f, n[4].i, n[5].i);
+	    break;
+	 case OPCODE_MAP2:
+	    fprintf(f,"Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n", 
+		    _mesa_lookup_enum_by_nr(n[1].ui),
+		    n[2].f, n[3].f, n[4].f, n[5].f,
+		    n[6].i, n[7].i, n[8].i, n[9].i);
+	    break;
+	 case OPCODE_MAPGRID1:
+	    fprintf(f,"MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);
+	    break;
+	 case OPCODE_MAPGRID2:
+	    fprintf(f,"MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n", 
+		    n[1].i, n[2].f, n[3].f,
+		    n[4].i, n[5].f, n[6].f);
 	    break;
+	 case OPCODE_EVALMESH1:
+	    fprintf(f,"EvalMesh1 %d %d\n", n[1].i, n[2].i);
+	    break;
+	 case OPCODE_EVALMESH2:
+	    fprintf(f,"EvalMesh2 %d %d %d %d\n",
+		    n[1].i, n[2].i, n[3].i, n[4].i);
+	    break;
 
 	 /*
 	  * meta opcodes/commands
@@ -5659,24 +6088,6 @@
          case OPCODE_ERROR:
             fprintf(f,"Error: %s %s\n", enum_string(n[1].e), (const char *)n[2].data );
             break;
-	 case OPCODE_VERTEX_CASSETTE:
-            {
-               struct immediate *IM; 
-               fprintf(f,"VERTEX-CASSETTE, id %u, rows %u..%u\n", 
-                       ((struct immediate *) n[1].data)->id,
-                       n[2].ui,
-                       n[3].ui);
-               IM = (struct immediate *) n[1].data; 
-               IM->Start = n[2].ui; 
-               IM->Count = n[3].ui; 
-               IM->BeginState = n[4].ui; 
-               IM->OrFlag = n[5].ui; 
-               IM->AndFlag = n[6].ui; 
-               IM->LastData = n[7].ui; 
-               IM->LastPrimitive = n[8].ui; 
-               gl_print_cassette( (struct immediate *) n[1].data );
-            }
-	    break;
 	 case OPCODE_CONTINUE:
             fprintf(f,"DISPLAY-LIST-CONTINUE\n");
 	    n = (Node *) n[1].next;
@@ -5694,11 +6105,11 @@
             else {
                fprintf(f,"command %d, %u operands\n",opcode,InstSize[opcode]);
             }
-      }
-
-      /* increment n to point to next compiled command */
-      if (opcode!=OPCODE_CONTINUE) {
-	 n += InstSize[opcode];
+	 }
+	 /* increment n to point to next compiled command */
+	 if (opcode!=OPCODE_CONTINUE) {
+	    n += InstSize[opcode];
+	 }
       }
    }
 }
Index: xc/extras/Mesa/src/dlist.h
diff -u xc/extras/Mesa/src/dlist.h:1.4 xc/extras/Mesa/src/dlist.h:1.5
--- xc/extras/Mesa/src/dlist.h:1.4	Fri Jun 16 20:02:09 2000
+++ xc/extras/Mesa/src/dlist.h	Fri Feb 22 14:25:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,26 +28,44 @@
 #define DLIST_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
-struct display_list {
-   union node *nodes;	
-   GLuint OrFlag;
-   struct gl_current_attrib outputs;
-};
+#define ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval)		\
+do {									\
+   if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\
+       ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\
+      _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" );	\
+      return retval;							\
+   }									\
+} while (0)
+
+#define ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx)				\
+do {									\
+   if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON ||		\
+       ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) {	\
+      _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" );	\
+      return;								\
+   }									\
+} while (0)
+
+#define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx)			\
+do {									\
+   ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);					\
+   FLUSH_VERTICES(ctx, 0);						\
+} while (0)
+
+#define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)\
+do {									\
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval);		\
+   FLUSH_VERTICES(ctx, 0);						\
+} while (0)
 
-struct display_list_compilation {
-   struct display_list *list;
-   union node *current_block;
-   GLuint current_pos;
-};
 
+extern void _mesa_init_lists( void );
 
-extern void gl_init_lists( void );
+extern void _mesa_destroy_list( GLcontext *ctx, GLuint list );
 
-extern void gl_destroy_list( GLcontext *ctx, GLuint list );
-
 extern void _mesa_CallList( GLuint list );
 
 extern void _mesa_CallLists( GLsizei n, GLenum type, const GLvoid *lists );
@@ -65,10 +83,25 @@
 extern void _mesa_NewList( GLuint list, GLenum mode );
 
 extern void _mesa_init_dlist_table( struct _glapi_table *table, GLuint tableSize );
+
+extern void _mesa_save_error( GLcontext *ctx, GLenum error, const char *s );
+
+
+void *
+_mesa_alloc_instruction( GLcontext *ctx, int opcode, GLint sz );
 
-extern void gl_compile_cassette( GLcontext *ctx );
+int
+_mesa_alloc_opcode( GLcontext *ctx, GLuint sz,
+		    void (*execute)( GLcontext *, void * ),
+		    void (*destroy)( GLcontext *, void * ),
+		    void (*print)( GLcontext *, void * ) );
+
+extern void _mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2,
+				 GLint j1, GLint j2 );
+extern void _mesa_save_EvalMesh1( GLenum mode, GLint i1, GLint i2 );
+extern void _mesa_save_CallLists( GLsizei n, GLenum type, const GLvoid *lists );
+extern void _mesa_save_CallList( GLuint list );
 
-extern void gl_save_error( GLcontext *ctx, GLenum error, const char *s );
 
 
 #endif
Index: xc/extras/Mesa/src/dotprod_tmp.h
diff -u xc/extras/Mesa/src/dotprod_tmp.h:1.3 xc/extras/Mesa/src/dotprod_tmp.h:removed
--- xc/extras/Mesa/src/dotprod_tmp.h:1.3	Tue Feb 15 02:12:11 2000
+++ xc/extras/Mesa/src/dotprod_tmp.h	Thu Feb 27 12:15:35 2003
@@ -1,127 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-/* Note - respects the stride of the output vector.
- */
-static void TAG(dotprod_vec2)( GLvector4f *out_vec, 
-			     GLuint elt,
-			     const GLvector4f *coord_vec, 
-			     const GLfloat plane[4], 
-			     const GLubyte mask[])
-{
-   GLuint stride = coord_vec->stride;
-   GLfloat *coord = coord_vec->start;
-   GLuint count = coord_vec->count;
-
-   GLuint outstride = out_vec->stride;
-   GLfloat *out = out_vec->start + elt;
-   GLuint i;
-   
-   const GLfloat plane0 = plane[0], plane1 = plane[1], plane3 = plane[3];
-      
-   (void) mask;
-
-   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(out,outstride)) {
-      CULL_CHECK {
-	 *out = (coord[0] * plane0 +
-		 coord[1] * plane1 +
-		            plane3);
-      }
-   }   
-   out_vec->count = coord_vec->count;
-}
-
-static void TAG(dotprod_vec3)( GLvector4f *out_vec, 
-			     GLuint elt,
-			     const GLvector4f *coord_vec, 
-			     const GLfloat plane[4], 
-			     const GLubyte mask[])
-{
-   GLuint stride = coord_vec->stride;
-   GLfloat *coord = coord_vec->start;
-   GLuint count = coord_vec->count;
-
-   GLuint outstride = out_vec->stride;
-   GLfloat *out = out_vec->start + elt;
-   GLuint i;
-
-   const GLfloat plane0 = plane[0], plane1 = plane[1], plane2 = plane[2];
-   const GLfloat plane3 = plane[3];
-
-   (void) mask;
-
-   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(out,outstride)) {
-      CULL_CHECK {
-	 *out = (coord[0] * plane0 +
-		 coord[1] * plane1 +
-		 coord[2] * plane2 +
-		            plane3);
-      }
-   }   
-   out_vec->count = coord_vec->count;
-}
-
-static void TAG(dotprod_vec4)( GLvector4f *out_vec, 
-			     GLuint elt,
-			     const GLvector4f *coord_vec, 
-			     const GLfloat plane[4], 
-			     const GLubyte mask[])
-{
-   GLuint stride = coord_vec->stride;
-   GLfloat *coord = coord_vec->start;
-   GLuint count = coord_vec->count;
-
-   GLuint outstride = out_vec->stride;
-   GLfloat *out = out_vec->start + elt;
-   GLuint i;
-
-   const GLfloat plane0 = plane[0], plane1 = plane[1], plane2 = plane[2];
-   const GLfloat plane3 = plane[3];
-
-   (void) mask;
-
-   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(out,outstride)) {
-      CULL_CHECK {
-	 *out = (coord[0] * plane0 +
-		 coord[1] * plane1 +
-		 coord[2] * plane2 +
-		 coord[3] * plane3);
-      }
-   }   
-   out_vec->count = coord_vec->count;
-}
-
-
-static void TAG(init_dotprod)( void )
-{
-   gl_dotprod_tab[IDX&1][2] = TAG(dotprod_vec2);
-   gl_dotprod_tab[IDX&1][3] = TAG(dotprod_vec3);
-   gl_dotprod_tab[IDX&1][4] = TAG(dotprod_vec4);
-}
Index: xc/extras/Mesa/src/drawpix.c
diff -u xc/extras/Mesa/src/drawpix.c:1.8 xc/extras/Mesa/src/drawpix.c:1.9
--- xc/extras/Mesa/src/drawpix.c:1.8	Mon Nov 13 18:30:44 2000
+++ xc/extras/Mesa/src/drawpix.c	Fri Feb 22 14:25:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.1
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,854 +28,196 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "drawpix.h"
 #include "feedback.h"
-#include "image.h"
 #include "macros.h"
 #include "mem.h"
 #include "mmath.h"
-#include "pixel.h"
-#include "pixeltex.h"
-#include "span.h"
 #include "state.h"
-#include "stencil.h"
-#include "texture.h"
-#include "types.h"
-#include "zoom.h"
+#include "mtypes.h"
 #endif
 
 
 
 /*
- * Given the dest position, size and skipPixels and skipRows values
- * for a glDrawPixels command, perform clipping of the image bounds
- * so the result lies withing the context's buffer bounds.
- * Return:  GL_TRUE if image is ready for drawing
- *          GL_FALSE if image was completely clipped away (draw nothing)
+ * Execute glDrawPixels
  */
-GLboolean
-_mesa_clip_pixelrect(const GLcontext *ctx,
-                     GLint *destX, GLint *destY,
-                     GLsizei *width, GLsizei *height,
-                     GLint *skipPixels, GLint *skipRows)
+void
+_mesa_DrawPixels( GLsizei width, GLsizei height,
+                  GLenum format, GLenum type, const GLvoid *pixels )
 {
-   const GLframebuffer *buffer = ctx->DrawBuffer;
-
-   /* left clipping */
-   if (*destX < buffer->Xmin) {
-      *skipPixels += (buffer->Xmin - *destX);
-      *width -= (buffer->Xmin - *destX);
-      *destX = buffer->Xmin;
-   }
-   /* right clipping */
-   if (*destX + *width > buffer->Xmax)
-      *width -= (*destX + *width - buffer->Xmax - 1);
-
-   if (*width <= 0)
-      return GL_FALSE;
-
-   /* bottom clipping */
-   if (*destY < buffer->Ymin) {
-      *skipRows += (buffer->Ymin - *destY);
-      *height -= (buffer->Ymin - *destY);
-      *destY = buffer->Ymin;
-   }
-   /* top clipping */
-   if (*destY + *height > buffer->Ymax)
-      *height -= (*destY + *height - buffer->Ymax - 1);
-
-   if (*height <= 0)
-      return GL_TRUE;
-
-   return GL_TRUE;
-}
-
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
+   if (width < 0 || height < 0) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glDrawPixels(width or height < 0" );
+      return;
+   }
 
-/*
- * Try to do a fast and simple RGB(a) glDrawPixels.
- * Return:  GL_TRUE if success, GL_FALSE if slow path must be used instead
- */
-static GLboolean
-simple_DrawPixels( GLcontext *ctx, GLint x, GLint y,
-                   GLsizei width, GLsizei height, GLenum format, GLenum type,
-                   const GLvoid *pixels )
-{
-   const struct gl_pixelstore_attrib *unpack = &ctx->Unpack;
-   GLubyte rgb[MAX_WIDTH][3];
-   GLubyte rgba[MAX_WIDTH][4];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glDrawPixels", 
-						  GL_FALSE);
-
-
-   if (!ctx->Current.RasterPosValid) {
-      /* no-op */
-      return GL_TRUE;
-   }
-
-   if ((ctx->RasterMask&(~(SCISSOR_BIT|WINCLIP_BIT)))==0
-       && !ctx->Pixel.ScaleOrBiasRGBA
-       && !ctx->Pixel.ScaleOrBiasRGBApcm
-       && ctx->ColorMatrix.type == MATRIX_IDENTITY
-       && !ctx->Pixel.ColorTableEnabled
-       && !ctx->Pixel.PostColorMatrixColorTableEnabled
-       && !ctx->Pixel.PostConvolutionColorTableEnabled
-       && !ctx->Pixel.MinMaxEnabled
-       && !ctx->Pixel.HistogramEnabled
-       && ctx->Pixel.IndexShift==0 && ctx->Pixel.IndexOffset==0
-       && ctx->Texture.ReallyEnabled == 0
-       && unpack->Alignment==1
-       && !unpack->SwapBytes
-       && !unpack->LsbFirst) {
-
-      GLint destX = x;
-      GLint destY = y;
-      GLint drawWidth = width;           /* actual width drawn */
-      GLint drawHeight = height;         /* actual height drawn */
-      GLint skipPixels = unpack->SkipPixels;
-      GLint skipRows = unpack->SkipRows;
-      GLint rowLength;
-      GLdepth zSpan[MAX_WIDTH];  /* only used when zooming */
-      GLint zoomY0 = 0;
-
-      if (unpack->RowLength > 0)
-         rowLength = unpack->RowLength;
-      else
-         rowLength = width;
-
-      /* If we're not using pixel zoom then do all clipping calculations
-       * now.  Otherwise, we'll let the gl_write_zoomed_*_span() functions
-       * handle the clipping.
-       */
-      if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
-         /* horizontal clipping */
-         if (destX < ctx->DrawBuffer->Xmin) {
-            skipPixels += (ctx->DrawBuffer->Xmin - destX);
-            drawWidth  -= (ctx->DrawBuffer->Xmin - destX);
-            destX = ctx->DrawBuffer->Xmin;
-         }
-         if (destX + drawWidth > ctx->DrawBuffer->Xmax)
-            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->Xmax - 1);
-         if (drawWidth <= 0)
-            return GL_TRUE;
-
-         /* vertical clipping */
-         if (destY < ctx->DrawBuffer->Ymin) {
-            skipRows   += (ctx->DrawBuffer->Ymin - destY);
-            drawHeight -= (ctx->DrawBuffer->Ymin - destY);
-            destY = ctx->DrawBuffer->Ymin;
-         }
-         if (destY + drawHeight > ctx->DrawBuffer->Ymax)
-            drawHeight -= (destY + drawHeight - ctx->DrawBuffer->Ymax - 1);
-         if (drawHeight <= 0)
-            return GL_TRUE;
-      }
-      else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
-         /* upside-down image */
-         /* horizontal clipping */
-         if (destX < ctx->DrawBuffer->Xmin) {
-            skipPixels += (ctx->DrawBuffer->Xmin - destX);
-            drawWidth  -= (ctx->DrawBuffer->Xmin - destX);
-            destX = ctx->DrawBuffer->Xmin;
-         }
-         if (destX + drawWidth > ctx->DrawBuffer->Xmax)
-            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->Xmax - 1);
-         if (drawWidth <= 0)
-            return GL_TRUE;
-
-         /* vertical clipping */
-         if (destY > ctx->DrawBuffer->Ymax) {
-            skipRows   += (destY - ctx->DrawBuffer->Ymax - 1);
-            drawHeight -= (destY - ctx->DrawBuffer->Ymax - 1);
-            destY = ctx->DrawBuffer->Ymax + 1;
-         }
-         if (destY - drawHeight < ctx->DrawBuffer->Ymin)
-            drawHeight -= (ctx->DrawBuffer->Ymin - (destY - drawHeight));
-         if (drawHeight <= 0)
-            return GL_TRUE;
+   if (ctx->RenderMode==GL_RENDER) {
+      GLint x, y;
+      if (!pixels || !ctx->Current.RasterPosValid) {
+	 return;
       }
-      else {
-         /* setup array of fragment Z value to pass to zoom function */
-         GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual->DepthMaxF);
-         GLint i;
-         ASSERT(drawWidth < MAX_WIDTH);
-         for (i=0; i<drawWidth; i++)
-            zSpan[i] = z;
 
-         /* save Y value of first row */
-         zoomY0 = (GLint) (ctx->Current.RasterPos[1] + 0.5F);
+      if (ctx->NewState) {
+         _mesa_update_state(ctx);
       }
 
+      /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
+      x = IROUND(ctx->Current.RasterPos[0]);
+      y = IROUND(ctx->Current.RasterPos[1]);
 
-      /*
-       * Ready to draw!
-       * The window region at (destX, destY) of size (drawWidth, drawHeight)
-       * will be written to.
-       * We'll take pixel data from buffer pointed to by "pixels" but we'll
-       * skip "skipRows" rows and skip "skipPixels" pixels/row.
-       */
-
-      if (format==GL_RGBA && type==GL_UNSIGNED_BYTE
-          && ctx->Pixel.MapColorFlag==0) {
-         if (ctx->Visual->RGBAflag) {
-            GLubyte *src = (GLubyte *) pixels
-               + (skipRows * rowLength + skipPixels) * 4;
-            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
-               /* no zooming */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
-                                             (CONST GLubyte (*)[4]) src, NULL);
-                  src += rowLength * 4;
-                  destY++;
-               }
-            }
-            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
-               /* upside-down */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  destY--;
-                  (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
-                                             (CONST GLubyte (*)[4]) src, NULL);
-                  src += rowLength * 4;
-               }
-            }
-            else {
-               /* with zooming */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  gl_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
-                                    zSpan, (CONST GLubyte (*)[4]) src, zoomY0);
-                  src += rowLength * 4;
-                  destY++;
-               }
-            }
-         }
-         return GL_TRUE;
-      }
-      else if (format==GL_RGB && type==GL_UNSIGNED_BYTE
-               && ctx->Pixel.MapColorFlag==0) {
-         if (ctx->Visual->RGBAflag) {
-            GLubyte *src = (GLubyte *) pixels
-               + (skipRows * rowLength + skipPixels) * 3;
-            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
-                                             (CONST GLubyte (*)[3]) src, NULL);
-                  src += rowLength * 3;
-                  destY++;
-               }
-            }
-            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
-               /* upside-down */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  destY--;
-                  (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
-                                             (CONST GLubyte (*)[3]) src, NULL);
-                  src += rowLength * 3;
-               }
-            }
-            else {
-               /* with zooming */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  gl_write_zoomed_rgb_span(ctx, drawWidth, destX, destY,
-                                    zSpan, (CONST GLubyte (*)[3]) src, zoomY0);
-                  src += rowLength * 3;
-                  destY++;
-               }
-            }
-         }
-         return GL_TRUE;
-      }
-      else if (format==GL_LUMINANCE && type==GL_UNSIGNED_BYTE
-               && ctx->Pixel.MapColorFlag==0) {
-         if (ctx->Visual->RGBAflag) {
-            GLubyte *src = (GLubyte *) pixels
-               + (skipRows * rowLength + skipPixels);
-            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
-               /* no zooming */
-               GLint row;
-               ASSERT(drawWidth < MAX_WIDTH);
-               for (row=0; row<drawHeight; row++) {
-                  GLint i;
-		  for (i=0;i<drawWidth;i++) {
-                     rgb[i][0] = src[i];
-                     rgb[i][1] = src[i];
-                     rgb[i][2] = src[i];
-		  }
-                  (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
-                                             (CONST GLubyte (*)[3]) rgb, NULL);
-                  src += rowLength;
-                  destY++;
-               }
-            }
-            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
-               /* upside-down */
-               GLint row;
-               ASSERT(drawWidth < MAX_WIDTH);
-               for (row=0; row<drawHeight; row++) {
-                  GLint i;
-                  for (i=0;i<drawWidth;i++) {
-                     rgb[i][0] = src[i];
-                     rgb[i][1] = src[i];
-                     rgb[i][2] = src[i];
-                  }
-                  destY--;
-                  (*ctx->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
-                                             (CONST GLubyte (*)[3]) rgb, NULL);
-                  src += rowLength;
-               }
-            }
-            else {
-               /* with zooming */
-               GLint row;
-               ASSERT(drawWidth < MAX_WIDTH);
-               for (row=0; row<drawHeight; row++) {
-                  GLint i;
-		  for (i=0;i<drawWidth;i++) {
-                     rgb[i][0] = src[i];
-                     rgb[i][1] = src[i];
-                     rgb[i][2] = src[i];
-		  }
-                  gl_write_zoomed_rgb_span(ctx, drawWidth, destX, destY,
-                                    zSpan, (CONST GLubyte (*)[3]) rgb, zoomY0);
-                  src += rowLength;
-                  destY++;
-               }
-            }
-         }
-         return GL_TRUE;
-      }
-      else if (format==GL_LUMINANCE_ALPHA && type==GL_UNSIGNED_BYTE
-               && ctx->Pixel.MapColorFlag==0) {
-         if (ctx->Visual->RGBAflag) {
-            GLubyte *src = (GLubyte *) pixels
-               + (skipRows * rowLength + skipPixels)*2;
-            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
-               /* no zooming */
-               GLint row;
-               ASSERT(drawWidth < MAX_WIDTH);
-               for (row=0; row<drawHeight; row++) {
-                  GLint i;
-                  GLubyte *ptr = src;
-		  for (i=0;i<drawWidth;i++) {
-                     rgba[i][0] = *ptr;
-                     rgba[i][1] = *ptr;
-                     rgba[i][2] = *ptr++;
-                     rgba[i][3] = *ptr++;
-		  }
-                  (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
-                                            (CONST GLubyte (*)[4]) rgba, NULL);
-                  src += rowLength*2;
-                  destY++;
-               }
-            }
-            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
-               /* upside-down */
-               GLint row;
-               ASSERT(drawWidth < MAX_WIDTH);
-               for (row=0; row<drawHeight; row++) {
-                  GLint i;
-                  GLubyte *ptr = src;
-                  for (i=0;i<drawWidth;i++) {
-                     rgba[i][0] = *ptr;
-                     rgba[i][1] = *ptr;
-                     rgba[i][2] = *ptr++;
-                     rgba[i][3] = *ptr++;
-                  }
-                  destY--;
-                  (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
-                                            (CONST GLubyte (*)[4]) rgba, NULL);
-                  src += rowLength*2;
-               }
-            }
-            else {
-               /* with zooming */
-               GLint row;
-               ASSERT(drawWidth < MAX_WIDTH);
-               for (row=0; row<drawHeight; row++) {
-                  GLubyte *ptr = src;
-                  GLint i;
-		  for (i=0;i<drawWidth;i++) {
-                     rgba[i][0] = *ptr;
-                     rgba[i][1] = *ptr;
-                     rgba[i][2] = *ptr++;
-                     rgba[i][3] = *ptr++;
-		  }
-                  gl_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
-                                   zSpan, (CONST GLubyte (*)[4]) rgba, zoomY0);
-                  src += rowLength*2;
-                  destY++;
-               }
-            }
-         }
-         return GL_TRUE;
-      }
-      else if (format==GL_COLOR_INDEX && type==GL_UNSIGNED_BYTE) {
-         GLubyte *src = (GLubyte *) pixels + skipRows * rowLength + skipPixels;
-         if (ctx->Visual->RGBAflag) {
-            /* convert CI data to RGBA */
-            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
-               /* no zooming */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  ASSERT(drawWidth < MAX_WIDTH);
-                  _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
-                  (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
-                                               (CONST GLubyte (*)[4])rgba, 
-					       NULL);
-                  src += rowLength;
-                  destY++;
-               }
-               return GL_TRUE;
-            }
-            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
-               /* upside-down */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  ASSERT(drawWidth < MAX_WIDTH);
-                  _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
-                  destY--;
-                  (*ctx->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
-                                               (CONST GLubyte (*)[4])rgba, 
-                                               NULL);
-                  src += rowLength;
-               }
-               return GL_TRUE;
-            }
-            else {
-               /* with zooming */
-               GLint row;
-               for (row=0; row<drawHeight; row++) {
-                  ASSERT(drawWidth < MAX_WIDTH);
-                  _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
-                  gl_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
-                                   zSpan, (CONST GLubyte (*)[4]) rgba, zoomY0);
-                  src += rowLength;
-                  destY++;
-               }
-               return GL_TRUE;
-            }
-         }
-         else {
-            /* write CI data to CI frame buffer */
-            GLint row;
-            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
-               /* no zooming */
-               for (row=0; row<drawHeight; row++) {
-                  (*ctx->Driver.WriteCI8Span)(ctx, drawWidth, destX, destY,
-                                              src, NULL);
-                  src += rowLength;
-                  destY++;
-               }
-               return GL_TRUE;
-            }
-            else {
-               /* with zooming */
-               return GL_FALSE;
-            }
-         }
+      ctx->OcclusionResult = GL_TRUE;
+      ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
+			     &ctx->Unpack, pixels);
+   }
+   else if (ctx->RenderMode==GL_FEEDBACK) {
+      if (ctx->Current.RasterPosValid) {
+	 FLUSH_CURRENT(ctx, 0);
+         FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
+         _mesa_feedback_vertex( ctx,
+				ctx->Current.RasterPos,
+				ctx->Current.RasterColor,
+				ctx->Current.RasterIndex, 
+				ctx->Current.RasterTexCoord );
       }
-      else {
-         /* can't handle this pixel format and/or data type here */
-         return GL_FALSE;
+   }
+   else if (ctx->RenderMode==GL_SELECT) {
+      if (ctx->Current.RasterPosValid) {
+         _mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
       }
    }
-
-   /* can't do a simple draw, have to use slow path */
-   return GL_FALSE;
 }
 
 
 
-/*
- * Do glDrawPixels of index pixels.
- */
-static void
-draw_index_pixels( GLcontext *ctx, GLint x, GLint y,
-                   GLsizei width, GLsizei height,
-                   GLenum type, const GLvoid *pixels )
+void
+_mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
+		  GLenum format, GLenum type, GLvoid *pixels )
 {
-   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
-   const GLint desty = y;
-   GLint row, drawWidth;
-   GLdepth zspan[MAX_WIDTH];
-
-   drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
-
-   /* Fragment depth values */
-   if (ctx->Depth.Test || ctx->Fog.Enabled) {
-      GLdepth zval = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual->DepthMaxF);
-      GLint i;
-      for (i = 0; i < drawWidth; i++) {
-	 zspan[i] = zval;
-      }
-   }
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   /*
-    * General solution
-    */
-   for (row = 0; row < height; row++, y++) {
-      GLuint indexes[MAX_WIDTH];
-      const GLvoid *source = _mesa_image_address(&ctx->Unpack,
-                    pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0);
-      _mesa_unpack_index_span(ctx, drawWidth, GL_UNSIGNED_INT, indexes,
-                              type, source, &ctx->Unpack, GL_TRUE);
-      if (zoom) {
-         gl_write_zoomed_index_span(ctx, drawWidth, x, y, zspan, indexes, desty);
-      }
-      else {
-         gl_write_index_span(ctx, drawWidth, x, y, zspan, indexes, GL_BITMAP);
-      }
+   if (width < 0 || height < 0) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glReadPixels(width or height < 0)" );
+      return;
    }
-}
-
-
 
-/*
- * Do glDrawPixels of stencil image.  The image datatype may either
- * be GLubyte or GLbitmap.
- */
-static void 
-draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y,
-                     GLsizei width, GLsizei height,
-                     GLenum type, const GLvoid *pixels )
-{
-   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
-   const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
-   const GLint desty = y;
-   GLint row, drawWidth;
-
-   if (type != GL_BYTE &&
-       type != GL_UNSIGNED_BYTE &&
-       type != GL_SHORT &&
-       type != GL_UNSIGNED_SHORT &&
-       type != GL_INT &&
-       type != GL_UNSIGNED_INT &&
-       type != GL_FLOAT &&
-       type != GL_BITMAP) {
-      gl_error( ctx, GL_INVALID_ENUM, "glDrawPixels(stencil type)");
+   if (!pixels) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glReadPixels(pixels)" );
       return;
    }
 
-   drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+   if (ctx->NewState)
+      _mesa_update_state(ctx);
 
-   for (row = 0; row < height; row++, y++) {
-      GLstencil values[MAX_WIDTH];
-      GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))
-                      ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
-      const GLvoid *source = _mesa_image_address(&ctx->Unpack,
-                    pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0);
-      _mesa_unpack_index_span(ctx, drawWidth, destType, values,
-                              type, source, &ctx->Unpack, GL_FALSE);
-      if (shift_or_offset) {
-         _mesa_shift_and_offset_stencil( ctx, drawWidth, values );
-      }
-      if (ctx->Pixel.MapStencilFlag) {
-         _mesa_map_stencil( ctx, drawWidth, values );
-      }
+   ctx->Driver.ReadPixels(ctx, x, y, width, height,
+			  format, type, &ctx->Pack, pixels);
 
-      if (zoom) {
-         gl_write_zoomed_stencil_span( ctx, (GLuint) drawWidth, x, y,
-                                       values, desty );
-      }
-      else {
-         _mesa_write_stencil_span( ctx, (GLuint) drawWidth, x, y, values );
-      }
-   }
 }
 
 
 
-/*
- * Do a glDrawPixels of depth values.
- */
-static void
-draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
-                   GLsizei width, GLsizei height,
-                   GLenum type, const GLvoid *pixels )
+void
+_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
+                  GLenum type )
 {
-   const GLboolean bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0;
-   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
-   const GLint desty = y;
-   GLubyte rgba[MAX_WIDTH][4];
-   GLuint ispan[MAX_WIDTH];
-   GLint drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
-
-   if (type != GL_BYTE
-       && type != GL_UNSIGNED_BYTE
-       && type != GL_SHORT
-       && type != GL_UNSIGNED_SHORT
-       && type != GL_INT
-       && type != GL_UNSIGNED_INT
-       && type != GL_FLOAT) {
-      gl_error(ctx, GL_INVALID_ENUM, "glDrawPixels(type)");
-      return;
-   }
+   GET_CURRENT_CONTEXT(ctx);
+   GLint destx, desty;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   /* Colors or indexes */
-   if (ctx->Visual->RGBAflag) {
-      GLint r = (GLint) (ctx->Current.RasterColor[0] * 255.0F);
-      GLint g = (GLint) (ctx->Current.RasterColor[1] * 255.0F);
-      GLint b = (GLint) (ctx->Current.RasterColor[2] * 255.0F);
-      GLint a = (GLint) (ctx->Current.RasterColor[3] * 255.0F);
-      GLint i;
-      for (i = 0; i < drawWidth; i++) {
-         rgba[i][RCOMP] = r;
-         rgba[i][GCOMP] = g;
-         rgba[i][BCOMP] = b;
-         rgba[i][ACOMP] = a;
-      }
-   }
-   else {
-      GLint i;
-      for (i = 0; i < drawWidth; i++) {
-	 ispan[i] = ctx->Current.RasterIndex;
-      }
+   if (width < 0 || height < 0) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)" );
+      return;
    }
 
-   if (type==GL_UNSIGNED_SHORT && sizeof(GLdepth)==sizeof(GLushort)
-       && !bias_or_scale && !zoom && ctx->Visual->RGBAflag) {
-      /* Special case: directly write 16-bit depth values */
-      GLint row;
-      for (row = 0; row < height; row++, y++) {
-         GLdepth zspan[MAX_WIDTH];
-         const GLushort *zptr = (const GLushort *)
-            _mesa_image_address(&ctx->Unpack, pixels, width, height,
-                                GL_DEPTH_COMPONENT, type, 0, row, 0);
-         GLint i;
-         for (i = 0; i < width; i++)
-            zspan[i] = zptr[i];
-         gl_write_rgba_span( ctx, width, x, y, zspan, rgba, GL_BITMAP );
-      }
+   if (ctx->NewState) {
+      _mesa_update_state(ctx);
    }
-   else if (type==GL_UNSIGNED_INT && ctx->Visual->DepthBits == 32
-       && !bias_or_scale && !zoom && ctx->Visual->RGBAflag) {
-      /* Special case: directly write 32-bit depth values */
-      GLint row;
-      for (row = 0; row < height; row++, y++) {
-         const GLuint *zptr = (const GLuint *)
-            _mesa_image_address(&ctx->Unpack, pixels, width, height,
-                                GL_DEPTH_COMPONENT, type, 0, row, 0);
-         gl_write_rgba_span( ctx, width, x, y, zptr, rgba, GL_BITMAP );
-      }
-   }
-   else {
-      /* General case */
-      GLint row;
-      for (row = 0; row < height; row++, y++) {
-         GLdepth zspan[MAX_WIDTH];
-         const GLvoid *src = _mesa_image_address(&ctx->Unpack,
-                pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0);
-         _mesa_unpack_depth_span( ctx, drawWidth, zspan, type, src,
-                                  &ctx->Unpack, GL_TRUE );
-         if (ctx->Visual->RGBAflag) {
-            if (zoom) {
-               gl_write_zoomed_rgba_span(ctx, width, x, y, zspan,
-                                         (CONST GLubyte (*)[4])rgba, desty);
-            }
-            else {
-               gl_write_rgba_span(ctx, width, x, y, zspan, rgba, GL_BITMAP);
-            }
-         }
-         else {
-            if (zoom) {
-               gl_write_zoomed_index_span(ctx, width, x, y, zspan,
-                                          ispan, GL_BITMAP);
-            }
-            else {
-               gl_write_index_span(ctx, width, x, y, zspan, ispan, GL_BITMAP);
-            }
-         }
 
+   if (ctx->RenderMode==GL_RENDER) {
+      /* Destination of copy: */
+      if (!ctx->Current.RasterPosValid) {
+	 return;
       }
-   }
-}
 
+      /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
+      destx = IROUND(ctx->Current.RasterPos[0]);
+      desty = IROUND(ctx->Current.RasterPos[1]);
 
-/*
- * Do glDrawPixels of RGBA pixels.
- */
-static void
-draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
-                  GLsizei width, GLsizei height,
-                  GLenum format, GLenum type, const GLvoid *pixels )
-{
-   const struct gl_pixelstore_attrib *unpack = &ctx->Unpack;
-   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
-   const GLint desty = y;
-   GLdepth zspan[MAX_WIDTH];
-   GLboolean quickDraw;
+      ctx->OcclusionResult = GL_TRUE;
 
-   if (!_mesa_is_legal_format_and_type(format, type)) {
-      gl_error(ctx, GL_INVALID_ENUM, "glDrawPixels(format or type)");
-      return;
+      ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
+			      type );
    }
-
-   /* Try an optimized glDrawPixels first */
-   if (simple_DrawPixels(ctx, x, y, width, height, format, type, pixels))
-      return;
-
-   /* Fragment depth values */
-   if (ctx->Depth.Test || ctx->Fog.Enabled) {
-      /* fill in array of z values */
-      GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->Visual->DepthMaxF);
-      GLint i;
-      for (i=0;i<width;i++) {
-	 zspan[i] = z;
+   else if (ctx->RenderMode == GL_FEEDBACK) {
+      if (ctx->Current.RasterPosValid) {
+	 FLUSH_CURRENT(ctx, 0);
+         FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
+         _mesa_feedback_vertex( ctx,
+				ctx->Current.RasterPos,
+				ctx->Current.RasterColor,
+				ctx->Current.RasterIndex, 
+				ctx->Current.RasterTexCoord );
       }
    }
-
-
-   if (ctx->RasterMask == 0 && !zoom
-       && x >= 0 && y >= 0
-       && x + width <= ctx->DrawBuffer->Width
-       && y + height <= ctx->DrawBuffer->Height) {
-      quickDraw = GL_TRUE;
-   }
-   else {
-      quickDraw = GL_FALSE;
-   }
-
-   /*
-    * General solution
-    */
-   {
-      GLubyte rgba[MAX_WIDTH][4];
-      GLint row;
-      if (width > MAX_WIDTH)
-         width = MAX_WIDTH;
-      for (row = 0; row < height; row++, y++) {
-         const GLvoid *source = _mesa_image_address(unpack,
-                  pixels, width, height, format, type, 0, row, 0);
-         _mesa_unpack_ubyte_color_span(ctx, width, GL_RGBA,
-                   (GLubyte *) rgba, format, type, source, unpack, GL_TRUE);
-         if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) ||
-             (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink))
-            continue;
-
-         if (ctx->Texture.ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
-            GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH];
-            GLubyte primary_rgba[MAX_WIDTH][4];
-            GLuint unit;
-            /* XXX not sure how multitexture is supposed to work here */
-
-            MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLubyte));
-
-            for (unit = 0; unit < MAX_TEXTURE_UNITS; unit++) {
-               _mesa_pixeltexgen(ctx, width, (CONST GLubyte (*)[4]) rgba,
-                                 s, t, r, q);
-               gl_texture_pixels(ctx, unit, width, s, t, r, NULL,
-                                 primary_rgba, rgba);
-            }
-         }
-
-         if (quickDraw) {
-            (*ctx->Driver.WriteRGBASpan)( ctx, width, x, y,
-                                          (CONST GLubyte (*)[4]) rgba, NULL);
-         }
-         else if (zoom) {
-            gl_write_zoomed_rgba_span( ctx, width, x, y, zspan, 
-				       (CONST GLubyte (*)[4]) rgba, desty );
-         }
-         else {
-            gl_write_rgba_span( ctx, (GLuint) width, x, y, zspan, rgba, GL_BITMAP);
-         }
-      }
+   else if (ctx->RenderMode == GL_SELECT) {
+      _mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
    }
 }
 
 
 
-/*
- * Execute glDrawPixels
- */
 void
-_mesa_DrawPixels( GLsizei width, GLsizei height,
-                  GLenum format, GLenum type, const GLvoid *pixels )
+_mesa_Bitmap( GLsizei width, GLsizei height,
+              GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
+              const GLubyte *bitmap )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDrawPixels");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->RenderMode==GL_RENDER) {
-      GLint x, y;
-      if (!pixels || !ctx->Current.RasterPosValid) {
-	 return;
-      }
-
-      if (ctx->NewState) {
-         gl_update_state(ctx);
-      }
+   if (width < 0 || height < 0) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glBitmap(width or height < 0)" );
+      return;
+   }
 
-      x = (GLint) (ctx->Current.RasterPos[0] + 0.5F);
-      y = (GLint) (ctx->Current.RasterPos[1] + 0.5F);
+   if (ctx->Current.RasterPosValid == GL_FALSE) {
+      return;    /* do nothing */
+   }
 
-      ctx->OcclusionResult = GL_TRUE;
+   if (ctx->RenderMode==GL_RENDER) {
+      if (bitmap) {
+         /* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */
+         GLint x = IFLOOR(ctx->Current.RasterPos[0] - xorig);
+         GLint y = IFLOOR(ctx->Current.RasterPos[1] - yorig);
 
-      /* see if device driver can do the drawpix */
-      if (ctx->Driver.DrawPixels
-          && (*ctx->Driver.DrawPixels)(ctx, x, y, width, height, format, type,
-                                       &ctx->Unpack, pixels)) {
-         return;
-      }
+         if (ctx->NewState) {
+            _mesa_update_state(ctx);
+         }
 
-      RENDER_START(ctx);
-      switch (format) {
-	 case GL_STENCIL_INDEX:
-	    draw_stencil_pixels( ctx, x, y, width, height, type, pixels );
-	    break;
-	 case GL_DEPTH_COMPONENT:
-	    draw_depth_pixels( ctx, x, y, width, height, type, pixels );
-	    break;
-	 case GL_COLOR_INDEX:
-            if (ctx->Visual->RGBAflag)
-               draw_rgba_pixels(ctx, x,y, width, height, format, type, pixels);
-            else
-               draw_index_pixels(ctx, x, y, width, height, type, pixels);
-	    break;
-	 case GL_RED:
-	 case GL_GREEN:
-	 case GL_BLUE:
-	 case GL_ALPHA:
-	 case GL_LUMINANCE:
-	 case GL_LUMINANCE_ALPHA:
-	 case GL_RGB:
-         case GL_BGR:
-	 case GL_RGBA:
-	 case GL_BGRA:
-	 case GL_ABGR_EXT:
-            draw_rgba_pixels(ctx, x, y, width, height, format, type, pixels);
-	    break;
-	 default:
-	    gl_error( ctx, GL_INVALID_ENUM, "glDrawPixels(format)" );
+         ctx->OcclusionResult = GL_TRUE;
+	 ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
       }
-      RENDER_FINISH(ctx);
    }
    else if (ctx->RenderMode==GL_FEEDBACK) {
       if (ctx->Current.RasterPosValid) {
-         GLfloat color[4];
-	 GLfloat texcoord[4], invq;
-	 UBYTE_RGBA_TO_FLOAT_RGBA(color, ctx->Current.ByteColor);
-         invq = 1.0F / ctx->Current.Texcoord[0][3];
-         texcoord[0] = ctx->Current.Texcoord[0][0] * invq;
-         texcoord[1] = ctx->Current.Texcoord[0][1] * invq;
-         texcoord[2] = ctx->Current.Texcoord[0][2] * invq;
-         texcoord[3] = ctx->Current.Texcoord[0][3];
-         FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
-         gl_feedback_vertex( ctx,
-                             ctx->Current.RasterPos,
-                             color, ctx->Current.Index, texcoord );
+	 FLUSH_CURRENT(ctx, 0);
+         FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
+         _mesa_feedback_vertex( ctx,
+				ctx->Current.RasterPos,
+				ctx->Current.RasterColor,
+				ctx->Current.RasterIndex, 
+				ctx->Current.RasterTexCoord );
       }
    }
    else if (ctx->RenderMode==GL_SELECT) {
-      if (ctx->Current.RasterPosValid) {
-         gl_update_hitflag( ctx, ctx->Current.RasterPos[2] );
-      }
+      /* Bitmaps don't generate selection hits.  See appendix B of 1.1 spec. */
    }
-}
 
+   /* update raster position */
+   ctx->Current.RasterPos[0] += xmove;
+   ctx->Current.RasterPos[1] += ymove;
+}
Index: xc/extras/Mesa/src/drawpix.h
diff -u xc/extras/Mesa/src/drawpix.h:1.3 xc/extras/Mesa/src/drawpix.h:1.4
--- xc/extras/Mesa/src/drawpix.h:1.3	Tue Feb 15 02:12:11 2000
+++ xc/extras/Mesa/src/drawpix.h	Fri Feb 22 14:25:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,19 +28,28 @@
 #define DRAWPIXELS_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
-extern GLboolean
-_mesa_clip_pixelrect(const GLcontext *ctx,
-                     GLint *destX, GLint *destY,
-                     GLsizei *width, GLsizei *height,
-                     GLint *skipPixels, GLint *skipRows);
-
-
 extern void
 _mesa_DrawPixels( GLsizei width, GLsizei height,
                   GLenum format, GLenum type, const GLvoid *pixels );
+
+
+extern void
+_mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
+                  GLenum format, GLenum type, GLvoid *pixels );
+
+
+extern void
+_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
+                  GLenum type );
+
+
+extern void
+_mesa_Bitmap( GLsizei width, GLsizei height,
+              GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
+              const GLubyte *bitmap );
 
 
 #endif
Index: xc/extras/Mesa/src/enable.c
diff -u xc/extras/Mesa/src/enable.c:1.7 xc/extras/Mesa/src/enable.c:1.13
--- xc/extras/Mesa/src/enable.c:1.7	Tue Mar 20 21:48:45 2001
+++ xc/extras/Mesa/src/enable.c	Mon Dec 16 11:18:26 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -32,519 +32,799 @@
 #include "enable.h"
 #include "light.h"
 #include "macros.h"
-#include "matrix.h"
 #include "mmath.h"
 #include "simple_list.h"
-#include "types.h"
-#include "vbfill.h"
-#include "xform.h"
+#include "mtypes.h"
 #include "enums.h"
+
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
+
 #endif
 
 
+static void
+client_state( GLcontext *ctx, GLenum cap, GLboolean state )
+{
+   GLuint flag;
+   GLboolean *var;
+
+   switch (cap) {
+   case GL_VERTEX_ARRAY:
+      var = &ctx->Array.Vertex.Enabled;
+      flag = _NEW_ARRAY_VERTEX;
+      break;
+   case GL_NORMAL_ARRAY:
+      var = &ctx->Array.Normal.Enabled;
+      flag = _NEW_ARRAY_NORMAL;
+      break;
+   case GL_COLOR_ARRAY:
+      var = &ctx->Array.Color.Enabled;
+      flag = _NEW_ARRAY_COLOR;
+      break;
+   case GL_INDEX_ARRAY:
+      var = &ctx->Array.Index.Enabled;
+      flag = _NEW_ARRAY_INDEX;
+      break;
+   case GL_TEXTURE_COORD_ARRAY:
+      var = &ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
+      flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
+      break;
+   case GL_EDGE_FLAG_ARRAY:
+      var = &ctx->Array.EdgeFlag.Enabled;
+      flag = _NEW_ARRAY_EDGEFLAG;
+      break;
+   case GL_FOG_COORDINATE_ARRAY_EXT:
+      var = &ctx->Array.FogCoord.Enabled;
+      flag = _NEW_ARRAY_FOGCOORD;
+      break;
+   case GL_SECONDARY_COLOR_ARRAY_EXT:
+      var = &ctx->Array.SecondaryColor.Enabled;
+      flag = _NEW_ARRAY_SECONDARYCOLOR;
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
+      return;
+   }
+
+   if (*var == state)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_ARRAY);
+   ctx->Array.NewState |= flag;
+   *var = state;
+
+   if (state)
+      ctx->Array._Enabled |= flag;
+   else
+      ctx->Array._Enabled &= ~flag;
 
+   if (ctx->Driver.Enable) {
+      (*ctx->Driver.Enable)( ctx, cap, state );
+   }
+}
+
+
+
+void
+_mesa_EnableClientState( GLenum cap )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   client_state( ctx, cap, GL_TRUE );
+}
+
+
+
+void
+_mesa_DisableClientState( GLenum cap )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   client_state( ctx, cap, GL_FALSE );
+}
+
+
 /*
  * Perform glEnable and glDisable calls.
  */
 void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 {
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, state ? "glEnable" : "glDisable" );
-
-   if (MESA_VERBOSE & VERBOSE_API) 
-      fprintf(stderr, "%s %s (newstate is %x)\n", 
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "%s %s (newstate is %x)\n",
 	      state ? "glEnable" : "glDisable",
-	      gl_lookup_enum_by_nr(cap),
+	      _mesa_lookup_enum_by_nr(cap),
 	      ctx->NewState);
 
    switch (cap) {
-      case GL_ALPHA_TEST:
-         if (ctx->Color.AlphaEnabled!=state) {
-            ctx->Color.AlphaEnabled = state;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_AUTO_NORMAL:
-	 ctx->Eval.AutoNormal = state;
-	 break;
-      case GL_BLEND:
-         if (ctx->Color.BlendEnabled!=state) {
-            ctx->Color.BlendEnabled = state;
-            /* The following needed to accomodate 1.0 RGB logic op blending */
-            if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
-               ctx->Color.ColorLogicOpEnabled = GL_TRUE;
-            }
-            else {
-               ctx->Color.ColorLogicOpEnabled = GL_FALSE;
-            }
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_CLIP_PLANE0:
-      case GL_CLIP_PLANE1:
-      case GL_CLIP_PLANE2:
-      case GL_CLIP_PLANE3:
-      case GL_CLIP_PLANE4:
-      case GL_CLIP_PLANE5:
-	 if (cap >= GL_CLIP_PLANE0 && 
-	     cap <= GL_CLIP_PLANE5 &&
-	     ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] != state) 
-	 {
-	    GLuint p = cap-GL_CLIP_PLANE0;
-
-	    ctx->Transform.ClipEnabled[p] = state;
-	    ctx->NewState |= NEW_USER_CLIP;
-
-	    if (state) {
-	       ctx->Enabled |= ENABLE_USERCLIP;
-	       ctx->Transform.AnyClip++;
-	       
-	       if (ctx->ProjectionMatrix.flags & MAT_DIRTY_ALL_OVER) {
-		  gl_matrix_analyze( &ctx->ProjectionMatrix );
-	       }
-	       
-	       gl_transform_vector( ctx->Transform.ClipUserPlane[p],
-				    ctx->Transform.EyeUserPlane[p],
-				    ctx->ProjectionMatrix.inv );
-	    } else {
-	       if (--ctx->Transform.AnyClip == 0)
-		  ctx->Enabled &= ~ENABLE_USERCLIP;	       
-	    }	    
-	 }
-	 break;
-      case GL_COLOR_MATERIAL:
-         if (ctx->Light.ColorMaterialEnabled!=state) {
-            ctx->Light.ColorMaterialEnabled = state;
-	    ctx->NewState |= NEW_LIGHTING;
-            if (state)
-               gl_update_color_material( ctx, ctx->Current.ByteColor );
-         }
-	 break;
-      case GL_CULL_FACE:
-         if (ctx->Polygon.CullFlag!=state) {
-            ctx->Polygon.CullFlag = state;
-	    ctx->TriangleCaps ^= DD_TRI_CULL;
-            ctx->NewState |= NEW_POLYGON;
-         }
-	 break;
-      case GL_DEPTH_TEST:
-         if (state && ctx->Visual->DepthBits==0) {
-            gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
-            return;
-         }
-	 if (ctx->Depth.Test!=state) {
-            ctx->Depth.Test = state;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-         break;
-      case GL_DITHER:
-         if (ctx->NoDither) {
-            /* MESA_NO_DITHER env var */
-            state = GL_FALSE;
-         }
-         if (ctx->Color.DitherFlag!=state) {
-            ctx->Color.DitherFlag = state;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_FOG:
-	 if (ctx->Fog.Enabled!=state) {
-            ctx->Fog.Enabled = state;
-	    ctx->Enabled ^= ENABLE_FOG;
-            ctx->NewState |= NEW_FOG|NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_HISTOGRAM:
-         ctx->Pixel.HistogramEnabled = state;
-         break;
-      case GL_LIGHT0:
-      case GL_LIGHT1:
-      case GL_LIGHT2:
-      case GL_LIGHT3:
-      case GL_LIGHT4:
-      case GL_LIGHT5:
-      case GL_LIGHT6:
-      case GL_LIGHT7:
-	 if (ctx->Light.Light[cap-GL_LIGHT0].Enabled != state) 
-	 {
-	    ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
-
-	    if (state) {
-	       insert_at_tail(&ctx->Light.EnabledList, 
-			      &ctx->Light.Light[cap-GL_LIGHT0]);
-	       if (ctx->Light.Enabled)
-		  ctx->Enabled |= ENABLE_LIGHT;
-	    } else {
-	       remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
-	       if (is_empty_list(&ctx->Light.EnabledList))
-		  ctx->Enabled &= ~ENABLE_LIGHT;
-	    }
+   case GL_ALPHA_TEST:
+      if (ctx->Color.AlphaEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.AlphaEnabled = state;
+      break;
+   case GL_AUTO_NORMAL:
+      if (ctx->Eval.AutoNormal == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.AutoNormal = state;
+      break;
+   case GL_BLEND:
+      if (ctx->Color.BlendEnabled == state)
+	 return;
+
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.BlendEnabled = state;
+      /* The following needed to accomodate 1.0 RGB logic op blending */
+      ctx->Color.ColorLogicOpEnabled =
+	 (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
+      break;
+   case GL_CLIP_PLANE0:
+   case GL_CLIP_PLANE1:
+   case GL_CLIP_PLANE2:
+   case GL_CLIP_PLANE3:
+   case GL_CLIP_PLANE4:
+   case GL_CLIP_PLANE5: {
+      GLuint p = cap-GL_CLIP_PLANE0;
+
+      if (ctx->Transform.ClipEnabled[p] == state)
+	 return;
 
-	    ctx->NewState |= NEW_LIGHTING;
-	 }
-         break;
-      case GL_LIGHTING:
-         if (ctx->Light.Enabled!=state) {
-            ctx->Light.Enabled = state;
-	    ctx->Enabled &= ~ENABLE_LIGHT;
-            if (state)
-	       ctx->Enabled |= ENABLE_LIGHT;
-            ctx->NewState |= NEW_LIGHTING;
-         }
-         break;
-      case GL_LINE_SMOOTH:
-	 if (ctx->Line.SmoothFlag!=state) {
-            ctx->Line.SmoothFlag = state;
-	    ctx->TriangleCaps ^= DD_LINE_SMOOTH;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_LINE_STIPPLE:
-	 if (ctx->Line.StippleFlag!=state) {
-            ctx->Line.StippleFlag = state;
-	    ctx->TriangleCaps ^= DD_LINE_STIPPLE;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_INDEX_LOGIC_OP:
-         if (ctx->Color.IndexLogicOpEnabled!=state) {
-	    ctx->Color.IndexLogicOpEnabled = state;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_COLOR_LOGIC_OP:
-         if (ctx->Color.ColorLogicOpEnabled!=state) {
-	    ctx->Color.ColorLogicOpEnabled = state;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_MAP1_COLOR_4:
-	 ctx->Eval.Map1Color4 = state;
-	 break;
-      case GL_MAP1_INDEX:
-	 ctx->Eval.Map1Index = state;
-	 break;
-      case GL_MAP1_NORMAL:
-	 ctx->Eval.Map1Normal = state;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_1:
-	 ctx->Eval.Map1TextureCoord1 = state;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_2:
-	 ctx->Eval.Map1TextureCoord2 = state;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_3:
-	 ctx->Eval.Map1TextureCoord3 = state;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_4:
-	 ctx->Eval.Map1TextureCoord4 = state;
-	 break;
-      case GL_MAP1_VERTEX_3:
-	 ctx->Eval.Map1Vertex3 = state;
-	 break;
-      case GL_MAP1_VERTEX_4:
-	 ctx->Eval.Map1Vertex4 = state;
-	 break;
-      case GL_MAP2_COLOR_4:
-	 ctx->Eval.Map2Color4 = state;
-	 break;
-      case GL_MAP2_INDEX:
-	 ctx->Eval.Map2Index = state;
-	 break;
-      case GL_MAP2_NORMAL:
-	 ctx->Eval.Map2Normal = state;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_1: 
-	 ctx->Eval.Map2TextureCoord1 = state;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_2:
-	 ctx->Eval.Map2TextureCoord2 = state;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_3:
-	 ctx->Eval.Map2TextureCoord3 = state;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_4:
-	 ctx->Eval.Map2TextureCoord4 = state;
-	 break;
-      case GL_MAP2_VERTEX_3:
-	 ctx->Eval.Map2Vertex3 = state;
-	 break;
-      case GL_MAP2_VERTEX_4:
-	 ctx->Eval.Map2Vertex4 = state;
-	 break;
-      case GL_MINMAX:
-         ctx->Pixel.MinMaxEnabled = state;
-         break;
-      case GL_NORMALIZE:
-	 if (ctx->Transform.Normalize != state) {
-	    ctx->Transform.Normalize = state;
-	    ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
-	    ctx->Enabled ^= ENABLE_NORMALIZE;
+      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+      ctx->Transform.ClipEnabled[p] = state;
+
+      if (state) {
+	 ctx->Transform._AnyClip++;
+
+	 if (ctx->ProjectionMatrix.flags & MAT_DIRTY) {
+	    _math_matrix_analyse( &ctx->ProjectionMatrix );
 	 }
-	 break;
-      case GL_POINT_SMOOTH:
-	 if (ctx->Point.SmoothFlag!=state) {
-            ctx->Point.SmoothFlag = state;
-	    ctx->TriangleCaps ^= DD_POINT_SMOOTH;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_POLYGON_SMOOTH:
-	 if (ctx->Polygon.SmoothFlag!=state) {
-            ctx->Polygon.SmoothFlag = state;
-	    ctx->TriangleCaps ^= DD_TRI_SMOOTH;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_POLYGON_STIPPLE:
-	 if (ctx->Polygon.StippleFlag!=state) {
-            ctx->Polygon.StippleFlag = state;
-	    ctx->TriangleCaps ^= DD_TRI_STIPPLE;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_POLYGON_OFFSET_POINT:
-         if (ctx->Polygon.OffsetPoint!=state) {
-            ctx->Polygon.OffsetPoint = state;
-            ctx->NewState |= NEW_POLYGON;
-         }
-         break;
-      case GL_POLYGON_OFFSET_LINE:
-         if (ctx->Polygon.OffsetLine!=state) {
-            ctx->Polygon.OffsetLine = state;
-            ctx->NewState |= NEW_POLYGON;
-         }
-         break;
-      case GL_POLYGON_OFFSET_FILL:
+
+	 /* This derived state also calculated in clip.c and
+	  * from _mesa_update_state() on changes to EyeUserPlane
+	  * and ctx->ProjectionMatrix respectively.
+	  */
+	 _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
+			      ctx->Transform.EyeUserPlane[p],
+			      ctx->ProjectionMatrix.inv );
+      }
+      else {
+	 ctx->Transform._AnyClip--;
+      }
+   }
+   break;
+   case GL_COLOR_MATERIAL:
+      if (ctx->Light.ColorMaterialEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      ctx->Light.ColorMaterialEnabled = state;
+      if (state) {
+	 FLUSH_CURRENT(ctx, 0);
+	 _mesa_update_color_material( ctx, ctx->Current.Color );
+      }
+      break;
+   case GL_CULL_FACE:
+      if (ctx->Polygon.CullFlag == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.CullFlag = state;
+      break;
+   case GL_DEPTH_TEST:
+      if (state && ctx->Visual.depthBits==0) {
+	 _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
+	 return;
+      }
+      if (ctx->Depth.Test==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_DEPTH);
+      ctx->Depth.Test = state;
+      break;
+   case GL_DITHER:
+      if (ctx->NoDither) {
+	 state = GL_FALSE; /* MESA_NO_DITHER env var */
+      }
+      if (ctx->Color.DitherFlag==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.DitherFlag = state;
+      break;
+   case GL_FOG:
+      if (ctx->Fog.Enabled==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_FOG);
+      ctx->Fog.Enabled = state;
+      break;
+   case GL_HISTOGRAM:
+      if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+	 _mesa_error(ctx, GL_INVALID_ENUM, "glEnable(GL_HISTOGRAM)");
+	 return;
+      }
+      if (ctx->Pixel.HistogramEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.HistogramEnabled = state;
+      break;
+   case GL_LIGHT0:
+   case GL_LIGHT1:
+   case GL_LIGHT2:
+   case GL_LIGHT3:
+   case GL_LIGHT4:
+   case GL_LIGHT5:
+   case GL_LIGHT6:
+   case GL_LIGHT7:
+      if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
+      if (state) {
+	 insert_at_tail(&ctx->Light.EnabledList,
+			&ctx->Light.Light[cap-GL_LIGHT0]);
+      }
+      else {
+	 remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
+      }
+      break;
+   case GL_LIGHTING:
+      if (ctx->Light.Enabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      ctx->Light.Enabled = state;
+
+      if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
+	 ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
+      else
+	 ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
+
+      if ((ctx->Light.Enabled &&
+	   ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+	  || ctx->Fog.ColorSumEnabled)
+	 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
+      else
+	 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+
+      break;
+   case GL_LINE_SMOOTH:
+      if (ctx->Line.SmoothFlag == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LINE);
+      ctx->Line.SmoothFlag = state;
+      ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
+      break;
+   case GL_LINE_STIPPLE:
+      if (ctx->Line.StippleFlag == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LINE);
+      ctx->Line.StippleFlag = state;
+      ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
+      break;
+   case GL_INDEX_LOGIC_OP:
+      if (ctx->Color.IndexLogicOpEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.IndexLogicOpEnabled = state;
+      break;
+   case GL_COLOR_LOGIC_OP:
+      if (ctx->Color.ColorLogicOpEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
+      ctx->Color.ColorLogicOpEnabled = state;
+      break;
+   case GL_MAP1_COLOR_4:
+      if (ctx->Eval.Map1Color4 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1Color4 = state;
+      break;
+   case GL_MAP1_INDEX:
+      if (ctx->Eval.Map1Index == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1Index = state;
+      break;
+   case GL_MAP1_NORMAL:
+      if (ctx->Eval.Map1Normal == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1Normal = state;
+      break;
+   case GL_MAP1_TEXTURE_COORD_1:
+      if (ctx->Eval.Map1TextureCoord1 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1TextureCoord1 = state;
+      break;
+   case GL_MAP1_TEXTURE_COORD_2:
+      if (ctx->Eval.Map1TextureCoord2 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1TextureCoord2 = state;
+      break;
+   case GL_MAP1_TEXTURE_COORD_3:
+      if (ctx->Eval.Map1TextureCoord3 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1TextureCoord3 = state;
+      break;
+   case GL_MAP1_TEXTURE_COORD_4:
+      if (ctx->Eval.Map1TextureCoord4 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1TextureCoord4 = state;
+      break;
+   case GL_MAP1_VERTEX_3:
+      if (ctx->Eval.Map1Vertex3 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1Vertex3 = state;
+      break;
+   case GL_MAP1_VERTEX_4:
+      if (ctx->Eval.Map1Vertex4 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map1Vertex4 = state;
+      break;
+   case GL_MAP2_COLOR_4:
+      if (ctx->Eval.Map2Color4 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2Color4 = state;
+      break;
+   case GL_MAP2_INDEX:
+      if (ctx->Eval.Map2Index == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2Index = state;
+      break;
+   case GL_MAP2_NORMAL:
+      if (ctx->Eval.Map2Normal == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2Normal = state;
+      break;
+   case GL_MAP2_TEXTURE_COORD_1:
+      if (ctx->Eval.Map2TextureCoord1 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2TextureCoord1 = state;
+      break;
+   case GL_MAP2_TEXTURE_COORD_2:
+      if (ctx->Eval.Map2TextureCoord2 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2TextureCoord2 = state;
+      break;
+   case GL_MAP2_TEXTURE_COORD_3:
+      if (ctx->Eval.Map2TextureCoord3 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2TextureCoord3 = state;
+      break;
+   case GL_MAP2_TEXTURE_COORD_4:
+      if (ctx->Eval.Map2TextureCoord4 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2TextureCoord4 = state;
+      break;
+   case GL_MAP2_VERTEX_3:
+      if (ctx->Eval.Map2Vertex3 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2Vertex3 = state;
+      break;
+   case GL_MAP2_VERTEX_4:
+      if (ctx->Eval.Map2Vertex4 == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_EVAL);
+      ctx->Eval.Map2Vertex4 = state;
+      break;
+   case GL_MINMAX:
+      if (ctx->Pixel.MinMaxEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.MinMaxEnabled = state;
+      break;
+   case GL_NORMALIZE:
+      if (ctx->Transform.Normalize == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+      ctx->Transform.Normalize = state;
+      break;
+   case GL_POINT_SMOOTH:
+      if (ctx->Point.SmoothFlag==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POINT);
+      ctx->Point.SmoothFlag = state;
+      ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
+      break;
+   case GL_POLYGON_SMOOTH:
+      if (ctx->Polygon.SmoothFlag==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.SmoothFlag = state;
+      ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
+      break;
+   case GL_POLYGON_STIPPLE:
+      if (ctx->Polygon.StippleFlag==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.StippleFlag = state;
+      ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
+      break;
+   case GL_POLYGON_OFFSET_POINT:
+      if (ctx->Polygon.OffsetPoint==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.OffsetPoint = state;
+      break;
+   case GL_POLYGON_OFFSET_LINE:
+      if (ctx->Polygon.OffsetLine==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.OffsetLine = state;
+      break;
+   case GL_POLYGON_OFFSET_FILL:
       /*case GL_POLYGON_OFFSET_EXT:*/
-         if (ctx->Polygon.OffsetFill!=state) {
-            ctx->Polygon.OffsetFill = state;
-            ctx->NewState |= NEW_POLYGON;
-         }
-         break;
-      case GL_RESCALE_NORMAL_EXT:
-	 if (ctx->Transform.RescaleNormals != state) {
-	    ctx->Transform.RescaleNormals = state;
-	    ctx->NewState |= NEW_NORMAL_TRANSFORM|NEW_LIGHTING;
-	    ctx->Enabled ^= ENABLE_RESCALE;
-	 }
-         break;
-      case GL_SCISSOR_TEST:
-         if (ctx->Scissor.Enabled!=state) {
-            ctx->Scissor.Enabled = state;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-	 break;
-      case GL_SHARED_TEXTURE_PALETTE_EXT:
-         ctx->Texture.SharedPalette = state;
-         break;
-      case GL_STENCIL_TEST:
-	 if (state && ctx->Visual->StencilBits==0) {
-            gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
-            return;
-	 }
-	 if (ctx->Stencil.Enabled!=state) {
-            ctx->Stencil.Enabled = state;
-            ctx->NewState |= NEW_RASTER_OPS;
-	    ctx->TriangleCaps ^= DD_STENCIL;
-         }
-	 break;
-      case GL_TEXTURE_1D:
-         if (ctx->Visual->RGBAflag) {
-	    const GLuint curr = ctx->Texture.CurrentUnit;
-            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-	    ctx->NewState |= NEW_TEXTURE_ENABLE;
-            if (state) {
-	       texUnit->Enabled |= TEXTURE0_1D;
-	    }
-            else {
-               texUnit->Enabled &= ~TEXTURE0_1D;
-            }
-         }
-         break;
-      case GL_TEXTURE_2D:
-         if (ctx->Visual->RGBAflag) {
-	    const GLuint curr = ctx->Texture.CurrentUnit;
-            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-	    ctx->NewState |= NEW_TEXTURE_ENABLE;
-            if (state) {
-	       texUnit->Enabled |= TEXTURE0_2D;
-	    }
-            else {
-               texUnit->Enabled &= ~TEXTURE0_2D;
-            }
-         }
-	 break;
-      case GL_TEXTURE_3D:
-         if (ctx->Visual->RGBAflag) {
-	    const GLuint curr = ctx->Texture.CurrentUnit;
-            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-	    ctx->NewState |= NEW_TEXTURE_ENABLE;
-            if (state) {
-	       texUnit->Enabled |= TEXTURE0_3D;
-	    }
-            else {
-               texUnit->Enabled &= ~TEXTURE0_3D;
-            }
-         }
-         break;
-      case GL_TEXTURE_GEN_Q:
-         {
-            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            if (state)
-               texUnit->TexGenEnabled |= Q_BIT;
-            else
-               texUnit->TexGenEnabled &= ~Q_BIT;
-            ctx->NewState |= NEW_TEXTURING;
-         }
-	 break;
-      case GL_TEXTURE_GEN_R:
-         {
-            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            if (state)
-               texUnit->TexGenEnabled |= R_BIT;
-            else
-               texUnit->TexGenEnabled &= ~R_BIT;
-            ctx->NewState |= NEW_TEXTURING;
-         }
-	 break;
-      case GL_TEXTURE_GEN_S:
-         {
-            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            if (state)
-               texUnit->TexGenEnabled |= S_BIT;
-            else
-               texUnit->TexGenEnabled &= ~S_BIT;
-            ctx->NewState |= NEW_TEXTURING;
-         }
-	 break;
-      case GL_TEXTURE_GEN_T:
-         {
-            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-            if (state)
-               texUnit->TexGenEnabled |= T_BIT;
-            else
-               texUnit->TexGenEnabled &= ~T_BIT;
-            ctx->NewState |= NEW_TEXTURING;
-         }
-	 break;
+      if (ctx->Polygon.OffsetFill==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.OffsetFill = state;
+      break;
+   case GL_RESCALE_NORMAL_EXT:
+      if (ctx->Transform.RescaleNormals == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+      ctx->Transform.RescaleNormals = state;
+      break;
+   case GL_SCISSOR_TEST:
+      if (ctx->Scissor.Enabled==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_SCISSOR);
+      ctx->Scissor.Enabled = state;
+      break;
+   case GL_SHARED_TEXTURE_PALETTE_EXT:
+      if (ctx->Texture.SharedPalette == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      ctx->Texture.SharedPalette = state;
+      break;
+   case GL_STENCIL_TEST:
+      if (state && ctx->Visual.stencilBits==0) {
+	 _mesa_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
+	 return;
+      }
+      if (ctx->Stencil.Enabled==state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_STENCIL);
+      ctx->Stencil.Enabled = state;
+      break;
+   case GL_TEXTURE_1D: {
+      const GLuint curr = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
+      if (state)
+	 newenabled |= TEXTURE0_1D;
+      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Enabled = newenabled;
+      break;
+   }
+   case GL_TEXTURE_2D: {
+      const GLuint curr = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
+      if (state)
+	 newenabled |= TEXTURE0_2D;
+      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Enabled = newenabled;
+      break;
+   }
+   case GL_TEXTURE_3D: {
+      const GLuint curr = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
+      if (state)
+	 newenabled |= TEXTURE0_3D;
+      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Enabled = newenabled;
+      break;
+   }
+   case GL_TEXTURE_GEN_Q: {
+      GLuint unit = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+      GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
+      if (state)
+	 newenabled |= Q_BIT;
+      if (texUnit->TexGenEnabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->TexGenEnabled = newenabled;
+      break;
+   }
+   case GL_TEXTURE_GEN_R: {
+      GLuint unit = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+      GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
+      if (state)
+	 newenabled |= R_BIT;
+      if (texUnit->TexGenEnabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->TexGenEnabled = newenabled;
+      break;
+   }
+   break;
+   case GL_TEXTURE_GEN_S: {
+      GLuint unit = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+      GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
+      if (state)
+	 newenabled |= S_BIT;
+      if (texUnit->TexGenEnabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->TexGenEnabled = newenabled;
+      break;
+   }
+   break;
+   case GL_TEXTURE_GEN_T: {
+      GLuint unit = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+      GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
+      if (state)
+	 newenabled |= T_BIT;
+      if (texUnit->TexGenEnabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->TexGenEnabled = newenabled;
+      break;
+   }
+   break;
 
-      /*
-       * CLIENT STATE!!!
-       */
-      case GL_VERTEX_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Vertex.Enabled = state;
-#else
-         ctx->Array.Vertex.Enabled = state;
-#endif
-         break;
-      case GL_NORMAL_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Normal.Enabled = state;
-#else
-         ctx->Array.Normal.Enabled = state;
-#endif
-         break;
-      case GL_COLOR_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Color.Enabled = state;
-#else
-         ctx->Array.Color.Enabled = state;
-#endif
-         break;
-      case GL_INDEX_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Index.Enabled = state;
-#else
-         ctx->Array.Index.Enabled = state;
-#endif
-         break;
-      case GL_TEXTURE_COORD_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->TexCoord[ctx->Array.ActiveTexture].Enabled = state;
-#else
-         ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
-#endif
-         break;
-      case GL_EDGE_FLAG_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->EdgeFlag.Enabled = state;
-#else
-         ctx->Array.EdgeFlag.Enabled = state;
-#endif
-         break;
+   /*
+    * CLIENT STATE!!!
+    */
+   case GL_VERTEX_ARRAY:
+   case GL_NORMAL_ARRAY:
+   case GL_COLOR_ARRAY:
+   case GL_INDEX_ARRAY:
+   case GL_TEXTURE_COORD_ARRAY:
+   case GL_EDGE_FLAG_ARRAY:
+   case GL_FOG_COORDINATE_ARRAY_EXT:
+   case GL_SECONDARY_COLOR_ARRAY_EXT:
+      client_state( ctx, cap, state );
+      return;
 
       /* GL_HP_occlusion_test */
-      case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
-            ctx->Depth.OcclusionTest = state;
-            if (state)
-               ctx->OcclusionResult = ctx->OcclusionResultSaved;
-            else
-               ctx->OcclusionResultSaved = ctx->OcclusionResult;
-            ctx->NewState |= NEW_RASTER_OPS;
-         }
-         else {
-            gl_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-            return;
-         }
-         break;
+   case GL_OCCLUSION_TEST_HP:
+      if (!ctx->Extensions.HP_occlusion_test) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
+	 return;
+      }
+      if (ctx->Depth.OcclusionTest == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_DEPTH);
+      ctx->Depth.OcclusionTest = state;
+      if (state)
+	 ctx->OcclusionResult = ctx->OcclusionResultSaved;
+      else
+	 ctx->OcclusionResultSaved = ctx->OcclusionResult;
+      break;
 
       /* GL_SGIS_pixel_texture */
-      case GL_PIXEL_TEXTURE_SGIS:
-         ctx->Pixel.PixelTextureEnabled = state;
-         break;
+   case GL_PIXEL_TEXTURE_SGIS:
+      if (!ctx->Extensions.SGIS_pixel_texture) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
+	 return;
+      }
+      if (ctx->Pixel.PixelTextureEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.PixelTextureEnabled = state;
+      break;
 
       /* GL_SGIX_pixel_texture */
-      case GL_PIXEL_TEX_GEN_SGIX:
-         ctx->Pixel.PixelTextureEnabled = state;
-         break;
+   case GL_PIXEL_TEX_GEN_SGIX:
+      if (!ctx->Extensions.SGIX_pixel_texture) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
+	 return;
+      }
+      if (ctx->Pixel.PixelTextureEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.PixelTextureEnabled = state;
+      break;
 
       /* GL_SGI_color_table */
-      case GL_COLOR_TABLE_SGI:
-         ctx->Pixel.ColorTableEnabled = state;
-         break;
-      case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-         ctx->Pixel.PostConvolutionColorTableEnabled = state;
-         break;
-      case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-         ctx->Pixel.PostColorMatrixColorTableEnabled = state;
-         break;
+   case GL_COLOR_TABLE_SGI:
+      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
+	 return;
+      }
+      if (ctx->Pixel.ColorTableEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.ColorTableEnabled = state;
+      break;
+   case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
+	 return;
+      }
+      if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.PostConvolutionColorTableEnabled = state;
+      break;
+   case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
+	 return;
+      }
+      if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.PostColorMatrixColorTableEnabled = state;
+      break;
 
       /* GL_EXT_convolution */
-      case GL_CONVOLUTION_1D:
-         ctx->Pixel.Convolution1DEnabled = state;
-         break;
-      case GL_CONVOLUTION_2D:
-         ctx->Pixel.Convolution2DEnabled = state;
-         break;
-      case GL_SEPARABLE_2D:
-         ctx->Pixel.Separable2DEnabled = state;
-         break;
+   case GL_CONVOLUTION_1D:
+      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
+	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+	 return;
+      }
+      if (ctx->Pixel.Convolution1DEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.Convolution1DEnabled = state;
+      break;
+   case GL_CONVOLUTION_2D:
+      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
+	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+	 return;
+      }
+      if (ctx->Pixel.Convolution2DEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.Convolution2DEnabled = state;
+      break;
+   case GL_SEPARABLE_2D:
+      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
+	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+	 return;
+      }
+      if (ctx->Pixel.Separable2DEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.Separable2DEnabled = state;
+      break;
 
       /* GL_ARB_texture_cube_map */
-      case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap) {
-            if (ctx->Visual->RGBAflag) {
-               const GLuint curr = ctx->Texture.CurrentUnit;
-               struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-               ctx->NewState |= NEW_TEXTURE_ENABLE;
-               if (state) {
-                  texUnit->Enabled |= TEXTURE0_CUBE;
-               }
-               else {
-                  texUnit->Enabled &= ~TEXTURE0_CUBE;
-               }
-            }
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+   case GL_TEXTURE_CUBE_MAP_ARB: {
+      const GLuint curr = ctx->Texture.CurrentUnit;
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
+      if (state)
+	 newenabled |= TEXTURE0_CUBE;
+      if (!ctx->Extensions.ARB_texture_cube_map) {
+	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+	 return;
+      }
+      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Enabled = newenabled;
+      break;
+   }
+      /* GL_EXT_secondary_color */
+   case GL_COLOR_SUM_EXT:
+      if (!ctx->Extensions.EXT_secondary_color) {
+	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+	 return;
+      }
+      if (ctx->Fog.ColorSumEnabled == state)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_FOG);
+      ctx->Fog.ColorSumEnabled = state;
+
+      if ((ctx->Light.Enabled &&
+	   ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+	  || ctx->Fog.ColorSumEnabled)
+	 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
+      else
+	 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+
+      break;
+
+      /* GL_ARB_multisample */
+   case GL_MULTISAMPLE_ARB:
+      if (!ctx->Extensions.ARB_multisample) {
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
+      }
+      if (ctx->Multisample.Enabled == state)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+      ctx->Multisample.Enabled = state;
+      break;
+   case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+      if (!ctx->Extensions.ARB_multisample) {
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
+      }
+      if (ctx->Multisample.SampleAlphaToCoverage == state)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+      ctx->Multisample.SampleAlphaToCoverage = state;
+      break;
+   case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+      if (!ctx->Extensions.ARB_multisample) {
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
+      }
+      if (ctx->Multisample.SampleAlphaToOne == state)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+      ctx->Multisample.SampleAlphaToOne = state;
+      break;
+   case GL_SAMPLE_COVERAGE_ARB:
+      if (!ctx->Extensions.ARB_multisample) {
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
+      }
+      if (ctx->Multisample.SampleCoverage == state)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+      ctx->Multisample.SampleCoverage = state;
+      break;
+   case GL_SAMPLE_COVERAGE_INVERT_ARB:
+      if (!ctx->Extensions.ARB_multisample) {
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
+      }
+      if (ctx->Multisample.SampleCoverageInvert == state)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+      ctx->Multisample.SampleCoverageInvert = state;
+      break;
+
+   /* GL_IBM_rasterpos_clip */
+   case GL_RASTER_POSITION_UNCLIPPED_IBM:
+      if (!ctx->Extensions.IBM_rasterpos_clip) {
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
+      }
+      if (ctx->Transform.RasterPositionUnclipped == state)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+      ctx->Transform.RasterPositionUnclipped = state;
+      break;
+
+   /* GL_NV_texture_rectangle */
+   case GL_TEXTURE_RECTANGLE_NV:
+      {
+         const GLuint curr = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_RECT;
+         if (!ctx->Extensions.NV_texture_rectangle) {
+            _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
             return;
          }
-	 break;
+         if (state)
+            newenabled |= TEXTURE0_RECT;
+         if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->Enabled = newenabled;
+      }
+      break;
 
       default:
-         gl_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
          return;
    }
 
@@ -560,6 +840,8 @@
 _mesa_Enable( GLenum cap )
 {
    GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    _mesa_set_enable( ctx, cap, GL_TRUE );
 }
 
@@ -569,6 +851,8 @@
 _mesa_Disable( GLenum cap )
 {
    GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    _mesa_set_enable( ctx, cap, GL_FALSE );
 }
 
@@ -603,7 +887,13 @@
       case GL_FOG:
 	 return ctx->Fog.Enabled;
       case GL_HISTOGRAM:
-         return ctx->Pixel.HistogramEnabled;
+         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
+            return ctx->Pixel.HistogramEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
       case GL_LIGHTING:
          return ctx->Light.Enabled;
       case GL_LIGHT0:
@@ -647,7 +937,7 @@
 	 return ctx->Eval.Map2Index;
       case GL_MAP2_NORMAL:
 	 return ctx->Eval.Map2Normal;
-      case GL_MAP2_TEXTURE_COORD_1: 
+      case GL_MAP2_TEXTURE_COORD_1:
 	 return ctx->Eval.Map2TextureCoord1;
       case GL_MAP2_TEXTURE_COORD_2:
 	 return ctx->Eval.Map2TextureCoord2;
@@ -724,49 +1014,25 @@
        * CLIENT STATE!!!
        */
       case GL_VERTEX_ARRAY:
-#ifdef VAO
-         return ctx->Array.Current->Vertex.Enabled;
-#else
          return ctx->Array.Vertex.Enabled;
-#endif
       case GL_NORMAL_ARRAY:
-#ifdef VAO
-         return ctx->Array.Current->Normal.Enabled;
-#else
          return ctx->Array.Normal.Enabled;
-#endif
       case GL_COLOR_ARRAY:
-#ifdef VAO
-         return ctx->Array.Current->Color.Enabled;
-#else
          return ctx->Array.Color.Enabled;
-#endif
       case GL_INDEX_ARRAY:
-#ifdef VAO
-         return ctx->Array.Current->Index.Enabled;
-#else
          return ctx->Array.Index.Enabled;
-#endif
       case GL_TEXTURE_COORD_ARRAY:
-#ifdef VAO
-         return ctx->Array.Current->TexCoord[ctx->Array.ActiveTexture].Enabled;
-#else
          return ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
-#endif
       case GL_EDGE_FLAG_ARRAY:
-#ifdef VAO
-         return ctx->Array.Current->EdgeFlag.Enabled;
-#else
          return ctx->Array.EdgeFlag.Enabled;
-#endif
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             return ctx->Depth.OcclusionTest;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
             return GL_FALSE;
          }
 
@@ -796,97 +1062,81 @@
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap) {
+         if (ctx->Extensions.ARB_texture_cube_map) {
             const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE;
          }
          else {
-            gl_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
             return GL_FALSE;
          }
 
-      default:
-	 gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
-	 return GL_FALSE;
-   }
-}
-
-
+      /* GL_ARB_multisample */
+      case GL_MULTISAMPLE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            return ctx->Multisample.Enabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            return ctx->Multisample.SampleAlphaToCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            return ctx->Multisample.SampleAlphaToOne;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
+      case GL_SAMPLE_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            return ctx->Multisample.SampleCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            return ctx->Multisample.SampleCoverageInvert;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
 
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         if (ctx->Extensions.IBM_rasterpos_clip) {
+            return ctx->Transform.RasterPositionUnclipped;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
 
-static void
-client_state( GLcontext *ctx, GLenum cap, GLboolean state )
-{
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, 
-				       (state 
-					? "glEnableClientState" 
-					: "glDisableClientState") );
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         if (ctx->Extensions.NV_texture_rectangle) {
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            return (texUnit->Enabled & TEXTURE0_RECT) ? GL_TRUE : GL_FALSE;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
+            return GL_FALSE;
+         }
 
-   switch (cap) {
-      case GL_VERTEX_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Vertex.Enabled = state;
-#else
-         ctx->Array.Vertex.Enabled = state;
-#endif
-         break;
-      case GL_NORMAL_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Normal.Enabled = state;
-#else
-         ctx->Array.Normal.Enabled = state;
-#endif
-         break;
-      case GL_COLOR_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Color.Enabled = state;
-#else
-         ctx->Array.Color.Enabled = state;
-#endif
-         break;
-      case GL_INDEX_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->Index.Enabled = state;
-#else
-         ctx->Array.Index.Enabled = state;
-#endif
-         break;
-      case GL_TEXTURE_COORD_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->TexCoord[ctx->Array.ActiveTexture].Enabled = state;
-#else
-         ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled = state;
-#endif
-         break;
-      case GL_EDGE_FLAG_ARRAY:
-#ifdef VAO
-         ctx->Array.Current->EdgeFlag.Enabled = state;
-#else
-         ctx->Array.EdgeFlag.Enabled = state;
-#endif
-         break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
+	 return GL_FALSE;
    }
-
-   ctx->NewState |= NEW_CLIENT_STATE;
-}
-
-
-
-void
-_mesa_EnableClientState( GLenum cap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   client_state( ctx, cap, GL_TRUE );
-}
-
-
-
-void
-_mesa_DisableClientState( GLenum cap )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   client_state( ctx, cap, GL_FALSE );
 }
-
Index: xc/extras/Mesa/src/enable.h
diff -u xc/extras/Mesa/src/enable.h:1.3 xc/extras/Mesa/src/enable.h:1.4
--- xc/extras/Mesa/src/enable.h:1.3	Tue Feb 15 02:12:12 2000
+++ xc/extras/Mesa/src/enable.h	Fri Feb 22 14:25:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define ENABLE_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
Index: xc/extras/Mesa/src/enums.c
diff -u xc/extras/Mesa/src/enums.c:1.9 xc/extras/Mesa/src/enums.c:1.10
--- xc/extras/Mesa/src/enums.c:1.9	Fri Aug 17 14:40:04 2001
+++ xc/extras/Mesa/src/enums.c	Fri Feb 22 14:25:28 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -21,6 +21,9 @@
  * BRIAN PAUL 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.
+ *
+ * Author:
+ *    Keith Whitwell <keithw@valinux.com>
  */
 
 
@@ -829,10 +832,19 @@
    { "GL_PRIMARY_COLOR_EXT", 0x8577 },
    { "GL_PREVIOUS_EXT", 0x8578 },
 
+   /* GL_ARB_texture_env_combine */
+   { "GL_SUBTRACT_ARB", 0x84E7 },
+
    /* GL_EXT_texture_env_dot3 */
    { "GL_DOT3_RGB_EXT", 0x8740 },
    { "GL_DOT3_RGBA_EXT", 0x8741 },
 
+   /* GL_ARB_texture_env_dot3 */
+   { "GL_DOT3_RGB_EXT", 0x86ae },
+   { "GL_DOT3_RGBA_EXT", 0x86af },
+
+   /* GL_ARB_texture_border_clamp */
+   { "GL_CLAMP_TO_BORDER_ARB", 0x812D },
 };
 
 #define Elements(x) sizeof(x)/sizeof(*x)
@@ -876,7 +888,7 @@
 
 
 
-int gl_lookup_enum_by_name( const char *symbol )
+int _mesa_lookup_enum_by_name( const char *symbol )
 {
    enum_elt tmp;
    enum_elt *e;
@@ -895,7 +907,9 @@
 }
 
 
-const char *gl_lookup_enum_by_nr( int nr )
+static char token_tmp[20];
+
+const char *_mesa_lookup_enum_by_nr( int nr )
 {
    enum_elt tmp, *e, **f;
 
@@ -907,25 +921,13 @@
 
    f = (enum_elt **)bsearch( &e, index1, Elements(all_enums),
 			     sizeof(*index1), (cfunc) compar_nr );
-
-   return f ? (*f)->c : "(unknown)";
-}
-
 
-#if 0
-int main()
-{
-   int i;
-   static const char *test[] = {
-      "GL_POLYGON",
-      "GL_TRUE",
-      "GL_BANANA",
-      "GL_REFLECTION_MAP_NV",
-   };
-
-   for (i = 0 ; i < Elements(test) ; i++) {
-      int d = gl_lookup_enum_by_name( test[i] );
-      printf("%s --> %d --> %s\n", test[i], d, gl_lookup_enum_by_nr( d ));
+   if (f) {
+      return (*f)->c;
    }
+   else {
+      /* this isn't re-entrant safe, no big deal here */
+      sprintf(token_tmp, "0x%x", nr);
+      return token_tmp;
+   }
 }
-#endif
Index: xc/extras/Mesa/src/enums.h
diff -u xc/extras/Mesa/src/enums.h:1.3 xc/extras/Mesa/src/enums.h:1.4
--- xc/extras/Mesa/src/enums.h:1.3	Tue Feb 15 02:12:12 2000
+++ xc/extras/Mesa/src/enums.h	Fri Feb 22 14:25:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -27,7 +27,7 @@
 #ifndef _ENUMS_H_
 #define _ENUMS_H_
 
-extern const char *gl_lookup_enum_by_nr( int nr );
-extern int gl_lookup_enum_by_name( const char *symbol );
+extern const char *_mesa_lookup_enum_by_nr( int nr );
+extern int _mesa_lookup_enum_by_name( const char *symbol );
 
 #endif
Index: xc/extras/Mesa/src/eval.c
diff -u xc/extras/Mesa/src/eval.c:1.6 xc/extras/Mesa/src/eval.c:1.7
--- xc/extras/Mesa/src/eval.c:1.6	Mon Nov 13 18:30:44 2000
+++ xc/extras/Mesa/src/eval.c	Fri Feb 22 14:25:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -41,484 +41,16 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "eval.h"
 #include "macros.h"
 #include "mem.h"
 #include "mmath.h"
-#include "types.h"
-#include "vbcull.h"
-#include "vbfill.h"
-#include "vbxform.h"
+#include "mtypes.h"
 #endif
 
 
-static GLfloat inv_tab[MAX_EVAL_ORDER];
-
-/*
- * Do one-time initialization for evaluators.
- */
-void gl_init_eval( void )
-{
-  static int init_flag = 0;
-  GLuint i;
-
-  /* Compute a table of nCr (combination) values used by the
-   * Bernstein polynomial generator.
-   */
-
-  /* KW: precompute 1/x for useful x.
-   */
-  if (init_flag==0) 
-  { 
-     for (i = 1 ; i < MAX_EVAL_ORDER ; i++)
-	inv_tab[i] = 1.0 / i;
-  }
-
-  init_flag = 1;
-}
-
-
-
-/*
- * Horner scheme for Bezier curves
- * 
- * Bezier curves can be computed via a Horner scheme.
- * Horner is numerically less stable than the de Casteljau
- * algorithm, but it is faster. For curves of degree n 
- * the complexity of Horner is O(n) and de Casteljau is O(n^2).
- * Since stability is not important for displaying curve 
- * points I decided to use the Horner scheme.
- *
- * A cubic Bezier curve with control points b0, b1, b2, b3 can be 
- * written as
- *
- *        (([3]        [3]     )     [3]       )     [3]
- * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
- *
- *                                           [n]
- * where s=1-t and the binomial coefficients [i]. These can 
- * be computed iteratively using the identity:
- *
- * [n]               [n  ]             [n]
- * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
- */
-
-
-static void
-horner_bezier_curve(const GLfloat *cp, GLfloat *out, GLfloat t,
-                    GLuint dim, GLuint order)
-{
-  GLfloat s, powert, bincoeff;
-  GLuint i, k;
-
-  if(order >= 2)
-  { 
-    bincoeff = order-1;
-    s = 1.0-t;
-
-    for(k=0; k<dim; k++)
-      out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
-
-    for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
-    {
-      bincoeff *= order-i;
-      bincoeff *= inv_tab[i];
-
-      for(k=0; k<dim; k++)
-        out[k] = s*out[k] + bincoeff*powert*cp[k];
-    }
-  }
-  else /* order=1 -> constant curve */
-  { 
-    for(k=0; k<dim; k++)
-      out[k] = cp[k];
-  } 
-}
-
-/*
- * Tensor product Bezier surfaces
- *
- * Again the Horner scheme is used to compute a point on a 
- * TP Bezier surface. First a control polygon for a curve
- * on the surface in one parameter direction is computed,
- * then the point on the curve for the other parameter 
- * direction is evaluated.
- *
- * To store the curve control polygon additional storage
- * for max(uorder,vorder) points is needed in the 
- * control net cn.
- */
-
-static void
-horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
-                   GLuint dim, GLuint uorder, GLuint vorder)
-{
-  GLfloat *cp = cn + uorder*vorder*dim;
-  GLuint i, uinc = vorder*dim;
-
-  if(vorder > uorder)
-  {
-    if(uorder >= 2)
-    { 
-      GLfloat s, poweru, bincoeff;
-      GLuint j, k;
-
-      /* Compute the control polygon for the surface-curve in u-direction */
-      for(j=0; j<vorder; j++)
-      {
-        GLfloat *ucp = &cn[j*dim];
-
-        /* Each control point is the point for parameter u on a */ 
-        /* curve defined by the control polygons in u-direction */
-	bincoeff = uorder-1;
-	s = 1.0-u;
-
-	for(k=0; k<dim; k++)
-	  cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
-
-	for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder; 
-            i++, poweru*=u, ucp +=uinc)
-	{
-	  bincoeff *= uorder-i;
-          bincoeff *= inv_tab[i];
-
-	  for(k=0; k<dim; k++)
-	    cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
-	}
-      }
-        
-      /* Evaluate curve point in v */
-      horner_bezier_curve(cp, out, v, dim, vorder);
-    }
-    else /* uorder=1 -> cn defines a curve in v */
-      horner_bezier_curve(cn, out, v, dim, vorder);
-  }
-  else /* vorder <= uorder */
-  {
-    if(vorder > 1)
-    {
-      GLuint i;
-
-      /* Compute the control polygon for the surface-curve in u-direction */
-      for(i=0; i<uorder; i++, cn += uinc)
-      {
-	/* For constant i all cn[i][j] (j=0..vorder) are located */
-	/* on consecutive memory locations, so we can use        */
-	/* horner_bezier_curve to compute the control points     */
-
-	horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
-      }
-
-      /* Evaluate curve point in u */
-      horner_bezier_curve(cp, out, u, dim, uorder);
-    }
-    else  /* vorder=1 -> cn defines a curve in u */
-      horner_bezier_curve(cn, out, u, dim, uorder);
-  }
-}
-
-/*
- * The direct de Casteljau algorithm is used when a point on the
- * surface and the tangent directions spanning the tangent plane
- * should be computed (this is needed to compute normals to the
- * surface). In this case the de Casteljau algorithm approach is
- * nicer because a point and the partial derivatives can be computed 
- * at the same time. To get the correct tangent length du and dv
- * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1. 
- * Since only the directions are needed, this scaling step is omitted.
- *
- * De Casteljau needs additional storage for uorder*vorder
- * values in the control net cn.
- */
-
-static void
-de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
-                  GLfloat u, GLfloat v, GLuint dim, 
-                  GLuint uorder, GLuint vorder)
-{
-  GLfloat *dcn = cn + uorder*vorder*dim;
-  GLfloat us = 1.0-u, vs = 1.0-v;
-  GLuint h, i, j, k;
-  GLuint minorder = uorder < vorder ? uorder : vorder;
-  GLuint uinc = vorder*dim;
-  GLuint dcuinc = vorder;
- 
-  /* Each component is evaluated separately to save buffer space  */
-  /* This does not drasticaly decrease the performance of the     */
-  /* algorithm. If additional storage for (uorder-1)*(vorder-1)   */
-  /* points would be available, the components could be accessed  */
-  /* in the innermost loop which could lead to less cache misses. */
-
-#define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)] 
-#define DCN(I, J) dcn[(I)*dcuinc+(J)]
-  if(minorder < 3)
-  {
-    if(uorder==vorder)
-    {
-      for(k=0; k<dim; k++)
-      {
-	/* Derivative direction in u */
-	du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
-	         v*(CN(1,1,k) - CN(0,1,k));
-
-	/* Derivative direction in v */
-	dv[k] = us*(CN(0,1,k) - CN(0,0,k)) + 
-	         u*(CN(1,1,k) - CN(1,0,k));
-
-	/* bilinear de Casteljau step */
-        out[k] =  us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
-	           u*(vs*CN(1,0,k) + v*CN(1,1,k));
-      }
-    }
-    else if(minorder == uorder)
-    {
-      for(k=0; k<dim; k++)
-      {
-	/* bilinear de Casteljau step */
-	DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
-	DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
-
-	for(j=0; j<vorder-1; j++)
-	{
-	  /* for the derivative in u */
-	  DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
-	  DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
-
-	  /* for the `point' */
-	  DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
-	  DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
-	}
-        
-	/* remaining linear de Casteljau steps until the second last step */
-	for(h=minorder; h<vorder-1; h++)
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    /* for the derivative in u */
-	    DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
-
-	    /* for the `point' */
-	    DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
-	  }
-
-	/* derivative direction in v */
-	dv[k] = DCN(0,1) - DCN(0,0);
-
-	/* derivative direction in u */
-	du[k] =   vs*DCN(1,0) + v*DCN(1,1);
-
-	/* last linear de Casteljau step */
-	out[k] =  vs*DCN(0,0) + v*DCN(0,1);
-      }
-    }
-    else /* minorder == vorder */
-    {
-      for(k=0; k<dim; k++)
-      {
-	/* bilinear de Casteljau step */
-	DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
-	DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
-	for(i=0; i<uorder-1; i++)
-	{
-	  /* for the derivative in v */
-	  DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
-	  DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
-
-	  /* for the `point' */
-	  DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
-	  DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
-	}
-        
-	/* remaining linear de Casteljau steps until the second last step */
-	for(h=minorder; h<uorder-1; h++)
-	  for(i=0; i<uorder-h; i++)
-	  {
-	    /* for the derivative in v */
-	    DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
-
-	    /* for the `point' */
-	    DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  }
-
-	/* derivative direction in u */
-	du[k] = DCN(1,0) - DCN(0,0);
-
-	/* derivative direction in v */
-	dv[k] =   us*DCN(0,1) + u*DCN(1,1);
-
-	/* last linear de Casteljau step */
-	out[k] =  us*DCN(0,0) + u*DCN(1,0);
-      }
-    }
-  }
-  else if(uorder == vorder)
-  {
-    for(k=0; k<dim; k++)
-    {
-      /* first bilinear de Casteljau step */
-      for(i=0; i<uorder-1; i++)
-      {
-	DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
-	for(j=0; j<vorder-1; j++)
-	{
-	  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
-	  DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
-	}
-      }
-
-      /* remaining bilinear de Casteljau steps until the second last step */
-      for(h=2; h<minorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
-	    DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
-	  }
-	}
-
-      /* derivative direction in u */
-      du[k] = vs*(DCN(1,0) - DCN(0,0)) +
-	       v*(DCN(1,1) - DCN(0,1));
-
-      /* derivative direction in v */
-      dv[k] = us*(DCN(0,1) - DCN(0,0)) + 
-	       u*(DCN(1,1) - DCN(1,0));
-
-      /* last bilinear de Casteljau step */
-      out[k] =  us*(vs*DCN(0,0) + v*DCN(0,1)) +
-	         u*(vs*DCN(1,0) + v*DCN(1,1));
-    }
-  }
-  else if(minorder == uorder)
-  {
-    for(k=0; k<dim; k++)
-    {
-      /* first bilinear de Casteljau step */
-      for(i=0; i<uorder-1; i++)
-      {
-	DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
-	for(j=0; j<vorder-1; j++)
-	{
-	  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
-	  DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
-	}
-      }
-
-      /* remaining bilinear de Casteljau steps until the second last step */
-      for(h=2; h<minorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
-	    DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
-	  }
-	}
-
-      /* last bilinear de Casteljau step */
-      DCN(2,0) =    DCN(1,0) -   DCN(0,0);
-      DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
-      for(j=0; j<vorder-1; j++)
-      {
-	/* for the derivative in u */
-	DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
-	DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
-	
-	/* for the `point' */
-	DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
-	DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
-      }
-        
-      /* remaining linear de Casteljau steps until the second last step */
-      for(h=minorder; h<vorder-1; h++)
-	for(j=0; j<vorder-h; j++)
-	{
-	  /* for the derivative in u */
-	  DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
-	  
-	  /* for the `point' */
-	  DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
-	}
-      
-      /* derivative direction in v */
-      dv[k] = DCN(0,1) - DCN(0,0);
-      
-      /* derivative direction in u */
-      du[k] =   vs*DCN(2,0) + v*DCN(2,1);
-      
-      /* last linear de Casteljau step */
-      out[k] =  vs*DCN(0,0) + v*DCN(0,1);
-    }
-  }
-  else /* minorder == vorder */
-  {
-    for(k=0; k<dim; k++)
-    {
-      /* first bilinear de Casteljau step */
-      for(i=0; i<uorder-1; i++)
-      {
-	DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
-	for(j=0; j<vorder-1; j++)
-	{
-	  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
-	  DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
-	}
-      }
-
-      /* remaining bilinear de Casteljau steps until the second last step */
-      for(h=2; h<minorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
-	    DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
-	  }
-	}
-
-      /* last bilinear de Casteljau step */
-      DCN(0,2) =    DCN(0,1) -   DCN(0,0);
-      DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
-      for(i=0; i<uorder-1; i++)
-      {
-	/* for the derivative in v */
-	DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
-	DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
-	
-	/* for the `point' */
-	DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
-	DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
-      }
-      
-      /* remaining linear de Casteljau steps until the second last step */
-      for(h=minorder; h<uorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  /* for the derivative in v */
-	  DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
-	  
-	  /* for the `point' */
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	}
-      
-      /* derivative direction in u */
-      du[k] = DCN(1,0) - DCN(0,0);
-      
-      /* derivative direction in v */
-      dv[k] =   us*DCN(0,2) + u*DCN(1,2);
-      
-      /* last linear de Casteljau step */
-      out[k] =  us*DCN(0,0) + u*DCN(1,0);
-    }
-  }
-#undef DCN
-#undef CN
-}
-
 /*
  * Return the number of components per control point for any type of
  * evaluator.  Return 0 if bad target.
@@ -556,13 +88,13 @@
 
 
 /*
- * Copy 1-parametric evaluator control points from user-specified 
+ * Copy 1-parametric evaluator control points from user-specified
  * memory space to a buffer of contiguous control points.
  * Input:  see glMap1f for details
  * Return:  pointer to buffer of contiguous control points or NULL if out
  *          of memory.
  */
-GLfloat *gl_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
+GLfloat *_mesa_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
                                const GLfloat *points )
 {
    GLfloat *buffer, *p;
@@ -574,7 +106,7 @@
 
    buffer = (GLfloat *) MALLOC(uorder * size * sizeof(GLfloat));
 
-   if(buffer) 
+   if(buffer)
       for(i=0, p=buffer; i<uorder; i++, points+=ustride)
 	for(k=0; k<size; k++)
 	  *p++ = points[k];
@@ -587,7 +119,7 @@
 /*
  * Same as above but convert doubles to floats.
  */
-GLfloat *gl_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
+GLfloat *_mesa_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
                                const GLdouble *points )
 {
    GLfloat *buffer, *p;
@@ -610,7 +142,7 @@
 
 
 /*
- * Copy 2-parametric evaluator control points from user-specified 
+ * Copy 2-parametric evaluator control points from user-specified
  * memory space to a buffer of contiguous control points.
  * Additional memory is allocated to be used by the horner and
  * de Casteljau evaluation schemes.
@@ -619,7 +151,7 @@
  * Return:  pointer to buffer of contiguous control points or NULL if out
  *          of memory.
  */
-GLfloat *gl_copy_map_points2f( GLenum target,
+GLfloat *_mesa_copy_map_points2f( GLenum target,
                                GLint ustride, GLint uorder,
                                GLint vstride, GLint vorder,
                                const GLfloat *points )
@@ -648,7 +180,7 @@
    /* compute the increment value for the u-loop */
    uinc = ustride - vorder*vstride;
 
-   if (buffer) 
+   if (buffer)
       for (i=0, p=buffer; i<uorder; i++, points += uinc)
 	 for (j=0; j<vorder; j++, points += vstride)
 	    for (k=0; k<size; k++)
@@ -662,7 +194,7 @@
 /*
  * Same as above but convert doubles to floats.
  */
-GLfloat *gl_copy_map_points2d(GLenum target,
+GLfloat *_mesa_copy_map_points2d(GLenum target,
                               GLint ustride, GLint uorder,
                               GLint vstride, GLint vorder,
                               const GLdouble *points )
@@ -691,7 +223,7 @@
    /* compute the increment value for the u-loop */
    uinc = ustride - vorder*vstride;
 
-   if (buffer) 
+   if (buffer)
       for (i=0, p=buffer; i<uorder; i++, points += uinc)
 	 for (j=0; j<vorder; j++, points += vstride)
 	    for (k=0; k<size; k++)
@@ -701,106 +233,8 @@
 }
 
 
-#if 00
-/*
- * This function is called by the display list deallocator function to
- * specify that a given set of control points are no longer needed.
- */
-void gl_free_control_points( GLcontext* ctx, GLenum target, GLfloat *data )
-{
-   struct gl_1d_map *map1 = NULL;
-   struct gl_2d_map *map2 = NULL;
 
-   switch (target) {
-      case GL_MAP1_VERTEX_3:
-         map1 = &ctx->EvalMap.Map1Vertex3;
-         break;
-      case GL_MAP1_VERTEX_4:
-         map1 = &ctx->EvalMap.Map1Vertex4;
-	 break;
-      case GL_MAP1_INDEX:
-         map1 = &ctx->EvalMap.Map1Index;
-         break;
-      case GL_MAP1_COLOR_4:
-         map1 = &ctx->EvalMap.Map1Color4;
-         break;
-      case GL_MAP1_NORMAL:
-         map1 = &ctx->EvalMap.Map1Normal;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_1:
-         map1 = &ctx->EvalMap.Map1Texture1;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_2:
-         map1 = &ctx->EvalMap.Map1Texture2;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_3:
-         map1 = &ctx->EvalMap.Map1Texture3;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_4:
-         map1 = &ctx->EvalMap.Map1Texture4;
-	 break;
-      case GL_MAP2_VERTEX_3:
-         map2 = &ctx->EvalMap.Map2Vertex3;
-	 break;
-      case GL_MAP2_VERTEX_4:
-         map2 = &ctx->EvalMap.Map2Vertex4;
-	 break;
-      case GL_MAP2_INDEX:
-         map2 = &ctx->EvalMap.Map2Index;
-	 break;
-      case GL_MAP2_COLOR_4:
-         map2 = &ctx->EvalMap.Map2Color4;
-         break;
-      case GL_MAP2_NORMAL:
-         map2 = &ctx->EvalMap.Map2Normal;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_1:
-         map2 = &ctx->EvalMap.Map2Texture1;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_2:
-         map2 = &ctx->EvalMap.Map2Texture2;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_3:
-         map2 = &ctx->EvalMap.Map2Texture3;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_4:
-         map2 = &ctx->EvalMap.Map2Texture4;
-	 break;
-      default:
-	 gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
-         return;
-   }
 
-   if (map1) {
-      if (data==map1->Points) {
-         /* The control points in the display list are currently */
-         /* being used so we can mark them as discard-able. */
-         map1->Retain = GL_FALSE;
-      }
-      else {
-         /* The control points in the display list are not currently */
-         /* being used. */
-         FREE( data );
-      }
-   }
-   if (map2) {
-      if (data==map2->Points) {
-         /* The control points in the display list are currently */
-         /* being used so we can mark them as discard-able. */
-         map2->Retain = GL_FALSE;
-      }
-      else {
-         /* The control points in the display list are not currently */
-         /* being used. */
-         FREE( data );
-      }
-   }
-
-}
-#endif
-
-
-
 /**********************************************************************/
 /***                      API entry points                          ***/
 /**********************************************************************/
@@ -816,125 +250,88 @@
    GET_CURRENT_CONTEXT(ctx);
    GLint k;
    GLfloat *pnts;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMap1");
+   struct gl_1d_map *map = 0;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    assert(type == GL_FLOAT || type == GL_DOUBLE);
 
    if (u1 == u2) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
       return;
    }
    if (uorder < 1 || uorder > MAX_EVAL_ORDER) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
       return;
    }
    if (!points) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap1(points)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(points)" );
       return;
    }
 
    k = _mesa_evaluator_components( target );
    if (k == 0) {
-      gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
    }
 
    if (ustride < k) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
       return;
    }
 
-   /* make copy of the control points */
-   if (type == GL_FLOAT)
-      pnts = gl_copy_map_points1f(target, ustride, uorder, (GLfloat*) points);
-   else
-      pnts = gl_copy_map_points1d(target, ustride, uorder, (GLdouble*) points);
+   if (ctx->Texture.CurrentUnit != 0) {
+      /* See OpenGL 1.2.1 spec, section F.2.13 */
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glMap2(ACTIVE_TEXTURE != 0)" );
+      return;
+   }
 
    switch (target) {
       case GL_MAP1_VERTEX_3:
-         ctx->EvalMap.Map1Vertex3.Order = uorder;
-	 ctx->EvalMap.Map1Vertex3.u1 = u1;
-	 ctx->EvalMap.Map1Vertex3.u2 = u2;
-	 ctx->EvalMap.Map1Vertex3.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Vertex3.Points)
-	    FREE( ctx->EvalMap.Map1Vertex3.Points );
-	 ctx->EvalMap.Map1Vertex3.Points = pnts;
+         map = &ctx->EvalMap.Map1Vertex3;
 	 break;
       case GL_MAP1_VERTEX_4:
-         ctx->EvalMap.Map1Vertex4.Order = uorder;
-	 ctx->EvalMap.Map1Vertex4.u1 = u1;
-	 ctx->EvalMap.Map1Vertex4.u2 = u2;
-	 ctx->EvalMap.Map1Vertex4.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Vertex4.Points)
-	    FREE( ctx->EvalMap.Map1Vertex4.Points );
-	 ctx->EvalMap.Map1Vertex4.Points = pnts;
+         map = &ctx->EvalMap.Map1Vertex4;
 	 break;
       case GL_MAP1_INDEX:
-         ctx->EvalMap.Map1Index.Order = uorder;
-	 ctx->EvalMap.Map1Index.u1 = u1;
-	 ctx->EvalMap.Map1Index.u2 = u2;
-	 ctx->EvalMap.Map1Index.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Index.Points)
-	    FREE( ctx->EvalMap.Map1Index.Points );
-	 ctx->EvalMap.Map1Index.Points = pnts;
+         map = &ctx->EvalMap.Map1Index;
 	 break;
       case GL_MAP1_COLOR_4:
-         ctx->EvalMap.Map1Color4.Order = uorder;
-	 ctx->EvalMap.Map1Color4.u1 = u1;
-	 ctx->EvalMap.Map1Color4.u2 = u2;
-	 ctx->EvalMap.Map1Color4.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Color4.Points)
-	    FREE( ctx->EvalMap.Map1Color4.Points );
-	 ctx->EvalMap.Map1Color4.Points = pnts;
+         map = &ctx->EvalMap.Map1Color4;
 	 break;
       case GL_MAP1_NORMAL:
-         ctx->EvalMap.Map1Normal.Order = uorder;
-	 ctx->EvalMap.Map1Normal.u1 = u1;
-	 ctx->EvalMap.Map1Normal.u2 = u2;
-	 ctx->EvalMap.Map1Normal.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Normal.Points)
-	    FREE( ctx->EvalMap.Map1Normal.Points );
-	 ctx->EvalMap.Map1Normal.Points = pnts;
+         map = &ctx->EvalMap.Map1Normal;
 	 break;
       case GL_MAP1_TEXTURE_COORD_1:
-         ctx->EvalMap.Map1Texture1.Order = uorder;
-	 ctx->EvalMap.Map1Texture1.u1 = u1;
-	 ctx->EvalMap.Map1Texture1.u2 = u2;
-	 ctx->EvalMap.Map1Texture1.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Texture1.Points)
-	    FREE( ctx->EvalMap.Map1Texture1.Points );
-	 ctx->EvalMap.Map1Texture1.Points = pnts;
+         map = &ctx->EvalMap.Map1Texture1;
 	 break;
       case GL_MAP1_TEXTURE_COORD_2:
-         ctx->EvalMap.Map1Texture2.Order = uorder;
-	 ctx->EvalMap.Map1Texture2.u1 = u1;
-	 ctx->EvalMap.Map1Texture2.u2 = u2;
-	 ctx->EvalMap.Map1Texture2.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Texture2.Points)
-	    FREE( ctx->EvalMap.Map1Texture2.Points );
-	 ctx->EvalMap.Map1Texture2.Points = pnts;
+         map = &ctx->EvalMap.Map1Texture2;
 	 break;
       case GL_MAP1_TEXTURE_COORD_3:
-         ctx->EvalMap.Map1Texture3.Order = uorder;
-	 ctx->EvalMap.Map1Texture3.u1 = u1;
-	 ctx->EvalMap.Map1Texture3.u2 = u2;
-	 ctx->EvalMap.Map1Texture3.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Texture3.Points)
-	    FREE( ctx->EvalMap.Map1Texture3.Points );
-	 ctx->EvalMap.Map1Texture3.Points = pnts;
+         map = &ctx->EvalMap.Map1Texture3;
 	 break;
       case GL_MAP1_TEXTURE_COORD_4:
-         ctx->EvalMap.Map1Texture4.Order = uorder;
-	 ctx->EvalMap.Map1Texture4.u1 = u1;
-	 ctx->EvalMap.Map1Texture4.u2 = u2;
-	 ctx->EvalMap.Map1Texture4.du = 1.0 / (u2 - u1);
-	 if (ctx->EvalMap.Map1Texture4.Points)
-	    FREE( ctx->EvalMap.Map1Texture4.Points );
-	 ctx->EvalMap.Map1Texture4.Points = pnts;
+         map = &ctx->EvalMap.Map1Texture4;
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
+	 return;
    }
+
+   /* make copy of the control points */
+   if (type == GL_FLOAT)
+      pnts = _mesa_copy_map_points1f(target, ustride, uorder, (GLfloat*) points);
+   else
+      pnts = _mesa_copy_map_points1d(target, ustride, uorder, (GLdouble*) points);
+
+
+   FLUSH_VERTICES(ctx, _NEW_EVAL);
+   map->Order = uorder;
+   map->u1 = u1;
+   map->u2 = u2;
+   map->du = 1.0F / (u2 - u1);
+   if (map->Points)
+      FREE( map->Points );
+   map->Points = pnts;
 }
 
 
@@ -951,7 +348,7 @@
 _mesa_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
              GLint order, const GLdouble *points )
 {
-   map1(target, u1, u2, stride, order, points, GL_DOUBLE);
+   map1(target, (GLfloat) u1, (GLfloat) u2, stride, order, points, GL_DOUBLE);
 }
 
 
@@ -963,172 +360,103 @@
    GET_CURRENT_CONTEXT(ctx);
    GLint k;
    GLfloat *pnts;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMap2");
+   struct gl_2d_map *map = 0;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (u1==u2) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
       return;
    }
 
    if (v1==v2) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
       return;
    }
 
    if (uorder<1 || uorder>MAX_EVAL_ORDER) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
       return;
    }
 
    if (vorder<1 || vorder>MAX_EVAL_ORDER) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
       return;
    }
 
    k = _mesa_evaluator_components( target );
    if (k==0) {
-      gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
    }
 
    if (ustride < k) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
       return;
    }
    if (vstride < k) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
       return;
    }
 
-   /* make copy of the control points */
-   if (type == GL_FLOAT)
-      pnts = gl_copy_map_points2f(target, ustride, uorder,
-                                  vstride, vorder, (GLfloat*) points);
-   else
-      pnts = gl_copy_map_points2d(target, ustride, uorder,
-                                  vstride, vorder, (GLdouble*) points);
+   if (ctx->Texture.CurrentUnit != 0) {
+      /* See OpenGL 1.2.1 spec, section F.2.13 */
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glMap2(ACTIVE_TEXTURE != 0)" );
+      return;
+   }
 
    switch (target) {
       case GL_MAP2_VERTEX_3:
-         ctx->EvalMap.Map2Vertex3.Uorder = uorder;
-	 ctx->EvalMap.Map2Vertex3.u1 = u1;
-	 ctx->EvalMap.Map2Vertex3.u2 = u2;
-	 ctx->EvalMap.Map2Vertex3.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Vertex3.Vorder = vorder;
-	 ctx->EvalMap.Map2Vertex3.v1 = v1;
-	 ctx->EvalMap.Map2Vertex3.v2 = v2;
-	 ctx->EvalMap.Map2Vertex3.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Vertex3.Points)
-	    FREE( ctx->EvalMap.Map2Vertex3.Points );
-	 ctx->EvalMap.Map2Vertex3.Points = pnts;
+         map = &ctx->EvalMap.Map2Vertex3;
 	 break;
       case GL_MAP2_VERTEX_4:
-         ctx->EvalMap.Map2Vertex4.Uorder = uorder;
-	 ctx->EvalMap.Map2Vertex4.u1 = u1;
-	 ctx->EvalMap.Map2Vertex4.u2 = u2;
-	 ctx->EvalMap.Map2Vertex4.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Vertex4.Vorder = vorder;
-	 ctx->EvalMap.Map2Vertex4.v1 = v1;
-	 ctx->EvalMap.Map2Vertex4.v2 = v2;
-	 ctx->EvalMap.Map2Vertex4.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Vertex4.Points)
-	    FREE( ctx->EvalMap.Map2Vertex4.Points );
-	 ctx->EvalMap.Map2Vertex4.Points = pnts;
+         map = &ctx->EvalMap.Map2Vertex4;
 	 break;
       case GL_MAP2_INDEX:
-         ctx->EvalMap.Map2Index.Uorder = uorder;
-	 ctx->EvalMap.Map2Index.u1 = u1;
-	 ctx->EvalMap.Map2Index.u2 = u2;
-	 ctx->EvalMap.Map2Index.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Index.Vorder = vorder;
-	 ctx->EvalMap.Map2Index.v1 = v1;
-	 ctx->EvalMap.Map2Index.v2 = v2;
-	 ctx->EvalMap.Map2Index.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Index.Points)
-	    FREE( ctx->EvalMap.Map2Index.Points );
-	 ctx->EvalMap.Map2Index.Points = pnts;
+         map = &ctx->EvalMap.Map2Index;
 	 break;
       case GL_MAP2_COLOR_4:
-         ctx->EvalMap.Map2Color4.Uorder = uorder;
-	 ctx->EvalMap.Map2Color4.u1 = u1;
-	 ctx->EvalMap.Map2Color4.u2 = u2;
-	 ctx->EvalMap.Map2Color4.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Color4.Vorder = vorder;
-	 ctx->EvalMap.Map2Color4.v1 = v1;
-	 ctx->EvalMap.Map2Color4.v2 = v2;
-	 ctx->EvalMap.Map2Color4.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Color4.Points)
-	    FREE( ctx->EvalMap.Map2Color4.Points );
-	 ctx->EvalMap.Map2Color4.Points = pnts;
+         map = &ctx->EvalMap.Map2Color4;
 	 break;
       case GL_MAP2_NORMAL:
-         ctx->EvalMap.Map2Normal.Uorder = uorder;
-	 ctx->EvalMap.Map2Normal.u1 = u1;
-	 ctx->EvalMap.Map2Normal.u2 = u2;
-	 ctx->EvalMap.Map2Normal.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Normal.Vorder = vorder;
-	 ctx->EvalMap.Map2Normal.v1 = v1;
-	 ctx->EvalMap.Map2Normal.v2 = v2;
-	 ctx->EvalMap.Map2Normal.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Normal.Points)
-	    FREE( ctx->EvalMap.Map2Normal.Points );
-	 ctx->EvalMap.Map2Normal.Points = pnts;
+         map = &ctx->EvalMap.Map2Normal;
 	 break;
       case GL_MAP2_TEXTURE_COORD_1:
-         ctx->EvalMap.Map2Texture1.Uorder = uorder;
-	 ctx->EvalMap.Map2Texture1.u1 = u1;
-	 ctx->EvalMap.Map2Texture1.u2 = u2;
-	 ctx->EvalMap.Map2Texture1.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Texture1.Vorder = vorder;
-	 ctx->EvalMap.Map2Texture1.v1 = v1;
-	 ctx->EvalMap.Map2Texture1.v2 = v2;
-	 ctx->EvalMap.Map2Texture1.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Texture1.Points)
-	    FREE( ctx->EvalMap.Map2Texture1.Points );
-	 ctx->EvalMap.Map2Texture1.Points = pnts;
+         map = &ctx->EvalMap.Map2Texture1;
 	 break;
       case GL_MAP2_TEXTURE_COORD_2:
-         ctx->EvalMap.Map2Texture2.Uorder = uorder;
-	 ctx->EvalMap.Map2Texture2.u1 = u1;
-	 ctx->EvalMap.Map2Texture2.u2 = u2;
-	 ctx->EvalMap.Map2Texture2.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Texture2.Vorder = vorder;
-	 ctx->EvalMap.Map2Texture2.v1 = v1;
-	 ctx->EvalMap.Map2Texture2.v2 = v2;
-	 ctx->EvalMap.Map2Texture2.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Texture2.Points)
-	    FREE( ctx->EvalMap.Map2Texture2.Points );
-	 ctx->EvalMap.Map2Texture2.Points = pnts;
+         map = &ctx->EvalMap.Map2Texture2;
 	 break;
       case GL_MAP2_TEXTURE_COORD_3:
-         ctx->EvalMap.Map2Texture3.Uorder = uorder;
-	 ctx->EvalMap.Map2Texture3.u1 = u1;
-	 ctx->EvalMap.Map2Texture3.u2 = u2;
-	 ctx->EvalMap.Map2Texture3.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Texture3.Vorder = vorder;
-	 ctx->EvalMap.Map2Texture3.v1 = v1;
-	 ctx->EvalMap.Map2Texture3.v2 = v2;
-	 ctx->EvalMap.Map2Texture3.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Texture3.Points)
-	    FREE( ctx->EvalMap.Map2Texture3.Points );
-	 ctx->EvalMap.Map2Texture3.Points = pnts;
+         map = &ctx->EvalMap.Map2Texture3;
 	 break;
       case GL_MAP2_TEXTURE_COORD_4:
-         ctx->EvalMap.Map2Texture4.Uorder = uorder;
-	 ctx->EvalMap.Map2Texture4.u1 = u1;
-	 ctx->EvalMap.Map2Texture4.u2 = u2;
-	 ctx->EvalMap.Map2Texture4.du = 1.0 / (u2 - u1);
-         ctx->EvalMap.Map2Texture4.Vorder = vorder;
-	 ctx->EvalMap.Map2Texture4.v1 = v1;
-	 ctx->EvalMap.Map2Texture4.v2 = v2;
-	 ctx->EvalMap.Map2Texture4.dv = 1.0 / (v2 - v1);
-	 if (ctx->EvalMap.Map2Texture4.Points)
-	    FREE( ctx->EvalMap.Map2Texture4.Points );
-	 ctx->EvalMap.Map2Texture4.Points = pnts;
+         map = &ctx->EvalMap.Map2Texture4;
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
+	 return;
    }
+
+   /* make copy of the control points */
+   if (type == GL_FLOAT)
+      pnts = _mesa_copy_map_points2f(target, ustride, uorder,
+                                  vstride, vorder, (GLfloat*) points);
+   else
+      pnts = _mesa_copy_map_points2d(target, ustride, uorder,
+                                  vstride, vorder, (GLdouble*) points);
+
+
+   FLUSH_VERTICES(ctx, _NEW_EVAL);
+   map->Uorder = uorder;
+   map->u1 = u1;
+   map->u2 = u2;
+   map->du = 1.0F / (u2 - u1);
+   map->Vorder = vorder;
+   map->v1 = v1;
+   map->v2 = v2;
+   map->dv = 1.0F / (v2 - v1);
+   if (map->Points)
+      FREE( map->Points );
+   map->Points = pnts;
 }
 
 
@@ -1149,18 +477,19 @@
              GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
              const GLdouble *points )
 {
-   map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
-        points, GL_DOUBLE);
+   map2(target, (GLfloat) u1, (GLfloat) u2, ustride, uorder, 
+	(GLfloat) v1, (GLfloat) v2, vstride, vorder, points, GL_DOUBLE);
 }
 
 
-   
+
 void
 _mesa_GetMapdv( GLenum target, GLenum query, GLdouble *v )
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i, n;
    GLfloat *data;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (query) {
       case GL_COEFF:
@@ -1247,7 +576,7 @@
                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
 	       return;
 	 }
 	 if (data) {
@@ -1322,7 +651,7 @@
 	       v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
 	       return;
 	 }
          break;
@@ -1419,11 +748,11 @@
 	       v[3] = ctx->EvalMap.Map2Vertex4.v2;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
 	 }
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
    }
 }
 
@@ -1434,6 +763,7 @@
    GET_CURRENT_CONTEXT(ctx);
    GLint i, n;
    GLfloat *data;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (query) {
       case GL_COEFF:
@@ -1520,7 +850,7 @@
                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
 	       return;
 	 }
 	 if (data) {
@@ -1532,70 +862,70 @@
       case GL_ORDER:
 	 switch (target) {
 	    case GL_MAP1_COLOR_4:
-	       *v = ctx->EvalMap.Map1Color4.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Color4.Order;
 	       break;
 	    case GL_MAP1_INDEX:
-	       *v = ctx->EvalMap.Map1Index.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Index.Order;
 	       break;
 	    case GL_MAP1_NORMAL:
-	       *v = ctx->EvalMap.Map1Normal.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Normal.Order;
 	       break;
 	    case GL_MAP1_TEXTURE_COORD_1:
-	       *v = ctx->EvalMap.Map1Texture1.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Texture1.Order;
 	       break;
 	    case GL_MAP1_TEXTURE_COORD_2:
-	       *v = ctx->EvalMap.Map1Texture2.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Texture2.Order;
 	       break;
 	    case GL_MAP1_TEXTURE_COORD_3:
-	       *v = ctx->EvalMap.Map1Texture3.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Texture3.Order;
 	       break;
 	    case GL_MAP1_TEXTURE_COORD_4:
-	       *v = ctx->EvalMap.Map1Texture4.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Texture4.Order;
 	       break;
 	    case GL_MAP1_VERTEX_3:
-	       *v = ctx->EvalMap.Map1Vertex3.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Vertex3.Order;
 	       break;
 	    case GL_MAP1_VERTEX_4:
-	       *v = ctx->EvalMap.Map1Vertex4.Order;
+	       *v = (GLfloat) ctx->EvalMap.Map1Vertex4.Order;
 	       break;
 	    case GL_MAP2_COLOR_4:
-	       v[0] = ctx->EvalMap.Map2Color4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Color4.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Color4.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Color4.Vorder;
 	       break;
 	    case GL_MAP2_INDEX:
-	       v[0] = ctx->EvalMap.Map2Index.Uorder;
-	       v[1] = ctx->EvalMap.Map2Index.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Index.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Index.Vorder;
 	       break;
 	    case GL_MAP2_NORMAL:
-	       v[0] = ctx->EvalMap.Map2Normal.Uorder;
-	       v[1] = ctx->EvalMap.Map2Normal.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Normal.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Normal.Vorder;
 	       break;
 	    case GL_MAP2_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map2Texture1.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture1.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Texture1.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Texture1.Vorder;
 	       break;
 	    case GL_MAP2_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map2Texture2.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture2.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Texture2.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Texture2.Vorder;
 	       break;
 	    case GL_MAP2_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map2Texture3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture3.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Texture3.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Texture3.Vorder;
 	       break;
 	    case GL_MAP2_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map2Texture4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture4.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Texture4.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Texture4.Vorder;
 	       break;
 	    case GL_MAP2_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Vertex3.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Vertex3.Vorder;
 	       break;
 	    case GL_MAP2_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
+	       v[0] = (GLfloat) ctx->EvalMap.Map2Vertex4.Uorder;
+	       v[1] = (GLfloat) ctx->EvalMap.Map2Vertex4.Vorder;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
 	       return;
 	 }
          break;
@@ -1692,11 +1022,11 @@
 	       v[3] = ctx->EvalMap.Map2Vertex4.v2;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
 	 }
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
    }
 }
 
@@ -1707,6 +1037,7 @@
    GET_CURRENT_CONTEXT(ctx);
    GLuint i, n;
    GLfloat *data;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (query) {
       case GL_COEFF:
@@ -1793,7 +1124,7 @@
                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
 	       return;
 	 }
 	 if (data) {
@@ -1868,7 +1199,7 @@
 	       v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
 	       return;
 	 }
          break;
@@ -1965,676 +1296,27 @@
 	       v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
 	 }
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
    }
 }
 
 
 
-static void eval_points1( GLfloat outcoord[][4], 
-			  GLfloat coord[][4],
-			  const GLuint *flags,
-			  GLuint start,
-			  GLfloat du, GLfloat u1 )
-{
-   GLuint i;
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & VERT_EVAL_P1) 
-	 outcoord[i][0] = coord[i][0] * du + u1;
-      else if (flags[i] & VERT_EVAL_ANY) {
-	 outcoord[i][0] = coord[i][0];
-	 outcoord[i][1] = coord[i][1];
-      }
-}
-
-static void eval_points2( GLfloat outcoord[][4], 
-			  GLfloat coord[][4],
-			  const GLuint *flags,
-			  GLuint start,
-			  GLfloat du, GLfloat u1,
-			  GLfloat dv, GLfloat v1 )
-{
-   GLuint i;
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & VERT_EVAL_P2) {
-	 outcoord[i][0] = coord[i][0] * du + u1;
-	 outcoord[i][1] = coord[i][1] * dv + v1;
-      } else if (flags[i] & VERT_EVAL_ANY) {
-	 outcoord[i][0] = coord[i][0];
-	 outcoord[i][1] = coord[i][1];
-      }
-}
-
-
-static const GLubyte dirty_flags[5] = {
-   0,				/* not possible */
-   VEC_DIRTY_0,
-   VEC_DIRTY_1, 
-   VEC_DIRTY_2, 
-   VEC_DIRTY_3
-};
-
-
-static GLvector4f *eval1_4f( GLvector4f *dest, 
-			     GLfloat coord[][4], 
-			     const GLuint *flags,
-			     GLuint start,
-			     GLuint dimension,
-			     struct gl_1d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLfloat (*to)[4] = dest->data;
-   GLuint i;
-   
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 ASSIGN_4V(to[i], 0,0,0,1);
-	 horner_bezier_curve(map->Points, to[i], u, dimension, map->Order);
-      }
-
-   dest->count = i;
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->size = MAX2(dest->size, dimension);
-   dest->flags |= dirty_flags[dimension];
-   return dest;
-}
-
-
-static GLvector1ui *eval1_1ui( GLvector1ui *dest, 
-			       GLfloat coord[][4], 
-			       const GLuint *flags,
-			       GLuint start,
-			       struct gl_1d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLuint *to = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat tmp;
-	 horner_bezier_curve(map->Points, &tmp, u, 1, map->Order);
-	 to[i] = (GLuint) (GLint) tmp;
-      }
-
-   dest->start = VEC_ELT(dest, GLuint, start);
-   dest->count = i;
-   return dest;
-}
-
-static GLvector3f *eval1_norm( GLvector3f *dest, 
-			       GLfloat coord[][4],
-			       GLuint *flags, /* not const */
-			       GLuint start,
-			       struct gl_1d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLfloat (*to)[3] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 horner_bezier_curve(map->Points, to[i], u, 3, map->Order);
-	 flags[i+1] |= VERT_NORM; /* reset */
-      }
-
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->count = i;
-   return dest;
-}
-
-static GLvector4ub *eval1_color( GLvector4ub *dest, 
-				 GLfloat coord[][4],
-				 GLuint *flags, /* not const */
-				 GLuint start,
-				 struct gl_1d_map *map )
-{   
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLubyte (*to)[4] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat fcolor[4];
-	 horner_bezier_curve(map->Points, fcolor, u, 4, map->Order);
-	 FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
-	 flags[i+1] |= VERT_RGBA; /* reset */
-      }
-
-   dest->start = VEC_ELT(dest, GLubyte, start);
-   dest->count = i;
-   return dest;
-}
-
-
-
-
-static GLvector4f *eval2_obj_norm( GLvector4f *obj_ptr, 
-				   GLvector3f *norm_ptr,
-				   GLfloat coord[][4], 
-				   GLuint *flags, 
-				   GLuint start,
-				   GLuint dimension,
-				   struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLfloat (*obj)[4] = obj_ptr->data;
-   GLfloat (*normal)[3] = norm_ptr->data;
-   GLuint i;
-   
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 GLfloat du[4], dv[4];
-
-	 ASSIGN_4V(obj[i], 0,0,0,1);
-	 de_casteljau_surf(map->Points, obj[i], du, dv, u, v, dimension,
-			   map->Uorder, map->Vorder);
-	       
-	 CROSS3(normal[i], du, dv);
-	 NORMALIZE_3FV(normal[i]);
-	 flags[i+1] |= VERT_NORM;
-      }
- 
-   obj_ptr->start = VEC_ELT(obj_ptr, GLfloat, start);
-   obj_ptr->count = i;
-   obj_ptr->size = MAX2(obj_ptr->size, dimension);
-   obj_ptr->flags |= dirty_flags[dimension];
-   return obj_ptr;
-}
-
-
-static GLvector4f *eval2_4f( GLvector4f *dest, 
-			     GLfloat coord[][4], 
-			     const GLuint *flags,
-			     GLuint start,
-			     GLuint dimension,
-			     struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLfloat (*to)[4] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 horner_bezier_surf(map->Points, to[i], u, v, dimension,
-			    map->Uorder, map->Vorder);
-      }
-
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->count = i;
-   dest->size = MAX2(dest->size, dimension);
-   dest->flags |= dirty_flags[dimension];
-   return dest;
-}
-
-
-static GLvector3f *eval2_norm( GLvector3f *dest, 
-			       GLfloat coord[][4], 
-			       GLuint *flags, 
-			       GLuint start,
-			       struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLfloat (*to)[3] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 horner_bezier_surf(map->Points, to[i], u, v, 3,
-			    map->Uorder, map->Vorder);
- 	 flags[i+1] |= VERT_NORM; /* reset */
-     }
-
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->count = i;
-   return dest;
-}
-
-
-static GLvector1ui *eval2_1ui( GLvector1ui *dest, 
-			       GLfloat coord[][4], 
-			       const GLuint *flags,
-			       GLuint start,
-			       struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLuint *to = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 GLfloat tmp;
-	 horner_bezier_surf(map->Points, &tmp, u, v, 1,
-			    map->Uorder, map->Vorder);
-
-	 to[i] = (GLuint) (GLint) tmp;
-      }
-
-   dest->start = VEC_ELT(dest, GLuint, start);
-   dest->count = i;
-   return dest;
-}
-
-
-
-static GLvector4ub *eval2_color( GLvector4ub *dest,
-				 GLfloat coord[][4], 
-				 GLuint *flags,
-				 GLuint start,
-				 struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLubyte (*to)[4] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 GLfloat fcolor[4];
-	 horner_bezier_surf(map->Points, fcolor, u, v, 4,
-			    map->Uorder, map->Vorder);
-	 FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
-	 flags[i+1] |= VERT_RGBA; /* reset */
-      }
-
-   dest->start = VEC_ELT(dest, GLubyte, start);
-   dest->count = i;
-   return dest;
-}
-
-
-static GLvector4f *copy_4f( GLvector4f *out, CONST GLvector4f *in, 
-			    const GLuint *flags,
-			    GLuint start )
-{
-   GLfloat (*to)[4] = out->data;
-   GLfloat (*from)[4] = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 COPY_4FV( to[i], from[i] );
-   
-   out->start = VEC_ELT(out, GLfloat, start);
-   return out;
-}
-
-static GLvector3f *copy_3f( GLvector3f *out, CONST GLvector3f *in, 
-			    const GLuint *flags,
-			    GLuint start )
-{
-   GLfloat (*to)[3] = out->data;
-   GLfloat (*from)[3] = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 COPY_3V( to[i], from[i] );
-   
-   out->start = VEC_ELT(out, GLfloat, start);
-   return out;
-}
-
-static GLvector4ub *copy_4ub( GLvector4ub *out, 
-			      CONST GLvector4ub *in, 
-			      const GLuint *flags,
-			      GLuint start )
-{
-   GLubyte (*to)[4] = out->data;
-   GLubyte (*from)[4] = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 COPY_4UBV( to[i], from[i] );
-
-   out->start = VEC_ELT(out, GLubyte, start);
-   return out;
-}
-
-static GLvector1ui *copy_1ui( GLvector1ui *out, 
-			      CONST GLvector1ui *in, 
-			      const GLuint *flags,
-			      GLuint start )
-{
-   GLuint *to = out->data;
-   CONST GLuint *from = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 to[i] = from[i];
-
-   out->start = VEC_ELT(out, GLuint, start);
-   return out;
-}
-
-
-/* KW: Rewrote this to perform eval on a whole buffer at once.
- *     Only evaluates active data items, and avoids scribbling
- *     the source buffer if we are running from a display list.
- *
- *     If the user (in this case looser) sends eval coordinates
- *     or runs a display list containing eval coords with no
- *     vertex maps enabled, we have to either copy all non-eval
- *     data to a new buffer, or find a way of working around
- *     the eval data.  I choose the second option.
- *
- * KW: This code not reached by cva - use IM to access storage.
- */
-void gl_eval_vb( struct vertex_buffer *VB )
-{
-   struct immediate *IM = VB->IM;
-   GLcontext *ctx = VB->ctx;
-   GLuint req = ctx->CVA.elt.inputs;
-   GLfloat (*coord)[4] = VB->ObjPtr->data;
-   GLuint *flags = VB->Flag;
-   GLuint new_flags = 0;
-   
-
-   GLuint any_eval1 = VB->OrFlag & (VERT_EVAL_C1|VERT_EVAL_P1);
-   GLuint any_eval2 = VB->OrFlag & (VERT_EVAL_C2|VERT_EVAL_P2);
-   GLuint all_eval = IM->AndFlag & VERT_EVAL_ANY;
-
-   /* Handle the degenerate cases.
-    */
-   if (any_eval1 && !ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3) {
-      VB->PurgeFlags |= (VERT_EVAL_C1|VERT_EVAL_P1);
-      VB->EarlyCull = 0;
-      any_eval1 = GL_FALSE;
-   }
-  
-   if (any_eval2 && !ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3) {
-      VB->PurgeFlags |= (VERT_EVAL_C2|VERT_EVAL_P2);
-      VB->EarlyCull = 0;
-      any_eval2 = GL_FALSE;
-   }
-
-   /* KW: This really is a degenerate case - doing this disables
-    * culling, and causes dummy values for the missing vertices to be
-    * transformed and clip tested.  It also forces the individual
-    * cliptesting of each primitive in vb_render.  I wish there was a
-    * nice alternative, but I can't say I want to put effort into
-    * optimizing such a bad usage of the library - I'd much rather
-    * work on useful changes.
-    */
-   if (VB->PurgeFlags) {
-      if (!any_eval1 && !any_eval2 && all_eval) VB->Count = VB->Start;
-      gl_purge_vertices( VB );
-      if (!any_eval1 && !any_eval2) return;
-   } else
-      VB->IndirectCount = VB->Count;
-
-   /* Translate points into coords.
-    */
-   if (any_eval1 && (VB->OrFlag & VERT_EVAL_P1)) 
-   {
-      eval_points1( IM->Obj, coord, flags, IM->Start,
-		    ctx->Eval.MapGrid1du,
-		    ctx->Eval.MapGrid1u1);
-
-      coord = IM->Obj;
-   }
-
-   if (any_eval2 && (VB->OrFlag & VERT_EVAL_P2)) 
-   {
-      eval_points2( IM->Obj, coord, flags, IM->Start,
-		    ctx->Eval.MapGrid2du,
-		    ctx->Eval.MapGrid2u1,
-		    ctx->Eval.MapGrid2dv,
-		    ctx->Eval.MapGrid2v1 );
-
-      coord = IM->Obj;
-   }
-
-   /* Perform the evaluations on active data elements.
-    */
-   if (req & VERT_INDEX) 
-   {
-      GLvector1ui  *in_index = VB->IndexPtr;
-      GLvector1ui  *out_index = &IM->v.Index;
-
-      if (ctx->Eval.Map1Index && any_eval1) 
-	 VB->IndexPtr = eval1_1ui( out_index, coord, flags, IM->Start,
-				   &ctx->EvalMap.Map1Index );
-      
-      if (ctx->Eval.Map2Index && any_eval2)
-	 VB->IndexPtr = eval2_1ui( out_index, coord, flags, IM->Start,
-				   &ctx->EvalMap.Map2Index );
-	 
-      if (VB->IndexPtr != in_index) {
-	 new_flags |= VERT_INDEX;
-	 if (!all_eval)
-	    VB->IndexPtr = copy_1ui( out_index, in_index, flags, IM->Start );
-      }
-   }
-
-   if (req & VERT_RGBA) 
-   {   
-      GLvector4ub  *in_color = VB->ColorPtr;
-      GLvector4ub  *out_color = &IM->v.Color;
-
-      if (ctx->Eval.Map1Color4 && any_eval1) 
-	 VB->ColorPtr = eval1_color( out_color, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map1Color4 );
-      
-      if (ctx->Eval.Map2Color4 && any_eval2)
-	 VB->ColorPtr = eval2_color( out_color, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map2Color4 );
-	 
-      if (VB->ColorPtr != in_color) {
-	 new_flags |= VERT_RGBA;
-	 if (!all_eval)
-	    VB->ColorPtr = copy_4ub( out_color, in_color, flags, IM->Start );
-      }
-
-      VB->Color[0] = VB->Color[1] = VB->ColorPtr;
-   }
-
-
-   if (req & VERT_NORM) 
-   {   
-      GLvector3f  *in_normal = VB->NormalPtr;
-      GLvector3f  *out_normal = &IM->v.Normal;
-
-      if (ctx->Eval.Map1Normal && any_eval1) 
-	 VB->NormalPtr = eval1_norm( out_normal, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map1Normal );
-      
-      if (ctx->Eval.Map2Normal && any_eval2)
-	 VB->NormalPtr = eval2_norm( out_normal, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map2Normal );
-	 
-      new_flags |= VERT_NORM;
-
-      if (VB->NormalPtr != in_normal) {
-	 if (!all_eval)
-	    VB->NormalPtr = copy_3f( out_normal, in_normal, flags, IM->Start );
-      }
-   }
-
-     
-   if (req & VERT_TEX_ANY(0)) 
-   {
-      GLvector4f *tc = VB->TexCoordPtr[0];
-      GLvector4f *in = tc;
-      GLvector4f *out = &IM->v.TexCoord[0];
-
-      if (any_eval1) {
-	 if (ctx->Eval.Map1TextureCoord4) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 
-			   4, &ctx->EvalMap.Map1Texture4);
-	 else if (ctx->Eval.Map1TextureCoord3) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 3,
-			   &ctx->EvalMap.Map1Texture3);
-	 else if (ctx->Eval.Map1TextureCoord2) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 2,
-			   &ctx->EvalMap.Map1Texture2);
-	 else if (ctx->Eval.Map1TextureCoord1) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 1,
-			   &ctx->EvalMap.Map1Texture1);
-      }
-
-      if (any_eval2) {
-	 if (ctx->Eval.Map2TextureCoord4) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   4, &ctx->EvalMap.Map2Texture4);
-	 else if (ctx->Eval.Map2TextureCoord3) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   3, &ctx->EvalMap.Map2Texture3);
-	 else if (ctx->Eval.Map2TextureCoord2) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   2, &ctx->EvalMap.Map2Texture2);
-	 else if (ctx->Eval.Map2TextureCoord1) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   1, &ctx->EvalMap.Map2Texture1);
-      }
-
-      if (tc != in) {
-	 new_flags |= VERT_TEX_ANY(0); /* fix for sizes.. */
-	 if (!all_eval)
-	    tc = copy_4f( out, in, flags, IM->Start );
-      }
-
-      VB->TexCoordPtr[0] = tc;
-   }
-
-
-   {
-      GLvector4f *in = VB->ObjPtr;
-      GLvector4f *out = &IM->v.Obj;
-      GLvector4f *obj = in;
-   
-      if (any_eval1) {
-	 if (ctx->Eval.Map1Vertex4) 
-	    obj = eval1_4f( out, coord, flags, IM->Start,
-			    4, &ctx->EvalMap.Map1Vertex4);
-	 else 
-	    obj = eval1_4f( out, coord, flags, IM->Start,
-			    3, &ctx->EvalMap.Map1Vertex3);
-      }
-
-      if (any_eval2) {
-	 GLvector3f  *in_normal = VB->NormalPtr;
-	 GLvector3f  *out_normal = &IM->v.Normal;
-
-	 if (ctx->Eval.Map2Vertex4) 
-	 {
-	    if (ctx->Eval.AutoNormal && (req & VERT_NORM)) {
-	       obj = eval2_obj_norm( out, out_normal, coord, flags, 
-				     IM->Start, 4, &ctx->EvalMap.Map2Vertex4 );
-	       VB->NormalPtr = out_normal;
-	       new_flags |= VERT_NORM;
-	    }
-	    else
-	       obj = eval2_4f( out, coord, flags, IM->Start,
-			       4, &ctx->EvalMap.Map2Vertex4 );
-	 }
-	 else if (ctx->Eval.Map2Vertex3) 
-	 {
-	    if (ctx->Eval.AutoNormal && (req & VERT_NORM)) {
-	       obj = eval2_obj_norm( out, out_normal, coord, flags, 
-				     IM->Start, 3, &ctx->EvalMap.Map2Vertex3 );
-	       VB->NormalPtr = out_normal;
-	       new_flags |= VERT_NORM;
-	    }
-	    else
-	       obj = eval2_4f( out, coord, flags, IM->Start,
-			       3, &ctx->EvalMap.Map2Vertex3 );
-	 }
-
-
-	 if (VB->NormalPtr != in_normal) {
-	    if (!all_eval)
-	       VB->NormalPtr = copy_3f( out_normal, in_normal, flags, 
-					IM->Start );
-	 }
-      }
-      
-      if (obj != in && !all_eval)
-	 obj = copy_4f( out, in, flags, IM->Start );
-
-      VB->ObjPtr = obj;
-   }
-
-   if (new_flags) {
-      GLuint *oldflags = VB->Flag;
-      GLuint *flags = VB->Flag = VB->EvaluatedFlags;
-      GLuint i;
-      GLuint count = VB->Count;
-      GLuint andflag = VB->IM->AndFlag;
-
-      if (!flags) {
-	 VB->EvaluatedFlags = (GLuint *) MALLOC(VB->Size * sizeof(GLuint));
-	 flags = VB->Flag = VB->EvaluatedFlags;
-      }
-
-      if (all_eval) {
-	 for (i = 0 ; i <= count ; i++) 
-	    flags[i] = oldflags[i] | new_flags;
-	 andflag |= new_flags;
-      } else {
-	 andflag = ~0;
-	 for (i = 0 ; i <= count ; i++) {
-	    flags[i] = oldflags[i];
-	    if (flags[i] & VERT_EVAL_ANY) 
-	       flags[i] |= new_flags;
-	    andflag &= flags[i];
-	 }
-      }
-
-      VB->OrFlag |= new_flags;
-      VB->CullMode = (GLubyte) ((andflag & VERT_NORM) ? 0 : COMPACTED_NORMALS);
-   }
-}
-
-
 void
 _mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMapGrid1f");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (un<1) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
       return;
    }
+   FLUSH_VERTICES(ctx, _NEW_EVAL);
    ctx->Eval.MapGrid1un = un;
    ctx->Eval.MapGrid1u1 = u1;
    ctx->Eval.MapGrid1u2 = u2;
@@ -2645,7 +1327,7 @@
 void
 _mesa_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
 {
-   _mesa_MapGrid1f( un, u1, u2 );
+   _mesa_MapGrid1f( un, (GLfloat) u1, (GLfloat) u2 );
 }
 
 
@@ -2654,15 +1336,18 @@
                  GLint vn, GLfloat v1, GLfloat v2 )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMapGrid2f");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    if (un<1) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
       return;
    }
    if (vn<1) {
-      gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
       return;
    }
+
+   FLUSH_VERTICES(ctx, _NEW_EVAL);
    ctx->Eval.MapGrid2un = un;
    ctx->Eval.MapGrid2u1 = u1;
    ctx->Eval.MapGrid2u2 = u2;
@@ -2677,287 +1362,7 @@
 void
 _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
                  GLint vn, GLdouble v1, GLdouble v2 )
-{
-   _mesa_MapGrid2f( un, u1, u2, vn, v1, v2 );
-}
-
-
-
-
-/* KW: If are compiling, we don't know whether eval will produce a
- *     vertex when it is run in the future.  If this is pure immediate
- *     mode, eval is a noop if neither vertex map is enabled.
- *
- *     Thus we need to have a check in the display list code or
- *     elsewhere for eval(1,2) vertices in the case where
- *     map(1,2)_vertex is disabled, and to purge those vertices from
- *     the vb.  This is currently done
- *     via  modifications to the cull_vb and render_vb operations, and
- *     by using the existing cullmask mechanism for all other operations.  
- */
-
-
-/* KW: Because the eval values don't become 'current', fixup will flow
- *     through these vertices, and then evaluation will write on top
- *     of the fixup results.  
- *
- *     This is a little inefficient, but at least it is correct.  This
- *     could be short-circuited in the case where all vertices are
- *     eval-vertices, or more generally by a cullmask in fixup.
- *
- *     Note: using Obj to hold eval coord data.  This data is actually
- *     transformed if eval is disabled.  But disabling eval & sending
- *     eval coords is stupid, right?
- */
-
-
-#define EVALCOORD1(IM, x)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_C1;			\
-   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      IM->maybe_transform_vb( IM );			\
-}
-
-#define EVALCOORD2(IM, x, y)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_C2;			\
-   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      IM->maybe_transform_vb( IM );			\
-}
-
-#define EVALPOINT1(IM, x)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_P1;			\
-   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      IM->maybe_transform_vb( IM );			\
-}
- 
-#define EVALPOINT2(IM, x, y)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_P2;			\
-   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      IM->maybe_transform_vb( IM );			\
-}
-
-
-/* Lame internal function:
- */
-static void
-eval_coord1f( GLcontext *CC, GLfloat u )
 {
-   struct immediate *i = CC->input;
-   EVALCOORD1( i, u );
+   _mesa_MapGrid2f( un, (GLfloat) u1, (GLfloat) u2, 
+		    vn, (GLfloat) v1, (GLfloat) v2 );
 }
-
-
-void
-_mesa_EvalCoord1d( GLdouble u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, (GLfloat) u );
-}
-
-
-void
-_mesa_EvalCoord1f( GLfloat u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, u );
-}
-
-
-void
-_mesa_EvalCoord1dv( const GLdouble *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, (GLfloat) *u );
-}
-
-
-void
-_mesa_EvalCoord1fv( const GLfloat *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, (GLfloat) *u );
-}
-
-
-void
-_mesa_EvalCoord2d( GLdouble u, GLdouble v )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, (GLfloat) u, (GLfloat) v );
-}
-
-
-void
-_mesa_EvalCoord2f( GLfloat u, GLfloat v )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, u, v );
-}
-
-
-/* Lame internal function:
- */
-static void
-eval_coord2f( GLcontext *CC, GLfloat u, GLfloat v )
-{
-   struct immediate *i = CC->input;
-   EVALCOORD2( i, u, v );
-}
-
-
-void
-_mesa_EvalCoord2dv( const GLdouble *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, (GLfloat) u[0], (GLfloat) u[1] );
-}
-
-
-void
-_mesa_EvalCoord2fv( const GLfloat *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, u[0], u[1] );
-}
-
-
-void
-_mesa_EvalPoint1( GLint i )
-{
-   GET_IMMEDIATE;
-   EVALPOINT1( IM, i );
-}
-
-
-void
-_mesa_EvalPoint2( GLint i, GLint j )
-{
-   GET_IMMEDIATE;
-   EVALPOINT2( IM, i, j );
-}
-
-
-
-
-
-void
-_mesa_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-   GLfloat u, du;
-   GLenum prim;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh1");
-
-   switch (mode) {
-      case GL_POINT:
-         prim = GL_POINTS;
-         break;
-      case GL_LINE:
-         prim = GL_LINE_STRIP;
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
-         return;
-   }
-
-   /* No effect if vertex maps disabled.
-    */
-   if (!ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3) 
-      return;
-
-   du = ctx->Eval.MapGrid1du;
-   u = ctx->Eval.MapGrid1u1 + i1 * du;
-
-   /* KW: Could short-circuit this to avoid the immediate mechanism.
-    */
-   RESET_IMMEDIATE(ctx);
-
-   gl_Begin( ctx, prim );
-   for (i=i1;i<=i2;i++,u+=du) {
-      eval_coord1f( ctx, u );
-   }
-   gl_End(ctx);
-}
-
-
-
-void
-_mesa_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i, j;
-   GLfloat u, du, v, dv, v1, u1;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh2");
-
-   /* No effect if vertex maps disabled.
-    */
-   if (!ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3) 
-      return;
-
-   du = ctx->Eval.MapGrid2du;
-   dv = ctx->Eval.MapGrid2dv;
-   v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
-   u1 = ctx->Eval.MapGrid2u1 + i1 * du;
-
-   RESET_IMMEDIATE(ctx);
-
-   switch (mode) {
-   case GL_POINT:
-      gl_Begin( ctx, GL_POINTS );
-      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
-	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	    eval_coord2f( ctx, u, v );
-	 }
-      }
-      gl_End(ctx);
-      break;
-   case GL_LINE:
-      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
-	 gl_Begin( ctx, GL_LINE_STRIP );
-	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	    eval_coord2f( ctx, u, v );
-	 }
-	 gl_End(ctx);
-      }
-      for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	 gl_Begin( ctx, GL_LINE_STRIP );
-	 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
-	    eval_coord2f( ctx, u, v );
-	 }
-	 gl_End(ctx);
-      }
-      break;
-   case GL_FILL:
-      for (v=v1,j=j1;j<j2;j++,v+=dv) {
-	 /* NOTE: a quad strip can't be used because the four */
-	 /* can't be guaranteed to be coplanar! */
-	 gl_Begin( ctx, GL_TRIANGLE_STRIP );
-	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	    eval_coord2f( ctx, u, v );
-	    eval_coord2f( ctx, u, v+dv );
-	 }
-	 gl_End(ctx);
-      }
-      break;
-   default:
-      gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
-      return;
-   }
-}
-
-
-
Index: xc/extras/Mesa/src/eval.h
diff -u xc/extras/Mesa/src/eval.h:1.3 xc/extras/Mesa/src/eval.h:1.4
--- xc/extras/Mesa/src/eval.h:1.3	Tue Feb 15 02:12:13 2000
+++ xc/extras/Mesa/src/eval.h	Fri Feb 22 14:25:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,10 +28,10 @@
 #define EVAL_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
-extern void gl_init_eval( void );
+extern void _mesa_init_eval( void );
 
 
 extern GLuint _mesa_evaluator_components( GLenum target );
@@ -41,28 +41,26 @@
                                     GLenum target, GLfloat *data );
 
 
-extern GLfloat *gl_copy_map_points1f( GLenum target,
+extern GLfloat *_mesa_copy_map_points1f( GLenum target,
                                       GLint ustride, GLint uorder,
                                       const GLfloat *points );
 
-extern GLfloat *gl_copy_map_points1d( GLenum target,
+extern GLfloat *_mesa_copy_map_points1d( GLenum target,
                                       GLint ustride, GLint uorder,
                                       const GLdouble *points );
 
-extern GLfloat *gl_copy_map_points2f( GLenum target,
+extern GLfloat *_mesa_copy_map_points2f( GLenum target,
                                       GLint ustride, GLint uorder,
                                       GLint vstride, GLint vorder,
                                       const GLfloat *points );
 
-extern GLfloat *gl_copy_map_points2d(GLenum target,
+extern GLfloat *_mesa_copy_map_points2d(GLenum target,
                                      GLint ustride, GLint uorder,
                                      GLint vstride, GLint vorder,
                                      const GLdouble *points );
 
 
-extern void gl_eval_vb( struct vertex_buffer *VB );
 
-
 extern void
 _mesa_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
              GLint order, const GLfloat *points );
@@ -106,40 +104,5 @@
 extern void
 _mesa_GetMapiv( GLenum target, GLenum query, GLint *v );
 
-extern void
-_mesa_EvalMesh1( GLenum mode, GLint i1, GLint i2 );
-
-extern void
-_mesa_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
-
-extern void
-_mesa_EvalCoord1d( GLdouble u );
-
-extern void
-_mesa_EvalCoord1f( GLfloat u );
-
-extern void
-_mesa_EvalCoord1dv( const GLdouble *u );
-
-extern void
-_mesa_EvalCoord1fv( const GLfloat *u );
-
-extern void
-_mesa_EvalCoord2d( GLdouble u, GLdouble v );
-
-extern void
-_mesa_EvalCoord2f( GLfloat u, GLfloat v );
-
-extern void
-_mesa_EvalCoord2dv( const GLdouble *u );
-
-extern void
-_mesa_EvalCoord2fv( const GLfloat *u );
-
-extern void
-_mesa_EvalPoint1( GLint i );
-
-extern void
-_mesa_EvalPoint2( GLint i, GLint j );
 
 #endif
Index: xc/extras/Mesa/src/extensions.c
diff -u xc/extras/Mesa/src/extensions.c:1.10 xc/extras/Mesa/src/extensions.c:1.14
--- xc/extras/Mesa/src/extensions.c:1.10	Tue May  1 17:36:45 2001
+++ xc/extras/Mesa/src/extensions.c	Mon Dec 16 11:18:26 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -32,7 +32,7 @@
 #include "extensions.h"
 #include "mem.h"
 #include "simple_list.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -41,147 +41,286 @@
 struct extension {
    struct extension *next, *prev;
    GLint enabled;
+   GLboolean *flag;			/* optional flag stored elsewhere */
    char name[MAX_EXT_NAMELEN+1];
    void (*notify)( GLcontext *, GLboolean );
 };
 
+#define F(x) (int)&(((struct gl_extensions *)0)->x)
+#define ON GL_TRUE
+#define OFF GL_FALSE
+
+static struct {
+   GLboolean enabled;
+   const char *name;
+   int flag_offset;
+} default_extensions[] = {
+   { OFF, "GL_ARB_imaging",                    F(ARB_imaging) },
+   { OFF, "GL_ARB_multisample",                F(ARB_multisample) },
+   { OFF, "GL_ARB_multitexture",               F(ARB_multitexture) },
+   { OFF, "GL_ARB_texture_border_clamp",       F(ARB_texture_border_clamp) },
+   { OFF, "GL_ARB_texture_compression",        F(ARB_texture_compression) },
+   { OFF, "GL_ARB_texture_cube_map",           F(ARB_texture_cube_map) },
+   { OFF, "GL_ARB_texture_env_add",            F(EXT_texture_env_add) },
+   { OFF, "GL_ARB_texture_env_combine",        F(ARB_texture_env_combine) },
+   { OFF, "GL_ARB_texture_env_dot3",           F(ARB_texture_env_dot3) },
+   { OFF, "GL_ARB_texture_mirrored_repeat",    F(ARB_texture_mirrored_repeat)},
+   { ON,  "GL_ARB_transpose_matrix",           0 },
+   { ON,  "GL_EXT_abgr",                       0 },
+   { ON,  "GL_EXT_bgra",                       0 },
+   { OFF, "GL_EXT_blend_color",                F(EXT_blend_color) },
+   { OFF, "GL_EXT_blend_func_separate",        F(EXT_blend_func_separate) },
+   { OFF, "GL_EXT_blend_logic_op",             F(EXT_blend_logic_op) },
+   { OFF, "GL_EXT_blend_minmax",               F(EXT_blend_minmax) },
+   { OFF, "GL_EXT_blend_subtract",             F(EXT_blend_subtract) },
+   { ON,  "GL_EXT_clip_volume_hint",           F(EXT_clip_volume_hint) },
+   { OFF, "GL_EXT_cull_vertex",                0 },
+   { OFF, "GL_EXT_convolution",                F(EXT_convolution) },
+   { ON,  "GL_EXT_compiled_vertex_array",      F(EXT_compiled_vertex_array) },
+   { OFF, "GL_EXT_fog_coord",                  F(EXT_fog_coord) },
+   { OFF, "GL_EXT_histogram",                  F(EXT_histogram) },
+   { ON,  "GL_EXT_packed_pixels",              F(EXT_packed_pixels) },
+   { OFF, "GL_EXT_paletted_texture",           F(EXT_paletted_texture) },
+   { OFF, "GL_EXT_point_parameters",           F(EXT_point_parameters) },
+   { ON,  "GL_EXT_polygon_offset",             F(EXT_polygon_offset) },
+   { ON,  "GL_EXT_rescale_normal",             F(EXT_rescale_normal) },
+   { OFF, "GL_EXT_secondary_color",            F(EXT_secondary_color) },
+   { OFF, "GL_EXT_shared_texture_palette",     F(EXT_shared_texture_palette) },
+   { OFF, "GL_EXT_stencil_wrap",               F(EXT_stencil_wrap) },
+   { ON,  "GL_EXT_texture3D",                  F(EXT_texture3D) },
+   { OFF, "GL_EXT_texture_compression_s3tc",   F(EXT_texture_compression_s3tc) },
+   { OFF, "GL_EXT_texture_edge_clamp",         F(SGIS_texture_edge_clamp) },
+   { OFF, "GL_EXT_texture_env_add",            F(EXT_texture_env_add) },
+   { OFF, "GL_EXT_texture_env_combine",        F(EXT_texture_env_combine) },
+   { OFF, "GL_EXT_texture_env_dot3",           F(EXT_texture_env_dot3) },
+   { OFF, "GL_EXT_texture_filter_anisotropic", F(EXT_texture_filter_anisotropic) },
+   { ON,  "GL_EXT_texture_object",             F(EXT_texture_object) },
+   { OFF, "GL_EXT_texture_lod_bias",           F(EXT_texture_lod_bias) },
+   { ON,  "GL_EXT_vertex_array",               0 },
+   { OFF, "GL_EXT_vertex_array_set",           F(EXT_vertex_array_set) },
+   { OFF, "GL_HP_occlusion_test",              F(HP_occlusion_test) },
+   { ON,  "GL_IBM_rasterpos_clip",             F(IBM_rasterpos_clip) },
+   { OFF, "GL_IBM_texture_mirrored_repeat",    F(ARB_texture_mirrored_repeat)},
+   { OFF, "GL_INGR_blend_func_separate",       F(INGR_blend_func_separate) },
+   { OFF, "GL_MESA_pack_invert",               F(MESA_pack_invert) },
+   { OFF, "GL_MESA_packed_depth_stencil",      0 },
+   { OFF, "GL_MESA_resize_buffers",            F(MESA_resize_buffers) },
+   { OFF, "GL_MESA_ycbcr_texture",             F(MESA_ycbcr_texture) },
+   { ON,  "GL_MESA_window_pos",                F(MESA_window_pos) },
+   { OFF, "GL_NV_blend_square",                F(NV_blend_square) },
+   { ON,  "GL_NV_texgen_reflection",           F(NV_texgen_reflection) },
+   { OFF, "GL_NV_texture_rectangle",           F(NV_texture_rectangle) },
+   { OFF, "GL_SGI_color_matrix",               F(SGI_color_matrix) },
+   { OFF, "GL_SGI_color_table",                F(SGI_color_table) },
+   { OFF, "GL_SGIS_generate_mipmap",           F(SGIS_generate_mipmap) },
+   { OFF, "GL_SGIS_pixel_texture",             F(SGIS_pixel_texture) },
+   { OFF, "GL_SGIS_texture_border_clamp",      F(ARB_texture_border_clamp) },
+   { OFF, "GL_SGIS_texture_edge_clamp",        F(SGIS_texture_edge_clamp) },
+   { OFF, "GL_SGIX_depth_texture",             F(SGIX_depth_texture) },
+   { OFF, "GL_SGIX_pixel_texture",             F(SGIX_pixel_texture) },
+   { OFF, "GL_SGIX_shadow",                    F(SGIX_shadow) },
+   { OFF, "GL_SGIX_shadow_ambient",            F(SGIX_shadow_ambient) },
+   { OFF, "GL_3DFX_texture_compression_FXT1",  F(_3DFX_texture_compression_FXT1) },
+   { OFF, "GL_APPLE_client_storage",           F(APPLE_client_storage) },
+};
 
 
-static struct { int enabled; const char *name; } default_extensions[] = {
-   { DEFAULT_OFF,    "GL_ARB_imaging" },  /* in progress */
-   { DEFAULT_ON,     "GL_ARB_multitexture" },
-   { DEFAULT_OFF,    "GL_ARB_texture_compression" },
-   { DEFAULT_OFF,    "GL_ARB_texture_cube_map" },  /* in progress */
-   { ALWAYS_ENABLED, "GL_ARB_transpose_matrix" },
-   { ALWAYS_ENABLED, "GL_EXT_abgr" },
-   { DEFAULT_ON,     "GL_EXT_blend_color" },
-   { DEFAULT_ON,     "GL_EXT_blend_func_separate" },
-   { DEFAULT_ON,     "GL_EXT_blend_logic_op" },
-   { DEFAULT_ON,     "GL_EXT_blend_minmax" },
-   { DEFAULT_ON,     "GL_EXT_blend_subtract" },
-   { DEFAULT_ON,     "GL_EXT_clip_volume_hint" },
-   { DEFAULT_OFF,    "GL_EXT_convolution" },  /* in progress */
-   { DEFAULT_ON,     "GL_EXT_compiled_vertex_array" },
-   { DEFAULT_ON,     "GL_EXT_histogram" },
-   { DEFAULT_ON,     "GL_EXT_packed_pixels" },
-   { DEFAULT_ON,     "GL_EXT_paletted_texture" },
-   { DEFAULT_ON,     "GL_EXT_point_parameters" },
-   { ALWAYS_ENABLED, "GL_EXT_polygon_offset" },
-   { ALWAYS_ENABLED, "GL_EXT_rescale_normal" },
-   { DEFAULT_ON,     "GL_EXT_shared_texture_palette" },
-   { ALWAYS_ENABLED, "GL_EXT_stencil_wrap" },
-   { DEFAULT_ON,     "GL_EXT_texture3D" },
-   { DEFAULT_OFF,    "GL_EXT_texture_compression_s3tc" },
-   { DEFAULT_OFF,    "GL_EXT_texture_env" },
-   { DEFAULT_ON,     "GL_EXT_texture_env_add" },
-   { DEFAULT_OFF,    "GL_EXT_texture_env_combine" },
-   { DEFAULT_OFF,    "GL_EXT_texture_env_dot3" },
-   { ALWAYS_ENABLED, "GL_EXT_texture_object" },
-   { DEFAULT_ON,     "GL_EXT_texture_lod_bias" },
-   { ALWAYS_ENABLED, "GL_EXT_vertex_array" },
-   { DEFAULT_OFF,    "GL_EXT_vertex_array_set" },
-   { DEFAULT_OFF,    "GL_HP_occlusion_test" },
-   { DEFAULT_ON,     "GL_INGR_blend_func_separate" },
-   { ALWAYS_ENABLED, "GL_MESA_window_pos" },
-   { ALWAYS_ENABLED, "GL_MESA_resize_buffers" },
-   { DEFAULT_OFF,    "GL_NV_blend_square" },
-   { ALWAYS_ENABLED, "GL_NV_texgen_reflection" },
-   { DEFAULT_ON,     "GL_PGI_misc_hints" },
-   { DEFAULT_ON,     "GL_SGI_color_matrix" },
-   { DEFAULT_ON,     "GL_SGI_color_table" },
-   { DEFAULT_ON,     "GL_SGIS_pixel_texture" },
-   { DEFAULT_ON,     "GL_SGIS_texture_edge_clamp" },
-   { DEFAULT_ON,     "GL_SGIX_pixel_texture" },
-   { DEFAULT_OFF,    "GL_3DFX_texture_compression_FXT1" }
-};
 
 
 /*
- * Update the boolean convenience flags in the Extensions struct.
+ * Enable all extensions suitable for a software-only renderer.
+ * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.
  */
-static void
-update_extension_flags( GLcontext *ctx )
+void
+_mesa_enable_sw_extensions(GLcontext *ctx)
+{
+   const char *extensions[] = {
+      "GL_ARB_imaging",
+      "GL_ARB_multitexture",
+      "GL_ARB_texture_border_clamp",
+      "GL_ARB_texture_cube_map",
+      "GL_ARB_texture_env_add",
+      "GL_ARB_texture_env_combine",
+      "GL_ARB_texture_env_dot3",
+      "GL_ARB_texture_mirrored_repeat",
+      "GL_EXT_blend_color",
+      "GL_EXT_blend_func_separate",
+      "GL_EXT_blend_logic_op",
+      "GL_EXT_blend_minmax",
+      "GL_EXT_blend_subtract",
+      "GL_EXT_convolution",
+      "GL_EXT_fog_coord",
+      "GL_EXT_histogram",
+      "GL_EXT_paletted_texture",
+      "GL_EXT_point_parameters",
+      "GL_EXT_secondary_color",
+      "GL_EXT_shared_texture_palette",
+      "GL_EXT_stencil_wrap",
+      "GL_EXT_texture_edge_clamp",
+      "GL_EXT_texture_env_add",
+      "GL_EXT_texture_env_combine",
+      "GL_EXT_texture_env_dot3",
+      "GL_EXT_texture_lod_bias",
+      "GL_HP_occlusion_test",
+      "GL_IBM_texture_mirrored_repeat",
+      "GL_INGR_blend_func_separate",
+      "GL_MESA_pack_invert",
+      "GL_MESA_resize_buffers",
+      "GL_MESA_ycbcr_texture",
+      "GL_NV_blend_square",
+      "GL_NV_texgen_reflection",
+      "GL_NV_texture_rectangle",
+      "GL_SGI_color_matrix",
+      "GL_SGI_color_table",
+      "GL_SGIS_generate_mipmap",
+      "GL_SGIS_pixel_texture",
+      "GL_SGIS_texture_edge_clamp",
+      "GL_SGIS_texture_border_clamp",
+      "GL_SGIX_depth_texture",
+      "GL_SGIX_pixel_texture",
+      "GL_SGIX_shadow",
+      "GL_SGIX_shadow_ambient",
+      NULL
+   };
+   GLuint i;
+
+   for (i = 0; extensions[i]; i++) {
+      _mesa_enable_extension(ctx, extensions[i]);
+   }
+}
+
+
+/*
+ * Enable GL_ARB_imaging and all the EXT extensions that are subsets of it.
+ */
+void
+_mesa_enable_imaging_extensions(GLcontext *ctx)
+{
+   const char *extensions[] = {
+      "GL_ARB_imaging",
+      "GL_EXT_blend_color",
+      "GL_EXT_blend_minmax",
+      "GL_EXT_blend_subtract",
+      "GL_EXT_convolution",
+      "GL_EXT_histogram",
+      "GL_SGI_color_matrix",
+      "GL_SGI_color_table",
+      NULL
+   };
+   GLuint i;
+
+   for (i = 0; extensions[i]; i++) {
+      _mesa_enable_extension(ctx, extensions[i]);
+   }
+}
+
+
+
+/*
+ * Enable all OpenGL 1.3 features and extensions.
+ */
+void
+_mesa_enable_1_3_extensions(GLcontext *ctx)
 {
-   /* Update flags */
-   ctx->Extensions.HaveTextureEnvAdd = gl_extension_is_enabled(ctx, "GL_EXT_texture_env_add");
-   ctx->Extensions.HaveTextureEnvCombine = gl_extension_is_enabled(ctx, "GL_EXT_texture_env_combine");
-   ctx->Extensions.HaveTextureEnvDot3 = gl_extension_is_enabled(ctx, "GL_EXT_texture_env_dot3");
-   ctx->Extensions.HaveTextureLodBias = gl_extension_is_enabled(ctx, "GL_EXT_texture_lod_bias");
-   ctx->Extensions.HaveHpOcclusionTest = gl_extension_is_enabled(ctx, "GL_HP_occlusion_test");
-   ctx->Extensions.HaveTextureCubeMap = gl_extension_is_enabled(ctx, "GL_ARB_texture_cube_map");
-   ctx->Extensions.HaveTextureCompression = gl_extension_is_enabled(ctx, "GL_ARB_texture_compression");
-   ctx->Extensions.HaveTextureCompressionS3TC = gl_extension_is_enabled(ctx, "GL_EXT_texture_compression_s3tc");
-   ctx->Extensions.HaveTextureCompressionFXT1 = gl_extension_is_enabled(ctx, "GL_3DFX_texture_compression_FXT1");
-   ctx->Extensions.HaveBlendSquare = gl_extension_is_enabled(ctx, "GL_NV_blend_square");
+   const char *extensions[] = {
+      "GL_ARB_multisample",
+      "GL_ARB_multitexture",
+      "GL_ARB_texture_border_clamp",
+      "GL_ARB_texture_compression",
+      "GL_ARB_texture_cube_map",
+      "GL_ARB_texture_env_add",
+      "GL_ARB_texture_env_combine",
+      "GL_ARB_texture_env_dot3",
+      "GL_ARB_transpose_matrix",
+      NULL
+   };
+   GLuint i;
+
+   for (i = 0; extensions[i]; i++) {
+      _mesa_enable_extension(ctx, extensions[i]);
+   }
 }
 
 
 
-int gl_extensions_add( GLcontext *ctx,
-		       int state,
-		       const char *name,
-		       void (*notify)(void) )
+/*
+ * Add a new extenstion.  This would be called from a Mesa driver.
+ */
+void
+_mesa_add_extension( GLcontext *ctx,
+                     GLboolean enabled,
+                     const char *name,
+                     GLboolean *flag_ptr )
 {
-   (void) notify;
+   /* We should never try to add an extension after
+    * _mesa_extensions_get_string() has been called!
+    */
+   assert(ctx->Extensions.ext_string == 0);
 
-   if (ctx->Extensions.ext_string == 0)
    {
       struct extension *t = MALLOC_STRUCT(extension);
-      t->enabled = state;
+      t->enabled = enabled;
       strncpy(t->name, name, MAX_EXT_NAMELEN);
       t->name[MAX_EXT_NAMELEN] = 0;
-      t->notify = (void (*)(GLcontext *, GLboolean)) notify;
+      t->flag = flag_ptr;
+      if (t->flag)
+         *t->flag = enabled;
       insert_at_tail( ctx->Extensions.ext_list, t );
-      return 0;
    }
-   return 1;
 }
 
 
 /*
  * Either enable or disable the named extension.
  */
-static int set_extension( GLcontext *ctx, const char *name, GLint state )
+static void
+set_extension( GLcontext *ctx, const char *name, GLint state )
 {
+   /* XXX we should assert that ext_string is null.  We should never be
+    * enabling/disabling extensions after _mesa_extensions_get_string()
+    * has been called!
+    */
    struct extension *i;
    foreach( i, ctx->Extensions.ext_list )
       if (strncmp(i->name, name, MAX_EXT_NAMELEN) == 0)
 	 break;
-
-   if (i == ctx->Extensions.ext_list)
-      return 1;
 
-   if (!(i->enabled & ALWAYS_ENABLED)) {
-      if (i->notify) i->notify( ctx, state );
-      i->enabled = state;
+   if (i == ctx->Extensions.ext_list) {
+      /* this is an error.  Drivers should never try to enable/disable
+       * an extension which is unknown to Mesa or wasn't added by calling
+       * _mesa_add_extension().
+       */
+      return;
    }
 
-   update_extension_flags(ctx);
-
-   return 0;
+   if (i->flag)
+      *(i->flag) = state;
+   i->enabled = state;
 }
 
+
 
-int gl_extensions_enable( GLcontext *ctx, const char *name )
+void
+_mesa_enable_extension( GLcontext *ctx, const char *name )
 {
    if (ctx->Extensions.ext_string == 0)
-      return set_extension( ctx, name, 1 );
-   return 1;
+      set_extension( ctx, name, 1 );
 }
 
 
-int gl_extensions_disable( GLcontext *ctx, const char *name )
+void
+_mesa_disable_extension( GLcontext *ctx, const char *name )
 {
    if (ctx->Extensions.ext_string == 0)
-      return set_extension( ctx, name, 0 );
-   return 1;
+      set_extension( ctx, name, 0 );
 }
 
 
 /*
  * Test if the named extension is enabled in this context.
  */
-GLboolean gl_extension_is_enabled( GLcontext *ctx, const char *name)
+GLboolean
+_mesa_extension_is_enabled( GLcontext *ctx, const char *name)
 {
    struct extension *i;
    foreach( i, ctx->Extensions.ext_list )
@@ -196,7 +335,8 @@
 }
 
 
-void gl_extensions_dtr( GLcontext *ctx )
+void
+_mesa_extensions_dtr( GLcontext *ctx )
 {
    struct extension *i, *nexti;
 
@@ -217,25 +357,32 @@
 }
 
 
-void gl_extensions_ctr( GLcontext *ctx )
+void
+_mesa_extensions_ctr( GLcontext *ctx )
 {
    GLuint i;
+   GLboolean *base = (GLboolean *)&ctx->Extensions;
 
-   ctx->Extensions.ext_string = 0;
+   ctx->Extensions.ext_string = NULL;
    ctx->Extensions.ext_list = MALLOC_STRUCT(extension);
    make_empty_list( ctx->Extensions.ext_list );
 
    for (i = 0 ; i < Elements(default_extensions) ; i++) {
-      gl_extensions_add( ctx,
-			 default_extensions[i].enabled,
-			 default_extensions[i].name,
-			 0 );
+      GLboolean *ptr = NULL;
+
+      if (default_extensions[i].flag_offset)
+	 ptr = base + default_extensions[i].flag_offset;
+
+      (void) _mesa_add_extension( ctx,
+                                  default_extensions[i].enabled,
+                                  default_extensions[i].name,
+                                  ptr);
    }
-   update_extension_flags(ctx);
 }
 
 
-const char *gl_extensions_get_string( GLcontext *ctx )
+const char *
+_mesa_extensions_get_string( GLcontext *ctx )
 {
    if (ctx->Extensions.ext_string == 0)
    {
Index: xc/extras/Mesa/src/extensions.h
diff -u xc/extras/Mesa/src/extensions.h:1.4 xc/extras/Mesa/src/extensions.h:1.5
--- xc/extras/Mesa/src/extensions.h:1.4	Fri Jun 16 20:02:09 2000
+++ xc/extras/Mesa/src/extensions.h	Fri Feb 22 14:25:29 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -27,25 +27,28 @@
 #ifndef _EXTENSIONS_H_
 #define _EXTENSIONS_H_
 
-#include "types.h"
+#include "mtypes.h"
 
 
-#define DEFAULT_OFF    0x0
-#define DEFAULT_ON     0x1
-#define ALWAYS_ENABLED 0x2
+extern void _mesa_enable_sw_extensions(GLcontext *ctx);
 
-/* Return 0 on success.
- */
-extern int gl_extensions_add( GLcontext *ctx, int state, 
-			      const char *name, void (*notify)( void ) );
+extern void _mesa_enable_imaging_extensions(GLcontext *ctx);
 
-extern int gl_extensions_enable( GLcontext *ctx, const char *name );
-extern int gl_extensions_disable( GLcontext *ctx, const char *name );
-extern GLboolean gl_extension_is_enabled( GLcontext *ctx, const char *name);
-extern void gl_extensions_dtr( GLcontext *ctx );
-extern void gl_extensions_ctr( GLcontext *ctx );
-extern const char *gl_extensions_get_string( GLcontext *ctx );
+extern void _mesa_enable_1_3_extensions(GLcontext *ctx);
 
-#endif
+extern void _mesa_add_extension( GLcontext *ctx, GLboolean enabled,
+                                 const char *name, GLboolean *flag_ptr );
+
+extern void _mesa_enable_extension( GLcontext *ctx, const char *name );
+
+extern void _mesa_disable_extension( GLcontext *ctx, const char *name );
 
+extern GLboolean _mesa_extension_is_enabled( GLcontext *ctx, const char *name);
 
+extern void _mesa_extensions_dtr( GLcontext *ctx );
+
+extern void _mesa_extensions_ctr( GLcontext *ctx );
+
+extern const char *_mesa_extensions_get_string( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/feedback.c
diff -u xc/extras/Mesa/src/feedback.c:1.5 xc/extras/Mesa/src/feedback.c:1.6
--- xc/extras/Mesa/src/feedback.c:1.5	Mon Nov 13 18:30:45 2000
+++ xc/extras/Mesa/src/feedback.c	Fri Feb 22 14:25:29 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,13 +28,13 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "enums.h"
 #include "feedback.h"
 #include "macros.h"
 #include "mmath.h"
-#include "types.h"
-#include "triangle.h"
+#include "mtypes.h"
 #endif
 
 
@@ -51,68 +51,64 @@
 _mesa_FeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "glFeedbackBuffer" );
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (ctx->RenderMode==GL_FEEDBACK) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glFeedbackBuffer" );
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glFeedbackBuffer" );
       return;
    }
-
    if (size<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glFeedbackBuffer(size<0)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glFeedbackBuffer(size<0)" );
       return;
    }
    if (!buffer) {
-      gl_error( ctx, GL_INVALID_VALUE, "glFeedbackBuffer(buffer==NULL)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glFeedbackBuffer(buffer==NULL)" );
       ctx->Feedback.BufferSize = 0;
       return;
    }
 
    switch (type) {
       case GL_2D:
-	 ctx->Feedback.Mask = 0;
-         ctx->Feedback.Type = type;
+	 ctx->Feedback._Mask = 0;
 	 break;
       case GL_3D:
-	 ctx->Feedback.Mask = FB_3D;
-         ctx->Feedback.Type = type;
+	 ctx->Feedback._Mask = FB_3D;
 	 break;
       case GL_3D_COLOR:
-	 ctx->Feedback.Mask = FB_3D
-                           | (ctx->Visual->RGBAflag ? FB_COLOR : FB_INDEX);
-         ctx->Feedback.Type = type;
+	 ctx->Feedback._Mask = (FB_3D |
+				(ctx->Visual.rgbMode ? FB_COLOR : FB_INDEX));
 	 break;
       case GL_3D_COLOR_TEXTURE:
-	 ctx->Feedback.Mask = FB_3D
-                           | (ctx->Visual->RGBAflag ? FB_COLOR : FB_INDEX)
-	                   | FB_TEXTURE;
-         ctx->Feedback.Type = type;
+	 ctx->Feedback._Mask = (FB_3D |
+				(ctx->Visual.rgbMode ? FB_COLOR : FB_INDEX) |
+				FB_TEXTURE);
 	 break;
       case GL_4D_COLOR_TEXTURE:
-	 ctx->Feedback.Mask = FB_3D | FB_4D
-                           | (ctx->Visual->RGBAflag ? FB_COLOR : FB_INDEX)
-	                   | FB_TEXTURE;
-         ctx->Feedback.Type = type;
+	 ctx->Feedback._Mask = (FB_3D | FB_4D |
+				(ctx->Visual.rgbMode ? FB_COLOR : FB_INDEX) |
+				FB_TEXTURE);
 	 break;
       default:
-	 ctx->Feedback.Mask = 0;
-         gl_error( ctx, GL_INVALID_ENUM, "glFeedbackBuffer" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glFeedbackBuffer" );
+	 return;
    }
 
+   FLUSH_VERTICES(ctx, _NEW_RENDERMODE); /* Always flush */
+   ctx->Feedback.Type = type;
    ctx->Feedback.BufferSize = size;
    ctx->Feedback.Buffer = buffer;
-   ctx->Feedback.Count = 0;
+   ctx->Feedback.Count = 0;	              /* Becaues of this. */
 }
 
 
-
 void
 _mesa_PassThrough( GLfloat token )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPassThrough");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (ctx->RenderMode==GL_FEEDBACK) {
+      FLUSH_VERTICES(ctx, 0);
       FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN );
       FEEDBACK_TOKEN( ctx, token );
    }
@@ -123,30 +119,30 @@
 /*
  * Put a vertex into the feedback buffer.
  */
-void gl_feedback_vertex( GLcontext *ctx,
+void _mesa_feedback_vertex( GLcontext *ctx,
                          const GLfloat win[4],
-			 const GLfloat color[4], 
+			 const GLfloat color[4],
 			 GLuint index,
 			 const GLfloat texcoord[4] )
 {
    FEEDBACK_TOKEN( ctx, win[0] );
    FEEDBACK_TOKEN( ctx, win[1] );
-   if (ctx->Feedback.Mask & FB_3D) {
+   if (ctx->Feedback._Mask & FB_3D) {
       FEEDBACK_TOKEN( ctx, win[2] );
    }
-   if (ctx->Feedback.Mask & FB_4D) {
+   if (ctx->Feedback._Mask & FB_4D) {
       FEEDBACK_TOKEN( ctx, win[3] );
    }
-   if (ctx->Feedback.Mask & FB_INDEX) {
+   if (ctx->Feedback._Mask & FB_INDEX) {
       FEEDBACK_TOKEN( ctx, (GLfloat) index );
    }
-   if (ctx->Feedback.Mask & FB_COLOR) {
+   if (ctx->Feedback._Mask & FB_COLOR) {
       FEEDBACK_TOKEN( ctx, color[0] );
       FEEDBACK_TOKEN( ctx, color[1] );
       FEEDBACK_TOKEN( ctx, color[2] );
       FEEDBACK_TOKEN( ctx, color[3] );
    }
-   if (ctx->Feedback.Mask & FB_TEXTURE) {
+   if (ctx->Feedback._Mask & FB_TEXTURE) {
       FEEDBACK_TOKEN( ctx, texcoord[0] );
       FEEDBACK_TOKEN( ctx, texcoord[1] );
       FEEDBACK_TOKEN( ctx, texcoord[2] );
@@ -155,101 +151,6 @@
 }
 
 
-
-static void feedback_vertex( GLcontext *ctx, GLuint v, GLuint pv )
-{
-   GLfloat win[4];
-   GLfloat color[4];
-   GLfloat tc[4];
-   GLuint texUnit = ctx->Texture.CurrentTransformUnit;
-   const struct vertex_buffer *VB = ctx->VB;
-   GLuint index;
-
-   win[0] = VB->Win.data[v][0];
-   win[1] = VB->Win.data[v][1];
-   win[2] = VB->Win.data[v][2] / ctx->Visual->DepthMaxF;
-   win[3] = 1.0 / VB->Win.data[v][3];
-
-   if (ctx->Light.ShadeModel == GL_SMOOTH)
-      pv = v;
-
-   UBYTE_RGBA_TO_FLOAT_RGBA( color, VB->ColorPtr->data[pv] );
-
-   if (VB->TexCoordPtr[texUnit]->size == 4 &&     
-       VB->TexCoordPtr[texUnit]->data[v][3] != 0.0) {
-      GLfloat invq = 1.0F / VB->TexCoordPtr[texUnit]->data[v][3];
-      tc[0] = VB->TexCoordPtr[texUnit]->data[v][0] * invq;
-      tc[1] = VB->TexCoordPtr[texUnit]->data[v][1] * invq;
-      tc[2] = VB->TexCoordPtr[texUnit]->data[v][2] * invq;
-      tc[3] = VB->TexCoordPtr[texUnit]->data[v][3];
-   }
-   else {
-      ASSIGN_4V(tc, 0,0,0,1);
-      COPY_SZ_4V(tc, 
-		 VB->TexCoordPtr[texUnit]->size,
-		 VB->TexCoordPtr[texUnit]->data[v]);
-   }
-
-   if (VB->IndexPtr)
-      index = VB->IndexPtr->data[v];
-   else
-      index = 0;
-
-   gl_feedback_vertex( ctx, win, color, index, tc );
-}
-
-
-
-/*
- * Put triangle in feedback buffer.
- */
-void gl_feedback_triangle( GLcontext *ctx,
-			   GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   if (gl_cull_triangle( ctx, v0, v1, v2, 0 )) {
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN );
-      FEEDBACK_TOKEN( ctx, (GLfloat) 3 );        /* three vertices */
-      
-      feedback_vertex( ctx, v0, pv );
-      feedback_vertex( ctx, v1, pv );
-      feedback_vertex( ctx, v2, pv );
-   }
-}
-
-
-void gl_feedback_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv )
-{
-   GLenum token = GL_LINE_TOKEN;
-
-   if (ctx->StippleCounter==0) 
-      token = GL_LINE_RESET_TOKEN;
-
-   FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) token );
-
-   feedback_vertex( ctx, v1, pv );
-   feedback_vertex( ctx, v2, pv );
-
-   ctx->StippleCounter++;
-}
-
-
-void gl_feedback_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   const struct vertex_buffer *VB = ctx->VB;
-   GLuint i;
-
-   for (i=first;i<last;i++) {
-      if (VB->ClipMask[i]==0) {
-         FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POINT_TOKEN );
-	 feedback_vertex( ctx, i, i );
-      }
-   }
-}
-
-
-
-
-
 /**********************************************************************/
 /*                              Selection                             */
 /**********************************************************************/
@@ -262,14 +163,17 @@
 _mesa_SelectBuffer( GLsizei size, GLuint *buffer )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glSelectBuffer");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    if (ctx->RenderMode==GL_SELECT) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glSelectBuffer" );
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glSelectBuffer" );
+      return;			/* KW: added return */
    }
+
+   FLUSH_VERTICES(ctx, _NEW_RENDERMODE); /* why bother? */
    ctx->Select.Buffer = buffer;
    ctx->Select.BufferSize = size;
    ctx->Select.BufferCount = 0;
-
    ctx->Select.HitFlag = GL_FALSE;
    ctx->Select.HitMinZ = 1.0;
    ctx->Select.HitMaxZ = 0.0;
@@ -284,7 +188,7 @@
 
 
 
-void gl_update_hitflag( GLcontext *ctx, GLfloat z )
+void _mesa_update_hitflag( GLcontext *ctx, GLfloat z )
 {
    ctx->Select.HitFlag = GL_TRUE;
    if (z < ctx->Select.HitMinZ) {
@@ -295,44 +199,7 @@
    }
 }
 
-void gl_select_triangle( GLcontext *ctx,
-			 GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   const struct vertex_buffer *VB = ctx->VB;
-
-   if (gl_cull_triangle( ctx, v0, v1, v2, 0 )) {
-      const GLfloat zs = 1.0F / ctx->Visual->DepthMaxF;
-      gl_update_hitflag( ctx, VB->Win.data[v0][2] * zs );
-      gl_update_hitflag( ctx, VB->Win.data[v1][2] * zs );
-      gl_update_hitflag( ctx, VB->Win.data[v2][2] * zs );
-   }
-}
-
-
-void gl_select_line( GLcontext *ctx,
-		     GLuint v0, GLuint v1, GLuint pv )
-{
-   const struct vertex_buffer *VB = ctx->VB;
-   const GLfloat zs = 1.0F / ctx->Visual->DepthMaxF;
-   gl_update_hitflag( ctx, VB->Win.data[v0][2] * zs );
-   gl_update_hitflag( ctx, VB->Win.data[v1][2] * zs );
-}
-
 
-void gl_select_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   const GLfloat zs = 1.0F / ctx->Visual->DepthMaxF;
-   GLuint i;
-
-   for (i=first;i<=last;i++) {
-      if (VB->ClipMask[i]==0) {
-         gl_update_hitflag( ctx, VB->Win.data[i][2] * zs );
-      }
-   }
-}
-
-
 static void write_hit_record( GLcontext *ctx )
 {
    GLuint i;
@@ -364,7 +231,8 @@
 _mesa_InitNames( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glInitNames");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
    /* Record the hit before the HitFlag is wiped out again. */
    if (ctx->RenderMode == GL_SELECT) {
       if (ctx->Select.HitFlag) {
@@ -375,6 +243,7 @@
    ctx->Select.HitFlag = GL_FALSE;
    ctx->Select.HitMinZ = 1.0;
    ctx->Select.HitMaxZ = 0.0;
+   ctx->NewState |= _NEW_RENDERMODE;
 }
 
 
@@ -383,14 +252,18 @@
 _mesa_LoadName( GLuint name )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLoadName");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    if (ctx->RenderMode != GL_SELECT) {
       return;
    }
    if (ctx->Select.NameStackDepth == 0) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glLoadName" );
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glLoadName" );
       return;
    }
+
+   FLUSH_VERTICES(ctx, _NEW_RENDERMODE);
+
    if (ctx->Select.HitFlag) {
       write_hit_record( ctx );
    }
@@ -407,19 +280,21 @@
 _mesa_PushName( GLuint name )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPushName");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    if (ctx->RenderMode != GL_SELECT) {
       return;
    }
+
+   FLUSH_VERTICES(ctx, _NEW_RENDERMODE);
    if (ctx->Select.HitFlag) {
       write_hit_record( ctx );
-   }
-   if (ctx->Select.NameStackDepth < MAX_NAME_STACK_DEPTH) {
-      ctx->Select.NameStack[ctx->Select.NameStackDepth++] = name;
    }
-   else {
-      gl_error( ctx, GL_STACK_OVERFLOW, "glPushName" );
+   if (ctx->Select.NameStackDepth >= MAX_NAME_STACK_DEPTH) {
+      _mesa_error( ctx, GL_STACK_OVERFLOW, "glPushName" );
    }
+   else
+      ctx->Select.NameStack[ctx->Select.NameStackDepth++] = name;
 }
 
 
@@ -428,19 +303,21 @@
 _mesa_PopName( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPopName");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    if (ctx->RenderMode != GL_SELECT) {
       return;
    }
+
+   FLUSH_VERTICES(ctx, _NEW_RENDERMODE);
    if (ctx->Select.HitFlag) {
       write_hit_record( ctx );
    }
-   if (ctx->Select.NameStackDepth > 0) {
-      ctx->Select.NameStackDepth--;
-   }
-   else {
-      gl_error( ctx, GL_STACK_UNDERFLOW, "glPopName" );
+   if (ctx->Select.NameStackDepth == 0) {
+      _mesa_error( ctx, GL_STACK_UNDERFLOW, "glPopName" );
    }
+   else
+      ctx->Select.NameStackDepth--;
 }
 
 
@@ -459,13 +336,12 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint result;
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glRenderMode", 0);
-
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glRenderMode %s\n", gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glRenderMode %s\n", _mesa_lookup_enum_by_nr(mode));
 
-   ctx->TriangleCaps &= ~(DD_FEEDBACK|DD_SELECT);
+   FLUSH_VERTICES(ctx, _NEW_RENDERMODE);
 
    switch (ctx->RenderMode) {
       case GL_RENDER:
@@ -478,7 +354,7 @@
 	 if (ctx->Select.BufferCount > ctx->Select.BufferSize) {
 	    /* overflow */
 #ifdef DEBUG
-            gl_warning(ctx, "Feedback buffer overflow");
+            _mesa_warning(ctx, "Feedback buffer overflow");
 #endif
 	    result = -1;
 	 }
@@ -500,7 +376,7 @@
 	 ctx->Feedback.Count = 0;
 	 break;
       default:
-	 gl_error( ctx, GL_INVALID_ENUM, "glRenderMode" );
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glRenderMode" );
 	 return 0;
    }
 
@@ -508,27 +384,25 @@
       case GL_RENDER:
          break;
       case GL_SELECT:
-	 ctx->TriangleCaps |= DD_SELECT;
 	 if (ctx->Select.BufferSize==0) {
 	    /* haven't called glSelectBuffer yet */
-	    gl_error( ctx, GL_INVALID_OPERATION, "glRenderMode" );
+	    _mesa_error( ctx, GL_INVALID_OPERATION, "glRenderMode" );
 	 }
 	 break;
       case GL_FEEDBACK:
-	 ctx->TriangleCaps |= DD_FEEDBACK;
 	 if (ctx->Feedback.BufferSize==0) {
 	    /* haven't called glFeedbackBuffer yet */
-	    gl_error( ctx, GL_INVALID_OPERATION, "glRenderMode" );
+	    _mesa_error( ctx, GL_INVALID_OPERATION, "glRenderMode" );
 	 }
 	 break;
       default:
-	 gl_error( ctx, GL_INVALID_ENUM, "glRenderMode" );
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glRenderMode" );
 	 return 0;
    }
 
    ctx->RenderMode = mode;
-   ctx->NewState |= NEW_ALL;
+   if (ctx->Driver.RenderMode)
+      ctx->Driver.RenderMode( ctx, mode );
 
    return result;
 }
-
Index: xc/extras/Mesa/src/feedback.h
diff -u xc/extras/Mesa/src/feedback.h:1.3 xc/extras/Mesa/src/feedback.h:1.4
--- xc/extras/Mesa/src/feedback.h:1.3	Tue Feb 15 02:12:14 2000
+++ xc/extras/Mesa/src/feedback.h	Fri Feb 22 14:25:29 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define FEEDBACK_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 #define FEEDBACK_TOKEN( CTX, T )				\
@@ -38,14 +38,14 @@
 	CTX->Feedback.Count++;
 
 
-extern void gl_feedback_vertex( GLcontext *ctx,
+extern void _mesa_feedback_vertex( GLcontext *ctx,
                                 const GLfloat win[4],
-                                const GLfloat color[4], 
+                                const GLfloat color[4],
 				GLuint index,
                                 const GLfloat texcoord[4] );
 
 
-extern void gl_update_hitflag( GLcontext *ctx, GLfloat z );
+extern void _mesa_update_hitflag( GLcontext *ctx, GLfloat z );
 
 
 extern void
@@ -73,15 +73,4 @@
 _mesa_RenderMode( GLenum mode );
 
 
-extern void gl_feedback_points( GLcontext *ctx, GLuint first, GLuint last );
-extern void gl_feedback_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv );
-extern void gl_feedback_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				  GLuint v2, GLuint pv );
-
-extern void gl_select_points( GLcontext *ctx, GLuint first, GLuint last );
-extern void gl_select_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv );
-extern void gl_select_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				GLuint v2, GLuint pv );
-
 #endif
-
Index: xc/extras/Mesa/src/fixed.h
diff -u xc/extras/Mesa/src/fixed.h:1.4 xc/extras/Mesa/src/fixed.h:removed
--- xc/extras/Mesa/src/fixed.h:1.4	Fri Jun 16 20:02:09 2000
+++ xc/extras/Mesa/src/fixed.h	Thu Feb 27 12:15:36 2003
@@ -1,52 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef FIXED_H
-#define FIXED_H
-
-
-typedef int GLfixed;
-
-#define FIXED_ONE       0x00000800
-#define FIXED_HALF      0x00000400
-#define FIXED_FRAC_MASK 0x000007FF
-#define FIXED_INT_MASK  (~FIXED_FRAC_MASK)
-#define FIXED_EPSILON   1
-#define FIXED_SCALE     2048.0f
-#define FIXED_SHIFT     11
-#define FloatToFixed(X) ((GLfixed) ((X) * FIXED_SCALE))
-#define IntToFixed(I)   ((I) << FIXED_SHIFT)
-#define FixedToInt(X)   ((X) >> FIXED_SHIFT)
-#define FixedToUns(X)   (((unsigned int)(X)) >> 11)
-#define FixedCeil(X)    (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK)
-#define FixedFloor(X)   ((X) & FIXED_INT_MASK)
-/* 0.00048828125 = 1/FIXED_SCALE */
-#define FixedToFloat(X) ((X) * 0.00048828125f)
-#define PosFloatToFixed(X)      FloatToFixed(X)
-#define SignedFloatToFixed(X)   FloatToFixed(X)
-
-
-#endif
Index: xc/extras/Mesa/src/fog.c
diff -u xc/extras/Mesa/src/fog.c:1.10 xc/extras/Mesa/src/fog.c:1.11
--- xc/extras/Mesa/src/fog.c:1.10	Mon Nov 13 18:30:46 2000
+++ xc/extras/Mesa/src/fog.c	Fri Feb 22 14:25:29 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,12 +28,10 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "fog.h"
-#include "macros.h"
-#include "mmath.h"
-#include "types.h"
-#include "xform.h"
+#include "mtypes.h"
 #endif
 
 
@@ -63,6 +61,7 @@
       case GL_FOG_START:
       case GL_FOG_END:
       case GL_FOG_INDEX:
+      case GL_FOG_COORDINATE_SOURCE_EXT:
 	 p[0] = (GLfloat) *params;
 	 break;
       case GL_FOG_COLOR:
@@ -79,350 +78,86 @@
 }
 
 
-void 
+void
 _mesa_Fogfv( GLenum pname, const GLfloat *params )
 {
    GET_CURRENT_CONTEXT(ctx);
    GLenum m;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFog");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (pname) {
       case GL_FOG_MODE:
          m = (GLenum) (GLint) *params;
-	 if (m==GL_LINEAR || m==GL_EXP || m==GL_EXP2) {
-	    ctx->Fog.Mode = m;
-	 }
-	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glFog" );
+	 switch (m) {
+	 case GL_LINEAR:
+	 case GL_EXP:
+	 case GL_EXP2:
+	    break;
+	 default:
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glFog" );
             return;
 	 }
+	 if (ctx->Fog.Mode == m)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+	 ctx->Fog.Mode = m;
 	 break;
       case GL_FOG_DENSITY:
 	 if (*params<0.0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glFog" );
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glFog" );
             return;
 	 }
-	 else {
-	    ctx->Fog.Density = *params;
-	 }
+	 if (ctx->Fog.Density == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+	 ctx->Fog.Density = *params;
 	 break;
       case GL_FOG_START:
+	 if (ctx->Fog.Start == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
 	 ctx->Fog.Start = *params;
 	 break;
       case GL_FOG_END:
+	 if (ctx->Fog.End == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
 	 ctx->Fog.End = *params;
 	 break;
       case GL_FOG_INDEX:
-	 ctx->Fog.Index = *params;
+ 	 if (ctx->Fog.Index == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+ 	 ctx->Fog.Index = *params;
 	 break;
       case GL_FOG_COLOR:
+	 if (TEST_EQ_4V(ctx->Fog.Color, params))
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
 	 ctx->Fog.Color[0] = params[0];
 	 ctx->Fog.Color[1] = params[1];
 	 ctx->Fog.Color[2] = params[2];
 	 ctx->Fog.Color[3] = params[3];
          break;
+      case GL_FOG_COORDINATE_SOURCE_EXT: {
+	 GLenum p = (GLenum) (GLint) *params;
+         if (!ctx->Extensions.EXT_fog_coord ||
+             (p != GL_FOG_COORDINATE_EXT && p != GL_FRAGMENT_DEPTH_EXT)) {
+	    _mesa_error(ctx, GL_INVALID_ENUM, "glFog");
+	    return;
+	 }
+	 if (ctx->Fog.FogCoordinateSource == p)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+	 ctx->Fog.FogCoordinateSource = p;
+	 break;
+      }
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glFog" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glFog" );
          return;
    }
 
    if (ctx->Driver.Fogfv) {
       (*ctx->Driver.Fogfv)( ctx, pname, params );
-   }
-
-   ctx->NewState |= NEW_FOG;
-}
-
-
-typedef void (*fog_func)( struct vertex_buffer *VB, GLuint side, 
-			  GLubyte flag );
-
-typedef void (*fog_coord_func)( struct vertex_buffer *VB, 
-				const GLvector4f *from,
-				GLubyte flag );
-
-static fog_func fog_ci_tab[2];
-static fog_func fog_rgba_tab[2];
-static fog_coord_func make_fog_coord_tab[2];
-
-/*
- * Compute the fogged color for an array of vertices.
- * Input:  n - number of vertices
- *         v - array of vertices
- *         color - the original vertex colors
- * Output:  color - the fogged colors
- * 
- */
-#define TAG(x) x##_raw
-#define CULLCHECK
-#define IDX 0
-#include "fog_tmp.h"
-
-#define TAG(x) x##_masked
-#define CULLCHECK if (cullmask[i]&flag)
-#define IDX 1
-#include "fog_tmp.h"
-
-
-void
-_mesa_init_fog( void )
-{
-   init_fog_tab_masked();
-   init_fog_tab_raw();
-}
-
-
-/*
- * Compute fog for the vertices in the vertex buffer.
- */
-void
-_mesa_fog_vertices( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint i = VB->CullMode & 1;
-
-   if (ctx->Visual->RGBAflag) {
-      /* Fog RGB colors */
-      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	 fog_rgba_tab[i]( VB, 0, VERT_FACE_FRONT );
-	 fog_rgba_tab[i]( VB, 1, VERT_FACE_REAR );
-      } else {
-	 fog_rgba_tab[i]( VB, 0, VERT_FACE_FRONT|VERT_FACE_REAR );
-      }
-   }
-   else {
-      /* Fog color indexes */
-      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	 fog_ci_tab[i]( VB, 0, VERT_FACE_FRONT );
-         fog_ci_tab[i]( VB, 1, VERT_FACE_REAR );
-      } else {
-	 fog_ci_tab[i]( VB, 0, VERT_FACE_FRONT|VERT_FACE_REAR );
-      }
-   }
-}
-
-
-static void check_fog_coords( GLcontext *ctx, struct gl_pipeline_stage *d )
-{
-   d->type = 0;
-
-   if (ctx->FogMode==FOG_FRAGMENT)
-   {
-      d->type = PIPE_IMMEDIATE|PIPE_PRECALC;
-      d->inputs = VERT_OBJ_ANY;
-      d->outputs = VERT_FOG_COORD;
-   }
-}
-
-
-static void gl_make_fog_coords( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-
-   /* If full eye coords weren't required, just calculate the eye Z
-    * values.  
-    */
-   if (!ctx->NeedEyeCoords) {
-      GLfloat *m = ctx->ModelView.m;
-      GLfloat plane[4];
-
-      plane[0] = m[2];
-      plane[1] = m[6];
-      plane[2] = m[10];
-      plane[3] = m[14];
-
-      gl_dotprod_tab[0][VB->ObjPtr->size](&VB->Eye,
-					  2, /* fill z coordinates */
-					  VB->ObjPtr,
-					  plane,
-					  0 );
-
-      make_fog_coord_tab[0]( VB, &VB->Eye, 0 );
-   }
-   else
-   {
-      make_fog_coord_tab[0]( VB, VB->EyePtr, 0 );
-   }
-}
-
-
-/* Drivers that want fog coordinates in VB->Spec[0] alpha, can substitute this
- * stage for the default PIPE_OP_FOG pipeline stage.
- */
-struct gl_pipeline_stage gl_fog_coord_stage = {
-   "build fog coordinates",
-   PIPE_OP_FOG,
-   PIPE_PRECALC|PIPE_IMMEDIATE,
-   0,
-   NEW_FOG,
-   NEW_LIGHTING|NEW_RASTER_OPS|NEW_FOG|NEW_MODELVIEW,
-   0, 0,
-   0, 0, 0,
-   check_fog_coords,
-   gl_make_fog_coords 
-};
-
-
-
-
-
-/*
- * Apply fog to an array of RGBA pixels.
- * Input:  n - number of pixels
- *         z - array of integer depth values
- *         red, green, blue, alpha - pixel colors
- * Output:  red, green, blue, alpha - fogged pixel colors
- */
-void
-_mesa_fog_rgba_pixels( const GLcontext *ctx,
-                       GLuint n, const GLdepth z[], GLubyte rgba[][4] )
-{
-   GLfloat c = ctx->ProjectionMatrix.m[10];
-   GLfloat d = ctx->ProjectionMatrix.m[14];
-   GLuint i;
-
-   GLfloat rFog = ctx->Fog.Color[0] * 255.0F;
-   GLfloat gFog = ctx->Fog.Color[1] * 255.0F;
-   GLfloat bFog = ctx->Fog.Color[2] * 255.0F;
-
-   GLfloat tz = ctx->Viewport.WindowMap.m[MAT_TZ];
-   GLfloat szInv = 1.0F / ctx->Viewport.WindowMap.m[MAT_SZ];
-
-   switch (ctx->Fog.Mode) {
-      case GL_LINEAR:
-         {
-            GLfloat fogEnd = ctx->Fog.End;
-            GLfloat fogScale = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-            for (i=0;i<n;i++) {
-               GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
-               GLfloat eyez = -d / (c+ndcz);
-               GLfloat f, g;
-               if (eyez < 0.0)  eyez = -eyez;
-               f = (fogEnd - eyez) * fogScale;
-               f = CLAMP( f, 0.0F, 1.0F );
-               g = 1.0F - f;
-               rgba[i][RCOMP] = (GLint) (f * rgba[i][RCOMP] + g * rFog);
-               rgba[i][GCOMP] = (GLint) (f * rgba[i][GCOMP] + g * gFog);
-               rgba[i][BCOMP] = (GLint) (f * rgba[i][BCOMP] + g * bFog);
-            }
-         }
-	 break;
-      case GL_EXP:
-	 for (i=0;i<n;i++) {
-	    GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
-	    GLfloat eyez = d / (c+ndcz);
-            GLfloat f, g;
-	    if (eyez < 0.0)
-               eyez = -eyez;
-	    f = exp( -ctx->Fog.Density * eyez );
-            g = 1.0F - f;
-            rgba[i][RCOMP] = (GLint) (f * rgba[i][RCOMP] + g * rFog);
-            rgba[i][GCOMP] = (GLint) (f * rgba[i][GCOMP] + g * gFog);
-            rgba[i][BCOMP] = (GLint) (f * rgba[i][BCOMP] + g * bFog);
-	 }
-	 break;
-      case GL_EXP2:
-         {
-            GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density;
-            for (i=0;i<n;i++) {
-               GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
-               GLfloat eyez = d / (c+ndcz);
-               GLfloat f, g;
-               GLfloat tmp = negDensitySquared * eyez * eyez;
-#if defined(__alpha__) || defined(__alpha)
-               /* XXX this underflow check may be needed for other systems */
-               if (tmp < FLT_MIN_10_EXP)
-                  f = exp( FLT_MIN_10_EXP );
-               else
-#endif
-                  f = exp( tmp );
-               g = 1.0F - f;
-               rgba[i][RCOMP] = (GLint) (f * rgba[i][RCOMP] + g * rFog);
-               rgba[i][GCOMP] = (GLint) (f * rgba[i][GCOMP] + g * gFog);
-               rgba[i][BCOMP] = (GLint) (f * rgba[i][BCOMP] + g * bFog);
-            }
-         }
-	 break;
-      default:
-         gl_problem(ctx, "Bad fog mode in _mesa_fog_rgba_pixels");
-         return;
-   }
-}
-
-
-
-
-/*
- * Apply fog to an array of color index pixels.
- * Input:  n - number of pixels
- *         z - array of integer depth values
- *         index - pixel color indexes
- * Output:  index - fogged pixel color indexes
- */
-void
-_mesa_fog_ci_pixels( const GLcontext *ctx,
-                     GLuint n, const GLdepth z[], GLuint index[] )
-{
-   GLfloat c = ctx->ProjectionMatrix.m[10];
-   GLfloat d = ctx->ProjectionMatrix.m[14];
-   GLuint i;
-
-   GLfloat tz = ctx->Viewport.WindowMap.m[MAT_TZ];
-   GLfloat szInv = 1.0F / ctx->Viewport.WindowMap.m[MAT_SZ];
-
-   switch (ctx->Fog.Mode) {
-      case GL_LINEAR:
-         {
-            GLfloat fogEnd = ctx->Fog.End;
-            GLfloat fogScale = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-            for (i=0;i<n;i++) {
-               GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
-               GLfloat eyez = -d / (c+ndcz);
-               GLfloat f;
-               if (eyez < 0.0)  eyez = -eyez;
-               f = (fogEnd - eyez) * fogScale;
-               f = CLAMP( f, 0.0F, 1.0F );
-               index[i] = (GLuint) ((GLfloat) index[i] + (1.0F-f) * ctx->Fog.Index);
-            }
-	 }
-	 break;
-      case GL_EXP:
-         for (i=0;i<n;i++) {
-	    GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
-	    GLfloat eyez = -d / (c+ndcz);
-            GLfloat f;
-	    if (eyez < 0.0)
-               eyez = -eyez;
-	    f = exp( -ctx->Fog.Density * eyez );
-	    f = CLAMP( f, 0.0F, 1.0F );
-	    index[i] = (GLuint) ((GLfloat) index[i] + (1.0F-f) * ctx->Fog.Index);
-	 }
-	 break;
-      case GL_EXP2:
-         {
-            GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density;
-            for (i=0;i<n;i++) {
-               GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
-               GLfloat eyez = -d / (c+ndcz);
-               GLfloat tmp, f;
-               if (eyez < 0.0)
-                  eyez = -eyez;
-               tmp = negDensitySquared * eyez * eyez;
-#if defined(__alpha__) || defined(__alpha)
-               /* XXX this underflow check may be needed for other systems */
-               if (tmp < FLT_MIN_10_EXP)
-                  f = exp( FLT_MIN_10_EXP );
-               else
-#endif
-               f = exp( tmp );
-               f = CLAMP( f, 0.0F, 1.0F );
-               index[i] = (GLuint) ((GLfloat) index[i] + (1.0F-f) * ctx->Fog.Index);
-            }
-	 }
-	 break;
-      default:
-         gl_problem(ctx, "Bad fog mode in _mesa_fog_ci_pixels");
-         return;
    }
 }
Index: xc/extras/Mesa/src/fog.h
diff -u xc/extras/Mesa/src/fog.h:1.4 xc/extras/Mesa/src/fog.h:1.5
--- xc/extras/Mesa/src/fog.h:1.4	Fri Jun 16 20:02:10 2000
+++ xc/extras/Mesa/src/fog.h	Fri Feb 22 14:25:29 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,12 +28,10 @@
 #define FOG_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
-extern struct gl_pipeline_stage gl_fog_coord_stage;
 
-
 extern void
 _mesa_Fogf(GLenum pname, GLfloat param);
 
@@ -48,24 +46,6 @@
 
 extern void
 _mesa_Fogiv(GLenum pname, const GLint *params );
-
-
-
-extern void
-_mesa_fog_vertices( struct vertex_buffer *VB );
-
-extern void
-_mesa_fog_rgba_pixels( const GLcontext *ctx,
-                       GLuint n, const GLdepth z[],
-                       GLubyte rgba[][4] );
-
-extern void
-_mesa_fog_ci_pixels( const GLcontext *ctx,
-                     GLuint n, const GLdepth z[], GLuint indx[] );
-
-
-extern void
-_mesa_init_fog( void );
 
 
 #endif
Index: xc/extras/Mesa/src/fog_tmp.h
diff -u xc/extras/Mesa/src/fog_tmp.h:1.7 xc/extras/Mesa/src/fog_tmp.h:removed
--- xc/extras/Mesa/src/fog_tmp.h:1.7	Fri May 18 12:59:53 2001
+++ xc/extras/Mesa/src/fog_tmp.h	Thu Feb 27 12:15:37 2003
@@ -1,449 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/* For 3.2: Add a helper function for drivers to do fog coordinate
- * calculation.  Not called from standard pipelines.  
- */
-static void TAG(make_fog_coord)( struct vertex_buffer *VB,
-				 const GLvector4f *eye,
-				 GLubyte flag)
-{
-   const GLcontext *ctx = VB->ctx;
-   GLfloat end  = ctx->Fog.End;
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-   GLfloat *v = eye->start;
-   GLuint stride = eye->stride;
-   GLuint n = VB->Count - VB->Start;
-   GLubyte (*out)[4];		
-   GLfloat d;
-   GLuint i;
-
-   (void) cullmask;
-   (void) flag;
-
-   /* Use specular alpha (front side) as fog coordinate.
-    */
-   out = VB->Spec[0] + VB->Start;
-
-   if (VB->EyePtr->size > 2) {
-      switch (ctx->Fog.Mode) {
-      case GL_LINEAR:
-	 d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-	 for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
-	    CULLCHECK {
-	       GLfloat f = (end - ABSF(v[2])) * d;
-	       FLOAT_COLOR_TO_UBYTE_COLOR(out[i][3], f);
-	    }
-	 }
-	 break;
-      case GL_EXP:
-	 d = -ctx->Fog.Density;
-	 for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride)) {
-	    CULLCHECK {
-	       GLfloat f = exp( d*ABSF(v[2]) ); /* already clamped */ 
-	       FLOAT_COLOR_TO_UBYTE_COLOR(out[i][3], f);
-	    }
-	 }
-	 break;
-      case GL_EXP2:
-	 d = -(ctx->Fog.Density*ctx->Fog.Density);
-	 for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
-	    CULLCHECK {
-	       GLfloat z = v[2];
-	       GLfloat f = exp( d*z*z ); /* already clamped */
-	       FLOAT_COLOR_TO_UBYTE_COLOR(out[i][3], f);
-	    }
-	 }
-	 break;
-      default:
-	 gl_problem(ctx, "Bad fog mode in make_fog_coord");
-	 return;
-      }
-   }
-   else 
-   {
-      GLubyte r = 255;
-
-      if (ctx->Fog.Mode == GL_LINEAR) {
-	 GLfloat f = 1.0 - ctx->Fog.End / (ctx->Fog.End - ctx->Fog.Start);
-	 CLAMP_FLOAT_COLOR( f );
-	 FLOAT_COLOR_TO_UBYTE_COLOR(r, f);
-      } 
-
-      for (i = 0 ; i < n ; i++) 
-	 out[i][3] = r;
-   }
-}
-
-
-
-
-
-#if 0
-/* TODO : use fog coordinates as intermediate step in all fog
- * calculations.
- */
-
-static void TAG(fog_rgba_vertices)( struct vertex_buffer *VB,
-				    GLuint side,
-				    GLubyte flag)
-{
-   const GLcontext *ctx = VB->ctx;
-   const GLubyte rFog = ctx->Fog.ByteColor[0];
-   const GLubyte gFog = ctx->Fog.ByteColor[1];
-   const GLubyte bFog = ctx->Fog.ByteColor[2];
-   GLfloat end  = ctx->Fog.End;
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-   GLubyte (*fcoord)[4] = VB->SpecPtr[0]->start;
-   GLuint stride = VB->SpecPtr[0]->stride;
-   GLuint n = VB->Count - VB->Start;
-   GLubyte *in;
-   GLuint in_stride;
-   GLubyte (*out)[4];
-   GLfloat d,t;
-   GLuint i;
-
-   (void) cullmask;
-   (void) flag;
-
-   /* Get correct source and destination for fogged colors.
-    */
-   in_stride = VB->Color[side]->stride;
-   in = VB->Color[side]->start;
-   VB->Color[side] = VB->FoggedColor[side];
-   VB->ColorPtr = VB->Color[0];
-   out = (GLubyte (*)[4])VB->Color[side]->start;
-
-   FLOAT_COLOR_TO_UBYTE_COLOR( rFog, ctx->Fog.Color[0] );
-
-   for ( i = 0 ; i < n ; i++, STRIDE_F(spec, sp_stride), in += in_stride) {
-      CULLCHECK {
-	 GLint fc = (GLint) spec[3], ifc = 255 - fc;
-	 
-	 out[i][0] = (fc * in[0] + ifc * rFog) >> 8;
-	 out[i][1] = (fc * in[1] + ifc * gFog) >> 8;
-	 out[i][2] = (fc * in[2] + ifc * bFog) >> 8;
-      }
-   }
-}
-
-
-
-static void TAG(fog_ci_vertices)( struct vertex_buffer *VB,
-				  GLuint side,
-				  GLubyte flag )
-{
-   GLcontext *ctx = VB->ctx;
-
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-  
-   GLfloat *v = VB->EyePtr->start;
-   GLuint stride = VB->EyePtr->stride;
-   GLuint vertex_size = VB->EyePtr->size;
-   GLuint n = VB->EyePtr->count;
-
-   GLuint *in;
-   GLuint in_stride;
-   GLuint *out;
-   GLuint i;
-
-   (void) flag;
-   (void) cullmask;
-
-
-   in = VB->Index[side]->start;
-   in_stride = VB->Index[side]->stride;
-   VB->IndexPtr = VB->FoggedIndex[side];
-   out = VB->IndexPtr->start;
-
-   /* NOTE: the use of casts generates better/faster code for MIPS */
-   for ( i = 0; i < n ; i++, STRIDE_F(v,stride), STRIDE_UI(in,in_stride))
-      CULLCHECK {
-      GLfloat f = (fogend - ABSF(v[2])) * d;
-      f = CLAMP( f, 0.0, 1.0 );
-      *out = (GLint) ((GLfloat)(GLint) *in + (1.0F-f) * fogindex);
-   }
-}
-
-#endif
-
-
-
-
-static void TAG(fog_rgba_vertices)( struct vertex_buffer *VB,
-				    GLuint side,
-				    GLubyte flag)
-{
-   const GLcontext *ctx = VB->ctx;
-   GLfloat rFog = ctx->Fog.Color[0];
-   GLfloat gFog = ctx->Fog.Color[1];
-   GLfloat bFog = ctx->Fog.Color[2];
-   GLfloat end  = ctx->Fog.End;
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-   GLfloat *v = VB->EyePtr->start;
-   GLuint stride = VB->EyePtr->stride;
-   GLuint n = VB->EyePtr->count;
-   GLubyte *in;
-   GLuint in_stride;
-   GLubyte (*out)[4];
-   GLfloat d,t;
-   GLuint i;
-
-   (void) cullmask;
-   (void) flag;
-
-   /* Get correct source and destination for fogged colors.
-    */
-   in_stride = VB->Color[side]->stride;
-   in = VB->Color[side]->start;
-   VB->Color[side] = VB->FoggedColor[side];
-   VB->ColorPtr = VB->Color[0];
-   out = (GLubyte (*)[4])VB->Color[side]->start;
-
-   if (VB->EyePtr->size > 2) {
-      switch (ctx->Fog.Mode) {
-      case GL_LINEAR:
-	 d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-	 for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride), in += in_stride) {
-	    CULLCHECK {
-	       GLfloat f = (end - ABSF(v[2])) * d;
-               if (f >= 1.0) {
-                  out[i][0] = in[0];
-                  out[i][1] = in[1];
-                  out[i][2] = in[2];
-               }
-	       else if (f <= 0.0) {
-		  CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][0], rFog);
-		  CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][1], gFog);
-		  CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][2], bFog);
-	       }
-               else {
-		  t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[0]) + (1.0F-f)*rFog;
-		  CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][0], t);
-	       
-		  t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[1]) + (1.0F-f)*gFog;
-		  CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][1], t);
-	       
-		  t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[2]) + (1.0F-f)*bFog;
-		  CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][2], t);
-
-	       }
-               out[i][3] = in[3];
-	    }
-	 }
-	 break;
-      case GL_EXP:
-	 d = -ctx->Fog.Density;
-	 for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride), in += in_stride) {
-	    CULLCHECK {
-	       GLfloat f = exp( d*ABSF(v[2]) ); /* already clamped */ 
-
-	       t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[0]) + (1.0F-f)*rFog;
-	       CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][0], t);
-	       
-	       t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[1]) + (1.0F-f)*gFog;
-	       CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][1], t);
-	       
-	       t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[2]) + (1.0F-f)*bFog;
-	       CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][2], t);
-	    }
-            out[i][3] = in[3];
-	 }
-	 break;
-      case GL_EXP2:
-	 d = -(ctx->Fog.Density*ctx->Fog.Density);
-	 for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride), in += in_stride) {
-	    CULLCHECK {
-	       GLfloat z = v[2];
-	       GLfloat f = exp( d*z*z ); /* already clamped */
-
-	       t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[0]) + (1.0F-f)*rFog;
-	       CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][0], t);
-	       
-	       t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[1]) + (1.0F-f)*gFog;
-	       CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][1], t);
-	       
-	       t = f * UBYTE_COLOR_TO_FLOAT_COLOR(in[2]) + (1.0F-f)*bFog;
-	       CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(out[i][2], t);
-	    }
-            out[i][3] = in[3];
-	 }
-	 break;
-	 default:
-	    gl_problem(ctx, "Bad fog mode in gl_fog_rgba_vertices");
-	 return;
-      }
-   }
-   else {
-      /* All vertex Z coordinates are zero */
-      if (ctx->Fog.Mode == GL_LINEAR) {
-         /* 2-vector vertices */
-         GLubyte r,g,b;
-         GLfloat f = ctx->Fog.End * (ctx->Fog.End - ctx->Fog.Start);
-         CLAMP_FLOAT_COLOR( f );
-         f = 1.0 - f;
-         rFog *= f;
-         bFog *= f;
-         gFog *= f;
-
-         CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(r, rFog);
-         CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(g, gFog);
-         CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(b, bFog);
-
-         for (i = 0 ; i < n ; i++) {
-            /* CULLCHECK */ {
-               out[i][0] = r;
-               out[i][1] = g;
-               out[i][2] = b;
-            }
-         }
-      }
-      else {
-         /* EXP or EXP2 mode */
-         /* f = exp(d*z*z) or f = exp(d*|z|) is one.  Copy in color to out */
-	 for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride), in += in_stride) {
-            /* CULLCHECK */ {
-               out[i][0] = in[0];
-               out[i][1] = in[1];
-               out[i][2] = in[2];
-            }
-         }
-      }
-   }
-}
-
-
-
-/*
- * Compute the fogged color indexes for an array of vertices.
- * Input:  n - number of vertices
- *         v - array of vertices
- * In/Out: indx - array of vertex color indexes
- */
-static void TAG(fog_ci_vertices)( struct vertex_buffer *VB,
-				  GLuint side,
-				  GLubyte flag )
-{
-   GLcontext *ctx = VB->ctx;
-
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-  
-   GLfloat *v = VB->EyePtr->start;
-   GLuint stride = VB->EyePtr->stride;
-   GLuint vertex_size = VB->EyePtr->size;
-   GLuint n = VB->EyePtr->count;
-
-   GLuint *in;
-   GLuint in_stride;
-   GLuint *out;
-   GLuint i;
-
-   (void) flag;
-   (void) cullmask;
-
-   in = VB->Index[side]->start;
-   in_stride = VB->Index[side]->stride;
-   VB->Index[side] = VB->FoggedIndex[side];
-   VB->IndexPtr = VB->Index[0];
-   out = (GLuint *)VB->Index[side]->start;
-
-   /* NOTE: the extensive use of casts generates better/faster code for MIPS */
-   if (vertex_size > 2) {
-      switch (ctx->Fog.Mode) {
-      case GL_LINEAR:
-      {
-	 GLfloat d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
-	 GLfloat fogindex = ctx->Fog.Index;
-	 GLfloat fogend = ctx->Fog.End;
-
- 	 for ( i = 0; i < n ; i++, STRIDE_F(v,stride), STRIDE_UI(in,in_stride))
-	 {
-	    CULLCHECK {
-	       GLfloat f = (fogend - ABSF(v[2])) * d;
-	       f = CLAMP( f, 0.0, 1.0 );
-	       out[i] = (GLint) ((GLfloat)(GLint) *in + (1.0F-f) * fogindex);
-	    }
-	 }
-	 break;
-      }
-      case GL_EXP:
-      {
-	 GLfloat d = -ctx->Fog.Density;
-	 GLfloat fogindex = ctx->Fog.Index;
- 	 for ( i = 0; i < n ; i++, STRIDE_F(v,stride), STRIDE_UI(in,in_stride))
-	 {
-	    CULLCHECK {
-	       GLfloat f = exp( d * ABSF(v[2]) );
-	       out[i] = (GLint) ((GLfloat)(GLint) *in + (1.0F-f) * fogindex);
-	    }
-	 }
-	 break;
-      }
-      case GL_EXP2:
-      {
-	 GLfloat d = -(ctx->Fog.Density*ctx->Fog.Density);
-	 GLfloat fogindex = ctx->Fog.Index;
- 	 for ( i = 0; i < n ; i++, STRIDE_F(v,stride),STRIDE_UI(in,in_stride))
-	 {
-	    CULLCHECK {
-	       GLfloat z = v[2]; /*ABSF(v[i][2]);*/
-	       GLfloat f = exp( d * z*z ); /* was -d ??? */
-	       out[i] = (GLint) ((GLfloat)(GLint) *in + (1.0F-f) * fogindex);
-	    }
-	 }
-	 break;
-      }
-      default:
-	 gl_problem(ctx, "Bad fog mode in gl_fog_ci_vertices");
-	 return;
-      }
-   }
-   else if (ctx->Fog.Mode == GL_LINEAR) {
-      GLuint fogindex;
-      GLfloat f = ctx->Fog.End / (ctx->Fog.End - ctx->Fog.Start);
-
-      f = 1.0 - CLAMP( f, 0.0F, 1.0F );
-      fogindex = (GLuint)(f * ctx->Fog.Index);
-      if (fogindex) {
- 	 for ( i = 0; i < n ; i++, STRIDE_F(v,stride), STRIDE_UI(in,in_stride))
-	 {
-	    CULLCHECK {
-	       out[i] = *in + fogindex;
-	    }
-	 }
-      }
-   } 
-}
-
-static void TAG(init_fog_tab)(void)
-{
-   fog_ci_tab[IDX] = TAG(fog_ci_vertices);
-   fog_rgba_tab[IDX] = TAG(fog_rgba_vertices);
-   make_fog_coord_tab[IDX] = TAG(make_fog_coord);
-}
-
-#undef TAG
-#undef CULLCHECK
-#undef IDX
Index: xc/extras/Mesa/src/general_clip.h
diff -u xc/extras/Mesa/src/general_clip.h:1.4 xc/extras/Mesa/src/general_clip.h:removed
--- xc/extras/Mesa/src/general_clip.h:1.4	Fri Jun 16 20:02:10 2000
+++ xc/extras/Mesa/src/general_clip.h	Thu Feb 27 12:15:37 2003
@@ -1,83 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#define PLANE CLIP_RIGHT_BIT
-#define CLIP_DOTPROD(K) (- X(K) + W(K))
-
-   GENERAL_CLIP
-
-#undef CLIP_DOTPROD
-#undef PLANE
-
-
-#define PLANE CLIP_LEFT_BIT
-#define CLIP_DOTPROD(K) (X(K) + W(K))
-
-   GENERAL_CLIP
-
-#undef CLIP_DOTPROD
-#undef PLANE
-
-#define PLANE CLIP_TOP_BIT
-#define CLIP_DOTPROD(K) (- Y(K) + W(K))
-
-   GENERAL_CLIP
-
-#undef CLIP_DOTPROD
-#undef PLANE
-
-#define PLANE CLIP_BOTTOM_BIT
-#define CLIP_DOTPROD(K) (Y(K) + W(K))
-
-   GENERAL_CLIP
-
-#undef CLIP_DOTPROD
-#undef PLANE
-
-#define PLANE CLIP_FAR_BIT
-#define CLIP_DOTPROD(K) (- Z(K) + W(K))
-
-   if (SIZE >= 3) { 
-      GENERAL_CLIP
-   }
-
-#undef CLIP_DOTPROD
-#undef PLANE
-
-#define PLANE CLIP_NEAR_BIT
-#define CLIP_DOTPROD(K) (Z(K) + W(K))
-
-   if (SIZE >=3 ) { 
-      GENERAL_CLIP
-   }
-
-#undef CLIP_DOTPROD
-#undef PLANE
-#undef GENERAL_CLIP
Index: xc/extras/Mesa/src/get.c
diff -u xc/extras/Mesa/src/get.c:1.12 xc/extras/Mesa/src/get.c:1.17
--- xc/extras/Mesa/src/get.c:1.12	Fri May 18 12:59:53 2001
+++ xc/extras/Mesa/src/get.c	Mon Dec 16 11:18:26 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4.2
- * 
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,16 +28,17 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "enable.h"
 #include "enums.h"
 #include "extensions.h"
 #include "get.h"
 #include "macros.h"
-#include "matrix.h"
 #include "mmath.h"
-#include "types.h"
-#include "vb.h"
+#include "mtypes.h"
+
+#include "math/m_matrix.h"
 #endif
 
 
@@ -57,6 +58,43 @@
 #endif
 
 
+
+/* Check if named extension is enabled, if not generate error and return */
+
+#define CHECK_EXTENSION_B(EXTNAME, PNAME)			\
+   if (!ctx->Extensions.EXTNAME) {				\
+      char message[100];					\
+      sprintf(message, "glGetBooleanv(0x%x)", (int) PNAME);	\
+      _mesa_error(ctx, GL_INVALID_VALUE, message);		\
+      return;							\
+   }	
+
+#define CHECK_EXTENSION_I(EXTNAME, PNAME)			\
+   if (!ctx->Extensions.EXTNAME) {				\
+      char message[100];					\
+      sprintf(message, "glGetIntegerv(0x%x)", (int) PNAME);	\
+      _mesa_error(ctx, GL_INVALID_VALUE, message);		\
+      return;							\
+   }	
+
+#define CHECK_EXTENSION_F(EXTNAME, PNAME)			\
+   if (!ctx->Extensions.EXTNAME) {				\
+      char message[100];					\
+      sprintf(message, "glGetFloatv(0x%x)", (int) PNAME);	\
+      _mesa_error(ctx, GL_INVALID_VALUE, message);		\
+      return;							\
+   }	
+
+#define CHECK_EXTENSION_D(EXTNAME, PNAME)			\
+   if (!ctx->Extensions.EXTNAME) {				\
+      char message[100];					\
+      sprintf(message, "glGetDoublev(0x%x)", (int) PNAME);	\
+      _mesa_error(ctx, GL_INVALID_VALUE, message);		\
+      return;							\
+   }	
+
+
+
 static GLenum
 pixel_texgen_mode(const GLcontext *ctx)
 {
@@ -79,40 +117,42 @@
 }
 
 
-
 void
 _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 {
    GET_CURRENT_CONTEXT(ctx);
    GLuint i;
    GLuint texUnit = ctx->Texture.CurrentUnit;
-   GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetBooleanv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (!params)
       return;
 
-   if (MESA_VERBOSE & VERBOSE_API) 
-      fprintf(stderr, "glGetBooleanv %s\n", gl_lookup_enum_by_nr(pname));
+   /* We need this in order to get correct results for
+    * GL_OCCLUSION_TEST_RESULT_HP.  There might be other important cases.
+    */
+   FLUSH_VERTICES(ctx, 0);
 
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glGetBooleanv %s\n", _mesa_lookup_enum_by_nr(pname));
+
    if (ctx->Driver.GetBooleanv
        && (*ctx->Driver.GetBooleanv)(ctx, pname, params))
       return;
 
    switch (pname) {
       case GL_ACCUM_RED_BITS:
-         *params = INT_TO_BOOL(ctx->Visual->AccumRedBits);
+         *params = INT_TO_BOOL(ctx->Visual.accumRedBits);
          break;
       case GL_ACCUM_GREEN_BITS:
-         *params = INT_TO_BOOL(ctx->Visual->AccumGreenBits);
+         *params = INT_TO_BOOL(ctx->Visual.accumGreenBits);
          break;
       case GL_ACCUM_BLUE_BITS:
-         *params = INT_TO_BOOL(ctx->Visual->AccumBlueBits);
+         *params = INT_TO_BOOL(ctx->Visual.accumBlueBits);
          break;
       case GL_ACCUM_ALPHA_BITS:
-         *params = INT_TO_BOOL(ctx->Visual->AccumAlphaBits);
+         *params = INT_TO_BOOL(ctx->Visual.accumAlphaBits);
          break;
       case GL_ACCUM_CLEAR_VALUE:
          params[0] = FLOAT_TO_BOOL(ctx->Accum.ClearColor[0]);
@@ -124,7 +164,7 @@
          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaBias);
          break;
       case GL_ALPHA_BITS:
-         *params = INT_TO_BOOL(ctx->Visual->AlphaBits);
+         *params = INT_TO_BOOL(ctx->Visual.alphaBits);
          break;
       case GL_ALPHA_SCALE:
          *params = FLOAT_TO_BOOL(ctx->Pixel.AlphaScale);
@@ -136,7 +176,7 @@
          *params = ENUM_TO_BOOL(ctx->Color.AlphaFunc);
          break;
       case GL_ALPHA_TEST_REF:
-         *params = FLOAT_TO_BOOL((GLfloat) ctx->Color.AlphaRef / 255.0);
+         *params = FLOAT_TO_BOOL((GLfloat) ctx->Color.AlphaRef / CHAN_MAXF);
          break;
       case GL_ATTRIB_STACK_DEPTH:
          *params = INT_TO_BOOL(ctx->AttribStackDepth);
@@ -181,7 +221,7 @@
          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueBias);
          break;
       case GL_BLUE_BITS:
-         *params = INT_TO_BOOL( ctx->Visual->BlueBits );
+         *params = INT_TO_BOOL( ctx->Visual.blueBits );
          break;
       case GL_BLUE_SCALE:
          *params = FLOAT_TO_BOOL(ctx->Pixel.BlueScale);
@@ -198,10 +238,10 @@
          *params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = FLOAT_TO_BOOL(ctx->Color.ClearColor[0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Color.ClearColor[1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Color.ClearColor[2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Color.ClearColor[3]);
+         params[0] = ctx->Color.ClearColor[0] ? GL_TRUE : GL_FALSE;
+         params[1] = ctx->Color.ClearColor[1] ? GL_TRUE : GL_FALSE;
+         params[2] = ctx->Color.ClearColor[2] ? GL_TRUE : GL_FALSE;
+         params[3] = ctx->Color.ClearColor[3] ? GL_TRUE : GL_FALSE;
          break;
       case GL_COLOR_MATERIAL:
          *params = ctx->Light.ColorMaterialEnabled;
@@ -225,15 +265,18 @@
          *params = ENUM_TO_BOOL(ctx->Polygon.CullFaceMode);
          break;
       case GL_CURRENT_COLOR:
-         params[0] = INT_TO_BOOL(ctx->Current.ByteColor[0]);
-         params[1] = INT_TO_BOOL(ctx->Current.ByteColor[1]);
-         params[2] = INT_TO_BOOL(ctx->Current.ByteColor[2]);
-         params[3] = INT_TO_BOOL(ctx->Current.ByteColor[3]);
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Color[0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Color[1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Color[2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.Color[3]);
          break;
       case GL_CURRENT_INDEX:
+	 FLUSH_CURRENT(ctx, 0);
          *params = INT_TO_BOOL(ctx->Current.Index);
          break;
       case GL_CURRENT_NORMAL:
+	 FLUSH_CURRENT(ctx, 0);
          params[0] = FLOAT_TO_BOOL(ctx->Current.Normal[0]);
          params[1] = FLOAT_TO_BOOL(ctx->Current.Normal[1]);
          params[2] = FLOAT_TO_BOOL(ctx->Current.Normal[2]);
@@ -257,25 +300,26 @@
 	 params[3] = FLOAT_TO_BOOL(ctx->Current.RasterPos[3]);
 	 break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-         params[0] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texTransformUnit][3]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][3]);
 	 break;
       case GL_CURRENT_RASTER_POSITION_VALID:
          *params = ctx->Current.RasterPosValid;
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
-         params[0] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texTransformUnit][3]);
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][3]);
 	 break;
       case GL_DEPTH_BIAS:
          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias);
 	 break;
       case GL_DEPTH_BITS:
-	 *params = INT_TO_BOOL(ctx->Visual->DepthBits);
+	 *params = INT_TO_BOOL(ctx->Visual.depthBits);
 	 break;
       case GL_DEPTH_CLEAR_VALUE:
          *params = FLOAT_TO_BOOL(ctx->Depth.Clear);
@@ -300,12 +344,13 @@
 	 *params = ctx->Color.DitherFlag;
 	 break;
       case GL_DOUBLEBUFFER:
-	 *params = ctx->Visual->DBflag;
+	 *params = ctx->Visual.doubleBufferMode;
 	 break;
       case GL_DRAW_BUFFER:
 	 *params = ENUM_TO_BOOL(ctx->Color.DrawBuffer);
 	 break;
       case GL_EDGE_FLAG:
+	 FLUSH_CURRENT(ctx, 0);
 	 *params = ctx->Current.EdgeFlag;
 	 break;
       case GL_FEEDBACK_BUFFER_SIZE:
@@ -348,22 +393,28 @@
          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenBias);
 	 break;
       case GL_GREEN_BITS:
-         *params = INT_TO_BOOL( ctx->Visual->GreenBits );
+         *params = INT_TO_BOOL( ctx->Visual.greenBits );
 	 break;
       case GL_GREEN_SCALE:
          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale);
 	 break;
       case GL_HISTOGRAM:
-         *params = ctx->Pixel.HistogramEnabled;
+         if (ctx->Extensions.EXT_histogram) {
+            *params = ctx->Pixel.HistogramEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
 	 break;
       case GL_INDEX_BITS:
-         *params = INT_TO_BOOL( ctx->Visual->IndexBits );
+         *params = INT_TO_BOOL( ctx->Visual.indexBits );
 	 break;
       case GL_INDEX_CLEAR_VALUE:
 	 *params = INT_TO_BOOL(ctx->Color.ClearIndex);
 	 break;
       case GL_INDEX_MODE:
-	 *params = ctx->Visual->RGBAflag ? GL_FALSE : GL_TRUE;
+	 *params = ctx->Visual.rgbMode ? GL_FALSE : GL_TRUE;
 	 break;
       case GL_INDEX_OFFSET:
 	 *params = INT_TO_BOOL(ctx->Pixel.IndexOffset);
@@ -537,19 +588,19 @@
          *params = INT_TO_BOOL( MAX_CLIENT_ATTRIB_STACK_DEPTH);
          break;
       case GL_MAX_CLIP_PLANES:
-	 *params = INT_TO_BOOL(MAX_CLIP_PLANES);
+	 *params = INT_TO_BOOL(ctx->Const.MaxClipPlanes);
 	 break;
       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
-         *params = INT_TO_BOOL(VB_MAX);
+         *params = INT_TO_BOOL(ctx->Const.MaxArrayLockSize);
          break;
       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
-         *params = INT_TO_BOOL(VB_MAX);
+         *params = INT_TO_BOOL(ctx->Const.MaxArrayLockSize);
          break;
       case GL_MAX_EVAL_ORDER:
 	 *params = INT_TO_BOOL(MAX_EVAL_ORDER);
 	 break;
       case GL_MAX_LIGHTS:
-	 *params = INT_TO_BOOL(MAX_LIGHTS);
+	 *params = INT_TO_BOOL(ctx->Const.MaxLights);
 	 break;
       case GL_MAX_LIST_NESTING:
 	 *params = INT_TO_BOOL(MAX_LIST_NESTING);
@@ -567,8 +618,10 @@
 	 *params = INT_TO_BOOL(MAX_PROJECTION_STACK_DEPTH);
 	 break;
       case GL_MAX_TEXTURE_SIZE:
+         *params = INT_TO_BOOL(1 << (ctx->Const.MaxTextureLevels - 1));
+	 break;
       case GL_MAX_3D_TEXTURE_SIZE:
-         *params = INT_TO_BOOL(ctx->Const.MaxTextureSize);
+         *params = INT_TO_BOOL(1 << (ctx->Const.Max3DTextureLevels - 1));
 	 break;
       case GL_MAX_TEXTURE_STACK_DEPTH:
 	 *params = INT_TO_BOOL(MAX_TEXTURE_STACK_DEPTH);
@@ -618,6 +671,9 @@
       case GL_PACK_IMAGE_HEIGHT_EXT:
          *params = ctx->Pack.ImageHeight;
          break;
+      case GL_PACK_INVERT_MESA:
+         *params = ctx->Pack.Invert;
+         break;
       case GL_PERSPECTIVE_CORRECTION_HINT:
 	 *params = ENUM_TO_BOOL(ctx->Hint.PerspectiveCorrection);
 	 break;
@@ -652,7 +708,7 @@
 	 *params = INT_TO_BOOL(ctx->Pixel.MapStoSsize);
 	 break;
       case GL_POINT_SIZE:
-	 *params = FLOAT_TO_BOOL(ctx->Point.UserSize);
+	 *params = FLOAT_TO_BOOL(ctx->Point.Size);
 	 break;
       case GL_POINT_SIZE_GRANULARITY:
 	 *params = FLOAT_TO_BOOL(ctx->Const.PointSizeGranularity );
@@ -722,7 +778,7 @@
          *params = FLOAT_TO_BOOL(ctx->Pixel.RedBias);
 	 break;
       case GL_RED_BITS:
-         *params = INT_TO_BOOL( ctx->Visual->RedBits );
+         *params = INT_TO_BOOL( ctx->Visual.redBits );
 	 break;
       case GL_RED_SCALE:
          *params = FLOAT_TO_BOOL(ctx->Pixel.RedScale);
@@ -734,7 +790,7 @@
          *params = ctx->Transform.RescaleNormals;
          break;
       case GL_RGBA_MODE:
-         *params = ctx->Visual->RGBAflag;
+         *params = ctx->Visual.rgbMode;
 	 break;
       case GL_SCISSOR_BOX:
 	 params[0] = INT_TO_BOOL(ctx->Scissor.X);
@@ -755,7 +811,7 @@
          *params = ctx->Texture.SharedPalette;
          break;
       case GL_STENCIL_BITS:
-	 *params = INT_TO_BOOL(ctx->Visual->StencilBits);
+	 *params = INT_TO_BOOL(ctx->Visual.stencilBits);
 	 break;
       case GL_STENCIL_CLEAR_VALUE:
 	 *params = INT_TO_BOOL(ctx->Stencil.Clear);
@@ -785,7 +841,7 @@
 	 *params = INT_TO_BOOL(ctx->Stencil.WriteMask);
 	 break;
       case GL_STEREO:
-	 *params = ctx->Visual->StereoFlag;
+	 *params = ctx->Visual.stereoMode;
 	 break;
       case GL_SUBPIXEL_BITS:
 	 *params = INT_TO_BOOL(ctx->Const.SubPixelBits);
@@ -800,13 +856,13 @@
          *params = _mesa_IsEnabled(GL_TEXTURE_3D);
 	 break;
       case GL_TEXTURE_BINDING_1D:
-         *params = INT_TO_BOOL(textureUnit->CurrentD[1]->Name);
+         *params = INT_TO_BOOL(textureUnit->Current1D->Name);
           break;
       case GL_TEXTURE_BINDING_2D:
-         *params = INT_TO_BOOL(textureUnit->CurrentD[2]->Name);
+         *params = INT_TO_BOOL(textureUnit->Current2D->Name);
           break;
       case GL_TEXTURE_BINDING_3D:
-         *params = INT_TO_BOOL(textureUnit->CurrentD[3]->Name);
+         *params = INT_TO_BOOL(textureUnit->Current3D->Name);
          break;
       case GL_TEXTURE_ENV_COLOR:
          {
@@ -833,12 +889,12 @@
 	 break;
       case GL_TEXTURE_MATRIX:
 	 for (i=0;i<16;i++) {
-	    params[i] = 
-	       FLOAT_TO_BOOL(ctx->TextureMatrix[texTransformUnit].m[i]);
+	    params[i] =
+	       FLOAT_TO_BOOL(ctx->TextureMatrix[texUnit].m[i]);
 	 }
 	 break;
       case GL_TEXTURE_STACK_DEPTH:
-	 *params = INT_TO_BOOL(ctx->TextureStackDepth[texTransformUnit] + 1);
+	 *params = INT_TO_BOOL(ctx->TextureStackDepth[texUnit] + 1);
 	 break;
       case GL_UNPACK_ALIGNMENT:
 	 *params = INT_TO_BOOL(ctx->Unpack.Alignment);
@@ -864,6 +920,9 @@
       case GL_UNPACK_IMAGE_HEIGHT_EXT:
          *params = ctx->Unpack.ImageHeight;
          break;
+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
+         *params = ctx->Unpack.ClientStorage;
+         break;
       case GL_VIEWPORT:
 	 params[0] = INT_TO_BOOL(ctx->Viewport.X);
 	 params[1] = INT_TO_BOOL(ctx->Viewport.Y);
@@ -877,160 +936,83 @@
 	 *params = FLOAT_TO_BOOL(ctx->Pixel.ZoomY);
 	 break;
       case GL_VERTEX_ARRAY:
-#ifdef VAO
-         *params = ctx->Array.Current->Vertex.Enabled;
-#else
          *params = ctx->Array.Vertex.Enabled;
-#endif
          break;
       case GL_VERTEX_ARRAY_SIZE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->Vertex.Size);
-#else
          *params = INT_TO_BOOL(ctx->Array.Vertex.Size);
-#endif
          break;
       case GL_VERTEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_BOOL(ctx->Array.Current->Vertex.Type);
-#else
          *params = ENUM_TO_BOOL(ctx->Array.Vertex.Type);
-#endif
          break;
       case GL_VERTEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->Vertex.Stride);
-#else
          *params = INT_TO_BOOL(ctx->Array.Vertex.Stride);
-#endif
          break;
       case GL_VERTEX_ARRAY_COUNT_EXT:
          *params = INT_TO_BOOL(0);
          break;
       case GL_NORMAL_ARRAY:
-#ifdef VAO
-         *params = ctx->Array.Current->Normal.Enabled;
-#else
          *params = ctx->Array.Normal.Enabled;
-#endif
          break;
       case GL_NORMAL_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_BOOL(ctx->Array.Current->Normal.Type);
-#else
          *params = ENUM_TO_BOOL(ctx->Array.Normal.Type);
-#endif
          break;
       case GL_NORMAL_ARRAY_STRIDE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->Normal.Stride);
-#else
          *params = INT_TO_BOOL(ctx->Array.Normal.Stride);
-#endif
          break;
       case GL_NORMAL_ARRAY_COUNT_EXT:
          *params = INT_TO_BOOL(0);
          break;
       case GL_COLOR_ARRAY:
-#ifdef VAO
-         *params = ctx->Array.Current->Color.Enabled;
-#else
          *params = ctx->Array.Color.Enabled;
-#endif
          break;
       case GL_COLOR_ARRAY_SIZE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->Color.Size);
-#else
          *params = INT_TO_BOOL(ctx->Array.Color.Size);
-#endif
          break;
       case GL_COLOR_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_BOOL(ctx->Array.Current->Color.Type);
-#else
          *params = ENUM_TO_BOOL(ctx->Array.Color.Type);
-#endif
          break;
       case GL_COLOR_ARRAY_STRIDE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->Color.Stride);
-#else
          *params = INT_TO_BOOL(ctx->Array.Color.Stride);
-#endif
          break;
       case GL_COLOR_ARRAY_COUNT_EXT:
          *params = INT_TO_BOOL(0);
          break;
       case GL_INDEX_ARRAY:
-#ifdef VAO
-         *params = ctx->Array.Current->Index.Enabled;
-#else
          *params = ctx->Array.Index.Enabled;
-#endif
          break;
       case GL_INDEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_BOOL(ctx->Array.Current->Index.Type);
-#else
          *params = ENUM_TO_BOOL(ctx->Array.Index.Type);
-#endif
          break;
       case GL_INDEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->Index.Stride);
-#else
          *params = INT_TO_BOOL(ctx->Array.Index.Stride);
-#endif
          break;
       case GL_INDEX_ARRAY_COUNT_EXT:
          *params = INT_TO_BOOL(0);
          break;
       case GL_TEXTURE_COORD_ARRAY:
-#ifdef VAO
-         *params = ctx->Array.Current->TexCoord[texUnit].Enabled;
-#else
          *params = ctx->Array.TexCoord[texUnit].Enabled;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_SIZE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->TexCoord[texUnit].Size);
-#else
          *params = INT_TO_BOOL(ctx->Array.TexCoord[texUnit].Size);
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_BOOL(ctx->Array.Current->TexCoord[texUnit].Type);
-#else
          *params = ENUM_TO_BOOL(ctx->Array.TexCoord[texUnit].Type);
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_STRIDE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->TexCoord[texUnit].Stride);
-#else
          *params = INT_TO_BOOL(ctx->Array.TexCoord[texUnit].Stride);
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
          *params = INT_TO_BOOL(0);
          break;
       case GL_EDGE_FLAG_ARRAY:
-#ifdef VAO
-         *params = ctx->Array.Current->EdgeFlag.Enabled;
-#else
          *params = ctx->Array.EdgeFlag.Enabled;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_STRIDE:
-#ifdef VAO
-         *params = INT_TO_BOOL(ctx->Array.Current->EdgeFlag.Stride);
-#else
          *params = INT_TO_BOOL(ctx->Array.EdgeFlag.Stride);
-#endif
          break;
+      case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
+         *params = INT_TO_BOOL(0);
+         break;
 
       /* GL_ARB_multitexture */
       case GL_MAX_TEXTURE_UNITS_ARB:
@@ -1045,113 +1027,55 @@
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          return;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = INT_TO_BOOL(textureUnit->CurrentCubeMap->Name);
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          return;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
-            *params = INT_TO_BOOL(ctx->Const.MaxCubeTextureSize);
+         if (ctx->Extensions.ARB_texture_cube_map)
+            *params = INT_TO_BOOL(1 << (ctx->Const.MaxCubeTextureLevels - 1));
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = INT_TO_BOOL(ctx->Hint.TextureCompression);
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = INT_TO_BOOL(ctx->Const.NumCompressedTextureFormats);
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = INT_TO_BOOL(ctx->Const.CompressedTextureFormats[i]);
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-         break;
-
-      /* GL_PGI_misc_hints */
-      case GL_STRICT_DEPTHFUNC_HINT_PGI:
-	 *params = ENUM_TO_BOOL(GL_NICEST);
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          break;
-      case GL_STRICT_LIGHTING_HINT_PGI:
-	 *params = ENUM_TO_BOOL(ctx->Hint.StrictLighting);
-	 break;
-      case GL_STRICT_SCISSOR_HINT_PGI:
-      case GL_FULL_STIPPLE_HINT_PGI:
-	 *params = ENUM_TO_BOOL(GL_TRUE);
-	 break;
-      case GL_CONSERVE_MEMORY_HINT_PGI:
-	 *params = ENUM_TO_BOOL(GL_FALSE);
-	 break;
-      case GL_ALWAYS_FAST_HINT_PGI:
-	 *params = (GLboolean) (ctx->Hint.AllowDrawWin == GL_TRUE &&
-			      ctx->Hint.AllowDrawFrg == GL_FALSE && 
-			      ctx->Hint.AllowDrawMem == GL_FALSE);
-	 break;
-      case GL_ALWAYS_SOFT_HINT_PGI:
-	 *params = (GLboolean) (ctx->Hint.AllowDrawWin == GL_TRUE &&
-			      ctx->Hint.AllowDrawFrg == GL_TRUE && 
-			      ctx->Hint.AllowDrawMem == GL_TRUE);
-	 break;
-      case GL_ALLOW_DRAW_OBJ_HINT_PGI:
-	 *params = (GLboolean) GL_TRUE;
-	 break;
-      case GL_ALLOW_DRAW_WIN_HINT_PGI:
-	 *params = (GLboolean) ctx->Hint.AllowDrawWin;
-	 break;
-      case GL_ALLOW_DRAW_FRG_HINT_PGI:
-	 *params = (GLboolean) ctx->Hint.AllowDrawFrg;
-	 break;
-      case GL_ALLOW_DRAW_MEM_HINT_PGI:
-	 *params = (GLboolean) ctx->Hint.AllowDrawMem;
-	 break;
-      case GL_CLIP_NEAR_HINT_PGI:
-      case GL_CLIP_FAR_HINT_PGI:
-	 *params = ENUM_TO_BOOL(GL_TRUE);
-	 break;
-      case GL_WIDE_LINE_HINT_PGI:
-	 *params = ENUM_TO_BOOL(GL_DONT_CARE);
-	 break;
-      case GL_BACK_NORMALS_HINT_PGI:
-	 *params = ENUM_TO_BOOL(GL_TRUE);
-	 break;
-      case GL_NATIVE_GRAPHICS_HANDLE_PGI:
-	 *params = 0;
-	 break;
 
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-#ifdef VAO
-	 *params = ctx->Array.Current->LockFirst ? GL_TRUE : GL_FALSE;
-#else
 	 *params = ctx->Array.LockFirst ? GL_TRUE : GL_FALSE;
-#endif
 	 break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-#ifdef VAO
-	 *params = ctx->Array.Current->LockCount ? GL_TRUE : GL_FALSE;
-#else
 	 *params = ctx->Array.LockCount ? GL_TRUE : GL_FALSE;
-#endif
 	 break;
 
       /* GL_ARB_transpose_matrix */
@@ -1159,7 +1083,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ColorMatrix.m);
+            _math_transposef(tm, ctx->ColorMatrix.m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1169,7 +1093,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ModelView.m);
+            _math_transposef(tm, ctx->ModelView.m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1179,7 +1103,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ProjectionMatrix.m);
+            _math_transposef(tm, ctx->ProjectionMatrix.m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1189,7 +1113,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
+            _math_transposef(tm, ctx->TextureMatrix[texUnit].m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1198,15 +1122,15 @@
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             *params = ctx->Depth.OcclusionTest;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
          }
          return;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             if (ctx->Depth.OcclusionTest)
                *params = ctx->OcclusionResult;
             else
@@ -1216,7 +1140,7 @@
             ctx->OcclusionResultSaved = GL_FALSE;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
          }
          return;
 
@@ -1271,11 +1195,32 @@
          break;
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
-      case GL_MAX_CONVOLUTION_WIDTH:
-         *params = INT_TO_BOOL(ctx->Const.MaxConvolutionWidth);
+      case GL_CONVOLUTION_1D_EXT:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = ctx->Pixel.Convolution1DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_CONVOLUTION_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = ctx->Pixel.Convolution2DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
          break;
-      case GL_MAX_CONVOLUTION_HEIGHT:
-         *params = INT_TO_BOOL(ctx->Const.MaxConvolutionHeight);
+      case GL_SEPARABLE_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = ctx->Pixel.Separable2DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[0]);
@@ -1313,46 +1258,211 @@
          *params = ctx->Pixel.PostColorMatrixColorTableEnabled;
          break;
 
+      /* GL_EXT_secondary_color */
+      case GL_COLOR_SUM_EXT:
+	 *params = ctx->Fog.ColorSumEnabled;
+	 break;
+      case GL_CURRENT_SECONDARY_COLOR_EXT:
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = INT_TO_BOOL(ctx->Current.SecondaryColor[0]);
+         params[1] = INT_TO_BOOL(ctx->Current.SecondaryColor[1]);
+         params[2] = INT_TO_BOOL(ctx->Current.SecondaryColor[2]);
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         *params = ctx->Array.SecondaryColor.Enabled;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+	 *params = ENUM_TO_BOOL(ctx->Array.SecondaryColor.Type);
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+	 *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Stride);
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+	 *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Stride);
+	 break;
+
+      /* GL_EXT_fog_coord */
+      case GL_CURRENT_FOG_COORDINATE_EXT:
+	 FLUSH_CURRENT(ctx, 0);
+	 *params = FLOAT_TO_BOOL(ctx->Current.FogCoord);
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+         *params = ctx->Array.FogCoord.Enabled;
+         break;
+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+	 *params = ENUM_TO_BOOL(ctx->Array.FogCoord.Type);
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+	 *params = INT_TO_BOOL(ctx->Array.FogCoord.Stride);
+	 break;
+
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureLodBias);
+         break;
+
+      /* GL_EXT_texture_filter_anisotropic */
+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+	    *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureMaxAnisotropy);
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
+            return;
+         }
+	 break;
+
+      /* GL_ARB_multisample */
+      case GL_MULTISAMPLE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = ctx->Multisample.Enabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = ctx->Multisample.SampleAlphaToCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = ctx->Multisample.SampleAlphaToOne;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = ctx->Multisample.SampleCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = FLOAT_TO_BOOL(ctx->Multisample.SampleCoverageValue);
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = ctx->Multisample.SampleCoverageInvert;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_BUFFERS_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0; /* XXX fix someday */
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+      case GL_SAMPLES_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0; /* XXX fix someday */
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+            return;
+         }
+         break;
+
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         if (ctx->Extensions.IBM_rasterpos_clip) {
+            *params = ctx->Transform.RasterPositionUnclipped;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBoolean");
+            return;
+         }
+         break;
+
+      /* GL_SGIS_generate_mipmap */
+      case GL_GENERATE_MIPMAP_HINT_SGIS:
+         if (ctx->Extensions.SGIS_generate_mipmap) {
+            *params = ENUM_TO_BOOL(ctx->Hint.GenerateMipmap);
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+	    return;
+         }
+         break;
+
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_B(NV_texture_rectangle, pname);
+         *params = _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_B(NV_texture_rectangle, pname);
+         *params = INT_TO_BOOL(textureUnit->CurrentRect->Name);
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_B(NV_texture_rectangle, pname);
+         *params = INT_TO_BOOL(ctx->Const.MaxTextureRectSize);
+         break;
+
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
    }
 }
 
 
-
-
 void
 _mesa_GetDoublev( GLenum pname, GLdouble *params )
 {
    GET_CURRENT_CONTEXT(ctx);
    GLuint i;
    GLuint texUnit = ctx->Texture.CurrentUnit;
-   GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetDoublev");
-
    if (!params)
       return;
+
+   /* We need this in order to get correct results for
+    * GL_OCCLUSION_TEST_RESULT_HP.  There might be other important cases.
+    */
+   FLUSH_VERTICES(ctx, 0);
 
-   if (MESA_VERBOSE & VERBOSE_API) 
-      fprintf(stderr, "glGetDoublev %s\n", gl_lookup_enum_by_nr(pname));
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glGetDoublev %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetDoublev && (*ctx->Driver.GetDoublev)(ctx, pname, params))
       return;
 
    switch (pname) {
       case GL_ACCUM_RED_BITS:
-         *params = (GLdouble) ctx->Visual->AccumRedBits;
+         *params = (GLdouble) ctx->Visual.accumRedBits;
          break;
       case GL_ACCUM_GREEN_BITS:
-         *params = (GLdouble) ctx->Visual->AccumGreenBits;
+         *params = (GLdouble) ctx->Visual.accumGreenBits;
          break;
       case GL_ACCUM_BLUE_BITS:
-         *params = (GLdouble) ctx->Visual->AccumBlueBits;
+         *params = (GLdouble) ctx->Visual.accumBlueBits;
          break;
       case GL_ACCUM_ALPHA_BITS:
-         *params = (GLdouble) ctx->Visual->AccumAlphaBits;
+         *params = (GLdouble) ctx->Visual.accumAlphaBits;
          break;
       case GL_ACCUM_CLEAR_VALUE:
          params[0] = (GLdouble) ctx->Accum.ClearColor[0];
@@ -1364,7 +1474,7 @@
          *params = (GLdouble) ctx->Pixel.AlphaBias;
          break;
       case GL_ALPHA_BITS:
-         *params = (GLdouble) ctx->Visual->AlphaBits;
+         *params = (GLdouble) ctx->Visual.alphaBits;
          break;
       case GL_ALPHA_SCALE:
          *params = (GLdouble) ctx->Pixel.AlphaScale;
@@ -1376,7 +1486,7 @@
          *params = ENUM_TO_DOUBLE(ctx->Color.AlphaFunc);
          break;
       case GL_ALPHA_TEST_REF:
-         *params = (GLdouble) ctx->Color.AlphaRef / 255.0;
+         *params = (GLdouble) ctx->Color.AlphaRef / CHAN_MAXF;
          break;
       case GL_ATTRIB_STACK_DEPTH:
          *params = (GLdouble ) (ctx->AttribStackDepth);
@@ -1421,7 +1531,7 @@
          *params = (GLdouble) ctx->Pixel.BlueBias;
          break;
       case GL_BLUE_BITS:
-         *params = (GLdouble) ctx->Visual->BlueBits;
+         *params = (GLdouble) ctx->Visual.blueBits;
          break;
       case GL_BLUE_SCALE:
          *params = (GLdouble) ctx->Pixel.BlueScale;
@@ -1438,10 +1548,10 @@
          *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = (GLdouble) ctx->Color.ClearColor[0];
-         params[1] = (GLdouble) ctx->Color.ClearColor[1];
-         params[2] = (GLdouble) ctx->Color.ClearColor[2];
-         params[3] = (GLdouble) ctx->Color.ClearColor[3];
+         params[0] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
+         params[1] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
+         params[2] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
+         params[3] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
          break;
       case GL_COLOR_MATERIAL:
          *params = (GLdouble) ctx->Light.ColorMaterialEnabled;
@@ -1465,15 +1575,18 @@
          *params = ENUM_TO_DOUBLE(ctx->Polygon.CullFaceMode);
          break;
       case GL_CURRENT_COLOR:
-         params[0] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[0]);
-         params[1] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[1]);
-         params[2] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[2]);
-         params[3] = UBYTE_COLOR_TO_FLOAT_COLOR(ctx->Current.ByteColor[3]);
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = (ctx->Current.Color[0]);
+         params[1] = (ctx->Current.Color[1]);
+         params[2] = (ctx->Current.Color[2]);
+         params[3] = (ctx->Current.Color[3]);
          break;
       case GL_CURRENT_INDEX:
+	 FLUSH_CURRENT(ctx, 0);
          *params = (GLdouble) ctx->Current.Index;
          break;
       case GL_CURRENT_NORMAL:
+	 FLUSH_CURRENT(ctx, 0);
          params[0] = (GLdouble) ctx->Current.Normal[0];
          params[1] = (GLdouble) ctx->Current.Normal[1];
          params[2] = (GLdouble) ctx->Current.Normal[2];
@@ -1497,25 +1610,26 @@
 	 params[3] = (GLdouble) ctx->Current.RasterPos[3];
 	 break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-	 params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
-	 params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
-	 params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
-	 params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
+	 params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][0];
+	 params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][1];
+	 params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][2];
+	 params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][3];
 	 break;
       case GL_CURRENT_RASTER_POSITION_VALID:
 	 *params = (GLdouble) ctx->Current.RasterPosValid;
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
-	 params[0] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][0];
-	 params[1] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][1];
-	 params[2] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][2];
-	 params[3] = (GLdouble) ctx->Current.Texcoord[texTransformUnit][3];
+	 FLUSH_CURRENT(ctx, 0);
+	 params[0] = (GLdouble) ctx->Current.Texcoord[texUnit][0];
+	 params[1] = (GLdouble) ctx->Current.Texcoord[texUnit][1];
+	 params[2] = (GLdouble) ctx->Current.Texcoord[texUnit][2];
+	 params[3] = (GLdouble) ctx->Current.Texcoord[texUnit][3];
 	 break;
       case GL_DEPTH_BIAS:
 	 *params = (GLdouble) ctx->Pixel.DepthBias;
 	 break;
       case GL_DEPTH_BITS:
-	 *params = (GLdouble) ctx->Visual->DepthBits;
+	 *params = (GLdouble) ctx->Visual.depthBits;
 	 break;
       case GL_DEPTH_CLEAR_VALUE:
 	 *params = (GLdouble) ctx->Depth.Clear;
@@ -1540,12 +1654,13 @@
 	 *params = (GLdouble) ctx->Color.DitherFlag;
 	 break;
       case GL_DOUBLEBUFFER:
-	 *params = (GLdouble) ctx->Visual->DBflag;
+	 *params = (GLdouble) ctx->Visual.doubleBufferMode;
 	 break;
       case GL_DRAW_BUFFER:
 	 *params = ENUM_TO_DOUBLE(ctx->Color.DrawBuffer);
 	 break;
       case GL_EDGE_FLAG:
+	 FLUSH_CURRENT(ctx, 0);
 	 *params = (GLdouble) ctx->Current.EdgeFlag;
 	 break;
       case GL_FEEDBACK_BUFFER_SIZE:
@@ -1588,22 +1703,28 @@
          *params = (GLdouble) ctx->Pixel.GreenBias;
          break;
       case GL_GREEN_BITS:
-         *params = (GLdouble) ctx->Visual->GreenBits;
+         *params = (GLdouble) ctx->Visual.greenBits;
          break;
       case GL_GREEN_SCALE:
          *params = (GLdouble) ctx->Pixel.GreenScale;
          break;
       case GL_HISTOGRAM:
-         *params = (GLdouble) ctx->Pixel.HistogramEnabled;
+         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
+            *params = (GLdouble) ctx->Pixel.HistogramEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
 	 break;
       case GL_INDEX_BITS:
-         *params = (GLdouble) ctx->Visual->IndexBits;
+         *params = (GLdouble) ctx->Visual.indexBits;
 	 break;
       case GL_INDEX_CLEAR_VALUE:
          *params = (GLdouble) ctx->Color.ClearIndex;
 	 break;
       case GL_INDEX_MODE:
-	 *params = ctx->Visual->RGBAflag ? 0.0 : 1.0;
+	 *params = ctx->Visual.rgbMode ? 0.0 : 1.0;
 	 break;
       case GL_INDEX_OFFSET:
 	 *params = (GLdouble) ctx->Pixel.IndexOffset;
@@ -1777,19 +1898,19 @@
          *params = (GLdouble) MAX_CLIENT_ATTRIB_STACK_DEPTH;
          break;
       case GL_MAX_CLIP_PLANES:
-	 *params = (GLdouble) MAX_CLIP_PLANES;
+	 *params = (GLdouble) ctx->Const.MaxClipPlanes;
 	 break;
       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
-         *params = (GLdouble) VB_MAX;
+         *params = (GLdouble) ctx->Const.MaxArrayLockSize;
          break;
       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
-         *params = (GLdouble) VB_MAX;
+         *params = (GLdouble) ctx->Const.MaxArrayLockSize;
          break;
       case GL_MAX_EVAL_ORDER:
 	 *params = (GLdouble) MAX_EVAL_ORDER;
 	 break;
       case GL_MAX_LIGHTS:
-	 *params = (GLdouble) MAX_LIGHTS;
+	 *params = (GLdouble) ctx->Const.MaxLights;
 	 break;
       case GL_MAX_LIST_NESTING:
 	 *params = (GLdouble) MAX_LIST_NESTING;
@@ -1807,8 +1928,10 @@
 	 *params = (GLdouble) MAX_PROJECTION_STACK_DEPTH;
 	 break;
       case GL_MAX_TEXTURE_SIZE:
+         *params = (GLdouble) (1 << (ctx->Const.MaxTextureLevels - 1));
+	 break;
       case GL_MAX_3D_TEXTURE_SIZE:
-         *params = (GLdouble) ctx->Const.MaxTextureSize;
+         *params = (GLdouble) (1 << (ctx->Const.Max3DTextureLevels - 1));
 	 break;
       case GL_MAX_TEXTURE_STACK_DEPTH:
 	 *params = (GLdouble) MAX_TEXTURE_STACK_DEPTH;
@@ -1858,6 +1981,9 @@
       case GL_PACK_IMAGE_HEIGHT_EXT:
          *params = (GLdouble) ctx->Pack.ImageHeight;
          break;
+      case GL_PACK_INVERT_MESA:
+         *params = (GLdouble) ctx->Pack.Invert;
+         break;
       case GL_PERSPECTIVE_CORRECTION_HINT:
 	 *params = ENUM_TO_DOUBLE(ctx->Hint.PerspectiveCorrection);
 	 break;
@@ -1892,7 +2018,7 @@
 	 *params = (GLdouble) ctx->Pixel.MapStoSsize;
 	 break;
       case GL_POINT_SIZE:
-         *params = (GLdouble) ctx->Point.UserSize;
+         *params = (GLdouble) ctx->Point.Size;
          break;
       case GL_POINT_SIZE_GRANULARITY:
 	 *params = (GLdouble) ctx->Const.PointSizeGranularity;
@@ -1962,7 +2088,7 @@
          *params = (GLdouble) ctx->Pixel.RedBias;
          break;
       case GL_RED_BITS:
-         *params = (GLdouble) ctx->Visual->RedBits;
+         *params = (GLdouble) ctx->Visual.redBits;
          break;
       case GL_RED_SCALE:
          *params = (GLdouble) ctx->Pixel.RedScale;
@@ -1974,7 +2100,7 @@
          *params = (GLdouble) ctx->Transform.RescaleNormals;
          break;
       case GL_RGBA_MODE:
-	 *params = (GLdouble) ctx->Visual->RGBAflag;
+	 *params = (GLdouble) ctx->Visual.rgbMode;
 	 break;
       case GL_SCISSOR_BOX:
 	 params[0] = (GLdouble) ctx->Scissor.X;
@@ -1995,7 +2121,7 @@
          *params = (GLdouble) ctx->Texture.SharedPalette;
          break;
       case GL_STENCIL_BITS:
-         *params = (GLdouble) ctx->Visual->StencilBits;
+         *params = (GLdouble) ctx->Visual.stencilBits;
          break;
       case GL_STENCIL_CLEAR_VALUE:
 	 *params = (GLdouble) ctx->Stencil.Clear;
@@ -2025,7 +2151,7 @@
 	 *params = (GLdouble) ctx->Stencil.WriteMask;
 	 break;
       case GL_STEREO:
-	 *params = (GLdouble) ctx->Visual->StereoFlag;
+	 *params = (GLdouble) ctx->Visual.stereoMode;
 	 break;
       case GL_SUBPIXEL_BITS:
 	 *params = (GLdouble) ctx->Const.SubPixelBits;
@@ -2040,13 +2166,13 @@
          *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
 	 break;
       case GL_TEXTURE_BINDING_1D:
-         *params = (GLdouble) textureUnit->CurrentD[1]->Name;
+         *params = (GLdouble) textureUnit->Current1D->Name;
           break;
       case GL_TEXTURE_BINDING_2D:
-         *params = (GLdouble) textureUnit->CurrentD[2]->Name;
+         *params = (GLdouble) textureUnit->Current2D->Name;
           break;
       case GL_TEXTURE_BINDING_3D:
-         *params = (GLdouble) textureUnit->CurrentD[3]->Name;
+         *params = (GLdouble) textureUnit->Current3D->Name;
           break;
       case GL_TEXTURE_ENV_COLOR:
 	 params[0] = (GLdouble) textureUnit->EnvColor[0];
@@ -2071,11 +2197,11 @@
 	 break;
       case GL_TEXTURE_MATRIX:
          for (i=0;i<16;i++) {
-	    params[i] = (GLdouble) ctx->TextureMatrix[texTransformUnit].m[i];
+	    params[i] = (GLdouble) ctx->TextureMatrix[texUnit].m[i];
 	 }
 	 break;
       case GL_TEXTURE_STACK_DEPTH:
-	 *params = (GLdouble) (ctx->TextureStackDepth[texTransformUnit] + 1);
+	 *params = (GLdouble) (ctx->TextureStackDepth[texUnit] + 1);
 	 break;
       case GL_UNPACK_ALIGNMENT:
 	 *params = (GLdouble) ctx->Unpack.Alignment;
@@ -2101,6 +2227,9 @@
       case GL_UNPACK_IMAGE_HEIGHT_EXT:
          *params = (GLdouble) ctx->Unpack.ImageHeight;
          break;
+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
+         *params = (GLdouble) ctx->Unpack.ClientStorage;
+         break;
       case GL_VIEWPORT:
 	 params[0] = (GLdouble) ctx->Viewport.X;
 	 params[1] = (GLdouble) ctx->Viewport.Y;
@@ -2114,159 +2243,79 @@
 	 *params = (GLdouble) ctx->Pixel.ZoomY;
 	 break;
       case GL_VERTEX_ARRAY:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Vertex.Enabled;
-#else
          *params = (GLdouble) ctx->Array.Vertex.Enabled;
-#endif
          break;
       case GL_VERTEX_ARRAY_SIZE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Vertex.Size;
-#else
          *params = (GLdouble) ctx->Array.Vertex.Size;
-#endif
          break;
       case GL_VERTEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_DOUBLE(ctx->Array.Current->Vertex.Type);
-#else
          *params = ENUM_TO_DOUBLE(ctx->Array.Vertex.Type);
-#endif
          break;
       case GL_VERTEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Vertex.Stride;
-#else
          *params = (GLdouble) ctx->Array.Vertex.Stride;
-#endif
          break;
       case GL_VERTEX_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_NORMAL_ARRAY:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Normal.Enabled;
-#else
          *params = (GLdouble) ctx->Array.Normal.Enabled;
-#endif
          break;
       case GL_NORMAL_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_DOUBLE(ctx->Array.Current->Normal.Type);
-#else
          *params = ENUM_TO_DOUBLE(ctx->Array.Normal.Type);
-#endif
          break;
       case GL_NORMAL_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Normal.Stride;
-#else
          *params = (GLdouble) ctx->Array.Normal.Stride;
-#endif
          break;
       case GL_NORMAL_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_COLOR_ARRAY:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Color.Enabled;
-#else
          *params = (GLdouble) ctx->Array.Color.Enabled;
-#endif
          break;
       case GL_COLOR_ARRAY_SIZE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Color.Size;
-#else
          *params = (GLdouble) ctx->Array.Color.Size;
-#endif
          break;
       case GL_COLOR_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_DOUBLE(ctx->Array.Current->Color.Type);
-#else
          *params = ENUM_TO_DOUBLE(ctx->Array.Color.Type);
-#endif
          break;
       case GL_COLOR_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Color.Stride;
-#else
          *params = (GLdouble) ctx->Array.Color.Stride;
-#endif
          break;
       case GL_COLOR_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_INDEX_ARRAY:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Index.Enabled;
-#else
          *params = (GLdouble) ctx->Array.Index.Enabled;
-#endif
          break;
       case GL_INDEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_DOUBLE(ctx->Array.Current->Index.Type);
-#else
          *params = ENUM_TO_DOUBLE(ctx->Array.Index.Type);
-#endif
          break;
       case GL_INDEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->Index.Stride;
-#else
          *params = (GLdouble) ctx->Array.Index.Stride;
-#endif
          break;
       case GL_INDEX_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_TEXTURE_COORD_ARRAY:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->TexCoord[texUnit].Enabled;
-#else
          *params = (GLdouble) ctx->Array.TexCoord[texUnit].Enabled;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_SIZE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->TexCoord[texUnit].Size;
-#else
          *params = (GLdouble) ctx->Array.TexCoord[texUnit].Size;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_DOUBLE(ctx->Array.Current->TexCoord[texUnit].Type);
-#else
          *params = ENUM_TO_DOUBLE(ctx->Array.TexCoord[texUnit].Type);
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->TexCoord[texUnit].Stride;
-#else
          *params = (GLdouble) ctx->Array.TexCoord[texUnit].Stride;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_EDGE_FLAG_ARRAY:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->EdgeFlag.Enabled;
-#else
          *params = (GLdouble) ctx->Array.EdgeFlag.Enabled;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLdouble) ctx->Array.Current->EdgeFlag.Stride;
-#else
          *params = (GLdouble) ctx->Array.EdgeFlag.Stride;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
          *params = 0.0;
@@ -2285,113 +2334,55 @@
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          return;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = (GLdouble) textureUnit->CurrentCubeMap->Name;
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          return;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
-            *params = (GLdouble) ctx->Const.MaxCubeTextureSize;
+         if (ctx->Extensions.ARB_texture_cube_map)
+            *params = (GLdouble) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          return;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = (GLdouble) ctx->Hint.TextureCompression;
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = (GLdouble) ctx->Const.NumCompressedTextureFormats;
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLdouble) ctx->Const.CompressedTextureFormats[i];
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-         break;
-
-      /* GL_PGI_misc_hints */
-      case GL_STRICT_DEPTHFUNC_HINT_PGI:
-	 *params = ENUM_TO_DOUBLE(GL_NICEST);
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          break;
-      case GL_STRICT_LIGHTING_HINT_PGI:
-	 *params = ENUM_TO_DOUBLE(ctx->Hint.StrictLighting);
-	 break;
-      case GL_STRICT_SCISSOR_HINT_PGI:
-      case GL_FULL_STIPPLE_HINT_PGI:
-	 *params = ENUM_TO_DOUBLE(GL_TRUE);
-	 break;
-      case GL_CONSERVE_MEMORY_HINT_PGI:
-	 *params = ENUM_TO_DOUBLE(GL_FALSE);
-	 break;
-      case GL_ALWAYS_FAST_HINT_PGI:
-	 *params = (GLdouble) (ctx->Hint.AllowDrawWin == GL_TRUE &&
-			      ctx->Hint.AllowDrawFrg == GL_FALSE && 
-			      ctx->Hint.AllowDrawMem == GL_FALSE);
-	 break;
-      case GL_ALWAYS_SOFT_HINT_PGI:
-	 *params = (GLdouble) (ctx->Hint.AllowDrawWin == GL_TRUE &&
-			      ctx->Hint.AllowDrawFrg == GL_TRUE && 
-			      ctx->Hint.AllowDrawMem == GL_TRUE);
-	 break;
-      case GL_ALLOW_DRAW_OBJ_HINT_PGI:
-	 *params = (GLdouble) GL_TRUE;
-	 break;
-      case GL_ALLOW_DRAW_WIN_HINT_PGI:
-	 *params = (GLdouble) ctx->Hint.AllowDrawWin;
-	 break;
-      case GL_ALLOW_DRAW_FRG_HINT_PGI:
-	 *params = (GLdouble) ctx->Hint.AllowDrawFrg;
-	 break;
-      case GL_ALLOW_DRAW_MEM_HINT_PGI:
-	 *params = (GLdouble) ctx->Hint.AllowDrawMem;
-	 break;
-      case GL_CLIP_NEAR_HINT_PGI:
-      case GL_CLIP_FAR_HINT_PGI:
-	 *params = ENUM_TO_DOUBLE(GL_TRUE);
-	 break;
-      case GL_WIDE_LINE_HINT_PGI:
-	 *params = ENUM_TO_DOUBLE(GL_DONT_CARE);
-	 break;
-      case GL_BACK_NORMALS_HINT_PGI:
-	 *params = ENUM_TO_DOUBLE(GL_TRUE);
-	 break;
-      case GL_NATIVE_GRAPHICS_HANDLE_PGI:
-	 *params = 0;
-	 break;
 
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-#ifdef VAO
-	 *params = (GLdouble) ctx->Array.Current->LockFirst;
-#else
 	 *params = (GLdouble) ctx->Array.LockFirst;
-#endif
 	 break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-#ifdef VAO
-	 *params = (GLdouble) ctx->Array.Current->LockCount;
-#else
 	 *params = (GLdouble) ctx->Array.LockCount;
-#endif
 	 break;
 
       /* GL_ARB_transpose_matrix */
@@ -2399,7 +2390,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ColorMatrix.m);
+            _math_transposef(tm, ctx->ColorMatrix.m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2409,7 +2400,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ModelView.m);
+            _math_transposef(tm, ctx->ModelView.m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2419,7 +2410,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ProjectionMatrix.m);
+            _math_transposef(tm, ctx->ProjectionMatrix.m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2429,7 +2420,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
+            _math_transposef(tm, ctx->TextureMatrix[texUnit].m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2438,15 +2429,15 @@
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             *params = (GLdouble) ctx->Depth.OcclusionTest;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
          }
          return;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             if (ctx->Depth.OcclusionTest)
                *params = (GLdouble) ctx->OcclusionResult;
             else
@@ -2456,7 +2447,7 @@
             ctx->OcclusionResultSaved = GL_FALSE;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
          }
          return;
 
@@ -2511,11 +2502,32 @@
          break;
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
-      case GL_MAX_CONVOLUTION_WIDTH:
-         *params = (GLdouble) ctx->Const.MaxConvolutionWidth;
+      case GL_CONVOLUTION_1D_EXT:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLdouble) ctx->Pixel.Convolution1DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_CONVOLUTION_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLdouble) ctx->Pixel.Convolution2DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
          break;
-      case GL_MAX_CONVOLUTION_HEIGHT:
-         *params = (GLdouble) ctx->Const.MaxConvolutionHeight;
+      case GL_SEPARABLE_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLdouble) ctx->Pixel.Separable2DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[0];
@@ -2553,46 +2565,218 @@
          *params = (GLdouble) ctx->Pixel.PostColorMatrixColorTableEnabled;
          break;
 
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-   }
-}
+      /* GL_EXT_secondary_color */
+      case GL_COLOR_SUM_EXT:
+	 *params = (GLdouble) ctx->Fog.ColorSumEnabled;
+	 break;
+      case GL_CURRENT_SECONDARY_COLOR_EXT:
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = (ctx->Current.SecondaryColor[0]);
+         params[1] = (ctx->Current.SecondaryColor[1]);
+         params[2] = (ctx->Current.SecondaryColor[2]);
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         *params = (GLdouble) ctx->Array.SecondaryColor.Enabled;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+	 *params = (GLdouble) ctx->Array.SecondaryColor.Type;
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+	 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+	 *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
+	 break;
 
+      /* GL_EXT_fog_coord */
+      case GL_CURRENT_FOG_COORDINATE_EXT:
+	 FLUSH_CURRENT(ctx, 0);
+	 *params = (GLdouble) ctx->Current.FogCoord;
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+         *params = (GLdouble) ctx->Array.FogCoord.Enabled;
+         break;
+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+	 *params = (GLdouble) ctx->Array.FogCoord.Type;
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+	 *params = (GLdouble) ctx->Array.FogCoord.Stride;
+	 break;
 
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = (GLdouble) ctx->Const.MaxTextureLodBias;
+         break;
 
+      /* GL_EXT_texture_filter_anisotropic */
+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+	    *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy;
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
+            return;
+         }
+	 break;
 
-void
-_mesa_GetFloatv( GLenum pname, GLfloat *params )
-{
-   GET_CURRENT_CONTEXT(ctx);
+      /* GL_ARB_multisample */
+      case GL_MULTISAMPLE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLdouble) ctx->Multisample.Enabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLdouble) ctx->Multisample.SampleAlphaToCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLdouble) ctx->Multisample.SampleAlphaToOne;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLdouble) ctx->Multisample.SampleCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = ctx->Multisample.SampleCoverageValue;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLdouble) ctx->Multisample.SampleCoverageInvert;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_SAMPLE_BUFFERS_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0.0; /* XXX fix someday */
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+      case GL_SAMPLES_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0.0; /* XXX fix someday */
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         if (ctx->Extensions.IBM_rasterpos_clip) {
+            *params = (GLdouble) ctx->Transform.RasterPositionUnclipped;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+            return;
+         }
+         break;
+
+      /* GL_SGIS_generate_mipmap */
+      case GL_GENERATE_MIPMAP_HINT_SGIS:
+         if (ctx->Extensions.SGIS_generate_mipmap) {
+            *params = (GLdouble) ctx->Hint.GenerateMipmap;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+	    return;
+         }
+         break;
+
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_D(NV_texture_rectangle, pname);
+         *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_D(NV_texture_rectangle, pname);
+         *params = (GLdouble) textureUnit->CurrentRect->Name;
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_D(NV_texture_rectangle, pname);
+         *params = (GLdouble) ctx->Const.MaxTextureRectSize;
+         break;
+
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
+   }
+}
+
+
+#define GET_FLOAT_ERROR				\
+{						\
+   char s[100];					\
+   sprintf(s, "glGetFloatv(0x%x)", pname);	\
+   _mesa_error(ctx, GL_INVALID_ENUM, s);	\
+}
+
+void
+_mesa_GetFloatv( GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
    GLuint i;
    GLuint texUnit = ctx->Texture.CurrentUnit;
-   GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetFloatv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (!params)
       return;
+
+   /* We need this in order to get correct results for
+    * GL_OCCLUSION_TEST_RESULT_HP.  There might be other important cases.
+    */
+   FLUSH_VERTICES(ctx, 0);
 
-   if (MESA_VERBOSE & VERBOSE_API) 
-      fprintf(stderr, "glGetFloatv %s\n", gl_lookup_enum_by_nr(pname));
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glGetFloatv %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetFloatv && (*ctx->Driver.GetFloatv)(ctx, pname, params))
       return;
 
    switch (pname) {
       case GL_ACCUM_RED_BITS:
-         *params = (GLfloat) ctx->Visual->AccumRedBits;
+         *params = (GLfloat) ctx->Visual.accumRedBits;
          break;
       case GL_ACCUM_GREEN_BITS:
-         *params = (GLfloat) ctx->Visual->AccumGreenBits;
+         *params = (GLfloat) ctx->Visual.accumGreenBits;
          break;
       case GL_ACCUM_BLUE_BITS:
-         *params = (GLfloat) ctx->Visual->AccumBlueBits;
+         *params = (GLfloat) ctx->Visual.accumBlueBits;
          break;
       case GL_ACCUM_ALPHA_BITS:
-         *params = (GLfloat) ctx->Visual->AccumAlphaBits;
+         *params = (GLfloat) ctx->Visual.accumAlphaBits;
          break;
       case GL_ACCUM_CLEAR_VALUE:
          params[0] = ctx->Accum.ClearColor[0];
@@ -2604,7 +2788,7 @@
          *params = ctx->Pixel.AlphaBias;
          break;
       case GL_ALPHA_BITS:
-         *params = (GLfloat) ctx->Visual->AlphaBits;
+         *params = (GLfloat) ctx->Visual.alphaBits;
          break;
       case GL_ALPHA_SCALE:
          *params = ctx->Pixel.AlphaScale;
@@ -2616,7 +2800,7 @@
          *params = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
          break;
       case GL_ALPHA_TEST_REF:
-         *params = (GLfloat) ctx->Color.AlphaRef / 255.0;
+         *params = (GLfloat) ctx->Color.AlphaRef / CHAN_MAXF;
          break;
       case GL_ATTRIB_STACK_DEPTH:
          *params = (GLfloat) (ctx->AttribStackDepth);
@@ -2661,7 +2845,7 @@
          *params = ctx->Pixel.BlueBias;
          break;
       case GL_BLUE_BITS:
-         *params = (GLfloat) ctx->Visual->BlueBits;
+         *params = (GLfloat) ctx->Visual.blueBits;
          break;
       case GL_BLUE_SCALE:
          *params = ctx->Pixel.BlueScale;
@@ -2678,10 +2862,10 @@
          *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = (GLfloat) ctx->Color.ClearColor[0];
-         params[1] = (GLfloat) ctx->Color.ClearColor[1];
-         params[2] = (GLfloat) ctx->Color.ClearColor[2];
-         params[3] = (GLfloat) ctx->Color.ClearColor[3];
+         params[0] = CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
+         params[1] = CHAN_TO_FLOAT(ctx->Color.ClearColor[1]);
+         params[2] = CHAN_TO_FLOAT(ctx->Color.ClearColor[2]);
+         params[3] = CHAN_TO_FLOAT(ctx->Color.ClearColor[3]);
          break;
       case GL_COLOR_MATERIAL:
          *params = (GLfloat) ctx->Light.ColorMaterialEnabled;
@@ -2705,12 +2889,18 @@
          *params = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
          break;
       case GL_CURRENT_COLOR:
-	 UBYTE_RGBA_TO_FLOAT_RGBA(params, ctx->Current.ByteColor);
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = (ctx->Current.Color[0]);
+         params[1] = (ctx->Current.Color[1]);
+         params[2] = (ctx->Current.Color[2]);
+         params[3] = (ctx->Current.Color[3]);
          break;
       case GL_CURRENT_INDEX:
+	 FLUSH_CURRENT(ctx, 0);
          *params = (GLfloat) ctx->Current.Index;
          break;
       case GL_CURRENT_NORMAL:
+	 FLUSH_CURRENT(ctx, 0);
          params[0] = ctx->Current.Normal[0];
          params[1] = ctx->Current.Normal[1];
          params[2] = ctx->Current.Normal[2];
@@ -2734,25 +2924,26 @@
 	 params[3] = ctx->Current.RasterPos[3];
 	 break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-	 params[0] = ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
-	 params[1] = ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
-	 params[2] = ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
-	 params[3] = ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
+	 params[0] = ctx->Current.RasterMultiTexCoord[texUnit][0];
+	 params[1] = ctx->Current.RasterMultiTexCoord[texUnit][1];
+	 params[2] = ctx->Current.RasterMultiTexCoord[texUnit][2];
+	 params[3] = ctx->Current.RasterMultiTexCoord[texUnit][3];
 	 break;
       case GL_CURRENT_RASTER_POSITION_VALID:
 	 *params = (GLfloat) ctx->Current.RasterPosValid;
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
-	 params[0] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][0];
-	 params[1] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][1];
-	 params[2] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][2];
-	 params[3] = (GLfloat) ctx->Current.Texcoord[texTransformUnit][3];
+	 FLUSH_CURRENT(ctx, 0);
+	 params[0] = (GLfloat) ctx->Current.Texcoord[texUnit][0];
+	 params[1] = (GLfloat) ctx->Current.Texcoord[texUnit][1];
+	 params[2] = (GLfloat) ctx->Current.Texcoord[texUnit][2];
+	 params[3] = (GLfloat) ctx->Current.Texcoord[texUnit][3];
 	 break;
       case GL_DEPTH_BIAS:
 	 *params = (GLfloat) ctx->Pixel.DepthBias;
 	 break;
       case GL_DEPTH_BITS:
-	 *params = (GLfloat) ctx->Visual->DepthBits;
+	 *params = (GLfloat) ctx->Visual.depthBits;
 	 break;
       case GL_DEPTH_CLEAR_VALUE:
 	 *params = (GLfloat) ctx->Depth.Clear;
@@ -2777,12 +2968,13 @@
 	 *params = (GLfloat) ctx->Color.DitherFlag;
 	 break;
       case GL_DOUBLEBUFFER:
-	 *params = (GLfloat) ctx->Visual->DBflag;
+	 *params = (GLfloat) ctx->Visual.doubleBufferMode;
 	 break;
       case GL_DRAW_BUFFER:
 	 *params = ENUM_TO_FLOAT(ctx->Color.DrawBuffer);
 	 break;
       case GL_EDGE_FLAG:
+	 FLUSH_CURRENT(ctx, 0);
 	 *params = (GLfloat) ctx->Current.EdgeFlag;
 	 break;
       case GL_FEEDBACK_BUFFER_SIZE:
@@ -2825,22 +3017,28 @@
          *params = (GLfloat) ctx->Pixel.GreenBias;
          break;
       case GL_GREEN_BITS:
-         *params = (GLfloat) ctx->Visual->GreenBits;
+         *params = (GLfloat) ctx->Visual.greenBits;
          break;
       case GL_GREEN_SCALE:
          *params = (GLfloat) ctx->Pixel.GreenScale;
          break;
       case GL_HISTOGRAM:
-         *params = (GLfloat) ctx->Pixel.HistogramEnabled;
+         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
+            *params = (GLfloat) ctx->Pixel.HistogramEnabled;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
 	 break;
       case GL_INDEX_BITS:
-         *params = (GLfloat) ctx->Visual->IndexBits;
+         *params = (GLfloat) ctx->Visual.indexBits;
 	 break;
       case GL_INDEX_CLEAR_VALUE:
          *params = (GLfloat) ctx->Color.ClearIndex;
 	 break;
       case GL_INDEX_MODE:
-	 *params = ctx->Visual->RGBAflag ? 0.0F : 1.0F;
+	 *params = ctx->Visual.rgbMode ? 0.0F : 1.0F;
 	 break;
       case GL_INDEX_OFFSET:
 	 *params = (GLfloat) ctx->Pixel.IndexOffset;
@@ -3014,19 +3212,19 @@
          *params = (GLfloat) MAX_CLIENT_ATTRIB_STACK_DEPTH;
          break;
       case GL_MAX_CLIP_PLANES:
-	 *params = (GLfloat) MAX_CLIP_PLANES;
+	 *params = (GLfloat) ctx->Const.MaxClipPlanes;
 	 break;
       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
-         *params = (GLfloat) VB_MAX;
+         *params = (GLfloat) ctx->Const.MaxArrayLockSize;
          break;
       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
-         *params = (GLfloat) VB_MAX;
+         *params = (GLfloat) ctx->Const.MaxArrayLockSize;
          break;
       case GL_MAX_EVAL_ORDER:
 	 *params = (GLfloat) MAX_EVAL_ORDER;
 	 break;
       case GL_MAX_LIGHTS:
-	 *params = (GLfloat) MAX_LIGHTS;
+	 *params = (GLfloat) ctx->Const.MaxLights;
 	 break;
       case GL_MAX_LIST_NESTING:
 	 *params = (GLfloat) MAX_LIST_NESTING;
@@ -3044,8 +3242,10 @@
 	 *params = (GLfloat) MAX_PROJECTION_STACK_DEPTH;
 	 break;
       case GL_MAX_TEXTURE_SIZE:
+         *params = (GLfloat) (1 << (ctx->Const.MaxTextureLevels - 1));
+	 break;
       case GL_MAX_3D_TEXTURE_SIZE:
-         *params = (GLfloat) ctx->Const.MaxTextureSize;
+         *params = (GLfloat) (1 << (ctx->Const.Max3DTextureLevels - 1));
 	 break;
       case GL_MAX_TEXTURE_STACK_DEPTH:
 	 *params = (GLfloat) MAX_TEXTURE_STACK_DEPTH;
@@ -3095,6 +3295,9 @@
       case GL_PACK_IMAGE_HEIGHT_EXT:
          *params = (GLfloat) ctx->Pack.ImageHeight;
          break;
+      case GL_PACK_INVERT_MESA:
+         *params = (GLfloat) ctx->Pack.Invert;
+         break;
       case GL_PERSPECTIVE_CORRECTION_HINT:
 	 *params = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
 	 break;
@@ -3129,7 +3332,7 @@
 	 *params = (GLfloat) ctx->Pixel.MapStoSsize;
 	 break;
       case GL_POINT_SIZE:
-         *params = (GLfloat) ctx->Point.UserSize;
+         *params = (GLfloat) ctx->Point.Size;
          break;
       case GL_POINT_SIZE_GRANULARITY:
 	 *params = (GLfloat) ctx->Const.PointSizeGranularity;
@@ -3201,7 +3404,7 @@
          *params = ctx->Pixel.RedBias;
          break;
       case GL_RED_BITS:
-         *params = (GLfloat) ctx->Visual->RedBits;
+         *params = (GLfloat) ctx->Visual.redBits;
          break;
       case GL_RED_SCALE:
          *params = ctx->Pixel.RedScale;
@@ -3213,7 +3416,7 @@
          *params = (GLfloat) ctx->Transform.RescaleNormals;
          break;
       case GL_RGBA_MODE:
-	 *params = (GLfloat) ctx->Visual->RGBAflag;
+	 *params = (GLfloat) ctx->Visual.rgbMode;
 	 break;
       case GL_SCISSOR_BOX:
 	 params[0] = (GLfloat) ctx->Scissor.X;
@@ -3234,7 +3437,7 @@
          *params = (GLfloat) ctx->Texture.SharedPalette;
          break;
       case GL_STENCIL_BITS:
-         *params = (GLfloat) ctx->Visual->StencilBits;
+         *params = (GLfloat) ctx->Visual.stencilBits;
          break;
       case GL_STENCIL_CLEAR_VALUE:
 	 *params = (GLfloat) ctx->Stencil.Clear;
@@ -3264,28 +3467,28 @@
 	 *params = (GLfloat) ctx->Stencil.WriteMask;
 	 break;
       case GL_STEREO:
-	 *params = (GLfloat) ctx->Visual->StereoFlag;
+	 *params = (GLfloat) ctx->Visual.stereoMode;
 	 break;
       case GL_SUBPIXEL_BITS:
 	 *params = (GLfloat) ctx->Const.SubPixelBits;
 	 break;
       case GL_TEXTURE_1D:
-         *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0;
+         *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0F : 0.0F;
 	 break;
       case GL_TEXTURE_2D:
-         *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0;
+         *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0F : 0.0F;
 	 break;
       case GL_TEXTURE_3D:
-         *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
+         *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0F : 0.0F;
 	 break;
       case GL_TEXTURE_BINDING_1D:
-         *params = (GLfloat) textureUnit->CurrentD[1]->Name;
+         *params = (GLfloat) textureUnit->Current1D->Name;
           break;
       case GL_TEXTURE_BINDING_2D:
-         *params = (GLfloat) textureUnit->CurrentD[2]->Name;
+         *params = (GLfloat) textureUnit->Current2D->Name;
           break;
       case GL_TEXTURE_BINDING_3D:
-         *params = (GLfloat) textureUnit->CurrentD[2]->Name;
+         *params = (GLfloat) textureUnit->Current2D->Name;
           break;
       case GL_TEXTURE_ENV_COLOR:
 	 params[0] = textureUnit->EnvColor[0];
@@ -3297,24 +3500,24 @@
 	 *params = ENUM_TO_FLOAT(textureUnit->EnvMode);
 	 break;
       case GL_TEXTURE_GEN_S:
-	 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
+	 *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0F : 0.0F;
 	 break;
       case GL_TEXTURE_GEN_T:
-	 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
+	 *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0F : 0.0F;
 	 break;
       case GL_TEXTURE_GEN_R:
-	 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
+	 *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0F : 0.0F;
 	 break;
       case GL_TEXTURE_GEN_Q:
-	 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
+	 *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0F : 0.0F;
 	 break;
       case GL_TEXTURE_MATRIX:
          for (i=0;i<16;i++) {
-	    params[i] = ctx->TextureMatrix[texTransformUnit].m[i];
+	    params[i] = ctx->TextureMatrix[texUnit].m[i];
 	 }
 	 break;
       case GL_TEXTURE_STACK_DEPTH:
-	 *params = (GLfloat) (ctx->TextureStackDepth[texTransformUnit] + 1);
+	 *params = (GLfloat) (ctx->TextureStackDepth[texUnit] + 1);
 	 break;
       case GL_UNPACK_ALIGNMENT:
 	 *params = (GLfloat) ctx->Unpack.Alignment;
@@ -3340,6 +3543,9 @@
       case GL_UNPACK_IMAGE_HEIGHT_EXT:
          *params = (GLfloat) ctx->Unpack.ImageHeight;
          break;
+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
+         *params = (GLfloat) ctx->Unpack.ClientStorage;
+         break;
       case GL_VIEWPORT:
 	 params[0] = (GLfloat) ctx->Viewport.X;
 	 params[1] = (GLfloat) ctx->Viewport.Y;
@@ -3353,159 +3559,79 @@
 	 *params = (GLfloat) ctx->Pixel.ZoomY;
 	 break;
       case GL_VERTEX_ARRAY:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Vertex.Enabled;
-#else
          *params = (GLfloat) ctx->Array.Vertex.Enabled;
-#endif
          break;
       case GL_VERTEX_ARRAY_SIZE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Vertex.Size;
-#else
          *params = (GLfloat) ctx->Array.Vertex.Size;
-#endif
          break;
       case GL_VERTEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_FLOAT(ctx->Array.Current->Vertex.Type);
-#else
          *params = ENUM_TO_FLOAT(ctx->Array.Vertex.Type);
-#endif
          break;
       case GL_VERTEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Vertex.Stride;
-#else
          *params = (GLfloat) ctx->Array.Vertex.Stride;
-#endif
          break;
       case GL_VERTEX_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_NORMAL_ARRAY:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Normal.Enabled;
-#else
          *params = (GLfloat) ctx->Array.Normal.Enabled;
-#endif
          break;
       case GL_NORMAL_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_FLOAT(ctx->Array.Current->Normal.Type);
-#else
          *params = ENUM_TO_FLOAT(ctx->Array.Normal.Type);
-#endif
          break;
       case GL_NORMAL_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Normal.Stride;
-#else
          *params = (GLfloat) ctx->Array.Normal.Stride;
-#endif
          break;
       case GL_NORMAL_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_COLOR_ARRAY:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Color.Enabled;
-#else
          *params = (GLfloat) ctx->Array.Color.Enabled;
-#endif
          break;
       case GL_COLOR_ARRAY_SIZE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Color.Size;
-#else
          *params = (GLfloat) ctx->Array.Color.Size;
-#endif
          break;
       case GL_COLOR_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_FLOAT(ctx->Array.Current->Color.Type);
-#else
          *params = ENUM_TO_FLOAT(ctx->Array.Color.Type);
-#endif
          break;
       case GL_COLOR_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Color.Stride;
-#else
          *params = (GLfloat) ctx->Array.Color.Stride;
-#endif
          break;
       case GL_COLOR_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_INDEX_ARRAY:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Index.Enabled;
-#else
          *params = (GLfloat) ctx->Array.Index.Enabled;
-#endif
          break;
       case GL_INDEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_FLOAT(ctx->Array.Current->Index.Type);
-#else
          *params = ENUM_TO_FLOAT(ctx->Array.Index.Type);
-#endif
          break;
       case GL_INDEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->Index.Stride;
-#else
          *params = (GLfloat) ctx->Array.Index.Stride;
-#endif
          break;
       case GL_INDEX_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_TEXTURE_COORD_ARRAY:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->TexCoord[texUnit].Enabled;
-#else
          *params = (GLfloat) ctx->Array.TexCoord[texUnit].Enabled;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_SIZE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->TexCoord[texUnit].Size;
-#else
          *params = (GLfloat) ctx->Array.TexCoord[texUnit].Size;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_TYPE:
-#ifdef VAO
-         *params = ENUM_TO_FLOAT(ctx->Array.Current->TexCoord[texUnit].Type);
-#else
          *params = ENUM_TO_FLOAT(ctx->Array.TexCoord[texUnit].Type);
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->TexCoord[texUnit].Stride;
-#else
          *params = (GLfloat) ctx->Array.TexCoord[texUnit].Stride;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
          *params = 0.0;
          break;
       case GL_EDGE_FLAG_ARRAY:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->EdgeFlag.Enabled;
-#else
          *params = (GLfloat) ctx->Array.EdgeFlag.Enabled;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_STRIDE:
-#ifdef VAO
-         *params = (GLfloat) ctx->Array.Current->EdgeFlag.Stride;
-#else
          *params = (GLfloat) ctx->Array.EdgeFlag.Stride;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
          *params = 0.0;
@@ -3524,140 +3650,82 @@
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+            GET_FLOAT_ERROR;
          return;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = (GLfloat) textureUnit->CurrentCubeMap->Name;
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+            GET_FLOAT_ERROR;
          return;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
-            *params = (GLfloat) ctx->Const.MaxCubeTextureSize;
+         if (ctx->Extensions.ARB_texture_cube_map)
+            *params = (GLfloat) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+            GET_FLOAT_ERROR;
          return;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = (GLfloat) ctx->Hint.TextureCompression;
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+            GET_FLOAT_ERROR;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = (GLfloat) ctx->Const.NumCompressedTextureFormats;
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+            GET_FLOAT_ERROR;
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLfloat) ctx->Const.CompressedTextureFormats[i];
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+            GET_FLOAT_ERROR;
          break;
 
-      /* GL_PGI_misc_hints */
-      case GL_STRICT_DEPTHFUNC_HINT_PGI:
-	 *params = ENUM_TO_FLOAT(GL_NICEST);
-         break;
-      case GL_STRICT_LIGHTING_HINT_PGI:
-	 *params = ENUM_TO_FLOAT(ctx->Hint.StrictLighting);
-	 break;
-      case GL_STRICT_SCISSOR_HINT_PGI:
-      case GL_FULL_STIPPLE_HINT_PGI:
-	 *params = ENUM_TO_FLOAT(GL_TRUE);
-	 break;
-      case GL_CONSERVE_MEMORY_HINT_PGI:
-	 *params = ENUM_TO_FLOAT(GL_FALSE);
-	 break;
-      case GL_ALWAYS_FAST_HINT_PGI:
-	 *params = (GLfloat) (ctx->Hint.AllowDrawWin == GL_TRUE &&
-			      ctx->Hint.AllowDrawFrg == GL_FALSE && 
-			      ctx->Hint.AllowDrawMem == GL_FALSE);
-	 break;
-      case GL_ALWAYS_SOFT_HINT_PGI:
-	 *params = (GLfloat) (ctx->Hint.AllowDrawWin == GL_TRUE &&
-			      ctx->Hint.AllowDrawFrg == GL_TRUE && 
-			      ctx->Hint.AllowDrawMem == GL_TRUE);
-	 break;
-      case GL_ALLOW_DRAW_OBJ_HINT_PGI:
-	 *params = (GLfloat) GL_TRUE;
-	 break;
-      case GL_ALLOW_DRAW_WIN_HINT_PGI:
-	 *params = (GLfloat) ctx->Hint.AllowDrawWin;
-	 break;
-      case GL_ALLOW_DRAW_FRG_HINT_PGI:
-	 *params = (GLfloat) ctx->Hint.AllowDrawFrg;
-	 break;
-      case GL_ALLOW_DRAW_MEM_HINT_PGI:
-	 *params = (GLfloat) ctx->Hint.AllowDrawMem;
-	 break;
-      case GL_CLIP_NEAR_HINT_PGI:
-      case GL_CLIP_FAR_HINT_PGI:
-	 *params = ENUM_TO_FLOAT(GL_TRUE);
-	 break;
-      case GL_WIDE_LINE_HINT_PGI:
-	 *params = ENUM_TO_FLOAT(GL_DONT_CARE);
-	 break;
-      case GL_BACK_NORMALS_HINT_PGI:
-	 *params = ENUM_TO_FLOAT(GL_TRUE);
-	 break;
-      case GL_NATIVE_GRAPHICS_HANDLE_PGI:
-	 *params = 0;
-	 break;
-
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-#ifdef VAO
-	 *params = (GLfloat) ctx->Array.Current->LockFirst;
-#else
 	 *params = (GLfloat) ctx->Array.LockFirst;
-#endif
 	 break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-#ifdef VAO
-	 *params = (GLfloat) ctx->Array.Current->LockCount;
-#else
 	 *params = (GLfloat) ctx->Array.LockCount;
-#endif
 	 break;
 
       /* GL_ARB_transpose_matrix */
       case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-         gl_matrix_transposef(params, ctx->ColorMatrix.m);
+         _math_transposef(params, ctx->ColorMatrix.m);
          break;
       case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-         gl_matrix_transposef(params, ctx->ModelView.m);
+         _math_transposef(params, ctx->ModelView.m);
          break;
       case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-         gl_matrix_transposef(params, ctx->ProjectionMatrix.m);
+         _math_transposef(params, ctx->ProjectionMatrix.m);
          break;
       case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-         gl_matrix_transposef(params, ctx->TextureMatrix[texTransformUnit].m);
+         _math_transposef(params, ctx->TextureMatrix[texUnit].m);
          break;
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             *params = (GLfloat) ctx->Depth.OcclusionTest;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
+            GET_FLOAT_ERROR;
          }
          return;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             if (ctx->Depth.OcclusionTest)
                *params = (GLfloat) ctx->OcclusionResult;
             else
@@ -3667,7 +3735,7 @@
             ctx->OcclusionResultSaved = GL_FALSE;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
+            GET_FLOAT_ERROR;
          }
          return;
 
@@ -3722,11 +3790,32 @@
          break;
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
-      case GL_MAX_CONVOLUTION_WIDTH:
-         *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
+      case GL_CONVOLUTION_1D_EXT:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLfloat) ctx->Pixel.Convolution1DEnabled;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_CONVOLUTION_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLfloat) ctx->Pixel.Convolution2DEnabled;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
          break;
-      case GL_MAX_CONVOLUTION_HEIGHT:
-         *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
+      case GL_SEPARABLE_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLfloat) ctx->Pixel.Separable2DEnabled;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
          *params = ctx->Pixel.PostConvolutionScale[0];
@@ -3764,12 +3853,174 @@
          *params = (GLfloat) ctx->Pixel.PostColorMatrixColorTableEnabled;
          break;
 
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
-   }
-}
+      /* GL_EXT_secondary_color */
+      case GL_COLOR_SUM_EXT:
+	 *params = (GLfloat) ctx->Fog.ColorSumEnabled;
+	 break;
+      case GL_CURRENT_SECONDARY_COLOR_EXT:
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = (ctx->Current.SecondaryColor[0]);
+         params[1] = (ctx->Current.SecondaryColor[1]);
+         params[2] = (ctx->Current.SecondaryColor[2]);
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         *params = (GLfloat) ctx->Array.SecondaryColor.Enabled;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+	 *params = (GLfloat) ctx->Array.SecondaryColor.Type;
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+	 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+	 *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
+	 break;
+
+      /* GL_EXT_fog_coord */
+      case GL_CURRENT_FOG_COORDINATE_EXT:
+	 FLUSH_CURRENT(ctx, 0);
+	 *params = (GLfloat) ctx->Current.FogCoord;
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+         *params = (GLfloat) ctx->Array.FogCoord.Enabled;
+         break;
+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+	 *params = (GLfloat) ctx->Array.FogCoord.Type;
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+	 *params = (GLfloat) ctx->Array.FogCoord.Stride;
+	 break;
+
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = ctx->Const.MaxTextureLodBias;
+         break;
+
+      /* GL_EXT_texture_filter_anisotropic */
+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+	    *params = ctx->Const.MaxTextureMaxAnisotropy;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+	 break;
+
+      /* GL_ARB_multisample */
+      case GL_MULTISAMPLE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLfloat) ctx->Multisample.Enabled;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLfloat) ctx->Multisample.SampleAlphaToCoverage;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLfloat) ctx->Multisample.SampleAlphaToOne;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLfloat) ctx->Multisample.SampleCoverage;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = ctx->Multisample.SampleCoverageValue;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLfloat) ctx->Multisample.SampleCoverageInvert;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_SAMPLE_BUFFERS_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0.0; /* XXX fix someday */
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+      case GL_SAMPLES_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0.0; /* XXX fix someday */
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         if (ctx->Extensions.IBM_rasterpos_clip) {
+            *params = (GLfloat) ctx->Transform.RasterPositionUnclipped;
+         }
+         else {
+            GET_FLOAT_ERROR;
+            return;
+         }
+         break;
+
+      /* GL_SGIS_generate_mipmap */
+      case GL_GENERATE_MIPMAP_HINT_SGIS:
+         if (ctx->Extensions.SGIS_generate_mipmap) {
+            *params = (GLfloat) ctx->Hint.GenerateMipmap;
+         }
+         else {
+            GET_FLOAT_ERROR;
+	    return;
+         }
+         break;
 
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_F(NV_texture_rectangle, pname);
+         *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_F(NV_texture_rectangle, pname);
+         *params = (GLfloat) textureUnit->CurrentRect->Name;
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_F(NV_texture_rectangle, pname);
+         *params = (GLfloat) ctx->Const.MaxTextureRectSize;
+         break;
 
+       default:
+         GET_FLOAT_ERROR;
+   }
+}
 
 
 void
@@ -3778,16 +4029,19 @@
    GET_CURRENT_CONTEXT(ctx);
    GLuint i;
    GLuint texUnit = ctx->Texture.CurrentUnit;
-   GLuint texTransformUnit = ctx->Texture.CurrentTransformUnit;
    const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetIntegerv");
-
    if (!params)
       return;
+
+   /* We need this in order to get correct results for
+    * GL_OCCLUSION_TEST_RESULT_HP.  There might be other important cases.
+    */
+   FLUSH_VERTICES(ctx, 0);
 
-   if (MESA_VERBOSE & VERBOSE_API) 
-      fprintf(stderr, "glGetIntegerv %s\n", gl_lookup_enum_by_nr(pname));
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glGetIntegerv %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetIntegerv
        && (*ctx->Driver.GetIntegerv)(ctx, pname, params))
@@ -3795,16 +4049,16 @@
 
    switch (pname) {
       case GL_ACCUM_RED_BITS:
-         *params = (GLint) ctx->Visual->AccumRedBits;
+         *params = (GLint) ctx->Visual.accumRedBits;
          break;
       case GL_ACCUM_GREEN_BITS:
-         *params = (GLint) ctx->Visual->AccumGreenBits;
+         *params = (GLint) ctx->Visual.accumGreenBits;
          break;
       case GL_ACCUM_BLUE_BITS:
-         *params = (GLint) ctx->Visual->AccumBlueBits;
+         *params = (GLint) ctx->Visual.accumBlueBits;
          break;
       case GL_ACCUM_ALPHA_BITS:
-         *params = (GLint) ctx->Visual->AccumAlphaBits;
+         *params = (GLint) ctx->Visual.accumAlphaBits;
          break;
       case GL_ACCUM_CLEAR_VALUE:
          params[0] = FLOAT_TO_INT( ctx->Accum.ClearColor[0] );
@@ -3816,7 +4070,7 @@
          *params = (GLint) ctx->Pixel.AlphaBias;
          break;
       case GL_ALPHA_BITS:
-         *params = ctx->Visual->AlphaBits;
+         *params = ctx->Visual.alphaBits;
          break;
       case GL_ALPHA_SCALE:
          *params = (GLint) ctx->Pixel.AlphaScale;
@@ -3825,7 +4079,7 @@
          *params = (GLint) ctx->Color.AlphaEnabled;
          break;
       case GL_ALPHA_TEST_REF:
-         *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / 255.0 );
+         *params = FLOAT_TO_INT( (GLfloat) ctx->Color.AlphaRef / CHAN_MAXF );
          break;
       case GL_ALPHA_TEST_FUNC:
          *params = (GLint) ctx->Color.AlphaFunc;
@@ -3873,7 +4127,7 @@
          *params = (GLint) ctx->Pixel.BlueBias;
          break;
       case GL_BLUE_BITS:
-         *params = (GLint) ctx->Visual->BlueBits;
+         *params = (GLint) ctx->Visual.blueBits;
          break;
       case GL_BLUE_SCALE:
          *params = (GLint) ctx->Pixel.BlueScale;
@@ -3891,10 +4145,10 @@
          *params = (GLint) ctx->Transform.ClipEnabled[i];
          break;
       case GL_COLOR_CLEAR_VALUE:
-         params[0] = FLOAT_TO_INT( ctx->Color.ClearColor[0] );
-         params[1] = FLOAT_TO_INT( ctx->Color.ClearColor[1] );
-         params[2] = FLOAT_TO_INT( ctx->Color.ClearColor[2] );
-         params[3] = FLOAT_TO_INT( ctx->Color.ClearColor[3] );
+         params[0] = FLOAT_TO_INT( (ctx->Color.ClearColor[0]) );
+         params[1] = FLOAT_TO_INT( (ctx->Color.ClearColor[1]) );
+         params[2] = FLOAT_TO_INT( (ctx->Color.ClearColor[2]) );
+         params[3] = FLOAT_TO_INT( (ctx->Color.ClearColor[3]) );
          break;
       case GL_COLOR_MATERIAL:
          *params = (GLint) ctx->Light.ColorMaterialEnabled;
@@ -3918,15 +4172,18 @@
          *params = (GLint) ctx->Polygon.CullFaceMode;
          break;
       case GL_CURRENT_COLOR:
-         params[0] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[0] ) );
-         params[1] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[1] ) );
-         params[2] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[2] ) );
-         params[3] = FLOAT_TO_INT( UBYTE_COLOR_TO_FLOAT_COLOR( ctx->Current.ByteColor[3] ) );
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = FLOAT_TO_INT( ( ctx->Current.Color[0] ) );
+         params[1] = FLOAT_TO_INT( ( ctx->Current.Color[1] ) );
+         params[2] = FLOAT_TO_INT( ( ctx->Current.Color[2] ) );
+         params[3] = FLOAT_TO_INT( ( ctx->Current.Color[3] ) );
          break;
       case GL_CURRENT_INDEX:
+	 FLUSH_CURRENT(ctx, 0);
          *params = (GLint) ctx->Current.Index;
          break;
       case GL_CURRENT_NORMAL:
+	 FLUSH_CURRENT(ctx, 0);
          params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
          params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
          params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
@@ -3950,25 +4207,26 @@
 	 params[3] = (GLint) ctx->Current.RasterPos[3];
 	 break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-	 params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][0];
-	 params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][1];
-	 params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][2];
-	 params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texTransformUnit][3];
+	 params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][0];
+	 params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][1];
+	 params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][2];
+	 params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][3];
 	 break;
       case GL_CURRENT_RASTER_POSITION_VALID:
 	 *params = (GLint) ctx->Current.RasterPosValid;
 	 break;
       case GL_CURRENT_TEXTURE_COORDS:
-         params[0] = (GLint) ctx->Current.Texcoord[texTransformUnit][0];
-         params[1] = (GLint) ctx->Current.Texcoord[texTransformUnit][1];
-         params[2] = (GLint) ctx->Current.Texcoord[texTransformUnit][2];
-         params[3] = (GLint) ctx->Current.Texcoord[texTransformUnit][3];
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = (GLint) ctx->Current.Texcoord[texUnit][0];
+         params[1] = (GLint) ctx->Current.Texcoord[texUnit][1];
+         params[2] = (GLint) ctx->Current.Texcoord[texUnit][2];
+         params[3] = (GLint) ctx->Current.Texcoord[texUnit][3];
 	 break;
       case GL_DEPTH_BIAS:
          *params = (GLint) ctx->Pixel.DepthBias;
 	 break;
       case GL_DEPTH_BITS:
-	 *params = ctx->Visual->DepthBits;
+	 *params = ctx->Visual.depthBits;
 	 break;
       case GL_DEPTH_CLEAR_VALUE:
          *params = (GLint) ctx->Depth.Clear;
@@ -3993,12 +4251,13 @@
 	 *params = (GLint) ctx->Color.DitherFlag;
 	 break;
       case GL_DOUBLEBUFFER:
-	 *params = (GLint) ctx->Visual->DBflag;
+	 *params = (GLint) ctx->Visual.doubleBufferMode;
 	 break;
       case GL_DRAW_BUFFER:
 	 *params = (GLint) ctx->Color.DrawBuffer;
 	 break;
       case GL_EDGE_FLAG:
+	 FLUSH_CURRENT(ctx, 0);
 	 *params = (GLint) ctx->Current.EdgeFlag;
 	 break;
       case GL_FEEDBACK_BUFFER_SIZE:
@@ -4041,22 +4300,28 @@
          *params = (GLint) ctx->Pixel.GreenBias;
          break;
       case GL_GREEN_BITS:
-         *params = (GLint) ctx->Visual->GreenBits;
+         *params = (GLint) ctx->Visual.greenBits;
          break;
       case GL_GREEN_SCALE:
          *params = (GLint) ctx->Pixel.GreenScale;
          break;
       case GL_HISTOGRAM:
-         *params = (GLint) ctx->Pixel.HistogramEnabled;
+         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
+            *params = (GLint) ctx->Pixel.HistogramEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+            return;
+         }
 	 break;
       case GL_INDEX_BITS:
-         *params = (GLint) ctx->Visual->IndexBits;
+         *params = (GLint) ctx->Visual.indexBits;
          break;
       case GL_INDEX_CLEAR_VALUE:
          *params = (GLint) ctx->Color.ClearIndex;
          break;
       case GL_INDEX_MODE:
-	 *params = ctx->Visual->RGBAflag ? 0 : 1;
+	 *params = ctx->Visual.rgbMode ? 0 : 1;
 	 break;
       case GL_INDEX_OFFSET:
 	 *params = ctx->Pixel.IndexOffset;
@@ -4230,19 +4495,19 @@
          *params = (GLint) MAX_CLIENT_ATTRIB_STACK_DEPTH;
          break;
       case GL_MAX_CLIP_PLANES:
-         *params = (GLint) MAX_CLIP_PLANES;
+         *params = (GLint) ctx->Const.MaxClipPlanes;
          break;
       case GL_MAX_ELEMENTS_VERTICES:  /* GL_VERSION_1_2 */
-         *params = VB_MAX;
+         *params = (GLint) ctx->Const.MaxArrayLockSize;
          break;
       case GL_MAX_ELEMENTS_INDICES:   /* GL_VERSION_1_2 */
-         *params = VB_MAX;
+         *params = (GLint) ctx->Const.MaxArrayLockSize;
          break;
       case GL_MAX_EVAL_ORDER:
 	 *params = (GLint) MAX_EVAL_ORDER;
 	 break;
       case GL_MAX_LIGHTS:
-         *params = (GLint) MAX_LIGHTS;
+         *params = (GLint) ctx->Const.MaxLights;
          break;
       case GL_MAX_LIST_NESTING:
          *params = (GLint) MAX_LIST_NESTING;
@@ -4260,8 +4525,10 @@
          *params = (GLint) MAX_PROJECTION_STACK_DEPTH;
          break;
       case GL_MAX_TEXTURE_SIZE:
+         *params = (1 << (ctx->Const.MaxTextureLevels - 1));
+	 break;
       case GL_MAX_3D_TEXTURE_SIZE:
-         *params = ctx->Const.MaxTextureSize;
+         *params = (1 << (ctx->Const.Max3DTextureLevels - 1));
 	 break;
       case GL_MAX_TEXTURE_STACK_DEPTH:
 	 *params = (GLint) MAX_TEXTURE_STACK_DEPTH;
@@ -4311,6 +4578,9 @@
       case GL_PACK_IMAGE_HEIGHT_EXT:
          *params = ctx->Pack.ImageHeight;
          break;
+      case GL_PACK_INVERT_MESA:
+         *params = ctx->Pack.Invert;
+         break;
       case GL_PERSPECTIVE_CORRECTION_HINT:
 	 *params = (GLint) ctx->Hint.PerspectiveCorrection;
 	 break;
@@ -4345,7 +4615,7 @@
 	 *params = ctx->Pixel.MapStoSsize;
 	 break;
       case GL_POINT_SIZE:
-         *params = (GLint) ctx->Point.UserSize;
+         *params = (GLint) ctx->Point.Size;
          break;
       case GL_POINT_SIZE_GRANULARITY:
 	 *params = (GLint) ctx->Const.PointSizeGranularity;
@@ -4415,7 +4685,7 @@
          *params = (GLint) ctx->Pixel.RedBias;
          break;
       case GL_RED_BITS:
-         *params = (GLint) ctx->Visual->RedBits;
+         *params = (GLint) ctx->Visual.redBits;
          break;
       case GL_RED_SCALE:
          *params = (GLint) ctx->Pixel.RedScale;
@@ -4427,7 +4697,7 @@
          *params = (GLint) ctx->Transform.RescaleNormals;
          break;
       case GL_RGBA_MODE:
-	 *params = (GLint) ctx->Visual->RGBAflag;
+	 *params = (GLint) ctx->Visual.rgbMode;
 	 break;
       case GL_SCISSOR_BOX:
 	 params[0] = (GLint) ctx->Scissor.X;
@@ -4448,7 +4718,7 @@
          *params = (GLint) ctx->Texture.SharedPalette;
          break;
       case GL_STENCIL_BITS:
-         *params = ctx->Visual->StencilBits;
+         *params = ctx->Visual.stencilBits;
          break;
       case GL_STENCIL_CLEAR_VALUE:
 	 *params = (GLint) ctx->Stencil.Clear;
@@ -4478,7 +4748,7 @@
 	 *params = (GLint) ctx->Stencil.WriteMask;
 	 break;
       case GL_STEREO:
-	 *params = (GLint) ctx->Visual->StereoFlag;
+	 *params = (GLint) ctx->Visual.stereoMode;
 	 break;
       case GL_SUBPIXEL_BITS:
 	 *params = ctx->Const.SubPixelBits;
@@ -4493,13 +4763,13 @@
          *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1 : 0;
 	 break;
       case GL_TEXTURE_BINDING_1D:
-         *params = textureUnit->CurrentD[1]->Name;
+         *params = textureUnit->Current1D->Name;
           break;
       case GL_TEXTURE_BINDING_2D:
-         *params = textureUnit->CurrentD[2]->Name;
+         *params = textureUnit->Current2D->Name;
           break;
       case GL_TEXTURE_BINDING_3D:
-         *params = textureUnit->CurrentD[3]->Name;
+         *params = textureUnit->Current3D->Name;
           break;
       case GL_TEXTURE_ENV_COLOR:
 	 params[0] = FLOAT_TO_INT( textureUnit->EnvColor[0] );
@@ -4524,11 +4794,11 @@
 	 break;
       case GL_TEXTURE_MATRIX:
          for (i=0;i<16;i++) {
-	    params[i] = (GLint) ctx->TextureMatrix[texTransformUnit].m[i];
+	    params[i] = (GLint) ctx->TextureMatrix[texUnit].m[i];
 	 }
 	 break;
       case GL_TEXTURE_STACK_DEPTH:
-	 *params = (GLint) (ctx->TextureStackDepth[texTransformUnit] + 1);
+	 *params = (GLint) (ctx->TextureStackDepth[texUnit] + 1);
 	 break;
       case GL_UNPACK_ALIGNMENT:
 	 *params = ctx->Unpack.Alignment;
@@ -4554,6 +4824,9 @@
       case GL_UNPACK_IMAGE_HEIGHT_EXT:
          *params = ctx->Unpack.ImageHeight;
          break;
+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
+         *params = ctx->Unpack.ClientStorage;
+         break;
       case GL_VIEWPORT:
          params[0] = (GLint) ctx->Viewport.X;
          params[1] = (GLint) ctx->Viewport.Y;
@@ -4567,159 +4840,79 @@
 	 *params = (GLint) ctx->Pixel.ZoomY;
 	 break;
       case GL_VERTEX_ARRAY:
-#ifdef VAO
-         *params = (GLint) ctx->Array.Current->Vertex.Enabled;
-#else
          *params = (GLint) ctx->Array.Vertex.Enabled;
-#endif
          break;
       case GL_VERTEX_ARRAY_SIZE:
-#ifdef VAO
-         *params = ctx->Array.Current->Vertex.Size;
-#else
          *params = ctx->Array.Vertex.Size;
-#endif
          break;
       case GL_VERTEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ctx->Array.Current->Vertex.Type;
-#else
          *params = ctx->Array.Vertex.Type;
-#endif
          break;
       case GL_VERTEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = ctx->Array.Current->Vertex.Stride;
-#else
          *params = ctx->Array.Vertex.Stride;
-#endif
          break;
       case GL_VERTEX_ARRAY_COUNT_EXT:
          *params = 0;
          break;
       case GL_NORMAL_ARRAY:
-#ifdef VAO
-         *params = (GLint) ctx->Array.Current->Normal.Enabled;
-#else
          *params = (GLint) ctx->Array.Normal.Enabled;
-#endif
          break;
       case GL_NORMAL_ARRAY_TYPE:
-#ifdef VAO
-         *params = ctx->Array.Current->Normal.Type;
-#else
          *params = ctx->Array.Normal.Type;
-#endif
          break;
       case GL_NORMAL_ARRAY_STRIDE:
-#ifdef VAO
-         *params = ctx->Array.Current->Normal.Stride;
-#else
          *params = ctx->Array.Normal.Stride;
-#endif
          break;
       case GL_NORMAL_ARRAY_COUNT_EXT:
          *params = 0;
          break;
       case GL_COLOR_ARRAY:
-#ifdef VAO
-         *params = (GLint) ctx->Array.Current->Color.Enabled;
-#else
          *params = (GLint) ctx->Array.Color.Enabled;
-#endif
          break;
       case GL_COLOR_ARRAY_SIZE:
-#ifdef VAO
-         *params = ctx->Array.Current->Color.Size;
-#else
          *params = ctx->Array.Color.Size;
-#endif
          break;
       case GL_COLOR_ARRAY_TYPE:
-#ifdef VAO
-         *params = ctx->Array.Current->Color.Type;
-#else
          *params = ctx->Array.Color.Type;
-#endif
          break;
       case GL_COLOR_ARRAY_STRIDE:
-#ifdef VAO
-         *params = ctx->Array.Current->Color.Stride;
-#else
          *params = ctx->Array.Color.Stride;
-#endif
          break;
       case GL_COLOR_ARRAY_COUNT_EXT:
          *params = 0;
          break;
       case GL_INDEX_ARRAY:
-#ifdef VAO
-         *params = (GLint) ctx->Array.Current->Index.Enabled;
-#else
          *params = (GLint) ctx->Array.Index.Enabled;
-#endif
          break;
       case GL_INDEX_ARRAY_TYPE:
-#ifdef VAO
-         *params = ctx->Array.Current->Index.Type;
-#else
          *params = ctx->Array.Index.Type;
-#endif
          break;
       case GL_INDEX_ARRAY_STRIDE:
-#ifdef VAO
-         *params = ctx->Array.Current->Index.Stride;
-#else
          *params = ctx->Array.Index.Stride;
-#endif
          break;
       case GL_INDEX_ARRAY_COUNT_EXT:
          *params = 0;
          break;
       case GL_TEXTURE_COORD_ARRAY:
-#ifdef VAO
-         *params = (GLint) ctx->Array.Current->TexCoord[texUnit].Enabled;
-#else
          *params = (GLint) ctx->Array.TexCoord[texUnit].Enabled;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_SIZE:
-#ifdef VAO
-         *params = ctx->Array.Current->TexCoord[texUnit].Size;
-#else
          *params = ctx->Array.TexCoord[texUnit].Size;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_TYPE:
-#ifdef VAO
-         *params = ctx->Array.Current->TexCoord[texUnit].Type;
-#else
          *params = ctx->Array.TexCoord[texUnit].Type;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_STRIDE:
-#ifdef VAO
-         *params = ctx->Array.Current->TexCoord[texUnit].Stride;
-#else
          *params = ctx->Array.TexCoord[texUnit].Stride;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
          *params = 0;
          break;
       case GL_EDGE_FLAG_ARRAY:
-#ifdef VAO
-         *params = (GLint) ctx->Array.Current->EdgeFlag.Enabled;
-#else
          *params = (GLint) ctx->Array.EdgeFlag.Enabled;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_STRIDE:
-#ifdef VAO
-         *params = ctx->Array.Current->EdgeFlag.Stride;
-#else
          *params = ctx->Array.EdgeFlag.Stride;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
          *params = 0;
@@ -4738,121 +4931,63 @@
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          return;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             *params = textureUnit->CurrentCubeMap->Name;
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          return;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
-            *params = ctx->Const.MaxCubeTextureSize;
+         if (ctx->Extensions.ARB_texture_cube_map)
+            *params = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          return;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = (GLint) ctx->Hint.TextureCompression;
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = (GLint) ctx->Const.NumCompressedTextureFormats;
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLint) ctx->Const.CompressedTextureFormats[i];
          }
          else
-            gl_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-         break;
-
-      /* GL_PGI_misc_hints */
-      case GL_STRICT_DEPTHFUNC_HINT_PGI:
-	 *params = (GL_NICEST);
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          break;
-      case GL_STRICT_LIGHTING_HINT_PGI:
-	 *params = (ctx->Hint.StrictLighting);
-	 break;
-      case GL_STRICT_SCISSOR_HINT_PGI:
-      case GL_FULL_STIPPLE_HINT_PGI:
-	 *params = GL_TRUE;
-	 break;
-      case GL_CONSERVE_MEMORY_HINT_PGI:
-	 *params = GL_FALSE;
-	 break;
-      case GL_ALWAYS_FAST_HINT_PGI:
-	 *params = (ctx->Hint.AllowDrawWin == GL_TRUE &&
-		    ctx->Hint.AllowDrawFrg == GL_FALSE && 
-		    ctx->Hint.AllowDrawMem == GL_FALSE);
-	 break;
-      case GL_ALWAYS_SOFT_HINT_PGI:
-	 *params =  (ctx->Hint.AllowDrawWin == GL_TRUE &&
-		     ctx->Hint.AllowDrawFrg == GL_TRUE && 
-		     ctx->Hint.AllowDrawMem == GL_TRUE);
-	 break;
-      case GL_ALLOW_DRAW_OBJ_HINT_PGI:
-	 *params = GL_TRUE;
-	 break;
-      case GL_ALLOW_DRAW_WIN_HINT_PGI:
-	 *params = ctx->Hint.AllowDrawWin;
-	 break;
-      case GL_ALLOW_DRAW_FRG_HINT_PGI:
-	 *params = ctx->Hint.AllowDrawFrg;
-	 break;
-      case GL_ALLOW_DRAW_MEM_HINT_PGI:
-	 *params = ctx->Hint.AllowDrawMem;
-	 break;
-      case GL_CLIP_NEAR_HINT_PGI:
-      case GL_CLIP_FAR_HINT_PGI:
-	 *params = GL_TRUE;
-	 break;
-      case GL_WIDE_LINE_HINT_PGI:
-	 *params = GL_DONT_CARE;
-	 break;
-      case GL_BACK_NORMALS_HINT_PGI:
-	 *params = GL_TRUE;
-	 break;
-      case GL_NATIVE_GRAPHICS_HANDLE_PGI:
-	 *params = 0;
-	 break;
 
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-#ifdef VAO
-	 *params = ctx->Array.Current->LockFirst;
-#else
 	 *params = ctx->Array.LockFirst;
-#endif
 	 break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-#ifdef VAO
-	 *params = ctx->Array.Current->LockCount;
-#else
 	 *params = ctx->Array.LockCount;
-#endif
 	 break;
-	 
+
       /* GL_ARB_transpose_matrix */
       case GL_TRANSPOSE_COLOR_MATRIX_ARB:
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ColorMatrix.m);
+            _math_transposef(tm, ctx->ColorMatrix.m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4862,7 +4997,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ModelView.m);
+            _math_transposef(tm, ctx->ModelView.m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4872,7 +5007,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->ProjectionMatrix.m);
+            _math_transposef(tm, ctx->ProjectionMatrix.m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4882,7 +5017,7 @@
          {
             GLfloat tm[16];
             GLuint i;
-            gl_matrix_transposef(tm, ctx->TextureMatrix[texTransformUnit].m);
+            _math_transposef(tm, ctx->TextureMatrix[texUnit].m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4891,15 +5026,15 @@
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             *params = (GLint) ctx->Depth.OcclusionTest;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
          }
          return;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HaveHpOcclusionTest) {
+         if (ctx->Extensions.HP_occlusion_test) {
             if (ctx->Depth.OcclusionTest)
                *params = (GLint) ctx->OcclusionResult;
             else
@@ -4909,7 +5044,7 @@
             ctx->OcclusionResultSaved = GL_FALSE;
          }
          else {
-            gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
          }
          return;
 
@@ -4964,12 +5099,33 @@
          break;
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
-      case GL_MAX_CONVOLUTION_WIDTH:
-         *params = ctx->Const.MaxConvolutionWidth;
+      case GL_CONVOLUTION_1D_EXT:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLint) ctx->Pixel.Convolution1DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
          break;
-      case GL_MAX_CONVOLUTION_HEIGHT:
-         *params = ctx->Const.MaxConvolutionHeight;
+      case GL_CONVOLUTION_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLint) ctx->Pixel.Convolution2DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
          break;
+      case GL_SEPARABLE_2D:
+         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
+            *params = (GLint) ctx->Pixel.Separable2DEnabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
          *params = (GLint) ctx->Pixel.PostConvolutionScale[0];
          break;
@@ -5006,8 +5162,193 @@
          *params = (GLint) ctx->Pixel.PostColorMatrixColorTableEnabled;
          break;
 
+
+      /* GL_EXT_secondary_color */
+      case GL_COLOR_SUM_EXT:
+	 *params = (GLint) ctx->Fog.ColorSumEnabled;
+	 break;
+      case GL_CURRENT_SECONDARY_COLOR_EXT:
+	 FLUSH_CURRENT(ctx, 0);
+         params[0] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[0]) );
+         params[1] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[1]) );
+         params[2] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[2]) );
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         *params = (GLint) ctx->Array.SecondaryColor.Enabled;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+	 *params = (GLint) ctx->Array.SecondaryColor.Type;
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+	 *params = (GLint) ctx->Array.SecondaryColor.Stride;
+	 break;
+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+	 *params = (GLint) ctx->Array.SecondaryColor.Stride;
+	 break;
+
+      /* GL_EXT_fog_coord */
+      case GL_CURRENT_FOG_COORDINATE_EXT:
+         if (ctx->Extensions.EXT_fog_coord) {
+            FLUSH_CURRENT(ctx, 0);
+            *params = (GLint) ctx->Current.FogCoord;
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+         }
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+         if (ctx->Extensions.EXT_fog_coord) {
+            *params = (GLint) ctx->Array.FogCoord.Enabled;
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+         }
+         break;
+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         if (ctx->Extensions.EXT_fog_coord) {
+            *params = (GLint) ctx->Array.FogCoord.Type;
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+         }
+	 break;
+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         if (ctx->Extensions.EXT_fog_coord) {
+            *params = (GLint) ctx->Array.FogCoord.Stride;
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+         }
+	 break;
+
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = (GLint) ctx->Const.MaxTextureLodBias;
+         break;
+
+      /* GL_EXT_texture_filter_anisotropic */
+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+	    *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy;
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+            return;
+         }
+	 break;
+
+      /* GL_ARB_multisample */
+      case GL_MULTISAMPLE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLint) ctx->Multisample.Enabled;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLint) ctx->Multisample.SampleAlphaToCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLint) ctx->Multisample.SampleAlphaToOne;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLint) ctx->Multisample.SampleCoverage;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLint) ctx->Multisample.SampleCoverageValue;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = (GLint) ctx->Multisample.SampleCoverageInvert;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+      case GL_SAMPLE_BUFFERS_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0; /* XXX fix someday */
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+      case GL_SAMPLES_ARB:
+         if (ctx->Extensions.ARB_multisample) {
+            *params = 0; /* XXX fix someday */
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         if (ctx->Extensions.IBM_rasterpos_clip) {
+            *params = (GLint) ctx->Transform.RasterPositionUnclipped;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+            return;
+         }
+         break;
+
+      /* GL_SGIS_generate_mipmap */
+      case GL_GENERATE_MIPMAP_HINT_SGIS:
+         if (ctx->Extensions.SGIS_generate_mipmap) {
+            *params = (GLint) ctx->Hint.GenerateMipmap;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+	    return;
+         }
+         break;
+
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_I(NV_texture_rectangle, pname);
+         *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_I(NV_texture_rectangle, pname);
+         *params = (GLint) textureUnit->CurrentRect->Name;
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_I(NV_texture_rectangle, pname);
+         *params = (GLint) ctx->Const.MaxTextureRectSize;
+         break;
+
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
    }
 }
 
@@ -5018,14 +5359,13 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLuint texUnit = ctx->Texture.CurrentUnit;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetPointerv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (!params)
       return;
 
-   if (MESA_VERBOSE & VERBOSE_API) 
-      fprintf(stderr, "glGetPointerv %s\n", gl_lookup_enum_by_nr(pname));
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glGetPointerv %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetPointerv
        && (*ctx->Driver.GetPointerv)(ctx, pname, params))
@@ -5033,46 +5373,28 @@
 
    switch (pname) {
       case GL_VERTEX_ARRAY_POINTER:
-#ifdef VAO
-         *params = ctx->Array.Current->Vertex.Ptr;
-#else
          *params = ctx->Array.Vertex.Ptr;
-#endif
          break;
       case GL_NORMAL_ARRAY_POINTER:
-#ifdef VAO
-         *params = ctx->Array.Current->Normal.Ptr;
-#else
          *params = ctx->Array.Normal.Ptr;
-#endif
          break;
       case GL_COLOR_ARRAY_POINTER:
-#ifdef VAO
-         *params = ctx->Array.Current->Color.Ptr;
-#else
          *params = ctx->Array.Color.Ptr;
-#endif
          break;
+      case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT:
+         *params = ctx->Array.SecondaryColor.Ptr;
+         break;
+      case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
+         *params = ctx->Array.FogCoord.Ptr;
+         break;
       case GL_INDEX_ARRAY_POINTER:
-#ifdef VAO
-         *params = ctx->Array.Current->Index.Ptr;
-#else
          *params = ctx->Array.Index.Ptr;
-#endif
          break;
       case GL_TEXTURE_COORD_ARRAY_POINTER:
-#ifdef VAO
-         *params = ctx->Array.Current->TexCoord[texUnit].Ptr;
-#else
          *params = ctx->Array.TexCoord[texUnit].Ptr;
-#endif
          break;
       case GL_EDGE_FLAG_ARRAY_POINTER:
-#ifdef VAO
-         *params = ctx->Array.Current->EdgeFlag.Ptr;
-#else
          *params = ctx->Array.EdgeFlag.Ptr;
-#endif
          break;
       case GL_FEEDBACK_BUFFER_POINTER:
          *params = ctx->Feedback.Buffer;
@@ -5081,7 +5403,7 @@
          *params = ctx->Select.Buffer;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerv" );
          return;
    }
 }
@@ -5094,9 +5416,10 @@
    GET_CURRENT_CONTEXT(ctx);
    static const char *vendor = "Brian Paul";
    static const char *renderer = "Mesa";
-   static const char *version = "1.2 Mesa 3.4.2";
+   static const char *version_1_2 = "1.2 Mesa 4.0.4";
+   static const char *version_1_3 = "1.3 Mesa 4.0.4";
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glGetString", 0);
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
 
    /* this is a required driver function */
    assert(ctx->Driver.GetString);
@@ -5111,12 +5434,22 @@
           case GL_RENDERER:
              return (const GLubyte *) renderer;
           case GL_VERSION:
-             return (const GLubyte *) version;
+             if (ctx->Extensions.ARB_multitexture &&
+                 ctx->Extensions.ARB_multisample &&
+                 ctx->Extensions.ARB_texture_border_clamp &&
+                 ctx->Extensions.ARB_texture_compression &&
+                 ctx->Extensions.ARB_texture_cube_map &&
+                 ctx->Extensions.EXT_texture_env_add &&
+                 ctx->Extensions.ARB_texture_env_combine &&
+                 ctx->Extensions.ARB_texture_env_dot3)
+                return (const GLubyte *) version_1_3;
+             else
+                return (const GLubyte *) version_1_2;
           case GL_EXTENSIONS:
-             return (GLubyte *) gl_extensions_get_string( ctx );
+             return (const GLubyte *) _mesa_extensions_get_string(ctx);
           default:
-             gl_error( ctx, GL_INVALID_ENUM, "glGetString" );
-             return (GLubyte *) 0;
+             _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" );
+             return (const GLubyte *) 0;
        }
    }
 }
@@ -5129,15 +5462,12 @@
 _mesa_GetError( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-
    GLenum e = ctx->ErrorValue;
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
 
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL( ctx, "glGetError", (GLenum) 0);
-
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glGetError <-- %s\n", gl_lookup_enum_by_nr(e));
+      fprintf(stderr, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e));
 
    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
    return e;
 }
-
Index: xc/extras/Mesa/src/get.h
diff -u xc/extras/Mesa/src/get.h:1.3 xc/extras/Mesa/src/get.h:1.4
--- xc/extras/Mesa/src/get.h:1.3	Tue Feb 15 02:12:15 2000
+++ xc/extras/Mesa/src/get.h	Fri Feb 22 14:25:30 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define GET_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
@@ -55,4 +55,3 @@
 
 
 #endif
-
Index: xc/extras/Mesa/src/glapi.c
diff -u xc/extras/Mesa/src/glapi.c:1.10 xc/extras/Mesa/src/glapi.c:1.13
--- xc/extras/Mesa/src/glapi.c:1.10	Wed Dec 19 10:44:34 2001
+++ xc/extras/Mesa/src/glapi.c	Mon Dec 16 11:18:26 2002
@@ -1,9 +1,9 @@
-/* $XFree86: xc/extras/Mesa/src/glapi.c,v 1.10 2001/12/19 15:44:34 tsi Exp $ */
+
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.1
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -37,44 +37,149 @@
  * based libGL.so, and perhaps the SGI SI.
  *
  * There are no dependencies on Mesa in this code.
+ *
+ * Versions (API changes):
+ *   2000/02/23  - original version for Mesa 3.3 and XFree86 4.0
+ *   2001/01/16  - added dispatch override feature for Mesa 3.5
  */
 
 
 
 #include "glheader.h"
 #include "glapi.h"
-#include "glapinoop.h"
 #include "glapioffsets.h"
 #include "glapitable.h"
 #include "glthread.h"
 
+/***** BEGIN NO-OP DISPATCH *****/
 
-/* This is used when thread safety is disabled */
-struct _glapi_table *_glapi_Dispatch = (struct _glapi_table *) __glapi_noop_table;
+static GLboolean WarnFlag = GL_FALSE;
 
-/* Used when thread safety disabled */
-void *_glapi_Context = NULL;
+void
+_glapi_noop_enable_warnings(GLboolean enable)
+{
+   WarnFlag = enable;
+}
+
+static GLboolean
+warn(void)
+{
+   if (WarnFlag || getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG"))
+      return GL_TRUE;
+   else
+      return GL_FALSE;
+}
+
+
+#define KEYWORD1 static
+#define KEYWORD2
+#define NAME(func)  NoOp##func
+
+#define F stderr
 
+#define DISPATCH(func, args, msg)			\
+   if (warn()) {					\
+      fprintf(stderr, "GL User Error: calling ");	\
+      fprintf msg;					\
+      fprintf(stderr, " without a current context\n");	\
+   }
+
+#define RETURN_DISPATCH(func, args, msg)		\
+   if (warn()) {					\
+      fprintf(stderr, "GL User Error: calling ");	\
+      fprintf msg;					\
+      fprintf(stderr, " without a current context\n");	\
+   }							\
+   return 0
+
+#define DISPATCH_TABLE_NAME __glapi_noop_table
+#define UNUSED_TABLE_NAME __usused_noop_functions
 
+#define TABLE_ENTRY(name) (void *) NoOp##name
+
+static int NoOpUnused(void)
+{
+   if (warn()) {
+      fprintf(stderr, "GL User Error: calling extension function without a current context\n");
+   }
+   return 0;
+}
+
+#include "glapitemp.h"
+
+/***** END NO-OP DISPATCH *****/
+
+
+
+/***** BEGIN THREAD-SAFE DISPATCH *****/
+/* if we support thread-safety, build a special dispatch table for use
+ * in thread-safety mode (ThreadSafe == GL_TRUE).  Each entry in the
+ * dispatch table will call _glthread_GetTSD() to get the actual dispatch
+ * table bound to the current thread, then jump through that table.
+ */
+
 #if defined(THREADS)
 
-/* Flag to indicate whether thread-safe dispatch is enabled */
-static GLboolean ThreadSafe = GL_FALSE;
+static GLboolean ThreadSafe = GL_FALSE;  /* In thread-safe mode? */
+static _glthread_TSD DispatchTSD;        /* Per-thread dispatch pointer */
+static _glthread_TSD RealDispatchTSD;    /* only when using override */
+static _glthread_TSD ContextTSD;         /* Per-thread context pointer */
+
+
+#define KEYWORD1 static
+#define KEYWORD2 GLAPIENTRY
+#define NAME(func)  _ts_##func
+
+#define DISPATCH(FUNC, ARGS, MESSAGE)					\
+   struct _glapi_table *dispatch;					\
+   dispatch = (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);	\
+   if (!dispatch)							\
+      dispatch = (struct _glapi_table *) __glapi_noop_table;		\
+   (dispatch->FUNC) ARGS
+
+#define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) 				\
+   struct _glapi_table *dispatch;					\
+   dispatch = (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);	\
+   if (!dispatch)							\
+      dispatch = (struct _glapi_table *) __glapi_noop_table;		\
+   return (dispatch->FUNC) ARGS
 
-static _glthread_TSD DispatchTSD;
+#define DISPATCH_TABLE_NAME __glapi_threadsafe_table
+#define UNUSED_TABLE_NAME __usused_threadsafe_functions
 
-static _glthread_TSD ContextTSD;
+#define TABLE_ENTRY(name) (void *) _ts_##name
 
+static int _ts_Unused(void)
+{
+   return 0;
+}
+
+#include "glapitemp.h"
+
 #endif
 
+/***** END THREAD-SAFE DISPATCH *****/
 
 
+
+struct _glapi_table *_glapi_Dispatch = (struct _glapi_table *) __glapi_noop_table;
+struct _glapi_table *_glapi_RealDispatch = (struct _glapi_table *) __glapi_noop_table;
+
+/* Used when thread safety disabled */
+void *_glapi_Context = NULL;
+
+
 static GLuint MaxDispatchOffset = sizeof(struct _glapi_table) / sizeof(void *) - 1;
 static GLboolean GetSizeCalled = GL_FALSE;
+
+static GLboolean DispatchOverride = GL_FALSE;
+
 
-/* strdup is actually not a standard ANSI C or POSIX routine
-   Irix will not define it if ANSI mode is in effect. */
-static char *str_dup(const char *str)
+/* strdup() is actually not a standard ANSI C or POSIX routine.
+ * Irix will not define it if ANSI mode is in effect.
+ */
+static char *
+str_dup(const char *str)
 {
    char *copy;
    copy = (char*) malloc(strlen(str) + 1);
@@ -177,14 +282,29 @@
 #endif
 
 #if defined(THREADS)
-   _glthread_SetTSD(&DispatchTSD, (void*) dispatch);
-   if (ThreadSafe)
-      _glapi_Dispatch = NULL;
-   else
+   if (DispatchOverride) {
+      _glthread_SetTSD(&RealDispatchTSD, (void *) dispatch);
+      if (ThreadSafe)
+         _glapi_RealDispatch = (struct _glapi_table*) __glapi_threadsafe_table;
+      else
+         _glapi_RealDispatch = dispatch;
+   }
+   else {
+      /* normal operation */
+      _glthread_SetTSD(&DispatchTSD, (void *) dispatch);
+      if (ThreadSafe)
+         _glapi_Dispatch = (struct _glapi_table *) __glapi_threadsafe_table;
+      else
+         _glapi_Dispatch = dispatch;
+   }
+#else /*THREADS*/
+   if (DispatchOverride) {
+      _glapi_RealDispatch = dispatch;
+   }
+   else {
       _glapi_Dispatch = dispatch;
-#else
-   _glapi_Dispatch = dispatch;
-#endif
+   }
+#endif /*THREADS*/
 }
 
 
@@ -197,11 +317,22 @@
 {
 #if defined(THREADS)
    if (ThreadSafe) {
-      return (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);
+      if (DispatchOverride) {
+         return (struct _glapi_table *) _glthread_GetTSD(&RealDispatchTSD);
+      }
+      else {
+         return (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);
+      }
    }
    else {
-      assert(_glapi_Dispatch);
-      return _glapi_Dispatch;
+      if (DispatchOverride) {
+         assert(_glapi_RealDispatch);
+         return _glapi_RealDispatch;
+      }
+      else {
+         assert(_glapi_Dispatch);
+         return _glapi_Dispatch;
+      }
    }
 #else
    return _glapi_Dispatch;
@@ -209,8 +340,89 @@
 }
 
 
+/*
+ * Notes on dispatch overrride:
+ *
+ * Dispatch override allows an external agent to hook into the GL dispatch
+ * mechanism before execution goes into the core rendering library.  For
+ * example, a trace mechanism would insert itself as an overrider, print
+ * logging info for each GL function, then dispatch to the real GL function.
+ *
+ * libGLS (GL Stream library) is another agent that might use override.
+ *
+ * We don't allow more than one layer of overriding at this time.
+ * In the future we may allow nested/layered override.  In that case
+ * _glapi_begin_dispatch_override() will return an override layer,
+ * _glapi_end_dispatch_override(layer) will remove an override layer
+ * and _glapi_get_override_dispatch(layer) will return the dispatch
+ * table for a given override layer.  layer = 0 will be the "real"
+ * dispatch table.
+ */
 
 /*
+ * Return: dispatch override layer number.
+ */
+int
+_glapi_begin_dispatch_override(struct _glapi_table *override)
+{
+   struct _glapi_table *real = _glapi_get_dispatch();
+
+   assert(!DispatchOverride);  /* can't nest at this time */
+   DispatchOverride = GL_TRUE;
+
+   _glapi_set_dispatch(real);
+
+#if defined(THREADS)
+   _glthread_SetTSD(&DispatchTSD, (void *) override);
+   if (ThreadSafe)
+      _glapi_Dispatch = (struct _glapi_table *) __glapi_threadsafe_table;
+   else
+      _glapi_Dispatch = override;
+#else
+   _glapi_Dispatch = override;
+#endif
+   return 1;
+}
+
+
+void
+_glapi_end_dispatch_override(int layer)
+{
+   struct _glapi_table *real = _glapi_get_dispatch();
+   (void) layer;
+   DispatchOverride = GL_FALSE;
+   _glapi_set_dispatch(real);
+   /* the rest of this isn't needed, just play it safe */
+#if defined(THREADS)
+   _glthread_SetTSD(&RealDispatchTSD, NULL);
+#endif
+   _glapi_RealDispatch = NULL;
+}
+
+
+struct _glapi_table *
+_glapi_get_override_dispatch(int layer)
+{
+   if (layer == 0) {
+      return _glapi_get_dispatch();
+   }
+   else {
+      if (DispatchOverride) {
+#if defined(THREADS)
+         return (struct _glapi_table *) _glthread_GetTSD(&DispatchTSD);
+#else
+         return _glapi_Dispatch;
+#endif
+      }
+      else {
+         return NULL;
+      }
+   }
+}
+
+
+
+/*
  * Return size of dispatch table struct as number of functions (or
  * slots).
  */
@@ -230,7 +442,7 @@
 const char *
 _glapi_get_version(void)
 {
-   return "20000223";  /* YYYYMMDD */
+   return "20010116";  /* YYYYMMDD */
 }
 
 
@@ -637,6 +849,63 @@
 	{ "glCopyTexSubImage3D", (GLvoid *) NAME(glCopyTexSubImage3D), _gloffset_CopyTexSubImage3D },
 #undef NAME
 
+	/* 1.3 */
+#ifdef GL_VERSION_1_3
+#define NAME(X) (GLvoid *) X
+#else
+#define NAME(X) NotImplemented
+#endif
+	{ "glActiveTexture", (GLvoid *) NAME(glActiveTexture), _gloffset_ActiveTextureARB },
+	{ "glClientActiveTexture", (GLvoid *) NAME(glClientActiveTexture), _gloffset_ClientActiveTextureARB },
+	{ "glCompressedTexImage1D", (GLvoid *) NAME(glCompressedTexImage1D), _gloffset_CompressedTexImage1DARB },
+	{ "glCompressedTexImage2D", (GLvoid *) NAME(glCompressedTexImage2D), _gloffset_CompressedTexImage2DARB },
+	{ "glCompressedTexImage3D", (GLvoid *) NAME(glCompressedTexImage3D), _gloffset_CompressedTexImage3DARB },
+	{ "glCompressedTexSubImage1D", (GLvoid *) NAME(glCompressedTexSubImage1D), _gloffset_CompressedTexSubImage1DARB },
+	{ "glCompressedTexSubImage2D", (GLvoid *) NAME(glCompressedTexSubImage2D), _gloffset_CompressedTexSubImage2DARB },
+	{ "glCompressedTexSubImage3D", (GLvoid *) NAME(glCompressedTexSubImage3D), _gloffset_CompressedTexSubImage3DARB },
+	{ "glGetCompressedTexImage", (GLvoid *) NAME(glGetCompressedTexImage), _gloffset_GetCompressedTexImageARB },
+	{ "glMultiTexCoord1d", (GLvoid *) NAME(glMultiTexCoord1d), _gloffset_MultiTexCoord1dARB },
+	{ "glMultiTexCoord1dv", (GLvoid *) NAME(glMultiTexCoord1dv), _gloffset_MultiTexCoord1dvARB },
+	{ "glMultiTexCoord1f", (GLvoid *) NAME(glMultiTexCoord1f), _gloffset_MultiTexCoord1fARB },
+	{ "glMultiTexCoord1fv", (GLvoid *) NAME(glMultiTexCoord1fv), _gloffset_MultiTexCoord1fvARB },
+	{ "glMultiTexCoord1i", (GLvoid *) NAME(glMultiTexCoord1i), _gloffset_MultiTexCoord1iARB },
+	{ "glMultiTexCoord1iv", (GLvoid *) NAME(glMultiTexCoord1iv), _gloffset_MultiTexCoord1ivARB },
+	{ "glMultiTexCoord1s", (GLvoid *) NAME(glMultiTexCoord1s), _gloffset_MultiTexCoord1sARB },
+	{ "glMultiTexCoord1sv", (GLvoid *) NAME(glMultiTexCoord1sv), _gloffset_MultiTexCoord1svARB },
+	{ "glMultiTexCoord2d", (GLvoid *) NAME(glMultiTexCoord2d), _gloffset_MultiTexCoord2dARB },
+	{ "glMultiTexCoord2dv", (GLvoid *) NAME(glMultiTexCoord2dv), _gloffset_MultiTexCoord2dvARB },
+	{ "glMultiTexCoord2f", (GLvoid *) NAME(glMultiTexCoord2f), _gloffset_MultiTexCoord2fARB },
+	{ "glMultiTexCoord2fv", (GLvoid *) NAME(glMultiTexCoord2fv), _gloffset_MultiTexCoord2fvARB },
+	{ "glMultiTexCoord2i", (GLvoid *) NAME(glMultiTexCoord2i), _gloffset_MultiTexCoord2iARB },
+	{ "glMultiTexCoord2iv", (GLvoid *) NAME(glMultiTexCoord2iv), _gloffset_MultiTexCoord2ivARB },
+	{ "glMultiTexCoord2s", (GLvoid *) NAME(glMultiTexCoord2s), _gloffset_MultiTexCoord2sARB },
+	{ "glMultiTexCoord2sv", (GLvoid *) NAME(glMultiTexCoord2sv), _gloffset_MultiTexCoord2svARB },
+	{ "glMultiTexCoord3d", (GLvoid *) NAME(glMultiTexCoord3d), _gloffset_MultiTexCoord3dARB },
+	{ "glMultiTexCoord3dv", (GLvoid *) NAME(glMultiTexCoord3dv), _gloffset_MultiTexCoord3dvARB },
+	{ "glMultiTexCoord3f", (GLvoid *) NAME(glMultiTexCoord3f), _gloffset_MultiTexCoord3fARB },
+	{ "glMultiTexCoord3fv", (GLvoid *) NAME(glMultiTexCoord3fv), _gloffset_MultiTexCoord3fvARB },
+	{ "glMultiTexCoord3i", (GLvoid *) NAME(glMultiTexCoord3i), _gloffset_MultiTexCoord3iARB },
+	{ "glMultiTexCoord3iv", (GLvoid *) NAME(glMultiTexCoord3iv), _gloffset_MultiTexCoord3ivARB },
+	{ "glMultiTexCoord3s", (GLvoid *) NAME(glMultiTexCoord3s), _gloffset_MultiTexCoord3sARB },
+	{ "glMultiTexCoord3sv", (GLvoid *) NAME(glMultiTexCoord3sv), _gloffset_MultiTexCoord3svARB },
+	{ "glMultiTexCoord4d", (GLvoid *) NAME(glMultiTexCoord4d), _gloffset_MultiTexCoord4dARB },
+	{ "glMultiTexCoord4dv", (GLvoid *) NAME(glMultiTexCoord4dv), _gloffset_MultiTexCoord4dvARB },
+	{ "glMultiTexCoord4f", (GLvoid *) NAME(glMultiTexCoord4f), _gloffset_MultiTexCoord4fARB },
+	{ "glMultiTexCoord4fv", (GLvoid *) NAME(glMultiTexCoord4fv), _gloffset_MultiTexCoord4fvARB },
+	{ "glMultiTexCoord4i", (GLvoid *) NAME(glMultiTexCoord4i), _gloffset_MultiTexCoord4iARB },
+	{ "glMultiTexCoord4iv", (GLvoid *) NAME(glMultiTexCoord4iv), _gloffset_MultiTexCoord4ivARB },
+	{ "glMultiTexCoord4s", (GLvoid *) NAME(glMultiTexCoord4s), _gloffset_MultiTexCoord4sARB },
+	{ "glMultiTexCoord4sv", (GLvoid *) NAME(glMultiTexCoord4sv), _gloffset_MultiTexCoord4svARB },
+	{ "glLoadTransposeMatrixd", (GLvoid *) NAME(glLoadTransposeMatrixd), _gloffset_LoadTransposeMatrixdARB },
+	{ "glLoadTransposeMatrixf", (GLvoid *) NAME(glLoadTransposeMatrixf), _gloffset_LoadTransposeMatrixfARB },
+	{ "glMultTransposeMatrixd", (GLvoid *) NAME(glMultTransposeMatrixd), _gloffset_MultTransposeMatrixdARB },
+	{ "glMultTransposeMatrixf", (GLvoid *) NAME(glMultTransposeMatrixf), _gloffset_MultTransposeMatrixfARB },
+	{ "glSampleCoverage", (GLvoid *) NAME(glSampleCoverage), _gloffset_SampleCoverageARB },
+#if 0
+	{ "glSamplePass", (GLvoid *) NAME(glSamplePass), _gloffset_SamplePassARB },
+#endif
+#undef NAME
+
 	/* ARB 1. GL_ARB_multitexture */
 #ifdef GL_ARB_multitexture
 #define NAME(X) (GLvoid *) X
@@ -691,32 +960,29 @@
 	{ "glMultTransposeMatrixfARB", (GLvoid *) NAME(glMultTransposeMatrixfARB), _gloffset_MultTransposeMatrixfARB },
 #undef NAME
 
-        /* ARB 5. GL_ARB_multisample */
+	/* ARB 5. GL_ARB_multisample */
 #ifdef GL_ARB_multisample
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glSamplePassARB", NAME(glSamplePassARB), _gloffset_SamplePassARB },
-        { "glSampleCoverageARB", NAME(glSampleCoverageARB), _gloffset_SampleCoverageARB },
+	{ "glSampleCoverageARB", NAME(glSampleCoverageARB), _gloffset_SampleCoverageARB },
 #undef NAME
 
-        /* ARB 12. GL_ARB_texture_compression */
-#if 000
-#if defined(GL_ARB_texture_compression) && defined(_gloffset_CompressedTexImage3DARB)
+	/* ARB 12. GL_ARB_texture_compression */
+#ifdef GL_ARB_texture_compression
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glCompressedTexImage3DARB", NAME(glCompressedTexImage3DARB), _gloffset_CompressedTexImage3DARB },
-        { "glCompressedTexImage2DARB", NAME(glCompressedTexImage2DARB), _gloffset_CompressedTexImage2DARB },
-        { "glCompressedTexImage1DARB", NAME(glCompressedTexImage1DARB), _gloffset_CompressedTexImage1DARB },
-        { "glCompressedTexSubImage3DARB", NAME(glCompressedTexSubImage3DARB), _gloffset_CompressedTexSubImage3DARB },
-        { "glCompressedTexSubImage2DARB", NAME(glCompressedTexSubImage2DARB), _gloffset_CompressedTexSubImage2DARB },
-        { "glCompressedTexSubImage1DARB", NAME(glCompressedTexSubImage1DARB), _gloffset_CompressedTexSubImage1DARB },
-        { "glGetCompressedTexImageARB", NAME(glGetCompressedTexImageARB), _gloffset_GetCompressedTexImageARB },
+	{ "glCompressedTexImage3DARB", NAME(glCompressedTexImage3DARB), _gloffset_CompressedTexImage3DARB },
+	{ "glCompressedTexImage2DARB", NAME(glCompressedTexImage2DARB), _gloffset_CompressedTexImage2DARB },
+	{ "glCompressedTexImage1DARB", NAME(glCompressedTexImage1DARB), _gloffset_CompressedTexImage1DARB },
+	{ "glCompressedTexSubImage3DARB", NAME(glCompressedTexSubImage3DARB), _gloffset_CompressedTexSubImage3DARB },
+	{ "glCompressedTexSubImage2DARB", NAME(glCompressedTexSubImage2DARB), _gloffset_CompressedTexSubImage2DARB },
+	{ "glCompressedTexSubImage1DARB", NAME(glCompressedTexSubImage1DARB), _gloffset_CompressedTexSubImage1DARB },
+	{ "glGetCompressedTexImageARB", NAME(glGetCompressedTexImageARB), _gloffset_GetCompressedTexImageARB },
 #undef NAME
-#endif
 
 	/* 2. GL_EXT_blend_color */
 #ifdef GL_EXT_blend_color
@@ -778,7 +1044,7 @@
 	{ "glCopyTexSubImage1DEXT", NAME(glCopyTexSubImage1DEXT), _gloffset_CopyTexSubImage1D },
 	{ "glCopyTexSubImage2DEXT", NAME(glCopyTexSubImage2DEXT), _gloffset_CopyTexSubImage2D },
 #undef NAME
-                              
+
 	/* 11. GL_EXT_histogram */
 #ifdef GL_EXT_histogram
 #define NAME(X) (GLvoid *) X
@@ -817,7 +1083,7 @@
 	{ "glGetSeparableFilterEXT", NAME(glGetSeparableFilterEXT), _gloffset_GetSeparableFilterEXT },
 	{ "glSeparableFilter2DEXT", NAME(glSeparableFilter2DEXT), _gloffset_SeparableFilter2D },
 #undef NAME
-                    
+
 	/* 14. GL_SGI_color_table */
 #ifdef GL_SGI_color_table
 #define NAME(X) (GLvoid *) X
@@ -840,11 +1106,22 @@
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
 	{ "glPixelTexGenParameterfSGIS", NAME(glPixelTexGenParameterfSGIS), _gloffset_PixelTexGenParameterfSGIS },
+	{ "glPixelTexGenParameterfvSGIS", NAME(glPixelTexGenParameterfvSGIS), _gloffset_PixelTexGenParameterfvSGIS },
 	{ "glPixelTexGenParameteriSGIS", NAME(glPixelTexGenParameteriSGIS), _gloffset_PixelTexGenParameteriSGIS },
+	{ "glPixelTexGenParameterivSGIS", NAME(glPixelTexGenParameterivSGIS), _gloffset_PixelTexGenParameterivSGIS },
 	{ "glGetPixelTexGenParameterfvSGIS", NAME(glGetPixelTexGenParameterfvSGIS), _gloffset_GetPixelTexGenParameterfvSGIS },
 	{ "glGetPixelTexGenParameterivSGIS", NAME(glGetPixelTexGenParameterivSGIS), _gloffset_GetPixelTexGenParameterivSGIS },
 #undef NAME
 
+	/* 15a. GL_SGIX_pixel_texture */
+#ifdef GL_SGIX_pixel_texture
+#define NAME(X) (GLvoid *) X
+#else
+#define NAME(X) (GLvoid *) NotImplemented
+#endif
+	{ "glPixelTexGenSGIX", NAME(glPixelTexGenSGIX), _gloffset_PixelTexGenSGIX },
+#undef NAME
+
 	/* 16. GL_SGIS_texture4D */
 #ifdef  GL_SGIS_texture4D
 #define NAME(X) (GLvoid *) X
@@ -972,7 +1249,7 @@
 	{ "glFrameZoomSGIX", NAME(glFrameZoomSGIX), _gloffset_FrameZoomSGIX },
 #undef NAME
 
-        /* 58. GL_SGIX_tag_sample_buffer */
+	/* 58. GL_SGIX_tag_sample_buffer */
 #ifdef GL_SGIX_tag_sample_buffer
 #define NAME(X) (GLvoid *) X
 #else
@@ -1098,7 +1375,7 @@
 	{ "glCullParameterdvEXT", NAME(glCullParameterdvEXT), _gloffset_CullParameterdvEXT },
 #undef NAME
 
-        /* 102. GL_SGIX_fragment_lighting */
+	/* 102. GL_SGIX_fragment_lighting */
 #ifdef GL_SGIX_fragment_lighting
 #define NAME(X) (GLvoid *) X
 #else
@@ -1124,90 +1401,83 @@
 	{ "glLightEnviSGIX", NAME(glLightEnviSGIX), _gloffset_LightEnviSGIX },
 #undef NAME
 
-        /* 112. GL_EXT_draw_range_elements */
+	/* 112. GL_EXT_draw_range_elements */
 #if 000
 #ifdef GL_EXT_draw_range_elements
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glDrawRangeElementsEXT", NAME(glDrawRangeElementsEXT), _gloffset_DrawRangeElementsEXT },
+	{ "glDrawRangeElementsEXT", NAME(glDrawRangeElementsEXT), _gloffset_DrawRangeElementsEXT },
 #undef NAME
 #endif
 
-        /* 117. GL_EXT_light_texture */
+	/* 117. GL_EXT_light_texture */
 #if 000
 #ifdef GL_EXT_light_texture
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glApplyTextureEXT", NAME(glApplyTextureEXT), _gloffset_ApplyTextureEXT },
-        { "glTextureLightEXT", NAME(glTextureLightEXT), _gloffset_TextureLightEXT },
-        { "glTextureMaterialEXT", NAME(glTextureMaterialEXT), _gloffset_TextureMaterialEXT },
+	{ "glApplyTextureEXT", NAME(glApplyTextureEXT), _gloffset_ApplyTextureEXT },
+	{ "glTextureLightEXT", NAME(glTextureLightEXT), _gloffset_TextureLightEXT },
+	{ "glTextureMaterialEXT", NAME(glTextureMaterialEXT), _gloffset_TextureMaterialEXT },
 #undef NAME
 
-        /* 135. GL_INTEL_texture_scissor */
+	/* 135. GL_INTEL_texture_scissor */
 #ifdef GL_INTEL_texture_scissor
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glTexScissorINTEL", NAME(glTexScissorINTEL), _gloffset_TexScissorINTEL },
-        { "glTexScissorFuncINTEL", NAME(glTexScissorFuncINTEL), _gloffset_glTexScissorFuncINTEL },
+	{ "glTexScissorINTEL", NAME(glTexScissorINTEL), _gloffset_TexScissorINTEL },
+	{ "glTexScissorFuncINTEL", NAME(glTexScissorFuncINTEL), _gloffset_glTexScissorFuncINTEL },
 #undef NAME
 
-        /* 136. GL_INTEL_parallel_arrays */
+	/* 136. GL_INTEL_parallel_arrays */
 #ifdef GL_INTEL_parallel_arrays
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glVertexPointervINTEL", NAME(glVertexPointervINTEL), _gloffset_VertexPointervINTEL },
-        { "glNormalPointervINTEL", NAME(glNormalPointervINTEL), _gloffset_NormalPointervINTEL },
-        { "glColorPointervINTEL", NAME(glColorPointervINTEL), _gloffset_ColorPointervINTEL },
-        { "glTexCoordPointervINTEL", NAME(glTexCoordPointervINTEL), _gloffset_glxCoordPointervINTEL },
+	{ "glVertexPointervINTEL", NAME(glVertexPointervINTEL), _gloffset_VertexPointervINTEL },
+	{ "glNormalPointervINTEL", NAME(glNormalPointervINTEL), _gloffset_NormalPointervINTEL },
+	{ "glColorPointervINTEL", NAME(glColorPointervINTEL), _gloffset_ColorPointervINTEL },
+	{ "glTexCoordPointervINTEL", NAME(glTexCoordPointervINTEL), _gloffset_glxCoordPointervINTEL },
 #undef NAME
 #endif
 
-        /* 138. GL_EXT_pixel_transform */
+	/* 138. GL_EXT_pixel_transform */
 #if 000
 #ifdef GL_EXT_pixel_transform
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glPixelTransformParameteriEXT", NAME(glPixelTransformParameteriEXT), _gloffset_PixelTransformParameteriEXT },
-        { "glPixelTransformParameterfEXT", NAME(glPixelTransformParameterfEXT), _gloffset_PixelTransformParameterfEXT },
-        { "glPixelTransformParameterivEXT", NAME(glPixelTransformParameterivEXT), _gloffset_PixelTransformParameterivEXT },
-        { "glPixelTransformParameterfvEXT", NAME(glPixelTransformParameterfvEXT), _gloffset_PixelTransformParameterfvEXT },
-        { "glGetPixelTransformParameterivEXT", NAME(glGetPixelTransformParameterivEXT), _gloffset_GetPixelTransformParameterivEXT },
-        { "glGetPixelTransformParameterfvEXT", NAME(glGetPixelTransformParameterfvEXT), _gloffset_GetPixelTransformParameterfvEXT },
+	{ "glPixelTransformParameteriEXT", NAME(glPixelTransformParameteriEXT), _gloffset_PixelTransformParameteriEXT },
+	{ "glPixelTransformParameterfEXT", NAME(glPixelTransformParameterfEXT), _gloffset_PixelTransformParameterfEXT },
+	{ "glPixelTransformParameterivEXT", NAME(glPixelTransformParameterivEXT), _gloffset_PixelTransformParameterivEXT },
+	{ "glPixelTransformParameterfvEXT", NAME(glPixelTransformParameterfvEXT), _gloffset_PixelTransformParameterfvEXT },
+	{ "glGetPixelTransformParameterivEXT", NAME(glGetPixelTransformParameterivEXT), _gloffset_GetPixelTransformParameterivEXT },
+	{ "glGetPixelTransformParameterfvEXT", NAME(glGetPixelTransformParameterfvEXT), _gloffset_GetPixelTransformParameterfvEXT },
 #undef NAME
+#endif
 
-        /* 145. GL_EXT_secondary_color */
+	/* 145. GL_EXT_secondary_color */
 #ifdef GL_EXT_secondary_color
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glSecondaryColor3bEXT", NAME(glSecondaryColor3bEXT), _gloffset_SecondaryColor3bEXT },
-        { "glSecondaryColor3dEXT", NAME(glSecondaryColor3dEXT), _gloffset_SecondaryColor3dEXT },
-        { "glSecondaryColor3fEXT", NAME(glSecondaryColor3fEXT), _gloffset_SecondaryColor3fEXT },
-        { "glSecondaryColor3iEXT", NAME(glSecondaryColor3iEXT), _gloffset_SecondaryColor3iEXT },
-        { "glSecondaryColor3sEXT", NAME(glSecondaryColor3sEXT), _gloffset_SecondaryColor3sEXT },
-        { "glSecondaryColor3ubEXT", NAME(glSecondaryColor3ubEXT), _gloffset_SecondaryColor3ubEXT },
-        { "glSecondaryColor3uiEXT", NAME(glSecondaryColor3uiEXT), _gloffset_SecondaryColor3uiEXT },
-        { "glSecondaryColor3usEXT", NAME(glSecondaryColor3usEXT), _gloffset_SecondaryColor3usEXT },
-        { "glSecondaryColor4bEXT", NAME(glSecondaryColor4bEXT), _gloffset_SecondaryColor4bEXT },
-        { "glSecondaryColor4dEXT", NAME(glSecondaryColor4dEXT), _gloffset_SecondaryColor4dEXT },
-        { "glSecondaryColor4fEXT", NAME(glSecondaryColor4fEXT), _gloffset_SecondaryColor4fEXT },
-        { "glSecondaryColor4iEXT", NAME(glSecondaryColor4iEXT), _gloffset_SecondaryColor4iEXT },
-        { "glSecondaryColor4sEXT", NAME(glSecondaryColor4sEXT), _gloffset_SecondaryColor4sEXT },
-        { "glSecondaryColor4ubEXT", NAME(glSecondaryColor4ubEXT), _gloffset_SecondaryColor4ubEXT },
-        { "glSecondaryColor4uiEXT", NAME(glSecondaryColor4uiEXT), _gloffset_SecondaryColor4uiEXT },
-        { "glSecondaryColor4usEXT", NAME(glSecondaryColor4usEXT), _gloffset_SecondaryColor4usEXT },
-        { "glSecondaryColor3bvEXT", NAME(glSecondaryColor3bvEXT), _gloffset_SecondaryColor3bvEXT },
+	{ "glSecondaryColor3bEXT", NAME(glSecondaryColor3bEXT), _gloffset_SecondaryColor3bEXT },
+	{ "glSecondaryColor3dEXT", NAME(glSecondaryColor3dEXT), _gloffset_SecondaryColor3dEXT },
+	{ "glSecondaryColor3fEXT", NAME(glSecondaryColor3fEXT), _gloffset_SecondaryColor3fEXT },
+	{ "glSecondaryColor3iEXT", NAME(glSecondaryColor3iEXT), _gloffset_SecondaryColor3iEXT },
+	{ "glSecondaryColor3sEXT", NAME(glSecondaryColor3sEXT), _gloffset_SecondaryColor3sEXT },
+	{ "glSecondaryColor3ubEXT", NAME(glSecondaryColor3ubEXT), _gloffset_SecondaryColor3ubEXT },
+	{ "glSecondaryColor3uiEXT", NAME(glSecondaryColor3uiEXT), _gloffset_SecondaryColor3uiEXT },
+	{ "glSecondaryColor3usEXT", NAME(glSecondaryColor3usEXT), _gloffset_SecondaryColor3usEXT },
+	{ "glSecondaryColor3bvEXT", NAME(glSecondaryColor3bvEXT), _gloffset_SecondaryColor3bvEXT },
 	{ "glSecondaryColor3dvEXT", NAME(glSecondaryColor3dvEXT), _gloffset_SecondaryColor3dvEXT },
 	{ "glSecondaryColor3fvEXT", NAME(glSecondaryColor3fvEXT), _gloffset_SecondaryColor3fvEXT },
 	{ "glSecondaryColor3ivEXT", NAME(glSecondaryColor3ivEXT), _gloffset_SecondaryColor3ivEXT },
@@ -1215,18 +1485,11 @@
 	{ "glSecondaryColor3ubvEXT", NAME(glSecondaryColor3ubvEXT), _gloffset_SecondaryColor3ubvEXT },
 	{ "glSecondaryColor3uivEXT", NAME(glSecondaryColor3uivEXT), _gloffset_SecondaryColor3uivEXT },
 	{ "glSecondaryColor3usvEXT", NAME(glSecondaryColor3usvEXT), _gloffset_SecondaryColor3usvEXT },
-	{ "glSecondaryColor4bvEXT", NAME(glSecondaryColor4bvEXT), _gloffset_SecondaryColor4bvEXT },
-	{ "glSecondaryColor4dvEXT", NAME(glSecondaryColor4dvEXT), _gloffset_SecondaryColor4dvEXT },
-	{ "glSecondaryColor4fvEXT", NAME(glSecondaryColor4fvEXT), _gloffset_SecondaryColor4fvEXT },
-	{ "glSecondaryColor4ivEXT", NAME(glSecondaryColor4ivEXT), _gloffset_SecondaryColor4ivEXT },
-	{ "glSecondaryColor4svEXT", NAME(glSecondaryColor4svEXT), _gloffset_SecondaryColor4svEXT },
-	{ "glSecondaryColor4ubvEXT", NAME(glSecondaryColor4ubvEXT), _gloffset_SecondaryColor4ubvEXT },
-	{ "glSecondaryColor4uivEXT", NAME(glSecondaryColor4uivEXT), _gloffset_SecondaryColor4uivEXT },
-	{ "glSecondaryColor4usvEXT", NAME(glSecondaryColor4usvEXT), _gloffset_SecondaryColor4usvEXT },
 	{ "glSecondaryColorPointerEXT", NAME(glSecondaryColorPointerEXT), _gloffset_SecondaryColorPointerEXT },
 #undef NAME
 
 	/* 147. GL_EXT_texture_perturb_normal */
+#if 000
 #ifdef GL_EXT_texture_perturb_normal
 #define NAME(X) (GLvoid *) X
 #else
@@ -1234,8 +1497,10 @@
 #endif
 	{ "glTextureNormalEXT", NAME(glTextureNormalEXT), _gloffset_TextureNormalEXT },
 #undef NAME
+#endif
 
 	/* 148. GL_EXT_multi_draw_arrays */
+#if 000
 #ifdef GL_EXT_multi_draw_arrays
 #define NAME(X) (GLvoid *) X
 #else
@@ -1254,12 +1519,12 @@
 	{ "glFogCoordfEXT", NAME(glFogCoordfEXT), _gloffset_FogCoordfEXT },
 	{ "glFogCoordfvEXT", NAME(glFogCoordfvEXT), _gloffset_FogCoordfvEXT },
 	{ "glFogCoorddEXT", NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT },
-	{ "glFogCoorddEXT", NAME(glFogCoorddEXT), _gloffset_FogCoorddEXT },
+	{ "glFogCoorddvEXT", NAME(glFogCoorddvEXT), _gloffset_FogCoorddvEXT },
 	{ "glFogCoordPointerEXT", NAME(glFogCoordPointerEXT), _gloffset_FogCoordPointerEXT },
 #undef NAME
 
-#if 000
 	/* 156. GL_EXT_coordinate_frame */
+#if 000
 #ifdef GL_EXT_coordinate_frame
 #define NAME(X) (GLvoid *) X
 #else
@@ -1288,8 +1553,10 @@
 	{ "glTangentPointerEXT", NAME(glTangentPointerEXT), _gloffset_TangentPointerEXT },
 	{ "glBinormalPointerEXT", NAME(glBinormalPointerEXT), _gloffset_BinormalPointerEXT },
 #undef NAME
+#endif
 
 	/* 164. GL_SUN_global_alpha */
+#if 000
 #ifdef GL_SUN_global_alpha
 #define NAME(X) (GLvoid *) X
 #else
@@ -1304,8 +1571,10 @@
 	{ "glGlobalAlphaFactorusSUN", NAME(glGlobalAlphaFactorusSUN), _gloffset_GlobalAlphaFactorusSUN },
 	{ "glGlobalAlphaFactoruiSUN", NAME(glGlobalAlphaFactoruiSUN), _gloffset_GlobalAlphaFactoruiSUN },
 #undef NAME
+#endif
 
 	/* 165. GL_SUN_triangle_list */
+#if 000
 #ifdef GL_SUN_triangle_list
 #define NAME(X) (GLvoid *) X
 #else
@@ -1319,8 +1588,10 @@
 	{ "glReplacementCodeubvSUN", NAME(glReplacementCodeubvSUN), _gloffset_ReplacementCodeubvSUN },
 	{ "glReplacementCodePointerSUN", NAME(glReplacementCodePointerSUN), _gloffset_ReplacementCodePointerSUN },
 #undef NAME
+#endif
 
 	/* 166. GL_SUN_vertex */
+#if 000
 #ifdef GL_SUN_vertex
 #define NAME(X) (GLvoid *) X
 #else
@@ -1390,7 +1661,7 @@
 	{ "glVertexWeightPointerEXT", NAME(glVertexWeightPointerEXT), _gloffset_VertexWeightPointerEXT },
 #undef NAME
 
-        /* 190. GL_NV_vertex_array_range */
+	/* 190. GL_NV_vertex_array_range */
 #ifdef GL_NV_vertex_array_range
 #define NAME(X) (GLvoid *) X
 #else
@@ -1436,17 +1707,40 @@
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
+        { "glWindowPos2iMESA", NAME(glWindowPos2iMESA), _gloffset_WindowPos2iMESA },
+        { "glWindowPos2sMESA", NAME(glWindowPos2sMESA), _gloffset_WindowPos2sMESA },
+	{ "glWindowPos2fMESA", NAME(glWindowPos2fMESA), _gloffset_WindowPos2fMESA },
+	{ "glWindowPos2dMESA", NAME(glWindowPos2dMESA), _gloffset_WindowPos2dMESA },
+	{ "glWindowPos2ivMESA", NAME(glWindowPos2ivMESA), _gloffset_WindowPos2ivMESA },
+	{ "glWindowPos2svMESA", NAME(glWindowPos2svMESA), _gloffset_WindowPos2svMESA },
+	{ "glWindowPos2fvMESA", NAME(glWindowPos2fvMESA), _gloffset_WindowPos2fvMESA },
+	{ "glWindowPos2dvMESA", NAME(glWindowPos2dvMESA), _gloffset_WindowPos2dvMESA },
+	{ "glWindowPos3iMESA", NAME(glWindowPos3iMESA), _gloffset_WindowPos3iMESA },
+	{ "glWindowPos3sMESA", NAME(glWindowPos3sMESA), _gloffset_WindowPos3sMESA },
+	{ "glWindowPos3fMESA", NAME(glWindowPos3fMESA), _gloffset_WindowPos3fMESA },
+	{ "glWindowPos3dMESA", NAME(glWindowPos3dMESA), _gloffset_WindowPos3dMESA },
+	{ "glWindowPos3ivMESA", NAME(glWindowPos3ivMESA), _gloffset_WindowPos3ivMESA },
+	{ "glWindowPos3svMESA", NAME(glWindowPos3svMESA), _gloffset_WindowPos3svMESA },
+	{ "glWindowPos3fvMESA", NAME(glWindowPos3fvMESA), _gloffset_WindowPos3fvMESA },
+	{ "glWindowPos3dvMESA", NAME(glWindowPos3dvMESA), _gloffset_WindowPos3dvMESA },
+	{ "glWindowPos4iMESA", NAME(glWindowPos4iMESA), _gloffset_WindowPos4iMESA },
+	{ "glWindowPos4sMESA", NAME(glWindowPos4sMESA), _gloffset_WindowPos4sMESA },
 	{ "glWindowPos4fMESA", NAME(glWindowPos4fMESA), _gloffset_WindowPos4fMESA },
+	{ "glWindowPos4dMESA", NAME(glWindowPos4dMESA), _gloffset_WindowPos4dMESA },
+	{ "glWindowPos4ivMESA", NAME(glWindowPos4ivMESA), _gloffset_WindowPos4ivMESA },
+	{ "glWindowPos4svMESA", NAME(glWindowPos4svMESA), _gloffset_WindowPos4svMESA },
+	{ "glWindowPos4fvMESA", NAME(glWindowPos4fvMESA), _gloffset_WindowPos4fvMESA },
+	{ "glWindowPos4dvMESA", NAME(glWindowPos4dvMESA), _gloffset_WindowPos4dvMESA },
 #undef NAME
 
-        /* 209. WGL_EXT_multisample */
+	/* 209. WGL_EXT_multisample */
 #ifdef WGL_EXT_multisample
 #define NAME(X) (GLvoid *) X
 #else
 #define NAME(X) (GLvoid *) NotImplemented
 #endif
-        { "glSampleMaskEXT", NAME(glSampleMaskEXT), _gloffset_SampleMaskSGIS },
-        { "glSamplePatternEXT", NAME(glSamplePatternEXT), _gloffset_SamplePatternSGIS },
+	{ "glSampleMaskEXT", NAME(glSampleMaskEXT), _gloffset_SampleMaskSGIS },
+	{ "glSamplePatternEXT", NAME(glSamplePatternEXT), _gloffset_SamplePatternSGIS },
 #undef NAME
 
 	{ NULL, NULL }  /* end of list marker */
@@ -1464,7 +1758,7 @@
    GLuint i;
    for (i = 0; static_functions[i].Name; i++) {
       if (strcmp(static_functions[i].Name, funcName) == 0) {
-         return static_functions[i].Offset;
+	 return static_functions[i].Offset;
       }
    }
    return -1;
@@ -1499,7 +1793,9 @@
 static struct name_address_offset ExtEntryTable[MAX_EXTENSION_FUNCS];
 static GLuint NumExtEntryPoints = 0;
 
-
+#ifdef USE_SPARC_ASM
+extern void __glapi_sparc_icache_flush(unsigned int *);
+#endif
 
 /*
  * Generate a dispatch function (entrypoint) which jumps through
@@ -1546,6 +1842,55 @@
       *(unsigned int *)(code + 0x16) = (unsigned int)functionOffset * 4;
    }
    return code;
+#elif defined(USE_SPARC_ASM)
+
+#ifdef __sparc_v9__
+   static const unsigned int insn_template[] = {
+	   0x05000000,	/* sethi	%uhi(_glapi_Dispatch), %g2	*/
+	   0x03000000,	/* sethi	%hi(_glapi_Dispatch), %g1	*/
+	   0x8410a000,	/* or		%g2, %ulo(_glapi_Dispatch), %g2	*/
+	   0x82106000,	/* or		%g1, %lo(_glapi_Dispatch), %g1	*/
+	   0x8528b020,	/* sllx		%g2, 32, %g2			*/
+	   0xc2584002,	/* ldx		[%g1 + %g2], %g1		*/
+	   0x05000000,	/* sethi	%hi(8 * glapioffset), %g2	*/
+	   0x8410a000,	/* or		%g2, %lo(8 * glapioffset), %g2	*/
+	   0xc6584002,	/* ldx		[%g1 + %g2], %g3		*/
+	   0x81c0c000,	/* jmpl		%g3, %g0			*/
+	   0x01000000	/*  nop						*/
+   };
+#else
+   static const unsigned int insn_template[] = {
+	   0x03000000,	/* sethi	%hi(_glapi_Dispatch), %g1	  */
+	   0xc2006000,	/* ld		[%g1 + %lo(_glapi_Dispatch)], %g1 */
+	   0xc6006000,	/* ld		[%g1 + %lo(4*glapioffset)], %g3	  */
+	   0x81c0c000,	/* jmpl		%g3, %g0			  */
+	   0x01000000	/*  nop						  */
+   };
+#endif
+   unsigned int *code = malloc(sizeof(insn_template));
+   unsigned long glapi_addr = (unsigned long) &_glapi_Dispatch;
+   if (code) {
+      memcpy(code, insn_template, sizeof(insn_template));
+
+#ifdef __sparc_v9__
+      code[0] |= (glapi_addr >> (32 + 10));
+      code[1] |= ((glapi_addr & 0xffffffff) >> 10);
+      __glapi_sparc_icache_flush(&code[0]);
+      code[2] |= ((glapi_addr >> 32) & ((1 << 10) - 1));
+      code[3] |= (glapi_addr & ((1 << 10) - 1));
+      __glapi_sparc_icache_flush(&code[2]);
+      code[6] |= ((functionOffset * 8) >> 10);
+      code[7] |= ((functionOffset * 8) & ((1 << 10) - 1));
+      __glapi_sparc_icache_flush(&code[6]);
+#else
+      code[0] |= (glapi_addr >> 10);
+      code[1] |= (glapi_addr & ((1 << 10) - 1));
+      __glapi_sparc_icache_flush(&code[0]);
+      code[2] |= (functionOffset * 4);
+      __glapi_sparc_icache_flush(&code[2]);
+#endif
+   }
+   return code;
 #else
    return NULL;
 #endif
@@ -1564,18 +1909,11 @@
    {
       GLint index = get_static_proc_offset(funcName);
       if (index >= 0) {
-         return (GLboolean) (index == (GLint) offset);  /* bad offset! */
+         return (GLboolean) ((GLuint) index == offset);  /* bad offset! */
       }
    }
 
    {
-      /* make sure this offset/name pair is legal */
-      const char *name = _glapi_get_proc_name(offset);
-      if (name && strcmp(name, funcName) != 0)
-         return GL_FALSE;  /* bad name! */
-   }
-
-   {
       /* be sure index and name match known data */
       GLuint i;
       for (i = 0; i < NumExtEntryPoints; i++) {
@@ -1733,7 +2071,7 @@
 
 /*
  * Make sure there are no NULL pointers in the given dispatch table.
- * Intented for debugging purposes.
+ * Intended for debugging purposes.
  */
 void
 _glapi_check_table(const struct _glapi_table *table)
@@ -1791,9 +2129,13 @@
       assert(istextureOffset == _gloffset_IsTextureEXT);
       assert(istextureOffset == offset);
    }
+   {
+      GLuint secondaryColor3fOffset = _glapi_get_proc_offset("glSecondaryColor3fEXT");
+      char *secondaryColor3fFunc = (char*) &table->SecondaryColor3fEXT;
+      GLuint offset = (secondaryColor3fFunc - (char *) table) / sizeof(void *);
+      assert(secondaryColor3fOffset == _gloffset_SecondaryColor3fEXT);
+      assert(secondaryColor3fOffset == offset);
+      assert(_glapi_get_proc_address("glSecondaryColor3fEXT") == (void *) &glSecondaryColor3fEXT);
+   }
 #endif
 }
-
-
-
-
Index: xc/extras/Mesa/src/glapi.h
diff -u xc/extras/Mesa/src/glapi.h:1.2 xc/extras/Mesa/src/glapi.h:1.3
--- xc/extras/Mesa/src/glapi.h:1.2	Tue Feb 15 02:12:16 2000
+++ xc/extras/Mesa/src/glapi.h	Fri Feb 22 14:25:31 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -39,6 +39,10 @@
 
 
 extern void
+_glapi_noop_enable_warnings(GLboolean enable);
+
+
+extern void
 _glapi_check_multithread(void);
 
 
@@ -56,6 +60,18 @@
 
 extern struct _glapi_table *
 _glapi_get_dispatch(void);
+
+
+extern int
+_glapi_begin_dispatch_override(struct _glapi_table *override);
+
+
+extern void
+_glapi_end_dispatch_override(int layer);
+
+
+struct _glapi_table *
+_glapi_get_override_dispatch(int layer);
 
 
 extern GLuint
Index: xc/extras/Mesa/src/glapinoop.c
diff -u xc/extras/Mesa/src/glapinoop.c:1.10 xc/extras/Mesa/src/glapinoop.c:removed
--- xc/extras/Mesa/src/glapinoop.c:1.10	Mon Nov 13 18:30:47 2000
+++ xc/extras/Mesa/src/glapinoop.c	Thu Feb 27 12:15:37 2003
@@ -1,868 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * This is part of the reusable GL dispather, see glapi.c for details.
- */
-
-
-#include "glheader.h"
-#include "glapi.h"
-#include "glapinoop.h"
-#include "glapitable.h"
-
-
-static GLboolean WarnFlag = GL_FALSE;
-
-
-void
-_glapi_noop_enable_warnings(GLboolean enable)
-{
-   WarnFlag = enable;
-}
-
-
-static GLboolean
-warn(void)
-{
-   if (WarnFlag || getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG"))
-      return GL_TRUE;
-   else
-      return GL_FALSE;
-}
-
-
-#define KEYWORD1 static
-#define KEYWORD2
-#define NAME(func)  NoOp##func
-
-#define F stderr
-
-#define DISPATCH(func, args, msg)			\
-   if (warn()) {					\
-      fprintf(stderr, "GL User Error: calling ");	\
-      fprintf msg;					\
-      fprintf(stderr, " without a current context\n");	\
-   }
-
-#define RETURN_DISPATCH(func, args, msg)		\
-   if (warn()) {					\
-      fprintf(stderr, "GL User Error: calling ");	\
-      fprintf msg;					\
-      fprintf(stderr, " without a current context\n");	\
-   }							\
-   return 0
-
-#include "glapitemp.h"
-
-
-
-static int
-NoOpGeneric(void)
-{
-   if (warn()) {
-      fprintf(stderr, "GL User Error: calling extension function without a current context\n");
-   }
-   return 0;
-}
-
-
-void *__glapi_noop_table[] = {
-   (void *) NoOpNewList,
-   (void *) NoOpEndList,
-   (void *) NoOpCallList,
-   (void *) NoOpCallLists,
-   (void *) NoOpDeleteLists,
-   (void *) NoOpGenLists,
-   (void *) NoOpListBase,
-   (void *) NoOpBegin,
-   (void *) NoOpBitmap,
-   (void *) NoOpColor3b,
-   (void *) NoOpColor3bv,
-   (void *) NoOpColor3d,
-   (void *) NoOpColor3dv,
-   (void *) NoOpColor3f,
-   (void *) NoOpColor3fv,
-   (void *) NoOpColor3i,
-   (void *) NoOpColor3iv,
-   (void *) NoOpColor3s,
-   (void *) NoOpColor3sv,
-   (void *) NoOpColor3ub,
-   (void *) NoOpColor3ubv,
-   (void *) NoOpColor3ui,
-   (void *) NoOpColor3uiv,
-   (void *) NoOpColor3us,
-   (void *) NoOpColor3usv,
-   (void *) NoOpColor4b,
-   (void *) NoOpColor4bv,
-   (void *) NoOpColor4d,
-   (void *) NoOpColor4dv,
-   (void *) NoOpColor4f,
-   (void *) NoOpColor4fv,
-   (void *) NoOpColor4i,
-   (void *) NoOpColor4iv,
-   (void *) NoOpColor4s,
-   (void *) NoOpColor4sv,
-   (void *) NoOpColor4ub,
-   (void *) NoOpColor4ubv,
-   (void *) NoOpColor4ui,
-   (void *) NoOpColor4uiv,
-   (void *) NoOpColor4us,
-   (void *) NoOpColor4usv,
-   (void *) NoOpEdgeFlag,
-   (void *) NoOpEdgeFlagv,
-   (void *) NoOpEnd,
-   (void *) NoOpIndexd,
-   (void *) NoOpIndexdv,
-   (void *) NoOpIndexf,
-   (void *) NoOpIndexfv,
-   (void *) NoOpIndexi,
-   (void *) NoOpIndexiv,
-   (void *) NoOpIndexs,
-   (void *) NoOpIndexsv,
-   (void *) NoOpNormal3b,
-   (void *) NoOpNormal3bv,
-   (void *) NoOpNormal3d,
-   (void *) NoOpNormal3dv,
-   (void *) NoOpNormal3f,
-   (void *) NoOpNormal3fv,
-   (void *) NoOpNormal3i,
-   (void *) NoOpNormal3iv,
-   (void *) NoOpNormal3s,
-   (void *) NoOpNormal3sv,
-   (void *) NoOpRasterPos2d,
-   (void *) NoOpRasterPos2dv,
-   (void *) NoOpRasterPos2f,
-   (void *) NoOpRasterPos2fv,
-   (void *) NoOpRasterPos2i,
-   (void *) NoOpRasterPos2iv,
-   (void *) NoOpRasterPos2s,
-   (void *) NoOpRasterPos2sv,
-   (void *) NoOpRasterPos3d,
-   (void *) NoOpRasterPos3dv,
-   (void *) NoOpRasterPos3f,
-   (void *) NoOpRasterPos3fv,
-   (void *) NoOpRasterPos3i,
-   (void *) NoOpRasterPos3iv,
-   (void *) NoOpRasterPos3s,
-   (void *) NoOpRasterPos3sv,
-   (void *) NoOpRasterPos4d,
-   (void *) NoOpRasterPos4dv,
-   (void *) NoOpRasterPos4f,
-   (void *) NoOpRasterPos4fv,
-   (void *) NoOpRasterPos4i,
-   (void *) NoOpRasterPos4iv,
-   (void *) NoOpRasterPos4s,
-   (void *) NoOpRasterPos4sv,
-   (void *) NoOpRectd,
-   (void *) NoOpRectdv,
-   (void *) NoOpRectf,
-   (void *) NoOpRectfv,
-   (void *) NoOpRecti,
-   (void *) NoOpRectiv,
-   (void *) NoOpRects,
-   (void *) NoOpRectsv,
-   (void *) NoOpTexCoord1d,
-   (void *) NoOpTexCoord1dv,
-   (void *) NoOpTexCoord1f,
-   (void *) NoOpTexCoord1fv,
-   (void *) NoOpTexCoord1i,
-   (void *) NoOpTexCoord1iv,
-   (void *) NoOpTexCoord1s,
-   (void *) NoOpTexCoord1sv,
-   (void *) NoOpTexCoord2d,
-   (void *) NoOpTexCoord2dv,
-   (void *) NoOpTexCoord2f,
-   (void *) NoOpTexCoord2fv,
-   (void *) NoOpTexCoord2i,
-   (void *) NoOpTexCoord2iv,
-   (void *) NoOpTexCoord2s,
-   (void *) NoOpTexCoord2sv,
-   (void *) NoOpTexCoord3d,
-   (void *) NoOpTexCoord3dv,
-   (void *) NoOpTexCoord3f,
-   (void *) NoOpTexCoord3fv,
-   (void *) NoOpTexCoord3i,
-   (void *) NoOpTexCoord3iv,
-   (void *) NoOpTexCoord3s,
-   (void *) NoOpTexCoord3sv,
-   (void *) NoOpTexCoord4d,
-   (void *) NoOpTexCoord4dv,
-   (void *) NoOpTexCoord4f,
-   (void *) NoOpTexCoord4fv,
-   (void *) NoOpTexCoord4i,
-   (void *) NoOpTexCoord4iv,
-   (void *) NoOpTexCoord4s,
-   (void *) NoOpTexCoord4sv,
-   (void *) NoOpVertex2d,
-   (void *) NoOpVertex2dv,
-   (void *) NoOpVertex2f,
-   (void *) NoOpVertex2fv,
-   (void *) NoOpVertex2i,
-   (void *) NoOpVertex2iv,
-   (void *) NoOpVertex2s,
-   (void *) NoOpVertex2sv,
-   (void *) NoOpVertex3d,
-   (void *) NoOpVertex3dv,
-   (void *) NoOpVertex3f,
-   (void *) NoOpVertex3fv,
-   (void *) NoOpVertex3i,
-   (void *) NoOpVertex3iv,
-   (void *) NoOpVertex3s,
-   (void *) NoOpVertex3sv,
-   (void *) NoOpVertex4d,
-   (void *) NoOpVertex4dv,
-   (void *) NoOpVertex4f,
-   (void *) NoOpVertex4fv,
-   (void *) NoOpVertex4i,
-   (void *) NoOpVertex4iv,
-   (void *) NoOpVertex4s,
-   (void *) NoOpVertex4sv,
-   (void *) NoOpClipPlane,
-   (void *) NoOpColorMaterial,
-   (void *) NoOpCullFace,
-   (void *) NoOpFogf,
-   (void *) NoOpFogfv,
-   (void *) NoOpFogi,
-   (void *) NoOpFogiv,
-   (void *) NoOpFrontFace,
-   (void *) NoOpHint,
-   (void *) NoOpLightf,
-   (void *) NoOpLightfv,
-   (void *) NoOpLighti,
-   (void *) NoOpLightiv,
-   (void *) NoOpLightModelf,
-   (void *) NoOpLightModelfv,
-   (void *) NoOpLightModeli,
-   (void *) NoOpLightModeliv,
-   (void *) NoOpLineStipple,
-   (void *) NoOpLineWidth,
-   (void *) NoOpMaterialf,
-   (void *) NoOpMaterialfv,
-   (void *) NoOpMateriali,
-   (void *) NoOpMaterialiv,
-   (void *) NoOpPointSize,
-   (void *) NoOpPolygonMode,
-   (void *) NoOpPolygonStipple,
-   (void *) NoOpScissor,
-   (void *) NoOpShadeModel,
-   (void *) NoOpTexParameterf,
-   (void *) NoOpTexParameterfv,
-   (void *) NoOpTexParameteri,
-   (void *) NoOpTexParameteriv,
-   (void *) NoOpTexImage1D,
-   (void *) NoOpTexImage2D,
-   (void *) NoOpTexEnvf,
-   (void *) NoOpTexEnvfv,
-   (void *) NoOpTexEnvi,
-   (void *) NoOpTexEnviv,
-   (void *) NoOpTexGend,
-   (void *) NoOpTexGendv,
-   (void *) NoOpTexGenf,
-   (void *) NoOpTexGenfv,
-   (void *) NoOpTexGeni,
-   (void *) NoOpTexGeniv,
-   (void *) NoOpFeedbackBuffer,
-   (void *) NoOpSelectBuffer,
-   (void *) NoOpRenderMode,
-   (void *) NoOpInitNames,
-   (void *) NoOpLoadName,
-   (void *) NoOpPassThrough,
-   (void *) NoOpPopName,
-   (void *) NoOpPushName,
-   (void *) NoOpDrawBuffer,
-   (void *) NoOpClear,
-   (void *) NoOpClearAccum,
-   (void *) NoOpClearIndex,
-   (void *) NoOpClearColor,
-   (void *) NoOpClearStencil,
-   (void *) NoOpClearDepth,
-   (void *) NoOpStencilMask,
-   (void *) NoOpColorMask,
-   (void *) NoOpDepthMask,
-   (void *) NoOpIndexMask,
-   (void *) NoOpAccum,
-   (void *) NoOpDisable,
-   (void *) NoOpEnable,
-   (void *) NoOpFinish,
-   (void *) NoOpFlush,
-   (void *) NoOpPopAttrib,
-   (void *) NoOpPushAttrib,
-   (void *) NoOpMap1d,
-   (void *) NoOpMap1f,
-   (void *) NoOpMap2d,
-   (void *) NoOpMap2f,
-   (void *) NoOpMapGrid1d,
-   (void *) NoOpMapGrid1f,
-   (void *) NoOpMapGrid2d,
-   (void *) NoOpMapGrid2f,
-   (void *) NoOpEvalCoord1d,
-   (void *) NoOpEvalCoord1dv,
-   (void *) NoOpEvalCoord1f,
-   (void *) NoOpEvalCoord1fv,
-   (void *) NoOpEvalCoord2d,
-   (void *) NoOpEvalCoord2dv,
-   (void *) NoOpEvalCoord2f,
-   (void *) NoOpEvalCoord2fv,
-   (void *) NoOpEvalMesh1,
-   (void *) NoOpEvalPoint1,
-   (void *) NoOpEvalMesh2,
-   (void *) NoOpEvalPoint2,
-   (void *) NoOpAlphaFunc,
-   (void *) NoOpBlendFunc,
-   (void *) NoOpLogicOp,
-   (void *) NoOpStencilFunc,
-   (void *) NoOpStencilOp,
-   (void *) NoOpDepthFunc,
-   (void *) NoOpPixelZoom,
-   (void *) NoOpPixelTransferf,
-   (void *) NoOpPixelTransferi,
-   (void *) NoOpPixelStoref,
-   (void *) NoOpPixelStorei,
-   (void *) NoOpPixelMapfv,
-   (void *) NoOpPixelMapuiv,
-   (void *) NoOpPixelMapusv,
-   (void *) NoOpReadBuffer,
-   (void *) NoOpCopyPixels,
-   (void *) NoOpReadPixels,
-   (void *) NoOpDrawPixels,
-   (void *) NoOpGetBooleanv,
-   (void *) NoOpGetClipPlane,
-   (void *) NoOpGetDoublev,
-   (void *) NoOpGetError,
-   (void *) NoOpGetFloatv,
-   (void *) NoOpGetIntegerv,
-   (void *) NoOpGetLightfv,
-   (void *) NoOpGetLightiv,
-   (void *) NoOpGetMapdv,
-   (void *) NoOpGetMapfv,
-   (void *) NoOpGetMapiv,
-   (void *) NoOpGetMaterialfv,
-   (void *) NoOpGetMaterialiv,
-   (void *) NoOpGetPixelMapfv,
-   (void *) NoOpGetPixelMapuiv,
-   (void *) NoOpGetPixelMapusv,
-   (void *) NoOpGetPolygonStipple,
-   (void *) NoOpGetString,
-   (void *) NoOpGetTexEnvfv,
-   (void *) NoOpGetTexEnviv,
-   (void *) NoOpGetTexGendv,
-   (void *) NoOpGetTexGenfv,
-   (void *) NoOpGetTexGeniv,
-   (void *) NoOpGetTexImage,
-   (void *) NoOpGetTexParameterfv,
-   (void *) NoOpGetTexParameteriv,
-   (void *) NoOpGetTexLevelParameterfv,
-   (void *) NoOpGetTexLevelParameteriv,
-   (void *) NoOpIsEnabled,
-   (void *) NoOpIsList,
-   (void *) NoOpDepthRange,
-   (void *) NoOpFrustum,
-   (void *) NoOpLoadIdentity,
-   (void *) NoOpLoadMatrixf,
-   (void *) NoOpLoadMatrixd,
-   (void *) NoOpMatrixMode,
-   (void *) NoOpMultMatrixf,
-   (void *) NoOpMultMatrixd,
-   (void *) NoOpOrtho,
-   (void *) NoOpPopMatrix,
-   (void *) NoOpPushMatrix,
-   (void *) NoOpRotated,
-   (void *) NoOpRotatef,
-   (void *) NoOpScaled,
-   (void *) NoOpScalef,
-   (void *) NoOpTranslated,
-   (void *) NoOpTranslatef,
-   (void *) NoOpViewport,
-   /* 1.1 */
-   (void *) NoOpArrayElement,
-   (void *) NoOpBindTexture,
-   (void *) NoOpColorPointer,
-   (void *) NoOpDisableClientState,
-   (void *) NoOpDrawArrays,
-   (void *) NoOpDrawElements,
-   (void *) NoOpEdgeFlagPointer,
-   (void *) NoOpEnableClientState,
-   (void *) NoOpIndexPointer,
-   (void *) NoOpIndexub,
-   (void *) NoOpIndexubv,
-   (void *) NoOpInterleavedArrays,
-   (void *) NoOpNormalPointer,
-   (void *) NoOpPolygonOffset,
-   (void *) NoOpTexCoordPointer,
-   (void *) NoOpVertexPointer,
-   (void *) NoOpAreTexturesResident,
-   (void *) NoOpCopyTexImage1D,
-   (void *) NoOpCopyTexImage2D,
-   (void *) NoOpCopyTexSubImage1D,
-   (void *) NoOpCopyTexSubImage2D,
-   (void *) NoOpDeleteTextures,
-   (void *) NoOpGenTextures,
-   (void *) NoOpGetPointerv,
-   (void *) NoOpIsTexture,
-   (void *) NoOpPrioritizeTextures,
-   (void *) NoOpTexSubImage1D,
-   (void *) NoOpTexSubImage2D,
-   (void *) NoOpPopClientAttrib,
-   (void *) NoOpPushClientAttrib,
-   /* 1.2 */
-   (void *) NoOpBlendColor,
-   (void *) NoOpBlendEquation,
-   (void *) NoOpDrawRangeElements,
-   (void *) NoOpColorTable,
-   (void *) NoOpColorTableParameterfv,
-   (void *) NoOpColorTableParameteriv,
-   (void *) NoOpCopyColorTable,
-   (void *) NoOpGetColorTable,
-   (void *) NoOpGetColorTableParameterfv,
-   (void *) NoOpGetColorTableParameteriv,
-   (void *) NoOpColorSubTable,
-   (void *) NoOpCopyColorSubTable,
-   (void *) NoOpConvolutionFilter1D,
-   (void *) NoOpConvolutionFilter2D,
-   (void *) NoOpConvolutionParameterf,
-   (void *) NoOpConvolutionParameterfv,
-   (void *) NoOpConvolutionParameteri,
-   (void *) NoOpConvolutionParameteriv,
-   (void *) NoOpCopyConvolutionFilter1D,
-   (void *) NoOpCopyConvolutionFilter2D,
-   (void *) NoOpGetConvolutionFilter,
-   (void *) NoOpGetConvolutionParameterfv,
-   (void *) NoOpGetConvolutionParameteriv,
-   (void *) NoOpGetSeparableFilter,
-   (void *) NoOpSeparableFilter2D,
-   (void *) NoOpGetHistogram,
-   (void *) NoOpGetHistogramParameterfv,
-   (void *) NoOpGetHistogramParameteriv,
-   (void *) NoOpGetMinmax,
-   (void *) NoOpGetMinmaxParameterfv,
-   (void *) NoOpGetMinmaxParameteriv,
-   (void *) NoOpHistogram,
-   (void *) NoOpMinmax,
-   (void *) NoOpResetHistogram,
-   (void *) NoOpResetMinmax,
-   (void *) NoOpTexImage3D,
-   (void *) NoOpTexSubImage3D,
-   (void *) NoOpCopyTexSubImage3D,
-   /* GL_ARB_multitexture */
-   (void *) NoOpActiveTextureARB,
-   (void *) NoOpClientActiveTextureARB,
-   (void *) NoOpMultiTexCoord1dARB,
-   (void *) NoOpMultiTexCoord1dvARB,
-   (void *) NoOpMultiTexCoord1fARB,
-   (void *) NoOpMultiTexCoord1fvARB,
-   (void *) NoOpMultiTexCoord1iARB,
-   (void *) NoOpMultiTexCoord1ivARB,
-   (void *) NoOpMultiTexCoord1sARB,
-   (void *) NoOpMultiTexCoord1svARB,
-   (void *) NoOpMultiTexCoord2dARB,
-   (void *) NoOpMultiTexCoord2dvARB,
-   (void *) NoOpMultiTexCoord2fARB,
-   (void *) NoOpMultiTexCoord2fvARB,
-   (void *) NoOpMultiTexCoord2iARB,
-   (void *) NoOpMultiTexCoord2ivARB,
-   (void *) NoOpMultiTexCoord2sARB,
-   (void *) NoOpMultiTexCoord2svARB,
-   (void *) NoOpMultiTexCoord3dARB,
-   (void *) NoOpMultiTexCoord3dvARB,
-   (void *) NoOpMultiTexCoord3fARB,
-   (void *) NoOpMultiTexCoord3fvARB,
-   (void *) NoOpMultiTexCoord3iARB,
-   (void *) NoOpMultiTexCoord3ivARB,
-   (void *) NoOpMultiTexCoord3sARB,
-   (void *) NoOpMultiTexCoord3svARB,
-   (void *) NoOpMultiTexCoord4dARB,
-   (void *) NoOpMultiTexCoord4dvARB,
-   (void *) NoOpMultiTexCoord4fARB,
-   (void *) NoOpMultiTexCoord4fvARB,
-   (void *) NoOpMultiTexCoord4iARB,
-   (void *) NoOpMultiTexCoord4ivARB,
-   (void *) NoOpMultiTexCoord4sARB,
-   (void *) NoOpMultiTexCoord4svARB,
-   /* GL_ARB_transpose_matrix */
-   (void *) NoOpLoadTransposeMatrixfARB,
-   (void *) NoOpLoadTransposeMatrixdARB,
-   (void *) NoOpMultTransposeMatrixfARB,
-   (void *) NoOpMultTransposeMatrixdARB,
-   /* GL_ARB_multisample */
-   (void *) NoOpSampleCoverageARB,
-   (void *) NoOpSamplePassARB,
-   /* GL_EXT_blend_color */
-   /* GL_EXT_polygon_offset */
-   (void *) NoOpPolygonOffsetEXT,
-   /* GL_EXT_texture3D */
-   /* GL_EXT_subtexture */
-   /* GL_SGIS_texture_filter4 */
-   (void *) NoOpGetTexFilterFuncSGIS,
-   (void *) NoOpTexFilterFuncSGIS,
-   /* GL_EXT_subtexture */
-   /* GL_EXT_copy_texture */
-   /* GL_EXT_histogram */
-   (void *) NoOpGetHistogramEXT,
-   (void *) NoOpGetHistogramParameterfvEXT,
-   (void *) NoOpGetHistogramParameterivEXT,
-   (void *) NoOpGetMinmaxEXT,
-   (void *) NoOpGetMinmaxParameterfvEXT,
-   (void *) NoOpGetMinmaxParameterivEXT,
-   /* GL_EXT_convolution */
-   (void *) NoOpGetConvolutionFilterEXT,
-   (void *) NoOpGetConvolutionParameterfvEXT,
-   (void *) NoOpGetConvolutionParameterivEXT,
-   (void *) NoOpGetSeparableFilterEXT,
-   /* GL_SGI_color_table */
-   (void *) NoOpGetColorTableSGI,
-   (void *) NoOpGetColorTableParameterfvSGI,
-   (void *) NoOpGetColorTableParameterivSGI,
-   /* GL_SGIX_pixel_texture */
-   (void *) NoOpPixelTexGenSGIX,
-   /* GL_SGIS_pixel_texture */
-   (void *) NoOpPixelTexGenParameteriSGIS,
-   (void *) NoOpPixelTexGenParameterivSGIS,
-   (void *) NoOpPixelTexGenParameterfSGIS,
-   (void *) NoOpPixelTexGenParameterfvSGIS,
-   (void *) NoOpGetPixelTexGenParameterivSGIS,
-   (void *) NoOpGetPixelTexGenParameterfvSGIS,
-   /* GL_SGIS_texture4D */
-   (void *) NoOpTexImage4DSGIS,
-   (void *) NoOpTexSubImage4DSGIS,
-   /* GL_EXT_texture_object */
-   (void *) NoOpAreTexturesResidentEXT,
-   (void *) NoOpGenTexturesEXT,
-   (void *) NoOpIsTextureEXT,
-   /* GL_SGIS_detail_texture */
-   (void *) NoOpDetailTexFuncSGIS,
-   (void *) NoOpGetDetailTexFuncSGIS,
-   /* GL_SGIS_sharpen_texture */
-   (void *) NoOpSharpenTexFuncSGIS,
-   (void *) NoOpGetSharpenTexFuncSGIS,
-   /* GL_SGIS_multisample */
-   (void *) NoOpSampleMaskSGIS,
-   (void *) NoOpSamplePatternSGIS,
-   /* GL_EXT_vertex_array */
-   (void *) NoOpColorPointerEXT,
-   (void *) NoOpEdgeFlagPointerEXT,
-   (void *) NoOpIndexPointerEXT,
-   (void *) NoOpNormalPointerEXT,
-   (void *) NoOpTexCoordPointerEXT,
-   (void *) NoOpVertexPointerEXT,
-   /* GL_EXT_blend_minmax */
-   /* GL_SGIX_sprite */
-   (void *) NoOpSpriteParameterfSGIX,
-   (void *) NoOpSpriteParameterfvSGIX,
-   (void *) NoOpSpriteParameteriSGIX,
-   (void *) NoOpSpriteParameterivSGIX,
-   /* GL_EXT_point_parameters */
-   (void *) NoOpPointParameterfEXT,
-   (void *) NoOpPointParameterfvEXT,
-   /* GL_SGIX_instruments */
-   (void *) NoOpGetInstrumentsSGIX,
-   (void *) NoOpInstrumentsBufferSGIX,
-   (void *) NoOpPollInstrumentsSGIX,
-   (void *) NoOpReadInstrumentsSGIX,
-   (void *) NoOpStartInstrumentsSGIX,
-   (void *) NoOpStopInstrumentsSGIX,
-   /* GL_SGIX_framezoom */
-   (void *) NoOpFrameZoomSGIX,
-   /* GL_SGIX_tag_sample_buffer */
-   (void *) NoOpTagSampleBufferSGIX,
-   /* GL_SGIX_reference_plane */
-   (void *) NoOpReferencePlaneSGIX,
-   /* GL_SGIX_flush_raster */
-   (void *) NoOpFlushRasterSGIX,
-   /* GL_SGIX_list_priority */
-   (void *) NoOpGetListParameterfvSGIX,
-   (void *) NoOpGetListParameterivSGIX,
-   (void *) NoOpListParameterfSGIX,
-   (void *) NoOpListParameterfvSGIX,
-   (void *) NoOpListParameteriSGIX,
-   (void *) NoOpListParameterivSGIX,
-   /* GL_SGIX_fragment_lighting */
-   (void *) NoOpFragmentColorMaterialSGIX,
-   (void *) NoOpFragmentLightfSGIX,
-   (void *) NoOpFragmentLightfvSGIX,
-   (void *) NoOpFragmentLightiSGIX,
-   (void *) NoOpFragmentLightivSGIX,
-   (void *) NoOpFragmentLightModelfSGIX,
-   (void *) NoOpFragmentLightModelfvSGIX,
-   (void *) NoOpFragmentLightModeliSGIX,
-   (void *) NoOpFragmentLightModelivSGIX,
-   (void *) NoOpFragmentMaterialfSGIX,
-   (void *) NoOpFragmentMaterialfvSGIX,
-   (void *) NoOpFragmentMaterialiSGIX,
-   (void *) NoOpFragmentMaterialivSGIX,
-   (void *) NoOpGetFragmentLightfvSGIX,
-   (void *) NoOpGetFragmentLightivSGIX,
-   (void *) NoOpGetFragmentMaterialfvSGIX,
-   (void *) NoOpGetFragmentMaterialivSGIX,
-   (void *) NoOpLightEnviSGIX,
-   /* GL_EXT_vertex_weighting */
-   (void *) NoOpVertexWeightfEXT,
-   (void *) NoOpVertexWeightfvEXT,
-   (void *) NoOpVertexWeightPointerEXT,
-   /* GL_NV_vertex_array_range */
-   (void *) NoOpFlushVertexArrayRangeNV,
-   (void *) NoOpVertexArrayRangeNV,
-   /* GL_NV_register_combiners */
-   (void *) NoOpCombinerParameterfvNV,
-   (void *) NoOpCombinerParameterfNV,
-   (void *) NoOpCombinerParameterivNV,
-   (void *) NoOpCombinerParameteriNV,
-   (void *) NoOpCombinerInputNV,
-   (void *) NoOpCombinerOutputNV,
-   (void *) NoOpFinalCombinerInputNV,
-   (void *) NoOpGetCombinerInputParameterfvNV,
-   (void *) NoOpGetCombinerInputParameterivNV,
-   (void *) NoOpGetCombinerOutputParameterfvNV,
-   (void *) NoOpGetCombinerOutputParameterivNV,
-   (void *) NoOpGetFinalCombinerInputParameterfvNV,
-   (void *) NoOpGetFinalCombinerInputParameterivNV,
-   /* GL_MESA_resize_buffers */
-   (void *) NoOpResizeBuffersMESA,
-   /* GL_MESA_window_pos */
-   (void *) NoOpWindowPos2dMESA,
-   (void *) NoOpWindowPos2dvMESA,
-   (void *) NoOpWindowPos2fMESA,
-   (void *) NoOpWindowPos2fvMESA,
-   (void *) NoOpWindowPos2iMESA,
-   (void *) NoOpWindowPos2ivMESA,
-   (void *) NoOpWindowPos2sMESA,
-   (void *) NoOpWindowPos2svMESA,
-   (void *) NoOpWindowPos3dMESA,
-   (void *) NoOpWindowPos3dvMESA,
-   (void *) NoOpWindowPos3fMESA,
-   (void *) NoOpWindowPos3fvMESA,
-   (void *) NoOpWindowPos3iMESA,
-   (void *) NoOpWindowPos3ivMESA,
-   (void *) NoOpWindowPos3sMESA,
-   (void *) NoOpWindowPos3svMESA,
-   (void *) NoOpWindowPos4dMESA,
-   (void *) NoOpWindowPos4dvMESA,
-   (void *) NoOpWindowPos4fMESA,
-   (void *) NoOpWindowPos4fvMESA,
-   (void *) NoOpWindowPos4iMESA,
-   (void *) NoOpWindowPos4ivMESA,
-   (void *) NoOpWindowPos4sMESA,
-   (void *) NoOpWindowPos4svMESA,
-   /* GL_EXT_draw_range_elements */
-   (void *) NoOpBlendFuncSeparateEXT,
-   /* GL_EXT_index_material */
-   (void *) NoOpIndexMaterialEXT,
-   /* GL_EXT_index_func */
-   (void *) NoOpIndexFuncEXT,
-   /* GL_EXT_compiled_vertex_array */
-   (void *) NoOpLockArraysEXT,
-   (void *) NoOpUnlockArraysEXT,
-   /* GL_EXT_cull_vertex */
-   (void *) NoOpCullParameterdvEXT,
-   (void *) NoOpCullParameterfvEXT,
-   /* GL_PGI_misc_hints */
-   (void *) NoOpHintPGI,
-   /* GL_EXT_fog_coord */
-   (void *) NoOpFogCoordfEXT,
-   (void *) NoOpFogCoordfvEXT,
-   (void *) NoOpFogCoorddEXT,
-   (void *) NoOpFogCoorddvEXT,
-   (void *) NoOpFogCoordPointerEXT,
-   /* GL_EXT_color_table */
-   (void *) NoOpGetColorTableEXT,
-   (void *) NoOpGetColorTableParameterivEXT,
-   (void *) NoOpGetColorTableParameterfvEXT,
-   /* GL_3DFX_tbuffer */
-   (void *) NoOpTbufferMask3DFX,
-   /* GL_ARB_texture_compression */
-   (void *) NoOpCompressedTexImage3DARB,
-   (void *) NoOpCompressedTexImage2DARB,
-   (void *) NoOpCompressedTexImage1DARB,
-   (void *) NoOpCompressedTexSubImage3DARB,
-   (void *) NoOpCompressedTexSubImage2DARB,
-   (void *) NoOpCompressedTexSubImage1DARB,
-   (void *) NoOpGetCompressedTexImageARB,
-   /* A whole bunch of no-op functions.  These might be called
-    * when someone tries to call a dynamically-registered extension
-    * function without a current rendering context.
-    */
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric,
-   (void *) NoOpGeneric
-};
Index: xc/extras/Mesa/src/glapinoop.h
diff -u xc/extras/Mesa/src/glapinoop.h:1.3 xc/extras/Mesa/src/glapinoop.h:removed
--- xc/extras/Mesa/src/glapinoop.h:1.3	Thu Mar  2 11:07:08 2000
+++ xc/extras/Mesa/src/glapinoop.h	Thu Feb 27 12:15:37 2003
@@ -1,40 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef _GLAPINOOP_H
-#define _GLAPINOOP_H
-
-#include "glapi.h"
-
-
-extern void
-_glapi_noop_enable_warnings(GLboolean enable);
-
-
-extern void *__glapi_noop_table[];
-
-
-#endif
Index: xc/extras/Mesa/src/glapioffsets.h
diff -u xc/extras/Mesa/src/glapioffsets.h:1.4 xc/extras/Mesa/src/glapioffsets.h:1.5
--- xc/extras/Mesa/src/glapioffsets.h:1.4	Fri Jun 16 20:02:11 2000
+++ xc/extras/Mesa/src/glapioffsets.h	Fri Feb 22 14:25:31 2002
@@ -563,5 +563,22 @@
 #define _gloffset_CompressedTexSubImage2DARB 558
 #define _gloffset_CompressedTexSubImage1DARB 559
 #define _gloffset_GetCompressedTexImageARB 560
+#define _gloffset_SecondaryColor3bEXT 561
+#define _gloffset_SecondaryColor3bvEXT 562
+#define _gloffset_SecondaryColor3dEXT 563
+#define _gloffset_SecondaryColor3dvEXT 564
+#define _gloffset_SecondaryColor3fEXT 565
+#define _gloffset_SecondaryColor3fvEXT 566
+#define _gloffset_SecondaryColor3iEXT 567
+#define _gloffset_SecondaryColor3ivEXT 568
+#define _gloffset_SecondaryColor3sEXT 569
+#define _gloffset_SecondaryColor3svEXT 570
+#define _gloffset_SecondaryColor3ubEXT 571
+#define _gloffset_SecondaryColor3ubvEXT 572
+#define _gloffset_SecondaryColor3uiEXT 573
+#define _gloffset_SecondaryColor3uivEXT 574
+#define _gloffset_SecondaryColor3usEXT 575
+#define _gloffset_SecondaryColor3usvEXT 576
+#define _gloffset_SecondaryColorPointerEXT 577
 
 #endif
Index: xc/extras/Mesa/src/glapitable.h
diff -u xc/extras/Mesa/src/glapitable.h:1.4 xc/extras/Mesa/src/glapitable.h:1.5
--- xc/extras/Mesa/src/glapitable.h:1.4	Fri Jun 16 20:02:11 2000
+++ xc/extras/Mesa/src/glapitable.h	Fri Feb 22 14:25:31 2002
@@ -313,7 +313,7 @@
    void (*Translatef)(GLfloat x, GLfloat y, GLfloat z); /* 304 */
    void (*Viewport)(GLint x, GLint y, GLsizei width, GLsizei height); /* 305 */
    void (*ArrayElement)(GLint i); /* 306 */
-   void (*BindTexture)(GLenum target, GLenum texture); /* 307 */
+   void (*BindTexture)(GLenum target, GLuint texture); /* 307 */
    void (*ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 308 */
    void (*DisableClientState)(GLenum array); /* 309 */
    void (*DrawArrays)(GLenum mode, GLint first, GLsizei count); /* 310 */
@@ -328,16 +328,16 @@
    void (*PolygonOffset)(GLfloat factor, GLfloat units); /* 319 */
    void (*TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 320 */
    void (*VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 321 */
-   GLboolean (*AreTexturesResident)(GLsizei n, const GLenum * textures, GLboolean * residences); /* 322 */
+   GLboolean (*AreTexturesResident)(GLsizei n, const GLuint * textures, GLboolean * residences); /* 322 */
    void (*CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); /* 323 */
    void (*CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); /* 324 */
    void (*CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); /* 325 */
    void (*CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 326 */
-   void (*DeleteTextures)(GLsizei n, const GLenum * textures); /* 327 */
-   void (*GenTextures)(GLsizei n, GLenum * textures); /* 328 */
+   void (*DeleteTextures)(GLsizei n, const GLuint * textures); /* 327 */
+   void (*GenTextures)(GLsizei n, GLuint * textures); /* 328 */
    void (*GetPointerv)(GLenum pname, GLvoid * * params); /* 329 */
-   GLboolean (*IsTexture)(GLenum texture); /* 330 */
-   void (*PrioritizeTextures)(GLsizei n, const GLenum * textures, const GLclampf * priorities); /* 331 */
+   GLboolean (*IsTexture)(GLuint texture); /* 330 */
+   void (*PrioritizeTextures)(GLsizei n, const GLuint * textures, const GLclampf * priorities); /* 331 */
    void (*TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels); /* 332 */
    void (*TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels); /* 333 */
    void (*PopClientAttrib)(void); /* 334 */
@@ -377,7 +377,7 @@
    void (*Minmax)(GLenum target, GLenum internalformat, GLboolean sink); /* 368 */
    void (*ResetHistogram)(GLenum target); /* 369 */
    void (*ResetMinmax)(GLenum target); /* 370 */
-   void (*TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 371 */
+   void (*TexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 371 */
    void (*TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels); /* 372 */
    void (*CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); /* 373 */
    void (*ActiveTextureARB)(GLenum texture); /* 374 */
@@ -445,9 +445,9 @@
    void (*GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 436 */
    void (*TexImage4DSGIS)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid * pixels); /* 437 */
    void (*TexSubImage4DSGIS)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid * pixels); /* 438 */
-   GLboolean (*AreTexturesResidentEXT)(GLsizei n, const GLenum * textures, GLboolean * residences); /* 439 */
-   void (*GenTexturesEXT)(GLsizei n, GLenum * textures); /* 440 */
-   GLboolean (*IsTextureEXT)(GLenum texture); /* 441 */
+   GLboolean (*AreTexturesResidentEXT)(GLsizei n, const GLuint * textures, GLboolean * residences); /* 439 */
+   void (*GenTexturesEXT)(GLsizei n, GLuint * textures); /* 440 */
+   GLboolean (*IsTextureEXT)(GLuint texture); /* 441 */
    void (*DetailTexFuncSGIS)(GLenum target, GLsizei n, const GLfloat * points); /* 442 */
    void (*GetDetailTexFuncSGIS)(GLenum target, GLfloat * points); /* 443 */
    void (*SharpenTexFuncSGIS)(GLenum target, GLsizei n, const GLfloat * points); /* 444 */
@@ -548,8 +548,8 @@
    void (*IndexFuncEXT)(GLenum func, GLclampf ref); /* 539 */
    void (*LockArraysEXT)(GLint first, GLsizei count); /* 540 */
    void (*UnlockArraysEXT)(void); /* 541 */
-   void (*CullParameterdvEXT)(GLenum pname, const GLdouble * params); /* 542 */
-   void (*CullParameterfvEXT)(GLenum pname, const GLfloat * params); /* 543 */
+   void (*CullParameterdvEXT)(GLenum pname, GLdouble * params); /* 542 */
+   void (*CullParameterfvEXT)(GLenum pname, GLfloat * params); /* 543 */
    void (*HintPGI)(GLenum target, GLint mode); /* 544 */
    void (*FogCoordfEXT)(GLfloat coord); /* 545 */
    void (*FogCoordfvEXT)(const GLfloat * coord); /* 546 */
@@ -566,7 +566,24 @@
    void (*CompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data); /* 557 */
    void (*CompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data); /* 558 */
    void (*CompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data); /* 559 */
-   void (*GetCompressedTexImageARB)(GLenum target, GLint level, void * img); /* 560 */
+   void (*GetCompressedTexImageARB)(GLenum target, GLint level, GLvoid * img); /* 560 */
+   void (*SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue); /* 561 */
+   void (*SecondaryColor3bvEXT)(const GLbyte * v); /* 562 */
+   void (*SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue); /* 563 */
+   void (*SecondaryColor3dvEXT)(const GLdouble * v); /* 564 */
+   void (*SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue); /* 565 */
+   void (*SecondaryColor3fvEXT)(const GLfloat * v); /* 566 */
+   void (*SecondaryColor3iEXT)(GLint red, GLint green, GLint blue); /* 567 */
+   void (*SecondaryColor3ivEXT)(const GLint * v); /* 568 */
+   void (*SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue); /* 569 */
+   void (*SecondaryColor3svEXT)(const GLshort * v); /* 570 */
+   void (*SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue); /* 571 */
+   void (*SecondaryColor3ubvEXT)(const GLubyte * v); /* 572 */
+   void (*SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue); /* 573 */
+   void (*SecondaryColor3uivEXT)(const GLuint * v); /* 574 */
+   void (*SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue); /* 575 */
+   void (*SecondaryColor3usvEXT)(const GLushort * v); /* 576 */
+   void (*SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 577 */
 };
 
 #endif
Index: xc/extras/Mesa/src/glapitemp.h
diff -u xc/extras/Mesa/src/glapitemp.h:1.4 xc/extras/Mesa/src/glapitemp.h:1.5
--- xc/extras/Mesa/src/glapitemp.h:1.4	Fri Jun 16 20:02:11 2000
+++ xc/extras/Mesa/src/glapitemp.h	Fri Feb 22 14:25:32 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -58,21 +58,15 @@
 #endif
 
 #ifndef NAME
-#define NAME(func)  gl##func
+#error NAME must be defined
 #endif
 
 #ifndef DISPATCH
-#define DISPATCH(func, args, msg)					\
-   const struct _glapi_table *dispatch;					\
-   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
-   (dispatch->func) args
+#error DISPATCH must be defined
 #endif
 
 #ifndef RETURN_DISPATCH
-#define RETURN_DISPATCH(FUNC, ARGS, MESSAGE) 				\
-   const struct _glapi_table *dispatch;					\
-   dispatch = _glapi_Dispatch ? _glapi_Dispatch : _glapi_get_dispatch();\
-   return (dispatch->func) args
+#error RETURN_DISPATCH must be defined
 #endif
 
 
@@ -102,6 +96,11 @@
    DISPATCH(AlphaFunc, (func, ref), (F, "glAlphaFunc(0x%x, %g);", func, ref));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ArrayElementEXT)(GLint i)
+{
+   DISPATCH(ArrayElement, (i), (F, ";"));
+}
+
 KEYWORD1 void KEYWORD2 NAME(Begin)(GLenum mode)
 {
    DISPATCH(Begin, (mode), (F, "glBegin(0x%x);", mode));
@@ -159,7 +158,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(ClipPlane)(GLenum plane, const GLdouble *equation)
 {
-   DISPATCH(ClipPlane, (plane, equation), (F, "glClipPlane(%p);", equation));
+   DISPATCH(ClipPlane, (plane, equation), (F, "glClipPlane(%p);", (void *) equation));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3b)(GLbyte red, GLbyte green, GLbyte blue)
@@ -249,37 +248,37 @@
 
 KEYWORD1 void KEYWORD2 NAME(Color3dv)(const GLdouble *v)
 {
-   DISPATCH(Color3dv, (v), (F, "glColor3dv(%p);", v));
+   DISPATCH(Color3dv, (v), (F, "glColor3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3fv)(const GLfloat *v)
 {
-   DISPATCH(Color3fv, (v), (F, "glColor3fv(%p);", v));
+   DISPATCH(Color3fv, (v), (F, "glColor3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3iv)(const GLint *v)
 {
-   DISPATCH(Color3iv, (v), (F, "glColor3iv(%p);", v));
+   DISPATCH(Color3iv, (v), (F, "glColor3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3sv)(const GLshort *v)
 {
-   DISPATCH(Color3sv, (v), (F, "glColor3sv(%p);", v));
+   DISPATCH(Color3sv, (v), (F, "glColor3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3ubv)(const GLubyte *v)
 {
-   DISPATCH(Color3ubv, (v), (F, "glColor3ubv(%p);", v));
+   DISPATCH(Color3ubv, (v), (F, "glColor3ubv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3uiv)(const GLuint *v)
 {
-   DISPATCH(Color3uiv, (v), (F, "glColor3uiv(%p);", v));
+   DISPATCH(Color3uiv, (v), (F, "glColor3uiv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color3usv)(const GLushort *v)
 {
-   DISPATCH(Color3usv, (v), (F, "glColor3usv(%p);", v));
+   DISPATCH(Color3usv, (v), (F, "glColor3usv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4bv)(const GLbyte *v)
@@ -289,37 +288,37 @@
 
 KEYWORD1 void KEYWORD2 NAME(Color4dv)(const GLdouble *v)
 {
-   DISPATCH(Color4dv, (v), (F, "glColor4dv(%p);", v));
+   DISPATCH(Color4dv, (v), (F, "glColor4dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4fv)(const GLfloat *v)
 {
-   DISPATCH(Color4fv, (v), (F, "glColor4fv(%p);", v));
+   DISPATCH(Color4fv, (v), (F, "glColor4fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4iv)(const GLint *v)
 {
-   DISPATCH(Color4iv, (v), (F, "glColor4iv(%p);", v));
+   DISPATCH(Color4iv, (v), (F, "glColor4iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4sv)(const GLshort *v)
 {
-   DISPATCH(Color4sv, (v), (F, "glColor4sv(%p);", v));
+   DISPATCH(Color4sv, (v), (F, "glColor4sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4ubv)(const GLubyte *v)
 {
-   DISPATCH(Color4ubv, (v), (F, "glColor4ubv(%p);", v));
+   DISPATCH(Color4ubv, (v), (F, "glColor4ubv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4uiv)(const GLuint *v)
 {
-   DISPATCH(Color4uiv, (v), (F, "glColor4uiv(%p);", v));
+   DISPATCH(Color4uiv, (v), (F, "glColor4uiv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Color4usv)(const GLushort *v)
 {
-   DISPATCH(Color4usv, (v), (F, "glColor4usv(%p);", v));
+   DISPATCH(Color4usv, (v), (F, "glColor4usv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
@@ -382,6 +381,16 @@
    DISPATCH(DrawPixels, (width, height, format, type, pixels), (F, "glDrawPixels(%d, %d, 0x%x, 0x%x, %p);", width, height, format, type, pixels));
 }
 
+KEYWORD1 void KEYWORD2 NAME(EdgeFlag)(GLboolean flag)
+{
+   DISPATCH(EdgeFlag, (flag), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(EdgeFlagv)(const GLboolean *flag)
+{
+   DISPATCH(EdgeFlagv, (flag), (F, ";"));
+}
+
 KEYWORD1 void KEYWORD2 NAME(Enable)(GLenum cap)
 {
    DISPATCH(Enable, (cap), (F, "glEnable(0x%x);", cap));
@@ -437,39 +446,29 @@
    DISPATCH(EvalCoord2fv, (u), (F, ";"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(EvalPoint1)(GLint i)
-{
-   DISPATCH(EvalPoint1, (i), (F, ";"));
-}
-
-KEYWORD1 void KEYWORD2 NAME(EvalPoint2)(GLint i, GLint j)
-{
-   DISPATCH(EvalPoint2, (i, j), (F, ";"));
-}
-
 KEYWORD1 void KEYWORD2 NAME(EvalMesh1)(GLenum mode, GLint i1, GLint i2)
 {
-   DISPATCH(EvalMesh1, (mode, i1, i2), (F, ";"));
+   DISPATCH(EvalMesh1, (mode, i1, i2), (F, "glEvalMesh(0x%x, %d, %d);", mode, i1, i2));
 }
 
-KEYWORD1 void KEYWORD2 NAME(EdgeFlag)(GLboolean flag)
+KEYWORD1 void KEYWORD2 NAME(EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-   DISPATCH(EdgeFlag, (flag), (F, ";"));
+   DISPATCH(EvalMesh2, (mode, i1, i2, j1, j2), (F, "glEvalMesh2(0x%x, %d, %d, %d, %d);", mode, i1, i2, j1, j2));
 }
 
-KEYWORD1 void KEYWORD2 NAME(EdgeFlagv)(const GLboolean *flag)
+KEYWORD1 void KEYWORD2 NAME(EvalPoint1)(GLint i)
 {
-   DISPATCH(EdgeFlagv, (flag), (F, ";"));
+   DISPATCH(EvalPoint1, (i), (F, ";"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+KEYWORD1 void KEYWORD2 NAME(EvalPoint2)(GLint i, GLint j)
 {
-   DISPATCH(EvalMesh2, (mode, i1, i2, j1, j2), (F, ";"));
+   DISPATCH(EvalPoint2, (i, j), (F, ";"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FeedbackBuffer)(GLsizei size, GLenum type, GLfloat *buffer)
 {
-   DISPATCH(FeedbackBuffer, (size, type, buffer), (F, ";"));
+   DISPATCH(FeedbackBuffer, (size, type, buffer), (F, "glFeedbackBuffer(%d, 0x%x, %p);", size, type, (void *) buffer));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Finish)(void)
@@ -494,12 +493,12 @@
 
 KEYWORD1 void KEYWORD2 NAME(Fogfv)(GLenum pname, const GLfloat *params)
 {
-   DISPATCH(Fogfv, (pname, params), (F, "glFogfv(0x%x, %p);", pname, params));
+   DISPATCH(Fogfv, (pname, params), (F, "glFogfv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Fogiv)(GLenum pname, const GLint *params)
 {
-   DISPATCH(Fogiv, (pname, params), (F, "glFogiv(0x%x, %p);", pname, params));
+   DISPATCH(Fogiv, (pname, params), (F, "glFogiv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FrontFace)(GLenum mode)
@@ -524,12 +523,12 @@
 
 KEYWORD1 void KEYWORD2 NAME(GetClipPlane)(GLenum plane, GLdouble *equation)
 {
-   DISPATCH(GetClipPlane, (plane, equation), (F, "glGetClipPlane(x0%x, %p);", plane, equation));
+   DISPATCH(GetClipPlane, (plane, equation), (F, "glGetClipPlane(x0%x, %p);", plane, (void *) equation));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetDoublev)(GLenum pname, GLdouble *params)
 {
-   DISPATCH(GetDoublev, (pname, params), (F, "glGetDoublev(0x%x, %p);", pname, params));
+   DISPATCH(GetDoublev, (pname, params), (F, "glGetDoublev(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 GLenum KEYWORD2 NAME(GetError)(void)
@@ -539,67 +538,67 @@
 
 KEYWORD1 void KEYWORD2 NAME(GetFloatv)(GLenum pname, GLfloat *params)
 {
-   DISPATCH(GetFloatv, (pname, params), (F, "glGetFloatv(0x%x, %p);", pname, params));
+   DISPATCH(GetFloatv, (pname, params), (F, "glGetFloatv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetIntegerv)(GLenum pname, GLint *params)
 {
-   DISPATCH(GetIntegerv, (pname, params), (F, "glGetIntegerv(0x%x, %p);", pname, params));
+   DISPATCH(GetIntegerv, (pname, params), (F, "glGetIntegerv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetLightfv)(GLenum light, GLenum pname, GLfloat *params)
 {
-   DISPATCH(GetLightfv, (light, pname, params), (F, ";"));
+   DISPATCH(GetLightfv, (light, pname, params), (F, "glGetLightfv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetLightiv)(GLenum light, GLenum pname, GLint *params)
 {
-   DISPATCH(GetLightiv, (light, pname, params), (F, ";"));
+   DISPATCH(GetLightiv, (light, pname, params), (F, "glGetLightiv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMapdv)(GLenum target, GLenum query, GLdouble *v)
 {
-   DISPATCH(GetMapdv, (target, query, v), (F, ";"));
+   DISPATCH(GetMapdv, (target, query, v), (F, "glGetMapdv(0x%x, 0x%x, %p);", target, query, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMapfv)(GLenum target, GLenum query, GLfloat *v)
 {
-   DISPATCH(GetMapfv, (target, query, v), (F, ";"));
+   DISPATCH(GetMapfv, (target, query, v), (F, "glGetMapfv(0x%x, 0x%x, %p);", target, query, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMapiv)(GLenum target, GLenum query, GLint *v)
 {
-   DISPATCH(GetMapiv, (target, query, v), (F, ";"));
+   DISPATCH(GetMapiv, (target, query, v), (F, "glGetMapiv(0x%x, 0x%x, %p);", target, query, (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMaterialfv)(GLenum face, GLenum pname, GLfloat *params)
 {
-   DISPATCH(GetMaterialfv, (face, pname, params), (F, ";"));
+   DISPATCH(GetMaterialfv, (face, pname, params), (F, "glGetMaterialfv(0x%x, 0x%x, %p;", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetMaterialiv)(GLenum face, GLenum pname, GLint *params)
 {
-   DISPATCH(GetMaterialiv, (face, pname, params), (F, ";"));
+   DISPATCH(GetMaterialiv, (face, pname, params), (F, "glGetMaterialiv(0x%x, 0x%x, %p);", face, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelMapfv)(GLenum map, GLfloat *values)
 {
-   DISPATCH(GetPixelMapfv, (map, values), (F, ";"));
+   DISPATCH(GetPixelMapfv, (map, values), (F, "glGetPixelMapfv(0x%x, %p);", map, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelMapuiv)(GLenum map, GLuint *values)
 {
-   DISPATCH(GetPixelMapuiv, (map, values), (F, ";"));
+   DISPATCH(GetPixelMapuiv, (map, values), (F, "glGetPixelMapuiv(0x%x, %p);", map, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPixelMapusv)(GLenum map, GLushort *values)
 {
-   DISPATCH(GetPixelMapusv, (map, values), (F, ";"));
+   DISPATCH(GetPixelMapusv, (map, values), (F, "glGetPixelMapusv(0x%x, %p);", map, (void *) values));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPolygonStipple)(GLubyte *mask)
 {
-   DISPATCH(GetPolygonStipple, (mask), (F, ";"));
+   DISPATCH(GetPolygonStipple, (mask), (F, "glGetPolygonStipple(%p);", mask));
 }
 
 KEYWORD1 const GLubyte * KEYWORD2 NAME(GetString)(GLenum name)
@@ -609,57 +608,57 @@
 
 KEYWORD1 void KEYWORD2 NAME(GetTexEnvfv)(GLenum target, GLenum pname, GLfloat *params)
 {
-   DISPATCH(GetTexEnvfv, (target, pname, params), (F, ";"));
+   DISPATCH(GetTexEnvfv, (target, pname, params), (F, "glGettexEnvfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexEnviv)(GLenum target, GLenum pname, GLint *params)
 {
-   DISPATCH(GetTexEnviv, (target, pname, params), (F, ";"));
+   DISPATCH(GetTexEnviv, (target, pname, params), (F, "glGetTexEnviv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexGeniv)(GLenum target, GLenum pname, GLint *params)
 {
-   DISPATCH(GetTexGeniv, (target, pname, params), (F, ";"));
+   DISPATCH(GetTexGeniv, (target, pname, params), (F, "glGetTexGeniv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexGendv)(GLenum target, GLenum pname, GLdouble *params)
 {
-   DISPATCH(GetTexGendv, (target, pname, params), (F, ";"));
+   DISPATCH(GetTexGendv, (target, pname, params), (F, "glGetTexGendv(0x%x, 0x%x, %p;", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexGenfv)(GLenum target, GLenum pname, GLfloat *params)
 {
-   DISPATCH(GetTexGenfv, (target, pname, params), (F, ";"));
+   DISPATCH(GetTexGenfv, (target, pname, params), (F, "glGetTexGenfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-   DISPATCH(GetTexImage, (target, level, format, type, pixels), (F, ";"));
+   DISPATCH(GetTexImage, (target, level, format, type, pixels), (F, "glGetTexImage(0x%x, %d, 0x%x, 0x%x, %p);", target, level, format, type, pixels));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-   DISPATCH(GetTexLevelParameterfv, (target, level, pname, params), (F, ";"));
+   DISPATCH(GetTexLevelParameterfv, (target, level, pname, params), (F, "glGetTexLevelParameterfv(0x%x, %d, 0x%x, %p);", target, level, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-   DISPATCH(GetTexLevelParameteriv, (target, level, pname, params), (F, ";"));
+   DISPATCH(GetTexLevelParameteriv, (target, level, pname, params), (F, "glGetTexLevelParameteriv(0x%x, %d, 0x%x, %p);", target, level, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params)
 {
-   DISPATCH(GetTexParameterfv, (target, pname, params), (F, ";"));
+   DISPATCH(GetTexParameterfv, (target, pname, params), (F, "glGetTexParameterfv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetTexParameteriv)(GLenum target, GLenum pname, GLint *params)
 {
-   DISPATCH(GetTexParameteriv, (target, pname, params), (F, ";"));
+   DISPATCH(GetTexParameteriv, (target, pname, params), (F, "glGetTexParameteriv(0x%x, 0x%x, %p);", target, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Hint)(GLenum target, GLenum mode)
 {
-   DISPATCH(Hint, (target, mode), (F, ";"));
+   DISPATCH(Hint, (target, mode), (F, "glHint(0x%x, 0x%x);", target, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Indexd)(GLdouble c)
@@ -702,14 +701,24 @@
    DISPATCH(Indexsv, (c), (F, ";"));
 }
 
+KEYWORD1 void KEYWORD2 NAME(Indexub)(GLubyte c)
+{
+   DISPATCH(Indexub, (c), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(Indexubv)(const GLubyte *c)
+{
+   DISPATCH(Indexubv, (c), (F, ";"));
+}
+
 KEYWORD1 void KEYWORD2 NAME(IndexMask)(GLuint mask)
 {
-   DISPATCH(IndexMask, (mask), (F, ";"));
+   DISPATCH(IndexMask, (mask), (F, "glIndexMask(%u);", mask));
 }
 
 KEYWORD1 void KEYWORD2 NAME(InitNames)(void)
 {
-   DISPATCH(InitNames, (), (F, ";"));
+   DISPATCH(InitNames, (), (F, "glInitNames();"));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(IsEnabled)(GLenum cap)
@@ -724,82 +733,82 @@
 
 KEYWORD1 void KEYWORD2 NAME(Lightf)(GLenum light, GLenum pname, GLfloat param)
 {
-   DISPATCH(Lightf, (light, pname, param), (F, ";"));
+   DISPATCH(Lightf, (light, pname, param), (F, "glLightfv(0x%x, 0x%x, %g);", light, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Lighti)(GLenum light, GLenum pname, GLint param)
 {
-   DISPATCH(Lighti, (light, pname, param), (F, ";"));
+   DISPATCH(Lighti, (light, pname, param), (F, "glLighti(0x%x, 0x%x, %d);", light, pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Lightfv)(GLenum light, GLenum pname, const GLfloat *params)
 {
-   DISPATCH(Lightfv, (light, pname, params), (F, ";"));
+   DISPATCH(Lightfv, (light, pname, params), (F, "glLightfv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Lightiv)(GLenum light, GLenum pname, const GLint *params)
 {
-   DISPATCH(Lightiv, (light, pname, params), (F, ";"));
+   DISPATCH(Lightiv, (light, pname, params), (F, "glLightiv(0x%x, 0x%x, %p);", light, pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModelf)(GLenum pname, GLfloat param)
 {
-   DISPATCH(LightModelf, (pname, param), (F, ";"));
+   DISPATCH(LightModelf, (pname, param), (F, "glLightModelf(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModeli)(GLenum pname, GLint param)
 {
-   DISPATCH(LightModeli, (pname, param), (F, ";"));
+   DISPATCH(LightModeli, (pname, param), (F, "glLightModeli(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModelfv)(GLenum pname, const GLfloat *params)
 {
-   DISPATCH(LightModelfv, (pname, params), (F, ";"));
+   DISPATCH(LightModelfv, (pname, params), (F, "glLightModelfv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LightModeliv)(GLenum pname, const GLint *params)
 {
-   DISPATCH(LightModeliv, (pname, params), (F, ";"));
+   DISPATCH(LightModeliv, (pname, params), (F, "glLightModeliv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LineWidth)(GLfloat width)
 {
-   DISPATCH(LineWidth, (width), (F, ";"));
+   DISPATCH(LineWidth, (width), (F, "glLineWidth(%g);", width));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LineStipple)(GLint factor, GLushort pattern)
 {
-   DISPATCH(LineStipple, (factor, pattern), (F, ";"));
+   DISPATCH(LineStipple, (factor, pattern), (F, "glLineStipple(%d, 0x%x);", factor, pattern));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ListBase)(GLuint base)
 {
-   DISPATCH(ListBase, (base), (F, ";"));
+   DISPATCH(ListBase, (base), (F, "glListbase(%d);", base));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadIdentity)(void)
 {
-   DISPATCH(LoadIdentity, (), (F, ";"));
+   DISPATCH(LoadIdentity, (), (F, "glLoadIdentity();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadMatrixd)(const GLdouble *m)
 {
-   DISPATCH(LoadMatrixd, (m), (F, ";"));
+   DISPATCH(LoadMatrixd, (m), (F, "glLoadMatirxd(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadMatrixf)(const GLfloat *m)
 {
-   DISPATCH(LoadMatrixf, (m), (F, ";"));
+   DISPATCH(LoadMatrixf, (m), (F, "glLoadMatrixf(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadName)(GLuint name)
 {
-   DISPATCH(LoadName, (name), (F, ";"));
+   DISPATCH(LoadName, (name), (F, "glLoadName(%u);", name));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LogicOp)(GLenum opcode)
 {
-   DISPATCH(LogicOp, (opcode), (F, ";"));
+   DISPATCH(LogicOp, (opcode), (F, "glLogicOp(0x%x);", opcode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Map1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
@@ -864,17 +873,17 @@
 
 KEYWORD1 void KEYWORD2 NAME(MatrixMode)(GLenum mode)
 {
-   DISPATCH(MatrixMode, (mode), (F, ";"));
+   DISPATCH(MatrixMode, (mode), (F, "glMatrixMode(0x%x);", mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultMatrixd)(const GLdouble *m)
 {
-   DISPATCH(MultMatrixd, (m), (F, ";"));
+   DISPATCH(MultMatrixd, (m), (F, "glMultMatrixd(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultMatrixf)(const GLfloat *m)
 {
-   DISPATCH(MultMatrixf, (m), (F, ";"));
+   DISPATCH(MultMatrixf, (m), (F, "glMultMatrixf(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(NewList)(GLuint list, GLenum mode)
@@ -889,7 +898,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Normal3bv)(const GLbyte *v)
 {
-   DISPATCH(Normal3bv, (v), (F, "glNormal3bv(%p);", v));
+   DISPATCH(Normal3bv, (v), (F, "glNormal3bv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz)
@@ -899,7 +908,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Normal3dv)(const GLdouble *v)
 {
-   DISPATCH(Normal3dv, (v), (F, "glNormal3dv(%p);", v));
+   DISPATCH(Normal3dv, (v), (F, "glNormal3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz)
@@ -909,7 +918,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Normal3fv)(const GLfloat *v)
 {
-   DISPATCH(Normal3fv, (v), (F, "glNormal3fv(%p);", v));
+   DISPATCH(Normal3fv, (v), (F, "glNormal3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3i)(GLint nx, GLint ny, GLint nz)
@@ -919,7 +928,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Normal3iv)(const GLint *v)
 {
-   DISPATCH(Normal3iv, (v), (F, "glNormal3iv(%p);", v));
+   DISPATCH(Normal3iv, (v), (F, "glNormal3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Normal3s)(GLshort nx, GLshort ny, GLshort nz)
@@ -929,7 +938,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Normal3sv)(const GLshort *v)
 {
-   DISPATCH(Normal3sv, (v), (F, "glNormal3sv(%p);", v));
+   DISPATCH(Normal3sv, (v), (F, "glNormal3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
@@ -959,42 +968,42 @@
 
 KEYWORD1 void KEYWORD2 NAME(PixelStoref)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PixelStoref, (pname, param), (F, ";"));
+   DISPATCH(PixelStoref, (pname, param), (F, "glPixelStoref(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelStorei)(GLenum pname, GLint param)
 {
-   DISPATCH(PixelStorei, (pname, param), (F, ";"));
+   DISPATCH(PixelStorei, (pname, param), (F, "glPixelStorei(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTransferf)(GLenum pname, GLfloat param)
 {
-   DISPATCH(PixelTransferf, (pname, param), (F, ";"));
+   DISPATCH(PixelTransferf, (pname, param), (F, "glPixelTransferf(0x%x, %f);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelTransferi)(GLenum pname, GLint param)
 {
-   DISPATCH(PixelTransferi, (pname, param), (F, ";"));
+   DISPATCH(PixelTransferi, (pname, param), (F, "glPixelTransferi(0x%x, %d);", pname, param));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PixelZoom)(GLfloat xfactor, GLfloat yfactor)
 {
-   DISPATCH(PixelZoom, (xfactor, yfactor), (F, ";"));
+   DISPATCH(PixelZoom, (xfactor, yfactor), (F, "glPixelZoom(%f, %f);", xfactor, yfactor));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PointSize)(GLfloat size)
 {
-   DISPATCH(PointSize, (size), (F, ";"));
+   DISPATCH(PointSize, (size), (F, "glPointSize(%f);", size));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PolygonMode)(GLenum face, GLenum mode)
 {
-   DISPATCH(PolygonMode, (face, mode), (F, ";"));
+   DISPATCH(PolygonMode, (face, mode), (F, "glPolygonMode(0x%x, 0x%x);", face, mode));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PolygonStipple)(const GLubyte *pattern)
 {
-   DISPATCH(PolygonStipple, (pattern), (F, ";"));
+   DISPATCH(PolygonStipple, (pattern), (F, "glPolygonStipple(%p);", pattern));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PopAttrib)(void)
@@ -1029,62 +1038,62 @@
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2d)(GLdouble x, GLdouble y)
 {
-   DISPATCH(RasterPos2d, (x, y), (F, ";"));
+   DISPATCH(RasterPos2d, (x, y), (F, "glRasterPos2d(%g, %g);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2f)(GLfloat x, GLfloat y)
 {
-   DISPATCH(RasterPos2f, (x, y), (F, ";"));
+   DISPATCH(RasterPos2f, (x, y), (F, "glRasterPos2f(%g, %g);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2i)(GLint x, GLint y)
 {
-   DISPATCH(RasterPos2i, (x, y), (F, ";"));
+   DISPATCH(RasterPos2i, (x, y), (F, "glRasterPos2i(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2s)(GLshort x, GLshort y)
 {
-   DISPATCH(RasterPos2s, (x, y), (F, ";"));
+   DISPATCH(RasterPos2s, (x, y), (F, "glRasterPos2s(%d, %d);", x, y));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3d)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(RasterPos3d, (x, y, z), (F, ";"));
+   DISPATCH(RasterPos3d, (x, y, z), (F, "glRasterPos3d(%g, %g, %g);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3f)(GLfloat x, GLfloat y, GLfloat z)
 {
-   DISPATCH(RasterPos3f, (x, y, z), (F, ";"));
+   DISPATCH(RasterPos3f, (x, y, z), (F, "glRasterPos3f(%g, %g, %g);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3i)(GLint x, GLint y, GLint z)
 {
-   DISPATCH(RasterPos3i, (x, y, z), (F, ";"));
+   DISPATCH(RasterPos3i, (x, y, z), (F, "glRasterPos3i(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos3s)(GLshort x, GLshort y, GLshort z)
 {
-   DISPATCH(RasterPos3s, (x, y, z), (F, ";"));
+   DISPATCH(RasterPos3s, (x, y, z), (F, "glRasterPos3s(%d, %d, %d);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-   DISPATCH(RasterPos4d, (x, y, z, w), (F, ";"));
+   DISPATCH(RasterPos4d, (x, y, z, w), (F, "glRasterPos4d(%g, %g, %g, %g);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-   DISPATCH(RasterPos4f, (x, y, z, w), (F, ";"));
+   DISPATCH(RasterPos4f, (x, y, z, w), (F, "glRasterPos4f(%g, %g, %g, %g);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4i)(GLint x, GLint y, GLint z, GLint w)
 {
-   DISPATCH(RasterPos4i, (x, y, z, w), (F, ";"));
+   DISPATCH(RasterPos4i, (x, y, z, w), (F, "glRasterPos4i(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-   DISPATCH(RasterPos4s, (x, y, z, w), (F, ";"));
+   DISPATCH(RasterPos4s, (x, y, z, w), (F, "glRasterPos4s(%d, %d, %d, %d);", x, y, z, w));
 }
 
 KEYWORD1 void KEYWORD2 NAME(RasterPos2dv)(const GLdouble *v)
@@ -1494,7 +1503,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Translated)(GLdouble x, GLdouble y, GLdouble z)
 {
-   DISPATCH(Translated, (x, y, z), (F, ";"));
+   DISPATCH(Translated, (x, y, z), (F, "glTranslated(%g, %g, %g);", x, y, z));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Translatef)(GLfloat x, GLfloat y, GLfloat z)
@@ -1509,7 +1518,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2dv)(const GLdouble *v)
 {
-   DISPATCH(Vertex2dv, (v), (F, "glVertex2dv(%p);", v));
+   DISPATCH(Vertex2dv, (v), (F, "glVertex2dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2f)(GLfloat x, GLfloat y)
@@ -1519,7 +1528,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2fv)(const GLfloat *v)
 {
-   DISPATCH(Vertex2fv, (v), (F, "glVertex2fv(%p);", v));
+   DISPATCH(Vertex2fv, (v), (F, "glVertex2fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2i)(GLint x, GLint y)
@@ -1529,7 +1538,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2iv)(const GLint *v)
 {
-   DISPATCH(Vertex2iv, (v), (F, "glVertex2iv(%p);", v));
+   DISPATCH(Vertex2iv, (v), (F, "glVertex2iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2s)(GLshort x, GLshort y)
@@ -1539,7 +1548,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex2sv)(const GLshort *v)
 {
-   DISPATCH(Vertex2sv, (v), (F, "glVertex2sv(%p);", v));
+   DISPATCH(Vertex2sv, (v), (F, "glVertex2sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3d)(GLdouble x, GLdouble y, GLdouble z)
@@ -1549,7 +1558,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3dv)(const GLdouble *v)
 {
-   DISPATCH(Vertex3dv, (v), (F, "glVertex3dv(%p);", v));
+   DISPATCH(Vertex3dv, (v), (F, "glVertex3dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3f)(GLfloat x, GLfloat y, GLfloat z)
@@ -1559,7 +1568,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3fv)(const GLfloat *v)
 {
-   DISPATCH(Vertex3fv, (v), (F, "glVertex3fv(%p);", v));
+   DISPATCH(Vertex3fv, (v), (F, "glVertex3fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3i)(GLint x, GLint y, GLint z)
@@ -1569,7 +1578,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3iv)(const GLint *v)
 {
-   DISPATCH(Vertex3iv, (v), (F, "glVertex3iv(%p);", v));
+   DISPATCH(Vertex3iv, (v), (F, "glVertex3iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3s)(GLshort x, GLshort y, GLshort z)
@@ -1579,7 +1588,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex3sv)(const GLshort *v)
 {
-   DISPATCH(Vertex3sv, (v), (F, "glVertex3sv(%p);", v));
+   DISPATCH(Vertex3sv, (v), (F, "glVertex3sv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
@@ -1589,7 +1598,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4dv)(const GLdouble *v)
 {
-   DISPATCH(Vertex4dv, (v), (F, "glVertex4dv(%p);", v));
+   DISPATCH(Vertex4dv, (v), (F, "glVertex4dv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
@@ -1599,7 +1608,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4fv)(const GLfloat *v)
 {
-   DISPATCH(Vertex4fv, (v), (F, "glVertex4fv(%p);", v));
+   DISPATCH(Vertex4fv, (v), (F, "glVertex4fv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4i)(GLint x, GLint y, GLint z, GLint w)
@@ -1609,7 +1618,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4iv)(const GLint *v)
 {
-   DISPATCH(Vertex4iv, (v), (F, "glVertex4iv(%p);", v));
+   DISPATCH(Vertex4iv, (v), (F, "glVertex4iv(%p);", (void *) v));
 }
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w)
@@ -1619,9 +1628,10 @@
 
 KEYWORD1 void KEYWORD2 NAME(Vertex4sv)(const GLshort *v)
 {
-   DISPATCH(Vertex4sv, (v), (F, "glVertex4sv(%p);", v));
+   DISPATCH(Vertex4sv, (v), (F, "glVertex4sv(%p);", (void *) v));
 }
 
+
 KEYWORD1 void KEYWORD2 NAME(Viewport)(GLint x, GLint y, GLsizei width, GLsizei height)
 {
    DISPATCH(Viewport, (x, y, width, height), (F, "glViewport(%d, %d, %d, %d);", x, y, width, height));
@@ -1629,12 +1639,11 @@
 
 
 
-
 /* GL 1.1 */
 
 KEYWORD1 GLboolean KEYWORD2 NAME(AreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-   RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResident(%d, %p, %p);", n, textures, residences));
+   RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResident(%d, %p, %p);", n, (void *) textures, (void *) residences));
 }
 
 KEYWORD1 void KEYWORD2 NAME(ArrayElement)(GLint i)
@@ -1674,7 +1683,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(DeleteTextures)(GLsizei n, const GLuint *textures)
 {
-   DISPATCH(DeleteTextures, (n, textures), (F, ";"));
+   DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTextures(%d, %p);", n, (void *) textures));
 }
 
 KEYWORD1 void KEYWORD2 NAME(DisableClientState)(GLenum cap)
@@ -1684,12 +1693,12 @@
 
 KEYWORD1 void KEYWORD2 NAME(DrawArrays)(GLenum mode, GLint first, GLsizei count)
 {
-   DISPATCH(DrawArrays, (mode, first, count), (F, ";"));
+   DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArrays(0x%x, %d, %d);", mode, first, count));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EdgeFlagPointer)(GLsizei stride, const GLvoid *ptr)
 {
-   DISPATCH(EdgeFlagPointer, (stride, ptr), (F, ";"));
+   DISPATCH(EdgeFlagPointer, (stride, ptr), (F, "glEdgeFlagPointer(%d, %p);", stride, (void *) ptr));
 }
 
 KEYWORD1 void KEYWORD2 NAME(EnableClientState)(GLenum cap)
@@ -1699,32 +1708,22 @@
 
 KEYWORD1 void KEYWORD2 NAME(GenTextures)(GLsizei n, GLuint *textures)
 {
-   DISPATCH(GenTextures, (n, textures), (F, ";"));
+   DISPATCH(GenTextures, (n, textures), (F, "glGenTextures(%d, %p);", n, (void *) textures));
 }
 
 KEYWORD1 void KEYWORD2 NAME(GetPointerv)(GLenum pname, GLvoid **params)
 {
-   DISPATCH(GetPointerv, (pname, params), (F, ";"));
+   DISPATCH(GetPointerv, (pname, params), (F, "glGetPointerv(0x%x, %p);", pname, (void *) params));
 }
 
 KEYWORD1 void KEYWORD2 NAME(IndexPointer)(GLenum type, GLsizei stride, const GLvoid *ptr)
 {
-   DISPATCH(IndexPointer, (type, stride, ptr), (F, ";"));
+   DISPATCH(IndexPointer, (type, stride, ptr), (F, "glIndexPointer(0x%x, %d, %p);", type, stride, ptr));
 }
 
-KEYWORD1 void KEYWORD2 NAME(Indexub)(GLubyte c)
-{
-   DISPATCH(Indexub, (c), (F, ";"));
-}
-
-KEYWORD1 void KEYWORD2 NAME(Indexubv)(const GLubyte *c)
-{
-   DISPATCH(Indexubv, (c), (F, ";"));
-}
-
 KEYWORD1 void KEYWORD2 NAME(InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-   DISPATCH(InterleavedArrays, (format, stride, pointer), (F, ";"));
+   DISPATCH(InterleavedArrays, (format, stride, pointer), (F, "glInterleavedArrays(0x%x, %d, %p);", format, stride, pointer));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(IsTexture)(GLuint texture)
@@ -1734,12 +1733,12 @@
 
 KEYWORD1 void KEYWORD2 NAME(NormalPointer)(GLenum type, GLsizei stride, const GLvoid *ptr)
 {
-   DISPATCH(NormalPointer, (type, stride, ptr), (F, ";"));
+   DISPATCH(NormalPointer, (type, stride, ptr), (F, "glNormalPointer(0x%x, %d, %p);", type, stride, (void *) ptr));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PolygonOffset)(GLfloat factor, GLfloat units)
 {
-   DISPATCH(PolygonOffset, (factor, units), (F, ";"));
+   DISPATCH(PolygonOffset, (factor, units), (F, "glPolygonOffset(%g, %g);", factor, units));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PopClientAttrib)(void)
@@ -1749,7 +1748,7 @@
 
 KEYWORD1 void KEYWORD2 NAME(PrioritizeTextures)(GLsizei n, const GLuint *textures, const GLclampf *priorities)
 {
-   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, ";"));
+   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTextures(%d, %p, %p);", n, (void *) textures, (void *) priorities));
 }
 
 KEYWORD1 void KEYWORD2 NAME(PushClientAttrib)(GLbitfield mask)
@@ -1778,8 +1777,6 @@
 }
 
 
-
-
 /* GL 1.2 */
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
@@ -1792,7 +1789,7 @@
    DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, ";"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+KEYWORD1 void KEYWORD2 NAME(TexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
    DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, ";"));
 }
@@ -1802,8 +1799,6 @@
    DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, ";"));
 }
 
-
-
 /* GL_ARB_imaging */
 
 KEYWORD1 void KEYWORD2 NAME(BlendColor)(GLclampf r, GLclampf g, GLclampf b, GLclampf a)
@@ -1976,29 +1971,22 @@
    DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, ";"));
 }
 
-
-
 /***
  *** Extension functions
  ***/
 
-
 /* 2. GL_EXT_blend_color */
 KEYWORD1 void KEYWORD2 NAME(BlendColorEXT)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
    DISPATCH(BlendColor, (red, green, blue, alpha), (F, ";"));
 }
 
-
-
 /* 3. GL_EXT_polygon_offset */
 KEYWORD1 void KEYWORD2 NAME(PolygonOffsetEXT)(GLfloat factor, GLfloat bias)
 {
    DISPATCH(PolygonOffsetEXT, (factor, bias), (F, ";"));
 }
 
-
-
 /* 6. GL_EXT_texture3D */
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
@@ -2016,8 +2004,6 @@
    DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, ";"));
 }
 
-
-
 /* 7. GL_SGI_texture_filter4 */
 
 KEYWORD1 void KEYWORD2 NAME(GetTexFilterFuncSGIS)(GLenum target, GLenum filter, GLfloat *weights)
@@ -2030,8 +2016,6 @@
    DISPATCH(TexFilterFuncSGIS, (target, filter, n, weights), (F, ";"));
 }
 
-
-
 /* 9. GL_EXT_subtexture */
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
@@ -2049,7 +2033,6 @@
    DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, ";"));
 }
 
-
 /* 10. GL_EXT_copy_texture */
 
 KEYWORD1 void KEYWORD2 NAME(CopyTexImage1DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
@@ -2062,14 +2045,11 @@
    DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, ";"));
 }
 
-
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
    DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, ";"));
 }
 
-
-
 /* 11. GL_EXT_histogram */
 KEYWORD1 void KEYWORD2 NAME(GetHistogramEXT)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
@@ -2121,8 +2101,6 @@
    DISPATCH(ResetMinmax, (target), (F, ";"));
 }
 
-
-
 /* 12. GL_EXT_convolution */
 
 KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
@@ -2190,8 +2168,6 @@
    DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, ";"));
 }
 
-
-
 /* 14. GL_SGI_color_table */
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableParameterfvSGI)(GLenum target, GLenum pname, const GLfloat *params)
@@ -2228,8 +2204,6 @@
    DISPATCH(GetColorTableParameterivSGI, (target, pname, params), (F, ";"));
 }
 
-
-
 /* ??. GL_SGIX_pixel_texture */
 
 KEYWORD1 void KEYWORD2 NAME(PixelTexGenSGIX)(GLenum mode)
@@ -2237,7 +2211,6 @@
    DISPATCH(PixelTexGenSGIX, (mode), (F, ";"));
 }
 
-
 /* 15. GL_SGIS_pixel_texture */
 
 KEYWORD1 void KEYWORD2 NAME(PixelTexGenParameterfSGIS)(GLenum target, GLfloat value)
@@ -2270,8 +2243,6 @@
    DISPATCH(GetPixelTexGenParameterivSGIS, (target, value), (F, ";"));
 }
 
-
-
 /* 16. GL_SGIS_texture4D */
 
 KEYWORD1 void KEYWORD2 NAME(TexImage4DSGIS)(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void *pixels)
@@ -2284,8 +2255,6 @@
    DISPATCH(TexSubImage4DSGIS, (target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, extent, format, type, pixels), (F, ";"));
 }
 
-
-
 /* 20. GL_EXT_texture_object */
 
 KEYWORD1 void KEYWORD2 NAME(GenTexturesEXT)(GLsizei n, GLuint *textures)
@@ -2310,7 +2279,7 @@
 
 KEYWORD1 GLboolean KEYWORD2 NAME(AreTexturesResidentEXT)(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-   RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResidentEXT(%d %p %p);", n, textures, residences));
+   RETURN_DISPATCH(AreTexturesResident, (n, textures, residences), (F, "glAreTexturesResidentEXT(%d %p %p);", n, (void *) textures, (void *) residences));
 }
 
 KEYWORD1 GLboolean KEYWORD2 NAME(IsTextureEXT)(GLuint texture)
@@ -2318,8 +2287,6 @@
    RETURN_DISPATCH(IsTexture, (texture), (F, "glIsTextureEXT(%u);", texture));
 }
 
-
-
 /* 21. GL_SGIS_detail_texture */
 
 KEYWORD1 void KEYWORD2 NAME(DetailTexFuncSGIS)(GLenum target, GLsizei n, const GLfloat *points)
@@ -2332,7 +2299,6 @@
    DISPATCH(GetDetailTexFuncSGIS, (target, points), (F, ";"));
 }
 
-
 /* 22. GL_SGIS_sharpen_texture */
 
 KEYWORD1 void KEYWORD2 NAME(GetSharpenTexFuncSGIS)(GLenum target, GLfloat *points)
@@ -2345,7 +2311,6 @@
    DISPATCH(SharpenTexFuncSGIS, (target, n, points), (F, ";"));
 }
 
-
 /* 25. GL_SGIS_multisample */
 
 KEYWORD1 void KEYWORD2 NAME(SampleMaskSGIS)(GLclampf value, GLboolean invert)
@@ -2358,7 +2323,6 @@
    DISPATCH(SamplePatternSGIS, (pattern), (F, ";"));
 }
 
-
 /* 30. GL_EXT_vertex_array */
 
 KEYWORD1 void KEYWORD2 NAME(VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr)
@@ -2396,24 +2360,17 @@
    DISPATCH(GetPointerv, (pname, params), (F, ";"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(ArrayElementEXT)(GLint i)
-{
-   DISPATCH(ArrayElement, (i), (F, ";"));
-}
-
 KEYWORD1 void KEYWORD2 NAME(DrawArraysEXT)(GLenum mode, GLint first, GLsizei count)
 {
    DISPATCH(DrawArrays, (mode, first, count), (F, ";"));
 }
 
-
 /* 37. GL_EXT_blend_minmax */
 KEYWORD1 void KEYWORD2 NAME(BlendEquationEXT)(GLenum mode)
 {
    DISPATCH(BlendEquation, (mode), (F, "glBlendEquationEXT(0x%x);", mode));
 }
 
-
 /* 52. GL_SGIX_sprite */
 
 KEYWORD1 void KEYWORD2 NAME(SpriteParameterfSGIX)(GLenum pname, GLfloat param)
@@ -2436,8 +2393,6 @@
    DISPATCH(SpriteParameterivSGIX, (pname, param), (F, ";"));
 }
 
-
-
 /* 54. GL_EXT_point_parameters */
 
 KEYWORD1 void KEYWORD2 NAME(PointParameterfEXT)(GLenum target, GLfloat param)
@@ -2460,8 +2415,6 @@
    DISPATCH(PointParameterfvEXT, (target, param), (F, ";"));
 }
 
-
-
 /* 55. GL_SGIX_instruments */
 KEYWORD1 GLint KEYWORD2 NAME(GetInstrumentsSGIX)(void)
 {
@@ -2493,39 +2446,32 @@
    DISPATCH(StopInstrumentsSGIX, (marker), (F, ";"));
 }
 
-
-
 /* 57. GL_SGIX_framezoom */
 KEYWORD1 void KEYWORD2 NAME(FrameZoomSGIX)(GLint factor)
 {
    DISPATCH(FrameZoomSGIX, (factor), (F, ";"));
 }
 
-
 /* 58. GL_SGIX_tag_sample_buffer */
 KEYWORD1 void KEYWORD2 NAME(TagSampleBufferSGIX)(void)
 {
    DISPATCH(TagSampleBufferSGIX, (), (F, ";"));
 }
 
-
 /* 60. GL_SGIX_reference_plane */
 KEYWORD1 void KEYWORD2 NAME(ReferencePlaneSGIX)(const GLdouble *plane)
 {
    DISPATCH(ReferencePlaneSGIX, (plane), (F, ";"));
 }
 
-
 /* 61. GL_SGIX_flush_raster */
 KEYWORD1 void KEYWORD2 NAME(FlushRasterSGIX)(void)
 {
    DISPATCH(FlushRasterSGIX, (), (F, ";"));
 }
 
-
-
 /* 66. GL_HP_image_transform */
-#if 0
+#if 00
 KEYWORD1 void KEYWORD2 NAME(GetImageTransformParameterfvHP)(GLenum target, GLenum pname, GLfloat *param)
 {
    DISPATCH(GetImageTransformParameterfvHP, (target, pname, param), (F, ";"));
@@ -2557,8 +2503,6 @@
 }
 #endif
 
-
-
 /* 74. GL_EXT_color_subtable */
 KEYWORD1 void KEYWORD2 NAME(ColorSubTableEXT)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
 {
@@ -2570,14 +2514,12 @@
    DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, ";"));
 }
 
-
 /* 77. GL_PGI_misc_hints */
 KEYWORD1 void KEYWORD2 NAME(HintPGI)(GLenum target, GLint mode)
 {
    DISPATCH(HintPGI, (target, mode), (F, ";"));
 }
 
-
 /* 78. GL_EXT_paletted_texture */
 
 KEYWORD1 void KEYWORD2 NAME(ColorTableEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
@@ -2600,8 +2542,6 @@
    DISPATCH(GetColorTableParameterivEXT, (target, pname, params), (F, ";"));
 }
 
-
-
 /* 80. GL_SGIX_list_priority */
 
 KEYWORD1 void KEYWORD2 NAME(GetListParameterfvSGIX)(GLuint list, GLenum name, GLfloat *param)
@@ -2634,23 +2574,18 @@
    DISPATCH(ListParameterivSGIX, (list, name, param), (F, ";"));
 }
 
-
-
 /* 94. GL_EXT_index_material */
 KEYWORD1 void KEYWORD2 NAME(IndexMaterialEXT)(GLenum face, GLenum mode)
 {
    DISPATCH(IndexMaterialEXT, (face, mode), (F, ";"));
 }
 
-
 /* 95. GL_EXT_index_func */
 KEYWORD1 void KEYWORD2 NAME(IndexFuncEXT)(GLenum func, GLfloat ref)
 {
    DISPATCH(IndexFuncEXT, (func, ref), (F, ";"));
 }
 
-
-
 /* 97. GL_EXT_compiled_vertex_array */
 KEYWORD1 void KEYWORD2 NAME(LockArraysEXT)(GLint first, GLsizei count)
 {
@@ -2662,7 +2597,6 @@
    DISPATCH(UnlockArraysEXT, (), (F, ";"));
 }
 
-
 /* 98. GL_EXT_cull_vertex */
 KEYWORD1 void KEYWORD2 NAME(CullParameterfvEXT)(GLenum pname, GLfloat *params)
 {
@@ -2674,8 +2608,6 @@
    DISPATCH(CullParameterdvEXT, (pname, params), (F, ";"));
 }
 
-
-
 /* 102. GL_SGIX_fragment_lighting */
 KEYWORD1 void KEYWORD2 NAME(FragmentColorMaterialSGIX)(GLenum face, GLenum mode)
 {
@@ -2767,14 +2699,12 @@
    DISPATCH(LightEnviSGIX, (pname, param), (F, ";"));
 }
 
-
 /* 112. GL_EXT_draw_range_elements */
 KEYWORD1 void KEYWORD2 NAME(DrawRangeElementsEXT)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElementsEXT(0x%x, %u %u %d 0x%x %p);", mode, start, end, count, type, indices));
+   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElementsEXT(0x%x, %u %u %d 0x%x %p);", mode, start, end, count, type, (void *) indices));
 }
 
-
 /* 117. GL_EXT_light_texture */
 #if 00
 KEYWORD1 void KEYWORD2 NAME(ApplyTextureEXT)(GLenum mode)
@@ -2793,8 +2723,6 @@
 }
 #endif
 
-
-
 /* 135. GL_INTEL_texture_scissor */
 #if 00
 KEYWORD1 void KEYWORD2 NAME(TexScissorINTEL)(GLenum target, GLclampf tlow, GLclampf thigh)
@@ -2808,8 +2736,6 @@
 }
 #endif
 
-
-
 /* 136. GL_INTEL_parallel_arrays */
 #if 00
 KEYWORD1 void KEYWORD2 NAME(VertexPointervINTEL)(GLint size, GLenum type, const void ** pointer)
@@ -2833,9 +2759,8 @@
 }
 #endif
 
-
 /* 138. GL_EXT_pixel_transform */
-#if 0
+#if 00
 KEYWORD1 void KEYWORD2 NAME(PixelTransformParameteriEXT)(GLenum target, GLenum pname, const GLint param)
 {
    DISPATCH(PixelTransformParameteriEXT, (target, pname, param), (F, "glPixelTransformParameteriEXT(0x%x, 0x%x, %d);", target, pname, param));
@@ -2867,22 +2792,103 @@
 }
 #endif
 
+/* 145. GL_EXT_secondary_color */
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue)
+{
+   DISPATCH(SecondaryColor3bEXT, (red, green, blue), (F, "glSecondaryColor3bEXT(%d, %d, %d);", red, green, blue));
+}
 
-/* 145. GL_EXT_secondary_color */
-/* XXX todo */
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bvEXT)(const GLbyte *v)
+{
+   DISPATCH(SecondaryColor3bvEXT, (v), (F, "glSecondaryColor3bvEXT(%d, %d, %d);", v[0], v[1], v[2]));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue)
+{
+   DISPATCH(SecondaryColor3dEXT, (red, green, blue), (F, "glSecondaryColor3dEXT(%g, %g, %g);", red, green, blue));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dvEXT)(const GLdouble * v)
+{
+   DISPATCH(SecondaryColor3dvEXT, (v), (F, "glSecondaryColor3dvEXT(%g, %g, %g);", v[0], v[1], v[2]));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue)
+{
+   DISPATCH(SecondaryColor3fEXT, (red, green, blue), (F, "glSecondaryColor3fEXT(%g, %g, %g);", red, green, blue));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fvEXT)(const GLfloat * v)
+{
+   DISPATCH(SecondaryColor3fvEXT, (v), (F, "glSecondaryColor3fvEXT(%g, %g, %g);", v[0], v[1], v[2]));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3iEXT)(GLint red, GLint green, GLint blue)
+{
+   DISPATCH(SecondaryColor3iEXT, (red, green, blue), (F, "glSecondaryColor3iEXT(%d, %d, %d);", red, green, blue));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ivEXT)(const GLint * v)
+{
+   DISPATCH(SecondaryColor3ivEXT, (v), (F, "glSecondaryColor3ivEXT(%d, %d, %d);", v[0], v[1], v[2]));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue)
+{
+   DISPATCH(SecondaryColor3sEXT, (red, green, blue), (F, "glSecondaryColor3sEXT(%d, %d, %d);", red, green, blue));
+}
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3svEXT)(const GLshort * v)
+{
+   DISPATCH(SecondaryColor3svEXT, (v), (F, "glSecondaryColor3svEXT(%d, %d, %d);", v[0], v[1], v[2]));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue)
+{
+   DISPATCH(SecondaryColor3ubEXT, (red, green, blue), (F, "glSecondaryColor3ubEXT(%d, %d, %d);", red, green, blue));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubvEXT)(const GLubyte * v)
+{
+   DISPATCH(SecondaryColor3ubvEXT, (v), (F, "glSecondaryColor3ubvEXT(%d, %d, %d);", v[0], v[1], v[2]));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue)
+{
+   DISPATCH(SecondaryColor3uiEXT, (red, green, blue), (F, "glSecondaryColor3uiEXT(%d, %d, %d);", red, green, blue));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uivEXT)(const GLuint * v)
+{
+   DISPATCH(SecondaryColor3uivEXT, (v), (F, "glSecondaryColor3uivEXT(%d, %d, %d);", v[0], v[1], v[2]));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue)
+{
+   DISPATCH(SecondaryColor3usEXT, (red, green, blue), (F, "glSecondaryColor3usEXT(%d, %d, %d);", red, green, blue));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usvEXT)(const GLushort * v)
+{
+   DISPATCH(SecondaryColor3usvEXT, (v), (F, "glSecondaryColor3usvEXT(%d, %d, %d);", v[0], v[1], v[2]));
+}
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
+{
+   DISPATCH(SecondaryColorPointerEXT, (size, type, stride, pointer), (F, "glSecondaryColorPointerEXT(%d, 0x%x, %d, %p);", size, type, stride, pointer));
+}
 
 /* 149. GL_EXT_fog_coord */
+
 KEYWORD1 void KEYWORD2 NAME(FogCoordfEXT)(GLfloat coord)
 {
    DISPATCH(FogCoordfEXT, (coord), (F, "glFogCoordfEXT(%g);", coord));
 }
 
-KEYWORD1 void KEYWORD2 NAME(FogCoordfvEXT)(const GLfloat * coord)
+KEYWORD1 void KEYWORD2 NAME(FogCoordfvEXT)(const GLfloat *coord)
 {
-   DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);", coord));
+   DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);", (void *) coord));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FogCoorddEXT)(GLdouble coord)
@@ -2892,16 +2898,14 @@
 
 KEYWORD1 void KEYWORD2 NAME(FogCoorddvEXT)(const GLdouble * coord)
 {
-   DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddvEXT(%p);", coord));
+   DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddvEXT(%p);", (void *) coord));
 }
 
 KEYWORD1 void KEYWORD2 NAME(FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer)
 {
-   DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointerEXT(0x%x, %d, %p);", type, stride, pointer));
+   DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointerEXT(0x%x, %d, %p);", type, stride, (void *) pointer));
 }
 
-
-
 /* 173. GL_EXT/INGR_blend_func_separate */
 KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
@@ -2913,7 +2917,6 @@
    DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, ";"));
 }
 
-
 /* 190. GL_NV_vertex_array_range */
 KEYWORD1 void KEYWORD2 NAME(FlushVertexArrayRangeNV)(void)
 {
@@ -2925,7 +2928,6 @@
    DISPATCH(VertexArrayRangeNV, (size, pointer), (F, ";"));
 }
 
-
 /* 191. GL_NV_register_combiners */
 KEYWORD1 void KEYWORD2 NAME(CombinerParameterfvNV)(GLenum pname, const GLfloat * params)
 {
@@ -2992,8 +2994,6 @@
 DISPATCH(GetFinalCombinerInputParameterivNV, (variable, pname, params), (F, ";"));
 }
 
-
-
 /* 194. GL_EXT_vertex_weighting */
 KEYWORD1 void KEYWORD2 NAME(VertexWeightfEXT)(GLfloat weight)
 {
@@ -3010,16 +3010,12 @@
    DISPATCH(VertexWeightPointerEXT, (size, type, stride, pointer), (F, ";"));
 }
 
-
-
 /* 196. GL_MESA_resize_buffers */
 KEYWORD1 void KEYWORD2 NAME(ResizeBuffersMESA)(void)
 {
    DISPATCH(ResizeBuffersMESA, (), (F, "glResizeBuffersMESA();"));
 }
 
-
-
 /* 197. GL_MESA_window_pos */
 KEYWORD1 void KEYWORD2 NAME(WindowPos2iMESA)(GLint x, GLint y)
 {
@@ -3141,14 +3137,12 @@
    DISPATCH(WindowPos4dvMESA, (p), (F, ";"));
 }
 
-
 /* 208. GL_3DFX_tbuffer */
 KEYWORD1 void KEYWORD2 NAME(TbufferMask3DFX)(GLuint mask)
 {
    DISPATCH(TbufferMask3DFX, (mask), (F, "glTbufferMask3DFX(0x%x);", mask));
 }
 
-
 /* 209. WGL_EXT_multisample */
 
 KEYWORD1 void KEYWORD2 NAME(SampleMaskEXT)(GLclampf value, GLboolean invert)
@@ -3161,7 +3155,6 @@
    DISPATCH(SamplePatternSGIS, (pattern), (F, ";"));
 }
 
-
 /* ARB 1. GL_ARB_multitexture */
 
 KEYWORD1 void KEYWORD2 NAME(ActiveTextureARB)(GLenum texture)
@@ -3335,57 +3328,64 @@
 }
 
 
-
 /* ARB 3. GL_ARB_transpose_matrix */
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixdARB)(const GLdouble m[16])
 {
-   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixARB(%p);", m));
+   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixARB(%p);", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixfARB)(const GLfloat m[16])
 {
-   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p)", m));
+   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p)", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixdARB)(const GLdouble m[16])
 {
-   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixfARB(%p)", m));
+   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixfARB(%p)", (void *) m));
 }
 
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixfARB)(const GLfloat m[16])
 {
-   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p)", m));
+   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p)", (void *) m));
 }
 
-
-
 /* ARB 5. GL_ARB_multisample */
 KEYWORD1 void KEYWORD2 NAME(SampleCoverageARB)(GLclampf value, GLboolean invert)
 {
    DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverageARB(%f, %d);", value, invert));
 }
 
+/*
 KEYWORD1 void KEYWORD2 NAME(SamplePassARB)(GLenum pass)
 {
    DISPATCH(SamplePassARB, (pass), (F, "glSamplePassARB(0x%x);", pass));
 }
+*/
 
+/* ARB 12. GL_ARB_texture_compression */
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
+{
+   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1DARB();"));
+}
 
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
+{
+   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2DARB();"));
+}
 
-/* ARB 12. GL_ARB_texture_compression */
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
    DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3DARB();"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2DARB();"));
+   DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1DARB();"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1DARB();"));
+   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2DARB();"));
 }
 
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
@@ -3393,21 +3393,1218 @@
    DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3DARB();"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
+KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImageARB)(GLenum target, GLint lod, GLvoid *img)
 {
-   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2DARB();"));
+   DISPATCH(GetCompressedTexImageARB, (target, lod, img), (F, "glGetCompressedTexImageARB();"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
+
+/* GL 1.3 */
+
+KEYWORD1 void KEYWORD2 NAME(ActiveTexture)(GLenum texture)
+{
+   DISPATCH(ActiveTextureARB, (texture), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ClientActiveTexture)(GLenum texture)
+{
+   DISPATCH(ClientActiveTextureARB, (texture), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
+{
+   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1DARB();"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
+{
+   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2DARB();"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
+   DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3DARB();"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
+{
    DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1DARB();"));
 }
 
-KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImageARB)(GLenum target, GLint lod, GLvoid *img)
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
+   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2DARB();"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
+{
+   DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3DARB();"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImage)(GLenum target, GLint lod, GLvoid *img)
+{
    DISPATCH(GetCompressedTexImageARB, (target, lod, img), (F, "glGetCompressedTexImageARB();"));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1d)(GLenum target, GLdouble s)
+{
+   DISPATCH(MultiTexCoord1dARB, (target, s), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dv)(GLenum target, const GLdouble *v)
+{
+   DISPATCH(MultiTexCoord1dvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1f)(GLenum target, GLfloat s)
+{
+   DISPATCH(MultiTexCoord1fARB, (target, s), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fv)(GLenum target, const GLfloat *v)
+{
+   DISPATCH(MultiTexCoord1fvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1i)(GLenum target, GLint s)
+{
+   DISPATCH(MultiTexCoord1iARB, (target, s), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1iv)(GLenum target, const GLint *v)
+{
+   DISPATCH(MultiTexCoord1ivARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1s)(GLenum target, GLshort s)
+{
+   DISPATCH(MultiTexCoord1sARB, (target, s), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1sv)(GLenum target, const GLshort *v)
+{
+   DISPATCH(MultiTexCoord1svARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t)
+{
+   DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dv)(GLenum target, const GLdouble *v)
+{
+   DISPATCH(MultiTexCoord2dvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2f)(GLenum target, GLfloat s, GLfloat t)
+{
+   DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fv)(GLenum target, const GLfloat *v)
+{
+   DISPATCH(MultiTexCoord2fvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2i)(GLenum target, GLint s, GLint t)
+{
+   DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2iv)(GLenum target, const GLint *v)
+{
+   DISPATCH(MultiTexCoord2ivARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2s)(GLenum target, GLshort s, GLshort t)
+{
+   DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2sv)(GLenum target, const GLshort *v)
+{
+   DISPATCH(MultiTexCoord2svARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r)
+{
+   DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dv)(GLenum target, const GLdouble *v)
+{
+   DISPATCH(MultiTexCoord3dvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3f)(GLenum target, GLfloat s, GLfloat t, GLfloat r)
+{
+   DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fv)(GLenum target, const GLfloat *v)
+{
+   DISPATCH(MultiTexCoord3fvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r)
+{
+   DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3iv)(GLenum target, const GLint *v)
+{
+   DISPATCH(MultiTexCoord3ivARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r)
+{
+   DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3sv)(GLenum target, const GLshort *v)
+{
+   DISPATCH(MultiTexCoord3svARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+   DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dv)(GLenum target, const GLdouble *v)
+{
+   DISPATCH(MultiTexCoord4dvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+   DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fv)(GLenum target, const GLfloat *v)
+{
+   DISPATCH(MultiTexCoord4fvARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q)
+{
+   DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4iv)(GLenum target, const GLint *v)
+{
+   DISPATCH(MultiTexCoord4ivARB, (target, v), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
+{
+   DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, ";"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4sv)(GLenum target, const GLshort *v)
+{
+   DISPATCH(MultiTexCoord4svARB, (target, v), (F, ";"));
+}
+
+
+KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixd)(const GLdouble m[16])
+{
+   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixARB(%p);", (void *) m));
+}
+
+KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixf)(const GLfloat m[16])
+{
+   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p)", (void *) m));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixd)(const GLdouble m[16])
+{
+   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixfARB(%p)", (void *) m));
+}
+
+KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixf)(const GLfloat m[16])
+{
+   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p)", (void *) m));
+}
+
+KEYWORD1 void KEYWORD2 NAME(SampleCoverage)(GLclampf value, GLboolean invert)
+{
+   DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverageARB(%f, %d);", value, invert));
+}
+
+/*
+KEYWORD1 void KEYWORD2 NAME(SamplePass)(GLenum pass)
+{
+   DISPATCH(SamplePassARB, (pass), (F, "glSamplePassARB(0x%x);", pass));
+}
+*/
+
+
+
+
+#ifdef DISPATCH_TABLE_NAME
+
+#ifndef TABLE_ENTRY
+#error TABLE_ENTRY must be defined
+#endif
+
+void *DISPATCH_TABLE_NAME[] = {
+   TABLE_ENTRY(NewList),
+   TABLE_ENTRY(EndList),
+   TABLE_ENTRY(CallList),
+   TABLE_ENTRY(CallLists),
+   TABLE_ENTRY(DeleteLists),
+   TABLE_ENTRY(GenLists),
+   TABLE_ENTRY(ListBase),
+   TABLE_ENTRY(Begin),
+   TABLE_ENTRY(Bitmap),
+   TABLE_ENTRY(Color3b),
+   TABLE_ENTRY(Color3bv),
+   TABLE_ENTRY(Color3d),
+   TABLE_ENTRY(Color3dv),
+   TABLE_ENTRY(Color3f),
+   TABLE_ENTRY(Color3fv),
+   TABLE_ENTRY(Color3i),
+   TABLE_ENTRY(Color3iv),
+   TABLE_ENTRY(Color3s),
+   TABLE_ENTRY(Color3sv),
+   TABLE_ENTRY(Color3ub),
+   TABLE_ENTRY(Color3ubv),
+   TABLE_ENTRY(Color3ui),
+   TABLE_ENTRY(Color3uiv),
+   TABLE_ENTRY(Color3us),
+   TABLE_ENTRY(Color3usv),
+   TABLE_ENTRY(Color4b),
+   TABLE_ENTRY(Color4bv),
+   TABLE_ENTRY(Color4d),
+   TABLE_ENTRY(Color4dv),
+   TABLE_ENTRY(Color4f),
+   TABLE_ENTRY(Color4fv),
+   TABLE_ENTRY(Color4i),
+   TABLE_ENTRY(Color4iv),
+   TABLE_ENTRY(Color4s),
+   TABLE_ENTRY(Color4sv),
+   TABLE_ENTRY(Color4ub),
+   TABLE_ENTRY(Color4ubv),
+   TABLE_ENTRY(Color4ui),
+   TABLE_ENTRY(Color4uiv),
+   TABLE_ENTRY(Color4us),
+   TABLE_ENTRY(Color4usv),
+   TABLE_ENTRY(EdgeFlag),
+   TABLE_ENTRY(EdgeFlagv),
+   TABLE_ENTRY(End),
+   TABLE_ENTRY(Indexd),
+   TABLE_ENTRY(Indexdv),
+   TABLE_ENTRY(Indexf),
+   TABLE_ENTRY(Indexfv),
+   TABLE_ENTRY(Indexi),
+   TABLE_ENTRY(Indexiv),
+   TABLE_ENTRY(Indexs),
+   TABLE_ENTRY(Indexsv),
+   TABLE_ENTRY(Normal3b),
+   TABLE_ENTRY(Normal3bv),
+   TABLE_ENTRY(Normal3d),
+   TABLE_ENTRY(Normal3dv),
+   TABLE_ENTRY(Normal3f),
+   TABLE_ENTRY(Normal3fv),
+   TABLE_ENTRY(Normal3i),
+   TABLE_ENTRY(Normal3iv),
+   TABLE_ENTRY(Normal3s),
+   TABLE_ENTRY(Normal3sv),
+   TABLE_ENTRY(RasterPos2d),
+   TABLE_ENTRY(RasterPos2dv),
+   TABLE_ENTRY(RasterPos2f),
+   TABLE_ENTRY(RasterPos2fv),
+   TABLE_ENTRY(RasterPos2i),
+   TABLE_ENTRY(RasterPos2iv),
+   TABLE_ENTRY(RasterPos2s),
+   TABLE_ENTRY(RasterPos2sv),
+   TABLE_ENTRY(RasterPos3d),
+   TABLE_ENTRY(RasterPos3dv),
+   TABLE_ENTRY(RasterPos3f),
+   TABLE_ENTRY(RasterPos3fv),
+   TABLE_ENTRY(RasterPos3i),
+   TABLE_ENTRY(RasterPos3iv),
+   TABLE_ENTRY(RasterPos3s),
+   TABLE_ENTRY(RasterPos3sv),
+   TABLE_ENTRY(RasterPos4d),
+   TABLE_ENTRY(RasterPos4dv),
+   TABLE_ENTRY(RasterPos4f),
+   TABLE_ENTRY(RasterPos4fv),
+   TABLE_ENTRY(RasterPos4i),
+   TABLE_ENTRY(RasterPos4iv),
+   TABLE_ENTRY(RasterPos4s),
+   TABLE_ENTRY(RasterPos4sv),
+   TABLE_ENTRY(Rectd),
+   TABLE_ENTRY(Rectdv),
+   TABLE_ENTRY(Rectf),
+   TABLE_ENTRY(Rectfv),
+   TABLE_ENTRY(Recti),
+   TABLE_ENTRY(Rectiv),
+   TABLE_ENTRY(Rects),
+   TABLE_ENTRY(Rectsv),
+   TABLE_ENTRY(TexCoord1d),
+   TABLE_ENTRY(TexCoord1dv),
+   TABLE_ENTRY(TexCoord1f),
+   TABLE_ENTRY(TexCoord1fv),
+   TABLE_ENTRY(TexCoord1i),
+   TABLE_ENTRY(TexCoord1iv),
+   TABLE_ENTRY(TexCoord1s),
+   TABLE_ENTRY(TexCoord1sv),
+   TABLE_ENTRY(TexCoord2d),
+   TABLE_ENTRY(TexCoord2dv),
+   TABLE_ENTRY(TexCoord2f),
+   TABLE_ENTRY(TexCoord2fv),
+   TABLE_ENTRY(TexCoord2i),
+   TABLE_ENTRY(TexCoord2iv),
+   TABLE_ENTRY(TexCoord2s),
+   TABLE_ENTRY(TexCoord2sv),
+   TABLE_ENTRY(TexCoord3d),
+   TABLE_ENTRY(TexCoord3dv),
+   TABLE_ENTRY(TexCoord3f),
+   TABLE_ENTRY(TexCoord3fv),
+   TABLE_ENTRY(TexCoord3i),
+   TABLE_ENTRY(TexCoord3iv),
+   TABLE_ENTRY(TexCoord3s),
+   TABLE_ENTRY(TexCoord3sv),
+   TABLE_ENTRY(TexCoord4d),
+   TABLE_ENTRY(TexCoord4dv),
+   TABLE_ENTRY(TexCoord4f),
+   TABLE_ENTRY(TexCoord4fv),
+   TABLE_ENTRY(TexCoord4i),
+   TABLE_ENTRY(TexCoord4iv),
+   TABLE_ENTRY(TexCoord4s),
+   TABLE_ENTRY(TexCoord4sv),
+   TABLE_ENTRY(Vertex2d),
+   TABLE_ENTRY(Vertex2dv),
+   TABLE_ENTRY(Vertex2f),
+   TABLE_ENTRY(Vertex2fv),
+   TABLE_ENTRY(Vertex2i),
+   TABLE_ENTRY(Vertex2iv),
+   TABLE_ENTRY(Vertex2s),
+   TABLE_ENTRY(Vertex2sv),
+   TABLE_ENTRY(Vertex3d),
+   TABLE_ENTRY(Vertex3dv),
+   TABLE_ENTRY(Vertex3f),
+   TABLE_ENTRY(Vertex3fv),
+   TABLE_ENTRY(Vertex3i),
+   TABLE_ENTRY(Vertex3iv),
+   TABLE_ENTRY(Vertex3s),
+   TABLE_ENTRY(Vertex3sv),
+   TABLE_ENTRY(Vertex4d),
+   TABLE_ENTRY(Vertex4dv),
+   TABLE_ENTRY(Vertex4f),
+   TABLE_ENTRY(Vertex4fv),
+   TABLE_ENTRY(Vertex4i),
+   TABLE_ENTRY(Vertex4iv),
+   TABLE_ENTRY(Vertex4s),
+   TABLE_ENTRY(Vertex4sv),
+   TABLE_ENTRY(ClipPlane),
+   TABLE_ENTRY(ColorMaterial),
+   TABLE_ENTRY(CullFace),
+   TABLE_ENTRY(Fogf),
+   TABLE_ENTRY(Fogfv),
+   TABLE_ENTRY(Fogi),
+   TABLE_ENTRY(Fogiv),
+   TABLE_ENTRY(FrontFace),
+   TABLE_ENTRY(Hint),
+   TABLE_ENTRY(Lightf),
+   TABLE_ENTRY(Lightfv),
+   TABLE_ENTRY(Lighti),
+   TABLE_ENTRY(Lightiv),
+   TABLE_ENTRY(LightModelf),
+   TABLE_ENTRY(LightModelfv),
+   TABLE_ENTRY(LightModeli),
+   TABLE_ENTRY(LightModeliv),
+   TABLE_ENTRY(LineStipple),
+   TABLE_ENTRY(LineWidth),
+   TABLE_ENTRY(Materialf),
+   TABLE_ENTRY(Materialfv),
+   TABLE_ENTRY(Materiali),
+   TABLE_ENTRY(Materialiv),
+   TABLE_ENTRY(PointSize),
+   TABLE_ENTRY(PolygonMode),
+   TABLE_ENTRY(PolygonStipple),
+   TABLE_ENTRY(Scissor),
+   TABLE_ENTRY(ShadeModel),
+   TABLE_ENTRY(TexParameterf),
+   TABLE_ENTRY(TexParameterfv),
+   TABLE_ENTRY(TexParameteri),
+   TABLE_ENTRY(TexParameteriv),
+   TABLE_ENTRY(TexImage1D),
+   TABLE_ENTRY(TexImage2D),
+   TABLE_ENTRY(TexEnvf),
+   TABLE_ENTRY(TexEnvfv),
+   TABLE_ENTRY(TexEnvi),
+   TABLE_ENTRY(TexEnviv),
+   TABLE_ENTRY(TexGend),
+   TABLE_ENTRY(TexGendv),
+   TABLE_ENTRY(TexGenf),
+   TABLE_ENTRY(TexGenfv),
+   TABLE_ENTRY(TexGeni),
+   TABLE_ENTRY(TexGeniv),
+   TABLE_ENTRY(FeedbackBuffer),
+   TABLE_ENTRY(SelectBuffer),
+   TABLE_ENTRY(RenderMode),
+   TABLE_ENTRY(InitNames),
+   TABLE_ENTRY(LoadName),
+   TABLE_ENTRY(PassThrough),
+   TABLE_ENTRY(PopName),
+   TABLE_ENTRY(PushName),
+   TABLE_ENTRY(DrawBuffer),
+   TABLE_ENTRY(Clear),
+   TABLE_ENTRY(ClearAccum),
+   TABLE_ENTRY(ClearIndex),
+   TABLE_ENTRY(ClearColor),
+   TABLE_ENTRY(ClearStencil),
+   TABLE_ENTRY(ClearDepth),
+   TABLE_ENTRY(StencilMask),
+   TABLE_ENTRY(ColorMask),
+   TABLE_ENTRY(DepthMask),
+   TABLE_ENTRY(IndexMask),
+   TABLE_ENTRY(Accum),
+   TABLE_ENTRY(Disable),
+   TABLE_ENTRY(Enable),
+   TABLE_ENTRY(Finish),
+   TABLE_ENTRY(Flush),
+   TABLE_ENTRY(PopAttrib),
+   TABLE_ENTRY(PushAttrib),
+   TABLE_ENTRY(Map1d),
+   TABLE_ENTRY(Map1f),
+   TABLE_ENTRY(Map2d),
+   TABLE_ENTRY(Map2f),
+   TABLE_ENTRY(MapGrid1d),
+   TABLE_ENTRY(MapGrid1f),
+   TABLE_ENTRY(MapGrid2d),
+   TABLE_ENTRY(MapGrid2f),
+   TABLE_ENTRY(EvalCoord1d),
+   TABLE_ENTRY(EvalCoord1dv),
+   TABLE_ENTRY(EvalCoord1f),
+   TABLE_ENTRY(EvalCoord1fv),
+   TABLE_ENTRY(EvalCoord2d),
+   TABLE_ENTRY(EvalCoord2dv),
+   TABLE_ENTRY(EvalCoord2f),
+   TABLE_ENTRY(EvalCoord2fv),
+   TABLE_ENTRY(EvalMesh1),
+   TABLE_ENTRY(EvalPoint1),
+   TABLE_ENTRY(EvalMesh2),
+   TABLE_ENTRY(EvalPoint2),
+   TABLE_ENTRY(AlphaFunc),
+   TABLE_ENTRY(BlendFunc),
+   TABLE_ENTRY(LogicOp),
+   TABLE_ENTRY(StencilFunc),
+   TABLE_ENTRY(StencilOp),
+   TABLE_ENTRY(DepthFunc),
+   TABLE_ENTRY(PixelZoom),
+   TABLE_ENTRY(PixelTransferf),
+   TABLE_ENTRY(PixelTransferi),
+   TABLE_ENTRY(PixelStoref),
+   TABLE_ENTRY(PixelStorei),
+   TABLE_ENTRY(PixelMapfv),
+   TABLE_ENTRY(PixelMapuiv),
+   TABLE_ENTRY(PixelMapusv),
+   TABLE_ENTRY(ReadBuffer),
+   TABLE_ENTRY(CopyPixels),
+   TABLE_ENTRY(ReadPixels),
+   TABLE_ENTRY(DrawPixels),
+   TABLE_ENTRY(GetBooleanv),
+   TABLE_ENTRY(GetClipPlane),
+   TABLE_ENTRY(GetDoublev),
+   TABLE_ENTRY(GetError),
+   TABLE_ENTRY(GetFloatv),
+   TABLE_ENTRY(GetIntegerv),
+   TABLE_ENTRY(GetLightfv),
+   TABLE_ENTRY(GetLightiv),
+   TABLE_ENTRY(GetMapdv),
+   TABLE_ENTRY(GetMapfv),
+   TABLE_ENTRY(GetMapiv),
+   TABLE_ENTRY(GetMaterialfv),
+   TABLE_ENTRY(GetMaterialiv),
+   TABLE_ENTRY(GetPixelMapfv),
+   TABLE_ENTRY(GetPixelMapuiv),
+   TABLE_ENTRY(GetPixelMapusv),
+   TABLE_ENTRY(GetPolygonStipple),
+   TABLE_ENTRY(GetString),
+   TABLE_ENTRY(GetTexEnvfv),
+   TABLE_ENTRY(GetTexEnviv),
+   TABLE_ENTRY(GetTexGendv),
+   TABLE_ENTRY(GetTexGenfv),
+   TABLE_ENTRY(GetTexGeniv),
+   TABLE_ENTRY(GetTexImage),
+   TABLE_ENTRY(GetTexParameterfv),
+   TABLE_ENTRY(GetTexParameteriv),
+   TABLE_ENTRY(GetTexLevelParameterfv),
+   TABLE_ENTRY(GetTexLevelParameteriv),
+   TABLE_ENTRY(IsEnabled),
+   TABLE_ENTRY(IsList),
+   TABLE_ENTRY(DepthRange),
+   TABLE_ENTRY(Frustum),
+   TABLE_ENTRY(LoadIdentity),
+   TABLE_ENTRY(LoadMatrixf),
+   TABLE_ENTRY(LoadMatrixd),
+   TABLE_ENTRY(MatrixMode),
+   TABLE_ENTRY(MultMatrixf),
+   TABLE_ENTRY(MultMatrixd),
+   TABLE_ENTRY(Ortho),
+   TABLE_ENTRY(PopMatrix),
+   TABLE_ENTRY(PushMatrix),
+   TABLE_ENTRY(Rotated),
+   TABLE_ENTRY(Rotatef),
+   TABLE_ENTRY(Scaled),
+   TABLE_ENTRY(Scalef),
+   TABLE_ENTRY(Translated),
+   TABLE_ENTRY(Translatef),
+   TABLE_ENTRY(Viewport),
+   /* 1.1 */
+   TABLE_ENTRY(ArrayElement),
+   TABLE_ENTRY(BindTexture),
+   TABLE_ENTRY(ColorPointer),
+   TABLE_ENTRY(DisableClientState),
+   TABLE_ENTRY(DrawArrays),
+   TABLE_ENTRY(DrawElements),
+   TABLE_ENTRY(EdgeFlagPointer),
+   TABLE_ENTRY(EnableClientState),
+   TABLE_ENTRY(IndexPointer),
+   TABLE_ENTRY(Indexub),
+   TABLE_ENTRY(Indexubv),
+   TABLE_ENTRY(InterleavedArrays),
+   TABLE_ENTRY(NormalPointer),
+   TABLE_ENTRY(PolygonOffset),
+   TABLE_ENTRY(TexCoordPointer),
+   TABLE_ENTRY(VertexPointer),
+   TABLE_ENTRY(AreTexturesResident),
+   TABLE_ENTRY(CopyTexImage1D),
+   TABLE_ENTRY(CopyTexImage2D),
+   TABLE_ENTRY(CopyTexSubImage1D),
+   TABLE_ENTRY(CopyTexSubImage2D),
+   TABLE_ENTRY(DeleteTextures),
+   TABLE_ENTRY(GenTextures),
+   TABLE_ENTRY(GetPointerv),
+   TABLE_ENTRY(IsTexture),
+   TABLE_ENTRY(PrioritizeTextures),
+   TABLE_ENTRY(TexSubImage1D),
+   TABLE_ENTRY(TexSubImage2D),
+   TABLE_ENTRY(PopClientAttrib),
+   TABLE_ENTRY(PushClientAttrib),
+   /* 1.2 */
+   TABLE_ENTRY(BlendColor),
+   TABLE_ENTRY(BlendEquation),
+   TABLE_ENTRY(DrawRangeElements),
+   TABLE_ENTRY(ColorTable),
+   TABLE_ENTRY(ColorTableParameterfv),
+   TABLE_ENTRY(ColorTableParameteriv),
+   TABLE_ENTRY(CopyColorTable),
+   TABLE_ENTRY(GetColorTable),
+   TABLE_ENTRY(GetColorTableParameterfv),
+   TABLE_ENTRY(GetColorTableParameteriv),
+   TABLE_ENTRY(ColorSubTable),
+   TABLE_ENTRY(CopyColorSubTable),
+   TABLE_ENTRY(ConvolutionFilter1D),
+   TABLE_ENTRY(ConvolutionFilter2D),
+   TABLE_ENTRY(ConvolutionParameterf),
+   TABLE_ENTRY(ConvolutionParameterfv),
+   TABLE_ENTRY(ConvolutionParameteri),
+   TABLE_ENTRY(ConvolutionParameteriv),
+   TABLE_ENTRY(CopyConvolutionFilter1D),
+   TABLE_ENTRY(CopyConvolutionFilter2D),
+   TABLE_ENTRY(GetConvolutionFilter),
+   TABLE_ENTRY(GetConvolutionParameterfv),
+   TABLE_ENTRY(GetConvolutionParameteriv),
+   TABLE_ENTRY(GetSeparableFilter),
+   TABLE_ENTRY(SeparableFilter2D),
+   TABLE_ENTRY(GetHistogram),
+   TABLE_ENTRY(GetHistogramParameterfv),
+   TABLE_ENTRY(GetHistogramParameteriv),
+   TABLE_ENTRY(GetMinmax),
+   TABLE_ENTRY(GetMinmaxParameterfv),
+   TABLE_ENTRY(GetMinmaxParameteriv),
+   TABLE_ENTRY(Histogram),
+   TABLE_ENTRY(Minmax),
+   TABLE_ENTRY(ResetHistogram),
+   TABLE_ENTRY(ResetMinmax),
+   TABLE_ENTRY(TexImage3D),
+   TABLE_ENTRY(TexSubImage3D),
+   TABLE_ENTRY(CopyTexSubImage3D),
+   /* GL_ARB_multitexture */
+   TABLE_ENTRY(ActiveTextureARB),
+   TABLE_ENTRY(ClientActiveTextureARB),
+   TABLE_ENTRY(MultiTexCoord1dARB),
+   TABLE_ENTRY(MultiTexCoord1dvARB),
+   TABLE_ENTRY(MultiTexCoord1fARB),
+   TABLE_ENTRY(MultiTexCoord1fvARB),
+   TABLE_ENTRY(MultiTexCoord1iARB),
+   TABLE_ENTRY(MultiTexCoord1ivARB),
+   TABLE_ENTRY(MultiTexCoord1sARB),
+   TABLE_ENTRY(MultiTexCoord1svARB),
+   TABLE_ENTRY(MultiTexCoord2dARB),
+   TABLE_ENTRY(MultiTexCoord2dvARB),
+   TABLE_ENTRY(MultiTexCoord2fARB),
+   TABLE_ENTRY(MultiTexCoord2fvARB),
+   TABLE_ENTRY(MultiTexCoord2iARB),
+   TABLE_ENTRY(MultiTexCoord2ivARB),
+   TABLE_ENTRY(MultiTexCoord2sARB),
+   TABLE_ENTRY(MultiTexCoord2svARB),
+   TABLE_ENTRY(MultiTexCoord3dARB),
+   TABLE_ENTRY(MultiTexCoord3dvARB),
+   TABLE_ENTRY(MultiTexCoord3fARB),
+   TABLE_ENTRY(MultiTexCoord3fvARB),
+   TABLE_ENTRY(MultiTexCoord3iARB),
+   TABLE_ENTRY(MultiTexCoord3ivARB),
+   TABLE_ENTRY(MultiTexCoord3sARB),
+   TABLE_ENTRY(MultiTexCoord3svARB),
+   TABLE_ENTRY(MultiTexCoord4dARB),
+   TABLE_ENTRY(MultiTexCoord4dvARB),
+   TABLE_ENTRY(MultiTexCoord4fARB),
+   TABLE_ENTRY(MultiTexCoord4fvARB),
+   TABLE_ENTRY(MultiTexCoord4iARB),
+   TABLE_ENTRY(MultiTexCoord4ivARB),
+   TABLE_ENTRY(MultiTexCoord4sARB),
+   TABLE_ENTRY(MultiTexCoord4svARB),
+   /* GL_ARB_transpose_matrix */
+   TABLE_ENTRY(LoadTransposeMatrixfARB),
+   TABLE_ENTRY(LoadTransposeMatrixdARB),
+   TABLE_ENTRY(MultTransposeMatrixfARB),
+   TABLE_ENTRY(MultTransposeMatrixdARB),
+   /* GL_ARB_multisample */
+   TABLE_ENTRY(SampleCoverageARB),
+#if 0
+   TABLE_ENTRY(SamplePassARB),
+#else
+   TABLE_ENTRY(Unused),
+#endif
+   /* GL_EXT_blend_color */
+   /* GL_EXT_polygon_offset */
+   TABLE_ENTRY(PolygonOffsetEXT),
+   /* GL_EXT_texture3D */
+   /* GL_EXT_subtexture */
+   /* GL_SGIS_texture_filter4 */
+   TABLE_ENTRY(GetTexFilterFuncSGIS),
+   TABLE_ENTRY(TexFilterFuncSGIS),
+   /* GL_EXT_subtexture */
+   /* GL_EXT_copy_texture */
+   /* GL_EXT_histogram */
+   TABLE_ENTRY(GetHistogramEXT),
+   TABLE_ENTRY(GetHistogramParameterfvEXT),
+   TABLE_ENTRY(GetHistogramParameterivEXT),
+   TABLE_ENTRY(GetMinmaxEXT),
+   TABLE_ENTRY(GetMinmaxParameterfvEXT),
+   TABLE_ENTRY(GetMinmaxParameterivEXT),
+   /* GL_EXT_convolution */
+   TABLE_ENTRY(GetConvolutionFilterEXT),
+   TABLE_ENTRY(GetConvolutionParameterfvEXT),
+   TABLE_ENTRY(GetConvolutionParameterivEXT),
+   TABLE_ENTRY(GetSeparableFilterEXT),
+   /* GL_SGI_color_table */
+   TABLE_ENTRY(GetColorTableSGI),
+   TABLE_ENTRY(GetColorTableParameterfvSGI),
+   TABLE_ENTRY(GetColorTableParameterivSGI),
+   /* GL_SGIX_pixel_texture */
+   TABLE_ENTRY(PixelTexGenSGIX),
+   /* GL_SGIS_pixel_texture */
+   TABLE_ENTRY(PixelTexGenParameteriSGIS),
+   TABLE_ENTRY(PixelTexGenParameterivSGIS),
+   TABLE_ENTRY(PixelTexGenParameterfSGIS),
+   TABLE_ENTRY(PixelTexGenParameterfvSGIS),
+   TABLE_ENTRY(GetPixelTexGenParameterivSGIS),
+   TABLE_ENTRY(GetPixelTexGenParameterfvSGIS),
+   /* GL_SGIS_texture4D */
+   TABLE_ENTRY(TexImage4DSGIS),
+   TABLE_ENTRY(TexSubImage4DSGIS),
+   /* GL_EXT_texture_object */
+   TABLE_ENTRY(AreTexturesResidentEXT),
+   TABLE_ENTRY(GenTexturesEXT),
+   TABLE_ENTRY(IsTextureEXT),
+   /* GL_SGIS_detail_texture */
+   TABLE_ENTRY(DetailTexFuncSGIS),
+   TABLE_ENTRY(GetDetailTexFuncSGIS),
+   /* GL_SGIS_sharpen_texture */
+   TABLE_ENTRY(SharpenTexFuncSGIS),
+   TABLE_ENTRY(GetSharpenTexFuncSGIS),
+   /* GL_SGIS_multisample */
+   TABLE_ENTRY(SampleMaskSGIS),
+   TABLE_ENTRY(SamplePatternSGIS),
+   /* GL_EXT_vertex_array */
+   TABLE_ENTRY(ColorPointerEXT),
+   TABLE_ENTRY(EdgeFlagPointerEXT),
+   TABLE_ENTRY(IndexPointerEXT),
+   TABLE_ENTRY(NormalPointerEXT),
+   TABLE_ENTRY(TexCoordPointerEXT),
+   TABLE_ENTRY(VertexPointerEXT),
+   /* GL_EXT_blend_minmax */
+   /* GL_SGIX_sprite */
+   TABLE_ENTRY(SpriteParameterfSGIX),
+   TABLE_ENTRY(SpriteParameterfvSGIX),
+   TABLE_ENTRY(SpriteParameteriSGIX),
+   TABLE_ENTRY(SpriteParameterivSGIX),
+   /* GL_EXT_point_parameters */
+   TABLE_ENTRY(PointParameterfEXT),
+   TABLE_ENTRY(PointParameterfvEXT),
+   /* GL_SGIX_instruments */
+   TABLE_ENTRY(GetInstrumentsSGIX),
+   TABLE_ENTRY(InstrumentsBufferSGIX),
+   TABLE_ENTRY(PollInstrumentsSGIX),
+   TABLE_ENTRY(ReadInstrumentsSGIX),
+   TABLE_ENTRY(StartInstrumentsSGIX),
+   TABLE_ENTRY(StopInstrumentsSGIX),
+   /* GL_SGIX_framezoom */
+   TABLE_ENTRY(FrameZoomSGIX),
+   /* GL_SGIX_tag_sample_buffer */
+   TABLE_ENTRY(TagSampleBufferSGIX),
+   /* GL_SGIX_reference_plane */
+   TABLE_ENTRY(ReferencePlaneSGIX),
+   /* GL_SGIX_flush_raster */
+   TABLE_ENTRY(FlushRasterSGIX),
+   /* GL_SGIX_list_priority */
+   TABLE_ENTRY(GetListParameterfvSGIX),
+   TABLE_ENTRY(GetListParameterivSGIX),
+   TABLE_ENTRY(ListParameterfSGIX),
+   TABLE_ENTRY(ListParameterfvSGIX),
+   TABLE_ENTRY(ListParameteriSGIX),
+   TABLE_ENTRY(ListParameterivSGIX),
+   /* GL_SGIX_fragment_lighting */
+   TABLE_ENTRY(FragmentColorMaterialSGIX),
+   TABLE_ENTRY(FragmentLightfSGIX),
+   TABLE_ENTRY(FragmentLightfvSGIX),
+   TABLE_ENTRY(FragmentLightiSGIX),
+   TABLE_ENTRY(FragmentLightivSGIX),
+   TABLE_ENTRY(FragmentLightModelfSGIX),
+   TABLE_ENTRY(FragmentLightModelfvSGIX),
+   TABLE_ENTRY(FragmentLightModeliSGIX),
+   TABLE_ENTRY(FragmentLightModelivSGIX),
+   TABLE_ENTRY(FragmentMaterialfSGIX),
+   TABLE_ENTRY(FragmentMaterialfvSGIX),
+   TABLE_ENTRY(FragmentMaterialiSGIX),
+   TABLE_ENTRY(FragmentMaterialivSGIX),
+   TABLE_ENTRY(GetFragmentLightfvSGIX),
+   TABLE_ENTRY(GetFragmentLightivSGIX),
+   TABLE_ENTRY(GetFragmentMaterialfvSGIX),
+   TABLE_ENTRY(GetFragmentMaterialivSGIX),
+   TABLE_ENTRY(LightEnviSGIX),
+   /* GL_EXT_vertex_weighting */
+   TABLE_ENTRY(VertexWeightfEXT),
+   TABLE_ENTRY(VertexWeightfvEXT),
+   TABLE_ENTRY(VertexWeightPointerEXT),
+   /* GL_NV_vertex_array_range */
+   TABLE_ENTRY(FlushVertexArrayRangeNV),
+   TABLE_ENTRY(VertexArrayRangeNV),
+   /* GL_NV_register_combiners */
+   TABLE_ENTRY(CombinerParameterfvNV),
+   TABLE_ENTRY(CombinerParameterfNV),
+   TABLE_ENTRY(CombinerParameterivNV),
+   TABLE_ENTRY(CombinerParameteriNV),
+   TABLE_ENTRY(CombinerInputNV),
+   TABLE_ENTRY(CombinerOutputNV),
+   TABLE_ENTRY(FinalCombinerInputNV),
+   TABLE_ENTRY(GetCombinerInputParameterfvNV),
+   TABLE_ENTRY(GetCombinerInputParameterivNV),
+   TABLE_ENTRY(GetCombinerOutputParameterfvNV),
+   TABLE_ENTRY(GetCombinerOutputParameterivNV),
+   TABLE_ENTRY(GetFinalCombinerInputParameterfvNV),
+   TABLE_ENTRY(GetFinalCombinerInputParameterivNV),
+   /* GL_MESA_resize_buffers */
+   TABLE_ENTRY(ResizeBuffersMESA),
+   /* GL_MESA_window_pos */
+   TABLE_ENTRY(WindowPos2dMESA),
+   TABLE_ENTRY(WindowPos2dvMESA),
+   TABLE_ENTRY(WindowPos2fMESA),
+   TABLE_ENTRY(WindowPos2fvMESA),
+   TABLE_ENTRY(WindowPos2iMESA),
+   TABLE_ENTRY(WindowPos2ivMESA),
+   TABLE_ENTRY(WindowPos2sMESA),
+   TABLE_ENTRY(WindowPos2svMESA),
+   TABLE_ENTRY(WindowPos3dMESA),
+   TABLE_ENTRY(WindowPos3dvMESA),
+   TABLE_ENTRY(WindowPos3fMESA),
+   TABLE_ENTRY(WindowPos3fvMESA),
+   TABLE_ENTRY(WindowPos3iMESA),
+   TABLE_ENTRY(WindowPos3ivMESA),
+   TABLE_ENTRY(WindowPos3sMESA),
+   TABLE_ENTRY(WindowPos3svMESA),
+   TABLE_ENTRY(WindowPos4dMESA),
+   TABLE_ENTRY(WindowPos4dvMESA),
+   TABLE_ENTRY(WindowPos4fMESA),
+   TABLE_ENTRY(WindowPos4fvMESA),
+   TABLE_ENTRY(WindowPos4iMESA),
+   TABLE_ENTRY(WindowPos4ivMESA),
+   TABLE_ENTRY(WindowPos4sMESA),
+   TABLE_ENTRY(WindowPos4svMESA),
+   /* GL_EXT_draw_range_elements */
+   TABLE_ENTRY(BlendFuncSeparateEXT),
+   /* GL_EXT_index_material */
+   TABLE_ENTRY(IndexMaterialEXT),
+   /* GL_EXT_index_func */
+   TABLE_ENTRY(IndexFuncEXT),
+   /* GL_EXT_compiled_vertex_array */
+   TABLE_ENTRY(LockArraysEXT),
+   TABLE_ENTRY(UnlockArraysEXT),
+   /* GL_EXT_cull_vertex */
+   TABLE_ENTRY(CullParameterdvEXT),
+   TABLE_ENTRY(CullParameterfvEXT),
+   /* GL_PGI_misc_hints */
+   TABLE_ENTRY(HintPGI),
+   /* GL_EXT_fog_coord */
+   TABLE_ENTRY(FogCoordfEXT),
+   TABLE_ENTRY(FogCoordfvEXT),
+   TABLE_ENTRY(FogCoorddEXT),
+   TABLE_ENTRY(FogCoorddvEXT),
+   TABLE_ENTRY(FogCoordPointerEXT),
+   /* GL_EXT_color_table */
+   TABLE_ENTRY(GetColorTableEXT),
+   TABLE_ENTRY(GetColorTableParameterivEXT),
+   TABLE_ENTRY(GetColorTableParameterfvEXT),
+   /* GL_3DFX_tbuffer */
+   TABLE_ENTRY(TbufferMask3DFX),
+   /* GL_ARB_texture_compression */
+   TABLE_ENTRY(CompressedTexImage3DARB),
+   TABLE_ENTRY(CompressedTexImage2DARB),
+   TABLE_ENTRY(CompressedTexImage1DARB),
+   TABLE_ENTRY(CompressedTexSubImage3DARB),
+   TABLE_ENTRY(CompressedTexSubImage2DARB),
+   TABLE_ENTRY(CompressedTexSubImage1DARB),
+   TABLE_ENTRY(GetCompressedTexImageARB),
+   /* GL_EXT_secondary_color */
+   TABLE_ENTRY(SecondaryColor3bEXT),
+   TABLE_ENTRY(SecondaryColor3bvEXT),
+   TABLE_ENTRY(SecondaryColor3dEXT),
+   TABLE_ENTRY(SecondaryColor3dvEXT),
+   TABLE_ENTRY(SecondaryColor3fEXT),
+   TABLE_ENTRY(SecondaryColor3fvEXT),
+   TABLE_ENTRY(SecondaryColor3iEXT),
+   TABLE_ENTRY(SecondaryColor3ivEXT),
+   TABLE_ENTRY(SecondaryColor3sEXT),
+   TABLE_ENTRY(SecondaryColor3svEXT),
+   TABLE_ENTRY(SecondaryColor3ubEXT),
+   TABLE_ENTRY(SecondaryColor3ubvEXT),
+   TABLE_ENTRY(SecondaryColor3uiEXT),
+   TABLE_ENTRY(SecondaryColor3uivEXT),
+   TABLE_ENTRY(SecondaryColor3usEXT),
+   TABLE_ENTRY(SecondaryColor3usvEXT),
+   TABLE_ENTRY(SecondaryColorPointerEXT),
+#if 0
+   /* 1.3 */
+   TABLE_ENTRY(ActiveTexture),
+   TABLE_ENTRY(ClientActiveTexture),
+   TABLE_ENTRY(CompressedTexImage1D),
+   TABLE_ENTRY(CompressedTexImage2D),
+   TABLE_ENTRY(CompressedTexImage3D),
+   TABLE_ENTRY(CompressedTexSubImage1D),
+   TABLE_ENTRY(CompressedTexSubImage2D),
+   TABLE_ENTRY(CompressedTexSubImage3D),
+   TABLE_ENTRY(GetCompressedTexImage),
+   TABLE_ENTRY(MultiTexCoord1d),
+   TABLE_ENTRY(MultiTexCoord1dv),
+   TABLE_ENTRY(MultiTexCoord1f),
+   TABLE_ENTRY(MultiTexCoord1fv),
+   TABLE_ENTRY(MultiTexCoord1i),
+   TABLE_ENTRY(MultiTexCoord1iv),
+   TABLE_ENTRY(MultiTexCoord1s),
+   TABLE_ENTRY(MultiTexCoord1sv),
+   TABLE_ENTRY(MultiTexCoord2d),
+   TABLE_ENTRY(MultiTexCoord2dv),
+   TABLE_ENTRY(MultiTexCoord2f),
+   TABLE_ENTRY(MultiTexCoord2fv),
+   TABLE_ENTRY(MultiTexCoord2i),
+   TABLE_ENTRY(MultiTexCoord2iv),
+   TABLE_ENTRY(MultiTexCoord2s),
+   TABLE_ENTRY(MultiTexCoord2sv),
+   TABLE_ENTRY(MultiTexCoord3d),
+   TABLE_ENTRY(MultiTexCoord3dv),
+   TABLE_ENTRY(MultiTexCoord3f),
+   TABLE_ENTRY(MultiTexCoord3fv),
+   TABLE_ENTRY(MultiTexCoord3i),
+   TABLE_ENTRY(MultiTexCoord3iv),
+   TABLE_ENTRY(MultiTexCoord3s),
+   TABLE_ENTRY(MultiTexCoord3sv),
+   TABLE_ENTRY(MultiTexCoord4d),
+   TABLE_ENTRY(MultiTexCoord4dv),
+   TABLE_ENTRY(MultiTexCoord4f),
+   TABLE_ENTRY(MultiTexCoord4fv),
+   TABLE_ENTRY(MultiTexCoord4i),
+   TABLE_ENTRY(MultiTexCoord4iv),
+   TABLE_ENTRY(MultiTexCoord4s),
+   TABLE_ENTRY(MultiTexCoord4sv),
+   TABLE_ENTRY(LoadTransposeMatrixd),
+   TABLE_ENTRY(LoadTransposeMatrixf),
+   TABLE_ENTRY(MultTransposeMatrixd),
+   TABLE_ENTRY(MultTransposeMatrixf),
+   TABLE_ENTRY(SampleCoverage),
+#if 0
+   TABLE_ENTRY(SamplePass),
+#else
+   TABLE_ENTRY(Unused),
+#endif
+#endif
+   /* A whole bunch of no-op functions.  These might be called
+    * when someone tries to call a dynamically-registered extension
+    * function without a current rendering context.
+    */
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused),
+   TABLE_ENTRY(Unused)
+};
+#endif /* DISPATCH_TABLE_NAME */
+
+
+
+/*
+ * This is just used to silence compiler warnings.
+ * We list the functions which aren't otherwise used.
+ */
+#ifdef UNUSED_TABLE_NAME
+void *UNUSED_TABLE_NAME[] = {
+   TABLE_ENTRY(BlendColorEXT),
+   TABLE_ENTRY(CopyTexSubImage3DEXT),
+   TABLE_ENTRY(TexImage3DEXT),
+   TABLE_ENTRY(TexSubImage3DEXT),
+   TABLE_ENTRY(CopyTexSubImage1DEXT),
+   TABLE_ENTRY(TexSubImage1DEXT),
+   TABLE_ENTRY(TexSubImage2DEXT),
+   TABLE_ENTRY(CopyTexImage1DEXT),
+   TABLE_ENTRY(CopyTexImage2DEXT),
+   TABLE_ENTRY(CopyTexSubImage2DEXT),
+   TABLE_ENTRY(HistogramEXT),
+   TABLE_ENTRY(MinmaxEXT),
+   TABLE_ENTRY(ResetHistogramEXT),
+   TABLE_ENTRY(ResetMinmaxEXT),
+   TABLE_ENTRY(ConvolutionFilter1DEXT),
+   TABLE_ENTRY(ConvolutionFilter2DEXT),
+   TABLE_ENTRY(ConvolutionParameterfEXT),
+   TABLE_ENTRY(ConvolutionParameterfvEXT),
+   TABLE_ENTRY(ConvolutionParameteriEXT),
+   TABLE_ENTRY(ConvolutionParameterivEXT),
+   TABLE_ENTRY(CopyConvolutionFilter1DEXT),
+   TABLE_ENTRY(CopyConvolutionFilter2DEXT),
+   TABLE_ENTRY(SeparableFilter2DEXT),
+   TABLE_ENTRY(ColorTableParameterfvSGI),
+   TABLE_ENTRY(ColorTableParameterivSGI),
+   TABLE_ENTRY(ColorTableSGI),
+   TABLE_ENTRY(CopyColorTableSGI),
+   TABLE_ENTRY(DeleteTexturesEXT),
+   TABLE_ENTRY(BindTextureEXT),
+   TABLE_ENTRY(PrioritizeTexturesEXT),
+   TABLE_ENTRY(GetPointervEXT),
+   TABLE_ENTRY(ArrayElementEXT),
+   TABLE_ENTRY(DrawArraysEXT),
+   TABLE_ENTRY(BlendEquationEXT),
+   TABLE_ENTRY(PointParameterfSGIS),
+   TABLE_ENTRY(PointParameterfvSGIS),
+   TABLE_ENTRY(ColorSubTableEXT),
+   TABLE_ENTRY(CopyColorSubTableEXT),
+   TABLE_ENTRY(ColorTableEXT),
+   TABLE_ENTRY(DrawRangeElementsEXT),
+   TABLE_ENTRY(BlendFuncSeparateINGR),
+   TABLE_ENTRY(SampleMaskEXT),
+   TABLE_ENTRY(SamplePatternEXT),
+   TABLE_ENTRY(ActiveTexture),
+   TABLE_ENTRY(ClientActiveTexture),
+   TABLE_ENTRY(CompressedTexImage1D),
+   TABLE_ENTRY(CompressedTexImage2D),
+   TABLE_ENTRY(CompressedTexImage2DARB),
+   TABLE_ENTRY(CompressedTexImage3D),
+   TABLE_ENTRY(CompressedTexSubImage1D),
+   TABLE_ENTRY(CompressedTexSubImage2D),
+   TABLE_ENTRY(CompressedTexSubImage3D),
+   TABLE_ENTRY(GetCompressedTexImage),
+   TABLE_ENTRY(MultiTexCoord1d),
+   TABLE_ENTRY(MultiTexCoord1dv),
+   TABLE_ENTRY(MultiTexCoord1f),
+   TABLE_ENTRY(MultiTexCoord1fv),
+   TABLE_ENTRY(MultiTexCoord1i),
+   TABLE_ENTRY(MultiTexCoord1iv),
+   TABLE_ENTRY(MultiTexCoord1s),
+   TABLE_ENTRY(MultiTexCoord1sv),
+   TABLE_ENTRY(MultiTexCoord2d),
+   TABLE_ENTRY(MultiTexCoord2dv),
+   TABLE_ENTRY(MultiTexCoord2f),
+   TABLE_ENTRY(MultiTexCoord2fv),
+   TABLE_ENTRY(MultiTexCoord2i),
+   TABLE_ENTRY(MultiTexCoord2iv),
+   TABLE_ENTRY(MultiTexCoord2s),
+   TABLE_ENTRY(MultiTexCoord2sv),
+   TABLE_ENTRY(MultiTexCoord3d),
+   TABLE_ENTRY(MultiTexCoord3dv),
+   TABLE_ENTRY(MultiTexCoord3f),
+   TABLE_ENTRY(MultiTexCoord3fv),
+   TABLE_ENTRY(MultiTexCoord3i),
+   TABLE_ENTRY(MultiTexCoord3iv),
+   TABLE_ENTRY(MultiTexCoord3s),
+   TABLE_ENTRY(MultiTexCoord3sv),
+   TABLE_ENTRY(MultiTexCoord4d),
+   TABLE_ENTRY(MultiTexCoord4dv),
+   TABLE_ENTRY(MultiTexCoord4f),
+   TABLE_ENTRY(MultiTexCoord4fv),
+   TABLE_ENTRY(MultiTexCoord4i),
+   TABLE_ENTRY(MultiTexCoord4iv),
+   TABLE_ENTRY(MultiTexCoord4s),
+   TABLE_ENTRY(MultiTexCoord4sv),
+   TABLE_ENTRY(LoadTransposeMatrixd),
+   TABLE_ENTRY(LoadTransposeMatrixf),
+   TABLE_ENTRY(MultTransposeMatrixd),
+   TABLE_ENTRY(MultTransposeMatrixf),
+   TABLE_ENTRY(SampleCoverage),
+#if 0
+   TABLE_ENTRY(SamplePass)
+#endif
+};
+#endif /*UNUSED_TABLE_NAME*/
 
 
 #undef KEYWORD1
@@ -3415,3 +4612,6 @@
 #undef NAME
 #undef DISPATCH
 #undef RETURN_DISPATCH
+#undef DISPATCH_TABLE_NAME
+#undef UNUSED_TABLE_NAME
+#undef TABLE_ENTRY
Index: xc/extras/Mesa/src/glheader.h
diff -u xc/extras/Mesa/src/glheader.h:1.14 xc/extras/Mesa/src/glheader.h:1.20
--- xc/extras/Mesa/src/glheader.h:1.14	Tue Apr 10 12:07:48 2001
+++ xc/extras/Mesa/src/glheader.h	Wed Nov  6 12:19:39 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.3
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,6 +22,7 @@
  * 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.
  */
+/* $XFree86: xc/extras/Mesa/src/glheader.h,v 1.20 2002/11/06 17:19:39 tsi Exp $ */
 
 
 #ifndef GLHEADER_H
@@ -45,7 +46,7 @@
 
 
 
-#ifdef XFree86LOADER
+#ifdef XFree86Module
 #include "xf86_ansic.h"
 #else
 #include <assert.h>
@@ -60,7 +61,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#if defined(__linux__) && defined(__i386__) 
+#if defined(__linux__) && defined(__i386__)
 #include <fpu_control.h>
 #endif
 #endif
@@ -75,6 +76,7 @@
 
 #if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__)
 #	define __WIN32__
+#	define finite _finite
 #endif
 
 #if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__))
@@ -160,13 +162,49 @@
 #endif
 
 
+/*
+ * Either define MESA_BIG_ENDIAN or MESA_LITTLE_ENDIAN.
+ * Do not use them unless absolutely necessary!
+ * Try to use a runtime test instead.
+ * For now, only used by some DRI hardware drivers for color/texel packing.
+ */
+#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+#if defined(__linux__)
+#include <byteswap.h>
+#define CPU_TO_LE32( x )	bswap_32( x )
+#else /*__linux__*/
+#define CPU_TO_LE32( x )	( x )  /* fix me for non-Linux big-endian! */
+#endif /*__linux__*/
+#define MESA_BIG_ENDIAN 1
+#else
+#define CPU_TO_LE32( x )	( x )
+#define MESA_LITTLE_ENDIAN 1
+#endif
+#define LE32_TO_CPU( x )	CPU_TO_LE32( x )
+
+
+/* This is a macro on IRIX */
+#ifdef _P
+#undef _P
+#endif
 
 
+
 #include "GL/gl.h"
 #include "GL/glext.h"
 
 
+#ifndef CAPI
+#ifdef WIN32
+#define CAPI _cdecl
+#else
+#define CAPI
+#endif
+#endif
+#include <GL/internal/glcore.h>
 
+
+
 /* Disable unreachable code warnings for Watcom C++ */
 #ifdef	__WATCOMC__
 #pragma disable_message(201)
@@ -204,5 +242,45 @@
 #endif
 
 
+/* Function inlining */
+#if defined(__GNUC__)
+#  define INLINE __inline__
+#elif defined(__MSC__)
+#  define INLINE __inline
+#elif defined(_MSC_VER)
+#  define INLINE __inline
+#elif defined(__ICL)
+#  define INLINE __inline
+#else
+#  define INLINE
+#endif
+
+
+/* Some compilers don't like some of Mesa's const usage */
+#ifdef NO_CONST
+#  define CONST
+#else
+#  define CONST const
+#endif
+
+
+#ifdef DEBUG
+#  define ASSERT(X)   assert(X)
+#else
+#  define ASSERT(X)
+#endif
+
+
+/*
+ * Sometimes we treat GLfloats as GLints.  On x86 systems, moving a float
+ * as a int (thereby using integer registers instead of fp registers) is
+ * a performance win.  Typically, this can be done with ordinary casts.
+ * But with gcc's -fstrict-aliasing flag (which defaults to on in gcc 3.0)
+ * these casts generate warnings.
+ * The following union typedef is used to solve that.
+ */
+typedef union { GLfloat f; GLint i; } fi_type;
+
 
+                                                       
 #endif /* GLHEADER_H */
Index: xc/extras/Mesa/src/glthread.c
diff -u xc/extras/Mesa/src/glthread.c:1.2 xc/extras/Mesa/src/glthread.c:1.3
--- xc/extras/Mesa/src/glthread.c:1.2	Tue Feb 15 02:12:19 2000
+++ xc/extras/Mesa/src/glthread.c	Fri Feb 22 14:25:32 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -34,7 +34,7 @@
 #include "all.h"
 #else
 #include "glheader.h"
-#include "glthread.h" 
+#include "glthread.h"
 #endif
 
 
@@ -92,7 +92,7 @@
 void *
 _glthread_GetTSD(_glthread_TSD *tsd)
 {
-   if (tsd->initMagic != INIT_MAGIC) {
+   if (tsd->initMagic != (int) INIT_MAGIC) {
       _glthread_InitTSD(tsd);
    }
    return pthread_getspecific(tsd->key);
@@ -102,7 +102,7 @@
 void
 _glthread_SetTSD(_glthread_TSD *tsd, void *ptr)
 {
-   if (tsd->initMagic != INIT_MAGIC) {
+   if (tsd->initMagic != (int) INIT_MAGIC) {
       _glthread_InitTSD(tsd);
    }
    if (pthread_setspecific(tsd->key, ptr) != 0) {
@@ -116,9 +116,9 @@
 
 
 /*
- * Solaris/Unix International Threads -- Use only if POSIX threads 
+ * Solaris/Unix International Threads -- Use only if POSIX threads
  *   aren't available on your Unix platform.  Solaris 2.[34] are examples
- *   of platforms where this is the case.  Be sure to use -mt and/or 
+ *   of platforms where this is the case.  Be sure to use -mt and/or
  *   -D_REENTRANT when compiling.
  */
 #ifdef SOLARIS_THREADS
@@ -155,7 +155,7 @@
 #ifdef USE_LOCK_FOR_KEY
    mutex_lock(&tsd->keylock);
    thr_getspecific(tsd->key, &ret);
-   mutex_unlock(&tsd->keylock); 
+   mutex_unlock(&tsd->keylock);
 #else
    if ((errno = thr_getspecific(tsd->key, &ret)) != 0) {
       perror(GET_TSD_ERROR);
@@ -187,7 +187,7 @@
  * Win32 Threads.  The only available option for Windows 95/NT.
  * Be sure that you compile using the Multithreaded runtime, otherwise
  * bad things will happen.
- */  
+ */
 #ifdef WIN32_THREADS
 
 unsigned long
Index: xc/extras/Mesa/src/glthread.h
diff -u xc/extras/Mesa/src/glthread.h:1.3 xc/extras/Mesa/src/glthread.h:1.4
--- xc/extras/Mesa/src/glthread.h:1.3	Sat Oct 27 23:32:06 2001
+++ xc/extras/Mesa/src/glthread.h	Fri Feb 22 14:25:32 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -22,7 +22,7 @@
  * 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.
  */
-/* $XFree86: xc/extras/Mesa/src/glthread.h,v 1.3 2001/10/28 03:32:06 tsi Exp $ */
+/* $XFree86: xc/extras/Mesa/src/glthread.h,v 1.4 2002/02/22 19:25:32 dawes Exp $ */
 
 /*
  * Thread support for gl dispatch.
@@ -56,12 +56,11 @@
  */
 
 /*
- * If this file is accidentally included by a non-threaded build, 
+ * If this file is accidentally included by a non-threaded build,
  * it should not cause the build to fail, or otherwise cause problems.
  * In general, it should only be included when needed however.
  */
 
-
 #ifndef GLTHREAD_H
 #define GLTHREAD_H
 
@@ -69,8 +68,10 @@
 #if defined(PTHREADS) || defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || defined(XTHREADS)
 #define THREADS
 #endif
-
 
+#ifdef VMS
+#include <GL/vms_x_fix.h>
+#endif
 
 /*
  * POSIX threads. This should be your choice in the Unix world
@@ -111,9 +112,9 @@
 
 
 /*
- * Solaris threads. Use only up to Solaris 2.4. 
+ * Solaris threads. Use only up to Solaris 2.4.
  * Solaris 2.5 and higher provide POSIX threads.
- * Be sure to compile with -mt on the Solaris compilers, or 
+ * Be sure to compile with -mt on the Solaris compilers, or
  * use -D_REENTRANT if using gcc.
  */
 #ifdef SOLARIS_THREADS
@@ -141,7 +142,7 @@
 
 
 /*
- * Windows threads. Should work with Windows NT and 95. 
+ * Windows threads. Should work with Windows NT and 95.
  * IMPORTANT: Link with multithreaded runtime library when THREADS are
  * used!
  */
@@ -231,7 +232,7 @@
 
 
 /*
- * Platform independent thread specific data API. 
+ * Platform independent thread specific data API.
  */
 
 extern unsigned long
@@ -252,4 +253,3 @@
 
 
 #endif /* THREADS_H */
-
Index: xc/extras/Mesa/src/hash.c
diff -u xc/extras/Mesa/src/hash.c:1.5 xc/extras/Mesa/src/hash.c:1.6
--- xc/extras/Mesa/src/hash.c:1.5	Thu Nov 30 10:39:04 2000
+++ xc/extras/Mesa/src/hash.c	Fri Feb 22 14:25:32 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -63,7 +63,11 @@
  */
 struct _mesa_HashTable *_mesa_NewHashTable(void)
 {
-   return CALLOC_STRUCT(_mesa_HashTable);
+   struct _mesa_HashTable *table = CALLOC_STRUCT(_mesa_HashTable);
+   if (table) {
+      _glthread_INIT_MUTEX(table->Mutex);
+   }
+   return table;
 }
 
 
@@ -100,6 +104,7 @@
    const struct HashEntry *entry;
 
    assert(table);
+   assert(key);
 
    pos = key & (TABLE_SIZE-1);
    entry = table->Table[pos];
@@ -128,6 +133,7 @@
    struct HashEntry *entry;
 
    assert(table);
+   assert(key);
 
    _glthread_LOCK_MUTEX(table->Mutex);
 
@@ -169,6 +175,7 @@
    struct HashEntry *entry, *prev;
 
    assert(table);
+   assert(key);
 
    _glthread_LOCK_MUTEX(table->Mutex);
 
Index: xc/extras/Mesa/src/hash.h
diff -u xc/extras/Mesa/src/hash.h:1.4 xc/extras/Mesa/src/hash.h:1.5
--- xc/extras/Mesa/src/hash.h:1.4	Fri Jun 16 20:02:12 2000
+++ xc/extras/Mesa/src/hash.h	Fri Feb 22 14:25:33 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
Index: xc/extras/Mesa/src/highpc.c
diff -u xc/extras/Mesa/src/highpc.c:1.3 xc/extras/Mesa/src/highpc.c:1.4
--- xc/extras/Mesa/src/highpc.c:1.3	Tue Feb 15 02:12:19 2000
+++ xc/extras/Mesa/src/highpc.c	Fri Feb 22 14:25:33 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,13 +28,14 @@
 #include "all.h"
 #else
 #include "glheader.h"
-#include "types.h"		/* for MESA_VERBOSE */
+#include "mtypes.h"
 #endif
 
 
 /*
  * This is the highest address in Mesa
  */
+extern void mesa_highpc(void);  /* silence compiler warning */
 void mesa_highpc(void) { }
 
 #if defined(__GNUC__) && defined(__linux__)
@@ -46,6 +47,7 @@
 
 static int profile = 0;
 
+extern void force_init_prof( void ); /* silence compiler warning */
 void force_init_prof( void )
 {
    FILE *fp;
@@ -56,8 +58,8 @@
 
    monstartup( (char *)mesa_lowpc, (char *)mesa_highpc );
 
-   fprintf(stderr, "Starting profiling, %x %x\n", 
-	   (unsigned int)mesa_lowpc, 
+   fprintf(stderr, "Starting profiling, %x %x\n",
+	   (unsigned int)mesa_lowpc,
 	   (unsigned int)mesa_highpc);
 
    if ((fp = fopen( "mesa_lowpc", "w" )) != NULL) {
@@ -69,6 +71,7 @@
 /*
  * Start profiling
  */
+extern void init_prof(void); /* silence compiler warning */
 void __attribute__ ((constructor))
 init_prof( void )
 {
@@ -82,8 +85,8 @@
 
    monstartup( (char *)mesa_lowpc, (char *)mesa_highpc );
 
-      fprintf(stderr, "Starting profiling, %x %x\n", 
-	      (unsigned int)mesa_lowpc, 
+      fprintf(stderr, "Starting profiling, %x %x\n",
+	      (unsigned int)mesa_lowpc,
 	      (unsigned int)mesa_highpc);
 
    if ((fp = fopen( "mesa_lowpc", "w" )) != NULL) {
@@ -97,6 +100,7 @@
 /*
  * Finish profiling
  */
+extern void fini_prof(void);  /* silence compiler warning */
 void __attribute__ ((destructor))
 fini_prof( void )
 {
Index: xc/extras/Mesa/src/hint.c
diff -u xc/extras/Mesa/src/hint.c:1.2 xc/extras/Mesa/src/hint.c:1.3
--- xc/extras/Mesa/src/hint.c:1.2	Fri Jun 16 20:02:12 2000
+++ xc/extras/Mesa/src/hint.c	Fri Feb 22 14:25:33 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -40,6 +40,7 @@
 _mesa_Hint( GLenum target, GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
    (void) _mesa_try_Hint( ctx, target, mode );
 }
 
@@ -47,150 +48,86 @@
 GLboolean
 _mesa_try_Hint( GLcontext *ctx, GLenum target, GLenum mode )
 {
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glHint", GL_FALSE);
-
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glHint %s %d\n", gl_lookup_enum_by_nr(target), mode);
+      fprintf(stderr, "glHint %s %d\n", _mesa_lookup_enum_by_nr(target), mode);
 
    if (mode != GL_NICEST && mode != GL_FASTEST && mode != GL_DONT_CARE) {
-      gl_error(ctx, GL_INVALID_ENUM, "glHint(mode)");
+      _mesa_error(ctx, GL_INVALID_ENUM, "glHint(mode)");
       return GL_FALSE;
    }
 
    switch (target) {
       case GL_FOG_HINT:
+         if (ctx->Hint.Fog == mode)
+	    return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
          ctx->Hint.Fog = mode;
          break;
       case GL_LINE_SMOOTH_HINT:
+         if (ctx->Hint.LineSmooth == mode)
+	    return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
          ctx->Hint.LineSmooth = mode;
          break;
       case GL_PERSPECTIVE_CORRECTION_HINT:
+         if (ctx->Hint.PerspectiveCorrection == mode)
+	    return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
          ctx->Hint.PerspectiveCorrection = mode;
          break;
       case GL_POINT_SMOOTH_HINT:
+         if (ctx->Hint.PointSmooth == mode)
+	    return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
          ctx->Hint.PointSmooth = mode;
          break;
       case GL_POLYGON_SMOOTH_HINT:
+         if (ctx->Hint.PolygonSmooth == mode)
+	    return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
          ctx->Hint.PolygonSmooth = mode;
          break;
-      case GL_PREFER_DOUBLEBUFFER_HINT_PGI:
-      case GL_STRICT_DEPTHFUNC_HINT_PGI:
-         break;
-      case GL_STRICT_LIGHTING_HINT_PGI:
-         ctx->Hint.StrictLighting = mode;
-         break;
-      case GL_STRICT_SCISSOR_HINT_PGI:
-      case GL_FULL_STIPPLE_HINT_PGI:
-      case GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI:
-      case GL_NATIVE_GRAPHICS_END_HINT_PGI:
-      case GL_CONSERVE_MEMORY_HINT_PGI:
-      case GL_RECLAIM_MEMORY_HINT_PGI:
-         break;
-      case GL_ALWAYS_FAST_HINT_PGI:
-         if (mode) {
-            ctx->Hint.AllowDrawWin = GL_TRUE;
-            ctx->Hint.AllowDrawFrg = GL_FALSE;
-            ctx->Hint.AllowDrawMem = GL_FALSE;
-         } else {
-            ctx->Hint.AllowDrawWin = GL_TRUE;
-            ctx->Hint.AllowDrawFrg = GL_TRUE;
-            ctx->Hint.AllowDrawMem = GL_TRUE;
-         } 
-         break;
-      case GL_ALWAYS_SOFT_HINT_PGI:
-         ctx->Hint.AllowDrawWin = GL_TRUE;
-         ctx->Hint.AllowDrawFrg = GL_TRUE;
-         ctx->Hint.AllowDrawMem = GL_TRUE;
-         break;
-      case GL_ALLOW_DRAW_OBJ_HINT_PGI:
-         break;
-      case GL_ALLOW_DRAW_WIN_HINT_PGI:
-         ctx->Hint.AllowDrawWin = mode;
-         break;
-      case GL_ALLOW_DRAW_FRG_HINT_PGI:
-         ctx->Hint.AllowDrawFrg = mode;
-         break;
-      case GL_ALLOW_DRAW_MEM_HINT_PGI:
-         ctx->Hint.AllowDrawMem = mode;
-         break;
-      case GL_CLIP_NEAR_HINT_PGI:
-      case GL_CLIP_FAR_HINT_PGI:
-      case GL_WIDE_LINE_HINT_PGI:
-      case GL_BACK_NORMALS_HINT_PGI:
-      case GL_NATIVE_GRAPHICS_HANDLE_PGI:
-         break;
 
       /* GL_EXT_clip_volume_hint */
       case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:
+         if (ctx->Hint.ClipVolumeClipping == mode)
+	    return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
          ctx->Hint.ClipVolumeClipping = mode;
          break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
-            ctx->Hint.TextureCompression = mode;
+         if (!ctx->Extensions.ARB_texture_compression) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");
+	    return GL_FALSE;
          }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glHint(target)");
+	 if (ctx->Hint.TextureCompression == mode)
+	    return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
+	 ctx->Hint.TextureCompression = mode;
+         break;
+
+      /* GL_SGIS_generate_mipmap */
+      case GL_GENERATE_MIPMAP_HINT_SGIS:
+         if (!ctx->Extensions.SGIS_generate_mipmap) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");
+	    return GL_FALSE;
          }
+         if (ctx->Hint.GenerateMipmap == mode)
+            return GL_TRUE;
+	 FLUSH_VERTICES(ctx, _NEW_HINT);
+	 ctx->Hint.GenerateMipmap = mode;
          break;
 
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glHint(target)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");
          return GL_FALSE;
    }
 
-   ctx->NewState |= NEW_ALL;   /* just to be safe */
-
    if (ctx->Driver.Hint) {
       (*ctx->Driver.Hint)( ctx, target, mode );
    }
-   
-   return GL_TRUE;
-}
-
 
-void
-_mesa_HintPGI( GLenum target, GLint mode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glHintPGI");
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glHintPGI %s %d\n", gl_lookup_enum_by_nr(target), mode);
-
-   if (mode != GL_NICEST && mode != GL_FASTEST && mode != GL_DONT_CARE) {
-      gl_error(ctx, GL_INVALID_ENUM, "glHintPGI(mode)");
-      return;
-   }
-
-   switch (target) {
-      case GL_PREFER_DOUBLEBUFFER_HINT_PGI:
-      case GL_STRICT_DEPTHFUNC_HINT_PGI:
-      case GL_STRICT_LIGHTING_HINT_PGI:
-      case GL_STRICT_SCISSOR_HINT_PGI:
-      case GL_FULL_STIPPLE_HINT_PGI:
-      case GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI:
-      case GL_NATIVE_GRAPHICS_END_HINT_PGI:
-      case GL_CONSERVE_MEMORY_HINT_PGI:
-      case GL_RECLAIM_MEMORY_HINT_PGI:
-      case GL_ALWAYS_FAST_HINT_PGI:
-      case GL_ALWAYS_SOFT_HINT_PGI:
-      case GL_ALLOW_DRAW_OBJ_HINT_PGI:
-      case GL_ALLOW_DRAW_WIN_HINT_PGI:
-      case GL_ALLOW_DRAW_FRG_HINT_PGI:
-      case GL_ALLOW_DRAW_MEM_HINT_PGI:
-      case GL_CLIP_NEAR_HINT_PGI:
-      case GL_CLIP_FAR_HINT_PGI:
-      case GL_WIDE_LINE_HINT_PGI:
-      case GL_BACK_NORMALS_HINT_PGI:
-      case GL_NATIVE_GRAPHICS_HANDLE_PGI:
-         (void) _mesa_try_Hint(ctx, target, (GLenum) mode);
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glHintPGI(target)" );
-         return;
-   }
+   return GL_TRUE;
 }
-
-   
Index: xc/extras/Mesa/src/hint.h
diff -u xc/extras/Mesa/src/hint.h:1.1 xc/extras/Mesa/src/hint.h:1.2
--- xc/extras/Mesa/src/hint.h:1.1	Tue Feb 15 09:50:52 2000
+++ xc/extras/Mesa/src/hint.h	Fri Feb 22 14:25:33 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define HINT_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern GLboolean
@@ -36,9 +36,6 @@
 
 extern void
 _mesa_Hint( GLenum target, GLenum mode );
-
-extern void
-_mesa_HintPGI( GLenum target, GLint mode );
 
 
 #endif
Index: xc/extras/Mesa/src/histogram.c
diff -u /dev/null xc/extras/Mesa/src/histogram.c:1.2
--- /dev/null	Thu Feb 27 12:15:38 2003
+++ xc/extras/Mesa/src/histogram.c	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,1034 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifdef PC_HEADER
+#include "all.h"
+#else
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "image.h"
+#include "histogram.h"
+#include "mmath.h"
+#endif
+
+
+/*
+ * XXX the packed pixel formats haven't been tested.
+ */
+static void
+pack_histogram( GLcontext *ctx,
+                GLuint n, CONST GLuint rgba[][4],
+                GLenum format, GLenum type, GLvoid *destination,
+                const struct gl_pixelstore_attrib *packing )
+{
+   const GLint comps = _mesa_components_in_format(format);
+   GLuint luminance[MAX_WIDTH];
+
+   if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
+      }
+   }
+
+#define PACK_MACRO(TYPE)					\
+   {								\
+      GLuint i;							\
+      switch (format) {						\
+         case GL_RED:						\
+            for (i=0;i<n;i++)					\
+               dst[i] = (TYPE) rgba[i][RCOMP];			\
+            break;						\
+         case GL_GREEN:						\
+            for (i=0;i<n;i++)					\
+               dst[i] = (TYPE) rgba[i][GCOMP];			\
+            break;						\
+         case GL_BLUE:						\
+            for (i=0;i<n;i++)					\
+               dst[i] = (TYPE) rgba[i][BCOMP];			\
+            break;						\
+         case GL_ALPHA:						\
+            for (i=0;i<n;i++)					\
+               dst[i] = (TYPE) rgba[i][ACOMP];			\
+            break;						\
+         case GL_LUMINANCE:					\
+            for (i=0;i<n;i++)					\
+               dst[i] = (TYPE) luminance[i];			\
+            break;						\
+         case GL_LUMINANCE_ALPHA:				\
+            for (i=0;i<n;i++) {					\
+               dst[i*2+0] = (TYPE) luminance[i];		\
+               dst[i*2+1] = (TYPE) rgba[i][ACOMP];		\
+            }							\
+            break;						\
+         case GL_RGB:						\
+            for (i=0;i<n;i++) {					\
+               dst[i*3+0] = (TYPE) rgba[i][RCOMP];		\
+               dst[i*3+1] = (TYPE) rgba[i][GCOMP];		\
+               dst[i*3+2] = (TYPE) rgba[i][BCOMP];		\
+            }							\
+            break;						\
+         case GL_RGBA:						\
+            for (i=0;i<n;i++) {					\
+               dst[i*4+0] = (TYPE) rgba[i][RCOMP];		\
+               dst[i*4+1] = (TYPE) rgba[i][GCOMP];		\
+               dst[i*4+2] = (TYPE) rgba[i][BCOMP];		\
+               dst[i*4+3] = (TYPE) rgba[i][ACOMP];		\
+            }							\
+            break;						\
+         case GL_BGR:						\
+            for (i=0;i<n;i++) {					\
+               dst[i*3+0] = (TYPE) rgba[i][BCOMP];		\
+               dst[i*3+1] = (TYPE) rgba[i][GCOMP];		\
+               dst[i*3+2] = (TYPE) rgba[i][RCOMP];		\
+            }							\
+            break;						\
+         case GL_BGRA:						\
+            for (i=0;i<n;i++) {					\
+               dst[i*4+0] = (TYPE) rgba[i][BCOMP];		\
+               dst[i*4+1] = (TYPE) rgba[i][GCOMP];		\
+               dst[i*4+2] = (TYPE) rgba[i][RCOMP];		\
+               dst[i*4+3] = (TYPE) rgba[i][ACOMP];		\
+            }							\
+            break;						\
+         case GL_ABGR_EXT:					\
+            for (i=0;i<n;i++) {					\
+               dst[i*4+0] = (TYPE) rgba[i][ACOMP];		\
+               dst[i*4+1] = (TYPE) rgba[i][BCOMP];		\
+               dst[i*4+2] = (TYPE) rgba[i][GCOMP];		\
+               dst[i*4+3] = (TYPE) rgba[i][RCOMP];		\
+            }							\
+            break;						\
+         default:						\
+            _mesa_problem(ctx, "bad format in pack_histogram");	\
+      }								\
+   }
+
+   switch (type) {
+      case GL_UNSIGNED_BYTE:
+         {
+            GLubyte *dst = (GLubyte *) destination;
+            PACK_MACRO(GLubyte);
+         }
+         break;
+      case GL_BYTE:
+         {
+            GLbyte *dst = (GLbyte *) destination;
+            PACK_MACRO(GLbyte);
+         }
+         break;
+      case GL_UNSIGNED_SHORT:
+         {
+            GLushort *dst = (GLushort *) destination;
+            PACK_MACRO(GLushort);
+            if (packing->SwapBytes) {
+               _mesa_swap2(dst, n * comps);
+            }
+         }
+         break;
+      case GL_SHORT:
+         {
+            GLshort *dst = (GLshort *) destination;
+            PACK_MACRO(GLshort);
+            if (packing->SwapBytes) {
+               _mesa_swap2((GLushort *) dst, n * comps);
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT:
+         {
+            GLuint *dst = (GLuint *) destination;
+            PACK_MACRO(GLuint);
+            if (packing->SwapBytes) {
+               _mesa_swap4(dst, n * comps);
+            }
+         }
+         break;
+      case GL_INT:
+         {
+            GLint *dst = (GLint *) destination;
+            PACK_MACRO(GLint);
+            if (packing->SwapBytes) {
+               _mesa_swap4((GLuint *) dst, n * comps);
+            }
+         }
+         break;
+      case GL_FLOAT:
+         {
+            GLfloat *dst = (GLfloat *) destination;
+            PACK_MACRO(GLfloat);
+            if (packing->SwapBytes) {
+               _mesa_swap4((GLuint *) dst, n * comps);
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE_3_3_2:
+         if (format == GL_RGB) {
+            GLubyte *dst = (GLubyte *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x7) << 5)
+                      | ((rgba[i][GCOMP] & 0x7) << 2)
+                      | ((rgba[i][BCOMP] & 0x3)     );
+            }
+         }
+         else {
+            GLubyte *dst = (GLubyte *) destination;
+            GLuint i;
+            ASSERT(format == GL_BGR);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0x7) << 5)
+                      | ((rgba[i][GCOMP] & 0x7) << 2)
+                      | ((rgba[i][RCOMP] & 0x3)     );
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+         if (format == GL_RGB) {
+            GLubyte *dst = (GLubyte *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x3) << 6)
+                      | ((rgba[i][GCOMP] & 0x7) << 3)
+                      | ((rgba[i][BCOMP] & 0x7)     );
+            }
+         }
+         else {
+            GLubyte *dst = (GLubyte *) destination;
+            GLuint i;
+            ASSERT(format == GL_BGR);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0x3) << 6)
+                      | ((rgba[i][GCOMP] & 0x7) << 3)
+                      | ((rgba[i][RCOMP] & 0x7)     );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5:
+         if (format == GL_RGB) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
+                      | ((rgba[i][GCOMP] & 0x3f) <<  5)
+                      | ((rgba[i][BCOMP] & 0x1f)      );
+            }
+         }
+         else {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            ASSERT(format == GL_BGR);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11)
+                      | ((rgba[i][GCOMP] & 0x3f) <<  5)
+                      | ((rgba[i][RCOMP] & 0x1f)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+         if (format == GL_RGB) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11)
+                      | ((rgba[i][GCOMP] & 0x3f) <<  5)
+                      | ((rgba[i][RCOMP] & 0x1f)      );
+            }
+         }
+         else {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            ASSERT(format == GL_BGR);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
+                      | ((rgba[i][GCOMP] & 0x3f) <<  5)
+                      | ((rgba[i][BCOMP] & 0x1f)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+         if (format == GL_RGBA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0xf) << 12)
+                      | ((rgba[i][GCOMP] & 0xf) <<  8)
+                      | ((rgba[i][BCOMP] & 0xf) <<  4)
+                      | ((rgba[i][ACOMP] & 0xf)      );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0xf) << 12)
+                      | ((rgba[i][GCOMP] & 0xf) <<  8)
+                      | ((rgba[i][RCOMP] & 0xf) <<  4)
+                      | ((rgba[i][ACOMP] & 0xf)      );
+            }
+         }
+         else {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0xf) << 12)
+                      | ((rgba[i][BCOMP] & 0xf) <<  8)
+                      | ((rgba[i][GCOMP] & 0xf) <<  4)
+                      | ((rgba[i][RCOMP] & 0xf)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+         if (format == GL_RGBA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0xf) << 12)
+                      | ((rgba[i][BCOMP] & 0xf) <<  8)
+                      | ((rgba[i][GCOMP] & 0xf) <<  4)
+                      | ((rgba[i][RCOMP] & 0xf)      );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0xf) << 12)
+                      | ((rgba[i][RCOMP] & 0xf) <<  8)
+                      | ((rgba[i][GCOMP] & 0xf) <<  4)
+                      | ((rgba[i][BCOMP] & 0xf)      );
+            }
+         }
+         else {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0xf) << 12)
+                      | ((rgba[i][GCOMP] & 0xf) <<  8)
+                      | ((rgba[i][BCOMP] & 0xf) <<  4)
+                      | ((rgba[i][ACOMP] & 0xf)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+         if (format == GL_RGBA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
+                      | ((rgba[i][GCOMP] & 0x1f) <<  6)
+                      | ((rgba[i][BCOMP] & 0x1f) <<  1)
+                      | ((rgba[i][ACOMP] & 0x1)       );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11)
+                      | ((rgba[i][GCOMP] & 0x1f) <<  6)
+                      | ((rgba[i][RCOMP] & 0x1f) <<  1)
+                      | ((rgba[i][ACOMP] & 0x1)       );
+            }
+         }
+         else {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11)
+                      | ((rgba[i][BCOMP] & 0x1f) <<  6)
+                      | ((rgba[i][GCOMP] & 0x1f) <<  1)
+                      | ((rgba[i][RCOMP] & 0x1)       );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+         if (format == GL_RGBA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11)
+                      | ((rgba[i][BCOMP] & 0x1f) <<  6)
+                      | ((rgba[i][GCOMP] & 0x1f) <<  1)
+                      | ((rgba[i][RCOMP] & 0x1)       );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11)
+                      | ((rgba[i][RCOMP] & 0x1f) <<  6)
+                      | ((rgba[i][GCOMP] & 0x1f) <<  1)
+                      | ((rgba[i][BCOMP] & 0x1)       );
+            }
+         }
+         else {
+            GLushort *dst = (GLushort *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11)
+                      | ((rgba[i][GCOMP] & 0x1f) <<  6)
+                      | ((rgba[i][BCOMP] & 0x1f) <<  1)
+                      | ((rgba[i][ACOMP] & 0x1)       );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8:
+         if (format == GL_RGBA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0xff) << 24)
+                      | ((rgba[i][GCOMP] & 0xff) << 16)
+                      | ((rgba[i][BCOMP] & 0xff) <<  8)
+                      | ((rgba[i][ACOMP] & 0xff)      );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0xff) << 24)
+                      | ((rgba[i][GCOMP] & 0xff) << 16)
+                      | ((rgba[i][RCOMP] & 0xff) <<  8)
+                      | ((rgba[i][ACOMP] & 0xff)      );
+            }
+         }
+         else {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0xff) << 24)
+                      | ((rgba[i][BCOMP] & 0xff) << 16)
+                      | ((rgba[i][GCOMP] & 0xff) <<  8)
+                      | ((rgba[i][RCOMP] & 0xff)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+         if (format == GL_RGBA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0xff) << 24)
+                      | ((rgba[i][BCOMP] & 0xff) << 16)
+                      | ((rgba[i][GCOMP] & 0xff) <<  8)
+                      | ((rgba[i][RCOMP] & 0xff)      );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0xff) << 24)
+                      | ((rgba[i][RCOMP] & 0xff) << 16)
+                      | ((rgba[i][GCOMP] & 0xff) <<  8)
+                      | ((rgba[i][BCOMP] & 0xff)      );
+            }
+         }
+         else {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0xff) << 24)
+                      | ((rgba[i][GCOMP] & 0xff) << 16)
+                      | ((rgba[i][BCOMP] & 0xff) <<  8)
+                      | ((rgba[i][ACOMP] & 0xff)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_10_10_10_2:
+         if (format == GL_RGBA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x3ff) << 22)
+                      | ((rgba[i][GCOMP] & 0x3ff) << 12)
+                      | ((rgba[i][BCOMP] & 0x3ff) <<  2)
+                      | ((rgba[i][ACOMP] & 0x3)        );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][BCOMP] & 0x3ff) << 22)
+                      | ((rgba[i][GCOMP] & 0x3ff) << 12)
+                      | ((rgba[i][RCOMP] & 0x3ff) <<  2)
+                      | ((rgba[i][ACOMP] & 0x3)        );
+            }
+         }
+         else {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22)
+                      | ((rgba[i][BCOMP] & 0x3ff) << 12)
+                      | ((rgba[i][GCOMP] & 0x3ff) <<  2)
+                      | ((rgba[i][RCOMP] & 0x3)        );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+         if (format == GL_RGBA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22)
+                      | ((rgba[i][BCOMP] & 0x3ff) << 12)
+                      | ((rgba[i][GCOMP] & 0x3ff) <<  2)
+                      | ((rgba[i][RCOMP] & 0x3)        );
+            }
+         }
+         else if (format == GL_BGRA) {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22)
+                      | ((rgba[i][RCOMP] & 0x3ff) << 12)
+                      | ((rgba[i][GCOMP] & 0x3ff) <<  2)
+                      | ((rgba[i][BCOMP] & 0x3)        );
+            }
+         }
+         else {
+            GLuint *dst = (GLuint *) destination;
+            GLuint i;
+            ASSERT(format == GL_ABGR_EXT);
+            for (i = 0; i < n; i++) {
+               dst[i] = ((rgba[i][RCOMP] & 0x3ff) << 22)
+                      | ((rgba[i][GCOMP] & 0x3ff) << 12)
+                      | ((rgba[i][BCOMP] & 0x3ff) <<  2)
+                      | ((rgba[i][ACOMP] & 0x3)        );
+            }
+         }
+         break;
+      default:
+         _mesa_problem(ctx, "Bad type in pack_histogram");
+   }
+
+#undef PACK_MACRO
+}
+
+
+/*
+ * Given an internalFormat token passed to glHistogram or glMinMax,
+ * return the corresponding base format.
+ * Return -1 if invalid token.
+ */
+static GLint
+base_histogram_format( GLenum format )
+{
+   switch (format) {
+      case GL_ALPHA:
+      case GL_ALPHA4:
+      case GL_ALPHA8:
+      case GL_ALPHA12:
+      case GL_ALPHA16:
+         return GL_ALPHA;
+      case GL_LUMINANCE:
+      case GL_LUMINANCE4:
+      case GL_LUMINANCE8:
+      case GL_LUMINANCE12:
+      case GL_LUMINANCE16:
+         return GL_LUMINANCE;
+      case GL_LUMINANCE_ALPHA:
+      case GL_LUMINANCE4_ALPHA4:
+      case GL_LUMINANCE6_ALPHA2:
+      case GL_LUMINANCE8_ALPHA8:
+      case GL_LUMINANCE12_ALPHA4:
+      case GL_LUMINANCE12_ALPHA12:
+      case GL_LUMINANCE16_ALPHA16:
+         return GL_LUMINANCE_ALPHA;
+      case GL_RGB:
+      case GL_R3_G3_B2:
+      case GL_RGB4:
+      case GL_RGB5:
+      case GL_RGB8:
+      case GL_RGB10:
+      case GL_RGB12:
+      case GL_RGB16:
+         return GL_RGB;
+      case GL_RGBA:
+      case GL_RGBA2:
+      case GL_RGBA4:
+      case GL_RGB5_A1:
+      case GL_RGBA8:
+      case GL_RGB10_A2:
+      case GL_RGBA12:
+      case GL_RGBA16:
+         return GL_RGBA;
+      default:
+         return -1;  /* error */
+   }
+}
+
+
+void
+_mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmax");
+      return;
+   }
+
+   if (target != GL_MINMAX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmax(target)");
+      return;
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmax(format or type)");
+      return;
+   }
+
+   if (type != GL_UNSIGNED_BYTE &&
+       type != GL_BYTE &&
+       type != GL_UNSIGNED_SHORT &&
+       type != GL_SHORT &&
+       type != GL_UNSIGNED_INT &&
+       type != GL_INT &&
+       type != GL_FLOAT &&
+       type != GL_UNSIGNED_BYTE_3_3_2 &&
+       type != GL_UNSIGNED_BYTE_2_3_3_REV &&
+       type != GL_UNSIGNED_SHORT_5_6_5 &&
+       type != GL_UNSIGNED_SHORT_5_6_5_REV &&
+       type != GL_UNSIGNED_SHORT_4_4_4_4 &&
+       type != GL_UNSIGNED_SHORT_4_4_4_4_REV &&
+       type != GL_UNSIGNED_SHORT_5_5_5_1 &&
+       type != GL_UNSIGNED_SHORT_1_5_5_5_REV &&
+       type != GL_UNSIGNED_INT_8_8_8_8 &&
+       type != GL_UNSIGNED_INT_8_8_8_8_REV &&
+       type != GL_UNSIGNED_INT_10_10_10_2 &&
+       type != GL_UNSIGNED_INT_2_10_10_10_REV) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmax(type)");
+      return;
+   }
+
+   if (!values)
+      return;
+
+   {
+      GLfloat minmax[2][4];
+      minmax[0][RCOMP] = CLAMP(ctx->MinMax.Min[RCOMP], 0.0F, 1.0F);
+      minmax[0][GCOMP] = CLAMP(ctx->MinMax.Min[GCOMP], 0.0F, 1.0F);
+      minmax[0][BCOMP] = CLAMP(ctx->MinMax.Min[BCOMP], 0.0F, 1.0F);
+      minmax[0][ACOMP] = CLAMP(ctx->MinMax.Min[ACOMP], 0.0F, 1.0F);
+      minmax[1][RCOMP] = CLAMP(ctx->MinMax.Max[RCOMP], 0.0F, 1.0F);
+      minmax[1][GCOMP] = CLAMP(ctx->MinMax.Max[GCOMP], 0.0F, 1.0F);
+      minmax[1][BCOMP] = CLAMP(ctx->MinMax.Max[BCOMP], 0.0F, 1.0F);
+      minmax[1][ACOMP] = CLAMP(ctx->MinMax.Max[ACOMP], 0.0F, 1.0F);
+      _mesa_pack_float_rgba_span(ctx, 2, (CONST GLfloat (*)[4]) minmax,
+                                 format, type, values, &ctx->Pack, 0);
+   }
+
+   if (reset) {
+      _mesa_ResetMinmax(GL_MINMAX);
+   }
+}
+
+
+void
+_mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogram");
+      return;
+   }
+
+   if (target != GL_HISTOGRAM) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogram(target)");
+      return;
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogram(format or type)");
+      return;
+   }
+
+   if (type != GL_UNSIGNED_BYTE &&
+       type != GL_BYTE &&
+       type != GL_UNSIGNED_SHORT &&
+       type != GL_SHORT &&
+       type != GL_UNSIGNED_INT &&
+       type != GL_INT &&
+       type != GL_FLOAT &&
+       type != GL_UNSIGNED_BYTE_3_3_2 &&
+       type != GL_UNSIGNED_BYTE_2_3_3_REV &&
+       type != GL_UNSIGNED_SHORT_5_6_5 &&
+       type != GL_UNSIGNED_SHORT_5_6_5_REV &&
+       type != GL_UNSIGNED_SHORT_4_4_4_4 &&
+       type != GL_UNSIGNED_SHORT_4_4_4_4_REV &&
+       type != GL_UNSIGNED_SHORT_5_5_5_1 &&
+       type != GL_UNSIGNED_SHORT_1_5_5_5_REV &&
+       type != GL_UNSIGNED_INT_8_8_8_8 &&
+       type != GL_UNSIGNED_INT_8_8_8_8_REV &&
+       type != GL_UNSIGNED_INT_10_10_10_2 &&
+       type != GL_UNSIGNED_INT_2_10_10_10_REV) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogram(type)");
+      return;
+   }
+
+   if (!values)
+      return;
+
+   pack_histogram(ctx, ctx->Histogram.Width,
+                  (CONST GLuint (*)[4]) ctx->Histogram.Count,
+                  format, type, values, &ctx->Pack);
+
+   if (reset) {
+      GLuint i;
+      for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
+         ctx->Histogram.Count[i][0] = 0;
+         ctx->Histogram.Count[i][1] = 0;
+         ctx->Histogram.Count[i][2] = 0;
+         ctx->Histogram.Count[i][3] = 0;
+      }
+   }
+}
+
+
+void
+_mesa_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogramParameterfv");
+      return;
+   }
+
+   if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(target)");
+      return;
+   }
+
+   switch (pname) {
+      case GL_HISTOGRAM_WIDTH:
+         *params = (GLfloat) ctx->Histogram.Width;
+         break;
+      case GL_HISTOGRAM_FORMAT:
+         *params = (GLfloat) ctx->Histogram.Format;
+         break;
+      case GL_HISTOGRAM_RED_SIZE:
+         *params = (GLfloat) ctx->Histogram.RedSize;
+         break;
+      case GL_HISTOGRAM_GREEN_SIZE:
+         *params = (GLfloat) ctx->Histogram.GreenSize;
+         break;
+      case GL_HISTOGRAM_BLUE_SIZE:
+         *params = (GLfloat) ctx->Histogram.BlueSize;
+         break;
+      case GL_HISTOGRAM_ALPHA_SIZE:
+         *params = (GLfloat) ctx->Histogram.AlphaSize;
+         break;
+      case GL_HISTOGRAM_LUMINANCE_SIZE:
+         *params = (GLfloat) ctx->Histogram.LuminanceSize;
+         break;
+      case GL_HISTOGRAM_SINK:
+         *params = (GLfloat) ctx->Histogram.Sink;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(pname)");
+   }
+}
+
+
+void
+_mesa_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogramParameteriv");
+      return;
+   }
+
+   if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(target)");
+      return;
+   }
+
+   switch (pname) {
+      case GL_HISTOGRAM_WIDTH:
+         *params = (GLint) ctx->Histogram.Width;
+         break;
+      case GL_HISTOGRAM_FORMAT:
+         *params = (GLint) ctx->Histogram.Format;
+         break;
+      case GL_HISTOGRAM_RED_SIZE:
+         *params = (GLint) ctx->Histogram.RedSize;
+         break;
+      case GL_HISTOGRAM_GREEN_SIZE:
+         *params = (GLint) ctx->Histogram.GreenSize;
+         break;
+      case GL_HISTOGRAM_BLUE_SIZE:
+         *params = (GLint) ctx->Histogram.BlueSize;
+         break;
+      case GL_HISTOGRAM_ALPHA_SIZE:
+         *params = (GLint) ctx->Histogram.AlphaSize;
+         break;
+      case GL_HISTOGRAM_LUMINANCE_SIZE:
+         *params = (GLint) ctx->Histogram.LuminanceSize;
+         break;
+      case GL_HISTOGRAM_SINK:
+         *params = (GLint) ctx->Histogram.Sink;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(pname)");
+   }
+}
+
+
+void
+_mesa_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmaxParameterfv");
+      return;
+   }
+   if (target != GL_MINMAX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameterfv(target)");
+      return;
+   }
+   if (pname == GL_MINMAX_FORMAT) {
+      *params = (GLfloat) ctx->MinMax.Format;
+   }
+   else if (pname == GL_MINMAX_SINK) {
+      *params = (GLfloat) ctx->MinMax.Sink;
+   }
+   else {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameterfv(pname)");
+   }
+}
+
+
+void
+_mesa_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmaxParameteriv");
+      return;
+   }
+   if (target != GL_MINMAX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameteriv(target)");
+      return;
+   }
+   if (pname == GL_MINMAX_FORMAT) {
+      *params = (GLint) ctx->MinMax.Format;
+   }
+   else if (pname == GL_MINMAX_SINK) {
+      *params = (GLint) ctx->MinMax.Sink;
+   }
+   else {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameteriv(pname)");
+   }
+}
+
+
+void
+_mesa_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink)
+{
+   GLuint i;
+   GLboolean error = GL_FALSE;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* sideeffects */
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glHistogram");
+      return;
+   }
+
+   if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(target)");
+      return;
+   }
+
+   if (width < 0 || width > HISTOGRAM_TABLE_SIZE) {
+      if (target == GL_PROXY_HISTOGRAM) {
+         error = GL_TRUE;
+      }
+      else {
+         if (width < 0)
+            _mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
+         else
+            _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glHistogram(width)");
+         return;
+      }
+   }
+
+   if (width != 0 && _mesa_bitcount(width) != 1) {
+      if (target == GL_PROXY_HISTOGRAM) {
+         error = GL_TRUE;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
+         return;
+      }
+   }
+
+   if (base_histogram_format(internalFormat) < 0) {
+      if (target == GL_PROXY_HISTOGRAM) {
+         error = GL_TRUE;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(internalFormat)");
+         return;
+      }
+   }
+
+   /* reset histograms */
+   for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
+      ctx->Histogram.Count[i][0] = 0;
+      ctx->Histogram.Count[i][1] = 0;
+      ctx->Histogram.Count[i][2] = 0;
+      ctx->Histogram.Count[i][3] = 0;
+   }
+
+   if (error) {
+      ctx->Histogram.Width = 0;
+      ctx->Histogram.Format = 0;
+      ctx->Histogram.RedSize       = 0;
+      ctx->Histogram.GreenSize     = 0;
+      ctx->Histogram.BlueSize      = 0;
+      ctx->Histogram.AlphaSize     = 0;
+      ctx->Histogram.LuminanceSize = 0;
+   }
+   else {
+      ctx->Histogram.Width = width;
+      ctx->Histogram.Format = internalFormat;
+      ctx->Histogram.Sink = sink;
+      ctx->Histogram.RedSize       = 8 * sizeof(GLuint);
+      ctx->Histogram.GreenSize     = 8 * sizeof(GLuint);
+      ctx->Histogram.BlueSize      = 8 * sizeof(GLuint);
+      ctx->Histogram.AlphaSize     = 8 * sizeof(GLuint);
+      ctx->Histogram.LuminanceSize = 8 * sizeof(GLuint);
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glMinmax");
+      return;
+   }
+
+   if (target != GL_MINMAX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glMinMax(target)");
+      return;
+   }
+
+   if (base_histogram_format(internalFormat) < 0) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glMinMax(internalFormat)");
+      return;
+   }
+
+   if (ctx->MinMax.Sink == sink)
+      return;
+   FLUSH_VERTICES(ctx, _NEW_PIXEL);
+   ctx->MinMax.Sink = sink;
+}
+
+
+void
+_mesa_ResetHistogram(GLenum target)
+{
+   GLuint i;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* sideeffects */
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glResetHistogram");
+      return;
+   }
+
+   if (target != GL_HISTOGRAM) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glResetHistogram(target)");
+      return;
+   }
+
+   for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
+      ctx->Histogram.Count[i][0] = 0;
+      ctx->Histogram.Count[i][1] = 0;
+      ctx->Histogram.Count[i][2] = 0;
+      ctx->Histogram.Count[i][3] = 0;
+   }
+
+   ctx->NewState |= _NEW_PIXEL;
+}
+
+
+void
+_mesa_ResetMinmax(GLenum target)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glResetMinmax");
+      return;
+   }
+
+   if (target != GL_MINMAX) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glResetMinMax(target)");
+      return;
+   }
+
+   ctx->MinMax.Min[RCOMP] = 1000;    ctx->MinMax.Max[RCOMP] = -1000;
+   ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
+   ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
+   ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
+   ctx->NewState |= _NEW_PIXEL;
+}
Index: xc/extras/Mesa/src/histogram.h
diff -u /dev/null xc/extras/Mesa/src/histogram.h:1.2
--- /dev/null	Thu Feb 27 12:15:38 2003
+++ xc/extras/Mesa/src/histogram.h	Mon Dec 16 11:18:26 2002
@@ -0,0 +1,67 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef HISTOGRAM_H
+#define HISTOGRAM_H
+
+
+#ifdef PC_HEADER
+#include "all.h"
+#else
+#include "glheader.h"
+#include "mtypes.h"
+#endif
+
+
+
+extern void _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values);
+
+extern void _mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+
+extern void _mesa_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
+
+extern void _mesa_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
+
+extern void _mesa_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
+
+extern void _mesa_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
+
+extern void _mesa_Histogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+
+extern void _mesa_Minmax(GLenum target, GLenum internalformat, GLboolean sink);
+
+extern void _mesa_ResetHistogram(GLenum target);
+
+extern void _mesa_ResetMinmax(GLenum target);
+
+extern void
+_mesa_update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]);
+
+extern void
+_mesa_update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]);
+
+
+#endif
Index: xc/extras/Mesa/src/image.c
diff -u xc/extras/Mesa/src/image.c:1.14 xc/extras/Mesa/src/image.c:1.18
--- xc/extras/Mesa/src/image.c:1.14	Fri May 18 12:59:53 2001
+++ xc/extras/Mesa/src/image.c	Mon Dec 16 11:18:26 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4.1
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -28,14 +28,15 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "image.h"
-#include "imaging.h"
+#include "histogram.h"
 #include "macros.h"
 #include "mem.h"
 #include "mmath.h"
 #include "pixel.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -55,13 +56,20 @@
    0,            /* ImageHeight */
    0,            /* SkipImages */
    GL_FALSE,     /* SwapBytes */
-   GL_FALSE      /* LsbFirst */
+   GL_FALSE,     /* LsbFirst */
+   GL_FALSE,     /* ClientStorage */
+   GL_FALSE      /* Invert */
 };
 
 
 
 /*
  * Flip the 8 bits in each byte of the given array.
+ *
+ * XXX try this trick to flip bytes someday:
+ *  v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
+ *  v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
+ *  v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
  */
 static void
 flip_bytes( GLubyte *p, GLuint n )
@@ -69,7 +77,7 @@
    register GLuint i, a, b;
 
    for (i=0;i<n;i++) {
-      b = (GLuint) p[i];
+      b = (GLuint) p[i];        /* words are often faster than bytes */
       a = ((b & 0x01) << 7) |
 	  ((b & 0x02) << 5) |
 	  ((b & 0x04) << 3) |
@@ -196,6 +204,9 @@
          return sizeof(GLuint);
       case GL_UNSIGNED_INT_2_10_10_10_REV:
          return sizeof(GLuint);
+      case GL_UNSIGNED_SHORT_8_8_MESA:
+      case GL_UNSIGNED_SHORT_8_8_REV_MESA:
+         return sizeof(GLushort);      
       default:
          return -1;
    }
@@ -238,6 +249,8 @@
 	 return 4;
       case GL_ABGR_EXT:
          return 4;
+      case GL_YCBCR_MESA:
+         return 2;
       default:
          return -1;
    }
@@ -296,6 +309,12 @@
             return sizeof(GLuint);
          else
             return -1;
+      case GL_UNSIGNED_SHORT_8_8_MESA:
+      case GL_UNSIGNED_SHORT_8_8_REV_MESA:
+         if (format == GL_YCBCR_MESA)
+            return sizeof(GLushort);
+         else
+            return -1;
       default:
          return -1;
    }
@@ -386,6 +405,12 @@
             default:
                return GL_FALSE;
          }
+      case GL_YCBCR_MESA:
+         if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
+             type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
+            return GL_TRUE;
+         else
+            return GL_FALSE;
       default:
          ; /* fall-through */
    }
@@ -469,6 +494,7 @@
    else {
       /* Non-BITMAP data */
       GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
+      GLint topOfImage;
 
       bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
 
@@ -484,9 +510,19 @@
 
       bytes_per_image = bytes_per_row * rows_per_image;
 
+      if (packing->Invert) {
+         /* set pixel_addr to the last row */
+         topOfImage = bytes_per_row * (height - 1);
+         bytes_per_row = -bytes_per_row;
+      }
+      else {
+         topOfImage = 0;
+      }
+
       /* compute final pixel address */
       pixel_addr = (GLubyte *) image
                  + (skipimages + img) * bytes_per_image
+                 + topOfImage
                  + (skiprows + row) * bytes_per_row
                  + (skippixels + column) * bytes_per_pixel;
    }
@@ -507,14 +543,18 @@
    ASSERT(packing);
    if (type == GL_BITMAP) {
       /* BITMAP data */
+      GLint bytes;
       if (packing->RowLength == 0) {
-         GLint bytes = (width + 7) / 8;
-         return bytes;
+         bytes = (width + 7) / 8;
       }
       else {
-         GLint bytes = (packing->RowLength + 7) / 8;
-         return bytes;
+         bytes = (packing->RowLength + 7) / 8;
+      }
+      if (packing->Invert) {
+         /* negate the bytes per row (negative row stride) */
+         bytes = -bytes;
       }
+      return bytes;
    }
    else {
       /* Non-BITMAP data */
@@ -531,6 +571,8 @@
       remainder = bytesPerRow % packing->Alignment;
       if (remainder > 0)
          bytesPerRow += (packing->Alignment - remainder);
+      if (packing->Invert)
+         bytesPerRow = -bytesPerRow;
       return bytesPerRow;
    }
 }
@@ -589,27 +631,223 @@
 }
 
 
+/*
+ * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
+ * order with row alignment = 1 byte.
+ */
+GLvoid *
+_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
+                     const struct gl_pixelstore_attrib *packing )
+{
+   GLint bytes, row, width_in_bytes;
+   GLubyte *buffer, *dst;
+
+   if (!pixels)
+      return NULL;
+
+   /* Alloc dest storage */
+   bytes = ((width + 7) / 8 * height);
+   buffer = (GLubyte *) MALLOC( bytes );
+   if (!buffer)
+      return NULL;
+
+
+   width_in_bytes = CEILING( width, 8 );
+   dst = buffer;
+   for (row = 0; row < height; row++) {
+      const GLubyte *src = (const GLubyte *)
+         _mesa_image_address(packing, pixels, width, height,
+                             GL_COLOR_INDEX, GL_BITMAP, 0, row, 0);
+      if (!src) {
+         FREE(buffer);
+         return NULL;
+      }
+
+      if (packing->SkipPixels == 0) {
+         MEMCPY( dst, src, width_in_bytes );
+         if (packing->LsbFirst) {
+            flip_bytes( dst, width_in_bytes );
+         }
+      }
+      else {
+         /* handling SkipPixels is a bit tricky (no pun intended!) */
+         GLint i;
+         if (packing->LsbFirst) {
+            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 128) {
+                  srcMask = 1;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask << 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+         else {
+            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 1) {
+                  srcMask = 128;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask >> 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+      }
+      dst += width_in_bytes;
+   }
+
+   return buffer;
+}
+
+
+/*
+ * Pack bitmap data.
+ */
+void
+_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
+                   GLubyte *dest, const struct gl_pixelstore_attrib *packing )
+{
+   GLint row, width_in_bytes;
+   const GLubyte *src;
+
+   if (!source)
+      return;
+
+   width_in_bytes = CEILING( width, 8 );
+   src = source;
+   for (row = 0; row < height; row++) {
+      GLubyte *dst = (GLubyte *) _mesa_image_address( packing, dest,
+                       width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
+      if (!dst)
+         return;
+
+      if (packing->SkipPixels == 0) {
+         MEMCPY( dst, src, width_in_bytes );
+         if (packing->LsbFirst) {
+            flip_bytes( dst, width_in_bytes );
+         }
+      }
+      else {
+         /* handling SkipPixels is a bit tricky (no pun intended!) */
+         GLint i;
+         if (packing->LsbFirst) {
+            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 128) {
+                  srcMask = 1;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask << 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+         else {
+            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 1) {
+                  srcMask = 128;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask >> 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+      }
+      src += width_in_bytes;
+   }
+}
+
 
 
+/*
+ * Used to pack an array [][4] of RGBA GLchan colors as specified
+ * by the dstFormat, dstType and dstPacking.  Used by glReadPixels,
+ * glGetConvolutionFilter(), etc.
+ */
 void
 _mesa_pack_float_rgba_span( GLcontext *ctx,
                             GLuint n, CONST GLfloat rgbaIn[][4],
                             GLenum dstFormat, GLenum dstType,
-                            GLvoid *destination,
+                            GLvoid *dstAddr,
                             const struct gl_pixelstore_attrib *dstPacking,
-                            GLboolean applyTransferOps )
+                            GLuint transferOps )
 {
    const GLint comps = _mesa_components_in_format(dstFormat);
    GLfloat luminance[MAX_WIDTH];
    GLfloat (*rgba)[4];
    GLuint i;
 
-   /*
-    * Apply scale, bias and lookup-tables if enabled.
-    */
-   if (applyTransferOps) {
+   if (transferOps) {
       /* make copy of incoming data */
-      GLfloat rgbaCopy[MAX_WIDTH][4];
+      DEFMARRAY(GLfloat, rgbaCopy, MAX_WIDTH, 4);  /* mac 32k limitation */
+      CHECKARRAY(rgbaCopy, return);  /* mac 32k limitation */
+
       for (i = 0; i < n; i++) {
          rgbaCopy[i][0] = rgbaIn[i][0];
          rgbaCopy[i][1] = rgbaIn[i][1];
@@ -620,51 +858,79 @@
       rgba = (GLfloat (*)[4]) rgbaCopy;
 
       /* scale & bias */
-      if (ctx->Pixel.ScaleOrBiasRGBA) {
-         _mesa_scale_and_bias_rgba( ctx, n, (GLfloat (*)[4]) rgba );
+      if (transferOps & IMAGE_SCALE_BIAS_BIT) {
+         _mesa_scale_and_bias_rgba(ctx, n, rgba,
+                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
+                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
+                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
+                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
       }
       /* color map lookup */
-      if (ctx->Pixel.MapColorFlag) {
+      if (transferOps & IMAGE_MAP_COLOR_BIT) {
          _mesa_map_rgba( ctx, n, rgba );
       }
       /* GL_COLOR_TABLE lookup */
-      if (ctx->Pixel.ColorTableEnabled) {
+      if (transferOps & IMAGE_COLOR_TABLE_BIT) {
          _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
       }
-      /* XXX convolution here */
+      /* convolution */
+      if (transferOps & IMAGE_CONVOLUTION_BIT) {
+         /* this has to be done in the calling code */
+      }
+      /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
+      if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
+         _mesa_scale_and_bias_rgba(ctx, n, rgba,
+                                   ctx->Pixel.PostConvolutionScale[RCOMP],
+                                   ctx->Pixel.PostConvolutionScale[GCOMP],
+                                   ctx->Pixel.PostConvolutionScale[BCOMP],
+                                   ctx->Pixel.PostConvolutionScale[ACOMP],
+                                   ctx->Pixel.PostConvolutionBias[RCOMP],
+                                   ctx->Pixel.PostConvolutionBias[GCOMP],
+                                   ctx->Pixel.PostConvolutionBias[BCOMP],
+                                   ctx->Pixel.PostConvolutionBias[ACOMP]);
+      }
       /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
-      if (ctx->Pixel.PostConvolutionColorTableEnabled) {
+      if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
          _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
       }
       /* color matrix transform */
-      if (ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-          ctx->Pixel.ScaleOrBiasRGBApcm) {
+      if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
          _mesa_transform_rgba(ctx, n, rgba);
       }
       /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
-      if (ctx->Pixel.PostColorMatrixColorTableEnabled) {
+      if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
          _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
       }
       /* update histogram count */
-      if (ctx->Pixel.HistogramEnabled) {
+      if (transferOps & IMAGE_HISTOGRAM_BIT) {
          _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
       }
-      /* XXX min/max here */
-      if (ctx->Pixel.MinMaxEnabled) {
+      /* min/max here */
+      if (transferOps & IMAGE_MIN_MAX_BIT) {
          _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
-         if (ctx->MinMax.Sink)
+         if (ctx->MinMax.Sink) {
+            UNDEFARRAY(rgbaCopy);  /* mac 32k limitation */
             return;
+         }
       }
+      UNDEFARRAY(rgbaCopy);  /* mac 32k limitation */
    }
    else {
       /* use incoming data, not a copy */
       rgba = (GLfloat (*)[4]) rgbaIn;
    }
 
+   /* XXX clamp rgba to [0,1]? */
+
+
    if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
-      for (i=0;i<n;i++) {
+      for (i = 0; i < n; i++) {
          GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
-         luminance[i] = CLAMP( sum, 0.0F, 1.0F );
+#if CHAN_TYPE == GL_FLOAT
+         luminance[i] = sum;
+#else
+         luminance[i] = CLAMP(sum, 0.0F, 1.0F);
+#endif
       }
    }
 
@@ -674,7 +940,7 @@
    switch (dstType) {
       case GL_UNSIGNED_BYTE:
          {
-            GLubyte *dst = (GLubyte *) destination;
+            GLubyte *dst = (GLubyte *) dstAddr;
             switch (dstFormat) {
                case GL_RED:
                   for (i=0;i<n;i++)
@@ -741,13 +1007,13 @@
                   }
                   break;
                default:
-                  gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
          }
          break;
       case GL_BYTE:
          {
-            GLbyte *dst = (GLbyte *) destination;
+            GLbyte *dst = (GLbyte *) dstAddr;
             switch (dstFormat) {
                case GL_RED:
                   for (i=0;i<n;i++)
@@ -813,13 +1079,13 @@
                   }
                   break;
                default:
-                  gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
          }
          break;
       case GL_UNSIGNED_SHORT:
          {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             switch (dstFormat) {
                case GL_RED:
                   for (i=0;i<n;i++)
@@ -886,7 +1152,7 @@
                   }
                   break;
                default:
-                  gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
             if (dstPacking->SwapBytes) {
                _mesa_swap2( (GLushort *) dst, n * comps);
@@ -895,7 +1161,7 @@
          break;
       case GL_SHORT:
          {
-            GLshort *dst = (GLshort *) destination;
+            GLshort *dst = (GLshort *) dstAddr;
             switch (dstFormat) {
                case GL_RED:
                   for (i=0;i<n;i++)
@@ -961,7 +1227,7 @@
                   }
                   break;
                default:
-                  gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
             if (dstPacking->SwapBytes) {
                _mesa_swap2( (GLushort *) dst, n * comps );
@@ -970,7 +1236,7 @@
          break;
       case GL_UNSIGNED_INT:
          {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             switch (dstFormat) {
                case GL_RED:
                   for (i=0;i<n;i++)
@@ -1037,7 +1303,7 @@
                   }
                   break;
                default:
-                  gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
             if (dstPacking->SwapBytes) {
                _mesa_swap4( (GLuint *) dst, n * comps );
@@ -1046,7 +1312,7 @@
          break;
       case GL_INT:
          {
-            GLint *dst = (GLint *) destination;
+            GLint *dst = (GLint *) dstAddr;
             switch (dstFormat) {
                case GL_RED:
                   for (i=0;i<n;i++)
@@ -1113,7 +1379,7 @@
                   }
                   break;
                default:
-                  gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
             if (dstPacking->SwapBytes) {
                _mesa_swap4( (GLuint *) dst, n * comps );
@@ -1122,7 +1388,7 @@
          break;
       case GL_FLOAT:
          {
-            GLfloat *dst = (GLfloat *) destination;
+            GLfloat *dst = (GLfloat *) dstAddr;
             switch (dstFormat) {
                case GL_RED:
                   for (i=0;i<n;i++)
@@ -1189,7 +1455,7 @@
                   }
                   break;
                default:
-                  gl_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
             if (dstPacking->SwapBytes) {
                _mesa_swap4( (GLuint *) dst, n * comps );
@@ -1198,7 +1464,7 @@
          break;
       case GL_UNSIGNED_BYTE_3_3_2:
          if (dstFormat == GL_RGB) {
-            GLubyte *dst = (GLubyte *) destination;
+            GLubyte *dst = (GLubyte *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
                       | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
@@ -1208,7 +1474,7 @@
          break;
       case GL_UNSIGNED_BYTE_2_3_3_REV:
          if (dstFormat == GL_RGB) {
-            GLubyte *dst = (GLubyte *) destination;
+            GLubyte *dst = (GLubyte *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F))     )
                       | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
@@ -1218,7 +1484,7 @@
          break;
       case GL_UNSIGNED_SHORT_5_6_5:
          if (dstFormat == GL_RGB) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
                       | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
@@ -1228,7 +1494,7 @@
          break;
       case GL_UNSIGNED_SHORT_5_6_5_REV:
          if (dstFormat == GL_RGB) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
                       | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
@@ -1238,7 +1504,7 @@
          break;
       case GL_UNSIGNED_SHORT_4_4_4_4:
          if (dstFormat == GL_RGBA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
@@ -1247,7 +1513,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
@@ -1256,7 +1522,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) <<  4)
                       | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  8)
@@ -1267,7 +1533,7 @@
          break;
       case GL_UNSIGNED_SHORT_4_4_4_4_REV:
          if (dstFormat == GL_RGBA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F))      )
                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
@@ -1276,7 +1542,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F))      )
                       | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
@@ -1285,7 +1551,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F))      )
                       | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  4)
@@ -1296,7 +1562,7 @@
          break;
       case GL_UNSIGNED_SHORT_5_5_5_1:
          if (dstFormat == GL_RGBA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
@@ -1305,7 +1571,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
@@ -1314,7 +1580,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
                       | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  6)
@@ -1325,7 +1591,7 @@
          break;
       case GL_UNSIGNED_SHORT_1_5_5_5_REV:
          if (dstFormat == GL_RGBA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
@@ -1334,7 +1600,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F))      )
                       | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
@@ -1343,7 +1609,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLushort *dst = (GLushort *) destination;
+            GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F))      )
                       | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  5)
@@ -1354,7 +1620,7 @@
          break;
       case GL_UNSIGNED_INT_8_8_8_8:
          if (dstFormat == GL_RGBA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
@@ -1363,7 +1629,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
@@ -1372,7 +1638,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
                       | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
@@ -1383,7 +1649,7 @@
          break;
       case GL_UNSIGNED_INT_8_8_8_8_REV:
          if (dstFormat == GL_RGBA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F))      )
                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
@@ -1392,7 +1658,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F))      )
                       | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
@@ -1401,7 +1667,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F))      )
                       | (((GLuint) (rgba[i][BCOMP] * 255.0F)) <<  8)
@@ -1412,7 +1678,7 @@
          break;
       case GL_UNSIGNED_INT_10_10_10_2:
          if (dstFormat == GL_RGBA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
@@ -1421,7 +1687,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
@@ -1430,7 +1696,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
                       | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
@@ -1441,7 +1707,7 @@
          break;
       case GL_UNSIGNED_INT_2_10_10_10_REV:
          if (dstFormat == GL_RGBA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F))      )
                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
@@ -1450,7 +1716,7 @@
             }
          }
          else if (dstFormat == GL_BGRA) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F))      )
                       | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
@@ -1459,7 +1725,7 @@
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
-            GLuint *dst = (GLuint *) destination;
+            GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
                dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F))      )
                       | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
@@ -1469,7 +1735,7 @@
          }
          break;
       default:
-         gl_problem( ctx, "bad type in _mesa_pack_rgba_rgba_span" );
+         _mesa_problem(ctx, "bad type in _mesa_pack_float_rgba_span");
    }
 }
 
@@ -1488,34 +1754,27 @@
  *         type - dest packing datatype
  *         destination - destination packing address
  *         packing - pixel packing parameters
- *         applyTransferOps - apply scale/bias/lookup-table ops?
+ *         transferOps - bitmask of IMAGE_*_BIT operations to apply
  */
 void
 _mesa_pack_rgba_span( GLcontext *ctx,
-                      GLuint n, CONST GLubyte srcRgba[][4],
-                      GLenum format, GLenum type, GLvoid *destination,
-                      const struct gl_pixelstore_attrib *packing,
-                      GLboolean applyTransferOps )
-{
-   applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA ||
-                        ctx->Pixel.MapColorFlag ||
-                        ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-                        ctx->Pixel.ScaleOrBiasRGBApcm ||
-                        ctx->Pixel.ColorTableEnabled ||
-                        ctx->Pixel.PostColorMatrixColorTableEnabled ||
-                        ctx->Pixel.PostConvolutionColorTableEnabled ||
-                        ctx->Pixel.MinMaxEnabled ||
-                        ctx->Pixel.HistogramEnabled);
+                      GLuint n, CONST GLchan srcRgba[][4],
+                      GLenum dstFormat, GLenum dstType,
+                      GLvoid *dstAddr,
+                      const struct gl_pixelstore_attrib *dstPacking,
+                      GLuint transferOps)
+{
+   ASSERT((ctx->NewState & _NEW_PIXEL) == 0 || transferOps == 0);
 
    /* Test for optimized case first */
-   if (!applyTransferOps && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
+   if (transferOps == 0 && dstFormat == GL_RGBA && dstType == CHAN_TYPE) {
       /* common simple case */
-      MEMCPY( destination, srcRgba, n * 4 * sizeof(GLubyte) );
+      MEMCPY(dstAddr, srcRgba, n * 4 * sizeof(GLchan));
    }
-   else if (!applyTransferOps && format == GL_RGB && type == GL_UNSIGNED_BYTE) {
+   else if (transferOps == 0 && dstFormat == GL_RGB && dstType == CHAN_TYPE) {
       /* common simple case */
       GLuint i;
-      GLubyte *dest = (GLubyte *) destination;
+      GLchan *dest = (GLchan *) dstAddr;
       for (i = 0; i < n; i++) {
          dest[0] = srcRgba[i][RCOMP];
          dest[1] = srcRgba[i][GCOMP];
@@ -1523,33 +1782,40 @@
          dest += 3;
       }
    }
+   else if (transferOps == 0 && dstFormat == GL_RGBA && dstType == GL_UNSIGNED_BYTE) {
+      /* common simple case */
+      GLuint i;
+      GLubyte *dest = (GLubyte *) dstAddr;
+      for (i = 0; i < n; i++) {
+         dest[0] = CHAN_TO_UBYTE(srcRgba[i][RCOMP]);
+         dest[1] = CHAN_TO_UBYTE(srcRgba[i][GCOMP]);
+         dest[2] = CHAN_TO_UBYTE(srcRgba[i][BCOMP]);
+         dest[3] = CHAN_TO_UBYTE(srcRgba[i][ACOMP]);
+         dest += 4;
+      }
+   }
    else {
       /* general solution */
-      GLfloat rgba[MAX_WIDTH][4];
-      const GLfloat rscale = 1.0F / 255.0F;
-      const GLfloat gscale = 1.0F / 255.0F;
-      const GLfloat bscale = 1.0F / 255.0F;
-      const GLfloat ascale = 1.0F / 255.0F;
       GLuint i;
+      DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
+      CHECKARRAY(rgba, return);  /* mac 32k limitation */
 
       assert(n <= MAX_WIDTH);
-
       /* convert color components to floating point */
       for (i=0;i<n;i++) {
-         rgba[i][RCOMP] = srcRgba[i][RCOMP] * rscale;
-         rgba[i][GCOMP] = srcRgba[i][GCOMP] * gscale;
-         rgba[i][BCOMP] = srcRgba[i][BCOMP] * bscale;
-         rgba[i][ACOMP] = srcRgba[i][ACOMP] * ascale;
+         rgba[i][RCOMP] = CHAN_TO_FLOAT(srcRgba[i][RCOMP]);
+         rgba[i][GCOMP] = CHAN_TO_FLOAT(srcRgba[i][GCOMP]);
+         rgba[i][BCOMP] = CHAN_TO_FLOAT(srcRgba[i][BCOMP]);
+         rgba[i][ACOMP] = CHAN_TO_FLOAT(srcRgba[i][ACOMP]);
       }
-
       _mesa_pack_float_rgba_span(ctx, n, (const GLfloat (*)[4]) rgba,
-                                 format, type, destination,
-                                 packing, applyTransferOps);
+                                 dstFormat, dstType, dstAddr,
+                                 dstPacking, transferOps);
+      UNDEFARRAY(rgba);  /* mac 32k limitation */
    }
 }
 
 
-
 #define SWAP2BYTE(VALUE)			\
    {						\
       GLubyte *bytes = (GLubyte *) &(VALUE);	\
@@ -1722,7 +1988,7 @@
          }
          break;
       default:
-         gl_problem(NULL, "bad srcType in extract_uint_indexes");
+         _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
          return;
    }
 }
@@ -1872,7 +2138,7 @@
          stride = 4;
          break;
       default:
-         gl_problem(NULL, "bad srcFormat in extract float data");
+         _mesa_problem(NULL, "bad srcFormat in extract float data");
          return;
    }
 
@@ -2133,10 +2399,10 @@
             GLuint i;
             for (i = 0; i < n; i ++) {
                GLuint p = uisrc[i];
-               rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
-               rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
-               rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
-               rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       );
+               rgba[i][rComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
+               rgba[i][gComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+               rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+               rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24)       );
             }
          }
          else {
@@ -2144,10 +2410,10 @@
             GLuint i;
             for (i = 0; i < n; i ++) {
                GLuint p = uisrc[i];
-               rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       );
-               rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
-               rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
-               rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
+               rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24)       );
+               rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+               rgba[i][bComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+               rgba[i][aComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
             }
          }
          break;
@@ -2157,10 +2423,10 @@
             GLuint i;
             for (i = 0; i < n; i ++) {
                GLuint p = uisrc[i];
-               rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       );
-               rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
-               rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
-               rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
+               rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24)       );
+               rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+               rgba[i][bComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+               rgba[i][aComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
             }
          }
          else {
@@ -2168,10 +2434,10 @@
             GLuint i;
             for (i = 0; i < n; i ++) {
                GLuint p = uisrc[i];
-               rgba[i][rComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p      ) & 0xff);
-               rgba[i][gComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >>  8) & 0xff);
-               rgba[i][bComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 16) & 0xff);
-               rgba[i][aComp] = UBYTE_COLOR_TO_FLOAT_COLOR((p >> 24)       );
+               rgba[i][rComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
+               rgba[i][gComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+               rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+               rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24)       );
             }
          }
          break;
@@ -2226,7 +2492,7 @@
          }
          break;
       default:
-         gl_problem(NULL, "bad srcType in extract float data");
+         _mesa_problem(NULL, "bad srcType in extract float data");
          break;
    }
 }
@@ -2235,8 +2501,7 @@
 
 /*
  * Unpack a row of color image data from a client buffer according to
- * the pixel unpacking parameters.  Apply any enabled pixel transfer
- * ops (PixelMap, scale/bias) if the applyTransferOps flag is enabled.
+ * the pixel unpacking parameters.
  * Return GLubyte values in the specified dest image format.
  * This is (or will be) used by glDrawPixels and glTexImage?D().
  * Input:  ctx - the context
@@ -2246,18 +2511,18 @@
  *         srcFormat - source image format
  *         srcType - source image  datatype
  *         source - source image pointer
- *         unpacking - pixel unpacking parameters
- *         applyTransferOps - apply scale/bias/lookup-table ops?
+ *         srcPacking - pixel unpacking parameters
+ *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply
  *
  * XXX perhaps expand this to process whole images someday.
  */
 void
-_mesa_unpack_ubyte_color_span( GLcontext *ctx,
-                               GLuint n, GLenum dstFormat, GLubyte dest[],
-                               GLenum srcFormat, GLenum srcType,
-                               const GLvoid *source,
-                               const struct gl_pixelstore_attrib *unpacking,
-                               GLboolean applyTransferOps )
+_mesa_unpack_chan_color_span( GLcontext *ctx,
+                              GLuint n, GLenum dstFormat, GLchan dest[],
+                              GLenum srcFormat, GLenum srcType,
+                              const GLvoid *source,
+                              const struct gl_pixelstore_attrib *srcPacking,
+                              GLuint transferOps )
 {
    ASSERT(dstFormat == GL_ALPHA ||
           dstFormat == GL_LUMINANCE ||
@@ -2302,72 +2567,129 @@
           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
           srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
 
-   applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA ||
-                        ctx->Pixel.MapColorFlag ||
-                        ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-                        ctx->Pixel.ScaleOrBiasRGBApcm ||
-                        ctx->Pixel.ColorTableEnabled ||
-                        ctx->Pixel.PostColorMatrixColorTableEnabled ||
-                        ctx->Pixel.PostConvolutionColorTableEnabled ||
-                        ctx->Pixel.MinMaxEnabled ||
-                        ctx->Pixel.HistogramEnabled);
-
    /* Try simple cases first */
-   if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE) {
-      if (dstFormat == GL_RGBA) {
-         if (srcFormat == GL_RGBA) {
-            MEMCPY( dest, source, n * 4 * sizeof(GLubyte) );
-            return;
-         }
-         else if (srcFormat == GL_RGB) {
-            GLuint i;
-            const GLubyte *src = (const GLubyte *) source;
-            GLubyte *dst = dest;
-            for (i = 0; i < n; i++) {
-               dst[0] = src[0];
-               dst[1] = src[1];
-               dst[2] = src[2];
-               dst[3] = 255;
-               src += 3;
-               dst += 4;
+   if (transferOps == 0 ){
+      if (srcType == CHAN_TYPE) {
+         if (dstFormat == GL_RGBA) {
+            if (srcFormat == GL_RGBA) {
+               MEMCPY( dest, source, n * 4 * sizeof(GLchan) );
+               return;
             }
-            return;
+            else if (srcFormat == GL_RGB) {
+               GLuint i;
+               const GLchan *src = (const GLchan *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = src[0];
+                  dst[1] = src[1];
+                  dst[2] = src[2];
+                  dst[3] = CHAN_MAX;
+                  src += 3;
+                  dst += 4;
+               }
+               return;
+            }
+         }
+         else if (dstFormat == GL_RGB) {
+            if (srcFormat == GL_RGB) {
+               MEMCPY( dest, source, n * 3 * sizeof(GLchan) );
+               return;
+            }
+            else if (srcFormat == GL_RGBA) {
+               GLuint i;
+               const GLchan *src = (const GLchan *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = src[0];
+                  dst[1] = src[1];
+                  dst[2] = src[2];
+                  src += 4;
+                  dst += 3;
+               }
+               return;
+            }
          }
-      }
-      else if (dstFormat == GL_RGB) {
-         if (srcFormat == GL_RGB) {
-            MEMCPY( dest, source, n * 3 * sizeof(GLubyte) );
+         else if (dstFormat == srcFormat) {
+            GLint comps = _mesa_components_in_format(srcFormat);
+            assert(comps > 0);
+            MEMCPY( dest, source, n * comps * sizeof(GLchan) );
             return;
          }
-         else if (srcFormat == GL_RGBA) {
-            GLuint i;
-            const GLubyte *src = (const GLubyte *) source;
-            GLubyte *dst = dest;
-            for (i = 0; i < n; i++) {
-               dst[0] = src[0];
-               dst[1] = src[1];
-               dst[2] = src[2];
-               src += 4;
-               dst += 3;
+      }
+      /*
+       * Common situation, loading 8bit RGBA/RGB source images
+       * into 16/32 bit destination. (OSMesa16/32)
+       */
+      else if (srcType == GL_UNSIGNED_BYTE) {
+         if (dstFormat == GL_RGBA) {
+            if (srcFormat == GL_RGB) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  dst[3] = CHAN_MAX;
+                  src += 3;
+                  dst += 4;
+               }
+               return;
             }
-            return;
+            else if (srcFormat == GL_RGBA) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  dst[3] = UBYTE_TO_CHAN(src[3]);
+                  src += 4;
+                  dst += 4;
+               }
+               return;
+             }
          }
-      }
-      else if (dstFormat == srcFormat) {
-         GLint comps = _mesa_components_in_format(srcFormat);
-         assert(comps > 0);
-         MEMCPY( dest, source, n * comps * sizeof(GLubyte) );
-         return;
-      }
-   }
-
-
+         else if (dstFormat == GL_RGB) {
+            if (srcFormat == GL_RGB) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  src += 3;
+                  dst += 3;
+               }
+               return;
+            }
+            else if (srcFormat == GL_RGBA) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  src += 4;
+                  dst += 3;
+               }
+               return;
+            }
+         }
+      }
+   }
+
+
    /* general solution begins here */
    {
-      GLfloat rgba[MAX_WIDTH][4];
       GLint dstComponents;
       GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
       GLint dstLuminanceIndex, dstIntensityIndex;
+      DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
+      CHECKARRAY(rgba, return);  /* mac 32k limitation */
 
       dstComponents = _mesa_components_in_format( dstFormat );
       /* source & dest image formats should have been error checked by now */
@@ -2380,23 +2702,23 @@
       if (srcFormat == GL_COLOR_INDEX) {
          GLuint indexes[MAX_WIDTH];
          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
-                              unpacking);
+                              srcPacking);
 
-         if (applyTransferOps) {
-            if (dstFormat == GL_COLOR_INDEX && ctx->Pixel.MapColorFlag) {
-               _mesa_map_ci(ctx, n, indexes);
-            }
-            if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
-               _mesa_shift_and_offset_ci(ctx, n, indexes);
-            }
+         if (dstFormat == GL_COLOR_INDEX
+             && (transferOps & IMAGE_MAP_COLOR_BIT)) {
+            _mesa_map_ci(ctx, n, indexes);
          }
+         if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
+            _mesa_shift_and_offset_ci(ctx, n, indexes);
+         }
 
          if (dstFormat == GL_COLOR_INDEX) {
-            /* convert to GLubyte and return */
+            /* convert to GLchan and return */
             GLuint i;
             for (i = 0; i < n; i++) {
-               dest[i] = (GLubyte) (indexes[i] & 0xff);
+               dest[i] = (GLchan) (indexes[i] & 0xff);
             }
+            UNDEFARRAY(rgba);  /* mac 32k limitation */
             return;
          }
          else {
@@ -2406,50 +2728,67 @@
       }
       else {
          extract_float_rgba(n, rgba, srcFormat, srcType, source,
-                            unpacking->SwapBytes);
+                            srcPacking->SwapBytes);
 
-         if (applyTransferOps) {
-            /* scale and bias colors */
-            if (ctx->Pixel.ScaleOrBiasRGBA) {
-               _mesa_scale_and_bias_rgba(ctx, n, rgba);
-            }
-            /* color map lookup */
-            if (ctx->Pixel.MapColorFlag) {
-               _mesa_map_rgba(ctx, n, rgba);
-            }
+         /* scale and bias colors */
+         if (transferOps & IMAGE_SCALE_BIAS_BIT) {
+            _mesa_scale_and_bias_rgba(ctx, n, rgba,
+                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
+                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
+                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
+                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
+         }
+         /* color map lookup */
+         if (transferOps & IMAGE_MAP_COLOR_BIT) {
+            _mesa_map_rgba(ctx, n, rgba);
          }
       }
 
-      if (applyTransferOps) {
+      if (transferOps) {
          /* GL_COLOR_TABLE lookup */
-         if (ctx->Pixel.ColorTableEnabled) {
+         if (transferOps & IMAGE_COLOR_TABLE_BIT) {
             _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
+         }
+         /* convolution */
+         if (transferOps & IMAGE_CONVOLUTION_BIT) {
+            /* this has to be done in the calling code */
+         }
+         /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
+         if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
+            _mesa_scale_and_bias_rgba(ctx, n, rgba,
+                                      ctx->Pixel.PostConvolutionScale[RCOMP],
+                                      ctx->Pixel.PostConvolutionScale[GCOMP],
+                                      ctx->Pixel.PostConvolutionScale[BCOMP],
+                                      ctx->Pixel.PostConvolutionScale[ACOMP],
+                                      ctx->Pixel.PostConvolutionBias[RCOMP],
+                                      ctx->Pixel.PostConvolutionBias[GCOMP],
+                                      ctx->Pixel.PostConvolutionBias[BCOMP],
+                                      ctx->Pixel.PostConvolutionBias[ACOMP]);
          }
-         /* XXX convolution here */
          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
-         if (ctx->Pixel.PostConvolutionColorTableEnabled) {
+         if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
             _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
          }
          /* color matrix transform */
-         if (ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-             ctx->Pixel.ScaleOrBiasRGBApcm) {
+         if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
             _mesa_transform_rgba(ctx, n, rgba);
          }
          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
-         if (ctx->Pixel.PostColorMatrixColorTableEnabled) {
+         if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
             _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
          }
          /* update histogram count */
-         if (ctx->Pixel.HistogramEnabled) {
+         if (transferOps & IMAGE_HISTOGRAM_BIT) {
             _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
          }
-         /* XXX min/max here */
-         if (ctx->Pixel.MinMaxEnabled) {
+         /* min/max here */
+         if (transferOps & IMAGE_MIN_MAX_BIT) {
             _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
          }
       }
 
       /* clamp to [0,1] */
+#if CHAN_TYPE != GL_FLOAT
       {
          GLuint i;
          for (i = 0; i < n; i++) {
@@ -2459,6 +2798,7 @@
             rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
          }
       }
+#endif
 
       /* Now determine which color channels we need to produce.
        * And determine the dest index (offset) within each color tuple.
@@ -2499,70 +2839,72 @@
             dstLuminanceIndex = dstIntensityIndex = -1;
             break;
          default:
-            gl_problem(ctx, "bad dstFormat in _mesa_unpack_ubyte_span()");
+            _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
+            UNDEFARRAY(rgba);  /* mac 32k limitation */
             return;
       }
 
 
-      /* Now return the GLubyte data in the requested dstFormat */
+      /* Now return the GLchan data in the requested dstFormat */
 
       if (dstRedIndex >= 0) {
-         GLubyte *dst = dest;
+         GLchan *dst = dest;
          GLuint i;
          for (i = 0; i < n; i++) {
-            dst[dstRedIndex] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+            CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]);
             dst += dstComponents;
          }
       }
 
       if (dstGreenIndex >= 0) {
-         GLubyte *dst = dest;
+         GLchan *dst = dest;
          GLuint i;
          for (i = 0; i < n; i++) {
-            dst[dstGreenIndex] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+            CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]);
             dst += dstComponents;
          }
       }
 
       if (dstBlueIndex >= 0) {
-         GLubyte *dst = dest;
+         GLchan *dst = dest;
          GLuint i;
          for (i = 0; i < n; i++) {
-            dst[dstBlueIndex] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
+            CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]);
             dst += dstComponents;
          }
       }
 
       if (dstAlphaIndex >= 0) {
-         GLubyte *dst = dest;
+         GLchan *dst = dest;
          GLuint i;
          for (i = 0; i < n; i++) {
-            dst[dstAlphaIndex] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
+            CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]);
             dst += dstComponents;
          }
       }
 
       if (dstIntensityIndex >= 0) {
-         GLubyte *dst = dest;
+         GLchan *dst = dest;
          GLuint i;
          assert(dstIntensityIndex == 0);
          assert(dstComponents == 1);
          for (i = 0; i < n; i++) {
             /* Intensity comes from red channel */
-            dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+            CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
          }
       }
 
       if (dstLuminanceIndex >= 0) {
-         GLubyte *dst = dest;
+         GLchan *dst = dest;
          GLuint i;
          assert(dstLuminanceIndex == 0);
          for (i = 0; i < n; i++) {
             /* Luminance comes from red channel */
-            dst[0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+            CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
             dst += dstComponents;
          }
       }
+      UNDEFARRAY(rgba);  /* mac 32k limitation */
    }
 }
 
@@ -2572,8 +2914,8 @@
                                GLuint n, GLenum dstFormat, GLfloat dest[],
                                GLenum srcFormat, GLenum srcType,
                                const GLvoid *source,
-                               const struct gl_pixelstore_attrib *unpacking,
-                               GLboolean applyTransferOps, GLboolean clamp )
+                               const struct gl_pixelstore_attrib *srcPacking,
+                               GLuint transferOps, GLboolean clamp )
 {
    ASSERT(dstFormat == GL_ALPHA ||
           dstFormat == GL_LUMINANCE ||
@@ -2618,25 +2960,13 @@
           srcType == GL_UNSIGNED_INT_10_10_10_2 ||
           srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
 
-   /* this is intended for RGBA mode only */
-   assert(ctx->Visual->RGBAflag);
-
-   applyTransferOps &= (ctx->Pixel.ScaleOrBiasRGBA ||
-                        ctx->Pixel.MapColorFlag ||
-                        ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-                        ctx->Pixel.ScaleOrBiasRGBApcm ||
-                        ctx->Pixel.ColorTableEnabled ||
-                        ctx->Pixel.PostColorMatrixColorTableEnabled ||
-                        ctx->Pixel.PostConvolutionColorTableEnabled ||
-                        ctx->Pixel.MinMaxEnabled ||
-                        ctx->Pixel.HistogramEnabled);
-
    /* general solution, no special cases, yet */
    {
-      GLfloat rgba[MAX_WIDTH][4];
       GLint dstComponents;
       GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
       GLint dstLuminanceIndex, dstIntensityIndex;
+      DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
+      CHECKARRAY(rgba, return);  /* mac 32k limitation */
 
       dstComponents = _mesa_components_in_format( dstFormat );
       /* source & dest image formats should have been error checked by now */
@@ -2649,23 +2979,23 @@
       if (srcFormat == GL_COLOR_INDEX) {
          GLuint indexes[MAX_WIDTH];
          extract_uint_indexes(n, indexes, srcFormat, srcType, source,
-                              unpacking);
+                              srcPacking);
 
-         if (applyTransferOps) {
-            if (dstFormat == GL_COLOR_INDEX && ctx->Pixel.MapColorFlag) {
-               _mesa_map_ci(ctx, n, indexes);
-            }
-            if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
-               _mesa_shift_and_offset_ci(ctx, n, indexes);
-            }
+         if (dstFormat == GL_COLOR_INDEX
+             && (transferOps & IMAGE_MAP_COLOR_BIT)) {
+            _mesa_map_ci(ctx, n, indexes);
          }
+         if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
+            _mesa_shift_and_offset_ci(ctx, n, indexes);
+         }
 
          if (dstFormat == GL_COLOR_INDEX) {
-            /* convert to GLubyte and return */
+            /* convert to GLchan and return */
             GLuint i;
             for (i = 0; i < n; i++) {
-               dest[i] = (GLubyte) (indexes[i] & 0xff);
+               dest[i] = (GLchan) (indexes[i] & 0xff);
             }
+            UNDEFARRAY(rgba);  /* mac 32k limitation */
             return;
          }
          else {
@@ -2675,50 +3005,67 @@
       }
       else {
          extract_float_rgba(n, rgba, srcFormat, srcType, source,
-                            unpacking->SwapBytes);
+                            srcPacking->SwapBytes);
 
-         if (applyTransferOps) {
-            /* scale and bias colors */
-            if (ctx->Pixel.ScaleOrBiasRGBA) {
-               _mesa_scale_and_bias_rgba(ctx, n, rgba);
-            }
-            /* color map lookup */
-            if (ctx->Pixel.MapColorFlag) {
-               _mesa_map_rgba(ctx, n, rgba);
-            }
+         /* scale and bias colors */
+         if (transferOps & IMAGE_SCALE_BIAS_BIT) {
+            _mesa_scale_and_bias_rgba(ctx, n, rgba,
+                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
+                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
+                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
+                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
          }
+         /* color map lookup */
+         if (transferOps & IMAGE_MAP_COLOR_BIT) {
+            _mesa_map_rgba(ctx, n, rgba);
+         }
       }
 
-      if (applyTransferOps) {
+      if (transferOps) {
          /* GL_COLOR_TABLE lookup */
-         if (ctx->Pixel.ColorTableEnabled) {
+         if (transferOps & IMAGE_COLOR_TABLE_BIT) {
             _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
+         }
+         /* convolution */
+         if (transferOps & IMAGE_CONVOLUTION_BIT) {
+            /* XXX to do */
+         }
+         /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
+         if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
+            _mesa_scale_and_bias_rgba(ctx, n, rgba,
+                                      ctx->Pixel.PostConvolutionScale[RCOMP],
+                                      ctx->Pixel.PostConvolutionScale[GCOMP],
+                                      ctx->Pixel.PostConvolutionScale[BCOMP],
+                                      ctx->Pixel.PostConvolutionScale[ACOMP],
+                                      ctx->Pixel.PostConvolutionBias[RCOMP],
+                                      ctx->Pixel.PostConvolutionBias[GCOMP],
+                                      ctx->Pixel.PostConvolutionBias[BCOMP],
+                                      ctx->Pixel.PostConvolutionBias[ACOMP]);
          }
-         /* XXX convolution here */
          /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
-         if (ctx->Pixel.PostConvolutionColorTableEnabled) {
+         if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
             _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
          }
          /* color matrix transform */
-         if (ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-             ctx->Pixel.ScaleOrBiasRGBApcm) {
+         if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
             _mesa_transform_rgba(ctx, n, rgba);
          }
          /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
-         if (ctx->Pixel.PostColorMatrixColorTableEnabled) {
+         if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
             _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
          }
          /* update histogram count */
-         if (ctx->Pixel.HistogramEnabled) {
+         if (transferOps & IMAGE_HISTOGRAM_BIT) {
             _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
          }
-         /* XXX min/max here */
-         if (ctx->Pixel.MinMaxEnabled) {
+         /* min/max here */
+         if (transferOps & IMAGE_MIN_MAX_BIT) {
             _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
          }
       }
 
       /* clamp to [0,1] */
+#if CHAN_TYPE != GL_FLOAT
       if (clamp) {
          GLuint i;
          for (i = 0; i < n; i++) {
@@ -2728,6 +3075,7 @@
             rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
          }
       }
+#endif
 
       /* Now determine which color channels we need to produce.
        * And determine the dest index (offset) within each color tuple.
@@ -2768,11 +3116,12 @@
             dstLuminanceIndex = dstIntensityIndex = -1;
             break;
          default:
-            gl_problem(ctx, "bad dstFormat in _mesa_unpack_float_span()");
+            _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()");
+            UNDEFARRAY(rgba);  /* mac 32k limitation */
             return;
       }
 
-      /* Now pack results in teh requested dstFormat */
+      /* Now pack results in the requested dstFormat */
       if (dstRedIndex >= 0) {
          GLfloat *dst = dest;
          GLuint i;
@@ -2830,6 +3179,7 @@
             dst += dstComponents;
          }
       }
+      UNDEFARRAY(rgba);  /* mac 32k limitation */
    }
 }
 
@@ -2838,8 +3188,7 @@
 
 /*
  * Unpack a row of color index data from a client buffer according to
- * the pixel unpacking parameters.  Apply pixel transfer ops if enabled
- * and applyTransferOps is true.
+ * the pixel unpacking parameters.
  * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
  *
  * Args:  ctx - the context
@@ -2848,15 +3197,15 @@
  *        dest - destination array
  *        srcType - source pixel type
  *        source - source data pointer
- *        unpacking - pixel unpacking parameters
- *        applyTransferOps - apply offset/bias/lookup ops?
+ *        srcPacking - pixel unpacking parameters
+ *        transferOps - the pixel transfer operations to apply
  */
 void
 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
                          GLenum dstType, GLvoid *dest,
                          GLenum srcType, const GLvoid *source,
-                         const struct gl_pixelstore_attrib *unpacking,
-                         GLboolean applyTransferOps )
+                         const struct gl_pixelstore_attrib *srcPacking,
+                         GLuint transferOps )
 {
    ASSERT(srcType == GL_BITMAP ||
           srcType == GL_UNSIGNED_BYTE ||
@@ -2871,17 +3220,18 @@
           dstType == GL_UNSIGNED_SHORT ||
           dstType == GL_UNSIGNED_INT);
 
-   applyTransferOps &= (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || ctx->Pixel.MapColorFlag);
 
+   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
+
    /*
     * Try simple cases first
     */
-   if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE
+   if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
        && dstType == GL_UNSIGNED_BYTE) {
       MEMCPY(dest, source, n * sizeof(GLubyte));
    }
-   else if (!applyTransferOps && srcType == GL_UNSIGNED_INT
-            && dstType == GL_UNSIGNED_INT && !unpacking->SwapBytes) {
+   else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
+            && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
       MEMCPY(dest, source, n * sizeof(GLuint));
    }
    else {
@@ -2892,17 +3242,15 @@
       assert(n <= MAX_WIDTH);
 
       extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
-                           unpacking);
+                           srcPacking);
 
-      if (applyTransferOps) {
-         if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
-            /* shift and offset indexes */
-            _mesa_shift_and_offset_ci(ctx, n, indexes);
-         }
-         if (ctx->Pixel.MapColorFlag) {
-            /* Apply lookup table */
-            _mesa_map_ci(ctx, n, indexes);
-         }
+      if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
+         /* shift and offset indexes */
+         _mesa_shift_and_offset_ci(ctx, n, indexes);
+      }
+      if (transferOps & IMAGE_MAP_COLOR_BIT) {
+         /* Apply lookup table */
+         _mesa_map_ci(ctx, n, indexes);
       }
 
       /* convert to dest type */
@@ -2929,16 +3277,125 @@
             MEMCPY(dest, indexes, n * sizeof(GLuint));
             break;
          default:
-            gl_problem(ctx, "bad dstType in _mesa_unpack_index_span");
+            _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
+      }
+   }
+}
+
+
+void
+_mesa_pack_index_span( const GLcontext *ctx, GLuint n,
+                       GLenum dstType, GLvoid *dest, const GLuint *source,
+                       const struct gl_pixelstore_attrib *dstPacking,
+                       GLuint transferOps )
+{
+   GLuint indexes[MAX_WIDTH];
+
+   ASSERT(n <= MAX_WIDTH);
+
+   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
+
+   if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
+      /* make a copy of input */
+      MEMCPY(indexes, source, n * sizeof(GLuint));
+      if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
+         _mesa_shift_and_offset_ci( ctx, n, indexes);
+      }
+      if (transferOps & IMAGE_MAP_COLOR_BIT) {
+         _mesa_map_ci(ctx, n, indexes);
+      }
+      source = indexes;
+   }
+
+   switch (dstType) {
+   case GL_UNSIGNED_BYTE:
+      {
+         GLubyte *dst = (GLubyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            *dst++ = (GLubyte) source[i];
+         }
+      }
+      break;
+   case GL_BYTE:
+      {
+         GLbyte *dst = (GLbyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLbyte) source[i];
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort *dst = (GLushort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLushort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_SHORT:
+      {
+         GLshort *dst = (GLshort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLshort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
       }
+      break;
+   case GL_UNSIGNED_INT:
+      {
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLuint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_INT:
+      {
+         GLint *dst = (GLint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_FLOAT:
+      {
+         GLfloat *dst = (GLfloat *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLfloat) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
    }
 }
 
 
+
 /*
  * Unpack a row of stencil data from a client buffer according to
- * the pixel unpacking parameters.  Apply pixel transfer ops if enabled
- * and applyTransferOps is true.
+ * the pixel unpacking parameters.
  * This is (or will be) used by glDrawPixels
  *
  * Args:  ctx - the context
@@ -2947,15 +3404,15 @@
  *        dest - destination array
  *        srcType - source pixel type
  *        source - source data pointer
- *        unpacking - pixel unpacking parameters
- *        applyTransferOps - apply offset/bias/lookup ops?
+ *        srcPacking - pixel unpacking parameters
+ *        transferOps - apply offset/bias/lookup ops?
  */
 void
 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
                            GLenum dstType, GLvoid *dest,
                            GLenum srcType, const GLvoid *source,
-                           const struct gl_pixelstore_attrib *unpacking,
-                           GLboolean applyTransferOps )
+                           const struct gl_pixelstore_attrib *srcPacking,
+                           GLuint transferOps )
 {
    ASSERT(srcType == GL_BITMAP ||
           srcType == GL_UNSIGNED_BYTE ||
@@ -2970,17 +3427,21 @@
           dstType == GL_UNSIGNED_SHORT ||
           dstType == GL_UNSIGNED_INT);
 
-   applyTransferOps &= (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset || ctx->Pixel.MapColorFlag);
+   /* only shift and offset apply to stencil */
+   transferOps &= IMAGE_SHIFT_OFFSET_BIT;
 
    /*
     * Try simple cases first
     */
-   if (!applyTransferOps && srcType == GL_UNSIGNED_BYTE
-       && dstType == GL_UNSIGNED_BYTE) {
+   if (transferOps == 0 &&
+       srcType == GL_UNSIGNED_BYTE &&
+       dstType == GL_UNSIGNED_BYTE) {
       MEMCPY(dest, source, n * sizeof(GLubyte));
    }
-   else if (!applyTransferOps && srcType == GL_UNSIGNED_INT
-            && dstType == GL_UNSIGNED_INT && !unpacking->SwapBytes) {
+   else if (transferOps == 0 &&
+            srcType == GL_UNSIGNED_INT &&
+            dstType == GL_UNSIGNED_INT &&
+            !srcPacking->SwapBytes) {
       MEMCPY(dest, source, n * sizeof(GLuint));
    }
    else {
@@ -2991,10 +3452,10 @@
       assert(n <= MAX_WIDTH);
 
       extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
-                           unpacking);
+                           srcPacking);
 
-      if (applyTransferOps) {
-         if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
+      if (transferOps) {
+         if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
             /* shift and offset indexes */
             _mesa_shift_and_offset_ci(ctx, n, indexes);
          }
@@ -3033,30 +3494,170 @@
             MEMCPY(dest, indexes, n * sizeof(GLuint));
             break;
          default:
-            gl_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
+            _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
       }
    }
 }
 
 
+void
+_mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
+                         GLenum dstType, GLvoid *dest, const GLstencil *source,
+                         const struct gl_pixelstore_attrib *dstPacking )
+{
+   GLstencil stencil[MAX_WIDTH];
+
+   ASSERT(n <= MAX_WIDTH);
 
+   if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
+       ctx->Pixel.MapStencilFlag) {
+      /* make a copy of input */
+      MEMCPY(stencil, source, n * sizeof(GLstencil));
+      if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
+         _mesa_shift_and_offset_stencil( ctx, n, stencil );
+      }
+      if (ctx->Pixel.MapStencilFlag) {
+         _mesa_map_stencil( ctx, n, stencil );
+      }
+      source = stencil;
+   }
+
+   switch (dstType) {
+   case GL_UNSIGNED_BYTE:
+      if (sizeof(GLstencil) == 8) {
+         MEMCPY( dest, source, n );
+      }
+      else {
+         GLubyte *dst = (GLubyte *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLubyte) source[i];
+         }
+      }
+      break;
+   case GL_BYTE:
+      if (sizeof(GLstencil) == 8) {
+         MEMCPY( dest, source, n );
+      }
+      else {
+         GLbyte *dst = (GLbyte *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLbyte) source[i];
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort *dst = (GLushort *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLushort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_SHORT:
+      {
+         GLshort *dst = (GLshort *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLshort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_UNSIGNED_INT:
+      {
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLuint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_INT:
+      {
+         GLint *dst = (GLint *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            *dst++ = (GLint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_FLOAT:
+      {
+         GLfloat *dst = (GLfloat *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLfloat) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_BITMAP:
+      if (dstPacking->LsbFirst) {
+         GLubyte *dst = (GLubyte *) dest;
+         GLint shift = 0;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            if (shift == 0)
+               *dst = 0;
+            *dst |= ((source[i] != 0) << shift);
+            shift++;
+            if (shift == 8) {
+               shift = 0;
+               dst++;
+            }
+         }
+      }
+      else {
+         GLubyte *dst = (GLubyte *) dest;
+         GLint shift = 7;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            if (shift == 7)
+               *dst = 0;
+            *dst |= ((source[i] != 0) << shift);
+            shift--;
+            if (shift < 0) {
+               shift = 7;
+               dst++;
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
+   }
+}
+
+
+
 void
-_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest,
+_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLfloat *dest,
                          GLenum srcType, const GLvoid *source,
-                         const struct gl_pixelstore_attrib *unpacking,
-                         GLboolean applyTransferOps )
+                         const struct gl_pixelstore_attrib *srcPacking )
 {
-   GLfloat *depth = (GLfloat *) MALLOC(n * sizeof(GLfloat));
-   if (!depth)
-      return;
-
    switch (srcType) {
       case GL_BYTE:
          {
             GLuint i;
             const GLubyte *src = (const GLubyte *) source;
             for (i = 0; i < n; i++) {
-               depth[i] = BYTE_TO_FLOAT(src[i]);
+               dest[i] = BYTE_TO_FLOAT(src[i]);
             }
          }
          break;
@@ -3065,7 +3666,7 @@
             GLuint i;
             const GLubyte *src = (const GLubyte *) source;
             for (i = 0; i < n; i++) {
-               depth[i] = UBYTE_TO_FLOAT(src[i]);
+               dest[i] = UBYTE_TO_FLOAT(src[i]);
             }
          }
          break;
@@ -3074,7 +3675,7 @@
             GLuint i;
             const GLshort *src = (const GLshort *) source;
             for (i = 0; i < n; i++) {
-               depth[i] = SHORT_TO_FLOAT(src[i]);
+               dest[i] = SHORT_TO_FLOAT(src[i]);
             }
          }
          break;
@@ -3083,7 +3684,7 @@
             GLuint i;
             const GLushort *src = (const GLushort *) source;
             for (i = 0; i < n; i++) {
-               depth[i] = USHORT_TO_FLOAT(src[i]);
+               dest[i] = USHORT_TO_FLOAT(src[i]);
             }
          }
          break;
@@ -3092,7 +3693,7 @@
             GLuint i;
             const GLint *src = (const GLint *) source;
             for (i = 0; i < n; i++) {
-               depth[i] = INT_TO_FLOAT(src[i]);
+               dest[i] = INT_TO_FLOAT(src[i]);
             }
          }
          break;
@@ -3101,42 +3702,142 @@
             GLuint i;
             const GLuint *src = (const GLuint *) source;
             for (i = 0; i < n; i++) {
-               depth[i] = UINT_TO_FLOAT(src[i]);
+               dest[i] = UINT_TO_FLOAT(src[i]);
             }
          }
          break;
       case GL_FLOAT:
-         MEMCPY(depth, source, n * sizeof(GLfloat));
+         MEMCPY(dest, source, n * sizeof(GLfloat));
          break;
       default:
-         gl_problem(NULL, "bad type in _mesa_unpack_depth_span()");
-         FREE(depth);
+         _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
          return;
    }
 
 
-   /* apply depth scale and bias */
+   /* apply depth scale and bias and clamp to [0,1] */
    if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
       GLuint i;
       for (i = 0; i < n; i++) {
-         depth[i] = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
+         GLfloat d = dest[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
+         dest[i] = CLAMP(d, 0.0F, 1.0F);
       }
    }
+}
 
-   /* clamp depth values to [0,1] and convert from floats to integers */
-   {
-      const GLfloat zs = ctx->Visual->DepthMaxF;
+
+
+/*
+ * Pack an array of depth values.  The values are floats in [0,1].
+ */
+void
+_mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
+                       GLenum dstType, const GLfloat *depthSpan,
+                       const struct gl_pixelstore_attrib *dstPacking )
+{
+   GLfloat depthCopy[MAX_WIDTH];
+   const GLboolean bias_or_scale = ctx->Pixel.DepthBias != 0.0 ||
+                                   ctx->Pixel.DepthScale != 1.0;
+
+   ASSERT(n <= MAX_WIDTH);
+
+   if (bias_or_scale) {
       GLuint i;
       for (i = 0; i < n; i++) {
-         dest[i] = (GLdepth) (CLAMP(depth[i], 0.0F, 1.0F) * zs);
+         GLfloat d;
+         d = depthSpan[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
+         depthCopy[i] = CLAMP(d, 0.0F, 1.0F);
       }
+      depthSpan = depthCopy;
    }
 
-   FREE(depth);
+   switch (dstType) {
+   case GL_UNSIGNED_BYTE:
+      {
+         GLubyte *dst = (GLubyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
+         }
+      }
+      break;
+   case GL_BYTE:
+      {
+         GLbyte *dst = (GLbyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort *dst = (GLushort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_USHORT( depthSpan[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_SHORT:
+      {
+         GLshort *dst = (GLshort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_UNSIGNED_INT:
+      {
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_UINT( depthSpan[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_INT:
+      {
+         GLint *dst = (GLint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_INT( depthSpan[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_FLOAT:
+      {
+         GLfloat *dst = (GLfloat *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = depthSpan[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
+   }
 }
 
 
 
+
 /*
  * Unpack image data.  Apply byteswapping, byte flipping (bitmap).
  * Return all image data in a contiguous block.
@@ -3203,198 +3904,5 @@
          }
       }
       return destBuffer;
-   }
-}
-
-
-/*
- * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
- * order with row alignment = 1 byte.
- */
-GLvoid *
-_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
-                     const struct gl_pixelstore_attrib *packing )
-{
-   GLint bytes, row, width_in_bytes;
-   GLubyte *buffer, *dst;
-
-   if (!pixels)
-      return NULL;
-
-   /* Alloc dest storage */
-   bytes = ((width + 7) / 8 * height);
-   buffer = (GLubyte *) MALLOC( bytes );
-   if (!buffer)
-      return NULL;
-
-
-   width_in_bytes = CEILING( width, 8 );
-   dst = buffer;
-   for (row = 0; row < height; row++) {
-      GLubyte *src = (GLubyte *) _mesa_image_address(packing, pixels, width,
-                                 height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0);
-      if (!src) {
-         FREE(buffer);
-         return NULL;
-      }
-
-      if (packing->SkipPixels == 0) {
-         MEMCPY( dst, src, width_in_bytes );
-         if (packing->LsbFirst) {
-            flip_bytes( dst, width_in_bytes );
-         }
-      }
-      else {
-         /* handling SkipPixels is a bit tricky (no pun intended!) */
-         GLint i;
-         if (packing->LsbFirst) {
-            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
-            GLubyte dstMask = 128;
-            GLubyte *s = src;
-            GLubyte *d = dst;
-            *d = 0;
-            for (i = 0; i < width; i++) {
-               if (*s & srcMask) {
-                  *d |= dstMask;
-               }
-               if (srcMask == 128) {
-                  srcMask = 1;
-                  s++;
-               }
-               else {
-                  srcMask = srcMask << 1;
-               }
-               if (dstMask == 1) {
-                  dstMask = 128;
-                  d++;
-                  *d = 0;
-               }
-               else {
-                  dstMask = dstMask >> 1;
-               }
-            }
-         }
-         else {
-            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
-            GLubyte dstMask = 128;
-            GLubyte *s = src;
-            GLubyte *d = dst;
-            *d = 0;
-            for (i = 0; i < width; i++) {
-               if (*s & srcMask) {
-                  *d |= dstMask;
-               }
-               if (srcMask == 1) {
-                  srcMask = 128;
-                  s++;
-               }
-               else {
-                  srcMask = srcMask >> 1;
-               }
-               if (dstMask == 1) {
-                  dstMask = 128;
-                  d++;
-                  *d = 0;
-               }
-               else {
-                  dstMask = dstMask >> 1;
-               }
-            }
-         }
-      }
-      dst += width_in_bytes;
-   }
-
-   return buffer;
-}
-
-
-/*
- * Pack bitmap data.
- */
-void
-_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
-                   GLubyte *dest, const struct gl_pixelstore_attrib *packing )
-{
-   GLint row, width_in_bytes;
-   const GLubyte *src;
-
-   if (!source)
-      return;
-
-   width_in_bytes = CEILING( width, 8 );
-   src = source;
-   for (row = 0; row < height; row++) {
-      GLubyte *dst = (GLubyte *) _mesa_image_address( packing, dest, width, height,
-                                          GL_COLOR_INDEX, GL_BITMAP,
-                                          0, row, 0 );
-      if (!dst)
-         return;
-
-      if (packing->SkipPixels == 0) {
-         MEMCPY( dst, src, width_in_bytes );
-         if (packing->LsbFirst) {
-            flip_bytes( dst, width_in_bytes );
-         }
-      }
-      else {
-         /* handling SkipPixels is a bit tricky (no pun intended!) */
-         GLint i;
-         if (packing->LsbFirst) {
-            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
-            GLubyte dstMask = 128;
-            const GLubyte *s = src;
-            GLubyte *d = dst;
-            *d = 0;
-            for (i = 0; i < width; i++) {
-               if (*s & srcMask) {
-                  *d |= dstMask;
-               }
-               if (srcMask == 128) {
-                  srcMask = 1;
-                  s++;
-               }
-               else {
-                  srcMask = srcMask << 1;
-               }
-               if (dstMask == 1) {
-                  dstMask = 128;
-                  d++;
-                  *d = 0;
-               }
-               else {
-                  dstMask = dstMask >> 1;
-               }
-            }
-         }
-         else {
-            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
-            GLubyte dstMask = 128;
-            const GLubyte *s = src;
-            GLubyte *d = dst;
-            *d = 0;
-            for (i = 0; i < width; i++) {
-               if (*s & srcMask) {
-                  *d |= dstMask;
-               }
-               if (srcMask == 1) {
-                  srcMask = 128;
-                  s++;
-               }
-               else {
-                  srcMask = srcMask >> 1;
-               }
-               if (dstMask == 1) {
-                  dstMask = 128;
-                  d++;
-                  *d = 0;
-               }
-               else {
-                  dstMask = dstMask >> 1;
-               }
-            }
-         }
-      }
-      src += width_in_bytes;
    }
 }
Index: xc/extras/Mesa/src/image.h
diff -u xc/extras/Mesa/src/image.h:1.5 xc/extras/Mesa/src/image.h:1.6
--- xc/extras/Mesa/src/image.h:1.5	Tue Mar 20 21:48:46 2001
+++ xc/extras/Mesa/src/image.h	Fri Feb 22 14:25:33 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4.1
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define IMAGE_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern const struct gl_pixelstore_attrib _mesa_native_packing;
@@ -78,30 +78,38 @@
                             const struct gl_pixelstore_attrib *packing );
 
 
+extern GLvoid *
+_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
+                     const struct gl_pixelstore_attrib *packing );
+
+extern void
+_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
+                   GLubyte *dest, const struct gl_pixelstore_attrib *packing );
+
+
 extern void
 _mesa_pack_float_rgba_span( GLcontext *ctx,
                             GLuint n, CONST GLfloat rgba[][4],
-                            GLenum dstFormat, GLenum dstType,
-                            GLvoid *dstAddr,
+                            GLenum dstFormat, GLenum dstType, GLvoid *dstAddr,
                             const struct gl_pixelstore_attrib *dstPacking,
-                            GLboolean applyTransferOps );
+                            GLuint transferOps );
 
 
 extern void
 _mesa_pack_rgba_span( GLcontext *ctx,
-                      GLuint n, CONST GLubyte rgba[][4],
-                      GLenum format, GLenum type, GLvoid *dest,
-                      const struct gl_pixelstore_attrib *packing,
-                      GLboolean applyTransferOps );
+                      GLuint n, CONST GLchan rgba[][4],
+                      GLenum dstFormat, GLenum dstType, GLvoid *dstAddr,
+                      const struct gl_pixelstore_attrib *dstPacking,
+                      GLuint transferOps );
 
 
 extern void
-_mesa_unpack_ubyte_color_span( GLcontext *ctx,
-                               GLuint n, GLenum dstFormat, GLubyte dest[],
-                               GLenum srcFormat, GLenum srcType,
-                               const GLvoid *source,
-                               const struct gl_pixelstore_attrib *unpacking,
-                               GLboolean applyTransferOps );
+_mesa_unpack_chan_color_span( GLcontext *ctx,
+                              GLuint n, GLenum dstFormat, GLchan dest[],
+                              GLenum srcFormat, GLenum srcType,
+                              const GLvoid *source,
+                              const struct gl_pixelstore_attrib *srcPacking,
+                              GLuint transferOps );
 
 
 extern void
@@ -109,46 +117,53 @@
                                GLuint n, GLenum dstFormat, GLfloat dest[],
                                GLenum srcFormat, GLenum srcType,
                                const GLvoid *source,
-                               const struct gl_pixelstore_attrib *unpacking,
-                               GLboolean applyTransferOps, GLboolean clamp );
+                               const struct gl_pixelstore_attrib *srcPacking,
+                               GLuint transferOps, GLboolean clamp );
 
 
 extern void
 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
                          GLenum dstType, GLvoid *dest,
                          GLenum srcType, const GLvoid *source,
-                         const struct gl_pixelstore_attrib *unpacking,
-                         GLboolean applyTransferOps );
+                         const struct gl_pixelstore_attrib *srcPacking,
+                         GLuint transferOps );
+
+
+extern void
+_mesa_pack_index_span( const GLcontext *ctx, GLuint n,
+                       GLenum dstType, GLvoid *dest, const GLuint *source,
+                       const struct gl_pixelstore_attrib *dstPacking,
+                       GLuint transferOps );
 
 
 extern void
 _mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
                            GLenum dstType, GLvoid *dest,
                            GLenum srcType, const GLvoid *source,
-                           const struct gl_pixelstore_attrib *unpacking,
-                           GLboolean applyTransferOps );
+                           const struct gl_pixelstore_attrib *srcPacking,
+                           GLuint transferOps );
 
+extern void
+_mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
+                         GLenum dstType, GLvoid *dest, const GLstencil *source,
+                         const struct gl_pixelstore_attrib *dstPacking );
+
 
 extern void
-_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLdepth *dest,
+_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLfloat *dest,
                          GLenum srcType, const GLvoid *source,
-                         const struct gl_pixelstore_attrib *unpacking,
-                         GLboolean applyTransferOps );
+                         const struct gl_pixelstore_attrib *srcPacking );
+
+extern void
+_mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
+                       GLenum dstType, const GLfloat *depthSpan,
+                       const struct gl_pixelstore_attrib *dstPacking );
 
 
 extern void *
 _mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
                     GLenum format, GLenum type, const GLvoid *pixels,
                     const struct gl_pixelstore_attrib *unpack );
-
-
-extern GLvoid *
-_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
-                     const struct gl_pixelstore_attrib *packing );
-
-extern void
-_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
-                   GLubyte *dest, const struct gl_pixelstore_attrib *packing );
 
 
 #endif
Index: xc/extras/Mesa/src/imaging.c
diff -u xc/extras/Mesa/src/imaging.c:1.9 xc/extras/Mesa/src/imaging.c:removed
--- xc/extras/Mesa/src/imaging.c:1.9	Fri May 18 12:59:54 2001
+++ xc/extras/Mesa/src/imaging.c	Thu Feb 27 12:15:39 2003
@@ -1,1651 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Histogram, Min/max and convolution for GL_ARB_imaging subset
- *
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "image.h"
-#include "imaging.h"
-#include "mmath.h"
-#include "span.h"
-#endif
-
-
-
-/**********************************************************************/
-/****                  Histogram and Min/max                      *****/
-/**********************************************************************/
-
-
-static void
-pack_histogram( GLcontext *ctx,
-                GLuint n, CONST GLuint rgba[][4],
-                GLenum format, GLenum type, GLvoid *destination,
-                const struct gl_pixelstore_attrib *packing )
-{
-   const GLint comps = _mesa_components_in_format(format);
-   GLuint luminance[MAX_WIDTH];
-
-   if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA) {
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
-      }
-   }
-
-#define PACK_MACRO(TYPE)					\
-   {								\
-      GLuint i;							\
-      switch (format) {						\
-         case GL_RED:						\
-            for (i=0;i<n;i++)					\
-               dst[i] = (TYPE) rgba[i][RCOMP];			\
-            break;						\
-         case GL_GREEN:						\
-            for (i=0;i<n;i++)					\
-               dst[i] = (TYPE) rgba[i][GCOMP];			\
-            break;						\
-         case GL_BLUE:						\
-            for (i=0;i<n;i++)					\
-               dst[i] = (TYPE) rgba[i][BCOMP];			\
-            break;						\
-         case GL_ALPHA:						\
-            for (i=0;i<n;i++)					\
-               dst[i] = (TYPE) rgba[i][ACOMP];			\
-            break;						\
-         case GL_LUMINANCE:					\
-            for (i=0;i<n;i++)					\
-               dst[i] = (TYPE) luminance[i];			\
-            break;						\
-         case GL_LUMINANCE_ALPHA:				\
-            for (i=0;i<n;i++) {					\
-               dst[i*2+0] = (TYPE) luminance[i];		\
-               dst[i*2+1] = (TYPE) rgba[i][ACOMP];		\
-            }							\
-            break;						\
-         case GL_RGB:						\
-            for (i=0;i<n;i++) {					\
-               dst[i*3+0] = (TYPE) rgba[i][RCOMP];		\
-               dst[i*3+1] = (TYPE) rgba[i][GCOMP];		\
-               dst[i*3+2] = (TYPE) rgba[i][BCOMP];		\
-            }							\
-            break;						\
-         case GL_RGBA:						\
-            for (i=0;i<n;i++) {					\
-               dst[i*4+0] = (TYPE) rgba[i][RCOMP];		\
-               dst[i*4+1] = (TYPE) rgba[i][GCOMP];		\
-               dst[i*4+2] = (TYPE) rgba[i][BCOMP];		\
-               dst[i*4+3] = (TYPE) rgba[i][ACOMP];		\
-            }							\
-            break;						\
-         case GL_BGR:						\
-            for (i=0;i<n;i++) {					\
-               dst[i*3+0] = (TYPE) rgba[i][BCOMP];		\
-               dst[i*3+1] = (TYPE) rgba[i][GCOMP];		\
-               dst[i*3+2] = (TYPE) rgba[i][RCOMP];		\
-            }							\
-            break;						\
-         case GL_BGRA:						\
-            for (i=0;i<n;i++) {					\
-               dst[i*4+0] = (TYPE) rgba[i][BCOMP];		\
-               dst[i*4+1] = (TYPE) rgba[i][GCOMP];		\
-               dst[i*4+2] = (TYPE) rgba[i][RCOMP];		\
-               dst[i*4+3] = (TYPE) rgba[i][ACOMP];		\
-            }							\
-            break;						\
-         case GL_ABGR_EXT:					\
-            for (i=0;i<n;i++) {					\
-               dst[i*4+0] = (TYPE) rgba[i][ACOMP];		\
-               dst[i*4+1] = (TYPE) rgba[i][BCOMP];		\
-               dst[i*4+2] = (TYPE) rgba[i][GCOMP];		\
-               dst[i*4+3] = (TYPE) rgba[i][RCOMP];		\
-            }							\
-            break;						\
-         default:						\
-            gl_problem(ctx, "bad format in pack_histogram");	\
-      }								\
-   }
-
-   switch (type) {
-      case GL_UNSIGNED_BYTE:
-         {
-            GLubyte *dst = (GLubyte *) destination;
-            PACK_MACRO(GLubyte);
-         }
-         break;
-      case GL_BYTE:
-         {
-            GLbyte *dst = (GLbyte *) destination;
-            PACK_MACRO(GLbyte);
-         }
-         break;
-      case GL_UNSIGNED_SHORT:
-         {
-            GLushort *dst = (GLushort *) destination;
-            PACK_MACRO(GLushort);
-            if (packing->SwapBytes) {
-               _mesa_swap2(dst, n * comps);
-            }
-         }
-         break;
-      case GL_SHORT:
-         {
-            GLshort *dst = (GLshort *) destination;
-            PACK_MACRO(GLshort);
-            if (packing->SwapBytes) {
-               _mesa_swap2((GLushort *) dst, n * comps);
-            }
-         }
-         break;
-      case GL_UNSIGNED_INT:
-         {
-            GLuint *dst = (GLuint *) destination;
-            PACK_MACRO(GLuint);
-            if (packing->SwapBytes) {
-               _mesa_swap4(dst, n * comps);
-            }
-         }
-         break;
-      case GL_INT:
-         {
-            GLint *dst = (GLint *) destination;
-            PACK_MACRO(GLint);
-            if (packing->SwapBytes) {
-               _mesa_swap4((GLuint *) dst, n * comps);
-            }
-         }
-         break;
-      case GL_FLOAT:
-         {
-            GLfloat *dst = (GLfloat *) destination;
-            PACK_MACRO(GLfloat);
-            if (packing->SwapBytes) {
-               _mesa_swap4((GLuint *) dst, n * comps);
-            }
-         }
-         break;
-      default:
-         gl_problem(ctx, "Bad type in pack_histogram");
-   }
-
-#undef PACK_MACRO
-}
-
-
-
-static void
-pack_minmax( GLcontext *ctx, CONST GLfloat minmax[2][4],
-             GLenum format, GLenum type, GLvoid *destination,
-             const struct gl_pixelstore_attrib *packing )
-{
-   const GLint comps = _mesa_components_in_format(format);
-   GLfloat luminance[2];
-
-   if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA) {
-      luminance[0] = minmax[0][RCOMP] + minmax[0][GCOMP] + minmax[0][BCOMP];
-      luminance[1] = minmax[1][RCOMP] + minmax[1][GCOMP] + minmax[1][BCOMP];
-   }
-
-#define PACK_MACRO(TYPE, CONVERSION)				\
-   {								\
-      GLuint i;							\
-      switch (format) {						\
-         case GL_RED:						\
-            for (i=0;i<2;i++)					\
-               dst[i] = CONVERSION (minmax[i][RCOMP]);		\
-            break;						\
-         case GL_GREEN:						\
-            for (i=0;i<2;i++)					\
-               dst[i] = CONVERSION (minmax[i][GCOMP]);		\
-            break;						\
-         case GL_BLUE:						\
-            for (i=0;i<2;i++)					\
-               dst[i] = CONVERSION (minmax[i][BCOMP]);		\
-            break;						\
-         case GL_ALPHA:						\
-            for (i=0;i<2;i++)					\
-               dst[i] = CONVERSION (minmax[i][ACOMP]);		\
-            break;						\
-         case GL_LUMINANCE:					\
-            for (i=0;i<2;i++)					\
-               dst[i] = CONVERSION (luminance[i]);		\
-            break;						\
-         case GL_LUMINANCE_ALPHA:				\
-            for (i=0;i<2;i++) {					\
-               dst[i*2+0] = CONVERSION (luminance[i]);		\
-               dst[i*2+1] = CONVERSION (minmax[i][ACOMP]);	\
-            }							\
-            break;						\
-         case GL_RGB:						\
-            for (i=0;i<2;i++) {					\
-               dst[i*3+0] = CONVERSION (minmax[i][RCOMP]);	\
-               dst[i*3+1] = CONVERSION (minmax[i][GCOMP]);	\
-               dst[i*3+2] = CONVERSION (minmax[i][BCOMP]);	\
-            }							\
-            break;						\
-         case GL_RGBA:						\
-            for (i=0;i<2;i++) {					\
-               dst[i*4+0] = CONVERSION (minmax[i][RCOMP]);	\
-               dst[i*4+1] = CONVERSION (minmax[i][GCOMP]);	\
-               dst[i*4+2] = CONVERSION (minmax[i][BCOMP]);	\
-               dst[i*4+3] = CONVERSION (minmax[i][ACOMP]);	\
-            }							\
-            break;						\
-         case GL_BGR:						\
-            for (i=0;i<2;i++) {					\
-               dst[i*3+0] = CONVERSION (minmax[i][BCOMP]);	\
-               dst[i*3+1] = CONVERSION (minmax[i][GCOMP]);	\
-               dst[i*3+2] = CONVERSION (minmax[i][RCOMP]);	\
-            }							\
-            break;						\
-         case GL_BGRA:						\
-            for (i=0;i<2;i++) {					\
-               dst[i*4+0] = CONVERSION (minmax[i][BCOMP]);	\
-               dst[i*4+1] = CONVERSION (minmax[i][GCOMP]);	\
-               dst[i*4+2] = CONVERSION (minmax[i][RCOMP]);	\
-               dst[i*4+3] = CONVERSION (minmax[i][ACOMP]);	\
-            }							\
-            break;						\
-         case GL_ABGR_EXT:					\
-            for (i=0;i<2;i++) {					\
-               dst[i*4+0] = CONVERSION (minmax[i][ACOMP]);	\
-               dst[i*4+1] = CONVERSION (minmax[i][BCOMP]);	\
-               dst[i*4+2] = CONVERSION (minmax[i][GCOMP]);	\
-               dst[i*4+3] = CONVERSION (minmax[i][RCOMP]);	\
-            }							\
-            break;						\
-         default:						\
-            gl_problem(ctx, "bad format in pack_minmax");	\
-      }								\
-   }
-
-   switch (type) {
-      case GL_UNSIGNED_BYTE:
-         {
-            GLubyte *dst = (GLubyte *) destination;
-            PACK_MACRO(GLubyte, FLOAT_TO_UBYTE);
-         }
-         break;
-      case GL_BYTE:
-         {
-            GLbyte *dst = (GLbyte *) destination;
-            PACK_MACRO(GLbyte, FLOAT_TO_BYTE);
-         }
-         break;
-      case GL_UNSIGNED_SHORT:
-         {
-            GLushort *dst = (GLushort *) destination;
-            PACK_MACRO(GLushort, FLOAT_TO_USHORT);
-            if (packing->SwapBytes) {
-               _mesa_swap2(dst, 2 * comps);
-            }
-         }
-         break;
-      case GL_SHORT:
-         {
-            GLshort *dst = (GLshort *) destination;
-            PACK_MACRO(GLshort, FLOAT_TO_SHORT);
-            if (packing->SwapBytes) {
-               _mesa_swap2((GLushort *) dst, 2 * comps);
-            }
-         }
-         break;
-      case GL_UNSIGNED_INT:
-         {
-            GLuint *dst = (GLuint *) destination;
-            PACK_MACRO(GLuint, FLOAT_TO_UINT);
-            if (packing->SwapBytes) {
-               _mesa_swap4(dst, 2 * comps);
-            }
-         }
-         break;
-      case GL_INT:
-         {
-            GLint *dst = (GLint *) destination;
-            PACK_MACRO(GLint, FLOAT_TO_INT);
-            if (packing->SwapBytes) {
-               _mesa_swap4((GLuint *) dst, 2 * comps);
-            }
-         }
-         break;
-      case GL_FLOAT:
-         {
-            GLfloat *dst = (GLfloat *) destination;
-            PACK_MACRO(GLfloat, (GLfloat));
-            if (packing->SwapBytes) {
-               _mesa_swap4((GLuint *) dst, 2 * comps);
-            }
-         }
-         break;
-      default:
-         gl_problem(ctx, "Bad type in pack_minmax");
-   }
-
-#undef PACK_MACRO
-}
-
-
-/*
- * Given an internalFormat token passed to glHistogram or glMinMax,
- * return the corresponding base format.
- * Return -1 if invalid token.
- */
-static GLint
-base_histogram_format( GLenum format )
-{
-   switch (format) {
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-         return GL_ALPHA;
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-         return GL_LUMINANCE;
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE4_ALPHA4:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-         return GL_LUMINANCE_ALPHA;
-      case GL_RGB:
-      case GL_R3_G3_B2:
-      case GL_RGB4:
-      case GL_RGB5:
-      case GL_RGB8:
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-         return GL_RGB;
-      case GL_RGBA:
-      case GL_RGBA2:
-      case GL_RGBA4:
-      case GL_RGB5_A1:
-      case GL_RGBA8:
-      case GL_RGB10_A2:
-      case GL_RGBA12:
-      case GL_RGBA16:
-         return GL_RGBA;
-      default:
-         return -1;  /* error */
-   }
-}
-
-
-/*
- * Given an internalFormat token passed to glConvolutionFilter
- * or glSeparableFilter, return the corresponding base format.
- * Return -1 if invalid token.
- */
-static GLint
-base_filter_format( GLenum format )
-{
-   switch (format) {
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-         return GL_ALPHA;
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-         return GL_LUMINANCE;
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE4_ALPHA4:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-         return GL_LUMINANCE_ALPHA;
-      case GL_INTENSITY:
-      case GL_INTENSITY4:
-      case GL_INTENSITY8:
-      case GL_INTENSITY12:
-      case GL_INTENSITY16:
-         return GL_INTENSITY;
-      case GL_RGB:
-      case GL_R3_G3_B2:
-      case GL_RGB4:
-      case GL_RGB5:
-      case GL_RGB8:
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-         return GL_RGB;
-      case 4:
-      case GL_RGBA:
-      case GL_RGBA2:
-      case GL_RGBA4:
-      case GL_RGB5_A1:
-      case GL_RGBA8:
-      case GL_RGB10_A2:
-      case GL_RGBA12:
-      case GL_RGBA16:
-         return GL_RGBA;
-      default:
-         return -1;  /* error */
-   }
-}
-
-
-void
-_mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetHistogram");
-
-   if (target != GL_MINMAX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetMinmax(target)");
-      return;
-   }
-
-   if (format != GL_RED &&
-       format != GL_GREEN &&
-       format != GL_BLUE &&
-       format != GL_ALPHA &&
-       format != GL_RGB &&
-       format != GL_RGBA &&
-       format != GL_ABGR_EXT &&
-       format != GL_LUMINANCE &&
-       format != GL_LUMINANCE_ALPHA) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetMinmax(format)");
-      return;
-   }
-
-   if (type != GL_UNSIGNED_BYTE &&
-       type != GL_BYTE &&
-       type != GL_UNSIGNED_SHORT &&
-       type != GL_SHORT &&
-       type != GL_UNSIGNED_INT &&
-       type != GL_INT &&
-       type != GL_FLOAT) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetMinmax(type)");
-      return;
-   }
-
-   if (!values)
-      return;
-
-   {
-      GLfloat minmax[2][4];
-      minmax[0][RCOMP] = CLAMP(ctx->MinMax.Min[RCOMP], 0.0F, 1.0F);
-      minmax[0][GCOMP] = CLAMP(ctx->MinMax.Min[GCOMP], 0.0F, 1.0F);
-      minmax[0][BCOMP] = CLAMP(ctx->MinMax.Min[BCOMP], 0.0F, 1.0F);
-      minmax[0][ACOMP] = CLAMP(ctx->MinMax.Min[ACOMP], 0.0F, 1.0F);
-      minmax[1][RCOMP] = CLAMP(ctx->MinMax.Max[RCOMP], 0.0F, 1.0F);
-      minmax[1][GCOMP] = CLAMP(ctx->MinMax.Max[GCOMP], 0.0F, 1.0F);
-      minmax[1][BCOMP] = CLAMP(ctx->MinMax.Max[BCOMP], 0.0F, 1.0F);
-      minmax[1][ACOMP] = CLAMP(ctx->MinMax.Max[ACOMP], 0.0F, 1.0F);
-      pack_minmax(ctx, (CONST GLfloat (*)[4]) minmax,
-                  format, type, values, &ctx->Pack);
-   }
-
-   if (reset) {
-      _mesa_ResetMinmax(GL_MINMAX);
-   }
-}
-
-
-void
-_mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetHistogram");
-
-   if (target != GL_HISTOGRAM) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetHistogram(target)");
-      return;
-   }
-
-   if (format != GL_RED &&
-       format != GL_GREEN &&
-       format != GL_BLUE &&
-       format != GL_ALPHA &&
-       format != GL_RGB &&
-       format != GL_RGBA &&
-       format != GL_ABGR_EXT &&
-       format != GL_LUMINANCE &&
-       format != GL_LUMINANCE_ALPHA) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetHistogram(format)");
-      return;
-   }
-
-   if (type != GL_UNSIGNED_BYTE &&
-       type != GL_BYTE &&
-       type != GL_UNSIGNED_SHORT &&
-       type != GL_SHORT &&
-       type != GL_UNSIGNED_INT &&
-       type != GL_INT &&
-       type != GL_FLOAT) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetHistogram(type)");
-      return;
-   }
-
-   if (!values)
-      return;
-
-   pack_histogram(ctx, ctx->Histogram.Width,
-                  (CONST GLuint (*)[4]) ctx->Histogram.Count,
-                  format, type, values, &ctx->Pack);
-
-   if (reset) {
-      GLuint i;
-      for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
-         ctx->Histogram.Count[i][0] = 0;
-         ctx->Histogram.Count[i][1] = 0;
-         ctx->Histogram.Count[i][2] = 0;
-         ctx->Histogram.Count[i][3] = 0;
-      }
-   }
-}
-
-
-void
-_mesa_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetHistogramParameterfv");
-
-   if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(target)");
-      return;
-   }
-
-   switch (pname) {
-      case GL_HISTOGRAM_WIDTH:
-         *params = (GLfloat) ctx->Histogram.Width;
-         break;
-      case GL_HISTOGRAM_FORMAT:
-         *params = (GLfloat) ctx->Histogram.Format;
-         break;
-      case GL_HISTOGRAM_RED_SIZE:
-         *params = (GLfloat) ctx->Histogram.RedSize;
-         break;
-      case GL_HISTOGRAM_GREEN_SIZE:
-         *params = (GLfloat) ctx->Histogram.GreenSize;
-         break;
-      case GL_HISTOGRAM_BLUE_SIZE:
-         *params = (GLfloat) ctx->Histogram.BlueSize;
-         break;
-      case GL_HISTOGRAM_ALPHA_SIZE:
-         *params = (GLfloat) ctx->Histogram.AlphaSize;
-         break;
-      case GL_HISTOGRAM_LUMINANCE_SIZE:
-         *params = (GLfloat) ctx->Histogram.LuminanceSize;
-         break;
-      case GL_HISTOGRAM_SINK:
-         *params = (GLfloat) ctx->Histogram.Sink;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(pname)");
-   }
-}
-
-
-void
-_mesa_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetHistogramParameteriv");
-
-   if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(target)");
-      return;
-   }
-
-   switch (pname) {
-      case GL_HISTOGRAM_WIDTH:
-         *params = (GLint) ctx->Histogram.Width;
-         break;
-      case GL_HISTOGRAM_FORMAT:
-         *params = (GLint) ctx->Histogram.Format;
-         break;
-      case GL_HISTOGRAM_RED_SIZE:
-         *params = (GLint) ctx->Histogram.RedSize;
-         break;
-      case GL_HISTOGRAM_GREEN_SIZE:
-         *params = (GLint) ctx->Histogram.GreenSize;
-         break;
-      case GL_HISTOGRAM_BLUE_SIZE:
-         *params = (GLint) ctx->Histogram.BlueSize;
-         break;
-      case GL_HISTOGRAM_ALPHA_SIZE:
-         *params = (GLint) ctx->Histogram.AlphaSize;
-         break;
-      case GL_HISTOGRAM_LUMINANCE_SIZE:
-         *params = (GLint) ctx->Histogram.LuminanceSize;
-         break;
-      case GL_HISTOGRAM_SINK:
-         *params = (GLint) ctx->Histogram.Sink;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(pname)");
-   }
-}
-
-
-void
-_mesa_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetMinmaxParameterfv");
-
-   if (target != GL_MINMAX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameterfv(target)");
-      return;
-   }
-   if (pname == GL_MINMAX_FORMAT) {
-      *params = (GLfloat) ctx->MinMax.Format;
-   }
-   else if (pname == GL_MINMAX_SINK) {
-      *params = (GLfloat) ctx->MinMax.Sink;
-   }
-   else {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameterfv(pname)");
-   }
-}
-
-
-void
-_mesa_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetMinmaxParameteriv");
-
-   if (target != GL_MINMAX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameteriv(target)");
-      return;
-   }
-   if (pname == GL_MINMAX_FORMAT) {
-      *params = (GLint) ctx->MinMax.Format;
-   }
-   else if (pname == GL_MINMAX_SINK) {
-      *params = (GLint) ctx->MinMax.Sink;
-   }
-   else {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameteriv(pname)");
-   }
-}
-
-
-void
-_mesa_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink)
-{
-   GLuint i;
-   GLboolean error = GL_FALSE;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glHistogram");
-
-   if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) {
-      gl_error(ctx, GL_INVALID_ENUM, "glHistogram(target)");
-      return;
-   }
-
-   if (width < 0 || width > HISTOGRAM_TABLE_SIZE) {
-      if (target == GL_PROXY_HISTOGRAM) {
-         error = GL_TRUE;
-      }
-      else {
-         if (width < 0)
-            gl_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
-         else
-            gl_error(ctx, GL_TABLE_TOO_LARGE, "glHistogram(width)");
-         return;
-      }
-   }
-
-   if (width != 0 && _mesa_bitcount(width) != 1) {
-      if (target == GL_PROXY_HISTOGRAM) {
-         error = GL_TRUE;
-      }
-      else {
-         gl_error(ctx, GL_INVALID_VALUE, "glHistogram(width)");
-         return;
-      }
-   }
-
-   if (base_histogram_format(internalFormat) < 0) {
-      if (target == GL_PROXY_HISTOGRAM) {
-         error = GL_TRUE;
-      }
-      else {
-         gl_error(ctx, GL_INVALID_ENUM, "glHistogram(internalFormat)");
-         return;
-      }
-   }
-
-   /* reset histograms */
-   for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
-      ctx->Histogram.Count[i][0] = 0;
-      ctx->Histogram.Count[i][1] = 0;
-      ctx->Histogram.Count[i][2] = 0;
-      ctx->Histogram.Count[i][3] = 0;
-   }
-
-   if (error) {
-      ctx->Histogram.Width = 0;
-      ctx->Histogram.Format = 0;
-      ctx->Histogram.RedSize       = 0;
-      ctx->Histogram.GreenSize     = 0;
-      ctx->Histogram.BlueSize      = 0;
-      ctx->Histogram.AlphaSize     = 0;
-      ctx->Histogram.LuminanceSize = 0;
-   }
-   else {
-      ctx->Histogram.Width = width;
-      ctx->Histogram.Format = internalFormat;
-      ctx->Histogram.Sink = sink;
-      ctx->Histogram.RedSize       = 0xffffffff;
-      ctx->Histogram.GreenSize     = 0xffffffff;
-      ctx->Histogram.BlueSize      = 0xffffffff;
-      ctx->Histogram.AlphaSize     = 0xffffffff;
-      ctx->Histogram.LuminanceSize = 0xffffffff;
-   }
-}
-
-
-void
-_mesa_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMinmax");
-
-   if (target != GL_MINMAX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glMinMax(target)");
-      return;
-   }
-
-   if (base_histogram_format(internalFormat) < 0) {
-      gl_error(ctx, GL_INVALID_ENUM, "glMinMax(internalFormat)");
-      return;
-   }
-
-   ctx->MinMax.Sink = sink;
-}
-
-
-void
-_mesa_ResetHistogram(GLenum target)
-{
-   GLuint i;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glResetHistogram");
-
-   if (target != GL_HISTOGRAM) {
-      gl_error(ctx, GL_INVALID_ENUM, "glResetHistogram(target)");
-      return;
-   }
-
-   for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
-      ctx->Histogram.Count[i][0] = 0;
-      ctx->Histogram.Count[i][1] = 0;
-      ctx->Histogram.Count[i][2] = 0;
-      ctx->Histogram.Count[i][3] = 0;
-   }
-}
-
-
-void
-_mesa_ResetMinmax(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glResetMinmax");
-
-   if (target != GL_MINMAX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glResetMinMax(target)");
-      return;
-   }
-
-   ctx->MinMax.Min[RCOMP] = 1000;    ctx->MinMax.Max[RCOMP] = -1000;
-   ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
-   ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
-   ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
-}
-
-
-
-/*
- * Update the min/max values from an array of fragment colors.
- */
-void
-_mesa_update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
-{
-   GLuint i;
-   for (i = 0; i < n; i++) {
-      /* update mins */
-      if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP])
-         ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP];
-      if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP])
-         ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP];
-      if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP])
-         ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP];
-      if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP])
-         ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP];
-
-      /* update maxs */
-      if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP])
-         ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP];
-      if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP])
-         ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP];
-      if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP])
-         ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP];
-      if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP])
-         ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP];
-   }
-}
-
-
-/*
- * Update the histogram values from an array of fragment colors.
- */
-void
-_mesa_update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
-{
-   const GLint max = ctx->Histogram.Width - 1;
-   GLfloat w = (GLfloat) max;
-   GLuint i;
-
-   if (ctx->Histogram.Width == 0)
-      return;
-   
-   for (i = 0; i < n; i++) {
-      GLint ri = (GLint) (rgba[i][RCOMP] * w + 0.5F);
-      GLint gi = (GLint) (rgba[i][GCOMP] * w + 0.5F);
-      GLint bi = (GLint) (rgba[i][BCOMP] * w + 0.5F);
-      GLint ai = (GLint) (rgba[i][ACOMP] * w + 0.5F);
-      ri = CLAMP(ri, 0, max);
-      gi = CLAMP(gi, 0, max);
-      bi = CLAMP(bi, 0, max);
-      ai = CLAMP(ai, 0, max);
-      ctx->Histogram.Count[ri][RCOMP]++;
-      ctx->Histogram.Count[gi][GCOMP]++;
-      ctx->Histogram.Count[bi][BCOMP]++;
-      ctx->Histogram.Count[ai][ACOMP]++;
-   }
-}
-
-
-
-/**********************************************************************/
-/****                        Convolution                          *****/
-/**********************************************************************/
-
-void
-_mesa_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
-{
-   GLenum baseFormat;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glConvolutionFilter1D");
-
-   if (target != GL_CONVOLUTION_1D) {
-      gl_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(target)");
-      return;
-   }
-
-   baseFormat = base_filter_format(internalFormat);
-   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(internalFormat)");
-      return;
-   }
-
-   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
-      gl_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter1D(width)");
-      return;
-   }
-
-   if (!_mesa_is_legal_format_and_type(format, type) ||
-       format == GL_COLOR_INDEX ||
-       format == GL_STENCIL_INDEX ||
-       format == GL_DEPTH_COMPONENT ||
-       format == GL_INTENSITY ||
-       type == GL_BITMAP) {
-      gl_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter1D(format or type)");
-      return;
-   }
-
-   ctx->Convolution1D.Format = format;
-   ctx->Convolution1D.InternalFormat = internalFormat;
-   ctx->Convolution1D.Width = width;
-   ctx->Convolution1D.Height = 1;
-
-   /* unpack filter image and apply scale and bias */
-   _mesa_unpack_float_color_span(ctx, width, GL_RGBA,
-                                 ctx->Convolution1D.Filter,
-                                 format, type, image, &ctx->Unpack,
-                                 GL_FALSE, GL_FALSE);
-   {
-      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[0];
-      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[0];
-      GLint i;
-      for (i = 0; i < width; i++) {
-         GLfloat r = ctx->Convolution1D.Filter[i * 4 + 0];
-         GLfloat g = ctx->Convolution1D.Filter[i * 4 + 1];
-         GLfloat b = ctx->Convolution1D.Filter[i * 4 + 2];
-         GLfloat a = ctx->Convolution1D.Filter[i * 4 + 3];
-         r = r * scale[0] + bias[0];
-         g = g * scale[1] + bias[1];
-         b = b * scale[2] + bias[2];
-         a = a * scale[3] + bias[3];
-         ctx->Convolution1D.Filter[i * 4 + 0] = r;
-         ctx->Convolution1D.Filter[i * 4 + 1] = g;
-         ctx->Convolution1D.Filter[i * 4 + 2] = b;
-         ctx->Convolution1D.Filter[i * 4 + 3] = a;
-      }
-   }
-}
-
-
-void
-_mesa_ConvolutionFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
-{
-   GLenum baseFormat;
-   GLint i, components;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glConvolutionFilter2D");
-
-   if (target != GL_CONVOLUTION_2D) {
-      gl_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(target)");
-      return;
-   }
-
-   baseFormat = base_filter_format(internalFormat);
-   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(internalFormat)");
-      return;
-   }
-
-   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
-      gl_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter2D(width)");
-      return;
-   }
-   if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) {
-      gl_error(ctx, GL_INVALID_VALUE, "glConvolutionFilter2D(height)");
-      return;
-   }
-
-   if (!_mesa_is_legal_format_and_type(format, type) ||
-       format == GL_COLOR_INDEX ||
-       format == GL_STENCIL_INDEX ||
-       format == GL_DEPTH_COMPONENT ||
-       format == GL_INTENSITY ||
-       type == GL_BITMAP) {
-      gl_error(ctx, GL_INVALID_ENUM, "glConvolutionFilter2D(format or type)");
-      return;
-   }
-
-   components = _mesa_components_in_format(format);
-   assert(components > 0);  /* this should have been caught earlier */
-
-   ctx->Convolution2D.Format = format;
-   ctx->Convolution2D.InternalFormat = internalFormat;
-   ctx->Convolution2D.Width = width;
-   ctx->Convolution2D.Height = height;
-
-   /* unpack filter image and apply scale and bias */
-   for (i = 0; i < height; i++) {
-      const GLvoid *src = _mesa_image_address(&ctx->Unpack, image, width,
-                                              height, format, type, 0, i, 0);
-      GLfloat *dst = ctx->Convolution2D.Filter + i * width * components;
-      _mesa_unpack_float_color_span(ctx, width, GL_RGBA, dst,
-                                    format, type, src, &ctx->Unpack,
-                                    GL_FALSE, GL_FALSE);
-   }
-
-   {
-      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[1];
-      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[1];
-      for (i = 0; i < width * height; i++) {
-         GLfloat r = ctx->Convolution2D.Filter[i * 4 + 0];
-         GLfloat g = ctx->Convolution2D.Filter[i * 4 + 1];
-         GLfloat b = ctx->Convolution2D.Filter[i * 4 + 2];
-         GLfloat a = ctx->Convolution2D.Filter[i * 4 + 3];
-         r = r * scale[0] + bias[0];
-         g = g * scale[1] + bias[1];
-         b = b * scale[2] + bias[2];
-         a = a * scale[3] + bias[3];
-         ctx->Convolution2D.Filter[i * 4 + 0] = r;
-         ctx->Convolution2D.Filter[i * 4 + 1] = g;
-         ctx->Convolution2D.Filter[i * 4 + 2] = b;
-         ctx->Convolution2D.Filter[i * 4 + 3] = a;
-      }
-   }
-}
-
-
-void
-_mesa_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint c;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glConvolutionParameterf");
-
-   switch (target) {
-      case GL_CONVOLUTION_1D:
-         c = 0;
-         break;
-      case GL_CONVOLUTION_2D:
-         c = 1;
-         break;
-      case GL_SEPARABLE_2D:
-         c = 2;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(target)");
-         return;
-   }
-
-   switch (pname) {
-      case GL_CONVOLUTION_BORDER_MODE:
-         if (param == (GLfloat) GL_REDUCE ||
-             param == (GLfloat) GL_CONSTANT_BORDER ||
-             param == (GLfloat) GL_REPLICATE_BORDER) {
-            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) param;
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(params)");
-            return;
-         }
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterf(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_convolution_attrib *conv;
-   GLuint c;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glConvolutionParameterfv");
-
-   switch (target) {
-      case GL_CONVOLUTION_1D:
-         c = 0;
-         conv = &ctx->Convolution1D;
-         break;
-      case GL_CONVOLUTION_2D:
-         c = 1;
-         conv = &ctx->Convolution2D;
-         break;
-      case GL_SEPARABLE_2D:
-         c = 2;
-         conv = &ctx->Separable2D;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(target)");
-         return;
-   }
-
-   switch (pname) {
-      case GL_CONVOLUTION_BORDER_COLOR:
-         COPY_4V(ctx->Pixel.ConvolutionBorderColor[c], params);
-         break;
-      case GL_CONVOLUTION_BORDER_MODE:
-         if (params[0] == (GLfloat) GL_REDUCE ||
-             params[0] == (GLfloat) GL_CONSTANT_BORDER ||
-             params[0] == (GLfloat) GL_REPLICATE_BORDER) {
-            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) params[0];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(params)");
-            return;
-         }
-         break;
-      case GL_CONVOLUTION_FILTER_SCALE:
-         COPY_4V(ctx->Pixel.ConvolutionFilterScale[c], params);
-         break;
-      case GL_CONVOLUTION_FILTER_BIAS:
-         COPY_4V(ctx->Pixel.ConvolutionFilterBias[c], params);
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameterfv(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint c;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glConvolutionParameteri");
-
-   switch (target) {
-      case GL_CONVOLUTION_1D:
-         c = 0;
-         break;
-      case GL_CONVOLUTION_2D:
-         c = 1;
-         break;
-      case GL_SEPARABLE_2D:
-         c = 2;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(target)");
-         return;
-   }
-
-   switch (pname) {
-      case GL_CONVOLUTION_BORDER_MODE:
-         if (param == (GLint) GL_REDUCE ||
-             param == (GLint) GL_CONSTANT_BORDER ||
-             param == (GLint) GL_REPLICATE_BORDER) {
-            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) param;
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(params)");
-            return;
-         }
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteri(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_convolution_attrib *conv;
-   GLuint c;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glConvolutionParameteriv");
-
-   switch (target) {
-      case GL_CONVOLUTION_1D:
-         c = 0;
-         conv = &ctx->Convolution1D;
-         break;
-      case GL_CONVOLUTION_2D:
-         c = 1;
-         conv = &ctx->Convolution2D;
-         break;
-      case GL_SEPARABLE_2D:
-         c = 2;
-         conv = &ctx->Separable2D;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(target)");
-         return;
-   }
-
-   switch (pname) {
-      case GL_CONVOLUTION_BORDER_COLOR:
-	 ctx->Pixel.ConvolutionBorderColor[c][0] = INT_TO_FLOAT(params[0]);
-	 ctx->Pixel.ConvolutionBorderColor[c][1] = INT_TO_FLOAT(params[1]);
-	 ctx->Pixel.ConvolutionBorderColor[c][2] = INT_TO_FLOAT(params[2]);
-	 ctx->Pixel.ConvolutionBorderColor[c][3] = INT_TO_FLOAT(params[3]);
-         break;
-      case GL_CONVOLUTION_BORDER_MODE:
-         if (params[0] == (GLint) GL_REDUCE ||
-             params[0] == (GLint) GL_CONSTANT_BORDER ||
-             params[0] == (GLint) GL_REPLICATE_BORDER) {
-            ctx->Pixel.ConvolutionBorderMode[c] = (GLenum) params[0];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(params)");
-            return;
-         }
-         break;
-      case GL_CONVOLUTION_FILTER_SCALE:
-         COPY_4V(ctx->Pixel.ConvolutionFilterScale[c], params);
-         break;
-      case GL_CONVOLUTION_FILTER_BIAS:
-         COPY_4V(ctx->Pixel.ConvolutionFilterBias[c], params);
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glConvolutionParameteriv(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width)
-{
-   GLenum baseFormat;
-   GLubyte rgba[MAX_CONVOLUTION_WIDTH][4];
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyConvolutionFilter1D");
-
-   if (target != GL_CONVOLUTION_1D) {
-      gl_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter1D(target)");
-      return;
-   }
-
-   baseFormat = base_filter_format(internalFormat);
-   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter1D(internalFormat)");
-      return;
-   }
-
-   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
-      gl_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter1D(width)");
-      return;
-   }
-
-   /* read pixels from framebuffer */
-   RENDER_START(ctx);
-   gl_read_rgba_span(ctx, ctx->ReadBuffer, width, x, y, (GLubyte (*)[4]) rgba);
-   RENDER_FINISH(ctx);
-
-   /* store as convolution filter */
-   _mesa_ConvolutionFilter1D(target, internalFormat, width,
-                             GL_RGBA, GL_UNSIGNED_BYTE, rgba);
-}
-
-
-void
-_mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   GLenum baseFormat;
-   GLint i;
-   struct gl_pixelstore_attrib packSave;
-   GLubyte rgba[MAX_CONVOLUTION_HEIGHT][MAX_CONVOLUTION_WIDTH][4];
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyConvolutionFilter2D");
-
-   if (target != GL_CONVOLUTION_2D) {
-      gl_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter2D(target)");
-      return;
-   }
-
-   baseFormat = base_filter_format(internalFormat);
-   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glCopyConvolutionFilter2D(internalFormat)");
-      return;
-   }
-
-   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
-      gl_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter2D(width)");
-      return;
-   }
-   if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) {
-      gl_error(ctx, GL_INVALID_VALUE, "glCopyConvolutionFilter2D(height)");
-      return;
-   }
-
-   /* read pixels from framebuffer */
-   RENDER_START(ctx);
-   for (i = 0; i < height; i++) {
-      gl_read_rgba_span(ctx, ctx->ReadBuffer, width, x, y + i,
-                        (GLubyte (*)[4]) rgba[i]);
-   }
-   RENDER_FINISH(ctx);
-
-   /*
-    * store as convolution filter
-    */
-   packSave = ctx->Unpack;  /* save pixel packing params */
-
-   ctx->Unpack.Alignment = 1;
-   ctx->Unpack.RowLength = MAX_CONVOLUTION_WIDTH;
-   ctx->Unpack.SkipPixels = 0;
-   ctx->Unpack.SkipRows = 0;
-   ctx->Unpack.ImageHeight = 0;
-   ctx->Unpack.SkipImages = 0;
-   ctx->Unpack.SwapBytes = GL_FALSE;
-   ctx->Unpack.LsbFirst = GL_FALSE;
-
-   _mesa_ConvolutionFilter2D(target, internalFormat, width, height,
-                             GL_RGBA, GL_UNSIGNED_BYTE, rgba);
-
-   ctx->Unpack = packSave;  /* restore pixel packing params */
-}
-
-
-void
-_mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
-{
-   const struct gl_convolution_attrib *filter;
-   GLint row;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetConvolutionFilter");
-
-   if (target != GL_CONVOLUTION_1D && target != GL_CONVOLUTION_2D) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(target)");
-      return;
-   }
-
-   if (!_mesa_is_legal_format_and_type(format, type) ||
-       format == GL_COLOR_INDEX ||
-       format == GL_STENCIL_INDEX ||
-       format == GL_DEPTH_COMPONENT ||
-       format == GL_INTENSITY ||
-       type == GL_BITMAP) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(format or type)");
-      return;
-   }
-
-   switch (target) {
-      case GL_CONVOLUTION_1D:
-         filter = &(ctx->Convolution1D);
-         break;
-      case GL_CONVOLUTION_2D:
-         filter = &(ctx->Convolution2D);
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(target)");
-         return;
-   }
-
-   for (row = 0; row < filter->Height; row++) {
-      GLvoid *dst = _mesa_image_address( &ctx->Pack, image, filter->Width,
-                                         filter->Height, format, type,
-                                         0, row, 0);
-      const GLfloat *src = filter->Filter + row * filter->Width * 4;
-      GLubyte img[MAX_WIDTH * 4];
-      GLint i;
-      for (i = 0; i < filter->Width * 4; i++) {
-         img[i] = (GLint) (CLAMP(src[i], 0.0, 1.0) * 255.0);
-      }
-      _mesa_pack_rgba_span(ctx, filter->Width, (const GLubyte (*)[4]) img,
-                           format, type, dst, &ctx->Pack, 0);
-   }
-}
-
-
-void
-_mesa_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const struct gl_convolution_attrib *conv;
-   GLuint c;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetConvolutionParameterfv");
-
-   switch (target) {
-      case GL_CONVOLUTION_1D:
-         c = 0;
-         conv = &ctx->Convolution1D;
-         break;
-      case GL_CONVOLUTION_2D:
-         c = 1;
-         conv = &ctx->Convolution2D;
-         break;
-      case GL_SEPARABLE_2D:
-         c = 2;
-         conv = &ctx->Separable2D;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameterfv(target)");
-         return;
-   }
-
-   switch (pname) {
-      case GL_CONVOLUTION_BORDER_COLOR:
-         COPY_4V(params, ctx->Pixel.ConvolutionBorderColor[c]);
-         break;
-      case GL_CONVOLUTION_BORDER_MODE:
-         *params = (GLfloat) ctx->Pixel.ConvolutionBorderMode[c];
-         break;
-      case GL_CONVOLUTION_FILTER_SCALE:
-         COPY_4V(params, ctx->Pixel.ConvolutionFilterScale[c]);
-         break;
-      case GL_CONVOLUTION_FILTER_BIAS:
-         COPY_4V(params, ctx->Pixel.ConvolutionFilterBias[c]);
-         break;
-      case GL_CONVOLUTION_FORMAT:
-         *params = (GLfloat) conv->Format;
-         break;
-      case GL_CONVOLUTION_WIDTH:
-         *params = (GLfloat) conv->Width;
-         break;
-      case GL_CONVOLUTION_HEIGHT:
-         *params = (GLfloat) conv->Height;
-         break;
-      case GL_MAX_CONVOLUTION_WIDTH:
-         *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
-         break;
-      case GL_MAX_CONVOLUTION_HEIGHT:
-         *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameterfv(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const struct gl_convolution_attrib *conv;
-   GLuint c;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetConvolutionParameteriv");
-
-   switch (target) {
-      case GL_CONVOLUTION_1D:
-         c = 0;
-         conv = &ctx->Convolution1D;
-         break;
-      case GL_CONVOLUTION_2D:
-         c = 1;
-         conv = &ctx->Convolution2D;
-         break;
-      case GL_SEPARABLE_2D:
-         c = 2;
-         conv = &ctx->Separable2D;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(target)");
-         return;
-   }
-
-   switch (pname) {
-      case GL_CONVOLUTION_BORDER_COLOR:
-         params[0] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][0]);
-         params[1] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][1]);
-         params[2] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][2]);
-         params[3] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][3]);
-         break;
-      case GL_CONVOLUTION_BORDER_MODE:
-         *params = (GLint) ctx->Pixel.ConvolutionBorderMode[c];
-         break;
-      case GL_CONVOLUTION_FILTER_SCALE:
-         params[0] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][0];
-         params[1] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][1];
-         params[2] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][2];
-         params[3] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][3];
-         break;
-      case GL_CONVOLUTION_FILTER_BIAS:
-         params[0] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][0];
-         params[1] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][1];
-         params[2] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][2];
-         params[3] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][3];
-         break;
-      case GL_CONVOLUTION_FORMAT:
-         *params = (GLint) conv->Format;
-         break;
-      case GL_CONVOLUTION_WIDTH:
-         *params = (GLint) conv->Width;
-         break;
-      case GL_CONVOLUTION_HEIGHT:
-         *params = (GLint) conv->Height;
-         break;
-      case GL_MAX_CONVOLUTION_WIDTH:
-         *params = (GLint) ctx->Const.MaxConvolutionWidth;
-         break;
-      case GL_MAX_CONVOLUTION_HEIGHT:
-         *params = (GLint) ctx->Const.MaxConvolutionHeight;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_GetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetSeparableFilter");
-
-   if (target != GL_SEPARABLE_2D) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetSeparableFilter(target)");
-      return;
-   }
-
-   if (!_mesa_is_legal_format_and_type(format, type) ||
-       format == GL_COLOR_INDEX ||
-       format == GL_STENCIL_INDEX ||
-       format == GL_DEPTH_COMPONENT ||
-       format == GL_INTENSITY ||
-       type == GL_BITMAP) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetConvolutionFilter(format or type)");
-      return;
-   }
-
-   (void) row;
-   (void) column;
-   (void) span;
-}
-
-
-void
-_mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
-{
-   const GLint colStart = MAX_CONVOLUTION_WIDTH * 4;
-   GLenum baseFormat;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glSeparableFilter2D");
-
-   if (target != GL_SEPARABLE_2D) {
-      gl_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(target)");
-      return;
-   }
-
-   baseFormat = base_filter_format(internalFormat);
-   if (baseFormat < 0 || baseFormat == GL_COLOR_INDEX) {
-      gl_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(internalFormat)");
-      return;
-   }
-
-   if (width < 0 || width > MAX_CONVOLUTION_WIDTH) {
-      gl_error(ctx, GL_INVALID_VALUE, "glSeparableFilter2D(width)");
-      return;
-   }
-   if (height < 0 || height > MAX_CONVOLUTION_HEIGHT) {
-      gl_error(ctx, GL_INVALID_VALUE, "glSeparableFilter2D(height)");
-      return;
-   }
-
-   if (!_mesa_is_legal_format_and_type(format, type) ||
-       format == GL_COLOR_INDEX ||
-       format == GL_STENCIL_INDEX ||
-       format == GL_DEPTH_COMPONENT ||
-       format == GL_INTENSITY ||
-       type == GL_BITMAP) {
-      gl_error(ctx, GL_INVALID_ENUM, "glSeparableFilter2D(format or type)");
-      return;
-   }
-
-   ctx->Separable2D.Format = format;
-   ctx->Separable2D.InternalFormat = internalFormat;
-   ctx->Separable2D.Width = width;
-   ctx->Separable2D.Height = height;
-
-   /* unpack row filter */
-   _mesa_unpack_float_color_span(ctx, width, GL_RGBA,
-                                 ctx->Separable2D.Filter,
-                                 format, type, row, &ctx->Unpack,
-                                 GL_FALSE, GL_FALSE);
-   {
-      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[2];
-      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[2];
-      GLint i;
-      for (i = 0; i < width; i++) {
-         GLfloat r = ctx->Separable2D.Filter[i * 4 + 0];
-         GLfloat g = ctx->Separable2D.Filter[i * 4 + 1];
-         GLfloat b = ctx->Separable2D.Filter[i * 4 + 2];
-         GLfloat a = ctx->Separable2D.Filter[i * 4 + 3];
-         r = r * scale[0] + bias[0];
-         g = g * scale[1] + bias[1];
-         b = b * scale[2] + bias[2];
-         a = a * scale[3] + bias[3];
-         ctx->Separable2D.Filter[i * 4 + 0] = r;
-         ctx->Separable2D.Filter[i * 4 + 1] = g;
-         ctx->Separable2D.Filter[i * 4 + 2] = b;
-         ctx->Separable2D.Filter[i * 4 + 3] = a;
-      }
-   }
-
-   /* unpack column filter */
-   _mesa_unpack_float_color_span(ctx, width, GL_RGBA,
-                                 &ctx->Separable2D.Filter[colStart],
-                                 format, type, column, &ctx->Unpack,
-                                 GL_FALSE, GL_FALSE);
-   {
-      const GLfloat *scale = ctx->Pixel.ConvolutionFilterScale[2];
-      const GLfloat *bias = ctx->Pixel.ConvolutionFilterBias[2];
-      GLint i;
-      for (i = 0; i < width; i++) {
-         GLfloat r = ctx->Separable2D.Filter[i * 4 + 0 + colStart];
-         GLfloat g = ctx->Separable2D.Filter[i * 4 + 1 + colStart];
-         GLfloat b = ctx->Separable2D.Filter[i * 4 + 2 + colStart];
-         GLfloat a = ctx->Separable2D.Filter[i * 4 + 3 + colStart];
-         r = r * scale[0] + bias[0];
-         g = g * scale[1] + bias[1];
-         b = b * scale[2] + bias[2];
-         a = a * scale[3] + bias[3];
-         ctx->Separable2D.Filter[i * 4 + 0 + colStart] = r;
-         ctx->Separable2D.Filter[i * 4 + 1 + colStart] = g;
-         ctx->Separable2D.Filter[i * 4 + 2 + colStart] = b;
-         ctx->Separable2D.Filter[i * 4 + 3 + colStart] = a;
-      }
-   }
-}
-
Index: xc/extras/Mesa/src/imaging.h
diff -u xc/extras/Mesa/src/imaging.h:1.4 xc/extras/Mesa/src/imaging.h:removed
--- xc/extras/Mesa/src/imaging.h:1.4	Fri Jun 16 20:02:13 2000
+++ xc/extras/Mesa/src/imaging.h	Thu Feb 27 12:15:39 2003
@@ -1,94 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef IMAGING_H
-#define IMAGING_H
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "types.h"
-#endif
-
-
-
-extern void _mesa_ConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-
-extern void _mesa_ConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-
-extern void _mesa_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
-
-extern void _mesa_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);
-
-extern void _mesa_ConvolutionParameteri(GLenum target, GLenum pname, GLint params);
-
-extern void _mesa_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);
-
-extern void _mesa_CopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-
-extern void _mesa_CopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-
-extern void _mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);
-
-extern void _mesa_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);
-
-extern void _mesa_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);
-
-extern void _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values);
-
-extern void _mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-
-extern void _mesa_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);
-
-extern void _mesa_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);
-
-extern void _mesa_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);
-
-extern void _mesa_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);
-
-extern void _mesa_GetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-
-extern void _mesa_Histogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-
-extern void _mesa_Minmax(GLenum target, GLenum internalformat, GLboolean sink);
-
-extern void _mesa_ResetHistogram(GLenum target);
-
-extern void _mesa_ResetMinmax(GLenum target);
-
-extern void _mesa_SeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-
-
-extern void
-_mesa_update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]);
-
-extern void
-_mesa_update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]);
-
-
-#endif
Index: xc/extras/Mesa/src/imports.c
diff -u /dev/null xc/extras/Mesa/src/imports.c:1.2
--- /dev/null	Thu Feb 27 12:15:39 2003
+++ xc/extras/Mesa/src/imports.c	Mon Dec 16 11:18:27 2002
@@ -0,0 +1,170 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Imports are functions which the device driver or window system or
+ * operating system provides to the core renderer.  The core renderer (Mesa)
+ * will call these functions in order to do memory allocation, simple I/O,
+ * etc.
+ *
+ * Some drivers will need to implement these functions themselves but
+ * many (most?) Mesa drivers will be fine using these.
+ *
+ * A server-side GL renderer will likely not use these functions since
+ * the renderer should use the XFree86-wrapped system calls.
+ */
+
+
+#include "glheader.h"
+#include "imports.h"
+#include "mem.h"
+#include "mtypes.h"
+
+
+static void *
+_mesa_Malloc(__GLcontext *gc, size_t size)
+{
+   return MALLOC(size);
+}
+
+static void *
+_mesa_Calloc(__GLcontext *gc, size_t numElem, size_t elemSize)
+{
+   return CALLOC(numElem * elemSize);
+}
+
+static void *
+_mesa_Realloc(__GLcontext *gc, void *oldAddr, size_t newSize)
+{
+   return realloc(oldAddr, newSize);
+}
+
+static void
+_mesa_Free(__GLcontext *gc, void *addr)
+{
+   FREE(addr);
+}
+
+/* Must be before '#undef getenv' for inclusion in XFree86.
+ */
+static char * CAPI
+_mesa_getenv(__GLcontext *gc, const char *var)
+{
+   (void) gc;
+   return getenv(var);
+}
+
+static void
+_mesa_warning(__GLcontext *gc, char *str)
+{
+   GLboolean debug;
+#ifdef DEBUG
+   debug = GL_TRUE;
+#else
+/* Whacko XFree86 macro:
+ */
+#ifdef getenv
+#undef getenv
+#endif
+   if (gc->imports.getenv(gc, "MESA_DEBUG")) {
+      debug = GL_TRUE;
+   }
+   else {
+      debug = GL_FALSE;
+   }
+#endif
+   if (debug) {
+      fprintf(stderr, "Mesa warning: %s\n", str);
+   }
+}
+
+static void
+_mesa_fatal(__GLcontext *gc, char *str)
+{
+   fprintf(stderr, "%s\n", str);
+   abort();
+}
+
+static int CAPI
+_mesa_atoi(__GLcontext *gc, const char *str)
+{
+   (void) gc;
+   return atoi(str);
+}
+
+static int CAPI
+_mesa_sprintf(__GLcontext *gc, char *str, const char *fmt, ...)
+{
+   /* XXX fix this */
+   return sprintf(str, fmt);
+}
+
+static void * CAPI
+_mesa_fopen(__GLcontext *gc, const char *path, const char *mode)
+{
+   return fopen(path, mode);
+}
+
+static int CAPI
+_mesa_fclose(__GLcontext *gc, void *stream)
+{
+   return fclose((FILE *) stream);
+}
+
+static int CAPI
+_mesa_fprintf(__GLcontext *gc, void *stream, const char *fmt, ...)
+{
+   /* XXX fix this */
+   return fprintf((FILE *) stream, fmt);
+}
+
+/* XXX this really is driver-specific and can't be here */
+static __GLdrawablePrivate *
+_mesa_GetDrawablePrivate(__GLcontext *gc)
+{
+   return NULL;
+}
+
+
+void
+_mesa_InitDefaultImports(__GLimports *imports, void *driverCtx, void *other)
+{
+   imports->malloc = _mesa_Malloc;
+   imports->calloc = _mesa_Calloc;
+   imports->realloc = _mesa_Realloc;
+   imports->free = _mesa_Free;
+   imports->warning = _mesa_warning;
+   imports->fatal = _mesa_fatal;
+   imports->getenv = _mesa_getenv;
+   imports->atoi = _mesa_atoi;
+   imports->sprintf = _mesa_sprintf;
+   imports->fopen = _mesa_fopen;
+   imports->fclose = _mesa_fclose;
+   imports->fprintf = _mesa_fprintf;
+   imports->getDrawablePrivate = _mesa_GetDrawablePrivate;
+/*     imports->wscx = driverCtx; */
+   imports->other = driverCtx;
+}
Index: xc/extras/Mesa/src/imports.h
diff -u /dev/null xc/extras/Mesa/src/imports.h:1.2
--- /dev/null	Thu Feb 27 12:15:39 2003
+++ xc/extras/Mesa/src/imports.h	Mon Dec 16 11:18:27 2002
@@ -0,0 +1,38 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef IMPORTS_H
+#define IMPORTS_H
+
+
+#include "glheader.h"
+
+
+extern void
+_mesa_InitDefaultImports(__GLimports *imports, void *driverCtx, void *other);
+
+
+#endif
Index: xc/extras/Mesa/src/indirect_tmp.h
diff -u xc/extras/Mesa/src/indirect_tmp.h:1.3 xc/extras/Mesa/src/indirect_tmp.h:removed
--- xc/extras/Mesa/src/indirect_tmp.h:1.3	Tue Feb 15 02:12:21 2000
+++ xc/extras/Mesa/src/indirect_tmp.h	Thu Feb 27 12:15:39 2003
@@ -1,168 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#define DO_CULL 0x1
-#define DO_OFFSET 0x2
-#define DO_LIGHT_TWOSIDE 0x4
-#define DO_UNFILLED 0x8
-#define HAVE_CULL_MASK 0x10
-
-
-static void TAG(render_triangle)( GLcontext *ctx,
-				  GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-
-#if ((IND & NEED_FACING) && !(IND & HAVE_CULL_MASK)) || (IND & DO_OFFSET)
-   GLfloat (*win)[4] = VB->Win.data;
-   GLfloat ex = win[v1][0] - win[v0][0];
-   GLfloat ey = win[v1][1] - win[v0][1];
-   GLfloat fx = win[v2][0] - win[v0][0];
-   GLfloat fy = win[v2][1] - win[v0][1];
-   GLfloat c = ex*fy-ey*fx;
-#endif
-
-#if (IND & NEED_FACING) 
-#if (IND & HAVE_CULL_MASK)
-   GLuint facing = ((VB->CullMask[pv]&PRIM_FACE_REAR)?1:0);
-#else
-   GLuint facing = (c<0.0F) ^ (ctx->Polygon.FrontFace==GL_CW);
-#endif
-#endif
-
-#if (IND & DO_CULL)
-   if ((facing+1) & ctx->Polygon.CullBits)
-      return;
-#endif
-
-#if (IND & DO_OFFSET)
-   {
-      /* finish computing plane equation of polygon, compute offset */
-      GLfloat fz = win[v2][2] - win[v0][2];
-      GLfloat ez = win[v1][2] - win[v0][2];
-      GLfloat a = ey*fz-ez*fy;
-      GLfloat b = ez*fx-ex*fz;
-      offset_polygon( ctx, a, b, c );
-   }
-#endif
-
-#if (IND & DO_LIGHT_TWOSIDE)
-   VB->Specular = VB->Spec[facing];
-   VB->ColorPtr = VB->Color[facing];
-   VB->IndexPtr = VB->Index[facing];
-#endif
-
-
-#if (IND & DO_UNFILLED)
-   {
-      GLuint vlist[3];
-      vlist[0] = v0;
-      vlist[1] = v1;
-      vlist[2] = v2;
-      unfilled_polygon( ctx, 3, vlist, pv, facing );
-   }
-#else
-   ctx->Driver.TriangleFunc( ctx, v0, v1, v2, pv );
-#endif
-}
-
-
-
-/* Implements quad rendering when direct_triangles is false.
- *
- * Need to implement cull check ?
- */
-static void render_quad( GLcontext *ctx, GLuint v0, GLuint v1,
-                         GLuint v2, GLuint v3, GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-
-   GLuint facing = ((VB->CullMask[pv]&PRIM_FACE_REAR)?1:0);
-
-
-   if (ctx->IndirectTriangles & DD_TRI_OFFSET) {
-      GLfloat (*win)[4] = VB->Win.data;
-      GLfloat ez = win[v2][2] - win[v0][2];
-      GLfloat fz = win[v3][2] - win[v1][2];
-      GLfloat ex = win[v2][0] - win[v0][0];
-      GLfloat ey = win[v2][1] - win[v0][1];
-      GLfloat fx = win[v3][0] - win[v1][0];
-      GLfloat fy = win[v3][1] - win[v1][1];
-      GLfloat a = ey*fz-ez*fy;
-      GLfloat b = ez*fx-ex*fz;
-      GLfloat c = ex*fy-ey*fx;
-      offset_polygon( ctx, a, b, c );
-   }
-
-
-   if (ctx->IndirectTriangles & DD_TRI_LIGHT_TWOSIDE) {
-      VB->Specular = VB->Spec[facing];
-      VB->ColorPtr = VB->Color[facing];
-      VB->IndexPtr = VB->Index[facing];
-   }
-
-
-   /* Render the quad! */
-   if (ctx->Polygon.Unfilled) {
-      GLuint vlist[4];
-      vlist[0] = v0;
-      vlist[1] = v1;
-      vlist[2] = v2;
-      vlist[3] = v3;
-      unfilled_polygon( ctx, 4, vlist, pv, facing );
-   }
-   else {
-      (*ctx->Driver.QuadFunc)( ctx, v0, v1, v2, v3, pv );
-   }
-}
-
-
-void unfilled_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, 
-			GLuint pv )
-{
-   GLuint vlist[4];
-   vlist[0] = v0;
-   vlist[1] = v1;
-   vlist[2] = v2;
-   unfilled_polygon( ctx, 3, vlist, pv, facing );
-}
-
-
-void unfilled_quad( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, 
-		    GLuint v3, GLuint pv )
-{
-   GLuint vlist[4];
-   vlist[0] = v0;
-   vlist[1] = v1;
-   vlist[2] = v2;
-   vlist[3] = v3;
-   unfilled_polygon( ctx, 4, vlist, pv, facing );
-}
-
Index: xc/extras/Mesa/src/interp_tmp.h
diff -u xc/extras/Mesa/src/interp_tmp.h:1.7 xc/extras/Mesa/src/interp_tmp.h:removed
--- xc/extras/Mesa/src/interp_tmp.h:1.7	Fri May 18 13:10:13 2001
+++ xc/extras/Mesa/src/interp_tmp.h	Thu Feb 27 12:15:39 2003
@@ -1,142 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#undef INTERP_UBYTE
-#define INTERP_UBYTE( out, t, a, b ) {			\
-      GLfloat fa = UBYTE_COLOR_TO_FLOAT_COLOR(a);	\
-      GLfloat fb = UBYTE_COLOR_TO_FLOAT_COLOR(b);	\
-      GLfloat fo = LINTERP(t, fa, fb);			\
-      FLOAT_COLOR_TO_UBYTE_COLOR(out, fo);		\
-}
-
-#if 1
-
-#undef INTERP_RGBA
-#define INTERP_RGBA(nr, t, out, a, b) {			\
-   int i;						\
-   for (i = 0; i < nr; i++) {				\
-      GLfloat fa = UBYTE_COLOR_TO_FLOAT_COLOR(a[i]);	\
-      GLfloat fb = UBYTE_COLOR_TO_FLOAT_COLOR(b[i]);	\
-      GLfloat fo = LINTERP(t, fa, fb);			\
-      FLOAT_COLOR_TO_UBYTE_COLOR(out[i], fo);		\
-   }							\
-}
-#else
-
-#undef INTERP_RGBA
-#define INTERP_RGBA(nr, t, out, a, b) {				\
-   int n;							\
-   const GLuint ti = FloatToInt(t*256.0F);			\
-   const GLubyte *Ib = (const GLubyte *)&a[0];			\
-   const GLubyte *Jb = (const GLubyte *)&b[0];			\
-   GLubyte *Ob = (GLubyte *)&out[0];				\
-								\
-   for (n = 0 ; n < nr ; n++)					\
-      Ob[n] = (GLubyte) (Ib[n] + ((ti * (Jb[n] - Ib[n]))/256));	\
-}
-#endif
-
-
-
-static void NAME( struct vertex_buffer *VB,
-		  GLuint dst, GLfloat t, GLuint in, GLuint out )
-{
-   (void) VB;
-   (void) dst;
-   (void) t;
-   (void) in;
-   (void) out;
-
-#if (IND & CLIP_RGBA0)
-   INTERP_RGBA( 4, t, 
-		VB->Color[0]->data[dst], 
-		VB->Color[0]->data[in],
-		VB->Color[0]->data[out] );
-#endif
-
-#if (IND & CLIP_RGBA1)
-   if (VB->ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-      INTERP_RGBA( 4, t, 
-		   VB->Color[1]->data[dst], 
-		   VB->Color[1]->data[in],
-		   VB->Color[1]->data[out] );
-   }
-
-   if (VB->ctx->TriangleCaps & DD_SEPERATE_SPECULAR) 
-   {
-      INTERP_RGBA( 3, t, 
-		   VB->Spec[0][dst], 
-		   VB->Spec[0][in],
-		   VB->Spec[0][out] );
-
-      if (VB->ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	 INTERP_RGBA( 3, t, 
-		      VB->Spec[1][dst], 
-		      VB->Spec[1][in],
-		      VB->Spec[1][out] );
-      }
-   }      
-#endif
-
-#if (IND & CLIP_FOG_COORD)
-   {
-      GLubyte a = VB->Spec[0][in][3], b = VB->Spec[0][out][3];
-      INTERP_UBYTE( VB->Spec[0][dst][3], t, a, b );
-   }
-#endif
-
-
-#if (IND & CLIP_INDEX0)
-   VB->IndexPtr->data[dst] = (GLuint) (GLint) 
-      LINTERP( t, 
-	       (GLfloat) VB->Index[0]->data[in],
-	       (GLfloat) VB->Index[0]->data[out] );
-#endif
-
-#if (IND & CLIP_INDEX1)
-   VB->Index[1]->data[dst] = (GLuint) (GLint) 
-      LINTERP( t, 
-	       (GLfloat) VB->Index[1]->data[in],
-	       (GLfloat) VB->Index[1]->data[out] );
-#endif
-
-#if (IND & CLIP_TEX0)
-   INTERP_SZ( t, 
-	      VB->TexCoordPtr[0]->data, 
-	      dst, in, out, 
-	      VB->TexCoordPtr[0]->size );
-#endif
-
-#if (IND & CLIP_TEX1)
-   INTERP_SZ( t, 
-	      VB->TexCoordPtr[1]->data, 
-	      dst, in, out, 
-	      VB->TexCoordPtr[1]->size );
-#endif
-}
-
-
-#undef IND
-#undef NAME
Index: xc/extras/Mesa/src/light.c
diff -u xc/extras/Mesa/src/light.c:1.6 xc/extras/Mesa/src/light.c:1.7
--- xc/extras/Mesa/src/light.c:1.6	Mon Nov 13 18:30:49 2000
+++ xc/extras/Mesa/src/light.c	Fri Feb 22 14:25:34 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,17 +28,18 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "enums.h"
 #include "light.h"
 #include "macros.h"
-#include "matrix.h"
 #include "mem.h"
 #include "mmath.h"
 #include "simple_list.h"
-#include "types.h"
-#include "vb.h"
-#include "xform.h"
+#include "mtypes.h"
+
+#include "math/m_xform.h"
+#include "math/m_matrix.h"
 #endif
 
 
@@ -52,26 +53,24 @@
 _mesa_ShadeModel( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glShadeModel");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glShadeModel %s\n", gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glShadeModel %s\n", _mesa_lookup_enum_by_nr(mode));
 
-   if (mode == GL_FLAT || mode == GL_SMOOTH) {
-      if (ctx->Light.ShadeModel != mode) {
-         ctx->Light.ShadeModel = mode;
-         if (ctx->Light.ShadeModel == GL_FLAT)
-            SET_BITS(ctx->TriangleCaps, DD_FLATSHADE);
-         else
-            CLEAR_BITS(ctx->TriangleCaps, DD_FLATSHADE);
-         ctx->NewState |= NEW_RASTER_OPS;
-         if (ctx->Driver.ShadeModel) 
-            (*ctx->Driver.ShadeModel)( ctx, mode );
-      }
-   }
-   else {
-      gl_error( ctx, GL_INVALID_ENUM, "glShadeModel" );
+   if (mode != GL_FLAT && mode != GL_SMOOTH) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glShadeModel" );
+      return;
    }
+
+   if (ctx->Light.ShadeModel == mode)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_LIGHT);
+   ctx->Light.ShadeModel = mode;
+   ctx->_TriangleCaps ^= DD_FLATSHADE;
+   if (ctx->Driver.ShadeModel)
+      (*ctx->Driver.ShadeModel)( ctx, mode );
 }
 
 
@@ -87,103 +86,125 @@
 _mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLint l;
-   GLint nParams;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLight");
+   GLint i = (GLint) (light - GL_LIGHT0);
+   struct gl_light *l = &ctx->Light.Light[i];
 
-   l = (GLint) (light - GL_LIGHT0);
-
-   if (l < 0 || l >= MAX_LIGHTS) {
-      gl_error( ctx, GL_INVALID_ENUM, "glLight" );
+   if (i < 0 || i >= (GLint) ctx->Const.MaxLights) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glLight" );
       return;
    }
 
    switch (pname) {
-      case GL_AMBIENT:
-         COPY_4V( ctx->Light.Light[l].Ambient, params );
-         nParams = 4;
-         break;
-      case GL_DIFFUSE:
-         COPY_4V( ctx->Light.Light[l].Diffuse, params );
-         nParams = 4;
-         break;
-      case GL_SPECULAR:
-         COPY_4V( ctx->Light.Light[l].Specular, params );
-         nParams = 4;
-         break;
-      case GL_POSITION:
-	 /* transform position by ModelView matrix */
-	 TRANSFORM_POINT( ctx->Light.Light[l].EyePosition, 
-			  ctx->ModelView.m,
-                          params );
-         nParams = 4;
-         break;
-      case GL_SPOT_DIRECTION:
-	 /* transform direction by inverse modelview */
-	 if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
-	    gl_matrix_analyze( &ctx->ModelView );
-	 }
-	 TRANSFORM_NORMAL( ctx->Light.Light[l].EyeDirection,
-			   params,
-			   ctx->ModelView.inv );
-         nParams = 3;
-         break;
-      case GL_SPOT_EXPONENT:
-         if (params[0]<0.0 || params[0]>128.0) {
-            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
-            return;
-         }
-         if (ctx->Light.Light[l].SpotExponent != params[0]) {
-            ctx->Light.Light[l].SpotExponent = params[0];
-            gl_compute_spot_exp_table( &ctx->Light.Light[l] );
-         }
-         nParams = 1;
-         break;
-      case GL_SPOT_CUTOFF:
-         if ((params[0]<0.0 || params[0]>90.0) && params[0]!=180.0) {
-            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
-            return;
-         }
-         ctx->Light.Light[l].SpotCutoff = params[0];
-         ctx->Light.Light[l].CosCutoff = cos(params[0]*DEG2RAD);
-         if (ctx->Light.Light[l].CosCutoff < 0) 
-	    ctx->Light.Light[l].CosCutoff = 0;
-         nParams = 1;
-         break;
-      case GL_CONSTANT_ATTENUATION:
-         if (params[0]<0.0) {
-            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
-            return;
-         }
-         ctx->Light.Light[l].ConstantAttenuation = params[0];
-         nParams = 1;
-         break;
-      case GL_LINEAR_ATTENUATION:
-         if (params[0]<0.0) {
-            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
-            return;
-         }
-         ctx->Light.Light[l].LinearAttenuation = params[0];
-         nParams = 1;
-         break;
-      case GL_QUADRATIC_ATTENUATION:
-         if (params[0]<0.0) {
-            gl_error( ctx, GL_INVALID_VALUE, "glLight" );
-            return;
-         }
-         ctx->Light.Light[l].QuadraticAttenuation = params[0];
-         nParams = 1;
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glLight" );
-         return;
+   case GL_AMBIENT:
+      if (TEST_EQ_4V(l->Ambient, params))
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      COPY_4V( l->Ambient, params );
+      break;
+   case GL_DIFFUSE:
+      if (TEST_EQ_4V(l->Diffuse, params))
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      COPY_4V( l->Diffuse, params );
+      break;
+   case GL_SPECULAR:
+      if (TEST_EQ_4V(l->Specular, params))
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      COPY_4V( l->Specular, params );
+      break;
+   case GL_POSITION: {
+      GLfloat tmp[4];
+      /* transform position by ModelView matrix */
+      TRANSFORM_POINT( tmp, ctx->ModelView.m, params );
+      if (TEST_EQ_4V(l->EyePosition, tmp))
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      COPY_4V(l->EyePosition, tmp);
+      if (l->EyePosition[3] != 0.0F)
+	 l->_Flags |= LIGHT_POSITIONAL;
+      else
+	 l->_Flags &= ~LIGHT_POSITIONAL;
+      break;
    }
+   case GL_SPOT_DIRECTION: {
+      GLfloat tmp[4];
+      /* transform direction by inverse modelview */
+      if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
+	 _math_matrix_analyse( &ctx->ModelView );
+      }
+      TRANSFORM_NORMAL( tmp, params, ctx->ModelView.inv );
+      if (TEST_EQ_3V(l->EyeDirection, tmp))
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      COPY_3V(l->EyeDirection, tmp);
+      break;
+   }
+   case GL_SPOT_EXPONENT:
+      if (params[0]<0.0 || params[0]>128.0) {
+	 _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+	 return;
+      }
+      if (l->SpotExponent == params[0])
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      l->SpotExponent = params[0];
+      _mesa_invalidate_spot_exp_table( l );
+      break;
+   case GL_SPOT_CUTOFF:
+      if ((params[0]<0.0 || params[0]>90.0) && params[0]!=180.0) {
+	 _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+	 return;
+      }
+      if (l->SpotCutoff == params[0])
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      l->SpotCutoff = params[0];
+      l->_CosCutoff = (GLfloat) cos(params[0]*DEG2RAD);
+      if (l->_CosCutoff < 0)
+	 l->_CosCutoff = 0;
+      if (l->SpotCutoff != 180.0F)
+	 l->_Flags |= LIGHT_SPOT;
+      else
+	 l->_Flags &= ~LIGHT_SPOT;
+      break;
+   case GL_CONSTANT_ATTENUATION:
+      if (params[0]<0.0) {
+	 _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+	 return;
+      }
+      if (l->ConstantAttenuation == params[0])
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      l->ConstantAttenuation = params[0];
+      break;
+   case GL_LINEAR_ATTENUATION:
+      if (params[0]<0.0) {
+	 _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+	 return;
+      }
+      if (l->LinearAttenuation == params[0])
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      l->LinearAttenuation = params[0];
+      break;
+   case GL_QUADRATIC_ATTENUATION:
+      if (params[0]<0.0) {
+	 _mesa_error( ctx, GL_INVALID_VALUE, "glLight" );
+	 return;
+      }
+      if (l->QuadraticAttenuation == params[0])
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
+      l->QuadraticAttenuation = params[0];
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glLight" );
+      return;
+   }
 
    if (ctx->Driver.Lightfv)
-      ctx->Driver.Lightfv( ctx, light, pname, params, nParams );
-
-   ctx->NewState |= NEW_LIGHTING;
+      ctx->Driver.Lightfv( ctx, light, pname, params );
 }
 
 
@@ -241,11 +262,10 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint l = (GLint) (light - GL_LIGHT0);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetLight");
-
-   if (l<0 || l>=MAX_LIGHTS) {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
+   if (l < 0 || l >= (GLint) ctx->Const.MaxLights) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
       return;
    }
 
@@ -281,7 +301,7 @@
          params[0] = ctx->Light.Light[l].QuadraticAttenuation;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightfv" );
          break;
    }
 }
@@ -293,11 +313,10 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint l = (GLint) (light - GL_LIGHT0);
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetLight");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (l<0 || l>=MAX_LIGHTS) {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
+   if (l < 0 || l >= (GLint) ctx->Const.MaxLights) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
       return;
    }
 
@@ -347,7 +366,7 @@
          params[0] = (GLint) ctx->Light.Light[l].QuadraticAttenuation;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
          break;
    }
 }
@@ -362,48 +381,66 @@
 void
 _mesa_LightModelfv( GLenum pname, const GLfloat *params )
 {
+   GLenum newenum;
+   GLboolean newbool;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLightModelfv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (pname) {
       case GL_LIGHT_MODEL_AMBIENT:
+         if (TEST_EQ_4V( ctx->Light.Model.Ambient, params ))
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_LIGHT);
          COPY_4V( ctx->Light.Model.Ambient, params );
          break;
       case GL_LIGHT_MODEL_LOCAL_VIEWER:
-         if (params[0]==0.0)
-            ctx->Light.Model.LocalViewer = GL_FALSE;
-         else
-            ctx->Light.Model.LocalViewer = GL_TRUE;
+         newbool = (params[0]!=0.0);
+	 if (ctx->Light.Model.LocalViewer == newbool)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_LIGHT);
+	 ctx->Light.Model.LocalViewer = newbool;
          break;
       case GL_LIGHT_MODEL_TWO_SIDE:
-         if (params[0]==0.0) 
-            ctx->Light.Model.TwoSide = GL_FALSE;
-         else
-            ctx->Light.Model.TwoSide = GL_TRUE;
+         newbool = (params[0]!=0.0);
+	 if (ctx->Light.Model.TwoSide == newbool)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_LIGHT);
+	 ctx->Light.Model.TwoSide = newbool;
+
+	 if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
+	    ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
+	 else
+	    ctx->_TriangleCaps &= ~DD_TRI_LIGHT_TWOSIDE;
          break;
       case GL_LIGHT_MODEL_COLOR_CONTROL:
-         if (params[0] == (GLfloat) GL_SINGLE_COLOR) {
-            ctx->Light.Model.ColorControl = GL_SINGLE_COLOR;
-            CLEAR_BITS(ctx->TriangleCaps, DD_SEPERATE_SPECULAR);
-         }
-         else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR) {
-            ctx->Light.Model.ColorControl = GL_SEPARATE_SPECULAR_COLOR;
-	    SET_BITS(ctx->TriangleCaps, DD_SEPERATE_SPECULAR);
-	 }
-         else {
-            gl_error( ctx, GL_INVALID_ENUM, "glLightModel(param)" );
+         if (params[0] == (GLfloat) GL_SINGLE_COLOR)
+	    newenum = GL_SINGLE_COLOR;
+         else if (params[0] == (GLfloat) GL_SEPARATE_SPECULAR_COLOR)
+	    newenum = GL_SEPARATE_SPECULAR_COLOR;
+	 else {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel(param)" );
+	    return;
          }
-	 ctx->NewState |= NEW_RASTER_OPS;
+	 if (ctx->Light.Model.ColorControl == newenum)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_LIGHT);
+	 ctx->Light.Model.ColorControl = newenum;
+
+	 if ((ctx->Light.Enabled &&
+	      ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+	     || ctx->Fog.ColorSumEnabled)
+	    ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
+	 else
+	    ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glLightModel" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glLightModel" );
          break;
    }
 
-   if (ctx->Driver.LightModelfv) 
+   if (ctx->Driver.LightModelfv)
       ctx->Driver.LightModelfv( ctx, pname, params );
-
-   ctx->NewState |= NEW_LIGHTING;
 }
 
 
@@ -411,8 +448,6 @@
 _mesa_LightModeliv( GLenum pname, const GLint *params )
 {
    GLfloat fparam[4];
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLightModeliv");
 
    switch (pname) {
       case GL_LIGHT_MODEL_AMBIENT:
@@ -456,9 +491,9 @@
  * Given a face and pname value (ala glColorMaterial), compute a bitmask
  * of the targeted material values.
  */
-GLuint gl_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname, 
-			    GLuint legal,
-			    const char *where )
+GLuint
+_mesa_material_bitmask( GLcontext *ctx, GLenum face, GLenum pname,
+                        GLuint legal, const char *where )
 {
    GLuint bitmask = 0;
 
@@ -487,7 +522,7 @@
          bitmask |= FRONT_INDEXES_BIT  | BACK_INDEXES_BIT;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, where );
+         _mesa_error( ctx, GL_INVALID_ENUM, where );
          return 0;
    }
 
@@ -498,12 +533,12 @@
       bitmask &= BACK_MATERIAL_BITS;
    }
    else if (face != GL_FRONT_AND_BACK) {
-      gl_error( ctx, GL_INVALID_ENUM, where );
+      _mesa_error( ctx, GL_INVALID_ENUM, where );
       return 0;
    }
-   
+
    if (bitmask & ~legal) {
-      gl_error( ctx, GL_INVALID_ENUM, where );
+      _mesa_error( ctx, GL_INVALID_ENUM, where );
       return 0;
    }
 
@@ -511,6 +546,54 @@
 }
 
 
+/* Perform a straight copy between pairs of materials.
+ */
+void _mesa_copy_material_pairs( struct gl_material dst[2],
+			     const struct gl_material src[2],
+			     GLuint bitmask )
+{
+   if (bitmask & FRONT_EMISSION_BIT) {
+      COPY_4FV( dst[0].Emission, src[0].Emission );
+   }
+   if (bitmask & BACK_EMISSION_BIT) {
+      COPY_4FV( dst[1].Emission, src[1].Emission );
+   }
+   if (bitmask & FRONT_AMBIENT_BIT) {
+      COPY_4FV( dst[0].Ambient, src[0].Ambient );
+   }
+   if (bitmask & BACK_AMBIENT_BIT) {
+      COPY_4FV( dst[1].Ambient, src[1].Ambient );
+   }
+   if (bitmask & FRONT_DIFFUSE_BIT) {
+      COPY_4FV( dst[0].Diffuse, src[0].Diffuse );
+   }
+   if (bitmask & BACK_DIFFUSE_BIT) {
+      COPY_4FV( dst[1].Diffuse, src[1].Diffuse );
+   }
+   if (bitmask & FRONT_SPECULAR_BIT) {
+      COPY_4FV( dst[0].Specular, src[0].Specular );
+   }
+   if (bitmask & BACK_SPECULAR_BIT) {
+      COPY_4FV( dst[1].Specular, src[1].Specular );
+   }
+   if (bitmask & FRONT_SHININESS_BIT) {
+      dst[0].Shininess = src[0].Shininess;
+   }
+   if (bitmask & BACK_SHININESS_BIT) {
+      dst[1].Shininess = src[1].Shininess;
+   }
+   if (bitmask & FRONT_INDEXES_BIT) {
+      dst[0].AmbientIndex = src[0].AmbientIndex;
+      dst[0].DiffuseIndex = src[0].DiffuseIndex;
+      dst[0].SpecularIndex = src[0].SpecularIndex;
+   }
+   if (bitmask & BACK_INDEXES_BIT) {
+      dst[1].AmbientIndex = src[1].AmbientIndex;
+      dst[1].DiffuseIndex = src[1].DiffuseIndex;
+      dst[1].SpecularIndex = src[1].SpecularIndex;
+   }
+}
+
 
 /*
  * Check if the global material has to be updated with info that was
@@ -521,14 +604,10 @@
  *
  * src[0] is front material, src[1] is back material
  *
- * KW: Added code here to keep the precomputed variables uptodate.
- *     This means we can use the faster shade functions when using
- *     GL_COLOR_MATERIAL, and we can also now use the precomputed 
- *     values in the slower shading functions, which further offsets
- *     the cost of doing this here.
+ * Additionally keeps the precomputed lighting state uptodate.
  */
-void gl_update_material( GLcontext *ctx, 
-			 const struct gl_material src[2], 
+void _mesa_update_material( GLcontext *ctx,
+			 const struct gl_material src[2],
 			 GLuint bitmask )
 {
    struct gl_light *light, *list = &ctx->Light.EnabledList;
@@ -537,9 +616,9 @@
       bitmask &= ~ctx->Light.ColorMaterialBitmask;
 
    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      fprintf(stderr, "gl_update_material, mask 0x%x\n", bitmask);
+      fprintf(stderr, "_mesa_update_material, mask 0x%x\n", bitmask);
 
-   if (!bitmask) 
+   if (!bitmask)
       return;
 
    /* update material emission */
@@ -557,88 +636,70 @@
       struct gl_material *mat = &ctx->Light.Material[0];
       COPY_4FV( mat->Ambient, src[0].Ambient );
       foreach (light, list) {
-         SCALE_3V( light->MatAmbient[0], light->Ambient, src[0].Ambient);
+         SCALE_3V( light->_MatAmbient[0], light->Ambient, src[0].Ambient);
       }
    }
    if (bitmask & BACK_AMBIENT_BIT) {
       struct gl_material *mat = &ctx->Light.Material[1];
       COPY_4FV( mat->Ambient, src[1].Ambient );
       foreach (light, list) {
-         SCALE_3V( light->MatAmbient[1], light->Ambient, src[1].Ambient);
+         SCALE_3V( light->_MatAmbient[1], light->Ambient, src[1].Ambient);
       }
    }
 
    /* update BaseColor = emission + scene's ambience * material's ambience */
    if (bitmask & (FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT)) {
       struct gl_material *mat = &ctx->Light.Material[0];
-      COPY_3V( ctx->Light.BaseColor[0], mat->Emission );
-      ACC_SCALE_3V( ctx->Light.BaseColor[0], mat->Ambient, ctx->Light.Model.Ambient );
+      COPY_3V( ctx->Light._BaseColor[0], mat->Emission );
+      ACC_SCALE_3V( ctx->Light._BaseColor[0], mat->Ambient,
+		    ctx->Light.Model.Ambient );
    }
    if (bitmask & (BACK_EMISSION_BIT | BACK_AMBIENT_BIT)) {
       struct gl_material *mat = &ctx->Light.Material[1];
-      COPY_3V( ctx->Light.BaseColor[1], mat->Emission );
-      ACC_SCALE_3V( ctx->Light.BaseColor[1], mat->Ambient, ctx->Light.Model.Ambient );
+      COPY_3V( ctx->Light._BaseColor[1], mat->Emission );
+      ACC_SCALE_3V( ctx->Light._BaseColor[1], mat->Ambient,
+		    ctx->Light.Model.Ambient );
    }
 
    /* update material diffuse values */
    if (bitmask & FRONT_DIFFUSE_BIT) {
       struct gl_material *mat = &ctx->Light.Material[0];
-      GLfloat tmp[4];
-      SUB_3V( tmp, src[0].Diffuse, mat->Diffuse );
+      COPY_4FV( mat->Diffuse, src[0].Diffuse );
       foreach (light, list) {
-	 ACC_SCALE_3V( light->MatDiffuse[0], light->Diffuse, tmp );
+	 SCALE_3V( light->_MatDiffuse[0], light->Diffuse, mat->Diffuse );
       }
-      COPY_4FV( mat->Diffuse, src[0].Diffuse );
-      FLOAT_COLOR_TO_UBYTE_COLOR(ctx->Light.BaseAlpha[0], mat->Diffuse[3]);
    }
    if (bitmask & BACK_DIFFUSE_BIT) {
       struct gl_material *mat = &ctx->Light.Material[1];
-      GLfloat tmp[4];
-      SUB_3V( tmp, src[1].Diffuse, mat->Diffuse );
+      COPY_4FV( mat->Diffuse, src[1].Diffuse );
       foreach (light, list) {
-	 ACC_SCALE_3V( light->MatDiffuse[1], light->Diffuse, tmp );
+	 SCALE_3V( light->_MatDiffuse[1], light->Diffuse, mat->Diffuse );
       }
-      COPY_4FV( mat->Diffuse, src[1].Diffuse );
-      FLOAT_COLOR_TO_UBYTE_COLOR(ctx->Light.BaseAlpha[1], mat->Diffuse[3]);
    }
 
    /* update material specular values */
    if (bitmask & FRONT_SPECULAR_BIT) {
       struct gl_material *mat = &ctx->Light.Material[0];
-      GLfloat tmp[4];
-      SUB_3V( tmp, src[0].Specular, mat->Specular );
+      COPY_4FV( mat->Specular, src[0].Specular );
       foreach (light, list) {
-	 if (light->Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->MatSpecular[0], light->Specular, tmp );
-	    light->IsMatSpecular[0] = 
-	       (LEN_SQUARED_3FV(light->MatSpecular[0]) > 1e-16);
-	 }
+	 SCALE_3V( light->_MatSpecular[0], light->Specular, mat->Specular);
       }
-      COPY_4FV( mat->Specular, src[0].Specular );
    }
    if (bitmask & BACK_SPECULAR_BIT) {
       struct gl_material *mat = &ctx->Light.Material[1];
-      GLfloat tmp[4];
-      SUB_3V( tmp, src[1].Specular, mat->Specular );
+      COPY_4FV( mat->Specular, src[1].Specular );
       foreach (light, list) {
-	 if (light->Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->MatSpecular[1], light->Specular, tmp );
-	    light->IsMatSpecular[1] = 
-	       (LEN_SQUARED_3FV(light->MatSpecular[1]) > 1e-16);
-	 }
+	 SCALE_3V( light->_MatSpecular[1], light->Specular, mat->Specular);
       }
-      COPY_4FV( mat->Specular, src[1].Specular );
    }
 
    if (bitmask & FRONT_SHININESS_BIT) {
-      GLfloat shininess = ctx->Light.Material[0].Shininess = src[0].Shininess;
-      gl_compute_shine_table( ctx, 0, shininess );
-      gl_compute_shine_table( ctx, 2, shininess * .5 );
+      ctx->Light.Material[0].Shininess = src[0].Shininess;
+      _mesa_invalidate_shine_table( ctx, 0 );
    }
    if (bitmask & BACK_SHININESS_BIT) {
-      GLfloat shininess = ctx->Light.Material[1].Shininess = src[1].Shininess;
-      gl_compute_shine_table( ctx, 1, shininess );
-      gl_compute_shine_table( ctx, 3, shininess * .5 );
+      ctx->Light.Material[1].Shininess = src[1].Shininess;
+      _mesa_invalidate_shine_table( ctx, 1 );
    }
 
    if (bitmask & FRONT_INDEXES_BIT) {
@@ -677,22 +738,22 @@
 
 
 
+
+
+
 /*
  * Update the current materials from the given rgba color
  * according to the bitmask in ColorMaterialBitmask, which is
  * set by glColorMaterial().
  */
-void gl_update_color_material( GLcontext *ctx, 
-			       const GLubyte rgba[4] )
+void _mesa_update_color_material( GLcontext *ctx,
+				  const GLfloat color[4] )
 {
    struct gl_light *light, *list = &ctx->Light.EnabledList;
    GLuint bitmask = ctx->Light.ColorMaterialBitmask;
-   GLfloat color[4];
 
-   UBYTE_RGBA_TO_FLOAT_RGBA( color, rgba );
-   
    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      fprintf(stderr, "gl_update_color_material, mask 0x%x\n", bitmask);
+      fprintf(stderr, "_mesa_update_color_material, mask 0x%x\n", bitmask);
 
    /* update emissive colors */
    if (bitmask & FRONT_EMISSION_BIT) {
@@ -705,11 +766,11 @@
       COPY_4FV( mat->Emission, color );
    }
 
-   /* update light->MatAmbient = light's ambient * material's ambient */
+   /* update light->_MatAmbient = light's ambient * material's ambient */
    if (bitmask & FRONT_AMBIENT_BIT) {
       struct gl_material *mat = &ctx->Light.Material[0];
       foreach (light, list) {
-         SCALE_3V( light->MatAmbient[0], light->Ambient, color);
+         SCALE_3V( light->_MatAmbient[0], light->Ambient, color);
       }
       COPY_4FV( mat->Ambient, color );
    }
@@ -717,7 +778,7 @@
    if (bitmask & BACK_AMBIENT_BIT) {
       struct gl_material *mat = &ctx->Light.Material[1];
       foreach (light, list) {
-         SCALE_3V( light->MatAmbient[1], light->Ambient, color);
+         SCALE_3V( light->_MatAmbient[1], light->Ambient, color);
       }
       COPY_4FV( mat->Ambient, color );
    }
@@ -725,66 +786,48 @@
    /* update BaseColor = emission + scene's ambience * material's ambience */
    if (bitmask & (FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT)) {
       struct gl_material *mat = &ctx->Light.Material[0];
-      COPY_3V( ctx->Light.BaseColor[0], mat->Emission );
-      ACC_SCALE_3V( ctx->Light.BaseColor[0], mat->Ambient, ctx->Light.Model.Ambient );
+      COPY_3V( ctx->Light._BaseColor[0], mat->Emission );
+      ACC_SCALE_3V( ctx->Light._BaseColor[0], mat->Ambient, ctx->Light.Model.Ambient );
    }
 
    if (bitmask & (BACK_EMISSION_BIT | BACK_AMBIENT_BIT)) {
       struct gl_material *mat = &ctx->Light.Material[1];
-      COPY_3V( ctx->Light.BaseColor[1], mat->Emission );
-      ACC_SCALE_3V( ctx->Light.BaseColor[1], mat->Ambient, ctx->Light.Model.Ambient );
+      COPY_3V( ctx->Light._BaseColor[1], mat->Emission );
+      ACC_SCALE_3V( ctx->Light._BaseColor[1], mat->Ambient, ctx->Light.Model.Ambient );
    }
 
-   /* update light->MatDiffuse = light's diffuse * material's diffuse */
+   /* update light->_MatDiffuse = light's diffuse * material's diffuse */
    if (bitmask & FRONT_DIFFUSE_BIT) {
       struct gl_material *mat = &ctx->Light.Material[0];
-      GLfloat tmp[4];
-      SUB_3V( tmp, color, mat->Diffuse );
+      COPY_4FV( mat->Diffuse, color );
       foreach (light, list) {
-	 ACC_SCALE_3V( light->MatDiffuse[0], light->Diffuse, tmp );
+	 SCALE_3V( light->_MatDiffuse[0], light->Diffuse, mat->Diffuse );
       }
-      COPY_4FV( mat->Diffuse, color );
-      FLOAT_COLOR_TO_UBYTE_COLOR(ctx->Light.BaseAlpha[0], mat->Diffuse[3]);
    }
 
    if (bitmask & BACK_DIFFUSE_BIT) {
       struct gl_material *mat = &ctx->Light.Material[1];
-      GLfloat tmp[4];
-      SUB_3V( tmp, color, mat->Diffuse );
+      COPY_4FV( mat->Diffuse, color );
       foreach (light, list) {
-	 ACC_SCALE_3V( light->MatDiffuse[1], light->Diffuse, tmp );
+	 SCALE_3V( light->_MatDiffuse[1], light->Diffuse, mat->Diffuse );
       }
-      COPY_4FV( mat->Diffuse, color );
-      FLOAT_COLOR_TO_UBYTE_COLOR(ctx->Light.BaseAlpha[1], mat->Diffuse[3]);
    }
 
-   /* update light->MatSpecular = light's specular * material's specular */
+   /* update light->_MatSpecular = light's specular * material's specular */
    if (bitmask & FRONT_SPECULAR_BIT) {
       struct gl_material *mat = &ctx->Light.Material[0];
-      GLfloat tmp[4];
-      SUB_3V( tmp, color, mat->Specular );
+      COPY_4FV( mat->Specular, color );
       foreach (light, list) {
-	 if (light->Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->MatSpecular[0], light->Specular, tmp );
-	    light->IsMatSpecular[0] = 
-	       (LEN_SQUARED_3FV(light->MatSpecular[0]) > 1e-16);
-	 }
+	 ACC_SCALE_3V( light->_MatSpecular[0], light->Specular, mat->Specular);
       }
-      COPY_4FV( mat->Specular, color );
    }
 
    if (bitmask & BACK_SPECULAR_BIT) {
       struct gl_material *mat = &ctx->Light.Material[1];
-      GLfloat tmp[4];
-      SUB_3V( tmp, color, mat->Specular );
+      COPY_4FV( mat->Specular, color );
       foreach (light, list) {
-	 if (light->Flags & LIGHT_SPECULAR) {
-	    ACC_SCALE_3V( light->MatSpecular[1], light->Specular, tmp );
-	    light->IsMatSpecular[1] = 
-	       (LEN_SQUARED_3FV(light->MatSpecular[1]) > 1e-16);
-	 }
+	 ACC_SCALE_3V( light->_MatSpecular[1], light->Specular, mat->Specular);
       }
-      COPY_4FV( mat->Specular, color );
    }
 
    if (0)
@@ -821,153 +864,36 @@
 		   FRONT_SPECULAR_BIT | BACK_SPECULAR_BIT |
 		   FRONT_DIFFUSE_BIT  | BACK_DIFFUSE_BIT  |
 		   FRONT_AMBIENT_BIT  | BACK_AMBIENT_BIT);
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorMaterial");
-
-   if (MESA_VERBOSE&VERBOSE_API) 
-      fprintf(stderr, "glColorMaterial %s %s\n", 
-	      gl_lookup_enum_by_nr(face),
-	      gl_lookup_enum_by_nr(mode));
-
-   bitmask = gl_material_bitmask( ctx, face, mode, legal, "glColorMaterial" );
-
-   if (bitmask != 0) {
-      ctx->Light.ColorMaterialBitmask = bitmask;
-      ctx->Light.ColorMaterialFace = face;
-      ctx->Light.ColorMaterialMode = mode;
-   }
-
-   if (ctx->Light.ColorMaterialEnabled)
-      gl_update_color_material( ctx, ctx->Current.ByteColor );
-}
-
-
-
-
-void
-_mesa_Materialf( GLenum face, GLenum pname, GLfloat param )
-{
-   _mesa_Materialfv( face, pname, &param );
-}
-
-
-/* KW:  This is now called directly (ie by name) from the glMaterial* 
- *      API functions.
- */
-void
-_mesa_Materialfv( GLenum face, GLenum pname, const GLfloat *params )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct immediate *IM;
-   struct gl_material *mat;
-   GLuint bitmask;
-   GLuint count;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   bitmask = gl_material_bitmask( ctx, face, pname, ~0, "gl_Materialfv" );
-   if (bitmask == 0)
+   if (MESA_VERBOSE&VERBOSE_API)
+      fprintf(stderr, "glColorMaterial %s %s\n",
+	      _mesa_lookup_enum_by_nr(face),
+	      _mesa_lookup_enum_by_nr(mode));
+
+   bitmask = _mesa_material_bitmask(ctx, face, mode, legal, "glColorMaterial");
+
+   if (ctx->Light.ColorMaterialBitmask == bitmask &&
+       ctx->Light.ColorMaterialFace == face &&
+       ctx->Light.ColorMaterialMode == mode)
       return;
 
-   IM = ctx->input;
-   count = IM->Count;
-
-   if (!IM->Material) {
-      IM->Material = 
-	 (struct gl_material (*)[2]) MALLOC( sizeof(struct gl_material) * 
-					     VB_SIZE * 2 );
-      IM->MaterialMask = (GLuint *) MALLOC( sizeof(GLuint) * VB_SIZE );
+   FLUSH_VERTICES(ctx, _NEW_LIGHT);
+   ctx->Light.ColorMaterialBitmask = bitmask;
+   ctx->Light.ColorMaterialFace = face;
+   ctx->Light.ColorMaterialMode = mode;
+
+   if (ctx->Light.ColorMaterialEnabled) {
+      FLUSH_CURRENT( ctx, 0 );
+      _mesa_update_color_material( ctx, ctx->Current.Color );
    }
-
-
-   if (!(IM->Flag[count] & VERT_MATERIAL)) {
-      IM->Flag[count] |= VERT_MATERIAL;
-      IM->MaterialMask[count] = 0;      
-   }
-
 
-   IM->MaterialMask[count] |= bitmask;
-   mat = IM->Material[count];
-
-   if (bitmask & FRONT_AMBIENT_BIT) {
-      COPY_4FV( mat[0].Ambient, params );
-   }
-   if (bitmask & BACK_AMBIENT_BIT) {
-      COPY_4FV( mat[1].Ambient, params );
-   }
-   if (bitmask & FRONT_DIFFUSE_BIT) {
-      COPY_4FV( mat[0].Diffuse, params );
-   }
-   if (bitmask & BACK_DIFFUSE_BIT) {
-      COPY_4FV( mat[1].Diffuse, params );
-   }
-   if (bitmask & FRONT_SPECULAR_BIT) {
-      COPY_4FV( mat[0].Specular, params );
-   }
-   if (bitmask & BACK_SPECULAR_BIT) {
-      COPY_4FV( mat[1].Specular, params );
-   }
-   if (bitmask & FRONT_EMISSION_BIT) {
-      COPY_4FV( mat[0].Emission, params );
-   }
-   if (bitmask & BACK_EMISSION_BIT) {
-      COPY_4FV( mat[1].Emission, params );
-   }
-   if (bitmask & FRONT_SHININESS_BIT) {
-      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
-      mat[0].Shininess = shininess;
-   }
-   if (bitmask & BACK_SHININESS_BIT) {
-      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
-      mat[1].Shininess = shininess;
-   }
-   if (bitmask & FRONT_INDEXES_BIT) {
-      mat[0].AmbientIndex = params[0];
-      mat[0].DiffuseIndex = params[1];
-      mat[0].SpecularIndex = params[2];
-   }
-   if (bitmask & BACK_INDEXES_BIT) {
-      mat[1].AmbientIndex = params[0];
-      mat[1].DiffuseIndex = params[1];
-      mat[1].SpecularIndex = params[2];
-   }
+   if (ctx->Driver.ColorMaterial)
+      (*ctx->Driver.ColorMaterial)( ctx, face, mode );
 }
 
 
-void
-_mesa_Materiali(GLenum face, GLenum pname, GLint param )
-{
-   _mesa_Materialiv(face, pname, &param);
-}
-
 
-void
-_mesa_Materialiv(GLenum face, GLenum pname, const GLint *params )
-{
-   GLfloat fparam[4];
-   switch (pname) {
-      case GL_AMBIENT:
-      case GL_DIFFUSE:
-      case GL_SPECULAR:
-      case GL_EMISSION:
-      case GL_AMBIENT_AND_DIFFUSE:
-         fparam[0] = INT_TO_FLOAT( params[0] );
-         fparam[1] = INT_TO_FLOAT( params[1] );
-         fparam[2] = INT_TO_FLOAT( params[2] );
-         fparam[3] = INT_TO_FLOAT( params[3] );
-         break;
-      case GL_SHININESS:
-         fparam[0] = (GLfloat) params[0];
-         break;
-      case GL_COLOR_INDEXES:
-         fparam[0] = (GLfloat) params[0];
-         fparam[1] = (GLfloat) params[1];
-         fparam[2] = (GLfloat) params[2];
-         break;
-      default:
-         /* Error will be caught later in gl_Materialfv */
-         ;
-   }
-   _mesa_Materialfv(face, pname, fparam);
-}
 
 
 void
@@ -975,9 +901,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLuint f;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetMaterialfv");
-
    if (face==GL_FRONT) {
       f = 0;
    }
@@ -985,7 +910,7 @@
       f = 1;
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(face)" );
       return;
    }
    switch (pname) {
@@ -1010,7 +935,7 @@
 	 params[2] = ctx->Light.Material[f].SpecularIndex;
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
    }
 }
 
@@ -1021,8 +946,7 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLuint f;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetMaterialiv");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* update materials */
 
    if (face==GL_FRONT) {
       f = 0;
@@ -1031,7 +955,7 @@
       f = 1;
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialiv(face)" );
       return;
    }
    switch (pname) {
@@ -1068,7 +992,7 @@
 	 params[2] = ROUNDF( ctx->Light.Material[f].SpecularIndex );
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetMaterialfv(pname)" );
    }
 }
 
@@ -1087,7 +1011,7 @@
  *   orientation of the facet is later learned, we can determine which
  *   color (or index) to use for rendering.
  *
- *   KW: We now know orientation in advance and only shade for 
+ *   KW: We now know orientation in advance and only shade for
  *       the side or sides which are actually required.
  *
  * Variables:
@@ -1100,10 +1024,10 @@
  *   IF P[3]==0 THEN
  *       // light at infinity
  *       IF local_viewer THEN
- *           VP_inf_norm = unit vector from V to P      // Precompute
- *       ELSE 
+ *           _VP_inf_norm = unit vector from V to P      // Precompute
+ *       ELSE
  *           // eye at infinity
- *           h_inf_norm = Normalize( VP + <0,0,1> )     // Precompute
+ *           _h_inf_norm = Normalize( VP + <0,0,1> )     // Precompute
  *       ENDIF
  *   ENDIF
  *
@@ -1119,29 +1043,35 @@
  * this function to recompute the exponent lookup table.
  */
 void
-gl_compute_spot_exp_table( struct gl_light *l )
+_mesa_invalidate_spot_exp_table( struct gl_light *l )
+{
+   l->_SpotExpTable[0][0] = -1;
+}
+
+static void validate_spot_exp_table( struct gl_light *l )
 {
    GLint i;
    GLdouble exponent = l->SpotExponent;
    GLdouble tmp = 0;
    GLint clamp = 0;
 
-   l->SpotExpTable[0][0] = 0.0;
+   l->_SpotExpTable[0][0] = 0.0;
 
    for (i = EXP_TABLE_SIZE - 1; i > 0 ;i--) {
       if (clamp == 0) {
-         tmp = pow(i / (GLdouble) (EXP_TABLE_SIZE - 1), exponent);
-         if (tmp < FLT_MIN * 100.0) {
-            tmp = 0.0;
-            clamp = 1;
-         }
+	 tmp = pow(i / (GLdouble) (EXP_TABLE_SIZE - 1), exponent);
+	 if (tmp < FLT_MIN * 100.0) {
+	    tmp = 0.0;
+	    clamp = 1;
+	 }
       }
-      l->SpotExpTable[i][0] = tmp;
+      l->_SpotExpTable[i][0] = (GLfloat) tmp;
    }
    for (i = 0; i < EXP_TABLE_SIZE - 1; i++) {
-      l->SpotExpTable[i][1] = l->SpotExpTable[i+1][0] - l->SpotExpTable[i][0];
+      l->_SpotExpTable[i][1] = (l->_SpotExpTable[i+1][0] -
+				l->_SpotExpTable[i][0]);
    }
-   l->SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0;
+   l->_SpotExpTable[EXP_TABLE_SIZE-1][1] = 0.0;
 }
 
 
@@ -1151,83 +1081,82 @@
  * lighting, and the cost of doing it early may be partially offset
  * by keeping a MRU cache of shine tables for various shine values.
  */
-static void
-compute_shine_table( struct gl_shine_tab *tab, GLfloat shininess )
+void
+_mesa_invalidate_shine_table( GLcontext *ctx, GLuint i )
 {
-   GLint i;
-   GLfloat *m = tab->tab;
-
-   m[0] = 0.0;
-   if (shininess == 0.0) {
-      for (i = 1 ; i <= SHINE_TABLE_SIZE ; i++)
-	 m[i] = 1.0;
-   }
-   else {
-      for (i = 1 ; i < SHINE_TABLE_SIZE ; i++) {
-	 GLdouble t = pow(i / (GLfloat) (SHINE_TABLE_SIZE - 1), shininess);
-	 if (t > 1e-20)
-            m[i] = t;
-         else
-            m[i] = 0.0;
-      }      
-      m[SHINE_TABLE_SIZE] = 1.0;
-   }
-
-   tab->shininess = shininess;
+   if (ctx->_ShineTable[i])
+      ctx->_ShineTable[i]->refcount--;
+   ctx->_ShineTable[i] = 0;
 }
-
 
-void
-gl_compute_shine_table( GLcontext *ctx, GLuint i, GLfloat shininess )
+static void validate_shine_table( GLcontext *ctx, GLuint i, GLfloat shininess )
 {
-#define DISTSQR(a,b) ((a-b)*(a-b))
-   struct gl_shine_tab *list = ctx->ShineTabList;
+   struct gl_shine_tab *list = ctx->_ShineTabList;
    struct gl_shine_tab *s;
 
-   foreach(s, list) 
-      if ( DISTSQR(s->shininess, shininess) < 1e-4 ) 
+   foreach(s, list)
+      if ( s->shininess == shininess )
 	 break;
 
    if (s == list) {
-      foreach(s, list) 
+      GLint j;
+      GLfloat *m;
+
+      foreach(s, list)
 	 if (s->refcount == 0)
-            break;
+	    break;
 
-      compute_shine_table( s, shininess );
+      m = s->tab;
+      m[0] = 0.0;
+      if (shininess == 0.0) {
+	 for (j = 1 ; j <= SHINE_TABLE_SIZE ; j++)
+	    m[j] = 1.0;
+      }
+      else {
+	 for (j = 1 ; j < SHINE_TABLE_SIZE ; j++) {
+            GLdouble t, x = j / (GLfloat) (SHINE_TABLE_SIZE - 1);
+            if (x < 0.005) /* underflow check */
+               x = 0.005;
+            t = pow(x, shininess);
+	    if (t > 1e-20)
+	       m[j] = (GLfloat) t;
+	    else
+	       m[j] = 0.0;
+	 }
+	 m[SHINE_TABLE_SIZE] = 1.0;
+      }
+
+      s->shininess = shininess;
    }
+
+   if (ctx->_ShineTable[i])
+      ctx->_ShineTable[i]->refcount--;
 
-   ctx->ShineTable[i]->refcount--;
-   ctx->ShineTable[i] = s;
+   ctx->_ShineTable[i] = s;
    move_to_tail( list, s );
    s->refcount++;
-#undef DISTSQR
 }
-
-
 
-#if 0
-static void
-gl_reinit_light_attrib( GLcontext *ctx, struct gl_light_attrib *l )
+void
+_mesa_validate_all_lighting_tables( GLcontext *ctx )
 {
-   GLuint i;
+   GLint i;
+   GLfloat shininess;
 
-   if (ctx->ShineTable[0]->shininess != l->Material[0].Shininess) {
-      gl_compute_shine_table( ctx, 0, l->Material[0].Shininess );
-      gl_compute_shine_table( ctx, 2, l->Material[0].Shininess * .5 );
-   }
+   shininess = ctx->Light.Material[0].Shininess;
+   if (!ctx->_ShineTable[0] || ctx->_ShineTable[0]->shininess != shininess)
+      validate_shine_table( ctx, 0, shininess );
+
+   shininess = ctx->Light.Material[1].Shininess;
+   if (!ctx->_ShineTable[1] || ctx->_ShineTable[1]->shininess != shininess)
+      validate_shine_table( ctx, 1, shininess );
+
+   for (i = 0 ; i < MAX_LIGHTS ; i++)
+      if (ctx->Light.Light[i]._SpotExpTable[0][0] == -1)
+	 validate_spot_exp_table( &ctx->Light.Light[i] );
+}
 
-   if (ctx->ShineTable[1]->shininess != l->Material[1].Shininess) {
-      gl_compute_shine_table( ctx, 1, l->Material[1].Shininess );
-      gl_compute_shine_table( ctx, 3, l->Material[1].Shininess * .5 );
-   }
 
-   make_empty_list( &l->EnabledList );
-   for (i = 0 ; i < MAX_LIGHTS ; i++) {
-      if (l->Light[i].Enabled) 
-	 insert_at_tail( &l->EnabledList, &l->Light[i] );
-   }
-}
-#endif
 
 
 /*
@@ -1237,211 +1166,150 @@
  * source and material ambient, diffuse and specular coefficients.
  */
 void
-gl_update_lighting( GLcontext *ctx )
+_mesa_update_lighting( GLcontext *ctx )
 {
    struct gl_light *light;
+   ctx->_NeedEyeCoords &= ~NEED_EYE_LIGHT;
+   ctx->_NeedNormals &= ~NEED_NORMALS_LIGHT;
+   ctx->Light._Flags = 0;
 
-   ctx->Light.Flags = 0;
+   if (!ctx->Light.Enabled)
+      return;
 
+   ctx->_NeedNormals |= NEED_NORMALS_LIGHT;
+
    foreach(light, &ctx->Light.EnabledList) {
+      ctx->Light._Flags |= light->_Flags;
+   }
 
-      light->Flags = 0;
+   ctx->Light._NeedVertices =
+      ((ctx->Light._Flags & (LIGHT_POSITIONAL|LIGHT_SPOT)) ||
+       ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR ||
+       ctx->Light.Model.LocalViewer);
 
-      if (light->EyePosition[3] != 0.0F) 
-	 light->Flags |= LIGHT_POSITIONAL;
-      
-      if (LEN_SQUARED_3FV(light->Specular) > 1e-16) 
-	 light->Flags |= LIGHT_SPECULAR;
-      
-      if (light->SpotCutoff != 180.0F)
-	 light->Flags |= LIGHT_SPOT;
+   if ((ctx->Light._Flags & LIGHT_POSITIONAL) ||
+       ctx->Light.Model.LocalViewer)
+      ctx->_NeedEyeCoords |= NEED_EYE_LIGHT;
 
-      ctx->Light.Flags |= light->Flags;
-   }
 
-   ctx->Light.NeedVertices = 
-      ((ctx->Light.Flags & (LIGHT_POSITIONAL|LIGHT_SPOT)) ||
-       (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) ||
-       (ctx->Light.Model.LocalViewer && (ctx->Light.Flags & LIGHT_SPECULAR)));
+   /* XXX: This test is overkill & needs to be fixed both for software and
+    * hardware t&l drivers.  The above should be sufficient & should
+    * be tested to verify this.
+    */
+   if (ctx->Light._NeedVertices)
+      ctx->_NeedEyeCoords |= NEED_EYE_LIGHT;
 
 
-   /* Precompute some shading values.
+   /* Precompute some shading values.  Although we reference
+    * Light.Material here, we can get away without flushing
+    * FLUSH_UPDATE_CURRENT, as when any outstanding material changes
+    * are flushed, they will update the derived state at that time.
     */
-   if (ctx->Visual->RGBAflag) {
-      GLuint sides = ((ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) ? 2 : 1);
+   if (ctx->Visual.rgbMode) {
+      GLuint sides = ctx->Light.Model.TwoSide ? 2 : 1;
       GLuint side;
       for (side=0; side < sides; side++) {
 	 struct gl_material *mat = &ctx->Light.Material[side];
 
-	 COPY_3V(ctx->Light.BaseColor[side], mat->Emission);
-	 ACC_SCALE_3V(ctx->Light.BaseColor[side], 
+	 COPY_3V(ctx->Light._BaseColor[side], mat->Emission);
+	 ACC_SCALE_3V(ctx->Light._BaseColor[side],
 		      ctx->Light.Model.Ambient,
 		      mat->Ambient);
-
-	 FLOAT_COLOR_TO_UBYTE_COLOR(ctx->Light.BaseAlpha[side],
-				    ctx->Light.Material[side].Diffuse[3] );
       }
-      
-      foreach (light, &ctx->Light.EnabledList) {	 
+
+      foreach (light, &ctx->Light.EnabledList) {
 	 for (side=0; side< sides; side++) {
 	    const struct gl_material *mat = &ctx->Light.Material[side];
-	    SCALE_3V( light->MatDiffuse[side], light->Diffuse, mat->Diffuse );
-	    SCALE_3V( light->MatAmbient[side], light->Ambient, mat->Ambient );
-	    if (light->Flags & LIGHT_SPECULAR) {
-	       SCALE_3V( light->MatSpecular[side], light->Specular,
-			 mat->Specular);
-	       light->IsMatSpecular[side] = 
-		  (LEN_SQUARED_3FV(light->MatSpecular[side]) > 1e-16);
-	    } 
-	    else 
-	       light->IsMatSpecular[side] = 0;
+	    SCALE_3V( light->_MatDiffuse[side], light->Diffuse, mat->Diffuse );
+	    SCALE_3V( light->_MatAmbient[side], light->Ambient, mat->Ambient );
+	    SCALE_3V( light->_MatSpecular[side], light->Specular,
+		      mat->Specular);
 	 }
       }
-   } 
+   }
    else {
-      static const GLfloat ci[3] = { .30, .59, .11 };
+      static const GLfloat ci[3] = { .30F, .59F, .11F };
       foreach(light, &ctx->Light.EnabledList) {
-	 light->dli = DOT3(ci, light->Diffuse);
-	 light->sli = DOT3(ci, light->Specular);
+	 light->_dli = DOT3(ci, light->Diffuse);
+	 light->_sli = DOT3(ci, light->Specular);
       }
    }
 }
 
-
 
-/* Need to seriously restrict the circumstances under which these
- * calc's are performed.
+/* _NEW_MODELVIEW
+ * _NEW_LIGHT
+ * _TNL_NEW_NEED_EYE_COORDS
+ *
+ * Update on (_NEW_MODELVIEW | _NEW_LIGHT) when lighting is enabled.
+ * Also update on lighting space changes.
  */
 void
-gl_compute_light_positions( GLcontext *ctx )
+_mesa_compute_light_positions( GLcontext *ctx )
 {
    struct gl_light *light;
-   
-   if (1 /*ctx->Light.NeedVertices && !ctx->Light.Model.LocalViewer*/) {
-      static const GLfloat eye_z[3] = { 0, 0, 1 };
-      if (ctx->NeedEyeCoords) {
-	 COPY_3V( ctx->EyeZDir, eye_z );
-      }
-      else {
-	 TRANSFORM_NORMAL( ctx->EyeZDir, eye_z, ctx->ModelView.m );
-      }
+   static const GLfloat eye_z[3] = { 0, 0, 1 };
+
+   if (!ctx->Light.Enabled)
+      return;
+
+   if (ctx->_NeedEyeCoords) {
+      COPY_3V( ctx->_EyeZDir, eye_z );
+   }
+   else {
+      TRANSFORM_NORMAL( ctx->_EyeZDir, eye_z, ctx->ModelView.m );
    }
 
    foreach (light, &ctx->Light.EnabledList) {
 
-      if (ctx->NeedEyeCoords) {
-	 COPY_4FV( light->Position, light->EyePosition );
+      if (ctx->_NeedEyeCoords) {
+	 COPY_4FV( light->_Position, light->EyePosition );
       }
       else {
-	 TRANSFORM_POINT( light->Position, ctx->ModelView.inv, 
+	 TRANSFORM_POINT( light->_Position, ctx->ModelView.inv,
 			  light->EyePosition );
       }
 
-      if (!(light->Flags & LIGHT_POSITIONAL)) {
+      if (!(light->_Flags & LIGHT_POSITIONAL)) {
 	 /* VP (VP) = Normalize( Position ) */
-	 COPY_3V( light->VP_inf_norm, light->Position );
-	 NORMALIZE_3FV( light->VP_inf_norm );
+	 COPY_3V( light->_VP_inf_norm, light->_Position );
+	 NORMALIZE_3FV( light->_VP_inf_norm );
 
 	 if (!ctx->Light.Model.LocalViewer) {
-	    /* h_inf_norm = Normalize( V_to_P + <0,0,1> ) */
-	    ADD_3V( light->h_inf_norm, light->VP_inf_norm, ctx->EyeZDir);
-	    NORMALIZE_3FV( light->h_inf_norm );
+	    /* _h_inf_norm = Normalize( V_to_P + <0,0,1> ) */
+	    ADD_3V( light->_h_inf_norm, light->_VP_inf_norm, ctx->_EyeZDir);
+	    NORMALIZE_3FV( light->_h_inf_norm );
 	 }
-	 light->VP_inf_spot_attenuation = 1.0;
+	 light->_VP_inf_spot_attenuation = 1.0;
       }
-      
-      if (light->Flags & LIGHT_SPOT) {
-	 if (ctx->NeedEyeNormals) {
-	    COPY_3V( light->NormDirection, light->EyeDirection );
+
+      if (light->_Flags & LIGHT_SPOT) {
+	 if (ctx->_NeedEyeCoords) {
+	    COPY_3V( light->_NormDirection, light->EyeDirection );
 	 }
          else {
-	    TRANSFORM_NORMAL( light->NormDirection, 
+	    TRANSFORM_NORMAL( light->_NormDirection,
 			      light->EyeDirection,
 			      ctx->ModelView.m);
 	 }
-
-	 NORMALIZE_3FV( light->NormDirection );
 
+	 NORMALIZE_3FV( light->_NormDirection );
 
-	 /* Unlikely occurrance?
-	  */
-	 if (!(light->Flags & LIGHT_POSITIONAL)) {
-	    GLfloat PV_dot_dir = - DOT3(light->VP_inf_norm, 
-					light->NormDirection);
+	 if (!(light->_Flags & LIGHT_POSITIONAL)) {
+	    GLfloat PV_dot_dir = - DOT3(light->_VP_inf_norm,
+					light->_NormDirection);
 
-	    if (PV_dot_dir > light->CosCutoff) {
+	    if (PV_dot_dir > light->_CosCutoff) {
 	       double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
 	       int k = (int) x;
-	       light->VP_inf_spot_attenuation = 
-		  (light->SpotExpTable[k][0] + 
-		   (x-k)*light->SpotExpTable[k][1]);
+	       light->_VP_inf_spot_attenuation =
+		  (GLfloat) (light->_SpotExpTable[k][0] +
+		   (x-k)*light->_SpotExpTable[k][1]);
 	    }
 	    else {
-	       light->VP_inf_spot_attenuation = 0;
+	       light->_VP_inf_spot_attenuation = 0;
             }
 	 }
       }
    }
-}
-
-
-void
-gl_update_normal_transform( GLcontext *ctx )
-{
-   GLuint new_flag = 0;
-   normal_func *last = ctx->NormalTransform;
-   
-   ctx->vb_rescale_factor = 1.0;
-
-   if (ctx->NeedEyeCoords) {
-      if (ctx->NeedNormals) {
-	 GLuint transform = NORM_TRANSFORM_NO_ROT;
-
-	 if (ctx->ModelView.flags & (MAT_FLAG_GENERAL |
-				     MAT_FLAG_ROTATION |
-				     MAT_FLAG_GENERAL_3D |
-				     MAT_FLAG_PERSPECTIVE)) 
-	    transform = NORM_TRANSFORM;
-
-	    
-	 new_flag = ctx->NewState & NEW_MODELVIEW;
-	 ctx->vb_rescale_factor = ctx->rescale_factor;
-	       
-	 if (ctx->Transform.Normalize) {
-	    ctx->NormalTransform = gl_normal_tab[transform | NORM_NORMALIZE];
-	 } 
-	 else if (ctx->Transform.RescaleNormals &&
-		  ctx->rescale_factor != 1.0) {
-	    ctx->NormalTransform = gl_normal_tab[transform | NORM_RESCALE];
-	 }
-	 else {
-	    ctx->NormalTransform = gl_normal_tab[transform];
-	 }
-      }
-      else {
-	 ctx->NormalTransform = 0;
-      }
-   }
-   else {
-      if (ctx->NeedNormals) {
-	 ctx->vb_rescale_factor = 1.0/ctx->rescale_factor;
-
-	 if (ctx->Transform.Normalize) {
-	    ctx->NormalTransform = gl_normal_tab[NORM_NORMALIZE];
-	 }
-	 else if (!ctx->Transform.RescaleNormals &&
-		  ctx->rescale_factor != 1.0) {
-	    ctx->NormalTransform = gl_normal_tab[NORM_RESCALE];
-	 }
-	 else {
-	    ctx->NormalTransform = 0;
-	 }
-      }
-      else {
-	 ctx->NormalTransform = 0;
-      }
-   }
-
-   if (last != ctx->NormalTransform || new_flag)
-      ctx->NewState |= NEW_NORMAL_TRANSFORM;
 }
Index: xc/extras/Mesa/src/light.h
diff -u xc/extras/Mesa/src/light.h:1.6 xc/extras/Mesa/src/light.h:1.7
--- xc/extras/Mesa/src/light.h:1.6	Mon Nov 13 18:30:49 2000
+++ xc/extras/Mesa/src/light.h	Fri Feb 22 14:25:34 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,16 +28,9 @@
 #define LIGHT_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
-struct gl_shine_tab {
-   struct gl_shine_tab *next, *prev;
-   GLfloat tab[SHINE_TABLE_SIZE+1];
-   GLfloat shininess;
-   GLuint refcount;
-};
 
-
 extern void
 _mesa_ShadeModel( GLenum mode );
 
@@ -69,18 +62,6 @@
 _mesa_LightModeliv( GLenum pname, const GLint *params );
 
 extern void
-_mesa_Materialf( GLenum face, GLenum pname, GLfloat param );
-
-extern void
-_mesa_Materialfv( GLenum face, GLenum pname, const GLfloat *params );
-
-extern void
-_mesa_Materiali( GLenum face, GLenum pname, GLint param );
-
-extern void
-_mesa_Materialiv( GLenum face, GLenum pname, const GLint *params );
-
-extern void
 _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params );
 
 extern void
@@ -93,32 +74,49 @@
 _mesa_GetMaterialiv( GLenum face, GLenum pname, GLint *params );
 
 
+/* Lerp between adjacent values in the f(x) lookup table, giving a
+ * continuous function, with adequeate overall accuracy.  (Though
+ * still pretty good compared to a straight lookup).
+ * Result should be a GLfloat.
+ */
+#define GET_SHINE_TAB_ENTRY( table, dp, result )			\
+do {									\
+   struct gl_shine_tab *_tab = table;					\
+   float f = (dp * (SHINE_TABLE_SIZE-1));				\
+   int k = (int) f;							\
+   if (k > SHINE_TABLE_SIZE-2) 						\
+      result = (GLfloat) pow( dp, _tab->shininess );			\
+   else									\
+      result = _tab->tab[k] + (f-k)*(_tab->tab[k+1]-_tab->tab[k]);	\
+} while (0)
+
 
-extern GLuint gl_material_bitmask( GLcontext *ctx, 
-				   GLenum face, GLenum pname, 
-				   GLuint legal,
-				   const char * );
 
-extern void gl_set_material( GLcontext *ctx, GLuint bitmask,
-                             const GLfloat *params);
+extern GLuint _mesa_material_bitmask( GLcontext *ctx,
+                                      GLenum face, GLenum pname,
+                                      GLuint legal,
+                                      const char * );
 
-extern void gl_compute_spot_exp_table( struct gl_light *l );
+extern void _mesa_invalidate_spot_exp_table( struct gl_light *l );
 
-extern void gl_compute_shine_table( GLcontext *ctx, GLuint i, 
-				    GLfloat shininess );
+extern void _mesa_invalidate_shine_table( GLcontext *ctx, GLuint i );
 
-extern void gl_update_lighting( GLcontext *ctx );
+extern void _mesa_validate_all_lighting_tables( GLcontext *ctx );
 
-extern void gl_compute_light_positions( GLcontext *ctx );
+extern void _mesa_update_lighting( GLcontext *ctx );
 
-extern void gl_update_normal_transform( GLcontext *ctx );
+extern void _mesa_compute_light_positions( GLcontext *ctx );
 
-extern void gl_update_material( GLcontext *ctx, 
-				const struct gl_material src[2], 
-				GLuint bitmask );
+extern void _mesa_update_material( GLcontext *ctx,
+                                   const struct gl_material src[2],
+                                   GLuint bitmask );
 
-extern void gl_update_color_material( GLcontext *ctx, const GLubyte rgba[4] );
+extern void _mesa_copy_material_pairs( struct gl_material dst[2],
+                                       const struct gl_material src[2],
+                                       GLuint bitmask );
 
+extern void _mesa_update_color_material( GLcontext *ctx,
+                                         const GLfloat rgba[4] );
 
-#endif
 
+#endif
Index: xc/extras/Mesa/src/lines.c
diff -u xc/extras/Mesa/src/lines.c:1.9 xc/extras/Mesa/src/lines.c:1.10
--- xc/extras/Mesa/src/lines.c:1.9	Wed Nov 14 05:28:07 2001
+++ xc/extras/Mesa/src/lines.c	Fri Feb 22 14:25:34 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -30,14 +30,11 @@
 #include "glheader.h"
 #include "context.h"
 #include "depth.h"
-#include "feedback.h"
 #include "lines.h"
 #include "macros.h"
 #include "mmath.h"
-#include "pb.h"
 #include "texstate.h"
-#include "types.h"
-#include "vb.h"
+#include "mtypes.h"
 #endif
 
 
@@ -46,1163 +43,50 @@
 _mesa_LineWidth( GLfloat width )
 {
    GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    if (width<=0.0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glLineWidth" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glLineWidth" );
       return;
    }
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLineWidth");
-   
-   if (ctx->Line.Width != width) {
-      ctx->Line.Width = width;
-      ctx->TriangleCaps &= ~DD_LINE_WIDTH;
-      if (width != 1.0) ctx->TriangleCaps |= DD_LINE_WIDTH;
-      ctx->NewState |= NEW_RASTER_OPS;
-      if (ctx->Driver.LineWidth)
-         (*ctx->Driver.LineWidth)(ctx, width);
-   }
-}
-
-
-
-void
-_mesa_LineStipple( GLint factor, GLushort pattern )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLineStipple");
-   ctx->Line.StippleFactor = CLAMP( factor, 1, 256 );
-   ctx->Line.StipplePattern = pattern;
-   ctx->NewState |= NEW_RASTER_OPS;
-
-   if (ctx->Driver.LineStipple)
-      ctx->Driver.LineStipple( ctx, factor, pattern );
-}
-
-
-
-/**********************************************************************/
-/*****                    Rasterization                           *****/
-/**********************************************************************/
-
-
-/*
- * There are 4 pairs (RGBA, CI) of line drawing functions:
- *   1. simple:  width=1 and no special rasterization functions (fastest)
- *   2. flat:  width=1, non-stippled, flat-shaded, any raster operations
- *   3. smooth:  width=1, non-stippled, smooth-shaded, any raster operations
- *   4. general:  any other kind of line (slowest)
- */
-
-
-/*
- * All line drawing functions have the same arguments:
- * v1, v2 - indexes of first and second endpoints into vertex buffer arrays
- * pv     - provoking vertex: which vertex color/index to use for flat shading.
- */
-
-
-
-
-
-
-#if MAX_WIDTH > MAX_HEIGHT
-#  define MAXPOINTS MAX_WIDTH
-#else
-#  define MAXPOINTS MAX_HEIGHT
-#endif
-
-
-/* Flat, color index line */
-static void flat_ci_line( GLcontext *ctx,
-                          GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] );
-
-#define INTERP_XY 1
-#define PLOT(X,Y)  PB_WRITE_PIXEL(ctx->PB, X, Y, 0);
-
-#include "linetemp.h"
-
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Flat, color index line with Z interpolation/testing */
-static void flat_ci_z_line( GLcontext *ctx,
-                            GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] );
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define PLOT(X,Y)  PB_WRITE_PIXEL(ctx->PB, X, Y, Z);
-
-#include "linetemp.h"
-
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Flat-shaded, RGBA line */
-static void flat_rgba_line( GLcontext *ctx,
-                            GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   const GLubyte *color = ctx->VB->ColorPtr->data[pvert];
-   PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] );
-
-#define INTERP_XY 1
-#define PLOT(X,Y)   PB_WRITE_PIXEL(ctx->PB, X, Y, 0);
-
-#include "linetemp.h"
-
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Flat-shaded, RGBA line with Z interpolation/testing */
-static void flat_rgba_z_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   const GLubyte *color = ctx->VB->ColorPtr->data[pvert];
-   PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] );
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define PLOT(X,Y)   PB_WRITE_PIXEL(ctx->PB, X, Y, Z);
-
-#include "linetemp.h"
-
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Smooth shaded, color index line */
-static void smooth_ci_line( GLcontext *ctx,
-                            GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLuint *pbi = ctx->PB->index;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-#define INTERP_XY 1
-#define INTERP_INDEX 1
-
-#define PLOT(X,Y)		\
-	pbx[count] = X;		\
-	pby[count] = Y;		\
-	pbi[count] = I;		\
-	count++;
-
-#include "linetemp.h"
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Smooth shaded, color index line with Z interpolation/testing */
-static void smooth_ci_z_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLuint *pbi = ctx->PB->index;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_INDEX 1
-
-#define PLOT(X,Y)		\
-	pbx[count] = X;		\
-	pby[count] = Y;		\
-	pbz[count] = Z;		\
-	pbi[count] = I;		\
-	count++;
-
-#include "linetemp.h"
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Smooth-shaded, RGBA line */
-static void smooth_rgba_line( GLcontext *ctx,
-                       	      GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLubyte (*pbrgba)[4] = ctx->PB->rgba;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-#define INTERP_XY 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-
-#define PLOT(X,Y)			\
-	pbx[count] = X;			\
-	pby[count] = Y;			\
-	pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	count++;
-
-#include "linetemp.h"
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Smooth-shaded, RGBA line with Z interpolation/testing */
-static void smooth_rgba_z_line( GLcontext *ctx,
-                       	        GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLubyte (*pbrgba)[4] = ctx->PB->rgba;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-
-#define PLOT(X,Y)			\
-	pbx[count] = X;			\
-	pby[count] = Y;			\
-	pbz[count] = Z;			\
-	pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	count++;
-
-#include "linetemp.h"
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-#define CHECK_FULL(count)			\
-	if (count >= PB_SIZE-MAX_WIDTH) {	\
-	   ctx->PB->count = count;		\
-	   gl_flush_pb(ctx);			\
-	   count = ctx->PB->count;		\
-	}
-
-
-
-/* Smooth shaded, color index, any width, maybe stippled */
-static void general_smooth_ci_line( GLcontext *ctx,
-                           	    GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLuint *pbi = ctx->PB->index;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_INDEX 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y)		\
-	pbx[count] = X;		\
-	pby[count] = Y;		\
-	pbz[count] = Z;		\
-	pbi[count] = I;		\
-	count++;		\
-	CHECK_FULL(count);
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-      if (ctx->Line.Width==2.0F) {
-         /* special case: unstippled and width=2 */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_INDEX 1
-#define XMAJOR_PLOT(X,Y)			\
-	pbx[count] = X;  pbx[count+1] = X;	\
-	pby[count] = Y;  pby[count+1] = Y+1;	\
-	pbz[count] = Z;  pbz[count+1] = Z;	\
-	pbi[count] = I;  pbi[count+1] = I;	\
-	count += 2;				\
-	CHECK_FULL(count);
-#define YMAJOR_PLOT(X,Y)			\
-	pbx[count] = X;  pbx[count+1] = X+1;	\
-	pby[count] = Y;  pby[count+1] = Y;	\
-	pbz[count] = Z;  pbz[count+1] = Z;	\
-	pbi[count] = I;  pbi[count+1] = I;	\
-	count += 2;				\
-	CHECK_FULL(count);
-#include "linetemp.h"
-      }
-      else {
-         /* unstippled, any width */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_INDEX 1
-#define WIDE 1
-#define PLOT(X,Y)		\
-	pbx[count] = X;		\
-	pby[count] = Y;		\
-	pbz[count] = Z;		\
-	pbi[count] = I;		\
-	count++;		\
-	CHECK_FULL(count);
-#include "linetemp.h"
-      }
-   }
 
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-/* Flat shaded, color index, any width, maybe stippled */
-static void general_flat_ci_line( GLcontext *ctx,
-                                  GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   PB_SET_INDEX( ctx->PB, ctx->VB->IndexPtr->data[pvert] );
-   count = ctx->PB->count;
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled, any width */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y)		\
-	pbx[count] = X;		\
-	pby[count] = Y;		\
-	pbz[count] = Z;		\
-	count++;		\
-	CHECK_FULL(count);
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-      if (ctx->Line.Width==2.0F) {
-         /* special case: unstippled and width=2 */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define XMAJOR_PLOT(X,Y)			\
-	pbx[count] = X;  pbx[count+1] = X;	\
-	pby[count] = Y;  pby[count+1] = Y+1;	\
-	pbz[count] = Z;  pbz[count+1] = Z;	\
-	count += 2;				\
-	CHECK_FULL(count);
-#define YMAJOR_PLOT(X,Y)			\
-	pbx[count] = X;  pbx[count+1] = X+1;	\
-	pby[count] = Y;  pby[count+1] = Y;	\
-	pbz[count] = Z;  pbz[count+1] = Z;	\
-	count += 2;				\
-	CHECK_FULL(count);
-#include "linetemp.h"
-      }
-      else {
-         /* unstippled, any width */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define WIDE 1
-#define PLOT(X,Y)		\
-	pbx[count] = X;		\
-	pby[count] = Y;		\
-	pbz[count] = Z;		\
-	count++;		\
-	CHECK_FULL(count);
-#include "linetemp.h"
-      }
-   }
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-
-static void general_smooth_rgba_line( GLcontext *ctx,
-                                      GLuint vert0, GLuint vert1, GLuint pvert)
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLubyte (*pbrgba)[4] = ctx->PB->rgba;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y)				\
-	pbx[count] = X;				\
-	pby[count] = Y;				\
-	pbz[count] = Z;				\
-	pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	count++;				\
-	CHECK_FULL(count);
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-      if (ctx->Line.Width==2.0F) {
-         /* special case: unstippled and width=2 */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define XMAJOR_PLOT(X,Y)				\
-	pbx[count] = X;  pbx[count+1] = X;		\
-	pby[count] = Y;  pby[count+1] = Y+1;		\
-	pbz[count] = Z;  pbz[count+1] = Z;		\
-	pbrgba[count][RCOMP] = FixedToInt(r0);		\
-	pbrgba[count][GCOMP] = FixedToInt(g0);		\
-	pbrgba[count][BCOMP] = FixedToInt(b0);		\
-	pbrgba[count][ACOMP] = FixedToInt(a0);		\
-	pbrgba[count+1][RCOMP] = FixedToInt(r0);	\
-	pbrgba[count+1][GCOMP] = FixedToInt(g0);	\
-	pbrgba[count+1][BCOMP] = FixedToInt(b0);	\
-	pbrgba[count+1][ACOMP] = FixedToInt(a0);	\
-	count += 2;					\
-	CHECK_FULL(count);
-#define YMAJOR_PLOT(X,Y)				\
-	pbx[count] = X;  pbx[count+1] = X+1;		\
-	pby[count] = Y;  pby[count+1] = Y;		\
-	pbz[count] = Z;  pbz[count+1] = Z;		\
-	pbrgba[count][RCOMP] = FixedToInt(r0);		\
-	pbrgba[count][GCOMP] = FixedToInt(g0);		\
-	pbrgba[count][BCOMP] = FixedToInt(b0);		\
-	pbrgba[count][ACOMP] = FixedToInt(a0);		\
-	pbrgba[count+1][RCOMP] = FixedToInt(r0);	\
-	pbrgba[count+1][GCOMP] = FixedToInt(g0);	\
-	pbrgba[count+1][BCOMP] = FixedToInt(b0);	\
-	pbrgba[count+1][ACOMP] = FixedToInt(a0);	\
-	count += 2;					\
-	CHECK_FULL(count);
-#include "linetemp.h"
-      }
-      else {
-         /* unstippled, any width */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define WIDE 1
-#define PLOT(X,Y)				\
-	pbx[count] = X;				\
-	pby[count] = Y;				\
-	pbz[count] = Z;				\
-	pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	count++;				\
-	CHECK_FULL(count);
-#include "linetemp.h"
-      }
-   }
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-static void general_flat_rgba_line( GLcontext *ctx,
-                                    GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   const GLubyte *color = ctx->VB->ColorPtr->data[pvert];
-   GLuint count;
-   PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] );
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y) 				\
-	PB_WRITE_PIXEL(ctx->PB, X, Y, Z);	\
-	count = ctx->PB->count;			\
-	CHECK_FULL(count);
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-      if (ctx->Line.Width==2.0F) {
-         /* special case: unstippled and width=2 */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define XMAJOR_PLOT(X,Y) PB_WRITE_PIXEL(ctx->PB, X, Y, Z); \
-                         PB_WRITE_PIXEL(ctx->PB, X, Y+1, Z);
-#define YMAJOR_PLOT(X,Y)  PB_WRITE_PIXEL(ctx->PB, X, Y, Z); \
-                          PB_WRITE_PIXEL(ctx->PB, X+1, Y, Z);
-#include "linetemp.h"
-      }
-      else {
-         /* unstippled, any width */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define WIDE 1
-#define PLOT(X,Y) 				\
-	PB_WRITE_PIXEL(ctx->PB, X, Y, Z);	\
-	count = ctx->PB->count;			\
-	CHECK_FULL(count);
-#include "linetemp.h"
-      }
-   }
-
-   gl_flush_pb(ctx);
-}
-
-
-/* Flat-shaded, textured, any width, maybe stippled */
-static void flat_textured_line( GLcontext *ctx,
-                                GLuint vert0, GLuint vert1, GLuint pv )
-{
-   GLint count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLfloat *pbs = ctx->PB->s[0];
-   GLfloat *pbt = ctx->PB->t[0];
-   GLfloat *pbu = ctx->PB->u[0];
-   GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   PB_SET_COLOR( ctx->PB, color[0], color[1], color[2], color[3] );
-   count = ctx->PB->count;
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_STUV0 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y)			\
-	{				\
-	   pbx[count] = X;		\
-	   pby[count] = Y;		\
-	   pbz[count] = Z;		\
-	   pbs[count] = s;		\
-	   pbt[count] = t;		\
-	   pbu[count] = u;		\
-	   count++;			\
-	   CHECK_FULL(count);		\
-	}
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_STUV0 1
-#define WIDE 1
-#define PLOT(X,Y)			\
-	{				\
-	   pbx[count] = X;		\
-	   pby[count] = Y;		\
-	   pbz[count] = Z;		\
-	   pbs[count] = s;		\
-	   pbt[count] = t;		\
-	   pbu[count] = u;		\
-	   count++;			\
-	   CHECK_FULL(count);		\
-	}
-#include "linetemp.h"
-   }
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-
-/* Smooth-shaded, textured, any width, maybe stippled */
-static void smooth_textured_line( GLcontext *ctx,
-                                  GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLfloat *pbs = ctx->PB->s[0];
-   GLfloat *pbt = ctx->PB->t[0];
-   GLfloat *pbu = ctx->PB->u[0];
-   GLubyte (*pbrgba)[4] = ctx->PB->rgba;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV0 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y)					\
-	{						\
-	   pbx[count] = X;				\
-	   pby[count] = Y;				\
-	   pbz[count] = Z;				\
-	   pbs[count] = s;				\
-	   pbt[count] = t;				\
-	   pbu[count] = u;				\
-	   pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	   pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	   pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	   pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	   count++;					\
-	   CHECK_FULL(count);				\
-	}
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV0 1
-#define WIDE 1
-#define PLOT(X,Y)					\
-	{						\
-	   pbx[count] = X;				\
-	   pby[count] = Y;				\
-	   pbz[count] = Z;				\
-	   pbs[count] = s;				\
-	   pbt[count] = t;				\
-	   pbu[count] = u;				\
-	   pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	   pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	   pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	   pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	   count++;					\
-	   CHECK_FULL(count);				\
-	}
-#include "linetemp.h"
-   }
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-/* Smooth-shaded, multitextured, any width, maybe stippled, separate specular
- * color interpolation.
- */
-static void smooth_multitextured_line( GLcontext *ctx,
-                                   GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLfloat *pbs = ctx->PB->s[0];
-   GLfloat *pbt = ctx->PB->t[0];
-   GLfloat *pbu = ctx->PB->u[0];
-   GLfloat *pbs1 = ctx->PB->s[1];
-   GLfloat *pbt1 = ctx->PB->t[1];
-   GLfloat *pbu1 = ctx->PB->u[1];
-   GLubyte (*pbrgba)[4] = ctx->PB->rgba;
-   GLubyte (*pbspec)[3] = ctx->PB->spec;
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_SPEC 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV0 1
-#define INTERP_STUV1 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y)					\
-	{						\
-	   pbx[count] = X;				\
-	   pby[count] = Y;				\
-	   pbz[count] = Z;				\
-	   pbs[count] = s;				\
-	   pbt[count] = t;				\
-	   pbu[count] = u;				\
-	   pbs1[count] = s1;				\
-	   pbt1[count] = t1;				\
-	   pbu1[count] = u1;				\
-	   pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	   pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	   pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	   pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	   pbspec[count][RCOMP] = FixedToInt(sr0);	\
-	   pbspec[count][GCOMP] = FixedToInt(sg0);	\
-	   pbspec[count][BCOMP] = FixedToInt(sb0);	\
-	   count++;					\
-	   CHECK_FULL(count);				\
-	}
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_RGB 1
-#define INTERP_SPEC 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV0 1
-#define INTERP_STUV1 1
-#define WIDE 1
-#define PLOT(X,Y)					\
-	{						\
-	   pbx[count] = X;				\
-	   pby[count] = Y;				\
-	   pbz[count] = Z;				\
-	   pbs[count] = s;				\
-	   pbt[count] = t;				\
-	   pbu[count] = u;				\
-	   pbs1[count] = s1;				\
-	   pbt1[count] = t1;				\
-	   pbu1[count] = u1;				\
-	   pbrgba[count][RCOMP] = FixedToInt(r0);	\
-	   pbrgba[count][GCOMP] = FixedToInt(g0);	\
-	   pbrgba[count][BCOMP] = FixedToInt(b0);	\
-	   pbrgba[count][ACOMP] = FixedToInt(a0);	\
-	   pbspec[count][RCOMP] = FixedToInt(sr0);	\
-	   pbspec[count][GCOMP] = FixedToInt(sg0);	\
-	   pbspec[count][BCOMP] = FixedToInt(sb0);	\
-	   count++;					\
-	   CHECK_FULL(count);				\
-	}
-#include "linetemp.h"
-   }
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-/* Flat-shaded, multitextured, any width, maybe stippled, separate specular
- * color interpolation.
- */
-static void flat_multitextured_line( GLcontext *ctx,
-                                     GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   GLint count = ctx->PB->count;
-   GLint *pbx = ctx->PB->x;
-   GLint *pby = ctx->PB->y;
-   GLdepth *pbz = ctx->PB->z;
-   GLfloat *pbs = ctx->PB->s[0];
-   GLfloat *pbt = ctx->PB->t[0];
-   GLfloat *pbu = ctx->PB->u[0];
-   GLfloat *pbs1 = ctx->PB->s[1];
-   GLfloat *pbt1 = ctx->PB->t[1];
-   GLfloat *pbu1 = ctx->PB->u[1];
-   GLubyte (*pbrgba)[4] = ctx->PB->rgba;
-   GLubyte (*pbspec)[3] = ctx->PB->spec;
-   GLubyte *color = ctx->VB->ColorPtr->data[pvert];
-   GLubyte sRed   = ctx->VB->Specular ? ctx->VB->Specular[pvert][0] : 0;
-   GLubyte sGreen = ctx->VB->Specular ? ctx->VB->Specular[pvert][1] : 0;
-   GLubyte sBlue  = ctx->VB->Specular ? ctx->VB->Specular[pvert][2] : 0;
-
-   (void) pvert;
-
-   ctx->PB->mono = GL_FALSE;
-
-   if (ctx->Line.StippleFlag) {
-      /* stippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV0 1
-#define INTERP_STUV1 1
-#define WIDE 1
-#define STIPPLE 1
-#define PLOT(X,Y)					\
-	{						\
-	   pbx[count] = X;				\
-	   pby[count] = Y;				\
-	   pbz[count] = Z;				\
-	   pbs[count] = s;				\
-	   pbt[count] = t;				\
-	   pbu[count] = u;				\
-	   pbs1[count] = s1;				\
-	   pbt1[count] = t1;				\
-	   pbu1[count] = u1;				\
-	   pbrgba[count][RCOMP] = color[0];		\
-	   pbrgba[count][GCOMP] = color[1];		\
-	   pbrgba[count][BCOMP] = color[2];		\
-	   pbrgba[count][ACOMP] = color[3];		\
-	   pbspec[count][RCOMP] = sRed;			\
-	   pbspec[count][GCOMP] = sGreen;		\
-	   pbspec[count][BCOMP] = sBlue;		\
-	   count++;					\
-	   CHECK_FULL(count);				\
-	}
-#include "linetemp.h"
-   }
-   else {
-      /* unstippled */
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV0 1
-#define INTERP_STUV1 1
-#define WIDE 1
-#define PLOT(X,Y)					\
-	{						\
-	   pbx[count] = X;				\
-	   pby[count] = Y;				\
-	   pbz[count] = Z;				\
-	   pbs[count] = s;				\
-	   pbt[count] = t;				\
-	   pbu[count] = u;				\
-	   pbs1[count] = s1;				\
-	   pbt1[count] = t1;				\
-	   pbu1[count] = u1;				\
-	   pbrgba[count][RCOMP] = color[0];		\
-	   pbrgba[count][GCOMP] = color[1];		\
-	   pbrgba[count][BCOMP] = color[2];		\
-	   pbrgba[count][ACOMP] = color[3];		\
-	   pbspec[count][RCOMP] = sRed;			\
-	   pbspec[count][GCOMP] = sGreen;		\
-	   pbspec[count][BCOMP] = sBlue;		\
-	   count++;					\
-	   CHECK_FULL(count);				\
-	}
-#include "linetemp.h"
-   }
-
-   ctx->PB->count = count;
-   gl_flush_pb(ctx);
-}
-
-
-
-
-/*
- * Antialiased RGBA line
- *
- * This AA line function isn't terribly efficient but it's pretty
- * straight-forward to understand.  Also, it doesn't exactly conform
- * to the specification.
- */
-static void aa_rgba_line( GLcontext *ctx,
-                          GLuint vert0, GLuint vert1, GLuint pvert )
-{
-#define INTERP_RGBA 1
-#define PLOT(x, y)  { PB_WRITE_RGBA_PIXEL( pb, (x), (y), z, red, green, blue, coverage ); }
-#include "lnaatemp.h"
-}
-
-/*
- * Antialiased Textured RGBA line
- *
- * This AA line function isn't terribly efficient but it's pretty
- * straight-forward to understand.  Also, it doesn't exactly conform
- * to the specification.
- */
-static void aa_tex_rgba_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pvert )
-{
-#define INTERP_RGBA 1
-#define INTERP_STUV0 1
-#define PLOT(x, y)							\
-   {									\
-      PB_WRITE_TEX_PIXEL( pb, (x), (y), z, red, green, blue, coverage,	\
-                          s, t, u );					\
-   }
-#include "lnaatemp.h"
-}
-
-
-/*
- * Antialiased Multitextured RGBA line
- *
- * This AA line function isn't terribly efficient but it's pretty
- * straight-forward to understand.  Also, it doesn't exactly conform
- * to the specification.
- */
-static void aa_multitex_rgba_line( GLcontext *ctx,
-                                   GLuint vert0, GLuint vert1, GLuint pvert )
-{
-#define INTERP_RGBA 1
-#define INTERP_STUV0 1
-#define INTERP_STUV1 1
-#define PLOT(x, y)							\
-   {									\
-      PB_WRITE_MULTITEX_PIXEL( pb, (x), (y), z,				\
-            red, green, blue, coverage,					\
-            s, t, u, s1, t1, u1 );					\
-   }
-#include "lnaatemp.h"
-}
-
+   if (ctx->Line.Width == width)
+      return;
 
-/* As above but with separate specular */
-static void aa_multitex_spec_line( GLcontext *ctx,
-                                   GLuint vert0, GLuint vert1, GLuint pvert )
-{
-#define INTERP_RGBA 1
-#define INTERP_SPEC 1
-#define INTERP_STUV0 1
-#define INTERP_STUV1 1
-#define PLOT(x, y)							\
-   {									\
-      PB_WRITE_MULTITEX_SPEC_PIXEL( pb, (x), (y), z,			\
-            red, green, blue, coverage, specRed, specGreen, specBlue,	\
-            s, t, u, s1, t1, u1 );					\
-   }
-#include "lnaatemp.h"
-}
+   FLUSH_VERTICES(ctx, _NEW_LINE);
+   ctx->Line.Width = width;
+   ctx->Line._Width = CLAMP(width,
+			    ctx->Const.MinLineWidth,
+			    ctx->Const.MaxLineWidth);
 
 
-/*
- * Antialiased CI line.  Same comments for RGBA antialiased lines apply.
- */
-static void aa_ci_line( GLcontext *ctx,
-                        GLuint vert0, GLuint vert1, GLuint pvert )
-{
-#define INTERP_INDEX 1
-#define PLOT(x, y)						\
-   {								\
-      PB_WRITE_CI_PIXEL( pb, (x), (y), z, index + coverage );	\
-   }
-#include "lnaatemp.h"
-}
-
+   if (width != 1.0)
+      ctx->_TriangleCaps |= DD_LINE_WIDTH;
+   else
+      ctx->_TriangleCaps &= ~DD_LINE_WIDTH;
 
-/*
- * Null rasterizer for measuring transformation speed.
- */
-static void null_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv )
-{
-   (void) ctx;
-   (void) v1;
-   (void) v2;
-   (void) pv;
+   if (ctx->Driver.LineWidth)
+      (*ctx->Driver.LineWidth)(ctx, width);
 }
 
 
 
-#ifdef DEBUG
 void
-_mesa_print_line_function(GLcontext *ctx)
+_mesa_LineStipple( GLint factor, GLushort pattern )
 {
-   printf("Line Func == ");
-   if (ctx->Driver.LineFunc == flat_ci_line)
-      printf("flat_ci_line\n");
-   else if (ctx->Driver.LineFunc == flat_ci_z_line)
-      printf("flat_ci_z_line\n");
-   else if (ctx->Driver.LineFunc == flat_rgba_line)
-      printf("flat_rgba_line\n");
-   else if (ctx->Driver.LineFunc == flat_rgba_z_line)
-      printf("flat_rgba_z_line\n");
-   else if (ctx->Driver.LineFunc == smooth_ci_line)
-      printf("smooth_ci_line\n");
-   else if (ctx->Driver.LineFunc == smooth_ci_z_line)
-      printf("smooth_ci_z_line\n");
-   else if (ctx->Driver.LineFunc == smooth_rgba_line)
-      printf("smooth_rgba_line\n");
-   else if (ctx->Driver.LineFunc == smooth_rgba_z_line)
-      printf("smooth_rgba_z_line\n");
-   else if (ctx->Driver.LineFunc == general_smooth_ci_line)
-      printf("general_smooth_ci_line\n");
-   else if (ctx->Driver.LineFunc == general_flat_ci_line)
-      printf("general_flat_ci_line\n");
-   else if (ctx->Driver.LineFunc == general_smooth_rgba_line)
-      printf("general_smooth_rgba_line\n");
-   else if (ctx->Driver.LineFunc == general_flat_rgba_line)
-      printf("general_flat_rgba_line\n");
-   else if (ctx->Driver.LineFunc == flat_textured_line)
-      printf("flat_textured_line\n");
-   else if (ctx->Driver.LineFunc == smooth_textured_line)
-      printf("smooth_textured_line\n");
-   else if (ctx->Driver.LineFunc == smooth_multitextured_line)
-      printf("smooth_multitextured_line\n");
-   else if (ctx->Driver.LineFunc == flat_multitextured_line)
-      printf("flat_multitextured_line\n");
-   else if (ctx->Driver.LineFunc == aa_rgba_line)
-      printf("aa_rgba_line\n");
-   else if (ctx->Driver.LineFunc == aa_tex_rgba_line)
-      printf("aa_tex_rgba_line\n");
-   else if (ctx->Driver.LineFunc == aa_multitex_rgba_line)
-      printf("aa_multitex_rgba_line\n");
-   else if (ctx->Driver.LineFunc == aa_multitex_spec_line)
-      printf("aa_multitex_spec_line\n");
-   else if (ctx->Driver.LineFunc == aa_ci_line)
-      printf("aa_ci_line\n");
-   else if (ctx->Driver.LineFunc == null_line)
-      printf("null_line\n");
-   else
-      printf("Driver func %p\n", ctx->Driver.LineFunc);
-}
-#endif
-
-
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-/*
- * Determine which line drawing function to use given the current
- * rendering context.
- */
-void gl_set_line_function( GLcontext *ctx )
-{
-   GLboolean rgbmode = ctx->Visual->RGBAflag;
-   /* TODO: antialiased lines */
+   factor = CLAMP( factor, 1, 256 );
 
-   if (ctx->RenderMode==GL_RENDER) {
-      if (ctx->NoRaster) {
-         ctx->Driver.LineFunc = null_line;
-         return;
-      }
-      if (ctx->Driver.LineFunc) {
-         /* Device driver will draw lines. */
-	 return;
-      }
+   if (ctx->Line.StippleFactor == factor &&
+       ctx->Line.StipplePattern == pattern)
+      return;
 
-      if (ctx->Line.SmoothFlag) {
-         /* antialiased lines */
-         if (rgbmode) {
-            if (ctx->Texture.ReallyEnabled) {
-               if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-                  /* Multitextured! */
-                  if (ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
-                     ctx->Driver.LineFunc = aa_multitex_spec_line;
-                  else
-                     ctx->Driver.LineFunc = aa_multitex_rgba_line;
-               }
-               else {
-                  ctx->Driver.LineFunc = aa_tex_rgba_line;
-               }
-            } else {
-               ctx->Driver.LineFunc = aa_rgba_line;
-            }
-         }
-         else {
-            ctx->Driver.LineFunc = aa_ci_line;
-         }
-      }
-      else if (ctx->Texture.ReallyEnabled) {
-         if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D
-             || ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) {
-            /* multi-texture and/or separate specular color */
-            if (ctx->Light.ShadeModel==GL_SMOOTH)
-               ctx->Driver.LineFunc = smooth_multitextured_line;
-            else
-               ctx->Driver.LineFunc = flat_multitextured_line;
-         }
-         else {
-            if (ctx->Light.ShadeModel==GL_SMOOTH) {
-                ctx->Driver.LineFunc = smooth_textured_line;
-            }
-            else {
-                ctx->Driver.LineFunc = flat_textured_line;
-            }
-         }
-      }
-      else if (ctx->Line.Width!=1.0 || ctx->Line.StippleFlag
-               || ctx->Line.SmoothFlag) {
-         if (ctx->Light.ShadeModel==GL_SMOOTH) {
-            if (rgbmode)
-               ctx->Driver.LineFunc = general_smooth_rgba_line;
-            else
-               ctx->Driver.LineFunc = general_smooth_ci_line;
-         }
-         else {
-            if (rgbmode)
-               ctx->Driver.LineFunc = general_flat_rgba_line;
-            else
-               ctx->Driver.LineFunc = general_flat_ci_line;
-         }
-      }
-      else {
-	 if (ctx->Light.ShadeModel==GL_SMOOTH) {
-	    /* Width==1, non-stippled, smooth-shaded */
-            if (ctx->Depth.Test || ctx->FogMode == FOG_FRAGMENT) {
-               if (rgbmode)
-                  ctx->Driver.LineFunc = smooth_rgba_z_line;
-               else
-                  ctx->Driver.LineFunc = smooth_ci_z_line;
-            }
-            else {
-               if (rgbmode)
-                  ctx->Driver.LineFunc = smooth_rgba_line;
-               else
-                  ctx->Driver.LineFunc = smooth_ci_line;
-            }
-	 }
-         else {
-	    /* Width==1, non-stippled, flat-shaded */
-            if (ctx->Depth.Test || ctx->FogMode == FOG_FRAGMENT) {
-               if (rgbmode)
-                  ctx->Driver.LineFunc = flat_rgba_z_line;
-               else
-                  ctx->Driver.LineFunc = flat_ci_z_line;
-            }
-            else {
-               if (rgbmode)
-                  ctx->Driver.LineFunc = flat_rgba_line;
-               else
-                  ctx->Driver.LineFunc = flat_ci_line;
-            }
-         }
-      }
-   }
-   else if (ctx->RenderMode==GL_FEEDBACK) {
-      ctx->Driver.LineFunc = gl_feedback_line;
-   }
-   else {
-      /* GL_SELECT mode */
-      ctx->Driver.LineFunc = gl_select_line;
-   }
+   FLUSH_VERTICES(ctx, _NEW_LINE);
+   ctx->Line.StippleFactor = factor;
+   ctx->Line.StipplePattern = pattern;
 
-   /*_mesa_print_line_function(ctx);*/
+   if (ctx->Driver.LineStipple)
+      ctx->Driver.LineStipple( ctx, factor, pattern );
 }
Index: xc/extras/Mesa/src/lines.h
diff -u xc/extras/Mesa/src/lines.h:1.3 xc/extras/Mesa/src/lines.h:1.4
--- xc/extras/Mesa/src/lines.h:1.3	Tue Feb 15 02:12:24 2000
+++ xc/extras/Mesa/src/lines.h	Fri Feb 22 14:25:34 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define LINES_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
@@ -36,9 +36,6 @@
 
 extern void
 _mesa_LineStipple( GLint factor, GLushort pattern );
-
-extern void
-gl_set_line_function( GLcontext *ctx );
 
 
 #endif
Index: xc/extras/Mesa/src/linetemp.h
diff -u xc/extras/Mesa/src/linetemp.h:1.11 xc/extras/Mesa/src/linetemp.h:removed
--- xc/extras/Mesa/src/linetemp.h:1.11	Tue Dec 11 04:18:54 2001
+++ xc/extras/Mesa/src/linetemp.h	Thu Feb 27 12:15:40 2003
@@ -1,624 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/linetemp.h,v 1.11 2001/12/11 09:18:54 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Line Rasterizer Template
- *
- * This file is #include'd to generate custom line rasterizers.
- *
- * The following macros may be defined to indicate what auxillary information
- * must be interplated along the line:
- *    INTERP_Z      - if defined, interpolate Z values
- *    INTERP_RGB    - if defined, interpolate RGB values
- *    INTERP_SPEC   - if defined, interpolate specular RGB values
- *    INTERP_ALPHA  - if defined, interpolate Alpha values
- *    INTERP_INDEX  - if defined, interpolate color index values
- *    INTERP_ST     - if defined, interpolate integer ST texcoords
- *                         (fast, simple 2-D texture mapping)
- *    INTERP_STUV0   - if defined, interpolate unit 0 STU texcoords with
- *                         perspective correction
- *                         NOTE:  OpenGL STRQ = Mesa STUV (R was taken for red)
- *    INTERP_STUV1   - if defined, interpolate unit 1 STU texcoords
- *
- * When one can directly address pixels in the color buffer the following
- * macros can be defined and used to directly compute pixel addresses during
- * rasterization (see pixelPtr):
- *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)
- *    BYTES_PER_ROW       - number of bytes per row in the color buffer
- *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
- *                          Y==0 at bottom of screen and increases upward.
- *
- * Similarly, for direct depth buffer access, this type is used for depth
- * buffer addressing:
- *    DEPTH_TYPE          - either GLushort or GLuint
- *
- * Optionally, one may provide one-time setup code
- *    SETUP_CODE    - code which is to be executed once per line
- *
- * To enable line stippling define STIPPLE = 1
- * To enable wide lines define WIDE = 1
- * 
- * To actually "plot" each pixel either the PLOT macro or
- * (XMAJOR_PLOT and YMAJOR_PLOT macros) must be defined...
- *    PLOT(X,Y) - code to plot a pixel.  Example:
- *                if (Z < *zPtr) {
- *                   *zPtr = Z;
- *                   color = pack_rgb( FixedToInt(r0), FixedToInt(g0),
- *                                     FixedToInt(b0) );
- *                   put_pixel( X, Y, color );
- *                }
- *
- * This code was designed for the origin to be in the lower-left corner.
- *
- */
-
-
-/*void line( GLcontext *ctx, GLuint vert0, GLuint vert1, GLuint pvert )*/
-{
-   const struct vertex_buffer *VB = ctx->VB;
-   GLint x0 = (GLint) VB->Win.data[vert0][0];
-   GLint x1 = (GLint) VB->Win.data[vert1][0];
-   GLint y0 = (GLint) VB->Win.data[vert0][1];
-   GLint y1 = (GLint) VB->Win.data[vert1][1];
-   GLint dx, dy;
-#ifdef INTERP_XY
-   GLint xstep, ystep;
-#endif
-#ifdef INTERP_Z
-   GLint z0, z1, dz;
-   const GLint depthBits = ctx->Visual->DepthBits;
-   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
-#  define FixedToDepth(F)  ((F) >> fixedToDepthShift)
-#  ifdef DEPTH_TYPE
-     GLint zPtrXstep, zPtrYstep;
-     DEPTH_TYPE *zPtr;
-#  endif
-#endif
-#ifdef INTERP_RGB
-   GLfixed r0 = IntToFixed(VB->ColorPtr->data[vert0][0]);
-   GLfixed dr = IntToFixed(VB->ColorPtr->data[vert1][0]) - r0;
-   GLfixed g0 = IntToFixed(VB->ColorPtr->data[vert0][1]);
-   GLfixed dg = IntToFixed(VB->ColorPtr->data[vert1][1]) - g0;
-   GLfixed b0 = IntToFixed(VB->ColorPtr->data[vert0][2]);
-   GLfixed db = IntToFixed(VB->ColorPtr->data[vert1][2]) - b0;
-#endif
-#ifdef INTERP_SPEC
-   GLfixed sr0 = VB->Specular ? IntToFixed(VB->Specular[vert0][0]) : 0;
-   GLfixed dsr = VB->Specular ? IntToFixed(VB->Specular[vert1][0]) - sr0 : 0;
-   GLfixed sg0 = VB->Specular ? IntToFixed(VB->Specular[vert0][1]) : 0;
-   GLfixed dsg = VB->Specular ? IntToFixed(VB->Specular[vert1][1]) - sg0 : 0;
-   GLfixed sb0 = VB->Specular ? IntToFixed(VB->Specular[vert0][2]) : 0;
-   GLfixed dsb = VB->Specular ? IntToFixed(VB->Specular[vert1][2]) - sb0 : 0;
-#endif
-#ifdef INTERP_ALPHA
-   GLfixed a0 = IntToFixed(VB->ColorPtr->data[vert0][3]);
-   GLfixed da = IntToFixed(VB->ColorPtr->data[vert1][3]) - a0;
-#endif
-#ifdef INTERP_INDEX
-   GLint i0 = VB->IndexPtr->data[vert0] << 8;
-   GLint di = (GLint) (VB->IndexPtr->data[vert1] << 8) - i0;
-#endif
-#ifdef INTERP_ST
-   GLfixed s0 = FloatToFixed(VB->TexCoord[vert0][0] * S_SCALE);
-   GLfixed ds = FloatToFixed(VB->TexCoord[vert1][0] * S_SCALE) - s0;
-   GLfixed t0 = FloatToFixed(VB->TexCoord[vert0][1] * T_SCALE);
-   GLfixed dt = FloatToFixed(VB->TexCoord[vert1][1] * T_SCALE) - t0;
-#endif
-#if defined(INTERP_STUV0) || defined(INTERP_STUV1)
-   GLfloat invw0 = VB->Win.data[vert0][3];
-   GLfloat invw1 = VB->Win.data[vert1][3];
-#endif
-#ifdef INTERP_STUV0
-   /* h denotes hyperbolic */
-   GLfloat hs0 = invw0 * VB->TexCoordPtr[0]->data[vert0][0];
-   GLfloat dhs = invw1 * VB->TexCoordPtr[0]->data[vert1][0] - hs0;
-   GLfloat ht0 = invw0 * VB->TexCoordPtr[0]->data[vert0][1];
-   GLfloat dht = invw1 * VB->TexCoordPtr[0]->data[vert1][1] - ht0;
-   GLfloat hu0 = 0, dhu = 0;
-   GLfloat hv0 = invw0, dhv = invw1 - invw0;
-#endif
-#ifdef INTERP_STUV1
-   GLfloat hs01 = invw0 * VB->TexCoordPtr[1]->data[vert0][0];
-   GLfloat dhs1 = invw1 * VB->TexCoordPtr[1]->data[vert1][0] - hs01;
-   GLfloat ht01 = invw0 * VB->TexCoordPtr[1]->data[vert0][1];
-   GLfloat dht1 = invw1 * VB->TexCoordPtr[1]->data[vert1][1] - ht01;
-   GLfloat hu01 = 0, dhu1 = 0;
-   GLfloat hv01 = invw0, dhv1 = invw1 - invw0;
-#endif
-#ifdef PIXEL_ADDRESS
-   PIXEL_TYPE *pixelPtr;
-   GLint pixelXstep, pixelYstep;
-#endif
-#ifdef WIDE
-   /* for wide lines, draw all X in [x+min, x+max] or Y in [y+min, y+max] */
-   GLint width, min, max;
-   width = (GLint) CLAMP( ctx->Line.Width, MIN_LINE_WIDTH, MAX_LINE_WIDTH );
-   min = (width-1) / -2;
-   max = min + width - 1;
-#endif
-#ifdef INTERP_STUV0
-   if (VB->TexCoordPtr[0]->size > 2) {
-      hu0 = invw0 * VB->TexCoordPtr[0]->data[vert0][2];
-      dhu = invw1 * VB->TexCoordPtr[0]->data[vert1][2] - hu0;
-      if (VB->TexCoordPtr[0]->size > 3) {
-	 hv0 = invw0 * VB->TexCoordPtr[0]->data[vert0][3];
-	 dhv = invw1 * VB->TexCoordPtr[0]->data[vert1][3] - hv0;
-      }
-   }
-#endif
-#ifdef INTERP_STUV1
-   if (VB->TexCoordPtr[1]->size > 2) {
-      hu01 = invw0 * VB->TexCoordPtr[1]->data[vert0][2];
-      dhu1 = invw1 * VB->TexCoordPtr[1]->data[vert1][2] - hu01;
-      if (VB->TexCoordPtr[1]->size > 3) {
-	 hv01 = invw0 * VB->TexCoordPtr[1]->data[vert0][3];
-	 dhv1 = invw1 * VB->TexCoordPtr[1]->data[vert1][3] - hv01;
-      }
-   }
-#endif
-
-   /* Cull primitives with malformed coordinates.
-    */
-   {
-      float tmp = VB->Win.data[vert0][0] + 
-	          VB->Win.data[vert0][1] + 
-		  VB->Win.data[vert1][0] + 
-		  VB->Win.data[vert1][1];
-      if (IS_INF_OR_NAN(tmp))
-	 return;
-   }
-
-/*
- * Despite being clipped to the view volume, the line's window coordinates
- * may just lie outside the window bounds.  That is, if the legal window
- * coordinates are [0,W-1][0,H-1], it's possible for x==W and/or y==H.
- * This quick and dirty code nudges the endpoints inside the window if
- * necessary.
- */
-#ifdef CLIP_HACK
-   {
-      GLint w = ctx->DrawBuffer->Width;
-      GLint h = ctx->DrawBuffer->Height;
-      if ((x0==w) | (x1==w)) {
-         if ((x0==w) & (x1==w))
-           return;
-         x0 -= x0==w;
-         x1 -= x1==w;
-      }
-      if ((y0==h) | (y1==h)) {
-         if ((y0==h) & (y1==h))
-           return;
-         y0 -= y0==h;
-         y1 -= y1==h;
-      }
-   }
-#endif
-   dx = x1 - x0;
-   dy = y1 - y0;
-   if (dx==0 && dy==0) {
-      return;
-   }
-
-   /*
-    * Setup
-    */
-#ifdef SETUP_CODE
-   SETUP_CODE
-#endif
-
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-     zPtr = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, x0, y0);
-#  endif
-   if (depthBits <= 16) {
-      z0 = FloatToFixed(VB->Win.data[vert0][2] + ctx->LineZoffset);
-      z1 = FloatToFixed(VB->Win.data[vert1][2] + ctx->LineZoffset);
-   }
-   else {
-      z0 = (GLint) (VB->Win.data[vert0][2] + ctx->LineZoffset);
-      z1 = (GLint) (VB->Win.data[vert1][2] + ctx->LineZoffset);
-   }
-#endif
-#ifdef PIXEL_ADDRESS
-   pixelPtr = (PIXEL_TYPE *) PIXEL_ADDRESS(x0,y0);
-#endif
-
-   if (dx<0) {
-      dx = -dx;   /* make positive */
-#ifdef INTERP_XY
-      xstep = -1;
-#endif
-#if defined(INTERP_Z) && defined(DEPTH_TYPE)
-      zPtrXstep = -((GLint)sizeof(DEPTH_TYPE));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelXstep = -((GLint)sizeof(PIXEL_TYPE));
-#endif
-   }
-   else {
-#ifdef INTERP_XY
-      xstep = 1;
-#endif
-#if defined(INTERP_Z) && defined(DEPTH_TYPE)
-      zPtrXstep = ((GLint)sizeof(DEPTH_TYPE));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelXstep = ((GLint)sizeof(PIXEL_TYPE));
-#endif
-   }
-
-   if (dy<0) {
-      dy = -dy;   /* make positive */
-#ifdef INTERP_XY
-      ystep = -1;
-#endif
-#if defined(INTERP_Z) && defined(DEPTH_TYPE)
-      zPtrYstep = -ctx->DrawBuffer->Width * ((GLint)sizeof(DEPTH_TYPE));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelYstep = BYTES_PER_ROW;
-#endif
-   }
-   else {
-#ifdef INTERP_XY
-      ystep = 1;
-#endif
-#if defined(INTERP_Z) && defined(DEPTH_TYPE)
-      zPtrYstep = ctx->DrawBuffer->Width * ((GLint)sizeof(DEPTH_TYPE));
-#endif
-#ifdef PIXEL_ADDRESS
-      pixelYstep = -(BYTES_PER_ROW);
-#endif
-   }
-
-   /*
-    * Draw
-    */
-
-   if (dx>dy) {
-      /*** X-major line ***/
-      GLint i;
-      GLint errorInc = dy+dy;
-      GLint error = errorInc-dx;
-      GLint errorDec = error-dx;
-#ifdef INTERP_Z
-      dz = (z1-z0) / dx;
-#endif
-#ifdef INTERP_RGB
-      dr /= dx;   /* convert from whole line delta to per-pixel delta */
-      dg /= dx;
-      db /= dx;
-#endif
-#ifdef INTERP_SPEC
-      dsr /= dx;   /* convert from whole line delta to per-pixel delta */
-      dsg /= dx;
-      dsb /= dx;
-#endif
-#ifdef INTERP_ALPHA
-      da /= dx;
-#endif
-#ifdef INTERP_INDEX
-      di /= dx;
-#endif
-#ifdef INTERP_ST
-      ds /= dx;
-      dt /= dx;
-#endif
-#ifdef INTERP_STUV0
-      {
-         GLfloat invDx = 1.0F / (GLfloat) dx;
-         dhs *= invDx;
-         dht *= invDx;
-         dhu *= invDx;
-         dhv *= invDx;
-      }
-#endif
-#ifdef INTERP_STUV1
-      {
-         GLfloat invDx = 1.0F / (GLfloat) dx;
-         dhs1 *= invDx;
-         dht1 *= invDx;
-         dhu1 *= invDx;
-         dhv1 *= invDx;
-      }
-#endif
-      for (i=0;i<dx;i++) {
-#ifdef STIPPLE
-         GLushort m;
-         m = 1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf);
-         if (ctx->Line.StipplePattern & m) {
-#endif
-#ifdef INTERP_Z
-            GLdepth Z = FixedToDepth(z0);
-#endif
-#ifdef INTERP_INDEX
-            GLint I = i0 >> 8;
-#endif
-#ifdef INTERP_STUV0
-            GLfloat invQ = 1.0F / hv0;
-            GLfloat s = hs0 * invQ;
-            GLfloat t = ht0 * invQ;
-            GLfloat u = hu0 * invQ;
-#endif
-#ifdef INTERP_STUV1
-            GLfloat invQ1 = 1.0F / hv01;
-            GLfloat s1 = hs01 * invQ1;
-            GLfloat t1 = ht01 * invQ1;
-            GLfloat u1 = hu01 * invQ1;
-#endif
-#ifdef WIDE
-            GLint yy;
-            GLint ymin = y0 + min;
-            GLint ymax = y0 + max;
-            for (yy=ymin;yy<=ymax;yy++) {
-               PLOT( x0, yy );
-            }
-#else
-#  ifdef XMAJOR_PLOT
-            XMAJOR_PLOT( x0, y0 );
-#  else
-            PLOT( x0, y0 );
-#  endif
-#endif /*WIDE*/
-#ifdef STIPPLE
-        }
-	ctx->StippleCounter++;
-#endif
-#ifdef INTERP_XY
-         x0 += xstep;
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
-#  endif
-         z0 += dz;
-#endif
-#ifdef INTERP_RGB
-         r0 += dr;
-         g0 += dg;
-         b0 += db;
-#endif
-#ifdef INTERP_SPEC
-         sr0 += dsr;
-         sg0 += dsg;
-         sb0 += dsb;
-#endif
-#ifdef INTERP_ALPHA
-         a0 += da;
-#endif
-#ifdef INTERP_INDEX
-         i0 += di;
-#endif
-#ifdef INTERP_ST
-         s0 += ds;
-         t0 += dt;
-#endif
-#ifdef INTERP_STUV0
-         hs0 += dhs;
-         ht0 += dht;
-         hu0 += dhu;
-         hv0 += dhv;
-#endif
-#ifdef INTERP_STUV1
-         hs01 += dhs1;
-         ht01 += dht1;
-         hu01 += dhu1;
-         hv01 += dhv1;
-#endif
-#ifdef PIXEL_ADDRESS
-         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
-#endif
-         if (error<0) {
-            error += errorInc;
-         }
-         else {
-            error += errorDec;
-#ifdef INTERP_XY
-            y0 += ystep;
-#endif
-#if defined(INTERP_Z) && defined(DEPTH_TYPE)
-            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
-#endif
-#ifdef PIXEL_ADDRESS
-            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
-#endif
-         }
-      }
-   }
-   else {
-      /*** Y-major line ***/
-      GLint i;
-      GLint errorInc = dx+dx;
-      GLint error = errorInc-dy;
-      GLint errorDec = error-dy;
-#ifdef INTERP_Z
-      dz = (z1-z0) / dy;
-#endif
-#ifdef INTERP_RGB
-      dr /= dy;   /* convert from whole line delta to per-pixel delta */
-      dg /= dy;
-      db /= dy;
-#endif
-#ifdef INTERP_SPEC
-      dsr /= dy;   /* convert from whole line delta to per-pixel delta */
-      dsg /= dy;
-      dsb /= dy;
-#endif
-#ifdef INTERP_ALPHA
-      da /= dy;
-#endif
-#ifdef INTERP_INDEX
-      di /= dy;
-#endif
-#ifdef INTERP_ST
-      ds /= dy;
-      dt /= dy;
-#endif
-#ifdef INTERP_STUV0
-      {
-         GLfloat invDy = 1.0F / (GLfloat) dy;
-         dhs *= invDy;
-         dht *= invDy;
-         dhu *= invDy;
-         dhv *= invDy;
-      }
-#endif
-#ifdef INTERP_STUV1
-      {
-         GLfloat invDy = 1.0F / (GLfloat) dy;
-         dhs1 *= invDy;
-         dht1 *= invDy;
-         dhu1 *= invDy;
-         dhv1 *= invDy;
-      }
-#endif
-      for (i=0;i<dy;i++) {
-#ifdef STIPPLE
-         GLushort m;
-         m = 1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf);
-         if (ctx->Line.StipplePattern & m) {
-#endif
-#ifdef INTERP_Z
-            GLdepth Z = FixedToDepth(z0);
-#endif
-#ifdef INTERP_INDEX
-            GLint I = i0 >> 8;
-#endif
-#ifdef INTERP_STUV0
-            GLfloat invQ = 1.0F / hv0;
-            GLfloat s = hs0 * invQ;
-            GLfloat t = ht0 * invQ;
-            GLfloat u = hu0 * invQ;
-#endif
-#ifdef INTERP_STUV1
-            GLfloat invQ1 = 1.0F / hv01;
-            GLfloat s1 = hs01 * invQ1;
-            GLfloat t1 = ht01 * invQ1;
-            GLfloat u1 = hu01 * invQ1;
-#endif
-#ifdef WIDE
-            GLint xx;
-            GLint xmin = x0 + min;
-            GLint xmax = x0 + max;
-            for (xx=xmin;xx<=xmax;xx++) {
-               PLOT( xx, y0 );
-            }
-#else
-#  ifdef YMAJOR_PLOT
-            YMAJOR_PLOT( x0, y0 );
-#  else
-            PLOT( x0, y0 );
-#  endif
-#endif /*WIDE*/
-#ifdef STIPPLE
-        }
-	ctx->StippleCounter++;
-#endif
-#ifdef INTERP_XY
-         y0 += ystep;
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
-#  endif
-         z0 += dz;
-#endif
-#ifdef INTERP_RGB
-         r0 += dr;
-         g0 += dg;
-         b0 += db;
-#endif
-#ifdef INTERP_SPEC
-         sr0 += dsr;
-         sg0 += dsg;
-         sb0 += dsb;
-#endif
-#ifdef INTERP_ALPHA
-         a0 += da;
-#endif
-#ifdef INTERP_INDEX
-         i0 += di;
-#endif
-#ifdef INTERP_ST
-         s0 += ds;
-         t0 += dt;
-#endif
-#ifdef INTERP_STUV0
-         hs0 += dhs;
-         ht0 += dht;
-         hu0 += dhu;
-         hv0 += dhv;
-#endif
-#ifdef INTERP_STUV1
-         hs01 += dhs1;
-         ht01 += dht1;
-         hu01 += dhu1;
-         hv01 += dhv1;
-#endif
-#ifdef PIXEL_ADDRESS
-         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
-#endif
-         if (error<0) {
-            error += errorInc;
-         }
-         else {
-            error += errorDec;
-#ifdef INTERP_XY
-            x0 += xstep;
-#endif
-#if defined(INTERP_Z) && defined(DEPTH_TYPE)
-            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
-#endif
-#ifdef PIXEL_ADDRESS
-            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
-#endif
-         }
-      }
-   }
-
-}
-
-
-#undef INTERP_XY
-#undef INTERP_Z
-#undef INTERP_RGB
-#undef INTERP_SPEC
-#undef INTERP_ALPHA
-#undef INTERP_STUV0
-#undef INTERP_STUV1
-#undef INTERP_INDEX
-#undef PIXEL_ADDRESS
-#undef PIXEL_TYPE
-#undef DEPTH_TYPE
-#undef BYTES_PER_ROW
-#undef SETUP_CODE
-#undef PLOT
-#undef XMAJOR_PLOT
-#undef YMAJOR_PLOT
-#undef CLIP_HACK
-#undef STIPPLE
-#undef WIDE
-#undef FixedToDepth
Index: xc/extras/Mesa/src/lnaatemp.h
diff -u xc/extras/Mesa/src/lnaatemp.h:1.14 xc/extras/Mesa/src/lnaatemp.h:removed
--- xc/extras/Mesa/src/lnaatemp.h:1.14	Tue Dec 11 04:18:54 2001
+++ xc/extras/Mesa/src/lnaatemp.h	Thu Feb 27 12:15:40 2003
@@ -1,513 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/lnaatemp.h,v 1.14 2001/12/11 09:18:54 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * Antialiased Line Rasterizer Template
- *
- * This file is #include'd to generate custom line rasterizers.
- *
- * The following macros may be defined to indicate what auxillary information
- * must be interplated along the line:
- *    INTERP_RGBA   - if defined, interpolate RGBA values
- *    INTERP_SPEC   - if defined, interpolate specular RGB values
- *    INTERP_INDEX  - if defined, interpolate color index values
- *    INTERP_STUV0  - if defined, interpolate unit 0 STU texcoords with
- *                        perspective correction
- *                        NOTE:  OpenGL STRQ = Mesa STUV (R was taken for red)
- *    INTERP_STUV1  - if defined, interpolate unit 1 STU texcoords
- *
- * Optionally, one may provide one-time setup code
- *    SETUP_CODE    - code which is to be executed once per line
- *
- * To actually "plot" each pixel the PLOT macro must be defined.
- *
- * This code was designed for the origin to be in the lower-left corner.
- */
-
-/* void aa_line( GLcontext *ctx, GLuint vert0, GLuint vert1, GLuint pvert ) */
-{
-   const struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *pb = ctx->PB;
-   GLfloat halfWidth = 0.5F * ctx->Line.Width;  /* 0.5 is a bit of a hack */
-   GLboolean solid = !ctx->Line.StippleFlag;
-   GLint x0 = (GLint) VB->Win.data[vert0][0];
-   GLint x1 = (GLint) VB->Win.data[vert1][0];
-   GLint y0 = (GLint) VB->Win.data[vert0][1];
-   GLint y1 = (GLint) VB->Win.data[vert1][1];
-   GLint dx = x1 - x0;
-   GLint dy = y1 - y0;
-   GLint xStep, yStep;
-   GLint z0, z1;
-   const GLint depthBits = ctx->Visual->DepthBits;
-   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
-#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
-#ifdef INTERP_RGBA
-   GLfixed fr, fg, fb, fa;      /* fixed-pt RGBA */
-   GLfixed dfr = 0, dfg = 0, dfb = 0, dfa = 0;  /* fixed-pt RGBA deltas */
-#endif
-#ifdef INTERP_SPEC
-   GLfixed fsr, fsg, fsb;      /* fixed-pt specular RGBA */
-   GLfixed dfsr = 0, dfsg = 0, dfsb = 0; /* fixed-pt specular RGBA deltas */
-#endif
-#ifdef INTERP_INDEX
-   GLfixed fi, dfi = 0;
-#endif
-#if defined(INTERP_STUV0) || defined(INTERP_STUV1)
-   GLfloat invw0 = VB->Win.data[vert0][3];
-   GLfloat invw1 = VB->Win.data[vert1][3];
-#endif
-#ifdef INTERP_STUV0
-   /* h denotes hyperbolic */
-   GLfloat hs0 = invw0 * VB->TexCoordPtr[0]->data[vert0][0];
-   GLfloat dhs = invw1 * VB->TexCoordPtr[0]->data[vert1][0] - hs0;
-   GLfloat ht0 = invw0 * VB->TexCoordPtr[0]->data[vert0][1];
-   GLfloat dht = invw1 * VB->TexCoordPtr[0]->data[vert1][1] - ht0;
-   GLfloat hu0 = 0, dhu = 0;
-   GLfloat hv0 = invw0, dhv = invw1 - invw0;
-#endif
-#ifdef INTERP_STUV1
-   GLfloat hs01 = invw0 * VB->TexCoordPtr[1]->data[vert0][0];
-   GLfloat dhs1 = invw1 * VB->TexCoordPtr[1]->data[vert1][0] - hs01;
-   GLfloat ht01 = invw0 * VB->TexCoordPtr[1]->data[vert0][1];
-   GLfloat dht1 = invw1 * VB->TexCoordPtr[1]->data[vert1][1] - ht01;
-   GLfloat hu01 = 0, dhu1 = 0;
-   GLfloat hv01 = invw0, dhv1 = invw1 - invw0;
-#endif
-
-   /* Cull primitives with malformed coordinates.
-    */
-   {
-      float tmp = VB->Win.data[vert0][0] + 
-	          VB->Win.data[vert0][1] + 
-		  VB->Win.data[vert1][0] + 
-		  VB->Win.data[vert1][1];
-      if (IS_INF_OR_NAN(tmp))
-	 return;
-   }
-
-   if (dx == 0 && dy == 0)
-      return;
-
-   ctx->PB->mono = GL_FALSE;
-
-   if (depthBits <= 16) {
-      z0 = FloatToFixed(VB->Win.data[vert0][2] + ctx->LineZoffset);
-      z1 = FloatToFixed(VB->Win.data[vert1][2] + ctx->LineZoffset);
-   }
-   else {
-      z0 = (GLint) (VB->Win.data[vert0][2] + ctx->LineZoffset);
-      z1 = (GLint) (VB->Win.data[vert1][2] + ctx->LineZoffset);
-   }
-
-#ifdef INTERP_STUV0
-   if (VB->TexCoordPtr[0]->size > 2) {
-      hu0 = invw0 * VB->TexCoordPtr[0]->data[vert0][2];
-      dhu = invw1 * VB->TexCoordPtr[0]->data[vert1][2] - hu0;
-      if (VB->TexCoordPtr[0]->size > 3) {
-         hv0 = invw0 * VB->TexCoordPtr[0]->data[vert0][3];
-         dhv = invw1 * VB->TexCoordPtr[0]->data[vert1][3] - hv0;
-      }
-   }
-#endif
-
-#ifdef INTERP_STUV1
-   if (VB->TexCoordPtr[1]->size > 2) {
-      hu01 = invw0 * VB->TexCoordPtr[1]->data[vert0][2];
-      dhu1 = invw1 * VB->TexCoordPtr[1]->data[vert1][2] - hu01;
-      if (VB->TexCoordPtr[1]->size > 3) {
-         hv01 = invw0 * VB->TexCoordPtr[1]->data[vert0][3];
-         dhv1 = invw1 * VB->TexCoordPtr[1]->data[vert1][3] - hv01;
-      }
-   }
-#endif
-
-#ifdef INTERP_RGBA
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      fr = IntToFixed(VB->ColorPtr->data[vert0][0]);
-      fg = IntToFixed(VB->ColorPtr->data[vert0][1]);
-      fb = IntToFixed(VB->ColorPtr->data[vert0][2]);
-      fa = IntToFixed(VB->ColorPtr->data[vert0][3]);
-   }
-   else {
-      fr = IntToFixed(VB->ColorPtr->data[pvert][0]);
-      fg = IntToFixed(VB->ColorPtr->data[pvert][1]);
-      fb = IntToFixed(VB->ColorPtr->data[pvert][2]);
-      fa = IntToFixed(VB->ColorPtr->data[pvert][3]);
-      dfr = dfg = dfb = dfa = 0;
-   }
-#endif
-#ifdef INTERP_SPEC
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      fsr = IntToFixed(VB->Specular[vert0][0]);
-      fsg = IntToFixed(VB->Specular[vert0][1]);
-      fsb = IntToFixed(VB->Specular[vert0][2]);
-   }
-   else {
-      fsr = IntToFixed(VB->Specular[pvert][0]);
-      fsg = IntToFixed(VB->Specular[pvert][1]);
-      fsb = IntToFixed(VB->Specular[pvert][2]);
-      dfsr = dfsg = dfsb = 0;
-   }
-#endif
-#ifdef INTERP_INDEX
-   if (ctx->Light.ShadeModel == GL_SMOOTH) {
-      fi = IntToFixed(VB->IndexPtr->data[vert0]);
-   }
-   else {
-      fi = IntToFixed(VB->IndexPtr->data[pvert]);
-      dfi = 0;
-   }
-#endif
-
-   /*
-    * Setup
-    */
-#ifdef SETUP_CODE
-   SETUP_CODE
-#endif
-
-   if (dx < 0) {
-      xStep = -1;
-      dx = -dx;
-   }
-   else {
-      xStep = 1;
-   }
-
-   if (dy < 0) {
-      yStep = -1;
-      dy = -dy;
-   }
-   else {
-      yStep = 1;
-   }
-
-   if (dx > dy) {
-      /*** X-major line ***/
-      GLint i;
-      GLint x = x0;
-      GLfloat y = VB->Win.data[vert0][1];
-      const GLfloat invDx = 1.0F / dx;
-      GLfloat yStep = (VB->Win.data[vert1][1] - y) * invDx;
-      GLint dz = (GLint) ((z1 - z0) * invDx);
-#ifdef INTERP_RGBA
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         dfr = (IntToFixed(VB->ColorPtr->data[vert1][0]) - fr) * invDx;
-         dfg = (IntToFixed(VB->ColorPtr->data[vert1][1]) - fg) * invDx;
-         dfb = (IntToFixed(VB->ColorPtr->data[vert1][2]) - fb) * invDx;
-         dfa = (IntToFixed(VB->ColorPtr->data[vert1][3]) - fa) * invDx;
-      }
-#endif
-#ifdef INTERP_SPEC
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         dfsr = (IntToFixed(VB->Specular[vert1][0]) - fsr) * invDx;
-         dfsg = (IntToFixed(VB->Specular[vert1][1]) - fsg) * invDx;
-         dfsb = (IntToFixed(VB->Specular[vert1][2]) - fsb) * invDx;
-      }
-#endif
-#ifdef INTERP_STUV0
-      dhs *= invDx;
-      dht *= invDx;
-      dhu *= invDx;
-      dhv *= invDx;
-#endif
-#ifdef INTERP_STUV1
-      dhs1 *= invDx;
-      dht1 *= invDx;
-      dhu1 *= invDx;
-      dhv1 *= invDx;
-#endif
-#ifdef INTERP_INDEX
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         dfi = (IntToFixed(VB->IndexPtr->data[vert1]) - fi) * invDx;
-      }
-#endif
-
-      for (i = 0; i < dx; i++) {
-         if (solid || (ctx->Line.StipplePattern & (1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf)))) {
-
-            GLfloat yTop = y + halfWidth;
-            GLfloat yBot = y - halfWidth;
-            GLint yTopi = (GLint) yTop;
-            GLint yBoti = (GLint) yBot;
-            GLint iy;
-#ifdef INTERP_RGBA
-            GLubyte red   = FixedToInt(fr);
-            GLubyte green = FixedToInt(fg);
-            GLubyte blue  = FixedToInt(fb);
-            GLubyte alpha = FixedToInt(fa);
-            GLint coverage;
-#endif
-#ifdef INTERP_SPEC
-            GLubyte specRed   = FixedToInt(fsr);
-            GLubyte specGreen = FixedToInt(fsg);
-            GLubyte specBlue  = FixedToInt(fsb);
-#endif
-#ifdef INTERP_INDEX
-            GLuint index = FixedToInt(fi) & 0xfffffff0;
-            GLuint coverage;
-#endif
-            GLdepth z = FixedToDepth(z0);
-            ASSERT(yBoti <= yTopi);
-
-            {
-#ifdef INTERP_STUV0
-               GLfloat invQ = 1.0F / hv0;
-               GLfloat s = hs0 * invQ;
-               GLfloat t = ht0 * invQ;
-               GLfloat u = hu0 * invQ;
-#endif
-#ifdef INTERP_STUV1
-               GLfloat invQ1 = 1.0F / hv01;
-               GLfloat s1 = hs01 * invQ1;
-               GLfloat t1 = ht01 * invQ1;
-               GLfloat u1 = hu01 * invQ1;
-#endif
-
-               /* bottom pixel of swipe */
-#ifdef INTERP_RGBA
-               coverage = (GLint) (alpha * (1.0F - (yBot - yBoti)));
-#endif
-#ifdef INTERP_INDEX
-               coverage = (GLuint) (15.0F * (1.0F - (yBot - yBoti)));
-#endif
-               PLOT(x, yBoti);
-               yBoti++;
-
-               /* top pixel of swipe */
-#ifdef INTERP_RGBA
-               coverage = (GLint) (alpha * (yTop - yTopi));
-#endif
-#ifdef INTERP_INDEX
-               coverage = (GLuint) (15.0F * (yTop - yTopi));
-#endif
-               PLOT(x, yTopi);
-               yTopi--;
-
-               /* pixels between top and bottom with 100% coverage */
-#ifdef INTERP_RGBA
-               coverage = alpha;
-#endif
-#ifdef INTERP_INDEX
-               coverage = 15;
-#endif
-               for (iy = yBoti; iy <= yTopi; iy++) {
-                  PLOT(x, iy);
-               }
-            }
-            PB_CHECK_FLUSH( ctx, pb );
-
-         } /* if stippling */
-
-         x += xStep;
-         y += yStep;
-         z0 += dz;
-#ifdef INTERP_RGBA
-         fr += dfr;
-         fg += dfg;
-         fb += dfb;
-         fa += dfa;
-#endif
-#ifdef INTERP_SPEC
-         fsr += dfsr;
-         fsg += dfsg;
-         fsb += dfsb;
-#endif
-#ifdef INTERP_STUV0
-         hs0 += dhs;
-         ht0 += dht;
-         hu0 += dhu;
-         hv0 += dhv;
-#endif
-#ifdef INTERP_STUV1
-         hs01 += dhs1;
-         ht01 += dht1;
-         hu01 += dhu1;
-         hv01 += dhv1;
-#endif
-#ifdef INTERP_INDEX
-         fi += dfi;
-#endif
-
-         if (!solid)
-            ctx->StippleCounter++;
-      }
-   }
-   else {
-      /*** Y-major line ***/
-      GLint i;
-      GLint y = y0;
-      GLfloat x = VB->Win.data[vert0][0];
-      const GLfloat invDy = 1.0F / dy;
-      GLfloat xStep = (VB->Win.data[vert1][0] - x) * invDy;
-      GLint dz = (GLint) ((z1 - z0) * invDy);
-#ifdef INTERP_RGBA
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         dfr = (IntToFixed(VB->ColorPtr->data[vert1][0]) - fr) * invDy;
-         dfg = (IntToFixed(VB->ColorPtr->data[vert1][1]) - fg) * invDy;
-         dfb = (IntToFixed(VB->ColorPtr->data[vert1][2]) - fb) * invDy;
-         dfa = (IntToFixed(VB->ColorPtr->data[vert1][3]) - fa) * invDy;
-      }
-#endif
-#ifdef INTERP_SPEC
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         dfsr = (IntToFixed(VB->Specular[vert1][0]) - fsr) * invDy;
-         dfsg = (IntToFixed(VB->Specular[vert1][1]) - fsg) * invDy;
-         dfsb = (IntToFixed(VB->Specular[vert1][2]) - fsb) * invDy;
-      }
-#endif
-#ifdef INTERP_STUV0
-      dhs *= invDy;
-      dht *= invDy;
-      dhu *= invDy;
-      dhv *= invDy;
-#endif
-#ifdef INTERP_STUV1
-      dhs1 *= invDy;
-      dht1 *= invDy;
-      dhu1 *= invDy;
-      dhv1 *= invDy;
-#endif
-#ifdef INTERP_INDEX
-      if (ctx->Light.ShadeModel == GL_SMOOTH) {
-         dfi = (IntToFixed(VB->IndexPtr->data[vert1]) - fi) * invDy;
-      }
-#endif
-      for (i = 0; i < dy; i++) {
-         if (solid || (ctx->Line.StipplePattern & (1 << ((ctx->StippleCounter/ctx->Line.StippleFactor) & 0xf)))) {
-            GLfloat xRight = x + halfWidth;
-            GLfloat xLeft = x - halfWidth;
-            GLint xRighti = (GLint) xRight;
-            GLint xLefti = (GLint) xLeft;
-            GLint ix;
-#ifdef INTERP_RGBA
-            GLubyte red   = FixedToInt(fr);
-            GLubyte green = FixedToInt(fg);
-            GLubyte blue  = FixedToInt(fb);
-            GLubyte alpha = FixedToInt(fa);
-            GLint coverage;
-#endif
-#ifdef INTERP_SPEC
-            GLubyte specRed   = FixedToInt(fsr);
-            GLubyte specGreen = FixedToInt(fsg);
-            GLubyte specBlue  = FixedToInt(fsb);
-#endif
-#ifdef INTERP_INDEX
-            GLuint index = FixedToInt(fi) & 0xfffffff0;
-            GLuint coverage;
-#endif
-            GLdepth z = FixedToDepth(z0);
-
-            ASSERT(xLefti < xRight);
-
-            {
-#ifdef INTERP_STUV0
-               GLfloat invQ = 1.0F / hv0;
-               GLfloat s = hs0 * invQ;
-               GLfloat t = ht0 * invQ;
-               GLfloat u = hu0 * invQ;
-#endif
-#ifdef INTERP_STUV1
-               GLfloat invQ1 = 1.0F / hv01;
-               GLfloat s1 = hs01 * invQ1;
-               GLfloat t1 = ht01 * invQ1;
-               GLfloat u1 = hu01 * invQ1;
-#endif
-
-               /* left pixel of swipe */
-#ifdef INTERP_RGBA
-               coverage = (GLint) (alpha * (1.0F - (xLeft - xLefti)));
-#endif
-#ifdef INTERP_INDEX
-               coverage = (GLuint) (15.0F * (1.0F - (xLeft - xLefti)));
-#endif
-               PLOT(xLefti, y);
-               xLefti++;
-
-               /* right pixel of swipe */
-#ifdef INTERP_RGBA
-               coverage = (GLint) (alpha * (xRight - xRighti));
-#endif
-#ifdef INTERP_INDEX
-               coverage = (GLuint) (15.0F * (xRight - xRighti));
-#endif
-               PLOT(xRighti, y)
-               xRighti--;
-
-               /* pixels between top and bottom with 100% coverage */
-#ifdef INTERP_RGBA
-               coverage = alpha;
-#endif
-#ifdef INTERP_INDEX
-               coverage = 15;
-#endif
-               for (ix = xLefti; ix <= xRighti; ix++) {
-                  PLOT(ix, y);
-               }
-            }
-            PB_CHECK_FLUSH( ctx, pb );
-         }
-
-         x += xStep;
-         y += yStep;
-         z0 += dz;
-#ifdef INTERP_RGBA
-         fr += dfr;
-         fg += dfg;
-         fb += dfb;
-         fa += dfa;
-#endif
-#ifdef INTERP_SPEC
-         fsr += dfsr;
-         fsg += dfsg;
-         fsb += dfsb;
-#endif
-#ifdef INTERP_STUV0
-         hs0 += dhs;
-         ht0 += dht;
-         hu0 += dhu;
-         hv0 += dhv;
-#endif
-#ifdef INTERP_STUV1
-         hs01 += dhs1;
-         ht01 += dht1;
-         hu01 += dhu1;
-         hv01 += dhv1;
-#endif
-#ifdef INTERP_INDEX
-         fi += dfi;
-#endif
-         if (!solid)
-            ctx->StippleCounter++;
-      }
-   }
-}
-
-#undef INTERP_RGBA
-#undef INTERP_SPEC
-#undef INTERP_STUV0
-#undef INTERP_STUV1
-#undef INTERP_INDEX
-#undef PLOT
Index: xc/extras/Mesa/src/logic.c
diff -u xc/extras/Mesa/src/logic.c:1.9 xc/extras/Mesa/src/logic.c:removed
--- xc/extras/Mesa/src/logic.c:1.9	Fri May 18 12:59:54 2001
+++ xc/extras/Mesa/src/logic.c	Thu Feb 27 12:15:40 2003
@@ -1,399 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4.1
- * 
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "alphabuf.h"
-#include "context.h"
-#include "logic.h"
-#include "macros.h"
-#include "pb.h"
-#include "span.h"
-#include "types.h"
-#endif
-
-
-
-void
-_mesa_LogicOp( GLenum opcode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glLogicOp");
-   switch (opcode) {
-      case GL_CLEAR:
-      case GL_SET:
-      case GL_COPY:
-      case GL_COPY_INVERTED:
-      case GL_NOOP:
-      case GL_INVERT:
-      case GL_AND:
-      case GL_NAND:
-      case GL_OR:
-      case GL_NOR:
-      case GL_XOR:
-      case GL_EQUIV:
-      case GL_AND_REVERSE:
-      case GL_AND_INVERTED:
-      case GL_OR_REVERSE:
-      case GL_OR_INVERTED:
-         ctx->Color.LogicOp = opcode;
-         ctx->NewState |= NEW_RASTER_OPS;
-	 break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glLogicOp" );
-	 return;
-   }
-   
-   if (ctx->Driver.LogicOpcode)
-      ctx->Driver.LogicOpcode( ctx, opcode );
-}
-
-
-
-/*
- * Apply logic op to array of CI pixels.
- */
-static void index_logicop( GLcontext *ctx, GLuint n,
-                           GLuint index[], const GLuint dest[],
-                           const GLubyte mask[] )
-{
-   GLuint i;
-   switch (ctx->Color.LogicOp) {
-      case GL_CLEAR:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_SET:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~0;
-	    }
-	 }
-	 break;
-      case GL_COPY:
-	 /* do nothing */
-	 break;
-      case GL_COPY_INVERTED:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~index[i];
-	    }
-	 }
-	 break;
-      case GL_NOOP:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = dest[i];
-	    }
-	 }
-	 break;
-      case GL_INVERT:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~dest[i];
-	    }
-	 }
-	 break;
-      case GL_AND:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] &= dest[i];
-	    }
-	 }
-	 break;
-      case GL_NAND:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~(index[i] & dest[i]);
-	    }
-	 }
-	 break;
-      case GL_OR:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] |= dest[i];
-	    }
-	 }
-	 break;
-      case GL_NOR:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~(index[i] | dest[i]);
-	    }
-	 }
-	 break;
-      case GL_XOR:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] ^= dest[i];
-	    }
-	 }
-	 break;
-      case GL_EQUIV:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~(index[i] ^ dest[i]);
-	    }
-	 }
-	 break;
-      case GL_AND_REVERSE:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = index[i] & ~dest[i];
-	    }
-	 }
-	 break;
-      case GL_AND_INVERTED:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~index[i] & dest[i];
-	    }
-	 }
-	 break;
-      case GL_OR_REVERSE:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = index[i] | ~dest[i];
-	    }
-	 }
-	 break;
-      case GL_OR_INVERTED:
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       index[i] = ~index[i] | dest[i];
-	    }
-	 }
-	 break;
-      default:
-	 gl_error( ctx, GL_INVALID_ENUM, "gl_logic error" );
-   }
-}
-
-
-
-/*
- * Apply the current logic operator to a span of CI pixels.  This is only
- * used if the device driver can't do logic ops.
- */
-void
-_mesa_logicop_ci_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                       GLuint index[], const GLubyte mask[] )
-{
-   GLuint dest[MAX_WIDTH];
-   /* Read dest values from frame buffer */
-   (*ctx->Driver.ReadCI32Span)( ctx, n, x, y, dest );
-   index_logicop( ctx, n, index, dest, mask );
-}
-
-
-
-/*
- * Apply the current logic operator to an array of CI pixels.  This is only
- * used if the device driver can't do logic ops.
- */
-void
-_mesa_logicop_ci_pixels( GLcontext *ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         GLuint index[], const GLubyte mask[] )
-{
-   GLuint dest[PB_SIZE];
-   /* Read dest values from frame buffer */
-   (*ctx->Driver.ReadCI32Pixels)( ctx, n, x, y, dest, mask );
-   index_logicop( ctx, n, index, dest, mask );
-}
-
-
-
-/*
- * Apply logic operator to rgba pixels.
- * Input:  ctx - the context
- *         n - number of pixels
- *         mask - pixel mask array
- * In/Out:  src - incoming pixels which will be modified
- * Input:  dest - frame buffer values
- *
- * Note:  Since the R, G, B, and A channels are all treated the same we
- * process them as 4-byte GLuints instead of four GLubytes.
- */
-static void rgba_logicop( const GLcontext *ctx, GLuint n,
-                          const GLubyte mask[],
-                          GLuint src[], const GLuint dest[] )
-{
-   GLuint i;
-   switch (ctx->Color.LogicOp) {
-      case GL_CLEAR:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = 0;
-            }
-         }
-         break;
-      case GL_SET:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~0;
-            }
-         }
-         break;
-      case GL_COPY:
-         /* do nothing */
-         break;
-      case GL_COPY_INVERTED:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~src[i];
-            }
-         }
-         break;
-      case GL_NOOP:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = dest[i];
-            }
-         }
-         break;
-      case GL_INVERT:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~dest[i];
-            }
-         }
-         break;
-      case GL_AND:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] &= dest[i];
-            }
-         }
-         break;
-      case GL_NAND:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~(src[i] & dest[i]);
-            }
-         }
-         break;
-      case GL_OR:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i]|= dest[i];
-            }
-         }
-         break;
-      case GL_NOR:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~(src[i] | dest[i]);
-            }
-         }
-         break;
-      case GL_XOR:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] ^= dest[i];
-            }
-         }
-         break;
-      case GL_EQUIV:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~(src[i] ^ dest[i]);
-            }
-         }
-         break;
-      case GL_AND_REVERSE:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = src[i] & ~dest[i];
-            }
-         }
-         break;
-      case GL_AND_INVERTED:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~src[i] & dest[i];
-            }
-         }
-         break;
-      case GL_OR_REVERSE:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = src[i] | ~dest[i];
-            }
-         }
-         break;
-      case GL_OR_INVERTED:
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               src[i] = ~src[i] | dest[i];
-            }
-         }
-         break;
-      default:
-         /* should never happen */
-         gl_problem(ctx, "Bad function in rgba_logicop");
-   }
-}
-
-
-
-/*
- * Apply the current logic operator to a span of RGBA pixels.
- * This is only used if the device driver can't do logic ops.
- */
-void
-_mesa_logicop_rgba_span( GLcontext *ctx,
-                         GLuint n, GLint x, GLint y,
-                         GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLubyte dest[MAX_WIDTH][4];
-   gl_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
-   rgba_logicop( ctx, n, mask, (GLuint *) rgba, (const GLuint *) dest );
-}
-
-
-
-/*
- * Apply the current logic operator to an array of RGBA pixels.
- * This is only used if the device driver can't do logic ops.
- */
-void
-_mesa_logicop_rgba_pixels( GLcontext *ctx,
-                           GLuint n, const GLint x[], const GLint y[],
-                           GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLubyte dest[PB_SIZE][4];
-   (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
-   if (ctx->RasterMask & ALPHABUF_BIT) {
-      _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
-   }
-   rgba_logicop( ctx, n, mask, (GLuint *) rgba, (const GLuint *) dest );
-}
Index: xc/extras/Mesa/src/logic.h
diff -u xc/extras/Mesa/src/logic.h:1.4 xc/extras/Mesa/src/logic.h:removed
--- xc/extras/Mesa/src/logic.h:1.4	Fri Jun 16 20:02:13 2000
+++ xc/extras/Mesa/src/logic.h	Thu Feb 27 12:15:40 2003
@@ -1,61 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef LOGIC_H
-#define LOGIC_H
-
-
-#include "types.h"
-
-
-extern void
-_mesa_LogicOp( GLenum opcode );
-
-
-extern void 
-_mesa_logicop_ci_span( GLcontext *ctx,
-                       GLuint n, GLint x, GLint y, GLuint index[],
-                       const GLubyte mask[] );
-
-
-extern void
-_mesa_logicop_ci_pixels( GLcontext *ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         GLuint index[], const GLubyte mask[] );
-
-
-extern void
-_mesa_logicop_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                         GLubyte rgba[][4], const GLubyte mask[] );
-
-
-extern void
-_mesa_logicop_rgba_pixels( GLcontext *ctx,
-                           GLuint n, const GLint x[], const GLint y[],
-                           GLubyte rgba[][4], const GLubyte mask[] );
-
-
-#endif
Index: xc/extras/Mesa/src/lowpc.c
diff -u xc/extras/Mesa/src/lowpc.c:1.3 xc/extras/Mesa/src/lowpc.c:1.4
--- xc/extras/Mesa/src/lowpc.c:1.3	Tue Feb 15 02:12:26 2000
+++ xc/extras/Mesa/src/lowpc.c	Fri Feb 22 14:25:35 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
Index: xc/extras/Mesa/src/macros.h
diff -u xc/extras/Mesa/src/macros.h:1.5 xc/extras/Mesa/src/macros.h:1.7
--- xc/extras/Mesa/src/macros.h:1.5	Fri Aug 17 14:40:04 2001
+++ xc/extras/Mesa/src/macros.h	Mon Sep  9 17:29:38 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.3
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -34,22 +34,8 @@
 
 
 #include "glheader.h"
-
-
-#ifdef DEBUG
-#  define ASSERT(X)   assert(X)
-#else
-#  define ASSERT(X)
-#endif
-
-
-#if defined(__GNUC__)
-#define INLINE __inline__
-#elif defined(__MSC__)
-#define INLINE __inline
-#else
-#define INLINE
-#endif
+/* Do not reference mtypes.h from this file.
+ */
 
 
 /* Limits: */
@@ -57,14 +43,6 @@
 #define MAX_GLUINT	0xffffffff
 
 
-/* Some compilers don't like some of Mesa's const usage */
-#ifdef NO_CONST
-#  define CONST
-#else
-#  define CONST const
-#endif
-
-
 /* Pi */
 #ifndef M_PI
 #define M_PI (3.1415926)
@@ -93,7 +71,10 @@
  */
 #define STRIDE_F(p, i)  (p = (GLfloat *)((GLubyte *)p + i))
 #define STRIDE_UI(p, i)  (p = (GLuint *)((GLubyte *)p + i))
-#define STRIDE_T(p, t, i)  (p = (t *)((GLubyte *)p + i))
+#define STRIDE_4UB(p, i)  (p = (GLubyte (*)[4])((GLubyte *)p + i))
+#define STRIDE_4CHAN(p, i)  (p = (GLchan (*)[4])((GLubyte *)p + i))
+#define STRIDE_CHAN(p, i)  (p = (GLchan *)((GLubyte *)p + i))
+#define STRIDE_T(p, t, i)  (p = (t)((GLubyte *)p + i))
 
 
 #define ZERO_2V( DST )	(DST)[0] = (DST)[1] = 0
@@ -101,6 +82,23 @@
 #define ZERO_4V( DST )	(DST)[0] = (DST)[1] = (DST)[2] = (DST)[3] = 0
 
 
+#define TEST_EQ_4V(a,b)  ((a)[0] == (b)[0] && 	\
+			  (a)[1] == (b)[1] &&	\
+			  (a)[2] == (b)[2] &&	\
+			  (a)[3] == (b)[3])
+
+#define TEST_EQ_3V(a,b)  ((a)[0] == (b)[0] && 	\
+			  (a)[1] == (b)[1] &&	\
+			  (a)[2] == (b)[2])
+
+#if defined(__i386__)
+#define TEST_EQ_4UBV(DST, SRC) *((GLuint*)(DST)) == *((GLuint*)(SRC))
+#else
+#define TEST_EQ_4UBV(DST, SRC) TEST_EQ_4V(DST, SRC)
+#endif
+
+
+
 /* Copy short vectors: */
 #define COPY_2V( DST, SRC )			\
 do {						\
@@ -108,7 +106,6 @@
    (DST)[1] = (SRC)[1];				\
 } while (0)
 
-
 #define COPY_3V( DST, SRC )			\
 do {						\
    (DST)[0] = (SRC)[0];				\
@@ -124,6 +121,21 @@
    (DST)[3] = (SRC)[3];				\
 } while (0)
 
+#if defined(__i386__)
+#define COPY_4UBV(DST, SRC)			\
+do {						\
+   *((GLuint*)(DST)) = *((GLuint*)(SRC));	\
+} while (0)
+#else
+/* The GLuint cast might fail if DST or SRC are not dword-aligned (RISC) */
+#define COPY_4UBV(DST, SRC)			\
+do {						\
+   (DST)[0] = (SRC)[0];				\
+   (DST)[1] = (SRC)[1];				\
+   (DST)[2] = (SRC)[2];				\
+   (DST)[3] = (SRC)[3];				\
+} while (0)
+#endif
 
 #define COPY_2FV( DST, SRC )			\
 do {						\
@@ -132,7 +144,6 @@
    (DST)[1] = _tmp[1];				\
 } while (0)
 
-
 #define COPY_3FV( DST, SRC )			\
 do {						\
    const GLfloat *_tmp = (SRC);			\
@@ -162,6 +173,12 @@
    }  						\
 } while(0)
 
+#define COPY_CLEAN_4V(DST, SZ, SRC) 		\
+do {						\
+      ASSIGN_4V( DST, 0, 0, 0, 1 );		\
+      COPY_SZ_4V( DST, SZ, SRC );		\
+} while (0)
+
 #define SUB_4V( DST, SRCA, SRCB )		\
 do {						\
       (DST)[0] = (SRCA)[0] - (SRCB)[0];		\
@@ -252,6 +269,13 @@
       (DST)[2] = (SRCA)[2] * (SRCB)[2];		\
 } while (0)
 
+#define SELF_SCALE_3V( DST, SRC )		\
+do {						\
+      (DST)[0] *= (SRC)[0];			\
+      (DST)[1] *= (SRC)[1];			\
+      (DST)[2] *= (SRC)[2];			\
+} while (0)
+
 #define ACC_3V( DST, SRC )			\
 do {						\
       (DST)[0] += (SRC)[0];			\
@@ -352,33 +376,19 @@
 
 
 
-/*
- * Copy a vector of 4 GLubytes from SRC to DST.
- */
-#if defined(__i386__)
-#define COPY_4UBV(DST, SRC)			\
-do {						\
-   *((GLuint*)(DST)) = *((GLuint*)(SRC));	\
-} while (0)
-#else
-/* The GLuint cast might fail if DST or SRC are not dword-aligned (RISC) */
-#define COPY_4UBV(DST, SRC)			\
-do {						\
-   (DST)[0] = (SRC)[0];				\
-   (DST)[1] = (SRC)[1];				\
-   (DST)[2] = (SRC)[2];				\
-   (DST)[3] = (SRC)[3];				\
-} while (0)
-#endif
-
-
-
 /* Assign scalers to short vectors: */
-#define ASSIGN_2V( V, V0, V1 )  \
-do { V[0] = V0;  V[1] = V1; } while(0)
+#define ASSIGN_2V( V, V0, V1 )	\
+do { 				\
+    V[0] = V0; 			\
+    V[1] = V1; 			\
+} while(0)
 
-#define ASSIGN_3V( V, V0, V1, V2 )  \
-do { V[0] = V0;  V[1] = V1;  V[2] = V2; } while(0)
+#define ASSIGN_3V( V, V0, V1, V2 )	\
+do { 				 	\
+    V[0] = V0; 				\
+    V[1] = V1; 				\
+    V[2] = V2; 				\
+} while(0)
 
 #define ASSIGN_4V( V, V0, V1, V2, V3 ) 		\
 do { 						\
@@ -418,7 +428,6 @@
 /* Min of two values: */
 #define MIN2( A, B )   ( (A)<(B) ? (A) : (B) )
 
-
 /* MAX of two values: */
 #define MAX2( A, B )   ( (A)>(B) ? (A) : (B) )
 
@@ -428,12 +437,11 @@
 /* Dot product of two 3-element vectors */
 #define DOT3( a, b )  ( (a)[0]*(b)[0] + (a)[1]*(b)[1] + (a)[2]*(b)[2] )
 
-
 /* Dot product of two 4-element vectors */
 #define DOT4( a, b )  ( (a)[0]*(b)[0] + (a)[1]*(b)[1] + \
 			(a)[2]*(b)[2] + (a)[3]*(b)[3] )
 
-#define DOT4V(v,a,b,c,d) (v[0]*a + v[1]*b + v[2]*c + v[3]*d)
+#define DOT4V(v,a,b,c,d) (v[0]*(a) + v[1]*(b) + v[2]*(c) + v[3]*(d))
 
 
 #define CROSS3(n, u, v) 			\
@@ -444,64 +452,9 @@
 } while (0)
 
 
-/*
- * Integer / float conversion for colors, normals, etc.
- */
-
-#define BYTE_TO_UBYTE(b)   (b < 0 ? 0 : (GLubyte) b)
-#define SHORT_TO_UBYTE(s)  (s < 0 ? 0 : (GLubyte) (s >> 7))
-#define USHORT_TO_UBYTE(s)              (GLubyte) (s >> 8)
-#define INT_TO_UBYTE(i)    (i < 0 ? 0 : (GLubyte) (i >> 23))
-#define UINT_TO_UBYTE(i)                (GLubyte) (i >> 24)
-
-/* Convert GLubyte in [0,255] to GLfloat in [0.0,1.0] */
-#define UBYTE_TO_FLOAT(B)	((GLfloat) (B) * (1.0F / 255.0F))
-
-/* Convert GLfloat in [0.0,1.0] to GLubyte in [0,255] */
-#define FLOAT_TO_UBYTE(X)	((GLubyte) (GLint) (((X)) * 255.0F))
-
-
-/* Convert GLbyte in [-128,127] to GLfloat in [-1.0,1.0] */
-#define BYTE_TO_FLOAT(B)	((2.0F * (B) + 1.0F) * (1.0F/255.0F))
-
-/* Convert GLfloat in [-1.0,1.0] to GLbyte in [-128,127] */
-#define FLOAT_TO_BYTE(X)	( (((GLint) (255.0F * (X))) - 1) / 2 )
-
-
-/* Convert GLushort in [0,65536] to GLfloat in [0.0,1.0] */
-#define USHORT_TO_FLOAT(S)	((GLfloat) (S) * (1.0F / 65535.0F))
-
-/* Convert GLfloat in [0.0,1.0] to GLushort in [0,65536] */
-#define FLOAT_TO_USHORT(X)	((GLushort) (GLint) ((X) * 65535.0F))
 
-
-/* Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0] */
-#define SHORT_TO_FLOAT(S)	((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
-
-/* Convert GLfloat in [0.0,1.0] to GLshort in [-32768,32767] */
-#define FLOAT_TO_SHORT(X)	( (((GLint) (65535.0F * (X))) - 1) / 2 )
-
-
-/* Convert GLuint in [0,4294967295] to GLfloat in [0.0,1.0] */
-#define UINT_TO_FLOAT(U)	((GLfloat) (U) * (1.0F / 4294967295.0F))
-
-/* Convert GLfloat in [0.0,1.0] to GLuint in [0,4294967295] */
-#define FLOAT_TO_UINT(X)	((GLuint) ((X) * 4294967295.0))
-
-
-/* Convert GLint in [-2147483648,2147483647] to GLfloat in [-1.0,1.0] */
-#define INT_TO_FLOAT(I)		((2.0F * (I) + 1.0F) * (1.0F/4294967294.0F))
-
-/* Convert GLfloat in [-1.0,1.0] to GLint in [-2147483648,2147483647] */
-/* causes overflow:
-#define FLOAT_TO_INT(X)		( (((GLint) (4294967294.0F * (X))) - 1) / 2 )
-*/
-/* a close approximation: */
-#define FLOAT_TO_INT(X)		( (GLint) (2147483647.0 * (X)) )
-
-
-
-/* Generic color packing macros
+/* Generic color packing macros.
+ * XXX We may move these into texutil.h at some point.
  */
 
 #define PACK_COLOR_8888( a, b, c, d )					\
@@ -526,5 +479,36 @@
 #define PACK_COLOR_332( a, b, c )					\
    (((a) & 0xe0) | (((b) & 0xe0) >> 3) | (((c) & 0xc0) >> 6))
 
+
+#ifdef MESA_BIG_ENDIAN
+
+#define PACK_COLOR_8888_LE( a, b, c, d )	PACK_COLOR_8888( d, c, b, a )
 
-#endif /*MACROS_H*/
+#define PACK_COLOR_565_LE( a, b, c )					\
+   (((a) & 0xf8) | (((b) & 0xe0) >> 5) | (((b) & 0x1c) << 11) |		\
+   (((c) & 0xf8) << 5))
+
+#define PACK_COLOR_1555_LE( a, b, c, d )				\
+   ((((b) & 0xf8) >> 1) | (((c) & 0xc0) >> 6) | (((c) & 0x38) << 10) |	\
+    (((d) & 0xf8) << 5) | ((a) ? 0x80 : 0))
+
+#define PACK_COLOR_4444_LE( a, b, c, d )	PACK_COLOR_4444( c, d, a, b )
+
+#define PACK_COLOR_88_LE( a, b )		PACK_COLOR_88( b, a )
+
+#else	/* little endian */
+
+#define PACK_COLOR_8888_LE( a, b, c, d )	PACK_COLOR_8888( a, b, c, d )
+
+#define PACK_COLOR_565_LE( a, b, c )		PACK_COLOR_565( a, b, c )
+
+#define PACK_COLOR_1555_LE( a, b, c, d )	PACK_COLOR_1555( a, b, c, d )
+
+#define PACK_COLOR_4444_LE( a, b, c, d )	PACK_COLOR_4444( a, b, c, d )
+
+#define PACK_COLOR_88_LE( a, b )		PACK_COLOR_88( a, b )
+
+#endif	/* endianness */
+
+
+#endif
Index: xc/extras/Mesa/src/masking.c
diff -u xc/extras/Mesa/src/masking.c:1.4 xc/extras/Mesa/src/masking.c:removed
--- xc/extras/Mesa/src/masking.c:1.4	Fri Jun 16 20:02:13 2000
+++ xc/extras/Mesa/src/masking.c	Thu Feb 27 12:15:40 2003
@@ -1,177 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Implement the effect of glColorMask and glIndexMask in software.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "alphabuf.h"
-#include "context.h"
-#include "enums.h"
-#include "macros.h"
-#include "masking.h"
-#include "pb.h"
-#include "span.h"
-#include "types.h"
-#endif
-
-
-
-void
-_mesa_IndexMask( GLuint mask )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glIndexMask");
-   ctx->Color.IndexMask = mask;
-   ctx->NewState |= NEW_RASTER_OPS;
-}
-
-
-
-void
-_mesa_ColorMask( GLboolean red, GLboolean green,
-                 GLboolean blue, GLboolean alpha )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glColorMask");
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glColorMask %d %d %d %d\n", red, green, blue, alpha);
-
-   ctx->Color.ColorMask[RCOMP] = red    ? 0xff : 0x0;
-   ctx->Color.ColorMask[GCOMP] = green  ? 0xff : 0x0;
-   ctx->Color.ColorMask[BCOMP] = blue   ? 0xff : 0x0;
-   ctx->Color.ColorMask[ACOMP] = alpha  ? 0xff : 0x0;
-
-   if (ctx->Driver.ColorMask) 
-      ctx->Driver.ColorMask( ctx, red, green, blue, alpha );
-
-   ctx->NewState |= NEW_RASTER_OPS;
-}
-
-
-
-
-/*
- * Apply glColorMask to a span of RGBA pixels.
- */
-void
-_mesa_mask_rgba_span( GLcontext *ctx,
-                      GLuint n, GLint x, GLint y, GLubyte rgba[][4] )
-{
-   GLubyte dest[MAX_WIDTH][4];
-   GLuint srcMask = *((GLuint*)ctx->Color.ColorMask);
-   GLuint dstMask = ~srcMask;
-   GLuint *rgba32 = (GLuint *) rgba;
-   GLuint *dest32 = (GLuint *) dest;
-   GLuint i;
-
-   gl_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
-
-   for (i=0; i<n; i++) {
-      rgba32[i] = (rgba32[i] & srcMask) | (dest32[i] & dstMask);
-   }
-}
-
-
-
-/*
- * Apply glColorMask to an array of RGBA pixels.
- */
-void
-_mesa_mask_rgba_pixels( GLcontext *ctx,
-                        GLuint n, const GLint x[], const GLint y[],
-                        GLubyte rgba[][4], const GLubyte mask[] )
-{
-   GLubyte dest[PB_SIZE][4];
-   GLuint srcMask = *((GLuint*)ctx->Color.ColorMask);
-   GLuint dstMask = ~srcMask;
-   GLuint *rgba32 = (GLuint *) rgba;
-   GLuint *dest32 = (GLuint *) dest;
-   GLuint i;
-
-   (*ctx->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
-   if (ctx->RasterMask & ALPHABUF_BIT) {
-      _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
-   }
-
-   for (i=0; i<n; i++) {
-      rgba32[i] = (rgba32[i] & srcMask) | (dest32[i] & dstMask);
-   }
-}
-
-
-
-/*
- * Apply glIndexMask to a span of CI pixels.
- */
-void
-_mesa_mask_index_span( GLcontext *ctx,
-                       GLuint n, GLint x, GLint y, GLuint index[] )
-{
-   GLuint i;
-   GLuint fbindexes[MAX_WIDTH];
-   GLuint msrc, mdest;
-
-   gl_read_index_span( ctx, ctx->DrawBuffer, n, x, y, fbindexes );
-
-   msrc = ctx->Color.IndexMask;
-   mdest = ~msrc;
-
-   for (i=0;i<n;i++) {
-      index[i] = (index[i] & msrc) | (fbindexes[i] & mdest);
-   }
-}
-
-
-
-/*
- * Apply glIndexMask to an array of CI pixels.
- */
-void
-_mesa_mask_index_pixels( GLcontext *ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         GLuint index[], const GLubyte mask[] )
-{
-   GLuint i;
-   GLuint fbindexes[PB_SIZE];
-   GLuint msrc, mdest;
-
-   (*ctx->Driver.ReadCI32Pixels)( ctx, n, x, y, fbindexes, mask );
-
-   msrc = ctx->Color.IndexMask;
-   mdest = ~msrc;
-
-   for (i=0;i<n;i++) {
-      index[i] = (index[i] & msrc) | (fbindexes[i] & mdest);
-   }
-}
-
Index: xc/extras/Mesa/src/masking.h
diff -u xc/extras/Mesa/src/masking.h:1.4 xc/extras/Mesa/src/masking.h:removed
--- xc/extras/Mesa/src/masking.h:1.4	Fri Jun 16 20:02:13 2000
+++ xc/extras/Mesa/src/masking.h	Thu Feb 27 12:15:40 2003
@@ -1,83 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef MASKING_H
-#define MASKING_H
-
-
-#include "types.h"
-
-
-
-extern void
-_mesa_IndexMask( GLuint mask );
-
-extern void
-_mesa_ColorMask( GLboolean red, GLboolean green,
-                 GLboolean blue, GLboolean alpha );
-
-
-/*
- * Implement glColorMask for a span of RGBA pixels.
- */
-extern void
-_mesa_mask_rgba_span( GLcontext *ctx,
-                      GLuint n, GLint x, GLint y,
-                      GLubyte rgba[][4] );
-
-
-
-/*
- * Implement glColorMask for an array of RGBA pixels.
- */
-extern void
-_mesa_mask_rgba_pixels( GLcontext *ctx,
-                        GLuint n, const GLint x[], const GLint y[],
-                        GLubyte rgba[][4], const GLubyte mask[] );
-
-
-
-/*
- * Implement glIndexMask for a span of CI pixels.
- */
-extern void
-_mesa_mask_index_span( GLcontext *ctx,
-                       GLuint n, GLint x, GLint y, GLuint index[] );
-
-
-
-/*
- * Implement glIndexMask for an array of CI pixels.
- */
-extern void
-_mesa_mask_index_pixels( GLcontext *ctx,
-                         GLuint n, const GLint x[], const GLint y[],
-                         GLuint index[], const GLubyte mask[] );
-
-
-
-#endif
-
Index: xc/extras/Mesa/src/matrix.c
diff -u xc/extras/Mesa/src/matrix.c:1.9 xc/extras/Mesa/src/matrix.c:1.11
--- xc/extras/Mesa/src/matrix.c:1.9	Tue Mar 20 22:02:18 2001
+++ xc/extras/Mesa/src/matrix.c	Mon Sep  9 17:29:38 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -27,12 +27,10 @@
 /*
  * Matrix operations
  *
- *
  * NOTES:
  * 1. 4x4 transformation matrices are stored in memory in column major order.
  * 2. Points/vertices are to be thought of as column vectors.
  * 3. Transformation of a point p by a matrix M is: p' = M * p
- *
  */
 
 
@@ -43,895 +41,43 @@
 #include "buffers.h"
 #include "context.h"
 #include "enums.h"
+#include "macros.h"
 #include "matrix.h"
 #include "mem.h"
 #include "mmath.h"
-#include "types.h"
-#endif
-
-
-static const char *types[] = {
-   "MATRIX_GENERAL",
-   "MATRIX_IDENTITY",
-   "MATRIX_3D_NO_ROT",
-   "MATRIX_PERSPECTIVE",
-   "MATRIX_2D",
-   "MATRIX_2D_NO_ROT",
-   "MATRIX_3D"
-};
-static void matmul4( GLfloat *product, const GLfloat *a, const GLfloat *b );
-
-
-static GLfloat Identity[16] = {
-   1.0, 0.0, 0.0, 0.0,
-   0.0, 1.0, 0.0, 0.0,
-   0.0, 0.0, 1.0, 0.0,
-   0.0, 0.0, 0.0, 1.0
-};
-
-
-static void print_matrix_floats( const GLfloat m[16] )
-{
-   int i;
-   for (i=0;i<4;i++) {
-      fprintf(stderr,"\t%f %f %f %f\n", m[i], m[4+i], m[8+i], m[12+i] );
-   }
-}
-
-void gl_print_matrix( const GLmatrix *m )
-{
-   fprintf(stderr, "Matrix type: %s, flags: %x\n", types[m->type], m->flags);
-   print_matrix_floats(m->m);
-#if 1
-   fprintf(stderr, "Inverse: \n");
-   if (m->inv) {
-      GLfloat prod[16];
-      print_matrix_floats(m->inv);
-      matmul4(prod, m->m, m->inv);
-      fprintf(stderr, "Mat * Inverse:\n");
-      print_matrix_floats(prod);
-  } else 
-      fprintf(stderr, "  - not available\n");
-#endif
-}
-
-
-
-/*
- * This matmul was contributed by Thomas Malik 
- *
- * Perform a 4x4 matrix multiplication  (product = a x b).
- * Input:  a, b - matrices to multiply
- * Output:  product - product of a and b
- * WARNING: (product != b) assumed
- * NOTE:    (product == a) allowed    
- *
- * KW: 4*16 = 64 muls
- */
-#define A(row,col)  a[(col<<2)+row]
-#define B(row,col)  b[(col<<2)+row]
-#define P(row,col)  product[(col<<2)+row]
-
-static void matmul4( GLfloat *product, const GLfloat *a, const GLfloat *b )
-{
-   GLint i;
-   for (i = 0; i < 4; i++) {
-      GLfloat ai0=A(i,0),  ai1=A(i,1),  ai2=A(i,2),  ai3=A(i,3);
-      P(i,0) = ai0 * B(0,0) + ai1 * B(1,0) + ai2 * B(2,0) + ai3 * B(3,0);
-      P(i,1) = ai0 * B(0,1) + ai1 * B(1,1) + ai2 * B(2,1) + ai3 * B(3,1);
-      P(i,2) = ai0 * B(0,2) + ai1 * B(1,2) + ai2 * B(2,2) + ai3 * B(3,2);
-      P(i,3) = ai0 * B(0,3) + ai1 * B(1,3) + ai2 * B(2,3) + ai3 * B(3,3);
-   }
-}
-
-
-
-
-/* Multiply two matrices known to occupy only the top three rows,
- * such as typical modelling matrices, and ortho matrices.
- *
- * KW: 3*9 = 27 muls
- */
-static void matmul34( GLfloat *product, const GLfloat *a, const GLfloat *b )
-{
-   GLint i;
-   for (i = 0; i < 3; i++) {
-      GLfloat ai0=A(i,0),  ai1=A(i,1),  ai2=A(i,2),  ai3=A(i,3);
-      P(i,0) = ai0 * B(0,0) + ai1 * B(1,0) + ai2 * B(2,0);
-      P(i,1) = ai0 * B(0,1) + ai1 * B(1,1) + ai2 * B(2,1);
-      P(i,2) = ai0 * B(0,2) + ai1 * B(1,2) + ai2 * B(2,2);
-      P(i,3) = ai0 * B(0,3) + ai1 * B(1,3) + ai2 * B(2,3) + ai3;
-   }
-   P(3,0) = 0;
-   P(3,1) = 0;
-   P(3,2) = 0;
-   P(3,3) = 1;
-}
-
-static void matmul4fd( GLfloat *product, const GLfloat *a, const GLdouble *b )
-{
-   GLint i;
-   for (i = 0; i < 4; i++) {
-      GLfloat ai0=A(i,0),  ai1=A(i,1),  ai2=A(i,2),  ai3=A(i,3);
-      P(i,0) = ai0 * B(0,0) + ai1 * B(1,0) + ai2 * B(2,0) + ai3 * B(3,0);
-      P(i,1) = ai0 * B(0,1) + ai1 * B(1,1) + ai2 * B(2,1) + ai3 * B(3,1);
-      P(i,2) = ai0 * B(0,2) + ai1 * B(1,2) + ai2 * B(2,2) + ai3 * B(3,2);
-      P(i,3) = ai0 * B(0,3) + ai1 * B(1,3) + ai2 * B(2,3) + ai3 * B(3,3);
-   }
-}
-
-#undef A
-#undef B
-#undef P
-
-
-
-#define SWAP_ROWS(a, b) { GLfloat *_tmp = a; (a)=(b); (b)=_tmp; }
-#define MAT(m,r,c) (m)[(c)*4+(r)]
-
-/*
- * Compute inverse of 4x4 transformation matrix.
- * Code contributed by Jacques Leroy jle@star.be
- * Return GL_TRUE for success, GL_FALSE for failure (singular matrix)
- */
-static GLboolean invert_matrix_general( GLmatrix *mat )
-{
-   const GLfloat *m = mat->m;
-   GLfloat *out = mat->inv;
-   GLfloat wtmp[4][8];
-   GLfloat m0, m1, m2, m3, s;
-   GLfloat *r0, *r1, *r2, *r3;
-  
-   r0 = wtmp[0], r1 = wtmp[1], r2 = wtmp[2], r3 = wtmp[3];
-  
-   r0[0] = MAT(m,0,0), r0[1] = MAT(m,0,1),
-   r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
-   r0[4] = 1.0, r0[5] = r0[6] = r0[7] = 0.0,
-  
-   r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
-   r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
-   r1[5] = 1.0, r1[4] = r1[6] = r1[7] = 0.0,
-  
-   r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
-   r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
-   r2[6] = 1.0, r2[4] = r2[5] = r2[7] = 0.0,
-  
-   r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
-   r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
-   r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
-  
-   /* choose pivot - or die */
-   if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
-   if (fabs(r2[0])>fabs(r1[0])) SWAP_ROWS(r2, r1);
-   if (fabs(r1[0])>fabs(r0[0])) SWAP_ROWS(r1, r0);
-   if (0.0 == r0[0])  return GL_FALSE;
-  
-   /* eliminate first variable     */
-   m1 = r1[0]/r0[0]; m2 = r2[0]/r0[0]; m3 = r3[0]/r0[0];
-   s = r0[1]; r1[1] -= m1 * s; r2[1] -= m2 * s; r3[1] -= m3 * s;
-   s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
-   s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
-   s = r0[4];
-   if (s != 0.0) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
-   s = r0[5];
-   if (s != 0.0) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
-   s = r0[6];
-   if (s != 0.0) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
-   s = r0[7];
-   if (s != 0.0) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
-  
-   /* choose pivot - or die */
-   if (fabs(r3[1])>fabs(r2[1])) SWAP_ROWS(r3, r2);
-   if (fabs(r2[1])>fabs(r1[1])) SWAP_ROWS(r2, r1);
-   if (0.0 == r1[1])  return GL_FALSE;
-  
-   /* eliminate second variable */
-   m2 = r2[1]/r1[1]; m3 = r3[1]/r1[1];
-   r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
-   r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
-   s = r1[4]; if (0.0 != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
-   s = r1[5]; if (0.0 != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
-   s = r1[6]; if (0.0 != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
-   s = r1[7]; if (0.0 != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
-  
-   /* choose pivot - or die */
-   if (fabs(r3[2])>fabs(r2[2])) SWAP_ROWS(r3, r2);
-   if (0.0 == r2[2])  return GL_FALSE;
-  
-   /* eliminate third variable */
-   m3 = r3[2]/r2[2];
-   r3[3] -= m3 * r2[3], r3[4] -= m3 * r2[4],
-   r3[5] -= m3 * r2[5], r3[6] -= m3 * r2[6],
-   r3[7] -= m3 * r2[7];
-  
-   /* last check */
-   if (0.0 == r3[3]) return GL_FALSE;
-  
-   s = 1.0/r3[3];              /* now back substitute row 3 */
-   r3[4] *= s; r3[5] *= s; r3[6] *= s; r3[7] *= s;
-  
-   m2 = r2[3];                 /* now back substitute row 2 */
-   s  = 1.0/r2[2];
-   r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
-   r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
-   m1 = r1[3];
-   r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1,
-   r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
-   m0 = r0[3];
-   r0[4] -= r3[4] * m0, r0[5] -= r3[5] * m0,
-   r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
-  
-   m1 = r1[2];                 /* now back substitute row 1 */
-   s  = 1.0/r1[1];
-   r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
-   r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
-   m0 = r0[2];
-   r0[4] -= r2[4] * m0, r0[5] -= r2[5] * m0,
-   r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
-  
-   m0 = r0[1];                 /* now back substitute row 0 */
-   s  = 1.0/r0[0];
-   r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
-   r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
-  
-   MAT(out,0,0) = r0[4]; MAT(out,0,1) = r0[5],
-   MAT(out,0,2) = r0[6]; MAT(out,0,3) = r0[7],
-   MAT(out,1,0) = r1[4]; MAT(out,1,1) = r1[5],
-   MAT(out,1,2) = r1[6]; MAT(out,1,3) = r1[7],
-   MAT(out,2,0) = r2[4]; MAT(out,2,1) = r2[5],
-   MAT(out,2,2) = r2[6]; MAT(out,2,3) = r2[7],
-   MAT(out,3,0) = r3[4]; MAT(out,3,1) = r3[5],
-   MAT(out,3,2) = r3[6]; MAT(out,3,3) = r3[7]; 
-  
-   return GL_TRUE;
-}
-#undef SWAP_ROWS
-
-/* Adapted from graphics gems II.
- */  
-static GLboolean invert_matrix_3d_general( GLmatrix *mat )
-{
-   const GLfloat *in = mat->m;
-   GLfloat *out = mat->inv;
-   GLfloat pos, neg, t;
-   GLfloat det;
-
-   /* Calculate the determinant of upper left 3x3 submatrix and
-    * determine if the matrix is singular. 
-    */
-   pos = neg = 0.0;
-   t =  MAT(in,0,0) * MAT(in,1,1) * MAT(in,2,2);
-   if (t >= 0.0) pos += t; else neg += t;
-
-   t =  MAT(in,1,0) * MAT(in,2,1) * MAT(in,0,2);
-   if (t >= 0.0) pos += t; else neg += t;
-
-   t =  MAT(in,2,0) * MAT(in,0,1) * MAT(in,1,2);
-   if (t >= 0.0) pos += t; else neg += t;
-
-   t = -MAT(in,2,0) * MAT(in,1,1) * MAT(in,0,2);
-   if (t >= 0.0) pos += t; else neg += t;
-
-   t = -MAT(in,1,0) * MAT(in,0,1) * MAT(in,2,2);
-   if (t >= 0.0) pos += t; else neg += t;
-
-   t = -MAT(in,0,0) * MAT(in,2,1) * MAT(in,1,2);
-   if (t >= 0.0) pos += t; else neg += t;
-
-   det = pos + neg;
-
-   if (det*det < 1e-25) 
-      return GL_FALSE;
-   
-   det = 1.0 / det;
-   MAT(out,0,0) = (  (MAT(in,1,1)*MAT(in,2,2) - MAT(in,2,1)*MAT(in,1,2) )*det);
-   MAT(out,0,1) = (- (MAT(in,0,1)*MAT(in,2,2) - MAT(in,2,1)*MAT(in,0,2) )*det);
-   MAT(out,0,2) = (  (MAT(in,0,1)*MAT(in,1,2) - MAT(in,1,1)*MAT(in,0,2) )*det);
-   MAT(out,1,0) = (- (MAT(in,1,0)*MAT(in,2,2) - MAT(in,2,0)*MAT(in,1,2) )*det);
-   MAT(out,1,1) = (  (MAT(in,0,0)*MAT(in,2,2) - MAT(in,2,0)*MAT(in,0,2) )*det);
-   MAT(out,1,2) = (- (MAT(in,0,0)*MAT(in,1,2) - MAT(in,1,0)*MAT(in,0,2) )*det);
-   MAT(out,2,0) = (  (MAT(in,1,0)*MAT(in,2,1) - MAT(in,2,0)*MAT(in,1,1) )*det);
-   MAT(out,2,1) = (- (MAT(in,0,0)*MAT(in,2,1) - MAT(in,2,0)*MAT(in,0,1) )*det);
-   MAT(out,2,2) = (  (MAT(in,0,0)*MAT(in,1,1) - MAT(in,1,0)*MAT(in,0,1) )*det);
-
-   /* Do the translation part */
-   MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0) +
-		     MAT(in,1,3) * MAT(out,0,1) +
-		     MAT(in,2,3) * MAT(out,0,2) );
-   MAT(out,1,3) = - (MAT(in,0,3) * MAT(out,1,0) +
-		     MAT(in,1,3) * MAT(out,1,1) +
-		     MAT(in,2,3) * MAT(out,1,2) );
-   MAT(out,2,3) = - (MAT(in,0,3) * MAT(out,2,0) +
-		     MAT(in,1,3) * MAT(out,2,1) +
-		     MAT(in,2,3) * MAT(out,2,2) );
-    
-   return GL_TRUE;
-}
-
-
-static GLboolean invert_matrix_3d( GLmatrix *mat )
-{
-   const GLfloat *in = mat->m;
-   GLfloat *out = mat->inv;
-
-   if (!TEST_MAT_FLAGS(mat, MAT_FLAGS_ANGLE_PRESERVING))
-   {
-      return invert_matrix_3d_general( mat );
-   }
-   
-   if (mat->flags & MAT_FLAG_UNIFORM_SCALE)
-   {
-      GLfloat  scale = (MAT(in,0,0) * MAT(in,0,0) +
-			MAT(in,0,1) * MAT(in,0,1) +
-			MAT(in,0,2) * MAT(in,0,2));
-
-      if (scale == 0.0) 
-         return GL_FALSE;
-
-      scale = 1.0 / scale;
-
-      /* Transpose and scale the 3 by 3 upper-left submatrix. */
-      MAT(out,0,0) = scale * MAT(in,0,0);
-      MAT(out,1,0) = scale * MAT(in,0,1);
-      MAT(out,2,0) = scale * MAT(in,0,2);
-      MAT(out,0,1) = scale * MAT(in,1,0);
-      MAT(out,1,1) = scale * MAT(in,1,1);
-      MAT(out,2,1) = scale * MAT(in,1,2);
-      MAT(out,0,2) = scale * MAT(in,2,0);
-      MAT(out,1,2) = scale * MAT(in,2,1);
-      MAT(out,2,2) = scale * MAT(in,2,2);
-   }
-   else if (mat->flags & MAT_FLAG_ROTATION)
-   {
-      /* Transpose the 3 by 3 upper-left submatrix. */
-      MAT(out,0,0) = MAT(in,0,0);
-      MAT(out,1,0) = MAT(in,0,1);
-      MAT(out,2,0) = MAT(in,0,2);
-      MAT(out,0,1) = MAT(in,1,0);
-      MAT(out,1,1) = MAT(in,1,1);
-      MAT(out,2,1) = MAT(in,1,2);
-      MAT(out,0,2) = MAT(in,2,0);
-      MAT(out,1,2) = MAT(in,2,1);
-      MAT(out,2,2) = MAT(in,2,2);
-   }
-   else /* pure translation */
-   {
-      MEMCPY( out, Identity, sizeof(Identity) );
-      MAT(out,0,3) = - MAT(in,0,3);
-      MAT(out,1,3) = - MAT(in,1,3);
-      MAT(out,2,3) = - MAT(in,2,3);
-      return GL_TRUE;
-   }
-    
-   if (mat->flags & MAT_FLAG_TRANSLATION)
-   {
-      /* Do the translation part */
-      MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0) +
-			MAT(in,1,3) * MAT(out,0,1) +
-			MAT(in,2,3) * MAT(out,0,2) );
-      MAT(out,1,3) = - (MAT(in,0,3) * MAT(out,1,0) +
-			MAT(in,1,3) * MAT(out,1,1) +
-			MAT(in,2,3) * MAT(out,1,2) );
-      MAT(out,2,3) = - (MAT(in,0,3) * MAT(out,2,0) +
-			MAT(in,1,3) * MAT(out,2,1) +
-			MAT(in,2,3) * MAT(out,2,2) );
-   }
-   else 
-   {
-      MAT(out,0,3) = MAT(out,1,3) = MAT(out,2,3) = 0.0;
-   }
-    
-   return GL_TRUE;
-}
-
-  
+#include "mtypes.h"
 
-static GLboolean invert_matrix_identity( GLmatrix *mat )
-{
-   MEMCPY( mat->inv, Identity, sizeof(Identity) );
-   return GL_TRUE;
-}
-
-
-static GLboolean invert_matrix_3d_no_rot( GLmatrix *mat )
-{
-   const GLfloat *in = mat->m;
-   GLfloat *out = mat->inv;
-
-   if (MAT(in,0,0) == 0 || MAT(in,1,1) == 0 || MAT(in,2,2) == 0 )       
-      return GL_FALSE;
-  
-   MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
-   MAT(out,0,0) = 1.0 / MAT(in,0,0);
-   MAT(out,1,1) = 1.0 / MAT(in,1,1);
-   MAT(out,2,2) = 1.0 / MAT(in,2,2);
-
-   if (mat->flags & MAT_FLAG_TRANSLATION)
-   {
-      MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0));
-      MAT(out,1,3) = - (MAT(in,1,3) * MAT(out,1,1));
-      MAT(out,2,3) = - (MAT(in,2,3) * MAT(out,2,2));
-   }
-
-   return GL_TRUE;
-}
-
-
-static GLboolean invert_matrix_2d_no_rot( GLmatrix *mat )
-{
-   const GLfloat *in = mat->m;
-   GLfloat *out = mat->inv;
-
-   if (MAT(in,0,0) == 0 || MAT(in,1,1) == 0)       
-      return GL_FALSE;
-  
-   MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
-   MAT(out,0,0) = 1.0 / MAT(in,0,0);
-   MAT(out,1,1) = 1.0 / MAT(in,1,1);
-
-   if (mat->flags & MAT_FLAG_TRANSLATION)
-   {
-      MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0));
-      MAT(out,1,3) = - (MAT(in,1,3) * MAT(out,1,1));
-   }
-
-   return GL_TRUE;
-}
-
-
-static GLboolean invert_matrix_perspective( GLmatrix *mat )
-{
-   const GLfloat *in = mat->m;
-   GLfloat *out = mat->inv;
-
-   if (MAT(in,2,3) == 0)
-      return GL_FALSE;
-
-   MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
-
-   MAT(out,0,0) = 1.0 / MAT(in,0,0);
-   MAT(out,1,1) = 1.0 / MAT(in,1,1);
-
-   MAT(out,0,3) = MAT(in,0,2);
-   MAT(out,1,3) = MAT(in,1,2);
-
-   MAT(out,2,2) = 0;
-   MAT(out,2,3) = -1;
-
-   MAT(out,3,2) = 1.0 / MAT(in,2,3);
-   MAT(out,3,3) = MAT(in,2,2) * MAT(out,3,2);
-
-   return GL_TRUE;
-}
-
-
-typedef GLboolean (*inv_mat_func)( GLmatrix *mat );
-
-static inv_mat_func inv_mat_tab[7] = {
-   invert_matrix_general,
-   invert_matrix_identity,
-   invert_matrix_3d_no_rot,
-   invert_matrix_perspective,
-   invert_matrix_3d,		/* lazy! */
-   invert_matrix_2d_no_rot,
-   invert_matrix_3d
-};
-
-
-GLboolean gl_matrix_invert( GLmatrix *mat )
-{
-   if (inv_mat_tab[mat->type](mat)) {
-#if 0
-      GLmatrix m; m.inv = 0; m.type = 0; m.flags = 0;
-      matmul4( m.m, mat->m, mat->inv );
-      printf("inverted matrix of type %s:\n", types[mat->type]);
-      gl_print_matrix( mat );
-      gl_print_matrix( &m );
+#include "math/m_matrix.h"
 #endif
-      return GL_TRUE;
-   } else {
-      MEMCPY( mat->inv, Identity, sizeof(Identity) );
-      return GL_FALSE;
-   }  
-}
-
-
-
-void gl_matrix_transposef( GLfloat to[16], const GLfloat from[16] )
-{
-   to[0] = from[0];
-   to[1] = from[4];
-   to[2] = from[8];
-   to[3] = from[12];
-   to[4] = from[1];
-   to[5] = from[5];
-   to[6] = from[9];
-   to[7] = from[13];
-   to[8] = from[2];
-   to[9] = from[6];
-   to[10] = from[10];
-   to[11] = from[14];
-   to[12] = from[3];
-   to[13] = from[7];
-   to[14] = from[11];
-   to[15] = from[15];
-}
-
-
-
-void gl_matrix_transposed( GLdouble to[16], const GLdouble from[16] )
-{
-   to[0] = from[0];
-   to[1] = from[4];
-   to[2] = from[8];
-   to[3] = from[12];
-   to[4] = from[1];
-   to[5] = from[5];
-   to[6] = from[9];
-   to[7] = from[13];
-   to[8] = from[2];
-   to[9] = from[6];
-   to[10] = from[10];
-   to[11] = from[14];
-   to[12] = from[3];
-   to[13] = from[7];
-   to[14] = from[11];
-   to[15] = from[15];
-}
-
 
 
-/*
- * Generate a 4x4 transformation matrix from glRotate parameters.
- */
-void gl_rotation_matrix( GLfloat angle, GLfloat x, GLfloat y, GLfloat z,
-                         GLfloat m[] )
-{
-   /* This function contributed by Erich Boleyn (erich@uruk.org) */
-   GLfloat mag, s, c;
-   GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
+/**********************************************************************/
+/*                        API functions                               */
+/**********************************************************************/
 
-   s = sin( angle * DEG2RAD );
-   c = cos( angle * DEG2RAD );
-
-   mag = GL_SQRT( x*x + y*y + z*z );
-
-   if (mag <= 1.0e-4) {
-      /* generate an identity matrix and return */
-      MEMCPY(m, Identity, sizeof(GLfloat)*16);
-      return;
-   }
-
-   x /= mag;
-   y /= mag;
-   z /= mag;
-
-#define M(row,col)  m[col*4+row]
-
-   /*
-    *     Arbitrary axis rotation matrix.
-    *
-    *  This is composed of 5 matrices, Rz, Ry, T, Ry', Rz', multiplied
-    *  like so:  Rz * Ry * T * Ry' * Rz'.  T is the final rotation
-    *  (which is about the X-axis), and the two composite transforms
-    *  Ry' * Rz' and Rz * Ry are (respectively) the rotations necessary
-    *  from the arbitrary axis to the X-axis then back.  They are
-    *  all elementary rotations.
-    *
-    *  Rz' is a rotation about the Z-axis, to bring the axis vector
-    *  into the x-z plane.  Then Ry' is applied, rotating about the
-    *  Y-axis to bring the axis vector parallel with the X-axis.  The
-    *  rotation about the X-axis is then performed.  Ry and Rz are
-    *  simply the respective inverse transforms to bring the arbitrary
-    *  axis back to it's original orientation.  The first transforms
-    *  Rz' and Ry' are considered inverses, since the data from the
-    *  arbitrary axis gives you info on how to get to it, not how
-    *  to get away from it, and an inverse must be applied.
-    *
-    *  The basic calculation used is to recognize that the arbitrary
-    *  axis vector (x, y, z), since it is of unit length, actually
-    *  represents the sines and cosines of the angles to rotate the
-    *  X-axis to the same orientation, with theta being the angle about
-    *  Z and phi the angle about Y (in the order described above)
-    *  as follows:
-    *
-    *  cos ( theta ) = x / sqrt ( 1 - z^2 )
-    *  sin ( theta ) = y / sqrt ( 1 - z^2 )
-    *
-    *  cos ( phi ) = sqrt ( 1 - z^2 )
-    *  sin ( phi ) = z
-    *
-    *  Note that cos ( phi ) can further be inserted to the above
-    *  formulas:
-    *
-    *  cos ( theta ) = x / cos ( phi )
-    *  sin ( theta ) = y / sin ( phi )
-    *
-    *  ...etc.  Because of those relations and the standard trigonometric
-    *  relations, it is pssible to reduce the transforms down to what
-    *  is used below.  It may be that any primary axis chosen will give the
-    *  same results (modulo a sign convention) using thie method.
-    *
-    *  Particularly nice is to notice that all divisions that might
-    *  have caused trouble when parallel to certain planes or
-    *  axis go away with care paid to reducing the expressions.
-    *  After checking, it does perform correctly under all cases, since
-    *  in all the cases of division where the denominator would have
-    *  been zero, the numerator would have been zero as well, giving
-    *  the expected result.
-    */
-
-   xx = x * x;
-   yy = y * y;
-   zz = z * z;
-   xy = x * y;
-   yz = y * z;
-   zx = z * x;
-   xs = x * s;
-   ys = y * s;
-   zs = z * s;
-   one_c = 1.0F - c;
-
-   M(0,0) = (one_c * xx) + c;
-   M(0,1) = (one_c * xy) - zs;
-   M(0,2) = (one_c * zx) + ys;
-   M(0,3) = 0.0F;
-
-   M(1,0) = (one_c * xy) + zs;
-   M(1,1) = (one_c * yy) + c;
-   M(1,2) = (one_c * yz) - xs;
-   M(1,3) = 0.0F;
-
-   M(2,0) = (one_c * zx) - ys;
-   M(2,1) = (one_c * yz) + xs;
-   M(2,2) = (one_c * zz) + c;
-   M(2,3) = 0.0F;
-
-   M(3,0) = 0.0F;
-   M(3,1) = 0.0F;
-   M(3,2) = 0.0F;
-   M(3,3) = 1.0F;
-
-#undef M
-}
-
-#define ZERO(x) (1<<x)
-#define ONE(x)  (1<<(x+16))
-
-#define MASK_NO_TRX      (ZERO(12) | ZERO(13) | ZERO(14))
-#define MASK_NO_2D_SCALE ( ONE(0)  | ONE(5))
-
-#define MASK_IDENTITY    ( ONE(0)  | ZERO(4)  | ZERO(8)  | ZERO(12) |\
-			  ZERO(1)  |  ONE(5)  | ZERO(9)  | ZERO(13) |\
-			  ZERO(2)  | ZERO(6)  |  ONE(10) | ZERO(14) |\
-			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
-
-#define MASK_2D_NO_ROT   (           ZERO(4)  | ZERO(8)  |           \
-			  ZERO(1)  |            ZERO(9)  |           \
-			  ZERO(2)  | ZERO(6)  |  ONE(10) | ZERO(14) |\
-			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
-
-#define MASK_2D          (                      ZERO(8)  |           \
-			                        ZERO(9)  |           \
-			  ZERO(2)  | ZERO(6)  |  ONE(10) | ZERO(14) |\
-			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
-
-
-#define MASK_3D_NO_ROT   (           ZERO(4)  | ZERO(8)  |           \
-			  ZERO(1)  |            ZERO(9)  |           \
-			  ZERO(2)  | ZERO(6)  |                      \
-			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
-
-#define MASK_3D          (                                           \
-			                                             \
-			                                             \
-			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
-
-
-#define MASK_PERSPECTIVE (           ZERO(4)  |            ZERO(12) |\
-			  ZERO(1)  |                       ZERO(13) |\
-			  ZERO(2)  | ZERO(6)  |                      \
-			  ZERO(3)  | ZERO(7)  |            ZERO(15) )
-
-#define SQ(x) ((x)*(x))
-  
-/* Determine type and flags from scratch.  This is expensive enough to
- * only want to do it once.
- */
-static void analyze_from_scratch( GLmatrix *mat )
-{
-   const GLfloat *m = mat->m;
-   GLuint mask = 0;
-   GLuint i;
 
-   for (i = 0 ; i < 16 ; i++) 
-   {
-      if (m[i] == 0.0) mask |= (1<<i);
-   }
-   
-   if (m[0] == 1.0F) mask |= (1<<16);
-   if (m[5] == 1.0F) mask |= (1<<21);
-   if (m[10] == 1.0F) mask |= (1<<26);
-   if (m[15] == 1.0F) mask |= (1<<31);
-
-   mat->flags &= ~MAT_FLAGS_GEOMETRY;
-
-   /* Check for translation - no-one really cares 
-    */
-   if ((mask & MASK_NO_TRX) != MASK_NO_TRX) 
-      mat->flags |= MAT_FLAG_TRANSLATION;      
-
-   /* Do the real work
-    */
-   if (mask == (GLuint) MASK_IDENTITY) {
-      mat->type = MATRIX_IDENTITY;
-   }
-   else if ((mask & MASK_2D_NO_ROT) == (GLuint) MASK_2D_NO_ROT) {
-      mat->type = MATRIX_2D_NO_ROT;
-      
-      if ((mask & MASK_NO_2D_SCALE) != MASK_NO_2D_SCALE)
-	 mat->flags = MAT_FLAG_GENERAL_SCALE;
-   }
-   else if ((mask & MASK_2D) == (GLuint) MASK_2D) {
-      GLfloat mm = DOT2(m, m);
-      GLfloat m4m4 = DOT2(m+4,m+4);
-      GLfloat mm4 = DOT2(m,m+4);
-
-      mat->type = MATRIX_2D;
-
-      /* Check for scale */
-      if (SQ(mm-1) > SQ(1e-6) ||
-	  SQ(m4m4-1) > SQ(1e-6)) 
-	 mat->flags |= MAT_FLAG_GENERAL_SCALE;
-
-      /* Check for rotation */
-      if (SQ(mm4) > SQ(1e-6))
-	 mat->flags |= MAT_FLAG_GENERAL_3D;
-      else
-	 mat->flags |= MAT_FLAG_ROTATION;
-
-   }
-   else if ((mask & MASK_3D_NO_ROT) == (GLuint) MASK_3D_NO_ROT) {
-      mat->type = MATRIX_3D_NO_ROT;
-
-      /* Check for scale */
-      if (SQ(m[0]-m[5]) < SQ(1e-6) && 
-	  SQ(m[0]-m[10]) < SQ(1e-6)) {
-	 if (SQ(m[0]-1.0) > SQ(1e-6))
-	    mat->flags |= MAT_FLAG_UNIFORM_SCALE;
-      } else
-	 mat->flags |= MAT_FLAG_GENERAL_SCALE;
-   }
-   else if ((mask & MASK_3D) == (GLuint) MASK_3D) {
-      GLfloat c1 = DOT3(m,m);
-      GLfloat c2 = DOT3(m+4,m+4);
-      GLfloat c3 = DOT3(m+8,m+8);
-      GLfloat d1 = DOT3(m, m+4);
-      GLfloat cp[3];
-
-      mat->type = MATRIX_3D;
-
-      /* Check for scale */
-      if (SQ(c1-c2) < SQ(1e-6) && SQ(c1-c3) < SQ(1e-6)) {
-	 if (SQ(c1-1.0) > SQ(1e-6))
-	    mat->flags |= MAT_FLAG_UNIFORM_SCALE;
-	 /* else no scale at all */
-      } else 
-	 mat->flags |= MAT_FLAG_GENERAL_SCALE;
-
-      /* Check for rotation */
-      if (SQ(d1) < SQ(1e-6)) {
-	 CROSS3( cp, m, m+4 );
-	 SUB_3V( cp, cp, (m+8) );
-	 if (LEN_SQUARED_3FV(cp) < SQ(1e-6)) 
-	    mat->flags |= MAT_FLAG_ROTATION;
-	 else
-	    mat->flags |= MAT_FLAG_GENERAL_3D;
-      }
-      else
-	 mat->flags |= MAT_FLAG_GENERAL_3D; /* shear, etc */
-   }
-   else if ((mask & MASK_PERSPECTIVE) == MASK_PERSPECTIVE && m[11]==-1.0F) 
-   {
-      mat->type = MATRIX_PERSPECTIVE;
-      mat->flags |= MAT_FLAG_GENERAL;
-   }
-   else {
-      mat->type = MATRIX_GENERAL;
-      mat->flags |= MAT_FLAG_GENERAL;
-   }
-}
-
-
-/* Analyse a matrix given that its flags are accurate - this is the
- * more common operation, hopefully. 
- */
-static void analyze_from_flags( GLmatrix *mat )
-{
-   const GLfloat *m = mat->m;
-
-   if (TEST_MAT_FLAGS(mat, 0)) {
-      mat->type = MATRIX_IDENTITY;
-   }
-   else if (TEST_MAT_FLAGS(mat, (MAT_FLAG_TRANSLATION |
-				 MAT_FLAG_UNIFORM_SCALE |
-				 MAT_FLAG_GENERAL_SCALE)))
-   {
-      if ( m[10]==1.0F && m[14]==0.0F ) {
-	 mat->type = MATRIX_2D_NO_ROT;
-      }
-      else {
-	 mat->type = MATRIX_3D_NO_ROT;
-      }
-   }
-   else if (TEST_MAT_FLAGS(mat, MAT_FLAGS_3D)) {
-      if (                                 m[ 8]==0.0F               
-            &&                             m[ 9]==0.0F
-            && m[2]==0.0F && m[6]==0.0F && m[10]==1.0F && m[14]==0.0F)
-      {
-	 mat->type = MATRIX_2D;
-      }
-      else 
-      {
-	 mat->type = MATRIX_3D;
-      }
-   }
-   else if (                 m[4]==0.0F                 && m[12]==0.0F
-            && m[1]==0.0F                               && m[13]==0.0F
-            && m[2]==0.0F && m[6]==0.0F
-            && m[3]==0.0F && m[7]==0.0F && m[11]==-1.0F && m[15]==0.0F) 
-   {
-      mat->type = MATRIX_PERSPECTIVE;
-   }
-   else {
-      mat->type = MATRIX_GENERAL;
-   }
-
-}
-
-
-void gl_matrix_analyze( GLmatrix *mat ) 
-{
-   if (mat->flags & MAT_DIRTY_TYPE) {
-      if (mat->flags & MAT_DIRTY_FLAGS) 
-	 analyze_from_scratch( mat );
-      else
-	 analyze_from_flags( mat );
-   }
-
-   if (mat->inv && (mat->flags & MAT_DIRTY_INVERSE)) {
-      gl_matrix_invert( mat );
-   }
-
-   mat->flags &= ~(MAT_DIRTY_FLAGS|
-		   MAT_DIRTY_TYPE|
-		   MAT_DIRTY_INVERSE);
-}
-
-
-#define GET_ACTIVE_MATRIX(ctx, mat, flags, where)			\
+#define GET_ACTIVE_MATRIX(ctx, mat, flags, where)		\
 do {									\
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, where);                      \
-   if (MESA_VERBOSE&VERBOSE_API) fprintf(stderr, "%s\n", where);        \
+   if (MESA_VERBOSE&VERBOSE_API) fprintf(stderr, "%s\n", where);	\
    switch (ctx->Transform.MatrixMode) {					\
       case GL_MODELVIEW:						\
 	 mat = &ctx->ModelView;						\
-	 flags |= NEW_MODELVIEW;					\
+	 flags |= _NEW_MODELVIEW;					\
 	 break;								\
       case GL_PROJECTION:						\
 	 mat = &ctx->ProjectionMatrix;					\
-	 flags |= NEW_PROJECTION;					\
+	 flags |= _NEW_PROJECTION;					\
 	 break;								\
       case GL_TEXTURE:							\
-	 mat = &ctx->TextureMatrix[ctx->Texture.CurrentTransformUnit];	\
-	 flags |= NEW_TEXTURE_MATRIX;					\
+	 mat = &ctx->TextureMatrix[ctx->Texture.CurrentUnit];		\
+	 flags |= _NEW_TEXTURE_MATRIX;					\
 	 break;								\
       case GL_COLOR:							\
 	 mat = &ctx->ColorMatrix;					\
-	 flags |= NEW_COLOR_MATRIX;					\
+	 flags |= _NEW_COLOR_MATRIX;					\
 	 break;								\
       default:								\
-         gl_problem(ctx, where);					\
+         _mesa_problem(ctx, where);					\
    }									\
 } while (0)
 
@@ -942,48 +88,24 @@
                GLdouble nearval, GLdouble farval )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat x, y, a, b, c, d;
-   GLfloat m[16];
    GLmatrix *mat = 0;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glFrustrum" );
 
-   if ((nearval<=0.0 || farval<=0.0) || (nearval == farval) || (left == right) || (top == bottom)) {
-      gl_error( ctx,  GL_INVALID_VALUE, "glFrustum(near or far)" );
+   if (nearval <= 0.0 ||
+       farval <= 0.0 ||
+       nearval == farval ||
+       left == right ||
+       top == bottom)
+   {
+      _mesa_error( ctx,  GL_INVALID_VALUE, "glFrustum" );
       return;
    }
-
-   x = (2.0*nearval) / (right-left);
-   y = (2.0*nearval) / (top-bottom);
-   a = (right+left) / (right-left);
-   b = (top+bottom) / (top-bottom);
-   c = -(farval+nearval) / ( farval-nearval);
-   d = -(2.0*farval*nearval) / (farval-nearval);  /* error? */
-
-#define M(row,col)  m[col*4+row]
-   M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = a;      M(0,3) = 0.0F;
-   M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = b;      M(1,3) = 0.0F;
-   M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = c;      M(2,3) = d;
-   M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = -1.0F;  M(3,3) = 0.0F;
-#undef M
 
-
-   gl_mat_mul_floats( mat, m, MAT_FLAG_PERSPECTIVE );
-
-
-   if (ctx->Transform.MatrixMode == GL_PROJECTION)
-   {
-      /* Need to keep a stack of near/far values in case the user push/pops
-       * the projection matrix stack so that we can call Driver.NearFar()
-       * after a pop.
-       */
-      ctx->NearFarStack[ctx->ProjectionStackDepth][0] = nearval;
-      ctx->NearFarStack[ctx->ProjectionStackDepth][1] = farval;
-      
-      if (ctx->Driver.NearFar) {
-	 (*ctx->Driver.NearFar)( ctx, nearval, farval );
-      }
-   }
+   _math_matrix_frustum( mat, (GLfloat) left, (GLfloat) right, 
+			 (GLfloat) bottom, (GLfloat) top, 
+			 (GLfloat) nearval, (GLfloat) farval );
 }
 
 
@@ -993,37 +115,22 @@
              GLdouble nearval, GLdouble farval )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat x, y, z;
-   GLfloat tx, ty, tz;
-   GLfloat m[16];
    GLmatrix *mat = 0;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glOrtho" );
-   
-   if ((left == right) || (bottom == top) || (nearval == farval)) {
-      gl_error( ctx,  GL_INVALID_VALUE, "gl_Ortho((l = r) or (b = top) or (n=f)" );
+
+   if (left == right ||
+       bottom == top ||
+       nearval == farval)
+   {
+      _mesa_error( ctx,  GL_INVALID_VALUE, "glOrtho" );
       return;
    }
-
-   x = 2.0 / (right-left);
-   y = 2.0 / (top-bottom);
-   z = -2.0 / (farval-nearval);
-   tx = -(right+left) / (right-left);
-   ty = -(top+bottom) / (top-bottom);
-   tz = -(farval+nearval) / (farval-nearval);
-
-#define M(row,col)  m[col*4+row]
-   M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = 0.0F;  M(0,3) = tx;
-   M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = 0.0F;  M(1,3) = ty;
-   M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = z;     M(2,3) = tz;
-   M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = 0.0F;  M(3,3) = 1.0F;
-#undef M
-
-   gl_mat_mul_floats( mat, m, (MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION));
 
-   if (ctx->Driver.NearFar) {
-      (*ctx->Driver.NearFar)( ctx, nearval, farval );
-   }
+   _math_matrix_ortho( mat, (GLfloat) left, (GLfloat) right, 
+		       (GLfloat) bottom, (GLfloat) top, 
+		       (GLfloat) nearval, (GLfloat) farval );
 }
 
 
@@ -1031,16 +138,20 @@
 _mesa_MatrixMode( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMatrixMode");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    switch (mode) {
       case GL_MODELVIEW:
       case GL_PROJECTION:
       case GL_TEXTURE:
       case GL_COLOR:
+	 if (ctx->Transform.MatrixMode == mode)
+	    return;
          ctx->Transform.MatrixMode = mode;
+	 FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
          break;
       default:
-         gl_error( ctx,  GL_INVALID_ENUM, "glMatrixMode" );
+         _mesa_error( ctx,  GL_INVALID_ENUM, "glMatrixMode" );
    }
 }
 
@@ -1050,56 +161,50 @@
 _mesa_PushMatrix( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPushMatrix");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glPushMatrix %s\n", 
-	      gl_lookup_enum_by_nr(ctx->Transform.MatrixMode));
+      fprintf(stderr, "glPushMatrix %s\n",
+	      _mesa_lookup_enum_by_nr(ctx->Transform.MatrixMode));
 
    switch (ctx->Transform.MatrixMode) {
       case GL_MODELVIEW:
          if (ctx->ModelViewStackDepth >= MAX_MODELVIEW_STACK_DEPTH - 1) {
-            gl_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
+            _mesa_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
             return;
          }
-         gl_matrix_copy( &ctx->ModelViewStack[ctx->ModelViewStackDepth++],
-			 &ctx->ModelView );
+         _math_matrix_copy( &ctx->ModelViewStack[ctx->ModelViewStackDepth++],
+                      &ctx->ModelView );
          break;
       case GL_PROJECTION:
          if (ctx->ProjectionStackDepth >= MAX_PROJECTION_STACK_DEPTH - 1) {
-            gl_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
+            _mesa_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
             return;
          }
-         gl_matrix_copy( &ctx->ProjectionStack[ctx->ProjectionStackDepth++],
-			 &ctx->ProjectionMatrix );
-
-         /* Save near and far projection values */
-         ctx->NearFarStack[ctx->ProjectionStackDepth][0]
-            = ctx->NearFarStack[ctx->ProjectionStackDepth-1][0];
-         ctx->NearFarStack[ctx->ProjectionStackDepth][1]
-            = ctx->NearFarStack[ctx->ProjectionStackDepth-1][1];
+         _math_matrix_copy( &ctx->ProjectionStack[ctx->ProjectionStackDepth++],
+                      &ctx->ProjectionMatrix );
          break;
       case GL_TEXTURE:
          {
-            GLuint t = ctx->Texture.CurrentTransformUnit;
+            GLuint t = ctx->Texture.CurrentUnit;
             if (ctx->TextureStackDepth[t] >= MAX_TEXTURE_STACK_DEPTH - 1) {
-               gl_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
+               _mesa_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
                return;
             }
-	    gl_matrix_copy( &ctx->TextureStack[t][ctx->TextureStackDepth[t]++],
-			    &ctx->TextureMatrix[t] );
+	    _math_matrix_copy( &ctx->TextureStack[t][ctx->TextureStackDepth[t]++],
+                         &ctx->TextureMatrix[t] );
          }
          break;
       case GL_COLOR:
          if (ctx->ColorStackDepth >= MAX_COLOR_STACK_DEPTH - 1) {
-            gl_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
+            _mesa_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix");
             return;
          }
-         gl_matrix_copy( &ctx->ColorStack[ctx->ColorStackDepth++],
-                         &ctx->ColorMatrix );
+         _math_matrix_copy( &ctx->ColorStack[ctx->ColorStackDepth++],
+                      &ctx->ColorMatrix );
          break;
       default:
-         gl_problem(ctx, "Bad matrix mode in gl_PushMatrix");
+         _mesa_problem(ctx, "Bad matrix mode in _mesa_PushMatrix");
    }
 }
 
@@ -1109,62 +214,55 @@
 _mesa_PopMatrix( void )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPopMatrix");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glPopMatrix %s\n", 
-	      gl_lookup_enum_by_nr(ctx->Transform.MatrixMode));
+      fprintf(stderr, "glPopMatrix %s\n",
+	      _mesa_lookup_enum_by_nr(ctx->Transform.MatrixMode));
 
    switch (ctx->Transform.MatrixMode) {
       case GL_MODELVIEW:
          if (ctx->ModelViewStackDepth==0) {
-            gl_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
+            _mesa_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
             return;
          }
-         gl_matrix_copy( &ctx->ModelView,
-			 &ctx->ModelViewStack[--ctx->ModelViewStackDepth] );
-	 ctx->NewState |= NEW_MODELVIEW;
+         _math_matrix_copy( &ctx->ModelView,
+			    &ctx->ModelViewStack[--ctx->ModelViewStackDepth] );
+	 ctx->NewState |= _NEW_MODELVIEW;
          break;
       case GL_PROJECTION:
          if (ctx->ProjectionStackDepth==0) {
-            gl_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
+            _mesa_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
             return;
          }
 
-         gl_matrix_copy( &ctx->ProjectionMatrix,
-			 &ctx->ProjectionStack[--ctx->ProjectionStackDepth] );
-	 ctx->NewState |= NEW_PROJECTION;
-
-         /* Device driver near/far values */
-         {
-            GLfloat nearVal = ctx->NearFarStack[ctx->ProjectionStackDepth][0];
-            GLfloat farVal  = ctx->NearFarStack[ctx->ProjectionStackDepth][1];
-            if (ctx->Driver.NearFar) {
-               (*ctx->Driver.NearFar)( ctx, nearVal, farVal );
-            }
-         }
+         _math_matrix_copy( &ctx->ProjectionMatrix,
+			    &ctx->ProjectionStack[--ctx->ProjectionStackDepth] );
+	 ctx->NewState |= _NEW_PROJECTION;
          break;
       case GL_TEXTURE:
          {
-            GLuint t = ctx->Texture.CurrentTransformUnit;
+            GLuint t = ctx->Texture.CurrentUnit;
             if (ctx->TextureStackDepth[t]==0) {
-               gl_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
+               _mesa_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
                return;
             }
-	    gl_matrix_copy(&ctx->TextureMatrix[t],
-			   &ctx->TextureStack[t][--ctx->TextureStackDepth[t]]);
+	    _math_matrix_copy(&ctx->TextureMatrix[t],
+			      &ctx->TextureStack[t][--ctx->TextureStackDepth[t]]);
+	    ctx->NewState |= _NEW_TEXTURE_MATRIX;
          }
          break;
       case GL_COLOR:
          if (ctx->ColorStackDepth==0) {
-            gl_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
+            _mesa_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix");
             return;
          }
-         gl_matrix_copy(&ctx->ColorMatrix,
-                        &ctx->ColorStack[--ctx->ColorStackDepth]);
+         _math_matrix_copy(&ctx->ColorMatrix,
+			   &ctx->ColorStack[--ctx->ColorStackDepth]);
+	 ctx->NewState |= _NEW_COLOR_MATRIX;
          break;
       default:
-         gl_problem(ctx, "Bad matrix mode in gl_PopMatrix");
+         _mesa_problem(ctx, "Bad matrix mode in _mesa_PopMatrix");
    }
 }
 
@@ -1175,20 +273,9 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glLoadIdentity");
-
-   MEMCPY( mat->m, Identity, 16*sizeof(GLfloat) );
-
-   if (mat->inv)
-      MEMCPY( mat->inv, Identity, 16*sizeof(GLfloat) );
-
-   mat->type = MATRIX_IDENTITY;
-   
-   /* Have to set this to dirty to make sure we recalculate the
-    * combined matrix later.  The update_matrix in this case is a
-    * shortcircuit anyway...
-    */
-   mat->flags = MAT_DIRTY_DEPENDENTS;	
+   _math_matrix_set_identity( mat );
 }
 
 
@@ -1197,41 +284,21 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
+   if (!m) return;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glLoadMatrix");
-
-   MEMCPY( mat->m, m, 16*sizeof(GLfloat) );
-   mat->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL_OVER);
-
-   if (ctx->Transform.MatrixMode == GL_PROJECTION) {
-
-#define M(row,col)  m[col*4+row]
-      GLfloat c = M(2,2);
-      GLfloat d = M(2,3);
-#undef M
-      GLfloat n = (c ==  1.0 ? 0.0 : d / (c - 1.0));
-      GLfloat f = (c == -1.0 ? 1.0 : d / (c + 1.0));
-
-      /* Need to keep a stack of near/far values in case the user
-       * push/pops the projection matrix stack so that we can call
-       * Driver.NearFar() after a pop.
-       */
-      ctx->NearFarStack[ctx->ProjectionStackDepth][0] = n;
-      ctx->NearFarStack[ctx->ProjectionStackDepth][1] = f;
-
-      if (ctx->Driver.NearFar) {
-	 (*ctx->Driver.NearFar)( ctx, n, f );
-      }
-   }
+   _math_matrix_loadf( mat, m );
 }
 
 
 void
 _mesa_LoadMatrixd( const GLdouble *m )
 {
-   GLfloat f[16];
    GLint i;
+   GLfloat f[16];
+   if (!m) return;
    for (i = 0; i < 16; i++)
-      f[i] = m[i];
+      f[i] = (GLfloat) m[i];
    _mesa_LoadMatrixf(f);
 }
 
@@ -1245,84 +312,49 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
+   if (!m) return;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glMultMatrix" );
-   matmul4( mat->m, mat->m, m );
-   mat->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL_OVER);
+   _math_matrix_mul_floats( mat, m );
 }
 
 
 /*
- * Multiply the active matrix by an arbitary matrix.  
+ * Multiply the active matrix by an arbitary matrix.
  */
 void
 _mesa_MultMatrixd( const GLdouble *m )
 {
-   GET_CURRENT_CONTEXT(ctx);
-   GLmatrix *mat = 0;
-   GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glMultMatrix" );
-   matmul4fd( mat->m, mat->m, m );
-   mat->flags = (MAT_FLAG_GENERAL | MAT_DIRTY_ALL_OVER);
+   GLint i;
+   GLfloat f[16];
+   if (!m) return;
+   for (i = 0; i < 16; i++)
+      f[i] = (GLfloat) m[i];
+   _mesa_MultMatrixf( f );
 }
 
 
 
 
 /*
- * Multiply a matrix by an array of floats with known properties.
- */
-void gl_mat_mul_floats( GLmatrix *mat, const GLfloat *m, GLuint flags )
-{
-   mat->flags |= (flags |
-		  MAT_DIRTY_TYPE | 
-		  MAT_DIRTY_INVERSE | 
-		  MAT_DIRTY_DEPENDENTS);
-
-   if (TEST_MAT_FLAGS(mat, MAT_FLAGS_3D))
-      matmul34( mat->m, mat->m, m );
-   else 
-      matmul4( mat->m, mat->m, m );      
-
-}
-
-/*
- * Multiply a matrix by an array of floats with known properties.
- */
-void gl_mat_mul_mat( GLmatrix *mat, const GLmatrix *m )
-{
-   mat->flags |= (m->flags |
-		  MAT_DIRTY_TYPE | 
-		  MAT_DIRTY_INVERSE | 
-		  MAT_DIRTY_DEPENDENTS);
-
-   if (TEST_MAT_FLAGS(mat, MAT_FLAGS_3D))
-      matmul34( mat->m, mat->m, m->m );
-   else 
-      matmul4( mat->m, mat->m, m->m );      
-}
-
-
-
-/*
  * Execute a glRotate call
  */
 void
 _mesa_Rotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLfloat m[16];
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    if (angle != 0.0F) {
       GLmatrix *mat = 0;
       GET_ACTIVE_MATRIX( ctx,  mat, ctx->NewState, "glRotate" );
-
-      gl_rotation_matrix( angle, x, y, z, m );
-      gl_mat_mul_floats( mat, m, MAT_FLAG_ROTATION );
+      _math_matrix_rotate( mat, angle, x, y, z );
    }
 }
 
 void
 _mesa_Rotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
 {
-   _mesa_Rotatef(angle, x, y, z);
+   _mesa_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
 }
 
 
@@ -1334,30 +366,16 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
-   GLfloat *m;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glScale");
-
-   m = mat->m;
-   m[0] *= x;   m[4] *= y;   m[8]  *= z;
-   m[1] *= x;   m[5] *= y;   m[9]  *= z;
-   m[2] *= x;   m[6] *= y;   m[10] *= z;
-   m[3] *= x;   m[7] *= y;   m[11] *= z;
-
-   if (fabs(x - y) < 1e-8 && fabs(x - z) < 1e-8)
-      mat->flags |= MAT_FLAG_UNIFORM_SCALE;
-   else
-      mat->flags |= MAT_FLAG_GENERAL_SCALE;
-
-   mat->flags |= (MAT_DIRTY_TYPE | 
-		  MAT_DIRTY_INVERSE | 
-		  MAT_DIRTY_DEPENDENTS);
+   _math_matrix_scale( mat, x, y, z );
 }
 
 
 void
 _mesa_Scaled( GLdouble x, GLdouble y, GLdouble z )
 {
-   _mesa_Scalef(x, y, z);
+   _mesa_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
 }
 
 
@@ -1369,34 +387,25 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLmatrix *mat = 0;
-   GLfloat *m;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
    GET_ACTIVE_MATRIX(ctx, mat, ctx->NewState, "glTranslate");
-   m = mat->m;
-   m[12] = m[0] * x + m[4] * y + m[8]  * z + m[12];
-   m[13] = m[1] * x + m[5] * y + m[9]  * z + m[13];
-   m[14] = m[2] * x + m[6] * y + m[10] * z + m[14];
-   m[15] = m[3] * x + m[7] * y + m[11] * z + m[15];
-
-   mat->flags |= (MAT_FLAG_TRANSLATION | 
-		  MAT_DIRTY_TYPE | 
-		  MAT_DIRTY_INVERSE | 
-		  MAT_DIRTY_DEPENDENTS);
+   _math_matrix_translate( mat, x, y, z );
 }
 
 
 void
 _mesa_Translated( GLdouble x, GLdouble y, GLdouble z )
 {
-   _mesa_Translatef(x, y, z);
+   _mesa_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
 }
 
 
-
 void
 _mesa_LoadTransposeMatrixfARB( const GLfloat *m )
 {
    GLfloat tm[16];
-   gl_matrix_transposef(tm, m);
+   if (!m) return;
+   _math_transposef(tm, m);
    _mesa_LoadMatrixf(tm);
 }
 
@@ -1404,9 +413,10 @@
 void
 _mesa_LoadTransposeMatrixdARB( const GLdouble *m )
 {
-   GLdouble tm[16];
-   gl_matrix_transposed(tm, m);
-   _mesa_LoadMatrixd(tm);
+   GLfloat tm[16];
+   if (!m) return;
+   _math_transposefd(tm, m);
+   _mesa_LoadMatrixf(tm);
 }
 
 
@@ -1414,7 +424,8 @@
 _mesa_MultTransposeMatrixfARB( const GLfloat *m )
 {
    GLfloat tm[16];
-   gl_matrix_transposef(tm, m);
+   if (!m) return;
+   _math_transposef(tm, m);
    _mesa_MultMatrixf(tm);
 }
 
@@ -1422,9 +433,10 @@
 void
 _mesa_MultTransposeMatrixdARB( const GLdouble *m )
 {
-   GLdouble tm[16];
-   gl_matrix_transposed(tm, m);
-   _mesa_MultMatrixd(tm);
+   GLfloat tm[16];
+   if (!m) return;
+   _math_transposefd(tm, m);
+   _mesa_MultMatrixf(tm);
 }
 
 
@@ -1435,35 +447,30 @@
 _mesa_Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
 {
    GET_CURRENT_CONTEXT(ctx);
-   gl_Viewport(ctx, x, y, width, height);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+   _mesa_set_viewport(ctx, x, y, width, height);
 }
 
 
-
 /*
  * Define a new viewport and reallocate auxillary buffers if the size of
  * the window (color buffer) has changed.
- *
- * XXX This is directly called by device drivers, BUT this function
- * may be renamed _mesa_Viewport (without ctx arg) in the future so
- * use of _mesa_Viewport is encouraged.
  */
 void
-gl_Viewport( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height )
+_mesa_set_viewport( GLcontext *ctx, GLint x, GLint y,
+                    GLsizei width, GLsizei height )
 {
    const GLfloat n = ctx->Viewport.Near;
    const GLfloat f = ctx->Viewport.Far;
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glViewport");
-
-   if (width<0 || height<0) {
-      gl_error( ctx,  GL_INVALID_VALUE, "glViewport" );
+   if (width < 0 || height < 0) {
+      _mesa_error( ctx,  GL_INVALID_VALUE, "glViewport" );
       return;
    }
 
    if (MESA_VERBOSE & VERBOSE_API)
       fprintf(stderr, "glViewport %d %d %d %d\n", x, y, width, height);
-   
+
    /* clamp width, and height to implementation dependent range */
    width  = CLAMP( width,  1, MAX_WIDTH );
    height = CLAMP( height, 1, MAX_HEIGHT );
@@ -1474,36 +481,24 @@
    ctx->Viewport.Y = y;
    ctx->Viewport.Height = height;
 
-   /* compute scale and bias values */
-   ctx->Viewport.WindowMap.m[MAT_SX] = (GLfloat) width / 2.0F;
-   ctx->Viewport.WindowMap.m[MAT_TX] = ctx->Viewport.WindowMap.m[MAT_SX] + x;
-   ctx->Viewport.WindowMap.m[MAT_SY] = (GLfloat) height / 2.0F;
-   ctx->Viewport.WindowMap.m[MAT_TY] = ctx->Viewport.WindowMap.m[MAT_SY] + y;
-   ctx->Viewport.WindowMap.m[MAT_SZ] = ctx->Visual->DepthMaxF * ((f - n) / 2.0);
-   ctx->Viewport.WindowMap.m[MAT_TZ] = ctx->Visual->DepthMaxF * ((f - n) / 2.0 + n);
-
-   ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
-   ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT;
-
-   ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
-   ctx->NewState |= NEW_VIEWPORT;
+   /* compute scale and bias values :: This is really driver-specific
+    * and should be maintained elsewhere if at all.
+    */
+   ctx->Viewport._WindowMap.m[MAT_SX] = (GLfloat) width / 2.0F;
+   ctx->Viewport._WindowMap.m[MAT_TX] = ctx->Viewport._WindowMap.m[MAT_SX] + x;
+   ctx->Viewport._WindowMap.m[MAT_SY] = (GLfloat) height / 2.0F;
+   ctx->Viewport._WindowMap.m[MAT_TY] = ctx->Viewport._WindowMap.m[MAT_SY] + y;
+   ctx->Viewport._WindowMap.m[MAT_SZ] = ctx->DepthMaxF * ((f - n) / 2.0F);
+   ctx->Viewport._WindowMap.m[MAT_TZ] = ctx->DepthMaxF * ((f - n) / 2.0F + n);
+   ctx->Viewport._WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
+   ctx->Viewport._WindowMap.type = MATRIX_3D_NO_ROT;
+   ctx->NewState |= _NEW_VIEWPORT;
 
    /* Check if window/buffer has been resized and if so, reallocate the
     * ancillary buffers.
     */
    _mesa_ResizeBuffersMESA();
 
-
-   ctx->RasterMask &= ~WINCLIP_BIT;
-
-   if (   ctx->Viewport.X<0
-       || ctx->Viewport.X + ctx->Viewport.Width > ctx->DrawBuffer->Width
-       || ctx->Viewport.Y<0
-       || ctx->Viewport.Y + ctx->Viewport.Height > ctx->DrawBuffer->Height) {
-      ctx->RasterMask |= WINCLIP_BIT;
-   }
-
-
    if (ctx->Driver.Viewport) {
       (*ctx->Driver.Viewport)( ctx, x, y, width, height );
    }
@@ -1527,102 +522,21 @@
     */
    GLfloat n, f;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDepthRange");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glDepthRange %f %f\n", nearval, farval); 
+      fprintf(stderr, "glDepthRange %f %f\n", nearval, farval);
 
    n = (GLfloat) CLAMP( nearval, 0.0, 1.0 );
    f = (GLfloat) CLAMP( farval, 0.0, 1.0 );
 
    ctx->Viewport.Near = n;
    ctx->Viewport.Far = f;
-   ctx->Viewport.WindowMap.m[MAT_SZ] = ctx->Visual->DepthMaxF * ((f - n) / 2.0);
-   ctx->Viewport.WindowMap.m[MAT_TZ] = ctx->Visual->DepthMaxF * ((f - n) / 2.0 + n);
-
-   ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
+   ctx->Viewport._WindowMap.m[MAT_SZ] = ctx->DepthMaxF * ((f - n) / 2.0F);
+   ctx->Viewport._WindowMap.m[MAT_TZ] = ctx->DepthMaxF * ((f - n) / 2.0F + n);
+   ctx->NewState |= _NEW_VIEWPORT;
 
    if (ctx->Driver.DepthRange) {
       (*ctx->Driver.DepthRange)( ctx, nearval, farval );
    }
-}
-
-
-void gl_calculate_model_project_matrix( GLcontext *ctx )
-{
-   gl_matrix_mul( &ctx->ModelProjectMatrix,
-		  &ctx->ProjectionMatrix,
-		  &ctx->ModelView );
-
-   gl_matrix_analyze( &ctx->ModelProjectMatrix );
-}
-
-
-void gl_matrix_ctr( GLmatrix *m )
-{
-   if ( m->m == 0 ) {
-      m->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
-   }
-   MEMCPY( m->m, Identity, sizeof(Identity) );
-   m->inv = 0;
-   m->type = MATRIX_IDENTITY;
-   m->flags = MAT_DIRTY_DEPENDENTS;
-}
-
-void gl_matrix_dtr( GLmatrix *m )
-{
-   if ( m->m != 0 ) {
-      ALIGN_FREE( m->m );
-      m->m = 0;
-   }
-   if ( m->inv != 0 ) {
-      ALIGN_FREE( m->inv );
-      m->inv = 0;
-   }
-}
-
-#if 0
-void gl_matrix_set_identity( GLmatrix *m )
-{
-   MEMCPY( m->m, Identity, sizeof(Identity) );
-   m->type = MATRIX_IDENTITY;
-   m->flags = MAT_DIRTY_DEPENDENTS;
-}
-#endif
-
-void gl_matrix_alloc_inv( GLmatrix *m )
-{
-   if ( m->inv == 0 ) {
-      m->inv = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
-      MEMCPY( m->inv, Identity, 16 * sizeof(GLfloat) );
-   }
-}
-
-void gl_matrix_copy( GLmatrix *to, const GLmatrix *from )
-{
-   MEMCPY( to->m, from->m, sizeof(Identity) );
-   to->flags = from->flags | MAT_DIRTY_DEPENDENTS;
-   to->type = from->type;
-
-   if (to->inv != 0) {
-      if (from->inv == 0) {
-	 gl_matrix_invert( to );
-      } else {
-	 MEMCPY(to->inv, from->inv, sizeof(GLfloat)*16);
-      }
-   }
-}
-
-void gl_matrix_mul( GLmatrix *dest, const GLmatrix *a, const GLmatrix *b )
-{
-   dest->flags = (a->flags |
-		  b->flags |
-		  MAT_DIRTY_TYPE | 
-		  MAT_DIRTY_INVERSE | 
-		  MAT_DIRTY_DEPENDENTS);
-
-   if (TEST_MAT_FLAGS(dest, MAT_FLAGS_3D))
-      matmul34( dest->m, a->m, b->m );
-   else 
-      matmul4( dest->m, a->m, b->m );
 }
Index: xc/extras/Mesa/src/matrix.h
diff -u xc/extras/Mesa/src/matrix.h:1.6 xc/extras/Mesa/src/matrix.h:1.7
--- xc/extras/Mesa/src/matrix.h:1.6	Mon Nov 13 18:30:50 2000
+++ xc/extras/Mesa/src/matrix.h	Fri Feb 22 14:25:36 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,58 +28,9 @@
 #define MATRIX_H
 
 
-#include "types.h"
-#include "config.h"
+#include "mtypes.h"
 
 
-typedef struct {
-   GLfloat *m;			/* 16-byte aligned */
-   GLfloat *inv;		/* optional, 16-byte aligned */
-   GLuint flags;
-   GLuint type;
-} GLmatrix;
-
-
-#ifdef VMS
-#define gl_calculate_model_project_matrix gl_calculate_model_project_matr
-#endif
-
-
-extern void gl_matrix_transposef( GLfloat to[16], const GLfloat from[16] );
-
-extern void gl_matrix_transposed( GLdouble to[16], const GLdouble from[16] );
-
-
-extern void gl_rotation_matrix( GLfloat angle, GLfloat x, GLfloat y, GLfloat z,
-                                GLfloat m[] );
-
-
-extern void gl_mat_mul_floats( GLmatrix *mat, const GLfloat *m, GLuint flags );
-
-extern void gl_mat_mul_mat( GLmatrix *mat, const GLmatrix *mat2 );
-
-extern void gl_calculate_model_project_matrix( GLcontext *ctx );
-
-extern void gl_matrix_copy( GLmatrix *to, const GLmatrix *from );
-
-extern void gl_matrix_ctr( GLmatrix *m );
-
-extern void gl_matrix_dtr( GLmatrix *m );
-
-extern void gl_matrix_alloc_inv( GLmatrix *m );
-
-extern void gl_matrix_mul( GLmatrix *dest, 
-			   const GLmatrix *a, 
-			   const GLmatrix *b );
-
-extern void gl_matrix_analyze( GLmatrix *mat );
-
-extern GLboolean gl_matrix_invert( GLmatrix *mat );
-
-extern void gl_print_matrix( const GLmatrix *m );
-
-
-
 extern void
 _mesa_Frustum( GLdouble left, GLdouble right,
                GLdouble bottom, GLdouble top,
@@ -148,11 +99,10 @@
 _mesa_Viewport( GLint x, GLint y, GLsizei width, GLsizei height );
 
 extern void
-gl_Viewport( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height );
+_mesa_set_viewport( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height );
 
 extern void
 _mesa_DepthRange( GLclampd nearval, GLclampd farval );
-
 
 
 #endif
Index: xc/extras/Mesa/src/mem.c
diff -u xc/extras/Mesa/src/mem.c:1.5 xc/extras/Mesa/src/mem.c:1.6
--- xc/extras/Mesa/src/mem.c:1.5	Mon Nov 13 18:30:50 2000
+++ xc/extras/Mesa/src/mem.c	Fri Feb 22 14:25:36 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -36,13 +36,95 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "config.h"
 #include "macros.h"
 #include "mem.h"
 #endif
 
 
+#if defined(WIN32) && defined(_DEBUG)
 
 /*
+ * N-byte aligned memory allocation functions.  Called via the ALIGN_MALLOC,
+ * ALIGN_CALLOC and ALIGN_FREE macros.  Debug versions?
+ * These functions allow dynamically allocated memory to be correctly
+ * aligned for improved cache utilization and specialized assembly
+ * support.
+ */
+
+/*
+ * Allocate N-byte aligned memory (uninitialized)
+ */
+void *
+_mesa_align_malloc_dbg(size_t bytes, unsigned long alignment, const char *_file, int _line )
+{
+   unsigned long ptr, buf;
+
+   ASSERT( alignment > 0 );
+
+   ptr = (unsigned long) _malloc_dbg( bytes + alignment, _NORMAL_BLOCK, _file, _line );
+
+   buf = (ptr + alignment) & ~(unsigned long)(alignment - 1);
+   *(unsigned long *)(buf - sizeof(void *)) = ptr;
+
+#ifdef DEBUG
+   /* mark the non-aligned area */
+   while ( ptr < buf - sizeof(void *) ) {
+      *(unsigned long *)ptr = 0xcdcdcdcd;
+      ptr += sizeof(unsigned long);
+   }
+#endif
+
+   return (void *)buf;
+}
+
+
+/*
+ * Allocate N-byte aligned memory and initialize to zero
+ */
+void *
+_mesa_align_calloc_dbg(size_t bytes, unsigned long alignment, const char *_file, int _line)
+{
+   unsigned long ptr, buf;
+
+   ASSERT( alignment > 0 );
+
+   ptr = (unsigned long) _calloc_dbg( 1, bytes + alignment, _NORMAL_BLOCK, _file, _line );
+
+   buf = (ptr + alignment) & ~(unsigned long)(alignment - 1);
+   *(unsigned long *)(buf - sizeof(void *)) = ptr;
+
+#ifdef DEBUG
+   /* mark the non-aligned area */
+   while ( ptr < buf - sizeof(void *) ) {
+      *(unsigned long *)ptr = 0xcdcdcdcd;
+      ptr += sizeof(unsigned long);
+   }
+#endif
+
+   return (void *)buf;
+}
+
+
+/*
+ * Free N-byte aligned memory
+ */
+void
+_mesa_align_free_dbg(void *ptr, const char *_file, int _line)
+{
+   /* The actuall address to free is stuffed in the word immediately
+    * before the address the client sees.
+    */
+   void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
+   void *realAddr = *cubbyHole;
+   _free_dbg(realAddr, _NORMAL_BLOCK );
+}
+
+
+#else  /* WIN32 && _DEBUG */
+
+
+/*
  * Allocate memory (uninitialized)
  */
 void *
@@ -152,4 +234,18 @@
    void *realAddr = *cubbyHole;
    FREE(realAddr);
 #endif
+}
+
+
+#endif  /* WIN32 && _DEBUG */
+
+
+/*
+ * Set a block of GLushorts to a particular value.
+ */
+void
+_mesa_memset16( GLushort *dst, GLushort val, size_t n )
+{
+   while (n-- > 0)
+      *dst++ = val;
 }
Index: xc/extras/Mesa/src/mem.h
diff -u xc/extras/Mesa/src/mem.h:1.6 xc/extras/Mesa/src/mem.h:1.9
--- xc/extras/Mesa/src/mem.h:1.6	Mon Nov 13 18:30:50 2000
+++ xc/extras/Mesa/src/mem.h	Sat Jan 11 22:55:44 2003
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  4.0.2
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,18 +22,40 @@
  * 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.
  */
+/* $XFree86: xc/extras/Mesa/src/mem.h,v 1.9 2003/01/12 03:55:44 tsi Exp $ */
 
-
 #ifndef MEM_H
 #define MEM_H
 
 
 #include "glheader.h"
-
+/* Do not reference mtypes.h from this file.
+ */
 
 /*
  * Memory allocation
  */
+#if defined(WIN32) && defined(_DEBUG)
+#include <malloc.h>  
+#ifndef _CRTDBG_MAP_ALLOC
+# define _CRTDBG_MAP_ALLOC 1
+#endif
+#include <crtdbg.h>
+
+#define _mesa_malloc(n)  _malloc_dbg( n, _NORMAL_BLOCK, __FILE__ , __LINE__ )
+#define _mesa_calloc(n)  _calloc_dbg( 1, n, _NORMAL_BLOCK, __FILE__ , __LINE__ )
+#define _mesa_free(p)    _free_dbg(p, _NORMAL_BLOCK )
+
+extern void *_mesa_align_malloc_dbg(size_t bytes, unsigned long alignment, const char *_file, int _line );
+extern void *_mesa_align_calloc_dbg(size_t bytes, unsigned long alignment, const char *_file, int _line );
+extern void _mesa_align_free_dbg(void *ptr, const char *_file, int _line);
+
+#define _mesa_align_malloc( s, a ) _mesa_align_malloc_dbg( s, a, __FILE__ , __LINE__ )
+#define _mesa_align_calloc( s, a ) _mesa_align_calloc_dbg( s, a, __FILE__ , __LINE__ )
+#define _mesa_align_free(p)        _mesa_align_free_dbg(p, __FILE__ , __LINE__)
+
+#else /* WIN32 && _DEBUG */
+
 extern void *_mesa_malloc(size_t bytes);
 extern void *_mesa_calloc(size_t bytes);
 extern void _mesa_free(void *ptr);
@@ -42,7 +64,9 @@
 extern void *_mesa_align_calloc(size_t bytes, unsigned long alignment);
 extern void _mesa_align_free(void *ptr);
 
+#endif /* WIN32 && _DEBUG */
 
+
 #ifdef DEBUG
 
 /* call Mesa memory functions */
@@ -71,6 +95,25 @@
 #define ALIGN_FREE(PTR)            _mesa_align_free(PTR)
 
 
+#ifdef MESA_EXTERNAL_BUFFERALLOC
+/*
+ * If you want Mesa's depth/stencil/accum/etc buffers to be allocated
+ * with a specialized allocator you can define MESA_EXTERNAL_BUFFERALLOC
+ * and implement _ext_mesa_alloc/free_pixelbuffer() in your app.
+ * Contributed by Gerk Huisma (gerk@five-d.demon.nl).
+ */
+extern void *_ext_mesa_alloc_pixelbuffer( unsigned int size );
+extern void _ext_mesa_free_pixelbuffer( void *pb );
+
+#define MESA_PBUFFER_ALLOC(BYTES)  (void *) _ext_mesa_alloc_pixelbuffer(BYTES)
+#define MESA_PBUFFER_FREE(PTR)     _ext_mesa_free_pixelbuffer(PTR)
+#else
+/* Default buffer allocation uses the aligned allocation routines: */
+#define MESA_PBUFFER_ALLOC(BYTES)  (void *) _mesa_align_malloc(BYTES, 512)
+#define MESA_PBUFFER_FREE(PTR)     _mesa_align_free(PTR)
+#endif
+
+
 /* Memory copy: */
 #ifdef SUNOS4
 #define MEMCPY( DST, SRC, BYTES) \
@@ -90,6 +133,11 @@
 	memset( (void *) (DST), (int) (VAL), (size_t) (N) )
 #endif
 
+extern void _mesa_memset16( GLushort *dst, GLushort val, size_t n );
+
+#define MEMSET16( DST, VAL, N ) \
+        _mesa_memset16( (GLushort *) (DST), (GLushort) (VAL), (size_t) (N) )
+
 
 /* On some systems we might want to use bzero() (but is bzero portable?) */
 #if defined(__FreeBSD__)
@@ -103,20 +151,24 @@
 
 /* MACs and BeOS don't support static larger than 32kb, so... */
 #if defined(macintosh) && !defined(__MRC__)
-  extern char *AGLAlloc(int size);
-  extern void AGLFree(char* ptr);
-#  define DEFARRAY(TYPE,NAME,SIZE)  			TYPE *NAME = (TYPE*)AGLAlloc(sizeof(TYPE)*(SIZE))
-#  define DEFMARRAY(TYPE,NAME,SIZE1,SIZE2)		TYPE (*NAME)[SIZE2] = (TYPE(*)[SIZE2])AGLAlloc(sizeof(TYPE)*(SIZE1)*(SIZE2))
-#  define CHECKARRAY(NAME,CMD)				do {if (!(NAME)) {CMD;}} while (0) 
-#  define UNDEFARRAY(NAME)          			do {if ((NAME)) {AGLFree((char*)NAME);}  }while (0)
+/*extern char *AGLAlloc(int size);*/
+/*extern void AGLFree(char* ptr);*/
+#  define DEFARRAY(TYPE,NAME,SIZE)  			TYPE *NAME = (TYPE*)MALLOC(sizeof(TYPE)*(SIZE))
+#  define DEFMARRAY(TYPE,NAME,SIZE1,SIZE2)		TYPE (*NAME)[SIZE2] = (TYPE(*)[SIZE2])MALLOC(sizeof(TYPE)*(SIZE1)*(SIZE2))
+#  define DEFMNARRAY(TYPE,NAME,SIZE1,SIZE2,SIZE3)	TYPE (*NAME)[SIZE2][SIZE3] = (TYPE(*)[SIZE2][SIZE3])MALLOC(sizeof(TYPE)*(SIZE1)*(SIZE2)*(SIZE3))
+
+#  define CHECKARRAY(NAME,CMD)				do {if (!(NAME)) {CMD;}} while (0)
+#  define UNDEFARRAY(NAME)          			do {if ((NAME)) {FREE((char*)NAME);}  }while (0)
 #elif defined(__BEOS__)
 #  define DEFARRAY(TYPE,NAME,SIZE)  			TYPE *NAME = (TYPE*)malloc(sizeof(TYPE)*(SIZE))
 #  define DEFMARRAY(TYPE,NAME,SIZE1,SIZE2)  		TYPE (*NAME)[SIZE2] = (TYPE(*)[SIZE2])malloc(sizeof(TYPE)*(SIZE1)*(SIZE2))
+#  define DEFMNARRAY(TYPE,NAME,SIZE1,SIZE2,SIZE3)	TYPE (*NAME)[SIZE2][SIZE3] = (TYPE(*)[SIZE2][SIZE3])malloc(sizeof(TYPE)*(SIZE1)*(SIZE2)*(SIZE3))
 #  define CHECKARRAY(NAME,CMD)				do {if (!(NAME)) {CMD;}} while (0)
 #  define UNDEFARRAY(NAME)          			do {if ((NAME)) {free((char*)NAME);}  }while (0)
 #else
 #  define DEFARRAY(TYPE,NAME,SIZE)  			TYPE NAME[SIZE]
 #  define DEFMARRAY(TYPE,NAME,SIZE1,SIZE2)		TYPE NAME[SIZE1][SIZE2]
+#  define DEFMNARRAY(TYPE,NAME,SIZE1,SIZE2,SIZE3)	TYPE NAME[SIZE1][SIZE2][SIZE3]
 #  define CHECKARRAY(NAME,CMD)				do {} while(0)
 #  define UNDEFARRAY(NAME)
 #endif
Index: xc/extras/Mesa/src/mmath.c
diff -u xc/extras/Mesa/src/mmath.c:1.5 xc/extras/Mesa/src/mmath.c:1.6
--- xc/extras/Mesa/src/mmath.c:1.5	Tue Dec 11 04:18:54 2001
+++ xc/extras/Mesa/src/mmath.c	Fri Feb 22 14:25:36 2002
@@ -1,20 +1,20 @@
-/* $XFree86: xc/extras/Mesa/src/mmath.c,v 1.5 2001/12/11 09:18:54 alanh Exp $ */
+/* $XFree86: xc/extras/Mesa/src/mmath.c,v 1.6 2002/02/22 19:25:36 dawes Exp $ */
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,6 @@
 #include "all.h"
 #else
 #include "glheader.h"
-#include "macros.h"
 #include "mmath.h"
 #endif
 
@@ -42,7 +41,7 @@
  */
 
 /*
- * SPARC implementation of a fast square root by table 
+ * SPARC implementation of a fast square root by table
  * lookup.
  * SPARC floating point format is as follows:
  *
@@ -55,38 +54,36 @@
 {
 #ifdef FAST_MATH
    unsigned short i;
-   float f;
-   unsigned int *fi = (unsigned int *)&f;
-                                /* to access the bits of a float in  */
-                                /* C quickly we must misuse pointers */
+   fi_type fi;     /* to access the bits of a float in  C quickly  */
+                   /* we use a union defined in glheader.h         */
 
    for(i=0; i<= 0x7f; i++) {
-      *fi = 0;
+      fi.i = 0;
 
       /*
        * Build a float with the bit pattern i as mantissa
        * and an exponent of 0, stored as 127
        */
 
-      *fi = (i << 16) | (127 << 23);
-      f = sqrt(f);
+      fi.i = (i << 16) | (127 << 23);
+      fi.f = sqrt(fi.f);
 
       /*
        * Take the square root then strip the first 7 bits of
        * the mantissa into the table
        */
 
-      sqrttab[i] = (*fi & 0x7fffff) >> 16;
+      sqrttab[i] = (fi.i & 0x7fffff) >> 16;
 
       /*
        * Repeat the process, this time with an exponent of
        * 1, stored as 128
        */
 
-      *fi = 0;
-      *fi = (i << 16) | (128 << 23);
-      f = sqrt(f);
-      sqrttab[i+0x80] = (*fi & 0x7fffff) >> 16;
+      fi.i = 0;
+      fi.i = (i << 16) | (128 << 23);
+      fi.f = sqrt(fi.f);
+      sqrttab[i+0x80] = (fi.i & 0x7fffff) >> 16;
    }
 #else
    (void) sqrttab;  /* silence compiler warnings */
@@ -97,16 +94,17 @@
 float gl_sqrt( float x )
 {
 #ifdef FAST_MATH
-   unsigned int *num = (unsigned int *)&x;
+   fi_type num;
                                 /* to access the bits of a float in C
-                                 * we must misuse pointers */
-                                                        
+                                 * we use a union from glheader.h     */
+
    short e;                     /* the exponent */
    if (x == 0.0F) return 0.0F;  /* check for square root of 0 */
-   e = (*num >> 23) - 127;      /* get the exponent - on a SPARC the */
+   num.f = x;
+   e = (num.i >> 23) - 127;     /* get the exponent - on a SPARC the */
                                 /* exponent is stored with 127 added */
-   *num &= 0x7fffff;            /* leave only the mantissa */
-   if (e & 0x01) *num |= 0x800000;
+   num.i &= 0x7fffff;           /* leave only the mantissa */
+   if (e & 0x01) num.i |= 0x800000;
                                 /* the exponent is odd so we have to */
                                 /* look it up in the second half of  */
                                 /* the lookup table, so we set the   */
@@ -118,25 +116,17 @@
    /* Do the table lookup, based on the quaternary mantissa,
     * then reconstruct the result back into a float
     */
-   *num = ((sqrttab[*num >> 16]) << 16) | ((e + 127) << 23);
-   return x;
+   num.i = ((sqrttab[num.i >> 16]) << 16) | ((e + 127) << 23);
+   return num.f;
 #else
-   return sqrt(x);
+   return (GLfloat) sqrt(x);
 #endif
 }
 
-float gl_ubyte_to_float_color_tab[256];
-float gl_ubyte_to_float_255_color_tab[256];
 
-static void
-init_ubyte_color_tab(void)
-{
-   int i;
-   for (i = 0 ; i < 256 ; i++) {
-      gl_ubyte_to_float_color_tab[i] = (float) i * (1.0/255.0);
-      gl_ubyte_to_float_255_color_tab[i] = (float) i;
-   }
-}
+/* ubyte -> float conversion */
+float _mesa_ubyte_to_float_color_tab[256];
+
 
 /*
  * Initialize tables, etc for fast math functions.
@@ -147,8 +137,12 @@
    static GLboolean initialized = GL_FALSE;
 
    if (!initialized) {
+      int i;
+      for (i = 0; i < 256; i++) {
+         _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
+      }
+
       init_sqrt();
-      init_ubyte_color_tab();
 
       initialized = GL_TRUE;
       in_fast_math = 0;
@@ -185,4 +179,3 @@
    }
    return bits;
 }
-
Index: xc/extras/Mesa/src/mmath.h
diff -u xc/extras/Mesa/src/mmath.h:1.15 xc/extras/Mesa/src/mmath.h:1.19
--- xc/extras/Mesa/src/mmath.h:1.15	Mon Jan  7 12:26:06 2002
+++ xc/extras/Mesa/src/mmath.h	Mon Nov 25 09:04:49 2002
@@ -1,20 +1,20 @@
-/* $XFree86: xc/extras/Mesa/src/mmath.h,v 1.15 2002/01/07 17:26:06 alanh Exp $ */
+
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -36,61 +36,61 @@
 
 
 #include "glheader.h"
-
+/* Do not reference mtypes.h from this file.
+ */
 
 /*
  * Set the x86 FPU control word to guarentee only 32 bits of presision
  * are stored in registers.  Allowing the FPU to store more introduces
  * differences between situations where numbers are pulled out of memory
  * vs. situations where the compiler is able to optimize register usage.
- * 
+ *
  * In the worst case, we force the compiler to use a memory access to
  * truncate the float, by specifying the 'volatile' keyword.
  */
-#if defined(__linux__) && defined(__i386__)
-#include <fpu_control.h>
-
-#if !defined(_FPU_SETCW)
-#define _FPU_SETCW __setfpucw
-typedef unsigned short fpu_control_t;
-#endif
+#if defined(__GNUC__) && defined(__i386__)
 
-#if !defined(_FPU_GETCW)
-#define _FPU_GETCW(a) (a) = __fpu_control;
-#endif
+/* Hardware default: All exceptions masked, extended double precision,
+ * round to nearest.  IEEE compliant.
+ */
+#define DEFAULT_X86_FPU		0x037f
 
-/* Set it up how we want it.
+/* All exceptions masked, single precision, round to nearest.
  */
-#if !defined(NO_FAST_MATH) 
-#define START_FAST_MATH(x)                  \
-   {								\
-      static fpu_control_t mask = _FPU_SINGLE | _FPU_MASK_IM	\
-            | _FPU_MASK_DM | _FPU_MASK_ZM | _FPU_MASK_OM	\
-            | _FPU_MASK_UM | _FPU_MASK_PM;			\
-      _FPU_GETCW( x );						\
-      _FPU_SETCW( mask );					\
-   }
+#define FAST_X86_FPU		0x003f
+
+/* Set it up how we want it.  The fldcw instruction will cause any
+ * pending FP exceptions to be raised prior to entering the block, and
+ * we clear any pending exceptions before exiting the block.  Hence, asm
+ * code has free reign over the FPU while in the fast math block.
+ */
+#if defined(NO_FAST_MATH)
+#define START_FAST_MATH(x)						\
+do {									\
+   static GLuint mask = DEFAULT_X86_FPU;				\
+   __asm__ ( "fnstcw %0" : "=m" (*&(x)) );				\
+   __asm__ ( "fldcw %0" : : "m" (mask) );				\
+} while (0)
 #else
-#define START_FAST_MATH(x)			\
-   {						\
-      static fpu_control_t mask = _FPU_DEFAULT;	\
-      _FPU_GETCW( x );				\
-      _FPU_SETCW( mask );			\
-   }
+#define START_FAST_MATH(x)						\
+do {									\
+   static GLuint mask = FAST_X86_FPU;					\
+   __asm__ ( "fnstcw %0" : "=m" (*&(x)) );				\
+   __asm__ ( "fldcw %0" : : "m" (mask) );				\
+} while (0)
 #endif
-
-
-/* Put it back how the application had it.
- */
-#define END_FAST_MATH(x)			\
-   {						\
-      _FPU_SETCW( x );				\
-   }
 
+/* Put it back how the application had it, and clear any exceptions that
+ * may have occurred in the FAST_MATH block.
+ */
+#define END_FAST_MATH(x)						\
+do {									\
+   __asm__ ( "fnclex ; fldcw %0" : : "m" (*&(x)) );			\
+} while (0)
 
 #define HAVE_FAST_MATH
 
-#elif defined(__WATCOMC__) && !defined(NO_FAST_MATH) 
+#elif defined(__WATCOMC__) && !defined(NO_FAST_MATH)
 
 /* This is the watcom specific inline assembly version of setcw and getcw */
 
@@ -108,25 +108,25 @@
     parm [esi]                          \
     modify exact [];
 
-#define START_FAST_MATH(x)  START_FAST_MATH2(& x)          
+#define START_FAST_MATH(x)  START_FAST_MATH2(& x)
 #define END_FAST_MATH(x)  END_FAST_MATH2(& x)
 
 /*
 __inline START_FAST_MATH(unsigned short x)
-    {                               
-    _asm {                          
-        fstcw   ax                  
-        mov     x , ax              
-        or      ax, 0x3f            
-        fldcw   ax                  
-        }                           
+    {
+    _asm {
+        fstcw   ax
+        mov     x , ax
+        or      ax, 0x3f
+        fldcw   ax
+        }
     }
 
-__inline END_FAST_MATH(unsigned short x)    
-    {                               
-    _asm {                          
-        fldcw   x                   
-        }                           
+__inline END_FAST_MATH(unsigned short x)
+    {
+    _asm {
+        fldcw   x
+        }
     }
 */
 #define HAVE_FAST_MATH
@@ -138,7 +138,7 @@
 /* The mac float really is a float, with the same precision as a
  * single precision 387 float.
  */
-#if defined(macintosh)
+#if defined(macintosh) || defined(__powerpc__)
 #define HAVE_FAST_MATH
 #endif
 
@@ -147,19 +147,141 @@
 
 
 /*
- * Float -> Int conversion
+ * Square root
  */
 
-#if defined(USE_X86_ASM)
-#if defined(__GNUC__) && defined(__i386__)
-static __inline__ int FloatToInt(float f)
+extern float gl_sqrt(float x);
+
+#ifdef FAST_MATH
+#if defined(__WATCOMC__) && defined(USE_X86_ASM)
+#  define GL_SQRT(X)  asm_sqrt(X)
+#else
+#  define GL_SQRT(X)  gl_sqrt(X)
+#endif
+#else
+#  define GL_SQRT(X)  sqrt(X)
+#endif
+
+
+/*
+ * Normalize a 3-element vector to unit length.
+ */
+#define NORMALIZE_3FV( V )			\
+do {						\
+   GLfloat len = LEN_SQUARED_3FV(V);		\
+   if (len) {					\
+      len = (GLfloat) (1.0 / GL_SQRT(len));	\
+      (V)[0] = (GLfloat) ((V)[0] * len);		\
+      (V)[1] = (GLfloat) ((V)[1] * len);		\
+      (V)[2] = (GLfloat) ((V)[2] * len);		\
+   }						\
+} while(0)
+
+#define LEN_3FV( V ) (GL_SQRT((V)[0]*(V)[0]+(V)[1]*(V)[1]+(V)[2]*(V)[2]))
+#define LEN_2FV( V ) (GL_SQRT((V)[0]*(V)[0]+(V)[1]*(V)[1]))
+
+#define LEN_SQUARED_3FV( V ) ((V)[0]*(V)[0]+(V)[1]*(V)[1]+(V)[2]*(V)[2])
+#define LEN_SQUARED_2FV( V ) ((V)[0]*(V)[0]+(V)[1]*(V)[1])
+
+
+/*
+ * Single precision ceiling, floor, and absolute value functions
+ */
+#if defined(__sparc__) /* XXX this probably isn't the ideal test */
+#define CEILF(x)   ceil(x)
+#define FLOORF(x)  floor(x)
+#define FABSF(x)   fabs(x)
+#else
+#define CEILF(x)   ceilf(x)
+#define FLOORF(x)  floorf(x)
+#define FABSF(x)   fabsf(x)
+#endif
+
+
+#if defined(__i386__) || defined(__sparc__) || defined(__s390x__) || \
+    defined(__powerpc__) || defined(__x86_64__) || \
+    ( defined(__alpha__) && ( defined(__IEEE_FLOAT) || !defined(VMS) ) )
+#define USE_IEEE
+#endif
+
+
+
+#define GET_FLOAT_BITS(x) ((fi_type *) &(x))->i
+
+/*
+ * Float -> Int conversions (rounding, floor, ceiling)
+ */
+
+#if defined(USE_SPARC_ASM) && defined(__GNUC__) && defined(__sparc__)
+
+static INLINE int iround(float f)
+{
+       int r;
+       __asm__ ("fstoi %1, %0" : "=f" (r) : "f" (f));
+       return r;
+}
+
+#define IROUND(x)  iround(x)
+
+#elif defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__)
+
+
+static INLINE int iround(float f)
 {
    int r;
    __asm__ ("fistpl %0" : "=m" (r) : "t" (f) : "st");
    return r;
+}
+
+#define IROUND(x)  iround(x)
+
+/*
+ * IEEE floor for computers that round to nearest or even.
+ * 'f' must be between -4194304 and 4194303.
+ * This floor operation is done by "(iround(f + .5) + iround(f - .5)) >> 1",
+ * but uses some IEEE specific tricks for better speed.
+ * Contributed by Josh Vanderhoof
+ */
+static INLINE int ifloor(float f)
+{
+   int ai, bi;
+   double af, bf;
+   af = (3 << 22) + 0.5 + (double)f;
+   bf = (3 << 22) + 0.5 - (double)f;
+   /* GCC generates an extra fstp/fld without this. */
+   __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st");
+   __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st");
+   return (ai - bi) >> 1;
 }
-#elif  defined(__MSC__) && defined(__WIN32__) && !defined(__CYGWIN__)
-static __inline int FloatToInt(float f)
+
+#define IFLOOR(x)  ifloor(x)
+
+/*
+ * IEEE ceil for computers that round to nearest or even.
+ * 'f' must be between -4194304 and 4194303.
+ * This ceil operation is done by "(iround(f + .5) + iround(f - .5) + 1) >> 1",
+ * but uses some IEEE specific tricks for better speed.
+ * Contributed by Josh Vanderhoof
+ */
+static INLINE int iceil(float f)
+{
+   int ai, bi;
+   double af, bf;
+   af = (3 << 22) + 0.5 + (double)f;
+   bf = (3 << 22) + 0.5 - (double)f;
+   /* GCC generates an extra fstp/fld without this. */
+   __asm__ ("fstps %0" : "=m" (ai) : "t" (af) : "st");
+   __asm__ ("fstps %0" : "=m" (bi) : "t" (bf) : "st");
+   return (ai - bi + 1) >> 1;
+}
+
+#define ICEIL(x)  iceil(x)
+
+
+#elif defined(USE_X86_ASM) && defined(__MSC__) && defined(__WIN32__)
+
+
+static INLINE int iround(float f)
 {
    int r;
    _asm {
@@ -168,179 +290,311 @@
 	}
    return r;
 }
-#elif defined(__WATCOMC__)
-long FloatToInt(float f);
-#pragma aux FloatToInt =                \
+
+#define IROUND(x)  iround(x)
+
+
+#elif defined(USE_X86_ASM) && defined(__WATCOMC__)
+
+
+long iround(float f);
+#pragma aux iround =                        \
 	"push   eax"                        \
 	"fistp  dword ptr [esp]"            \
 	"pop    eax"                        \
 	parm [8087]                         \
 	value [eax]                         \
 	modify exact [eax];
+
+#define IROUND(x)  iround(x)
+
 float asm_sqrt (float x);
-#pragma aux asm_sqrt =                  \
+#pragma aux asm_sqrt =                      \
 	"fsqrt"                             \
 	parm [8087]                         \
 	value [8087]                        \
 	modify exact [];
-#else
-#define FloatToInt(F) ((int) (F))
+
+
+#endif /* assembly/optimized IROUND, IROUND_POS, IFLOOR, ICEIL macros */
+
+
+/* default IROUND macro */
+#ifndef IROUND
+#define IROUND(f)  ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))
 #endif
+
+
+/* default IROUND_POS macro */
+#ifndef IROUND_POS
+#ifdef DEBUG
+#define IROUND_POS(f) (ASSERT((f) >= 0.0F), IROUND(f))
 #else
-#define FloatToInt(F) ((int) (F))
+#define IROUND_POS(f) (IROUND(f))
 #endif
+#endif /* IROUND_POS */
 
 
-/*
- * Square root
- */
-
-extern float gl_sqrt(float x);
-    
-#ifdef FAST_MATH
-#if defined (__WATCOMC__) && defined(USE_X86_ASM)
-#  define GL_SQRT(X)  asm_sqrt(X)
+/* default IFLOOR macro */
+#ifndef IFLOOR
+static INLINE int ifloor(float f)
+{
+#ifdef USE_IEEE
+   int ai, bi;
+   double af, bf;
+   union { int i; float f; } u;
+
+   af = (3 << 22) + 0.5 + (double)f;
+   bf = (3 << 22) + 0.5 - (double)f;
+   u.f = af; ai = u.i;
+   u.f = bf; bi = u.i;
+   return (ai - bi) >> 1;
 #else
-#  define GL_SQRT(X)  gl_sqrt(X)
+   int i = IROUND(f);
+   return (i > f) ? i - 1 : i;
 #endif
+}
+#define IFLOOR(x)  ifloor(x)
+#endif /* IFLOOR */
+
+
+/* default ICEIL macro */
+#ifndef ICEIL
+static INLINE int iceil(float f)
+{
+#ifdef USE_IEEE
+   int ai, bi;
+   double af, bf;
+   union { int i; float f; } u;
+   af = (3 << 22) + 0.5 + (double)f;
+   bf = (3 << 22) + 0.5 - (double)f;
+   u.f = af; ai = u.i;
+   u.f = bf; bi = u.i;
+   return (ai - bi + 1) >> 1;
 #else
-#  define GL_SQRT(X)  sqrt(X)
+   int i = IROUND(f);
+   return (i < f) ? i + 1 : i;
 #endif
+}
+#define ICEIL(x)  iceil(x)
+#endif /* ICEIL */
 
 
+
 /*
- * Normalize a 3-element vector to unit length.
+ * Convert unclamped or clamped ([0,1]) floats to ubytes for color
+ * conversion only.  These functions round to the nearest int.
  */
-#define NORMALIZE_3FV( V )			\
-do {						\
-   GLdouble len = LEN_SQUARED_3FV(V);		\
-   if (len > 1e-50) {				\
-      len = 1.0 / GL_SQRT(len);			\
-      V[0] = (GLfloat) (V[0] * len);		\
-      V[1] = (GLfloat) (V[1] * len);		\
-      V[2] = (GLfloat) (V[2] * len);		\
-   }						\
-} while(0)
-
-#define LEN_3FV( V ) (GL_SQRT(V[0]*V[0]+V[1]*V[1]+V[2]*V[2]))
+#define IEEE_ONE 0x3f800000
+#define IEEE_0996 0x3f7f0000	/* 0.996 or something??? used in macro
+                                   below only */
 
-#define LEN_SQUARED_3FV( V ) (V[0]*V[0]+V[1]*V[1]+V[2]*V[2])
+#if defined(USE_IEEE) && !defined(DEBUG)
 
 /*
- * Optimization for:
- * GLfloat f;
- * GLubyte b = FloatToInt(CLAMP(f, 0, 1) * 255)
+ * This function/macro is sensitive to precision.  Test carefully
+ * if you change it.
  */
+#define UNCLAMPED_FLOAT_TO_UBYTE(b, f)					\
+        do {								\
+           union { GLfloat r; GLuint i; } __tmp;			\
+           __tmp.r = (f);						\
+           b = ((__tmp.i >= IEEE_0996)				\
+               ? ((GLint)__tmp.i < 0) ? (GLubyte)0 : (GLubyte)255	\
+               : (__tmp.r = __tmp.r*(255.0F/256.0F) + 32768.0F,		\
+                  (GLubyte)__tmp.i));					\
+        } while (0)
 
-#if defined(__i386__) || defined(__sparc__) || defined(__s390x__) || \
-    defined(__ppc__) || defined(__powerpc__) || \
-    ( defined(__alpha__) && ( defined( __IEEE_FLOAT ) || !defined( VMS ) ) )
-#define USE_IEEE
-#define IEEE_ONE 0x3f7f0000
-#endif
+#define CLAMPED_FLOAT_TO_UBYTE(b, f) \
+        UNCLAMPED_FLOAT_TO_UBYTE(b, f)
 
-#if defined(USE_IEEE) && !defined(DEBUG)
+#define COPY_FLOAT( dst, src )					\
+	((fi_type *) &(dst))->i = ((fi_type *) &(src))->i
 
-#define CLAMP_FLOAT_COLOR(f)			\
-	do {					\
-	   if (*(GLuint *)&f >= IEEE_ONE)	\
-	      f = (*(GLint *)&f < 0) ? 0 : 1;	\
-	} while(0)
-
-#define CLAMP_FLOAT_COLOR_VALUE(f)		\
-    ( (*(GLuint *)&f >= IEEE_ONE)		\
-      ? ((*(GLint *)&f < 0) ? 0 : 1)		\
-      : f )
+#else /* USE_IEEE */
 
-/* 
- * This function/macro is sensitive to precision.  Test carefully
- * if you change it.
+#define UNCLAMPED_FLOAT_TO_UBYTE(b, f) \
+	b = ((GLubyte) IROUND(CLAMP(f, 0.0F, 1.0F) * 255.0F))
+
+#define CLAMPED_FLOAT_TO_UBYTE(b, f) \
+	b = ((GLubyte) IROUND((f) * 255.0F))
+
+#define COPY_FLOAT( dst, src )		(dst) = (src)
+
+#endif /* USE_IEEE */
+
+
+
+/*
+ * Integer / float conversion for colors, normals, etc.
  */
-#define FLOAT_COLOR_TO_UBYTE_COLOR(b, f)                        \
-        do {                                                    \
-           union { GLfloat r; GLuint i; } tmp;                  \
-           tmp.r = f;                                           \
-           b = ((tmp.i >= IEEE_ONE)                             \
-               ? ((GLint)tmp.i < 0) ? (GLubyte)0 : (GLubyte)255 \
-               : (tmp.r = tmp.r*(255.0F/256.0F) + 32768.0F,     \
-                  (GLubyte)tmp.i));                             \
-        } while (0)
 
+/* Convert GLubyte in [0,255] to GLfloat in [0.0,1.0] */
+extern float _mesa_ubyte_to_float_color_tab[256];
+#define UBYTE_TO_FLOAT(u) _mesa_ubyte_to_float_color_tab[(unsigned int)(u)]
 
-#define CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(b,f) \
-         FLOAT_COLOR_TO_UBYTE_COLOR(b, f)
+/* Convert GLfloat in [0.0,1.0] to GLubyte in [0,255] */
+#define FLOAT_TO_UBYTE(X)	((GLubyte) (GLint) ((X) * 255.0F))
 
-#else
 
-#define CLAMP_FLOAT_COLOR(f) \
-        (void) CLAMP_SELF(f,0,1)
+/* Convert GLbyte in [-128,127] to GLfloat in [-1.0,1.0] */
+#define BYTE_TO_FLOAT(B)	((2.0F * (B) + 1.0F) * (1.0F/255.0F))
 
-#define CLAMP_FLOAT_COLOR_VALUE(f) \
-        CLAMP(f,0,1)
-       
-#define FLOAT_COLOR_TO_UBYTE_COLOR(b, f)			\
-	b = ((GLubyte) FloatToInt(CLAMP(f, 0.0F, 1.0F) * 255.0F))
+/* Convert GLfloat in [-1.0,1.0] to GLbyte in [-128,127] */
+#define FLOAT_TO_BYTE(X)	( (((GLint) (255.0F * (X))) - 1) / 2 )
 
-#define CLAMPED_FLOAT_COLOR_TO_UBYTE_COLOR(b,f) \
-	b = ((GLubyte) FloatToInt(f * 255.0F))
 
-#endif
+/* Convert GLushort in [0,65536] to GLfloat in [0.0,1.0] */
+#define USHORT_TO_FLOAT(S)	((GLfloat) (S) * (1.0F / 65535.0F))
 
-#ifdef USE_IEEE
-/* Returns TRUE for x == Inf or x == NaN. */
-static INLINE int IS_INF_OR_NAN( float x )
-{
-   union {float f; int i;} tmp;
-   tmp.f = x;
-   return !(int)((unsigned int)((tmp.i & 0x7fffffff)-0x7f800000) >> 31);
-}
-#else
-#define IS_INF_OR_NAN(x)        (!finite(x)) 
-#endif
+/* Convert GLfloat in [0.0,1.0] to GLushort in [0,65536] */
+#define FLOAT_TO_USHORT(X)	((GLushort) (GLint) ((X) * 65535.0F))
 
-extern float gl_ubyte_to_float_color_tab[256];
-extern float gl_ubyte_to_float_255_color_tab[256];
-#define UBYTE_COLOR_TO_FLOAT_COLOR(c) gl_ubyte_to_float_color_tab[c]
 
-#define UBYTE_COLOR_TO_FLOAT_255_COLOR(c) gl_ubyte_to_float_255_color_tab[c]
+/* Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0] */
+#define SHORT_TO_FLOAT(S)	((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
 
-#define UBYTE_COLOR_TO_FLOAT_255_COLOR2(f,c) \
-    (*(int *)&(f)) = ((int *)gl_ubyte_to_float_255_color_tab)[c]
+/* Convert GLfloat in [0.0,1.0] to GLshort in [-32768,32767] */
+#define FLOAT_TO_SHORT(X)	( (((GLint) (65535.0F * (X))) - 1) / 2 )
 
 
-#define UBYTE_RGBA_TO_FLOAT_RGBA(f,b) 		\
-do {						\
-   f[0] = UBYTE_COLOR_TO_FLOAT_COLOR(b[0]);	\
-   f[1] = UBYTE_COLOR_TO_FLOAT_COLOR(b[1]);	\
-   f[2] = UBYTE_COLOR_TO_FLOAT_COLOR(b[2]);	\
-   f[3] = UBYTE_COLOR_TO_FLOAT_COLOR(b[3]);	\
-} while(0)
+/* Convert GLuint in [0,4294967295] to GLfloat in [0.0,1.0] */
+#define UINT_TO_FLOAT(U)	((GLfloat) (U) * (1.0F / 4294967295.0F))
 
+/* Convert GLfloat in [0.0,1.0] to GLuint in [0,4294967295] */
+#define FLOAT_TO_UINT(X)	((GLuint) ((X) * 4294967295.0))
 
-#define UBYTE_RGBA_TO_FLOAT_255_RGBA(f,b) 		\
-do {						\
-   f[0] = UBYTE_COLOR_TO_FLOAT_255_COLOR(b[0]);	\
-   f[1] = UBYTE_COLOR_TO_FLOAT_255_COLOR(b[1]);	\
-   f[2] = UBYTE_COLOR_TO_FLOAT_255_COLOR(b[2]);	\
-   f[3] = UBYTE_COLOR_TO_FLOAT_255_COLOR(b[3]);	\
-} while(0)
+
+/* Convert GLint in [-2147483648,2147483647] to GLfloat in [-1.0,1.0] */
+#define INT_TO_FLOAT(I)		((2.0F * (I) + 1.0F) * (1.0F/4294967294.0F))
+
+/* Convert GLfloat in [-1.0,1.0] to GLint in [-2147483648,2147483647] */
+/* causes overflow:
+#define FLOAT_TO_INT(X)		( (((GLint) (4294967294.0F * (X))) - 1) / 2 )
+*/
+/* a close approximation: */
+#define FLOAT_TO_INT(X)		( (GLint) (2147483647.0 * (X)) )
+
 
-#define FLOAT_RGBA_TO_UBYTE_RGBA(b,f) 		\
+#define BYTE_TO_UBYTE(b)   ((GLubyte) ((b) < 0 ? 0 : (GLubyte) (b)))
+#define SHORT_TO_UBYTE(s)  ((GLubyte) ((s) < 0 ? 0 : (GLubyte) ((s) >> 7)))
+#define USHORT_TO_UBYTE(s) ((GLubyte) ((s) >> 8))
+#define INT_TO_UBYTE(i)    ((GLubyte) ((i) < 0 ? 0 : (GLubyte) ((i) >> 23)))
+#define UINT_TO_UBYTE(i)   ((GLubyte) ((i) >> 24))
+
+
+#define BYTE_TO_USHORT(b)  ((b) < 0 ? 0 : ((GLushort) (((b) * 65535) / 255)))
+#define UBYTE_TO_USHORT(b) (((GLushort) (b) << 8) | (GLushort) (b))
+#define SHORT_TO_USHORT(s) ((s) < 0 ? 0 : ((GLushort) (((s) * 65535 / 32767))))
+#define INT_TO_USHORT(i)   ((i) < 0 ? 0 : ((GLushort) ((i) >> 15)))
+#define UINT_TO_USHORT(i)  ((i) < 0 ? 0 : ((GLushort) ((i) >> 16)))
+#define UNCLAMPED_FLOAT_TO_USHORT(us, f)   us = (GLushort) ((f) * 65535.0F)
+
+
+
+/*
+ * Linear interpolation
+ * NOTE:  OUT argument is evaluated twice!
+ * NOTE:  Be wary of using *coord++ as an argument to any of these macros!
+ */
+#define LINTERP(T, OUT, IN)	((OUT) + (T) * ((IN) - (OUT)))
+
+/* Can do better with integer math:
+ */
+#define INTERP_UB( t, dstub, outub, inub )	\
 do {						\
-   FLOAT_COLOR_TO_UBYTE_COLOR((b[0]),(f[0]));	\
-   FLOAT_COLOR_TO_UBYTE_COLOR((b[1]),(f[1]));	\
-   FLOAT_COLOR_TO_UBYTE_COLOR((b[2]),(f[2]));	\
-   FLOAT_COLOR_TO_UBYTE_COLOR((b[3]),(f[3]));	\
-} while(0)
+   GLfloat inf = UBYTE_TO_FLOAT( inub );	\
+   GLfloat outf = UBYTE_TO_FLOAT( outub );	\
+   GLfloat dstf = LINTERP( t, outf, inf );	\
+   UNCLAMPED_FLOAT_TO_UBYTE( dstub, dstf );	\
+} while (0)
 
-#define FLOAT_RGB_TO_UBYTE_RGB(b,f) 		\
+#define INTERP_CHAN( t, dstc, outc, inc )	\
 do {						\
-   FLOAT_COLOR_TO_UBYTE_COLOR(b[0],f[0]);	\
-   FLOAT_COLOR_TO_UBYTE_COLOR(b[1],f[1]);	\
-   FLOAT_COLOR_TO_UBYTE_COLOR(b[2],f[2]);	\
+   GLfloat inf = CHAN_TO_FLOAT( inc );		\
+   GLfloat outf = CHAN_TO_FLOAT( outc );	\
+   GLfloat dstf = LINTERP( t, outf, inf );	\
+   UNCLAMPED_FLOAT_TO_CHAN( dstc, dstf );	\
+} while (0)
+
+#define INTERP_UI( t, dstui, outui, inui )	\
+   dstui = (GLuint) (GLint) LINTERP( t, (GLfloat) (outui), (GLfloat) (inui) )
+
+#define INTERP_F( t, dstf, outf, inf )		\
+   dstf = LINTERP( t, outf, inf )
+
+#define INTERP_4F( t, dst, out, in )			\
+do {							\
+   (dst)[0] = LINTERP( (t), (out)[0], (in)[0] );	\
+   (dst)[1] = LINTERP( (t), (out)[1], (in)[1] );	\
+   (dst)[2] = LINTERP( (t), (out)[2], (in)[2] );	\
+   (dst)[3] = LINTERP( (t), (out)[3], (in)[3] );	\
+} while (0)
+
+#define INTERP_3F( t, dst, out, in )			\
+do {							\
+   (dst)[0] = LINTERP( (t), (out)[0], (in)[0] );	\
+   (dst)[1] = LINTERP( (t), (out)[1], (in)[1] );	\
+   (dst)[2] = LINTERP( (t), (out)[2], (in)[2] );	\
+} while (0)
+
+#define INTERP_4CHAN( t, dst, out, in )			\
+do {							\
+   INTERP_CHAN( (t), (dst)[0], (out)[0], (in)[0] );	\
+   INTERP_CHAN( (t), (dst)[1], (out)[1], (in)[1] );	\
+   INTERP_CHAN( (t), (dst)[2], (out)[2], (in)[2] );	\
+   INTERP_CHAN( (t), (dst)[3], (out)[3], (in)[3] );	\
+} while (0)
+
+#define INTERP_3CHAN( t, dst, out, in )			\
+do {							\
+   INTERP_CHAN( (t), (dst)[0], (out)[0], (in)[0] );	\
+   INTERP_CHAN( (t), (dst)[1], (out)[1], (in)[1] );	\
+   INTERP_CHAN( (t), (dst)[2], (out)[2], (in)[2] );	\
+} while (0)
+
+#define INTERP_SZ( t, vec, to, out, in, sz )				\
+do {							       		\
+   switch (sz) {							\
+   case 4: (vec)[to][3] = LINTERP( (t), (vec)[out][3], (vec)[in][3] );	\
+   case 3: (vec)[to][2] = LINTERP( (t), (vec)[out][2], (vec)[in][2] );	\
+   case 2: (vec)[to][1] = LINTERP( (t), (vec)[out][1], (vec)[in][1] );	\
+   case 1: (vec)[to][0] = LINTERP( (t), (vec)[out][0], (vec)[in][0] );	\
+   }									\
 } while(0)
 
 
+/*
+ * Fixed point arithmetic macros
+ */
+#define FIXED_ONE       0x00000800
+#define FIXED_HALF      0x00000400
+#define FIXED_FRAC_MASK 0x000007FF
+#define FIXED_INT_MASK  (~FIXED_FRAC_MASK)
+#define FIXED_EPSILON   1
+#define FIXED_SCALE     2048.0f
+#define FIXED_SHIFT     11
+#define FloatToFixed(X) (IROUND((X) * FIXED_SCALE))
+#define IntToFixed(I)   ((I) << FIXED_SHIFT)
+#define FixedToInt(X)   ((X) >> FIXED_SHIFT)
+#define FixedToUns(X)   (((unsigned int)(X)) >> FIXED_SHIFT)
+#define FixedCeil(X)    (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK)
+#define FixedFloor(X)   ((X) & FIXED_INT_MASK)
+#define FixedToFloat(X) ((X) * (1.0F / FIXED_SCALE))
+#define PosFloatToFixed(X)      FloatToFixed(X)
+#define SignedFloatToFixed(X)   FloatToFixed(X)
+
+#ifdef USE_IEEE
+/* Returns TRUE for x == Inf or x == NaN. */
+static INLINE int IS_INF_OR_NAN( float x )
+{
+   union {float f; int i;} tmp;
+   tmp.f = x;
+   return !(int)((unsigned int)((tmp.i & 0x7fffffff)-0x7f800000) >> 31);
+}
+#else
+#define IS_INF_OR_NAN(x)        (!finite(x)) 
+#endif
 
 extern void
 _mesa_init_math(void);
Index: xc/extras/Mesa/src/mtypes.h
diff -u /dev/null xc/extras/Mesa/src/mtypes.h:1.2
--- /dev/null	Thu Feb 27 12:15:40 2003
+++ xc/extras/Mesa/src/mtypes.h	Mon Dec 16 11:18:27 2002
@@ -0,0 +1,1719 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef TYPES_H
+#define TYPES_H
+
+
+#include "glheader.h"
+#include "config.h"		/* Hardwired parameters */
+#include "glapitable.h"
+#include "glthread.h"
+
+#include "math/m_matrix.h"	/* GLmatrix */
+
+#if defined(MESA_TRACE)
+#include "Trace/tr_context.h"
+#endif
+
+
+/* Please try to mark derived values with a leading underscore ('_').
+ */
+
+/*
+ * Color channel data type:
+ */
+#if CHAN_BITS == 8
+   typedef GLubyte GLchan;
+#define CHAN_MAX 255
+#define CHAN_MAXF 255.0F
+#define CHAN_TYPE GL_UNSIGNED_BYTE
+#elif CHAN_BITS == 16
+   typedef GLushort GLchan;
+#define CHAN_MAX 65535
+#define CHAN_MAXF 65535.0F
+#define CHAN_TYPE GL_UNSIGNED_SHORT
+#elif CHAN_BITS == 32
+   typedef GLfloat GLchan;
+#define CHAN_MAX 1.0
+#define CHAN_MAXF 1.0F
+#define CHAN_TYPE GL_FLOAT
+#else
+#error  illegal number of color channel bits
+#endif
+
+
+/*
+ * Accumulation buffer data type:
+ */
+#if ACCUM_BITS==8
+   typedef GLbyte GLaccum;
+#elif ACCUM_BITS==16
+   typedef GLshort GLaccum;
+#elif ACCUM_BITS==32
+   typedef GLfloat GLaccum;
+#else
+#  error "illegal number of accumulation bits"
+#endif
+
+
+/*
+ * Stencil buffer data type:
+ */
+#if STENCIL_BITS==8
+   typedef GLubyte GLstencil;
+#  define STENCIL_MAX 0xff
+#elif STENCIL_BITS==16
+   typedef GLushort GLstencil;
+#  define STENCIL_MAX 0xffff
+#else
+#  error "illegal number of stencil bits"
+#endif
+
+
+/*
+ * Depth buffer data type:
+ */
+typedef GLuint GLdepth;  /* Must be 32-bits! */
+
+
+/*
+ * Fixed point data type:
+ */
+typedef int GLfixed;
+
+
+
+/*
+ * Some forward type declarations
+ */
+struct _mesa_HashTable;
+struct gl_texture_image;
+struct gl_texture_object;
+typedef struct __GLcontextRec GLcontext;
+typedef struct __GLcontextModesRec GLvisual;
+typedef struct gl_frame_buffer GLframebuffer;
+
+
+
+/* Maximum number of temporary vertices required for clipping.  (Used
+ * in array_cache and tnl modules).
+ */
+#define MAX_CLIPPED_VERTICES ((2 * (6 + MAX_CLIP_PLANES))+1)
+
+
+/* Data structure for color tables */
+struct gl_color_table {
+   GLenum Format;         /* GL_ALPHA, GL_RGB, GL_RGB, etc */
+   GLenum IntFormat;
+   GLuint Size;           /* number of entries (rows) in table */
+   GLvoid *Table;         /* either GLfloat * or GLchan * */
+   GLboolean FloatTable;  /* are entries stored as floats? */
+   GLubyte RedSize;
+   GLubyte GreenSize;
+   GLubyte BlueSize;
+   GLubyte AlphaSize;
+   GLubyte LuminanceSize;
+   GLubyte IntensitySize;
+};
+
+
+/*
+ * Bit flags used for updating material values.
+ */
+#define FRONT_AMBIENT_BIT     0x1
+#define BACK_AMBIENT_BIT      0x2
+#define FRONT_DIFFUSE_BIT     0x4
+#define BACK_DIFFUSE_BIT      0x8
+#define FRONT_SPECULAR_BIT   0x10
+#define BACK_SPECULAR_BIT    0x20
+#define FRONT_EMISSION_BIT   0x40
+#define BACK_EMISSION_BIT    0x80
+#define FRONT_SHININESS_BIT 0x100
+#define BACK_SHININESS_BIT  0x200
+#define FRONT_INDEXES_BIT   0x400
+#define BACK_INDEXES_BIT    0x800
+
+#define FRONT_MATERIAL_BITS	(FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT | \
+				 FRONT_DIFFUSE_BIT | FRONT_SPECULAR_BIT | \
+				 FRONT_SHININESS_BIT | FRONT_INDEXES_BIT)
+
+#define BACK_MATERIAL_BITS	(BACK_EMISSION_BIT | BACK_AMBIENT_BIT | \
+				 BACK_DIFFUSE_BIT | BACK_SPECULAR_BIT | \
+				 BACK_SHININESS_BIT | BACK_INDEXES_BIT)
+
+#define ALL_MATERIAL_BITS	(FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)
+
+
+
+/*
+ * Specular exponent and material shininess lookup table sizes:
+ */
+#define EXP_TABLE_SIZE 512
+#define SHINE_TABLE_SIZE 256
+
+struct gl_shine_tab {
+   struct gl_shine_tab *next, *prev;
+   GLfloat tab[SHINE_TABLE_SIZE+1];
+   GLfloat shininess;
+   GLuint refcount;
+};
+
+
+struct gl_light {
+   struct gl_light *next;	        /* double linked list with sentinel */
+   struct gl_light *prev;
+
+   GLfloat Ambient[4];		/* ambient color */
+   GLfloat Diffuse[4];		/* diffuse color */
+   GLfloat Specular[4];		/* specular color */
+   GLfloat EyePosition[4];	/* position in eye coordinates */
+   GLfloat EyeDirection[4];	/* spotlight dir in eye coordinates */
+   GLfloat SpotExponent;
+   GLfloat SpotCutoff;		/* in degress */
+   GLfloat _CosCutoff;		/* = MAX(0, cos(SpotCutoff)) */
+   GLfloat ConstantAttenuation;
+   GLfloat LinearAttenuation;
+   GLfloat QuadraticAttenuation;
+   GLboolean Enabled;		/* On/off flag */
+
+   /* Derived fields */
+   GLuint _Flags;		/* State */
+
+   GLfloat _Position[4];	/* position in eye/obj coordinates */
+   GLfloat _VP_inf_norm[3];	/* Norm direction to infinite light */
+   GLfloat _h_inf_norm[3];	/* Norm( _VP_inf_norm + <0,0,1> ) */
+   GLfloat _NormDirection[4];	/* normalized spotlight direction */
+   GLfloat _VP_inf_spot_attenuation;
+
+   GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  /* to replace a pow() call */
+   GLfloat _MatAmbient[2][3];	/* material ambient * light ambient */
+   GLfloat _MatDiffuse[2][3];	/* material diffuse * light diffuse */
+   GLfloat _MatSpecular[2][3];	/* material spec * light specular */
+   GLfloat _dli;		/* CI diffuse light intensity */
+   GLfloat _sli;		/* CI specular light intensity */
+};
+
+
+struct gl_lightmodel {
+   GLfloat Ambient[4];		/* ambient color */
+   GLboolean LocalViewer;	/* Local (or infinite) view point? */
+   GLboolean TwoSide;		/* Two (or one) sided lighting? */
+   GLenum ColorControl;		/* either GL_SINGLE_COLOR */
+				/* or GL_SEPARATE_SPECULAR_COLOR */
+};
+
+
+struct gl_material
+{
+   GLfloat Ambient[4];
+   GLfloat Diffuse[4];
+   GLfloat Specular[4];
+   GLfloat Emission[4];
+   GLfloat Shininess;
+   GLfloat AmbientIndex;	/* for color index lighting */
+   GLfloat DiffuseIndex;	/* for color index lighting */
+   GLfloat SpecularIndex;	/* for color index lighting */
+};
+
+
+/*
+ * Attribute structures:
+ *    We define a struct for each attribute group to make pushing and
+ *    popping attributes easy.  Also it's a good organization.
+ */
+struct gl_accum_attrib {
+   GLfloat ClearColor[4];	/* Accumulation buffer clear color */
+};
+
+
+/*
+ * Used in DrawDestMask below
+ */
+#define FRONT_LEFT_BIT  1
+#define FRONT_RIGHT_BIT 2
+#define BACK_LEFT_BIT   4
+#define BACK_RIGHT_BIT  8
+
+
+struct gl_colorbuffer_attrib {
+   GLuint ClearIndex;			/* Index to use for glClear */
+   GLchan ClearColor[4];		/* Color to use for glClear */
+
+   GLuint IndexMask;			/* Color index write mask */
+   GLubyte ColorMask[4];		/* Each flag is 0xff or 0x0 */
+
+   GLenum DrawBuffer;			/* Which buffer to draw into */
+   GLenum DriverDrawBuffer;		/* Current device driver dest buffer */
+   GLubyte DrawDestMask;		/* bitwise-OR of bitflags above */
+
+   /* alpha testing */
+   GLboolean AlphaEnabled;		/* Alpha test enabled flag */
+   GLenum AlphaFunc;			/* Alpha test function */
+   GLchan AlphaRef;			/* Alpha ref value as GLchan */
+
+   /* blending */
+   GLboolean BlendEnabled;		/* Blending enabled flag */
+   GLenum BlendSrcRGB;			/* Blending source operator */
+   GLenum BlendDstRGB;			/* Blending destination operator */
+   GLenum BlendSrcA;			/* GL_INGR_blend_func_separate */
+   GLenum BlendDstA;			/* GL_INGR_blend_func_separate */
+   GLenum BlendEquation;
+   GLfloat BlendColor[4];
+
+   /* logic op */
+   GLenum LogicOp;			/* Logic operator */
+   GLboolean IndexLogicOpEnabled;	/* Color index logic op enabled flag */
+   GLboolean ColorLogicOpEnabled;	/* RGBA logic op enabled flag */
+
+   GLboolean DitherFlag;		/* Dither enable flag */
+};
+
+
+struct gl_current_attrib {
+   /* These values valid only when FLUSH_VERTICES has been called.
+    */
+   GLfloat Normal[3];				/* Current vertex normal */
+   GLfloat Color[4];				/* Current RGBA color */
+   GLfloat SecondaryColor[4];			/* Current secondary color */
+   GLfloat FogCoord;			        /* Current Fog coord */
+   GLuint Index;				/* Current color index */
+   GLboolean EdgeFlag;				/* Current edge flag */
+   GLfloat Texcoord[MAX_TEXTURE_UNITS][4];	/* Current texture coords */
+
+   /* These values are always valid.
+    */
+   GLfloat RasterPos[4];			/* Current raster position */
+   GLfloat RasterDistance;			/* Current raster distance */
+   GLfloat RasterColor[4];			/* Current raster color */
+   GLfloat RasterSecondaryColor[4];             /* Current rast 2ndary color */
+   GLuint  RasterIndex;				/* Current raster index */
+   GLfloat *RasterTexCoord;			/* Current raster texcoord*/
+   GLfloat RasterMultiTexCoord[MAX_TEXTURE_UNITS][4];
+   GLfloat RasterFogCoord;
+   GLboolean RasterPosValid;			/* Raster po valid flag */
+};
+
+
+struct gl_depthbuffer_attrib {
+   GLenum Func;			/* Function for depth buffer compare */
+   GLfloat Clear;		/* Value to clear depth buffer to */
+   GLboolean Test;		/* Depth buffering enabled flag */
+   GLboolean Mask;		/* Depth buffer writable? */
+   GLboolean OcclusionTest;	/* GL_HP_occlusion_test */
+};
+
+
+struct gl_enable_attrib {
+   GLboolean AlphaTest;
+   GLboolean AutoNormal;
+   GLboolean Blend;
+   GLboolean ClipPlane[MAX_CLIP_PLANES];
+   GLboolean ColorMaterial;
+   GLboolean Convolution1D;
+   GLboolean Convolution2D;
+   GLboolean Separable2D;
+   GLboolean CullFace;
+   GLboolean DepthTest;
+   GLboolean Dither;
+   GLboolean Fog;
+   GLboolean Histogram;
+   GLboolean Light[MAX_LIGHTS];
+   GLboolean Lighting;
+   GLboolean LineSmooth;
+   GLboolean LineStipple;
+   GLboolean IndexLogicOp;
+   GLboolean ColorLogicOp;
+   GLboolean Map1Color4;
+   GLboolean Map1Index;
+   GLboolean Map1Normal;
+   GLboolean Map1TextureCoord1;
+   GLboolean Map1TextureCoord2;
+   GLboolean Map1TextureCoord3;
+   GLboolean Map1TextureCoord4;
+   GLboolean Map1Vertex3;
+   GLboolean Map1Vertex4;
+   GLboolean Map2Color4;
+   GLboolean Map2Index;
+   GLboolean Map2Normal;
+   GLboolean Map2TextureCoord1;
+   GLboolean Map2TextureCoord2;
+   GLboolean Map2TextureCoord3;
+   GLboolean Map2TextureCoord4;
+   GLboolean Map2Vertex3;
+   GLboolean Map2Vertex4;
+   GLboolean MinMax;
+   GLboolean Normalize;
+   GLboolean PixelTexture;
+   GLboolean PointSmooth;
+   GLboolean PolygonOffsetPoint;
+   GLboolean PolygonOffsetLine;
+   GLboolean PolygonOffsetFill;
+   GLboolean PolygonSmooth;
+   GLboolean PolygonStipple;
+   GLboolean RescaleNormals;
+   GLboolean Scissor;
+   GLboolean Stencil;
+   GLboolean MultisampleEnabled;     /* GL_ARB_multisample */
+   GLboolean SampleAlphaToCoverage;  /* GL_ARB_multisample */
+   GLboolean SampleAlphaToOne;       /* GL_ARB_multisample */
+   GLboolean SampleCoverage;         /* GL_ARB_multisample */
+   GLboolean SampleCoverageInvert;   /* GL_ARB_multisample */
+   GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */
+   GLuint Texture[MAX_TEXTURE_UNITS];
+   GLuint TexGen[MAX_TEXTURE_UNITS];
+};
+
+
+struct gl_eval_attrib {
+   /* Enable bits */
+   GLboolean Map1Color4;
+   GLboolean Map1Index;
+   GLboolean Map1Normal;
+   GLboolean Map1TextureCoord1;
+   GLboolean Map1TextureCoord2;
+   GLboolean Map1TextureCoord3;
+   GLboolean Map1TextureCoord4;
+   GLboolean Map1Vertex3;
+   GLboolean Map1Vertex4;
+   GLboolean Map2Color4;
+   GLboolean Map2Index;
+   GLboolean Map2Normal;
+   GLboolean Map2TextureCoord1;
+   GLboolean Map2TextureCoord2;
+   GLboolean Map2TextureCoord3;
+   GLboolean Map2TextureCoord4;
+   GLboolean Map2Vertex3;
+   GLboolean Map2Vertex4;
+   GLboolean AutoNormal;
+   /* Map Grid endpoints and divisions and calculated du values */
+   GLint MapGrid1un;
+   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;
+   GLint MapGrid2un, MapGrid2vn;
+   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;
+   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;
+};
+
+
+struct gl_fog_attrib {
+   GLboolean Enabled;		/* Fog enabled flag */
+   GLfloat Color[4];		/* Fog color */
+   GLfloat Density;		/* Density >= 0.0 */
+   GLfloat Start;		/* Start distance in eye coords */
+   GLfloat End;			/* End distance in eye coords */
+   GLfloat Index;		/* Fog index */
+   GLenum Mode;			/* Fog mode */
+   GLboolean ColorSumEnabled;
+   GLenum FogCoordinateSource;  /* GL_EXT_fog_coord */
+};
+
+
+struct gl_hint_attrib {
+   /* always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE */
+   GLenum PerspectiveCorrection;
+   GLenum PointSmooth;
+   GLenum LineSmooth;
+   GLenum PolygonSmooth;
+   GLenum Fog;
+   GLenum ClipVolumeClipping;   /* GL_EXT_clip_volume_hint */
+   GLenum TextureCompression;   /* GL_ARB_texture_compression */
+   GLenum GenerateMipmap;       /* GL_SGIS_generate_mipmap */
+};
+
+
+struct gl_histogram_attrib {
+   GLuint Width;				/* number of table entries */
+   GLint Format;				/* GL_ALPHA, GL_RGB, etc */
+   GLuint Count[HISTOGRAM_TABLE_SIZE][4];	/* the histogram */
+   GLboolean Sink;				/* terminate image transfer? */
+   GLubyte RedSize;				/* Bits per counter */
+   GLubyte GreenSize;
+   GLubyte BlueSize;
+   GLubyte AlphaSize;
+   GLubyte LuminanceSize;
+};
+
+
+struct gl_minmax_attrib {
+   GLenum Format;
+   GLboolean Sink;
+   GLfloat Min[4], Max[4];   /* RGBA */
+};
+
+
+struct gl_convolution_attrib {
+   GLenum Format;
+   GLenum InternalFormat;
+   GLuint Width;
+   GLuint Height;
+   GLfloat Filter[MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_HEIGHT * 4];
+};
+
+
+struct gl_light_attrib {
+   struct gl_light Light[MAX_LIGHTS];	/* Array of lights */
+   struct gl_lightmodel Model;		/* Lighting model */
+
+   /* Must flush FLUSH_VERTICES before referencing:
+    */
+   struct gl_material Material[2];	/* Material 0=front, 1=back */
+
+   GLboolean Enabled;			/* Lighting enabled flag */
+   GLenum ShadeModel;			/* GL_FLAT or GL_SMOOTH */
+   GLenum ColorMaterialFace;		/* GL_FRONT, BACK or FRONT_AND_BACK */
+   GLenum ColorMaterialMode;		/* GL_AMBIENT, GL_DIFFUSE, etc */
+   GLuint ColorMaterialBitmask;		/* bitmask formed from Face and Mode */
+   GLboolean ColorMaterialEnabled;
+
+   struct gl_light EnabledList;         /* List sentinel */
+
+   /* Derived for optimizations: */
+   GLboolean _NeedVertices;		/* Use fast shader? */
+   GLuint  _Flags;		        /* LIGHT_* flags, see below */
+   GLfloat _BaseColor[2][3];
+};
+
+
+#define LIGHT_SPOT         0x1
+#define LIGHT_LOCAL_VIEWER 0x2
+#define LIGHT_POSITIONAL   0x4
+
+#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
+
+struct gl_line_attrib {
+   GLboolean SmoothFlag;	/* GL_LINE_SMOOTH enabled? */
+   GLboolean StippleFlag;	/* GL_LINE_STIPPLE enabled? */
+   GLushort StipplePattern;	/* Stipple pattern */
+   GLint StippleFactor;		/* Stipple repeat factor */
+   GLfloat Width;		/* Line width */
+   GLfloat _Width;		/* Clamped Line width */
+};
+
+
+struct gl_list_attrib {
+   GLuint ListBase;
+};
+
+struct gl_list_opcode {
+   GLuint size;
+   void (*execute)( GLcontext *ctx, void *data );
+   void (*destroy)( GLcontext *ctx, void *data );
+   void (*print)( GLcontext *ctx, void *data );
+};
+
+#define GL_MAX_EXT_OPCODES 16
+
+struct gl_list_extensions {
+   struct gl_list_opcode opcode[GL_MAX_EXT_OPCODES];
+   GLuint nr_opcodes;
+};
+
+
+struct gl_multisample_attrib {
+   GLboolean Enabled;
+   GLboolean SampleAlphaToCoverage;
+   GLboolean SampleAlphaToOne;
+   GLboolean SampleCoverage;
+   GLfloat SampleCoverageValue;
+   GLboolean SampleCoverageInvert;
+};
+
+
+struct gl_pixel_attrib {
+   GLenum ReadBuffer;		/* src buffer for glRead/CopyPixels */
+   GLenum DriverReadBuffer;	/* Driver's current source buffer */
+   GLfloat RedBias, RedScale;
+   GLfloat GreenBias, GreenScale;
+   GLfloat BlueBias, BlueScale;
+   GLfloat AlphaBias, AlphaScale;
+   GLfloat DepthBias, DepthScale;
+   GLint IndexShift, IndexOffset;
+   GLboolean MapColorFlag;
+   GLboolean MapStencilFlag;
+   GLfloat ZoomX, ZoomY;
+   GLint MapStoSsize;		/* Size of each pixel map */
+   GLint MapItoIsize;
+   GLint MapItoRsize;
+   GLint MapItoGsize;
+   GLint MapItoBsize;
+   GLint MapItoAsize;
+   GLint MapRtoRsize;
+   GLint MapGtoGsize;
+   GLint MapBtoBsize;
+   GLint MapAtoAsize;
+   GLint MapStoS[MAX_PIXEL_MAP_TABLE];	/* Pixel map tables */
+   GLint MapItoI[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapItoR[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapItoG[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapItoB[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapItoA[MAX_PIXEL_MAP_TABLE];
+   GLubyte MapItoR8[MAX_PIXEL_MAP_TABLE];  /* converted to 8-bit color */
+   GLubyte MapItoG8[MAX_PIXEL_MAP_TABLE];
+   GLubyte MapItoB8[MAX_PIXEL_MAP_TABLE];
+   GLubyte MapItoA8[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapRtoR[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapGtoG[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapBtoB[MAX_PIXEL_MAP_TABLE];
+   GLfloat MapAtoA[MAX_PIXEL_MAP_TABLE];
+   /* GL_EXT_histogram */
+   GLboolean HistogramEnabled;
+   GLboolean MinMaxEnabled;
+   /* GL_SGIS_pixel_texture */
+   GLboolean PixelTextureEnabled;
+   GLenum FragmentRgbSource;
+   GLenum FragmentAlphaSource;
+   /* GL_SGI_color_matrix */
+   GLfloat PostColorMatrixScale[4];  /* RGBA */
+   GLfloat PostColorMatrixBias[4];   /* RGBA */
+   /* GL_SGI_color_table */
+   GLfloat ColorTableScale[4];
+   GLfloat ColorTableBias[4];
+   GLboolean ColorTableEnabled;
+   GLfloat PCCTscale[4];
+   GLfloat PCCTbias[4];
+   GLboolean PostConvolutionColorTableEnabled;
+   GLfloat PCMCTscale[4];
+   GLfloat PCMCTbias[4];
+   GLboolean PostColorMatrixColorTableEnabled;
+   /* Convolution */
+   GLboolean Convolution1DEnabled;
+   GLboolean Convolution2DEnabled;
+   GLboolean Separable2DEnabled;
+   GLfloat ConvolutionBorderColor[3][4];
+   GLenum ConvolutionBorderMode[3];
+   GLfloat ConvolutionFilterScale[3][4];
+   GLfloat ConvolutionFilterBias[3][4];
+   GLfloat PostConvolutionScale[4];  /* RGBA */
+   GLfloat PostConvolutionBias[4];   /* RGBA */
+};
+
+
+struct gl_point_attrib {
+   GLboolean SmoothFlag;	/* True if GL_POINT_SMOOTH is enabled */
+   GLfloat Size;		/* User-specified point size */
+   GLfloat _Size;		/* Size clamped to Const.Min/MaxPointSize */
+   GLfloat Params[3];		/* GL_EXT_point_parameters */
+   GLfloat MinSize, MaxSize;	/* GL_EXT_point_parameters */
+   GLfloat Threshold;		/* GL_EXT_point_parameters */
+   GLboolean _Attenuated;	/* True if Params != [1, 0, 0] */
+};
+
+
+struct gl_polygon_attrib {
+   GLenum FrontFace;		/* Either GL_CW or GL_CCW */
+   GLenum FrontMode;		/* Either GL_POINT, GL_LINE or GL_FILL */
+   GLenum BackMode;		/* Either GL_POINT, GL_LINE or GL_FILL */
+   GLboolean _FrontBit;		/*  */
+   GLboolean CullFlag;		/* Culling on/off flag */
+   GLboolean SmoothFlag;	/* True if GL_POLYGON_SMOOTH is enabled */
+   GLboolean StippleFlag;	/* True if GL_POLYGON_STIPPLE is enabled */
+   GLenum CullFaceMode;		/* Culling mode GL_FRONT or GL_BACK */
+   GLfloat OffsetFactor;	/* Polygon offset factor, from user */
+   GLfloat OffsetUnits;		/* Polygon offset units, from user */
+   GLfloat OffsetMRD;		/* = OffsetUnits * visual->MRD */
+   GLboolean OffsetPoint;	/* Offset in GL_POINT mode */
+   GLboolean OffsetLine;	/* Offset in GL_LINE mode */
+   GLboolean OffsetFill;	/* Offset in GL_FILL mode */
+   GLboolean _OffsetAny;
+};
+
+
+struct gl_scissor_attrib {
+   GLboolean Enabled;		/* Scissor test enabled? */
+   GLint X, Y;			/* Lower left corner of box */
+   GLsizei Width, Height;	/* Size of box */
+};
+
+
+struct gl_stencil_attrib {
+   GLboolean Enabled;		/* Enabled flag */
+   GLenum Function;		/* Stencil function */
+   GLenum FailFunc;		/* Fail function */
+   GLenum ZPassFunc;		/* Depth buffer pass function */
+   GLenum ZFailFunc;		/* Depth buffer fail function */
+   GLstencil Ref;		/* Reference value */
+   GLstencil ValueMask;		/* Value mask */
+   GLstencil Clear;		/* Clear value */
+   GLstencil WriteMask;		/* Write mask */
+};
+
+
+/* TexGenEnabled flags */
+#define S_BIT 1
+#define T_BIT 2
+#define R_BIT 4
+#define Q_BIT 8
+
+#define NUM_TEXTURE_TARGETS 5 /* 1D, 2D, 3D, CUBE, and RECT */
+
+/* Texture Enabled flags */
+#define TEXTURE0_1D   0x1     /* Texture unit 0 (default) */
+#define TEXTURE0_2D   0x2
+#define TEXTURE0_3D   0x4
+#define TEXTURE0_CUBE 0x8
+#define TEXTURE0_RECT 0x10
+#define TEXTURE0_ANY  (TEXTURE0_1D | TEXTURE0_2D | TEXTURE0_3D | TEXTURE0_CUBE | TEXTURE0_RECT)
+
+#define TEXTURE1_1D   (TEXTURE0_1D << 5)    /* Texture unit 1 */
+#define TEXTURE1_2D   (TEXTURE0_2D << 5)
+#define TEXTURE1_3D   (TEXTURE0_3D << 5)
+#define TEXTURE1_CUBE (TEXTURE0_CUBE << 5)
+#define TEXTURE1_RECT (TEXTURE0_RECT << 5)
+#define TEXTURE1_ANY  (TEXTURE1_1D | TEXTURE1_2D | TEXTURE1_3D | TEXTURE1_CUBE | TEXTURE1_RECT)
+
+#define TEXTURE2_1D   (TEXTURE0_1D << 10)    /* Texture unit 2 */
+#define TEXTURE2_2D   (TEXTURE0_2D << 10)
+#define TEXTURE2_3D   (TEXTURE0_3D << 10)
+#define TEXTURE2_CUBE (TEXTURE0_CUBE << 10)
+#define TEXTURE2_RECT (TEXTURE0_RECT << 10)
+#define TEXTURE2_ANY  (TEXTURE2_1D | TEXTURE2_2D | TEXTURE2_3D | TEXTURE2_CUBE | TEXTURE2_RECT)
+
+#define TEXTURE3_1D   (TEXTURE0_1D << 15)    /* Texture unit 3 */
+#define TEXTURE3_2D   (TEXTURE0_2D << 15)
+#define TEXTURE3_3D   (TEXTURE0_3D << 15)
+#define TEXTURE3_CUBE (TEXTURE0_CUBE << 15)
+#define TEXTURE3_RECT (TEXTURE0_RECT << 15)
+#define TEXTURE3_ANY  (TEXTURE3_1D | TEXTURE3_2D | TEXTURE3_3D | TEXTURE3_CUBE | TEXTURE3_RECT)
+
+#define TEXTURE4_1D   (TEXTURE0_1D << 20)    /* Texture unit 4 */
+#define TEXTURE4_2D   (TEXTURE0_2D << 20)
+#define TEXTURE4_3D   (TEXTURE0_3D << 20)
+#define TEXTURE4_CUBE (TEXTURE0_CUBE << 20)
+#define TEXTURE4_RECT (TEXTURE0_RECT << 20)
+#define TEXTURE4_ANY  (TEXTURE4_1D | TEXTURE4_2D | TEXTURE4_3D | TEXTURE4_CUBE | TEXTURE4_TECT)
+
+#define TEXTURE5_1D   (TEXTURE0_1D << 25)    /* Texture unit 5 */
+#define TEXTURE5_2D   (TEXTURE0_2D << 25)
+#define TEXTURE5_3D   (TEXTURE0_3D << 25)
+#define TEXTURE5_CUBE (TEXTURE0_CUBE << 25)
+#define TEXTURE5_RECT (TEXTURE0_CUBE << 25)
+#define TEXTURE5_ANY  (TEXTURE5_1D | TEXTURE5_2D | TEXTURE5_3D | TEXTURE5_CUBE | TEXTURE5_RECT)
+
+
+/* Bitmap versions of the GL_ constants.
+ */
+#define TEXGEN_SPHERE_MAP        0x1
+#define TEXGEN_OBJ_LINEAR        0x2
+#define TEXGEN_EYE_LINEAR        0x4
+#define TEXGEN_REFLECTION_MAP_NV 0x8
+#define TEXGEN_NORMAL_MAP_NV     0x10
+
+#define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \
+				  TEXGEN_REFLECTION_MAP_NV | \
+				  TEXGEN_NORMAL_MAP_NV)
+#define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \
+				  TEXGEN_REFLECTION_MAP_NV | \
+				  TEXGEN_NORMAL_MAP_NV     | \
+				  TEXGEN_EYE_LINEAR)
+
+
+
+/* A selection of state flags to make driver and module's lives easier.
+ */
+#define ENABLE_TEXGEN0        0x1
+#define ENABLE_TEXGEN1        0x2
+#define ENABLE_TEXGEN2        0x4
+#define ENABLE_TEXGEN3        0x8
+#define ENABLE_TEXGEN4        0x10
+#define ENABLE_TEXGEN5        0x20
+#define ENABLE_TEXGEN6        0x40
+#define ENABLE_TEXGEN7        0x80
+
+#define ENABLE_TEXMAT0        0x1	/* Ie. not the identity matrix */
+#define ENABLE_TEXMAT1        0x2
+#define ENABLE_TEXMAT2        0x4
+#define ENABLE_TEXMAT3        0x8
+#define ENABLE_TEXMAT4        0x10
+#define ENABLE_TEXMAT5        0x20
+#define ENABLE_TEXMAT6        0x40
+#define ENABLE_TEXMAT7        0x80
+
+#define ENABLE_TEXGEN(i) (ENABLE_TEXGEN0 << (i))
+#define ENABLE_TEXMAT(i) (ENABLE_TEXMAT0 << (i))
+
+/*
+ * If teximage is color-index, texelOut returns GLchan[1].
+ * If teximage is depth, texelOut returns GLfloat[1].
+ * Otherwise, texelOut returns GLchan[4].
+ */
+typedef void (*FetchTexelFunc)( const struct gl_texture_image *texImage,
+                                GLint col, GLint row, GLint img,
+                                GLvoid *texelOut );
+
+/* Texture format record */
+struct gl_texture_format {
+   GLint MesaFormat;		/* One of the MESA_FORMAT_* values */
+
+   GLenum BaseFormat;		/* Either GL_ALPHA, GL_INTENSITY, GL_LUMINANCE,
+                                 * GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA,
+                                 * GL_COLOR_INDEX or GL_DEPTH_COMPONENT.
+                                 */
+   GLenum Type;			/* Internal type as GL enum value */
+
+   GLubyte RedBits;		/* Bits per texel component */
+   GLubyte GreenBits;
+   GLubyte BlueBits;
+   GLubyte AlphaBits;
+   GLubyte LuminanceBits;
+   GLubyte IntensityBits;
+   GLubyte IndexBits;
+   GLubyte DepthBits;
+
+   GLint TexelBytes;
+
+   FetchTexelFunc FetchTexel1D;	/* Texel fetch function pointers */
+   FetchTexelFunc FetchTexel2D;
+   FetchTexelFunc FetchTexel3D;
+};
+
+/* Texture image record */
+struct gl_texture_image {
+   GLenum Format;		/* GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA,
+				 * GL_INTENSITY, GL_RGB, GL_RGBA,
+                                 * GL_COLOR_INDEX or GL_DEPTH_COMPONENT only.
+				 */
+   GLint IntFormat;		/* Internal format as given by the user */
+   GLuint Border;		/* 0 or 1 */
+   GLuint Width;		/* = 2^WidthLog2 + 2*Border */
+   GLuint Height;		/* = 2^HeightLog2 + 2*Border */
+   GLuint Depth;		/* = 2^DepthLog2 + 2*Border */
+   GLuint RowStride;		/* == Width unless IsClientData and padded */
+   GLuint Width2;		/* = Width - 2*Border */
+   GLuint Height2;		/* = Height - 2*Border */
+   GLuint Depth2;		/* = Depth - 2*Border */
+   GLuint WidthLog2;		/* = log2(Width2) */
+   GLuint HeightLog2;		/* = log2(Height2) */
+   GLuint DepthLog2;		/* = log2(Depth2) */
+   GLuint MaxLog2;		/* = MAX(WidthLog2, HeightLog2) */
+   GLvoid *Data;		/* Image data, accessed via FetchTexel() */
+   GLboolean IsClientData;      /* Data owned by client? */
+
+   const struct gl_texture_format *TexFormat;
+
+   FetchTexelFunc FetchTexel;	/* Texel fetch function pointer */
+
+   GLboolean IsCompressed;	/* GL_ARB_texture_compression */
+   GLuint CompressedSize;	/* GL_ARB_texture_compression */
+
+   /* For device driver: */
+   void *DriverData;		/* Arbitrary device driver data */
+};
+
+
+/* Texture object record */
+struct gl_texture_object {
+   _glthread_Mutex Mutex;	/* for thread safety */
+   GLint RefCount;		/* reference count */
+   GLuint Name;			/* an unsigned integer */
+   GLenum Target;               /* GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
+   GLfloat Priority;		/* in [0,1] */
+   GLchan BorderColor[4];
+   GLenum WrapS;		/* Wrap modes are: GL_CLAMP, REPEAT */
+   GLenum WrapT;		/*   GL_CLAMP_TO_EDGE, and          */
+   GLenum WrapR;		/*   GL_CLAMP_TO_BORDER_ARB         */
+   GLenum MinFilter;		/* minification filter */
+   GLenum MagFilter;		/* magnification filter */
+   GLfloat MinLod;		/* min lambda, OpenGL 1.2 */
+   GLfloat MaxLod;		/* max lambda, OpenGL 1.2 */
+   GLint BaseLevel;		/* min mipmap level, OpenGL 1.2 */
+   GLint MaxLevel;		/* max mipmap level, OpenGL 1.2 */
+   GLfloat MaxAnisotropy;	/* GL_EXT_texture_filter_anisotropic */
+   GLboolean CompareFlag;	/* GL_SGIX_shadow */
+   GLenum CompareOperator;	/* GL_SGIX_shadow */
+   GLchan ShadowAmbient;	/* GL_SGIX_shadow_ambient */
+   GLint _MaxLevel;		/* actual max mipmap level (q in the spec) */
+   GLfloat _MaxLambda;		/* = _MaxLevel - BaseLevel (q - b in spec) */
+   GLboolean GenerateMipmap;    /* GL_SGIS_generate_mipmap */
+
+   struct gl_texture_image *Image[MAX_TEXTURE_LEVELS];
+
+   /* Texture cube faces */
+   /* Image[] is alias for *PosX[MAX_TEXTURE_LEVELS]; */
+   struct gl_texture_image *NegX[MAX_TEXTURE_LEVELS];
+   struct gl_texture_image *PosY[MAX_TEXTURE_LEVELS];
+   struct gl_texture_image *NegY[MAX_TEXTURE_LEVELS];
+   struct gl_texture_image *PosZ[MAX_TEXTURE_LEVELS];
+   struct gl_texture_image *NegZ[MAX_TEXTURE_LEVELS];
+
+   /* GL_EXT_paletted_texture */
+   struct gl_color_table Palette;
+
+   GLboolean Complete;			/* Is texture object complete? */
+   struct gl_texture_object *Next;	/* Next in linked list */
+
+   /* For device driver: */
+   void *DriverData;	/* Arbitrary device driver data */
+};
+
+
+
+/*
+ * Texture units are new with the multitexture extension.
+ */
+struct gl_texture_unit {
+   GLuint Enabled;        /* bitmask of TEXTURE0_1D, _2D, _3D, _CUBE, _RECT */
+   GLuint _ReallyEnabled; /* 0 or one of TEXTURE0_1D, _2D, _3D, _CUBE, _RECT */
+
+   GLenum EnvMode;              /* GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
+   GLfloat EnvColor[4];
+   GLuint TexGenEnabled;	/* Bitwise-OR of [STRQ]_BIT values */
+   GLenum GenModeS;		/* Tex coord generation mode, either */
+   GLenum GenModeT;		/*	GL_OBJECT_LINEAR, or */
+   GLenum GenModeR;		/*	GL_EYE_LINEAR, or    */
+   GLenum GenModeQ;		/*      GL_SPHERE_MAP        */
+   GLuint _GenBitS;
+   GLuint _GenBitT;
+   GLuint _GenBitR;
+   GLuint _GenBitQ;
+   GLuint _GenFlags;		/* bitwise or of GenBit[STRQ] */
+   GLfloat ObjectPlaneS[4];
+   GLfloat ObjectPlaneT[4];
+   GLfloat ObjectPlaneR[4];
+   GLfloat ObjectPlaneQ[4];
+   GLfloat EyePlaneS[4];
+   GLfloat EyePlaneT[4];
+   GLfloat EyePlaneR[4];
+   GLfloat EyePlaneQ[4];
+   GLfloat LodBias;		/* for biasing mipmap levels */
+
+   /* GL_EXT_texture_env_combine */
+   GLenum CombineModeRGB;       /* GL_REPLACE, GL_DECAL, GL_ADD, etc. */
+   GLenum CombineModeA;         /* GL_REPLACE, GL_DECAL, GL_ADD, etc. */
+   GLenum CombineSourceRGB[3];  /* GL_PRIMARY_COLOR, GL_TEXTURE, etc. */
+   GLenum CombineSourceA[3];    /* GL_PRIMARY_COLOR, GL_TEXTURE, etc. */
+   GLenum CombineOperandRGB[3]; /* SRC_COLOR, ONE_MINUS_SRC_COLOR, etc */
+   GLenum CombineOperandA[3];   /* SRC_ALPHA, ONE_MINUS_SRC_ALPHA, etc */
+   GLuint CombineScaleShiftRGB; /* 0, 1 or 2 */
+   GLuint CombineScaleShiftA;   /* 0, 1 or 2 */
+
+   struct gl_texture_object *Current1D;
+   struct gl_texture_object *Current2D;
+   struct gl_texture_object *Current3D;
+   struct gl_texture_object *CurrentCubeMap; /* GL_ARB_texture_cube_map */
+   struct gl_texture_object *CurrentRect;    /* GL_NV_texture_rectangle */
+
+   struct gl_texture_object *_Current; /* Points to really enabled tex obj */
+
+   struct gl_texture_object Saved1D;  /* only used by glPush/PopAttrib */
+   struct gl_texture_object Saved2D;
+   struct gl_texture_object Saved3D;
+   struct gl_texture_object SavedCubeMap; /* GL_ARB_texture_cube_map */
+   struct gl_texture_object SavedRect;    /* GL_NV_texture_rectangle */
+};
+
+
+struct gl_texture_attrib {
+   /* multitexture */
+   GLuint CurrentUnit;	          /* Active texture unit */
+
+   GLuint _ReallyEnabled;     /* enables for all texture units: */
+                             /* = (Unit[0]._ReallyEnabled << 0) | */
+                             /*   (Unit[1]._ReallyEnabled << 5) | */
+	                     /*   (Unit[2]._ReallyEnabled << 10) | etc... */
+
+   GLuint _GenFlags;  /* for texgen */
+   GLuint _TexGenEnabled;	
+   GLuint _TexMatEnabled;
+
+   struct gl_texture_unit Unit[MAX_TEXTURE_UNITS];
+
+   struct gl_texture_object *Proxy1D;
+   struct gl_texture_object *Proxy2D;
+   struct gl_texture_object *Proxy3D;
+   struct gl_texture_object *ProxyCubeMap; /* GL_ARB_texture_cube_map */
+   struct gl_texture_object *ProxyRect;    /* GL_NV_texture_rectangle */
+
+   /* GL_EXT_shared_texture_palette */
+   GLboolean SharedPalette;
+   struct gl_color_table Palette;
+};
+
+
+struct gl_transform_attrib {
+   GLenum MatrixMode;				/* Matrix mode */
+   GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];
+   GLfloat _ClipUserPlane[MAX_CLIP_PLANES][4];	/* derived */
+   GLboolean ClipEnabled[MAX_CLIP_PLANES];
+   GLubyte   _AnyClip;				/* How many ClipEnabled? */
+   GLboolean Normalize;				/* Normalize all normals? */
+   GLboolean RescaleNormals;			/* GL_EXT_rescale_normal */
+   GLboolean RasterPositionUnclipped;           /* GL_IBM_rasterpos_clip */
+};
+
+
+struct gl_viewport_attrib {
+   GLint X, Y;			/* position */
+   GLsizei Width, Height;	/* size */
+   GLfloat Near, Far;		/* Depth buffer range */
+   GLmatrix _WindowMap;		/* Mapping transformation as a matrix. */
+};
+
+
+/* For the attribute stack: */
+struct gl_attrib_node {
+   GLbitfield kind;
+   void *data;
+   struct gl_attrib_node *next;
+};
+
+
+/*
+ * Client pixel packing/unpacking attributes
+ */
+struct gl_pixelstore_attrib {
+   GLint Alignment;
+   GLint RowLength;
+   GLint SkipPixels;
+   GLint SkipRows;
+   GLint ImageHeight;     /* for GL_EXT_texture3D */
+   GLint SkipImages;      /* for GL_EXT_texture3D */
+   GLboolean SwapBytes;
+   GLboolean LsbFirst;
+   GLboolean ClientStorage; /* GL_APPLE_client_storage */
+   GLboolean Invert;        /* GL_MESA_pack_invert */
+};
+
+
+#define CA_CLIENT_DATA     0x1	/* Data not alloced by mesa */
+
+
+/*
+ * Client vertex array attributes
+ */
+struct gl_client_array {
+   GLint Size;
+   GLenum Type;
+   GLsizei Stride;		/* user-specified stride */
+   GLsizei StrideB;		/* actual stride in bytes */
+   void *Ptr;
+   GLuint Flags;
+   GLboolean Enabled;
+};
+
+
+struct gl_array_attrib {
+   struct gl_client_array Vertex;	     /* client data descriptors */
+   struct gl_client_array Normal;
+   struct gl_client_array Color;
+   struct gl_client_array SecondaryColor;
+   struct gl_client_array FogCoord;
+   struct gl_client_array Index;
+   struct gl_client_array TexCoord[MAX_TEXTURE_UNITS];
+   struct gl_client_array EdgeFlag;
+
+   GLint TexCoordInterleaveFactor;
+   GLint ActiveTexture;		/* Client Active Texture */
+   GLuint LockFirst;
+   GLuint LockCount;
+
+   GLuint _Enabled;		/* _NEW_ARRAY_* - bit set if array enabled */
+   GLuint NewState;		/* _NEW_ARRAY_* */
+};
+
+
+struct gl_feedback {
+   GLenum Type;
+   GLuint _Mask;		/* FB_* bits */
+   GLfloat *Buffer;
+   GLuint BufferSize;
+   GLuint Count;
+};
+
+
+struct gl_selection {
+   GLuint *Buffer;
+   GLuint BufferSize;	/* size of SelectBuffer */
+   GLuint BufferCount;	/* number of values in SelectBuffer */
+   GLuint Hits;		/* number of records in SelectBuffer */
+   GLuint NameStackDepth;
+   GLuint NameStack[MAX_NAME_STACK_DEPTH];
+   GLboolean HitFlag;
+   GLfloat HitMinZ, HitMaxZ;
+};
+
+
+/*
+ * 1-D Evaluator control points
+ */
+struct gl_1d_map {
+   GLuint Order;	/* Number of control points */
+   GLfloat u1, u2, du;	/* u1, u2, 1.0/(u2-u1) */
+   GLfloat *Points;	/* Points to contiguous control points */
+};
+
+
+/*
+ * 2-D Evaluator control points
+ */
+struct gl_2d_map {
+   GLuint Uorder;		/* Number of control points in U dimension */
+   GLuint Vorder;		/* Number of control points in V dimension */
+   GLfloat u1, u2, du;
+   GLfloat v1, v2, dv;
+   GLfloat *Points;		/* Points to contiguous control points */
+};
+
+
+/*
+ * All evalutator control points
+ */
+struct gl_evaluators {
+   /* 1-D maps */
+   struct gl_1d_map Map1Vertex3;
+   struct gl_1d_map Map1Vertex4;
+   struct gl_1d_map Map1Index;
+   struct gl_1d_map Map1Color4;
+   struct gl_1d_map Map1Normal;
+   struct gl_1d_map Map1Texture1;
+   struct gl_1d_map Map1Texture2;
+   struct gl_1d_map Map1Texture3;
+   struct gl_1d_map Map1Texture4;
+
+   /* 2-D maps */
+   struct gl_2d_map Map2Vertex3;
+   struct gl_2d_map Map2Vertex4;
+   struct gl_2d_map Map2Index;
+   struct gl_2d_map Map2Color4;
+   struct gl_2d_map Map2Normal;
+   struct gl_2d_map Map2Texture1;
+   struct gl_2d_map Map2Texture2;
+   struct gl_2d_map Map2Texture3;
+   struct gl_2d_map Map2Texture4;
+};
+
+
+/*
+ * State which can be shared by multiple contexts:
+ */
+struct gl_shared_state {
+   _glthread_Mutex Mutex;		   /* for thread safety */
+   GLint RefCount;			   /* Reference count */
+   struct _mesa_HashTable *DisplayList;	   /* Display lists hash table */
+   struct _mesa_HashTable *TexObjects;	   /* Texture objects hash table */
+   struct gl_texture_object *TexObjectList;/* Linked list of texture objects */
+
+   /* Default texture objects (shared by all multi-texture units) */
+   struct gl_texture_object *Default1D;
+   struct gl_texture_object *Default2D;
+   struct gl_texture_object *Default3D;
+   struct gl_texture_object *DefaultCubeMap;
+   struct gl_texture_object *DefaultRect;
+
+   void *DriverData;  /* Device driver shared state */
+};
+
+
+/*
+ * A "frame buffer" is a color buffer and its optional ancillary buffers:
+ * depth, accum, stencil, and software-simulated alpha buffers.
+ * In C++ terms, think of this as a base class from which device drivers
+ * will make derived classes.
+ */
+struct gl_frame_buffer {
+   GLvisual Visual;		/* The corresponding visual */
+
+   GLuint Width, Height;	/* size of frame buffer in pixels */
+
+   GLboolean UseSoftwareDepthBuffer;
+   GLboolean UseSoftwareAccumBuffer;
+   GLboolean UseSoftwareStencilBuffer;
+   GLboolean UseSoftwareAlphaBuffers;
+
+   /* Software depth (aka Z) buffer */
+   GLvoid *DepthBuffer;		/* array [Width*Height] of GLushort or GLuint*/
+
+   /* Software stencil buffer */
+   GLstencil *Stencil;		/* array [Width*Height] of GLstencil values */
+
+   /* Software accumulation buffer */
+   GLaccum *Accum;		/* array [4*Width*Height] of GLaccum values */
+
+   /* Software alpha planes */
+   GLchan *FrontLeftAlpha;	/* array [Width*Height] of GLubyte */
+   GLchan *BackLeftAlpha;	/* array [Width*Height] of GLubyte */
+   GLchan *FrontRightAlpha;	/* array [Width*Height] of GLubyte */
+   GLchan *BackRightAlpha;	/* array [Width*Height] of GLubyte */
+   GLchan *Alpha;		/* Points to current alpha buffer */
+
+   /* Drawing bounds: intersection of window size and scissor box */
+   GLint _Xmin, _Ymin;  /* inclusive */
+   GLint _Xmax, _Ymax;  /* exclusive */
+};
+
+
+/*
+ * Constants which may be overriden by device driver during context creation
+ * but are never changed after that.
+ */
+struct gl_constants {
+   GLint MaxTextureLevels;
+   GLint Max3DTextureLevels;
+   GLint MaxCubeTextureLevels;          /* GL_ARB_texture_cube_map */
+   GLint MaxTextureRectSize;            /* GL_NV_texture_rectangle */
+   GLuint MaxTextureUnits;
+   GLfloat MaxTextureMaxAnisotropy;	/* GL_EXT_texture_filter_anisotropic */
+   GLfloat MaxTextureLodBias;           /* GL_EXT_texture_lod_bias */
+   GLuint MaxArrayLockSize;
+   GLint SubPixelBits;
+   GLfloat MinPointSize, MaxPointSize;		/* aliased */
+   GLfloat MinPointSizeAA, MaxPointSizeAA;	/* antialiased */
+   GLfloat PointSizeGranularity;
+   GLfloat MinLineWidth, MaxLineWidth;		/* aliased */
+   GLfloat MinLineWidthAA, MaxLineWidthAA;	/* antialiased */
+   GLfloat LineWidthGranularity;
+   GLuint NumAuxBuffers;
+   GLuint MaxColorTableSize;
+   GLuint MaxConvolutionWidth;
+   GLuint MaxConvolutionHeight;
+   GLuint NumCompressedTextureFormats;	/* GL_ARB_texture_compression */
+   GLenum CompressedTextureFormats[MAX_COMPRESSED_TEXTURE_FORMATS];
+   GLuint MaxClipPlanes;
+   GLuint MaxLights;
+};
+
+
+/*
+ * List of extensions.
+ */
+struct extension;
+struct gl_extensions {
+   char *ext_string;
+   struct extension *ext_list;
+   /* Flags to quickly test if certain extensions are available.
+    * Not every extension needs to have such a flag, but it's encouraged.
+    */
+   GLboolean ARB_imaging;
+   GLboolean ARB_multisample;
+   GLboolean ARB_multitexture;
+   GLboolean ARB_texture_border_clamp;
+   GLboolean ARB_texture_compression;
+   GLboolean ARB_texture_cube_map;
+   GLboolean ARB_texture_env_combine;
+   GLboolean ARB_texture_env_dot3;
+   GLboolean ARB_texture_mirrored_repeat;
+   GLboolean EXT_blend_color;
+   GLboolean EXT_blend_func_separate;
+   GLboolean EXT_blend_logic_op;
+   GLboolean EXT_blend_minmax;
+   GLboolean EXT_blend_subtract;
+   GLboolean EXT_clip_volume_hint;
+   GLboolean EXT_convolution;
+   GLboolean EXT_compiled_vertex_array;
+   GLboolean EXT_fog_coord;
+   GLboolean EXT_histogram;
+   GLboolean EXT_packed_pixels;
+   GLboolean EXT_paletted_texture;
+   GLboolean EXT_point_parameters;
+   GLboolean EXT_polygon_offset;
+   GLboolean EXT_rescale_normal;
+   GLboolean EXT_secondary_color;
+   GLboolean EXT_shared_texture_palette;
+   GLboolean EXT_stencil_wrap;
+   GLboolean EXT_texture3D;
+   GLboolean EXT_texture_compression_s3tc;
+   GLboolean EXT_texture_env_add;
+   GLboolean EXT_texture_env_combine;
+   GLboolean EXT_texture_env_dot3;
+   GLboolean EXT_texture_filter_anisotropic;
+   GLboolean EXT_texture_object;
+   GLboolean EXT_texture_lod_bias;
+   GLboolean EXT_vertex_array_set;
+   GLboolean HP_occlusion_test;
+   GLboolean IBM_rasterpos_clip;
+   GLboolean INGR_blend_func_separate;
+   GLboolean MESA_pack_invert;
+   GLboolean MESA_window_pos;
+   GLboolean MESA_resize_buffers;
+   GLboolean MESA_ycbcr_texture;
+   GLboolean NV_blend_square;
+   GLboolean NV_texgen_reflection;
+   GLboolean NV_texture_rectangle;
+   GLboolean SGI_color_matrix;
+   GLboolean SGI_color_table;
+   GLboolean SGIS_generate_mipmap;
+   GLboolean SGIS_pixel_texture;
+   GLboolean SGIS_texture_edge_clamp;
+   GLboolean SGIX_depth_texture;
+   GLboolean SGIX_pixel_texture;
+   GLboolean SGIX_shadow;
+   GLboolean SGIX_shadow_ambient;
+   GLboolean _3DFX_texture_compression_FXT1;
+   GLboolean APPLE_client_storage;
+};
+
+
+
+/*
+ * Bits for image transfer operations (ctx->ImageTransferState).
+ */
+#define IMAGE_SCALE_BIAS_BIT                      0x1
+#define IMAGE_SHIFT_OFFSET_BIT                    0x2
+#define IMAGE_MAP_COLOR_BIT                       0x4
+#define IMAGE_COLOR_TABLE_BIT                     0x8
+#define IMAGE_CONVOLUTION_BIT                     0x10
+#define IMAGE_POST_CONVOLUTION_SCALE_BIAS         0x20
+#define IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT    0x40
+#define IMAGE_COLOR_MATRIX_BIT                    0x80
+#define IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT   0x100
+#define IMAGE_HISTOGRAM_BIT                       0x200
+#define IMAGE_MIN_MAX_BIT                         0x400
+
+/* transfer ops up to convolution: */
+#define IMAGE_PRE_CONVOLUTION_BITS (IMAGE_SCALE_BIAS_BIT |     \
+                                    IMAGE_SHIFT_OFFSET_BIT |   \
+                                    IMAGE_MAP_COLOR_BIT |      \
+                                    IMAGE_COLOR_TABLE_BIT)
+
+/* transfer ops after convolution: */
+#define IMAGE_POST_CONVOLUTION_BITS (IMAGE_POST_CONVOLUTION_SCALE_BIAS |      \
+                                     IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT | \
+                                     IMAGE_COLOR_MATRIX_BIT |                 \
+                                     IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT |\
+                                     IMAGE_HISTOGRAM_BIT |                    \
+                                     IMAGE_MIN_MAX_BIT)
+
+
+/*
+ * Bits to indicate what state has changed.  6 unused flags.
+ */
+#define _NEW_MODELVIEW		0x1        /* ctx->ModelView */
+#define _NEW_PROJECTION		0x2        /* ctx->Projection */
+#define _NEW_TEXTURE_MATRIX	0x4        /* ctx->TextureMatrix */
+#define _NEW_COLOR_MATRIX	0x8        /* ctx->ColorMatrix */
+#define _NEW_ACCUM		0x10       /* ctx->Accum */
+#define _NEW_COLOR		0x20       /* ctx->Color */
+#define _NEW_DEPTH		0x40       /* ctx->Depth */
+#define _NEW_EVAL		0x80       /* ctx->Eval, ctx->EvalMap */
+#define _NEW_FOG		0x100      /* ctx->Fog */
+#define _NEW_HINT		0x200      /* ctx->Hint */
+#define _NEW_LIGHT		0x400      /* ctx->Light */
+#define _NEW_LINE		0x800      /* ctx->Line */
+#define _NEW_PIXEL		0x1000     /* ctx->Pixel */
+#define _NEW_POINT		0x2000     /* ctx->Point */
+#define _NEW_POLYGON		0x4000     /* ctx->Polygon */
+#define _NEW_POLYGONSTIPPLE	0x8000     /* ctx->PolygonStipple */
+#define _NEW_SCISSOR		0x10000    /* ctx->Scissor */
+#define _NEW_STENCIL		0x20000    /* ctx->Stencil */
+#define _NEW_TEXTURE		0x40000    /* ctx->Texture */
+#define _NEW_TRANSFORM		0x80000    /* ctx->Transform */
+#define _NEW_VIEWPORT		0x100000   /* ctx->Viewport */
+#define _NEW_PACKUNPACK		0x200000   /* ctx->Pack, ctx->Unpack */
+#define _NEW_ARRAY	        0x400000   /* ctx->Array */
+#define _NEW_RENDERMODE		0x800000   /* RenderMode, Feedback, Select */
+#define _NEW_BUFFERS            0x1000000  /* ctx->Visual, ctx->DrawBuffer, */
+#define _NEW_MULTISAMPLE        0x2000000  /* ctx->Multisample */
+#define _NEW_ALL ~0
+
+
+
+/* Bits to track array state changes (also used to summarize array enabled)
+ */
+#define _NEW_ARRAY_VERTEX           0x1
+#define _NEW_ARRAY_COLOR            0x2
+#define _NEW_ARRAY_NORMAL           0x4
+#define _NEW_ARRAY_INDEX            0x8
+#define _NEW_ARRAY_EDGEFLAG         0x10
+#define _NEW_ARRAY_SECONDARYCOLOR   0x20
+#define _NEW_ARRAY_FOGCOORD         0x40
+#define _NEW_ARRAY_TEXCOORD_0       0x80
+#define _NEW_ARRAY_TEXCOORD_1       0x100
+#define _NEW_ARRAY_TEXCOORD_2       0x200
+#define _NEW_ARRAY_TEXCOORD_3       0x400
+#define _NEW_ARRAY_TEXCOORD_4       0x800
+#define _NEW_ARRAY_TEXCOORD_5       0x1000
+#define _NEW_ARRAY_TEXCOORD_6       0x2000
+#define _NEW_ARRAY_TEXCOORD_7       0x4000
+#define _NEW_ARRAY_ALL              0x7fff
+
+#define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))
+
+/* A bunch of flags that we think might be useful to drivers.
+ */
+#define DD_FLATSHADE                0x1
+#define DD_SEPARATE_SPECULAR        0x2
+#define DD_TRI_CULL_FRONT_BACK      0x4 /* special case on some hw */
+#define DD_TRI_LIGHT_TWOSIDE        0x8
+#define DD_TRI_UNFILLED             0x10
+#define DD_TRI_SMOOTH               0x20
+#define DD_TRI_STIPPLE              0x40
+#define DD_TRI_OFFSET               0x80
+#define DD_LINE_SMOOTH              0x100
+#define DD_LINE_STIPPLE             0x200
+#define DD_LINE_WIDTH               0x400
+#define DD_POINT_SMOOTH             0x800
+#define DD_POINT_SIZE               0x1000
+#define DD_POINT_ATTEN              0x2000
+
+/* Define the state changes under which each of these bits might change
+ */
+#define _DD_NEW_FLATSHADE                _NEW_LIGHT
+#define _DD_NEW_SEPARATE_SPECULAR        (_NEW_LIGHT | _NEW_FOG)
+#define _DD_NEW_TRI_CULL_FRONT_BACK      _NEW_POLYGON
+#define _DD_NEW_TRI_LIGHT_TWOSIDE        _NEW_LIGHT
+#define _DD_NEW_TRI_UNFILLED             _NEW_POLYGON
+#define _DD_NEW_TRI_SMOOTH               _NEW_POLYGON
+#define _DD_NEW_TRI_STIPPLE              _NEW_POLYGON
+#define _DD_NEW_TRI_OFFSET               _NEW_POLYGON
+#define _DD_NEW_LINE_SMOOTH              _NEW_LINE
+#define _DD_NEW_LINE_STIPPLE             _NEW_LINE
+#define _DD_NEW_LINE_WIDTH               _NEW_LINE
+#define _DD_NEW_POINT_SMOOTH             _NEW_POINT
+#define _DD_NEW_POINT_SIZE               _NEW_POINT
+#define _DD_NEW_POINT_ATTEN              _NEW_POINT
+
+#define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |		\
+                                           _NEW_TEXTURE |	\
+                                           _NEW_POINT |		\
+                                           _NEW_MODELVIEW)
+
+#define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |		\
+                                           _NEW_TEXTURE)
+
+#define _IMAGE_NEW_TRANSFER_STATE         (_NEW_PIXEL | _NEW_COLOR_MATRIX)
+
+
+#define NEED_NORMALS_TEXGEN      0x1
+#define NEED_NORMALS_LIGHT       0x2
+
+#define NEED_EYE_TEXGEN          0x1
+#define NEED_EYE_LIGHT           0x2
+#define NEED_EYE_LIGHT_MODELVIEW 0x4
+#define NEED_EYE_POINT_ATTEN     0x8
+#define NEED_EYE_DRIVER          0x10
+
+
+/*
+ * Forward declaration of display list datatypes:
+ */
+union node;
+typedef union node Node;
+
+
+/* This has to be included here. */
+#include "dd.h"
+
+
+/*
+ * Core Mesa's support for tnl modules:
+ */
+#define NUM_VERTEX_FORMAT_ENTRIES (sizeof(GLvertexformat) / sizeof(void *))
+
+struct gl_tnl_module {
+   /* Vertex format to be lazily swapped into current dispatch.
+    */
+   GLvertexformat *Current;
+
+   /* Record of functions swapped out.  On restore, only need to swap
+    * these functions back in.
+    */
+   void *Swapped[NUM_VERTEX_FORMAT_ENTRIES][2];
+   GLuint SwapCount;
+};
+
+
+/*
+ * The library context:
+ */
+struct __GLcontextRec {
+   /*
+   ** Os related interfaces; these *must* be the first members of this
+   ** structure, because they are exposed to the outside world (i.e. GLX
+   ** extension).
+   */
+   __GLimports imports;
+   __GLexports exports;
+
+   /* State possibly shared with other contexts in the address space */
+   struct gl_shared_state *Shared;
+
+   /* API function pointer tables */
+   struct _glapi_table *Save;	/* Display list save funcs */
+   struct _glapi_table *Exec;	/* Execute funcs */
+   struct _glapi_table *CurrentDispatch;  /* == Save or Exec !! */
+
+   GLboolean ExecPrefersFloat;	/* What preference for color conversion? */
+   GLboolean SavePrefersFloat;
+
+   GLvisual Visual;
+   GLframebuffer *DrawBuffer;	/* buffer for writing */
+   GLframebuffer *ReadBuffer;	/* buffer for reading */
+
+   /* Driver function pointer table */
+   struct dd_function_table Driver;
+
+   void *DriverCtx;	/* Points to device driver context/state */
+   void *DriverMgrCtx;	/* Points to device driver manager (optional)*/
+
+   /* Core/Driver constants */
+   struct gl_constants Const;
+
+   /* Modelview matrix and stack */
+   GLmatrix ModelView;           /* current matrix, not stored on stack */
+   GLuint ModelViewStackDepth;
+   GLmatrix ModelViewStack[MAX_MODELVIEW_STACK_DEPTH - 1];
+
+   /* Projection matrix and stack */
+   GLmatrix ProjectionMatrix;    /* current matrix, not stored on stack */
+   GLuint ProjectionStackDepth;
+   GLmatrix ProjectionStack[MAX_PROJECTION_STACK_DEPTH - 1];
+
+   /* Combined modelview and projection matrix */
+   GLmatrix _ModelProjectMatrix;
+
+   /* Texture matrix and stack */
+   GLmatrix TextureMatrix[MAX_TEXTURE_UNITS];
+   GLuint TextureStackDepth[MAX_TEXTURE_UNITS];
+   GLmatrix TextureStack[MAX_TEXTURE_UNITS][MAX_TEXTURE_STACK_DEPTH - 1];
+
+   /* Color matrix and stack */
+   GLmatrix ColorMatrix;
+   GLuint ColorStackDepth;
+   GLmatrix ColorStack[MAX_COLOR_STACK_DEPTH - 1];
+
+   /* Display lists */
+   GLuint CallDepth;		/* Current recursion calling depth */
+   GLboolean ExecuteFlag;	/* Execute GL commands? */
+   GLboolean CompileFlag;	/* Compile GL commands into display list? */
+   Node *CurrentListPtr;	/* Head of list being compiled */
+   GLuint CurrentListNum;	/* Number of the list being compiled */
+   Node *CurrentBlock;		/* Pointer to current block of nodes */
+   GLuint CurrentPos;		/* Index into current block of nodes */
+
+   /* Extensions */
+   struct gl_extensions Extensions;
+
+   /* Renderer attribute stack */
+   GLuint AttribStackDepth;
+   struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];
+
+   /* Renderer attribute groups */
+   struct gl_accum_attrib	Accum;
+   struct gl_colorbuffer_attrib	Color;
+   struct gl_current_attrib	Current;
+   struct gl_depthbuffer_attrib	Depth;
+   struct gl_eval_attrib	Eval;
+   struct gl_fog_attrib		Fog;
+   struct gl_hint_attrib	Hint;
+   struct gl_light_attrib	Light;
+   struct gl_line_attrib	Line;
+   struct gl_list_attrib	List;
+   struct gl_multisample_attrib Multisample;
+   struct gl_pixel_attrib	Pixel;
+   struct gl_point_attrib	Point;
+   struct gl_polygon_attrib	Polygon;
+   GLuint PolygonStipple[32];
+   struct gl_scissor_attrib	Scissor;
+   struct gl_stencil_attrib	Stencil;
+   struct gl_texture_attrib	Texture;
+   struct gl_transform_attrib	Transform;
+   struct gl_viewport_attrib	Viewport;
+
+   /* Other attribute groups */
+   struct gl_histogram_attrib	Histogram;
+   struct gl_minmax_attrib	MinMax;
+   struct gl_convolution_attrib Convolution1D;
+   struct gl_convolution_attrib Convolution2D;
+   struct gl_convolution_attrib Separable2D;
+
+   /* Client attribute stack */
+   GLuint ClientAttribStackDepth;
+   struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];
+
+   /* Client attribute groups */
+   struct gl_array_attrib	Array;	/* Vertex arrays */
+   struct gl_pixelstore_attrib	Pack;	/* Pixel packing */
+   struct gl_pixelstore_attrib	Unpack;	/* Pixel unpacking */
+
+   struct gl_evaluators EvalMap;   /* All evaluators */
+   struct gl_feedback   Feedback;  /* Feedback */
+   struct gl_selection  Select;    /* Selection */
+
+   struct gl_color_table ColorTable;       /* Pre-convolution */
+   struct gl_color_table ProxyColorTable;  /* Pre-convolution */
+   struct gl_color_table PostConvolutionColorTable;
+   struct gl_color_table ProxyPostConvolutionColorTable;
+   struct gl_color_table PostColorMatrixColorTable;
+   struct gl_color_table ProxyPostColorMatrixColorTable;
+
+   GLenum ErrorValue;        /* Last error code */
+   GLenum RenderMode;        /* either GL_RENDER, GL_SELECT, GL_FEEDBACK */
+   GLuint NewState;          /* bitwise-or of _NEW_* flags */
+
+   /* Derived */
+   GLuint _TriangleCaps;      /* bitwise-or of DD_* flags */
+   GLuint _ImageTransferState;/* bitwise-or of IMAGE_*_BIT flags */
+   GLfloat _EyeZDir[3];
+   GLfloat _ModelViewInvScale;
+   GLuint _NeedEyeCoords;
+   GLuint _NeedNormals;    /* Are vertex normal vectors needed? */
+
+   struct gl_shine_tab *_ShineTable[2];  /* Active shine tables */
+   struct gl_shine_tab *_ShineTabList;   /* Mru list of inactive shine tables */
+
+   struct gl_list_extensions listext; /* driver dlist extensions */
+
+
+   GLboolean OcclusionResult;  /* GL_HP_occlusion_test */
+   GLboolean OcclusionResultSaved;  /* GL_HP_occlusion_test */
+
+   /* Z buffer stuff */
+   GLuint DepthMax;		/* Max depth buffer value */
+   GLfloat DepthMaxF;		/* Float max depth buffer value */
+   GLfloat MRD;			/* minimum resolvable difference in Z values */
+
+   /* Should 3Dfx Glide driver catch signals? */
+   GLboolean CatchSignals;
+
+   /* For debugging/development only */
+   GLboolean NoRaster;
+   GLboolean FirstTimeCurrent;
+
+   /* Dither disable via MESA_NO_DITHER env var */
+   GLboolean NoDither;
+
+   GLboolean Rendering;
+
+#if defined(MESA_TRACE)
+   struct _glapi_table *TraceDispatch;
+   trace_context_t     *TraceCtx;
+#else
+   void *TraceDispatch;
+   void *TraceCtx;
+#endif
+
+   /* Core tnl module support */
+   struct gl_tnl_module TnlModule;
+
+   /* Hooks for module contexts.  These will eventually live
+    * in the driver or elsewhere.
+    */
+   void *swrast_context;
+   void *swsetup_context;
+   void *swtnl_context;
+   void *swtnl_im;
+   void *acache_context;
+   void *aelt_context;
+};
+
+
+/* The string names for GL_POINT, GL_LINE_LOOP, etc */
+extern const char *_mesa_prim_name[GL_POLYGON+4];
+
+#ifndef MESA_DEBUG
+#define MESA_DEBUG
+#endif
+
+#ifdef MESA_DEBUG
+extern int MESA_VERBOSE;
+extern int MESA_DEBUG_FLAGS;
+#else
+# define MESA_VERBOSE 0
+# define MESA_DEBUG_FLAGS 0
+# ifndef NDEBUG
+#  define NDEBUG
+# endif
+#endif
+
+
+enum _verbose {
+   VERBOSE_VARRAY		= 0x0001,
+   VERBOSE_TEXTURE		= 0x0002,
+   VERBOSE_IMMEDIATE		= 0x0004,
+   VERBOSE_PIPELINE		= 0x0008,
+   VERBOSE_DRIVER		= 0x0010,
+   VERBOSE_STATE		= 0x0020,
+   VERBOSE_API			= 0x0040,
+   VERBOSE_DISPLAY_LIST		= 0x0100,
+   VERBOSE_LIGHTING		= 0x0200,
+   VERBOSE_PRIMS		= 0x0400,
+   VERBOSE_VERTS		= 0x0800
+};
+
+
+enum _debug {
+   DEBUG_ALWAYS_FLUSH		= 0x1
+};
+
+
+
+#define Elements(x) sizeof(x)/sizeof(*(x))
+
+#ifndef __GNUC__
+#define __FUNCTION__ "some function"
+#endif
+
+/* Eventually let the driver specify what statechanges require a flush:
+ */
+#define FLUSH_VERTICES(ctx, newstate)				\
+do {								\
+   if (MESA_VERBOSE & VERBOSE_STATE)				\
+      fprintf(stderr, "FLUSH_VERTICES in %s\n", __FUNCTION__);	\
+   if (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES)		\
+      ctx->Driver.FlushVertices(ctx, FLUSH_STORED_VERTICES);	\
+   ctx->NewState |= newstate;					\
+} while (0)
+
+#define FLUSH_CURRENT(ctx, newstate)				\
+do {								\
+   if (MESA_VERBOSE & VERBOSE_STATE)				\
+      fprintf(stderr, "FLUSH_CURRENT in %s\n", __FUNCTION__);	\
+   if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)		\
+      ctx->Driver.FlushVertices(ctx, FLUSH_UPDATE_CURRENT);	\
+   ctx->NewState |= newstate;					\
+} while (0)
+
+#define ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval)		\
+do {									\
+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\
+      _mesa_error( ctx, GL_INVALID_OPERATION, "begin/end" );		\
+      return retval;							\
+   }									\
+} while (0)
+
+#define ASSERT_OUTSIDE_BEGIN_END(ctx)					\
+do {									\
+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\
+      _mesa_error( ctx, GL_INVALID_OPERATION, "begin/end" );		\
+      return;								\
+   }									\
+} while (0)
+
+#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx)				\
+do {									\
+   ASSERT_OUTSIDE_BEGIN_END(ctx);					\
+   FLUSH_VERTICES(ctx, 0);						\
+} while (0)
+
+#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)	\
+do {									\
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval);			\
+   FLUSH_VERTICES(ctx, 0);						\
+} while (0)
+
+
+
+
+#endif /* TYPES_H */
Index: xc/extras/Mesa/src/norm_tmp.h
diff -u xc/extras/Mesa/src/norm_tmp.h:1.4 xc/extras/Mesa/src/norm_tmp.h:removed
--- xc/extras/Mesa/src/norm_tmp.h:1.4	Fri Jun 16 20:02:14 2000
+++ xc/extras/Mesa/src/norm_tmp.h	Thu Feb 27 12:15:40 2003
@@ -1,412 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-static void _XFORMAPI
-TAG(transform_normalize_normals)( const GLmatrix *mat,
-                                  GLfloat scale,
-                                  const GLvector3f *in,
-                                  const GLfloat *lengths,
-                                  const GLubyte mask[],
-                                  GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   GLfloat *m = mat->inv;
-   GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8];
-   GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9];
-   GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10];
-
-   (void) mask;
-   if (!lengths) {
-      STRIDE_LOOP {
-	 CULL_CHECK {
-	    GLfloat tx, ty, tz;
-	    {
-	       const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	       tx = ux * m0 + uy * m1 + uz * m2;
-	       ty = ux * m4 + uy * m5 + uz * m6;
-	       tz = ux * m8 + uy * m9 + uz * m10;
-	    }
-	    {
-	       GLdouble len = tx*tx + ty*ty + tz*tz;
-	       if (len > 1e-20) {
-		  GLdouble scale = 1.0 / GL_SQRT(len);
-		  out[i][0] = (GLfloat) (tx * scale);
-		  out[i][1] = (GLfloat) (ty * scale);
-		  out[i][2] = (GLfloat) (tz * scale);
-	       }
-	       else
-	       {
-		  out[i][0] = out[i][1] = out[i][2] = 0;
-	       }
-	    }
-	 }
-      }
-   }
-   else {
-      /* scale has been snapped to 1.0 if it is close.
-       */
-      if (scale != 1.0) {
-	 m0 *= scale,  m4 *= scale,  m8 *= scale;
-	 m1 *= scale,  m5 *= scale,  m9 *= scale;
-	 m2 *= scale,  m6 *= scale,  m10 *= scale;
-      }
-
-      STRIDE_LOOP {
-	 CULL_CHECK {
-	    GLfloat tx, ty, tz;
-	    {
-	       const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	       tx = ux * m0 + uy * m1 + uz * m2;
-	       ty = ux * m4 + uy * m5 + uz * m6;
-	       tz = ux * m8 + uy * m9 + uz * m10;
-	    }
-	    {
-	       GLfloat len = lengths[i];
-	       out[i][0] = tx * len;
-	       out[i][1] = ty * len;
-	       out[i][2] = tz * len;
-	    }
-	 }
-      }
-   }
-   dest->count = in->count;
-}
-
-
-static void _XFORMAPI
-TAG(transform_normalize_normals_no_rot)( const GLmatrix *mat,
-                                         GLfloat scale,
-                                         const GLvector3f *in,
-                                         const GLfloat *lengths,
-                                         const GLubyte mask[],
-                                         GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   GLfloat *m = mat->inv;
-   GLfloat m0 = m[0];
-   GLfloat m5 = m[5];
-   GLfloat m10 = m[10];
-   (void) mask;
-   if (!lengths) {
-      STRIDE_LOOP {
-	 CULL_CHECK {
-	    GLfloat tx, ty, tz;
-	    {
-	       const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	       tx = ux * m0                    ;
-	       ty =           uy * m5          ;
-	       tz =                     uz * m10;
-	    }
-	    {
-	       GLdouble len = tx*tx + ty*ty + tz*tz;
-	       if (len > 1e-20) {
-		  GLdouble scale = 1.0 / GL_SQRT(len);
-		  out[i][0] = (GLfloat) (tx * scale);
-		  out[i][1] = (GLfloat) (ty * scale);
-		  out[i][2] = (GLfloat) (tz * scale);
-	       }
-	       else
-	       {
-		  out[i][0] = out[i][1] = out[i][2] = 0;
-	       }
-	    }
-	 }
-      }
-   }
-   else {
-      /* scale has been snapped to 1.0 if it is close.
-       */
-      if (scale != 1.0) {
-	 m0 *= scale; 
-	 m5 *= scale;
-	 m10 *= scale;
-      }
-
-      STRIDE_LOOP {
-	 CULL_CHECK {
-	    GLfloat tx, ty, tz;
-	    {
-	       const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	       tx = ux * m0                    ;
-	       ty =           uy * m5          ;
-	       tz =                     uz * m10;
-	    }
-	    {
-	       GLfloat len = lengths[i];
-	       out[i][0] = tx * len;
-	       out[i][1] = ty * len;
-	       out[i][2] = tz * len;
-	    }
-	 }
-      }
-   }
-   dest->count = in->count;
-}
-
-
-static void _XFORMAPI
-TAG(transform_rescale_normals_no_rot)( const GLmatrix *mat,
-                                       GLfloat scale,
-                                       const GLvector3f *in,
-                                       const GLfloat *lengths,
-                                       const GLubyte mask[],
-                                       GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   const GLfloat *m = mat->inv;
-   GLfloat m0 = scale*m[0];
-   GLfloat m5 = scale*m[5];
-   GLfloat m10 = scale*m[10];
-   (void) lengths;
-   (void) mask;
-   STRIDE_LOOP {
-      CULL_CHECK {
-	 GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	 out[i][0] = ux * m0;
-	 out[i][1] =           uy * m5;
-	 out[i][2] =                     uz * m10;
-      }
-   }
-   dest->count = in->count;
-}
-
-static void _XFORMAPI
-TAG(transform_rescale_normals)( const GLmatrix *mat,
-                                GLfloat scale,
-                                const GLvector3f *in,
-                                const GLfloat *lengths,
-                                const GLubyte mask[],
-                                GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   /* Since we are unlikely to have < 3 vertices in the buffer,
-    * it makes sense to pre-multiply by scale.
-    */
-   const GLfloat *m = mat->inv;
-   GLfloat m0 = scale*m[0],  m4 = scale*m[4],  m8 = scale*m[8];
-   GLfloat m1 = scale*m[1],  m5 = scale*m[5],  m9 = scale*m[9];
-   GLfloat m2 = scale*m[2],  m6 = scale*m[6],  m10 = scale*m[10];
-   (void) lengths;
-   (void) mask;
-   STRIDE_LOOP {
-      CULL_CHECK {
-	 GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	 out[i][0] = ux * m0 + uy * m1 + uz * m2;
-	 out[i][1] = ux * m4 + uy * m5 + uz * m6;
-	 out[i][2] = ux * m8 + uy * m9 + uz * m10;
-      }
-   }
-   dest->count = in->count;
-}
-
-
-static void _XFORMAPI
-TAG(transform_normals_no_rot)(const GLmatrix *mat,
-                              GLfloat scale,
-                              const GLvector3f *in,
-                              const GLfloat *lengths,
-                              const GLubyte mask[],
-                              GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   const GLfloat *m = mat->inv;
-   GLfloat m0 = m[0];
-   GLfloat m5 = m[5];
-   GLfloat m10 = m[10];
-   (void) scale;
-   (void) lengths;
-   (void) mask;
-   STRIDE_LOOP {
-      CULL_CHECK {
-	 GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	 out[i][0] = ux * m0;
-	 out[i][1] =           uy * m5;
-	 out[i][2] =                     uz * m10;
-      }
-   }
-   dest->count = in->count;
-}
-
-
-static void _XFORMAPI
-TAG(transform_normals)( const GLmatrix *mat,
-                        GLfloat scale,
-                        const GLvector3f *in,
-                        const GLfloat *lengths,
-                        const GLubyte mask[],
-                        GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   const GLfloat *m = mat->inv;
-   GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8];
-   GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9];
-   GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10];
-   (void) scale;
-   (void) lengths;
-   (void) mask;
-   STRIDE_LOOP {
-      CULL_CHECK {
-	 GLfloat ux = from[0],  uy = from[1],  uz = from[2];
-	 out[i][0] = ux * m0 + uy * m1 + uz * m2;
-	 out[i][1] = ux * m4 + uy * m5 + uz * m6;
-	 out[i][2] = ux * m8 + uy * m9 + uz * m10;
-      }
-   }
-   dest->count = in->count;
-}
-
-
-static void _XFORMAPI
-TAG(normalize_normals)( const GLmatrix *mat,
-                        GLfloat scale,
-                        const GLvector3f *in,
-                        const GLfloat *lengths,
-                        const GLubyte mask[],
-                        GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   (void) mat;
-   (void) mask;
-   (void) scale;
-   if (lengths) {
-      STRIDE_LOOP {
-	 CULL_CHECK {
-	    const GLfloat x = from[0], y = from[1], z = from[2];
-	    GLfloat invlen = lengths[i];
-	    out[i][0] = x * invlen;
-	    out[i][1] = y * invlen;
-	    out[i][2] = z * invlen;
-	 }	 
-      }
-   }
-   else {
-      STRIDE_LOOP {
-	 CULL_CHECK {
-	    const GLfloat x = from[0], y = from[1], z = from[2];
-	    GLdouble len = x * x + y * y + z * z;
-	    if (len > 1e-50) {
-	       len = 1.0 / GL_SQRT(len);
-	       out[i][0] = (GLfloat) (x * len);
-	       out[i][1] = (GLfloat) (y * len);
-	       out[i][2] = (GLfloat) (z * len);
-	    }
-	    else {
-	       out[i][0] = x;
-	       out[i][1] = y;
-	       out[i][2] = z;
-	    }
-	 }	 
-      }
-   }
-   dest->count = in->count;
-}
-
-
-static void _XFORMAPI
-TAG(rescale_normals)( const GLmatrix *mat,
-                      GLfloat scale,
-                      const GLvector3f *in,
-                      const GLfloat *lengths,
-                      const GLubyte mask[],
-                      GLvector3f *dest )
-{
-   GLuint i;  
-   const GLfloat *from = in->start;
-   GLuint stride = in->stride;
-   GLuint count = in->count;
-   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
-   (void) mat;
-   (void) lengths;
-   (void) mask;
-
-   STRIDE_LOOP {
-      CULL_CHECK {
-	 SCALE_SCALAR_3V( out[i], scale, from );
-      }
-   }
-   dest->count = in->count;
-}
-
-
-static void _XFORMAPI
-TAG(init_c_norm_transform)( void )
-{
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT][IDX] = 
-      TAG(transform_normals_no_rot);
-
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE][IDX] = 
-      TAG(transform_rescale_normals_no_rot);
-
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE][IDX] = 
-      TAG(transform_normalize_normals_no_rot);
-
-   gl_normal_tab[NORM_TRANSFORM][IDX] = 
-      TAG(transform_normals);
-
-   gl_normal_tab[NORM_TRANSFORM | NORM_RESCALE][IDX] = 
-      TAG(transform_rescale_normals);
-
-   gl_normal_tab[NORM_TRANSFORM | NORM_NORMALIZE][IDX] = 
-      TAG(transform_normalize_normals);
-
-   gl_normal_tab[NORM_RESCALE][IDX] = 
-      TAG(rescale_normals);
-
-   gl_normal_tab[NORM_NORMALIZE][IDX] = 
-      TAG(normalize_normals);
-}
Index: xc/extras/Mesa/src/pb.c
diff -u xc/extras/Mesa/src/pb.c:1.7 xc/extras/Mesa/src/pb.c:removed
--- xc/extras/Mesa/src/pb.c:1.7	Mon Nov 13 18:30:50 2000
+++ xc/extras/Mesa/src/pb.c	Thu Feb 27 12:15:40 2003
@@ -1,462 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-/*
- * Pixel buffer:
- *
- * As fragments are produced (by point, line, and bitmap drawing) they
- * are accumlated in a buffer.  When the buffer is full or has to be
- * flushed (glEnd), we apply all enabled rasterization functions to the
- * pixels and write the results to the display buffer.  The goal is to
- * maximize the number of pixels processed inside loops and to minimize
- * the number of function calls.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "alpha.h"
-#include "alphabuf.h"
-#include "blend.h"
-#include "depth.h"
-#include "fog.h"
-#include "logic.h"
-#include "mem.h"
-#include "masking.h"
-#include "pb.h"
-#include "scissor.h"
-#include "stencil.h"
-#include "texture.h"
-#include "types.h"
-#endif
-
-
-
-/*
- * Allocate and initialize a new pixel buffer structure.
- */
-struct pixel_buffer *gl_alloc_pb(void)
-{
-   struct pixel_buffer *pb;
-   pb = CALLOC_STRUCT(pixel_buffer);
-   if (pb) {
-      int i, j;
-      /* set non-zero fields */
-      pb->primitive = GL_BITMAP;
-      pb->mono = GL_TRUE;
-
-      /* Set all lambda values to 0.0 since we don't do mipmapping for
-       * points or lines and want to use the level 0 texture image.
-       */
-      for (j=0;j<MAX_TEXTURE_UNITS;j++) {
-         for (i=0; i<PB_SIZE; i++) {
-            pb->lambda[j][i] = 0.0;
-         }
-      }
-   }
-   return pb;
-}
-
-
-
-/*
- * Draw to more than one color buffer (or none).
- */
-static void multi_write_index_pixels( GLcontext *ctx, GLuint n,
-                                      const GLint x[], const GLint y[],
-                                      const GLuint indexes[],
-                                      const GLubyte mask[] )
-{
-   GLuint bufferBit;
-
-   if (ctx->Color.DrawBuffer == GL_NONE)
-      return;
-
-   /* loop over four possible dest color buffers */
-   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
-      if (bufferBit & ctx->Color.DrawDestMask) {
-         GLuint indexTmp[MAX_WIDTH];
-         ASSERT(n < MAX_WIDTH);
-
-         if (bufferBit == FRONT_LEFT_BIT)
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
-         else if (bufferBit == FRONT_RIGHT_BIT)
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
-         else if (bufferBit == BACK_LEFT_BIT)
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
-         else
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
-
-         /* make copy of incoming indexes */
-         MEMCPY( indexTmp, indexes, n * sizeof(GLuint) );
-         if (ctx->Color.SWLogicOpEnabled) {
-            _mesa_logicop_ci_pixels( ctx, n, x, y, indexTmp, mask );
-         }
-         if (ctx->Color.SWmasking) {
-            _mesa_mask_index_pixels( ctx, n, x, y, indexTmp, mask );
-         }
-         (*ctx->Driver.WriteCI32Pixels)( ctx, n, x, y, indexTmp, mask );
-      }
-   }
-
-   /* restore default dest buffer */
-   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer);
-}
-
-
-
-/*
- * Draw to more than one RGBA color buffer (or none).
- */
-static void multi_write_rgba_pixels( GLcontext *ctx, GLuint n,
-                                     const GLint x[], const GLint y[],
-                                     CONST GLubyte rgba[][4],
-                                     const GLubyte mask[] )
-{
-   GLuint bufferBit;
-
-   if (ctx->Color.DrawBuffer == GL_NONE)
-      return;
-
-   /* loop over four possible dest color buffers */
-   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
-      if (bufferBit & ctx->Color.DrawDestMask) {
-         GLubyte rgbaTmp[MAX_WIDTH][4];
-         ASSERT(n < MAX_WIDTH);
-
-         if (bufferBit == FRONT_LEFT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontLeftAlpha;
-         }
-         else if (bufferBit == FRONT_RIGHT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontRightAlpha;
-         }
-         else if (bufferBit == BACK_LEFT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackLeftAlpha;
-         }
-         else {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackRightAlpha;
-         }
-
-         /* make copy of incoming colors */
-         MEMCPY( rgbaTmp, rgba, 4 * n * sizeof(GLubyte) );
-
-         if (ctx->Color.SWLogicOpEnabled) {
-            _mesa_logicop_rgba_pixels( ctx, n, x, y, rgbaTmp, mask );
-         }
-         else if (ctx->Color.BlendEnabled) {
-            _mesa_blend_pixels( ctx, n, x, y, rgbaTmp, mask );
-         }
-         if (ctx->Color.SWmasking) {
-            _mesa_mask_rgba_pixels( ctx, n, x, y, rgbaTmp, mask );
-         }
-
-         (*ctx->Driver.WriteRGBAPixels)( ctx, n, x, y, 
-					 (CONST GLubyte (*)[4])rgbaTmp, mask );
-         if (ctx->RasterMask & ALPHABUF_BIT) {
-            _mesa_write_alpha_pixels( ctx, n, x, y, 
-                                      (CONST GLubyte (*)[4])rgbaTmp, mask );
-         }
-      }
-   }
-
-   /* restore default dest buffer */
-   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer);
-}
-
-
-
-/*
- * Add specular color to primary color.  This is used only when
- * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
- */
-static void add_colors( GLuint n, GLubyte rgba[][4], CONST GLubyte spec[][3] )
-{
-   GLuint i;
-   for (i=0; i<n; i++) {
-      GLint r = rgba[i][RCOMP] + spec[i][RCOMP];
-      GLint g = rgba[i][GCOMP] + spec[i][GCOMP];
-      GLint b = rgba[i][BCOMP] + spec[i][BCOMP];
-      rgba[i][RCOMP] = MIN2(r, 255);
-      rgba[i][GCOMP] = MIN2(g, 255);
-      rgba[i][BCOMP] = MIN2(b, 255);
-   }
-}
-
-
-
-/*
- * When the pixel buffer is full, or needs to be flushed, call this
- * function.  All the pixels in the pixel buffer will be subjected
- * to texturing, scissoring, stippling, alpha testing, stenciling,
- * depth testing, blending, and finally written to the frame buffer.
- */
-void gl_flush_pb( GLcontext *ctx )
-{
-   /* Pixel colors may be changed if any of these raster ops enabled */
-   const GLuint modBits = FOG_BIT | TEXTURE_BIT | BLEND_BIT |
-                          MASKING_BIT | LOGIC_OP_BIT;
-   struct pixel_buffer *PB = ctx->PB;
-   GLubyte mask[PB_SIZE];
-
-   if (PB->count == 0)
-      goto CleanUp;
-
-   /* initialize mask array and clip pixels simultaneously */
-   {
-      GLint xmin = ctx->DrawBuffer->Xmin;
-      GLint xmax = ctx->DrawBuffer->Xmax;
-      GLint ymin = ctx->DrawBuffer->Ymin;
-      GLint ymax = ctx->DrawBuffer->Ymax;
-      GLint *x = PB->x;
-      GLint *y = PB->y;
-      GLuint i, n = PB->count;
-      for (i=0;i<n;i++) {
-         mask[i] = (x[i]>=xmin) & (x[i]<=xmax) & (y[i]>=ymin) & (y[i]<=ymax);
-      }
-   }
-
-   if (ctx->Visual->RGBAflag) {
-      /*
-       * RGBA COLOR PIXELS
-       */
-
-      /* If each pixel can be of a different color... */
-      if ((ctx->RasterMask & modBits) || !PB->mono) {
-
-	 if (ctx->Texture.ReallyEnabled) {
-            GLubyte primary_rgba[PB_SIZE][4];
-            GLint texUnit;
-
-            /* must make a copy of primary colors since they may be modified */
-            MEMCPY(primary_rgba, PB->rgba, 4 * PB->count * sizeof(GLubyte));
-
-            for (texUnit=0;texUnit<MAX_TEXTURE_UNITS;texUnit++) {
-               gl_texture_pixels( ctx, texUnit,
-                                  PB->count, PB->s[texUnit], PB->t[texUnit],
-                                  PB->u[texUnit], PB->lambda[texUnit],
-                                  primary_rgba, PB->rgba );
-            }
-	 }
-
-         if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR
-             && ctx->Light.Enabled && ctx->Texture.ReallyEnabled) {
-            /* add specular color to primary color */
-            add_colors( PB->count, PB->rgba, (CONST GLubyte (*)[3]) PB->spec );
-         }
-
-	 if (ctx->Fog.Enabled
-             && (ctx->Hint.Fog==GL_NICEST || PB->primitive==GL_BITMAP
-                 || ctx->Texture.ReallyEnabled)) {
-	    _mesa_fog_rgba_pixels( ctx, PB->count, PB->z, PB->rgba );
-	 }
-
-         /* Scissoring already done above */
-
-	 if (ctx->Color.AlphaEnabled) {
-	    if (_mesa_alpha_test( ctx, PB->count, 
-                                  (CONST GLubyte (*)[4]) PB->rgba, mask )==0) {
-	       goto CleanUp;
-	    }
-	 }
-
-	 if (ctx->Stencil.Enabled) {
-	    /* first stencil test */
-	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
-                                       PB->x, PB->y, PB->z, mask) == 0) {
-	       goto CleanUp;
-	    }
-	 }
-	 else if (ctx->Depth.Test) {
-	    /* regular depth testing */
-	    _mesa_depth_test_pixels( ctx, PB->count, PB->x, PB->y, PB->z, mask );
-	 }
-
-         
-         if (ctx->RasterMask & MULTI_DRAW_BIT) {
-            multi_write_rgba_pixels( ctx, PB->count, PB->x, PB->y,
-                                     (CONST GLubyte (*)[4])PB->rgba, mask );
-         }
-         else {
-            /* normal case: write to exactly one buffer */
-
-            if (ctx->Color.SWLogicOpEnabled) {
-               _mesa_logicop_rgba_pixels( ctx, PB->count, PB->x, PB->y,
-                                          PB->rgba, mask);
-            }
-            else if (ctx->Color.BlendEnabled) {
-               _mesa_blend_pixels( ctx, PB->count, PB->x, PB->y, PB->rgba, mask);
-            }
-            if (ctx->Color.SWmasking) {
-               _mesa_mask_rgba_pixels(ctx, PB->count, PB->x, PB->y, PB->rgba, mask);
-            }
-
-            (*ctx->Driver.WriteRGBAPixels)( ctx, PB->count, PB->x, PB->y,
-                                            (CONST GLubyte (*)[4]) PB->rgba,
-					    mask );
-            if (ctx->RasterMask & ALPHABUF_BIT) {
-               _mesa_write_alpha_pixels( ctx, PB->count, PB->x, PB->y, 
-				      (CONST GLubyte (*)[4]) PB->rgba, mask );
-            }
-         }
-      }
-      else {
-	 /* Same color for all pixels */
-
-         /* Scissoring already done above */
-
-	 if (ctx->Color.AlphaEnabled) {
-	    if (_mesa_alpha_test( ctx, PB->count, 
-                                  (CONST GLubyte (*)[4]) PB->rgba, mask )==0) {
-	       goto CleanUp;
-	    }
-	 }
-
-	 if (ctx->Stencil.Enabled) {
-	    /* first stencil test */
-	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
-                                       PB->x, PB->y, PB->z, mask) == 0) {
-	       goto CleanUp;
-	    }
-	 }
-	 else if (ctx->Depth.Test) {
-	    /* regular depth testing */
-	    _mesa_depth_test_pixels( ctx, PB->count, PB->x, PB->y, PB->z, mask );
-	 }
-
-         if (ctx->Color.DrawBuffer == GL_NONE) {
-            goto CleanUp;
-         }
-
-         if (ctx->RasterMask & MULTI_DRAW_BIT) {
-            /* Copy mono color to all pixels */
-            multi_write_rgba_pixels( ctx, PB->count, PB->x, PB->y,
-                                     (CONST GLubyte (*)[4]) PB->rgba, mask );
-         }
-         else {
-            /* normal case: write to exactly one buffer */
-            GLubyte red   = PB->currentColor[RCOMP];
-            GLubyte green = PB->currentColor[GCOMP];
-            GLubyte blue  = PB->currentColor[BCOMP];
-            GLubyte alpha = PB->currentColor[ACOMP];
-	    (*ctx->Driver.Color)( ctx, red, green, blue, alpha );
-
-            (*ctx->Driver.WriteMonoRGBAPixels)( ctx, PB->count, PB->x, PB->y, mask );
-            if (ctx->RasterMask & ALPHABUF_BIT) {
-               _mesa_write_mono_alpha_pixels( ctx, PB->count, PB->x, PB->y,
-                                              PB->currentColor[ACOMP], mask );
-            }
-         }
-         /*** ALL DONE ***/
-      }
-   }
-   else {
-      /*
-       * COLOR INDEX PIXELS
-       */
-
-      /* If we may be writting pixels with different indexes... */
-      if ((ctx->RasterMask & modBits) || !PB->mono) {
-
-	 if (ctx->Fog.Enabled
-             && (ctx->Hint.Fog==GL_NICEST || PB->primitive==GL_BITMAP)) {
-	    _mesa_fog_ci_pixels( ctx, PB->count, PB->z, PB->index );
-	 }
-
-         /* Scissoring already done above */
-
-	 if (ctx->Stencil.Enabled) {
-	    /* first stencil test */
-	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
-                                       PB->x, PB->y, PB->z, mask) == 0) {
-	       goto CleanUp;
-	    }
-	 }
-	 else if (ctx->Depth.Test) {
-	    /* regular depth testing */
-	    _mesa_depth_test_pixels( ctx, PB->count, PB->x, PB->y, PB->z, mask );
-	 }
-
-         if (ctx->RasterMask & MULTI_DRAW_BIT) {
-            multi_write_index_pixels( ctx, PB->count, PB->x, PB->y, PB->index, mask );
-         }
-         else {
-            /* normal case: write to exactly one buffer */
-
-            if (ctx->Color.SWLogicOpEnabled) {
-               _mesa_logicop_ci_pixels( ctx, PB->count, PB->x, PB->y, PB->index, mask );
-            }
-            if (ctx->Color.SWmasking) {
-               _mesa_mask_index_pixels( ctx, PB->count, PB->x, PB->y, PB->index, mask );
-            }
-
-            (*ctx->Driver.WriteCI32Pixels)( ctx, PB->count, PB->x, PB->y,
-                                            PB->index, mask );
-         }
-
-         /*** ALL DONE ***/
-      }
-      else {
-	 /* Same color index for all pixels */
-
-         /* Scissoring already done above */
-
-	 if (ctx->Stencil.Enabled) {
-	    /* first stencil test */
-	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
-                                       PB->x, PB->y, PB->z, mask) == 0) {
-	       goto CleanUp;
-	    }
-	 }
-	 else if (ctx->Depth.Test) {
-	    /* regular depth testing */
-	    _mesa_depth_test_pixels( ctx, PB->count, PB->x, PB->y, PB->z, mask );
-	 }
-         
-         if (ctx->RasterMask & MULTI_DRAW_BIT) {
-            multi_write_index_pixels( ctx, PB->count, PB->x, PB->y, PB->index, mask );
-         }
-         else {
-            /* normal case: write to exactly one buffer */
-
-            (*ctx->Driver.Index)( ctx, PB->currentIndex );
-            (*ctx->Driver.WriteMonoCIPixels)( ctx, PB->count, PB->x, PB->y, mask );
-         }
-      }
-   }
-
-CleanUp:
-   PB->count = 0;
-   PB->mono = GL_TRUE;
-}
-
-
Index: xc/extras/Mesa/src/pb.h
diff -u xc/extras/Mesa/src/pb.h:1.4 xc/extras/Mesa/src/pb.h:removed
--- xc/extras/Mesa/src/pb.h:1.4	Fri Jun 16 20:02:14 2000
+++ xc/extras/Mesa/src/pb.h	Thu Feb 27 12:15:40 2003
@@ -1,234 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef PB_H
-#define PB_H
-
-
-#include "types.h"
-
-
-/*
- * Pixel buffer size, must be larger than MAX_WIDTH.
- */
-#define PB_SIZE (3*MAX_WIDTH)
-
-
-struct pixel_buffer {
-   GLenum primitive;           /* GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP */
-   GLubyte currentColor[4];    /* Current color, for subsequent pixels */
-   GLuint currentIndex;        /* Current index, for subsequent pixels */
-   GLuint count;               /* Number of pixels in buffer */
-   GLboolean mono;             /* Same color or index for all pixels? */
-
-   GLint x[PB_SIZE];           /* X window coord in [0,MAX_WIDTH) */
-   GLint y[PB_SIZE];           /* Y window coord in [0,MAX_HEIGHT) */
-   GLdepth z[PB_SIZE];         /* Z window coord in [0,Visual.MaxDepth] */
-   GLubyte rgba[PB_SIZE][4];   /* Colors */
-   GLubyte spec[PB_SIZE][3];   /* Separate specular colors */
-   GLuint index[PB_SIZE];      /* Color indexes */
-   GLfloat s[MAX_TEXTURE_UNITS][PB_SIZE];	/* Texture S coordinates */
-   GLfloat t[MAX_TEXTURE_UNITS][PB_SIZE];	/* Texture T coordinates */
-   GLfloat u[MAX_TEXTURE_UNITS][PB_SIZE];	/* Texture R coordinates */
-   GLfloat lambda[MAX_TEXTURE_UNITS][PB_SIZE];  /* Texture lambda values */
-};
-
-
-
-/*
- * Set the color used for all subsequent pixels in the buffer.
- */
-#define PB_SET_COLOR( PB, R, G, B, A )		\
-do {						\
-   if ((PB)->count > 0)				\
-      (PB)->mono = GL_FALSE;			\
-   (PB)->currentColor[RCOMP] = (R);		\
-   (PB)->currentColor[GCOMP] = (G);		\
-   (PB)->currentColor[BCOMP] = (B);		\
-   (PB)->currentColor[ACOMP] = (A);		\
-} while (0)
-
-
-/*
- * Set the color index used for all subsequent pixels in the buffer.
- */
-#define PB_SET_INDEX( PB, I )			\
-do {						\
-   if ((PB)->count > 0)				\
-      (PB)->mono = GL_FALSE;			\
-   (PB)->currentIndex = (I);			\
-} while (0)
-
-
-/*
- * "write" a pixel using current color or index
- */
-#define PB_WRITE_PIXEL( PB, X, Y, Z )			\
-do {							\
-   GLuint count = (PB)->count;				\
-   (PB)->x[count] = X;					\
-   (PB)->y[count] = Y;					\
-   (PB)->z[count] = Z;					\
-   COPY_4UBV((PB)->rgba[count], (PB)->currentColor);	\
-   (PB)->index[count] = (PB)->currentIndex;		\
-   (PB)->count++;					\
-} while (0)
-
-
-/*
-   (PB)->rgba[count][0] = (PB)->currentColor[0];	\
-   (PB)->rgba[count][1] = (PB)->currentColor[1];	\
-   (PB)->rgba[count][2] = (PB)->currentColor[2];	\
-   (PB)->rgba[count][3] = (PB)->currentColor[3];	\
-
-*/
-
-
-/*
- * "write" an RGBA pixel
- */
-#define PB_WRITE_RGBA_PIXEL( PB, X, Y, Z, R, G, B, A )	\
-do {							\
-   GLuint count = (PB)->count;				\
-   (PB)->x[count] = X;					\
-   (PB)->y[count] = Y;					\
-   (PB)->z[count] = Z;					\
-   (PB)->rgba[count][RCOMP] = R;			\
-   (PB)->rgba[count][GCOMP] = G;			\
-   (PB)->rgba[count][BCOMP] = B;			\
-   (PB)->rgba[count][ACOMP] = A;			\
-   (PB)->mono = GL_FALSE;				\
-   (PB)->count++;					\
-} while (0)
-
-
-/*
- * "write" a color-index pixel
- */
-#define PB_WRITE_CI_PIXEL( PB, X, Y, Z, I )	\
-do {						\
-   GLuint count = (PB)->count;			\
-   (PB)->x[count] = X;				\
-   (PB)->y[count] = Y;				\
-   (PB)->z[count] = Z;				\
-   (PB)->index[count] = I;			\
-   (PB)->mono = GL_FALSE;			\
-   (PB)->count++;				\
-} while (0)
-
-
-
-/*
- * "write" an RGBA pixel with texture coordinates
- */
-#define PB_WRITE_TEX_PIXEL( PB, X, Y, Z, R, G, B, A, S, T, U )	\
-do {							\
-   GLuint count = (PB)->count;				\
-   (PB)->x[count] = X;					\
-   (PB)->y[count] = Y;					\
-   (PB)->z[count] = Z;					\
-   (PB)->rgba[count][RCOMP] = R;			\
-   (PB)->rgba[count][GCOMP] = G;			\
-   (PB)->rgba[count][BCOMP] = B;			\
-   (PB)->rgba[count][ACOMP] = A;			\
-   (PB)->s[0][count] = S;				\
-   (PB)->t[0][count] = T;				\
-   (PB)->u[0][count] = U;				\
-   (PB)->mono = GL_FALSE;				\
-   (PB)->count++;					\
-} while (0)
-
-
-/*
- * "write" an RGBA pixel with multiple texture coordinates
- */
-#define PB_WRITE_MULTITEX_PIXEL( PB, X, Y, Z, R, G, B, A, S0, T0, U0, S1, T1, U1 )	\
-do {							\
-   GLuint count = (PB)->count;				\
-   (PB)->x[count] = X;					\
-   (PB)->y[count] = Y;					\
-   (PB)->z[count] = Z;					\
-   (PB)->rgba[count][RCOMP] = R;			\
-   (PB)->rgba[count][GCOMP] = G;			\
-   (PB)->rgba[count][BCOMP] = B;			\
-   (PB)->rgba[count][ACOMP] = A;			\
-   (PB)->s[0][count] = S0;				\
-   (PB)->t[0][count] = T0;				\
-   (PB)->u[0][count] = U0;				\
-   (PB)->s[1][count] = S1;				\
-   (PB)->t[1][count] = T1;				\
-   (PB)->u[1][count] = U1;				\
-   (PB)->mono = GL_FALSE;				\
-   (PB)->count++;					\
-} while (0)
-
-
-/*
- * "write" an RGBA pixel with multiple texture coordinates and specular color
- */
-#define PB_WRITE_MULTITEX_SPEC_PIXEL( PB, X, Y, Z, R, G, B, A,	\
-			SR, SG, SB, S0, T0, U0, S1, T1, U1 )	\
-do {								\
-   GLuint count = (PB)->count;					\
-   (PB)->x[count] = X;						\
-   (PB)->y[count] = Y;						\
-   (PB)->z[count] = Z;						\
-   (PB)->rgba[count][RCOMP] = R;				\
-   (PB)->rgba[count][GCOMP] = G;				\
-   (PB)->rgba[count][BCOMP] = B;				\
-   (PB)->rgba[count][ACOMP] = A;				\
-   (PB)->spec[count][RCOMP] = SR;				\
-   (PB)->spec[count][GCOMP] = SG;				\
-   (PB)->spec[count][BCOMP] = SB;				\
-   (PB)->s[0][count] = S0;					\
-   (PB)->t[0][count] = T0;					\
-   (PB)->u[0][count] = U0;					\
-   (PB)->s[1][count] = S1;					\
-   (PB)->t[1][count] = T1;					\
-   (PB)->u[1][count] = U1;					\
-   (PB)->mono = GL_FALSE;					\
-   (PB)->count++;						\
-} while (0)
-
-
-
-/*
- * Call this function at least every MAX_WIDTH pixels:
- */
-#define PB_CHECK_FLUSH( CTX, PB )			\
-do {							\
-   if ((PB)->count >= PB_SIZE - MAX_WIDTH) {		\
-      gl_flush_pb( CTX );				\
-   }							\
-} while(0)
-
-
-extern struct pixel_buffer *gl_alloc_pb(void);
-
-extern void gl_flush_pb( GLcontext *ctx );
-
-
-#endif
Index: xc/extras/Mesa/src/pipeline.c
diff -u xc/extras/Mesa/src/pipeline.c:1.7 xc/extras/Mesa/src/pipeline.c:removed
--- xc/extras/Mesa/src/pipeline.c:1.7	Sun Jan  7 20:07:14 2001
+++ xc/extras/Mesa/src/pipeline.c	Thu Feb 27 12:15:41 2003
@@ -1,675 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/* Dynamic pipelines, support for CVA.
- * Copyright (C) 1999 Keith Whitwell.
- */
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "bbox.h"
-#include "clip.h"
-#include "context.h"
-#include "cva.h"
-#include "fog.h"
-#include "light.h"
-#include "mem.h"
-#include "mmath.h"
-#include "pipeline.h"
-#include "shade.h"
-#include "stages.h"
-#include "state.h"
-#include "types.h"
-#include "translate.h"
-#include "vbcull.h"
-#include "vbindirect.h"
-#include "vbrender.h"
-#include "vbxform.h"
-#include "xform.h"
-#endif
-
-
-
-#ifndef MESA_VERBOSE
-int MESA_VERBOSE = 0 
-/*                 | VERBOSE_PIPELINE */
-/*                 | VERBOSE_IMMEDIATE */
-/*                 | VERBOSE_VARRAY */
-/*                 | VERBOSE_TEXTURE */
-/*                 | VERBOSE_API */
-/*                 | VERBOSE_DRIVER */
-/*                 | VERBOSE_STATE */
-/*                 | VERBOSE_CULL */
-/*                 | VERBOSE_DISPLAY_LIST */
-;
-#endif
-
-#ifndef MESA_DEBUG_FLAGS
-int MESA_DEBUG_FLAGS = 0 
-/*                 | DEBUG_ALWAYS_FLUSH */
-;
-#endif
-
-
-
-void gl_print_pipe_ops( const char *msg, GLuint flags )
-{
-   fprintf(stderr, 
-	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s\n",
-	   msg,
-	   flags,
-	   (flags & PIPE_OP_CVA_PREPARE)   ? "cva-prepare, " : "",
-	   (flags & PIPE_OP_VERT_XFORM)    ? "vert-xform, " : "",
-	   (flags & PIPE_OP_NORM_XFORM)    ? "norm-xform, " : "",
-	   (flags & PIPE_OP_LIGHT)         ? "light, " : "",
-	   (flags & PIPE_OP_FOG)           ? "fog, " : "",
-	   (flags & PIPE_OP_TEX0)          ? "tex-0, " : "",
-	   (flags & PIPE_OP_TEX1)          ? "tex-1, " : "",
-	   (flags & PIPE_OP_RAST_SETUP_0)  ? "rast-0, " : "",
-	   (flags & PIPE_OP_RAST_SETUP_1)  ? "rast-1, " : "",
-	   (flags & PIPE_OP_RENDER)        ? "render, " : "");
-
-}
-
-
-
-/* Have to reset only those parts of the vb which are being recalculated.
- */
-void gl_reset_cva_vb( struct vertex_buffer *VB, GLuint stages )
-{
-   GLcontext *ctx = VB->ctx;
-
-   if (MESA_VERBOSE&VERBOSE_PIPELINE)
-      gl_print_pipe_ops( "reset cva vb", stages ); 
-
-   if (ctx->Driver.ResetCvaVB)
-      ctx->Driver.ResetCvaVB( VB, stages );
-
-   if (stages & PIPE_OP_VERT_XFORM) 
-   {
-      if (VB->ClipOrMask & CLIP_USER_BIT)
-	 MEMSET(VB->UserClipMask, 0, VB->Count);
-
-      VB->ClipOrMask = 0;
-      VB->ClipAndMask = CLIP_ALL_BITS;
-      VB->CullMode = 0;
-      VB->CullFlag[0] = VB->CullFlag[1] = 0;
-      VB->Culled = 0;
-   }
-
-   if (stages & PIPE_OP_NORM_XFORM) {
-      VB->NormalPtr = &ctx->CVA.v.Normal;
-   }
-
-   if (stages & PIPE_OP_LIGHT) 
-   {
-      VB->ColorPtr = VB->Color[0] = VB->Color[1] = &ctx->CVA.v.Color;
-      VB->IndexPtr = VB->Index[0] = VB->Index[1] = &ctx->CVA.v.Index;
-   }
-   else if (stages & PIPE_OP_FOG) 
-   {
-      if (ctx->Light.Enabled) {
-	 VB->Color[0] = VB->LitColor[0];
-	 VB->Color[1] = VB->LitColor[1];      
-	 VB->Index[0] = VB->LitIndex[0];
-	 VB->Index[1] = VB->LitIndex[1];      
-      } else {
-	 VB->Color[0] = VB->Color[1] = &ctx->CVA.v.Color;
-	 VB->Index[0] = VB->Index[1] = &ctx->CVA.v.Index;
-      }
-      VB->ColorPtr = VB->Color[0];
-      VB->IndexPtr = VB->Index[0];
-   }
-}
-
-
-
-
-static const char *pipeline_name[3] = {
-   0,
-   "Immediate",
-   "CVA Precalc",
-};
-
-
-
-static void pipeline_ctr( struct gl_pipeline *p, GLcontext *ctx, GLuint type )
-{
-   GLuint i;
-   (void) ctx;
-
-   p->state_change = 0;
-   p->cva_state_change = 0;
-   p->inputs = 0;
-   p->outputs = 0;
-   p->type = type;
-   p->ops = 0;
-
-   for (i = 0 ; i < gl_default_nr_stages ; i++) 
-      p->state_change |= gl_default_pipeline[i].state_change;
-}
-
-
-void gl_pipeline_init( GLcontext *ctx )
-{
-   if (ctx->Driver.RegisterPipelineStages)
-      ctx->NrPipelineStages = 
-	 ctx->Driver.RegisterPipelineStages( ctx->PipelineStage,
-					     gl_default_pipeline,
-					     gl_default_nr_stages );
-   else 
-   {
-      MEMCPY( ctx->PipelineStage, 
-	      gl_default_pipeline, 
-	      sizeof(*gl_default_pipeline) * gl_default_nr_stages );
-
-      ctx->NrPipelineStages = gl_default_nr_stages;
-   }
-
-   pipeline_ctr( &ctx->CVA.elt, ctx, PIPE_IMMEDIATE);
-   pipeline_ctr( &ctx->CVA.pre, ctx, PIPE_PRECALC );
-}
-
-
-
-
-
-
-#define MINIMAL_VERT_DATA (VERT_DATA&~(VERT_TEX0_4|VERT_TEX1_4|VERT_EVAL_ANY))
-
-#define VERT_CURRENT_DATA (VERT_TEX0_1234|VERT_TEX1_1234|VERT_RGBA| \
-			   VERT_INDEX|VERT_EDGE|VERT_NORM| \
-	                   VERT_MATERIAL)
-
-/* Called prior to every recomputation of the CVA precalc data, except where
- * the driver is able to calculate the pipeline unassisted.
- */
-static void build_full_precalc_pipeline( GLcontext *ctx )
-{
-   struct gl_pipeline_stage *pipeline = ctx->PipelineStage;
-   struct gl_cva *cva = &ctx->CVA;
-   struct gl_pipeline *pre = &cva->pre;   
-   struct gl_pipeline_stage **stages = pre->stages;
-   GLuint i;
-   GLuint newstate = pre->new_state;
-   GLuint changed_ops = 0;
-   GLuint oldoutputs = pre->outputs;
-   GLuint oldinputs = pre->inputs;
-#ifdef VAO
-   GLuint fallback = (VERT_CURRENT_DATA & ctx->Current.Flag & 
-		      ~ctx->Array.Current->Summary);
-   GLuint changed_outputs = (ctx->Array.NewArrayState | 
-			     (fallback & cva->orflag));
-   GLuint available = fallback | ctx->Array.Current->Flags;
-#else
-   GLuint fallback = (VERT_CURRENT_DATA & ctx->Current.Flag & 
-		      ~ctx->Array.Summary);
-   GLuint changed_outputs = (ctx->Array.NewArrayState | 
-			     (fallback & cva->orflag));
-   GLuint available = fallback | ctx->Array.Flags;
-#endif
-
-   pre->cva_state_change = 0;
-   pre->ops = 0;
-   pre->outputs = 0;
-   pre->inputs = 0;
-   pre->forbidden_inputs = 0;
-   pre->fallback = 0;
-   
-#ifdef VAO
-   if (ctx->Array.Current->Summary & VERT_ELT) 
-#else
-   if (ctx->Array.Summary & VERT_ELT) 
-#endif
-      cva->orflag &= VERT_MATERIAL;
-  
-#ifdef VAO
-   cva->orflag &= ~(ctx->Array.Current->Summary & ~VERT_OBJ_ANY);
-#else
-   cva->orflag &= ~(ctx->Array.Summary & ~VERT_OBJ_ANY);
-#endif
-   available &= ~cva->orflag;
-   
-   pre->outputs = available;
-   pre->inputs = available;
-
-   if (MESA_VERBOSE & VERBOSE_PIPELINE) {
-      fprintf(stderr, ": Rebuild pipeline\n");
-      gl_print_vert_flags("orflag", cva->orflag);
-   }
-      
-   
-
-   /* If something changes in the pipeline, tag all subsequent stages
-    * using this value for recalcuation.  Also used to build the full
-    * pipeline by setting newstate and newinputs to ~0.
-    *
-    * Because all intermediate values are buffered, the new inputs
-    * are enough to fully specify what needs to be calculated, and a
-    * single pass identifies all stages requiring recalculation.
-    */
-   for (i = 0 ; i < ctx->NrPipelineStages ; i++) 
-   {
-      pipeline[i].check(ctx, &pipeline[i]);
-
-      if (pipeline[i].type & PIPE_PRECALC) 
-      {
-	 if ((newstate & pipeline[i].cva_state_change) ||
-	     (changed_outputs & pipeline[i].inputs) ||
-	     !pipeline[i].inputs)
-	 {	    
-	    changed_ops |= pipeline[i].ops;
-	    changed_outputs |= pipeline[i].outputs;
-	    pipeline[i].active &= ~PIPE_PRECALC;
-
-	    if ((pipeline[i].inputs & ~available) == 0 &&
-		(pipeline[i].ops & pre->ops) == 0)
-	    {
-	       pipeline[i].active |= PIPE_PRECALC;
-	       *stages++ = &pipeline[i];
-	    } 
-	 }
-      
-	 /* Incompatible with multiple stages structs implementing
-	  * the same stage.
-	  */
-	 available &= ~pipeline[i].outputs;
-	 pre->outputs &= ~pipeline[i].outputs;
-
-	 if (pipeline[i].active & PIPE_PRECALC) {
-	    pre->ops |= pipeline[i].ops;
-	    pre->outputs |= pipeline[i].outputs;
-	    available |= pipeline[i].outputs;
-	    pre->forbidden_inputs |= pipeline[i].pre_forbidden_inputs;
-	 }
-      } 
-      else if (pipeline[i].active & PIPE_PRECALC) 
-      {
-	 pipeline[i].active &= ~PIPE_PRECALC;
-	 changed_outputs |= pipeline[i].outputs;
-	 changed_ops |= pipeline[i].ops;
-      }
-   }
-
-   *stages = 0;
-
-   pre->new_outputs = pre->outputs & (changed_outputs | ~oldoutputs);
-   pre->new_inputs = pre->inputs & ~oldinputs;
-   pre->fallback = pre->inputs & fallback;
-   pre->forbidden_inputs |= pre->inputs & fallback;
-
-   pre->changed_ops = changed_ops;
-
-   if (ctx->Driver.OptimizePrecalcPipeline)
-      ctx->Driver.OptimizePrecalcPipeline( ctx, pre );
-}
-
-void gl_build_precalc_pipeline( GLcontext *ctx )
-{
-   struct gl_pipeline *pre = &ctx->CVA.pre;   
-   struct gl_pipeline *elt = &ctx->CVA.elt;   
-
-   if (!ctx->Driver.BuildPrecalcPipeline ||
-       !ctx->Driver.BuildPrecalcPipeline( ctx ))
-      build_full_precalc_pipeline( ctx );
-
-   pre->data_valid = 0;
-   pre->pipeline_valid = 1;
-   elt->pipeline_valid = 0;
-   
-   ctx->CVA.orflag = 0;
-   
-   if (MESA_VERBOSE&VERBOSE_PIPELINE)
-      gl_print_pipeline( ctx, pre ); 
-}
-
-
-static void build_full_immediate_pipeline( GLcontext *ctx )
-{
-   struct gl_pipeline_stage *pipeline = ctx->PipelineStage;
-   struct gl_cva *cva = &ctx->CVA;
-   struct gl_pipeline *pre = &cva->pre;   
-   struct gl_pipeline *elt = &cva->elt;
-   struct gl_pipeline_stage **stages = elt->stages;
-   GLuint i;
-   GLuint newstate = elt->new_state;
-   GLuint active_ops = 0;
-   GLuint available = cva->orflag | MINIMAL_VERT_DATA;
-   GLuint generated = 0;
-   GLuint is_elt = 0;
-
-   if (pre->data_valid && ctx->CompileCVAFlag) {
-      is_elt = 1;
-      active_ops = cva->pre.ops;
-      available |= pre->outputs | VERT_PRECALC_DATA;
-   }
-
-
-   elt->outputs = 0;		/* not used */
-   elt->inputs = 0;
-
-   for (i = 0 ; i < ctx->NrPipelineStages ; i++) {
-      pipeline[i].active &= ~PIPE_IMMEDIATE;
-
-      if ((pipeline[i].state_change & newstate) ||
-  	  (pipeline[i].elt_forbidden_inputs & available)) 
-      {
-	 pipeline[i].check(ctx, &pipeline[i]);
-      }
-
-      if ((pipeline[i].type & PIPE_IMMEDIATE) &&
-	  (pipeline[i].ops & active_ops) == 0 && 
-	  (pipeline[i].elt_forbidden_inputs & available) == 0
-	 )
-      {
-	 if (pipeline[i].inputs & ~available) 
-	    elt->forbidden_inputs |= pipeline[i].inputs & ~available;
-	 else
-	 {
-	    elt->inputs |= pipeline[i].inputs & ~generated;
-	    elt->forbidden_inputs |= pipeline[i].elt_forbidden_inputs;
-	    pipeline[i].active |= PIPE_IMMEDIATE;
-	    *stages++ = &pipeline[i];
-	    generated |= pipeline[i].outputs;
-	    available |= pipeline[i].outputs;
-	    active_ops |= pipeline[i].ops;
-	 }
-      }
-   }
-
-   *stages = 0;
-   
-   elt->copy_transformed_data = 1;
-   elt->replay_copied_vertices = 0;
-
-   if (is_elt) {
-      cva->merge = elt->inputs & pre->outputs;
-      elt->ops = active_ops & ~pre->ops;
-   }
-}
-
-
-
-void gl_build_immediate_pipeline( GLcontext *ctx )
-{
-   struct gl_pipeline *elt = &ctx->CVA.elt;   
-
-   if (!ctx->Driver.BuildEltPipeline ||
-       !ctx->Driver.BuildEltPipeline( ctx )) {
-      build_full_immediate_pipeline( ctx );
-   }
-
-   elt->pipeline_valid = 1;
-   ctx->CVA.orflag = 0;
-   
-   if (MESA_VERBOSE&VERBOSE_PIPELINE)
-      gl_print_pipeline( ctx, elt ); 
-}
-   
-#define INTERESTED ~(NEW_DRIVER_STATE|NEW_CLIENT_STATE)
-
-void gl_update_pipelines( GLcontext *ctx )
-{
-   GLuint newstate = ctx->NewState;
-   struct gl_cva *cva = &ctx->CVA;
-
-   newstate &= INTERESTED;
-
-   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_STATE))
-      gl_print_enable_flags("enabled", ctx->Enabled);
-
-   if (newstate ||
-       cva->lock_changed ||
-       cva->orflag != cva->last_orflag ||
-#ifdef VAO
-       ctx->Array.Current->Flags != cva->last_array_flags)
-#else
-       ctx->Array.Flags != cva->last_array_flags)
-#endif
-   {   
-      GLuint flags = VERT_WIN;
-
-      if (ctx->Visual->RGBAflag) 
-	 flags |= VERT_RGBA;
-      else 
-	 flags |= VERT_INDEX;
-
-      if (ctx->Texture.ReallyEnabled & 0xf) {
-/* XXX this should also check that the texture is RGBA.  What about Unit[1]?
-	 if (ctx->Texture.Unit[0].EnvMode == GL_REPLACE)
-	    flags &= ~VERT_RGBA;
-*/
-	 flags |= VERT_TEX0_ANY;
-      }
-
-      if (ctx->Texture.ReallyEnabled & 0xf0)
-	 flags |= VERT_TEX1_ANY;
-   
-      if (ctx->Polygon.Unfilled) 
-	 flags |= VERT_EDGE;
- 
-      if (ctx->RenderMode==GL_FEEDBACK) 
-      {
-	 flags = (VERT_WIN|VERT_RGBA|VERT_INDEX|
-		  VERT_NORM|VERT_EDGE|
-		  VERT_TEX0_ANY|VERT_TEX1_ANY);
-      }
-
-      ctx->RenderFlags = flags;
-
-      cva->elt.new_state |= newstate;
-      cva->elt.pipeline_valid = 0;
-
-      cva->pre.new_state |= newstate;
-      cva->pre.forbidden_inputs = 0;
-      cva->pre.pipeline_valid = 0;
-      cva->lock_changed = 0;
-   }
-
-#ifdef VAO
-   if (ctx->Array.NewArrayState != cva->last_array_new_state)
-#else
-   if (ctx->Array.NewArrayState != cva->last_array_new_state)
-#endif
-      cva->pre.pipeline_valid = 0;
-
-   cva->pre.data_valid = 0;
-#ifdef VAO
-   cva->last_array_new_state = ctx->Array.NewArrayState;
-#else
-   cva->last_array_new_state = ctx->Array.NewArrayState;
-#endif
-   cva->last_orflag = cva->orflag;
-#ifdef VAO
-   cva->last_array_flags = ctx->Array.Current->Flags;
-#else
-   cva->last_array_flags = ctx->Array.Flags;
-#endif
-}
-
-void gl_run_pipeline( struct vertex_buffer *VB )
-{
-   struct gl_pipeline *pipe = VB->pipeline;
-   struct gl_pipeline_stage **stages = pipe->stages;
-   unsigned short x;
-
-   pipe->data_valid = 1;	/* optimized stages might want to reset this. */
-
-   START_FAST_MATH(x);
-   
-   for ( VB->Culled = 0; *stages && !VB->Culled ; stages++ )
-      (*stages)->run( VB );
-      
-   END_FAST_MATH(x);
-
-   pipe->new_state = 0;
-}
-
-void gl_print_vert_flags( const char *name, GLuint flags ) 
-{
-   fprintf(stderr, 
-	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
-	   name,
-	   flags,
-	   (flags & VERT_OBJ_ANY)    ? "vertices (obj), " : "",
-	   (flags & VERT_ELT)        ? "array-elt, " : "",
-	   (flags & VERT_RGBA)       ? "colors, " : "",
-	   (flags & VERT_NORM)       ? "normals, " : "",
-	   (flags & VERT_INDEX)      ? "index, " : "",
-	   (flags & VERT_EDGE)       ? "edgeflag, " : "",
-	   (flags & VERT_MATERIAL)   ? "material, " : "",
-	   (flags & VERT_TEX0_ANY)   ? "texcoord0, " : "",
-	   (flags & VERT_TEX1_ANY)   ? "texcoord1, " : "",
-	   (flags & VERT_EVAL_ANY)   ? "eval-coord, " : "",
-	   (flags & VERT_EYE)        ? "eye, " : "",
-	   (flags & VERT_WIN)        ? "win, " : "",
-	   (flags & VERT_PRECALC_DATA) ? "precalc data, " : "",
-	   (flags & VERT_SETUP_FULL) ? "driver-data, " : "", 
-	   (flags & VERT_SETUP_PART) ? "partial-driver-data, " : ""
-      );
-}
-
-void gl_print_tri_caps( const char *name, GLuint flags ) 
-{
-   fprintf(stderr, 
-	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
-	   name,
-	   flags,
-	   (flags & DD_FEEDBACK)            ? "feedback, " : "",
-	   (flags & DD_SELECT)              ? "select, " : "",
-	   (flags & DD_FLATSHADE)           ? "flat-shade, " : "",
-	   (flags & DD_MULTIDRAW)           ? "multidraw, " : "",
-	   (flags & DD_SEPERATE_SPECULAR)   ? "seperate-specular, " : "",
-	   (flags & DD_TRI_LIGHT_TWOSIDE)   ? "tri-light-twoside, " : "",
-	   (flags & DD_TRI_UNFILLED)        ? "tri-unfilled, " : "",
-	   (flags & DD_TRI_STIPPLE)         ? "tri-stipple, " : "",
-	   (flags & DD_TRI_OFFSET)          ? "tri-offset, " : "",
-	   (flags & DD_TRI_CULL)            ? "tri-bf-cull, " : "",
-	   (flags & DD_LINE_SMOOTH)         ? "line-smooth, " : "",
-	   (flags & DD_LINE_STIPPLE)        ? "line-stipple, " : "",
-	   (flags & DD_LINE_WIDTH)          ? "line-wide, " : "",
-	   (flags & DD_POINT_SMOOTH)        ? "point-smooth, " : "", 
-	   (flags & DD_POINT_SIZE)          ? "point-size, " : "", 
-	   (flags & DD_POINT_ATTEN)         ? "point-atten, " : "", 
-	   (flags & DD_LIGHTING_CULL)       ? "lighting-cull, " : "", 
-	   (flags & DD_POINT_SW_RASTERIZE)  ? "sw-points, " : "", 
-	   (flags & DD_LINE_SW_RASTERIZE)   ? "sw-lines, " : "", 
-	   (flags & DD_TRI_SW_RASTERIZE)    ? "sw-tris, " : "", 
-	   (flags & DD_QUAD_SW_RASTERIZE)   ? "sw-quads, " : "",
-	   (flags & DD_TRI_CULL_FRONT_BACK) ? "cull-all, " : "",
-	   (flags & DD_STENCIL)             ? "stencil, " : "",
-	   (flags & DD_CLIP_FOG_COORD)      ? "clip-fog-coord, " : ""
-      );
-}
-
-
-void gl_print_pipeline( GLcontext *ctx, struct gl_pipeline *p )
-{
-   struct gl_pipeline_stage *pipeline = ctx->PipelineStage;
-   GLuint i;
-
-   fprintf(stderr,"Type: %s\n", pipeline_name[p->type]);
-
-   if (!p->pipeline_valid) {
-      printf("--> Not up to date!!!\n");
-      return;
-   }
-
-   gl_print_vert_flags("Inputs", p->inputs);
-   gl_print_vert_flags("Forbidden", p->forbidden_inputs);
-   gl_print_vert_flags("Outputs", p->outputs);
-
-   if (0) 
-      for (i = 0 ; i < ctx->NrPipelineStages ; i++) 
-	 if (pipeline[i].active & p->type) {
-	    fprintf(stderr,"%u: %s\n", i, pipeline[i].name);
-	    
-	    gl_print_vert_flags("\tinputs", pipeline[i].inputs);
-	    gl_print_vert_flags("\toutputs", pipeline[i].outputs);
-	    
-	    if (p->type == PIPE_PRECALC && pipeline[i].pre_forbidden_inputs)
-	       gl_print_vert_flags("\tforbidden", 
-				   pipeline[i].pre_forbidden_inputs);
-
-	    if (p->type == PIPE_IMMEDIATE && pipeline[i].elt_forbidden_inputs)
-	       gl_print_vert_flags("\tforbidden", 
-				   pipeline[i].elt_forbidden_inputs);
-
-	 }
-
-
-   if (1) {
-      struct gl_pipeline_stage **stages = p->stages;
-      fprintf(stderr,"\nStages requiring precalculation:\n");
-      for ( i=0 ; stages[i] ; i++) {
-	 fprintf(stderr, "%u: %s\n", i, stages[i]->name);
-	 gl_print_vert_flags("\tinputs", stages[i]->inputs);
-	 gl_print_vert_flags("\toutputs", stages[i]->outputs);
-	 if (p->type == PIPE_PRECALC && pipeline[i].pre_forbidden_inputs)
-	    gl_print_vert_flags("\tforbidden", 
-				pipeline[i].pre_forbidden_inputs);
-
-	 if (p->type == PIPE_IMMEDIATE && pipeline[i].elt_forbidden_inputs)
-	    gl_print_vert_flags("\tforbidden", 
-				pipeline[i].elt_forbidden_inputs);
-      }
-   }
-}
-
-
-
-void gl_print_active_pipeline( GLcontext *ctx, struct gl_pipeline *p )
-{
-   struct gl_pipeline_stage **stages = p->stages;
-   GLuint i;
-
-   (void) ctx;
-
-   fprintf(stderr,"Type: %s\n", pipeline_name[p->type]);
-
-   if (!p->pipeline_valid) {
-      printf("--> Not up to date!!!\n");
-      return;
-   }
-
-   gl_print_vert_flags("Inputs", p->inputs);
-   gl_print_vert_flags("Forbidden", p->forbidden_inputs);
-   gl_print_vert_flags("Outputs", p->outputs);
-
-   for ( i=0 ; stages[i] ; i++) {
-      fprintf(stderr, "%u: %s\n", i, stages[i]->name);
-
-      gl_print_vert_flags("\tinputs", stages[i]->inputs);
-      gl_print_vert_flags("\toutputs", stages[i]->outputs);
-
-      if (p->type == PIPE_PRECALC && stages[i]->pre_forbidden_inputs)
-	    gl_print_vert_flags("\tforbidden", 
-				stages[i]->pre_forbidden_inputs);
-      }
-}
-
-
Index: xc/extras/Mesa/src/pipeline.h
diff -u xc/extras/Mesa/src/pipeline.h:1.3 xc/extras/Mesa/src/pipeline.h:removed
--- xc/extras/Mesa/src/pipeline.h:1.3	Tue Feb 15 02:12:29 2000
+++ xc/extras/Mesa/src/pipeline.h	Thu Feb 27 12:15:41 2003
@@ -1,56 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifndef _PIPELINE_H_
-#define _PIPELINE_H_
-
-
-extern void gl_update_materials( struct vertex_buffer *VB);
-
-extern void gl_pipeline_init( GLcontext *ctx );
-extern void gl_update_pipelines( GLcontext *ctx );
-
-extern void gl_build_precalc_pipeline( GLcontext *ctx );
-extern void gl_build_immediate_pipeline( GLcontext *ctx );
-
-extern void gl_print_vert_flags( const char *name, GLuint flags );
-extern void gl_print_pipeline( GLcontext *ctx, struct gl_pipeline *p );
-extern void gl_print_active_pipeline( GLcontext *ctx, struct gl_pipeline *p );
-
-extern void gl_run_pipeline( struct vertex_buffer *VB );
-
-extern void gl_clean_color( struct vertex_buffer *VB );
-
-extern void gl_reset_cva_vb( struct vertex_buffer *VB, GLuint stages );
-
-extern void gl_print_tri_caps( const char *name, GLuint flags );
-extern void gl_print_pipe_ops( const char *msg, GLuint flags );
-
-#endif
Index: xc/extras/Mesa/src/pixel.c
diff -u xc/extras/Mesa/src/pixel.c:1.6 xc/extras/Mesa/src/pixel.c:1.10
--- xc/extras/Mesa/src/pixel.c:1.6	Fri Aug 17 14:40:04 2001
+++ xc/extras/Mesa/src/pixel.c	Mon Dec 16 11:18:27 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,11 +28,12 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "macros.h"
 #include "mem.h"
 #include "pixel.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -47,8 +48,12 @@
 _mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelZoom");
 
+   if (ctx->Pixel.ZoomX == xfactor &&
+       ctx->Pixel.ZoomY == yfactor)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_PIXEL);
    ctx->Pixel.ZoomX = xfactor;
    ctx->Pixel.ZoomY = yfactor;
 }
@@ -65,115 +70,179 @@
 {
    /* NOTE: this call can't be compiled into the display list */
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelStore");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (pname) {
       case GL_PACK_SWAP_BYTES:
+	 if (param == (GLint)ctx->Pack.SwapBytes)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
          ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
 	 break;
       case GL_PACK_LSB_FIRST:
+	 if (param == (GLint)ctx->Pack.LsbFirst)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
          ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
 	 break;
       case GL_PACK_ROW_LENGTH:
 	 if (param<0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-	 }
-	 else {
-	    ctx->Pack.RowLength = param;
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
+	 if (ctx->Pack.RowLength == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Pack.RowLength = param;
 	 break;
       case GL_PACK_IMAGE_HEIGHT:
-         if (param<0)
-            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-         else
-            ctx->Pack.ImageHeight = param;
+         if (param<0) {
+            _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
+	 }
+	 if (ctx->Pack.ImageHeight == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Pack.ImageHeight = param;
          break;
       case GL_PACK_SKIP_PIXELS:
 	 if (param<0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
-	 else {
-	    ctx->Pack.SkipPixels = param;
-	 }
+	 if (ctx->Pack.SkipPixels == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Pack.SkipPixels = param;
 	 break;
       case GL_PACK_SKIP_ROWS:
 	 if (param<0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-	 }
-	 else {
-	    ctx->Pack.SkipRows = param;
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
+	 if (ctx->Pack.SkipRows == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Pack.SkipRows = param;
 	 break;
       case GL_PACK_SKIP_IMAGES:
 	 if (param<0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-	 }
-	 else {
-	    ctx->Pack.SkipImages = param;
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
+	 if (ctx->Pack.SkipImages == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Pack.SkipImages = param;
 	 break;
       case GL_PACK_ALIGNMENT:
-         if (param==1 || param==2 || param==4 || param==8) {
-	    ctx->Pack.Alignment = param;
-	 }
-	 else {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-	 }
-	 break;
+         if (param!=1 && param!=2 && param!=4 && param!=8) {
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
+	 }
+	 if (ctx->Pack.Alignment == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Pack.Alignment = param;
+	 break;
+      case GL_PACK_INVERT_MESA:
+         if (!ctx->Extensions.MESA_pack_invert) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glPixelstore(pname)" );
+            return;
+         }
+         if (ctx->Pack.Invert == param)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+         ctx->Pack.Invert = param;
+         break;
+
       case GL_UNPACK_SWAP_BYTES:
+	 if (param == (GLint)ctx->Unpack.SwapBytes)
+	    return;
+	 if ((GLint)ctx->Unpack.SwapBytes == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 	 ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
          break;
       case GL_UNPACK_LSB_FIRST:
+	 if (param == (GLint)ctx->Unpack.LsbFirst)
+	    return;
+	 if ((GLint)ctx->Unpack.LsbFirst == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
 	 ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
 	 break;
       case GL_UNPACK_ROW_LENGTH:
 	 if (param<0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-	 }
-	 else {
-	    ctx->Unpack.RowLength = param;
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
+	 if (ctx->Unpack.RowLength == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Unpack.RowLength = param;
 	 break;
       case GL_UNPACK_IMAGE_HEIGHT:
-         if (param<0)
-            gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-         else
-            ctx->Unpack.ImageHeight = param;
+         if (param<0) {
+            _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
+	 }
+	 if (ctx->Unpack.ImageHeight == param)
+	    return;
+
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Unpack.ImageHeight = param;
          break;
       case GL_UNPACK_SKIP_PIXELS:
 	 if (param<0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-	 }
-	 else {
-	    ctx->Unpack.SkipPixels = param;
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
+	 if (ctx->Unpack.SkipPixels == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Unpack.SkipPixels = param;
 	 break;
       case GL_UNPACK_SKIP_ROWS:
 	 if (param<0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
-	 }
-	 else {
-	    ctx->Unpack.SkipRows = param;
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
+	 if (ctx->Unpack.SkipRows == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Unpack.SkipRows = param;
 	 break;
       case GL_UNPACK_SKIP_IMAGES:
 	 if (param < 0) {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
+	    return;
 	 }
-	 else {
-	    ctx->Unpack.SkipImages = param;
-	 }
+	 if (ctx->Unpack.SkipImages == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Unpack.SkipImages = param;
 	 break;
       case GL_UNPACK_ALIGNMENT:
-         if (param==1 || param==2 || param==4 || param==8) {
-	    ctx->Unpack.Alignment = param;
-	 }
-	 else {
-	    gl_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
-	 }
-	 break;
+         if (param!=1 && param!=2 && param!=4 && param!=8) {
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
+	    return;
+	 }
+	 if (ctx->Unpack.Alignment == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+	 ctx->Unpack.Alignment = param;
+	 break;
+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
+         if (param == (GLint)ctx->Unpack.ClientStorage)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PACKUNPACK);
+         ctx->Unpack.ClientStorage = param ? GL_TRUE : GL_FALSE;
+         break;
+
       default:
-	 gl_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
+	 return;
    }
 }
 
@@ -197,30 +266,23 @@
 {
    GLint i;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelMapfv");
-
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (mapsize<0 || mapsize>MAX_PIXEL_MAP_TABLE) {
-      gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
+   if (mapsize < 1 || mapsize > MAX_PIXEL_MAP_TABLE) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
       return;
    }
 
-   if (map>=GL_PIXEL_MAP_S_TO_S && map<=GL_PIXEL_MAP_I_TO_A) {
+   if (map >= GL_PIXEL_MAP_S_TO_S && map <= GL_PIXEL_MAP_I_TO_A) {
       /* test that mapsize is a power of two */
-      GLuint p;
-      GLboolean ok = GL_FALSE;
-      for (p=1; p<=MAX_PIXEL_MAP_TABLE; p=p<<1) {
-	 if ( (p&mapsize) == p ) {
-	    ok = GL_TRUE;
-	    break;
-	 }
-      }
-      if (!ok) {
-	 gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
+      if (_mesa_bitcount((GLuint) mapsize) != 1) {
+	 _mesa_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
          return;
       }
    }
 
+   FLUSH_VERTICES(ctx, _NEW_PIXEL);
+
    switch (map) {
       case GL_PIXEL_MAP_S_TO_S:
          ctx->Pixel.MapStoSsize = mapsize;
@@ -237,7 +299,7 @@
       case GL_PIXEL_MAP_I_TO_R:
          ctx->Pixel.MapItoRsize = mapsize;
          for (i=0;i<mapsize;i++) {
-            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
+            GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 	    ctx->Pixel.MapItoR[i] = val;
 	    ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
 	 }
@@ -245,7 +307,7 @@
       case GL_PIXEL_MAP_I_TO_G:
          ctx->Pixel.MapItoGsize = mapsize;
          for (i=0;i<mapsize;i++) {
-            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
+            GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 	    ctx->Pixel.MapItoG[i] = val;
 	    ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
 	 }
@@ -253,7 +315,7 @@
       case GL_PIXEL_MAP_I_TO_B:
          ctx->Pixel.MapItoBsize = mapsize;
          for (i=0;i<mapsize;i++) {
-            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
+            GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 	    ctx->Pixel.MapItoB[i] = val;
 	    ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
 	 }
@@ -261,7 +323,7 @@
       case GL_PIXEL_MAP_I_TO_A:
          ctx->Pixel.MapItoAsize = mapsize;
          for (i=0;i<mapsize;i++) {
-            GLfloat val = CLAMP( values[i], 0.0, 1.0 );
+            GLfloat val = CLAMP( values[i], 0.0F, 1.0F );
 	    ctx->Pixel.MapItoA[i] = val;
 	    ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
 	 }
@@ -269,29 +331,29 @@
       case GL_PIXEL_MAP_R_TO_R:
          ctx->Pixel.MapRtoRsize = mapsize;
          for (i=0;i<mapsize;i++) {
-	    ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0, 1.0 );
+	    ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0F, 1.0F );
 	 }
 	 break;
       case GL_PIXEL_MAP_G_TO_G:
          ctx->Pixel.MapGtoGsize = mapsize;
          for (i=0;i<mapsize;i++) {
-	    ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0, 1.0 );
+	    ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0F, 1.0F );
 	 }
 	 break;
       case GL_PIXEL_MAP_B_TO_B:
          ctx->Pixel.MapBtoBsize = mapsize;
          for (i=0;i<mapsize;i++) {
-	    ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0, 1.0 );
+	    ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0F, 1.0F );
 	 }
 	 break;
       case GL_PIXEL_MAP_A_TO_A:
          ctx->Pixel.MapAtoAsize = mapsize;
          for (i=0;i<mapsize;i++) {
-	    ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0, 1.0 );
+	    ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0F, 1.0F );
 	 }
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
    }
 }
 
@@ -300,15 +362,16 @@
 void
 _mesa_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values )
 {
+   const GLint n = MIN2(mapsize, MAX_PIXEL_MAP_TABLE);
    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
    GLint i;
    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
-      for (i=0;i<mapsize;i++) {
+      for (i=0;i<n;i++) {
          fvalues[i] = (GLfloat) values[i];
       }
    }
    else {
-      for (i=0;i<mapsize;i++) {
+      for (i=0;i<n;i++) {
          fvalues[i] = UINT_TO_FLOAT( values[i] );
       }
    }
@@ -320,15 +383,16 @@
 void
 _mesa_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values )
 {
+   const GLint n = MIN2(mapsize, MAX_PIXEL_MAP_TABLE);
    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
    GLint i;
    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
-      for (i=0;i<mapsize;i++) {
+      for (i=0;i<n;i++) {
          fvalues[i] = (GLfloat) values[i];
       }
    }
    else {
-      for (i=0;i<mapsize;i++) {
+      for (i=0;i<n;i++) {
          fvalues[i] = USHORT_TO_FLOAT( values[i] );
       }
    }
@@ -342,9 +406,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
-
    switch (map) {
       case GL_PIXEL_MAP_I_TO_I:
          for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
@@ -381,7 +444,7 @@
          MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
    }
 }
 
@@ -391,8 +454,7 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (map) {
       case GL_PIXEL_MAP_I_TO_I:
@@ -442,7 +504,7 @@
 	 }
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
    }
 }
 
@@ -452,9 +514,8 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glGetPixelMapfv");
-
    switch (map) {
       case GL_PIXEL_MAP_I_TO_I:
 	 for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
@@ -507,7 +568,7 @@
 	 }
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
    }
 }
 
@@ -526,128 +587,193 @@
 _mesa_PixelTransferf( GLenum pname, GLfloat param )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelTransfer");
-
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (pname) {
       case GL_MAP_COLOR:
+         if (ctx->Pixel.MapColorFlag == (param ? GL_TRUE : GL_FALSE))
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
 	 break;
       case GL_MAP_STENCIL:
+         if (ctx->Pixel.MapStencilFlag == (param ? GL_TRUE : GL_FALSE))
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
 	 break;
       case GL_INDEX_SHIFT:
+         if (ctx->Pixel.IndexShift == (GLint) param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.IndexShift = (GLint) param;
 	 break;
       case GL_INDEX_OFFSET:
+         if (ctx->Pixel.IndexOffset == (GLint) param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.IndexOffset = (GLint) param;
 	 break;
       case GL_RED_SCALE:
+         if (ctx->Pixel.RedScale == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.RedScale = param;
 	 break;
       case GL_RED_BIAS:
+         if (ctx->Pixel.RedBias == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.RedBias = param;
 	 break;
       case GL_GREEN_SCALE:
+         if (ctx->Pixel.GreenScale == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.GreenScale = param;
 	 break;
       case GL_GREEN_BIAS:
+         if (ctx->Pixel.GreenBias == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.GreenBias = param;
 	 break;
       case GL_BLUE_SCALE:
+         if (ctx->Pixel.BlueScale == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.BlueScale = param;
 	 break;
       case GL_BLUE_BIAS:
+         if (ctx->Pixel.BlueBias == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.BlueBias = param;
 	 break;
       case GL_ALPHA_SCALE:
+         if (ctx->Pixel.AlphaScale == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.AlphaScale = param;
 	 break;
       case GL_ALPHA_BIAS:
+         if (ctx->Pixel.AlphaBias == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.AlphaBias = param;
 	 break;
       case GL_DEPTH_SCALE:
+         if (ctx->Pixel.DepthScale == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.DepthScale = param;
 	 break;
       case GL_DEPTH_BIAS:
+         if (ctx->Pixel.DepthBias == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.DepthBias = param;
 	 break;
       case GL_POST_COLOR_MATRIX_RED_SCALE:
+         if (ctx->Pixel.PostColorMatrixScale[0] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixScale[0] = param;
 	 break;
       case GL_POST_COLOR_MATRIX_RED_BIAS:
+         if (ctx->Pixel.PostColorMatrixBias[0] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixBias[0] = param;
 	 break;
       case GL_POST_COLOR_MATRIX_GREEN_SCALE:
+         if (ctx->Pixel.PostColorMatrixScale[1] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixScale[1] = param;
 	 break;
       case GL_POST_COLOR_MATRIX_GREEN_BIAS:
+         if (ctx->Pixel.PostColorMatrixBias[1] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixBias[1] = param;
 	 break;
       case GL_POST_COLOR_MATRIX_BLUE_SCALE:
+         if (ctx->Pixel.PostColorMatrixScale[2] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixScale[2] = param;
 	 break;
       case GL_POST_COLOR_MATRIX_BLUE_BIAS:
+         if (ctx->Pixel.PostColorMatrixBias[2] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixBias[2] = param;
 	 break;
       case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
+         if (ctx->Pixel.PostColorMatrixScale[3] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixScale[3] = param;
 	 break;
       case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
+         if (ctx->Pixel.PostColorMatrixBias[3] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostColorMatrixBias[3] = param;
 	 break;
       case GL_POST_CONVOLUTION_RED_SCALE:
+         if (ctx->Pixel.PostConvolutionScale[0] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionScale[0] = param;
 	 break;
       case GL_POST_CONVOLUTION_RED_BIAS:
+         if (ctx->Pixel.PostConvolutionBias[0] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionBias[0] = param;
 	 break;
       case GL_POST_CONVOLUTION_GREEN_SCALE:
+         if (ctx->Pixel.PostConvolutionScale[1] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionScale[1] = param;
 	 break;
       case GL_POST_CONVOLUTION_GREEN_BIAS:
+         if (ctx->Pixel.PostConvolutionBias[1] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionBias[1] = param;
 	 break;
       case GL_POST_CONVOLUTION_BLUE_SCALE:
+         if (ctx->Pixel.PostConvolutionScale[2] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionScale[2] = param;
 	 break;
       case GL_POST_CONVOLUTION_BLUE_BIAS:
+         if (ctx->Pixel.PostConvolutionBias[2] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionBias[2] = param;
 	 break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE:
+         if (ctx->Pixel.PostConvolutionScale[2] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionScale[2] = param;
 	 break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS:
+         if (ctx->Pixel.PostConvolutionBias[2] == param)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_PIXEL);
          ctx->Pixel.PostConvolutionBias[2] = param;
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
          return;
    }
-
-   if (ctx->Pixel.RedScale!=1.0F   || ctx->Pixel.RedBias!=0.0F ||
-       ctx->Pixel.GreenScale!=1.0F || ctx->Pixel.GreenBias!=0.0F ||
-       ctx->Pixel.BlueScale!=1.0F  || ctx->Pixel.BlueBias!=0.0F ||
-       ctx->Pixel.AlphaScale!=1.0F || ctx->Pixel.AlphaBias!=0.0F) {
-      ctx->Pixel.ScaleOrBiasRGBA = GL_TRUE;
-   }
-   else {
-      ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
-   }
-
-   if (ctx->Pixel.PostColorMatrixScale[0] != 1.0F ||
-       ctx->Pixel.PostColorMatrixBias[0]  != 0.0F ||
-       ctx->Pixel.PostColorMatrixScale[1] != 1.0F ||
-       ctx->Pixel.PostColorMatrixBias[1]  != 0.0F ||
-       ctx->Pixel.PostColorMatrixScale[2] != 1.0F ||
-       ctx->Pixel.PostColorMatrixBias[2]  != 0.0F ||
-       ctx->Pixel.PostColorMatrixScale[3] != 1.0F ||
-       ctx->Pixel.PostColorMatrixBias[3]  != 0.0F) {
-      ctx->Pixel.ScaleOrBiasRGBApcm = GL_TRUE;
-   }
-   else {
-      ctx->Pixel.ScaleOrBiasRGBApcm = GL_FALSE;
-   }
 }
 
 
@@ -668,38 +794,34 @@
  * Apply scale and bias factors to an array of RGBA pixels.
  */
 void
-_mesa_scale_and_bias_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4])
+_mesa_scale_and_bias_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4],
+                          GLfloat rScale, GLfloat gScale,
+                          GLfloat bScale, GLfloat aScale,
+                          GLfloat rBias, GLfloat gBias,
+                          GLfloat bBias, GLfloat aBias)
 {
-   if (ctx->Pixel.RedScale != 1.0 || ctx->Pixel.RedBias != 0.0) {
-      const GLfloat scale = ctx->Pixel.RedScale;
-      const GLfloat bias = ctx->Pixel.RedBias;
+   if (rScale != 1.0 || rBias != 0.0) {
       GLuint i;
       for (i = 0; i < n; i++) {
-         rgba[i][RCOMP] = rgba[i][RCOMP] * scale + bias;
+         rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
       }
    }
-   if (ctx->Pixel.GreenScale != 1.0 || ctx->Pixel.GreenBias != 0.0) {
-      const GLfloat scale = ctx->Pixel.GreenScale;
-      const GLfloat bias = ctx->Pixel.GreenBias;
+   if (gScale != 1.0 || gBias != 0.0) {
       GLuint i;
       for (i = 0; i < n; i++) {
-         rgba[i][GCOMP] = rgba[i][GCOMP] * scale + bias;
+         rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
       }
    }
-   if (ctx->Pixel.BlueScale != 1.0 || ctx->Pixel.BlueBias != 0.0) {
-      const GLfloat scale = ctx->Pixel.BlueScale;
-      const GLfloat bias = ctx->Pixel.BlueBias;
+   if (bScale != 1.0 || bBias != 0.0) {
       GLuint i;
       for (i = 0; i < n; i++) {
-         rgba[i][BCOMP] = rgba[i][BCOMP] * scale + bias;
+         rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
       }
    }
-   if (ctx->Pixel.AlphaScale != 1.0 || ctx->Pixel.AlphaBias != 0.0) {
-      const GLfloat scale = ctx->Pixel.AlphaScale;
-      const GLfloat bias = ctx->Pixel.AlphaBias;
+   if (aScale != 1.0 || aBias != 0.0) {
       GLuint i;
       for (i = 0; i < n; i++) {
-         rgba[i][ACOMP] = rgba[i][ACOMP] * scale + bias;
+         rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
       }
    }
 }
@@ -711,10 +833,10 @@
 void
 _mesa_map_rgba( const GLcontext *ctx, GLuint n, GLfloat rgba[][4] )
 {
-   const GLfloat rscale = ctx->Pixel.MapRtoRsize - 1;
-   const GLfloat gscale = ctx->Pixel.MapGtoGsize - 1;
-   const GLfloat bscale = ctx->Pixel.MapBtoBsize - 1;
-   const GLfloat ascale = ctx->Pixel.MapAtoAsize - 1;
+   const GLfloat rscale = (GLfloat) (ctx->Pixel.MapRtoRsize - 1);
+   const GLfloat gscale = (GLfloat) (ctx->Pixel.MapGtoGsize - 1);
+   const GLfloat bscale = (GLfloat) (ctx->Pixel.MapBtoBsize - 1);
+   const GLfloat ascale = (GLfloat) (ctx->Pixel.MapAtoAsize - 1);
    const GLfloat *rMap = ctx->Pixel.MapRtoR;
    const GLfloat *gMap = ctx->Pixel.MapGtoG;
    const GLfloat *bMap = ctx->Pixel.MapBtoB;
@@ -725,10 +847,10 @@
       GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
       GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
       GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
-      rgba[i][RCOMP] = rMap[(GLint) (r * rscale + 0.5F)];
-      rgba[i][GCOMP] = gMap[(GLint) (g * gscale + 0.5F)];
-      rgba[i][BCOMP] = bMap[(GLint) (b * bscale + 0.5F)];
-      rgba[i][ACOMP] = aMap[(GLint) (a * ascale + 0.5F)];
+      rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
+      rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
+      rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
+      rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
    }
 }
 
@@ -769,21 +891,21 @@
 _mesa_lookup_rgba(const struct gl_color_table *table,
                   GLuint n, GLfloat rgba[][4])
 {
-   ASSERT(table->TableType == GL_FLOAT);
-   if (!table->Table)
+   ASSERT(table->FloatTable);
+   if (!table->Table || table->Size == 0)
       return;
 
    switch (table->Format) {
       case GL_INTENSITY:
          /* replace RGBA with I */
-         if (table->TableType == GL_UNSIGNED_BYTE) {
+         if (!table->FloatTable) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLubyte *lut = (const GLubyte *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint j = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLfloat c = lut[CLAMP(j, 0, max)] * (1.0F / 255.0F);
+               GLint j = IROUND(rgba[i][RCOMP] * scale);
+               GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, 1)]);
                rgba[i][RCOMP] = rgba[i][GCOMP] =
                   rgba[i][BCOMP] = rgba[i][ACOMP] = c;
             }
@@ -795,7 +917,7 @@
             const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint j = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
+               GLint j = IROUND(rgba[i][RCOMP] * scale);
                GLfloat c = lut[CLAMP(j, 0, max)];
                rgba[i][RCOMP] = rgba[i][GCOMP] =
                   rgba[i][BCOMP] = rgba[i][ACOMP] = c;
@@ -804,14 +926,14 @@
          break;
       case GL_LUMINANCE:
          /* replace RGB with L */
-         if (table->TableType == GL_UNSIGNED_BYTE) {
+         if (!table->FloatTable) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLubyte *lut = (const GLubyte *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint j = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLfloat c = lut[CLAMP(j, 0, max)] * (1.0F / 255.0F);
+               GLint j = IROUND(rgba[i][RCOMP] * scale);
+               GLfloat c = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
             }
          }
@@ -821,7 +943,7 @@
             const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint j = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
+               GLint j = IROUND(rgba[i][RCOMP] * scale);
                GLfloat c = lut[CLAMP(j, 0, max)];
                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = c;
             }
@@ -829,14 +951,14 @@
          break;
       case GL_ALPHA:
          /* replace A with A */
-         if (table->TableType == GL_UNSIGNED_BYTE) {
+         if (!table->FloatTable) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLubyte *lut = (const GLubyte *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint j = (GLint) (rgba[i][ACOMP] * scale + 0.5F);
-               rgba[i][ACOMP] = lut[CLAMP(j, 0, max)] * (1.0F / 255.0F);
+               GLint j = IROUND(rgba[i][ACOMP] * scale);
+               rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[CLAMP(j, 0, max)]);
             }
          }
          else  {
@@ -845,26 +967,26 @@
             const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint j = (GLint) (rgba[i][ACOMP] * scale + 0.5F);
+               GLint j = IROUND(rgba[i][ACOMP] * scale);
                rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
             }
          }
          break;
       case GL_LUMINANCE_ALPHA:
          /* replace RGBA with LLLA */
-         if (table->TableType == GL_UNSIGNED_BYTE) {
+         if (!table->FloatTable) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLubyte *lut = (const GLubyte *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint jL = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLint jA = (GLint) (rgba[i][ACOMP] * scale + 0.5F);
+               GLint jL = IROUND(rgba[i][RCOMP] * scale);
+               GLint jA = IROUND(rgba[i][ACOMP] * scale);
                GLfloat luminance, alpha;
                jL = CLAMP(jL, 0, max);
                jA = CLAMP(jA, 0, max);
-               luminance = lut[jL * 2 + 0] * (1.0F / 255.0F);
-               alpha     = lut[jA * 2 + 1] * (1.0F / 255.0F);
+               luminance = CHAN_TO_FLOAT(lut[jL * 2 + 0]);
+               alpha     = CHAN_TO_FLOAT(lut[jA * 2 + 1]);
                rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = luminance;
                rgba[i][ACOMP] = alpha;;
             }
@@ -875,8 +997,8 @@
             const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint jL = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLint jA = (GLint) (rgba[i][ACOMP] * scale + 0.5F);
+               GLint jL = IROUND(rgba[i][RCOMP] * scale);
+               GLint jA = IROUND(rgba[i][ACOMP] * scale);
                GLfloat luminance, alpha;
                jL = CLAMP(jL, 0, max);
                jA = CLAMP(jA, 0, max);
@@ -889,21 +1011,21 @@
          break;
       case GL_RGB:
          /* replace RGB with RGB */
-         if (table->TableType == GL_UNSIGNED_BYTE) {
+         if (!table->FloatTable) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLubyte *lut = (const GLubyte *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint jR = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLint jG = (GLint) (rgba[i][GCOMP] * scale + 0.5F);
-               GLint jB = (GLint) (rgba[i][BCOMP] * scale + 0.5F);
+               GLint jR = IROUND(rgba[i][RCOMP] * scale);
+               GLint jG = IROUND(rgba[i][GCOMP] * scale);
+               GLint jB = IROUND(rgba[i][BCOMP] * scale);
                jR = CLAMP(jR, 0, max);
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
-               rgba[i][RCOMP] = lut[jR * 3 + 0] * (1.0F / 255.0F);
-               rgba[i][GCOMP] = lut[jG * 3 + 1] * (1.0F / 255.0F);
-               rgba[i][BCOMP] = lut[jB * 3 + 2] * (1.0F / 255.0F);
+               rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 3 + 0]);
+               rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 3 + 1]);
+               rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 3 + 2]);
             }
          }
          else {
@@ -912,9 +1034,9 @@
             const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint jR = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLint jG = (GLint) (rgba[i][GCOMP] * scale + 0.5F);
-               GLint jB = (GLint) (rgba[i][BCOMP] * scale + 0.5F);
+               GLint jR = IROUND(rgba[i][RCOMP] * scale);
+               GLint jG = IROUND(rgba[i][GCOMP] * scale);
+               GLint jB = IROUND(rgba[i][BCOMP] * scale);
                jR = CLAMP(jR, 0, max);
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
@@ -926,24 +1048,24 @@
          break;
       case GL_RGBA:
          /* replace RGBA with RGBA */
-         if (table->TableType == GL_UNSIGNED_BYTE) {
+         if (!table->FloatTable) {
             const GLint max = table->Size - 1;
             const GLfloat scale = (GLfloat) max;
-            const GLubyte *lut = (const GLubyte *) table->Table;
+            const GLchan *lut = (const GLchan *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint jR = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLint jG = (GLint) (rgba[i][GCOMP] * scale + 0.5F);
-               GLint jB = (GLint) (rgba[i][BCOMP] * scale + 0.5F);
-               GLint jA = (GLint) (rgba[i][ACOMP] * scale + 0.5F);
+               GLint jR = IROUND(rgba[i][RCOMP] * scale);
+               GLint jG = IROUND(rgba[i][GCOMP] * scale);
+               GLint jB = IROUND(rgba[i][BCOMP] * scale);
+               GLint jA = IROUND(rgba[i][ACOMP] * scale);
                jR = CLAMP(jR, 0, max);
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
                jA = CLAMP(jA, 0, max);
-               rgba[i][RCOMP] = lut[jR * 4 + 0] * (1.0F / 255.0F);
-               rgba[i][GCOMP] = lut[jG * 4 + 1] * (1.0F / 255.0F);
-               rgba[i][BCOMP] = lut[jB * 4 + 2] * (1.0F / 255.0F);
-               rgba[i][ACOMP] = lut[jA * 4 + 3] * (1.0F / 255.0F);
+               rgba[i][RCOMP] = CHAN_TO_FLOAT(lut[jR * 4 + 0]);
+               rgba[i][GCOMP] = CHAN_TO_FLOAT(lut[jG * 4 + 1]);
+               rgba[i][BCOMP] = CHAN_TO_FLOAT(lut[jB * 4 + 2]);
+               rgba[i][ACOMP] = CHAN_TO_FLOAT(lut[jA * 4 + 3]);
             }
          }
          else {
@@ -952,10 +1074,10 @@
             const GLfloat *lut = (const GLfloat *) table->Table;
             GLuint i;
             for (i = 0; i < n; i++) {
-               GLint jR = (GLint) (rgba[i][RCOMP] * scale + 0.5F);
-               GLint jG = (GLint) (rgba[i][GCOMP] * scale + 0.5F);
-               GLint jB = (GLint) (rgba[i][BCOMP] * scale + 0.5F);
-               GLint jA = (GLint) (rgba[i][ACOMP] * scale + 0.5F);
+               GLint jR = IROUND(rgba[i][RCOMP] * scale);
+               GLint jG = IROUND(rgba[i][GCOMP] * scale);
+               GLint jB = IROUND(rgba[i][BCOMP] * scale);
+               GLint jA = IROUND(rgba[i][ACOMP] * scale);
                jR = CLAMP(jR, 0, max);
                jG = CLAMP(jG, 0, max);
                jB = CLAMP(jB, 0, max);
@@ -968,7 +1090,7 @@
          }
          break;
       default:
-         gl_problem(NULL, "Bad format in _mesa_lookup_rgba");
+         _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba");
          return;
    }
 }
@@ -1021,9 +1143,10 @@
  * Map color indexes to rgba values.
  */
 void
-_mesa_map_ci_to_rgba_ubyte( const GLcontext *ctx, GLuint n,
-                            const GLuint index[], GLubyte rgba[][4] )
+_mesa_map_ci_to_rgba_chan( const GLcontext *ctx, GLuint n,
+                           const GLuint index[], GLchan rgba[][4] )
 {
+#if CHAN_BITS == 8
    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
@@ -1039,6 +1162,23 @@
       rgba[i][BCOMP] = bMap[index[i] & bmask];
       rgba[i][ACOMP] = aMap[index[i] & amask];
    }
+#else
+   GLuint rmask = ctx->Pixel.MapItoRsize - 1;
+   GLuint gmask = ctx->Pixel.MapItoGsize - 1;
+   GLuint bmask = ctx->Pixel.MapItoBsize - 1;
+   GLuint amask = ctx->Pixel.MapItoAsize - 1;
+   const GLfloat *rMap = ctx->Pixel.MapItoR;
+   const GLfloat *gMap = ctx->Pixel.MapItoG;
+   const GLfloat *bMap = ctx->Pixel.MapItoB;
+   const GLfloat *aMap = ctx->Pixel.MapItoA;
+   GLuint i;
+   for (i=0;i<n;i++) {
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
+   }
+#endif
 }
 
 
@@ -1072,8 +1212,9 @@
  */
 void
 _mesa_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
-                       GLubyte rgba[][4] )
+                       GLchan rgba[][4] )
 {
+#if CHAN_BITS == 8
    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
@@ -1089,6 +1230,23 @@
       rgba[i][BCOMP] = bMap[index[i] & bmask];
       rgba[i][ACOMP] = aMap[index[i] & amask];
    }
+#else
+   GLuint rmask = ctx->Pixel.MapItoRsize - 1;
+   GLuint gmask = ctx->Pixel.MapItoGsize - 1;
+   GLuint bmask = ctx->Pixel.MapItoBsize - 1;
+   GLuint amask = ctx->Pixel.MapItoAsize - 1;
+   const GLfloat *rMap = ctx->Pixel.MapItoR;
+   const GLfloat *gMap = ctx->Pixel.MapItoG;
+   const GLfloat *bMap = ctx->Pixel.MapItoB;
+   const GLfloat *aMap = ctx->Pixel.MapItoA;
+   GLuint i;
+   for (i=0;i<n;i++) {
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], rMap[index[i] & rmask]);
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], gMap[index[i] & gmask]);
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], bMap[index[i] & bmask]);
+      CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], aMap[index[i] & amask]);
+   }
+#endif
 }
 
 
@@ -1127,4 +1285,53 @@
    for (i=0;i<n;i++) {
       stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
    }
+}
+
+
+
+/*
+ * This function converts an array of GLchan colors to GLfloat colors.
+ * Most importantly, it undoes the non-uniform quantization of pixel
+ * values introduced when we convert shallow (< 8 bit) pixel values
+ * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
+ * This fixes a number of OpenGL conformance failures when running on
+ * 16bpp displays, for example.
+ */
+void
+_mesa_chan_to_float_span(const GLcontext *ctx, GLuint n,
+                         CONST GLchan rgba[][4], GLfloat rgbaf[][4])
+{
+#if CHAN_TYPE == GL_FLOAT
+   MEMCPY(rgbaf, rgba, n * 4 * sizeof(GLfloat));
+#else
+   const GLuint rShift = CHAN_BITS - ctx->Visual.redBits;
+   const GLuint gShift = CHAN_BITS - ctx->Visual.greenBits;
+   const GLuint bShift = CHAN_BITS - ctx->Visual.blueBits;
+   GLuint aShift;
+   const GLfloat rScale = 1.0F / (GLfloat) ((1 << ctx->Visual.redBits  ) - 1);
+   const GLfloat gScale = 1.0F / (GLfloat) ((1 << ctx->Visual.greenBits) - 1);
+   const GLfloat bScale = 1.0F / (GLfloat) ((1 << ctx->Visual.blueBits ) - 1);
+   GLfloat aScale;
+   GLuint i;
+
+   if (ctx->Visual.alphaBits > 0) {
+      aShift = CHAN_BITS - ctx->Visual.alphaBits;
+      aScale = 1.0F / (GLfloat) ((1 << ctx->Visual.alphaBits) - 1);
+   }
+   else {
+      aShift = 0;
+      aScale = 1.0F / CHAN_MAXF;
+   }
+
+   for (i = 0; i < n; i++) {
+      const GLint r = rgba[i][RCOMP] >> rShift;
+      const GLint g = rgba[i][GCOMP] >> gShift;
+      const GLint b = rgba[i][BCOMP] >> bShift;
+      const GLint a = rgba[i][ACOMP] >> aShift;
+      rgbaf[i][RCOMP] = (GLfloat) r * rScale;
+      rgbaf[i][GCOMP] = (GLfloat) g * gScale;
+      rgbaf[i][BCOMP] = (GLfloat) b * bScale;
+      rgbaf[i][ACOMP] = (GLfloat) a * aScale;
+   }
+#endif
 }
Index: xc/extras/Mesa/src/pixel.h
diff -u xc/extras/Mesa/src/pixel.h:1.4 xc/extras/Mesa/src/pixel.h:1.5
--- xc/extras/Mesa/src/pixel.h:1.4	Fri Jun 16 20:02:14 2000
+++ xc/extras/Mesa/src/pixel.h	Fri Feb 22 14:25:38 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define PIXEL_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 /*
@@ -76,9 +76,12 @@
  */
 
 extern void
-_mesa_scale_and_bias_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4]);
+_mesa_scale_and_bias_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4],
+                          GLfloat rScale, GLfloat gScale,
+                          GLfloat bScale, GLfloat aScale,
+                          GLfloat rBias, GLfloat gBias,
+                          GLfloat bBias, GLfloat aBias);
 
-
 extern void
 _mesa_map_rgba(const GLcontext *ctx, GLuint n, GLfloat rgba[][4]);
 
@@ -102,9 +105,9 @@
 
 
 extern void
-_mesa_map_ci_to_rgba_ubyte(const GLcontext *ctx,
-                           GLuint n, const GLuint index[],
-                           GLubyte rgba[][4]);
+_mesa_map_ci_to_rgba_chan(const GLcontext *ctx,
+                          GLuint n, const GLuint index[],
+                          GLchan rgba[][4]);
 
 
 extern void
@@ -115,7 +118,7 @@
 extern void
 _mesa_map_ci8_to_rgba(const GLcontext *ctx,
                       GLuint n, const GLubyte index[],
-                      GLubyte rgba[][4]);
+                      GLchan rgba[][4]);
 
 
 extern void
@@ -125,6 +128,11 @@
 
 extern void
 _mesa_map_stencil(const GLcontext *ctx, GLuint n, GLstencil index[]);
+
+
+extern void
+_mesa_chan_to_float_span(const GLcontext *ctx, GLuint n,
+                         CONST GLchan rgba[][4], GLfloat rgbaf[][4]);
 
 
 #endif
Index: xc/extras/Mesa/src/pixeltex.c
diff -u xc/extras/Mesa/src/pixeltex.c:1.1 xc/extras/Mesa/src/pixeltex.c:removed
--- xc/extras/Mesa/src/pixeltex.c:1.1	Fri Jun 16 20:02:14 2000
+++ xc/extras/Mesa/src/pixeltex.c	Thu Feb 27 12:15:41 2003
@@ -1,204 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * This file implements both the GL_SGIX_pixel_texture and
- * GL_SIGS_pixel_texture extensions. Luckily, they pretty much
- * overlap in functionality so we use the same state variables
- * and execution code for both.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "pixeltex.h"
-#endif
-
-
-void
-_mesa_PixelTexGenSGIX(GLenum mode)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelTexGenSGIX");
-
-   switch (mode) {
-      case GL_NONE:
-         ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
-         ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
-         break;
-      case GL_ALPHA:
-         ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
-         ctx->Pixel.FragmentAlphaSource = GL_CURRENT_RASTER_COLOR;
-         break;
-      case GL_RGB:
-         ctx->Pixel.FragmentRgbSource = GL_CURRENT_RASTER_COLOR;
-         ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
-         break;
-      case GL_RGBA:
-         ctx->Pixel.FragmentRgbSource = GL_CURRENT_RASTER_COLOR;
-         ctx->Pixel.FragmentAlphaSource = GL_CURRENT_RASTER_COLOR;
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glPixelTexGenSGIX(mode)");
-         return;
-   }
-}
-
-
-void
-_mesa_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
-{
-   _mesa_PixelTexGenParameteriSGIS(target, (GLint) value);
-}
-
-
-void
-_mesa_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
-{
-   _mesa_PixelTexGenParameteriSGIS(target, (GLint) *value);
-}
-
-
-void
-_mesa_PixelTexGenParameteriSGIS(GLenum target, GLint value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPixelTexGenParameterSGIS");
-
-   if (value != GL_CURRENT_RASTER_COLOR && value != GL_PIXEL_GROUP_COLOR_SGIS) {
-      gl_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(value)");
-      return;
-   }
-
-   if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
-      ctx->Pixel.FragmentRgbSource = (GLenum) value;
-   }
-   else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
-      ctx->Pixel.FragmentAlphaSource = (GLenum) value;
-   }
-   else {
-      gl_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(target)");
-   }
-}
-
-
-void
-_mesa_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
-{
-  _mesa_PixelTexGenParameteriSGIS(target, *value);
-}
-
-
-void
-_mesa_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetPixelTexGenParameterfvSGIS");
-
-   if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
-      *value = (GLfloat) ctx->Pixel.FragmentRgbSource;
-   }
-   else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
-      *value = (GLfloat) ctx->Pixel.FragmentAlphaSource;
-   }
-   else {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterfvSGIS(target)");
-   }
-}
-
-
-void
-_mesa_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetPixelTexGenParameterivSGIS");
-
-   if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
-      *value = (GLint) ctx->Pixel.FragmentRgbSource;
-   }
-   else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
-      *value = (GLint) ctx->Pixel.FragmentAlphaSource;
-   }
-   else {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterivSGIS(target)");
-   }
-}
-
-
-
-/*
- * Convert RGBA values into strq texture coordinates.
- */
-void
-_mesa_pixeltexgen(GLcontext *ctx, GLuint n, const GLubyte rgba[][4],
-                  GLfloat s[], GLfloat t[], GLfloat r[], GLfloat q[])
-{
-   static GLboolean firstCall = GL_TRUE;
-   static GLfloat byteToFloat[256];
-
-   if (firstCall) {
-      GLuint i;
-      for (i = 0; i < 256; i++) {
-         byteToFloat[i] = i / 255.0F;
-      }
-      firstCall = GL_FALSE;
-   }
-
-   if (ctx->Pixel.FragmentRgbSource == GL_CURRENT_RASTER_COLOR) {
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         s[i] = ctx->Current.RasterColor[RCOMP];
-         t[i] = ctx->Current.RasterColor[GCOMP];
-         r[i] = ctx->Current.RasterColor[BCOMP];
-      }
-   }
-   else {
-      GLuint i;
-      ASSERT(ctx->Pixel.FragmentRgbSource == GL_PIXEL_GROUP_COLOR_SGIS);
-      for (i = 0; i < n; i++) {
-         s[i] = byteToFloat[rgba[i][RCOMP]];
-         t[i] = byteToFloat[rgba[i][GCOMP]];
-         r[i] = byteToFloat[rgba[i][BCOMP]];
-      }
-   }
-
-   if (ctx->Pixel.FragmentAlphaSource == GL_CURRENT_RASTER_COLOR) {
-      GLuint i;
-      for (i = 0; i < n; i++) {
-         q[i] = ctx->Current.RasterColor[ACOMP];
-      }
-   }
-   else {
-      GLuint i;
-      ASSERT(ctx->Pixel.FragmentAlphaSource == GL_PIXEL_GROUP_COLOR_SGIS);
-      for (i = 0; i < n; i++) {
-         q[i] = byteToFloat[rgba[i][ACOMP]];
-      }
-   }
-}
Index: xc/extras/Mesa/src/pixeltex.h
diff -u xc/extras/Mesa/src/pixeltex.h:1.1 xc/extras/Mesa/src/pixeltex.h:removed
--- xc/extras/Mesa/src/pixeltex.h:1.1	Fri Jun 16 20:02:15 2000
+++ xc/extras/Mesa/src/pixeltex.h	Thu Feb 27 12:15:41 2003
@@ -1,69 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright noti_mesa_PixelTexGenParameterfvce 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
- * BRIAN PAUL 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.
- */
-
-
-#ifndef PIXELTEX_H
-#define PIXELTEX_H
-
-
-extern void
-_mesa_PixelTexGenSGIX(GLenum mode);
-
-extern void
-_mesa_PixelTexGenParameterfSGIS(GLenum target, GLfloat value);
-
-#ifdef VMS
-#define _mesa_PixelTexGenParameterfvSGIS _mesa_PixelTexGenParameterfv
-#endif
-extern void
-_mesa_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value);
-
-extern void
-_mesa_PixelTexGenParameteriSGIS(GLenum target, GLint value);
-
-#ifdef VMS
-#define _mesa_PixelTexGenParameterivSGIS _mesa_PixelTexGenParameteriv
-#endif
-extern void
-_mesa_PixelTexGenParameterivSGIS(GLenum target, const GLint *value);
-
-#ifdef VMS
-#define _mesa_GetPixelTexGenParameterfvSGIS _mesa_GetPixelTexGenParameterfv
-#endif
-extern void
-_mesa_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value);
-
-#ifdef VMS
-#define _mesa_GetPixelTexGenParameterivSGIS _mesa_GetPixelTexGenParameteriv
-#endif
-extern void
-_mesa_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value);
-
-extern void
-_mesa_pixeltexgen(GLcontext *ctx, GLuint n, const GLubyte rgba[][4],
-                  GLfloat s[], GLfloat t[], GLfloat r[], GLfloat q[]);
-
-
-#endif
Index: xc/extras/Mesa/src/points.c
diff -u xc/extras/Mesa/src/points.c:1.8 xc/extras/Mesa/src/points.c:1.9
--- xc/extras/Mesa/src/points.c:1.8	Tue Dec 11 04:18:54 2001
+++ xc/extras/Mesa/src/points.c	Fri Feb 22 14:25:38 2002
@@ -1,20 +1,19 @@
-/* $XFree86: xc/extras/Mesa/src/points.c,v 1.8 2001/12/11 09:18:54 alanh Exp $ */
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -29,15 +28,11 @@
 #else
 #include "glheader.h"
 #include "context.h"
-#include "feedback.h"
 #include "macros.h"
 #include "mmath.h"
-#include "pb.h"
 #include "points.h"
-#include "span.h"
 #include "texstate.h"
-#include "types.h"
-#include "vb.h"
+#include "mtypes.h"
 #endif
 
 
@@ -46,21 +41,29 @@
 _mesa_PointSize( GLfloat size )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPointSize");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (size <= 0.0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glPointSize" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glPointSize" );
       return;
    }
 
-   if (ctx->Point.UserSize != size) {
-      ctx->Point.UserSize = size;
-      ctx->Point.Size = CLAMP(size, ctx->Const.MinPointSize, ctx->Const.MaxPointSize);
-      ctx->TriangleCaps &= ~DD_POINT_SIZE;
-      if (size != 1.0)
-         ctx->TriangleCaps |= DD_POINT_SIZE;
-      ctx->NewState |= NEW_RASTER_OPS;
-   }
+   if (ctx->Point.Size == size)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_POINT);
+   ctx->Point.Size = size;
+   ctx->Point._Size = CLAMP(size,
+			    ctx->Const.MinPointSize,
+			    ctx->Const.MaxPointSize);
+
+   if (ctx->Point._Size == 1.0F)
+      ctx->_TriangleCaps &= ~DD_POINT_SIZE;
+   else
+      ctx->_TriangleCaps |= DD_POINT_SIZE;
+
+   if (ctx->Driver.PointSize)
+      (*ctx->Driver.PointSize)(ctx, size);
 }
 
 
@@ -76,1369 +79,67 @@
 _mesa_PointParameterfvEXT( GLenum pname, const GLfloat *params)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPointParameterfvEXT");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (pname) {
       case GL_DISTANCE_ATTENUATION_EXT:
          {
-            const GLboolean tmp = ctx->Point.Attenuated;
+            const GLboolean tmp = ctx->Point._Attenuated;
+            if (TEST_EQ_3V(ctx->Point.Params, params))
+	       return;
+
+	    FLUSH_VERTICES(ctx, _NEW_POINT);
             COPY_3V(ctx->Point.Params, params);
-            ctx->Point.Attenuated = (params[0] != 1.0 ||
-                                     params[1] != 0.0 ||
-                                     params[2] != 0.0);
 
-            if (tmp != ctx->Point.Attenuated) {
-               ctx->Enabled ^= ENABLE_POINT_ATTEN;
-               ctx->TriangleCaps ^= DD_POINT_ATTEN;
-               ctx->NewState |= NEW_RASTER_OPS;
+	    /* Update several derived values now.  This likely to be
+	     * more efficient than trying to catch this statechange in
+	     * state.c.
+	     */
+            ctx->Point._Attenuated = (params[0] != 1.0 ||
+				      params[1] != 0.0 ||
+				      params[2] != 0.0);
+
+            if (tmp != ctx->Point._Attenuated) {
+               ctx->_TriangleCaps ^= DD_POINT_ATTEN;
+	       ctx->_NeedEyeCoords ^= NEED_EYE_POINT_ATTEN;
             }
          }
          break;
       case GL_POINT_SIZE_MIN_EXT:
          if (*params < 0.0F) {
-            gl_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
             return;
          }
+         if (ctx->Point.MinSize == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_POINT);
          ctx->Point.MinSize = *params;
          break;
       case GL_POINT_SIZE_MAX_EXT:
          if (*params < 0.0F) {
-            gl_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
             return;
          }
+         if (ctx->Point.MaxSize == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_POINT);
          ctx->Point.MaxSize = *params;
          break;
       case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
          if (*params < 0.0F) {
-            gl_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glPointParameterfvEXT" );
             return;
          }
+         if (ctx->Point.Threshold == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_POINT);
          ctx->Point.Threshold = *params;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glPointParameterfvEXT" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glPointParameterfvEXT" );
          return;
    }
-
-   ctx->NewState |= NEW_RASTER_OPS;
-}
-
-
-/**********************************************************************/
-/*****                    Rasterization                           *****/
-/**********************************************************************/
-
-
-/*
- * There are 3 pairs (RGBA, CI) of point rendering functions:
- *   1. simple:  size=1 and no special rasterization functions (fastest)
- *   2. size1:  size=1 and any rasterization functions
- *   3. general:  any size and rasterization functions (slowest)
- *
- * All point rendering functions take the same two arguments: first and
- * last which specify that the points specified by VB[first] through
- * VB[last] are to be rendered.
- */
-
-
-
-
-
-/*
- * CI points with size == 1.0
- */
-static void
-size1_ci_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLfloat *win;
-   GLint *pbx = PB->x, *pby = PB->y;
-   GLdepth *pbz = PB->z;
-   GLuint *pbi = PB->index;
-   GLuint pbcount = PB->count;
-   GLuint i;
-
-   win = &VB->Win.data[first][0];
-   for (i = first; i < last; i++) {
-      if (VB->ClipMask[i] == 0) {
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-         pbx[pbcount] = (GLint)  win[0];
-         pby[pbcount] = (GLint)  win[1];
-         pbz[pbcount] = (GLint) (win[2] + ctx->PointZoffset);
-         pbi[pbcount] = VB->IndexPtr->data[i];
-         pbcount++;
-      }
-      win += 3;
-   }
-   PB->count = pbcount;
-   PB_CHECK_FLUSH(ctx, PB);
-}
-
-
-
-/*
- * RGBA points with size == 1.0
- */
-static void
-size1_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLuint i;
-
-   for (i = first; i < last; i++) {
-      if (VB->ClipMask[i] == 0) {
-         GLint x, y, z;
-         GLint red, green, blue, alpha;
-	 GLfloat *win = VB->Win.data[i];
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         x = (GLint)  win[0];
-         y = (GLint)  win[1];
-         z = (GLint) (win[2] + ctx->PointZoffset);
-
-         red   = VB->ColorPtr->data[i][0];
-         green = VB->ColorPtr->data[i][1];
-         blue  = VB->ColorPtr->data[i][2];
-         alpha = VB->ColorPtr->data[i][3];
-
-         PB_WRITE_RGBA_PIXEL( PB, x, y, z, red, green, blue, alpha );
-      }
-   }
-   PB_CHECK_FLUSH(ctx, PB);
-}
-
-
-
-/*
- * General CI points.
- */
-static void
-general_ci_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   const GLint isize = (GLint) (ctx->Point.Size + 0.5F);
-   GLint radius = isize >> 1;
-   GLuint i;
-
-   for (i = first; i < last; i++) {
-      if (VB->ClipMask[i] == 0) {
-         GLint x0, x1, y0, y1;
-         GLint ix, iy;
-	 GLfloat *win = VB->Win.data[i];
-         GLint x = (GLint)  win[0];
-         GLint y = (GLint)  win[1];
-         GLint z = (GLint) (win[2] + ctx->PointZoffset);
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         if (isize & 1) {
-            /* odd size */
-            x0 = x - radius;
-            x1 = x + radius;
-            y0 = y - radius;
-            y1 = y + radius;
-         }
-         else {
-            /* even size */
-            x0 = (GLint) (x + 1.5F) - radius;
-            x1 = x0 + isize - 1;
-            y0 = (GLint) (y + 1.5F) - radius;
-            y1 = y0 + isize - 1;
-         }
-
-         PB_SET_INDEX( PB, VB->IndexPtr->data[i] );
-
-         for (iy = y0; iy <= y1; iy++) {
-            for (ix = x0; ix <= x1; ix++) {
-               PB_WRITE_PIXEL( PB, ix, iy, z );
-            }
-         }
-         PB_CHECK_FLUSH(ctx,PB);
-      }
-   }
-}
-
-
-/*
- * General RGBA points.
- */
-static void
-general_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLint isize = (GLint) (ctx->Point.Size + 0.5F);
-   GLint radius = isize >> 1;
-   GLuint i;
-
-   for (i = first; i < last; i++) {
-      if (VB->ClipMask[i] == 0) {
-         GLint x0, x1, y0, y1;
-         GLint ix, iy;
-	 GLfloat *win = VB->Win.data[i];
-         GLint x = (GLint)  win[0];
-         GLint y = (GLint)  win[1];
-         GLint z = (GLint) (win[2] + ctx->PointZoffset);
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         if (isize & 1) {
-            /* odd size */
-            x0 = x - radius;
-            x1 = x + radius;
-            y0 = y - radius;
-            y1 = y + radius;
-         }
-         else {
-            /* even size */
-            x0 = (GLint) (x + 1.5F) - radius;
-            x1 = x0 + isize - 1;
-            y0 = (GLint) (y + 1.5F) - radius;
-            y1 = y0 + isize - 1;
-         }
-
-         PB_SET_COLOR( PB,
-                       VB->ColorPtr->data[i][0],
-                       VB->ColorPtr->data[i][1],
-                       VB->ColorPtr->data[i][2],
-                       VB->ColorPtr->data[i][3] );
-
-         for (iy = y0; iy <= y1; iy++) {
-            for (ix = x0; ix <= x1; ix++) {
-               PB_WRITE_PIXEL( PB, ix, iy, z );
-            }
-         }
-         PB_CHECK_FLUSH(ctx,PB);
-      }
-   }
-}
-
-
-
-
-/*
- * Textured RGBA points.
- */
-static void
-textured_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLuint i;
-
-   for (i = first; i < last; i++) {
-      if (VB->ClipMask[i] == 0) {
-         GLint x0, x1, y0, y1;
-         GLint ix, iy, radius;
-         GLint red, green, blue, alpha;
-         GLfloat s, t, u;
-         GLint isize = (GLint) (ctx->Point.Size + 0.5F);
-	 GLfloat *win = VB->Win.data[i];
-         GLint x = (GLint)  win[0];
-         GLint y = (GLint)  win[1];
-         GLint z = (GLint) (win[2] + ctx->PointZoffset);
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         if (isize < 1) {
-            isize = 1;
-         }
-         radius = isize >> 1;
-
-         if (isize & 1) {
-            /* odd size */
-            x0 = x - radius;
-            x1 = x + radius;
-            y0 = y - radius;
-            y1 = y + radius;
-         }
-         else {
-            /* even size */
-            x0 = (GLint) (x + 1.5F) - radius;
-            x1 = x0 + isize - 1;
-            y0 = (GLint) (y + 1.5F) - radius;
-            y1 = y0 + isize - 1;
-         }
-
-         red   = VB->ColorPtr->data[i][0];
-         green = VB->ColorPtr->data[i][1];
-         blue  = VB->ColorPtr->data[i][2];
-         alpha = VB->ColorPtr->data[i][3];
-
-	 switch (VB->TexCoordPtr[0]->size) {
-	 case 4:
-	    s = VB->TexCoordPtr[0]->data[i][0]/VB->TexCoordPtr[0]->data[i][3];
-	    t = VB->TexCoordPtr[0]->data[i][1]/VB->TexCoordPtr[0]->data[i][3];
-	    u = VB->TexCoordPtr[0]->data[i][2]/VB->TexCoordPtr[0]->data[i][3];
-	    break;
-	 case 3:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = VB->TexCoordPtr[0]->data[i][1];
-	    u = VB->TexCoordPtr[0]->data[i][2];
-	    break;
-	 case 2:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = VB->TexCoordPtr[0]->data[i][1];
-	    u = 0.0;
-	    break;
-	 case 1:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = 0.0;
-	    u = 0.0;
-	    break;
-         default:
-            /* should never get here */
-            s = t = u = 0.0;
-            gl_problem(ctx, "unexpected texcoord size in textured_rgba_points()");
-	 }
-
-         for (iy = y0; iy <= y1; iy++) {
-            for (ix = x0; ix <= x1; ix++) {
-               PB_WRITE_TEX_PIXEL( PB, ix, iy, z, red, green, blue, alpha,
-                                   s, t, u );
-            }
-         }
-
-         PB_CHECK_FLUSH(ctx, PB);
-      }
-   }
-}
-
-
-/*
- * Multitextured RGBA points.
- */
-static void
-multitextured_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLuint i;
-
-   for (i = first; i < last; i++) {
-      if (VB->ClipMask[i] == 0) {
-         GLint x0, x1, y0, y1;
-         GLint ix, iy;
-         GLint radius;
-         GLint red, green, blue, alpha;
-         GLint sRed, sGreen, sBlue;
-         GLfloat s, t, u;
-         GLfloat s1, t1, u1;
-         GLint isize = (GLint) (ctx->Point.Size + 0.5F);
-	 GLfloat *win = VB->Win.data[i];
-         GLint x = (GLint)  win[0];
-         GLint y = (GLint)  win[1];
-         GLint z = (GLint) (win[2] + ctx->PointZoffset);
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         if (isize < 1) {
-            isize = 1;
-         }
-         radius = isize >> 1;
-
-         if (isize & 1) {
-            /* odd size */
-            x0 = x - radius;
-            x1 = x + radius;
-            y0 = y - radius;
-            y1 = y + radius;
-         }
-         else {
-            /* even size */
-            x0 = (GLint) (x + 1.5F) - radius;
-            x1 = x0 + isize - 1;
-            y0 = (GLint) (y + 1.5F) - radius;
-            y1 = y0 + isize - 1;
-         }
-
-         red   = VB->ColorPtr->data[i][0];
-         green = VB->ColorPtr->data[i][1];
-         blue  = VB->ColorPtr->data[i][2];
-         alpha = VB->ColorPtr->data[i][3];
-	 sRed   = VB->Specular ? VB->Specular[i][0] : 0;
-	 sGreen = VB->Specular ? VB->Specular[i][1] : 0;
-	 sBlue  = VB->Specular ? VB->Specular[i][2] : 0;
-	 
-	 switch (VB->TexCoordPtr[0]->size) {
-	 case 4:
-	    s = VB->TexCoordPtr[0]->data[i][0]/VB->TexCoordPtr[0]->data[i][3];
-	    t = VB->TexCoordPtr[0]->data[i][1]/VB->TexCoordPtr[0]->data[i][3];
-	    u = VB->TexCoordPtr[0]->data[i][2]/VB->TexCoordPtr[0]->data[i][3];
-	    break;
-	 case 3:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = VB->TexCoordPtr[0]->data[i][1];
-	    u = VB->TexCoordPtr[0]->data[i][2];
-	    break;
-	 case 2:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = VB->TexCoordPtr[0]->data[i][1];
-	    u = 0.0;
-	    break;
-	 case 1:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = 0.0;
-	    u = 0.0;
-	    break;
-         default:
-            /* should never get here */
-            s = t = u = 0.0;
-            gl_problem(ctx, "unexpected texcoord size in multitextured_rgba_points()");
-	 }
-
-	 switch (VB->TexCoordPtr[1]->size) {
-	 case 4:
-	    s1 = VB->TexCoordPtr[1]->data[i][0]/VB->TexCoordPtr[1]->data[i][3];
-	    t1 = VB->TexCoordPtr[1]->data[i][1]/VB->TexCoordPtr[1]->data[i][3];
-	    u1 = VB->TexCoordPtr[1]->data[i][2]/VB->TexCoordPtr[1]->data[i][3];
-	    break;
-	 case 3:
-	    s1 = VB->TexCoordPtr[1]->data[i][0];
-	    t1 = VB->TexCoordPtr[1]->data[i][1];
-	    u1 = VB->TexCoordPtr[1]->data[i][2];
-	    break;
-	 case 2:
-	    s1 = VB->TexCoordPtr[1]->data[i][0];
-	    t1 = VB->TexCoordPtr[1]->data[i][1];
-	    u1 = 0.0;
-	    break;
-	 case 1:
-	    s1 = VB->TexCoordPtr[1]->data[i][0];
-	    t1 = 0.0;
-	    u1 = 0.0;
-	    break;
-         default:
-            /* should never get here */
-            s1 = t1 = u1 = 0.0;
-            gl_problem(ctx, "unexpected texcoord size in multitextured_rgba_points()");
-	 }
-
-         for (iy=y0;iy<=y1;iy++) {
-            for (ix=x0;ix<=x1;ix++) {
-               PB_WRITE_MULTITEX_SPEC_PIXEL( PB, ix, iy, z,
-                                             red, green, blue, alpha,
-                                             sRed, sGreen, sBlue,
-                                             s, t, u, s1, t1, u1 );
-            }
-         }
-         PB_CHECK_FLUSH(ctx, PB);
-      }
-   }
-}
-
-
-/*
- * NOTES on aa point rasterization:
- *
- * Let d = distance of fragment center from vertex.
- * if d < rmin2 then
- *    fragment has 100% coverage
- * else if d > rmax2 then
- *    fragment has 0% coverage
- * else
- *    fragement has % coverage = (d - rmin2) / (rmax2 - rmin2)
- */
-
-
-/*
- * Antialiased points with or without texture mapping.
- */
-static void
-antialiased_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   const GLfloat radius = ctx->Point.Size * 0.5F;
-   const GLfloat rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
-   const GLfloat rmax = radius + 0.7071F;
-   const GLfloat rmin2 = MAX2(0.0, rmin * rmin);
-   const GLfloat rmax2 = rmax * rmax;
-   const GLfloat cscale = 256.0F / (rmax2 - rmin2);
-   GLuint i;
-
-   if (ctx->Texture.ReallyEnabled) {
-      for (i = first; i < last; i++) {
-         if (VB->ClipMask[i] == 0) {
-            GLint x, y;
-            GLint red, green, blue, alpha;
-            GLfloat s = 0.0F, t = 0.0F, u = 0.0F;
-            GLfloat s1 = 0.0F, t1 = 0.0F, u1 = 0.0F;
-	    GLfloat *win = VB->Win.data[i];
-            GLfloat vx = win[0];
-            GLfloat vy = win[1];
-
-            GLint xmin = (GLint) (vx - radius);
-            GLint xmax = (GLint) (vx + radius);
-            GLint ymin = (GLint) (vy - radius);
-            GLint ymax = (GLint) (vy + radius);
-            GLint z = (GLint) (win[2] + ctx->PointZoffset);
 
-	    if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-            red   = VB->ColorPtr->data[i][0];
-            green = VB->ColorPtr->data[i][1];
-            blue  = VB->ColorPtr->data[i][2];
-
-	    switch (VB->TexCoordPtr[0]->size) {
-	    case 4:
-	       s = (VB->TexCoordPtr[0]->data[i][0]/
-		    VB->TexCoordPtr[0]->data[i][3]);
-	       t = (VB->TexCoordPtr[0]->data[i][1]/
-		    VB->TexCoordPtr[0]->data[i][3]);
-	       u = (VB->TexCoordPtr[0]->data[i][2]/
-		    VB->TexCoordPtr[0]->data[i][3]);
-	       break;
-	    case 3:
-	       s = VB->TexCoordPtr[0]->data[i][0];
-	       t = VB->TexCoordPtr[0]->data[i][1];
-	       u = VB->TexCoordPtr[0]->data[i][2];
-	       break;
-	    case 2:
-	       s = VB->TexCoordPtr[0]->data[i][0];
-	       t = VB->TexCoordPtr[0]->data[i][1];
-	       u = 0.0;
-	       break;
-	    case 1:
-	       s = VB->TexCoordPtr[0]->data[i][0];
-	       t = 0.0;
-	       u = 0.0;
-	       break;
-            default:
-               /* should never get here */
-               s = t = u = 0.0;
-               gl_problem(ctx, "unexpected texcoord size in antialiased_rgba_points()");
-	    }
-
-	    if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-	       /* Multitextured!  This is probably a slow enough path that
-		  there's no reason to specialize the multitexture case. */
-	       switch (VB->TexCoordPtr[1]->size) {
-	       case 4:
-		  s1 = ( VB->TexCoordPtr[1]->data[i][0] /  
-			 VB->TexCoordPtr[1]->data[i][3]);
-		  t1 = ( VB->TexCoordPtr[1]->data[i][1] / 
-			 VB->TexCoordPtr[1]->data[i][3]);
-		  u1 = ( VB->TexCoordPtr[1]->data[i][2] / 
-			 VB->TexCoordPtr[1]->data[i][3]);
-		  break;
-	       case 3:
-		  s1 = VB->TexCoordPtr[1]->data[i][0];
-		  t1 = VB->TexCoordPtr[1]->data[i][1];
-		  u1 = VB->TexCoordPtr[1]->data[i][2];
-		  break;
-	       case 2:
-		  s1 = VB->TexCoordPtr[1]->data[i][0];
-		  t1 = VB->TexCoordPtr[1]->data[i][1];
-		  u1 = 0.0;
-		  break;
-	       case 1:
-		  s1 = VB->TexCoordPtr[1]->data[i][0];
-		  t1 = 0.0;
-		  u1 = 0.0;
-		  break;
-               default:
-                  /* should never get here */
-                  s1 = t1 = u1 = 0.0;
-                  gl_problem(ctx, "unexpected texcoord size in antialiased_rgba_points()");
-	       }
-	    }
-
-            /* translate by a half pixel to simplify math below */
-            vx -= 0.5F;
-            vx -= 0.5F;
-
-            for (y = ymin; y <= ymax; y++) {
-               for (x = xmin; x <= xmax; x++) {
-                  const GLfloat dx = x - vx;
-                  const GLfloat dy = y - vy;
-                  const GLfloat dist2 = dx*dx + dy*dy;
-                  if (dist2 < rmax2) {
-                     alpha = VB->ColorPtr->data[i][3];
-                     if (dist2 >= rmin2) {
-                        GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale);
-                        /* coverage is in [0,256] */
-                        alpha = (alpha * coverage) >> 8;
-                     }
-                     if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-                        PB_WRITE_MULTITEX_PIXEL( PB, x,y,z, red, green, blue, 
-						 alpha, s, t, u, s1, t1, u1 );
-                     } else {
-                        PB_WRITE_TEX_PIXEL( PB, x,y,z, red, green, blue, 
-					    alpha, s, t, u );
-                     }
-                  }
-               }
-            }
-
-            PB_CHECK_FLUSH(ctx,PB);
-         }
-      }
-   }
-   else {
-      /* Not texture mapped */
-      for (i=first;i<last;i++) {
-         if (VB->ClipMask[i]==0) {
-            GLint xmin, ymin, xmax, ymax;
-            GLint x, y, z;
-            GLint red, green, blue, alpha;
-	    GLfloat *win = VB->Win.data[i];
-
-	    if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-            xmin = (GLint) (win[0] - 0.0 - radius);
-            xmax = (GLint) (win[0] - 0.0 + radius);
-            ymin = (GLint) (win[1] - 0.0 - radius);
-            ymax = (GLint) (win[1] - 0.0 + radius);
-            z = (GLint) (win[2] + ctx->PointZoffset);
-
-            red   = VB->ColorPtr->data[i][0];
-            green = VB->ColorPtr->data[i][1];
-            blue  = VB->ColorPtr->data[i][2];
-
-            /*
-            printf("point %g, %g\n", win[0], win[1]);
-            printf("%d..%d X %d..%d\n", xmin, xmax, ymin, ymax);
-            */
-            for (y = ymin; y <= ymax; y++) {
-               for (x = xmin; x <= xmax; x++) {
-                  const GLfloat dx = x + 0.5F - win[0];
-                  const GLfloat dy = y + 0.5F - win[1];
-                  const GLfloat dist2 = dx*dx + dy*dy;
-                  if (dist2 < rmax2) {
-                     alpha = VB->ColorPtr->data[i][3];
-                     if (dist2 >= rmin2) {
-                        GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale);
-                        /* coverage is in [0,256] */
-                        alpha = (alpha * coverage) >> 8;
-                     }
-                     PB_WRITE_RGBA_PIXEL( PB, x, y, z, red, green, blue, 
-					  alpha );
-                  }
-               }
-            }
-            PB_CHECK_FLUSH(ctx,PB);
-	 }
-      }
-   }
+   if (ctx->Driver.PointParameterfv)
+      (*ctx->Driver.PointParameterfv)(ctx, pname, params);
 }
-
-
-
-/*
- * Null rasterizer for measuring transformation speed.
- */
-static void
-null_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   (void) ctx;
-   (void) first;
-   (void) last;
-}
-
-
-
-/* Definition of the functions for GL_EXT_point_parameters */
-
-/* Calculates the distance attenuation formula of a vector of points in
- * eye space coordinates 
- */
-static void
-dist3(GLfloat *out, GLuint first, GLuint last,
-      const GLcontext *ctx, const GLvector4f *v)
-{
-   GLuint stride = v->stride;
-   const GLfloat *p = VEC_ELT(v, GLfloat, first);
-   GLuint i;
-
-   for (i = first ; i < last ; i++, STRIDE_F(p, stride) ) {
-      GLfloat dist = GL_SQRT(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]);
-      out[i] = 1.0F / (ctx->Point.Params[0] +
-                       dist * (ctx->Point.Params[1] +
-                               dist * ctx->Point.Params[2]));
-   }
-}
-
-
-static void
-dist2(GLfloat *out, GLuint first, GLuint last,
-      const GLcontext *ctx, const GLvector4f *v)
-{
-   GLuint stride = v->stride;
-   const GLfloat *p = VEC_ELT(v, GLfloat, first);
-   GLuint i;
-
-   for (i = first ; i < last ; i++, STRIDE_F(p, stride) ) {
-      GLfloat dist = GL_SQRT(p[0]*p[0]+p[1]*p[1]);
-      out[i] = 1.0F / (ctx->Point.Params[0] +
-                       dist * (ctx->Point.Params[1] +
-                               dist * ctx->Point.Params[2]));
-   }
-}
-
-
-typedef void (*dist_func)(GLfloat *out, GLuint first, GLuint last,
-			     const GLcontext *ctx, const GLvector4f *v);
-
-
-static dist_func eye_dist_tab[5] = {
-   0,
-   0,
-   dist2,
-   dist3,
-   dist3
-};
-
-
-static void
-clip_dist(GLfloat *out, GLuint first, GLuint last,
-          const GLcontext *ctx, GLvector4f *clip)
-{
-   /* this is never called */
-   gl_problem(NULL, "clip_dist() called - dead code!\n");
-
-   (void) out;
-   (void) first;
-   (void) last;
-   (void) ctx;
-   (void) clip;
-
-#if 0
-   GLuint i;
-   const GLfloat *from = (GLfloat *)clip_vec->start;
-   const GLuint stride = clip_vec->stride;
-
-   for (i = first ; i < last ; i++ )
-   {
-      GLfloat dist = win[i][2];
-      out[i] = 1/(ctx->Point.Params[0]+ 
-		  dist * (ctx->Point.Params[1] +
-			  dist * ctx->Point.Params[2]));
-   }
-#endif
-}
-
-
-
-/*
- * Distance Attenuated General CI points.
- */
-static void
-dist_atten_general_ci_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLfloat dist[VB_SIZE];
-   const GLfloat psize = ctx->Point.Size;
-   GLuint i;
-
-   if (ctx->NeedEyeCoords)
-      (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr );
-   else 
-      clip_dist( dist, first, last, ctx, VB->ClipPtr );
-
-   for (i=first;i<last;i++) {
-      if (VB->ClipMask[i]==0) {
-         GLint x0, x1, y0, y1;
-         GLint ix, iy;
-         GLint isize, radius;
-	 GLfloat *win = VB->Win.data[i];
-         GLint x = (GLint)  win[0];
-         GLint y = (GLint)  win[1];
-         GLint z = (GLint) (win[2] + ctx->PointZoffset);
-         GLfloat dsize = psize * dist[i];
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         if (dsize >= ctx->Point.Threshold) {
-            isize = (GLint) (MIN2(dsize, ctx->Point.MaxSize) + 0.5F);
-         }
-         else {
-            isize = (GLint) (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) + 0.5F);
-         }
-         radius = isize >> 1;
-
-         if (isize & 1) {
-            /* odd size */
-            x0 = x - radius;
-            x1 = x + radius;
-            y0 = y - radius;
-            y1 = y + radius;
-         }
-         else {
-            /* even size */
-            x0 = (GLint) (x + 1.5F) - radius;
-            x1 = x0 + isize - 1;
-            y0 = (GLint) (y + 1.5F) - radius;
-            y1 = y0 + isize - 1;
-         }
-
-         PB_SET_INDEX( PB, VB->IndexPtr->data[i] );
-
-         for (iy=y0;iy<=y1;iy++) {
-            for (ix=x0;ix<=x1;ix++) {
-               PB_WRITE_PIXEL( PB, ix, iy, z );
-            }
-         }
-         PB_CHECK_FLUSH(ctx,PB);
-      }
-   }
-}
-
-/*
- * Distance Attenuated General RGBA points.
- */
-static void
-dist_atten_general_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLfloat dist[VB_SIZE];
-   const GLfloat psize = ctx->Point.Size;
-   GLuint i;
-
-   if (ctx->NeedEyeCoords)
-      (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr );
-   else 
-      clip_dist( dist, first, last, ctx, VB->ClipPtr );
-
-   for (i=first;i<last;i++) {
-      if (VB->ClipMask[i]==0) {
-         GLint x0, x1, y0, y1;
-         GLint ix, iy;
-         GLint isize, radius;
-	 GLfloat *win = VB->Win.data[i];
-         GLint x = (GLint)  win[0];
-         GLint y = (GLint)  win[1];
-         GLint z = (GLint) (win[2] + ctx->PointZoffset);
-         GLfloat dsize=psize*dist[i];
-         GLubyte alpha;
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         if (dsize >= ctx->Point.Threshold) {
-            isize = (GLint) (MIN2(dsize,ctx->Point.MaxSize)+0.5F);
-            alpha = VB->ColorPtr->data[i][3];
-         }
-         else {
-            isize = (GLint) (MAX2(ctx->Point.Threshold,ctx->Point.MinSize)+0.5F);
-            dsize /= ctx->Point.Threshold;
-            alpha = (GLint) (VB->ColorPtr->data[i][3]* (dsize*dsize));
-         }
-         radius = isize >> 1;
-
-         if (isize & 1) {
-            /* odd size */
-            x0 = x - radius;
-            x1 = x + radius;
-            y0 = y - radius;
-            y1 = y + radius;
-         }
-         else {
-            /* even size */
-            x0 = (GLint) (x + 1.5F) - radius;
-            x1 = x0 + isize - 1;
-            y0 = (GLint) (y + 1.5F) - radius;
-            y1 = y0 + isize - 1;
-         }
-
-         PB_SET_COLOR( PB,
-                       VB->ColorPtr->data[i][0],
-                       VB->ColorPtr->data[i][1],
-                       VB->ColorPtr->data[i][2],
-                       alpha );
-
-         for (iy=y0;iy<=y1;iy++) {
-            for (ix=x0;ix<=x1;ix++) {
-               PB_WRITE_PIXEL( PB, ix, iy, z );
-            }
-         }
-         PB_CHECK_FLUSH(ctx,PB);
-      }
-   }
-}
-
-/*
- *  Distance Attenuated Textured RGBA points.
- */
-static void
-dist_atten_textured_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLfloat dist[VB_SIZE];
-   const GLfloat psize = ctx->Point.Size;
-   GLuint i;
-
-   if (ctx->NeedEyeCoords)
-      (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr );
-   else 
-      clip_dist( dist, first, last, ctx, VB->ClipPtr );
-
-   for (i=first;i<last;i++) {
-      if (VB->ClipMask[i]==0) {
-         GLint x0, x1, y0, y1;
-         GLint ix, iy;
-         GLint isize, radius;
-         GLint red, green, blue, alpha;
-         GLfloat s = 0.0F, t = 0.0F, u = 0.0F;
-         GLfloat s1 = 0.0F, t1 = 0.0F, u1 = 0.0F;
- 	 GLfloat *win = VB->Win.data[i];
-         GLint x = (GLint)  win[0];
-         GLint y = (GLint)  win[1];
-         GLint z = (GLint) (win[2] + ctx->PointZoffset);
-         GLfloat dsize = psize*dist[i];
-
-	 if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-         if(dsize >= ctx->Point.Threshold) {
-            isize = (GLint) (MIN2(dsize, ctx->Point.MaxSize) + 0.5F);
-            alpha = VB->ColorPtr->data[i][3];
-         }
-         else {
-            isize = (GLint) (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) + 0.5F);
-            dsize /= ctx->Point.Threshold;
-            alpha = (GLint) (VB->ColorPtr->data[i][3] * (dsize * dsize));
-         }
-
-         if (isize < 1) {
-            isize = 1;
-         }
-         radius = isize >> 1;
-
-         if (isize & 1) {
-            /* odd size */
-            x0 = x - radius;
-            x1 = x + radius;
-            y0 = y - radius;
-            y1 = y + radius;
-         }
-         else {
-            /* even size */
-            x0 = (GLint) (x + 1.5F) - radius;
-            x1 = x0 + isize - 1;
-            y0 = (GLint) (y + 1.5F) - radius;
-            y1 = y0 + isize - 1;
-         }
-
-	 red   = VB->ColorPtr->data[i][0];
-	 green = VB->ColorPtr->data[i][1];
-	 blue  = VB->ColorPtr->data[i][2];
-	 
-	 switch (VB->TexCoordPtr[0]->size) {
-	 case 4:
-	    s = (VB->TexCoordPtr[0]->data[i][0]/
-		 VB->TexCoordPtr[0]->data[i][3]);
-	    t = (VB->TexCoordPtr[0]->data[i][1]/
-		 VB->TexCoordPtr[0]->data[i][3]);
-	    u = (VB->TexCoordPtr[0]->data[i][2]/
-		 VB->TexCoordPtr[0]->data[i][3]);
-	    break;
-	 case 3:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = VB->TexCoordPtr[0]->data[i][1];
-	    u = VB->TexCoordPtr[0]->data[i][2];
-	    break;
-	 case 2:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = VB->TexCoordPtr[0]->data[i][1];
-	    u = 0.0;
-	    break;
-	 case 1:
-	    s = VB->TexCoordPtr[0]->data[i][0];
-	    t = 0.0;
-	    u = 0.0;
-	    break;
-         default:
-            /* should never get here */
-            s = t = u = 0.0;
-            gl_problem(ctx, "unexpected texcoord size in dist_atten_textured_rgba_points()");
-	 }
-
-	 if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-	    /* Multitextured!  This is probably a slow enough path that
-	       there's no reason to specialize the multitexture case. */
-	    switch (VB->TexCoordPtr[1]->size) {
-	    case 4:
-	       s1 = ( VB->TexCoordPtr[1]->data[i][0] /  
-		      VB->TexCoordPtr[1]->data[i][3] );
-	       t1 = ( VB->TexCoordPtr[1]->data[i][1] / 
-		      VB->TexCoordPtr[1]->data[i][3] );
-	       u1 = ( VB->TexCoordPtr[1]->data[i][2] / 
-		      VB->TexCoordPtr[1]->data[i][3] );
-	       break;
-	    case 3:
-	       s1 = VB->TexCoordPtr[1]->data[i][0];
-	       t1 = VB->TexCoordPtr[1]->data[i][1];
-	       u1 = VB->TexCoordPtr[1]->data[i][2];
-	       break;
-	    case 2:
-	       s1 = VB->TexCoordPtr[1]->data[i][0];
-	       t1 = VB->TexCoordPtr[1]->data[i][1];
-	       u1 = 0.0;
-	       break;
-	    case 1:
-	       s1 = VB->TexCoordPtr[1]->data[i][0];
-	       t1 = 0.0;
-	       u1 = 0.0;
-	       break;
-            default:
-               /* should never get here */
-               s1 = t1 = u1 = 0.0;
-               gl_problem(ctx, "unexpected texcoord size in dist_atten_textured_rgba_points()");
-	    }
-	 }
-
-/*    don't think this is needed
-      PB_SET_COLOR( red, green, blue, alpha );
-*/
-  
-         for (iy=y0;iy<=y1;iy++) {
-            for (ix=x0;ix<=x1;ix++) {
-               if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-                  PB_WRITE_MULTITEX_PIXEL( PB, ix, iy, z, red, green, blue, alpha, s, t, u, s1, t1, u1 );
-               } else {
-                  PB_WRITE_TEX_PIXEL( PB, ix, iy, z, red, green, blue, alpha, s, t, u );
-               }
-            }
-         }
-         PB_CHECK_FLUSH(ctx,PB);
-      }
-   }
-}
-
-/*
- * Distance Attenuated Antialiased points with or without texture mapping.
- */
-static void
-dist_atten_antialiased_rgba_points( GLcontext *ctx, GLuint first, GLuint last )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct pixel_buffer *PB = ctx->PB;
-   GLfloat dist[VB_SIZE];
-   const GLfloat psize = ctx->Point.Size;
-   GLuint i;
-
-   if (ctx->NeedEyeCoords)
-      (eye_dist_tab[VB->EyePtr->size])( dist, first, last, ctx, VB->EyePtr );
-   else 
-      clip_dist( dist, first, last, ctx, VB->ClipPtr );
-
-   if (ctx->Texture.ReallyEnabled) {
-      for (i=first;i<last;i++) {
-         if (VB->ClipMask[i]==0) {
-            GLfloat radius, rmin, rmax, rmin2, rmax2, cscale, alphaf;
-            GLint xmin, ymin, xmax, ymax;
-            GLint x, y, z;
-            GLint red, green, blue, alpha;
-            GLfloat s = 0.0F, t = 0.0F, u = 0.0F;
-            GLfloat s1 = 0.0F, t1 = 0.0F, u1 = 0.0F;
-            GLfloat dsize = psize * dist[i];
-	    GLfloat *win = VB->Win.data[i];
-	    
-	    if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-            if (dsize >= ctx->Point.Threshold) {
-               radius = MIN2(dsize, ctx->Point.MaxSize) * 0.5F;
-               alphaf = 1.0F;
-            }
-            else {
-               radius = (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) * 0.5F);
-               dsize /= ctx->Point.Threshold;
-               alphaf = (dsize*dsize);
-            }
-            rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
-            rmax = radius + 0.7071F;
-            rmin2 = MAX2(0.0, rmin * rmin);
-            rmax2 = rmax * rmax;
-            cscale = 256.0F / (rmax2 - rmin2);
-
-            xmin = (GLint) (win[0] - radius);
-            xmax = (GLint) (win[0] + radius);
-            ymin = (GLint) (win[1] - radius);
-            ymax = (GLint) (win[1] + radius);
-            z = (GLint) (win[2] + ctx->PointZoffset);
-
-	    red   = VB->ColorPtr->data[i][0];
-	    green = VB->ColorPtr->data[i][1];
-	    blue  = VB->ColorPtr->data[i][2];
-	 
-	    switch (VB->TexCoordPtr[0]->size) {
-	    case 4:
-	       s = (VB->TexCoordPtr[0]->data[i][0]/
-		    VB->TexCoordPtr[0]->data[i][3]);
-	       t = (VB->TexCoordPtr[0]->data[i][1]/
-		    VB->TexCoordPtr[0]->data[i][3]);
-	       u = (VB->TexCoordPtr[0]->data[i][2]/
-		    VB->TexCoordPtr[0]->data[i][3]);
-	       break;
-	    case 3:
-	       s = VB->TexCoordPtr[0]->data[i][0];
-	       t = VB->TexCoordPtr[0]->data[i][1];
-	       u = VB->TexCoordPtr[0]->data[i][2];
-	       break;
-	    case 2:
-	       s = VB->TexCoordPtr[0]->data[i][0];
-	       t = VB->TexCoordPtr[0]->data[i][1];
-	       u = 0.0;
-	       break;
-	    case 1:
-	       s = VB->TexCoordPtr[0]->data[i][0];
-	       t = 0.0;
-	       u = 0.0;
-	       break;
-            default:
-               /* should never get here */
-               s = t = u = 0.0;
-               gl_problem(ctx, "unexpected texcoord size in dist_atten_antialiased_rgba_points()");
-	    }
-
-	    if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-	       /* Multitextured!  This is probably a slow enough path that
-		  there's no reason to specialize the multitexture case. */
-	       switch (VB->TexCoordPtr[1]->size) {
-	       case 4:
-		  s1 = ( VB->TexCoordPtr[1]->data[i][0] /  
-			 VB->TexCoordPtr[1]->data[i][3] );
-		  t1 = ( VB->TexCoordPtr[1]->data[i][1] / 
-			 VB->TexCoordPtr[1]->data[i][3] );
-		  u1 = ( VB->TexCoordPtr[1]->data[i][2] / 
-			 VB->TexCoordPtr[1]->data[i][3] );
-		  break;
-	       case 3:
-		  s1 = VB->TexCoordPtr[1]->data[i][0];
-		  t1 = VB->TexCoordPtr[1]->data[i][1];
-		  u1 = VB->TexCoordPtr[1]->data[i][2];
-		  break;
-	       case 2:
-		  s1 = VB->TexCoordPtr[1]->data[i][0];
-		  t1 = VB->TexCoordPtr[1]->data[i][1];
-		  u1 = 0.0;
-		  break;
-	       case 1:
-		  s1 = VB->TexCoordPtr[1]->data[i][0];
-		  t1 = 0.0;
-		  u1 = 0.0;
-		  break;
-               default:
-                  /* should never get here */
-                  s = t = u = 0.0;
-                  gl_problem(ctx, "unexpected texcoord size in dist_atten_antialiased_rgba_points()");
-	       }
-	    }
-
-            for (y = ymin; y <= ymax; y++) {
-               for (x = xmin; x <= xmax; x++) {
-                  const GLfloat dx = x + 0.5F - win[0];
-                  const GLfloat dy = y + 0.5F - win[1];
-                  const GLfloat dist2 = dx*dx + dy*dy;
-                  if (dist2 < rmax2) {
-                     alpha = VB->ColorPtr->data[i][3];
-                     if (dist2 >= rmin2) {
-                        GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale);
-                        /* coverage is in [0,256] */
-                        alpha = (alpha * coverage) >> 8;
-                     }
-                     alpha = (GLint) (alpha * alphaf);
-                     if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-                        PB_WRITE_MULTITEX_PIXEL( PB, x,y,z, red, green, blue,
-                                                 alpha, s, t, u, s1, t1, u1 );
-                     } else {
-                        PB_WRITE_TEX_PIXEL( PB, x,y,z, red, green, blue, alpha,
-                                            s, t, u );
-                     }
-                  }
-               }
-            }
-            PB_CHECK_FLUSH(ctx,PB);
-         }
-      }
-   }
-   else {
-      /* Not texture mapped */
-      for (i = first; i < last; i++) {
-         if (VB->ClipMask[i] == 0) {
-            GLfloat radius, rmin, rmax, rmin2, rmax2, cscale, alphaf;
-            GLint xmin, ymin, xmax, ymax;
-            GLint x, y, z;
-            GLint red, green, blue, alpha;
-            GLfloat dsize = psize * dist[i];
-	    GLfloat *win = VB->Win.data[i];
-
-	    if (IS_INF_OR_NAN(win[0] + win[1]))
-		 continue;
-
-            if (dsize >= ctx->Point.Threshold) {
-               radius = MIN2(dsize, ctx->Point.MaxSize) * 0.5F;
-               alphaf = 1.0F;
-            }
-            else {
-               radius = (MAX2(ctx->Point.Threshold, ctx->Point.MinSize) * 0.5F);
-               dsize /= ctx->Point.Threshold;
-               alphaf = dsize * dsize;
-            }
-            rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
-            rmax = radius + 0.7071F;
-            rmin2 = MAX2(0.0, rmin * rmin);
-            rmax2 = rmax * rmax;
-            cscale = 256.0F / (rmax2 - rmin2);
-
-            xmin = (GLint) (win[0] - radius);
-            xmax = (GLint) (win[0] + radius);
-            ymin = (GLint) (win[1] - radius);
-            ymax = (GLint) (win[1] + radius);
-            z = (GLint) (win[2] + ctx->PointZoffset);
-
-            red   = VB->ColorPtr->data[i][0];
-            green = VB->ColorPtr->data[i][1];
-            blue  = VB->ColorPtr->data[i][2];
-
-            for (y = ymin; y <= ymax; y++) {
-               for (x = xmin; x <= xmax; x++) {
-                  const GLfloat dx = x + 0.5F - win[0];
-                  const GLfloat dy = y + 0.5F - win[1];
-                  const GLfloat dist2 = dx * dx + dy * dy;
-                  if (dist2 < rmax2) {
-		     alpha = VB->ColorPtr->data[i][3];
-                     if (dist2 >= rmin2) {
-                        GLint coverage = (GLint) (256.0F - (dist2 - rmin2) * cscale);
-                        /* coverage is in [0,256] */
-                        alpha = (alpha * coverage) >> 8;
-                     }
-                     alpha = (GLint) (alpha * alphaf);
-                     PB_WRITE_RGBA_PIXEL(PB, x, y, z, red, green, blue, alpha);
-                  }
-               }
-            }
-            PB_CHECK_FLUSH(ctx,PB);
-	 }
-      }
-   }
-}
-
-
-#ifdef DEBUG
-void
-_mesa_print_points_function(GLcontext *ctx)
-{
-   printf("Point Func == ");
-   if (ctx->Driver.PointsFunc == size1_ci_points)
-      printf("size1_ci_points\n");
-   else if (ctx->Driver.PointsFunc == size1_rgba_points)
-      printf("size1_rgba_points\n");
-   else if (ctx->Driver.PointsFunc == general_ci_points)
-      printf("general_ci_points\n");
-   else if (ctx->Driver.PointsFunc == general_rgba_points)
-      printf("general_rgba_points\n");
-   else if (ctx->Driver.PointsFunc == textured_rgba_points)
-      printf("textured_rgba_points\n");
-   else if (ctx->Driver.PointsFunc == multitextured_rgba_points)
-      printf("multitextured_rgba_points\n");
-   else if (ctx->Driver.PointsFunc == antialiased_rgba_points)
-      printf("antialiased_rgba_points\n");
-   else if (ctx->Driver.PointsFunc == null_points)
-      printf("null_points\n");
-   else if (ctx->Driver.PointsFunc == dist_atten_general_ci_points)
-      printf("dist_atten_general_ci_points\n");
-   else if (ctx->Driver.PointsFunc == dist_atten_general_rgba_points)
-      printf("dist_atten_general_rgba_points\n");
-   else if (ctx->Driver.PointsFunc == dist_atten_textured_rgba_points)
-      printf("dist_atten_textured_rgba_points\n");
-   else if (ctx->Driver.PointsFunc == dist_atten_antialiased_rgba_points)
-      printf("dist_atten_antialiased_rgba_points\n");
-   else if (!ctx->Driver.PointsFunc)
-      printf("NULL\n");
-   else
-      printf("Driver func %p\n", ctx->Driver.PointsFunc);
-}
-#endif
-
-
-/*
- * Examine the current context to determine which point drawing function
- * should be used.
- */
-void gl_set_point_function( GLcontext *ctx )
-{
-   GLboolean rgbmode = ctx->Visual->RGBAflag;
-
-   if (ctx->RenderMode==GL_RENDER) {
-      if (ctx->NoRaster) {
-         ctx->Driver.PointsFunc = null_points;
-         return;
-      }
-      if (ctx->Driver.PointsFunc) {
-         /* Device driver will draw points. */
-	 ctx->IndirectTriangles &= ~DD_POINT_SW_RASTERIZE;
-	 return;
-      }
-
-      if (!ctx->Point.Attenuated) {
-         if (ctx->Point.SmoothFlag && rgbmode) {
-            ctx->Driver.PointsFunc = antialiased_rgba_points;
-         }
-         else if (ctx->Texture.ReallyEnabled) {
-            if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D ||
-                ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) {
-	       ctx->Driver.PointsFunc = multitextured_rgba_points;
-            }
-            else {
-               ctx->Driver.PointsFunc = textured_rgba_points;
-            }
-         }
-         else if (ctx->Point.Size==1.0) {
-            /* size=1, any raster ops */
-            if (rgbmode)
-               ctx->Driver.PointsFunc = size1_rgba_points;
-            else
-               ctx->Driver.PointsFunc = size1_ci_points;
-         }
-         else {
-	    /* every other kind of point rendering */
-            if (rgbmode)
-               ctx->Driver.PointsFunc = general_rgba_points;
-            else
-               ctx->Driver.PointsFunc = general_ci_points;
-         }
-      } 
-      else if(ctx->Point.SmoothFlag && rgbmode) {
-         ctx->Driver.PointsFunc = dist_atten_antialiased_rgba_points;
-      }
-      else if (ctx->Texture.ReallyEnabled) {
-         ctx->Driver.PointsFunc = dist_atten_textured_rgba_points;
-      } 
-      else {
-         /* every other kind of point rendering */
-         if (rgbmode)
-            ctx->Driver.PointsFunc = dist_atten_general_rgba_points;
-         else
-            ctx->Driver.PointsFunc = dist_atten_general_ci_points;
-     }
-   }
-   else if (ctx->RenderMode==GL_FEEDBACK) {
-      ctx->Driver.PointsFunc = gl_feedback_points;
-   }
-   else {
-      /* GL_SELECT mode */
-      ctx->Driver.PointsFunc = gl_select_points;
-   }
-
-   /*_mesa_print_points_function(ctx);*/
-}
-
Index: xc/extras/Mesa/src/points.h
diff -u xc/extras/Mesa/src/points.h:1.3 xc/extras/Mesa/src/points.h:1.4
--- xc/extras/Mesa/src/points.h:1.3	Tue Feb 15 02:12:30 2000
+++ xc/extras/Mesa/src/points.h	Fri Feb 22 14:25:38 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -31,7 +31,7 @@
 #define POINTS_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
@@ -45,8 +45,6 @@
 extern void
 _mesa_PointParameterfvEXT( GLenum pname, const GLfloat *params );
 
-
-extern void gl_set_point_function( GLcontext *ctx );
 
 
 #endif
Index: xc/extras/Mesa/src/polygon.c
diff -u xc/extras/Mesa/src/polygon.c:1.4 xc/extras/Mesa/src/polygon.c:1.5
--- xc/extras/Mesa/src/polygon.c:1.4	Fri Jun 16 20:02:15 2000
+++ xc/extras/Mesa/src/polygon.c	Fri Feb 22 14:25:38 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -34,7 +34,7 @@
 #include "macros.h"
 #include "mem.h"
 #include "polygon.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -43,18 +43,21 @@
 _mesa_CullFace( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCullFace");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glCullFace %s\n", gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glCullFace %s\n", _mesa_lookup_enum_by_nr(mode));
 
    if (mode!=GL_FRONT && mode!=GL_BACK && mode!=GL_FRONT_AND_BACK) {
-      gl_error( ctx, GL_INVALID_ENUM, "glCullFace" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glCullFace" );
       return;
    }
 
+   if (ctx->Polygon.CullFaceMode == mode)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_POLYGON);
    ctx->Polygon.CullFaceMode = mode;
-   ctx->NewState |= NEW_POLYGON;
 
    if (ctx->Driver.CullFace)
       ctx->Driver.CullFace( ctx, mode );
@@ -66,19 +69,23 @@
 _mesa_FrontFace( GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glFrontFace");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glFrontFace %s\n", gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glFrontFace %s\n", _mesa_lookup_enum_by_nr(mode));
 
    if (mode!=GL_CW && mode!=GL_CCW) {
-      gl_error( ctx, GL_INVALID_ENUM, "glFrontFace" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glFrontFace" );
       return;
    }
 
+   if (ctx->Polygon.FrontFace == mode)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_POLYGON);
    ctx->Polygon.FrontFace = mode;
-   ctx->Polygon.FrontBit = (GLboolean) (mode == GL_CW);
-   ctx->NewState |= NEW_POLYGON;
+
+   ctx->Polygon._FrontBit = (GLboolean) (mode == GL_CW);
 
    if (ctx->Driver.FrontFace)
       ctx->Driver.FrontFace( ctx, mode );
@@ -90,39 +97,47 @@
 _mesa_PolygonMode( GLenum face, GLenum mode )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPolygonMode");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glPolygonMode %s %s\n", 
-	      gl_lookup_enum_by_nr(face),
-	      gl_lookup_enum_by_nr(mode));
+      fprintf(stderr, "glPolygonMode %s %s\n",
+	      _mesa_lookup_enum_by_nr(face),
+	      _mesa_lookup_enum_by_nr(mode));
 
-   if (face!=GL_FRONT && face!=GL_BACK && face!=GL_FRONT_AND_BACK) {
-      gl_error( ctx, GL_INVALID_ENUM, "glPolygonMode(face)" );
+   if (mode!=GL_POINT && mode!=GL_LINE && mode!=GL_FILL) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(mode)" );
       return;
    }
-   else if (mode!=GL_POINT && mode!=GL_LINE && mode!=GL_FILL) {
-      gl_error( ctx, GL_INVALID_ENUM, "glPolygonMode(mode)" );
-      return;
-   }
 
-   if (face==GL_FRONT || face==GL_FRONT_AND_BACK) {
+   switch (face) {
+   case GL_FRONT:
+      if (ctx->Polygon.FrontMode == mode)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
       ctx->Polygon.FrontMode = mode;
-   }
-   if (face==GL_BACK || face==GL_FRONT_AND_BACK) {
+      break;
+   case GL_FRONT_AND_BACK:
+      if (ctx->Polygon.FrontMode == mode &&
+	  ctx->Polygon.BackMode == mode)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.FrontMode = mode;
       ctx->Polygon.BackMode = mode;
-   }
-
-   /* Compute a handy "shortcut" value: */
-   ctx->TriangleCaps &= ~DD_TRI_UNFILLED;
-   ctx->Polygon.Unfilled = GL_FALSE;
-
-   if (ctx->Polygon.FrontMode!=GL_FILL || ctx->Polygon.BackMode!=GL_FILL) {
-      ctx->Polygon.Unfilled = GL_TRUE;
-      ctx->TriangleCaps |= DD_TRI_UNFILLED;
+      break;
+   case GL_BACK:
+      if (ctx->Polygon.BackMode == mode)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_POLYGON);
+      ctx->Polygon.BackMode = mode;
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glPolygonMode(face)" );
+      return;
    }
 
-   ctx->NewState |= (NEW_POLYGON | NEW_RASTER_OPS);
+   ctx->_TriangleCaps &= ~DD_TRI_UNFILLED;
+   if (ctx->Polygon.FrontMode!=GL_FILL || ctx->Polygon.BackMode!=GL_FILL)
+      ctx->_TriangleCaps |= DD_TRI_UNFILLED;
 
    if (ctx->Driver.PolygonMode) {
       (*ctx->Driver.PolygonMode)( ctx, face, mode );
@@ -135,17 +150,14 @@
 _mesa_PolygonStipple( const GLubyte *pattern )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPolygonStipple");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
       fprintf(stderr, "glPolygonStipple\n");
 
+   FLUSH_VERTICES(ctx, _NEW_POLYGONSTIPPLE);
    _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack);
 
-   if (ctx->Polygon.StippleFlag) {
-      ctx->NewState |= NEW_RASTER_OPS;
-   }
-   
    if (ctx->Driver.PolygonStipple)
       ctx->Driver.PolygonStipple( ctx, (const GLubyte *) ctx->PolygonStipple );
 }
@@ -156,7 +168,7 @@
 _mesa_GetPolygonStipple( GLubyte *dest )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPolygonOffset");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
       fprintf(stderr, "glGetPolygonStipple\n");
@@ -170,13 +182,22 @@
 _mesa_PolygonOffset( GLfloat factor, GLfloat units )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPolygonOffset");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&VERBOSE_API)
       fprintf(stderr, "glPolygonOffset %f %f\n", factor, units);
 
+   if (ctx->Polygon.OffsetFactor == factor &&
+       ctx->Polygon.OffsetUnits == units)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_POLYGON);
    ctx->Polygon.OffsetFactor = factor;
    ctx->Polygon.OffsetUnits = units;
+   ctx->Polygon.OffsetMRD = units * ctx->MRD;
+
+   if (ctx->Driver.PolygonOffset)
+      ctx->Driver.PolygonOffset( ctx, factor, units );
 }
 
 
@@ -185,6 +206,5 @@
 _mesa_PolygonOffsetEXT( GLfloat factor, GLfloat bias )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPolygonOffsetEXT");
-   _mesa_PolygonOffset(factor, bias * ctx->Visual->DepthMaxF );
+   _mesa_PolygonOffset(factor, bias * ctx->DepthMaxF );
 }
Index: xc/extras/Mesa/src/polygon.h
diff -u xc/extras/Mesa/src/polygon.h:1.3 xc/extras/Mesa/src/polygon.h:1.4
--- xc/extras/Mesa/src/polygon.h:1.3	Tue Feb 15 02:12:31 2000
+++ xc/extras/Mesa/src/polygon.h	Fri Feb 22 14:25:38 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define POLYGON_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
@@ -54,4 +54,3 @@
 
 
 #endif
-
Index: xc/extras/Mesa/src/quads.c
diff -u xc/extras/Mesa/src/quads.c:1.3 xc/extras/Mesa/src/quads.c:removed
--- xc/extras/Mesa/src/quads.c:1.3	Tue Feb 15 02:12:31 2000
+++ xc/extras/Mesa/src/quads.c	Thu Feb 27 12:15:41 2003
@@ -1,94 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Quadrilateral rendering functions.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "quads.h"
-#include "types.h"
-#endif
-
-
-
-/*
- * At this time there is no quadrilateral optimization.  Just call the
- * triangle function twice.
- * v0, v1, v2, v3 in CCW order = front facing.
- */
-static void basic_quad( GLcontext *ctx,
-                        GLuint v0, GLuint v1, GLuint v2, GLuint v3, GLuint pv )
-{
-/*     (*ctx->Driver.TriangleFunc)( ctx, v0, v1, v3, pv ); */
-/*     (*ctx->Driver.TriangleFunc)( ctx, v1, v2, v3, pv ); */
-   (*ctx->Driver.TriangleFunc)( ctx, v0, v1, v2, pv );
-   (*ctx->Driver.TriangleFunc)( ctx, v0, v2, v3, pv );
-}
-
-
-
-/*
- * Draw nothing (NULL raster mode)
- */
-static void null_quad( GLcontext *ctx,
-                       GLuint v0, GLuint v1, GLuint v2, GLuint v3, GLuint pv )
-{
-   (void) ctx;
-   (void) v0;
-   (void) v1;
-   (void) v2;
-   (void) v3;
-   (void) pv;
-}
-
-
-
-void gl_set_quad_function( GLcontext *ctx )
-{
-   if (ctx->RenderMode==GL_RENDER) {
-      if (ctx->NoRaster) {
-         ctx->Driver.QuadFunc = null_quad;
-      }
-      else if (ctx->Driver.QuadFunc) {
-         /* Device driver will draw quads. */
-	 return;
-      }
-      else 
-         ctx->Driver.QuadFunc = basic_quad;
-      
-   }
-   else {
-      /* if in feedback or selection mode we can fall back to triangle code */
-      ctx->Driver.QuadFunc = basic_quad;
-   }      
-}
-
-
Index: xc/extras/Mesa/src/quads.h
diff -u xc/extras/Mesa/src/quads.h:1.3 xc/extras/Mesa/src/quads.h:removed
--- xc/extras/Mesa/src/quads.h:1.3	Tue Feb 15 02:12:31 2000
+++ xc/extras/Mesa/src/quads.h	Thu Feb 27 12:15:41 2003
@@ -1,40 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef QUADS_H
-#define QUADS_H
-
-
-#include "types.h"
-
-
-extern void gl_set_quad_function( GLcontext *ctx );
-
-
-#endif
Index: xc/extras/Mesa/src/rastpos.c
diff -u xc/extras/Mesa/src/rastpos.c:1.4 xc/extras/Mesa/src/rastpos.c:1.5
--- xc/extras/Mesa/src/rastpos.c:1.4	Fri Jun 16 20:02:15 2000
+++ xc/extras/Mesa/src/rastpos.c	Fri Feb 22 14:25:38 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -29,69 +29,290 @@
 #else
 #include "glheader.h"
 #include "clip.h"
+#include "colormac.h"
 #include "context.h"
 #include "feedback.h"
 #include "light.h"
 #include "macros.h"
-#include "matrix.h"
 #include "mmath.h"
 #include "rastpos.h"
-#include "shade.h"
 #include "state.h"
-#include "types.h"
-#include "xform.h"
+#include "simple_list.h"
+#include "mtypes.h"
+
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
 #endif
 
 
 /*
+ * Clip a point against the view volume.
+ * Input:  v - vertex-vector describing the point to clip
+ * Return:  0 = outside view volume
+ *          1 = inside view volume
+ */
+static GLuint
+viewclip_point( const GLfloat v[] )
+{
+   if (   v[0] > v[3] || v[0] < -v[3]
+       || v[1] > v[3] || v[1] < -v[3]
+       || v[2] > v[3] || v[2] < -v[3] ) {
+      return 0;
+   }
+   else {
+      return 1;
+   }
+}
+
+
+/* As above, but only clip test against far/near Z planes */
+static GLuint
+viewclip_point_z( const GLfloat v[] )
+{
+   if (v[2] > v[3] || v[2] < -v[3] ) {
+      return 0;
+   }
+   else {
+      return 1;
+   }
+}
+
+
+
+/*
+ * Clip a point against the user clipping planes.
+ * Input:  v - vertex-vector describing the point to clip.
+ * Return:  0 = point was clipped
+ *          1 = point not clipped
+ */
+static GLuint
+userclip_point( GLcontext* ctx, const GLfloat v[] )
+{
+   GLuint p;
+
+   for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
+      if (ctx->Transform.ClipEnabled[p]) {
+	 GLfloat dot = v[0] * ctx->Transform._ClipUserPlane[p][0]
+		     + v[1] * ctx->Transform._ClipUserPlane[p][1]
+		     + v[2] * ctx->Transform._ClipUserPlane[p][2]
+		     + v[3] * ctx->Transform._ClipUserPlane[p][3];
+         if (dot < 0.0F) {
+            return 0;
+         }
+      }
+   }
+
+   return 1;
+}
+
+
+/* This has been split off to allow the normal shade routines to
+ * get a little closer to the vertex buffer, and to use the
+ * GLvector objects directly.
+ * Input: ctx - the context
+ *        vertex - vertex location
+ *        normal - normal vector
+ * Output: Rcolor - returned color
+ *         Rspec  - returned specular color (if separate specular enabled)
+ *         Rindex - returned color index
+ */
+static void
+shade_rastpos(GLcontext *ctx,
+              const GLfloat vertex[4],
+              const GLfloat normal[3],
+              GLfloat Rcolor[4],
+              GLfloat Rspec[4],
+              GLuint *Rindex)
+{
+   GLfloat (*base)[3] = ctx->Light._BaseColor;
+   struct gl_light *light;
+   GLfloat diffuseColor[4], specularColor[4];
+   GLfloat diffuse = 0, specular = 0;
+
+   if (!ctx->_ShineTable[0] || !ctx->_ShineTable[1])
+      _mesa_validate_all_lighting_tables( ctx );
+
+   COPY_3V(diffuseColor, base[0]);
+   diffuseColor[3] = CLAMP( ctx->Light.Material[0].Diffuse[3], 0.0F, 1.0F );
+   ASSIGN_4V(specularColor, 0.0, 0.0, 0.0, 0.0);
+
+   foreach (light, &ctx->Light.EnabledList) {
+      GLfloat n_dot_h;
+      GLfloat attenuation = 1.0;
+      GLfloat VP[3];
+      GLfloat n_dot_VP;
+      GLfloat *h;
+      GLfloat diffuseContrib[3], specularContrib[3];
+      GLboolean normalized;
+
+      if (!(light->_Flags & LIGHT_POSITIONAL)) {
+	 COPY_3V(VP, light->_VP_inf_norm);
+	 attenuation = light->_VP_inf_spot_attenuation;
+      }
+      else {
+	 GLfloat d;
+
+	 SUB_3V(VP, light->_Position, vertex);
+	 d = (GLfloat) LEN_3FV( VP );
+
+	 if ( d > 1e-6) {
+	    GLfloat invd = 1.0F / d;
+	    SELF_SCALE_SCALAR_3V(VP, invd);
+	 }
+	 attenuation = 1.0F / (light->ConstantAttenuation + d *
+			       (light->LinearAttenuation + d *
+				light->QuadraticAttenuation));
+
+	 if (light->_Flags & LIGHT_SPOT) {
+	    GLfloat PV_dot_dir = - DOT3(VP, light->_NormDirection);
+
+	    if (PV_dot_dir<light->_CosCutoff) {
+	       continue;
+	    }
+	    else {
+	       double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
+	       int k = (int) x;
+	       GLfloat spot = (GLfloat) (light->_SpotExpTable[k][0]
+			       + (x-k)*light->_SpotExpTable[k][1]);
+	       attenuation *= spot;
+	    }
+	 }
+      }
+
+      if (attenuation < 1e-3)
+	 continue;
+
+      n_dot_VP = DOT3( normal, VP );
+
+      if (n_dot_VP < 0.0F) {
+	 ACC_SCALE_SCALAR_3V(diffuseColor, attenuation, light->_MatAmbient[0]);
+	 continue;
+      }
+
+      COPY_3V(diffuseContrib, light->_MatAmbient[0]);
+      ACC_SCALE_SCALAR_3V(diffuseContrib, n_dot_VP, light->_MatDiffuse[0]);
+      diffuse += n_dot_VP * light->_dli * attenuation;
+      ASSIGN_3V(specularContrib, 0.0, 0.0, 0.0);
+
+      {
+	 if (ctx->Light.Model.LocalViewer) {
+	    GLfloat v[3];
+	    COPY_3V(v, vertex);
+	    NORMALIZE_3FV(v);
+	    SUB_3V(VP, VP, v);
+	    h = VP;
+	    normalized = 0;
+	 }
+	 else if (light->_Flags & LIGHT_POSITIONAL) {
+	    h = VP;
+	    ACC_3V(h, ctx->_EyeZDir);
+	    normalized = 0;
+	 }
+         else {
+	    h = light->_h_inf_norm;
+	    normalized = 1;
+	 }
+
+	 n_dot_h = DOT3(normal, h);
+
+	 if (n_dot_h > 0.0F) {
+	    const struct gl_material *mat = &ctx->Light.Material[0];
+	    GLfloat spec_coef;
+	    GLfloat shininess = mat->Shininess;
+
+	    if (!normalized) {
+	       n_dot_h *= n_dot_h;
+	       n_dot_h /= LEN_SQUARED_3FV( h );
+	       shininess *= .5;
+	    }
+
+	    GET_SHINE_TAB_ENTRY( ctx->_ShineTable[0], n_dot_h, spec_coef );
+
+	    if (spec_coef > 1.0e-10) {
+               if (ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) {
+                  ACC_SCALE_SCALAR_3V( specularContrib, spec_coef,
+                                       light->_MatSpecular[0]);
+               }
+               else {
+                  ACC_SCALE_SCALAR_3V( diffuseContrib, spec_coef,
+                                       light->_MatSpecular[0]);
+               }
+	       specular += spec_coef * light->_sli * attenuation;
+	    }
+	 }
+      }
+
+      ACC_SCALE_SCALAR_3V( diffuseColor, attenuation, diffuseContrib );
+      ACC_SCALE_SCALAR_3V( specularColor, attenuation, specularContrib );
+   }
+
+   if (ctx->Visual.rgbMode) {
+      Rcolor[0] = CLAMP(diffuseColor[0], 0.0F, 1.0F);
+      Rcolor[1] = CLAMP(diffuseColor[1], 0.0F, 1.0F);
+      Rcolor[2] = CLAMP(diffuseColor[2], 0.0F, 1.0F);
+      Rcolor[3] = CLAMP(diffuseColor[3], 0.0F, 1.0F);
+      Rspec[0] = CLAMP(specularColor[0], 0.0F, 1.0F);
+      Rspec[1] = CLAMP(specularColor[1], 0.0F, 1.0F);
+      Rspec[2] = CLAMP(specularColor[2], 0.0F, 1.0F);
+      Rspec[3] = CLAMP(specularColor[3], 0.0F, 1.0F);
+   }
+   else {
+      struct gl_material *mat = &ctx->Light.Material[0];
+      GLfloat d_a = mat->DiffuseIndex - mat->AmbientIndex;
+      GLfloat s_a = mat->SpecularIndex - mat->AmbientIndex;
+      GLfloat ind = mat->AmbientIndex
+                  + diffuse * (1.0F-specular) * d_a
+                  + specular * s_a;
+      if (ind > mat->SpecularIndex) {
+	 ind = mat->SpecularIndex;
+      }
+      *Rindex = (GLuint) (GLint) ind;
+   }
+
+}
+
+/*
  * Caller:  context->API.RasterPos4f
  */
-static void raster_pos4f( GLcontext *ctx,
-                          GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+static void
+raster_pos4f(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
    GLfloat v[4], eye[4], clip[4], ndc[3], d;
-
-   /* KW: Added this test, which is in the spec.  We can't do this
-    *     outside begin/end any more because the ctx->Current values
-    *     aren't uptodate during that period. 
-    */
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "glRasterPos" );
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
 
    if (ctx->NewState)
-      gl_update_state( ctx );
+      _mesa_update_state( ctx );
 
    ASSIGN_4V( v, x, y, z, w );
    TRANSFORM_POINT( eye, ctx->ModelView.m, v );
 
    /* raster color */
-   if (ctx->Light.Enabled) 
-   {
-      /*GLfloat *vert;*/
+   if (ctx->Light.Enabled) {
       GLfloat *norm, eyenorm[3];
       GLfloat *objnorm = ctx->Current.Normal;
 
-	  /* Not needed???
-      vert = (ctx->NeedEyeCoords ? eye : v);
-	  */
-
-      if (ctx->NeedEyeNormals) {
+      if (ctx->_NeedEyeCoords) {
 	 GLfloat *inv = ctx->ModelView.inv;
 	 TRANSFORM_NORMAL( eyenorm, objnorm, inv );
 	 norm = eyenorm;
-      } else {
+      }
+      else {
 	 norm = objnorm;
       }
 
-      gl_shade_rastpos( ctx, v, norm, 
-			ctx->Current.RasterColor,
-			&ctx->Current.RasterIndex );
+      shade_rastpos( ctx, v, norm,
+                     ctx->Current.RasterColor,
+                     ctx->Current.RasterSecondaryColor,
+                     &ctx->Current.RasterIndex );
 
    }
    else {
       /* use current color or index */
-      if (ctx->Visual->RGBAflag) {
-	 UBYTE_RGBA_TO_FLOAT_RGBA(ctx->Current.RasterColor, 
-				  ctx->Current.ByteColor);
+      if (ctx->Visual.rgbMode) {
+         COPY_4FV(ctx->Current.RasterColor, ctx->Current.Color);
+         COPY_4FV(ctx->Current.RasterSecondaryColor,
+                  ctx->Current.SecondaryColor);
       }
       else {
 	 ctx->Current.RasterIndex = ctx->Current.Index;
@@ -106,15 +327,20 @@
    TRANSFORM_POINT( clip, ctx->ProjectionMatrix.m, eye );
 
    /* clip to view volume */
-   if (gl_viewclip_point( clip )==0) {
+   if (ctx->Transform.RasterPositionUnclipped) {
+      /* GL_IBM_rasterpos_clip: only clip against Z */
+      if (viewclip_point_z(clip) == 0)
+         ctx->Current.RasterPosValid = GL_FALSE;
+   }
+   else if (viewclip_point(clip) == 0) {
+      /* Normal OpenGL behaviour */
       ctx->Current.RasterPosValid = GL_FALSE;
       return;
    }
 
    /* clip to user clipping planes */
-   if ( ctx->Transform.AnyClip &&
-	gl_userclip_point(ctx, clip) == 0) 
-   {
+   if (ctx->Transform._AnyClip &&
+       userclip_point(ctx, clip) == 0) {
       ctx->Current.RasterPosValid = GL_FALSE;
       return;
    }
@@ -126,27 +352,27 @@
    ndc[1] = clip[1] * d;
    ndc[2] = clip[2] * d;
 
-   ctx->Current.RasterPos[0] = (ndc[0] * ctx->Viewport.WindowMap.m[MAT_SX] + 
-				ctx->Viewport.WindowMap.m[MAT_TX]);
-   ctx->Current.RasterPos[1] = (ndc[1] * ctx->Viewport.WindowMap.m[MAT_SY] + 
-				ctx->Viewport.WindowMap.m[MAT_TY]);
-   ctx->Current.RasterPos[2] = (ndc[2] * ctx->Viewport.WindowMap.m[MAT_SZ] + 
-				ctx->Viewport.WindowMap.m[MAT_TZ]) / ctx->Visual->DepthMaxF;
+   ctx->Current.RasterPos[0] = (ndc[0] * ctx->Viewport._WindowMap.m[MAT_SX] +
+				ctx->Viewport._WindowMap.m[MAT_TX]);
+   ctx->Current.RasterPos[1] = (ndc[1] * ctx->Viewport._WindowMap.m[MAT_SY] +
+				ctx->Viewport._WindowMap.m[MAT_TY]);
+   ctx->Current.RasterPos[2] = (ndc[2] * ctx->Viewport._WindowMap.m[MAT_SZ] +
+				ctx->Viewport._WindowMap.m[MAT_TZ]) / ctx->DepthMaxF;
    ctx->Current.RasterPos[3] = clip[3];
    ctx->Current.RasterPosValid = GL_TRUE;
 
-   /* FOG??? */
+   ctx->Current.RasterFogCoord = ctx->Current.FogCoord;
 
    {
       GLuint texSet;
-      for (texSet=0; texSet<MAX_TEXTURE_UNITS; texSet++) {
+      for (texSet = 0; texSet < ctx->Const.MaxTextureUnits; texSet++) {
          COPY_4FV( ctx->Current.RasterMultiTexCoord[texSet],
                   ctx->Current.Texcoord[texSet] );
       }
    }
 
    if (ctx->RenderMode==GL_SELECT) {
-      gl_update_hitflag( ctx, ctx->Current.RasterPos[2] );
+      _mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
    }
 
 }
@@ -156,7 +382,7 @@
 void
 _mesa_RasterPos2d(GLdouble x, GLdouble y)
 {
-   _mesa_RasterPos4f(x, y, 0.0F, 1.0F);
+   _mesa_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
 }
 
 void
@@ -168,7 +394,7 @@
 void
 _mesa_RasterPos2i(GLint x, GLint y)
 {
-   _mesa_RasterPos4f(x, y, 0.0F, 1.0F);
+   _mesa_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
 }
 
 void
@@ -180,7 +406,7 @@
 void
 _mesa_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-   _mesa_RasterPos4f(x, y, z, 1.0F);
+   _mesa_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
 }
 
 void
@@ -192,7 +418,7 @@
 void
 _mesa_RasterPos3i(GLint x, GLint y, GLint z)
 {
-   _mesa_RasterPos4f(x, y, z, 1.0F);
+   _mesa_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
 }
 
 void
@@ -204,7 +430,7 @@
 void
 _mesa_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-   _mesa_RasterPos4f(x, y, z, w);
+   _mesa_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 }
 
 void
@@ -217,7 +443,7 @@
 void
 _mesa_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-   _mesa_RasterPos4f(x, y, z, w);
+   _mesa_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
 }
 
 void
@@ -229,7 +455,7 @@
 void
 _mesa_RasterPos2dv(const GLdouble *v)
 {
-   _mesa_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
+   _mesa_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
 }
 
 void
@@ -241,7 +467,7 @@
 void
 _mesa_RasterPos2iv(const GLint *v)
 {
-   _mesa_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
+   _mesa_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
 }
 
 void
@@ -253,7 +479,7 @@
 void
 _mesa_RasterPos3dv(const GLdouble *v)
 {
-   _mesa_RasterPos4f(v[0], v[1], v[2], 1.0F);
+   _mesa_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
 }
 
 void
@@ -265,7 +491,7 @@
 void
 _mesa_RasterPos3iv(const GLint *v)
 {
-   _mesa_RasterPos4f(v[0], v[1], v[2], 1.0F);
+   _mesa_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
 }
 
 void
@@ -277,7 +503,8 @@
 void
 _mesa_RasterPos4dv(const GLdouble *v)
 {
-   _mesa_RasterPos4f(v[0], v[1], v[2], v[3]);
+   _mesa_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 
+		     (GLfloat) v[2], (GLfloat) v[3]);
 }
 
 void
@@ -289,7 +516,8 @@
 void
 _mesa_RasterPos4iv(const GLint *v)
 {
-   _mesa_RasterPos4f(v[0], v[1], v[2], v[3]);
+   _mesa_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 
+		     (GLfloat) v[2], (GLfloat) v[3]);
 }
 
 void
@@ -297,3 +525,241 @@
 {
    _mesa_RasterPos4f(v[0], v[1], v[2], v[3]);
 }
+
+
+
+/**********************************************************************/
+/***                     GL_MESA_window_pos                         ***/
+/**********************************************************************/
+
+
+/*
+ * This is a MESA extension function.  Pretty much just like glRasterPos
+ * except we don't apply the modelview or projection matrices; specify a
+ * window coordinate directly.
+ * Caller:  context->API.WindowPos4fMESA pointer.
+ */
+void
+_mesa_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT(ctx, 0);
+
+   /* set raster position */
+   ctx->Current.RasterPos[0] = x;
+   ctx->Current.RasterPos[1] = y;
+   ctx->Current.RasterPos[2] = CLAMP( z, 0.0F, 1.0F );
+   ctx->Current.RasterPos[3] = w;
+
+   ctx->Current.RasterPosValid = GL_TRUE;
+   ctx->Current.RasterDistance = 0.0F;
+   ctx->Current.RasterFogCoord = 0.0F;
+
+   /* raster color = current color or index */
+   if (ctx->Visual.rgbMode) {
+      ctx->Current.RasterColor[0] = (ctx->Current.Color[0]);
+      ctx->Current.RasterColor[1] = (ctx->Current.Color[1]);
+      ctx->Current.RasterColor[2] = (ctx->Current.Color[2]);
+      ctx->Current.RasterColor[3] = (ctx->Current.Color[3]);
+   }
+   else {
+      ctx->Current.RasterIndex = ctx->Current.Index;
+   }
+
+   /* raster texcoord = current texcoord */
+   {
+      GLuint texSet;
+      for (texSet = 0; texSet < ctx->Const.MaxTextureUnits; texSet++) {
+         COPY_4FV( ctx->Current.RasterMultiTexCoord[texSet],
+                  ctx->Current.Texcoord[texSet] );
+      }
+   }
+
+   if (ctx->RenderMode==GL_SELECT) {
+      _mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
+   }
+}
+
+
+
+
+void
+_mesa_WindowPos2dMESA(GLdouble x, GLdouble y)
+{
+   _mesa_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos2fMESA(GLfloat x, GLfloat y)
+{
+   _mesa_WindowPos4fMESA(x, y, 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos2iMESA(GLint x, GLint y)
+{
+   _mesa_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos2sMESA(GLshort x, GLshort y)
+{
+   _mesa_WindowPos4fMESA(x, y, 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
+{
+   _mesa_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
+}
+
+void
+_mesa_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
+{
+   _mesa_WindowPos4fMESA(x, y, z, 1.0F);
+}
+
+void
+_mesa_WindowPos3iMESA(GLint x, GLint y, GLint z)
+{
+   _mesa_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
+}
+
+void
+_mesa_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
+{
+   _mesa_WindowPos4fMESA(x, y, z, 1.0F);
+}
+
+void
+_mesa_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+   _mesa_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
+}
+
+void
+_mesa_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
+{
+   _mesa_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
+}
+
+void
+_mesa_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+   _mesa_WindowPos4fMESA(x, y, z, w);
+}
+
+void
+_mesa_WindowPos2dvMESA(const GLdouble *v)
+{
+   _mesa_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos2fvMESA(const GLfloat *v)
+{
+   _mesa_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos2ivMESA(const GLint *v)
+{
+   _mesa_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos2svMESA(const GLshort *v)
+{
+   _mesa_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
+}
+
+void
+_mesa_WindowPos3dvMESA(const GLdouble *v)
+{
+   _mesa_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
+}
+
+void
+_mesa_WindowPos3fvMESA(const GLfloat *v)
+{
+   _mesa_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
+}
+
+void
+_mesa_WindowPos3ivMESA(const GLint *v)
+{
+   _mesa_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
+}
+
+void
+_mesa_WindowPos3svMESA(const GLshort *v)
+{
+   _mesa_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
+}
+
+void
+_mesa_WindowPos4dvMESA(const GLdouble *v)
+{
+   _mesa_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 
+			 (GLfloat) v[2], (GLfloat) v[3]);
+}
+
+void
+_mesa_WindowPos4fvMESA(const GLfloat *v)
+{
+   _mesa_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
+}
+
+void
+_mesa_WindowPos4ivMESA(const GLint *v)
+{
+   _mesa_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 
+			 (GLfloat) v[2], (GLfloat) v[3]);
+}
+
+void
+_mesa_WindowPos4svMESA(const GLshort *v)
+{
+   _mesa_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
+}
+
+
+
+#if 0
+
+/*
+ * OpenGL implementation of glWindowPos*MESA()
+ */
+void glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+   GLfloat fx, fy;
+
+   /* Push current matrix mode and viewport attributes */
+   glPushAttrib( GL_TRANSFORM_BIT | GL_VIEWPORT_BIT );
+
+   /* Setup projection parameters */
+   glMatrixMode( GL_PROJECTION );
+   glPushMatrix();
+   glLoadIdentity();
+   glMatrixMode( GL_MODELVIEW );
+   glPushMatrix();
+   glLoadIdentity();
+
+   glDepthRange( z, z );
+   glViewport( (int) x - 1, (int) y - 1, 2, 2 );
+
+   /* set the raster (window) position */
+   fx = x - (int) x;
+   fy = y - (int) y;
+   glRasterPos4f( fx, fy, 0.0, w );
+
+   /* restore matrices, viewport and matrix mode */
+   glPopMatrix();
+   glMatrixMode( GL_PROJECTION );
+   glPopMatrix();
+
+   glPopAttrib();
+}
+
+#endif
Index: xc/extras/Mesa/src/rastpos.h
diff -u xc/extras/Mesa/src/rastpos.h:1.3 xc/extras/Mesa/src/rastpos.h:1.4
--- xc/extras/Mesa/src/rastpos.h:1.3	Tue Feb 15 02:12:32 2000
+++ xc/extras/Mesa/src/rastpos.h	Fri Feb 22 14:25:38 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -104,5 +104,81 @@
 _mesa_RasterPos4sv(const GLshort *v);
 
 
-#endif
+/**********************************************************************/
+/***                     GL_MESA_window_pos                         ***/
+/**********************************************************************/
+
+extern void
+_mesa_WindowPos2dMESA(GLdouble x, GLdouble y);
+
+extern void
+_mesa_WindowPos2fMESA(GLfloat x, GLfloat y);
+
+extern void
+_mesa_WindowPos2iMESA(GLint x, GLint y);
+
+extern void
+_mesa_WindowPos2sMESA(GLshort x, GLshort y);
+
+extern void
+_mesa_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z);
+
+extern void
+_mesa_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z);
 
+extern void
+_mesa_WindowPos3iMESA(GLint x, GLint y, GLint z);
+
+extern void
+_mesa_WindowPos3sMESA(GLshort x, GLshort y, GLshort z);
+
+extern void
+_mesa_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+
+extern void
+_mesa_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+
+extern void
+_mesa_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w);
+
+extern void
+_mesa_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w);
+
+extern void
+_mesa_WindowPos2dvMESA(const GLdouble *v);
+
+extern void
+_mesa_WindowPos2fvMESA(const GLfloat *v);
+
+extern void
+_mesa_WindowPos2ivMESA(const GLint *v);
+
+extern void
+_mesa_WindowPos2svMESA(const GLshort *v);
+
+extern void
+_mesa_WindowPos3dvMESA(const GLdouble *v);
+
+extern void
+_mesa_WindowPos3fvMESA(const GLfloat *v);
+
+extern void
+_mesa_WindowPos3ivMESA(const GLint *v);
+
+extern void
+_mesa_WindowPos3svMESA(const GLshort *v);
+
+extern void
+_mesa_WindowPos4dvMESA(const GLdouble *v);
+
+extern void
+_mesa_WindowPos4fvMESA(const GLfloat *v);
+
+extern void
+_mesa_WindowPos4ivMESA(const GLint *v);
+
+extern void
+_mesa_WindowPos4svMESA(const GLshort *v);
+
+
+#endif
Index: xc/extras/Mesa/src/readpix.c
diff -u xc/extras/Mesa/src/readpix.c:1.10 xc/extras/Mesa/src/readpix.c:removed
--- xc/extras/Mesa/src/readpix.c:1.10	Tue Mar 20 21:48:46 2001
+++ xc/extras/Mesa/src/readpix.c	Thu Feb 27 12:15:41 2003
@@ -1,806 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4.1
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "alphabuf.h"
-#include "context.h"
-#include "depth.h"
-#include "feedback.h"
-#include "image.h"
-#include "macros.h"
-#include "mem.h"
-#include "pixel.h"
-#include "readpix.h"
-#include "span.h"
-#include "state.h"
-#include "stencil.h"
-#include "types.h"
-#endif
-
-
-
-
-/*
- * Read a block of color index pixels.
- */
-static void read_index_pixels( GLcontext *ctx,
-                               GLint x, GLint y,
-			       GLsizei width, GLsizei height,
-			       GLenum type, GLvoid *pixels,
-                               const struct gl_pixelstore_attrib *packing )
-{
-   GLint i, j, readWidth;
-
-   /* error checking */
-   if (ctx->Visual->RGBAflag) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
-      return;
-   }
-
-   ASSERT(ctx->Driver.SetReadBuffer);
-   (*ctx->Driver.SetReadBuffer)(ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer);
-
-   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
-
-   /* process image row by row */
-   for (j=0;j<height;j++,y++) {
-      GLuint index[MAX_WIDTH];
-      GLvoid *dest;
-
-      (*ctx->Driver.ReadCI32Span)( ctx, readWidth, x, y, index );
-
-      if (ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0) {
-         _mesa_shift_and_offset_ci( ctx, readWidth, index);
-      }
-
-      if (ctx->Pixel.MapColorFlag) {
-         _mesa_map_ci(ctx, readWidth, index);
-      }
-
-      dest = _mesa_image_address(packing, pixels,
-                         width, height, GL_COLOR_INDEX, type, 0, j, 0);
-
-      switch (type) {
-	 case GL_UNSIGNED_BYTE:
-	    {
-               GLubyte *dst = (GLubyte *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  *dst++ = (GLubyte) index[i];
-	       }
-	    }
-	    break;
-	 case GL_BYTE:
-	    {
-               GLbyte *dst = (GLbyte *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLbyte) index[i];
-	       }
-	    }
-	    break;
-	 case GL_UNSIGNED_SHORT:
-	    {
-               GLushort *dst = (GLushort *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLushort) index[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap2( (GLushort *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_SHORT:
-	    {
-               GLshort *dst = (GLshort *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLshort) index[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap2( (GLushort *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_UNSIGNED_INT:
-	    {
-               GLuint *dst = (GLuint *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLuint) index[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap4( (GLuint *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_INT:
-	    {
-               GLint *dst = (GLint *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLint) index[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap4( (GLuint *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_FLOAT:
-	    {
-               GLfloat *dst = (GLfloat *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLfloat) index[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap4( (GLuint *) dst, readWidth );
-	       }
-	    }
-	    break;
-         default:
-            gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
-            j = height + 1; /* exit loop */
-      }
-   }
-
-   (*ctx->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer);
-}
-
-
-
-static void read_depth_pixels( GLcontext *ctx,
-                               GLint x, GLint y,
-			       GLsizei width, GLsizei height,
-			       GLenum type, GLvoid *pixels,
-                               const struct gl_pixelstore_attrib *packing )
-{
-   GLint i, j, readWidth;
-   GLboolean bias_or_scale;
-
-   /* Error checking */
-   if (ctx->Visual->DepthBits <= 0) {
-      /* No depth buffer */
-      gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
-      return;
-   }
-
-   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
-
-   if (type != GL_BYTE &&
-       type != GL_UNSIGNED_BYTE &&
-       type != GL_SHORT &&
-       type != GL_UNSIGNED_SHORT &&
-       type != GL_INT &&
-       type != GL_UNSIGNED_INT &&
-       type != GL_FLOAT) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels(depth type)");
-      return;
-   }
-
-   bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0;
-
-   if (type==GL_UNSIGNED_SHORT && ctx->Visual->DepthBits == 16
-       && !bias_or_scale && !packing->SwapBytes) {
-      /* Special case: directly read 16-bit unsigned depth values. */
-      for (j=0;j<height;j++,y++) {
-         GLdepth depth[MAX_WIDTH];
-         GLushort *dst = (GLushort*) _mesa_image_address( packing, pixels,
-                         width, height, GL_DEPTH_COMPONENT, type, 0, j, 0 );
-         GLint i;
-         _mesa_read_depth_span(ctx, width, x, y, depth);
-         for (i = 0; i < width; i++)
-            dst[i] = depth[i];
-      }
-   }
-   else if (type==GL_UNSIGNED_INT && ctx->Visual->DepthBits == 32
-            && !bias_or_scale && !packing->SwapBytes) {
-      /* Special case: directly read 32-bit unsigned depth values. */
-      for (j=0;j<height;j++,y++) {
-         GLdepth *dst = (GLdepth *) _mesa_image_address( packing, pixels,
-                         width, height, GL_DEPTH_COMPONENT, type, 0, j, 0 );
-         _mesa_read_depth_span(ctx, width, x, y, dst);
-      }
-   }
-   else {
-      /* General case (slower) */
-      for (j=0;j<height;j++,y++) {
-         GLfloat depth[MAX_WIDTH];
-         GLvoid *dest;
-
-         _mesa_read_depth_span_float(ctx, readWidth, x, y, depth);
-
-         if (bias_or_scale) {
-            for (i=0;i<readWidth;i++) {
-               GLfloat d;
-               d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
-               depth[i] = CLAMP( d, 0.0F, 1.0F );
-            }
-         }
-
-         dest = _mesa_image_address(packing, pixels,
-                         width, height, GL_DEPTH_COMPONENT, type, 0, j, 0);
-
-         switch (type) {
-            case GL_UNSIGNED_BYTE:
-               {
-                  GLubyte *dst = (GLubyte *) dest;
-                  for (i=0;i<readWidth;i++) {
-                     dst[i] = FLOAT_TO_UBYTE( depth[i] );
-                  }
-               }
-               break;
-            case GL_BYTE:
-               {
-                  GLbyte *dst = (GLbyte *) dest;
-                  for (i=0;i<readWidth;i++) {
-                     dst[i] = FLOAT_TO_BYTE( depth[i] );
-                  }
-               }
-               break;
-            case GL_UNSIGNED_SHORT:
-               {
-                  GLushort *dst = (GLushort *) dest;
-                  for (i=0;i<readWidth;i++) {
-                     dst[i] = FLOAT_TO_USHORT( depth[i] );
-                  }
-                  if (packing->SwapBytes) {
-                     _mesa_swap2( (GLushort *) dst, readWidth );
-                  }
-               }
-               break;
-            case GL_SHORT:
-               {
-                  GLshort *dst = (GLshort *) dest;
-                  for (i=0;i<readWidth;i++) {
-                     dst[i] = FLOAT_TO_SHORT( depth[i] );
-                  }
-                  if (packing->SwapBytes) {
-                     _mesa_swap2( (GLushort *) dst, readWidth );
-                  }
-               }
-               break;
-            case GL_UNSIGNED_INT:
-               {
-                  GLuint *dst = (GLuint *) dest;
-                  for (i=0;i<readWidth;i++) {
-                     dst[i] = FLOAT_TO_UINT( depth[i] );
-                  }
-                  if (packing->SwapBytes) {
-                     _mesa_swap4( (GLuint *) dst, readWidth );
-                  }
-               }
-               break;
-            case GL_INT:
-               {
-                  GLint *dst = (GLint *) dest;
-                  for (i=0;i<readWidth;i++) {
-                     dst[i] = FLOAT_TO_INT( depth[i] );
-                  }
-                  if (packing->SwapBytes) {
-                     _mesa_swap4( (GLuint *) dst, readWidth );
-                  }
-               }
-               break;
-            case GL_FLOAT:
-               {
-                  GLfloat *dst = (GLfloat *) dest;
-                  for (i=0;i<readWidth;i++) {
-                     dst[i] = depth[i];
-                  }
-                  if (packing->SwapBytes) {
-                     _mesa_swap4( (GLuint *) dst, readWidth );
-                  }
-               }
-               break;
-            default:
-               gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
-         }
-      }
-   }
-}
-
-
-
-
-static void read_stencil_pixels( GLcontext *ctx,
-                                 GLint x, GLint y,
-				 GLsizei width, GLsizei height,
-				 GLenum type, GLvoid *pixels,
-                                 const struct gl_pixelstore_attrib *packing )
-{
-   GLboolean shift_or_offset;
-   GLint i, j, readWidth;
-
-   if (type != GL_BYTE &&
-       type != GL_UNSIGNED_BYTE &&
-       type != GL_SHORT &&
-       type != GL_UNSIGNED_SHORT &&
-       type != GL_INT &&
-       type != GL_UNSIGNED_INT &&
-       type != GL_FLOAT &&
-       type != GL_BITMAP) {
-      gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels(stencil type)");
-      return;
-   }
-
-   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
-
-   if (ctx->Visual->StencilBits<=0) {
-      /* No stencil buffer */
-      gl_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
-      return;
-   }
-
-   shift_or_offset = ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0;
-
-   /* process image row by row */
-   for (j=0;j<height;j++,y++) {
-      GLvoid *dest;
-      GLstencil stencil[MAX_WIDTH];
-
-      _mesa_read_stencil_span( ctx, readWidth, x, y, stencil );
-
-      if (shift_or_offset) {
-         _mesa_shift_and_offset_stencil( ctx, readWidth, stencil );
-      }
-
-      if (ctx->Pixel.MapStencilFlag) {
-         _mesa_map_stencil( ctx, readWidth, stencil );
-      }
-
-      dest = _mesa_image_address( packing, pixels,
-                          width, height, GL_STENCIL_INDEX, type, 0, j, 0 );
-
-      switch (type) {
-	 case GL_UNSIGNED_BYTE:
-            if (sizeof(GLstencil) == 8) {
-               MEMCPY( dest, stencil, readWidth );
-            }
-            else {
-               GLubyte *dst = (GLubyte *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLubyte) stencil[i];
-	       }
-            }
-	    break;
-	 case GL_BYTE:
-            if (sizeof(GLstencil) == 8) {
-               MEMCPY( dest, stencil, readWidth );
-            }
-            else {
-               GLbyte *dst = (GLbyte *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLbyte) stencil[i];
-	       }
-            }
-	    break;
-	 case GL_UNSIGNED_SHORT:
-	    {
-               GLushort *dst = (GLushort *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLushort) stencil[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap2( (GLushort *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_SHORT:
-	    {
-               GLshort *dst = (GLshort *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLshort) stencil[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap2( (GLushort *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_UNSIGNED_INT:
-	    {
-               GLuint *dst = (GLuint *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLuint) stencil[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap4( (GLuint *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_INT:
-	    {
-               GLint *dst = (GLint *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  *dst++ = (GLint) stencil[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap4( (GLuint *) dst, readWidth );
-	       }
-	    }
-	    break;
-	 case GL_FLOAT:
-	    {
-               GLfloat *dst = (GLfloat *) dest;
-	       for (i=0;i<readWidth;i++) {
-		  dst[i] = (GLfloat) stencil[i];
-	       }
-	       if (packing->SwapBytes) {
-		  _mesa_swap4( (GLuint *) dst, readWidth );
-	       }
-	    }
-	    break;
-         case GL_BITMAP:
-            if (packing->LsbFirst) {
-               GLubyte *dst = (GLubyte*) dest;
-               GLint shift = 0;
-               for (i = 0; i < readWidth; i++) {
-                  if (shift == 0)
-                     *dst = 0;
-                  *dst |= ((stencil != 0) << shift);
-                  shift++;
-                  if (shift == 8) {
-                     shift = 0;
-                     dst++;
-                  }
-               }
-            }
-            else {
-               GLubyte *dst = (GLubyte*) dest;
-               GLint shift = 7;
-               for (i = 0; i < readWidth; i++) {
-                  if (shift == 7)
-                     *dst = 0;
-                  *dst |= ((stencil != 0) << shift);
-                  shift--;
-                  if (shift < 0) {
-                     shift = 7;
-                     dst++;
-                  }
-               }
-            }
-            break;
-         default:
-            gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
-      }
-   }
-}
-
-
-
-/*
- * Optimized glReadPixels for particular pixel formats:
- *   GL_UNSIGNED_BYTE, GL_RGBA
- * when pixel scaling, biasing and mapping are disabled.
- */
-static GLboolean
-read_fast_rgba_pixels( GLcontext *ctx,
-                       GLint x, GLint y,
-                       GLsizei width, GLsizei height,
-                       GLenum format, GLenum type,
-                       GLvoid *pixels,
-                       const struct gl_pixelstore_attrib *packing )
-{
-   GLboolean applyTransferOps;
-
-   applyTransferOps = ctx->Pixel.ScaleOrBiasRGBA ||
-                      ctx->Pixel.MapColorFlag ||
-                      ctx->ColorMatrix.type != MATRIX_IDENTITY ||
-                      ctx->Pixel.ScaleOrBiasRGBApcm ||
-                      ctx->Pixel.ColorTableEnabled ||
-                      ctx->Pixel.PostColorMatrixColorTableEnabled ||
-                      ctx->Pixel.MinMaxEnabled ||
-                      ctx->Pixel.HistogramEnabled;
-
-   /* can't do scale, bias, mapping, etc */
-   if (applyTransferOps)
-       return GL_FALSE;
-
-   /* can't do fancy pixel packing */
-   if (packing->Alignment != 1 || packing->SwapBytes || packing->LsbFirst)
-      return GL_FALSE;
-
-   {
-      GLint srcX = x;
-      GLint srcY = y;
-      GLint readWidth = width;           /* actual width read */
-      GLint readHeight = height;         /* actual height read */
-      GLint skipPixels = packing->SkipPixels;
-      GLint skipRows = packing->SkipRows;
-      GLint rowLength;
-
-      if (packing->RowLength > 0)
-         rowLength = packing->RowLength;
-      else
-         rowLength = width;
-
-      /* horizontal clipping */
-      if (srcX < ctx->ReadBuffer->Xmin) {
-         skipPixels += (ctx->ReadBuffer->Xmin - srcX);
-         readWidth  -= (ctx->ReadBuffer->Xmin - srcX);
-         srcX = ctx->ReadBuffer->Xmin;
-      }
-      if (srcX + readWidth > ctx->ReadBuffer->Xmax)
-         readWidth -= (srcX + readWidth - ctx->ReadBuffer->Xmax - 1);
-      if (readWidth <= 0)
-         return GL_TRUE;
-
-      /* vertical clipping */
-      if (srcY < ctx->ReadBuffer->Ymin) {
-         skipRows   += (ctx->ReadBuffer->Ymin - srcY);
-         readHeight -= (ctx->ReadBuffer->Ymin - srcY);
-         srcY = ctx->ReadBuffer->Ymin;
-      }
-      if (srcY + readHeight > ctx->ReadBuffer->Ymax)
-         readHeight -= (srcY + readHeight - ctx->ReadBuffer->Ymax - 1);
-      if (readHeight <= 0)
-         return GL_TRUE;
-
-      /*
-       * Ready to read!
-       * The window region at (destX, destY) of size (readWidth, readHeight)
-       * will be read back.
-       * We'll write pixel data to buffer pointed to by "pixels" but we'll
-       * skip "skipRows" rows and skip "skipPixels" pixels/row.
-       */
-      if (format==GL_RGBA && type==GL_UNSIGNED_BYTE) {
-         GLubyte *dest = (GLubyte *) pixels
-                         + (skipRows * rowLength + skipPixels) * 4;
-         GLint row;
-         for (row=0; row<readHeight; row++) {
-            (*ctx->Driver.ReadRGBASpan)(ctx, readWidth, srcX, srcY,
-                                        (GLubyte (*)[4]) dest);
-            if (ctx->DrawBuffer->UseSoftwareAlphaBuffers) {
-               _mesa_read_alpha_span(ctx, readWidth, srcX, srcY,
-                                     (GLubyte (*)[4]) dest);
-            }
-            dest += rowLength * 4;
-            srcY++;
-         }
-         return GL_TRUE;
-      }
-      else {
-         /* can't do this format/type combination */
-         return GL_FALSE;
-      }
-   }
-}
-
-
-/*
- * This function converts an array of GLchan colors to GLfloat colors.
- * Most importantly, it undoes the non-uniform quantization of pixel
- * values introduced when we convert shallow (< 8 bit) pixel values
- * to GLubytes in the ctx->Driver.ReadRGBASpan() functions.
- * This fixes a number of OpenGL conformance failures when running on
- * 16bpp displays, for example.
- */
-static void
-ubyte_to_float_span(const GLcontext *ctx, GLuint n,
-                    CONST GLubyte rgba[][4], GLfloat rgbaf[][4])
-{
-   const GLuint rShift = 8 - ctx->Visual->RedBits;
-   const GLuint gShift = 8 - ctx->Visual->GreenBits;
-   const GLuint bShift = 8 - ctx->Visual->BlueBits;
-   GLuint aShift;
-   const GLfloat rScale = 1.0 / (GLfloat) ((1 << ctx->Visual->RedBits  ) - 1);
-   const GLfloat gScale = 1.0 / (GLfloat) ((1 << ctx->Visual->GreenBits) - 1);
-   const GLfloat bScale = 1.0 / (GLfloat) ((1 << ctx->Visual->BlueBits ) - 1);
-   GLfloat aScale;
-   GLuint i;
-
-   if (ctx->Visual->AlphaBits > 0) {
-      aShift = 8 - ctx->Visual->AlphaBits;
-      aScale = 1.0 / (GLfloat) ((1 << ctx->Visual->AlphaBits) - 1);
-   }
-   else {
-      aShift = 0;
-      aScale = 1.0F / 255.0F;
-   }
-
-   for (i = 0; i < n; i++) {
-      const GLint r = rgba[i][RCOMP] >> rShift;
-      const GLint g = rgba[i][GCOMP] >> gShift;
-      const GLint b = rgba[i][BCOMP] >> bShift;
-      const GLint a = rgba[i][ACOMP] >> aShift;
-      rgbaf[i][RCOMP] = (GLfloat) r * rScale;
-      rgbaf[i][GCOMP] = (GLfloat) g * gScale;
-      rgbaf[i][BCOMP] = (GLfloat) b * bScale;
-      rgbaf[i][ACOMP] = (GLfloat) a * aScale;
-   }
-}
-
-
-
-/*
- * Read R, G, B, A, RGB, L, or LA pixels.
- */
-static void read_rgba_pixels( GLcontext *ctx,
-                              GLint x, GLint y,
-                              GLsizei width, GLsizei height,
-                              GLenum format, GLenum type, GLvoid *pixels,
-                              const struct gl_pixelstore_attrib *packing )
-{
-   GLint readWidth;
-
-   (*ctx->Driver.SetReadBuffer)(ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer);
-
-   /* Try optimized path first */
-   if (read_fast_rgba_pixels( ctx, x, y, width, height,
-                              format, type, pixels, packing )) {
-
-      (*ctx->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer);
-      return; /* done! */
-   }
-
-   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
-
-   /* do error checking on pixel type, format was already checked by caller */
-   switch (type) {
-      case GL_UNSIGNED_BYTE:
-      case GL_BYTE:
-      case GL_UNSIGNED_SHORT:
-      case GL_SHORT:
-      case GL_UNSIGNED_INT:
-      case GL_INT:
-      case GL_FLOAT:
-      case GL_UNSIGNED_BYTE_3_3_2:
-      case GL_UNSIGNED_BYTE_2_3_3_REV:
-      case GL_UNSIGNED_SHORT_5_6_5:
-      case GL_UNSIGNED_SHORT_5_6_5_REV:
-      case GL_UNSIGNED_SHORT_4_4_4_4:
-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
-      case GL_UNSIGNED_SHORT_5_5_5_1:
-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
-      case GL_UNSIGNED_INT_8_8_8_8:
-      case GL_UNSIGNED_INT_8_8_8_8_REV:
-      case GL_UNSIGNED_INT_10_10_10_2:
-      case GL_UNSIGNED_INT_2_10_10_10_REV:
-         /* valid pixel type */
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
-         return;
-   }
-
-   if (!_mesa_is_legal_format_and_type(format, type) ||
-       format == GL_INTENSITY) {
-      gl_error(ctx, GL_INVALID_OPERATION, "glReadPixels(format or type)");
-      return;
-   }
-
-   if (ctx->Visual->RGBAflag) {
-      GLint j;
-      for (j=0;j<height;j++,y++) {
-         GLubyte rgba[MAX_WIDTH][4];
-         GLvoid *dest;
-
-         gl_read_rgba_span( ctx, ctx->ReadBuffer, readWidth, x, y, rgba );
-
-         dest = _mesa_image_address( packing, pixels, width, height,
-                                     format, type, 0, j, 0);
-
-         if (ctx->Visual->RedBits < 8 ||
-             ctx->Visual->GreenBits < 8 ||
-             ctx->Visual->BlueBits < 8) {
-            /* Requantize the color values into floating point and go from
-             * there.  This fixes conformance failures with 16-bit color
-             * buffers, for example.
-             */
-            GLfloat rgbaf[MAX_WIDTH][4];
-            ubyte_to_float_span(ctx, readWidth,
-                                (CONST GLubyte (*)[4]) rgba, rgbaf);
-            _mesa_pack_float_rgba_span(ctx, readWidth,
-                                       (CONST GLfloat (*)[4]) rgbaf,
-                                       format, type, dest, packing,
-                                       GL_TRUE);
-         }
-         else {
-            /* GLubytes are fine */
-            _mesa_pack_rgba_span(ctx, readWidth, (CONST GLchan (*)[4]) rgba,
-                                 format, type, dest, packing, GL_TRUE);
-         }
-      }
-   }
-   else {
-      /* Convert color index pixels to RGBA */
-      GLint j;
-      for (j=0;j<height;j++,y++) {
-         GLubyte rgba[MAX_WIDTH][4];
-	 GLuint index[MAX_WIDTH];
-         GLvoid *dest;
-
-	 (*ctx->Driver.ReadCI32Span)( ctx, readWidth, x, y, index );
-
-	 if (ctx->Pixel.IndexShift!=0 || ctx->Pixel.IndexOffset!=0) {
-            _mesa_map_ci( ctx, readWidth, index );
-	 }
-
-         _mesa_map_ci_to_rgba_ubyte(ctx, readWidth, index, rgba );
-
-         dest = _mesa_image_address( packing, pixels, width, height,
-                                     format, type, 0, j, 0);
-
-         _mesa_pack_rgba_span( ctx, readWidth, (CONST GLubyte (*)[4]) rgba,
-                               format, type, dest, packing, GL_TRUE );
-      }
-   }
-
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer );
-}
-
-
-
-void
-_mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
-		  GLenum format, GLenum type, GLvoid *pixels )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glReadPixels");
-
-   if (!pixels) {
-      gl_error( ctx, GL_INVALID_VALUE, "glReadPixels(pixels)" );
-      return;
-   }
-
-   if (ctx->NewState) {
-      gl_update_state(ctx);
-   }
-
-   if (ctx->Driver.ReadPixels &&
-       (*ctx->Driver.ReadPixels)(ctx, x, y, width, height,
-                                 format, type, &ctx->Pack, pixels))
-      return;
-
-   RENDER_START(ctx);
-
-   switch (format) {
-      case GL_COLOR_INDEX:
-         read_index_pixels(ctx, x, y, width, height, type, pixels, &ctx->Pack);
-	 break;
-      case GL_STENCIL_INDEX:
-	 read_stencil_pixels(ctx, x,y, width,height, type, pixels, &ctx->Pack);
-         break;
-      case GL_DEPTH_COMPONENT:
-	 read_depth_pixels(ctx, x, y, width, height, type, pixels, &ctx->Pack);
-	 break;
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_RGB:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE_ALPHA:
-      case GL_RGBA:
-      case GL_BGR:
-      case GL_BGRA:
-      case GL_ABGR_EXT:
-         read_rgba_pixels(ctx, x, y, width, height,
-                          format, type, pixels, &ctx->Pack);
-	 break;
-      default:
-	 gl_error( ctx, GL_INVALID_ENUM, "glReadPixels(format)" );
-   }
-
-   RENDER_FINISH(ctx);
-}
Index: xc/extras/Mesa/src/readpix.h
diff -u xc/extras/Mesa/src/readpix.h:1.3 xc/extras/Mesa/src/readpix.h:removed
--- xc/extras/Mesa/src/readpix.h:1.3	Tue Feb 15 02:12:32 2000
+++ xc/extras/Mesa/src/readpix.h	Thu Feb 27 12:15:41 2003
@@ -1,39 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef READPIX_H
-#define READPIX_H
-
-
-#include "glheader.h"
-
-
-extern void
-_mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
-                  GLenum format, GLenum type, GLvoid *pixels );
-
-
-#endif
Index: xc/extras/Mesa/src/rect.c
diff -u xc/extras/Mesa/src/rect.c:1.6 xc/extras/Mesa/src/rect.c:removed
--- xc/extras/Mesa/src/rect.c:1.6	Mon Nov 13 18:30:51 2000
+++ xc/extras/Mesa/src/rect.c	Thu Feb 27 12:15:41 2003
@@ -1,109 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "macros.h"
-#include "rect.h"
-#include "varray.h"
-#include "vbfill.h"
-#endif
-
-
-
-/*
- * Execute a glRect*() function.
- */
-void
-_mesa_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx, "glRect"); 
-   RESET_IMMEDIATE(ctx);
-   gl_Begin( ctx, GL_QUADS );
-   gl_Vertex2f( ctx, x1, y1 );
-   gl_Vertex2f( ctx, x2, y1 );
-   gl_Vertex2f( ctx, x2, y2 );
-   gl_Vertex2f( ctx, x1, y2 );
-   gl_End( ctx );
-
-   /* If compiling, flush these vertices so that they aren't saved
-    * by the normal vertex compilation methods.
-    */
-   if (ctx->CompileFlag) 
-   {
-      ctx->CompileFlag = 0;
-      ctx->input->maybe_transform_vb( ctx->input );
-      ctx->CompileFlag = GL_TRUE;
-   }
-}
-
-
-void
-_mesa_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
-{
-   _mesa_Rectf(x1, y1, x2, y2);
-}
-
-void
-_mesa_Rectdv(const GLdouble *v1, const GLdouble *v2)
-{
-   _mesa_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
-
-void
-_mesa_Rectfv(const GLfloat *v1, const GLfloat *v2)
-{
-   _mesa_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
-
-void
-_mesa_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
-{
-   _mesa_Rectf(x1, y1, x2, y2);
-}
-
-void
-_mesa_Rectiv(const GLint *v1, const GLint *v2)
-{
-   _mesa_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
-
-void
-_mesa_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
-{
-   _mesa_Rectf(x1, y1, x2, y2);
-}
-
-void
-_mesa_Rectsv(const GLshort *v1, const GLshort *v2)
-{
-   _mesa_Rectf(v1[0], v1[1], v2[0], v2[1]);
-}
-
Index: xc/extras/Mesa/src/rect.h
diff -u xc/extras/Mesa/src/rect.h:1.3 xc/extras/Mesa/src/rect.h:removed
--- xc/extras/Mesa/src/rect.h:1.3	Tue Feb 15 02:12:32 2000
+++ xc/extras/Mesa/src/rect.h	Thu Feb 27 12:15:41 2003
@@ -1,59 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef RECT_H
-#define RECT_H
-
-
-#include "glheader.h"
-
-
-extern void
-_mesa_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-
-extern void
-_mesa_Rectdv(const GLdouble *v1, const GLdouble *v2);
-
-extern void
-_mesa_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-
-extern void
-_mesa_Rectfv(const GLfloat *v1, const GLfloat *v2);
-
-extern void
-_mesa_Recti(GLint x1, GLint y1, GLint x2, GLint y2);
-
-extern void
-_mesa_Rectiv(const GLint *v1, const GLint *v2);
-
-extern void
-_mesa_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-
-extern void
-_mesa_Rectsv(const GLshort *v1, const GLshort *v2);
-
-
-#endif
Index: xc/extras/Mesa/src/render_tmp.h
diff -u xc/extras/Mesa/src/render_tmp.h:1.7 xc/extras/Mesa/src/render_tmp.h:removed
--- xc/extras/Mesa/src/render_tmp.h:1.7	Mon Nov 13 18:30:51 2000
+++ xc/extras/Mesa/src/render_tmp.h	Thu Feb 27 12:15:41 2003
@@ -1,314 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-#ifndef POSTFIX
-#define POSTFIX
-#endif
-
-#ifndef INIT
-#define INIT(x)  
-#endif
-
-#ifndef NEED_EDGEFLAG_SETUP
-#define NEED_EDGEFLAG_SETUP 0
-#define EDGEFLAG_TRI(a,b,c,d,e)
-#define EDGEFLAG_POLY_TRI_PRE(a,b,c,d)
-#define EDGEFLAG_POLY_TRI_POST(a,b,c,d)
-#define EDGEFLAG_QUAD(a,b,c,d,e)
-#endif
-
-#ifndef RESET_STIPPLE
-#define RESET_STIPPLE
-#endif
-
-
-static void TAG(render_vb_points)( struct vertex_buffer *VB,
-				   GLuint start,
-				   GLuint count,
-				   GLuint parity )
-{
-   LOCAL_VARS;
-   (void) parity;
-   VB->ctx->OcclusionResult = GL_TRUE;
-
-   INIT(GL_POINTS);
-   RENDER_POINTS( start, count );
-   POSTFIX;
-}
-
-static void TAG(render_vb_lines)( struct vertex_buffer *VB,
-				  GLuint start,
-				  GLuint count,
-				  GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-   VB->ctx->OcclusionResult = GL_TRUE;
-
-   INIT(GL_LINES);
-   for (j=start+1; j<count; j+=2 ) {
-      RENDER_LINE( j-1, j );
-      RESET_STIPPLE;
-   }
-   POSTFIX;
-}
-
-
-static void TAG(render_vb_line_strip)( struct vertex_buffer *VB,
-				       GLuint start,
-				       GLuint count,
-				       GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-   VB->ctx->OcclusionResult = GL_TRUE;
-
-   INIT(GL_LINES);
-   for (j=start+1; j<count; j++ ) {
-      RENDER_LINE( j-1, j );
-   }   
-
-   if (VB->Flag[count] & VERT_END) {
-      RESET_STIPPLE;
-   }
-   POSTFIX;
-}
-
-
-static void TAG(render_vb_line_loop)( struct vertex_buffer *VB,
-				      GLuint start,
-				      GLuint count,
-				      GLuint parity )
-{
-   GLuint i = start < VB->Start ? VB->Start : start + 1;	 
-   LOCAL_VARS;
-   (void) parity;
-   VB->ctx->OcclusionResult = GL_TRUE;
-
-   INIT(GL_LINES);
-   for ( ; i < count ; i++) {
-      RENDER_LINE( i-1, i );
-   }
-
-   if (VB->Flag[count] & VERT_END) {
-      RENDER_LINE( i-1, start );
-      RESET_STIPPLE;
-   }
-
-   POSTFIX;
-}
-
-
-static void TAG(render_vb_triangles)( struct vertex_buffer *VB,
-				      GLuint start,
-				      GLuint count,
-				      GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-
-   INIT(GL_POLYGON);
-   for (j=start+2; j<count; j+=3) {
-      RENDER_TRI( j-2, j-1, j, j, 0 );
-      RESET_STIPPLE;
-   }
-   POSTFIX;
-}
-
-
-
-static void TAG(render_vb_tri_strip)( struct vertex_buffer *VB,
-				      GLuint start,
-				      GLuint count,
-				      GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-   INIT(GL_POLYGON);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+2;j<count;j++,parity^=1) {
-	 EDGEFLAG_TRI( j-2, j-1, j, j, parity );
-	 RENDER_TRI( j-2, j-1, j, j, parity );
-	 RESET_STIPPLE;
-      }
-   } else {
-      for (j=start+2;j<count;j++,parity^=1) {
-	 RENDER_TRI( j-2, j-1, j, j, parity );
-      }
-   }
-   POSTFIX;
-}
-
-
-static void TAG(render_vb_tri_fan)( struct vertex_buffer *VB,
-				    GLuint start,
-				    GLuint count,
-				    GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-   INIT(GL_POLYGON);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+2;j<count;j++) {
-	 EDGEFLAG_TRI( start, j-1, j, j, 0 );
-	 RENDER_TRI( start, j-1, j, j, 0 );
-	 RESET_STIPPLE;
-      }
-   } else {
-      for (j=start+2;j<count;j++) {
-	 RENDER_TRI( start, j-1, j, j, 0 );
-      }
-   }
-
-   POSTFIX;
-}
-
-
-static void TAG(render_vb_poly)( struct vertex_buffer *VB,
-				 GLuint start,
-				 GLuint count,
-				 GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-   INIT(GL_POLYGON);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+2;j<count;j++) {
-	 EDGEFLAG_POLY_TRI_PRE( start, j-1, j, start );
-	 RENDER_TRI( start, j-1, j, start, 0 );
-	 EDGEFLAG_POLY_TRI_POST( start, j-1, j, start );
-      }
-      if (VB->Flag[count] & VERT_END) {
-	 RESET_STIPPLE;
-      }
-   }
-   else {
-      for (j=start+2;j<count;j++) {
-	 RENDER_TRI( start, j-1, j, start, 0 );
-      }
-   }
-   POSTFIX;
-}
-
-
-static void TAG(render_vb_quads)( struct vertex_buffer *VB,
-				  GLuint start,
-				  GLuint count,
-				  GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-   INIT(GL_POLYGON);
-   for (j=start+3; j<count; j+=4) {
-      RENDER_QUAD( j-3, j-2, j-1, j, j );
-      RESET_STIPPLE;
-   }
-   POSTFIX;
-}
-
-static void TAG(render_vb_quad_strip)( struct vertex_buffer *VB,
-				       GLuint start,
-				       GLuint count,
-				       GLuint parity )
-{
-   GLuint j;
-   LOCAL_VARS;
-   (void) parity;
-   INIT(GL_POLYGON);
-   if (NEED_EDGEFLAG_SETUP) {
-      for (j=start+3;j<count;j+=2) {
-	 EDGEFLAG_QUAD( j-3, j-2, j, j-1, j );
-	 RENDER_QUAD( j-3, j-2, j, j-1, j );
-	 RESET_STIPPLE;
-      }
-   } else {
-      for (j=start+3;j<count;j+=2) {
-	 RENDER_QUAD( j-3, j-2, j, j-1, j );
-      }
-   }
-   POSTFIX;
-}
-
-static void TAG(render_vb_noop)( struct vertex_buffer *VB,
-				 GLuint start,
-				 GLuint count,
-				 GLuint parity )
-{
-   (void) VB;
-   (void) start;
-   (void) count;
-   (void) parity;
-}
-
-
-
-static render_func TAG(render_tab)[GL_POLYGON+2] = {
-   TAG(render_vb_points),
-   TAG(render_vb_lines),
-   TAG(render_vb_line_loop),
-   TAG(render_vb_line_strip),
-   TAG(render_vb_triangles),
-   TAG(render_vb_tri_strip),
-   TAG(render_vb_tri_fan),
-   TAG(render_vb_quads),
-   TAG(render_vb_quad_strip),
-   TAG(render_vb_poly),
-   TAG(render_vb_noop)
-};
-
-static void TAG(render_init)( void )
-{
-}
-
-
-#ifndef PRESERVE_VB_DEFS
-#undef RENDER_TRI
-#undef RENDER_QUAD
-#undef RENDER_LINE
-#undef RENDER_POINTS
-#undef LOCAL_VARS
-#undef INIT
-#undef POSTFIX
-#undef RESET_STIPPLE
-#endif
-
-#ifndef PRESERVE_TAG
-#undef TAG
-#endif
-
-#undef PRESERVE_VB_DEFS
-#undef PRESERVE_TAG
-
Index: xc/extras/Mesa/src/scissor.c
diff -u xc/extras/Mesa/src/scissor.c:1.3 xc/extras/Mesa/src/scissor.c:removed
--- xc/extras/Mesa/src/scissor.c:1.3	Tue Feb 15 02:12:33 2000
+++ xc/extras/Mesa/src/scissor.c	Thu Feb 27 12:15:41 2003
@@ -1,121 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "macros.h"
-#include "scissor.h"
-#include "types.h"
-#endif
-
-
-void
-_mesa_Scissor( GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glScissor");
-
-   if (width < 0 || height < 0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glScissor" );
-      return;
-   }
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glScissor %d %d %d %d\n", x, y, width, height);
-
-   if (x != ctx->Scissor.X ||
-       y != ctx->Scissor.Y ||
-       width != ctx->Scissor.Width ||
-       height != ctx->Scissor.Height) {
-      ctx->Scissor.X = x;
-      ctx->Scissor.Y = y;
-      ctx->Scissor.Width = width;
-      ctx->Scissor.Height = height;
-      ctx->NewState |= NEW_RASTER_OPS;
-   }
-
-   if (ctx->Driver.Scissor)
-      ctx->Driver.Scissor( ctx, x, y, width, height );
-}
-
-
-
-/*
- * Apply the scissor test to a span of pixels.
- * Return:  0 = all pixels in the span are outside the scissor box.
- *          1 = one or more pixels passed the scissor test.
- */
-GLint gl_scissor_span( GLcontext *ctx,
-                       GLuint n, GLint x, GLint y, GLubyte mask[] )
-{
-   /* first check if whole span is outside the scissor box */
-   if (y < ctx->DrawBuffer->Ymin
-       || y > ctx->DrawBuffer->Ymax
-       || x > ctx->DrawBuffer->Xmax
-       || x + (GLint) n - 1 < ctx->DrawBuffer->Xmin) {
-      return 0;
-   }
-   else {
-      const GLint xMin = ctx->DrawBuffer->Xmin;
-      const GLint xMax = ctx->DrawBuffer->Xmax;
-      GLint i;
-      for (i = 0; x + i < xMin; i++) {
-         mask[i] = 0;
-      }
-      for (i = (GLint) n - 1; x + i > xMax; i--) {
-         mask[i] = 0;
-      }
-
-      return 1;
-   }
-}
-
-
-
-
-/*
- * Apply the scissor test to an array of pixels.
- */
-GLuint gl_scissor_pixels( GLcontext *ctx,
-                          GLuint n, const GLint x[], const GLint y[],
-                          GLubyte mask[] )
-{
-   const GLint xmin = ctx->DrawBuffer->Xmin;
-   const GLint xmax = ctx->DrawBuffer->Xmax;
-   const GLint ymin = ctx->DrawBuffer->Ymin;
-   const GLint ymax = ctx->DrawBuffer->Ymax;
-   GLuint i;
-
-   for (i=0;i<n;i++) {
-      mask[i] &= (x[i]>=xmin) & (x[i]<=xmax) & (y[i]>=ymin) & (y[i]<=ymax);
-   }
-
-   return 1;
-}
-
Index: xc/extras/Mesa/src/scissor.h
diff -u xc/extras/Mesa/src/scissor.h:1.3 xc/extras/Mesa/src/scissor.h:removed
--- xc/extras/Mesa/src/scissor.h:1.3	Tue Feb 15 02:12:33 2000
+++ xc/extras/Mesa/src/scissor.h	Thu Feb 27 12:15:41 2003
@@ -1,47 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef SCISSOR_H
-#define SCISSOR_H
-
-
-#include "types.h"
-
-
-extern void
-_mesa_Scissor( GLint x, GLint y, GLsizei width, GLsizei height );
-
-
-extern GLint
-gl_scissor_span( GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte mask[] );
-
-
-extern GLuint
-gl_scissor_pixels( GLcontext *ctx, GLuint n, const GLint x[], const GLint y[],
-                   GLubyte mask[] );
-
-
-#endif
Index: xc/extras/Mesa/src/shade.c
diff -u xc/extras/Mesa/src/shade.c:1.8 xc/extras/Mesa/src/shade.c:removed
--- xc/extras/Mesa/src/shade.c:1.8	Thu Nov 30 10:39:04 2000
+++ xc/extras/Mesa/src/shade.c	Thu Feb 27 12:15:41 2003
@@ -1,383 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "light.h"
-#include "macros.h"
-#include "mmath.h"
-#include "pipeline.h"
-#include "shade.h"
-#include "simple_list.h"
-#include "types.h"
-#endif
-
-#if defined(USE_X86_ASM)
-#include "X86/common_x86_asm.h"
-#endif
-
-
-/* Lerp between adjacent values in the f(x) lookup table, giving a
- * continuous function, with adequeate overall accuracy.  (Though
- * still pretty good compared to a straight lookup). 
- */
-#define GET_SHINE_TAB_ENTRY( table, dp, result )			\
-do {									\
-   struct gl_shine_tab *_tab = table;					\
-   if (dp>1.0)								\
-      result = pow( dp, _tab->shininess );				\
-   else {								\
-      float f = (dp * (SHINE_TABLE_SIZE-1));				\
-      int k = (int) f;							\
-      result = _tab->tab[k] + (f-k)*(_tab->tab[k+1]-_tab->tab[k]);	\
-   }									\
-} while (0)
-
-
-
-/* Combinatorics:  
- *     rgba_spec/rgba/rgba_fast/rgba_fast_single/ci
- *     one_side/two_side
- *     compacted_normals/ordinary_normals
- *     cull_mask/no_cull_mask
- */
-
-
-/* Table of all the shading functions.
- */
-gl_shade_func gl_shade_tab[0x10];
-gl_shade_func gl_shade_fast_tab[0x10];
-gl_shade_func gl_shade_fast_single_tab[0x10];
-gl_shade_func gl_shade_spec_tab[0x10];
-gl_shade_func gl_shade_ci_tab[0x10];
-
-
-/* The original case where the normal for vertex[j] is normal[j],
- * both stride-aware, and every normal is present.
- */
-#define NEXT_NORMAL        STRIDE_F(normal, nstride), mask++
-#define NEXT_VERTEX_NORMAL STRIDE_F(normal, nstride), mask++
-#define STATE_CHANGE(a,b)  1
-#define COMPACTED          0
-
-#define TAG(x)           x##_one_sided_masked
-#define INVALID(x)       0
-#define IDX              CULL_MASK_ACTIVE
-#define LIGHT_FRONT(x)   1
-#define LIGHT_REAR(x)    0
-#define LIGHT_SIDE(x,y)  1
-#define CULL(x)          !((x)&VERT_FACE_FLAGS)
-#define NR_SIDES         1
-#include "shade_tmp.h" 
-
-#define TAG(x)           x##_one_sided
-#define INVALID(x)       0
-#define IDX              0
-#define LIGHT_FRONT(x)   1
-#define LIGHT_REAR(x)    0
-#define LIGHT_SIDE(x,y)  1
-#define CULL(x)          0 
-#define NR_SIDES         1
-#include "shade_tmp.h" 
-
-#define TAG(x)           x##_two_sided_masked
-#define INVALID(x)       ((x)&invalid)
-#define IDX              SHADE_TWOSIDE|CULL_MASK_ACTIVE
-#define LIGHT_FRONT(f)   ((f)&VERT_FACE_FRONT)
-#define LIGHT_REAR(f)    ((f)&VERT_FACE_REAR)
-#define LIGHT_SIDE(x,y)  ((x)&(y))
-#define CULL(x)          !((x)&VERT_FACE_FLAGS)
-#define NR_SIDES         2
-#include "shade_tmp.h"
-
-#define TAG(x)           x##_two_sided
-#define INVALID(x)       0
-#define IDX              SHADE_TWOSIDE
-#define LIGHT_FRONT(f)   1
-#define LIGHT_REAR(f)    1
-#define LIGHT_SIDE(x,y)  1
-#define CULL(x)          0
-#define NR_SIDES         2
-#include "shade_tmp.h"
-
-#undef NEXT_NORMAL 
-#undef NEXT_VERTEX_NORMAL 
-#undef STATE_CHANGE
-#undef COMPACTED
-
-/* The 'compacted normal' case, where we have a sparse list of normals
- * with flags indicating a new (valid) normal, as now built by the
- * 'glVertex' API routines.   We have a small bonus in that we know
- * in advance that the normal stride must be 3 floats.
- */
-#define NEXT_NORMAL         ((flags[j]&VERT_NORM) ? normal=first_normal[j],mask=&cullmask[j] : 0)
-#define NEXT_VERTEX_NORMAL  ((flags[j]&VERT_NORM) ? normal=first_normal[j],mask=&cullmask[j] : 0)
-#define STATE_CHANGE(a,b)   (a & b)
-#define COMPACTED            1
-
-
-#define TAG(x)           x##_one_sided_masked_compacted
-#define INVALID(x)       0
-#define IDX              COMPACTED_NORMALS|CULL_MASK_ACTIVE
-#define LIGHT_FRONT(x)   1
-#define LIGHT_REAR(x)    0
-#define LIGHT_SIDE(x,y)  1
-#define CULL(x)          !((x)&VERT_FACE_FLAGS)
-#define NR_SIDES         1
-#include "shade_tmp.h" 
-
-#define TAG(x)           x##_one_sided_compacted
-#define INVALID(x)       0
-#define IDX              COMPACTED_NORMALS
-#define LIGHT_FRONT(x)   1
-#define LIGHT_REAR(x)    0
-#define LIGHT_SIDE(x,y)  1
-#define CULL(x)          0
-#define NR_SIDES         1
-#include "shade_tmp.h" 
-
-#define TAG(x)           x##_two_sided_masked_compacted
-#define INVALID(x)       ((x)&invalid)
-#define IDX              COMPACTED_NORMALS|SHADE_TWOSIDE
-#define LIGHT_FRONT(f)   ((f)&VERT_FACE_FRONT)
-#define LIGHT_REAR(f)    ((f)&VERT_FACE_REAR)
-#define LIGHT_SIDE(x,y)  ((x)&(y))
-#define CULL(x)          !((x)&VERT_FACE_FLAGS)
-#define NR_SIDES         2
-#include "shade_tmp.h"
-
-#define TAG(x)           x##_two_sided_compacted
-#define INVALID(x)       0
-#define IDX              COMPACTED_NORMALS|CULL_MASK_ACTIVE|SHADE_TWOSIDE
-#define LIGHT_FRONT(f)   1
-#define LIGHT_REAR(f)    1
-#define LIGHT_SIDE(x,y)  1
-#define CULL(x)          0
-#define NR_SIDES         2
-#include "shade_tmp.h"
-
-#undef COMPACTED
-#undef NEXT_NORMAL 
-#undef NEXT_VERTEX_NORMAL 
-#undef STATE_CHANGE
-
-
-
-void gl_init_shade( void )
-{
-   init_shade_tab_one_sided();
-   init_shade_tab_one_sided_masked();
-   init_shade_tab_one_sided_compacted();
-   init_shade_tab_one_sided_masked_compacted();
-
-   init_shade_tab_two_sided();
-   init_shade_tab_two_sided_masked();
-   init_shade_tab_two_sided_compacted();
-   init_shade_tab_two_sided_masked_compacted();
-
-#ifdef USE_X86_ASM
-   gl_init_all_x86_shade_asm();
-#endif
-}
-
-void gl_update_lighting_function( GLcontext *ctx )
-{
-   gl_shade_func *tab;
-
-   if (ctx->Visual->RGBAflag) {
-      if (ctx->Light.NeedVertices) {
-	 if (ctx->Texture.ReallyEnabled && 
-	     ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) 
-	    tab = gl_shade_spec_tab;
-	 else
-	    tab = gl_shade_tab;	 
-      }  
-      else {
-	 if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev &&
-	     !ctx->Light.ColorMaterialEnabled) 
-	    tab = gl_shade_fast_single_tab;
-	 else
-	    tab = gl_shade_fast_tab;
-      }
-   }
-   else
-      tab = gl_shade_ci_tab;
-
-   if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-      tab += SHADE_TWOSIDE;
-   }
-
-   ctx->shade_func_tab = tab;
-}
-
-
-
-/* This has been split off to allow the normal shade routines to
- * get a little closer to the vertex buffer, and to use the 
- * GLvector objects directly.
- */
-void gl_shade_rastpos( GLcontext *ctx,
-		       GLfloat vertex[4],
-		       GLfloat normal[3],
-		       GLfloat Rcolor[4],
-		       GLuint *index )
-{
-   GLfloat (*base)[3] = ctx->Light.BaseColor;
-   GLubyte *sumA = ctx->Light.BaseAlpha;
-   struct gl_light *light;
-   GLfloat color[4];
-   GLfloat diffuse = 0, specular = 0;
-
-   COPY_3V(color, base[0]);
-   color[3] = UBYTE_COLOR_TO_FLOAT_COLOR( sumA[0] );
-
-   foreach (light, &ctx->Light.EnabledList) {
-      GLfloat n_dot_h;
-      GLfloat attenuation = 1.0;
-      GLfloat VP[3];  
-      GLfloat n_dot_VP;
-      GLfloat *h;
-      GLfloat contrib[3];
-      GLboolean normalized;
-
-      if (!(light->Flags & LIGHT_POSITIONAL)) {
-	 COPY_3V(VP, light->VP_inf_norm);
-	 attenuation = light->VP_inf_spot_attenuation;
-      }
-      else {
-	 GLfloat d; 
-	 
-	 SUB_3V(VP, light->Position, vertex);
-	 d = LEN_3FV( VP );
-	 
-	 if ( d > 1e-6) {
-	    GLfloat invd = 1.0F / d;
-	    SELF_SCALE_SCALAR_3V(VP, invd);
-	 }
-	 attenuation = 1.0F / (light->ConstantAttenuation + d * 
-			       (light->LinearAttenuation + d * 
-				light->QuadraticAttenuation));
-	 
-	 if (light->Flags & LIGHT_SPOT) 
-	 {
-	    GLfloat PV_dot_dir = - DOT3(VP, light->NormDirection);
-	    
-	    if (PV_dot_dir<light->CosCutoff) {
-	       continue; 
-	    }
-	    else 
-	    {
-	       double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
-	       int k = (int) x;
-	       GLfloat spot = (GLfloat) (light->SpotExpTable[k][0]
-			       + (x-k)*light->SpotExpTable[k][1]);
-	       attenuation *= spot;
-	    }
-	 }
-      }
-
-      if (attenuation < 1e-3) 
-	 continue;
-
-      n_dot_VP = DOT3( normal, VP );
-
-      if (n_dot_VP < 0.0F) {
-	 ACC_SCALE_SCALAR_3V(color, attenuation, light->MatAmbient[0]);
-	 continue;
-      } 
-
-      COPY_3V(contrib, light->MatAmbient[0]);
-      ACC_SCALE_SCALAR_3V(contrib, n_dot_VP, light->MatDiffuse[0]);
-      diffuse += n_dot_VP * light->dli * attenuation;
-
-      if (light->IsMatSpecular[0]) {
-	 if (ctx->Light.Model.LocalViewer) {
-	    GLfloat v[3];
-	    COPY_3V(v, vertex);
-	    NORMALIZE_3FV(v);
-	    SUB_3V(VP, VP, v);
-	    h = VP;
-	    normalized = 0;
-	 }
-	 else if (light->Flags & LIGHT_POSITIONAL) {
-	    h = VP;
-	    ACC_3V(h, ctx->EyeZDir);
-	    normalized = 0;
-	 }
-         else {
-	    h = light->h_inf_norm;
-	    normalized = 1;
-	 }
-	 
-	 n_dot_h = DOT3(normal, h);
-
-	 if (n_dot_h > 0.0F) {
-	    struct gl_material *mat = &ctx->Light.Material[0];
-	    GLfloat spec_coef;
-	    GLfloat shininess = mat->Shininess;
-
-	    if (!normalized) {
-	       n_dot_h *= n_dot_h;
-	       n_dot_h /= LEN_SQUARED_3FV( h );
-	       shininess *= .5;
-	    }
-	    
-	    GET_SHINE_TAB_ENTRY( ctx->ShineTable[0], n_dot_h, spec_coef );
-
-	    if (spec_coef > 1.0e-10) {
-	       ACC_SCALE_SCALAR_3V( contrib, spec_coef,
-				    light->MatSpecular[0]);
-	       specular += spec_coef * light->sli * attenuation;
-	    }
-	 }
-      }
-
-      ACC_SCALE_SCALAR_3V( color, attenuation, contrib );
-   } 
-
-   if (ctx->Visual->RGBAflag) {
-      Rcolor[0] = CLAMP(color[0], 0.0F, 1.0F);
-      Rcolor[1] = CLAMP(color[1], 0.0F, 1.0F);
-      Rcolor[2] = CLAMP(color[2], 0.0F, 1.0F);
-      Rcolor[3] = CLAMP(color[3], 0.0F, 1.0F);
-   }
-   else {
-      struct gl_material *mat = &ctx->Light.Material[0];
-      GLfloat d_a = mat->DiffuseIndex - mat->AmbientIndex;
-      GLfloat s_a = mat->SpecularIndex - mat->AmbientIndex;
-      GLfloat ind = mat->AmbientIndex
-                  + diffuse * (1.0F-specular) * d_a
-                  + specular * s_a;
-      if (ind > mat->SpecularIndex) {
-	 ind = mat->SpecularIndex;
-      }
-      *index = (GLuint) (GLint) ind;
-   }
-
-}
Index: xc/extras/Mesa/src/shade.h
diff -u xc/extras/Mesa/src/shade.h:1.4 xc/extras/Mesa/src/shade.h:removed
--- xc/extras/Mesa/src/shade.h:1.4	Thu Nov 30 10:39:04 2000
+++ xc/extras/Mesa/src/shade.h	Thu Feb 27 12:15:41 2003
@@ -1,55 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef SHADE_H
-#define SHADE_H
-
-
-#include "types.h"
-
-
-
-extern void gl_update_lighting_function( GLcontext *ctx );
-
-extern void gl_init_shade( void );
-
-extern gl_shade_func gl_shade_tab[0x10];
-extern gl_shade_func gl_shade_fast_tab[0x10];
-extern gl_shade_func gl_shade_fast_single_tab[0x10];
-extern gl_shade_func gl_shade_spec_tab[0x10];
-extern gl_shade_func gl_shade_ci_tab[0x10];
-
-
-void gl_shade_rastpos( GLcontext *ctx,
-		       GLfloat vertex[4],
-		       GLfloat normal[3],
-		       GLfloat Rcolor[4],
-		       GLuint *index );
-
-#endif
Index: xc/extras/Mesa/src/shade_tmp.h
diff -u xc/extras/Mesa/src/shade_tmp.h:1.10 xc/extras/Mesa/src/shade_tmp.h:removed
--- xc/extras/Mesa/src/shade_tmp.h:1.10	Tue Mar 20 22:02:18 2001
+++ xc/extras/Mesa/src/shade_tmp.h	Thu Feb 27 12:15:41 2003
@@ -1,958 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-static void TAG(shade_rgba_spec)( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLfloat (*base)[3] = ctx->Light.BaseColor;
-   GLubyte *sumA = ctx->Light.BaseAlpha;
-
-   GLuint j;
-
-   GLuint  vstride = VB->Unprojected->stride;
-   const GLfloat *vertex = VB->Unprojected->start;
-   GLuint  nstride = VB->NormalPtr->stride;
-   const GLfloat *normal = VB->NormalPtr->start;
-   CONST GLfloat (*first_normal)[3] = (CONST GLfloat (*)[3]) VB->NormalPtr->start;
-
-   /* Has stride 4 to help the drivers - and us...
-    */
-   GLubyte (*CMcolor)[4] = 0;
-
-   GLubyte (*Fcolor)[4] = (GLubyte (*)[4])VB->LitColor[0]->start;
-   GLubyte (*Bcolor)[4] = (GLubyte (*)[4])VB->LitColor[1]->start;
-   GLubyte (*Fspec)[4] = VB->Spec[0] + VB->Start;
-   GLubyte (*Bspec)[4] = VB->Spec[1] + VB->Start;
-   GLubyte *mask = VB->CullMask + VB->Start;
-   GLubyte *cullmask = mask;
-   GLuint *flags = VB->Flag + VB->Start;
-
-   struct gl_material (*new_material)[2] = VB->Material + VB->Start;
-   GLuint *new_material_mask = VB->MaterialMask + VB->Start;
-   GLuint nr = VB->Count - VB->Start;
-
-   GLuint cm_flags = 0;
-
-   (void) cullmask;
-   (void) nstride;
-   (void) first_normal;
-   (void) flags;
-
-   if (ctx->Light.ColorMaterialEnabled) {
-      cm_flags = VERT_RGBA;
-
-      if (VB->ColorPtr->flags & VEC_BAD_STRIDE)
-	 gl_clean_color(VB);
-
-      CMcolor =  (GLubyte (*)[4])VB->ColorPtr->start;
-   }
-
-   VB->Color[0] = VB->LitColor[0];
-   VB->Color[1] = VB->LitColor[1];
-   VB->ColorPtr = VB->LitColor[0];
-   VB->Specular = VB->Spec[0];
-
-   for ( j=0 ; j<nr ; j++,STRIDE_F(vertex,vstride),NEXT_VERTEX_NORMAL) {
-      GLfloat sum[2][3], spec[2][3];
-      struct gl_light *light;
-
-      if ( flags[j] & cm_flags )
-	 gl_update_color_material( ctx, CMcolor[j] );
-
-      if ( flags[j] & VERT_MATERIAL )
-	 gl_update_material( ctx, new_material[j], new_material_mask[j] );
-
-      if ( CULL(*mask) )
-	 continue;
-
-      if (LIGHT_FRONT(*mask)) {
-	 COPY_3V(sum[0], base[0]);
-	 ZERO_3V(spec[0]);
-      }
-
-      if (LIGHT_REAR(*mask)) {
-	 COPY_3V(sum[1], base[1]);
-	 ZERO_3V(spec[1]);
-      }
-
-      /* Add contribution from each enabled light source */
-      foreach (light, &ctx->Light.EnabledList) {
-	 GLfloat n_dot_h;
-	 GLfloat correction;
-	 GLint side;
-	 GLfloat contrib[3];
-	 GLfloat attenuation;
-	 GLfloat VP[3];  /* unit vector from vertex to light */
-	 GLfloat n_dot_VP;       /* n dot VP */
-	 GLfloat *h;
-	 GLboolean normalized;
-
-	 /* compute VP and attenuation */
-	 if (!(light->Flags & LIGHT_POSITIONAL)) {
-	    /* directional light */
-	    COPY_3V(VP, light->VP_inf_norm);
-	    attenuation = light->VP_inf_spot_attenuation;
-	 }
-	 else {
-	    GLfloat d;     /* distance from vertex to light */
-
-	    SUB_3V(VP, light->Position, vertex);
-
-	    d = (GLfloat) LEN_3FV( VP );
-
-	    if (d > 1e-6) {
-	       GLfloat invd = 1.0F / d;
-	       SELF_SCALE_SCALAR_3V(VP, invd);
-	    }
-
-	    attenuation = 1.0F / (light->ConstantAttenuation + d *
-				  (light->LinearAttenuation + d *
-				   light->QuadraticAttenuation));
-
-	    /* spotlight attenuation */
-	    if (light->Flags & LIGHT_SPOT) {
-	       GLfloat PV_dot_dir = - DOT3(VP, light->NormDirection);
-
-	       if (PV_dot_dir<light->CosCutoff) {
-		  continue; /* this light makes no contribution */
-	       }
-	       else {
-		  double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
-		  int k = (int) x;
-		  GLfloat spot = (GLfloat) (light->SpotExpTable[k][0]
-				  + (x-k)*light->SpotExpTable[k][1]);
-		  attenuation *= spot;
-	       }
-	    }
-	 }
-
-
-	 if (attenuation < 1e-3)
-	    continue;		/* this light makes no contribution */
-
-	 /* Compute dot product or normal and vector from V to light pos */
-	 n_dot_VP = DOT3( normal, VP );
-
-	 /* Which side gets the diffuse & specular terms? */
-	 if (n_dot_VP < 0.0F) {
-	    if (LIGHT_FRONT(*mask)) {
-	       ACC_SCALE_SCALAR_3V(sum[0], attenuation, light->MatAmbient[0]);
-	    }
-	    if (!LIGHT_REAR(*mask)) {
-	       continue;
-	    }
-	    side = 1;
-	    correction = -1;
-	    n_dot_VP = -n_dot_VP;
-	 }
-         else {
-	    if (LIGHT_REAR(*mask)) {
-	       ACC_SCALE_SCALAR_3V( sum[1], attenuation, light->MatAmbient[1]);
-	    }
-	    if (!LIGHT_FRONT(*mask)) {
-	       continue;
-	    }
-	    side = 0;
-	    correction = 1;
-	 }
-
-	 /* diffuse term */
-	 COPY_3V(contrib, light->MatAmbient[side]);
-	 ACC_SCALE_SCALAR_3V(contrib, n_dot_VP, light->MatDiffuse[side]);
-	 ACC_SCALE_SCALAR_3V(sum[side], attenuation, contrib );
-
-	 if (!light->IsMatSpecular[side])
-	    continue;
-
-	 /* specular term - cannibalize VP... */
-	 if (ctx->Light.Model.LocalViewer) {
-	    GLfloat v[3];
-	    COPY_3V(v, vertex);
-	    NORMALIZE_3FV(v);
-	    SUB_3V(VP, VP, v);                /* h = VP + VPe */
-	    h = VP;
-	    normalized = 0;
-	 }
-	 else if (light->Flags & LIGHT_POSITIONAL) {
-	    h = VP;
-	    ACC_3V(h, ctx->EyeZDir);
-	    normalized = 0;
-	 }
-         else {
-	    h = light->h_inf_norm;
-	    normalized = 1;
-	 }
-
-	 n_dot_h = correction * DOT3(normal, h);
-
-	 if (n_dot_h > 0.0F) {
-	    GLfloat spec_coef;
-	    struct gl_shine_tab *tab = ctx->ShineTable[side];
-
-	    if (!normalized) {
-	       n_dot_h *= n_dot_h;
-	       n_dot_h /= LEN_SQUARED_3FV( h );
-	       tab = ctx->ShineTable[side+2];
-	    }
-
-	    GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec_coef );
-
-	    if (spec_coef > 1.0e-10) {
-	       spec_coef *= attenuation;
-	       ACC_SCALE_SCALAR_3V( spec[side], spec_coef,
-				    light->MatSpecular[side]);
-	    }
-	 }
-      } /*loop over lights*/
-
-      if (LIGHT_FRONT(*mask)) {
-	 FLOAT_RGB_TO_UBYTE_RGB( Fcolor[j], sum[0] );
-	 FLOAT_RGB_TO_UBYTE_RGB( Fspec[j], spec[0] );
-	 Fcolor[j][3] = sumA[0];
-      }
-
-      if (LIGHT_REAR(*mask)) {
-	 FLOAT_RGB_TO_UBYTE_RGB( Bcolor[j], sum[1] );
-	 FLOAT_RGB_TO_UBYTE_RGB( Bspec[j], spec[1] );
-	 Bcolor[j][3] = sumA[1];
-      }
-   }
-
-   if ( flags[j] & cm_flags )
-      gl_update_color_material( ctx, CMcolor[j] );
-
-   if ( flags[j] & VERT_MATERIAL )
-      gl_update_material( ctx, new_material[j], new_material_mask[j] );
-}
-
-
-static void TAG(shade_rgba)( struct vertex_buffer *VB )
-{
-   GLuint j;
-   GLcontext *ctx = VB->ctx;
-
-   GLfloat (*base)[3] = ctx->Light.BaseColor;
-   GLubyte *sumA = ctx->Light.BaseAlpha;
-
-   GLuint  vstride = VB->Unprojected->stride;
-   const GLfloat *vertex = (GLfloat *)VB->Unprojected->start;
-   GLuint  nstride = VB->NormalPtr->stride;
-   const GLfloat *normal = VB->NormalPtr->start;
-   CONST GLfloat (*first_normal)[3] = (CONST GLfloat (*)[3])VB->NormalPtr->start;
-
-   GLubyte (*CMcolor)[4] = 0;
-   GLubyte (*Fcolor)[4] = (GLubyte (*)[4])VB->LitColor[0]->start;
-   GLubyte (*Bcolor)[4] = (GLubyte (*)[4])VB->LitColor[1]->start;
-   GLubyte *mask = VB->CullMask + VB->Start;
-   GLubyte *cullmask = mask;
-   GLuint *flags = VB->Flag + VB->Start;
-   GLuint cm_flags = 0;
-
-   struct gl_material (*new_material)[2] = VB->Material + VB->Start;
-   GLuint *new_material_mask = VB->MaterialMask + VB->Start;
-   GLuint nr = VB->Count - VB->Start;
-
-   (void) cullmask;
-   (void) nstride;
-   (void) first_normal;
-   (void) flags;
-
-   if (ctx->Light.ColorMaterialEnabled) {
-      cm_flags = VERT_RGBA;
-
-      if (VB->ColorPtr->flags & VEC_BAD_STRIDE)
-	 gl_clean_color(VB);
-
-      CMcolor =  (GLubyte (*)[4])VB->ColorPtr->start;
-   }
-
-   VB->ColorPtr = VB->LitColor[0];
-   VB->Color[0] = VB->LitColor[0];
-   VB->Color[1] = VB->LitColor[1];
-   VB->Specular = VB->Spec[0];
-
-   for ( j=0 ; j<nr ; j++,STRIDE_F(vertex,vstride),NEXT_VERTEX_NORMAL) {
-      GLfloat sum[2][3];
-      struct gl_light *light;
-
-      if ( flags[j] & cm_flags )
-	 gl_update_color_material( ctx, CMcolor[j] );
-
-      if ( flags[j] & VERT_MATERIAL )
-	 gl_update_material( ctx, new_material[j], new_material_mask[j] );
-
-      if ( CULL(*mask) )
-	 continue;
-
-      COPY_3V(sum[0], base[0]);
-
-      if ( NR_SIDES == 2 )
-	 COPY_3V(sum[1], base[1]);
-
-      /* Add contribution from each enabled light source */
-      foreach (light, &ctx->Light.EnabledList) {
-
-	 GLfloat n_dot_h;
-	 GLfloat correction;
-	 GLint side;
-	 GLfloat contrib[3];
-	 GLfloat attenuation = 1.0;
-	 GLfloat VP[3];          /* unit vector from vertex to light */
-	 GLfloat n_dot_VP;       /* n dot VP */
-	 GLfloat *h;
-	 GLboolean normalized;
-
-	 /* compute VP and attenuation */
-	 if (!(light->Flags & LIGHT_POSITIONAL)) {
-	    /* directional light */
-	    COPY_3V(VP, light->VP_inf_norm);
-	    attenuation = light->VP_inf_spot_attenuation;
-	 }
-	 else {
-	    GLfloat d;     /* distance from vertex to light */
-
-
-	    SUB_3V(VP, light->Position, vertex);
-
-	    d = LEN_3FV( VP );
-
-	    if ( d > 1e-6) {
-	       GLfloat invd = 1.0F / d;
-	       SELF_SCALE_SCALAR_3V(VP, invd);
-	    }
-
-            attenuation = 1.0F / (light->ConstantAttenuation + d *
-                                  (light->LinearAttenuation + d *
-                                   light->QuadraticAttenuation));
-
-	    /* spotlight attenuation */
-	    if (light->Flags & LIGHT_SPOT) {
-	       GLfloat PV_dot_dir = - DOT3(VP, light->NormDirection);
-
-	       if (PV_dot_dir<light->CosCutoff) {
-		  continue; /* this light makes no contribution */
-	       }
-	       else {
-		  double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
-		  int k = (int) x;
-		  GLfloat spot = (light->SpotExpTable[k][0]
-				  + (x-k)*light->SpotExpTable[k][1]);
-		  attenuation *= spot;
-	       }
-	    }
-	 }
-
-
-	 if (attenuation < 1e-3)
-	    continue;		/* this light makes no contribution */
-
-
-	 /* Compute dot product or normal and vector from V to light pos */
-	 n_dot_VP = DOT3( normal, VP );
-
-	 /* which side are we lighting? */
-	 if (n_dot_VP < 0.0F) {
-	    if (LIGHT_FRONT(*mask)) {
-	       ACC_SCALE_SCALAR_3V(sum[0], attenuation, light->MatAmbient[0]);
-	    }
-	    if (!LIGHT_REAR(*mask))
-	       continue;
-
-	    side = 1;
-	    correction = -1;
-	    n_dot_VP = -n_dot_VP;
-	 }
-         else {
-	    if (LIGHT_REAR(*mask)) {
-	       ACC_SCALE_SCALAR_3V( sum[1], attenuation, light->MatAmbient[1]);
-	    }
-	    if (!LIGHT_FRONT(*mask))
-	       continue;
-	    side = 0;
-	    correction = 1;
-	 }
-
-	 COPY_3V(contrib, light->MatAmbient[side]);
-
-	 /* diffuse term */
-	 ACC_SCALE_SCALAR_3V(contrib, n_dot_VP, light->MatDiffuse[side]);
-
-	 /* specular term - cannibalize VP... */
-	 if (light->IsMatSpecular[side]) {
-	    if (ctx->Light.Model.LocalViewer) {
-	       GLfloat v[3];
-	       COPY_3V(v, vertex);
-	       NORMALIZE_3FV(v);
-	       SUB_3V(VP, VP, v);                /* h = VP + VPe */
-	       h = VP;
-	       normalized = 0;
-	    }
-	    else if (light->Flags & LIGHT_POSITIONAL) {
-	       h = VP;
-	       ACC_3V(h, ctx->EyeZDir);
-	       normalized = 0;
-	    }
-            else {
-	       h = light->h_inf_norm;
-	       normalized = 1;
-	    }
-
-	    n_dot_h = correction * DOT3(normal, h);
-
-	    if (n_dot_h > 0.0F)
-	    {
-	       GLfloat spec_coef;
-	       struct gl_shine_tab *tab = ctx->ShineTable[side];
-
-	       if (!normalized) {
-		  n_dot_h *= n_dot_h;
-		  n_dot_h /= LEN_SQUARED_3FV( h );
-		  tab = ctx->ShineTable[side+2];
-	       }
-
-	       GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec_coef );
-
-	       ACC_SCALE_SCALAR_3V( contrib, spec_coef,
-				    light->MatSpecular[side]);
-	    }
-	 }
-
-	 ACC_SCALE_SCALAR_3V( sum[side], attenuation, contrib );
-      }
-
-      if (LIGHT_FRONT(*mask)) {
-	 FLOAT_RGB_TO_UBYTE_RGB( Fcolor[j], sum[0] );
-	 Fcolor[j][3] = sumA[0];
-      }
-
-      if (LIGHT_REAR(*mask)) {
-	 FLOAT_RGB_TO_UBYTE_RGB( Bcolor[j], sum[1] );
-	 Bcolor[j][3] = sumA[1];
-      }
-   }
-
-   if ( flags[j] & cm_flags )
-      gl_update_color_material( ctx, CMcolor[j] );
-
-   if ( flags[j] & VERT_MATERIAL )
-      gl_update_material( ctx, new_material[j], new_material_mask[j] );
-}
-
-
-
-
-/* As below, but with just a single light and no colormaterial.
- */
-static void TAG(shade_fast_rgba_single)( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint  nstride = VB->NormalPtr->stride;
-   const GLfloat *normal = VB->NormalPtr->start;
-   CONST GLfloat (*first_normal)[3] =
-      (CONST GLfloat (*)[3])VB->NormalPtr->start;
-   GLubyte (*Fcolor)[4] = (GLubyte (*)[4])VB->LitColor[0]->start;
-   GLubyte (*Bcolor)[4] = (GLubyte (*)[4])VB->LitColor[1]->start;
-   GLubyte *mask = VB->NormCullStart;
-   struct gl_light *light = ctx->Light.EnabledList.next;
-   GLubyte *cullmask = mask;
-   GLuint *flags = VB->Flag + VB->Start;
-   GLubyte baseubyte[2][4];
-   GLuint j = 0;
-   struct gl_material (*new_material)[2] = VB->Material + VB->Start;
-   GLuint *new_material_mask = VB->MaterialMask + VB->Start;
-   GLfloat base[2][3];
-
-   (void) cullmask;
-   (void) first_normal;
-   (void) nstride;
-
-   if ( flags[j] & VERT_MATERIAL )
-      gl_update_material( ctx, new_material[j], new_material_mask[j] );
-
-   /* No attenuation, so incoporate MatAmbient into base color.
-    */
-   {
-      COPY_3V(base[0], light->MatAmbient[0]);
-      ACC_3V(base[0], ctx->Light.BaseColor[0] );
-      FLOAT_RGB_TO_UBYTE_RGB( baseubyte[0], base[0] );
-      baseubyte[0][3] = ctx->Light.BaseAlpha[0];
-
-      if (NR_SIDES == 2) {
-	 COPY_3V(base[1], light->MatAmbient[1]);
-	 ACC_3V(base[1], ctx->Light.BaseColor[1]);
-	 FLOAT_RGB_TO_UBYTE_RGB( baseubyte[1], base[1]);
-	 baseubyte[1][3] = ctx->Light.BaseAlpha[1];
-      }
-   }
-
-   VB->ColorPtr = VB->LitColor[0];
-   VB->Color[0] = VB->LitColor[0];
-   VB->Color[1] = VB->LitColor[1];
-   VB->Specular = VB->Spec[0];
-
-   do {
-      do {
-	 if ( !CULL(*mask) ) {
-	    GLfloat n_dot_VP = DOT3(normal, light->VP_inf_norm);
-
-	    COPY_4UBV(Fcolor[j], baseubyte[0]);
-	    if (NR_SIDES == 2) COPY_4UBV(Bcolor[j], baseubyte[1]);
-
-	    if (n_dot_VP < 0.0F) {
-	       if (LIGHT_REAR(*mask)) {
-		  GLfloat n_dot_h = -DOT3(normal, light->h_inf_norm);
-		  if (n_dot_h > 0.0F) {
-		     GLfloat spec, sum[3];
-		     GET_SHINE_TAB_ENTRY( ctx->ShineTable[1], n_dot_h, spec );
-		     COPY_3V(sum, base[1]);
-		     ACC_SCALE_SCALAR_3V(sum, -n_dot_VP, light->MatDiffuse[1]);
-		     ACC_SCALE_SCALAR_3V(sum, spec, light->MatSpecular[1]);
-		     FLOAT_RGB_TO_UBYTE_RGB(Bcolor[j], sum );
-		  }
-	       }
-	    } else {
-	       if (LIGHT_FRONT(*mask)) {
-		  GLfloat n_dot_h = DOT3(normal, light->h_inf_norm);
-		  if (n_dot_h > 0.0F) {
-		     GLfloat spec, sum[3];
-		     GET_SHINE_TAB_ENTRY( ctx->ShineTable[0], n_dot_h, spec );
-		     COPY_3V(sum, base[0]);
-		     ACC_SCALE_SCALAR_3V(sum, n_dot_VP, light->MatDiffuse[0]);
-		     ACC_SCALE_SCALAR_3V(sum, spec, light->MatSpecular[0]);
-		     FLOAT_RGB_TO_UBYTE_RGB(Fcolor[j], sum );
-		  }
-	       }
-	    }
-	 }
-	 j++;
-	 NEXT_NORMAL;
-      } while ((flags[j] & (VERT_MATERIAL|VERT_END_VB|VERT_NORM)) == VERT_NORM);
-
-
-      if (COMPACTED) {
-	 GLuint last = j-1;
-	 for ( ; !(flags[j] & (VERT_MATERIAL|VERT_END_VB|VERT_NORM)) ; j++ ) {
-	    COPY_4UBV(Fcolor[j], Fcolor[last]);
-	    if (NR_SIDES==2)
-	       COPY_4UBV(Bcolor[j], Bcolor[last]);
-	 }
-	 NEXT_NORMAL;
-      }
-
-      /* Have to recompute our base colors on material change.
-       */
-      if ( flags[j] & VERT_MATERIAL ) {
-	 gl_update_material( ctx, new_material[j], new_material_mask[j] );
-
-	 COPY_3V(base[0], light->MatAmbient[0]);
-	 ACC_3V(base[0], ctx->Light.BaseColor[0] );
-	 FLOAT_RGB_TO_UBYTE_RGB( baseubyte[0], base[0] );
-
-	 if (NR_SIDES == 2) {
-	    COPY_3V(base[1], light->MatAmbient[1]);
-	    ACC_3V(base[1], ctx->Light.BaseColor[1]);
-	    FLOAT_RGB_TO_UBYTE_RGB( baseubyte[1], base[1]);
-	 }
-      }
-
-   } while (!(flags[j] & VERT_END_VB));
-}
-
-
-/* Vertex size doesn't matter - yay!
- */
-static void TAG(shade_fast_rgba)( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLfloat (*base)[3] = ctx->Light.BaseColor;
-   GLubyte *sumA = ctx->Light.BaseAlpha;
-   GLuint  nstride = VB->NormalPtr->stride;
-   const GLfloat *normal = VB->NormalPtr->start;
-   CONST GLfloat (*first_normal)[3] = (CONST GLfloat (*)[3])VB->NormalPtr->start;
-   GLubyte (*CMcolor)[4] = 0;
-   GLubyte (*Fcolor)[4] = (GLubyte (*)[4])VB->LitColor[0]->start;
-   GLubyte (*Bcolor)[4] = (GLubyte (*)[4])VB->LitColor[1]->start;
-   GLubyte *mask = VB->NormCullStart;
-   GLubyte *cullmask = mask;
-   GLuint *flags = VB->Flag + VB->Start;
-   GLuint cm_flags = 0;
-   GLuint interesting;
-   GLuint j = 0;
-   struct gl_material (*new_material)[2] = VB->Material + VB->Start;
-   GLuint *new_material_mask = VB->MaterialMask + VB->Start;
-   struct gl_light *light;
-
-   (void) cullmask;
-   (void) first_normal;
-   (void) flags;
-   (void) nstride;
-
-   if (ctx->Light.ColorMaterialEnabled)
-   {
-      cm_flags = VERT_RGBA;
-
-      if (VB->ColorPtr->flags & VEC_BAD_STRIDE)
-	 gl_clean_color(VB);
-
-      CMcolor =  (GLubyte (*)[4])VB->ColorPtr->start;
-      if ( *flags & VERT_RGBA )
-	 gl_update_color_material( ctx, *CMcolor );
-
-   }
-
-   if ( flags[j] & VERT_MATERIAL )
-      gl_update_material( ctx, new_material[j], new_material_mask[j] );
-
-   interesting = cm_flags | VERT_MATERIAL | VERT_END_VB | VERT_NORM;
-   VB->ColorPtr = VB->LitColor[0];
-   VB->Color[0] = VB->LitColor[0];
-   VB->Color[1] = VB->LitColor[1];
-   VB->Specular = VB->Spec[0];
-
-   do {
-      do {
-	 if ( !CULL(*mask) ) {
-	    GLfloat sum[2][3];
-	    GLfloat spec;
-
-	    COPY_3V(sum[0], base[0]);
-	    if (NR_SIDES == 2)  COPY_3V(sum[1], base[1]);
-
-	    if (MESA_VERBOSE&VERBOSE_LIGHTING)
-	       fprintf(stderr, "light normal %d/%d, %f %f %f\n",
-		       j, VB->Start, normal[0], normal[1], normal[2]);
-
-
-	    foreach (light, &ctx->Light.EnabledList) {
-
-	       GLfloat n_dot_h;
-	       GLint side = 0;
-	       GLfloat n_dot_VP = DOT3(normal, light->VP_inf_norm);
-
-	       ACC_3V(sum[0], light->MatAmbient[0]);
-	       if (NR_SIDES == 2) ACC_3V(sum[1], light->MatAmbient[1]);
-
-	       if (n_dot_VP < 0.0F) {
-		  if ( !LIGHT_REAR(*mask) ) continue;
-		  ACC_SCALE_SCALAR_3V(sum[1], -n_dot_VP, light->MatDiffuse[1]);
-		  if (!light->IsMatSpecular[1]) continue;
-		  n_dot_h = -DOT3(normal, light->h_inf_norm);
-		  side = 1;
-	       }
-               else {
-		  if ( !LIGHT_FRONT(*mask) ) continue;
-		  ACC_SCALE_SCALAR_3V(sum[0], n_dot_VP, light->MatDiffuse[0]);
-		  if (!light->IsMatSpecular[0]) continue;
-		  n_dot_h = DOT3(normal, light->h_inf_norm);
-	       }
-
-	       if (n_dot_h > 0.0F) {
-		  struct gl_shine_tab *tab = ctx->ShineTable[side];
-		  GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec );
-		  ACC_SCALE_SCALAR_3V( sum[side], spec,
-				       light->MatSpecular[side]);
-	       }
-	    }
-	    if (LIGHT_FRONT(*mask)) {
-	       FLOAT_RGB_TO_UBYTE_RGB( Fcolor[j], sum[0] );
-	       Fcolor[j][3] = sumA[0];
-	    }
-
-	    if (LIGHT_REAR(*mask)) {
-	       FLOAT_RGB_TO_UBYTE_RGB( Bcolor[j], sum[1] );
-	       Bcolor[j][3] = sumA[1];
-	    }
-	 }
-	 j++;
-	 NEXT_NORMAL;
-      } while ((flags[j] & interesting) == VERT_NORM);
-
-
-      if (COMPACTED) {
-	 GLuint last = j-1;
-
-	 for ( ; !(flags[j] & interesting) ; j++ )
-	 {
-	    COPY_4UBV(Fcolor[j], Fcolor[last]);
-	    if (NR_SIDES==2)
-	       COPY_4UBV(Bcolor[j], Bcolor[last]);
-	 }
-
-	 NEXT_NORMAL;
-      }
-
-      if ( flags[j] & cm_flags )
-	 gl_update_color_material( ctx, CMcolor[j] );
-
-      if ( flags[j] & VERT_MATERIAL )
-	 gl_update_material( ctx, new_material[j], new_material_mask[j] );
-
-   } while (!(flags[j] & VERT_END_VB));
-}
-
-
-
-
-
-/*
- * Use current lighting/material settings to compute the color indexes
- * for an array of vertices.
- * Input:  n - number of vertices to shade
- *         side - 0=use front material, 1=use back material
- *         vertex - array of [n] vertex position in eye coordinates
- *         normal - array of [n] surface normal vector
- * Output:  indexResult - resulting array of [n] color indexes
- */
-static void TAG(shade_ci)( struct vertex_buffer *VB )
-{
-   GLuint j;
-
-   GLcontext *ctx = VB->ctx;
-   GLuint  vstride = VB->Unprojected->stride;
-   const GLfloat *vertex = (GLfloat *)VB->Unprojected->start;
-   GLuint  nstride = VB->NormalPtr->stride;
-   const GLfloat *normal = VB->NormalPtr->start;
-   CONST GLfloat (*first_normal)[3] = (CONST GLfloat (*)[3])VB->NormalPtr->start;
-
-   GLubyte (*CMcolor)[4] = 0;
-   GLubyte *mask = VB->CullMask + VB->Start;
-   GLubyte *cullmask = mask;
-   GLuint *flags = VB->Flag + VB->Start;
-   GLuint cm_flags = 0;
-   GLuint  *indexResult[2];
-
-   struct gl_material (*new_material)[2] = VB->Material + VB->Start;
-   GLuint *new_material_mask = VB->MaterialMask + VB->Start;
-   GLuint nr = VB->Count - VB->Start;
-
-   (void) cullmask;
-   (void) nstride;
-   (void) first_normal;
-   (void) flags;
-
-   VB->IndexPtr = VB->LitIndex[0];
-   VB->Index[0] = VB->LitIndex[0];
-   VB->Index[1] = VB->LitIndex[1];
-
-   indexResult[0] = VB->Index[0]->start;
-   indexResult[1] = VB->Index[1]->start;
-
-   /* loop over vertices */
-
-   if (ctx->Light.ColorMaterialEnabled) {
-      cm_flags = VERT_RGBA;
-
-      if (VB->ColorPtr->flags & VEC_BAD_STRIDE)
-	 gl_clean_color(VB);
-
-      CMcolor =  (GLubyte (*)[4])VB->ColorPtr->start;
-   }
-
-   for ( j=0 ; j<nr ; j++,STRIDE_F(vertex,vstride),NEXT_VERTEX_NORMAL) {
-      GLfloat diffuse[2], specular[2];
-      GLuint side = 0;
-      struct gl_light *light;
-
-      if ( flags[j] & cm_flags )
-	 gl_update_color_material( ctx, CMcolor[j] );
-
-      if ( flags[j] & VERT_MATERIAL )
-	 gl_update_material( ctx, new_material[j], new_material_mask[j] );
-
-      if ( CULL(*mask) )
-	 continue;
-
-      diffuse[0] = specular[0] = 0.0F;
-
-      if ( NR_SIDES == 2 ) {
-	 diffuse[1] = specular[1] = 0.0F;
-      }
-
-      /* Accumulate diffuse and specular from each light source */
-      foreach (light, &ctx->Light.EnabledList) {
-
-	 GLfloat attenuation = 1.0F;
-	 GLfloat VP[3];  /* unit vector from vertex to light */
-	 GLfloat n_dot_VP;  /* dot product of l and n */
-	 GLfloat *h, n_dot_h, correction = 1.0;
-	 GLboolean normalized;
-
-	 /* compute l and attenuation */
-	 if (!(light->Flags & LIGHT_POSITIONAL)) {
-	    /* directional light */
-	    COPY_3V(VP, light->VP_inf_norm);
-	 }
-	 else {
-	    GLfloat d;     /* distance from vertex to light */
-
-	    SUB_3V(VP, light->Position, vertex);
-
-	    d = LEN_3FV( VP );
-	    if ( d > 1e-6) {
-	       GLfloat invd = 1.0F / d;
-	       SELF_SCALE_SCALAR_3V(VP, invd);
-	    }
-
-	    attenuation = 1.0F / (light->ConstantAttenuation + d *
-				  (light->LinearAttenuation + d *
-				   light->QuadraticAttenuation));
-
-	    /* spotlight attenuation */
-	    if (light->Flags & LIGHT_SPOT) {
-	       GLfloat PV_dot_dir = - DOT3(VP, light->NormDirection);
-	       if (PV_dot_dir<light->CosCutoff) {
-		  continue; /* this light makes no contribution */
-	       }
-	       else {
-		  double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
-		  int k = (int) x;
-		  GLfloat spot = (light->SpotExpTable[k][0]
-				  + (x-k)*light->SpotExpTable[k][1]);
-		  attenuation *= spot;
-	       }
-	    }
-	 }
-
-	 if (attenuation < 1e-3)
-	    continue;		/* this light makes no contribution */
-
-	 n_dot_VP = DOT3( normal, VP );
-
-	 /* which side are we lighting? */
-	 if (n_dot_VP < 0.0F) {
-	    if (!LIGHT_REAR(*mask))
-	       continue;
-	    side = 1;
-	    correction = -1;
-	    n_dot_VP = -n_dot_VP;
-	 }
-         else {
-	    if (!LIGHT_FRONT(*mask))
-	       continue;
-	 }
-
-	 /* accumulate diffuse term */
-	 diffuse[side] += n_dot_VP * light->dli * attenuation;
-
-	 /* specular term */
-	 if (!(light->Flags & LIGHT_SPECULAR))
-	    continue;
-
-	 if (ctx->Light.Model.LocalViewer) {
-	    GLfloat v[3];
-	    COPY_3V(v, vertex);
-	    NORMALIZE_3FV(v);
-	    SUB_3V(VP, VP, v);                /* h = VP + VPe */
-	    h = VP;
-	    normalized = 0;
-	 }
-	 else if (light->Flags & LIGHT_POSITIONAL) {
-	    h = VP;
-	    ACC_3V(h, ctx->EyeZDir);
-	    normalized = 0;
-	 }
-         else {
-	    h = light->h_inf_norm;
-	    normalized = 1;
-	 }
-
-	 n_dot_h = correction * DOT3(normal, h);
-
-	 if (n_dot_h > 0.0F)
-	 {
-	    GLfloat spec_coef;
-	    struct gl_shine_tab *tab = ctx->ShineTable[side];
-
-	    if (!normalized) {
-	       n_dot_h *= n_dot_h;
-	       n_dot_h /= LEN_SQUARED_3FV( h );
-	       tab = ctx->ShineTable[side+2];
-	    }
-
-	    GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec_coef);
-
-	    specular[side] += spec_coef * light->sli * attenuation;
-	 }
-      } /*loop over lights*/
-
-      /* Now compute final color index */
-      for (side = 0 ; side < NR_SIDES ; side++) {
-	 GLfloat index;
-	 struct gl_material *mat;
-
-	 if (!LIGHT_SIDE(*mask, side))
-	    continue;
-
-	 mat = &ctx->Light.Material[side];
-	 if (specular[side] > 1.0F) {
-	    index = mat->SpecularIndex;
-	 }
-	 else {
-	    GLfloat d_a = mat->DiffuseIndex - mat->AmbientIndex;
-	    GLfloat s_a = mat->SpecularIndex - mat->AmbientIndex;
-
-	    index = mat->AmbientIndex
-	       + diffuse[side] * (1.0F-specular[side]) * d_a
-	       + specular[side] * s_a;
-	    if (index > mat->SpecularIndex) {
-	       index = mat->SpecularIndex;
-	    }
-	 }
-	 indexResult[side][j] = (GLuint) (GLint) index;
-      }
-   } /*for vertex*/
-
-   if ( flags[j] & cm_flags )
-      gl_update_color_material( ctx, CMcolor[j] );
-
-   if ( flags[j] & VERT_MATERIAL )
-      gl_update_material( ctx, new_material[j], new_material_mask[j] );
-}
-
-
-
-static void TAG(init_shade_tab)( void )
-{
-   gl_shade_tab[IDX] = TAG(shade_rgba);
-   gl_shade_fast_tab[IDX] = TAG(shade_fast_rgba);
-   gl_shade_fast_single_tab[IDX] = TAG(shade_fast_rgba_single);
-   gl_shade_spec_tab[IDX] = TAG(shade_rgba_spec);
-   gl_shade_ci_tab[IDX] = TAG(shade_ci);
-}
-
-
-#undef TAG
-#undef INVALID
-#undef IDX
-#undef LIGHT_FRONT
-#undef LIGHT_REAR
-#undef LIGHT_SIDE
-#undef NR_SIDES
-#undef CULL
Index: xc/extras/Mesa/src/simple_list.h
diff -u xc/extras/Mesa/src/simple_list.h:1.3 xc/extras/Mesa/src/simple_list.h:1.4
--- xc/extras/Mesa/src/simple_list.h:1.3	Tue Feb 15 02:12:34 2000
+++ xc/extras/Mesa/src/simple_list.h	Fri Feb 22 14:25:39 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -27,7 +27,7 @@
  *  (C) 1997, Keith Whitwell
  *
  *  Intended to work with a list sentinal which is created as an empty
- *  list.  Insert & delete are O(1).  
+ *  list.  Insert & delete are O(1).
  */
 
 
@@ -95,4 +95,3 @@
 
 
 #endif
-
Index: xc/extras/Mesa/src/span.c
diff -u xc/extras/Mesa/src/span.c:1.8 xc/extras/Mesa/src/span.c:removed
--- xc/extras/Mesa/src/span.c:1.8	Mon Nov 13 18:30:51 2000
+++ xc/extras/Mesa/src/span.c	Thu Feb 27 12:15:42 2003
@@ -1,1072 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * pixel span rasterization:
- * These functions implement the rasterization pipeline.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "alpha.h"
-#include "alphabuf.h"
-#include "blend.h"
-#include "depth.h"
-#include "fog.h"
-#include "logic.h"
-#include "macros.h"
-#include "masking.h"
-#include "mem.h"
-#include "scissor.h"
-#include "span.h"
-#include "stencil.h"
-#include "texture.h"
-#include "types.h"
-#endif
-
-
-
-
-/*
- * Apply the current polygon stipple pattern to a span of pixels.
- */
-static void stipple_polygon_span( GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y, GLubyte mask[] )
-{
-   register GLuint i, m, stipple, highbit=0x80000000;
-
-   stipple = ctx->PolygonStipple[y % 32];
-   m = highbit >> (GLuint) (x % 32);
-
-   for (i=0;i<n;i++) {
-      if ((m & stipple)==0) {
-	 mask[i] = 0;
-      }
-      m = m >> 1;
-      if (m==0) {
-	 m = 0x80000000;
-      }
-   }
-}
-
-
-
-/*
- * Clip a pixel span to the current buffer/window boundaries.
- * Return:  0 = all pixels clipped
- *          1 = at least one pixel is visible
- */
-static GLuint clip_span( GLcontext *ctx,
-                         GLint n, GLint x, GLint y, GLubyte mask[] )
-{
-   GLint i;
-
-   /* Clip to top and bottom */
-   if (y < 0 || y >= ctx->DrawBuffer->Height) {
-      return 0;
-   }
-
-   /* Clip to left and right */
-   if (x >= 0 && x + n <= ctx->DrawBuffer->Width) {
-      /* no clipping needed */
-      return 1;
-   }
-   else if (x + n <= 0) {
-      /* completely off left side */
-      return 0;
-   }
-   else if (x >= ctx->DrawBuffer->Width) {
-      /* completely off right side */
-      return 0;
-   }
-   else {
-      /* clip-test each pixel, this could be done better */
-      for (i=0;i<n;i++) {
-         if (x + i < 0 || x + i >= ctx->DrawBuffer->Width) {
-            mask[i] = 0;
-         }
-      }
-      return 1;
-   }
-}
-
-
-
-/*
- * Draw to more than one color buffer (or none).
- */
-static void multi_write_index_span( GLcontext *ctx, GLuint n,
-                                    GLint x, GLint y, const GLuint indexes[],
-                                    const GLubyte mask[] )
-{
-   GLuint bufferBit;
-
-   if (ctx->Color.DrawBuffer == GL_NONE)
-      return;
-
-   /* loop over four possible dest color buffers */
-   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
-      if (bufferBit & ctx->Color.DrawDestMask) {
-         GLuint indexTmp[MAX_WIDTH];
-         ASSERT(n < MAX_WIDTH);
-
-         if (bufferBit == FRONT_LEFT_BIT)
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
-         else if (bufferBit == FRONT_RIGHT_BIT)
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
-         else if (bufferBit == BACK_LEFT_BIT)
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
-         else
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
-
-         /* make copy of incoming indexes */
-         MEMCPY( indexTmp, indexes, n * sizeof(GLuint) );
-         if (ctx->Color.SWLogicOpEnabled) {
-            _mesa_logicop_ci_span( ctx, n, x, y, indexTmp, mask );
-         }
-         if (ctx->Color.SWmasking) {
-            if (ctx->Color.IndexMask == 0)
-               break;
-            _mesa_mask_index_span( ctx, n, x, y, indexTmp );
-         }
-         (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, indexTmp, mask );
-      }
-   }
-
-   /* restore default dest buffer */
-   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer);
-}
-
-
-
-/*
- * Write a horizontal span of color index pixels to the frame buffer.
- * Stenciling, Depth-testing, etc. are done as needed.
- * Input:  n - number of pixels in the span
- *         x, y - location of leftmost pixel in the span
- *         z - array of [n] z-values
- *         index - array of [n] color indexes
- *         primitive - either GL_POINT, GL_LINE, GL_POLYGON, or GL_BITMAP
- */
-void gl_write_index_span( GLcontext *ctx,
-                          GLuint n, GLint x, GLint y, const GLdepth z[],
-			  GLuint indexIn[], GLenum primitive )
-{
-   const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT | LOGIC_OP_BIT;
-   GLubyte mask[MAX_WIDTH];
-   GLuint indexBackup[MAX_WIDTH];
-   GLuint *index;  /* points to indexIn or indexBackup */
-
-   /* init mask to 1's (all pixels are to be written) */
-   MEMSET(mask, 1, n);
-
-   if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
-      if (clip_span(ctx,n,x,y,mask)==0) {
-	 return;
-      }
-   }
-
-   if ((primitive==GL_BITMAP && (ctx->RasterMask & modBits))
-       || (ctx->RasterMask & MULTI_DRAW_BIT)) {
-      /* Make copy of color indexes */
-      MEMCPY( indexBackup, indexIn, n * sizeof(GLuint) );
-      index = indexBackup;
-   }
-   else {
-      index = indexIn;
-   }
-
-   /* Per-pixel fog */
-   if (ctx->Fog.Enabled && (primitive==GL_BITMAP || ctx->FogMode == FOG_FRAGMENT)) {
-      _mesa_fog_ci_pixels( ctx, n, z, index );
-   }
-
-   /* Do the scissor test */
-   if (ctx->Scissor.Enabled) {
-      if (gl_scissor_span( ctx, n, x, y, mask )==0) {
-	 return;
-      }
-   }
-
-   /* Polygon Stippling */
-   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
-      stipple_polygon_span( ctx, n, x, y, mask );
-   }
-
-   if (ctx->Stencil.Enabled) {
-      /* first stencil test */
-      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
-	 return;
-      }
-   }
-   else if (ctx->Depth.Test) {
-      /* regular depth testing */
-      if (_mesa_depth_test_span( ctx, n, x, y, z, mask )==0)  return;
-   }
-
-   /* if we get here, something passed the depth test */
-   ctx->OcclusionResult = GL_TRUE;
-
-   if (ctx->RasterMask & MULTI_DRAW_BIT) {
-      /* draw to zero or two or more buffers */
-      multi_write_index_span( ctx, n, x, y, index, mask );
-   }
-   else {
-      /* normal situation: draw to exactly one buffer */
-      if (ctx->Color.SWLogicOpEnabled) {
-         _mesa_logicop_ci_span( ctx, n, x, y, index, mask );
-      }
-      if (ctx->Color.SWmasking) {
-         if (ctx->Color.IndexMask == 0)
-            return;
-         _mesa_mask_index_span( ctx, n, x, y, index );
-      }
-
-      /* write pixels */
-      (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, index, mask );
-   }
-}
-
-
-
-
-void gl_write_monoindex_span( GLcontext *ctx,
-                              GLuint n, GLint x, GLint y, const GLdepth z[],
-			      GLuint index, GLenum primitive )
-{
-   GLubyte mask[MAX_WIDTH];
-   GLuint i;
-
-   /* init mask to 1's (all pixels are to be written) */
-   MEMSET(mask, 1, n);
-
-   if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
-      if (clip_span( ctx, n, x, y, mask)==0) {
-	 return;
-      }
-   }
-
-   /* Do the scissor test */
-   if (ctx->Scissor.Enabled) {
-      if (gl_scissor_span( ctx, n, x, y, mask )==0) {
-	 return;
-      }
-   }
-
-   /* Polygon Stippling */
-   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
-      stipple_polygon_span( ctx, n, x, y, mask );
-   }
-
-   if (ctx->Stencil.Enabled) {
-      /* first stencil test */
-      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
-	 return;
-      }
-   }
-   else if (ctx->Depth.Test) {
-      /* regular depth testing */
-      if (_mesa_depth_test_span( ctx, n, x, y, z, mask )==0)  return;
-   }
-
-   /* if we get here, something passed the depth test */
-   ctx->OcclusionResult = GL_TRUE;
-
-   if (ctx->Color.DrawBuffer == GL_NONE) {
-      /* write no pixels */
-      return;
-   }
-
-   if ((ctx->Fog.Enabled && (primitive==GL_BITMAP || ctx->FogMode==FOG_FRAGMENT))
-        || ctx->Color.SWLogicOpEnabled || ctx->Color.SWmasking) {
-      /* different index per pixel */
-      GLuint indexes[MAX_WIDTH];
-      for (i=0;i<n;i++) {
-	 indexes[i] = index;
-      }
-
-      if (ctx->Fog.Enabled && (primitive==GL_BITMAP || ctx->FogMode==FOG_FRAGMENT)) {
-	 _mesa_fog_ci_pixels( ctx, n, z, indexes );
-      }
-
-      if (ctx->Color.SWLogicOpEnabled) {
-	 _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
-      }
-
-      if (ctx->RasterMask & MULTI_DRAW_BIT) {
-         /* draw to zero or two or more buffers */
-         multi_write_index_span( ctx, n, x, y, indexes, mask );
-      }
-      else {
-         /* normal situation: draw to exactly one buffer */
-         if (ctx->Color.SWLogicOpEnabled) {
-            _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
-         }
-         if (ctx->Color.SWmasking) {
-            if (ctx->Color.IndexMask == 0)
-               return;
-            _mesa_mask_index_span( ctx, n, x, y, indexes );
-         }
-         (*ctx->Driver.WriteCI32Span)( ctx, n, x, y, indexes, mask );
-      }
-   }
-   else {
-      /* same color index for all pixels */
-      ASSERT(!ctx->Color.SWLogicOpEnabled);
-      ASSERT(!ctx->Color.SWmasking);
-      if (ctx->RasterMask & MULTI_DRAW_BIT) {
-         /* draw to zero or two or more buffers */
-         GLuint indexes[MAX_WIDTH];
-         for (i=0;i<n;i++)
-            indexes[i] = index;
-         multi_write_index_span( ctx, n, x, y, indexes, mask );
-      }
-      else {
-         /* normal situation: draw to exactly one buffer */
-         (*ctx->Driver.WriteMonoCISpan)( ctx, n, x, y, mask );
-      }
-   }
-}
-
-
-
-/*
- * Draw to more than one RGBA color buffer (or none).
- */
-static void multi_write_rgba_span( GLcontext *ctx, GLuint n,
-                                   GLint x, GLint y, CONST GLubyte rgba[][4],
-                                   const GLubyte mask[] )
-{
-   GLuint bufferBit;
-
-   if (ctx->Color.DrawBuffer == GL_NONE)
-      return;
-
-   /* loop over four possible dest color buffers */
-   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
-      if (bufferBit & ctx->Color.DrawDestMask) {
-         GLubyte rgbaTmp[MAX_WIDTH][4];
-         ASSERT(n < MAX_WIDTH);
-
-         if (bufferBit == FRONT_LEFT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontLeftAlpha;
-         }
-         else if (bufferBit == FRONT_RIGHT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontRightAlpha;
-         }
-         else if (bufferBit == BACK_LEFT_BIT) {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackLeftAlpha;
-         }
-         else {
-            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
-            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackRightAlpha;
-         }
-
-         /* make copy of incoming colors */
-         MEMCPY( rgbaTmp, rgba, 4 * n * sizeof(GLubyte) );
-
-         if (ctx->Color.SWLogicOpEnabled) {
-            _mesa_logicop_rgba_span( ctx, n, x, y, rgbaTmp, mask );
-         }
-         else if (ctx->Color.BlendEnabled) {
-            _mesa_blend_span( ctx, n, x, y, rgbaTmp, mask );
-         }
-         if (ctx->Color.SWmasking) {
-            if (*((GLuint *) ctx->Color.ColorMask) == 0)
-               break;
-            _mesa_mask_rgba_span( ctx, n, x, y, rgbaTmp );
-         }
-
-         (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, 
-				       (CONST GLubyte (*)[4]) rgbaTmp, mask );
-         if (ctx->RasterMask & ALPHABUF_BIT) {
-            _mesa_write_alpha_span( ctx, n, x, y, 
-                                    (CONST GLubyte (*)[4])rgbaTmp, mask );
-         }
-      }
-   }
-
-   /* restore default dest buffer */
-   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
-}
-
-
-
-void gl_write_rgba_span( GLcontext *ctx,
-                         GLuint n, GLint x, GLint y, const GLdepth z[],
-                         GLubyte rgbaIn[][4],
-                         GLenum primitive )
-{
-   const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT |
-                          LOGIC_OP_BIT | TEXTURE_BIT;
-   GLubyte mask[MAX_WIDTH];
-   GLboolean write_all = GL_TRUE;
-   GLubyte rgbaBackup[MAX_WIDTH][4];
-   GLubyte (*rgba)[4];
-   const GLubyte *Null = 0;
-
-   /* init mask to 1's (all pixels are to be written) */
-   MEMSET(mask, 1, n);
-
-   if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
-      if (clip_span( ctx,n,x,y,mask)==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   if ((primitive==GL_BITMAP && (ctx->RasterMask & modBits))
-       || (ctx->RasterMask & MULTI_DRAW_BIT)) {
-      /* must make a copy of the colors since they may be modified */
-      MEMCPY( rgbaBackup, rgbaIn, 4 * n * sizeof(GLubyte) );
-      rgba = rgbaBackup;
-   }
-   else {
-      rgba = rgbaIn;
-   }
-
-   /* Per-pixel fog */
-   if (ctx->Fog.Enabled && (primitive==GL_BITMAP || ctx->FogMode==FOG_FRAGMENT)) {
-      _mesa_fog_rgba_pixels( ctx, n, z, rgba );
-   }
-
-   /* Do the scissor test */
-   if (ctx->Scissor.Enabled) {
-      if (gl_scissor_span( ctx, n, x, y, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   /* Polygon Stippling */
-   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
-      stipple_polygon_span( ctx, n, x, y, mask );
-      write_all = GL_FALSE;
-   }
-
-   /* Do the alpha test */
-   if (ctx->Color.AlphaEnabled) {
-      if (_mesa_alpha_test( ctx, n, (CONST GLubyte (*)[4]) rgba, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   if (ctx->Stencil.Enabled) {
-      /* first stencil test */
-      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-   else if (ctx->Depth.Test) {
-      /* regular depth testing */
-      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
-      if (m==0) {
-         return;
-      }
-      if (m<n) {
-         write_all = GL_FALSE;
-      }
-   }
-
-   /* if we get here, something passed the depth test */
-   ctx->OcclusionResult = GL_TRUE;
-
-   if (ctx->RasterMask & MULTI_DRAW_BIT) {
-      multi_write_rgba_span( ctx, n, x, y, (CONST GLubyte (*)[4]) rgba, mask );
-   }
-   else {
-      /* normal: write to exactly one buffer */
-      /* logic op or blending */
-      if (ctx->Color.SWLogicOpEnabled) {
-         _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
-      }
-      else if (ctx->Color.BlendEnabled) {
-         _mesa_blend_span( ctx, n, x, y, rgba, mask );
-      }
-
-      /* Color component masking */
-      if (ctx->Color.SWmasking) {
-         if (*((GLuint *) ctx->Color.ColorMask) == 0)
-            return;
-         _mesa_mask_rgba_span( ctx, n, x, y, rgba );
-      }
-
-      /* write pixels */
-      (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, 
-				    (CONST GLubyte (*)[4]) rgba, 
-				    write_all ? Null : mask );
-
-      if (ctx->RasterMask & ALPHABUF_BIT) {
-         _mesa_write_alpha_span( ctx, n, x, y, 
-                                 (CONST GLubyte (*)[4]) rgba, 
-                                 write_all ? Null : mask );
-      }
-
-   }
-}
-
-
-
-/*
- * Write a horizontal span of color pixels to the frame buffer.
- * The color is initially constant for the whole span.
- * Alpha-testing, stenciling, depth-testing, and blending are done as needed.
- * Input:  n - number of pixels in the span
- *         x, y - location of leftmost pixel in the span
- *         z - array of [n] z-values
- *         r, g, b, a - the color of the pixels
- *         primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
- */
-void gl_write_monocolor_span( GLcontext *ctx,
-                              GLuint n, GLint x, GLint y, const GLdepth z[],
-			      const GLubyte color[4],
-                              GLenum primitive )
-{
-   GLuint i;
-   GLubyte mask[MAX_WIDTH];
-   GLboolean write_all = GL_TRUE;
-   GLubyte rgba[MAX_WIDTH][4];
-   const GLubyte *Null = 0;
-
-   /* init mask to 1's (all pixels are to be written) */
-   MEMSET(mask, 1, n);
-
-   if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
-      if (clip_span( ctx,n,x,y,mask)==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   /* Do the scissor test */
-   if (ctx->Scissor.Enabled) {
-      if (gl_scissor_span( ctx, n, x, y, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   /* Polygon Stippling */
-   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
-      stipple_polygon_span( ctx, n, x, y, mask );
-      write_all = GL_FALSE;
-   }
-
-   /* Do the alpha test */
-   if (ctx->Color.AlphaEnabled) {
-      for (i=0;i<n;i++) {
-         rgba[i][ACOMP] = color[ACOMP];
-      }
-      if (_mesa_alpha_test( ctx, n, (CONST GLubyte (*)[4])rgba, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   if (ctx->Stencil.Enabled) {
-      /* first stencil test */
-      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-   else if (ctx->Depth.Test) {
-      /* regular depth testing */
-      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
-      if (m==0) {
-         return;
-      }
-      if (m<n) {
-         write_all = GL_FALSE;
-      }
-   }
-
-   /* if we get here, something passed the depth test */
-   ctx->OcclusionResult = GL_TRUE;
-
-   if (ctx->Color.DrawBuffer == GL_NONE) {
-      /* write no pixels */
-      return;
-   }
-
-   if (ctx->Color.SWLogicOpEnabled || ctx->Color.SWmasking ||
-       (ctx->RasterMask & (BLEND_BIT | FOG_BIT))) {
-      /* assign same color to each pixel */
-      for (i=0;i<n;i++) {
-	 if (mask[i]) {
-            COPY_4UBV(rgba[i], color);
-	 }
-      }
-
-      /* Per-pixel fog */
-      if (ctx->Fog.Enabled &&
-          (primitive==GL_BITMAP || ctx->FogMode==FOG_FRAGMENT)) {
-         _mesa_fog_rgba_pixels( ctx, n, z, rgba );
-      }
-
-      if (ctx->RasterMask & MULTI_DRAW_BIT) {
-         multi_write_rgba_span( ctx, n, x, y,
-                                (CONST GLubyte (*)[4]) rgba, mask );
-      }
-      else {
-         /* normal: write to exactly one buffer */
-         if (ctx->Color.SWLogicOpEnabled) {
-            _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
-         }
-         else if (ctx->Color.BlendEnabled) {
-            _mesa_blend_span( ctx, n, x, y, rgba, mask );
-         }
-
-         /* Color component masking */
-         if (ctx->Color.SWmasking) {
-            if (*((GLuint *) ctx->Color.ColorMask) == 0)
-               return;
-            _mesa_mask_rgba_span( ctx, n, x, y, rgba );
-         }
-
-         /* write pixels */
-         (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, 
-				       (CONST GLubyte (*)[4]) rgba, 
-				       write_all ? Null : mask );
-         if (ctx->RasterMask & ALPHABUF_BIT) {
-            _mesa_write_alpha_span( ctx, n, x, y, 
-                                    (CONST GLubyte (*)[4]) rgba, 
-                                    write_all ? Null : mask );
-         }
-      }
-   }
-   else {
-      /* same color for all pixels */
-      ASSERT(!ctx->Color.BlendEnabled);
-      ASSERT(!ctx->Color.SWLogicOpEnabled);
-      ASSERT(!ctx->Color.SWmasking);
-
-      if (ctx->RasterMask & MULTI_DRAW_BIT) {
-         for (i=0;i<n;i++) {
-            if (mask[i]) {
-               COPY_4UBV(rgba[i], color);
-            }
-         }
-         multi_write_rgba_span( ctx, n, x, y, 
-				(CONST GLubyte (*)[4]) rgba, mask );
-      }
-      else {
-         (*ctx->Driver.WriteMonoRGBASpan)( ctx, n, x, y, mask );
-         if (ctx->RasterMask & ALPHABUF_BIT) {
-            _mesa_write_mono_alpha_span( ctx, n, x, y, (GLubyte) color[ACOMP],
-                                         write_all ? Null : mask );
-         }
-      }
-   }
-}
-
-
-
-/*
- * Add specular color to base color.  This is used only when
- * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
- */
-static void add_colors(GLuint n, GLubyte rgba[][4], CONST GLubyte specular[][4] )
-{
-   GLuint i;
-   for (i=0; i<n; i++) {
-      GLint r = rgba[i][RCOMP] + specular[i][RCOMP];
-      GLint g = rgba[i][GCOMP] + specular[i][GCOMP];
-      GLint b = rgba[i][BCOMP] + specular[i][BCOMP];
-      rgba[i][RCOMP] = (GLubyte) MIN2(r, 255);
-      rgba[i][GCOMP] = (GLubyte) MIN2(g, 255);
-      rgba[i][BCOMP] = (GLubyte) MIN2(b, 255);
-   }
-}
-
-
-/*
- * Write a horizontal span of textured pixels to the frame buffer.
- * The color of each pixel is different.
- * Alpha-testing, stenciling, depth-testing, and blending are done
- * as needed.
- * Input:  n - number of pixels in the span
- *         x, y - location of leftmost pixel in the span
- *         z - array of [n] z-values
- *         s, t - array of (s,t) texture coordinates for each pixel
- *         lambda - array of texture lambda values
- *         rgba - array of [n] color components
- *         primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
- */
-void gl_write_texture_span( GLcontext *ctx,
-                            GLuint n, GLint x, GLint y, const GLdepth z[],
-			    const GLfloat s[], const GLfloat t[],
-                            const GLfloat u[], GLfloat lambda[],
-			    GLubyte rgbaIn[][4], CONST GLubyte spec[][4],
-			    GLenum primitive )
-{
-   GLubyte mask[MAX_WIDTH];
-   GLboolean write_all = GL_TRUE;
-   GLubyte rgbaBackup[MAX_WIDTH][4];
-   GLubyte (*rgba)[4];   /* points to either rgbaIn or rgbaBackup */
-   const GLubyte *Null = 0;
-
-   /* init mask to 1's (all pixels are to be written) */
-   MEMSET(mask, 1, n);
-
-   if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
-      if (clip_span(ctx, n, x, y, mask)==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-
-   if (primitive==GL_BITMAP || (ctx->RasterMask & MULTI_DRAW_BIT)) {
-      /* must make a copy of the colors since they may be modified */
-      MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLubyte));
-      rgba = rgbaBackup;
-   }
-   else {
-      rgba = rgbaIn;
-   }
-
-   /* Texture */
-   ASSERT(ctx->Texture.ReallyEnabled);
-   gl_texture_pixels( ctx, 0, n, s, t, u, lambda, rgba, rgba );
-
-   /* Add base and specular colors */
-   if (spec && ctx->Light.Enabled
-       && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
-      add_colors( n, rgba, spec );   /* rgba = rgba + spec */
-
-   /* Per-pixel fog */
-   if (ctx->Fog.Enabled && (primitive==GL_BITMAP || ctx->FogMode==FOG_FRAGMENT)) {
-      _mesa_fog_rgba_pixels( ctx, n, z, rgba );
-   }
-
-   /* Do the scissor test */
-   if (ctx->Scissor.Enabled) {
-      if (gl_scissor_span( ctx, n, x, y, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   /* Polygon Stippling */
-   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
-      stipple_polygon_span( ctx, n, x, y, mask );
-      write_all = GL_FALSE;
-   }
-
-   /* Do the alpha test */
-   if (ctx->Color.AlphaEnabled) {
-      if (_mesa_alpha_test( ctx, n, (CONST GLubyte (*)[4]) rgba, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   if (ctx->Stencil.Enabled) {
-      /* first stencil test */
-      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-   else if (ctx->Depth.Test) {
-      /* regular depth testing */
-      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
-      if (m==0) {
-         return;
-      }
-      if (m<n) {
-         write_all = GL_FALSE;
-      }
-   }
-
-   /* if we get here, something passed the depth test */
-   ctx->OcclusionResult = GL_TRUE;
-
-   if (ctx->RasterMask & MULTI_DRAW_BIT) {
-      multi_write_rgba_span( ctx, n, x, y, (CONST GLubyte (*)[4]) rgba, mask );
-   }
-   else {
-      /* normal: write to exactly one buffer */
-      if (ctx->Color.SWLogicOpEnabled) {
-         _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
-      }
-      else  if (ctx->Color.BlendEnabled) {
-         _mesa_blend_span( ctx, n, x, y, rgba, mask );
-      }
-      if (ctx->Color.SWmasking) {
-         if (*((GLuint *) ctx->Color.ColorMask) == 0)
-            return;
-         _mesa_mask_rgba_span( ctx, n, x, y, rgba );
-      }
-
-      (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (CONST GLubyte (*)[4])rgba,
-				    write_all ? Null : mask );
-      if (ctx->RasterMask & ALPHABUF_BIT) {
-         _mesa_write_alpha_span( ctx, n, x, y, (CONST GLubyte (*)[4]) rgba, 
-                                 write_all ? Null : mask );
-      }
-   }
-}
-
-
-
-/*
- * As above but perform multiple stages of texture application.
- * Input:  texUnits - number of texture units to apply
- */
-void
-gl_write_multitexture_span( GLcontext *ctx, GLuint texUnits,
-                            GLuint n, GLint x, GLint y,
-                            const GLdepth z[],
-                            CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                            CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                            CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                            GLfloat lambda[][MAX_WIDTH],
-                            GLubyte rgbaIn[MAX_TEXTURE_UNITS][4],
-                            CONST GLubyte spec[MAX_TEXTURE_UNITS][4],
-                            GLenum primitive )
-{
-   GLubyte mask[MAX_WIDTH];
-   GLboolean write_all = GL_TRUE;
-   GLubyte rgbaBackup[MAX_WIDTH][4];
-   GLubyte (*rgba)[4];   /* points to either rgbaIn or rgbaBackup */
-   GLuint i;
-   const GLubyte *Null = 0;
-
-   /* init mask to 1's (all pixels are to be written) */
-   MEMSET(mask, 1, n);
-
-   if ((ctx->RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
-      if (clip_span(ctx, n, x, y, mask)==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-
-   if (primitive==GL_BITMAP || (ctx->RasterMask & MULTI_DRAW_BIT)
-                            || texUnits > 1) {
-      /* must make a copy of the colors since they may be modified */
-      MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLubyte));
-      rgba = rgbaBackup;
-   }
-   else {
-      rgba = rgbaIn;
-   }
-
-   /* Texture */
-   ASSERT(ctx->Texture.ReallyEnabled);
-   ASSERT(texUnits <= MAX_TEXTURE_UNITS);
-   for (i=0;i<texUnits;i++)
-      gl_texture_pixels( ctx, i, n, s[i], t[i], u[i], lambda[i], rgbaIn, rgba );
-
-   /* Add base and specular colors */
-   if (spec && ctx->Light.Enabled
-       && ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
-      add_colors( n, rgba, spec );   /* rgba = rgba + spec */
-
-   /* Per-pixel fog */
-   if (ctx->Fog.Enabled && (primitive==GL_BITMAP || ctx->FogMode==FOG_FRAGMENT)) {
-      _mesa_fog_rgba_pixels( ctx, n, z, rgba );
-   }
-
-   /* Do the scissor test */
-   if (ctx->Scissor.Enabled) {
-      if (gl_scissor_span( ctx, n, x, y, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   /* Polygon Stippling */
-   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
-      stipple_polygon_span( ctx, n, x, y, mask );
-      write_all = GL_FALSE;
-   }
-
-   /* Do the alpha test */
-   if (ctx->Color.AlphaEnabled) {
-      if (_mesa_alpha_test( ctx, n, (CONST GLubyte (*)[4])rgba, mask )==0) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-
-   if (ctx->Stencil.Enabled) {
-      /* first stencil test */
-      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
-	 return;
-      }
-      write_all = GL_FALSE;
-   }
-   else if (ctx->Depth.Test) {
-      /* regular depth testing */
-      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
-      if (m==0) {
-         return;
-      }
-      if (m<n) {
-         write_all = GL_FALSE;
-      }
-   }
-
-   /* if we get here, something passed the depth test */
-   ctx->OcclusionResult = GL_TRUE;
-
-   if (ctx->RasterMask & MULTI_DRAW_BIT) {
-      multi_write_rgba_span( ctx, n, x, y, (CONST GLubyte (*)[4]) rgba, mask );
-   }
-   else {
-      /* normal: write to exactly one buffer */
-
-      if (ctx->Color.SWLogicOpEnabled) {
-         _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
-      }
-      else  if (ctx->Color.BlendEnabled) {
-         _mesa_blend_span( ctx, n, x, y, rgba, mask );
-      }
-      if (ctx->Color.SWmasking) {
-         if (*((GLuint *) ctx->Color.ColorMask) == 0)
-            return;
-         _mesa_mask_rgba_span( ctx, n, x, y, rgba );
-      }
-
-      (*ctx->Driver.WriteRGBASpan)( ctx, n, x, y, (CONST GLubyte (*)[4])rgba, write_all ? Null : mask );
-      if (ctx->RasterMask & ALPHABUF_BIT) {
-         _mesa_write_alpha_span( ctx, n, x, y, (CONST GLubyte (*)[4])rgba,
-                                 write_all ? Null : mask );
-      }
-   }
-}
-
-
-
-/*
- * Read RGBA pixels from frame buffer.  Clipping will be done to prevent
- * reading ouside the buffer's boundaries.
- */
-void gl_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
-                        GLuint n, GLint x, GLint y,
-                        GLubyte rgba[][4] )
-{
-   if (y < 0 || y >= buffer->Height
-       || x + (GLint) n < 0 || x >= buffer->Width) {
-      /* completely above, below, or right */
-      /* XXX maybe leave undefined? */
-      BZERO(rgba, 4 * n * sizeof(GLubyte));
-   }
-   else {
-      GLint skip, length;
-      if (x < 0) {
-         /* left edge clippping */
-         skip = -x;
-         length = (GLint) n - skip;
-         if (length < 0) {
-            /* completely left of window */
-            return;
-         }
-         if (length > buffer->Width) {
-            length = buffer->Width;
-         }
-      }
-      else if ((GLint) (x + n) > buffer->Width) {
-         /* right edge clipping */
-         skip = 0;
-         length = buffer->Width - x;
-         if (length < 0) {
-            /* completely to right of window */
-            return;
-         }
-      }
-      else {
-         /* no clipping */
-         skip = 0;
-         length = (GLint) n;
-      }
-
-      (*ctx->Driver.ReadRGBASpan)( ctx, length, x + skip, y, rgba + skip );
-      if (buffer->UseSoftwareAlphaBuffers) {
-         _mesa_read_alpha_span( ctx, length, x + skip, y, rgba + skip );
-      }
-   }
-}
-
-
-
-
-/*
- * Read CI pixels from frame buffer.  Clipping will be done to prevent
- * reading ouside the buffer's boundaries.
- */
-void gl_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
-                         GLuint n, GLint x, GLint y, GLuint indx[] )
-{
-   if (y < 0 || y >= buffer->Height
-       || x + (GLint) n < 0 || x >= buffer->Width) {
-      /* completely above, below, or right */
-      BZERO(indx, n * sizeof(GLuint));
-   }
-   else {
-      GLint skip, length;
-      if (x < 0) {
-         /* left edge clippping */
-         skip = -x;
-         length = (GLint) n - skip;
-         if (length < 0) {
-            /* completely left of window */
-            return;
-         }
-         if (length > buffer->Width) {
-            length = buffer->Width;
-         }
-      }
-      else if ((GLint) (x + n) > buffer->Width) {
-         /* right edge clipping */
-         skip = 0;
-         length = buffer->Width - x;
-         if (length < 0) {
-            /* completely to right of window */
-            return;
-         }
-      }
-      else {
-         /* no clipping */
-         skip = 0;
-         length = (GLint) n;
-      }
-
-      (*ctx->Driver.ReadCI32Span)( ctx, length, skip + x, y, indx + skip );
-   }
-}
Index: xc/extras/Mesa/src/span.h
diff -u xc/extras/Mesa/src/span.h:1.4 xc/extras/Mesa/src/span.h:removed
--- xc/extras/Mesa/src/span.h:1.4	Thu Mar  2 11:07:13 2000
+++ xc/extras/Mesa/src/span.h	Thu Feb 27 12:15:42 2003
@@ -1,90 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef SPAN_H
-#define SPAN_H
-
-
-#include "types.h"
-
-
-extern void gl_write_index_span( GLcontext *ctx,
-                                 GLuint n, GLint x, GLint y, const GLdepth z[],
-				 GLuint index[], GLenum primitive );
-
-
-extern void gl_write_monoindex_span( GLcontext *ctx,
-                                     GLuint n, GLint x, GLint y,
-                                     const GLdepth z[],
-				     GLuint index, GLenum primitive );
-
-
-extern void gl_write_rgba_span( GLcontext *ctx,
-                                GLuint n, GLint x, GLint y, const GLdepth z[],
-                                GLubyte rgba[][4], GLenum primitive );
-
-
-extern void gl_write_monocolor_span( GLcontext *ctx,
-                                     GLuint n, GLint x, GLint y,
-                                     const GLdepth z[], const GLubyte color[4],
-                                     GLenum primitive );
-
-
-extern void gl_write_texture_span( GLcontext *ctx,
-                                   GLuint n, GLint x, GLint y,
-                                   const GLdepth z[],
-				   const GLfloat s[], const GLfloat t[],
-                                   const GLfloat u[], GLfloat lambda[],
-				   GLubyte rgba[][4], CONST GLubyte spec[][4],
-                                   GLenum primitive );
-
-
-extern void
-gl_write_multitexture_span( GLcontext *ctx, GLuint texSets,
-                            GLuint n, GLint x, GLint y,
-                            const GLdepth z[],
-                            CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                            CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                            CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                            GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                            GLubyte rgba[][4],
-                            CONST GLubyte spec[][4],
-                            GLenum primitive );
-
-
-extern void gl_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
-                               GLuint n, GLint x, GLint y,
-                               GLubyte rgba[][4] );
-
-
-extern void gl_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
-                                GLuint n, GLint x, GLint y, GLuint indx[] );
-
-
-#endif
Index: xc/extras/Mesa/src/stages.c
diff -u xc/extras/Mesa/src/stages.c:1.9 xc/extras/Mesa/src/stages.c:removed
--- xc/extras/Mesa/src/stages.c:1.9	Thu Nov 30 10:39:04 2000
+++ xc/extras/Mesa/src/stages.c	Thu Feb 27 12:15:42 2003
@@ -1,896 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "bbox.h"
-#include "clip.h"
-#include "context.h"
-#include "cva.h"
-#include "fog.h"
-#include "light.h"
-#include "mmath.h"
-#include "pipeline.h"
-#include "shade.h"
-#include "stages.h"
-#include "translate.h"
-#include "types.h"
-#include "vbcull.h"
-#include "vbindirect.h"
-#include "vbrender.h"
-#include "vbxform.h"
-#include "xform.h"
-#endif
-
-
-static GLmatrix gl_identity_mat;
-
-
-/*
- * One-time init function called from one_time_init() in context.c
- */
-void gl_init_vbxform( void )
-{
-   gl_matrix_ctr( &gl_identity_mat );
-}
-
-
-
-/* KW: Even if all the vertices are clipped or culled, still need to
- *     execute the material changes.
- *
- *     TODO: Do this backwards, from count to start.
- */
-void gl_update_materials( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint orflag = VB->OrFlag;
-
-   if (orflag & VERT_MATERIAL)
-   {
-      GLuint i;
-      GLuint *flag = VB->Flag, count = VB->Count;
-      struct gl_material (*new_material)[2] = VB->Material;
-      GLuint *new_material_mask = VB->MaterialMask;
-
-      /* This code never reached in cva.
-       */
-      for ( i = VB->Start ; i <= count ; i++ )
-	 if ( flag[i] & VERT_MATERIAL )
-	    gl_update_material( ctx, new_material[i], new_material_mask[i] );
-   }
-
-   if ((orflag & VERT_RGBA) && ctx->Light.ColorMaterialEnabled)
-      gl_update_color_material( ctx, ctx->Current.ByteColor );
-}
-
-
-void gl_clean_color( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-#ifdef VAO
-   struct gl_client_array *client_data = &ctx->Array.Current->Color;
-#else
-   struct gl_client_array *client_data = &ctx->Array.Color;
-#endif
-   GLvector4ub *col;
-
-#ifdef VAO
-   if (!(ctx->Array.Current->Summary & VERT_RGBA))
-#else
-   if (!(ctx->Array.Summary & VERT_RGBA))
-#endif
-      client_data = &ctx->Fallback.Color;
-
-   if (VB->Type == VB_CVA_PRECALC) {
-      col = VB->ColorPtr;
-      col->data = ctx->CVA.store.Color;
-   } else {
-      VB->ColorPtr = VB->Color[0] = col = &VB->IM->v.Color;
-   }
-
-   gl_trans_4ub_tab[4][TYPE_IDX(GL_UNSIGNED_BYTE)]( col->data, client_data,
-						    VB->Start, VB->Count );
-
-   col->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-   col->stride = 4 * sizeof(GLubyte);
-}
-
-static void clean_index( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-#ifdef VAO
-   struct gl_client_array *client_data = &ctx->Array.Current->Index;
-#else
-   struct gl_client_array *client_data = &ctx->Array.Index;
-#endif
-   GLvector1ui *index;
-
-#ifdef VAO
-   if (!(ctx->Array.Current->Summary & VERT_INDEX))
-#else
-   if (!(ctx->Array.Summary & VERT_INDEX))
-#endif
-      client_data = &ctx->Fallback.Color;
-
-   if (VB->Type == VB_CVA_PRECALC) {
-      index = VB->IndexPtr;
-      index->data =  ctx->CVA.store.Index;
-   } else {
-      VB->IndexPtr = index = &VB->IM->v.Index;
-   }
-
-   gl_trans_1ui_tab[TYPE_IDX(GL_UNSIGNED_INT)]( index->data, client_data,
-						VB->Start, VB->Count );
-
-   index->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-   index->stride = sizeof(GLuint);
-}
-
-
-static void clean_edgeflag( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-#ifdef VAO
-   struct gl_client_array *client_data = &ctx->Array.Current->EdgeFlag;
-#else
-   struct gl_client_array *client_data = &ctx->Array.EdgeFlag;
-#endif
-   GLvector1ub *edge;
-
-#ifdef VAO
-   if (!(ctx->Array.Current->Summary & VERT_EDGE))
-#else
-   if (!(ctx->Array.Summary & VERT_EDGE))
-#endif
-      client_data = &ctx->Fallback.EdgeFlag;
-
-   if (VB->Type == VB_CVA_PRECALC) {
-      edge = VB->EdgeFlagPtr;
-      edge->data = ctx->CVA.store.EdgeFlag;
-   } else {
-      VB->EdgeFlagPtr = edge = &VB->IM->v.EdgeFlag;
-   }
-
-   gl_trans_1ub_tab[TYPE_IDX(GL_UNSIGNED_BYTE)]( edge->data, client_data,
-						 VB->Start, VB->Count );
-
-   edge->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-   edge->stride = sizeof(GLubyte);
-}
-
-
-static void clean_texcoord( struct vertex_buffer *VB, GLuint i )
-{
-   GLcontext *ctx = VB->ctx;
-#ifdef VAO
-   struct gl_client_array *client_data = &ctx->Array.Current->TexCoord[i];
-#else
-   struct gl_client_array *client_data = &ctx->Array.TexCoord[i];
-#endif
-   GLvector4f *tc;
-   GLuint flag = PIPE_TEX(i);
-
-#ifdef VAO
-   if (!(ctx->Array.Current->Summary & flag))
-#else
-   if (!(ctx->Array.Summary & flag))
-#endif
-      client_data = &ctx->Fallback.TexCoord[i];
-
-   if (VB->Type == VB_CVA_PRECALC) {
-      tc = VB->TexCoordPtr[i];
-      tc->data = ctx->CVA.store.TexCoord[i];
-   } else {
-      VB->TexCoordPtr[i] = tc = &VB->IM->v.TexCoord[i];
-   }
-
-   gl_trans_4f_tab[tc->size][TYPE_IDX(GL_FLOAT)]( tc->data, client_data,
-						  VB->Start, VB->Count );
-
-   tc->flags = VEC_WRITABLE|VEC_GOOD_STRIDE;
-   tc->stride = 4 * sizeof(GLfloat);
-}
-
-static void clean_unprojected( struct vertex_buffer *VB )
-{
-   (void) Transform( &VB->Eye,
-                     &gl_identity_mat,
-                     VB->Unprojected,
-                     0,
-                     0);
-   VB->Unprojected = &VB->Eye;
-}
-
-static void clean_clip( struct vertex_buffer *VB )
-{
-   (void) Transform( &VB->Clip,
-                     &gl_identity_mat,
-                     VB->ClipPtr,
-                     VB->ClipMask + VB->Start,
-                     VB->CullFlag[0]);
-   VB->ClipPtr = &VB->Clip;
-}
-
-
-
-void gl_import_client_data( struct vertex_buffer *VB,
-			    GLuint required,
-			    GLuint vec_flags )
-{
-   if ((required & VERT_RGBA) && !(VB->ColorPtr->flags & vec_flags))
-      gl_clean_color(VB);
-
-   if ((required & VERT_INDEX) && !(VB->IndexPtr->flags & vec_flags))
-      clean_index(VB);
-
-   if ((required & VERT_TEX0_ANY) && !(VB->TexCoordPtr[0]->flags & vec_flags))
-      clean_texcoord(VB, 0);
-
-   if ((required & VERT_TEX1_ANY) && !(VB->TexCoordPtr[1]->flags & vec_flags))
-      clean_texcoord(VB, 1);
-
-   if ((required & VERT_EDGE) && !(VB->EdgeFlagPtr->flags & vec_flags))
-      clean_edgeflag(VB);
-
-   if (!(VB->ClipPtr->flags & vec_flags))
-      clean_clip(VB);
-}
-
-
-
-#if 0
-/* Figure this is too rare to update via UpdateState, so give it a
- * flag of its own.
- */
-static void gl_calculate_model_project_win_matrix( GLcontext *ctx )
-{
-    gl_matrix_mul( &ctx->ModelProjectWinMatrix,
-		   &ctx->Viewport.WindowMap,
-		   &ctx->ModelProjectMatrix );
-
-   gl_matrix_analyze( &ctx->ModelProjectWinMatrix );
-   ctx->ModelProjectWinMatrixUptodate = GL_TRUE;
-}
-#endif
-
-
-
-#if 0
-static void bound_cull_vb( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   VB->Projected = &VB->Win;
-   VB->ClipPtr = &VB->Clip;
-   VB->Culled = 1;
-
-   gl_dont_cull_vb( VB );
-
-   {
-      GLuint start = 3 - VB->CopyCount;
-      GLuint dst;
-      GLuint *copy = VB->Copy;
-      GLmatrix *mat = &ctx->ModelProjectMatrix;
-
-      for (dst = start ; dst < VB->Start ; dst++) {
-	 GLfloat *src = VEC_ELT(VB->ObjPtr, GLfloat, copy[dst]);
-	 GLfloat *clip = VB->Clip.data[copy[dst]];
-	 gl_transform_point_sz( clip, mat->m, src, VB->ObjPtr->size );
-	 {
-	    const GLfloat cw = clip[3];
-	    const GLfloat cx = clip[0];
-	    const GLfloat cy = clip[1];
-	    const GLfloat cz = clip[2];
-	    GLuint mask = 0;
-	    if (cx >  cw) mask |= CLIP_RIGHT_BIT;
-	    if (cx < -cw) mask |= CLIP_LEFT_BIT;
-	    if (cy >  cw) mask |= CLIP_TOP_BIT;
-	    if (cy < -cw) mask |= CLIP_BOTTOM_BIT;
-	    if (cz >  cw) mask |= CLIP_FAR_BIT;
-	    if (cz < -cw) mask |= CLIP_NEAR_BIT;
-	    VB->ClipMask[copy[dst]] = mask;
-	 }
-      }
-   }
-}
-#endif
-
-
-
-
-static void do_vertex_pipeline( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLmatrix *proj_mat = ctx->vb_proj_matrix;
-   GLvector4f *proj_dest = &VB->Clip;
-   GLboolean need_window_transform = (1 || ctx->DoViewportMapping);
-   GLuint copycount = VB->CopyCount;
-
-   /* Eye transform
-    */
-   VB->Unprojected = VB->ObjPtr;
-
-   if (ctx->NeedEyeCoords && ctx->ModelView.type != MATRIX_IDENTITY) {
-      VB->Unprojected = TransformRaw( &VB->Eye, &ctx->ModelView, VB->ObjPtr );
-   }
-
-   VB->EyePtr = VB->Unprojected;
-
-
-   /* Clip transform.
-    */
-   VB->ClipPtr = VB->Unprojected;
-
-   if (proj_mat->type != MATRIX_IDENTITY ||
-       ((ctx->IndirectTriangles & DD_ANY_CULL) &&
-	VB->Unprojected->stride != 4*sizeof(GLfloat)))
-   {
-      VB->ClipPtr = TransformRaw(proj_dest, proj_mat, VB->Unprojected );
-   }
-
-
-   /* Cliptest and/or perspective divide.
-    */
-
-   VB->Projected = gl_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
-                                                   &VB->Win,
-                                                   VB->ClipMask + VB->Start,
-                                                   &VB->ClipOrMask,
-                                                   &VB->ClipAndMask );
-   if (VB->ClipOrMask) {
-      VB->CullFlag[1] = (GLubyte) (VB->ClipOrMask & ctx->AllowVertexCull);
-      VB->CullMode |= CLIP_MASK_ACTIVE;
-   }
-
-   if (VB->ClipAndMask) {
-      if (MESA_VERBOSE&VERBOSE_CULL)
-	 fprintf(stderr, "Culled in clip\n");
-
-      VB->Culled = 1;
-      gl_dont_cull_vb( VB );
-      gl_update_materials(VB);
-      return;
-   }
-
-
-   /* User cliptest.
-    */
-   if (ctx->Transform.AnyClip) {
-      gl_user_cliptest( VB );
-      if (VB->Culled) {
-
-	 if (MESA_VERBOSE&VERBOSE_CULL)
-	    fprintf(stderr, "Culled in userclip\n");
-
-	 gl_dont_cull_vb( VB );
-	 gl_update_materials(VB);
-	 return;
-      }
-   }
-
-
-   /* Vertex culling - not for cva precalc.
-    */
-   if (VB->IM) {
-      if (ctx->IndirectTriangles & DD_ANY_CULL)
-      {
-	 GLuint cullcount = gl_cull_vb( VB );
-	 
-	 if (MESA_VERBOSE&VERBOSE_CULL)
-	    fprintf(stderr, "culled %u of %u vertices\n", cullcount, VB->Count);
-
-	 if (cullcount == VB->Count) {
-	    VB->Culled = 1;
-	    gl_update_materials(VB);
-	    return;
-	 }
-	 if (cullcount || (ctx->IndirectTriangles & DD_LIGHTING_CULL))
-	    VB->CullMode |= CULL_MASK_ACTIVE;
-      }
-      else 
-      {
-	 if (MESA_VERBOSE&VERBOSE_CULL)
-	    fprintf(stderr, "culling not active\n");
-
-	 gl_dont_cull_vb( VB );
-      }
-   }
-
-
-   /* Window transform.
-    */
-   if (need_window_transform) {
-
-      if (VB->Start != VB->CopyStart) {
-         VB->Projected->start = (GLfloat *)( (GLubyte *)VB->Projected->start 
-                        - (copycount*VB->Projected->stride) );
-         VB->Projected->count += copycount;
-
-	 VB->Win.start = (GLfloat *)VB->Win.data[VB->CopyStart];
-      }
-
-      (void) Transform( &VB->Win,
-			&ctx->Viewport.WindowMap,
-			VB->Projected,
-			VB->ClipMask + VB->CopyStart,
-			VB->CullFlag[1]);
-
-      if (VB->Win.size == 2) {
-	 gl_vector4f_clean_elem(&VB->Win, VB->Count, 2);
-      }
-   }
-}
-
-
-
-
-static void do_normal_transform( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint tmp = 0;
-
-   if (VB->Type == VB_CVA_PRECALC)
-      VB->NormalPtr = &ctx->CVA.v.Normal;
-
-
-   if (VB->CullMode & (COMPACTED_NORMALS|CULL_MASK_ACTIVE)) {
-      tmp = 1;
-      gl_make_normal_cullmask( VB );
-   }
-
-   if (ctx->NormalTransform) {
-      (ctx->NormalTransform[tmp])(&ctx->ModelView,
-				  ctx->vb_rescale_factor,
-				  VB->NormalPtr,
-				  (VB->NormalLengthPtr ?
-				   VB->NormalLengthPtr + VB->Start : 0),
-				  VB->NormCullStart,
-				  VB->store.Normal);
-
-      VB->NormalPtr = VB->store.Normal;
-   }
-}
-
-
-
-static void do_lighting( struct vertex_buffer *VB )
-{
-   GLubyte flags = (GLubyte) (VB->CullMode & 
-			      (CULL_MASK_ACTIVE|COMPACTED_NORMALS));
-
-   if ((flags&CULL_MASK_ACTIVE) && !VB->NormCullStart)
-      gl_make_normal_cullmask( VB );
-
-   /* Make sure we can talk about elements 0..2 in the vector we are
-    * lighting.
-    */
-   if (VB->Unprojected && VB->Unprojected->size == 2) {
-      if (VB->Unprojected->flags & VEC_WRITABLE)
-	 gl_vector4f_clean_elem(VB->Unprojected, VB->Count, 2);
-      else 
-	 clean_unprojected( VB );
-   }
-
-   VB->ctx->shade_func_tab[flags]( VB );
-}
-
-
-
-static void do_update_materials( struct vertex_buffer *VB )
-{
-   gl_update_materials( VB );
-}
-
-
-static void do_texture_0( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-
-   if (ctx->Enabled & ENABLE_TEXGEN0) 
-      (ctx->Texture.Unit[0].func[VB->CullMode & 0x3])( VB, 0 );
-
-   if (ctx->Enabled & ENABLE_TEXMAT0)
-      VB->TexCoordPtr[0] = Transform( VB->store.TexCoord[0],
-				      &ctx->TextureMatrix[0],
-				      VB->TexCoordPtr[0],
-				      VB->ClipMask + VB->Start,
-				      VB->CullFlag[0]);
-}
-
-
-static void do_texture_1( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-
-   if (ctx->Enabled & ENABLE_TEXGEN1)
-      (ctx->Texture.Unit[1].func[VB->CullMode & 0x3])( VB, 1 );
-
-   if (ctx->Enabled & ENABLE_TEXMAT1)
-      VB->TexCoordPtr[1] = Transform( VB->store.TexCoord[1],
-				      &ctx->TextureMatrix[1],
-				      VB->TexCoordPtr[1],
-				      VB->ClipMask + VB->Start,
-				      VB->CullFlag[0]);
-}
-
-
-
-/* Done if we need to pull cva data into the immediate struct for some
- * further processing, or if there is no ctx->Driver.MergeAndRenderCVA()
- * implemented.  Inputs: ArrayElt - Outputs: ctx->Array.LockPrecalcOutputs
- *
- * Should only be done if a later stage needs LockPrecalcOutputs.  If
- */
-static void do_cva_merge( struct vertex_buffer *VB )
-{
-   struct gl_cva *cva = &VB->ctx->CVA;
-   gl_merge_cva( VB, cva->VB );
-}
-
-
-/* This is deprecated and should be overridden by any driver implementing CVA.
- */
-static void do_full_setup( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-
-   if (ctx->Driver.RasterSetup)
-      ctx->Driver.RasterSetup( VB, VB->CopyStart, VB->Count );
-}
-
-
-static void check_fog( GLcontext *ctx, struct gl_pipeline_stage *d )
-{
-   d->type = 0;
-
-   if (ctx->FogMode==FOG_VERTEX)
-   {
-      GLuint flags;
-
-      if (ctx->Visual->RGBAflag)
-	 flags = VERT_EYE|VERT_RGBA;
-      else
-	 flags = VERT_EYE|VERT_INDEX;
-
-      d->type = PIPE_IMMEDIATE|PIPE_PRECALC;
-      d->inputs = flags;
-      d->outputs = VERT_RGBA;
-   }
-}
-
-
-static void check_lighting( GLcontext *ctx, struct gl_pipeline_stage *d )
-{
-   d->type = 0;
-
-   if (ctx->Light.Enabled)
-   {
-      GLuint flags = VERT_NORM|VERT_MATERIAL;
-
-      if (ctx->Light.NeedVertices) {
-	 if (ctx->NeedEyeCoords)
-	    flags |= VERT_EYE;
-	 else
-	    flags |= VERT_OBJ_ANY;
-      }
-
-      if (ctx->Light.ColorMaterialEnabled) flags |= VERT_RGBA;
-
-      d->type = PIPE_IMMEDIATE|PIPE_PRECALC;
-      d->inputs = flags;
-      d->outputs = VERT_RGBA;
-   }
-}
-
-static void check_update_materials( GLcontext *ctx,
-				    struct gl_pipeline_stage *d )
-{
-   d->type = 0;
-
-   if (!ctx->Light.Enabled) {
-      GLuint flags = VERT_MATERIAL;
-      if (ctx->Light.ColorMaterialEnabled) flags |= VERT_RGBA;
-      d->type = PIPE_IMMEDIATE;
-      d->inputs = flags;
-      d->outputs = 0;
-   }
-}
-
-
-static void check_normal_transform( GLcontext *ctx,
-				    struct gl_pipeline_stage *d )
-{
-   d->type = 0;
-
-   if ( ctx->NormalTransform &&
-	(ctx->Enabled & (ENABLE_LIGHT|ENABLE_TEXGEN0|ENABLE_TEXGEN1)) )
-   {
-      d->type = PIPE_IMMEDIATE|PIPE_PRECALC;
-      d->inputs = VERT_NORM;
-      d->outputs = VERT_NORM;
-   }
-}
-
-
-
-static void check_texture( GLcontext *ctx, GLuint i,
-			   struct gl_pipeline_stage *d )
-{
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
-
-   d->type = 0;
-
-   if (ctx->Enabled & ((ENABLE_TEXGEN0|ENABLE_TEXMAT0)<<i))
-   {
-      GLuint texflag = PIPE_TEX(i);
-      GLuint flags = 0;
-
-      /* safe, but potentially inefficient
-       */
-      if (texUnit->GenFlags & TEXGEN_NEED_VERTICES) {
-	 if (0)
-	    flags |= VERT_OBJ_ANY;
-	 if (1)
-	    flags |= VERT_EYE;
-      }
-
-      if (texUnit->GenFlags & TEXGEN_NEED_NORMALS)
-	 flags |= VERT_NORM;
-
-      if (texUnit->Enabled & ~texUnit->TexGenEnabled)
-	 flags |= texflag;
-
-      d->type = PIPE_IMMEDIATE|PIPE_PRECALC;
-      d->inputs = flags;
-      d->outputs = texflag;
-   }
-}
-
-
-static void check_texture_0( GLcontext *ctx, struct gl_pipeline_stage *d )
-{
-   check_texture(ctx, 0, d);
-}
-
-static void check_texture_1( GLcontext *ctx, struct gl_pipeline_stage *d )
-{
-   check_texture(ctx, 1, d);
-}
-
-static void check_full_setup( GLcontext *ctx, struct gl_pipeline_stage *d )
-{
-   /* Even on drivers without a raster setup step, this is useful as a
-    * token to show you've got everything you need to render.  On
-    * those drivers, this stage is active, but a no-op.
-    */
-   d->type = PIPE_IMMEDIATE|PIPE_PRECALC;
-   d->inputs = ctx->RenderFlags;
-   d->outputs = VERT_SETUP_FULL;
-
-   if (ctx->IndirectTriangles & DD_SW_SETUP)
-      d->type = PIPE_IMMEDIATE;
-}
-
-static void check_indirect_render( GLcontext *ctx,
-				   struct gl_pipeline_stage *d )
-{
-   d->type = 0;
-
-   if ((ctx->IndirectTriangles & DD_SW_SETUP) == 0)
-   {
-      d->type = PIPE_IMMEDIATE;
-      d->inputs = VERT_SETUP_FULL | VERT_ELT | VERT_PRECALC_DATA;
-   }
-}
-
-static void check_noop( GLcontext *ctx, struct gl_pipeline_stage *d )
-{
-   (void) ctx; (void) d;
-}
-
-
-static void do_noop( struct vertex_buffer *VB )
-{
-   (void) VB;
-}
-
-
-/*
- */
-#define DYN_STATE 0,0,0
-
-CONST struct gl_pipeline_stage gl_default_pipeline[] = {
-   { "cva merge",
-     0,
-     PIPE_IMMEDIATE,
-     0,
-     0,				/* state change (recheck) */
-     0,				/* cva state change (recalc) */
-     0, 0,			/* cva forbidden */
-     0, VERT_PRECALC_DATA | VERT_ELT, 0,
-     check_noop,
-     do_cva_merge },
-
-   { "cva prepare arrays",
-     0,
-     PIPE_PRECALC,
-     0,
-     0,
-     NEW_CLIENT_STATE,		/* cva state change (recalc) */
-     0, 0,
-     PIPE_PRECALC, 0, 0,
-     check_noop,
-     gl_prepare_arrays_cva },
-
-   { "vertex pipeline",
-     PIPE_OP_VERT_XFORM,
-     PIPE_PRECALC|PIPE_IMMEDIATE,
-     0,
-     NEW_LIGHTING|NEW_TEXTURING|NEW_MODELVIEW|NEW_PROJECTION|NEW_USER_CLIP|NEW_VIEWPORT, /* state change */
-     NEW_MODELVIEW|NEW_PROJECTION|NEW_USER_CLIP|NEW_VIEWPORT, /* cva state change */
-     0, 0,
-     0, VERT_OBJ_ANY, VERT_EYE|VERT_WIN,
-     check_noop,
-     do_vertex_pipeline },
-
-   { "normal transform",
-     PIPE_OP_NORM_XFORM,
-     PIPE_PRECALC|PIPE_IMMEDIATE,
-     0,
-     NEW_LIGHTING|NEW_FOG|NEW_TEXTURING|NEW_NORMAL_TRANSFORM,	/* state change (recheck) */
-     NEW_NORMAL_TRANSFORM,	/* cva state change (recalc) */
-     0, 0,
-     DYN_STATE,
-     check_normal_transform,
-     do_normal_transform },
-
-   { "lighting",
-     PIPE_OP_LIGHT,
-     PIPE_PRECALC|PIPE_IMMEDIATE,
-     0,
-     NEW_LIGHTING,		 /* recheck */
-     NEW_LIGHTING|NEW_MODELVIEW, /* recalc */
-     0, VERT_MATERIAL,  	 /* I hate glMaterial() */
-     DYN_STATE,
-     check_lighting,
-     do_lighting },
-
-   { "update materials (no lighting)",
-     0,
-     PIPE_IMMEDIATE,
-     0,
-     NEW_LIGHTING,		/* recheck */
-     0,
-     0, 0,
-     DYN_STATE,
-     check_update_materials,
-     do_update_materials },
-
-   { "fog",
-     PIPE_OP_FOG,
-     PIPE_PRECALC|PIPE_IMMEDIATE,
-     0,
-     NEW_FOG,
-     NEW_LIGHTING|NEW_RASTER_OPS|NEW_FOG|NEW_MODELVIEW,
-     0, 0,
-     DYN_STATE,
-     check_fog,
-     _mesa_fog_vertices },
-
-   { "texture gen/transform 0",
-     PIPE_OP_TEX0,
-     PIPE_PRECALC|PIPE_IMMEDIATE,
-     0,
-     NEW_TEXTURING|NEW_TEXTURE_MATRIX|NEW_TEXTURE_ENABLE,
-     NEW_TEXTURING|NEW_TEXTURE_MATRIX|NEW_TEXTURE_ENABLE,
-     0, 0,
-     DYN_STATE,
-     check_texture_0,
-     do_texture_0 },
-
-   { "texture gen/transform 1",
-     PIPE_OP_TEX1,
-     PIPE_PRECALC|PIPE_IMMEDIATE,
-     0,
-     NEW_TEXTURING|NEW_TEXTURE_MATRIX|NEW_TEXTURE_ENABLE,
-     NEW_TEXTURING|NEW_TEXTURE_MATRIX|NEW_TEXTURE_ENABLE,
-     0, 0,
-     DYN_STATE,
-     check_texture_1,
-     do_texture_1 },
-
-
-   { "cva indirect render",	/* prior to setup -> require precalc'd setup */
-     PIPE_OP_RENDER,
-     PIPE_IMMEDIATE,
-     0,
-     NEW_LIGHTING|NEW_TEXTURING|NEW_RASTER_OPS,
-     0,
-     0, 0,
-     DYN_STATE,
-     check_indirect_render,
-     gl_render_vb_indirect },
-
-
-   { "full raster setup",	/* prepare for indirect and normal render */
-     PIPE_OP_RAST_SETUP_0|PIPE_OP_RAST_SETUP_1,
-     PIPE_PRECALC|PIPE_IMMEDIATE,
-     0,
-     NEW_LIGHTING|NEW_TEXTURING|NEW_RASTER_OPS|NEW_POLYGON|NEW_TEXTURE_ENV,
-     NEW_LIGHTING|NEW_TEXTURING|NEW_RASTER_OPS|NEW_POLYGON|NEW_TEXTURE_ENV,
-     0, 0,
-     DYN_STATE,
-     check_full_setup,
-     do_full_setup },
-
-   { "partial raster setup",	/* prepare for merge_and_render */
-     PIPE_OP_RAST_SETUP_0,
-     0,
-     0,
-     0,
-     0,
-     0, 0,
-     DYN_STATE,
-     check_noop,
-     do_noop },
-
-   { "cva merge & render",
-     PIPE_OP_RAST_SETUP_1|PIPE_OP_RENDER, /* rsetup1 if processing in elt? */
-     0,
-     0,
-     0,				/* state change (recheck)  */
-     0,				/* cva state change */
-     0,	0,			/* cva forbidden */
-     DYN_STATE,
-     check_noop,
-     do_noop },
-
-   { "render",
-     PIPE_OP_RENDER,
-     PIPE_IMMEDIATE,
-     0,
-     0,
-     0,
-     0, 0,
-     0, VERT_SETUP_FULL, 0,
-     check_noop,
-     gl_render_vb },
-
-   { "render elements",		/* essentially the same as indirect render */
-     PIPE_OP_RENDER,
-     PIPE_PRECALC,
-     0,
-     0,				/* render always triggered by data updates */
-     0,
-     0, 0,
-     0, VERT_SETUP_FULL|VERT_ELT, 0,
-     check_noop,
-     gl_render_elts },
-};
-
-CONST GLuint gl_default_nr_stages = Elements(gl_default_pipeline);
Index: xc/extras/Mesa/src/stages.h
diff -u xc/extras/Mesa/src/stages.h:1.3 xc/extras/Mesa/src/stages.h:removed
--- xc/extras/Mesa/src/stages.h:1.3	Tue Feb 15 02:12:35 2000
+++ xc/extras/Mesa/src/stages.h	Thu Feb 27 12:15:42 2003
@@ -1,39 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef STAGES_H
-#define STAGES_H
-
-extern CONST GLuint gl_default_nr_stages;
-extern CONST struct gl_pipeline_stage gl_default_pipeline[];
-
-extern void gl_init_vbxform( void );
-
-extern void gl_import_client_data( struct vertex_buffer *VB,
-				   GLuint required,
-				   GLuint vec_flags );
-
-#endif
Index: xc/extras/Mesa/src/state.c
diff -u xc/extras/Mesa/src/state.c:1.8 xc/extras/Mesa/src/state.c:1.13
--- xc/extras/Mesa/src/state.c:1.8	Sun Jan  7 20:07:14 2001
+++ xc/extras/Mesa/src/state.c	Wed Dec 11 16:13:20 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -25,8 +25,8 @@
 
 
 /*
- * This file initializes the immediate-mode dispatch table (which may
- * be state-dependant) and manages internal Mesa state update.
+ * This file manages recalculation of derived values in the
+ * __GLcontext.
  */
 
 
@@ -35,16 +35,14 @@
 #else
 #include "glheader.h"
 #include "accum.h"
-#include "alpha.h"
+#include "api_loopback.h"
 #include "attrib.h"
-#include "bitmap.h"
 #include "blend.h"
 #include "buffers.h"
 #include "clip.h"
 #include "colortab.h"
 #include "context.h"
-#include "copypix.h"
-#include "cva.h"
+#include "convolve.h"
 #include "depth.h"
 #include "dlist.h"
 #include "drawpix.h"
@@ -54,45 +52,33 @@
 #include "feedback.h"
 #include "fog.h"
 #include "hint.h"
-#include "imaging.h"
+#include "histogram.h"
 #include "light.h"
 #include "lines.h"
-#include "logic.h"
-#include "masking.h"
 #include "matrix.h"
 #include "mmath.h"
-#include "pipeline.h"
 #include "pixel.h"
-#include "pixeltex.h"
 #include "points.h"
 #include "polygon.h"
-#include "quads.h"
 #include "rastpos.h"
-#include "readpix.h"
-#include "rect.h"
-#include "scissor.h"
-#include "shade.h"
 #include "state.h"
 #include "stencil.h"
 #include "teximage.h"
 #include "texobj.h"
 #include "texstate.h"
-#include "texture.h"
-#include "triangle.h"
-#include "types.h"
+#include "mtypes.h"
 #include "varray.h"
-#include "vbfill.h"
-#include "vbrender.h"
-#include "winpos.h"
-#endif
 
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
+#endif
 
 
 static int
 generic_noop(void)
 {
 #ifdef DEBUG
-   gl_problem(NULL, "undefined function dispatch");
+   _mesa_problem(NULL, "undefined function dispatch");
 #endif
    return 0;
 }
@@ -113,9 +99,13 @@
 }
 
 
+
 /*
  * Initialize the given dispatch table with pointers to Mesa's
  * immediate-mode commands.
+ *
+ * Pointers to begin/end object commands and a few others
+ * are provided via the vtxfmt interface elsewhere.
  */
 void
 _mesa_init_exec_table(struct _glapi_table *exec, GLuint tableSize)
@@ -123,10 +113,11 @@
    /* first initialize all dispatch slots to no-op */
    _mesa_init_no_op_table(exec, tableSize);
 
+   _mesa_loopback_init_api_table( exec, GL_TRUE );
+
    /* load the dispatch slots we understand */
    exec->Accum = _mesa_Accum;
    exec->AlphaFunc = _mesa_AlphaFunc;
-   exec->Begin = _mesa_Begin;
    exec->Bitmap = _mesa_Bitmap;
    exec->BlendFunc = _mesa_BlendFunc;
    exec->CallList = _mesa_CallList;
@@ -138,38 +129,6 @@
    exec->ClearIndex = _mesa_ClearIndex;
    exec->ClearStencil = _mesa_ClearStencil;
    exec->ClipPlane = _mesa_ClipPlane;
-   exec->Color3b = _mesa_Color3b;
-   exec->Color3bv = _mesa_Color3bv;
-   exec->Color3d = _mesa_Color3d;
-   exec->Color3dv = _mesa_Color3dv;
-   exec->Color3f = _mesa_Color3f;
-   exec->Color3fv = _mesa_Color3fv;
-   exec->Color3i = _mesa_Color3i;
-   exec->Color3iv = _mesa_Color3iv;
-   exec->Color3s = _mesa_Color3s;
-   exec->Color3sv = _mesa_Color3sv;
-   exec->Color3ub = _mesa_Color3ub;
-   exec->Color3ubv = _mesa_Color3ubv;
-   exec->Color3ui = _mesa_Color3ui;
-   exec->Color3uiv = _mesa_Color3uiv;
-   exec->Color3us = _mesa_Color3us;
-   exec->Color3usv = _mesa_Color3usv;
-   exec->Color4b = _mesa_Color4b;
-   exec->Color4bv = _mesa_Color4bv;
-   exec->Color4d = _mesa_Color4d;
-   exec->Color4dv = _mesa_Color4dv;
-   exec->Color4f = _mesa_Color4f;
-   exec->Color4fv = _mesa_Color4fv;
-   exec->Color4i = _mesa_Color4i;
-   exec->Color4iv = _mesa_Color4iv;
-   exec->Color4s = _mesa_Color4s;
-   exec->Color4sv = _mesa_Color4sv;
-   exec->Color4ub = _mesa_Color4ub;
-   exec->Color4ubv = _mesa_Color4ubv;
-   exec->Color4ui = _mesa_Color4ui;
-   exec->Color4uiv = _mesa_Color4uiv;
-   exec->Color4us = _mesa_Color4us;
-   exec->Color4usv = _mesa_Color4usv;
    exec->ColorMask = _mesa_ColorMask;
    exec->ColorMaterial = _mesa_ColorMaterial;
    exec->CopyPixels = _mesa_CopyPixels;
@@ -181,26 +140,12 @@
    exec->Disable = _mesa_Disable;
    exec->DrawBuffer = _mesa_DrawBuffer;
    exec->DrawPixels = _mesa_DrawPixels;
-   exec->EdgeFlag = _mesa_EdgeFlag;
-   exec->EdgeFlagv = _mesa_EdgeFlagv;
    exec->Enable = _mesa_Enable;
-   exec->End = _mesa_End;
    exec->EndList = _mesa_EndList;
-   exec->EvalCoord1d = _mesa_EvalCoord1d;
-   exec->EvalCoord1dv = _mesa_EvalCoord1dv;
-   exec->EvalCoord1f = _mesa_EvalCoord1f;
-   exec->EvalCoord1fv = _mesa_EvalCoord1fv;
-   exec->EvalCoord2d = _mesa_EvalCoord2d;
-   exec->EvalCoord2dv = _mesa_EvalCoord2dv;
-   exec->EvalCoord2f = _mesa_EvalCoord2f;
-   exec->EvalCoord2fv = _mesa_EvalCoord2fv;
-   exec->EvalMesh1 = _mesa_EvalMesh1;
-   exec->EvalMesh2 = _mesa_EvalMesh2;
-   exec->EvalPoint1 = _mesa_EvalPoint1;
-   exec->EvalPoint2 = _mesa_EvalPoint2;
    exec->FeedbackBuffer = _mesa_FeedbackBuffer;
    exec->Finish = _mesa_Finish;
    exec->Flush = _mesa_Flush;
+   exec->FogCoordPointerEXT = _mesa_FogCoordPointerEXT;
    exec->Fogf = _mesa_Fogf;
    exec->Fogfv = _mesa_Fogfv;
    exec->Fogi = _mesa_Fogi;
@@ -238,14 +183,6 @@
    exec->GetTexParameteriv = _mesa_GetTexParameteriv;
    exec->Hint = _mesa_Hint;
    exec->IndexMask = _mesa_IndexMask;
-   exec->Indexd = _mesa_Indexd;
-   exec->Indexdv = _mesa_Indexdv;
-   exec->Indexf = _mesa_Indexf;
-   exec->Indexfv = _mesa_Indexfv;
-   exec->Indexi = _mesa_Indexi;
-   exec->Indexiv = _mesa_Indexiv;
-   exec->Indexs = _mesa_Indexs;
-   exec->Indexsv = _mesa_Indexsv;
    exec->InitNames = _mesa_InitNames;
    exec->IsEnabled = _mesa_IsEnabled;
    exec->IsList = _mesa_IsList;
@@ -273,24 +210,10 @@
    exec->MapGrid1f = _mesa_MapGrid1f;
    exec->MapGrid2d = _mesa_MapGrid2d;
    exec->MapGrid2f = _mesa_MapGrid2f;
-   exec->Materialf = _mesa_Materialf;
-   exec->Materialfv = _mesa_Materialfv;
-   exec->Materiali = _mesa_Materiali;
-   exec->Materialiv = _mesa_Materialiv;
    exec->MatrixMode = _mesa_MatrixMode;
    exec->MultMatrixd = _mesa_MultMatrixd;
    exec->MultMatrixf = _mesa_MultMatrixf;
    exec->NewList = _mesa_NewList;
-   exec->Normal3b = _mesa_Normal3b;
-   exec->Normal3bv = _mesa_Normal3bv;
-   exec->Normal3d = _mesa_Normal3d;
-   exec->Normal3dv = _mesa_Normal3dv;
-   exec->Normal3f = _mesa_Normal3f;
-   exec->Normal3fv = _mesa_Normal3fv;
-   exec->Normal3i = _mesa_Normal3i;
-   exec->Normal3iv = _mesa_Normal3iv;
-   exec->Normal3s = _mesa_Normal3s;
-   exec->Normal3sv = _mesa_Normal3sv;
    exec->Ortho = _mesa_Ortho;
    exec->PassThrough = _mesa_PassThrough;
    exec->PixelMapfv = _mesa_PixelMapfv;
@@ -337,57 +260,18 @@
    exec->RasterPos4sv = _mesa_RasterPos4sv;
    exec->ReadBuffer = _mesa_ReadBuffer;
    exec->ReadPixels = _mesa_ReadPixels;
-   exec->Rectd = _mesa_Rectd;
-   exec->Rectdv = _mesa_Rectdv;
-   exec->Rectf = _mesa_Rectf;
-   exec->Rectfv = _mesa_Rectfv;
-   exec->Recti = _mesa_Recti;
-   exec->Rectiv = _mesa_Rectiv;
-   exec->Rects = _mesa_Rects;
-   exec->Rectsv = _mesa_Rectsv;
    exec->RenderMode = _mesa_RenderMode;
    exec->Rotated = _mesa_Rotated;
    exec->Rotatef = _mesa_Rotatef;
    exec->Scaled = _mesa_Scaled;
    exec->Scalef = _mesa_Scalef;
    exec->Scissor = _mesa_Scissor;
+   exec->SecondaryColorPointerEXT = _mesa_SecondaryColorPointerEXT;
    exec->SelectBuffer = _mesa_SelectBuffer;
    exec->ShadeModel = _mesa_ShadeModel;
    exec->StencilFunc = _mesa_StencilFunc;
    exec->StencilMask = _mesa_StencilMask;
    exec->StencilOp = _mesa_StencilOp;
-   exec->TexCoord1d = _mesa_TexCoord1d;
-   exec->TexCoord1dv = _mesa_TexCoord1dv;
-   exec->TexCoord1f = _mesa_TexCoord1f;
-   exec->TexCoord1fv = _mesa_TexCoord1fv;
-   exec->TexCoord1i = _mesa_TexCoord1i;
-   exec->TexCoord1iv = _mesa_TexCoord1iv;
-   exec->TexCoord1s = _mesa_TexCoord1s;
-   exec->TexCoord1sv = _mesa_TexCoord1sv;
-   exec->TexCoord2d = _mesa_TexCoord2d;
-   exec->TexCoord2dv = _mesa_TexCoord2dv;
-   exec->TexCoord2f = _mesa_TexCoord2f;
-   exec->TexCoord2fv = _mesa_TexCoord2fv;
-   exec->TexCoord2i = _mesa_TexCoord2i;
-   exec->TexCoord2iv = _mesa_TexCoord2iv;
-   exec->TexCoord2s = _mesa_TexCoord2s;
-   exec->TexCoord2sv = _mesa_TexCoord2sv;
-   exec->TexCoord3d = _mesa_TexCoord3d;
-   exec->TexCoord3dv = _mesa_TexCoord3dv;
-   exec->TexCoord3f = _mesa_TexCoord3f;
-   exec->TexCoord3fv = _mesa_TexCoord3fv;
-   exec->TexCoord3i = _mesa_TexCoord3i;
-   exec->TexCoord3iv = _mesa_TexCoord3iv;
-   exec->TexCoord3s = _mesa_TexCoord3s;
-   exec->TexCoord3sv = _mesa_TexCoord3sv;
-   exec->TexCoord4d = _mesa_TexCoord4d;
-   exec->TexCoord4dv = _mesa_TexCoord4dv;
-   exec->TexCoord4f = _mesa_TexCoord4f;
-   exec->TexCoord4fv = _mesa_TexCoord4fv;
-   exec->TexCoord4i = _mesa_TexCoord4i;
-   exec->TexCoord4iv = _mesa_TexCoord4iv;
-   exec->TexCoord4s = _mesa_TexCoord4s;
-   exec->TexCoord4sv = _mesa_TexCoord4sv;
    exec->TexEnvf = _mesa_TexEnvf;
    exec->TexEnvfv = _mesa_TexEnvfv;
    exec->TexEnvi = _mesa_TexEnvi;
@@ -406,35 +290,11 @@
    exec->TexParameteriv = _mesa_TexParameteriv;
    exec->Translated = _mesa_Translated;
    exec->Translatef = _mesa_Translatef;
-   exec->Vertex2d = _mesa_Vertex2d;
-   exec->Vertex2dv = _mesa_Vertex2dv;
-   exec->Vertex2f = _mesa_Vertex2f;
-   exec->Vertex2fv = _mesa_Vertex2fv;
-   exec->Vertex2i = _mesa_Vertex2i;
-   exec->Vertex2iv = _mesa_Vertex2iv;
-   exec->Vertex2s = _mesa_Vertex2s;
-   exec->Vertex2sv = _mesa_Vertex2sv;
-   exec->Vertex3d = _mesa_Vertex3d;
-   exec->Vertex3dv = _mesa_Vertex3dv;
-   exec->Vertex3f = _mesa_Vertex3f;
-   exec->Vertex3fv = _mesa_Vertex3fv;
-   exec->Vertex3i = _mesa_Vertex3i;
-   exec->Vertex3iv = _mesa_Vertex3iv;
-   exec->Vertex3s = _mesa_Vertex3s;
-   exec->Vertex3sv = _mesa_Vertex3sv;
-   exec->Vertex4d = _mesa_Vertex4d;
-   exec->Vertex4dv = _mesa_Vertex4dv;
-   exec->Vertex4f = _mesa_Vertex4f;
-   exec->Vertex4fv = _mesa_Vertex4fv;
-   exec->Vertex4i = _mesa_Vertex4i;
-   exec->Vertex4iv = _mesa_Vertex4iv;
-   exec->Vertex4s = _mesa_Vertex4s;
-   exec->Vertex4sv = _mesa_Vertex4sv;
    exec->Viewport = _mesa_Viewport;
 
    /* 1.1 */
    exec->AreTexturesResident = _mesa_AreTexturesResident;
-   exec->ArrayElement = _mesa_ArrayElement;
+   exec->AreTexturesResidentEXT = _mesa_AreTexturesResident;
    exec->BindTexture = _mesa_BindTexture;
    exec->ColorPointer = _mesa_ColorPointer;
    exec->CopyTexImage1D = _mesa_CopyTexImage1D;
@@ -443,17 +303,15 @@
    exec->CopyTexSubImage2D = _mesa_CopyTexSubImage2D;
    exec->DeleteTextures = _mesa_DeleteTextures;
    exec->DisableClientState = _mesa_DisableClientState;
-   exec->DrawArrays = _mesa_DrawArrays;
-   exec->DrawElements = _mesa_DrawElements;
    exec->EdgeFlagPointer = _mesa_EdgeFlagPointer;
    exec->EnableClientState = _mesa_EnableClientState;
    exec->GenTextures = _mesa_GenTextures;
+   exec->GenTexturesEXT = _mesa_GenTextures;
    exec->GetPointerv = _mesa_GetPointerv;
    exec->IndexPointer = _mesa_IndexPointer;
-   exec->Indexub = _mesa_Indexub;
-   exec->Indexubv = _mesa_Indexubv;
    exec->InterleavedArrays = _mesa_InterleavedArrays;
    exec->IsTexture = _mesa_IsTexture;
+   exec->IsTextureEXT = _mesa_IsTexture;
    exec->NormalPointer = _mesa_NormalPointer;
    exec->PopClientAttrib = _mesa_PopClientAttrib;
    exec->PrioritizeTextures = _mesa_PrioritizeTextures;
@@ -465,7 +323,6 @@
 
    /* 1.2 */
    exec->CopyTexSubImage3D = _mesa_CopyTexSubImage3D;
-   exec->DrawRangeElements = _mesa_DrawRangeElements;
    exec->TexImage3D = _mesa_TexImage3D;
    exec->TexSubImage3D = _mesa_TexSubImage3D;
 
@@ -487,18 +344,31 @@
    exec->CopyConvolutionFilter1D = _mesa_CopyConvolutionFilter1D;
    exec->CopyConvolutionFilter2D = _mesa_CopyConvolutionFilter2D;
    exec->GetColorTable = _mesa_GetColorTable;
+   exec->GetColorTableEXT = _mesa_GetColorTable;
    exec->GetColorTableParameterfv = _mesa_GetColorTableParameterfv;
+   exec->GetColorTableParameterfvEXT = _mesa_GetColorTableParameterfv;
    exec->GetColorTableParameteriv = _mesa_GetColorTableParameteriv;
+   exec->GetColorTableParameterivEXT = _mesa_GetColorTableParameteriv;
    exec->GetConvolutionFilter = _mesa_GetConvolutionFilter;
+   exec->GetConvolutionFilterEXT = _mesa_GetConvolutionFilter;
    exec->GetConvolutionParameterfv = _mesa_GetConvolutionParameterfv;
+   exec->GetConvolutionParameterfvEXT = _mesa_GetConvolutionParameterfv;
    exec->GetConvolutionParameteriv = _mesa_GetConvolutionParameteriv;
+   exec->GetConvolutionParameterivEXT = _mesa_GetConvolutionParameteriv;
    exec->GetHistogram = _mesa_GetHistogram;
+   exec->GetHistogramEXT = _mesa_GetHistogram;
    exec->GetHistogramParameterfv = _mesa_GetHistogramParameterfv;
+   exec->GetHistogramParameterfvEXT = _mesa_GetHistogramParameterfv;
    exec->GetHistogramParameteriv = _mesa_GetHistogramParameteriv;
+   exec->GetHistogramParameterivEXT = _mesa_GetHistogramParameteriv;
    exec->GetMinmax = _mesa_GetMinmax;
+   exec->GetMinmaxEXT = _mesa_GetMinmax;
    exec->GetMinmaxParameterfv = _mesa_GetMinmaxParameterfv;
+   exec->GetMinmaxParameterfvEXT = _mesa_GetMinmaxParameterfv;
    exec->GetMinmaxParameteriv = _mesa_GetMinmaxParameteriv;
+   exec->GetMinmaxParameterivEXT = _mesa_GetMinmaxParameteriv;
    exec->GetSeparableFilter = _mesa_GetSeparableFilter;
+   exec->GetSeparableFilterEXT = _mesa_GetSeparableFilter;
    exec->Histogram = _mesa_Histogram;
    exec->Minmax = _mesa_Minmax;
    exec->ResetHistogram = _mesa_ResetHistogram;
@@ -556,9 +426,6 @@
    exec->PointParameterfEXT = _mesa_PointParameterfEXT;
    exec->PointParameterfvEXT = _mesa_PointParameterfvEXT;
 
-   /* 77. GL_PGI_misc_hints */
-   exec->HintPGI = _mesa_HintPGI;
-
    /* 78. GL_EXT_paletted_texture */
 #if 0
    exec->ColorTableEXT = _mesa_ColorTableEXT;
@@ -607,38 +474,6 @@
    /* ARB 1. GL_ARB_multitexture */
    exec->ActiveTextureARB = _mesa_ActiveTextureARB;
    exec->ClientActiveTextureARB = _mesa_ClientActiveTextureARB;
-   exec->MultiTexCoord1dARB = _mesa_MultiTexCoord1dARB;
-   exec->MultiTexCoord1dvARB = _mesa_MultiTexCoord1dvARB;
-   exec->MultiTexCoord1fARB = _mesa_MultiTexCoord1fARB;
-   exec->MultiTexCoord1fvARB = _mesa_MultiTexCoord1fvARB;
-   exec->MultiTexCoord1iARB = _mesa_MultiTexCoord1iARB;
-   exec->MultiTexCoord1ivARB = _mesa_MultiTexCoord1ivARB;
-   exec->MultiTexCoord1sARB = _mesa_MultiTexCoord1sARB;
-   exec->MultiTexCoord1svARB = _mesa_MultiTexCoord1svARB;
-   exec->MultiTexCoord2dARB = _mesa_MultiTexCoord2dARB;
-   exec->MultiTexCoord2dvARB = _mesa_MultiTexCoord2dvARB;
-   exec->MultiTexCoord2fARB = _mesa_MultiTexCoord2fARB;
-   exec->MultiTexCoord2fvARB = _mesa_MultiTexCoord2fvARB;
-   exec->MultiTexCoord2iARB = _mesa_MultiTexCoord2iARB;
-   exec->MultiTexCoord2ivARB = _mesa_MultiTexCoord2ivARB;
-   exec->MultiTexCoord2sARB = _mesa_MultiTexCoord2sARB;
-   exec->MultiTexCoord2svARB = _mesa_MultiTexCoord2svARB;
-   exec->MultiTexCoord3dARB = _mesa_MultiTexCoord3dARB;
-   exec->MultiTexCoord3dvARB = _mesa_MultiTexCoord3dvARB;
-   exec->MultiTexCoord3fARB = _mesa_MultiTexCoord3fARB;
-   exec->MultiTexCoord3fvARB = _mesa_MultiTexCoord3fvARB;
-   exec->MultiTexCoord3iARB = _mesa_MultiTexCoord3iARB;
-   exec->MultiTexCoord3ivARB = _mesa_MultiTexCoord3ivARB;
-   exec->MultiTexCoord3sARB = _mesa_MultiTexCoord3sARB;
-   exec->MultiTexCoord3svARB = _mesa_MultiTexCoord3svARB;
-   exec->MultiTexCoord4dARB = _mesa_MultiTexCoord4dARB;
-   exec->MultiTexCoord4dvARB = _mesa_MultiTexCoord4dvARB;
-   exec->MultiTexCoord4fARB = _mesa_MultiTexCoord4fARB;
-   exec->MultiTexCoord4fvARB = _mesa_MultiTexCoord4fvARB;
-   exec->MultiTexCoord4iARB = _mesa_MultiTexCoord4iARB;
-   exec->MultiTexCoord4ivARB = _mesa_MultiTexCoord4ivARB;
-   exec->MultiTexCoord4sARB = _mesa_MultiTexCoord4sARB;
-   exec->MultiTexCoord4svARB = _mesa_MultiTexCoord4svARB;
 
    /* ARB 3. GL_ARB_transpose_matrix */
    exec->LoadTransposeMatrixdARB = _mesa_LoadTransposeMatrixdARB;
@@ -646,6 +481,9 @@
    exec->MultTransposeMatrixdARB = _mesa_MultTransposeMatrixdARB;
    exec->MultTransposeMatrixfARB = _mesa_MultTransposeMatrixfARB;
 
+   /* ARB 5. GL_ARB_multisample */
+   exec->SampleCoverageARB = _mesa_SampleCoverageARB;
+
    /* ARB 12. GL_ARB_texture_compression */
    exec->CompressedTexImage3DARB = _mesa_CompressedTexImage3DARB;
    exec->CompressedTexImage2DARB = _mesa_CompressedTexImage2DARB;
@@ -664,577 +502,523 @@
 /**********************************************************************/
 
 
-/*
- * Since the device driver may or may not support pixel logic ops we
- * have to make some extensive tests to determine whether or not
- * software-implemented logic operations have to be used.
+static void
+update_polygon( GLcontext *ctx )
+{
+   ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET);
+
+   if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
+      ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
+
+   /* Any Polygon offsets enabled? */
+   ctx->Polygon._OffsetAny = GL_FALSE;
+   ctx->_TriangleCaps &= ~DD_TRI_OFFSET;
+
+   if (ctx->Polygon.OffsetPoint ||
+       ctx->Polygon.OffsetLine ||
+       ctx->Polygon.OffsetFill) {
+      ctx->_TriangleCaps |= DD_TRI_OFFSET;
+      ctx->Polygon._OffsetAny = GL_TRUE;
+   }
+}
+
+static void
+calculate_model_project_matrix( GLcontext *ctx )
+{
+      _math_matrix_mul_matrix( &ctx->_ModelProjectMatrix,
+			       &ctx->ProjectionMatrix,
+			       &ctx->ModelView );
+
+      _math_matrix_analyse( &ctx->_ModelProjectMatrix );
+}
+
+static void
+update_modelview_scale( GLcontext *ctx )
+{
+   ctx->_ModelViewInvScale = 1.0F;
+   if (ctx->ModelView.flags & (MAT_FLAG_UNIFORM_SCALE |
+			       MAT_FLAG_GENERAL_SCALE |
+			       MAT_FLAG_GENERAL_3D |
+			       MAT_FLAG_GENERAL) ) {
+      const GLfloat *m = ctx->ModelView.inv;
+      GLfloat f = m[2] * m[2] + m[6] * m[6] + m[10] * m[10];
+      if (f < 1e-12) f = 1.0;
+      if (ctx->_NeedEyeCoords)
+	 ctx->_ModelViewInvScale = (GLfloat) (1.0/GL_SQRT(f));
+      else
+	 ctx->_ModelViewInvScale = (GLfloat) GL_SQRT(f);
+   }
+}
+
+
+/* Bring uptodate any state that relies on _NeedEyeCoords.
  */
-static void update_pixel_logic( GLcontext *ctx )
+static void
+update_tnl_spaces( GLcontext *ctx, GLuint oldneedeyecoords )
 {
-   if (ctx->Visual->RGBAflag) {
-      /* RGBA mode blending w/ Logic Op */
-      if (ctx->Color.ColorLogicOpEnabled) {
-	 if (ctx->Driver.LogicOp
-             && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
-	    /* Device driver can do logic, don't have to do it in software */
-	    ctx->Color.SWLogicOpEnabled = GL_FALSE;
-	 }
-	 else {
-	    /* Device driver can't do logic op so we do it in software */
-	    ctx->Color.SWLogicOpEnabled = GL_TRUE;
-	 }
-      }
-      else {
-	 /* no logic op */
-	 if (ctx->Driver.LogicOp) {
-            (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
-         }
-	 ctx->Color.SWLogicOpEnabled = GL_FALSE;
-      }
+   /* Check if the truth-value interpretations of the bitfields have
+    * changed:
+    */
+   if ((oldneedeyecoords == 0) != (ctx->_NeedEyeCoords == 0)) {
+      /* Recalculate all state that depends on _NeedEyeCoords.
+       */
+      update_modelview_scale(ctx);
+      _mesa_compute_light_positions( ctx );
+
+      if (ctx->Driver.LightingSpaceChange)
+	 ctx->Driver.LightingSpaceChange( ctx );
    }
    else {
-      /* CI mode Logic Op */
-      if (ctx->Color.IndexLogicOpEnabled) {
-	 if (ctx->Driver.LogicOp
-             && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
-	    /* Device driver can do logic, don't have to do it in software */
-	    ctx->Color.SWLogicOpEnabled = GL_FALSE;
-	 }
-	 else {
-	    /* Device driver can't do logic op so we do it in software */
-	    ctx->Color.SWLogicOpEnabled = GL_TRUE;
-	 }
-      }
-      else {
-	 /* no logic op */
-	 if (ctx->Driver.LogicOp) {
-            (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
-         }
-	 ctx->Color.SWLogicOpEnabled = GL_FALSE;
-      }
+      GLuint new_state = ctx->NewState;
+
+      /* Recalculate that same state only if it has been invalidated
+       * by other statechanges.
+       */
+      if (new_state & _NEW_MODELVIEW)
+	 update_modelview_scale(ctx);
+
+      if (new_state & (_NEW_LIGHT|_NEW_MODELVIEW))
+	 _mesa_compute_light_positions( ctx );
    }
 }
 
 
-
-/*
- * Check if software implemented RGBA or Color Index masking is needed.
- */
-static void update_pixel_masking( GLcontext *ctx )
+static void
+update_drawbuffer( GLcontext *ctx )
 {
-   if (ctx->Visual->RGBAflag) {
-      GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;
-      if (*colorMask == 0xffffffff) {
-         /* disable masking */
-         if (ctx->Driver.ColorMask) {
-            (void) (*ctx->Driver.ColorMask)( ctx, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
-         }
-         ctx->Color.SWmasking = GL_FALSE;
+   ctx->DrawBuffer->_Xmin = 0;
+   ctx->DrawBuffer->_Ymin = 0;
+   ctx->DrawBuffer->_Xmax = ctx->DrawBuffer->Width;
+   ctx->DrawBuffer->_Ymax = ctx->DrawBuffer->Height;
+   if (ctx->Scissor.Enabled) {
+      if (ctx->Scissor.X > ctx->DrawBuffer->_Xmin) {
+	 ctx->DrawBuffer->_Xmin = ctx->Scissor.X;
       }
-      else {
-         /* Ask driver to do color masking, if it can't then
-          * do it in software
-          */
-         GLboolean red   = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE;
-         GLboolean green = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE;
-         GLboolean blue  = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE;
-         GLboolean alpha = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE;
-         if (ctx->Driver.ColorMask
-             && (*ctx->Driver.ColorMask)( ctx, red, green, blue, alpha )) {
-            ctx->Color.SWmasking = GL_FALSE;
-         }
-         else {
-            ctx->Color.SWmasking = GL_TRUE;
-         }
+      if (ctx->Scissor.Y > ctx->DrawBuffer->_Ymin) {
+	 ctx->DrawBuffer->_Ymin = ctx->Scissor.Y;
       }
-   }
-   else {
-      if (ctx->Color.IndexMask==0xffffffff) {
-         /* disable masking */
-         if (ctx->Driver.IndexMask) {
-            (void) (*ctx->Driver.IndexMask)( ctx, 0xffffffff );
-         }
-         ctx->Color.SWmasking = GL_FALSE;
+      if (ctx->Scissor.X + ctx->Scissor.Width < ctx->DrawBuffer->_Xmax) {
+	 ctx->DrawBuffer->_Xmax = ctx->Scissor.X + ctx->Scissor.Width;
       }
-      else {
-         /* Ask driver to do index masking, if it can't then
-          * do it in software
-          */
-         if (ctx->Driver.IndexMask
-             && (*ctx->Driver.IndexMask)( ctx, ctx->Color.IndexMask )) {
-            ctx->Color.SWmasking = GL_FALSE;
-         }
-         else {
-            ctx->Color.SWmasking = GL_TRUE;
-         }
+      if (ctx->Scissor.Y + ctx->Scissor.Height < ctx->DrawBuffer->_Ymax) {
+	 ctx->DrawBuffer->_Ymax = ctx->Scissor.Y + ctx->Scissor.Height;
       }
    }
 }
 
 
-static void update_fog_mode( GLcontext *ctx )
+/* NOTE: This routine references Tranform attribute values to compute
+ * userclip positions in clip space, but is only called on
+ * _NEW_PROJECTION.  The _mesa_ClipPlane() function keeps these values
+ * uptodate across changes to the Transform attributes.
+ */
+static void
+update_projection( GLcontext *ctx )
 {
-   const GLuint old_mode = ctx->FogMode;
+   _math_matrix_analyse( &ctx->ProjectionMatrix );
 
-   if (ctx->Fog.Enabled) {
-      if (ctx->Texture.ReallyEnabled)
-         ctx->FogMode = FOG_FRAGMENT;
-      else if (ctx->Hint.Fog == GL_NICEST)
-         ctx->FogMode = FOG_FRAGMENT;
-      else
-         ctx->FogMode = FOG_VERTEX;
-
-      if (ctx->Driver.GetParameteri)
-         if ((ctx->Driver.GetParameteri)( ctx, DD_HAVE_HARDWARE_FOG ))
-            ctx->FogMode = FOG_FRAGMENT;
-   }
-   else {
-      ctx->FogMode = FOG_NONE;
+   /* Recompute clip plane positions in clipspace.  This is also done
+    * in _mesa_ClipPlane().
+    */
+   if (ctx->Transform._AnyClip) {
+      GLuint p;
+      for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
+	 if (ctx->Transform.ClipEnabled[p]) {
+	    _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
+				 ctx->Transform.EyeUserPlane[p],
+				 ctx->ProjectionMatrix.inv );
+	 }
+      }
    }
-   
-   if (old_mode != ctx->FogMode)
-      ctx->NewState |= NEW_FOG;
 }
 
 
 /*
- * Recompute the value of ctx->RasterMask, etc. according to
- * the current context.
+ * Return a bitmask of IMAGE_*_BIT flags which to indicate which
+ * pixel transfer operations are enabled.
  */
-static void update_rasterflags( GLcontext *ctx )
+static void
+update_image_transfer_state(GLcontext *ctx)
 {
-   ctx->RasterMask = 0;
+   GLuint mask = 0;
 
-   if (ctx->Color.AlphaEnabled)		ctx->RasterMask |= ALPHATEST_BIT;
-   if (ctx->Color.BlendEnabled)		ctx->RasterMask |= BLEND_BIT;
-   if (ctx->Depth.Test)			ctx->RasterMask |= DEPTH_BIT;
-   if (ctx->FogMode==FOG_FRAGMENT)	ctx->RasterMask |= FOG_BIT;
-   if (ctx->Color.SWLogicOpEnabled)	ctx->RasterMask |= LOGIC_OP_BIT;
-   if (ctx->Scissor.Enabled)		ctx->RasterMask |= SCISSOR_BIT;
-   if (ctx->Stencil.Enabled)		ctx->RasterMask |= STENCIL_BIT;
-   if (ctx->Color.SWmasking)		ctx->RasterMask |= MASKING_BIT;
-   if (ctx->Texture.ReallyEnabled)	ctx->RasterMask |= TEXTURE_BIT;
-
-   if (ctx->DrawBuffer->UseSoftwareAlphaBuffers
-       && ctx->Color.ColorMask[ACOMP]
-       && ctx->Color.DrawBuffer != GL_NONE)
-      ctx->RasterMask |= ALPHABUF_BIT;
-
-   if (   ctx->Viewport.X<0
-       || ctx->Viewport.X + ctx->Viewport.Width > ctx->DrawBuffer->Width
-       || ctx->Viewport.Y<0
-       || ctx->Viewport.Y + ctx->Viewport.Height > ctx->DrawBuffer->Height) {
-      ctx->RasterMask |= WINCLIP_BIT;
+   if (ctx->Pixel.RedScale   != 1.0F || ctx->Pixel.RedBias   != 0.0F ||
+       ctx->Pixel.GreenScale != 1.0F || ctx->Pixel.GreenBias != 0.0F ||
+       ctx->Pixel.BlueScale  != 1.0F || ctx->Pixel.BlueBias  != 0.0F ||
+       ctx->Pixel.AlphaScale != 1.0F || ctx->Pixel.AlphaBias != 0.0F)
+      mask |= IMAGE_SCALE_BIAS_BIT;
+
+   if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset)
+      mask |= IMAGE_SHIFT_OFFSET_BIT;
+
+   if (ctx->Pixel.MapColorFlag)
+      mask |= IMAGE_MAP_COLOR_BIT;
+
+   if (ctx->Pixel.ColorTableEnabled)
+      mask |= IMAGE_COLOR_TABLE_BIT;
+
+   if (ctx->Pixel.Convolution1DEnabled ||
+       ctx->Pixel.Convolution2DEnabled ||
+       ctx->Pixel.Separable2DEnabled) {
+      mask |= IMAGE_CONVOLUTION_BIT;
+      if (ctx->Pixel.PostConvolutionScale[0] != 1.0F ||
+          ctx->Pixel.PostConvolutionScale[1] != 1.0F ||
+          ctx->Pixel.PostConvolutionScale[2] != 1.0F ||
+          ctx->Pixel.PostConvolutionScale[3] != 1.0F ||
+          ctx->Pixel.PostConvolutionBias[0] != 0.0F ||
+          ctx->Pixel.PostConvolutionBias[1] != 0.0F ||
+          ctx->Pixel.PostConvolutionBias[2] != 0.0F ||
+          ctx->Pixel.PostConvolutionBias[3] != 0.0F) {
+         mask |= IMAGE_POST_CONVOLUTION_SCALE_BIAS;
+      }
    }
 
-   if (ctx->Depth.OcclusionTest)
-      ctx->RasterMask |= OCCLUSION_BIT;
+   if (ctx->Pixel.PostConvolutionColorTableEnabled)
+      mask |= IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT;
+
+   if (ctx->ColorMatrix.type != MATRIX_IDENTITY ||
+       ctx->Pixel.PostColorMatrixScale[0] != 1.0F ||
+       ctx->Pixel.PostColorMatrixBias[0]  != 0.0F ||
+       ctx->Pixel.PostColorMatrixScale[1] != 1.0F ||
+       ctx->Pixel.PostColorMatrixBias[1]  != 0.0F ||
+       ctx->Pixel.PostColorMatrixScale[2] != 1.0F ||
+       ctx->Pixel.PostColorMatrixBias[2]  != 0.0F ||
+       ctx->Pixel.PostColorMatrixScale[3] != 1.0F ||
+       ctx->Pixel.PostColorMatrixBias[3]  != 0.0F)
+      mask |= IMAGE_COLOR_MATRIX_BIT;
+
+   if (ctx->Pixel.PostColorMatrixColorTableEnabled)
+      mask |= IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT;
 
+   if (ctx->Pixel.HistogramEnabled)
+      mask |= IMAGE_HISTOGRAM_BIT;
 
-   /* If we're not drawing to exactly one color buffer set the
-    * MULTI_DRAW_BIT flag.  Also set it if we're drawing to no
-    * buffers or the RGBA or CI mask disables all writes.
-    */
-   ctx->TriangleCaps &= ~DD_MULTIDRAW;
+   if (ctx->Pixel.MinMaxEnabled)
+      mask |= IMAGE_MIN_MAX_BIT;
 
-   if (ctx->Color.MultiDrawBuffer) {
-      ctx->RasterMask |= MULTI_DRAW_BIT;
-      ctx->TriangleCaps |= DD_MULTIDRAW;
-   }
-   else if (ctx->Color.DrawBuffer==GL_NONE) {
-      ctx->RasterMask |= MULTI_DRAW_BIT;
-      ctx->TriangleCaps |= DD_MULTIDRAW;
-   }
-   else if (ctx->Visual->RGBAflag && *((GLuint *) ctx->Color.ColorMask) == 0) {
-      /* all RGBA channels disabled */
-      ctx->RasterMask |= MULTI_DRAW_BIT;
-      ctx->TriangleCaps |= DD_MULTIDRAW;
-   }
-   else if (!ctx->Visual->RGBAflag && ctx->Color.IndexMask==0) {
-      /* all color index bits disabled */
-      ctx->RasterMask |= MULTI_DRAW_BIT;
-      ctx->TriangleCaps |= DD_MULTIDRAW;
-   }
+   ctx->_ImageTransferState = mask;
 }
 
 
-void gl_print_state( const char *msg, GLuint state )
-{
-   fprintf(stderr,
-	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
-	   msg,
-	   state,
-	   (state & NEW_LIGHTING)         ? "lighting, " : "",
-	   (state & NEW_RASTER_OPS)       ? "raster-ops, " : "",
-	   (state & NEW_TEXTURING)        ? "texturing, " : "",
-	   (state & NEW_POLYGON)          ? "polygon, " : "",
-	   (state & NEW_DRVSTATE0)        ? "driver-0, " : "",
-	   (state & NEW_DRVSTATE1)        ? "driver-1, " : "",
-	   (state & NEW_DRVSTATE2)        ? "driver-2, " : "",
-	   (state & NEW_DRVSTATE3)        ? "driver-3, " : "",
-	   (state & NEW_MODELVIEW)        ? "modelview, " : "",
-	   (state & NEW_PROJECTION)       ? "projection, " : "",
-	   (state & NEW_TEXTURE_MATRIX)   ? "texture-matrix, " : "",
-	   (state & NEW_USER_CLIP)        ? "user-clip, " : "",
-	   (state & NEW_TEXTURE_ENV)      ? "texture-env, " : "",
-	   (state & NEW_CLIENT_STATE)     ? "client-state, " : "",
-	   (state & NEW_FOG)              ? "fog, " : "",
-	   (state & NEW_NORMAL_TRANSFORM) ? "normal-transform, " : "",
-	   (state & NEW_VIEWPORT)         ? "viewport, " : "",
-	   (state & NEW_TEXTURE_ENABLE)   ? "texture-enable, " : "");
-}
 
 
-void gl_print_enable_flags( const char *msg, GLuint flags )
+/* Note: This routine refers to derived texture attribute values to
+ * compute the ENABLE_TEXMAT flags, but is only called on
+ * _NEW_TEXTURE_MATRIX.  On changes to _NEW_TEXTURE, the ENABLE_TEXMAT
+ * flags are updated by _mesa_update_textures(), below.
+ *
+ * If both TEXTURE and TEXTURE_MATRIX change at once, these values
+ * will be computed twice.
+ */
+static void
+update_texture_matrices( GLcontext *ctx )
 {
-   fprintf(stderr,
-	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s\n",
-	   msg,
-	   flags,
-	   (flags & ENABLE_TEX0)       ? "tex-0, " : "",
-	   (flags & ENABLE_TEX1)       ? "tex-1, " : "",
-	   (flags & ENABLE_LIGHT)      ? "light, " : "",
-	   (flags & ENABLE_FOG)        ? "fog, " : "",
-	   (flags & ENABLE_USERCLIP)   ? "userclip, " : "",
-	   (flags & ENABLE_TEXGEN0)    ? "tex-gen-0, " : "",
-	   (flags & ENABLE_TEXGEN1)    ? "tex-gen-1, " : "",
-	   (flags & ENABLE_TEXMAT0)    ? "tex-mat-0, " : "",
-	   (flags & ENABLE_TEXMAT1)    ? "tex-mat-1, " : "",
-	   (flags & ENABLE_NORMALIZE)  ? "normalize, " : "",
-	   (flags & ENABLE_RESCALE)    ? "rescale, " : "");
+   GLuint i;
+
+   ctx->Texture._TexMatEnabled = 0;
+
+   for (i=0; i < ctx->Const.MaxTextureUnits; i++) {
+      if (ctx->TextureMatrix[i].flags & MAT_DIRTY) {
+	 _math_matrix_analyse( &ctx->TextureMatrix[i] );
+
+	 if (ctx->Texture.Unit[i]._ReallyEnabled &&
+	     ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
+	    ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(i);
+
+	 if (ctx->Driver.TextureMatrix)
+	    ctx->Driver.TextureMatrix( ctx, i, &ctx->TextureMatrix[i] );
+      }
+   }
 }
 
 
-/*
- * If ctx->NewState is non-zero then this function MUST be called before
- * rendering any primitive.  Basically, function pointers and miscellaneous
- * flags are updated to reflect the current state of the state machine.
+/* Note: This routine refers to derived texture matrix values to
+ * compute the ENABLE_TEXMAT flags, but is only called on
+ * _NEW_TEXTURE.  On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT
+ * flags are updated by _mesa_update_texture_matrices, above.
+ *
+ * If both TEXTURE and TEXTURE_MATRIX change at once, these values
+ * will be computed twice.
  */
-void gl_update_state( GLcontext *ctx )
+static void
+update_texture_state( GLcontext *ctx )
 {
    GLuint i;
 
-   if (MESA_VERBOSE & VERBOSE_STATE)
-      gl_print_state("", ctx->NewState);
+   ctx->Texture._ReallyEnabled = 0;
+   ctx->Texture._GenFlags = 0;
+   ctx->_NeedNormals &= ~NEED_NORMALS_TEXGEN;
+   ctx->_NeedEyeCoords &= ~NEED_EYE_TEXGEN;
+   ctx->Texture._TexMatEnabled = 0;
+   ctx->Texture._TexGenEnabled = 0;
 
-   if (ctx->NewState & NEW_CLIENT_STATE)
-      gl_update_client_state( ctx );
+   /* Update texture unit state.
+    */
+   for (i=0; i < ctx->Const.MaxTextureUnits; i++) {
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
 
-   if ((ctx->NewState & NEW_TEXTURE_ENABLE) &&
-       (ctx->Enabled & ENABLE_TEX_ANY) != ctx->Texture.ReallyEnabled) {
-      ctx->NewState |= NEW_TEXTURING | NEW_RASTER_OPS;
-   }
+      texUnit->_ReallyEnabled = 0;
+      texUnit->_GenFlags = 0;
 
-   /* XXX this is a hack, gone in 3.5 */
-   if (ctx->NewState & NEW_TEXTURE_ENV) {
-      if (ctx->Texture.Unit[0].EnvMode == ctx->Texture.Unit[0].LastEnvMode &&
-	  ctx->Texture.Unit[1].EnvMode == ctx->Texture.Unit[1].LastEnvMode &&
-          ctx->Texture.Unit[0].EnvMode != GL_COMBINE_EXT &&
-          ctx->Texture.Unit[1].EnvMode != GL_COMBINE_EXT)
-	 ctx->NewState &= ~NEW_TEXTURE_ENV;
-      ctx->Texture.Unit[0].LastEnvMode = ctx->Texture.Unit[0].EnvMode;
-      ctx->Texture.Unit[1].LastEnvMode = ctx->Texture.Unit[1].EnvMode;
-   }
+      if (!texUnit->Enabled)
+	 continue;
 
-   /* Update ctx->Enabled's ENABLE_TEXMATn flags */
-   if (ctx->NewState & (NEW_TEXTURE_MATRIX | NEW_TEXTURE_ENABLE)) {
-      ctx->Enabled &= ~(ENABLE_TEXMAT0 | ENABLE_TEXMAT1);
-
-      for (i=0; i < MAX_TEXTURE_UNITS; i++) {
-	 if (ctx->TextureMatrix[i].flags & MAT_DIRTY_ALL_OVER) {
-	    gl_matrix_analyze( &ctx->TextureMatrix[i] );
-	    ctx->TextureMatrix[i].flags &= ~MAT_DIRTY_DEPENDENTS;
-	 }
-         if (ctx->Texture.Unit[i].Enabled &&
-             ctx->TextureMatrix[i].type != MATRIX_IDENTITY) {
-            ctx->Enabled |= ENABLE_TEXMAT0 << i;
+      /* Find the texture of highest dimensionality that is enabled
+       * and complete.  We'll use it for texturing.
+       */
+      if (texUnit->Enabled & TEXTURE0_CUBE) {
+         struct gl_texture_object *texObj = texUnit->CurrentCubeMap;
+         if (!texObj->Complete) {
+            _mesa_test_texobj_completeness(ctx, texObj);
          }
+         if (texObj->Complete) {
+            texUnit->_ReallyEnabled = TEXTURE0_CUBE;
+            texUnit->_Current = texObj;
+         }
       }
-   }
 
-   /* Update ctx->Enabled's ENABLE_TEXGENn and ENABLE_TEXn flags */
-   if (ctx->NewState & (NEW_TEXTURING | NEW_TEXTURE_ENABLE)) {
-      ctx->Texture.NeedNormals = GL_FALSE;
-      gl_update_dirty_texobjs(ctx);
-      ctx->Enabled &= ~(ENABLE_TEXGEN0 | ENABLE_TEXGEN1);
-      ctx->Texture.ReallyEnabled = 0;
-
-      for (i=0; i < MAX_TEXTURE_UNITS; i++) {
-	 if (ctx->Texture.Unit[i].Enabled) {
-	    gl_update_texture_unit( ctx, &ctx->Texture.Unit[i] );
-
-	    ctx->Texture.ReallyEnabled |=
-	       ctx->Texture.Unit[i].ReallyEnabled << (i * 4);
-
-	    if (ctx->Texture.Unit[i].GenFlags != 0) {
-	       ctx->Enabled |= ENABLE_TEXGEN0 << i;
-
-	       if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_NORMALS) {
-		  ctx->Texture.NeedNormals = GL_TRUE;
-		  ctx->Texture.NeedEyeCoords = GL_TRUE;
-	       }
-
-	       if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_EYE_COORD) {
-		  ctx->Texture.NeedEyeCoords = GL_TRUE;
-	       }
-	    }
-	 }
-         else {
-            ctx->Texture.Unit[i].ReallyEnabled = 0;
+      if (!texUnit->_ReallyEnabled && (texUnit->Enabled & TEXTURE0_3D)) {
+         struct gl_texture_object *texObj = texUnit->Current3D;
+         if (!texObj->Complete) {
+            _mesa_test_texobj_completeness(ctx, texObj);
+         }
+         if (texObj->Complete) {
+            texUnit->_ReallyEnabled = TEXTURE0_3D;
+            texUnit->_Current = texObj;
          }
       }
-      ctx->Enabled = (ctx->Enabled & ~ENABLE_TEX_ANY) | ctx->Texture.ReallyEnabled;
-      ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
-   }
 
-   if (ctx->NewState & (NEW_RASTER_OPS | NEW_LIGHTING | NEW_FOG | NEW_TEXTURE_ENABLE)) {
-
-      if (ctx->NewState & (NEW_RASTER_OPS | NEW_TEXTURE_ENABLE)) {
-	 update_pixel_logic(ctx);
-	 update_pixel_masking(ctx);
-	 update_fog_mode(ctx);
-	 update_rasterflags(ctx);
-	 if (ctx->Driver.Dither) {
-	    (*ctx->Driver.Dither)( ctx, ctx->Color.DitherFlag );
-	 }
+      if (!texUnit->_ReallyEnabled && (texUnit->Enabled & TEXTURE0_RECT)) {
+         struct gl_texture_object *texObj = texUnit->CurrentRect;
+         if (!texObj->Complete) {
+            _mesa_test_texobj_completeness(ctx, texObj);
+         }
+         if (texObj->Complete) {
+            texUnit->_ReallyEnabled = TEXTURE0_RECT;
+            texUnit->_Current = texObj;
+         }
+      }
 
-	 /* update scissor region */
-	 ctx->DrawBuffer->Xmin = 0;
-	 ctx->DrawBuffer->Ymin = 0;
-	 ctx->DrawBuffer->Xmax = ctx->DrawBuffer->Width-1;
-	 ctx->DrawBuffer->Ymax = ctx->DrawBuffer->Height-1;
-	 if (ctx->Scissor.Enabled) {
-	    if (ctx->Scissor.X > ctx->DrawBuffer->Xmin) {
-	       ctx->DrawBuffer->Xmin = ctx->Scissor.X;
-	    }
-	    if (ctx->Scissor.Y > ctx->DrawBuffer->Ymin) {
-	       ctx->DrawBuffer->Ymin = ctx->Scissor.Y;
-	    }
-	    if (ctx->Scissor.X + ctx->Scissor.Width - 1 < ctx->DrawBuffer->Xmax) {
-	       ctx->DrawBuffer->Xmax = ctx->Scissor.X + ctx->Scissor.Width - 1;
-	    }
-	    if (ctx->Scissor.Y + ctx->Scissor.Height - 1 < ctx->DrawBuffer->Ymax) {
-	       ctx->DrawBuffer->Ymax = ctx->Scissor.Y + ctx->Scissor.Height - 1;
-	    }
-	 }
+      if (!texUnit->_ReallyEnabled && (texUnit->Enabled & TEXTURE0_2D)) {
+         struct gl_texture_object *texObj = texUnit->Current2D;
+         if (!texObj->Complete) {
+            _mesa_test_texobj_completeness(ctx, texObj);
+         }
+         if (texObj->Complete) {
+            texUnit->_ReallyEnabled = TEXTURE0_2D;
+            texUnit->_Current = texObj;
+         }
       }
 
-      if (ctx->NewState & NEW_LIGHTING) {
-	 ctx->TriangleCaps &= ~(DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
-	 if (ctx->Light.Enabled) {
-	    if (ctx->Light.Model.TwoSide)
-	       ctx->TriangleCaps |= (DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
-	    gl_update_lighting(ctx);
-	 }
+      if (!texUnit->_ReallyEnabled && (texUnit->Enabled & TEXTURE0_1D)) {
+         struct gl_texture_object *texObj = texUnit->Current1D;
+         if (!texObj->Complete) {
+            _mesa_test_texobj_completeness(ctx, texObj);
+         }
+         if (texObj->Complete) {
+            texUnit->_ReallyEnabled = TEXTURE0_1D;
+            texUnit->_Current = texObj;
+         }
       }
-   }
 
-   if (ctx->NewState & (NEW_POLYGON | NEW_LIGHTING)) {
+      if (!texUnit->_ReallyEnabled) {
+	 texUnit->_Current = NULL;
+	 continue;
+      }
 
-      ctx->TriangleCaps &= ~DD_TRI_CULL_FRONT_BACK;
+      {
+	 GLuint flag = texUnit->_ReallyEnabled << (i * NUM_TEXTURE_TARGETS);
+	 ctx->Texture._ReallyEnabled |= flag;
+      }
 
-      if (ctx->NewState & NEW_POLYGON) {
-	 /* Setup CullBits bitmask */
-	 if (ctx->Polygon.CullFlag) {
-	    ctx->backface_sign = 1;
-	    switch(ctx->Polygon.CullFaceMode) {
-	    case GL_BACK:
-	       if(ctx->Polygon.FrontFace==GL_CCW)
-		  ctx->backface_sign = -1;
-	       ctx->Polygon.CullBits = 1;
-	       break;
-	    case GL_FRONT:
-	       if(ctx->Polygon.FrontFace!=GL_CCW)
-		  ctx->backface_sign = -1;
-	       ctx->Polygon.CullBits = 2;
-	       break;
-	    default:
-	    case GL_FRONT_AND_BACK:
-	       ctx->backface_sign = 0;
-	       ctx->Polygon.CullBits = 0;
-	       ctx->TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
-	       break;
-	    }
+      if (texUnit->TexGenEnabled) {
+	 if (texUnit->TexGenEnabled & S_BIT) {
+	    texUnit->_GenFlags |= texUnit->_GenBitS;
 	 }
-	 else {
-	    ctx->Polygon.CullBits = 3;
-	    ctx->backface_sign = 0;
+	 if (texUnit->TexGenEnabled & T_BIT) {
+	    texUnit->_GenFlags |= texUnit->_GenBitT;
 	 }
-
-	 /* Any Polygon offsets enabled? */
-	 ctx->TriangleCaps &= ~DD_TRI_OFFSET;
+	 if (texUnit->TexGenEnabled & Q_BIT) {
+	    texUnit->_GenFlags |= texUnit->_GenBitQ;
+	 }
+	 if (texUnit->TexGenEnabled & R_BIT) {
+	    texUnit->_GenFlags |= texUnit->_GenBitR;
+	 }
 
-	 if (ctx->Polygon.OffsetPoint ||
-	     ctx->Polygon.OffsetLine ||
-	     ctx->Polygon.OffsetFill)
-	    ctx->TriangleCaps |= DD_TRI_OFFSET;
+	 ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(i);
+	 ctx->Texture._GenFlags |= texUnit->_GenFlags;
       }
+
+      if (ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
+	 ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(i);
    }
 
-   if (ctx->NewState & ~(NEW_CLIENT_STATE|
-			 NEW_DRIVER_STATE|NEW_USER_CLIP|
-			 NEW_POLYGON))
-      gl_update_clipmask(ctx);
-
-   if (ctx->NewState & (NEW_LIGHTING|
-			NEW_RASTER_OPS|
-			NEW_TEXTURING|
-			NEW_TEXTURE_ENABLE|
-			NEW_TEXTURE_ENV|
-			NEW_POLYGON|
-			NEW_DRVSTATE0|
-			NEW_DRVSTATE1|
-			NEW_DRVSTATE2|
-			NEW_DRVSTATE3|
-			NEW_USER_CLIP))
-   {
-      ctx->IndirectTriangles = ctx->TriangleCaps & ~ctx->Driver.TriangleCaps;
-      ctx->IndirectTriangles |= DD_SW_RASTERIZE;
-
-      if (MESA_VERBOSE&VERBOSE_CULL)
-	 gl_print_tri_caps("initial indirect tris", ctx->IndirectTriangles);
-
-      ctx->Driver.PointsFunc = NULL;
-      ctx->Driver.LineFunc = NULL;
-      ctx->Driver.TriangleFunc = NULL;
-      ctx->Driver.QuadFunc = NULL;
-      ctx->Driver.RectFunc = NULL;
-      ctx->Driver.RenderVBClippedTab = NULL;
-      ctx->Driver.RenderVBCulledTab = NULL;
-      ctx->Driver.RenderVBRawTab = NULL;
-
-      /*
-       * Here the driver sets up all the ctx->Driver function pointers to
-       * it's specific, private functions.
-       */
-      ctx->Driver.UpdateState(ctx);
+   if (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS) {
+      ctx->_NeedNormals |= NEED_NORMALS_TEXGEN;
+      ctx->_NeedEyeCoords |= NEED_EYE_TEXGEN;
+   }
 
-      if (MESA_VERBOSE&VERBOSE_CULL)
-	 gl_print_tri_caps("indirect tris", ctx->IndirectTriangles);
+   if (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD) {
+      ctx->_NeedEyeCoords |= NEED_EYE_TEXGEN;
+   }
+}
 
-      /*
-       * In case the driver didn't hook in an optimized point, line or
-       * triangle function we'll now select "core/fallback" point, line
-       * and triangle functions.
-       */
-      if (ctx->IndirectTriangles & DD_SW_RASTERIZE) {
-	 gl_set_point_function(ctx);
-	 gl_set_line_function(ctx);
-	 gl_set_triangle_function(ctx);
-	 gl_set_quad_function(ctx);
-
-	 if ((ctx->IndirectTriangles & 
-	      (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE|DD_TRI_CULL)) ==
-	     (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE|DD_TRI_CULL)) 
-	    ctx->IndirectTriangles &= ~DD_TRI_CULL;
-      }
 
-      if (MESA_VERBOSE&VERBOSE_CULL)
-	 gl_print_tri_caps("indirect tris 2", ctx->IndirectTriangles);
+/*
+ * If ctx->NewState is non-zero then this function MUST be called before
+ * rendering any primitive.  Basically, function pointers and miscellaneous
+ * flags are updated to reflect the current state of the state machine.
+ *
+ * The above constraint is now maintained largely by the two Exec
+ * dispatch tables, which trigger the appropriate flush on transition
+ * between State and Geometry modes.
+ *
+ * Special care is taken with the derived value _NeedEyeCoords.  This
+ * is a bitflag which is updated with information from a number of
+ * attribute groups (MODELVIEW, LIGHT, TEXTURE).  A lot of derived
+ * state references this value, and must be treated with care to
+ * ensure that updates are done correctly.  All state dependent on
+ * _NeedEyeCoords is calculated from within _mesa_update_tnl_spaces(),
+ * and from nowhere else.
+ */
+void _mesa_update_state( GLcontext *ctx )
+{
+   const GLuint new_state = ctx->NewState;
+   const GLuint oldneedeyecoords = ctx->_NeedEyeCoords;
 
-      gl_set_render_vb_function(ctx);
-   }
+   if (MESA_VERBOSE & VERBOSE_STATE)
+      _mesa_print_state("_mesa_update_state", new_state);
 
-   /* Should only be calc'd when !need_eye_coords and not culling.
-    */
-   if (ctx->NewState & (NEW_MODELVIEW|NEW_PROJECTION)) {
-      if (ctx->NewState & NEW_MODELVIEW) {
-	 gl_matrix_analyze( &ctx->ModelView );
-	 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
-      }
+   if (new_state & _NEW_MODELVIEW)
+      _math_matrix_analyse( &ctx->ModelView );
 
-      if (ctx->NewState & NEW_PROJECTION) {
-	 gl_matrix_analyze( &ctx->ProjectionMatrix );
-	 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
+   if (new_state & _NEW_PROJECTION)
+      update_projection( ctx );
 
-	 if (ctx->Transform.AnyClip) {
-	    gl_update_userclip( ctx );
-	 }
-      }
+   if (new_state & _NEW_TEXTURE_MATRIX)
+      update_texture_matrices( ctx );
 
-      gl_calculate_model_project_matrix( ctx );
-      ctx->ModelProjectWinMatrixUptodate = 0;
-   }
+   if (new_state & _NEW_COLOR_MATRIX)
+      _math_matrix_analyse( &ctx->ColorMatrix );
 
-   if (ctx->NewState & NEW_COLOR_MATRIX) {
-      gl_matrix_analyze( &ctx->ColorMatrix );
-   }
+   /* References ColorMatrix.type (derived above).
+    */
+   if (new_state & _IMAGE_NEW_TRANSFER_STATE)
+      update_image_transfer_state(ctx);
 
-   /* Figure out whether we can light in object space or not.  If we
-    * can, find the current positions of the lights in object space
+   /* Contributes to NeedEyeCoords, NeedNormals.
     */
-   if ((ctx->Enabled & (ENABLE_POINT_ATTEN | ENABLE_LIGHT | ENABLE_FOG |
-			ENABLE_TEXGEN0 | ENABLE_TEXGEN1)) &&
-       (ctx->NewState & (NEW_LIGHTING | 
-                         NEW_FOG |
-			 NEW_MODELVIEW | 
-			 NEW_PROJECTION |
-			 NEW_TEXTURING |
-			 NEW_RASTER_OPS |
-			 NEW_USER_CLIP)))
-   {
-      GLboolean oldcoord, oldnorm;
-
-      oldcoord = ctx->NeedEyeCoords;
-      oldnorm = ctx->NeedEyeNormals;
-
-      ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
-      ctx->NeedEyeCoords = ((ctx->Fog.Enabled && ctx->Hint.Fog != GL_NICEST) ||
-			    ctx->Point.Attenuated);
-      ctx->NeedEyeNormals = GL_FALSE;
-
-      if (ctx->Light.Enabled) {
-	 if ((ctx->Light.Flags & LIGHT_POSITIONAL) ||
-             ctx->Light.NeedVertices ||
-             !TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING)) {
-            /* Need length for attenuation or need angle for spotlights
-             * or non-uniform scale matrix
-             */
-            ctx->NeedEyeCoords = GL_TRUE;
-	 }
-	 ctx->NeedEyeNormals = ctx->NeedEyeCoords;
-      }
-      if (ctx->Texture.ReallyEnabled || ctx->RenderMode==GL_FEEDBACK) {
-	 if (ctx->Texture.NeedEyeCoords)
-            ctx->NeedEyeCoords = GL_TRUE;
-	 if (ctx->Texture.NeedNormals)
-	    ctx->NeedNormals = ctx->NeedEyeNormals = GL_TRUE;
-      }
+   if (new_state & _NEW_TEXTURE)
+      update_texture_state( ctx );
 
-      ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
+   if (new_state & (_NEW_BUFFERS|_NEW_SCISSOR))
+      update_drawbuffer( ctx );
 
-      if (ctx->NeedEyeCoords)
-	 ctx->vb_proj_matrix = &ctx->ProjectionMatrix;
+   if (new_state & _NEW_POLYGON)
+      update_polygon( ctx );
 
-      if (ctx->Light.Enabled) {
-	 gl_update_lighting_function(ctx);
+   /* Contributes to NeedEyeCoords, NeedNormals.
+    */
+   if (new_state & _NEW_LIGHT)
+      _mesa_update_lighting( ctx );
 
-	 if ( (ctx->NewState & NEW_LIGHTING) ||
-	      ((ctx->NewState & (NEW_MODELVIEW| NEW_PROJECTION)) &&
-	       !ctx->NeedEyeCoords) ||
-	      oldcoord != ctx->NeedEyeCoords ||
-	      oldnorm != ctx->NeedEyeNormals) {
-	    gl_compute_light_positions(ctx);
-	 }
+   /* We can light in object space if the modelview matrix preserves
+    * lengths and relative angles.
+    */
+   if (new_state & (_NEW_MODELVIEW|_NEW_LIGHT)) {
+      ctx->_NeedEyeCoords &= ~NEED_EYE_LIGHT_MODELVIEW;
+      if (ctx->Light.Enabled &&
+	  !TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING))
+	    ctx->_NeedEyeCoords |= NEED_EYE_LIGHT_MODELVIEW;
+   }
 
-	 ctx->rescale_factor = 1.0F;
+   /* Keep ModelviewProject uptodate always to allow tnl
+    * implementations that go model->clip even when eye is required.
+    */
+   if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
+      calculate_model_project_matrix(ctx);
 
-	 if (ctx->ModelView.flags & (MAT_FLAG_UNIFORM_SCALE |
-				     MAT_FLAG_GENERAL_SCALE |
-				     MAT_FLAG_GENERAL_3D |
-				     MAT_FLAG_GENERAL) )
-
-	 {
-	    GLfloat *m = ctx->ModelView.inv;
-	    GLfloat f = m[2]*m[2] + m[6]*m[6] + m[10]*m[10];
-	    if (f > 1e-12 && (f-1)*(f-1) > 1e-12)
-	       ctx->rescale_factor = 1.0/GL_SQRT(f);
-	 }
-      }
+
+   /* ctx->_NeedEyeCoords is now uptodate.
+    *
+    * If the truth value of this variable has changed, update for the
+    * new lighting space and recompute the positions of lights and the
+    * normal transform.
+    *
+    * If the lighting space hasn't changed, may still need to recompute
+    * light positions & normal transforms for other reasons.
+    */
+   if (new_state & (_NEW_MODELVIEW |
+		    _NEW_LIGHT |
+		    _MESA_NEW_NEED_EYE_COORDS))
+      update_tnl_spaces( ctx, oldneedeyecoords );
+
+   /*
+    * Here the driver sets up all the ctx->Driver function pointers
+    * to it's specific, private functions, and performs any
+    * internal state management necessary, including invalidating
+    * state of active modules.
+    *
+    * Set ctx->NewState to zero to avoid recursion if
+    * Driver.UpdateState() has to call FLUSH_VERTICES().  (fixed?)
+    */
+   ctx->NewState = 0;
+   ctx->Driver.UpdateState(ctx, new_state);
+   ctx->Array.NewState = 0;
 
-      gl_update_normal_transform( ctx );
+   /* At this point we can do some assertions to be sure the required
+    * device driver function pointers are all initialized.
+    */
+   ASSERT(ctx->Driver.GetString);
+   ASSERT(ctx->Driver.UpdateState);
+   ASSERT(ctx->Driver.Clear);
+   ASSERT(ctx->Driver.SetDrawBuffer);
+   ASSERT(ctx->Driver.GetBufferSize);
+   if (ctx->Visual.accumRedBits > 0) {
+      ASSERT(ctx->Driver.Accum);
+   }
+   ASSERT(ctx->Driver.DrawPixels);
+   ASSERT(ctx->Driver.ReadPixels);
+   ASSERT(ctx->Driver.CopyPixels);
+   ASSERT(ctx->Driver.Bitmap);
+   ASSERT(ctx->Driver.ResizeBuffers);
+   ASSERT(ctx->Driver.TexImage1D);
+   ASSERT(ctx->Driver.TexImage2D);
+   ASSERT(ctx->Driver.TexImage3D);
+   ASSERT(ctx->Driver.TexSubImage1D);
+   ASSERT(ctx->Driver.TexSubImage2D);
+   ASSERT(ctx->Driver.TexSubImage3D);
+   ASSERT(ctx->Driver.CopyTexImage1D);
+   ASSERT(ctx->Driver.CopyTexImage2D);
+   ASSERT(ctx->Driver.CopyTexSubImage1D);
+   ASSERT(ctx->Driver.CopyTexSubImage2D);
+   ASSERT(ctx->Driver.CopyTexSubImage3D);
+   if (ctx->Extensions.ARB_texture_compression) {
+      ASSERT(ctx->Driver.BaseCompressedTexFormat);
+      ASSERT(ctx->Driver.CompressedTextureSize);
+      ASSERT(ctx->Driver.GetCompressedTexImage);
+#if 0  /* HW drivers need these, but not SW rasterizers */
+      ASSERT(ctx->Driver.CompressedTexImage1D);
+      ASSERT(ctx->Driver.CompressedTexImage2D);
+      ASSERT(ctx->Driver.CompressedTexImage3D);
+      ASSERT(ctx->Driver.CompressedTexSubImage1D);
+      ASSERT(ctx->Driver.CompressedTexSubImage2D);
+      ASSERT(ctx->Driver.CompressedTexSubImage3D);
+#endif
    }
+}
 
-   gl_update_pipelines(ctx);
-   ctx->NewState = 0;
+/* Is this helpful?
+ */
+void
+_mesa_allow_light_in_model( GLcontext *ctx, GLboolean flag )
+{
+   if (flag) 
+      ctx->_NeedEyeCoords &= ~NEED_EYE_DRIVER;
+   else
+      ctx->_NeedEyeCoords |= NEED_EYE_DRIVER;
+
+   ctx->NewState |= _NEW_POINT;	/* one of the bits from
+				 * _MESA_NEW_NEED_EYE_COORDS.
+				 */
 }
Index: xc/extras/Mesa/src/state.h
diff -u xc/extras/Mesa/src/state.h:1.2 xc/extras/Mesa/src/state.h:1.3
--- xc/extras/Mesa/src/state.h:1.2	Fri Jun 16 20:02:16 2000
+++ xc/extras/Mesa/src/state.h	Fri Feb 22 14:25:40 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -27,7 +27,7 @@
 #ifndef STATE_H
 #define STATE_H
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
@@ -36,15 +36,16 @@
 extern void
 _mesa_init_exec_table(struct _glapi_table *exec, GLuint tableSize);
 
-
-extern void gl_update_state( GLcontext *ctx );
-
+extern void
+_mesa_update_state( GLcontext *ctx );
 
-/* for debugging */
-extern void gl_print_state( const char *msg, GLuint state );
+extern void
+_mesa_print_state( const char *msg, GLuint state );
 
-/* for debugging */
-extern void gl_print_enable_flags( const char *msg, GLuint flags );
+extern void
+_mesa_print_enable_flags( const char *msg, GLuint flags );
 
+extern void
+_mesa_allow_light_in_model( GLcontext *ctx, GLboolean flag );
 
 #endif
Index: xc/extras/Mesa/src/stencil.c
diff -u xc/extras/Mesa/src/stencil.c:1.8 xc/extras/Mesa/src/stencil.c:1.9
--- xc/extras/Mesa/src/stencil.c:1.8	Mon Jan  7 13:17:03 2002
+++ xc/extras/Mesa/src/stencil.c	Fri Feb 22 14:25:40 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4.2
- * 
+ * Version:  3.5
+ *
  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -30,10 +30,10 @@
 #include "glheader.h"
 #include "context.h"
 #include "depth.h"
+#include "macros.h"
 #include "mem.h"
-#include "pb.h"
 #include "stencil.h"
-#include "types.h"
+#include "mtypes.h"
 #include "enable.h"
 #endif
 
@@ -44,7 +44,12 @@
 _mesa_ClearStencil( GLint s )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClearStencil");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->Stencil.Clear == (GLstencil) s)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_STENCIL);
    ctx->Stencil.Clear = (GLstencil) s;
 
    if (ctx->Driver.ClearStencil) {
@@ -59,8 +64,7 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint maxref;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glStencilFunc");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (func) {
       case GL_NEVER:
@@ -71,15 +75,23 @@
       case GL_EQUAL:
       case GL_NOTEQUAL:
       case GL_ALWAYS:
-         ctx->Stencil.Function = func;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glStencilFunc" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glStencilFunc" );
          return;
    }
 
    maxref = (1 << STENCIL_BITS) - 1;
-   ctx->Stencil.Ref = (GLstencil) CLAMP( ref, 0, maxref );
+   ref = (GLstencil) CLAMP( ref, 0, maxref );
+
+   if (ctx->Stencil.Function == func &&
+       ctx->Stencil.ValueMask == (GLstencil) mask &&
+       ctx->Stencil.Ref == ref)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_STENCIL);
+   ctx->Stencil.Function = func;
+   ctx->Stencil.Ref = ref;
    ctx->Stencil.ValueMask = (GLstencil) mask;
 
    if (ctx->Driver.StencilFunc) {
@@ -93,7 +105,12 @@
 _mesa_StencilMask( GLuint mask )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glStencilMask");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->Stencil.WriteMask == (GLstencil) mask)
+	 return;
+
+   FLUSH_VERTICES(ctx, _NEW_STENCIL);
    ctx->Stencil.WriteMask = (GLstencil) mask;
 
    if (ctx->Driver.StencilMask) {
@@ -104,10 +121,11 @@
 
 
 void
-_mesa_StencilOp( GLenum fail, GLenum zfail, GLenum zpass )
+_mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glStencilOp");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
    switch (fail) {
       case GL_KEEP:
       case GL_ZERO:
@@ -115,12 +133,15 @@
       case GL_INCR:
       case GL_DECR:
       case GL_INVERT:
+         break;
       case GL_INCR_WRAP_EXT:
       case GL_DECR_WRAP_EXT:
-         ctx->Stencil.FailFunc = fail;
-         break;
+         if (!ctx->Extensions.EXT_stencil_wrap) {
+            break;
+         }
+         /* FALL-THROUGH */
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" );
+         _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp");
          return;
    }
    switch (zfail) {
@@ -130,1296 +151,47 @@
       case GL_INCR:
       case GL_DECR:
       case GL_INVERT:
-      case GL_INCR_WRAP_EXT:
-      case GL_DECR_WRAP_EXT:
-         ctx->Stencil.ZFailFunc = zfail;
          break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" );
-         return;
-   }
-   switch (zpass) {
-      case GL_KEEP:
-      case GL_ZERO:
-      case GL_REPLACE:
-      case GL_INCR:
-      case GL_DECR:
-      case GL_INVERT:
       case GL_INCR_WRAP_EXT:
       case GL_DECR_WRAP_EXT:
-         ctx->Stencil.ZPassFunc = zpass;
-         break;
+         if (ctx->Extensions.EXT_stencil_wrap) {
+            break;
+         }
+         /* FALL-THROUGH */
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glStencilOp" );
+         _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp");
          return;
    }
-
-   if (ctx->Driver.StencilOp) {
-      (*ctx->Driver.StencilOp)( ctx, fail, zfail, zpass );
-   }
-}
-
-
-
-/* Stencil Logic:
-
-IF stencil test fails THEN
-   Apply fail-op to stencil value   
-   Don't write the pixel (RGBA,Z)
-ELSE
-   IF doing depth test && depth test fails THEN
-      Apply zfail-op to stencil value   
-      Write RGBA and Z to appropriate buffers
-   ELSE
-      Apply zpass-op to stencil value
-ENDIF
-
-*/
-
-
-
-
-/*
- * Return the address of a stencil buffer value given the window coords:
- */
-#define STENCIL_ADDRESS(X,Y)  \
-       (ctx->DrawBuffer->Stencil + ctx->DrawBuffer->Width * (Y) + (X))
-
-
-
-/*
- * Apply the given stencil operator to the array of stencil values.
- * Don't touch stencil[i] if mask[i] is zero.
- * Input:  n - size of stencil array
- *         oper - the stencil buffer operator
- *         stencil - array of stencil values
- *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator
- * Output:  stencil - modified values
- */
-static void apply_stencil_op( const GLcontext *ctx, GLenum oper,
-                              GLuint n, GLstencil stencil[],
-                              const GLubyte mask[] )
-{
-   const GLstencil ref = ctx->Stencil.Ref;
-   const GLstencil wrtmask = ctx->Stencil.WriteMask;
-   const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
-   GLuint i;
-
-   switch (oper) {
+   switch (zpass) {
       case GL_KEEP:
-         /* do nothing */
-         break;
       case GL_ZERO:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  stencil[i] = 0;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  stencil[i] = (GLstencil) (stencil[i] & invmask);
-	       }
-	    }
-	 }
-	 break;
       case GL_REPLACE:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  stencil[i] = ref;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  stencil[i] = (GLstencil) ((invmask & s ) | (wrtmask & ref));
-	       }
-	    }
-	 }
-	 break;
       case GL_INCR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  if (s < STENCIL_MAX) {
-		     stencil[i] = (GLstencil) (s+1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  /* VERIFY logic of adding 1 to a write-masked value */
-		  GLstencil s = stencil[i];
-		  if (s < STENCIL_MAX) {
-		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
       case GL_DECR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  if (s>0) {
-		     stencil[i] = (GLstencil) (s-1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  /* VERIFY logic of subtracting 1 to a write-masked value */
-		  GLstencil s = stencil[i];
-		  if (s>0) {
-		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_INCR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  stencil[i]++;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil s = stencil[i];
-                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
-	       }
-	    }
-	 }
-	 break;
-      case GL_DECR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  stencil[i]--;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil s = stencil[i];
-                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
-	       }
-	    }
-	 }
-	 break;
       case GL_INVERT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  stencil[i] = (GLstencil) ~s;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-		  GLstencil s = stencil[i];
-		  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & ~s));
-	       }
-	    }
-	 }
-	 break;
-      default:
-         gl_problem(ctx, "Bad stencil op in apply_stencil_op");
-   }
-}
-
-
-
-
-/*
- * Apply stencil test to an array of stencil values (before depth buffering).
- * Input:  n - number of pixels in the array
- *         stencil - array of [n] stencil values
- *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel
- * Output:  mask - pixels which fail the stencil test will have their
- *                 mask flag set to 0.
- *          stencil - updated stencil values (where the test passed)
- * Return:  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
- */
-static GLboolean
-do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
-                 GLubyte mask[] )
-{
-   GLubyte fail[PB_SIZE];
-   GLboolean allfail = GL_FALSE;
-   GLuint i;
-   GLstencil r, s;
-
-   ASSERT(n <= PB_SIZE);
-
-   /*
-    * Perform stencil test.  The results of this operation are stored
-    * in the fail[] array:
-    *   IF fail[i] is non-zero THEN
-    *       the stencil fail operator is to be applied
-    *   ELSE
-    *       the stencil fail operator is not to be applied
-    *   ENDIF
-    */
-   switch (ctx->Stencil.Function) {
-      case GL_NEVER:
-         /* always fail */
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       mask[i] = 0;
-	       fail[i] = 1;
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 allfail = GL_TRUE;
-	 break;
-      case GL_LESS:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
-	       if (r < s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
-	       if (r <= s) {
-		  /* pass */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
-	       if (r > s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
-	       if (r >= s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
-	       if (r == s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
-	       if (r != s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 /* always pass */
-	 for (i=0;i<n;i++) {
-	    fail[i] = 0;
-	 }
-	 break;
-      default:
-         gl_problem(ctx, "Bad stencil func in gl_stencil_span");
-         return 0;
-   }
-
-   if (ctx->Stencil.FailFunc != GL_KEEP) {
-      apply_stencil_op( ctx, ctx->Stencil.FailFunc, n, stencil, fail );
-   }
-
-   return !allfail;
-}
-
-
-
-
-/*
- * Apply stencil and depth testing to an array of pixels.
- * Hardware or software stencil buffer acceptable.
- * Input:  n - number of pixels in the span
- *         z - array [n] of z values
- *         stencil - array [n] of stencil values
- *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
- * Output:  stencil - modified stencil values
- *          mask - array [n] of flags (1=stencil and depth test passed)
- * Return: GL_TRUE - all fragments failed the testing
- *         GL_FALSE - one or more fragments passed the testing
- * 
- */
-static GLboolean
-stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                        const GLdepth z[], GLstencil stencil[],
-                        GLubyte mask[] )
-{
-   ASSERT(ctx->Stencil.Enabled);
-   ASSERT(n <= PB_SIZE);
-
-   /*
-    * Apply the stencil test to the fragments.
-    * failMask[i] is 1 if the stencil test failed.
-    */
-   if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) {
-      /* all fragments failed the stencil test, we're done. */
-      return GL_FALSE;
-   }
-
-
-   /*
-    * Some fragments passed the stencil test, apply depth test to them
-    * and apply Zpass and Zfail stencil ops.
-    */
-   if (ctx->Depth.Test==GL_FALSE) {
-      /*
-       * No depth buffer, just apply zpass stencil function to active pixels.
-       */
-      apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, mask );
-   }
-   else {
-      /*
-       * Perform depth buffering, then apply zpass or zfail stencil function.
-       */
-      GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH];
-      GLuint i;
-
-      /* save the current mask bits */
-      MEMCPY(oldmask, mask, n * sizeof(GLubyte));
-
-      /* apply the depth test */
-      _mesa_depth_test_span(ctx, n, x, y, z, mask);
-
-      /* Set the stencil pass/fail flags according to result of depth testing.
-       * if oldmask[i] == 0 then
-       *    Don't touch the stencil value
-       * else if oldmask[i] and newmask[i] then
-       *    Depth test passed
-       * else
-       *    assert(oldmask[i] && !newmask[i])
-       *    Depth test failed
-       * endif
-       */
-      for (i=0;i<n;i++) {
-         ASSERT(mask[i] == 0 || mask[i] == 1);
-         passmask[i] = oldmask[i] & mask[i];
-         failmask[i] = oldmask[i] & (mask[i] ^ 1);
-      }
-
-      /* apply the pass and fail operations */
-      if (ctx->Stencil.ZFailFunc != GL_KEEP) {
-         apply_stencil_op( ctx, ctx->Stencil.ZFailFunc, n, stencil, failmask );
-      }
-      if (ctx->Stencil.ZPassFunc != GL_KEEP) {
-         apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, passmask );
-      }
-   }
-
-   return GL_TRUE;  /* one or more fragments passed both tests */
-}
-
-
-
-/*
- * Apply stencil and depth testing to the span of pixels.
- * Both software and hardware stencil buffers are acceptable.
- * Input:  n - number of pixels in the span
- *         x, y - location of leftmost pixel in span
- *         z - array [n] of z values
- *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
- * Output:  mask - array [n] of flags (1=stencil and depth test passed)
- * Return: GL_TRUE - all fragments failed the testing
- *         GL_FALSE - one or more fragments passed the testing
- * 
- */
-GLboolean
-_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                              const GLdepth z[], GLubyte mask[] )
-{
-   GLstencil stencilRow[MAX_WIDTH];
-   GLstencil *stencil;
-   GLboolean result;
-
-   ASSERT(ctx->Stencil.Enabled);
-   ASSERT(n <= MAX_WIDTH);
-
-   /* Get initial stencil values */
-   if (ctx->Driver.WriteStencilSpan) {
-      ASSERT(ctx->Driver.ReadStencilSpan);
-      /* Get stencil values from the hardware stencil buffer */
-      (*ctx->Driver.ReadStencilSpan)(ctx, n, x, y, stencilRow);
-      stencil = stencilRow;
-   }
-   else {
-      /* software stencil buffer */
-      stencil = STENCIL_ADDRESS(x, y);
-   }
-
-   /* do all the stencil/depth testing/updating */
-   result = stencil_and_ztest_span( ctx, n, x, y, z, stencil, mask );
-
-   if (ctx->Driver.WriteStencilSpan) {
-      /* Write updated stencil values into hardware stencil buffer */
-      (ctx->Driver.WriteStencilSpan)(ctx, n, x, y, stencil, mask );
-   }
-
-   return result;
-}
-
-
-
-
-/*
- * Apply the given stencil operator for each pixel in the array whose
- * mask flag is set.  This is for software stencil buffers only.
- * Input:  n - number of pixels in the span
- *         x, y - array of [n] pixels
- *         operator - the stencil buffer operator
- *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator
- */
-static void
-apply_stencil_op_to_pixels( const GLcontext *ctx,
-                            GLuint n, const GLint x[], const GLint y[],
-                            GLenum oper, const GLubyte mask[] )
-{
-   const GLstencil ref = ctx->Stencil.Ref;
-   const GLstencil wrtmask = ctx->Stencil.WriteMask;
-   const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
-   GLuint i;
-
-   ASSERT(!ctx->Driver.WriteStencilSpan);  /* software stencil buffer only! */
-
-   switch (oper) {
-      case GL_KEEP:
-         /* do nothing */
          break;
-      case GL_ZERO:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = 0;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  *sptr = (GLstencil) (invmask & *sptr);
-	       }
-	    }
-	 }
-	 break;
-      case GL_REPLACE:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = ref;
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  *sptr = (GLstencil) ((invmask & *sptr ) | (wrtmask & ref));
-	       }
-	    }
-	 }
-	 break;
-      case GL_INCR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr < STENCIL_MAX) {
-		     *sptr = (GLstencil) (*sptr + 1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr < STENCIL_MAX) {
-		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
-      case GL_DECR:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr>0) {
-		     *sptr = (GLstencil) (*sptr - 1);
-		  }
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-		  if (*sptr>0) {
-		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
-		  }
-	       }
-	    }
-	 }
-	 break;
       case GL_INCR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) (*sptr + 1);
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
-	       }
-	    }
-	 }
-	 break;
       case GL_DECR_WRAP_EXT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) (*sptr - 1);
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
-	       }
-	    }
-	 }
-	 break;
-      case GL_INVERT:
-	 if (invmask==0) {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) (~*sptr);
-	       }
-	    }
-	 }
-	 else {
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
-                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & ~*sptr));
-	       }
-	    }
-	 }
-	 break;
-      default:
-         gl_problem(ctx, "Bad stencilop in apply_stencil_op_to_pixels");
-   }
-}
-
-
-
-/*
- * Apply stencil test to an array of pixels before depth buffering.
- * Used for software stencil buffer only.
- * Input:  n - number of pixels in the span
- *         x, y - array of [n] pixels to stencil
- *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel
- * Output:  mask - pixels which fail the stencil test will have their
- *                 mask flag set to 0.
- * Return:  0 = all pixels failed, 1 = zero or more pixels passed.
- */
-static GLboolean
-stencil_test_pixels( GLcontext *ctx, GLuint n,
-                     const GLint x[], const GLint y[], GLubyte mask[] )
-{
-   GLubyte fail[PB_SIZE];
-   GLstencil r, s;
-   GLuint i;
-   GLboolean allfail = GL_FALSE;
-
-   ASSERT(!ctx->Driver.WriteStencilSpan);  /* software stencil buffer only! */
-
-   /*
-    * Perform stencil test.  The results of this operation are stored
-    * in the fail[] array:
-    *   IF fail[i] is non-zero THEN
-    *       the stencil fail operator is to be applied
-    *   ELSE
-    *       the stencil fail operator is not to be applied
-    *   ENDIF
-    */
-
-   switch (ctx->Stencil.Function) {
-      case GL_NEVER:
-         /* always fail */
-         for (i=0;i<n;i++) {
-	    if (mask[i]) {
-	       mask[i] = 0;
-	       fail[i] = 1;
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 allfail = GL_TRUE;
-	 break;
-      case GL_LESS:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
-	       if (r < s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_LEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
-	       if (r <= s) {
-		  /* pass */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GREATER:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
-	       if (r > s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_GEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
-	       if (r >= s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_EQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
-	       if (r == s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_NOTEQUAL:
-	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
-	 for (i=0;i<n;i++) {
-	    if (mask[i]) {
-               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
-	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
-	       if (r != s) {
-		  /* passed */
-		  fail[i] = 0;
-	       }
-	       else {
-		  fail[i] = 1;
-		  mask[i] = 0;
-	       }
-	    }
-	    else {
-	       fail[i] = 0;
-	    }
-	 }
-	 break;
-      case GL_ALWAYS:
-	 /* always pass */
-	 for (i=0;i<n;i++) {
-	    fail[i] = 0;
-	 }
-	 break;
-      default:
-         gl_problem(ctx, "Bad stencil func in gl_stencil_pixels");
-         return 0;
-   }
-
-   if (ctx->Stencil.FailFunc != GL_KEEP) {
-      apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc, fail );
-   }
-
-   return !allfail;
-}
-
-
-
-
-/*
- * Apply stencil and depth testing to an array of pixels.
- * This is used both for software and hardware stencil buffers.
- *
- * The comments in this function are a bit sparse but the code is
- * almost identical to stencil_and_ztest_span(), which is well
- * commented.
- * 
- * Input:  n - number of pixels in the array
- *         x, y - array of [n] pixel positions
- *         z - array [n] of z values
- *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
- * Output: mask - array [n] of flags (1=stencil and depth test passed)
- * Return: GL_TRUE - all fragments failed the testing
- *         GL_FALSE - one or more fragments passed the testing
- */
-GLboolean
-_mesa_stencil_and_ztest_pixels( GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-                                const GLdepth z[], GLubyte mask[] )
-{
-   ASSERT(ctx->Stencil.Enabled);
-   ASSERT(n <= PB_SIZE);
-
-   if (ctx->Driver.WriteStencilPixels) {
-      /*** Hardware stencil buffer ***/
-      GLstencil stencil[PB_SIZE];
-      GLubyte origMask[PB_SIZE];
-
-      ASSERT(ctx->Driver.ReadStencilPixels);
-      (*ctx->Driver.ReadStencilPixels)(ctx, n, x, y, stencil);
-
-      MEMCPY(origMask, mask, n * sizeof(GLubyte));
-
-      (void) do_stencil_test( ctx, n, stencil, mask );
-
-      if (ctx->Depth.Test == GL_FALSE) {
-         apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, mask );
-      }
-      else {
-         _mesa_depth_test_pixels(ctx, n, x, y, z, mask);
-
-         if (ctx->Stencil.ZFailFunc != GL_KEEP) {
-            GLubyte failmask[PB_SIZE];
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               ASSERT(mask[i] == 0 || mask[i] == 1);
-               failmask[i] = origMask[i] & (mask[i] ^ 1);
-            }
-            apply_stencil_op(ctx, ctx->Stencil.ZFailFunc, n, stencil, failmask);
-         }
-         if (ctx->Stencil.ZPassFunc != GL_KEEP) {
-            GLubyte passmask[PB_SIZE];
-            GLuint i;
-            for (i = 0; i < n; i++) {
-               ASSERT(mask[i] == 0 || mask[i] == 1);
-               passmask[i] = origMask[i] & mask[i];
-            }
-            apply_stencil_op(ctx, ctx->Stencil.ZPassFunc, n, stencil, passmask);
-         }
-      }
-
-      /* Write updated stencil values into hardware stencil buffer */
-      (ctx->Driver.WriteStencilPixels)(ctx, n, x, y, stencil, origMask );
-
-      return GL_TRUE;
-   }
-   else {
-      /*** Software stencil buffer ***/
-
-      if (stencil_test_pixels(ctx, n, x, y, mask) == GL_FALSE) {
-         /* all fragments failed the stencil test, we're done. */
-         return GL_FALSE;
-      }
-
-      if (ctx->Depth.Test==GL_FALSE) {
-         apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.ZPassFunc, mask );
-      }
-      else {
-         GLubyte passmask[PB_SIZE], failmask[PB_SIZE], oldmask[PB_SIZE];
-         GLuint i;
-
-         MEMCPY(oldmask, mask, n * sizeof(GLubyte));
-
-         _mesa_depth_test_pixels(ctx, n, x, y, z, mask);
-
-         for (i=0;i<n;i++) {
-            ASSERT(mask[i] == 0 || mask[i] == 1);
-            passmask[i] = oldmask[i] & mask[i];
-            failmask[i] = oldmask[i] & (mask[i] ^ 1);
-         }
-
-         if (ctx->Stencil.ZFailFunc != GL_KEEP) {
-            apply_stencil_op_to_pixels( ctx, n, x, y,
-                                        ctx->Stencil.ZFailFunc, failmask );
-         }
-         if (ctx->Stencil.ZPassFunc != GL_KEEP) {
-            apply_stencil_op_to_pixels( ctx, n, x, y,
-                                        ctx->Stencil.ZPassFunc, passmask );
+         if (ctx->Extensions.EXT_stencil_wrap) {
+            break;
          }
-      }
-
-      return GL_TRUE;  /* one or more fragments passed both tests */
-   }
-}
-
-
-
-/*
- * Return a span of stencil values from the stencil buffer.
- * Used for glRead/CopyPixels
- * Input:  n - how many pixels
- *         x,y - location of first pixel
- * Output:  stencil - the array of stencil values
- */
-void
-_mesa_read_stencil_span( GLcontext *ctx,
-                         GLint n, GLint x, GLint y, GLstencil stencil[] )
-{
-   if (y < 0 || y >= ctx->DrawBuffer->Height ||
-       x + n <= 0 || x >= ctx->DrawBuffer->Width) {
-      /* span is completely outside framebuffer */
-      return; /* undefined values OK */
-   }
-
-   if (x < 0) {
-      GLint dx = -x;
-      x = 0;
-      n -= dx;
-      stencil += dx;
-   }
-   if (x + n > ctx->DrawBuffer->Width) {
-      GLint dx = x + n - ctx->DrawBuffer->Width;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
-
-
-   ASSERT(n >= 0);
-   if (ctx->Driver.ReadStencilSpan) {
-      (*ctx->Driver.ReadStencilSpan)( ctx, (GLuint) n, x, y, stencil );
-   }
-   else if (ctx->DrawBuffer->Stencil) {
-      const GLstencil *s = STENCIL_ADDRESS( x, y );
-#if STENCIL_BITS == 8
-      MEMCPY( stencil, s, n * sizeof(GLstencil) );
-#else
-      GLuint i;
-      for (i=0;i<n;i++)
-         stencil[i] = s[i];
-#endif
-   }
-}
-
-
-
-/*
- * Write a span of stencil values to the stencil buffer.
- * Used for glDraw/CopyPixels
- * Input:  n - how many pixels
- *         x, y - location of first pixel
- *         stencil - the array of stencil values
- */
-void
-_mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
-                          const GLstencil stencil[] )
-{
-   const GLstencil *ssrc = stencil;
-
-   if (y < 0 || y >= ctx->DrawBuffer->Height ||
-       x + n <= 0 || x >= ctx->DrawBuffer->Width) {
-      /* span is completely outside framebuffer */
-      return; /* undefined values OK */
-   }
-
-   if (x < 0) {
-      GLint dx = -x;
-      x = 0;
-      n -= dx;
-      ssrc += dx;
-   }
-   if (x + n > ctx->DrawBuffer->Width) {
-      GLint dx = x + n - ctx->DrawBuffer->Width;
-      n -= dx;
-   }
-   if (n <= 0) {
-      return;
-   }
-
-   if (ctx->Driver.WriteStencilSpan) {
-      (*ctx->Driver.WriteStencilSpan)( ctx, n, x, y, ssrc, NULL );
-   }
-   else if (ctx->DrawBuffer->Stencil) {
-      GLstencil *s = STENCIL_ADDRESS( x, y );
-#if STENCIL_BITS == 8
-      MEMCPY( s, ssrc, n * sizeof(GLstencil) );
-#else
-      GLuint i;
-      for (i=0;i<n;i++)
-         s[i] = ssrc[i];
-#endif
-   }
-}
-
-
-
-/*
- * Allocate a new stencil buffer.  If there's an old one it will be
- * deallocated first.  The new stencil buffer will be uninitialized.
- */
-void
-_mesa_alloc_stencil_buffer( GLcontext *ctx )
-{
-   GLuint buffersize = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-
-   /* deallocate current stencil buffer if present */
-   if (ctx->DrawBuffer->Stencil) {
-      FREE(ctx->DrawBuffer->Stencil);
-      ctx->DrawBuffer->Stencil = NULL;
-   }
-
-   /* allocate new stencil buffer */
-   ctx->DrawBuffer->Stencil = (GLstencil *) MALLOC(buffersize * sizeof(GLstencil));
-   if (!ctx->DrawBuffer->Stencil) {
-      /* out of memory */
-      _mesa_set_enable( ctx, GL_STENCIL_TEST, GL_FALSE );
-      gl_error( ctx, GL_OUT_OF_MEMORY, "_mesa_alloc_stencil_buffer" );
+         /* FALL-THROUGH */
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glStencilOp");
+         return;
    }
-}
-
-
 
-/*
- * Clear the software (malloc'd) stencil buffer.
- */
-static void
-clear_software_stencil_buffer( GLcontext *ctx )
-{
-   if (ctx->Visual->StencilBits==0 || !ctx->DrawBuffer->Stencil) {
-      /* no stencil buffer */
+   if (ctx->Stencil.ZFailFunc == zfail &&
+       ctx->Stencil.ZPassFunc == zpass &&
+       ctx->Stencil.FailFunc == fail)
       return;
-   }
-
-   if (ctx->Scissor.Enabled) {
-      /* clear scissor region only */
-      const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
-         /* must apply mask to the clear */
-         GLint y;
-         for (y = ctx->DrawBuffer->Ymin; y <= ctx->DrawBuffer->Ymax; y++) {
-            const GLstencil mask = ctx->Stencil.WriteMask;
-            const GLstencil invMask = ~mask;
-            const GLstencil clearVal = (ctx->Stencil.Clear & mask);
-            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->Xmin, y );
-            GLint i;
-            for (i = 0; i < width; i++) {
-               stencil[i] = (stencil[i] & invMask) | clearVal;
-            }
-         }
-      }
-      else {
-         /* no masking */
-         GLint y;
-         for (y = ctx->DrawBuffer->Ymin; y <= ctx->DrawBuffer->Ymax; y++) {
-            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->Xmin, y );
-#if STENCIL_BITS==8
-            MEMSET( stencil, ctx->Stencil.Clear, width * sizeof(GLstencil) );
-#else
-            GLint i;
-            for (i = 0; i < width; i++)
-               stencil[x] = ctx->Stencil.Clear;
-#endif
-         }
-      }
-   }
-   else {
-      /* clear whole stencil buffer */
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
-         /* must apply mask to the clear */
-         const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-         GLstencil *stencil = ctx->DrawBuffer->Stencil;
-         const GLstencil mask = ctx->Stencil.WriteMask;
-         const GLstencil invMask = ~mask;
-         const GLstencil clearVal = (ctx->Stencil.Clear & mask);
-         GLuint i;
-         for (i = 0; i < n; i++) {
-            stencil[i] = (stencil[i] & invMask) | clearVal;
-         }
-      }
-      else {
-         /* clear whole buffer without masking */
-         const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
-         GLstencil *stencil = ctx->DrawBuffer->Stencil;
-
-#if STENCIL_BITS==8
-         MEMSET(stencil, ctx->Stencil.Clear, n * sizeof(GLstencil) );
-#else
-         GLuint i;
-         for (i = 0; i < n; i++) {
-            stencil[i] = ctx->Stencil.Clear;
-         }
-#endif
-      }
-   }
-}
-
 
-
-/*
- * Clear the hardware (in graphics card) stencil buffer.
- * This is done with the Driver.WriteStencilSpan() and Driver.ReadStencilSpan()
- * functions.
- * Actually, if there is a hardware stencil buffer it really should have
- * been cleared in Driver.Clear()!  However, if the hardware does not
- * support scissored clears or masked clears (i.e. glStencilMask) then
- * we have to use the span-based functions.
- */
-static void
-clear_hardware_stencil_buffer( GLcontext *ctx )
-{
-   ASSERT(ctx->Driver.WriteStencilSpan);
-   ASSERT(ctx->Driver.ReadStencilSpan);
+   FLUSH_VERTICES(ctx, _NEW_STENCIL);
+   ctx->Stencil.ZFailFunc = zfail;
+   ctx->Stencil.ZPassFunc = zpass;
+   ctx->Stencil.FailFunc = fail;
 
-   if (ctx->Scissor.Enabled) {
-      /* clear scissor region only */
-      const GLint x = ctx->DrawBuffer->Xmin;
-      const GLint width = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
-         /* must apply mask to the clear */
-         GLint y;
-         for (y = ctx->DrawBuffer->Ymin; y <= ctx->DrawBuffer->Ymax; y++) {
-            const GLstencil mask = ctx->Stencil.WriteMask;
-            const GLstencil invMask = ~mask;
-            const GLstencil clearVal = (ctx->Stencil.Clear & mask);
-            GLstencil stencil[MAX_WIDTH];
-            GLint i;
-            (*ctx->Driver.ReadStencilSpan)(ctx, width, x, y, stencil);
-            for (i = 0; i < width; i++) {
-               stencil[i] = (stencil[i] & invMask) | clearVal;
-            }
-            (*ctx->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
-         }
-      }
-      else {
-         /* no masking */
-         GLstencil stencil[MAX_WIDTH];
-         GLint y, i;
-         for (i = 0; i < width; i++) {
-            stencil[i] = ctx->Stencil.Clear;
-         }
-         for (y = ctx->DrawBuffer->Ymin; y <= ctx->DrawBuffer->Ymax; y++) {
-            (*ctx->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
-         }
-      }
-   }
-   else {
-      /* clear whole stencil buffer */
-      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
-         /* must apply mask to the clear */
-         const GLstencil mask = ctx->Stencil.WriteMask;
-         const GLstencil invMask = ~mask;
-         const GLstencil clearVal = (ctx->Stencil.Clear & mask);
-         const GLint width = ctx->DrawBuffer->Width;
-         const GLint height = ctx->DrawBuffer->Height;
-         const GLint x = ctx->DrawBuffer->Xmin;
-         GLint y;
-         for (y = 0; y < height; y++) {
-            GLstencil stencil[MAX_WIDTH];
-            GLuint i;
-            (*ctx->Driver.ReadStencilSpan)(ctx, width, x, y, stencil);
-            for (i = 0; i < width; i++) {
-               stencil[i] = (stencil[i] & invMask) | clearVal;
-            }
-            (*ctx->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
-         }
-      }
-      else {
-         /* clear whole buffer without masking */
-         const GLint width = ctx->DrawBuffer->Width;
-         const GLint height = ctx->DrawBuffer->Height;
-         const GLint x = ctx->DrawBuffer->Xmin;
-         GLstencil stencil[MAX_WIDTH];
-         GLint y, i;
-         for (i = 0; i < width; i++) {
-            stencil[i] = ctx->Stencil.Clear;
-         }
-         for (y = 0; y < height; y++) {
-            (*ctx->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
-         }
-      }
-   }
-}
-
-
-
-/*
- * Clear the stencil buffer.
- */
-void
-_mesa_clear_stencil_buffer( GLcontext *ctx )
-{
-   if (ctx->Driver.WriteStencilSpan) {
-      ASSERT(ctx->Driver.ReadStencilSpan);
-      clear_hardware_stencil_buffer(ctx);
-   }
-   else {
-      clear_software_stencil_buffer(ctx);
+   if (ctx->Driver.StencilOp) {
+      (*ctx->Driver.StencilOp)(ctx, fail, zfail, zpass);
    }
 }
-
Index: xc/extras/Mesa/src/stencil.h
diff -u xc/extras/Mesa/src/stencil.h:1.4 xc/extras/Mesa/src/stencil.h:1.5
--- xc/extras/Mesa/src/stencil.h:1.4	Fri Jun 16 20:02:16 2000
+++ xc/extras/Mesa/src/stencil.h	Fri Feb 22 14:25:40 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define STENCIL_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
@@ -46,34 +46,6 @@
 extern void
 _mesa_StencilOp( GLenum fail, GLenum zfail, GLenum zpass );
 
-
-
-extern GLboolean
-_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
-                              const GLdepth z[], GLubyte mask[] );
-
-extern GLboolean
-_mesa_stencil_and_ztest_pixels( GLcontext *ctx, GLuint n,
-                                const GLint x[], const GLint y[],
-                                const GLdepth z[], GLubyte mask[] );
-
-
-extern void
-_mesa_read_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
-                         GLstencil stencil[] );
-
-
-extern void
-_mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
-                          const GLstencil stencil[] );
-
-
-extern void
-_mesa_alloc_stencil_buffer( GLcontext *ctx );
-
-
-extern void
-_mesa_clear_stencil_buffer( GLcontext *ctx );
 
 
 #endif
Index: xc/extras/Mesa/src/texformat.c
diff -u xc/extras/Mesa/src/texformat.c:1.2 xc/extras/Mesa/src/texformat.c:1.5
--- xc/extras/Mesa/src/texformat.c:1.2	Tue Apr 10 12:07:48 2001
+++ xc/extras/Mesa/src/texformat.c	Mon Dec 16 11:18:27 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,235 +22,505 @@
  * 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.
  *
- * Author:
+ * Authors:
  *    Gareth Hughes <gareth@valinux.com>
+ *    Brian Paul
  */
 
 #ifdef PC_HEADER
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "image.h"
 #include "mem.h"
 #include "mmath.h"
-#include "span.h"
+#include "mtypes.h"
 #include "texformat.h"
 #include "teximage.h"
 #include "texstate.h"
-#include "types.h"
+#include "swrast/s_span.h"
 #endif
 
 
-/* ================================================================
- * Texture internal formats:
+/* Texel fetch routines for all supported formats:
  */
+#define DIM 1
+#include "texformat_tmp.h"
 
+#define DIM 2
+#include "texformat_tmp.h"
+
+#define DIM 3
+#include "texformat_tmp.h"
+
+/* Have to have this so the FetchTexel function pointer is never NULL.
+ */
+static void fetch_null_texel( const struct gl_texture_image *texImage,
+			      GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = 0;
+   rgba[GCOMP] = 0;
+   rgba[BCOMP] = 0;
+   rgba[ACOMP] = 0;
+}
+
+
+/* =============================================================
+ * Default GLchan-based formats:
+ */
+
+const struct gl_texture_format _mesa_texformat_rgba = {
+   MESA_FORMAT_RGBA,			/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   CHAN_TYPE,				/* Type */
+   CHAN_BITS,				/* RedBits */
+   CHAN_BITS,				/* GreenBits */
+   CHAN_BITS,				/* BlueBits */
+   CHAN_BITS,				/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   4 * CHAN_BITS / 8,			/* TexelBytes */
+   fetch_1d_texel_rgba,			/* FetchTexel1D */
+   fetch_2d_texel_rgba,			/* FetchTexel2D */
+   fetch_3d_texel_rgba,			/* FetchTexel3D */
+};
+
+const struct gl_texture_format _mesa_texformat_rgb = {
+   MESA_FORMAT_RGB,			/* MesaFormat */
+   GL_RGB,				/* BaseFormat */
+   CHAN_TYPE,				/* Type */
+   CHAN_BITS,				/* RedBits */
+   CHAN_BITS,				/* GreenBits */
+   CHAN_BITS,				/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   3 * CHAN_BITS / 8,			/* TexelBytes */
+   fetch_1d_texel_rgb,			/* FetchTexel1D */
+   fetch_2d_texel_rgb,			/* FetchTexel2D */
+   fetch_3d_texel_rgb,			/* FetchTexel3D */
+};
+
+const struct gl_texture_format _mesa_texformat_alpha = {
+   MESA_FORMAT_ALPHA,			/* MesaFormat */
+   GL_ALPHA,				/* BaseFormat */
+   CHAN_TYPE,				/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   CHAN_BITS,				/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   CHAN_BITS / 8,			/* TexelBytes */
+   fetch_1d_texel_alpha,		/* FetchTexel1D */
+   fetch_2d_texel_alpha,		/* FetchTexel2D */
+   fetch_3d_texel_alpha,		/* FetchTexel3D */
+};
+
+const struct gl_texture_format _mesa_texformat_luminance = {
+   MESA_FORMAT_LUMINANCE,		/* MesaFormat */
+   GL_LUMINANCE,			/* BaseFormat */
+   CHAN_TYPE,				/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   CHAN_BITS,				/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   CHAN_BITS / 8,			/* TexelBytes */
+   fetch_1d_texel_luminance,		/* FetchTexel1D */
+   fetch_2d_texel_luminance,		/* FetchTexel2D */
+   fetch_3d_texel_luminance,		/* FetchTexel3D */
+};
+
+const struct gl_texture_format _mesa_texformat_luminance_alpha = {
+   MESA_FORMAT_LUMINANCE_ALPHA,		/* MesaFormat */
+   GL_LUMINANCE_ALPHA,			/* BaseFormat */
+   CHAN_TYPE,				/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   CHAN_BITS,				/* AlphaBits */
+   CHAN_BITS,				/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   2 * CHAN_BITS / 8,			/* TexelBytes */
+   fetch_1d_texel_luminance_alpha,	/* FetchTexel1D */
+   fetch_2d_texel_luminance_alpha,	/* FetchTexel2D */
+   fetch_3d_texel_luminance_alpha,	/* FetchTexel3D */
+};
+
+const struct gl_texture_format _mesa_texformat_intensity = {
+   MESA_FORMAT_INTENSITY,		/* MesaFormat */
+   GL_INTENSITY,			/* BaseFormat */
+   CHAN_TYPE,				/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   CHAN_BITS,				/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   CHAN_BITS / 8,			/* TexelBytes */
+   fetch_1d_texel_intensity,		/* FetchTexel1D */
+   fetch_2d_texel_intensity,		/* FetchTexel2D */
+   fetch_3d_texel_intensity,		/* FetchTexel3D */
+};
+
+const struct gl_texture_format _mesa_texformat_color_index = {
+   MESA_FORMAT_COLOR_INDEX,		/* MesaFormat */
+   GL_COLOR_INDEX,			/* BaseFormat */
+   CHAN_TYPE,				/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   CHAN_BITS,				/* IndexBits */
+   0,					/* DepthBits */
+   CHAN_BITS / 8,			/* TexelBytes */
+   fetch_1d_texel_color_index,		/* FetchTexel1D */
+   fetch_2d_texel_color_index,		/* FetchTexel2D */
+   fetch_3d_texel_color_index,		/* FetchTexel3D */
+};
+
+const struct gl_texture_format _mesa_texformat_depth_component = {
+   MESA_FORMAT_DEPTH_COMPONENT,		/* MesaFormat */
+   GL_DEPTH_COMPONENT,			/* BaseFormat */
+   GL_FLOAT,				/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   sizeof(GLfloat) * 8,			/* DepthBits */
+   sizeof(GLfloat),			/* TexelBytes */
+   fetch_1d_texel_depth_component,	/* FetchTexel1D */
+   fetch_2d_texel_depth_component,	/* FetchTexel2D */
+   fetch_3d_texel_depth_component,	/* FetchTexel3D */
+};
+
+
+/* =============================================================
+ * Hardware formats:
+ */
+
 const struct gl_texture_format _mesa_texformat_rgba8888 = {
-   MESA_FORMAT_RGBA8888,	/* IntFormat */
-   8,				/* RedBits */
-   8,				/* GreenBits */
-   8,				/* BlueBits */
-   8,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   4,				/* TexelBytes */
-};
-
-const struct gl_texture_format _mesa_texformat_abgr8888 = {
-   MESA_FORMAT_ABGR8888,	/* IntFormat */
-   8,				/* RedBits */
-   8,				/* GreenBits */
-   8,				/* BlueBits */
-   8,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   4,				/* TexelBytes */
+   MESA_FORMAT_RGBA8888,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_INT_8_8_8_8,		/* Type */
+   8,					/* RedBits */
+   8,					/* GreenBits */
+   8,					/* BlueBits */
+   8,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   4,					/* TexelBytes */
+   fetch_1d_texel_rgba8888,		/* FetchTexel1D */
+   fetch_2d_texel_rgba8888,		/* FetchTexel2D */
+   fetch_3d_texel_rgba8888,		/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_argb8888 = {
-   MESA_FORMAT_ARGB8888,	/* IntFormat */
-   8,				/* RedBits */
-   8,				/* GreenBits */
-   8,				/* BlueBits */
-   8,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   4,				/* TexelBytes */
+   MESA_FORMAT_ARGB8888,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_INT_8_8_8_8_REV,		/* Type */
+   8,					/* RedBits */
+   8,					/* GreenBits */
+   8,					/* BlueBits */
+   8,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   4,					/* TexelBytes */
+   fetch_1d_texel_argb8888,		/* FetchTexel1D */
+   fetch_2d_texel_argb8888,		/* FetchTexel2D */
+   fetch_3d_texel_argb8888,		/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_rgb888 = {
-   MESA_FORMAT_RGB888,		/* IntFormat */
-   8,				/* RedBits */
-   8,				/* GreenBits */
-   8,				/* BlueBits */
-   0,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   3,				/* TexelBytes */
-};
-
-const struct gl_texture_format _mesa_texformat_bgr888 = {
-   MESA_FORMAT_BGR888,		/* IntFormat */
-   8,				/* RedBits */
-   8,				/* GreenBits */
-   8,				/* BlueBits */
-   0,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   3,				/* TexelBytes */
+   MESA_FORMAT_RGB888,			/* MesaFormat */
+   GL_RGB,				/* BaseFormat */
+   GL_UNSIGNED_BYTE,			/* Type */
+   8,					/* RedBits */
+   8,					/* GreenBits */
+   8,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   3,					/* TexelBytes */
+   fetch_1d_texel_rgb888,		/* FetchTexel1D */
+   fetch_2d_texel_rgb888,		/* FetchTexel2D */
+   fetch_3d_texel_rgb888,		/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_rgb565 = {
-   MESA_FORMAT_RGB565,		/* IntFormat */
-   5,				/* RedBits */
-   6,				/* GreenBits */
-   5,				/* BlueBits */
-   0,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   2,				/* TexelBytes */
+   MESA_FORMAT_RGB565,			/* MesaFormat */
+   GL_RGB,				/* BaseFormat */
+   GL_UNSIGNED_SHORT_5_6_5,		/* Type */
+   5,					/* RedBits */
+   6,					/* GreenBits */
+   5,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   2,					/* TexelBytes */
+   fetch_1d_texel_rgb565,		/* FetchTexel1D */
+   fetch_2d_texel_rgb565,		/* FetchTexel2D */
+   fetch_3d_texel_rgb565,		/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_argb4444 = {
-   MESA_FORMAT_ARGB4444,	/* IntFormat */
-   4,				/* RedBits */
-   4,				/* GreenBits */
-   4,				/* BlueBits */
-   4,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   2,				/* TexelBytes */
+   MESA_FORMAT_ARGB4444,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_SHORT_4_4_4_4_REV,	/* Type */
+   4,					/* RedBits */
+   4,					/* GreenBits */
+   4,					/* BlueBits */
+   4,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   2,					/* TexelBytes */
+   fetch_1d_texel_argb4444,		/* FetchTexel1D */
+   fetch_2d_texel_argb4444,		/* FetchTexel2D */
+   fetch_3d_texel_argb4444,		/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_argb1555 = {
-   MESA_FORMAT_ARGB1555,	/* IntFormat */
-   5,				/* RedBits */
-   5,				/* GreenBits */
-   5,				/* BlueBits */
-   1,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   2,				/* TexelBytes */
+   MESA_FORMAT_ARGB1555,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_SHORT_1_5_5_5_REV,	/* Type */
+   5,					/* RedBits */
+   5,					/* GreenBits */
+   5,					/* BlueBits */
+   1,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   2,					/* TexelBytes */
+   fetch_1d_texel_argb1555,		/* FetchTexel1D */
+   fetch_2d_texel_argb1555,		/* FetchTexel2D */
+   fetch_3d_texel_argb1555,		/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_al88 = {
-   MESA_FORMAT_AL88,		/* IntFormat */
-   0,				/* RedBits */
-   0,				/* GreenBits */
-   0,				/* BlueBits */
-   8,				/* AlphaBits */
-   8,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   2,				/* TexelBytes */
+   MESA_FORMAT_AL88,			/* MesaFormat */
+   GL_LUMINANCE_ALPHA,			/* BaseFormat */
+   GL_UNSIGNED_BYTE,			/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   8,					/* AlphaBits */
+   8,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   2,					/* TexelBytes */
+   fetch_1d_texel_al88,			/* FetchTexel1D */
+   fetch_2d_texel_al88,			/* FetchTexel2D */
+   fetch_3d_texel_al88,			/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_rgb332 = {
-   MESA_FORMAT_RGB332,		/* IntFormat */
-   3,				/* RedBits */
-   3,				/* GreenBits */
-   2,				/* BlueBits */
-   0,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   1,				/* TexelBytes */
+   MESA_FORMAT_RGB332,			/* MesaFormat */
+   GL_RGB,				/* BaseFormat */
+   GL_UNSIGNED_BYTE_3_3_2,		/* Type */
+   3,					/* RedBits */
+   3,					/* GreenBits */
+   2,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   1,					/* TexelBytes */
+   fetch_1d_texel_rgb332,		/* FetchTexel1D */
+   fetch_2d_texel_rgb332,		/* FetchTexel2D */
+   fetch_3d_texel_rgb332,		/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_a8 = {
-   MESA_FORMAT_A8,		/* IntFormat */
-   0,				/* RedBits */
-   0,				/* GreenBits */
-   0,				/* BlueBits */
-   8,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   1,				/* TexelBytes */
+   MESA_FORMAT_A8,			/* MesaFormat */
+   GL_ALPHA,				/* BaseFormat */
+   GL_UNSIGNED_BYTE,			/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   8,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   1,					/* TexelBytes */
+   fetch_1d_texel_a8,			/* FetchTexel1D */
+   fetch_2d_texel_a8,			/* FetchTexel2D */
+   fetch_3d_texel_a8,			/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_l8 = {
-   MESA_FORMAT_L8,		/* IntFormat */
-   0,				/* RedBits */
-   0,				/* GreenBits */
-   0,				/* BlueBits */
-   0,				/* AlphaBits */
-   8,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   1,				/* TexelBytes */
+   MESA_FORMAT_L8,			/* MesaFormat */
+   GL_LUMINANCE,			/* BaseFormat */
+   GL_UNSIGNED_BYTE,			/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   8,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   1,					/* TexelBytes */
+   fetch_1d_texel_l8,			/* FetchTexel1D */
+   fetch_2d_texel_l8,			/* FetchTexel2D */
+   fetch_3d_texel_l8,			/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_i8 = {
-   MESA_FORMAT_I8,		/* IntFormat */
-   0,				/* RedBits */
-   0,				/* GreenBits */
-   0,				/* BlueBits */
-   0,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   8,				/* IntensityBits */
-   0,				/* IndexBits */
-   1,				/* TexelBytes */
+   MESA_FORMAT_I8,			/* MesaFormat */
+   GL_INTENSITY,			/* BaseFormat */
+   GL_UNSIGNED_BYTE,			/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   8,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   1,					/* TexelBytes */
+   fetch_1d_texel_i8,			/* FetchTexel1D */
+   fetch_2d_texel_i8,			/* FetchTexel2D */
+   fetch_3d_texel_i8,			/* FetchTexel3D */
 };
 
 const struct gl_texture_format _mesa_texformat_ci8 = {
-   MESA_FORMAT_CI8,		/* IntFormat */
-   0,				/* RedBits */
-   0,				/* GreenBits */
-   0,				/* BlueBits */
-   0,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   8,				/* IndexBits */
-   1,				/* TexelBytes */
+   MESA_FORMAT_CI8,			/* MesaFormat */
+   GL_COLOR_INDEX,			/* BaseFormat */
+   GL_UNSIGNED_BYTE,			/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   8,					/* IndexBits */
+   0,					/* DepthBits */
+   1,					/* TexelBytes */
+   fetch_1d_texel_ci8,			/* FetchTexel1D */
+   fetch_2d_texel_ci8,			/* FetchTexel2D */
+   fetch_3d_texel_ci8,			/* FetchTexel3D */
 };
 
-const struct gl_texture_format _mesa_null_texformat = {
-   -1,				/* IntFormat */
-   0,				/* RedBits */
-   0,				/* GreenBits */
-   0,				/* BlueBits */
-   0,				/* AlphaBits */
-   0,				/* LuminanceBits */
-   0,				/* IntensityBits */
-   0,				/* IndexBits */
-   0,				/* TexelBytes */
+
+const struct gl_texture_format _mesa_texformat_ycbcr = {
+   MESA_FORMAT_YCBCR,			/* MesaFormat */
+   GL_YCBCR_MESA,			/* BaseFormat */
+   GL_UNSIGNED_SHORT_8_8_MESA,		/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   2,					/* TexelBytes */
+   fetch_1d_texel_ycbcr,		/* FetchTexel1D */
+   fetch_2d_texel_ycbcr,		/* FetchTexel2D */
+   fetch_3d_texel_ycbcr,		/* FetchTexel3D */
 };
 
 
+const struct gl_texture_format _mesa_texformat_ycbcr_rev = {
+   MESA_FORMAT_YCBCR_REV,		/* MesaFormat */
+   GL_YCBCR_MESA,			/* BaseFormat */
+   GL_UNSIGNED_SHORT_8_8_REV_MESA,	/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   2,					/* TexelBytes */
+   fetch_1d_texel_ycbcr_rev,		/* FetchTexel1D */
+   fetch_2d_texel_ycbcr_rev,		/* FetchTexel2D */
+   fetch_3d_texel_ycbcr_rev,		/* FetchTexel3D */
+};
 
-/*
- * Given an internal texture format enum or 1, 2, 3, 4 return the
- * corresponding _base_ internal format:  GL_ALPHA, GL_LUMINANCE,
- * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA.
- * Return -1 if invalid enum.
+
+
+/* =============================================================
+ * Null format:
  */
-void _mesa_init_texture_format( GLcontext *ctx,
-				struct gl_texture_image *texImage,
-				GLenum internalFormat )
+
+const struct gl_texture_format _mesa_null_texformat = {
+   -1,					/* MesaFormat */
+   0,					/* BaseFormat */
+   0,					/* Type */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* TexelBytes */
+   fetch_null_texel,			/* FetchTexel1D */
+   fetch_null_texel,			/* FetchTexel2D */
+   fetch_null_texel,			/* FetchTexel3D */
+};
+
+
+
+GLboolean
+_mesa_is_hardware_tex_format( const struct gl_texture_format *format )
 {
-   texImage->IntFormat = internalFormat;
+   return (format->MesaFormat < MESA_FORMAT_RGBA);
+}
 
-   /* Ask the driver for the base format, if it doesn't know, it will
-    * return -1;
-    */
-   if ( ctx->Driver.BaseCompressedTexFormat ) {
-      GLint format = 0;			/* Silence compiler warning */
-      format = (*ctx->Driver.BaseCompressedTexFormat)( ctx, format );
-      if ( format >= 0 ) {
-	 internalFormat = format;
-      }
-   }
 
+/* Given an internal texture format (or 1, 2, 3, 4) return a pointer
+ * to a gl_texture_format which which to store the texture.
+ * This is called via ctx->Driver.ChooseTextureFormat().
+ * Hardware drivers should not use this function, but instead a 
+ * specialized function.
+ */
+const struct gl_texture_format *
+_mesa_choose_tex_format( GLcontext *ctx, GLint internalFormat,
+                         GLenum format, GLenum type )
+{
+   (void) format;
+   (void) type;
+
    switch ( internalFormat ) {
       /* GH: Bias towards GL_RGB, GL_RGBA texture formats.  This has
        * got to be better than sticking them way down the end of this
@@ -258,15 +528,11 @@
        */
    case 4:				/* Quake3 uses this... */
    case GL_RGBA:
-      texImage->Format = GL_RGBA;
-      texImage->TexFormat = &_mesa_texformat_abgr8888;
-      break;
+      return &_mesa_texformat_rgba;
 
    case 3:				/* ... and this. */
    case GL_RGB:
-      texImage->Format = GL_RGB;
-      texImage->TexFormat = &_mesa_texformat_bgr888;
-      break;
+      return &_mesa_texformat_rgb;
 
       /* GH: Okay, keep checking as normal.  Still test for GL_RGB,
        * GL_RGBA formats first.
@@ -278,9 +544,7 @@
    case GL_RGB10_A2:
    case GL_RGBA12:
    case GL_RGBA16:
-      texImage->Format = GL_RGBA;
-      texImage->TexFormat = &_mesa_texformat_abgr8888;
-      break;
+      return &_mesa_texformat_rgba;
 
    case GL_R3_G3_B2:
    case GL_RGB4:
@@ -289,18 +553,14 @@
    case GL_RGB10:
    case GL_RGB12:
    case GL_RGB16:
-      texImage->Format = GL_RGB;
-      texImage->TexFormat = &_mesa_texformat_bgr888;
-      break;
+      return &_mesa_texformat_rgb;
 
    case GL_ALPHA:
    case GL_ALPHA4:
    case GL_ALPHA8:
    case GL_ALPHA12:
    case GL_ALPHA16:
-      texImage->Format = GL_ALPHA;
-      texImage->TexFormat = &_mesa_texformat_a8;
-      break;
+      return &_mesa_texformat_alpha;
 
    case 1:
    case GL_LUMINANCE:
@@ -308,9 +568,7 @@
    case GL_LUMINANCE8:
    case GL_LUMINANCE12:
    case GL_LUMINANCE16:
-      texImage->Format = GL_LUMINANCE;
-      texImage->TexFormat = &_mesa_texformat_l8;
-      break;
+      return &_mesa_texformat_luminance;
 
    case 2:
    case GL_LUMINANCE_ALPHA:
@@ -320,18 +578,14 @@
    case GL_LUMINANCE12_ALPHA4:
    case GL_LUMINANCE12_ALPHA12:
    case GL_LUMINANCE16_ALPHA16:
-      texImage->Format = GL_LUMINANCE_ALPHA;
-      texImage->TexFormat = &_mesa_texformat_al88;
-      break;
+      return &_mesa_texformat_luminance_alpha;
 
    case GL_INTENSITY:
    case GL_INTENSITY4:
    case GL_INTENSITY8:
    case GL_INTENSITY12:
    case GL_INTENSITY16:
-      texImage->Format = GL_INTENSITY;
-      texImage->TexFormat = &_mesa_texformat_i8;
-      break;
+      return &_mesa_texformat_intensity;
 
    case GL_COLOR_INDEX:
    case GL_COLOR_INDEX1_EXT:
@@ -340,12 +594,101 @@
    case GL_COLOR_INDEX8_EXT:
    case GL_COLOR_INDEX12_EXT:
    case GL_COLOR_INDEX16_EXT:
-      texImage->Format = GL_COLOR_INDEX;
-      texImage->TexFormat = &_mesa_texformat_ci8;
-      break;
+      return &_mesa_texformat_color_index;
+
+   case GL_DEPTH_COMPONENT:
+   case GL_DEPTH_COMPONENT16_SGIX:
+   case GL_DEPTH_COMPONENT24_SGIX:
+   case GL_DEPTH_COMPONENT32_SGIX:
+      if (!ctx->Extensions.SGIX_depth_texture)
+	 _mesa_problem(ctx, "depth format without GL_SGIX_depth_texture");
+      return &_mesa_texformat_depth_component;
+
+   case GL_COMPRESSED_ALPHA_ARB:
+      if (!ctx->Extensions.ARB_texture_compression)
+	 _mesa_problem(ctx, "texture compression extension not enabled");
+      return &_mesa_texformat_alpha;
+   case GL_COMPRESSED_LUMINANCE_ARB:
+      if (!ctx->Extensions.ARB_texture_compression)
+	 _mesa_problem(ctx, "texture compression extension not enabled");
+      return &_mesa_texformat_luminance;
+   case GL_COMPRESSED_LUMINANCE_ALPHA_ARB:
+      if (!ctx->Extensions.ARB_texture_compression)
+	 _mesa_problem(ctx, "texture compression extension not enabled");
+      return &_mesa_texformat_luminance_alpha;
+   case GL_COMPRESSED_INTENSITY_ARB:
+      if (!ctx->Extensions.ARB_texture_compression)
+	 _mesa_problem(ctx, "texture compression extension not enabled");
+      return &_mesa_texformat_intensity;
+   case GL_COMPRESSED_RGB_ARB:
+      if (!ctx->Extensions.ARB_texture_compression)
+	 _mesa_problem(ctx, "texture compression extension not enabled");
+      return &_mesa_texformat_rgb;
+   case GL_COMPRESSED_RGBA_ARB:
+      if (!ctx->Extensions.ARB_texture_compression)
+	 _mesa_problem(ctx, "texture compression extension not enabled");
+      return &_mesa_texformat_rgba;
+
+   case GL_YCBCR_MESA:
+      if (type == GL_UNSIGNED_SHORT_8_8_MESA)
+         return &_mesa_texformat_ycbcr;
+      else
+         return &_mesa_texformat_ycbcr_rev;
+
+   default:
+      _mesa_problem(ctx, "unexpected format in _mesa_choose_tex_format()");
+      printf("intformat = %d %x\n", internalFormat, internalFormat);
+      return NULL;
+   }
+}
 
+
+
+
+/*
+ * Return the base texture format for the given compressed format
+ * Called via ctx->Driver.BaseCompressedTexFormat().
+ * This function is used by software rasterizers.  Hardware drivers
+ * which support texture compression should not use this function but
+ * a specialized function instead.
+ */
+GLint
+_mesa_base_compressed_texformat(GLcontext *ctx, GLint intFormat)
+{
+   switch (intFormat) {
+   case GL_COMPRESSED_ALPHA_ARB:
+      return GL_ALPHA;
+   case GL_COMPRESSED_LUMINANCE_ARB:
+      return GL_LUMINANCE;
+   case GL_COMPRESSED_LUMINANCE_ALPHA_ARB:
+      return GL_LUMINANCE_ALPHA;
+   case GL_COMPRESSED_INTENSITY_ARB:
+      return GL_INTENSITY;
+   case GL_COMPRESSED_RGB_ARB:
+      return GL_RGB;
+   case GL_COMPRESSED_RGBA_ARB:
+      return GL_RGBA;
    default:
-      gl_problem( ctx, "unexpected format in _mesa_init_texture_format" );
-      return;
+      return -1;  /* not a recognized compressed format */
    }
+}
+
+
+/*
+ * Called via ctx->Driver.CompressedTextureSize().
+ * This function is only used by software rasterizers.
+ * Hardware drivers will have to implement a specialized function.
+ */
+GLint
+_mesa_compressed_texture_size(GLcontext *ctx,
+                              const struct gl_texture_image *texImage)
+{
+   GLint b;
+   assert(texImage);
+   assert(texImage->TexFormat);
+
+   b = texImage->Width * texImage->Height * texImage->Depth *
+      texImage->TexFormat->TexelBytes;
+   assert(b > 0);
+   return b;
 }
Index: xc/extras/Mesa/src/texformat.h
diff -u xc/extras/Mesa/src/texformat.h:1.2 xc/extras/Mesa/src/texformat.h:1.6
--- xc/extras/Mesa/src/texformat.h:1.2	Tue Apr 10 12:07:48 2001
+++ xc/extras/Mesa/src/texformat.h	Mon Dec 16 11:18:27 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,26 +22,35 @@
  * 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.
  *
- * Author:
+ * Authors:
  *    Gareth Hughes <gareth@valinux.com>
+ *    Brian Paul
  */
 
 #ifndef TEXFORMAT_H
 #define TEXFORMAT_H
 
-#include "types.h"
+#include "mtypes.h"
 
 
-/* The Mesa internal texture image types.  These will be set to their
- * default value, but may be changed by drivers as required.
+/* The Mesa internal texture image types.
  */
+enum _format {
+   /* Hardware-friendly formats.  Drivers can override the default
+    * formats and convert texture images to one of these as required.
+    * These formats are all little endian, as shown below.  They will be
+    * most useful for x86-based PC graphics card drivers.
+    *
+    * NOTE: In the default case, some of these formats will be
+    * duplicates of the default formats listed above.  However, these
+    * formats guarantee their internal component sizes, while GLchan may
+    * vary betwen GLubyte, GLushort and GLfloat.
+    */
 				/* msb <------ TEXEL BITS -----------> lsb */
-enum _format {			/* ---- ---- ---- ---- ---- ---- ---- ---- */
+				/* ---- ---- ---- ---- ---- ---- ---- ---- */
    MESA_FORMAT_RGBA8888,	/* RRRR RRRR GGGG GGGG BBBB BBBB AAAA AAAA */
-   MESA_FORMAT_ABGR8888,	/* AAAA AAAA BBBB BBBB GGGG GGGG RRRR RRRR */
    MESA_FORMAT_ARGB8888,	/* AAAA AAAA RRRR RRRR GGGG GGGG BBBB BBBB */
    MESA_FORMAT_RGB888,		/*           RRRR RRRR GGGG GGGG BBBB BBBB */
-   MESA_FORMAT_BGR888,		/*           BBBB BBBB GGGG GGGG RRRR RRRR */
    MESA_FORMAT_RGB565,		/*                     RRRR RGGG GGGB BBBB */
    MESA_FORMAT_ARGB4444,	/*                     AAAA RRRR GGGG BBBB */
    MESA_FORMAT_ARGB1555,	/*                     ARRR RRGG GGGB BBBB */
@@ -50,21 +59,62 @@
    MESA_FORMAT_A8,		/*                               AAAA AAAA */
    MESA_FORMAT_L8,		/*                               LLLL LLLL */
    MESA_FORMAT_I8,		/*                               IIII IIII */
-   MESA_FORMAT_CI8		/*                               CCCC CCCC */
+   MESA_FORMAT_CI8,		/*                               CCCC CCCC */
+   MESA_FORMAT_YCBCR,           /*                     YYYY YYYY UorV UorV */
+   MESA_FORMAT_YCBCR_REV,       /*                     UorV UorV YYYY YYYY */
+
+   /* Generic GLchan-based formats.  These are the default formats used
+    * by the software rasterizer and, unless the driver overrides the
+    * texture image functions, incoming images will be converted to one
+    * of these formats.  Components are arrays of GLchan values, so
+    * there will be no big/little endian issues.
+    *
+    * NOTE: Because these are based on the GLchan datatype, one cannot
+    * assume 8 bits per channel with these formats.  If you require
+    * GLubyte per channel, use one of the hardware formats above.
+    */
+   MESA_FORMAT_RGBA,
+   MESA_FORMAT_RGB,
+   MESA_FORMAT_ALPHA,
+   MESA_FORMAT_LUMINANCE,
+   MESA_FORMAT_LUMINANCE_ALPHA,
+   MESA_FORMAT_INTENSITY,
+   MESA_FORMAT_COLOR_INDEX,
+   MESA_FORMAT_DEPTH_COMPONENT
 };
 
 
-extern void
-_mesa_init_texture_format( GLcontext *ctx,
-			   struct gl_texture_image *texImage,
-			   GLenum internalFormat );
+extern GLboolean
+_mesa_is_hardware_tex_format( const struct gl_texture_format *format );
 
+extern const struct gl_texture_format *
+_mesa_choose_tex_format( GLcontext *ctx, GLint internalFormat,
+                         GLenum format, GLenum type );
 
+extern GLint
+_mesa_base_compressed_texformat( GLcontext *ctx, GLint intFormat );
+
+extern GLint
+_mesa_compressed_texture_size( GLcontext *ctx,
+                               const struct gl_texture_image *texImage );
+
+
+/* The default formats, GLchan per component:
+ */
+extern const struct gl_texture_format _mesa_texformat_rgba;
+extern const struct gl_texture_format _mesa_texformat_rgb;
+extern const struct gl_texture_format _mesa_texformat_alpha;
+extern const struct gl_texture_format _mesa_texformat_luminance;
+extern const struct gl_texture_format _mesa_texformat_luminance_alpha;
+extern const struct gl_texture_format _mesa_texformat_intensity;
+extern const struct gl_texture_format _mesa_texformat_color_index;
+extern const struct gl_texture_format _mesa_texformat_depth_component;
+
+/* The hardware-friendly formats:
+ */
 extern const struct gl_texture_format _mesa_texformat_rgba8888;
-extern const struct gl_texture_format _mesa_texformat_abgr8888;
 extern const struct gl_texture_format _mesa_texformat_argb8888;
 extern const struct gl_texture_format _mesa_texformat_rgb888;
-extern const struct gl_texture_format _mesa_texformat_bgr888;
 extern const struct gl_texture_format _mesa_texformat_rgb565;
 extern const struct gl_texture_format _mesa_texformat_argb4444;
 extern const struct gl_texture_format _mesa_texformat_argb1555;
@@ -74,7 +124,11 @@
 extern const struct gl_texture_format _mesa_texformat_l8;
 extern const struct gl_texture_format _mesa_texformat_i8;
 extern const struct gl_texture_format _mesa_texformat_ci8;
+extern const struct gl_texture_format _mesa_texformat_ycbcr;
+extern const struct gl_texture_format _mesa_texformat_ycbcr_rev;
 
+/* The null format:
+ */
 extern const struct gl_texture_format _mesa_null_texformat;
 
 #endif
Index: xc/extras/Mesa/src/texformat_tmp.h
diff -u /dev/null xc/extras/Mesa/src/texformat_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:42 2003
+++ xc/extras/Mesa/src/texformat_tmp.h	Mon Dec 16 11:18:27 2002
@@ -0,0 +1,356 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ *    Brian Paul
+ */
+
+#if DIM == 1
+
+#define CHAN_SRC( t, i, j, k, sz )					\
+	((GLchan *)(t)->Data + (i) * (sz))
+#define UBYTE_SRC( t, i, j, k, sz )					\
+	((GLubyte *)(t)->Data + (i) * (sz))
+#define USHORT_SRC( t, i, j, k )					\
+	((GLushort *)(t)->Data + (i))
+#define FLOAT_SRC( t, i, j, k )						\
+	((GLfloat *)(t)->Data + (i))
+
+#define FETCH(x) fetch_1d_texel_##x
+
+#elif DIM == 2
+
+#define CHAN_SRC( t, i, j, k, sz )					\
+	((GLchan *)(t)->Data + ((t)->RowStride * (j) + (i)) * (sz))
+#define UBYTE_SRC( t, i, j, k, sz )					\
+	((GLubyte *)(t)->Data + ((t)->RowStride * (j) + (i)) * (sz))
+#define USHORT_SRC( t, i, j, k )					\
+	((GLushort *)(t)->Data + ((t)->RowStride * (j) + (i)))
+#define FLOAT_SRC( t, i, j, k )						\
+	((GLfloat *)(t)->Data + ((t)->RowStride * (j) + (i)))
+
+#define FETCH(x) fetch_2d_texel_##x
+
+#elif DIM == 3
+
+#define CHAN_SRC( t, i, j, k, sz )					\
+	(GLchan *)(t)->Data + (((t)->Height * (k) + (j)) *		\
+				(t)->RowStride + (i)) * (sz)
+#define UBYTE_SRC( t, i, j, k, sz )					\
+	((GLubyte *)(t)->Data + (((t)->Height * (k) + (j)) *		\
+				 (t)->RowStride + (i)) * (sz))
+#define USHORT_SRC( t, i, j, k )					\
+	((GLushort *)(t)->Data + (((t)->Height * (k) + (j)) *		\
+				  (t)->RowStride + (i)))
+#define FLOAT_SRC( t, i, j, k )						\
+	((GLfloat *)(t)->Data + (((t)->Height * (k) + (j)) *		\
+				  (t)->RowStride + (i)))
+
+#define FETCH(x) fetch_3d_texel_##x
+
+#else
+#error	illegal number of texture dimensions
+#endif
+
+
+static void FETCH(rgba)( const struct gl_texture_image *texImage,
+			 GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLchan *src = CHAN_SRC( texImage, i, j, k, 4 );
+   GLchan *rgba = (GLchan *) texel;
+   COPY_CHAN4( rgba, src );
+}
+
+static void FETCH(rgb)( const struct gl_texture_image *texImage,
+			GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLchan *src = CHAN_SRC( texImage, i, j, k, 3 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = src[0];
+   rgba[GCOMP] = src[1];
+   rgba[BCOMP] = src[2];
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+static void FETCH(alpha)( const struct gl_texture_image *texImage,
+			  GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLchan *src = CHAN_SRC( texImage, i, j, k, 1 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = 0;
+   rgba[GCOMP] = 0;
+   rgba[BCOMP] = 0;
+   rgba[ACOMP] = src[0];
+}
+
+static void FETCH(luminance)( const struct gl_texture_image *texImage,
+			      GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLchan *src = CHAN_SRC( texImage, i, j, k, 1 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = src[0];
+   rgba[GCOMP] = src[0];
+   rgba[BCOMP] = src[0];
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+static void FETCH(luminance_alpha)( const struct gl_texture_image *texImage,
+				    GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLchan *src = CHAN_SRC( texImage, i, j, k, 2 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = src[0];
+   rgba[GCOMP] = src[0];
+   rgba[BCOMP] = src[0];
+   rgba[ACOMP] = src[1];
+}
+
+static void FETCH(intensity)( const struct gl_texture_image *texImage,
+			      GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLchan *src = CHAN_SRC( texImage, i, j, k, 1 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = src[0];
+   rgba[GCOMP] = src[0];
+   rgba[BCOMP] = src[0];
+   rgba[ACOMP] = src[0];
+}
+
+static void FETCH(color_index)( const struct gl_texture_image *texImage,
+				GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLchan *src = CHAN_SRC( texImage, i, j, k, 1 );
+   GLchan *index = (GLchan *) texel;
+   *index = *src;
+}
+
+static void FETCH(depth_component)( const struct gl_texture_image *texImage,
+				    GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLfloat *src = FLOAT_SRC( texImage, i, j, k );
+   GLfloat *depth = (GLfloat *) texel;
+   *depth = *src;
+}
+
+static void FETCH(rgba8888)( const struct gl_texture_image *texImage,
+			     GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 4 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( src[3] );
+   rgba[GCOMP] = UBYTE_TO_CHAN( src[2] );
+   rgba[BCOMP] = UBYTE_TO_CHAN( src[1] );
+   rgba[ACOMP] = UBYTE_TO_CHAN( src[0] );
+}
+
+static void FETCH(argb8888)( const struct gl_texture_image *texImage,
+			     GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 4 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( src[2] );
+   rgba[GCOMP] = UBYTE_TO_CHAN( src[1] );
+   rgba[BCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[ACOMP] = UBYTE_TO_CHAN( src[3] );
+}
+
+static void FETCH(rgb888)( const struct gl_texture_image *texImage,
+			   GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 3 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( src[2] );
+   rgba[GCOMP] = UBYTE_TO_CHAN( src[1] );
+   rgba[BCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+static void FETCH(rgb565)( const struct gl_texture_image *texImage,
+			   GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLushort *src = USHORT_SRC( texImage, i, j, k );
+   const GLushort s = *src;
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( ((s >> 8) & 0xf8) * 255 / 0xf8 );
+   rgba[GCOMP] = UBYTE_TO_CHAN( ((s >> 3) & 0xfc) * 255 / 0xfc );
+   rgba[BCOMP] = UBYTE_TO_CHAN( ((s << 3) & 0xf8) * 255 / 0xf8 );
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+static void FETCH(argb4444)( const struct gl_texture_image *texImage,
+			     GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLushort *src = USHORT_SRC( texImage, i, j, k );
+   const GLushort s = *src;
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( ((s >>  8) & 0xf) * 255 / 0xf );
+   rgba[GCOMP] = UBYTE_TO_CHAN( ((s >>  4) & 0xf) * 255 / 0xf );
+   rgba[BCOMP] = UBYTE_TO_CHAN( ((s      ) & 0xf) * 255 / 0xf );
+   rgba[ACOMP] = UBYTE_TO_CHAN( ((s >> 12) & 0xf) * 255 / 0xf );
+}
+
+static void FETCH(argb1555)( const struct gl_texture_image *texImage,
+			     GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLushort *src = USHORT_SRC( texImage, i, j, k );
+   const GLushort s = *src;
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( ((s >> 10) & 0x1f) * 255 / 0x1f );
+   rgba[GCOMP] = UBYTE_TO_CHAN( ((s >>  5) & 0x1f) * 255 / 0x1f );
+   rgba[BCOMP] = UBYTE_TO_CHAN( ((s      ) & 0x1f) * 255 / 0x1f );
+   rgba[ACOMP] = UBYTE_TO_CHAN( ((s >> 15) & 0x01) * 255 );
+}
+
+static void FETCH(al88)( const struct gl_texture_image *texImage,
+			 GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 2 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[GCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[BCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[ACOMP] = UBYTE_TO_CHAN( src[1] );
+}
+
+static void FETCH(rgb332)( const struct gl_texture_image *texImage,
+			   GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 1 );
+   const GLubyte s = *src;
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( ((s     ) & 0xe0) * 255 / 0xe0 );
+   rgba[GCOMP] = UBYTE_TO_CHAN( ((s << 3) & 0xe0) * 255 / 0xe0 );
+   rgba[BCOMP] = UBYTE_TO_CHAN( ((s << 5) & 0xc0) * 255 / 0xc0 );
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+static void FETCH(a8)( const struct gl_texture_image *texImage,
+		       GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 1 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = 0;
+   rgba[GCOMP] = 0;
+   rgba[BCOMP] = 0;
+   rgba[ACOMP] = UBYTE_TO_CHAN( src[0] );
+}
+
+static void FETCH(l8)( const struct gl_texture_image *texImage,
+		       GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 1 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[GCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[BCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+static void FETCH(i8)( const struct gl_texture_image *texImage,
+		       GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 1 );
+   GLchan *rgba = (GLchan *) texel;
+   rgba[RCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[GCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[BCOMP] = UBYTE_TO_CHAN( src[0] );
+   rgba[ACOMP] = UBYTE_TO_CHAN( src[0] );
+}
+
+static void FETCH(ci8)( const struct gl_texture_image *texImage,
+			GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLubyte *src = UBYTE_SRC( texImage, i, j, k, 1 );
+   GLchan *index = (GLchan *) texel;
+   *index = UBYTE_TO_CHAN( *src );
+}
+
+/* XXX this may break if GLchan != GLubyte */
+static void FETCH(ycbcr)( const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLushort *src0 = USHORT_SRC( texImage, (i & ~1), j, k ); /* even */
+   const GLushort *src1 = src0 + 1;                               /* odd */
+   const GLubyte y0 = (*src0 >> 8) & 0xff;  /* luminance */
+   const GLubyte cb = *src0 & 0xff;         /* chroma U */
+   const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */
+   const GLubyte cr = *src1 & 0xff;         /* chroma V */
+   GLchan *rgba = (GLchan *) texel;
+   GLint r, g, b;
+   if (i & 1) {
+      /* odd pixel: use y1,cr,cb */
+      r = (GLint) (1.164 * (y1-16) + 1.596 * (cr-128));
+      g = (GLint) (1.164 * (y1-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
+      b = (GLint) (1.164 * (y1-16) + 2.018 * (cb-128));
+   }
+   else {
+      /* even pixel: use y0,cr,cb */
+      r = (GLint) (1.164 * (y0-16) + 1.596 * (cr-128));
+      g = (GLint) (1.164 * (y0-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
+      b = (GLint) (1.164 * (y0-16) + 2.018 * (cb-128));
+   }
+   rgba[RCOMP] = CLAMP(r, 0, CHAN_MAX);
+   rgba[GCOMP] = CLAMP(g, 0, CHAN_MAX);
+   rgba[BCOMP] = CLAMP(b, 0, CHAN_MAX);
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+/* XXX this may break if GLchan != GLubyte */
+static void FETCH(ycbcr_rev)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLvoid *texel )
+{
+   const GLushort *src0 = USHORT_SRC( texImage, (i & ~1), j, k ); /* even */
+   const GLushort *src1 = src0 + 1;                               /* odd */
+   const GLubyte y0 = *src0 & 0xff;         /* luminance */
+   const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma U */
+   const GLubyte y1 = *src1 & 0xff;         /* luminance */
+   const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma V */
+   GLchan *rgba = (GLchan *) texel;
+   GLint r, g, b;
+   if (i & 1) {
+      /* odd pixel: use y1,cr,cb */
+      r = (GLint) (1.164 * (y1-16) + 1.596 * (cr-128));
+      g = (GLint) (1.164 * (y1-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
+      b = (GLint) (1.164 * (y1-16) + 2.018 * (cb-128));
+   }
+   else {
+      /* even pixel: use y0,cr,cb */
+      r = (GLint) (1.164 * (y0-16) + 1.596 * (cr-128));
+      g = (GLint) (1.164 * (y0-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
+      b = (GLint) (1.164 * (y0-16) + 2.018 * (cb-128));
+   }
+   rgba[RCOMP] = CLAMP(r, 0, CHAN_MAX);
+   rgba[GCOMP] = CLAMP(g, 0, CHAN_MAX);
+   rgba[BCOMP] = CLAMP(b, 0, CHAN_MAX);
+   rgba[ACOMP] = CHAN_MAX;
+}
+
+
+#undef CHAN_SRC
+#undef UBYTE_SRC
+#undef USHORT_SRC
+#undef FLOAT_SRC
+#undef FETCH
+#undef DIM
Index: xc/extras/Mesa/src/texgen_tmp.h
diff -u xc/extras/Mesa/src/texgen_tmp.h:1.7 xc/extras/Mesa/src/texgen_tmp.h:removed
--- xc/extras/Mesa/src/texgen_tmp.h:1.7	Tue Mar 20 21:48:46 2001
+++ xc/extras/Mesa/src/texgen_tmp.h	Thu Feb 27 12:15:42 2003
@@ -1,516 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4.1
- * 
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-/* Need to transform the eye plane equations into object space, and
- * use ctx->EyeZDir in spheregen.
- */
-
-#define CULL IDX&1
-
-/* 
- */
-static void TAG(build_m3)(GLfloat      f[][3],
-			  GLfloat      m[],
-			  const GLvector3f  *normals, 
-			  const GLvector4f  *coord_vec, 
-			  const GLuint       flags[],
-			  const GLubyte      cullmask[] )
-{
-   const GLuint stride = coord_vec->stride;
-   const GLfloat *coord = (const GLfloat *) coord_vec->start;
-   const GLuint count = coord_vec->count;
-   const GLfloat *normal = FIRST_NORMAL;
-   GLuint i;
-
-   LOCAL_VARS;
-
-   (void) flags;
-   (void) cullmask;
-
-   for (i=0; i<count; i++, STRIDE_F(coord,stride), NEXT_NORMAL) {
-      CHECK {
-	 GLfloat u[3], two_nu, fx, fy, fz;
-         CUR_NORMAL;
-	 COPY_3V( u, coord ); 
-	 NORMALIZE_3FV( u );
-	 two_nu = 2.0F * DOT3(normal,u);
-	 fx = f[i][0] = u[0] - normal[0] * two_nu;
-	 fy = f[i][1] = u[1] - normal[1] * two_nu;
-	 fz = f[i][2] = u[2] - normal[2] * two_nu;
-	 m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
-	 if (m[i] != 0.0F) {
-	    m[i] = 0.5F / (GLfloat) GL_SQRT(m[i]);
-	 }
-      }
-   }
-}
-
-
-
-static void TAG(build_m2)(GLfloat f[][3],
-			  GLfloat m[],
-			  const GLvector3f  *normals, 
-			  const GLvector4f  *coord_vec, 
-			  const GLuint       flags[],
-			  const GLubyte      cullmask[] )
-{
-   const GLuint stride = coord_vec->stride;
-   const GLfloat *coord = coord_vec->start;
-   const GLuint count = coord_vec->count;
-   const GLfloat *normal = FIRST_NORMAL;
-   GLuint i;
-
-   LOCAL_VARS;
-
-   (void) flags;
-   (void) cullmask;
-
-   for (i=0; i<count; i++, STRIDE_F(coord,stride), NEXT_NORMAL) {
-      CHECK {
-	 GLfloat u[3], two_nu, fx, fy, fz;
-         CUR_NORMAL;
-	 COPY_2V( u, coord ); u[2] = 0;
-	 NORMALIZE_3FV( u );
-	 two_nu = 2.0F * DOT3(normal,u);
-	 fx = f[i][0] = u[0] - normal[0] * two_nu;
-	 fy = f[i][1] = u[1] - normal[1] * two_nu;
-	 fz = f[i][2] = u[2] - normal[2] * two_nu;
-	 m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
-	 if (m[i] != 0.0F) {
-	    m[i] = 0.5F / (GLfloat) GL_SQRT(m[i]);
-	 }
-      }
-   }
-}
-
-
-
-static build_m_func TAG(build_m_tab)[5] = {
-   0,
-   0,
-   TAG(build_m2),
-   TAG(build_m3),
-   TAG(build_m3)
-};
-
-
-/* This is unusual in that we respect the stride of the output vector
- * (f).  This allows us to pass in either a texcoord vector4f, or a
- * temporary vector3f.  
- */
-static void TAG(build_f3)( GLfloat *f, 
-			   GLuint fstride,
-			   const GLvector3f *normals,
-			   const GLvector4f *coord_vec, 
-			   const GLuint       flags[],
-			   const GLubyte cullmask[] )
-{
-   const GLuint stride = coord_vec->stride;
-   const GLfloat *coord = coord_vec->start;
-   const GLuint count = coord_vec->count;
-   const GLfloat *normal = FIRST_NORMAL;
-   GLuint i;
-
-   LOCAL_VARS;
-
-   (void) flags;
-   (void) cullmask;
-
-   for (i=0; i<count; i++, STRIDE_F(coord,stride), STRIDE_F(f,fstride), NEXT_NORMAL) {
-      CHECK {
-	 GLfloat u[3], two_nu;
-         CUR_NORMAL;
-	 COPY_3V( u, coord ); 
-	 NORMALIZE_3FV( u );
-	 two_nu = 2.0F * DOT3(normal,u);
-	 f[0] = u[0] - normal[0] * two_nu;
-	 f[1] = u[1] - normal[1] * two_nu;
-	 f[2] = u[2] - normal[2] * two_nu;
-      }
-   }
-}
-
-
-static void TAG(build_f2)( GLfloat *f, 
-			   GLuint fstride,
-			   const GLvector3f *normals,
-			   const GLvector4f *coord_vec, 
-			   const GLuint      flags[],
-			   const GLubyte     cullmask[] )
-{
-   const GLuint stride = coord_vec->stride;
-   const GLfloat *coord = coord_vec->start;
-   const GLuint count = coord_vec->count;
-   const GLfloat *normal = FIRST_NORMAL;
-   GLuint i;
-
-   LOCAL_VARS;
-
-   (void) flags;
-   (void) cullmask;
-
-   for (i=0; i<count; i++, STRIDE_F(coord,stride), STRIDE_F(f,fstride), NEXT_NORMAL) {
-      CHECK {
-	 GLfloat u[3], two_nu;
-         CUR_NORMAL;
-	 COPY_2V( u, coord ); u[2] = 0;
-	 NORMALIZE_3FV( u );
-	 two_nu = 2.0F * DOT3(normal,u);
-	 f[0] = u[0] - normal[0] * two_nu;
-	 f[1] = u[1] - normal[1] * two_nu;
-	 f[2] = u[2] - normal[2] * two_nu;
-      }
-   }
-}
-
-/* Just treat 4-vectors as 3-vectors. 
- */
-static build_f_func TAG(build_f_tab)[5] = {
-   0,
-   0,
-   TAG(build_f2),
-   TAG(build_f3),
-   TAG(build_f3)		
-};
-
-
-/* Special case texgen functions.
- */
-static void TAG(texgen_reflection_map_nv)( struct vertex_buffer *VB, 
-					   GLuint textureUnit )
-{
-   GLvector4f *in = VB->TexCoordPtr[textureUnit];
-   GLvector4f *out = VB->store.TexCoord[textureUnit];
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-
-   TAG(build_f_tab)[VB->Unprojected->size]( out->start,
-					    out->stride,
-					    VB->NormalPtr, 
-					    VB->Unprojected, 
-					    VB->Flag + VB->Start,
-					    cullmask ); 
-
-   if (!in) in = out;
-
-   if (in != out && in->size == 4) {
-      gl_copy_tab[CULL][0x8](out, in, cullmask);
-   }
-
-   VB->TexCoordPtr[textureUnit] = out;
-   out->size = MAX2(in->size, 3);
-   out->flags |= in->flags | VEC_SIZE_3;
-}
-
-
-
-static void TAG(texgen_normal_map_nv)( struct vertex_buffer *VB, 
-				       GLuint textureUnit )
-{
-   GLvector4f *in = VB->TexCoordPtr[textureUnit];
-   GLvector4f *out = VB->store.TexCoord[textureUnit];
-   GLvector3f *normals = VB->NormalPtr;   
-   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start;
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-   GLuint *flags = VB->Flag + VB->Start;
-   GLuint count = VB->Count;
-
-   const GLfloat *normal = FIRST_NORMAL;
-   GLuint i;
-
-   LOCAL_VARS;
-
-   (void) flags;
-   (void) cullmask;
-
-   for (i=0; i<count; i++,NEXT_NORMAL) {
-      CHECK {
-         CUR_NORMAL;
-	 texcoord[i][0] = normal[0];
-	 texcoord[i][1] = normal[1];
-	 texcoord[i][2] = normal[2];
-      }
-   }
-
-   if (!in) in = out;
-
-   if (in != out && in->size == 4) {
-      gl_copy_tab[CULL][0x8](out, in, cullmask);
-   }
-
-   VB->TexCoordPtr[textureUnit] = out;
-   out->size = MAX2(in->size, 3);
-   out->flags |= in->flags | VEC_SIZE_3;
-}
-
-
-static void TAG(texgen_sphere_map)( struct vertex_buffer *VB, 
-				    GLuint textureUnit )
-{
-   GLvector4f *in = VB->TexCoordPtr[textureUnit];
-   GLvector4f *out = VB->store.TexCoord[textureUnit];
-   GLfloat (*texcoord)[4] = (GLfloat (*)[4]) out->start;
-   GLubyte *cullmask = VB->CullMask + VB->Start;
-   GLuint count = VB->Count;
-   GLuint i;
-   GLfloat (*f)[3], *m;
-
-   if (!VB->tmp_f) 
-      VB->tmp_f = (GLfloat (*)[3]) MALLOC(VB->Size * sizeof(GLfloat) * 3);
-
-   if (!VB->tmp_m) 
-      VB->tmp_m = (GLfloat *) MALLOC(VB->Size * sizeof(GLfloat));
-   
-   f = VB->tmp_f;
-   m = VB->tmp_m;
-
-   (TAG(build_m_tab)[VB->Unprojected->size])( f, m, 
-					      VB->NormalPtr, 
-					      VB->Unprojected, 
-					      VB->Flag + VB->Start,
-					      cullmask ); 
-
-   for (i=0;i<count;i++) {
-      CHECK {
-	 texcoord[i][0] = f[i][0] * m[i] + 0.5F;
-	 texcoord[i][1] = f[i][1] * m[i] + 0.5F;
-      }
-   }
-
-
-   if (!in) in = out;
-
-   if (in != out) {
-      struct gl_texture_unit *texUnit = &VB->ctx->Texture.Unit[textureUnit];
-      GLuint copy = (all_bits[in->size] & ~texUnit->TexGenEnabled);
-      if (copy)
-	 gl_copy_tab[CULL][copy](out, in, cullmask);
-   }
-
-   VB->TexCoordPtr[textureUnit] = out;
-   out->size = MAX2(in->size,2);
-   out->flags |= in->flags | VEC_SIZE_2;
-}
-
-
-
-static void TAG(texgen)( struct vertex_buffer *VB, GLuint textureUnit )
-{
-   GLcontext *ctx = VB->ctx;
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[textureUnit];
-   const GLvector4f *obj = VB->ObjPtr;
-   const GLvector4f *eye = VB->EyePtr;
-   const GLvector3f *normals = VB->NormalPtr;
-   const GLubyte *cullmask = VB->CullMask + VB->Start;
-   const GLuint *flags = VB->Flag + VB->Start;
-
-   GLvector4f *in = VB->TexCoordPtr[textureUnit];
-   GLvector4f *out = VB->store.TexCoord[textureUnit];
-   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start;
-   GLfloat *indata;
-   GLuint instride;
-   GLuint count = VB->Count;
-   GLfloat (*f)[3], *m;
-
-   LOCAL_VARS;
-
-   if (!VB->tmp_f) 
-      VB->tmp_f = (GLfloat (*)[3]) MALLOC(VB->Size * sizeof(GLfloat) * 3);
-
-   if (!VB->tmp_m) 
-      VB->tmp_m = (GLfloat *) MALLOC(VB->Size * sizeof(GLfloat));
-   
-   f = VB->tmp_f;
-   m = VB->tmp_m;
-
-   if (!in) in = out;
-   instride = in->stride;
-
-
-
-   if (texUnit->GenFlags & TEXGEN_NEED_M) {
-      TAG(build_m_tab)[in->size]( f, m, normals, eye, flags, cullmask ); 
-   } else if (texUnit->GenFlags & TEXGEN_NEED_F) {
-      TAG(build_f_tab)[in->size]( (GLfloat *)f, 3, normals, eye, 
-				  flags, cullmask ); 
-   }
-
-   if (in != out) {
-      GLuint copy = (all_bits[in->size] & ~texUnit->TexGenEnabled);
-      if (copy)
-	 gl_copy_tab[CULL][copy](out, in, cullmask);
-   }
-
-   if (texUnit->Holes)
-   {
-      GLubyte holes = (GLubyte) (texUnit->Holes & ~all_bits[in->size]);
-      if (holes) {
-	 if (holes & VEC_DIRTY_2) gl_vector4f_clean_elem(out, count, 2);
-	 if (holes & VEC_DIRTY_1) gl_vector4f_clean_elem(out, count, 1);
-	 if (holes & VEC_DIRTY_0) gl_vector4f_clean_elem(out, count, 0);
-      }
-   }
-
-   VB->TexCoordPtr[textureUnit] = out;
-   out->size = MAX2(in->size, texUnit->TexgenSize);
-   out->flags |= in->flags | texUnit->TexGenEnabled;
-
-   if (texUnit->TexGenEnabled & S_BIT) {
-      GLuint i;
-      switch (texUnit->GenModeS) {
-      case GL_OBJECT_LINEAR:
-	 (gl_dotprod_tab[CULL][obj->size])(out, 0, obj, 
-					   texUnit->ObjectPlaneS, cullmask);
-	 break;
-      case GL_EYE_LINEAR:
-	 (gl_dotprod_tab[CULL][eye->size])(out, 0, eye,
-					   texUnit->EyePlaneS, cullmask);
-	 break;
-      case GL_SPHERE_MAP: 
-	 for (indata=in->start,i=0 ; i<count ; i++, STRIDE_F(indata,instride) )
-	    CHECK texcoord[i][0] = indata[0] * m[i] + 0.5F;
-	 break;
-      case GL_REFLECTION_MAP_NV: 
-	 for (i=0;i<count;i++) 
-	    CHECK texcoord[i][0] = f[i][0];
-	 break;
-      case GL_NORMAL_MAP_NV: {
-
-	 const GLfloat *normal = FIRST_NORMAL;
-	 for (i=0;i<count;i++, NEXT_NORMAL) {
-	    CHECK {
-               CUR_NORMAL;
-               texcoord[i][0] = normal[0];
-            }
-	 }
-	 break;
-      }
-      default:
-	 gl_problem(ctx, "Bad S texgen");
-      }
-   } 
-
-   if (texUnit->TexGenEnabled & T_BIT) {
-      GLuint i;
-      switch (texUnit->GenModeT) {
-      case GL_OBJECT_LINEAR:
-	 (gl_dotprod_tab[CULL][obj->size])(out, 1, obj, 
-					   texUnit->ObjectPlaneT, cullmask);
-	 break;
-      case GL_EYE_LINEAR:
-	 (gl_dotprod_tab[CULL][eye->size])(out, 1, eye, 
-				       texUnit->EyePlaneT, cullmask);
-	 break; 
-      case GL_SPHERE_MAP: 
-	 for (indata=in->start,i=0; i<count ;i++,STRIDE_F(indata,instride)) 
-	    CHECK texcoord[i][1] = indata[1] * m[i] + 0.5F;
-	 break;      
-      case GL_REFLECTION_MAP_NV: 
-	 for (i=0;i<count;i++) 
-	    CHECK texcoord[i][0] = f[i][0];
-	 break;
-      case GL_NORMAL_MAP_NV: {
-	 const GLfloat *normal = FIRST_NORMAL;
-	 for (i=0;i<count;i++, NEXT_NORMAL) {
-	    CHECK {
-               CUR_NORMAL;
-               texcoord[i][1] = normal[1];
-            }
-	 }
-	 break;
-      }
-      default:
-	 gl_problem(ctx, "Bad T texgen");
-      }
-   }
-
-   if (texUnit->TexGenEnabled & R_BIT) {
-      GLuint i;
-      switch (texUnit->GenModeR) {
-      case GL_OBJECT_LINEAR:
-	 (gl_dotprod_tab[CULL][obj->size])(out, 2, obj, 
-					  texUnit->ObjectPlaneR, cullmask);
-	 break;
-      case GL_EYE_LINEAR:
-	 (gl_dotprod_tab[CULL][eye->size])(out, 2, eye,
-					  texUnit->EyePlaneR, cullmask);
-	 break;
-      case GL_REFLECTION_MAP_NV: 
-	 for (i=0;i<count;i++) 
-	    CHECK texcoord[i][2] = f[i][2];
-	 break;
-      case GL_NORMAL_MAP_NV: {
-	 const GLfloat *normal = FIRST_NORMAL;
-	 for (i=0;i<count;i++,NEXT_NORMAL) {
-	    CHECK {
-               CUR_NORMAL;
-               texcoord[i][2] = normal[2];
-            }
-	 }
-	 break;
-      }
-      default:
-	 gl_problem(ctx, "Bad R texgen");
-      }
-   }
-
-   if (texUnit->TexGenEnabled & Q_BIT) {
-      switch (texUnit->GenModeQ) {
-      case GL_OBJECT_LINEAR:
-	 (gl_dotprod_tab[CULL][obj->size])(out, 3, obj, 
-					   texUnit->ObjectPlaneQ, cullmask);
-	 break;
-      case GL_EYE_LINEAR:
-	 (gl_dotprod_tab[CULL][eye->size])(out, 3, eye,
-					   texUnit->EyePlaneQ, cullmask);
-	 break;
-      default:
-	 gl_problem(ctx, "Bad Q texgen");
-      }
-   }
-}
-
-static void TAG(init_texgen)( void )
-{
-   texgen_generic_tab[IDX] = TAG(texgen);
-   texgen_reflection_map_nv_tab[IDX] = TAG(texgen_reflection_map_nv);
-   texgen_normal_map_nv_tab[IDX] = TAG(texgen_normal_map_nv);
-   texgen_sphere_map_tab[IDX] = TAG(texgen_sphere_map);
-}
-
-#undef TAG
-#undef IDX
-#undef CULL
-#undef FIRST_NORMAL  
-#undef NEXT_NORMAL
-#undef CUR_NORMAL
-#undef LOCAL_VARS
-#undef CHECK
-
-
Index: xc/extras/Mesa/src/teximage.c
diff -u xc/extras/Mesa/src/teximage.c:1.16 xc/extras/Mesa/src/teximage.c:1.22
--- xc/extras/Mesa/src/teximage.c:1.16	Fri May 18 12:59:54 2001
+++ xc/extras/Mesa/src/teximage.c	Mon Dec 16 11:18:27 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -29,21 +29,25 @@
 #else
 #include "glheader.h"
 #include "context.h"
+#include "convolve.h"
 #include "image.h"
+#include "macros.h"
 #include "mem.h"
 #include "mmath.h"
-#include "span.h"
+#include "state.h"
 #include "texformat.h"
 #include "teximage.h"
 #include "texstate.h"
-#include "types.h"
+#include "texstore.h"
+#include "mtypes.h"
+#include "swrast/s_span.h" /* XXX SWRAST hack */
 #endif
 
 
 /*
  * NOTES:
  *
- * Mesa's native texture datatype is GLubyte.  Native formats are
+ * Mesa's native texture datatype is GLchan.  Native formats are
  * GL_ALPHA, GL_LUMINANCE, GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, GL_RGBA,
  * and GL_COLOR_INDEX.
  * Device drivers are free to implement any internal format they want.
@@ -53,8 +57,11 @@
 #ifdef DEBUG
 static void PrintTexture(const struct gl_texture_image *img)
 {
+#if CHAN_TYPE == GL_FLOAT
+   _mesa_problem(NULL, "PrintTexture doesn't support float channels");
+#else
    GLuint i, j, c;
-   GLubyte *data = img->Data;
+   const GLchan *data = (const GLchan *) img->Data;
 
    if (!data) {
       printf("No texture data\n");
@@ -78,11 +85,10 @@
          c = 4;
          break;
       default:
-         gl_problem(NULL, "error in PrintTexture\n");
+         _mesa_problem(NULL, "error in PrintTexture\n");
          return;
    }
 
-
    for (i = 0; i < img->Height; i++) {
       for (j = 0; j < img->Width; j++) {
          if (c==1)
@@ -95,8 +101,10 @@
             printf("%02x%02x%02x%02x  ", data[0], data[1], data[2], data[3]);
          data += c;
       }
+      data += (img->RowStride - img->Width) * c;
       printf("\n");
    }
+#endif
 }
 #endif
 
@@ -105,7 +113,7 @@
 /*
  * Compute log base 2 of n.
  * If n isn't an exact power of two return -1.
- * If n<0 return -1.
+ * If n < 0 return -1.
  */
 static int
 logbase2( int n )
@@ -113,7 +121,7 @@
    GLint i = 1;
    GLint log2 = 0;
 
-   if (n<0) {
+   if (n < 0) {
       return -1;
    }
 
@@ -140,10 +148,10 @@
 GLint
 _mesa_base_tex_format( GLcontext *ctx, GLint format )
 {
-  /*
-   * Ask the driver for the base format, if it doesn't
-   * know, it will return -1;
-   */
+   /*
+    * Ask the driver for the base format, if it doesn't
+    * know, it will return -1;
+    */
    if (ctx->Driver.BaseCompressedTexFormat) {
       GLint ifmt = (*ctx->Driver.BaseCompressedTexFormat)(ctx, format);
       if (ifmt >= 0) {
@@ -206,22 +214,35 @@
       case GL_COLOR_INDEX8_EXT:
       case GL_COLOR_INDEX12_EXT:
       case GL_COLOR_INDEX16_EXT:
-         return GL_COLOR_INDEX;
+         if (ctx->Extensions.EXT_paletted_texture)
+            return GL_COLOR_INDEX;
+         else
+            return -1;
+      case GL_DEPTH_COMPONENT:
+      case GL_DEPTH_COMPONENT16_SGIX:
+      case GL_DEPTH_COMPONENT24_SGIX:
+      case GL_DEPTH_COMPONENT32_SGIX:
+         if (ctx->Extensions.SGIX_depth_texture)
+            return GL_DEPTH_COMPONENT;
+         else
+            return -1;
+      case GL_YCBCR_MESA:
+         if (ctx->Extensions.MESA_ycbcr_texture)
+            return GL_YCBCR_MESA;
+         else
+            return -1;
       default:
          return -1;  /* error */
    }
 }
 
 
-
 /*
- * Given an internal texture format enum or 1, 2, 3, 4 return the
- * corresponding _base_ internal format:  GL_ALPHA, GL_LUMINANCE,
- * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA.  Return the
- * number of components for the format.  Return -1 if invalid enum.
+ * Test if the given image format is a color/rgba format.  That is,
+ * not color index, depth, stencil, etc.
  */
-static GLint
-components_in_intformat( GLint format )
+static GLboolean
+is_color_format(GLenum format)
 {
    switch (format) {
       case GL_ALPHA:
@@ -229,14 +250,12 @@
       case GL_ALPHA8:
       case GL_ALPHA12:
       case GL_ALPHA16:
-         return 1;
       case 1:
       case GL_LUMINANCE:
       case GL_LUMINANCE4:
       case GL_LUMINANCE8:
       case GL_LUMINANCE12:
       case GL_LUMINANCE16:
-         return 1;
       case 2:
       case GL_LUMINANCE_ALPHA:
       case GL_LUMINANCE4_ALPHA4:
@@ -245,13 +264,11 @@
       case GL_LUMINANCE12_ALPHA4:
       case GL_LUMINANCE12_ALPHA12:
       case GL_LUMINANCE16_ALPHA16:
-         return 2;
       case GL_INTENSITY:
       case GL_INTENSITY4:
       case GL_INTENSITY8:
       case GL_INTENSITY12:
       case GL_INTENSITY16:
-         return 1;
       case 3:
       case GL_RGB:
       case GL_R3_G3_B2:
@@ -261,7 +278,6 @@
       case GL_RGB10:
       case GL_RGB12:
       case GL_RGB16:
-         return 3;
       case 4:
       case GL_RGBA:
       case GL_RGBA2:
@@ -271,7 +287,18 @@
       case GL_RGB10_A2:
       case GL_RGBA12:
       case GL_RGBA16:
-         return 4;
+         return GL_TRUE;
+      case GL_YCBCR_MESA:  /* not considered to be RGB */
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+static GLboolean
+is_index_format(GLenum format)
+{
+   switch (format) {
       case GL_COLOR_INDEX:
       case GL_COLOR_INDEX1_EXT:
       case GL_COLOR_INDEX2_EXT:
@@ -279,9 +306,9 @@
       case GL_COLOR_INDEX8_EXT:
       case GL_COLOR_INDEX12_EXT:
       case GL_COLOR_INDEX16_EXT:
-         return 1;
+         return GL_TRUE;
       default:
-         return -1;  /* error */
+         return GL_FALSE;
    }
 }
 
@@ -293,23 +320,34 @@
 static GLboolean
 is_compressed_format(GLcontext *ctx, GLenum internalFormat)
 {
-    if (ctx->Driver.IsCompressedFormat) {
-        return (*ctx->Driver.IsCompressedFormat)(ctx, internalFormat);
-    }
-    return GL_FALSE;
+   if (ctx->Driver.BaseCompressedTexFormat) {
+      GLint b = (*ctx->Driver.BaseCompressedTexFormat)(ctx, internalFormat);
+      if (b > 0)
+         return GL_TRUE;
+      else
+         return GL_FALSE;
+   }
+   return GL_FALSE;
 }
 
 
 
-static void
-set_tex_image(struct gl_texture_object *tObj,
-              GLenum target, GLint level,
-              struct gl_texture_image *texImage)
+/*
+ * Store a gl_texture_image pointer in a gl_texture_object structure
+ * according to the target and level parameters.
+ * This was basically prompted by the introduction of cube maps.
+ */
+void
+_mesa_set_tex_image(struct gl_texture_object *tObj,
+                    GLenum target, GLint level,
+                    struct gl_texture_image *texImage)
 {
    ASSERT(tObj);
    ASSERT(texImage);
    switch (target) {
+      case GL_TEXTURE_1D:
       case GL_TEXTURE_2D:
+      case GL_TEXTURE_3D:
          tObj->Image[level] = texImage;
          return;
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
@@ -330,13 +368,18 @@
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
          tObj->NegZ[level] = texImage;
          return;
+      case GL_TEXTURE_RECTANGLE_NV:
+         ASSERT(level == 0);
+         tObj->Image[level] = texImage;
+         return;
       default:
-         gl_problem(NULL, "bad target in set_tex_image()");
+         _mesa_problem(NULL, "bad target in _mesa_set_tex_image()");
          return;
    }
 }
 
 
+
 /*
  * Return new gl_texture_image struct with all fields initialized to zero.
  */
@@ -348,97 +391,49 @@
 
 
 
-/*
- * Initialize most fields of a gl_texture_image struct.
- */
-static void
-init_texture_image( GLcontext *ctx,
-                    struct gl_texture_image *img,
-                    GLsizei width, GLsizei height, GLsizei depth,
-                    GLint border, GLenum internalFormat )
-{
-   ASSERT(img);
-   ASSERT(!img->Data);
-   _mesa_init_texture_format( ctx, img, internalFormat );
-   img->Border = border;
-   img->Width = width;
-   img->Height = height;
-   img->Depth = depth;
-   img->WidthLog2 = logbase2(width - 2 * border);
-   if (height == 1)  /* 1-D texture */
-      img->HeightLog2 = 0;
-   else
-      img->HeightLog2 = logbase2(height - 2 * border);
-   if (depth == 1)   /* 2-D texture */
-      img->DepthLog2 = 0;
-   else
-      img->DepthLog2 = logbase2(depth - 2 * border);
-   img->Width2 = 1 << img->WidthLog2;
-   img->Height2 = 1 << img->HeightLog2;
-   img->Depth2 = 1 << img->DepthLog2;
-   img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);
-   img->IsCompressed = is_compressed_format(ctx, internalFormat);
-}
-
-
-
 void
 _mesa_free_texture_image( struct gl_texture_image *teximage )
 {
-   if (teximage->Data) {
-      FREE( teximage->Data );
+   if (teximage->Data && !teximage->IsClientData) {
+      MESA_PBUFFER_FREE( teximage->Data );
       teximage->Data = NULL;
    }
    FREE( teximage );
 }
 
 
-
 /*
- * Return number of bytes of storage needed to store a compressed texture
- * image.  Only the driver knows for sure.  If the driver can't help us,
- * we must return 0.
+ * Return GL_TRUE if the target is a proxy target.
  */
-GLuint
-_mesa_compressed_image_size(GLcontext *ctx,
-                            GLenum internalFormat,
-                            GLint numDimensions,
-                            GLint width,
-                            GLint height,
-                            GLint depth)
-{
-   if (ctx->Driver.CompressedImageSize) {
-      return (*ctx->Driver.CompressedImageSize)(ctx, internalFormat,
-                                                numDimensions,
-                                                width, height, depth);
-   }
-   else {
-      /* Shouldn't this be an internal error of some sort? */
-      return 0;
-   }
+static GLboolean
+is_proxy_target(GLenum target)
+{
+   return (target == GL_PROXY_TEXTURE_1D ||
+           target == GL_PROXY_TEXTURE_2D ||
+           target == GL_PROXY_TEXTURE_3D ||
+           target == GL_PROXY_TEXTURE_CUBE_MAP_ARB);
 }
 
 
-
 /*
  * Given a texture unit and a texture target, return the corresponding
  * texture object.
  */
 struct gl_texture_object *
-_mesa_select_tex_object(GLcontext *ctx, struct gl_texture_unit *texUnit,
+_mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit,
                         GLenum target)
 {
    switch (target) {
       case GL_TEXTURE_1D:
-         return texUnit->CurrentD[1];
+         return texUnit->Current1D;
       case GL_PROXY_TEXTURE_1D:
          return ctx->Texture.Proxy1D;
       case GL_TEXTURE_2D:
-         return texUnit->CurrentD[2];
+         return texUnit->Current2D;
       case GL_PROXY_TEXTURE_2D:
          return ctx->Texture.Proxy2D;
       case GL_TEXTURE_3D:
-         return texUnit->CurrentD[3];
+         return texUnit->Current3D;
       case GL_PROXY_TEXTURE_3D:
          return ctx->Texture.Proxy3D;
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
@@ -448,13 +443,19 @@
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
       case GL_TEXTURE_CUBE_MAP_ARB:
-         return ctx->Extensions.HaveTextureCubeMap
+         return ctx->Extensions.ARB_texture_cube_map
                 ? texUnit->CurrentCubeMap : NULL;
       case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-         return ctx->Extensions.HaveTextureCubeMap
+         return ctx->Extensions.ARB_texture_cube_map
                 ? ctx->Texture.ProxyCubeMap : NULL;
+      case GL_TEXTURE_RECTANGLE_NV:
+         return ctx->Extensions.NV_texture_rectangle
+                ? texUnit->CurrentRect : NULL;
+      case GL_PROXY_TEXTURE_RECTANGLE_NV:
+         return ctx->Extensions.NV_texture_rectangle
+                ? ctx->Texture.ProxyRect : NULL;
       default:
-         gl_problem(NULL, "bad target in _mesa_select_tex_object()");
+         _mesa_problem(NULL, "bad target in _mesa_select_tex_object()");
          return NULL;
    }
 }
@@ -469,240 +470,99 @@
                        GLenum target, GLint level)
 {
    ASSERT(texUnit);
+   ASSERT(level < MAX_TEXTURE_LEVELS);
    switch (target) {
       case GL_TEXTURE_1D:
-         return texUnit->CurrentD[1]->Image[level];
+         return texUnit->Current1D->Image[level];
       case GL_PROXY_TEXTURE_1D:
          return ctx->Texture.Proxy1D->Image[level];
       case GL_TEXTURE_2D:
-         return texUnit->CurrentD[2]->Image[level];
+         return texUnit->Current2D->Image[level];
       case GL_PROXY_TEXTURE_2D:
          return ctx->Texture.Proxy2D->Image[level];
       case GL_TEXTURE_3D:
-         return texUnit->CurrentD[3]->Image[level];
+         return texUnit->Current3D->Image[level];
       case GL_PROXY_TEXTURE_3D:
          return ctx->Texture.Proxy3D->Image[level];
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             return texUnit->CurrentCubeMap->Image[level];
          else
             return NULL;
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             return texUnit->CurrentCubeMap->NegX[level];
          else
             return NULL;
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             return texUnit->CurrentCubeMap->PosY[level];
          else
             return NULL;
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             return texUnit->CurrentCubeMap->NegY[level];
          else
             return NULL;
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             return texUnit->CurrentCubeMap->PosZ[level];
          else
             return NULL;
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             return texUnit->CurrentCubeMap->NegZ[level];
          else
             return NULL;
       case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap)
+         if (ctx->Extensions.ARB_texture_cube_map)
             return ctx->Texture.ProxyCubeMap->Image[level];
          else
             return NULL;
-      default:
-         gl_problem(ctx, "bad target in _mesa_select_tex_image()");
-         return NULL;
-   }
-}
-
-
-
-/* Need this to prevent an out-of-bounds memory access when using
- * X86 optimized code.
- */
-#ifdef USE_X86_ASM
-#  define EXTRA_BYTE 1
-#else
-#  define EXTRA_BYTE 0
-#endif
-
-
-
-/*
- * Called by glTexImage[123]D.  Fill in a texture image with data given
- * by the client.  All pixel transfer and unpack modes are handled here.
- * NOTE: All texture image parameters should have already been error checked.
- */
-static void
-make_texture_image( GLcontext *ctx,
-                    struct gl_texture_image *texImage,
-                    GLenum srcFormat, GLenum srcType, const GLvoid *pixels,
-                    const struct gl_pixelstore_attrib *unpacking)
-{
-   GLint components, numPixels;
-   GLint internalFormat, width, height, depth, border;
-
-   ASSERT(ctx);
-   ASSERT(texImage);
-   ASSERT(!texImage->Data);
-   ASSERT(pixels);
-   ASSERT(unpacking);
-
-   internalFormat = texImage->IntFormat;
-   width = texImage->Width;
-   height = texImage->Height;
-   depth = texImage->Depth;
-   border = texImage->Border;
-   components = components_in_intformat(internalFormat);
-
-   ASSERT(width > 0);
-   ASSERT(height > 0);
-   ASSERT(depth > 0);
-   ASSERT(border == 0 || border == 1);
-   ASSERT(pixels);
-   ASSERT(unpacking);
-   ASSERT(components);
-
-   numPixels = width * height * depth;
-
-   texImage->Data = (GLubyte *) MALLOC(numPixels * components + EXTRA_BYTE);
-   if (!texImage->Data)
-      return;      /* out of memory */
-
-   /*
-    * OK, the texture image struct has been initialized and the texture
-    * image memory has been allocated.
-    * Now fill in the texture image from the source data.
-    * This includes applying the pixel transfer operations.
-    */
-
-   /* try common 2D texture cases first */
-   if (!ctx->Pixel.ScaleOrBiasRGBA && !ctx->Pixel.MapColorFlag
-       && !ctx->Pixel.IndexOffset && !ctx->Pixel.IndexShift
-       && srcType == GL_UNSIGNED_BYTE && depth == 1) {
-
-      if ((GLint) srcFormat == internalFormat ||
-          (srcFormat == GL_LUMINANCE && internalFormat == 1) ||
-          (srcFormat == GL_LUMINANCE_ALPHA && internalFormat == 2) ||
-          (srcFormat == GL_RGB && internalFormat == 3) ||
-          (srcFormat == GL_RGBA && internalFormat == 4)) {
-         /* This will cover the common GL_RGB, GL_RGBA, GL_ALPHA,
-          * GL_LUMINANCE_ALPHA, etc. texture formats.
-          */
-         const GLubyte *src = (const GLubyte *) _mesa_image_address(
-            unpacking, pixels, width, height, srcFormat, srcType, 0, 0, 0);
-         const GLint srcStride = _mesa_image_row_stride(unpacking, width,
-                                                        srcFormat, srcType);
-         GLubyte *dst = texImage->Data;
-         GLint dstBytesPerRow = width * components * sizeof(GLubyte);
-         if (srcStride == dstBytesPerRow) {
-            MEMCPY(dst, src, height * dstBytesPerRow);
+      case GL_TEXTURE_RECTANGLE_NV:
+         if (ctx->Extensions.NV_texture_rectangle) {
+            ASSERT(level == 0);
+            return texUnit->CurrentRect->Image[level];
          }
          else {
-            GLint i;
-            for (i = 0; i < height; i++) {
-               MEMCPY(dst, src, dstBytesPerRow);
-               src += srcStride;
-               dst += dstBytesPerRow;
-            }
-         }
-         return;  /* all done */
-      }
-      else if (srcFormat == GL_RGBA && internalFormat == GL_RGB) {
-         /* commonly used by Quake */
-         const GLubyte *src = (const GLubyte *) _mesa_image_address(
-            unpacking, pixels, width, height, srcFormat, srcType, 0, 0, 0);
-         const GLint srcStride = _mesa_image_row_stride(unpacking, width,
-                                                        srcFormat, srcType);
-         GLubyte *dst = texImage->Data;
-         GLint i, j;
-         for (i = 0; i < height; i++) {
-            const GLubyte *s = src;
-            for (j = 0; j < width; j++) {
-               *dst++ = *s++;  /*red*/
-               *dst++ = *s++;  /*green*/
-               *dst++ = *s++;  /*blue*/
-               s++;            /*alpha*/
-            }
-            src += srcStride;
+            return NULL;
          }
-         return;  /* all done */
-      }
-   }
-
-
-   /*
-    * General case solutions
-    */
-   if (texImage->Format == GL_COLOR_INDEX) {
-      /* color index texture */
-      const GLint destBytesPerRow = width * components * sizeof(GLubyte);
-      const GLenum dstType = GL_UNSIGNED_BYTE;
-      GLubyte *dest = texImage->Data;
-      GLint img, row;
-      for (img = 0; img < depth; img++) {
-         for (row = 0; row < height; row++) {
-            const GLvoid *source = _mesa_image_address(unpacking,
-                pixels, width, height, srcFormat, srcType, img, row, 0);
-            _mesa_unpack_index_span(ctx, width, dstType, dest,
-                                    srcType, source, unpacking, GL_TRUE);
-            dest += destBytesPerRow;
+      case GL_PROXY_TEXTURE_RECTANGLE_NV:
+         if (ctx->Extensions.NV_texture_rectangle) {
+            ASSERT(level == 0);
+            return ctx->Texture.ProxyRect->Image[level];
          }
-      }
-   }
-   else {
-      /* regular, color texture */
-      const GLint destBytesPerRow = width * components * sizeof(GLubyte);
-      const GLenum dstFormat = texImage->Format;
-      GLubyte *dest = texImage->Data;
-      GLint img, row;
-      for (img = 0; img < depth; img++) {
-         for (row = 0; row < height; row++) {
-            const GLvoid *source = _mesa_image_address(unpacking,
-                   pixels, width, height, srcFormat, srcType, img, row, 0);
-            _mesa_unpack_ubyte_color_span(ctx, width, dstFormat, dest,
-                   srcFormat, srcType, source, unpacking, GL_TRUE);
-            dest += destBytesPerRow;
+         else {
+            return NULL;
          }
-      }
+      default:
+         _mesa_problem(ctx, "bad target in _mesa_select_tex_image()");
+         return NULL;
    }
 }
 
 
 
+#if 000 /* not used anymore */
 /*
  * glTexImage[123]D can accept a NULL image pointer.  In this case we
  * create a texture image with unspecified image contents per the OpenGL
- * spec.  This function creates an empty image for the given texture image.
+ * spec.
  */
-static void
-make_null_texture( struct gl_texture_image *texImage )
+static GLubyte *
+make_null_texture(GLint width, GLint height, GLint depth, GLenum format)
 {
-   GLint components;
-   GLint numPixels;
-
-   ASSERT(texImage);
-   ASSERT(!texImage->Data);
-
-   components = components_in_intformat(texImage->IntFormat);
-   numPixels = texImage->Width * texImage->Height * texImage->Depth;
+   const GLint components = _mesa_components_in_format(format);
+   const GLint numPixels = width * height * depth;
+   GLubyte *data = (GLubyte *) MALLOC(numPixels * components * sizeof(GLubyte));
 
-   texImage->Data = (GLubyte *) MALLOC( numPixels * components + EXTRA_BYTE );
-
+#ifdef DEBUG
    /*
     * Let's see if anyone finds this.  If glTexImage2D() is called with
     * a NULL image pointer then load the texture image with something
     * interesting instead of leaving it indeterminate.
     */
-   if (texImage->Data) {
+   if (data) {
       static const char message[8][32] = {
          "   X   X  XXXXX   XXX     X    ",
          "   XX XX  X      X   X   X X   ",
@@ -714,30 +574,39 @@
          "                               "
       };
 
-      GLubyte *imgPtr = texImage->Data;
-      GLuint i, j;
-      GLint k;
-      for (i = 0; i < texImage->Height; i++) {
-         GLint srcRow = 7 - i % 8;
-         for (j = 0; j < texImage->Width; j++) {
-            GLint srcCol = j % 32;
-            GLint texel = (message[srcRow][srcCol]=='X') ? 255 : 70;
-            for (k = 0; k < components; k++) {
-               *imgPtr++ = (GLubyte) texel;
+      GLubyte *imgPtr = data;
+      GLint h, i, j, k;
+      for (h = 0; h < depth; h++) {
+         for (i = 0; i < height; i++) {
+            GLint srcRow = 7 - (i % 8);
+            for (j = 0; j < width; j++) {
+               GLint srcCol = j % 32;
+               GLubyte texel = (message[srcRow][srcCol]=='X') ? 255 : 70;
+               for (k = 0; k < components; k++) {
+                  *imgPtr++ = texel;
+               }
             }
          }
       }
    }
+#endif
+
+   return data;
 }
+#endif
 
 
 
 /*
+ * Reset the fields of a gl_texture_image struct to zero.
  * This is called when a proxy texture test fails, we set all the
  * image members (except DriverData) to zero.
+ * It's also used in glTexImage[123]D as a safeguard to be sure all
+ * required fields get initialized properly by the Driver.TexImage[123]D
+ * functions.
  */
 static void
-clear_proxy_teximage(struct gl_texture_image *img)
+clear_teximage_fields(struct gl_texture_image *img)
 {
    ASSERT(img);
    img->Format = 0;
@@ -746,6 +615,7 @@
    img->Width = 0;
    img->Height = 0;
    img->Depth = 0;
+   img->RowStride = 0;
    img->Width2 = 0;
    img->Height2 = 0;
    img->Depth2 = 0;
@@ -753,9 +623,45 @@
    img->HeightLog2 = 0;
    img->DepthLog2 = 0;
    img->Data = NULL;
+   img->TexFormat = &_mesa_null_texformat;
+   img->FetchTexel = NULL;
    img->IsCompressed = 0;
    img->CompressedSize = 0;
-   img->TexFormat = &_mesa_null_texformat;
+}
+
+
+/*
+ * Initialize basic fields of the gl_texture_image struct.
+ */
+void
+_mesa_init_teximage_fields(GLcontext *ctx, GLenum target,
+                           struct gl_texture_image *img,
+                           GLsizei width, GLsizei height, GLsizei depth,
+                           GLint border, GLenum internalFormat)
+{
+   ASSERT(img);
+   img->Format = _mesa_base_tex_format( ctx, internalFormat );
+   ASSERT(img->Format > 0);
+   img->IntFormat = internalFormat;
+   img->Border = border;
+   img->Width = width;
+   img->Height = height;
+   img->Depth = depth;
+   img->RowStride = img->Width;
+   img->WidthLog2 = logbase2(width - 2 * border);
+   if (height == 1)  /* 1-D texture */
+      img->HeightLog2 = 0;
+   else
+      img->HeightLog2 = logbase2(height - 2 * border);
+   if (depth == 1)   /* 2-D texture */
+      img->DepthLog2 = 0;
+   else
+      img->DepthLog2 = logbase2(depth - 2 * border);
+   img->Width2 = 1 << img->WidthLog2;
+   img->Height2 = 1 << img->HeightLog2;
+   img->Depth2 = 1 << img->DepthLog2;
+   img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);
+   img->IsCompressed = is_compressed_format(ctx, internalFormat);
 }
 
 
@@ -776,65 +682,144 @@
 {
    GLboolean isProxy;
    GLint iformat;
+   GLint maxLevels = 0, maxTextureSize;
 
    if (dimensions == 1) {
-      isProxy = (GLboolean) (target == GL_PROXY_TEXTURE_1D);
-      if (target != GL_TEXTURE_1D && !isProxy) {
-         gl_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
+      if (target == GL_PROXY_TEXTURE_1D) {
+         isProxy = GL_TRUE;
+      }
+      else if (target == GL_TEXTURE_1D) {
+         isProxy = GL_FALSE;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
          return GL_TRUE;
       }
+      maxLevels = ctx->Const.MaxTextureLevels;
    }
    else if (dimensions == 2) {
-      isProxy = (GLboolean) (target == GL_PROXY_TEXTURE_2D);
-      if (target != GL_TEXTURE_2D && !isProxy &&
-          !(ctx->Extensions.HaveTextureCubeMap &&
-            target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-            target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
-          gl_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
-          return GL_TRUE;
+      if (target == GL_PROXY_TEXTURE_2D) {
+         isProxy = GL_TRUE;
+         maxLevels = ctx->Const.MaxTextureLevels;
+      }
+      else if (target == GL_TEXTURE_2D) {
+         isProxy = GL_FALSE;
+         maxLevels = ctx->Const.MaxTextureLevels;
+      }
+      else if (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
+            return GL_TRUE;
+         }
+         isProxy = GL_TRUE;
+         maxLevels = ctx->Const.MaxCubeTextureLevels;
+      }
+      else if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
+               target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
+            return GL_TRUE;
+         }
+         isProxy = GL_FALSE;
+         maxLevels = ctx->Const.MaxCubeTextureLevels;
+      }
+      else if (target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
+         if (!ctx->Extensions.NV_texture_rectangle) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
+            return GL_TRUE;
+         }
+         isProxy = GL_TRUE;
+         maxLevels = 1;
+      }
+      else if (target == GL_TEXTURE_RECTANGLE_NV) {
+         if (!ctx->Extensions.NV_texture_rectangle) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
+            return GL_TRUE;
+         }
+         isProxy = GL_FALSE;
+         maxLevels = 1;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage2D(target)");
+         return GL_TRUE;
       }
    }
    else if (dimensions == 3) {
-      isProxy = (GLboolean) (target == GL_PROXY_TEXTURE_3D);
-      if (target != GL_TEXTURE_3D && !isProxy) {
-         gl_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
+      if (target == GL_PROXY_TEXTURE_3D) {
+         isProxy = GL_TRUE;
+      }
+      else if (target == GL_TEXTURE_3D) {
+         isProxy = GL_FALSE;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
          return GL_TRUE;
       }
+      maxLevels = ctx->Const.Max3DTextureLevels;
    }
    else {
-      gl_problem( ctx, "bad dims in texture_error_check" );
+      _mesa_problem( ctx, "bad dims in texture_error_check" );
       return GL_TRUE;
    }
 
+   ASSERT(maxLevels > 0);
+   maxTextureSize = 1 << (maxLevels - 1);
+
    /* Border */
    if (border != 0 && border != 1) {
       if (!isProxy) {
          char message[100];
-         sprintf(message, "glTexImage%dD(border)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         sprintf(message, "glTexImage%dD(border=%d)", dimensions, border);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
       }
       return GL_TRUE;
    }
+   if ((target == GL_TEXTURE_RECTANGLE_NV ||
+        target == GL_PROXY_TEXTURE_RECTANGLE_NV) && border != 0) {
+      return GL_TRUE;
+   }
 
    /* Width */
-   if (width < 2 * border || width > 2 + ctx->Const.MaxTextureSize
+   if (target == GL_TEXTURE_RECTANGLE_NV ||
+       target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
+      if (width < 1 || width > ctx->Const.MaxTextureRectSize) {
+         if (!isProxy) {
+            char message[100];
+            sprintf(message, "glTexImage%dD(width=%d)", dimensions, width);
+            _mesa_error(ctx, GL_INVALID_VALUE, message);
+         }
+         return GL_TRUE;
+      }
+   }
+   else if (width < 2 * border || width > 2 + maxTextureSize
        || logbase2( width - 2 * border ) < 0) {
       if (!isProxy) {
          char message[100];
-         sprintf(message, "glTexImage%dD(width)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         sprintf(message, "glTexImage%dD(width=%d)", dimensions, width);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
       }
       return GL_TRUE;
    }
 
    /* Height */
-   if (dimensions >= 2) {
-      if (height < 2 * border || height > 2 + ctx->Const.MaxTextureSize
+   if (target == GL_TEXTURE_RECTANGLE_NV ||
+       target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
+      if (height < 1 || height > ctx->Const.MaxTextureRectSize) {
+         if (!isProxy) {
+            char message[100];
+            sprintf(message, "glTexImage%dD(height=%d)", dimensions, height);
+            _mesa_error(ctx, GL_INVALID_VALUE, message);
+         }
+         return GL_TRUE;
+      }
+   }
+   else if (dimensions >= 2) {
+      if (height < 2 * border || height > 2 + maxTextureSize
           || logbase2( height - 2 * border ) < 0) {
          if (!isProxy) {
             char message[100];
-            sprintf(message, "glTexImage%dD(height)", dimensions);
-            gl_error(ctx, GL_INVALID_VALUE, message);
+            sprintf(message, "glTexImage%dD(height=%d)", dimensions, height);
+            _mesa_error(ctx, GL_INVALID_VALUE, message);
          }
          return GL_TRUE;
       }
@@ -845,7 +830,7 @@
        target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
       if (width != height) {
          if (!isProxy) {
-            gl_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
+            _mesa_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
          }
          return GL_TRUE;
       }
@@ -853,44 +838,103 @@
 
    /* Depth */
    if (dimensions >= 3) {
-      if (depth < 2 * border || depth > 2 + ctx->Const.MaxTextureSize
+      if (depth < 2 * border || depth > 2 + maxTextureSize
           || logbase2( depth - 2 * border ) < 0) {
          if (!isProxy) {
-            gl_error( ctx, GL_INVALID_VALUE, "glTexImage3D(depth)" );
+            char message[100];
+            sprintf(message, "glTexImage3D(depth=%d)", depth );
+            _mesa_error( ctx, GL_INVALID_VALUE, message );
          }
          return GL_TRUE;
       }
    }
 
    /* Level */
-   if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
+   if (target == GL_TEXTURE_RECTANGLE_NV ||
+       target == GL_PROXY_TEXTURE_RECTANGLE_NV) {
+      if (level != 0) {
+         if (!isProxy) {
+            char message[100];
+            sprintf(message, "glTexImage%dD(level=%d)", dimensions, level);
+            _mesa_error(ctx, GL_INVALID_VALUE, message);
+         }
+         return GL_TRUE;
+      }
+   }
+   else if (level < 0 || level >= maxLevels) {
       if (!isProxy) {
          char message[100];
-         sprintf(message, "glTexImage%dD(level)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         sprintf(message, "glTexImage%dD(level=%d)", dimensions, level);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
       }
       return GL_TRUE;
    }
 
+   /* For cube map, width must equal height */
+   if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
+       target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
+      if (width != height) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexImage2D(width != height)");
+         return GL_TRUE;
+      }
+   }
+
    iformat = _mesa_base_tex_format( ctx, internalFormat );
    if (iformat < 0) {
       if (!isProxy) {
          char message[100];
-         sprintf(message, "glTexImage%dD(internalFormat)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         sprintf(message, "glTexImage%dD(internalFormat=0x%x)", dimensions,
+                 internalFormat);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
+      }
+      return GL_TRUE;
+   }
+
+   ASSERT(iformat > 0);
+
+   if (!is_compressed_format( ctx, internalFormat ) &&
+       !_mesa_is_legal_format_and_type( format, type )) {
+      /* Yes, generate GL_INVALID_OPERATION, not GL_INVALID_ENUM, if there
+       * is a type/format mismatch.  See 1.2 spec page 94, sec 3.6.4.
+       */
+      if (!isProxy) {
+	 char message[100];
+	 sprintf(message, "glTexImage%dD(format or type)", dimensions);
+	 _mesa_error(ctx, GL_INVALID_OPERATION, message);
       }
       return GL_TRUE;
    }
 
-   if (!is_compressed_format(ctx, internalFormat)) {
-      if (!_mesa_is_legal_format_and_type( format, type )) {
-         /* Yes, generate GL_INVALID_OPERATION, not GL_INVALID_ENUM, if there
-          * is a type/format mismatch.  See 1.2 spec page 94, sec 3.6.4.
-          */
+   if (format == GL_YCBCR_MESA || iformat == GL_YCBCR_MESA) {
+      ASSERT(ctx->Extensions.MESA_ycbcr_texture);
+      if (format != GL_YCBCR_MESA ||
+          iformat != GL_YCBCR_MESA ||
+          (type != GL_UNSIGNED_SHORT_8_8_MESA &&
+          type != GL_UNSIGNED_SHORT_8_8_REV_MESA)) {
+         if (!isProxy) {
+            char message[100];
+            sprintf(message,
+                    "glTexImage%d(format/type/internalFormat YCBCR mismatch)",
+                    dimensions);
+            _mesa_error(ctx, GL_INVALID_ENUM, message);
+         }
+         return GL_TRUE; /* error */
+      }
+      if (target != GL_TEXTURE_2D &&
+          target != GL_PROXY_TEXTURE_2D &&
+          target != GL_TEXTURE_RECTANGLE_NV &&
+          target != GL_PROXY_TEXTURE_RECTANGLE_NV) {
+         if (!isProxy)
+            _mesa_error(ctx, GL_INVALID_ENUM, "glTexImage(target)");
+         return GL_TRUE;
+      }
+      if (border != 0) {
          if (!isProxy) {
             char message[100];
-            sprintf(message, "glTexImage%dD(format or type)", dimensions);
-            gl_error(ctx, GL_INVALID_OPERATION, message);
+            sprintf(message,
+                    "glTexImage%d(format=GL_YCBCR_MESA and border=%d)",
+                    dimensions, border);
+            _mesa_error(ctx, GL_INVALID_VALUE, message);
          }
          return GL_TRUE;
       }
@@ -917,104 +961,139 @@
 {
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    struct gl_texture_image *destTex;
+   GLint maxLevels = 0;
+   GLboolean compressed;
 
    if (dimensions == 1) {
-      if (target != GL_TEXTURE_1D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage1D(target)" );
+      if (target == GL_TEXTURE_1D) {
+         maxLevels = ctx->Const.MaxTextureLevels;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage1D(target)" );
          return GL_TRUE;
       }
    }
    else if (dimensions == 2) {
-      if (ctx->Extensions.HaveTextureCubeMap) {
-         if ((target < GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB ||
-              target > GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) &&
-             target != GL_TEXTURE_2D) {
-            gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
-            return GL_TRUE;
-         }
+      if (ctx->Extensions.ARB_texture_cube_map &&
+          target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
+          target <=GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
+         maxLevels = ctx->Const.MaxCubeTextureLevels;
+      }
+      else if (ctx->Extensions.NV_texture_rectangle &&
+               target == GL_TEXTURE_RECTANGLE_NV) {
+         maxLevels = 1;
       }
-      else if (target != GL_TEXTURE_2D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
+      else if (target == GL_TEXTURE_2D) {
+         maxLevels = ctx->Const.MaxTextureLevels;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage2D(target)" );
          return GL_TRUE;
       }
    }
    else if (dimensions == 3) {
-      if (target != GL_TEXTURE_3D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glTexSubImage3D(target)" );
+      if (target == GL_TEXTURE_3D) {
+         maxLevels = ctx->Const.Max3DTextureLevels;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexSubImage3D(target)" );
          return GL_TRUE;
       }
    }
    else {
-      gl_problem( ctx, "bad dims in texture_error_check" );
+      _mesa_problem( ctx, "bad dims in texture_error_check" );
       return GL_TRUE;
    }
+
+   ASSERT(maxLevels > 0);
 
-   if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
-      gl_error(ctx, GL_INVALID_ENUM, "glTexSubImage2D(level)");
+   if (level < 0 || level >= maxLevels) {
+      char message[100];
+      sprintf(message, "glTexSubImage2D(level=%d)", level);
+      _mesa_error(ctx, GL_INVALID_ENUM, message);
       return GL_TRUE;
    }
 
    if (width < 0) {
       char message[100];
-      sprintf(message, "glTexSubImage%dD(width)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glTexSubImage%dD(width=%d)", dimensions, width);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
    if (height < 0 && dimensions > 1) {
       char message[100];
-      sprintf(message, "glTexSubImage%dD(height)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glTexSubImage%dD(height=%d)", dimensions, height);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
    if (depth < 0 && dimensions > 2) {
       char message[100];
-      sprintf(message, "glTexSubImage%dD(depth)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glTexSubImage%dD(depth=%d)", dimensions, depth);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
+
+   destTex = _mesa_select_tex_image(ctx, texUnit, target, level);
 
-   destTex = texUnit->CurrentD[dimensions]->Image[level];
    if (!destTex) {
-      gl_error(ctx, GL_INVALID_OPERATION, "glTexSubImage1/2/3D");
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexSubImage1/2/3D");
       return GL_TRUE;
    }
 
    if (xoffset < -((GLint)destTex->Border)) {
-      gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset)");
       return GL_TRUE;
    }
    if (xoffset + width > (GLint) (destTex->Width + destTex->Border)) {
-      gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset+width)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage1/2/3D(xoffset+width)");
       return GL_TRUE;
    }
    if (dimensions > 1) {
       if (yoffset < -((GLint)destTex->Border)) {
-         gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset)");
+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset)");
          return GL_TRUE;
       }
       if (yoffset + height > (GLint) (destTex->Height + destTex->Border)) {
-         gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset+height)");
+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage2/3D(yoffset+height)");
          return GL_TRUE;
       }
    }
    if (dimensions > 2) {
       if (zoffset < -((GLint)destTex->Border)) {
-         gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");
+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset)");
          return GL_TRUE;
       }
-      if (zoffset + depth  > (GLint) (destTex->Depth+destTex->Border)) {
-         gl_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");
+      if (zoffset + depth  > (GLint) (destTex->Depth + destTex->Border)) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glTexSubImage3D(zoffset+depth)");
          return GL_TRUE;
       }
    }
 
-   if (!is_compressed_format(ctx, destTex->IntFormat)) {
-      if (!_mesa_is_legal_format_and_type(format, type)) {
-         char message[100];
-         sprintf(message, "glTexSubImage%dD(format or type)", dimensions);
-         gl_error(ctx, GL_INVALID_ENUM, message);
+   compressed = is_compressed_format(ctx, destTex->IntFormat);
+
+   if (!compressed && !_mesa_is_legal_format_and_type(format, type)) {
+      char message[100];
+      sprintf(message, "glTexSubImage%dD(format or type)", dimensions);
+      _mesa_error(ctx, GL_INVALID_ENUM, message);
+      return GL_TRUE;
+   }
+
+   if (compressed) {
+      if (xoffset != -((GLint)destTex->Border)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glTexSubImage1/2/3D(xoffset != -border");
          return GL_TRUE;
       }
+      if (dimensions > 1 && yoffset != -((GLint)destTex->Border)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glTexSubImage2/3D(yoffset != -border");
+         return GL_TRUE;
+      }
+      if (dimensions > 2 && zoffset != -((GLint)destTex->Border)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glTexSubImage3D(zoffset != -border");
+         return GL_TRUE;
+      }
    }
 
    return GL_FALSE;
@@ -1032,52 +1111,68 @@
                          GLint width, GLint height, GLint border )
 {
    GLint iformat;
+   GLint maxLevels = 0, maxTextureSize;
 
    if (dimensions == 1) {
       if (target != GL_TEXTURE_1D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glCopyTexImage1D(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage1D(target)" );
          return GL_TRUE;
       }
+      maxLevels = ctx->Const.MaxTextureLevels;
    }
    else if (dimensions == 2) {
-      if (ctx->Extensions.HaveTextureCubeMap) {
-         if ((target < GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB ||
-              target > GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) &&
-             target != GL_TEXTURE_2D) {
-            gl_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
+      if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
+          target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
             return GL_TRUE;
          }
       }
-      else if (target != GL_TEXTURE_2D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
+      else if (target == GL_TEXTURE_RECTANGLE_NV) {
+         if (!ctx->Extensions.NV_texture_rectangle) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
+            return GL_TRUE;
+         }
+      }
+      else if (target != GL_TEXTURE_2D) {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexImage2D(target)" );
          return GL_TRUE;
       }
+      if (target == GL_TEXTURE_2D)
+         maxLevels = ctx->Const.MaxTextureLevels;
+      else if (target == GL_TEXTURE_RECTANGLE_NV)
+         maxLevels = 1;
+      else
+         maxLevels = ctx->Const.MaxCubeTextureLevels;
    }
 
+   ASSERT(maxLevels > 0);
+   maxTextureSize = 1 << (maxLevels - 1);
+
    /* Border */
-   if (border!=0 && border!=1) {
+   if (border != 0 && border != 1) {
       char message[100];
       sprintf(message, "glCopyTexImage%dD(border)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
 
    /* Width */
-   if (width < 2 * border || width > 2 + ctx->Const.MaxTextureSize
+   if (width < 2 * border || width > 2 + maxTextureSize
        || logbase2( width - 2 * border ) < 0) {
       char message[100];
-      sprintf(message, "glCopyTexImage%dD(width)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glCopyTexImage%dD(width=%d)", dimensions, width);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
 
    /* Height */
    if (dimensions >= 2) {
-      if (height < 2 * border || height > 2 + ctx->Const.MaxTextureSize
+      if (height < 2 * border || height > 2 + maxTextureSize
           || logbase2( height - 2 * border ) < 0) {
          char message[100];
-         sprintf(message, "glCopyTexImage%dD(height)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         sprintf(message, "glCopyTexImage%dD(height=%d)", dimensions, height);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
          return GL_TRUE;
       }
    }
@@ -1086,24 +1181,24 @@
    if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
        target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) {
       if (width != height) {
-         gl_error(ctx, GL_INVALID_VALUE, "glCopyTexImage2D(width != height)");
+         _mesa_error(ctx, GL_INVALID_VALUE, "glCopyTexImage2D(width != height)");
          return GL_TRUE;
       }
    }
 
    /* Level */
-   if (level<0 || level>=ctx->Const.MaxTextureLevels) {
+   if (level < 0 || level >= maxLevels) {
       char message[100];
-      sprintf(message, "glCopyTexImage%dD(level)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glCopyTexImage%dD(level=%d)", dimensions, level);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
 
-   iformat = _mesa_base_tex_format( ctx, internalFormat );
+   iformat = _mesa_base_tex_format(ctx, internalFormat);
    if (iformat < 0) {
       char message[100];
       sprintf(message, "glCopyTexImage%dD(internalFormat)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
 
@@ -1120,86 +1215,96 @@
 {
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    struct gl_texture_image *teximage;
+   GLint maxLevels = 0;
+   GLboolean compressed;
 
    if (dimensions == 1) {
       if (target != GL_TEXTURE_1D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage1D(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage1D(target)" );
          return GL_TRUE;
       }
+      maxLevels = ctx->Const.MaxTextureLevels;
    }
    else if (dimensions == 2) {
-      if (ctx->Extensions.HaveTextureCubeMap) {
+      if (ctx->Extensions.ARB_texture_cube_map) {
          if ((target < GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB ||
               target > GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) &&
              target != GL_TEXTURE_2D) {
-            gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
+            _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
             return GL_TRUE;
          }
       }
       else if (target != GL_TEXTURE_2D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage2D(target)" );
          return GL_TRUE;
       }
+      if (target == GL_TEXTURE_2D)
+         maxLevels = ctx->Const.MaxTextureLevels;
+      else
+         maxLevels = ctx->Const.MaxCubeTextureLevels;
    }
    else if (dimensions == 3) {
       if (target != GL_TEXTURE_3D) {
-         gl_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage3D(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glCopyTexSubImage3D(target)" );
          return GL_TRUE;
       }
+      maxLevels = ctx->Const.Max3DTextureLevels;
    }
+
+   ASSERT(maxLevels > 0);
 
-   if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
+   if (level < 0 || level >= maxLevels) {
       char message[100];
-      sprintf(message, "glCopyTexSubImage%dD(level)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glCopyTexSubImage%dD(level=%d)", dimensions, level);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
 
    if (width < 0) {
       char message[100];
-      sprintf(message, "glCopyTexSubImage%dD(width)", dimensions );
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glCopyTexSubImage%dD(width=%d)", dimensions, width);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
    if (dimensions > 1 && height < 0) {
       char message[100];
-      sprintf(message, "glCopyTexSubImage%dD(height)", dimensions );
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glCopyTexSubImage%dD(height=%d)", dimensions, height);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
 
-   teximage = texUnit->CurrentD[dimensions]->Image[level];
+   teximage = _mesa_select_tex_image(ctx, texUnit, target, level);
    if (!teximage) {
       char message[100];
       sprintf(message, "glCopyTexSubImage%dD(undefined texture)", dimensions);
-      gl_error(ctx, GL_INVALID_OPERATION, message);
+      _mesa_error(ctx, GL_INVALID_OPERATION, message);
       return GL_TRUE;
    }
 
    if (xoffset < -((GLint)teximage->Border)) {
       char message[100];
-      sprintf(message, "glCopyTexSubImage%dD(xoffset)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      sprintf(message, "glCopyTexSubImage%dD(xoffset=%d)", dimensions, xoffset);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
-   if (xoffset+width > (GLint) (teximage->Width+teximage->Border)) {
+   if (xoffset + width > (GLint) (teximage->Width + teximage->Border)) {
       char message[100];
       sprintf(message, "glCopyTexSubImage%dD(xoffset+width)", dimensions);
-      gl_error(ctx, GL_INVALID_VALUE, message);
+      _mesa_error(ctx, GL_INVALID_VALUE, message);
       return GL_TRUE;
    }
    if (dimensions > 1) {
       if (yoffset < -((GLint)teximage->Border)) {
          char message[100];
-         sprintf(message, "glCopyTexSubImage%dD(yoffset)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         sprintf(message, "glCopyTexSubImage%dD(yoffset=%d)", dimensions, yoffset);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
          return GL_TRUE;
       }
       /* NOTE: we're adding the border here, not subtracting! */
-      if (yoffset+height > (GLint) (teximage->Height+teximage->Border)) {
+      if (yoffset + height > (GLint) (teximage->Height + teximage->Border)) {
          char message[100];
          sprintf(message, "glCopyTexSubImage%dD(yoffset+height)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
          return GL_TRUE;
       }
    }
@@ -1208,121 +1313,194 @@
       if (zoffset < -((GLint)teximage->Border)) {
          char message[100];
          sprintf(message, "glCopyTexSubImage%dD(zoffset)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
          return GL_TRUE;
       }
-      if (zoffset > (GLint) (teximage->Depth+teximage->Border)) {
+      if (zoffset > (GLint) (teximage->Depth + teximage->Border)) {
          char message[100];
          sprintf(message, "glCopyTexSubImage%dD(zoffset+depth)", dimensions);
-         gl_error(ctx, GL_INVALID_VALUE, message);
+         _mesa_error(ctx, GL_INVALID_VALUE, message);
+         return GL_TRUE;
+      }
+   }
+
+   compressed = is_compressed_format(ctx, teximage->IntFormat);
+   if (compressed) {
+      if (xoffset != -((GLint)teximage->Border)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glCopyTexSubImage1/2/3D(xoffset != -border");
+         return GL_TRUE;
+      }
+      if (dimensions > 1 && yoffset != -((GLint)teximage->Border)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glCopyTexSubImage2/3D(yoffset != -border");
+         return GL_TRUE;
+      }
+      if (dimensions > 2 && zoffset != -((GLint)teximage->Border)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glCopyTexSubImage3D(zoffset != -border");
          return GL_TRUE;
       }
    }
 
+   if (teximage->IntFormat == GL_YCBCR_MESA) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glCopyTexSubImage2D");
+      return GL_TRUE;
+   }
+
    /* if we get here, the parameters are OK */
    return GL_FALSE;
 }
 
 
 
+void
+_mesa_GetTexImage( GLenum target, GLint level, GLenum format,
+                   GLenum type, GLvoid *pixels )
+{
+   const struct gl_texture_unit *texUnit;
+   const struct gl_texture_object *texObj;
+   const struct gl_texture_image *texImage;
+   GLint maxLevels = 0;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-/*
- * Turn generic compressed formats into specific compressed format.
- * Some of the compressed formats we don't support, so we
- * fall back to the uncompressed format.  (See issue 15 of
- * the GL_ARB_texture_compression specification.)
- */
-static GLint
-get_specific_compressed_tex_format(GLcontext *ctx,
-                                   GLint ifmt, GLint numDimensions,
-                                   GLint     *levelp,
-                                   GLsizei   *widthp,
-                                   GLsizei   *heightp,
-                                   GLsizei   *depthp,
-                                   GLint     *borderp,
-                                   GLenum    *formatp,
-                                   GLenum    *typep)
-{
-   char message[100];
-   GLint internalFormat = ifmt;
-
-   if (ctx->Extensions.HaveTextureCompression
-       && ctx->Driver.SpecificCompressedTexFormat) {
-      /*
-       * First, ask the driver for the specific format.
-       * We do this for all formats, since we may want to
-       * fake one compressed format for another.
-       */
-       internalFormat = (*ctx->Driver.SpecificCompressedTexFormat)
-                               (ctx, internalFormat, numDimensions,
-                                levelp,
-                                widthp, heightp, depthp,
-                                borderp, formatp, typep);
+   texUnit = &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   if (!texObj || is_proxy_target(target)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");
+      return;
    }
 
-   /*
-    * Now, convert any generic format left to an uncompressed
-    * specific format.  If the driver does not support compression
-    * of the format, we must drop back to the uncompressed format.
-    * See issue 15 of the GL_ARB_texture_compression specification.
-    */
-   switch (internalFormat) {
-      case GL_COMPRESSED_ALPHA_ARB:
-         if (ctx && !ctx->Extensions.HaveTextureCompression) {
-            sprintf(message, "glTexImage%dD(internalFormat)", numDimensions);
-            gl_error(ctx, GL_INVALID_VALUE, message);
-            return -1;
-         }
-         internalFormat = GL_ALPHA;
-         break;
-      case GL_COMPRESSED_LUMINANCE_ARB:
-         if (ctx && !ctx->Extensions.HaveTextureCompression) {
-            sprintf(message, "glTexImage%dD(internalFormat)", numDimensions);
-            gl_error(ctx, GL_INVALID_VALUE, message);
-            return -1;
-         }
-         internalFormat = GL_LUMINANCE;
-         break;
-      case GL_COMPRESSED_LUMINANCE_ALPHA_ARB:
-         if (ctx && !ctx->Extensions.HaveTextureCompression) {
-            sprintf(message, "glTexImage%dD(internalFormat)", numDimensions);
-            gl_error(ctx, GL_INVALID_VALUE, message);
-            return -1;
-         }
-         internalFormat = GL_LUMINANCE_ALPHA;
-         break;
-      case GL_COMPRESSED_INTENSITY_ARB:
-         if (ctx && !ctx->Extensions.HaveTextureCompression) {
-            sprintf(message, "glTexImage%dD(internalFormat)", numDimensions);
-            gl_error(ctx, GL_INVALID_VALUE, message);
-            return -1;
-         }
-         internalFormat = GL_INTENSITY;
-         break;
-      case GL_COMPRESSED_RGB_ARB:
-         if (ctx && !ctx->Extensions.HaveTextureCompression) {
-            sprintf(message, "glTexImage%dD(internalFormat)", numDimensions);
-            gl_error(ctx, GL_INVALID_VALUE, message);
-            return -1;
-         }
-         internalFormat = GL_RGB;
-         break;
-      case GL_COMPRESSED_RGBA_ARB:
-         if (ctx && !ctx->Extensions.HaveTextureCompression) {
-            sprintf(message, "glTexImage%dD(internalFormat)", numDimensions);
-            gl_error(ctx, GL_INVALID_VALUE, message);
-            return -1;
-         }
-         internalFormat = GL_RGBA;
-         break;
-      default:
-         /* silence compiler warning */
-         ;
+   if (target == GL_TEXTURE_1D || target == GL_TEXTURE_2D) {
+      maxLevels = ctx->Const.MaxTextureLevels;
    }
-   return internalFormat;
+   else if (target == GL_TEXTURE_3D) {
+      maxLevels = ctx->Const.Max3DTextureLevels;
+   }
+   else if (target == GL_TEXTURE_RECTANGLE_NV) {
+      maxLevels = 1;
+   }
+   else {
+      maxLevels = ctx->Const.MaxCubeTextureLevels;
+   }
+
+   ASSERT(maxLevels > 0);
+
+   if (level < 0 || level >= maxLevels) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
+      return;
+   }
+
+   if (_mesa_sizeof_packed_type(type) <= 0) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
+      return;
+   }
+
+   if (_mesa_components_in_format(format) <= 0 ||
+       format == GL_STENCIL_INDEX) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
+      return;
+   }
+
+   if (!ctx->Extensions.EXT_paletted_texture && is_index_format(format)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+   }
+
+   if (!ctx->Extensions.SGIX_depth_texture && format == GL_DEPTH_COMPONENT) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+   }
+
+   if (!ctx->Extensions.MESA_ycbcr_texture && format == GL_YCBCR_MESA) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+   }
+
+   /* XXX what if format/type doesn't match texture format/type? */
+
+   if (!pixels)
+      return;
+
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   if (!texImage) {
+      /* invalid mipmap level, not an error */
+      return;
+   }
+
+   if (!texImage->Data) {
+      /* no image data, not an error */
+      return;
+   }
+
+   {
+      const GLint width = texImage->Width;
+      const GLint height = texImage->Height;
+      const GLint depth = texImage->Depth;
+      GLint img, row;
+      for (img = 0; img < depth; img++) {
+         for (row = 0; row < height; row++) {
+            /* compute destination address in client memory */
+            GLvoid *dest = _mesa_image_address( &ctx->Pack, pixels,
+                                                width, height, format, type,
+                                                img, row, 0);
+            assert(dest);
+
+            if (format == GL_COLOR_INDEX) {
+               GLuint indexRow[MAX_WIDTH];
+               GLint col;
+               for (col = 0; col < width; col++) {
+                  (*texImage->FetchTexel)(texImage, col, row, img,
+                                          (GLvoid *) &indexRow[col]);
+               }
+               _mesa_pack_index_span(ctx, width, type, dest,
+                                     indexRow, &ctx->Pack,
+                                     0 /* no image transfer */);
+            }
+            else if (format == GL_DEPTH_COMPONENT) {
+               GLfloat depthRow[MAX_WIDTH];
+               GLint col;
+               for (col = 0; col < width; col++) {
+                  (*texImage->FetchTexel)(texImage, col, row, img,
+                                          (GLvoid *) &depthRow[col]);
+               }
+               _mesa_pack_depth_span(ctx, width, dest, type,
+                                     depthRow, &ctx->Pack);
+            }
+            else if (format == GL_YCBCR_MESA) {
+	       const GLint rowstride = texImage->RowStride;
+               /* No pixel transfer */
+               MEMCPY(dest, (const GLushort *) texImage->Data + row * rowstride,
+                      width * sizeof(GLushort));
+               /* check for byte swapping */
+               if ((texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR
+                    && type == GL_UNSIGNED_SHORT_8_8_REV_MESA) ||
+                   (texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR_REV
+                    && type == GL_UNSIGNED_SHORT_8_8_MESA)) {
+                  if (!ctx->Pack.SwapBytes)
+                     _mesa_swap2((GLushort *) dest, width);
+               }
+               else if (ctx->Pack.SwapBytes) {
+                  _mesa_swap2((GLushort *) dest, width);
+               }
+            }
+            else {
+               /* general case:  convert row to RGBA format */
+               GLchan rgba[MAX_WIDTH][4];
+               GLint col;
+               for (col = 0; col < width; col++) {
+                  (*texImage->FetchTexel)(texImage, col, row, img,
+                                          (GLvoid *) rgba[col]);
+               }
+               _mesa_pack_rgba_span(ctx, width, (const GLchan (*)[4])rgba,
+                                    format, type, dest, &ctx->Pack,
+                                    0 /* no image transfer */);
+            } /* format */
+         } /* row */
+      } /* img */
+   }
 }
 
 
+
 /*
  * Called from the API.  Note that width includes the border.
  */
@@ -1331,121 +1509,114 @@
                   GLsizei width, GLint border, GLenum format,
                   GLenum type, const GLvoid *pixels )
 {
+   GLsizei postConvWidth = width;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexImage1D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (is_color_format(internalFormat)) {
+      _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
+   }
 
-   if (target==GL_TEXTURE_1D) {
+   if (target == GL_TEXTURE_1D) {
       struct gl_texture_unit *texUnit;
       struct gl_texture_object *texObj;
       struct gl_texture_image *texImage;
-      GLint ifmt;
 
-      ifmt = get_specific_compressed_tex_format(ctx, internalFormat, 1,
-                                                &level,
-                                                &width, 0, 0,
-                                                &border, &format, &type);
-      if (ifmt < 0) {
-         /*
-          * The error here is that we were sent a generic compressed
-          * format, but the extension is not supported.
-          */
-         return;
-      }
-      else {
-         internalFormat = ifmt;
-      }
-
       if (texture_error_check(ctx, target, level, internalFormat,
-                              format, type, 1, width, 1, 1, border)) {
-         return;   /* error in texture image was detected */
+                              format, type, 1, postConvWidth, 1, 1, border)) {
+         return;   /* error was recorded */
       }
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texObj = texUnit->CurrentD[1];
-      texImage = texObj->Image[level];
+      texObj = _mesa_select_tex_object(ctx, texUnit, target);
+      texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
       if (!texImage) {
          texImage = _mesa_alloc_texture_image();
          texObj->Image[level] = texImage;
          if (!texImage) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
             return;
          }
       }
-      else if (texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
+      else if (texImage->Data && !texImage->IsClientData) {
+         /* free the old texture data */
+         MESA_PBUFFER_FREE(texImage->Data);
       }
+      texImage->Data = NULL;
+      clear_teximage_fields(texImage); /* not really needed, but helpful */
+      _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
+                                 border, internalFormat);
 
-      /* setup the teximage struct's fields */
-      init_texture_image(ctx, texImage, width, 1, 1, border, internalFormat);
+      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+         _mesa_update_state(ctx);
 
-      /* process the texture image */
+      ASSERT(ctx->Driver.TexImage1D);
+
+#if 0 /* don't make default teximage anymore */
       if (pixels) {
-         GLboolean retain = GL_TRUE;
-         GLboolean success = GL_FALSE;
-         if (!ctx->Pixel.MapColorFlag && !ctx->Pixel.ScaleOrBiasRGBA
-             && ctx->Driver.TexImage1D) {
-            /* let device driver try to use raw image */
-            success = (*ctx->Driver.TexImage1D)( ctx, target, level, format,
-                                                 type, pixels, &ctx->Unpack,
-                                                 texObj, texImage, &retain);
-         }
-         if (retain || !success) {
-            /* make internal copy of the texture image */
-            make_texture_image(ctx, texImage, format, type,
-                               pixels, &ctx->Unpack);
-            if (!success && ctx->Driver.TexImage1D) {
-               /* let device driver try to use unpacked image */
-               (*ctx->Driver.TexImage1D)( ctx, target, level, texImage->Format,
-                                          GL_UNSIGNED_BYTE, texImage->Data,
-                                          &_mesa_native_packing,
-                                          texObj, texImage, &retain);
-            }
-         }
-         if (!retain && texImage->Data) {
-            FREE(texImage->Data);
-            texImage->Data = NULL;
-         }
+         (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
+                                   width, border, format, type, pixels,
+                                   &ctx->Unpack, texObj, texImage);
       }
       else {
-         make_null_texture(texImage);
-         if (ctx->Driver.TexImage1D) {
-            GLboolean retain;
-            (*ctx->Driver.TexImage1D)( ctx, target, level, texImage->Format,
-                                       GL_UNSIGNED_BYTE, texImage->Data,
-                                       &_mesa_native_packing,
-                                       texObj, texImage, &retain);
+         GLubyte *dummy = make_null_texture(width, 1, 1, format);
+         if (dummy) {
+            (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
+                                      width, border,
+                                      format, GL_UNSIGNED_BYTE, dummy,
+                                      &_mesa_native_packing, texObj, texImage);
+            FREE(dummy);
          }
       }
+#else
+      /* <pixels> may be null! */
+      (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
+                                width, border, format, type, pixels,
+                                &ctx->Unpack, texObj, texImage);
+#endif
 
+      ASSERT(texImage->TexFormat);
+      if (!texImage->FetchTexel) {
+         /* If driver didn't explicitly set this, use the default */
+         texImage->FetchTexel = texImage->TexFormat->FetchTexel1D;
+      }
+      ASSERT(texImage->FetchTexel);
+
+      if (texImage->IsCompressed) {
+         ASSERT(texImage->CompressedSize > 0);
+      }
+
       /* state update */
-      gl_put_texobj_on_dirty_list( ctx, texObj );
-      ctx->NewState |= NEW_TEXTURING;
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
    }
    else if (target == GL_PROXY_TEXTURE_1D) {
       /* Proxy texture: check for errors and update proxy state */
       GLenum error = texture_error_check(ctx, target, level, internalFormat,
-                                         format, type, 1, width, 1, 1, border);
-      if (!error && ctx->Driver.TestProxyTexImage) {
+                                         format, type, 1,
+                                         postConvWidth, 1, 1, border);
+      if (!error) {
+         struct gl_texture_unit *texUnit;
+         struct gl_texture_image *texImage;
+         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+         _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
+                                    border, internalFormat);
+         ASSERT(ctx->Driver.TestProxyTexImage);
          error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
                                                   internalFormat, format, type,
-                                                  width, 1, 1, border);
+                                                  postConvWidth, 1, 1, border);
       }
       if (error) {
          /* if error, clear all proxy texture image parameters */
-         if (level>=0 && level<ctx->Const.MaxTextureLevels) {
-            clear_proxy_teximage(ctx->Texture.Proxy1D->Image[level]);
+         if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
+            clear_teximage_fields(ctx->Texture.Proxy1D->Image[level]);
          }
       }
-      else {
-         /* if no error, update proxy texture image parameters */
-         init_texture_image(ctx, ctx->Texture.Proxy1D->Image[level],
-                            width, 1, 1, border, internalFormat);
-      }
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage1D(target)" );
       return;
    }
 }
@@ -1457,36 +1628,30 @@
                   GLenum format, GLenum type,
                   const GLvoid *pixels )
 {
+   GLsizei postConvWidth = width, postConvHeight = height;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexImage2D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (is_color_format(internalFormat)) {
+      _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
+					 &postConvHeight);
+   }
 
-   if (target==GL_TEXTURE_2D ||
-       (ctx->Extensions.HaveTextureCubeMap &&
+   if (target == GL_TEXTURE_2D ||
+       (ctx->Extensions.ARB_texture_cube_map &&
         target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-        target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
+        target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) ||
+       (ctx->Extensions.NV_texture_rectangle &&
+        target == GL_TEXTURE_RECTANGLE_NV)) {
+      /* non-proxy target */
       struct gl_texture_unit *texUnit;
       struct gl_texture_object *texObj;
       struct gl_texture_image *texImage;
-      GLint ifmt;
-
-      ifmt = get_specific_compressed_tex_format(ctx, internalFormat, 2,
-                                                &level,
-                                                &width, &height, 0,
-                                                &border, &format, &type);
-      if (ifmt < 0) {
-         /*
-          * The error here is that we were sent a generic compressed
-          * format, but the extension is not supported.
-          */
-         return;
-      }
-      else {
-         internalFormat = ifmt;
-      }
 
       if (texture_error_check(ctx, target, level, internalFormat,
-                              format, type, 2, width, height, 1, border)) {
-         return;   /* error in texture image was detected */
+                              format, type, 2, postConvWidth, postConvHeight,
+                              1, border)) {
+         return;   /* error was recorded */
       }
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
@@ -1495,98 +1660,97 @@
 
       if (!texImage) {
          texImage = _mesa_alloc_texture_image();
-         set_tex_image(texObj, target, level, texImage);
-         /*texObj->Image[level] = texImage;*/
+         _mesa_set_tex_image(texObj, target, level, texImage);
          if (!texImage) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
             return;
          }
-      }
-      else if (texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
       }
+      else if (texImage->Data && !texImage->IsClientData) {
+         /* free the old texture data */
+         MESA_PBUFFER_FREE(texImage->Data);
+      }
+      texImage->Data = NULL;
+      clear_teximage_fields(texImage); /* not really needed, but helpful */
+      _mesa_init_teximage_fields(ctx, target, texImage,
+                                 postConvWidth, postConvHeight,
+                                 1, border, internalFormat);
 
-      /* setup the teximage struct's fields */
-      init_texture_image(ctx, texImage, width, height,
-                         1, border, internalFormat);
+      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+         _mesa_update_state(ctx);
 
-      /* process the texture image */
+      ASSERT(ctx->Driver.TexImage2D);
+
+#if 0 /* don't make default teximage anymore */
       if (pixels) {
-         GLboolean retain = GL_TRUE;
-         GLboolean success = GL_FALSE;
-         if (!ctx->Pixel.MapColorFlag && !ctx->Pixel.ScaleOrBiasRGBA
-             && ctx->Driver.TexImage2D) {
-            /* let device driver try to use raw image */
-            success = (*ctx->Driver.TexImage2D)( ctx, target, level, format,
-                                                 type, pixels, &ctx->Unpack,
-                                                 texObj, texImage, &retain);
-         }
-         if (retain || !success) {
-            /* make internal copy of the texture image */
-            make_texture_image(ctx, texImage, format, type,
-                               pixels, &ctx->Unpack);
-            if (!success && ctx->Driver.TexImage2D) {
-               /* let device driver try to use unpacked image */
-               (*ctx->Driver.TexImage2D)( ctx, target, level, texImage->Format,
-                                          GL_UNSIGNED_BYTE, texImage->Data,
-                                          &_mesa_native_packing,
-                                          texObj, texImage, &retain);
-            }
-         }
-         if (!retain && texImage->Data) {
-            FREE(texImage->Data);
-            texImage->Data = NULL;
-         }
+         (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
+                                   width, height, border, format, type, pixels,
+                                   &ctx->Unpack, texObj, texImage);
       }
       else {
-         make_null_texture(texImage);
-         if (ctx->Driver.TexImage2D) {
-            GLboolean retain;
-            (*ctx->Driver.TexImage2D)( ctx, target, level, texImage->Format,
-                                       GL_UNSIGNED_BYTE, texImage->Data,
-                                       &_mesa_native_packing,
-                                       texObj, texImage, &retain);
+         GLubyte *dummy = make_null_texture(width, height, 1, format);
+         if (dummy) {
+            (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
+                                      width, height, border,
+                                      format, GL_UNSIGNED_BYTE, dummy,
+                                      &_mesa_native_packing, texObj, texImage);
+            FREE(dummy);
          }
       }
+#else
+      /* <pixels> may be null! */
+      (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
+                                width, height, border, format, type, pixels,
+                                &ctx->Unpack, texObj, texImage);
+#endif
 
-#define OLD_DD_TEXTURE
-#ifdef OLD_DD_TEXTURE
-      /* XXX this will be removed in the future */
-      if (ctx->Driver.TexImage) {
-         (*ctx->Driver.TexImage)( ctx, target, texObj, level, internalFormat,
-                                  texImage );
+      ASSERT(texImage->TexFormat);
+      if (!texImage->FetchTexel) {
+         /* If driver didn't explicitly set this, use the default */
+         texImage->FetchTexel = texImage->TexFormat->FetchTexel2D;
       }
-#endif
+      ASSERT(texImage->FetchTexel);
+
+      if (texImage->IsCompressed) {
+         ASSERT(texImage->CompressedSize > 0);
+      }
 
       /* state update */
-      gl_put_texobj_on_dirty_list( ctx, texObj );
-      ctx->NewState |= NEW_TEXTURING;
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
    }
-   else if (target == GL_PROXY_TEXTURE_2D) {
+   else if (target == GL_PROXY_TEXTURE_2D ||
+            (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB &&
+             ctx->Extensions.ARB_texture_cube_map) ||
+            (target == GL_PROXY_TEXTURE_RECTANGLE_NV &&
+             ctx->Extensions.NV_texture_rectangle)) {
       /* Proxy texture: check for errors and update proxy state */
       GLenum error = texture_error_check(ctx, target, level, internalFormat,
-                                    format, type, 2, width, height, 1, border);
-      if (!error && ctx->Driver.TestProxyTexImage) {
+				format, type, 2,
+				postConvWidth, postConvHeight, 1, border);
+      if (!error) {
+         struct gl_texture_unit *texUnit;
+         struct gl_texture_image *texImage;
+         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+         _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth,
+                                    postConvHeight, 1, border, internalFormat);
+         ASSERT(ctx->Driver.TestProxyTexImage);
          error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
-                                                  internalFormat, format, type,
-                                                  width, height, 1, border);
+                                    internalFormat, format, type,
+                                    postConvWidth, postConvHeight, 1, border);
       }
       if (error) {
          /* if error, clear all proxy texture image parameters */
-         if (level>=0 && level<ctx->Const.MaxTextureLevels) {
-            clear_proxy_teximage(ctx->Texture.Proxy2D->Image[level]);
+         const GLint maxLevels = (target == GL_PROXY_TEXTURE_2D) ?
+            ctx->Const.MaxTextureLevels : ctx->Const.MaxCubeTextureLevels;
+         if (level >= 0 && level < maxLevels) {
+            clear_teximage_fields(ctx->Texture.Proxy2D->Image[level]);
          }
       }
-      else {
-         /* if no error, update proxy texture image parameters */
-         init_texture_image(ctx,
-                            ctx->Texture.Proxy2D->Image[level],
-                            width, height, 1, border, internalFormat);
-      }
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage2D(target)" );
       return;
    }
 }
@@ -1597,127 +1761,114 @@
  * Note that width and height include the border.
  */
 void
-_mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
+_mesa_TexImage3D( GLenum target, GLint level, GLenum internalFormat,
                   GLsizei width, GLsizei height, GLsizei depth,
                   GLint border, GLenum format, GLenum type,
                   const GLvoid *pixels )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexImage3D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (target==GL_TEXTURE_3D_EXT) {
+   if (target == GL_TEXTURE_3D) {
       struct gl_texture_unit *texUnit;
       struct gl_texture_object *texObj;
       struct gl_texture_image *texImage;
-      GLint ifmt;
-
-      ifmt = get_specific_compressed_tex_format(ctx, internalFormat, 3,
-                                                &level,
-                                                &width, &height, &depth,
-                                                &border, &format, &type);
-      if (ifmt < 0) {
-         /*
-          * The error here is that we were sent a generic compressed
-          * format, but the extension is not supported.
-          */
-         return;
-      }
-      else {
-         internalFormat = ifmt;
-      }
 
-      if (texture_error_check(ctx, target, level, internalFormat,
+      if (texture_error_check(ctx, target, level, (GLint) internalFormat,
                               format, type, 3, width, height, depth, border)) {
-         return;   /* error in texture image was detected */
+         return;   /* error was recorded */
       }
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texObj = texUnit->CurrentD[3];
-      texImage = texObj->Image[level];
+      texObj = _mesa_select_tex_object(ctx, texUnit, target);
+      texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
       if (!texImage) {
          texImage = _mesa_alloc_texture_image();
          texObj->Image[level] = texImage;
          if (!texImage) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
             return;
          }
       }
-      else if (texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
+      else if (texImage->Data && !texImage->IsClientData) {
+         MESA_PBUFFER_FREE(texImage->Data);
       }
+      texImage->Data = NULL;
+      clear_teximage_fields(texImage); /* not really needed, but helpful */
+      _mesa_init_teximage_fields(ctx, target, texImage, width, height, depth,
+                                 border, internalFormat);
 
-      /* setup the teximage struct's fields */
-      init_texture_image(ctx, texImage, width, height, depth,
-                         border, internalFormat);
+      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+         _mesa_update_state(ctx);
 
-      /* process the texture image */
+      ASSERT(ctx->Driver.TexImage3D);
+
+#if 0 /* don't make default teximage anymore */
       if (pixels) {
-         GLboolean retain = GL_TRUE;
-         GLboolean success = GL_FALSE;
-         if (!ctx->Pixel.MapColorFlag && !ctx->Pixel.ScaleOrBiasRGBA
-             && ctx->Driver.TexImage3D) {
-            /* let device driver try to use raw image */
-            success = (*ctx->Driver.TexImage3D)( ctx, target, level, format,
-                                                 type, pixels, &ctx->Unpack,
-                                                 texObj, texImage, &retain);
-         }
-         if (retain || !success) {
-            /* make internal copy of the texture image */
-            make_texture_image(ctx, texImage, format, type,
-                               pixels, &ctx->Unpack);
-            if (!success && ctx->Driver.TexImage3D) {
-               /* let device driver try to use unpacked image */
-               (*ctx->Driver.TexImage3D)( ctx, target, level, texImage->Format,
-                                          GL_UNSIGNED_BYTE, texImage->Data,
-                                          &_mesa_native_packing,
-                                          texObj, texImage, &retain);
-            }
-         }
-         if (!retain && texImage->Data) {
-            FREE(texImage->Data);
-            texImage->Data = NULL;
-         }
+         (*ctx->Driver.TexImage3D)(ctx, target, level, (GLint) internalFormat,
+                                   width, height, depth, border,
+                                   format, type, pixels,
+                                   &ctx->Unpack, texObj, texImage);
       }
       else {
-         make_null_texture(texImage);
-         if (ctx->Driver.TexImage3D) {
-            GLboolean retain;
-            (*ctx->Driver.TexImage3D)( ctx, target, level, texImage->Format,
-                                       GL_UNSIGNED_BYTE, texImage->Data,
-                                       &_mesa_native_packing,
-                                       texObj, texImage, &retain);
+         GLubyte *dummy = make_null_texture(width, height, depth, format);
+         if (dummy) {
+            (*ctx->Driver.TexImage3D)(ctx, target, level,
+                                      (GLint) internalFormat,
+                                      width, height, depth, border,
+                                      format, GL_UNSIGNED_BYTE, dummy,
+                                      &_mesa_native_packing, texObj, texImage);
+            FREE(dummy);
          }
       }
+#else
+      /* <pixels> may be null! */
+      (*ctx->Driver.TexImage3D)(ctx, target, level, internalFormat,
+                                width, height, depth, border, format, type,
+                                pixels, &ctx->Unpack, texObj, texImage);
+#endif
+
+      ASSERT(texImage->TexFormat);
+      if (!texImage->FetchTexel) {
+         /* If driver didn't explicitly set this, use the default */
+         texImage->FetchTexel = texImage->TexFormat->FetchTexel3D;
+      }
+      ASSERT(texImage->FetchTexel);
 
+      if (texImage->IsCompressed) {
+         ASSERT(texImage->CompressedSize > 0);
+      }
+
       /* state update */
-      gl_put_texobj_on_dirty_list( ctx, texObj );
-      ctx->NewState |= NEW_TEXTURING;
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
    }
    else if (target == GL_PROXY_TEXTURE_3D) {
       /* Proxy texture: check for errors and update proxy state */
       GLenum error = texture_error_check(ctx, target, level, internalFormat,
                                 format, type, 3, width, height, depth, border);
-      if (!error && ctx->Driver.TestProxyTexImage) {
+      if (!error) {
+         struct gl_texture_unit *texUnit;
+         struct gl_texture_image *texImage;
+         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+         _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
+                                    border, internalFormat);
+         ASSERT(ctx->Driver.TestProxyTexImage);
          error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
                                                  internalFormat, format, type,
                                                  width, height, depth, border);
       }
       if (error) {
          /* if error, clear all proxy texture image parameters */
-         if (level>=0 && level<ctx->Const.MaxTextureLevels) {
-            clear_proxy_teximage(ctx->Texture.Proxy3D->Image[level]);
+         if (level >= 0 && level < ctx->Const.Max3DTextureLevels) {
+            clear_teximage_fields(ctx->Texture.Proxy3D->Image[level]);
          }
       }
-      else {
-         /* if no error, update proxy texture image parameters */
-         init_texture_image(ctx, ctx->Texture.Proxy3D->Image[level],
-                            width, height, depth, border, internalFormat);
-      }
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexImage3D(target)" );
       return;
    }
 }
@@ -1729,328 +1880,11 @@
                      GLint border, GLenum format, GLenum type,
                      const GLvoid *pixels )
 {
-   _mesa_TexImage3D(target, level, (GLint) internalFormat, width, height,
+   _mesa_TexImage3D(target, level, internalFormat, width, height,
                     depth, border, format, type, pixels);
 }
 
 
-/*
- * Fetch a texture image from the device driver.
- * Store the results in the given texture object at the given mipmap level.
- */
-void
-_mesa_get_teximage_from_driver( GLcontext *ctx, GLenum target, GLint level,
-                                const struct gl_texture_object *texObj )
-{
-   GLvoid *image;
-   GLenum imgFormat, imgType;
-   GLboolean freeImage;
-   struct gl_texture_image *texImage;
-   GLint destComponents, numPixels, srcBytesPerTexel;
-
-   if (!ctx->Driver.GetTexImage)
-      return;
-
-   image = (*ctx->Driver.GetTexImage)( ctx, target, level, texObj,
-                                       &imgFormat, &imgType, &freeImage);
-   if (!image)
-      return;
-
-   texImage = texObj->Image[level];
-   ASSERT(texImage);
-   if (!texImage)
-      return;
-
-   destComponents = components_in_intformat(texImage->Format);
-   assert(destComponents > 0);
-   numPixels = texImage->Width * texImage->Height * texImage->Depth;
-   assert(numPixels > 0);
-   srcBytesPerTexel = _mesa_bytes_per_pixel(imgFormat, imgType);
-   assert(srcBytesPerTexel > 0);
-
-   if (!texImage->Data) {
-      /* Allocate memory for the texture image data */
-      texImage->Data = (GLubyte *) MALLOC(numPixels * destComponents + EXTRA_BYTE);
-   }
-
-   if (imgFormat == texImage->Format && imgType == GL_UNSIGNED_BYTE) {
-      /* We got lucky!  The driver's format and type match Mesa's format. */
-      if (texImage->Data) {
-         MEMCPY(texImage->Data, image, numPixels * destComponents);
-      }
-   }
-   else {
-      /* Convert the texture image from the driver's format to Mesa's
-       * internal format.
-       */
-      const GLint width = texImage->Width;
-      const GLint height = texImage->Height;
-      const GLint depth = texImage->Depth;
-      const GLint destBytesPerRow = width * destComponents * sizeof(GLchan);
-      const GLint srcBytesPerRow = width * srcBytesPerTexel;
-      const GLenum dstType = GL_UNSIGNED_BYTE;
-      const GLenum dstFormat = texImage->Format;
-      const GLubyte *srcPtr = (const GLubyte *) image;
-      GLubyte *destPtr = texImage->Data;
-
-      if (texImage->Format == GL_COLOR_INDEX) {
-         /* color index texture */
-         GLint img, row;
-         assert(imgFormat == GL_COLOR_INDEX);
-         for (img = 0; img < depth; img++) {
-            for (row = 0; row < height; row++) {
-               _mesa_unpack_index_span(ctx, width, dstType, destPtr,
-                             imgType, srcPtr, &_mesa_native_packing, GL_FALSE);
-               destPtr += destBytesPerRow;
-               srcPtr += srcBytesPerRow;
-            }
-         }
-      }
-      else {
-         /* color texture */
-         GLint img, row;
-         for (img = 0; img < depth; img++) {
-            for (row = 0; row < height; row++) {
-               _mesa_unpack_ubyte_color_span(ctx, width, dstFormat, destPtr,
-                  imgFormat, imgType, srcPtr, &_mesa_native_packing, GL_FALSE);
-               destPtr += destBytesPerRow;
-               srcPtr += srcBytesPerRow;
-            }
-         }
-      }
-   }
-
-   if (freeImage)
-      FREE(image);
-}
-
-
-/*
- * Get all the mipmap images for a texture object from the device driver.
- * Actually, only get mipmap images if we're using a mipmap filter.
- */
-GLboolean
-_mesa_get_teximages_from_driver(GLcontext *ctx,
-                                struct gl_texture_object *texObj)
-{
-   if (ctx->Driver.GetTexImage) {
-      static const GLenum targets[] = {
-         GL_TEXTURE_1D,
-         GL_TEXTURE_2D,
-         GL_TEXTURE_3D,
-         GL_TEXTURE_CUBE_MAP_ARB,
-         GL_TEXTURE_CUBE_MAP_ARB,
-         GL_TEXTURE_CUBE_MAP_ARB
-      };
-      GLboolean needLambda = (texObj->MinFilter != texObj->MagFilter);
-      GLenum target = targets[texObj->Dimensions - 1];
-      if (needLambda) {
-         GLint level;
-         /* Get images for all mipmap levels.  We might not need them
-          * all but this is easier.  We're on a (slow) software path
-          * anyway.
-          */
-         for (level = 0; level <= texObj->P; level++) {
-            struct gl_texture_image *texImg = texObj->Image[level];
-            if (texImg && !texImg->Data) {
-               _mesa_get_teximage_from_driver(ctx, target, level, texObj);
-               if (!texImg->Data)
-                  return GL_FALSE;  /* out of memory */
-            }
-         }
-      }
-      else {
-         GLint level = texObj->BaseLevel;
-         struct gl_texture_image *texImg = texObj->Image[level];
-         if (texImg && !texImg->Data) {
-            _mesa_get_teximage_from_driver(ctx, target, level, texObj);
-            if (!texImg->Data)
-               return GL_FALSE;  /* out of memory */
-         }
-      }
-      return GL_TRUE;
-   }
-   return GL_FALSE;
-}
-
-
-
-void
-_mesa_GetTexImage( GLenum target, GLint level, GLenum format,
-                   GLenum type, GLvoid *pixels )
-{
-   const struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GLboolean discardImage;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexImage");
-
-   if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
-      gl_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
-      return;
-   }
-
-   if (_mesa_sizeof_type(type) <= 0) {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
-      return;
-   }
-
-   if (_mesa_components_in_format(format) <= 0) {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
-      return;
-   }
-
-   if (!pixels)
-      return;
-
-   switch (target) {
-      case GL_TEXTURE_1D:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentD[1];
-         texImage = texObj->Image[level];
-         break;
-      case GL_TEXTURE_2D:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentD[2];
-         texImage = texObj->Image[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->Image[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->NegX[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->PosY[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->NegY[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->PosZ[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->NegZ[level];
-         break;
-      case GL_TEXTURE_3D:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentD[3];
-         texImage = texObj->Image[level];
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexImage(target)" );
-         return;
-   }
-
-   if (!texImage) {
-      /* invalid mipmap level */
-      return;
-   }
-
-   if (!texImage->Data) {
-      /* try to get the texture image from the device driver */
-      _mesa_get_teximage_from_driver(ctx, target, level, texObj);
-      discardImage = GL_TRUE;
-   }
-   else {
-      discardImage = GL_FALSE;
-   }
-
-   if (texImage->Data) {
-      GLint width = texImage->Width;
-      GLint height = texImage->Height;
-      GLint row;
-
-      for (row = 0; row < height; row++) {
-         /* compute destination address in client memory */
-         GLvoid *dest = _mesa_image_address( &ctx->Unpack, pixels,
-                                                width, height,
-                                                format, type, 0, row, 0);
-
-         assert(dest);
-         if (texImage->Format == GL_RGBA) {
-            const GLubyte *src = texImage->Data + row * width * 4 * sizeof(GLubyte);
-            _mesa_pack_rgba_span( ctx, width, (CONST GLubyte (*)[4]) src,
-                                  format, type, dest, &ctx->Pack, GL_TRUE );
-         }
-         else {
-            /* fetch RGBA row from texture image then pack it in client mem */
-            GLubyte rgba[MAX_WIDTH][4];
-            GLint i;
-            const GLubyte *src;
-            switch (texImage->Format) {
-               case GL_ALPHA:
-                  src = texImage->Data + row * width * sizeof(GLubyte);
-                  for (i = 0; i < width; i++) {
-                     rgba[i][RCOMP] = 255;
-                     rgba[i][GCOMP] = 255;
-                     rgba[i][BCOMP] = 255;
-                     rgba[i][ACOMP] = src[i];
-                  }
-                  break;
-               case GL_LUMINANCE:
-                  src = texImage->Data + row * width * sizeof(GLubyte);
-                  for (i = 0; i < width; i++) {
-                     rgba[i][RCOMP] = src[i];
-                     rgba[i][GCOMP] = src[i];
-                     rgba[i][BCOMP] = src[i];
-                     rgba[i][ACOMP] = 255;
-                   }
-                  break;
-               case GL_LUMINANCE_ALPHA:
-                  src = texImage->Data + row * 2 * width * sizeof(GLubyte);
-                  for (i = 0; i < width; i++) {
-                     rgba[i][RCOMP] = src[i*2+0];
-                     rgba[i][GCOMP] = src[i*2+0];
-                     rgba[i][BCOMP] = src[i*2+0];
-                     rgba[i][ACOMP] = src[i*2+1];
-                  }
-                  break;
-               case GL_INTENSITY:
-                  src = texImage->Data + row * width * sizeof(GLubyte);
-                  for (i = 0; i < width; i++) {
-                     rgba[i][RCOMP] = src[i];
-                     rgba[i][GCOMP] = src[i];
-                     rgba[i][BCOMP] = src[i];
-                     rgba[i][ACOMP] = 255;
-                  }
-                  break;
-               case GL_RGB:
-                  src = texImage->Data + row * 3 * width * sizeof(GLubyte);
-                  for (i = 0; i < width; i++) {
-                     rgba[i][RCOMP] = src[i*3+0];
-                     rgba[i][GCOMP] = src[i*3+1];
-                     rgba[i][BCOMP] = src[i*3+2];
-                     rgba[i][ACOMP] = 255;
-                  }
-                  break;
-               case GL_RGBA:
-                  /* this special case should have been handled above! */
-                  gl_problem( ctx, "error 1 in gl_GetTexImage" );
-                  break;
-               case GL_COLOR_INDEX:
-                  gl_problem( ctx, "GL_COLOR_INDEX not implemented in gl_GetTexImage" );
-                  break;
-               default:
-                  gl_problem( ctx, "bad format in gl_GetTexImage" );
-            }
-            _mesa_pack_rgba_span( ctx, width, (CONST GLubyte (*)[4])rgba,
-                                  format, type, dest, &ctx->Pack, GL_TRUE );
-         }
-      }
-
-      /* if we got the teximage from the device driver we'll discard it now */
-      if (discardImage) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
-      }
-   }
-}
-
-
 
 void
 _mesa_TexSubImage1D( GLenum target, GLint level,
@@ -2058,80 +1892,42 @@
                      GLenum format, GLenum type,
                      const GLvoid *pixels )
 {
+   GLsizei postConvWidth = width;
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
-   GLboolean success = GL_FALSE;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexSubImage1D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
+
+   /* XXX should test internal format */
+   if (is_color_format(format)) {
+      _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
+   }
 
    if (subtexture_error_check(ctx, 1, target, level, xoffset, 0, 0,
-                              width, 1, 1, format, type)) {
+                              postConvWidth, 1, 1, format, type)) {
       return;   /* error was detected */
    }
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = texUnit->CurrentD[1];
-   texImage = texObj->Image[level];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
    assert(texImage);
 
    if (width == 0 || !pixels)
       return;  /* no-op, not an error */
-
-
-   if (!ctx->Pixel.MapColorFlag && !ctx->Pixel.ScaleOrBiasRGBA
-       && ctx->Driver.TexSubImage1D) {
-      success = (*ctx->Driver.TexSubImage1D)( ctx, target, level, xoffset,
-                                              width, format, type, pixels,
-                                              &ctx->Unpack, texObj, texImage );
-   }
-   if (!success) {
-      /* XXX if Driver.TexSubImage1D, unpack image and try again? */
-
-      const GLint texComponents = components_in_intformat(texImage->Format);
-      const GLenum texFormat = texImage->Format;
-      const GLint xoffsetb = xoffset + texImage->Border;
-      GLboolean retain = GL_TRUE;
-      if (!texImage->Data) {
-         _mesa_get_teximage_from_driver( ctx, target, level, texObj );
-         if (!texImage->Data) {
-            make_null_texture(texImage);
-         }
-         if (!texImage->Data)
-            return;  /* we're really out of luck! */
-      }
-
-      if (texFormat == GL_COLOR_INDEX) {
-         /* color index texture */
-         GLubyte *dst = texImage->Data + xoffsetb * texComponents;
-         const GLvoid *src = _mesa_image_address(&ctx->Unpack, pixels, width,
-                                                 1, format, type, 0, 0, 0);
-         _mesa_unpack_index_span(ctx, width, GL_UNSIGNED_BYTE, dst,
-                                 type, src, &ctx->Unpack, GL_TRUE);
-      }
-      else {
-         /* color texture */
-         GLubyte *dst = texImage->Data + xoffsetb * texComponents;
-         const GLvoid *src = _mesa_image_address(&ctx->Unpack, pixels, width,
-                                                 1, format, type, 0, 0, 0);
-         _mesa_unpack_ubyte_color_span(ctx, width, texFormat, dst, format,
-                                       type, src, &ctx->Unpack, GL_TRUE);
-      }
 
-      if (ctx->Driver.TexImage1D) {
-         (*ctx->Driver.TexImage1D)( ctx, target, level, texImage->Format,
-                                    GL_UNSIGNED_BYTE, texImage->Data,
-                                    &_mesa_native_packing, texObj, texImage,
-                                    &retain );
-      }
+   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+   xoffset += texImage->Border;
 
-      if (!retain && texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
-      }
-   }
-
-   /*gl_put_texobj_on_dirty_list( ctx, texUnit->CurrentD[1] );*/
+   ASSERT(ctx->Driver.TexSubImage1D);
+   (*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
+                                format, type, pixels, &ctx->Unpack,
+                                texObj, texImage);
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2142,109 +1938,44 @@
                      GLenum format, GLenum type,
                      const GLvoid *pixels )
 {
+   GLsizei postConvWidth = width, postConvHeight = height;
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
-   GLboolean success = GL_FALSE;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexSubImage2D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
 
+   /* XXX should test internal format */
+   if (is_color_format(format)) {
+      _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
+                                         &postConvHeight);
+   }
+
    if (subtexture_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
-                              width, height, 1, format, type)) {
+                             postConvWidth, postConvHeight, 1, format, type)) {
       return;   /* error was detected */
    }
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = texObj->Image[level];
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
    assert(texImage);
 
    if (width == 0 || height == 0 || !pixels)
       return;  /* no-op, not an error */
 
-   if (!ctx->Pixel.MapColorFlag && !ctx->Pixel.ScaleOrBiasRGBA
-       && ctx->Driver.TexSubImage2D) {
-      success = (*ctx->Driver.TexSubImage2D)( ctx, target, level, xoffset,
-                                     yoffset, width, height, format, type,
-                                     pixels, &ctx->Unpack, texObj, texImage );
-   }
-   if (!success) {
-      /* XXX if Driver.TexSubImage2D, unpack image and try again? */
-
-      const GLint texComponents = components_in_intformat(texImage->Format);
-      const GLenum texFormat = texImage->Format;
-      const GLint xoffsetb = xoffset + texImage->Border;
-      const GLint yoffsetb = yoffset + texImage->Border;
-      const GLint srcStride = _mesa_image_row_stride(&ctx->Unpack, width,
-                                                     format, type);
-      const GLint dstStride = texImage->Width * texComponents *sizeof(GLubyte);
-      GLboolean retain = GL_TRUE;
-
-      if (!texImage->Data) {
-         _mesa_get_teximage_from_driver( ctx, target, level, texObj );
-         if (!texImage->Data) {
-            make_null_texture(texImage);
-         }
-         if (!texImage->Data)
-            return;  /* we're really out of luck! */
-      }
-
-      if (texFormat == GL_COLOR_INDEX) {
-         /* color index texture */
-         GLubyte *dst = texImage->Data
-                    + (yoffsetb * texImage->Width + xoffsetb) * texComponents;
-         const GLubyte *src = (const GLubyte *)
-            _mesa_image_address(&ctx->Unpack, pixels, width, height, format,
-                                type, 0, 0, 0);
-         GLint row;
-         for (row = 0; row < height; row++) {
-            _mesa_unpack_index_span(ctx, width, GL_UNSIGNED_BYTE, dst, type,
-                                 (const GLvoid *) src, &ctx->Unpack, GL_TRUE);
-            src += srcStride;
-            dst += dstStride;
-         }
-      }
-      else {
-         /* color texture */
-         GLubyte *dst = texImage->Data
-                    + (yoffsetb * texImage->Width + xoffsetb) * texComponents;
-         const GLubyte *src = (const GLubyte *)
-            _mesa_image_address(&ctx->Unpack, pixels, width, height, format,
-                                type, 0, 0, 0);
-         GLint row;
-         for (row = 0; row < height; row++) {
-            _mesa_unpack_ubyte_color_span(ctx, width, texFormat, dst, format,
-                           type, (const GLvoid *) src, &ctx->Unpack, GL_TRUE);
-            src += srcStride;
-            dst += dstStride;
-         }
-      }
-
-      if (ctx->Driver.TexImage2D) {
-         (*ctx->Driver.TexImage2D)(ctx, target, level, texImage->Format,
-                                   GL_UNSIGNED_BYTE, texImage->Data,
-                                   &_mesa_native_packing, texObj, texImage,
-                                   &retain);
-      }
-
-      if (!retain && texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
-      }
-
-#ifdef OLD_DD_TEXTURE
-      /* XXX this will be removed in the future */
-      if (ctx->Driver.TexSubImage) {
-         (*ctx->Driver.TexSubImage)(ctx, target, texObj, level,
-                                    xoffset, yoffset, width, height,
-                                    texImage->IntFormat, texImage);
-      }
-      else if (ctx->Driver.TexImage) {
-         (*ctx->Driver.TexImage)(ctx, GL_TEXTURE_2D, texObj,
-                                 level, texImage->IntFormat, texImage );
-      }
-#endif
-   }
+   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+   xoffset += texImage->Border;
+   yoffset += texImage->Border;
+
+   ASSERT(ctx->Driver.TexSubImage2D);
+   (*ctx->Driver.TexSubImage2D)(ctx, target, level, xoffset, yoffset,
+                                width, height, format, type, pixels,
+                                &ctx->Unpack, texObj, texImage);
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2259,9 +1990,11 @@
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
-   GLboolean success = GL_FALSE;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexSubImage3D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
 
    if (subtexture_error_check(ctx, 3, target, level, xoffset, yoffset, zoffset,
                               width, height, depth, format, type)) {
@@ -2269,127 +2002,25 @@
    }
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = texUnit->CurrentD[3];
-   texImage = texObj->Image[level];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
    assert(texImage);
 
    if (width == 0 || height == 0 || height == 0 || !pixels)
       return;  /* no-op, not an error */
-
-   if (!ctx->Pixel.MapColorFlag && !ctx->Pixel.ScaleOrBiasRGBA
-       && ctx->Driver.TexSubImage3D) {
-      success = (*ctx->Driver.TexSubImage3D)( ctx, target, level, xoffset,
-                                yoffset, zoffset, width, height, depth, format,
-                                type, pixels, &ctx->Unpack, texObj, texImage );
-   }
-   if (!success) {
-      /* XXX if Driver.TexSubImage3D, unpack image and try again? */
-
-      const GLint texComponents = components_in_intformat(texImage->Format);
-      const GLenum texFormat = texImage->Format;
-      const GLint xoffsetb = xoffset + texImage->Border;
-      const GLint yoffsetb = yoffset + texImage->Border;
-      const GLint zoffsetb = zoffset + texImage->Border;
-      const GLint texWidth = texImage->Width;
-      const GLint dstRectArea = texWidth * texImage->Height;
-      const GLint srcStride = _mesa_image_row_stride(&ctx->Unpack,
-                                                     width, format, type);
-      const GLint dstStride = texWidth * texComponents * sizeof(GLubyte);
-      GLboolean retain = GL_TRUE;
-
-      if (texFormat == GL_COLOR_INDEX) {
-         /* color index texture */
-         GLint img, row;
-         for (img = 0; img < depth; img++) {
-            const GLubyte *src = (const GLubyte *)
-               _mesa_image_address(&ctx->Unpack, pixels, width, height,
-                                   format, type, img, 0, 0);
-            GLubyte *dst = texImage->Data + ((zoffsetb + img) * dstRectArea
-                     + yoffsetb * texWidth + xoffsetb) * texComponents;
-            for (row = 0; row < height; row++) {
-               _mesa_unpack_index_span(ctx, width, GL_UNSIGNED_BYTE, dst,
-                         type, (const GLvoid *) src, &ctx->Unpack, GL_TRUE);
-               src += srcStride;
-               dst += dstStride;
-            }
-         }
-      }
-      else {
-         /* color texture */
-         GLint img, row;
-         for (img = 0; img < depth; img++) {
-            const GLubyte *src = (const GLubyte *)
-               _mesa_image_address(&ctx->Unpack, pixels, width, height,
-                                   format, type, img, 0, 0);
-            GLubyte *dst = texImage->Data + ((zoffsetb + img) * dstRectArea
-                     + yoffsetb * texWidth + xoffsetb) * texComponents;
-            for (row = 0; row < height; row++) {
-               _mesa_unpack_ubyte_color_span(ctx, width, texFormat, dst,
-                   format, type, (const GLvoid *) src, &ctx->Unpack, GL_TRUE);
-               src += srcStride;
-               dst += dstStride;
-            }
-         }
-      }
-
-      if (ctx->Driver.TexImage3D) {
-         (*ctx->Driver.TexImage3D)(ctx, target, level, texImage->Format,
-                                   GL_UNSIGNED_BYTE, texImage->Data,
-                                   &_mesa_native_packing, texObj, texImage,
-                                   &retain);
-      }
-
-      if (!retain && texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
-      }
-   }
-}
-
-
-
-/*
- * Read an RGBA image from the frame buffer.
- * This is used by glCopyTexSubImage[12]D().
- * Input:  ctx - the context
- *         x, y - lower left corner
- *         width, height - size of region to read
- * Return: pointer to block of GL_RGBA, GLubyte data.
- */
-static GLubyte *
-read_color_image( GLcontext *ctx, GLint x, GLint y,
-                  GLsizei width, GLsizei height )
-{
-   GLint stride, i;
-   GLubyte *image, *dst;
-
-   image = (GLubyte *) MALLOC(width * height * 4 * sizeof(GLubyte));
-   if (!image)
-      return NULL;
 
-   /* Select buffer to read from */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
-                                 ctx->Pixel.DriverReadBuffer );
-
-   /* XXX TODO we have to apply pixel transfer ops here! */
-
-   RENDER_START(ctx);
-
-   dst = image;
-   stride = width * 4 * sizeof(GLubyte);
-   for (i = 0; i < height; i++) {
-      gl_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y + i,
-                         (GLubyte (*)[4]) dst );
-      dst += stride;
-   }
-
-   RENDER_FINISH(ctx);
-
-   /* Read from draw buffer (the default) */
-   (*ctx->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
-                                 ctx->Color.DriverDrawBuffer );
-
-   return image;
+   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+   xoffset += texImage->Border;
+   yoffset += texImage->Border;
+   zoffset += texImage->Border;
+
+   ASSERT(ctx->Driver.TexSubImage3D);
+   (*ctx->Driver.TexSubImage3D)(ctx, target, level,
+                                xoffset, yoffset, zoffset,
+                                width, height, depth,
+                                format, type, pixels,
+                                &ctx->Unpack, texObj, texImage );
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2400,36 +2031,60 @@
                       GLint x, GLint y,
                       GLsizei width, GLint border )
 {
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLsizei postConvWidth = width;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyTexImage1D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
+
+   if (is_color_format(internalFormat)) {
+      _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
+   }
 
    if (copytexture_error_check(ctx, 1, target, level, internalFormat,
-                               width, 1, border))
+                               postConvWidth, 1, border))
       return;
-
-   if (ctx->Pixel.MapColorFlag || ctx->Pixel.ScaleOrBiasRGBA
-       || !ctx->Driver.CopyTexImage1D
-       || !(*ctx->Driver.CopyTexImage1D)(ctx, target, level,
-                         internalFormat, x, y, width, border))
-   {
-      struct gl_pixelstore_attrib unpackSave;
 
-      /* get image from framebuffer */
-      GLubyte *image  = read_color_image( ctx, x, y, width, 1 );
-      if (!image) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D" );
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   if (!texImage) {
+      texImage = _mesa_alloc_texture_image();
+      _mesa_set_tex_image(texObj, target, level, texImage);
+      if (!texImage) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
          return;
       }
+   }
+   else if (texImage->Data && !texImage->IsClientData) {
+      /* free the old texture data */
+      MESA_PBUFFER_FREE(texImage->Data);
+   }
+   texImage->Data = NULL;
+
+   clear_teximage_fields(texImage); /* not really needed, but helpful */
+   _mesa_init_teximage_fields(ctx, target, texImage, postConvWidth, 1, 1,
+                              border, internalFormat);
 
-      /* call glTexImage1D to redefine the texture */
-      unpackSave = ctx->Unpack;
-      ctx->Unpack = _mesa_native_packing;
-      (*ctx->Exec->TexImage1D)( target, level, internalFormat, width,
-                                border, GL_RGBA, GL_UNSIGNED_BYTE, image );
-      ctx->Unpack = unpackSave;
 
-      FREE(image);
+   ASSERT(ctx->Driver.CopyTexImage1D);
+   (*ctx->Driver.CopyTexImage1D)(ctx, target, level, internalFormat,
+                                 x, y, width, border);
+
+   ASSERT(texImage->TexFormat);
+   if (!texImage->FetchTexel) {
+      /* If driver didn't explicitly set this, use the default */
+      texImage->FetchTexel = texImage->TexFormat->FetchTexel1D;
    }
+   ASSERT(texImage->FetchTexel);
+
+   /* state update */
+   texObj->Complete = GL_FALSE;
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2439,36 +2094,61 @@
                       GLint x, GLint y, GLsizei width, GLsizei height,
                       GLint border )
 {
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLsizei postConvWidth = width, postConvHeight = height;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyTexImage2D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
 
+   if (is_color_format(internalFormat)) {
+      _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
+                                         &postConvHeight);
+   }
+
    if (copytexture_error_check(ctx, 2, target, level, internalFormat,
-                               width, height, border))
+                               postConvWidth, postConvHeight, border))
       return;
 
-   if (ctx->Pixel.MapColorFlag || ctx->Pixel.ScaleOrBiasRGBA
-       || !ctx->Driver.CopyTexImage2D
-       || !(*ctx->Driver.CopyTexImage2D)(ctx, target, level,
-                         internalFormat, x, y, width, height, border))
-   {
-      struct gl_pixelstore_attrib unpackSave;
-
-      /* get image from framebuffer */
-      GLubyte *image  = read_color_image( ctx, x, y, width, height );
-      if (!image) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D" );
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   if (!texImage) {
+      texImage = _mesa_alloc_texture_image();
+      _mesa_set_tex_image(texObj, target, level, texImage);
+      if (!texImage) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
          return;
       }
+   }
+   else if (texImage->Data && !texImage->IsClientData) {
+      /* free the old texture data */
+      MESA_PBUFFER_FREE(texImage->Data);
+   }
+   texImage->Data = NULL;
+
+   clear_teximage_fields(texImage); /* not really needed, but helpful */
+   _mesa_init_teximage_fields(ctx, target, texImage,
+                              postConvWidth, postConvHeight, 1,
+                              border, internalFormat);
 
-      /* call glTexImage2D to redefine the texture */
-      unpackSave = ctx->Unpack;
-      ctx->Unpack = _mesa_native_packing;
-      (ctx->Exec->TexImage2D)( target, level, internalFormat, width,
-                      height, border, GL_RGBA, GL_UNSIGNED_BYTE, image );
-      ctx->Unpack = unpackSave;
+   ASSERT(ctx->Driver.CopyTexImage2D);
+   (*ctx->Driver.CopyTexImage2D)(ctx, target, level, internalFormat,
+                                 x, y, width, height, border);
 
-      FREE(image);
+   ASSERT(texImage->TexFormat);
+   if (!texImage->FetchTexel) {
+      /* If driver didn't explicitly set this, use the default */
+      texImage->FetchTexel = texImage->TexFormat->FetchTexel2D;
    }
+   ASSERT(texImage->FetchTexel);
+
+   /* state update */
+   texObj->Complete = GL_FALSE;
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2477,42 +2157,33 @@
 _mesa_CopyTexSubImage1D( GLenum target, GLint level,
                          GLint xoffset, GLint x, GLint y, GLsizei width )
 {
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLsizei postConvWidth = width;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyTexSubImage1D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (copytexsubimage_error_check(ctx, 1, target, level,
-                                   xoffset, 0, 0, width, 1))
-      return;
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
 
-   if (ctx->Pixel.MapColorFlag || ctx->Pixel.ScaleOrBiasRGBA
-       || !ctx->Driver.CopyTexSubImage1D
-       || !(*ctx->Driver.CopyTexSubImage1D)(ctx, target, level,
-                                            xoffset, x, y, width)) {
-      struct gl_texture_unit *texUnit;
-      struct gl_texture_image *teximage;
-      struct gl_pixelstore_attrib unpackSave;
-      GLubyte *image;
+   /* XXX should test internal format */
+   _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      teximage = texUnit->CurrentD[1]->Image[level];
-      assert(teximage);
+   if (copytexsubimage_error_check(ctx, 1, target, level,
+                                   xoffset, 0, 0, postConvWidth, 1))
+      return;
 
-      /* get image from frame buffer */
-      image = read_color_image(ctx, x, y, width, 1);
-      if (!image) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D" );
-         return;
-      }
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
-      /* now call glTexSubImage1D to do the real work */
-      unpackSave = ctx->Unpack;
-      ctx->Unpack = _mesa_native_packing;
-      _mesa_TexSubImage1D(target, level, xoffset, width,
-                          GL_RGBA, GL_UNSIGNED_BYTE, image);
-      ctx->Unpack = unpackSave;
+   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+   xoffset += texImage->Border;
 
-      FREE(image);
-   }
+   ASSERT(ctx->Driver.CopyTexSubImage1D);
+   (*ctx->Driver.CopyTexSubImage1D)(ctx, target, level, xoffset, x, y, width);
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2522,42 +2193,35 @@
                          GLint xoffset, GLint yoffset,
                          GLint x, GLint y, GLsizei width, GLsizei height )
 {
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLsizei postConvWidth = width, postConvHeight = height;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyTexSubImage2D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (copytexsubimage_error_check(ctx, 2, target, level,
-                                   xoffset, yoffset, 0, width, height))
-      return;
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
 
-   if (ctx->Pixel.MapColorFlag || ctx->Pixel.ScaleOrBiasRGBA
-       || !ctx->Driver.CopyTexSubImage2D
-       || !(*ctx->Driver.CopyTexSubImage2D)(ctx, target, level,
-                                xoffset, yoffset, x, y, width, height )) {
-      struct gl_texture_unit *texUnit;
-      struct gl_texture_image *teximage;
-      struct gl_pixelstore_attrib unpackSave;
-      GLubyte *image;
+   /* XXX should test internal format */
+   _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth, &postConvHeight);
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      teximage = texUnit->CurrentD[2]->Image[level];
-      assert(teximage);
-
-      /* get image from frame buffer */
-      image = read_color_image(ctx, x, y, width, height);
-      if (!image) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D" );
-         return;
-      }
+   if (copytexsubimage_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
+                                   postConvWidth, postConvHeight))
+      return;
 
-      /* now call glTexSubImage2D to do the real work */
-      unpackSave = ctx->Unpack;
-      ctx->Unpack = _mesa_native_packing;
-      _mesa_TexSubImage2D(target, level, xoffset, yoffset, width, height,
-                          GL_RGBA, GL_UNSIGNED_BYTE, image);
-      ctx->Unpack = unpackSave;
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
-      FREE(image);
-   }
+   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+   xoffset += texImage->Border;
+   yoffset += texImage->Border;
+
+   ASSERT(ctx->Driver.CopyTexSubImage2D);
+   (*ctx->Driver.CopyTexSubImage2D)(ctx, target, level,
+                                    xoffset, yoffset, x, y, width, height);
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2567,42 +2231,37 @@
                          GLint xoffset, GLint yoffset, GLint zoffset,
                          GLint x, GLint y, GLsizei width, GLsizei height )
 {
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLsizei postConvWidth = width, postConvHeight = height;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCopyTexSubImage3D");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (copytexsubimage_error_check(ctx, 3, target, level,
-                    xoffset, yoffset, zoffset, width, height))
-      return;
-
-   if (ctx->Pixel.MapColorFlag || ctx->Pixel.ScaleOrBiasRGBA
-       || !ctx->Driver.CopyTexSubImage3D
-       || !(*ctx->Driver.CopyTexSubImage3D)(ctx, target, level,
-                     xoffset, yoffset, zoffset, x, y, width, height )) {
-      struct gl_texture_unit *texUnit;
-      struct gl_texture_image *teximage;
-      struct gl_pixelstore_attrib unpackSave;
-      GLubyte *image;
+   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      _mesa_update_state(ctx);
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      teximage = texUnit->CurrentD[3]->Image[level];
-      assert(teximage);
+   /* XXX should test internal format */
+   _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth, &postConvHeight);
 
-      /* get image from frame buffer */
-      image = read_color_image(ctx, x, y, width, height);
-      if (!image) {
-         gl_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D" );
-         return;
-      }
+   if (copytexsubimage_error_check(ctx, 3, target, level, xoffset, yoffset,
+                                   zoffset, postConvWidth, postConvHeight))
+      return;
 
-      /* now call glTexSubImage2D to do the real work */
-      unpackSave = ctx->Unpack;
-      ctx->Unpack = _mesa_native_packing;
-      _mesa_TexSubImage3D(target, level, xoffset, yoffset, zoffset,
-                          width, height, 1, GL_RGBA, GL_UNSIGNED_BYTE, image);
-      ctx->Unpack = unpackSave;
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
-      FREE(image);
-   }
+   /* If we have a border, xoffset=-1 is legal.  Bias by border width */
+   xoffset += texImage->Border;
+   yoffset += texImage->Border;
+   zoffset += texImage->Border;
+
+   ASSERT(ctx->Driver.CopyTexSubImage3D);
+   (*ctx->Driver.CopyTexSubImage3D)(ctx, target, level,
+                                    xoffset, yoffset, zoffset,
+                                    x, y, width, height);
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -2614,7 +2273,7 @@
                               const GLvoid *data)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCompressedTexImage1DARB");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    switch (internalFormat) {
       case GL_COMPRESSED_ALPHA_ARB:
@@ -2623,7 +2282,7 @@
       case GL_COMPRESSED_INTENSITY_ARB:
       case GL_COMPRESSED_RGB_ARB:
       case GL_COMPRESSED_RGBA_ARB:
-         gl_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB");
          return;
       default:
          /* silence compiler warning */
@@ -2634,7 +2293,6 @@
       struct gl_texture_unit *texUnit;
       struct gl_texture_object *texObj;
       struct gl_texture_image *texImage;
-      GLsizei computedImageSize;
 
       if (texture_error_check(ctx, target, level, internalFormat,
                               GL_NONE, GL_NONE, 1, width, 1, 1, border)) {
@@ -2642,93 +2300,63 @@
       }
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texObj = texUnit->CurrentD[1];
-      texImage = texObj->Image[level];
+      texObj = _mesa_select_tex_object(ctx, texUnit, target);
+      texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
       if (!texImage) {
          texImage = _mesa_alloc_texture_image();
          texObj->Image[level] = texImage;
          if (!texImage) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
             return;
          }
       }
-      else if (texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
-      }
-
-      /* setup the teximage struct's fields */
-      init_texture_image(ctx, texImage, width, 1, 1,
-                         border, internalFormat);
-
-      /* process the texture image */
-      if (data) {
-         GLboolean retain = GL_TRUE;
-         GLboolean success = GL_FALSE;
-         if (ctx->Driver.CompressedTexImage1D) {
-            success = (*ctx->Driver.CompressedTexImage1D)(ctx, target, level,
-                               imageSize, data, texObj, texImage, &retain);
-         }
-         if (retain || !success) {
-            /* make internal copy of the texture image */
-            computedImageSize = _mesa_compressed_image_size(ctx,
-                                                        internalFormat,
-                                                        1,    /* num dims */
-                                                        width,
-                                                        1,    /* height   */
-                                                        1);   /* depth    */
-            if (computedImageSize != imageSize) {
-                gl_error(ctx, GL_INVALID_VALUE, "glCompressedTexImage1DARB(imageSize)");
-                return;
-            }
-            texImage->Data = (GLubyte *) MALLOC(computedImageSize);
-            if (texImage->Data) {
-               MEMCPY(texImage->Data, data, computedImageSize);
-            }
-         }
-         if (!retain && texImage->Data) {
-            FREE(texImage->Data);
-            texImage->Data = NULL;
-         }
+      else if (texImage->Data && !texImage->IsClientData) {
+         MESA_PBUFFER_FREE(texImage->Data);
       }
-      else {
-         make_null_texture(texImage);
-         if (ctx->Driver.CompressedTexImage1D) {
-            GLboolean retain;
-            (*ctx->Driver.CompressedTexImage1D)(ctx, target, level, 0,
-                                                texImage->Data, texObj,
-                                                texImage, &retain);
-         }
+      texImage->Data = NULL;
+
+      _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
+                                 border, internalFormat);
+
+      if (ctx->Extensions.ARB_texture_compression) {
+         ASSERT(ctx->Driver.CompressedTexImage1D);
+         (*ctx->Driver.CompressedTexImage1D)(ctx, target, level,
+                                             internalFormat, width, border,
+                                             imageSize, data,
+                                             texObj, texImage);
+         ASSERT(texImage->CompressedSize > 0); /* sanity */
       }
 
       /* state update */
-      gl_put_texobj_on_dirty_list( ctx, texObj );
-      ctx->NewState |= NEW_TEXTURING;
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
    }
    else if (target == GL_PROXY_TEXTURE_1D) {
       /* Proxy texture: check for errors and update proxy state */
       GLenum error = texture_error_check(ctx, target, level, internalFormat,
                                     GL_NONE, GL_NONE, 1, width, 1, 1, border);
-      if (!error && ctx->Driver.TestProxyTexImage) {
+      if (!error) {
+         struct gl_texture_unit *texUnit;
+         struct gl_texture_image *texImage;
+         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+         _mesa_init_teximage_fields(ctx, target, texImage, width, 1, 1,
+                                    border, internalFormat);
+         ASSERT(ctx->Driver.TestProxyTexImage);
          error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
                                              internalFormat, GL_NONE, GL_NONE,
                                              width, 1, 1, border);
       }
       if (error) {
          /* if error, clear all proxy texture image parameters */
-         if (level>=0 && level<ctx->Const.MaxTextureLevels) {
-            clear_proxy_teximage(ctx->Texture.Proxy1D->Image[level]);
+         if (level >= 0 && level < ctx->Const.MaxTextureLevels) {
+            clear_teximage_fields(ctx->Texture.Proxy1D->Image[level]);
          }
       }
-      else {
-         /* if no error, update proxy texture image parameters */
-         init_texture_image(ctx, ctx->Texture.Proxy1D->Image[level],
-                            width, 1, 1, border, internalFormat);
-      }
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB(target)" );
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage1DARB(target)");
       return;
    }
 }
@@ -2741,7 +2369,7 @@
                               const GLvoid *data)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCompressedTexImage2DARB");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    switch (internalFormat) {
       case GL_COMPRESSED_ALPHA_ARB:
@@ -2750,120 +2378,88 @@
       case GL_COMPRESSED_INTENSITY_ARB:
       case GL_COMPRESSED_RGB_ARB:
       case GL_COMPRESSED_RGBA_ARB:
-         gl_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB");
          return;
       default:
          /* silence compiler warning */
          ;
    }
 
-   if (target==GL_TEXTURE_2D ||
-       (ctx->Extensions.HaveTextureCubeMap &&
+   if (target == GL_TEXTURE_2D ||
+       (ctx->Extensions.ARB_texture_cube_map &&
         target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB &&
-        target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB)) {
+        target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB) ||
+       (ctx->Extensions.NV_texture_rectangle &&
+        target == GL_TEXTURE_RECTANGLE_NV)) {
       struct gl_texture_unit *texUnit;
       struct gl_texture_object *texObj;
       struct gl_texture_image *texImage;
-      GLsizei computedImageSize;
 
       if (texture_error_check(ctx, target, level, internalFormat,
-                              GL_NONE, GL_NONE, 1, width, height, 1, border)) {
+                              GL_NONE, GL_NONE, 2, width, height, 1, border)) {
          return;   /* error in texture image was detected */
       }
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texObj = texUnit->CurrentD[2];
-      texImage = texObj->Image[level];
+      texObj = _mesa_select_tex_object(ctx, texUnit, target);
+      texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
       if (!texImage) {
          texImage = _mesa_alloc_texture_image();
          texObj->Image[level] = texImage;
          if (!texImage) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
             return;
          }
       }
-      else if (texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
-      }
-
-      /* setup the teximage struct's fields */
-      init_texture_image(ctx, texImage, width, height, 1, border, internalFormat);
-
-      /* process the texture image */
-      if (data) {
-         GLboolean retain = GL_TRUE;
-         GLboolean success = GL_FALSE;
-         if (ctx->Driver.CompressedTexImage2D) {
-            success = (*ctx->Driver.CompressedTexImage2D)( ctx,
-                                                           target,
-                                                           level,
-                                                           imageSize,
-                                                           data,
-                                                           texObj,
-                                                           texImage,
-                                                           &retain);
-         }
-         if (retain || !success) {
-            /* make internal copy of the texture image */
-            computedImageSize = _mesa_compressed_image_size(ctx,
-                                                           internalFormat,
-                                                           2,    /* num dims */
-                                                           width,
-                                                           height,
-                                                           1);   /* depth    */
-            if (computedImageSize != imageSize) {
-                gl_error(ctx, GL_INVALID_VALUE, "glCompressedTexImage2DARB(imageSize)");
-                return;
-            }
-            texImage->Data = (GLubyte *) MALLOC(computedImageSize);
-            if (texImage->Data) {
-               MEMCPY(texImage->Data, data, computedImageSize);
-            }
-         }
-         if (!retain && texImage->Data) {
-            FREE(texImage->Data);
-            texImage->Data = NULL;
-         }
+      else if (texImage->Data && !texImage->IsClientData) {
+         MESA_PBUFFER_FREE(texImage->Data);
       }
-      else {
-         make_null_texture(texImage);
-         if (ctx->Driver.CompressedTexImage2D) {
-            GLboolean retain;
-            (*ctx->Driver.CompressedTexImage2D)( ctx, target, level, 0,
-                                                 texImage->Data, texObj,
-                                                 texImage, &retain);
-         }
+      texImage->Data = NULL;
+
+      _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
+                                 border, internalFormat);
+
+      if (ctx->Extensions.ARB_texture_compression) {
+         ASSERT(ctx->Driver.CompressedTexImage2D);
+         (*ctx->Driver.CompressedTexImage2D)(ctx, target, level,
+                                             internalFormat, width, height,
+                                             border, imageSize, data,
+                                             texObj, texImage);
+         ASSERT(texImage->CompressedSize > 0); /* sanity */
       }
 
       /* state update */
-      gl_put_texobj_on_dirty_list( ctx, texObj );
-      ctx->NewState |= NEW_TEXTURING;
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
    }
    else if (target == GL_PROXY_TEXTURE_2D) {
       /* Proxy texture: check for errors and update proxy state */
       GLenum error = texture_error_check(ctx, target, level, internalFormat,
                                 GL_NONE, GL_NONE, 2, width, height, 1, border);
-      if (!error && ctx->Driver.TestProxyTexImage) {
+      if (!error) {
+         struct gl_texture_unit *texUnit;
+         struct gl_texture_image *texImage;
+         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+         _mesa_init_teximage_fields(ctx, target, texImage, width, height, 1,
+                                    border, internalFormat);
+         ASSERT(ctx->Driver.TestProxyTexImage);
          error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
                                               internalFormat, GL_NONE, GL_NONE,
                                               width, height, 1, border);
       }
       if (error) {
          /* if error, clear all proxy texture image parameters */
-         if (level>=0 && level<ctx->Const.MaxTextureLevels) {
-            clear_proxy_teximage(ctx->Texture.Proxy2D->Image[level]);
+         const GLint maxLevels = (target == GL_PROXY_TEXTURE_2D) ?
+            ctx->Const.MaxTextureLevels : ctx->Const.MaxCubeTextureLevels;
+         if (level >= 0 && level < maxLevels) {
+            clear_teximage_fields(ctx->Texture.Proxy2D->Image[level]);
          }
       }
-      else {
-         /* if no error, update proxy texture image parameters */
-         init_texture_image(ctx, ctx->Texture.Proxy2D->Image[level],
-                            width, 1, 1, border, internalFormat);
-      }
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB(target)" );
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage2DARB(target)");
       return;
    }
 }
@@ -2876,7 +2472,7 @@
                               GLsizei imageSize, const GLvoid *data)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCompressedTexImage3DARB");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    switch (internalFormat) {
       case GL_COMPRESSED_ALPHA_ARB:
@@ -2885,7 +2481,7 @@
       case GL_COMPRESSED_INTENSITY_ARB:
       case GL_COMPRESSED_RGB_ARB:
       case GL_COMPRESSED_RGBA_ARB:
-         gl_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB");
          return;
       default:
          /* silence compiler warning */
@@ -2896,103 +2492,72 @@
       struct gl_texture_unit *texUnit;
       struct gl_texture_object *texObj;
       struct gl_texture_image *texImage;
-      GLsizei computedImageSize;
 
       if (texture_error_check(ctx, target, level, internalFormat,
-                          GL_NONE, GL_NONE, 1, width, height, depth, border)) {
+                          GL_NONE, GL_NONE, 3, width, height, depth, border)) {
          return;   /* error in texture image was detected */
       }
 
       texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      texObj = texUnit->CurrentD[3];
-      texImage = texObj->Image[level];
+      texObj = _mesa_select_tex_object(ctx, texUnit, target);
+      texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
 
       if (!texImage) {
          texImage = _mesa_alloc_texture_image();
          texObj->Image[level] = texImage;
          if (!texImage) {
-            gl_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
             return;
          }
       }
-      else if (texImage->Data) {
-         FREE(texImage->Data);
-         texImage->Data = NULL;
-      }
-
-      /* setup the teximage struct's fields */
-      init_texture_image(ctx, texImage, width, height, depth,
-                         border, internalFormat);
-
-      /* process the texture image */
-      if (data) {
-         GLboolean retain = GL_TRUE;
-         GLboolean success = GL_FALSE;
-         if (ctx->Driver.CompressedTexImage3D) {
-            success = (*ctx->Driver.CompressedTexImage3D)(ctx, target, level,
-                                                          imageSize, data,
-                                                          texObj, texImage,
-                                                          &retain);
-         }
-         if (retain || !success) {
-            /* make internal copy of the texture image */
-            computedImageSize = _mesa_compressed_image_size(ctx,
-                                                            internalFormat,
-                                                            3,  /* num dims */
-                                                            width,
-                                                            height,
-                                                            depth);
-            if (computedImageSize != imageSize) {
-                gl_error(ctx, GL_INVALID_VALUE, "glCompressedTexImage3DARB(imageSize)");
-                return;
-            }
-            texImage->Data = (GLubyte *) MALLOC(computedImageSize);
-            if (texImage->Data) {
-               MEMCPY(texImage->Data, data, computedImageSize);
-            }
-         }
-         if (!retain && texImage->Data) {
-            FREE(texImage->Data);
-            texImage->Data = NULL;
-         }
+      else if (texImage->Data && !texImage->IsClientData) {
+         MESA_PBUFFER_FREE(texImage->Data);
       }
-      else {
-         make_null_texture(texImage);
-         if (ctx->Driver.CompressedTexImage3D) {
-            GLboolean retain;
-            (*ctx->Driver.CompressedTexImage3D)( ctx, target, level, 0,
-                                                 texImage->Data, texObj,
-                                                 texImage, &retain);
-         }
+      texImage->Data = NULL;
+
+      _mesa_init_teximage_fields(ctx, target, texImage, width, height, depth,
+                                 border, internalFormat);
+
+      if (ctx->Extensions.ARB_texture_compression) {
+         ASSERT(ctx->Driver.CompressedTexImage3D);
+         (*ctx->Driver.CompressedTexImage3D)(ctx, target, level,
+                                             internalFormat,
+                                             width, height, depth,
+                                             border, imageSize, data,
+                                             texObj, texImage);
+         ASSERT(texImage->CompressedSize > 0); /* sanity */
       }
 
       /* state update */
-      gl_put_texobj_on_dirty_list( ctx, texObj );
-      ctx->NewState |= NEW_TEXTURING;
+      texObj->Complete = GL_FALSE;
+      ctx->NewState |= _NEW_TEXTURE;
    }
    else if (target == GL_PROXY_TEXTURE_3D) {
       /* Proxy texture: check for errors and update proxy state */
       GLenum error = texture_error_check(ctx, target, level, internalFormat,
-                            GL_NONE, GL_NONE, 1, width, height, depth, border);
-      if (!error && ctx->Driver.TestProxyTexImage) {
+                            GL_NONE, GL_NONE, 3, width, height, depth, border);
+      if (!error) {
+         struct gl_texture_unit *texUnit;
+         struct gl_texture_image *texImage;
+         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+         _mesa_init_teximage_fields(ctx, target, texImage,
+                                    width, height, depth,
+                                    border, internalFormat);
+         ASSERT(ctx->Driver.TestProxyTexImage);
          error = !(*ctx->Driver.TestProxyTexImage)(ctx, target, level,
                                              internalFormat, GL_NONE, GL_NONE,
                                              width, height, depth, border);
       }
       if (error) {
          /* if error, clear all proxy texture image parameters */
-         if (level>=0 && level<ctx->Const.MaxTextureLevels) {
-            clear_proxy_teximage(ctx->Texture.Proxy3D->Image[level]);
+         if (level >= 0 && level < ctx->Const.Max3DTextureLevels) {
+            clear_teximage_fields(ctx->Texture.Proxy3D->Image[level]);
          }
       }
-      else {
-         /* if no error, update proxy texture image parameters */
-         init_texture_image(ctx, ctx->Texture.Proxy3D->Image[level],
-                            width, 1, 1, border, internalFormat);
-      }
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB(target)" );
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCompressedTexImage3DARB(target)");
       return;
    }
 }
@@ -3006,9 +2571,8 @@
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
-   GLboolean success = GL_FALSE;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCompressedTexSubImage1DARB");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (subtexture_error_check(ctx, 1, target, level, xoffset, 0, 0,
                               width, 1, 1, format, GL_NONE)) {
@@ -3017,21 +2581,19 @@
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = texObj->Image[level];
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
    assert(texImage);
 
    if (width == 0 || !data)
       return;  /* no-op, not an error */
 
    if (ctx->Driver.CompressedTexSubImage1D) {
-      success = (*ctx->Driver.CompressedTexSubImage1D)(ctx, target, level,
-                   xoffset, width, format, imageSize, data, texObj, texImage);
+      (*ctx->Driver.CompressedTexSubImage1D)(ctx, target, level,
+                                             xoffset, width,
+                                             format, imageSize, data,
+                                             texObj, texImage);
    }
-   if (!success) {
-      /* XXX what else can we do? */
-      gl_problem(ctx, "glCompressedTexSubImage1DARB failed!");
-      return;
-   }
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -3044,9 +2606,8 @@
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
-   GLboolean success = GL_FALSE;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCompressedTexSubImage2DARB");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (subtexture_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
                               width, height, 1, format, GL_NONE)) {
@@ -3055,22 +2616,19 @@
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = texObj->Image[level];
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
    assert(texImage);
 
    if (width == 0 || height == 0 || !data)
       return;  /* no-op, not an error */
 
    if (ctx->Driver.CompressedTexSubImage2D) {
-      success = (*ctx->Driver.CompressedTexSubImage2D)(ctx, target, level,
-                                       xoffset, yoffset, width, height, format,
-                                       imageSize, data, texObj, texImage);
-   }
-   if (!success) {
-      /* XXX what else can we do? */
-      gl_problem(ctx, "glCompressedTexSubImage2DARB failed!");
-      return;
+      (*ctx->Driver.CompressedTexSubImage2D)(ctx, target, level,
+                                             xoffset, yoffset, width, height,
+                                             format, imageSize, data,
+                                             texObj, texImage);
    }
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
@@ -3083,9 +2641,8 @@
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
-   GLboolean success = GL_FALSE;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glCompressedTexSubImage3DARB");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (subtexture_error_check(ctx, 3, target, level, xoffset, yoffset, zoffset,
                               width, height, depth, format, GL_NONE)) {
@@ -3094,99 +2651,80 @@
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   texImage = texObj->Image[level];
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
    assert(texImage);
 
    if (width == 0 || height == 0 || depth == 0 || !data)
       return;  /* no-op, not an error */
 
    if (ctx->Driver.CompressedTexSubImage3D) {
-      success = (*ctx->Driver.CompressedTexSubImage3D)(ctx, target, level,
-                               xoffset, yoffset, zoffset, width, height, depth,
-                               format, imageSize, data, texObj, texImage);
-   }
-   if (!success) {
-      /* XXX what else can we do? */
-      gl_problem(ctx, "glCompressedTexSubImage3DARB failed!");
-      return;
+      (*ctx->Driver.CompressedTexSubImage3D)(ctx, target, level,
+                                             xoffset, yoffset, zoffset,
+                                             width, height, depth,
+                                             format, imageSize, data,
+                                             texObj, texImage);
    }
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
 void
 _mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)
 {
+   const struct gl_texture_unit *texUnit;
    const struct gl_texture_object *texObj;
    struct gl_texture_image *texImage;
+   GLint maxLevels;
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetCompressedTexImageARB");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
-      gl_error( ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)" );
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   if (!texObj) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB");
       return;
    }
 
-   switch (target) {
-      case GL_TEXTURE_1D:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentD[1];
-         texImage = texObj->Image[level];
-         break;
-      case GL_TEXTURE_2D:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentD[2];
-         texImage = texObj->Image[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->Image[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->NegX[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->PosY[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->NegY[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->PosZ[level];
-         break;
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap;
-         texImage = texObj->NegZ[level];
-         break;
-      case GL_TEXTURE_3D:
-         texObj = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentD[3];
-         texImage = texObj->Image[level];
-         break;
-      default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
-         return;
+   if (target == GL_TEXTURE_1D || target == GL_TEXTURE_2D) {
+      maxLevels = ctx->Const.MaxTextureLevels;
+   }
+   else if (target == GL_TEXTURE_3D) {
+      maxLevels = ctx->Const.Max3DTextureLevels;
    }
+   else {
+      maxLevels = ctx->Const.MaxCubeTextureLevels;
+   }
 
+   ASSERT(maxLevels > 0);
+
+   if (level < 0 || level >= maxLevels) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
+      return;
+   }
+
+   if (is_proxy_target(target)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
+      return;
+   }
+
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
    if (!texImage) {
-      /* invalid mipmap level */
-      gl_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
+      /* probably invalid mipmap level */
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
       return;
    }
 
    if (!texImage->IsCompressed) {
-      gl_error(ctx, GL_INVALID_OPERATION, "glGetCompressedTexImageARB");
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetCompressedTexImageARB");
       return;
    }
 
    if (!img)
       return;
 
-   if (ctx->Driver.GetCompressedTexImage) {
+   if (ctx->Extensions.ARB_texture_compression) {
+      ASSERT(ctx->Driver.GetCompressedTexImage);
       (*ctx->Driver.GetCompressedTexImage)(ctx, target, level, img, texObj,
                                            texImage);
-   }
-   else {
-      gl_problem(ctx, "Driver doesn't implement GetCompressedTexImage");
    }
 }
Index: xc/extras/Mesa/src/teximage.h
diff -u xc/extras/Mesa/src/teximage.h:1.9 xc/extras/Mesa/src/teximage.h:1.11
--- xc/extras/Mesa/src/teximage.h:1.9	Fri May 18 12:59:54 2001
+++ xc/extras/Mesa/src/teximage.h	Mon Sep  9 17:51:59 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -28,7 +28,7 @@
 #define TEXIMAGE_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 /*** Internal functions ***/
@@ -46,15 +46,21 @@
 _mesa_free_texture_image( struct gl_texture_image *teximage );
 
 
-extern GLuint
-_mesa_compressed_image_size(GLcontext *ctx,
-                            GLenum internalFormat,
-                            GLint numDimensions,
-                            GLint width, GLint height, GLint depth);
+extern void
+_mesa_init_teximage_fields(GLcontext *ctx, GLenum target,
+                           struct gl_texture_image *img,
+                           GLsizei width, GLsizei height, GLsizei depth,
+                           GLint border, GLenum internalFormat);
+
 
+extern void
+_mesa_set_tex_image(struct gl_texture_object *tObj,
+                    GLenum target, GLint level,
+                    struct gl_texture_image *texImage);
 
+
 extern struct gl_texture_object *
-_mesa_select_tex_object(GLcontext *ctx, struct gl_texture_unit *texUnit,
+_mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit,
                         GLenum target);
 
 
@@ -63,16 +69,6 @@
                        GLenum target, GLint level);
 
 
-extern void
-_mesa_get_teximage_from_driver(GLcontext *ctx, GLenum target, GLint level,
-                               const struct gl_texture_object *texObj);
-
-
-extern GLboolean
-_mesa_get_teximages_from_driver(GLcontext *ctx,
-                                struct gl_texture_object *texObj);
-
-
 
 /*** API entry point functions ***/
 
@@ -90,7 +86,7 @@
 
 
 extern void
-_mesa_TexImage3D( GLenum target, GLint level, GLint internalformat,
+_mesa_TexImage3D( GLenum target, GLint level, GLenum internalformat,
                   GLsizei width, GLsizei height, GLsizei depth, GLint border,
                   GLenum format, GLenum type, const GLvoid *pixels );
 
Index: xc/extras/Mesa/src/texobj.c
diff -u xc/extras/Mesa/src/texobj.c:1.11 xc/extras/Mesa/src/texobj.c:1.16
--- xc/extras/Mesa/src/texobj.c:1.11	Mon Apr  9 19:09:03 2001
+++ xc/extras/Mesa/src/texobj.c	Mon Dec 16 11:18:27 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -32,11 +32,12 @@
 #include "context.h"
 #include "enums.h"
 #include "hash.h"
+#include "macros.h"
 #include "mem.h"
 #include "teximage.h"
 #include "texstate.h"
 #include "texobj.h"
-#include "types.h"
+#include "mtypes.h"
 #endif
 
 
@@ -48,15 +49,21 @@
  * Input:  shared - the shared GL state structure to contain the texture object
  *         name - integer name for the texture object
  *         dimensions - either 1, 2, 3 or 6 (cube map)
+ *                      zero is ok for the sake of GenTextures()
  * Return:  pointer to new texture object
  */
 struct gl_texture_object *
-gl_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
-                         GLuint dimensions)
+_mesa_alloc_texture_object( struct gl_shared_state *shared,
+			    GLuint name, GLenum target )
 {
    struct gl_texture_object *obj;
 
-   ASSERT(dimensions <= 3 || dimensions == 6);
+   ASSERT(target == 0 ||
+          target == GL_TEXTURE_1D ||
+          target == GL_TEXTURE_2D ||
+          target == GL_TEXTURE_3D ||
+          target == GL_TEXTURE_CUBE_MAP_ARB ||
+          target == GL_TEXTURE_RECTANGLE_NV);
 
    obj = CALLOC_STRUCT(gl_texture_object);
 
@@ -65,18 +72,30 @@
       _glthread_INIT_MUTEX(obj->Mutex);
       obj->RefCount = 1;
       obj->Name = name;
-      obj->Dimensions = dimensions;
+      obj->Target = target;
       obj->Priority = 1.0F;
-      obj->WrapS = GL_REPEAT;
-      obj->WrapT = GL_REPEAT;
-      obj->WrapR = GL_REPEAT;
+      if (target == GL_TEXTURE_RECTANGLE_NV) {
+         obj->WrapS = GL_CLAMP_TO_EDGE;
+         obj->WrapT = GL_CLAMP_TO_EDGE;
+         obj->WrapR = GL_CLAMP_TO_EDGE;
+         obj->MinFilter = GL_LINEAR;
+      }
+      else {
+         obj->WrapS = GL_REPEAT;
+         obj->WrapT = GL_REPEAT;
+         obj->WrapR = GL_REPEAT;
+         obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
+      }
       obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
       obj->MagFilter = GL_LINEAR;
       obj->MinLod = -1000.0;
       obj->MaxLod = 1000.0;
       obj->BaseLevel = 0;
       obj->MaxLevel = 1000;
-      obj->MinMagThresh = 0.0F;
+      obj->MaxAnisotropy = 1.0;
+      obj->CompareFlag = GL_FALSE;
+      obj->CompareOperator = GL_TEXTURE_LEQUAL_R_SGIX;
+      obj->ShadowAmbient = 0;
       _mesa_init_colortable(&obj->Palette);
 
       /* insert into linked list */
@@ -102,19 +121,13 @@
  * Input:  shared - the shared GL state to which the object belongs
  *         t - the texture object to delete
  */
-void gl_free_texture_object( struct gl_shared_state *shared,
-                             struct gl_texture_object *t )
+void _mesa_free_texture_object( struct gl_shared_state *shared,
+                                struct gl_texture_object *t )
 {
    struct gl_texture_object *tprev, *tcurr;
 
    assert(t);
 
-   /* Remove t from dirty list so we don't touch free'd memory later.
-    * Test for shared since Proxy texture aren't in global linked list.
-    */
-   if (shared)
-      gl_remove_texobj_from_dirty_list( shared, t );
-
    /* unlink t from the linked list */
    if (shared) {
       _glthread_LOCK_MUTEX(shared->Mutex);
@@ -143,7 +156,7 @@
 
    _mesa_free_colortable_data(&t->Palette);
 
-   /* free texture images */
+   /* free the texture images */
    {
       GLuint i;
       for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
@@ -152,6 +165,7 @@
          }
       }
    }
+
    /* free this object */
    FREE( t );
 }
@@ -159,8 +173,42 @@
 
 
 /*
- * This is helpful to diagnose incomplete texture problems.
+ * Copy texture object state from one texture object to another.
  */
+void
+_mesa_copy_texture_object( struct gl_texture_object *dest,
+                           const struct gl_texture_object *src )
+{
+   dest->Name = src->Name;
+   dest->Priority = src->Priority;
+   dest->BorderColor[0] = src->BorderColor[0];
+   dest->BorderColor[1] = src->BorderColor[1];
+   dest->BorderColor[2] = src->BorderColor[2];
+   dest->BorderColor[3] = src->BorderColor[3];
+   dest->WrapS = src->WrapS;
+   dest->WrapT = src->WrapT;
+   dest->WrapR = src->WrapR;
+   dest->MinFilter = src->MinFilter;
+   dest->MagFilter = src->MagFilter;
+   dest->MinLod = src->MinLod;
+   dest->MaxLod = src->MaxLod;
+   dest->BaseLevel = src->BaseLevel;
+   dest->MaxLevel = src->MaxLevel;
+   dest->MaxAnisotropy = src->MaxAnisotropy;
+   dest->CompareFlag = src->CompareFlag;
+   dest->CompareOperator = src->CompareOperator;
+   dest->ShadowAmbient = src->ShadowAmbient;
+   dest->_MaxLevel = src->_MaxLevel;
+   dest->_MaxLambda = src->_MaxLambda;
+   dest->Palette = src->Palette;
+   dest->Complete = src->Complete;
+}
+
+
+
+/*
+ * Report why a texture object is incomplete.  (for debug only)
+ */
 #if 0
 static void
 incomplete(const struct gl_texture_object *t, const char *why)
@@ -173,7 +221,7 @@
 
 
 /*
- * Examine a texture object to determine if it is complete or not.
+ * Examine a texture object to determine if it is complete.
  * The t->Complete flag will be set to GL_TRUE or GL_FALSE accordingly.
  */
 void
@@ -181,43 +229,60 @@
                                 struct gl_texture_object *t )
 {
    const GLint baseLevel = t->BaseLevel;
+   GLint maxLog2 = 0, maxLevels = 0;
 
    t->Complete = GL_TRUE;  /* be optimistic */
 
-   /* Always need level zero image */
+   /* Always need the base level image */
    if (!t->Image[baseLevel]) {
       incomplete(t, "Image[baseLevel] == NULL");
       t->Complete = GL_FALSE;
       return;
    }
 
-   /* Compute number of mipmap levels */
-   if (t->Dimensions == 1) {
-      t->P = t->Image[baseLevel]->WidthLog2;
-   }
-   else if (t->Dimensions == 2 || t->Dimensions == 6) {
-      t->P = MAX2(t->Image[baseLevel]->WidthLog2,
-                  t->Image[baseLevel]->HeightLog2);
+   /* Compute _MaxLevel */
+   if (t->Target == GL_TEXTURE_1D) {
+      maxLog2 = t->Image[baseLevel]->WidthLog2;
+      maxLevels = ctx->Const.MaxTextureLevels;
+   }
+   else if (t->Target == GL_TEXTURE_2D) {
+      maxLog2 = MAX2(t->Image[baseLevel]->WidthLog2,
+                     t->Image[baseLevel]->HeightLog2);
+      maxLevels = ctx->Const.MaxTextureLevels;
    }
-   else if (t->Dimensions == 3) {
+   else if (t->Target == GL_TEXTURE_3D) {
       GLint max = MAX2(t->Image[baseLevel]->WidthLog2,
                        t->Image[baseLevel]->HeightLog2);
-      max = MAX2(max, (GLint)(t->Image[baseLevel]->DepthLog2));
-      t->P = max;
+      maxLog2 = MAX2(max, (GLint)(t->Image[baseLevel]->DepthLog2));
+      maxLevels = ctx->Const.Max3DTextureLevels;
    }
-
-   t->P += baseLevel;
-   t->P = MIN2(t->P, t->MaxLevel);
-   t->P = MIN2(t->P, ctx->Const.MaxTextureLevels - 1);
-
-   /* Compute M (see the 1.2 spec) used during mipmapping */
-   t->M = (GLfloat) (t->P - t->BaseLevel);
+   else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
+      maxLog2 = MAX2(t->Image[baseLevel]->WidthLog2,
+                     t->Image[baseLevel]->HeightLog2);
+      maxLevels = ctx->Const.MaxCubeTextureLevels;
+   }
+   else if (t->Target == GL_TEXTURE_RECTANGLE_NV) {
+      maxLog2 = 0;  /* not applicable */
+      maxLevels = 1;  /* no mipmapping */
+   }
+   else {
+      _mesa_problem(ctx, "Bad t->Target in _mesa_test_texobj_completeness");
+      return;
+   }
 
+   ASSERT(maxLevels > 0);
 
-   if (t->Dimensions == 6) {
-      /* make sure all six level 0 images are same size */
-      const GLint w = t->Image[baseLevel]->Width2;
-      const GLint h = t->Image[baseLevel]->Height2;
+   t->_MaxLevel = baseLevel + maxLog2;
+   t->_MaxLevel = MIN2(t->_MaxLevel, t->MaxLevel);
+   t->_MaxLevel = MIN2(t->_MaxLevel, maxLevels - 1);
+
+   /* Compute _MaxLambda = q - b (see the 1.2 spec) used during mipmapping */
+   t->_MaxLambda = (GLfloat) (t->_MaxLevel - t->BaseLevel);
+
+   if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
+      /* make sure that all six cube map level 0 images are the same size */
+      const GLuint w = t->Image[baseLevel]->Width2;
+      const GLuint h = t->Image[baseLevel]->Height2;
       if (!t->NegX[baseLevel] ||
           t->NegX[baseLevel]->Width2 != w ||
           t->NegX[baseLevel]->Height2 != h ||
@@ -245,7 +310,7 @@
        */
       GLint i;
       GLint minLevel = baseLevel;
-      GLint maxLevel = t->P;
+      GLint maxLevel = t->_MaxLevel;
 
       if (minLevel > maxLevel) {
          t->Complete = GL_FALSE;
@@ -256,7 +321,7 @@
       /* Test dimension-independent attributes */
       for (i = minLevel; i <= maxLevel; i++) {
          if (t->Image[i]) {
-            if (t->Image[i]->Format != t->Image[baseLevel]->Format) {
+            if (t->Image[i]->TexFormat != t->Image[baseLevel]->TexFormat) {
                t->Complete = GL_FALSE;
                incomplete(t, "Format[i] != Format[baseLevel]");
                return;
@@ -270,10 +335,10 @@
       }
 
       /* Test things which depend on number of texture image dimensions */
-      if (t->Dimensions == 1) {
+      if (t->Target == GL_TEXTURE_1D) {
          /* Test 1-D mipmaps */
          GLuint width = t->Image[baseLevel]->Width2;
-         for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
+         for (i = baseLevel + 1; i < maxLevels; i++) {
             if (width > 1) {
                width /= 2;
             }
@@ -294,11 +359,11 @@
             }
          }
       }
-      else if (t->Dimensions == 2) {
+      else if (t->Target == GL_TEXTURE_2D) {
          /* Test 2-D mipmaps */
          GLuint width = t->Image[baseLevel]->Width2;
          GLuint height = t->Image[baseLevel]->Height2;
-         for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
+         for (i = baseLevel + 1; i < maxLevels; i++) {
             if (width > 1) {
                width /= 2;
             }
@@ -327,12 +392,12 @@
             }
          }
       }
-      else if (t->Dimensions == 3) {
+      else if (t->Target == GL_TEXTURE_3D) {
          /* Test 3-D mipmaps */
          GLuint width = t->Image[baseLevel]->Width2;
          GLuint height = t->Image[baseLevel]->Height2;
          GLuint depth = t->Image[baseLevel]->Depth2;
-	 for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
+	 for (i = baseLevel + 1; i < maxLevels; i++) {
             if (width > 1) {
                width /= 2;
             }
@@ -369,11 +434,11 @@
             }
          }
       }
-      else if (t->Dimensions == 6) {
+      else if (t->Target == GL_TEXTURE_CUBE_MAP_ARB) {
          /* make sure 6 cube faces are consistant */
          GLuint width = t->Image[baseLevel]->Width2;
          GLuint height = t->Image[baseLevel]->Height2;
-	 for (i = baseLevel + 1; i < ctx->Const.MaxTextureLevels; i++) {
+	 for (i = baseLevel + 1; i < maxLevels; i++) {
             if (width > 1) {
                width /= 2;
             }
@@ -405,9 +470,13 @@
             }
          }
       }
+      else if (t->Target == GL_TEXTURE_RECTANGLE_NV) {
+         /* XXX special checking? */
+
+      }
       else {
          /* Dimensions = ??? */
-         gl_problem(NULL, "Bug in gl_test_texture_object_completeness\n");
+         _mesa_problem(ctx, "Bug in gl_test_texture_object_completeness\n");
       }
    }
 }
@@ -425,10 +494,10 @@
    GET_CURRENT_CONTEXT(ctx);
    GLuint first;
    GLint i;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGenTextures");
    if (n < 0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glGenTextures" );
       return;
    }
 
@@ -451,7 +520,7 @@
    for (i=0;i<n;i++) {
       GLuint name = first + i;
       GLuint dims = 0;
-      (void) gl_alloc_texture_object(ctx->Shared, name, dims);
+      (void) _mesa_alloc_texture_object( ctx->Shared, name, dims);
    }
 
    _glthread_UNLOCK_MUTEX(GenTexturesLock);
@@ -467,43 +536,69 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex */
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDeleteTextures");
-
    if (!texName)
       return;
 
    for (i=0;i<n;i++) {
-      struct gl_texture_object *t;
-      if (texName[i]>0) {
-         t = (struct gl_texture_object *)
+      if (texName[i] > 0) {
+         struct gl_texture_object *delObj = (struct gl_texture_object *)
             _mesa_HashLookup(ctx->Shared->TexObjects, texName[i]);
-         if (t) {
+         if (delObj) {
             /* First check if this texture is currently bound.
              * If so, unbind it and decrement the reference count.
              */
             GLuint u;
             for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
                struct gl_texture_unit *unit = &ctx->Texture.Unit[u];
-	       GLuint d;
-	       for (d = 1 ; d <= 3 ; d++) {
-		  if (unit->CurrentD[d] == t) {
-		     unit->CurrentD[d] = ctx->Shared->DefaultD[d];
-		     ctx->Shared->DefaultD[d]->RefCount++;
-		     t->RefCount--;
-		     ASSERT( t->RefCount >= 0 );
-                     ctx->NewState |= NEW_TEXTURING;
-		  }
-	       }
+               if (delObj == unit->Current1D) {
+                  unit->Current1D = ctx->Shared->Default1D;
+                  ctx->Shared->Default1D->RefCount++;
+                  delObj->RefCount--;
+                  if (delObj == unit->_Current)
+                     unit->_Current = unit->Current1D;
+               }
+               else if (delObj == unit->Current2D) {
+                  unit->Current2D = ctx->Shared->Default2D;
+                  ctx->Shared->Default2D->RefCount++;
+                  delObj->RefCount--;
+                  if (delObj == unit->_Current)
+                     unit->_Current = unit->Current2D;
+               }
+               else if (delObj == unit->Current3D) {
+                  unit->Current3D = ctx->Shared->Default3D;
+                  ctx->Shared->Default3D->RefCount++;
+                  delObj->RefCount--;
+                  if (delObj == unit->_Current)
+                     unit->_Current = unit->Current3D;
+               }
+               else if (delObj == unit->CurrentCubeMap) {
+                  unit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
+                  ctx->Shared->DefaultCubeMap->RefCount++;
+                  delObj->RefCount--;
+                  if (delObj == unit->_Current)
+                     unit->_Current = unit->CurrentCubeMap;
+               }
+               else if (delObj == unit->CurrentRect) {
+                  unit->CurrentRect = ctx->Shared->DefaultRect;
+                  ctx->Shared->DefaultRect->RefCount++;
+                  delObj->RefCount--;
+                  if (delObj == unit->_Current)
+                     unit->_Current = unit->CurrentRect;
+               }
             }
+            ctx->NewState |= _NEW_TEXTURE;
 
             /* Decrement reference count and delete if zero */
-            t->RefCount--;
-            ASSERT( t->RefCount >= 0 );
-            if (t->RefCount == 0) {
+            delObj->RefCount--;
+            ASSERT(delObj->RefCount >= 0);
+
+            if (delObj->RefCount == 0) {
+               ASSERT(delObj->Name != 0);
                if (ctx->Driver.DeleteTexture)
-                  (*ctx->Driver.DeleteTexture)( ctx, t );
-               gl_free_texture_object(ctx->Shared, t);
+                  (*ctx->Driver.DeleteTexture)( ctx, delObj );
+               _mesa_free_texture_object(ctx->Shared, delObj);
             }
          }
       }
@@ -522,119 +617,140 @@
    GLuint unit = ctx->Texture.CurrentUnit;
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
    struct gl_texture_object *oldTexObj;
-   struct gl_texture_object *newTexObj;
-   GLuint dim;
+   struct gl_texture_object *newTexObj = 0;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
       fprintf(stderr, "glBindTexture %s %d\n",
-	      gl_lookup_enum_by_nr(target), (GLint) texName);
+	      _mesa_lookup_enum_by_nr(target), (GLint) texName);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBindTexture");
-
    switch (target) {
       case GL_TEXTURE_1D:
-         dim = 1;
-         oldTexObj = texUnit->CurrentD[1];
+         oldTexObj = texUnit->Current1D;
          break;
       case GL_TEXTURE_2D:
-         dim = 2;
-         oldTexObj = texUnit->CurrentD[2];
+         oldTexObj = texUnit->Current2D;
          break;
       case GL_TEXTURE_3D:
-         dim = 3;
-         oldTexObj = texUnit->CurrentD[3];
+         oldTexObj = texUnit->Current3D;
          break;
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap) {
-            dim = 6;
-            oldTexObj = texUnit->CurrentCubeMap;
-            break;
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
+            return;
+         }
+         oldTexObj = texUnit->CurrentCubeMap;
+         break;
+      case GL_TEXTURE_RECTANGLE_NV:
+         if (!ctx->Extensions.NV_texture_rectangle) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
+            return;
          }
-         /* fallthrough */
+         oldTexObj = texUnit->CurrentRect;
+         break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glBindTexture(target)" );
          return;
    }
 
-   ctx->NewState |= NEW_TEXTURING;
-
    if (oldTexObj->Name == texName)
-      return;
+      return;   /* rebinding the same texture- no change */
 
+   /*
+    * Get pointer to new texture object (newTexObj)
+    */
    if (texName == 0) {
-      if (target == GL_TEXTURE_CUBE_MAP_ARB)
-         newTexObj = ctx->Shared->DefaultCubeMap;
-      else
-         newTexObj = ctx->Shared->DefaultD[dim];
+      /* newTexObj = a default texture object */
+      switch (target) {
+         case GL_TEXTURE_1D:
+            newTexObj = ctx->Shared->Default1D;
+            break;
+         case GL_TEXTURE_2D:
+            newTexObj = ctx->Shared->Default2D;
+            break;
+         case GL_TEXTURE_3D:
+            newTexObj = ctx->Shared->Default3D;
+            break;
+         case GL_TEXTURE_CUBE_MAP_ARB:
+            newTexObj = ctx->Shared->DefaultCubeMap;
+            break;
+         case GL_TEXTURE_RECTANGLE_NV:
+            newTexObj = ctx->Shared->DefaultRect;
+            break;
+         default:
+            ; /* Bad targets are caught above */
+      }
    }
    else {
-      struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
+      /* non-default texture object */
+      const struct _mesa_HashTable *hash = ctx->Shared->TexObjects;
       newTexObj = (struct gl_texture_object *) _mesa_HashLookup(hash, texName);
-
-      if (!newTexObj)
-	 newTexObj = gl_alloc_texture_object(ctx->Shared, texName, dim);
-
-      if (newTexObj->Dimensions != dim) {
-	 if (newTexObj->Dimensions) {
+      if (newTexObj) {
+         /* error checking */
+         if (newTexObj->Target != 0 && newTexObj->Target != target) {
             /* the named texture object's dimensions don't match the target */
-	    gl_error( ctx, GL_INVALID_OPERATION, "glBindTexture" );
-	    return;
-	 }
-	 newTexObj->Dimensions = dim;
+            _mesa_error( ctx, GL_INVALID_OPERATION,
+                         "glBindTexture(wrong dimensionality)" );
+            return;
+         }
+         if (newTexObj->Target == 0 && target == GL_TEXTURE_RECTANGLE_NV) {
+            /* have to init wrap and filter state here - kind of klunky */
+            newTexObj->WrapS = GL_CLAMP_TO_EDGE;
+            newTexObj->WrapT = GL_CLAMP_TO_EDGE;
+            newTexObj->WrapR = GL_CLAMP_TO_EDGE;
+            newTexObj->MinFilter = GL_LINEAR;
+         }
+      }
+      else {
+         /* if this is a new texture id, allocate a texture object now */
+	 newTexObj = _mesa_alloc_texture_object( ctx->Shared, texName,
+						 target);
+         if (!newTexObj) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindTexture");
+            return;
+         }
       }
+      newTexObj->Target = target;
    }
 
    newTexObj->RefCount++;
 
+   /* do the actual binding, but first flush outstanding vertices:
+    */
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+
    switch (target) {
       case GL_TEXTURE_1D:
-         texUnit->CurrentD[1] = newTexObj;
+         texUnit->Current1D = newTexObj;
          break;
       case GL_TEXTURE_2D:
-         texUnit->CurrentD[2] = newTexObj;
+         texUnit->Current2D = newTexObj;
          break;
       case GL_TEXTURE_3D:
-         texUnit->CurrentD[3] = newTexObj;
+         texUnit->Current3D = newTexObj;
          break;
       case GL_TEXTURE_CUBE_MAP_ARB:
          texUnit->CurrentCubeMap = newTexObj;
          break;
+      case GL_TEXTURE_RECTANGLE_NV:
+         texUnit->CurrentRect = newTexObj;
+         break;
       default:
-         gl_problem(ctx, "bad target in BindTexture");
-   }
-
-   /* If we've changed the CurrentD[123] texture object then update the
-    * ctx->Texture.Current pointer to point to the new texture object.
-    */
-   texUnit->Current = texUnit->CurrentD[texUnit->CurrentDimension];
-
-   /* Check if we may have to use a new triangle rasterizer */
-   if ((ctx->IndirectTriangles & DD_SW_RASTERIZE) &&
-       (   oldTexObj->WrapS != newTexObj->WrapS
-        || oldTexObj->WrapT != newTexObj->WrapT
-        || oldTexObj->WrapR != newTexObj->WrapR
-        || oldTexObj->MinFilter != newTexObj->MinFilter
-        || oldTexObj->MagFilter != newTexObj->MagFilter
-        || (oldTexObj->Image[0] && newTexObj->Image[0] && 
-	   (oldTexObj->Image[0]->Format!=newTexObj->Image[0]->Format))))
-   {
-      ctx->NewState |= NEW_RASTER_OPS;
+         _mesa_problem(ctx, "bad target in BindTexture");
    }
 
    /* Pass BindTexture call to device driver */
-   if (ctx->Driver.BindTexture) {
+   if (ctx->Driver.BindTexture)
       (*ctx->Driver.BindTexture)( ctx, target, newTexObj );
-   }
 
-   if (oldTexObj->Name > 0) {
-      /* never delete default (id=0) texture objects */
-      oldTexObj->RefCount--;
-      if (oldTexObj->RefCount <= 0) {
-         if (ctx->Driver.DeleteTexture) {
-	    (*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
-	 }
-         gl_free_texture_object(ctx->Shared, oldTexObj);
+   oldTexObj->RefCount--;
+   assert(oldTexObj->RefCount >= 0);
+   if (oldTexObj->RefCount == 0) {
+      assert(oldTexObj->Name != 0);
+      if (ctx->Driver.DeleteTexture) {
+         (*ctx->Driver.DeleteTexture)( ctx, oldTexObj );
       }
+      _mesa_free_texture_object(ctx->Shared, oldTexObj);
    }
 }
 
@@ -649,10 +765,10 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPrioritizeTextures");
    if (n < 0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glPrioritizeTextures" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glPrioritizeTextures" );
       return;
    }
 
@@ -670,12 +786,14 @@
          }
       }
    }
+
+   ctx->NewState |= _NEW_TEXTURE;
 }
 
 
 
 /*
- * Execute glAreTexturesResident 
+ * Execute glAreTexturesResident
  */
 GLboolean
 _mesa_AreTexturesResident(GLsizei n, const GLuint *texName,
@@ -684,11 +802,10 @@
    GET_CURRENT_CONTEXT(ctx);
    GLboolean allResident = GL_TRUE;
    GLint i;
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, 
-                                            "glAreTexturesResident", GL_FALSE);
    if (n < 0) {
-      gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(n)");
       return GL_FALSE;
    }
 
@@ -698,7 +815,7 @@
    for (i = 0; i < n; i++) {
       struct gl_texture_object *t;
       if (texName[i] == 0) {
-         gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
+         _mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
          return GL_FALSE;
       }
       t = (struct gl_texture_object *)
@@ -714,7 +831,7 @@
          }
       }
       else {
-         gl_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
+         _mesa_error(ctx, GL_INVALID_VALUE, "glAreTexturesResident(textures)");
          return GL_FALSE;
       }
    }
@@ -730,13 +847,6 @@
 _mesa_IsTexture( GLuint texture )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glIsTextures",
-						  GL_FALSE);
-   if (texture > 0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture)) {
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+   return texture > 0 && _mesa_HashLookup(ctx->Shared->TexObjects, texture);
 }
-
Index: xc/extras/Mesa/src/texobj.h
diff -u xc/extras/Mesa/src/texobj.h:1.4 xc/extras/Mesa/src/texobj.h:1.7
--- xc/extras/Mesa/src/texobj.h:1.4	Fri Jun 16 20:02:17 2000
+++ xc/extras/Mesa/src/texobj.h	Mon Sep  9 17:52:00 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,7 +28,7 @@
 #define TEXTOBJ_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 
@@ -37,12 +37,18 @@
  */
 
 extern struct gl_texture_object *
-gl_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
-                         GLuint dimensions );
+_mesa_alloc_texture_object( struct gl_shared_state *shared, GLuint name,
+                            GLenum target );
 
 
-extern void gl_free_texture_object( struct gl_shared_state *shared,
-                                    struct gl_texture_object *t );
+extern void
+_mesa_free_texture_object( struct gl_shared_state *shared,
+                           struct gl_texture_object *t );
+
+
+extern void
+_mesa_copy_texture_object( struct gl_texture_object *dest,
+                           const struct gl_texture_object *src );
 
 
 extern void
Index: xc/extras/Mesa/src/texstate.c
diff -u xc/extras/Mesa/src/texstate.c:1.14 xc/extras/Mesa/src/texstate.c:1.19
--- xc/extras/Mesa/src/texstate.c:1.14	Fri Aug 17 14:40:04 2001
+++ xc/extras/Mesa/src/texstate.c	Wed Jan 29 18:00:40 2003
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.4
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -28,17 +28,17 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "colormac.h"
 #include "context.h"
 #include "enums.h"
 #include "extensions.h"
 #include "macros.h"
-#include "matrix.h"
 #include "texobj.h"
 #include "teximage.h"
 #include "texstate.h"
-#include "texture.h"
-#include "types.h"
-#include "xform.h"
+#include "mtypes.h"
+#include "math/m_xform.h"
+#include "math/m_matrix.h"
 #endif
 
 
@@ -55,6 +55,70 @@
 
 
 
+void
+_mesa_copy_texture_state( const GLcontext *src, GLcontext *dst )
+{
+   GLuint i;
+
+   ASSERT(src);
+   ASSERT(dst);
+
+   dst->Texture.CurrentUnit = src->Texture.CurrentUnit;
+   dst->Texture._GenFlags = src->Texture._GenFlags;
+   dst->Texture._TexGenEnabled = src->Texture._TexGenEnabled;
+   dst->Texture._TexMatEnabled = src->Texture._TexMatEnabled;
+   dst->Texture.SharedPalette = src->Texture.SharedPalette;
+
+   /* per-unit state */
+   for (i = 0; i < src->Const.MaxTextureUnits; i++) {
+      dst->Texture.Unit[i].Enabled = src->Texture.Unit[i].Enabled;
+      dst->Texture.Unit[i].EnvMode = src->Texture.Unit[i].EnvMode;
+      COPY_4V(dst->Texture.Unit[i].EnvColor, src->Texture.Unit[i].EnvColor);
+      dst->Texture.Unit[i].TexGenEnabled = src->Texture.Unit[i].TexGenEnabled;
+      dst->Texture.Unit[i].GenModeS = src->Texture.Unit[i].GenModeS;
+      dst->Texture.Unit[i].GenModeT = src->Texture.Unit[i].GenModeT;
+      dst->Texture.Unit[i].GenModeR = src->Texture.Unit[i].GenModeR;
+      dst->Texture.Unit[i].GenModeQ = src->Texture.Unit[i].GenModeQ;
+      dst->Texture.Unit[i]._GenBitS = src->Texture.Unit[i]._GenBitS;
+      dst->Texture.Unit[i]._GenBitT = src->Texture.Unit[i]._GenBitT;
+      dst->Texture.Unit[i]._GenBitR = src->Texture.Unit[i]._GenBitR;
+      dst->Texture.Unit[i]._GenBitQ = src->Texture.Unit[i]._GenBitQ;
+      dst->Texture.Unit[i]._GenFlags = src->Texture.Unit[i]._GenFlags;
+      COPY_4V(dst->Texture.Unit[i].ObjectPlaneS, src->Texture.Unit[i].ObjectPlaneS);
+      COPY_4V(dst->Texture.Unit[i].ObjectPlaneT, src->Texture.Unit[i].ObjectPlaneT);
+      COPY_4V(dst->Texture.Unit[i].ObjectPlaneR, src->Texture.Unit[i].ObjectPlaneR);
+      COPY_4V(dst->Texture.Unit[i].ObjectPlaneQ, src->Texture.Unit[i].ObjectPlaneQ);
+      COPY_4V(dst->Texture.Unit[i].EyePlaneS, src->Texture.Unit[i].EyePlaneS);
+      COPY_4V(dst->Texture.Unit[i].EyePlaneT, src->Texture.Unit[i].EyePlaneT);
+      COPY_4V(dst->Texture.Unit[i].EyePlaneR, src->Texture.Unit[i].EyePlaneR);
+      COPY_4V(dst->Texture.Unit[i].EyePlaneQ, src->Texture.Unit[i].EyePlaneQ);
+      dst->Texture.Unit[i].LodBias = src->Texture.Unit[i].LodBias;
+
+      /* GL_EXT_texture_env_combine */
+      dst->Texture.Unit[i].CombineModeRGB = src->Texture.Unit[i].CombineModeRGB;
+      dst->Texture.Unit[i].CombineModeA = src->Texture.Unit[i].CombineModeA;
+      COPY_3V(dst->Texture.Unit[i].CombineSourceRGB, src->Texture.Unit[i].CombineSourceRGB);
+      COPY_3V(dst->Texture.Unit[i].CombineSourceA, src->Texture.Unit[i].CombineSourceA);
+      COPY_3V(dst->Texture.Unit[i].CombineOperandRGB, src->Texture.Unit[i].CombineOperandRGB);
+      COPY_3V(dst->Texture.Unit[i].CombineOperandA, src->Texture.Unit[i].CombineOperandA);
+      dst->Texture.Unit[i].CombineScaleShiftRGB = src->Texture.Unit[i].CombineScaleShiftRGB;
+      dst->Texture.Unit[i].CombineScaleShiftA = src->Texture.Unit[i].CombineScaleShiftA;
+
+      /* texture object state */
+      _mesa_copy_texture_object(dst->Texture.Unit[i].Current1D,
+                                src->Texture.Unit[i].Current1D);
+      _mesa_copy_texture_object(dst->Texture.Unit[i].Current2D,
+                                src->Texture.Unit[i].Current2D);
+      _mesa_copy_texture_object(dst->Texture.Unit[i].Current3D,
+                                src->Texture.Unit[i].Current3D);
+      _mesa_copy_texture_object(dst->Texture.Unit[i].CurrentCubeMap,
+                                src->Texture.Unit[i].CurrentCubeMap);
+      _mesa_copy_texture_object(dst->Texture.Unit[i].CurrentRect,
+                                src->Texture.Unit[i].CurrentRect);
+   }
+}
+
+
 
 /**********************************************************************/
 /*                       Texture Environment                          */
@@ -66,398 +130,616 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexEnv");
+#define TE_ERROR(errCode, msg, value)				\
+   {								\
+      char s[100];						\
+      sprintf(s, msg, _mesa_lookup_enum_by_nr(value));		\
+      _mesa_error(ctx, errCode, s);				\
+   }
 
    if (target==GL_TEXTURE_ENV) {
       switch (pname) {
-         case GL_TEXTURE_ENV_MODE:
-            {
-               GLenum mode = (GLenum) (GLint) *param;
-               switch (mode) {
-                  case GL_MODULATE:
-                  case GL_BLEND:
-                  case GL_DECAL:
-                  case GL_REPLACE:
-                  case GL_ADD:
-                  case GL_COMBINE_EXT:
-                     if (mode == GL_ADD &&
-                         !ctx->Extensions.HaveTextureEnvAdd) {
-                        gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(param)");
-                        return;
-                     }
-                     if (mode == GL_COMBINE_EXT &&
-                         !ctx->Extensions.HaveTextureEnvCombine) {
-                        gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(param)");
-                        return;
-                     }
-                     if (texUnit->EnvMode == mode)
-                        return;  /* no change */
-                     texUnit->EnvMode = mode;
-                     ctx->NewState |= NEW_TEXTURE_ENV;
-                     break;
-                  default:
-                     gl_error( ctx, GL_INVALID_VALUE, "glTexEnv(param)" );
-                     return;
+      case GL_TEXTURE_ENV_MODE: {
+	 GLenum mode = (GLenum) (GLint) *param;
+
+	 switch (mode) {
+	 case GL_ADD:
+	    if (!ctx->Extensions.EXT_texture_env_add) {
+	       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+	       return;
+	    }
+	    break;
+	 case GL_COMBINE_EXT:
+	    if (!ctx->Extensions.EXT_texture_env_combine &&
+                !ctx->Extensions.ARB_texture_env_combine) {
+	       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+	       return;
+	    }
+	    break;
+	 case GL_MODULATE:
+	 case GL_BLEND:
+	 case GL_DECAL:
+	 case GL_REPLACE:
+	    break;
+	 default:
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+	    return;
+	 }
+
+	 if (texUnit->EnvMode == mode)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	 texUnit->EnvMode = mode;
+	 break;
+      }
+      case GL_TEXTURE_ENV_COLOR: {
+	 GLfloat tmp[4];
+	 tmp[0] = CLAMP( param[0], 0.0F, 1.0F );
+	 tmp[1] = CLAMP( param[1], 0.0F, 1.0F );
+	 tmp[2] = CLAMP( param[2], 0.0F, 1.0F );
+	 tmp[3] = CLAMP( param[3], 0.0F, 1.0F );
+	 if (TEST_EQ_4V(tmp, texUnit->EnvColor))
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	 COPY_4FV(texUnit->EnvColor, tmp);
+	 break;
+      }
+      case GL_COMBINE_RGB_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    const GLenum mode = (GLenum) (GLint) *param;
+	    switch (mode) {
+	    case GL_REPLACE:
+	    case GL_MODULATE:
+	    case GL_ADD:
+	    case GL_ADD_SIGNED_EXT:
+	    case GL_INTERPOLATE_EXT:
+               /* OK */
+	       break;
+            case GL_SUBTRACT_ARB:
+               if (!ctx->Extensions.ARB_texture_env_combine) {
+                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+                  return;
                }
-            }
+               break;
+	    case GL_DOT3_RGB_EXT:
+	    case GL_DOT3_RGBA_EXT:
+	       if (!ctx->Extensions.EXT_texture_env_dot3) {
+                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+		  return;
+	       }
+	       break;
+	    case GL_DOT3_RGB_ARB:
+	    case GL_DOT3_RGBA_ARB:
+               if (!ctx->Extensions.ARB_texture_env_dot3) {
+                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+		  return;
+	       }
+	       break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+	       return;
+	    }
+	    if (texUnit->CombineModeRGB == mode)
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->CombineModeRGB = mode;
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+         break;
+      case GL_COMBINE_ALPHA_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    const GLenum mode = (GLenum) (GLint) *param;
+	    switch (mode) {
+	    case GL_REPLACE:
+	    case GL_MODULATE:
+	    case GL_ADD:
+	    case GL_ADD_SIGNED_EXT:
+	    case GL_INTERPOLATE_EXT:
+               /* OK */
+	       break;
+            case GL_SUBTRACT_ARB:
+               if (!ctx->Extensions.ARB_texture_env_combine) {
+                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+                  return;
+               }
+               break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+	       return;
+	    }
+            if (texUnit->CombineModeA == mode)
+               return;
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texUnit->CombineModeA = mode;
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_SOURCE0_RGB_EXT:
+      case GL_SOURCE1_RGB_EXT:
+      case GL_SOURCE2_RGB_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+	     ctx->Extensions.ARB_texture_env_combine) {
+	    GLenum source = (GLenum) (GLint) *param;
+	    GLuint s = pname - GL_SOURCE0_RGB_EXT;
+	    switch (source) {
+	    case GL_TEXTURE:
+	    case GL_CONSTANT_EXT:
+	    case GL_PRIMARY_COLOR_EXT:
+	    case GL_PREVIOUS_EXT:
+	       if (texUnit->CombineSourceRGB[s] == source)
+		  return;
+	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	       texUnit->CombineSourceRGB[s] = source;
+	       break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
+	       return;
+	    }
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_SOURCE0_ALPHA_EXT:
+      case GL_SOURCE1_ALPHA_EXT:
+      case GL_SOURCE2_ALPHA_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    GLenum source = (GLenum) (GLint) *param;
+	    GLuint s = pname - GL_SOURCE0_ALPHA_EXT;
+	    switch (source) {
+	    case GL_TEXTURE:
+	    case GL_CONSTANT_EXT:
+	    case GL_PRIMARY_COLOR_EXT:
+	    case GL_PREVIOUS_EXT:
+	       if (texUnit->CombineSourceA[s] == source) return;
+	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	       texUnit->CombineSourceA[s] = source;
+	       break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
+	       return;
+	    }
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_OPERAND0_RGB_EXT:
+      case GL_OPERAND1_RGB_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+	     ctx->Extensions.ARB_texture_env_combine) {
+	    GLenum operand = (GLenum) (GLint) *param;
+	    GLuint s = pname - GL_OPERAND0_RGB_EXT;
+	    switch (operand) {
+	    case GL_SRC_COLOR:
+	    case GL_ONE_MINUS_SRC_COLOR:
+	    case GL_SRC_ALPHA:
+	    case GL_ONE_MINUS_SRC_ALPHA:
+	       if (texUnit->CombineOperandRGB[s] == operand)
+		  return;
+	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	       texUnit->CombineOperandRGB[s] = operand;
+	       break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
+	       return;
+	    }
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_OPERAND0_ALPHA_EXT:
+      case GL_OPERAND1_ALPHA_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    GLenum operand = (GLenum) (GLint) *param;
+	    switch (operand) {
+	    case GL_SRC_ALPHA:
+	    case GL_ONE_MINUS_SRC_ALPHA:
+	       if (texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] ==
+		   operand)
+		  return;
+	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	       texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] = operand;
+	       break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
+	       return;
+	    }
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_OPERAND2_RGB_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    GLenum operand = (GLenum) (GLint) *param;
+	    switch (operand) {
+	    case GL_SRC_COLOR:           /* ARB combine only */
+	    case GL_ONE_MINUS_SRC_COLOR: /* ARB combine only */
+	    case GL_SRC_ALPHA:
+	    case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
+	       if (texUnit->CombineOperandRGB[2] == operand)
+		  return;
+	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	       texUnit->CombineOperandRGB[2] = operand;
+	       break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
+	       return;
+	    }
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_OPERAND2_ALPHA_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    GLenum operand = (GLenum) (GLint) *param;
+	    switch (operand) {
+	    case GL_SRC_ALPHA:
+	    case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
+	       if (texUnit->CombineOperandA[2] == operand)
+		  return;
+	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	       texUnit->CombineOperandA[2] = operand;
+	       break;
+	    default:
+               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
+	       return;
+	    }
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_RGB_SCALE_EXT:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    GLuint newshift;
+	    if (*param == 1.0) {
+	       newshift = 0;
+	    }
+	    else if (*param == 2.0) {
+	       newshift = 1;
+	    }
+	    else if (*param == 4.0) {
+	       newshift = 2;
+	    }
+	    else {
+	       _mesa_error( ctx, GL_INVALID_VALUE,
+                            "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
+	       return;
+	    }
+	    if (texUnit->CombineScaleShiftRGB == newshift)
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->CombineScaleShiftRGB = newshift;
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      case GL_ALPHA_SCALE:
+	 if (ctx->Extensions.EXT_texture_env_combine ||
+             ctx->Extensions.ARB_texture_env_combine) {
+	    GLuint newshift;
+	    if (*param == 1.0) {
+	       newshift = 0;
+	    }
+	    else if (*param == 2.0) {
+	       newshift = 1;
+	    }
+	    else if (*param == 4.0) {
+	       newshift = 2;
+	    }
+	    else {
+	       _mesa_error( ctx, GL_INVALID_VALUE,
+                            "glTexEnv(GL_ALPHA_SCALE not 1, 2 or 4)" );
+	       return;
+	    }
+	    if (texUnit->CombineScaleShiftA == newshift)
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->CombineScaleShiftA = newshift;
+	 }
+	 else {
+            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	    return;
+	 }
+	 break;
+      default:
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
+	 return;
+      }
+   }
+   else if (target==GL_TEXTURE_FILTER_CONTROL_EXT) {
+      if (!ctx->Extensions.EXT_texture_lod_bias) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
+	 return;
+      }
+      switch (pname) {
+      case GL_TEXTURE_LOD_BIAS_EXT:
+	 if (texUnit->LodBias == param[0])
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->LodBias = CLAMP(param[0], -ctx->Const.MaxTextureLodBias,
+                                  ctx->Const.MaxTextureLodBias);
+	 break;
+      default:
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	 return;
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target)" );
+      return;
+   }
+
+   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
+      fprintf(stderr, "glTexEnv %s %s %.1f(%s) ...\n",
+	      _mesa_lookup_enum_by_nr(target),
+	      _mesa_lookup_enum_by_nr(pname),
+	      *param,
+	      _mesa_lookup_enum_by_nr((GLenum) (GLint) *param));
+
+   /* Tell device driver about the new texture environment */
+   if (ctx->Driver.TexEnv) {
+      (*ctx->Driver.TexEnv)( ctx, target, pname, param );
+   }
+}
+
+
+void
+_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
+{
+   _mesa_TexEnvfv( target, pname, &param );
+}
+
+
+
+void
+_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
+{
+   GLfloat p[4];
+   p[0] = (GLfloat) param;
+   p[1] = p[2] = p[3] = 0.0;
+   _mesa_TexEnvfv( target, pname, p );
+}
+
+
+void
+_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
+{
+   GLfloat p[4];
+   if (pname == GL_TEXTURE_ENV_COLOR) {
+      p[0] = INT_TO_FLOAT( param[0] );
+      p[1] = INT_TO_FLOAT( param[1] );
+      p[2] = INT_TO_FLOAT( param[2] );
+      p[3] = INT_TO_FLOAT( param[3] );
+   }
+   else {
+      p[0] = (GLfloat) param[0];
+      p[1] = p[2] = p[3] = 0;  /* init to zero, just to be safe */
+   }
+   _mesa_TexEnvfv( target, pname, p );
+}
+
+
+void
+_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (target == GL_TEXTURE_ENV) {
+      switch (pname) {
+         case GL_TEXTURE_ENV_MODE:
+            *params = ENUM_TO_FLOAT(texUnit->EnvMode);
             break;
          case GL_TEXTURE_ENV_COLOR:
-            texUnit->EnvColor[0] = CLAMP( param[0], 0.0F, 1.0F );
-            texUnit->EnvColor[1] = CLAMP( param[1], 0.0F, 1.0F );
-            texUnit->EnvColor[2] = CLAMP( param[2], 0.0F, 1.0F );
-            texUnit->EnvColor[3] = CLAMP( param[3], 0.0F, 1.0F );
+            COPY_4FV( params, texUnit->EnvColor );
             break;
          case GL_COMBINE_RGB_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               GLenum mode = (GLenum) (GLint) *param;
-               switch (mode) {
-                  case GL_REPLACE:
-                  case GL_MODULATE:
-                  case GL_ADD:
-                  case GL_ADD_SIGNED_EXT:
-                  case GL_INTERPOLATE_EXT:
-	          case GL_DOT3_RGB_EXT:
-	          case GL_DOT3_RGBA_EXT:
-                     if ((mode == GL_DOT3_RGB_EXT ||
-			  mode == GL_DOT3_RGBA_EXT) &&
-                         !ctx->Extensions.HaveTextureEnvDot3) {
-                        gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(param)");
-                        return;
-                     }
-                     if (texUnit->CombineModeRGB == mode)
-                        return;  /* no change */
-                     texUnit->CombineModeRGB = mode;
-                     ctx->NewState |= NEW_TEXTURE_ENV;
-                     break;
-                  default:
-                     gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                     return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineModeRGB;
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
          case GL_COMBINE_ALPHA_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               GLenum mode = (GLenum) (GLint) *param;
-               switch (mode) {
-                  case GL_REPLACE:
-                  case GL_MODULATE:
-                  case GL_ADD:
-                  case GL_ADD_SIGNED_EXT:
-                  case GL_INTERPOLATE_EXT:
-                     if (texUnit->CombineModeA == mode)
-                        return;  /* no change */
-                     texUnit->CombineModeA = mode;
-                     ctx->NewState |= NEW_TEXTURE_ENV;
-                     break;
-                  default:
-                     gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                     return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineModeA;
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
          case GL_SOURCE0_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineSourceRGB[0];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+            }
+            break;
          case GL_SOURCE1_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineSourceRGB[1];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+            }
+            break;
          case GL_SOURCE2_RGB_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               GLenum source = (GLenum) (GLint) *param;
-               GLuint s = pname - GL_SOURCE0_RGB_EXT;
-               switch (source) {
-                  case GL_TEXTURE:
-                  case GL_CONSTANT_EXT:
-                  case GL_PRIMARY_COLOR_EXT:
-                  case GL_PREVIOUS_EXT:
-                     if (texUnit->CombineSourceRGB[s] == source)
-                        return;  /* no change */
-                     texUnit->CombineSourceRGB[s] = source;
-                     ctx->NewState |= NEW_TEXTURE_ENV;
-                     break;
-                  default:
-                     gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                     return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineSourceRGB[2];
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
          case GL_SOURCE0_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineSourceA[0];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+            }
+            break;
          case GL_SOURCE1_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineSourceA[1];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+            }
+            break;
          case GL_SOURCE2_ALPHA_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               GLenum source = (GLenum) (GLint) *param;
-               GLuint s = pname - GL_SOURCE0_ALPHA_EXT;
-               switch (source) {
-                  case GL_TEXTURE:
-                  case GL_CONSTANT_EXT:
-                  case GL_PRIMARY_COLOR_EXT:
-                  case GL_PREVIOUS_EXT:
-                     if (texUnit->CombineSourceA[s] == source) return;
-                     texUnit->CombineSourceA[s] = source;
-                     ctx->NewState |= NEW_TEXTURE_ENV;
-                     break;
-                  default:
-                     gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                     return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineSourceA[2];
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
          case GL_OPERAND0_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineOperandRGB[0];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+            }
+            break;
          case GL_OPERAND1_RGB_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               GLenum operand = (GLenum) (GLint) *param;
-               GLuint s = pname - GL_OPERAND0_RGB_EXT;
-               switch (operand) {
-                  case GL_SRC_COLOR:
-                  case GL_ONE_MINUS_SRC_COLOR:
-                  case GL_SRC_ALPHA:
-                  case GL_ONE_MINUS_SRC_ALPHA:
-                     texUnit->CombineOperandRGB[s] = operand;
-                     ctx->NewState |= NEW_TEXTURE_ENV;
-                     break;
-                  default:
-                     gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                     return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineOperandRGB[1];
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
+         case GL_OPERAND2_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineOperandRGB[2];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+            }
+            break;
          case GL_OPERAND0_ALPHA_EXT:
-         case GL_OPERAND1_ALPHA_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               GLenum operand = (GLenum) (GLint) *param;
-               switch (operand) {
-                  case GL_SRC_ALPHA:
-                  case GL_ONE_MINUS_SRC_ALPHA:
-                     texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT]
-                        = operand;
-                     ctx->NewState |= NEW_TEXTURE_ENV;
-                     break;
-                  default:
-                     gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                     return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineOperandA[0];
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
-         case GL_OPERAND2_RGB_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               if ((GLenum) (GLint) *param == GL_SRC_ALPHA) {
-                  texUnit->CombineOperandRGB[2] = (GLenum) (GLint) *param;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else {
-                  gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                  return;
-               }
+         case GL_OPERAND1_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineOperandA[1];
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
          case GL_OPERAND2_ALPHA_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               if ((GLenum) (GLint) *param == GL_SRC_ALPHA) {
-                  texUnit->CombineOperandA[2] = (GLenum) (GLint) *param;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else {
-                  gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
-                  return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLfloat) texUnit->CombineOperandA[2];
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
-               return;
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
             }
             break;
          case GL_RGB_SCALE_EXT:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               if (*param == 1.0) {
-                  texUnit->CombineScaleShiftRGB = 0;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else if (*param == 2.0) {
-                  texUnit->CombineScaleShiftRGB = 1;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else if (*param == 4.0) {
-                  texUnit->CombineScaleShiftRGB = 2;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else {
-                  gl_error( ctx, GL_INVALID_VALUE, "glTexEnv(param)" );
-                  return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               if (texUnit->CombineScaleShiftRGB == 0)
+                  *params = 1.0;
+               else if (texUnit->CombineScaleShiftRGB == 1)
+                  *params = 2.0;
+               else
+                  *params = 4.0;
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
                return;
             }
             break;
          case GL_ALPHA_SCALE:
-            if (ctx->Extensions.HaveTextureEnvCombine) {
-               if (*param == 1.0) {
-                  texUnit->CombineScaleShiftA = 0;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else if (*param == 2.0) {
-                  texUnit->CombineScaleShiftA = 1;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else if (*param == 4.0) {
-                  texUnit->CombineScaleShiftA = 2;
-                  ctx->NewState |= NEW_TEXTURE_ENV;
-               }
-               else {
-                  gl_error( ctx, GL_INVALID_VALUE, "glTexEnv(param)" );
-                  return;
-               }
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               if (texUnit->CombineScaleShiftA == 0)
+                  *params = 1.0;
+               else if (texUnit->CombineScaleShiftA == 1)
+                  *params = 2.0;
+               else
+                  *params = 4.0;
             }
             else {
-               gl_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
                return;
             }
             break;
          default:
-            gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
-            return;
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
       }
    }
-   else if (target==GL_TEXTURE_FILTER_CONTROL_EXT) {
-      if (!ctx->Extensions.HaveTextureLodBias) {
-	 gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
+   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
+      /* GL_EXT_texture_lod_bias */
+      if (!ctx->Extensions.EXT_texture_lod_bias) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
 	 return;
       }
       if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
-	 texUnit->LodBias = param[0];
+         *params = texUnit->LodBias;
       }
       else {
-	 gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
 	 return;
       }
    }
    else {
-      gl_error( ctx, GL_INVALID_ENUM, "glTexEnv(target)" );
-      return;
-   }
-
-   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
-      fprintf(stderr, "glTexEnv %s %s %.1f(%s) ...\n",
-	      gl_lookup_enum_by_nr(target),
-	      gl_lookup_enum_by_nr(pname),
-	      *param,
-	      gl_lookup_enum_by_nr((GLenum) (GLint) *param));
-
-   /* Tell device driver about the new texture environment */
-   if (ctx->Driver.TexEnv) {
-      (*ctx->Driver.TexEnv)( ctx, target, pname, param );
-   }
-
-}
-
-
-void
-_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
-{
-   _mesa_TexEnvfv( target, pname, &param );
-}
-
-
-
-void
-_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
-{
-   GLfloat p[4];
-   p[0] = (GLfloat) param;
-   p[1] = p[2] = p[3] = 0.0;
-   _mesa_TexEnvfv( target, pname, p );
-}
-
-
-void
-_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
-{
-   GLfloat p[4];
-   p[0] = INT_TO_FLOAT( param[0] );
-   p[1] = INT_TO_FLOAT( param[1] );
-   p[2] = INT_TO_FLOAT( param[2] );
-   p[3] = INT_TO_FLOAT( param[3] );
-   _mesa_TexEnvfv( target, pname, p );
-}
-
-
-void
-_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexEnvfv");
-
-   if (target!=GL_TEXTURE_ENV) {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
       return;
    }
-
-   switch (pname) {
-      case GL_TEXTURE_ENV_MODE:
-         *params = ENUM_TO_FLOAT(texUnit->EnvMode);
-	 break;
-      case GL_TEXTURE_ENV_COLOR:
-	 COPY_4FV( params, texUnit->EnvColor );
-	 break;
-      case GL_RGB_SCALE_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            if (texUnit->CombineScaleShiftRGB == 0)
-               *params = 1.0;
-            else if (texUnit->CombineScaleShiftRGB == 1)
-               *params = 2.0;
-            else
-               *params = 4.0;
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            return;
-         }
-         break;
-      case GL_ALPHA_SCALE:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            if (texUnit->CombineScaleShiftA == 0)
-               *params = 1.0;
-            else if (texUnit->CombineScaleShiftA == 1)
-               *params = 2.0;
-            else
-               *params = 4.0;
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            return;
-         }
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
-   }
 }
 
 
@@ -466,139 +748,202 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexEnviv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (target != GL_TEXTURE_ENV) {
-      gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
       return;
    }
 
-   switch (pname) {
-      case GL_TEXTURE_ENV_MODE:
-         *params = (GLint) texUnit->EnvMode;
-	 break;
-      case GL_TEXTURE_ENV_COLOR:
-	 params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
-	 params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
-	 params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
-	 params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
-         break;
-      case GL_COMBINE_RGB_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineModeRGB;
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_COMBINE_ALPHA_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineModeA;
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_SOURCE0_RGB_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineSourceRGB[0];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_SOURCE1_RGB_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineSourceRGB[1];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_SOURCE2_RGB_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineSourceRGB[2];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_SOURCE0_ALPHA_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineSourceA[0];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_SOURCE1_ALPHA_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineSourceA[1];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_SOURCE2_ALPHA_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineSourceA[2];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_OPERAND0_RGB_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineOperandRGB[0];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_OPERAND1_RGB_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineOperandRGB[1];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_OPERAND2_RGB_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineOperandRGB[2];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_OPERAND0_ALPHA_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineOperandA[0];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_OPERAND1_ALPHA_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineOperandA[1];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-         break;
-      case GL_OPERAND2_ALPHA_EXT:
-         if (ctx->Extensions.HaveTextureEnvCombine) {
-            *params = (GLint) texUnit->CombineOperandA[2];
-         }
-         else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-         }
-	 break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
+   if (target == GL_TEXTURE_ENV) {
+      switch (pname) {
+         case GL_TEXTURE_ENV_MODE:
+            *params = (GLint) texUnit->EnvMode;
+            break;
+         case GL_TEXTURE_ENV_COLOR:
+            params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
+            params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
+            params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
+            params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
+            break;
+         case GL_COMBINE_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineModeRGB;
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_COMBINE_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineModeA;
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_SOURCE0_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineSourceRGB[0];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_SOURCE1_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineSourceRGB[1];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_SOURCE2_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineSourceRGB[2];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_SOURCE0_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineSourceA[0];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_SOURCE1_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineSourceA[1];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_SOURCE2_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineSourceA[2];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_OPERAND0_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineOperandRGB[0];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_OPERAND1_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineOperandRGB[1];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_OPERAND2_RGB_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineOperandRGB[2];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_OPERAND0_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineOperandA[0];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_OPERAND1_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineOperandA[1];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_OPERAND2_ALPHA_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               *params = (GLint) texUnit->CombineOperandA[2];
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+            }
+            break;
+         case GL_RGB_SCALE_EXT:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               if (texUnit->CombineScaleShiftRGB == 0)
+                  *params = 1;
+               else if (texUnit->CombineScaleShiftRGB == 1)
+                  *params = 2;
+               else
+                  *params = 4;
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+               return;
+            }
+            break;
+         case GL_ALPHA_SCALE:
+            if (ctx->Extensions.EXT_texture_env_combine ||
+                ctx->Extensions.ARB_texture_env_combine) {
+               if (texUnit->CombineScaleShiftA == 0)
+                  *params = 1;
+               else if (texUnit->CombineScaleShiftA == 1)
+                  *params = 2;
+               else
+                  *params = 4;
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
+               return;
+            }
+            break;
+         default:
+            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
+      }
+   }
+   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
+      /* GL_EXT_texture_lod_bias */
+      if (!ctx->Extensions.EXT_texture_lod_bias) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
+	 return;
+      }
+      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
+         *params = (GLint) texUnit->LodBias;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
+	 return;
+      }
    }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
+      return;
+   }
 }
 
 
@@ -623,34 +968,41 @@
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    GLenum eparam = (GLenum) (GLint) params[0];
    struct gl_texture_object *texObj;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexParameterfv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
       fprintf(stderr, "texPARAM %s %s %d...\n",
-	      gl_lookup_enum_by_nr(target),
-	      gl_lookup_enum_by_nr(pname),
+	      _mesa_lookup_enum_by_nr(target),
+	      _mesa_lookup_enum_by_nr(pname),
 	      eparam);
 
 
    switch (target) {
       case GL_TEXTURE_1D:
-         texObj = texUnit->CurrentD[1];
+         texObj = texUnit->Current1D;
          break;
       case GL_TEXTURE_2D:
-         texObj = texUnit->CurrentD[2];
+         texObj = texUnit->Current2D;
          break;
       case GL_TEXTURE_3D_EXT:
-         texObj = texUnit->CurrentD[3];
+         texObj = texUnit->Current3D;
          break;
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.HaveTextureCubeMap) {
-            texObj = texUnit->CurrentCubeMap;
-            break;
+         if (!ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
+            return;
+         }
+         texObj = texUnit->CurrentCubeMap;
+         break;
+      case GL_TEXTURE_RECTANGLE_NV:
+         if (!ctx->Extensions.NV_texture_rectangle) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
+            return;
          }
-         /* fallthrough */
+         texObj = texUnit->CurrentRect;
+         break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
          return;
    }
 
@@ -660,16 +1012,20 @@
          if (texObj->MinFilter == eparam)
             return;
 
-         if (eparam==GL_NEAREST || eparam==GL_LINEAR
-             || eparam==GL_NEAREST_MIPMAP_NEAREST
-             || eparam==GL_LINEAR_MIPMAP_NEAREST
-             || eparam==GL_NEAREST_MIPMAP_LINEAR
-             || eparam==GL_LINEAR_MIPMAP_LINEAR) {
+         if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texObj->MinFilter = eparam;
+         }
+         else if ((eparam==GL_NEAREST_MIPMAP_NEAREST ||
+                   eparam==GL_LINEAR_MIPMAP_NEAREST ||
+                   eparam==GL_NEAREST_MIPMAP_LINEAR ||
+                   eparam==GL_LINEAR_MIPMAP_LINEAR) &&
+                  texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
             texObj->MinFilter = eparam;
-            ctx->NewState |= NEW_TEXTURING;
          }
          else {
-            gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
             return;
          }
          break;
@@ -679,92 +1035,202 @@
             return;
 
          if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
             texObj->MagFilter = eparam;
-            ctx->NewState |= NEW_TEXTURING;
          }
          else {
-            gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
             return;
          }
          break;
       case GL_TEXTURE_WRAP_S:
          if (texObj->WrapS == eparam)
             return;
-
-         if (eparam==GL_CLAMP || eparam==GL_REPEAT || eparam==GL_CLAMP_TO_EDGE) {
+         if (eparam == GL_CLAMP || eparam == GL_CLAMP_TO_EDGE ||
+             (eparam == GL_CLAMP_TO_BORDER_ARB &&
+              ctx->Extensions.ARB_texture_border_clamp)) {
+            /* any texture target */
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texObj->WrapS = eparam;
+         }
+         else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
+                  (eparam == GL_REPEAT ||
+                   (eparam == GL_MIRRORED_REPEAT_ARB &&
+                    ctx->Extensions.ARB_texture_mirrored_repeat))) {
+            /* non-rectangle texture */
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
             texObj->WrapS = eparam;
-            ctx->NewState |= NEW_TEXTURING;
          }
          else {
-            gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
             return;
          }
          break;
       case GL_TEXTURE_WRAP_T:
          if (texObj->WrapT == eparam)
             return;
-
-         if (eparam==GL_CLAMP || eparam==GL_REPEAT || eparam==GL_CLAMP_TO_EDGE) {
+         if (eparam == GL_CLAMP || eparam == GL_CLAMP_TO_EDGE ||
+             (eparam == GL_CLAMP_TO_BORDER_ARB &&
+              ctx->Extensions.ARB_texture_border_clamp)) {
+            /* any texture target */
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texObj->WrapT = eparam;
+         }
+         else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
+                  (eparam == GL_REPEAT ||
+                   (eparam == GL_MIRRORED_REPEAT_ARB &&
+                    ctx->Extensions.ARB_texture_mirrored_repeat))) {
+            /* non-rectangle texture */
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
             texObj->WrapT = eparam;
-            ctx->NewState |= NEW_TEXTURING;
          }
          else {
-            gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
             return;
          }
          break;
       case GL_TEXTURE_WRAP_R_EXT:
          if (texObj->WrapR == eparam)
             return;
-
-         if (eparam==GL_CLAMP || eparam==GL_REPEAT || eparam==GL_CLAMP_TO_EDGE) {
+         if (eparam == GL_CLAMP || eparam == GL_CLAMP_TO_EDGE ||
+             (eparam == GL_CLAMP_TO_BORDER_ARB &&
+              ctx->Extensions.ARB_texture_border_clamp)) {
+            /* any texture target */
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
             texObj->WrapR = eparam;
-            ctx->NewState |= NEW_TEXTURING;
          }
+         else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
+                  (eparam == GL_REPEAT ||
+                   (eparam == GL_MIRRORED_REPEAT_ARB &&
+                    ctx->Extensions.ARB_texture_mirrored_repeat))) {
+            /* non-rectangle texture */
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texObj->WrapR = eparam;
+         }
          else {
-            gl_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
          }
          break;
       case GL_TEXTURE_BORDER_COLOR:
-         texObj->BorderColor[0] = (GLubyte) CLAMP((GLint)(params[0]*255.0), 0, 255);
-         texObj->BorderColor[1] = (GLubyte) CLAMP((GLint)(params[1]*255.0), 0, 255);
-         texObj->BorderColor[2] = (GLubyte) CLAMP((GLint)(params[2]*255.0), 0, 255);
-         texObj->BorderColor[3] = (GLubyte) CLAMP((GLint)(params[3]*255.0), 0, 255);
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[0], params[0]);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[1], params[1]);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[2], params[2]);
+         UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[3], params[3]);
          break;
       case GL_TEXTURE_MIN_LOD:
+         if (texObj->MinLod == params[0])
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
          texObj->MinLod = params[0];
-         ctx->NewState |= NEW_TEXTURING;
          break;
       case GL_TEXTURE_MAX_LOD:
+         if (texObj->MaxLod == params[0])
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
          texObj->MaxLod = params[0];
-         ctx->NewState |= NEW_TEXTURING;
          break;
       case GL_TEXTURE_BASE_LEVEL:
          if (params[0] < 0.0) {
-            gl_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
             return;
          }
+         if (target == GL_TEXTURE_RECTANGLE_NV && params[0] != 0.0) {
+            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            return;
+         }
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
          texObj->BaseLevel = (GLint) params[0];
-         ctx->NewState |= NEW_TEXTURING;
          break;
       case GL_TEXTURE_MAX_LEVEL:
          if (params[0] < 0.0) {
-            gl_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
             return;
          }
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
          texObj->MaxLevel = (GLint) params[0];
-         ctx->NewState |= NEW_TEXTURING;
          break;
       case GL_TEXTURE_PRIORITY:
          /* (keithh@netcomuk.co.uk) */
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
          texObj->Priority = CLAMP( params[0], 0.0F, 1.0F );
          break;
+      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+	    if (params[0] < 1.0) {
+	       _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+	       return;
+	    }
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texObj->MaxAnisotropy = params[0];
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glTexParameter(pname=GL_MAX_TEXTURE_ANISOTROPY_EXT)");
+            return;
+         }
+         break;
+      case GL_TEXTURE_COMPARE_SGIX:
+         if (ctx->Extensions.SGIX_shadow) {
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texObj->CompareFlag = params[0] ? GL_TRUE : GL_FALSE;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glTexParameter(pname=GL_TEXTURE_COMPARE_SGIX)");
+            return;
+         }
+         break;
+      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+         if (ctx->Extensions.SGIX_shadow) {
+            GLenum op = (GLenum) params[0];
+            if (op == GL_TEXTURE_LEQUAL_R_SGIX ||
+                op == GL_TEXTURE_GEQUAL_R_SGIX) {
+               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+               texObj->CompareOperator = op;
+            }
+            else {
+               _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param)");
+            }
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                    "glTexParameter(pname=GL_TEXTURE_COMPARE_OPERATOR_SGIX)");
+            return;
+         }
+         break;
+      case GL_SHADOW_AMBIENT_SGIX:
+         if (ctx->Extensions.SGIX_shadow_ambient) {
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            UNCLAMPED_FLOAT_TO_CHAN(texObj->ShadowAmbient, params[0]);
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glTexParameter(pname=GL_SHADOW_AMBIENT_SGIX)");
+            return;
+         }
+         break;
+      case GL_GENERATE_MIPMAP_SGIS:
+         if (ctx->Extensions.SGIS_generate_mipmap) {
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_ENUM,
+                        "glTexParameter(pname=GL_GENERATE_MIPMAP_SGIS)");
+            return;
+         }
+         break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glTexParameter(pname)" );
+         {
+            char s[100];
+            sprintf(s, "glTexParameter(pname=0x%x)", pname);
+            _mesa_error( ctx, GL_INVALID_ENUM, s);
+         }
          return;
    }
 
-   gl_put_texobj_on_dirty_list( ctx, texObj );
+   texObj->Complete = GL_FALSE;
 
    if (ctx->Driver.TexParameter) {
       (*ctx->Driver.TexParameter)( ctx, target, texObj, pname, params );
@@ -816,9 +1282,18 @@
          return 3;
       case GL_TEXTURE_CUBE_MAP_ARB:
       case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-         return ctx->Extensions.HaveTextureCubeMap ? 2 : 0;
+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
+         return ctx->Extensions.ARB_texture_cube_map ? 2 : 0;
+      case GL_TEXTURE_RECTANGLE_NV:
+      case GL_PROXY_TEXTURE_RECTANGLE_NV:
+         return ctx->Extensions.NV_texture_rectangle ? 2 : 0;
       default:
-         gl_problem(ctx, "bad target in _mesa_tex_target_dimensions()");
+         _mesa_problem(ctx, "bad target in _mesa_tex_target_dimensions()");
          return 0;
    }
 }
@@ -833,22 +1308,52 @@
    const struct gl_texture_image *img = NULL;
    GLuint dimensions;
    GLboolean isProxy;
+   GLint maxLevels;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexLevelParameter");
-
-   if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
-      gl_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
+   dimensions = tex_image_dimensions(ctx, target);  /* 1, 2 or 3 */
+   if (dimensions == 0) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
       return;
    }
 
-   dimensions = tex_image_dimensions(ctx, target);  /* 1, 2 or 3 */
-   if (dimensions == 0) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
+   switch (target) {
+   case GL_TEXTURE_1D:
+   case GL_PROXY_TEXTURE_1D:
+   case GL_TEXTURE_2D:
+   case GL_PROXY_TEXTURE_2D:
+      maxLevels = ctx->Const.MaxTextureLevels;
+      break;
+   case GL_TEXTURE_3D:
+   case GL_PROXY_TEXTURE_3D:
+      maxLevels = ctx->Const.Max3DTextureLevels;
+      break;
+   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
+   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
+   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
+   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
+      maxLevels = ctx->Const.MaxCubeTextureLevels;
+      break;
+   case GL_TEXTURE_RECTANGLE_NV:
+   case GL_PROXY_TEXTURE_RECTANGLE_NV:
+      maxLevels = 1;
+      break;
+   default:
+      maxLevels = ctx->Const.MaxCubeTextureLevels;
+      break;
+   }
+
+   if (level < 0 || level >= maxLevels) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
       return;
    }
 
    img = _mesa_select_tex_image(ctx, texUnit, target, level);
-   if (!img) {
+   if (!img || !img->TexFormat) {
+      /* undefined texture image */
       if (pname == GL_TEXTURE_COMPONENTS)
          *params = 1;
       else
@@ -859,31 +1364,20 @@
    isProxy = (target == GL_PROXY_TEXTURE_1D) ||
              (target == GL_PROXY_TEXTURE_2D) ||
              (target == GL_PROXY_TEXTURE_3D) ||
-             (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB);
+             (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) ||
+             (target == GL_PROXY_TEXTURE_RECTANGLE_NV);
 
    switch (pname) {
       case GL_TEXTURE_WIDTH:
          *params = img->Width;
          return;
       case GL_TEXTURE_HEIGHT:
-         if (dimensions > 1) {
-            *params = img->Height;
-         }
-         else {
-            gl_error( ctx, GL_INVALID_ENUM,
-                      "glGetTexLevelParameter[if]v(pname=GL_TEXTURE_HEIGHT)" );
-         }
+         *params = img->Height;
          return;
       case GL_TEXTURE_DEPTH:
-         if (dimensions > 2) {
-            *params = img->Depth;
-         }
-         else {
-            gl_error( ctx, GL_INVALID_ENUM,
-                      "glGetTexLevelParameter[if]v(pname=GL_TEXTURE_DEPTH)" );
-         }
+         *params = img->Depth;
          return;
-      case GL_TEXTURE_COMPONENTS:
+      case GL_TEXTURE_INTERNAL_FORMAT:
          *params = img->IntFormat;
          return;
       case GL_TEXTURE_BORDER:
@@ -926,39 +1420,51 @@
          if (img->Format != GL_LUMINANCE &&
              img->Format != GL_LUMINANCE_ALPHA)
             *params = 0;
-         else if (img->TexFormat->LuminanceBits)
+         else if (img->TexFormat->LuminanceBits > 0)
             *params = img->TexFormat->LuminanceBits;
          else /* luminance probably stored as rgb texture */
-            *params = img->TexFormat->RedBits;
+            *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
          return;
       case GL_TEXTURE_INDEX_SIZE_EXT:
-         *params = img->TexFormat->IndexBits;
+         if (img->Format == GL_COLOR_INDEX)
+            *params = img->TexFormat->IndexBits;
+         else
+            *params = 0;
          return;
+      case GL_DEPTH_BITS:
+         /* XXX this isn't in the GL_SGIX_depth_texture spec
+          * but seems appropriate.
+          */
+         if (ctx->Extensions.SGIX_depth_texture)
+            *params = img->TexFormat->DepthBits;
+         else
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
+         return;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             if (img->IsCompressed && !isProxy)
                *params = img->CompressedSize;
             else
-               gl_error(ctx, GL_INVALID_OPERATION,
+               _mesa_error(ctx, GL_INVALID_OPERATION,
                         "glGetTexLevelParameter[if]v(pname)");
          }
          else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
          }
          return;
       case GL_TEXTURE_COMPRESSED_ARB:
-         if (ctx->Extensions.HaveTextureCompression) {
+         if (ctx->Extensions.ARB_texture_compression) {
             *params = (GLint) img->IsCompressed;
          }
          else {
-            gl_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
          }
          return;
 
       default:
-         gl_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
    }
 }
 
@@ -970,37 +1476,36 @@
    GET_CURRENT_CONTEXT(ctx);
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    struct gl_texture_object *obj;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexParameterfv");
-
    obj = _mesa_select_tex_object(ctx, texUnit, target);
    if (!obj) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
       return;
    }
 
    switch (pname) {
       case GL_TEXTURE_MAG_FILTER:
 	 *params = ENUM_TO_FLOAT(obj->MagFilter);
-	 break;
+	 return;
       case GL_TEXTURE_MIN_FILTER:
          *params = ENUM_TO_FLOAT(obj->MinFilter);
-         break;
+         return;
       case GL_TEXTURE_WRAP_S:
          *params = ENUM_TO_FLOAT(obj->WrapS);
-         break;
+         return;
       case GL_TEXTURE_WRAP_T:
          *params = ENUM_TO_FLOAT(obj->WrapT);
-         break;
+         return;
       case GL_TEXTURE_WRAP_R_EXT:
          *params = ENUM_TO_FLOAT(obj->WrapR);
-         break;
+         return;
       case GL_TEXTURE_BORDER_COLOR:
-         params[0] = obj->BorderColor[0] / 255.0F;
-         params[1] = obj->BorderColor[1] / 255.0F;
-         params[2] = obj->BorderColor[2] / 255.0F;
-         params[3] = obj->BorderColor[3] / 255.0F;
-         break;
+         params[0] = obj->BorderColor[0] / CHAN_MAXF;
+         params[1] = obj->BorderColor[1] / CHAN_MAXF;
+         params[2] = obj->BorderColor[2] / CHAN_MAXF;
+         params[3] = obj->BorderColor[3] / CHAN_MAXF;
+         return;
       case GL_TEXTURE_RESIDENT:
          {
             GLboolean resident;
@@ -1010,25 +1515,57 @@
                resident = GL_TRUE;
             *params = ENUM_TO_FLOAT(resident);
          }
-         break;
+         return;
       case GL_TEXTURE_PRIORITY:
          *params = obj->Priority;
-         break;
+         return;
       case GL_TEXTURE_MIN_LOD:
          *params = obj->MinLod;
-         break;
+         return;
       case GL_TEXTURE_MAX_LOD:
          *params = obj->MaxLod;
-         break;
+         return;
       case GL_TEXTURE_BASE_LEVEL:
          *params = (GLfloat) obj->BaseLevel;
-         break;
+         return;
       case GL_TEXTURE_MAX_LEVEL:
          *params = (GLfloat) obj->MaxLevel;
+         return;
+      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+            *params = obj->MaxAnisotropy;
+            return;
+         }
+         break;
+      case GL_TEXTURE_COMPARE_SGIX:
+         if (ctx->Extensions.SGIX_shadow) {
+            *params = (GLfloat) obj->CompareFlag;
+            return;
+         }
+         break;
+      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+         if (ctx->Extensions.SGIX_shadow) {
+            *params = (GLfloat) obj->CompareOperator;
+            return;
+         }
+         break;
+      case GL_SHADOW_AMBIENT_SGIX:
+         if (ctx->Extensions.SGIX_shadow_ambient) {
+            *params = CHAN_TO_FLOAT(obj->ShadowAmbient);
+            return;
+         }
+         break;
+      case GL_GENERATE_MIPMAP_SGIS:
+         if (ctx->Extensions.SGIS_generate_mipmap) {
+            *params = (GLfloat) obj->GenerateMipmap;
+            return;
+         }
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname)" );
+         ; /* silence warnings */
    }
+   /* If we get here, pname was an unrecognized enum */
+   _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname)" );
 }
 
 
@@ -1038,44 +1575,43 @@
    GET_CURRENT_CONTEXT(ctx);
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
    struct gl_texture_object *obj;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexParameteriv");
-
    obj = _mesa_select_tex_object(ctx, texUnit, target);
    if (!obj) {
-      gl_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
       return;
    }
 
    switch (pname) {
       case GL_TEXTURE_MAG_FILTER:
          *params = (GLint) obj->MagFilter;
-         break;
+         return;
       case GL_TEXTURE_MIN_FILTER:
          *params = (GLint) obj->MinFilter;
-         break;
+         return;
       case GL_TEXTURE_WRAP_S:
          *params = (GLint) obj->WrapS;
-         break;
+         return;
       case GL_TEXTURE_WRAP_T:
          *params = (GLint) obj->WrapT;
-         break;
+         return;
       case GL_TEXTURE_WRAP_R_EXT:
          *params = (GLint) obj->WrapR;
-         break;
+         return;
       case GL_TEXTURE_BORDER_COLOR:
          {
             GLfloat color[4];
-            color[0] = obj->BorderColor[0] / 255.0F;
-            color[1] = obj->BorderColor[1] / 255.0F;
-            color[2] = obj->BorderColor[2] / 255.0F;
-            color[3] = obj->BorderColor[3] / 255.0F;
+            color[0] = obj->BorderColor[0] / CHAN_MAXF;
+            color[1] = obj->BorderColor[1] / CHAN_MAXF;
+            color[2] = obj->BorderColor[2] / CHAN_MAXF;
+            color[3] = obj->BorderColor[3] / CHAN_MAXF;
             params[0] = FLOAT_TO_INT( color[0] );
             params[1] = FLOAT_TO_INT( color[1] );
             params[2] = FLOAT_TO_INT( color[2] );
             params[3] = FLOAT_TO_INT( color[3] );
          }
-         break;
+         return;
       case GL_TEXTURE_RESIDENT:
          {
             GLboolean resident;
@@ -1085,25 +1621,58 @@
                resident = GL_TRUE;
             *params = (GLint) resident;
          }
-         break;
+         return;
       case GL_TEXTURE_PRIORITY:
          *params = (GLint) obj->Priority;
-         break;
+         return;
       case GL_TEXTURE_MIN_LOD:
          *params = (GLint) obj->MinLod;
-         break;
+         return;
       case GL_TEXTURE_MAX_LOD:
          *params = (GLint) obj->MaxLod;
-         break;
+         return;
       case GL_TEXTURE_BASE_LEVEL:
          *params = obj->BaseLevel;
-         break;
+         return;
       case GL_TEXTURE_MAX_LEVEL:
          *params = obj->MaxLevel;
+         return;
+      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+            *params = (GLint) obj->MaxAnisotropy;
+            return;
+         }
+         break;
+      case GL_TEXTURE_COMPARE_SGIX:
+         if (ctx->Extensions.SGIX_shadow) {
+            *params = (GLint) obj->CompareFlag;
+            return;
+         }
+         break;
+      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+         if (ctx->Extensions.SGIX_shadow) {
+            *params = (GLint) obj->CompareOperator;
+            return;
+         }
+         break;
+      case GL_SHADOW_AMBIENT_SGIX:
+         if (ctx->Extensions.SGIX_shadow_ambient) {
+            /* XXX range? */
+            *params = (GLint) CHAN_TO_FLOAT(obj->ShadowAmbient);
+            return;
+         }
+         break;
+      case GL_GENERATE_MIPMAP_SGIS:
+         if (ctx->Extensions.SGIS_generate_mipmap) {
+            *params = (GLint) obj->GenerateMipmap;
+            return;
+         }
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
+         ; /* silence warnings */
    }
+   /* If we get here, pname was an unrecognized enum */
+   _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
 }
 
 
@@ -1118,199 +1687,237 @@
 _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
+   GLuint tUnit = ctx->Texture.CurrentUnit;
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glTexGenfv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
       fprintf(stderr, "texGEN %s %s %x...\n",
-	      gl_lookup_enum_by_nr(coord),
-	      gl_lookup_enum_by_nr(pname),
+	      _mesa_lookup_enum_by_nr(coord),
+	      _mesa_lookup_enum_by_nr(pname),
 	      *(int *)params);
 
    switch (coord) {
       case GL_S:
          if (pname==GL_TEXTURE_GEN_MODE) {
 	    GLenum mode = (GLenum) (GLint) *params;
+	    GLuint bits;
 	    switch (mode) {
 	    case GL_OBJECT_LINEAR:
-	       texUnit->GenModeS = mode;
-	       texUnit->GenBitS = TEXGEN_OBJ_LINEAR;
+	       bits = TEXGEN_OBJ_LINEAR;
 	       break;
 	    case GL_EYE_LINEAR:
-	       texUnit->GenModeS = mode;
-	       texUnit->GenBitS = TEXGEN_EYE_LINEAR;
+	       bits = TEXGEN_EYE_LINEAR;
 	       break;
 	    case GL_REFLECTION_MAP_NV:
-	       texUnit->GenModeS = mode;
-	       texUnit->GenBitS = TEXGEN_REFLECTION_MAP_NV;
+	       bits = TEXGEN_REFLECTION_MAP_NV;
 	       break;
 	    case GL_NORMAL_MAP_NV:
-	       texUnit->GenModeS = mode;
-	       texUnit->GenBitS = TEXGEN_NORMAL_MAP_NV;
+	       bits = TEXGEN_NORMAL_MAP_NV;
 	       break;
 	    case GL_SPHERE_MAP:
-	       texUnit->GenModeS = mode;
-	       texUnit->GenBitS = TEXGEN_SPHERE_MAP;
+	       bits = TEXGEN_SPHERE_MAP;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
 	       return;
 	    }
+	    if (texUnit->GenModeS == mode)
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->GenModeS = mode;
+	    texUnit->_GenBitS = bits;
 	 }
 	 else if (pname==GL_OBJECT_PLANE) {
+	    if (TEST_EQ_4V(texUnit->ObjectPlaneS, params))
+		return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 	    texUnit->ObjectPlaneS[0] = params[0];
 	    texUnit->ObjectPlaneS[1] = params[1];
 	    texUnit->ObjectPlaneS[2] = params[2];
 	    texUnit->ObjectPlaneS[3] = params[3];
 	 }
 	 else if (pname==GL_EYE_PLANE) {
+	    GLfloat tmp[4];
+
             /* Transform plane equation by the inverse modelview matrix */
             if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
-               gl_matrix_analyze( &ctx->ModelView );
+               _math_matrix_analyse( &ctx->ModelView );
             }
-            gl_transform_vector( texUnit->EyePlaneS, params,
-                                 ctx->ModelView.inv );
+            _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
+	    if (TEST_EQ_4V(texUnit->EyePlaneS, tmp))
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    COPY_4FV(texUnit->EyePlaneS, tmp);
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
       case GL_T:
          if (pname==GL_TEXTURE_GEN_MODE) {
 	    GLenum mode = (GLenum) (GLint) *params;
+	    GLuint bitt;
 	    switch (mode) {
                case GL_OBJECT_LINEAR:
-                  texUnit->GenModeT = GL_OBJECT_LINEAR;
-                  texUnit->GenBitT = TEXGEN_OBJ_LINEAR;
+                  bitt = TEXGEN_OBJ_LINEAR;
                   break;
                case GL_EYE_LINEAR:
-                  texUnit->GenModeT = GL_EYE_LINEAR;
-                  texUnit->GenBitT = TEXGEN_EYE_LINEAR;
+                  bitt = TEXGEN_EYE_LINEAR;
                   break;
                case GL_REFLECTION_MAP_NV:
-                  texUnit->GenModeT = GL_REFLECTION_MAP_NV;
-                  texUnit->GenBitT = TEXGEN_REFLECTION_MAP_NV;
+                  bitt = TEXGEN_REFLECTION_MAP_NV;
                   break;
                case GL_NORMAL_MAP_NV:
-                  texUnit->GenModeT = GL_NORMAL_MAP_NV;
-                  texUnit->GenBitT = TEXGEN_NORMAL_MAP_NV;
+                  bitt = TEXGEN_NORMAL_MAP_NV;
                   break;
                case GL_SPHERE_MAP:
-                  texUnit->GenModeT = GL_SPHERE_MAP;
-                  texUnit->GenBitT = TEXGEN_SPHERE_MAP;
+                  bitt = TEXGEN_SPHERE_MAP;
                   break;
                default:
-                  gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
+                  _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
                   return;
 	    }
+	    if (texUnit->GenModeT == mode)
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->GenModeT = mode;
+	    texUnit->_GenBitT = bitt;
 	 }
 	 else if (pname==GL_OBJECT_PLANE) {
+	    if (TEST_EQ_4V(texUnit->ObjectPlaneT, params))
+		return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 	    texUnit->ObjectPlaneT[0] = params[0];
 	    texUnit->ObjectPlaneT[1] = params[1];
 	    texUnit->ObjectPlaneT[2] = params[2];
 	    texUnit->ObjectPlaneT[3] = params[3];
 	 }
 	 else if (pname==GL_EYE_PLANE) {
+	    GLfloat tmp[4];
             /* Transform plane equation by the inverse modelview matrix */
-            if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
-               gl_matrix_analyze( &ctx->ModelView );
+	    if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
+               _math_matrix_analyse( &ctx->ModelView );
             }
-            gl_transform_vector( texUnit->EyePlaneT, params,
-                                 ctx->ModelView.inv );
+            _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
+	    if (TEST_EQ_4V(texUnit->EyePlaneT, tmp))
+		return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    COPY_4FV(texUnit->EyePlaneT, tmp);
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
       case GL_R:
          if (pname==GL_TEXTURE_GEN_MODE) {
 	    GLenum mode = (GLenum) (GLint) *params;
+	    GLuint bitr;
 	    switch (mode) {
 	    case GL_OBJECT_LINEAR:
-	       texUnit->GenModeR = GL_OBJECT_LINEAR;
-	       texUnit->GenBitR = TEXGEN_OBJ_LINEAR;
+	       bitr = TEXGEN_OBJ_LINEAR;
 	       break;
 	    case GL_REFLECTION_MAP_NV:
-	       texUnit->GenModeR = GL_REFLECTION_MAP_NV;
-	       texUnit->GenBitR = TEXGEN_REFLECTION_MAP_NV;
+	       bitr = TEXGEN_REFLECTION_MAP_NV;
 	       break;
 	    case GL_NORMAL_MAP_NV:
-	       texUnit->GenModeR = GL_NORMAL_MAP_NV;
-	       texUnit->GenBitR = TEXGEN_NORMAL_MAP_NV;
+	       bitr = TEXGEN_NORMAL_MAP_NV;
 	       break;
 	    case GL_EYE_LINEAR:
-	       texUnit->GenModeR = GL_EYE_LINEAR;
-	       texUnit->GenBitR = TEXGEN_EYE_LINEAR;
+	       bitr = TEXGEN_EYE_LINEAR;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
 	       return;
 	    }
+	    if (texUnit->GenModeR == mode)
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->GenModeR = mode;
+	    texUnit->_GenBitR = bitr;
 	 }
 	 else if (pname==GL_OBJECT_PLANE) {
+	    if (TEST_EQ_4V(texUnit->ObjectPlaneR, params))
+		return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 	    texUnit->ObjectPlaneR[0] = params[0];
 	    texUnit->ObjectPlaneR[1] = params[1];
 	    texUnit->ObjectPlaneR[2] = params[2];
 	    texUnit->ObjectPlaneR[3] = params[3];
 	 }
 	 else if (pname==GL_EYE_PLANE) {
+	    GLfloat tmp[4];
             /* Transform plane equation by the inverse modelview matrix */
             if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
-               gl_matrix_analyze( &ctx->ModelView );
+               _math_matrix_analyse( &ctx->ModelView );
             }
-            gl_transform_vector( texUnit->EyePlaneR, params,
-                                 ctx->ModelView.inv );
+            _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
+	    if (TEST_EQ_4V(texUnit->EyePlaneR, tmp))
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    COPY_4FV(texUnit->EyePlaneR, tmp);
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
       case GL_Q:
          if (pname==GL_TEXTURE_GEN_MODE) {
 	    GLenum mode = (GLenum) (GLint) *params;
+	    GLuint bitq;
 	    switch (mode) {
 	    case GL_OBJECT_LINEAR:
-	       texUnit->GenModeQ = GL_OBJECT_LINEAR;
-	       texUnit->GenBitQ = TEXGEN_OBJ_LINEAR;
+	       bitq = TEXGEN_OBJ_LINEAR;
 	       break;
 	    case GL_EYE_LINEAR:
-	       texUnit->GenModeQ = GL_EYE_LINEAR;
-	       texUnit->GenBitQ = TEXGEN_EYE_LINEAR;
+	       bitq = TEXGEN_EYE_LINEAR;
 	       break;
 	    default:
-	       gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
+	       _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
 	       return;
 	    }
+	    if (texUnit->GenModeQ == mode)
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->GenModeQ = mode;
+	    texUnit->_GenBitQ = bitq;
 	 }
 	 else if (pname==GL_OBJECT_PLANE) {
+	    if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params))
+		return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 	    texUnit->ObjectPlaneQ[0] = params[0];
 	    texUnit->ObjectPlaneQ[1] = params[1];
 	    texUnit->ObjectPlaneQ[2] = params[2];
 	    texUnit->ObjectPlaneQ[3] = params[3];
 	 }
 	 else if (pname==GL_EYE_PLANE) {
+	    GLfloat tmp[4];
             /* Transform plane equation by the inverse modelview matrix */
             if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
-               gl_matrix_analyze( &ctx->ModelView );
+               _math_matrix_analyse( &ctx->ModelView );
             }
-            gl_transform_vector( texUnit->EyePlaneQ, params,
-                                 ctx->ModelView.inv );
+            _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
+	    if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp))
+	       return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    COPY_4FV(texUnit->EyePlaneQ, tmp);
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
 	 return;
    }
 
-   ctx->NewState |= NEW_TEXTURING;
+   if (ctx->Driver.TexGen)
+      ctx->Driver.TexGen( ctx, coord, pname, params );
 }
 
 
@@ -1318,10 +1925,10 @@
 _mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
 {
    GLfloat p[4];
-   p[0] = params[0];
-   p[1] = params[1];
-   p[2] = params[2];
-   p[3] = params[3];
+   p[0] = (GLfloat) params[0];
+   p[1] = (GLfloat) params[1];
+   p[2] = (GLfloat) params[2];
+   p[3] = (GLfloat) params[3];
    _mesa_TexGenfv(coord, pname, p);
 }
 
@@ -1338,10 +1945,10 @@
 _mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
 {
    GLfloat p[4];
-   p[0] = params[0];
-   p[1] = params[1];
-   p[2] = params[2];
-   p[3] = params[3];
+   p[0] = (GLfloat) params[0];
+   p[1] = (GLfloat) params[1];
+   p[2] = (GLfloat) params[2];
+   p[3] = (GLfloat) params[3];
    _mesa_TexGenfv( coord, pname, p );
 }
 
@@ -1365,10 +1972,9 @@
 _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
+   GLuint tUnit = ctx->Texture.CurrentUnit;
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexGendv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (coord) {
       case GL_S:
@@ -1382,7 +1988,7 @@
             COPY_4V( params, texUnit->EyePlaneS );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1397,7 +2003,7 @@
             COPY_4V( params, texUnit->EyePlaneT );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1412,7 +2018,7 @@
             COPY_4V( params, texUnit->EyePlaneR );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1427,12 +2033,12 @@
             COPY_4V( params, texUnit->EyePlaneQ );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
 	    return;
 	 }
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
 	 return;
    }
 }
@@ -1443,11 +2049,10 @@
 _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
+   GLuint tUnit = ctx->Texture.CurrentUnit;
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexGenfv");
-
    switch (coord) {
       case GL_S:
          if (pname==GL_TEXTURE_GEN_MODE) {
@@ -1460,7 +2065,7 @@
             COPY_4V( params, texUnit->EyePlaneS );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1475,7 +2080,7 @@
             COPY_4V( params, texUnit->EyePlaneT );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1490,7 +2095,7 @@
             COPY_4V( params, texUnit->EyePlaneR );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1505,12 +2110,12 @@
             COPY_4V( params, texUnit->EyePlaneQ );
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
 	    return;
 	 }
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
 	 return;
    }
 }
@@ -1521,10 +2126,9 @@
 _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLuint tUnit = ctx->Texture.CurrentTransformUnit;
+   GLuint tUnit = ctx->Texture.CurrentUnit;
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGetTexGeniv");
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    switch (coord) {
       case GL_S:
@@ -1544,7 +2148,7 @@
             params[3] = (GLint) texUnit->EyePlaneS[3];
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1565,7 +2169,7 @@
             params[3] = (GLint) texUnit->EyePlaneT[3];
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1586,7 +2190,7 @@
             params[3] = (GLint) texUnit->EyePlaneR[3];
 	 }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 	    return;
 	 }
 	 break;
@@ -1607,12 +2211,12 @@
             params[3] = (GLint) texUnit->EyePlaneQ[3];
          }
 	 else {
-	    gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
 	    return;
 	 }
 	 break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
 	 return;
    }
 }
@@ -1623,24 +2227,23 @@
 _mesa_ActiveTextureARB( GLenum target )
 {
    GET_CURRENT_CONTEXT(ctx);
-   const GLuint maxUnits = ctx->Const.MaxTextureUnits;
+   GLuint texUnit = target - GL_TEXTURE0_ARB;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   ASSERT_OUTSIDE_BEGIN_END( ctx, "glActiveTextureARB" );
-
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
       fprintf(stderr, "glActiveTexture %s\n",
-	      gl_lookup_enum_by_nr(target));
+	      _mesa_lookup_enum_by_nr(target));
 
-   if (target >= GL_TEXTURE0_ARB && target < GL_TEXTURE0_ARB + maxUnits) {
-      GLint texUnit = target - GL_TEXTURE0_ARB;
-      ctx->Texture.CurrentUnit = texUnit;
-      ctx->Texture.CurrentTransformUnit = texUnit;
-      if (ctx->Driver.ActiveTexture) {
-         (*ctx->Driver.ActiveTexture)( ctx, (GLuint) texUnit );
-      }
+   /* Cater for texture unit 0 is first, therefore use >= */
+   if (texUnit >= ctx->Const.MaxTextureUnits) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTextureARB(target)");
+      return;
    }
-   else {
-      gl_error(ctx, GL_INVALID_ENUM, "glActiveTextureARB(target)");
+
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+   ctx->Texture.CurrentUnit = texUnit;
+   if (ctx->Driver.ActiveTexture) {
+      (*ctx->Driver.ActiveTexture)( ctx, (GLuint) texUnit );
    }
 }
 
@@ -1650,92 +2253,146 @@
 _mesa_ClientActiveTextureARB( GLenum target )
 {
    GET_CURRENT_CONTEXT(ctx);
-   const GLuint maxUnits = ctx->Const.MaxTextureUnits;
-
-   ASSERT_OUTSIDE_BEGIN_END( ctx, "glClientActiveTextureARB" );
+   GLuint texUnit = target - GL_TEXTURE0_ARB;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (target >= GL_TEXTURE0_ARB && target < GL_TEXTURE0_ARB + maxUnits) {
-      GLint texUnit = target - GL_TEXTURE0_ARB;
-      ctx->Array.ActiveTexture = texUnit;
+   if (texUnit > ctx->Const.MaxTextureUnits) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTextureARB(target)");
+      return;
    }
-   else {
-      gl_error(ctx, GL_INVALID_ENUM, "glClientActiveTextureARB(target)");
+
+   FLUSH_VERTICES(ctx, _NEW_ARRAY);
+   ctx->Array.ActiveTexture = texUnit;
+}
+
+
+
+/**********************************************************************/
+/*                     Pixel Texgen Extensions                        */
+/**********************************************************************/
+
+void
+_mesa_PixelTexGenSGIX(GLenum mode)
+{
+   GLenum newRgbSource, newAlphaSource;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   switch (mode) {
+      case GL_NONE:
+         newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
+         newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
+         break;
+      case GL_ALPHA:
+         newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
+         newAlphaSource = GL_CURRENT_RASTER_COLOR;
+         break;
+      case GL_RGB:
+         newRgbSource = GL_CURRENT_RASTER_COLOR;
+         newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
+         break;
+      case GL_RGBA:
+         newRgbSource = GL_CURRENT_RASTER_COLOR;
+         newAlphaSource = GL_CURRENT_RASTER_COLOR;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenSGIX(mode)");
+         return;
    }
+
+   if (newRgbSource == ctx->Pixel.FragmentRgbSource &&
+       newAlphaSource == ctx->Pixel.FragmentAlphaSource)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_PIXEL);
+   ctx->Pixel.FragmentRgbSource = newRgbSource;
+   ctx->Pixel.FragmentAlphaSource = newAlphaSource;
 }
 
 
+void
+_mesa_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
+{
+   _mesa_PixelTexGenParameteriSGIS(target, (GLint) value);
+}
 
-/*
- * Put the given texture object into the list of dirty texture objects.
- * When a texture object is dirty we have to reexamine it for completeness
- * and perhaps choose a different texture sampling function.
- */
-void gl_put_texobj_on_dirty_list( GLcontext *ctx, struct gl_texture_object *t )
+
+void
+_mesa_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
+{
+   _mesa_PixelTexGenParameteriSGIS(target, (GLint) *value);
+}
+
+
+void
+_mesa_PixelTexGenParameteriSGIS(GLenum target, GLint value)
 {
-   ASSERT(ctx);
-   ASSERT(t);
-   /* Only insert if not already in the dirty list.
-    * The Dirty flag is only set iff the texture object is in the dirty list.
-    */
-   if (!t->Dirty) {
-      ASSERT(t->NextDirty == NULL);
-      t->Dirty = GL_TRUE;
-      t->NextDirty = ctx->Shared->DirtyTexObjList;
-      ctx->Shared->DirtyTexObjList = t;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (value != GL_CURRENT_RASTER_COLOR && value != GL_PIXEL_GROUP_COLOR_SGIS) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(value)");
+      return;
    }
-#ifdef DEBUG
-   else {
-      /* make sure t is in the list */
-      struct gl_texture_object *obj = ctx->Shared->DirtyTexObjList;
-      while (obj) {
-         if (obj == t) {
-            return;
-         }
-         obj = obj->NextDirty;
-      }
-      gl_problem(ctx, "Error in gl_put_texobj_on_dirty_list");
+
+   switch (target) {
+   case GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS:
+      if (ctx->Pixel.FragmentRgbSource == (GLenum) value)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.FragmentRgbSource = (GLenum) value;
+      break;
+   case GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS:
+      if (ctx->Pixel.FragmentAlphaSource == (GLenum) value)
+	 return;
+      FLUSH_VERTICES(ctx, _NEW_PIXEL);
+      ctx->Pixel.FragmentAlphaSource = (GLenum) value;
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(target)");
+      return;
    }
-#endif
 }
 
 
-/*
- * Remove a texture object from the dirty texture list.
- */
-void gl_remove_texobj_from_dirty_list( struct gl_shared_state *shared,
-                                       struct gl_texture_object *tObj )
+void
+_mesa_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
 {
-   struct gl_texture_object *t, *prev = NULL;
-   ASSERT(shared);
-   ASSERT(tObj);
-   for (t = shared->DirtyTexObjList; t; t = t->NextDirty) {
-      if (t == tObj) {
-         if (prev) {
-            prev->NextDirty = t->NextDirty;
-         }
-         else {
-            shared->DirtyTexObjList = t->NextDirty;
-         }
-         return;
-      }
-      prev = t;
+  _mesa_PixelTexGenParameteriSGIS(target, *value);
+}
+
+
+void
+_mesa_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
+      *value = (GLfloat) ctx->Pixel.FragmentRgbSource;
+   }
+   else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
+      *value = (GLfloat) ctx->Pixel.FragmentAlphaSource;
+   }
+   else {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterfvSGIS(target)");
    }
 }
 
 
-/*
- * This is called by gl_update_state() if the NEW_TEXTURING bit in
- * ctx->NewState is set.
- */
-void gl_update_dirty_texobjs( GLcontext *ctx )
+void
+_mesa_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
 {
-   struct gl_texture_object *t, *next;
-   for (t = ctx->Shared->DirtyTexObjList; t; t = next) {
-      next = t->NextDirty;
-      _mesa_test_texobj_completeness(ctx, t);
-      _mesa_set_texture_sampler(t);
-      t->NextDirty = NULL;
-      t->Dirty = GL_FALSE;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
+      *value = (GLint) ctx->Pixel.FragmentRgbSource;
+   }
+   else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
+      *value = (GLint) ctx->Pixel.FragmentAlphaSource;
+   }
+   else {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterivSGIS(target)");
    }
-   ctx->Shared->DirtyTexObjList = NULL;
 }
Index: xc/extras/Mesa/src/texstate.h
diff -u xc/extras/Mesa/src/texstate.h:1.3 xc/extras/Mesa/src/texstate.h:1.5
--- xc/extras/Mesa/src/texstate.h:1.3	Tue Feb 15 02:12:37 2000
+++ xc/extras/Mesa/src/texstate.h	Mon Sep  9 17:29:39 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -24,14 +24,15 @@
  */
 
 
-
-
-
 #ifndef TEXSTATE_H
 #define TEXSTATE_H
 
 
-#include "types.h"
+#include "mtypes.h"
+
+
+extern void
+_mesa_copy_texture_state( const GLcontext *src, GLcontext *dst );
 
 
 /*** Called from API ***/
@@ -113,9 +114,7 @@
 
 
 
-extern void gl_SelectTextureTransform( GLcontext *ctx, GLenum target );
 
-
 /*
  * GL_ARB_multitexture
  */
@@ -126,22 +125,42 @@
 _mesa_ClientActiveTextureARB( GLenum target );
 
 
+/*
+ * Pixel Texture Extensions
+ */
 
-/*** Internal functions ***/
+extern void
+_mesa_PixelTexGenSGIX(GLenum mode);
 
-extern void 
-gl_put_texobj_on_dirty_list( GLcontext *ctx, struct gl_texture_object *t );
+extern void
+_mesa_PixelTexGenParameterfSGIS(GLenum target, GLfloat value);
 
 #ifdef VMS
-#define gl_remove_texobj_from_dirty_list gl_remove_texobj_from_dirty_lis
+#define _mesa_PixelTexGenParameterfvSGIS _mesa_PixelTexGenParameterfv
 #endif
 extern void
-gl_remove_texobj_from_dirty_list( struct gl_shared_state *shared,
-                                  struct gl_texture_object *tObj );
+_mesa_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value);
 
 extern void
-gl_update_dirty_texobjs( GLcontext *ctx );
+_mesa_PixelTexGenParameteriSGIS(GLenum target, GLint value);
 
+#ifdef VMS
+#define _mesa_PixelTexGenParameterivSGIS _mesa_PixelTexGenParameteriv
+#endif
+extern void
+_mesa_PixelTexGenParameterivSGIS(GLenum target, const GLint *value);
 
+#ifdef VMS
+#define _mesa_GetPixelTexGenParameterfvSGIS _mesa_GetPixelTexGenParameterfv
 #endif
+extern void
+_mesa_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value);
 
+#ifdef VMS
+#define _mesa_GetPixelTexGenParameterivSGIS _mesa_GetPixelTexGenParameteriv
+#endif
+extern void
+_mesa_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value);
+
+
+#endif
Index: xc/extras/Mesa/src/texstore.c
diff -u /dev/null xc/extras/Mesa/src/texstore.c:1.4
--- /dev/null	Thu Feb 27 12:15:43 2003
+++ xc/extras/Mesa/src/texstore.c	Mon Dec 16 11:18:27 2002
@@ -0,0 +1,1775 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Authors:
+ *   Brian Paul
+ */
+
+#include "colormac.h"
+#include "context.h"
+#include "convolve.h"
+#include "image.h"
+#include "macros.h"
+#include "mem.h"
+#include "texformat.h"
+#include "teximage.h"
+#include "texstore.h"
+#include "texutil.h"
+
+
+/*
+ * Given an internal texture format enum or 1, 2, 3, 4 return the
+ * corresponding _base_ internal format:  GL_ALPHA, GL_LUMINANCE,
+ * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA.  Return the
+ * number of components for the format.  Return -1 if invalid enum.
+ *
+ * GH: Do we really need this?  We have the number of bytes per texel
+ * in the texture format structures, so why don't we just use that?
+ */
+static GLint
+components_in_intformat( GLint format )
+{
+   switch (format) {
+      case GL_ALPHA:
+      case GL_ALPHA4:
+      case GL_ALPHA8:
+      case GL_ALPHA12:
+      case GL_ALPHA16:
+         return 1;
+      case 1:
+      case GL_LUMINANCE:
+      case GL_LUMINANCE4:
+      case GL_LUMINANCE8:
+      case GL_LUMINANCE12:
+      case GL_LUMINANCE16:
+         return 1;
+      case 2:
+      case GL_LUMINANCE_ALPHA:
+      case GL_LUMINANCE4_ALPHA4:
+      case GL_LUMINANCE6_ALPHA2:
+      case GL_LUMINANCE8_ALPHA8:
+      case GL_LUMINANCE12_ALPHA4:
+      case GL_LUMINANCE12_ALPHA12:
+      case GL_LUMINANCE16_ALPHA16:
+         return 2;
+      case GL_INTENSITY:
+      case GL_INTENSITY4:
+      case GL_INTENSITY8:
+      case GL_INTENSITY12:
+      case GL_INTENSITY16:
+         return 1;
+      case 3:
+      case GL_RGB:
+      case GL_R3_G3_B2:
+      case GL_RGB4:
+      case GL_RGB5:
+      case GL_RGB8:
+      case GL_RGB10:
+      case GL_RGB12:
+      case GL_RGB16:
+         return 3;
+      case 4:
+      case GL_RGBA:
+      case GL_RGBA2:
+      case GL_RGBA4:
+      case GL_RGB5_A1:
+      case GL_RGBA8:
+      case GL_RGB10_A2:
+      case GL_RGBA12:
+      case GL_RGBA16:
+         return 4;
+      case GL_COLOR_INDEX:
+      case GL_COLOR_INDEX1_EXT:
+      case GL_COLOR_INDEX2_EXT:
+      case GL_COLOR_INDEX4_EXT:
+      case GL_COLOR_INDEX8_EXT:
+      case GL_COLOR_INDEX12_EXT:
+      case GL_COLOR_INDEX16_EXT:
+         return 1;
+      case GL_DEPTH_COMPONENT:
+      case GL_DEPTH_COMPONENT16_SGIX:
+      case GL_DEPTH_COMPONENT24_SGIX:
+      case GL_DEPTH_COMPONENT32_SGIX:
+         return 1;
+      case GL_YCBCR_MESA:
+         return 2; /* Y + (Cb or Cr) */
+      default:
+         return -1;  /* error */
+   }
+}
+
+
+/*
+ * This function is used to transfer the user's image data into a texture
+ * image buffer.  We handle both full texture images and subtexture images.
+ * We also take care of all image transfer operations here, including
+ * convolution, scale/bias, colortables, etc.
+ *
+ * The destination texel channel type is always GLchan.
+ *
+ * A hardware driver may use this as a helper routine to unpack and
+ * apply pixel transfer ops into a temporary image buffer.  Then,
+ * convert the temporary image into the special hardware format.
+ *
+ * Input:
+ *   dimensions - 1, 2, or 3
+ *   texFormat - GL_LUMINANCE, GL_INTENSITY, GL_LUMINANCE_ALPHA, GL_ALPHA,
+ *               GL_RGB or GL_RGBA
+ *   texDestAddr - destination image address
+ *   srcWidth, srcHeight, srcDepth - size (in pixels) of src and dest images
+ *   dstXoffset, dstYoffset, dstZoffset - position to store the image within
+ *      the destination 3D texture
+ *   dstRowStride, dstImageStride - dest image strides in bytes
+ *   srcFormat - source image format (GL_ALPHA, GL_RED, GL_RGB, etc)
+ *   srcType - GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_5_6_5, GL_FLOAT, etc
+ *   srcPacking - describes packing of incoming image.
+ *   transferOps - mask of pixel transfer operations
+ */
+static void
+transfer_teximage(GLcontext *ctx, GLuint dimensions,
+                  GLenum texDestFormat, GLvoid *texDestAddr,
+                  GLint srcWidth, GLint srcHeight, GLint srcDepth,
+                  GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
+                  GLint dstRowStride, GLint dstImageStride,
+                  GLenum srcFormat, GLenum srcType,
+                  const GLvoid *srcAddr,
+                  const struct gl_pixelstore_attrib *srcPacking,
+                  GLuint transferOps)
+{
+   GLint texComponents;
+
+   ASSERT(ctx);
+   ASSERT(dimensions >= 1 && dimensions <= 3);
+   ASSERT(texDestAddr);
+   ASSERT(srcWidth >= 1);
+   ASSERT(srcHeight >= 1);
+   ASSERT(srcDepth >= 1);
+   ASSERT(dstXoffset >= 0);
+   ASSERT(dstYoffset >= 0);
+   ASSERT(dstZoffset >= 0);
+   ASSERT(dstRowStride >= 0);
+   ASSERT(dstImageStride >= 0);
+   ASSERT(srcAddr);
+   ASSERT(srcPacking);
+
+   texComponents = components_in_intformat(texDestFormat);
+
+   /* try common 2D texture cases first */
+   if (!transferOps && dimensions == 2 && srcType == CHAN_TYPE) {
+
+      if (srcFormat == texDestFormat) {
+         /* This will cover the common GL_RGB, GL_RGBA, GL_ALPHA,
+          * GL_LUMINANCE_ALPHA, etc. texture formats.  Use memcpy().
+          */
+         const GLchan *src = (const GLchan *) _mesa_image_address(
+                                   srcPacking, srcAddr, srcWidth, srcHeight,
+                                   srcFormat, srcType, 0, 0, 0);
+         const GLint srcRowStride = _mesa_image_row_stride(srcPacking,
+                                               srcWidth, srcFormat, srcType);
+         const GLint widthInBytes = srcWidth * texComponents * sizeof(GLchan);
+         GLchan *dst = (GLchan *) texDestAddr
+                     + dstYoffset * (dstRowStride / sizeof(GLchan))
+                     + dstXoffset * texComponents;
+         if (srcRowStride == widthInBytes && dstRowStride == widthInBytes) {
+            MEMCPY(dst, src, srcHeight * widthInBytes);
+         }
+         else {
+            GLint i;
+            for (i = 0; i < srcHeight; i++) {
+               MEMCPY(dst, src, widthInBytes);
+               src += (srcRowStride / sizeof(GLchan));
+               dst += (dstRowStride / sizeof(GLchan));
+            }
+         }
+         return;  /* all done */
+      }
+      else if (srcFormat == GL_RGBA && texDestFormat == GL_RGB) {
+         /* commonly used by Quake */
+         const GLchan *src = (const GLchan *) _mesa_image_address(
+                                   srcPacking, srcAddr, srcWidth, srcHeight,
+                                   srcFormat, srcType, 0, 0, 0);
+         const GLint srcRowStride = _mesa_image_row_stride(srcPacking,
+                                               srcWidth, srcFormat, srcType);
+         GLchan *dst = (GLchan *) texDestAddr
+                     + dstYoffset * (dstRowStride / sizeof(GLchan))
+                     + dstXoffset * texComponents;
+         GLint i, j;
+         for (i = 0; i < srcHeight; i++) {
+            const GLchan *s = src;
+            GLchan *d = dst;
+            for (j = 0; j < srcWidth; j++) {
+               *d++ = *s++;  /*red*/
+               *d++ = *s++;  /*green*/
+               *d++ = *s++;  /*blue*/
+               s++;          /*alpha*/
+            }
+            src += (srcRowStride / sizeof(GLchan));
+            dst += (dstRowStride / sizeof(GLchan));
+         }
+         return;  /* all done */
+      }
+   }
+
+   /*
+    * General case solutions
+    */
+   if (texDestFormat == GL_COLOR_INDEX) {
+      /* color index texture */
+      const GLenum texType = CHAN_TYPE;
+      GLint img, row;
+      GLchan *dest = (GLchan *) texDestAddr
+                   + dstZoffset * (dstImageStride / sizeof(GLchan))
+                   + dstYoffset * (dstRowStride / sizeof(GLchan))
+                   + dstXoffset * texComponents;
+      for (img = 0; img < srcDepth; img++) {
+         GLchan *destRow = dest;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_index_span(ctx, srcWidth, texType, destRow,
+                                    srcType, src, srcPacking, transferOps);
+            destRow += (dstRowStride / sizeof(GLchan));
+         }
+         dest += dstImageStride;
+      }
+   }
+   else if (texDestFormat == GL_YCBCR_MESA) {
+      /* YCbCr texture */
+      GLint img, row;
+      GLushort *dest = (GLushort *) texDestAddr
+                     + dstZoffset * (dstImageStride / sizeof(GLushort))
+                     + dstYoffset * (dstRowStride / sizeof(GLushort))
+                     + dstXoffset * texComponents;
+      ASSERT(ctx->Extensions.MESA_ycbcr_texture);
+      for (img = 0; img < srcDepth; img++) {
+         GLushort *destRow = dest;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *srcRow = _mesa_image_address(srcPacking,
+                                          srcAddr, srcWidth, srcHeight,
+                                          srcFormat, srcType, img, row, 0);
+            MEMCPY(destRow, srcRow, srcWidth * sizeof(GLushort));
+            destRow += (dstRowStride / sizeof(GLushort));
+         }
+         dest += dstImageStride / sizeof(GLushort);
+      }
+   }
+   else if (texDestFormat == GL_DEPTH_COMPONENT) {
+      /* Depth texture (shadow maps) */
+      GLint img, row;
+      GLubyte *dest = (GLubyte *) texDestAddr
+                    + dstZoffset * dstImageStride
+                    + dstYoffset * (dstRowStride / sizeof(GLchan))
+                    + dstXoffset * texComponents;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *destRow = dest;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_depth_span(ctx, srcWidth, (GLfloat *) destRow,
+                                    srcType, src, srcPacking);
+            destRow += (dstRowStride / sizeof(GLchan));
+         }
+         dest += dstImageStride;
+      }
+   }
+   else {
+      /* regular, color texture */
+      if ((dimensions == 1 && ctx->Pixel.Convolution1DEnabled) ||
+          (dimensions >= 2 && ctx->Pixel.Convolution2DEnabled) ||
+          (dimensions >= 2 && ctx->Pixel.Separable2DEnabled)) {
+         /*
+          * Fill texture image with convolution
+          */
+         GLint img, row;
+         GLint convWidth = srcWidth, convHeight = srcHeight;
+         GLfloat *tmpImage, *convImage;
+         tmpImage = (GLfloat *) MALLOC(srcWidth * srcHeight * 4 * sizeof(GLfloat));
+         if (!tmpImage) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
+            return;
+         }
+         convImage = (GLfloat *) MALLOC(srcWidth * srcHeight * 4 * sizeof(GLfloat));
+         if (!convImage) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage");
+            FREE(tmpImage);
+            return;
+         }
+
+         for (img = 0; img < srcDepth; img++) {
+            const GLfloat *srcf;
+            GLfloat *dstf = tmpImage;
+            GLchan *dest;
+
+            /* unpack and do transfer ops up to convolution */
+            for (row = 0; row < srcHeight; row++) {
+               const GLvoid *src = _mesa_image_address(srcPacking,
+                                              srcAddr, srcWidth, srcHeight,
+                                              srcFormat, srcType, img, row, 0);
+               _mesa_unpack_float_color_span(ctx, srcWidth, GL_RGBA, dstf,
+                         srcFormat, srcType, src, srcPacking,
+                         transferOps & IMAGE_PRE_CONVOLUTION_BITS,
+                         GL_TRUE);
+               dstf += srcWidth * 4;
+            }
+
+            /* convolve */
+            if (dimensions == 1) {
+               ASSERT(ctx->Pixel.Convolution1DEnabled);
+               _mesa_convolve_1d_image(ctx, &convWidth, tmpImage, convImage);
+            }
+            else {
+               if (ctx->Pixel.Convolution2DEnabled) {
+                  _mesa_convolve_2d_image(ctx, &convWidth, &convHeight,
+                                          tmpImage, convImage);
+               }
+               else {
+                  ASSERT(ctx->Pixel.Separable2DEnabled);
+                  _mesa_convolve_sep_image(ctx, &convWidth, &convHeight,
+                                           tmpImage, convImage);
+               }
+            }
+
+            /* packing and transfer ops after convolution */
+            srcf = convImage;
+            dest = (GLchan *) texDestAddr
+                 + (dstZoffset + img) * (dstImageStride / sizeof(GLchan))
+                 + dstYoffset * (dstRowStride / sizeof(GLchan));
+            for (row = 0; row < convHeight; row++) {
+               _mesa_pack_float_rgba_span(ctx, convWidth,
+                                          (const GLfloat (*)[4]) srcf,
+                                          texDestFormat, CHAN_TYPE,
+                                          dest, &_mesa_native_packing,
+                                          transferOps
+                                          & IMAGE_POST_CONVOLUTION_BITS);
+               srcf += convWidth * 4;
+               dest += (dstRowStride / sizeof(GLchan));
+            }
+         }
+
+         FREE(convImage);
+         FREE(tmpImage);
+      }
+      else {
+         /*
+          * no convolution
+          */
+         GLint img, row;
+         GLchan *dest = (GLchan *) texDestAddr
+                      + dstZoffset * (dstImageStride / sizeof(GLchan))
+                      + dstYoffset * (dstRowStride / sizeof(GLchan))
+                      + dstXoffset * texComponents;
+         for (img = 0; img < srcDepth; img++) {
+            GLchan *destRow = dest;
+            for (row = 0; row < srcHeight; row++) {
+               const GLvoid *srcRow = _mesa_image_address(srcPacking,
+                                              srcAddr, srcWidth, srcHeight,
+                                              srcFormat, srcType, img, row, 0);
+               _mesa_unpack_chan_color_span(ctx, srcWidth, texDestFormat,
+                                       destRow, srcFormat, srcType, srcRow,
+                                       srcPacking, transferOps);
+               destRow += (dstRowStride / sizeof(GLchan));
+            }
+            dest += dstImageStride / sizeof(GLchan);
+         }
+      }
+   }
+}
+
+
+
+/*
+ * Transfer a texture image from user space to <destAddr> applying all
+ * needed image transfer operations and storing the result in the format
+ * specified by <dstFormat>.  <dstFormat> may be any format from texformat.h.
+ * Input:
+ *   dimensions - 1, 2 or 3
+ *   baseInternalFormat - base format of the internal texture format
+ *       specified by the user.  This is very important, see below.
+ *   dstFormat - destination image format
+ *   dstAddr - destination address
+ *   srcWidth, srcHeight, srcDepth - size of source iamge
+ *   dstX/Y/Zoffset - as specified by glTexSubImage
+ *   dstRowStride - stride between dest rows in bytes
+ *   dstImageStride - stride between dest images in bytes
+ *   srcFormat, srcType - incoming image format and datatype
+ *   srcAddr - source image address
+ *   srcPacking - packing params of source image
+ *
+ * XXX this function is a bit more complicated than it should be.  If
+ * _mesa_convert_texsubimage[123]d could handle any dest/source formats
+ * or if transfer_teximage() could store in any MESA_FORMAT_* format, we
+ * could simplify things here.
+ */
+void
+_mesa_transfer_teximage(GLcontext *ctx, GLuint dimensions,
+                        GLenum baseInternalFormat,
+                        const struct gl_texture_format *dstFormat,
+                        GLvoid *dstAddr,
+                        GLint srcWidth, GLint srcHeight, GLint srcDepth,
+                        GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
+                        GLint dstRowStride, GLint dstImageStride,
+                        GLenum srcFormat, GLenum srcType,
+                        const GLvoid *srcAddr,
+                        const struct gl_pixelstore_attrib *srcPacking)
+{
+   const GLint dstRowStridePixels = dstRowStride / dstFormat->TexelBytes;
+   const GLint dstImageStridePixels = dstImageStride / dstFormat->TexelBytes;
+   GLboolean makeTemp;
+   GLuint transferOps = ctx->_ImageTransferState;
+   GLboolean freeSourceData = GL_FALSE;
+   GLint postConvWidth = srcWidth, postConvHeight = srcHeight;
+
+   assert(baseInternalFormat > 0);
+
+   if (transferOps & IMAGE_CONVOLUTION_BIT) {
+      _mesa_adjust_image_for_convolution(ctx, dimensions, &postConvWidth,
+                                         &postConvHeight);
+   }
+
+   /*
+    * Consider this scenario:  The user's source image is GL_RGB and the
+    * requested internal format is GL_LUMINANCE.  Now suppose the device
+    * driver doesn't support GL_LUMINANCE and instead uses RGB16 as the
+    * texture format.  In that case we still need to do an intermediate
+    * conversion to luminance format so that the incoming red channel gets
+    * replicated into the dest red, green and blue channels.  The following
+    * code takes care of that.
+    */
+   if (dstFormat->BaseFormat != baseInternalFormat) {
+      /* Allocate storage for temporary image in the baseInternalFormat */
+      const GLint texelSize = _mesa_components_in_format(baseInternalFormat)
+         * sizeof(GLchan);
+      const GLint bytes = texelSize * postConvWidth * postConvHeight *srcDepth;
+      const GLint tmpRowStride = texelSize * postConvWidth;
+      const GLint tmpImgStride = texelSize * postConvWidth * postConvHeight;
+      GLvoid *tmpImage = MALLOC(bytes);
+      if (!tmpImage)
+         return;
+      transfer_teximage(ctx, dimensions, baseInternalFormat, tmpImage,
+                        srcWidth, srcHeight, srcDepth,
+                        0, 0, 0, /* x/y/zoffset */
+                        tmpRowStride, tmpImgStride,
+                        srcFormat, srcType, srcAddr, srcPacking, transferOps);
+
+      /* this is our new source image */
+      srcWidth = postConvWidth;
+      srcHeight = postConvHeight;
+      srcFormat = baseInternalFormat;
+      srcType = CHAN_TYPE;
+      srcAddr = tmpImage;
+      srcPacking = &_mesa_native_packing;
+      freeSourceData = GL_TRUE;
+      transferOps = 0;  /* image transfer ops were completed */
+   }
+
+   /* Let the optimized tex conversion functions take a crack at the
+    * image conversion if the dest format is a h/w format.
+    */
+   if (_mesa_is_hardware_tex_format(dstFormat)) {
+      if (transferOps) {
+         makeTemp = GL_TRUE;
+      }
+      else {
+         if (dimensions == 1) {
+            makeTemp = !_mesa_convert_texsubimage1d(dstFormat->MesaFormat,
+                                                    dstXoffset,
+                                                    srcWidth,
+                                                    srcFormat, srcType,
+                                                    srcPacking, srcAddr,
+                                                    dstAddr);
+         }
+         else if (dimensions == 2) {
+            makeTemp = !_mesa_convert_texsubimage2d(dstFormat->MesaFormat,
+                                                    dstXoffset, dstYoffset,
+                                                    srcWidth, srcHeight,
+                                                    dstRowStridePixels,
+                                                    srcFormat, srcType,
+                                                    srcPacking, srcAddr,
+                                                    dstAddr);
+         }
+         else {
+            assert(dimensions == 3);
+            makeTemp = !_mesa_convert_texsubimage3d(dstFormat->MesaFormat,
+                                      dstXoffset, dstYoffset, dstZoffset,
+                                      srcWidth, srcHeight, srcDepth,
+                                      dstRowStridePixels, dstImageStridePixels,
+                                      srcFormat, srcType,
+                                      srcPacking, srcAddr, dstAddr);
+         }
+         if (!makeTemp) {
+            /* all done! */
+            if (freeSourceData)
+               FREE((void *) srcAddr);
+            return;
+         }
+      }
+   }
+   else {
+      /* software texture format */
+      makeTemp = GL_FALSE;
+   }
+
+   if (makeTemp) {
+      GLint postConvWidth = srcWidth, postConvHeight = srcHeight;
+      GLenum tmpFormat;
+      GLuint tmpComps, tmpTexelSize;
+      GLint tmpRowStride, tmpImageStride;
+      GLubyte *tmpImage;
+
+      if (transferOps & IMAGE_CONVOLUTION_BIT) {
+         _mesa_adjust_image_for_convolution(ctx, dimensions, &postConvWidth,
+                                            &postConvHeight);
+      }
+
+      tmpFormat = dstFormat->BaseFormat;
+      tmpComps = _mesa_components_in_format(tmpFormat);
+      tmpTexelSize = tmpComps * sizeof(GLchan);
+      tmpRowStride = postConvWidth * tmpTexelSize;
+      tmpImageStride = postConvWidth * postConvHeight * tmpTexelSize;
+      tmpImage = (GLubyte *) MALLOC(postConvWidth * postConvHeight *
+                                    srcDepth * tmpTexelSize);
+      if (!tmpImage) {
+         if (freeSourceData)
+            FREE((void *) srcAddr);
+         return;
+      }
+
+      transfer_teximage(ctx, dimensions, tmpFormat, tmpImage,
+                        srcWidth, srcHeight, srcDepth,
+                        0, 0, 0, /* x/y/zoffset */
+                        tmpRowStride, tmpImageStride,
+                        srcFormat, srcType, srcAddr, srcPacking, transferOps);
+
+      if (freeSourceData)
+         FREE((void *) srcAddr);
+
+      /* the temp image is our new source image */
+      srcWidth = postConvWidth;
+      srcHeight = postConvHeight;
+      srcFormat = tmpFormat;
+      srcType = CHAN_TYPE;
+      srcAddr = tmpImage;
+      srcPacking = &_mesa_native_packing;
+      freeSourceData = GL_TRUE;
+   }
+
+   if (_mesa_is_hardware_tex_format(dstFormat)) {
+      assert(makeTemp);
+      if (dimensions == 1) {
+         GLboolean b;
+         b = _mesa_convert_texsubimage1d(dstFormat->MesaFormat,
+                                         dstXoffset,
+                                         srcWidth,
+                                         srcFormat, srcType,
+                                         srcPacking, srcAddr,
+                                         dstAddr);
+         assert(b);
+      }
+      else if (dimensions == 2) {
+         GLboolean b;
+         b = _mesa_convert_texsubimage2d(dstFormat->MesaFormat,
+                                         dstXoffset, dstYoffset,
+                                         srcWidth, srcHeight,
+                                         dstRowStridePixels,
+                                         srcFormat, srcType,
+                                         srcPacking, srcAddr,
+                                         dstAddr);
+         assert(b);
+      }
+      else {
+         GLboolean b;
+         b = _mesa_convert_texsubimage3d(dstFormat->MesaFormat,
+                                      dstXoffset, dstYoffset, dstZoffset,
+                                      srcWidth, srcHeight, srcDepth,
+                                      dstRowStridePixels, dstImageStridePixels,
+                                      srcFormat, srcType,
+                                      srcPacking, srcAddr, dstAddr);
+         assert(b);
+      }
+   }
+   else {
+      /* software format */
+      assert(!makeTemp);
+      transfer_teximage(ctx, dimensions, dstFormat->BaseFormat, dstAddr,
+                        srcWidth, srcHeight, srcDepth,
+                        dstXoffset, dstYoffset, dstZoffset,
+                        dstRowStride, dstImageStride,
+                        srcFormat, srcType, srcAddr, srcPacking, transferOps);
+   }
+
+   if (freeSourceData)
+      FREE((void *) srcAddr);  /* the temp image */
+}
+
+
+/*
+ * This is the software fallback for Driver.TexImage1D().
+ * The texture image type will be GLchan.
+ * The texture image format will be GL_COLOR_INDEX, GL_INTENSITY,
+ * GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_ALPHA, GL_RGB or GL_RGBA.
+ *
+ */
+void
+_mesa_store_teximage1d(GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint border,
+                       GLenum format, GLenum type, const GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLint postConvWidth = width;
+   GLint texelBytes, sizeInBytes;
+
+   if (ctx->_ImageTransferState & IMAGE_CONVOLUTION_BIT) {
+      _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
+   }
+
+   /* choose the texture format */
+   assert(ctx->Driver.ChooseTextureFormat);
+   texImage->TexFormat = (*ctx->Driver.ChooseTextureFormat)(ctx,
+                                          internalFormat, format, type);
+   assert(texImage->TexFormat);
+   texImage->FetchTexel = texImage->TexFormat->FetchTexel1D;
+
+   texelBytes = texImage->TexFormat->TexelBytes;
+
+   /* Compute image size, in bytes */
+   if (texImage->IsCompressed) {
+      assert(ctx->Driver.CompressedTextureSize);
+      sizeInBytes = ctx->Driver.CompressedTextureSize(ctx, texImage);
+      assert(sizeInBytes > 0);
+      texImage->CompressedSize = sizeInBytes;
+   }
+   else {
+      sizeInBytes = postConvWidth * texelBytes;
+   }
+
+   /* allocate memory */
+   texImage->Data = MESA_PBUFFER_ALLOC(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+      return;
+   }
+
+   if (pixels) {
+      /* unpack image, apply transfer ops and store in texImage->Data */
+      _mesa_transfer_teximage(ctx, 1,
+                              _mesa_base_tex_format(ctx, internalFormat),
+                              texImage->TexFormat, texImage->Data,
+                              width, 1, 1, 0, 0, 0,
+                              0, /* dstRowStride */
+                              0, /* dstImageStride */
+                              format, type, pixels, packing);
+
+      /* GL_SGIS_generate_mipmap */
+      if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+         _mesa_generate_mipmap(ctx, target,
+                               &ctx->Texture.Unit[ctx->Texture.CurrentUnit],
+                               texObj);
+      }
+   }
+}
+
+
+/*
+ * This is the software fallback for Driver.TexImage2D().
+ * The texture image type will be GLchan.
+ * The texture image format will be GL_COLOR_INDEX, GL_INTENSITY,
+ * GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_ALPHA, GL_RGB or GL_RGBA.
+ *
+ * NOTE: if real texture compression is supported, this whole function
+ * will need to be overridden.
+ */
+void
+_mesa_store_teximage2d(GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLint postConvWidth = width, postConvHeight = height;
+   GLint texelBytes, sizeInBytes;
+
+   if (ctx->_ImageTransferState & IMAGE_CONVOLUTION_BIT) {
+      _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
+                                         &postConvHeight);
+   }
+
+   /* choose the texture format */
+   assert(ctx->Driver.ChooseTextureFormat);
+   texImage->TexFormat = (*ctx->Driver.ChooseTextureFormat)(ctx,
+                                          internalFormat, format, type);
+   assert(texImage->TexFormat);
+   texImage->FetchTexel = texImage->TexFormat->FetchTexel2D;
+
+   texelBytes = texImage->TexFormat->TexelBytes;
+
+   /* Compute image size, in bytes */
+   if (texImage->IsCompressed) {
+      assert(ctx->Driver.CompressedTextureSize);
+      sizeInBytes = ctx->Driver.CompressedTextureSize(ctx, texImage);
+      assert(sizeInBytes > 0);
+      texImage->CompressedSize = sizeInBytes;
+   }
+   else {
+      sizeInBytes = postConvWidth * postConvHeight * texelBytes;
+   }
+
+   /* allocate memory */
+   texImage->Data = MESA_PBUFFER_ALLOC(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+      return;
+   }
+
+   if (pixels) {
+      /* unpack image, apply transfer ops and store in texImage->Data */
+      _mesa_transfer_teximage(ctx, 2,
+                              _mesa_base_tex_format(ctx, internalFormat),
+                              texImage->TexFormat, texImage->Data,
+                              width, height, 1, 0, 0, 0,
+                              texImage->Width * texelBytes,
+                              0, /* dstImageStride */
+                              format, type, pixels, packing);
+
+      /* GL_SGIS_generate_mipmap */
+      if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+         _mesa_generate_mipmap(ctx, target,
+                               &ctx->Texture.Unit[ctx->Texture.CurrentUnit],
+                               texObj);
+      }
+   }
+}
+
+
+
+/*
+ * This is the software fallback for Driver.TexImage3D().
+ * The texture image type will be GLchan.
+ * The texture image format will be GL_COLOR_INDEX, GL_INTENSITY,
+ * GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_ALPHA, GL_RGB or GL_RGBA.
+ *
+ */
+void
+_mesa_store_teximage3d(GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint depth, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLint texelBytes, sizeInBytes;
+
+   /* choose the texture format */
+   assert(ctx->Driver.ChooseTextureFormat);
+   texImage->TexFormat = (*ctx->Driver.ChooseTextureFormat)(ctx,
+                                          internalFormat, format, type);
+   assert(texImage->TexFormat);
+   texImage->FetchTexel = texImage->TexFormat->FetchTexel3D;
+
+   texelBytes = texImage->TexFormat->TexelBytes;
+
+   /* Compute image size, in bytes */
+   if (texImage->IsCompressed) {
+      assert(ctx->Driver.CompressedTextureSize);
+      sizeInBytes = ctx->Driver.CompressedTextureSize(ctx, texImage);
+      assert(sizeInBytes > 0);
+      texImage->CompressedSize = sizeInBytes;
+   }
+   else {
+      sizeInBytes = width * height * depth * texelBytes;
+   }
+
+   /* allocate memory */
+   texImage->Data = MESA_PBUFFER_ALLOC(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+      return;
+   }
+
+   if (pixels) {
+      /* unpack image, apply transfer ops and store in texImage->Data */
+      _mesa_transfer_teximage(ctx, 3,
+                              _mesa_base_tex_format(ctx, internalFormat),
+                              texImage->TexFormat, texImage->Data,
+                              width, height, depth, 0, 0, 0,
+                              texImage->Width * texelBytes,
+                              texImage->Width * texImage->Height * texelBytes,
+                              format, type, pixels, packing);
+
+      /* GL_SGIS_generate_mipmap */
+      if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+         _mesa_generate_mipmap(ctx, target,
+                               &ctx->Texture.Unit[ctx->Texture.CurrentUnit],
+                               texObj);
+      }
+   }
+}
+
+
+
+
+/*
+ * This is the software fallback for Driver.TexSubImage1D().
+ */
+void
+_mesa_store_texsubimage1d(GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint width,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   _mesa_transfer_teximage(ctx, 1,
+                           _mesa_base_tex_format(ctx, texImage->IntFormat),
+                           texImage->TexFormat, texImage->Data,
+                           width, 1, 1, /* src size */
+                           xoffset, 0, 0, /* dest offsets */
+                           0, /* dstRowStride */
+                           0, /* dstImageStride */
+                           format, type, pixels, packing);
+
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target,
+                            &ctx->Texture.Unit[ctx->Texture.CurrentUnit],
+                            texObj);
+   }
+}
+
+
+/*
+ * This is the software fallback for Driver.TexSubImage2D().
+ */
+void
+_mesa_store_texsubimage2d(GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset,
+                          GLint width, GLint height,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   _mesa_transfer_teximage(ctx, 2,
+                           _mesa_base_tex_format(ctx, texImage->IntFormat),
+                           texImage->TexFormat, texImage->Data,
+                           width, height, 1, /* src size */
+                           xoffset, yoffset, 0, /* dest offsets */
+                           texImage->Width * texImage->TexFormat->TexelBytes,
+                           0, /* dstImageStride */
+                           format, type, pixels, packing);
+
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target,
+                            &ctx->Texture.Unit[ctx->Texture.CurrentUnit],
+                            texObj);
+   }
+}
+
+
+/*
+ * This is the software fallback for Driver.TexSubImage3D().
+ */
+void
+_mesa_store_texsubimage3d(GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset, GLint zoffset,
+                          GLint width, GLint height, GLint depth,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   const GLint texelBytes = texImage->TexFormat->TexelBytes;
+   _mesa_transfer_teximage(ctx, 3,
+                           _mesa_base_tex_format(ctx, texImage->IntFormat),
+                           texImage->TexFormat, texImage->Data,
+                           width, height, depth, /* src size */
+                           xoffset, yoffset, xoffset, /* dest offsets */
+                           texImage->Width * texelBytes,
+                           texImage->Width * texImage->Height * texelBytes,
+                           format, type, pixels, packing);
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target,
+                            &ctx->Texture.Unit[ctx->Texture.CurrentUnit],
+                            texObj);
+   }
+}
+
+
+
+
+/*
+ * Fallback for Driver.CompressedTexImage1D()
+ */
+void
+_mesa_store_compressed_teximage1d(GLcontext *ctx, GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   /* Nothing here.
+    * The device driver has to do it all.
+    */
+}
+
+
+
+/*
+ * Fallback for Driver.CompressedTexImage2D()
+ */
+void
+_mesa_store_compressed_teximage2d(GLcontext *ctx, GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   /* Nothing here.
+    * The device driver has to do it all.
+    */
+}
+
+
+
+/*
+ * Fallback for Driver.CompressedTexImage3D()
+ */
+void
+_mesa_store_compressed_teximage3d(GLcontext *ctx, GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint depth,
+                                  GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   /* Nothing here.
+    * The device driver has to do it all.
+    */
+}
+
+
+
+/*
+ * Fallback for Driver.GetCompressedTexImage3D()
+ * This will probably work find for hardware drivers.  That is, hardware
+ * drivers won't have to override this function, unless the compressed
+ * texture must first be fetched from the TRAM.
+ */
+void
+_mesa_get_compressed_teximage(GLcontext *ctx, GLenum target,
+                              GLint level, void *image,
+                              const struct gl_texture_object *texObj,
+                              struct gl_texture_image *texImage)
+{
+   assert(texImage->IsCompressed);
+   assert(texImage->CompressedSize > 0);
+   MEMCPY(image, texImage->Data, texImage->CompressedSize);
+}
+
+
+
+/*
+ * This is the fallback for Driver.TestProxyTexImage().
+ */
+GLboolean
+_mesa_test_proxy_teximage(GLcontext *ctx, GLenum target, GLint level,
+                          GLint internalFormat, GLenum format, GLenum type,
+                          GLint width, GLint height, GLint depth, GLint border)
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+
+   (void) format;
+   (void) type;
+
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+
+   /* We always pass.
+    * The core Mesa code will have already tested the image size, etc.
+    * If a driver has more stringent texture limits to enforce it will
+    * have to override this function.
+    */
+   /* choose the texture format */
+   assert(ctx->Driver.ChooseTextureFormat);
+   texImage->TexFormat = (*ctx->Driver.ChooseTextureFormat)(ctx,
+                                          internalFormat, format, type);
+   assert(texImage->TexFormat);
+
+   return GL_TRUE;
+}
+
+
+
+/*
+ * Average together two rows of a source image to produce a single new
+ * row in the dest image.  It's legal for the two source rows to point
+ * to the same data.  The source width must be equal to either the
+ * dest width or two times the dest width.
+ */
+static void
+do_row(const struct gl_texture_format *format, GLint srcWidth,
+       const GLvoid *srcRowA, const GLvoid *srcRowB,
+       GLint dstWidth, GLvoid *dstRow)
+{
+   const GLuint k0 = (srcWidth == dstWidth) ? 0 : 1;
+   const GLuint colStride = (srcWidth == dstWidth) ? 1 : 2;
+
+   assert(srcWidth == dstWidth || srcWidth == 2 * dstWidth);
+
+   switch (format->MesaFormat) {
+   case MESA_FORMAT_RGBA:
+      {
+         GLuint i, j, k;
+         const GLchan (*rowA)[4] = (const GLchan (*)[4]) srcRowA;
+         const GLchan (*rowB)[4] = (const GLchan (*)[4]) srcRowB;
+         GLchan (*dst)[4] = (GLchan (*)[4]) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i][0] = (rowA[j][0] + rowA[k][0] +
+                         rowB[j][0] + rowB[k][0]) / 4;
+            dst[i][1] = (rowA[j][1] + rowA[k][1] +
+                         rowB[j][1] + rowB[k][1]) / 4;
+            dst[i][2] = (rowA[j][2] + rowA[k][2] +
+                         rowB[j][2] + rowB[k][2]) / 4;
+            dst[i][3] = (rowA[j][3] + rowA[k][3] +
+                         rowB[j][3] + rowB[k][3]) / 4;
+         }
+      }
+      return;
+   case MESA_FORMAT_RGB:
+      {
+         GLuint i, j, k;
+         const GLchan (*rowA)[3] = (const GLchan (*)[3]) srcRowA;
+         const GLchan (*rowB)[3] = (const GLchan (*)[3]) srcRowB;
+         GLchan (*dst)[3] = (GLchan (*)[3]) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i][0] = (rowA[j][0] + rowA[k][0] +
+                         rowB[j][0] + rowB[k][0]) / 4;
+            dst[i][1] = (rowA[j][1] + rowA[k][1] +
+                         rowB[j][1] + rowB[k][1]) / 4;
+            dst[i][2] = (rowA[j][2] + rowA[k][2] +
+                         rowB[j][2] + rowB[k][2]) / 4;
+         }
+      }
+      return;
+   case MESA_FORMAT_ALPHA:
+   case MESA_FORMAT_LUMINANCE:
+   case MESA_FORMAT_INTENSITY:
+   case MESA_FORMAT_COLOR_INDEX:
+      {
+         GLuint i, j, k;
+         const GLchan *rowA = (const GLchan *) srcRowA;
+         const GLchan *rowB = (const GLchan *) srcRowB;
+         GLchan *dst = (GLchan *) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
+         }
+      }
+      return;
+   case MESA_FORMAT_LUMINANCE_ALPHA:
+      {
+         GLuint i, j, k;
+         const GLchan (*rowA)[2] = (const GLchan (*)[2]) srcRowA;
+         const GLchan (*rowB)[2] = (const GLchan (*)[2]) srcRowB;
+         GLchan (*dst)[2] = (GLchan (*)[2]) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i][0] = (rowA[j][0] + rowA[k][0] +
+                         rowB[j][0] + rowB[k][0]) / 4;
+            dst[i][1] = (rowA[j][1] + rowA[k][1] +
+                         rowB[j][1] + rowB[k][1]) / 4;
+         }
+      }
+      return;
+   case MESA_FORMAT_DEPTH_COMPONENT:
+      {
+         GLuint i, j, k;
+         const GLfloat *rowA = (const GLfloat *) srcRowA;
+         const GLfloat *rowB = (const GLfloat *) srcRowB;
+         GLfloat *dst = (GLfloat *) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) * 0.25F;
+         }
+      }
+      return;
+   /* Begin hardware formats */
+   case MESA_FORMAT_RGBA8888:
+   case MESA_FORMAT_ARGB8888:
+      {
+         GLuint i, j, k;
+         const GLubyte (*rowA)[4] = (const GLubyte (*)[4]) srcRowA;
+         const GLubyte (*rowB)[4] = (const GLubyte (*)[4]) srcRowB;
+         GLubyte (*dst)[4] = (GLubyte (*)[4]) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i][0] = (rowA[j][0] + rowA[k][0] +
+                         rowB[j][0] + rowB[k][0]) / 4;
+            dst[i][1] = (rowA[j][1] + rowA[k][1] +
+                         rowB[j][1] + rowB[k][1]) / 4;
+            dst[i][2] = (rowA[j][2] + rowA[k][2] +
+                         rowB[j][2] + rowB[k][2]) / 4;
+            dst[i][3] = (rowA[j][3] + rowA[k][3] +
+                         rowB[j][3] + rowB[k][3]) / 4;
+         }
+      }
+      return;
+   case MESA_FORMAT_RGB888:
+      {
+         GLuint i, j, k;
+         const GLubyte (*rowA)[3] = (const GLubyte (*)[3]) srcRowA;
+         const GLubyte (*rowB)[3] = (const GLubyte (*)[3]) srcRowB;
+         GLubyte (*dst)[3] = (GLubyte (*)[3]) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i][0] = (rowA[j][0] + rowA[k][0] +
+                         rowB[j][0] + rowB[k][0]) / 4;
+            dst[i][1] = (rowA[j][1] + rowA[k][1] +
+                         rowB[j][1] + rowB[k][1]) / 4;
+            dst[i][2] = (rowA[j][2] + rowA[k][2] +
+                         rowB[j][2] + rowB[k][2]) / 4;
+         }
+      }
+      return;
+   case MESA_FORMAT_RGB565:
+      {
+         GLuint i, j, k;
+         const GLushort *rowA = (const GLushort *) srcRowA;
+         const GLushort *rowB = (const GLushort *) srcRowB;
+         GLushort *dst = (GLushort *) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            const GLint rowAr0 = rowA[j] & 0x1f;
+            const GLint rowAr1 = rowA[k] & 0x1f;
+            const GLint rowBr0 = rowB[j] & 0x1f;
+            const GLint rowBr1 = rowB[k] & 0x1f;
+            const GLint rowAg0 = (rowA[j] >> 5) & 0x3f;
+            const GLint rowAg1 = (rowA[k] >> 5) & 0x3f;
+            const GLint rowBg0 = (rowB[j] >> 5) & 0x3f;
+            const GLint rowBg1 = (rowB[k] >> 5) & 0x3f;
+            const GLint rowAb0 = (rowA[j] >> 11) & 0x1f;
+            const GLint rowAb1 = (rowA[k] >> 11) & 0x1f;
+            const GLint rowBb0 = (rowB[j] >> 11) & 0x1f;
+            const GLint rowBb1 = (rowB[k] >> 11) & 0x1f;
+            const GLint red   = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 4;
+            const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 4;
+            const GLint blue  = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 4;
+            dst[i] = (blue << 11) | (green << 5) | red;
+         }
+      }
+      return;
+   case MESA_FORMAT_ARGB4444:
+      {
+         GLuint i, j, k;
+         const GLushort *rowA = (const GLushort *) srcRowA;
+         const GLushort *rowB = (const GLushort *) srcRowB;
+         GLushort *dst = (GLushort *) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            const GLint rowAr0 = rowA[j] & 0xf;
+            const GLint rowAr1 = rowA[k] & 0xf;
+            const GLint rowBr0 = rowB[j] & 0xf;
+            const GLint rowBr1 = rowB[k] & 0xf;
+            const GLint rowAg0 = (rowA[j] >> 4) & 0xf;
+            const GLint rowAg1 = (rowA[k] >> 4) & 0xf;
+            const GLint rowBg0 = (rowB[j] >> 4) & 0xf;
+            const GLint rowBg1 = (rowB[k] >> 4) & 0xf;
+            const GLint rowAb0 = (rowA[j] >> 8) & 0xf;
+            const GLint rowAb1 = (rowA[k] >> 8) & 0xf;
+            const GLint rowBb0 = (rowB[j] >> 8) & 0xf;
+            const GLint rowBb1 = (rowB[k] >> 8) & 0xf;
+            const GLint rowAa0 = (rowA[j] >> 12) & 0xf;
+            const GLint rowAa1 = (rowA[k] >> 12) & 0xf;
+            const GLint rowBa0 = (rowB[j] >> 12) & 0xf;
+            const GLint rowBa1 = (rowB[k] >> 12) & 0xf;
+            const GLint red   = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 4;
+            const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 4;
+            const GLint blue  = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 4;
+            const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 4;
+            dst[i] = (alpha << 12) | (blue << 8) | (green << 4) | red;
+         }
+      }
+      return;
+   case MESA_FORMAT_ARGB1555:
+      {
+         GLuint i, j, k;
+         const GLushort *rowA = (const GLushort *) srcRowA;
+         const GLushort *rowB = (const GLushort *) srcRowB;
+         GLushort *dst = (GLushort *) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            const GLint rowAr0 = rowA[j] & 0x1f;
+            const GLint rowAr1 = rowA[k] & 0x1f;
+            const GLint rowBr0 = rowB[j] & 0x1f;
+            const GLint rowBr1 = rowB[k] & 0xf;
+            const GLint rowAg0 = (rowA[j] >> 5) & 0x1f;
+            const GLint rowAg1 = (rowA[k] >> 5) & 0x1f;
+            const GLint rowBg0 = (rowB[j] >> 5) & 0x1f;
+            const GLint rowBg1 = (rowB[k] >> 5) & 0x1f;
+            const GLint rowAb0 = (rowA[j] >> 10) & 0x1f;
+            const GLint rowAb1 = (rowA[k] >> 10) & 0x1f;
+            const GLint rowBb0 = (rowB[j] >> 10) & 0x1f;
+            const GLint rowBb1 = (rowB[k] >> 10) & 0x1f;
+            const GLint rowAa0 = (rowA[j] >> 15) & 0x1;
+            const GLint rowAa1 = (rowA[k] >> 15) & 0x1;
+            const GLint rowBa0 = (rowB[j] >> 15) & 0x1;
+            const GLint rowBa1 = (rowB[k] >> 15) & 0x1;
+            const GLint red   = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 4;
+            const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 4;
+            const GLint blue  = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 4;
+            const GLint alpha = (rowAa0 + rowAa1 + rowBa0 + rowBa1) >> 4;
+            dst[i] = (alpha << 15) | (blue << 10) | (green << 5) | red;
+         }
+      }
+      return;
+   case MESA_FORMAT_AL88:
+      {
+         GLuint i, j, k;
+         const GLubyte (*rowA)[2] = (const GLubyte (*)[2]) srcRowA;
+         const GLubyte (*rowB)[2] = (const GLubyte (*)[2]) srcRowB;
+         GLubyte (*dst)[2] = (GLubyte (*)[2]) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i][0] = (rowA[j][0] + rowA[k][0] +
+                         rowB[j][0] + rowB[k][0]) >> 2;
+            dst[i][1] = (rowA[j][1] + rowA[k][1] +
+                         rowB[j][1] + rowB[k][1]) >> 2;
+         }
+      }
+      return;
+   case MESA_FORMAT_RGB332:
+      {
+         GLuint i, j, k;
+         const GLubyte *rowA = (const GLubyte *) srcRowA;
+         const GLubyte *rowB = (const GLubyte *) srcRowB;
+         GLubyte *dst = (GLubyte *) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            const GLint rowAr0 = rowA[j] & 0x3;
+            const GLint rowAr1 = rowA[k] & 0x3;
+            const GLint rowBr0 = rowB[j] & 0x3;
+            const GLint rowBr1 = rowB[k] & 0x3;
+            const GLint rowAg0 = (rowA[j] >> 2) & 0x7;
+            const GLint rowAg1 = (rowA[k] >> 2) & 0x7;
+            const GLint rowBg0 = (rowB[j] >> 2) & 0x7;
+            const GLint rowBg1 = (rowB[k] >> 2) & 0x7;
+            const GLint rowAb0 = (rowA[j] >> 5) & 0x7;
+            const GLint rowAb1 = (rowA[k] >> 5) & 0x7;
+            const GLint rowBb0 = (rowB[j] >> 5) & 0x7;
+            const GLint rowBb1 = (rowB[k] >> 5) & 0x7;
+            const GLint red   = (rowAr0 + rowAr1 + rowBr0 + rowBr1) >> 4;
+            const GLint green = (rowAg0 + rowAg1 + rowBg0 + rowBg1) >> 4;
+            const GLint blue  = (rowAb0 + rowAb1 + rowBb0 + rowBb1) >> 4;
+            dst[i] = (blue << 5) | (green << 2) | red;
+         }
+      }
+      return;
+   case MESA_FORMAT_A8:
+   case MESA_FORMAT_L8:
+   case MESA_FORMAT_I8:
+   case MESA_FORMAT_CI8:
+      {
+         GLuint i, j, k;
+         const GLubyte *rowA = (const GLubyte *) srcRowA;
+         const GLubyte *rowB = (const GLubyte *) srcRowB;
+         GLubyte *dst = (GLubyte *) dstRow;
+         for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+              i++, j += colStride, k += colStride) {
+            dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) >> 2;
+         }
+      }
+      return;
+   default:
+      _mesa_problem(NULL, "bad format in do_row()");
+   }
+}
+
+
+/*
+ * These functions generate a 1/2-size mipmap image from a source image.
+ * Texture borders are handled by copying or averaging the source image's
+ * border texels, depending on the scale-down factor.
+ */
+
+static void
+make_1d_mipmap(const struct gl_texture_format *format, GLint border,
+               GLint srcWidth, const GLubyte *srcPtr,
+               GLint dstWidth, GLubyte *dstPtr)
+{
+   const GLint bpt = format->TexelBytes;
+   const GLubyte *src;
+   GLubyte *dst;
+
+   /* skip the border pixel, if any */
+   src = srcPtr + border * bpt;
+   dst = dstPtr + border * bpt;
+
+   /* we just duplicate the input row, kind of hack, saves code */
+   do_row(format, srcWidth - 2 * border, src, src,
+          dstWidth - 2 * border, dst);
+
+   if (border) {
+      /* copy left-most pixel from source */
+      MEMCPY(dstPtr, srcPtr, bpt);
+      /* copy right-most pixel from source */
+      MEMCPY(dstPtr + (dstWidth - 1) * bpt,
+             srcPtr + (srcWidth - 1) * bpt,
+             bpt);
+   }
+}
+
+
+static void
+make_2d_mipmap(const struct gl_texture_format *format, GLint border,
+               GLint srcWidth, GLint srcHeight, const GLubyte *srcPtr,
+               GLint dstWidth, GLint dstHeight, GLubyte *dstPtr)
+{
+   const GLint bpt = format->TexelBytes;
+   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
+   const GLint dstWidthNB = dstWidth - 2 * border;
+   const GLint dstHeightNB = dstHeight - 2 * border;
+   const GLint srcRowStride = bpt * srcWidth;
+   const GLint dstRowStride = bpt * dstWidth;
+   const GLubyte *srcA, *srcB;
+   GLubyte *dst;
+   GLint row, colStride;
+
+   colStride = (srcWidth == dstWidth) ? 1 : 2;
+
+   /* Compute src and dst pointers, skipping any border */
+   srcA = srcPtr + border * ((srcWidth + 1) * bpt);
+   if (srcHeight > 1)
+      srcB = srcA + srcRowStride;
+   else
+      srcB = srcA;
+   dst = dstPtr + border * ((dstWidth + 1) * bpt);
+
+   for (row = 0; row < dstHeightNB; row++) {
+      do_row(format, srcWidthNB, srcA, srcB,
+             dstWidthNB, dst);
+      srcA += 2 * srcRowStride;
+      srcB += 2 * srcRowStride;
+      dst += dstRowStride;
+   }
+
+   /* This is ugly but probably won't be used much */
+   if (border > 0) {
+      /* fill in dest border */
+      /* lower-left border pixel */
+      MEMCPY(dstPtr, srcPtr, bpt);
+      /* lower-right border pixel */
+      MEMCPY(dstPtr + (dstWidth - 1) * bpt,
+             srcPtr + (srcWidth - 1) * bpt, bpt);
+      /* upper-left border pixel */
+      MEMCPY(dstPtr + dstWidth * (dstHeight - 1) * bpt,
+             srcPtr + srcWidth * (srcHeight - 1) * bpt, bpt);
+      /* upper-right border pixel */
+      MEMCPY(dstPtr + (dstWidth * dstHeight - 1) * bpt,
+             srcPtr + (srcWidth * srcHeight - 1) * bpt, bpt);
+      /* lower border */
+      do_row(format, srcWidthNB,
+             srcPtr + bpt,
+             srcPtr + bpt,
+             dstWidthNB, dstPtr + bpt);
+      /* upper border */
+      do_row(format, srcWidthNB,
+             srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
+             srcPtr + (srcWidth * (srcHeight - 1) + 1) * bpt,
+             dstWidthNB,
+             dstPtr + (dstWidth * (dstHeight - 1) + 1) * bpt);
+      /* left and right borders */
+      if (srcHeight == dstHeight) {
+         /* copy border pixel from src to dst */
+         for (row = 1; row < srcHeight; row++) {
+            MEMCPY(dstPtr + dstWidth * row * bpt,
+                   srcPtr + srcWidth * row * bpt, bpt);
+            MEMCPY(dstPtr + (dstWidth * row + dstWidth - 1) * bpt,
+                   srcPtr + (srcWidth * row + srcWidth - 1) * bpt, bpt);
+         }
+      }
+      else {
+         /* average two src pixels each dest pixel */
+         for (row = 0; row < dstHeightNB; row += 2) {
+            do_row(format, 1,
+                   srcPtr + (srcWidth * (row * 2 + 1)) * bpt,
+                   srcPtr + (srcWidth * (row * 2 + 2)) * bpt,
+                   1, dstPtr + (dstWidth * row + 1) * bpt);
+            do_row(format, 1,
+                   srcPtr + (srcWidth * (row * 2 + 1) + srcWidth - 1) * bpt,
+                   srcPtr + (srcWidth * (row * 2 + 2) + srcWidth - 1) * bpt,
+                   1, dstPtr + (dstWidth * row + 1 + dstWidth - 1) * bpt);
+         }
+      }
+   }
+}
+
+
+static void
+make_3d_mipmap(const struct gl_texture_format *format, GLint border,
+               GLint srcWidth, GLint srcHeight, GLint srcDepth,
+               const GLubyte *srcPtr,
+               GLint dstWidth, GLint dstHeight, GLint dstDepth,
+               GLubyte *dstPtr)
+{
+   const GLint bpt = format->TexelBytes;
+   const GLint srcWidthNB = srcWidth - 2 * border;  /* sizes w/out border */
+   const GLint srcDepthNB = srcDepth - 2 * border;
+   const GLint dstWidthNB = dstWidth - 2 * border;
+   const GLint dstHeightNB = dstHeight - 2 * border;
+   const GLint dstDepthNB = dstDepth - 2 * border;
+   GLvoid *tmpRowA, *tmpRowB;
+   GLint img, row;
+   GLint bytesPerSrcImage, bytesPerDstImage;
+   GLint bytesPerSrcRow, bytesPerDstRow;
+   GLint srcImageOffset, srcRowOffset;
+
+   (void) srcDepthNB; /* silence warnings */
+
+   /* Need two temporary row buffers */
+   tmpRowA = MALLOC(srcWidth * bpt);
+   if (!tmpRowA)
+      return;
+   tmpRowB = MALLOC(srcWidth * bpt);
+   if (!tmpRowB) {
+      FREE(tmpRowA);
+      return;
+   }
+
+   bytesPerSrcImage = srcWidth * srcHeight * bpt;
+   bytesPerDstImage = dstWidth * dstHeight * bpt;
+
+   bytesPerSrcRow = srcWidth * bpt;
+   bytesPerDstRow = dstWidth * bpt;
+
+   /* Offset between adjacent src images to be averaged together */
+   srcImageOffset = (srcDepth == dstDepth) ? 0 : bytesPerSrcImage;
+
+   /* Offset between adjacent src rows to be averaged together */
+   srcRowOffset = (srcHeight == dstHeight) ? 0 : srcWidth * bpt;
+
+   /*
+    * Need to average together up to 8 src pixels for each dest pixel.
+    * Break that down into 3 operations:
+    *   1. take two rows from source image and average them together.
+    *   2. take two rows from next source image and average them together.
+    *   3. take the two averaged rows and average them for the final dst row.
+    */
+
+   /*
+   printf("mip3d %d x %d x %d  ->  %d x %d x %d\n",
+          srcWidth, srcHeight, srcDepth, dstWidth, dstHeight, dstDepth);
+   */
+
+   for (img = 0; img < dstDepthNB; img++) {
+      /* first source image pointer, skipping border */
+      const GLubyte *imgSrcA = srcPtr
+         + (bytesPerSrcImage + bytesPerSrcRow + border) * bpt * border
+         + img * (bytesPerSrcImage + srcImageOffset);
+      /* second source image pointer, skipping border */
+      const GLubyte *imgSrcB = imgSrcA + srcImageOffset;
+      /* address of the dest image, skipping border */
+      GLubyte *imgDst = dstPtr
+         + (bytesPerDstImage + bytesPerDstRow + border) * bpt * border
+         + img * bytesPerDstImage;
+
+      /* setup the four source row pointers and the dest row pointer */
+      const GLubyte *srcImgARowA = imgSrcA;
+      const GLubyte *srcImgARowB = imgSrcA + srcRowOffset;
+      const GLubyte *srcImgBRowA = imgSrcB;
+      const GLubyte *srcImgBRowB = imgSrcB + srcRowOffset;
+      GLubyte *dstImgRow = imgDst;
+
+      for (row = 0; row < dstHeightNB; row++) {
+         /* Average together two rows from first src image */
+         do_row(format, srcWidthNB, srcImgARowA, srcImgARowB,
+                srcWidthNB, tmpRowA);
+         /* Average together two rows from second src image */
+         do_row(format, srcWidthNB, srcImgBRowA, srcImgBRowB,
+                srcWidthNB, tmpRowB);
+         /* Average together the temp rows to make the final row */
+         do_row(format, srcWidthNB, tmpRowA, tmpRowB,
+                dstWidthNB, dstImgRow);
+         /* advance to next rows */
+         srcImgARowA += bytesPerSrcRow + srcRowOffset;
+         srcImgARowB += bytesPerSrcRow + srcRowOffset;
+         srcImgBRowA += bytesPerSrcRow + srcRowOffset;
+         srcImgBRowB += bytesPerSrcRow + srcRowOffset;
+         dstImgRow += bytesPerDstRow;
+      }
+   }
+
+   FREE(tmpRowA);
+   FREE(tmpRowB);
+
+   /* Luckily we can leverage the make_2d_mipmap() function here! */
+   if (border > 0) {
+      /* do front border image */
+      make_2d_mipmap(format, 1, srcWidth, srcHeight, srcPtr,
+                     dstWidth, dstHeight, dstPtr);
+      /* do back border image */
+      make_2d_mipmap(format, 1, srcWidth, srcHeight,
+                     srcPtr + bytesPerSrcImage * (srcDepth - 1),
+                     dstWidth, dstHeight,
+                     dstPtr + bytesPerDstImage * (dstDepth - 1));
+      /* do four remaining border edges that span the image slices */
+      if (srcDepth == dstDepth) {
+         /* just copy border pixels from src to dst */
+         for (img = 0; img < dstDepthNB; img++) {
+            const GLubyte *src;
+            GLubyte *dst;
+
+            /* do border along [img][row=0][col=0] */
+            src = srcPtr + (img + 1) * bytesPerSrcImage;
+            dst = dstPtr + (img + 1) * bytesPerDstImage;
+            MEMCPY(dst, src, bpt);
+
+            /* do border along [img][row=dstHeight-1][col=0] */
+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+                         + (srcHeight - 1) * bytesPerSrcRow;
+            dst = dstPtr + (img + 1) * bytesPerDstImage
+                         + (dstHeight - 1) * bytesPerDstRow;
+            MEMCPY(dst, src, bpt);
+
+            /* do border along [img][row=0][col=dstWidth-1] */
+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+                         + (srcWidth - 1) * bpt;
+            dst = dstPtr + (img + 1) * bytesPerDstImage
+                         + (dstWidth - 1) * bpt;
+            MEMCPY(dst, src, bpt);
+
+            /* do border along [img][row=dstHeight-1][col=dstWidth-1] */
+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+                         + (bytesPerSrcImage - bpt);
+            dst = dstPtr + (img + 1) * bytesPerDstImage
+                         + (bytesPerDstImage - bpt);
+            MEMCPY(dst, src, bpt);
+         }
+      }
+      else {
+         /* average border pixels from adjacent src image pairs */
+         ASSERT(srcDepthNB == 2 * dstDepthNB);
+         for (img = 0; img < dstDepthNB; img++) {
+            const GLubyte *src;
+            GLubyte *dst;
+
+            /* do border along [img][row=0][col=0] */
+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage;
+            dst = dstPtr + (img + 1) * bytesPerDstImage;
+            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+
+            /* do border along [img][row=dstHeight-1][col=0] */
+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+                         + (srcHeight - 1) * bytesPerSrcRow;
+            dst = dstPtr + (img + 1) * bytesPerDstImage
+                         + (dstHeight - 1) * bytesPerDstRow;
+            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+
+            /* do border along [img][row=0][col=dstWidth-1] */
+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+                         + (srcWidth - 1) * bpt;
+            dst = dstPtr + (img + 1) * bytesPerDstImage
+                         + (dstWidth - 1) * bpt;
+            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+
+            /* do border along [img][row=dstHeight-1][col=dstWidth-1] */
+            src = srcPtr + (img * 2 + 1) * bytesPerSrcImage
+                         + (bytesPerSrcImage - bpt);
+            dst = dstPtr + (img + 1) * bytesPerDstImage
+                         + (bytesPerDstImage - bpt);
+            do_row(format, 1, src, src + srcImageOffset, 1, dst);
+         }
+      }
+   }
+}
+
+
+/*
+ * For GL_SGIX_generate_mipmap:
+ * Generate a complete set of mipmaps from texObj's base-level image.
+ * Stop at texObj's MaxLevel or when we get to the 1x1 texture.
+ */
+void
+_mesa_generate_mipmap(GLcontext *ctx, GLenum target,
+                      const struct gl_texture_unit *texUnit,
+                      struct gl_texture_object *texObj)
+{
+   GLint level;
+   GLint maxLevels = 0;
+
+   ASSERT(texObj);
+   ASSERT(texObj->Image[texObj->BaseLevel]);
+
+   switch (texObj->Target) {
+   case GL_TEXTURE_1D:
+      maxLevels = ctx->Const.MaxTextureLevels;
+      break;
+   case GL_TEXTURE_2D:
+      maxLevels = ctx->Const.MaxTextureLevels;
+      break;
+   case GL_TEXTURE_3D:
+      maxLevels = ctx->Const.Max3DTextureLevels;
+      break;
+   case GL_TEXTURE_CUBE_MAP_ARB:
+      maxLevels = ctx->Const.MaxCubeTextureLevels;
+      break;
+   case GL_TEXTURE_RECTANGLE_NV:
+      maxLevels = 1;
+      break;
+   default:
+      _mesa_problem(ctx,
+                    "Bad texture object dimension in _mesa_generate_mipmaps");
+      return;
+   }
+
+   for (level = texObj->BaseLevel; level < texObj->MaxLevel
+           && level < maxLevels - 1; level++) {
+      /* generate image[level+1] from image[level] */
+      const struct gl_texture_image *srcImage;
+      struct gl_texture_image *dstImage;
+      GLint srcWidth, srcHeight, srcDepth;
+      GLint dstWidth, dstHeight, dstDepth;
+      GLint border, bytesPerTexel;
+
+      srcImage = texObj->Image[level];
+      ASSERT(srcImage);
+      srcWidth = srcImage->Width;
+      srcHeight = srcImage->Height;
+      srcDepth = srcImage->Depth;
+      border = srcImage->Border;
+      bytesPerTexel = srcImage->TexFormat->TexelBytes;
+
+      /* compute next (level+1) image size */
+      if (srcWidth - 2 * border > 1) {
+         dstWidth = (srcWidth - 2 * border) / 2 + 2 * border;
+      }
+      else {
+         dstWidth = srcWidth; /* can't go smaller */
+      }
+      if (srcHeight - 2 * border > 1) {
+         dstHeight = (srcHeight - 2 * border) / 2 + 2 * border;
+      }
+      else {
+         dstHeight = srcHeight; /* can't go smaller */
+      }
+      if (srcDepth - 2 * border > 1) {
+         dstDepth = (srcDepth - 2 * border) / 2 + 2 * border;
+      }
+      else {
+         dstDepth = srcDepth; /* can't go smaller */
+      }
+
+      if (dstWidth == srcWidth &&
+          dstHeight == srcHeight &&
+          dstDepth == srcDepth) {
+         /* all done */
+         return;
+      }
+
+      /* get dest gl_texture_image */
+      dstImage = _mesa_select_tex_image(ctx, texUnit, target, level+1);
+      if (!dstImage) {
+         dstImage = _mesa_alloc_texture_image();
+         if (!dstImage) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
+            return;
+         }
+         _mesa_set_tex_image(texObj, target, level + 1, dstImage);
+      }
+
+      /* Free old image data */
+      if (dstImage->Data)
+         MESA_PBUFFER_FREE(dstImage->Data);
+
+      /* initialize new image */
+      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,
+                                 dstDepth, border, srcImage->Format);
+      dstImage->DriverData = NULL;
+      dstImage->TexFormat = srcImage->TexFormat;
+      dstImage->FetchTexel = srcImage->FetchTexel;
+      ASSERT(dstImage->TexFormat);
+      ASSERT(dstImage->FetchTexel);
+
+      ASSERT(dstWidth * dstHeight * dstDepth * bytesPerTexel > 0);
+
+      /* alloc new image buffer */
+      dstImage->Data = MESA_PBUFFER_ALLOC(dstWidth * dstHeight * dstDepth
+                                          * bytesPerTexel);
+      if (!dstImage->Data) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
+         return;
+      }
+
+      /*
+       * We use simple 2x2 averaging to compute the next mipmap level.
+       */
+      switch (target) {
+      case GL_TEXTURE_1D:
+         make_1d_mipmap(srcImage->TexFormat, border,
+                        srcWidth, (const GLubyte *) srcImage->Data,
+                        dstWidth, (GLubyte *) dstImage->Data);
+         break;
+      case GL_TEXTURE_2D:
+      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
+      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
+      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
+         make_2d_mipmap(srcImage->TexFormat, border,
+                        srcWidth, srcHeight, (const GLubyte *) srcImage->Data,
+                        dstWidth, dstHeight, (GLubyte *) dstImage->Data);
+         break;
+      case GL_TEXTURE_3D:
+         make_3d_mipmap(srcImage->TexFormat, border,
+                        srcWidth, srcHeight, srcDepth,
+                        (const GLubyte *) srcImage->Data,
+                        dstWidth, dstHeight, dstDepth,
+                        (GLubyte *) dstImage->Data);
+         break;
+      case GL_TEXTURE_RECTANGLE_NV:
+         /* no mipmaps, do nothing */
+         break;
+      default:
+         _mesa_problem(ctx, "bad dimensions in _mesa_generate_mipmaps");
+         return;
+      }
+   } /* loop over tex levels */
+}
Index: xc/extras/Mesa/src/texstore.h
diff -u /dev/null xc/extras/Mesa/src/texstore.h:1.2
--- /dev/null	Thu Feb 27 12:15:43 2003
+++ xc/extras/Mesa/src/texstore.h	Mon Dec 16 11:18:27 2002
@@ -0,0 +1,155 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Authors:
+ *   Brian Paul
+ */
+
+
+#ifndef TEXSTORE_H
+#define TEXSTORE_H
+
+
+#include "mtypes.h"
+
+
+extern void
+_mesa_transfer_teximage(GLcontext *ctx, GLuint dimensions,
+                        GLenum baseInternalFormat,
+                        const struct gl_texture_format *texDestFormat,
+                        GLvoid *texDestAddr,
+                        GLint srcWidth, GLint srcHeight, GLint srcDepth,
+                        GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
+                        GLint dstRowStride, GLint dstImageStride,
+                        GLenum srcFormat, GLenum srcType,
+                        const GLvoid *srcAddr,
+                        const struct gl_pixelstore_attrib *srcPacking);
+
+
+extern void
+_mesa_store_teximage1d(GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint border,
+                       GLenum format, GLenum type, const GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_store_teximage2d(GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_store_teximage3d(GLcontext *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint depth, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_store_texsubimage1d(GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint width,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_store_texsubimage2d(GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset,
+                          GLint width, GLint height,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_store_texsubimage3d(GLcontext *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset, GLint zoffset,
+                          GLint width, GLint height, GLint depth,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_store_compressed_teximage1d(GLcontext *ctx, GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage);
+
+extern void
+_mesa_store_compressed_teximage2d(GLcontext *ctx, GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage);
+
+extern void
+_mesa_store_compressed_teximage3d(GLcontext *ctx, GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint depth,
+                                  GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_get_compressed_teximage(GLcontext *ctx, GLenum target,
+                              GLint level, void *image,
+                              const struct gl_texture_object *texObj,
+                              struct gl_texture_image *texImage);
+
+
+extern GLboolean
+_mesa_test_proxy_teximage(GLcontext *ctx, GLenum target, GLint level,
+                         GLint internalFormat, GLenum format, GLenum type,
+                         GLint width, GLint height, GLint depth, GLint border);
+
+
+extern void
+_mesa_generate_mipmap(GLcontext *ctx, GLenum target,
+                      const struct gl_texture_unit *texUnit,
+                      struct gl_texture_object *texObj);
+
+#endif
Index: xc/extras/Mesa/src/texture.c
diff -u xc/extras/Mesa/src/texture.c:1.13 xc/extras/Mesa/src/texture.c:removed
--- xc/extras/Mesa/src/texture.c:1.13	Tue May  1 17:36:45 2001
+++ xc/extras/Mesa/src/texture.c	Thu Feb 27 12:15:44 2003
@@ -1,2779 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4.1
- *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "macros.h"
-#include "mmath.h"
-#include "mem.h"
-#include "pb.h"
-#include "teximage.h"
-#include "texture.h"
-#include "types.h"
-#include "xform.h"
-#endif
-
-
-/***********************************************************************
- * Automatic texture coordinate generation (texgen) code.
- */
-
-static GLuint all_bits[5] = {
-   0,
-   VEC_SIZE_1,
-   VEC_SIZE_2,
-   VEC_SIZE_3,
-   VEC_SIZE_4,
-};
-
-
-static texgen_func texgen_generic_tab[4];
-static texgen_func texgen_reflection_map_nv_tab[4];
-static texgen_func texgen_normal_map_nv_tab[4];
-static texgen_func texgen_sphere_map_tab[4];
-
-
-typedef void (*build_m_func)(GLfloat f[][3],
-			     GLfloat m[],
-			     const GLvector3f *normals,
-			     const GLvector4f *coord_vec,
-			     const GLuint flags[],
-			     const GLubyte cullmask[] );
-
-
-typedef void (*build_f_func)( GLfloat *f,
-			      GLuint fstride,
-			      const GLvector3f *normal_vec,
-			      const GLvector4f *coord_vec,
-			      const GLuint flags[],
-			      const GLubyte cullmask[] );
-
-
-/* KW: compacted vs. coindexed normals don't bring any performance
- *     gains to texture generation, but it is still necessary to cope
- *     with the two different formats.
- */
-#define IDX              0
-#define TAG(x)           x
-#define FIRST_NORMAL     normals->start
-#define CUR_NORMAL       (void) normal
-#define NEXT_NORMAL      STRIDE_F(normal, normals->stride)
-#define CHECK            
-#define LOCAL_VARS
-#include "texgen_tmp.h"
-
-
-#define IDX              2
-#define TAG(x)           x##_compacted
-#define FIRST_NORMAL     normals->start
-#define CUR_NORMAL       ((flags[i]&VERT_NORM) ? normal=normal_ptr : normal)
-#define NEXT_NORMAL      STRIDE_F(normal_ptr, normals->stride)
-#define CHECK            
-#define LOCAL_VARS       const GLfloat *normal_ptr = FIRST_NORMAL;
-#include "texgen_tmp.h"
-
-
-#define IDX              1
-#define TAG(x)           x##_masked
-#define FIRST_NORMAL     normals->start
-#define CUR_NORMAL       (void) normal
-#define NEXT_NORMAL      STRIDE_F(normal, normals->stride)
-#define CHECK            if (cullmask[i])
-#define LOCAL_VARS       
-#include "texgen_tmp.h"
-
-#define IDX              3
-#define TAG(x)           x##_compacted_masked
-#define FIRST_NORMAL     normals->start
-#define CUR_NORMAL       ((flags[i]&VERT_NORM) ? normal=normal_ptr : normal)
-#define NEXT_NORMAL      STRIDE_F(normal_ptr, normals->stride)
-#define CHECK            if (cullmask[i])
-#define LOCAL_VARS       const GLfloat *normal_ptr = FIRST_NORMAL;
-#include "texgen_tmp.h"
-
-
-/*
- * End texgen code
- ***********************************************************************
- */
-
-
-
-/*
- * One time inits for texture mapping.
- * Called by one_time_init() in context.c
- */
-void gl_init_texture( void )
-{
-   init_texgen();
-   init_texgen_compacted();
-   init_texgen_masked();
-   init_texgen_compacted_masked();
-}
-
-
-/*
- * After state changes to texturing we call this function to update
- * intermediate and derived state.
- * Called by gl_update_state().
- */
-void gl_update_texture_unit( GLcontext *ctx, struct gl_texture_unit *texUnit )
-{
-   (void) ctx;
-
-   if ((texUnit->Enabled & TEXTURE0_CUBE) && texUnit->CurrentCubeMap->Complete) {
-      texUnit->ReallyEnabled = TEXTURE0_CUBE;
-      texUnit->Current = texUnit->CurrentCubeMap;
-      texUnit->CurrentDimension = 6;
-   }
-   else if ((texUnit->Enabled & TEXTURE0_3D) && texUnit->CurrentD[3]->Complete) {
-      texUnit->ReallyEnabled = TEXTURE0_3D;
-      texUnit->Current = texUnit->CurrentD[3];
-      texUnit->CurrentDimension = 3;
-   }
-   else if ((texUnit->Enabled & TEXTURE0_2D) && texUnit->CurrentD[2]->Complete) {
-      texUnit->ReallyEnabled = TEXTURE0_2D;
-      texUnit->Current = texUnit->CurrentD[2];
-      texUnit->CurrentDimension = 2;
-   }
-   else if ((texUnit->Enabled & TEXTURE0_1D) && texUnit->CurrentD[1]->Complete) {
-      texUnit->ReallyEnabled = TEXTURE0_1D;
-      texUnit->Current = texUnit->CurrentD[1];
-      texUnit->CurrentDimension = 1;
-   }
-   else {
-      if (MESA_VERBOSE & VERBOSE_TEXTURE) {
-	 switch (texUnit->Enabled) {
-	 case TEXTURE0_CUBE:
-	    fprintf(stderr, "Using incomplete cube texture %u\n",
-		    texUnit->CurrentCubeMap->Name);
-	    break;
-	 case TEXTURE0_3D:
-	    fprintf(stderr, "Using incomplete 3d texture %u\n",
-		    texUnit->CurrentD[3]->Name);
-	    break;
-	 case TEXTURE0_2D:
-	    fprintf(stderr, "Using incomplete 2d texture %u\n",
-		    texUnit->CurrentD[2]->Name);
-	    break;
-	 case TEXTURE0_1D:
-	    fprintf(stderr, "Using incomplete 1d texture %u\n",
-		    texUnit->CurrentD[1]->Name);
-	    break;
-	 default:
-	    fprintf(stderr, "Bad value for texUnit->Enabled %x\n",
-		    texUnit->Enabled);
-	    break;
-	 }
-      }
-
-      texUnit->ReallyEnabled = 0;
-      texUnit->Current = NULL;
-      texUnit->CurrentDimension = 0;
-      return;
-   }
-
-   texUnit->GenFlags = 0;
-
-   if (texUnit->TexGenEnabled) {
-      GLuint sz = 0;
-
-      if (texUnit->TexGenEnabled & S_BIT) {
-         sz = 1;
-         texUnit->GenFlags |= texUnit->GenBitS;
-      }
-      if (texUnit->TexGenEnabled & T_BIT) {
-         sz = 2;
-         texUnit->GenFlags |= texUnit->GenBitT;
-      }
-      if (texUnit->TexGenEnabled & Q_BIT) {
-         sz = 3;
-         texUnit->GenFlags |= texUnit->GenBitQ;
-      }
-      if (texUnit->TexGenEnabled & R_BIT) {
-         sz = 4;
-         texUnit->GenFlags |= texUnit->GenBitR;
-      }
-
-      texUnit->TexgenSize = sz;
-      texUnit->Holes = (GLubyte) (all_bits[sz] & ~texUnit->TexGenEnabled);
-      texUnit->func = texgen_generic_tab;
-
-      if (texUnit->TexGenEnabled == (S_BIT|T_BIT|R_BIT)) {
-	 if (texUnit->GenFlags == TEXGEN_REFLECTION_MAP_NV) {
-	    texUnit->func = texgen_reflection_map_nv_tab;
-	 }
-	 else if (texUnit->GenFlags == TEXGEN_NORMAL_MAP_NV) {
-	    texUnit->func = texgen_normal_map_nv_tab;
-	 }
-      }
-      else if (texUnit->TexGenEnabled == (S_BIT|T_BIT) &&
-	       texUnit->GenFlags == TEXGEN_SPHERE_MAP) {
-	 texUnit->func = texgen_sphere_map_tab;
-      }
-   }
-}
-
-
-
-/*
- * Paletted texture sampling.
- * Input:  tObj - the texture object
- *         index - the palette index (8-bit only)
- * Output:  red, green, blue, alpha - the texel color
- */
-static void palette_sample(const struct gl_texture_object *tObj,
-                           GLubyte index, GLubyte rgba[4] )
-{
-   GLcontext *ctx = gl_get_current_context();  /* THIS IS A HACK */
-   GLint i = index;
-   const GLubyte *palette;
-   GLenum format;
-
-   if (ctx->Texture.SharedPalette) {
-      ASSERT(ctx->Texture.Palette.TableType == GL_UNSIGNED_BYTE);
-      palette = (const GLubyte *) ctx->Texture.Palette.Table;
-      format = ctx->Texture.Palette.Format;
-   }
-   else {
-      ASSERT(tObj->Palette.TableType == GL_UNSIGNED_BYTE);
-      palette = (const GLubyte *) tObj->Palette.Table;
-      format = tObj->Palette.Format;
-   }
-
-   switch (format) {
-      case GL_ALPHA:
-         rgba[ACOMP] = palette[index];
-         return;
-      case GL_LUMINANCE:
-      case GL_INTENSITY:
-         rgba[RCOMP] = palette[index];
-         return;
-      case GL_LUMINANCE_ALPHA:
-         rgba[RCOMP] = palette[(index << 1) + 0];
-         rgba[ACOMP] = palette[(index << 1) + 1];
-         return;
-      case GL_RGB:
-         rgba[RCOMP] = palette[index * 3 + 0];
-         rgba[GCOMP] = palette[index * 3 + 1];
-         rgba[BCOMP] = palette[index * 3 + 2];
-         return;
-      case GL_RGBA:
-         rgba[RCOMP] = palette[(i << 2) + 0];
-         rgba[GCOMP] = palette[(i << 2) + 1];
-         rgba[BCOMP] = palette[(i << 2) + 2];
-         rgba[ACOMP] = palette[(i << 2) + 3];
-         return;
-      default:
-         gl_problem(NULL, "Bad palette format in palette_sample");
-   }
-}
-
-
-
-/*
- * These values are used in the fixed-point arithmetic used
- * for linear filtering.
- */
-#define WEIGHT_SCALE 65536.0F
-#define WEIGHT_SHIFT 16
-
-
-/*
- * Used to compute texel locations for linear sampling.
- */
-#define COMPUTE_LINEAR_TEXEL_LOCATIONS(wrapMode, S, U, SIZE, I0, I1)	\
-{									\
-   if (wrapMode == GL_REPEAT) {						\
-      U = S * SIZE - 0.5F;						\
-      I0 = ((GLint) myFloor(U)) & (SIZE - 1);				\
-      I1 = (I0 + 1) & (SIZE - 1);					\
-   }									\
-   else {								\
-      U = S * SIZE;							\
-      if (U < 0.0F)							\
-         U = 0.0F;							\
-      else if (U >= SIZE)						\
-         U = SIZE;							\
-      U -= 0.5F;							\
-      I0 = (GLint) myFloor(U);						\
-      I1 = I0 + 1;							\
-      if (wrapMode == GL_CLAMP_TO_EDGE) {				\
-         if (I0 < 0)							\
-            I0 = 0;							\
-         if (I1 >= SIZE)						\
-            I1 = SIZE - 1;						\
-      }									\
-   }									\
-}
-
-
-/*
- * Used to compute texel location for nearest sampling.
- */
-#define COMPUTE_NEAREST_TEXEL_LOCATION(wrapMode, S, SIZE, I)		\
-{									\
-   if (wrapMode == GL_REPEAT) {						\
-      /* s limited to [0,1) */						\
-      /* i limited to [0,width-1] */					\
-      I = (GLint) (S * SIZE);						\
-      if (S < 0.0F)							\
-         I -= 1;							\
-      I &= (SIZE - 1);							\
-   }									\
-   else if (wrapMode == GL_CLAMP_TO_EDGE) {				\
-      const GLfloat min = 1.0F / (2.0F * SIZE);				\
-      const GLfloat max = 1.0F - min;					\
-      if (S < min)							\
-         I = 0;								\
-      else if (S > max)							\
-         I = SIZE - 1;							\
-      else								\
-         I = (GLint) (S * SIZE);					\
-   }									\
-   else {								\
-      ASSERT(wrapMode == GL_CLAMP);					\
-      /* s limited to [0,1] */						\
-      /* i limited to [0,width-1] */					\
-      if (S <= 0.0F)							\
-         I = 0;								\
-      else if (S >= 1.0F)						\
-         I = SIZE - 1;							\
-      else								\
-         I = (GLint) (S * SIZE);					\
-   }									\
-}
-
-
-/*
- * Compute linear mipmap levels for given lambda.
- */
-#define COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level)	\
-{								\
-   if (lambda < 0.0F)						\
-      lambda = 0.0F;						\
-   else if (lambda > tObj->M)					\
-      lambda = tObj->M;						\
-   level = (GLint) (tObj->BaseLevel + lambda);			\
-}
-
-
-/*
- * Compute nearest mipmap level for given lambda.
- */
-#define COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level)	\
-{								\
-   if (lambda <= 0.5F)						\
-      lambda = 0.0F;						\
-   else if (lambda > tObj->M + 0.4999F)				\
-      lambda = tObj->M + 0.4999F;				\
-   level = (GLint) (tObj->BaseLevel + lambda + 0.5F);		\
-   if (level > tObj->P)						\
-      level = tObj->P;						\
-}
-
-
-
-
-/*
- * Bitflags for texture border color sampling.
- */
-#define I0BIT   1
-#define I1BIT   2
-#define J0BIT   4
-#define J1BIT   8
-#define K0BIT  16
-#define K1BIT  32
-
-
-
-/**********************************************************************/
-/*                    1-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-
-/*
- * Return floor of x, being careful of negative values.
- */
-static GLfloat myFloor(GLfloat x)
-{
-   if (x < 0.0F)
-      return (GLfloat) ((GLint) x - 1);
-   else
-      return (GLfloat) (GLint) x;
-}
-
-
-/*
- * Return the fractional part of x.
- */
-#define myFrac(x)  ( (x) - myFloor(x) )
-
-
-
-
-/*
- * Given 1-D texture image and an (i) texel column coordinate, return the
- * texel color.
- */
-static void get_1d_texel( const struct gl_texture_object *tObj,
-                          const struct gl_texture_image *img, GLint i,
-                          GLubyte rgba[4] )
-{
-   const GLubyte *texel;
-
-#ifdef DEBUG
-   GLint width = img->Width;
-   assert(i >= 0);
-   assert(i < width);
-#endif
-
-   switch (img->Format) {
-      case GL_COLOR_INDEX:
-         {
-            GLubyte index = img->Data[i];
-            palette_sample(tObj, index, rgba);
-            return;
-         }
-      case GL_ALPHA:
-         rgba[ACOMP] = img->Data[ i ];
-         return;
-      case GL_LUMINANCE:
-      case GL_INTENSITY:
-         rgba[RCOMP] = img->Data[ i ];
-         return;
-      case GL_LUMINANCE_ALPHA:
-         texel = img->Data + i * 2;
-         rgba[RCOMP] = texel[0];
-         rgba[ACOMP] = texel[1];
-         return;
-      case GL_RGB:
-         texel = img->Data + i * 3;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         return;
-      case GL_RGBA:
-         texel = img->Data + i * 4;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         rgba[ACOMP] = texel[3];
-         return;
-      default:
-         gl_problem(NULL, "Bad format in get_1d_texel");
-         return;
-   }
-}
-
-
-
-/*
- * Return the texture sample for coordinate (s) using GL_NEAREST filter.
- */
-static void sample_1d_nearest( const struct gl_texture_object *tObj,
-                               const struct gl_texture_image *img,
-                               GLfloat s, GLubyte rgba[4] )
-{
-   const GLint width = img->Width2;  /* without border, power of two */
-   const GLubyte *texel;
-   GLint i;
-
-   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width, i);
-
-   /* skip over the border, if any */
-   i += img->Border;
-
-   /* Get the texel */
-   switch (img->Format) {
-      case GL_COLOR_INDEX:
-         {
-            GLubyte index = img->Data[i];
-            palette_sample(tObj, index, rgba );
-            return;
-         }
-      case GL_ALPHA:
-         rgba[ACOMP] = img->Data[i];
-         return;
-      case GL_LUMINANCE:
-      case GL_INTENSITY:
-         rgba[RCOMP] = img->Data[i];
-         return;
-      case GL_LUMINANCE_ALPHA:
-         texel = img->Data + i * 2;
-         rgba[RCOMP] = texel[0];
-         rgba[ACOMP] = texel[1];
-         return;
-      case GL_RGB:
-         texel = img->Data + i * 3;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         return;
-      case GL_RGBA:
-         texel = img->Data + i * 4;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         rgba[ACOMP] = texel[3];
-         return;
-      default:
-         gl_problem(NULL, "Bad format in sample_1d_nearest");
-   }
-}
-
-
-
-/*
- * Return the texture sample for coordinate (s) using GL_LINEAR filter.
- */
-static void sample_1d_linear( const struct gl_texture_object *tObj,
-                              const struct gl_texture_image *img,
-                              GLfloat s,
-                              GLubyte rgba[4] )
-{
-   const GLint width = img->Width2;
-   GLint i0, i1;
-   GLfloat u;
-   GLuint useBorderColor;
-
-   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width, i0, i1);
-
-   useBorderColor = 0;
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-   }
-   else {
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-   }
-
-   {
-      const GLfloat a = myFrac(u);
-      /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
-      const GLint w0 = (GLint) ((1.0F-a) * WEIGHT_SCALE + 0.5F);
-      const GLint w1 = (GLint) (      a  * WEIGHT_SCALE + 0.5F);
-
-      GLubyte t0[4], t1[4];  /* texels */
-
-      if (useBorderColor & I0BIT) {
-         COPY_4UBV(t0, tObj->BorderColor);
-      }
-      else {
-         get_1d_texel( tObj, img, i0, t0 );
-      }
-      if (useBorderColor & I1BIT) {
-         COPY_4UBV(t1, tObj->BorderColor);
-      }
-      else {
-         get_1d_texel( tObj, img, i1, t1 );
-      }
-
-      rgba[0] = (GLubyte) ((w0 * t0[0] + w1 * t1[0]) >> WEIGHT_SHIFT);
-      rgba[1] = (GLubyte) ((w0 * t0[1] + w1 * t1[1]) >> WEIGHT_SHIFT);
-      rgba[2] = (GLubyte) ((w0 * t0[2] + w1 * t1[2]) >> WEIGHT_SHIFT);
-      rgba[3] = (GLubyte) ((w0 * t0[3] + w1 * t1[3]) >> WEIGHT_SHIFT);
-   }
-}
-
-
-static void
-sample_1d_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
-                                  GLfloat s, GLfloat lambda,
-                                  GLubyte rgba[4] )
-{
-   GLint level;
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-   sample_1d_nearest( tObj, tObj->Image[level], s, rgba );
-}
-
-
-static void
-sample_1d_linear_mipmap_nearest( const struct gl_texture_object *tObj,
-                                 GLfloat s, GLfloat lambda,
-                                 GLubyte rgba[4] )
-{
-   GLint level;
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-   sample_1d_linear( tObj, tObj->Image[level], s, rgba );
-}
-
-
-
-static void
-sample_1d_nearest_mipmap_linear( const struct gl_texture_object *tObj,
-                                 GLfloat s, GLfloat lambda,
-                                 GLubyte rgba[4] )
-{
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   if (level >= tObj->P) {
-      sample_1d_nearest( tObj, tObj->Image[tObj->P], s, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];
-      const GLfloat f = myFrac(lambda);
-      sample_1d_nearest( tObj, tObj->Image[level  ], s, t0 );
-      sample_1d_nearest( tObj, tObj->Image[level+1], s, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-
-static void
-sample_1d_linear_mipmap_linear( const struct gl_texture_object *tObj,
-                                GLfloat s, GLfloat lambda,
-                                GLubyte rgba[4] )
-{
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   if (level >= tObj->P) {
-      sample_1d_linear( tObj, tObj->Image[tObj->P], s, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];
-      const GLfloat f = myFrac(lambda);
-      sample_1d_linear( tObj, tObj->Image[level  ], s, t0 );
-      sample_1d_linear( tObj, tObj->Image[level+1], s, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-
-static void sample_nearest_1d( const struct gl_texture_object *tObj, GLuint n,
-                               const GLfloat s[], const GLfloat t[],
-                               const GLfloat u[], const GLfloat lambda[],
-                               GLubyte rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
-   (void) t;
-   (void) u;
-   (void) lambda;
-   for (i=0;i<n;i++) {
-      sample_1d_nearest( tObj, image, s[i], rgba[i] );
-   }
-}
-
-
-
-static void sample_linear_1d( const struct gl_texture_object *tObj, GLuint n,
-                              const GLfloat s[], const GLfloat t[],
-                              const GLfloat u[], const GLfloat lambda[],
-                              GLubyte rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
-   (void) t;
-   (void) u;
-   (void) lambda;
-   for (i=0;i<n;i++) {
-      sample_1d_linear( tObj, image, s[i], rgba[i] );
-   }
-}
-
-
-/*
- * Given an (s) texture coordinate and lambda (level of detail) value,
- * return a texture sample.
- *
- */
-static void sample_lambda_1d( const struct gl_texture_object *tObj, GLuint n,
-                              const GLfloat s[], const GLfloat t[],
-                              const GLfloat u[], const GLfloat lambda[],
-                              GLubyte rgba[][4] )
-{
-   GLuint i;
-
-   (void) t;
-   (void) u;
-
-   for (i=0;i<n;i++) {
-      if (lambda[i] > tObj->MinMagThresh) {
-         /* minification */
-         switch (tObj->MinFilter) {
-            case GL_NEAREST:
-               sample_1d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
-               break;
-            case GL_LINEAR:
-               sample_1d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
-               break;
-            case GL_NEAREST_MIPMAP_NEAREST:
-               sample_1d_nearest_mipmap_nearest( tObj, lambda[i], s[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_NEAREST:
-               sample_1d_linear_mipmap_nearest( tObj, s[i], lambda[i], rgba[i] );
-               break;
-            case GL_NEAREST_MIPMAP_LINEAR:
-               sample_1d_nearest_mipmap_linear( tObj, s[i], lambda[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_LINEAR:
-               sample_1d_linear_mipmap_linear( tObj, s[i], lambda[i], rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad min filter in sample_1d_texture");
-               return;
-         }
-      }
-      else {
-         /* magnification */
-         switch (tObj->MagFilter) {
-            case GL_NEAREST:
-               sample_1d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
-               break;
-            case GL_LINEAR:
-               sample_1d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad mag filter in sample_1d_texture");
-               return;
-         }
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*                    2-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-
-/*
- * Given a texture image and an (i,j) integer texel coordinate, return the
- * texel color.
- */
-static void get_2d_texel( const struct gl_texture_object *tObj,
-                          const struct gl_texture_image *img, GLint i, GLint j,
-                          GLubyte rgba[4] )
-{
-   const GLint width = img->Width;    /* includes border */
-   const GLubyte *texel;
-
-#ifdef DEBUG
-   const GLint height = img->Height;  /* includes border */
-   assert(i >= 0);
-   assert(i < width);
-   assert(j >= 0);
-   assert(j < height);
-#endif
-
-   switch (img->Format) {
-      case GL_COLOR_INDEX:
-         {
-            GLubyte index = img->Data[ width *j + i ];
-            palette_sample(tObj, index, rgba );
-            return;
-         }
-      case GL_ALPHA:
-         rgba[ACOMP] = img->Data[ width * j + i ];
-         return;
-      case GL_LUMINANCE:
-      case GL_INTENSITY:
-         rgba[RCOMP] = img->Data[ width * j + i ];
-         return;
-      case GL_LUMINANCE_ALPHA:
-         texel = img->Data + (width * j + i) * 2;
-         rgba[RCOMP] = texel[0];
-         rgba[ACOMP] = texel[1];
-         return;
-      case GL_RGB:
-         texel = img->Data + (width * j + i) * 3;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         return;
-      case GL_RGBA:
-         texel = img->Data + (width * j + i) * 4;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         rgba[ACOMP] = texel[3];
-         return;
-      default:
-         gl_problem(NULL, "Bad format in get_2d_texel");
-   }
-}
-
-
-
-/*
- * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.
- */
-static void sample_2d_nearest( const struct gl_texture_object *tObj,
-                               const struct gl_texture_image *img,
-                               GLfloat s, GLfloat t,
-                               GLubyte rgba[] )
-{
-   const GLint imgWidth = img->Width;  /* includes border */
-   const GLint width = img->Width2;    /* without border, power of two */
-   const GLint height = img->Height2;  /* without border, power of two */
-   const GLubyte *texel;
-   GLint i, j;
-
-   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width,  i);
-   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, t, height, j);
-
-   /* skip over the border, if any */
-   i += img->Border;
-   j += img->Border;
-
-   switch (img->Format) {
-      case GL_COLOR_INDEX:
-         {
-            GLubyte index = img->Data[ j * imgWidth + i ];
-            palette_sample(tObj, index, rgba);
-            return;
-         }
-      case GL_ALPHA:
-         rgba[ACOMP] = img->Data[ j * imgWidth + i ];
-         return;
-      case GL_LUMINANCE:
-      case GL_INTENSITY:
-         rgba[RCOMP] = img->Data[ j * imgWidth + i ];
-         return;
-      case GL_LUMINANCE_ALPHA:
-         texel = img->Data + ((j * imgWidth + i) << 1);
-         rgba[RCOMP] = texel[0];
-         rgba[ACOMP] = texel[1];
-         return;
-      case GL_RGB:
-         texel = img->Data + (j * imgWidth + i) * 3;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         return;
-      case GL_RGBA:
-         texel = img->Data + ((j * imgWidth + i) << 2);
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         rgba[ACOMP] = texel[3];
-         return;
-      default:
-         gl_problem(NULL, "Bad format in sample_2d_nearest");
-   }
-}
-
-
-
-/*
- * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.
- * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.
- */
-static void sample_2d_linear( const struct gl_texture_object *tObj,
-                              const struct gl_texture_image *img,
-                              GLfloat s, GLfloat t,
-                              GLubyte rgba[] )
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   GLint i0, j0, i1, j1;
-   GLuint useBorderColor;
-   GLfloat u, v;
-
-   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width,  i0, i1);
-   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, t, v, height, j0, j1);
-
-   useBorderColor = 0;
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-      j0 += img->Border;
-      j1 += img->Border;
-   }
-   else {
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-   }
-
-   {
-      const GLfloat a = myFrac(u);
-      const GLfloat b = myFrac(v);
-      /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
-      const GLint w00 = (GLint) ((1.0F-a)*(1.0F-b) * WEIGHT_SCALE + 0.5F);
-      const GLint w10 = (GLint) (      a *(1.0F-b) * WEIGHT_SCALE + 0.5F);
-      const GLint w01 = (GLint) ((1.0F-a)*      b  * WEIGHT_SCALE + 0.5F);
-      const GLint w11 = (GLint) (      a *      b  * WEIGHT_SCALE + 0.5F);
-      GLubyte t00[4];
-      GLubyte t10[4];
-      GLubyte t01[4];
-      GLubyte t11[4];
-
-      if (useBorderColor & (I0BIT | J0BIT)) {
-         COPY_4UBV(t00, tObj->BorderColor);
-      }
-      else {
-         get_2d_texel( tObj, img, i0, j0, t00 );
-      }
-      if (useBorderColor & (I1BIT | J0BIT)) {
-         COPY_4UBV(t10, tObj->BorderColor);
-      }
-      else {
-         get_2d_texel( tObj, img, i1, j0, t10 );
-      }
-      if (useBorderColor & (I0BIT | J1BIT)) {
-         COPY_4UBV(t01, tObj->BorderColor);
-      }
-      else {
-         get_2d_texel( tObj, img, i0, j1, t01 );
-      }
-      if (useBorderColor & (I1BIT | J1BIT)) {
-         COPY_4UBV(t11, tObj->BorderColor);
-      }
-      else {
-         get_2d_texel( tObj, img, i1, j1, t11 );
-      }
-
-      rgba[0] = (GLubyte) ((w00 * t00[0] + w10 * t10[0] + w01 * t01[0] + w11 * t11[0]) >> WEIGHT_SHIFT);
-      rgba[1] = (GLubyte) ((w00 * t00[1] + w10 * t10[1] + w01 * t01[1] + w11 * t11[1]) >> WEIGHT_SHIFT);
-      rgba[2] = (GLubyte) ((w00 * t00[2] + w10 * t10[2] + w01 * t01[2] + w11 * t11[2]) >> WEIGHT_SHIFT);
-      rgba[3] = (GLubyte) ((w00 * t00[3] + w10 * t10[3] + w01 * t01[3] + w11 * t11[3]) >> WEIGHT_SHIFT);
-   }
-
-}
-
-
-
-static void
-sample_2d_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
-                                  GLfloat s, GLfloat t, GLfloat lambda,
-                                  GLubyte rgba[4] )
-{
-   GLint level;
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-   sample_2d_nearest( tObj, tObj->Image[level], s, t, rgba );
-}
-
-
-
-static void
-sample_2d_linear_mipmap_nearest( const struct gl_texture_object *tObj,
-                                 GLfloat s, GLfloat t, GLfloat lambda,
-                                 GLubyte rgba[4] )
-{
-   GLint level;
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-   sample_2d_linear( tObj, tObj->Image[level], s, t, rgba );
-}
-
-
-
-static void
-sample_2d_nearest_mipmap_linear( const struct gl_texture_object *tObj,
-                                 GLfloat s, GLfloat t, GLfloat lambda,
-                                 GLubyte rgba[4] )
-{
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   if (level >= tObj->P) {
-      sample_2d_nearest( tObj, tObj->Image[tObj->P], s, t, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];  /* texels */
-      const GLfloat f = myFrac(lambda);
-      sample_2d_nearest( tObj, tObj->Image[level  ], s, t, t0 );
-      sample_2d_nearest( tObj, tObj->Image[level+1], s, t, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-
-static void
-sample_2d_linear_mipmap_linear( const struct gl_texture_object *tObj,
-                                GLfloat s, GLfloat t, GLfloat lambda,
-                                GLubyte rgba[4] )
-{
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   if (level >= tObj->P) {
-      sample_2d_linear( tObj, tObj->Image[tObj->P], s, t, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];  /* texels */
-      const GLfloat f = myFrac(lambda);
-      sample_2d_linear( tObj, tObj->Image[level  ], s, t, t0 );
-      sample_2d_linear( tObj, tObj->Image[level+1], s, t, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-
-static void sample_nearest_2d( const struct gl_texture_object *tObj, GLuint n,
-                               const GLfloat s[], const GLfloat t[],
-                               const GLfloat u[], const GLfloat lambda[],
-                               GLubyte rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
-   (void) u;
-   (void) lambda;
-   for (i=0;i<n;i++) {
-      sample_2d_nearest( tObj, image, s[i], t[i], rgba[i] );
-   }
-}
-
-
-
-static void sample_linear_2d( const struct gl_texture_object *tObj, GLuint n,
-                              const GLfloat s[], const GLfloat t[],
-                              const GLfloat u[], const GLfloat lambda[],
-                              GLubyte rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
-   (void) u;
-   (void) lambda;
-   for (i=0;i<n;i++) {
-      sample_2d_linear( tObj, image, s[i], t[i], rgba[i] );
-   }
-}
-
-
-/*
- * Given an (s,t) texture coordinate and lambda (level of detail) value,
- * return a texture sample.
- */
-static void sample_lambda_2d( const struct gl_texture_object *tObj,
-                              GLuint n,
-                              const GLfloat s[], const GLfloat t[],
-                              const GLfloat u[], const GLfloat lambda[],
-                              GLubyte rgba[][4] )
-{
-   GLuint i;
-   (void) u;
-   for (i=0;i<n;i++) {
-      if (lambda[i] > tObj->MinMagThresh) {
-         /* minification */
-         switch (tObj->MinFilter) {
-            case GL_NEAREST:
-               sample_2d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
-               break;
-            case GL_LINEAR:
-               sample_2d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
-               break;
-            case GL_NEAREST_MIPMAP_NEAREST:
-               sample_2d_nearest_mipmap_nearest( tObj, s[i], t[i], lambda[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_NEAREST:
-               sample_2d_linear_mipmap_nearest( tObj, s[i], t[i], lambda[i], rgba[i] );
-               break;
-            case GL_NEAREST_MIPMAP_LINEAR:
-               sample_2d_nearest_mipmap_linear( tObj, s[i], t[i], lambda[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_LINEAR:
-               sample_2d_linear_mipmap_linear( tObj, s[i], t[i], lambda[i], rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad min filter in sample_2d_texture");
-               return;
-         }
-      }
-      else {
-         /* magnification */
-         switch (tObj->MagFilter) {
-            case GL_NEAREST:
-               sample_2d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
-               break;
-            case GL_LINEAR:
-               sample_2d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad mag filter in sample_2d_texture");
-         }
-      }
-   }
-}
-
-
-/*
- * Optimized 2-D texture sampling:
- *    S and T wrap mode == GL_REPEAT
- *    GL_NEAREST min/mag filter
- *    No border
- *    Format = GL_RGB
- */
-static void opt_sample_rgb_2d( const struct gl_texture_object *tObj,
-                               GLuint n, const GLfloat s[], const GLfloat t[],
-                               const GLfloat u[], const GLfloat lambda[],
-                               GLubyte rgba[][4] )
-{
-   const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
-   const GLfloat width = (GLfloat) img->Width;
-   const GLfloat height = (GLfloat) img->Height;
-   const GLint colMask = img->Width - 1;
-   const GLint rowMask = img->Height - 1;
-   const GLint shift = img->WidthLog2;
-   GLuint k;
-   (void) u;
-   (void) lambda;
-   ASSERT(tObj->WrapS==GL_REPEAT);
-   ASSERT(tObj->WrapT==GL_REPEAT);
-   ASSERT(tObj->MinFilter==GL_NEAREST);
-   ASSERT(tObj->MagFilter==GL_NEAREST);
-   ASSERT(img->Border==0);
-   ASSERT(img->Format==GL_RGB);
-
-   /* NOTE: negative float->int doesn't floor, add 10000 as to work-around */
-   for (k=0;k<n;k++) {
-      GLint i = (GLint) ((s[k] + 10000.0) * width) & colMask;
-      GLint j = (GLint) ((t[k] + 10000.0) * height) & rowMask;
-      GLint pos = (j << shift) | i;
-      GLubyte *texel = img->Data + pos + pos + pos;  /* pos*3 */
-      rgba[k][RCOMP] = texel[0];
-      rgba[k][GCOMP] = texel[1];
-      rgba[k][BCOMP] = texel[2];
-   }
-}
-
-
-/*
- * Optimized 2-D texture sampling:
- *    S and T wrap mode == GL_REPEAT
- *    GL_NEAREST min/mag filter
- *    No border
- *    Format = GL_RGBA
- */
-static void opt_sample_rgba_2d( const struct gl_texture_object *tObj,
-                                GLuint n, const GLfloat s[], const GLfloat t[],
-                                const GLfloat u[], const GLfloat lambda[],
-                                GLubyte rgba[][4] )
-{
-   const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
-   const GLfloat width = (GLfloat) img->Width;
-   const GLfloat height = (GLfloat) img->Height;
-   const GLint colMask = img->Width - 1;
-   const GLint rowMask = img->Height - 1;
-   const GLint shift = img->WidthLog2;
-   GLuint k;
-   (void) u;
-   (void) lambda;
-   ASSERT(tObj->WrapS==GL_REPEAT);
-   ASSERT(tObj->WrapT==GL_REPEAT);
-   ASSERT(tObj->MinFilter==GL_NEAREST);
-   ASSERT(tObj->MagFilter==GL_NEAREST);
-   ASSERT(img->Border==0);
-   ASSERT(img->Format==GL_RGBA);
-
-   /* NOTE: negative float->int doesn't floor, add 10000 as to work-around */
-   for (k=0;k<n;k++) {
-      GLint i = (GLint) ((s[k] + 10000.0) * width) & colMask;
-      GLint j = (GLint) ((t[k] + 10000.0) * height) & rowMask;
-      GLint pos = (j << shift) | i;
-      GLubyte *texel = img->Data + (pos << 2);    /* pos*4 */
-      rgba[k][RCOMP] = texel[0];
-      rgba[k][GCOMP] = texel[1];
-      rgba[k][BCOMP] = texel[2];
-      rgba[k][ACOMP] = texel[3];
-   }
-}
-
-
-
-/**********************************************************************/
-/*                    3-D Texture Sampling Functions                  */
-/**********************************************************************/
-
-/*
- * Given a texture image and an (i,j,k) integer texel coordinate, return the
- * texel color.
- */
-static void get_3d_texel( const struct gl_texture_object *tObj,
-                          const struct gl_texture_image *img,
-                          GLint i, GLint j, GLint k,
-                          GLubyte rgba[4] )
-{
-   const GLint width = img->Width;    /* includes border */
-   const GLint height = img->Height;  /* includes border */
-   const GLint rectarea = width * height;
-   const GLubyte *texel;
-
-#ifdef DEBUG
-   const GLint depth = img->Depth;    /* includes border */
-   assert(i >= 0);
-   assert(i < width);
-   assert(j >= 0);
-   assert(j < height);
-   assert(k >= 0);
-   assert(k < depth);
-#endif
-
-   switch (img->Format) {
-      case GL_COLOR_INDEX:
-         {
-            GLubyte index = img->Data[ rectarea * k +  width * j + i ];
-            palette_sample(tObj, index, rgba );
-            return;
-         }
-      case GL_ALPHA:
-         rgba[ACOMP] = img->Data[ rectarea * k +  width * j + i ];
-         return;
-      case GL_LUMINANCE:
-      case GL_INTENSITY:
-         rgba[RCOMP] = img->Data[ rectarea * k +  width * j + i ];
-         return;
-      case GL_LUMINANCE_ALPHA:
-         texel = img->Data + ( rectarea * k + width * j + i) * 2;
-         rgba[RCOMP] = texel[0];
-         rgba[ACOMP] = texel[1];
-         return;
-      case GL_RGB:
-         texel = img->Data + (rectarea * k + width * j + i) * 3;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         return;
-      case GL_RGBA:
-         texel = img->Data + (rectarea * k + width * j + i) * 4;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         rgba[ACOMP] = texel[3];
-         return;
-      default:
-         gl_problem(NULL, "Bad format in get_3d_texel");
-   }
-}
-
-
-/*
- * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
- */
-static void sample_3d_nearest( const struct gl_texture_object *tObj,
-                               const struct gl_texture_image *img,
-                               GLfloat s, GLfloat t, GLfloat r,
-                               GLubyte rgba[4] )
-{
-   const GLint imgWidth = img->Width;   /* includes border, if any */
-   const GLint imgHeight = img->Height; /* includes border, if any */
-   const GLint width = img->Width2;     /* without border, power of two */
-   const GLint height = img->Height2;   /* without border, power of two */
-   const GLint depth = img->Depth2;     /* without border, power of two */
-   const GLint rectarea = imgWidth * imgHeight;
-   const GLubyte *texel;
-   GLint i, j, k;
-
-   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width,  i);
-   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, t, height, j);
-   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapR, r, depth,  k);
-
-   switch (tObj->Image[0]->Format) {
-      case GL_COLOR_INDEX:
-         {
-            GLubyte index = img->Data[ rectarea * k + j * imgWidth + i ];
-            palette_sample(tObj, index, rgba );
-            return;
-         }
-      case GL_ALPHA:
-         rgba[ACOMP] = img->Data[ rectarea * k + j * imgWidth + i ];
-         return;
-      case GL_LUMINANCE:
-      case GL_INTENSITY:
-         rgba[RCOMP] = img->Data[ rectarea * k + j * imgWidth + i ];
-         return;
-      case GL_LUMINANCE_ALPHA:
-         texel = img->Data + ((rectarea * k + j * imgWidth + i) << 1);
-         rgba[RCOMP] = texel[0];
-         rgba[ACOMP] = texel[1];
-         return;
-      case GL_RGB:
-         texel = img->Data + ( rectarea * k + j * imgWidth + i) * 3;
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         return;
-      case GL_RGBA:
-         texel = img->Data + ((rectarea * k + j * imgWidth + i) << 2);
-         rgba[RCOMP] = texel[0];
-         rgba[GCOMP] = texel[1];
-         rgba[BCOMP] = texel[2];
-         rgba[ACOMP] = texel[3];
-         return;
-      default:
-         gl_problem(NULL, "Bad format in sample_3d_nearest");
-   }
-}
-
-
-
-/*
- * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
- */
-static void sample_3d_linear( const struct gl_texture_object *tObj,
-                              const struct gl_texture_image *img,
-                              GLfloat s, GLfloat t, GLfloat r,
-                              GLubyte rgba[4] )
-{
-   const GLint width = img->Width2;
-   const GLint height = img->Height2;
-   const GLint depth = img->Depth2;
-   GLint i0, j0, k0, i1, j1, k1;
-   GLuint useBorderColor;
-   GLfloat u, v, w;
-
-   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width,  i0, i1);
-   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, t, v, height, j0, j1);
-   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapR, r, w, depth,  k0, k1);
-
-   useBorderColor = 0;
-   if (img->Border) {
-      i0 += img->Border;
-      i1 += img->Border;
-      j0 += img->Border;
-      j1 += img->Border;
-      k0 += img->Border;
-      k1 += img->Border;
-   }
-   else {
-      /* check if sampling texture border color */
-      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
-      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
-      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
-      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
-      if (k0 < 0 || k0 >= depth)   useBorderColor |= K0BIT;
-      if (k1 < 0 || k1 >= depth)   useBorderColor |= K1BIT;
-   }
-
-   {
-      const GLfloat a = myFrac(u);
-      const GLfloat b = myFrac(v);
-      const GLfloat c = myFrac(w);
-      /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
-      GLint w000 = (GLint) ((1.0F-a)*(1.0F-b)*(1.0F-c) * WEIGHT_SCALE + 0.5F);
-      GLint w100 = (GLint) (      a *(1.0F-b)*(1.0F-c) * WEIGHT_SCALE + 0.5F);
-      GLint w010 = (GLint) ((1.0F-a)*      b *(1.0F-c) * WEIGHT_SCALE + 0.5F);
-      GLint w110 = (GLint) (      a *      b *(1.0F-c) * WEIGHT_SCALE + 0.5F);
-      GLint w001 = (GLint) ((1.0F-a)*(1.0F-b)*      c  * WEIGHT_SCALE + 0.5F);
-      GLint w101 = (GLint) (      a *(1.0F-b)*      c  * WEIGHT_SCALE + 0.5F);
-      GLint w011 = (GLint) ((1.0F-a)*      b *      c  * WEIGHT_SCALE + 0.5F);
-      GLint w111 = (GLint) (      a *      b *      c  * WEIGHT_SCALE + 0.5F);
-
-      GLubyte t000[4], t010[4], t001[4], t011[4];
-      GLubyte t100[4], t110[4], t101[4], t111[4];
-
-      if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {
-         COPY_4UBV(t000, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i0, j0, k0, t000 );
-      }
-      if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {
-         COPY_4UBV(t100, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i1, j0, k0, t100 );
-      }
-      if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {
-         COPY_4UBV(t010, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i0, j1, k0, t010 );
-      }
-      if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {
-         COPY_4UBV(t110, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i1, j1, k0, t110 );
-      }
-
-      if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {
-         COPY_4UBV(t001, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i0, j0, k1, t001 );
-      }
-      if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {
-         COPY_4UBV(t101, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i1, j0, k1, t101 );
-      }
-      if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {
-         COPY_4UBV(t011, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i0, j1, k1, t011 );
-      }
-      if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {
-         COPY_4UBV(t111, tObj->BorderColor);
-      }
-      else {
-         get_3d_texel( tObj, img, i1, j1, k1, t111 );
-      }
-
-      rgba[0] = (GLubyte) (
-                 (w000*t000[0] + w010*t010[0] + w001*t001[0] + w011*t011[0] +
-                  w100*t100[0] + w110*t110[0] + w101*t101[0] + w111*t111[0]  )
-                 >> WEIGHT_SHIFT);
-      rgba[1] = (GLubyte) (
-                 (w000*t000[1] + w010*t010[1] + w001*t001[1] + w011*t011[1] +
-                  w100*t100[1] + w110*t110[1] + w101*t101[1] + w111*t111[1] )
-                 >> WEIGHT_SHIFT);
-      rgba[2] = (GLubyte) (
-                 (w000*t000[2] + w010*t010[2] + w001*t001[2] + w011*t011[2] +
-                  w100*t100[2] + w110*t110[2] + w101*t101[2] + w111*t111[2] )
-                 >> WEIGHT_SHIFT);
-      rgba[3] = (GLubyte) (
-                 (w000*t000[3] + w010*t010[3] + w001*t001[3] + w011*t011[3] +
-                  w100*t100[3] + w110*t110[3] + w101*t101[3] + w111*t111[3] )
-                 >> WEIGHT_SHIFT);
-   }
-}
-
-
-
-static void
-sample_3d_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
-                                  GLfloat s, GLfloat t, GLfloat r,
-                                  GLfloat lambda, GLubyte rgba[4] )
-{
-   GLint level;
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-   sample_3d_nearest( tObj, tObj->Image[level], s, t, r, rgba );
-}
-
-
-static void
-sample_3d_linear_mipmap_nearest( const struct gl_texture_object *tObj,
-                                 GLfloat s, GLfloat t, GLfloat r,
-                                 GLfloat lambda, GLubyte rgba[4] )
-{
-   GLint level;
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-   sample_3d_linear( tObj, tObj->Image[level], s, t, r, rgba );
-}
-
-
-static void
-sample_3d_nearest_mipmap_linear( const struct gl_texture_object *tObj,
-                                 GLfloat s, GLfloat t, GLfloat r,
-                                 GLfloat lambda, GLubyte rgba[4] )
-{
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   if (level >= tObj->P) {
-      sample_3d_nearest( tObj, tObj->Image[tObj->P], s, t, r, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];  /* texels */
-      const GLfloat f = myFrac(lambda);
-      sample_3d_nearest( tObj, tObj->Image[level  ], s, t, r, t0 );
-      sample_3d_nearest( tObj, tObj->Image[level+1], s, t, r, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-static void
-sample_3d_linear_mipmap_linear( const struct gl_texture_object *tObj,
-                                GLfloat s, GLfloat t, GLfloat r,
-                                GLfloat lambda, GLubyte rgba[4] )
-{
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   if (level >= tObj->P) {
-      sample_3d_linear( tObj, tObj->Image[tObj->P], s, t, r, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];  /* texels */
-      const GLfloat f = myFrac(lambda);
-      sample_3d_linear( tObj, tObj->Image[level  ], s, t, r, t0 );
-      sample_3d_linear( tObj, tObj->Image[level+1], s, t, r, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-static void sample_nearest_3d( const struct gl_texture_object *tObj, GLuint n,
-                               const GLfloat s[], const GLfloat t[],
-                               const GLfloat u[], const GLfloat lambda[],
-                               GLubyte rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
-   (void) lambda;
-   for (i=0;i<n;i++) {
-      sample_3d_nearest( tObj, image, s[i], t[i], u[i], rgba[i] );
-   }
-}
-
-
-
-static void sample_linear_3d( const struct gl_texture_object *tObj, GLuint n,
-                              const GLfloat s[], const GLfloat t[],
-                              const GLfloat u[], const GLfloat lambda[],
-                              GLubyte rgba[][4] )
-{
-   GLuint i;
-   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
-   (void) lambda;
-   for (i=0;i<n;i++) {
-      sample_3d_linear( tObj, image, s[i], t[i], u[i], rgba[i] );
-   }
-}
-
-
-/*
- * Given an (s,t,r) texture coordinate and lambda (level of detail) value,
- * return a texture sample.
- */
-static void sample_lambda_3d( const struct gl_texture_object *tObj, GLuint n,
-                              const GLfloat s[], const GLfloat t[],
-                              const GLfloat u[], const GLfloat lambda[],
-                              GLubyte rgba[][4] )
-{
-   GLuint i;
-
-   for (i=0;i<n;i++) {
-
-      if (lambda[i] > tObj->MinMagThresh) {
-         /* minification */
-         switch (tObj->MinFilter) {
-            case GL_NEAREST:
-               sample_3d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
-               break;
-            case GL_LINEAR:
-               sample_3d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
-               break;
-            case GL_NEAREST_MIPMAP_NEAREST:
-               sample_3d_nearest_mipmap_nearest( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_NEAREST:
-               sample_3d_linear_mipmap_nearest( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
-               break;
-            case GL_NEAREST_MIPMAP_LINEAR:
-               sample_3d_nearest_mipmap_linear( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_LINEAR:
-               sample_3d_linear_mipmap_linear( tObj, s[i], t[i], u[i], lambda[i], rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad min filterin sample_3d_texture");
-         }
-      }
-      else {
-         /* magnification */
-         switch (tObj->MagFilter) {
-            case GL_NEAREST:
-               sample_3d_nearest( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
-               break;
-            case GL_LINEAR:
-               sample_3d_linear( tObj, tObj->Image[tObj->BaseLevel], s[i], t[i], u[i], rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad mag filter in sample_3d_texture");
-         }
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                Texture Cube Map Sampling Functions                 */
-/**********************************************************************/
-
-/*
- * Choose one of six sides of a texture cube map given the texture
- * coord (rx,ry,rz).  Return pointer to corresponding array of texture
- * images.
- */
-static const struct gl_texture_image **
-choose_cube_face(const struct gl_texture_object *texObj,
-                 GLfloat rx, GLfloat ry, GLfloat rz,
-                 GLfloat *newS, GLfloat *newT)
-{
-/*
-      major axis
-      direction     target                             sc     tc    ma
-      ----------    -------------------------------    ---    ---   ---
-       +rx          TEXTURE_CUBE_MAP_POSITIVE_X_EXT    -rz    -ry   rx
-       -rx          TEXTURE_CUBE_MAP_NEGATIVE_X_EXT    +rz    -ry   rx
-       +ry          TEXTURE_CUBE_MAP_POSITIVE_Y_EXT    +rx    +rz   ry
-       -ry          TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT    +rx    -rz   ry
-       +rz          TEXTURE_CUBE_MAP_POSITIVE_Z_EXT    +rx    -ry   rz
-       -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz
-*/
-   const struct gl_texture_image **imgArray;
-   const GLfloat arx = ABSF(rx),   ary = ABSF(ry),   arz = ABSF(rz);
-   GLfloat sc, tc, ma;
-
-   if (arx > ary && arx > arz) {
-      if (rx >= 0.0F) {
-         imgArray = (const struct gl_texture_image **) texObj->Image;
-         sc = -rz;
-         tc = -ry;
-         ma = arx;
-      }
-      else {
-         imgArray = (const struct gl_texture_image **) texObj->NegX;
-         sc = rz;
-         tc = -ry;
-         ma = arx;
-      }
-   }
-   else if (ary > arx && ary > arz) {
-      if (ry >= 0.0F) {
-         imgArray = (const struct gl_texture_image **) texObj->PosY;
-         sc = rx;
-         tc = rz;
-         ma = ary;
-      }
-      else {
-         imgArray = (const struct gl_texture_image **) texObj->NegY;
-         sc = rx;
-         tc = -rz;
-         ma = ary;
-      }
-   }
-   else {
-      if (rz > 0.0F) {
-         imgArray = (const struct gl_texture_image **) texObj->PosZ;
-         sc = rx;
-         tc = -ry;
-         ma = arz;
-      }
-      else {
-         imgArray = (const struct gl_texture_image **) texObj->NegZ;
-         sc = -rx;
-         tc = -ry;
-         ma = arz;
-      }
-   }
-
-   *newS = ( sc / ma + 1.0F ) * 0.5F;
-   *newT = ( tc / ma + 1.0F ) * 0.5F;
-   return imgArray;
-}
-
-
-static void
-sample_nearest_cube(const struct gl_texture_object *tObj, GLuint n,
-                    const GLfloat s[], const GLfloat t[],
-                    const GLfloat u[], const GLfloat lambda[],
-                    GLubyte rgba[][4])
-{
-   GLuint i;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newS, newT;
-      images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
-      sample_2d_nearest( tObj, images[tObj->BaseLevel], newS, newT, rgba[i] );
-   }
-}
-
-
-static void
-sample_linear_cube(const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat s[], const GLfloat t[],
-                   const GLfloat u[], const GLfloat lambda[],
-                   GLubyte rgba[][4])
-{
-   GLuint i;
-   (void) lambda;
-   for (i = 0; i < n; i++) {
-      const struct gl_texture_image **images;
-      GLfloat newS, newT;
-      images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
-      sample_2d_linear( tObj, images[tObj->BaseLevel], newS, newT, rgba[i] );
-   }
-}
-
-
-static void
-sample_cube_nearest_mipmap_nearest( const struct gl_texture_object *tObj,
-                                    GLfloat s, GLfloat t, GLfloat u,
-                                    GLfloat lambda, GLubyte rgba[4] )
-{
-   const struct gl_texture_image **images;
-   GLfloat newS, newT;
-   GLint level;
-
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-
-   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
-   sample_2d_nearest( tObj, images[level], newS, newT, rgba );
-}
-
-
-static void
-sample_cube_linear_mipmap_nearest( const struct gl_texture_object *tObj,
-                                   GLfloat s, GLfloat t, GLfloat u,
-                                   GLfloat lambda, GLubyte rgba[4] )
-{
-   const struct gl_texture_image **images;
-   GLfloat newS, newT;
-   GLint level;
-
-   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
-
-   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
-   sample_2d_linear( tObj, images[level], newS, newT, rgba );
-}
-
-
-static void
-sample_cube_nearest_mipmap_linear( const struct gl_texture_object *tObj,
-                                   GLfloat s, GLfloat t, GLfloat u,
-                                   GLfloat lambda, GLubyte rgba[4] )
-{
-   const struct gl_texture_image **images;
-   GLfloat newS, newT;
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
-
-   if (level >= tObj->P) {
-      sample_2d_nearest( tObj, images[tObj->P], newS, newT, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];  /* texels */
-      const GLfloat f = myFrac(lambda);
-      sample_2d_nearest( tObj, images[level  ], newS, newT, t0 );
-      sample_2d_nearest( tObj, images[level+1], newS, newT, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-static void
-sample_cube_linear_mipmap_linear( const struct gl_texture_object *tObj,
-                                  GLfloat s, GLfloat t, GLfloat u,
-                                  GLfloat lambda, GLubyte rgba[4] )
-{
-   const struct gl_texture_image **images;
-   GLfloat newS, newT;
-   GLint level;
-
-   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
-
-   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
-
-   if (level >= tObj->P) {
-      sample_2d_linear( tObj, images[tObj->P], newS, newT, rgba );
-   }
-   else {
-      GLubyte t0[4], t1[4];
-      const GLfloat f = myFrac(lambda);
-      sample_2d_linear( tObj, images[level  ], newS, newT, t0 );
-      sample_2d_linear( tObj, images[level+1], newS, newT, t1 );
-      rgba[RCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
-      rgba[GCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
-      rgba[BCOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
-      rgba[ACOMP] = (GLubyte) (GLint) ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
-   }
-}
-
-
-static void
-sample_lambda_cube(const struct gl_texture_object *tObj, GLuint n,
-                   const GLfloat s[], const GLfloat t[],
-                   const GLfloat u[], const GLfloat lambda[],
-                   GLubyte rgba[][4])
-{
-   GLuint i;
-
-   for (i = 0; i < n; i++) {
-      if (lambda[i] > tObj->MinMagThresh) {
-         /* minification */
-         switch (tObj->MinFilter) {
-            case GL_NEAREST:
-               {
-                  const struct gl_texture_image **images;
-                  GLfloat newS, newT;
-                  images = choose_cube_face(tObj, s[i], t[i], u[i],
-                                            &newS, &newT);
-                  sample_2d_nearest( tObj, images[tObj->BaseLevel],
-                                     newS, newT, rgba[i] );
-               }
-               break;
-            case GL_LINEAR:
-               {
-                  const struct gl_texture_image **images;
-                  GLfloat newS, newT;
-                  images = choose_cube_face(tObj, s[i], t[i], u[i],
-                                            &newS, &newT);
-                  sample_2d_linear( tObj, images[tObj->BaseLevel],
-                                    newS, newT, rgba[i] );
-               }
-               break;
-            case GL_NEAREST_MIPMAP_NEAREST:
-               sample_cube_nearest_mipmap_nearest( tObj, s[i], t[i], u[i],
-                                                   lambda[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_NEAREST:
-               sample_cube_linear_mipmap_nearest( tObj, s[i], t[i], u[i],
-                                                  lambda[i], rgba[i] );
-               break;
-            case GL_NEAREST_MIPMAP_LINEAR:
-               sample_cube_nearest_mipmap_linear( tObj, s[i], t[i], u[i],
-                                                  lambda[i], rgba[i] );
-               break;
-            case GL_LINEAR_MIPMAP_LINEAR:
-               sample_cube_linear_mipmap_linear( tObj, s[i], t[i], u[i],
-                                                 lambda[i], rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad min filter in sample_lambda_cube");
-         }
-      }
-      else {
-         /* magnification */
-         const struct gl_texture_image **images;
-         GLfloat newS, newT;
-         images = choose_cube_face(tObj, s[i], t[i], u[i],
-                                   &newS, &newT);
-         switch (tObj->MagFilter) {
-            case GL_NEAREST:
-               sample_2d_nearest( tObj, images[tObj->BaseLevel],
-                                  newS, newT, rgba[i] );
-               break;
-            case GL_LINEAR:
-               sample_2d_linear( tObj, images[tObj->BaseLevel],
-                                 newS, newT, rgba[i] );
-               break;
-            default:
-               gl_problem(NULL, "Bad mag filter in sample_lambda_cube");
-         }
-      }
-   }
-}
-
-
-/**********************************************************************/
-/*                       Texture Sampling Setup                       */
-/**********************************************************************/
-
-
-/*
- * Setup the texture sampling function for this texture object.
- */
-void
-_mesa_set_texture_sampler( struct gl_texture_object *t )
-{
-   if (!t->Complete) {
-      t->SampleFunc = NULL;
-   }
-   else {
-      GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);
-
-      if (needLambda) {
-         /* Compute min/mag filter threshold */
-         if (t->MagFilter==GL_LINEAR
-             && (t->MinFilter==GL_NEAREST_MIPMAP_NEAREST ||
-                 t->MinFilter==GL_LINEAR_MIPMAP_NEAREST)) {
-            t->MinMagThresh = 0.5F;
-         }
-         else {
-            t->MinMagThresh = 0.0F;
-         }
-      }
-
-      switch (t->Dimensions) {
-         case 1:
-            if (needLambda) {
-               t->SampleFunc = sample_lambda_1d;
-            }
-            else if (t->MinFilter==GL_LINEAR) {
-               t->SampleFunc = sample_linear_1d;
-            }
-            else {
-               ASSERT(t->MinFilter==GL_NEAREST);
-               t->SampleFunc = sample_nearest_1d;
-            }
-            break;
-         case 2:
-            if (needLambda) {
-               t->SampleFunc = sample_lambda_2d;
-            }
-            else if (t->MinFilter==GL_LINEAR) {
-               t->SampleFunc = sample_linear_2d;
-            }
-            else {
-               ASSERT(t->MinFilter==GL_NEAREST);
-               if (t->WrapS==GL_REPEAT && t->WrapT==GL_REPEAT
-                   && t->Image[0]->Border==0 && t->Image[0]->Format==GL_RGB) {
-                  t->SampleFunc = opt_sample_rgb_2d;
-               }
-               else if (t->WrapS==GL_REPEAT && t->WrapT==GL_REPEAT
-                   && t->Image[0]->Border==0 && t->Image[0]->Format==GL_RGBA) {
-                  t->SampleFunc = opt_sample_rgba_2d;
-               }
-               else
-                  t->SampleFunc = sample_nearest_2d;
-            }
-            break;
-         case 3:
-            if (needLambda) {
-               t->SampleFunc = sample_lambda_3d;
-            }
-            else if (t->MinFilter==GL_LINEAR) {
-               t->SampleFunc = sample_linear_3d;
-            }
-            else {
-               ASSERT(t->MinFilter==GL_NEAREST);
-               t->SampleFunc = sample_nearest_3d;
-            }
-            break;
-         case 6: /* cube map */
-            if (needLambda) {
-               t->SampleFunc = sample_lambda_cube;
-            }
-            else if (t->MinFilter==GL_LINEAR) {
-               t->SampleFunc = sample_linear_cube;
-            }
-            else {
-               ASSERT(t->MinFilter==GL_NEAREST);
-               t->SampleFunc = sample_nearest_cube;
-            }
-            break;
-         default:
-            gl_problem(NULL, "invalid dimensions in _mesa_set_texture_sampler");
-      }
-   }
-}
-
-
-#define PROD(A,B)   ( (GLuint)(A) * ((GLuint)(B)+1) )
-#define S_PROD(A,B) ( (GLint)(A) * ((GLint)(B)+1) )
-
-static INLINE void
-_mesa_texture_combine(const GLcontext *ctx,
-                      const struct gl_texture_unit *textureUnit,
-                      GLuint n,
-                      GLubyte (*primary_rgba)[4],
-                      GLubyte (*texel)[4],
-                      GLubyte (*rgba)[4])
-{
-   GLubyte ccolor [3][3*MAX_WIDTH][4];
-   GLubyte (*argRGB [3])[4];
-   GLubyte (*argA [3])[4];
-   GLuint i, j;
-   GLuint RGBshift = textureUnit->CombineScaleShiftRGB;
-   GLuint Ashift   = textureUnit->CombineScaleShiftA;
-
-   ASSERT(ctx->Extensions.HaveTextureEnvCombine);
-
-   for (j = 0; j < 3; j++) {
-      switch (textureUnit->CombineSourceA[j]) {
-         case GL_TEXTURE:
-            argA[j] = texel;
-            break;
-         case GL_PRIMARY_COLOR_EXT:
-            argA[j] = primary_rgba;
-            break;
-         case GL_PREVIOUS_EXT:
-            argA[j] = rgba;
-            break;
-         case GL_CONSTANT_EXT:
-            {
-               GLubyte (*c)[4] = ccolor[j];
-               GLubyte alpha = FLOAT_TO_UBYTE(textureUnit->EnvColor[3]);
-               for (i = 0; i < n; i++)
-                  c[i][ACOMP] = alpha;
-               argA[j] = ccolor[j];
-            }
-            break;
-         default:
-            gl_problem(NULL, "invalid combine source");
-      }
-
-      switch (textureUnit->CombineSourceRGB[j]) {
-         case GL_TEXTURE:
-            argRGB[j] = texel;
-            break;
-         case GL_PRIMARY_COLOR_EXT:
-            argRGB[j] = primary_rgba;
-            break;
-         case GL_PREVIOUS_EXT:
-            argRGB[j] = rgba;
-            break;
-         case GL_CONSTANT_EXT:
-            {
-               GLubyte (*c)[4] = ccolor[j];
-               const GLubyte red   = FLOAT_TO_UBYTE(textureUnit->EnvColor[0]);
-               const GLubyte green = FLOAT_TO_UBYTE(textureUnit->EnvColor[1]);
-               const GLubyte blue  = FLOAT_TO_UBYTE(textureUnit->EnvColor[2]);
-               const GLubyte alpha = FLOAT_TO_UBYTE(textureUnit->EnvColor[3]);
-               for (i = 0; i < n; i++) {
-                  c[i][RCOMP] = red;
-                  c[i][GCOMP] = green;
-                  c[i][BCOMP] = blue;
-                  c[i][ACOMP] = alpha;
-               }
-               argRGB[j] = ccolor[j];
-            }
-            break;
-         default:
-            gl_problem(NULL, "invalid combine source");
-      }
-
-      if (textureUnit->CombineOperandRGB[j] != GL_SRC_COLOR) {
-         GLubyte (*src)[4] = argRGB[j];
-         GLubyte (*dst)[4] = ccolor[j];
-
-         /* point to new arg[j] storage */
-         argRGB[j] = ccolor[j];
-
-         if (textureUnit->CombineOperandRGB[j] == GL_ONE_MINUS_SRC_COLOR) {
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] = 255 - src[i][RCOMP];
-               dst[i][GCOMP] = 255 - src[i][GCOMP];
-               dst[i][BCOMP] = 255 - src[i][BCOMP];
-            }
-         }
-         else if (textureUnit->CombineOperandRGB[j] == GL_SRC_ALPHA) {
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] = src[i][ACOMP];
-               dst[i][GCOMP] = src[i][ACOMP];
-               dst[i][BCOMP] = src[i][ACOMP];
-            }
-         }
-         else {                      /*  GL_ONE_MINUS_SRC_ALPHA  */
-            for (i = 0; i < n; i++) {
-               dst[i][RCOMP] = 255 - src[i][ACOMP];
-               dst[i][GCOMP] = 255 - src[i][ACOMP];
-               dst[i][BCOMP] = 255 - src[i][ACOMP];
-            }
-         }
-      }
-
-      if (textureUnit->CombineOperandA[j] == GL_ONE_MINUS_SRC_ALPHA) {
-         GLubyte (*src)[4] = argA[j];
-         GLubyte (*dst)[4] = ccolor[j];
-         argA[j] = ccolor[j];
-         for (i = 0; i < n; i++) {
-            dst[i][ACOMP] = 255 - src[i][ACOMP];
-         }
-      }
-
-      if (textureUnit->CombineModeRGB == GL_REPLACE &&
-          textureUnit->CombineModeA == GL_REPLACE) {
-         break;      /*  done, we need only arg0  */
-      }
-
-      if (j == 1 &&
-          textureUnit->CombineModeRGB != GL_INTERPOLATE_EXT &&
-          textureUnit->CombineModeA != GL_INTERPOLATE_EXT) {
-         break;      /*  arg0 and arg1 are done. we don't need arg2. */
-      }
-   }
-
-   switch (textureUnit->CombineModeRGB) {
-      case GL_REPLACE:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argRGB[0];
-            if (RGBshift) {
-               for (i = 0; i < n; i++) {
-                  GLuint r = (GLuint) arg0[i][RCOMP] << RGBshift;
-                  GLuint g = (GLuint) arg0[i][GCOMP] << RGBshift;
-                  GLuint b = (GLuint) arg0[i][BCOMP] << RGBshift;
-                  rgba[i][RCOMP] = MIN2(r, 255);
-                  rgba[i][GCOMP] = MIN2(g, 255);
-                  rgba[i][BCOMP] = MIN2(b, 255);
-               }
-            }
-            else {
-               for (i = 0; i < n; i++) {
-                  rgba[i][RCOMP] = arg0[i][RCOMP];
-                  rgba[i][GCOMP] = arg0[i][GCOMP];
-                  rgba[i][BCOMP] = arg0[i][BCOMP];
-               }
-            }
-         }
-         break;
-      case GL_MODULATE:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argRGB[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argRGB[1];
-            RGBshift = 8 - RGBshift;
-            for (i = 0; i < n; i++) {
-               GLuint r = PROD(arg0[i][0], arg1[i][RCOMP]) >> RGBshift;
-               GLuint g = PROD(arg0[i][1], arg1[i][GCOMP]) >> RGBshift;
-               GLuint b = PROD(arg0[i][2], arg1[i][BCOMP]) >> RGBshift;
-               rgba[i][RCOMP] = (GLubyte) MIN2(r, 255);
-               rgba[i][GCOMP] = (GLubyte) MIN2(g, 255);
-               rgba[i][BCOMP] = (GLubyte) MIN2(b, 255);
-            }
-         }
-         break;
-      case GL_ADD:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argRGB[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argRGB[1];
-            for (i = 0; i < n; i++) {
-               GLint r = ((GLuint) arg0[i][RCOMP] + arg1[i][RCOMP]) << RGBshift;
-               GLint g = ((GLuint) arg0[i][GCOMP] + arg1[i][GCOMP]) << RGBshift;
-               GLint b = ((GLuint) arg0[i][BCOMP] + arg1[i][BCOMP]) << RGBshift;
-               rgba[i][RCOMP] = (GLubyte) MIN2(r, 255);
-               rgba[i][GCOMP] = (GLubyte) MIN2(g, 255);
-               rgba[i][BCOMP] = (GLubyte) MIN2(b, 255);
-            }
-         }
-         break;
-      case GL_ADD_SIGNED_EXT:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argRGB[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argRGB[1];
-            for (i = 0; i < n; i++) {
-               GLint r = (GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP] - 128;
-               GLint g = (GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP] - 128;
-               GLint b = (GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP] - 128;
-               r = (r < 0) ? 0 : r << RGBshift;
-               b = (b < 0) ? 0 : b << RGBshift;
-               g = (g < 0) ? 0 : g << RGBshift;
-               rgba[i][RCOMP] = (GLubyte) MIN2(r, 255);
-               rgba[i][GCOMP] = (GLubyte) MIN2(g, 255);
-               rgba[i][BCOMP] = (GLubyte) MIN2(b, 255);
-            }
-         }
-         break;
-      case GL_INTERPOLATE_EXT:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argRGB[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argRGB[1];
-            const GLubyte (*arg2)[4] = (const GLubyte (*)[4]) argRGB[2];
-            RGBshift = 8 - RGBshift;
-            for (i = 0; i < n; i++) {
-               GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
-                           + PROD(arg1[i][RCOMP], 255 - arg2[i][RCOMP]))
-                              >> RGBshift;
-               GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
-                           + PROD(arg1[i][GCOMP], 255 - arg2[i][GCOMP]))
-                              >> RGBshift;
-               GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
-                           + PROD(arg1[i][BCOMP], 255 - arg2[i][BCOMP]))
-                              >> RGBshift;
-               rgba[i][RCOMP] = (GLubyte) MIN2(r, 255);
-               rgba[i][GCOMP] = (GLubyte) MIN2(g, 255);
-               rgba[i][BCOMP] = (GLubyte) MIN2(b, 255);
-            }
-         }
-	 break;
-      case GL_DOT3_RGB_EXT:
-      case GL_DOT3_RGBA_EXT:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argRGB[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argRGB[1];
-	    /* ATI's EXT extension has a constant scale by 4.  The ARB
-	     * one will likely remove this restriction, and we should
-	     * drop the EXT extension in favour of the ARB one.
-	     */
-            RGBshift = 6;
-            for (i = 0; i < n; i++) {
-               GLint dot = (S_PROD((GLint) arg0[i][RCOMP] - 128,
-                                   (GLint) arg1[i][RCOMP] - 128) +
-                            S_PROD((GLint) arg0[i][GCOMP] - 128,
-                                   (GLint) arg1[i][GCOMP] - 128) +
-                            S_PROD((GLint) arg0[i][BCOMP] - 128,
-                                   (GLint) arg1[i][BCOMP] - 128)) >> RGBshift;
-               rgba[i][RCOMP] = (GLubyte) CLAMP(dot, 0, 255);
-               rgba[i][GCOMP] = (GLubyte) CLAMP(dot, 0, 255);
-               rgba[i][BCOMP] = (GLubyte) CLAMP(dot, 0, 255);
-            }
-         }
-         break;
-      default:
-         gl_problem(NULL, "invalid combine mode");
-   }
-
-   switch (textureUnit->CombineModeA) {
-      case GL_REPLACE:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argA[0];
-            if (Ashift) {
-               for (i = 0; i < n; i++) {
-                  GLuint a = (GLuint) arg0[i][ACOMP] << Ashift;
-                  rgba[i][ACOMP] = (GLubyte) MIN2(a, 255);
-               }
-            }
-            else {
-               for (i = 0; i < n; i++) {
-                  rgba[i][ACOMP] = arg0[i][ACOMP];
-               }
-            }
-         }
-         break;
-      case GL_MODULATE:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argA[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argA[1];
-            Ashift = 8 - Ashift;
-            for (i = 0; i < n; i++) {
-               GLuint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> Ashift);
-               rgba[i][ACOMP] = (GLubyte) MIN2(a, 255);
-            }
-         }
-         break;
-      case GL_ADD:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argA[0];
-            const GLubyte  (*arg1)[4] = (const GLubyte (*)[4]) argA[1];
-            for (i = 0; i < n; i++) {
-               GLint a = ((GLint) arg0[i][ACOMP] + arg1[i][ACOMP]) << Ashift;
-               rgba[i][ACOMP] = (GLubyte) MIN2(a, 255);
-            }
-         }
-         break;
-      case GL_ADD_SIGNED_EXT:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argA[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argA[1];
-            for (i = 0; i < n; i++) {
-               GLint a = (GLint) arg0[i][ACOMP] + (GLint) arg1[i][ACOMP] - 128;
-               a = (a < 0) ? 0 : a << Ashift;
-               rgba[i][ACOMP] = (GLubyte) MIN2(a, 255);
-            }
-         }
-         break;
-      case GL_INTERPOLATE_EXT:
-         {
-            const GLubyte (*arg0)[4] = (const GLubyte (*)[4]) argA[0];
-            const GLubyte (*arg1)[4] = (const GLubyte (*)[4]) argA[1];
-            const GLubyte (*arg2)[4] = (const GLubyte (*)[4]) argA[2];
-            Ashift = 8 - Ashift;
-            for (i=0; i<n; i++) {
-               GLuint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
-                           + PROD(arg1[i][ACOMP], 255 - arg2[i][ACOMP]))
-                              >> Ashift;
-               rgba[i][ACOMP] = (GLubyte) MIN2(a, 255);
-            }
-         }
-         break;
-      default:
-         gl_problem(NULL, "invalid combine mode");
-   }
-
-   /* Fix the alpha component for GL_DOT3_RGBA_EXT combining.
-    */
-   if (textureUnit->CombineModeRGB == GL_DOT3_RGBA_EXT) {
-      for (i = 0; i < n; i++) {
-	 rgba[i][ACOMP] = rgba[i][RCOMP];
-      }
-   }
-}
-#undef PROD
-
-
-
-/**********************************************************************/
-/*                      Texture Application                           */
-/**********************************************************************/
-
-
-/*
- * Combine incoming fragment color with texel color to produce output color.
- * Input:  textureUnit - pointer to texture unit to apply
- *         format - base internal texture format
- *         n - number of fragments
- *         primary_rgba - primary colors (may be rgba for single texture)
- *         texels - array of texel colors
- * InOut:  rgba - incoming fragment colors modified by texel colors
- *                according to the texture environment mode.
- */
-static void apply_texture( CONST GLcontext *ctx,
-                           const struct gl_texture_unit *texUnit,
-                           GLuint n,
-                           GLubyte primary_rgba[][4], GLubyte texel[][4],
-                           GLubyte rgba[][4] )
-{
-   GLint baseLevel;
-   GLuint i;
-   GLint Rc, Gc, Bc, Ac;
-   GLenum format;
-
-   ASSERT(texUnit);
-   ASSERT(texUnit->Current);
-
-   baseLevel = texUnit->Current->BaseLevel;
-   ASSERT(texUnit->Current->Image[baseLevel]);
-
-   format = texUnit->Current->Image[baseLevel]->Format;
-
-/*
- * Use (A*(B+1)) >> 8 as a fast approximation of (A*B)/255 for A
- * and B in [0,255]
- */
-#define PROD(A,B)   ( (GLubyte) (((GLint)(A) * ((GLint)(B)+1)) >> 8) )
-
-   if (format==GL_COLOR_INDEX) {
-      format = GL_RGBA;  /* XXXX a hack! */
-   }
-
-   switch (texUnit->EnvMode) {
-      case GL_REPLACE:
-	 switch (format) {
-	    case GL_ALPHA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf */
-                  /* Av = At */
-                  rgba[i][ACOMP] = texel[i][ACOMP];
-	       }
-	       break;
-	    case GL_LUMINANCE:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Lt */
-                  GLubyte Lt = texel[i][RCOMP];
-                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
-                  /* Av = Af */
-	       }
-	       break;
-	    case GL_LUMINANCE_ALPHA:
-	       for (i=0;i<n;i++) {
-                  GLubyte Lt = texel[i][RCOMP];
-		  /* Cv = Lt */
-		  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
-		  /* Av = At */
-		  rgba[i][ACOMP] = texel[i][ACOMP];
-	       }
-	       break;
-	    case GL_INTENSITY:
-	       for (i=0;i<n;i++) {
-		  /* Cv = It */
-                  GLubyte It = texel[i][RCOMP];
-                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = It;
-                  /* Av = It */
-                  rgba[i][ACOMP] = It;
-	       }
-	       break;
-	    case GL_RGB:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Ct */
-		  rgba[i][RCOMP] = texel[i][RCOMP];
-		  rgba[i][GCOMP] = texel[i][GCOMP];
-		  rgba[i][BCOMP] = texel[i][BCOMP];
-		  /* Av = Af */
-	       }
-	       break;
-	    case GL_RGBA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Ct */
-		  rgba[i][RCOMP] = texel[i][RCOMP];
-		  rgba[i][GCOMP] = texel[i][GCOMP];
-		  rgba[i][BCOMP] = texel[i][BCOMP];
-		  /* Av = At */
-		  rgba[i][ACOMP] = texel[i][ACOMP];
-	       }
-	       break;
-            default:
-               gl_problem(ctx, "Bad format (GL_REPLACE) in apply_texture");
-               return;
-	 }
-	 break;
-
-      case GL_MODULATE:
-         switch (format) {
-	    case GL_ALPHA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf */
-		  /* Av = AfAt */
-		  rgba[i][ACOMP] = PROD( rgba[i][ACOMP], texel[i][ACOMP] );
-	       }
-	       break;
-	    case GL_LUMINANCE:
-	       for (i=0;i<n;i++) {
-		  /* Cv = LtCf */
-                  GLubyte Lt = texel[i][RCOMP];
-		  rgba[i][RCOMP] = PROD( rgba[i][RCOMP], Lt );
-		  rgba[i][GCOMP] = PROD( rgba[i][GCOMP], Lt );
-		  rgba[i][BCOMP] = PROD( rgba[i][BCOMP], Lt );
-		  /* Av = Af */
-	       }
-	       break;
-	    case GL_LUMINANCE_ALPHA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = CfLt */
-                  GLubyte Lt = texel[i][RCOMP];
-		  rgba[i][RCOMP] = PROD( rgba[i][RCOMP], Lt );
-		  rgba[i][GCOMP] = PROD( rgba[i][GCOMP], Lt );
-		  rgba[i][BCOMP] = PROD( rgba[i][BCOMP], Lt );
-		  /* Av = AfAt */
-		  rgba[i][ACOMP] = PROD( rgba[i][ACOMP], texel[i][ACOMP] );
-	       }
-	       break;
-	    case GL_INTENSITY:
-	       for (i=0;i<n;i++) {
-		  /* Cv = CfIt */
-                  GLubyte It = texel[i][RCOMP];
-		  rgba[i][RCOMP] = PROD( rgba[i][RCOMP], It );
-		  rgba[i][GCOMP] = PROD( rgba[i][GCOMP], It );
-		  rgba[i][BCOMP] = PROD( rgba[i][BCOMP], It );
-		  /* Av = AfIt */
-		  rgba[i][ACOMP] = PROD( rgba[i][ACOMP], It );
-	       }
-	       break;
-	    case GL_RGB:
-	       for (i=0;i<n;i++) {
-		  /* Cv = CfCt */
-		  rgba[i][RCOMP] = PROD( rgba[i][RCOMP], texel[i][RCOMP] );
-		  rgba[i][GCOMP] = PROD( rgba[i][GCOMP], texel[i][GCOMP] );
-		  rgba[i][BCOMP] = PROD( rgba[i][BCOMP], texel[i][BCOMP] );
-		  /* Av = Af */
-	       }
-	       break;
-	    case GL_RGBA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = CfCt */
-		  rgba[i][RCOMP] = PROD( rgba[i][RCOMP], texel[i][RCOMP] );
-		  rgba[i][GCOMP] = PROD( rgba[i][GCOMP], texel[i][GCOMP] );
-		  rgba[i][BCOMP] = PROD( rgba[i][BCOMP], texel[i][BCOMP] );
-		  /* Av = AfAt */
-		  rgba[i][ACOMP] = PROD( rgba[i][ACOMP], texel[i][ACOMP] );
-	       }
-	       break;
-            default:
-               gl_problem(ctx, "Bad format (GL_MODULATE) in apply_texture");
-               return;
-	 }
-	 break;
-
-      case GL_DECAL:
-         switch (format) {
-            case GL_ALPHA:
-            case GL_LUMINANCE:
-            case GL_LUMINANCE_ALPHA:
-            case GL_INTENSITY:
-               /* undefined */
-               break;
-	    case GL_RGB:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Ct */
-		  rgba[i][RCOMP] = texel[i][RCOMP];
-		  rgba[i][GCOMP] = texel[i][GCOMP];
-		  rgba[i][BCOMP] = texel[i][BCOMP];
-		  /* Av = Af */
-	       }
-	       break;
-	    case GL_RGBA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf(1-At) + CtAt */
-		  GLint t = texel[i][ACOMP], s = 255 - t;
-		  rgba[i][RCOMP] = PROD(rgba[i][RCOMP], s) + PROD(texel[i][RCOMP],t);
-		  rgba[i][GCOMP] = PROD(rgba[i][GCOMP], s) + PROD(texel[i][GCOMP],t);
-		  rgba[i][BCOMP] = PROD(rgba[i][BCOMP], s) + PROD(texel[i][BCOMP],t);
-		  /* Av = Af */
-	       }
-	       break;
-            default:
-               gl_problem(ctx, "Bad format (GL_DECAL) in apply_texture");
-               return;
-	 }
-	 break;
-
-      case GL_BLEND:
-         Rc = (GLint) (texUnit->EnvColor[0] * 255.0F);
-         Gc = (GLint) (texUnit->EnvColor[1] * 255.0F);
-         Bc = (GLint) (texUnit->EnvColor[2] * 255.0F);
-         Ac = (GLint) (texUnit->EnvColor[3] * 255.0F);
-	 switch (format) {
-	    case GL_ALPHA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf */
-		  /* Av = AfAt */
-                  rgba[i][ACOMP] = PROD(rgba[i][ACOMP], texel[i][ACOMP]);
-	       }
-	       break;
-            case GL_LUMINANCE:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf(1-Lt) + CcLt */
-		  GLubyte Lt = texel[i][RCOMP], s = 255 - Lt;
-		  rgba[i][RCOMP] = PROD(rgba[i][RCOMP], s) + PROD(Rc, Lt);
-		  rgba[i][GCOMP] = PROD(rgba[i][GCOMP], s) + PROD(Gc, Lt);
-		  rgba[i][BCOMP] = PROD(rgba[i][BCOMP], s) + PROD(Bc, Lt);
-		  /* Av = Af */
-	       }
-	       break;
-	    case GL_LUMINANCE_ALPHA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf(1-Lt) + CcLt */
-		  GLubyte Lt = texel[i][RCOMP], s = 255 - Lt;
-		  rgba[i][RCOMP] = PROD(rgba[i][RCOMP], s) + PROD(Rc, Lt);
-		  rgba[i][GCOMP] = PROD(rgba[i][GCOMP], s) + PROD(Gc, Lt);
-		  rgba[i][BCOMP] = PROD(rgba[i][BCOMP], s) + PROD(Bc, Lt);
-		  /* Av = AfAt */
-		  rgba[i][ACOMP] = PROD(rgba[i][ACOMP],texel[i][ACOMP]);
-	       }
-	       break;
-            case GL_INTENSITY:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf(1-It) + CcLt */
-		  GLubyte It = texel[i][RCOMP], s = 255 - It;
-		  rgba[i][RCOMP] = PROD(rgba[i][RCOMP], s) + PROD(Rc, It);
-		  rgba[i][GCOMP] = PROD(rgba[i][GCOMP], s) + PROD(Gc, It);
-		  rgba[i][BCOMP] = PROD(rgba[i][BCOMP], s) + PROD(Bc, It);
-                  /* Av = Af(1-It) + Ac*It */
-                  rgba[i][ACOMP] = PROD(rgba[i][ACOMP], s) + PROD(Ac, It);
-               }
-               break;
-	    case GL_RGB:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf(1-Ct) + CcCt */
-		  rgba[i][RCOMP] = PROD(rgba[i][RCOMP], (255-texel[i][RCOMP])) + PROD(Rc,texel[i][RCOMP]);
-		  rgba[i][GCOMP] = PROD(rgba[i][GCOMP], (255-texel[i][GCOMP])) + PROD(Gc,texel[i][GCOMP]);
-		  rgba[i][BCOMP] = PROD(rgba[i][BCOMP], (255-texel[i][BCOMP])) + PROD(Bc,texel[i][BCOMP]);
-		  /* Av = Af */
-	       }
-	       break;
-	    case GL_RGBA:
-	       for (i=0;i<n;i++) {
-		  /* Cv = Cf(1-Ct) + CcCt */
-		  rgba[i][RCOMP] = PROD(rgba[i][RCOMP], (255-texel[i][RCOMP])) + PROD(Rc,texel[i][RCOMP]);
-		  rgba[i][GCOMP] = PROD(rgba[i][GCOMP], (255-texel[i][GCOMP])) + PROD(Gc,texel[i][GCOMP]);
-		  rgba[i][BCOMP] = PROD(rgba[i][BCOMP], (255-texel[i][BCOMP])) + PROD(Bc,texel[i][BCOMP]);
-		  /* Av = AfAt */
-		  rgba[i][ACOMP] = PROD(rgba[i][ACOMP],texel[i][ACOMP]);
-	       }
-	       break;
-            default:
-               gl_problem(ctx, "Bad format (GL_BLEND) in apply_texture");
-               return;
-	 }
-	 break;
-
-      case GL_ADD:  /* GL_EXT_texture_add_env */
-         switch (format) {
-            case GL_ALPHA:
-               for (i=0;i<n;i++) {
-                  /* Rv = Rf */
-                  /* Gv = Gf */
-                  /* Bv = Bf */
-                  rgba[i][ACOMP] = PROD(rgba[i][ACOMP], texel[i][ACOMP]);
-               }
-               break;
-            case GL_LUMINANCE:
-               for (i=0;i<n;i++) {
-                  GLuint Lt = texel[i][RCOMP];
-                  GLuint r = rgba[i][RCOMP] + Lt;
-                  GLuint g = rgba[i][GCOMP] + Lt;
-                  GLuint b = rgba[i][BCOMP] + Lt;
-                  rgba[i][RCOMP] = r < 256 ? (GLubyte) r : 255;
-                  rgba[i][GCOMP] = g < 256 ? (GLubyte) g : 255;
-                  rgba[i][BCOMP] = b < 256 ? (GLubyte) b : 255;
-                  /* Av = Af */
-               }
-               break;
-            case GL_LUMINANCE_ALPHA:
-               for (i=0;i<n;i++) {
-                  GLuint Lt = texel[i][RCOMP];
-                  GLuint r = rgba[i][RCOMP] + Lt;
-                  GLuint g = rgba[i][GCOMP] + Lt;
-                  GLuint b = rgba[i][BCOMP] + Lt;
-                  rgba[i][RCOMP] = r < 256 ? (GLubyte) r : 255;
-                  rgba[i][GCOMP] = g < 256 ? (GLubyte) g : 255;
-                  rgba[i][BCOMP] = b < 256 ? (GLubyte) b : 255;
-                  rgba[i][ACOMP] = PROD(rgba[i][ACOMP], texel[i][ACOMP]);
-               }
-               break;
-            case GL_INTENSITY:
-               for (i=0;i<n;i++) {
-                  GLubyte It = texel[i][RCOMP];
-                  GLuint r = rgba[i][RCOMP] + It;
-                  GLuint g = rgba[i][GCOMP] + It;
-                  GLuint b = rgba[i][BCOMP] + It;
-                  GLuint a = rgba[i][ACOMP] + It;
-                  rgba[i][RCOMP] = r < 256 ? (GLubyte) r : 255;
-                  rgba[i][GCOMP] = g < 256 ? (GLubyte) g : 255;
-                  rgba[i][BCOMP] = b < 256 ? (GLubyte) b : 255;
-                  rgba[i][ACOMP] = a < 256 ? (GLubyte) a : 255;
-               }
-               break;
-	    case GL_RGB:
-	       for (i=0;i<n;i++) {
-                  GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
-                  GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
-                  GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
-		  rgba[i][RCOMP] = r < 256 ? (GLubyte) r : 255;
-		  rgba[i][GCOMP] = g < 256 ? (GLubyte) g : 255;
-		  rgba[i][BCOMP] = b < 256 ? (GLubyte) b : 255;
-		  /* Av = Af */
-	       }
-	       break;
-	    case GL_RGBA:
-	       for (i=0;i<n;i++) {
-                  GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
-                  GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
-                  GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
-		  rgba[i][RCOMP] = r < 256 ? (GLubyte) r : 255;
-		  rgba[i][GCOMP] = g < 256 ? (GLubyte) g : 255;
-		  rgba[i][BCOMP] = b < 256 ? (GLubyte) b : 255;
-                  rgba[i][ACOMP] = PROD(rgba[i][ACOMP], texel[i][ACOMP]);
-               }
-               break;
-            default:
-               gl_problem(ctx, "Bad format (GL_ADD) in apply_texture");
-               return;
-	 }
-	 break;
-
-      case GL_COMBINE_EXT:    /*  GL_EXT_combine_ext; we modify texel array */
-         switch (format) {
-            case GL_ALPHA:
-               for (i=0;i<n;i++)
-                  texel[i][RCOMP] = texel[i][GCOMP] = texel[i][BCOMP] = 0;
-               break;
-            case GL_LUMINANCE:
-               for (i=0;i<n;i++) {
-                  /* Cv = Lt */
-                  GLubyte Lt = texel[i][RCOMP];
-                  texel[i][GCOMP] = texel[i][BCOMP] = Lt;
-                  /* Av = 1 */
-                  texel[i][ACOMP] = 255;
-               }
-               break;
-            case GL_LUMINANCE_ALPHA:
-               for (i=0;i<n;i++) {
-                  GLubyte Lt = texel[i][RCOMP];
-                  /* Cv = Lt */
-                  texel[i][GCOMP] = texel[i][BCOMP] = Lt;
-               }
-               break;
-            case GL_INTENSITY:
-               for (i=0;i<n;i++) {
-                  /* Cv = It */
-                  GLubyte It = texel[i][RCOMP];
-                  texel[i][GCOMP] = texel[i][BCOMP] = It;
-                  /* Av = It */
-                  texel[i][ACOMP] = It;
-               }
-               break;
-            case GL_RGB:
-               for (i=0;i<n;i++) {
-                  /* Av = 1 */
-                  texel[i][ACOMP] = 255;
-               }
-               break;
-            case GL_RGBA:  /* do nothing. */
-               break;
-            default:
-               gl_problem(ctx, "Bad format in apply_texture (GL_COMBINE_EXT)");
-               return;
-         }
-         _mesa_texture_combine(ctx, texUnit, n, primary_rgba, texel, rgba);
-         break;
-
-      default:
-         gl_problem(ctx, "Bad env mode in apply_texture");
-         return;
-   }
-#undef PROD
-}
-
-
-
-/*
- * Apply a unit of texture mapping to the incoming fragments.
- */
-void gl_texture_pixels( GLcontext *ctx, GLuint texUnit, GLuint n,
-                        const GLfloat s[], const GLfloat t[],
-                        const GLfloat r[], GLfloat lambda[],
-                        GLubyte primary_rgba[][4], GLubyte rgba[][4] )
-{
-   GLuint mask = (TEXTURE0_1D | TEXTURE0_2D | TEXTURE0_3D | TEXTURE0_CUBE) << (texUnit * 4);
-   if (ctx->Texture.ReallyEnabled & mask) {
-      const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
-      if (textureUnit->Current && textureUnit->Current->SampleFunc) {
-         GLubyte texel[PB_SIZE][4];
-	 if (textureUnit->LodBias != 0.0F) {
-	    /* apply LOD bias, but don't clamp yet */
-            GLuint i;
-	    for (i=0;i<n;i++) {
-	       lambda[i] += textureUnit->LodBias;
-	    }
-	 }
-
-         if (textureUnit->Current->MinLod != -1000.0
-             || textureUnit->Current->MaxLod != 1000.0) {
-            /* apply LOD clamping to lambda */
-            GLfloat min = textureUnit->Current->MinLod;
-            GLfloat max = textureUnit->Current->MaxLod;
-            GLuint i;
-            for (i=0;i<n;i++) {
-               GLfloat l = lambda[i];
-               lambda[i] = CLAMP(l, min, max);
-            }
-         }
-
-         /* fetch texture images from device driver, if needed */
-         if (ctx->Driver.GetTexImage) {
-            if (!_mesa_get_teximages_from_driver(ctx, textureUnit->Current)) {
-               return;
-            }
-         }
-
-         /* Sample the texture. */
-         (*textureUnit->Current->SampleFunc)( textureUnit->Current, n,
-                                             s, t, r, lambda, texel );
-
-         apply_texture( ctx, textureUnit, n, primary_rgba, texel, rgba );
-      }
-   }
-}
Index: xc/extras/Mesa/src/texture.h
diff -u xc/extras/Mesa/src/texture.h:1.7 xc/extras/Mesa/src/texture.h:removed
--- xc/extras/Mesa/src/texture.h:1.7	Mon Nov 13 18:30:53 2000
+++ xc/extras/Mesa/src/texture.h	Thu Feb 27 12:15:44 2003
@@ -1,53 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef TEXTURE_H
-#define TEXTURE_H
-
-
-#include "types.h"
-
-
-extern void
-_mesa_set_texture_sampler( struct gl_texture_object *t );
-
-extern void gl_init_texture( void );
-
-extern void gl_update_texture_unit( GLcontext *ctx, 
-				    struct gl_texture_unit *texUnit );
-
-
-extern void gl_texture_pixels( GLcontext *ctx, GLuint texSet, GLuint n,
-                               const GLfloat s[], const GLfloat t[],
-                               const GLfloat r[], GLfloat lambda[],
-                               GLubyte primary_rgba[][4], GLubyte rgba[][4] );
-
-
-#endif
-
Index: xc/extras/Mesa/src/texutil.c
diff -u xc/extras/Mesa/src/texutil.c:1.9 xc/extras/Mesa/src/texutil.c:1.14
--- xc/extras/Mesa/src/texutil.c:1.9	Fri May 18 20:03:18 2001
+++ xc/extras/Mesa/src/texutil.c	Mon Dec 16 11:18:27 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.3
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -26,6 +26,14 @@
  *    Gareth Hughes <gareth@valinux.com>
  */
 
+/*
+ * Description:
+ * Functions for texture image conversion.  This takes care of converting
+ * typical GL_RGBA/GLubyte textures into hardware-specific formats.
+ * We can handle non-standard row strides and pixel unpacking parameters.
+ */
+
+
 #ifdef PC_HEADER
 #include "all.h"
 #else
@@ -33,23 +41,32 @@
 #include "context.h"
 #include "enums.h"
 #include "image.h"
+#include "macros.h"
 #include "mem.h"
+#include "mtypes.h"
 #include "texformat.h"
 #include "texutil.h"
-#include "types.h"
 #endif
 
 #define DEBUG_TEXUTIL 0
 
+
+#ifdef MESA_BIG_ENDIAN
+#define APPEND16( a, b )	( (a) << 16 | (b) )
+#else
+#define APPEND16( a, b )	( (a) | (b) << 16 )
+#endif
+
 
-struct gl_texture_convert {
+struct convert_info {
    GLint xoffset, yoffset, zoffset;	/* Subimage offset */
    GLint width, height, depth;		/* Subimage region */
 
-   GLint imageWidth, imageHeight;	/* Full image dimensions */
-   GLenum format, type;
+   GLint dstImageWidth, dstImageHeight;	/* Dest image size */
+                                        /* Needed for subimage replacement */
+   GLenum format, type;                 /* Source (user) format and type */
 
-   const struct gl_pixelstore_attrib *packing;
+   const struct gl_pixelstore_attrib *unpacking;
 
    const GLvoid *srcImage;
    GLvoid *dstImage;
@@ -57,22 +74,23 @@
    GLint index;
 };
 
-typedef GLboolean (*convert_func)( struct gl_texture_convert *convert );
-typedef void (*unconvert_func)( struct gl_texture_convert *convert );
+typedef GLboolean (*convert_func)( const struct convert_info *convert );
 
+/* bitvalues for convert->index */
 #define CONVERT_STRIDE_BIT	0x1
-#define CONVERT_PACKING_BIT	0x2
+#define CONVERT_UNPACKING_BIT	0x2
+
 
 
-/* ================================================================
- * RGBA8888 textures:
+/* =============================================================
+ * Convert to RGBA8888 textures:
  */
 
 #define DST_TYPE		GLuint
 #define DST_TEXELS_PER_DWORD	1
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( src[3], src[2], src[1], src[0] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_8888_LE( src[3], src[2], src[1], src[0] )
 
 #define CONVERT_DIRECT
 
@@ -83,10 +101,10 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( src[0], src[1], src[2], src[3] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_8888_LE( src[0], src[1], src[2], src[3] )
 
-#define CONVERT_TEXEL_DWORD( src )	CONVERT_TEXEL( src )
+#define CONVERT_TEXEL_DWORD( dst, src )		CONVERT_TEXEL( dst, src )
 
 #define SRC_TEXEL_BYTES		4
 
@@ -95,10 +113,10 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( src[0], src[1], src[2], 0xff )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_8888_LE( src[0], src[1], src[2], 0xff )
 
-#define CONVERT_TEXEL_DWORD( src )	CONVERT_TEXEL( src )
+#define CONVERT_TEXEL_DWORD( dst, src )		CONVERT_TEXEL( dst, src )
 
 #define SRC_TEXEL_BYTES		3
 
@@ -108,7 +126,7 @@
 
 #define CONVERT_RGBA8888( name )					\
 static GLboolean							\
-convert_##name##_rgba8888( struct gl_texture_convert *convert )		\
+convert_##name##_rgba8888( const struct convert_info *convert )		\
 {									\
    convert_func *tab;							\
    GLint index = convert->index;					\
@@ -142,152 +160,30 @@
 CONVERT_RGBA8888( texsubimage3d )
 
 
-static void
-unconvert_teximage_rgba8888( struct gl_texture_convert *convert )
-{
-   const GLubyte *src = (const GLubyte *)convert->srcImage;
-   GLint texels, i;
-
-   texels = convert->width * convert->height * convert->depth;
-
-   switch ( convert->format ) {
-   case GL_RGBA: {
-      GLuint *dst = (GLuint *)convert->dstImage;
-      for ( i = 0 ; i < texels ; i++ ) {
-	 *dst++ = PACK_COLOR_8888( src[0], src[1], src[2], src[3] );
-	 src += 4;
-      }
-      break;
-   }
-   case GL_RGB: {
-      GLubyte *dst = (GLubyte *)convert->dstImage;
-      for ( i = 0 ; i < texels ; i++ ) {
-	 *dst++ = src[3];
-	 *dst++ = src[2];
-	 *dst++ = src[1];
-	 src += 4;
-      }
-      break;
-   }
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
-}
-
-
 
-/* ================================================================
- * ABGR8888 textures:
+/* =============================================================
+ * Convert to ARGB8888 textures:
  */
 
 #define DST_TYPE		GLuint
 #define DST_TEXELS_PER_DWORD	1
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( src[3], src[2], src[1], src[0] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_8888_LE( src[3], src[2], src[1], src[0] )
 
 #define CONVERT_DIRECT
 
 #define SRC_TEXEL_BYTES		4
 
-#define TAG(x) x##_abgr8888_direct
-#define PRESERVE_DST_TYPE
-#include "texutil_tmp.h"
-
-
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( 0xff, src[2], src[1], src[0] )
-
-#define CONVERT_TEXEL_DWORD( src )	CONVERT_TEXEL( src )
-
-#define SRC_TEXEL_BYTES		3
-
-#define TAG(x) x##_bgr888_to_abgr8888
-#include "texutil_tmp.h"
-
-
-#define CONVERT_ABGR8888( name )					\
-static GLboolean							\
-convert_##name##_abgr8888( struct gl_texture_convert *convert )		\
-{									\
-   convert_func *tab;							\
-   GLint index = convert->index;					\
-									\
-   if ( convert->format == GL_RGBA &&					\
-	convert->type == GL_UNSIGNED_BYTE )				\
-   {									\
-      tab = name##_tab_abgr8888_direct;					\
-   }									\
-   else if ( convert->format == GL_RGB &&				\
-	     convert->type == GL_UNSIGNED_BYTE )			\
-   {									\
-      tab = name##_tab_bgr888_to_abgr8888;				\
-   }									\
-   else									\
-   {									\
-      /* Can't handle this source format/type combination */		\
-      return GL_FALSE;							\
-   }									\
-									\
-   return tab[index]( convert );					\
-}
-
-CONVERT_ABGR8888( texsubimage2d )
-CONVERT_ABGR8888( texsubimage3d )
-
-
-static void
-unconvert_teximage_abgr8888( struct gl_texture_convert *convert )
-{
-   const GLubyte *src = (const GLubyte *)convert->srcImage;
-   GLint texels, i;
-
-   texels = convert->width * convert->height * convert->depth;
-
-   switch ( convert->format ) {
-   case GL_RGBA:
-      MEMCPY( convert->dstImage, src, texels * 4 );
-      break;
-   case GL_RGB: {
-      GLubyte *dst = (GLubyte *)convert->dstImage;
-      for ( i = 0 ; i < texels ; i++ ) {
-	 *dst++ = src[0];
-	 *dst++ = src[1];
-	 *dst++ = src[2];
-	 src += 4;
-      }
-      break;
-   }
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
-}
-
-
-
-/* ================================================================
- * ARGB8888 textures:
- */
-
-#define DST_TYPE		GLuint
-#define DST_TEXELS_PER_DWORD	1
-
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( src[3], src[2], src[1], src[0] )
-
-#define CONVERT_DIRECT
-
-#define SRC_TEXEL_BYTES		4
-
 #define TAG(x) x##_argb8888_direct
 #define PRESERVE_DST_TYPE
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( src[3], src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_8888_LE( src[3], src[0], src[1], src[2] )
 
-#define CONVERT_TEXEL_DWORD( src )	CONVERT_TEXEL( src )
+#define CONVERT_TEXEL_DWORD( dst, src )		CONVERT_TEXEL( dst, src )
 
 #define SRC_TEXEL_BYTES		4
 
@@ -296,10 +192,10 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_8888( 0xff, src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_8888_LE( 0xff, src[0], src[1], src[2] )
 
-#define CONVERT_TEXEL_DWORD( src )	CONVERT_TEXEL( src )
+#define CONVERT_TEXEL_DWORD( dst, src )		CONVERT_TEXEL( dst, src )
 
 #define SRC_TEXEL_BYTES		3
 
@@ -309,7 +205,7 @@
 
 #define CONVERT_ARGB8888( name )					\
 static GLboolean							\
-convert_##name##_argb8888( struct gl_texture_convert *convert )		\
+convert_##name##_argb8888( const struct convert_info *convert )		\
 {									\
    convert_func *tab;							\
    GLint index = convert->index;					\
@@ -342,46 +238,13 @@
 CONVERT_ARGB8888( texsubimage3d )
 
 
-static void
-unconvert_teximage_argb8888( struct gl_texture_convert *convert )
-{
-   const GLubyte *src = (const GLubyte *)convert->srcImage;
-   GLint texels, i;
-
-   texels = convert->width * convert->height * convert->depth;
 
-   switch ( convert->format ) {
-   case GL_RGBA: {
-      GLuint *dst = (GLuint *)convert->dstImage;
-      for ( i = 0 ; i < texels ; i++ ) {
-	 *dst++ = PACK_COLOR_8888( src[3], src[0], src[1], src[2] );
-	 src += 4;
-      }
-      break;
-   }
-   case GL_RGB: {
-      GLubyte *dst = (GLubyte *)convert->dstImage;
-      for ( i = 0 ; i < texels ; i++ ) {
-	 *dst++ = src[2];
-	 *dst++ = src[1];
-	 *dst++ = src[0];
-	 src += 4;
-      }
-      break;
-   }
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
-}
-
-
-
-/* ================================================================
- * RGB888 textures:
+/* =============================================================
+ * Convert to RGB888 textures:
  */
 
 static GLboolean
-convert_texsubimage2d_rgb888( struct gl_texture_convert *convert )
+convert_texsubimage2d_rgb888( const struct convert_info *convert )
 {
    /* This is a placeholder for now...
     */
@@ -389,7 +252,7 @@
 }
 
 static GLboolean
-convert_texsubimage3d_rgb888( struct gl_texture_convert *convert )
+convert_texsubimage3d_rgb888( const struct convert_info *convert )
 {
    /* This is a placeholder for now...
     */
@@ -397,52 +260,16 @@
 }
 
 
-static void
-unconvert_teximage_rgb888( struct gl_texture_convert *convert )
-{
-   gl_problem(NULL, "texture unconvert error");
-}
-
-
-
-/* ================================================================
- * BGR888 textures:
- */
-
-static GLboolean
-convert_texsubimage2d_bgr888( struct gl_texture_convert *convert )
-{
-   /* This is a placeholder for now...
-    */
-   return GL_FALSE;
-}
-
-static GLboolean
-convert_texsubimage3d_bgr888( struct gl_texture_convert *convert )
-{
-   /* This is a placeholder for now...
-    */
-   return GL_FALSE;
-}
-
-
-static void
-unconvert_teximage_bgr888( struct gl_texture_convert *convert )
-{
-   gl_problem(NULL, "texture unconvert error");
-}
-
-
 
-/* ================================================================
- * RGB565 textures:
+/* =============================================================
+ * Convert to RGB565 textures:
  */
 
 #define DST_TYPE		GLushort
 #define DST_TEXELS_PER_DWORD	2
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_565( src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_565_LE( src[0], src[1], src[2] )
 
 #define CONVERT_DIRECT
 
@@ -453,12 +280,12 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_565( src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_565_LE( src[0], src[1], src[2] )
 
-#define CONVERT_TEXEL_DWORD( src )					\
-		((PACK_COLOR_565( src[0], src[1], src[2] )) |		\
-		 (PACK_COLOR_565( src[3], src[4], src[5] ) << 16))
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	dst = APPEND16( PACK_COLOR_565_LE( src[0], src[1], src[2] ),	\
+			PACK_COLOR_565_LE( src[3], src[4], src[5] ) )
 
 #define SRC_TEXEL_BYTES		3
 
@@ -467,12 +294,12 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_565( src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_565_LE( src[0], src[1], src[2] )
 
-#define CONVERT_TEXEL_DWORD( src )					\
-		((PACK_COLOR_565( src[0], src[1], src[2] )) |		\
-		 (PACK_COLOR_565( src[4], src[5], src[6] ) << 16))
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	dst = APPEND16( PACK_COLOR_565_LE( src[0], src[1], src[2] ),	\
+			PACK_COLOR_565_LE( src[4], src[5], src[6] ) )
 
 #define SRC_TEXEL_BYTES		4
 
@@ -482,7 +309,7 @@
 
 #define CONVERT_RGB565( name )						\
 static GLboolean							\
-convert_##name##_rgb565( struct gl_texture_convert *convert )		\
+convert_##name##_rgb565( const struct convert_info *convert )		\
 {									\
    convert_func *tab;							\
    GLint index = convert->index;					\
@@ -515,49 +342,16 @@
 CONVERT_RGB565( texsubimage3d )
 
 
-static void
-unconvert_teximage_rgb565( struct gl_texture_convert *convert )
-{
-   const GLushort *src = (const GLushort *)convert->srcImage;
-   GLubyte *dst = (GLubyte *)convert->dstImage;
-   GLint texels, i;
-
-   texels = convert->width * convert->height * convert->depth;
-
-   switch ( convert->format ) {
-   case GL_RGBA:
-      for ( i = 0 ; i < texels ; i++ ) {
-	 GLushort s = *src++;
-	 *dst++ = ((s >> 8) & 0xf8) * 255 / 0xf8;
-	 *dst++ = ((s >> 3) & 0xfc) * 255 / 0xfc;
-	 *dst++ = ((s << 3) & 0xf8) * 255 / 0xf8;
-	 *dst++ = 0xff;
-      }
-      break;
-   case GL_RGB:
-      for ( i = 0 ; i < texels ; i++ ) {
-	 GLushort s = *src++;
-	 *dst++ = ((s >> 8) & 0xf8) * 255 / 0xf8;
-	 *dst++ = ((s >> 3) & 0xfc) * 255 / 0xfc;
-	 *dst++ = ((s << 3) & 0xf8) * 255 / 0xf8;
-      }
-      break;
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
-}
-
-
 
-/* ================================================================
- * ARGB4444 textures:
+/* =============================================================
+ * Convert to ARGB4444 textures:
  */
 
 #define DST_TYPE		GLushort
 #define DST_TEXELS_PER_DWORD	2
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_4444( src[3], src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_4444_LE( src[3], src[0], src[1], src[2] )
 
 #define CONVERT_DIRECT
 
@@ -568,22 +362,22 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_4444( src[3], src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_4444_LE( src[3], src[0], src[1], src[2] )
 
-#define CONVERT_TEXEL_DWORD( src )					\
-		((PACK_COLOR_4444( src[3], src[0], src[1], src[2] )) |	\
-		 (PACK_COLOR_4444( src[7], src[4], src[5], src[6] ) << 16))
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	dst = APPEND16( PACK_COLOR_4444_LE( src[3], src[0], src[1], src[2] ),	\
+			PACK_COLOR_4444_LE( src[7], src[4], src[5], src[6] ) )
 
 #define SRC_TEXEL_BYTES		4
 
-#define TAG(x) x##_rgba8888_to_argb4444
+#define TAG(x) x##_abgr8888_to_argb4444
 #include "texutil_tmp.h"
 
 
 #define CONVERT_ARGB4444( name )					\
 static GLboolean							\
-convert_##name##_argb4444( struct gl_texture_convert *convert )		\
+convert_##name##_argb4444( const struct convert_info *convert )		\
 {									\
    convert_func *tab;							\
    GLint index = convert->index;					\
@@ -596,7 +390,7 @@
    else if ( convert->format == GL_RGBA &&				\
 	     convert->type == GL_UNSIGNED_BYTE )			\
    {									\
-      tab = name##_tab_rgba8888_to_argb4444;				\
+      tab = name##_tab_abgr8888_to_argb4444;				\
    }									\
    else									\
    {									\
@@ -611,41 +405,16 @@
 CONVERT_ARGB4444( texsubimage3d )
 
 
-static void
-unconvert_teximage_argb4444( struct gl_texture_convert *convert )
-{
-   const GLushort *src = (const GLushort *)convert->srcImage;
-   GLubyte *dst = (GLubyte *)convert->dstImage;
-   GLint texels, i;
-
-   texels = convert->width * convert->height * convert->depth;
-
-   switch ( convert->format ) {
-   case GL_RGBA:
-      for ( i = 0 ; i < texels ; i++ ) {
-	 GLushort s = *src++;
-	 *dst++ = ((s >>  8) & 0xf) * 255 / 0xf;
-	 *dst++ = ((s >>  4) & 0xf) * 255 / 0xf;
-	 *dst++ = ((s      ) & 0xf) * 255 / 0xf;
-	 *dst++ = ((s >> 12) & 0xf) * 255 / 0xf;
-      }
-      break;
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
-}
 
-
-
-/* ================================================================
- * ARGB1555 textures:
+/* =============================================================
+ * Convert to ARGB1555 textures:
  */
 
 #define DST_TYPE		GLushort
 #define DST_TEXELS_PER_DWORD	2
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_1555( src[3], src[0], src[1], src[2] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_1555_LE( src[3], src[0], src[1], src[2] )
 
 #define CONVERT_DIRECT
 
@@ -656,22 +425,53 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_1555( src[3], src[0], src[1], src[2] )
+#ifdef MESA_BIG_ENDIAN
 
-#define CONVERT_TEXEL_DWORD( src )					\
-		((PACK_COLOR_1555( src[3], src[0], src[1], src[2] )) |	\
-		 (PACK_COLOR_1555( src[7], src[4], src[5], src[6] ) << 16))
+#define CONVERT_TEXEL( dst, src )					\
+	{ const GLushort s = *(GLushort *)src;				\
+	  dst = (s >> 9) | ((s & 0x1ff) << 7); }
+
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	{ const GLuint s = ((fi_type *)src)->i;				\
+	  dst = (((s & 0xfe00fe00) >> 9) |				\
+		 ((s & 0x01ff01ff) << 7)); }
+
+#else
 
+#define CONVERT_TEXEL( dst, src )					\
+	{ const GLushort s = *(GLushort *)src;				\
+	  dst = (s >> 1) | ((s & 1) << 15); }
+
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	{ const GLuint s = ((fi_type *)src)->i;				\
+	  dst = (((s & 0xfffefffe) >> 1) |				\
+		 ((s & 0x00010001) << 15)); }
+
+#endif
+
+#define SRC_TEXEL_BYTES		2
+
+#define TAG(x) x##_rgba5551_to_argb1555
+#define PRESERVE_DST_TYPE
+#include "texutil_tmp.h"
+
+
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_1555_LE( src[3], src[0], src[1], src[2] )
+
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	dst = APPEND16( PACK_COLOR_1555_LE( src[3], src[0], src[1], src[2] ),	\
+			PACK_COLOR_1555_LE( src[7], src[4], src[5], src[6] ) )
+
 #define SRC_TEXEL_BYTES		4
 
-#define TAG(x) x##_rgba8888_to_argb1555
+#define TAG(x) x##_abgr8888_to_argb1555
 #include "texutil_tmp.h"
 
 
 #define CONVERT_ARGB1555( name )					\
 static GLboolean							\
-convert_##name##_argb1555( struct gl_texture_convert *convert )		\
+convert_##name##_argb1555( const struct convert_info *convert )		\
 {									\
    convert_func *tab;							\
    GLint index = convert->index;					\
@@ -682,9 +482,14 @@
       tab = name##_tab_argb1555_direct;					\
    }									\
    else if ( convert->format == GL_RGBA &&				\
+	     convert->type == GL_UNSIGNED_SHORT_5_5_5_1 )		\
+   {									\
+      tab = name##_tab_rgba5551_to_argb1555;				\
+   }									\
+   else if ( convert->format == GL_RGBA &&				\
 	     convert->type == GL_UNSIGNED_BYTE )			\
    {									\
-      tab = name##_tab_rgba8888_to_argb1555;				\
+      tab = name##_tab_abgr8888_to_argb1555;				\
    }									\
    else									\
    {									\
@@ -699,41 +504,16 @@
 CONVERT_ARGB1555( texsubimage3d )
 
 
-static void
-unconvert_teximage_argb1555( struct gl_texture_convert *convert )
-{
-   const GLushort *src = (const GLushort *)convert->srcImage;
-   GLubyte *dst = (GLubyte *)convert->dstImage;
-   GLint texels, i;
-
-   texels = convert->width * convert->height * convert->depth;
-
-   switch ( convert->format ) {
-   case GL_RGBA:
-      for ( i = 0 ; i < texels ; i++ ) {
-	 GLushort s = *src++;
-	 *dst++ = ((s >> 10) & 0xf8) * 255 / 0xf8;
-	 *dst++ = ((s >>  5) & 0xf8) * 255 / 0xf8;
-	 *dst++ = ((s      ) & 0xf8) * 255 / 0xf8;
-	 *dst++ = ((s >> 15) & 0x01) * 255;
-      }
-      break;
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
-}
-
-
 
-/* ================================================================
- * AL88 textures:
+/* =============================================================
+ * Conver to AL88 textures:
  */
 
 #define DST_TYPE		GLushort
 #define DST_TEXELS_PER_DWORD	2
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_88( src[0], src[1] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_88_LE( src[0], src[1] )
 
 #define CONVERT_DIRECT
 
@@ -744,12 +524,12 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_88( src[0], 0x00 )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_88_LE( src[0], 0x00 )
 
-#define CONVERT_TEXEL_DWORD( src )					\
-		((PACK_COLOR_88( src[0], 0x00 )) |			\
-		 (PACK_COLOR_88( src[1], 0x00 ) << 16))
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	dst = APPEND16( PACK_COLOR_88_LE( src[0], 0x00 ),		\
+			PACK_COLOR_88_LE( src[1], 0x00 ) )
 
 #define SRC_TEXEL_BYTES		1
 
@@ -758,22 +538,36 @@
 #include "texutil_tmp.h"
 
 
-#define CONVERT_TEXEL( src )						\
-		PACK_COLOR_88( 0xff, src[0] )
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_88_LE( 0xff, src[0] )
 
-#define CONVERT_TEXEL_DWORD( src )					\
-		((PACK_COLOR_88( 0xff, src[0] )) |			\
-		 (PACK_COLOR_88( 0xff, src[1] ) << 16))
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	dst = APPEND16( PACK_COLOR_88_LE( 0xff, src[0] ),			\
+			PACK_COLOR_88_LE( 0xff, src[1] ) )
 
 #define SRC_TEXEL_BYTES		1
 
 #define TAG(x) x##_l8_to_al88
+#define PRESERVE_DST_TYPE
 #include "texutil_tmp.h"
 
 
+#define CONVERT_TEXEL( dst, src )					\
+	dst = PACK_COLOR_88_LE( src[3], src[0] )
+
+#define CONVERT_TEXEL_DWORD( dst, src )					\
+	dst = APPEND16( PACK_COLOR_88_LE( src[3], src[0] ),		\
+			PACK_COLOR_88_LE( src[7], src[4] ) )
+
+#define SRC_TEXEL_BYTES		4
+
+#define TAG(x) x##_abgr8888_to_al88
+#include "texutil_tmp.h"
+
+
 #define CONVERT_AL88( name )						\
 static GLboolean							\
-convert_##name##_al88( struct gl_texture_convert *convert )		\
+convert_##name##_al88( const struct convert_info *convert )		\
 {									\
    convert_func *tab;							\
    GLint index = convert->index;					\
@@ -793,6 +587,11 @@
    {									\
       tab = name##_tab_l8_to_al88;					\
    }									\
+   else if ( convert->format == GL_RGBA &&				\
+	     convert->type == GL_UNSIGNED_BYTE )			\
+   {									\
+      tab = name##_tab_abgr8888_to_al88;				\
+   }									\
    else									\
    {									\
       /* Can't handle this source format/type combination */		\
@@ -806,47 +605,13 @@
 CONVERT_AL88( texsubimage3d )
 
 
-static void
-unconvert_teximage_al88( struct gl_texture_convert *convert )
-{
-   const GLubyte *src = (const GLubyte *)convert->srcImage;
-   GLint texels, i;
-
-   texels = convert->width * convert->height * convert->depth;
-
-   switch ( convert->format ) {
-   case GL_LUMINANCE_ALPHA:
-      MEMCPY( convert->dstImage, src, texels * 2 );
-      break;
-   case GL_ALPHA: {
-      GLubyte *dst = (GLubyte *)convert->dstImage;
-      for ( i = 0 ; i < texels ; i++ ) {
-	 *dst++ = src[1];
-	 src += 2;
-      }
-      break;
-   }
-   case GL_LUMINANCE: {
-      GLubyte *dst = (GLubyte *)convert->dstImage;
-      for ( i = 0 ; i < texels ; i++ ) {
-	 *dst++ = src[0];
-	 src += 2;
-      }
-      break;
-   }
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
-}
-
 
-
-/* ================================================================
- * RGB332 textures:
+/* =============================================================
+ * Convert to RGB332 textures:
  */
 
 static GLboolean
-convert_texsubimage2d_rgb332( struct gl_texture_convert *convert )
+convert_texsubimage2d_rgb332( const struct convert_info *convert )
 {
    /* This is a placeholder for now...
     */
@@ -854,7 +619,7 @@
 }
 
 static GLboolean
-convert_texsubimage3d_rgb332( struct gl_texture_convert *convert )
+convert_texsubimage3d_rgb332( const struct convert_info *convert )
 {
    /* This is a placeholder for now...
     */
@@ -862,22 +627,15 @@
 }
 
 
-static void
-unconvert_teximage_rgb332( struct gl_texture_convert *convert )
-{
-   gl_problem(NULL, "texture unconvert error");
-}
-
-
 
-/* ================================================================
- * CI8 (and all other single-byte texel) textures:
+/* =============================================================
+ * Convert to CI8 (and all other single-byte texel) textures:
  */
 
 #define DST_TYPE		GLubyte
 #define DST_TEXELS_PER_DWORD	4
 
-#define CONVERT_TEXEL( src )	src[0]
+#define CONVERT_TEXEL( dst, src )	dst = src[0]
 
 #define CONVERT_DIRECT
 
@@ -889,7 +647,7 @@
 
 #define CONVERT_CI8( name )						\
 static GLboolean							\
-convert_##name##_ci8( struct gl_texture_convert *convert )		\
+convert_##name##_ci8( const struct convert_info *convert )		\
 {									\
    convert_func *tab;							\
    GLint index = convert->index;					\
@@ -915,38 +673,91 @@
 CONVERT_CI8( texsubimage3d )
 
 
-static void
-unconvert_teximage_ci8( struct gl_texture_convert *convert )
-{
-   const GLubyte *src = (const GLubyte *)convert->srcImage;
-   GLint texels;
+/* =============================================================
+ * convert to YCBCR textures:
+ */
 
-   texels = convert->width * convert->height * convert->depth;
+#define DST_TYPE		GLushort
+#define DST_TEXELS_PER_DWORD	2
 
-   switch ( convert->format ) {
-   case GL_ALPHA:
-   case GL_LUMINANCE:
-   case GL_INTENSITY:
-   case GL_COLOR_INDEX:
-      MEMCPY( convert->dstImage, src, texels );
-      break;
-   default:
-      gl_problem(NULL, "texture unconvert error");
-   }
+#define CONVERT_TEXEL( dst, src ) \
+   dst = (src[0] << 8) | src[1];
+
+#define CONVERT_DIRECT
+
+#define SRC_TEXEL_BYTES		2
+
+#define TAG(x) x##_ycbcr_direct
+#include "texutil_tmp.h"
+
+
+#define CONVERT_YCBCR( name )						\
+static GLboolean							\
+convert_##name##_ycbcr( const struct convert_info *convert )		\
+{									\
+   convert_func *tab;							\
+   GLint index = convert->index;					\
+									\
+   if (convert->format != GL_YCBCR_MESA) {				\
+      /* Can't handle this source format/type combination */		\
+      return GL_FALSE;							\
+   }      								\
+   tab = name##_tab_ycbcr_direct;					\
+									\
+   return tab[index]( convert );					\
 }
 
+CONVERT_YCBCR( texsubimage2d )
+CONVERT_YCBCR( texsubimage3d )
 
 
-/* ================================================================
- * Global entry points
+/* =============================================================
+ * convert to YCBCR_REV textures:
  */
 
-static convert_func gl_convert_texsubimage2d_tab[] = {
+#define DST_TYPE		GLushort
+#define DST_TEXELS_PER_DWORD	2
+
+#define CONVERT_TEXEL( dst, src ) \
+   dst = (src[1] << 8) | src[0];
+
+#define CONVERT_DIRECT
+
+#define SRC_TEXEL_BYTES		2
+
+#define TAG(x) x##_ycbcr_rev_direct
+#include "texutil_tmp.h"
+
+
+#define CONVERT_YCBCR_REV( name )					\
+static GLboolean							\
+convert_##name##_ycbcr_rev( const struct convert_info *convert )	\
+{									\
+   convert_func *tab;							\
+   GLint index = convert->index;					\
+									\
+   if (convert->format != GL_YCBCR_MESA) {				\
+      /* Can't handle this source format/type combination */		\
+      return GL_FALSE;							\
+   }      								\
+   tab = name##_tab_ycbcr_rev_direct;					\
+									\
+   return tab[index]( convert );					\
+}
+
+CONVERT_YCBCR_REV( texsubimage2d )
+CONVERT_YCBCR_REV( texsubimage3d )
+
+
+
+/* =============================================================
+ * Tables of texture conversion/packing functions.
+ */
+
+static convert_func convert_texsubimage2d_table[] = {
    convert_texsubimage2d_rgba8888,
-   convert_texsubimage2d_abgr8888,
    convert_texsubimage2d_argb8888,
    convert_texsubimage2d_rgb888,
-   convert_texsubimage2d_bgr888,
    convert_texsubimage2d_rgb565,
    convert_texsubimage2d_argb4444,
    convert_texsubimage2d_argb1555,
@@ -956,14 +767,14 @@
    convert_texsubimage2d_ci8,
    convert_texsubimage2d_ci8,
    convert_texsubimage2d_ci8,
+   convert_texsubimage2d_ycbcr,
+   convert_texsubimage2d_ycbcr_rev,
 };
 
-static convert_func gl_convert_texsubimage3d_tab[] = {
+static convert_func convert_texsubimage3d_table[] = {
    convert_texsubimage3d_rgba8888,
-   convert_texsubimage3d_abgr8888,
    convert_texsubimage3d_argb8888,
    convert_texsubimage3d_rgb888,
-   convert_texsubimage3d_bgr888,
    convert_texsubimage3d_rgb565,
    convert_texsubimage3d_argb4444,
    convert_texsubimage3d_argb1555,
@@ -973,45 +784,30 @@
    convert_texsubimage3d_ci8,
    convert_texsubimage3d_ci8,
    convert_texsubimage3d_ci8,
-};
-
-static unconvert_func gl_unconvert_teximage_tab[] = {
-   unconvert_teximage_rgba8888,
-   unconvert_teximage_abgr8888,
-   unconvert_teximage_argb8888,
-   unconvert_teximage_rgb888,
-   unconvert_teximage_bgr888,
-   unconvert_teximage_rgb565,
-   unconvert_teximage_argb4444,
-   unconvert_teximage_argb1555,
-   unconvert_teximage_al88,
-   unconvert_teximage_rgb332,
-   unconvert_teximage_ci8,		/* These are all the same... */
-   unconvert_teximage_ci8,
-   unconvert_teximage_ci8,
-   unconvert_teximage_ci8,
+   convert_texsubimage3d_ycbcr,
+   convert_texsubimage3d_ycbcr_rev,
 };
 
 
 /* See if we need to care about the pixel store attributes when we're
  * converting the texture image.  This should be stored as
- * packing->_SomeBoolean and updated when the values change, to avoid
+ * unpacking->_SomeBoolean and updated when the values change, to avoid
  * testing every time...
  */
 static INLINE GLboolean
-convert_needs_packing( const struct gl_pixelstore_attrib *packing,
+convert_needs_unpacking( const struct gl_pixelstore_attrib *unpacking,
 		       GLenum format, GLenum type )
 {
-   if ( ( packing->Alignment == 1 ||
-	  ( packing->Alignment == 4 &&	/* Pick up the common Q3A case... */
+   if ( ( unpacking->Alignment == 1 ||
+	  ( unpacking->Alignment == 4 &&   /* Pick up the common Q3A case... */
 	    format == GL_RGBA && type == GL_UNSIGNED_BYTE ) ) &&
-	packing->RowLength == 0 &&
-	packing->SkipPixels == 0 &&
-	packing->SkipRows == 0 &&
-	packing->ImageHeight == 0 &&
-	packing->SkipImages == 0 &&
-	packing->SwapBytes == GL_FALSE &&
-	packing->LsbFirst == GL_FALSE ) {
+	unpacking->RowLength == 0 &&
+	unpacking->SkipPixels == 0 &&
+	unpacking->SkipRows == 0 &&
+	unpacking->ImageHeight == 0 &&
+	unpacking->SkipImages == 0 &&
+	unpacking->SwapBytes == GL_FALSE &&
+	unpacking->LsbFirst == GL_FALSE ) {
       return GL_FALSE;
    } else {
       return GL_TRUE;
@@ -1020,21 +816,21 @@
 
 
 GLboolean
-_mesa_convert_texsubimage1d( GLint mesaFormat,
+_mesa_convert_texsubimage1d( GLint mesaFormat,  /* dest */
 			     GLint xoffset,
 			     GLint width,
-			     GLenum format, GLenum type,
-			     const struct gl_pixelstore_attrib *packing,
+			     GLenum format, GLenum type,  /* source */
+			     const struct gl_pixelstore_attrib *unpacking,
 			     const GLvoid *srcImage, GLvoid *dstImage )
 {
-   struct gl_texture_convert convert;
+   struct convert_info convert;
 
-   ASSERT( packing );
+   ASSERT( unpacking );
    ASSERT( srcImage );
    ASSERT( dstImage );
 
    ASSERT( mesaFormat >= MESA_FORMAT_RGBA8888 );
-   ASSERT( mesaFormat <= MESA_FORMAT_CI8 );
+   ASSERT( mesaFormat <= MESA_FORMAT_YCBCR_REV );
 
    /* Make it easier to pass all the parameters around.
     */
@@ -1044,35 +840,63 @@
    convert.height = 1;
    convert.format = format;
    convert.type = type;
-   convert.packing = packing;
+   convert.unpacking = unpacking;
    convert.srcImage = srcImage;
    convert.dstImage = dstImage;
 
    convert.index = 0;
 
-   if ( convert_needs_packing( packing, format, type ) )
-      convert.index |= CONVERT_PACKING_BIT;
+   if ( convert_needs_unpacking( unpacking, format, type ) )
+      convert.index |= CONVERT_UNPACKING_BIT;
 
-   return gl_convert_texsubimage2d_tab[mesaFormat]( &convert );
+   ASSERT(convert.index < 4);
+
+   return convert_texsubimage2d_table[mesaFormat]( &convert );
 }
 
+
+/* Convert a user's 2D image into a texture image.  This basically
+ * repacks pixel data into the special texture formats used by core Mesa
+ * and the DRI drivers.  This function can do full images or subimages.
+ *
+ * We return a boolean because this function may not accept some kinds
+ * of source image formats and/or types.  For example, if the incoming
+ * format/type = GL_BGR, GL_UNSIGNED_INT this function probably won't
+ * be able to do the conversion.
+ *
+ * In that case, the incoming image should first be simplified to one of
+ * the "canonical" formats (GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA,
+ * GL_INTENSITY, GL_RGB, GL_RGBA) and types (GL_CHAN).  We can do that
+ * with the _mesa_transfer_teximage() function.  That function will also
+ * do image transfer operations such as scale/bias and convolution.
+ *
+ * Input:
+ *   mesaFormat - one of the MESA_FORMAT_* values from texformat.h
+ *   xoffset, yoffset - position in dest image to put data
+ *   width, height - incoming image size, also size of dest region.
+ *   dstImageWidth - width (row stride) of dest image in pixels
+ *   format, type - incoming image format and type
+ *   unpacking - describes incoming image unpacking
+ *   srcImage - pointer to source image
+ *   destImage - pointer to dest image
+ */
 GLboolean
-_mesa_convert_texsubimage2d( GLint mesaFormat,
+_mesa_convert_texsubimage2d( GLint mesaFormat,  /* dest */
 			     GLint xoffset, GLint yoffset,
 			     GLint width, GLint height,
-			     GLint imageWidth,
-			     GLenum format, GLenum type,
-			     const struct gl_pixelstore_attrib *packing,
+			     GLint destImageWidth,
+			     GLenum format, GLenum type,  /* source */
+			     const struct gl_pixelstore_attrib *unpacking,
 			     const GLvoid *srcImage, GLvoid *dstImage )
 {
-   struct gl_texture_convert convert;
+   struct convert_info convert;
 
-   ASSERT( packing );
+   ASSERT( unpacking );
    ASSERT( srcImage );
    ASSERT( dstImage );
 
    ASSERT( mesaFormat >= MESA_FORMAT_RGBA8888 );
-   ASSERT( mesaFormat <= MESA_FORMAT_CI8 );
+   ASSERT( mesaFormat <= MESA_FORMAT_YCBCR_REV );
 
    /* Make it easier to pass all the parameters around.
     */
@@ -1080,41 +904,46 @@
    convert.yoffset = yoffset;
    convert.width = width;
    convert.height = height;
-   convert.imageWidth = imageWidth;
-   convert.format = format;
-   convert.type = type;
-   convert.packing = packing;
+   convert.dstImageWidth = destImageWidth;
+   convert.format = format;  /* src */
+   convert.type = type;      /* src */
+   convert.unpacking = unpacking;
    convert.srcImage = srcImage;
    convert.dstImage = dstImage;
 
    convert.index = 0;
 
-   if ( convert_needs_packing( packing, format, type ) )
-      convert.index |= CONVERT_PACKING_BIT;
+   if ( convert_needs_unpacking( unpacking, format, type ) )
+      convert.index |= CONVERT_UNPACKING_BIT;
 
-   if ( width != imageWidth )
+   if ( width != destImageWidth )
       convert.index |= CONVERT_STRIDE_BIT;
+
+   ASSERT(convert.index < 4);
 
-   return gl_convert_texsubimage2d_tab[mesaFormat]( &convert );
+   ASSERT(mesaFormat < sizeof(convert_texsubimage2d_table) /
+                       sizeof(convert_texsubimage2d_table[0]));
+
+   return convert_texsubimage2d_table[mesaFormat]( &convert );
 }
 
 GLboolean
-_mesa_convert_texsubimage3d( GLint mesaFormat,
+_mesa_convert_texsubimage3d( GLint mesaFormat,  /* dest */
 			     GLint xoffset, GLint yoffset, GLint zoffset,
 			     GLint width, GLint height, GLint depth,
-			     GLint imageWidth, GLint imageHeight,
-			     GLenum format, GLenum type,
-			     const struct gl_pixelstore_attrib *packing,
+			     GLint dstImageWidth, GLint dstImageHeight,
+			     GLenum format, GLenum type,  /* source */
+			     const struct gl_pixelstore_attrib *unpacking,
 			     const GLvoid *srcImage, GLvoid *dstImage )
 {
-   struct gl_texture_convert convert;
+   struct convert_info convert;
 
-   ASSERT( packing );
+   ASSERT( unpacking );
    ASSERT( srcImage );
    ASSERT( dstImage );
 
    ASSERT( mesaFormat >= MESA_FORMAT_RGBA8888 );
-   ASSERT( mesaFormat <= MESA_FORMAT_CI8 );
+   ASSERT( mesaFormat <= MESA_FORMAT_YCBCR_REV );
 
    /* Make it easier to pass all the parameters around.
     */
@@ -1124,118 +953,48 @@
    convert.width = width;
    convert.height = height;
    convert.depth = depth;
-   convert.imageWidth = imageWidth;
-   convert.imageHeight = imageHeight;
+   convert.dstImageWidth = dstImageWidth;
+   convert.dstImageHeight = dstImageHeight;
    convert.format = format;
    convert.type = type;
-   convert.packing = packing;
+   convert.unpacking = unpacking;
    convert.srcImage = srcImage;
    convert.dstImage = dstImage;
 
    convert.index = 0;
 
-   if ( convert_needs_packing( packing, format, type ) )
-      convert.index |= CONVERT_PACKING_BIT;
+   if ( convert_needs_unpacking( unpacking, format, type ) )
+      convert.index |= CONVERT_UNPACKING_BIT;
 
-   if ( width != imageWidth || height != imageHeight )
+   if ( width != dstImageWidth || height != dstImageHeight )
       convert.index |= CONVERT_STRIDE_BIT;
-
-   return gl_convert_texsubimage3d_tab[mesaFormat]( &convert );
-}
-
-
-
-void _mesa_unconvert_teximage1d( GLint mesaFormat, GLenum format, GLint width,
-				 const GLvoid *srcImage, GLvoid *dstImage )
-{
-   struct gl_texture_convert convert;
-
-   ASSERT( srcImage );
-   ASSERT( dstImage );
-
-   ASSERT( mesaFormat >= MESA_FORMAT_RGBA8888 );
-   ASSERT( mesaFormat <= MESA_FORMAT_CI8 );
-
-   /* Make it easier to pass all the parameters around.
-    */
-   convert.width = width;
-   convert.height = 1;
-   convert.depth = 1;
-   convert.format = format;
-   convert.srcImage = srcImage;
-   convert.dstImage = dstImage;
-
-   gl_unconvert_teximage_tab[mesaFormat]( &convert );
-}
-
-void _mesa_unconvert_teximage2d( GLint mesaFormat, GLenum format,
-				 GLint width, GLint height,
-				 const GLvoid *srcImage, GLvoid *dstImage )
-{
-   struct gl_texture_convert convert;
 
-   ASSERT( srcImage );
-   ASSERT( dstImage );
-
-   ASSERT( mesaFormat >= MESA_FORMAT_RGBA8888 );
-   ASSERT( mesaFormat <= MESA_FORMAT_CI8 );
+   ASSERT(convert.index < 4);
 
-   /* Make it easier to pass all the parameters around.
-    */
-   convert.width = width;
-   convert.height = height;
-   convert.depth = 1;
-   convert.format = format;
-   convert.srcImage = srcImage;
-   convert.dstImage = dstImage;
-
-   gl_unconvert_teximage_tab[mesaFormat]( &convert );
+   return convert_texsubimage3d_table[mesaFormat]( &convert );
 }
 
-void _mesa_unconvert_teximage3d( GLint mesaFormat, GLenum format,
-				 GLint width, GLint height, GLint depth,
-				 const GLvoid *srcImage, GLvoid *dstImage )
-{
-   struct gl_texture_convert convert;
 
-   ASSERT( srcImage );
-   ASSERT( dstImage );
-
-   ASSERT( mesaFormat >= MESA_FORMAT_RGBA8888 );
-   ASSERT( mesaFormat <= MESA_FORMAT_CI8 );
-
-   /* Make it easier to pass all the parameters around.
-    */
-   convert.width = width;
-   convert.height = height;
-   convert.depth = depth;
-   convert.format = format;
-   convert.srcImage = srcImage;
-   convert.dstImage = dstImage;
 
-   gl_unconvert_teximage_tab[mesaFormat]( &convert );
-}
-
-
-
 /* Nearest filtering only (for broken hardware that can't support
  * all aspect ratios).  This can be made a lot faster, but I don't
  * really care enough...
  */
-void _mesa_rescale_teximage2d( GLint texelBytes,
+void _mesa_rescale_teximage2d( GLuint bytesPerPixel, GLuint dstRowStride,
 			       GLint srcWidth, GLint srcHeight,
 			       GLint dstWidth, GLint dstHeight,
 			       const GLvoid *srcImage, GLvoid *dstImage )
 {
    GLint row, col;
 
-#define INNER_LOOP( HOP, WOP )						\
+#define INNER_LOOP( TYPE, HOP, WOP )					\
    for ( row = 0 ; row < dstHeight ; row++ ) {				\
       GLint srcRow = row HOP hScale;					\
       for ( col = 0 ; col < dstWidth ; col++ ) {			\
 	 GLint srcCol = col WOP wScale;					\
-	 *dst++ = src[srcRow * srcWidth + srcCol];			\
+	 dst[col] = src[srcRow * srcWidth + srcCol];			\
       }									\
+      dst = (TYPE *) ((GLubyte *) dst + dstRowStride);			\
    }									\
 
 #define RESCALE_IMAGE( TYPE )						\
@@ -1247,27 +1006,27 @@
       const GLint hScale = dstHeight / srcHeight;			\
       if ( srcWidth <= dstWidth ) {					\
 	 const GLint wScale = dstWidth / srcWidth;			\
-	 INNER_LOOP( /, / );						\
+	 INNER_LOOP( TYPE, /, / );					\
       }									\
       else {								\
 	 const GLint wScale = srcWidth / dstWidth;			\
-	 INNER_LOOP( /, * );						\
+	 INNER_LOOP( TYPE, /, * );					\
       }									\
    }									\
    else {								\
       const GLint hScale = srcHeight / dstHeight;			\
       if ( srcWidth <= dstWidth ) {					\
 	 const GLint wScale = dstWidth / srcWidth;			\
-	 INNER_LOOP( *, / );						\
+	 INNER_LOOP( TYPE, *, / );					\
       }									\
       else {								\
 	 const GLint wScale = srcWidth / dstWidth;			\
-	 INNER_LOOP( *, * );						\
+	 INNER_LOOP( TYPE, *, * );					\
       }									\
    }									\
 } while (0)
 
-   switch ( texelBytes ) {
+   switch ( bytesPerPixel ) {
    case 4:
       RESCALE_IMAGE( GLuint );
       break;
@@ -1279,5 +1038,7 @@
    case 1:
       RESCALE_IMAGE( GLubyte );
       break;
+   default:
+      _mesa_problem(NULL,"unexpected bytes/pixel in _mesa_rescale_teximage2d");
    }
 }
Index: xc/extras/Mesa/src/texutil.h
diff -u xc/extras/Mesa/src/texutil.h:1.7 xc/extras/Mesa/src/texutil.h:1.8
--- xc/extras/Mesa/src/texutil.h:1.7	Fri May 18 12:59:55 2001
+++ xc/extras/Mesa/src/texutil.h	Fri Feb 22 14:25:43 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -30,7 +30,7 @@
 #ifndef TEXUTIL_H
 #define TEXUTIL_H
 
-#include "types.h"
+#include "mtypes.h"
 #include "texformat.h"
 
 extern GLboolean
@@ -59,29 +59,14 @@
 			     const struct gl_pixelstore_attrib *packing,
 			     const GLvoid *srcImage, GLvoid *dstImage );
 
-/* Deprecated in 3.5:
- */
-extern void
-_mesa_unconvert_teximage1d( GLint mesaFormat, GLenum format, GLint width,
-			    const GLvoid *srcImage, GLvoid *dstImage );
-
-extern void
-_mesa_unconvert_teximage2d( GLint mesaFormat, GLenum format,
-			    GLint width, GLint height,
-			    const GLvoid *srcImage, GLvoid *dstImage );
-
-extern void
-_mesa_unconvert_teximage3d( GLint mesaFormat, GLenum format,
-			    GLint width, GLint height, GLint depth,
-			    const GLvoid *srcImage, GLvoid *dstImage );
-
 /* Nearest filtering only (for broken hardware that can't support
  * all aspect ratios).  FIXME: Make this a subimage update as well...
  */
 extern void
-_mesa_rescale_teximage2d( GLint texelBytes,
+_mesa_rescale_teximage2d( GLuint bytesPerPixel, GLuint dstRowStride,
 			  GLint srcWidth, GLint srcHeight,
 			  GLint dstWidth, GLint dstHeight,
 			  const GLvoid *srcImage, GLvoid *dstImage );
+
 
 #endif
Index: xc/extras/Mesa/src/texutil_tmp.h
diff -u xc/extras/Mesa/src/texutil_tmp.h:1.1.1.2 xc/extras/Mesa/src/texutil_tmp.h:1.2
--- xc/extras/Mesa/src/texutil_tmp.h:1.1.1.2	Fri May 18 19:59:22 2001
+++ xc/extras/Mesa/src/texutil_tmp.h	Mon Dec 16 11:18:28 2002
@@ -1,72 +1,125 @@
 /*
- * NOTE: All 3D code is untested and most definitely broken...
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Author:
+ *    Gareth Hughes <gareth@valinux.com>
  */
 
+/*
+ * For 2D and 3D texture images, we generate functions for
+ *  - conversion without pixel unpacking and standard stride
+ *  - conversion without pixel unpacking and non-standard stride
+ *  - conversion with pixel unpacking and standard stride
+ *  - conversion with pixel unpacking and non-standard stride
+ *
+ *
+ * Macros which need to be defined before including this file:
+ *  TAG(x)  - the function name wrapper
+ *  DST_TYPE - the destination texel datatype (GLuint, GLushort, etc)
+ *  DST_TEXELS_PER_DWORD - number of dest texels that'll fit in 4 bytes
+ *  CONVERT_TEXEL - code to convert from source to dest texel
+ *  CONVER_TEXEL_DWORD - if multiple texels fit in 4 bytes, this macros
+ *                       will convert/store multiple texels at once
+ *  CONVERT_DIRECT - if defined, just memcpy texels from src to dest
+ *  SRC_TEXEL_BYTES - bytes per source texel
+ *  PRESERVE_DST_TYPE - if defined, don't undefined these macros at end
+ */
+
+
 #define DST_TEXEL_BYTES		(4 / DST_TEXELS_PER_DWORD)
-#define DST_ROW_WIDTH		(convert->width * DST_TEXEL_BYTES)
-#define DST_ROW_STRIDE		(convert->imageWidth * DST_TEXEL_BYTES)
-#define DST_IMG_STRIDE		(convert->imageWidth *			\
-				 convert->imageHeight * DST_TEXEL_BYTES)
+#define DST_ROW_BYTES		(convert->width * DST_TEXEL_BYTES)
+#define DST_ROW_STRIDE		(convert->dstImageWidth * DST_TEXEL_BYTES)
+#define DST_IMG_STRIDE		(convert->dstImageWidth *		\
+				 convert->dstImageHeight * DST_TEXEL_BYTES)
 
 
-/* ================================================================
- * PRE: No pixelstore attribs, width == imageWidth.
+/* =============================================================
+ * PRE: No pixelstore attribs, width == dstImageWidth.
  */
 static GLboolean
-TAG(texsubimage2d)( struct gl_texture_convert *convert )
+TAG(texsubimage2d)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)convert->srcImage;
    GLuint *dst = (GLuint *)((GLubyte *)convert->dstImage +
-			    (convert->yoffset * convert->imageWidth +
+			    (convert->yoffset * convert->dstImageWidth +
 			     convert->xoffset) * DST_TEXEL_BYTES);
-   GLint dwords, i;
-   (void) dwords; (void) i;
 
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ "\n" );
 #endif
 
 #ifdef CONVERT_DIRECT
-   MEMCPY( dst, src, convert->height * DST_ROW_WIDTH );
+   MEMCPY( dst, src, convert->height * DST_ROW_BYTES );
 #else
-   dwords = (convert->width * convert->height +
-	     DST_TEXELS_PER_DWORD - 1) / DST_TEXELS_PER_DWORD;
-
-   for ( i = 0 ; i < dwords ; i++ ) {
-      *dst++ = CONVERT_TEXEL_DWORD( src );
-      src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
+   {
+      const GLint texels = convert->width * convert->height;
+      const GLint dwords = texels / DST_TEXELS_PER_DWORD;
+      const GLint leftover = texels - dwords * DST_TEXELS_PER_DWORD;
+      GLint i;
+      for ( i = 0 ; i < dwords ; i++ ) {
+         CONVERT_TEXEL_DWORD( *dst++, src );
+         src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
+      }
+      for ( i = 0; i < leftover; i++ ) {
+         CONVERT_TEXEL( *dst++, src );
+         src += SRC_TEXEL_BYTES;
+      }
    }
 #endif
 
    return GL_TRUE;
 }
 
-/* PRE: As above, height == imageHeight also.
+/* PRE: As above, height == dstImageHeight also.
  */
 static GLboolean
-TAG(texsubimage3d)( struct gl_texture_convert *convert )
+TAG(texsubimage3d)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)convert->srcImage;
    GLuint *dst = (GLuint *)((GLubyte *)convert->dstImage +
 			    ((convert->zoffset * convert->height +
 			      convert->yoffset) * convert->width +
 			     convert->xoffset) * DST_TEXEL_BYTES);
-   GLint dwords, i;
-   (void) dwords; (void) i;
-
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ "\n" );
 #endif
 
 #ifdef CONVERT_DIRECT
-   MEMCPY( dst, src, convert->depth * convert->height * DST_ROW_WIDTH );
+   MEMCPY( dst, src, convert->depth * convert->height * DST_ROW_BYTES );
 #else
-   dwords = (convert->width * convert->height * convert->depth +
-	     DST_TEXELS_PER_DWORD - 1) / DST_TEXELS_PER_DWORD;
-
-   for ( i = 0 ; i < dwords ; i++ ) {
-      *dst++ = CONVERT_TEXEL_DWORD( src );
-      src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
+   {
+      const GLint texels = convert->width * convert->height * convert->depth;
+      const GLint dwords = texels / DST_TEXELS_PER_DWORD;
+      const GLint leftover = texels - dwords * DST_TEXELS_PER_DWORD;
+      GLint i;
+      for ( i = 0 ; i < dwords ; i++ ) {
+         CONVERT_TEXEL_DWORD( *dst++, src );
+         src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
+      }
+      for ( i = 0; i < leftover; i++ ) {
+         CONVERT_TEXEL( *dst++, src );
+         src += SRC_TEXEL_BYTES;
+      }
    }
 #endif
 
@@ -75,32 +128,32 @@
 
 
 
-/* ================================================================
- * PRE: No pixelstore attribs, width != imageWidth.
+/* =============================================================
+ * PRE: No pixelstore attribs, width != dstImageWidth.
  */
 static GLboolean
-TAG(texsubimage2d_stride)( struct gl_texture_convert *convert )
+TAG(texsubimage2d_stride)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)convert->srcImage;
    DST_TYPE *dst = (DST_TYPE *)((GLubyte *)convert->dstImage +
-				(convert->yoffset * convert->imageWidth +
+				(convert->yoffset * convert->dstImageWidth +
 				 convert->xoffset) * DST_TEXEL_BYTES);
    GLint adjust;
    GLint row, col;
 
-   adjust = convert->imageWidth - convert->width;
+   adjust = convert->dstImageWidth - convert->width;
 
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ ":\n" );
    fprintf( stderr, "   x=%d y=%d w=%d h=%d s=%d\n",
             convert->xoffset, convert->yoffset, convert->width,
-            convert->height, convert->imageWidth );
+            convert->height, convert->dstImageWidth );
    fprintf( stderr, "   adjust=%d\n", adjust );
 #endif
 
    for ( row = 0 ; row < convert->height ; row++ ) {
       for ( col = 0 ; col < convert->width ; col++ ) {
-	 *dst++ = CONVERT_TEXEL( src );
+	 CONVERT_TEXEL( *dst++, src );
 	 src += SRC_TEXEL_BYTES;
       }
       dst += adjust;
@@ -109,33 +162,33 @@
    return GL_TRUE;
 }
 
-/* PRE: As above, or height != imageHeight also.
+/* PRE: As above, or height != dstImageHeight also.
  */
 static GLboolean
-TAG(texsubimage3d_stride)( struct gl_texture_convert *convert )
+TAG(texsubimage3d_stride)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)convert->srcImage;
    DST_TYPE *dst = (DST_TYPE *)((GLubyte *)convert->dstImage +
-				((convert->zoffset * convert->imageHeight +
-				  convert->yoffset) * convert->imageWidth +
+				((convert->zoffset * convert->dstImageHeight +
+				  convert->yoffset) * convert->dstImageWidth +
 				 convert->xoffset) * DST_TEXEL_BYTES);
    GLint adjust;
    GLint row, col, img;
 
-   adjust = convert->imageWidth - convert->width;
+   adjust = convert->dstImageWidth - convert->width;
 
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ ":\n" );
    fprintf( stderr, "   x=%d y=%d w=%d h=%d s=%d\n",
             convert->xoffset, convert->yoffset, convert->width,
-            convert->height, convert->imageWidth );
+            convert->height, convert->dstImageWidth );
    fprintf( stderr, "   adjust=%d\n", adjust );
 #endif
 
    for ( img = 0 ; img < convert->depth ; img++ ) {
       for ( row = 0 ; row < convert->height ; row++ ) {
 	 for ( col = 0 ; col < convert->width ; col++ ) {
-	    *dst++ = CONVERT_TEXEL( src );
+	    CONVERT_TEXEL( *dst++, src );
 	    src += SRC_TEXEL_BYTES;
 	 }
 	 dst += adjust;
@@ -148,92 +201,131 @@
 
 
 
-/* ================================================================
- * PRE: Require pixelstore attribs, width == imageWidth.
+/* =============================================================
+ * PRE: Require pixelstore attribs, width == dstImageWidth.
  */
 static GLboolean
-TAG(texsubimage2d_pack)( struct gl_texture_convert *convert )
+TAG(texsubimage2d_unpack)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)
-      _mesa_image_address( convert->packing, convert->srcImage,
+      _mesa_image_address( convert->unpacking, convert->srcImage,
 			   convert->width, convert->height,
 			   convert->format, convert->type, 0, 0, 0 );
    const GLint srcRowStride =
-      _mesa_image_row_stride( convert->packing, convert->width,
+      _mesa_image_row_stride( convert->unpacking, convert->width,
 			      convert->format, convert->type );
-   GLuint *dst = (GLuint *)((GLubyte *)convert->dstImage +
-			    (convert->yoffset * convert->width +
-			     convert->xoffset) * DST_TEXEL_BYTES);
-   GLint width;
    GLint row, col;
-   (void) col;
 
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ "\n" );
 #endif
-
-   width = ((convert->width + DST_TEXELS_PER_DWORD - 1)
-	    & ~(DST_TEXELS_PER_DWORD - 1));
 
-   for ( row = 0 ; row < convert->height ; row++ ) {
+   if (convert->width & (DST_TEXELS_PER_DWORD - 1)) {
+      /* Can't use dword conversion (i.e. when width = 1 and texels/dword = 2
+       * or width = 2 and texels/dword = 4).
+       */
+      DST_TYPE *dst = (DST_TYPE *)((GLubyte *)convert->dstImage +
+                                   (convert->yoffset * convert->width +
+                                    convert->xoffset) * DST_TEXEL_BYTES);
+      for ( row = 0 ; row < convert->height ; row++ ) {
+         const GLubyte *srcRow = src;
+         for ( col = 0; col < convert->width; col++ ) {
+            CONVERT_TEXEL(*dst, src);
+            src += SRC_TEXEL_BYTES;
+         }
+         src = srcRow + srcRowStride;
+      }
+   }
+   else {
+      /* the common case */
+      GLuint *dst = (GLuint *)((GLubyte *)convert->dstImage +
+                               (convert->yoffset * convert->width +
+                                convert->xoffset) * DST_TEXEL_BYTES);
+      for ( row = 0 ; row < convert->height ; row++ ) {
 #ifdef CONVERT_DIRECT
-      MEMCPY( dst, src, DST_ROW_STRIDE );
-      src += srcRowStride;
-      dst = (GLuint *)((GLubyte *)dst + DST_ROW_STRIDE);
+         MEMCPY( dst, src, DST_ROW_STRIDE );
+         src += srcRowStride;
+         dst = (GLuint *)((GLubyte *)dst + DST_ROW_STRIDE);
 #else
-      const GLubyte *srcRow = src;
-      for ( col = width / DST_TEXELS_PER_DWORD ; col ; col-- ) {
-	 *dst++ = CONVERT_TEXEL_DWORD( src );
-	 src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
-      }
-      src = srcRow + srcRowStride;
+         const GLubyte *srcRow = src;
+         for ( col = convert->width / DST_TEXELS_PER_DWORD ; col ; col-- ) {
+            CONVERT_TEXEL_DWORD( *dst++, src );
+            src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
+         }
+         src = srcRow + srcRowStride;
 #endif
+      }
    }
 
    return GL_TRUE;
 }
 
-/* PRE: as above, height == imageHeight also.
+/* PRE: as above, height == dstImageHeight also.
  */
 static GLboolean
-TAG(texsubimage3d_pack)( struct gl_texture_convert *convert )
+TAG(texsubimage3d_unpack)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)
-      _mesa_image_address( convert->packing, convert->srcImage,
+      _mesa_image_address( convert->unpacking, convert->srcImage,
 			   convert->width, convert->height,
 			   convert->format, convert->type, 0, 0, 0 );
+   const GLint srcImgStride = (const GLubyte *)
+      _mesa_image_address( convert->unpacking, convert->srcImage,
+			   convert->width, convert->height,
+			   convert->format, convert->type, 1, 0, 0 ) - src;
    const GLint srcRowStride =
-      _mesa_image_row_stride( convert->packing, convert->width,
+      _mesa_image_row_stride( convert->unpacking, convert->width,
 			      convert->format, convert->type );
-   GLuint *dst = (GLuint *)((GLubyte *)convert->dstImage +
-			    ((convert->zoffset * convert->height +
-			      convert->yoffset) * convert->width +
-			     convert->xoffset) * DST_TEXEL_BYTES);
-   GLint width;
    GLint row, col, img;
-   (void) col;
 
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ "\n" );
 #endif
-
-   width = ((convert->width + DST_TEXELS_PER_DWORD - 1)
-	    & ~(DST_TEXELS_PER_DWORD - 1));
 
-   for ( img = 0 ; img < convert->depth ; img++ ) {
-      for ( row = 0 ; row < convert->height ; row++ ) {
+   if (convert->width & (DST_TEXELS_PER_DWORD - 1)) {
+      /* Can't use dword conversion (i.e. when width = 1 and texels/dword = 2
+       * or width = 2 and texels/dword = 4).
+       */
+      DST_TYPE *dst = (DST_TYPE *)((GLubyte *)convert->dstImage +
+                                   ((convert->zoffset * convert->height +
+                                     convert->yoffset) * convert->width +
+                                    convert->xoffset) * DST_TEXEL_BYTES);
+      for ( img = 0 ; img < convert->depth ; img++ ) {
+         const GLubyte *srcImage = src;
+         for ( row = 0 ; row < convert->height ; row++ ) {
+            const GLubyte *srcRow = src;
+            for ( col = 0; col < convert->width; col++ ) {
+               CONVERT_TEXEL(*dst, src);
+               src += SRC_TEXEL_BYTES;
+            }
+            src = srcRow + srcRowStride;
+         }
+         src = srcImage + srcImgStride;
+      }
+   }
+   else {
+      /* the common case */
+      GLuint *dst = (GLuint *)((GLubyte *)convert->dstImage +
+                               ((convert->zoffset * convert->height +
+                                 convert->yoffset) * convert->width +
+                                convert->xoffset) * DST_TEXEL_BYTES);
+      for ( img = 0 ; img < convert->depth ; img++ ) {
+         const GLubyte *srcImage = src;
+         for ( row = 0 ; row < convert->height ; row++ ) {
 #ifdef CONVERT_DIRECT
-	 MEMCPY( dst, src, DST_ROW_STRIDE );
-	 src += srcRowStride;
-	 dst = (GLuint *)((GLubyte *)dst + DST_ROW_STRIDE);
+            MEMCPY( dst, src, DST_ROW_STRIDE );
+            src += srcRowStride;
+            dst = (GLuint *)((GLubyte *)dst + DST_ROW_STRIDE);
 #else
-	 const GLubyte *srcRow = src;
-	 for ( col = width / DST_TEXELS_PER_DWORD ; col ; col-- ) {
-	    *dst++ = CONVERT_TEXEL_DWORD( src );
-	    src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
-	 }
-	 src = srcRow + srcRowStride;
+            const GLubyte *srcRow = src;
+            for ( col = convert->width / DST_TEXELS_PER_DWORD ; col ; col-- ) {
+               CONVERT_TEXEL_DWORD( *dst++, src );
+               src += SRC_TEXEL_BYTES * DST_TEXELS_PER_DWORD;
+            }
+            src = srcRow + srcRowStride;
 #endif
+         }
+         src = srcImage + srcImgStride;
       }
    }
 
@@ -242,45 +334,45 @@
 
 
 
-/* ================================================================
- * PRE: Require pixelstore attribs, width != imageWidth.
+/* =============================================================
+ * PRE: Require pixelstore attribs, width != dstImageWidth.
  */
 static GLboolean
-TAG(texsubimage2d_stride_pack)( struct gl_texture_convert *convert )
+TAG(texsubimage2d_stride_unpack)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)
-      _mesa_image_address( convert->packing, convert->srcImage,
+      _mesa_image_address( convert->unpacking, convert->srcImage,
 			   convert->width, convert->height,
 			   convert->format, convert->type, 0, 0, 0 );
    const GLint srcRowStride =
-      _mesa_image_row_stride( convert->packing, convert->width,
+      _mesa_image_row_stride( convert->unpacking, convert->width,
 			      convert->format, convert->type );
    DST_TYPE *dst = (DST_TYPE *)((GLubyte *)convert->dstImage +
-				(convert->yoffset * convert->imageWidth +
+				(convert->yoffset * convert->dstImageWidth +
 				 convert->xoffset) * DST_TEXEL_BYTES);
    GLint adjust;
    GLint row, col;
    (void) col;
 
-   adjust = convert->imageWidth - convert->width;
+   adjust = convert->dstImageWidth - convert->width;
 
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ ":\n" );
    fprintf( stderr, "   x=%d y=%d w=%d h=%d s=%d\n",
             convert->xoffset, convert->yoffset, convert->width,
-            convert->height, convert->imageWidth );
+            convert->height, convert->dstImageWidth );
    fprintf( stderr, "   adjust=%d\n", adjust );
 #endif
 
    for ( row = 0 ; row < convert->height ; row++ ) {
 #ifdef CONVERT_DIRECT
-      MEMCPY( dst, src, DST_ROW_WIDTH );
+      MEMCPY( dst, src, DST_ROW_BYTES );
       src += srcRowStride;
-      dst += convert->imageWidth;
+      dst += convert->dstImageWidth;
 #else
       const GLubyte *srcRow = src;
       for ( col = 0 ; col < convert->width ; col++ ) {
-	 *dst++ = CONVERT_TEXEL( src );
+	 CONVERT_TEXEL( *dst++, src );
 	 src += SRC_TEXEL_BYTES;
       }
       src = srcRow + srcRowStride;
@@ -291,53 +383,58 @@
    return GL_TRUE;
 }
 
-/* PRE: As above, or height != imageHeight also.
+/* PRE: As above, or height != dstImageHeight also.
  */
 static GLboolean
-TAG(texsubimage3d_stride_pack)( struct gl_texture_convert *convert )
+TAG(texsubimage3d_stride_unpack)( const struct convert_info *convert )
 {
    const GLubyte *src = (const GLubyte *)
-      _mesa_image_address( convert->packing, convert->srcImage,
+      _mesa_image_address( convert->unpacking, convert->srcImage,
 			   convert->width, convert->height,
 			   convert->format, convert->type, 0, 0, 0 );
+   const GLint srcImgStride = (const GLubyte *)
+      _mesa_image_address( convert->unpacking, convert->srcImage,
+			   convert->width, convert->height,
+			   convert->format, convert->type, 1, 0, 0 ) - src;
    const GLint srcRowStride =
-      _mesa_image_row_stride( convert->packing, convert->width,
+      _mesa_image_row_stride( convert->unpacking, convert->width,
 			      convert->format, convert->type );
    DST_TYPE *dst = (DST_TYPE *)((GLubyte *)convert->dstImage +
-				((convert->zoffset * convert->imageHeight +
-				  convert->yoffset) * convert->imageWidth +
+				((convert->zoffset * convert->dstImageHeight +
+				  convert->yoffset) * convert->dstImageWidth +
 				 convert->xoffset) * DST_TEXEL_BYTES);
    GLint adjust;
    GLint row, col, img;
    (void) col;
 
-   adjust = convert->imageWidth - convert->width;
+   adjust = convert->dstImageWidth - convert->width;
 
 #if DEBUG_TEXUTIL
    fprintf( stderr, __FUNCTION__ ":\n" );
    fprintf( stderr, "   x=%d y=%d w=%d h=%d s=%d\n",
             convert->xoffset, convert->yoffset, convert->width,
-            convert->height, convert->imageWidth );
+            convert->height, convert->dstImageWidth );
    fprintf( stderr, "   adjust=%d\n", adjust );
 #endif
 
    for ( img = 0 ; img < convert->depth ; img++ ) {
+      const GLubyte *srcImage = src;
       for ( row = 0 ; row < convert->height ; row++ ) {
 #ifdef CONVERT_DIRECT
-	 MEMCPY( dst, src, DST_ROW_WIDTH );
+	 MEMCPY( dst, src, DST_ROW_BYTES );
 	 src += srcRowStride;
-	 dst += convert->imageWidth;
+	 dst += convert->dstImageWidth;
 #else
 	 const GLubyte *srcRow = src;
 	 for ( col = 0 ; col < convert->width ; col++ ) {
-	    *dst++ = CONVERT_TEXEL( src );
+	    CONVERT_TEXEL( *dst++, src );
 	    src += SRC_TEXEL_BYTES;
 	 }
 	 src = srcRow + srcRowStride;
 	 dst += adjust;
 #endif
       }
-      /* FIXME: ... */
+      src = srcImage + srcImgStride;
    }
 
    return GL_TRUE;
@@ -348,15 +445,15 @@
 static convert_func TAG(texsubimage2d_tab)[] = {
    TAG(texsubimage2d),
    TAG(texsubimage2d_stride),
-   TAG(texsubimage2d_pack),
-   TAG(texsubimage2d_stride_pack),
+   TAG(texsubimage2d_unpack),
+   TAG(texsubimage2d_stride_unpack),
 };
 
 static convert_func TAG(texsubimage3d_tab)[] = {
    TAG(texsubimage3d),
    TAG(texsubimage3d_stride),
-   TAG(texsubimage3d_pack),
-   TAG(texsubimage3d_stride_pack),
+   TAG(texsubimage3d_unpack),
+   TAG(texsubimage3d_stride_unpack),
 };
 
 
@@ -367,7 +464,7 @@
 
 #undef SRC_TEXEL_BYTES
 #undef DST_TEXEL_BYTES
-#undef DST_ROW_WIDTH
+#undef DST_ROW_BYTES
 #undef DST_ROW_STRIDE
 
 #undef CONVERT_TEXEL
Index: xc/extras/Mesa/src/trans_tmp.h
diff -u xc/extras/Mesa/src/trans_tmp.h:1.3 xc/extras/Mesa/src/trans_tmp.h:removed
--- xc/extras/Mesa/src/trans_tmp.h:1.3	Tue Feb 15 02:12:38 2000
+++ xc/extras/Mesa/src/trans_tmp.h	Thu Feb 27 12:15:44 2003
@@ -1,183 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-/* KW: It might be possible to organize to do the translation *after*
- *     culling in an array-optimized gl_transform_vb().  
- */
-
-
-#ifdef DEST_4F
-static void DEST_4F( GLfloat (*t)[4],
-		     const struct gl_client_array *from,
-		     ARGS)
-{
-   GLuint stride = from->StrideB;
-   const GLubyte *f = (GLubyte *) from->Ptr + SRC_START * stride;
-   const GLubyte *first = f;
-   GLuint i;
-
-   (void) first;
-   (void) start;
-   for (i = DST_START ; i < n ; i++, NEXT_F) {
-      CHECK { 
-         NEXT_F2;
-	 if (SZ >= 1) t[i][0] = TRX_4F(f, 0);
-	 if (SZ >= 2) t[i][1] = TRX_4F(f, 1);
-	 if (SZ >= 3) t[i][2] = TRX_4F(f, 2);
-	 if (SZ == 4) t[i][3] = TRX_4F(f, 3);
-      }
-   }
-}
-#endif
-
-
-#ifdef DEST_3F
-static void DEST_3F( GLfloat (*t)[3],
-		     const struct gl_client_array *from,
-		     ARGS)
-{
-   GLuint stride = from->StrideB;
-   const GLubyte *f = (GLubyte *) from->Ptr + SRC_START * stride;
-   const GLubyte *first = f;
-   GLuint i;
-   (void) first;
-   (void) start;
-   for (i = DST_START ; i < n ; i++, NEXT_F) {
-      CHECK {
-         NEXT_F2;
-	 t[i][0] = TRX_3F(f, 0);
-	 t[i][1] = TRX_3F(f, 1);
-	 t[i][2] = TRX_3F(f, 2);
-      }
-   }
-}
-#endif
-
-#ifdef DEST_4UB
-static void DEST_4UB( GLubyte (*t)[4],
-		      const struct gl_client_array *from,
-		      ARGS)
-{
-   GLuint stride = from->StrideB;
-   const GLubyte *f = (GLubyte *) from->Ptr + SRC_START * stride;
-   const GLubyte *first = f;
-   GLuint i;
-   (void) start;
-   (void) first;
-   for (i = DST_START ; i < n ; i++, NEXT_F) {
-      CHECK {
-         NEXT_F2;
-	 if (SZ >= 1) TRX_UB(t[i][0], f, 0);
-	 if (SZ >= 2) TRX_UB(t[i][1], f, 1);
-	 if (SZ >= 3) TRX_UB(t[i][2], f, 2); 
-	 if (SZ == 4) TRX_UB(t[i][3], f, 3); else t[i][3] = 255;
-      }
-   }
-}
-#endif
-
-
-#ifdef DEST_1UB
-static void DEST_1UB( GLubyte *t,
-		      const struct gl_client_array *from,
-		      ARGS)
-{
-   GLuint stride = from->StrideB;
-   const GLubyte *f = (GLubyte *) from->Ptr + SRC_START * stride;
-   const GLubyte *first = f;
-   GLuint i;
-   (void) start;
-   (void) first;
-   for (i = DST_START ; i < n ; i++, NEXT_F) {
-      CHECK {
-         NEXT_F2;
-	  TRX_UB(t[i], f, 0);
-      }
-   }
-}
-#endif
-
-
-#ifdef DEST_1UI
-static void DEST_1UI( GLuint *t,
-		      const struct gl_client_array *from,
-		      ARGS)
-{
-   GLuint stride = from->StrideB;
-   const GLubyte *f = (GLubyte *) from->Ptr + SRC_START * stride;
-   const GLubyte *first = f;
-   GLuint i;
-   (void) start;
-   (void) first;
-
-   for (i = DST_START ; i < n ; i++, NEXT_F) {
-      CHECK {
-         NEXT_F2;
-	 t[i] = TRX_UI(f, 0);
-      }
-   }
-}
-#endif
-
-
-static void INIT(void)
-{
-#ifdef DEST_1UI
-   ASSERT(SZ == 1);
-   TAB(_1ui)[SRC_IDX] = DEST_1UI;
-#endif
-#ifdef DEST_1UB
-   ASSERT(SZ == 1);
-   TAB(_1ub)[SRC_IDX] = DEST_1UB;
-#endif
-#ifdef DEST_3F
-   ASSERT(SZ == 3);
-   TAB(_3f)[SRC_IDX] = DEST_3F;
-#endif
-#ifdef DEST_4UB
-   TAB(_4ub)[SZ][SRC_IDX] = DEST_4UB;
-#endif
-#ifdef DEST_4F
-   TAB(_4f)[SZ][SRC_IDX] = DEST_4F;
-#endif
-   
-}
-
-
-#undef INIT
-#undef DEST_1UI
-#undef DEST_1UB
-#undef DEST_4UB
-#undef DEST_3F
-#undef DEST_4F
-#undef SZ
-#undef TAG
-
-
Index: xc/extras/Mesa/src/translate.c
diff -u xc/extras/Mesa/src/translate.c:1.4 xc/extras/Mesa/src/translate.c:removed
--- xc/extras/Mesa/src/translate.c:1.4	Tue Dec 11 04:18:54 2001
+++ xc/extras/Mesa/src/translate.c	Thu Feb 27 12:15:44 2003
@@ -1,909 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/translate.c,v 1.4 2001/12/11 09:18:54 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "mem.h"
-#include "macros.h"
-#include "mmath.h"
-#include "translate.h"
-#include "types.h"
-#endif
-
-/* This macro is used on other systems, so undefine it for this module */
-
-#undef	CHECK
-
-trans_1ui_func gl_trans_1ui_tab[MAX_TYPES];
-trans_1ub_func gl_trans_1ub_tab[MAX_TYPES];
-trans_3f_func  gl_trans_3f_tab[MAX_TYPES];
-trans_4ub_func gl_trans_4ub_tab[5][MAX_TYPES];
-trans_4f_func  gl_trans_4f_tab[5][MAX_TYPES];
-
-trans_elt_1ui_func gl_trans_elt_1ui_tab[MAX_TYPES];
-trans_elt_1ub_func gl_trans_elt_1ub_tab[MAX_TYPES];
-trans_elt_3f_func  gl_trans_elt_3f_tab[MAX_TYPES];
-trans_elt_4ub_func gl_trans_elt_4ub_tab[5][MAX_TYPES];
-trans_elt_4f_func  gl_trans_elt_4f_tab[5][MAX_TYPES];
-
-
-#define PTR_ELT(ptr, elt) (((SRC *)ptr)[elt])
-
-
-#define TAB(x) gl_trans##x##_tab
-#define ARGS   GLuint start, GLuint n
-#define SRC_START  start
-#define DST_START  0
-#define STRIDE stride
-#define NEXT_F f += stride
-#define NEXT_F2
-#define CHECK
-
-
-
-
-/* GL_BYTE
- */
-#define SRC GLbyte
-#define SRC_IDX TYPE_IDX(GL_BYTE)
-#define TRX_3F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
-#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
-
-
-#define SZ 4
-#define INIT init_trans_4_GLbyte_raw
-#define DEST_4F trans_4_GLbyte_4f_raw
-#define DEST_4UB trans_4_GLbyte_4ub_raw
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLbyte_raw
-#define DEST_4F trans_3_GLbyte_4f_raw
-#define DEST_4UB trans_3_GLbyte_4ub_raw
-#define DEST_3F trans_3_GLbyte_3f_raw
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLbyte_raw
-#define DEST_4F trans_2_GLbyte_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLbyte_raw
-#define DEST_4F trans_1_GLbyte_4f_raw
-#define DEST_1UB trans_1_GLbyte_1ub_raw
-#define DEST_1UI trans_1_GLbyte_1ui_raw
-#include "trans_tmp.h"
-
-#undef SRC
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-#undef SRC_IDX
-
-/* GL_UNSIGNED_BYTE
- */
-#define SRC GLubyte
-#define SRC_IDX TYPE_IDX(GL_UNSIGNED_BYTE)
-#define TRX_3F(f,n)		/* unused */
-#define TRX_4F(f,n)		/* unused */
-#define TRX_UB(ub, f,n)	     ub = PTR_ELT(f,n)
-#define TRX_UI(f,n)          (GLuint)PTR_ELT(f,n)
-
-/* 4ub->4ub handled in special case below.
- */
-
-#define SZ 3
-#define INIT init_trans_3_GLubyte_raw
-#define DEST_4UB trans_3_GLubyte_4ub_raw
-#include "trans_tmp.h"
-
-
-#define SZ 1
-#define INIT init_trans_1_GLubyte_raw
-#define DEST_1UI trans_1_GLubyte_1ui_raw
-#define DEST_1UB trans_1_GLubyte_1ub_raw
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_SHORT
- */
-#define SRC GLshort
-#define SRC_IDX TYPE_IDX(GL_SHORT)
-#define TRX_3F(f,n)   SHORT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
-#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
-
-
-#define SZ  4
-#define INIT init_trans_4_GLshort_raw
-#define DEST_4F trans_4_GLshort_4f_raw
-#define DEST_4UB trans_4_GLshort_4ub_raw
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLshort_raw
-#define DEST_4F trans_3_GLshort_4f_raw
-#define DEST_4UB trans_3_GLshort_4ub_raw
-#define DEST_3F trans_3_GLshort_3f_raw
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLshort_raw
-#define DEST_4F trans_2_GLshort_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLshort_raw
-#define DEST_4F trans_1_GLshort_4f_raw
-#define DEST_1UB trans_1_GLshort_1ub_raw
-#define DEST_1UI trans_1_GLshort_1ui_raw
-#include "trans_tmp.h"
-
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_UNSIGNED_SHORT
- */
-#define SRC GLushort
-#define SRC_IDX TYPE_IDX(GL_UNSIGNED_SHORT)
-#define TRX_3F(f,n)   USHORT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub,f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 8)
-#define TRX_UI(f,n)  (GLuint)   PTR_ELT(f,n)
-
-
-#define SZ 4
-#define INIT init_trans_4_GLushort_raw
-#define DEST_4F trans_4_GLushort_4f_raw
-#define DEST_4UB trans_4_GLushort_4ub_raw
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLushort_raw
-#define DEST_4F trans_3_GLushort_4f_raw
-#define DEST_4UB trans_3_GLushort_4ub_raw
-#define DEST_3F trans_3_GLushort_3f_raw
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLushort_raw
-#define DEST_4F trans_2_GLushort_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLushort_raw
-#define DEST_4F trans_1_GLushort_4f_raw
-#define DEST_1UB trans_1_GLushort_1ub_raw
-#define DEST_1UI trans_1_GLushort_1ui_raw
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_INT
- */
-#define SRC GLint
-#define SRC_IDX TYPE_IDX(GL_INT)
-#define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = INT_TO_UBYTE(PTR_ELT(f,n))
-#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
-
-
-#define SZ 4
-#define INIT init_trans_4_GLint_raw
-#define DEST_4F trans_4_GLint_4f_raw
-#define DEST_4UB trans_4_GLint_4ub_raw
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLint_raw
-#define DEST_4F trans_3_GLint_4f_raw
-#define DEST_4UB trans_3_GLint_4ub_raw
-#define DEST_3F trans_3_GLint_3f_raw
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLint_raw
-#define DEST_4F trans_2_GLint_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLint_raw
-#define DEST_4F trans_1_GLint_4f_raw
-#define DEST_1UB trans_1_GLint_1ub_raw
-#define DEST_1UI trans_1_GLint_1ui_raw
-#include "trans_tmp.h"
-
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_UNSIGNED_INT
- */
-#define SRC GLuint
-#define SRC_IDX TYPE_IDX(GL_UNSIGNED_INT)
-#define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 24)
-#define TRX_UI(f,n)		PTR_ELT(f,n)
-
-
-#define SZ 4
-#define INIT init_trans_4_GLuint_raw
-#define DEST_4F trans_4_GLuint_4f_raw
-#define DEST_4UB trans_4_GLuint_4ub_raw
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLuint_raw
-#define DEST_4F trans_3_GLuint_4f_raw
-#define DEST_4UB trans_3_GLuint_4ub_raw
-#define DEST_3F trans_3_GLuint_3f_raw
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLuint_raw
-#define DEST_4F trans_2_GLuint_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLuint_raw
-#define DEST_4F trans_1_GLuint_4f_raw
-#define DEST_1UB trans_1_GLuint_1ub_raw
-#define DEST_1UI trans_1_GLuint_1ui_raw
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_DOUBLE
- */
-#define SRC GLdouble
-#define SRC_IDX TYPE_IDX(GL_DOUBLE)
-#define TRX_3F(f,n)   PTR_ELT(f,n)
-#define TRX_4F(f,n)   PTR_ELT(f,n)
-#define TRX_UB(ub,f,n) FLOAT_COLOR_TO_UBYTE_COLOR(ub, PTR_ELT(f,n))
-#define TRX_UI(f,n)  (GLuint) (GLint) PTR_ELT(f,n)
-
-
-#define SZ 4
-#define INIT init_trans_4_GLdouble_raw
-#define DEST_4F trans_4_GLdouble_4f_raw
-#define DEST_4UB trans_4_GLdouble_4ub_raw
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLdouble_raw
-#define DEST_4F trans_3_GLdouble_4f_raw
-#define DEST_4UB trans_3_GLdouble_4ub_raw
-#define DEST_3F trans_3_GLdouble_3f_raw
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLdouble_raw
-#define DEST_4F trans_2_GLdouble_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLdouble_raw
-#define DEST_4F trans_1_GLdouble_4f_raw
-#define DEST_1UB trans_1_GLdouble_1ub_raw
-#define DEST_1UI trans_1_GLdouble_1ui_raw
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-
-/* GL_FLOAT
- */
-#define SRC GLfloat
-#define SRC_IDX TYPE_IDX(GL_FLOAT)
-#define SZ 4
-#define INIT init_trans_4_GLfloat_raw 
-#define DEST_4UB trans_4_GLfloat_4ub_raw 
-#define DEST_4F  trans_4_GLfloat_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLfloat_raw
-#define DEST_4F  trans_3_GLfloat_4f_raw
-#define DEST_4UB trans_3_GLfloat_4ub_raw
-#define DEST_3F trans_3_GLfloat_3f_raw
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLfloat_raw
-#define DEST_4F trans_2_GLfloat_4f_raw
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLfloat_raw
-#define DEST_4F  trans_1_GLfloat_4f_raw
-#define DEST_1UB trans_1_GLfloat_1ub_raw
-#define DEST_1UI trans_1_GLfloat_1ui_raw
-
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-static void trans_4_GLubyte_4ub_raw (GLubyte (*t)[4],
-				     const struct gl_client_array *from,
-				     ARGS )
-{
-   GLuint stride = from->StrideB;
-   const GLubyte *f = (GLubyte *) from->Ptr + SRC_START * stride;
-   GLuint i;
-
-   if (((((long) f | (long) stride)) & 3L) == 0L) { 
-      /* Aligned.
-       */
-      for (i = DST_START ; i < n ; i++, f += stride) {
-	 COPY_4UBV( t[i], f );
-      }
-   } else {
-      for (i = DST_START ; i < n ; i++, f += stride) {
-	 t[i][0] = f[0];
-	 t[i][1] = f[1];
-	 t[i][2] = f[2];
-	 t[i][3] = f[3];
-      }
-   }
-}
-
-
-static void init_translate_raw(void)
-{
-   MEMSET( TAB(_1ui), 0, sizeof(TAB(_1ui)) );
-   MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
-   MEMSET( TAB(_3f),  0, sizeof(TAB(_3f)) );
-   MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
-   MEMSET( TAB(_4f),  0, sizeof(TAB(_4f)) );
-
-   TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub_raw;
-
-   init_trans_4_GLbyte_raw();
-   init_trans_3_GLbyte_raw();
-   init_trans_2_GLbyte_raw();
-   init_trans_1_GLbyte_raw();
-   init_trans_1_GLubyte_raw();
-   init_trans_3_GLubyte_raw();
-   init_trans_4_GLshort_raw();
-   init_trans_3_GLshort_raw();
-   init_trans_2_GLshort_raw();
-   init_trans_1_GLshort_raw();
-   init_trans_4_GLushort_raw();
-   init_trans_3_GLushort_raw();
-   init_trans_2_GLushort_raw();
-   init_trans_1_GLushort_raw();
-   init_trans_4_GLint_raw();
-   init_trans_3_GLint_raw();
-   init_trans_2_GLint_raw();
-   init_trans_1_GLint_raw();
-   init_trans_4_GLuint_raw();
-   init_trans_3_GLuint_raw();
-   init_trans_2_GLuint_raw();
-   init_trans_1_GLuint_raw();
-   init_trans_4_GLdouble_raw();
-   init_trans_3_GLdouble_raw();
-   init_trans_2_GLdouble_raw();
-   init_trans_1_GLdouble_raw();
-   init_trans_4_GLfloat_raw();
-   init_trans_3_GLfloat_raw();
-   init_trans_2_GLfloat_raw();
-   init_trans_1_GLfloat_raw();
-}
-
-
-#undef TAB
-#undef CLASS
-#undef ARGS
-#undef CHECK
-#undef SRC_START
-#undef DST_START
-#undef NEXT_F
-#undef NEXT_F2
-
-
-/* Code specific to array element implementation.  There is a small
- * subtlety in the bits CHECK() tests, and the way bits are set in
- * glArrayElement which ensures that if, eg, in the case that the
- * vertex array is disabled and normal array is enabled, and we get
- * either sequence:
- *
- * ArrayElement()    OR   Normal()
- * Normal()               ArrayElement()
- * Vertex()               Vertex()
- *
- * That the correct value for normal is used.  
- */
-#define TAB(x) gl_trans_elt##x##_tab
-#define ARGS   GLuint *flags, GLuint *elts, GLuint match, \
-               GLuint start, GLuint n
-#define SRC_START  0
-#define DST_START  start
-#define CHECK  if ((flags[i]&match) == VERT_ELT)
-#define NEXT_F  (void)1
-#define NEXT_F2 f = first + elts[i] * stride; 
-
-
-/* GL_BYTE
- */
-#define SRC GLbyte
-#define SRC_IDX TYPE_IDX(GL_BYTE)
-#define TRX_3F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
-#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
-
-
-#define SZ 4
-#define INIT init_trans_4_GLbyte_elt
-#define DEST_4F trans_4_GLbyte_4f_elt
-#define DEST_4UB trans_4_GLbyte_4ub_elt
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLbyte_elt
-#define DEST_4F trans_3_GLbyte_4f_elt
-#define DEST_4UB trans_3_GLbyte_4ub_elt
-#define DEST_3F trans_3_GLbyte_3f_elt
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLbyte_elt
-#define DEST_4F trans_2_GLbyte_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLbyte_elt
-#define DEST_4F trans_1_GLbyte_4f_elt
-#define DEST_1UB trans_1_GLbyte_1ub_elt
-#define DEST_1UI trans_1_GLbyte_1ui_elt
-#include "trans_tmp.h"
-
-#undef SRC
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-#undef SRC_IDX
-
-/* GL_UNSIGNED_BYTE
- */
-#define SRC GLubyte
-#define SRC_IDX TYPE_IDX(GL_UNSIGNED_BYTE)
-#define TRX_3F(f,n)		/* unused */
-#define TRX_4F(f,n)		/* unused */
-#define TRX_UB(ub, f,n)	     ub = PTR_ELT(f,n)
-#define TRX_UI(f,n)          (GLuint)PTR_ELT(f,n)
-
-/* 4ub->4ub handled in special case below.
- */
-
-#define SZ 3
-#define INIT init_trans_3_GLubyte_elt
-#define DEST_4UB trans_3_GLubyte_4ub_elt
-#include "trans_tmp.h"
-
-
-#define SZ 1
-#define INIT init_trans_1_GLubyte_elt
-#define DEST_1UI trans_1_GLubyte_1ui_elt
-#define DEST_1UB trans_1_GLubyte_1ub_elt
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_SHORT
- */
-#define SRC GLshort
-#define SRC_IDX TYPE_IDX(GL_SHORT)
-#define TRX_3F(f,n)   SHORT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
-#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
-
-
-#define SZ  4
-#define INIT init_trans_4_GLshort_elt
-#define DEST_4F trans_4_GLshort_4f_elt
-#define DEST_4UB trans_4_GLshort_4ub_elt
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLshort_elt
-#define DEST_4F trans_3_GLshort_4f_elt
-#define DEST_4UB trans_3_GLshort_4ub_elt
-#define DEST_3F trans_3_GLshort_3f_elt
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLshort_elt
-#define DEST_4F trans_2_GLshort_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLshort_elt
-#define DEST_4F trans_1_GLshort_4f_elt
-#define DEST_1UB trans_1_GLshort_1ub_elt
-#define DEST_1UI trans_1_GLshort_1ui_elt
-#include "trans_tmp.h"
-
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_UNSIGNED_SHORT
- */
-#define SRC GLushort
-#define SRC_IDX TYPE_IDX(GL_UNSIGNED_SHORT)
-#define TRX_3F(f,n)   USHORT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub,f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 8)
-#define TRX_UI(f,n)  (GLuint)   PTR_ELT(f,n)
-
-
-#define SZ 4
-#define INIT init_trans_4_GLushort_elt
-#define DEST_4F trans_4_GLushort_4f_elt
-#define DEST_4UB trans_4_GLushort_4ub_elt
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLushort_elt
-#define DEST_4F trans_3_GLushort_4f_elt
-#define DEST_4UB trans_3_GLushort_4ub_elt
-#define DEST_3F trans_3_GLushort_3f_elt
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLushort_elt
-#define DEST_4F trans_2_GLushort_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLushort_elt
-#define DEST_4F trans_1_GLushort_4f_elt
-#define DEST_1UB trans_1_GLushort_1ub_elt
-#define DEST_1UI trans_1_GLushort_1ui_elt
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_INT
- */
-#define SRC GLint
-#define SRC_IDX TYPE_IDX(GL_INT)
-#define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = INT_TO_UBYTE(PTR_ELT(f,n))
-#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
-
-
-#define SZ 4
-#define INIT init_trans_4_GLint_elt
-#define DEST_4F trans_4_GLint_4f_elt
-#define DEST_4UB trans_4_GLint_4ub_elt
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLint_elt
-#define DEST_4F trans_3_GLint_4f_elt
-#define DEST_4UB trans_3_GLint_4ub_elt
-#define DEST_3F trans_3_GLint_3f_elt
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLint_elt
-#define DEST_4F trans_2_GLint_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLint_elt
-#define DEST_4F trans_1_GLint_4f_elt
-#define DEST_1UB trans_1_GLint_1ub_elt
-#define DEST_1UI trans_1_GLint_1ui_elt
-#include "trans_tmp.h"
-
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_UNSIGNED_INT
- */
-#define SRC GLuint
-#define SRC_IDX TYPE_IDX(GL_UNSIGNED_INT)
-#define TRX_3F(f,n)   UINT_TO_FLOAT( PTR_ELT(f,n) )
-#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
-#define TRX_UB(ub, f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 24)
-#define TRX_UI(f,n)		PTR_ELT(f,n)
-
-
-#define SZ 4
-#define INIT init_trans_4_GLuint_elt
-#define DEST_4F trans_4_GLuint_4f_elt
-#define DEST_4UB trans_4_GLuint_4ub_elt
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLuint_elt
-#define DEST_4F trans_3_GLuint_4f_elt
-#define DEST_4UB trans_3_GLuint_4ub_elt
-#define DEST_3F trans_3_GLuint_3f_elt
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLuint_elt
-#define DEST_4F trans_2_GLuint_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLuint_elt
-#define DEST_4F trans_1_GLuint_4f_elt
-#define DEST_1UB trans_1_GLuint_1ub_elt
-#define DEST_1UI trans_1_GLuint_1ui_elt
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-/* GL_DOUBLE
- */
-#define SRC GLdouble
-#define SRC_IDX TYPE_IDX(GL_DOUBLE)
-#define TRX_3F(f,n)   PTR_ELT(f,n)
-#define TRX_4F(f,n)   PTR_ELT(f,n)
-#define TRX_UB(ub,f,n) FLOAT_COLOR_TO_UBYTE_COLOR(ub, PTR_ELT(f,n))
-#define TRX_UI(f,n)  (GLuint) (GLint) PTR_ELT(f,n)
-
-
-#define SZ 4
-#define INIT init_trans_4_GLdouble_elt
-#define DEST_4F trans_4_GLdouble_4f_elt
-#define DEST_4UB trans_4_GLdouble_4ub_elt
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLdouble_elt
-#define DEST_4F trans_3_GLdouble_4f_elt
-#define DEST_4UB trans_3_GLdouble_4ub_elt
-#define DEST_3F trans_3_GLdouble_3f_elt
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLdouble_elt
-#define DEST_4F trans_2_GLdouble_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLdouble_elt
-#define DEST_4F trans_1_GLdouble_4f_elt
-#define DEST_1UB trans_1_GLdouble_1ub_elt
-#define DEST_1UI trans_1_GLdouble_1ui_elt
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-
-/* GL_FLOAT
- */
-#define SRC GLfloat
-#define SRC_IDX TYPE_IDX(GL_FLOAT)
-#define SZ 4
-#define INIT init_trans_4_GLfloat_elt 
-#define DEST_4UB trans_4_GLfloat_4ub_elt 
-#define DEST_4F  trans_4_GLfloat_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 3
-#define INIT init_trans_3_GLfloat_elt
-#define DEST_4F  trans_3_GLfloat_4f_elt
-#define DEST_4UB trans_3_GLfloat_4ub_elt
-#define DEST_3F trans_3_GLfloat_3f_elt
-#include "trans_tmp.h"
-
-#define SZ 2
-#define INIT init_trans_2_GLfloat_elt
-#define DEST_4F trans_2_GLfloat_4f_elt
-#include "trans_tmp.h"
-
-#define SZ 1
-#define INIT init_trans_1_GLfloat_elt
-#define DEST_4F  trans_1_GLfloat_3f_elt
-#define DEST_1UB trans_1_GLfloat_1ub_elt
-#define DEST_1UI trans_1_GLfloat_1ui_elt
-#include "trans_tmp.h"
-
-#undef SRC
-#undef SRC_IDX
-#undef TRX_3F
-#undef TRX_4F
-#undef TRX_UB
-#undef TRX_UI
-
-
-static void trans_4_GLubyte_4ub(GLubyte (*t)[4],
-				const struct gl_client_array *from,
-				ARGS )
-{
-   GLuint stride = from->StrideB;
-   const GLubyte *f = (GLubyte *) from->Ptr + SRC_START * stride;
-   const GLubyte *first = f;
-   GLuint i;
-   (void) start;
-   if (((((long) f | (long) stride)) & 3L) == 0L) { 
-      /* Aligned.
-       */
-      for (i = DST_START ; i < n ; i++, NEXT_F) {
-	 CHECK {
-	    NEXT_F2;
-	    COPY_4UBV( t[i], f );
-	 }
-      }
-   } else {
-      for (i = DST_START ; i < n ; i++, NEXT_F) {
-	 CHECK {
-	    NEXT_F2;
-	    t[i][0] = f[0];
-	    t[i][1] = f[1];
-	    t[i][2] = f[2];
-	    t[i][3] = f[3];
-	 }
-      }
-   }
-}
-
-
-static void init_translate_elt(void)
-{
-   MEMSET( TAB(_1ui), 0, sizeof(TAB(_1ui)) );
-   MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
-   MEMSET( TAB(_3f),  0, sizeof(TAB(_3f)) );
-   MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
-   MEMSET( TAB(_4f),  0, sizeof(TAB(_4f)) );
-
-   TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub;
-
-   init_trans_4_GLbyte_elt();
-   init_trans_3_GLbyte_elt();
-   init_trans_2_GLbyte_elt();
-   init_trans_1_GLbyte_elt();
-   init_trans_1_GLubyte_elt();
-   init_trans_3_GLubyte_elt();
-   init_trans_4_GLshort_elt();
-   init_trans_3_GLshort_elt();
-   init_trans_2_GLshort_elt();
-   init_trans_1_GLshort_elt();
-   init_trans_4_GLushort_elt();
-   init_trans_3_GLushort_elt();
-   init_trans_2_GLushort_elt();
-   init_trans_1_GLushort_elt();
-   init_trans_4_GLint_elt();
-   init_trans_3_GLint_elt();
-   init_trans_2_GLint_elt();
-   init_trans_1_GLint_elt();
-   init_trans_4_GLuint_elt();
-   init_trans_3_GLuint_elt();
-   init_trans_2_GLuint_elt();
-   init_trans_1_GLuint_elt();
-   init_trans_4_GLdouble_elt();
-   init_trans_3_GLdouble_elt();
-   init_trans_2_GLdouble_elt();
-   init_trans_1_GLdouble_elt();
-   init_trans_4_GLfloat_elt();
-   init_trans_3_GLfloat_elt();
-   init_trans_2_GLfloat_elt();
-   init_trans_1_GLfloat_elt();
-}
-
-
-#undef TAB
-#undef CLASS
-#undef ARGS
-#undef CHECK
-#undef START
-
-
-
-
-void gl_init_translate( void )
-{
-   init_translate_raw();
-   init_translate_elt();
-}
Index: xc/extras/Mesa/src/translate.h
diff -u xc/extras/Mesa/src/translate.h:1.3 xc/extras/Mesa/src/translate.h:removed
--- xc/extras/Mesa/src/translate.h:1.3	Tue Feb 15 02:12:38 2000
+++ xc/extras/Mesa/src/translate.h	Thu Feb 27 12:15:44 2003
@@ -1,58 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef _TRANSLATE_H_
-#define _TRANSLATE_H_
-
-#include "types.h"
-
-/* Translate GL_UNSIGNED_BYTE, etc to the indexes used in the arrays
- * below.
- */
-#define TYPE_IDX(t) ((t) & 0xf)
-
-#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1      /* 0xa + 1 */
-
-/* Only useful combinations are defined, thus there is no function to
- * translate eg, ubyte->float or ubyte->ubyte, which are never used.  
- */
-extern trans_1ui_func gl_trans_1ui_tab[MAX_TYPES];
-extern trans_1ub_func gl_trans_1ub_tab[MAX_TYPES];
-extern trans_3f_func  gl_trans_3f_tab[MAX_TYPES];
-extern trans_4ub_func gl_trans_4ub_tab[5][MAX_TYPES];
-extern trans_4f_func  gl_trans_4f_tab[5][MAX_TYPES];
-
-extern trans_elt_1ui_func gl_trans_elt_1ui_tab[MAX_TYPES];
-extern trans_elt_1ub_func gl_trans_elt_1ub_tab[MAX_TYPES];
-extern trans_elt_3f_func  gl_trans_elt_3f_tab[MAX_TYPES];
-extern trans_elt_4ub_func gl_trans_elt_4ub_tab[5][MAX_TYPES];
-extern trans_elt_4f_func  gl_trans_elt_4f_tab[5][MAX_TYPES];
-
-
-extern void gl_init_translate( void );
-
-
-#endif
Index: xc/extras/Mesa/src/triangle.c
diff -u xc/extras/Mesa/src/triangle.c:1.11 xc/extras/Mesa/src/triangle.c:removed
--- xc/extras/Mesa/src/triangle.c:1.11	Mon Jan 14 16:07:57 2002
+++ xc/extras/Mesa/src/triangle.c	Thu Feb 27 12:15:44 2003
@@ -1,1688 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Triangle rasterizers
- * When the device driver doesn't implement triangle rasterization Mesa
- * will use these functions to draw triangles.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "aatriangle.h"
-#include "context.h"
-#include "depth.h"
-#include "feedback.h"
-#include "mem.h"
-#include "mmath.h"
-#include "span.h"
-#include "teximage.h"
-#include "texstate.h"
-#include "triangle.h"
-#include "types.h"
-#include "vb.h"
-#endif
-
-
-GLboolean gl_cull_triangle( GLcontext *ctx,
-			    GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   GLfloat (*win)[4] = VB->Win.data;
-   GLfloat ex = win[v1][0] - win[v0][0];
-   GLfloat ey = win[v1][1] - win[v0][1];
-   GLfloat fx = win[v2][0] - win[v0][0];
-   GLfloat fy = win[v2][1] - win[v0][1];
-   GLfloat c = ex*fy-ey*fx;
-
-   if (c * ctx->backface_sign > 0)
-      return 0;
-   
-   return 1;
-}
-
-
-
-
-
-
-/*
- * Render a flat-shaded color index triangle.
- */
-static void flat_ci_triangle( GLcontext *ctx,
-                              GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-#define INTERP_Z 1
-#define SETUP_CODE				\
-   GLuint index = VB->IndexPtr->data[pv];	\
-   if (1) {					\
-      /* set the color index */			\
-      (*ctx->Driver.Index)( ctx, index );	\
-   }
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-	   GLdepth zspan[MAX_WIDTH];				\
-	   if (n>0) {						\
-	      for (i=0;i<n;i++) {				\
-		 zspan[i] = FixedToDepth(ffz);			\
-		 ffz += fdzdx;					\
-	      }							\
-	      gl_write_monoindex_span( ctx, n, LEFT, Y,		\
-	                            zspan, index, GL_POLYGON );	\
-	   }							\
-	}
-
-#include "tritemp.h"	      
-}
-
-
-
-/*
- * Render a smooth-shaded color index triangle.
- */
-static void smooth_ci_triangle( GLcontext *ctx,
-                                GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   (void) pv;
-#define INTERP_Z 1
-#define INTERP_INDEX 1
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-	   GLdepth zspan[MAX_WIDTH];				\
-           GLuint index[MAX_WIDTH];				\
-	   if (n>0) {						\
-	      for (i=0;i<n;i++) {				\
-		 zspan[i] = FixedToDepth(ffz);			\
-                 index[i] = FixedToInt(ffi);			\
-		 ffz += fdzdx;					\
-		 ffi += fdidx;					\
-	      }							\
-	      gl_write_index_span( ctx, n, LEFT, Y, zspan,	\
-	                           index, GL_POLYGON );		\
-	   }							\
-	}
-
-#include "tritemp.h"
-}
-
-
-
-/*
- * Render a flat-shaded RGBA triangle.
- */
-static void flat_rgba_triangle( GLcontext *ctx,
-                                GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-
-#define SETUP_CODE				\
-   if (1) {					\
-      /* set the color */			\
-      GLubyte r = VB->ColorPtr->data[pv][0];	\
-      GLubyte g = VB->ColorPtr->data[pv][1];	\
-      GLubyte b = VB->ColorPtr->data[pv][2];	\
-      GLubyte a = VB->ColorPtr->data[pv][3];	\
-      (*ctx->Driver.Color)( ctx, r, g, b, a );	\
-   }
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-	   GLdepth zspan[MAX_WIDTH];				\
-	   if (n>0) {						\
-	      for (i=0;i<n;i++) {				\
-		 zspan[i] = FixedToDepth(ffz);			\
-		 ffz += fdzdx;					\
-	      }							\
-              gl_write_monocolor_span( ctx, n, LEFT, Y, zspan,	\
-                                       VB->ColorPtr->data[pv],	\
-			               GL_POLYGON );		\
-	   }							\
-	}
-
-#include "tritemp.h"
-
-   ASSERT(!ctx->Texture.ReallyEnabled);  /* texturing must be off */
-   ASSERT(ctx->Light.ShadeModel==GL_FLAT);
-}
-
-
-
-/*
- * Render a smooth-shaded RGBA triangle.
- */
-static void smooth_rgba_triangle( GLcontext *ctx,
-                                  GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-	   GLdepth zspan[MAX_WIDTH];				\
-	   GLubyte rgba[MAX_WIDTH][4];				\
-	   if (n>0) {						\
-	      for (i=0;i<n;i++) {				\
-		 zspan[i] = FixedToDepth(ffz);			\
-		 rgba[i][RCOMP] = FixedToInt(ffr);		\
-		 rgba[i][GCOMP] = FixedToInt(ffg);		\
-		 rgba[i][BCOMP] = FixedToInt(ffb);		\
-		 rgba[i][ACOMP] = FixedToInt(ffa);		\
-		 ffz += fdzdx;					\
-		 ffr += fdrdx;					\
-		 ffg += fdgdx;					\
-		 ffb += fdbdx;					\
-		 ffa += fdadx;					\
-	      }							\
-	      gl_write_rgba_span( ctx, n, LEFT, Y,		\
-                                  (const GLdepth *) zspan,	\
-	                          rgba, GL_POLYGON );		\
-	   }							\
-	}
-
-#include "tritemp.h"
-
-   ASSERT(!ctx->Texture.ReallyEnabled);  /* texturing must be off */
-   ASSERT(ctx->Light.ShadeModel==GL_SMOOTH);
-}
-
-
-
-/*
- * Render an RGB, GL_DECAL, textured triangle.
- * Interpolate S,T only w/out mipmapping or perspective correction.
- */
-static void simple_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                      GLuint v2, GLuint pv )
-{
-#define INTERP_INT_ST 1
-#define S_SCALE twidth
-#define T_SCALE theight
-#define SETUP_CODE							\
-   struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2];	\
-   GLint b = obj->BaseLevel;						\
-   GLfloat twidth = (GLfloat) obj->Image[b]->Width;			\
-   GLfloat theight = (GLfloat) obj->Image[b]->Height;			\
-   GLint twidth_log2 = obj->Image[b]->WidthLog2;			\
-   GLubyte *texture = obj->Image[b]->Data;				\
-   GLint smask = obj->Image[b]->Width - 1;				\
-   GLint tmask = obj->Image[b]->Height - 1;				\
-   (void) pv;								\
-   if (!texture) {							\
-      if (!_mesa_get_teximages_from_driver(ctx, obj))			\
-         return;							\
-      texture = obj->Image[b]->Data;					\
-      ASSERT(texture);							\
-   }
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-	   GLubyte rgb[MAX_WIDTH][3];				\
-	   if (n>0) {						\
-              ffs -= FIXED_HALF; /* off-by-one error? */        \
-              fft -= FIXED_HALF;                                \
-	      for (i=0;i<n;i++) {				\
-                 GLint s = FixedToInt(ffs) & smask;		\
-                 GLint t = FixedToInt(fft) & tmask;		\
-                 GLint pos = (t << twidth_log2) + s;		\
-                 pos = pos + pos + pos;  /* multiply by 3 */	\
-                 rgb[i][RCOMP] = texture[pos];			\
-                 rgb[i][GCOMP] = texture[pos+1];		\
-                 rgb[i][BCOMP] = texture[pos+2];		\
-		 ffs += fdsdx;					\
-		 fft += fdtdx;					\
-	      }							\
-              (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y,	\
-                           (CONST GLubyte (*)[3]) rgb, NULL );	\
-	   }							\
-	}
-
-#include "tritemp.h"
-}
-
-
-/*
- * Render an RGB, GL_DECAL, textured triangle.
- * Interpolate S,T, GL_LESS depth test, w/out mipmapping or
- * perspective correction.
- */
-static void simple_z_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                        GLuint v2, GLuint pv )
-{
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_INT_ST 1
-#define S_SCALE twidth
-#define T_SCALE theight
-#define SETUP_CODE							\
-   struct gl_texture_object *obj = ctx->Texture.Unit[0].CurrentD[2];	\
-   GLint b = obj->BaseLevel;						\
-   GLfloat twidth = (GLfloat) obj->Image[b]->Width;			\
-   GLfloat theight = (GLfloat) obj->Image[b]->Height;			\
-   GLint twidth_log2 = obj->Image[b]->WidthLog2;			\
-   GLubyte *texture = obj->Image[b]->Data;				\
-   GLint smask = obj->Image[b]->Width - 1;				\
-   GLint tmask = obj->Image[b]->Height - 1;				\
-   (void) pv;								\
-   if (!texture) {							\
-      if (!_mesa_get_teximages_from_driver(ctx, obj))			\
-         return;							\
-      texture = obj->Image[b]->Data;					\
-      ASSERT(texture);							\
-   }
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-	   GLubyte rgb[MAX_WIDTH][3];				\
-           GLubyte mask[MAX_WIDTH];				\
-	   if (n>0) {						\
-              ffs -= FIXED_HALF; /* off-by-one error? */        \
-              fft -= FIXED_HALF;                                \
-	      for (i=0;i<n;i++) {				\
-                 GLdepth z = FixedToDepth(ffz);			\
-                 if (z < zRow[i]) {				\
-                    GLint s = FixedToInt(ffs) & smask;		\
-                    GLint t = FixedToInt(fft) & tmask;		\
-                    GLint pos = (t << twidth_log2) + s;		\
-                    pos = pos + pos + pos;  /* multiply by 3 */	\
-                    rgb[i][RCOMP] = texture[pos];		\
-                    rgb[i][GCOMP] = texture[pos+1];		\
-                    rgb[i][BCOMP] = texture[pos+2];		\
-		    zRow[i] = z;				\
-                    mask[i] = 1;				\
-                 }						\
-                 else {						\
-                    mask[i] = 0;				\
-                 }						\
-		 ffz += fdzdx;					\
-		 ffs += fdsdx;					\
-		 fft += fdtdx;					\
-	      }							\
-              (*ctx->Driver.WriteRGBSpan)( ctx, n, LEFT, Y,	\
-                           (CONST GLubyte (*)[3]) rgb, mask );	\
-	   }							\
-	}
-
-#include "tritemp.h"
-}
-
-
-
-/*
- * Render an RGB/RGBA textured triangle without perspective correction.
- */
-static void affine_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				      GLuint v2, GLuint pv )
-{
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_INT_ST 1
-#define S_SCALE twidth
-#define T_SCALE theight
-#define SETUP_CODE							\
-   struct gl_texture_unit *unit = ctx->Texture.Unit+0;			\
-   struct gl_texture_object *obj = unit->CurrentD[2];			\
-   GLint b = obj->BaseLevel;						\
-   GLfloat twidth = (GLfloat) obj->Image[b]->Width;			\
-   GLfloat theight = (GLfloat) obj->Image[b]->Height;			\
-   GLint twidth_log2 = obj->Image[b]->WidthLog2;			\
-   GLubyte *texture = obj->Image[b]->Data;				\
-   GLint smask = obj->Image[b]->Width - 1;				\
-   GLint tmask = obj->Image[b]->Height - 1;                             \
-   GLint format = obj->Image[b]->Format;                                \
-   GLint filter = obj->MinFilter;                                       \
-   GLint envmode = unit->EnvMode;                                       \
-   GLint comp, tbytesline, tsize;                                       \
-   GLfixed er = 0, eg = 0, eb = 0, ea = 0;                              \
-   GLint tr, tg, tb, ta;                                                \
-   if (!texture) {							\
-      if (!_mesa_get_teximages_from_driver(ctx, obj))			\
-         return;							\
-      texture = obj->Image[b]->Data;					\
-      ASSERT(texture);							\
-   }									\
-   if (envmode == GL_BLEND) {                                           \
-      /* potential off-by-one error here? (1.0f -> 2048 -> 0) */        \
-      er = FloatToFixed(unit->EnvColor[0]);                             \
-      eg = FloatToFixed(unit->EnvColor[1]);                             \
-      eb = FloatToFixed(unit->EnvColor[2]);                             \
-      ea = FloatToFixed(unit->EnvColor[3]);                             \
-   }                                                                    \
-   switch (format) {                                                    \
-   case GL_ALPHA:                                                       \
-   case GL_LUMINANCE:                                                   \
-   case GL_INTENSITY:                                                   \
-      comp = 1;                                                         \
-      break;                                                            \
-   case GL_LUMINANCE_ALPHA:                                             \
-      comp = 2;                                                         \
-      break;                                                            \
-   case GL_RGB:                                                         \
-      comp = 3;                                                         \
-      break;                                                            \
-   case GL_RGBA:                                                        \
-      comp = 4;                                                         \
-      break;                                                            \
-   default:                                                             \
-      gl_problem(NULL, "Bad texture format in affine_texture_triangle");\
-      return;                                                           \
-   }                                                                    \
-   tbytesline = obj->Image[b]->Width * comp;                            \
-   tsize = theight * tbytesline;
-   (void) pv;
-
-  /* Instead of defining a function for each mode, a test is done 
-   * between the outer and inner loops. This is to reduce code size
-   * and complexity. Observe that an optimizing compiler kills 
-   * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
-   */ 
-
-#define NEAREST_RGB    \
-        tr = tex00[0]; \
-        tg = tex00[1]; \
-        tb = tex00[2]; \
-        ta = 0xff
-
-#define LINEAR_RGB                                                      \
-	tr = (ti * (si * tex00[0] + sf * tex01[0]) +                    \
-              tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \
-	tg = (ti * (si * tex00[1] + sf * tex01[1]) +                    \
-              tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \
-	tb = (ti * (si * tex00[2] + sf * tex01[2]) +                    \
-              tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \
-	ta = 0xff
-
-#define NEAREST_RGBA   \
-        tr = tex00[0]; \
-        tg = tex00[1]; \
-        tb = tex00[2]; \
-        ta = tex00[3]
-
-#define LINEAR_RGBA                                                     \
-	tr = (ti * (si * tex00[0] + sf * tex01[0]) +                    \
-              tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT; \
-	tg = (ti * (si * tex00[1] + sf * tex01[1]) +                    \
-              tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT; \
-	tb = (ti * (si * tex00[2] + sf * tex01[2]) +                    \
-              tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT; \
-	ta = (ti * (si * tex00[3] + sf * tex01[3]) +                    \
-              tf * (si * tex10[3] + sf * tex11[3])) >> 2 * FIXED_SHIFT
-
-#define MODULATE                                       \
-        dest[0] = ffr * (tr + 1) >> (FIXED_SHIFT + 8); \
-        dest[1] = ffg * (tg + 1) >> (FIXED_SHIFT + 8); \
-        dest[2] = ffb * (tb + 1) >> (FIXED_SHIFT + 8); \
-        dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8)
-
-#define DECAL                                                                \
-	dest[0] = ((0xff - ta) * ffr + ((ta + 1) * tr << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \
-	dest[1] = ((0xff - ta) * ffg + ((ta + 1) * tg << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \
-	dest[2] = ((0xff - ta) * ffb + ((ta + 1) * tb << FIXED_SHIFT)) >> (FIXED_SHIFT + 8); \
-	dest[3] = FixedToInt(ffa)
-
-#define BLEND                                                               \
-        dest[0] = ((0xff - tr) * ffr + (tr + 1) * er) >> (FIXED_SHIFT + 8); \
-        dest[1] = ((0xff - tg) * ffg + (tg + 1) * eg) >> (FIXED_SHIFT + 8); \
-        dest[2] = ((0xff - tb) * ffb + (tb + 1) * eb) >> (FIXED_SHIFT + 8); \
-	dest[3] = ffa * (ta + 1) >> (FIXED_SHIFT + 8)
-
-#define REPLACE       \
-        dest[0] = tr; \
-        dest[1] = tg; \
-        dest[2] = tb; \
-        dest[3] = ta
-
-/* shortcuts */
-
-#define NEAREST_RGB_REPLACE  NEAREST_RGB;REPLACE
-
-#define NEAREST_RGBA_REPLACE  *(GLint *)dest = *(GLint *)tex00
-
-#define SPAN1(DO_TEX,COMP)                                 \
-	for (i=0;i<n;i++) {                                \
-           GLint s = FixedToInt(ffs) & smask;              \
-           GLint t = FixedToInt(fft) & tmask;              \
-           GLint pos = (t << twidth_log2) + s;             \
-           GLubyte *tex00 = texture + COMP * pos;          \
-	   zspan[i] = FixedToDepth(ffz);                   \
-           DO_TEX;                                         \
-	   ffz += fdzdx;                                   \
-           ffr += fdrdx;                                   \
-	   ffg += fdgdx;                                   \
-           ffb += fdbdx;                                   \
-	   ffa += fdadx;                                   \
-	   ffs += fdsdx;                                   \
-	   fft += fdtdx;                                   \
-           dest += 4;                                      \
-	}
-
-#define SPAN2(DO_TEX,COMP)                                 \
-	for (i=0;i<n;i++) {                                \
-           GLint s = FixedToInt(ffs) & smask;              \
-           GLint t = FixedToInt(fft) & tmask;              \
-           GLint sf = ffs & FIXED_FRAC_MASK;               \
-           GLint tf = fft & FIXED_FRAC_MASK;               \
-           GLint si = FIXED_FRAC_MASK - sf;                \
-           GLint ti = FIXED_FRAC_MASK - tf;                \
-           GLint pos = (t << twidth_log2) + s;             \
-           GLubyte *tex00 = texture + COMP * pos;          \
-           GLubyte *tex10 = tex00 + tbytesline;            \
-           GLubyte *tex01 = tex00 + COMP;                  \
-           GLubyte *tex11 = tex10 + COMP;                  \
-           if (t == tmask) {                               \
-              tex10 -= tsize;                              \
-              tex11 -= tsize;                              \
-           }                                               \
-           if (s == smask) {                               \
-              tex01 -= tbytesline;                         \
-              tex11 -= tbytesline;                         \
-           }                                               \
-	   zspan[i] = FixedToDepth(ffz);                   \
-           DO_TEX;                                         \
-	   ffz += fdzdx;                                   \
-           ffr += fdrdx;                                   \
-	   ffg += fdgdx;                                   \
-           ffb += fdbdx;                                   \
-	   ffa += fdadx;                                   \
-	   ffs += fdsdx;                                   \
-	   fft += fdtdx;                                   \
-           dest += 4;                                      \
-	}
-
-/* here comes the heavy part.. (something for the compiler to chew on) */
-#define INNER_LOOP( LEFT, RIGHT, Y )	                   \
-	{				                   \
-	   GLint i, n = RIGHT-LEFT;	                   \
-	   GLdepth zspan[MAX_WIDTH];	                   \
-	   GLubyte rgba[MAX_WIDTH][4];                     \
-	   if (n>0) {                                      \
-              GLubyte *dest = rgba[0];                     \
-              ffs -= FIXED_HALF; /* off-by-one error? */   \
-              fft -= FIXED_HALF;                           \
-              switch (filter) {                            \
-   	      case GL_NEAREST:                             \
-		 switch (format) {                         \
-                 case GL_RGB:                              \
-	            switch (envmode) {                     \
-	            case GL_MODULATE:                      \
-                       SPAN1(NEAREST_RGB;MODULATE,3);      \
-                       break;                              \
-	            case GL_DECAL:                         \
-                    case GL_REPLACE:                       \
-                       SPAN1(NEAREST_RGB_REPLACE,3);       \
-                       break;                              \
-                    case GL_BLEND:                         \
-                       SPAN1(NEAREST_RGB;BLEND,3);         \
-                       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-	            }                                      \
-                    break;                                 \
-		 case GL_RGBA:                             \
-		    switch(envmode) {                      \
-		    case GL_MODULATE:                      \
-                       SPAN1(NEAREST_RGBA;MODULATE,4);     \
-                       break;                              \
-		    case GL_DECAL:                         \
-                       SPAN1(NEAREST_RGBA;DECAL,4);        \
-                       break;                              \
-		    case GL_BLEND:                         \
-                       SPAN1(NEAREST_RGBA;BLEND,4);        \
-                       break;                              \
-		    case GL_REPLACE:                       \
-                       SPAN1(NEAREST_RGBA_REPLACE,4);      \
-                       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-		    }                                      \
-                    break;                                 \
-	         }                                         \
-                 break;                                    \
-	      case GL_LINEAR:                              \
-                 ffs -= FIXED_HALF;                        \
-                 fft -= FIXED_HALF;                        \
-		 switch (format) {                         \
-		 case GL_RGB:                              \
-		    switch (envmode) {                     \
-		    case GL_MODULATE:                      \
-		       SPAN2(LINEAR_RGB;MODULATE,3);       \
-                       break;                              \
-		    case GL_DECAL:                         \
-		    case GL_REPLACE:                       \
-                       SPAN2(LINEAR_RGB;REPLACE,3);        \
-                       break;                              \
-		    case GL_BLEND:                         \
-		       SPAN2(LINEAR_RGB;BLEND,3);          \
-		       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-		    }                                      \
-		    break;                                 \
-		 case GL_RGBA:                             \
-		    switch (envmode) {                     \
-		    case GL_MODULATE:                      \
-		       SPAN2(LINEAR_RGBA;MODULATE,4);      \
-		       break;                              \
-		    case GL_DECAL:                         \
-		       SPAN2(LINEAR_RGBA;DECAL,4);         \
-		       break;                              \
-		    case GL_BLEND:                         \
-		       SPAN2(LINEAR_RGBA;BLEND,4);         \
-		       break;                              \
-		    case GL_REPLACE:                       \
-		       SPAN2(LINEAR_RGBA;REPLACE,4);       \
-		       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-		    }                                      \
-		    break;                                 \
-	         }                                         \
-                 break;                                    \
-	      }                                            \
-              gl_write_rgba_span(ctx, n, LEFT, Y, zspan,   \
-                                 rgba, GL_POLYGON);        \
-              /* explicit kill of variables: */            \
-              ffr = ffg = ffb = ffa = 0;                   \
-           }                                               \
-	}
-
-#include "tritemp.h"
-#undef SPAN1
-#undef SPAN2
-}
-
-
-/*
- * Render an perspective corrected RGB/RGBA textured triangle.
- * The Q (aka V in Mesa) coordinate must be zero such that the divide
- * by interpolated Q/W comes out right.
- */
-static void persp_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				     GLuint v2, GLuint pv )
-{
-/* The BIAS value is used to shift negative values into positive values.
- * Without this, negative texture values don't GL_REPEAT correctly at just
- * below zero.  We're not going to worry about texture coords less than -BIAS.
- * Only seems to be a problem with GL_NEAREST filtering.
- */
-#define BIAS 4096.0F
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV 1
-#define SETUP_CODE							\
-   struct gl_texture_unit *unit = ctx->Texture.Unit+0;			\
-   struct gl_texture_object *obj = unit->CurrentD[2];			\
-   GLint b = obj->BaseLevel;						\
-   GLfloat twidth = (GLfloat) obj->Image[b]->Width;			\
-   GLfloat theight = (GLfloat) obj->Image[b]->Height;			\
-   GLint twidth_log2 = obj->Image[b]->WidthLog2;			\
-   GLubyte *texture = obj->Image[b]->Data;				\
-   GLint smask = (obj->Image[b]->Width - 1);                            \
-   GLint tmask = (obj->Image[b]->Height - 1);                           \
-   GLint format = obj->Image[b]->Format;                                \
-   GLint filter = obj->MinFilter;                                       \
-   GLint envmode = unit->EnvMode;                                       \
-   GLfloat sscale, tscale;                                              \
-   GLint comp, tbytesline, tsize;                                       \
-   GLfixed er = 0, eg = 0, eb = 0, ea = 0;                              \
-   GLint tr, tg, tb, ta;                                                \
-   if (!texture) {							\
-      if (!_mesa_get_teximages_from_driver(ctx, obj))			\
-         return;							\
-      texture = obj->Image[b]->Data;					\
-      ASSERT(texture);							\
-   }									\
-   if (envmode == GL_BLEND) {                                           \
-      er = FloatToFixed(unit->EnvColor[0]);                             \
-      eg = FloatToFixed(unit->EnvColor[1]);                             \
-      eb = FloatToFixed(unit->EnvColor[2]);                             \
-      ea = FloatToFixed(unit->EnvColor[3]);                             \
-   }                                                                    \
-   switch (format) {                                                    \
-   case GL_ALPHA:                                                       \
-   case GL_LUMINANCE:                                                   \
-   case GL_INTENSITY:                                                   \
-      comp = 1;                                                         \
-      break;                                                            \
-   case GL_LUMINANCE_ALPHA:                                             \
-      comp = 2;                                                         \
-      break;                                                            \
-   case GL_RGB:                                                         \
-      comp = 3;                                                         \
-      break;                                                            \
-   case GL_RGBA:                                                        \
-      comp = 4;                                                         \
-      break;                                                            \
-   default:                                                             \
-      gl_problem(NULL, "Bad texture format in persp_texture_triangle"); \
-      return;                                                           \
-   }                                                                    \
-   if (filter == GL_NEAREST) {                                          \
-      sscale = twidth;                                                  \
-      tscale = theight;                                                 \
-   }                                                                    \
-   else {                                                               \
-      sscale = FIXED_SCALE * twidth;                                    \
-      tscale = FIXED_SCALE * theight;                                   \
-   }                                                                    \
-   tbytesline = obj->Image[b]->Width * comp;                            \
-   tsize = theight * tbytesline;
-   (void) pv;
-
-#define SPAN1(DO_TEX,COMP)                                 \
-        for (i=0;i<n;i++) {                                \
-           GLfloat invQ = 1.0f / vv;                       \
-           GLint s = (int)(SS * invQ + BIAS) & smask;      \
-           GLint t = (int)(TT * invQ + BIAS) & tmask;      \
-           GLint pos = COMP * ((t << twidth_log2) + s);    \
-           GLubyte *tex00 = texture + pos;                 \
-	   zspan[i] = FixedToDepth(ffz);                   \
-           DO_TEX;                                         \
-	   ffz += fdzdx;                                   \
-           ffr += fdrdx;                                   \
-	   ffg += fdgdx;                                   \
-           ffb += fdbdx;                                   \
-	   ffa += fdadx;                                   \
-           SS += dSdx;                                     \
-           TT += dTdx;                                     \
-	   vv += dvdx;                                     \
-           dest += 4;                                      \
-	}
-
-#define SPAN2(DO_TEX,COMP)                                 \
-        for (i=0;i<n;i++) {                                \
-           GLfloat invQ = 1.0f / vv;                       \
-           GLfixed ffs = (int)(SS * invQ);                 \
-           GLfixed fft = (int)(TT * invQ);                 \
-	   GLint s = FixedToInt(ffs) & smask;              \
-	   GLint t = FixedToInt(fft) & tmask;              \
-           GLint sf = ffs & FIXED_FRAC_MASK;               \
-           GLint tf = fft & FIXED_FRAC_MASK;               \
-           GLint si = FIXED_FRAC_MASK - sf;                \
-           GLint ti = FIXED_FRAC_MASK - tf;                \
-           GLint pos = COMP * ((t << twidth_log2) + s);    \
-           GLubyte *tex00 = texture + pos;                 \
-           GLubyte *tex10 = tex00 + tbytesline;            \
-           GLubyte *tex01 = tex00 + COMP;                  \
-           GLubyte *tex11 = tex10 + COMP;                  \
-           if (t == tmask) {                               \
-              tex10 -= tsize;                              \
-              tex11 -= tsize;                              \
-           }                                               \
-           if (s == smask) {                               \
-              tex01 -= tbytesline;                         \
-              tex11 -= tbytesline;                         \
-           }                                               \
-	   zspan[i] = FixedToDepth(ffz);                   \
-           DO_TEX;                                         \
-	   ffz += fdzdx;                                   \
-           ffr += fdrdx;                                   \
-	   ffg += fdgdx;                                   \
-           ffb += fdbdx;                                   \
-	   ffa += fdadx;                                   \
-           SS += dSdx;                                     \
-           TT += dTdx;                                     \
-	   vv += dvdx;                                     \
-           dest += 4;                                      \
-	}
-
-#define INNER_LOOP( LEFT, RIGHT, Y )	                   \
-	{				                   \
-	   GLint i, n = RIGHT-LEFT;	                   \
-	   GLdepth zspan[MAX_WIDTH];	                   \
-	   GLubyte rgba[MAX_WIDTH][4];	                   \
-           (void)uu; /* please GCC */                      \
-	   if (n>0) {                                      \
-              GLfloat SS = ss * sscale;                    \
-              GLfloat TT = tt * tscale;                    \
-              GLfloat dSdx = dsdx * sscale;                \
-              GLfloat dTdx = dtdx * tscale;                \
-              GLubyte *dest = rgba[0];                     \
-              switch (filter) {                            \
-   	      case GL_NEAREST:                             \
-		 switch (format) {                         \
-                 case GL_RGB:                              \
-	            switch (envmode) {                     \
-	            case GL_MODULATE:                      \
-                       SPAN1(NEAREST_RGB;MODULATE,3);      \
-                       break;                              \
-	            case GL_DECAL:                         \
-                    case GL_REPLACE:                       \
-                       SPAN1(NEAREST_RGB_REPLACE,3);       \
-                       break;                              \
-                    case GL_BLEND:                         \
-                       SPAN1(NEAREST_RGB;BLEND,3);         \
-                       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-	            }                                      \
-                    break;                                 \
-		 case GL_RGBA:                             \
-		    switch(envmode) {                      \
-		    case GL_MODULATE:                      \
-                       SPAN1(NEAREST_RGBA;MODULATE,4);     \
-                       break;                              \
-		    case GL_DECAL:                         \
-                       SPAN1(NEAREST_RGBA;DECAL,4);        \
-                       break;                              \
-		    case GL_BLEND:                         \
-                       SPAN1(NEAREST_RGBA;BLEND,4);        \
-                       break;                              \
-		    case GL_REPLACE:                       \
-                       SPAN1(NEAREST_RGBA_REPLACE,4);      \
-                       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-		    }                                      \
-                    break;                                 \
-	         }                                         \
-                 break;                                    \
-	      case GL_LINEAR:                              \
-	         SS -= 0.5f * FIXED_SCALE * vv;            \
-		 TT -= 0.5f * FIXED_SCALE * vv;            \
-		 switch (format) {                         \
-		 case GL_RGB:                              \
-		    switch (envmode) {                     \
-		    case GL_MODULATE:                      \
-		       SPAN2(LINEAR_RGB;MODULATE,3);       \
-                       break;                              \
-		    case GL_DECAL:                         \
-		    case GL_REPLACE:                       \
-                       SPAN2(LINEAR_RGB;REPLACE,3);        \
-                       break;                              \
-		    case GL_BLEND:                         \
-		       SPAN2(LINEAR_RGB;BLEND,3);          \
-		       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-		    }                                      \
-		    break;                                 \
-		 case GL_RGBA:                             \
-		    switch (envmode) {                     \
-		    case GL_MODULATE:                      \
-		       SPAN2(LINEAR_RGBA;MODULATE,4);      \
-		       break;                              \
-		    case GL_DECAL:                         \
-		       SPAN2(LINEAR_RGBA;DECAL,4);         \
-		       break;                              \
-		    case GL_BLEND:                         \
-		       SPAN2(LINEAR_RGBA;BLEND,4);         \
-		       break;                              \
-		    case GL_REPLACE:                       \
-		       SPAN2(LINEAR_RGBA;REPLACE,4);       \
-		       break;                              \
-                    default: /* unexpected env mode */     \
-                       abort();                            \
-		    }                                      \
-		    break;                                 \
-	         }                                         \
-                 break;                                    \
-	      }                                            \
-	      gl_write_rgba_span( ctx, n, LEFT, Y, zspan,  \
-				  rgba, GL_POLYGON );      \
-              ffr = ffg = ffb = ffa = 0;                   \
-	   }                                               \
-	}
-
-
-#include "tritemp.h"
-#undef SPAN1
-#undef SPAN2
-#undef BIAS
-}
-
-
-
-/*
- * Render a smooth-shaded, textured, RGBA triangle.
- * Interpolate S,T,U with perspective correction, w/out mipmapping.
- * Note: we use texture coordinates S,T,U,V instead of S,T,R,Q because
- * R is already used for red.
- */
-static void general_textured_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                       GLuint v2, GLuint pv )
-{
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV 1
-#define SETUP_CODE						\
-   GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT);	\
-   GLint r = 0, g = 0, b = 0, a = 0;				\
-   if (flat_shade) {						\
-      r = VB->ColorPtr->data[pv][0];				\
-      g = VB->ColorPtr->data[pv][1];				\
-      b = VB->ColorPtr->data[pv][2];				\
-      a = VB->ColorPtr->data[pv][3];				\
-   }
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-	   GLdepth zspan[MAX_WIDTH];				\
-	   GLubyte rgba[MAX_WIDTH][4];				\
-           GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH];	\
-	   if (n>0) {						\
-              if (flat_shade) {					\
-                 for (i=0;i<n;i++) {				\
-		    GLdouble invQ = 1.0 / vv;			\
-		    zspan[i] = FixedToDepth(ffz);		\
-		    rgba[i][RCOMP] = r;				\
-		    rgba[i][GCOMP] = g;				\
-		    rgba[i][BCOMP] = b;				\
-		    rgba[i][ACOMP] = a;				\
-		    s[i] = ss*invQ;				\
-		    t[i] = tt*invQ;				\
-		    u[i] = uu*invQ;				\
-		    ffz += fdzdx;				\
-		    ss += dsdx;					\
-		    tt += dtdx;					\
-		    uu += dudx;					\
-		    vv += dvdx;					\
-		 }						\
-              }							\
-              else {						\
-                 for (i=0;i<n;i++) {				\
-		    GLdouble invQ = 1.0 / vv;			\
-		    zspan[i] = FixedToDepth(ffz);		\
-		    rgba[i][RCOMP] = FixedToInt(ffr);		\
-		    rgba[i][GCOMP] = FixedToInt(ffg);		\
-		    rgba[i][BCOMP] = FixedToInt(ffb);		\
-		    rgba[i][ACOMP] = FixedToInt(ffa);		\
-		    s[i] = ss*invQ;				\
-		    t[i] = tt*invQ;				\
-		    u[i] = uu*invQ;				\
-		    ffz += fdzdx;				\
-		    ffr += fdrdx;				\
-		    ffg += fdgdx;				\
-		    ffb += fdbdx;				\
-		    ffa += fdadx;				\
-		    ss += dsdx;					\
-		    tt += dtdx;					\
-		    uu += dudx;					\
-		    vv += dvdx;					\
-		 }						\
-              }							\
-	      gl_write_texture_span( ctx, n, LEFT, Y, zspan,	\
-                                     s, t, u, NULL, 		\
-	                             rgba, \
-                                     NULL, GL_POLYGON );	\
-	   }							\
-	}
-
-#include "tritemp.h"
-}
-
-
-/*
- * Render a smooth-shaded, textured, RGBA triangle with separate specular
- * color interpolation.
- * Interpolate S,T,U with perspective correction, w/out mipmapping.
- * Note: we use texture coordinates S,T,U,V instead of S,T,R,Q because
- * R is already used for red.
- */
-static void general_textured_spec_triangle1( GLcontext *ctx, GLuint v0,
-                                             GLuint v1, GLuint v2, GLuint pv,
-                                             GLdepth zspan[MAX_WIDTH],
-                                             GLubyte rgba[MAX_WIDTH][4],
-                                             GLubyte spec[MAX_WIDTH][4] )
-{
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_SPEC 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV 1
-#define SETUP_CODE						\
-   GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT);	\
-   GLint r = 0, g = 0, b = 0, a = 0, sr = 0, sg = 0, sb = 0;	\
-   if (flat_shade) {						\
-      r = VB->ColorPtr->data[pv][0];				\
-      g = VB->ColorPtr->data[pv][1];				\
-      b = VB->ColorPtr->data[pv][2];				\
-      a = VB->ColorPtr->data[pv][3];				\
-      sr = VB->Specular[pv][0]; 				\
-      sg = VB->Specular[pv][1]; 				\
-      sb = VB->Specular[pv][2]; 				\
-   }
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-	{							\
-	   GLint i, n = RIGHT-LEFT;				\
-           GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH];	\
-	   if (n>0) {						\
-              if (flat_shade) {					\
-                 for (i=0;i<n;i++) {				\
-		    GLdouble invQ = 1.0 / vv;			\
-		    zspan[i] = FixedToDepth(ffz);		\
-		    rgba[i][RCOMP] = r;				\
-		    rgba[i][GCOMP] = g;				\
-		    rgba[i][BCOMP] = b;				\
-		    rgba[i][ACOMP] = a;				\
-		    spec[i][RCOMP] = sr;			\
-		    spec[i][GCOMP] = sg;			\
-		    spec[i][BCOMP] = sb;			\
-		    s[i] = ss*invQ;				\
-		    t[i] = tt*invQ;				\
-		    u[i] = uu*invQ;				\
-		    ffz += fdzdx;				\
-		    ss += dsdx;					\
-		    tt += dtdx;					\
-		    uu += dudx;					\
-		    vv += dvdx;					\
-		 }						\
-              }							\
-              else {						\
-                 for (i=0;i<n;i++) {				\
-		    GLdouble invQ = 1.0 / vv;			\
-		    zspan[i] = FixedToDepth(ffz);		\
-		    rgba[i][RCOMP] = FixedToInt(ffr);		\
-		    rgba[i][GCOMP] = FixedToInt(ffg);		\
-		    rgba[i][BCOMP] = FixedToInt(ffb);		\
-		    rgba[i][ACOMP] = FixedToInt(ffa);		\
-		    spec[i][RCOMP] = FixedToInt(ffsr);		\
-		    spec[i][GCOMP] = FixedToInt(ffsg);		\
-		    spec[i][BCOMP] = FixedToInt(ffsb);		\
-		    s[i] = ss*invQ;				\
-		    t[i] = tt*invQ;				\
-		    u[i] = uu*invQ;				\
-		    ffz += fdzdx;				\
-		    ffr += fdrdx;				\
-		    ffg += fdgdx;				\
-		    ffb += fdbdx;				\
-		    ffa += fdadx;				\
-		    ffsr += fdsrdx;				\
-		    ffsg += fdsgdx;				\
-		    ffsb += fdsbdx;				\
-		    ss += dsdx;					\
-		    tt += dtdx;					\
-		    uu += dudx;					\
-		    vv += dvdx;					\
-		 }						\
-              }							\
-	      gl_write_texture_span( ctx, n, LEFT, Y, zspan,	\
-                                   s, t, u, NULL, rgba,		\
-                                   (CONST GLubyte (*)[4]) spec,	\
-	                           GL_POLYGON );		\
-	   }							\
-	}
-
-#include "tritemp.h"
-}
-
-
-
-/*
- * Compute the lambda value for a fragment. (texture level of detail)
- */
-static INLINE GLfloat
-compute_lambda( GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
-                GLfloat invQ, GLfloat width, GLfloat height ) 
-{
-   GLfloat dudx = dsdx * invQ * width;
-   GLfloat dudy = dsdy * invQ * width;
-   GLfloat dvdx = dtdx * invQ * height;
-   GLfloat dvdy = dtdy * invQ * height;
-   GLfloat r1 = dudx * dudx + dudy * dudy;
-   GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
-   GLfloat rho2 = r1 + r2;     /* used to be:  rho2 = MAX2(r1,r2); */
-   /* return log base 2 of rho */
-   return log(rho2) * 1.442695 * 0.5;       /* 1.442695 = 1/log(2) */
-}
-
-
-/*
- * Render a smooth-shaded, textured, RGBA triangle.
- * Interpolate S,T,U with perspective correction and compute lambda for
- * each fragment.  Lambda is used to determine whether to use the
- * minification or magnification filter.  If minification and using
- * mipmaps, lambda is also used to select the texture level of detail.
- */
-static void lambda_textured_triangle1( GLcontext *ctx, GLuint v0, GLuint v1,
-                                       GLuint v2, GLuint pv,
-                                       GLfloat s[MAX_WIDTH],
-                                       GLfloat t[MAX_WIDTH],
-                                       GLfloat u[MAX_WIDTH] )
-{
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV 1
-
-#define SETUP_CODE							\
-   const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current;	\
-   const GLint baseLevel = obj->BaseLevel;				\
-   const struct gl_texture_image *texImage = obj->Image[baseLevel];	\
-   const GLfloat twidth = (GLfloat) texImage->Width;			\
-   const GLfloat theight = (GLfloat) texImage->Height;			\
-   const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT);	\
-   GLint r = 0, g = 0, b = 0, a = 0;					\
-   if (flat_shade) {							\
-      r = VB->ColorPtr->data[pv][0];					\
-      g = VB->ColorPtr->data[pv][1];					\
-      b = VB->ColorPtr->data[pv][2];					\
-      a = VB->ColorPtr->data[pv][3];					\
-   }
-
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-	{								\
-	   GLint i, n = RIGHT-LEFT;					\
-	   GLdepth zspan[MAX_WIDTH];					\
-	   GLubyte rgba[MAX_WIDTH][4];					\
-	   GLfloat lambda[MAX_WIDTH];					\
-	   if (n>0) {							\
-	      if (flat_shade) {						\
-		 for (i=0;i<n;i++) {					\
-		    GLdouble invQ = 1.0 / vv;				\
-		    zspan[i] = FixedToDepth(ffz);			\
-		    rgba[i][RCOMP] = r;					\
-		    rgba[i][GCOMP] = g;					\
-		    rgba[i][BCOMP] = b;					\
-		    rgba[i][ACOMP] = a;					\
-		    s[i] = ss*invQ;					\
-		    t[i] = tt*invQ;					\
-		    u[i] = uu*invQ;					\
-		    lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy,	\
-						invQ, twidth, theight );\
-		    ffz += fdzdx;					\
-		    ss += dsdx;						\
-		    tt += dtdx;						\
-		    uu += dudx;						\
-		    vv += dvdx;						\
-		 }							\
-              }								\
-              else {							\
-		 for (i=0;i<n;i++) {					\
-		    GLdouble invQ = 1.0 / vv;				\
-		    zspan[i] = FixedToDepth(ffz);			\
-		    rgba[i][RCOMP] = FixedToInt(ffr);			\
-		    rgba[i][GCOMP] = FixedToInt(ffg);			\
-		    rgba[i][BCOMP] = FixedToInt(ffb);			\
-		    rgba[i][ACOMP] = FixedToInt(ffa);			\
-		    s[i] = ss*invQ;					\
-		    t[i] = tt*invQ;					\
-		    u[i] = uu*invQ;					\
-		    lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy,	\
-						invQ, twidth, theight );\
-		    ffz += fdzdx;					\
-		    ffr += fdrdx;					\
-		    ffg += fdgdx;					\
-		    ffb += fdbdx;					\
-		    ffa += fdadx;					\
-		    ss += dsdx;						\
-		    tt += dtdx;						\
-		    uu += dudx;						\
-		    vv += dvdx;						\
-		 }							\
-              }								\
-	      gl_write_texture_span( ctx, n, LEFT, Y, zspan,		\
-                                     s, t, u, lambda,	 		\
-	                             rgba, NULL, GL_POLYGON );		\
-	   }								\
-	}
-
-#include "tritemp.h"
-}
-
-
-/*
- * Render a smooth-shaded, textured, RGBA triangle with separate specular
- * interpolation.
- * Interpolate S,T,U with perspective correction and compute lambda for
- * each fragment.  Lambda is used to determine whether to use the
- * minification or magnification filter.  If minification and using
- * mipmaps, lambda is also used to select the texture level of detail.
- */
-static void lambda_textured_spec_triangle1( GLcontext *ctx, GLuint v0,
-                                            GLuint v1, GLuint v2, GLuint pv,
-                                            GLfloat s[MAX_WIDTH],
-                                            GLfloat t[MAX_WIDTH],
-                                            GLfloat u[MAX_WIDTH] )
-{
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_SPEC 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV 1
-
-#define SETUP_CODE							\
-   const struct gl_texture_object *obj = ctx->Texture.Unit[0].Current;	\
-   const GLint baseLevel = obj->BaseLevel;				\
-   const struct gl_texture_image *texImage = obj->Image[baseLevel];	\
-   const GLfloat twidth = (GLfloat) texImage->Width;			\
-   const GLfloat theight = (GLfloat) texImage->Height;			\
-   const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT);	\
-   GLint r = 0, g = 0, b = 0, a = 0, sr = 0, sg = 0, sb = 0;		\
-   if (flat_shade) {							\
-      r = VB->ColorPtr->data[pv][0];					\
-      g = VB->ColorPtr->data[pv][1];					\
-      b = VB->ColorPtr->data[pv][2];					\
-      a = VB->ColorPtr->data[pv][3];					\
-      sr = VB->Specular[pv][0];						\
-      sg = VB->Specular[pv][1];						\
-      sb = VB->Specular[pv][2];						\
-   }
-
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-	{								\
-	   GLint i, n = RIGHT-LEFT;					\
-	   GLdepth zspan[MAX_WIDTH];					\
-	   GLubyte spec[MAX_WIDTH][4];					\
-           GLubyte rgba[MAX_WIDTH][4];					\
-	   GLfloat lambda[MAX_WIDTH];					\
-	   if (n>0) {							\
-	      if (flat_shade) {						\
-		 for (i=0;i<n;i++) {					\
-		    GLdouble invQ = 1.0 / vv;				\
-		    zspan[i] = FixedToDepth(ffz);			\
-		    rgba[i][RCOMP] = r;					\
-		    rgba[i][GCOMP] = g;					\
-		    rgba[i][BCOMP] = b;					\
-		    rgba[i][ACOMP] = a;					\
-		    spec[i][RCOMP] = sr;				\
-		    spec[i][GCOMP] = sg;				\
-		    spec[i][BCOMP] = sb;				\
-		    s[i] = ss*invQ;					\
-		    t[i] = tt*invQ;					\
-		    u[i] = uu*invQ;					\
-		    lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy,	\
-						invQ, twidth, theight );\
-		    ffz += fdzdx;					\
-		    ss += dsdx;						\
-		    tt += dtdx;						\
-		    uu += dudx;						\
-		    vv += dvdx;						\
-		 }							\
-              }								\
-              else {							\
-		 for (i=0;i<n;i++) {					\
-		    GLdouble invQ = 1.0 / vv;				\
-		    zspan[i] = FixedToDepth(ffz);			\
-		    rgba[i][RCOMP] = FixedToInt(ffr);			\
-		    rgba[i][GCOMP] = FixedToInt(ffg);			\
-		    rgba[i][BCOMP] = FixedToInt(ffb);			\
-		    rgba[i][ACOMP] = FixedToInt(ffa);			\
-		    spec[i][RCOMP] = FixedToInt(ffsr);			\
-		    spec[i][GCOMP] = FixedToInt(ffsg);			\
-		    spec[i][BCOMP] = FixedToInt(ffsb);			\
-		    s[i] = ss*invQ;					\
-		    t[i] = tt*invQ;					\
-		    u[i] = uu*invQ;					\
-		    lambda[i] = compute_lambda( dsdx, dsdy, dtdx, dtdy,	\
-						invQ, twidth, theight );\
-		    ffz += fdzdx;					\
-		    ffr += fdrdx;					\
-		    ffg += fdgdx;					\
-		    ffb += fdbdx;					\
-		    ffa += fdadx;					\
-		    ffsr += fdsrdx;					\
-		    ffsg += fdsgdx;					\
-		    ffsb += fdsbdx;					\
-		    ss += dsdx;						\
-		    tt += dtdx;						\
-		    uu += dudx;						\
-		    vv += dvdx;						\
-		 }							\
-              }								\
-	      gl_write_texture_span( ctx, n, LEFT, Y, zspan,		\
-                                     s, t, u, lambda,	 		\
-	                             rgba, (CONST GLubyte (*)[4]) spec, \
-                                     GL_POLYGON );			\
-	   }								\
-	}
-
-#include "tritemp.h"
-}
-
-
-/*
- * This is the big one!
- * Interpolate Z, RGB, Alpha, and two sets of texture coordinates.
- * Yup, it's slow.
- */
-static void lambda_multitextured_triangle1( GLcontext *ctx, GLuint v0,
-                                      GLuint v1, GLuint v2, GLuint pv,
-                                      GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                                      GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
-                                      GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH]
-                                      )
-{
-   GLubyte rgba[MAX_WIDTH][4];
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INTERP_ALPHA 1
-#define INTERP_STUV 1
-#define INTERP_STUV1 1
-
-#define SETUP_CODE							\
-   const struct gl_texture_object *obj0 = ctx->Texture.Unit[0].Current;	\
-   const struct gl_texture_object *obj1 = ctx->Texture.Unit[1].Current;	\
-   const struct gl_texture_image *texImage0, *texImage1;		\
-   GLfloat twidth0, theight0, twidth1, theight1;			\
-   const GLboolean flat_shade = (ctx->Light.ShadeModel==GL_FLAT);	\
-   GLint r = 0, g = 0, b = 0, a = 0;					\
-   if (obj0) {								\
-      texImage0 = obj0->Image[obj0->BaseLevel];				\
-      twidth0 = texImage0->Width;					\
-      theight0 = texImage0->Height;					\
-   }									\
-   else {								\
-      twidth0 = theight0 = 1;						\
-   }									\
-   if (obj1) {								\
-      texImage1 = obj1->Image[obj1->BaseLevel];				\
-      twidth1 = texImage1->Width;					\
-      theight1 = texImage1->Height;					\
-   }									\
-   else {								\
-      twidth1 = theight1 = 1;						\
-   }									\
-   if (flat_shade) {							\
-      r = VB->ColorPtr->data[pv][0];					\
-      g = VB->ColorPtr->data[pv][1];					\
-      b = VB->ColorPtr->data[pv][2];					\
-      a = VB->ColorPtr->data[pv][3];					\
-   }
-
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-	{								\
-	   GLint i, n = RIGHT-LEFT;					\
-	   GLdepth zspan[MAX_WIDTH];					\
-           GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];		\
-	   if (n>0) {							\
-	      if (flat_shade) {						\
-		 for (i=0;i<n;i++) {					\
-		    GLdouble invQ = 1.0 / vv;				\
-		    GLdouble invQ1 = 1.0 / vv1;				\
-		    zspan[i] = FixedToDepth(ffz);			\
-		    rgba[i][RCOMP] = r;					\
-		    rgba[i][GCOMP] = g;					\
-		    rgba[i][BCOMP] = b;					\
-		    rgba[i][ACOMP] = a;					\
-		    s[0][i] = ss*invQ;					\
-		    t[0][i] = tt*invQ;					\
-		    u[0][i] = uu*invQ;					\
-		    lambda[0][i] = compute_lambda( dsdx, dsdy,		\
-						   dtdx, dtdy,		\
-						   invQ,		\
-						   twidth0, theight0 );	\
-		    s[1][i] = ss1*invQ1;				\
-		    t[1][i] = tt1*invQ1;				\
-		    u[1][i] = uu1*invQ1;				\
-		    lambda[1][i] = compute_lambda( ds1dx, ds1dy,	\
-						   dt1dx, dt1dy,	\
-						   invQ1,		\
-						   twidth1, theight1 );	\
-		    ffz += fdzdx;					\
-		    ss += dsdx;						\
-		    tt += dtdx;						\
-		    uu += dudx;						\
-		    vv += dvdx;						\
-		    ss1 += ds1dx;					\
-		    tt1 += dt1dx;					\
-		    uu1 += du1dx;					\
-		    vv1 += dv1dx;					\
-		 }							\
-              }								\
-              else {							\
-		 for (i=0;i<n;i++) {					\
-		    GLdouble invQ = 1.0 / vv;				\
-		    GLdouble invQ1 = 1.0 / vv1;				\
-		    zspan[i] = FixedToDepth(ffz);			\
-		    rgba[i][RCOMP] = FixedToInt(ffr);			\
-		    rgba[i][GCOMP] = FixedToInt(ffg);			\
-		    rgba[i][BCOMP] = FixedToInt(ffb);			\
-		    rgba[i][ACOMP] = FixedToInt(ffa);			\
-		    s[0][i] = ss*invQ;					\
-		    t[0][i] = tt*invQ;					\
-		    u[0][i] = uu*invQ;					\
-		    lambda[0][i] = compute_lambda( dsdx, dsdy,		\
-						   dtdx, dtdy,		\
-						   invQ,		\
-						   twidth0, theight0 );	\
-		    s[1][i] = ss1*invQ1;				\
-		    t[1][i] = tt1*invQ1;				\
-		    u[1][i] = uu1*invQ1;				\
-		    lambda[1][i] = compute_lambda( ds1dx, ds1dy,	\
-						   dt1dx, dt1dy,	\
-						   invQ1,		\
-						   twidth1, theight1 );	\
-		    ffz += fdzdx;					\
-		    ffr += fdrdx;					\
-		    ffg += fdgdx;					\
-		    ffb += fdbdx;					\
-		    ffa += fdadx;					\
-		    ss += dsdx;						\
-		    tt += dtdx;						\
-		    uu += dudx;						\
-		    vv += dvdx;						\
-		    ss1 += ds1dx;					\
-		    tt1 += dt1dx;					\
-		    uu1 += du1dx;					\
-		    vv1 += dv1dx;					\
-		 }							\
-              }								\
-	      gl_write_multitexture_span( ctx, 2, n, LEFT, Y, zspan,	\
-                                      (CONST GLfloat (*)[MAX_WIDTH]) s,	\
-                                      (CONST GLfloat (*)[MAX_WIDTH]) t,	\
-                                      (CONST GLfloat (*)[MAX_WIDTH]) u,	\
-                                      (GLfloat (*)[MAX_WIDTH]) lambda,	\
-	                              rgba, NULL, GL_POLYGON );		\
-	   }								\
-	}
-
-#include "tritemp.h"
-}
-
-
-/*
- * These wrappers are needed to deal with the 32KB / stack frame limit
- * on Mac / PowerPC systems.
- */
-
-static void general_textured_spec_triangle(GLcontext *ctx, GLuint v0,
-                                           GLuint v1, GLuint v2, GLuint pv)
-{
-   GLdepth zspan[MAX_WIDTH];
-   GLubyte rgba[MAX_WIDTH][4], spec[MAX_WIDTH][4];
-   general_textured_spec_triangle1(ctx,v0,v1,v2,pv,zspan,rgba,spec);
-}
-
-static void lambda_textured_triangle( GLcontext *ctx, GLuint v0,
-                                      GLuint v1, GLuint v2, GLuint pv )
-{
-   GLfloat s[MAX_WIDTH], t[MAX_WIDTH], u[MAX_WIDTH];
-   lambda_textured_triangle1(ctx,v0,v1,v2,pv,s,t,u);
-}
-
-static void lambda_textured_spec_triangle( GLcontext *ctx, GLuint v0,
-                                           GLuint v1, GLuint v2, GLuint pv )
-{
-   GLfloat s[MAX_WIDTH];
-   GLfloat t[MAX_WIDTH];
-   GLfloat u[MAX_WIDTH];
-   lambda_textured_spec_triangle1(ctx,v0,v1,v2,pv,s,t,u);
-}
-
-
-static void lambda_multitextured_triangle( GLcontext *ctx, GLuint v0,
-                                           GLuint v1, GLuint v2, GLuint pv)
-{
-
-   GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH];
-   GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH];
-   DEFMARRAY(GLfloat,u,MAX_TEXTURE_UNITS,MAX_WIDTH);
-   CHECKARRAY(u,return);
-   
-   lambda_multitextured_triangle1(ctx,v0,v1,v2,pv,s,t,u);
-   
-   UNDEFARRAY(u);
-}
-
-
-
-static void occlusion_zless_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                      GLuint v2, GLuint pv )
-{
-   (void)pv;
-   if (ctx->OcclusionResult) {
-      return;
-   }
-
-#define DO_OCCLUSION_TEST
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INNER_LOOP( LEFT, RIGHT, Y )		\
-   {						\
-      GLint i, len = RIGHT-LEFT;		\
-      for (i=0;i<len;i++) {			\
-	 GLdepth z = FixedToDepth(ffz);		\
-	 if (z < zRow[i]) {			\
-	    ctx->OcclusionResult = GL_TRUE;	\
-	    return;				\
-	 }					\
-	 ffz += fdzdx;				\
-      }						\
-   }
-#include "tritemp.h"
-}
-
-
-
-/*
- * Null rasterizer for measuring transformation speed.
- */
-static void null_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                           GLuint v2, GLuint pv )
-{
-   (void) ctx;
-   (void) v0;
-   (void) v1;
-   (void) v2;
-   (void) pv;
-}
-
-
-#if 0
-# define dputs(s) puts(s)
-#else
-# define dputs(s)
-#endif
-
-
-
-/*
- * Determine which triangle rendering function to use given the current
- * rendering context.
- */
-void gl_set_triangle_function( GLcontext *ctx )
-{
-   GLboolean rgbmode = ctx->Visual->RGBAflag;
-
-   if (ctx->RenderMode==GL_RENDER) {
-      if (ctx->NoRaster) {
-         ctx->Driver.TriangleFunc = null_triangle;
-         return;
-      }
-      if (ctx->Driver.TriangleFunc) {
-         /* Device driver will draw triangles. */
-         dputs("Driver triangle");
-	 return;
-      }
-
-      if (ctx->Polygon.SmoothFlag) {
-         _mesa_set_aa_triangle_function(ctx);
-         ASSERT(ctx->Driver.TriangleFunc);
-         return;
-      }
-
-      if (ctx->Depth.OcclusionTest &&
-          ctx->DrawBuffer->DepthBuffer &&
-          ctx->Depth.Test &&
-          ctx->Depth.Mask == GL_FALSE &&
-          ctx->Depth.Func == GL_LESS &&
-          !ctx->Stencil.Enabled) {
-         if ((ctx->Visual->RGBAflag &&
-              ctx->Color.ColorMask[0] == 0 && 
-              ctx->Color.ColorMask[1] == 0 && 
-              ctx->Color.ColorMask[2] == 0 &&
-              ctx->Color.ColorMask[3] == 0)
-             ||
-             (!ctx->Visual->RGBAflag && ctx->Color.IndexMask == 0)) {
-            dputs("occlusion_test_triangle");
-            ctx->Driver.TriangleFunc = occlusion_zless_triangle;
-            return;
-         }
-      }
-
-      if (ctx->Texture.ReallyEnabled) {
-         /* Ugh, we do a _lot_ of tests to pick the best textured tri func */
-	 GLint format, filter;
-	 const struct gl_texture_object *current2Dtex = ctx->Texture.Unit[0].CurrentD[2];
-         const struct gl_texture_image *image;
-         /* First see if we can used an optimized 2-D texture function */
-         if (ctx->Texture.ReallyEnabled==TEXTURE0_2D
-             && current2Dtex->WrapS==GL_REPEAT
-	     && current2Dtex->WrapT==GL_REPEAT
-             && ((image = current2Dtex->Image[current2Dtex->BaseLevel]) != 0)  /* correct! */
-             && image->Border==0
-             && ((format = image->Format)==GL_RGB || format==GL_RGBA)
-	     && (filter = current2Dtex->MinFilter)==current2Dtex->MagFilter
-	     && ctx->Light.Model.ColorControl==GL_SINGLE_COLOR
-	     && ctx->Texture.Unit[0].EnvMode!=GL_COMBINE_EXT) {
-
-	    if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) {
-	     
-	       if (filter==GL_NEAREST
-		   && format==GL_RGB
-		   && (ctx->Texture.Unit[0].EnvMode==GL_REPLACE
-		       || ctx->Texture.Unit[0].EnvMode==GL_DECAL)
-		   && ((ctx->RasterMask==DEPTH_BIT
-			&& ctx->Depth.Func==GL_LESS
-			&& ctx->Depth.Mask==GL_TRUE)
-		       || ctx->RasterMask==0)
-		   && ctx->Polygon.StippleFlag==GL_FALSE) {
-
-		  if (ctx->RasterMask==DEPTH_BIT) {
-		     ctx->Driver.TriangleFunc = simple_z_textured_triangle;
-		     dputs("simple_z_textured_triangle");
-		  }
-		  else {
-		     ctx->Driver.TriangleFunc = simple_textured_triangle;
-		     dputs("simple_textured_triangle");
-		  }
-	       }
-	       else {
-                  if (ctx->Texture.Unit[0].EnvMode==GL_ADD) {
-                     ctx->Driver.TriangleFunc = general_textured_triangle;
-                     dputs("general_textured_triangle");
-                  }
-                  else {
-                     ctx->Driver.TriangleFunc = affine_textured_triangle;
-                     dputs("affine_textured_triangle");
-                  }
-	       }
-	    }
-	    else {
-	       ctx->Driver.TriangleFunc = persp_textured_triangle;
-	       dputs("persp_textured_triangle");
-	    }
-	 }
-         else {
-            /* More complicated textures (mipmap, multi-tex, sep specular) */
-            GLboolean needLambda;
-            /* if mag filter != min filter we need to compute lambda */
-            const struct gl_texture_object *obj0 = ctx->Texture.Unit[0].Current;
-            const struct gl_texture_object *obj1 = ctx->Texture.Unit[1].Current;
-            if (obj0 && obj0->MinFilter != obj0->MagFilter)
-               needLambda = GL_TRUE;
-            else if (obj1 && obj1->MinFilter != obj1->MagFilter)
-               needLambda = GL_TRUE;
-            else
-               needLambda = GL_FALSE;
-            if (ctx->Texture.ReallyEnabled >= TEXTURE1_1D) {
-               /* multi-texture! */
-               ctx->Driver.TriangleFunc = lambda_multitextured_triangle;
-	       dputs("lambda_multitextured_triangle");
-            }
-            else if (ctx->Light.Enabled &&
-               ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR) {
-               /* separate specular color interpolation */
-               if (needLambda) {
-                  ctx->Driver.TriangleFunc = lambda_textured_spec_triangle;
-		  dputs("lambda_textured_spec_triangle");
-	       }
-               else {
-                  ctx->Driver.TriangleFunc = general_textured_spec_triangle;
-		  dputs("general_textured_spec_triangle");
-	       }
-            }
-            else {
-               if (needLambda) {
-                  ctx->Driver.TriangleFunc = lambda_textured_triangle;
-		  dputs("lambda_textured_triangle");
-	       }
-               else {
-                  ctx->Driver.TriangleFunc = general_textured_triangle;
-		  dputs("general_textured_triangle");
-	       }
-            }
-         }
-      }
-      else {
-	 if (ctx->Light.ShadeModel==GL_SMOOTH) {
-	    /* smooth shaded, no texturing, stippled or some raster ops */
-            if (rgbmode) {
-               dputs("smooth_rgba_triangle");
-               ctx->Driver.TriangleFunc = smooth_rgba_triangle;
-            }
-            else {
-               dputs("smooth_ci_triangle");
-               ctx->Driver.TriangleFunc = smooth_ci_triangle;
-            }
-	 }
-	 else {
-	    /* flat shaded, no texturing, stippled or some raster ops */
-            if (rgbmode) {
-               dputs("flat_rgba_triangle");
-               ctx->Driver.TriangleFunc = flat_rgba_triangle;
-            }
-            else {
-               dputs("flat_ci_triangle");
-               ctx->Driver.TriangleFunc = flat_ci_triangle;
-            }
-	 }
-      }
-   }
-   else if (ctx->RenderMode==GL_FEEDBACK) {
-      ctx->Driver.TriangleFunc = gl_feedback_triangle;
-   }
-   else {
-      /* GL_SELECT mode */
-      ctx->Driver.TriangleFunc = gl_select_triangle;
-   }
-}
Index: xc/extras/Mesa/src/triangle.h
diff -u xc/extras/Mesa/src/triangle.h:1.3 xc/extras/Mesa/src/triangle.h:removed
--- xc/extras/Mesa/src/triangle.h:1.3	Tue Feb 15 02:12:39 2000
+++ xc/extras/Mesa/src/triangle.h	Thu Feb 27 12:15:44 2003
@@ -1,42 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef TRIANGLES_H
-#define TRIANGLES_H
-
-
-#include "types.h"
-
-
-void gl_set_triangle_function( GLcontext *ctx );
-GLboolean gl_cull_triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv );
-
-
-#endif
-
Index: xc/extras/Mesa/src/tritemp.h
diff -u xc/extras/Mesa/src/tritemp.h:1.14 xc/extras/Mesa/src/tritemp.h:removed
--- xc/extras/Mesa/src/tritemp.h:1.14	Mon Jan 14 16:07:57 2002
+++ xc/extras/Mesa/src/tritemp.h	Thu Feb 27 12:15:44 2003
@@ -1,1111 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/tritemp.h,v 1.14 2002/01/14 21:07:57 tsi Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.4.1
- *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Triangle Rasterizer Template
- *
- * This file is #include'd to generate custom triangle rasterizers.
- *
- * The following macros may be defined to indicate what auxillary information
- * must be interplated across the triangle:
- *    INTERP_Z      - if defined, interpolate Z values
- *    INTERP_RGB    - if defined, interpolate RGB values
- *    INTERP_SPEC   - if defined, interpolate specular RGB values
- *    INTERP_ALPHA  - if defined, interpolate Alpha values
- *    INTERP_INDEX  - if defined, interpolate color index values
- *    INTERP_INT_ST - if defined, interpolate integer ST texcoords
- *                         (fast, simple 2-D texture mapping)
- *    INTERP_STUV   - if defined, interpolate set 0 float STRQ texcoords
- *                         NOTE:  OpenGL STRQ = Mesa STUV (R was taken for red)
- *    INTERP_STUV1  - if defined, interpolate set 1 float STRQ texcoords
- *
- * When one can directly address pixels in the color buffer the following
- * macros can be defined and used to compute pixel addresses during
- * rasterization (see pRow):
- *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)
- *    BYTES_PER_ROW       - number of bytes per row in the color buffer
- *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
- *                          Y==0 at bottom of screen and increases upward.
- *
- * Similarly, for direct depth buffer access, this type is used for depth
- * buffer addressing:
- *    DEPTH_TYPE          - either GLushort or GLuint
- *
- * Optionally, one may provide one-time setup code per triangle:
- *    SETUP_CODE    - code which is to be executed once per triangle
- *
- * The following macro MUST be defined:
- *    INNER_LOOP(LEFT,RIGHT,Y) - code to write a span of pixels.
- *        Something like:
- *
- *                    for (x=LEFT; x<RIGHT;x++) {
- *                       put_pixel(x,Y);
- *                       // increment fixed point interpolants
- *                    }
- *
- * This code was designed for the origin to be in the lower-left corner.
- *
- * Inspired by triangle rasterizer code written by Allen Akin.  Thanks Allen!
- */
-
-
-/*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/
-{
-   typedef struct {
-        GLint v0, v1;   /* Y(v0) < Y(v1) */
-	GLfloat dx;	/* X(v1) - X(v0) */
-	GLfloat dy;	/* Y(v1) - Y(v0) */
-	GLfixed fdxdy;	/* dx/dy in fixed-point */
-	GLfixed fsx;	/* first sample point x coord */
-	GLfixed fsy;
-	GLfloat adjy;	/* adjust from v[0]->fy to fsy, scaled */
-	GLint lines;	/* number of lines to be sampled on this edge */
-	GLfixed fx0;	/* fixed pt X of lower endpoint */
-   } EdgeT;
-
-#ifdef INTERP_Z
-   const GLint depthBits = ctx->Visual->DepthBits;
-   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
-   const GLfloat maxDepth = ctx->Visual->DepthMaxF;
-#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
-#endif
-   const struct vertex_buffer *VB = ctx->VB;
-   EdgeT eMaj, eTop, eBot;
-   GLfloat oneOverArea;
-   int vMin, vMid, vMax;       /* vertex indexes:  Y(vMin)<=Y(vMid)<=Y(vMax) */
-   float bf = ctx->backface_sign;
-   GLboolean tiny;
-
-   /* find the order of the 3 vertices along the Y axis */
-   {
-      GLfloat y0 = VB->Win.data[v0][1];
-      GLfloat y1 = VB->Win.data[v1][1];
-      GLfloat y2 = VB->Win.data[v2][1];
-
-      if (y0<=y1) {
-	 if (y1<=y2) {
-	    vMin = v0;   vMid = v1;   vMax = v2;   /* y0<=y1<=y2 */
-	 }
-	 else if (y2<=y0) {
-	    vMin = v2;   vMid = v0;   vMax = v1;   /* y2<=y0<=y1 */
-	 }
-	 else {
-	    vMin = v0;   vMid = v2;   vMax = v1;  bf = -bf; /* y0<=y2<=y1 */
-	 }
-      }
-      else {
-	 if (y0<=y2) {
-	    vMin = v1;   vMid = v0;   vMax = v2;  bf = -bf; /* y1<=y0<=y2 */
-	 }
-	 else if (y2<=y1) {
-	    vMin = v2;   vMid = v1;   vMax = v0;  bf = -bf; /* y2<=y1<=y0 */
-	 }
-	 else {
-	    vMin = v1;   vMid = v2;   vMax = v0;   /* y1<=y2<=y0 */
-	 }
-      }
-   }
-
-   /* vertex/edge relationship */
-   eMaj.v0 = vMin;   eMaj.v1 = vMax;   /*TODO: .v1's not needed */
-   eTop.v0 = vMid;   eTop.v1 = vMax;
-   eBot.v0 = vMin;   eBot.v1 = vMid;
-
-   /* compute deltas for each edge:  vertex[v1] - vertex[v0] */
-   eMaj.dx = VB->Win.data[vMax][0] - VB->Win.data[vMin][0];
-   eMaj.dy = VB->Win.data[vMax][1] - VB->Win.data[vMin][1];
-   eTop.dx = VB->Win.data[vMax][0] - VB->Win.data[vMid][0];
-   eTop.dy = VB->Win.data[vMax][1] - VB->Win.data[vMid][1];
-   eBot.dx = VB->Win.data[vMid][0] - VB->Win.data[vMin][0];
-   eBot.dy = VB->Win.data[vMid][1] - VB->Win.data[vMin][1];
-
-   /* compute oneOverArea */
-   {
-      const GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;
-
-      /* Do backface culling */
-      if (area * bf < 0.0)
-	 return;
-
-      if (area == 0.0F || IS_INF_OR_NAN(area) )
-         return;
-
-      /* check for very tiny triangle */
-      if (area * area < 0.0025F) {  /* square it to ensure positive value */
-         oneOverArea = 1.0F / 0.0025F;  /* a close-enough value */
-         tiny = GL_TRUE;
-      }
-      else {
-         oneOverArea = 1.0F / area;
-         tiny = GL_FALSE;
-      }
-   }
-
-#ifndef DO_OCCLUSION_TEST
-   ctx->OcclusionResult = GL_TRUE;
-#endif
-
-   /* Edge setup.  For a triangle strip these could be reused... */
-   {
-      /* fixed point Y coordinates */
-      GLfixed vMin_fx = FloatToFixed(VB->Win.data[vMin][0] + 0.5F);
-      GLfixed vMin_fy = FloatToFixed(VB->Win.data[vMin][1] - 0.5F);
-      GLfixed vMid_fx = FloatToFixed(VB->Win.data[vMid][0] + 0.5F);
-      GLfixed vMid_fy = FloatToFixed(VB->Win.data[vMid][1] - 0.5F);
-      GLfixed vMax_fy = FloatToFixed(VB->Win.data[vMax][1] - 0.5F);
-
-      eMaj.fsy = FixedCeil(vMin_fy);
-      eMaj.lines = FixedToInt(vMax_fy + FIXED_ONE - FIXED_EPSILON - eMaj.fsy);
-      if (eMaj.lines > 0) {
-         GLfloat dxdy = eMaj.dx / eMaj.dy;
-         eMaj.fdxdy = SignedFloatToFixed(dxdy);
-         eMaj.adjy = (GLfloat) (eMaj.fsy - vMin_fy);  /* SCALED! */
-         eMaj.fx0 = vMin_fx;
-         eMaj.fsx = eMaj.fx0 + (GLfixed) (eMaj.adjy * dxdy);
-      }
-      else {
-         return;  /*CULLED*/
-      }
-
-      eTop.fsy = FixedCeil(vMid_fy);
-      eTop.lines = FixedToInt(vMax_fy + FIXED_ONE - FIXED_EPSILON - eTop.fsy);
-      if (eTop.lines > 0) {
-         GLfloat dxdy = eTop.dx / eTop.dy;
-         eTop.fdxdy = SignedFloatToFixed(dxdy);
-         eTop.adjy = (GLfloat) (eTop.fsy - vMid_fy); /* SCALED! */
-         eTop.fx0 = vMid_fx;
-         eTop.fsx = eTop.fx0 + (GLfixed) (eTop.adjy * dxdy);
-      }
-
-      eBot.fsy = FixedCeil(vMin_fy);
-      eBot.lines = FixedToInt(vMid_fy + FIXED_ONE - FIXED_EPSILON - eBot.fsy);
-      if (eBot.lines > 0) {
-         GLfloat dxdy = eBot.dx / eBot.dy;
-         eBot.fdxdy = SignedFloatToFixed(dxdy);
-         eBot.adjy = (GLfloat) (eBot.fsy - vMin_fy);  /* SCALED! */
-         eBot.fx0 = vMin_fx;
-         eBot.fsx = eBot.fx0 + (GLfixed) (eBot.adjy * dxdy);
-      }
-   }
-
-   /*
-    * Conceptually, we view a triangle as two subtriangles
-    * separated by a perfectly horizontal line.  The edge that is
-    * intersected by this line is one with maximal absolute dy; we
-    * call it a ``major'' edge.  The other two edges are the
-    * ``top'' edge (for the upper subtriangle) and the ``bottom''
-    * edge (for the lower subtriangle).  If either of these two
-    * edges is horizontal or very close to horizontal, the
-    * corresponding subtriangle might cover zero sample points;
-    * we take care to handle such cases, for performance as well
-    * as correctness.
-    *
-    * By stepping rasterization parameters along the major edge,
-    * we can avoid recomputing them at the discontinuity where
-    * the top and bottom edges meet.  However, this forces us to
-    * be able to scan both left-to-right and right-to-left.
-    * Also, we must determine whether the major edge is at the
-    * left or right side of the triangle.  We do this by
-    * computing the magnitude of the cross-product of the major
-    * and top edges.  Since this magnitude depends on the sine of
-    * the angle between the two edges, its sign tells us whether
-    * we turn to the left or to the right when travelling along
-    * the major edge to the top edge, and from this we infer
-    * whether the major edge is on the left or the right.
-    *
-    * Serendipitously, this cross-product magnitude is also a
-    * value we need to compute the iteration parameter
-    * derivatives for the triangle, and it can be used to perform
-    * backface culling because its sign tells us whether the
-    * triangle is clockwise or counterclockwise.  In this code we
-    * refer to it as ``area'' because it's also proportional to
-    * the pixel area of the triangle.
-    */
-
-   {
-      GLint ltor;		/* true if scanning left-to-right */
-#ifdef INTERP_Z
-      GLfloat dzdx, dzdy;      GLfixed fdzdx;
-#endif
-#ifdef INTERP_RGB
-      GLfloat drdx, drdy;      GLfixed fdrdx;
-      GLfloat dgdx, dgdy;      GLfixed fdgdx;
-      GLfloat dbdx, dbdy;      GLfixed fdbdx;
-#endif
-#ifdef INTERP_SPEC
-      GLfloat dsrdx, dsrdy;    GLfixed fdsrdx;
-      GLfloat dsgdx, dsgdy;    GLfixed fdsgdx;
-      GLfloat dsbdx, dsbdy;    GLfixed fdsbdx;
-#endif
-#ifdef INTERP_ALPHA
-      GLfloat dadx, dady;      GLfixed fdadx;
-#endif
-#ifdef INTERP_INDEX
-      GLfloat didx, didy;      GLfixed fdidx;
-#endif
-#ifdef INTERP_INT_ST
-      GLfloat dsdx, dsdy;      GLfixed fdsdx;
-      GLfloat dtdx, dtdy;      GLfixed fdtdx;
-#endif
-#ifdef INTERP_STUV
-      GLfloat dsdx, dsdy;
-      GLfloat dtdx, dtdy;
-      GLfloat dudx, dudy;
-      GLfloat dvdx, dvdy;
-#endif
-#ifdef INTERP_STUV1
-      GLfloat ds1dx, ds1dy;
-      GLfloat dt1dx, dt1dy;
-      GLfloat du1dx, du1dy;
-      GLfloat dv1dx, dv1dy;
-#endif
-
-      /*
-       * Execute user-supplied setup code
-       */
-#ifdef SETUP_CODE
-      SETUP_CODE
-#endif
-
-      ltor = (oneOverArea < 0.0F);
-
-      /* compute d?/dx and d?/dy derivatives */
-#ifdef INTERP_Z
-      {
-         GLfloat eMaj_dz, eBot_dz;
-         eMaj_dz = VB->Win.data[vMax][2] - VB->Win.data[vMin][2];
-         eBot_dz = VB->Win.data[vMid][2] - VB->Win.data[vMin][2];
-         dzdx = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz);
-         if (dzdx > maxDepth || dzdx < -maxDepth) {
-            /* probably a sliver triangle */
-            dzdx = 0.0;
-            dzdy = 0.0;
-         }
-         else {
-            dzdy = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx);
-         }
-         if (depthBits <= 16)
-            fdzdx = SignedFloatToFixed(dzdx);
-         else
-            fdzdx = (GLint) dzdx;
-      }
-#endif
-#ifdef INTERP_RGB
-      if (tiny) {
-         /* This is kind of a hack to eliminate RGB color over/underflow
-          * problems when rendering very tiny triangles.  We're not doing
-          * anything with alpha or specular color at this time.
-          */
-         drdx = drdy = 0.0;  fdrdx = 0;
-         dgdx = dgdy = 0.0;  fdgdx = 0;
-         dbdx = dbdy = 0.0;  fdbdx = 0;
-      }
-      else {
-         GLfloat eMaj_dr, eBot_dr;
-         GLfloat eMaj_dg, eBot_dg;
-         GLfloat eMaj_db, eBot_db;
-         eMaj_dr = (GLint) VB->ColorPtr->data[vMax][0]
-                 - (GLint) VB->ColorPtr->data[vMin][0];
-         eBot_dr = (GLint) VB->ColorPtr->data[vMid][0]
-                 - (GLint) VB->ColorPtr->data[vMin][0];
-         drdx = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr);
-         fdrdx = SignedFloatToFixed(drdx);
-         drdy = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx);
-         eMaj_dg = (GLint) VB->ColorPtr->data[vMax][1]
-                 - (GLint) VB->ColorPtr->data[vMin][1];
-	 eBot_dg = (GLint) VB->ColorPtr->data[vMid][1]
-                 - (GLint) VB->ColorPtr->data[vMin][1];
-         dgdx = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg);
-         fdgdx = SignedFloatToFixed(dgdx);
-         dgdy = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx);
-         eMaj_db = (GLint) VB->ColorPtr->data[vMax][2]
-                 - (GLint) VB->ColorPtr->data[vMin][2];
-         eBot_db = (GLint) VB->ColorPtr->data[vMid][2]
-                 - (GLint) VB->ColorPtr->data[vMin][2];
-         dbdx = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db);
-         fdbdx = SignedFloatToFixed(dbdx);
-	 dbdy = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx);
-      }
-#endif
-#ifdef INTERP_SPEC
-      {
-         GLfloat eMaj_dsr, eBot_dsr;
-         eMaj_dsr = (GLint) VB->Specular[vMax][0] - (GLint) VB->Specular[vMin][0];
-         eBot_dsr = (GLint) VB->Specular[vMid][0] - (GLint) VB->Specular[vMin][0];
-         dsrdx = oneOverArea * (eMaj_dsr * eBot.dy - eMaj.dy * eBot_dsr);
-         fdsrdx = SignedFloatToFixed(dsrdx);
-         dsrdy = oneOverArea * (eMaj.dx * eBot_dsr - eMaj_dsr * eBot.dx);
-      }
-      {
-         GLfloat eMaj_dsg, eBot_dsg;
-         eMaj_dsg = (GLint) VB->Specular[vMax][1] - (GLint) VB->Specular[vMin][1];
-	 eBot_dsg = (GLint) VB->Specular[vMid][1] - (GLint) VB->Specular[vMin][1];
-         dsgdx = oneOverArea * (eMaj_dsg * eBot.dy - eMaj.dy * eBot_dsg);
-         fdsgdx = SignedFloatToFixed(dsgdx);
-         dsgdy = oneOverArea * (eMaj.dx * eBot_dsg - eMaj_dsg * eBot.dx);
-      }
-      {
-         GLfloat eMaj_dsb, eBot_dsb;
-         eMaj_dsb = (GLint) VB->Specular[vMax][2] - (GLint) VB->Specular[vMin][2];
-         eBot_dsb = (GLint) VB->Specular[vMid][2] - (GLint) VB->Specular[vMin][2];
-         dsbdx = oneOverArea * (eMaj_dsb * eBot.dy - eMaj.dy * eBot_dsb);
-         fdsbdx = SignedFloatToFixed(dsbdx);
-	 dsbdy = oneOverArea * (eMaj.dx * eBot_dsb - eMaj_dsb * eBot.dx);
-      }
-#endif
-#ifdef INTERP_ALPHA
-      {
-         GLfloat eMaj_da, eBot_da;
-         eMaj_da = (GLint) VB->ColorPtr->data[vMax][3] - (GLint) VB->ColorPtr->data[vMin][3];
-         eBot_da = (GLint) VB->ColorPtr->data[vMid][3] - (GLint) VB->ColorPtr->data[vMin][3];
-         dadx = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
-         fdadx = SignedFloatToFixed(dadx);
-         dady = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
-      }
-#endif
-#ifdef INTERP_INDEX
-      {
-         GLfloat eMaj_di, eBot_di;
-         eMaj_di = (GLint) VB->IndexPtr->data[vMax] - (GLint) VB->IndexPtr->data[vMin];
-         eBot_di = (GLint) VB->IndexPtr->data[vMid] - (GLint) VB->IndexPtr->data[vMin];
-         didx = oneOverArea * (eMaj_di * eBot.dy - eMaj.dy * eBot_di);
-         fdidx = SignedFloatToFixed(didx);
-         didy = oneOverArea * (eMaj.dx * eBot_di - eMaj_di * eBot.dx);
-      }
-#endif
-#ifdef INTERP_INT_ST
-      {
-         GLfloat eMaj_ds, eBot_ds;
-         eMaj_ds = (VB->TexCoordPtr[0]->data[vMax][0] - VB->TexCoordPtr[0]->data[vMin][0]) * S_SCALE;
-         eBot_ds = (VB->TexCoordPtr[0]->data[vMid][0] - VB->TexCoordPtr[0]->data[vMin][0]) * S_SCALE;
-         dsdx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds);
-         fdsdx = SignedFloatToFixed(dsdx);
-         dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
-      }
-      if (VB->TexCoordPtr[0]->size > 1)
-      {
-         GLfloat eMaj_dt, eBot_dt;
-         eMaj_dt = (VB->TexCoordPtr[0]->data[vMax][1] - VB->TexCoordPtr[0]->data[vMin][1]) * T_SCALE;
-         eBot_dt = (VB->TexCoordPtr[0]->data[vMid][1] - VB->TexCoordPtr[0]->data[vMin][1]) * T_SCALE;
-         dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);
-         fdtdx = SignedFloatToFixed(dtdx);
-         dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
-      } else {
-         dtdx = 0;
-         fdtdx = SignedFloatToFixed(dtdx);
-         dtdy = 0;
-      }
-
-#endif
-#ifdef INTERP_STUV
-      {
-         GLfloat wMax = VB->Win.data[vMax][3];
-         GLfloat wMin = VB->Win.data[vMin][3];
-         GLfloat wMid = VB->Win.data[vMid][3];
-         GLfloat eMaj_ds, eBot_ds;
-         GLfloat eMaj_dt, eBot_dt;
-         GLfloat eMaj_du, eBot_du;
-         GLfloat eMaj_dv, eBot_dv;
-
-         eMaj_ds = VB->TexCoordPtr[0]->data[vMax][0]*wMax - VB->TexCoordPtr[0]->data[vMin][0]*wMin;
-         eBot_ds = VB->TexCoordPtr[0]->data[vMid][0]*wMid - VB->TexCoordPtr[0]->data[vMin][0]*wMin;
-         dsdx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds);
-         dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
-
-
-	 if (VB->TexCoordPtr[0]->size > 1)
-	 {
-	    eMaj_dt = VB->TexCoordPtr[0]->data[vMax][1]*wMax - VB->TexCoordPtr[0]->data[vMin][1]*wMin;
-	    eBot_dt = VB->TexCoordPtr[0]->data[vMid][1]*wMid - VB->TexCoordPtr[0]->data[vMin][1]*wMin;
-	    dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);
-	    dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
-	 } else {
-	    dtdx = 0;
-	    dtdy = 0;
-	 }
-
-	 if (VB->TexCoordPtr[0]->size > 2)
-	 {
-	    eMaj_du = VB->TexCoordPtr[0]->data[vMax][2]*wMax - VB->TexCoordPtr[0]->data[vMin][2]*wMin;
-	    eBot_du = VB->TexCoordPtr[0]->data[vMid][2]*wMid - VB->TexCoordPtr[0]->data[vMin][2]*wMin;
-	    dudx = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du);
-	    dudy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx);
-	 } else {
-	    dudx = 0;
-	    dudy = 0;
-	 }
-
-	 if (VB->TexCoordPtr[0]->size > 3)
-	 {
-	    eMaj_dv = VB->TexCoordPtr[0]->data[vMax][3]*wMax - VB->TexCoordPtr[0]->data[vMin][3]*wMin;
-	    eBot_dv = VB->TexCoordPtr[0]->data[vMid][3]*wMid - VB->TexCoordPtr[0]->data[vMin][3]*wMin;
-	    dvdx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
-	    dvdy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
-	 } else {
-	    eMaj_dv = wMax - wMin;
-	    eBot_dv = wMid - wMin;
-	    dvdx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
-	    dvdy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
-	 }
-      }
-#endif
-#ifdef INTERP_STUV1
-      {
-         GLfloat wMax = VB->Win.data[vMax][3];
-         GLfloat wMin = VB->Win.data[vMin][3];
-         GLfloat wMid = VB->Win.data[vMid][3];
-         GLfloat eMaj_ds, eBot_ds;
-         GLfloat eMaj_dt, eBot_dt;
-         GLfloat eMaj_du, eBot_du;
-         GLfloat eMaj_dv, eBot_dv;
-         eMaj_ds = VB->TexCoordPtr[1]->data[vMax][0]*wMax - VB->TexCoordPtr[1]->data[vMin][0]*wMin;
-         eBot_ds = VB->TexCoordPtr[1]->data[vMid][0]*wMid - VB->TexCoordPtr[1]->data[vMin][0]*wMin;
-         ds1dx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds);
-         ds1dy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
-
-	 if (VB->TexCoordPtr[1]->size > 1)
-	 {
-	    eMaj_dt = VB->TexCoordPtr[1]->data[vMax][1]*wMax - VB->TexCoordPtr[1]->data[vMin][1]*wMin;
-	    eBot_dt = VB->TexCoordPtr[1]->data[vMid][1]*wMid - VB->TexCoordPtr[1]->data[vMin][1]*wMin;
-	    dt1dx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);
-	    dt1dy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
-	 }
-	 else
-	 {
-	    dt1dx = 0;
-	    dt1dy = 0;
-	 }
-
-	 if (VB->TexCoordPtr[1]->size > 2)
-	 {
-	    eMaj_du = VB->TexCoordPtr[1]->data[vMax][2]*wMax - VB->TexCoordPtr[1]->data[vMin][2]*wMin;
-	    eBot_du = VB->TexCoordPtr[1]->data[vMid][2]*wMid - VB->TexCoordPtr[1]->data[vMin][2]*wMin;
-	    du1dx = oneOverArea * (eMaj_du * eBot.dy - eMaj.dy * eBot_du);
-	    du1dy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx);
-	 }
-	 else
-	 {
-	    du1dx = 0;
-	    du1dy = 0;
-	 }
-
-	 if (VB->TexCoordPtr[1]->size > 3)
-	 {
-	    eMaj_dv = VB->TexCoordPtr[1]->data[vMax][3]*wMax - VB->TexCoordPtr[1]->data[vMin][3]*wMin;
-	    eBot_dv = VB->TexCoordPtr[1]->data[vMid][3]*wMid - VB->TexCoordPtr[1]->data[vMin][3]*wMin;
-	    dv1dx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
-	    dv1dy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
-	 }
-	 else
-	 {
-	    eMaj_dv = wMax - wMin;
-	    eBot_dv = wMid - wMin;
-	    dv1dx = oneOverArea * (eMaj_dv * eBot.dy - eMaj.dy * eBot_dv);
-	    dv1dy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
-	 }
-      }
-#endif
-
-      /*
-       * We always sample at pixel centers.  However, we avoid
-       * explicit half-pixel offsets in this code by incorporating
-       * the proper offset in each of x and y during the
-       * transformation to window coordinates.
-       *
-       * We also apply the usual rasterization rules to prevent
-       * cracks and overlaps.  A pixel is considered inside a
-       * subtriangle if it meets all of four conditions: it is on or
-       * to the right of the left edge, strictly to the left of the
-       * right edge, on or below the top edge, and strictly above
-       * the bottom edge.  (Some edges may be degenerate.)
-       *
-       * The following discussion assumes left-to-right scanning
-       * (that is, the major edge is on the left); the right-to-left
-       * case is a straightforward variation.
-       *
-       * We start by finding the half-integral y coordinate that is
-       * at or below the top of the triangle.  This gives us the
-       * first scan line that could possibly contain pixels that are
-       * inside the triangle.
-       *
-       * Next we creep down the major edge until we reach that y,
-       * and compute the corresponding x coordinate on the edge.
-       * Then we find the half-integral x that lies on or just
-       * inside the edge.  This is the first pixel that might lie in
-       * the interior of the triangle.  (We won't know for sure
-       * until we check the other edges.)
-       *
-       * As we rasterize the triangle, we'll step down the major
-       * edge.  For each step in y, we'll move an integer number
-       * of steps in x.  There are two possible x step sizes, which
-       * we'll call the ``inner'' step (guaranteed to land on the
-       * edge or inside it) and the ``outer'' step (guaranteed to
-       * land on the edge or outside it).  The inner and outer steps
-       * differ by one.  During rasterization we maintain an error
-       * term that indicates our distance from the true edge, and
-       * select either the inner step or the outer step, whichever
-       * gets us to the first pixel that falls inside the triangle.
-       *
-       * All parameters (z, red, etc.) as well as the buffer
-       * addresses for color and z have inner and outer step values,
-       * so that we can increment them appropriately.  This method
-       * eliminates the need to adjust parameters by creeping a
-       * sub-pixel amount into the triangle at each scanline.
-       */
-
-      {
-         int subTriangle;
-         GLfixed fx;
-         GLfixed fxLeftEdge = 0, fxRightEdge = 0;
-         GLfixed fdxLeftEdge = 0, fdxRightEdge = 0;
-         GLfixed fdxOuter;
-         int idxOuter;
-         float dxOuter;
-         GLfixed fError = 0, fdError = 0;
-         float adjx, adjy;
-         GLfixed fy;
-         int iy = 0;
-#ifdef PIXEL_ADDRESS
-         PIXEL_TYPE *pRow = NULL;
-         int dPRowOuter = 0, dPRowInner;  /* offset in bytes */
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-         DEPTH_TYPE *zRow = NULL;
-         int dZRowOuter = 0, dZRowInner;  /* offset in bytes */
-#  endif
-         GLfixed fz = 0, fdzOuter = 0, fdzInner;
-#endif
-#ifdef INTERP_RGB
-         GLfixed fr = 0, fdrOuter = 0, fdrInner;
-         GLfixed fg = 0, fdgOuter = 0, fdgInner;
-         GLfixed fb = 0, fdbOuter = 0, fdbInner;
-#endif
-#ifdef INTERP_SPEC
-         GLfixed fsr = 0, fdsrOuter = 0, fdsrInner;
-         GLfixed fsg = 0, fdsgOuter = 0, fdsgInner;
-         GLfixed fsb = 0, fdsbOuter = 0, fdsbInner;
-#endif
-#ifdef INTERP_ALPHA
-         GLfixed fa = 0, fdaOuter = 0, fdaInner;
-#endif
-#ifdef INTERP_INDEX
-         GLfixed fi = 0, fdiOuter = 0, fdiInner;
-#endif
-#ifdef INTERP_INT_ST
-         GLfixed fs = 0, fdsOuter = 0, fdsInner;
-         GLfixed ft = 0, fdtOuter = 0, fdtInner;
-#endif
-#ifdef INTERP_STUV
-         GLfloat sLeft = 0, dsOuter = 0, dsInner;
-         GLfloat tLeft = 0, dtOuter = 0, dtInner;
-         GLfloat uLeft = 0, duOuter = 0, duInner;
-         GLfloat vLeft = 0, dvOuter = 0, dvInner;
-#endif
-#ifdef INTERP_STUV1
-         GLfloat s1Left = 0, ds1Outer = 0, ds1Inner;
-         GLfloat t1Left = 0, dt1Outer = 0, dt1Inner;
-         GLfloat u1Left = 0, du1Outer = 0, du1Inner;
-         GLfloat v1Left = 0, dv1Outer = 0, dv1Inner;
-#endif
-
-         for (subTriangle=0; subTriangle<=1; subTriangle++) {
-            EdgeT *eLeft, *eRight;
-            int setupLeft, setupRight;
-            int lines;
-
-            if (subTriangle==0) {
-               /* bottom half */
-               if (ltor) {
-                  eLeft = &eMaj;
-                  eRight = &eBot;
-                  lines = eRight->lines;
-                  setupLeft = 1;
-                  setupRight = 1;
-               }
-               else {
-                  eLeft = &eBot;
-                  eRight = &eMaj;
-                  lines = eLeft->lines;
-                  setupLeft = 1;
-                  setupRight = 1;
-               }
-            }
-            else {
-               /* top half */
-               if (ltor) {
-                  eLeft = &eMaj;
-                  eRight = &eTop;
-                  lines = eRight->lines;
-                  setupLeft = 0;
-                  setupRight = 1;
-               }
-               else {
-                  eLeft = &eTop;
-                  eRight = &eMaj;
-                  lines = eLeft->lines;
-                  setupLeft = 1;
-                  setupRight = 0;
-               }
-               if (lines==0) return;
-            }
-
-            if (setupLeft && eLeft->lines>0) {
-               GLint vLower;
-               GLfixed fsx = eLeft->fsx;
-               fx = FixedCeil(fsx);
-               fError = fx - fsx - FIXED_ONE;
-               fxLeftEdge = fsx - FIXED_EPSILON;
-               fdxLeftEdge = eLeft->fdxdy;
-               fdxOuter = FixedFloor(fdxLeftEdge - FIXED_EPSILON);
-               fdError = fdxOuter - fdxLeftEdge + FIXED_ONE;
-               idxOuter = FixedToInt(fdxOuter);
-               dxOuter = (float) idxOuter;
-               (void) dxOuter;
-
-               fy = eLeft->fsy;
-               iy = FixedToInt(fy);
-
-               adjx = (float)(fx - eLeft->fx0);  /* SCALED! */
-               adjy = eLeft->adjy;		 /* SCALED! */
-               (void) adjx;  /* silence compiler warnings */
-               (void) adjy;  /* silence compiler warnings */
-
-               vLower = eLeft->v0;
-               (void) vLower;  /* silence compiler warnings */
-
-#ifdef PIXEL_ADDRESS
-               {
-                  pRow = PIXEL_ADDRESS( FixedToInt(fxLeftEdge), iy );
-                  dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE);
-                  /* negative because Y=0 at bottom and increases upward */
-               }
-#endif
-               /*
-                * Now we need the set of parameter (z, color, etc.) values at
-                * the point (fx, fy).  This gives us properly-sampled parameter
-                * values that we can step from pixel to pixel.  Furthermore,
-                * although we might have intermediate results that overflow
-                * the normal parameter range when we step temporarily outside
-                * the triangle, we shouldn't overflow or underflow for any
-                * pixel that's actually inside the triangle.
-                */
-
-#ifdef INTERP_Z
-               {
-                  GLfloat z0 = VB->Win.data[vLower][2] + ctx->PolygonZoffset;
-                  if (depthBits <= 16) {
-                     /* interpolate fixed-pt values */
-                     GLfloat tmp = (z0 * FIXED_SCALE + dzdx * adjx + dzdy * adjy) + FIXED_HALF;
-                     if (tmp < MAX_GLUINT / 2)
-                        fz = (GLfixed) tmp;
-                     else
-                        fz = MAX_GLUINT / 2;
-                     fdzOuter = SignedFloatToFixed(dzdy + dxOuter * dzdx);
-                  }
-                  else {
-                     /* interpolate depth values exactly */
-                     fz = (GLint) (z0 + dzdx*FixedToFloat(adjx) + dzdy*FixedToFloat(adjy));
-                     fdzOuter = (GLint) (dzdy + dxOuter * dzdx);
-                  }
-#  ifdef DEPTH_TYPE
-                  zRow = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, FixedToInt(fxLeftEdge), iy);
-                  dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);
-#  endif
-               }
-#endif
-#ifdef INTERP_RGB
-               fr = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][0]) + drdx * adjx + drdy * adjy)
-                    + FIXED_HALF;
-               fdrOuter = SignedFloatToFixed(drdy + dxOuter * drdx);
-
-               fg = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][1]) + dgdx * adjx + dgdy * adjy)
-                    + FIXED_HALF;
-               fdgOuter = SignedFloatToFixed(dgdy + dxOuter * dgdx);
-
-               fb = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][2]) + dbdx * adjx + dbdy * adjy)
-                    + FIXED_HALF;
-               fdbOuter = SignedFloatToFixed(dbdy + dxOuter * dbdx);
-#endif
-#ifdef INTERP_SPEC
-               fsr = (GLfixed)(IntToFixed(VB->Specular[vLower][0]) + dsrdx * adjx + dsrdy * adjy)
-                    + FIXED_HALF;
-               fdsrOuter = SignedFloatToFixed(dsrdy + dxOuter * dsrdx);
-
-               fsg = (GLfixed)(IntToFixed(VB->Specular[vLower][1]) + dsgdx * adjx + dsgdy * adjy)
-                    + FIXED_HALF;
-               fdsgOuter = SignedFloatToFixed(dsgdy + dxOuter * dsgdx);
-
-               fsb = (GLfixed)(IntToFixed(VB->Specular[vLower][2]) + dsbdx * adjx + dsbdy * adjy)
-                    + FIXED_HALF;
-               fdsbOuter = SignedFloatToFixed(dsbdy + dxOuter * dsbdx);
-#endif
-#ifdef INTERP_ALPHA
-               fa = (GLfixed)(IntToFixed(VB->ColorPtr->data[vLower][3]) + dadx * adjx + dady * adjy)
-                    + FIXED_HALF;
-               fdaOuter = SignedFloatToFixed(dady + dxOuter * dadx);
-#endif
-#ifdef INTERP_INDEX
-               fi = (GLfixed)(VB->IndexPtr->data[vLower] * FIXED_SCALE + didx * adjx
-                              + didy * adjy) + FIXED_HALF;
-               fdiOuter = SignedFloatToFixed(didy + dxOuter * didx);
-#endif
-#ifdef INTERP_INT_ST
-               {
-                  GLfloat s0, t0;
-                  s0 = VB->TexCoordPtr[0]->data[vLower][0] * S_SCALE;
-                  fs = (GLfixed)(s0 * FIXED_SCALE + dsdx * adjx + dsdy * adjy) + FIXED_HALF;
-                  fdsOuter = SignedFloatToFixed(dsdy + dxOuter * dsdx);
-
-		  if (VB->TexCoordPtr[0]->size > 1)
-		  {
-		     t0 = VB->TexCoordPtr[0]->data[vLower][1] * T_SCALE;
-		     ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx + dtdy * adjy) + FIXED_HALF;
-		     fdtOuter = SignedFloatToFixed(dtdy + dxOuter * dtdx);
-		  }
-		  else
-		  {
-		     t0 = 0;
-		     ft = (GLfixed) FIXED_HALF;
-		     fdtOuter = SignedFloatToFixed(0);
-		  }
-	       }
-#endif
-#ifdef INTERP_STUV
-               {
-                  GLfloat invW = VB->Win.data[vLower][3];
-                  GLfloat s0, t0, u0, v0;
-                  s0 = VB->TexCoordPtr[0]->data[vLower][0] * invW;
-                  sLeft = s0 + (dsdx * adjx + dsdy * adjy) * (1.0F/FIXED_SCALE);
-                  dsOuter = dsdy + dxOuter * dsdx;
-		  if (VB->TexCoordPtr[0]->size > 1)
-		  {
-		     t0 = VB->TexCoordPtr[0]->data[vLower][1] * invW;
-		     tLeft = t0 + (dtdx * adjx + dtdy * adjy) * (1.0F/FIXED_SCALE);
-		     dtOuter = dtdy + dxOuter * dtdx;
-		  } else {
-		     tLeft = dtOuter = 0;
-		  }
-		  if (VB->TexCoordPtr[0]->size > 2)
-		  {
-		     u0 = VB->TexCoordPtr[0]->data[vLower][2] * invW;
-		     uLeft = u0 + (dudx * adjx + dudy * adjy) * (1.0F/FIXED_SCALE);
-		     duOuter = dudy + dxOuter * dudx;
-		  } else {
-		     uLeft = duOuter = 0;
-		  }
-		  if (VB->TexCoordPtr[0]->size > 3)
-		  {
-		     v0 = VB->TexCoordPtr[0]->data[vLower][3] * invW;
-		  } else {
-		     v0 = invW;
-		  }
-		  vLeft = v0 + (dvdx * adjx + dvdy * adjy) * (1.0F/FIXED_SCALE);
-		  dvOuter = dvdy + dxOuter * dvdx;
-               }
-#endif
-#ifdef INTERP_STUV1
-               {
-                  GLfloat invW = VB->Win.data[vLower][3];
-                  GLfloat s0, t0, u0, v0;
-                  s0 = VB->TexCoordPtr[1]->data[vLower][0] * invW;
-                  s1Left = s0 + (ds1dx * adjx + ds1dy * adjy) * (1.0F/FIXED_SCALE);
-                  ds1Outer = ds1dy + dxOuter * ds1dx;
-		  if (VB->TexCoordPtr[0]->size > 1)
-		  {
-		     t0 = VB->TexCoordPtr[1]->data[vLower][1] * invW;
-		     t1Left = t0 + (dt1dx * adjx + dt1dy * adjy) * (1.0F/FIXED_SCALE);
-		     dt1Outer = dt1dy + dxOuter * dt1dx;
-		  } else {
-		     t1Left = dt1Outer = 0;
-		  }
-		  if (VB->TexCoordPtr[0]->size > 2)
-		  {
-		     u0 = VB->TexCoordPtr[1]->data[vLower][2] * invW;
-		     u1Left = u0 + (du1dx * adjx + du1dy * adjy) * (1.0F/FIXED_SCALE);
-		     du1Outer = du1dy + dxOuter * du1dx;
-		  } else {
-		     u1Left = du1Outer = 0;
-		  }
-		  if (VB->TexCoordPtr[0]->size > 3)
-		  {
-		     v0 = VB->TexCoordPtr[1]->data[vLower][3] * invW;
-		  } else {
-		     v0 =  invW;
-		  }
-		  v1Left = v0 + (dv1dx * adjx + dv1dy * adjy) * (1.0F/FIXED_SCALE);
-		  dv1Outer = dv1dy + dxOuter * dv1dx;
-               }
-#endif
-
-            } /*if setupLeft*/
-
-
-            if (setupRight && eRight->lines>0) {
-               fxRightEdge = eRight->fsx - FIXED_EPSILON;
-               fdxRightEdge = eRight->fdxdy;
-            }
-
-            if (lines==0) {
-               continue;
-            }
-
-
-            /* Rasterize setup */
-#ifdef PIXEL_ADDRESS
-            dPRowInner = dPRowOuter + sizeof(PIXEL_TYPE);
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-            dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE);
-#  endif
-            fdzInner = fdzOuter + fdzdx;
-#endif
-#ifdef INTERP_RGB
-            fdrInner = fdrOuter + fdrdx;
-            fdgInner = fdgOuter + fdgdx;
-            fdbInner = fdbOuter + fdbdx;
-#endif
-#ifdef INTERP_SPEC
-            fdsrInner = fdsrOuter + fdsrdx;
-            fdsgInner = fdsgOuter + fdsgdx;
-            fdsbInner = fdsbOuter + fdsbdx;
-#endif
-#ifdef INTERP_ALPHA
-            fdaInner = fdaOuter + fdadx;
-#endif
-#ifdef INTERP_INDEX
-            fdiInner = fdiOuter + fdidx;
-#endif
-#ifdef INTERP_INT_ST
-            fdsInner = fdsOuter + fdsdx;
-            fdtInner = fdtOuter + fdtdx;
-#endif
-#ifdef INTERP_STUV
-	    dsInner = dsOuter + dsdx;
-	    dtInner = dtOuter + dtdx;
-	    duInner = duOuter + dudx;
-	    dvInner = dvOuter + dvdx;
-#endif
-#ifdef INTERP_STUV1
-	    ds1Inner = ds1Outer + ds1dx;
-	    dt1Inner = dt1Outer + dt1dx;
-	    du1Inner = du1Outer + du1dx;
-	    dv1Inner = dv1Outer + dv1dx;
-#endif
-
-            while (lines>0) {
-               /* initialize the span interpolants to the leftmost value */
-               /* ff = fixed-pt fragment */
-#ifdef INTERP_Z
-               GLfixed ffz = fz;
-#endif
-#ifdef INTERP_RGB
-               GLfixed ffr = fr,  ffg = fg,  ffb = fb;
-#endif
-#ifdef INTERP_SPEC
-               GLfixed ffsr = fsr,  ffsg = fsg,  ffsb = fsb;
-#endif
-#ifdef INTERP_ALPHA
-               GLfixed ffa = fa;
-#endif
-#ifdef INTERP_INDEX
-               GLfixed ffi = fi;
-#endif
-#ifdef INTERP_INT_ST
-               GLfixed ffs = fs,  fft = ft;
-#endif
-#ifdef INTERP_STUV
-               GLfloat ss = sLeft, tt = tLeft, uu = uLeft, vv = vLeft;
-#endif
-#ifdef INTERP_STUV1
-               GLfloat ss1 = s1Left, tt1 = t1Left, uu1 = u1Left, vv1 = v1Left;
-#endif
-               GLint left = FixedToInt(fxLeftEdge);
-               GLint right = FixedToInt(fxRightEdge);
-
-#ifdef INTERP_RGB
-               {
-                  /* need this to accomodate round-off errors */
-                  GLfixed ffrend = ffr+(right-left-1)*fdrdx;
-                  GLfixed ffgend = ffg+(right-left-1)*fdgdx;
-                  GLfixed ffbend = ffb+(right-left-1)*fdbdx;
-                  if (ffrend<0) ffr -= ffrend;
-                  if (ffgend<0) ffg -= ffgend;
-                  if (ffbend<0) ffb -= ffbend;
-                  if (ffr<0) ffr = 0;
-                  if (ffg<0) ffg = 0;
-                  if (ffb<0) ffb = 0;
-               }
-#endif
-#ifdef INTERP_SPEC
-               {
-                  /* need this to accomodate round-off errors */
-                  GLfixed ffsrend = ffsr+(right-left-1)*fdsrdx;
-                  GLfixed ffsgend = ffsg+(right-left-1)*fdsgdx;
-                  GLfixed ffsbend = ffsb+(right-left-1)*fdsbdx;
-                  if (ffsrend<0) ffsr -= ffsrend;
-                  if (ffsgend<0) ffsg -= ffsgend;
-                  if (ffsbend<0) ffsb -= ffsbend;
-                  if (ffsr<0) ffsr = 0;
-                  if (ffsg<0) ffsg = 0;
-                  if (ffsb<0) ffsb = 0;
-               }
-#endif
-#ifdef INTERP_ALPHA
-               {
-                  GLfixed ffaend = ffa+(right-left-1)*fdadx;
-                  if (ffaend<0) ffa -= ffaend;
-                  if (ffa<0) ffa = 0;
-               }
-#endif
-#ifdef INTERP_INDEX
-               if (ffi<0) ffi = 0;
-#endif
-
-               INNER_LOOP( left, right, iy );
-
-               /*
-                * Advance to the next scan line.  Compute the
-                * new edge coordinates, and adjust the
-                * pixel-center x coordinate so that it stays
-                * on or inside the major edge.
-                */
-               iy++;
-               lines--;
-
-               fxLeftEdge += fdxLeftEdge;
-               fxRightEdge += fdxRightEdge;
-
-
-               fError += fdError;
-               if (fError >= 0) {
-                  fError -= FIXED_ONE;
-#ifdef PIXEL_ADDRESS
-                  pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowOuter);
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-                  zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowOuter);
-#  endif
-                  fz += fdzOuter;
-#endif
-#ifdef INTERP_RGB
-                  fr += fdrOuter;   fg += fdgOuter;   fb += fdbOuter;
-#endif
-#ifdef INTERP_SPEC
-                  fsr += fdsrOuter;   fsg += fdsgOuter;   fsb += fdsbOuter;
-#endif
-#ifdef INTERP_ALPHA
-                  fa += fdaOuter;
-#endif
-#ifdef INTERP_INDEX
-                  fi += fdiOuter;
-#endif
-#ifdef INTERP_INT_ST
-                  fs += fdsOuter;   ft += fdtOuter;
-#endif
-#ifdef INTERP_STUV
-		  sLeft += dsOuter;
-		  tLeft += dtOuter;
-		  uLeft += duOuter;
-		  vLeft += dvOuter;
-#endif
-#ifdef INTERP_STUV1
-		  s1Left += ds1Outer;
-		  t1Left += dt1Outer;
-		  u1Left += du1Outer;
-		  v1Left += dv1Outer;
-#endif
-               }
-               else {
-#ifdef PIXEL_ADDRESS
-                  pRow = (PIXEL_TYPE *) ((GLubyte*)pRow + dPRowInner);
-#endif
-#ifdef INTERP_Z
-#  ifdef DEPTH_TYPE
-                  zRow = (DEPTH_TYPE *) ((GLubyte*)zRow + dZRowInner);
-#  endif
-                  fz += fdzInner;
-#endif
-#ifdef INTERP_RGB
-                  fr += fdrInner;   fg += fdgInner;   fb += fdbInner;
-#endif
-#ifdef INTERP_SPEC
-                  fsr += fdsrInner;   fsg += fdsgInner;   fsb += fdsbInner;
-#endif
-#ifdef INTERP_ALPHA
-                  fa += fdaInner;
-#endif
-#ifdef INTERP_INDEX
-                  fi += fdiInner;
-#endif
-#ifdef INTERP_INT_ST
-                  fs += fdsInner;   ft += fdtInner;
-#endif
-#ifdef INTERP_STUV
-		  sLeft += dsInner;
-		  tLeft += dtInner;
-		  uLeft += duInner;
-		  vLeft += dvInner;
-#endif
-#ifdef INTERP_STUV1
-		  s1Left += ds1Inner;
-		  t1Left += dt1Inner;
-		  u1Left += du1Inner;
-		  v1Left += dv1Inner;
-#endif
-               }
-            } /*while lines>0*/
-
-         } /* for subTriangle */
-
-      }
-   }
-}
-
-#undef SETUP_CODE
-#undef INNER_LOOP
-
-#undef PIXEL_TYPE
-#undef BYTES_PER_ROW
-#undef PIXEL_ADDRESS
-
-#undef INTERP_Z
-#undef INTERP_RGB
-#undef INTERP_SPEC
-#undef INTERP_ALPHA
-#undef INTERP_INDEX
-#undef INTERP_INT_ST
-#undef INTERP_STUV
-#undef INTERP_STUV1
-
-#undef S_SCALE
-#undef T_SCALE
-
-#undef FixedToDepth
-
-#undef DO_OCCLUSION_TEST
Index: xc/extras/Mesa/src/types.h
diff -u xc/extras/Mesa/src/types.h:1.12 xc/extras/Mesa/src/types.h:removed
--- xc/extras/Mesa/src/types.h:1.12	Tue Mar 20 22:02:19 2001
+++ xc/extras/Mesa/src/types.h	Thu Feb 27 12:15:44 2003
@@ -1,2173 +0,0 @@
-/* -*- mode: C; tab-width:8; c-basic-offset:3 -*- */
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef TYPES_H
-#define TYPES_H
-
-
-#include "glheader.h"
-#include "config.h"
-#include "fixed.h"
-#include "glapitable.h"
-#include "glthread.h"
-#include "macros.h"
-#include "matrix.h"
-#include "vb.h"
-#include "vector.h"
-
-
-/*
- * Color channel data type:
- */
-#if CHAN_BITS==8
-   typedef GLubyte GLchan;
-#elif CHAN_BITS==16
-   typedef GLushort GLchan;
-#else
-   illegal number of color channel bits
-#endif
-
-
-/*
- * Accumulation buffer data type:
- */
-#if ACCUM_BITS==8
-   typedef GLbyte GLaccum;
-#elif ACCUM_BITS==16
-   typedef GLshort GLaccum;
-#else
-#  error "illegal number of accumulation bits"
-#endif
-
-
-/*
- * Stencil buffer data type:
- */
-#if STENCIL_BITS==8
-   typedef GLubyte GLstencil;
-#  define STENCIL_MAX 0xff
-#elif STENCIL_BITS==16
-   typedef GLushort GLstencil;
-#  define STENCIL_MAX 0xffff
-#else
-#  error "illegal number of stencil bits"
-#endif
-
-
-/*
- * Depth buffer data type:
- */
-typedef GLuint GLdepth;  /* Must be 32-bits! */
-
-
-
-/*
- * Some forward type declarations
- */
-struct _mesa_HashTable;
-
-typedef struct gl_visual GLvisual;
-
-typedef struct gl_frame_buffer GLframebuffer;
-
-
-/*
- * Functions for transformation of normals in the VB.
- */
-typedef void (_NORMAPIP normal_func)( const GLmatrix *mat,
-			     GLfloat scale,
-			     const GLvector3f *in,
-			     const GLfloat lengths[],
-			     const GLubyte mask[],
-			     GLvector3f *dest );
-
-
-
-/*
- * Point, line, triangle, quadrilateral and rectangle rasterizer functions:
- */
-typedef void (*points_func)( GLcontext *ctx, GLuint first, GLuint last );
-
-typedef void (*line_func)( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv );
-
-typedef void (*triangle_func)( GLcontext *ctx,
-                               GLuint v1, GLuint v2, GLuint v3, GLuint pv );
-
-typedef void (*quad_func)( GLcontext *ctx, GLuint v1, GLuint v2,
-                           GLuint v3, GLuint v4, GLuint pv );
-
-typedef void (*rect_func)( GLcontext *ctx, GLint x, GLint y,
-                           GLint width, GLint height );
-
-
-
-/*
- * The auxiliary interpolation function for clipping - now always in
- * clip space.
- */
-typedef void (*clip_interp_func)( struct vertex_buffer *VB, GLuint dst,
-                                  GLfloat t, GLuint in, GLuint out );
-
-
-/*
- * Renders vertices in vertex buffer
- */
-typedef void (*render_vb_func)( GLcontext *ctx );
-
-
-
-typedef void (*render_func)( struct vertex_buffer *VB,
-			     GLuint start,
-			     GLuint count,
-			     GLuint parity );
-
-
-/*
- * Blending function
- */
-#ifdef USE_MMX_ASM
-typedef void (_ASMAPIP blend_func)( GLcontext *ctx, GLuint n,
-                                    const GLubyte mask[],
-                                    GLubyte src[][4], CONST GLubyte dst[][4] );
-#else
-typedef void (*blend_func)( GLcontext *ctx, GLuint n, const GLubyte mask[],
-                            GLubyte src[][4], CONST GLubyte dst[][4] );
-#endif
-
-
-
-/*
- * For texture sampling:
- */
-struct gl_texture_object;
-
-typedef void (*TextureSampleFunc)( const struct gl_texture_object *tObj,
-                                   GLuint n,
-                                   const GLfloat s[], const GLfloat t[],
-                                   const GLfloat u[], const GLfloat lambda[],
-                                   GLubyte rgba[][4] );
-
-/* Texture format record */
-/* GH: This is an interim structure until 3.5 */
-struct gl_texture_format {
-   GLint IntFormat;		/* One of the MESA_FORMAT_* values */
-
-   GLubyte RedBits;		/* Bits per texel component */
-   GLubyte GreenBits;
-   GLubyte BlueBits;
-   GLubyte AlphaBits;
-   GLubyte LuminanceBits;
-   GLubyte IntensityBits;
-   GLubyte IndexBits;
-
-   GLint TexelBytes;
-};
-
-/* Texture image record */
-struct gl_texture_image {
-   GLenum Format;		/* GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA,
-				 * GL_INTENSITY, GL_RGB, GL_RGBA, or
-				 * GL_COLOR_INDEX only
-				 */
-   GLenum IntFormat;		/* Internal format as given by the user */
-   GLuint Border;		/* 0 or 1 */
-   GLuint Width;		/* = 2^WidthLog2 + 2*Border */
-   GLuint Height;		/* = 2^HeightLog2 + 2*Border */
-   GLuint Depth;		/* = 2^DepthLog2 + 2*Border */
-   GLuint Width2;		/* = Width - 2*Border */
-   GLuint Height2;		/* = Height - 2*Border */
-   GLuint Depth2;		/* = Depth - 2*Border */
-   GLuint WidthLog2;		/* = log2(Width2) */
-   GLuint HeightLog2;		/* = log2(Height2) */
-   GLuint DepthLog2;		/* = log2(Depth2) */
-   GLuint MaxLog2;		/* = MAX(WidthLog2, HeightLog2) */
-   GLubyte *Data;		/* Image data as unsigned bytes */
-
-   const struct gl_texture_format *TexFormat;
-
-   GLboolean IsCompressed;	/* GL_ARB_texture_compression */
-   GLuint CompressedSize;	/* GL_ARB_texture_compression */
-
-   /* For device driver: */
-   void *DriverData;		/* Arbitrary device driver data */
-};
-
-
-/* Data structure for color tables */
-struct gl_color_table {
-   GLvoid *Table;
-   GLenum TableType;      /* GL_UNSIGNED_BYTE or GL_FLOAT */
-   GLuint Size;           /* number of entries (rows) in table */
-   GLenum Format;
-   GLenum IntFormat;
-   GLint RedSize;
-   GLint GreenSize;
-   GLint BlueSize;
-   GLint AlphaSize;
-   GLint LuminanceSize;
-   GLint IntensitySize;
-};
-
-
-
-/* This has to included here. */
-#include "dd.h"
-
-
-/*
- * Bit flags used for updating material values.
- */
-#define FRONT_AMBIENT_BIT     0x1
-#define BACK_AMBIENT_BIT      0x2
-#define FRONT_DIFFUSE_BIT     0x4
-#define BACK_DIFFUSE_BIT      0x8
-#define FRONT_SPECULAR_BIT   0x10
-#define BACK_SPECULAR_BIT    0x20
-#define FRONT_EMISSION_BIT   0x40
-#define BACK_EMISSION_BIT    0x80
-#define FRONT_SHININESS_BIT 0x100
-#define BACK_SHININESS_BIT  0x200
-#define FRONT_INDEXES_BIT   0x400
-#define BACK_INDEXES_BIT    0x800
-
-#define FRONT_MATERIAL_BITS	(FRONT_EMISSION_BIT | FRONT_AMBIENT_BIT | \
-				 FRONT_DIFFUSE_BIT | FRONT_SPECULAR_BIT | \
-				 FRONT_SHININESS_BIT | FRONT_INDEXES_BIT)
-
-#define BACK_MATERIAL_BITS	(BACK_EMISSION_BIT | BACK_AMBIENT_BIT | \
-				 BACK_DIFFUSE_BIT | BACK_SPECULAR_BIT | \
-				 BACK_SHININESS_BIT | BACK_INDEXES_BIT)
-
-#define ALL_MATERIAL_BITS	(FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)
-
-
-
-/*
- * Specular exponent and material shininess lookup table sizes:
- */
-#define EXP_TABLE_SIZE 512
-#define SHINE_TABLE_SIZE 256
-
-struct gl_light {
-   struct gl_light *next;	        /* double linked list with sentinel */
-   struct gl_light *prev;
-
-   GLfloat Ambient[4];		/* ambient color */
-   GLfloat Diffuse[4];		/* diffuse color */
-   GLfloat Specular[4];		/* specular color */
-   GLfloat EyePosition[4];	/* position in eye coordinates */
-   GLfloat EyeDirection[4];	/* spotlight dir in eye coordinates */
-   GLfloat SpotExponent;
-   GLfloat SpotCutoff;		/* in degress */
-   GLfloat CosCutoff;		/* = MAX(0, cos(SpotCutoff)) */
-   GLfloat ConstantAttenuation;
-   GLfloat LinearAttenuation;
-   GLfloat QuadraticAttenuation;
-   GLboolean Enabled;		/* On/off flag */
-
-   /* Derived fields */
-   GLuint Flags;		/* State */
-
-   GLfloat Position[4];		/* position in eye/obj coordinates */
-   GLfloat VP_inf_norm[3];	/* Norm direction to infinite light */
-   GLfloat h_inf_norm[3];	/* Norm( VP_inf_norm + <0,0,1> ) */
-   GLfloat NormDirection[4];	/* normalized spotlight direction */
-   GLfloat VP_inf_spot_attenuation;
-
-   GLfloat SpotExpTable[EXP_TABLE_SIZE][2];  /* to replace a pow() call */
-   GLfloat MatAmbient[2][3];	/* material ambient * light ambient */
-   GLfloat MatDiffuse[2][3];	/* material diffuse * light diffuse */
-   GLfloat MatSpecular[2][3];	/* material spec * light specular */
-   GLfloat dli;			/* CI diffuse light intensity */
-   GLfloat sli;			/* CI specular light intensity */
-   GLboolean IsMatSpecular[2];
-};
-
-
-struct gl_lightmodel {
-   GLfloat Ambient[4];		/* ambient color */
-   GLboolean LocalViewer;	/* Local (or infinite) view point? */
-   GLboolean TwoSide;		/* Two (or one) sided lighting? */
-   GLenum ColorControl;		/* either GL_SINGLE_COLOR */
-				/* or GL_SEPARATE_SPECULAR_COLOR */
-};
-
-
-/*
- * Attribute structures:
- *    We define a struct for each attribute group to make pushing and
- *    popping attributes easy.  Also it's a good organization.
- */
-
-
-struct gl_accum_attrib {
-   GLfloat ClearColor[4];	/* Accumulation buffer clear color */
-};
-
-
-/*
- * Used in DrawDestMask below
- */
-#define FRONT_LEFT_BIT  1
-#define FRONT_RIGHT_BIT 2
-#define BACK_LEFT_BIT   4
-#define BACK_RIGHT_BIT  8
-
-
-struct gl_colorbuffer_attrib {
-   GLuint ClearIndex;			/* Index to use for glClear */
-   GLfloat ClearColor[4];		/* Color to use for glClear */
-
-   GLuint IndexMask;			/* Color index write mask */
-   GLubyte ColorMask[4];		/* Each flag is 0xff or 0x0 */
-   GLboolean SWmasking;			/* Do color/CI masking in software? */
-
-   GLenum DrawBuffer;			/* Which buffer to draw into */
-   GLenum DriverDrawBuffer;		/* Current device driver dest buffer */
-   GLboolean MultiDrawBuffer;		/* Drawing to mutliple buffers? */
-   GLubyte DrawDestMask;		/* bitwise-OR of bitflags above */
-
-   /* alpha testing */
-   GLboolean AlphaEnabled;		/* Alpha test enabled flag */
-   GLenum AlphaFunc;			/* Alpha test function */
-   GLubyte AlphaRef;			/* Alpha ref value in range [0,255] */
-
-   /* blending */
-   GLboolean BlendEnabled;		/* Blending enabled flag */
-   GLenum BlendSrcRGB;			/* Blending source operator */
-   GLenum BlendDstRGB;			/* Blending destination operator */
-   GLenum BlendSrcA;			/* GL_INGR_blend_func_separate */
-   GLenum BlendDstA;			/* GL_INGR_blend_func_separate */
-   GLenum BlendEquation;
-   GLfloat BlendColor[4];
-   blend_func BlendFunc;		/* Points to C blending function */
-
-   /* logic op */
-   GLenum LogicOp;			/* Logic operator */
-   GLboolean IndexLogicOpEnabled;	/* Color index logic op enabled flag */
-   GLboolean ColorLogicOpEnabled;	/* RGBA logic op enabled flag */
-   GLboolean SWLogicOpEnabled;		/* Do logic ops in software? */
-
-   GLboolean DitherFlag;		/* Dither enable flag */
-};
-
-
-struct gl_current_attrib {
-   /* KW: These values valid only when the VB is flushed.
-    */
-   GLuint Flag;		                	/* Contains size information */
-   GLfloat Normal[3];
-   GLubyte ByteColor[4];			/* Current RGBA color */
-   GLuint Index;				/* Current color index */
-   GLboolean EdgeFlag;				/* Current edge flag */
-   GLfloat Texcoord[MAX_TEXTURE_UNITS][4];	/* Current texture coords */
-   GLenum Primitive;		                /* Prim or GL_POLYGON+1 */
-
-   /* KW: No change to these values.
-    */
-   GLfloat RasterPos[4];			/* Current raster position */
-   GLfloat RasterDistance;			/* Current raster distance */
-   GLfloat RasterColor[4];			/* Current raster color */
-   GLuint  RasterIndex;				/* Current raster index */
-   GLfloat *RasterTexCoord;			/* Current raster texcoord*/
-   GLfloat RasterMultiTexCoord[MAX_TEXTURE_UNITS][4];
-   GLboolean RasterPosValid;			/* Raster po valid flag */
-};
-
-
-struct gl_depthbuffer_attrib {
-   GLenum Func;			/* Function for depth buffer compare */
-   GLfloat Clear;		/* Value to clear depth buffer to */
-   GLboolean Test;		/* Depth buffering enabled flag */
-   GLboolean Mask;		/* Depth buffer writable? */
-   GLboolean OcclusionTest;	/* GL_HP_occlusion_test */
-};
-
-
-struct gl_enable_attrib {
-   GLboolean AlphaTest;
-   GLboolean AutoNormal;
-   GLboolean Blend;
-   GLboolean ClipPlane[MAX_CLIP_PLANES];
-   GLboolean ColorMaterial;
-   GLboolean Convolution1D;
-   GLboolean Convolution2D;
-   GLboolean Separable2D;
-   GLboolean CullFace;
-   GLboolean DepthTest;
-   GLboolean Dither;
-   GLboolean Fog;
-   GLboolean Histogram;
-   GLboolean Light[MAX_LIGHTS];
-   GLboolean Lighting;
-   GLboolean LineSmooth;
-   GLboolean LineStipple;
-   GLboolean IndexLogicOp;
-   GLboolean ColorLogicOp;
-   GLboolean Map1Color4;
-   GLboolean Map1Index;
-   GLboolean Map1Normal;
-   GLboolean Map1TextureCoord1;
-   GLboolean Map1TextureCoord2;
-   GLboolean Map1TextureCoord3;
-   GLboolean Map1TextureCoord4;
-   GLboolean Map1Vertex3;
-   GLboolean Map1Vertex4;
-   GLboolean Map2Color4;
-   GLboolean Map2Index;
-   GLboolean Map2Normal;
-   GLboolean Map2TextureCoord1;
-   GLboolean Map2TextureCoord2;
-   GLboolean Map2TextureCoord3;
-   GLboolean Map2TextureCoord4;
-   GLboolean Map2Vertex3;
-   GLboolean Map2Vertex4;
-   GLboolean MinMax;
-   GLboolean Normalize;
-   GLboolean PixelTexture;
-   GLboolean PointSmooth;
-   GLboolean PolygonOffsetPoint;
-   GLboolean PolygonOffsetLine;
-   GLboolean PolygonOffsetFill;
-   GLboolean PolygonSmooth;
-   GLboolean PolygonStipple;
-   GLboolean RescaleNormals;
-   GLboolean Scissor;
-   GLboolean Stencil;
-   GLuint Texture[MAX_TEXTURE_UNITS];
-   GLuint TexGen[MAX_TEXTURE_UNITS];
-};
-
-
-struct gl_eval_attrib {
-   /* Enable bits */
-   GLboolean Map1Color4;
-   GLboolean Map1Index;
-   GLboolean Map1Normal;
-   GLboolean Map1TextureCoord1;
-   GLboolean Map1TextureCoord2;
-   GLboolean Map1TextureCoord3;
-   GLboolean Map1TextureCoord4;
-   GLboolean Map1Vertex3;
-   GLboolean Map1Vertex4;
-   GLboolean Map2Color4;
-   GLboolean Map2Index;
-   GLboolean Map2Normal;
-   GLboolean Map2TextureCoord1;
-   GLboolean Map2TextureCoord2;
-   GLboolean Map2TextureCoord3;
-   GLboolean Map2TextureCoord4;
-   GLboolean Map2Vertex3;
-   GLboolean Map2Vertex4;
-   GLboolean AutoNormal;
-   /* Map Grid endpoints and divisions and calculated du values */
-   GLint MapGrid1un;
-   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;
-   GLint MapGrid2un, MapGrid2vn;
-   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;
-   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;
-};
-
-
-struct gl_fog_attrib {
-   GLboolean Enabled;		/* Fog enabled flag */
-   GLfloat Color[4];		/* Fog color */
-   GLfloat Density;		/* Density >= 0.0 */
-   GLfloat Start;		/* Start distance in eye coords */
-   GLfloat End;			/* End distance in eye coords */
-   GLfloat Index;		/* Fog index */
-   GLenum Mode;			/* Fog mode */
-};
-
-
-struct gl_hint_attrib {
-   /* always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE */
-   GLenum PerspectiveCorrection;
-   GLenum PointSmooth;
-   GLenum LineSmooth;
-   GLenum PolygonSmooth;
-   GLenum Fog;
-
-   /* GL_PGI_misc_hints */
-   GLenum AllowDrawWin;
-   GLenum AllowDrawFrg;
-   GLenum AllowDrawMem;
-   GLenum StrictLighting;
-
-   /* GL_EXT_clip_volume_hint */
-   GLenum ClipVolumeClipping;
-
-   /* GL_ARB_texture_compression */
-   GLenum TextureCompression;
-};
-
-
-struct gl_histogram_attrib {
-   GLuint Width;
-   GLint Format;
-   GLboolean Sink;
-   GLuint RedSize;
-   GLuint GreenSize;
-   GLuint BlueSize;
-   GLuint AlphaSize;
-   GLuint LuminanceSize;
-   GLuint Count[HISTOGRAM_TABLE_SIZE][4];
-};
-
-
-struct gl_minmax_attrib {
-   GLenum Format;
-   GLboolean Sink;
-   GLfloat Min[4], Max[4];   /* RGBA */
-};
-
-
-struct gl_convolution_attrib {
-   /* XXX not done yet */
-   GLenum Format;
-   GLenum InternalFormat;
-   GLuint Width;
-   GLuint Height;
-   GLfloat Filter[MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_HEIGHT * 4];
-};
-
-
-struct gl_light_attrib {
-   struct gl_light Light[MAX_LIGHTS];	/* Array of lights */
-   struct gl_lightmodel Model;		/* Lighting model */
-   struct gl_material Material[2];	/* Material 0=front, 1=back */
-   GLboolean Enabled;			/* Lighting enabled flag */
-   GLenum ShadeModel;			/* GL_FLAT or GL_SMOOTH */
-   GLenum ColorMaterialFace;		/* GL_FRONT, BACK or FRONT_AND_BACK */
-   GLenum ColorMaterialMode;		/* GL_AMBIENT, GL_DIFFUSE, etc */
-   GLuint ColorMaterialBitmask;		/* bitmask formed from Face and Mode */
-   GLboolean ColorMaterialEnabled;
-
-   struct gl_light EnabledList;         /* List sentinel */
-
-   /* Derived for optimizations: */
-   GLboolean NeedVertices;		/* Use fast shader? */
-   GLuint  Flags;		        /* State, see below */
-   GLfloat BaseColor[2][3];
-   GLubyte BaseAlpha[2];
-};
-
-
-#define LIGHT_POSITIONAL   0x4
-#define LIGHT_SPECULAR     0x8
-#define LIGHT_SPOT         0x10
-#define LIGHT_LOCAL_VIEWER 0x20
-#define LIGHT_TWO_SIDE     0x40
-
-#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
-
-struct gl_line_attrib {
-   GLboolean SmoothFlag;	/* GL_LINE_SMOOTH enabled? */
-   GLboolean StippleFlag;	/* GL_LINE_STIPPLE enabled? */
-   GLushort StipplePattern;	/* Stipple pattern */
-   GLint StippleFactor;		/* Stipple repeat factor */
-   GLfloat Width;		/* Line width */
-};
-
-
-struct gl_list_attrib {
-   GLuint ListBase;
-};
-
-
-struct gl_pixel_attrib {
-   GLenum ReadBuffer;		/* src buffer for glRead/CopyPixels */
-   GLenum DriverReadBuffer;	/* Driver's current source buffer */
-   GLfloat RedBias, RedScale;
-   GLfloat GreenBias, GreenScale;
-   GLfloat BlueBias, BlueScale;
-   GLfloat AlphaBias, AlphaScale;
-   GLboolean ScaleOrBiasRGBA;
-   GLfloat DepthBias, DepthScale;
-   GLint IndexShift, IndexOffset;
-   GLboolean MapColorFlag;
-   GLboolean MapStencilFlag;
-   GLfloat ZoomX, ZoomY;
-   GLint MapStoSsize;		/* Size of each pixel map */
-   GLint MapItoIsize;
-   GLint MapItoRsize;
-   GLint MapItoGsize;
-   GLint MapItoBsize;
-   GLint MapItoAsize;
-   GLint MapRtoRsize;
-   GLint MapGtoGsize;
-   GLint MapBtoBsize;
-   GLint MapAtoAsize;
-   GLint MapStoS[MAX_PIXEL_MAP_TABLE];	/* Pixel map tables */
-   GLint MapItoI[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapItoR[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapItoG[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapItoB[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapItoA[MAX_PIXEL_MAP_TABLE];
-   GLubyte MapItoR8[MAX_PIXEL_MAP_TABLE];  /* converted to 8-bit color */
-   GLubyte MapItoG8[MAX_PIXEL_MAP_TABLE];
-   GLubyte MapItoB8[MAX_PIXEL_MAP_TABLE];
-   GLubyte MapItoA8[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapRtoR[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapGtoG[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapBtoB[MAX_PIXEL_MAP_TABLE];
-   GLfloat MapAtoA[MAX_PIXEL_MAP_TABLE];
-   /* GL_EXT_histogram */
-   GLboolean HistogramEnabled;
-   GLboolean MinMaxEnabled;
-   /* GL_SGIS_pixel_texture */
-   GLboolean PixelTextureEnabled;
-   GLenum FragmentRgbSource;
-   GLenum FragmentAlphaSource;
-   /* GL_SGI_color_matrix */
-   GLfloat PostColorMatrixScale[4];  /* RGBA */
-   GLfloat PostColorMatrixBias[4];   /* RGBA */
-   GLboolean ScaleOrBiasRGBApcm;
-   /* GL_SGI_color_table */
-   GLfloat ColorTableScale[4];
-   GLfloat ColorTableBias[4];
-   GLboolean ColorTableEnabled;
-   GLfloat PCCTscale[4];
-   GLfloat PCCTbias[4];
-   GLboolean PostConvolutionColorTableEnabled;
-   GLfloat PCMCTscale[4];
-   GLfloat PCMCTbias[4];
-   GLboolean PostColorMatrixColorTableEnabled;
-   /* Convolution */
-   GLboolean Convolution1DEnabled;
-   GLboolean Convolution2DEnabled;
-   GLboolean Separable2DEnabled;
-   GLfloat ConvolutionBorderColor[3][4];
-   GLenum ConvolutionBorderMode[3];
-   GLfloat ConvolutionFilterScale[3][4];
-   GLfloat ConvolutionFilterBias[3][4];
-   GLfloat PostConvolutionScale[4];  /* RGBA */
-   GLfloat PostConvolutionBias[4];   /* RGBA */
-};
-
-
-struct gl_point_attrib {
-   GLboolean SmoothFlag;/* True if GL_POINT_SMOOTH is enabled */
-   GLfloat UserSize;	/* User-specified point size */
-   GLfloat Size;	/* Point size actually used */
-   GLfloat Params[3];	/* Point Parameters EXT distance atenuation
-			   factors by default = {1,0,0} */
-   GLfloat MinSize;	/* Default 0.0 always >=0 */
-   GLfloat MaxSize;	/* Default MAX_POINT_SIZE */
-   GLfloat Threshold;	/* Default 1.0 */
-   GLboolean Attenuated;
-};
-
-
-struct gl_polygon_attrib {
-   GLenum FrontFace;		/* Either GL_CW or GL_CCW */
-   GLenum FrontMode;		/* Either GL_POINT, GL_LINE or GL_FILL */
-   GLenum BackMode;		/* Either GL_POINT, GL_LINE or GL_FILL */
-   GLboolean FrontBit;		/*  */
-   GLboolean Unfilled;		/* True if back or front mode is not GL_FILL */
-   GLboolean CullFlag;		/* Culling on/off flag */
-   GLubyte CullBits;		/* Used for cull testing */
-   GLboolean SmoothFlag;	/* True if GL_POLYGON_SMOOTH is enabled */
-   GLboolean StippleFlag;	/* True if GL_POLYGON_STIPPLE is enabled */
-   GLenum CullFaceMode;		/* Culling mode GL_FRONT or GL_BACK */
-   GLfloat OffsetFactor;	/* Polygon offset factor */
-   GLfloat OffsetUnits;		/* Polygon offset units */
-   GLboolean OffsetPoint;	/* Offset in GL_POINT mode? */
-   GLboolean OffsetLine;	/* Offset in GL_LINE mode? */
-   GLboolean OffsetFill;	/* Offset in GL_FILL mode? */
-};
-
-
-struct gl_scissor_attrib {
-   GLboolean Enabled;		/* Scissor test enabled? */
-   GLint X, Y;			/* Lower left corner of box */
-   GLsizei Width, Height;		/* Size of box */
-};
-
-
-struct gl_stencil_attrib {
-   GLboolean Enabled;		/* Enabled flag */
-   GLenum Function;		/* Stencil function */
-   GLenum FailFunc;		/* Fail function */
-   GLenum ZPassFunc;		/* Depth buffer pass function */
-   GLenum ZFailFunc;		/* Depth buffer fail function */
-   GLstencil Ref;			/* Reference value */
-   GLstencil ValueMask;		/* Value mask */
-   GLstencil Clear;		/* Clear value */
-   GLstencil WriteMask;		/* Write mask */
-};
-
-
-/* TexGenEnabled flags */
-#define S_BIT 1
-#define T_BIT 2
-#define R_BIT 4
-#define Q_BIT 8
-
-/* Texture Enabled flags */
-#define TEXTURE0_1D   0x1     /* Texture unit 0 (default) */
-#define TEXTURE0_2D   0x2
-#define TEXTURE0_3D   0x4
-#define TEXTURE0_CUBE 0x8
-#define TEXTURE0_ANY  (TEXTURE0_1D | TEXTURE0_2D | TEXTURE0_3D | TEXTURE0_CUBE)
-#define TEXTURE1_1D   (TEXTURE0_1D << 4)    /* Texture unit 1 */
-#define TEXTURE1_2D   (TEXTURE0_2D << 4)
-#define TEXTURE1_3D   (TEXTURE0_3D << 4)
-#define TEXTURE1_CUBE (TEXTURE0_CUBE << 4)
-#define TEXTURE1_ANY  (TEXTURE1_1D | TEXTURE1_2D | TEXTURE1_3D | TEXTURE1_CUBE)
-
-/* Bitmap versions of the GL_ constants.
- */
-#define TEXGEN_SPHERE_MAP        0x1
-#define TEXGEN_OBJ_LINEAR        0x2
-#define TEXGEN_EYE_LINEAR        0x4
-#define TEXGEN_REFLECTION_MAP_NV 0x8
-#define TEXGEN_NORMAL_MAP_NV     0x10
-
-#define TEXGEN_NEED_M            (TEXGEN_SPHERE_MAP)
-#define TEXGEN_NEED_F            (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV)
-#define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV | \
-				  TEXGEN_NORMAL_MAP_NV)
-#define TEXGEN_NEED_VERTICES     (TEXGEN_OBJ_LINEAR | 		\
-				  TEXGEN_EYE_LINEAR |		\
-				  TEXGEN_REFLECTION_MAP_NV |	\
-				  TEXGEN_SPHERE_MAP )
-#define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV | \
-				  TEXGEN_NORMAL_MAP_NV     | \
-				  TEXGEN_EYE_LINEAR)
-
-
-/* A selection of state flags to make choosing optimized pipelines easier.
- */
-#define ENABLE_TEX0         0xf	/* TEXTURE0_ANY */
-#define ENABLE_TEX1         0xf0   /* TEXTURE1_ANY */
-#define ENABLE_LIGHT        0x100
-#define ENABLE_FOG          0x200
-#define ENABLE_USERCLIP     0x400
-#define ENABLE_TEXGEN0      0x800
-#define ENABLE_TEXGEN1      0x1000
-#define ENABLE_TEXMAT0      0x2000	/* Ie. not the identity matrix */
-#define ENABLE_TEXMAT1      0x4000
-#define ENABLE_VIEWCLIP     0x8000
-#define ENABLE_NORMALIZE    0x10000
-#define ENABLE_RESCALE      0x20000
-#define ENABLE_POINT_ATTEN  0x40000
-
-
-#define ENABLE_TEX_ANY  (ENABLE_TEX0 | ENABLE_TEX1)
-
-
-typedef void (*texgen_func)( struct vertex_buffer *VB,
-			     GLuint textureSet);
-
-
-/* Texture object record */
-struct gl_texture_object {
-   _glthread_Mutex Mutex;	/* for thread safety */
-   GLint RefCount;		/* reference count */
-   GLuint Name;			/* an unsigned integer */
-   GLuint Dimensions;		/* 1 or 2 or 3 */
-   GLfloat Priority;		/* in [0,1] */
-   GLubyte BorderColor[4];	/* as integers in [0,255] */
-   GLenum WrapS;		/* GL_CLAMP, REPEAT or CLAMP_TO_EDGE */
-   GLenum WrapT;		/* GL_CLAMP, REPEAT or CLAMP_TO_EDGE */
-   GLenum WrapR;		/* GL_CLAMP, REPEAT or CLAMP_TO_EDGE */
-   GLenum MinFilter;		/* minification filter */
-   GLenum MagFilter;		/* magnification filter */
-   GLfloat MinLod;		/* OpenGL 1.2 */
-   GLfloat MaxLod;		/* OpenGL 1.2 */
-   GLint BaseLevel;		/* OpenGL 1.2 */
-   GLint MaxLevel;		/* OpenGL 1.2 */
-   GLint P;			/* Highest mipmap level */
-   GLfloat M;			/* = MIN(MaxLevel, P) - BaseLevel */
-   GLfloat MinMagThresh;	/* min/mag threshold */
-   struct gl_texture_image *Image[MAX_TEXTURE_LEVELS];
-
-   /* Texture cube faces */
-   /* Image[] is alias for *PosX[MAX_TEXTURE_LEVELS]; */
-   struct gl_texture_image *NegX[MAX_TEXTURE_LEVELS];
-   struct gl_texture_image *PosY[MAX_TEXTURE_LEVELS];
-   struct gl_texture_image *NegY[MAX_TEXTURE_LEVELS];
-   struct gl_texture_image *PosZ[MAX_TEXTURE_LEVELS];
-   struct gl_texture_image *NegZ[MAX_TEXTURE_LEVELS];
-
-   /* GL_EXT_paletted_texture */
-   struct gl_color_table Palette;
-
-   /* For device driver: */
-   GLboolean Dirty;	/* Is this texture object in dirty list? */
-   void *DriverData;	/* Arbitrary device driver data */
-
-   GLboolean Complete;			/* Complete set of images? */
-   TextureSampleFunc SampleFunc;	/* The texel sampling function */
-   struct gl_texture_object *Next;	/* Next in linked list */
-   struct gl_texture_object *NextDirty;	/* Next in dirty linked list */
-};
-
-
-
-/*
- * Texture units are new with the multitexture extension.
- */
-struct gl_texture_unit {
-   GLuint Enabled;              /* bitmask of TEXTURE0_1D, _2D, _3D, _CUBE */
-   GLuint ReallyEnabled;        /* 0 or one of TEXTURE0_1D, _2D, _3D, _CUBE */
-
-   GLenum EnvMode;	   /* GL_MODULATE, GL_DECAL, GL_BLEND, GL_COMBINE_EXT */
-   GLenum LastEnvMode;
-
-   GLenum CombineSourceRGB[3];  /* arg[i] for rgb EXT_texture_combine   */
-   GLenum CombineSourceA[3];    /* dito for alpha combiner              */
-   GLenum CombineModeRGB;       /* GL_REPLACE, GL_DECAL, GL_ADD ...     */
-   GLenum CombineModeA;
-   GLenum CombineOperandRGB[3]; /* SRC_COLOR or ONE_MINUS_SRC_COLOR     */
-   GLenum CombineOperandA[3];   /* SRC_ALPHA or ONE_MINUS_SRC_ALPHA     */
-   GLuint CombineScaleShiftRGB; /* 0, 1 or 2   */
-   GLuint CombineScaleShiftA;
-
-   GLfloat EnvColor[4];
-   GLuint TexGenEnabled;	/* Bitwise-OR of [STRQ]_BIT values */
-   GLenum GenModeS;		/* Tex coord generation mode, either */
-   GLenum GenModeT;		/*	GL_OBJECT_LINEAR, or */
-   GLenum GenModeR;		/*	GL_EYE_LINEAR, or    */
-   GLenum GenModeQ;		/*      GL_SPHERE_MAP        */
-   GLuint GenBitS;
-   GLuint GenBitT;
-   GLuint GenBitR;
-   GLuint GenBitQ;
-   GLuint GenFlags;		/* bitwise or of GenBit[STRQ] */
-   GLfloat ObjectPlaneS[4];
-   GLfloat ObjectPlaneT[4];
-   GLfloat ObjectPlaneR[4];
-   GLfloat ObjectPlaneQ[4];
-   GLfloat EyePlaneS[4];
-   GLfloat EyePlaneT[4];
-   GLfloat EyePlaneR[4];
-   GLfloat EyePlaneQ[4];
-   texgen_func *func;		/* points to array of func pointers */
-   GLubyte Holes;		/* elements not generated by texgen */
-   GLuint  TexgenSize;		/* size of element generated */
-   GLboolean AnyTransform;	/* texgen or non-identity matrix */
-   GLfloat LodBias;		/* for biasing mipmap levels */
-
-   struct gl_texture_object *CurrentD[4];
-   struct gl_texture_object *CurrentCubeMap; /* GL_ARB_texture_cube_map */
-
-   struct gl_texture_object *Current;
-   GLuint CurrentDimension;
-
-   struct gl_texture_object Saved1D;  /* only used by glPush/PopAttrib */
-   struct gl_texture_object Saved2D;
-   struct gl_texture_object Saved3D;
-   struct gl_texture_object SavedCubeMap;
-};
-
-
-struct gl_texture_attrib {
-   /* multitexture */
-   GLuint CurrentUnit;			/* Current texture unit */
-   GLuint CurrentTransformUnit;		/* Current texture xform unit */
-
-   GLuint ReallyEnabled;     /* Really enabled (w.r.t. completeness, etc) */
-
-   GLuint LastEnabled;	/* Decide whether enabled has really changed */
-
-   GLboolean NeedNormals;
-   GLboolean NeedEyeCoords;
-
-   struct gl_texture_unit Unit[MAX_TEXTURE_UNITS];
-
-   struct gl_texture_object *Proxy1D;
-   struct gl_texture_object *Proxy2D;
-   struct gl_texture_object *Proxy3D;
-   struct gl_texture_object *ProxyCubeMap;
-
-   /* GL_EXT_shared_texture_palette */
-   GLboolean SharedPalette;
-   struct gl_color_table Palette;
-};
-
-
-
-/* KW: Renamed ClipEquation to avoid having 'ClipClipEquation'
- */
-struct gl_transform_attrib {
-   GLenum MatrixMode;				/* Matrix mode */
-   GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];
-   GLfloat ClipUserPlane[MAX_CLIP_PLANES][4];	/* derived */
-   GLboolean ClipEnabled[MAX_CLIP_PLANES];
-   GLubyte   AnyClip;				/* How many ClipEnabled? */
-   GLboolean Normalize;				/* Normalize all normals? */
-   GLboolean RescaleNormals;			/* GL_EXT_rescale_normal */
-};
-
-
-struct gl_viewport_attrib {
-   GLint X, Y;			/* position */
-   GLsizei Width, Height;	/* size */
-   GLfloat Near, Far;		/* Depth buffer range */
-   GLmatrix WindowMap;		/* Mapping transformation as a matrix. */
-};
-
-
-/* For the attribute stack: */
-struct gl_attrib_node {
-   GLbitfield kind;
-   void *data;
-   struct gl_attrib_node *next;
-};
-
-
-
-/*
- * Client pixel packing/unpacking attributes
- */
-struct gl_pixelstore_attrib {
-   GLint Alignment;
-   GLint RowLength;
-   GLint SkipPixels;
-   GLint SkipRows;
-   GLint ImageHeight;     /* for GL_EXT_texture3D */
-   GLint SkipImages;      /* for GL_EXT_texture3D */
-   GLboolean SwapBytes;
-   GLboolean LsbFirst;
-};
-
-
-/*
- * Client vertex array attributes
- */
-struct gl_client_array {
-   GLint Size;
-   GLenum Type;
-   GLsizei Stride;		/* user-specified stride */
-   GLsizei StrideB;		/* actual stride in bytes */
-   void *Ptr;
-   GLboolean Enabled;
-};
-
-
-/* KW:  New functions to populate a vector from data of a different type.
- *      Used in the array interface.  Flags & match only used in the
- *      specialized array-element case.
- */
-typedef void (*trans_1ui_func)(GLuint *to,
-			       const struct gl_client_array *from,
-			       GLuint start,
-			       GLuint n );
-
-typedef void (*trans_1ub_func)(GLubyte *to,
-			       const struct gl_client_array *from,
-			       GLuint start,
-			       GLuint n );
-
-typedef void (*trans_4ub_func)(GLubyte (*to)[4],
-			       const struct gl_client_array *from,
-			       GLuint start,
-			       GLuint n );
-
-typedef void (*trans_4f_func)(GLfloat (*to)[4],
-			      const struct gl_client_array *from,
-			      GLuint start,
-			      GLuint n );
-
-typedef void (*trans_3f_func)(GLfloat (*to)[3],
-			      const struct gl_client_array *from,
-			      GLuint start,
-			      GLuint n );
-
-
-
-typedef void (*trans_elt_1ui_func)(GLuint *to,
-				   const struct gl_client_array *from,
-				   GLuint *flags,
-				   GLuint *elts,
-				   GLuint match,
-				   GLuint start,
-				   GLuint n );
-
-typedef void (*trans_elt_1ub_func)(GLubyte *to,
-				   const struct gl_client_array *from,
-				   GLuint *flags,
-				   GLuint *elts,
-				   GLuint match,
-				   GLuint start,
-				   GLuint n );
-
-typedef void (*trans_elt_4ub_func)(GLubyte (*to)[4],
-				   const struct gl_client_array *from,
-				   GLuint *flags,
-				   GLuint *elts,
-				   GLuint match,
-				   GLuint start,
-				   GLuint n );
-
-typedef void (*trans_elt_4f_func)(GLfloat (*to)[4],
-				  const struct gl_client_array *from,
-				  GLuint *flags,
-				  GLuint *elts,
-				  GLuint match,
-				  GLuint start,
-				  GLuint n );
-
-typedef void (*trans_elt_3f_func)(GLfloat (*to)[3],
-				  const struct gl_client_array *from,
-				  GLuint *flags,
-				  GLuint *elts,
-				  GLuint match,
-				  GLuint start,
-				  GLuint n );
-
-
-/*#define VAO*/
-#ifdef VAO
-struct gl_array_object {
-   GLuint Name;
-   GLuint RefCount;
-
-   struct gl_client_array Vertex;	     /* client data descriptors */
-   struct gl_client_array Normal;
-   struct gl_client_array Color;
-   struct gl_client_array Index;
-   struct gl_client_array TexCoord[MAX_TEXTURE_UNITS];
-   struct gl_client_array EdgeFlag;
-
-   trans_4f_func  VertexFunc;       /* conversion functions */
-   trans_3f_func  NormalFunc;
-   trans_4ub_func ColorFunc;
-   trans_1ui_func IndexFunc;
-   trans_4f_func  TexCoordFunc[MAX_TEXTURE_UNITS];
-   trans_1ub_func EdgeFlagFunc;
-
-   trans_elt_4f_func  VertexEltFunc; /* array elt conversion functions */
-   trans_elt_3f_func  NormalEltFunc;
-   trans_elt_4ub_func ColorEltFunc;
-   trans_elt_1ui_func IndexEltFunc;
-   trans_elt_4f_func  TexCoordEltFunc[MAX_TEXTURE_UNITS];
-   trans_elt_1ub_func EdgeFlagEltFunc;
-
-   GLint TexCoordInterleaveFactor;
-
-   GLuint LockFirst;
-   GLuint LockCount;
-
-   GLuint Flag[VB_SIZE];	/* crock */
-   GLuint Flags;
-   GLuint Summary;		/* Like flags, but no size information */
-};
-#endif
-
-
-struct gl_array_attrib {
-#ifdef VAO
-   struct gl_array_object *Current;
-   GLint ActiveTexture;		/* Client Active Texture */
-   GLuint NewArrayState;	/* Tracks which arrays have been changed. */
-#else
-   struct gl_client_array Vertex;	     /* client data descriptors */
-   struct gl_client_array Normal;
-   struct gl_client_array Color;
-   struct gl_client_array Index;
-   struct gl_client_array TexCoord[MAX_TEXTURE_UNITS];
-   struct gl_client_array EdgeFlag;
-
-   trans_4f_func  VertexFunc;       /* conversion functions */
-   trans_3f_func  NormalFunc;
-   trans_4ub_func ColorFunc;
-   trans_1ui_func IndexFunc;
-   trans_4f_func  TexCoordFunc[MAX_TEXTURE_UNITS];
-   trans_1ub_func EdgeFlagFunc;
-
-   trans_elt_4f_func  VertexEltFunc; /* array elt conversion functions */
-   trans_elt_3f_func  NormalEltFunc;
-   trans_elt_4ub_func ColorEltFunc;
-   trans_elt_1ui_func IndexEltFunc;
-   trans_elt_4f_func  TexCoordEltFunc[MAX_TEXTURE_UNITS];
-   trans_elt_1ub_func EdgeFlagEltFunc;
-
-   GLint TexCoordInterleaveFactor;
-   GLint ActiveTexture;		/* Client Active Texture */
-
-   GLuint LockFirst;
-   GLuint LockCount;
-
-   GLuint Flag[VB_SIZE];	/* crock */
-   GLuint Flags;
-   GLuint Summary;		/* Like flags, but no size information */
-   GLuint NewArrayState;	/* Tracks which arrays have been changed. */
-#endif
-};
-
-
-/* These are used to make the ctx->Current values look like
- * arrays (with zero StrideB).
- */
-struct gl_fallback_arrays {
-   struct gl_client_array Normal;
-   struct gl_client_array Color;
-   struct gl_client_array Index;
-   struct gl_client_array TexCoord[MAX_TEXTURE_UNITS];
-   struct gl_client_array EdgeFlag;
-};
-
-#define MAX_PIPELINE_STAGES     30
-
-#define PIPE_IMMEDIATE          0x1
-#define PIPE_PRECALC            0x2
-
-#define PIPE_OP_VERT_XFORM      0x1
-#define PIPE_OP_NORM_XFORM      0x2
-#define PIPE_OP_LIGHT           0x4
-#define PIPE_OP_FOG             0x8
-#define PIPE_OP_TEX0            0x10
-#define PIPE_OP_TEX1            0x20
-#define PIPE_OP_RAST_SETUP_0    0x40
-#define PIPE_OP_RAST_SETUP_1    0x80
-#define PIPE_OP_RENDER          0x100
-#define PIPE_OP_CVA_PREPARE     0x200
-
-
-/* Nodes in a state machine to drive rendering of the various
- * point/line/tri primitives.
- */
-struct gl_prim_state {
-   GLuint v0, v1;
-   GLboolean draw;
-   GLboolean finish_loop;	/* not used... */
-   struct gl_prim_state *next;
-};
-
-
-typedef void (*vb_func)( struct vertex_buffer *VB );
-typedef void (*ctx_func)( GLcontext * );
-
-struct gl_pipeline_stage {
-   const char *name;
-   GLuint ops;			/* PIPE_OP flags */
-   GLuint type;			/* PIPE flags */
-   GLuint special;		/* PIPE flags - force update_inputs() */
-   GLuint state_change;	        /* state flags - trigger update_inputs() */
-   GLuint cva_state_change;          /* state flags - recalc cva buffer */
-   GLuint elt_forbidden_inputs;      /* VERT flags - force a pipeline recalc */
-   GLuint pre_forbidden_inputs;	     /* VERT flags - force a pipeline recalc */
-   GLuint active;		     /* PIPE flags */
-   GLuint inputs;		     /* VERT flags */
-   GLuint outputs;		     /* VERT flags */
-   void (*check)( GLcontext *ctx, struct gl_pipeline_stage * );
-   void (*run)( struct vertex_buffer *VB );
-};
-
-
-struct gl_pipeline {
-   GLuint state_change;		/* state changes which require recalc */
-   GLuint cva_state_change;	/* ... which require re-run */
-   GLuint forbidden_inputs;	/* inputs which require recalc */
-   GLuint ops;			/* what gets done in this pipe */
-   GLuint changed_ops;
-   GLuint inputs;
-   GLuint outputs;
-   GLuint new_inputs;
-   GLuint new_outputs;
-   GLuint fallback;
-   GLuint type;
-   GLuint pipeline_valid:1;
-   GLuint data_valid:1;
-   GLuint copy_transformed_data:1;
-   GLuint replay_copied_vertices:1;
-   GLuint new_state;		/* state changes since last recalc */
-   struct gl_pipeline_stage *stages[MAX_PIPELINE_STAGES];
-};
-
-
-struct gl_cva {
-   struct gl_pipeline pre;
-   struct gl_pipeline elt;
-
-   struct gl_client_array Elt;
-   trans_1ui_func EltFunc;
-
-   struct vertex_buffer *VB;
-   struct vertex_arrays v;
-   struct vertex_data store;
-
-   GLuint elt_count;
-   GLenum elt_mode;
-   GLuint elt_size;
-
-   GLuint forbidden_inputs;
-   GLuint orflag;
-   GLuint merge;
-
-   GLuint lock_changed;
-   GLuint last_orflag;
-   GLuint last_array_flags;
-   GLuint last_array_new_state;
-};
-
-
-struct gl_feedback {
-   GLenum Type;
-   GLuint Mask;
-   GLfloat *Buffer;
-   GLuint BufferSize;
-   GLuint Count;
-};
-
-
-
-struct gl_selection {
-   GLuint *Buffer;
-   GLuint BufferSize;	/* size of SelectBuffer */
-   GLuint BufferCount;	/* number of values in SelectBuffer */
-   GLuint Hits;		/* number of records in SelectBuffer */
-   GLuint NameStackDepth;
-   GLuint NameStack[MAX_NAME_STACK_DEPTH];
-   GLboolean HitFlag;
-   GLfloat HitMinZ, HitMaxZ;
-};
-
-
-
-/*
- * 1-D Evaluator control points
- */
-struct gl_1d_map {
-   GLuint Order;	/* Number of control points */
-   GLfloat u1, u2, du;	/* u1, u2, 1.0/(u2-u1) */
-   GLfloat *Points;	/* Points to contiguous control points */
-};
-
-
-/*
- * 2-D Evaluator control points
- */
-struct gl_2d_map {
-   GLuint Uorder;		/* Number of control points in U dimension */
-   GLuint Vorder;		/* Number of control points in V dimension */
-   GLfloat u1, u2, du;
-   GLfloat v1, v2, dv;
-   GLfloat *Points;		/* Points to contiguous control points */
-};
-
-
-/*
- * All evalutator control points
- */
-struct gl_evaluators {
-   /* 1-D maps */
-   struct gl_1d_map Map1Vertex3;
-   struct gl_1d_map Map1Vertex4;
-   struct gl_1d_map Map1Index;
-   struct gl_1d_map Map1Color4;
-   struct gl_1d_map Map1Normal;
-   struct gl_1d_map Map1Texture1;
-   struct gl_1d_map Map1Texture2;
-   struct gl_1d_map Map1Texture3;
-   struct gl_1d_map Map1Texture4;
-
-   /* 2-D maps */
-   struct gl_2d_map Map2Vertex3;
-   struct gl_2d_map Map2Vertex4;
-   struct gl_2d_map Map2Index;
-   struct gl_2d_map Map2Color4;
-   struct gl_2d_map Map2Normal;
-   struct gl_2d_map Map2Texture1;
-   struct gl_2d_map Map2Texture2;
-   struct gl_2d_map Map2Texture3;
-   struct gl_2d_map Map2Texture4;
-};
-
-
-
-/*
- * State which can be shared by multiple contexts:
- */
-struct gl_shared_state {
-   _glthread_Mutex Mutex;		   /* for thread safety */
-   GLint RefCount;			   /* Reference count */
-   struct _mesa_HashTable *DisplayList;	   /* Display lists hash table */
-   struct _mesa_HashTable *TexObjects;	   /* Texture objects hash table */
-#ifdef VAO
-   struct _mesa_HashTable *ArrayObjects;   /* GL_EXT_vertex_array_set */
-#endif
-   struct gl_texture_object *TexObjectList;/* Linked list of texture objects */
-   struct gl_texture_object *DirtyTexObjList; /* List of dirty tex objects */
-
-   /* Default texture objects (shared by all multi-texture units) */
-   struct gl_texture_object *DefaultD[4];
-   struct gl_texture_object *DefaultCubeMap;
-
-   void *DriverData;  /* Device driver shared state */
-};
-
-
-
-/*
- * Describes the color, depth, stencil and accum buffer parameters.
- * In C++ terms, think of this as a base class from which device drivers
- * will make derived classes.
- */
-struct gl_visual {
-   GLboolean RGBAflag;		/* Is frame buffer in RGBA mode, not CI? */
-   GLboolean DBflag;		/* Is color buffer double buffered? */
-   GLboolean StereoFlag;	/* stereo buffer? */
-
-   GLint RedBits;		/* Bits per color component */
-   GLint GreenBits;
-   GLint BlueBits;
-   GLint AlphaBits;
-
-   GLint IndexBits;		/* Bits/pixel if in color index mode */
-
-   GLint AccumRedBits;		/* Number of bits in red accum channel */
-   GLint AccumGreenBits;	/* Number of bits in green accum channel */
-   GLint AccumBlueBits;		/* Number of bits in blue accum channel */
-   GLint AccumAlphaBits;	/* Number of bits in alpha accum channel */
-   GLint DepthBits;		/* Number of bits in depth buffer, or 0 */
-   GLint StencilBits;		/* Number of bits in stencil buffer, or 0 */
-   GLint NumSamples;            /* Samples/pixel for multisampling */
-
-   GLuint DepthMax;		/* Max depth buffer value */
-   GLfloat DepthMaxF;		/* Float max depth buffer value */
-};
-
-
-
-/*
- * A "frame buffer" is a color buffer and its optional ancillary buffers:
- * depth, accum, stencil, and software-simulated alpha buffers.
- * In C++ terms, think of this as a base class from which device drivers
- * will make derived classes.
- */
-struct gl_frame_buffer {
-   GLvisual *Visual;		/* The corresponding visual */
-
-   GLint Width, Height;		/* size of frame buffer in pixels */
-
-   GLboolean UseSoftwareDepthBuffer;
-   GLboolean UseSoftwareAccumBuffer;
-   GLboolean UseSoftwareStencilBuffer;
-   GLboolean UseSoftwareAlphaBuffers;
-
-   /* Software depth (aka Z) buffer */
-   GLvoid *DepthBuffer;		/* array [Width*Height] of GLushort or GLuint*/
-
-   /* Software stencil buffer */
-   GLstencil *Stencil;		/* array [Width*Height] of GLstencil values */
-
-   /* Software accumulation buffer */
-   GLaccum *Accum;		/* array [4*Width*Height] of GLaccum values */
-
-   /* Software alpha planes */
-   GLubyte *FrontLeftAlpha;	/* array [Width*Height] of GLubyte */
-   GLubyte *BackLeftAlpha;	/* array [Width*Height] of GLubyte */
-   GLubyte *FrontRightAlpha;	/* array [Width*Height] of GLubyte */
-   GLubyte *BackRightAlpha;	/* array [Width*Height] of GLubyte */
-   GLubyte *Alpha;		/* Points to current alpha buffer */
-
-   /* Drawing bounds: intersection of window size and scissor box */
-   GLint Xmin, Xmax, Ymin, Ymax;  /* [Xmin,Xmax] X [Ymin,Ymax] */
-};
-
-
-/*
- * Constants which may be overriden by device driver.
- */
-struct gl_constants {
-   GLint MaxTextureSize;
-   GLint MaxCubeTextureSize;
-   GLint MaxTextureLevels;
-   GLuint MaxTextureUnits;
-   GLuint MaxArrayLockSize;
-   GLint SubPixelBits;
-   GLfloat MinPointSize, MaxPointSize;		/* aliased */
-   GLfloat MinPointSizeAA, MaxPointSizeAA;	/* antialiased */
-   GLfloat PointSizeGranularity;
-   GLfloat MinLineWidth, MaxLineWidth;		/* aliased */
-   GLfloat MinLineWidthAA, MaxLineWidthAA;	/* antialiased */
-   GLfloat LineWidthGranularity;
-   GLuint NumAuxBuffers;
-   GLuint MaxColorTableSize;
-   GLuint MaxConvolutionWidth;
-   GLuint MaxConvolutionHeight;
-   GLuint NumCompressedTextureFormats;	/* GL_ARB_texture_compression */
-   GLenum CompressedTextureFormats[MAX_COMPRESSED_TEXTURE_FORMATS];
-};
-
-
-/*
- * List of extensions.
- */
-struct extension;
-struct gl_extensions {
-   char *ext_string;
-   struct extension *ext_list;
-   /* flags to quickly test if certain extensions are available */
-   GLboolean HaveTextureEnvAdd;
-   GLboolean HaveTextureEnvCombine;
-   GLboolean HaveTextureEnvDot3;
-   GLboolean HaveTextureLodBias;
-   GLboolean HaveHpOcclusionTest;
-   GLboolean HaveTextureCubeMap;
-   GLboolean HaveTextureCompression;
-   GLboolean HaveTextureCompressionS3TC;
-   GLboolean HaveTextureCompressionFXT1;
-   GLboolean HaveBlendSquare;
-};
-
-
-/*
- * Bitmasks to indicate which rasterization options are enabled (RasterMask)
- */
-#define ALPHATEST_BIT		0x001	/* Alpha-test pixels */
-#define BLEND_BIT		0x002	/* Blend pixels */
-#define DEPTH_BIT		0x004	/* Depth-test pixels */
-#define FOG_BIT			0x008	/* Per-pixel fog */
-#define LOGIC_OP_BIT		0x010	/* Apply logic op in software */
-#define SCISSOR_BIT		0x020	/* Scissor pixels */
-#define STENCIL_BIT		0x040	/* Stencil pixels */
-#define MASKING_BIT		0x080	/* Do glColorMask or glIndexMask */
-#define ALPHABUF_BIT		0x100	/* Using software alpha buffer */
-#define WINCLIP_BIT		0x200	/* Clip pixels/primitives to window */
-#define MULTI_DRAW_BIT		0x400	/* Write to more than one color- */
-                                        /* buffer or no buffers. */
-#define OCCLUSION_BIT           0x800   /* GL_HP_occlusion_test enabled */
-#define TEXTURE_BIT		0x1000	/* Texturing really enabled */
-
-
-/*
- * Bits to indicate what state has to be updated (NewState)
- */
-#define NEW_LIGHTING	        0x1
-#define NEW_RASTER_OPS	        0x2
-#define NEW_TEXTURING	        0x4
-#define NEW_POLYGON	        0x8
-#define NEW_DRVSTATE0	        0x10 /* Reserved for drivers */
-#define NEW_DRVSTATE1	        0x20 /* Reserved for drivers */
-#define NEW_DRVSTATE2	        0x40 /* Reserved for drivers */
-#define NEW_DRVSTATE3	        0x80 /* Reserved for drivers */
-#define NEW_MODELVIEW	        0x100
-#define NEW_PROJECTION	        0x200
-#define NEW_TEXTURE_MATRIX	0x400
-#define NEW_USER_CLIP	        0x800
-#define NEW_TEXTURE_ENV         0x1000
-#define NEW_CLIENT_STATE        0x2000
-#define NEW_FOG                 0x4000
-#define NEW_NORMAL_TRANSFORM    0x8000
-#define NEW_VIEWPORT            0x10000
-#define NEW_TEXTURE_ENABLE      0x20000
-#define NEW_COLOR_MATRIX        0x40000
-#define NEW_ALL		        ~0
-
-
-#define NEW_DRIVER_STATE (NEW_DRVSTATE0 | NEW_DRVSTATE1 |	\
-                          NEW_DRVSTATE2 | NEW_DRVSTATE3)
-
-/* What can the driver do, what requires us to call render_triangle or
- * a non-driver rasterize function?
- */
-#define DD_FEEDBACK                 0x1
-#define DD_SELECT                   0x2
-#define DD_FLATSHADE                0x4
-#define DD_MULTIDRAW                0x8
-#define DD_SEPERATE_SPECULAR        0x10
-#define DD_TRI_LIGHT_TWOSIDE        0x20
-#define DD_TRI_UNFILLED             0x40
-#define DD_TRI_SMOOTH               0x80
-#define DD_TRI_STIPPLE              0x100
-#define DD_TRI_OFFSET               0x200
-#define DD_TRI_CULL                 0x400
-#define DD_LINE_SMOOTH              0x800
-#define DD_LINE_STIPPLE             0x1000
-#define DD_LINE_WIDTH               0x2000
-#define DD_POINT_SMOOTH             0x4000
-#define DD_POINT_SIZE               0x8000
-#define DD_POINT_ATTEN              0x10000
-#define DD_LIGHTING_CULL            0x20000 /* never set by driver */
-#define DD_POINT_SW_RASTERIZE       0x40000
-#define DD_LINE_SW_RASTERIZE        0x80000
-#define DD_TRI_SW_RASTERIZE         0x100000
-#define DD_QUAD_SW_RASTERIZE        0x200000
-#define DD_TRI_CULL_FRONT_BACK      0x400000 /* not supported by most drivers */
-#define DD_Z_NEVER                  0x800000
-#define DD_STENCIL                  0x1000000
-#define DD_CLIP_FOG_COORD           0x2000000
-
-
-
-#define DD_SW_SETUP           (DD_TRI_CULL|		\
-                               DD_TRI_CULL_FRONT_BACK|	\
-                               DD_TRI_OFFSET|		\
-			       DD_TRI_LIGHT_TWOSIDE|	\
-                               DD_TRI_UNFILLED)
-
-#define DD_ANY_CULL           (DD_TRI_CULL_FRONT_BACK|	\
-                               DD_TRI_CULL|		\
-                               DD_LIGHTING_CULL)
-
-#define DD_SW_RASTERIZE       (DD_POINT_SW_RASTERIZE|	\
-                               DD_LINE_SW_RASTERIZE|	\
-                               DD_TRI_SW_RASTERIZE|	\
-                               DD_QUAD_SW_RASTERIZE)
-
-
-/* Vertex buffer clipping flags
- */
-#define CLIP_RIGHT_SHIFT 	0
-#define CLIP_LEFT_SHIFT 	1
-#define CLIP_TOP_SHIFT  	2
-#define CLIP_BOTTOM_SHIFT       3
-#define CLIP_NEAR_SHIFT  	4
-#define CLIP_FAR_SHIFT  	5
-
-#define CLIP_RIGHT_BIT   0x01
-#define CLIP_LEFT_BIT    0x02
-#define CLIP_TOP_BIT     0x04
-#define CLIP_BOTTOM_BIT  0x08
-#define CLIP_NEAR_BIT    0x10
-#define CLIP_FAR_BIT     0x20
-#define CLIP_USER_BIT    0x40
-#define CLIP_CULLED_BIT  0x80	/* Vertex has been culled */
-#define CLIP_ALL_BITS    0x3f
-
-
-/*
- * Bits to indicate which faces a vertex participates in,
- * what facing the primitive provoked by that vertex has,
- * and some misc. flags.
- */
-#define VERT_FACE_FRONT       0x1	/* is in a front-color primitive */
-#define VERT_FACE_REAR        0x2	/* is in a rear-color primitive */
-#define PRIM_FACE_FRONT       0x4	/* use front color */
-#define PRIM_FACE_REAR        0x8	/* use rear color */
-#define PRIM_CLIPPED          0x10	/* needs clipping */
-#define PRIM_USER_CLIPPED     CLIP_USER_BIT	/* 0x40 */
-
-
-#define PRIM_FLAG_SHIFT  2
-#define PRIM_FACE_FLAGS  (PRIM_FACE_FRONT|PRIM_FACE_REAR)
-#define VERT_FACE_FLAGS  (VERT_FACE_FRONT|VERT_FACE_REAR)
-
-#define PRIM_ANY_CLIP    (PRIM_CLIPPED|PRIM_USER_CLIPPED)
-#define PRIM_NOT_CULLED  (PRIM_ANY_CLIP|PRIM_FACE_FLAGS)
-
-/* Flags for ctx->VB->CullMode.
- */
-#define CULL_MASK_ACTIVE  0x1
-#define COMPACTED_NORMALS 0x2
-#define CLIP_MASK_ACTIVE  0x4
-
-/* Flags for selecting a shading function.  The first two bits are
- * shared with the cull mode (ie. cull_mask_active and
- * compacted_normals.)
- */
-#define SHADE_TWOSIDE           0x4
-
-/* Flags for selecting a normal transformation function.
- */
-#define NORM_RESCALE   0x1	/* apply the scale factor */
-#define NORM_NORMALIZE 0x2	/* normalize */
-#define NORM_TRANSFORM 0x4	/* apply the transformation matrix */
-#define NORM_TRANSFORM_NO_ROT 0x8	/* apply the transformation matrix */
-
-
-/*
- * Different kinds of 4x4 transformation matrices:
- */
-#define MATRIX_GENERAL		0	/* general 4x4 matrix */
-#define MATRIX_IDENTITY		1	/* identity matrix */
-#define MATRIX_3D_NO_ROT	2	/* ortho projection and others... */
-#define MATRIX_PERSPECTIVE	3	/* perspective projection matrix */
-#define MATRIX_2D		4	/* 2-D transformation */
-#define MATRIX_2D_NO_ROT	5	/* 2-D scale & translate only */
-#define MATRIX_3D		6	/* 3-D transformation */
-
-#define MAT_FLAG_IDENTITY        0
-#define MAT_FLAG_GENERAL        0x1
-#define MAT_FLAG_ROTATION       0x2
-#define MAT_FLAG_TRANSLATION    0x4
-#define MAT_FLAG_UNIFORM_SCALE  0x8
-#define MAT_FLAG_GENERAL_SCALE  0x10
-#define MAT_FLAG_GENERAL_3D     0x20
-#define MAT_FLAG_PERSPECTIVE    0x40
-#define MAT_DIRTY_TYPE          0x80
-#define MAT_DIRTY_FLAGS         0x100
-#define MAT_DIRTY_INVERSE       0x200
-#define MAT_DIRTY_DEPENDENTS    0x400
-
-
-/* Give symbolic names to some of the entries in the matrix to help
- * out with the rework of the viewport_map as a matrix transform.
- */
-#define MAT_SX 0
-#define MAT_SY 5
-#define MAT_SZ 10
-#define MAT_TX 12
-#define MAT_TY 13
-#define MAT_TZ 14
-
-
-#define MAT_FLAGS_ANGLE_PRESERVING (MAT_FLAG_ROTATION | \
-				    MAT_FLAG_TRANSLATION | \
-				    MAT_FLAG_UNIFORM_SCALE)
-
-#define MAT_FLAGS_LENGTH_PRESERVING (MAT_FLAG_ROTATION | \
-				     MAT_FLAG_TRANSLATION)
-
-#define MAT_FLAGS_3D (MAT_FLAG_ROTATION | \
-		      MAT_FLAG_TRANSLATION | \
-		      MAT_FLAG_UNIFORM_SCALE | \
-		      MAT_FLAG_GENERAL_SCALE | \
-		      MAT_FLAG_GENERAL_3D)
-
-#define MAT_FLAGS_GEOMETRY (MAT_FLAG_GENERAL | \
-			    MAT_FLAG_ROTATION | \
-			    MAT_FLAG_TRANSLATION | \
-			    MAT_FLAG_UNIFORM_SCALE | \
-			    MAT_FLAG_GENERAL_SCALE | \
-			    MAT_FLAG_GENERAL_3D | \
-			    MAT_FLAG_PERSPECTIVE)
-
-#define MAT_DIRTY_ALL_OVER (MAT_DIRTY_TYPE | \
-			    MAT_DIRTY_DEPENDENTS | \
-			    MAT_DIRTY_FLAGS | \
-			    MAT_DIRTY_INVERSE)
-
-#define TEST_MAT_FLAGS(mat, a)  ((MAT_FLAGS_GEOMETRY&(~(a))&((mat)->flags))==0)
-
-
-/*
- * FogMode values:
- */
-#define FOG_NONE	0	/* no fog */
-#define FOG_VERTEX	1	/* apply per vertex */
-#define FOG_FRAGMENT	2	/* apply per fragment */
-
-
-
-typedef void (*gl_shade_func)( struct vertex_buffer *VB );
-
-
-
-/*
- * Forward declaration of display list datatypes:
- */
-union node;
-typedef union node Node;
-
-
-
-
-/* KW: Flags that describe the current vertex state, and the contents
- * of a vertex in a vertex-cassette.
- *
- * For really major expansion, consider a 'VERT_ADDITIONAL_FLAGS' flag,
- * which means there is data in another flags array (eg, extra_flags[]).
- */
-
-#define VERT_OBJ_2           0x1	/* glVertex2 */
-#define VERT_OBJ_3           0x2        /* glVertex3 */
-#define VERT_OBJ_4           0x4        /* glVertex4 */
-#define VERT_BEGIN           0x8	/* glBegin */
-#define VERT_END             0x10	/* glEnd */
-#define VERT_ELT             0x20	/* glArrayElement */
-#define VERT_RGBA            0x40	/* glColor */
-#define VERT_NORM            0x80	/* glNormal */
-#define VERT_INDEX           0x100	/* glIndex */
-#define VERT_EDGE            0x200	/* glEdgeFlag */
-#define VERT_MATERIAL        0x400	/* glMaterial */
-#define VERT_TEX0_1          0x800
-#define VERT_TEX0_2          0x1000
-#define VERT_TEX0_3          0x2000
-#define VERT_TEX0_4          0x4000
-#define VERT_TEX1_1          0x8000
-#define VERT_TEX1_2          0x10000
-#define VERT_TEX1_3          0x20000
-#define VERT_TEX1_4          0x40000
-#define VERT_TEX2_1          0x80000    /* 3rd texunit - reserved but unused */
-#define VERT_TEX2_2          0x100000
-#define VERT_TEX2_3          0x200000
-#define VERT_TEX2_4          0x400000
-#define VERT_END_VB          0x800000   /* end vb marker */
-#define VERT_EVAL_C1         0x1000000  /* could reuse OBJ bits for this? */
-#define VERT_EVAL_C2         0x2000000  /*    - or just use 3 bits */
-#define VERT_EVAL_P1         0x4000000  /*  */
-#define VERT_EVAL_P2         0x8000000  /*  */
-#define VERT_SPEC_RGB        0x10000000
-#define VERT_FOG_COORD       0x20000000	/* internal use only, currently */
-
-#define VERT_EYE             VERT_BEGIN /* for pipeline management & cva */
-#define VERT_WIN             VERT_END   /* some overlaps can be tolerated */
-#define VERT_SETUP_FULL      0x4000000
-#define VERT_SETUP_PART      0x8000000
-#define VERT_PRECALC_DATA    VERT_END_VB /* overlap! */
-
-/* Shorthands.
- */
-#define VERT_TEX0_SHIFT 11
-
-#define VERT_EVAL_ANY      (VERT_EVAL_C1|VERT_EVAL_P1|	\
-                            VERT_EVAL_C2|VERT_EVAL_P2)
-
-#define VERT_OBJ_23       (VERT_OBJ_3|VERT_OBJ_2)
-#define VERT_OBJ_234      (VERT_OBJ_4|VERT_OBJ_23)
-#define VERT_OBJ_ANY      VERT_OBJ_2
-
-#define VERT_TEX0_12      (VERT_TEX0_2|VERT_TEX0_1)
-#define VERT_TEX0_123     (VERT_TEX0_3|VERT_TEX0_12)
-#define VERT_TEX0_1234    (VERT_TEX0_4|VERT_TEX0_123)
-#define VERT_TEX0_ANY     VERT_TEX0_1
-
-#define VERT_TEX1_12      (VERT_TEX1_2|VERT_TEX1_1)
-#define VERT_TEX1_123     (VERT_TEX1_3|VERT_TEX1_12)
-#define VERT_TEX1_1234    (VERT_TEX1_4|VERT_TEX1_123)
-#define VERT_TEX1_ANY     VERT_TEX1_1
-
-/* not used */
-#define VERT_TEX2_12      (VERT_TEX2_2|VERT_TEX2_1)
-#define VERT_TEX2_123     (VERT_TEX2_3|VERT_TEX2_12)
-#define VERT_TEX2_1234    (VERT_TEX2_4|VERT_TEX2_123)
-#define VERT_TEX2_ANY     VERT_TEX2_1
-
-/* not used
-#define VERT_TEX3_12      (VERT_TEX3_2|VERT_TEX3_1)
-#define VERT_TEX3_123     (VERT_TEX3_3|VERT_TEX3_12)
-#define VERT_TEX3_1234    (VERT_TEX3_4|VERT_TEX3_123)
-#define VERT_TEX3_ANY     VERT_TEX3_1
-*/
-
-#define NR_TEXSIZE_BITS   4
-#define VERT_TEX_ANY(i)   (VERT_TEX0_ANY<<(i*NR_TEXSIZE_BITS))
-
-#define VERT_FIXUP         (VERT_TEX0_ANY|VERT_TEX1_ANY|VERT_RGBA| \
-			    VERT_INDEX|VERT_EDGE|VERT_NORM)
-
-#define VERT_DATA          (VERT_TEX0_ANY|VERT_TEX1_ANY|VERT_RGBA| \
-			    VERT_INDEX|VERT_EDGE|VERT_NORM| \
-	                    VERT_OBJ_ANY|VERT_MATERIAL|VERT_ELT| \
-	                    VERT_EVAL_ANY|VERT_FOG_COORD)
-
-
-#define VERT_TO_PIPE      (~VERT_END_VB)
-#define VERT_FLAGS_TO_PIPE_FLAGS(x) (x & VERT_TO_PIPE)
-#define PIPE_FLAGS_TO_VERT_FLAGS(x) (x & VERT_TO_PIPE)
-#define PIPE_TEX(i)       VERT_TEX_ANY(i)
-
-
-
-/* For beginstate
- */
-#define VERT_BEGIN_0    0x1	   /* glBegin (if initially inside beg/end) */
-#define VERT_BEGIN_1    0x2	   /* glBegin (if initially outside beg/end) */
-#define VERT_ERROR_0    0x4	   /* invalid_operation in initial state 0 */
-#define VERT_ERROR_1    0x8        /* invalid_operation in initial state 1 */
-
-
-
-
-typedef void (*vb_transform_func)( GLcontext *ctx );
-
-
-typedef GLuint (*clip_line_func)( struct vertex_buffer *VB,
-				  GLuint *i, GLuint *j,
-				  GLubyte mask);
-typedef GLuint (*clip_poly_func)( struct vertex_buffer *VB,
-				  GLuint n, GLuint vlist[],
-				  GLubyte mask );
-
-/*
- * The library context:
- */
-
-struct gl_context {
-   /* State possibly shared with other contexts in the address space */
-   struct gl_shared_state *Shared;
-
-   /* API function pointer tables */
-   struct _glapi_table *Save;	/* Display list save funcs */
-   struct _glapi_table *Exec;	/* Execute funcs */
-   struct _glapi_table *CurrentDispatch;  /* == Save or Exec !! */
-
-   GLvisual *Visual;
-   GLframebuffer *DrawBuffer;	/* buffer for writing */
-   GLframebuffer *ReadBuffer;	/* buffer for reading */
-
-   /* Driver function pointer table */
-   struct dd_function_table Driver;
-
-   triangle_func TriangleFunc; /* driver or indirect triangle func */
-   quad_func     QuadFunc;
-   triangle_func ClippedTriangleFunc;
-   clip_poly_func *poly_clip_tab;
-   clip_line_func *line_clip_tab;
-
-   void *DriverCtx;	/* Points to device driver context/state */
-   void *DriverMgrCtx;	/* Points to device driver manager (optional)*/
-
-   /* Core/Driver constants */
-   struct gl_constants Const;
-
-   /* Modelview matrix and stack */
-   GLmatrix ModelView;           /* current matrix, not stored on stack */
-   GLuint ModelViewStackDepth;
-   GLmatrix ModelViewStack[MAX_MODELVIEW_STACK_DEPTH - 1];
-
-   /* Projection matrix and stack */
-   GLmatrix ProjectionMatrix;    /* current matrix, not stored on stack */
-   GLuint ProjectionStackDepth;
-   GLmatrix ProjectionStack[MAX_PROJECTION_STACK_DEPTH - 1];
-   GLfloat NearFarStack[MAX_PROJECTION_STACK_DEPTH][2];
-
-   /* Combined modelview and projection matrix */
-   GLmatrix ModelProjectMatrix;
-
-   /* Combined modelview, projection and window matrix */
-   GLmatrix ModelProjectWinMatrix;
-   GLboolean ModelProjectWinMatrixUptodate;
-
-   /* Texture matrix and stack */
-   GLmatrix TextureMatrix[MAX_TEXTURE_UNITS];
-   GLuint TextureStackDepth[MAX_TEXTURE_UNITS];
-   GLmatrix TextureStack[MAX_TEXTURE_UNITS][MAX_TEXTURE_STACK_DEPTH - 1];
-
-   /* Color matrix and stack */
-   GLmatrix ColorMatrix;
-   GLuint ColorStackDepth;
-   GLmatrix ColorStack[MAX_COLOR_STACK_DEPTH - 1];
-
-   /* Display lists */
-   GLuint CallDepth;		/* Current recursion calling depth */
-   GLboolean ExecuteFlag;	/* Execute GL commands? */
-   GLboolean CompileFlag;	/* Compile GL commands into display list? */
-   GLboolean CompileCVAFlag;
-   Node *CurrentListPtr;	/* Head of list being compiled */
-   GLuint CurrentListNum;	/* Number of the list being compiled */
-   Node *CurrentBlock;		/* Pointer to current block of nodes */
-   GLuint CurrentPos;		/* Index into current block of nodes */
-
-   /* Extensions */
-   struct gl_extensions Extensions;
-
-
-   /* Pipeline stages - shared between the two pipelines,
-    * which live in CVA.
-    */
-   struct gl_pipeline_stage PipelineStage[MAX_PIPELINE_STAGES];
-   GLuint NrPipelineStages;
-
-   /* Cva */
-   struct gl_cva CVA;
-
-   /* Renderer attribute stack */
-   GLuint AttribStackDepth;
-   struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];
-
-   /* Renderer attribute groups */
-   struct gl_accum_attrib	Accum;
-   struct gl_colorbuffer_attrib	Color;
-   struct gl_current_attrib	Current;
-   struct gl_depthbuffer_attrib	Depth;
-   struct gl_eval_attrib	Eval;
-   struct gl_fog_attrib		Fog;
-   struct gl_hint_attrib	Hint;
-   struct gl_light_attrib	Light;
-   struct gl_line_attrib	Line;
-   struct gl_list_attrib	List;
-   struct gl_pixel_attrib	Pixel;
-   struct gl_point_attrib	Point;
-   struct gl_polygon_attrib	Polygon;
-   GLuint PolygonStipple[32];
-   struct gl_scissor_attrib	Scissor;
-   struct gl_stencil_attrib	Stencil;
-   struct gl_texture_attrib	Texture;
-   struct gl_transform_attrib	Transform;
-   struct gl_viewport_attrib	Viewport;
-
-   /* Other attribute groups */
-   struct gl_histogram_attrib	Histogram;
-   struct gl_minmax_attrib	MinMax;
-   struct gl_convolution_attrib Convolution1D;
-   struct gl_convolution_attrib Convolution2D;
-   struct gl_convolution_attrib Separable2D;
-
-   /* Client attribute stack */
-   GLuint ClientAttribStackDepth;
-   struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];
-
-   /* Client attribute groups */
-   struct gl_array_attrib	Array;	/* Vertex arrays */
-   struct gl_pixelstore_attrib	Pack;	/* Pixel packing */
-   struct gl_pixelstore_attrib	Unpack;	/* Pixel unpacking */
-
-   struct gl_evaluators EvalMap;   /* All evaluators */
-   struct gl_feedback   Feedback;  /* Feedback */
-   struct gl_selection  Select;    /* Selection */
-
-   struct gl_color_table ColorTable;       /* Pre-convolution */
-   struct gl_color_table ProxyColorTable;  /* Pre-convolution */
-   struct gl_color_table PostConvolutionColorTable;
-   struct gl_color_table ProxyPostConvolutionColorTable;
-   struct gl_color_table PostColorMatrixColorTable;
-   struct gl_color_table ProxyPostColorMatrixColorTable;
-
-   /* Optimized Accumulation buffer info */
-   GLboolean IntegerAccumMode;	/* Storing unscaled integers? */
-   GLfloat IntegerAccumScaler;	/* Implicit scale factor */
-
-   struct gl_fallback_arrays Fallback;
-
-   GLenum ErrorValue;        /* Last error code */
-
-   /* Miscellaneous */
-   GLuint NewState;          /* bitwise OR of NEW_* flags */
-   GLuint Enabled;           /* bitwise or of ENABLE_* flags */
-   GLenum RenderMode;        /* either GL_RENDER, GL_SELECT, GL_FEEDBACK */
-   GLuint StippleCounter;    /* Line stipple counter */
-   GLuint RasterMask;        /* OR of rasterization flags */
-   GLuint TriangleCaps;      /* OR of DD_* flags */
-   GLuint IndirectTriangles; /* TriangleCaps not handled by the driver */
-   GLfloat PolygonZoffset;   /* Z offset for GL_FILL polygons */
-   GLfloat LineZoffset;      /* Z offset for GL_LINE polygons */
-   GLfloat PointZoffset;     /* Z offset for GL_POINT polygons */
-   GLboolean NeedNormals;    /* Are vertex normal vectors needed? */
-   GLuint FogMode;           /* FOG_OFF, FOG_VERTEX or FOG_FRAGMENT */
-
-   GLboolean DoViewportMapping;
-
-   GLuint RenderFlags;	/* Active inputs to render stage */
-
-   GLuint RequireWriteableFlags; /* What can the driver/clipping tolerate? */
-
-   /* Points to function which interpolates colors, etc when clipping */
-   clip_interp_func ClipInterpFunc;
-   GLuint ClipTabMask;
-
-   normal_func *NormalTransform;
-
-   /* Current shading function table */
-   gl_shade_func *shade_func_tab;
-
-   GLfloat EyeZDir[3];
-   GLfloat rescale_factor;
-
-   GLfloat vb_rescale_factor;
-   GLmatrix *vb_proj_matrix;
-
-   GLubyte   AllowVertexCull; /* To be set by the geometry driver */
-   GLboolean NeedEyeCoords;
-   GLboolean NeedEyeNormals;
-   GLboolean NeedClipCoords;
-
-   GLfloat backface_sign;
-
-   GLboolean OcclusionResult;  /* GL_HP_occlusion_test */
-   GLboolean OcclusionResultSaved;  /* GL_HP_occlusion_test */
-
-   /* Destination of immediate mode commands */
-   struct immediate *input;
-
-
-   /* Cache of unused immediate structs
-    */
-   struct immediate *freed_im_queue;
-   GLuint nr_im_queued;
-
-   /* The vertex buffer being used by this context.
-    */
-   struct vertex_buffer *VB;
-
-   /* The pixel buffer being used by this context */
-   struct pixel_buffer* PB;
-
-   struct gl_shine_tab *ShineTable[4];  /* Active shine tables */
-   struct gl_shine_tab *ShineTabList;   /* Mru list of inactive shine tables */
-
-   /* Should 3Dfx Glide driver catch signals? */
-   GLboolean CatchSignals;
-
-   /* For debugging/development only */
-   GLboolean NoRaster;
-   GLboolean FirstTimeCurrent;
-
-   /* Dither disable via MESA_NO_DITHER env var */
-   GLboolean NoDither;
-
-#ifdef DEBUG
-   GLboolean Rendering;
-#endif
-};
-
-
-#ifdef MESA_DEBUG
-extern int MESA_VERBOSE;
-extern int MESA_DEBUG_FLAGS;
-#else
-# define MESA_VERBOSE 0
-# define MESA_DEBUG_FLAGS 0
-# ifndef NDEBUG
-#  define NDEBUG
-# endif
-#endif
-
-
-enum _verbose {
-	VERBOSE_VARRAY          = 0x1,
-	VERBOSE_TEXTURE         = 0x2,
-	VERBOSE_IMMEDIATE       = 0x4,
-	VERBOSE_PIPELINE        = 0x8,
-	VERBOSE_DRIVER          = 0x10,
-	VERBOSE_STATE           = 0x20,
-	VERBOSE_API             = 0x40,
-	VERBOSE_TRIANGLE_CHECKS = 0x80,
-	VERBOSE_CULL            = 0x100,
-	VERBOSE_DISPLAY_LIST    = 0x200,
-	VERBOSE_LIGHTING        = 0x400
-};
-
-
-enum _debug {
-	DEBUG_ALWAYS_FLUSH          = 0x1
-};
-
-
-extern void gl_flush_vb( GLcontext *ctx, const char *where );
-
-extern void RESET_IMMEDIATE( GLcontext *ctx );
-
-#define FLUSH_VB( ctx, where )			\
-do {						\
-	struct immediate *IM = ctx->input;	\
-	if (IM->Flag[IM->Start])		\
-		gl_flush_vb( ctx, where );	\
-} while (0)
-
-
-
-
-/* Test if we're inside a glBegin / glEnd pair:
-*/
-#define ASSERT_OUTSIDE_BEGIN_END( ctx, where )				\
-do {									\
-	struct immediate *IM = ctx->input;				\
-	GLuint flag = IM->Flag[IM->Count];				\
-	if ((flag & (VERT_BEGIN|VERT_END)) != VERT_END) {		\
-                FLUSH_VB(ctx, where);					\
-		if (ctx->Current.Primitive != GL_POLYGON+1) {		\
-			gl_error( ctx, GL_INVALID_OPERATION, where );	\
-			return;						\
-		}							\
-	}								\
-} while (0)
-
-#define ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL( ctx, where, what )	\
-do {									\
-	struct immediate *IM = ctx->input;				\
-	GLuint flag = IM->Flag[IM->Count];				\
-	if ((flag & (VERT_BEGIN|VERT_END)) != VERT_END) {		\
-                FLUSH_VB(ctx, where);					\
-		if (ctx->Current.Primitive != GL_POLYGON+1) {		\
-			gl_error( ctx, GL_INVALID_OPERATION, where );	\
-			return what;					\
-		}							\
-	}								\
-} while (0)
-
-
-#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, where )	\
-do {								\
-	FLUSH_VB( ctx, where );					\
-	if (ctx->Current.Primitive != GL_POLYGON+1) {		\
-		gl_error( ctx, GL_INVALID_OPERATION, where );	\
-		return;						\
-	}							\
-} while (0)
-
-
-#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL( ctx, where, what )  \
-do {								\
-	FLUSH_VB( ctx, where );		                    	\
-	if (ctx->Current.Primitive != GL_POLYGON+1) {		\
-		gl_error( ctx, GL_INVALID_OPERATION, where );	\
-		return what;					\
-	}							\
-} while (0)
-
-#if 0
-#undef ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL
-#define ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL
-
-#undef ASSERT_OUTSIDE_BEGIN_END
-#define ASSERT_OUTSIDE_BEGIN_END ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH
-#endif
-
-
-#define Elements(x) sizeof(x)/sizeof(*(x))
-
-
-#ifdef DEBUG
-
-#define RENDER_START(CTX)			\
-   do {						\
-      assert(!(CTX)->Rendering);		\
-      (CTX)->Rendering = GL_TRUE;		\
-      if ((CTX)->Driver.RenderStart) {		\
-         (*(CTX)->Driver.RenderStart)(CTX);	\
-      }						\
-   } while (0)
-
-#define RENDER_FINISH(CTX)			\
-   do {						\
-      assert((CTX)->Rendering);			\
-      (CTX)->Rendering = GL_FALSE;		\
-      if ((CTX)->Driver.RenderFinish) {		\
-         (*(CTX)->Driver.RenderFinish)(CTX);	\
-      }						\
-   } while (0)
-
-#else
-
-#define RENDER_START(CTX)			\
-   do {						\
-      if ((CTX)->Driver.RenderStart) {		\
-         (*(CTX)->Driver.RenderStart)(CTX);	\
-      }						\
-   } while (0)
-
-#define RENDER_FINISH(CTX)			\
-   do {						\
-      if ((CTX)->Driver.RenderFinish) {		\
-         (*(CTX)->Driver.RenderFinish)(CTX);	\
-      }						\
-   } while (0)
-
-#endif
-
-
-#endif /* TYPES_H */
Index: xc/extras/Mesa/src/varray.c
diff -u xc/extras/Mesa/src/varray.c:1.9 xc/extras/Mesa/src/varray.c:1.11
--- xc/extras/Mesa/src/varray.c:1.9	Tue Dec  5 16:18:33 2000
+++ xc/extras/Mesa/src/varray.c	Mon Sep  9 17:29:39 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,27 +28,17 @@
 #else
 #include "glheader.h"
 #include "context.h"
-#include "cva.h"
-#include "dlist.h"
 #include "enable.h"
 #include "enums.h"
-#include "hash.h"
+#include "dlist.h"
 #include "light.h"
 #include "macros.h"
-#include "mem.h"
 #include "mmath.h"
-#include "pipeline.h"
 #include "state.h"
 #include "texstate.h"
-#include "translate.h"
-#include "types.h"
+#include "mtypes.h"
 #include "varray.h"
-#include "vb.h"
-#include "vbfill.h"
-#include "vbrender.h"
-#include "vbindirect.h"
-#include "vbxform.h"
-#include "xform.h"
+#include "math/m_translate.h"
 #endif
 
 
@@ -57,79 +47,51 @@
 _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
-   
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
    if (size<2 || size>4) {
-      gl_error( ctx, GL_INVALID_VALUE, "glVertexPointer(size)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexPointer(size)" );
       return;
    }
    if (stride<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glVertexPointer(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexPointer(stride)" );
       return;
    }
-   
+
    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
-      fprintf(stderr, "glVertexPointer( sz %d type %s stride %d )\n", size, 
-	      gl_lookup_enum_by_nr( type ),
+      fprintf(stderr, "glVertexPointer( sz %d type %s stride %d )\n", size,
+	      _mesa_lookup_enum_by_nr( type ),
 	      stride);
 
-#ifdef VAO
-   ctx->Array.Current->Vertex.StrideB = stride;
-#else
    ctx->Array.Vertex.StrideB = stride;
-#endif
    if (!stride) {
       switch (type) {
       case GL_SHORT:
-#ifdef VAO
-         ctx->Array.Current->Vertex.StrideB =  size*sizeof(GLshort);
-#else
          ctx->Array.Vertex.StrideB =  size*sizeof(GLshort);
-#endif
          break;
       case GL_INT:
-#ifdef VAO
-         ctx->Array.Current->Vertex.StrideB =  size*sizeof(GLint);
-#else
          ctx->Array.Vertex.StrideB =  size*sizeof(GLint);
-#endif
          break;
       case GL_FLOAT:
-#ifdef VAO
-         ctx->Array.Current->Vertex.StrideB =  size*sizeof(GLfloat);
-#else
          ctx->Array.Vertex.StrideB =  size*sizeof(GLfloat);
-#endif
          break;
       case GL_DOUBLE:
-#ifdef VAO
-         ctx->Array.Current->Vertex.StrideB =  size*sizeof(GLdouble);
-#else
          ctx->Array.Vertex.StrideB =  size*sizeof(GLdouble);
-#endif
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type)" );
          return;
       }
    }
-#ifdef VAO
-   ctx->Array.Current->Vertex.Size = size;
-   ctx->Array.Current->Vertex.Type = type;
-   ctx->Array.Current->Vertex.Stride = stride;
-   ctx->Array.Current->Vertex.Ptr = (void *) ptr;
-   ctx->Array.Current->VertexFunc = gl_trans_4f_tab[size][TYPE_IDX(type)];
-   ctx->Array.Current->VertexEltFunc = gl_trans_elt_4f_tab[size][TYPE_IDX(type)];
-   ctx->Array.NewArrayState |= VERT_OBJ_ANY;
-#else
    ctx->Array.Vertex.Size = size;
    ctx->Array.Vertex.Type = type;
    ctx->Array.Vertex.Stride = stride;
    ctx->Array.Vertex.Ptr = (void *) ptr;
-   ctx->Array.VertexFunc = gl_trans_4f_tab[size][TYPE_IDX(type)];
-   ctx->Array.VertexEltFunc = gl_trans_elt_4f_tab[size][TYPE_IDX(type)];
-   ctx->Array.NewArrayState |= VERT_OBJ_ANY;
-#endif
-   ctx->NewState |= NEW_CLIENT_STATE;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_VERTEX;
+
+   if (ctx->Driver.VertexPointer)
+      ctx->Driver.VertexPointer( ctx, size, type, stride, ptr );
 }
 
 
@@ -139,79 +101,49 @@
 _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
 {
    GET_CURRENT_CONTEXT(ctx);
-   
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
    if (stride<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glNormalPointer(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glNormalPointer(stride)" );
       return;
    }
 
    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
-      fprintf(stderr, "glNormalPointer( type %s stride %d )\n", 
-	      gl_lookup_enum_by_nr( type ),
+      fprintf(stderr, "glNormalPointer( type %s stride %d )\n",
+	      _mesa_lookup_enum_by_nr( type ),
 	      stride);
 
-#ifdef VAO
-   ctx->Array.Current->Normal.StrideB = stride;
-#else
    ctx->Array.Normal.StrideB = stride;
-#endif
    if (!stride) {
       switch (type) {
       case GL_BYTE:
-#ifdef VAO
-         ctx->Array.Current->Normal.StrideB =  3*sizeof(GLbyte);
-#else
          ctx->Array.Normal.StrideB =  3*sizeof(GLbyte);
-#endif
          break;
       case GL_SHORT:
-#ifdef VAO
-         ctx->Array.Current->Normal.StrideB =  3*sizeof(GLshort);
-#else
          ctx->Array.Normal.StrideB =  3*sizeof(GLshort);
-#endif
          break;
       case GL_INT:
-#ifdef VAO
-         ctx->Array.Current->Normal.StrideB =  3*sizeof(GLint);
-#else
          ctx->Array.Normal.StrideB =  3*sizeof(GLint);
-#endif
          break;
       case GL_FLOAT:
-#ifdef VAO
-         ctx->Array.Current->Normal.StrideB =  3*sizeof(GLfloat);
-#else
          ctx->Array.Normal.StrideB =  3*sizeof(GLfloat);
-#endif
          break;
       case GL_DOUBLE:
-#ifdef VAO
-         ctx->Array.Current->Normal.StrideB =  3*sizeof(GLdouble);
-#else
          ctx->Array.Normal.StrideB =  3*sizeof(GLdouble);
-#endif
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type)" );
          return;
       }
    }
-#ifdef VAO
-   ctx->Array.Current->Normal.Type = type;
-   ctx->Array.Current->Normal.Stride = stride;
-   ctx->Array.Current->Normal.Ptr = (void *) ptr;
-   ctx->Array.Current->NormalFunc = gl_trans_3f_tab[TYPE_IDX(type)];
-   ctx->Array.Current->NormalEltFunc = gl_trans_elt_3f_tab[TYPE_IDX(type)];
-#else
    ctx->Array.Normal.Type = type;
    ctx->Array.Normal.Stride = stride;
    ctx->Array.Normal.Ptr = (void *) ptr;
-   ctx->Array.NormalFunc = gl_trans_3f_tab[TYPE_IDX(type)];
-   ctx->Array.NormalEltFunc = gl_trans_elt_3f_tab[TYPE_IDX(type)];
-#endif
-   ctx->Array.NewArrayState |= VERT_NORM;
-   ctx->NewState |= NEW_CLIENT_STATE;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_NORMAL;
+
+   if (ctx->Driver.NormalPointer)
+      ctx->Driver.NormalPointer( ctx, type, stride, ptr );
 }
 
 
@@ -220,269 +152,268 @@
 _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (size<3 || size>4) {
-      gl_error( ctx, GL_INVALID_VALUE, "glColorPointer(size)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(size)" );
       return;
    }
    if (stride<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glColorPointer(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(stride)" );
       return;
    }
 
    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
-      fprintf(stderr, "glColorPointer( sz %d type %s stride %d )\n", size, 
-	  gl_lookup_enum_by_nr( type ),
+      fprintf(stderr, "glColorPointer( sz %d type %s stride %d )\n", size,
+	  _mesa_lookup_enum_by_nr( type ),
 	  stride);
 
-#ifdef VAO
-   ctx->Array.Current->Color.StrideB = stride;
-#else
    ctx->Array.Color.StrideB = stride;
-#endif
    if (!stride) {
       switch (type) {
       case GL_BYTE:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLbyte);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLbyte);
-#endif
          break;
       case GL_UNSIGNED_BYTE:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLubyte);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLubyte);
-#endif
          break;
       case GL_SHORT:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLshort);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLshort);
-#endif
          break;
       case GL_UNSIGNED_SHORT:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLushort);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLushort);
-#endif
          break;
       case GL_INT:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLint);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLint);
-#endif
          break;
       case GL_UNSIGNED_INT:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLuint);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLuint);
-#endif
          break;
       case GL_FLOAT:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLfloat);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLfloat);
-#endif
          break;
       case GL_DOUBLE:
-#ifdef VAO
-         ctx->Array.Current->Color.StrideB =  size*sizeof(GLdouble);
-#else
          ctx->Array.Color.StrideB =  size*sizeof(GLdouble);
-#endif
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glColorPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glColorPointer(type)" );
          return;
       }
    }
-#ifdef VAO
-   ctx->Array.Current->Color.Size = size;
-   ctx->Array.Current->Color.Type = type;
-   ctx->Array.Current->Color.Stride = stride;
-   ctx->Array.Current->Color.Ptr = (void *) ptr;
-   ctx->Array.Current->ColorFunc = gl_trans_4ub_tab[size][TYPE_IDX(type)];
-   ctx->Array.Current->ColorEltFunc = gl_trans_elt_4ub_tab[size][TYPE_IDX(type)];
-#else
    ctx->Array.Color.Size = size;
    ctx->Array.Color.Type = type;
    ctx->Array.Color.Stride = stride;
    ctx->Array.Color.Ptr = (void *) ptr;
-   ctx->Array.ColorFunc = gl_trans_4ub_tab[size][TYPE_IDX(type)];
-   ctx->Array.ColorEltFunc = gl_trans_elt_4ub_tab[size][TYPE_IDX(type)];
-#endif
-   ctx->Array.NewArrayState |= VERT_RGBA;
-   ctx->NewState |= NEW_CLIENT_STATE;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_COLOR;
+
+   if (ctx->Driver.ColorPointer)
+      ctx->Driver.ColorPointer( ctx, size, type, stride, ptr );
 }
 
 
 
 void
+_mesa_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (stride<0) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glFogCoordPointer(stride)" );
+      return;
+   }
+
+   ctx->Array.FogCoord.StrideB = stride;
+   if (!stride) {
+      switch (type) {
+      case GL_FLOAT:
+         ctx->Array.FogCoord.StrideB =  sizeof(GLfloat);
+         break;
+      case GL_DOUBLE:
+         ctx->Array.FogCoord.StrideB =  sizeof(GLdouble);
+         break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glFogCoordPointer(type)" );
+         return;
+      }
+   }
+   ctx->Array.FogCoord.Type = type;
+   ctx->Array.FogCoord.Stride = stride;
+   ctx->Array.FogCoord.Ptr = (void *) ptr;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_FOGCOORD;
+
+   if (ctx->Driver.FogCoordPointer)
+      ctx->Driver.FogCoordPointer( ctx, type, stride, ptr );
+}
+
+
+void
 _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
-   
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
    if (stride<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glIndexPointer(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glIndexPointer(stride)" );
       return;
    }
 
-#ifdef VAO
-   ctx->Array.Current->Index.StrideB = stride;
-#else
    ctx->Array.Index.StrideB = stride;
-#endif
    if (!stride) {
       switch (type) {
       case GL_UNSIGNED_BYTE:
-#ifdef VAO
-         ctx->Array.Current->Index.StrideB =  sizeof(GLubyte);
-#else
          ctx->Array.Index.StrideB =  sizeof(GLubyte);
-#endif
          break;
       case GL_SHORT:
-#ifdef VAO
-         ctx->Array.Current->Index.StrideB =  sizeof(GLshort);
-#else
          ctx->Array.Index.StrideB =  sizeof(GLshort);
-#endif
          break;
       case GL_INT:
-#ifdef VAO
-         ctx->Array.Current->Index.StrideB =  sizeof(GLint);
-#else
          ctx->Array.Index.StrideB =  sizeof(GLint);
-#endif
          break;
       case GL_FLOAT:
-#ifdef VAO
-         ctx->Array.Current->Index.StrideB =  sizeof(GLfloat);
-#else
          ctx->Array.Index.StrideB =  sizeof(GLfloat);
-#endif
          break;
       case GL_DOUBLE:
-#ifdef VAO
-         ctx->Array.Current->Index.StrideB =  sizeof(GLdouble);
-#else
          ctx->Array.Index.StrideB =  sizeof(GLdouble);
-#endif
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glIndexPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glIndexPointer(type)" );
          return;
       }
    }
-#ifdef VAO
-   ctx->Array.Current->Index.Type = type;
-   ctx->Array.Current->Index.Stride = stride;
-   ctx->Array.Current->Index.Ptr = (void *) ptr;
-   ctx->Array.Current->IndexFunc = gl_trans_1ui_tab[TYPE_IDX(type)];
-   ctx->Array.Current->IndexEltFunc = gl_trans_elt_1ui_tab[TYPE_IDX(type)];
-#else
    ctx->Array.Index.Type = type;
    ctx->Array.Index.Stride = stride;
    ctx->Array.Index.Ptr = (void *) ptr;
-   ctx->Array.IndexFunc = gl_trans_1ui_tab[TYPE_IDX(type)];
-   ctx->Array.IndexEltFunc = gl_trans_elt_1ui_tab[TYPE_IDX(type)];
-#endif
-   ctx->Array.NewArrayState |= VERT_INDEX;
-   ctx->NewState |= NEW_CLIENT_STATE;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_INDEX;
+
+   if (ctx->Driver.IndexPointer)
+      ctx->Driver.IndexPointer( ctx, type, stride, ptr );
 }
 
 
+void
+_mesa_SecondaryColorPointerEXT(GLint size, GLenum type,
+			       GLsizei stride, const GLvoid *ptr)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
+   if (size != 3 && size != 4) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(size)" );
+      return;
+   }
+   if (stride<0) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(stride)" );
+      return;
+   }
+
+   if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
+      fprintf(stderr, "glColorPointer( sz %d type %s stride %d )\n", size,
+	  _mesa_lookup_enum_by_nr( type ),
+	  stride);
+
+   ctx->Array.SecondaryColor.StrideB = stride;
+   if (!stride) {
+      switch (type) {
+      case GL_BYTE:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLbyte);
+         break;
+      case GL_UNSIGNED_BYTE:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLubyte);
+         break;
+      case GL_SHORT:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLshort);
+         break;
+      case GL_UNSIGNED_SHORT:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLushort);
+         break;
+      case GL_INT:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLint);
+         break;
+      case GL_UNSIGNED_INT:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLuint);
+         break;
+      case GL_FLOAT:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLfloat);
+         break;
+      case GL_DOUBLE:
+         ctx->Array.SecondaryColor.StrideB =  size*sizeof(GLdouble);
+         break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glSecondaryColorPointer(type)" );
+         return;
+      }
+   }
+   ctx->Array.SecondaryColor.Size = 3; /* hardwire */
+   ctx->Array.SecondaryColor.Type = type;
+   ctx->Array.SecondaryColor.Stride = stride;
+   ctx->Array.SecondaryColor.Ptr = (void *) ptr;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_SECONDARYCOLOR;
+
+   if (ctx->Driver.SecondaryColorPointer)
+      ctx->Driver.SecondaryColorPointer( ctx, size, type, stride, ptr );
+}
+
+
+
 void
 _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLuint texUnit;
-   
-   texUnit = ctx->Array.ActiveTexture;
+   GLuint texUnit = ctx->Array.ActiveTexture;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (size<1 || size>4) {
-      gl_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(size)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(size)" );
       return;
    }
    if (stride<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glTexCoordPointer(stride)" );
       return;
    }
 
    if (MESA_VERBOSE&(VERBOSE_VARRAY|VERBOSE_API))
-      fprintf(stderr, "glTexCoordPointer( unit %u sz %d type %s stride %d )\n", 
+      fprintf(stderr, "glTexCoordPointer( unit %u sz %d type %s stride %d )\n",
 	  texUnit,
-	  size, 
-	  gl_lookup_enum_by_nr( type ),
+	  size,
+	  _mesa_lookup_enum_by_nr( type ),
 	  stride);
 
-#ifdef VAO
-   ctx->Array.Current->TexCoord[texUnit].StrideB = stride;
-#else
    ctx->Array.TexCoord[texUnit].StrideB = stride;
-#endif
    if (!stride) {
       switch (type) {
       case GL_SHORT:
-#ifdef VAO
-         ctx->Array.Current->TexCoord[texUnit].StrideB =  size*sizeof(GLshort);
-#else
          ctx->Array.TexCoord[texUnit].StrideB =  size*sizeof(GLshort);
-#endif
          break;
       case GL_INT:
-#ifdef VAO
-         ctx->Array.Current->TexCoord[texUnit].StrideB =  size*sizeof(GLint);
-#else
          ctx->Array.TexCoord[texUnit].StrideB =  size*sizeof(GLint);
-#endif
          break;
       case GL_FLOAT:
-#ifdef VAO
-         ctx->Array.Current->TexCoord[texUnit].StrideB =  size*sizeof(GLfloat);
-#else
          ctx->Array.TexCoord[texUnit].StrideB =  size*sizeof(GLfloat);
-#endif
          break;
       case GL_DOUBLE:
-#ifdef VAO
-         ctx->Array.Current->TexCoord[texUnit].StrideB =  size*sizeof(GLdouble);
-#else
          ctx->Array.TexCoord[texUnit].StrideB =  size*sizeof(GLdouble);
-#endif
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type)" );
          return;
       }
    }
-#ifdef VAO
-   ctx->Array.Current->TexCoord[texUnit].Size = size;
-   ctx->Array.Current->TexCoord[texUnit].Type = type;
-   ctx->Array.Current->TexCoord[texUnit].Stride = stride;
-   ctx->Array.Current->TexCoord[texUnit].Ptr = (void *) ptr;
-
-   ctx->Array.Current->TexCoordFunc[texUnit] = gl_trans_4f_tab[size][TYPE_IDX(type)];
-   ctx->Array.Current->TexCoordEltFunc[texUnit] = gl_trans_elt_4f_tab[size][TYPE_IDX(type)];
-#else
    ctx->Array.TexCoord[texUnit].Size = size;
    ctx->Array.TexCoord[texUnit].Type = type;
    ctx->Array.TexCoord[texUnit].Stride = stride;
    ctx->Array.TexCoord[texUnit].Ptr = (void *) ptr;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_TEXCOORD(texUnit);
 
-   ctx->Array.TexCoordFunc[texUnit] = gl_trans_4f_tab[size][TYPE_IDX(type)];
-   ctx->Array.TexCoordEltFunc[texUnit] = gl_trans_elt_4f_tab[size][TYPE_IDX(type)];
-#endif
-   ctx->Array.NewArrayState |= PIPE_TEX(texUnit);
-   ctx->NewState |= NEW_CLIENT_STATE;
+/*     fprintf(stderr, "%s ptr %p\n", __FUNCTION__, ptr); */
+
+   if (ctx->Driver.TexCoordPointer)
+      ctx->Driver.TexCoordPointer( ctx, size, type, stride, ptr );
 }
 
 
@@ -493,63 +424,23 @@
 {
    GET_CURRENT_CONTEXT(ctx);
    const GLboolean *ptr = (GLboolean *)vptr;
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (stride<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glEdgeFlagPointer(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glEdgeFlagPointer(stride)" );
       return;
    }
-#ifdef VAO
-   ctx->Array.Current->EdgeFlag.Stride = stride;
-   ctx->Array.Current->EdgeFlag.StrideB = stride ? stride : sizeof(GLboolean);
-   ctx->Array.Current->EdgeFlag.Ptr = (GLboolean *) ptr;
-   if (stride != sizeof(GLboolean)) {
-      ctx->Array.Current->EdgeFlagFunc = gl_trans_1ub_tab[TYPE_IDX(GL_UNSIGNED_BYTE)];
-   } else {
-      ctx->Array.Current->EdgeFlagFunc = 0;
-   }
-   ctx->Array.Current->EdgeFlagEltFunc = gl_trans_elt_1ub_tab[TYPE_IDX(GL_UNSIGNED_BYTE)];
-#else
    ctx->Array.EdgeFlag.Stride = stride;
    ctx->Array.EdgeFlag.StrideB = stride ? stride : sizeof(GLboolean);
    ctx->Array.EdgeFlag.Ptr = (GLboolean *) ptr;
-   if (stride != sizeof(GLboolean)) {
-      ctx->Array.EdgeFlagFunc = gl_trans_1ub_tab[TYPE_IDX(GL_UNSIGNED_BYTE)];
-   } else {
-      ctx->Array.EdgeFlagFunc = 0;
-   }
-   ctx->Array.EdgeFlagEltFunc = gl_trans_elt_1ub_tab[TYPE_IDX(GL_UNSIGNED_BYTE)];
-#endif
-   ctx->Array.NewArrayState |= VERT_EDGE;
-   ctx->NewState |= NEW_CLIENT_STATE;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_EDGEFLAG;
+
+   if (ctx->Driver.EdgeFlagPointer)
+      ctx->Driver.EdgeFlagPointer( ctx, stride, ptr );
 }
 
 
-#if 0
-/* Called only from gl_DrawElements
- */
-static void gl_CVAEltPointer( GLcontext *ctx, GLenum type, const GLvoid *ptr )
-{
-   switch (type) {
-      case GL_UNSIGNED_BYTE:
-         ctx->CVA.Elt.StrideB = sizeof(GLubyte);
-         break;
-      case GL_UNSIGNED_SHORT:
-         ctx->CVA.Elt.StrideB = sizeof(GLushort);
-         break;
-      case GL_UNSIGNED_INT:
-         ctx->CVA.Elt.StrideB = sizeof(GLuint);
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glEltPointer(type)" );
-         return;
-   }
-   ctx->CVA.Elt.Type = type;
-   ctx->CVA.Elt.Stride = 0;
-   ctx->CVA.Elt.Ptr = (void *) ptr;
-   ctx->CVA.EltFunc = gl_trans_1ui_tab[TYPE_IDX(type)];
-   ctx->Array.NewArrayState |= VERT_ELT; /* ??? */
-}
-#endif
 
 
 
@@ -609,777 +500,27 @@
 
 
 
-/* KW: Batch function to exec all the array elements in the input
- *     buffer prior to transform.  Done only the first time a vertex
- *     buffer is executed or compiled.
- *
- * KW: Have to do this after each glEnd if cva isn't active.  (also
- *     have to do it after each full buffer)
- */
-void gl_exec_array_elements( GLcontext *ctx, struct immediate *IM,
-			     GLuint start, 
-			     GLuint count)
-{
-   GLuint *flags = IM->Flag;
-   GLuint *elts = IM->Elt;
-#ifdef VAO
-   GLuint translate = ctx->Array.Current->Flags;
-#else
-   GLuint translate = ctx->Array.Flags;
-#endif
-   GLuint i;
-
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      fprintf(stderr, "exec_array_elements %d .. %d\n", start, count);
-   
-#ifdef VAO
-   if (translate & VERT_OBJ_ANY) 
-      (ctx->Array.Current->VertexEltFunc)( IM->Obj, 
-				  &ctx->Array.Current->Vertex, 
-				  flags, elts, (VERT_ELT|VERT_OBJ_ANY),
-				  start, count);
-   
-   if (translate & VERT_NORM) 
-      (ctx->Array.Current->NormalEltFunc)( IM->Normal, 
-				  &ctx->Array.Current->Normal, 
-				  flags, elts, (VERT_ELT|VERT_NORM),
-				  start, count);
-
-   if (translate & VERT_EDGE) 
-      (ctx->Array.Current->EdgeFlagEltFunc)( IM->EdgeFlag, 
-				    &ctx->Array.Current->EdgeFlag, 
-				    flags, elts, (VERT_ELT|VERT_EDGE),
-				    start, count);
-   
-   if (translate & VERT_RGBA)
-      (ctx->Array.Current->ColorEltFunc)( IM->Color, 
-				 &ctx->Array.Current->Color, 
-				 flags, elts, (VERT_ELT|VERT_RGBA),
-				 start, count);
-
-   if (translate & VERT_INDEX)
-      (ctx->Array.Current->IndexEltFunc)( IM->Index, 
-				 &ctx->Array.Current->Index, 
-				 flags, elts, (VERT_ELT|VERT_INDEX),
-				 start, count);
-
-   if (translate & VERT_TEX0_ANY)
-      (ctx->Array.Current->TexCoordEltFunc[0])( IM->TexCoord[0], 
-				       &ctx->Array.Current->TexCoord[0], 
-				       flags, elts, (VERT_ELT|VERT_TEX0_ANY),
-				       start, count);
-
-   if (translate & VERT_TEX1_ANY)
-      (ctx->Array.Current->TexCoordEltFunc[1])( IM->TexCoord[1], 
-				       &ctx->Array.Current->TexCoord[1], 
-				       flags, elts, (VERT_ELT|VERT_TEX1_ANY),
-				       start, count);
-#else
-   if (translate & VERT_OBJ_ANY) 
-      (ctx->Array.VertexEltFunc)( IM->Obj, 
-				  &ctx->Array.Vertex, 
-				  flags, elts, (VERT_ELT|VERT_OBJ_ANY),
-				  start, count);
-   
-   if (translate & VERT_NORM) 
-      (ctx->Array.NormalEltFunc)( IM->Normal, 
-				  &ctx->Array.Normal, 
-				  flags, elts, (VERT_ELT|VERT_NORM),
-				  start, count);
-
-   if (translate & VERT_EDGE) 
-      (ctx->Array.EdgeFlagEltFunc)( IM->EdgeFlag, 
-				    &ctx->Array.EdgeFlag, 
-				    flags, elts, (VERT_ELT|VERT_EDGE),
-				    start, count);
-   
-   if (translate & VERT_RGBA)
-      (ctx->Array.ColorEltFunc)( IM->Color, 
-				 &ctx->Array.Color, 
-				 flags, elts, (VERT_ELT|VERT_RGBA),
-				 start, count);
-
-   if (translate & VERT_INDEX)
-      (ctx->Array.IndexEltFunc)( IM->Index, 
-				 &ctx->Array.Index, 
-				 flags, elts, (VERT_ELT|VERT_INDEX),
-				 start, count);
-
-   if (translate & VERT_TEX0_ANY)
-      (ctx->Array.TexCoordEltFunc[0])( IM->TexCoord[0], 
-				       &ctx->Array.TexCoord[0], 
-				       flags, elts, (VERT_ELT|VERT_TEX0_ANY),
-				       start, count);
-
-   if (translate & VERT_TEX1_ANY)
-      (ctx->Array.TexCoordEltFunc[1])( IM->TexCoord[1], 
-				       &ctx->Array.TexCoord[1], 
-				       flags, elts, (VERT_ELT|VERT_TEX1_ANY),
-				       start, count);
-#endif
-
-   for (i = start ; i < count ; i++) 
-      if (flags[i] & VERT_ELT) 
-	 flags[i] |= translate;
-
-}
-
-
-
-/* Enough funny business going on in here it might be quicker to use a
- * function pointer.
- */
-#define ARRAY_ELT( IM, i )					\
-{								\
-   GLuint count = IM->Count;					\
-   IM->Elt[count] = i;						\
-   IM->Flag[count] = ((IM->Flag[count] & IM->ArrayAndFlags) |	\
-		      VERT_ELT);				\
-   IM->FlushElt |= IM->ArrayEltFlush;				\
-   IM->Count = count += IM->ArrayIncr;				\
-   if (count == VB_MAX)						\
-      IM->maybe_transform_vb( IM );				\
-}
-
-
-void
-_mesa_ArrayElement( GLint i )
-{
-   GET_IMMEDIATE;
-   ARRAY_ELT( IM, i );
-}
-
 
-static void
-gl_ArrayElement( GLcontext *CC, GLint i )
-{
-   struct immediate *im = CC->input;
-   ARRAY_ELT( im, i );
-}
-
-
-
 void
-_mesa_DrawArrays(GLenum mode, GLint start, GLsizei count)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct vertex_buffer *VB = ctx->VB;
-   GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDrawArrays");
-
-   if (count<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
-      return;
-   }
-
-#ifdef VAO
-   if (!ctx->CompileFlag && ctx->Array.Current->Vertex.Enabled) {
-#else
-   if (!ctx->CompileFlag && ctx->Array.Vertex.Enabled) {
-#endif
-      GLint remaining = count;
-      GLint i;
-      struct gl_client_array *Normal = 0;
-      struct gl_client_array *Color = 0;
-      struct gl_client_array *Index = 0;
-      struct gl_client_array *TexCoord[MAX_TEXTURE_UNITS];
-      struct gl_client_array *EdgeFlag = 0;
-      struct immediate *IM = VB->IM;
-      struct gl_pipeline *elt = &ctx->CVA.elt;
-      GLboolean relock;
-      GLuint fallback, required;
-
-      if (ctx->NewState)
-	 gl_update_state( ctx );	
-
-      /* Just turn off cva on this path.  Could be useful for multipass
-       * rendering to keep it turned on.
-       */
-      relock = ctx->CompileCVAFlag;
-
-      if (relock) {
-	 ctx->CompileCVAFlag = 0;
-	 elt->pipeline_valid = 0;
-      }
-
-      if (!elt->pipeline_valid)
-	 gl_build_immediate_pipeline( ctx );
-
-      required = elt->inputs;
-#ifdef VAO
-      fallback = (elt->inputs & ~ctx->Array.Current->Summary);
-#else
-      fallback = (elt->inputs & ~ctx->Array.Summary);
-#endif
-
-      /* The translate function doesn't do anything about size.  It
-       * just ensures that type and stride come out right.
-       */
-#ifdef VAO
-      IM->v.Obj.size = ctx->Array.Current->Vertex.Size;
-
-      if (required & VERT_RGBA) 
-      {
-	 Color = &ctx->Array.Current->Color;
-	 if (fallback & VERT_RGBA) {
-	    Color = &ctx->Fallback.Color;
-	    ctx->Array.Current->ColorFunc = 
-	       gl_trans_4ub_tab[4][TYPE_IDX(GL_UNSIGNED_BYTE)];
-	 }
-      }
-   
-      if (required & VERT_INDEX) 
-      {
-	 Index = &ctx->Array.Current->Index;
-	 if (fallback & VERT_INDEX) {
-	    Index = &ctx->Fallback.Index;
-	    ctx->Array.Current->IndexFunc = gl_trans_1ui_tab[TYPE_IDX(GL_UNSIGNED_INT)];
-	 }
-      }
-
-      for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) 
-      {
-	 GLuint flag = VERT_TEX_ANY(i);
-
-	 if (required & flag) {
-	    TexCoord[i] = &ctx->Array.Current->TexCoord[i];
-
-	    if (fallback & flag) 
-	    {
-	       TexCoord[i] = &ctx->Fallback.TexCoord[i];
-	       TexCoord[i]->Size = gl_texcoord_size( ctx->Current.Flag, i );
-
-	       ctx->Array.Current->TexCoordFunc[i] = 
-		  gl_trans_4f_tab[TexCoord[i]->Size][TYPE_IDX(GL_FLOAT)];
-	    }
-	 }
-      }
-
-      if (ctx->Array.Current->Flags != ctx->Array.Current->Flag[0])
- 	 for (i = 0 ; i < VB_MAX ; i++) 
-	    ctx->Array.Current->Flag[i] = ctx->Array.Current->Flags;
-
-
-      if (required & VERT_NORM) 
-      {
-	 Normal = &ctx->Array.Current->Normal;
-	 if (fallback & VERT_NORM) {
-	    Normal = &ctx->Fallback.Normal;
-	    ctx->Array.Current->NormalFunc = gl_trans_3f_tab[TYPE_IDX(GL_FLOAT)];
-	 }
-      }
-
-      if ( required & VERT_EDGE )
-      {
-	 if (mode == GL_TRIANGLES || 
-	     mode == GL_QUADS || 
-	     mode == GL_POLYGON)
-	 {
-	    EdgeFlag = &ctx->Array.Current->EdgeFlag;
-	    if (fallback & VERT_EDGE) {
-	       EdgeFlag = &ctx->Fallback.EdgeFlag;
-	       ctx->Array.Current->EdgeFlagFunc = 
-		  gl_trans_1ub_tab[TYPE_IDX(GL_UNSIGNED_BYTE)];
-	    }
-	 }
-	 else
-	    required &= ~VERT_EDGE;
-      }
-#else
-      IM->v.Obj.size = ctx->Array.Vertex.Size;
-
-      if (required & VERT_RGBA) 
-      {
-	 Color = &ctx->Array.Color;
-	 if (fallback & VERT_RGBA) {
-	    Color = &ctx->Fallback.Color;
-	    ctx->Array.ColorFunc = 
-	       gl_trans_4ub_tab[4][TYPE_IDX(GL_UNSIGNED_BYTE)];
-	 }
-      }
-   
-      if (required & VERT_INDEX) 
-      {
-	 Index = &ctx->Array.Index;
-	 if (fallback & VERT_INDEX) {
-	    Index = &ctx->Fallback.Index;
-	    ctx->Array.IndexFunc = gl_trans_1ui_tab[TYPE_IDX(GL_UNSIGNED_INT)];
-	 }
-      }
-
-      for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) 
-      {
-	 GLuint flag = VERT_TEX_ANY(i);
-
-	 if (required & flag) {
-	    TexCoord[i] = &ctx->Array.TexCoord[i];
-
-	    if (fallback & flag) 
-	    {
-	       TexCoord[i] = &ctx->Fallback.TexCoord[i];
-	       TexCoord[i]->Size = gl_texcoord_size( ctx->Current.Flag, i );
-
-	       ctx->Array.TexCoordFunc[i] = 
-		  gl_trans_4f_tab[TexCoord[i]->Size][TYPE_IDX(GL_FLOAT)];
-	    }
-	 }
-      }
-
-      if (ctx->Array.Flags != ctx->Array.Flag[0])
- 	 for (i = 0 ; i < VB_MAX ; i++) 
-	    ctx->Array.Flag[i] = ctx->Array.Flags;
-
-
-      if (required & VERT_NORM) 
-      {
-	 Normal = &ctx->Array.Normal;
-	 if (fallback & VERT_NORM) {
-	    Normal = &ctx->Fallback.Normal;
-	    ctx->Array.NormalFunc = gl_trans_3f_tab[TYPE_IDX(GL_FLOAT)];
-	 }
-      }
-
-      if ( required & VERT_EDGE )
-      {
-	 if (mode == GL_TRIANGLES || 
-	     mode == GL_QUADS || 
-	     mode == GL_POLYGON)
-	 {
-	    EdgeFlag = &ctx->Array.EdgeFlag;
-	    if (fallback & VERT_EDGE) {
-	       EdgeFlag = &ctx->Fallback.EdgeFlag;
-	       ctx->Array.EdgeFlagFunc = 
-		  gl_trans_1ub_tab[TYPE_IDX(GL_UNSIGNED_BYTE)];
-	    }
-	 }
-	 else
-	    required &= ~VERT_EDGE;
-      }
-#endif
-
-      VB->Primitive = IM->Primitive; 
-      VB->NextPrimitive = IM->NextPrimitive; 
-      VB->MaterialMask = IM->MaterialMask;
-      VB->Material = IM->Material;
-      VB->BoundsPtr = 0;
-
-      while (remaining > 0) {
-         GLint vbspace = VB_MAX - VB_START;
-	 GLuint count, n;
-	 
-	 if (vbspace >= remaining) {
-	    n = remaining;
-	    VB->LastPrimitive = VB_START + n;
-	 } else {
-	    n = vbspace;
-	    VB->LastPrimitive = VB_START;
-	 }
-	 
-	 VB->CullMode = 0;
-	 
-#ifdef VAO
-	 ctx->Array.Current->VertexFunc( IM->Obj + VB_START, 
-				&ctx->Array.Current->Vertex, start, n );
-	 
-	 if (required & VERT_NORM) {
-	    ctx->Array.Current->NormalFunc( IM->Normal + VB_START, 
-				   Normal, start, n );
-	 }
-	 
-	 if (required & VERT_EDGE) {
-	    ctx->Array.Current->EdgeFlagFunc( IM->EdgeFlag + VB_START, 
-				     EdgeFlag, start, n );
-	 }
-	 
-	 if (required & VERT_RGBA) {
-	    ctx->Array.Current->ColorFunc( IM->Color + VB_START, 
-				  Color, start, n );
-	 }
-	 
-	 if (required & VERT_INDEX) {
-	    ctx->Array.Current->IndexFunc( IM->Index + VB_START, 
-				  Index, start, n );
-	 }
-	 
-	 if (required & VERT_TEX0_ANY) {
-	    IM->v.TexCoord[0].size = TexCoord[0]->Size;
-	    ctx->Array.Current->TexCoordFunc[0]( IM->TexCoord[0] + VB_START, 
-					TexCoord[0], start, n );
-	 }
-	 
-	 if (required & VERT_TEX1_ANY) {
-	    IM->v.TexCoord[1].size = TexCoord[1]->Size;
-	    ctx->Array.Current->TexCoordFunc[1]( IM->TexCoord[1] + VB_START, 
-					TexCoord[1], start, n );
-	 }
-#else
-	 ctx->Array.VertexFunc( IM->Obj + VB_START, 
-				&ctx->Array.Vertex, start, n );
-	 
-	 if (required & VERT_NORM) {
-	    ctx->Array.NormalFunc( IM->Normal + VB_START, 
-				   Normal, start, n );
-	 }
-	 
-	 if (required & VERT_EDGE) {
-	    ctx->Array.EdgeFlagFunc( IM->EdgeFlag + VB_START, 
-				     EdgeFlag, start, n );
-	 }
-	 
-	 if (required & VERT_RGBA) {
-	    ctx->Array.ColorFunc( IM->Color + VB_START, 
-				  Color, start, n );
-	 }
-	 
-	 if (required & VERT_INDEX) {
-	    ctx->Array.IndexFunc( IM->Index + VB_START, 
-				  Index, start, n );
-	 }
-	 
-	 if (required & VERT_TEX0_ANY) {
-	    IM->v.TexCoord[0].size = TexCoord[0]->Size;
-	    ctx->Array.TexCoordFunc[0]( IM->TexCoord[0] + VB_START, 
-					TexCoord[0], start, n );
-	 }
-	 
-	 if (required & VERT_TEX1_ANY) {
-	    IM->v.TexCoord[1].size = TexCoord[1]->Size;
-	    ctx->Array.TexCoordFunc[1]( IM->TexCoord[1] + VB_START, 
-					TexCoord[1], start, n );
-	 }
-#endif
-	 VB->ObjPtr = &IM->v.Obj;
-	 VB->NormalPtr = &IM->v.Normal;
-	 VB->ColorPtr = &IM->v.Color;
-	 VB->Color[0] = VB->Color[1] = VB->ColorPtr;
-	 VB->IndexPtr = &IM->v.Index;
-	 VB->EdgeFlagPtr = &IM->v.EdgeFlag;
-	 VB->TexCoordPtr[0] = &IM->v.TexCoord[0];
-	 VB->TexCoordPtr[1] = &IM->v.TexCoord[1];
-
-#ifdef VAO
-	 VB->Flag = ctx->Array.Current->Flag;
-	 VB->OrFlag = ctx->Array.Current->Flags;
-#else
-	 VB->Flag = ctx->Array.Flag;
-	 VB->OrFlag = ctx->Array.Flags;
-#endif
-
-	 VB->Start = IM->Start = VB_START;
-	 count = VB->Count = IM->Count = VB_START + n;
-
-#define RESET_VEC(v, t, s, c) (v.start = t v.data[s], v.count = c)  
-
-	 RESET_VEC(IM->v.Obj, (GLfloat *), VB_START, count);
-	 RESET_VEC(IM->v.Normal, (GLfloat *), VB_START, count);
-	 RESET_VEC(IM->v.TexCoord[0], (GLfloat *), VB_START, count);
-	 RESET_VEC(IM->v.TexCoord[1], (GLfloat *), VB_START, count);
-	 RESET_VEC(IM->v.Index, &, VB_START, count);
-	 RESET_VEC(IM->v.Elt, &, VB_START, count);
-	 RESET_VEC(IM->v.EdgeFlag, &, VB_START, count);
-	 RESET_VEC(IM->v.Color, (GLubyte *), VB_START, count);
-	 RESET_VEC(VB->Clip, (GLfloat *), VB_START, count);
-	 RESET_VEC(VB->Eye, (GLfloat *), VB_START, count);
-	 RESET_VEC(VB->Win, (GLfloat *), VB_START, count);
-	 RESET_VEC(VB->BColor, (GLubyte *), VB_START, count); 
-	 RESET_VEC(VB->BIndex, &, VB_START, count);
-
-	 VB->NextPrimitive[VB->CopyStart] = VB->Count;
-	 VB->Primitive[VB->CopyStart] = mode;
-#ifdef VAO
-	 ctx->Array.Current->Flag[count] |= VERT_END_VB;
-#else
-	 ctx->Array.Flag[count] |= VERT_END_VB;
-#endif
-
-         /* Transform and render.
-	  */
-         gl_run_pipeline( VB );
-	 gl_reset_vb( VB );
-
-#ifdef VAO
-	 ctx->Array.Current->Flag[count] = ctx->Array.Current->Flags;
-	 ctx->Array.Current->Flag[VB_START] = ctx->Array.Current->Flags;
-#else
-	 ctx->Array.Flag[count] = ctx->Array.Flags;
-	 ctx->Array.Flag[VB_START] = ctx->Array.Flags;
-#endif
-
-         start += n;
-         remaining -= n;
-      }
-
-      gl_reset_input( ctx );
-
-      if (relock) {
-	 ctx->CompileCVAFlag = relock;
-	 elt->pipeline_valid = 0;
-      }
-   }
-#ifdef VAO
-   else if (ctx->Array.Current->Vertex.Enabled)
-#else
-   else if (ctx->Array.Vertex.Enabled)
-#endif
-   {
-      /* The GL_COMPILE and GL_COMPILE_AND_EXECUTE cases.  These
-       * could be handled by the above code, but it gets a little
-       * complex.  The generated list is still of good quality
-       * this way.
-       */
-      gl_Begin( ctx, mode );
-      for (i=0;i<count;i++) {
-         gl_ArrayElement( ctx, start+i );
-      }
-      gl_End( ctx );
-   }
-   else
-   {
-      /* The degenerate case where vertices are not enabled - only
-       * need to process the very final array element, as all of the
-       * preceding ones would be overwritten anyway. 
-       */
-      gl_Begin( ctx, mode );
-      gl_ArrayElement( ctx, start+count );
-      gl_End( ctx );
-   }
-}
-
-
-
-/* KW: Exactly fakes the effects of calling glArrayElement multiple times.
- *     Compilation is handled via. the IM->maybe_transform_vb() callback.
- */
-#if 1
-#define DRAW_ELT(FUNC, TYPE)				\
-static void FUNC( GLcontext *ctx, GLenum mode,		\
-		  TYPE *indices, GLuint count )		\
-{							\
-   GLuint i,j;						\
-							\
-   gl_Begin( ctx, mode );				\
-							\
-   for (j = 0 ; j < count ; ) {				\
-      struct immediate *IM = ctx->input;		\
-      GLuint start = IM->Start;				\
-      GLuint nr = MIN2( VB_MAX, count - j + start );	\
-      GLuint sf = IM->Flag[start];			\
-      IM->FlushElt |= IM->ArrayEltFlush;		\
-							\
-      for (i = start ; i < nr ; i++) {			\
-	 IM->Elt[i] = (GLuint) *indices++;		\
-	 IM->Flag[i] = VERT_ELT;			\
-      }							\
-							\
-      if (j == 0) IM->Flag[start] |= sf;		\
-							\
-      IM->Count = nr;					\
-      j += nr - start;					\
-							\
-      if (j == count) gl_End( ctx );			\
-      IM->maybe_transform_vb( IM );			\
-   }							\
-}
-#else 
-#define DRAW_ELT(FUNC, TYPE)				\
-static void FUNC( GLcontext *ctx, GLenum mode,		\
-		   TYPE *indices, GLuint count )	\
-{							\
-  int i;						\
-  glBegin(mode);					\
-  for (i = 0 ; i < count ; i++)				\
-    glArrayElement( indices[i] );			\
-  glEnd();						\
-}
-#endif
-	
-
-DRAW_ELT( draw_elt_ubyte, GLubyte )
-DRAW_ELT( draw_elt_ushort, GLushort )
-DRAW_ELT( draw_elt_uint, GLuint )
-
-
-static GLuint natural_stride[0x10] = 
-{
-   sizeof(GLbyte),		/* 0 */
-   sizeof(GLubyte),		/* 1 */
-   sizeof(GLshort),		/* 2 */
-   sizeof(GLushort),		/* 3 */
-   sizeof(GLint),		/* 4 */
-   sizeof(GLuint),		/* 5 */
-   sizeof(GLfloat),		/* 6 */
-   2 * sizeof(GLbyte),		/* 7 */
-   3 * sizeof(GLbyte),		/* 8 */
-   4 * sizeof(GLbyte),		/* 9 */
-   sizeof(GLdouble),		/* a */
-   0,				/* b */
-   0,				/* c */
-   0,				/* d */
-   0,				/* e */
-   0				/* f */
-};
-
-
-void
-_mesa_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_cva *cva;
-      
-   cva = &ctx->CVA;
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDrawElements");
-
-   if (count <= 0) {
-      if (count < 0)
-	 gl_error( ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
-      return;
-   }
-
-   if (mode < 0 || mode > GL_POLYGON) {
-      gl_error( ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
-      return;
-   }
-   
-   if (type != GL_UNSIGNED_INT && type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT)
-   {
-       gl_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
-       return;
-   }
-
-   if (ctx->NewState)
-      gl_update_state(ctx);
-
-   if (ctx->CompileCVAFlag) 
-   {
-#if defined(MESA_CVA_PROF)
-      force_init_prof(); 
-#endif
-
-      /* Treat VERT_ELT like a special client array.
-       */
-      ctx->Array.NewArrayState |= VERT_ELT;
-#ifdef VAO
-      ctx->Array.Current->Summary |= VERT_ELT;
-      ctx->Array.Current->Flags |= VERT_ELT;
-#else
-      ctx->Array.Summary |= VERT_ELT;
-      ctx->Array.Flags |= VERT_ELT;
-#endif
-
-      cva->elt_mode = mode;
-      cva->elt_count = count;
-      cva->Elt.Type = type;
-      cva->Elt.Ptr = (void *) indices;
-      cva->Elt.StrideB = natural_stride[TYPE_IDX(type)];
-      cva->EltFunc = gl_trans_1ui_tab[TYPE_IDX(type)];
-
-      if (!cva->pre.pipeline_valid) 
-	 gl_build_precalc_pipeline( ctx );
-      else if (MESA_VERBOSE & VERBOSE_PIPELINE)
-	 fprintf(stderr, ": dont rebuild\n");
-
-      gl_cva_force_precalc( ctx );
-
-      /* Did we 'precalculate' the render op?
-       */
-      if (ctx->CVA.pre.ops & PIPE_OP_RENDER) {
-	 ctx->Array.NewArrayState |= VERT_ELT;
-#ifdef VAO
-	 ctx->Array.Current->Summary &= ~VERT_ELT;
-	 ctx->Array.Current->Flags &= ~VERT_ELT;
-#else
-	 ctx->Array.Summary &= ~VERT_ELT;
-	 ctx->Array.Flags &= ~VERT_ELT;
-#endif
-	 return;
-      } 
-
-      if ( (MESA_VERBOSE&VERBOSE_VARRAY) )
-	 printf("using immediate\n");
-   }
-
-
-   /* Otherwise, have to use the immediate path to render.
-    */
-   switch (type) {
-   case GL_UNSIGNED_BYTE:
-   {
-      GLubyte *ub_indices = (GLubyte *) indices;
-#ifdef VAO
-      if (ctx->Array.Current->Summary & VERT_OBJ_ANY) {
-#else
-      if (ctx->Array.Summary & VERT_OBJ_ANY) {
-#endif
-	 draw_elt_ubyte( ctx, mode, ub_indices, count );
-      } else {
-	 gl_ArrayElement( ctx, (GLuint) ub_indices[count-1] );
-      }
-   }
-   break;
-   case GL_UNSIGNED_SHORT:
-   {
-      GLushort *us_indices = (GLushort *) indices;
-#ifdef VAO
-      if (ctx->Array.Current->Summary & VERT_OBJ_ANY) {
-#else
-      if (ctx->Array.Summary & VERT_OBJ_ANY) {
-#endif
-	 draw_elt_ushort( ctx, mode, us_indices, count );
-      } else {
-	 gl_ArrayElement( ctx, (GLuint) us_indices[count-1] );
-      }
-   }
-   break;
-   case GL_UNSIGNED_INT:
-   {
-      GLuint *ui_indices = (GLuint *) indices;
-#ifdef VAO
-      if (ctx->Array.Current->Summary & VERT_OBJ_ANY) {
-#else
-      if (ctx->Array.Summary & VERT_OBJ_ANY) {
-#endif
-	 draw_elt_uint( ctx, mode, ui_indices, count );
-      } else {
-	 gl_ArrayElement( ctx, ui_indices[count-1] );
-      }
-   }
-   break;
-   default:
-      gl_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
-      break;
-   }
-
-   if (ctx->CompileCVAFlag) {
-      ctx->Array.NewArrayState |= VERT_ELT;
-#ifdef VAO
-      ctx->Array.Current->Summary &= ~VERT_ELT;
-#else
-      ctx->Array.Summary &= ~VERT_ELT;
-#endif
-   }
-}
-
-
-
-void
 _mesa_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLboolean tflag, cflag, nflag;              /* enable/disable flags */
-   GLint tcomps, ccomps, vcomps;               /* components per texcoord, color, vertex */
+   GLboolean tflag, cflag, nflag;  /* enable/disable flags */
+   GLint tcomps, ccomps, vcomps;   /* components per texcoord, color, vertex */
 
-   GLenum ctype = 0;                           /* color type */
-   GLint coffset = 0, noffset = 0, voffset = 0;/* color, normal, vertex offsets */
-   GLint defstride;                            /* default stride */
+   GLenum ctype = 0;               /* color type */
+   GLint coffset = 0, noffset = 0, voffset;/* color, normal, vertex offsets */
+   GLint defstride;                /* default stride */
    GLint c, f;
    GLint coordUnitSave;
-   
+
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
    f = sizeof(GLfloat);
    c = f * ((4*sizeof(GLubyte) + (f-1)) / f);
 
    if (stride<0) {
-      gl_error( ctx, GL_INVALID_VALUE, "glInterleavedArrays(stride)" );
+      _mesa_error( ctx, GL_INVALID_VALUE, "glInterleavedArrays(stride)" );
       return;
    }
 
@@ -1490,7 +631,7 @@
          defstride = 15*f;
          break;
       default:
-         gl_error( ctx, GL_INVALID_ENUM, "glInterleavedArrays(format)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glInterleavedArrays(format)" );
          return;
    }
 
@@ -1505,16 +646,12 @@
    coordUnitSave = ctx->Array.ActiveTexture;
    if (tflag) {
       GLint i;
-#ifdef VAO
-      GLint factor = ctx->Array.Current->TexCoordInterleaveFactor;
-#else
       GLint factor = ctx->Array.TexCoordInterleaveFactor;
-#endif
       for (i = 0; i < factor; i++) {
          _mesa_ClientActiveTextureARB( (GLenum) (GL_TEXTURE0_ARB + i) );
          _mesa_EnableClientState( GL_TEXTURE_COORD_ARRAY );
-         glTexCoordPointer( tcomps, GL_FLOAT, stride,
-                             (GLubyte *) pointer + i * coffset );
+         _mesa_TexCoordPointer( tcomps, GL_FLOAT, stride,
+				(GLubyte *) pointer + i * coffset );
       }
       for (i = factor; i < (GLint) ctx->Const.MaxTextureUnits; i++) {
          _mesa_ClientActiveTextureARB( (GLenum) (GL_TEXTURE0_ARB + i) );
@@ -1535,8 +672,8 @@
    /* Color */
    if (cflag) {
       _mesa_EnableClientState( GL_COLOR_ARRAY );
-      glColorPointer( ccomps, ctype, stride,
-                       (GLubyte*) pointer + coffset );
+      _mesa_ColorPointer( ccomps, ctype, stride,
+			  (GLubyte*) pointer + coffset );
    }
    else {
       _mesa_DisableClientState( GL_COLOR_ARRAY );
@@ -1546,319 +683,61 @@
    /* Normals */
    if (nflag) {
       _mesa_EnableClientState( GL_NORMAL_ARRAY );
-      glNormalPointer( GL_FLOAT, stride,
-                        (GLubyte*) pointer + noffset );
+      _mesa_NormalPointer( GL_FLOAT, stride,
+			   (GLubyte*) pointer + noffset );
    }
    else {
       _mesa_DisableClientState( GL_NORMAL_ARRAY );
    }
 
    _mesa_EnableClientState( GL_VERTEX_ARRAY );
-   glVertexPointer( vcomps, GL_FLOAT, stride,
-                     (GLubyte *) pointer + voffset );
-}
-
-
-
-void
-_mesa_DrawRangeElements(GLenum mode, GLuint start,
-                        GLuint end, GLsizei count,
-                        GLenum type, const GLvoid *indices)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (end < start) {
-      gl_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements( end < start )");
-      return;
-   }
-
-#if 0
-   /*
-    * XXX something in locked arrays is broken!  If start = 0,
-    * end = 1 and count = 2 we'll take the LockArrays path and
-    * get incorrect results.  See Scott McMillan's bug of 3 Jan 2000.
-    * For now, don't use locked arrays.
-    */
-   if (!ctx->Array.LockCount && 2*count > (GLint) 3*(end-start)) {
-      glLockArraysEXT( start, end );
-      glDrawElements( mode, count, type, indices );
-      glUnlockArraysEXT();
-   } else {
-      glDrawElements( mode, count, type, indices );
-   }
-#else
-   glDrawElements( mode, count, type, indices );
-#endif
-}
-
-
-
-void gl_update_client_state( GLcontext *ctx )
-{
-   static GLuint sz_flags[5] = { 0, 
-				 0,
-				 VERT_OBJ_2, 
-				 VERT_OBJ_23, 
-				 VERT_OBJ_234 };
-
-   static GLuint tc_flags[5] = { 0, 
-				 VERT_TEX0_1,
-				 VERT_TEX0_12, 
-				 VERT_TEX0_123, 
-				 VERT_TEX0_1234 };
-
-#ifdef VAO
-   ctx->Array.Current->Flags = 0;
-   ctx->Array.Current->Summary = 0;
-#else
-   ctx->Array.Flags = 0;
-   ctx->Array.Summary = 0;
-#endif
-   ctx->input->ArrayIncr = 0;
-   
-#ifdef VAO
-   if (ctx->Array.Current->Normal.Enabled)      ctx->Array.Current->Flags |= VERT_NORM;
-   if (ctx->Array.Current->Color.Enabled)       ctx->Array.Current->Flags |= VERT_RGBA;
-   if (ctx->Array.Current->Index.Enabled)       ctx->Array.Current->Flags |= VERT_INDEX;
-   if (ctx->Array.Current->EdgeFlag.Enabled)    ctx->Array.Current->Flags |= VERT_EDGE;
-   if (ctx->Array.Current->Vertex.Enabled) {
-      ctx->Array.Current->Flags |= sz_flags[ctx->Array.Current->Vertex.Size];
-      ctx->input->ArrayIncr = 1;
-   }
-   if (ctx->Array.Current->TexCoord[0].Enabled) {
-      ctx->Array.Current->Flags |= tc_flags[ctx->Array.Current->TexCoord[0].Size];
-   }
-   if (ctx->Array.Current->TexCoord[1].Enabled) {
-      ctx->Array.Current->Flags |= (tc_flags[ctx->Array.Current->TexCoord[1].Size] << NR_TEXSIZE_BITS);
-   }
-#else
-   if (ctx->Array.Normal.Enabled)      ctx->Array.Flags |= VERT_NORM;
-   if (ctx->Array.Color.Enabled)       ctx->Array.Flags |= VERT_RGBA;
-   if (ctx->Array.Index.Enabled)       ctx->Array.Flags |= VERT_INDEX;
-   if (ctx->Array.EdgeFlag.Enabled)    ctx->Array.Flags |= VERT_EDGE;
-   if (ctx->Array.Vertex.Enabled) {
-      ctx->Array.Flags |= sz_flags[ctx->Array.Vertex.Size];
-      ctx->input->ArrayIncr = 1;
-   }
-   if (ctx->Array.TexCoord[0].Enabled) {
-      ctx->Array.Flags |= tc_flags[ctx->Array.TexCoord[0].Size];
-   }
-   if (ctx->Array.TexCoord[1].Enabled) {
-      ctx->Array.Flags |= (tc_flags[ctx->Array.TexCoord[1].Size] << NR_TEXSIZE_BITS);
-   }
-#endif
-
-   /* Not really important any more:
-    */
-#ifdef VAO
-   ctx->Array.Current->Summary = ctx->Array.Current->Flags & VERT_DATA;
-   ctx->input->ArrayAndFlags = ~ctx->Array.Current->Flags;
-#else
-   ctx->Array.Summary = ctx->Array.Flags & VERT_DATA;
-   ctx->input->ArrayAndFlags = ~ctx->Array.Flags;
-#endif
-   ctx->input->ArrayEltFlush = !(ctx->CompileCVAFlag);
-}
-
-
-
-/**********************************************************************/
-/* Vertex Array Objects extension                                     */
-/**********************************************************************/
-
-#ifdef VAO
-
-struct gl_array_object *
-_mesa_alloc_vertex_array_object(GLcontext *ctx, GLuint name)
-{
-   struct gl_array_object *arrayObj;
-
-   arrayObj = MALLOC_STRUCT(gl_array_object);
-   if (arrayObj) {
-      GLuint i;
-      arrayObj->Name = name;
-      arrayObj->RefCount = 1;
-      arrayObj->Vertex.Size = 4;
-      arrayObj->Vertex.Type = GL_FLOAT;
-      arrayObj->Vertex.Stride = 0;
-      arrayObj->Vertex.StrideB = 0;
-      arrayObj->Vertex.Ptr = NULL;
-      arrayObj->Vertex.Enabled = GL_FALSE;
-      arrayObj->Normal.Type = GL_FLOAT;
-      arrayObj->Normal.Stride = 0;
-      arrayObj->Normal.StrideB = 0;
-      arrayObj->Normal.Ptr = NULL;
-      arrayObj->Normal.Enabled = GL_FALSE;
-      arrayObj->Color.Size = 4;
-      arrayObj->Color.Type = GL_FLOAT;
-      arrayObj->Color.Stride = 0;
-      arrayObj->Color.StrideB = 0;
-      arrayObj->Color.Ptr = NULL;
-      arrayObj->Color.Enabled = GL_FALSE;
-      arrayObj->Index.Type = GL_FLOAT;
-      arrayObj->Index.Stride = 0;
-      arrayObj->Index.StrideB = 0;
-      arrayObj->Index.Ptr = NULL;
-      arrayObj->Index.Enabled = GL_FALSE;
-      for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
-         arrayObj->TexCoord[i].Size = 4;
-         arrayObj->TexCoord[i].Type = GL_FLOAT;
-         arrayObj->TexCoord[i].Stride = 0;
-         arrayObj->TexCoord[i].StrideB = 0;
-         arrayObj->TexCoord[i].Ptr = NULL;
-         arrayObj->TexCoord[i].Enabled = GL_FALSE;
-      }
-      arrayObj->TexCoordInterleaveFactor = 1;
-      arrayObj->EdgeFlag.Stride = 0;
-      arrayObj->EdgeFlag.StrideB = 0;
-      arrayObj->EdgeFlag.Ptr = NULL;
-      arrayObj->EdgeFlag.Enabled = GL_FALSE;
-
-      /* Put into hash table */
-      _mesa_HashInsert(ctx->Shared->ArrayObjects, name, arrayObj);
-   }
-   return arrayObj;
+   _mesa_VertexPointer( vcomps, GL_FLOAT, stride,
+			(GLubyte *) pointer + voffset );
 }
 
 
-void
-glGenArraySetsEXT(GLsizei n, GLuint *arrayset)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint first;
-   GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glGenArraySetsEXT");
-
-   if (n < 0) {
-      gl_error(ctx, GL_INVALID_VALUE, "glGenArraySetsEXT");
-      return;
-   }
-
-   if (!arrayset)
-      return;
-
-   /*
-    * This must be atomic (generation and allocation of texture IDs)
-    */
-   /*XXX _glthread_LOCK_MUTEX(GenTexturesLock);*/
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->ArrayObjects, n);
-
-   /* Return the object names */
-   for (i = 0; i < n; i++) {
-      arrayset[i] = first + i;
-   }
-
-   /* Allocate new array objects */
-   for (i = 0; i < n; i++) {
-      struct gl_array_object *arrayObj;
-      GLuint name = first + i;
-      arrayObj = _mesa_alloc_vertex_array_object(ctx, name);
-      if (!arrayObj) {
-         gl_error(ctx, GL_OUT_OF_MEMORY, "glGenArraySetsEXT");
-         break;
-      }
-   }
-
-   /*XXX _glthread_UNLOCK_MUTEX(GenTexturesLock);*/
-}
-
 
 void
-glBindArraySetEXT(GLuint arraySet)
+_mesa_LockArraysEXT(GLint first, GLsizei count)
 {
-   struct gl_array_object *arrayObj;
    GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glBindArraySetEXT");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (arraySet < 0) {
-      gl_error(ctx, GL_INVALID_OPERATION, "glBindArraySetEXT");
-      return;
-   }
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glLockArrays %d %d\n", first, count);
 
-   ctx->Array.Current->RefCount--;
-   if (ctx->Array.Current->RefCount == 0) {
-      _mesa_HashRemove(ctx->Shared->ArrayObjects, arraySet);
-      FREE(ctx->Array.Current);
+   if (first == 0 && count > 0 &&
+       count <= (GLint) ctx->Const.MaxArrayLockSize) {
+      ctx->Array.LockFirst = first;
+      ctx->Array.LockCount = count;
    }
-
-   arrayObj = (struct gl_array_object *) _mesa_HashLookup(ctx->Shared->ArrayObjects, arraySet);
-   if (arrayObj) {
-      ctx->Array.Current = arrayObj;
-   }
    else {
-      /* create the array object and insert into hash table */
-      arrayObj = _mesa_alloc_vertex_array_object(ctx, arraySet);
-      if (!arrayObj) {
-         gl_error(ctx, GL_OUT_OF_MEMORY, "glBindArraySetEXT");
-         return;
-      }
-      ctx->Array.Current = (struct gl_array_object *) _mesa_HashLookup(ctx->Shared->ArrayObjects, 0);
+      ctx->Array.LockFirst = 0;
+      ctx->Array.LockCount = 0;
    }
-
-   ctx->Array.Current->RefCount++;
-
-   /* Signal new state */
-   /*   ctx->Array.NewArrayState = ~0;*/
-   ctx->NewState |= NEW_CLIENT_STATE;
 
-#if 0
-   printf("Bind %d\n", ctx->Array.Current->Name);
-   printf("Vertex array size: %d\n", ctx->Array.Current->Vertex.Size);
-   printf("Vertex array enable: %d\n", ctx->Array.Current->Vertex.Enabled);
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_ALL;
 
-   printf("Normal array size: %d\n", ctx->Array.Current->Normal.Size);
-   printf("Normal array enable: %d\n", ctx->Array.Current->Normal.Enabled);
-   printf("Lock first %d  count %d\n", ctx->Array.Current->LockFirst,
-          ctx->Array.Current->LockCount);
-#endif
+   if (ctx->Driver.LockArraysEXT)
+      ctx->Driver.LockArraysEXT( ctx, first, count );
 }
 
 
 void
-glDeleteArraySetsEXT(GLsizei n, const GLuint *arraySet)
+_mesa_UnlockArraysEXT( void )
 {
-   GLint i;
    GET_CURRENT_CONTEXT(ctx);
-   
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDeleteArraySetsEXT");
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (n < 0) {
-      gl_error(ctx, GL_INVALID_OPERATION, "glDeleteArraySetEXT");
-      return;
-   }
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "glUnlockArrays\n");
 
-   for (i = 0; i < n; i++) {
-      if (arraySet[i] > 0) {
-         struct gl_array_object *arrayObj;
-         arrayObj = (struct gl_array_object *) _mesa_HashLookup(ctx->Shared->ArrayObjects, arraySet[i]);
-         if (arrayObj) {
-            arrayObj->RefCount--;
-            if (arrayObj->RefCount == 0) {
-               _mesa_HashRemove(ctx->Shared->ArrayObjects, arraySet[i]);
-               FREE(arrayObj);
-            }
-         }
-      }
-   }
-}
-
-
-GLboolean
-glIsArraySetEXT(GLuint arraySet)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, "glIsArraySetEXT",
-						  GL_FALSE);
+   ctx->Array.LockFirst = 0;
+   ctx->Array.LockCount = 0;
+   ctx->NewState |= _NEW_ARRAY;
+   ctx->Array.NewState |= _NEW_ARRAY_ALL;
 
-   if (arraySet > 0 && _mesa_HashLookup(ctx->Shared->ArrayObjects, arraySet)) {
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
+   if (ctx->Driver.UnlockArraysEXT)
+      ctx->Driver.UnlockArraysEXT( ctx );
 }
-
-#endif
Index: xc/extras/Mesa/src/varray.h
diff -u xc/extras/Mesa/src/varray.h:1.5 xc/extras/Mesa/src/varray.h:1.6
--- xc/extras/Mesa/src/varray.h:1.5	Wed Jan 17 07:50:07 2001
+++ xc/extras/Mesa/src/varray.h	Fri Feb 22 14:25:45 2002
@@ -1,20 +1,21 @@
+/* $Id: varray.h,v 1.12 2001/03/12 00:48:39 gareth Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -28,13 +29,19 @@
 #define VARRAY_H
 
 
-#include "types.h"
+#include "mtypes.h"
 
 
 extern void
 _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride,
                     const GLvoid *ptr);
 
+extern void
+_mesa_UnlockArraysEXT( void );
+
+extern void
+_mesa_LockArraysEXT(GLint first, GLsizei count);
+
 
 extern void
 _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr);
@@ -86,61 +93,17 @@
 _mesa_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr);
 
 
-
-
-
 extern void
-_mesa_ArrayElement( GLint );
-
-
-extern void
-_mesa_DrawArrays(GLenum mode, GLint first, GLsizei count);
-
-
-extern void
-_mesa_save_DrawArrays(GLenum mode, GLint first, GLsizei count);
-
+_mesa_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr);
 
 extern void
-_mesa_DrawElements(GLenum mode, GLsizei count, GLenum type,
-                   const GLvoid *indices);
+_mesa_SecondaryColorPointerEXT(GLint size, GLenum type,
+			       GLsizei stride, const GLvoid *ptr);
 
 
 extern void
-_mesa_save_DrawElements(GLenum mode, GLsizei count,
-                        GLenum type, const GLvoid *indices);
-
-
-extern void
 _mesa_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);
 
-extern void
-_mesa_save_InterleavedArrays(GLenum format, GLsizei stride,
-                             const GLvoid *pointer);
-
-
-extern void
-_mesa_DrawRangeElements(GLenum mode, GLuint start,
-                        GLuint end, GLsizei count, GLenum type,
-                        const GLvoid *indices);
-
-extern void
-_mesa_save_DrawRangeElements(GLenum mode,
-                             GLuint start, GLuint end, GLsizei count,
-                             GLenum type, const GLvoid *indices );
-
-
-extern void gl_exec_array_elements( GLcontext *ctx, 
-				    struct immediate *IM,
-				    GLuint start, 
-				    GLuint end );
-
-extern void gl_update_client_state( GLcontext *ctx );
-
 
-#ifdef VAO
-struct gl_array_object *
-_mesa_alloc_vertex_array_object(GLcontext *ctx, GLuint name);
-#endif
 
 #endif
Index: xc/extras/Mesa/src/vb.c
diff -u xc/extras/Mesa/src/vb.c:1.8 xc/extras/Mesa/src/vb.c:removed
--- xc/extras/Mesa/src/vb.c:1.8	Mon Nov 13 18:30:53 2000
+++ xc/extras/Mesa/src/vb.c	Thu Feb 27 12:15:45 2003
@@ -1,338 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "mem.h"
-#include "types.h"
-#include "vb.h"
-#include "vbxform.h"
-#include "xform.h"
-#endif
-
-
-/*
- * Allocate and initialize a vertex buffer.
- */
-struct vertex_buffer *gl_vb_create_for_immediate( GLcontext *ctx )
-{
-   struct vertex_buffer *VB;
-   struct immediate *IM;
-   const GLuint alignment = 32;
-
-   VB = ALIGN_CALLOC_STRUCT( vertex_buffer, alignment );
-   if (!VB) 
-      return 0;
-
-   VB->ctx = ctx;
-   VB->ClipAndMask = CLIP_ALL_BITS;
-   VB->Size = VB_SIZE;
-   VB->FirstFree = VB_MAX;
-   VB->Type = VB_IMMEDIATE;
-   VB->Start = VB_START;
-   VB->pipeline = &ctx->CVA.elt;
-
-   gl_vector4f_alloc( &VB->Eye, 2, VEC_WRITABLE, VB_SIZE, alignment );
-   gl_vector4f_alloc( &VB->Clip, 2, VEC_WRITABLE, VB_SIZE, alignment );
-   gl_vector4f_alloc( &VB->Win, 2, VEC_WRITABLE, VB_SIZE, alignment );
-   gl_vector4ub_alloc( &VB->BColor, VEC_WRITABLE, VB_SIZE, alignment );      
-   gl_vector1ui_alloc( &VB->BIndex, VEC_WRITABLE, VB_SIZE, alignment );
-
-   VB->ClipMask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte) * VB_SIZE, alignment);
-   VB->UserClipMask = (GLubyte *) ALIGN_CALLOC(sizeof(GLubyte) * VB_SIZE, alignment);
-   VB->CullMask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte) * VB_SIZE, alignment);
-   VB->NormCullMask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte) * VB_SIZE, alignment);
-   VB->Spec[0] = (GLubyte (*)[4]) ALIGN_MALLOC(sizeof(GLubyte) * 4 * VB_SIZE, alignment);
-   VB->Spec[1] = (GLubyte (*)[4]) ALIGN_MALLOC(sizeof(GLubyte) * 4 * VB_SIZE, alignment);
-
-   IM = VB->IM = gl_immediate_alloc(ctx);
-      
-   VB->store.Obj = &IM->v.Obj;
-   VB->store.Normal = &IM->v.Normal;
-   VB->store.Color = 0;		/* not used */
-   VB->store.Index = 0;		/* not used */
-   VB->store.EdgeFlag = &IM->v.EdgeFlag;
-   VB->store.TexCoord[0] = &IM->v.TexCoord[0];
-   VB->store.TexCoord[1] = &IM->v.TexCoord[1];
-   VB->store.Elt = &IM->v.Elt;
-      
-   VB->LitColor[0] = VB->FoggedColor[0] = &IM->v.Color;
-   VB->LitColor[1] = VB->FoggedColor[1] = &VB->BColor;
-
-   VB->LitIndex[0] = VB->FoggedIndex[0] = &IM->v.Index;
-   VB->LitIndex[1] = VB->FoggedIndex[1] = &VB->BIndex;
-   
-
-   VB->prev_buffer = IM;
-   /* prev_buffer is now also a reference for the immediate buffer */
-   IM->ref_count++;
-
-   if (ctx->Driver.RegisterVB)
-      ctx->Driver.RegisterVB( VB );
-
-   return VB;
-}
-
-
-
-struct vertex_buffer *gl_vb_create_for_cva( GLcontext *ctx, GLuint size )
-{
-   struct vertex_buffer *VB;
-   GLuint alignment = 32;
-
-   VB = ALIGN_CALLOC_STRUCT( vertex_buffer, alignment );
-   if (!VB) 
-      return 0;
-
-   /* set non-zero fields */
-
-   VB->ctx = ctx;
-   VB->Type = VB_CVA_PRECALC;
-   VB->FirstFree = size;
-   VB->CullDone = 1;
-
-   size += VB_MAX_CLIPPED_VERTS;
-   VB->Size = size;
-   VB->ClipAndMask = CLIP_ALL_BITS;
-   VB->pipeline = &ctx->CVA.pre;
-
-   VB->ClipMask = (GLubyte *)ALIGN_MALLOC( sizeof(GLubyte) * size, alignment );
-   VB->UserClipMask = (GLubyte *)ALIGN_CALLOC( sizeof(GLubyte) * size,
-					       alignment );
-   VB->Spec[0] = (GLubyte (*)[4])ALIGN_MALLOC( sizeof(GLubyte) * 4 * size,
-					       alignment );
-   VB->Spec[1] = (GLubyte (*)[4])ALIGN_MALLOC( sizeof(GLubyte) * 4 * size,
-					       alignment );
-   VB->Flag = (GLuint *)ALIGN_MALLOC( sizeof(GLuint) * size, alignment );
-
-   gl_vector4f_alloc( &VB->Eye, 2, VEC_WRITABLE, size, alignment );
-   gl_vector4f_alloc( &VB->Clip, 2, VEC_WRITABLE, size, alignment );
-   gl_vector4f_alloc( &VB->Win, 2, VEC_WRITABLE, size, alignment );
-
-   VB->store.Obj         = (GLvector4f *)  CALLOC(sizeof(GLvector4f));
-   VB->store.Normal      = (GLvector3f *)  CALLOC(sizeof(GLvector3f));
-   VB->store.Color       = 0;
-   VB->store.Index       = 0;
-   VB->store.EdgeFlag    = (GLvector1ub *) CALLOC(sizeof(GLvector1ub));
-   VB->store.TexCoord[0] = (GLvector4f *)  CALLOC(sizeof(GLvector4f));
-   VB->store.TexCoord[1] = (GLvector4f *)  CALLOC(sizeof(GLvector4f));
-   VB->store.Elt         = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
-   VB->LitColor[0]       = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
-   VB->LitColor[1]       = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
-   VB->LitIndex[0]       = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
-   VB->LitIndex[1]       = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
-   VB->FoggedColor[0]    = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
-   VB->FoggedColor[1]    = (GLvector4ub *) CALLOC(sizeof(GLvector4ub));
-   VB->FoggedIndex[0]    = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
-   VB->FoggedIndex[1]    = (GLvector1ui *) CALLOC(sizeof(GLvector1ui));
-
-   VB->ColorPtr = VB->Color[0] = VB->LitColor[0];
-   VB->IndexPtr = VB->Index[0] = VB->LitIndex[0];
-   VB->Specular = VB->Spec[0];
-   VB->TexCoordPtr[0] = VB->store.TexCoord[0];
-   VB->TexCoordPtr[1] = VB->store.TexCoord[1];
-   VB->EdgeFlagPtr = VB->store.EdgeFlag;
-   VB->NormalPtr = VB->store.Normal;
-   VB->ObjPtr = VB->store.Obj;
-   VB->EltPtr = VB->store.Elt;
-      
-   gl_vector4f_alloc( VB->store.Obj, 2, VEC_WRITABLE, size, alignment );
-   gl_vector3f_alloc( VB->store.Normal, VEC_WRITABLE, size, alignment );
-   gl_vector1ub_alloc( VB->store.EdgeFlag, VEC_WRITABLE, size, alignment );
-   gl_vector4f_alloc( VB->store.TexCoord[0], 2, VEC_WRITABLE, size, alignment );
-   gl_vector4f_alloc( VB->store.TexCoord[1], 2, VEC_WRITABLE, size, alignment );
-
-   /* TODO: allocate these on demand.
-    */
-   gl_vector4ub_alloc( VB->LitColor[0], VEC_WRITABLE, size, alignment );
-   gl_vector4ub_alloc( VB->LitColor[1], VEC_WRITABLE, size, alignment );
-   gl_vector1ui_alloc( VB->LitIndex[0], VEC_WRITABLE, size, alignment );
-   gl_vector1ui_alloc( VB->LitIndex[1], VEC_WRITABLE, size, alignment );
-   gl_vector4ub_alloc( VB->FoggedColor[0], VEC_WRITABLE, size, alignment );
-   gl_vector4ub_alloc( VB->FoggedColor[1], VEC_WRITABLE, size, alignment );
-   gl_vector1ui_alloc( VB->FoggedIndex[0], VEC_WRITABLE, size, alignment );
-   gl_vector1ui_alloc( VB->FoggedIndex[1], VEC_WRITABLE, size, alignment );
-
-
-
-   VB->prev_buffer = 0;
-   VB->Start = 0;
-
-   if (ctx->Driver.RegisterVB)
-      ctx->Driver.RegisterVB( VB );
-
-   return VB;
-}
-
-void gl_vb_free( struct vertex_buffer *VB )
-{
-   gl_vector4f_free( &VB->Eye );
-   gl_vector4f_free( &VB->Clip );
-   gl_vector4f_free( &VB->Win );
-   gl_vector4ub_free( &VB->BColor );
-   gl_vector1ui_free( &VB->BIndex );
-
-   if ( VB->prev_buffer && ! --VB->prev_buffer->ref_count )
-      gl_immediate_free( VB->prev_buffer );
-
-   if (VB->IM) {
-      if ( ! --VB->IM->ref_count )
-	 gl_immediate_free( VB->IM );
-
-      ALIGN_FREE( VB->CullMask );
-      ALIGN_FREE( VB->NormCullMask );
-   } else {
-      gl_vector4f_free( VB->store.Obj );          FREE( VB->store.Obj );
-      gl_vector3f_free( VB->store.Normal );       FREE( VB->store.Normal );
-      gl_vector1ub_free( VB->store.EdgeFlag );    FREE( VB->store.EdgeFlag );
-      gl_vector4f_free( VB->store.TexCoord[0] );  FREE( VB->store.TexCoord[0]);
-      gl_vector4f_free( VB->store.TexCoord[1] );  FREE( VB->store.TexCoord[1]);
-
-      gl_vector4ub_free( VB->LitColor[0] );       FREE( VB->LitColor[0] );
-      gl_vector4ub_free( VB->LitColor[1] );       FREE( VB->LitColor[1] );
-      gl_vector1ui_free( VB->LitIndex[0] );       FREE( VB->LitIndex[0] );
-      gl_vector1ui_free( VB->LitIndex[1] );       FREE( VB->LitIndex[1] );
-
-      gl_vector4ub_free( VB->FoggedColor[0] );    FREE( VB->FoggedColor[0] );
-      gl_vector4ub_free( VB->FoggedColor[1] );    FREE( VB->FoggedColor[1] );
-      gl_vector1ui_free( VB->FoggedIndex[0] );    FREE( VB->FoggedIndex[0] );
-      gl_vector1ui_free( VB->FoggedIndex[1] );    FREE( VB->FoggedIndex[1] );
-
-      ALIGN_FREE( VB->Flag );
-   }
-
-   if (VB->tmp_f) FREE( VB->tmp_f );
-   if (VB->tmp_m) FREE( VB->tmp_m );
-   if (VB->EvaluatedFlags) FREE( VB->EvaluatedFlags );
-
-   ALIGN_FREE( VB->Spec[0] );
-   ALIGN_FREE( VB->Spec[1] );
-   ALIGN_FREE( VB->ClipMask );
-   ALIGN_FREE( VB->UserClipMask );
-
-   if (VB->ctx->Driver.UnregisterVB)
-      VB->ctx->Driver.UnregisterVB( VB );
-
-   ALIGN_FREE( VB );
-}
-
-
-struct immediate *gl_immediate_alloc( GLcontext *ctx )
-{
-   static int id = 0;
-   struct immediate *IM;
-   GLuint j;
-
-   if (ctx->freed_im_queue) {
-      IM = ctx->freed_im_queue;
-      ctx->freed_im_queue = IM->next;
-      ctx->nr_im_queued--; 
-      IM->ref_count = 1;
-      return IM;
-   }
-
-   IM = ALIGN_MALLOC_STRUCT( immediate, 32 );
-   if (!IM)
-      return 0;
-
-   IM->id = id++;
-   IM->ref_count = 1;
-   IM->backref = ctx;
-   IM->maybe_transform_vb = gl_maybe_transform_vb;
-/*     IM->Bounds = 0; */
-   IM->NormalLengths = 0;
-   IM->LastCalcedLength = 0;
-   IM->FlushElt = 0;
-   IM->LastPrimitive = VB_START;
-   IM->Count = VB_MAX;		/* force clear of Flag. */
-   IM->Start = VB_START;	
-   IM->Material = 0;
-   IM->MaterialMask = 0;
-#ifdef VMS
-   for (j = 0; j < VB_SIZE; j++)
-     IM->Normal[j][0] = IM->Normal[j][1] = IM->Normal[j][2] = 0.0;
-#endif
-   
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      fprintf(stderr, "alloc immediate %d\n", id);
-
-   gl_vector4f_init( &IM->v.Obj, VEC_WRITABLE, IM->Obj );
-   gl_vector3f_init( &IM->v.Normal, VEC_WRITABLE, IM->Normal );
-   gl_vector4ub_init( &IM->v.Color, VEC_WRITABLE, IM->Color );
-   gl_vector1ui_init( &IM->v.Index, VEC_WRITABLE, IM->Index );
-   gl_vector1ub_init( &IM->v.EdgeFlag, VEC_WRITABLE, IM->EdgeFlag );
-   gl_vector1ui_init( &IM->v.Elt, VEC_WRITABLE, IM->Elt );
-
-   for (j=0;j<MAX_TEXTURE_UNITS;j++) {
-      IM->TexCoordPtr[j] = IM->TexCoord[j];
-      gl_vector4f_init( &IM->v.TexCoord[j], VEC_WRITABLE, IM->TexCoord[j]);
-
-      /* Precalculate some flags and keep them in a handy place.
-       */
-      IM->TF1[j] = VERT_TEX0_1 << (j*NR_TEXSIZE_BITS);
-      IM->TF2[j] = VERT_TEX0_12 << (j*NR_TEXSIZE_BITS);
-      IM->TF3[j] = VERT_TEX0_123 << (j*NR_TEXSIZE_BITS);
-      IM->TF4[j] = VERT_TEX0_1234 << (j*NR_TEXSIZE_BITS);
-   }
-
-   return IM;
-}
-
-
-void gl_immediate_free( struct immediate *IM )
-{
-   GLcontext *ctx = IM->backref;
-
-   if (IM->NormalLengths) {
-      FREE( IM->NormalLengths );
-      IM->NormalLengths = 0;
-      IM->LastCalcedLength = 0;
-   }
-
-   if (IM->Material) {
-      FREE( IM->Material );
-      FREE( IM->MaterialMask );
-      IM->Material = 0;
-      IM->MaterialMask = 0;
-   }
-
-   if (ctx->nr_im_queued > 5) {
-      if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-	 fprintf(stderr, "really free immediate %d\n", IM->id);
-
-      ALIGN_FREE( IM );
-   }
-   else {
-      if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-	 fprintf(stderr, "requeue immediate %d\n", IM->id);
-
-      IM->next = ctx->freed_im_queue;
-      ctx->freed_im_queue = IM;
-      ctx->nr_im_queued++; 
-   }
-}
Index: xc/extras/Mesa/src/vb.h
diff -u xc/extras/Mesa/src/vb.h:1.4 xc/extras/Mesa/src/vb.h:removed
--- xc/extras/Mesa/src/vb.h:1.4	Mon Nov 13 16:55:35 2000
+++ xc/extras/Mesa/src/vb.h	Thu Feb 27 12:15:45 2003
@@ -1,325 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-/* OVERVIEW: 
- *
- * The vertices between glBegin() and glEnd() are accumulated in the
- * vertex buffer.  When either the vertex buffer becomes filled or a
- * state change outside the glBegin()/glEnd() is made, we must flush
- * the buffer.
- * 
- * That is, we apply the vertex transformations, compute lighting,
- * fog, texture coordinates etc.  Then, we can render the vertices as
- * points, lines or polygons by calling the gl_render_vb() function in
- * render.c
- *
- * When we're outside of a glBegin/glEnd pair the information in this
- * structure is retained pending either of the flushing events
- * described above.  
- */
-
-
-#ifndef VB_H
-#define VB_H
-
-
-#include "glheader.h"
-#include "vector.h"
-#include "matrix.h"
-#include "config.h"
-
-
-enum {
-   VB_IMMEDIATE,
-   VB_CVA_PRECALC
-};
-
-
-
-/* 
- */
-struct vertex_data
-{
-   GLfloat (*Obj)[4];
-   GLfloat (*Normal)[3];
-   GLubyte (*Color)[4];
-   GLuint   *Index;
-   GLubyte  *EdgeFlag;
-   GLfloat (*TexCoord[MAX_TEXTURE_UNITS])[4];
-   GLuint   *Elt;
-};
-
-struct vertex_arrays
-{
-   GLvector4f  Obj;
-   GLvector3f  Normal;
-   GLvector4ub Color;
-   GLvector1ui Index;
-   GLvector1ub EdgeFlag;
-   GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
-   GLvector1ui Elt;     
-};
-
-struct vertex_array_pointers
-{
-   GLvector4f  *Obj;
-   GLvector3f  *Normal;
-   GLvector4ub *Color;
-   GLvector1ui *Index;
-   GLvector1ub *EdgeFlag;
-   GLvector4f  *TexCoord[MAX_TEXTURE_UNITS];
-   GLvector1ui *Elt;     
-};
-
-
-/* Move to using pointers to this struct in the immediate structs -
- * this is too big to keep 94 unused copies (7K) lying around in
- * display lists.  
- */
-struct gl_material 
-{
-   GLfloat Ambient[4];
-   GLfloat Diffuse[4];
-   GLfloat Specular[4];
-   GLfloat Emission[4];
-   GLfloat Shininess;
-   GLfloat AmbientIndex;	/* for color index lighting */
-   GLfloat DiffuseIndex;	/* for color index lighting */
-   GLfloat SpecularIndex;	/* for color index lighting */
-};
-
-
-/* KW: Represents everything that can take place between a begin and
- * end, and can represent multiple begin/end pairs.  This plus *any*
- * state variable (GLcontext) should be all you need to replay the
- * represented begin/end pairs as if they took place in that state.  
- *
- * Thus this is sufficient for both immediate and compiled modes, but
- * we could/should throw some elements away for compiled mode if we
- * know they were empty. 
- */
-struct immediate 
-{ 
-   struct immediate *next;	/* for cache of free IM's */
-   GLuint id, ref_count;
-
-   /* This must be saved when immediates are shared in display lists.
-    */
-   GLuint Start, Count;
-   GLuint LastData;		/* count or count+1 */
-   GLuint AndFlag, OrFlag, BeginState;
-   GLuint LastPrimitive;	
-
-   GLuint ArrayAndFlags;	/* precalc'ed for glArrayElt */
-   GLuint ArrayIncr;
-   GLuint ArrayEltFlush;
-   GLuint FlushElt;
-
-   GLuint TF1[MAX_TEXTURE_UNITS];	/* precalc'ed for glTexCoord */
-   GLuint TF2[MAX_TEXTURE_UNITS];
-   GLuint TF3[MAX_TEXTURE_UNITS];
-   GLuint TF4[MAX_TEXTURE_UNITS];
-
-   GLuint  Primitive[VB_SIZE];	/* GLubyte would do... */
-   GLuint  NextPrimitive[VB_SIZE]; 
-
-   /* allocate storage for these on demand:
-    */
-   struct  gl_material (*Material)[2]; 
-   GLuint  *MaterialMask;       
-
-   GLfloat (*TexCoordPtr[MAX_TEXTURE_UNITS])[4]; 
-
-   struct vertex_arrays v;
-   
-   struct gl_context *backref;		    
-   void (*maybe_transform_vb)( struct immediate * );
-
-   /* Normal lengths, zero if not available.
-    */
-   GLfloat   *NormalLengths;
-   GLuint     LastCalcedLength;
-
-   GLuint  Flag[VB_SIZE];
-   GLubyte Color[VB_SIZE][4];
-   GLfloat Obj[VB_SIZE][4];
-   GLfloat Normal[VB_SIZE][3];
-   GLfloat TexCoord[MAX_TEXTURE_UNITS][VB_SIZE][4];
-   GLuint  Elt[VB_SIZE];
-   GLubyte EdgeFlag[VB_SIZE];
-   GLuint  Index[VB_SIZE];
-};
-
-
-
-
-/* Not so big on storage these days, although still has pointers to
- * arrays used for temporary results.
- */
-struct vertex_buffer
-{
-   /* Pointers to enable multiple vertex_buffers - required for
-    * CVA, should also be useful for the PMesa people.
-    *
-    * Driver_data is alloc'ed in Driver.RegisterVB(), if required.
-    */
-   struct gl_context *ctx;
-   struct gl_pipeline *pipeline;
-   void *driver_data;
-
-
-   /* Data easily accessible by immediate mode fuctions: There is no
-    * guarentee on the driver side that processed data will end up or
-    * even pass through here.  Use the GLvector pointers below.
-    *
-    * If we are not compiling, ctx->input points to this struct, in which
-    * case the values will be scribbled during transform_vb.
-    */
-   struct immediate *IM;	        
-   struct vertex_array_pointers store;	
-
-   /* Where to find outstanding untransformed vertices.
-    */
-   struct immediate *prev_buffer;
-
-
-   GLuint     Type;
-   GLuint     Size, Start, Count;
-   GLuint     Free, FirstFree;
-   GLuint     CopyStart;
-   GLuint     Parity, Ovf;
-   GLuint     PurgeFlags;
-   GLuint     IndirectCount;	/* defaults to count */
-   GLuint     OrFlag, SavedOrFlag;
-   GLuint     EarlyCull;
-   GLuint     Culled, CullDone;
-
-   /* Pointers to input data - default to buffers in 'im' above.
-    */
-   GLvector4f  *ObjPtr;
-   GLvector3f  *NormalPtr;
-   GLvector4ub *ColorPtr;
-   GLvector1ui *IndexPtr;
-   GLvector1ub *EdgeFlagPtr;
-   GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS];
-   GLvector1ui *EltPtr;
-   GLuint      *Flag, FlagMax;
-   struct      gl_material (*Material)[2];
-   GLuint      *MaterialMask;       
-
-   GLuint      *NextPrimitive; 
-   GLuint      *Primitive;     
-   GLuint      LastPrimitive;
-
-   GLfloat (*BoundsPtr)[3];	/* Bounds for cull check */
-   GLfloat  *NormalLengthPtr;	/* Array of precomputed inv. normal lengths */
-   
-
-   /* Holds malloced storage for pipeline data not supplied by 
-    * the immediate struct.
-    */
-   GLvector4f Eye;
-   GLvector4f Clip;
-   GLvector4f Win;
-   GLvector4ub BColor;		/* not used in cva */
-   GLvector1ui BIndex;		/* not used in cva */
-   GLubyte (*Specular)[4];
-   GLubyte (*Spec[2])[4];
-
-   /* Temporary storage - may point into IM, or be dynamically
-    * allocated (for cva).  
-    */
-   GLubyte *ClipMask;
-   GLubyte *UserClipMask;
-   
-   /* Internal values.  Where these point depends on whether
-    * there were any identity matrices defined as transformations
-    * in the pipeline.
-    */
-   GLvector4f *EyePtr;
-   GLvector4f *ClipPtr;
-   GLvector4f *Unprojected;
-   GLvector4f *Projected;
-   GLvector4f *CurrentTexCoord;
-   GLuint     *Indirect;           /* For eval rescue and cva render */
-
-
-   /* Currently active colors
-    */
-   GLvector4ub *Color[2];
-   GLvector1ui *Index[2];
-
-   /* Storage for colors which have been lit but not yet fogged.  
-    * Required for CVA, just point into store for normal VB's.
-    */
-   GLvector4ub *LitColor[2];
-   GLvector1ui *LitIndex[2];
-   GLvector4ub *FoggedColor[2];
-   GLvector1ui *FoggedIndex[2];
-   
-
-   /* Temporary values used in texgen.
-    */
-   GLfloat (*tmp_f)[3];
-   GLfloat *tmp_m;
-
-   /* Temporary values used in eval.
-    */
-   GLuint *EvaluatedFlags;
-
-   /* Not used for cva: 
-    */
-   GLubyte *NormCullStart;
-   GLubyte *CullMask;	        /* Results of vertex culling */
-   GLubyte *NormCullMask;       /* Compressed onto shared normals */
-
-
-   GLubyte ClipOrMask;		/* bitwise-OR of all ClipMask[] values */
-   GLubyte ClipAndMask;		/* bitwise-AND of all ClipMask[] values */
-   GLubyte CullFlag[2];
-   GLubyte CullMode;		/* see flags below */
-
-   GLuint CopyCount;		/* max 3 vertices to copy after transform */
-   GLuint Copy[3];
-   GLfloat CopyProj[3][4];	/* temporary store for projected clip coords */
-};
-
-
-extern struct vertex_buffer *gl_alloc_vb( GLcontext *ctx );
-extern struct immediate *gl_alloc_immediate( GLcontext *ctx );
-extern void gl_free_immediate( struct immediate *im );
-
-extern struct vertex_buffer *gl_vb_create_for_immediate( GLcontext *ctx );
-extern struct vertex_buffer *gl_vb_create_for_cva( GLcontext *ctx, 
-						   GLuint size );
-extern void gl_vb_free( struct vertex_buffer * );
-extern struct immediate *gl_immediate_alloc( GLcontext *ctx );
-extern void gl_immediate_free( struct immediate *im );
-
-
-#endif
-
Index: xc/extras/Mesa/src/vbcull.c
diff -u xc/extras/Mesa/src/vbcull.c:1.7 xc/extras/Mesa/src/vbcull.c:removed
--- xc/extras/Mesa/src/vbcull.c:1.7	Mon Nov 13 18:30:53 2000
+++ xc/extras/Mesa/src/vbcull.c	Thu Feb 27 12:15:45 2003
@@ -1,971 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "macros.h"
-#include "mem.h"
-#include "types.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbrender.h"
-#include "xform.h"
-#endif
-
-
-/* Culling for vertices and primitives.
- * (C) Keith Whitwell, December 1998.
- *
- * These functions build bitmasks which can be used to shortcircuit
- * lighting, fogging and texture calculations, and to convert
- * two-sided lighting into one-sided on a per-vertex basis.
- *
- * Each of these functions returns a value 'cullcount'.  The meaning
- * of this value just has to satisfy the requirements:
- *
- *    cullcount == VB->Count implies the entire vb has been culled and
- *    can be discarded.
- * 
- *    cullcount == 0 implies that every vertex in the buffer is required
- *    and that the cullmask can be ignored for transformation 
- *    and lighting.
- * 
- */
-
-
-const char *gl_prim_name[GL_POLYGON+2] = {
-   "GL_POINTS",
-   "GL_LINES",
-   "GL_LINE_LOOP",
-   "GL_LINE_STRIP",
-   "GL_TRIANGLES",
-   "GL_TRIANGLE_STRIP",
-   "GL_TRIANGLE_FAN",
-   "GL_QUADS",
-   "GL_QUAD_STRIP",
-   "GL_POLYGON",
-   "culled primitive"
-};
-
-static GLuint gl_cull_points( struct vertex_buffer *VB,
-			      GLuint start, 
-			      GLuint count,
-			      GLuint parity,
-			      CONST GLfloat (*proj)[4])
-{
-   const GLubyte *clipmask = VB->ClipMask;
-   GLubyte *cullmask = VB->CullMask;
-   GLuint i, cullcount = 0;
-
-   (void) parity;
-   (void) proj;
-
-   /* This is pretty pointless.  (arf arf)
-    */
-   for (i = start; i < count; i++) {
-      if (clipmask[i] == 0) 
-	 cullmask[i] = VERT_FACE_FRONT | PRIM_FACE_FRONT;
-      else {
-	 cullcount++;
-      }
-   }
-   return cullcount;
-}
-
-
-/* Covers all the non-polygonal primitives when only area culling is
- * activated.
- */
-static GLuint gl_cull_points_neither( struct vertex_buffer *VB,
-				      GLuint start, 
-				      GLuint count,
-				      GLuint parity,
-				      CONST GLfloat (*proj)[4])
-{
-   GLubyte unculled_prim = VERT_FACE_FRONT|PRIM_FACE_FRONT;
-   (void) parity;
-   (void) proj;
-   MEMSET(VB->CullMask+start, unculled_prim, (count-start)*sizeof(GLubyte));
-   return 0;
-}
-
-
-
-#define CULL_LINE( i1, i, nr )						 \
-do {									 \
-   GLubyte ClipOr = VB->ClipMask[i1] | VB->ClipMask[i];			 \
-									 \
-   if (ClipOr) {							 \
-      if (VB->ClipMask[i1] & VB->ClipMask[i] & CLIP_ALL_BITS) {		 \
-	 cullcount+=nr;							 \
-      }									 \
-      else {								 \
-	 cullmask[i1] |= VERT_FACE_FRONT;				 \
-	 cullmask[i] |= VERT_FACE_FRONT | PRIM_FACE_FRONT | PRIM_CLIPPED; \
-      }									 \
-   } else {								 \
-      cullmask[i1] |= VERT_FACE_FRONT;					 \
-      cullmask[i] |= VERT_FACE_FRONT | PRIM_FACE_FRONT;			 \
-   }									 \
-} while (0)
-
-
-
-static GLuint gl_cull_lines( struct vertex_buffer *VB,
-			     GLuint start, 
-			     GLuint count, 
-			     GLuint parity, 
-			     CONST GLfloat (*proj)[4])
-{
-   GLubyte *cullmask = VB->CullMask;
-   GLuint cullcount = 0;
-   GLuint i;
-   GLuint last = count - 1;
-
-   (void) parity;
-   (void) proj;
-
-   for (i = start; i < last ; i += 2) {
-      CULL_LINE(i, i+1, 2);
-   }
-
-   if (i != last)
-      cullcount++;
-
-   return cullcount;
-}
-
-
-static GLuint gl_cull_line_strip( struct vertex_buffer *VB,
-				  GLuint start, 
-				  GLuint count, 
-				  GLuint parity, 
-				  CONST GLfloat (*proj)[4])
-{
-   GLubyte *cullmask = VB->CullMask;
-   GLuint cullcount = 0;
-   GLuint i;
-   GLuint last = count - 1;
-   GLuint nr = 2;
-
-   (void) parity;
-   (void) proj;
-   
-   for (i = start; i < last ; i++, nr = 1) {
-      CULL_LINE(i, i+1, nr);
-   }
-
-   if (i != last)
-      cullcount++;
-
-   return cullcount;
-}
-
-
-static GLuint gl_cull_line_loop( struct vertex_buffer *VB,
-				 GLuint start, 
-				 GLuint count, 
-				 GLuint parity, 
-				 CONST GLfloat (*proj)[4])
-{
-   GLuint cullcount = 0;
-   GLubyte *cullmask = VB->CullMask;
-   GLuint i, last = count - 1;
-   (void) parity;
-   (void) proj;
-   if (count - start < 2) 
-      return count - start;
-
-   for (i = start; i < last ; i++) {
-      CULL_LINE(i, i+1, 1);
-   }
-
-   CULL_LINE(last, start, 1);
-
-   return cullcount;
-}
-
-
-#define CULL_TRI( do_clip, do_area, i2, i1, i0, parity, nr )		\
-do {									\
-   GLubyte ClipOr = 0;							\
-   if (do_clip) {							\
-      ClipOr = (VB->ClipMask[i2] |					\
-		VB->ClipMask[i1] |					\
-		VB->ClipMask[i0]);					\
-   }									\
-									\
-   if (do_clip && (ClipOr&CLIP_ALL_BITS))				\
-   {									\
-      if (VB->ClipMask[i2] & VB->ClipMask[i1] & VB->ClipMask[i0] &	\
-	  CLIP_ALL_BITS)						\
-      {									\
-	 cullcount+=nr;							\
-      }									\
-      else								\
-      {									\
-	 cullmask[i0]   = cull_faces | PRIM_CLIPPED;			\
-	 cullmask[i1] |= cull_faces;					\
-	 cullmask[i2] |= cull_faces;					\
-      }									\
-   }									\
-   else									\
-   {									\
-      GLfloat area;							\
-      GLubyte face_flags;						\
-									\
-      if (do_area) {							\
-	 area = ((proj[i2][0] - proj[i0][0]) *				\
-		 (proj[i1][1] - proj[i0][1]) -				\
-		 (proj[i2][1] - proj[i0][1]) *				\
-		 (proj[i1][0] - proj[i0][0]));				\
-									\
-	 face_flags = (((area<0.0F) ^ parity) + 1) & cull_faces;	\
-      } else {								\
-	 face_flags = cull_faces;					\
-      }									\
-									\
-      if (!do_area || face_flags)					\
-      {									\
-	 cullmask[i0]  = face_flags | (face_flags << PRIM_FLAG_SHIFT);	\
-	 cullmask[i1] |= face_flags;					\
-	 cullmask[i2] |= face_flags;					\
-	 if (do_clip && ClipOr) cullmask[i0] |= PRIM_CLIPPED;		\
-      }									\
-      else								\
-      {									\
-	 cullcount+=nr;							\
-      }									\
-   }									\
-} while (0)
-
-
-
-
-
-#define CULL_QUAD( do_clip, do_area, i3, i2, i1, i, nr )		\
-do {									\
-   GLubyte ClipOr = 0;							\
-									\
-   if (do_clip) {							\
-      ClipOr = (VB->ClipMask[i3] |					\
-		VB->ClipMask[i2] | 					\
-		VB->ClipMask[i1] | 					\
-		VB->ClipMask[i]);					\
-   }									\
-									\
-   if (do_clip && (ClipOr&CLIP_ALL_BITS))				\
-   {									\
-      if (VB->ClipMask[i3] & VB->ClipMask[i2] & 			\
-	  VB->ClipMask[i1] & VB->ClipMask[i] &				\
-	  CLIP_ALL_BITS) 						\
-      {									\
-	 cullcount+=nr;							\
-      }									\
-      else								\
-      {									\
-	 cullmask[i] = cull_faces | PRIM_CLIPPED;			\
-	 cullmask[i1] = cull_faces | PRIM_CLIPPED; 			\
-	 cullmask[i2] |= cull_faces; 			\
-	 cullmask[i3] |= cull_faces; 					\
-      }									\
-   }									\
-   else 								\
-   {									\
-      GLfloat area;							\
-      GLubyte face_flags;						\
-      									\
-      if (do_area) {							\
-	 area = ((proj[i1][0] - proj[i3][0]) * /* ex */			\
-		 (proj[i ][1] - proj[i2][1]) - /* fy */			\
-		 (proj[i1][1] - proj[i3][1]) * /* ey */			\
-		 (proj[i ][0] - proj[i2][0])); /* fx */			\
-	    								\
-	 face_flags = (((area<0.0F) ^ face_bit) + 1) & cull_faces;	\
-      } else {								\
-	 face_flags = cull_faces;					\
-      }									\
-   									\
-      if (do_area && !face_flags)					\
-      {									\
-	 cullcount+=nr;							\
-      }									\
-      else 								\
-      {									\
-	 cullmask[i]  = face_flags | (face_flags<<PRIM_FLAG_SHIFT);	\
-	 cullmask[i1] = face_flags | (face_flags<<PRIM_FLAG_SHIFT);	\
-	 cullmask[i2] |= face_flags;					\
-	 cullmask[i3] |= face_flags;					\
-	 if (ClipOr)							\
-	    cullmask[i] |= PRIM_CLIPPED;				\
-      } 								\
-   }									\
-} while(0)
-
-
-#define DO_AREA 1
-#define DO_CLIP 1
-#define TAG(x) x
-#include "cull_tmp.h"
-
-
-#define DO_AREA 1
-#define DO_CLIP 0
-#define TAG(x) x##_area
-#include "cull_tmp.h"
-
-#define DO_AREA 0
-#define DO_CLIP 1
-#define TAG(x) x##_clip
-#include "cull_tmp.h"
-
-
-
-static GLuint gl_cull_dummy_prim( struct vertex_buffer *VB,
-				  GLuint start, 
-				  GLuint count, 
-				  GLuint parity, 
-				  CONST GLfloat (*proj)[4])
-{
-   (void) VB;
-   (void) parity;
-   (void) proj;
-   return count - start;
-}
-
-
-/* KW:  Force the vertices which are used in both this and the
- * next vertex buffer to be fully transformed on their first 
- * appearance.  Need to do this because otherwise I would have
- * to try to copy the un-transformed (Obj, Normal) data.  This
- * is difficult in the case of shared normals, and seems
- * to be quite complex in the immediate mode case.  For now,
- * just force the copied vertices to be transformed.
- *
- * KW: Copy now organized to grow towards zero.
- */
-static GLuint gl_copy_last_cull( struct vertex_buffer *VB, 
-				 GLuint start, GLuint count,
-				 GLuint ovf, CONST GLfloat (*proj)[4])
-{
-   const GLcontext *ctx = VB->ctx;
-   GLubyte *cullmask = VB->CullMask;
-   GLuint rv = 0;
-   (void) start;
-   (void) ovf;
-   if (cullmask[count-1] == 0) {
-      rv++;
-      cullmask[count-1] = ctx->Polygon.CullBits;
-   }
-   VB->CopyCount = 1;
-   VB->Copy[2] = count-1;
-   COPY_4FV(VB->CopyProj[2], proj[count-1]);
-   return rv;
-}
-
-static GLuint gl_copy_first_and_last_cull( struct vertex_buffer *VB, 
-					   GLuint start, 
-					   GLuint count, GLuint ovf,
-					   CONST GLfloat (*proj)[4] )
-{
-   const GLcontext *ctx = VB->ctx;
-   GLuint rv = 0;
-   GLubyte *cullmask = VB->CullMask;
-   (void) ovf;
-   if (cullmask[count-1] == 0) {
-      rv++;
-      cullmask[count-1] = ctx->Polygon.CullBits;
-   }
-   if (cullmask[start] == 0) {
-      rv++;
-      cullmask[start] = ctx->Polygon.CullBits;
-   }
-   VB->CopyCount = 2;
-   VB->Copy[1] = start;
-   VB->Copy[2] = count-1;
-   COPY_4FV(VB->CopyProj[1], proj[start]);
-   COPY_4FV(VB->CopyProj[2], proj[count-1]);
-   return rv;
-}
-
-/* Must be able to cope with zero or one overflow
- * 
- */
-static GLuint gl_copy_last_two_cull( struct vertex_buffer *VB,
-				     GLuint start, 
-				     GLuint count, GLuint ovf,
-				     CONST GLfloat (*proj)[4] )
-{
-   const GLcontext *ctx = VB->ctx;
-   GLubyte *cullmask = VB->CullMask;
-   GLuint rv = 0;
-   (void) start;
-   if (cullmask[count-1] == 0) {
-      rv++;
-      cullmask[count-1] = ctx->Polygon.CullBits;
-   }
-   if (cullmask[count-2] == 0) {
-      rv++;
-      cullmask[count-2] = ctx->Polygon.CullBits;
-   }
-   
-   VB->CopyCount = 2;
-   VB->Copy[1] = count-2;
-   VB->Copy[2] = count-1;
-   COPY_4FV(VB->CopyProj[1], proj[count-2]);
-   COPY_4FV(VB->CopyProj[2], proj[count-1]);
-
-   if (ovf == 1) {
-      if (cullmask[count-3] == 0) {
-	 rv++;
-	 cullmask[count-3] = ctx->Polygon.CullBits;
-      }
-      VB->CopyCount = 3;
-      VB->Copy[0] = count-3;
-      COPY_4FV(VB->CopyProj[0], proj[count-3]);
-   }
-
-   return rv;
-}
-
-
-/* Eg, quads - just copy the overflow, guarenteed to all be culled.
- */
-static GLuint gl_copy_overflow_cull( struct vertex_buffer *VB, 
-				     GLuint start, GLuint count,
-				     GLuint ovf, CONST GLfloat (*proj)[4] )
-{
-   const GLcontext *ctx = VB->ctx;
-   GLubyte *cullmask = VB->CullMask;
-   GLuint src_offset = count - ovf;
-   GLuint dst_offset = 3 - ovf;
-   GLuint i;
-   (void) start;
-   VB->CopyCount = ovf;
-   for (i = 0 ; i < ovf ; i++) {
-      cullmask[i+src_offset] = ctx->Polygon.CullBits;
-      VB->Copy[i+dst_offset] = i+src_offset;
-      COPY_4FV(VB->CopyProj[i+dst_offset], proj[i+src_offset]);
-   }
-   return ovf;
-}
-
-
-static GLuint gl_copy_last( struct vertex_buffer *VB,
-			    GLuint start, GLuint count,
-			    GLuint ovf, CONST GLfloat (*proj)[4])
-{
-   (void) start;
-   (void) ovf;
-   VB->CopyCount = 1;
-   VB->Copy[2] = count-1;
-   COPY_4FV(VB->CopyProj[2], proj[count-1]);
-   return 0;
-}
-
-static GLuint gl_copy_first_and_last( struct vertex_buffer *VB, 
-				      GLuint start, 
-				      GLuint count,
-				      GLuint ovf, CONST GLfloat (*proj)[4])
-{
-   (void) ovf;
-   VB->CopyCount = 2;
-   VB->Copy[1] = start;
-   VB->Copy[2] = count-1;
-   COPY_4FV(VB->CopyProj[1], proj[start]);
-   COPY_4FV(VB->CopyProj[2], proj[count-1]);
-   return 0;
-}
-
-static GLuint gl_copy_last_two( struct vertex_buffer *VB, 
-				GLuint start, GLuint count, 
-				GLuint ovf, CONST GLfloat (*proj)[4])
-{
-   (void) start;
-   VB->CopyCount = 2;
-   VB->Copy[1] = count-2;
-   VB->Copy[2] = count-1;
-   COPY_4FV(VB->CopyProj[1], proj[count-2]);
-   COPY_4FV(VB->CopyProj[2], proj[count-1]);
-
-   if (ovf == 1) {
-      VB->CopyCount = 3;
-      VB->Copy[0] = count-3;
-      COPY_4FV(VB->CopyProj[0], proj[count-3]);
-   }
-
-   return 0;
-}
-
-static GLuint gl_copy_overflow( struct vertex_buffer *VB, 
-				GLuint start, 
-				GLuint count,
-				GLuint ovf,
-				CONST GLfloat (*proj)[4] )
-{
-   GLuint src_offset = count - ovf;
-   GLuint dst_offset = 3 - ovf;
-   GLuint i;
-   (void) start;
-   VB->CopyCount = ovf;
-   for (i = 0 ; i < ovf ; i++) {
-      VB->Copy[i+dst_offset] = i+src_offset;
-      COPY_4FV(VB->CopyProj[i+dst_offset], proj[i+src_offset]);
-   }
-
-   return 0;
-}
-
-static void gl_fast_copy_noop( struct vertex_buffer *VB,
-			       GLuint start, GLuint count,
-			       GLuint ovf)
-{
-   (void) start;
-   (void) ovf;
-   (void) VB;
-   (void) count;
-}
-
-static void gl_fast_copy_last( struct vertex_buffer *VB,
-			       GLuint start, GLuint count,
-			       GLuint ovf)
-{
-   (void) start;
-   (void) ovf;
-   VB->CopyCount = 1;
-   VB->Copy[2] = count-1;
-}
-
-static void gl_fast_copy_first_and_last( struct vertex_buffer *VB, 
-					 GLuint start, 
-					 GLuint count,
-					 GLuint ovf)
-{
-   (void) ovf;
-   VB->CopyCount = 2;
-   VB->Copy[1] = start;
-   VB->Copy[2] = count-1;
-}
-
-static void gl_fast_copy_last_two( struct vertex_buffer *VB, 
-				   GLuint start, GLuint count, 
-				   GLuint ovf )
-{
-   (void) start;
-   VB->CopyCount = 2;
-   VB->Copy[1] = count-2;
-   VB->Copy[2] = count-1;
-
-   if (ovf == 1) {
-      VB->CopyCount = 3;
-      VB->Copy[0] = count-3;
-   }
-}
-
-static void gl_fast_copy_overflow( struct vertex_buffer *VB, 
-				   GLuint start, 
-				   GLuint count,
-				   GLuint ovf )
-{
-   GLuint src_offset = count - ovf;
-   GLuint dst_offset = 3 - ovf;
-   GLuint i;
-   (void) start;
-   VB->CopyCount = ovf;
-   for (i = 0 ; i < ovf ; i++) 
-      VB->Copy[i+dst_offset] = i+src_offset;
-}
-
-
-typedef void (*fast_copy_func)( struct vertex_buffer *VB, 
-				GLuint start, 
-				GLuint count,
-				GLuint ovf );
-
-
-
-
-typedef GLuint (*cull_func)( struct vertex_buffer *VB, 
-			     GLuint start,
-			     GLuint count,
-			     GLuint parity,
-			     CONST GLfloat (*proj)[4]);
-
-
-typedef GLuint (*copy_func)( struct vertex_buffer *VB, 
-			     GLuint start, 
-			     GLuint end,
-			     GLuint ovf,
-			     CONST GLfloat (*proj)[4] );
-
-
-
-static cull_func cull_tab_both[GL_POLYGON+2] = 
-{
-   gl_cull_points,
-   gl_cull_lines,
-   gl_cull_line_loop,
-   gl_cull_line_strip,
-   gl_cull_triangles,
-   gl_cull_triangle_strip,
-   gl_cull_triangle_fan,
-   gl_cull_quads,
-   gl_cull_quad_strip,
-   gl_cull_triangle_fan,
-   gl_cull_dummy_prim
-};
-
-static cull_func cull_tab_area[GL_POLYGON+2] = 
-{
-   gl_cull_points_neither,
-   gl_cull_points_neither,
-   gl_cull_points_neither,
-   gl_cull_points_neither,
-   gl_cull_triangles_area,
-   gl_cull_triangle_strip_area,
-   gl_cull_triangle_fan_area,
-   gl_cull_quads_area,
-   gl_cull_quad_strip_area,
-   gl_cull_triangle_fan_area,
-   gl_cull_dummy_prim
-};
-
-static cull_func cull_tab_clip[GL_POLYGON+2] = 
-{
-   gl_cull_points,
-   gl_cull_lines,
-   gl_cull_line_loop,
-   gl_cull_line_strip,
-   gl_cull_triangles_clip,
-   gl_cull_triangle_strip_clip,
-   gl_cull_triangle_fan_clip,
-   gl_cull_quads_clip,
-   gl_cull_quad_strip_clip,
-   gl_cull_triangle_fan_clip,
-   gl_cull_dummy_prim
-};
-
-static cull_func *cull_tab[4] = 
-{
-   0,
-   cull_tab_area,
-   cull_tab_clip,
-   cull_tab_both
-};
-
-
-static copy_func copy_tab_cull[GL_POLYGON+2] = 
-{
-   0,
-   gl_copy_overflow_cull,
-   gl_copy_first_and_last_cull,
-   gl_copy_last_cull,
-   gl_copy_overflow_cull,
-   gl_copy_last_two_cull,
-   gl_copy_first_and_last_cull,
-   gl_copy_overflow_cull,
-   gl_copy_last_two_cull,
-   gl_copy_first_and_last_cull,
-   0,
-};
-
-
-static copy_func copy_tab_no_cull[GL_POLYGON+2] = 
-{
-   0,
-   gl_copy_overflow,
-   gl_copy_first_and_last,
-   gl_copy_last,
-   gl_copy_overflow,
-   gl_copy_last_two,
-   gl_copy_first_and_last,
-   gl_copy_overflow,
-   gl_copy_last_two,
-   gl_copy_first_and_last,
-   0,
-};
-
-
-static fast_copy_func fast_copy_tab[GL_POLYGON+2] = 
-{
-   gl_fast_copy_noop,
-   gl_fast_copy_overflow,
-   gl_fast_copy_first_and_last,
-   gl_fast_copy_last,
-   gl_fast_copy_overflow,
-   gl_fast_copy_last_two,
-   gl_fast_copy_first_and_last,
-   gl_fast_copy_overflow,
-   gl_fast_copy_last_two,
-   gl_fast_copy_first_and_last,
-   gl_fast_copy_noop,
-};
-
-
-
-
-
-/* Do this after (?) primitive fixup on buffers containing unwanted
- * eval coords.  No early culling will be done on these vertices (it's
- * a degenerate case & not worth the code), and the vertices will be
- * rendered by a special 'indirect' case in gl_render_vb.  Otherwise,
- * the cullmask will force (some) transforms to skip these vertices.
- */
-void gl_purge_vertices( struct vertex_buffer *VB )
-{
-   GLuint *flags = VB->Flag;
-   GLubyte *cullmask = VB->CullMask;
-   GLuint *indirect = VB->Indirect = VB->EltPtr->start;
-   GLuint *in_prim = VB->Primitive;
-   GLuint *out_prim = VB->IM->Primitive;
-   GLuint *in_nextprim = VB->NextPrimitive;
-   GLuint *out_nextprim = VB->IM->NextPrimitive;
-   GLuint count = VB->Count;
-   GLuint purge = VB->PurgeFlags;
-   GLuint next, start;
-   GLuint j;
-
-   /*
-    */
-   for ( j = start = VB->CopyStart ; start < count ; start = next ) {
-      GLuint startj = j;
-      GLuint i;
-
-      next = in_nextprim[start]; 
-      out_prim[j] = in_prim[start];
-
-      for ( i = start ; i < next ; i++) {
-	 if (~(flags[i] & purge)) {
-	    indirect[j] = i;
-	    cullmask[i] = PRIM_CLIPPED;	/* nonzero */
-	    j++;
-	 }
-	 
-      }
-
-      out_nextprim[startj] = j;
-   }
-   
-   VB->Primitive = out_prim;
-   VB->NextPrimitive = out_nextprim;
-   VB->IndirectCount = j;
-}
-
-#define VERT_NOT_CLIPPED 0x80
-
-
-static void build_clip_vert_bits( GLubyte *clipmask, const GLubyte *cullmask,
-				  GLuint count )
-{
-   GLuint i = 0;
-   for (;;)
-      if (cullmask[++i]==0) {
-	 clipmask[i] |= CLIP_CULLED_BIT;
-	 if (&cullmask[i] == &cullmask[count]) return;
-      }
-}
-
-GLuint gl_cull_vb( struct vertex_buffer *VB )
-{
-   const GLcontext *ctx = VB->ctx;
-   GLuint i, next, prim = 0xffffffff, n;
-   GLfloat (*proj)[4] = VB->Projected->data;
-   GLuint *in_prim = VB->Primitive;
-   GLuint *out_prim = VB->IM->Primitive;
-   GLuint cullcount = 0;
-   GLuint lastprim = in_prim[VB->LastPrimitive];
-   GLuint first = VB->CopyStart;
-   GLuint parity = VB->Parity;
-   cull_func *cull_funcs;
-   GLuint idx = 0;
-
-   if (VB->CullDone)
-      return 0;
-
-   if (VB->ClipOrMask)
-      idx |= 0x2;
-
-   if (ctx->IndirectTriangles & DD_ANY_CULL)
-      idx |= 0x1;
-   
-   cull_funcs = cull_tab[idx];
-
-   for (i = VB->CopyStart ; i < VB->Start ; i++) {
-      COPY_4FV(proj[i], VB->CopyProj[i]);
-   }
-
-   VB->CopyCount = 0;
-
-   MEMSET(VB->CullMask, 0, (VB->Count+1) * sizeof(GLubyte));
-
-   for ( i = VB->CopyStart ; i < VB->Count ; i = next, parity = 0 ) 
-   {
-      first = i;
-      next = VB->NextPrimitive[i];
-      prim = in_prim[i];
-      n = cull_funcs[prim]( VB, i, next, parity, (CONST GLfloat (*)[4])proj );
-
-      if (n == next - i)
-	 out_prim[i] = GL_POLYGON+1; 
-      else 
-	 out_prim[i] = prim;
-
-      cullcount += n;
-   }
-
-   if (VB->LastPrimitive <  VB->Count) {
-      if (copy_tab_cull[lastprim]) 
-	 cullcount -= copy_tab_cull[prim]( VB, 
-					   first, 
-					   VB->Count, 
-					   VB->Ovf, 
-					   (CONST GLfloat (*)[4])proj );     
-   }
-
-   VB->Primitive = out_prim;
-   
-   VB->CullFlag[0] = VB->CullFlag[1] = (GLubyte) 0;
-
-   if (cullcount > 0 || (ctx->IndirectTriangles & DD_LIGHTING_CULL)) {
-      VB->CullMode |= CULL_MASK_ACTIVE;
-      VB->CullFlag[0] = VB->CullFlag[1] = CLIP_CULLED_BIT&ctx->AllowVertexCull;
-
-      if (cullcount < VB->Count)
-	 build_clip_vert_bits( VB->ClipMask, VB->CullMask, VB->Count );
-   }
-
-   if (VB->ClipOrMask) {
-      VB->CullMode |= CLIP_MASK_ACTIVE;
-      VB->CullFlag[1] |= (CLIP_ALL_BITS|CLIP_USER_BIT) & ctx->AllowVertexCull; 
-   }
-
-   VB->CullDone = 1;
-   return cullcount;
-}
-
-
-/* Need to set up to copy some vertices at the end of the buffer, even
- * if culling is disabled or the entire vb has been culled by clipping.
- */
-void gl_dont_cull_vb( struct vertex_buffer *VB )
-{
-   GLfloat (*proj)[4] = VB->Projected->data;
-   GLuint i;
-
-   if (VB->CullDone)
-      return;
-
-   for (i = VB->CopyStart ; i < VB->Start ; i++) 
-      COPY_4FV(proj[i], VB->CopyProj[i]);
-   
-   VB->CopyCount = 0;
-
-   if (VB->LastPrimitive < VB->Count) 
-   {
-      GLuint first = VB->LastPrimitive;
-      GLuint prim = VB->Primitive[first];
-
-      if (first == VB_START)
-	 first = VB->Start;
-
-      if (copy_tab_no_cull[prim]) 
-	 copy_tab_no_cull[prim]( VB, 
-				 first, 
-				 VB->Count, 
-				 VB->Ovf,
-				 (CONST GLfloat (*)[4])proj );
-   }
-
-   VB->CullDone = 1;
-}
-
-void gl_fast_copy_vb( struct vertex_buffer *VB )
-{
-   VB->CopyCount = 0;
-
-   if (VB->LastPrimitive < VB->Count) 
-   {
-      GLuint first = VB->LastPrimitive;
-      GLuint prim = VB->Primitive[first];
-
-      if (first == VB_START) 
-	 first = VB->Start;
-
-      fast_copy_tab[prim]( VB, first, VB->Count, VB->Ovf );
-   }
-
-   VB->CullDone = 1;
-}
-
-
-
-
-
-void gl_make_normal_cullmask( struct vertex_buffer *VB )
-{
-   GLuint i;
-
-   if (VB->CullMode & COMPACTED_NORMALS) {
-      /* The shared normals case - never for cva.
-       */
-      MEMSET(VB->NormCullMask, 0, VB->Count * sizeof(GLubyte));      
-      VB->NormCullStart = VB->NormCullMask + VB->Start;
-
-      if (VB->CullMode & CULL_MASK_ACTIVE) {
-	 GLubyte *lastnorm = VB->NormCullStart;
-
-	 for (i = VB->Start ;;) {
-	    *lastnorm |= VB->CullMask[i];
-	    if (VB->Flag[++i] & (VERT_NORM|VERT_END_VB)) {
-	       lastnorm = &VB->NormCullMask[i];
-	       if (VB->Flag[i] & VERT_END_VB) return;
-	    }
-	 }
-      } else {
-	 VB->NormCullMask[VB->Start] = ~0;
-	 for (i = VB->Start ;; ) 
-	    if (VB->Flag[++i] & (VERT_NORM|VERT_END_VB)) {
-	       VB->NormCullMask[i] = ~0;
-	       if (VB->Flag[i] & VERT_END_VB) return;
-	    }
-      }
-   } else  {
-      /*  Non-shared normals.
-       */
-      VB->NormCullStart = VB->CullMask + VB->Start;      
-   }   
-}
-
-
-
-
Index: xc/extras/Mesa/src/vbcull.h
diff -u xc/extras/Mesa/src/vbcull.h:1.4 xc/extras/Mesa/src/vbcull.h:removed
--- xc/extras/Mesa/src/vbcull.h:1.4	Fri Jun 16 20:02:18 2000
+++ xc/extras/Mesa/src/vbcull.h	Thu Feb 27 12:15:45 2003
@@ -1,46 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef VCULL_H
-#define VCULL_H
-
-
-#include "types.h"
-
-
-extern const char *gl_prim_name[GL_POLYGON+2];
-
-extern GLuint gl_cull_vb( struct vertex_buffer *VB );
-
-extern void gl_dont_cull_vb( struct vertex_buffer *VB );
-
-extern void gl_fast_copy_vb( struct vertex_buffer *VB );
-
-extern void gl_make_normal_cullmask( struct vertex_buffer *VB );
-
-extern void gl_purge_vertices( struct vertex_buffer *VB );
-
-#endif
Index: xc/extras/Mesa/src/vbfill.c
diff -u xc/extras/Mesa/src/vbfill.c:1.7 xc/extras/Mesa/src/vbfill.c:removed
--- xc/extras/Mesa/src/vbfill.c:1.7	Mon Nov 13 18:30:54 2000
+++ xc/extras/Mesa/src/vbfill.c	Thu Feb 27 12:15:45 2003
@@ -1,1702 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "enums.h"
-#include "light.h"
-#include "macros.h"
-#include "matrix.h"
-#include "mmath.h"
-#include "state.h"
-#include "types.h"
-#include "varray.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbfill.h"
-#include "vbrender.h"
-#include "vbxform.h"
-#include "xform.h"
-#endif
-
-
-
-/* KW: The work of most of the functions which were in this file are
- *     now done directly by the GLVertex, GLTexCoord, GLIndex, ...,
- *     functions in api{1,2}.c.  This is made possible by the fact
- *     that display lists and vertex buffers are now built the same
- *     way, so there is no need for the indirection and overhead of a
- *     function pointer.  
- */
-
-
-void
-_mesa_Begin( GLenum mode )
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (mode > GL_POLYGON) {
-      gl_compile_error( ctx, GL_INVALID_ENUM, "glBegin" );
-      return;		     
-   }
-
-   gl_Begin(ctx, mode);
-}
-
-
-void
-gl_Begin( GLcontext *ctx, GLenum p )
-{
-   struct immediate *IM = ctx->input;
-   GLuint inflags, state;
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glBegin(IM %d) %s\n", IM->id, gl_lookup_enum_by_nr(p));
-   
-   if (ctx->NewState) 
-      gl_update_state( ctx );	/* should already be flushed */
-       
-   /* if only a very few slots left, might as well flush now
-    */
-   if (IM->Count > VB_MAX-4) {	      
-      IM->maybe_transform_vb( IM );
-      IM = ctx->input;
-   }
-
-   state = IM->BeginState;
-   inflags = state & (VERT_BEGIN_0|VERT_BEGIN_1);
-   state |= inflags << 2;	/* set error conditions */
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "in gl_Begin(IM %d), BeginState is %x, errors %x", 
-	      IM->id,
-	      state,
-	      inflags<<2);
-
-   if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
-   {
-      GLuint count = IM->Count;
-      GLuint last = IM->LastPrimitive;
-
-      state |= (VERT_BEGIN_0|VERT_BEGIN_1);
-      IM->Flag[count] |= VERT_BEGIN; 
-      IM->Primitive[count] = p;
-
-      IM->NextPrimitive[IM->LastPrimitive] = count;
-      IM->LastPrimitive = count;
-
-      if (IM->FlushElt) {
-	 gl_exec_array_elements( ctx, IM, last, count );
-	 IM->FlushElt = 0;
-      }
-   }
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "in gl_Begin final state %x\n", state);
-
-   IM->BeginState = state;
-}
-
-
-
-/* KW: Both streams now go to the outside-begin-end state.  Raise
- *     errors for either stream if it was not in the inside state.
- */
-void
-_mesa_End(void)
-{
-   GLuint state;
-   GLuint inflags;
-   GET_IMMEDIATE;
-
-
-   state = IM->BeginState;
-   inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
-   state |= inflags << 2;	/* errors */
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "glEnd(IM %d), BeginState is %x, errors %x\n", 
-	      IM->id, state,
-	      inflags<<2);
-
-   
-   if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
-   {
-      GLuint count = IM->Count;
-      GLuint last = IM->LastPrimitive;
-
-      state &= ~(VERT_BEGIN_0|VERT_BEGIN_1); /* update state */
-      IM->Flag[count] |= VERT_END;
-      IM->NextPrimitive[IM->LastPrimitive] = count;
-      IM->LastPrimitive = count;
-      IM->Primitive[count] = GL_POLYGON+1;
-
-      if (IM->FlushElt) {
-	 gl_exec_array_elements( IM->backref, IM, last, count );
-	 IM->FlushElt = 0;
-      }
-   }
-   
-   if (MESA_VERBOSE&VERBOSE_API)
-      fprintf(stderr, "in glEnd final state %x\n", state);
-
-   IM->BeginState = state;      
-
-   if ((MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH))
-      IM->maybe_transform_vb( IM );
-}
-
-
-void
-gl_End( GLcontext *ctx )
-{
-   struct immediate *IM = ctx->input;
-   GLuint state = IM->BeginState;
-   GLuint inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
-
-   state |= inflags << 2;	/* errors */
-
-   if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
-   {
-      GLuint count = IM->Count;
-      GLuint last = IM->LastPrimitive;
-
-      state &= ~(VERT_BEGIN_0|VERT_BEGIN_1); /* update state */
-      IM->Flag[count] |= VERT_END;
-      IM->NextPrimitive[IM->LastPrimitive] = count;
-      IM->LastPrimitive = count;
-      IM->Primitive[count] = GL_POLYGON+1;
-
-      if (IM->FlushElt) {
-	 gl_exec_array_elements( ctx, IM, last, count );
-	 IM->FlushElt = 0;
-      }
-   }
-
-   IM->BeginState = state;      
-
-   /* You can set this flag to get the old 'flush vb on glEnd()'
-    * behaviour.
-    */
-   if ((MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH))
-      IM->maybe_transform_vb( IM );
-}
-
-
-
-
-
-/* KW: Again, a stateless implementation of these functions.  The big
- * news here is the impact on color material.  This was previously
- * handled by swaping the function pointers that these API's used to
- * call.  This is no longer possible, and we have to pick up the
- * pieces later on and make them work with either color-color, or
- * color-material.
- *
- * But in truth, this is not a bad thing, because it was necessary
- * to implement that mechanism to get good performance from
- * color-material and vertex arrays.  
- */
-#define COLOR( IM, r, g, b, a )			\
-{						\
-   GLuint count = IM->Count;			\
-   IM->Flag[count] |= VERT_RGBA;		\
-   IM->Color[count][0] = r;			\
-   IM->Color[count][1] = g;			\
-   IM->Color[count][2] = b;			\
-   IM->Color[count][3] = a;			\
-}
-
-#define COLORV( IM, v )				\
-{						\
-   GLuint count = IM->Count;			\
-   IM->Flag[count] |= VERT_RGBA;		\
-   COPY_4UBV(IM->Color[count], v);		\
-}
-
-
-void
-_mesa_Color3b( GLbyte red, GLbyte green, GLbyte blue )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, BYTE_TO_UBYTE(red), BYTE_TO_UBYTE(green),
-          BYTE_TO_UBYTE(blue), 255 );
-}
-
-
-void
-_mesa_Color3d( GLdouble red, GLdouble green, GLdouble blue )
-{
-   GLubyte col[4];
-   GLfloat r = red;
-   GLfloat g = green;
-   GLfloat b = blue;
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
-   col[3] = 255;
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color3f( GLfloat red, GLfloat green, GLfloat blue )
-{
-   GLubyte col[4];
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], red);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], green);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], blue);
-   col[3] = 255;
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color3i( GLint red, GLint green, GLint blue )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, INT_TO_UBYTE(red), INT_TO_UBYTE(green),
-	  INT_TO_UBYTE(blue), 255);
-}
-
-
-void
-_mesa_Color3s( GLshort red, GLshort green, GLshort blue )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, SHORT_TO_UBYTE(red), SHORT_TO_UBYTE(green),
-	  SHORT_TO_UBYTE(blue), 255);
-}
-
-
-void
-_mesa_Color3ub( GLubyte red, GLubyte green, GLubyte blue )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, red, green, blue, 255 );
-}
-
-
-void
-_mesa_Color3ui( GLuint red, GLuint green, GLuint blue )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, UINT_TO_UBYTE(red), UINT_TO_UBYTE(green),
-	  UINT_TO_UBYTE(blue), 255 );
-}
-
-
-void
-_mesa_Color3us( GLushort red, GLushort green, GLushort blue )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
-	  USHORT_TO_UBYTE(blue), 255 );
-}
-
-
-void
-_mesa_Color4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, BYTE_TO_UBYTE(red), BYTE_TO_UBYTE(green),
-	  BYTE_TO_UBYTE(blue), BYTE_TO_UBYTE(alpha) );
-}
-
-
-void
-_mesa_Color4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
-{
-   GLubyte col[4];
-   GLfloat r = red;
-   GLfloat g = green;
-   GLfloat b = blue;
-   GLfloat a = alpha;
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
-{
-   GLubyte col[4];
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], red);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], green);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], blue);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[3], alpha);
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color4i( GLint red, GLint green, GLint blue, GLint alpha )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, INT_TO_UBYTE(red), INT_TO_UBYTE(green),
-	  INT_TO_UBYTE(blue), INT_TO_UBYTE(alpha) );
-}
-
-
-void
-_mesa_Color4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, SHORT_TO_UBYTE(red), SHORT_TO_UBYTE(green),
-	  SHORT_TO_UBYTE(blue), SHORT_TO_UBYTE(alpha) );
-}
-
-void
-_mesa_Color4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, red, green, blue, alpha );
-}
-
-void
-_mesa_Color4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, UINT_TO_UBYTE(red), UINT_TO_UBYTE(green),
-	  UINT_TO_UBYTE(blue), UINT_TO_UBYTE(alpha) );
-}
-
-void
-_mesa_Color4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
-	  USHORT_TO_UBYTE(blue), USHORT_TO_UBYTE(alpha) );
-}
-
-
-void
-_mesa_Color3bv( const GLbyte *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
-	  BYTE_TO_UBYTE(v[2]), 255 );
-}
-
-
-void
-_mesa_Color3dv( const GLdouble *v )
-{
-   GLubyte col[4];
-   GLfloat r = v[0];
-   GLfloat g = v[1];
-   GLfloat b = v[2];
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
-   col[3]= 255;
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color3fv( const GLfloat *v )
-{
-   GLubyte col[4];
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], v[0]);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], v[1]);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], v[2]);
-   col[3] = 255;
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color3iv( const GLint *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
-	  INT_TO_UBYTE(v[2]), 255 );
-}
-
-
-void
-_mesa_Color3sv( const GLshort *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
-	  SHORT_TO_UBYTE(v[2]), 255 );
-}
-
-
-void
-_mesa_Color3ubv( const GLubyte *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, v[0], v[1], v[2], 255 );
-}
-
-
-void
-_mesa_Color3uiv( const GLuint *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
-	  UINT_TO_UBYTE(v[2]), 255 );
-}
-
-
-void
-_mesa_Color3usv( const GLushort *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
-	  USHORT_TO_UBYTE(v[2]), 255 );
-
-}
-
-
-void
-_mesa_Color4bv( const GLbyte *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
-	  BYTE_TO_UBYTE(v[2]), BYTE_TO_UBYTE(v[3]) );
-}
-
-
-void
-_mesa_Color4dv( const GLdouble *v )
-{
-   GLubyte col[4];
-   GLfloat r = v[0];
-   GLfloat g = v[1];
-   GLfloat b = v[2];
-   GLfloat a = v[3];
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color4fv( const GLfloat *v )
-{
-   GLubyte col[4];
-   GET_IMMEDIATE;
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[0], v[0]);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[1], v[1]);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[2], v[2]);
-   FLOAT_COLOR_TO_UBYTE_COLOR(col[3], v[3]);
-   COLORV( IM, col );
-}
-
-
-void
-_mesa_Color4iv( const GLint *v )
-{
-   GET_IMMEDIATE;
-   COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
-	  INT_TO_UBYTE(v[2]), INT_TO_UBYTE(v[3]) );
-}
-
-
-void
-_mesa_Color4sv( const GLshort *v)
-{
-   GET_IMMEDIATE;
-   COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
-	  SHORT_TO_UBYTE(v[2]), SHORT_TO_UBYTE(v[3]) );
-}
-
-
-void
-_mesa_Color4ubv( const GLubyte *v)
-{
-   GET_IMMEDIATE;
-   COLORV( IM, v );
-}
-
-
-void
-_mesa_Color4uiv( const GLuint *v)
-{
-   GET_IMMEDIATE;
-   COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
-	  UINT_TO_UBYTE(v[2]), UINT_TO_UBYTE(v[3]) );
-}
-
-
-void
-_mesa_Color4usv( const GLushort *v)
-{
-   GET_IMMEDIATE;
-   COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
-	  USHORT_TO_UBYTE(v[2]), USHORT_TO_UBYTE(v[3]) );
-}
-
-
-
-
-void
-_mesa_EdgeFlag( GLboolean flag )
-{
-   GLuint count;
-   GET_IMMEDIATE;
-   count = IM->Count;
-   IM->EdgeFlag[count] = flag;
-   IM->Flag[count] |= VERT_EDGE;
-}
-
-
-void
-_mesa_EdgeFlagv( const GLboolean *flag )
-{
-   GLuint count;
-   GET_IMMEDIATE;
-   count = IM->Count;
-   IM->EdgeFlag[count] = *flag;
-   IM->Flag[count] |= VERT_EDGE;
-}
-
-
-
-#define INDEX( c )				\
-{						\
-   GLuint count;				\
-   GET_IMMEDIATE;				\
-   count = IM->Count;				\
-   IM->Index[count] = c;			\
-   IM->Flag[count] |= VERT_INDEX;		\
-}
-
-
-void
-_mesa_Indexd( GLdouble c )
-{
-   INDEX( ( GLuint) (GLint) c );
-}
-
-
-void
-_mesa_Indexf( GLfloat c )
-{
-   INDEX( (GLuint) (GLint) c );
-}
-
-
-void
-_mesa_Indexi( GLint c )
-{
-   INDEX( (GLuint) c );
-}
-
-
-void
-_mesa_Indexs( GLshort c )
-{
-   INDEX( (GLuint) c );
-}
-
-
-void
-_mesa_Indexub( GLubyte c )
-{
-   INDEX( (GLuint) c );
-}
-
-
-void
-_mesa_Indexdv( const GLdouble *c )
-{
-   INDEX( (GLuint) (GLint) *c );
-}
-
-
-void
-_mesa_Indexfv( const GLfloat *c )
-{
-   INDEX( (GLuint) (GLint) *c );
-}
-
-
-void
-_mesa_Indexiv( const GLint *c )
-{
-   INDEX( *c );
-}
-
-
-void
-_mesa_Indexsv( const GLshort *c )
-{
-   INDEX( (GLuint) (GLint) *c );
-}
-
-
-void
-_mesa_Indexubv( const GLubyte *c )
-{
-   INDEX( (GLuint) *c );
-}
-
-
-
-
-
-/* KW: Now that we build buffers for display lists the same way we
- *     fill the vb, we can do the work here without a second function
- *     call.  The Flag member allows the identification of missing
- *     (ie shared) normals.
- */
-#define NORMAL( x, y, z )			\
-{						\
-   GLuint count;				\
-   GLfloat *normal;				\
-   GET_IMMEDIATE;				\
-   count = IM->Count;				\
-   IM->Flag[count] |= VERT_NORM;		\
-   normal = IM->Normal[count];			\
-   ASSIGN_3V(normal, x,y,z);			\
-}
-
-#if defined(USE_IEEE)
-#define NORMALF( x, y, z )					\
-{								\
-   GLuint count;						\
-   GLint *normal;						\
-   GET_IMMEDIATE;						\
-   count = IM->Count;						\
-   IM->Flag[count] |= VERT_NORM;				\
-   normal = (GLint *)IM->Normal[count];				\
-   ASSIGN_3V(normal, *(int*)&(x), *(int*)&(y), *(int*)&(z));	\
-}
-#else
-#define NORMALF NORMAL
-#endif
-
-void
-_mesa_Normal3b( GLbyte nx, GLbyte ny, GLbyte nz )
-{
-   NORMAL( BYTE_TO_FLOAT(nx), BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
-}
-
-
-void
-_mesa_Normal3d( GLdouble nx, GLdouble ny, GLdouble nz )
-{
-   NORMAL(nx, ny, nz);
-}
-
-
-void
-_mesa_Normal3f( GLfloat nx, GLfloat ny, GLfloat nz )
-{
-   NORMALF(nx, ny, nz);
-}
-
-
-void
-_mesa_Normal3i( GLint nx, GLint ny, GLint nz )
-{
-   NORMAL( INT_TO_FLOAT(nx), INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
-}
-
-
-void
-_mesa_Normal3s( GLshort nx, GLshort ny, GLshort nz )
-{
-   NORMAL( SHORT_TO_FLOAT(nx), SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
-}
-
-
-void
-_mesa_Normal3bv( const GLbyte *v )
-{
-   NORMAL( BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
-}
-
-
-void
-_mesa_Normal3dv( const GLdouble *v )
-{
-   NORMAL( v[0], v[1], v[2] );
-}
-
-
-void
-_mesa_Normal3fv( const GLfloat *v )
-{
-   NORMALF( v[0], v[1], v[2] );
-}
-
-
-void
-_mesa_Normal3iv( const GLint *v )
-{
-   NORMAL( INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
-}
-
-
-void
-_mesa_Normal3sv( const GLshort *v )
-{
-   NORMAL( SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
-}
-
-
-
-
-
-#define TEXCOORD1(s)				\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   GET_IMMEDIATE;				\
-   count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0_1;		\
-   tc = IM->TexCoord[0][count];			\
-   ASSIGN_4V(tc,s,0,0,1);			\
-}
-
-#define TEXCOORD2(s,t)				\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   GET_IMMEDIATE;				\
-   count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0_12;		\
-   tc = IM->TexCoord[0][count];			\
-   ASSIGN_4V(tc, s,t,0,1);		        \
-}
-
-#define TEXCOORD3(s,t,u)			\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   GET_IMMEDIATE;				\
-   count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0_123;		\
-   tc = IM->TexCoord[0][count];			\
-   ASSIGN_4V(tc, s,t,u,1);			\
-}
-
-#define TEXCOORD4(s,t,u,v)			\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   GET_IMMEDIATE;				\
-   count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0_1234;		\
-   tc = IM->TexCoord[0][count];			\
-   ASSIGN_4V(tc, s,t,u,v);			\
-}
-
-#if defined(USE_IEEE)
-#define TEXCOORD2F(s,t)				\
-{						\
-   GLuint count;				\
-   GLint *tc;					\
-   GET_IMMEDIATE;				\
-   count = IM->Count;				\
-   IM->Flag[count] |= VERT_TEX0_12;		\
-   tc = (GLint *)IM->TexCoord[0][count];	\
-   *tc = *(int *)&(s);				\
-   *(tc+1) = *(int *)&(t);			\
-   *(tc+2) = 0;					\
-   *(tc+3) = IEEE_ONE;				\
-}
-#else
-#define TEXCOORD2F TEXCOORD2
-#endif
-
-void
-_mesa_TexCoord1d( GLdouble s )
-{
-   TEXCOORD1(s);
-}
-
-
-void
-_mesa_TexCoord1f( GLfloat s )
-{
-   TEXCOORD1(s);
-}
-
-
-void
-_mesa_TexCoord1i( GLint s )
-{
-   TEXCOORD1(s);
-}
-
-
-void
-_mesa_TexCoord1s( GLshort s )
-{
-   TEXCOORD1(s);
-}
-
-
-void
-_mesa_TexCoord2d( GLdouble s, GLdouble t )
-{
-   TEXCOORD2(s,t);
-}
-
-
-void
-_mesa_TexCoord2f( GLfloat s, GLfloat t )
-{
-   TEXCOORD2F(s,t); 
-}
-
-
-void
-_mesa_TexCoord2s( GLshort s, GLshort t )
-{
-   TEXCOORD2(s,t);
-}
-
-
-void
-_mesa_TexCoord2i( GLint s, GLint t )
-{
-   TEXCOORD2(s,t);
-}
-
-
-void
-_mesa_TexCoord3d( GLdouble s, GLdouble t, GLdouble r )
-{
-   TEXCOORD3(s,t,r);
-}
-
-
-void
-_mesa_TexCoord3f( GLfloat s, GLfloat t, GLfloat r )
-{
-   TEXCOORD3(s,t,r);
-}
-
-
-void
-_mesa_TexCoord3i( GLint s, GLint t, GLint r )
-{
-   TEXCOORD3(s,t,r);
-}
-
-
-void
-_mesa_TexCoord3s( GLshort s, GLshort t, GLshort r )
-{
-   TEXCOORD3(s,t,r);
-}
-
-
-void
-_mesa_TexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
-{
-   TEXCOORD4(s,t,r,q)
-}
-
-
-void
-_mesa_TexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
-{
-   TEXCOORD4(s,t,r,q)
-}
-
-
-void
-_mesa_TexCoord4i( GLint s, GLint t, GLint r, GLint q )
-{
-   TEXCOORD4(s,t,r,q)
-}
-
-
-void
-_mesa_TexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
-{
-   TEXCOORD4(s,t,r,q)
-}
-
-
-void
-_mesa_TexCoord1dv( const GLdouble *v )
-{
-   TEXCOORD1(v[0]);
-}
-
-
-void
-_mesa_TexCoord1fv( const GLfloat *v )
-{
-   TEXCOORD1(v[0]);
-}
-
-
-void
-_mesa_TexCoord1iv( const GLint *v )
-{
-   TEXCOORD1(v[0]);
-}
-
-
-void
-_mesa_TexCoord1sv( const GLshort *v )
-{
-   TEXCOORD1(v[0]);
-}
-
-
-void
-_mesa_TexCoord2dv( const GLdouble *v )
-{
-   TEXCOORD2(v[0],v[1]);
-}
-
-
-void
-_mesa_TexCoord2fv( const GLfloat *v )
-{
-   TEXCOORD2F(v[0],v[1]);
-}
-
-
-void
-_mesa_TexCoord2iv( const GLint *v )
-{
-   TEXCOORD2(v[0],v[1]);
-}
-
-
-void
-_mesa_TexCoord2sv( const GLshort *v )
-{
-   TEXCOORD2(v[0],v[1]);
-}
-
-
-void
-_mesa_TexCoord3dv( const GLdouble *v )
-{
-   TEXCOORD2(v[0],v[1]);
-}
-
-
-void
-_mesa_TexCoord3fv( const GLfloat *v )
-{
-   TEXCOORD3(v[0],v[1],v[2]);
-}
-
-
-void
-_mesa_TexCoord3iv( const GLint *v )
-{
-   TEXCOORD3(v[0],v[1],v[2]);
-}
-
-
-void
-_mesa_TexCoord3sv( const GLshort *v )
-{
-   TEXCOORD3(v[0],v[1],v[2]);
-}
-
-
-void
-_mesa_TexCoord4dv( const GLdouble *v )
-{
-   TEXCOORD4(v[0],v[1],v[2],v[3]);
-}
-
-
-void
-_mesa_TexCoord4fv( const GLfloat *v )
-{
-   TEXCOORD4(v[0],v[1],v[2],v[3]);
-}
-
-
-void
-_mesa_TexCoord4iv( const GLint *v )
-{
-   TEXCOORD4(v[0],v[1],v[2],v[3]);
-}
-
-
-void
-_mesa_TexCoord4sv( const GLshort *v )
-{
-   TEXCOORD4(v[0],v[1],v[2],v[3]);
-}
-
-
-
-
-
-/* KW: Run into bad problems in reset_vb/fixup_input if we don't fully pad
- *     the incoming vertices.
- */
-#define VERTEX2(IM, x,y)			\
-{						\
-   GLuint count = IM->Count++;			\
-   GLfloat *dest = IM->Obj[count];		\
-   IM->Flag[count] |= VERT_OBJ_2;		\
-   ASSIGN_4V(dest, x, y, 0, 1);			\
-   if (dest == IM->Obj[VB_MAX-1])		\
-      IM->maybe_transform_vb( IM );		\
-}
-
-#define VERTEX3(IM,x,y,z)			\
-{						\
-   GLuint count = IM->Count++;			\
-   GLfloat *dest = IM->Obj[count];		\
-   IM->Flag[count] |= VERT_OBJ_23;		\
-   ASSIGN_4V(dest, x, y, z, 1);			\
-   if (dest == IM->Obj[VB_MAX-1])		\
-      IM->maybe_transform_vb( IM );		\
-}
-
-#define VERTEX4(IM, x,y,z,w)			\
-{						\
-   GLuint count = IM->Count++;			\
-   GLfloat *dest = IM->Obj[count];		\
-   IM->Flag[count] |= VERT_OBJ_234;		\
-   ASSIGN_4V(dest, x, y, z, w);			\
-   if (dest == IM->Obj[VB_MAX-1])		\
-      IM->maybe_transform_vb( IM );		\
-}
-
-#if defined(USE_IEEE)
-#define VERTEX3F(IM,x,y,z)			\
-{						\
-   GLuint count = IM->Count++;			\
-   GLint *dest = (GLint *)IM->Obj[count];	\
-   IM->Flag[count] |= VERT_OBJ_23;		\
-   dest[0] = *(int *)&(x);			\
-   dest[1] = *(int *)&(y);			\
-   dest[2] = *(int *)&(z);			\
-   dest[3] = IEEE_ONE;				\
-   if (dest == (GLint *)IM->Obj[VB_MAX-1])	\
-      IM->maybe_transform_vb( IM );		\
-}
-#else
-#define VERTEX3F VERTEX3
-#endif
-
-void
-_mesa_Vertex2d( GLdouble x, GLdouble y )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, (GLfloat) x, (GLfloat) y );
-}
-
-
-void
-_mesa_Vertex2f( GLfloat x, GLfloat y )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, *(&x), *(&y) );
-}
-
-
-/* Internal use:
- */
-void
-gl_Vertex2f( GLcontext *ctx, GLfloat x, GLfloat y )
-{
-   struct immediate *im = ctx->input;
-   VERTEX2( im, x, y );
-}
-
-
-void
-_mesa_Vertex2i( GLint x, GLint y )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, (GLfloat) x, (GLfloat) y );
-}
-
-
-void
-_mesa_Vertex2s( GLshort x, GLshort y )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, (GLfloat) x, (GLfloat) y );
-}
-
-
-void
-_mesa_Vertex3d( GLdouble x, GLdouble y, GLdouble z )
-{
-   GET_IMMEDIATE;
-   VERTEX3( IM, (GLfloat) x, (GLfloat) y, (GLfloat) z );
-}
-
-
-void
-_mesa_Vertex3f( GLfloat x, GLfloat y, GLfloat z )
-{
-   GET_IMMEDIATE;
-   VERTEX3F( IM, x, y, z ); 
-}
-
-
-void
-_mesa_Vertex3i( GLint x, GLint y, GLint z )
-{
-   GET_IMMEDIATE;
-   VERTEX3( IM, (GLfloat) x, (GLfloat) y, (GLfloat) z );
-}
-
-
-void
-_mesa_Vertex3s( GLshort x, GLshort y, GLshort z )
-{
-   GET_IMMEDIATE;
-   VERTEX3( IM, (GLfloat) x, (GLfloat) y, (GLfloat) z );
-}
-
-
-void
-_mesa_Vertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
-}
-
-
-void
-_mesa_Vertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, x, y, z, w );
-}
-
-
-void
-_mesa_Vertex4i( GLint x, GLint y, GLint z, GLint w )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
-}
-
-
-void
-_mesa_Vertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w );
-}
-
-
-void
-_mesa_Vertex2dv( const GLdouble *v )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, (GLfloat) v[0], (GLfloat) v[1] );
-}
-
-
-void
-_mesa_Vertex2fv( const GLfloat *v )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, v[0], v[1] );
-}
-
-
-void
-_mesa_Vertex2iv( const GLint *v )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, (GLfloat) v[0], (GLfloat) v[1] );
-}
-
-
-void
-_mesa_Vertex2sv( const GLshort *v )
-{
-   GET_IMMEDIATE;
-   VERTEX2( IM, (GLfloat) v[0], (GLfloat) v[1] );
-}
-
-
-void
-_mesa_Vertex3dv( const GLdouble *v )
-{
-   GET_IMMEDIATE;
-   VERTEX3( IM, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
-}
-
-
-void
-_mesa_Vertex3fv( const GLfloat *v )
-{
-   GET_IMMEDIATE;
-   VERTEX3F( IM, v[0], v[1], v[2] );
-}
-
-
-void
-_mesa_Vertex3iv( const GLint *v )
-{
-   GET_IMMEDIATE;
-   VERTEX3( IM, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
-}
-
-
-void
-_mesa_Vertex3sv( const GLshort *v )
-{
-   GET_IMMEDIATE;
-   VERTEX3( IM, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
-}
-
-
-void
-_mesa_Vertex4dv( const GLdouble *v )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, 
-	    (GLfloat) v[0], (GLfloat) v[1], 
-	    (GLfloat) v[2], (GLfloat) v[3] );
-}
-
-
-void
-_mesa_Vertex4fv( const GLfloat *v )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, v[0], v[1], v[2], v[3] );
-}
-
-
-void
-_mesa_Vertex4iv( const GLint *v )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, 
-	    (GLfloat) v[0], (GLfloat) v[1], 
-	    (GLfloat) v[2], (GLfloat) v[3] );
-}
-
-
-void
-_mesa_Vertex4sv( const GLshort *v )
-{
-   GET_IMMEDIATE;
-   VERTEX4( IM, 
-	    (GLfloat) v[0], (GLfloat) v[1], 
-	    (GLfloat) v[2], (GLfloat) v[3] );
-}
-
-
-
-
-/* KW: Do the check here so that we only have to do a single range
- *     test.  The possible compliance problem with this is that we
- *     will throw out error-producing calls when compiling display
- *     lists.  The solution is to do dispatch on gl_error to call
- *     gl_save_error if compiling.
- */
-
-
-/*
- * GL_ARB_multitexture
- */
-
-#define CHECK_ARB							\
-   if (target >= GL_TEXTURE0_ARB && target <= GL_TEXTURE1_ARB) {	\
-      texSet = target - GL_TEXTURE0_ARB;				\
-   }									\
-   else {								\
-      gl_error(IM->backref, GL_INVALID_ENUM, 				\
-               "glMultiTexCoord(target)");				\
-      return;								\
-   }
-
-
-#define MULTI_TEXCOORD1(s)			\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   count = IM->Count;				\
-   IM->Flag[count] |= IM->TF1[texSet];		\
-   tc = IM->TexCoordPtr[texSet][count];		\
-   ASSIGN_4V(tc, s,0,0,1);			\
-}
-
-
-#define MULTI_TEXCOORD2(s,t)			\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   count = IM->Count;				\
-   IM->Flag[count] |= IM->TF2[texSet];		\
-   tc = IM->TexCoordPtr[texSet][count];		\
-   ASSIGN_4V(tc, s,t,0,1);			\
-}
-
-#define MULTI_TEXCOORD3(s,t,u)			\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   count = IM->Count;				\
-   IM->Flag[count] |= IM->TF3[texSet];		\
-   tc = IM->TexCoordPtr[texSet][count];		\
-   ASSIGN_4V(tc, s,t,u,1);			\
-}
-
-#define MULTI_TEXCOORD4(s,t,u,v)		\
-{						\
-   GLuint count;				\
-   GLfloat *tc;					\
-   count = IM->Count;				\
-   IM->Flag[count] |= IM->TF4[texSet];		\
-   tc = IM->TexCoordPtr[texSet][count];		\
-   ASSIGN_4V(tc, s,t,u,v);			\
-}
-
-#if defined(USE_IEEE)
-#define MULTI_TEXCOORD2F(s,t)			\
-{						\
-   GLuint count;				\
-   GLint *tc;					\
-   count = IM->Count;				\
-   IM->Flag[count] |= IM->TF2[texSet];		\
-   tc = (GLint *)IM->TexCoord[texSet][count];	\
-   tc[0] = *(int *)&(s);			\
-   tc[1] = *(int *)&(t);			\
-   tc[2] = 0;					\
-   tc[3] = IEEE_ONE;				\
-}
-#else
-#define MULTI_TEXCOORD2F MULTI_TEXCOORD2
-#endif
-
-void
-_mesa_MultiTexCoord1dARB(GLenum target, GLdouble s)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( s );
-}
-
-void
-_mesa_MultiTexCoord1dvARB(GLenum target, const GLdouble *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( v[0] );
-}
-
-void
-_mesa_MultiTexCoord1fARB(GLenum target, GLfloat s)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( s );
-}
-
-void
-_mesa_MultiTexCoord1fvARB(GLenum target, const GLfloat *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( v[0] );
-}
-
-void
-_mesa_MultiTexCoord1iARB(GLenum target, GLint s)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( s );
-}
-
-void
-_mesa_MultiTexCoord1ivARB(GLenum target, const GLint *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( v[0] );
-}
-
-void
-_mesa_MultiTexCoord1sARB(GLenum target, GLshort s)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( s );
-}
-
-void
-_mesa_MultiTexCoord1svARB(GLenum target, const GLshort *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD1( v[0] );
-}
-
-void
-_mesa_MultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2( s, t );
-}
-
-void
-_mesa_MultiTexCoord2dvARB(GLenum target, const GLdouble *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2( v[0], v[1] );
-}
-
-void
-_mesa_MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2F( s, t );
-}
-
-void
-_mesa_MultiTexCoord2fvARB(GLenum target, const GLfloat *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2F( v[0], v[1] );
-}
-
-void
-_mesa_MultiTexCoord2iARB(GLenum target, GLint s, GLint t)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2( s, t );
-}
-
-void
-_mesa_MultiTexCoord2ivARB(GLenum target, const GLint *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2( v[0], v[1] );
-}
-
-void
-_mesa_MultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2( s, t );
-}
-
-void
-_mesa_MultiTexCoord2svARB(GLenum target, const GLshort *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD2( v[0], v[1] );
-}
-
-void
-_mesa_MultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( s, t, r );
-}
-
-void
-_mesa_MultiTexCoord3dvARB(GLenum target, const GLdouble *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( v[0], v[1], v[2] );
-}
-
-void
-_mesa_MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( s, t, r );
-}
-
-void
-_mesa_MultiTexCoord3fvARB(GLenum target, const GLfloat *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( v[0], v[1], v[2] );
-}
-
-void
-_mesa_MultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( s, t, r );
-}
-
-void
-_mesa_MultiTexCoord3ivARB(GLenum target, const GLint *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( v[0], v[1], v[2] );
-}
-
-void
-_mesa_MultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( s, t, r );
-}
-
-void
-_mesa_MultiTexCoord3svARB(GLenum target, const GLshort *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD3( v[0], v[1], v[2] );
-}
-
-void
-_mesa_MultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( s, t, r, q );
-}
-
-void
-_mesa_MultiTexCoord4dvARB(GLenum target, const GLdouble *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( v[0], v[1], v[2], v[3] );
-}
-
-void
-_mesa_MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( s, t, r, q );
-}
-
-
-void
-_mesa_MultiTexCoord4fvARB(GLenum target, const GLfloat *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( v[0], v[1], v[2], v[3] );
-}
-
-void
-_mesa_MultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( s, t, r, q );
-}
-
-void
-_mesa_MultiTexCoord4ivARB(GLenum target, const GLint *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( v[0], v[1], v[2], v[3] );
-}
-
-void
-_mesa_MultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( s, t, r, q );
-}
-
-void
-_mesa_MultiTexCoord4svARB(GLenum target, const GLshort *v)
-{
-   GLint texSet;
-   GET_IMMEDIATE;
-   CHECK_ARB
-   MULTI_TEXCOORD4( v[0], v[1], v[2], v[3] );
-}
-
Index: xc/extras/Mesa/src/vbfill.h
diff -u xc/extras/Mesa/src/vbfill.h:1.4 xc/extras/Mesa/src/vbfill.h:removed
--- xc/extras/Mesa/src/vbfill.h:1.4	Fri Jun 16 20:02:19 2000
+++ xc/extras/Mesa/src/vbfill.h	Thu Feb 27 12:15:45 2003
@@ -1,344 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef VBFILL_H
-#define VBFILL_H
-
-
-#include "types.h"
-
-
-extern void gl_Begin( GLcontext *ctx, GLenum p );
-extern void gl_End( GLcontext *ctx );
-extern void gl_Vertex2f( GLcontext *ctx, GLfloat x, GLfloat y );
-
-
-extern void
-_mesa_Begin( GLenum p );
-
-extern void
-_mesa_End( void );
-
-
-
-extern void _mesa_Color3b(GLbyte red, GLbyte green, GLbyte blue);
-
-extern void _mesa_Color3d(GLdouble red, GLdouble green, GLdouble blue);
-
-extern void _mesa_Color3f(GLfloat red, GLfloat green, GLfloat blue);
-
-extern void _mesa_Color3i(GLint red, GLint green, GLint blue);
-
-extern void _mesa_Color3s(GLshort red, GLshort green, GLshort blue);
-
-extern void _mesa_Color3ub(GLubyte red, GLubyte green, GLubyte blue);
-
-extern void _mesa_Color3ui(GLuint red, GLuint green, GLuint blue);
-
-extern void _mesa_Color3us(GLushort red, GLushort green, GLushort blue);
-
-extern void _mesa_Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-
-extern void _mesa_Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-
-extern void _mesa_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-
-extern void _mesa_Color4i(GLint red, GLint green, GLint blue, GLint alpha);
-
-extern void _mesa_Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-
-extern void _mesa_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-
-extern void _mesa_Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-
-extern void _mesa_Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-
-extern void _mesa_Color3bv(const GLbyte *v);
-
-extern void _mesa_Color3dv(const GLdouble *v);
-
-extern void _mesa_Color3fv(const GLfloat *v);
-
-extern void _mesa_Color3iv(const GLint *v);
-
-extern void _mesa_Color3sv(const GLshort *v);
-
-extern void _mesa_Color3ubv(const GLubyte *v);
-
-extern void _mesa_Color3uiv(const GLuint *v);
-
-extern void _mesa_Color3usv(const GLushort *v);
-
-extern void _mesa_Color4bv(const GLbyte *v);
-
-extern void _mesa_Color4dv(const GLdouble *v);
-
-extern void _mesa_Color4fv(const GLfloat *v);
-
-extern void _mesa_Color4iv(const GLint *v);
-
-extern void _mesa_Color4sv(const GLshort *v);
-
-extern void _mesa_Color4ubv(const GLubyte *v);
-
-extern void _mesa_Color4uiv(const GLuint *v);
-
-extern void _mesa_Color4usv(const GLushort *v);
-
-
-
-extern void _mesa_EdgeFlag( GLboolean flag );
-
-extern void _mesa_EdgeFlagv( const GLboolean *flag );
-
-
-
-extern void _mesa_Indexd(GLdouble c);
-
-extern void _mesa_Indexdv(const GLdouble *c);
-
-extern void _mesa_Indexf(GLfloat c);
-
-extern void _mesa_Indexfv(const GLfloat *c);
-
-extern void _mesa_Indexi(GLint c);
-
-extern void _mesa_Indexiv(const GLint *c);
-
-extern void _mesa_Indexs(GLshort c);
-
-extern void _mesa_Indexsv(const GLshort *c);
-
-extern void _mesa_Indexub(GLubyte b);
-
-extern void _mesa_Indexubv(const GLubyte *b);
-
-
-
-extern void _mesa_Normal3b(GLbyte nx, GLbyte ny, GLbyte nz);
-
-extern void _mesa_Normal3bv(const GLbyte *v);
-
-extern void _mesa_Normal3d(GLdouble nx, GLdouble ny, GLdouble nz);
-
-extern void _mesa_Normal3dv(const GLdouble *v);
-
-extern void _mesa_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-
-extern void _mesa_Normal3fv(const GLfloat *v);
-
-extern void _mesa_Normal3i(GLint nx, GLint ny, GLint nz);
-
-extern void _mesa_Normal3iv(const GLint *v);
-
-extern void _mesa_Normal3s(GLshort nx, GLshort ny, GLshort nz);
-
-extern void _mesa_Normal3sv(const GLshort *v);
-
-
-
-extern void _mesa_TexCoord1d(GLdouble s);
-
-extern void _mesa_TexCoord1dv(const GLdouble *v);
-
-extern void _mesa_TexCoord1f(GLfloat s);
-
-extern void _mesa_TexCoord1fv(const GLfloat *v);
-
-extern void _mesa_TexCoord1i(GLint s);
-
-extern void _mesa_TexCoord1iv(const GLint *v);
-
-extern void _mesa_TexCoord1s(GLshort s);
-
-extern void _mesa_TexCoord1sv(const GLshort *v);
-
-extern void _mesa_TexCoord2d(GLdouble s, GLdouble t);
-
-extern void _mesa_TexCoord2dv(const GLdouble *v);
-
-extern void _mesa_TexCoord2f(GLfloat s, GLfloat t);
-
-extern void _mesa_TexCoord2fv(const GLfloat *v);
-
-extern void _mesa_TexCoord2s(GLshort s, GLshort t);
-
-extern void _mesa_TexCoord2sv(const GLshort *v);
-
-extern void _mesa_TexCoord2i(GLint s, GLint t);
-
-extern void _mesa_TexCoord2iv(const GLint *v);
-
-extern void _mesa_TexCoord3d(GLdouble s, GLdouble t, GLdouble r);
-
-extern void _mesa_TexCoord3dv(const GLdouble *v);
-
-extern void _mesa_TexCoord3f(GLfloat s, GLfloat t, GLfloat r);
-
-extern void _mesa_TexCoord3fv(const GLfloat *v);
-
-extern void _mesa_TexCoord3i(GLint s, GLint t, GLint r);
-
-extern void _mesa_TexCoord3iv(const GLint *v);
-
-extern void _mesa_TexCoord3s(GLshort s, GLshort t, GLshort r);
-
-extern void _mesa_TexCoord3sv(const GLshort *v);
-
-extern void _mesa_TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-
-extern void _mesa_TexCoord4dv(const GLdouble *v);
-
-extern void _mesa_TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-
-extern void _mesa_TexCoord4fv(const GLfloat *v);
-
-extern void _mesa_TexCoord4i(GLint s, GLint t, GLint r, GLint q);
-
-extern void _mesa_TexCoord4iv(const GLint *v);
-
-extern void _mesa_TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
-
-extern void _mesa_TexCoord4sv(const GLshort *v);
-
-
-
-extern void _mesa_Vertex2d(GLdouble x, GLdouble y);
-
-extern void _mesa_Vertex2dv(const GLdouble *v);
-
-extern void _mesa_Vertex2f(GLfloat x, GLfloat y);
-
-extern void _mesa_Vertex2fv(const GLfloat *v);
-
-extern void _mesa_Vertex2i(GLint x, GLint y);
-
-extern void _mesa_Vertex2iv(const GLint *v);
-
-extern void _mesa_Vertex2s(GLshort x, GLshort y);
-
-extern void _mesa_Vertex2sv(const GLshort *v);
-
-extern void _mesa_Vertex3d(GLdouble x, GLdouble y, GLdouble z);
-
-extern void _mesa_Vertex3dv(const GLdouble *v);
-
-extern void _mesa_Vertex3f(GLfloat x, GLfloat y, GLfloat z);
-
-extern void _mesa_Vertex3fv(const GLfloat *v);
-
-extern void _mesa_Vertex3i(GLint x, GLint y, GLint z);
-
-extern void _mesa_Vertex3iv(const GLint *v);
-
-extern void _mesa_Vertex3s(GLshort x, GLshort y, GLshort z);
-
-extern void _mesa_Vertex3sv(const GLshort *v);
-
-extern void _mesa_Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-
-extern void _mesa_Vertex4dv(const GLdouble *v);
-
-extern void _mesa_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-
-extern void _mesa_Vertex4fv(const GLfloat *v);
-
-extern void _mesa_Vertex4i(GLint x, GLint y, GLint z, GLint w);
-
-extern void _mesa_Vertex4iv(const GLint *v);
-
-extern void _mesa_Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
-
-extern void _mesa_Vertex4sv(const GLshort *v);
-
-
-
-extern void _mesa_MultiTexCoord1dARB(GLenum target, GLdouble s);
-
-extern void _mesa_MultiTexCoord1dvARB(GLenum target, const GLdouble *v);
-
-extern void _mesa_MultiTexCoord1fARB(GLenum target, GLfloat s);
-
-extern void _mesa_MultiTexCoord1fvARB(GLenum target, const GLfloat *v);
-
-extern void _mesa_MultiTexCoord1iARB(GLenum target, GLint s);
-
-extern void _mesa_MultiTexCoord1ivARB(GLenum target, const GLint *v);
-
-extern void _mesa_MultiTexCoord1sARB(GLenum target, GLshort s);
-
-extern void _mesa_MultiTexCoord1svARB(GLenum target, const GLshort *v);
-
-extern void _mesa_MultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t);
-
-extern void _mesa_MultiTexCoord2dvARB(GLenum target, const GLdouble *v);
-
-extern void _mesa_MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t);
-
-extern void _mesa_MultiTexCoord2fvARB(GLenum target, const GLfloat *v);
-
-extern void _mesa_MultiTexCoord2iARB(GLenum target, GLint s, GLint t);
-
-extern void _mesa_MultiTexCoord2ivARB(GLenum target, const GLint *v);
-
-extern void _mesa_MultiTexCoord2sARB(GLenum target, GLshort s, GLshort t);
-
-extern void _mesa_MultiTexCoord2svARB(GLenum target, const GLshort *v);
-
-extern void _mesa_MultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-
-extern void _mesa_MultiTexCoord3dvARB(GLenum target, const GLdouble *v);
-
-extern void _mesa_MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-
-extern void _mesa_MultiTexCoord3fvARB(GLenum target, const GLfloat *v);
-
-extern void _mesa_MultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r);
-
-extern void _mesa_MultiTexCoord3ivARB(GLenum target, const GLint *v);
-
-extern void _mesa_MultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r);
-
-extern void _mesa_MultiTexCoord3svARB(GLenum target, const GLshort *v);
-
-extern void _mesa_MultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-
-extern void _mesa_MultiTexCoord4dvARB(GLenum target, const GLdouble *v);
-
-extern void _mesa_MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-
-extern void _mesa_MultiTexCoord4fvARB(GLenum target, const GLfloat *v);
-
-extern void _mesa_MultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q);
-
-extern void _mesa_MultiTexCoord4ivARB(GLenum target, const GLint *v);
-
-extern void _mesa_MultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-
-extern void _mesa_MultiTexCoord4svARB(GLenum target, const GLshort *v);
-
-
-#endif
Index: xc/extras/Mesa/src/vbindirect.c
diff -u xc/extras/Mesa/src/vbindirect.c:1.4 xc/extras/Mesa/src/vbindirect.c:removed
--- xc/extras/Mesa/src/vbindirect.c:1.4	Mon Nov 13 18:30:54 2000
+++ xc/extras/Mesa/src/vbindirect.c	Thu Feb 27 12:15:45 2003
@@ -1,395 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "pb.h"
-#include "pipeline.h"
-#include "stages.h"
-#include "types.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbindirect.h"
-#include "vbrender.h"
-#endif
-
-
-
-static struct gl_prim_state next_lines[3] = {
-   { 1, 2, 0, 0, &next_lines[1] },
-   { 1, 2, 1, 0, &next_lines[0] }
-};
-
-static struct gl_prim_state next_line_loop[3] = {
-   { 1, 2, 0, 0, &next_line_loop[1] },
-   { 1, 2, 1, 1, &next_line_loop[1] }
-};
-
-static struct gl_prim_state next_line_strip[3] = {
-   { 1, 2, 0, 0, &next_line_strip[1] },
-   { 1, 2, 1, 0, &next_line_strip[1] }
-};
-
-static struct gl_prim_state next_poly[3] = {
-   { 1, 2, 0, 0, &next_poly[1] },
-   { 1, 2, 0, 0, &next_poly[2] },
-   { 0, 2, 1, 0, &next_poly[2] }
-};
-
-static struct gl_prim_state next_tris[3] = {
-   { 1, 2, 0, 0, &next_tris[1] },
-   { 1, 2, 0, 0, &next_tris[2] },
-   { 1, 2, 1, 0, &next_tris[0] } 
-};
-
-static struct gl_prim_state next_tri_strip0[4] = {
-   { 2, 1, 0, 0, &next_tri_strip0[1] },
-   { 0, 2, 0, 0, &next_tri_strip0[2] },
-   { 2, 1, 1, 0, &next_tri_strip0[3] },
-   { 0, 2, 1, 0, &next_tri_strip0[2] },
-};
-
-static struct gl_prim_state next_tri_strip1[4] = {
-   { 0, 2, 0, 0, &next_tri_strip1[1] },
-   { 2, 1, 0, 0, &next_tri_strip1[2] },
-   { 0, 2, 1, 0, &next_tri_strip1[3] },
-   { 2, 1, 1, 0, &next_tri_strip1[2] },
-};
-
-static struct gl_prim_state next_quads[4] = {
-   { 1, 2, 0, 0, &next_quads[1] },
-   { 2, 1, 0, 0, &next_quads[2] },
-   { 1, 2, 1, 0, &next_quads[3] }, 
-   { 1, 2, 1, 0, &next_quads[0] }
-};
-
-static struct gl_prim_state next_quad_strip[4] = {
-   { 2, 1, 0, 0, &next_quad_strip[1] },
-   { 0, 2, 0, 0, &next_quad_strip[2] },
-   { 2, 1, 1, 0, &next_quad_strip[3] },
-   { 0, 2, 1, 0, &next_quad_strip[2] },
-};
-
-
-
-
-
-
-
-#define INIT(ctx, prim)					\
-do {							\
-   if (ctx->PB->count > 0) gl_flush_pb(ctx);		\
-   if (ctx->PB->primitive != prim) {			\
-      gl_reduced_prim_change( ctx, prim );		\
-   }							\
-} while(0)
-
-
-
-/* Need better driver support for this case.
- */
-static void 
-indexed_render_points( struct vertex_buffer *VB,
-		       const struct gl_prim_state *state,
-		       const GLuint *elt,
-		       GLuint start,
-		       GLuint count )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint i;
-   (void) state;
-   INIT(ctx, GL_POINTS);
-
-   if (VB->ClipOrMask) {
-      const GLubyte *clip = VB->ClipMask;
-      for (i = start ; i < count ; i++) 
-	 if (!clip[elt[i]]) 
-	    ctx->Driver.PointsFunc( ctx, elt[i], elt[i]+1 );
-   } else {
-      for (i = start ; i < count ; i++) 
-	 ctx->Driver.PointsFunc( ctx, elt[i], elt[i]+1 );
-   }
-}
-
-static void 
-indexed_render_lines( struct vertex_buffer *VB,
-		      const struct gl_prim_state *state,
-		      const GLuint *elt,
-		      GLuint start,
-		      GLuint count )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint i;
-
-   INIT(ctx, GL_LINES);
-
-   if (VB->ClipOrMask) {
-      const GLubyte *clip = VB->ClipMask;
-      GLuint prev = 0;
-   
-      for (i = start ; i < count ; i++) {
-	 GLuint curr = elt[i];
-	 if (state->draw) {
-	    if (clip[curr] | clip[prev]) 
-	       gl_render_clipped_line( ctx, prev, curr ); 
-	    else
-	       ctx->Driver.LineFunc( ctx, prev, curr, curr );	 
-         }
-	 prev = curr;	 
-	 state = state->next;
-      }
-      if (state->finish_loop) {
-	 GLuint curr = elt[start];
-	 if (clip[curr] | clip[prev]) 
-	    gl_render_clipped_line( ctx, prev, curr ); 
-	 else
-	    ctx->Driver.LineFunc( ctx, prev, curr, curr );
-      }
-   } else {
-      GLuint prev = 0;
-      for (i = start ; i < count ; i++) {
-	 GLuint curr = elt[i];
-	 if (state->draw) ctx->Driver.LineFunc( ctx, prev, curr, curr ); 
-	 prev = curr;
-	 state = state->next;
-      }
-      if (state->finish_loop) {
-	 GLuint curr = elt[start];
-	 ctx->Driver.LineFunc( ctx, prev, curr, curr );
-      }
-   }      
-}
-
-
-
-static void 
-indexed_render_tris( struct vertex_buffer *VB,
-		     const struct gl_prim_state *state,
-		     const GLuint *elt,
-		     GLuint start,
-		     GLuint count ) 
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint i;
-
-   INIT(ctx, GL_POLYGON);
-
-   if (VB->ClipOrMask) {      
-      GLuint v[3];
-      GLuint vlist[VB_MAX_CLIPPED_VERTS];
-
-      const GLubyte *clip = VB->ClipMask;
-      for (i = start ; i < count ; i++) {
-	 v[2] = elt[i];
-	 if (state->draw) { 
-	    if (clip[v[0]] | clip[v[1]] | clip[v[2]]) {
-	       if (!(clip[v[0]] & clip[v[1]] & clip[v[2]] & CLIP_ALL_BITS)) {
-		  COPY_3V(vlist, v);
-		  gl_render_clipped_triangle( ctx, 3, vlist, vlist[2] );
-	       }
-	    }
-	    else
-	       ctx->TriangleFunc( ctx, v[0], v[1], v[2], v[2] );
-	 }
-	 v[0] = v[state->v0];
-	 v[1] = v[state->v1];
-	 state = state->next;
-      }
-   } else {
-      GLuint v[3];
-      const triangle_func tf = ctx->TriangleFunc;
-
-      for (i = start ; i < count ; i++) {
-	 v[2] = elt[i];
-	 if (state->draw)
-	    tf( ctx, v[0], v[1], v[2], v[2] );
-	 v[0] = v[state->v0];
-	 v[1] = v[state->v1];
-	 state = state->next;
-      }
-   }
-}
-
-
-static void 
-indexed_render_noop( struct vertex_buffer *VB,
-		     const struct gl_prim_state *state,
-		     const GLuint *elt,
-		     GLuint start,
-		     GLuint count ) 
-{
-	(void) VB;
-	(void) state;
-	(void) elt;
-	(void) start;
-	(void) count;
-}
-
-
-typedef void (*indexed_render_func)( struct vertex_buffer *VB,
-				     const struct gl_prim_state *state,
-				     const GLuint *elt,
-				     GLuint start,
-				     GLuint count );
-
-
-indexed_render_func prim_func[GL_POLYGON+2] = {
-   indexed_render_points,
-   indexed_render_lines,
-   indexed_render_lines,
-   indexed_render_lines,
-   indexed_render_tris,
-   indexed_render_tris,
-   indexed_render_tris,
-   indexed_render_tris,
-   indexed_render_tris,
-   indexed_render_tris,
-   indexed_render_noop
-};
-   
-
-CONST struct gl_prim_state *gl_prim_state_machine[GL_POLYGON+2][2] = {
-   { 0, 0 },
-   { next_lines,      next_lines },
-   { next_line_loop,  next_line_loop },
-   { next_line_strip, next_line_strip },
-   { next_tris,       next_tris },
-   { next_tri_strip0, next_tri_strip1 },
-   { next_poly,       next_poly },
-   { next_quads,      next_quads },
-   { next_quad_strip, next_quad_strip },
-   { next_poly,       next_poly },
-};
-
-
-
-
-void gl_render_elts( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   struct vertex_buffer *saved_vb = ctx->VB;
-   GLenum prim = ctx->CVA.elt_mode;
-   GLuint *elt = VB->EltPtr->start;
-   GLuint nr = VB->EltPtr->count;
-   GLuint p = 0;
-
-   gl_import_client_data( VB, ctx->RenderFlags,
-			  (VB->ClipOrMask 
-			   ? VEC_WRITABLE|VEC_GOOD_STRIDE
-			   : VEC_GOOD_STRIDE));
-
-   ctx->VB = VB;
-
-   if (ctx->Driver.RenderStart)
-      ctx->Driver.RenderStart( ctx );
-   
-   do {
-      const struct gl_prim_state *state = gl_prim_state_machine[prim][0];
-      indexed_render_func func = prim_func[prim];
-      
-      func( VB, state, elt, 0, nr );
-
-      if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	 VB->Specular = VB->Spec[0];
-	 VB->ColorPtr = VB->Color[0];
-	 VB->IndexPtr = VB->Index[0];
-      }
-      
-   } while (ctx->Driver.MultipassFunc &&
-	    ctx->Driver.MultipassFunc( VB, ++p ));
-
-   
-   if (ctx->PB->count > 0) 
-      gl_flush_pb(ctx);
-
-   if (ctx->Driver.RenderFinish)
-      ctx->Driver.RenderFinish( ctx );
-
-   ctx->VB = saved_vb;
-}
-
-
-
-void gl_render_vb_indirect( struct vertex_buffer *VB )
-{
-   GLuint i, next, prim;
-   GLuint parity = VB->Parity;
-   GLuint count = VB->Count;
-   const struct gl_prim_state *state;
-   indexed_render_func func;
-   GLcontext *ctx = VB->ctx;
-   struct vertex_buffer *cvaVB = ctx->CVA.VB;
-   struct vertex_buffer *saved_vb = ctx->VB;
-   GLuint p = 0;
-
-   gl_import_client_data( cvaVB, ctx->RenderFlags,
-			  (VB->ClipOrMask 
-			   ? VEC_WRITABLE|VEC_GOOD_STRIDE
-			   : VEC_GOOD_STRIDE));
-
-   ctx->VB = cvaVB;
-
-   if (!VB->CullDone)
-      gl_fast_copy_vb( VB );
-
-   if (/*  ctx->Current.Primitive == GL_POLYGON+1 &&  */ctx->Driver.RenderStart)
-      ctx->Driver.RenderStart( ctx );
-
-   do {
-      for (i = VB->CopyStart ; i < count ; parity = 0, i = next ) {
-	 prim = VB->Primitive[i];
-	 next = VB->NextPrimitive[i];
-
-	 state = gl_prim_state_machine[prim][parity];
-	 func = prim_func[prim];
-      
-	 func( cvaVB, state, VB->EltPtr->data, i, next );
-      
-	 if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	    cvaVB->Specular = cvaVB->Spec[0];
-	    cvaVB->ColorPtr = cvaVB->Color[0];
-	    cvaVB->IndexPtr = cvaVB->Index[0];
-	 }
-      }
-
-   } while (ctx->Driver.MultipassFunc &&
-	    ctx->Driver.MultipassFunc( VB, ++p ));
-
-
-   if (ctx->PB->count > 0) 
-      gl_flush_pb(ctx);
-
-   if (/*  ctx->Current.Primitive == GL_POLYGON+1 &&  */ctx->Driver.RenderFinish)
-      ctx->Driver.RenderFinish( ctx );
-
-   ctx->VB = saved_vb;
-}
Index: xc/extras/Mesa/src/vbindirect.h
diff -u xc/extras/Mesa/src/vbindirect.h:1.3 xc/extras/Mesa/src/vbindirect.h:removed
--- xc/extras/Mesa/src/vbindirect.h:1.3	Tue Feb 15 02:12:42 2000
+++ xc/extras/Mesa/src/vbindirect.h	Thu Feb 27 12:15:45 2003
@@ -1,49 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifndef VBINDIRECT_H
-#define VBINDIRECT_H
-
-
-#include "types.h"
-
-
-extern void gl_render_vb_indirect( struct vertex_buffer *VB );
-
-extern void gl_render_elts( struct vertex_buffer *VB );
-
-/* Drivers may use the state machine in their indirect render funcs.
- */
-extern CONST struct gl_prim_state *gl_prim_state_machine[GL_POLYGON+2][2];
-
-
-
-
-#endif
Index: xc/extras/Mesa/src/vbrender.c
diff -u xc/extras/Mesa/src/vbrender.c:1.10 xc/extras/Mesa/src/vbrender.c:removed
--- xc/extras/Mesa/src/vbrender.c:1.10	Sat Oct 27 23:32:07 2001
+++ xc/extras/Mesa/src/vbrender.c	Thu Feb 27 12:15:45 2003
@@ -1,784 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/vbrender.c,v 1.10 2001/10/28 03:32:07 tsi Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Render points, lines, and polygons.  The only entry point to this
- * file is the gl_render_vb() function.  This function is called after
- * the vertex buffer has filled up or a state change has occurred.
- *
- * This file basically only makes calls to the clipping functions and
- * the point, line and triangle rasterizers via the function pointers.
- *    context->Driver.PointsFunc()
- *    context->Driver.LineFunc()
- *    context->Driver.TriangleFunc()
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "clip.h"
-#include "context.h"
-#include "light.h"
-#include "lines.h"
-#include "macros.h"
-#include "matrix.h"
-#include "pb.h"
-#include "points.h"
-#include "pipeline.h"
-#include "stages.h"
-#include "types.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbrender.h"
-#include "vbindirect.h"
-#include "xform.h"
-#endif
-
-
-/*
- * This file implements rendering of points, lines and polygons defined by
- * vertices in the vertex buffer.
- */
-
-/*
- * Render a line segment from VB[v1] to VB[v2] when either one or both
- * endpoints must be clipped.
- */
-void gl_render_clipped_line( GLcontext *ctx, GLuint v1, GLuint v2 )
-{
-   GLuint pv = v2;
-   struct vertex_buffer *VB = ctx->VB;
-   GLubyte mask = (GLubyte) (VB->ClipMask[v1] | VB->ClipMask[v2]);
-/*     GLubyte andmask = VB->ClipMask[v1] & VB->ClipMask[v2]; */
-
-   if ((ctx->line_clip_tab[VB->ClipPtr->size])( VB, &v1, &v2, mask ))
-      ctx->Driver.LineFunc( ctx, v1, v2, pv );
-}
-
-static INLINE void gl_render_clipped_line2( GLcontext *ctx, 
-					    GLuint v1, GLuint v2 )
-{
-   GLuint pv = v2;
-   struct vertex_buffer *VB = ctx->VB;
-   GLubyte mask = (GLubyte) (VB->ClipMask[v1] | VB->ClipMask[v2]);
-
-   if (!mask || (ctx->line_clip_tab[VB->ClipPtr->size])( VB, &v1, &v2, mask ))
-      ctx->Driver.LineFunc( ctx, v1, v2, pv );
-}
-
-
-
-/*
- * Compute Z offsets for a polygon with plane defined by (A,B,C,D)
- * D is not needed.
- */
-static void offset_polygon( GLcontext *ctx, GLfloat a, GLfloat b, GLfloat c )
-{
-   GLfloat ac, bc, m;
-   GLfloat offset = 0.0F;
-
-   if (c*c > 1e-16) {
-      ac = a / c;
-      bc = b / c;
-      if (ac<0.0F)  ac = -ac;
-      if (bc<0.0F)  bc = -bc;
-      m = MAX2( ac, bc );
-      offset = m * ctx->Polygon.OffsetFactor + ctx->Polygon.OffsetUnits;
-   }
-
-   ctx->PointZoffset   = ctx->Polygon.OffsetPoint ? offset : 0.0F;
-   ctx->LineZoffset    = ctx->Polygon.OffsetLine  ? offset : 0.0F;
-   ctx->PolygonZoffset = ctx->Polygon.OffsetFill  ? offset : 0.0F;
-}
-
-#define FLUSH_PRIM(prim)			\
-do {						\
-   if (ctx->PB->primitive != prim) {		\
-      gl_reduced_prim_change( ctx, prim );	\
-   }						\
-} while(0)
-
-#define FLUSH_POLY(prim)					\
-do {								\
-   if ((ctx->IndirectTriangles & DD_TRI_UNFILLED) == 0) {	\
-      FLUSH_PRIM(prim);						\
-   }								\
-} while(0)
-
-
-/*
- * When glPolygonMode() is used to specify that the front/back rendering
- * mode for polygons is not GL_FILL we end up calling this function.
- */
-static void unfilled_polygon( GLcontext *ctx,
-                              GLuint n, GLuint vlist[],
-                              GLuint pv, GLuint facing )
-{
-   GLenum mode = facing ? ctx->Polygon.BackMode : ctx->Polygon.FrontMode;
-   struct vertex_buffer *VB = ctx->VB;
-   GLubyte *edge_ptr = (GLubyte *)VB->EdgeFlagPtr->data;
-
-   FLUSH_PRIM(mode);
-
-   if (mode==GL_POINT) {
-      GLuint i, j;
-      for (i=0;i<n;i++) {
-         j = vlist[i];
-         if (edge_ptr[j] & 0x3) {
-	    edge_ptr[j] &= ~0x3;
-            (*ctx->Driver.PointsFunc)( ctx, j, j+1 );
-         }
-      }
-   }
-   else if (mode==GL_LINE) {
-      GLuint i, j0, j1;
-
-      /* draw the edges */
-      for (i=0;i<n-1;i++) {
-	 j0 = vlist[i];
-	 j1 = vlist[i+1];
-	
-	 if (edge_ptr[j0] & 0x1) {
-	    edge_ptr[j0] &= ~0x1;
-	    (*ctx->Driver.LineFunc)( ctx, j0, j1, pv );
-	 }
-      }
-      
-      /* last edge is special */
-      j0 = vlist[i];
-      j1 = vlist[0];
-
-      if (edge_ptr[j0] & 0x2) {
-	 edge_ptr[j0] &= ~0x2;
-	 (*ctx->Driver.LineFunc)( ctx, j0, j1, pv );
-      }
-   }
-   else {
-      /* Fill the polygon */
-      GLuint j0, i;
-      j0 = vlist[0];
-      for (i=2;i<n;i++) {
-         (*ctx->Driver.TriangleFunc)( ctx, j0, vlist[i-1], vlist[i], pv );
-      }
-   }
-}
-
-
-
-
-/*
- * Render a polygon in which at least one vertex has to be clipped.
- * Input:  n - number of vertices
- *         vlist - list of vertices in the polygon.
- *                 CCW order = front facing.
- */
-void gl_render_clipped_triangle( GLcontext *ctx, GLuint n, GLuint vlist[], 
-				 GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   GLubyte mask = 0;
-   GLuint i;
-
-   for (i = 0 ; i < n ; i++) 
-      mask |= VB->ClipMask[vlist[i]];
-   
-   n = (ctx->poly_clip_tab[VB->ClipPtr->size])( VB, n, vlist, mask );
-
-   for (i=2;i<n;i++) 
-      ctx->TriangleFunc( ctx, *vlist, vlist[i-1], vlist[i], pv ); 
-}
-
-
-static INLINE void gl_render_clipped_triangle2( GLcontext *ctx, 
-						GLuint v1, GLuint v2, GLuint v3,
-						GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   GLubyte mask = (GLubyte) (VB->ClipMask[v1] | 
-			     VB->ClipMask[v2] | 
-			     VB->ClipMask[v3]);
-   GLuint vlist[VB_MAX_CLIPPED_VERTS];
-   GLuint i, n;
-
-   if (!mask) {
-      ctx->TriangleFunc( ctx, v1, v2, v3, pv ); 
-      return;
-   }
-
-   if (CLIP_ALL_BITS & VB->ClipMask[v1] & VB->ClipMask[v2] & VB->ClipMask[v3]) 
-      return;
-
-   ASSIGN_3V(vlist, v1, v2, v3 );
-   n = (ctx->poly_clip_tab[VB->ClipPtr->size])( VB, 3, vlist, mask );
-
-   for (i=2;i<n;i++) 
-      ctx->TriangleFunc( ctx, *vlist, vlist[i-1], vlist[i], pv ); 
-}
-
-
-static INLINE void gl_render_clipped_quad2( GLcontext *ctx, 
-					    GLuint v1, GLuint v2, GLuint v3,
-					    GLuint v4,
-					    GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   GLubyte mask = (GLubyte) (VB->ClipMask[v1] | 
-			     VB->ClipMask[v2] | 
-			     VB->ClipMask[v3] |
-			     VB->ClipMask[v4]);
-   GLuint vlist[VB_MAX_CLIPPED_VERTS];
-   GLuint i, n;
-
-   if (!mask) {
-      ctx->QuadFunc( ctx, v1, v2, v3, v4, pv ); 
-      return;
-   }
-
-   if (CLIP_ALL_BITS & VB->ClipMask[v1] & 
-       VB->ClipMask[v2] & VB->ClipMask[v3] &
-       VB->ClipMask[v4]) 
-      return;
-
-   ASSIGN_4V(vlist, v1, v2, v3, v4 );
-   n = (ctx->poly_clip_tab[VB->ClipPtr->size])( VB, 4, vlist, mask );
-
-   for (i=2;i<n;i++) 
-      ctx->TriangleFunc( ctx, *vlist, vlist[i-1], vlist[i], pv ); 
-}
-
-
-/* Implements triangle_rendering when (IndirectTriangles & DD_SW_SETUP)
- * is non-zero.
- */
-static void render_triangle( GLcontext *ctx,
-                             GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   GLfloat (*win)[4] = VB->Win.data;
-   GLfloat ex = win[v1][0] - win[v0][0];
-   GLfloat ey = win[v1][1] - win[v0][1];
-   GLfloat fx = win[v2][0] - win[v0][0];
-   GLfloat fy = win[v2][1] - win[v0][1];
-   GLfloat c = ex*fy-ey*fx;
-   GLuint facing;
-   GLuint tricaps;
-
-   if (c * ctx->backface_sign > 0)
-      return;
-
-   facing = (c<0.0F) ^ (ctx->Polygon.FrontFace==GL_CW);
-   tricaps = ctx->TriangleCaps;
-   
-   if (tricaps & DD_TRI_OFFSET) {
-      /* finish computing plane equation of polygon, compute offset */
-      GLfloat fz = win[v2][2] - win[v0][2];
-      GLfloat ez = win[v1][2] - win[v0][2];
-      GLfloat a = ey*fz-ez*fy;
-      GLfloat b = ez*fx-ex*fz;
-      offset_polygon( ctx, a, b, c );
-   }
-
-   if (tricaps & DD_TRI_LIGHT_TWOSIDE) {
-      VB->Specular = VB->Spec[facing];
-      VB->ColorPtr = VB->Color[facing];
-      VB->IndexPtr = VB->Index[facing];
-   }
-
-   if (tricaps & DD_TRI_UNFILLED) {
-      GLuint vlist[3];
-      vlist[0] = v0;
-      vlist[1] = v1;
-      vlist[2] = v2;
-      unfilled_polygon( ctx, 3, vlist, pv, facing );
-   }
-   else {
-      (*ctx->Driver.TriangleFunc)( ctx, v0, v1, v2, pv );
-   }
-
-   if (tricaps & DD_TRI_OFFSET) {
-      /* reset Z offsets now */
-      ctx->PointZoffset   = 0.0;
-      ctx->LineZoffset    = 0.0;
-      ctx->PolygonZoffset = 0.0;
-   }
-}
-
-
-static void null_triangle( GLcontext *ctx,
-			   GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-}
-
-
-/* Implements triangle_rendering when (IndirectTriangles & DD_SW_SETUP)
- * is non-zero.
- */
-static void render_quad( GLcontext *ctx, GLuint v0, GLuint v1,
-                         GLuint v2, GLuint v3, GLuint pv )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   GLfloat (*win)[4] = VB->Win.data;
-   GLfloat ex = win[v2][0] - win[v0][0];
-   GLfloat ey = win[v2][1] - win[v0][1];
-   GLfloat fx = win[v3][0] - win[v1][0];
-   GLfloat fy = win[v3][1] - win[v1][1];
-   GLfloat c = ex*fy-ey*fx;
-   GLuint facing;
-   GLuint tricaps = ctx->TriangleCaps;
-
-   if (c * ctx->backface_sign > 0)
-      return;
-
-   facing = (c<0.0F) ^ (ctx->Polygon.FrontFace==GL_CW);
-
-   if (tricaps & DD_TRI_OFFSET) {
-      GLfloat ez = win[v2][2] - win[v0][2];
-      GLfloat fz = win[v3][2] - win[v1][2];
-      GLfloat a = ey*fz-ez*fy;
-      GLfloat b = ez*fx-ex*fz;
-      offset_polygon( ctx, a, b, c );
-   }
-
-
-   if (tricaps & DD_TRI_LIGHT_TWOSIDE) {
-      VB->Specular = VB->Spec[facing];
-      VB->ColorPtr = VB->Color[facing];
-      VB->IndexPtr = VB->Index[facing];
-   }
-
-
-   /* Render the quad! */
-   if (tricaps & DD_TRI_UNFILLED) {
-      GLuint vlist[4];
-      vlist[0] = v0;
-      vlist[1] = v1;
-      vlist[2] = v2;
-      vlist[3] = v3;
-      unfilled_polygon( ctx, 4, vlist, pv, facing );
-   }
-   else {
-      (*ctx->Driver.QuadFunc)( ctx, v0, v1, v2, v3, pv );
-   }
-
-   if (tricaps & DD_TRI_OFFSET) {
-      /* reset Z offsets now */
-      ctx->PointZoffset   = 0.0;
-      ctx->LineZoffset    = 0.0;
-      ctx->PolygonZoffset = 0.0;
-   }
-}
-
-
-#if 0
-static void null_quad( GLcontext *ctx, GLuint v0, GLuint v1,
-		       GLuint v2, GLuint v3, GLuint pv )
-{
-}
-#endif
-
-
-/*
- * Either the vertex buffer is full (VB->Count==VB_MAX) or glEnd() has been
- * called.  Render the primitives defined by the vertices and reset the
- * buffer.
- *
- * This function won't be called if the device driver implements a
- * RenderVB() function.
- */
-
-#define NEED_EDGEFLAG_SETUP (ctx->TriangleCaps & DD_TRI_UNFILLED)
-
-#define EDGEFLAG_TRI( i2, i1, i, pv, parity)	\
-do {						\
-  eflag[i2] = eflag[i1] = 1; eflag[i] = 2;	\
-} while (0)
-
-#define EDGEFLAG_QUAD( i3, i2, i1, i, pv)		\
-do {							\
-  eflag[i3] = eflag[i2] = eflag[i1] = 1; eflag[i] = 2;	\
-} while (0)
-
-
-#define EDGEFLAG_POLY_TRI_PRE( i2, i1, i, pv)	\
-do {						\
-  eflag[i2] |= (eflag[i2] >> 2) & 1; 		\
-  eflag[i1] |= (eflag[i1] >> 2) & 1; 		\
-  eflag[i] |= (eflag[i] >> 2) & 2;		\
-} while (0)
-
-#define EDGEFLAG_POLY_TRI_POST( i2, i1, i, pv)	\
-do {						\
-  eflag[i2] &= ~(4|1); 		\
-  eflag[i1] &= ~(4|1); 		\
-  eflag[i] &= ~(8|2); 		\
-} while (0)
-
-
-
-/* Culled and possibly clipped primitives.
- */
-#define RENDER_POINTS( start, count )			\
-   (void) cullmask;					\
-   (*ctx->Driver.PointsFunc)( ctx, start, count );
-
-
-#define RENDER_LINE( i1, i )			\
-do {						\
-   const GLubyte flags = cullmask[i];		\
-						\
-   if (!(flags & PRIM_NOT_CULLED))		\
-      continue;					\
-						\
-   if (flags & PRIM_ANY_CLIP)			\
-      gl_render_clipped_line( ctx, i1, i );	\
-   else						\
-      ctx->Driver.LineFunc( ctx, i1, i, i );	\
-} while (0)
-
-
-
-#define RENDER_TRI( i2, i1, i, pv, parity)		\
-do {							\
-   const GLubyte flags = cullmask[i];			\
-							\
-   if (!(flags & PRIM_NOT_CULLED))			\
-      continue;						\
-							\
-   if (flags & PRIM_ANY_CLIP) {				\
-      if (parity) {					\
-	 vlist[0] = i1;					\
-	 vlist[1] = i2;					\
-	 vlist[2] = i;					\
-      } else {						\
-	 vlist[0] = i2;					\
-	 vlist[1] = i1;					\
-	 vlist[2] = i;					\
-      }							\
-      gl_render_clipped_triangle( ctx, 3, vlist, pv );	\
-   } else if (parity) 					\
-      ctx->TriangleFunc( ctx, i1, i2, i, pv );		\
-   else							\
-      ctx->TriangleFunc( ctx, i2, i1, i, pv );		\
-							\
-} while (0)
-
-
-#define RENDER_QUAD( i3, i2, i1, i, pv)			\
-do {							\
-   const GLubyte flags = cullmask[i];			\
-							\
-   if (!(flags & PRIM_NOT_CULLED))			\
-      continue;						\
-							\
-   if (flags&PRIM_ANY_CLIP) {				\
-      vlist[0] = i3;					\
-      vlist[1] = i2;					\
-      vlist[2] = i1;					\
-      vlist[3] = i;					\
-      gl_render_clipped_triangle( ctx, 4, vlist, pv );	\
-   } else						\
-      ctx->QuadFunc( ctx, i3, i2, i1, i, pv );		\
-} while (0)
-
-
-#define LOCAL_VARS				\
-    GLcontext *ctx = VB->ctx;			\
-    const GLubyte *cullmask = VB->CullMask;	\
-    GLuint vlist[VB_SIZE];			\
-    GLubyte *eflag = VB->EdgeFlagPtr->data;    	\
-    GLuint *stipplecounter = &VB->ctx->StippleCounter; \
-    (void) vlist; (void) eflag; (void) stipplecounter;
-
-#define TAG(x) x##_cull
-#define INIT(x)  if (x == GL_POLYGON) FLUSH_POLY(x); else FLUSH_PRIM(x)
-#define RESET_STIPPLE *stipplecounter = 0
-#include "render_tmp.h"
-
-
-
-
-
-
-
-/* Direct, no clipping or culling.
- */
-#define RENDER_POINTS( start, count ) \
-   (*ctx->Driver.PointsFunc)( ctx, start, count )
-
-#define RENDER_LINE( i1, i ) \
-   (*ctx->Driver.LineFunc)( ctx, i1, i, i )
-
-#define RENDER_TRI( i2, i1, i, pv, parity )	\
-do {						\
-   if (parity)					\
-      ctx->TriangleFunc( ctx, i1, i2, i, pv );	\
-   else						\
-      ctx->TriangleFunc( ctx, i2, i1, i, pv );	\
-} while (0)
-
-
-#define RENDER_QUAD( i3, i2, i1, i, pv )	\
-   ctx->QuadFunc( ctx, i3, i2, i1, i, i );
-
-#define TAG(x) x##_raw
-
-#define LOCAL_VARS  				\
-    GLcontext *ctx = VB->ctx;			\
-    GLubyte *eflag = VB->EdgeFlagPtr->data;	\
-    GLuint *stipplecounter = &VB->ctx->StippleCounter; \
-    (void) eflag; (void) stipplecounter;
-
-#define INIT(x)  if (x == GL_POLYGON) FLUSH_POLY(x); else FLUSH_PRIM(x)
-#define RESET_STIPPLE *stipplecounter = 0
-#include "render_tmp.h"
-
-
-
-
-/* Direct, with the possibility of clipping.
- */ 
-#define RENDER_POINTS( start, count )			\
-   (*ctx->Driver.PointsFunc)( ctx, start, count )
-
-#define RENDER_LINE( i1, i )			\
-   gl_render_clipped_line2( ctx, i1, i )
-
-#define RENDER_TRI( i2, i1, i, pv, parity)	\
-do {						\
-  GLuint e2=i2, e1=i1;				\
-  if (parity) { GLuint t=e2; e2=e1; e1=t; }	\
-  gl_render_clipped_triangle2(ctx,e2,e1,i,pv);	\
-} while (0)
-
-#define RENDER_QUAD( i3, i2, i1, i, pv)		\
-do {						\
-  gl_render_clipped_quad2(ctx,i3,i2,i1,i,pv);	\
-} while (0)
-
-
-#define LOCAL_VARS  				\
-    GLcontext *ctx = VB->ctx;			\
-    GLubyte *eflag = VB->EdgeFlagPtr->data;	\
-    GLuint *stipplecounter = &VB->ctx->StippleCounter; \
-    (void) eflag; (void) stipplecounter;
-
-#define INIT(x)  if (x == GL_POLYGON) FLUSH_POLY(x); else FLUSH_PRIM(x)
-#define TAG(x) x##_clipped
-#define RESET_STIPPLE *stipplecounter = 0
-
-#include "render_tmp.h"
-
-/* Bits:
- *    0x1 - draw this edge if it is first or second in a triangle.
- *    0x2 - draw this edge if it is last in a triangle.
- *    0x4 - placeholder for multipass rendering.
- *
- * Bits 0x1 and 0x2 are cleared after they are used.  Bit 0x4 is used
- * to stop these values going to zero in multipass rendering. 
- *
- * Clipping introduces vertices on outgoing edges with edgeflag 0x1.
- * Incoming edges retain the value of the clipped vertex, with the following 
- * masks:
- *    - If the incoming edge originates from the last vertex in the
- *      clipped primitive (triangle or quad), the introduced vertex 
- *      retains both bits (0x3) of the original flag.
- *    - All other introduced vertices retain only bit 1 (0x1).
- *
- * In a horrible hack I've had to push tristrips, fans & quadstrip handling 
- * into render_tmp.h...
- *
- * Keith. 
- */
-static void 
-setup_edgeflag( struct vertex_buffer *VB, 
-                GLenum prim, 
-                GLuint start, 
-                GLuint count,
-                GLuint parity )
-{
-   GLubyte *flag = VB->EdgeFlagPtr->data + start;
-   GLuint n = count - start;
-   GLuint i;
-   (void) parity;
-
-   switch (prim) {
-   case GL_TRIANGLES:
-      for (i = 0 ; i < n-2 ; i+=3) {
-	 if (flag[i])   flag[i]   = 0x1;
-	 if (flag[i+1]) flag[i+1] = 0x1;
-	 if (flag[i+2]) flag[i+2] = 0x3;
-      }
-      break;
-   case GL_QUADS:
-      for (i = 0 ; i < n-3 ; i+=4) {
-	 if (flag[i])   flag[i]   = 0x1;
-	 if (flag[i+1]) flag[i+1] = 0x1;
-	 if (flag[i+2]) flag[i+2] = 0x1;
-	 if (flag[i+3]) flag[i+3] = 0x3;
-      }
-      break;
-   case GL_POLYGON:
-      if (flag[0]) flag[0] = 0x1;
-      for (i = 1 ; i < n-1 ; i++) {
-	 if (flag[i]) flag[i] = 0x4;
-      }
-      if (flag[i]) flag[i] = 0x8;
-      break;
-   default:
-      break;
-   }
-}
-
-
-
-/* Could eventually generalize to handle changes of rasterization
- * state other than change-of-primitive.  An example might be 
- * some bind-texture calls.
- */
-void gl_render_vb( struct vertex_buffer *VB )
-{
-   GLcontext *ctx = VB->ctx;
-   GLuint i, next, prim;
-   GLuint parity = VB->Parity;
-   render_func *tab;
-   GLuint count = VB->Count;
-   GLint p = 0;
-
-   if (VB->Indirect) { 
-/*        gl_render_vb_indirect( VB, VB );   */
-      return; 
-   } else if (VB->CullMode & CULL_MASK_ACTIVE) {
-      tab = ctx->Driver.RenderVBCulledTab;
-   } else if (VB->CullMode & CLIP_MASK_ACTIVE) {
-      tab = ctx->Driver.RenderVBClippedTab;
-   } else {
-      tab = ctx->Driver.RenderVBRawTab;
-   }
-
-   if (!VB->CullDone)
-      gl_fast_copy_vb( VB );
-
-   if (ctx->TriangleCaps & DD_TRI_UNFILLED)
-      gl_import_client_data( VB, VERT_EDGE, VEC_WRITABLE|VEC_GOOD_STRIDE );
-
-   gl_import_client_data( VB, ctx->RenderFlags,
-			  (VB->ClipOrMask
-			   ? VEC_WRITABLE|VEC_GOOD_STRIDE
-			   : VEC_GOOD_STRIDE));
-
-   if (/*  ctx->Current.Primitive == GL_POLYGON+1 &&  */
-      ctx->Driver.RenderStart)
-      ctx->Driver.RenderStart( ctx );
-
-   do
-   {      
-      for ( i= VB->CopyStart ; i < count ; parity = 0, i = next ) 
-      {
-	 prim = VB->Primitive[i];
-	 next = VB->NextPrimitive[i];
-
-	 if (ctx->TriangleCaps & DD_TRI_UNFILLED) 
-	    setup_edgeflag(VB, prim, i, next, parity);
-
-	 tab[prim]( VB, i, next, parity );
-
-	 if (ctx->TriangleCaps & DD_TRI_LIGHT_TWOSIDE) {
-	    VB->Specular = VB->Spec[0];
-	    VB->ColorPtr = VB->Color[0];
-	    VB->IndexPtr = VB->Index[0];
-	 }
-      }
-
-   } while (ctx->Driver.MultipassFunc &&
-	    ctx->Driver.MultipassFunc( VB, ++p ));
-
-   if (ctx->PB->count > 0) 
-      gl_flush_pb(ctx);
-
-   if (/*  ctx->Current.Primitive == GL_POLYGON+1 &&  */
-      ctx->Driver.RenderFinish)
-      ctx->Driver.RenderFinish( ctx );
-}
-
-
-void gl_reduced_prim_change( GLcontext *ctx, GLenum prim )
-{
-   if (ctx->PB->count > 0) 
-      gl_flush_pb(ctx);	
-
-   if (ctx->PB->primitive != prim) {
-      ctx->PB->primitive = prim;			
-
-      if (ctx->Driver.ReducedPrimitiveChange)
-	 ctx->Driver.ReducedPrimitiveChange( ctx, prim );
-   }
-}
-
-
-void gl_set_render_vb_function( GLcontext *ctx )
-{
-   if (ctx->Driver.RenderVBCulledTab == 0)
-      ctx->Driver.RenderVBCulledTab = render_tab_cull;
-
-   if (ctx->Driver.RenderVBClippedTab == 0)
-      ctx->Driver.RenderVBClippedTab = render_tab_clipped;
-
-   if (ctx->Driver.RenderVBRawTab == 0)
-      ctx->Driver.RenderVBRawTab = render_tab_raw;
-
-   ctx->TriangleFunc = ctx->Driver.TriangleFunc;
-   ctx->QuadFunc = ctx->Driver.QuadFunc;
-   ctx->ClippedTriangleFunc = ctx->TriangleFunc;
-
-   if (ctx->IndirectTriangles & DD_SW_SETUP) {
-
-      ctx->ClippedTriangleFunc = render_triangle;
-
-      if (ctx->IndirectTriangles & (DD_SW_SETUP & ~DD_TRI_CULL)) {
-	 if (ctx->IndirectTriangles & DD_TRI_CULL_FRONT_BACK) {
-	    ctx->TriangleFunc = null_triangle;
-	    ctx->QuadFunc = render_quad;
-	    ctx->ClippedTriangleFunc = null_triangle;
-	 } else {
-	    ctx->TriangleFunc = render_triangle;
-	    ctx->QuadFunc = render_quad;
-	 }
-      }
-   }
-}
-
-void gl_init_vbrender( void )
-{
-   render_init_raw();
-   render_init_cull();
-   render_init_clipped();
-}
-
-
-
-
Index: xc/extras/Mesa/src/vbrender.h
diff -u xc/extras/Mesa/src/vbrender.h:1.3 xc/extras/Mesa/src/vbrender.h:removed
--- xc/extras/Mesa/src/vbrender.h:1.3	Tue Feb 15 02:12:42 2000
+++ xc/extras/Mesa/src/vbrender.h	Thu Feb 27 12:15:45 2003
@@ -1,54 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef VBRENDER_H
-#define VBRENDER_H
-
-
-#include "types.h"
-
-
-extern void gl_set_render_vb_function( GLcontext *ctx );
-
-extern void gl_render_vb( struct vertex_buffer *VB );
-
-extern void gl_init_vbrender( void );
-
-
-/* Needed by vbindirect.c:
- */
-extern void gl_render_clipped_triangle( GLcontext *ctx, GLuint n, 
-					GLuint vlist[], 
-					GLuint pv );
-
-extern void gl_render_clipped_line( GLcontext *ctx, GLuint v1, GLuint v2 );
-
-extern void gl_reduced_prim_change( GLcontext *ctx, GLenum prim );
-
-#endif
Index: xc/extras/Mesa/src/vbxform.c
diff -u xc/extras/Mesa/src/vbxform.c:1.8 xc/extras/Mesa/src/vbxform.c:removed
--- xc/extras/Mesa/src/vbxform.c:1.8	Fri May 18 12:59:55 2001
+++ xc/extras/Mesa/src/vbxform.c	Thu Feb 27 12:15:45 2003
@@ -1,1095 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "cva.h"
-#include "clip.h"
-#include "eval.h"
-#include "enums.h"
-#include "dlist.h"
-#include "fog.h"
-#include "light.h"
-#include "macros.h"
-#include "matrix.h"
-#include "mem.h"
-#include "mmath.h"
-#include "pipeline.h"
-#include "shade.h"
-#include "state.h"
-#include "texture.h"
-#include "types.h"
-#include "varray.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbfill.h"
-#include "vbrender.h"
-#include "vbxform.h"
-#include "xform.h"
-#endif
-
-
-void gl_maybe_transform_vb( struct immediate *IM )
-{
-   GLcontext *ctx = IM->backref;
-
-   if (ctx->NewState)
-      gl_update_state(ctx);
-
-   if (IM->FlushElt) {
-      gl_exec_array_elements( ctx, IM, IM->LastPrimitive, IM->Count );
-      IM->FlushElt = 0;
-   }
-
-   gl_compute_orflag( IM );
- 
-   if (ctx->ExecuteFlag) 
-      gl_cva_compile_cassette( ctx, IM );
-   else
-      gl_fixup_input( ctx, IM );
-   
-   if (ctx->CompileFlag) 
-      gl_compile_cassette( ctx );
-   else
-      gl_reset_input( ctx );
-}
-
-
-void gl_flush_vb( GLcontext *ctx, const char *where )
-{
-   struct immediate *IM = ctx->input;
-
-   if (MESA_VERBOSE&VERBOSE_PIPELINE)
-      fprintf(stderr, "gl_flush_vb: %s\n", where);
-
-   gl_maybe_transform_vb( IM );
-}
-
-/* Drivers can call this inside their swapbuffers routines:
- */
-void gl_internal_flush( GLcontext *ctx )
-{
-   FLUSH_VB( ctx, "internal flush" );
-}
-
-
-#define RESET_VEC(v, t, s, c) (v.start = t v.data[s], v.count = c)  
-
-/* 
- *
- */
-void gl_reset_vb( struct vertex_buffer *VB )
-{
-   GLuint copy;
-   GLuint dst;
-   GLuint start;
-   struct immediate *IM = VB->IM;
-   GLubyte clipor = VB->ClipOrMask;
-
-   if (!VB->CullDone)
-      gl_fast_copy_vb( VB );
-      
-   copy = VB->CopyCount;
-   start = 3-copy;
-
-   VB->CopyStart = start;
-   VB->ClipOrMask = 0;
-   VB->ClipAndMask = CLIP_ALL_BITS;
-
-   if (IM) 
-   {
-      if (VB->Count != IM->Count && 0) {
-	 fprintf(stderr, "Trying to copy vertices in the middle of an IM (%d/%d)!!\n",
-		 VB->Count, IM->Count);
-      }
-      else if (VB->pipeline->copy_transformed_data) {
-
-	 for (dst = start ; dst < VB_START ; dst++) 
-	 {
-	    GLuint src = VB->Copy[dst];
-	    
-	    if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-	       fprintf(stderr, "copying vertex %u to %u\n", src, dst);
-	    
-	    COPY_4FV( VB->Clip.data[dst], VEC_ELT(VB->ClipPtr, GLfloat, src) ); 
-	    COPY_4FV( VB->Win.data[dst], VB->Win.data[src] ); 
-	    
-	    VB->UserClipMask[dst] = VB->UserClipMask[src];
-	    VB->ClipMask[dst] = (GLubyte) (VB->ClipMask[src] & ~CLIP_CULLED_BIT);
-	    VB->ClipAndMask &= VB->ClipMask[dst];
-	    VB->ClipOrMask  |= VB->ClipMask[dst];
-	    VB->ClipMask[src] = 0;	/* hack for bounds_cull_vb */
-
-	    COPY_4UBV( IM->Color[dst], IM->Color[src] );
-	    COPY_4UBV( VB->Spec[0][dst], VB->Spec[0][src] );
-	    COPY_4UBV( VB->Spec[1][dst], VB->Spec[1][src] );
-	    COPY_4UBV( VB->BColor.data[dst], VB->BColor.data[src] );
-	    IM->Index[dst] = IM->Index[src];
-	    VB->BIndex.data[dst] = VB->BIndex.data[src];
-
-	    if (VB->TexCoordPtr[0] == &IM->v.TexCoord[0])
-	       COPY_4FV( IM->TexCoord[0][dst], IM->TexCoord[0][src] );
-	    
-	    if (VB->TexCoordPtr[1] == &IM->v.TexCoord[1])
-	       COPY_4FV( IM->TexCoord[1][dst], IM->TexCoord[1][src] );
-
-	    IM->Elt[dst] = IM->Elt[src];
-	    VB->SavedOrFlag |= IM->Flag[src];
-	 } 
-      }
-      
-      VB->CullDone = 0;
-   }
-
-   if (clipor & CLIP_USER_BIT) 
-      MEMSET(VB->UserClipMask + VB->Start, 0, VB->Count - VB->Start);
-
-   VB->NormCullStart = 0;
-   VB->Parity = (VB->LastPrimitive^VB->Count)&1;
-   VB->PurgeFlags = 0;
-   VB->EarlyCull = 1;
-   VB->Culled = 0;
-   VB->BoundsPtr = 0;
-   VB->NormalLengthPtr = 0;  
-   VB->Indirect = 0;
-   VB->Culled = 0;
-}
-
-
-
-
-/* Copy the untransformed parts of the overlapping vertices from one
- * immediate struct to another (or possibly the same one).  
- *
- * Only copy those elements which are genuinely untransformed.  Others
- * are done in gl_reset_vb.
- */
-void gl_copy_prev_vertices( struct vertex_buffer *VB,
-			    struct immediate *prev,
-			    struct immediate *next )
-{
-   GLuint dst;
-   GLuint flags = VB->pipeline->inputs;
-
-   if (MESA_VERBOSE&VERBOSE_CULL)
-      fprintf(stderr, "copy prev vertices im: prev %d next %d copystart %d\n", 
-	      prev->id, next->id, VB->CopyStart);
-
-   /* VB_START is correct as vertex copying is only required when an
-    * IM wraps, which means that the next VB must start at VB_START.
-    */
-   for (dst = VB->CopyStart ; dst < VB_START ; dst++) 
-   {
-      GLuint src = VB->Copy[dst];
-
-      if (MESA_VERBOSE&VERBOSE_CULL)
-	 fprintf(stderr, "copy_prev: copy %d to %d\n", src, dst );
-
-      COPY_4FV( next->Obj[dst], prev->Obj[src] );
-
-      if ((flags&VERT_TEX0_ANY) && VB->TexCoordPtr[0] == &prev->v.TexCoord[0])
-	 COPY_4FV( next->TexCoord[0][dst], prev->TexCoord[0][src] );
-	    
-      if ((flags&VERT_TEX1_ANY) && VB->TexCoordPtr[1] == &prev->v.TexCoord[1])
-	 COPY_4FV( next->TexCoord[1][dst], prev->TexCoord[1][src] );
-
-      COPY_4UBV( next->Color[dst], prev->Color[src] );
-      next->Index[dst] = prev->Index[src];
-      next->EdgeFlag[dst] = prev->EdgeFlag[src];
-
-      next->Elt[dst] = prev->Elt[src];
-      VB->SavedOrFlag |= prev->Flag[src];
-   }
-}
-
-
-
-void RESET_IMMEDIATE( GLcontext *ctx ) 
-{
-   if (ctx->VB->prev_buffer != ctx->VB->IM) {
-      /* Should only get here if we are trying to use the internal
-       * interfaces, eg gl_Vertex3f(), gl_Begin() from inside a
-       * display list.  In this case, it is necessary to pull the
-       * current values into the ctx->VB.store buffer, because this
-       * may not have been done.
-       */
-      FLUSH_VB( ctx, "RESET_IMMEDIATE" );
-      gl_reset_input( ctx );
-   }
-}
-
-
-/* Called to initialize new buffers, and to recycle old ones.
- */
-void gl_reset_input( GLcontext *ctx )
-{
-   struct immediate *IM = ctx->input;
-
-   MEMSET(IM->Flag, 0, sizeof(GLuint) * (IM->Count+2));
-   IM->Start = VB_START;
-   IM->Count = VB_START;
-   
-   IM->Primitive[IM->Start] = ctx->Current.Primitive;
-   IM->LastPrimitive = IM->Start;
-   IM->BeginState = VERT_BEGIN_0;         
-   IM->OrFlag = 0;
-   IM->AndFlag = ~0U;
-
-   if (0)
-      fprintf(stderr, 
-	   "in reset_input(IM %d), BeginState is %x, setting prim[%d] to %s\n", 
-	   IM->id,
-	   VERT_BEGIN_0,
-	   IM->Start, gl_lookup_enum_by_nr(ctx->Current.Primitive));
-
-#ifdef VAO
-   IM->ArrayAndFlags = ~ctx->Array.Current->Flags;
-   IM->ArrayIncr = ctx->Array.Current->Vertex.Enabled;
-#else
-   IM->ArrayAndFlags = ~ctx->Array.Flags;
-   IM->ArrayIncr = ctx->Array.Vertex.Enabled;
-#endif
-   IM->ArrayEltFlush = !(ctx->CompileCVAFlag);
-}
-
-
-/* Preserves size information as well.
- */
-static void 
-fixup_4f( GLfloat data[][4], GLuint flag[], GLuint start, GLuint match )
-{
-   GLuint i = start;
-
-   for (;;) {
-      if ((flag[++i] & match) == 0) {
-	 COPY_4FV(data[i], data[i-1]);
-	 flag[i] |= (flag[i-1] & match);
-	 if (flag[i] & VERT_END_VB) break;
-      } 
-   }
-}
-
-
-
-/* Only needed for buffers with eval coords.
- */
-static void
-fixup_3f( float data[][3], GLuint flag[], GLuint start, GLuint match )
-{
-   GLuint i = start;
-
-   for (;;) {
-      if ((flag[++i] & match) == 0) {
-	 COPY_3V(data[i], data[i-1]);
-	 flag[i] |= match;
-	 if (flag[i] & VERT_END_VB) break;
-      } 
-   }
-}
-
-
-static void
-fixup_1ui( GLuint *data, GLuint flag[], GLuint start, GLuint match )
-{
-   GLuint i = start;
-
-   for (;;) {
-      if ((flag[++i] & match) == 0) {
-	 data[i] = data[i-1];
-	 if (flag[i] & VERT_END_VB) break;
-      } 
-   }
-   flag[i] |= match;
-}
-
-static void
-fixup_1ub( GLubyte *data, GLuint flag[], GLuint start, GLuint match )
-{
-   GLuint i = start;
-
-   for (;;) {
-      if ((flag[++i] & match) == 0) {
-	 data[i] = data[i-1];
-	 if (flag[i] & VERT_END_VB) break;
-      } 
-   }
-   flag[i] |= match;
-}
-
-
-static void
-fixup_4ub( GLubyte data[][4], GLuint flag[], GLuint start, GLuint match )
-{
-   GLuint i = start;
-
-   for (;;) {
-      if ((flag[++i] & match) == 0) {
-	 COPY_4UBV(data[i], data[i-1]);
-	 if (flag[i] & VERT_END_VB) break;
-      } 
-   }
-   flag[i] |= match;
-}
-
-
-/* Do this instead of fixup for shared normals.
- */
-static void
-find_last_3f( float data[][3], GLuint flag[], GLuint match, GLuint count )
-{
-   int i = count;
-
-   do {
-      if ((flag[--i] & match) != 0) {
-	 COPY_3V(data[count], data[i]);	 
-	 return;      
-      }
-   } while (i >= 0);
-
-   /* To reach this point excercises a bug that seems only to exist on
-    * dec alpha installations.  I want to leave this print statement
-    * enabled on the 3.3 branch so that we are reminded to track down
-    * the problem.
-    */
-   fprintf(stderr, 
-	   "didn't find VERT_NORM in find_last_3f"
-	   "(Dec alpha problem?)\n");
-}
-
-static void
-fixup_first_4v( GLfloat data[][4], GLuint flag[], GLuint match, 
-		GLuint start, GLfloat *dflt )
-{
-   GLuint i = start-1;
-   match |= VERT_END_VB;
-
-   while ((flag[++i]&match) == 0)
-      COPY_4FV(data[i], dflt);
-}
-
-
-static void
-fixup_first_1ui( GLuint data[], GLuint flag[], GLuint match,
-		 GLuint start, GLuint dflt )
-{
-   GLuint i = start-1;
-   match |= VERT_END_VB;
-
-   while ((flag[++i]&match) == 0)
-      data[i] = dflt;
-}
-
-
-static void
-fixup_first_1ub( GLubyte data[], GLuint flag[], GLuint match,
-		 GLuint start, GLubyte dflt )
-{
-   GLuint i = start-1;
-   match |= VERT_END_VB;
-
-   while ((flag[++i]&match) == 0)
-      data[i] = dflt;
-}
-
-
-static void
-fixup_first_4ub( GLubyte data[][4], GLuint flag[], GLuint match,
-		 GLuint start, GLubyte dflt[4] )
-{
-   GLuint i = start-1;
-   match |= VERT_END_VB;
-
-   while ((flag[++i]&match) == 0)
-      COPY_4UBV(data[i], dflt);
-}
-
-
-
-
-static GLuint vertex_sizes[16] = { 0, 
-				   1, 
-				   2, 2, 
-				   3, 3, 3, 3, 
-				   4, 4, 4, 4, 4, 4, 4, 4 };
-
-
-
-GLuint gl_texcoord_size( GLuint flag, GLuint unit )
-{
-   flag >>= VERT_TEX0_SHIFT + unit * NR_TEXSIZE_BITS;
-   return vertex_sizes[flag & 0xf];
-}
-
-
-static void set_vec_sizes( struct immediate *IM, GLuint orflag )
-{
-   GLuint i;
-
-   if (orflag & VERT_OBJ_ANY) {
-      GLuint szflag = orflag & VERT_OBJ_234;
-      IM->v.Obj.size = vertex_sizes[szflag<<1];
-   }
-
-   for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
-      if (orflag & VERT_TEX_ANY(i)) {
-	 GLuint szflag = ((orflag>>(VERT_TEX0_SHIFT+i*NR_TEXSIZE_BITS))
-			  & 0xf);
-	 IM->v.TexCoord[i].size = vertex_sizes[szflag];
-      }
-   }
-}
-
-
-void gl_compute_orflag( struct immediate *IM )
-{
-   GLuint count = IM->Count;
-   GLuint orflag = 0;
-   GLuint andflag = ~0U;
-   GLuint i;
-
-   IM->LastData = count-1;
-
-/*     fprintf(stderr, "In gl_compute_orflag, start %d count %d\n", IM->Start, IM->Count); */
-/*     gl_print_vert_flags("initial andflag", andflag); */
-
-   /* Compute the flags for the whole buffer, even if 
-    */
-   for (i = IM->Start ; i < count ; i++) {
-      andflag &= IM->Flag[i];
-      orflag |= IM->Flag[i];
-   }
-
-   if (IM->Flag[i] & VERT_DATA) {
-      IM->LastData++;
-/*        andflag &= IM->Flag[i]; */
-      orflag |= IM->Flag[i];
-   }      
-
-/*     gl_print_vert_flags("final andflag", andflag); */
-
-   IM->Flag[IM->LastData+1] |= VERT_END_VB;
-   IM->AndFlag = andflag;
-   IM->OrFlag = orflag;
-}
-
-void gl_fixup_input( GLcontext *ctx, struct immediate *IM )
-{
-   GLuint count = IM->Count;
-   GLuint start = IM->Start;
-   GLuint fixup, diff;
-   GLuint andflag = IM->AndFlag;
-   GLuint orflag = IM->OrFlag;
-
-   IM->Primitive[count] = IM->Primitive[IM->LastPrimitive];
-   IM->NextPrimitive[IM->LastPrimitive] = count;
-   IM->NextPrimitive[count] = count+1;
-
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE) 
-   {
-      fprintf(stderr, "Start: %u Count: %u LastData: %u\n", 
-	      IM->Start, IM->Count, IM->LastData);
-      gl_print_vert_flags("Orflag", orflag);
-      gl_print_vert_flags("Andflag", andflag);
-   }
-
-   /* Array elements modify the current state - must do this before
-    * fixup.
-    */
-   if (ctx->CompileCVAFlag && !(andflag & VERT_ELT)) 
-      gl_rescue_cva( ctx, IM );
-
-   if (orflag & VERT_ELT) 
-   {
-      orflag = IM->OrFlag;
-      andflag = IM->AndFlag;
-      start = IM->Start;
-   }
-   
-   fixup = ~andflag & VERT_FIXUP;
-
-   if (!ctx->CompileFlag) 
-      fixup &= ctx->CVA.elt.inputs; 
-   
-   if (!ctx->ExecuteFlag)
-      fixup &= orflag;
-
-   if (ctx->CompileCVAFlag)
-      fixup &= ~ctx->CVA.pre.outputs;
-
-   if ((orflag & (VERT_OBJ_ANY|VERT_EVAL_ANY)) == 0)
-      fixup = 0;
-
-   if (fixup) 
-   {
-
-      if (ctx->ExecuteFlag && (fixup & ~IM->Flag[start])) {
-	 GLuint copy = fixup & ~IM->Flag[start];
-
-	 if (copy & VERT_NORM) 	 
-	    COPY_3V( IM->Normal[start], ctx->Current.Normal );
-	 
-	 if (copy & VERT_RGBA)
-	    COPY_4UBV( IM->Color[start], ctx->Current.ByteColor);
-      
-	 if (copy & VERT_INDEX)
-	    IM->Index[start] = ctx->Current.Index;
-	 
-	 if (copy & VERT_EDGE)
-	    IM->EdgeFlag[start] = ctx->Current.EdgeFlag;
-
-	 if (copy & VERT_TEX0_ANY)
-	    COPY_4FV( IM->TexCoord[0][start], ctx->Current.Texcoord[0] ); 
-	 
-	 if (copy & VERT_TEX1_ANY)
-	    COPY_4FV( IM->TexCoord[1][start], ctx->Current.Texcoord[1] ); 
-      }
-
-
-      if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-	 gl_print_vert_flags("fixup", fixup);
-      
-      if (fixup & VERT_TEX0_ANY) {
-	 if (orflag & VERT_TEX0_ANY)
-	    fixup_4f( IM->TexCoord[0], IM->Flag, start, VERT_TEX0_1234 );
-	 else 
-	    fixup_first_4v( IM->TexCoord[0], IM->Flag, 0, start, 
-			    IM->TexCoord[0][start]);
-      }
-
-      if (fixup & VERT_TEX1_ANY) {
-	 if (orflag & VERT_TEX1_ANY)
-	    fixup_4f( IM->TexCoord[1], IM->Flag, start, VERT_TEX1_1234 );
-	 else 
-	    fixup_first_4v( IM->TexCoord[1], IM->Flag, 0, start, 
-			    IM->TexCoord[1][start] );
-      }
-
-      if (fixup & VERT_EDGE) {
-	 if (orflag & VERT_EDGE)
-	    fixup_1ub( IM->EdgeFlag, IM->Flag, start, VERT_EDGE );
-	 else 
-	    fixup_first_1ub( IM->EdgeFlag, IM->Flag, 0, start, 
-			     IM->EdgeFlag[start] );
-      }
-
-      if (fixup & VERT_INDEX) {
-	 if (orflag & VERT_INDEX)
-	    fixup_1ui( IM->Index, IM->Flag, start, VERT_INDEX );
-	 else 
-	    fixup_first_1ui( IM->Index, IM->Flag, 0, start, IM->Index[start] );
-      }
-
-      if (fixup & VERT_RGBA) {
-	 if (orflag & VERT_RGBA) 
-	    fixup_4ub( IM->Color, IM->Flag, start, VERT_RGBA );      
-	 else 
-	    fixup_first_4ub( IM->Color, IM->Flag, 0, start, IM->Color[start] );
-      }
-
-      if (fixup & VERT_NORM) {
-	 /* Only eval cannot use the Flag member to find valid normals:
-	  */
-	 if (IM->OrFlag & VERT_EVAL_ANY)
-	    fixup_3f( IM->Normal, IM->Flag, start, VERT_NORM );
-	 else {
-	    /* Copy-to-current requires a valid normal in the last slot:
-	     */
-	    if ((IM->OrFlag & VERT_NORM) &&
-		!(IM->Flag[IM->LastData] & VERT_NORM)) 
-	       find_last_3f( IM->Normal, IM->Flag, VERT_NORM, IM->LastData );
-	 }
-      }
-   }
-
-   diff = count - start;
-   IM->v.Obj.count = diff;
-   IM->v.Normal.count = diff;
-   IM->v.TexCoord[0].count = diff;
-   IM->v.TexCoord[1].count = diff;
-   IM->v.EdgeFlag.count = diff;
-   IM->v.Color.count = diff;
-   IM->v.Index.count = diff;
- 
-   /* Prune possible half-filled slot.
-    */
-   IM->Flag[IM->LastData+1] &= ~VERT_END_VB;
-   IM->Flag[IM->Count] |= VERT_END_VB;
-}
-
-
-static void calc_normal_lengths( GLfloat *dest, 
-				 CONST GLfloat (*data)[3],
-				 const GLuint *flags,
-				 GLuint count )
-{
-   GLuint i;
-
-   for (i = 0 ; i < count ; i++ )
-      if (flags[i] & VERT_NORM) {
-	 GLfloat tmp = (GLfloat) LEN_3FV( data[i] );
-	 dest[i] = 0;
-	 if (tmp > 0)
-	    dest[i] = 1.0F / tmp;
-      }      
-}
-
-
-/* Revive a compiled immediate struct - propogate new 'Current'
- * values.  Often this is redundant because the current values were
- * known and fixed up at compile time.
- */
-void gl_fixup_cassette( GLcontext *ctx, struct immediate *IM )
-{
-   GLuint fixup;
-   GLuint count = IM->Count;
-   GLuint start = IM->Start;
-   
-   if (count == start) 
-      return;
-
-   if (ctx->NewState)
-      gl_update_state( ctx );
-
-
-   if (ctx->Transform.Normalize && IM->LastCalcedLength < IM->Count) {
-      GLuint start = IM->LastCalcedLength;
-
-      if (!IM->NormalLengths)
-	 IM->NormalLengths = (GLfloat *)MALLOC(sizeof(GLfloat) * VB_SIZE);
-
-      calc_normal_lengths( IM->NormalLengths + start, 
-			   (CONST GLfloat (*)[3])(IM->Normal + start), 
-			   IM->Flag + start, 
-			   IM->Count - start);
-      
-      IM->LastCalcedLength = IM->Count;
-   }
-
-   fixup = ctx->CVA.elt.inputs & ~IM->AndFlag & VERT_FIXUP;
-
-   if (fixup) {
-
-      if (MESA_VERBOSE & VERBOSE_IMMEDIATE) {
-	 fprintf(stderr, "start: %d count: %d\n", start, count);
-	 gl_print_vert_flags("fixup_cassette", fixup);
-      }
-
-      if (fixup & VERT_TEX0_ANY) 
-	 fixup_first_4v( IM->TexCoord[0], IM->Flag, VERT_TEX0_ANY, start,
-			 ctx->Current.Texcoord[0] );
-
-      if (fixup & VERT_TEX1_ANY) 
-	 fixup_first_4v( IM->TexCoord[1], IM->Flag, VERT_TEX1_ANY, start,
-			 ctx->Current.Texcoord[1] );
-
-      if (fixup & VERT_EDGE)
-	 fixup_first_1ub(IM->EdgeFlag, IM->Flag, VERT_EDGE, start,
-			 ctx->Current.EdgeFlag );
-
-      if (fixup & VERT_INDEX)
-	 fixup_first_1ui(IM->Index, IM->Flag, VERT_INDEX, start,
-			 ctx->Current.Index );
-   
-      if (fixup & VERT_RGBA) 
-	 fixup_first_4ub(IM->Color, IM->Flag, VERT_RGBA, start,
-			 ctx->Current.ByteColor );      
-
-      if ((fixup & VERT_NORM) && !(IM->Flag[start] & VERT_NORM)) {
-	 COPY_3V(IM->Normal[start], ctx->Current.Normal);
-	 if (ctx->Transform.Normalize)
-	    IM->NormalLengths[start] = 1.0F / (GLfloat) LEN_3FV(ctx->Current.Normal);
-      }
-   }  
-}
-
-
-
-static void fixup_primitives( struct vertex_buffer *VB, struct immediate *IM )
-{
-   static GLuint increment[GL_POLYGON+2] = { 1,2,1,1,3,1,1,4,2,1,1 };
-   static GLuint intro[GL_POLYGON+2]     = { 0,0,2,2,0,2,2,0,2,2,0 };
-   GLcontext *ctx = VB->ctx;
-   const GLuint *flags = IM->Flag;
-   const GLuint *in_prim = IM->Primitive;
-   const GLuint *in_nextprim = IM->NextPrimitive;
-   GLuint *out_prim = VB->IM->Primitive;
-   GLuint *out_nextprim = VB->IM->NextPrimitive;
-   GLuint count = VB->Count;
-   GLuint start = VB->Start;
-   GLuint in, out, last;
-   GLuint incr, prim;   
-   GLuint transition;
-   GLuint interesting;
-   GLuint err;
-   
-/*     printf("IM: %d VB->Count %d VB->Start %d current prim: %d\n", IM->id, VB->Count, VB->Start, ctx->Current.Primitive);  */
-
-   if (ctx->Current.Primitive == GL_POLYGON+1) {
-      transition = VERT_BEGIN;
-      err = IM->BeginState & VERT_ERROR_1;
-   } else {
-      transition = VERT_END;
-      err = IM->BeginState & VERT_ERROR_0;
-   }
-
-   if (err) {
-      /* Occurred somewhere inside the vb.  Don't know/care where/why.
-       */
-      gl_error( ctx, GL_INVALID_OPERATION, "glBegin/glEnd");
-   }
-
-   interesting = transition | VERT_END_VB;
-
-
-   for (in = start ; in <= count ; in = in_nextprim[in]) 
-      if (flags[in] & interesting) 
-	 break;
-
-   out = VB->CopyStart;
-
-   if (in == out) {
-      out_nextprim[out] = in_nextprim[in];
-      out_prim[out] = in_prim[in];
-      last = IM->LastPrimitive;
-   } else if (flags[in] & transition) {
-      out_nextprim[out] = in;
-      out_prim[out] = ctx->Current.Primitive;
-      out = in;
-      last = IM->LastPrimitive;
-   } else {
-      out_nextprim[out] = in;
-      out_prim[out] = ctx->Current.Primitive;
-      in++;
-      last = out;
-   }
-
-   for ( ; in <= count ; in = in_nextprim[in] ) {
-      out_prim[in] = in_prim[in];
-      out_nextprim[in] = in_nextprim[in];
-   }
-	  
-
-   VB->Primitive = out_prim;
-   VB->NextPrimitive = out_nextprim;
-   VB->LastPrimitive = last;
-   prim = ctx->Current.Primitive = (GLenum) out_prim[last];
-
-
-   /* Calculate whether the primitive finished on a 'good number' of
-    * vertices, or whether there are overflowing vertices we have to
-    * copy to the next buffer (in addition to the normal ones required
-    * by a continuing primitive).
-    *
-    * Note that GL_POLYGON+1, ie outside begin/end, has increment 1.
-    */
-
-   incr = increment[prim];
-  
-   if (incr != 1 && (count - last - intro[prim])) 
-      VB->Ovf = (count - last - intro[prim]) % incr; 
-   else
-      VB->Ovf = 0;
-
-   if (0) 
-      fprintf(stderr, "prim: %s count %u last %u incr %u ovf: %u\n",
-	      gl_prim_name[prim], count, last, incr, VB->Ovf);
-}
-
-
-void gl_copy_to_current( GLcontext *ctx, struct immediate *IM )
-{
-   GLuint count = IM->LastData;
-   GLuint flag = IM->OrFlag;
-   GLuint mask = 0;
-
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      gl_print_vert_flags("copy to current", flag);
-
-   if (flag & VERT_NORM) 
-      COPY_3FV( ctx->Current.Normal, IM->Normal[count]);   
-   
-   if (flag & VERT_INDEX)
-      ctx->Current.Index = IM->Index[count];
-
-   if (flag & VERT_EDGE)
-      ctx->Current.EdgeFlag = IM->EdgeFlag[count];
-
-   if (flag & VERT_RGBA) 
-      COPY_4UBV(ctx->Current.ByteColor, IM->Color[count]);
-
-   if (flag & VERT_TEX0_ANY) {
-      mask |= VERT_TEX0_1234;
-      COPY_4FV( ctx->Current.Texcoord[0], IM->TexCoord[0][count]);
-   }
-      
-   if (flag & VERT_TEX1_ANY) {
-      mask |= VERT_TEX1_1234;
-      COPY_4FV( ctx->Current.Texcoord[1], IM->TexCoord[1][count]);
-   }
-
-   /* Save the texcoord size information as well.
-    */
-   ctx->Current.Flag &= ~mask;
-   ctx->Current.Flag |= IM->Flag[count] & mask;
-}
-
-
-void gl_execute_cassette( GLcontext *ctx, struct immediate *IM )
-{
-   struct vertex_buffer *VB = ctx->VB;
-   struct immediate *prev = VB->prev_buffer;
-   GLuint vec_start, diff;
-
-   IM->ref_count++;
-
-   if (prev != IM || IM != VB->IM) {
-      gl_copy_prev_vertices( VB, VB->prev_buffer, IM );
-   }
-
-   if (! --prev->ref_count ) 
-      gl_immediate_free( prev );
-
-   VB->prev_buffer = IM;
-   VB->Start = IM->Start;
-   VB->Count = IM->Count;
-   VB->Flag = IM->Flag;
-   VB->OrFlag = IM->OrFlag | VB->SavedOrFlag;
-   VB->EltPtr = &IM->v.Elt;
-   VB->MaterialMask = IM->MaterialMask;
-   VB->Material = IM->Material;
-   VB->CullMode = (GLubyte) ((IM->AndFlag & VERT_NORM) ? 0 : COMPACTED_NORMALS);
-   VB->ObjPtr = &IM->v.Obj;
-   VB->NormalPtr = &IM->v.Normal;
-   VB->ColorPtr = &IM->v.Color;
-   VB->Color[0] = VB->Color[1] = VB->ColorPtr;
-   VB->IndexPtr = &IM->v.Index;
-   VB->Index[0] = VB->Index[1] = VB->IndexPtr;
-   VB->EdgeFlagPtr = &IM->v.EdgeFlag;
-   VB->TexCoordPtr[0] = &IM->v.TexCoord[0];
-   VB->TexCoordPtr[1] = &IM->v.TexCoord[1];
-/*     VB->BoundsPtr = IM->Bounds; */
-   VB->NormalLengthPtr = IM->NormalLengths;
-   VB->IndirectCount = VB->Count;
-   VB->SavedOrFlag = 0;
-
-   if (IM->Start != VB_START)
-      VB->CopyStart = IM->Start;
-
-   vec_start = IM->Start;
-   if (vec_start == VB_START && VB->pipeline->replay_copied_vertices)
-      vec_start = VB->CopyStart;
-
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
-      fprintf(stderr, "reseting vectors to %d/%d .. %d\n", vec_start, IM->Start, IM->Count);
-
-   VB->LastPrimitive = IM->Start; 
-
-   diff = IM->Count - vec_start;
-
-   RESET_VEC(IM->v.Obj, (GLfloat *), vec_start, diff);
-   RESET_VEC(IM->v.Normal, (GLfloat *), vec_start, diff);
-   RESET_VEC(IM->v.TexCoord[0], (GLfloat *), vec_start, diff);
-   RESET_VEC(IM->v.TexCoord[1], (GLfloat *), vec_start, diff);
-   RESET_VEC(IM->v.Index, &, vec_start, diff);
-   RESET_VEC(IM->v.Elt, &, vec_start, diff);
-   RESET_VEC(IM->v.EdgeFlag, &, vec_start, diff);
-   RESET_VEC(IM->v.Color, (GLubyte *), vec_start, diff);
-   RESET_VEC(VB->Clip, (GLfloat *), vec_start, diff);
-   RESET_VEC(VB->Eye, (GLfloat *), vec_start, diff);
-   RESET_VEC(VB->Win, (GLfloat *), vec_start, diff);
-   RESET_VEC(VB->BColor, (GLubyte *), vec_start, diff); 
-   RESET_VEC(VB->BIndex, &, vec_start, diff);
-
-   if (IM != VB->IM) {
-      RESET_VEC(VB->IM->v.Obj, (GLfloat *), vec_start, diff);
-      RESET_VEC(VB->IM->v.Normal, (GLfloat *), vec_start, diff);
-      RESET_VEC(VB->IM->v.TexCoord[0], (GLfloat *), vec_start, diff);
-      RESET_VEC(VB->IM->v.TexCoord[1], (GLfloat *), vec_start, diff);
-      RESET_VEC(VB->IM->v.Index, &, vec_start, diff);
-      RESET_VEC(VB->IM->v.Elt, &, vec_start, diff);
-      RESET_VEC(VB->IM->v.EdgeFlag, &, vec_start, diff);
-      RESET_VEC(VB->IM->v.Color, (GLubyte *), vec_start, diff);
-   }
-
-   gl_copy_to_current( ctx, IM );
-
-   set_vec_sizes( IM, VB->OrFlag );
-
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE) 
-      fprintf(stderr,
-	      "executing cassette, rows %u tc0->size == %u tc1->size == %u\n",
-	      VB->Count,
-	      VB->TexCoordPtr[0]->size,
-	      VB->TexCoordPtr[1]->size);
-
-   if (MESA_VERBOSE&VERBOSE_IMMEDIATE) 
-      gl_print_cassette( IM );
-
-   
-   if (IM->OrFlag & VERT_EVAL_ANY) 
-      gl_eval_vb( VB );
-
-   if (IM->Count > IM->Start || (IM->Flag[IM->Start] & (VERT_END|VERT_BEGIN)))
-      fixup_primitives( VB, IM );
-
-   if (VB->IndirectCount > IM->Start) 
-      gl_run_pipeline( VB );      
-   else 
-      gl_update_materials( VB );
-
-   /* This is unfortunate:
-    */
-   if (VB->pipeline->replay_copied_vertices) {
-      if (!VB->CullDone)
-	 gl_fast_copy_vb( VB );
-
-      gl_copy_prev_vertices( VB, VB->prev_buffer, IM );
-   }
-
-   gl_reset_vb( VB );
-}
-
-void gl_print_cassette( struct immediate *IM )
-{
-   gl_print_cassette_flags( IM, IM->Flag );
-}
-
-void gl_print_cassette_flags( struct immediate *IM, GLuint *flags ) 
-{
-   GLuint i;
-   GLuint andflag = IM->AndFlag;
-   GLuint orflag = IM->OrFlag;
-   GLuint state = IM->BeginState;
-   GLuint req = ~0;
-   static const char *tplate[5] = { "%s ", 
-				    "%s: %f ",
-				    "%s: %f %f ",
-				    "%s: %f %f %f ",
-				    "%s: %f %f %f %f " };
-
-   fprintf(stderr, "Cassette id %d, %u rows.\n", IM->id, IM->Count - IM->Start);
-
-   gl_print_vert_flags("Contains at least one", orflag);
-
-   if (IM->Count != IM->Start) 
-   {
-      gl_print_vert_flags("Contains a full complement of", andflag);
-   
-      fprintf(stderr, "Final begin/end state %s/%s, errors %s/%s\n",
-	     (state & VERT_BEGIN_0) ? "in" : "out", 
-	     (state & VERT_BEGIN_1) ? "in" : "out", 
-	     (state & VERT_ERROR_0) ? "y" : "n", 
-	     (state & VERT_ERROR_1) ? "y" : "n");
-
-      fprintf(stderr, "Obj size: %u, TexCoord0 size: %u, TexCoord1 size: %u\n",
-	     IM->v.Obj.size,
-	     IM->v.TexCoord[0].size,
-	     IM->v.TexCoord[1].size);
-   }
-
-   for (i = IM->Start ; i <= IM->Count ; i++) {
-      fprintf(stderr, "%u: ", i);
-      if (req & VERT_OBJ_ANY) {
-	 if (flags[i] & VERT_EVAL_C1) 
-	    fprintf(stderr, "EvalCoord %f ", IM->Obj[i][0]);
-	 else if (flags[i] & VERT_EVAL_P1) 
-	    fprintf(stderr, "EvalPoint %.0f ", IM->Obj[i][0]);
-	 else if (flags[i] & VERT_EVAL_C2) 
-	    fprintf(stderr, "EvalCoord %f %f ", IM->Obj[i][0], IM->Obj[i][1]);
-	 else if (flags[i] & VERT_EVAL_P2) 
-	    fprintf(stderr, "EvalPoint %.0f %.0f ", IM->Obj[i][0], IM->Obj[i][1]);
-	 else if (i < IM->Count && (flags[i]&VERT_OBJ_234)) {
-	    fprintf(stderr, "(%x) ", flags[i] & VERT_OBJ_234);
-	    fprintf(stderr, tplate[vertex_sizes[(flags[i]&VERT_OBJ_234)<<1]],
-		   "Obj",
-		   IM->Obj[i][0], IM->Obj[i][1], IM->Obj[i][2], IM->Obj[i][3]);
-	 }
-      }
-
-      if (req & flags[i] & VERT_ELT) 
-	 fprintf(stderr, " Elt %u\t", IM->Elt[i]);
-
-      if (req & flags[i] & VERT_NORM)
-	 fprintf(stderr, " Norm %f %f %f ", 
-		IM->Normal[i][0], IM->Normal[i][1], IM->Normal[i][2]);
-
-      if (req & flags[i] & VERT_TEX0_ANY)
-	 fprintf(stderr, tplate[vertex_sizes[(flags[i]>>VERT_TEX0_SHIFT)&7]], 
-		"TC0",
-		IM->TexCoord[0][i][0], IM->TexCoord[0][i][1], 
-		IM->TexCoord[0][i][2], IM->TexCoord[0][i][2]);
-
-
-      if (req & flags[i] & VERT_TEX1_ANY)
-	 fprintf(stderr, tplate[vertex_sizes[(flags[i]>>(VERT_TEX0_SHIFT+4))&7]], 
-		"TC1",
-		IM->TexCoord[1][i][0], IM->TexCoord[1][i][1], 
-		IM->TexCoord[1][i][2], IM->TexCoord[1][i][2]);
-
-      if (req & flags[i] & VERT_RGBA)
-	 fprintf(stderr, " Rgba %d %d %d %d ", 
-		IM->Color[i][0], IM->Color[i][1], 
-		IM->Color[i][2], IM->Color[i][3]);
-
-      if (req & flags[i] & VERT_INDEX)
-	 fprintf(stderr, " Index %u ", IM->Index[i]);
-      
-      if (req & flags[i] & VERT_EDGE)
-	 fprintf(stderr, " Edgeflag %d ", IM->EdgeFlag[i]);
-
-      if (req & flags[i] & VERT_MATERIAL)
-	 fprintf(stderr, " Material ");
-	 
-
-      /* The order of these two is not easily knowable, but this is
-       * the usually correct way to look at them.
-       */
-      if (req & flags[i] & VERT_END) 
-	 fprintf(stderr, " END ");
-
-      if (req & flags[i] & VERT_BEGIN) 
-	 fprintf(stderr, " BEGIN(%s) ", gl_prim_name[IM->Primitive[i]]);
-
-      fprintf(stderr, "\n");  
-   }      
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
Index: xc/extras/Mesa/src/vbxform.h
diff -u xc/extras/Mesa/src/vbxform.h:1.3 xc/extras/Mesa/src/vbxform.h:removed
--- xc/extras/Mesa/src/vbxform.h:1.3	Tue Feb 15 02:12:43 2000
+++ xc/extras/Mesa/src/vbxform.h	Thu Feb 27 12:15:45 2003
@@ -1,68 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef VBXFORM_H
-#define VBXFORM_H
-
-extern void gl_internal_flush( GLcontext *ctx );
-
-extern void gl_maybe_transform_vb( struct immediate *IM );
-
-extern void gl_compute_orflag( struct immediate *IM );
-
-extern void gl_reset_vb( struct vertex_buffer *VB );
-
-extern void gl_fixup_input( GLcontext *ctx, struct immediate *IM );
-extern void gl_fixup_cassette( GLcontext *ctx, struct immediate *IM );
-
-
-extern void gl_copy_prev_vertices( struct vertex_buffer *VB, 
-				   struct immediate *prev,
-				   struct immediate *next );
-
-extern void gl_execute_cassette( GLcontext *ctx, struct immediate *IM );
-
-extern void gl_reset_input( GLcontext *ctx );
-extern void gl_execute_vb( GLcontext *ctx );
-
-extern void gl_copy_to_current( GLcontext *ctx, struct immediate *IM );
-extern void gl_copy_all_to_current( GLcontext *ctx, struct immediate *IM );
-
-
-extern struct immediate *gl_purge_immediate( GLcontext *ctx, 
-					     struct immediate *IM,
-					     GLuint flag );
-
-extern void gl_print_cassette( struct immediate *IM );
-extern void gl_print_cassette_flags( struct immediate *IM, GLuint *flags );
-
-
-extern GLuint gl_texcoord_size( GLuint flag, GLuint unit );
-
-#endif
Index: xc/extras/Mesa/src/vector.c
diff -u xc/extras/Mesa/src/vector.c:1.6 xc/extras/Mesa/src/vector.c:removed
--- xc/extras/Mesa/src/vector.c:1.6	Mon Nov 13 18:30:54 2000
+++ xc/extras/Mesa/src/vector.c	Thu Feb 27 12:15:45 2003
@@ -1,305 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "config.h"
-#include "macros.h"
-#include "mem.h"
-#include "vector.h"
-#endif
-
-
-
-static const GLubyte elem_bits[4] = {
-   VEC_DIRTY_0,
-   VEC_DIRTY_1, 
-   VEC_DIRTY_2, 
-   VEC_DIRTY_3
-};
-
-void gl_vector4f_clean_elem( GLvector4f *vec, GLuint count, GLuint elt )
-{
-   static GLfloat clean[4] = { 0, 0, 0, 1 };
-   GLfloat v = clean[elt];
-   GLfloat (*data)[4] = (GLfloat (*)[4])vec->start;
-   GLuint i; 
-
-   for (i = 0 ; i < count ; i++)
-      data[i][elt] = v;
-
-   vec->flags &= ~elem_bits[elt];
-}
-
-static const GLubyte size_bits[5] = {
-   0,
-   VEC_SIZE_1,
-   VEC_SIZE_2,
-   VEC_SIZE_3,
-   VEC_SIZE_4,
-};
-
-
-
-void gl_vector4f_init( GLvector4f *v, GLuint flags, GLfloat (*storage)[4] )
-{
-   v->stride = 4*sizeof(GLfloat);
-   v->size = 2;
-   v->data = storage;
-   v->start = (GLfloat *)storage;
-   v->count = 0;
-   v->flags = size_bits[4] | flags | VEC_GOOD_STRIDE;
-}
-
-void gl_vector3f_init( GLvector3f *v, GLuint flags, GLfloat (*storage)[3] )
-{
-   v->stride = 3*sizeof(GLfloat);
-   v->data = storage;
-   v->start = (GLfloat *)storage;
-   v->count = 0;
-   v->flags = flags | VEC_GOOD_STRIDE;
-}
-
-void gl_vector4ub_init( GLvector4ub *v, GLuint flags, GLubyte (*storage)[4] )
-{
-   v->stride = 4*sizeof(GLubyte);
-   v->data = storage;
-   v->start = (GLubyte *)storage;
-   v->count = 0;
-   v->flags = flags | VEC_GOOD_STRIDE;
-}
-
-void gl_vector1ub_init( GLvector1ub *v, GLuint flags, GLubyte *storage )
-{
-   v->stride = 1*sizeof(GLubyte);
-   v->data = storage;
-   v->start = (GLubyte *)storage;
-   v->count = 0;
-   v->flags = flags | VEC_GOOD_STRIDE;
-}
-
-void gl_vector1ui_init( GLvector1ui *v, GLuint flags, GLuint *storage )
-{
-   v->stride = 1*sizeof(GLuint);
-   v->data = storage;
-   v->start = (GLuint *)storage;
-   v->count = 0;
-   v->flags = flags | VEC_GOOD_STRIDE;
-}
-
-
-
-void gl_vector4f_alloc( GLvector4f *v, GLuint sz, GLuint flags, GLuint count,
-			GLuint alignment )
-{
-   (void) sz;
-   v->stride = 4*sizeof(GLfloat);
-   v->size = 2;
-   v->storage = v->start = (GLfloat *)
-      ALIGN_MALLOC( count * 4 * sizeof(GLfloat), alignment );
-   v->data = (GLfloat (*)[4])v->start;
-   v->count = 0;
-   v->flags = size_bits[4] | flags | VEC_MALLOC | VEC_GOOD_STRIDE;
-}
-
-void gl_vector3f_alloc( GLvector3f *v, GLuint flags, GLuint count,
-			GLuint alignment )
-{
-   v->stride = 3*sizeof(GLfloat);
-   v->storage = v->start = (GLfloat *)
-      ALIGN_MALLOC( count * 3 * sizeof(GLfloat), alignment );
-   v->data = (GLfloat (*)[3])v->start;
-   v->count = 0;
-   v->flags = flags | VEC_MALLOC | VEC_GOOD_STRIDE;
-}
-
-void gl_vector4ub_alloc( GLvector4ub *v, GLuint flags, GLuint count,
-			 GLuint alignment )
-{
-   v->stride = 4*sizeof(GLubyte);
-   v->storage = v->start = (GLubyte *)
-      ALIGN_MALLOC( count * 4 * sizeof(GLubyte), alignment );
-   v->data = (GLubyte (*)[4])v->start;
-   v->count = 0;
-   v->flags = flags | VEC_MALLOC | VEC_GOOD_STRIDE;
-}
-
-void gl_vector1ub_alloc( GLvector1ub *v, GLuint flags, GLuint count,
-			 GLuint alignment )
-{
-   v->stride = 1*sizeof(GLubyte);
-   v->storage = v->start = (GLubyte *)
-      ALIGN_MALLOC( count * sizeof(GLubyte), alignment );
-   v->data = v->start;
-   v->count = 0;
-   v->flags = flags | VEC_MALLOC | VEC_GOOD_STRIDE;
-}
-
-void gl_vector1ui_alloc( GLvector1ui *v, GLuint flags, GLuint count,
-			 GLuint alignment )
-{
-   v->stride = 1*sizeof(GLuint);
-   v->storage = v->start = (GLuint *)
-      ALIGN_MALLOC( count * sizeof(GLuint), alignment );
-   v->data = v->start;
-   v->count = 0;
-   v->flags = flags | VEC_MALLOC | VEC_GOOD_STRIDE;
-}
-
-
-
-void gl_vector4f_free( GLvector4f *v )
-{
-   if (v->flags & VEC_MALLOC) {
-      ALIGN_FREE( v->storage );
-      v->data = 0;
-      v->start = 0;
-      v->storage = 0;
-      v->flags &= ~VEC_MALLOC;
-   }
-}
-
-void gl_vector3f_free( GLvector3f *v )
-{
-   if (v->flags & VEC_MALLOC) {
-      ALIGN_FREE( v->storage );
-      v->data = 0;
-      v->start = 0;
-      v->storage = 0;
-      v->flags &= ~VEC_MALLOC;
-   }
-}
-
-void gl_vector4ub_free( GLvector4ub *v )
-{
-   if (v->flags & VEC_MALLOC) {
-      ALIGN_FREE( v->storage );
-      v->data = 0;
-      v->start = 0;
-      v->storage = 0;
-      v->flags &= ~VEC_MALLOC;
-   }
-}
-
-void gl_vector1ub_free( GLvector1ub *v )
-{
-   if (v->flags & VEC_MALLOC) {
-      ALIGN_FREE( v->storage );
-      v->data = 0;
-      v->start = 0;
-      v->storage = 0;
-      v->flags &= ~VEC_MALLOC;
-   }
-}
-
-void gl_vector1ui_free( GLvector1ui *v )
-{
-   if (v->flags & VEC_MALLOC) {
-      ALIGN_FREE( v->storage );
-      v->data = 0;
-      v->start = 0;
-      v->storage = 0;
-      v->flags &= ~VEC_MALLOC;
-   }
-}
-
-
-
-void gl_vector4f_print( GLvector4f *v, GLubyte *cullmask, GLboolean culling )
-{
-   GLfloat c[4] = { 0, 0, 0, 1 };
-   const char *templates[5] = {
-      "%d:\t0, 0, 0, 1\n",
-      "%d:\t%f, 0, 0, 1\n",
-      "%d:\t%f, %f, 0, 1\n",
-      "%d:\t%f, %f, %f, 1\n",
-      "%d:\t%f, %f, %f, %f\n"
-   };
-
-   const char *t = templates[v->size];
-   GLfloat *d = (GLfloat *)v->data;
-   GLuint j, i = 0, count;
-
-   printf("data-start\n");
-   for ( ; d != v->start ; STRIDE_F(d, v->stride), i++) 
-      printf( t, i, d[0], d[1], d[2], d[3]);
-   
-   printf("start-count(%u)\n", v->count);
-   count = i + v->count;
-
-   if (culling) {
-      for ( ; i < count ; STRIDE_F(d, v->stride), i++) 
-	 if (cullmask[i]) 
-	    printf( t, i, d[0], d[1], d[2], d[3]);      
-   } else {
-      for ( ; i < count ; STRIDE_F(d, v->stride), i++) 
-	 printf( t, i, d[0], d[1], d[2], d[3]);      
-   }
-
-   for (j = v->size ; j < 4; j++) {
-      if ((v->flags & (1<<j)) == 0) {
-
-	 printf("checking col %u is clean as advertised ", j);
-
-	 for (i = 0, d = (GLfloat *) v->data ; 
-	      i < count && d[j] == c[j] ; 
-	      i++, STRIDE_F(d, v->stride)) {};
-
-	 if (i == count) 
-	    printf(" --> ok\n");
-	 else 
-	    printf(" --> Failed at %u ******\n", i);
-      }
-   }
-}
-
-void gl_vector3f_print( GLvector3f *v, GLubyte *cullmask, GLboolean culling )
-{
-   GLfloat *d = (GLfloat *)v->data;
-   GLuint i = 0, count;
-
-   printf("data-start\n");
-   for ( ; d != v->start ; STRIDE_F(d,v->stride), i++) 
-      printf( "%u:\t%f, %f, %f\n", i, d[0], d[1], d[2]);
-   
-   printf("start-count(%u)\n", v->count);
-   count = i + v->count;
-
-   if (culling) {
-      for ( ; i < count ; STRIDE_F(d,v->stride), i++) 
-	 if (cullmask[i])
-	    printf( "%u:\t%f, %f, %f\n", i, d[0], d[1], d[2]);      
-   } else {
-      for ( ; i < count ; STRIDE_F(d,v->stride), i++) 
-	 printf( "%u:\t%f, %f, %f\n", i, d[0], d[1], d[2]);      
-   }
-}
Index: xc/extras/Mesa/src/vector.h
diff -u xc/extras/Mesa/src/vector.h:1.3 xc/extras/Mesa/src/vector.h:removed
--- xc/extras/Mesa/src/vector.h:1.3	Tue Feb 15 02:12:43 2000
+++ xc/extras/Mesa/src/vector.h	Thu Feb 27 12:15:45 2003
@@ -1,167 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-#ifndef _VECTOR_H_
-#define _VECTOR_H_
-
-#include "glheader.h"
-
-
-/* Wrap all the information about vertices up in a struct.  Has
- * additional fields compared to the other vectors to help us track of
- * different vertex sizes, and whether we need to clean columns out
- * because they contain non-(0,0,0,1) values.  
- *
- * The start field is used to reserve data for copied vertices at the
- * end of gl_transform_vb, and avoids the need for a multiplication in
- * the transformation routines.
- */
-typedef struct {
-   GLfloat (*data)[4];           /* may be malloced or point to client data */
-   GLfloat *start;
-   GLuint count;
-   GLuint stride;		 /* start to start */
-   GLuint size;			 /* 2-4 for vertices and 1-4 for texcoords */
-   GLuint flags;		 /* which columns are dirty */
-   void *storage;
-} GLvector4f;
-
-
-extern void gl_vector4f_print( GLvector4f *v, GLubyte *, GLboolean );
-extern void gl_vector4f_init( GLvector4f *v, GLuint flags,
-			      GLfloat (*storage)[4] );
-extern void gl_vector4f_alloc( GLvector4f *v, GLuint sz, GLuint flags,
-			       GLuint count, GLuint alignment );
-extern void gl_vector4f_free( GLvector4f *v );
-extern void gl_vector4f_clean_elem( GLvector4f *vec, GLuint nr, GLuint elt );
-
-
-#define VEC_DIRTY_0        0x1	/* dirty flags not really used any more */
-#define VEC_DIRTY_1        0x2
-#define VEC_DIRTY_2        0x4
-#define VEC_DIRTY_3        0x8
-#define VEC_MALLOC         0x10
-#define VEC_WRITABLE       0x20	/* keep both + and - bits for easy testing */
-#define VEC_NOT_WRITABLE   0x40
-#define VEC_GOOD_STRIDE    0x80	
-#define VEC_BAD_STRIDE     0x100
-
-#define VEC_WRITABLE_FLAGS (VEC_WRITABLE|VEC_NOT_WRITABLE)
-#define VEC_STRIDE_FLAGS   (VEC_GOOD_STRIDE|VEC_BAD_STRIDE)
-
-
-#define VEC_SIZE_1   VEC_DIRTY_0
-#define VEC_SIZE_2   (VEC_DIRTY_0|VEC_DIRTY_1)
-#define VEC_SIZE_3   (VEC_DIRTY_0|VEC_DIRTY_1|VEC_DIRTY_2)
-#define VEC_SIZE_4   (VEC_DIRTY_0|VEC_DIRTY_1|VEC_DIRTY_2|VEC_DIRTY_3)
-
-
-/* Could use a single vector type for normals and vertices, but
- * this way avoids some casts.  
- */
-typedef struct {
-   GLfloat (*data)[3];       
-   GLfloat *start;
-   GLuint count;
-   GLuint stride;
-   GLuint flags;
-   void *storage;
-} GLvector3f;
-
-extern void gl_vector3f_print( GLvector3f *v, GLubyte *, GLboolean );
-extern void gl_vector3f_free( GLvector3f *v );
-extern void gl_vector3f_init( GLvector3f *v, GLuint flags, GLfloat (*)[3] );
-extern void gl_vector3f_alloc( GLvector3f *v, GLuint flags, GLuint count,
-			       GLuint alignment );
-
-
-/* For 4ub rgba values.
- */
-typedef struct {
-   GLubyte (*data)[4];
-   GLubyte *start;
-   GLuint count;
-   GLuint stride;		 
-   GLuint flags; 
-   void *storage;
-} GLvector4ub;
-
-extern void gl_vector4ub_init( GLvector4ub *v, GLuint flags, 
-			       GLubyte (*storage)[4] );
-extern void gl_vector4ub_free( GLvector4ub * );
-extern void gl_vector4ub_alloc( GLvector4ub *v, GLuint flags, GLuint count,
-				GLuint alignment );
-
-
-
-
-/* For 1ub values, eg edgeflag.
- */
-typedef struct {
-   GLubyte *data;
-   GLubyte *start;
-   GLuint count;
-   GLuint stride;		 
-   GLuint flags; 
-   void *storage;
-} GLvector1ub;
-
-extern void gl_vector1ub_init( GLvector1ub *v, GLuint flags, GLubyte *storage);
-extern void gl_vector1ub_free( GLvector1ub * );
-extern void gl_vector1ub_alloc( GLvector1ub *v, GLuint flags, GLuint count,
-				GLuint alignment );
-
-
-
-
-/* For, eg Index, Array element.
- */
-typedef struct {
-   GLuint *data;
-   GLuint *start;
-   GLuint count;
-   GLuint stride; 
-   GLuint flags; 
-   void *storage;
-} GLvector1ui;
-
-extern void gl_vector1ui_init( GLvector1ui *v, GLuint flags, GLuint *storage );
-extern void gl_vector1ui_free( GLvector1ui * );
-extern void gl_vector1ui_alloc( GLvector1ui *v, GLuint flags, GLuint count, 
-				GLuint alignment );
-
-
-
-/* End up doing a lot of slow imuls if not careful.
- */
-#define VEC_ELT( v, t, i ) ((t *) (((GLbyte *)((v)->data))+(i)*(v)->stride) )
-
-
-#endif
Index: xc/extras/Mesa/src/vertices.c
diff -u xc/extras/Mesa/src/vertices.c:1.4 xc/extras/Mesa/src/vertices.c:removed
--- xc/extras/Mesa/src/vertices.c:1.4	Mon Nov 13 16:55:35 2000
+++ xc/extras/Mesa/src/vertices.c	Thu Feb 27 12:15:45 2003
@@ -1,211 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "types.h"
-#include "vertices.h"
-#endif
-
-
-#if defined(USE_X86_ASM)
-#include "X86/common_x86_asm.h"
-#endif
-
-
-/* The start of a bunch of vertex oriented geometry routines.  These
- * are expected to support the production of driver-specific fast paths
- * for CVA and eventually normal processing.
- *
- * These have been taken from fxfastpath.c, and are now also used in
- * the mga driver.
- *
- * These should grow to include:
- *     - choice of 8/16 dword vertices
- *     - ??
- *     - use of portable assembly layouts.
- *
- * More tentatively:
- *     - more (all?) matrix types
- *     - more (?) vertex sizes
- *
- * -- Keith Whitwell.
- */
-
-/* The inline 3dnow code seems to give problems with some peoples
- * compiler/binutils.
- */
-/*  #undef USE_3DNOW_ASM */
-
-
-#if defined(USE_X86_ASM) && defined(__GNUC__)
-
-
-#endif
-
-
-static void _PROJAPI transform_v16( GLfloat *f,
-				    const GLfloat *m,
-				    const GLfloat *obj,
-				    GLuint obj_stride,
-				    GLuint count )
-{
-   GLuint i;
-
-   for (i = 0 ; i < count ; i++, STRIDE_F(obj, obj_stride), f+=16)
-   {
-      const GLfloat ox = obj[0], oy = obj[1], oz = obj[2];
-      f[0] = m[0] * ox + m[4] * oy + m[8]  * oz + m[12];
-      f[1] = m[1] * ox + m[5] * oy + m[9]  * oz + m[13];
-      f[2] = m[2] * ox + m[6] * oy + m[10] * oz + m[14];
-      f[3] = m[3] * ox + m[7] * oy + m[11] * oz + m[15];
-   }
-}
-
-
-
-
-static void _PROJAPI cliptest_v16( GLfloat *first,
-				   GLfloat *last,
-				   GLubyte *p_clipOr,
-				   GLubyte *p_clipAnd,
-				   GLubyte *clipmask )
-{
-   GLubyte clipAnd = (GLubyte) ~0;
-   GLubyte clipOr = 0;
-   GLfloat *f = first;
-   static int i;
-   i = 0;
-
-   for ( ; f != last ; f+=16, clipmask++, i++)
-   {
-      const GLfloat cx = f[0];
-      const GLfloat cy = f[1];
-      const GLfloat cz = f[2];
-      const GLfloat cw = f[3];
-      GLubyte mask = 0;
-
-      if (cx >  cw) mask |= CLIP_RIGHT_BIT;
-      if (cx < -cw) mask |= CLIP_LEFT_BIT;
-      if (cy >  cw) mask |= CLIP_TOP_BIT;
-      if (cy < -cw) mask |= CLIP_BOTTOM_BIT;
-      if (cz >  cw) mask |= CLIP_FAR_BIT;
-      if (cz < -cw) mask |= CLIP_NEAR_BIT;
-
-      *clipmask = mask;
-      clipAnd &= mask;
-      clipOr |= mask;
-   }
-
-   (*p_clipOr) |= clipOr;
-   (*p_clipAnd) &= clipAnd;
-}
-
-
-
-/* Project all vertices upto but not including last.  Guarenteed to be
- * at least one such vertex.
- */
-static void _PROJAPI project_verts( GLfloat *first,
-				    GLfloat *last,
-				    const GLfloat *m,
-				    GLuint stride )
-{
-   const GLfloat sx = m[0], sy = m[5], sz = m[10];
-   const GLfloat tx = m[12], ty = m[13], tz = m[14];
-   GLfloat *f;
-
-   for ( f = first ; f != last ; STRIDE_F(f,stride))
-   {
-      const GLfloat oow = 1.0F / f[3];
-      f[0] = sx * f[0] * oow + tx;
-      f[1] = sy * f[1] * oow + ty;
-      f[2] = sz * f[2] * oow + tz;
-      f[3] = oow;
-   }
-}
-
-static void _PROJAPI project_clipped_verts( GLfloat *first,
-					    GLfloat *last,
-					    const GLfloat *m,
-					    GLuint stride,
-					    const GLubyte *clipmask )
-{
-   const GLfloat sx = m[0], sy = m[5], sz = m[10];
-   const GLfloat tx = m[12], ty = m[13], tz = m[14];
-   GLfloat *f;
-
-   for ( f = first ; f != last ; STRIDE_F(f,stride), clipmask++)
-   {
-      if (!*clipmask) {
-	 const GLfloat oow = 1.0F / f[3];
-	 f[0] = sx * f[0] * oow + tx;
-	 f[1] = sy * f[1] * oow + ty;
-	 f[2] = sz * f[2] * oow + tz;
-	 f[3] = oow;
-      }
-   }
-}
-
-
-GLenum gl_reduce_prim[GL_POLYGON+1] = {
-   GL_POINTS,
-   GL_LINES,
-   GL_LINES,
-   GL_LINES,
-   GL_TRIANGLES,
-   GL_TRIANGLES,
-   GL_TRIANGLES,
-   GL_TRIANGLES,
-   GL_TRIANGLES,
-   GL_TRIANGLES,
-};
-
-
-gl_transform_func	gl_xform_points3_v16_general;
-gl_cliptest_func	gl_cliptest_points4_v16;
-gl_project_func		gl_project_v16;
-gl_project_clipped_func gl_project_clipped_v16;
-
-
-void gl_init_vertices( void )
-{
-   gl_xform_points3_v16_general	= transform_v16;
-   gl_cliptest_points4_v16	= cliptest_v16;
-   gl_project_v16		= project_verts;
-   gl_project_clipped_v16	= project_clipped_verts;
-
-#if 0
-   /* GH: Add tests/benchmarks for the vertex asm */
-   gl_test_all_vertex_functions( "default" );
-#endif
-
-#ifdef USE_X86_ASM
-   gl_init_all_x86_vertex_asm();
-#endif
-}
Index: xc/extras/Mesa/src/vertices.h
diff -u xc/extras/Mesa/src/vertices.h:1.4 xc/extras/Mesa/src/vertices.h:removed
--- xc/extras/Mesa/src/vertices.h:1.4	Mon Nov 13 16:55:35 2000
+++ xc/extras/Mesa/src/vertices.h	Thu Feb 27 12:15:45 2003
@@ -1,79 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef __VERTICES_H__
-#define __VERTICES_H__
-
-#ifdef USE_X86_ASM
-#define _PROJAPI _ASMAPI
-#define _PROJAPIP _ASMAPIP
-#else
-#define _PROJAPI
-#define _PROJAPIP *
-#endif
-
-typedef void (_PROJAPIP gl_transform_func)( GLfloat *first_vert,
-					    const GLfloat *m,
-					    const GLfloat *src,
-					    GLuint src_stride,
-					    GLuint count );
-
-typedef void (_PROJAPIP gl_cliptest_func)( GLfloat *first_vert,
-					   GLfloat *last_vert, /* use count instead? */
-					   GLubyte *or_mask,
-					   GLubyte *and_mask,
-					   GLubyte *clip_mask );
-
-typedef void (_PROJAPIP gl_project_func)( GLfloat *first,
-					  GLfloat *last,
-					  const GLfloat *m,
-					  GLuint stride );
-
-typedef void (_PROJAPIP gl_project_clipped_func)( GLfloat *first,
-						  GLfloat *last,
-						  const GLfloat *m,
-						  GLuint stride,
-						  const GLubyte *clipmask );
-
-typedef void (_PROJAPIP gl_vertex_interp_func)( GLfloat t,
-						GLfloat *result,
-						const GLfloat *in,
-						const GLfloat *out );
-
-
-/* At the moment these are used by fastpaths in the FX and MGA drivers.
- */
-extern gl_transform_func       gl_xform_points3_v16_general;
-extern gl_cliptest_func        gl_cliptest_points4_v16;
-extern gl_project_func         gl_project_v16;
-extern gl_project_clipped_func gl_project_clipped_v16;
-
-
-extern GLenum gl_reduce_prim[];
-
-extern void gl_init_vertices( void );
-
-#endif
Index: xc/extras/Mesa/src/vtxfmt.c
diff -u /dev/null xc/extras/Mesa/src/vtxfmt.c:1.2
--- /dev/null	Thu Feb 27 12:15:45 2003
+++ xc/extras/Mesa/src/vtxfmt.c	Mon Dec 16 11:18:28 2002
@@ -0,0 +1,178 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#include "glheader.h"
+#include "api_loopback.h"
+#include "context.h"
+#include "mtypes.h"
+#include "state.h"
+#include "vtxfmt.h"
+
+
+/* The neutral vertex format.  This wraps all tnl module functions,
+ * verifying that the currently-installed module is valid and then
+ * installing the function pointers in a lazy fashion.  It records the
+ * function pointers that have been swapped out, which allows a fast
+ * restoration of the neutral module in almost all cases -- a typical
+ * app might only require 4-6 functions to be modified from the neutral
+ * baseline, and only restoring these is certainly preferable to doing
+ * the entire module's 60 or so function pointers.
+ */
+
+#define PRE_LOOPBACK( FUNC )						\
+{									\
+   GET_CURRENT_CONTEXT(ctx);						\
+   struct gl_tnl_module *tnl = &(ctx->TnlModule);			\
+									\
+   ASSERT( tnl->Current );						\
+   ASSERT( tnl->SwapCount < NUM_VERTEX_FORMAT_ENTRIES );		\
+									\
+   /* Save the swapped function's dispatch entry so it can be		\
+    * restored later.							\
+    */									\
+   tnl->Swapped[tnl->SwapCount][0] = (void *)&(ctx->Exec->FUNC);	\
+   tnl->Swapped[tnl->SwapCount][1] = (void *)TAG(FUNC);			\
+   tnl->SwapCount++;							\
+									\
+   if ( 0 )								\
+      fprintf( stderr, "   swapping gl" #FUNC"...\n" );			\
+									\
+   /* Install the tnl function pointer.					\
+    */									\
+   ctx->Exec->FUNC = tnl->Current->FUNC;				\
+}
+
+#define TAG(x) neutral_##x
+#include "vtxfmt_tmp.h"
+
+
+
+static void install_vtxfmt( struct _glapi_table *tab, GLvertexformat *vfmt )
+{
+   tab->ArrayElement = vfmt->ArrayElement;
+   tab->Color3f = vfmt->Color3f;
+   tab->Color3fv = vfmt->Color3fv;
+   tab->Color3ub = vfmt->Color3ub;
+   tab->Color3ubv = vfmt->Color3ubv;
+   tab->Color4f = vfmt->Color4f;
+   tab->Color4fv = vfmt->Color4fv;
+   tab->Color4ub = vfmt->Color4ub;
+   tab->Color4ubv = vfmt->Color4ubv;
+   tab->EdgeFlag = vfmt->EdgeFlag;
+   tab->EdgeFlagv = vfmt->EdgeFlagv;
+   tab->EvalCoord1f = vfmt->EvalCoord1f;
+   tab->EvalCoord1fv = vfmt->EvalCoord1fv;
+   tab->EvalCoord2f = vfmt->EvalCoord2f;
+   tab->EvalCoord2fv = vfmt->EvalCoord2fv;
+   tab->EvalPoint1 = vfmt->EvalPoint1;
+   tab->EvalPoint2 = vfmt->EvalPoint2;
+   tab->FogCoordfEXT = vfmt->FogCoordfEXT;
+   tab->FogCoordfvEXT = vfmt->FogCoordfvEXT;
+   tab->Indexi = vfmt->Indexi;
+   tab->Indexiv = vfmt->Indexiv;
+   tab->Materialfv = vfmt->Materialfv;
+   tab->MultiTexCoord1fARB = vfmt->MultiTexCoord1fARB;
+   tab->MultiTexCoord1fvARB = vfmt->MultiTexCoord1fvARB;
+   tab->MultiTexCoord2fARB = vfmt->MultiTexCoord2fARB;
+   tab->MultiTexCoord2fvARB = vfmt->MultiTexCoord2fvARB;
+   tab->MultiTexCoord3fARB = vfmt->MultiTexCoord3fARB;
+   tab->MultiTexCoord3fvARB = vfmt->MultiTexCoord3fvARB;
+   tab->MultiTexCoord4fARB = vfmt->MultiTexCoord4fARB;
+   tab->MultiTexCoord4fvARB = vfmt->MultiTexCoord4fvARB;
+   tab->Normal3f = vfmt->Normal3f;
+   tab->Normal3fv = vfmt->Normal3fv;
+   tab->SecondaryColor3fEXT = vfmt->SecondaryColor3fEXT;
+   tab->SecondaryColor3fvEXT = vfmt->SecondaryColor3fvEXT;
+   tab->SecondaryColor3ubEXT = vfmt->SecondaryColor3ubEXT;
+   tab->SecondaryColor3ubvEXT = vfmt->SecondaryColor3ubvEXT;
+   tab->TexCoord1f = vfmt->TexCoord1f;
+   tab->TexCoord1fv = vfmt->TexCoord1fv;
+   tab->TexCoord2f = vfmt->TexCoord2f;
+   tab->TexCoord2fv = vfmt->TexCoord2fv;
+   tab->TexCoord3f = vfmt->TexCoord3f;
+   tab->TexCoord3fv = vfmt->TexCoord3fv;
+   tab->TexCoord4f = vfmt->TexCoord4f;
+   tab->TexCoord4fv = vfmt->TexCoord4fv;
+   tab->Vertex2f = vfmt->Vertex2f;
+   tab->Vertex2fv = vfmt->Vertex2fv;
+   tab->Vertex3f = vfmt->Vertex3f;
+   tab->Vertex3fv = vfmt->Vertex3fv;
+   tab->Vertex4f = vfmt->Vertex4f;
+   tab->Vertex4fv = vfmt->Vertex4fv;
+   tab->Begin = vfmt->Begin;
+   tab->End = vfmt->End;
+
+/*     tab->NewList = vfmt->NewList; */
+   tab->CallList = vfmt->CallList;
+
+   tab->Rectf = vfmt->Rectf;
+   tab->DrawArrays = vfmt->DrawArrays;
+   tab->DrawElements = vfmt->DrawElements;
+   tab->DrawRangeElements = vfmt->DrawRangeElements;
+   tab->EvalMesh1 = vfmt->EvalMesh1;
+   tab->EvalMesh2 = vfmt->EvalMesh2;
+}
+
+
+void _mesa_init_exec_vtxfmt( GLcontext *ctx )
+{
+   install_vtxfmt( ctx->Exec, &neutral_vtxfmt );
+   ctx->TnlModule.SwapCount = 0;
+}
+
+
+void _mesa_install_exec_vtxfmt( GLcontext *ctx, GLvertexformat *vfmt )
+{
+   ctx->TnlModule.Current = vfmt;
+   _mesa_restore_exec_vtxfmt( ctx );
+   if ( ctx->ExecPrefersFloat != vfmt->prefer_float_colors )
+      _mesa_loopback_prefer_float( ctx->Exec, vfmt->prefer_float_colors );
+}
+
+void _mesa_install_save_vtxfmt( GLcontext *ctx, GLvertexformat *vfmt )
+{
+   install_vtxfmt( ctx->Save, vfmt );
+   if ( ctx->SavePrefersFloat != vfmt->prefer_float_colors )
+      _mesa_loopback_prefer_float( ctx->Save, vfmt->prefer_float_colors );
+}
+
+
+void _mesa_restore_exec_vtxfmt( GLcontext *ctx )
+{
+   struct gl_tnl_module *tnl = &(ctx->TnlModule);
+   GLuint i;
+
+   /* Restore the neutral tnl module wrapper.
+    */
+   for ( i = 0 ; i < tnl->SwapCount ; i++ ) {
+      *(void **)tnl->Swapped[i][0] = tnl->Swapped[i][1];
+   }
+
+   tnl->SwapCount = 0;
+}
Index: xc/extras/Mesa/src/vtxfmt.h
diff -u /dev/null xc/extras/Mesa/src/vtxfmt.h:1.2
--- /dev/null	Thu Feb 27 12:15:45 2003
+++ xc/extras/Mesa/src/vtxfmt.h	Mon Dec 16 11:18:28 2002
@@ -0,0 +1,40 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef _VTXFMT_H_
+#define _VTXFMT_H_
+
+extern void _mesa_init_exec_vtxfmt( GLcontext *ctx );
+
+extern void _mesa_install_exec_vtxfmt( GLcontext *ctx, GLvertexformat *vfmt );
+extern void _mesa_install_save_vtxfmt( GLcontext *ctx, GLvertexformat *vfmt );
+
+extern void _mesa_restore_exec_vtxfmt( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/vtxfmt_tmp.h
diff -u /dev/null xc/extras/Mesa/src/vtxfmt_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:45 2003
+++ xc/extras/Mesa/src/vtxfmt_tmp.h	Mon Dec 16 11:18:28 2002
@@ -0,0 +1,457 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.1
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef PRE_LOOPBACK
+#define PRE_LOOPBACK( FUNC )
+#endif
+
+static void TAG(ArrayElement)( GLint i )
+{
+   PRE_LOOPBACK( ArrayElement );
+   glArrayElement( i );
+}
+
+static void TAG(Color3f)( GLfloat a, GLfloat b, GLfloat c )
+{
+   PRE_LOOPBACK( Color3f );
+   glColor3f( a, b, c );
+}
+
+static void TAG(Color3fv)( const GLfloat *v )
+{
+   PRE_LOOPBACK( Color3fv );
+   glColor3fv( v );
+}
+
+static void TAG(Color3ub)( GLubyte a, GLubyte b, GLubyte c )
+{
+   PRE_LOOPBACK( Color3ub );
+   glColor3ub( a, b, c );
+}
+
+static void TAG(Color3ubv)( const GLubyte *v )
+{
+   PRE_LOOPBACK( Color3ubv );
+   glColor3ubv( v );
+}
+
+static void TAG(Color4f)( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
+{
+   PRE_LOOPBACK( Color4f );
+   glColor4f( a, b, c, d );
+}
+
+static void TAG(Color4fv)( const GLfloat *v )
+{
+   PRE_LOOPBACK( Color4fv );
+   glColor4fv( v );
+}
+
+static void TAG(Color4ub)( GLubyte a, GLubyte b, GLubyte c, GLubyte d )
+{
+   PRE_LOOPBACK( Color4ub );
+   glColor4ub( a, b, c, d );
+}
+
+static void TAG(Color4ubv)( const GLubyte *v )
+{
+   PRE_LOOPBACK( Color4ubv );
+   glColor4ubv( v );
+}
+
+static void TAG(EdgeFlag)( GLboolean a )
+{
+   PRE_LOOPBACK( EdgeFlag );
+   glEdgeFlag( a );
+}
+
+static void TAG(EdgeFlagv)( const GLboolean *v )
+{
+   PRE_LOOPBACK( EdgeFlagv );
+   glEdgeFlagv( v );
+}
+
+static void TAG(EvalCoord1f)( GLfloat a )
+{
+   PRE_LOOPBACK( EvalCoord1f );
+   glEvalCoord1f( a );
+}
+
+static void TAG(EvalCoord1fv)( const GLfloat *v )
+{
+   PRE_LOOPBACK( EvalCoord1fv );
+   glEvalCoord1fv( v );
+}
+
+static void TAG(EvalCoord2f)( GLfloat a, GLfloat b )
+{
+   PRE_LOOPBACK( EvalCoord2f );
+   glEvalCoord2f( a, b );
+}
+
+static void TAG(EvalCoord2fv)( const GLfloat *v )
+{
+   PRE_LOOPBACK( EvalCoord2fv );
+   glEvalCoord2fv( v );
+}
+
+static void TAG(EvalPoint1)( GLint a )
+{
+   PRE_LOOPBACK( EvalPoint1 );
+   glEvalPoint1( a );
+}
+
+static void TAG(EvalPoint2)( GLint a, GLint b )
+{
+   PRE_LOOPBACK( EvalPoint2 );
+   glEvalPoint2( a, b );
+}
+
+static void TAG(FogCoordfEXT)( GLfloat a )
+{
+   PRE_LOOPBACK( FogCoordfEXT );
+   _glapi_Dispatch->FogCoordfEXT( a );
+}
+
+static void TAG(FogCoordfvEXT)( const GLfloat *v )
+{
+   PRE_LOOPBACK( FogCoordfvEXT );
+   _glapi_Dispatch->FogCoordfvEXT( v );
+}
+
+static void TAG(Indexi)( GLint a )
+{
+   PRE_LOOPBACK( Indexi );
+   glIndexi( a );
+}
+
+static void TAG(Indexiv)( const GLint *v )
+{
+   PRE_LOOPBACK( Indexiv );
+   glIndexiv( v );
+}
+
+static void TAG(Materialfv)( GLenum face, GLenum pname, const GLfloat *v )
+{
+   PRE_LOOPBACK( Materialfv );
+   glMaterialfv( face, pname, v );
+}
+
+static void TAG(MultiTexCoord1fARB)( GLenum target, GLfloat a )
+{
+   PRE_LOOPBACK( MultiTexCoord1fARB );
+   glMultiTexCoord1fARB( target, a );
+}
+
+static void TAG(MultiTexCoord1fvARB)( GLenum target, const GLfloat *tc )
+{
+   PRE_LOOPBACK( MultiTexCoord1fvARB );
+   glMultiTexCoord1fvARB( target, tc );
+}
+
+static void TAG(MultiTexCoord2fARB)( GLenum target, GLfloat a, GLfloat b )
+{
+   PRE_LOOPBACK( MultiTexCoord2fARB );
+   glMultiTexCoord2fARB( target, a, b );
+}
+
+static void TAG(MultiTexCoord2fvARB)( GLenum target, const GLfloat *tc )
+{
+   PRE_LOOPBACK( MultiTexCoord2fvARB );
+   glMultiTexCoord2fvARB( target, tc );
+}
+
+static void TAG(MultiTexCoord3fARB)( GLenum target, GLfloat a,
+				     GLfloat b, GLfloat c )
+{
+   PRE_LOOPBACK( MultiTexCoord3fARB );
+   glMultiTexCoord3fARB( target, a, b, c );
+}
+
+static void TAG(MultiTexCoord3fvARB)( GLenum target, const GLfloat *tc )
+{
+   PRE_LOOPBACK( MultiTexCoord3fvARB );
+   glMultiTexCoord3fvARB( target, tc );
+}
+
+static void TAG(MultiTexCoord4fARB)( GLenum target, GLfloat a,
+				     GLfloat b, GLfloat c, GLfloat d )
+{
+   PRE_LOOPBACK( MultiTexCoord4fARB );
+   glMultiTexCoord4fARB( target, a, b, c, d );
+}
+
+static void TAG(MultiTexCoord4fvARB)( GLenum target, const GLfloat *tc )
+{
+   PRE_LOOPBACK( MultiTexCoord4fvARB );
+   glMultiTexCoord4fvARB( target, tc );
+}
+
+static void TAG(Normal3f)( GLfloat a, GLfloat b, GLfloat c )
+{
+   PRE_LOOPBACK( Normal3f );
+   glNormal3f( a, b, c );
+}
+
+static void TAG(Normal3fv)( const GLfloat *v )
+{
+   PRE_LOOPBACK( Normal3fv );
+   glNormal3fv( v );
+}
+
+static void TAG(SecondaryColor3fEXT)( GLfloat a, GLfloat b, GLfloat c )
+{
+   PRE_LOOPBACK( SecondaryColor3fEXT );
+   _glapi_Dispatch->SecondaryColor3fEXT( a, b, c );
+}
+
+static void TAG(SecondaryColor3fvEXT)( const GLfloat *v )
+{
+   PRE_LOOPBACK( SecondaryColor3fvEXT );
+   _glapi_Dispatch->SecondaryColor3fvEXT( v );
+}
+
+static void TAG(SecondaryColor3ubEXT)( GLubyte a, GLubyte b, GLubyte c )
+{
+   PRE_LOOPBACK( SecondaryColor3ubEXT );
+   _glapi_Dispatch->SecondaryColor3ubEXT( a, b, c );
+}
+
+static void TAG(SecondaryColor3ubvEXT)( const GLubyte *v )
+{
+   PRE_LOOPBACK( SecondaryColor3ubvEXT );
+   _glapi_Dispatch->SecondaryColor3ubvEXT( v );
+}
+
+static void TAG(TexCoord1f)( GLfloat a )
+{
+   PRE_LOOPBACK( TexCoord1f );
+   glTexCoord1f( a );
+}
+
+static void TAG(TexCoord1fv)( const GLfloat *tc )
+{
+   PRE_LOOPBACK( TexCoord1fv );
+   glTexCoord1fv( tc );
+}
+
+static void TAG(TexCoord2f)( GLfloat a, GLfloat b )
+{
+   PRE_LOOPBACK( TexCoord2f );
+   glTexCoord2f( a, b );
+}
+
+static void TAG(TexCoord2fv)( const GLfloat *tc )
+{
+   PRE_LOOPBACK( TexCoord2fv );
+   glTexCoord2fv( tc );
+}
+
+static void TAG(TexCoord3f)( GLfloat a, GLfloat b, GLfloat c )
+{
+   PRE_LOOPBACK( TexCoord3f );
+   glTexCoord3f( a, b, c );
+}
+
+static void TAG(TexCoord3fv)( const GLfloat *tc )
+{
+   PRE_LOOPBACK( TexCoord3fv );
+   glTexCoord3fv( tc );
+}
+
+static void TAG(TexCoord4f)( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
+{
+   PRE_LOOPBACK( TexCoord4f );
+   glTexCoord4f( a, b, c, d );
+}
+
+static void TAG(TexCoord4fv)( const GLfloat *tc )
+{
+   PRE_LOOPBACK( TexCoord4fv );
+   glTexCoord4fv( tc );
+}
+
+static void TAG(Vertex2f)( GLfloat a, GLfloat b )
+{
+   PRE_LOOPBACK( Vertex2f );
+   glVertex2f( a, b );
+}
+
+static void TAG(Vertex2fv)( const GLfloat *obj )
+{
+   PRE_LOOPBACK( Vertex2fv );
+   glVertex2fv( obj );
+}
+
+static void TAG(Vertex3f)( GLfloat a, GLfloat b, GLfloat c )
+{
+   PRE_LOOPBACK( Vertex3f );
+   glVertex3f( a, b, c );
+}
+
+static void TAG(Vertex3fv)( const GLfloat *obj )
+{
+   PRE_LOOPBACK( Vertex3fv );
+   glVertex3fv( obj );
+}
+
+static void TAG(Vertex4f)( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
+{
+   PRE_LOOPBACK( Vertex4f );
+   glVertex4f( a, b, c, d );
+}
+
+static void TAG(Vertex4fv)( const GLfloat *obj )
+{
+   PRE_LOOPBACK( Vertex4fv );
+   glVertex4fv( obj );
+}
+
+static void TAG(CallList)( GLuint i )
+{
+   PRE_LOOPBACK( CallList );
+   glCallList( i );
+}
+
+static void TAG(Begin)( GLenum mode )
+{
+   PRE_LOOPBACK( Begin );
+   glBegin( mode );
+}
+
+static void TAG(End)( void )
+{
+   PRE_LOOPBACK( End );
+   glEnd();
+}
+
+static void TAG(Rectf)( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+   PRE_LOOPBACK( Rectf );
+   glRectf( x1, y1, x2, y2 );
+}
+
+static void TAG(DrawArrays)( GLenum mode, GLint start, GLsizei count )
+{
+   PRE_LOOPBACK( DrawArrays );
+   glDrawArrays( mode, start, count );
+}
+
+static void TAG(DrawElements)( GLenum mode, GLsizei count, GLenum type,
+			       const void *indices )
+{
+   PRE_LOOPBACK( DrawElements );
+   glDrawElements( mode, count, type, indices );
+}
+
+static void TAG(DrawRangeElements)( GLenum mode, GLuint start,
+				    GLuint end, GLsizei count,
+				    GLenum type, const void *indices )
+{
+   PRE_LOOPBACK( DrawRangeElements );
+   glDrawRangeElements( mode, start, end, count, type, indices );
+}
+
+static void TAG(EvalMesh1)( GLenum mode, GLint i1, GLint i2 )
+{
+   PRE_LOOPBACK( EvalMesh1 );
+   glEvalMesh1( mode, i1, i2 );
+}
+
+static void TAG(EvalMesh2)( GLenum mode, GLint i1, GLint i2,
+			    GLint j1, GLint j2 )
+{
+   PRE_LOOPBACK( EvalMesh2 );
+   glEvalMesh2( mode, i1, i2, j1, j2 );
+}
+
+
+static GLvertexformat TAG(vtxfmt) = {
+   TAG(ArrayElement),
+   TAG(Color3f),
+   TAG(Color3fv),
+   TAG(Color3ub),
+   TAG(Color3ubv),
+   TAG(Color4f),
+   TAG(Color4fv),
+   TAG(Color4ub),
+   TAG(Color4ubv),
+   TAG(EdgeFlag),
+   TAG(EdgeFlagv),
+   TAG(EvalCoord1f),
+   TAG(EvalCoord1fv),
+   TAG(EvalCoord2f),
+   TAG(EvalCoord2fv),
+   TAG(EvalPoint1),
+   TAG(EvalPoint2),
+   TAG(FogCoordfEXT),
+   TAG(FogCoordfvEXT),
+   TAG(Indexi),
+   TAG(Indexiv),
+   TAG(Materialfv),
+   TAG(MultiTexCoord1fARB),
+   TAG(MultiTexCoord1fvARB),
+   TAG(MultiTexCoord2fARB),
+   TAG(MultiTexCoord2fvARB),
+   TAG(MultiTexCoord3fARB),
+   TAG(MultiTexCoord3fvARB),
+   TAG(MultiTexCoord4fARB),
+   TAG(MultiTexCoord4fvARB),
+   TAG(Normal3f),
+   TAG(Normal3fv),
+   TAG(SecondaryColor3fEXT),
+   TAG(SecondaryColor3fvEXT),
+   TAG(SecondaryColor3ubEXT),
+   TAG(SecondaryColor3ubvEXT),
+   TAG(TexCoord1f),
+   TAG(TexCoord1fv),
+   TAG(TexCoord2f),
+   TAG(TexCoord2fv),
+   TAG(TexCoord3f),
+   TAG(TexCoord3fv),
+   TAG(TexCoord4f),
+   TAG(TexCoord4fv),
+   TAG(Vertex2f),
+   TAG(Vertex2fv),
+   TAG(Vertex3f),
+   TAG(Vertex3fv),
+   TAG(Vertex4f),
+   TAG(Vertex4fv),
+   TAG(CallList),
+   TAG(Begin),
+   TAG(End),
+   TAG(Rectf),
+   TAG(DrawArrays),
+   TAG(DrawElements),
+   TAG(DrawRangeElements),
+   TAG(EvalMesh1),
+   TAG(EvalMesh2),
+};
+
+#undef TAG
+#undef PRE_LOOPBACK
Index: xc/extras/Mesa/src/winpos.c
diff -u xc/extras/Mesa/src/winpos.c:1.4 xc/extras/Mesa/src/winpos.c:removed
--- xc/extras/Mesa/src/winpos.c:1.4	Thu Mar  2 11:07:16 2000
+++ xc/extras/Mesa/src/winpos.c	Thu Feb 27 12:15:45 2003
@@ -1,282 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * GL_MESA_window_pos extension
- *
- * This extension offers a set of functions named glWindowPos*MESA() which
- * directly set the current raster position to the given window coordinate.
- * glWindowPos*MESA() are similar to glRasterPos*() but bypass the
- * modelview, projection and viewport transformations.
- *
- * These functions should be very handy in conjunction with glDrawPixels()
- * and glCopyPixels().
- *
- * If your application uses glWindowPos*MESA() and may be compiled with
- * a real OpenGL instead of Mesa you can simply copy the winpos.[ch] files
- * into your source tree and compile them with the rest of your code
- * since glWindowPos*MESA() can, and is, implemented in terms of standard
- * OpenGL commands when not using Mesa.  In your source files which use
- * glWindowPos*MESA() just #include "winpos.h".
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "feedback.h"
-#include "mmath.h"
-#include "rastpos.h"
-#include "winpos.h"
-#endif
-
-
-/*
- * This is a MESA extension function.  Pretty much just like glRasterPos
- * except we don't apply the modelview or projection matrices; specify a
- * window coordinate directly.
- * Caller:  context->API.WindowPos4fMESA pointer.
- */
-void
-_mesa_WindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx, "glWindowPosMESA" );
-
-   /* set raster position */
-   ctx->Current.RasterPos[0] = x;
-   ctx->Current.RasterPos[1] = y;
-   ctx->Current.RasterPos[2] = CLAMP( z, 0.0F, 1.0F );
-   ctx->Current.RasterPos[3] = w;
-
-   ctx->Current.RasterPosValid = GL_TRUE;
-   ctx->Current.RasterDistance = 0.0F;
-
-   /* raster color = current color or index */
-   if (ctx->Visual->RGBAflag) {
-      UBYTE_RGBA_TO_FLOAT_RGBA(ctx->Current.RasterColor, 
-                               ctx->Current.ByteColor);
-   }
-   else {
-      ctx->Current.RasterIndex = ctx->Current.Index;
-   }
-
-   /* raster texcoord = current texcoord */
-   {
-      GLuint texSet;
-      for (texSet=0; texSet<MAX_TEXTURE_UNITS; texSet++) {
-         COPY_4FV( ctx->Current.RasterMultiTexCoord[texSet],
-                  ctx->Current.Texcoord[texSet] );
-      }
-   }
-
-   if (ctx->RenderMode==GL_SELECT) {
-      gl_update_hitflag( ctx, ctx->Current.RasterPos[2] );
-   }
-}
-
-
-
-
-void
-_mesa_WindowPos2dMESA(GLdouble x, GLdouble y)
-{
-   _mesa_WindowPos4fMESA(x, y, 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos2fMESA(GLfloat x, GLfloat y)
-{
-   _mesa_WindowPos4fMESA(x, y, 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos2iMESA(GLint x, GLint y)
-{
-   _mesa_WindowPos4fMESA(x, y, 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos2sMESA(GLshort x, GLshort y)
-{
-   _mesa_WindowPos4fMESA(x, y, 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
-{
-   _mesa_WindowPos4fMESA(x, y, z, 1.0F);
-}
-
-void
-_mesa_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
-{
-   _mesa_WindowPos4fMESA(x, y, z, 1.0F);
-}
-
-void
-_mesa_WindowPos3iMESA(GLint x, GLint y, GLint z)
-{
-   _mesa_WindowPos4fMESA(x, y, z, 1.0F);
-}
-
-void
-_mesa_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
-{
-   _mesa_WindowPos4fMESA(x, y, z, 1.0F);
-}
-
-void
-_mesa_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-{
-   _mesa_WindowPos4fMESA(x, y, z, w);
-}
-
-void
-_mesa_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
-{
-   _mesa_WindowPos4fMESA(x, y, z, w);
-}
-
-void
-_mesa_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
-{
-   _mesa_WindowPos4fMESA(x, y, z, w);
-}
-
-void
-_mesa_WindowPos2dvMESA(const GLdouble *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos2fvMESA(const GLfloat *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos2ivMESA(const GLint *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos2svMESA(const GLshort *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
-}
-
-void
-_mesa_WindowPos3dvMESA(const GLdouble *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
-}
-
-void
-_mesa_WindowPos3fvMESA(const GLfloat *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
-}
-
-void
-_mesa_WindowPos3ivMESA(const GLint *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
-}
-
-void
-_mesa_WindowPos3svMESA(const GLshort *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
-}
-
-void
-_mesa_WindowPos4dvMESA(const GLdouble *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
-}
-
-void
-_mesa_WindowPos4fvMESA(const GLfloat *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
-}
-
-void
-_mesa_WindowPos4ivMESA(const GLint *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
-}
-
-void
-_mesa_WindowPos4svMESA(const GLshort *v)
-{
-   _mesa_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
-}
-
-
-
-#if 0
-
-/*
- * OpenGL implementation of glWindowPos*MESA()
- */
-void glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
-{
-   GLfloat fx, fy;
-
-   /* Push current matrix mode and viewport attributes */
-   glPushAttrib( GL_TRANSFORM_BIT | GL_VIEWPORT_BIT );
-
-   /* Setup projection parameters */
-   glMatrixMode( GL_PROJECTION );
-   glPushMatrix();
-   glLoadIdentity();
-   glMatrixMode( GL_MODELVIEW );
-   glPushMatrix();
-   glLoadIdentity();
-
-   glDepthRange( z, z );
-   glViewport( (int) x - 1, (int) y - 1, 2, 2 );
-
-   /* set the raster (window) position */
-   fx = x - (int) x;
-   fy = y - (int) y;
-   glRasterPos4f( fx, fy, 0.0, w );
-
-   /* restore matrices, viewport and matrix mode */
-   glPopMatrix();
-   glMatrixMode( GL_PROJECTION );
-   glPopMatrix();
-
-   glPopAttrib();
-}
-
-#endif
Index: xc/extras/Mesa/src/winpos.h
diff -u xc/extras/Mesa/src/winpos.h:1.3 xc/extras/Mesa/src/winpos.h:removed
--- xc/extras/Mesa/src/winpos.h:1.3	Tue Feb 15 02:12:44 2000
+++ xc/extras/Mesa/src/winpos.h	Thu Feb 27 12:15:45 2003
@@ -1,107 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef WINPOS_H
-#define WINPOS_H
-
-
-#include "glheader.h"
-
-
-extern void
-_mesa_WindowPos2dMESA(GLdouble x, GLdouble y);
-
-extern void
-_mesa_WindowPos2fMESA(GLfloat x, GLfloat y);
-
-extern void
-_mesa_WindowPos2iMESA(GLint x, GLint y);
-
-extern void
-_mesa_WindowPos2sMESA(GLshort x, GLshort y);
-
-extern void
-_mesa_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z);
-
-extern void
-_mesa_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z);
-
-extern void
-_mesa_WindowPos3iMESA(GLint x, GLint y, GLint z);
-
-extern void
-_mesa_WindowPos3sMESA(GLshort x, GLshort y, GLshort z);
-
-extern void
-_mesa_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-
-extern void
-_mesa_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-
-extern void
-_mesa_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w);
-
-extern void
-_mesa_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w);
-
-extern void
-_mesa_WindowPos2dvMESA(const GLdouble *v);
-
-extern void
-_mesa_WindowPos2fvMESA(const GLfloat *v);
-
-extern void
-_mesa_WindowPos2ivMESA(const GLint *v);
-
-extern void
-_mesa_WindowPos2svMESA(const GLshort *v);
-
-extern void
-_mesa_WindowPos3dvMESA(const GLdouble *v);
-
-extern void
-_mesa_WindowPos3fvMESA(const GLfloat *v);
-
-extern void
-_mesa_WindowPos3ivMESA(const GLint *v);
-
-extern void
-_mesa_WindowPos3svMESA(const GLshort *v);
-
-extern void
-_mesa_WindowPos4dvMESA(const GLdouble *v);
-
-extern void
-_mesa_WindowPos4fvMESA(const GLfloat *v);
-
-extern void
-_mesa_WindowPos4ivMESA(const GLint *v);
-
-extern void
-_mesa_WindowPos4svMESA(const GLshort *v);
-
-
-#endif
Index: xc/extras/Mesa/src/xform.c
diff -u xc/extras/Mesa/src/xform.c:1.4 xc/extras/Mesa/src/xform.c:removed
--- xc/extras/Mesa/src/xform.c:1.4	Mon Nov 13 16:55:35 2000
+++ xc/extras/Mesa/src/xform.c	Thu Feb 27 12:15:45 2003
@@ -1,274 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Matrix/vertex/vector transformation stuff
- *
- *
- * NOTES:
- * 1. 4x4 transformation matrices are stored in memory in column major order.
- * 2. Points/vertices are to be thought of as column vectors.
- * 3. Transformation of a point p by a matrix M is: p' = M * p
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "context.h"
-#include "mmath.h"
-#include "types.h"
-#include "vb.h"
-#include "xform.h"
-#endif
-
-
-#ifdef DEBUG
-#include "debug_xform.h"
-#endif
-
-#ifdef USE_X86_ASM
-#include "X86/common_x86_asm.h"
-#endif
-
-clip_func gl_clip_tab[5];
-dotprod_func gl_dotprod_tab[2][5];
-vec_copy_func gl_copy_tab[2][0x10];
-normal_func gl_normal_tab[0xf][0x4];
-transform_func **(gl_transform_tab[2]);
-static transform_func *cull_transform_tab[5];
-static transform_func *raw_transform_tab[5];
-
-
-/* Raw data format used for:
- *    - Object-to-eye transform prior to culling, although this too
- *      could be culled under some circumstances.
- *    - Eye-to-clip transform (via the function above).
- *    - Cliptesting
- *    - And everything else too, if culling happens to be disabled.
- */
-#define TAG(x) x##_raw
-#define TAG2(x,y) x##y##_raw
-#define IDX 0
-#define STRIDE_LOOP for (i=0;i<count;i++, STRIDE_F(from, stride))
-#define LOOP for (i=0;i<n;i++)
-#define CULL_CHECK
-#define CLIP_CHECK
-#define ARGS
-#include "xform_tmp.h"
-#include "clip_tmp.h"
-#include "norm_tmp.h"
-#include "dotprod_tmp.h"
-#include "copy_tmp.h"
-#undef TAG
-#undef TAG2
-#undef LOOP
-#undef CULL_CHECK
-#undef CLIP_CHECK
-#undef ARGS
-#undef IDX
-
-/* Culled data used for:
- *    - texture transformations
- *    - viewport map transformation
- *    - normal transformations prior to lighting
- *    - user cliptests
- */
-#define TAG(x) x##_masked
-#define TAG2(x,y) x##y##_masked
-#define IDX CULL_MASK_ACTIVE
-#define STRIDE_LOOP for (i=0;i<count;i++, STRIDE_F(from, stride))
-#define LOOP for (i=0;i<n;i++)
-#define CULL_CHECK if (mask[i])
-#define CLIP_CHECK if ((mask[i] & flag) == 0)
-#define ARGS , const GLubyte mask[]
-#include "xform_tmp.h"
-#include "norm_tmp.h"
-#include "dotprod_tmp.h"
-#include "copy_tmp.h"
-#undef TAG
-#undef TAG2
-#undef LOOP
-#undef CULL_CHECK
-#undef CLIP_CHECK
-#undef ARGS
-#undef IDX
-
-
-
-
-#if 0
-
-#define TAG(x) x##_raw_compacted
-#define TAG2(x,y) x##y##_raw_compacted
-#define IDX COMPACTED_NORMALS
-#define STRIDE_LOOP for (i=0;i<count;i++, STRIDE_F(from, stride))
-#define LOOP for (i=0;i<n;i++)
-#define CHECK if (flag[i] & VERT_NORM)
-#define ARGS
-#include "norm_tmp.h"
-#undef TAG
-#undef TAG2
-#undef LOOP
-#undef CHECK
-#undef ARGS
-#undef IDX
-
-
-#define TAG(x) x##_masked
-#define TAG2(x,y) x##y##_masked
-#define IDX CULL_MASK_ACTIVE|COMPACTED_NORMALS
-#define DUPLICATE_FUNCTIONS
-#include "norm_tmp.h"
-#undef TAG
-#undef TAG2
-#undef LOOP
-#undef CHECK
-#undef ARGS
-#undef IDX
-
-#endif
-
-
-GLvector4f *gl_project_points( GLvector4f *proj_vec,
-			       const GLvector4f *clip_vec )
-{
-   const GLuint stride = clip_vec->stride;
-   const GLfloat *from = (GLfloat *)clip_vec->start;
-   const GLuint count = clip_vec->count;
-   GLfloat (*vProj)[4] = (GLfloat (*)[4])proj_vec->start;
-   GLuint i;
-
-   for (i = 0 ; i < count ; i++, STRIDE_F(from, stride))
-   {
-	 GLfloat oow = 1.0F / from[3];
-	 vProj[i][3] = oow;
-	 vProj[i][0] = from[0] * oow;
-	 vProj[i][1] = from[1] * oow;
-	 vProj[i][2] = from[2] * oow;
-   }
-
-   proj_vec->flags |= VEC_SIZE_4;
-   proj_vec->size = 3;
-   proj_vec->count = clip_vec->count;
-   return proj_vec;
-}
-
-
-
-/*
- * This is called only once.  It initializes several tables with pointers
- * to optimized transformation functions.  This is where we can test for
- * AMD 3Dnow! capability, Intel Katmai, etc. and hook in the right code.
- */
-void gl_init_transformation( void )
-{
-   gl_transform_tab[0] = raw_transform_tab;
-   gl_transform_tab[1] = cull_transform_tab;
-
-   init_c_transformations_raw();
-   init_c_transformations_masked();
-   init_c_norm_transform_raw();
-   init_c_norm_transform_masked();
-   init_c_cliptest_raw();
-   init_copy0_raw();
-   init_copy0_masked();
-   init_dotprod_raw();
-   init_dotprod_masked();
-
-#ifdef DEBUG
-   gl_test_all_transform_functions( "default" );
-   gl_test_all_normal_transform_functions( "default" );
-#endif
-
-#ifdef USE_X86_ASM
-   gl_init_all_x86_transform_asm();
-#endif
-}
-
-
-
-/*
- * Transform a 4-element row vector (1x4 matrix) by a 4x4 matrix.  This
- * function is used for transforming clipping plane equations and spotlight
- * directions.
- * Mathematically,  u = v * m.
- * Input:  v - input vector
- *         m - transformation matrix
- * Output:  u - transformed vector
- */
-void gl_transform_vector( GLfloat u[4], const GLfloat v[4], const GLfloat m[16] )
-{
-   GLfloat v0=v[0], v1=v[1], v2=v[2], v3=v[3];
-#define M(row,col)  m[row + col*4]
-   u[0] = v0 * M(0,0) + v1 * M(1,0) + v2 * M(2,0) + v3 * M(3,0);
-   u[1] = v0 * M(0,1) + v1 * M(1,1) + v2 * M(2,1) + v3 * M(3,1);
-   u[2] = v0 * M(0,2) + v1 * M(1,2) + v2 * M(2,2) + v3 * M(3,2);
-   u[3] = v0 * M(0,3) + v1 * M(1,3) + v2 * M(2,3) + v3 * M(3,3);
-#undef M
-}
-
-
-/* Useful for one-off point transformations, as in clipping.
- * Note that because the matrix isn't analyzed we do too many
- * multiplies, and that the result is always 4-clean.
- */
-void gl_transform_point_sz( GLfloat Q[4], const GLfloat M[16],
-			    const GLfloat P[4], GLuint sz )
-{
-   if (Q == P)
-      return;
-
-   if (sz == 4)
-   {
-      Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12] * P[3];
-      Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13] * P[3];
-      Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3];
-      Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3];
-   }
-   else if (sz == 3)
-   {
-      Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12];
-      Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13];
-      Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14];
-      Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15];
-   }
-   else if (sz == 2)
-   {
-      Q[0] = M[0] * P[0] + M[4] * P[1] +                M[12];
-      Q[1] = M[1] * P[0] + M[5] * P[1] +                M[13];
-      Q[2] = M[2] * P[0] + M[6] * P[1] +                M[14];
-      Q[3] = M[3] * P[0] + M[7] * P[1] +                M[15];
-   }
-   else if (sz == 1)
-   {
-      Q[0] = M[0] * P[0] +                              M[12];
-      Q[1] = M[1] * P[0] +                              M[13];
-      Q[2] = M[2] * P[0] +                              M[14];
-      Q[3] = M[3] * P[0] +                              M[15];
-   }
-}
Index: xc/extras/Mesa/src/xform.h
diff -u xc/extras/Mesa/src/xform.h:1.6 xc/extras/Mesa/src/xform.h:removed
--- xc/extras/Mesa/src/xform.h:1.6	Mon Nov 13 18:30:54 2000
+++ xc/extras/Mesa/src/xform.h	Thu Feb 27 12:15:45 2003
@@ -1,179 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-
-
-
-#ifndef XFORM_H
-#define XFORM_H
-
-
-#include "types.h"
-
-#ifdef USE_X86_ASM
-#define _XFORMAPI _ASMAPI
-#define _XFORMAPIP _ASMAPIP
-#else
-#define _XFORMAPI
-#define _XFORMAPIP *
-#endif
-
-/*
- * Transform a point (column vector) by a matrix:   Q = M * P
- */
-#define TRANSFORM_POINT( Q, M, P )					\
-   Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12] * P[3];	\
-   Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13] * P[3];	\
-   Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3];	\
-   Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3];
-
-
-#define TRANSFORM_POINT3( Q, M, P )				\
-   Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12];	\
-   Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13];	\
-   Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14];	\
-   Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15];
-
-
-/*
- * Transform a normal (row vector) by a matrix:  [NX NY NZ] = N * MAT
- */
-#define TRANSFORM_NORMAL( TO, N, MAT )				\
-do {								\
-   TO[0] = N[0] * MAT[0] + N[1] * MAT[1] + N[2] * MAT[2];	\
-   TO[1] = N[0] * MAT[4] + N[1] * MAT[5] + N[2] * MAT[6];	\
-   TO[2] = N[0] * MAT[8] + N[1] * MAT[9] + N[2] * MAT[10];	\
-} while (0)
-
-
-extern void gl_transform_vector( GLfloat u[4],
-				 const GLfloat v[4],
-                                 const GLfloat m[16] );
-
-
-extern void gl_init_transformation( void );
-
-
-/* KW: Clip functions now do projective divide as well.  The projected
- * coordinates are very useful to us because they let us cull
- * backfaces and eliminate vertices from lighting, fogging, etc
- * calculations.  Despite the fact that this divide could be done one
- * day in hardware, we would still have a reason to want to do it here
- * as long as those other calculations remain in software.
- *
- * Clipping is a convenient place to do the divide on x86 as it should be
- * possible to overlap with integer outcode calculations.
- *
- * There are two cases where we wouldn't want to do the divide in cliptest:
- *    - When we aren't clipping.  We still might want to cull backfaces
- *      so the divide should be done elsewhere.  This currently never 
- *      happens.
- *
- *    - When culling isn't likely to help us, such as when the GL culling
- *      is disabled and we not lighting or are only lighting
- *      one-sided.  In this situation, backface determination provides
- *      us with no useful information.  A tricky case to detect is when
- *      all input data is already culled, although hopefully the
- *      application wouldn't turn on culling in such cases.
- *
- * We supply a buffer to hold the [x/w,y/w,z/w,1/w] values which
- * are the result of the projection.  This is only used in the 
- * 4-vector case - in other cases, we just use the clip coordinates
- * as the projected coordinates - they are identical.
- * 
- * This is doubly convenient because it means the Win[] array is now
- * of the same stride as all the others, so I can now turn map_vertices
- * into a straight-forward matrix transformation, with asm acceleration
- * automatically available.  
- */
-typedef GLvector4f * (_XFORMAPIP clip_func)( GLvector4f *vClip,
-				  GLvector4f *vProj, 
-				  GLubyte clipMask[],
-				  GLubyte *orMask, 
-				  GLubyte *andMask );
-
-typedef void (*dotprod_func)( GLvector4f *out_vec, 
-			      GLuint elt,
-			      const GLvector4f *coord_vec, 
-			      const GLfloat plane[4], 
-			      const GLubyte mask[]);
-
-typedef void (*vec_copy_func)( GLvector4f *to, 
-			       const GLvector4f *from, 
-			       const GLubyte mask[]);
-
-
-
-
-/* KW: New versions of the transform function allow a mask array
- *     specifying that individual vector transform should be skipped
- *     when the mask byte is zero.  This is always present as a
- *     parameter, to allow a unified interface.  
- */
-typedef void (_XFORMAPIP transform_func)( GLvector4f *to_vec,
-					  const GLfloat m[16],
-				const GLvector4f *from_vec, 
-				const GLubyte *clipmask,
-				const GLubyte flag );
-
-
-extern GLvector4f *gl_project_points( GLvector4f *to,
-			       const GLvector4f *from );
-
-extern void gl_transform_bounds3( GLubyte *orMask, GLubyte *andMask,
-				  const GLfloat m[16],
-			   CONST GLfloat src[][3] );
-
-extern void gl_transform_bounds2( GLubyte *orMask, GLubyte *andMask,
-				  const GLfloat m[16],
-			   CONST GLfloat src[][3] );
-
-
-extern dotprod_func  gl_dotprod_tab[2][5];
-extern vec_copy_func gl_copy_tab[2][0x10];
-extern clip_func     gl_clip_tab[5];
-extern normal_func   gl_normal_tab[0xf][0x4];
-
-/* Use of 3 layers of linked 1-dimensional arrays to reduce
- * cost of lookup.
- */
-extern transform_func **(gl_transform_tab[2]);
-
-
-extern void gl_transform_point_sz( GLfloat Q[4], const GLfloat M[16],
-				   const GLfloat P[4], GLuint sz );
-
-
-#define TransformRaw( to, mat, from ) \
-      ( (*gl_transform_tab[0][(from)->size][(mat)->type])( to, (mat)->m, from, 0, 0 ), \
-        (to) )
-
-#define Transform( to, mat, from, mask, cull ) \
-      ( (*gl_transform_tab[cull!=0][(from)->size][(mat)->type])( to, (mat)->m, from, mask, cull ), \
-	(to) )
-
-
-#endif
Index: xc/extras/Mesa/src/xform_tmp.h
diff -u xc/extras/Mesa/src/xform_tmp.h:1.9 xc/extras/Mesa/src/xform_tmp.h:removed
--- xc/extras/Mesa/src/xform_tmp.h:1.9	Sat Oct 27 23:32:07 2001
+++ xc/extras/Mesa/src/xform_tmp.h	Thu Feb 27 12:15:45 2003
@@ -1,977 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/xform_tmp.h,v 1.9 2001/10/28 03:32:07 tsi Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.1
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * New (3.1) transformation code written by Keith Whitwell.
- */
-
-
-/*----------------------------------------------------------------------
- * Begin Keith's new code
- *
- *----------------------------------------------------------------------
- */
-
-/* KW: Fixed stride, now measured in bytes as is the OpenGL array stride.
- */
-
-/* KW: These are now parameterized to produce two versions, one
- *     which transforms all incoming points, and a second which
- *     takes notice of a cullmask array, and only transforms
- *     unculled vertices.
- */
-
-/* KW: 1-vectors can sneak into the texture pipeline via the array
- *     interface.  These functions are here because I want consistant
- *     treatment of the vertex sizes and a lazy strategy for
- *     cleaning unused parts of the vector, and so as not to exclude
- *     them from the vertex array interface.
- *
- *     Under our current analysis of matrices, there is no way that
- *     the product of a matrix and a 1-vector can remain a 1-vector,
- *     with the exception of the identity transform.
- */
-
-/* KW: No longer zero-pad outgoing vectors.  Now that external
- *     vectors can get into the pipeline we cannot ever assume
- *     that there is more to a vector than indicated by its
- *     size.
- */
-
-/* KW: Now uses clipmask and a flag to allow us to skip both/either
- *     cliped and/or culled vertices.
- */
-
-static void _XFORMAPI
-TAG(transform_points1_general)( GLvector4f *to_vec,
-				const GLfloat m[16],
-					    const GLvector4f *from_vec,
-					    const GLubyte *mask,
-					    const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0],  m12 = m[12];
-   const GLfloat m1 = m[1],  m13 = m[13];
-   const GLfloat m2 = m[2],  m14 = m[14];
-   const GLfloat m3 = m[3],  m15 = m[15];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] = m1 * ox + m13;
-	 to[i][2] = m2 * ox + m14;
-	 to[i][3] = m3 * ox + m15;
-      }
-   }
-
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points1_identity)( GLvector4f *to_vec,
-				 const GLfloat m[16],
-					     const GLvector4f *from_vec,
-					     const GLubyte *mask,
-					     const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLuint count = from_vec->count;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   if (to_vec == from_vec) return;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-      }
-   }
-
-   to_vec->size = 1;
-   to_vec->flags |= VEC_SIZE_1;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points1_2d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1];
-   const GLfloat m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] = m1 * ox + m13;
-      }
-   }
-   to_vec->size = 2;
-   to_vec->flags |= VEC_SIZE_2;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points1_2d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] =           m13;
-      }
-   }
-
-   to_vec->size = 2;
-   to_vec->flags |= VEC_SIZE_2;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points1_3d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2];
-   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox + m12;
-	 to[i][1] = m1 * ox + m13;
-	 to[i][2] = m2 * ox + m14;
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-
-static void _XFORMAPI
-TAG(transform_points1_3d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0];
-   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox           + m12;
-	 to[i][1] =                     m13;
-	 to[i][2] =                     m14;
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points1_perspective)( GLvector4f *to_vec,
-				    const GLfloat m[16],
-						const GLvector4f *from_vec,
-						const GLubyte *mask,
-						const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0];
-	 to[i][0] = m0 * ox                ;
-	 to[i][1] =           0            ;
-	 to[i][2] =                     m14;
-	 to[i][3] = 0;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-
-
-
-/* 2-vectors, which are a lot more relevant than 1-vectors, are
- * present early in the geometry pipeline and throughout the
- * texture pipeline.
- */
-static void _XFORMAPI
-TAG(transform_points2_general)( GLvector4f *to_vec,
-				const GLfloat m[16],
-					    const GLvector4f *from_vec,
-					    const GLubyte *mask,
-					    const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0],  m4 = m[4],  m12 = m[12];
-   const GLfloat m1 = m[1],  m5 = m[5],  m13 = m[13];
-   const GLfloat m2 = m[2],  m6 = m[6],  m14 = m[14];
-   const GLfloat m3 = m[3],  m7 = m[7],  m15 = m[15];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox + m4 * oy + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m13;
-	 to[i][2] = m2 * ox + m6 * oy + m14;
-	 to[i][3] = m3 * ox + m7 * oy + m15;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points2_identity)( GLvector4f *to_vec,
-				 const GLfloat m[16],
-					     const GLvector4f *from_vec,
-					     const GLubyte *mask,
-					     const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   if (to_vec == from_vec) return;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-	 to[i][1] = from[1];
-      }
-   }
-   to_vec->size = 2;
-   to_vec->flags |= VEC_SIZE_2;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points2_2d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
-   const GLfloat m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox + m4 * oy + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m13;
-      }
-   }
-
-   to_vec->size = 2;
-   to_vec->flags |= VEC_SIZE_2;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points2_2d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox           + m12;
-	 to[i][1] =           m5 * oy + m13;
-      }
-   }
-
-   to_vec->size = 2;
-   to_vec->flags |= VEC_SIZE_2;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points2_3d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
-   const GLfloat m6 = m[6], m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox + m4 * oy + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m13;
-	 to[i][2] = m2 * ox + m6 * oy + m14;
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-
-/* I would actually say this was a fairly important function, from
- * a texture transformation point of view.
- */
-static void _XFORMAPI
-TAG(transform_points2_3d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5];
-   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox           + m12;
-	 to[i][1] =           m5 * oy + m13;
-	 to[i][2] =                     m14;
-      }
-   }
-   if (m14 == 0) {
-      to_vec->size = 2;
-      to_vec->flags |= VEC_SIZE_2;
-   } else {
-      to_vec->size = 3;
-      to_vec->flags |= VEC_SIZE_3;
-   }
-   to_vec->count = from_vec->count;
-}
-
-/* This may not be called too often, but I wouldn't say it was dead
- * code.  It's also hard to remove any of these functions if you are
- * attached to the assertions that have appeared in them.
- */
-static void _XFORMAPI
-TAG(transform_points2_perspective)( GLvector4f *to_vec,
-				    const GLfloat m[16],
-						const GLvector4f *from_vec,
-						const GLubyte *mask,
-						const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1];
-	 to[i][0] = m0 * ox                ;
-	 to[i][1] =           m5 * oy      ;
-	 to[i][2] =                     m14;
-	 to[i][3] = 0;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-
-
-static void _XFORMAPI
-TAG(transform_points3_general)( GLvector4f *to_vec,
-				const GLfloat m[16],
-					    const GLvector4f *from_vec,
-					    const GLubyte *mask,
-					    const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8],  m12 = m[12];
-   const GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9],  m13 = m[13];
-   const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
-   const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12;
-	 to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14;
-	 to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points3_identity)( GLvector4f *to_vec,
-				 const GLfloat m[16],
-					     const GLvector4f *from_vec,
-					     const GLubyte *mask,
-					     const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   if (to_vec == from_vec) return;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-	 to[i][1] = from[1];
-	 to[i][2] = from[2];
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points3_2d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
-   const GLfloat m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox + m4 * oy            + m12       ;
-	 to[i][1] = m1 * ox + m5 * oy            + m13       ;
-	 to[i][2] =                   +       oz             ;
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points3_2d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox                      + m12       ;
-	 to[i][1] =           m5 * oy            + m13       ;
-	 to[i][2] =                   +       oz             ;
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points3_3d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
-   const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
-   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12       ;
-	 to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13       ;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14       ;
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-/* previously known as ortho...
- */
-static void _XFORMAPI
-TAG(transform_points3_3d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5];
-   const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox                      + m12       ;
-	 to[i][1] =           m5 * oy            + m13       ;
-	 to[i][2] =                     m10 * oz + m14       ;
-      }
-   }
-   to_vec->size = 3;
-   to_vec->flags |= VEC_SIZE_3;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points3_perspective)( GLvector4f *to_vec,
-				    const GLfloat m[16],
-						const GLvector4f *from_vec,
-						const GLubyte *mask,
-						const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
-   const GLfloat m10 = m[10], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2];
-	 to[i][0] = m0 * ox           + m8  * oz       ;
-	 to[i][1] =           m5 * oy + m9  * oz       ;
-	 to[i][2] =                     m10 * oz + m14 ;
-	 to[i][3] =                          -oz       ;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-
-
-static void _XFORMAPI
-TAG(transform_points4_general)( GLvector4f *to_vec,
-				const GLfloat m[16],
-					    const GLvector4f *from_vec,
-					    const GLubyte *mask,
-					    const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8],  m12 = m[12];
-   const GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9],  m13 = m[13];
-   const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
-   const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12 * ow;
-	 to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13 * ow;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
-	 to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15 * ow;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points4_identity)( GLvector4f *to_vec,
-				 const GLfloat m[16],
-					     const GLvector4f *from_vec,
-					     const GLubyte *mask,
-					     const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   if (to_vec == from_vec) return;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 to[i][0] = from[0];
-	 to[i][1] = from[1];
-	 to[i][2] = from[2];
-	 to[i][3] = from[3];
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points4_2d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
-   const GLfloat m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox + m4 * oy            + m12 * ow;
-	 to[i][1] = m1 * ox + m5 * oy            + m13 * ow;
-	 to[i][2] =                   +       oz           ;
-	 to[i][3] =                                      ow;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points4_2d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox                      + m12 * ow;
-	 to[i][1] =           m5 * oy            + m13 * ow;
-	 to[i][2] =                   +       oz           ;
-	 to[i][3] =                                      ow;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points4_3d)( GLvector4f *to_vec,
-			   const GLfloat m[16],
-				       const GLvector4f *from_vec,
-				       const GLubyte *mask,
-				       const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
-   const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
-   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12 * ow;
-	 to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13 * ow;
-	 to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
-	 to[i][3] =                                      ow;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points4_3d_no_rot)( GLvector4f *to_vec,
-				  const GLfloat m[16],
-					      const GLvector4f *from_vec,
-					      const GLubyte *mask,
-					      const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5];
-   const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox                      + m12 * ow;
-	 to[i][1] =           m5 * oy            + m13 * ow;
-	 to[i][2] =                     m10 * oz + m14 * ow;
-	 to[i][3] =                                      ow;
-      }
-   }
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static void _XFORMAPI
-TAG(transform_points4_perspective)( GLvector4f *to_vec,
-				    const GLfloat m[16],
-						const GLvector4f *from_vec,
-						const GLubyte *mask,
-						const GLubyte flag )
-{
-   const GLuint stride = from_vec->stride;
-   GLfloat *from = from_vec->start;
-   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
-   GLuint count = from_vec->count;
-   const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
-   const GLfloat m10 = m[10], m14 = m[14];
-   GLuint i;
-   (void) mask;
-   (void) flag;
-   STRIDE_LOOP {
-      CLIP_CHECK {
-	 const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
-	 to[i][0] = m0 * ox           + m8  * oz            ;
-	 to[i][1] =           m5 * oy + m9  * oz            ;
-	 to[i][2] =                     m10 * oz + m14 * ow ;
-	 to[i][3] =                          -oz            ;
-      }
-   }
-
-   to_vec->size = 4;
-   to_vec->flags |= VEC_SIZE_4;
-   to_vec->count = from_vec->count;
-}
-
-static transform_func _XFORMAPI TAG(transform_tab_1)[7];
-static transform_func _XFORMAPI TAG(transform_tab_2)[7];
-static transform_func _XFORMAPI TAG(transform_tab_3)[7];
-static transform_func _XFORMAPI TAG(transform_tab_4)[7];
-
-/* Similar functions could be called several times, with more highly
- * optimized routines overwriting the arrays.  This only occurs during
- * startup.
- */
-static void _XFORMAPI TAG(init_c_transformations)( void )
-{
-#define TAG_TAB   gl_transform_tab[IDX]
-#define TAG_TAB_1 TAG(transform_tab_1)
-#define TAG_TAB_2 TAG(transform_tab_2)
-#define TAG_TAB_3 TAG(transform_tab_3)
-#define TAG_TAB_4 TAG(transform_tab_4)
-
-   TAG_TAB[1] = TAG_TAB_1;
-   TAG_TAB[2] = TAG_TAB_2;
-   TAG_TAB[3] = TAG_TAB_3;
-   TAG_TAB[4] = TAG_TAB_4;
-
-   /* 1-D points (ie texcoords) */
-   TAG_TAB_1[MATRIX_GENERAL]     = TAG(transform_points1_general);
-   TAG_TAB_1[MATRIX_IDENTITY]    = TAG(transform_points1_identity);
-   TAG_TAB_1[MATRIX_3D_NO_ROT]   = TAG(transform_points1_3d_no_rot);
-   TAG_TAB_1[MATRIX_PERSPECTIVE] = TAG(transform_points1_perspective) ;
-   TAG_TAB_1[MATRIX_2D]          = TAG(transform_points1_2d);
-   TAG_TAB_1[MATRIX_2D_NO_ROT]   = TAG(transform_points1_2d_no_rot);
-   TAG_TAB_1[MATRIX_3D]          = TAG(transform_points1_3d);
-
-   /* 2-D points */
-   TAG_TAB_2[MATRIX_GENERAL]     = TAG(transform_points2_general);
-   TAG_TAB_2[MATRIX_IDENTITY]    = TAG(transform_points2_identity);
-   TAG_TAB_2[MATRIX_3D_NO_ROT]   = TAG(transform_points2_3d_no_rot);
-   TAG_TAB_2[MATRIX_PERSPECTIVE] = TAG(transform_points2_perspective) ;
-   TAG_TAB_2[MATRIX_2D]          = TAG(transform_points2_2d);
-   TAG_TAB_2[MATRIX_2D_NO_ROT]   = TAG(transform_points2_2d_no_rot);
-   TAG_TAB_2[MATRIX_3D]          = TAG(transform_points2_3d);
-
-   /* 3-D points */
-   TAG_TAB_3[MATRIX_GENERAL]     = TAG(transform_points3_general);
-   TAG_TAB_3[MATRIX_IDENTITY]    = TAG(transform_points3_identity);
-   TAG_TAB_3[MATRIX_3D_NO_ROT]   = TAG(transform_points3_3d_no_rot);
-   TAG_TAB_3[MATRIX_PERSPECTIVE] = TAG(transform_points3_perspective);
-   TAG_TAB_3[MATRIX_2D]          = TAG(transform_points3_2d);
-   TAG_TAB_3[MATRIX_2D_NO_ROT]   = TAG(transform_points3_2d_no_rot);
-   TAG_TAB_3[MATRIX_3D]          = TAG(transform_points3_3d);
-
-   /* 4-D points */
-   TAG_TAB_4[MATRIX_GENERAL]     = TAG(transform_points4_general);
-   TAG_TAB_4[MATRIX_IDENTITY]    = TAG(transform_points4_identity);
-   TAG_TAB_4[MATRIX_3D_NO_ROT]   = TAG(transform_points4_3d_no_rot);
-   TAG_TAB_4[MATRIX_PERSPECTIVE] = TAG(transform_points4_perspective);
-   TAG_TAB_4[MATRIX_2D]          = TAG(transform_points4_2d);
-   TAG_TAB_4[MATRIX_2D_NO_ROT]   = TAG(transform_points4_2d_no_rot);
-   TAG_TAB_4[MATRIX_3D]          = TAG(transform_points4_3d);
-
-#undef TAG_TAB
-#undef TAG_TAB_1
-#undef TAG_TAB_2
-#undef TAG_TAB_3
-#undef TAG_TAB_4
-}
Index: xc/extras/Mesa/src/zoom.c
diff -u xc/extras/Mesa/src/zoom.c:1.4 xc/extras/Mesa/src/zoom.c:removed
--- xc/extras/Mesa/src/zoom.c:1.4	Fri Jun 16 20:02:19 2000
+++ xc/extras/Mesa/src/zoom.c	Thu Feb 27 12:15:45 2003
@@ -1,407 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifdef PC_HEADER
-#include "all.h"
-#else
-#include "glheader.h"
-#include "macros.h"
-#include "span.h"
-#include "stencil.h"
-#include "zoom.h"
-#endif
-
-
-
-/*
- * Write a span of pixels to the frame buffer while applying a pixel zoom.
- * This is only used by glDrawPixels and glCopyPixels.
- * Input:  n - number of pixels in input row
- *         x, y - destination of the span
- *         z - depth values for the span
- *         red, green, blue, alpha - array of colors
- *         y0 - location of first row in the image we're drawing.
- */
-void
-gl_write_zoomed_rgba_span( GLcontext *ctx,
-                           GLuint n, GLint x, GLint y, const GLdepth z[],
-                           CONST GLubyte rgba[][4], GLint y0 )
-{
-   GLint m;
-   GLint r0, r1, row, r;
-   GLint i, j, skipcol;
-   GLubyte zrgba[MAX_WIDTH][4];  /* zoomed pixel colors */
-   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
-   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
-   const GLuint *srcRGBA32 = (const GLuint *) rgba;
-   GLuint *dstRGBA32 = (GLuint *) zrgba;
-
-   /* compute width of output row */
-   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
-   if (m==0) {
-      return;
-   }
-   if (ctx->Pixel.ZoomX<0.0) {
-      /* adjust x coordinate for left/right mirroring */
-      x = x - m;
-   }
-
-   /* compute which rows to draw */
-   row = y-y0;
-   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
-   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
-   if (r0==r1) {
-      return;
-   }
-   else if (r1<r0) {
-      GLint rtmp = r1;
-      r1 = r0;
-      r0 = rtmp;
-   }
-
-   /* return early if r0...r1 is above or below window */
-   if (r0<0 && r1<0) {
-      /* below window */
-      return;
-   }
-   if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
-      /* above window */
-      return;
-   }
-
-   /* check if left edge is outside window */
-   skipcol = 0;
-   if (x<0) {
-      skipcol = -x;
-      m += x;
-   }
-   /* make sure span isn't too long or short */
-   if (m>maxwidth) {
-      m = maxwidth;
-   }
-   else if (m<=0) {
-      return;
-   }
-
-   assert( m <= MAX_WIDTH );
-
-   /* zoom the span horizontally */
-   if (ctx->Pixel.ZoomX==-1.0F) {
-      /* n==m */
-      for (j=0;j<m;j++) {
-         i = n - (j+skipcol) - 1;
-         dstRGBA32[j] = srcRGBA32[i];
-         zdepth[j] = z[i];
-      }
-   }
-   else {
-      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
-      for (j=0;j<m;j++) {
-         i = (GLint) ((j+skipcol) * xscale);
-         if (i<0)  i = n + i - 1;
-         dstRGBA32[j] = srcRGBA32[i];
-         zdepth[j] = z[i];
-      }
-   }
-
-   /* write the span */
-   for (r=r0; r<r1; r++) {
-      gl_write_rgba_span( ctx, m, x+skipcol, r, zdepth, zrgba, GL_BITMAP );
-   }
-}
-
-
-
-void
-gl_write_zoomed_rgb_span( GLcontext *ctx,
-                          GLuint n, GLint x, GLint y, const GLdepth z[],
-                          CONST GLubyte rgb[][3], GLint y0 )
-{
-   GLint m;
-   GLint r0, r1, row, r;
-   GLint i, j, skipcol;
-   GLubyte zrgba[MAX_WIDTH][4];  /* zoomed pixel colors */
-   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
-   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
-
-   /* compute width of output row */
-   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
-   if (m==0) {
-      return;
-   }
-   if (ctx->Pixel.ZoomX<0.0) {
-      /* adjust x coordinate for left/right mirroring */
-      x = x - m;
-   }
-
-   /* compute which rows to draw */
-   row = y-y0;
-   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
-   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
-   if (r0==r1) {
-      return;
-   }
-   else if (r1<r0) {
-      GLint rtmp = r1;
-      r1 = r0;
-      r0 = rtmp;
-   }
-
-   /* return early if r0...r1 is above or below window */
-   if (r0<0 && r1<0) {
-      /* below window */
-      return;
-   }
-   if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
-      /* above window */
-      return;
-   }
-
-   /* check if left edge is outside window */
-   skipcol = 0;
-   if (x<0) {
-      skipcol = -x;
-      m += x;
-   }
-   /* make sure span isn't too long or short */
-   if (m>maxwidth) {
-      m = maxwidth;
-   }
-   else if (m<=0) {
-      return;
-   }
-
-   assert( m <= MAX_WIDTH );
-
-   /* zoom the span horizontally */
-   if (ctx->Pixel.ZoomX==-1.0F) {
-      /* n==m */
-      for (j=0;j<m;j++) {
-         i = n - (j+skipcol) - 1;
-         zrgba[j][0] = rgb[i][0];
-         zrgba[j][1] = rgb[i][1];
-         zrgba[j][2] = rgb[i][2];
-         zrgba[j][3] = 255;
-         zdepth[j] = z[i];
-      }
-   }
-   else {
-      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
-      for (j=0;j<m;j++) {
-         i = (GLint) ((j+skipcol) * xscale);
-         if (i<0)  i = n + i - 1;
-         zrgba[j][0] = rgb[i][0];
-         zrgba[j][1] = rgb[i][1];
-         zrgba[j][2] = rgb[i][2];
-         zrgba[j][3] = 255;
-         zdepth[j] = z[i];
-      }
-   }
-
-   /* write the span */
-   for (r=r0; r<r1; r++) {
-      gl_write_rgba_span( ctx, m, x+skipcol, r, zdepth, zrgba, GL_BITMAP );
-   }
-}
-
-
-
-/*
- * As above, but write CI pixels.
- */
-void
-gl_write_zoomed_index_span( GLcontext *ctx,
-                            GLuint n, GLint x, GLint y, const GLdepth z[],
-                            const GLuint indexes[], GLint y0 )
-{
-   GLint m;
-   GLint r0, r1, row, r;
-   GLint i, j, skipcol;
-   GLuint zindexes[MAX_WIDTH];  /* zoomed color indexes */
-   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
-   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
-
-   /* compute width of output row */
-   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
-   if (m==0) {
-      return;
-   }
-   if (ctx->Pixel.ZoomX<0.0) {
-      /* adjust x coordinate for left/right mirroring */
-      x = x - m;
-   }
-
-   /* compute which rows to draw */
-   row = y-y0;
-   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
-   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
-   if (r0==r1) {
-      return;
-   }
-   else if (r1<r0) {
-      GLint rtmp = r1;
-      r1 = r0;
-      r0 = rtmp;
-   }
-
-   /* return early if r0...r1 is above or below window */
-   if (r0<0 && r1<0) {
-      /* below window */
-      return;
-   }
-   if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
-      /* above window */
-      return;
-   }
-
-   /* check if left edge is outside window */
-   skipcol = 0;
-   if (x<0) {
-      skipcol = -x;
-      m += x;
-   }
-   /* make sure span isn't too long or short */
-   if (m>maxwidth) {
-      m = maxwidth;
-   }
-   else if (m<=0) {
-      return;
-   }
-
-   assert( m <= MAX_WIDTH );
-
-   /* zoom the span horizontally */
-   if (ctx->Pixel.ZoomX==-1.0F) {
-      /* n==m */
-      for (j=0;j<m;j++) {
-         i = n - (j+skipcol) - 1;
-         zindexes[j] = indexes[i];
-         zdepth[j]   = z[i];
-      }
-   }
-   else {
-      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
-      for (j=0;j<m;j++) {
-         i = (GLint) ((j+skipcol) * xscale);
-         if (i<0)  i = n + i - 1;
-         zindexes[j] = indexes[i];
-         zdepth[j] = z[i];
-      }
-   }
-
-   /* write the span */
-   for (r=r0; r<r1; r++) {
-      gl_write_index_span( ctx, m, x+skipcol, r, zdepth, zindexes, GL_BITMAP );
-   }
-}
-
-
-
-/*
- * As above, but write stencil values.
- */
-void
-gl_write_zoomed_stencil_span( GLcontext *ctx,
-                              GLuint n, GLint x, GLint y,
-                              const GLstencil stencil[], GLint y0 )
-{
-   GLint m;
-   GLint r0, r1, row, r;
-   GLint i, j, skipcol;
-   GLstencil zstencil[MAX_WIDTH];  /* zoomed stencil values */
-   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
-
-   /* compute width of output row */
-   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
-   if (m==0) {
-      return;
-   }
-   if (ctx->Pixel.ZoomX<0.0) {
-      /* adjust x coordinate for left/right mirroring */
-      x = x - m;
-   }
-
-   /* compute which rows to draw */
-   row = y-y0;
-   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
-   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
-   if (r0==r1) {
-      return;
-   }
-   else if (r1<r0) {
-      GLint rtmp = r1;
-      r1 = r0;
-      r0 = rtmp;
-   }
-
-   /* return early if r0...r1 is above or below window */
-   if (r0<0 && r1<0) {
-      /* below window */
-      return;
-   }
-   if (r0>=ctx->DrawBuffer->Height && r1>=ctx->DrawBuffer->Height) {
-      /* above window */
-      return;
-   }
-
-   /* check if left edge is outside window */
-   skipcol = 0;
-   if (x<0) {
-      skipcol = -x;
-      m += x;
-   }
-   /* make sure span isn't too long or short */
-   if (m>maxwidth) {
-      m = maxwidth;
-   }
-   else if (m<=0) {
-      return;
-   }
-
-   assert( m <= MAX_WIDTH );
-
-   /* zoom the span horizontally */
-   if (ctx->Pixel.ZoomX==-1.0F) {
-      /* n==m */
-      for (j=0;j<m;j++) {
-         i = n - (j+skipcol) - 1;
-         zstencil[j] = stencil[i];
-      }
-   }
-   else {
-      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
-      for (j=0;j<m;j++) {
-         i = (GLint) ((j+skipcol) * xscale);
-         if (i<0)  i = n + i - 1;
-         zstencil[j] = stencil[i];
-      }
-   }
-
-   /* write the span */
-   for (r=r0; r<r1; r++) {
-      _mesa_write_stencil_span( ctx, m, x+skipcol, r, zstencil );
-   }
-}
Index: xc/extras/Mesa/src/zoom.h
diff -u xc/extras/Mesa/src/zoom.h:1.4 xc/extras/Mesa/src/zoom.h:removed
--- xc/extras/Mesa/src/zoom.h:1.4	Fri Jun 16 20:02:19 2000
+++ xc/extras/Mesa/src/zoom.h	Thu Feb 27 12:15:45 2003
@@ -1,58 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-#ifndef ZOOM_H
-#define ZOOM_H
-
-
-#include "types.h"
-
-
-extern void
-gl_write_zoomed_rgba_span( GLcontext *ctx,
-                           GLuint n, GLint x, GLint y, const GLdepth z[],
-                           CONST GLubyte rgba[][4], GLint y0 );
-
-
-extern void
-gl_write_zoomed_rgb_span( GLcontext *ctx,
-                          GLuint n, GLint x, GLint y, const GLdepth z[],
-                          CONST GLubyte rgb[][3], GLint y0 );
-
-
-extern void
-gl_write_zoomed_index_span( GLcontext *ctx,
-                            GLuint n, GLint x, GLint y, const GLdepth z[],
-                            const GLuint indexes[], GLint y0 );
-
-
-extern void
-gl_write_zoomed_stencil_span( GLcontext *ctx,
-                              GLuint n, GLint x, GLint y,
-                              const GLstencil stencil[], GLint y0 );
-
-
-#endif
Index: xc/extras/Mesa/src/OSmesa/Makefile.am
diff -u xc/extras/Mesa/src/OSmesa/Makefile.am:1.1.1.2 xc/extras/Mesa/src/OSmesa/Makefile.am:removed
--- xc/extras/Mesa/src/OSmesa/Makefile.am:1.1.1.2	Thu Nov 30 10:24:38 2000
+++ xc/extras/Mesa/src/OSmesa/Makefile.am	Thu Feb 27 12:15:48 2003
@@ -1,12 +0,0 @@
-## Process this file with automake to produce Makefile.in
-
-#AUTOMAKE_OPTIONS = no-dependencies
-
-INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/src
-
-if HAVE_OSMESA
-# Build a libtool convenience library.
-noinst_LTLIBRARIES = libMesaOS.la
-endif
-
-libMesaOS_la_SOURCES = osmesa.c
Index: xc/extras/Mesa/src/OSmesa/osmesa.c
diff -u xc/extras/Mesa/src/OSmesa/osmesa.c:1.9 xc/extras/Mesa/src/OSmesa/osmesa.c:1.13
--- xc/extras/Mesa/src/OSmesa/osmesa.c:1.9	Wed Jan  2 12:49:50 2002
+++ xc/extras/Mesa/src/OSmesa/osmesa.c	Mon Sep  9 17:52:09 2002
@@ -1,9 +1,8 @@
-/* $XFree86: xc/extras/Mesa/src/OSmesa/osmesa.c,v 1.9 2002/01/02 17:49:50 tsi Exp $ */
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  4.0.3
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -29,27 +28,39 @@
  *
  * Note on thread safety:  this driver is thread safe.  All
  * functions are reentrant.  The notion of current context is
- * managed by the core gl_make_current() and gl_get_current_context()
+ * managed by the core _mesa_make_current() and _mesa_get_current_context()
  * functions.  Those functions are thread-safe.
  */
 
 
-#ifdef PC_HEADER
-#include "all.h"
-#else
 #include "glheader.h"
 #include "GL/osmesa.h"
+#include "buffers.h"
 #include "context.h"
+#include "colormac.h"
 #include "depth.h"
-#include "mem.h"
-#include "matrix.h"
-#include "types.h"
-#include "vb.h"
 #include "extensions.h"
+#include "macros.h"
+#include "matrix.h"
+#include "mem.h"
 #include "mmath.h"
-#endif
+#include "mtypes.h"
+#include "texformat.h"
+#include "texstore.h"
+#include "array_cache/acache.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
+#include "swrast/s_context.h"
+#include "swrast/s_depth.h"
+#include "swrast/s_lines.h"
+#include "swrast/s_triangle.h"
+#include "swrast/s_trispan.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
 
 
+
 /*
  * This is the OS/Mesa context struct.
  * Notice how it includes a GLcontext.  By doing this we're mimicking
@@ -64,14 +75,12 @@
    GLenum format;		/* either GL_RGBA or GL_COLOR_INDEX */
    void *buffer;		/* the image buffer */
    GLint width, height;		/* size of image buffer */
-   GLuint pixel;		/* current color index or RGBA pixel value */
-   GLuint clearpixel;		/* pixel for clearing the color buffer */
    GLint rowlength;		/* number of pixels per row */
    GLint userRowLength;		/* user-specified number of pixels per row */
    GLint rshift, gshift;	/* bit shifts for RGBA formats */
    GLint bshift, ashift;
-   GLint rind, gind, bind;	/* index offsets for RGBA formats */
-   void *rowaddr[MAX_HEIGHT];	/* address of first pixel in each image row */
+   GLint rInd, gInd, bInd, aInd;/* index offsets for RGBA formats */
+   GLchan *rowaddr[MAX_HEIGHT];	/* address of first pixel in each image row */
    GLboolean yup;		/* TRUE  -> Y increases upward */
 				/* FALSE -> Y increases downward */
 };
@@ -79,10 +88,15 @@
 
 
 /* A forward declaration: */
-static void osmesa_update_state( GLcontext *ctx );
+static void osmesa_update_state( GLcontext *ctx, GLuint newstate );
+static void osmesa_register_swrast_functions( GLcontext *ctx );
+
+
 
+#define OSMESA_CONTEXT(ctx)  ((OSMesaContext) (ctx->DriverCtx))
 
 
+
 /**********************************************************************/
 /*****                    Public Functions                        *****/
 /**********************************************************************/
@@ -97,21 +111,34 @@
  *                     display lists.  NULL indicates no sharing.
  * Return:  an OSMesaContext or 0 if error
  */
-OSMesaContext GLAPIENTRY
+GLAPI OSMesaContext GLAPIENTRY
 OSMesaCreateContext( GLenum format, OSMesaContext sharelist )
 {
+   return OSMesaCreateContextExt(format, DEFAULT_SOFTWARE_DEPTH_BITS,
+                                 8, 16, sharelist);
+}
+
+
+
+/*
+ * New in Mesa 3.5
+ *
+ * Create context and specify size of ancillary buffers.
+ */
+GLAPI OSMesaContext GLAPIENTRY
+OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
+                        GLint accumBits, OSMesaContext sharelist )
+{
    OSMesaContext osmesa;
    GLint rshift, gshift, bshift, ashift;
-   GLint rind, gind, bind;
-   GLint indexBits, alphaBits = 0;
+   GLint rind, gind, bind, aind;
+   GLint indexBits = 0, redBits = 0, greenBits = 0, blueBits = 0, alphaBits =0;
    GLboolean rgbmode;
-   GLboolean swalpha;
-   GLuint i4 = 1;
-   GLubyte *i1 = (GLubyte *) &i4;
-   GLint little_endian = *i1;
+   const GLuint i4 = 1;
+   const GLubyte *i1 = (GLubyte *) &i4;
+   const GLint little_endian = *i1;
 
-   swalpha = GL_FALSE;
-   rind = gind = bind = 0;
+   rind = gind = bind = aind = 0;
    if (format==OSMESA_COLOR_INDEX) {
       indexBits = 8;
       rshift = gshift = bshift = ashift = 0;
@@ -119,7 +146,14 @@
    }
    else if (format==OSMESA_RGBA) {
       indexBits = 0;
-      alphaBits = 8;
+      redBits = CHAN_BITS;
+      greenBits = CHAN_BITS;
+      blueBits = CHAN_BITS;
+      alphaBits = CHAN_BITS;
+      rind = 0;
+      gind = 1;
+      bind = 2;
+      aind = 3;
       if (little_endian) {
          rshift = 0;
          gshift = 8;
@@ -136,12 +170,19 @@
    }
    else if (format==OSMESA_BGRA) {
       indexBits = 0;
-      alphaBits = 8;
+      redBits = CHAN_BITS;
+      greenBits = CHAN_BITS;
+      blueBits = CHAN_BITS;
+      alphaBits = CHAN_BITS;
+      bind = 0;
+      gind = 1;
+      rind = 2;
+      aind = 3;
       if (little_endian) {
-         ashift = 0;
-         rshift = 8;
-         gshift = 16;
-         bshift = 24;
+         bshift = 0;
+         gshift = 8;
+         rshift = 16;
+         ashift = 24;
       }
       else {
          bshift = 24;
@@ -153,12 +194,19 @@
    }
    else if (format==OSMESA_ARGB) {
       indexBits = 0;
-      alphaBits = 8;
+      redBits = CHAN_BITS;
+      greenBits = CHAN_BITS;
+      blueBits = CHAN_BITS;
+      alphaBits = CHAN_BITS;
+      aind = 0;
+      rind = 1;
+      gind = 2;
+      bind = 3;
       if (little_endian) {
-         bshift = 0;
-         gshift = 8;
-         rshift = 16;
-         ashift = 24;
+         ashift = 0;
+         rshift = 8;
+         gshift = 16;
+         bshift = 24;
       }
       else {
          ashift = 24;
@@ -170,29 +218,48 @@
    }
    else if (format==OSMESA_RGB) {
       indexBits = 0;
+      redBits = CHAN_BITS;
+      greenBits = CHAN_BITS;
+      blueBits = CHAN_BITS;
       alphaBits = 0;
       bshift = 0;
       gshift = 8;
       rshift = 16;
       ashift = 24;
-      bind = 2;
-      gind = 1;
       rind = 0;
+      gind = 1;
+      bind = 2;
       rgbmode = GL_TRUE;
-      swalpha = GL_TRUE;
    }
    else if (format==OSMESA_BGR) {
       indexBits = 0;
+      redBits = CHAN_BITS;
+      greenBits = CHAN_BITS;
+      blueBits = CHAN_BITS;
       alphaBits = 0;
       bshift = 0;
       gshift = 8;
       rshift = 16;
       ashift = 24;
-      bind = 0;
-      gind = 1;
       rind = 2;
+      gind = 1;
+      bind = 0;
+      rgbmode = GL_TRUE;
+   }
+   else if (format==OSMESA_RGB_565) {
+      indexBits = 0;
+      redBits = 5;
+      greenBits = 6;
+      blueBits = 5;
+      alphaBits = 0;
+      rshift = 11;
+      gshift = 5;
+      bshift = 0;
+      ashift = 0;
+      rind = 0; /* not used */
+      gind = 0;
+      bind = 0;
       rgbmode = GL_TRUE;
-      swalpha = GL_TRUE;
    }
    else {
       return NULL;
@@ -201,15 +268,22 @@
 
    osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context);
    if (osmesa) {
-      osmesa->gl_visual = gl_create_visual( rgbmode,
-                                            swalpha,    /* software alpha */
-                                            GL_FALSE,	/* double buffer */
-                                            GL_FALSE,	/* stereo */
-                                            DEFAULT_SOFTWARE_DEPTH_BITS,
-                                            STENCIL_BITS,
-                                            rgbmode ? ACCUM_BITS : 0,
-                                            indexBits,
-                                            8, 8, 8, alphaBits );
+      osmesa->gl_visual = _mesa_create_visual( rgbmode,
+                                               GL_FALSE,    /* double buffer */
+                                               GL_FALSE,    /* stereo */
+                                               redBits,
+                                               greenBits,
+                                               blueBits,
+                                               alphaBits,
+                                               indexBits,
+                                               depthBits,
+                                               stencilBits,
+                                               accumBits,
+                                               accumBits,
+                                               accumBits,
+                                               alphaBits ? accumBits : 0,
+                                               1            /* num samples */
+                                               );
       if (!osmesa->gl_visual) {
          FREE(osmesa);
          return NULL;
@@ -224,20 +298,19 @@
          FREE(osmesa);
          return NULL;
       }
-      gl_extensions_enable(&(osmesa->gl_ctx),"GL_HP_occlusion_test");
-      gl_extensions_enable(&(osmesa->gl_ctx), "GL_ARB_texture_cube_map");
-      gl_extensions_enable(&(osmesa->gl_ctx), "GL_EXT_texture_env_combine");
-      gl_extensions_enable(&(osmesa->gl_ctx), "GL_EXT_texture_env_dot3");
-
-      osmesa->gl_buffer = gl_create_framebuffer( osmesa->gl_visual,
-                                           osmesa->gl_visual->DepthBits > 0,
-                                           osmesa->gl_visual->StencilBits > 0,
-                                           osmesa->gl_visual->AccumRedBits > 0,
-                                           osmesa->gl_visual->AlphaBits > 0 );
 
+      _mesa_enable_sw_extensions(&(osmesa->gl_ctx));
+      _mesa_enable_1_3_extensions(&(osmesa->gl_ctx));
+
+      osmesa->gl_buffer = _mesa_create_framebuffer( osmesa->gl_visual,
+                           (GLboolean) ( osmesa->gl_visual->depthBits > 0 ),
+                           (GLboolean) ( osmesa->gl_visual->stencilBits > 0 ),
+                           (GLboolean) ( osmesa->gl_visual->accumRedBits > 0 ),
+                           GL_FALSE /* s/w alpha */ );
+
       if (!osmesa->gl_buffer) {
-         gl_destroy_visual( osmesa->gl_visual );
-         gl_free_context_data( &osmesa->gl_ctx );
+         _mesa_destroy_visual( osmesa->gl_visual );
+         _mesa_free_context_data( &osmesa->gl_ctx );
          FREE(osmesa);
          return NULL;
       }
@@ -245,8 +318,6 @@
       osmesa->buffer = NULL;
       osmesa->width = 0;
       osmesa->height = 0;
-      osmesa->pixel = 0;
-      osmesa->clearpixel = 0;
       osmesa->userRowLength = 0;
       osmesa->rowlength = 0;
       osmesa->yup = GL_TRUE;
@@ -254,26 +325,48 @@
       osmesa->gshift = gshift;
       osmesa->bshift = bshift;
       osmesa->ashift = ashift;
-      osmesa->rind = rind;
-      osmesa->gind = gind;
-      osmesa->bind = bind;
+      osmesa->rInd = rind;
+      osmesa->gInd = gind;
+      osmesa->bInd = bind;
+      osmesa->aInd = aind;
+
+
+      /* Initialize the software rasterizer and helper modules.
+       */
+      {
+	 GLcontext *ctx = &osmesa->gl_ctx;
+
+	 _swrast_CreateContext( ctx );
+	 _ac_CreateContext( ctx );
+	 _tnl_CreateContext( ctx );
+	 _swsetup_CreateContext( ctx );
+	
+	 _swsetup_Wakeup( ctx );
+	 osmesa_register_swrast_functions( ctx );
+      }
    }
    return osmesa;
 }
 
 
 
+
 /*
  * Destroy an Off-Screen Mesa rendering context.
  *
  * Input:  ctx - the context to destroy
  */
-void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx )
+GLAPI void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx )
 {
    if (ctx) {
-      gl_destroy_visual( ctx->gl_visual );
-      gl_destroy_framebuffer( ctx->gl_buffer );
-      gl_free_context_data( &ctx->gl_ctx );
+      _swsetup_DestroyContext( &ctx->gl_ctx );
+      _tnl_DestroyContext( &ctx->gl_ctx );
+      _ac_DestroyContext( &ctx->gl_ctx );
+      _swrast_DestroyContext( &ctx->gl_ctx );
+
+      _mesa_destroy_visual( ctx->gl_visual );
+      _mesa_destroy_framebuffer( ctx->gl_buffer );
+      _mesa_free_context_data( &ctx->gl_ctx );
       FREE( ctx );
    }
 }
@@ -285,57 +378,40 @@
  */
 static void compute_row_addresses( OSMesaContext ctx )
 {
-   GLint i;
+   GLint bytesPerPixel, bytesPerRow, i;
+   GLubyte *origin = (GLubyte *) ctx->buffer;
+
+   if (ctx->format == OSMESA_COLOR_INDEX) {
+      /* CI mode */
+      bytesPerPixel = 1 * sizeof(GLchan);
+   }
+   else if ((ctx->format == OSMESA_RGB) || (ctx->format == OSMESA_BGR)) {
+      /* RGB mode */
+      bytesPerPixel = 3 * sizeof(GLchan);
+   }
+   else if (ctx->format == OSMESA_RGB_565) {
+      /* 5/6/5 RGB pixel in 16 bits */
+      bytesPerPixel = 2;
+   }
+   else {
+      /* RGBA mode */
+      bytesPerPixel = 4 * sizeof(GLchan);
+   }
+
+   bytesPerRow = ctx->rowlength * bytesPerPixel;
 
    if (ctx->yup) {
       /* Y=0 is bottom line of window */
-      if (ctx->format==OSMESA_COLOR_INDEX) {
-         /* 1-byte CI mode */
-         GLubyte *origin = (GLubyte *) ctx->buffer;
-         for (i=0;i<MAX_HEIGHT;i++) {
-            ctx->rowaddr[i] = origin + i * ctx->rowlength;
-         }
-      }
-      else {
-         if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) {
-            /* 3-byte RGB mode */
-            GLubyte *origin = (GLubyte *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + (i * (ctx->rowlength*3));
-            }
-         } else {
-            /* 4-byte RGBA mode */
-            GLuint *origin = (GLuint *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + i * ctx->rowlength;
-            }
-         }
+      for (i = 0; i < MAX_HEIGHT; i++) {
+         ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + i * bytesPerRow);
       }
    }
    else {
       /* Y=0 is top line of window */
-      if (ctx->format==OSMESA_COLOR_INDEX) {
-         /* 1-byte CI mode */
-         GLubyte *origin = (GLubyte *) ctx->buffer;
-         for (i=0;i<MAX_HEIGHT;i++) {
-            ctx->rowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength;
-         }
+      for (i = 0; i < MAX_HEIGHT; i++) {
+         GLint j = ctx->height - i - 1;
+         ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + j * bytesPerRow);
       }
-      else {
-         if ((ctx->format==OSMESA_RGB) || (ctx->format==OSMESA_BGR)) {
-            /* 3-byte RGB mode */
-            GLubyte *origin = (GLubyte *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + ((ctx->height-i-1) * (ctx->rowlength*3));
-            }
-         } else {
-            /* 4-byte RGBA mode */
-            GLuint *origin = (GLuint *) ctx->buffer;
-            for (i=0;i<MAX_HEIGHT;i++) {
-               ctx->rowaddr[i] = origin + (ctx->height-i-1) * ctx->rowlength;
-            }
-         }
-      }
    }
 }
 
@@ -350,34 +426,41 @@
  * with the lower-left image pixel stored in the first array position
  * (ie. bottom-to-top).
  *
- * Since the only type initially supported is GL_UNSIGNED_BYTE, if the
- * context is in RGBA mode, each pixel will be stored as a 4-byte RGBA
- * value.  If the context is in color indexed mode, each pixel will be
- * stored as a 1-byte value.
- *
  * If the context's viewport hasn't been initialized yet, it will now be
  * initialized to (0,0,width,height).
  *
  * Input:  ctx - the rendering context
  *         buffer - the image buffer memory
- *         type - data type for pixel components, only GL_UNSIGNED_BYTE
- *                supported now
+ *         type - data type for pixel components
+ *            Normally, only GL_UNSIGNED_BYTE and GL_UNSIGNED_SHORT_5_6_5
+ *            are supported.  But if Mesa's been compiled with CHAN_BITS==16
+ *            then type must be GL_UNSIGNED_SHORT.  And if Mesa's been build
+ *            with CHAN_BITS==32 then type must be GL_FLOAT.
  *         width, height - size of image buffer in pixels, at least 1
  * Return:  GL_TRUE if success, GL_FALSE if error because of invalid ctx,
- *          invalid buffer address, type!=GL_UNSIGNED_BYTE, width<1, height<1,
+ *          invalid buffer address, invalid type, width<1, height<1,
  *          width>internal limit or height>internal limit.
  */
-GLboolean GLAPIENTRY
+GLAPI GLboolean GLAPIENTRY
 OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type,
                    GLsizei width, GLsizei height )
 {
-   if (!ctx || !buffer || type!=GL_UNSIGNED_BYTE
-       || width<1 || height<1 || width>MAX_WIDTH || height>MAX_HEIGHT) {
+   if (!ctx || !buffer ||
+       width < 1 || height < 1 ||
+       width > MAX_WIDTH || height > MAX_HEIGHT) {
+      return GL_FALSE;
+   }
+
+   if (ctx->format == OSMESA_RGB_565) {
+      if (type != GL_UNSIGNED_SHORT_5_6_5)
+         return GL_FALSE;
+   }
+   else if (type != CHAN_TYPE) {
       return GL_FALSE;
    }
 
-   osmesa_update_state( &ctx->gl_ctx );
-   gl_make_current( &ctx->gl_ctx, ctx->gl_buffer );
+   osmesa_update_state( &ctx->gl_ctx, 0 );
+   _mesa_make_current( &ctx->gl_ctx, ctx->gl_buffer );
 
    ctx->buffer = buffer;
    ctx->width = width;
@@ -396,15 +479,23 @@
       ctx->gl_ctx.Scissor.Width = width;
       ctx->gl_ctx.Scissor.Height = height;
    }
+   else {
+      /* this will make ensure we recognize the new buffer size */
+      _mesa_ResizeBuffersMESA();
+   }
 
+   /* Added by Gerk Huisma: */
+   _tnl_MakeCurrent( &ctx->gl_ctx, ctx->gl_ctx.DrawBuffer,
+                     ctx->gl_ctx.ReadBuffer );
+
    return GL_TRUE;
 }
 
 
 
-OSMesaContext GLAPIENTRY OSMesaGetCurrentContext( void )
+GLAPI OSMesaContext GLAPIENTRY OSMesaGetCurrentContext( void )
 {
-   GLcontext *ctx = gl_get_current_context();
+   GLcontext *ctx = _mesa_get_current_context();
    if (ctx)
       return (OSMesaContext) ctx;
    else
@@ -413,14 +504,14 @@
 
 
 
-void GLAPIENTRY OSMesaPixelStore( GLint pname, GLint value )
+GLAPI void GLAPIENTRY OSMesaPixelStore( GLint pname, GLint value )
 {
    OSMesaContext ctx = OSMesaGetCurrentContext();
 
    switch (pname) {
       case OSMESA_ROW_LENGTH:
          if (value<0) {
-            gl_error( &ctx->gl_ctx, GL_INVALID_VALUE,
+            _mesa_error( &ctx->gl_ctx, GL_INVALID_VALUE,
                       "OSMesaPixelStore(value)" );
             return;
          }
@@ -431,7 +522,7 @@
          ctx->yup = value ? GL_TRUE : GL_FALSE;
          break;
       default:
-         gl_error( &ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaPixelStore(pname)" );
+         _mesa_error( &ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaPixelStore(pname)" );
          return;
    }
 
@@ -439,7 +530,7 @@
 }
 
 
-void GLAPIENTRY OSMesaGetIntegerv( GLint pname, GLint *value )
+GLAPI void GLAPIENTRY OSMesaGetIntegerv( GLint pname, GLint *value )
 {
    OSMesaContext ctx = OSMesaGetCurrentContext();
 
@@ -454,7 +545,7 @@
          *value = ctx->format;
          return;
       case OSMESA_TYPE:
-         *value = GL_UNSIGNED_BYTE;
+         *value = CHAN_TYPE;
          return;
       case OSMESA_ROW_LENGTH:
          *value = ctx->rowlength;
@@ -462,8 +553,14 @@
       case OSMESA_Y_UP:
          *value = ctx->yup;
          return;
+      case OSMESA_MAX_WIDTH:
+         *value = MAX_WIDTH;
+         return;
+      case OSMESA_MAX_HEIGHT:
+         *value = MAX_HEIGHT;
+         return;
       default:
-         gl_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetIntergerv(pname)");
+         _mesa_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetIntergerv(pname)");
          return;
    }
 }
@@ -476,7 +573,7 @@
  *          buffer - pointer to depth buffer values
  * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
  */
-GLboolean GLAPIENTRY
+GLAPI GLboolean GLAPIENTRY
 OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint *height,
                       GLint *bytesPerValue, void **buffer )
 {
@@ -490,7 +587,7 @@
    else {
       *width = c->gl_buffer->Width;
       *height = c->gl_buffer->Height;
-      if (c->gl_visual->DepthBits <= 16)
+      if (c->gl_visual->depthBits <= 16)
          *bytesPerValue = sizeof(GLushort);
       else
          *bytesPerValue = sizeof(GLuint);
@@ -507,7 +604,7 @@
  *          buffer - pointer to color buffer values
  * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
  */
-GLboolean GLAPIENTRY
+GLAPI GLboolean GLAPIENTRY
 OSMesaGetColorBuffer( OSMesaContext c, GLint *width,
                       GLint *height, GLint *format, void **buffer )
 {
@@ -535,37 +632,63 @@
 /*
  * Useful macros:
  */
-#define PACK_RGBA(R,G,B,A)  (  ((R) << osmesa->rshift) \
-                             | ((G) << osmesa->gshift) \
-                             | ((B) << osmesa->bshift) \
-                             | ((A) << osmesa->ashift) )
+
+#if CHAN_TYPE == GL_FLOAT
+#define PACK_RGBA(DST, R, G, B, A)				\
+do {								\
+   (DST)[0] = (R < 0.0f) ? 0.0f : ((R > 1.0f) ? 1.0f : R);	\
+   (DST)[1] = (G < 0.0f) ? 0.0f : ((G > 1.0f) ? 1.0f : G);	\
+   (DST)[2] = (B < 0.0f) ? 0.0f : ((B > 1.0f) ? 1.0f : B);	\
+   (DST)[3] = (A < 0.0f) ? 0.0f : ((A > 1.0f) ? 1.0f : A);	\
+} while (0)
+#else
+#define PACK_RGBA(DST, R, G, B, A)	\
+do {					\
+   (DST)[osmesa->rInd] = R;		\
+   (DST)[osmesa->gInd] = G;		\
+   (DST)[osmesa->bInd] = B;		\
+   (DST)[osmesa->aInd] = A;		\
+} while (0)
+#endif
+
+#define PACK_RGB(DST, R, G, B)  \
+do {				\
+   (DST)[0] = R;		\
+   (DST)[1] = G;		\
+   (DST)[2] = B;		\
+} while (0)
+
+#define PACK_BGR(DST, R, G, B)  \
+do {				\
+   (DST)[0] = B;		\
+   (DST)[1] = G;		\
+   (DST)[2] = R;		\
+} while (0)
 
-#define PACK_RGBA2(R,G,B,A)  (  ((R) << rshift) \
-                              | ((G) << gshift) \
-                              | ((B) << bshift) \
-                              | ((A) << ashift) )
+#define PACK_RGB_565(DST, R, G, B)					\
+do {									\
+   (DST) = (((int) (R) << 8) & 0xf800) | (((int) (G) << 3) & 0x7e0) | ((int) (B) >> 3);\
+} while (0)
 
-#define UNPACK_RED(P)      (((P) >> osmesa->rshift) & 0xff)
-#define UNPACK_GREEN(P)    (((P) >> osmesa->gshift) & 0xff)
-#define UNPACK_BLUE(P)     (((P) >> osmesa->bshift) & 0xff)
-#define UNPACK_ALPHA(P)    (((P) >> osmesa->ashift) & 0xff)
 
-#define PIXELADDR1(X,Y)  ((GLubyte *) osmesa->rowaddr[Y] + (X))
-#define PIXELADDR3(X,Y)  ((GLubyte *) osmesa->rowaddr[Y] + ((X)*3))
-#define PIXELADDR4(X,Y)  ((GLuint *)  osmesa->rowaddr[Y] + (X))
+#define UNPACK_RED(P)      ( (P)[osmesa->rInd] )
+#define UNPACK_GREEN(P)    ( (P)[osmesa->gInd] )
+#define UNPACK_BLUE(P)     ( (P)[osmesa->bInd] )
+#define UNPACK_ALPHA(P)    ( (P)[osmesa->aInd] )
 
 
+#define PIXELADDR1(X,Y)  (osmesa->rowaddr[Y] + (X))
+#define PIXELADDR2(X,Y)  (osmesa->rowaddr[Y] + 2 * (X))
+#define PIXELADDR3(X,Y)  (osmesa->rowaddr[Y] + 3 * (X))
+#define PIXELADDR4(X,Y)  (osmesa->rowaddr[Y] + 4 * (X))
 
 
-static GLboolean set_draw_buffer( GLcontext *ctx, GLenum mode )
+
+static void set_draw_buffer( GLcontext *ctx, GLenum mode )
 {
+   /* A no-op since there's only one color buffer! */
    (void) ctx;
-   if (mode==GL_FRONT_LEFT) {
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
+   (void) mode;
 }
 
 
@@ -576,143 +699,211 @@
    ASSERT(mode == GL_FRONT_LEFT);
 }
 
-
-static void clear_index( GLcontext *ctx, GLuint index )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   osmesa->clearpixel = index;
-}
-
-
-
-static void clear_color( GLcontext *ctx,
-                         GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   osmesa->clearpixel = PACK_RGBA( r, g, b, a );
-}
-
-
 
-static GLbitfield clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
-                         GLint x, GLint y, GLint width, GLint height )
+static void clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+		   GLint x, GLint y, GLint width, GLint height )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    const GLuint *colorMask = (GLuint *) &ctx->Color.ColorMask;
 
-   /* we can't handle color or index masking */
-   if (*colorMask != 0xffffffff || ctx->Color.IndexMask != 0xffffffff)
-      return mask;
-
    /* sanity check - we only have a front-left buffer */
    ASSERT((mask & (DD_FRONT_RIGHT_BIT | DD_BACK_LEFT_BIT | DD_BACK_RIGHT_BIT)) == 0);
-
-   if (mask & DD_FRONT_LEFT_BIT) {
-      if (osmesa->format==OSMESA_COLOR_INDEX) {
-         if (all) {
-            /* Clear whole CI buffer */
-            MEMSET(osmesa->buffer, osmesa->clearpixel,
-                   osmesa->rowlength * osmesa->height);
-         }
-         else {
-            /* Clear part of CI buffer */
-            GLint i, j;
-            for (i=0;i<height;i++) {
-               GLubyte *ptr1 = PIXELADDR1( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  *ptr1++ = osmesa->clearpixel;
-               }
-            }
-         }
-      }
-      else if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR)) {
-         GLubyte rval = UNPACK_RED(osmesa->clearpixel);
-         GLubyte gval = UNPACK_GREEN(osmesa->clearpixel);
-         GLubyte bval = UNPACK_BLUE(osmesa->clearpixel);
-         GLint   rind = osmesa->rind;
-         GLint   gind = osmesa->gind;
-         GLint   bind = osmesa->bind;
-         if (all) {
-            GLuint  i, n;
-            GLubyte *ptr3 = (GLubyte *) osmesa->buffer;
-            /* Clear whole RGB buffer */
-            n = osmesa->rowlength * osmesa->height;
-            for (i=0;i<n;i++) {
-               ptr3[rind] = rval;
-               ptr3[gind] = gval;
-               ptr3[bind] = bval;
-               ptr3 += 3;
-            }
-         }
-         else {
-            /* Clear part of RGB buffer */
-            GLint i, j;
-            for (i=0;i<height;i++) {
-               GLubyte *ptr3 = PIXELADDR3( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  ptr3[rind] = rval;
-                  ptr3[gind] = gval;
-                  ptr3[bind] = bval;
-                  ptr3 += 3;
-               }
-            }
-         }
-      }
-      else {
-         if (all) {
-            /* Clear whole RGBA buffer */
-            GLuint i, n, *ptr4;
-            n = osmesa->rowlength * osmesa->height;
-            ptr4 = (GLuint *) osmesa->buffer;
-            if (osmesa->clearpixel) {
-               for (i=0;i<n;i++) {
-                  *ptr4++ = osmesa->clearpixel;
+   if (*colorMask == 0xffffffff && ctx->Color.IndexMask == 0xffffffff) {
+      if (mask & DD_FRONT_LEFT_BIT) {
+	 if (osmesa->format == OSMESA_COLOR_INDEX) {
+	    if (all) {
+	       /* Clear whole CI buffer */
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+	       MEMSET(osmesa->buffer, ctx->Color.ClearIndex,
+		      osmesa->rowlength * osmesa->height);
+#else
+	       const GLint n = osmesa->rowlength * osmesa->height;
+	       GLchan *buffer = (GLchan *) osmesa->buffer;
+	       GLint i;
+	       for (i = 0; i < n; i ++) {
+		  buffer[i] = ctx->Color.ClearIndex;
+	       }
+#endif
+	    }
+	    else {
+	       /* Clear part of CI buffer */
+	       const GLchan clearIndex = (GLchan) ctx->Color.ClearIndex;
+	       GLint i, j;
+	       for (i = 0; i < height; i++) {
+		  GLchan *ptr1 = PIXELADDR1(x, (y + i));
+		  for (j = 0; j < width; j++) {
+		     *ptr1++ = clearIndex;
+		  }
+	       }
+	    }
+	 }
+	 else if (osmesa->format == OSMESA_RGB) {
+	    const GLchan r = ctx->Color.ClearColor[0];
+	    const GLchan g = ctx->Color.ClearColor[1];
+	    const GLchan b = ctx->Color.ClearColor[2];
+	    if (all) {
+	       /* Clear whole RGB buffer */
+	       GLuint n = osmesa->rowlength * osmesa->height;
+	       GLchan *ptr3 = (GLchan *) osmesa->buffer;
+	       GLuint i;
+	       for (i = 0; i < n; i++) {
+		  PACK_RGB(ptr3, r, g, b);
+		  ptr3 += 3;
+	       }
+	    }
+	    else {
+	       /* Clear part of RGB buffer */
+	       GLint i, j;
+	       for (i = 0; i < height; i++) {
+		  GLchan *ptr3 = PIXELADDR3(x, (y + i));
+		  for (j = 0; j < width; j++) {
+		     PACK_RGB(ptr3, r, g, b);
+		     ptr3 += 3;
+		  }
+	       }
+	    }
+	 }
+	 else if (osmesa->format == OSMESA_BGR) {
+	    const GLchan r = ctx->Color.ClearColor[0];
+	    const GLchan g = ctx->Color.ClearColor[1];
+	    const GLchan b = ctx->Color.ClearColor[2];
+	    if (all) {
+	       /* Clear whole RGB buffer */
+	       const GLint n = osmesa->rowlength * osmesa->height;
+	       GLchan *ptr3 = (GLchan *) osmesa->buffer;
+	       GLint i;
+	       for (i = 0; i < n; i++) {
+		  PACK_BGR(ptr3, r, g, b);
+		  ptr3 += 3;
+	       }
+	    }
+	    else {
+	       /* Clear part of RGB buffer */
+	       GLint i, j;
+	       for (i = 0; i < height; i++) {
+		  GLchan *ptr3 = PIXELADDR3(x, (y + i));
+		  for (j = 0; j < width; j++) {
+		     PACK_BGR(ptr3, r, g, b);
+		     ptr3 += 3;
+		  }
+	       }
+	    }
+	 }
+         else if (osmesa->format == OSMESA_RGB_565) {
+	    const GLchan r = ctx->Color.ClearColor[0];
+	    const GLchan g = ctx->Color.ClearColor[1];
+	    const GLchan b = ctx->Color.ClearColor[2];
+            GLushort clearPixel;
+            PACK_RGB_565(clearPixel, r, g, b);
+            if (all) {
+               /* Clear whole RGB buffer */
+	       const GLuint n = osmesa->rowlength * osmesa->height;
+               GLushort *ptr2 = (GLushort *) osmesa->buffer;
+               GLuint  i;
+               for (i = 0; i < n; i++) {
+                  *ptr2 = clearPixel;
+                  ptr2++;
                }
             }
             else {
-               BZERO(ptr4, n * sizeof(GLuint));
-            }
-         }
-         else {
-            /* Clear part of RGBA buffer */
-            GLint i, j;
-            for (i=0;i<height;i++) {
-               GLuint *ptr4 = PIXELADDR4( x, (y+i) );
-               for (j=0;j<width;j++) {
-                  *ptr4++ = osmesa->clearpixel;
+               /* clear scissored region */
+               GLint i, j;
+               for (i = 0; i < height; i++) {
+                  GLushort *ptr2 = (GLushort *) PIXELADDR2(x, (y + i));
+                  for (j = 0; j < width; j++) {
+                     *ptr2 = clearPixel;
+                     ptr2++;
+                  }
                }
             }
          }
+	 else {
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+	    /* 4-byte pixel value */
+	    GLuint clearPixel;
+	    GLchan *clr = (GLchan *) &clearPixel;
+	    clr[osmesa->rInd] = ctx->Color.ClearColor[0];
+	    clr[osmesa->gInd] = ctx->Color.ClearColor[1];
+	    clr[osmesa->bInd] = ctx->Color.ClearColor[2];
+	    clr[osmesa->aInd] = ctx->Color.ClearColor[3];
+	    if (all) {
+	       /* Clear whole RGBA buffer */
+	       const GLuint n = osmesa->rowlength * osmesa->height;
+	       GLuint *ptr4 = (GLuint *) osmesa->buffer;
+	       GLuint i;
+	       if (clearPixel) {
+		  for (i = 0; i < n; i++) {
+		     *ptr4++ = clearPixel;
+		  }
+	       }
+	       else {
+		  BZERO(ptr4, n * sizeof(GLuint));
+	       }
+	    }
+	    else {
+	       /* Clear part of RGBA buffer */
+	       GLint i, j;
+	       for (i = 0; i < height; i++) {
+		  GLuint *ptr4 = (GLuint *) PIXELADDR4(x, (y + i));
+		  for (j = 0; j < width; j++) {
+		     *ptr4++ = clearPixel;
+		  }
+	       }
+	    }
+#else
+	    const GLchan r = ctx->Color.ClearColor[0];
+	    const GLchan g = ctx->Color.ClearColor[1];
+	    const GLchan b = ctx->Color.ClearColor[2];
+	    const GLchan a = ctx->Color.ClearColor[3];
+	    if (all) {
+	       /* Clear whole RGBA buffer */
+	       const GLuint n = osmesa->rowlength * osmesa->height;
+	       GLchan *p = (GLchan *) osmesa->buffer;
+	       GLuint i;
+	       for (i = 0; i < n; i++) {
+		  PACK_RGBA(p, r, g, b, a);
+		  p += 4;
+	       }
+	    }
+	    else {
+	       /* Clear part of RGBA buffer */
+	       GLint i, j;
+	       for (i = 0; i < height; i++) {
+		  GLchan *p = PIXELADDR4(x, (y + i));
+		  for (j = 0; j < width; j++) {
+		     PACK_RGBA(p, r, g, b, a);
+		     p += 4;
+		  }
+	       }
+	    }
+
+#endif
+	 }
+	 mask &= ~DD_FRONT_LEFT_BIT;
       }
    }
-   /* have Mesa clear all other buffers */
-   return mask & (~DD_FRONT_LEFT_BIT);
+   
+   if (mask)
+      _swrast_Clear( ctx, mask, all, x, y, width, height );
 }
 
 
 
-static void set_index( GLcontext *ctx, GLuint index )
+static void buffer_size( GLframebuffer *buffer, GLuint *width, GLuint *height )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   osmesa->pixel = index;
-}
-
-
-
-static void set_color( GLcontext *ctx,
-                       GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   osmesa->pixel = PACK_RGBA( r, g, b, a );
-}
-
-
-
-static void buffer_size( GLcontext *ctx, GLuint *width, GLuint *height )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   *width = osmesa->width;
-   *height = osmesa->height;
+#ifdef WIN32
+   /* Hack to get around problems with exporting glapi_Context from Mesa
+      and importing into OSMesa. */
+   GLcontext *ctx = (GLcontext *) _glapi_get_context();
+#else
+   GET_CURRENT_CONTEXT(ctx);
+#endif
+   (void) buffer;
+   if (ctx) {
+      OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+      *width = osmesa->width;
+      *height = osmesa->height;
+   }
 }
 
 
@@ -721,44 +912,42 @@
 /**********************************************************************/
 
 /* Write RGBA pixels to an RGBA (or permuted) buffer. */
-static void write_rgba_span( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             CONST GLubyte rgba[][4], const GLubyte mask[] )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLuint *ptr4 = PIXELADDR4( x, y );
-   GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
+static void
+write_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                 CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR4(x, y);
+   GLuint i;
    if (mask) {
-      for (i=0;i<n;i++,ptr4++) {
+      for (i = 0; i < n; i++, p += 4) {
          if (mask[i]) {
-            *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+            PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                         rgba[i][BCOMP], rgba[i][ACOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr4++) {
-         *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+      for (i = 0; i < n; i++, p += 4) {
+         PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                      rgba[i][BCOMP], rgba[i][ACOMP]);
       }
    }
 }
 
 
 /* Write RGBA pixels to an RGBA buffer.  This is the fastest span-writer. */
-static void write_rgba_span_rgba( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-                                  CONST GLubyte rgba[][4],
-                                  const GLubyte mask[] )
+static void
+write_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLuint *ptr4 = PIXELADDR4( x, y );
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
    const GLuint *rgba4 = (const GLuint *) rgba;
    GLuint i;
+   ASSERT(CHAN_TYPE == GL_UNSIGNED_BYTE);
    if (mask) {
-      for (i=0;i<n;i++) {
+      for (i = 0; i < n; i++) {
          if (mask[i]) {
             ptr4[i] = rgba4[i];
          }
@@ -771,125 +960,120 @@
 
 
 /* Write RGB pixels to an RGBA (or permuted) buffer. */
-static void write_rgb_span( const GLcontext *ctx,
-                            GLuint n, GLint x, GLint y,
-                            CONST GLubyte rgb[][3], const GLubyte mask[] )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLuint *ptr4 = PIXELADDR4( x, y );
-   GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
+static void
+write_rgb_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                CONST GLchan rgb[][3], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR4(x, y);
+   GLuint i;
    if (mask) {
-      for (i=0;i<n;i++,ptr4++) {
+      for (i = 0; i < n; i++, p+=4) {
          if (mask[i]) {
-            *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+            PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], CHAN_MAX);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr4++) {
-         *ptr4 = PACK_RGBA2( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255);
+      for (i = 0; i < n; i++, p+=4) {
+         PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], CHAN_MAX);
       }
    }
 }
 
 
 
-static void write_monocolor_span( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-				  const GLubyte mask[] )
+static void
+write_monocolor_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLuint *ptr4 = PIXELADDR4(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR4(x, y);
    GLuint i;
-   for (i=0;i<n;i++,ptr4++) {
+   for (i = 0; i < n; i++, p += 4) {
       if (mask[i]) {
-         *ptr4 = osmesa->pixel;
+         PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
       }
    }
 }
 
 
 
-static void write_rgba_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-                               CONST GLubyte rgba[][4], const GLubyte mask[] )
+static void
+write_rgba_pixels( const GLcontext *ctx, GLuint n,
+                   const GLint x[], const GLint y[],
+                   CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         *ptr4 = PACK_RGBA2( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+         GLchan *p = PIXELADDR4(x[i], y[i]);
+         PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
+                      rgba[i][BCOMP], rgba[i][ACOMP]);
       }
    }
 }
 
 
 
-static void write_monocolor_pixels( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-				    const GLubyte mask[] )
+static void
+write_monocolor_pixels( const GLcontext *ctx, GLuint n,
+                        const GLint x[], const GLint y[],
+                        const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         *ptr4 = osmesa->pixel;
+         GLchan *p = PIXELADDR4(x[i], y[i]);
+         PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
       }
    }
 }
 
 
-static void read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
-                             GLubyte rgba[][4] )
+static void
+read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                GLchan rgba[][4] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLuint *ptr4 = PIXELADDR4(x,y);
-   for (i=0;i<n;i++) {
-      GLuint pixel = *ptr4++;
-      rgba[i][RCOMP] = UNPACK_RED(pixel);
-      rgba[i][GCOMP] = UNPACK_GREEN(pixel);
-      rgba[i][BCOMP] = UNPACK_BLUE(pixel);
-      rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+   GLchan *p = PIXELADDR4(x, y);
+   for (i = 0; i < n; i++, p += 4) {
+      rgba[i][RCOMP] = UNPACK_RED(p);
+      rgba[i][GCOMP] = UNPACK_GREEN(p);
+      rgba[i][BCOMP] = UNPACK_BLUE(p);
+      rgba[i][ACOMP] = UNPACK_ALPHA(p);
    }
 }
 
 
 /* Read RGBA pixels from an RGBA buffer */
-static void read_rgba_span_rgba( const GLcontext *ctx,
-                                 GLuint n, GLint x, GLint y,
-                                 GLubyte rgba[][4] )
+static void
+read_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     GLchan rgba[][4] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLuint *ptr4 = PIXELADDR4(x,y);
-   MEMCPY( rgba, ptr4, n * 4 * sizeof(GLubyte) );
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
+   MEMCPY( rgba, ptr4, n * 4 * sizeof(GLchan) );
 }
 
 
-static void read_rgba_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLubyte rgba[][4], const GLubyte mask[] )
+static void
+read_rgba_pixels( const GLcontext *ctx,
+                  GLuint n, const GLint x[], const GLint y[],
+                  GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLuint *ptr4 = PIXELADDR4(x[i],y[i]);
-         GLuint pixel = *ptr4;
-         rgba[i][RCOMP] = UNPACK_RED(pixel);
-         rgba[i][GCOMP] = UNPACK_GREEN(pixel);
-         rgba[i][BCOMP] = UNPACK_BLUE(pixel);
-         rgba[i][ACOMP] = UNPACK_ALPHA(pixel);
+         const GLchan *p = PIXELADDR4(x[i], y[i]);
+         rgba[i][RCOMP] = UNPACK_RED(p);
+         rgba[i][GCOMP] = UNPACK_GREEN(p);
+         rgba[i][BCOMP] = UNPACK_BLUE(p);
+         rgba[i][ACOMP] = UNPACK_ALPHA(p);
       }
    }
 }
@@ -898,282 +1082,474 @@
 /*****                3 byte RGB pixel support funcs              *****/
 /**********************************************************************/
 
-/* Write RGBA pixels to an RGB or BGR buffer. */
-static void write_rgba_span3( const GLcontext *ctx,
-                              GLuint n, GLint x, GLint y,
-                              CONST GLubyte rgba[][4], const GLubyte mask[] )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLubyte *ptr3 = PIXELADDR3( x, y);
-   GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
+/* Write RGBA pixels to an RGB buffer. */
+static void
+write_rgba_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
    if (mask) {
-      for (i=0;i<n;i++,ptr3+=3) {
+      for (i = 0; i < n; i++, p += 3) {
          if (mask[i]) {
-            ptr3[rind] = rgba[i][RCOMP];
-            ptr3[gind] = rgba[i][GCOMP];
-            ptr3[bind] = rgba[i][BCOMP];
+            PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr3+=3) {
-         ptr3[rind] = rgba[i][RCOMP];
-         ptr3[gind] = rgba[i][GCOMP];
-         ptr3[bind] = rgba[i][BCOMP];
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
-/* Write RGB pixels to an RGB or BGR buffer. */
-static void write_rgb_span3( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             CONST GLubyte rgb[][3], const GLubyte mask[] )
+/* Write RGBA pixels to an BGR buffer. */
+static void
+write_rgba_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                     CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
    if (mask) {
-      for (i=0;i<n;i++,ptr3+=3) {
+      for (i = 0; i < n; i++, p += 3) {
          if (mask[i]) {
-            ptr3[rind] = rgb[i][RCOMP];
-            ptr3[gind] = rgb[i][GCOMP];
-            ptr3[bind] = rgb[i][BCOMP];
+            PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
          }
       }
    }
    else {
-      for (i=0;i<n;i++,ptr3+=3) {
-         ptr3[rind] = rgb[i][RCOMP];
-         ptr3[gind] = rgb[i][GCOMP];
-         ptr3[bind] = rgb[i][BCOMP];
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
       }
    }
 }
 
+/* Write RGB pixels to an RGB buffer. */
+static void
+write_rgb_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    CONST GLchan rgb[][3], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   if (mask) {
+      for (i = 0; i < n; i++, p += 3) {
+         if (mask[i]) {
+            PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
 
-static void write_monocolor_span3( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-				  const GLubyte mask[] )
+/* Write RGB pixels to an BGR buffer. */
+static void
+write_rgb_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    CONST GLchan rgb[][3], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
+   GLuint i;
+   if (mask) {
+      for (i = 0; i < n; i++, p += 3) {
+         if (mask[i]) {
+            PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, p += 3) {
+         PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
+
 
-   GLubyte rval = UNPACK_RED(osmesa->pixel);
-   GLubyte gval = UNPACK_GREEN(osmesa->pixel);
-   GLubyte bval = UNPACK_BLUE(osmesa->pixel);
-   GLint   rind = osmesa->rind;
-   GLint   gind = osmesa->gind;
-   GLint   bind = osmesa->bind;
-   GLubyte *ptr3 = PIXELADDR3( x, y);
+static void
+write_monocolor_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLchan color[4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
-   for (i=0;i<n;i++,ptr3+=3) {
+   for (i = 0; i < n; i++, p += 3) {
       if (mask[i]) {
-         ptr3[rind] = rval;
-         ptr3[gind] = gval;
-         ptr3[bind] = bval;
+         PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
       }
    }
 }
 
-static void write_rgba_pixels3( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-                                CONST GLubyte rgba[][4], const GLubyte mask[] )
+static void
+write_monocolor_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *p = PIXELADDR3(x, y);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++, p += 3) {
       if (mask[i]) {
-         GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         ptr3[rind] = rgba[i][RCOMP];
-         ptr3[gind] = rgba[i][GCOMP];
-         ptr3[bind] = rgba[i][BCOMP];
+         PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
       }
    }
 }
 
-static void write_monocolor_pixels3( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-				    const GLubyte mask[] )
+static void
+write_rgba_pixels_RGB( const GLcontext *ctx, GLuint n,
+                       const GLint x[], const GLint y[],
+                       CONST GLchan rgba[][4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = (const OSMesaContext) ctx;
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   GLubyte rval = UNPACK_RED(osmesa->pixel);
-   GLubyte gval = UNPACK_GREEN(osmesa->pixel);
-   GLubyte bval = UNPACK_BLUE(osmesa->pixel);
-   for (i=0;i<n;i++) {
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+   }
+}
+
+static void
+write_rgba_pixels_BGR( const GLcontext *ctx, GLuint n,
+                       const GLint x[], const GLint y[],
+                       CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = (const OSMesaContext) ctx;
+   GLuint i;
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+   }
+}
+
+static void
+write_monocolor_pixels_RGB( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLchan color[4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         ptr3[rind] = rval;
-         ptr3[gind] = gval;
-         ptr3[bind] = bval;
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
       }
    }
 }
 
-static void read_rgba_span3( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y,
-                             GLubyte rgba[][4] )
+static void
+write_monocolor_pixels_BGR( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLchan color[4], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   const GLubyte *ptr3 = PIXELADDR3( x, y);
-   for (i=0;i<n;i++,ptr3+=3) {
-      rgba[i][RCOMP] = ptr3[rind];
-      rgba[i][GCOMP] = ptr3[gind];
-      rgba[i][BCOMP] = ptr3[bind];
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLchan *p = PIXELADDR3(x[i], y[i]);
+         PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
+      }
+   }
+}
+
+static void
+read_rgba_span3( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                 GLchan rgba[][4] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   const GLchan *p = PIXELADDR3(x, y);
+   for (i = 0; i < n; i++, p += 3) {
+      rgba[i][RCOMP] = UNPACK_RED(p);
+      rgba[i][GCOMP] = UNPACK_GREEN(p);
+      rgba[i][BCOMP] = UNPACK_BLUE(p);
+      rgba[i][ACOMP] = CHAN_MAX;
+   }
+}
+
+static void
+read_rgba_pixels3( const GLcontext *ctx,
+                   GLuint n, const GLint x[], const GLint y[],
+                   GLchan rgba[][4], const GLubyte mask[] )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         const GLchan *p = PIXELADDR3(x[i], y[i]);
+         rgba[i][RCOMP] = UNPACK_RED(p);
+         rgba[i][GCOMP] = UNPACK_GREEN(p);
+         rgba[i][BCOMP] = UNPACK_BLUE(p);
+         rgba[i][ACOMP] = CHAN_MAX;
+      }
+   }
+}
+
+
+/**********************************************************************/
+/*****                2 byte RGB pixel support funcs              *****/
+/**********************************************************************/
+
+/* Write RGBA pixels to an RGB_565 buffer. */
+static void
+write_rgba_span2( const GLcontext *ctx,
+                  GLuint n, GLint x, GLint y,
+                  CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLushort *ptr2 = (GLushort *) PIXELADDR2(x, y);
+   GLuint i;
+   if (mask) {
+      for (i = 0; i < n; i++, ptr2++) {
+         if (mask[i]) {
+            PACK_RGB_565(*ptr2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, ptr2++) {
+         PACK_RGB_565(*ptr2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+   }
+}
+
+
+/* Write RGB pixels to an RGB_565 buffer. */
+static void
+write_rgb_span2( const GLcontext *ctx,
+                 GLuint n, GLint x, GLint y,
+                 CONST GLchan rgb[][3], const GLubyte mask[] )
+{
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLushort *ptr2 = (GLushort *) PIXELADDR2(x, y);
+   GLuint i;
+   if (mask) {
+      for (i = 0; i < n; i++, ptr2++) {
+         if (mask[i]) {
+            PACK_RGB_565(*ptr2, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i = 0; i < n; i++, ptr2++) {
+         PACK_RGB_565(*ptr2, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
+
+
+static void
+write_monocolor_span2( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                       const GLchan color[4], const GLubyte mask[] )
+{
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLushort pixel;
+   GLushort *ptr2 = (GLushort *) PIXELADDR2(x, y);
+   GLuint i;
+   PACK_RGB_565(pixel, color[RCOMP], color[GCOMP], color[BCOMP]);
+   for (i = 0; i < n; i++, ptr2++) {
+      if (mask[i]) {
+         *ptr2 = pixel;
+      }
+   }
+}
+
+
+static void
+write_rgba_pixels2( const GLcontext *ctx,
+                    GLuint n, const GLint x[], const GLint y[],
+                    CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLushort *ptr2 = (GLushort *) PIXELADDR2(x[i],y[i]);
+         PACK_RGB_565(*ptr2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+   }
+}
+
+static void
+write_monocolor_pixels2( const GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         const GLchan color[4], const GLubyte mask[] )
+{
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   GLushort pixel;
+   PACK_RGB_565(pixel, color[RCOMP], color[GCOMP], color[BCOMP]);
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         GLushort *ptr2 = (GLushort *) PIXELADDR2(x[i],y[i]);
+         *ptr2 = pixel;
+      }
+   }
+}
+
+static void
+read_rgba_span2( const GLcontext *ctx,
+                 GLuint n, GLint x, GLint y,
+                 GLchan rgba[][4] )
+{
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   const GLushort *ptr2 = (const GLushort *) PIXELADDR2(x, y);
+   for (i = 0; i < n; i++, ptr2++) {
+      /* This should be fixed to get the low bits right */
+      rgba[i][RCOMP] = (*ptr2 >> 8) & 0xFe;
+      rgba[i][GCOMP] = (*ptr2 >> 3) & 0xFc;
+      rgba[i][BCOMP] = (*ptr2 << 3) & 0xFe;
       rgba[i][ACOMP] = 0;
    }
 }
 
-static void read_rgba_pixels3( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLubyte rgba[][4], const GLubyte mask[] )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLuint i;
-   GLint rind = osmesa->rind;
-   GLint gind = osmesa->gind;
-   GLint bind = osmesa->bind;
-   for (i=0;i<n;i++) {
+static void
+read_rgba_pixels2( const GLcontext *ctx,
+                   GLuint n, const GLint x[], const GLint y[],
+                   GLchan rgba[][4], const GLubyte mask[] )
+{
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLuint i;
+   for (i = 0; i < n; i++) {
       if (mask[i]) {
-         const GLubyte *ptr3 = PIXELADDR3(x[i],y[i]);
-         rgba[i][RCOMP] = ptr3[rind];
-         rgba[i][GCOMP] = ptr3[gind];
-         rgba[i][BCOMP] = ptr3[bind];
+         /* This should be fixed to get the low bits right */
+         const GLushort *ptr2 = (const GLushort *) PIXELADDR2(x[i],y[i]);
+         rgba[i][RCOMP] = (*ptr2 >> 8) & 0xFE;
+         rgba[i][GCOMP] = (*ptr2 >> 3) & 0xFC;
+         rgba[i][BCOMP] = (*ptr2 << 3) & 0xFE;
          rgba[i][ACOMP] = 0;
       }
    }
 }
 
 
+
 /**********************************************************************/
 /*****        Read/write spans/arrays of CI pixels                *****/
 /**********************************************************************/
 
 /* Write 32-bit color index to buffer */
-static void write_index32_span( const GLcontext *ctx,
-                                GLuint n, GLint x, GLint y,
-                                const GLuint index[], const GLubyte mask[] )
+static void
+write_index32_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                    const GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    if (mask) {
       for (i=0;i<n;i++,ptr1++) {
          if (mask[i]) {
-            *ptr1 = (GLubyte) index[i];
+            *ptr1 = (GLchan) index[i];
          }
       }
    }
    else {
       for (i=0;i<n;i++,ptr1++) {
-         *ptr1 = (GLubyte) index[i];
+         *ptr1 = (GLchan) index[i];
       }
    }
 }
 
 
 /* Write 8-bit color index to buffer */
-static void write_index8_span( const GLcontext *ctx,
-                               GLuint n, GLint x, GLint y,
-                               const GLubyte index[], const GLubyte mask[] )
+static void
+write_index8_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                   const GLubyte index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    if (mask) {
       for (i=0;i<n;i++,ptr1++) {
          if (mask[i]) {
-            *ptr1 = (GLubyte) index[i];
+            *ptr1 = (GLchan) index[i];
          }
       }
    }
    else {
-      MEMCPY( ptr1, index, n );
+      MEMCPY(ptr1, index, n * sizeof(GLchan));
    }
 }
 
 
-static void write_monoindex_span( const GLcontext *ctx,
-                                  GLuint n, GLint x, GLint y,
-				  const GLubyte mask[] )
+static void
+write_monoindex_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      GLuint colorIndex, const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLubyte *ptr1 = PIXELADDR1(x,y);
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   GLchan *ptr1 = PIXELADDR1(x, y);
    GLuint i;
    for (i=0;i<n;i++,ptr1++) {
       if (mask[i]) {
-         *ptr1 = (GLubyte) osmesa->pixel;
+         *ptr1 = (GLchan) colorIndex;
       }
    }
 }
 
 
-static void write_index_pixels( const GLcontext *ctx,
-                                GLuint n, const GLint x[], const GLint y[],
-			        const GLuint index[], const GLubyte mask[] )
+static void
+write_index_pixels( const GLcontext *ctx,
+                    GLuint n, const GLint x[], const GLint y[],
+                    const GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i]) {
-         GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
-         *ptr1 = (GLubyte) index[i];
+         GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
+         *ptr1 = (GLchan) index[i];
       }
    }
 }
 
 
-static void write_monoindex_pixels( const GLcontext *ctx,
-                                    GLuint n, const GLint x[], const GLint y[],
-				    const GLubyte mask[] )
+static void
+write_monoindex_pixels( const GLcontext *ctx,
+                        GLuint n, const GLint x[], const GLint y[],
+                        GLuint colorIndex, const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i]) {
-         GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
-         *ptr1 = (GLubyte) osmesa->pixel;
+         GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
+         *ptr1 = (GLchan) colorIndex;
       }
    }
 }
 
 
-static void read_index_span( const GLcontext *ctx,
-                             GLuint n, GLint x, GLint y, GLuint index[] )
+static void
+read_index_span( const GLcontext *ctx,
+                 GLuint n, GLint x, GLint y, GLuint index[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
-   const GLubyte *ptr1 = PIXELADDR1(x,y);
+   const GLchan *ptr1 = (const GLchan *) PIXELADDR1(x, y);
    for (i=0;i<n;i++,ptr1++) {
       index[i] = (GLuint) *ptr1;
    }
 }
 
 
-static void read_index_pixels( const GLcontext *ctx,
-                               GLuint n, const GLint x[], const GLint y[],
-			       GLuint index[], const GLubyte mask[] )
+static void
+read_index_pixels( const GLcontext *ctx,
+                   GLuint n, const GLint x[], const GLint y[],
+                   GLuint index[], const GLubyte mask[] )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
    GLuint i;
    for (i=0;i<n;i++) {
       if (mask[i] ) {
-         const GLubyte *ptr1 = PIXELADDR1(x[i],y[i]);
+         const GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
          index[i] = (GLuint) *ptr1;
       }
    }
@@ -1189,21 +1565,24 @@
 /*
  * Draw a flat-shaded, RGB line into an osmesa buffer.
  */
-static void flat_rgba_line( GLcontext *ctx,
-                            GLuint vert0, GLuint vert1, GLuint pvert )
+static void
+flat_rgba_line( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLubyte *color = ctx->VB->ColorPtr->data[pvert];
-   unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLchan *color = vert1->color;
 
 #define INTERP_XY 1
 #define CLIP_HACK 1
-#define PLOT(X,Y) { GLuint *ptr4 = PIXELADDR4(X,Y); *ptr4 = pixel; }
+#define PLOT(X, Y)						\
+do {								\
+   GLchan *p = PIXELADDR4(X, Y);				\
+   PACK_RGBA(p, color[0], color[1], color[2], color[3]);	\
+} while (0)
 
 #ifdef WIN32
-#include "..\linetemp.h"
+#include "..\swrast\s_linetemp.h"
 #else
-#include "linetemp.h"
+#include "swrast/s_linetemp.h"
 #endif
 }
 
@@ -1211,53 +1590,57 @@
 /*
  * Draw a flat-shaded, Z-less, RGB line into an osmesa buffer.
  */
-static void flat_rgba_z_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pvert )
+static void
+flat_rgba_z_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1)
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLubyte *color = ctx->VB->ColorPtr->data[pvert];
-   unsigned long pixel = PACK_RGBA( color[0], color[1], color[2], color[3] );
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLchan *color = vert1->color;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define CLIP_HACK 1
-#define PLOT(X,Y)				\
-	if (Z < *zPtr) {			\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);	\
-	   *ptr4 = pixel;			\
-	   *zPtr = Z;				\
-	}
+#define PLOT(X, Y)					\
+do {							\
+   if (Z < *zPtr) {					\
+      GLchan *p = PIXELADDR4(X, Y);			\
+      PACK_RGBA(p, color[RCOMP], color[GCOMP],		\
+                   color[BCOMP], color[ACOMP]);		\
+      *zPtr = Z;					\
+   }							\
+} while (0)
+
 
 #ifdef WIN32
-#include "..\linetemp.h"
+#include "..\swrast\s_linetemp.h"
 #else
-#include "linetemp.h"
+#include "swrast/s_linetemp.h"
 #endif
 }
 
 
 /*
  * Draw a flat-shaded, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_line( GLcontext *ctx,
-                                  GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   struct vertex_buffer *VB = ctx->VB;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = VB->ColorPtr->data[pvert][3];
-   GLint msavalue = 255 - avalue;
-   GLint rvalue = VB->ColorPtr->data[pvert][0]*avalue;
-   GLint gvalue = VB->ColorPtr->data[pvert][1]*avalue;
-   GLint bvalue = VB->ColorPtr->data[pvert][2]*avalue;
+static void
+flat_blend_rgba_line( GLcontext *ctx,
+                      const SWvertex *vert0, const SWvertex *vert1 )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = CHAN_MAX - avalue;
+   const GLint rvalue = vert1->color[0]*avalue;
+   const GLint gvalue = vert1->color[1]*avalue;
+   const GLint bvalue = vert1->color[2]*avalue;
 
 #define INTERP_XY 1
 #define CLIP_HACK 1
 #define PLOT(X,Y)					\
-   { GLuint *ptr4 = PIXELADDR4(X,Y);			\
+   { GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);	\
      GLuint  pixel = 0;					\
      pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\
      pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\
@@ -1265,30 +1648,43 @@
      *ptr4 = pixel;					\
    }
 
+#if 0  /* XXX use this in the future */
+#define PLOT(X,Y)							\
+   {									\
+      GLchan *pixel = (GLchan *) PIXELADDR4(X, Y);			\
+      pixel[rInd] = (pixel[rInd] * msavalue + rvalue) >> CHAN_BITS;	\
+      pixel[gInd] = (pixel[gInd] * msavalue + gvalue) >> CHAN_BITS;	\
+      pixel[bInd] = (pixel[bInd] * msavalue + bvalue) >> CHAN_BITS;	\
+      pixel[aInd] = (pixel[aInd] * msavalue + avalue) >> CHAN_BITS;	\
+   }
+#endif
+
 #ifdef WIN32
-#include "..\linetemp.h"
+#include "..\swrast\s_linetemp.h"
 #else
-#include "linetemp.h"
+#include "swrast/s_linetemp.h"
 #endif
 }
 
 
 /*
  * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
+ * But don't write to Z buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_z_line( GLcontext *ctx,
-                                   GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   struct vertex_buffer *VB = ctx->VB;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = VB->ColorPtr->data[pvert][3];
-   GLint msavalue = 256 - avalue;
-   GLint rvalue = VB->ColorPtr->data[pvert][0]*avalue;
-   GLint gvalue = VB->ColorPtr->data[pvert][1]*avalue;
-   GLint bvalue = VB->ColorPtr->data[pvert][2]*avalue;
+static void
+flat_blend_rgba_z_line( GLcontext *ctx,
+                        const SWvertex *vert0, const SWvertex *vert1 )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 256 - avalue;
+   const GLint rvalue = vert1->color[0]*avalue;
+   const GLint gvalue = vert1->color[1]*avalue;
+   const GLint bvalue = vert1->color[2]*avalue;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
@@ -1296,7 +1692,7 @@
 #define CLIP_HACK 1
 #define PLOT(X,Y)							\
 	if (Z < *zPtr) {						\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);				\
+	   GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);			\
 	   GLuint  pixel = 0;						\
 	   pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);	\
 	   pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);	\
@@ -1304,30 +1700,42 @@
 	   *ptr4 = pixel; 						\
 	}
 
+#if 0  /* XXX use this in the future */
+#define PLOT(X,Y)							\
+   if (Z < *zPtr) {							\
+      GLchan *pixel = (GLchan *) PIXELADDR4(X, Y);			\
+      pixel[rInd] = (pixel[rInd] * msavalue + rvalue) >> CHAN_BITS;	\
+      pixel[gInd] = (pixel[gInd] * msavalue + gvalue) >> CHAN_BITS;	\
+      pixel[bInd] = (pixel[bInd] * msavalue + bvalue) >> CHAN_BITS;	\
+      pixel[aInd] = (pixel[aInd] * msavalue + avalue) >> CHAN_BITS;	\
+   }
+#endif
+
 #ifdef WIN32
-#include "..\linetemp.h"
+#include "..\swrast\s_linetemp.h"
 #else
-#include "linetemp.h"
+#include "swrast/s_linetemp.h"
 #endif
 }
 
 
 /*
  * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
+ * XXX update for GLchan
  */
-static void flat_blend_rgba_z_line_write( GLcontext *ctx,
-                                   GLuint vert0, GLuint vert1, GLuint pvert )
-{
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   struct vertex_buffer *VB = ctx->VB;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint avalue = VB->ColorPtr->data[pvert][3];
-   GLint msavalue = 256 - avalue;
-   GLint rvalue = VB->ColorPtr->data[pvert][0]*avalue;
-   GLint gvalue = VB->ColorPtr->data[pvert][1]*avalue;
-   GLint bvalue = VB->ColorPtr->data[pvert][2]*avalue;
+static void
+flat_blend_rgba_z_line_write( GLcontext *ctx,
+                              const SWvertex *vert0, const SWvertex *vert1 )
+{
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const GLint rshift = osmesa->rshift;
+   const GLint gshift = osmesa->gshift;
+   const GLint bshift = osmesa->bshift;
+   const GLint avalue = vert0->color[3];
+   const GLint msavalue = 256 - avalue;
+   const GLint rvalue = vert1->color[0]*avalue;
+   const GLint gvalue = vert1->color[1]*avalue;
+   const GLint bvalue = vert1->color[2]*avalue;
 
 #define INTERP_XY 1
 #define INTERP_Z 1
@@ -1335,7 +1743,7 @@
 #define CLIP_HACK 1
 #define PLOT(X,Y)							\
 	if (Z < *zPtr) {						\
-	   GLuint *ptr4 = PIXELADDR4(X,Y);				\
+	   GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y);			\
 	   GLuint  pixel = 0;						\
 	   pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);	\
 	   pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);	\
@@ -1344,10 +1752,22 @@
 	   *zPtr = Z;							\
 	}
 
+#if 0  /* XXX use this in the future */
+#define PLOT(X,Y)							\
+   if (Z < *zPtr) {							\
+      GLchan *pixel = (GLchan *) PIXELADDR4(X, Y);			\
+      pixel[rInd] = (pixel[rInd] * msavalue + rvalue) >> CHAN_BITS;	\
+      pixel[gInd] = (pixel[gInd] * msavalue + gvalue) >> CHAN_BITS;	\
+      pixel[bInd] = (pixel[bInd] * msavalue + bvalue) >> CHAN_BITS;	\
+      pixel[aInd] = (pixel[aInd] * msavalue + avalue) >> CHAN_BITS;	\
+      *zPtr = Z;							\
+   }
+#endif
+
 #ifdef WIN32
-#include "..\linetemp.h"
+#include "..\swrast\s_linetemp.h"
 #else
-#include "linetemp.h"
+#include "swrast/s_linetemp.h"
 #endif
 }
 
@@ -1356,98 +1776,70 @@
  * Analyze context state to see if we can provide a fast line drawing
  * function, like those in lines.c.  Otherwise, return NULL.
  */
-static line_func choose_line_function( GLcontext *ctx )
+static swrast_line_func
+osmesa_choose_line_function( GLcontext *ctx )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
 
+   if (CHAN_BITS != 8)                    return NULL;
+   if (ctx->RenderMode != GL_RENDER)      return NULL;
+   if (ctx->Line.SmoothFlag)              return NULL;
+   if (ctx->Texture._ReallyEnabled)       return NULL;
+   if (ctx->Light.ShadeModel != GL_FLAT)  return NULL;
+   if (ctx->Line.Width != 1.0F)           return NULL;
+   if (ctx->Line.StippleFlag)             return NULL;
    if (ctx->Line.SmoothFlag)              return NULL;
-   if (ctx->Texture.ReallyEnabled)        return NULL;
-   if (ctx->Light.ShadeModel!=GL_FLAT)    return NULL;
+   if (osmesa->format != OSMESA_RGBA &&
+       osmesa->format != OSMESA_BGRA &&
+       osmesa->format != OSMESA_ARGB)     return NULL;
 
-   if (ctx->Line.Width==1.0F
-       && ctx->Line.StippleFlag==GL_FALSE) {
 
-       if (ctx->RasterMask==DEPTH_BIT
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_TRUE
-           && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_rgba_z_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (ctx->RasterMask==0) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_rgba_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (ctx->RasterMask==(DEPTH_BIT|BLEND_BIT)
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_TRUE
-           && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_z_line_write;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (ctx->RasterMask==(DEPTH_BIT|BLEND_BIT)
-           && ctx->Depth.Func==GL_LESS
-           && ctx->Depth.Mask==GL_FALSE
-           && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_z_line;
-       		default:
-       			return NULL;
-           }
-       }
-
-       if (ctx->RasterMask==BLEND_BIT
-           && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
-           && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendSrcA==GL_SRC_ALPHA
-           && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
-           && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
-           switch(osmesa->format) {
-       		case OSMESA_RGBA:
-       		case OSMESA_BGRA:
-       		case OSMESA_ARGB:
-       			return flat_blend_rgba_line;
-       		default:
-       			return NULL;
-           }
-       }
+   if (swrast->_RasterMask==DEPTH_BIT
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_TRUE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
+      return (swrast_line_func) flat_rgba_z_line;
+   }
+
+   if (swrast->_RasterMask == 0) {
+      return (swrast_line_func) flat_rgba_line;
+   }
+
+   if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_TRUE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return (swrast_line_func) flat_blend_rgba_z_line_write;
+   }
 
+   if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_FALSE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return (swrast_line_func) flat_blend_rgba_z_line;
+   }
+
+   if (swrast->_RasterMask==BLEND_BIT
+       && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
+       && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendSrcA==GL_SRC_ALPHA
+       && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
+       && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+      return (swrast_line_func) flat_blend_rgba_line;
    }
-   return NULL;
+
+   return (swrast_line_func) NULL;
 }
 
 
@@ -1459,39 +1851,39 @@
 /*
  * Smooth-shaded, z-less triangle, RGBA color.
  */
-static void smooth_rgba_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
+static void smooth_rgba_z_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+                                    const SWvertex *v1,
+                                    const SWvertex *v2 )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-   GLint rshift = osmesa->rshift;
-   GLint gshift = osmesa->gshift;
-   GLint bshift = osmesa->bshift;
-   GLint ashift = osmesa->ashift;
-   (void) pv;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
 
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
 #define INTERP_RGB 1
 #define INTERP_ALPHA 1
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint i, len = RIGHT-LEFT;					\
-   GLuint *img = PIXELADDR4(LEFT,Y);   				\
-   for (i=0;i<len;i++,img++) {					\
-      GLdepth z = FixedToDepth(ffz);				\
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLchan *img = PIXELADDR4(span.x, span.y); 			\
+   for (i = 0; i < span.count; i++, img += 4) {			\
+      const GLdepth z = FixedToDepth(span.z);			\
       if (z < zRow[i]) {					\
-         *img = PACK_RGBA2( FixedToInt(ffr), FixedToInt(ffg),	\
-		            FixedToInt(ffb), FixedToInt(ffa) );	\
+         PACK_RGBA(img, FixedToChan(span.red),			\
+            FixedToChan(span.green), FixedToChan(span.blue),	\
+            FixedToChan(span.alpha));				\
          zRow[i] = z;						\
       }								\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;  ffa += fdadx;\
-      ffz += fdzdx;						\
-   }								\
-}
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.alpha += span.alphaStep;				\
+      span.z += span.zStep;					\
+   }
+
 #ifdef WIN32
-#include "..\tritemp.h"
+#include "..\swrast\s_tritemp.h"
 #else
-#include "tritemp.h"
+#include "swrast/s_tritemp.h"
 #endif
 }
 
@@ -1501,36 +1893,35 @@
 /*
  * Flat-shaded, z-less triangle, RGBA color.
  */
-static void flat_rgba_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                   GLuint v2, GLuint pv )
+static void flat_rgba_z_triangle( GLcontext *ctx,
+				  const SWvertex *v0,
+                                  const SWvertex *v1,
+                                  const SWvertex *v2 )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
 #define INTERP_Z 1
 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE			\
-   GLubyte r = VB->ColorPtr->data[pv][0];	\
-   GLubyte g = VB->ColorPtr->data[pv][1];	\
-   GLubyte b = VB->ColorPtr->data[pv][2];	\
-   GLubyte a = VB->ColorPtr->data[pv][3];	\
-   GLuint pixel = PACK_RGBA(r,g,b,a);
-
-#define INNER_LOOP( LEFT, RIGHT, Y )	\
-{					\
-   GLint i, len = RIGHT-LEFT;		\
-   GLuint *img = PIXELADDR4(LEFT,Y);   	\
-   for (i=0;i<len;i++,img++) {		\
-      GLdepth z = FixedToDepth(ffz);	\
-      if (z < zRow[i]) {		\
-         *img = pixel;			\
-         zRow[i] = z;			\
-      }					\
-      ffz += fdzdx;			\
-   }					\
-}
+#define SETUP_CODE						\
+   GLuint pixel;						\
+   PACK_RGBA((GLchan *) &pixel, v2->color[0], v2->color[1],	\
+                                v2->color[2], v2->color[3]);
+
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   GLuint *img = (GLuint *) PIXELADDR4(span.x, span.y);	\
+   for (i = 0; i < span.count; i++) {			\
+      const GLdepth z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {				\
+         img[i] = pixel;				\
+         zRow[i] = z;					\
+      }							\
+      span.z += span.zStep;				\
+   }
+
 #ifdef WIN32
-#include "..\tritemp.h"
+#include "..\swrast\s_tritemp.h"
 #else
-#include "tritemp.h"
+#include "swrast/s_tritemp.h"
 #endif
 }
 
@@ -1539,105 +1930,223 @@
 /*
  * Return pointer to an accelerated triangle function if possible.
  */
-static triangle_func choose_triangle_function( GLcontext *ctx )
+static swrast_tri_func
+osmesa_choose_triangle_function( GLcontext *ctx )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
-
-   if ((osmesa->format==OSMESA_RGB)||(osmesa->format==OSMESA_BGR)) return NULL;
+   const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   const SWcontext *swrast = SWRAST_CONTEXT(ctx);
 
-   if (ctx->Polygon.SmoothFlag)     return NULL;
-   if (ctx->Polygon.StippleFlag)    return NULL;
-   if (ctx->Texture.ReallyEnabled)  return NULL;
-
-   if (ctx->RasterMask==DEPTH_BIT
-       && ctx->Depth.Func==GL_LESS
-       && ctx->Depth.Mask==GL_TRUE
-       && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-       && osmesa->format!=OSMESA_COLOR_INDEX) {
-      if (ctx->Light.ShadeModel==GL_SMOOTH) {
-         return smooth_rgba_z_triangle;
+   if (CHAN_BITS != 8)                  return (swrast_tri_func) NULL;
+   if (ctx->RenderMode != GL_RENDER)    return (swrast_tri_func) NULL;
+   if (ctx->Polygon.SmoothFlag)         return (swrast_tri_func) NULL;
+   if (ctx->Polygon.StippleFlag)        return (swrast_tri_func) NULL;
+   if (ctx->Texture._ReallyEnabled)     return (swrast_tri_func) NULL;
+   if (osmesa->format != OSMESA_RGBA &&
+       osmesa->format != OSMESA_BGRA &&
+       osmesa->format != OSMESA_ARGB)   return (swrast_tri_func) NULL;
+   if (ctx->Polygon.CullFlag && 
+       ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
+                                        return (swrast_tri_func) NULL;
+
+   if (swrast->_RasterMask == DEPTH_BIT &&
+       ctx->Depth.Func == GL_LESS &&
+       ctx->Depth.Mask == GL_TRUE &&
+       ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+         return (swrast_tri_func) smooth_rgba_z_triangle;
       }
       else {
-         return flat_rgba_z_triangle;
+         return (swrast_tri_func) flat_rgba_z_triangle;
       }
    }
-   return NULL;
+   return (swrast_tri_func) NULL;
 }
 
 
 
+/* Override for the swrast triangle-selection function.  Try to use one
+ * of our internal triangle functions, otherwise fall back to the
+ * standard swrast functions.
+ */
+static void osmesa_choose_triangle( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   swrast->Triangle = osmesa_choose_triangle_function( ctx );
+   if (!swrast->Triangle)
+      _swrast_choose_triangle( ctx );
+}
+
+static void osmesa_choose_line( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   swrast->Line = osmesa_choose_line_function( ctx );
+   if (!swrast->Line)
+      _swrast_choose_line( ctx );
+}
+
+
+#define OSMESA_NEW_LINE   (_NEW_LINE | \
+                           _NEW_TEXTURE | \
+                           _NEW_LIGHT | \
+                           _NEW_DEPTH | \
+                           _NEW_RENDERMODE | \
+                           _SWRAST_NEW_RASTERMASK)
+
+#define OSMESA_NEW_TRIANGLE (_NEW_POLYGON | \
+                             _NEW_TEXTURE | \
+                             _NEW_LIGHT | \
+                             _NEW_DEPTH | \
+                             _NEW_RENDERMODE | \
+                             _SWRAST_NEW_RASTERMASK)
+
+
+/* Extend the software rasterizer with our line and triangle
+ * functions.
+ */
+static void osmesa_register_swrast_functions( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT( ctx );
+
+   swrast->choose_line = osmesa_choose_line;
+   swrast->choose_triangle = osmesa_choose_triangle;
+
+   swrast->invalidate_line |= OSMESA_NEW_LINE;
+   swrast->invalidate_triangle |= OSMESA_NEW_TRIANGLE;
+}
+
+
 static const GLubyte *get_string( GLcontext *ctx, GLenum name )
 {
    (void) ctx;
    switch (name) {
       case GL_RENDERER:
+#if CHAN_BITS == 32
+         return (const GLubyte *) "Mesa OffScreen32";
+#elif CHAN_BITS == 16
+         return (const GLubyte *) "Mesa OffScreen16";
+#else
          return (const GLubyte *) "Mesa OffScreen";
+#endif
       default:
          return NULL;
    }
 }
 
 
-static void osmesa_update_state( GLcontext *ctx )
+static void osmesa_update_state( GLcontext *ctx, GLuint new_state )
 {
-   OSMesaContext osmesa = (OSMesaContext) ctx;
+   OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
+   struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
 
    ASSERT((void *) osmesa == (void *) ctx->DriverCtx);
 
+   /*
+    * XXX these function pointers could be initialized just once during
+    * context creation since they don't depend on any state changes.
+    */
+
    ctx->Driver.GetString = get_string;
    ctx->Driver.UpdateState = osmesa_update_state;
-
    ctx->Driver.SetDrawBuffer = set_draw_buffer;
-   ctx->Driver.SetReadBuffer = set_read_buffer;
-   ctx->Driver.Color = set_color;
-   ctx->Driver.Index = set_index;
-   ctx->Driver.ClearIndex = clear_index;
-   ctx->Driver.ClearColor = clear_color;
-   ctx->Driver.Clear = clear;
-
    ctx->Driver.GetBufferSize = buffer_size;
+   ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;
 
-   ctx->Driver.PointsFunc = NULL;
-   ctx->Driver.LineFunc = choose_line_function( ctx );
-   ctx->Driver.TriangleFunc = choose_triangle_function( ctx );
-
+   ctx->Driver.Accum = _swrast_Accum;
+   ctx->Driver.Bitmap = _swrast_Bitmap;
+   ctx->Driver.Clear = clear;
+   ctx->Driver.CopyPixels = _swrast_CopyPixels;
+   ctx->Driver.DrawPixels = _swrast_DrawPixels;
+   ctx->Driver.ReadPixels = _swrast_ReadPixels;
+
+   ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
+   ctx->Driver.TexImage1D = _mesa_store_teximage1d;
+   ctx->Driver.TexImage2D = _mesa_store_teximage2d;
+   ctx->Driver.TexImage3D = _mesa_store_teximage3d;
+   ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
+   ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
+   ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
+   ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
+
+   ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
+   ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
+   ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
+   ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
+   ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
+   ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
+   ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
+   ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
+   ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
+
+   ctx->Driver.BaseCompressedTexFormat = _mesa_base_compressed_texformat;
+   ctx->Driver.CompressedTextureSize = _mesa_compressed_texture_size;
+   ctx->Driver.GetCompressedTexImage = _mesa_get_compressed_teximage;
 
    /* RGB(A) span/pixel functions */
-   if ((osmesa->format==OSMESA_RGB) || (osmesa->format==OSMESA_BGR)) {
-      /* 3 bytes / pixel in frame buffer */
-      ctx->Driver.WriteRGBASpan = write_rgba_span3;
-      ctx->Driver.WriteRGBSpan = write_rgb_span3;
-      ctx->Driver.WriteRGBAPixels = write_rgba_pixels3;
-      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span3;
-      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels3;
-      ctx->Driver.ReadRGBASpan = read_rgba_span3;
-      ctx->Driver.ReadRGBAPixels = read_rgba_pixels3;
+   if (osmesa->format == OSMESA_RGB) {
+      swdd->WriteRGBASpan = write_rgba_span_RGB;
+      swdd->WriteRGBSpan = write_rgb_span_RGB;
+      swdd->WriteMonoRGBASpan = write_monocolor_span_RGB;
+      swdd->WriteRGBAPixels = write_rgba_pixels_RGB;
+      swdd->WriteMonoRGBAPixels = write_monocolor_pixels_RGB;
+      swdd->ReadRGBASpan = read_rgba_span3;
+      swdd->ReadRGBAPixels = read_rgba_pixels3;
+   }
+   else if (osmesa->format == OSMESA_BGR) {
+      swdd->WriteRGBASpan = write_rgba_span_BGR;
+      swdd->WriteRGBSpan = write_rgb_span_BGR;
+      swdd->WriteMonoRGBASpan = write_monocolor_span_BGR;
+      swdd->WriteRGBAPixels = write_rgba_pixels_BGR;
+      swdd->WriteMonoRGBAPixels = write_monocolor_pixels_BGR;
+      swdd->ReadRGBASpan = read_rgba_span3;
+      swdd->ReadRGBAPixels = read_rgba_pixels3;
+   }
+   else if (osmesa->format == OSMESA_RGB_565) {
+      swdd->WriteRGBASpan = write_rgba_span2;
+      swdd->WriteRGBSpan = write_rgb_span2;
+      swdd->WriteMonoRGBASpan = write_monocolor_span2;
+      swdd->WriteRGBAPixels = write_rgba_pixels2;
+      swdd->WriteMonoRGBAPixels = write_monocolor_pixels2;
+      swdd->ReadRGBASpan = read_rgba_span2;
+      swdd->ReadRGBAPixels = read_rgba_pixels2;
    }
    else {
-      /* 4 bytes / pixel in frame buffer */
-      if (osmesa->format==OSMESA_RGBA
-          && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3)
-         ctx->Driver.WriteRGBASpan = write_rgba_span_rgba;
-      else
-         ctx->Driver.WriteRGBASpan = write_rgba_span;
-      ctx->Driver.WriteRGBSpan = write_rgb_span;
-      ctx->Driver.WriteRGBAPixels = write_rgba_pixels;
-      ctx->Driver.WriteMonoRGBASpan = write_monocolor_span;
-      ctx->Driver.WriteMonoRGBAPixels = write_monocolor_pixels;
-      if (osmesa->format==OSMESA_RGBA
-          && RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3)
-         ctx->Driver.ReadRGBASpan = read_rgba_span_rgba;
-      else
-         ctx->Driver.ReadRGBASpan = read_rgba_span;
-      ctx->Driver.ReadRGBAPixels = read_rgba_pixels;
+      /* 4 GLchan / pixel in frame buffer */
+      swdd->WriteRGBSpan = write_rgb_span;
+      swdd->WriteRGBAPixels = write_rgba_pixels;
+      swdd->WriteMonoRGBASpan = write_monocolor_span;
+      swdd->WriteMonoRGBAPixels = write_monocolor_pixels;
+      if (osmesa->format == OSMESA_RGBA &&
+          CHAN_TYPE == GL_UNSIGNED_BYTE &&
+          RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) {
+         /* special, fast case */
+         swdd->WriteRGBASpan = write_rgba_span_rgba;
+         swdd->ReadRGBASpan = read_rgba_span_rgba;
+      }
+      else {
+         swdd->WriteRGBASpan = write_rgba_span;
+         swdd->ReadRGBASpan = read_rgba_span;
+      }
+      swdd->ReadRGBAPixels = read_rgba_pixels;
    }
 
    /* CI span/pixel functions */
-   ctx->Driver.WriteCI32Span = write_index32_span;
-   ctx->Driver.WriteCI8Span = write_index8_span;
-   ctx->Driver.WriteMonoCISpan = write_monoindex_span;
-   ctx->Driver.WriteCI32Pixels = write_index_pixels;
-   ctx->Driver.WriteMonoCIPixels = write_monoindex_pixels;
-   ctx->Driver.ReadCI32Span = read_index_span;
-   ctx->Driver.ReadCI32Pixels = read_index_pixels;
+   swdd->WriteCI32Span = write_index32_span;
+   swdd->WriteCI8Span = write_index8_span;
+   swdd->WriteMonoCISpan = write_monoindex_span;
+   swdd->WriteCI32Pixels = write_index_pixels;
+   swdd->WriteMonoCIPixels = write_monoindex_pixels;
+   swdd->ReadCI32Span = read_index_span;
+   swdd->ReadCI32Pixels = read_index_pixels;
+
+   swdd->SetReadBuffer = set_read_buffer;
+
+   tnl->Driver.RunPipeline = _tnl_run_pipeline;
+
+   _swrast_InvalidateState( ctx, new_state );
+   _swsetup_InvalidateState( ctx, new_state );
+   _ac_InvalidateState( ctx, new_state );
+   _tnl_InvalidateState( ctx, new_state );
 }
Index: xc/extras/Mesa/src/SPARC/clip.S
diff -u /dev/null xc/extras/Mesa/src/SPARC/clip.S:1.2
--- /dev/null	Thu Feb 27 12:15:49 2003
+++ xc/extras/Mesa/src/SPARC/clip.S	Mon Dec 16 11:18:30 2002
@@ -0,0 +1,233 @@
+
+#ifdef __sparc_v9__
+#define LDPTR		ldx
+#define V4F_DATA	0x00
+#define V4F_START	0x08
+#define V4F_COUNT	0x10
+#define V4F_STRIDE	0x14
+#define V4F_SIZE	0x18
+#define V4F_FLAGS	0x1c
+#else
+#define LDPTR		ld
+#define V4F_DATA	0x00
+#define V4F_START	0x04
+#define V4F_COUNT	0x08
+#define V4F_STRIDE	0x0c
+#define V4F_SIZE	0x10
+#define V4F_FLAGS	0x14
+#endif
+
+#define VEC_SIZE_1   	1
+#define VEC_SIZE_2   	3
+#define VEC_SIZE_3   	7
+#define VEC_SIZE_4   	15
+
+	.text
+	.align		64
+
+one_dot_zero:
+	.word		0x3f800000	/* 1.0f */
+
+	/* This trick is shamelessly stolen from the x86
+	 * Mesa asm.  Very clever, and we can do it too
+	 * since we have the necessary add with carry
+	 * instructions on Sparc.
+	 */
+clip_table:
+	.byte	 0,  1,  0,  2,  4,  5,  4,  6
+	.byte	 0,  1,  0,  2,  8,  9,  8, 10
+	.byte	32, 33, 32, 34, 36, 37, 36, 38
+	.byte	32, 33, 32, 34, 40, 41, 40, 42
+	.byte	 0,  1,  0,  2,  4,  5,  4,  6
+	.byte	 0,  1,  0,  2,  8,  9,  8, 10
+	.byte	16, 17, 16, 18, 20, 21, 20, 22
+	.byte	16, 17, 16, 18, 24, 25, 24, 26
+	.byte	63, 61, 63, 62, 55, 53, 55, 54
+	.byte	63, 61, 63, 62, 59, 57, 59, 58
+	.byte	47, 45, 47, 46, 39, 37, 39, 38
+	.byte	47, 45, 47, 46, 43, 41, 43, 42
+	.byte	63, 61, 63, 62, 55, 53, 55, 54
+	.byte	63, 61, 63, 62, 59, 57, 59, 58
+	.byte	31, 29, 31, 30, 23, 21, 23, 22
+	.byte	31, 29, 31, 30, 27, 25, 27, 26
+
+/* GLvector4f *clip_vec, GLvector4f *proj_vec, 
+   GLubyte clipMask[], GLubyte *orMask, GLubyte *andMask */
+
+	.align		64
+__pc_tramp:
+	retl
+	 nop
+
+	.globl		_mesa_sparc_cliptest_points4
+_mesa_sparc_cliptest_points4:
+	save		%sp, -64, %sp
+	call		__pc_tramp
+	 sub		%o7, (. - one_dot_zero - 4), %g1
+	ld		[%g1 + 0x0], %f4
+	add		%g1, 0x4, %g1
+
+	ld		[%i0 + V4F_STRIDE], %l1
+	ld		[%i0 + V4F_COUNT], %g7
+	LDPTR		[%i0 + V4F_START], %i0
+	LDPTR		[%i1 + V4F_START], %i5
+	ldub		[%i3], %g2
+	ldub		[%i4], %g3
+	sll		%g3, 8, %g3
+	or		%g2, %g3, %g2
+
+	ld		[%i1 + V4F_FLAGS], %g3
+	or		%g3, VEC_SIZE_4, %g3
+	st		%g3, [%i1 + V4F_FLAGS]
+	mov		3, %g3
+	st		%g3, [%i1 + V4F_SIZE]
+	st		%g7, [%i1 + V4F_COUNT]
+	clr		%l2
+	clr		%l0
+
+	/* l0:	i
+	 * g7:	count
+	 * l1:	stride
+	 * l2:	c
+	 * g2:	(tmpAndMask << 8) | tmpOrMask
+	 * g1:	clip_table
+	 * i0:	from[stride][i]
+	 * i2:	clipMask
+	 * i5:	vProj[4][i]
+	 */
+
+1:	ld		[%i0 + 0x0c], %f3	! LSU	Group
+	ld		[%i0 + 0x0c], %g5	! LSU	Group
+	ld		[%i0 + 0x08], %g4	! LSU	Group
+	fdivs		%f4, %f3, %f8		! FGM
+	addcc		%g5, %g5, %g5		! IEU1	Group
+	addx		%g0, 0x0, %g3		! IEU1	Group
+	addcc		%g4, %g4, %g4		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	subcc		%g5, %g4, %g0		! IEU1	Group
+	ld		[%i0 + 0x04], %g4	! LSU	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	addcc		%g4, %g4, %g4		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	subcc		%g5, %g4, %g0		! IEU1	Group
+	ld		[%i0 + 0x00], %g4	! LSU	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	addcc		%g4, %g4, %g4		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	subcc		%g5, %g4, %g0		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	ldub		[%g1 + %g3], %g3	! LSU	Group
+	cmp		%g3, 0			! IEU1	Group, stall
+	be		2f			! CTI
+	 stb		%g3, [%i2]		! LSU
+	sll		%g3, 8, %g4		! IEU1	Group
+	add		%l2, 1, %l2		! IEU0
+	st		%g0, [%i5 + 0x00]	! LSU
+	or		%g4, 0xff, %g4		! IEU0	Group
+	or		%g2, %g3, %g2		! IEU1
+	st		%g0, [%i5 + 0x04]	! LSU
+	and		%g2, %g4, %g2		! IEU0	Group
+	st		%g0, [%i5 + 0x08]	! LSU
+	b		3f			! CTI
+	 st		%f4, [%i5 + 0x0c]	! LSU	Group
+2:	ld		[%i0 + 0x00], %f0	! LSU	Group
+	ld		[%i0 + 0x04], %f1	! LSU	Group
+	ld		[%i0 + 0x08], %f2	! LSU	Group
+	fmuls		%f0, %f8, %f0		! FGM
+	st		%f0, [%i5 + 0x00]	! LSU	Group
+	fmuls		%f1, %f8, %f1		! FGM
+	st		%f1, [%i5 + 0x04]	! LSU	Group
+	fmuls		%f2, %f8, %f2		! FGM
+	st		%f2, [%i5 + 0x08]	! LSU	Group
+	st		%f8, [%i5 + 0x0c]	! LSU	Group
+3:	add		%i5, 0x10, %i5		! IEU1
+	add		%l0, 1, %l0		! IEU0	Group
+	add		%i2, 1, %i2		! IEU0	Group
+	cmp		%l0, %g7		! IEU1	Group
+	bne		1b			! CTI
+	 add		%i0, %l1, %i0		! IEU0	Group
+	stb		%g2, [%i3]		! LSU
+	srl		%g2, 8, %g3		! IEU0	Group
+	cmp		%l2, %g7		! IEU1	Group
+	bl,a		1f			! CTI
+	 clr		%g3			! IEU0
+1:	stb		%g3, [%i4]		! LSU	Group
+	ret					! CTI	Group
+	 restore	%i1, 0x0, %o0
+
+	.globl		_mesa_sparc_cliptest_points4_np
+_mesa_sparc_cliptest_points4_np:
+	save		%sp, -64, %sp
+
+	call		__pc_tramp
+	 sub		%o7, (. - one_dot_zero - 4), %g1
+	add		%g1, 0x4, %g1
+
+	ld		[%i0 + V4F_STRIDE], %l1
+	ld		[%i0 + V4F_COUNT], %g7
+	LDPTR		[%i0 + V4F_START], %i0
+	LDPTR		[%i1 + V4F_START], %i5
+	ldub		[%i3], %g2
+	ldub		[%i4], %g3
+	sll		%g3, 8, %g3
+	or		%g2, %g3, %g2
+
+	ld		[%i1 + V4F_FLAGS], %g3
+	or		%g3, VEC_SIZE_4, %g3
+	st		%g3, [%i1 + V4F_FLAGS]
+	mov		3, %g3
+	st		%g3, [%i1 + V4F_SIZE]
+	st		%g7, [%i1 + V4F_COUNT]
+	clr		%l2
+	clr		%l0
+
+	/* l0:	i
+	 * g7:	count
+	 * l1:	stride
+	 * l2:	c
+	 * g2:	(tmpAndMask << 8) | tmpOrMask
+	 * g1:	clip_table
+	 * i0:	from[stride][i]
+	 * i2:	clipMask
+	 */
+
+1:	ld		[%i0 + 0x0c], %g5	! LSU	Group
+	ld		[%i0 + 0x08], %g4	! LSU	Group
+	addcc		%g5, %g5, %g5		! IEU1	Group
+	addx		%g0, 0x0, %g3		! IEU1	Group
+	addcc		%g4, %g4, %g4		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	subcc		%g5, %g4, %g0		! IEU1	Group
+	ld		[%i0 + 0x04], %g4	! LSU	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	addcc		%g4, %g4, %g4		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	subcc		%g5, %g4, %g0		! IEU1	Group
+	ld		[%i0 + 0x00], %g4	! LSU	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	addcc		%g4, %g4, %g4		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	subcc		%g5, %g4, %g0		! IEU1	Group
+	addx		%g3, %g3, %g3		! IEU1	Group
+	ldub		[%g1 + %g3], %g3	! LSU	Group
+	cmp		%g3, 0			! IEU1	Group, stall
+	be		2f			! CTI
+	 stb		%g3, [%i2]		! LSU
+	sll		%g3, 8, %g4		! IEU1	Group
+	add		%l2, 1, %l2		! IEU0
+	or		%g4, 0xff, %g4		! IEU0	Group
+	or		%g2, %g3, %g2		! IEU1
+	and		%g2, %g4, %g2		! IEU0	Group
+2:	add		%l0, 1, %l0		! IEU0	Group
+	add		%i2, 1, %i2		! IEU0	Group
+	cmp		%l0, %g7		! IEU1	Group
+	bne		1b			! CTI
+	 add		%i0, %l1, %i0		! IEU0	Group
+	stb		%g2, [%i3]		! LSU
+	srl		%g2, 8, %g3		! IEU0	Group
+	cmp		%l2, %g7		! IEU1	Group
+	bl,a		1f			! CTI
+	 clr		%g3			! IEU0
+1:	stb		%g3, [%i4]		! LSU	Group
+	ret					! CTI	Group
+	 restore	%i1, 0x0, %o0
Index: xc/extras/Mesa/src/SPARC/glapi_sparc.S
diff -u /dev/null xc/extras/Mesa/src/SPARC/glapi_sparc.S:1.1.1.3
--- /dev/null	Thu Feb 27 12:15:49 2003
+++ xc/extras/Mesa/src/SPARC/glapi_sparc.S	Fri Feb 22 12:44:20 2002
@@ -0,0 +1,13975 @@
+/* DO NOT EDIT - This file generated automatically with glsparcasm.py script */
+#include "glapioffsets.h"
+
+
+
+
+/* The _glapi_Dispatch symbol addresses get relocated into the
+ * sethi/or instruction sequences below at library init time.
+ */
+
+
+.text
+.align 32
+.globl __glapi_sparc_icache_flush
+__glapi_sparc_icache_flush: /* %o0 = insn_addr */
+	flush	%o0
+	retl
+	nop
+
+.data
+.align 64
+
+.globl _mesa_sparc_glapi_begin
+.type _mesa_sparc_glapi_begin,#function
+_mesa_sparc_glapi_begin:
+
+.globl glNewList
+.type glNewList,#function
+glNewList:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_NewList), %g2
+	or	%g2, %lo(8 * _gloffset_NewList), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_NewList)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEndList
+.type glEndList,#function
+glEndList:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EndList), %g2
+	or	%g2, %lo(8 * _gloffset_EndList), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EndList)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCallList
+.type glCallList,#function
+glCallList:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CallList), %g2
+	or	%g2, %lo(8 * _gloffset_CallList), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CallList)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCallLists
+.type glCallLists,#function
+glCallLists:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CallLists), %g2
+	or	%g2, %lo(8 * _gloffset_CallLists), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CallLists)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDeleteLists
+.type glDeleteLists,#function
+glDeleteLists:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DeleteLists), %g2
+	or	%g2, %lo(8 * _gloffset_DeleteLists), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DeleteLists)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGenLists
+.type glGenLists,#function
+glGenLists:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GenLists), %g2
+	or	%g2, %lo(8 * _gloffset_GenLists), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GenLists)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glListBase
+.type glListBase,#function
+glListBase:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ListBase), %g2
+	or	%g2, %lo(8 * _gloffset_ListBase), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ListBase)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBegin
+.type glBegin,#function
+glBegin:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Begin), %g2
+	or	%g2, %lo(8 * _gloffset_Begin), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Begin)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBitmap
+.type glBitmap,#function
+glBitmap:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Bitmap), %g2
+	or	%g2, %lo(8 * _gloffset_Bitmap), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Bitmap)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3b
+.type glColor3b,#function
+glColor3b:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3b), %g2
+	or	%g2, %lo(8 * _gloffset_Color3b), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3b)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3bv
+.type glColor3bv,#function
+glColor3bv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3bv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3bv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3bv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3d
+.type glColor3d,#function
+glColor3d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3d), %g2
+	or	%g2, %lo(8 * _gloffset_Color3d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3dv
+.type glColor3dv,#function
+glColor3dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3dv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3f
+.type glColor3f,#function
+glColor3f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3f), %g2
+	or	%g2, %lo(8 * _gloffset_Color3f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3fv
+.type glColor3fv,#function
+glColor3fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3fv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3i
+.type glColor3i,#function
+glColor3i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3i), %g2
+	or	%g2, %lo(8 * _gloffset_Color3i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3iv
+.type glColor3iv,#function
+glColor3iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3iv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3s
+.type glColor3s,#function
+glColor3s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3s), %g2
+	or	%g2, %lo(8 * _gloffset_Color3s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3sv
+.type glColor3sv,#function
+glColor3sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3sv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3ub
+.type glColor3ub,#function
+glColor3ub:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3ub), %g2
+	or	%g2, %lo(8 * _gloffset_Color3ub), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3ub)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3ubv
+.type glColor3ubv,#function
+glColor3ubv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3ubv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3ubv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3ubv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3ui
+.type glColor3ui,#function
+glColor3ui:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3ui), %g2
+	or	%g2, %lo(8 * _gloffset_Color3ui), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3ui)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3uiv
+.type glColor3uiv,#function
+glColor3uiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3uiv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3uiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3uiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3us
+.type glColor3us,#function
+glColor3us:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3us), %g2
+	or	%g2, %lo(8 * _gloffset_Color3us), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3us)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor3usv
+.type glColor3usv,#function
+glColor3usv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color3usv), %g2
+	or	%g2, %lo(8 * _gloffset_Color3usv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color3usv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4b
+.type glColor4b,#function
+glColor4b:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4b), %g2
+	or	%g2, %lo(8 * _gloffset_Color4b), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4b)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4bv
+.type glColor4bv,#function
+glColor4bv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4bv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4bv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4bv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4d
+.type glColor4d,#function
+glColor4d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4d), %g2
+	or	%g2, %lo(8 * _gloffset_Color4d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4dv
+.type glColor4dv,#function
+glColor4dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4dv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4f
+.type glColor4f,#function
+glColor4f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4f), %g2
+	or	%g2, %lo(8 * _gloffset_Color4f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4fv
+.type glColor4fv,#function
+glColor4fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4fv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4i
+.type glColor4i,#function
+glColor4i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4i), %g2
+	or	%g2, %lo(8 * _gloffset_Color4i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4iv
+.type glColor4iv,#function
+glColor4iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4iv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4s
+.type glColor4s,#function
+glColor4s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4s), %g2
+	or	%g2, %lo(8 * _gloffset_Color4s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4sv
+.type glColor4sv,#function
+glColor4sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4sv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4ub
+.type glColor4ub,#function
+glColor4ub:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4ub), %g2
+	or	%g2, %lo(8 * _gloffset_Color4ub), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4ub)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4ubv
+.type glColor4ubv,#function
+glColor4ubv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4ubv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4ubv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4ubv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4ui
+.type glColor4ui,#function
+glColor4ui:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4ui), %g2
+	or	%g2, %lo(8 * _gloffset_Color4ui), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4ui)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4uiv
+.type glColor4uiv,#function
+glColor4uiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4uiv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4uiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4uiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4us
+.type glColor4us,#function
+glColor4us:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4us), %g2
+	or	%g2, %lo(8 * _gloffset_Color4us), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4us)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColor4usv
+.type glColor4usv,#function
+glColor4usv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Color4usv), %g2
+	or	%g2, %lo(8 * _gloffset_Color4usv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Color4usv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEdgeFlag
+.type glEdgeFlag,#function
+glEdgeFlag:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EdgeFlag), %g2
+	or	%g2, %lo(8 * _gloffset_EdgeFlag), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EdgeFlag)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEdgeFlagv
+.type glEdgeFlagv,#function
+glEdgeFlagv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EdgeFlagv), %g2
+	or	%g2, %lo(8 * _gloffset_EdgeFlagv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EdgeFlagv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEnd
+.type glEnd,#function
+glEnd:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_End), %g2
+	or	%g2, %lo(8 * _gloffset_End), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_End)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexd
+.type glIndexd,#function
+glIndexd:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexd), %g2
+	or	%g2, %lo(8 * _gloffset_Indexd), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexd)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexdv
+.type glIndexdv,#function
+glIndexdv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexdv), %g2
+	or	%g2, %lo(8 * _gloffset_Indexdv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexdv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexf
+.type glIndexf,#function
+glIndexf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexf), %g2
+	or	%g2, %lo(8 * _gloffset_Indexf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexfv
+.type glIndexfv,#function
+glIndexfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexfv), %g2
+	or	%g2, %lo(8 * _gloffset_Indexfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexi
+.type glIndexi,#function
+glIndexi:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexi), %g2
+	or	%g2, %lo(8 * _gloffset_Indexi), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexi)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexiv
+.type glIndexiv,#function
+glIndexiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexiv), %g2
+	or	%g2, %lo(8 * _gloffset_Indexiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexs
+.type glIndexs,#function
+glIndexs:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexs), %g2
+	or	%g2, %lo(8 * _gloffset_Indexs), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexs)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexsv
+.type glIndexsv,#function
+glIndexsv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexsv), %g2
+	or	%g2, %lo(8 * _gloffset_Indexsv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexsv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3b
+.type glNormal3b,#function
+glNormal3b:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3b), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3b), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3b)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3bv
+.type glNormal3bv,#function
+glNormal3bv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3bv), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3bv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3bv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3d
+.type glNormal3d,#function
+glNormal3d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3d), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3dv
+.type glNormal3dv,#function
+glNormal3dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3dv), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3f
+.type glNormal3f,#function
+glNormal3f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3f), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3fv
+.type glNormal3fv,#function
+glNormal3fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3fv), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3i
+.type glNormal3i,#function
+glNormal3i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3i), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3iv
+.type glNormal3iv,#function
+glNormal3iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3iv), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3s
+.type glNormal3s,#function
+glNormal3s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3s), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormal3sv
+.type glNormal3sv,#function
+glNormal3sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Normal3sv), %g2
+	or	%g2, %lo(8 * _gloffset_Normal3sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Normal3sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2d
+.type glRasterPos2d,#function
+glRasterPos2d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2d), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2dv
+.type glRasterPos2dv,#function
+glRasterPos2dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2dv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2f
+.type glRasterPos2f,#function
+glRasterPos2f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2f), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2fv
+.type glRasterPos2fv,#function
+glRasterPos2fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2fv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2i
+.type glRasterPos2i,#function
+glRasterPos2i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2i), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2iv
+.type glRasterPos2iv,#function
+glRasterPos2iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2iv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2s
+.type glRasterPos2s,#function
+glRasterPos2s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2s), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos2sv
+.type glRasterPos2sv,#function
+glRasterPos2sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos2sv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos2sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos2sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3d
+.type glRasterPos3d,#function
+glRasterPos3d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3d), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3dv
+.type glRasterPos3dv,#function
+glRasterPos3dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3dv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3f
+.type glRasterPos3f,#function
+glRasterPos3f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3f), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3fv
+.type glRasterPos3fv,#function
+glRasterPos3fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3fv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3i
+.type glRasterPos3i,#function
+glRasterPos3i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3i), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3iv
+.type glRasterPos3iv,#function
+glRasterPos3iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3iv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3s
+.type glRasterPos3s,#function
+glRasterPos3s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3s), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos3sv
+.type glRasterPos3sv,#function
+glRasterPos3sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos3sv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos3sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos3sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4d
+.type glRasterPos4d,#function
+glRasterPos4d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4d), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4dv
+.type glRasterPos4dv,#function
+glRasterPos4dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4dv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4f
+.type glRasterPos4f,#function
+glRasterPos4f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4f), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4fv
+.type glRasterPos4fv,#function
+glRasterPos4fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4fv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4i
+.type glRasterPos4i,#function
+glRasterPos4i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4i), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4iv
+.type glRasterPos4iv,#function
+glRasterPos4iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4iv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4s
+.type glRasterPos4s,#function
+glRasterPos4s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4s), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRasterPos4sv
+.type glRasterPos4sv,#function
+glRasterPos4sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RasterPos4sv), %g2
+	or	%g2, %lo(8 * _gloffset_RasterPos4sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RasterPos4sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRectd
+.type glRectd,#function
+glRectd:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rectd), %g2
+	or	%g2, %lo(8 * _gloffset_Rectd), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rectd)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRectdv
+.type glRectdv,#function
+glRectdv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rectdv), %g2
+	or	%g2, %lo(8 * _gloffset_Rectdv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rectdv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRectf
+.type glRectf,#function
+glRectf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rectf), %g2
+	or	%g2, %lo(8 * _gloffset_Rectf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rectf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRectfv
+.type glRectfv,#function
+glRectfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rectfv), %g2
+	or	%g2, %lo(8 * _gloffset_Rectfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rectfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRecti
+.type glRecti,#function
+glRecti:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Recti), %g2
+	or	%g2, %lo(8 * _gloffset_Recti), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Recti)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRectiv
+.type glRectiv,#function
+glRectiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rectiv), %g2
+	or	%g2, %lo(8 * _gloffset_Rectiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rectiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRects
+.type glRects,#function
+glRects:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rects), %g2
+	or	%g2, %lo(8 * _gloffset_Rects), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rects)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRectsv
+.type glRectsv,#function
+glRectsv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rectsv), %g2
+	or	%g2, %lo(8 * _gloffset_Rectsv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rectsv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1d
+.type glTexCoord1d,#function
+glTexCoord1d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1d), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1dv
+.type glTexCoord1dv,#function
+glTexCoord1dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1dv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1f
+.type glTexCoord1f,#function
+glTexCoord1f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1f), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1fv
+.type glTexCoord1fv,#function
+glTexCoord1fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1fv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1i
+.type glTexCoord1i,#function
+glTexCoord1i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1i), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1iv
+.type glTexCoord1iv,#function
+glTexCoord1iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1iv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1s
+.type glTexCoord1s,#function
+glTexCoord1s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1s), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord1sv
+.type glTexCoord1sv,#function
+glTexCoord1sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord1sv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord1sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord1sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2d
+.type glTexCoord2d,#function
+glTexCoord2d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2d), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2dv
+.type glTexCoord2dv,#function
+glTexCoord2dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2dv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2f
+.type glTexCoord2f,#function
+glTexCoord2f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2f), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2fv
+.type glTexCoord2fv,#function
+glTexCoord2fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2fv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2i
+.type glTexCoord2i,#function
+glTexCoord2i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2i), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2iv
+.type glTexCoord2iv,#function
+glTexCoord2iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2iv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2s
+.type glTexCoord2s,#function
+glTexCoord2s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2s), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord2sv
+.type glTexCoord2sv,#function
+glTexCoord2sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord2sv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord2sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord2sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3d
+.type glTexCoord3d,#function
+glTexCoord3d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3d), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3dv
+.type glTexCoord3dv,#function
+glTexCoord3dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3dv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3f
+.type glTexCoord3f,#function
+glTexCoord3f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3f), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3fv
+.type glTexCoord3fv,#function
+glTexCoord3fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3fv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3i
+.type glTexCoord3i,#function
+glTexCoord3i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3i), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3iv
+.type glTexCoord3iv,#function
+glTexCoord3iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3iv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3s
+.type glTexCoord3s,#function
+glTexCoord3s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3s), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord3sv
+.type glTexCoord3sv,#function
+glTexCoord3sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord3sv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord3sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord3sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4d
+.type glTexCoord4d,#function
+glTexCoord4d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4d), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4dv
+.type glTexCoord4dv,#function
+glTexCoord4dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4dv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4f
+.type glTexCoord4f,#function
+glTexCoord4f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4f), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4fv
+.type glTexCoord4fv,#function
+glTexCoord4fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4fv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4i
+.type glTexCoord4i,#function
+glTexCoord4i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4i), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4iv
+.type glTexCoord4iv,#function
+glTexCoord4iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4iv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4s
+.type glTexCoord4s,#function
+glTexCoord4s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4s), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoord4sv
+.type glTexCoord4sv,#function
+glTexCoord4sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoord4sv), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoord4sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoord4sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2d
+.type glVertex2d,#function
+glVertex2d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2d), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2dv
+.type glVertex2dv,#function
+glVertex2dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2dv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2f
+.type glVertex2f,#function
+glVertex2f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2f), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2fv
+.type glVertex2fv,#function
+glVertex2fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2fv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2i
+.type glVertex2i,#function
+glVertex2i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2i), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2iv
+.type glVertex2iv,#function
+glVertex2iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2iv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2s
+.type glVertex2s,#function
+glVertex2s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2s), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex2sv
+.type glVertex2sv,#function
+glVertex2sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex2sv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex2sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex2sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3d
+.type glVertex3d,#function
+glVertex3d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3d), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3dv
+.type glVertex3dv,#function
+glVertex3dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3dv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3f
+.type glVertex3f,#function
+glVertex3f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3f), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3fv
+.type glVertex3fv,#function
+glVertex3fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3fv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3i
+.type glVertex3i,#function
+glVertex3i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3i), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3iv
+.type glVertex3iv,#function
+glVertex3iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3iv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3s
+.type glVertex3s,#function
+glVertex3s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3s), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex3sv
+.type glVertex3sv,#function
+glVertex3sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex3sv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex3sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex3sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4d
+.type glVertex4d,#function
+glVertex4d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4d), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4dv
+.type glVertex4dv,#function
+glVertex4dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4dv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4f
+.type glVertex4f,#function
+glVertex4f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4f), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4fv
+.type glVertex4fv,#function
+glVertex4fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4fv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4i
+.type glVertex4i,#function
+glVertex4i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4i), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4i), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4i)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4iv
+.type glVertex4iv,#function
+glVertex4iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4iv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4iv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4iv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4s
+.type glVertex4s,#function
+glVertex4s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4s), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4s), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4s)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertex4sv
+.type glVertex4sv,#function
+glVertex4sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Vertex4sv), %g2
+	or	%g2, %lo(8 * _gloffset_Vertex4sv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Vertex4sv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClipPlane
+.type glClipPlane,#function
+glClipPlane:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClipPlane), %g2
+	or	%g2, %lo(8 * _gloffset_ClipPlane), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClipPlane)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorMaterial
+.type glColorMaterial,#function
+glColorMaterial:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorMaterial), %g2
+	or	%g2, %lo(8 * _gloffset_ColorMaterial), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorMaterial)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCullFace
+.type glCullFace,#function
+glCullFace:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CullFace), %g2
+	or	%g2, %lo(8 * _gloffset_CullFace), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CullFace)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogf
+.type glFogf,#function
+glFogf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Fogf), %g2
+	or	%g2, %lo(8 * _gloffset_Fogf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Fogf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogfv
+.type glFogfv,#function
+glFogfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Fogfv), %g2
+	or	%g2, %lo(8 * _gloffset_Fogfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Fogfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogi
+.type glFogi,#function
+glFogi:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Fogi), %g2
+	or	%g2, %lo(8 * _gloffset_Fogi), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Fogi)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogiv
+.type glFogiv,#function
+glFogiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Fogiv), %g2
+	or	%g2, %lo(8 * _gloffset_Fogiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Fogiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFrontFace
+.type glFrontFace,#function
+glFrontFace:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FrontFace), %g2
+	or	%g2, %lo(8 * _gloffset_FrontFace), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FrontFace)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glHint
+.type glHint,#function
+glHint:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Hint), %g2
+	or	%g2, %lo(8 * _gloffset_Hint), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Hint)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightf
+.type glLightf,#function
+glLightf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Lightf), %g2
+	or	%g2, %lo(8 * _gloffset_Lightf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Lightf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightfv
+.type glLightfv,#function
+glLightfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Lightfv), %g2
+	or	%g2, %lo(8 * _gloffset_Lightfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Lightfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLighti
+.type glLighti,#function
+glLighti:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Lighti), %g2
+	or	%g2, %lo(8 * _gloffset_Lighti), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Lighti)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightiv
+.type glLightiv,#function
+glLightiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Lightiv), %g2
+	or	%g2, %lo(8 * _gloffset_Lightiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Lightiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightModelf
+.type glLightModelf,#function
+glLightModelf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LightModelf), %g2
+	or	%g2, %lo(8 * _gloffset_LightModelf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LightModelf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightModelfv
+.type glLightModelfv,#function
+glLightModelfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LightModelfv), %g2
+	or	%g2, %lo(8 * _gloffset_LightModelfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LightModelfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightModeli
+.type glLightModeli,#function
+glLightModeli:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LightModeli), %g2
+	or	%g2, %lo(8 * _gloffset_LightModeli), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LightModeli)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightModeliv
+.type glLightModeliv,#function
+glLightModeliv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LightModeliv), %g2
+	or	%g2, %lo(8 * _gloffset_LightModeliv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LightModeliv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLineStipple
+.type glLineStipple,#function
+glLineStipple:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LineStipple), %g2
+	or	%g2, %lo(8 * _gloffset_LineStipple), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LineStipple)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLineWidth
+.type glLineWidth,#function
+glLineWidth:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LineWidth), %g2
+	or	%g2, %lo(8 * _gloffset_LineWidth), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LineWidth)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMaterialf
+.type glMaterialf,#function
+glMaterialf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Materialf), %g2
+	or	%g2, %lo(8 * _gloffset_Materialf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Materialf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMaterialfv
+.type glMaterialfv,#function
+glMaterialfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Materialfv), %g2
+	or	%g2, %lo(8 * _gloffset_Materialfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Materialfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMateriali
+.type glMateriali,#function
+glMateriali:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Materiali), %g2
+	or	%g2, %lo(8 * _gloffset_Materiali), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Materiali)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMaterialiv
+.type glMaterialiv,#function
+glMaterialiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Materialiv), %g2
+	or	%g2, %lo(8 * _gloffset_Materialiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Materialiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPointSize
+.type glPointSize,#function
+glPointSize:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PointSize), %g2
+	or	%g2, %lo(8 * _gloffset_PointSize), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PointSize)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPolygonMode
+.type glPolygonMode,#function
+glPolygonMode:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PolygonMode), %g2
+	or	%g2, %lo(8 * _gloffset_PolygonMode), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PolygonMode)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPolygonStipple
+.type glPolygonStipple,#function
+glPolygonStipple:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PolygonStipple), %g2
+	or	%g2, %lo(8 * _gloffset_PolygonStipple), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PolygonStipple)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glScissor
+.type glScissor,#function
+glScissor:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Scissor), %g2
+	or	%g2, %lo(8 * _gloffset_Scissor), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Scissor)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glShadeModel
+.type glShadeModel,#function
+glShadeModel:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ShadeModel), %g2
+	or	%g2, %lo(8 * _gloffset_ShadeModel), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ShadeModel)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexParameterf
+.type glTexParameterf,#function
+glTexParameterf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexParameterf), %g2
+	or	%g2, %lo(8 * _gloffset_TexParameterf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexParameterf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexParameterfv
+.type glTexParameterfv,#function
+glTexParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_TexParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexParameteri
+.type glTexParameteri,#function
+glTexParameteri:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexParameteri), %g2
+	or	%g2, %lo(8 * _gloffset_TexParameteri), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexParameteri)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexParameteriv
+.type glTexParameteriv,#function
+glTexParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_TexParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexImage1D
+.type glTexImage1D,#function
+glTexImage1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexImage1D), %g2
+	or	%g2, %lo(8 * _gloffset_TexImage1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexImage1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexImage2D
+.type glTexImage2D,#function
+glTexImage2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexImage2D), %g2
+	or	%g2, %lo(8 * _gloffset_TexImage2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexImage2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexEnvf
+.type glTexEnvf,#function
+glTexEnvf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexEnvf), %g2
+	or	%g2, %lo(8 * _gloffset_TexEnvf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexEnvf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexEnvfv
+.type glTexEnvfv,#function
+glTexEnvfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexEnvfv), %g2
+	or	%g2, %lo(8 * _gloffset_TexEnvfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexEnvfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexEnvi
+.type glTexEnvi,#function
+glTexEnvi:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexEnvi), %g2
+	or	%g2, %lo(8 * _gloffset_TexEnvi), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexEnvi)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexEnviv
+.type glTexEnviv,#function
+glTexEnviv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexEnviv), %g2
+	or	%g2, %lo(8 * _gloffset_TexEnviv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexEnviv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexGend
+.type glTexGend,#function
+glTexGend:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexGend), %g2
+	or	%g2, %lo(8 * _gloffset_TexGend), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexGend)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexGendv
+.type glTexGendv,#function
+glTexGendv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexGendv), %g2
+	or	%g2, %lo(8 * _gloffset_TexGendv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexGendv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexGenf
+.type glTexGenf,#function
+glTexGenf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexGenf), %g2
+	or	%g2, %lo(8 * _gloffset_TexGenf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexGenf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexGenfv
+.type glTexGenfv,#function
+glTexGenfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexGenfv), %g2
+	or	%g2, %lo(8 * _gloffset_TexGenfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexGenfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexGeni
+.type glTexGeni,#function
+glTexGeni:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexGeni), %g2
+	or	%g2, %lo(8 * _gloffset_TexGeni), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexGeni)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexGeniv
+.type glTexGeniv,#function
+glTexGeniv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexGeniv), %g2
+	or	%g2, %lo(8 * _gloffset_TexGeniv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexGeniv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFeedbackBuffer
+.type glFeedbackBuffer,#function
+glFeedbackBuffer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FeedbackBuffer), %g2
+	or	%g2, %lo(8 * _gloffset_FeedbackBuffer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FeedbackBuffer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSelectBuffer
+.type glSelectBuffer,#function
+glSelectBuffer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SelectBuffer), %g2
+	or	%g2, %lo(8 * _gloffset_SelectBuffer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SelectBuffer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRenderMode
+.type glRenderMode,#function
+glRenderMode:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_RenderMode), %g2
+	or	%g2, %lo(8 * _gloffset_RenderMode), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_RenderMode)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glInitNames
+.type glInitNames,#function
+glInitNames:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_InitNames), %g2
+	or	%g2, %lo(8 * _gloffset_InitNames), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_InitNames)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadName
+.type glLoadName,#function
+glLoadName:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadName), %g2
+	or	%g2, %lo(8 * _gloffset_LoadName), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadName)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPassThrough
+.type glPassThrough,#function
+glPassThrough:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PassThrough), %g2
+	or	%g2, %lo(8 * _gloffset_PassThrough), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PassThrough)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPopName
+.type glPopName,#function
+glPopName:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PopName), %g2
+	or	%g2, %lo(8 * _gloffset_PopName), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PopName)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPushName
+.type glPushName,#function
+glPushName:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PushName), %g2
+	or	%g2, %lo(8 * _gloffset_PushName), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PushName)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDrawBuffer
+.type glDrawBuffer,#function
+glDrawBuffer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DrawBuffer), %g2
+	or	%g2, %lo(8 * _gloffset_DrawBuffer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DrawBuffer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClear
+.type glClear,#function
+glClear:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Clear), %g2
+	or	%g2, %lo(8 * _gloffset_Clear), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Clear)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClearAccum
+.type glClearAccum,#function
+glClearAccum:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClearAccum), %g2
+	or	%g2, %lo(8 * _gloffset_ClearAccum), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClearAccum)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClearIndex
+.type glClearIndex,#function
+glClearIndex:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClearIndex), %g2
+	or	%g2, %lo(8 * _gloffset_ClearIndex), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClearIndex)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClearColor
+.type glClearColor,#function
+glClearColor:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClearColor), %g2
+	or	%g2, %lo(8 * _gloffset_ClearColor), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClearColor)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClearStencil
+.type glClearStencil,#function
+glClearStencil:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClearStencil), %g2
+	or	%g2, %lo(8 * _gloffset_ClearStencil), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClearStencil)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClearDepth
+.type glClearDepth,#function
+glClearDepth:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClearDepth), %g2
+	or	%g2, %lo(8 * _gloffset_ClearDepth), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClearDepth)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glStencilMask
+.type glStencilMask,#function
+glStencilMask:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_StencilMask), %g2
+	or	%g2, %lo(8 * _gloffset_StencilMask), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_StencilMask)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorMask
+.type glColorMask,#function
+glColorMask:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorMask), %g2
+	or	%g2, %lo(8 * _gloffset_ColorMask), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorMask)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDepthMask
+.type glDepthMask,#function
+glDepthMask:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DepthMask), %g2
+	or	%g2, %lo(8 * _gloffset_DepthMask), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DepthMask)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexMask
+.type glIndexMask,#function
+glIndexMask:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IndexMask), %g2
+	or	%g2, %lo(8 * _gloffset_IndexMask), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IndexMask)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glAccum
+.type glAccum,#function
+glAccum:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Accum), %g2
+	or	%g2, %lo(8 * _gloffset_Accum), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Accum)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDisable
+.type glDisable,#function
+glDisable:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Disable), %g2
+	or	%g2, %lo(8 * _gloffset_Disable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Disable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEnable
+.type glEnable,#function
+glEnable:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Enable), %g2
+	or	%g2, %lo(8 * _gloffset_Enable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Enable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFinish
+.type glFinish,#function
+glFinish:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Finish), %g2
+	or	%g2, %lo(8 * _gloffset_Finish), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Finish)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFlush
+.type glFlush,#function
+glFlush:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Flush), %g2
+	or	%g2, %lo(8 * _gloffset_Flush), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Flush)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPopAttrib
+.type glPopAttrib,#function
+glPopAttrib:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PopAttrib), %g2
+	or	%g2, %lo(8 * _gloffset_PopAttrib), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PopAttrib)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPushAttrib
+.type glPushAttrib,#function
+glPushAttrib:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PushAttrib), %g2
+	or	%g2, %lo(8 * _gloffset_PushAttrib), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PushAttrib)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMap1d
+.type glMap1d,#function
+glMap1d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Map1d), %g2
+	or	%g2, %lo(8 * _gloffset_Map1d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Map1d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMap1f
+.type glMap1f,#function
+glMap1f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Map1f), %g2
+	or	%g2, %lo(8 * _gloffset_Map1f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Map1f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMap2d
+.type glMap2d,#function
+glMap2d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Map2d), %g2
+	or	%g2, %lo(8 * _gloffset_Map2d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Map2d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMap2f
+.type glMap2f,#function
+glMap2f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Map2f), %g2
+	or	%g2, %lo(8 * _gloffset_Map2f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Map2f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMapGrid1d
+.type glMapGrid1d,#function
+glMapGrid1d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MapGrid1d), %g2
+	or	%g2, %lo(8 * _gloffset_MapGrid1d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MapGrid1d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMapGrid1f
+.type glMapGrid1f,#function
+glMapGrid1f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MapGrid1f), %g2
+	or	%g2, %lo(8 * _gloffset_MapGrid1f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MapGrid1f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMapGrid2d
+.type glMapGrid2d,#function
+glMapGrid2d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MapGrid2d), %g2
+	or	%g2, %lo(8 * _gloffset_MapGrid2d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MapGrid2d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMapGrid2f
+.type glMapGrid2f,#function
+glMapGrid2f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MapGrid2f), %g2
+	or	%g2, %lo(8 * _gloffset_MapGrid2f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MapGrid2f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord1d
+.type glEvalCoord1d,#function
+glEvalCoord1d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord1d), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord1d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord1d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord1dv
+.type glEvalCoord1dv,#function
+glEvalCoord1dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord1dv), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord1dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord1dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord1f
+.type glEvalCoord1f,#function
+glEvalCoord1f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord1f), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord1f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord1f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord1fv
+.type glEvalCoord1fv,#function
+glEvalCoord1fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord1fv), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord1fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord1fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord2d
+.type glEvalCoord2d,#function
+glEvalCoord2d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord2d), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord2d), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord2d)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord2dv
+.type glEvalCoord2dv,#function
+glEvalCoord2dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord2dv), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord2dv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord2dv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord2f
+.type glEvalCoord2f,#function
+glEvalCoord2f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord2f), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord2f), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord2f)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalCoord2fv
+.type glEvalCoord2fv,#function
+glEvalCoord2fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalCoord2fv), %g2
+	or	%g2, %lo(8 * _gloffset_EvalCoord2fv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalCoord2fv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalMesh1
+.type glEvalMesh1,#function
+glEvalMesh1:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalMesh1), %g2
+	or	%g2, %lo(8 * _gloffset_EvalMesh1), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalMesh1)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalPoint1
+.type glEvalPoint1,#function
+glEvalPoint1:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalPoint1), %g2
+	or	%g2, %lo(8 * _gloffset_EvalPoint1), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalPoint1)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalMesh2
+.type glEvalMesh2,#function
+glEvalMesh2:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalMesh2), %g2
+	or	%g2, %lo(8 * _gloffset_EvalMesh2), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalMesh2)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEvalPoint2
+.type glEvalPoint2,#function
+glEvalPoint2:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EvalPoint2), %g2
+	or	%g2, %lo(8 * _gloffset_EvalPoint2), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EvalPoint2)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glAlphaFunc
+.type glAlphaFunc,#function
+glAlphaFunc:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_AlphaFunc), %g2
+	or	%g2, %lo(8 * _gloffset_AlphaFunc), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_AlphaFunc)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBlendFunc
+.type glBlendFunc,#function
+glBlendFunc:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BlendFunc), %g2
+	or	%g2, %lo(8 * _gloffset_BlendFunc), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BlendFunc)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLogicOp
+.type glLogicOp,#function
+glLogicOp:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LogicOp), %g2
+	or	%g2, %lo(8 * _gloffset_LogicOp), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LogicOp)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glStencilFunc
+.type glStencilFunc,#function
+glStencilFunc:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_StencilFunc), %g2
+	or	%g2, %lo(8 * _gloffset_StencilFunc), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_StencilFunc)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glStencilOp
+.type glStencilOp,#function
+glStencilOp:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_StencilOp), %g2
+	or	%g2, %lo(8 * _gloffset_StencilOp), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_StencilOp)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDepthFunc
+.type glDepthFunc,#function
+glDepthFunc:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DepthFunc), %g2
+	or	%g2, %lo(8 * _gloffset_DepthFunc), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DepthFunc)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelZoom
+.type glPixelZoom,#function
+glPixelZoom:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelZoom), %g2
+	or	%g2, %lo(8 * _gloffset_PixelZoom), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelZoom)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelTransferf
+.type glPixelTransferf,#function
+glPixelTransferf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelTransferf), %g2
+	or	%g2, %lo(8 * _gloffset_PixelTransferf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelTransferf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelTransferi
+.type glPixelTransferi,#function
+glPixelTransferi:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelTransferi), %g2
+	or	%g2, %lo(8 * _gloffset_PixelTransferi), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelTransferi)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelStoref
+.type glPixelStoref,#function
+glPixelStoref:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelStoref), %g2
+	or	%g2, %lo(8 * _gloffset_PixelStoref), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelStoref)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelStorei
+.type glPixelStorei,#function
+glPixelStorei:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelStorei), %g2
+	or	%g2, %lo(8 * _gloffset_PixelStorei), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelStorei)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelMapfv
+.type glPixelMapfv,#function
+glPixelMapfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelMapfv), %g2
+	or	%g2, %lo(8 * _gloffset_PixelMapfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelMapfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelMapuiv
+.type glPixelMapuiv,#function
+glPixelMapuiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelMapuiv), %g2
+	or	%g2, %lo(8 * _gloffset_PixelMapuiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelMapuiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelMapusv
+.type glPixelMapusv,#function
+glPixelMapusv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelMapusv), %g2
+	or	%g2, %lo(8 * _gloffset_PixelMapusv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelMapusv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glReadBuffer
+.type glReadBuffer,#function
+glReadBuffer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ReadBuffer), %g2
+	or	%g2, %lo(8 * _gloffset_ReadBuffer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ReadBuffer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyPixels
+.type glCopyPixels,#function
+glCopyPixels:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyPixels), %g2
+	or	%g2, %lo(8 * _gloffset_CopyPixels), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyPixels)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glReadPixels
+.type glReadPixels,#function
+glReadPixels:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ReadPixels), %g2
+	or	%g2, %lo(8 * _gloffset_ReadPixels), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ReadPixels)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDrawPixels
+.type glDrawPixels,#function
+glDrawPixels:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DrawPixels), %g2
+	or	%g2, %lo(8 * _gloffset_DrawPixels), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DrawPixels)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetBooleanv
+.type glGetBooleanv,#function
+glGetBooleanv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetBooleanv), %g2
+	or	%g2, %lo(8 * _gloffset_GetBooleanv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetBooleanv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetClipPlane
+.type glGetClipPlane,#function
+glGetClipPlane:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetClipPlane), %g2
+	or	%g2, %lo(8 * _gloffset_GetClipPlane), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetClipPlane)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetDoublev
+.type glGetDoublev,#function
+glGetDoublev:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetDoublev), %g2
+	or	%g2, %lo(8 * _gloffset_GetDoublev), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetDoublev)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetError
+.type glGetError,#function
+glGetError:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetError), %g2
+	or	%g2, %lo(8 * _gloffset_GetError), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetError)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetFloatv
+.type glGetFloatv,#function
+glGetFloatv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetFloatv), %g2
+	or	%g2, %lo(8 * _gloffset_GetFloatv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetFloatv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetIntegerv
+.type glGetIntegerv,#function
+glGetIntegerv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetIntegerv), %g2
+	or	%g2, %lo(8 * _gloffset_GetIntegerv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetIntegerv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetLightfv
+.type glGetLightfv,#function
+glGetLightfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetLightfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetLightfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetLightfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetLightiv
+.type glGetLightiv,#function
+glGetLightiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetLightiv), %g2
+	or	%g2, %lo(8 * _gloffset_GetLightiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetLightiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMapdv
+.type glGetMapdv,#function
+glGetMapdv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMapdv), %g2
+	or	%g2, %lo(8 * _gloffset_GetMapdv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMapdv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMapfv
+.type glGetMapfv,#function
+glGetMapfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMapfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetMapfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMapfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMapiv
+.type glGetMapiv,#function
+glGetMapiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMapiv), %g2
+	or	%g2, %lo(8 * _gloffset_GetMapiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMapiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMaterialfv
+.type glGetMaterialfv,#function
+glGetMaterialfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMaterialfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetMaterialfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMaterialfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMaterialiv
+.type glGetMaterialiv,#function
+glGetMaterialiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMaterialiv), %g2
+	or	%g2, %lo(8 * _gloffset_GetMaterialiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMaterialiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPixelMapfv
+.type glGetPixelMapfv,#function
+glGetPixelMapfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPixelMapfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetPixelMapfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPixelMapfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPixelMapuiv
+.type glGetPixelMapuiv,#function
+glGetPixelMapuiv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPixelMapuiv), %g2
+	or	%g2, %lo(8 * _gloffset_GetPixelMapuiv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPixelMapuiv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPixelMapusv
+.type glGetPixelMapusv,#function
+glGetPixelMapusv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPixelMapusv), %g2
+	or	%g2, %lo(8 * _gloffset_GetPixelMapusv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPixelMapusv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPolygonStipple
+.type glGetPolygonStipple,#function
+glGetPolygonStipple:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPolygonStipple), %g2
+	or	%g2, %lo(8 * _gloffset_GetPolygonStipple), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPolygonStipple)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetString
+.type glGetString,#function
+glGetString:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetString), %g2
+	or	%g2, %lo(8 * _gloffset_GetString), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetString)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexEnvfv
+.type glGetTexEnvfv,#function
+glGetTexEnvfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexEnvfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexEnvfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexEnvfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexEnviv
+.type glGetTexEnviv,#function
+glGetTexEnviv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexEnviv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexEnviv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexEnviv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexGendv
+.type glGetTexGendv,#function
+glGetTexGendv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexGendv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexGendv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexGendv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexGenfv
+.type glGetTexGenfv,#function
+glGetTexGenfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexGenfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexGenfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexGenfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexGeniv
+.type glGetTexGeniv,#function
+glGetTexGeniv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexGeniv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexGeniv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexGeniv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexImage
+.type glGetTexImage,#function
+glGetTexImage:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexImage), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexImage), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexImage)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexParameterfv
+.type glGetTexParameterfv,#function
+glGetTexParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexParameteriv
+.type glGetTexParameteriv,#function
+glGetTexParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexLevelParameterfv
+.type glGetTexLevelParameterfv,#function
+glGetTexLevelParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexLevelParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexLevelParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexLevelParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexLevelParameteriv
+.type glGetTexLevelParameteriv,#function
+glGetTexLevelParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexLevelParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexLevelParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexLevelParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIsEnabled
+.type glIsEnabled,#function
+glIsEnabled:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IsEnabled), %g2
+	or	%g2, %lo(8 * _gloffset_IsEnabled), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IsEnabled)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIsList
+.type glIsList,#function
+glIsList:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IsList), %g2
+	or	%g2, %lo(8 * _gloffset_IsList), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IsList)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDepthRange
+.type glDepthRange,#function
+glDepthRange:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DepthRange), %g2
+	or	%g2, %lo(8 * _gloffset_DepthRange), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DepthRange)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFrustum
+.type glFrustum,#function
+glFrustum:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Frustum), %g2
+	or	%g2, %lo(8 * _gloffset_Frustum), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Frustum)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadIdentity
+.type glLoadIdentity,#function
+glLoadIdentity:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadIdentity), %g2
+	or	%g2, %lo(8 * _gloffset_LoadIdentity), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadIdentity)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadMatrixf
+.type glLoadMatrixf,#function
+glLoadMatrixf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadMatrixf), %g2
+	or	%g2, %lo(8 * _gloffset_LoadMatrixf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadMatrixf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadMatrixd
+.type glLoadMatrixd,#function
+glLoadMatrixd:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadMatrixd), %g2
+	or	%g2, %lo(8 * _gloffset_LoadMatrixd), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadMatrixd)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMatrixMode
+.type glMatrixMode,#function
+glMatrixMode:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MatrixMode), %g2
+	or	%g2, %lo(8 * _gloffset_MatrixMode), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MatrixMode)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultMatrixf
+.type glMultMatrixf,#function
+glMultMatrixf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultMatrixf), %g2
+	or	%g2, %lo(8 * _gloffset_MultMatrixf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultMatrixf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultMatrixd
+.type glMultMatrixd,#function
+glMultMatrixd:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultMatrixd), %g2
+	or	%g2, %lo(8 * _gloffset_MultMatrixd), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultMatrixd)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glOrtho
+.type glOrtho,#function
+glOrtho:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Ortho), %g2
+	or	%g2, %lo(8 * _gloffset_Ortho), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Ortho)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPopMatrix
+.type glPopMatrix,#function
+glPopMatrix:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PopMatrix), %g2
+	or	%g2, %lo(8 * _gloffset_PopMatrix), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PopMatrix)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPushMatrix
+.type glPushMatrix,#function
+glPushMatrix:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PushMatrix), %g2
+	or	%g2, %lo(8 * _gloffset_PushMatrix), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PushMatrix)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRotated
+.type glRotated,#function
+glRotated:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rotated), %g2
+	or	%g2, %lo(8 * _gloffset_Rotated), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rotated)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glRotatef
+.type glRotatef,#function
+glRotatef:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Rotatef), %g2
+	or	%g2, %lo(8 * _gloffset_Rotatef), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Rotatef)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glScaled
+.type glScaled,#function
+glScaled:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Scaled), %g2
+	or	%g2, %lo(8 * _gloffset_Scaled), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Scaled)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glScalef
+.type glScalef,#function
+glScalef:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Scalef), %g2
+	or	%g2, %lo(8 * _gloffset_Scalef), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Scalef)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTranslated
+.type glTranslated,#function
+glTranslated:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Translated), %g2
+	or	%g2, %lo(8 * _gloffset_Translated), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Translated)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTranslatef
+.type glTranslatef,#function
+glTranslatef:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Translatef), %g2
+	or	%g2, %lo(8 * _gloffset_Translatef), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Translatef)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glViewport
+.type glViewport,#function
+glViewport:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Viewport), %g2
+	or	%g2, %lo(8 * _gloffset_Viewport), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Viewport)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glArrayElement
+.type glArrayElement,#function
+glArrayElement:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ArrayElement), %g2
+	or	%g2, %lo(8 * _gloffset_ArrayElement), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ArrayElement)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorPointer
+.type glColorPointer,#function
+glColorPointer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorPointer), %g2
+	or	%g2, %lo(8 * _gloffset_ColorPointer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorPointer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDisableClientState
+.type glDisableClientState,#function
+glDisableClientState:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DisableClientState), %g2
+	or	%g2, %lo(8 * _gloffset_DisableClientState), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DisableClientState)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDrawArrays
+.type glDrawArrays,#function
+glDrawArrays:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DrawArrays), %g2
+	or	%g2, %lo(8 * _gloffset_DrawArrays), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DrawArrays)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDrawElements
+.type glDrawElements,#function
+glDrawElements:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DrawElements), %g2
+	or	%g2, %lo(8 * _gloffset_DrawElements), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DrawElements)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEdgeFlagPointer
+.type glEdgeFlagPointer,#function
+glEdgeFlagPointer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EdgeFlagPointer), %g2
+	or	%g2, %lo(8 * _gloffset_EdgeFlagPointer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EdgeFlagPointer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEnableClientState
+.type glEnableClientState,#function
+glEnableClientState:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EnableClientState), %g2
+	or	%g2, %lo(8 * _gloffset_EnableClientState), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EnableClientState)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPointerv
+.type glGetPointerv,#function
+glGetPointerv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPointerv), %g2
+	or	%g2, %lo(8 * _gloffset_GetPointerv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPointerv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexPointer
+.type glIndexPointer,#function
+glIndexPointer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IndexPointer), %g2
+	or	%g2, %lo(8 * _gloffset_IndexPointer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IndexPointer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glInterleavedArrays
+.type glInterleavedArrays,#function
+glInterleavedArrays:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_InterleavedArrays), %g2
+	or	%g2, %lo(8 * _gloffset_InterleavedArrays), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_InterleavedArrays)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormalPointer
+.type glNormalPointer,#function
+glNormalPointer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_NormalPointer), %g2
+	or	%g2, %lo(8 * _gloffset_NormalPointer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_NormalPointer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoordPointer
+.type glTexCoordPointer,#function
+glTexCoordPointer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoordPointer), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoordPointer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoordPointer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertexPointer
+.type glVertexPointer,#function
+glVertexPointer:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexPointer), %g2
+	or	%g2, %lo(8 * _gloffset_VertexPointer), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexPointer)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPolygonOffset
+.type glPolygonOffset,#function
+glPolygonOffset:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PolygonOffset), %g2
+	or	%g2, %lo(8 * _gloffset_PolygonOffset), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PolygonOffset)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexImage1D
+.type glCopyTexImage1D,#function
+glCopyTexImage1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexImage1D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexImage1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexImage1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexImage2D
+.type glCopyTexImage2D,#function
+glCopyTexImage2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexImage2D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexImage2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexImage2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexSubImage1D
+.type glCopyTexSubImage1D,#function
+glCopyTexSubImage1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexSubImage1D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexSubImage1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexSubImage1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexSubImage2D
+.type glCopyTexSubImage2D,#function
+glCopyTexSubImage2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexSubImage2D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexSubImage2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexSubImage2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexSubImage1D
+.type glTexSubImage1D,#function
+glTexSubImage1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexSubImage1D), %g2
+	or	%g2, %lo(8 * _gloffset_TexSubImage1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexSubImage1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexSubImage2D
+.type glTexSubImage2D,#function
+glTexSubImage2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexSubImage2D), %g2
+	or	%g2, %lo(8 * _gloffset_TexSubImage2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexSubImage2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glAreTexturesResident
+.type glAreTexturesResident,#function
+glAreTexturesResident:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_AreTexturesResident), %g2
+	or	%g2, %lo(8 * _gloffset_AreTexturesResident), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_AreTexturesResident)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBindTexture
+.type glBindTexture,#function
+glBindTexture:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BindTexture), %g2
+	or	%g2, %lo(8 * _gloffset_BindTexture), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BindTexture)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDeleteTextures
+.type glDeleteTextures,#function
+glDeleteTextures:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DeleteTextures), %g2
+	or	%g2, %lo(8 * _gloffset_DeleteTextures), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DeleteTextures)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGenTextures
+.type glGenTextures,#function
+glGenTextures:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GenTextures), %g2
+	or	%g2, %lo(8 * _gloffset_GenTextures), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GenTextures)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIsTexture
+.type glIsTexture,#function
+glIsTexture:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IsTexture), %g2
+	or	%g2, %lo(8 * _gloffset_IsTexture), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IsTexture)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPrioritizeTextures
+.type glPrioritizeTextures,#function
+glPrioritizeTextures:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PrioritizeTextures), %g2
+	or	%g2, %lo(8 * _gloffset_PrioritizeTextures), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PrioritizeTextures)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexub
+.type glIndexub,#function
+glIndexub:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexub), %g2
+	or	%g2, %lo(8 * _gloffset_Indexub), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexub)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexubv
+.type glIndexubv,#function
+glIndexubv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Indexubv), %g2
+	or	%g2, %lo(8 * _gloffset_Indexubv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Indexubv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPopClientAttrib
+.type glPopClientAttrib,#function
+glPopClientAttrib:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PopClientAttrib), %g2
+	or	%g2, %lo(8 * _gloffset_PopClientAttrib), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PopClientAttrib)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPushClientAttrib
+.type glPushClientAttrib,#function
+glPushClientAttrib:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PushClientAttrib), %g2
+	or	%g2, %lo(8 * _gloffset_PushClientAttrib), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PushClientAttrib)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBlendColor
+.type glBlendColor,#function
+glBlendColor:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BlendColor), %g2
+	or	%g2, %lo(8 * _gloffset_BlendColor), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BlendColor)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBlendEquation
+.type glBlendEquation,#function
+glBlendEquation:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BlendEquation), %g2
+	or	%g2, %lo(8 * _gloffset_BlendEquation), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BlendEquation)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDrawRangeElements
+.type glDrawRangeElements,#function
+glDrawRangeElements:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DrawRangeElements), %g2
+	or	%g2, %lo(8 * _gloffset_DrawRangeElements), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DrawRangeElements)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorTable
+.type glColorTable,#function
+glColorTable:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorTable), %g2
+	or	%g2, %lo(8 * _gloffset_ColorTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorTableParameterfv
+.type glColorTableParameterfv,#function
+glColorTableParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorTableParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_ColorTableParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorTableParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorTableParameteriv
+.type glColorTableParameteriv,#function
+glColorTableParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorTableParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_ColorTableParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorTableParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyColorTable
+.type glCopyColorTable,#function
+glCopyColorTable:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyColorTable), %g2
+	or	%g2, %lo(8 * _gloffset_CopyColorTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyColorTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTable
+.type glGetColorTable,#function
+glGetColorTable:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTable), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableParameterfv
+.type glGetColorTableParameterfv,#function
+glGetColorTableParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableParameteriv
+.type glGetColorTableParameteriv,#function
+glGetColorTableParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorSubTable
+.type glColorSubTable,#function
+glColorSubTable:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorSubTable), %g2
+	or	%g2, %lo(8 * _gloffset_ColorSubTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorSubTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyColorSubTable
+.type glCopyColorSubTable,#function
+glCopyColorSubTable:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyColorSubTable), %g2
+	or	%g2, %lo(8 * _gloffset_CopyColorSubTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyColorSubTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionFilter1D
+.type glConvolutionFilter1D,#function
+glConvolutionFilter1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionFilter1D), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionFilter1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionFilter1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionFilter2D
+.type glConvolutionFilter2D,#function
+glConvolutionFilter2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionFilter2D), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionFilter2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionFilter2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameterf
+.type glConvolutionParameterf,#function
+glConvolutionParameterf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameterf), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameterf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameterf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameterfv
+.type glConvolutionParameterfv,#function
+glConvolutionParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameteri
+.type glConvolutionParameteri,#function
+glConvolutionParameteri:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameteri), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameteri), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameteri)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameteriv
+.type glConvolutionParameteriv,#function
+glConvolutionParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyConvolutionFilter1D
+.type glCopyConvolutionFilter1D,#function
+glCopyConvolutionFilter1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyConvolutionFilter1D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyConvolutionFilter1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyConvolutionFilter1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyConvolutionFilter2D
+.type glCopyConvolutionFilter2D,#function
+glCopyConvolutionFilter2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyConvolutionFilter2D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyConvolutionFilter2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyConvolutionFilter2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetConvolutionFilter
+.type glGetConvolutionFilter,#function
+glGetConvolutionFilter:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetConvolutionFilter), %g2
+	or	%g2, %lo(8 * _gloffset_GetConvolutionFilter), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetConvolutionFilter)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetConvolutionParameterfv
+.type glGetConvolutionParameterfv,#function
+glGetConvolutionParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetConvolutionParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetConvolutionParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetConvolutionParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetConvolutionParameteriv
+.type glGetConvolutionParameteriv,#function
+glGetConvolutionParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetConvolutionParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_GetConvolutionParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetConvolutionParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetSeparableFilter
+.type glGetSeparableFilter,#function
+glGetSeparableFilter:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetSeparableFilter), %g2
+	or	%g2, %lo(8 * _gloffset_GetSeparableFilter), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetSeparableFilter)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSeparableFilter2D
+.type glSeparableFilter2D,#function
+glSeparableFilter2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SeparableFilter2D), %g2
+	or	%g2, %lo(8 * _gloffset_SeparableFilter2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SeparableFilter2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetHistogram
+.type glGetHistogram,#function
+glGetHistogram:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetHistogram), %g2
+	or	%g2, %lo(8 * _gloffset_GetHistogram), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetHistogram)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetHistogramParameterfv
+.type glGetHistogramParameterfv,#function
+glGetHistogramParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetHistogramParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetHistogramParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetHistogramParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetHistogramParameteriv
+.type glGetHistogramParameteriv,#function
+glGetHistogramParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetHistogramParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_GetHistogramParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetHistogramParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMinmax
+.type glGetMinmax,#function
+glGetMinmax:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMinmax), %g2
+	or	%g2, %lo(8 * _gloffset_GetMinmax), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMinmax)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMinmaxParameterfv
+.type glGetMinmaxParameterfv,#function
+glGetMinmaxParameterfv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMinmaxParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_GetMinmaxParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMinmaxParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMinmaxParameteriv
+.type glGetMinmaxParameteriv,#function
+glGetMinmaxParameteriv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMinmaxParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_GetMinmaxParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMinmaxParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glHistogram
+.type glHistogram,#function
+glHistogram:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Histogram), %g2
+	or	%g2, %lo(8 * _gloffset_Histogram), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Histogram)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMinmax
+.type glMinmax,#function
+glMinmax:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Minmax), %g2
+	or	%g2, %lo(8 * _gloffset_Minmax), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Minmax)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glResetHistogram
+.type glResetHistogram,#function
+glResetHistogram:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ResetHistogram), %g2
+	or	%g2, %lo(8 * _gloffset_ResetHistogram), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ResetHistogram)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glResetMinmax
+.type glResetMinmax,#function
+glResetMinmax:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ResetMinmax), %g2
+	or	%g2, %lo(8 * _gloffset_ResetMinmax), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ResetMinmax)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexImage3D
+.type glTexImage3D,#function
+glTexImage3D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexImage3D), %g2
+	or	%g2, %lo(8 * _gloffset_TexImage3D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexImage3D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexSubImage3D
+.type glTexSubImage3D,#function
+glTexSubImage3D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexSubImage3D), %g2
+	or	%g2, %lo(8 * _gloffset_TexSubImage3D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexSubImage3D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexSubImage3D
+.type glCopyTexSubImage3D,#function
+glCopyTexSubImage3D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexSubImage3D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexSubImage3D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexSubImage3D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glActiveTextureARB
+.type glActiveTextureARB,#function
+glActiveTextureARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ActiveTextureARB), %g2
+	or	%g2, %lo(8 * _gloffset_ActiveTextureARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ActiveTextureARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClientActiveTextureARB
+.type glClientActiveTextureARB,#function
+glClientActiveTextureARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClientActiveTextureARB), %g2
+	or	%g2, %lo(8 * _gloffset_ClientActiveTextureARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClientActiveTextureARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1dARB
+.type glMultiTexCoord1dARB,#function
+glMultiTexCoord1dARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1dvARB
+.type glMultiTexCoord1dvARB,#function
+glMultiTexCoord1dvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1fARB
+.type glMultiTexCoord1fARB,#function
+glMultiTexCoord1fARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1fvARB
+.type glMultiTexCoord1fvARB,#function
+glMultiTexCoord1fvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1iARB
+.type glMultiTexCoord1iARB,#function
+glMultiTexCoord1iARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1ivARB
+.type glMultiTexCoord1ivARB,#function
+glMultiTexCoord1ivARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1sARB
+.type glMultiTexCoord1sARB,#function
+glMultiTexCoord1sARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1svARB
+.type glMultiTexCoord1svARB,#function
+glMultiTexCoord1svARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2dARB
+.type glMultiTexCoord2dARB,#function
+glMultiTexCoord2dARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2dvARB
+.type glMultiTexCoord2dvARB,#function
+glMultiTexCoord2dvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2fARB
+.type glMultiTexCoord2fARB,#function
+glMultiTexCoord2fARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2fvARB
+.type glMultiTexCoord2fvARB,#function
+glMultiTexCoord2fvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2iARB
+.type glMultiTexCoord2iARB,#function
+glMultiTexCoord2iARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2ivARB
+.type glMultiTexCoord2ivARB,#function
+glMultiTexCoord2ivARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2sARB
+.type glMultiTexCoord2sARB,#function
+glMultiTexCoord2sARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2svARB
+.type glMultiTexCoord2svARB,#function
+glMultiTexCoord2svARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3dARB
+.type glMultiTexCoord3dARB,#function
+glMultiTexCoord3dARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3dvARB
+.type glMultiTexCoord3dvARB,#function
+glMultiTexCoord3dvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3fARB
+.type glMultiTexCoord3fARB,#function
+glMultiTexCoord3fARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3fvARB
+.type glMultiTexCoord3fvARB,#function
+glMultiTexCoord3fvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3iARB
+.type glMultiTexCoord3iARB,#function
+glMultiTexCoord3iARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3ivARB
+.type glMultiTexCoord3ivARB,#function
+glMultiTexCoord3ivARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3sARB
+.type glMultiTexCoord3sARB,#function
+glMultiTexCoord3sARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3svARB
+.type glMultiTexCoord3svARB,#function
+glMultiTexCoord3svARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4dARB
+.type glMultiTexCoord4dARB,#function
+glMultiTexCoord4dARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4dvARB
+.type glMultiTexCoord4dvARB,#function
+glMultiTexCoord4dvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4fARB
+.type glMultiTexCoord4fARB,#function
+glMultiTexCoord4fARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4fvARB
+.type glMultiTexCoord4fvARB,#function
+glMultiTexCoord4fvARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4iARB
+.type glMultiTexCoord4iARB,#function
+glMultiTexCoord4iARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4ivARB
+.type glMultiTexCoord4ivARB,#function
+glMultiTexCoord4ivARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4sARB
+.type glMultiTexCoord4sARB,#function
+glMultiTexCoord4sARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4svARB
+.type glMultiTexCoord4svARB,#function
+glMultiTexCoord4svARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadTransposeMatrixfARB
+.type glLoadTransposeMatrixfARB,#function
+glLoadTransposeMatrixfARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadTransposeMatrixfARB), %g2
+	or	%g2, %lo(8 * _gloffset_LoadTransposeMatrixfARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadTransposeMatrixfARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadTransposeMatrixdARB
+.type glLoadTransposeMatrixdARB,#function
+glLoadTransposeMatrixdARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadTransposeMatrixdARB), %g2
+	or	%g2, %lo(8 * _gloffset_LoadTransposeMatrixdARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadTransposeMatrixdARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultTransposeMatrixfARB
+.type glMultTransposeMatrixfARB,#function
+glMultTransposeMatrixfARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultTransposeMatrixfARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultTransposeMatrixfARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultTransposeMatrixfARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultTransposeMatrixdARB
+.type glMultTransposeMatrixdARB,#function
+glMultTransposeMatrixdARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultTransposeMatrixdARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultTransposeMatrixdARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultTransposeMatrixdARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSampleCoverageARB
+.type glSampleCoverageARB,#function
+glSampleCoverageARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SampleCoverageARB), %g2
+	or	%g2, %lo(8 * _gloffset_SampleCoverageARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SampleCoverageARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexImage3DARB
+.type glCompressedTexImage3DARB,#function
+glCompressedTexImage3DARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexImage3DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexImage3DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexImage3DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexImage2DARB
+.type glCompressedTexImage2DARB,#function
+glCompressedTexImage2DARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexImage2DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexImage2DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexImage2DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexImage1DARB
+.type glCompressedTexImage1DARB,#function
+glCompressedTexImage1DARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexImage1DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexImage1DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexImage1DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexSubImage3DARB
+.type glCompressedTexSubImage3DARB,#function
+glCompressedTexSubImage3DARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexSubImage3DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexSubImage3DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexSubImage3DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexSubImage2DARB
+.type glCompressedTexSubImage2DARB,#function
+glCompressedTexSubImage2DARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexSubImage2DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexSubImage2DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexSubImage2DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexSubImage1DARB
+.type glCompressedTexSubImage1DARB,#function
+glCompressedTexSubImage1DARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexSubImage1DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexSubImage1DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexSubImage1DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetCompressedTexImageARB
+.type glGetCompressedTexImageARB,#function
+glGetCompressedTexImageARB:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetCompressedTexImageARB), %g2
+	or	%g2, %lo(8 * _gloffset_GetCompressedTexImageARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetCompressedTexImageARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBlendColorEXT
+.type glBlendColorEXT,#function
+glBlendColorEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BlendColor), %g2
+	or	%g2, %lo(8 * _gloffset_BlendColor), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BlendColor)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPolygonOffsetEXT
+.type glPolygonOffsetEXT,#function
+glPolygonOffsetEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PolygonOffsetEXT), %g2
+	or	%g2, %lo(8 * _gloffset_PolygonOffsetEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PolygonOffsetEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexImage3DEXT
+.type glTexImage3DEXT,#function
+glTexImage3DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexImage3D), %g2
+	or	%g2, %lo(8 * _gloffset_TexImage3D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexImage3D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexSubImage3DEXT
+.type glTexSubImage3DEXT,#function
+glTexSubImage3DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexSubImage3D), %g2
+	or	%g2, %lo(8 * _gloffset_TexSubImage3D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexSubImage3D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetTexFilterFuncSGIS
+.type glGetTexFilterFuncSGIS,#function
+glGetTexFilterFuncSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetTexFilterFuncSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_GetTexFilterFuncSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetTexFilterFuncSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexFilterFuncSGIS
+.type glTexFilterFuncSGIS,#function
+glTexFilterFuncSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexFilterFuncSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_TexFilterFuncSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexFilterFuncSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexSubImage1DEXT
+.type glTexSubImage1DEXT,#function
+glTexSubImage1DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexSubImage1D), %g2
+	or	%g2, %lo(8 * _gloffset_TexSubImage1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexSubImage1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexSubImage2DEXT
+.type glTexSubImage2DEXT,#function
+glTexSubImage2DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexSubImage2D), %g2
+	or	%g2, %lo(8 * _gloffset_TexSubImage2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexSubImage2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexImage1DEXT
+.type glCopyTexImage1DEXT,#function
+glCopyTexImage1DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexImage1D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexImage1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexImage1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexImage2DEXT
+.type glCopyTexImage2DEXT,#function
+glCopyTexImage2DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexImage2D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexImage2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexImage2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexSubImage1DEXT
+.type glCopyTexSubImage1DEXT,#function
+glCopyTexSubImage1DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexSubImage1D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexSubImage1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexSubImage1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexSubImage2DEXT
+.type glCopyTexSubImage2DEXT,#function
+glCopyTexSubImage2DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexSubImage2D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexSubImage2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexSubImage2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyTexSubImage3DEXT
+.type glCopyTexSubImage3DEXT,#function
+glCopyTexSubImage3DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyTexSubImage3D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyTexSubImage3D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyTexSubImage3D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetHistogramEXT
+.type glGetHistogramEXT,#function
+glGetHistogramEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetHistogramEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetHistogramEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetHistogramEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetHistogramParameterfvEXT
+.type glGetHistogramParameterfvEXT,#function
+glGetHistogramParameterfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetHistogramParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetHistogramParameterfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetHistogramParameterfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetHistogramParameterivEXT
+.type glGetHistogramParameterivEXT,#function
+glGetHistogramParameterivEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetHistogramParameterivEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetHistogramParameterivEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetHistogramParameterivEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMinmaxEXT
+.type glGetMinmaxEXT,#function
+glGetMinmaxEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMinmaxEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetMinmaxEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMinmaxEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMinmaxParameterfvEXT
+.type glGetMinmaxParameterfvEXT,#function
+glGetMinmaxParameterfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMinmaxParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetMinmaxParameterfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMinmaxParameterfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetMinmaxParameterivEXT
+.type glGetMinmaxParameterivEXT,#function
+glGetMinmaxParameterivEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetMinmaxParameterivEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetMinmaxParameterivEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetMinmaxParameterivEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glHistogramEXT
+.type glHistogramEXT,#function
+glHistogramEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Histogram), %g2
+	or	%g2, %lo(8 * _gloffset_Histogram), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Histogram)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMinmaxEXT
+.type glMinmaxEXT,#function
+glMinmaxEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_Minmax), %g2
+	or	%g2, %lo(8 * _gloffset_Minmax), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_Minmax)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glResetHistogramEXT
+.type glResetHistogramEXT,#function
+glResetHistogramEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ResetHistogram), %g2
+	or	%g2, %lo(8 * _gloffset_ResetHistogram), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ResetHistogram)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glResetMinmaxEXT
+.type glResetMinmaxEXT,#function
+glResetMinmaxEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ResetMinmax), %g2
+	or	%g2, %lo(8 * _gloffset_ResetMinmax), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ResetMinmax)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionFilter1DEXT
+.type glConvolutionFilter1DEXT,#function
+glConvolutionFilter1DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionFilter1D), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionFilter1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionFilter1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionFilter2DEXT
+.type glConvolutionFilter2DEXT,#function
+glConvolutionFilter2DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionFilter2D), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionFilter2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionFilter2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameterfEXT
+.type glConvolutionParameterfEXT,#function
+glConvolutionParameterfEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameterf), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameterf), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameterf)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameterfvEXT
+.type glConvolutionParameterfvEXT,#function
+glConvolutionParameterfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameteriEXT
+.type glConvolutionParameteriEXT,#function
+glConvolutionParameteriEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameteri), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameteri), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameteri)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glConvolutionParameterivEXT
+.type glConvolutionParameterivEXT,#function
+glConvolutionParameterivEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ConvolutionParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_ConvolutionParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ConvolutionParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyConvolutionFilter1DEXT
+.type glCopyConvolutionFilter1DEXT,#function
+glCopyConvolutionFilter1DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyConvolutionFilter1D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyConvolutionFilter1D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyConvolutionFilter1D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyConvolutionFilter2DEXT
+.type glCopyConvolutionFilter2DEXT,#function
+glCopyConvolutionFilter2DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyConvolutionFilter2D), %g2
+	or	%g2, %lo(8 * _gloffset_CopyConvolutionFilter2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyConvolutionFilter2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetConvolutionFilterEXT
+.type glGetConvolutionFilterEXT,#function
+glGetConvolutionFilterEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetConvolutionFilterEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetConvolutionFilterEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetConvolutionFilterEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetConvolutionParameterfvEXT
+.type glGetConvolutionParameterfvEXT,#function
+glGetConvolutionParameterfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetConvolutionParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetConvolutionParameterfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetConvolutionParameterfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetConvolutionParameterivEXT
+.type glGetConvolutionParameterivEXT,#function
+glGetConvolutionParameterivEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetConvolutionParameterivEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetConvolutionParameterivEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetConvolutionParameterivEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetSeparableFilterEXT
+.type glGetSeparableFilterEXT,#function
+glGetSeparableFilterEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetSeparableFilterEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetSeparableFilterEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetSeparableFilterEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSeparableFilter2DEXT
+.type glSeparableFilter2DEXT,#function
+glSeparableFilter2DEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SeparableFilter2D), %g2
+	or	%g2, %lo(8 * _gloffset_SeparableFilter2D), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SeparableFilter2D)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorTableSGI
+.type glColorTableSGI,#function
+glColorTableSGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorTable), %g2
+	or	%g2, %lo(8 * _gloffset_ColorTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorTableParameterfvSGI
+.type glColorTableParameterfvSGI,#function
+glColorTableParameterfvSGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorTableParameterfv), %g2
+	or	%g2, %lo(8 * _gloffset_ColorTableParameterfv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorTableParameterfv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorTableParameterivSGI
+.type glColorTableParameterivSGI,#function
+glColorTableParameterivSGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorTableParameteriv), %g2
+	or	%g2, %lo(8 * _gloffset_ColorTableParameteriv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorTableParameteriv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyColorTableSGI
+.type glCopyColorTableSGI,#function
+glCopyColorTableSGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyColorTable), %g2
+	or	%g2, %lo(8 * _gloffset_CopyColorTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyColorTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableSGI
+.type glGetColorTableSGI,#function
+glGetColorTableSGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableSGI), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableSGI), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableSGI)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableParameterfvSGI
+.type glGetColorTableParameterfvSGI,#function
+glGetColorTableParameterfvSGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableParameterfvSGI), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableParameterfvSGI), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableParameterfvSGI)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableParameterivSGI
+.type glGetColorTableParameterivSGI,#function
+glGetColorTableParameterivSGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableParameterivSGI), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableParameterivSGI), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableParameterivSGI)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelTexGenSGIX
+.type glPixelTexGenSGIX,#function
+glPixelTexGenSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelTexGenSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_PixelTexGenSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelTexGenSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelTexGenParameteriSGIS
+.type glPixelTexGenParameteriSGIS,#function
+glPixelTexGenParameteriSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelTexGenParameteriSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_PixelTexGenParameteriSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelTexGenParameteriSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelTexGenParameterivSGIS
+.type glPixelTexGenParameterivSGIS,#function
+glPixelTexGenParameterivSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelTexGenParameterivSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_PixelTexGenParameterivSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelTexGenParameterivSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelTexGenParameterfSGIS
+.type glPixelTexGenParameterfSGIS,#function
+glPixelTexGenParameterfSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelTexGenParameterfSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_PixelTexGenParameterfSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelTexGenParameterfSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPixelTexGenParameterfvSGIS
+.type glPixelTexGenParameterfvSGIS,#function
+glPixelTexGenParameterfvSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PixelTexGenParameterfvSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_PixelTexGenParameterfvSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PixelTexGenParameterfvSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPixelTexGenParameterivSGIS
+.type glGetPixelTexGenParameterivSGIS,#function
+glGetPixelTexGenParameterivSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPixelTexGenParameterivSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_GetPixelTexGenParameterivSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPixelTexGenParameterivSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPixelTexGenParameterfvSGIS
+.type glGetPixelTexGenParameterfvSGIS,#function
+glGetPixelTexGenParameterfvSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPixelTexGenParameterfvSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_GetPixelTexGenParameterfvSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPixelTexGenParameterfvSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexImage4DSGIS
+.type glTexImage4DSGIS,#function
+glTexImage4DSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexImage4DSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_TexImage4DSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexImage4DSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexSubImage4DSGIS
+.type glTexSubImage4DSGIS,#function
+glTexSubImage4DSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexSubImage4DSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_TexSubImage4DSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexSubImage4DSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glAreTexturesResidentEXT
+.type glAreTexturesResidentEXT,#function
+glAreTexturesResidentEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_AreTexturesResidentEXT), %g2
+	or	%g2, %lo(8 * _gloffset_AreTexturesResidentEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_AreTexturesResidentEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBindTextureEXT
+.type glBindTextureEXT,#function
+glBindTextureEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BindTexture), %g2
+	or	%g2, %lo(8 * _gloffset_BindTexture), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BindTexture)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDeleteTexturesEXT
+.type glDeleteTexturesEXT,#function
+glDeleteTexturesEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DeleteTextures), %g2
+	or	%g2, %lo(8 * _gloffset_DeleteTextures), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DeleteTextures)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGenTexturesEXT
+.type glGenTexturesEXT,#function
+glGenTexturesEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GenTexturesEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GenTexturesEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GenTexturesEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIsTextureEXT
+.type glIsTextureEXT,#function
+glIsTextureEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IsTextureEXT), %g2
+	or	%g2, %lo(8 * _gloffset_IsTextureEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IsTextureEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPrioritizeTexturesEXT
+.type glPrioritizeTexturesEXT,#function
+glPrioritizeTexturesEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PrioritizeTextures), %g2
+	or	%g2, %lo(8 * _gloffset_PrioritizeTextures), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PrioritizeTextures)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDetailTexFuncSGIS
+.type glDetailTexFuncSGIS,#function
+glDetailTexFuncSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DetailTexFuncSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_DetailTexFuncSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DetailTexFuncSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetDetailTexFuncSGIS
+.type glGetDetailTexFuncSGIS,#function
+glGetDetailTexFuncSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetDetailTexFuncSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_GetDetailTexFuncSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetDetailTexFuncSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSharpenTexFuncSGIS
+.type glSharpenTexFuncSGIS,#function
+glSharpenTexFuncSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SharpenTexFuncSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_SharpenTexFuncSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SharpenTexFuncSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetSharpenTexFuncSGIS
+.type glGetSharpenTexFuncSGIS,#function
+glGetSharpenTexFuncSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetSharpenTexFuncSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_GetSharpenTexFuncSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetSharpenTexFuncSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glArrayElementEXT
+.type glArrayElementEXT,#function
+glArrayElementEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ArrayElement), %g2
+	or	%g2, %lo(8 * _gloffset_ArrayElement), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ArrayElement)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorPointerEXT
+.type glColorPointerEXT,#function
+glColorPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_ColorPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDrawArraysEXT
+.type glDrawArraysEXT,#function
+glDrawArraysEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DrawArrays), %g2
+	or	%g2, %lo(8 * _gloffset_DrawArrays), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DrawArrays)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glEdgeFlagPointerEXT
+.type glEdgeFlagPointerEXT,#function
+glEdgeFlagPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_EdgeFlagPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_EdgeFlagPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_EdgeFlagPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetPointervEXT
+.type glGetPointervEXT,#function
+glGetPointervEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetPointerv), %g2
+	or	%g2, %lo(8 * _gloffset_GetPointerv), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetPointerv)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexPointerEXT
+.type glIndexPointerEXT,#function
+glIndexPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IndexPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_IndexPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IndexPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glNormalPointerEXT
+.type glNormalPointerEXT,#function
+glNormalPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_NormalPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_NormalPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_NormalPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTexCoordPointerEXT
+.type glTexCoordPointerEXT,#function
+glTexCoordPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TexCoordPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_TexCoordPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TexCoordPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertexPointerEXT
+.type glVertexPointerEXT,#function
+glVertexPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_VertexPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBlendEquationEXT
+.type glBlendEquationEXT,#function
+glBlendEquationEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BlendEquation), %g2
+	or	%g2, %lo(8 * _gloffset_BlendEquation), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BlendEquation)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSpriteParameterfSGIX
+.type glSpriteParameterfSGIX,#function
+glSpriteParameterfSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SpriteParameterfSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_SpriteParameterfSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SpriteParameterfSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSpriteParameterfvSGIX
+.type glSpriteParameterfvSGIX,#function
+glSpriteParameterfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SpriteParameterfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_SpriteParameterfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SpriteParameterfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSpriteParameteriSGIX
+.type glSpriteParameteriSGIX,#function
+glSpriteParameteriSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SpriteParameteriSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_SpriteParameteriSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SpriteParameteriSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSpriteParameterivSGIX
+.type glSpriteParameterivSGIX,#function
+glSpriteParameterivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SpriteParameterivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_SpriteParameterivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SpriteParameterivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPointParameterfEXT
+.type glPointParameterfEXT,#function
+glPointParameterfEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PointParameterfEXT), %g2
+	or	%g2, %lo(8 * _gloffset_PointParameterfEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PointParameterfEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPointParameterfvEXT
+.type glPointParameterfvEXT,#function
+glPointParameterfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PointParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_PointParameterfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PointParameterfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPointParameterfSGIS
+.type glPointParameterfSGIS,#function
+glPointParameterfSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PointParameterfEXT), %g2
+	or	%g2, %lo(8 * _gloffset_PointParameterfEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PointParameterfEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPointParameterfvSGIS
+.type glPointParameterfvSGIS,#function
+glPointParameterfvSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PointParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_PointParameterfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PointParameterfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetInstrumentsSGIX
+.type glGetInstrumentsSGIX,#function
+glGetInstrumentsSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetInstrumentsSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_GetInstrumentsSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetInstrumentsSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glInstrumentsBufferSGIX
+.type glInstrumentsBufferSGIX,#function
+glInstrumentsBufferSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_InstrumentsBufferSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_InstrumentsBufferSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_InstrumentsBufferSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glPollInstrumentsSGIX
+.type glPollInstrumentsSGIX,#function
+glPollInstrumentsSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_PollInstrumentsSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_PollInstrumentsSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_PollInstrumentsSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glReadInstrumentsSGIX
+.type glReadInstrumentsSGIX,#function
+glReadInstrumentsSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ReadInstrumentsSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_ReadInstrumentsSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ReadInstrumentsSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glStartInstrumentsSGIX
+.type glStartInstrumentsSGIX,#function
+glStartInstrumentsSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_StartInstrumentsSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_StartInstrumentsSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_StartInstrumentsSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glStopInstrumentsSGIX
+.type glStopInstrumentsSGIX,#function
+glStopInstrumentsSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_StopInstrumentsSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_StopInstrumentsSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_StopInstrumentsSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFrameZoomSGIX
+.type glFrameZoomSGIX,#function
+glFrameZoomSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FrameZoomSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FrameZoomSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FrameZoomSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTagSampleBufferSGIX
+.type glTagSampleBufferSGIX,#function
+glTagSampleBufferSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TagSampleBufferSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_TagSampleBufferSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TagSampleBufferSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glReferencePlaneSGIX
+.type glReferencePlaneSGIX,#function
+glReferencePlaneSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ReferencePlaneSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_ReferencePlaneSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ReferencePlaneSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFlushRasterSGIX
+.type glFlushRasterSGIX,#function
+glFlushRasterSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FlushRasterSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FlushRasterSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FlushRasterSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorSubTableEXT
+.type glColorSubTableEXT,#function
+glColorSubTableEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorSubTable), %g2
+	or	%g2, %lo(8 * _gloffset_ColorSubTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorSubTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCopyColorSubTableEXT
+.type glCopyColorSubTableEXT,#function
+glCopyColorSubTableEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CopyColorSubTable), %g2
+	or	%g2, %lo(8 * _gloffset_CopyColorSubTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CopyColorSubTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glHintPGI
+.type glHintPGI,#function
+glHintPGI:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_HintPGI), %g2
+	or	%g2, %lo(8 * _gloffset_HintPGI), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_HintPGI)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glColorTableEXT
+.type glColorTableEXT,#function
+glColorTableEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ColorTable), %g2
+	or	%g2, %lo(8 * _gloffset_ColorTable), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ColorTable)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableEXT
+.type glGetColorTableEXT,#function
+glGetColorTableEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableParameterivEXT
+.type glGetColorTableParameterivEXT,#function
+glGetColorTableParameterivEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableParameterivEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableParameterivEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableParameterivEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetColorTableParameterfvEXT
+.type glGetColorTableParameterfvEXT,#function
+glGetColorTableParameterfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetColorTableParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_GetColorTableParameterfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetColorTableParameterfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetListParameterfvSGIX
+.type glGetListParameterfvSGIX,#function
+glGetListParameterfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetListParameterfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_GetListParameterfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetListParameterfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetListParameterivSGIX
+.type glGetListParameterivSGIX,#function
+glGetListParameterivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetListParameterivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_GetListParameterivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetListParameterivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glListParameterfSGIX
+.type glListParameterfSGIX,#function
+glListParameterfSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ListParameterfSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_ListParameterfSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ListParameterfSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glListParameterfvSGIX
+.type glListParameterfvSGIX,#function
+glListParameterfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ListParameterfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_ListParameterfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ListParameterfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glListParameteriSGIX
+.type glListParameteriSGIX,#function
+glListParameteriSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ListParameteriSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_ListParameteriSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ListParameteriSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glListParameterivSGIX
+.type glListParameterivSGIX,#function
+glListParameterivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ListParameterivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_ListParameterivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ListParameterivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexMaterialEXT
+.type glIndexMaterialEXT,#function
+glIndexMaterialEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IndexMaterialEXT), %g2
+	or	%g2, %lo(8 * _gloffset_IndexMaterialEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IndexMaterialEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glIndexFuncEXT
+.type glIndexFuncEXT,#function
+glIndexFuncEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_IndexFuncEXT), %g2
+	or	%g2, %lo(8 * _gloffset_IndexFuncEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_IndexFuncEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLockArraysEXT
+.type glLockArraysEXT,#function
+glLockArraysEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LockArraysEXT), %g2
+	or	%g2, %lo(8 * _gloffset_LockArraysEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LockArraysEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glUnlockArraysEXT
+.type glUnlockArraysEXT,#function
+glUnlockArraysEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_UnlockArraysEXT), %g2
+	or	%g2, %lo(8 * _gloffset_UnlockArraysEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_UnlockArraysEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCullParameterdvEXT
+.type glCullParameterdvEXT,#function
+glCullParameterdvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CullParameterdvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_CullParameterdvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CullParameterdvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCullParameterfvEXT
+.type glCullParameterfvEXT,#function
+glCullParameterfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CullParameterfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_CullParameterfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CullParameterfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentColorMaterialSGIX
+.type glFragmentColorMaterialSGIX,#function
+glFragmentColorMaterialSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentColorMaterialSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentColorMaterialSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentColorMaterialSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightfSGIX
+.type glFragmentLightfSGIX,#function
+glFragmentLightfSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightfSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightfSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightfSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightfvSGIX
+.type glFragmentLightfvSGIX,#function
+glFragmentLightfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightiSGIX
+.type glFragmentLightiSGIX,#function
+glFragmentLightiSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightiSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightiSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightiSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightivSGIX
+.type glFragmentLightivSGIX,#function
+glFragmentLightivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightModelfSGIX
+.type glFragmentLightModelfSGIX,#function
+glFragmentLightModelfSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightModelfSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightModelfSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightModelfSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightModelfvSGIX
+.type glFragmentLightModelfvSGIX,#function
+glFragmentLightModelfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightModelfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightModelfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightModelfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightModeliSGIX
+.type glFragmentLightModeliSGIX,#function
+glFragmentLightModeliSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightModeliSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightModeliSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightModeliSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentLightModelivSGIX
+.type glFragmentLightModelivSGIX,#function
+glFragmentLightModelivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentLightModelivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentLightModelivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentLightModelivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentMaterialfSGIX
+.type glFragmentMaterialfSGIX,#function
+glFragmentMaterialfSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentMaterialfSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentMaterialfSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentMaterialfSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentMaterialfvSGIX
+.type glFragmentMaterialfvSGIX,#function
+glFragmentMaterialfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentMaterialfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentMaterialfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentMaterialfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentMaterialiSGIX
+.type glFragmentMaterialiSGIX,#function
+glFragmentMaterialiSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentMaterialiSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentMaterialiSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentMaterialiSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFragmentMaterialivSGIX
+.type glFragmentMaterialivSGIX,#function
+glFragmentMaterialivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FragmentMaterialivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_FragmentMaterialivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FragmentMaterialivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetFragmentLightfvSGIX
+.type glGetFragmentLightfvSGIX,#function
+glGetFragmentLightfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetFragmentLightfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_GetFragmentLightfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetFragmentLightfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetFragmentLightivSGIX
+.type glGetFragmentLightivSGIX,#function
+glGetFragmentLightivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetFragmentLightivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_GetFragmentLightivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetFragmentLightivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetFragmentMaterialfvSGIX
+.type glGetFragmentMaterialfvSGIX,#function
+glGetFragmentMaterialfvSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetFragmentMaterialfvSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_GetFragmentMaterialfvSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetFragmentMaterialfvSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetFragmentMaterialivSGIX
+.type glGetFragmentMaterialivSGIX,#function
+glGetFragmentMaterialivSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetFragmentMaterialivSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_GetFragmentMaterialivSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetFragmentMaterialivSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLightEnviSGIX
+.type glLightEnviSGIX,#function
+glLightEnviSGIX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LightEnviSGIX), %g2
+	or	%g2, %lo(8 * _gloffset_LightEnviSGIX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LightEnviSGIX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glDrawRangeElementsEXT
+.type glDrawRangeElementsEXT,#function
+glDrawRangeElementsEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_DrawRangeElements), %g2
+	or	%g2, %lo(8 * _gloffset_DrawRangeElements), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_DrawRangeElements)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3bEXT
+.type glSecondaryColor3bEXT,#function
+glSecondaryColor3bEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3bEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3bEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3bEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3bvEXT
+.type glSecondaryColor3bvEXT,#function
+glSecondaryColor3bvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3bvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3bvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3bvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3dEXT
+.type glSecondaryColor3dEXT,#function
+glSecondaryColor3dEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3dEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3dEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3dEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3dvEXT
+.type glSecondaryColor3dvEXT,#function
+glSecondaryColor3dvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3dvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3dvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3dvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3fEXT
+.type glSecondaryColor3fEXT,#function
+glSecondaryColor3fEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3fEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3fEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3fEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3fvEXT
+.type glSecondaryColor3fvEXT,#function
+glSecondaryColor3fvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3fvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3fvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3fvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3iEXT
+.type glSecondaryColor3iEXT,#function
+glSecondaryColor3iEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3iEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3iEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3iEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3ivEXT
+.type glSecondaryColor3ivEXT,#function
+glSecondaryColor3ivEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3ivEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3ivEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3ivEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3sEXT
+.type glSecondaryColor3sEXT,#function
+glSecondaryColor3sEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3sEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3sEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3sEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3svEXT
+.type glSecondaryColor3svEXT,#function
+glSecondaryColor3svEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3svEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3svEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3svEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3ubEXT
+.type glSecondaryColor3ubEXT,#function
+glSecondaryColor3ubEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3ubEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3ubEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3ubEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3ubvEXT
+.type glSecondaryColor3ubvEXT,#function
+glSecondaryColor3ubvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3ubvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3ubvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3ubvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3uiEXT
+.type glSecondaryColor3uiEXT,#function
+glSecondaryColor3uiEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3uiEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3uiEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3uiEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3uivEXT
+.type glSecondaryColor3uivEXT,#function
+glSecondaryColor3uivEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3uivEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3uivEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3uivEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3usEXT
+.type glSecondaryColor3usEXT,#function
+glSecondaryColor3usEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3usEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3usEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3usEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColor3usvEXT
+.type glSecondaryColor3usvEXT,#function
+glSecondaryColor3usvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColor3usvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColor3usvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColor3usvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSecondaryColorPointerEXT
+.type glSecondaryColorPointerEXT,#function
+glSecondaryColorPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SecondaryColorPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_SecondaryColorPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SecondaryColorPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogCoordfEXT
+.type glFogCoordfEXT,#function
+glFogCoordfEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FogCoordfEXT), %g2
+	or	%g2, %lo(8 * _gloffset_FogCoordfEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FogCoordfEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogCoordfvEXT
+.type glFogCoordfvEXT,#function
+glFogCoordfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FogCoordfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_FogCoordfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FogCoordfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogCoorddEXT
+.type glFogCoorddEXT,#function
+glFogCoorddEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FogCoorddEXT), %g2
+	or	%g2, %lo(8 * _gloffset_FogCoorddEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FogCoorddEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogCoorddvEXT
+.type glFogCoorddvEXT,#function
+glFogCoorddvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FogCoorddvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_FogCoorddvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FogCoorddvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFogCoordPointerEXT
+.type glFogCoordPointerEXT,#function
+glFogCoordPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FogCoordPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_FogCoordPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FogCoordPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBlendFuncSeparateEXT
+.type glBlendFuncSeparateEXT,#function
+glBlendFuncSeparateEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BlendFuncSeparateEXT), %g2
+	or	%g2, %lo(8 * _gloffset_BlendFuncSeparateEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BlendFuncSeparateEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glBlendFuncSeparateINGR
+.type glBlendFuncSeparateINGR,#function
+glBlendFuncSeparateINGR:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_BlendFuncSeparateEXT), %g2
+	or	%g2, %lo(8 * _gloffset_BlendFuncSeparateEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_BlendFuncSeparateEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertexWeightfEXT
+.type glVertexWeightfEXT,#function
+glVertexWeightfEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexWeightfEXT), %g2
+	or	%g2, %lo(8 * _gloffset_VertexWeightfEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexWeightfEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertexWeightfvEXT
+.type glVertexWeightfvEXT,#function
+glVertexWeightfvEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexWeightfvEXT), %g2
+	or	%g2, %lo(8 * _gloffset_VertexWeightfvEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexWeightfvEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertexWeightPointerEXT
+.type glVertexWeightPointerEXT,#function
+glVertexWeightPointerEXT:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexWeightPointerEXT), %g2
+	or	%g2, %lo(8 * _gloffset_VertexWeightPointerEXT), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexWeightPointerEXT)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFlushVertexArrayRangeNV
+.type glFlushVertexArrayRangeNV,#function
+glFlushVertexArrayRangeNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FlushVertexArrayRangeNV), %g2
+	or	%g2, %lo(8 * _gloffset_FlushVertexArrayRangeNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FlushVertexArrayRangeNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glVertexArrayRangeNV
+.type glVertexArrayRangeNV,#function
+glVertexArrayRangeNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_VertexArrayRangeNV), %g2
+	or	%g2, %lo(8 * _gloffset_VertexArrayRangeNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_VertexArrayRangeNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCombinerParameterfvNV
+.type glCombinerParameterfvNV,#function
+glCombinerParameterfvNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CombinerParameterfvNV), %g2
+	or	%g2, %lo(8 * _gloffset_CombinerParameterfvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CombinerParameterfvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCombinerParameterfNV
+.type glCombinerParameterfNV,#function
+glCombinerParameterfNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CombinerParameterfNV), %g2
+	or	%g2, %lo(8 * _gloffset_CombinerParameterfNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CombinerParameterfNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCombinerParameterivNV
+.type glCombinerParameterivNV,#function
+glCombinerParameterivNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CombinerParameterivNV), %g2
+	or	%g2, %lo(8 * _gloffset_CombinerParameterivNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CombinerParameterivNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCombinerParameteriNV
+.type glCombinerParameteriNV,#function
+glCombinerParameteriNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CombinerParameteriNV), %g2
+	or	%g2, %lo(8 * _gloffset_CombinerParameteriNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CombinerParameteriNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCombinerInputNV
+.type glCombinerInputNV,#function
+glCombinerInputNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CombinerInputNV), %g2
+	or	%g2, %lo(8 * _gloffset_CombinerInputNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CombinerInputNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCombinerOutputNV
+.type glCombinerOutputNV,#function
+glCombinerOutputNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CombinerOutputNV), %g2
+	or	%g2, %lo(8 * _gloffset_CombinerOutputNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CombinerOutputNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glFinalCombinerInputNV
+.type glFinalCombinerInputNV,#function
+glFinalCombinerInputNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_FinalCombinerInputNV), %g2
+	or	%g2, %lo(8 * _gloffset_FinalCombinerInputNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_FinalCombinerInputNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetCombinerInputParameterfvNV
+.type glGetCombinerInputParameterfvNV,#function
+glGetCombinerInputParameterfvNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetCombinerInputParameterfvNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetCombinerInputParameterfvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetCombinerInputParameterfvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetCombinerInputParameterivNV
+.type glGetCombinerInputParameterivNV,#function
+glGetCombinerInputParameterivNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetCombinerInputParameterivNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetCombinerInputParameterivNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetCombinerInputParameterivNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetCombinerOutputParameterfvNV
+.type glGetCombinerOutputParameterfvNV,#function
+glGetCombinerOutputParameterfvNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetCombinerOutputParameterfvNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetCombinerOutputParameterfvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetCombinerOutputParameterfvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetCombinerOutputParameterivNV
+.type glGetCombinerOutputParameterivNV,#function
+glGetCombinerOutputParameterivNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetCombinerOutputParameterivNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetCombinerOutputParameterivNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetCombinerOutputParameterivNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetFinalCombinerInputParameterfvNV
+.type glGetFinalCombinerInputParameterfvNV,#function
+glGetFinalCombinerInputParameterfvNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetFinalCombinerInputParameterfvNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetFinalCombinerInputParameterfvNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetFinalCombinerInputParameterfvNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetFinalCombinerInputParameterivNV
+.type glGetFinalCombinerInputParameterivNV,#function
+glGetFinalCombinerInputParameterivNV:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetFinalCombinerInputParameterivNV), %g2
+	or	%g2, %lo(8 * _gloffset_GetFinalCombinerInputParameterivNV), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetFinalCombinerInputParameterivNV)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glResizeBuffersMESA
+.type glResizeBuffersMESA,#function
+glResizeBuffersMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ResizeBuffersMESA), %g2
+	or	%g2, %lo(8 * _gloffset_ResizeBuffersMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ResizeBuffersMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2dMESA
+.type glWindowPos2dMESA,#function
+glWindowPos2dMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2dMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2dMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2dMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2dvMESA
+.type glWindowPos2dvMESA,#function
+glWindowPos2dvMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2dvMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2dvMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2dvMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2fMESA
+.type glWindowPos2fMESA,#function
+glWindowPos2fMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2fMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2fMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2fMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2fvMESA
+.type glWindowPos2fvMESA,#function
+glWindowPos2fvMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2fvMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2fvMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2fvMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2iMESA
+.type glWindowPos2iMESA,#function
+glWindowPos2iMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2iMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2iMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2iMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2ivMESA
+.type glWindowPos2ivMESA,#function
+glWindowPos2ivMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2ivMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2ivMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2ivMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2sMESA
+.type glWindowPos2sMESA,#function
+glWindowPos2sMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2sMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2sMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2sMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos2svMESA
+.type glWindowPos2svMESA,#function
+glWindowPos2svMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos2svMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos2svMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos2svMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3dMESA
+.type glWindowPos3dMESA,#function
+glWindowPos3dMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3dMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3dMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3dMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3dvMESA
+.type glWindowPos3dvMESA,#function
+glWindowPos3dvMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3dvMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3dvMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3dvMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3fMESA
+.type glWindowPos3fMESA,#function
+glWindowPos3fMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3fMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3fMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3fMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3fvMESA
+.type glWindowPos3fvMESA,#function
+glWindowPos3fvMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3fvMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3fvMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3fvMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3iMESA
+.type glWindowPos3iMESA,#function
+glWindowPos3iMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3iMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3iMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3iMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3ivMESA
+.type glWindowPos3ivMESA,#function
+glWindowPos3ivMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3ivMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3ivMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3ivMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3sMESA
+.type glWindowPos3sMESA,#function
+glWindowPos3sMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3sMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3sMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3sMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos3svMESA
+.type glWindowPos3svMESA,#function
+glWindowPos3svMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos3svMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos3svMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos3svMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4dMESA
+.type glWindowPos4dMESA,#function
+glWindowPos4dMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4dMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4dMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4dMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4dvMESA
+.type glWindowPos4dvMESA,#function
+glWindowPos4dvMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4dvMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4dvMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4dvMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4fMESA
+.type glWindowPos4fMESA,#function
+glWindowPos4fMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4fMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4fMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4fMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4fvMESA
+.type glWindowPos4fvMESA,#function
+glWindowPos4fvMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4fvMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4fvMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4fvMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4iMESA
+.type glWindowPos4iMESA,#function
+glWindowPos4iMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4iMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4iMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4iMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4ivMESA
+.type glWindowPos4ivMESA,#function
+glWindowPos4ivMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4ivMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4ivMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4ivMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4sMESA
+.type glWindowPos4sMESA,#function
+glWindowPos4sMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4sMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4sMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4sMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glWindowPos4svMESA
+.type glWindowPos4svMESA,#function
+glWindowPos4svMESA:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_WindowPos4svMESA), %g2
+	or	%g2, %lo(8 * _gloffset_WindowPos4svMESA), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_WindowPos4svMESA)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glTbufferMask3DFX
+.type glTbufferMask3DFX,#function
+glTbufferMask3DFX:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_TbufferMask3DFX), %g2
+	or	%g2, %lo(8 * _gloffset_TbufferMask3DFX), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_TbufferMask3DFX)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSampleMaskSGIS
+.type glSampleMaskSGIS,#function
+glSampleMaskSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SampleMaskSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_SampleMaskSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SampleMaskSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSamplePatternSGIS
+.type glSamplePatternSGIS,#function
+glSamplePatternSGIS:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SamplePatternSGIS), %g2
+	or	%g2, %lo(8 * _gloffset_SamplePatternSGIS), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SamplePatternSGIS)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glActiveTexture
+.type glActiveTexture,#function
+glActiveTexture:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ActiveTextureARB), %g2
+	or	%g2, %lo(8 * _gloffset_ActiveTextureARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ActiveTextureARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glClientActiveTexture
+.type glClientActiveTexture,#function
+glClientActiveTexture:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_ClientActiveTextureARB), %g2
+	or	%g2, %lo(8 * _gloffset_ClientActiveTextureARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_ClientActiveTextureARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexImage1D
+.type glCompressedTexImage1D,#function
+glCompressedTexImage1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexImage1DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexImage1DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexImage1DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexImage2D
+.type glCompressedTexImage2D,#function
+glCompressedTexImage2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexImage2DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexImage2DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexImage2DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexImage3D
+.type glCompressedTexImage3D,#function
+glCompressedTexImage3D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexImage3DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexImage3DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexImage3DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexSubImage1D
+.type glCompressedTexSubImage1D,#function
+glCompressedTexSubImage1D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexSubImage1DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexSubImage1DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexSubImage1DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexSubImage2D
+.type glCompressedTexSubImage2D,#function
+glCompressedTexSubImage2D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexSubImage2DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexSubImage2DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexSubImage2DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glCompressedTexSubImage3D
+.type glCompressedTexSubImage3D,#function
+glCompressedTexSubImage3D:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_CompressedTexSubImage3DARB), %g2
+	or	%g2, %lo(8 * _gloffset_CompressedTexSubImage3DARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_CompressedTexSubImage3DARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glGetCompressedTexImage
+.type glGetCompressedTexImage,#function
+glGetCompressedTexImage:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_GetCompressedTexImageARB), %g2
+	or	%g2, %lo(8 * _gloffset_GetCompressedTexImageARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_GetCompressedTexImageARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1d
+.type glMultiTexCoord1d,#function
+glMultiTexCoord1d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1dv
+.type glMultiTexCoord1dv,#function
+glMultiTexCoord1dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1f
+.type glMultiTexCoord1f,#function
+glMultiTexCoord1f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1fv
+.type glMultiTexCoord1fv,#function
+glMultiTexCoord1fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1i
+.type glMultiTexCoord1i,#function
+glMultiTexCoord1i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1iv
+.type glMultiTexCoord1iv,#function
+glMultiTexCoord1iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1s
+.type glMultiTexCoord1s,#function
+glMultiTexCoord1s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord1sv
+.type glMultiTexCoord1sv,#function
+glMultiTexCoord1sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord1svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord1svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord1svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2d
+.type glMultiTexCoord2d,#function
+glMultiTexCoord2d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2dv
+.type glMultiTexCoord2dv,#function
+glMultiTexCoord2dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2f
+.type glMultiTexCoord2f,#function
+glMultiTexCoord2f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2fv
+.type glMultiTexCoord2fv,#function
+glMultiTexCoord2fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2i
+.type glMultiTexCoord2i,#function
+glMultiTexCoord2i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2iv
+.type glMultiTexCoord2iv,#function
+glMultiTexCoord2iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2s
+.type glMultiTexCoord2s,#function
+glMultiTexCoord2s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord2sv
+.type glMultiTexCoord2sv,#function
+glMultiTexCoord2sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord2svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord2svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord2svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3d
+.type glMultiTexCoord3d,#function
+glMultiTexCoord3d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3dv
+.type glMultiTexCoord3dv,#function
+glMultiTexCoord3dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3f
+.type glMultiTexCoord3f,#function
+glMultiTexCoord3f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3fv
+.type glMultiTexCoord3fv,#function
+glMultiTexCoord3fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3i
+.type glMultiTexCoord3i,#function
+glMultiTexCoord3i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3iv
+.type glMultiTexCoord3iv,#function
+glMultiTexCoord3iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3s
+.type glMultiTexCoord3s,#function
+glMultiTexCoord3s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord3sv
+.type glMultiTexCoord3sv,#function
+glMultiTexCoord3sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord3svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord3svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord3svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4d
+.type glMultiTexCoord4d,#function
+glMultiTexCoord4d:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4dARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4dARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4dARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4dv
+.type glMultiTexCoord4dv,#function
+glMultiTexCoord4dv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4dvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4dvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4dvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4f
+.type glMultiTexCoord4f,#function
+glMultiTexCoord4f:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4fARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4fARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4fARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4fv
+.type glMultiTexCoord4fv,#function
+glMultiTexCoord4fv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4fvARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4fvARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4fvARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4i
+.type glMultiTexCoord4i,#function
+glMultiTexCoord4i:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4iARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4iARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4iARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4iv
+.type glMultiTexCoord4iv,#function
+glMultiTexCoord4iv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4ivARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4ivARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4ivARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4s
+.type glMultiTexCoord4s,#function
+glMultiTexCoord4s:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4sARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4sARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4sARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultiTexCoord4sv
+.type glMultiTexCoord4sv,#function
+glMultiTexCoord4sv:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultiTexCoord4svARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultiTexCoord4svARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultiTexCoord4svARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadTransposeMatrixd
+.type glLoadTransposeMatrixd,#function
+glLoadTransposeMatrixd:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadTransposeMatrixdARB), %g2
+	or	%g2, %lo(8 * _gloffset_LoadTransposeMatrixdARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadTransposeMatrixdARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glLoadTransposeMatrixf
+.type glLoadTransposeMatrixf,#function
+glLoadTransposeMatrixf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_LoadTransposeMatrixfARB), %g2
+	or	%g2, %lo(8 * _gloffset_LoadTransposeMatrixfARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_LoadTransposeMatrixfARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultTransposeMatrixd
+.type glMultTransposeMatrixd,#function
+glMultTransposeMatrixd:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultTransposeMatrixdARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultTransposeMatrixdARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultTransposeMatrixdARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glMultTransposeMatrixf
+.type glMultTransposeMatrixf,#function
+glMultTransposeMatrixf:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_MultTransposeMatrixfARB), %g2
+	or	%g2, %lo(8 * _gloffset_MultTransposeMatrixfARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_MultTransposeMatrixfARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+.globl glSampleCoverage
+.type glSampleCoverage,#function
+glSampleCoverage:
+#ifdef __sparc_v9__
+	sethi	%hi(0x00000000), %g2
+	sethi	%hi(0x00000000), %g1
+	or	%g2, %lo(0x00000000), %g2
+	or	%g1, %lo(0x00000000), %g1
+	sllx	%g2, 32, %g2
+	ldx	[%g1 + %g2], %g1
+	sethi	%hi(8 * _gloffset_SampleCoverageARB), %g2
+	or	%g2, %lo(8 * _gloffset_SampleCoverageARB), %g2
+	ldx	[%g1 + %g2], %g3
+#else
+	sethi	%hi(0x00000000), %g1
+	ld	[%g1 + %lo(0x00000000)], %g1
+	ld	[%g1 + (4 * _gloffset_SampleCoverageARB)], %g3
+#endif
+	jmpl	%g3, %g0
+	nop
+
+
+.globl _mesa_sparc_glapi_end
+.type _mesa_sparc_glapi_end,#function
+_mesa_sparc_glapi_end:
+
Index: xc/extras/Mesa/src/SPARC/norm.S
diff -u /dev/null xc/extras/Mesa/src/SPARC/norm.S:1.2
--- /dev/null	Thu Feb 27 12:15:50 2003
+++ xc/extras/Mesa/src/SPARC/norm.S	Mon Dec 16 11:18:30 2002
@@ -0,0 +1,602 @@
+
+#include "sparc_matrix.h"
+
+	.text
+
+#ifdef __sparc_v9__
+#define STACK_VAR_OFF	(2047 + (8 * 16))
+#else
+#define STACK_VAR_OFF	(4 * 16)
+#endif
+
+	/* Newton-Raphson approximation turns out to be slower
+	 * (and less accurate) than direct fsqrts/fdivs.
+	 */
+#define ONE_DOT_ZERO	0x3f800000
+
+	.globl	_mesa_sparc_transform_normalize_normals
+_mesa_sparc_transform_normalize_normals:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+
+	sethi	%hi(ONE_DOT_ZERO), %g2
+	sub	%sp, 16, %sp
+	st	%g2, [%sp + STACK_VAR_OFF+0x0]
+	st	%o1, [%sp + STACK_VAR_OFF+0x4]
+	ld	[%sp + STACK_VAR_OFF+0x0], %f12	! f12 = 1.0f
+	ld	[%sp + STACK_VAR_OFF+0x4], %f15	! f15 = scale
+	add	%sp, 16, %sp
+
+	LDPTR	[%o0 + MAT_INV], %o0		! o0 = mat->inv
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	LDMATRIX_0_1_2_4_5_6_8_9_10(%o0)
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 cmp	%o3, 0
+	bne	4f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+1:	/* LENGTHS == NULL */
+	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* tx (f3) = (ux * m0) + (uy * m1) + (uz * m2)
+	 * ty (f5) = (ux * m4) + (uy * m5) + (uz * m6)
+	 * tz (f7) = (ux * m8) + (uy * m9) + (uz * m10)
+	 */
+	fmuls	%f0, M0, %f3			! FGM	Group
+	fmuls	%f1, M1, %f4			! FGM	Group
+	fmuls	%f0, M4, %f5			! FGM	Group
+	fmuls	%f1, M5, %f6			! FGM	Group
+	fmuls	%f0, M8, %f7			! FGM	Group	f3 available
+	fmuls	%f1, M9, %f8			! FGM	Group	f4 available
+	fadds	%f3, %f4, %f3			! FGA
+	fmuls	%f2, M2, %f10			! FGM	Group	f5 available
+	fmuls	%f2, M6, %f0			! FGM	Group	f6 available
+	fadds	%f5, %f6, %f5			! FGA
+	fmuls	%f2, M10, %f4			! FGM	Group	f7 available
+	fadds	%f7, %f8, %f7			! FGA	Group	f8,f3 available
+	fadds	%f3, %f10, %f3			! FGA	Group	f10 available
+	fadds	%f5, %f0, %f5			! FGA	Group	stall f0,f5 available
+	fadds	%f7, %f4, %f7			! FGA	Group	stall f4,f7 available
+
+	/* f3=tx, f5=ty, f7=tz */
+
+	/* len (f6) = (tx * tx) + (ty * ty) + (tz * tz) */
+	fmuls	%f3, %f3, %f6			! FGM	Group	f3 available
+	fmuls	%f5, %f5, %f8			! FGM	Group	f5 available
+	fmuls	%f7, %f7, %f10			! FGM	Group	f7 available
+	fadds	%f6, %f8, %f6			! FGA	Group	2cyc stall f6,f8 available
+	fadds	%f6, %f10, %f6			! FGA	Group	4cyc stall f6,f10 available
+
+	/* scale (f6) = 1.0 / sqrt(len) */
+	fsqrts	%f6, %f6			! FDIV  20 cycles
+	fdivs	%f12, %f6, %f6			! FDIV	14 cycles
+
+	fmuls	%f3, %f6, %f3
+	st	%f3, [%g3 + 0x00]		! out[i][0] = tx * scale
+	fmuls	%f5, %f6, %f5
+	st	%f5, [%g3 + 0x04]		! out[i][1] = ty * scale
+	fmuls	%f7, %f6, %f7
+	st	%f7, [%g3 + 0x08]		! out[i][2] = tz * scale
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+	ba	7f
+	 nop
+
+4:	/* LENGTHS != NULL */
+	fmuls	M0, %f15, M0
+	fmuls	M1, %f15, M1
+	fmuls	M2, %f15, M2
+	fmuls	M4, %f15, M4
+	fmuls	M5, %f15, M5
+	fmuls	M6, %f15, M6
+	fmuls	M8, %f15, M8
+	fmuls	M9, %f15, M9
+	fmuls	M10, %f15, M10
+
+5:
+	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* tx (f3) = (ux * m0) + (uy * m1) + (uz * m2)
+	 * ty (f5) = (ux * m4) + (uy * m5) + (uz * m6)
+	 * tz (f7) = (ux * m8) + (uy * m9) + (uz * m10)
+	 */
+	fmuls	%f0, M0, %f3			! FGM	Group
+	fmuls	%f1, M1, %f4			! FGM	Group
+	fmuls	%f0, M4, %f5			! FGM	Group
+	fmuls	%f1, M5, %f6			! FGM	Group
+	fmuls	%f0, M8, %f7			! FGM	Group	f3 available
+	fmuls	%f1, M9, %f8			! FGM	Group	f4 available
+	fadds	%f3, %f4, %f3			! FGA
+	fmuls	%f2, M2, %f10			! FGM	Group	f5 available
+	fmuls	%f2, M6, %f0			! FGM	Group	f6 available
+	fadds	%f5, %f6, %f5			! FGA
+	fmuls	%f2, M10, %f4			! FGM	Group	f7 available
+	fadds	%f7, %f8, %f7			! FGA	Group	f8,f3 available
+	fadds	%f3, %f10, %f3			! FGA	Group	f10 available
+	ld	[%o3], %f13			! LSU
+	fadds	%f5, %f0, %f5			! FGA	Group	stall f0,f5 available
+	add	%o3, 4, %o3			! IEU0
+	fadds	%f7, %f4, %f7			! FGA	Group	stall f4,f7 available
+
+	/* f3=tx, f5=ty, f7=tz, f13=lengths[i] */
+
+	fmuls	%f3, %f13, %f3
+	st	%f3, [%g3 + 0x00]		! out[i][0] = tx * len
+	fmuls	%f5, %f13, %f5
+	st	%f5, [%g3 + 0x04]		! out[i][1] = ty * len
+	fmuls	%f7, %f13, %f7
+	st	%f7, [%g3 + 0x08]		! out[i][2] = tz * len
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	5b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
+	
+	.globl	_mesa_sparc_transform_normalize_normals_no_rot
+_mesa_sparc_transform_normalize_normals_no_rot:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+
+	sethi	%hi(ONE_DOT_ZERO), %g2
+	sub	%sp, 16, %sp
+	st	%g2, [%sp + STACK_VAR_OFF+0x0]
+	st	%o1, [%sp + STACK_VAR_OFF+0x4]
+	ld	[%sp + STACK_VAR_OFF+0x0], %f12	! f12 = 1.0f
+	ld	[%sp + STACK_VAR_OFF+0x4], %f15	! f15 = scale
+	add	%sp, 16, %sp
+
+	LDPTR	[%o0 + MAT_INV], %o0		! o0 = mat->inv
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	LDMATRIX_0_5_10(%o0)
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 cmp	%o3, 0
+	bne	4f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+1:	/* LENGTHS == NULL */
+	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* tx (f3) = (ux * m0)
+	 * ty (f5) = (uy * m5)
+	 * tz (f7) = (uz * m10)
+	 */
+	fmuls	%f0, M0, %f3			! FGM	Group
+	fmuls	%f1, M5, %f5			! FGM	Group
+	fmuls	%f2, M10, %f7			! FGM	Group
+
+	/* f3=tx, f5=ty, f7=tz */
+
+	/* len (f6) = (tx * tx) + (ty * ty) + (tz * tz) */
+	fmuls	%f3, %f3, %f6			! FGM	Group	stall, f3 available
+	fmuls	%f5, %f5, %f8			! FGM	Group	f5 available
+	fmuls	%f7, %f7, %f10			! FGM	Group	f7 available
+	fadds	%f6, %f8, %f6			! FGA	Group	2cyc stall f6,f8 available
+	fadds	%f6, %f10, %f6			! FGA	Group	4cyc stall f6,f10 available
+
+	/* scale (f6) = 1.0 / sqrt(len) */
+	fsqrts	%f6, %f6			! FDIV  20 cycles
+	fdivs	%f12, %f6, %f6			! FDIV	14 cycles
+
+	fmuls	%f3, %f6, %f3
+	st	%f3, [%g3 + 0x00]		! out[i][0] = tx * scale
+	fmuls	%f5, %f6, %f5
+	st	%f5, [%g3 + 0x04]		! out[i][1] = ty * scale
+	fmuls	%f7, %f6, %f7
+	st	%f7, [%g3 + 0x08]		! out[i][2] = tz * scale
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+	ba	7f
+	 nop
+
+4:	/* LENGTHS != NULL */
+	fmuls	M0, %f15, M0
+	fmuls	M5, %f15, M5
+	fmuls	M10, %f15, M10
+
+5:
+	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* tx (f3) = (ux * m0)
+	 * ty (f5) = (uy * m5)
+	 * tz (f7) = (uz * m10)
+	 */
+	fmuls	%f0, M0, %f3			! FGM	Group
+	ld	[%o3], %f13			! LSU
+	fmuls	%f1, M5, %f5			! FGM	Group
+	add	%o3, 4, %o3			! IEU0
+	fmuls	%f2, M10, %f7			! FGM	Group
+
+	/* f3=tx, f5=ty, f7=tz, f13=lengths[i] */
+
+	fmuls	%f3, %f13, %f3
+	st	%f3, [%g3 + 0x00]		! out[i][0] = tx * len
+	fmuls	%f5, %f13, %f5
+	st	%f5, [%g3 + 0x04]		! out[i][1] = ty * len
+	fmuls	%f7, %f13, %f7
+	st	%f7, [%g3 + 0x08]		! out[i][2] = tz * len
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	5b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
+
+	.globl	_mesa_sparc_transform_rescale_normals_no_rot
+_mesa_sparc_transform_rescale_normals_no_rot:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+	sub	%sp, 16, %sp
+	st	%o1, [%sp + STACK_VAR_OFF+0x0]
+	ld	[%sp + STACK_VAR_OFF+0x0], %f15	! f15 = scale
+	add	%sp, 16, %sp
+
+	LDPTR	[%o0 + MAT_INV], %o0		! o0 = mat->inv
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	LDMATRIX_0_5_10(%o0)
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+	fmuls	M0, %f15, M0
+	fmuls	M5, %f15, M5
+	fmuls	M10, %f15, M10
+
+1:	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* tx (f3) = (ux * m0)
+	 * ty (f5) = (uy * m5)
+	 * tz (f7) = (uz * m10)
+	 */
+	fmuls	%f0, M0, %f3			! FGM	Group
+	st	%f3, [%g3 + 0x00]		! LSU
+	fmuls	%f1, M5, %f5			! FGM	Group
+	st	%f5, [%g3 + 0x04]		! LSU
+	fmuls	%f2, M10, %f7			! FGM	Group
+	st	%f7, [%g3 + 0x08]		! LSU
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
+
+	.globl	_mesa_sparc_transform_rescale_normals
+_mesa_sparc_transform_rescale_normals:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+	sub	%sp, 16, %sp
+	st	%o1, [%sp + STACK_VAR_OFF+0x0]
+	ld	[%sp + STACK_VAR_OFF+0x0], %f15	! f15 = scale
+	add	%sp, 16, %sp
+
+	LDPTR	[%o0 + MAT_INV], %o0		! o0 = mat->inv
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	LDMATRIX_0_1_2_4_5_6_8_9_10(%o0)
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+	fmuls	M0, %f15, M0
+	fmuls	M1, %f15, M1
+	fmuls	M2, %f15, M2
+	fmuls	M4, %f15, M4
+	fmuls	M5, %f15, M5
+	fmuls	M6, %f15, M6
+	fmuls	M8, %f15, M8
+	fmuls	M9, %f15, M9
+	fmuls	M10, %f15, M10
+
+1:	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	fmuls	%f0, M0, %f3			! FGM	Group
+	fmuls	%f1, M1, %f4			! FGM	Group
+	fmuls	%f0, M4, %f5			! FGM	Group
+	fmuls	%f1, M5, %f6			! FGM	Group
+	fmuls	%f0, M8, %f7			! FGM	Group	f3 available
+	fmuls	%f1, M9, %f8			! FGM	Group	f4 available
+	fadds	%f3, %f4, %f3			! FGA
+	fmuls	%f2, M2, %f10			! FGM	Group	f5 available
+	fmuls	%f2, M6, %f0			! FGM	Group	f6 available
+	fadds	%f5, %f6, %f5			! FGA
+	fmuls	%f2, M10, %f4			! FGM	Group	f7 available
+	fadds	%f7, %f8, %f7			! FGA	Group	f8,f3 available
+	fadds	%f3, %f10, %f3			! FGA	Group	f10 available
+	st	%f3, [%g3 + 0x00]		! LSU
+	fadds	%f5, %f0, %f5			! FGA	Group	stall f0,f5 available
+	st	%f5, [%g3 + 0x04]		! LSU
+	fadds	%f7, %f4, %f7			! FGA	Group	stall f4,f7 available
+	st	%f7, [%g3 + 0x08]		! LSU
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
+
+	.globl	_mesa_sparc_transform_normals_no_rot
+_mesa_sparc_transform_normals_no_rot:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+	LDPTR	[%o0 + MAT_INV], %o0		! o0 = mat->inv
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	LDMATRIX_0_5_10(%o0)
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+1:	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* tx (f3) = (ux * m0)
+	 * ty (f5) = (uy * m5)
+	 * tz (f7) = (uz * m10)
+	 */
+	fmuls	%f0, M0, %f3			! FGM	Group
+	st	%f3, [%g3 + 0x00]		! LSU
+	fmuls	%f1, M5, %f5			! FGM	Group
+	st	%f5, [%g3 + 0x04]		! LSU
+	fmuls	%f2, M10, %f7			! FGM	Group
+	st	%f7, [%g3 + 0x08]		! LSU
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
+
+	.globl	_mesa_sparc_transform_normals
+_mesa_sparc_transform_normals:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+	LDPTR	[%o0 + MAT_INV], %o0		! o0 = mat->inv
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	LDMATRIX_0_1_2_4_5_6_8_9_10(%o0)
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+1:	ld	[%o5 + 0x00], %f0		! ux = from[0]
+	ld	[%o5 + 0x04], %f1		! uy = from[1]
+	ld	[%o5 + 0x08], %f2		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	fmuls	%f0, M0, %f3			! FGM	Group
+	fmuls	%f1, M1, %f4			! FGM	Group
+	fmuls	%f0, M4, %f5			! FGM	Group
+	fmuls	%f1, M5, %f6			! FGM	Group
+	fmuls	%f0, M8, %f7			! FGM	Group	f3 available
+	fmuls	%f1, M9, %f8			! FGM	Group	f4 available
+	fadds	%f3, %f4, %f3			! FGA
+	fmuls	%f2, M2, %f10			! FGM	Group	f5 available
+	fmuls	%f2, M6, %f0			! FGM	Group	f6 available
+	fadds	%f5, %f6, %f5			! FGA
+	fmuls	%f2, M10, %f4			! FGM	Group	f7 available
+	fadds	%f7, %f8, %f7			! FGA	Group	f8,f3 available
+	fadds	%f3, %f10, %f3			! FGA	Group	f10 available
+	st	%f3, [%g3 + 0x00]		! LSU
+	fadds	%f5, %f0, %f5			! FGA	Group	stall f0,f5 available
+	st	%f5, [%g3 + 0x04]		! LSU
+	fadds	%f7, %f4, %f7			! FGA	Group	stall f4,f7 available
+	st	%f7, [%g3 + 0x08]		! LSU
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
+
+	.globl	_mesa_sparc_normalize_normals
+_mesa_sparc_normalize_normals:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+
+	sethi	%hi(ONE_DOT_ZERO), %g2
+	sub	%sp, 16, %sp
+	st	%g2, [%sp + STACK_VAR_OFF+0x0]
+	ld	[%sp + STACK_VAR_OFF+0x0], %f12	! f12 = 1.0f
+	add	%sp, 16, %sp
+
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 cmp	%o3, 0
+	bne	4f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+1:	/* LENGTHS == NULL */
+	ld	[%o5 + 0x00], %f3		! ux = from[0]
+	ld	[%o5 + 0x04], %f5		! uy = from[1]
+	ld	[%o5 + 0x08], %f7		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* f3=tx, f5=ty, f7=tz */
+
+	/* len (f6) = (tx * tx) + (ty * ty) + (tz * tz) */
+	fmuls	%f3, %f3, %f6			! FGM	Group	f3 available
+	fmuls	%f5, %f5, %f8			! FGM	Group	f5 available
+	fmuls	%f7, %f7, %f10			! FGM	Group	f7 available
+	fadds	%f6, %f8, %f6			! FGA	Group	2cyc stall f6,f8 available
+	fadds	%f6, %f10, %f6			! FGA	Group	4cyc stall f6,f10 available
+
+	/* scale (f6) = 1.0 / sqrt(len) */
+	fsqrts	%f6, %f6			! FDIV  20 cycles
+	fdivs	%f12, %f6, %f6			! FDIV	14 cycles
+
+	fmuls	%f3, %f6, %f3
+	st	%f3, [%g3 + 0x00]		! out[i][0] = tx * scale
+	fmuls	%f5, %f6, %f5
+	st	%f5, [%g3 + 0x04]		! out[i][1] = ty * scale
+	fmuls	%f7, %f6, %f7
+	st	%f7, [%g3 + 0x08]		! out[i][2] = tz * scale
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+	ba	7f
+	 nop
+
+4:	/* LENGTHS != NULL */
+
+5:
+	ld	[%o5 + 0x00], %f3		! ux = from[0]
+	ld	[%o5 + 0x04], %f5		! uy = from[1]
+	ld	[%o5 + 0x08], %f7		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	ld	[%o3], %f13			! LSU
+	add	%o3, 4, %o3			! IEU0
+
+	/* f3=tx, f5=ty, f7=tz, f13=lengths[i] */
+
+	fmuls	%f3, %f13, %f3
+	st	%f3, [%g3 + 0x00]		! out[i][0] = tx * len
+	fmuls	%f5, %f13, %f5
+	st	%f5, [%g3 + 0x04]		! out[i][1] = ty * len
+	fmuls	%f7, %f13, %f7
+	st	%f7, [%g3 + 0x08]		! out[i][2] = tz * len
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	5b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
+
+	.globl	_mesa_sparc_rescale_normals
+_mesa_sparc_rescale_normals:
+	/* o0=mat o1=scale o2=in o3=lengths o4=dest */
+
+	sethi	%hi(ONE_DOT_ZERO), %g2
+	sub	%sp, 16, %sp
+	st	%o1, [%sp + STACK_VAR_OFF+0x0]
+	ld	[%sp + STACK_VAR_OFF+0x0], %f15	! f15 = scale
+	add	%sp, 16, %sp
+
+	LDPTR	[%o2 + V4F_START], %o5		! o5 = 'from' in->start
+	ld	[%o2 + V4F_COUNT], %g1		! g1 = in->count
+	ld	[%o2 + V4F_STRIDE], %g2		! g2 = in->stride
+	LDPTR	[%o4 + V4F_START], %g3		! g3 = 'out' dest->start
+
+	/* dest->count = in->count */
+	st	%g1, [%o4 + V4F_COUNT]
+
+	cmp	%g1, 1
+	bl	7f
+	 clr	%o4				! 'i' for STRIDE_LOOP
+
+1:
+	ld	[%o5 + 0x00], %f3		! ux = from[0]
+	ld	[%o5 + 0x04], %f5		! uy = from[1]
+	ld	[%o5 + 0x08], %f7		! uz = from[2]
+	add	%o5, %g2, %o5			! STRIDE_F(from, stride)
+	add	%o4, 1, %o4			! i++
+
+	/* f3=tx, f5=ty, f7=tz */
+
+	fmuls	%f3, %f15, %f3
+	st	%f3, [%g3 + 0x00]		! out[i][0] = tx * scale
+	fmuls	%f5, %f15, %f5
+	st	%f5, [%g3 + 0x04]		! out[i][1] = ty * scale
+	fmuls	%f7, %f15, %f7
+	st	%f7, [%g3 + 0x08]		! out[i][2] = tz * scale
+
+	cmp	%o4, %g1			! continue if (i < count)
+	bl	1b
+	 add	%g3, 0x0c, %g3			! advance out vector pointer
+
+7:	retl
+	 nop
Index: xc/extras/Mesa/src/SPARC/sparc.c
diff -u /dev/null xc/extras/Mesa/src/SPARC/sparc.c:1.2
--- /dev/null	Thu Feb 27 12:15:50 2003
+++ xc/extras/Mesa/src/SPARC/sparc.c	Mon Dec 16 11:18:30 2002
@@ -0,0 +1,176 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ * 
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Sparc assembly code by David S. Miller
+ */
+
+
+#include "context.h"
+#include "math/m_vertices.h"
+#include "math/m_xform.h"
+#include "tnl/t_context.h"
+#include "sparc.h"
+
+#ifdef DEBUG
+#include "math/m_debug.h"
+#endif
+
+#define XFORM_ARGS 	GLvector4f *to_vec, 		\
+			const GLfloat m[16], 		\
+			const GLvector4f *from_vec
+
+#define DECLARE_XFORM_GROUP(pfx, sz)					   \
+ extern void _mesa_##pfx##_transform_points##sz##_general(XFORM_ARGS);     \
+ extern void _mesa_##pfx##_transform_points##sz##_identity(XFORM_ARGS);    \
+ extern void _mesa_##pfx##_transform_points##sz##_3d_no_rot(XFORM_ARGS);   \
+ extern void _mesa_##pfx##_transform_points##sz##_perspective(XFORM_ARGS); \
+ extern void _mesa_##pfx##_transform_points##sz##_2d(XFORM_ARGS);          \
+ extern void _mesa_##pfx##_transform_points##sz##_2d_no_rot(XFORM_ARGS);   \
+ extern void _mesa_##pfx##_transform_points##sz##_3d(XFORM_ARGS);
+
+#define ASSIGN_XFORM_GROUP(pfx, sz)					\
+   _mesa_transform_tab[sz][MATRIX_GENERAL] =				\
+      _mesa_##pfx##_transform_points##sz##_general;			\
+   _mesa_transform_tab[sz][MATRIX_IDENTITY] =				\
+      _mesa_##pfx##_transform_points##sz##_identity;			\
+   _mesa_transform_tab[sz][MATRIX_3D_NO_ROT] =				\
+      _mesa_##pfx##_transform_points##sz##_3d_no_rot;			\
+   _mesa_transform_tab[sz][MATRIX_PERSPECTIVE] =			\
+      _mesa_##pfx##_transform_points##sz##_perspective;			\
+   _mesa_transform_tab[sz][MATRIX_2D] =					\
+      _mesa_##pfx##_transform_points##sz##_2d;				\
+   _mesa_transform_tab[sz][MATRIX_2D_NO_ROT] =				\
+      _mesa_##pfx##_transform_points##sz##_2d_no_rot;			\
+   _mesa_transform_tab[sz][MATRIX_3D] =					\
+      _mesa_##pfx##_transform_points##sz##_3d;
+
+
+#ifdef USE_SPARC_ASM
+DECLARE_XFORM_GROUP(sparc, 1)
+DECLARE_XFORM_GROUP(sparc, 2)
+DECLARE_XFORM_GROUP(sparc, 3)
+DECLARE_XFORM_GROUP(sparc, 4)
+
+extern GLvector4f  *_mesa_sparc_cliptest_points4(GLvector4f *clip_vec,
+						 GLvector4f *proj_vec,
+						 GLubyte clipMask[],
+						 GLubyte *orMask,
+						 GLubyte *andMask);
+
+extern GLvector4f  *_mesa_sparc_cliptest_points4_np(GLvector4f *clip_vec,
+						    GLvector4f *proj_vec,
+						    GLubyte clipMask[],
+						    GLubyte *orMask,
+						    GLubyte *andMask);
+
+#define NORM_ARGS	const GLmatrix *mat,				\
+			GLfloat scale,					\
+			const GLvector3f *in,				\
+			const GLfloat *lengths,				\
+			GLvector3f *dest
+
+extern void _mesa_sparc_transform_normalize_normals(NORM_ARGS);
+extern void _mesa_sparc_transform_normalize_normals_no_rot(NORM_ARGS);
+extern void _mesa_sparc_transform_rescale_normals_no_rot(NORM_ARGS);
+extern void _mesa_sparc_transform_rescale_normals(NORM_ARGS);
+extern void _mesa_sparc_transform_normals_no_rot(NORM_ARGS);
+extern void _mesa_sparc_transform_normals(NORM_ARGS);
+extern void _mesa_sparc_normalize_normals(NORM_ARGS);
+extern void _mesa_sparc_rescale_normals(NORM_ARGS);
+
+#endif
+
+void _mesa_init_all_sparc_transform_asm(void)
+{
+#ifdef USE_SPARC_ASM
+   ASSIGN_XFORM_GROUP(sparc, 1)
+   ASSIGN_XFORM_GROUP(sparc, 2)
+   ASSIGN_XFORM_GROUP(sparc, 3)
+   ASSIGN_XFORM_GROUP(sparc, 4)
+
+#if 0
+   /* Disabled for now.  See Mesa bug report # 544665.  Evidently these
+    * functions are using SPARC registers that shouldn't be touched.
+    */
+   _mesa_clip_tab[4] = _mesa_sparc_cliptest_points4;
+   _mesa_clip_np_tab[4] = _mesa_sparc_cliptest_points4_np;
+#endif
+   _mesa_normal_tab[NORM_TRANSFORM | NORM_NORMALIZE] =
+	   _mesa_sparc_transform_normalize_normals;
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE] =
+	   _mesa_sparc_transform_normalize_normals_no_rot;
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE] =
+	   _mesa_sparc_transform_rescale_normals_no_rot;
+   _mesa_normal_tab[NORM_TRANSFORM | NORM_RESCALE] =
+	   _mesa_sparc_transform_rescale_normals;
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT] =
+	   _mesa_sparc_transform_normals_no_rot;
+   _mesa_normal_tab[NORM_TRANSFORM] =
+	   _mesa_sparc_transform_normals;
+   _mesa_normal_tab[NORM_NORMALIZE] =
+	   _mesa_sparc_normalize_normals;
+   _mesa_normal_tab[NORM_RESCALE] =
+	   _mesa_sparc_rescale_normals;
+
+#ifdef DEBUG
+   _math_test_all_transform_functions("sparc");
+   _math_test_all_cliptest_functions("sparc");
+   _math_test_all_normal_transform_functions("sparc");
+#endif
+
+#endif
+}
+
+extern unsigned int _mesa_sparc_glapi_begin;
+extern unsigned int _mesa_sparc_glapi_end;
+extern void __glapi_sparc_icache_flush(unsigned int *);
+
+void _mesa_init_sparc_glapi_relocs(void)
+{
+	unsigned int *insn_ptr, *end_ptr;
+	unsigned long disp_addr;
+
+	insn_ptr = &_mesa_sparc_glapi_begin;
+	end_ptr = &_mesa_sparc_glapi_end;
+	disp_addr = (unsigned long) &_glapi_Dispatch;
+
+	while (insn_ptr < end_ptr) {
+#ifdef __sparc_v9__
+		insn_ptr[0] |= (disp_addr >> (32 + 10));
+		insn_ptr[1] |= ((disp_addr & 0xffffffff) >> 10);
+		__glapi_sparc_icache_flush(&insn_ptr[0]);
+		insn_ptr[2] |= ((disp_addr >> 32) & ((1 << 10) - 1));
+		insn_ptr[3] |= (disp_addr & ((1 << 10) - 1));
+		__glapi_sparc_icache_flush(&insn_ptr[2]);
+		insn_ptr += 11;
+#else
+		insn_ptr[0] |= (disp_addr >> 10);
+		insn_ptr[1] |= (disp_addr & ((1 << 10) - 1));
+		__glapi_sparc_icache_flush(&insn_ptr[0]);
+		insn_ptr += 5;
+#endif
+	}
+}
Index: xc/extras/Mesa/src/SPARC/sparc.h
diff -u /dev/null xc/extras/Mesa/src/SPARC/sparc.h:1.2
--- /dev/null	Thu Feb 27 12:15:50 2003
+++ xc/extras/Mesa/src/SPARC/sparc.h	Mon Dec 16 11:18:30 2002
@@ -0,0 +1,37 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ * 
+ * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Sparc assembly code by David S. Miller
+ */
+
+
+#ifndef SPARC_H
+#define SPARC_H
+
+extern void _mesa_init_all_sparc_transform_asm(void);
+extern void _mesa_init_sparc_glapi_relocs(void);
+
+#endif /* !(SPARC_H) */
Index: xc/extras/Mesa/src/SPARC/sparc_matrix.h
diff -u /dev/null xc/extras/Mesa/src/SPARC/sparc_matrix.h:1.2
--- /dev/null	Thu Feb 27 12:15:50 2003
+++ xc/extras/Mesa/src/SPARC/sparc_matrix.h	Mon Dec 16 11:18:30 2002
@@ -0,0 +1,167 @@
+
+#ifndef _SPARC_MATRIX_H
+#define _SPARC_MATRIX_H
+
+#ifdef __sparc_v9__
+#define LDPTR		ldx
+#define MAT_M		0x00
+#define MAT_INV		0x08
+#define V4F_DATA	0x00
+#define V4F_START	0x08
+#define V4F_COUNT	0x10
+#define V4F_STRIDE	0x14
+#define V4F_SIZE	0x18
+#define V4F_FLAGS	0x1c
+#else
+#define LDPTR		ld
+#define MAT_M		0x00
+#define MAT_INV		0x04
+#define V4F_DATA	0x00
+#define V4F_START	0x04
+#define V4F_COUNT	0x08
+#define V4F_STRIDE	0x0c
+#define V4F_SIZE	0x10
+#define V4F_FLAGS	0x14
+#endif
+
+#define VEC_SIZE_1   	1
+#define VEC_SIZE_2   	3
+#define VEC_SIZE_3   	7
+#define VEC_SIZE_4   	15
+
+#define M0		%f16
+#define M1		%f17
+#define M2		%f18
+#define M3		%f19
+#define M4		%f20
+#define M5		%f21
+#define M6		%f22
+#define M7		%f23
+#define M8		%f24
+#define M9		%f25
+#define M10		%f26
+#define M11		%f27
+#define M12		%f28
+#define M13		%f29
+#define M14		%f30
+#define M15		%f31
+
+#define LDMATRIX_0_1_2_3_12_13_14_15(BASE)	\
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + ( 2 * 0x4)], M2;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ldd	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_1_12_13(BASE)		\
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + (12 * 0x4)], M12
+
+#define LDMATRIX_0_12_13(BASE)			\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + (12 * 0x4)], M12
+
+#define LDMATRIX_0_1_2_12_13_14(BASE)		\
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 2 * 0x4)], M2;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_12_13_14(BASE)		\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_14(BASE)			\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_1_2_3_4_5_6_7_12_13_14_15(BASE) \
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + ( 2 * 0x4)], M2;	\
+	ldd	[BASE + ( 4 * 0x4)], M4;	\
+	ldd	[BASE + ( 6 * 0x4)], M6;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ldd	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_5_12_13(BASE) 		\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 5 * 0x4)], M5;	\
+	ldd	[BASE + (12 * 0x4)], M12
+
+#define LDMATRIX_0_1_2_3_4_5_6_12_13_14(BASE)	\
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + ( 2 * 0x4)], M2;	\
+	ldd	[BASE + ( 4 * 0x4)], M4;	\
+	ld	[BASE + ( 6 * 0x4)], M6;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_5_12_13_14(BASE)		\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 5 * 0x4)], M5;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_5_14(BASE)			\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 5 * 0x4)], M5;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_1_2_3_4_5_6_7_8_9_10_11_12_13_14_15(BASE) \
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + ( 2 * 0x4)], M2;	\
+	ldd	[BASE + ( 4 * 0x4)], M4;	\
+	ldd	[BASE + ( 6 * 0x4)], M6;	\
+	ldd	[BASE + ( 8 * 0x4)], M8;	\
+	ldd	[BASE + (10 * 0x4)], M10;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ldd	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_1_4_5_12_13(BASE) 		\
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ldd	[BASE + ( 4 * 0x4)], M4;	\
+	ldd	[BASE + (12 * 0x4)], M12
+
+#define LDMATRIX_0_5_12_13(BASE) 		\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 5 * 0x4)], M5;	\
+	ldd	[BASE + (12 * 0x4)], M12
+
+#define LDMATRIX_0_1_2_4_5_6_8_9_10(BASE) \
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 2 * 0x4)], M2;	\
+	ldd	[BASE + ( 4 * 0x4)], M4;	\
+	ld	[BASE + ( 6 * 0x4)], M6;	\
+	ldd	[BASE + ( 8 * 0x4)], M8;	\
+	ld	[BASE + (10 * 0x4)], M10
+
+#define LDMATRIX_0_1_2_4_5_6_8_9_10_12_13_14(BASE) \
+	ldd	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 2 * 0x4)], M2;	\
+	ldd	[BASE + ( 4 * 0x4)], M4;	\
+	ld	[BASE + ( 6 * 0x4)], M6;	\
+	ldd	[BASE + ( 8 * 0x4)], M8;	\
+	ld	[BASE + (10 * 0x4)], M10;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_5_10(BASE) 			\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 5 * 0x4)], M5;	\
+	ld	[BASE + (10 * 0x4)], M10;	\
+
+#define LDMATRIX_0_5_10_12_13_14(BASE) 		\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 5 * 0x4)], M5;	\
+	ld	[BASE + (10 * 0x4)], M10;	\
+	ldd	[BASE + (12 * 0x4)], M12;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#define LDMATRIX_0_5_8_9_10_14(BASE) 		\
+	ld	[BASE + ( 0 * 0x4)], M0;	\
+	ld	[BASE + ( 5 * 0x4)], M5;	\
+	ldd	[BASE + ( 8 * 0x4)], M8;	\
+	ld	[BASE + (10 * 0x4)], M10;	\
+	ld	[BASE + (14 * 0x4)], M14
+
+#endif /* !(_SPARC_MATRIX_H) */
Index: xc/extras/Mesa/src/SPARC/xform.S
diff -u /dev/null xc/extras/Mesa/src/SPARC/xform.S:1.2
--- /dev/null	Thu Feb 27 12:15:50 2003
+++ xc/extras/Mesa/src/SPARC/xform.S	Mon Dec 16 11:18:30 2002
@@ -0,0 +1,1386 @@
+
+	/* TODO
+	 *
+	 * 1) It would be nice if load/store double could be used
+	 *    at least for the matrix parts.  I think for the matrices
+	 *    it is safe, but for the vertices it probably is not due to
+	 *    things like glInterleavedArrays etc.
+	 *
+	 *    UPDATE: Trying this now in sparc_matrix.h -DaveM_990624
+	 *
+	 * 2) One extremely slick trick would be if we could enclose
+	 *    groups of xform calls on the same vertices such that
+	 *    we just load the matrix into f16-->f31 before the calls
+	 *    and then we would not have to do them here.  This may be
+	 *    tricky and not much of a gain though.
+	 */
+
+#include "sparc_matrix.h"
+
+	.text
+	.align	64
+
+__set_v4f_1:
+	ld	[%o0 + V4F_FLAGS], %g2
+	mov	1, %g1
+	st	%g1, [%o0 + V4F_SIZE]
+	or	%g2, VEC_SIZE_1, %g2
+	retl
+	 st	%g2, [%o0 + V4F_FLAGS]
+__set_v4f_2:
+	ld	[%o0 + V4F_FLAGS], %g2
+	mov	2, %g1
+	st	%g1, [%o0 + V4F_SIZE]
+	or	%g2, VEC_SIZE_2, %g2
+	retl
+	 st	%g2, [%o0 + V4F_FLAGS]
+__set_v4f_3:
+	ld	[%o0 + V4F_FLAGS], %g2
+	mov	3, %g1
+	st	%g1, [%o0 + V4F_SIZE]
+	or	%g2, VEC_SIZE_3, %g2
+	retl
+	 st	%g2, [%o0 + V4F_FLAGS]
+__set_v4f_4:
+	ld	[%o0 + V4F_FLAGS], %g2
+	mov	4, %g1
+	st	%g1, [%o0 + V4F_SIZE]
+	or	%g2, VEC_SIZE_4, %g2
+	retl
+	 st	%g2, [%o0 + V4F_FLAGS]
+
+	/* First the raw versions. */
+
+	.globl	_mesa_sparc_transform_points1_general
+_mesa_sparc_transform_points1_general:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_3_12_13_14_15(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	ld	[%g1 + 0x00], %f8	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f1		! FGM	Group	1-cycle stall on %f0
+	fmuls	%f0, M1, %f2		! FGM	Group
+	fmuls	%f0, M2, %f3		! FGM	Group
+	fmuls	%f0, M3, %f4		! FGM	Group
+	fmuls	%f8, M0, %f9		! FGM	Group	f1 available
+	fadds	%f1, M12, %f1		! FGA
+	st	%f1, [%g2 + 0x00]	! LSU
+	fmuls	%f8, M1, %f10		! FGM	Group	f2 available
+	fadds	%f2, M13, %f2		! FGA
+	st	%f2, [%g2 + 0x04]	! LSU
+	fmuls	%f8, M2, %f11		! FGM	Group	f3 available
+	fadds	%f3, M14, %f3		! FGA
+	st	%f3, [%g2 + 0x08]	! LSU
+	fmuls	%f8, M3, %f12		! FGM	Group	f4 available
+	fadds	%f4, M15, %f4		! FGA
+	st	%f4, [%g2 + 0x0c]	! LSU
+	fadds	%f9, M12, %f9		! FGA	Group	f9 available
+	st	%f9, [%g2 + 0x10]	! LSU
+	fadds	%f10, M13, %f10		! FGA	Group	f10 available
+	st	%f10, [%g2 + 0x14]	! LSU
+	fadds	%f11, M14, %f11		! FGA	Group	f11 available
+	st	%f11, [%g2 + 0x18]	! LSU
+	fadds	%f12, M15, %f12		! FGA	Group	f12 available
+	st	%f12, [%g2 + 0x1c]	! LSU
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	fmuls	%f0, M0, %f1		! FGM	Group	1-cycle stall on %f0
+	fmuls	%f0, M1, %f2		! FGM	Group
+	fmuls	%f0, M2, %f3		! FGM	Group
+	fmuls	%f0, M3, %f4		! FGM	Group
+	fadds	%f1, M12, %f1		! FGA	Group
+	st	%f1, [%g2 + 0x00]	! LSU
+	fadds	%f2, M13, %f2		! FGA	Group
+	st	%f2, [%g2 + 0x04]	! LSU
+	fadds	%f3, M14, %f3		! FGA	Group
+	st	%f3, [%g2 + 0x08]	! LSU
+	fadds	%f4, M15, %f4		! FGA	Group
+	st	%f4, [%g2 + 0x0c]	! LSU
+
+3:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points1_identity
+_mesa_sparc_transform_points1_identity:
+	cmp	%o0, %o2
+	be	4f
+	 ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	ld	[%g1 + 0x00], %f1	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	st	%f0, [%g2 + 0x00]	! LSU	Group
+	cmp	%o1, %o2		! IEU1
+	st	%f1, [%g2 + 0x10]	! LSU	Group
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0
+	addx	%g0, %g0, %g0
+	st	%f0, [%g2 + 0x00]
+
+3:
+	ba	__set_v4f_1
+	 nop
+
+4:	retl
+	 nop
+
+	.globl	_mesa_sparc_transform_points1_2d
+_mesa_sparc_transform_points1_2d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_12_13(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	ld	[%g1 + 0x00], %f8	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f1		! FGM	Group
+	fmuls	%f0, M1, %f2		! FGM	Group
+	fmuls	%f8, M0, %f9		! FGM	Group
+	fmuls	%f8, M1, %f10		! FGM	Group
+	fadds	%f1, M12, %f3		! FGA	Group	f1 available
+	st	%f3, [%g2 + 0x00]	! LSU
+	fadds	%f2, M13, %f4		! FGA	Group	f2 available
+	st	%f4, [%g2 + 0x04]	! LSU
+	fadds	%f9, M12, %f11		! FGA	Group	f9 available
+	st	%f11, [%g2 + 0x10]	! LSU
+	fadds	%f10, M13, %f12		! FGA	Group	f10 available
+	st	%f12, [%g2 + 0x14]	! LSU
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0
+	fmuls	%f0, M0, %f1
+	fmuls	%f0, M1, %f2
+	fadds	%f1, M12, %f3
+	st	%f3, [%g2 + 0x00]
+	fadds	%f2, M13, %f4
+	st	%f4, [%g2 + 0x04]
+
+3:
+	ba	__set_v4f_2
+	 nop
+
+	.globl	_mesa_sparc_transform_points1_2d_no_rot
+_mesa_sparc_transform_points1_2d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_12_13(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	ld	[%g1 + 0x00], %f4	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f1		! FGM	Group
+	fmuls	%f4, M0, %f5		! FGM	Group
+	fadds	%f1, M12, %f3		! FGA	Group, 2 cycle stall, f1 available
+	st	%f3, [%g2 + 0x00]	! LSU
+	st	M13, [%g2 + 0x04]	! LSU	Group, f5 available
+	fadds	%f5, M12, %f6		! FGA
+	st	%f6, [%g2 + 0x10]	! LSU	Group
+	st	M13, [%g2 + 0x14]	! LSU	Group
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0
+	fmuls	%f0, M0, %f1
+	fadds	%f1, M12, %f3
+	st	%f3, [%g2 + 0x00]
+	st	M13, [%g2 + 0x04]
+
+3:
+	ba	__set_v4f_2
+	 nop
+
+	.globl	_mesa_sparc_transform_points1_3d
+_mesa_sparc_transform_points1_3d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_12_13_14(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	ld	[%g1 + 0x00], %f4	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f1		! FGM	Group
+	fmuls	%f0, M1, %f2		! FGM	Group
+	fmuls	%f0, M2, %f3		! FGM	Group
+	fmuls	%f4, M0, %f5		! FGM	Group
+	fadds	%f1, M12, %f1		! FGA	Group, f1 available
+	st	%f1, [%g2 + 0x00]	! LSU
+	fmuls	%f4, M1, %f6		! FGM
+	fadds	%f2, M13, %f2		! FGA	Group, f2 available
+	st	%f2, [%g2 + 0x04]	! LSU
+	fmuls	%f4, M2, %f7		! FGM
+	fadds	%f3, M14, %f3		! FGA	Group, f3 available
+	st	%f3, [%g2 + 0x08]	! LSU
+	fadds	%f5, M12, %f5		! FGA	Group, f5 available
+	st	%f5, [%g2 + 0x10]	! LSU
+	fadds	%f6, M13, %f6		! FGA	Group, f6 available
+	st	%f6, [%g2 + 0x14]	! LSU
+	fadds	%f7, M14, %f7		! FGA	Group, f7 available
+	st	%f7, [%g2 + 0x18]	! LSU
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0
+	fmuls	%f0, M0, %f1
+	fmuls	%f0, M1, %f2
+	fmuls	%f0, M2, %f3
+	fadds	%f1, M12, %f1
+	st	%f1, [%g2 + 0x00]
+	fadds	%f2, M13, %f2
+	st	%f2, [%g2 + 0x04]
+	fadds	%f3, M14, %f3
+	st	%f3, [%g2 + 0x08]
+
+3:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points1_3d_no_rot
+_mesa_sparc_transform_points1_3d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_12_13_14(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	ld	[%g1 + 0x00], %f2	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f1		! FGM	Group
+	fmuls	%f2, M0, %f3		! FGM	Group
+	fadds	%f1, M12, %f1		! FGA	Group, 2 cycle stall, f1 available
+	st	%f1, [%g2 + 0x00]	! LSU
+	fadds	%f3, M12, %f3		! FGA	Group, f3 available
+	st	M13, [%g2 + 0x04]	! LSU
+	st	M14, [%g2 + 0x08]	! LSU	Group
+	st	%f3, [%g2 + 0x10]	! LSU	Group
+	st	M13, [%g2 + 0x14]	! LSU	Group
+	st	M14, [%g2 + 0x18]	! LSU	Group
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0
+	fmuls	%f0, M0, %f1
+	fadds	%f1, M12, %f1
+	st	%f1, [%g2 + 0x00]
+	st	M13, [%g2 + 0x04]
+	st	M14, [%g2 + 0x08]
+
+3:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points1_perspective
+_mesa_sparc_transform_points1_perspective:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_14(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	ld	[%g1 + 0x00], %f2	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f1		! FGM	Group
+	st	%f1, [%g2 + 0x00]	! LSU
+	fmuls	%f2, M0, %f3		! FGM	Group
+	st	%g0, [%g2 + 0x04]	! LSU
+	st	M14, [%g2 + 0x08]	! LSU	Group
+	st	%g0, [%g2 + 0x0c]	! LSU	Group
+	st	%f3, [%g2 + 0x10]	! LSU	Group
+	st	%g0, [%g2 + 0x14]	! LSU	Group
+	st	M14, [%g2 + 0x18]	! LSU	Group
+	st	%g0, [%g2 + 0x1c]	! LSU	Group
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0
+	fmuls	%f0, M0, %f1
+	st	%f1, [%g2 + 0x00]
+	st	%g0, [%g2 + 0x04]
+	st	M14, [%g2 + 0x08]
+	st	%g0, [%g2 + 0x0c]
+
+3:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points2_general
+_mesa_sparc_transform_points2_general:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_3_4_5_6_7_12_13_14_15(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f2		! FGM	Group
+	fmuls	%f0, M1, %f3		! FGM	Group
+	fmuls	%f0, M2, %f4		! FGM	Group
+	fmuls	%f0, M3, %f5		! FGM	Group
+	fadds	%f2, M12, %f2		! FGA	Group	f2 available
+	fmuls	%f1, M4, %f6		! FGM
+	fadds	%f3, M13, %f3		! FGA	Group	f3 available
+	fmuls	%f1, M5, %f7		! FGM
+	fadds	%f4, M14, %f4		! FGA	Group	f4 available
+	fmuls	%f1, M6, %f8		! FGM
+	fadds	%f5, M15, %f5		! FGA	Group	f5 available
+	fmuls	%f1, M7, %f9		! FGM
+	fadds	%f2, %f6, %f2		! FGA	Group	f6 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f3, %f7, %f3		! FGA	Group	f7 available
+	st	%f3, [%g2 + 0x04]	! LSU
+	fadds	%f4, %f8, %f4		! FGA	Group	f8 available
+	st	%f4, [%g2 + 0x08]	! LSU
+	fadds	%f5, %f9, %f5		! FGA	Group	f9 available
+	st	%f5, [%g2 + 0x0c]	! LSU
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points2_identity
+_mesa_sparc_transform_points2_identity:
+	cmp	%o2, %o0
+	be	3f
+	 ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	add	%g1, %o5, %g1		! IEU0
+	cmp	%o1, %g3		! IEU1
+	st	%f0, [%g2 + 0x00]	! LSU	Group
+	st	%f1, [%g2 + 0x04]	! LSU	Group
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0
+2:
+	ba	__set_v4f_2
+	 nop
+
+3:	retl
+	 nop
+
+	.globl	_mesa_sparc_transform_points2_2d
+_mesa_sparc_transform_points2_2d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_4_5_12_13(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f2		! FGM
+	ld	[%g1 + 0x00], %f8	! LSU	Group
+	fmuls	%f0, M1, %f3		! FGM
+	ld	[%g1 + 0x04], %f9	! LSU	Group
+	fmuls	%f1, M4, %f6		! FGM
+	fmuls	%f1, M5, %f7		! FGM	Group
+	add	%g1, %o5, %g1		! IEU0
+	fmuls	%f8, M0, %f10		! FGM	Group	f2 available
+	fadds	%f2, M12, %f2		! FGA
+	fmuls	%f8, M1, %f11		! FGM	Group	f3 available
+	fadds	%f3, M13, %f3		! FGA
+	fmuls	%f9, M4, %f12		! FGM	Group
+	fmuls	%f9, M5, %f13		! FGM	Group
+	fadds	%f10, M12, %f10		! FGA	Group	f2, f10 available
+	fadds	%f2, %f6, %f2		! FGA	Group	f3, f11 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f11, M13, %f11		! FGA	Group	f12 available
+	fadds	%f3, %f7, %f3		! FGA	Group	f13 available
+	st	%f3, [%g2 + 0x04]	! LSU
+	fadds	%f10, %f12, %f10	! FGA	Group	f10 available
+	st	%f10, [%g2 + 0x10]	! LSU
+	fadds	%f11, %f13, %f11	! FGA	Group	f11 available
+	st	%f11, [%g2 + 0x14]	! LSU
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	fmuls	%f0, M0, %f2		! FGM	Group
+	fmuls	%f0, M1, %f3		! FGM	Group
+	fmuls	%f1, M4, %f6		! FGM	Group
+	fmuls	%f1, M5, %f7		! FGM	Group
+	fadds	%f2, M12, %f2		! FGA	Group	f2 available
+	fadds	%f3, M13, %f3		! FGA	Group	f3 available
+	fadds	%f2, %f6, %f2		! FGA	Group	2 cycle stall, f2 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f3, %f7, %f3		! FGA	Group	f3 available
+	st	%f3, [%g2 + 0x04]	! LSU
+
+3:
+	ba	__set_v4f_2
+	 nop
+
+	.globl	_mesa_sparc_transform_points2_2d_no_rot
+_mesa_sparc_transform_points2_2d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_12_13(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	ld	[%g1 + 0x00], %f4	! LSU	Group
+	fmuls	%f0, M0, %f2		! FGM
+	ld	[%g1 + 0x04], %f5	! LSU	Group
+	fmuls	%f1, M5, %f3		! FGM
+	fmuls	%f4, M0, %f6		! FGM	Group
+	add	%g1, %o5, %g1		! IEU0
+	fmuls	%f5, M5, %f7		! FGM	Group
+	fadds	%f2, M12, %f2		! FGA	Group	f2 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f3, M13, %f3		! FGA	Group	f3 available
+	st	%f3, [%g2 + 0x04]	! LSU
+	fadds	%f6, M12, %f6		! FGA	Group	f6 available
+	st	%f6, [%g2 + 0x10]	! LSU
+	fadds	%f7, M13, %f7		! FGA	Group	f7 available
+	st	%f7, [%g2 + 0x14]	! LSU
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	fmuls	%f0, M0, %f2		! FGM	Group
+	fmuls	%f1, M5, %f3		! FGM	Group
+	fadds	%f2, M12, %f2		! FGA	Group, 2 cycle stall, f2 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f3, M13, %f3		! FGA	Group	f3 available
+	st	%f3, [%g2 + 0x04]	! LSU
+
+3:
+	ba	__set_v4f_2
+	 nop
+
+	/* orig: 12 cycles */
+	.globl	_mesa_sparc_transform_points2_3d
+_mesa_sparc_transform_points2_3d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	ld	[%o2 + V4F_START], %g1
+	ld	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_3_4_5_6_12_13_14(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o1
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	add	%o1, 2, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	ld	[%g1 + 0x00], %f9	! LSU	Group
+	fmuls	%f0, M0, %f2		! FGM
+	ld	[%g1 + 0x04], %f10	! LSU	Group
+	fmuls	%f0, M1, %f3		! FGM
+	fmuls	%f0, M2, %f4		! FGM	Group
+	add	%g1, %o5, %g1		! IEU0
+	fmuls	%f1, M4, %f6		! FGM	Group
+	fmuls	%f1, M5, %f7		! FGM	Group	f2 available
+	fadds	%f2, M12, %f2		! FGA
+	fmuls	%f1, M6, %f8		! FGM	Group	f3 available
+	fadds	%f3, M13, %f3		! FGA
+	fmuls	%f9, M0, %f11		! FGM	Group	f4 available
+	fadds	%f4, M14, %f4		! FGA
+	fmuls	%f9, M1, %f12		! FGM	Group	f6 available
+	fmuls	%f9, M2, %f13		! FGM	Group	f2, f7 available
+	fadds	%f2, %f6, %f2		! FGA
+	st	%f2, [%g2 + 0x00]	! LSU
+	fmuls	%f10, M4, %f14		! FGM	Group	f3, f8 available
+	fadds	%f3, %f7, %f3		! FGA
+	st	%f3, [%g2 + 0x04]	! LSU
+	fmuls	%f10, M5, %f15		! FGM	Group	f4, f11 available
+	fadds	%f11, M12, %f11		! FGA
+	fmuls	%f10, M6, %f0		! FGM	Group	f12 available
+	fadds	%f12, M13, %f12		! FGA
+	fadds	%f13, M14, %f13		! FGA	Group	f13 available
+	fadds	%f4, %f8, %f4		! FGA	Group	f14 available
+	st	%f4, [%g2 + 0x08]	! LSU
+	fadds	%f11, %f14, %f11	! FGA	Group	f15, f11 available
+	st	%f11, [%g2 + 0x10]	! LSU
+	fadds	%f12, %f15, %f12	! FGA	Group	f0, f12 available
+	st	%f12, [%g2 + 0x14]	! LSU
+	fadds	%f13, %f0, %f13		! FGA	Group	f13 available
+	st	%f13, [%g2 + 0x18]	! LSU
+
+	cmp	%o1, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o1, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	fmuls	%f0, M0, %f2		! FGM	Group
+	fmuls	%f0, M1, %f3		! FGM	Group
+	fmuls	%f0, M2, %f4		! FGM	Group
+	fmuls	%f1, M4, %f6		! FGM	Group
+	fmuls	%f1, M5, %f7		! FGM	Group	f2 available
+	fadds	%f2, M12, %f2		! FGA
+	fmuls	%f1, M6, %f8		! FGM	Group	f3 available
+	fadds	%f3, M13, %f3		! FGA
+	fadds	%f4, M14, %f4		! FGA	Group	f4 available
+	fadds	%f2, %f6, %f2		! FGA	Group	stall, f2, f6, f7 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f3, %f7, %f3		! FGA	Group	f3, f8 available
+	st	%f3, [%g2 + 0x04]	! LSU
+	fadds	%f4, %f8, %f4		! FGA	Group	f4 available
+	st	%f4, [%g2 + 0x08]	! LSU
+
+3:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points2_3d_no_rot
+_mesa_sparc_transform_points2_3d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_12_13_14(%o1)
+
+	cmp	%g3, 1
+	st	%g3, [%o0 + V4F_COUNT]
+	bl	3f
+	 clr	%o3
+
+	be	2f
+	 andn	%g3, 1, %o2
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	add	%o3, 2, %o3		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	ld	[%g1 + 0x00], %f4	! LSU	Group
+	fmuls	%f0, M0, %f2		! FGM
+	ld	[%g1 + 0x04], %f5	! LSU	Group
+	fmuls	%f1, M5, %f3		! FGM
+	fmuls	%f4, M0, %f6		! FGM	Group
+	add	%g1, %o5, %g1		! IEU0
+	fmuls	%f5, M5, %f7		! FGM	Group
+	fadds	%f2, M12, %f2		! FGA	Group	f2 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f3, M13, %f3		! FGA	Group	f3 available
+	st	%f3, [%g2 + 0x04]	! LSU
+	fadds	%f6, M12, %f6		! FGA	Group	f6 available
+	st	M14, [%g2 + 0x08]	! LSU
+	fadds	%f7, M13, %f7		! FGA	Group	f7 available
+	st	%f6, [%g2 + 0x10]	! LSU
+	st	%f7, [%g2 + 0x14]	! LSU	Group
+	st	M14, [%g2 + 0x18]	! LSU	Group
+	cmp	%o3, %o2		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x20, %g2		! IEU0	Group
+
+	cmp	%o3, %g3
+	be	3f
+	 nop
+
+2:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	fmuls	%f0, M0, %f2		! FGM	Group
+	fmuls	%f1, M5, %f3		! FGM	Group
+	fadds	%f2, M12, %f2		! FGA	Group, 2 cycle stall, f2 available
+	st	%f2, [%g2 + 0x00]	! LSU
+	fadds	%f3, M13, %f3		! FGA	Group	f3 available
+	st	%f3, [%g2 + 0x04]	! LSU
+	st	M14, [%g2 + 0x08]	! LSU	Group
+
+3:	ld	[%o1 + (14 * 0x4)], %g3
+	cmp	%g3, 0
+	bne	__set_v4f_3
+	 nop
+	ba	__set_v4f_2
+	 nop
+
+	.globl	_mesa_sparc_transform_points2_perspective
+_mesa_sparc_transform_points2_perspective:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_14(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0
+	ld	[%g1 + 0x04], %f1
+	add	%o1, 1, %o1
+	add	%g1, %o5, %g1
+	fmuls	%f0, M0, %f2
+	st	%f2, [%g2 + 0x00]
+	fmuls	%f1, M5, %f3
+	st	%f3, [%g2 + 0x04]
+	st	M14, [%g2 + 0x08]
+	st	%g0, [%g2 + 0x0c]
+	cmp	%o1, %g3
+	bne	1b
+	 add	%g2, 0x10, %g2
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points3_general
+_mesa_sparc_transform_points3_general:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_3_4_5_6_7_8_9_10_11_12_13_14_15(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f3		! FGM
+	fmuls	%f1, M4, %f7		! FGM	Group
+	fmuls	%f0, M1, %f4		! FGM	Group
+	fmuls	%f1, M5, %f8		! FGM	Group
+	fmuls	%f0, M2, %f5		! FGM	Group	f3 available
+	fmuls	%f1, M6, %f9		! FGM	Group	f7 available
+	fadds	%f3, %f7, %f3		! FGA
+	fmuls	%f0, M3, %f6		! FGM	Group	f4 available
+	fmuls	%f1, M7, %f10		! FGM	Group	f8 available
+	fadds	%f4, %f8, %f4		! FGA
+	fmuls	%f2, M8, %f7		! FGM	Group	f5 available
+	fmuls	%f2, M9, %f8		! FGM	Group	f9,f3 available
+	fadds	%f5, %f9, %f5		! FGA
+	fmuls	%f2, M10, %f9		! FGM	Group	f6 available
+	fadds	%f6, %f10, %f6		! FGA	Group	f10,f4 available
+	fmuls	%f2, M11, %f10		! FGM
+	fadds	%f3, M12, %f3		! FGA	Group	f7 available
+	fadds	%f4, M13, %f4		! FGA	Group	f8,f5 available
+	fadds	%f5, M14, %f5		! FGA	Group	f9 available
+	fadds	%f6, M15, %f6		! FGA	Group	f10,f6 available
+	fadds	%f3, %f7, %f3		! FGA	Group	f3 available
+	st	%f3, [%g2 + 0x00]	! LSU
+	fadds	%f4, %f8, %f4		! FGA	Group	f4 available
+	st	%f4, [%g2 + 0x04]	! LSU
+	fadds	%f5, %f9, %f5		! FGA	Group	f5 available
+	st	%f5, [%g2 + 0x08]	! LSU
+	fadds	%f6, %f10, %f6		! FGA	Group	f6 available
+	st	%f6, [%g2 + 0x0c]	! LSU
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points3_identity
+_mesa_sparc_transform_points3_identity:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0
+	ld	[%g1 + 0x04], %f1
+	ld	[%g1 + 0x08], %f2
+	add	%o1, 1, %o1
+	add	%g1, %o5, %g1
+	cmp	%o1, %g3
+	st	%f0, [%g2 + 0x00]
+	st	%f1, [%g2 + 0x04]
+	st	%f2, [%g2 + 0x08]
+	bne	1b
+	 add	%g2, 0x10, %g2
+2:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points3_2d
+_mesa_sparc_transform_points3_2d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_4_5_12_13(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f3		! FGM
+	fmuls	%f0, M1, %f4		! FGM	Group
+	fmuls	%f1, M4, %f6		! FGM	Group
+	fmuls	%f1, M5, %f7		! FGM	Group
+	fadds	%f3, M12, %f3		! FGA	Group	f3 available
+	fadds	%f4, M13, %f4		! FGA	Group	f4 available
+	fadds	%f3, %f6, %f3		! FGA	Group	f6 available
+	st	%f3, [%g2 + 0x00]	! LSU
+	fadds	%f4, %f7, %f4		! FGA	Group	f7 available
+	st	%f4, [%g2 + 0x04]	! LSU
+	st	%f2, [%g2 + 0x08]	! LSU	Group
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points3_2d_no_rot
+_mesa_sparc_transform_points3_2d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_12_13(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f3		! FGM
+	fmuls	%f1, M5, %f4		! FGM	Group
+	st	%f2, [%g2 + 0x08]	! LSU
+	fadds	%f3, M12, %f3		! FGA	Group
+	st	%f3, [%g2 + 0x00]	! LSU
+	fadds	%f4, M13, %f4		! FGA	Group
+	st	%f4, [%g2 + 0x04]	! LSU
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points3_3d
+_mesa_sparc_transform_points3_3d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_4_5_6_8_9_10_12_13_14(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f3		! FGM
+	fmuls	%f1, M4, %f6		! FGM	Group
+	fmuls	%f0, M1, %f4		! FGM	Group
+	fmuls	%f1, M5, %f7		! FGM	Group
+	fmuls	%f0, M2, %f5		! FGM	Group	f3 available
+	fmuls	%f1, M6, %f8		! FGM	Group	f6 available
+	fadds	%f3, %f6, %f3		! FGA
+	fmuls	%f2, M8, %f9		! FGM	Group	f4 available
+	fmuls	%f2, M9, %f10		! FGM	Group	f7 available
+	fadds	%f4, %f7, %f4		! FGA
+	fmuls	%f2, M10, %f11		! FGM	Group	f5 available
+	fadds	%f5, %f8, %f5		! FGA	Group	f8, f3 available
+	fadds	%f3, %f9, %f3		! FGA	Group	f9 available
+	fadds	%f4, %f10, %f4		! FGA	Group	f10, f4 available
+	fadds	%f5, %f11, %f5		! FGA	Group	stall, f11, f5 available
+	fadds	%f3, M12, %f3		! FGA	Group	f3 available
+	st	%f3, [%g2 + 0x00]	! LSU
+	fadds	%f4, M13, %f4		! FGA	Group	f4 available
+	st	%f4, [%g2 + 0x04]	! LSU
+	fadds	%f5, M14, %f5		! FGA	Group	f5 available
+	st	%f5, [%g2 + 0x08]	! LSU
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points3_3d_no_rot
+_mesa_sparc_transform_points3_3d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_10_12_13_14(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	cmp	%o1, %g3		! IEU1	Group
+	fmuls	%f0, M0, %f3		! FGM
+	fmuls	%f1, M5, %f4		! FGM	Group
+	fmuls	%f2, M10, %f5		! FGM	Group
+	fadds	%f3, M12, %f3		! FGA	Group, stall, f3 available
+	st	%f3, [%g2 + 0x00]	! LSU
+	fadds	%f4, M13, %f4		! FGA	Group, f4 available
+	st	%f4, [%g2 + 0x04]	! LSU
+	fadds	%f5, M14, %f5		! FGA	Group, f5 available
+	st	%f5, [%g2 + 0x08]	! LEU
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_3
+	 nop
+
+	.globl	_mesa_sparc_transform_points3_perspective
+_mesa_sparc_transform_points3_perspective:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_8_9_10_14(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f3		! FGM
+	fmuls	%f2, M8, %f6		! FGM	Group
+	fmuls	%f1, M5, %f4		! FGM	Group
+	fmuls	%f2, M9, %f7		! FGM	Group
+	fmuls	%f2, M10, %f5		! FGM	Group	f3 available
+	fadds	%f3, %f6, %f3		! FGA	Group	f6 available
+	st	%f3, [%g2 + 0x00]	! LSU
+	fadds	%f4, %f7, %f4		! FGA	Group	stall, f4, f7 available
+	st	%f4, [%g2 + 0x04]	! LSU
+	fadds	%f5, M14, %f5		! FGA	Group
+	st	%f5, [%g2 + 0x08]	! LSU
+	fnegs	%f2, %f6		! FGA	Group
+	st	%f6, [%g2 + 0x0c]	! LSU
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points4_general
+_mesa_sparc_transform_points4_general:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_3_4_5_6_7_8_9_10_11_12_13_14_15(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	ld	[%g1 + 0x0c], %f3	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f4		! FGM	Group
+	fmuls	%f1, M4, %f8		! FGM	Group
+	fmuls	%f0, M1, %f5		! FGM	Group
+	fmuls	%f1, M5, %f9		! FGM	Group
+	fmuls	%f0, M2, %f6		! FGM	Group	f4 available
+	fmuls	%f1, M6, %f10		! FGM	Group	f8 available
+	fadds	%f4, %f8, %f4		! FGA
+	fmuls	%f0, M3, %f7		! FGM	Group	f5 available
+	fmuls	%f1, M7, %f11		! FGM	Group	f9 available
+	fadds	%f5, %f9, %f5		! FGA
+	fmuls	%f2, M8, %f12		! FGM	Group	f6 available
+	fmuls	%f2, M9, %f13		! FGM	Group	f10, f4 available
+	fadds	%f6, %f10, %f6		! FGA
+	fmuls	%f2, M10, %f14		! FGM	Group	f7 available
+	fmuls	%f2, M11, %f15		! FGM	Group	f11, f5 available
+	fadds	%f7, %f11, %f7		! FGA
+	fmuls	%f3, M12, %f8		! FGM	Group	f12 available
+	fadds	%f4, %f12, %f4		! FGA
+	fmuls	%f3, M13, %f9		! FGM	Group	f13, f6 available
+	fadds	%f5, %f13, %f5		! FGA
+	fmuls	%f3, M14, %f10		! FGM	Group	f14 available
+	fadds	%f6, %f14, %f6		! FGA
+	fmuls	%f3, M15, %f11		! FGM	Group	f15, f7 available
+	fadds	%f7, %f15, %f7		! FGA
+	fadds	%f4, %f8, %f4		! FGA	Group	f8, f4 available
+	st	%f4, [%g2 + 0x00]	! LSU
+	fadds	%f5, %f9, %f5		! FGA	Group	f9, f5 available
+	st	%f5, [%g2 + 0x04]	! LSU
+	fadds	%f6, %f10, %f6		! FGA	Group	f10, f6 available
+	st	%f6, [%g2 + 0x08]	! LSU
+	fadds	%f7, %f11, %f7		! FGA	Group	f11, f7 available
+	st	%f7, [%g2 + 0x0c]	! LSU
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points4_identity
+_mesa_sparc_transform_points4_identity:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0
+	ld	[%g1 + 0x04], %f1
+	ld	[%g1 + 0x08], %f2
+	add	%o1, 1, %o1
+	ld	[%g1 + 0x0c], %f3
+	add	%g1, %o5, %g1
+	st	%f0, [%g2 + 0x00]
+	st	%f1, [%g2 + 0x04]
+	st	%f2, [%g2 + 0x08]
+	cmp	%o1, %g3
+	st	%f3, [%g2 + 0x0c]
+	bne	1b
+	 add	%g2, 0x10, %g2
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points4_2d
+_mesa_sparc_transform_points4_2d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_4_5_12_13(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	ld	[%g1 + 0x0c], %f3	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f4		! FGM
+	fmuls	%f1, M4, %f8		! FGM	Group
+	fmuls	%f0, M1, %f5		! FGM	Group
+	fmuls	%f1, M5, %f9		! FGM	Group	f4 available
+	fmuls	%f3, M12, %f12		! FGM	Group
+	fmuls	%f3, M13, %f13		! FGM	Group	f8 available
+	fadds	%f4, %f8, %f4		! FGA
+	fadds	%f5, %f9, %f5		! FGA	Group	stall, f5, f9 available
+	fadds	%f4, %f12, %f4		! FGA	Group	2 cycle stall, f4, f12, f13 avail
+	st	%f4, [%g2 + 0x00]	! LSU
+	fadds	%f5, %f13, %f5		! FGA	Group	f5 available
+	st	%f5, [%g2 + 0x04]	! LSU
+	st	%f2, [%g2 + 0x08]	! LSU	Group
+	st	%f3, [%g2 + 0x0c]	! LSU	Group
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points4_2d_no_rot
+_mesa_sparc_transform_points4_2d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_4_5_12_13(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0
+	ld	[%g1 + 0x04], %f1
+	ld	[%g1 + 0x08], %f2
+	ld	[%g1 + 0x0c], %f3
+	add	%o1, 1, %o1
+	add	%g1, %o5, %g1
+	fmuls	%f0, M0, %f4
+	fmuls	%f3, M12, %f8
+	fmuls	%f1, M5, %f5
+	fmuls	%f3, M13, %f9
+	fadds	%f4, %f8, %f4
+	st	%f4, [%g2 + 0x00]
+	fadds	%f5, %f9, %f5
+	st	%f5, [%g2 + 0x04]
+	st	%f2, [%g2 + 0x08]
+	st	%f3, [%g2 + 0x0c]
+	cmp	%o1, %g3
+	bne	1b
+	 add	%g2, 0x10, %g2
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points4_3d
+_mesa_sparc_transform_points4_3d:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_1_2_4_5_6_8_9_10_12_13_14(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	ld	[%g1 + 0x0c], %f3	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f4		! FGM
+	fmuls	%f1, M4, %f7		! FGM	Group
+	fmuls	%f0, M1, %f5		! FGM	Group
+	fmuls	%f1, M5, %f8		! FGM	Group
+	fmuls	%f0, M2, %f6		! FGM	Group	f4 available
+	fmuls	%f1, M6, %f9		! FGM	Group	f7 available
+	fadds	%f4, %f7, %f4		! FGA
+	fmuls	%f2, M8, %f10		! FGM	Group	f5 available
+	fmuls	%f2, M9, %f11		! FGM	Group	f8 available
+	fadds	%f5, %f8, %f5		! FGA
+	fmuls	%f2, M10, %f12		! FGM	Group	f6 available
+	fmuls	%f3, M12, %f13		! FGM	Group	f9, f4 available
+	fadds	%f6, %f9, %f6		! FGA
+	fmuls	%f3, M13, %f14		! FGM	Group	f10 available
+	fadds	%f4, %f10, %f4		! FGA
+	fmuls	%f3, M14, %f15		! FGM	Group	f11, f5 available
+	fadds	%f5, %f11, %f5		! FGA
+	fadds	%f6, %f12, %f6		! FGA	Group	stall, f12, f13, f6 available
+	fadds	%f4, %f13, %f4		! FGA	Group	f14, f4 available
+	st	%f4, [%g2 + 0x00]	! LSU
+	fadds	%f5, %f14, %f5		! FGA	Group	f15, f5 available
+	st	%f5, [%g2 + 0x04]	! LSU
+	fadds	%f6, %f15, %f6		! FGA	Group	f6 available
+	st	%f6, [%g2 + 0x08]	! LSU
+	st	%f3, [%g2 + 0x0c]	! LSU	Group
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points4_3d_no_rot
+_mesa_sparc_transform_points4_3d_no_rot:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_10_12_13_14(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	ld	[%g1 + 0x0c], %f3	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f4		! FGM
+	fmuls	%f3, M12, %f7		! FGM	Group
+	fmuls	%f1, M5, %f5		! FGM	Group
+	fmuls	%f3, M13, %f8		! FGM	Group
+	fmuls	%f2, M10, %f6		! FGM	Group	f4 available
+	fmuls	%f3, M14, %f9		! FGM	Group	f7 available
+	fadds	%f4, %f7, %f4		! FGA
+	st	%f4, [%g2 + 0x00]	! LSU
+	fadds	%f5, %f8, %f5		! FGA	Group	stall, f5, f8 available
+	st	%f5, [%g2 + 0x04]	! LSU
+	fadds	%f6, %f9, %f6		! FGA	Group	stall, f6, f9 available
+	st	%f6, [%g2 + 0x08]	! LSU
+	st	%f3, [%g2 + 0x0c]	! LSU	Group
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
+
+	.globl	_mesa_sparc_transform_points4_perspective
+_mesa_sparc_transform_points4_perspective:
+	ld	[%o2 + V4F_STRIDE], %o5
+	LDPTR	[%o2 + V4F_START], %g1
+	LDPTR	[%o0 + V4F_START], %g2
+	ld	[%o2 + V4F_COUNT], %g3
+
+	LDMATRIX_0_5_8_9_10_14(%o1)
+
+	cmp	%g3, 0
+	st	%g3, [%o0 + V4F_COUNT]
+	be	2f
+	 clr	%o1
+
+1:	ld	[%g1 + 0x00], %f0	! LSU	Group
+	ld	[%g1 + 0x04], %f1	! LSU	Group
+	ld	[%g1 + 0x08], %f2	! LSU	Group
+	ld	[%g1 + 0x0c], %f3	! LSU	Group
+	add	%o1, 1, %o1		! IEU0
+	add	%g1, %o5, %g1		! IEU1
+	fmuls	%f0, M0, %f4		! FGM
+	fmuls	%f2, M8, %f7		! FGM	Group
+	fmuls	%f1, M5, %f5		! FGM	Group
+	fmuls	%f2, M9, %f8		! FGM	Group
+	fmuls	%f2, M10, %f6		! FGM	Group	f4 available
+	fmuls	%f3, M14, %f9		! FGM	Group	f7 available
+	fadds	%f4, %f7, %f4		! FGA
+	st	%f4, [%g2 + 0x00]	! LSU
+	fadds	%f5, %f8, %f5		! FGA	Group	stall, f5, f8 available
+	st	%f5, [%g2 + 0x04]	! LSU
+	fadds	%f6, %f9, %f6		! FGA	Group	stall, f6, f9 available
+	st	%f6, [%g2 + 0x08]	! LSU
+	fnegs	%f2, %f7		! FGA	Group
+	st	%f7, [%g2 + 0x0c]	! LSU
+	cmp	%o1, %g3		! IEU1
+	bne	1b			! CTI
+	 add	%g2, 0x10, %g2		! IEU0	Group
+2:
+	ba	__set_v4f_4
+	 nop
Index: xc/extras/Mesa/src/Trace/tr_commands.h
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_commands.h:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_commands.h	Wed Dec 11 16:13:32 2002
@@ -0,0 +1,644 @@
+/* This may look like C code, but it is really -*- C++ -*-  */
+/* $Id: tr_commands.h,v 1.1 2000/11/11 01:42:30 brianp Exp $ */
+
+/*
+ * DebugGL
+ * Version:  1.0
+ * 
+ * Copyright (C) 1999-2000  Bernd Kreimeier, Loki Entertainment
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef TR_COMMANDS_H
+#define TR_COMMANDS_H
+
+
+/**
+ * Enumeration of GL commands, for metafile format 
+ *  and networking protocol. Has to be re-indexed
+ *  if (ever) used as GLX stream. This uses the
+ *  Mesa internal values.
+ */
+
+#define CMD_NEWLIST                                            0
+#define CMD_ENDLIST                                            1
+#define CMD_CALLLIST                                           2
+#define CMD_CALLLISTS                                          3
+#define CMD_DELETELISTS                                        4
+#define CMD_GENLISTS                                           5
+#define CMD_LISTBASE                                           6
+#define CMD_BEGIN                                              7
+#define CMD_BITMAP                                             8 
+#define CMD_COLOR3B                                            9
+#define CMD_COLOR3BV                                          10
+#define CMD_COLOR3D                                           11
+#define CMD_COLOR3DV                                          12
+#define CMD_COLOR3F                                           13 
+#define CMD_COLOR3FV                                          14 
+#define CMD_COLOR3I                                           15 
+#define CMD_COLOR3IV                                          16 
+#define CMD_COLOR3S                                           17 
+#define CMD_COLOR3SV                                          18 
+#define CMD_COLOR3UB                                          19 
+#define CMD_COLOR3UBV                                         20 
+#define CMD_COLOR3UI                                          21 
+#define CMD_COLOR3UIV                                         22 
+#define CMD_COLOR3US                                          23 
+#define CMD_COLOR3USV                                         24 
+#define CMD_COLOR4B                                           25 
+#define CMD_COLOR4BV                                          26 
+#define CMD_COLOR4D                                           27 
+#define CMD_COLOR4DV                                          28 
+#define CMD_COLOR4F                                           29 
+#define CMD_COLOR4FV                                          30 
+#define CMD_COLOR4I                                           31 
+#define CMD_COLOR4IV                                          32 
+#define CMD_COLOR4S                                           33 
+#define CMD_COLOR4SV                                          34 
+#define CMD_COLOR4UB                                          35 
+#define CMD_COLOR4UBV                                         36 
+#define CMD_COLOR4UI                                          37 
+#define CMD_COLOR4UIV                                         38 
+#define CMD_COLOR4US                                          39 
+#define CMD_COLOR4USV                                         40 
+#define CMD_EDGEFLAG                                          41 
+#define CMD_EDGEFLAGV                                         42 
+#define CMD_END                                               43 
+#define CMD_INDEXD                                            44 
+#define CMD_INDEXDV                                           45 
+#define CMD_INDEXF                                            46 
+#define CMD_INDEXFV                                           47 
+#define CMD_INDEXI                                            48 
+#define CMD_INDEXIV                                           49 
+#define CMD_INDEXS                                            50 
+#define CMD_INDEXSV                                           51 
+#define CMD_NORMAL3B                                          52 
+#define CMD_NORMAL3BV                                         53 
+#define CMD_NORMAL3D                                          54 
+#define CMD_NORMAL3DV                                         55 
+#define CMD_NORMAL3F                                          56 
+#define CMD_NORMAL3FV                                         57 
+#define CMD_NORMAL3I                                          58 
+#define CMD_NORMAL3IV                                         59 
+#define CMD_NORMAL3S                                          60 
+#define CMD_NORMAL3SV                                         61 
+#define CMD_RASTERPOS2D                                       62 
+#define CMD_RASTERPOS2DV                                      63 
+#define CMD_RASTERPOS2F                                       64 
+#define CMD_RASTERPOS2FV                                      65 
+#define CMD_RASTERPOS2I                                       66 
+#define CMD_RASTERPOS2IV                                      67 
+#define CMD_RASTERPOS2S                                       68 
+#define CMD_RASTERPOS2SV                                      69 
+#define CMD_RASTERPOS3D                                       70 
+#define CMD_RASTERPOS3DV                                      71 
+#define CMD_RASTERPOS3F                                       72 
+#define CMD_RASTERPOS3FV                                      73 
+#define CMD_RASTERPOS3I                                       74 
+#define CMD_RASTERPOS3IV                                      75 
+#define CMD_RASTERPOS3S                                       76 
+#define CMD_RASTERPOS3SV                                      77 
+#define CMD_RASTERPOS4D                                       78 
+#define CMD_RASTERPOS4DV                                      79 
+#define CMD_RASTERPOS4F                                       80 
+#define CMD_RASTERPOS4FV                                      81 
+#define CMD_RASTERPOS4I                                       82 
+#define CMD_RASTERPOS4IV                                      83 
+#define CMD_RASTERPOS4S                                       84 
+#define CMD_RASTERPOS4SV                                      85 
+#define CMD_RECTD                                             86 
+#define CMD_RECTDV                                            87 
+#define CMD_RECTF                                             88 
+#define CMD_RECTFV                                            89 
+#define CMD_RECTI                                             90 
+#define CMD_RECTIV                                            91 
+#define CMD_RECTS                                             92 
+#define CMD_RECTSV                                            93 
+#define CMD_TEXCOORD1D                                        94 
+#define CMD_TEXCOORD1DV                                       95 
+#define CMD_TEXCOORD1F                                        96 
+#define CMD_TEXCOORD1FV                                       97 
+#define CMD_TEXCOORD1I                                        98 
+#define CMD_TEXCOORD1IV                                       99 
+#define CMD_TEXCOORD1S                                       100 
+#define CMD_TEXCOORD1SV                                      101 
+#define CMD_TEXCOORD2D                                       102 
+#define CMD_TEXCOORD2DV                                      103 
+#define CMD_TEXCOORD2F                                       104 
+#define CMD_TEXCOORD2FV                                      105 
+#define CMD_TEXCOORD2I                                       106 
+#define CMD_TEXCOORD2IV                                      107 
+#define CMD_TEXCOORD2S                                       108 
+#define CMD_TEXCOORD2SV                                      109 
+#define CMD_TEXCOORD3D                                       110 
+#define CMD_TEXCOORD3DV                                      111 
+#define CMD_TEXCOORD3F                                       112 
+#define CMD_TEXCOORD3FV                                      113 
+#define CMD_TEXCOORD3I                                       114 
+#define CMD_TEXCOORD3IV                                      115 
+#define CMD_TEXCOORD3S                                       116 
+#define CMD_TEXCOORD3SV                                      117 
+#define CMD_TEXCOORD4D                                       118 
+#define CMD_TEXCOORD4DV                                      119 
+#define CMD_TEXCOORD4F                                       120 
+#define CMD_TEXCOORD4FV                                      121 
+#define CMD_TEXCOORD4I                                       122 
+#define CMD_TEXCOORD4IV                                      123 
+#define CMD_TEXCOORD4S                                       124 
+#define CMD_TEXCOORD4SV                                      125 
+#define CMD_VERTEX2D                                         126 
+#define CMD_VERTEX2DV                                        127 
+#define CMD_VERTEX2F                                         128 
+#define CMD_VERTEX2FV                                        129 
+#define CMD_VERTEX2I                                         130 
+#define CMD_VERTEX2IV                                        131 
+#define CMD_VERTEX2S                                         132 
+#define CMD_VERTEX2SV                                        133 
+#define CMD_VERTEX3D                                         134 
+#define CMD_VERTEX3DV                                        135 
+#define CMD_VERTEX3F                                         136 
+#define CMD_VERTEX3FV                                        137 
+#define CMD_VERTEX3I                                         138 
+#define CMD_VERTEX3IV                                        139 
+#define CMD_VERTEX3S                                         140 
+#define CMD_VERTEX3SV                                        141 
+#define CMD_VERTEX4D                                         142 
+#define CMD_VERTEX4DV                                        143 
+#define CMD_VERTEX4F                                         144 
+#define CMD_VERTEX4FV                                        145 
+#define CMD_VERTEX4I                                         146 
+#define CMD_VERTEX4IV                                        147 
+#define CMD_VERTEX4S                                         148 
+#define CMD_VERTEX4SV                                        149 
+#define CMD_CLIPPLANE                                        150 
+#define CMD_COLORMATERIAL                                    151 
+#define CMD_CULLFACE                                         152 
+#define CMD_FOGF                                             153 
+#define CMD_FOGFV                                            154 
+#define CMD_FOGI                                             155 
+#define CMD_FOGIV                                            156 
+#define CMD_FRONTFACE                                        157 
+#define CMD_HINT                                             158 
+#define CMD_LIGHTF                                           159 
+#define CMD_LIGHTFV                                          160 
+#define CMD_LIGHTI                                           161 
+#define CMD_LIGHTIV                                          162 
+#define CMD_LIGHTMODELF                                      163 
+#define CMD_LIGHTMODELFV                                     164 
+#define CMD_LIGHTMODELI                                      165 
+#define CMD_LIGHTMODELIV                                     166 
+#define CMD_LINESTIPPLE                                      167 
+#define CMD_LINEWIDTH                                        168 
+#define CMD_MATERIALF                                        169 
+#define CMD_MATERIALFV                                       170 
+#define CMD_MATERIALI                                        171 
+#define CMD_MATERIALIV                                       172 
+#define CMD_POINTSIZE                                        173 
+#define CMD_POLYGONMODE                                      174 
+#define CMD_POLYGONSTIPPLE                                   175 
+#define CMD_SCISSOR                                          176 
+#define CMD_SHADEMODEL                                       177 
+#define CMD_TEXPARAMETERF                                    178 
+#define CMD_TEXPARAMETERFV                                   179 
+#define CMD_TEXPARAMETERI                                    180 
+#define CMD_TEXPARAMETERIV                                   181 
+#define CMD_TEXIMAGE1D                                       182 
+#define CMD_TEXIMAGE2D                                       183 
+#define CMD_TEXENVF                                          184 
+#define CMD_TEXENVFV                                         185 
+#define CMD_TEXENVI                                          186 
+#define CMD_TEXENVIV                                         187 
+#define CMD_TEXGEND                                          188 
+#define CMD_TEXGENDV                                         189 
+#define CMD_TEXGENF                                          190 
+#define CMD_TEXGENFV                                         191 
+#define CMD_TEXGENI                                          192 
+#define CMD_TEXGENIV                                         193 
+#define CMD_FEEDBACKBUFFER                                   194 
+#define CMD_SELECTBUFFER                                     195 
+#define CMD_RENDERMODE                                       196 
+#define CMD_INITNAMES                                        197 
+#define CMD_LOADNAME                                         198 
+#define CMD_PASSTHROUGH                                      199 
+#define CMD_POPNAME                                          200 
+#define CMD_PUSHNAME                                         201 
+#define CMD_DRAWBUFFER                                       202 
+#define CMD_CLEAR                                            203 
+#define CMD_CLEARACCUM                                       204 
+#define CMD_CLEARINDEX                                       205 
+#define CMD_CLEARCOLOR                                       206 
+#define CMD_CLEARSTENCIL                                     207 
+#define CMD_CLEARDEPTH                                       208 
+#define CMD_STENCILMASK                                      209 
+#define CMD_COLORMASK                                        210 
+#define CMD_DEPTHMASK                                        211 
+#define CMD_INDEXMASK                                        212 
+#define CMD_ACCUM                                            213 
+#define CMD_DISABLE                                          214 
+#define CMD_ENABLE                                           215 
+#define CMD_FINISH                                           216 
+#define CMD_FLUSH                                            217 
+#define CMD_POPATTRIB                                        218 
+#define CMD_PUSHATTRIB                                       219 
+#define CMD_MAP1D                                            220 
+#define CMD_MAP1F                                            221 
+#define CMD_MAP2D                                            222 
+#define CMD_MAP2F                                            223 
+#define CMD_MAPGRID1D                                        224 
+#define CMD_MAPGRID1F                                        225 
+#define CMD_MAPGRID2D                                        226 
+#define CMD_MAPGRID2F                                        227 
+#define CMD_EVALCOORD1D                                      228 
+#define CMD_EVALCOORD1DV                                     229 
+#define CMD_EVALCOORD1F                                      230 
+#define CMD_EVALCOORD1FV                                     231 
+#define CMD_EVALCOORD2D                                      232 
+#define CMD_EVALCOORD2DV                                     233 
+#define CMD_EVALCOORD2F                                      234 
+#define CMD_EVALCOORD2FV                                     235 
+#define CMD_EVALMESH1                                        236 
+#define CMD_EVALPOINT1                                       237 
+#define CMD_EVALMESH2                                        238 
+#define CMD_EVALPOINT2                                       239 
+#define CMD_ALPHAFUNC                                        240 
+#define CMD_BLENDFUNC                                        241 
+#define CMD_LOGICOP                                          242 
+#define CMD_STENCILFUNC                                      243 
+#define CMD_STENCILOP                                        244 
+#define CMD_DEPTHFUNC                                        245 
+#define CMD_PIXELZOOM                                        246 
+#define CMD_PIXELTRANSFERF                                   247 
+#define CMD_PIXELTRANSFERI                                   248 
+#define CMD_PIXELSTOREF                                      249 
+#define CMD_PIXELSTOREI                                      250 
+#define CMD_PIXELMAPFV                                       251 
+#define CMD_PIXELMAPUIV                                      252 
+#define CMD_PIXELMAPUSV                                      253 
+#define CMD_READBUFFER                                       254 
+#define CMD_COPYPIXELS                                       255 
+#define CMD_READPIXELS                                       256 
+#define CMD_DRAWPIXELS                                       257 
+#define CMD_GETBOOLEANV                                      258 
+#define CMD_GETCLIPPLANE                                     259 
+#define CMD_GETDOUBLEV                                       260 
+#define CMD_GETERROR                                         261 
+#define CMD_GETFLOATV                                        262 
+#define CMD_GETINTEGERV                                      263 
+#define CMD_GETLIGHTFV                                       264 
+#define CMD_GETLIGHTIV                                       265 
+#define CMD_GETMAPDV                                         266 
+#define CMD_GETMAPFV                                         267 
+#define CMD_GETMAPIV                                         268 
+#define CMD_GETMATERIALFV                                    269 
+#define CMD_GETMATERIALIV                                    270 
+#define CMD_GETPIXELMAPFV                                    271 
+#define CMD_GETPIXELMAPUIV                                   272 
+#define CMD_GETPIXELMAPUSV                                   273 
+#define CMD_GETPOLYGONSTIPPLE                                274 
+#define CMD_GETSTRING                                        275 
+#define CMD_GETTEXENVFV                                      276 
+#define CMD_GETTEXENVIV                                      277 
+#define CMD_GETTEXGENDV                                      278 
+#define CMD_GETTEXGENFV                                      279 
+#define CMD_GETTEXGENIV                                      280 
+#define CMD_GETTEXIMAGE                                      281 
+#define CMD_GETTEXPARAMETERFV                                282 
+#define CMD_GETTEXPARAMETERIV                                283 
+#define CMD_GETTEXLEVELPARAMETERFV                           284 
+#define CMD_GETTEXLEVELPARAMETERIV                           285 
+#define CMD_ISENABLED                                        286 
+#define CMD_ISLIST                                           287 
+#define CMD_DEPTHRANGE                                       288 
+#define CMD_FRUSTUM                                          289 
+#define CMD_LOADIDENTITY                                     290 
+#define CMD_LOADMATRIXF                                      291 
+#define CMD_LOADMATRIXD                                      292 
+#define CMD_MATRIXMODE                                       293 
+#define CMD_MULTMATRIXF                                      294 
+#define CMD_MULTMATRIXD                                      295 
+#define CMD_ORTHO                                            296 
+#define CMD_POPMATRIX                                        297 
+#define CMD_PUSHMATRIX                                       298 
+#define CMD_ROTATED                                          299 
+#define CMD_ROTATEF                                          300 
+#define CMD_SCALED                                           301 
+#define CMD_SCALEF                                           302 
+#define CMD_TRANSLATED                                       303 
+#define CMD_TRANSLATEF                                       304 
+#define CMD_VIEWPORT                                         305 
+#define CMD_ARRAYELEMENT                                     306 
+#define CMD_BINDTEXTURE                                      307 
+#define CMD_COLORPOINTER                                     308 
+#define CMD_DISABLECLIENTSTATE                               309 
+#define CMD_DRAWARRAYS                                       310 
+#define CMD_DRAWELEMENTS                                     311 
+#define CMD_EDGEFLAGPOINTER                                  312 
+#define CMD_ENABLECLIENTSTATE                                313 
+#define CMD_INDEXPOINTER                                     314 
+#define CMD_INDEXUB                                          315 
+#define CMD_INDEXUBV                                         316 
+#define CMD_INTERLEAVEDARRAYS                                317 
+#define CMD_NORMALPOINTER                                    318 
+#define CMD_POLYGONOFFSET                                    319 
+#define CMD_TEXCOORDPOINTER                                  320 
+#define CMD_VERTEXPOINTER                                    321 
+#define CMD_ARETEXTURESRESIDENT                              322 
+#define CMD_COPYTEXIMAGE1D                                   323 
+#define CMD_COPYTEXIMAGE2D                                   324 
+#define CMD_COPYTEXSUBIMAGE1D                                325 
+#define CMD_COPYTEXSUBIMAGE2D                                326 
+#define CMD_DELETETEXTURES                                   327 
+#define CMD_GENTEXTURES                                      328 
+#define CMD_GETPOINTERV                                      329 
+#define CMD_ISTEXTURE                                        330 
+#define CMD_PRIORITIZETEXTURES                               331 
+#define CMD_TEXSUBIMAGE1D                                    332 
+#define CMD_TEXSUBIMAGE2D                                    333 
+#define CMD_POPCLIENTATTRIB                                  334 
+#define CMD_PUSHCLIENTATTRIB                                 335 
+#define CMD_BLENDCOLOR                                       336 
+#define CMD_BLENDEQUATION                                    337 
+#define CMD_DRAWRANGEELEMENTS                                338 
+#define CMD_COLORTABLE                                       339 
+#define CMD_COLORTABLEPARAMETERFV                            340 
+#define CMD_COLORTABLEPARAMETERIV                            341 
+#define CMD_COPYCOLORTABLE                                   342 
+#define CMD_GETCOLORTABLE                                    343 
+#define CMD_GETCOLORTABLEPARAMETERFV                         344 
+#define CMD_GETCOLORTABLEPARAMETERIV                         345 
+#define CMD_COLORSUBTABLE                                    346 
+#define CMD_COPYCOLORSUBTABLE                                347 
+#define CMD_CONVOLUTIONFILTER1D                              348 
+#define CMD_CONVOLUTIONFILTER2D                              349 
+#define CMD_CONVOLUTIONPARAMETERF                            350 
+#define CMD_CONVOLUTIONPARAMETERFV                           351 
+#define CMD_CONVOLUTIONPARAMETERI                            352 
+#define CMD_CONVOLUTIONPARAMETERIV                           353 
+#define CMD_COPYCONVOLUTIONFILTER1D                          354 
+#define CMD_COPYCONVOLUTIONFILTER2D                          355 
+#define CMD_GETCONVOLUTIONFILTER                             356 
+#define CMD_GETCONVOLUTIONPARAMETERFV                        357 
+#define CMD_GETCONVOLUTIONPARAMETERIV                        358 
+#define CMD_GETSEPARABLEFILTER                               359 
+#define CMD_SEPARABLEFILTER2D                                360 
+#define CMD_GETHISTOGRAM                                     361 
+#define CMD_GETHISTOGRAMPARAMETERFV                          362 
+#define CMD_GETHISTOGRAMPARAMETERIV                          363 
+#define CMD_GETMINMAX                                        364 
+#define CMD_GETMINMAXPARAMETERFV                             365 
+#define CMD_GETMINMAXPARAMETERIV                             366 
+#define CMD_HISTOGRAM                                        367 
+#define CMD_MINMAX                                           368 
+#define CMD_RESETHISTOGRAM                                   369 
+#define CMD_RESETMINMAX                                      370 
+#define CMD_TEXIMAGE3D                                       371 
+#define CMD_TEXSUBIMAGE3D                                    372 
+#define CMD_COPYTEXSUBIMAGE3D                                373 
+#define CMD_ACTIVETEXTUREARB                                 374 
+#define CMD_CLIENTACTIVETEXTUREARB                           375 
+#define CMD_MULTITEXCOORD1DARB                               376 
+#define CMD_MULTITEXCOORD1DVARB                              377 
+#define CMD_MULTITEXCOORD1FARB                               378 
+#define CMD_MULTITEXCOORD1FVARB                              379 
+#define CMD_MULTITEXCOORD1IARB                               380 
+#define CMD_MULTITEXCOORD1IVARB                              381 
+#define CMD_MULTITEXCOORD1SARB                               382 
+#define CMD_MULTITEXCOORD1SVARB                              383 
+#define CMD_MULTITEXCOORD2DARB                               384 
+#define CMD_MULTITEXCOORD2DVARB                              385 
+#define CMD_MULTITEXCOORD2FARB                               386 
+#define CMD_MULTITEXCOORD2FVARB                              387 
+#define CMD_MULTITEXCOORD2IARB                               388 
+#define CMD_MULTITEXCOORD2IVARB                              389 
+#define CMD_MULTITEXCOORD2SARB                               390 
+#define CMD_MULTITEXCOORD2SVARB                              391 
+#define CMD_MULTITEXCOORD3DARB                               392 
+#define CMD_MULTITEXCOORD3DVARB                              393 
+#define CMD_MULTITEXCOORD3FARB                               394 
+#define CMD_MULTITEXCOORD3FVARB                              395 
+#define CMD_MULTITEXCOORD3IARB                               396 
+#define CMD_MULTITEXCOORD3IVARB                              397 
+#define CMD_MULTITEXCOORD3SARB                               398 
+#define CMD_MULTITEXCOORD3SVARB                              399 
+#define CMD_MULTITEXCOORD4DARB                               400 
+#define CMD_MULTITEXCOORD4DVARB                              401 
+#define CMD_MULTITEXCOORD4FARB                               402 
+#define CMD_MULTITEXCOORD4FVARB                              403 
+#define CMD_MULTITEXCOORD4IARB                               404 
+#define CMD_MULTITEXCOORD4IVARB                              405 
+#define CMD_MULTITEXCOORD4SARB                               406 
+#define CMD_MULTITEXCOORD4SVARB                              407 
+#define CMD_LOADTRANSPOSEMATRIXFARB                          408 
+#define CMD_LOADTRANSPOSEMATRIXDARB                          409 
+#define CMD_MULTTRANSPOSEMATRIXFARB                          410 
+#define CMD_MULTTRANSPOSEMATRIXDARB                          411 
+#define CMD_SAMPLECOVERAGEARB                                412 
+#define CMD_SAMPLEPASSARB                                    413 
+#define CMD_POLYGONOFFSETEXT                                 414 
+#define CMD_GETTEXFILTERFUNCSGIS                             415 
+#define CMD_TEXFILTERFUNCSGIS                                416 
+#define CMD_GETHISTOGRAMEXT                                  417 
+#define CMD_GETHISTOGRAMPARAMETERFVEXT                       418 
+#define CMD_GETHISTOGRAMPARAMETERIVEXT                       419 
+#define CMD_GETMINMAXEXT                                     420 
+#define CMD_GETMINMAXPARAMETERFVEXT                          421 
+#define CMD_GETMINMAXPARAMETERIVEXT                          422 
+#define CMD_GETCONVOLUTIONFILTEREXT                          423 
+#define CMD_GETCONVOLUTIONPARAMETERFVEXT                     424 
+#define CMD_GETCONVOLUTIONPARAMETERIVEXT                     425 
+#define CMD_GETSEPARABLEFILTEREXT                            426 
+#define CMD_GETCOLORTABLESGI                                 427 
+#define CMD_GETCOLORTABLEPARAMETERFVSGI                      428 
+#define CMD_GETCOLORTABLEPARAMETERIVSGI                      429 
+#define CMD_PIXELTEXGENSGIX                                  430 
+#define CMD_PIXELTEXGENPARAMETERISGIS                        431 
+#define CMD_PIXELTEXGENPARAMETERIVSGIS                       432 
+#define CMD_PIXELTEXGENPARAMETERFSGIS                        433 
+#define CMD_PIXELTEXGENPARAMETERFVSGIS                       434 
+#define CMD_GETPIXELTexGenPARAMETERIVSGIS                    435 
+#define CMD_GETPIXELTexGenPARAMETERFVSGIS                    436 
+#define CMD_TEXIMAGE4DSGIS                                   437 
+#define CMD_TEXSUBIMAGE4DSGIS                                438 
+#define CMD_ARETEXTURESRESIDENTEXT                           439 
+#define CMD_GENTEXTURESEXT                                   440 
+#define CMD_ISTEXTUREEXT                                     441 
+#define CMD_DETAILTEXFUNCSGIS                                442 
+#define CMD_GETDETAILTEXFUNCSGIS                             443 
+#define CMD_SHARPENTEXFUNCSGIS                               444 
+#define CMD_GETSHARPENTEXFUNCSGIS                            445 
+#define CMD_SAMPLEMASKSGIS                                   446 
+#define CMD_SAMPLEPATTERNSGIS                                447 
+#define CMD_COLORPOINTEREXT                                  448 
+#define CMD_EDGEFLAGPOINTEREXT                               449 
+#define CMD_INDEXPOINTEREXT                                  450 
+#define CMD_NORMALPOINTEREXT                                 451 
+#define CMD_TEXCOORDPOINTEREXT                               452 
+#define CMD_VERTEXPOINTEREXT                                 453 
+#define CMD_SPRITEPARAMETERFSGIX                             454 
+#define CMD_SPRITEPARAMETERFVSGIX                            455 
+#define CMD_SPRITEPARAMETERISGIX                             456 
+#define CMD_SPRITEPARAMETERIVSGIX                            457 
+#define CMD_POINTPARAMETERFEXT                               458 
+#define CMD_POINTPARAMETERFVEXT                              459 
+#define CMD_GETINSTRUMENTSSGIX                               460 
+#define CMD_INSTRUMENTSBUFFERSGIX                            461 
+#define CMD_POLLINSTRUMENTSSGIX                              462 
+#define CMD_READINSTRUMENTSSGIX                              463 
+#define CMD_STARTINSTRUMENTSSGIX                             464 
+#define CMD_STOPINSTRUMENTSSGIX                              465 
+#define CMD_FRAMEZOOMSGIX                                    466 
+#define CMD_TAGSAMPLEBUFFERSGIX                              467 
+#define CMD_REFERENCEPLANESGIX                               468 
+#define CMD_FLUSHRASTERSGIX                                  469 
+#define CMD_GETLISTPARAMETERFVSGIX                           470 
+#define CMD_GETLISTPARAMETERIVSGIX                           471 
+#define CMD_LISTPARAMETERFSGIX                               472 
+#define CMD_LISTPARAMETERFVSGIX                              473 
+#define CMD_LISTPARAMETERISGIX                               474 
+#define CMD_LISTPARAMETERIVSGIX                              475 
+#define CMD_FRAGMENTCOLORMATERIALSGIX                        476 
+#define CMD_FRAGMENTLIGHTFSGIX                               477 
+#define CMD_FRAGMENTLIGHTFVSGIX                              478 
+#define CMD_FRAGMENTLIGHTISGIX                               479 
+#define CMD_FRAGMENTLIGHTIVSGIX                              480 
+#define CMD_FRAGMENTLIGHTMODELFSGIX                          481 
+#define CMD_FRAGMENTLIGHTMODELFVSGIX                         482 
+#define CMD_FRAGMENTLIGHTMODELISGIX                          483 
+#define CMD_FRAGMENTLIGHTMODELIVSGIX                         484 
+#define CMD_FRAGMENTMATERIALFSGIX                            485 
+#define CMD_FRAGMENTMATERIALFVSGIX                           486 
+#define CMD_FRAGMENTMATERIALISGIX                            487 
+#define CMD_FRAGMENTMATERIALIVSGIX                           488 
+#define CMD_GETFRAGMENTLIGHTFVSGIX                           489 
+#define CMD_GETFRAGMENTLIGHTIVSGIX                           490 
+#define CMD_GETFRAGMENTMATERIALFVSGIX                        491 
+#define CMD_GETFRAGMENTMATERIALIVSGIX                        492 
+#define CMD_LIGHTENVISGIX                                    493 
+#define CMD_VERTEXWEIGHTFEXT                                 494 
+#define CMD_VERTEXWEIGHTFVEXT                                495 
+#define CMD_VERTEXWEIGHTPOINTEREXT                           496 
+#define CMD_FLUSHVERTEXARRAYRANGENV                          497 
+#define CMD_VERTEXARRAYRANGENV                               498 
+#define CMD_COMBINERPARAMETERFVNV                            499 
+#define CMD_COMBINERPARAMETERFNV                             500 
+#define CMD_COMBINERPARAMETERIVNV                            501 
+#define CMD_COMBINERPARAMETERINV                             502 
+#define CMD_COMBINERINPUTNV                                  503 
+#define CMD_COMBINEROUTPUTNV                                 504 
+#define CMD_FINALCOMBINERINPUTNV                             505 
+#define CMD_GETCOMBINERINPUTPARAMETERFVNV                    506 
+#define CMD_GETCOMBINERINPUTPARAMETERIVNV                    507 
+#define CMD_GETCOMBINEROUTPUTPARAMETERFVNV                   508 
+#define CMD_GETCOMBINEROUTPUTPARAMETERIVNV                   509 
+#define CMD_GETFINALCOMBINERINPUTPARAMETERFVNV               510 
+#define CMD_GETFINALCOMBINERINPUTPARAMETERIVNV               511 
+#define CMD_RESIZEBUFFERSMESA                                512 
+#define CMD_WINDOWPOS2DMESA                                  513 
+#define CMD_WINDOWPOS2DVMESA                                 514 
+#define CMD_WINDOWPOS2FMESA                                  515 
+#define CMD_WINDOWPOS2FVMESA                                 516 
+#define CMD_WINDOWPOS2IMESA                                  517 
+#define CMD_WINDOWPOS2IVMESA                                 518 
+#define CMD_WINDOWPOS2SMESA                                  519 
+#define CMD_WINDOWPOS2SVMESA                                 520 
+#define CMD_WINDOWPOS3DMESA                                  521 
+#define CMD_WINDOWPOS3DVMESA                                 522 
+#define CMD_WINDOWPOS3FMESA                                  523 
+#define CMD_WINDOWPOS3FVMESA                                 524 
+#define CMD_WINDOWPOS3IMESA                                  525 
+#define CMD_WINDOWPOS3IVMESA                                 526 
+#define CMD_WINDOWPOS3SMESA                                  527 
+#define CMD_WINDOWPOS3SVMESA                                 528 
+#define CMD_WINDOWPOS4DMESA                                  529 
+#define CMD_WINDOWPOS4DVMESA                                 530 
+#define CMD_WINDOWPOS4FMESA                                  531 
+#define CMD_WINDOWPOS4FVMESA                                 532 
+#define CMD_WINDOWPOS4IMESA                                  533 
+#define CMD_WINDOWPOS4IVMESA                                 534 
+#define CMD_WINDOWPOS4SMESA                                  535 
+#define CMD_WINDOWPOS4SVMESA                                 536 
+#define CMD_BLENDFUNCSEPARATEEXT                             537 
+#define CMD_INDEXMATERIALEXT                                 538 
+#define CMD_INDEXFUNCEXT                                     539 
+#define CMD_LOCKARRAYSEXT                                    540 
+#define CMD_UNLOCKARRAYSEXT                                  541 
+#define CMD_CULLPARAMETERDVEXT                               542 
+#define CMD_CULLPARAMETERFVEXT                               543 
+#define CMD_HINTPGI                                          544 
+#define CMD_FOGCOORDFEXT                                     545 
+#define CMD_FOGCOORDFVEXT                                    546 
+#define CMD_FOGCOORDDEXT                                     547 
+#define CMD_FOGCOORDDVEXT                                    548 
+#define CMD_FOGCOORDPOINTEREXT                               549 
+#define CMD_GETCOLORTABLEEXT                                 550 
+#define CMD_GETCOLORTABLEPARAMETERIVEXT                      551 
+#define CMD_GETCOLORTABLEPARAMETERFVEXT                      552         
+
+
+/* FIXME: Trace Extension itself - not yet defined. */
+#define CMD_NEWTRACEMESA                                     666
+#define CMD_ENDTRACEMESA                                     667
+#define CMD_TRACECOMMENTMESA                                 668
+
+
+
+/**
+ * Enumeration of non-GL entries in trace stream.
+ * This is (static) variable and "various" data,
+ *  some of which optional. All these values are
+ *  negative.
+ */
+#define VAR_VERSION                                           -1 /* Metafile version. Mandatory. */
+#define VAR_CYCLES                                            -2 /* Profiling, CPU cycles. Optional. */
+#define VAR_CONTEXT                                           -3 /* Context ID. Optional. */    
+#define VAR_THREAD                                            -4 /* Thread ID. Optional. */
+#define VAR_STRING                                            -5 /* Internally generated. Optional. */
+
+#define VAR_COLORELEMENT                                      -6
+#define VAR_EDGEFLAGELEMENT                                   -7
+#define VAR_INDEXELEMENT                                      -8
+#define VAR_NORMALELEMENT                                     -9
+#define VAR_TEXCOORDELEMENT                                   -10
+#define VAR_VERTEXELEMENT                                     -11 /* Dereferenced Vertex Array Data. */
+
+
+/* FIXME: more VAR_ as needed. */
+/*
+ * Mindbender - The following two vars are needed to surround the queries
+ *              performed when the trace context is in a half initialized
+ *              state.
+ */
+#define VAR_OOBBEGIN                                          -14
+#define VAR_OOBEND                                            -15
+
+/*
+ * Mindbender - These are needed when the pointer changes through one of the
+ *              XXXPointer calls.  Change these as needed.
+ */
+#define VAR_COLORPOINTER                                      -8
+#define VAR_EDGEFLAGPOINTER                                   -9
+#define VAR_INDEXPOINTER                                      -10
+#define VAR_NORMALPOINTER                                     -11
+#define VAR_TEXCOORDPOINTER                                   -12
+#define VAR_VERTEXPOINTER                                     -13
+
+
+#endif
Index: xc/extras/Mesa/src/Trace/tr_context.c
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_context.c:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_context.c	Wed Dec 11 16:13:32 2002
@@ -0,0 +1,118 @@
+#ifdef MESA_TRACE
+
+#include "glheader.h"
+#include "glapi.h"
+#include "glapitable.h"
+#include "context.h"
+#include "tr_context.h"
+
+
+/* Full precision on floats/double, else human readable. */
+#define  TR_FULL_PRECISION  0x000000001
+
+
+void trInitContext( trace_context_t * tr_context )
+{
+	int i;
+
+	if (!tr_context)
+		return;
+
+	tr_context->traceEnabled = GL_FALSE;
+	tr_context->logFP = stdout;      
+	tr_context->traceName = NULL;
+
+	tr_context->traceAttribLogBits = GL_ALL_ATTRIB_BITS;
+	tr_context->traceEnableLogBits = GL_TRACE_ALL_BITS_MESA;
+
+	tr_context->betweenBeginEnd = GL_FALSE;
+
+	tr_context->framecounter = 0;
+
+	tr_context->trDoPrint = GL_TRUE;
+	tr_context->doExec = GL_TRUE;
+	tr_context->check_errors = GL_TRUE;
+
+	tr_context->head_errors = 0;
+	tr_context->tail_errors = 0;
+
+	for( i = 0; i < TR_MAX_QUEUED_ERRORS; i++ ) {
+		tr_context->cached_errors[i] = GL_NO_ERROR;
+	}
+
+#if 0
+	tr_context->doAsserts    = GL_TRUE;
+	tr_context->clientStateValid = GL_FALSE;
+#endif
+}
+
+
+/**
+ * Get the current context.
+ */
+trace_context_t* trCtx() {
+	GLcontext * ctx;
+	ctx = (GLcontext *)_glapi_get_context();
+
+	assert(ctx);
+	assert(ctx->TraceCtx);
+	if( (!ctx) || !(ctx->TraceCtx) ) {
+		_mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__ );
+		return NULL;
+	}
+
+	return ctx->TraceCtx;
+}
+
+
+/**
+ * Get the current, real dispatch table pointer.
+ */
+struct _glapi_table* trGetDispatch() {
+	return _glapi_get_dispatch();
+}
+
+
+void trSetTraceDispatch( void ) {
+	GLcontext * ctx;
+	ctx = (GLcontext *)_glapi_get_context();
+
+	assert( ctx );
+	assert( ctx->TraceCtx );
+	assert( ctx->TraceDispatch );
+
+	ctx->TraceCtx->traceEnabled = GL_TRUE;
+
+        /* XXX save returned value */
+	(void) _glapi_begin_dispatch_override(ctx->TraceDispatch);
+}
+
+
+void trSetOriginalDispatch( void ) {
+	GLcontext * ctx;
+	ctx = (GLcontext *)_glapi_get_context();
+
+	assert( ctx );
+	assert( ctx->TraceCtx );
+	assert( ctx->TraceDispatch );
+
+	ctx->TraceCtx->traceEnabled = GL_FALSE;
+
+        /* XXX pass value we got from _glapi_begin_dispatch_override() */
+	_glapi_end_dispatch_override(1);
+}
+
+
+/**
+ * Is error checking enabled?
+ */
+GLboolean trDoErrorCheck() {
+  return trCtx()->check_errors;
+}
+
+#else
+extern void tr_context_dummy_func(void);
+void tr_context_dummy_func(void)
+{
+}
+#endif
Index: xc/extras/Mesa/src/Trace/tr_context.h
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_context.h:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_context.h	Wed Dec 11 16:13:32 2002
@@ -0,0 +1,80 @@
+#ifndef TR_CONTEXT_H
+#define TR_CONTEXT_H
+
+#include "glheader.h"
+#include "glapitable.h"
+
+#define TR_MAX_QUEUED_ERRORS 8
+
+
+/**
+ * State Variables.
+ * To make this thread-safe we'd maintain such
+ *  a set per thread/context.
+ */
+typedef struct t_t{
+
+	GLboolean                traceEnabled;
+
+	/* The current log file pointer. */
+	FILE *                   logFP;      
+
+	char *                   traceName;
+
+	/* What frame we're currently on. */
+	GLint                    framecounter;
+
+	/* Not yet used.  This field will control which attributes should be logged. */
+	GLbitfield               traceAttribLogBits;
+
+	GLbitfield               traceEnableLogBits;
+
+	/* Used to short-circuit writing to the file, if the disk is full */
+	GLboolean                trDoPrint;
+
+	/* Used to toggle whether the gl command should
+	 * actually be executed.  For now this will always be true.
+	 */
+	GLboolean                doExec;
+  
+	/* Verify GL_NO_ERROR wherever possible. */
+	GLboolean                check_errors;
+
+	/* Loop over all GL errors.
+	 * TODO: We have to make sure the application gets 
+	 *  the exact same errors despite our checking.
+	 *  That basically means we have to queue all
+	 *  errors from our internal checks.
+	 */
+	GLint                    head_errors;
+	GLint                    tail_errors;
+
+	GLenum                   cached_errors[TR_MAX_QUEUED_ERRORS];
+
+	/* Not yet used.  The 1st of many state flags used to
+	 * track the current state of the GL state machine.
+	 */
+	GLboolean                betweenBeginEnd;
+
+#if 0
+	GLboolean                doAsserts;
+	GLboolean                clientStateValid;
+#endif
+
+} trace_context_t;
+
+
+extern void trInitContext( trace_context_t * tr_context );
+
+extern trace_context_t*  trCtx( void );
+
+extern struct _glapi_table* trGetDispatch( void );
+
+extern void trSetTraceDispatch( void );
+
+extern void trSetOriginalDispatch( void );
+
+extern GLboolean trDoErrorCheck( void );
+
+
+#endif
Index: xc/extras/Mesa/src/Trace/tr_control.c
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_control.c:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_control.c	Wed Dec 11 16:13:32 2002
@@ -0,0 +1,147 @@
+#ifdef MESA_TRACE
+#include "glheader.h"
+#include "glapi.h"
+#include "context.h" /* for _mesa_error */
+#include "mtypes.h"
+#include "tr_context.h"
+#include "tr_write.h"
+
+
+void glEnableTraceMESA( GLbitfield mask )
+{
+	trace_context_t * tctx = trCtx();
+
+	tctx->traceEnableLogBits = mask;
+	tctx->traceEnabled       = GL_TRUE;
+}
+
+
+void glDisableTraceMESA( GLbitfield mask )
+{
+	/* Reset traceEnableLogBits ? */
+	trCtx()->traceEnabled = GL_FALSE;
+}
+
+
+void glNewTraceMESA( GLbitfield logbits, const GLubyte * traceName )
+{
+	char * newname;
+	GLint     length;
+	GLcontext * ctx;
+	const char * defaultName = "traceGL";
+
+	ctx = (GLcontext *)_glapi_get_context();
+
+	assert(ctx);
+	assert(ctx->TraceCtx);
+	assert(ctx->TraceDispatch);
+	if( !ctx ||                                      /* Do we even have a context ? */
+		(ctx->TraceCtx->betweenBeginEnd == GL_TRUE)   || /* Are we currently between glBegin and glEnd ? */
+	   (ctx->TraceDispatch == _glapi_get_override_dispatch(1)) ) {  /* Has a trace already started ? */
+		_mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__ );
+		return;
+	}
+
+	/* FIXME!!! When do we free tracename after the app is finished? */
+	if( ctx->TraceCtx->traceName ) {
+		free( ctx->TraceCtx->traceName );
+	}
+
+	length = strlen((char *)traceName) + 1;
+	if( length != 1 ) {
+		newname = (char *)malloc( length );
+		strncpy( (char *)newname, (char *)traceName, length );
+	} else {
+		length = strlen( defaultName );
+		newname = (char *)malloc( length );
+		strncpy( (char *)newname, defaultName, length );
+	}
+	ctx->TraceCtx->traceName          = newname;
+	ctx->TraceCtx->traceAttribLogBits = logbits;
+
+	trOpenLogFile();
+	trSetTraceDispatch();
+}
+
+
+void glEndTraceMESA(void)
+{
+	GLcontext * ctx;
+
+	ctx = (GLcontext *)_glapi_get_context();
+	assert(ctx);
+	assert(ctx->TraceCtx);
+	assert(ctx->TraceDispatch);
+
+        /* Do we even have a context ? */
+        /* Are we currently between glBegin and glEnd ? */
+        /* Are we sure the current dispatch _is_ the TraceDispatch ? */
+	if (!ctx ||
+            (ctx->TraceCtx->betweenBeginEnd == GL_TRUE)  ||
+	    (ctx->TraceDispatch != _glapi_get_override_dispatch(1)) ) {
+		_mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__ );
+		return;
+	}
+
+#if 0
+	/* Always dump the max indices */
+// But not yet...
+	trWriteCMD( VAR_COLORPOINTER );
+	trWritei( ctx->TraceCtx->trColorPtrState.maxIndex );
+	trWriteCMD( VAR_EDGEFLAGPOINTER );
+	trWritei( ctx->TraceCtx->trEdgeFlagPtrState.maxIndex );
+	trWriteCMD( VAR_INDEXPOINTER );
+	trWritei( ctx->TraceCtx->trIndexPtrState.maxIndex );
+	trWriteCMD( VAR_NORMALPOINTER );
+	trWritei( ctx->TraceCtx->trNormalPtrState.maxIndex );
+	trWriteCMD( VAR_TEXCOORDPOINTER );
+	trWritei( ctx->TraceCtx->trTexCoordPtrState.maxIndex );
+	trWriteCMD( VAR_VERTEXPOINTER );
+	trWritei( ctx->TraceCtx->trVertexPtrState.maxIndex );
+#endif
+
+	trCloseLogFile();
+	trSetOriginalDispatch();
+}
+
+
+void glTraceAssertAttribMESA( GLbitfield attribMask )
+{
+#warning TraceAssertAttrib not implemented
+}
+
+
+void glTraceCommentMESA( const GLubyte * comment )
+{
+	trWriteString( (char *)comment );
+}
+
+
+void glTraceTextureMESA( GLuint name, const GLubyte* comment )
+{
+#warning TraceTexture not implemented
+}
+
+void glTraceListMESA( GLuint name, const GLubyte* comment )
+{
+#warning TraceList not implemented
+}
+
+
+void glTracePointerMESA( GLvoid* pointer, const GLubyte* comment )
+{
+#warning TracePointer not implemented
+}
+
+
+void glTracePointerRangeMESA( const GLvoid* first, const GLvoid* last, const GLubyte* comment )
+{
+#warning TracePointerRange not implemented
+}
+
+#else
+extern void tr_control_dummy_func(void);
+void tr_control_dummy_func(void)
+{
+}
+#endif
Index: xc/extras/Mesa/src/Trace/tr_error.c
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_error.c:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_error.c	Wed Dec 11 16:13:33 2002
@@ -0,0 +1,40 @@
+#ifdef MESA_TRACE
+
+#include "tr_context.h"
+#include "tr_error.h"
+#include "tr_write.h"
+
+
+/* Have a Begin/End flag, skip checks if in-between. */
+
+
+/**
+ * Some GL implementations cache errors internally,
+ *  thus we have to loop until we do not get
+ *  any errors.
+ */
+void trError( void ) {
+	int     sanity = 0;  /* Bail out on endless loops. */
+	GLenum  err;
+
+	if( !(trCtx()->check_errors) )
+		return;
+
+	while ( (err=trGetDispatch()->GetError())!=GL_NO_ERROR ) {
+		trWriteEnum(err);
+		sanity++;
+
+		if (sanity > TR_MAX_QUEUED_ERRORS ) {
+			/* Too many errors */
+			return;
+		}
+	}
+}
+
+
+#else
+extern void tr_error_dummy_func(void);
+void tr_error_dummy_func(void)
+{
+}
+#endif
Index: xc/extras/Mesa/src/Trace/tr_error.h
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_error.h:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_error.h	Wed Dec 11 16:13:33 2002
@@ -0,0 +1,7 @@
+#ifndef TR_ERROR_H
+#define TR_ERROR_H
+
+extern void trError( void );
+
+#endif
+
Index: xc/extras/Mesa/src/Trace/tr_support.c
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_support.c:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_support.c	Wed Dec 11 16:13:33 2002
@@ -0,0 +1,584 @@
+#ifdef MESA_TRACE
+
+#include "GL/gl.h"
+#include "tr_context.h"
+#include "tr_support.h"
+#include "tr_write.h"
+
+
+#if 0
+static void trQueryConvolutionState( void ) {
+
+	if( trCtx()->trConvolutionWidth == -1 ) {
+		/* Query it */
+		trWriteCMD( VAR_OOBBEGIN );
+		trGetDispatch()->GetConvolutionParameteriv( GL_SEPARABLE_2D, GL_CONVOLUTION_WIDTH,
+		                                          &(trCtx()->trConvolutionWidth) );
+		trWriteCMD( VAR_OOBEND );
+	}
+
+	if( trCtx()->trConvolutionHeight == -1 ) {
+		/* Query it */
+		trWriteCMD( VAR_OOBBEGIN );
+		trGetDispatch()->GetConvolutionParameteriv( GL_SEPARABLE_2D, GL_CONVOLUTION_HEIGHT,
+		                                          &(trCtx()->trConvolutionHeight) );
+		trWriteCMD( VAR_OOBEND );
+	}
+}
+#endif
+
+
+void trZeroGetterData( GLenum pname, GLsizei typesize, GLvoid * params ) {
+
+   switch( pname ) {
+      case GL_COLOR_MATRIX:
+      case GL_MODELVIEW_MATRIX:
+      case GL_PROJECTION_MATRIX:
+      case GL_TEXTURE_MATRIX:
+			memset( params, 0, typesize * 16 );
+         break;
+
+      case GL_ACCUM_CLEAR_VALUE:
+      case GL_BLEND_COLOR:
+      case GL_COLOR_CLEAR_VALUE:
+      case GL_COLOR_WRITEMASK:
+      case GL_CURRENT_COLOR:
+      case GL_CURRENT_RASTER_COLOR:
+      case GL_CURRENT_RASTER_POSITION:
+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
+      case GL_CURRENT_TEXTURE_COORDS:
+      case GL_LIGHT_MODEL_AMBIENT:
+      case GL_MAP2_GRID_DOMAIN:
+      case GL_SCISSOR_BOX:
+      case GL_VIEWPORT:
+			memset( params, 0, typesize * 4 );
+         break;
+
+      case GL_CURRENT_NORMAL:
+			memset( params, 0, typesize * 3 );
+         break;
+
+      case GL_ALIASED_POINT_SIZE_RANGE:
+      case GL_ALIASED_LINE_WIDTH_RANGE:
+      case GL_DEPTH_RANGE:
+      case GL_MAP1_GRID_DOMAIN:
+      case GL_MAP2_GRID_SEGMENTS:
+      case GL_MAX_VIEWPORT_DIMS:
+      case GL_POLYGON_MODE:
+      case GL_SMOOTH_LINE_WIDTH_RANGE:
+      case GL_SMOOTH_POINT_SIZE_RANGE:
+			memset( params, 0, typesize * 2 );
+         break;
+
+      case GL_ACCUM_ALPHA_BITS:
+      case GL_ACCUM_BLUE_BITS:
+      case GL_ACCUM_GREEN_BITS:
+      case GL_ACCUM_RED_BITS:
+      case GL_ACTIVE_TEXTURE_ARB:
+      case GL_ALPHA_BIAS:
+      case GL_ALPHA_BITS:
+      case GL_ALPHA_SCALE:
+      case GL_ALPHA_TEST:
+      case GL_ALPHA_TEST_FUNC:
+      case GL_ALPHA_TEST_REF:
+      case GL_ATTRIB_STACK_DEPTH:
+      case GL_AUTO_NORMAL:
+      case GL_AUX_BUFFERS:
+      case GL_BLEND:
+      case GL_BLEND_SRC:
+      case GL_BLUE_BIAS:
+      case GL_BLUE_BITS:
+      case GL_BLUE_SCALE:
+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_CLIP_PLANE0:
+      case GL_CLIP_PLANE1:
+      case GL_CLIP_PLANE2:
+      case GL_CLIP_PLANE3:
+      case GL_CLIP_PLANE4:
+      case GL_CLIP_PLANE5:
+      case GL_COLOR_ARRAY:
+      case GL_COLOR_ARRAY_SIZE:
+      case GL_COLOR_ARRAY_STRIDE:
+      case GL_COLOR_ARRAY_TYPE:
+      case GL_COLOR_LOGIC_OP:
+      case GL_COLOR_MATERIAL:
+      case GL_COLOR_MATERIAL_FACE:
+      case GL_COLOR_MATERIAL_PARAMETER:
+      case GL_COLOR_MATRIX_STACK_DEPTH:
+      case GL_COLOR_TABLE:
+      case GL_CONVOLUTION_1D:
+      case GL_CONVOLUTION_2D:
+      case GL_CULL_FACE:
+      case GL_CULL_FACE_MODE:
+      case GL_CURRENT_INDEX:
+      case GL_CURRENT_RASTER_DISTANCE:
+      case GL_CURRENT_RASTER_INDEX:
+      case GL_CURRENT_RASTER_POSITION_VALID:
+      case GL_DEPTH_BIAS:
+      case GL_DEPTH_CLEAR_VALUE:
+      case GL_DEPTH_FUNC:
+      case GL_DEPTH_SCALE:
+      case GL_DEPTH_TEST:
+      case GL_DEPTH_WRITEMASK:
+      case GL_DITHER:
+      case GL_DOUBLEBUFFER:
+      case GL_DRAW_BUFFER:
+      case GL_EDGE_FLAG:
+      case GL_EDGE_FLAG_ARRAY:
+      case GL_EDGE_FLAG_ARRAY_STRIDE:
+      case GL_FEEDBACK_BUFFER_SIZE:
+      case GL_FEEDBACK_BUFFER_TYPE:
+      case GL_FOG:
+      case GL_FOG_DENSITY:
+      case GL_FOG_END:
+      case GL_FOG_HINT:
+      case GL_FOG_INDEX:
+      case GL_FOG_MODE:
+      case GL_FOG_START:
+      case GL_FRONT_FACE:
+      case GL_GREEN_BIAS:
+      case GL_GREEN_BITS:
+      case GL_GREEN_SCALE:
+      case GL_HISTOGRAM:
+      case GL_INDEX_ARRAY:
+      case GL_INDEX_ARRAY_STRIDE:
+      case GL_INDEX_ARRAY_TYPE:
+      case GL_INDEX_BITS:
+      case GL_INDEX_CLEAR_VALUE:
+      case GL_INDEX_LOGIC_OP:
+      case GL_INDEX_MODE:
+      case GL_INDEX_OFFSET:
+      case GL_INDEX_SHIFT:
+      case GL_INDEX_WRITEMASK:
+      case GL_LIGHT0:
+      case GL_LIGHT1:
+      case GL_LIGHT2:
+      case GL_LIGHT3:
+      case GL_LIGHT4:
+      case GL_LIGHT5:
+      case GL_LIGHT6:
+      case GL_LIGHT7:
+      case GL_LIGHTING:
+      case GL_LIGHT_MODEL_COLOR_CONTROL:
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
+      case GL_LIGHT_MODEL_TWO_SIDE:
+      case GL_LINE_SMOOTH:
+      case GL_LINE_SMOOTH_HINT:
+      case GL_LINE_STIPPLE:
+      case GL_LINE_STIPPLE_PATTERN:
+      case GL_LINE_STIPPLE_REPEAT:
+      case GL_LINE_WIDTH:
+      case GL_LIST_BASE:
+      case GL_LIST_INDEX:
+      case GL_LIST_MODE:
+      case GL_LOGIC_OP_MODE:
+      case GL_MAP1_COLOR_4:
+      case GL_MAP1_GRID_SEGMENTS:
+      case GL_MAP1_INDEX:
+      case GL_MAP1_NORMAL:
+      case GL_MAP1_TEXTURE_COORD_1:
+      case GL_MAP1_TEXTURE_COORD_2:
+      case GL_MAP1_TEXTURE_COORD_3:
+      case GL_MAP1_TEXTURE_COORD_4:
+      case GL_MAP1_VERTEX_3:
+      case GL_MAP1_VERTEX_4:
+      case GL_MAP2_COLOR_4:
+      case GL_MAP2_INDEX:
+      case GL_MAP2_NORMAL:
+      case GL_MAP2_TEXTURE_COORD_1:
+      case GL_MAP2_TEXTURE_COORD_2:
+      case GL_MAP2_TEXTURE_COORD_3:
+      case GL_MAP2_TEXTURE_COORD_4:
+      case GL_MAP2_VERTEX_3:
+      case GL_MAP2_VERTEX_4:
+      case GL_MAP_COLOR:
+      case GL_MAP_STENCIL:
+      case GL_MATRIX_MODE:
+      case GL_MAX_3D_TEXTURE_SIZE:
+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_MAX_ATTRIB_STACK_DEPTH:
+      case GL_MAX_CLIP_PLANES:
+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
+      case GL_MAX_ELEMENTS_VERTICES:
+      case GL_MAX_EVAL_ORDER:
+      case GL_MAX_LIGHTS:
+      case GL_MAX_LIST_NESTING:
+      case GL_MAX_MODELVIEW_STACK_DEPTH:
+      case GL_MAX_NAME_STACK_DEPTH:
+      case GL_MAX_PIXEL_MAP_TABLE:
+      case GL_MAX_PROJECTION_STACK_DEPTH:
+      case GL_MAX_TEXTURE_SIZE:
+      case GL_MAX_TEXTURE_STACK_DEPTH:
+      case GL_MAX_TEXTURE_UNITS_ARB:
+      case GL_MINMAX:
+      case GL_MODELVIEW_STACK_DEPTH:
+      case GL_NAME_STACK_DEPTH:
+      case GL_NORMAL_ARRAY:
+      case GL_NORMAL_ARRAY_STRIDE:
+      case GL_NORMAL_ARRAY_TYPE:
+      case GL_NORMALIZE:
+      case GL_PACK_ALIGNMENT:
+      case GL_PACK_IMAGE_HEIGHT:
+      case GL_PACK_LSB_FIRST:
+      case GL_PACK_ROW_LENGTH:
+      case GL_PACK_SKIP_IMAGES:
+      case GL_PACK_SKIP_PIXELS:
+      case GL_PACK_SKIP_ROWS:
+      case GL_PACK_SWAP_BYTES:
+      case GL_PERSPECTIVE_CORRECTION_HINT:
+      case GL_PIXEL_MAP_A_TO_A_SIZE:
+      case GL_PIXEL_MAP_B_TO_B_SIZE:
+      case GL_PIXEL_MAP_G_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_A_SIZE:
+      case GL_PIXEL_MAP_I_TO_B_SIZE:
+      case GL_PIXEL_MAP_I_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_I_SIZE:
+      case GL_PIXEL_MAP_I_TO_R_SIZE:
+      case GL_PIXEL_MAP_R_TO_R_SIZE:
+      case GL_PIXEL_MAP_S_TO_S_SIZE:
+      case GL_POINT_SIZE:
+      case GL_POINT_SMOOTH:
+      case GL_POINT_SMOOTH_HINT:
+      case GL_POLYGON_OFFSET_FACTOR:
+      case GL_POLYGON_OFFSET_UNITS:
+      case GL_POLYGON_OFFSET_FILL:
+      case GL_POLYGON_OFFSET_LINE:
+      case GL_POLYGON_OFFSET_POINT:
+      case GL_POLYGON_SMOOTH:
+      case GL_POLYGON_SMOOTH_HINT:
+      case GL_POLYGON_STIPPLE:
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE:
+      case GL_POST_COLOR_MATRIX_RED_BIAS:
+      case GL_POST_COLOR_MATRIX_GREEN_BIAS:
+      case GL_POST_COLOR_MATRIX_BLUE_BIAS:
+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
+      case GL_POST_COLOR_MATRIX_RED_SCALE:
+      case GL_POST_COLOR_MATRIX_GREEN_SCALE:
+      case GL_POST_COLOR_MATRIX_BLUE_SCALE:
+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
+      case GL_POST_CONVOLUTION_COLOR_TABLE:
+      case GL_POST_CONVOLUTION_RED_BIAS:
+      case GL_POST_CONVOLUTION_GREEN_BIAS:
+      case GL_POST_CONVOLUTION_BLUE_BIAS:
+      case GL_POST_CONVOLUTION_ALPHA_BIAS:
+      case GL_POST_CONVOLUTION_RED_SCALE:
+      case GL_POST_CONVOLUTION_GREEN_SCALE:
+      case GL_POST_CONVOLUTION_BLUE_SCALE:
+      case GL_POST_CONVOLUTION_ALPHA_SCALE:
+      case GL_PROJECTION_STACK_DEPTH:
+      case GL_READ_BUFFER:
+      case GL_RED_BIAS:
+      case GL_RED_BITS:
+      case GL_RED_SCALE:
+      case GL_RENDER_MODE:
+      case GL_RESCALE_NORMAL:
+      case GL_RGBA_MODE:
+      case GL_SCISSOR_TEST:
+      case GL_SELECTION_BUFFER_SIZE:
+      case GL_SEPARABLE_2D:
+      case GL_SHADE_MODEL:
+      case GL_SMOOTH_LINE_WIDTH_GRANULARITY:
+      case GL_SMOOTH_POINT_SIZE_GRANULARITY:
+      case GL_STENCIL_BITS:
+      case GL_STENCIL_CLEAR_VALUE:
+      case GL_STENCIL_FAIL:
+      case GL_STENCIL_FUNC:
+      case GL_STENCIL_PASS_DEPTH_FAIL:
+      case GL_STENCIL_PASS_DEPTH_PASS:
+      case GL_STENCIL_REF:
+      case GL_STENCIL_TEST:
+      case GL_STENCIL_VALUE_MASK:
+      case GL_STENCIL_WRITEMASK:
+      case GL_STEREO:
+      case GL_SUBPIXEL_BITS:
+      case GL_TEXTURE_1D:
+      case GL_TEXTURE_BINDING_1D:
+      case GL_TEXTURE_2D:
+      case GL_TEXTURE_BINDING_2D:
+      case GL_TEXTURE_3D:
+      case GL_TEXTURE_BINDING_3D:
+      case GL_TEXTURE_COORD_ARRAY:
+      case GL_TEXTURE_COORD_ARRAY_SIZE:
+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
+      case GL_TEXTURE_COORD_ARRAY_TYPE:
+      case GL_TEXTURE_GEN_Q:
+      case GL_TEXTURE_GEN_R:
+      case GL_TEXTURE_GEN_S:
+      case GL_TEXTURE_GEN_T:
+      case GL_TEXTURE_STACK_DEPTH:
+      case GL_UNPACK_ALIGNMENT:
+      case GL_UNPACK_IMAGE_HEIGHT:
+      case GL_UNPACK_LSB_FIRST:
+      case GL_UNPACK_ROW_LENGTH:
+      case GL_UNPACK_SKIP_IMAGES:
+      case GL_UNPACK_SKIP_PIXELS:
+      case GL_UNPACK_SKIP_ROWS:
+      case GL_UNPACK_SWAP_BYTES:
+      case GL_VERTEX_ARRAY:
+      case GL_VERTEX_ARRAY_SIZE:
+      case GL_VERTEX_ARRAY_STRIDE:
+      case GL_VERTEX_ARRAY_TYPE:
+      case GL_ZOOM_X:
+      case GL_ZOOM_Y:
+			memset( params, 0, typesize );
+         break;
+
+      default:
+         /* Bad enum.  What should we do? */
+         break;
+   }
+}
+
+
+void trPrintColorTableData( GLenum pname, GLenum type, GLvoid * params ) {
+   if( !(trCtx()->doExec) ) {
+		switch( pname ) {
+			case GL_COLOR_TABLE_SCALE:
+			case GL_COLOR_TABLE_BIAS:
+            if( type == GL_FLOAT ) {
+				   memset( params, 0, 4 * sizeof(GLfloat) );
+            } else {
+               memset( params, 0, 4 * sizeof(GLint) );
+            }
+				break;
+
+			case GL_COLOR_TABLE_FORMAT:
+			case GL_COLOR_TABLE_WIDTH:
+			case GL_COLOR_TABLE_RED_SIZE:
+			case GL_COLOR_TABLE_GREEN_SIZE:
+			case GL_COLOR_TABLE_BLUE_SIZE:
+			case GL_COLOR_TABLE_ALPHA_SIZE:
+			case GL_COLOR_TABLE_LUMINANCE_SIZE:
+			case GL_COLOR_TABLE_INTENSITY_SIZE:
+            if( type == GL_FLOAT ) {
+				   ((GLfloat *)params)[0] = 0.0;
+            } else {
+               ((GLint *)params)[0] = 0;
+            }
+				break;
+
+			default:
+				/* The 2nd pass should catch this */
+				break;
+		}
+	}
+
+	switch( pname ) {
+		case GL_COLOR_TABLE_SCALE:
+		case GL_COLOR_TABLE_BIAS:
+         if( type == GL_FLOAT ) {
+			   trWriteArrayf( 4, (GLfloat *)params );
+         } else {
+			   trWriteArrayi( 4, (GLint *)params );
+         }
+			break;
+
+		case GL_COLOR_TABLE_FORMAT:
+		case GL_COLOR_TABLE_WIDTH:
+		case GL_COLOR_TABLE_RED_SIZE:
+		case GL_COLOR_TABLE_GREEN_SIZE:
+		case GL_COLOR_TABLE_BLUE_SIZE:
+		case GL_COLOR_TABLE_ALPHA_SIZE:
+		case GL_COLOR_TABLE_LUMINANCE_SIZE:
+		case GL_COLOR_TABLE_INTENSITY_SIZE:
+         if( type == GL_FLOAT ) {
+			   trWritef( ((GLfloat *)params)[0] );
+         } else {
+			   trWritei( ((GLint *)params)[0] );
+         }
+			break;
+
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+}
+
+
+void trWriteTypeArray( GLenum type, GLsizei width, GLsizei pixelsize, GLint start, const GLvoid * ptr ) {
+
+	switch( type ) {
+		case GL_BYTE:
+			{
+				GLbyte * p = (GLbyte *)ptr + start * pixelsize;
+				trWriteArrayb( width * pixelsize, p );
+			}
+			break;
+
+		case GL_UNSIGNED_BYTE:
+		case GL_UNSIGNED_BYTE_3_3_2:
+		case GL_UNSIGNED_BYTE_2_3_3_REV:
+			{
+				GLubyte * p = (GLubyte *)ptr + start * pixelsize;
+				trWriteArrayub( width * pixelsize, p );
+			}
+			break;
+
+		case GL_SHORT:
+			{
+				GLshort * p = (GLshort *)ptr + start * pixelsize;
+				trWriteArrays( width * pixelsize, p );
+			}
+			break;
+
+		case GL_UNSIGNED_SHORT:
+		case GL_UNSIGNED_SHORT_5_6_5:
+		case GL_UNSIGNED_SHORT_5_6_5_REV:
+		case GL_UNSIGNED_SHORT_4_4_4_4:
+		case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+		case GL_UNSIGNED_SHORT_5_5_5_1:
+		case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+			{
+				GLushort * p = (GLushort *)ptr + start * pixelsize;
+				trWriteArrayus( width * pixelsize, p );
+			}
+			break;
+
+		case GL_INT:
+			{
+				GLint * p = (GLint *)ptr + start * pixelsize;
+				trWriteArrayi( width * pixelsize, p );
+			}
+			break;
+
+		case GL_UNSIGNED_INT:
+		case GL_UNSIGNED_INT_8_8_8_8:
+		case GL_UNSIGNED_INT_8_8_8_8_REV:
+		case GL_UNSIGNED_INT_10_10_10_2:
+		case GL_UNSIGNED_INT_2_10_10_10_REV:
+			{
+				GLuint * p = (GLuint *)ptr + start * pixelsize;
+				trWriteArrayui( width * pixelsize, p );
+			}
+			break;
+
+		case GL_FLOAT:
+			{
+				GLfloat * p = (GLfloat *)ptr + start * pixelsize;
+				trWriteArrayf( width * pixelsize, p );
+			}
+			break;
+
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+}
+
+
+static GLint trGetFormatSize( GLenum format ) {
+	GLint pixelsize;
+
+	switch( format ) {
+		case GL_RED:
+		case GL_GREEN:
+		case GL_BLUE:
+		case GL_ALPHA:
+		case GL_LUMINANCE:
+		case GL_INTENSITY:
+		case GL_COLOR_INDEX:
+		case GL_STENCIL_INDEX:
+		case GL_DEPTH_COMPONENT:
+			pixelsize = 1;
+			break;
+		case GL_LUMINANCE_ALPHA:
+			pixelsize = 2;
+			break;
+		case GL_RGB:
+		case GL_BGR:
+			pixelsize = 3;
+			break;
+		case GL_RGBA:
+		case GL_BGRA:
+			pixelsize = 4;
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			pixelsize = 0;
+			break;
+	}
+
+	return pixelsize;
+}
+
+
+GLint trGetPixelSize( GLenum format, GLenum type ) {
+   GLint retval;
+   GLint formatsize = trGetFormatSize( format );
+
+   switch( type ) {
+		case GL_BYTE:
+		case GL_UNSIGNED_BYTE:
+         retval = formatsize * sizeof(GLubyte);
+         break;
+
+		case GL_UNSIGNED_BYTE_3_3_2:
+		case GL_UNSIGNED_BYTE_2_3_3_REV:
+         if( (type == GL_RGB) || (type == GL_BGR) ) {
+            retval = sizeof(GLubyte);
+         } else {
+            retval = -1;
+         }
+         break;
+
+		case GL_SHORT:
+		case GL_UNSIGNED_SHORT:
+         retval = sizeof(GLushort);
+         break;
+
+		case GL_UNSIGNED_SHORT_5_6_5:
+		case GL_UNSIGNED_SHORT_5_6_5_REV:
+         if( (type == GL_RGB) || (type == GL_BGR) ) {
+            retval = sizeof(GLushort);
+         } else {
+            retval = -1;
+         }
+         break;
+
+		case GL_UNSIGNED_SHORT_4_4_4_4:
+		case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+		case GL_UNSIGNED_SHORT_5_5_5_1:
+		case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+         if( (type == GL_RGBA) || (type == GL_BGRA) ) {
+            retval = sizeof(GLushort);
+         } else {
+            retval = -1;
+         }
+         break;
+
+		case GL_INT:
+		case GL_UNSIGNED_INT:
+         retval = sizeof(GLuint);
+         break;
+
+		case GL_UNSIGNED_INT_8_8_8_8:
+		case GL_UNSIGNED_INT_8_8_8_8_REV:
+		case GL_UNSIGNED_INT_10_10_10_2:
+		case GL_UNSIGNED_INT_2_10_10_10_REV:
+         if( (type == GL_RGBA) || (type == GL_BGRA) ) {
+            retval = sizeof(GLuint);
+         } else {
+            retval = -1;
+         }
+         break;
+
+		case GL_FLOAT:
+         retval = sizeof(GLfloat);
+         break;
+
+      default:
+         retval = -1;
+         break;
+   }
+
+   return retval;
+}
+
+
+#else
+extern void tr_support_dummy_func(void);
+void tr_support_dummy_func(void)
+{
+}
+#endif
Index: xc/extras/Mesa/src/Trace/tr_support.h
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_support.h:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_support.h	Wed Dec 11 16:13:33 2002
@@ -0,0 +1,16 @@
+#ifndef TR_SUPPORT_H
+#define TR_SUPPORT_H
+
+
+extern void trQueryConvolutionState( void );
+
+extern void trZeroGetterData( GLenum pname, GLsizei typesize, GLvoid * params );
+
+extern void trPrintColorTableData( GLenum pname, GLenum type, GLvoid * params );
+
+extern void trWriteTypeArray( GLenum type, GLsizei width, GLsizei pixelsize, GLint start, const GLvoid * ptr );
+
+extern GLint trGetPixelSize( GLenum format, GLenum type );
+
+
+#endif
Index: xc/extras/Mesa/src/Trace/tr_wrapper.c
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_wrapper.c:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_wrapper.c	Wed Dec 11 16:13:33 2002
@@ -0,0 +1,9311 @@
+#ifdef MESA_TRACE
+
+#include "glheader.h"
+#include "glapitable.h"
+#include "tr_write.h"
+#include "tr_error.h"
+#include "tr_context.h"
+#include "tr_commands.h"
+#include "tr_support.h"
+#include "tr_wrapper.h"
+
+
+#ifdef GLAPI
+#undef GLAPI
+#endif
+#define GLAPI static
+
+#ifdef GLAPIENTRY
+#undef GLAPIENTRY
+#endif
+#define GLAPIENTRY
+
+
+GLAPI void GLAPIENTRY trAccum( GLenum op, GLfloat value ) {
+	trWriteCMD( CMD_ACCUM );
+	trWriteEnum( op );
+	trWritef( value );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Accum( op, value );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trActiveTextureARB( GLenum texture) {
+	trWriteCMD( CMD_ACTIVETEXTUREARB );
+	trWriteEnum( texture );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ActiveTextureARB( texture );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trAlphaFunc( GLenum func, GLclampf ref ) {
+	trWriteCMD( CMD_ALPHAFUNC );
+	trWriteEnum( func );
+	trWriteClampf( ref );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->AlphaFunc( func, ref );
+		trError();
+	}
+}
+
+
+GLAPI GLboolean GLAPIENTRY trAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences ) {
+	GLboolean retval;
+
+	trWriteCMD( CMD_ARETEXTURESRESIDENT );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures );
+	trFileFlush();
+	trWriteArrayui( n, textures );
+	trWritePointer( (void *)residences  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->AreTexturesResident( n, textures, residences  );
+		trError();
+	} else {
+		memset( residences, 0, n * sizeof(GLboolean) );
+		retval = GL_NO_ERROR;
+	}
+
+	trWriteBool( retval );
+	trWriteArrayBool( n, residences );
+
+	return retval;
+}
+
+
+GLAPI GLboolean GLAPIENTRY trAreTexturesResidentEXT( GLsizei n, const GLuint *textures, GLboolean *residences ) {
+	GLboolean retval;
+
+	trWriteCMD( CMD_ARETEXTURESRESIDENTEXT );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures );
+	trFileFlush();
+	trWriteArrayui( n, textures );
+	trWritePointer( (void *)residences  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->AreTexturesResidentEXT( n, textures, residences  );
+		trError();
+	} else {
+		memset( residences, 0, n * sizeof(GLboolean) );
+		retval = GL_NO_ERROR;
+	}
+
+	trWriteBool( retval );
+	trWriteArrayBool( n, residences );
+
+	return retval;
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trArrayElementEXT( GLint i ) {
+	trWriteCMD( CMD_ARRAYELEMENTEXT );
+	trWritei( i );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ArrayElementEXT( i );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trArrayElement( GLint i ) {
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_ARRAYELEMENT );
+	trWritei( i );
+
+	tctx = trCtx();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->ArrayElement( i );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trBegin( GLenum mode ) {
+	trWriteCMD( CMD_BEGIN );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Begin( mode );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trBindTextureEXT( GLenum target, GLuint texture ) {
+	trWriteCMD( CMD_BINDTEXTUREEXT );
+	trWriteEnum( target );
+	trWriteui( texture );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->BindTextureEXT( target, texture );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trBindTexture( GLenum target, GLuint texture ) {
+	trWriteCMD( CMD_BINDTEXTURE );
+	trWriteEnum( target );
+	trWriteui( texture );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->BindTexture( target, texture );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap ) {
+	trWriteCMD( CMD_BITMAP );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWritef( xorig );
+	trWritef( yorig );
+	trWritef( xmove );
+	trWritef( ymove );
+	trWritePointer( (void *)bitmap  );
+	trFileFlush();
+	trWriteArrayub( width * height / 8, bitmap );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Bitmap( width, height, xorig, yorig, xmove, ymove, bitmap  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trBlendColorEXT( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
+	trWriteCMD( CMD_BLENDCOLOREXT );
+	trWriteClampf( red );
+	trWriteClampf( green );
+	trWriteClampf( blue );
+	trWriteClampf( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->BlendColorEXT( red, green, blue, alpha );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
+	trWriteCMD( CMD_BLENDCOLOR );
+	trWriteClampf( red );
+	trWriteClampf( green );
+	trWriteClampf( blue );
+	trWriteClampf( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->BlendColor( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trBlendEquationEXT( GLenum mode ) {
+	trWriteCMD( CMD_BLENDEQUATIONEXT );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->BlendEquationEXT( mode );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trBlendEquation( GLenum mode ) {
+	trWriteCMD( CMD_BLENDEQUATION );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->BlendEquation( mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trBlendFunc( GLenum sfactor, GLenum dfactor ) {
+	trWriteCMD( CMD_BLENDFUNC );
+	trWriteEnum( sfactor );
+	trWriteEnum( dfactor );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->BlendFunc( sfactor, dfactor );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCallList( GLuint list ) {
+	trWriteCMD( CMD_CALLLIST );
+	trWriteui( list );
+
+	if( trCtx()->doExec ) {
+		trSetOriginalDispatch();
+		trGetDispatch()->CallList( list );
+		trSetTraceDispatch();
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCallLists( GLsizei n, GLenum type, const GLvoid *lists ) {
+	trWriteCMD( CMD_CALLLISTS );
+	trWriteSizei( n );
+	trWriteEnum( type );
+	trWritePointer( (void *)lists  );
+	trFileFlush();
+
+	switch( type ) {
+		case GL_2_BYTES:
+			trWriteTypeArray( GL_UNSIGNED_BYTE, n, 2, 0, lists );
+			break;
+		case GL_3_BYTES:
+			trWriteTypeArray( GL_UNSIGNED_BYTE, n, 3, 0, lists );
+			break;
+		case GL_4_BYTES:
+			trWriteTypeArray( GL_UNSIGNED_BYTE, n, 4, 0, lists );
+			break;
+		default:
+			trWriteTypeArray( type, n, 1, 0, lists );
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trSetOriginalDispatch();
+		trGetDispatch()->CallLists( n, type, lists  );
+		trSetTraceDispatch();
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+	trWriteCMD( CMD_CLEARACCUM );
+	trWritef( red );
+	trWritef( green );
+	trWritef( blue );
+	trWritef( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ClearAccum( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
+	trWriteCMD( CMD_CLEARCOLOR );
+	trWriteClampf( red );
+	trWriteClampf( green );
+	trWriteClampf( blue );
+	trWriteClampf( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ClearColor( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClearDepth( GLclampd depth ) {
+	trWriteCMD( CMD_CLEARDEPTH );
+	trWriteClampd( depth );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ClearDepth( depth );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClear( GLbitfield mask ) {
+	trWriteCMD( CMD_CLEAR );
+	trWriteBits( mask );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Clear( mask );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClearIndex( GLfloat c ) {
+	trWriteCMD( CMD_CLEARINDEX );
+	trWritef( c );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ClearIndex( c );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClearStencil( GLint s ) {
+	trWriteCMD( CMD_CLEARSTENCIL );
+	trWritei( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ClearStencil( s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClientActiveTextureARB( GLenum texture) {
+	trWriteCMD( CMD_CLIENTACTIVETEXTUREARB );
+	trWriteEnum( texture );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ClientActiveTextureARB( texture );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trClipPlane( GLenum plane, const GLdouble *equation ) {
+	trWriteCMD( CMD_CLIPPLANE );
+	trWriteEnum( plane );
+	trWritePointer( (void *)equation  );
+	trFileFlush();
+	trWriteArrayd( 4, equation );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ClipPlane( plane, equation  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3b( GLbyte red, GLbyte green, GLbyte blue ) {
+	trWriteCMD( CMD_COLOR3B );
+	trWriteb( red );
+	trWriteb( green );
+	trWriteb( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3b( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3bv( const GLbyte *v ) {
+	trWriteCMD( CMD_COLOR3BV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayb( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3bv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3d( GLdouble red, GLdouble green, GLdouble blue ) {
+	trWriteCMD( CMD_COLOR3D );
+	trWrited( red );
+	trWrited( green );
+	trWrited( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3d( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3dv( const GLdouble *v ) {
+	trWriteCMD( CMD_COLOR3DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3f( GLfloat red, GLfloat green, GLfloat blue ) {
+	trWriteCMD( CMD_COLOR3F );
+	trWritef( red );
+	trWritef( green );
+	trWritef( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3f( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3fv( const GLfloat *v ) {
+	trWriteCMD( CMD_COLOR3FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3i( GLint red, GLint green, GLint blue ) {
+	trWriteCMD( CMD_COLOR3I );
+	trWritei( red );
+	trWritei( green );
+	trWritei( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3i( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3iv( const GLint *v ) {
+	trWriteCMD( CMD_COLOR3IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3s( GLshort red, GLshort green, GLshort blue ) {
+	trWriteCMD( CMD_COLOR3S );
+	trWrites( red );
+	trWrites( green );
+	trWrites( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3s( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3sv( const GLshort *v ) {
+	trWriteCMD( CMD_COLOR3SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3ub( GLubyte red, GLubyte green, GLubyte blue ) {
+	trWriteCMD( CMD_COLOR3UB );
+	trWriteub( red );
+	trWriteub( green );
+	trWriteub( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3ub( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3ubv( const GLubyte *v ) {
+	trWriteCMD( CMD_COLOR3UBV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayub( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3ubv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3ui( GLuint red, GLuint green, GLuint blue ) {
+	trWriteCMD( CMD_COLOR3UI );
+	trWriteui( red );
+	trWriteui( green );
+	trWriteui( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3ui( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3uiv( const GLuint *v ) {
+	trWriteCMD( CMD_COLOR3UIV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayui( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3uiv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3us( GLushort red, GLushort green, GLushort blue ) {
+	trWriteCMD( CMD_COLOR3US );
+	trWriteus( red );
+	trWriteus( green );
+	trWriteus( blue );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3us( red, green, blue );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor3usv( const GLushort *v ) {
+	trWriteCMD( CMD_COLOR3USV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayus( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color3usv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) {
+	trWriteCMD( CMD_COLOR4B );
+	trWriteb( red );
+	trWriteb( green );
+	trWriteb( blue );
+	trWriteb( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4b( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4bv( const GLbyte *v ) {
+	trWriteCMD( CMD_COLOR4BV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayb( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4bv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) {
+	trWriteCMD( CMD_COLOR4D );
+	trWrited( red );
+	trWrited( green );
+	trWrited( blue );
+	trWrited( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4d( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4dv( const GLdouble *v ) {
+	trWriteCMD( CMD_COLOR4DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+	trWriteCMD( CMD_COLOR4F );
+	trWritef( red );
+	trWritef( green );
+	trWritef( blue );
+	trWritef( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4f( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4fv( const GLfloat *v ) {
+	trWriteCMD( CMD_COLOR4FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4i( GLint red, GLint green, GLint blue, GLint alpha ) {
+	trWriteCMD( CMD_COLOR4I );
+	trWritei( red );
+	trWritei( green );
+	trWritei( blue );
+	trWritei( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4i( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4iv( const GLint *v ) {
+	trWriteCMD( CMD_COLOR4IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha ) {
+	trWriteCMD( CMD_COLOR4S );
+	trWrites( red );
+	trWrites( green );
+	trWrites( blue );
+	trWrites( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4s( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4sv( const GLshort *v ) {
+	trWriteCMD( CMD_COLOR4SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) {
+	trWriteCMD( CMD_COLOR4UB );
+	trWriteub( red );
+	trWriteub( green );
+	trWriteub( blue );
+	trWriteub( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4ub( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4ubv( const GLubyte *v ) {
+	trWriteCMD( CMD_COLOR4UBV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayub( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4ubv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha ) {
+	trWriteCMD( CMD_COLOR4UI );
+	trWriteui( red );
+	trWriteui( green );
+	trWriteui( blue );
+	trWriteui( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4ui( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4uiv( const GLuint *v ) {
+	trWriteCMD( CMD_COLOR4UIV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayui( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4uiv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha ) {
+	trWriteCMD( CMD_COLOR4US );
+	trWriteus( red );
+	trWriteus( green );
+	trWriteus( blue );
+	trWriteus( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4us( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColor4usv( const GLushort *v ) {
+	trWriteCMD( CMD_COLOR4USV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayus( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Color4usv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {
+	trWriteCMD( CMD_COLORMASK );
+	trWriteBool( red );
+	trWriteBool( green );
+	trWriteBool( blue );
+	trWriteBool( alpha );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorMask( red, green, blue, alpha );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColorMaterial( GLenum face, GLenum mode ) {
+	trWriteCMD( CMD_COLORMATERIAL );
+	trWriteEnum( face );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorMaterial( face, mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */
+	trWriteCMD( CMD_COLORPOINTEREXT );
+	trWritei( size );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWriteSizei( count );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorPointerEXT( size, type, stride, count, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) {
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_COLORPOINTER );
+	trWritei( size );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->ColorPointer( size, type, stride, ptr  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data ) {
+	GLint pixelsize;
+
+	trWriteCMD( CMD_COLORSUBTABLEEXT );
+	trWriteEnum( target );
+	trWriteSizei( start );
+	trWriteSizei( count );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)data  );
+	trFileFlush();
+
+	pixelsize = trGetPixelSize( format, type );
+	trWriteTypeArray( type, count, pixelsize, start, data );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorSubTableEXT( target, start, count, format, type, data  );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data ) {
+	GLint pixelsize;
+
+	trWriteCMD( CMD_COLORSUBTABLE );
+	trWriteEnum( target );
+	trWriteSizei( start );
+	trWriteSizei( count );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)data  );
+	trFileFlush();
+
+	pixelsize = trGetPixelSize( format, type );
+	trWriteTypeArray( type, count, pixelsize, start, data );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorSubTable( target, start, count, format, type, data  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trColorTableEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table ) {
+	GLint pixelsize;
+
+	trWriteCMD( CMD_COLORTABLEEXT );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWriteSizei( width );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)table  );
+	trFileFlush();
+
+	pixelsize = trGetPixelSize( format, type );
+	trWriteTypeArray( type, width, pixelsize, 0, table );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorTableEXT( target, internalformat, width, format, type, table  );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table ) { /* TODO */
+	GLint pixelsize;
+
+	trWriteCMD( CMD_COLORTABLE );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWriteSizei( width );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)table  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorTable( target, internalformat, width, format, type, table  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params) {
+	trWriteCMD( CMD_COLORTABLEPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params );
+	trFileFlush();
+	trWriteArrayf( 4, params );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorTableParameterfv( target, pname, params );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trColorTableParameteriv( GLenum target, GLenum pname, const GLint *params) {
+	trWriteCMD( CMD_COLORTABLEPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params );
+	trFileFlush();
+	trWriteArrayi( 4, params );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ColorTableParameteriv( target, pname, params );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image ) {
+	GLint pixelsize;
+
+	trWriteCMD( CMD_CONVOLUTIONFILTER1D );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWriteSizei( width );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)image  );
+	trFileFlush();
+
+	pixelsize = trGetPixelSize( format, type );
+	trWriteTypeArray( type, width, pixelsize, 0, image );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ConvolutionFilter1D( target, internalformat, width, format, type, image  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image ) {
+	GLint i;
+	GLint pixelsize;
+
+	trWriteCMD( CMD_CONVOLUTIONFILTER2D );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)image  );
+	trFileFlush();
+
+	/* p76 of GL spec says this isn't subject to unpack_row_width... */
+	pixelsize = trGetPixelSize( format, type );
+	for( i = 0; i < height; i++ ) {
+		trWriteTypeArray( type, width, pixelsize, i * width, image );
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ConvolutionFilter2D( target, internalformat, width, height, format, type, image  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trConvolutionParameterf( GLenum target, GLenum pname, GLfloat params ) {
+	trWriteCMD( CMD_CONVOLUTIONPARAMETERF );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritef( params );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ConvolutionParameterf( target, pname, params );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_CONVOLUTIONPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_CONVOLUTION_BORDER_MODE:
+			trWritef( params[0] );
+			break;
+		case GL_CONVOLUTION_BORDER_COLOR:
+			trWriteArrayf( 4, params );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ConvolutionParameterfv( target, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trConvolutionParameteri( GLenum target, GLenum pname, GLint params ) {
+	trWriteCMD( CMD_CONVOLUTIONPARAMETERI );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritei( params );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ConvolutionParameteri( target, pname, params );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_CONVOLUTIONPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_CONVOLUTION_BORDER_MODE:
+			trWritei( params[0] );
+			break;
+		case GL_CONVOLUTION_BORDER_COLOR:
+			trWriteArrayi( 4, params );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ConvolutionParameteriv( target, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) {
+	trWriteCMD( CMD_COPYCOLORSUBTABLE );
+	trWriteEnum( target );
+	trWriteSizei( start );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyColorSubTable( target, start, x, y, width );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+	trWriteCMD( CMD_COPYCOLORTABLE );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyColorTable( target, internalformat, x, y, width );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+	trWriteCMD( CMD_COPYCONVOLUTIONFILTER1D );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyConvolutionFilter1D( target, internalformat, x, y, width );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {
+	trWriteCMD( CMD_COPYCONVOLUTIONFILTER2D );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyConvolutionFilter2D( target, internalformat, x, y, width, height );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) {
+	trWriteCMD( CMD_COPYPIXELS );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteEnum( type );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyPixels( x, y, width, height, type );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
+	trWriteCMD( CMD_COPYTEXIMAGE1D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWriteEnum( internalformat );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWritei( border );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyTexImage1D( target, level, internalformat, x, y, width, border );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
+	trWriteCMD( CMD_COPYTEXIMAGE2D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWriteEnum( internalformat );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWritei( border );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyTexImage2D( target, level, internalformat, x, y, width, height, border );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+	trWriteCMD( CMD_COPYTEXSUBIMAGE1D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyTexSubImage1D( target, level, xoffset, x, y, width );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+	trWriteCMD( CMD_COPYTEXSUBIMAGE2D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWritei( yoffset );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+	trWriteCMD( CMD_COPYTEXSUBIMAGE3DEXT );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWritei( yoffset );
+	trWritei( zoffset );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, x, y, width, height );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+	trWriteCMD( CMD_COPYTEXSUBIMAGE3D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWritei( yoffset );
+	trWritei( zoffset );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trCullFace( GLenum mode ) {
+	trWriteCMD( CMD_CULLFACE );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->CullFace( mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDeleteLists( GLuint list, GLsizei range ) {
+	trWriteCMD( CMD_DELETELISTS );
+	trWriteui( list );
+	trWriteSizei( range );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DeleteLists( list, range );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trDeleteTexturesEXT( GLsizei n, const GLuint *textures) {
+	trWriteCMD( CMD_DELETETEXTURESEXT );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures );
+	trFileFlush();
+	trWriteArrayui( n, textures );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DeleteTexturesEXT( n, textures );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trDeleteTextures( GLsizei n, const GLuint *textures) {
+	trWriteCMD( CMD_DELETETEXTURES );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures );
+	trFileFlush();
+	trWriteArrayui( n, textures );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DeleteTextures( n, textures );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDepthFunc( GLenum func ) {
+	trWriteCMD( CMD_DEPTHFUNC );
+	trWriteEnum( func );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DepthFunc( func );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDepthMask( GLboolean flag ) {
+	trWriteCMD( CMD_DEPTHMASK );
+	trWriteBool( flag );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DepthMask( flag );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDepthRange( GLclampd near_val, GLclampd far_val ) {
+	trWriteCMD( CMD_DEPTHRANGE );
+	trWriteClampd( near_val );
+	trWriteClampd( far_val );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DepthRange( near_val, far_val );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDisableClientState( GLenum cap ) {
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_DISABLECLIENTSTATE );
+	trWriteEnum( cap );
+
+	tctx = trCtx();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->DisableClientState( cap );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDisable( GLenum cap ) {
+	trWriteCMD( CMD_DISABLE );
+	trWriteEnum( cap );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Disable( cap );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trDrawArraysEXT( GLenum mode, GLint first, GLsizei count ) {
+	trWriteCMD( CMD_DRAWARRAYSEXT );
+	trWriteEnum( mode );
+	trWritei( first );
+	trWriteSizei( count );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DrawArraysEXT( mode, first, count );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trDrawArrays( GLenum mode, GLint first, GLsizei count ) {
+
+	trWriteCMD( CMD_DRAWARRAYS );
+	trWriteEnum( mode );
+	trWritei( first );
+	trWriteSizei( count );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DrawArrays( mode, first, count );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDrawBuffer( GLenum mode ) {
+	trWriteCMD( CMD_DRAWBUFFER );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DrawBuffer( mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) {
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_DRAWELEMENTS );
+	trWriteEnum( mode );
+	trWriteSizei( count );
+	trWriteEnum( type );
+	trWritePointer( (void *)indices  );
+	trFileFlush();
+	/* Why isn't the indices a GLint * ? */
+	trWriteArrayi( count, (GLint *)indices );
+
+	tctx = trCtx();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->DrawElements( mode, count, type, indices  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */
+	GLint pixelsize;
+
+	trWriteCMD( CMD_DRAWPIXELS );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DrawPixels( width, height, format, type, pixels  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices ) {
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_DRAWRANGEELEMENTS );
+	trWriteEnum( mode );
+	trWriteui( start );
+	trWriteui( end );
+	trWriteSizei( count );
+	trWriteEnum( type );
+	trWritePointer( (void *)indices  );
+	trFileFlush();
+	switch( type ) {
+		case GL_UNSIGNED_BYTE:
+			trWriteArrayub( count, (GLubyte *)indices );
+			break;
+		case GL_UNSIGNED_SHORT:
+			trWriteArrayus( count, (GLushort *)indices );
+			break;
+		case GL_UNSIGNED_INT:
+			trWriteArrayui( count, (GLuint *)indices );
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	tctx = trCtx();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->DrawRangeElements( mode, start, end, count, type, indices  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEdgeFlag( GLboolean flag ) {
+	trWriteCMD( CMD_EDGEFLAG );
+	trWriteBool( flag );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EdgeFlag( flag );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean *ptr ) { /* TODO */
+	trWriteCMD( CMD_EDGEFLAGPOINTEREXT );
+	trWriteSizei( stride );
+	trWriteSizei( count );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EdgeFlagPointerEXT( stride, count, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEdgeFlagPointer( GLsizei stride, const GLvoid *ptr ) { /* TODO */
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_EDGEFLAGPOINTER );
+	trWriteSizei( stride );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	tctx = trCtx();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->EdgeFlagPointer( stride, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEdgeFlagv( const GLboolean *flag ) {
+	trWriteCMD( CMD_EDGEFLAGV );
+	trWritePointer( (void *)flag  );
+	trFileFlush();
+	trWriteBool( flag[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EdgeFlagv( flag  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEnableClientState( GLenum cap ) {
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_ENABLECLIENTSTATE );
+	trWriteEnum( cap );
+
+	tctx = trCtx();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->EnableClientState( cap );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEnable( GLenum cap ) {
+	trWriteCMD( CMD_ENABLE );
+	trWriteEnum( cap );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Enable( cap );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEndList( void ) {
+	trWriteCMD( CMD_ENDLIST );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EndList(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEnd( void ) {
+	trWriteCMD( CMD_END );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->End(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord1d( GLdouble u ) {
+	trWriteCMD( CMD_EVALCOORD1D );
+	trWrited( u );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord1d( u );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord1dv( const GLdouble *u ) {
+	trWriteCMD( CMD_EVALCOORD1DV );
+	trWritePointer( (void *)u  );
+	trFileFlush();
+	trWrited( u[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord1dv( u  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord1f( GLfloat u ) {
+	trWriteCMD( CMD_EVALCOORD1F );
+	trWritef( u );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord1f( u );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord1fv( const GLfloat *u ) {
+	trWriteCMD( CMD_EVALCOORD1FV );
+	trWritePointer( (void *)u  );
+	trFileFlush();
+	trWritef( u[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord1fv( u  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord2d( GLdouble u, GLdouble v ) {
+	trWriteCMD( CMD_EVALCOORD2D );
+	trWrited( u );
+	trWrited( v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord2d( u, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord2dv( const GLdouble *u ) {
+	trWriteCMD( CMD_EVALCOORD2DV );
+	trWritePointer( (void *)u  );
+	trFileFlush();
+	trWriteArrayd( 2, u );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord2dv( u  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord2f( GLfloat u, GLfloat v ) {
+	trWriteCMD( CMD_EVALCOORD2F );
+	trWritef( u );
+	trWritef( v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord2f( u, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalCoord2fv( const GLfloat *u ) {
+	trWriteCMD( CMD_EVALCOORD2FV );
+	trWritePointer( (void *)u  );
+	trFileFlush();
+	trWriteArrayf( 2, u );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalCoord2fv( u  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalMesh1( GLenum mode, GLint i1, GLint i2 ) {
+	trWriteCMD( CMD_EVALMESH1 );
+	trWriteEnum( mode );
+	trWritei( i1 );
+	trWritei( i2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalMesh1( mode, i1, i2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) {
+	trWriteCMD( CMD_EVALMESH2 );
+	trWriteEnum( mode );
+	trWritei( i1 );
+	trWritei( i2 );
+	trWritei( j1 );
+	trWritei( j2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalMesh2( mode, i1, i2, j1, j2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalPoint1( GLint i ) {
+	trWriteCMD( CMD_EVALPOINT1 );
+	trWritei( i );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalPoint1( i );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trEvalPoint2( GLint i, GLint j ) {
+	trWriteCMD( CMD_EVALPOINT2 );
+	trWritei( i );
+	trWritei( j );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->EvalPoint2( i, j );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer ) {
+	trWriteCMD( CMD_FEEDBACKBUFFER );
+	trWriteSizei( size );
+	trWriteEnum( type );
+	trWritePointer( (void *)buffer  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->FeedbackBuffer( size, type, buffer  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFinish( void ) {
+	trWriteCMD( CMD_FINISH );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Finish(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFlush( void ) {
+	trWriteCMD( CMD_FLUSH );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Flush(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFogf( GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_FOGF );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Fogf( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFogfv( GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_FOGFV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_FOG_MODE:
+		case GL_FOG_DENSITY:
+		case GL_FOG_START:	
+		case GL_FOG_END:
+		case GL_FOG_INDEX:
+			trWritef( params[0] );
+			break;
+
+		case GL_FOG_COLOR:
+			trWriteArrayf( 4, params );
+			break;
+
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Fogfv( pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFogi( GLenum pname, GLint param ) {
+	trWriteCMD( CMD_FOGI );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Fogi( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFogiv( GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_FOGIV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_FOG_MODE:
+		case GL_FOG_DENSITY:
+		case GL_FOG_START:	
+		case GL_FOG_END:
+		case GL_FOG_INDEX:
+			trWritei( params[0] );
+			break;
+
+		case GL_FOG_COLOR:
+			trWriteArrayi( 4, params );
+			break;
+
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Fogiv( pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFrontFace( GLenum mode ) {
+	trWriteCMD( CMD_FRONTFACE );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->FrontFace( mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) {
+	trWriteCMD( CMD_FRUSTUM );
+	trWrited( left );
+	trWrited( right );
+	trWrited( bottom );
+	trWrited( top );
+	trWrited( near_val );
+	trWrited( far_val );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Frustum( left, right, bottom, top, near_val, far_val );
+		trError();
+	}
+}
+
+
+GLAPI GLuint GLAPIENTRY trGenLists( GLsizei range ) {
+	GLuint retval;
+
+	trWriteCMD( CMD_GENLISTS );
+	trWriteSizei( range );
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->GenLists( range );
+		trError();
+	} else {
+		retval = 0;
+	}
+
+	trWriteui( retval );
+	return retval;
+}
+
+
+GLAPI void GLAPIENTRY trGenTexturesEXT( GLsizei n, GLuint *textures ) {
+	trWriteCMD( CMD_GENTEXTURESEXT );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GenTexturesEXT( n, textures  );
+		trError();
+	}
+
+	if( !(trCtx()->doExec) ) {
+		memset( textures, 0, n * sizeof(GLuint) );
+	}
+
+	trWriteArrayui( n, textures );
+}
+
+
+GLAPI void GLAPIENTRY trGenTextures( GLsizei n, GLuint *textures ) {
+	trWriteCMD( CMD_GENTEXTURES );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GenTextures( n, textures  );
+		trError();
+	}
+
+	if( !(trCtx()->doExec) ) {
+		memset( textures, 0, n * sizeof(GLuint) );
+	}
+
+	trWriteArrayui( n, textures );
+}
+
+
+GLAPI void GLAPIENTRY trGetBooleanv( GLenum pname, GLboolean *params ) { /* TODO */
+	trWriteCMD( CMD_GETBOOLEANV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+   switch( pname ) {
+      case GL_COLOR_MATRIX:
+      case GL_MODELVIEW_MATRIX:
+      case GL_PROJECTION_MATRIX:
+      case GL_TEXTURE_MATRIX:
+         trWriteArrayBool( 16, params );
+         break;
+
+      case GL_ACCUM_CLEAR_VALUE:
+      case GL_BLEND_COLOR:
+      case GL_COLOR_CLEAR_VALUE:
+      case GL_COLOR_WRITEMASK:
+      case GL_CURRENT_COLOR:
+      case GL_CURRENT_RASTER_COLOR:
+      case GL_CURRENT_RASTER_POSITION:
+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
+      case GL_CURRENT_TEXTURE_COORDS:
+      case GL_LIGHT_MODEL_AMBIENT:
+      case GL_MAP2_GRID_DOMAIN:
+      case GL_SCISSOR_BOX:
+      case GL_VIEWPORT:
+         trWriteArrayBool( 4, params );
+         break;
+
+      case GL_CURRENT_NORMAL:
+         trWriteArrayBool( 3, params );
+         break;
+
+      case GL_ALIASED_POINT_SIZE_RANGE:
+      case GL_ALIASED_LINE_WIDTH_RANGE:
+      case GL_DEPTH_RANGE:
+      case GL_MAP1_GRID_DOMAIN:
+      case GL_MAP2_GRID_SEGMENTS:
+      case GL_MAX_VIEWPORT_DIMS:
+      case GL_POLYGON_MODE:
+      case GL_SMOOTH_LINE_WIDTH_RANGE:
+      case GL_SMOOTH_POINT_SIZE_RANGE:
+         trWriteArrayBool( 2, params );
+         break;
+
+      case GL_ACCUM_ALPHA_BITS:
+      case GL_ACCUM_BLUE_BITS:
+      case GL_ACCUM_GREEN_BITS:
+      case GL_ACCUM_RED_BITS:
+      case GL_ACTIVE_TEXTURE_ARB:
+      case GL_ALPHA_BIAS:
+      case GL_ALPHA_BITS:
+      case GL_ALPHA_SCALE:
+      case GL_ALPHA_TEST:
+      case GL_ALPHA_TEST_FUNC:
+      case GL_ALPHA_TEST_REF:
+      case GL_ATTRIB_STACK_DEPTH:
+      case GL_AUTO_NORMAL:
+      case GL_AUX_BUFFERS:
+      case GL_BLEND:
+      case GL_BLEND_SRC:
+      case GL_BLUE_BIAS:
+      case GL_BLUE_BITS:
+      case GL_BLUE_SCALE:
+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_CLIP_PLANE0:
+      case GL_CLIP_PLANE1:
+      case GL_CLIP_PLANE2:
+      case GL_CLIP_PLANE3:
+      case GL_CLIP_PLANE4:
+      case GL_CLIP_PLANE5:
+      case GL_COLOR_ARRAY:
+      case GL_COLOR_ARRAY_SIZE:
+      case GL_COLOR_ARRAY_STRIDE:
+      case GL_COLOR_ARRAY_TYPE:
+      case GL_COLOR_LOGIC_OP:
+      case GL_COLOR_MATERIAL:
+      case GL_COLOR_MATERIAL_FACE:
+      case GL_COLOR_MATERIAL_PARAMETER:
+      case GL_COLOR_MATRIX_STACK_DEPTH:
+      case GL_COLOR_TABLE:
+      case GL_CONVOLUTION_1D:
+      case GL_CONVOLUTION_2D:
+      case GL_CULL_FACE:
+      case GL_CULL_FACE_MODE:
+      case GL_CURRENT_INDEX:
+      case GL_CURRENT_RASTER_DISTANCE:
+      case GL_CURRENT_RASTER_INDEX:
+      case GL_CURRENT_RASTER_POSITION_VALID:
+      case GL_DEPTH_BIAS:
+      case GL_DEPTH_CLEAR_VALUE:
+      case GL_DEPTH_FUNC:
+      case GL_DEPTH_SCALE:
+      case GL_DEPTH_TEST:
+      case GL_DEPTH_WRITEMASK:
+      case GL_DITHER:
+      case GL_DOUBLEBUFFER:
+      case GL_DRAW_BUFFER:
+      case GL_EDGE_FLAG:
+      case GL_EDGE_FLAG_ARRAY:
+      case GL_EDGE_FLAG_ARRAY_STRIDE:
+      case GL_FEEDBACK_BUFFER_SIZE:
+      case GL_FEEDBACK_BUFFER_TYPE:
+      case GL_FOG:
+      case GL_FOG_DENSITY:
+      case GL_FOG_END:
+      case GL_FOG_HINT:
+      case GL_FOG_INDEX:
+      case GL_FOG_MODE:
+      case GL_FOG_START:
+      case GL_FRONT_FACE:
+      case GL_GREEN_BIAS:
+      case GL_GREEN_BITS:
+      case GL_GREEN_SCALE:
+      case GL_HISTOGRAM:
+      case GL_INDEX_ARRAY:
+      case GL_INDEX_ARRAY_STRIDE:
+      case GL_INDEX_ARRAY_TYPE:
+      case GL_INDEX_BITS:
+      case GL_INDEX_CLEAR_VALUE:
+      case GL_INDEX_LOGIC_OP:
+      case GL_INDEX_MODE:
+      case GL_INDEX_OFFSET:
+      case GL_INDEX_SHIFT:
+      case GL_INDEX_WRITEMASK:
+      case GL_LIGHT0:
+      case GL_LIGHT1:
+      case GL_LIGHT2:
+      case GL_LIGHT3:
+      case GL_LIGHT4:
+      case GL_LIGHT5:
+      case GL_LIGHT6:
+      case GL_LIGHT7:
+      case GL_LIGHTING:
+      case GL_LIGHT_MODEL_COLOR_CONTROL:
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
+      case GL_LIGHT_MODEL_TWO_SIDE:
+      case GL_LINE_SMOOTH:
+      case GL_LINE_SMOOTH_HINT:
+      case GL_LINE_STIPPLE:
+      case GL_LINE_STIPPLE_PATTERN:
+      case GL_LINE_STIPPLE_REPEAT:
+      case GL_LINE_WIDTH:
+      case GL_LIST_BASE:
+      case GL_LIST_INDEX:
+      case GL_LIST_MODE:
+      case GL_LOGIC_OP_MODE:
+      case GL_MAP1_COLOR_4:
+      case GL_MAP1_GRID_SEGMENTS:
+      case GL_MAP1_INDEX:
+      case GL_MAP1_NORMAL:
+      case GL_MAP1_TEXTURE_COORD_1:
+      case GL_MAP1_TEXTURE_COORD_2:
+      case GL_MAP1_TEXTURE_COORD_3:
+      case GL_MAP1_TEXTURE_COORD_4:
+      case GL_MAP1_VERTEX_3:
+      case GL_MAP1_VERTEX_4:
+      case GL_MAP2_COLOR_4:
+      case GL_MAP2_INDEX:
+      case GL_MAP2_NORMAL:
+      case GL_MAP2_TEXTURE_COORD_1:
+      case GL_MAP2_TEXTURE_COORD_2:
+      case GL_MAP2_TEXTURE_COORD_3:
+      case GL_MAP2_TEXTURE_COORD_4:
+      case GL_MAP2_VERTEX_3:
+      case GL_MAP2_VERTEX_4:
+      case GL_MAP_COLOR:
+      case GL_MAP_STENCIL:
+      case GL_MATRIX_MODE:
+      case GL_MAX_3D_TEXTURE_SIZE:
+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_MAX_ATTRIB_STACK_DEPTH:
+      case GL_MAX_CLIP_PLANES:
+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
+      case GL_MAX_ELEMENTS_VERTICES:
+      case GL_MAX_EVAL_ORDER:
+      case GL_MAX_LIGHTS:
+      case GL_MAX_LIST_NESTING:
+      case GL_MAX_MODELVIEW_STACK_DEPTH:
+      case GL_MAX_NAME_STACK_DEPTH:
+      case GL_MAX_PIXEL_MAP_TABLE:
+      case GL_MAX_PROJECTION_STACK_DEPTH:
+      case GL_MAX_TEXTURE_SIZE:
+      case GL_MAX_TEXTURE_STACK_DEPTH:
+      case GL_MAX_TEXTURE_UNITS_ARB:
+      case GL_MINMAX:
+      case GL_MODELVIEW_STACK_DEPTH:
+      case GL_NAME_STACK_DEPTH:
+      case GL_NORMAL_ARRAY:
+      case GL_NORMAL_ARRAY_STRIDE:
+      case GL_NORMAL_ARRAY_TYPE:
+      case GL_NORMALIZE:
+      case GL_PACK_ALIGNMENT:
+      case GL_PACK_IMAGE_HEIGHT:
+      case GL_PACK_LSB_FIRST:
+      case GL_PACK_ROW_LENGTH:
+      case GL_PACK_SKIP_IMAGES:
+      case GL_PACK_SKIP_PIXELS:
+      case GL_PACK_SKIP_ROWS:
+      case GL_PACK_SWAP_BYTES:
+      case GL_PERSPECTIVE_CORRECTION_HINT:
+      case GL_PIXEL_MAP_A_TO_A_SIZE:
+      case GL_PIXEL_MAP_B_TO_B_SIZE:
+      case GL_PIXEL_MAP_G_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_A_SIZE:
+      case GL_PIXEL_MAP_I_TO_B_SIZE:
+      case GL_PIXEL_MAP_I_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_I_SIZE:
+      case GL_PIXEL_MAP_I_TO_R_SIZE:
+      case GL_PIXEL_MAP_R_TO_R_SIZE:
+      case GL_PIXEL_MAP_S_TO_S_SIZE:
+      case GL_POINT_SIZE:
+      case GL_POINT_SMOOTH:
+      case GL_POINT_SMOOTH_HINT:
+      case GL_POLYGON_OFFSET_FACTOR:
+      case GL_POLYGON_OFFSET_UNITS:
+      case GL_POLYGON_OFFSET_FILL:
+      case GL_POLYGON_OFFSET_LINE:
+      case GL_POLYGON_OFFSET_POINT:
+      case GL_POLYGON_SMOOTH:
+      case GL_POLYGON_SMOOTH_HINT:
+      case GL_POLYGON_STIPPLE:
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE:
+      case GL_POST_COLOR_MATRIX_RED_BIAS:
+      case GL_POST_COLOR_MATRIX_GREEN_BIAS:
+      case GL_POST_COLOR_MATRIX_BLUE_BIAS:
+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
+      case GL_POST_COLOR_MATRIX_RED_SCALE:
+      case GL_POST_COLOR_MATRIX_GREEN_SCALE:
+      case GL_POST_COLOR_MATRIX_BLUE_SCALE:
+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
+      case GL_POST_CONVOLUTION_COLOR_TABLE:
+      case GL_POST_CONVOLUTION_RED_BIAS:
+      case GL_POST_CONVOLUTION_GREEN_BIAS:
+      case GL_POST_CONVOLUTION_BLUE_BIAS:
+      case GL_POST_CONVOLUTION_ALPHA_BIAS:
+      case GL_POST_CONVOLUTION_RED_SCALE:
+      case GL_POST_CONVOLUTION_GREEN_SCALE:
+      case GL_POST_CONVOLUTION_BLUE_SCALE:
+      case GL_POST_CONVOLUTION_ALPHA_SCALE:
+      case GL_PROJECTION_STACK_DEPTH:
+      case GL_READ_BUFFER:
+      case GL_RED_BIAS:
+      case GL_RED_BITS:
+      case GL_RED_SCALE:
+      case GL_RENDER_MODE:
+      case GL_RESCALE_NORMAL:
+      case GL_RGBA_MODE:
+      case GL_SCISSOR_TEST:
+      case GL_SELECTION_BUFFER_SIZE:
+      case GL_SEPARABLE_2D:
+      case GL_SHADE_MODEL:
+      case GL_SMOOTH_LINE_WIDTH_GRANULARITY:
+      case GL_SMOOTH_POINT_SIZE_GRANULARITY:
+      case GL_STENCIL_BITS:
+      case GL_STENCIL_CLEAR_VALUE:
+      case GL_STENCIL_FAIL:
+      case GL_STENCIL_FUNC:
+      case GL_STENCIL_PASS_DEPTH_FAIL:
+      case GL_STENCIL_PASS_DEPTH_PASS:
+      case GL_STENCIL_REF:
+      case GL_STENCIL_TEST:
+      case GL_STENCIL_VALUE_MASK:
+      case GL_STENCIL_WRITEMASK:
+      case GL_STEREO:
+      case GL_SUBPIXEL_BITS:
+      case GL_TEXTURE_1D:
+      case GL_TEXTURE_BINDING_1D:
+      case GL_TEXTURE_2D:
+      case GL_TEXTURE_BINDING_2D:
+      case GL_TEXTURE_3D:
+      case GL_TEXTURE_BINDING_3D:
+      case GL_TEXTURE_COORD_ARRAY:
+      case GL_TEXTURE_COORD_ARRAY_SIZE:
+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
+      case GL_TEXTURE_COORD_ARRAY_TYPE:
+      case GL_TEXTURE_GEN_Q:
+      case GL_TEXTURE_GEN_R:
+      case GL_TEXTURE_GEN_S:
+      case GL_TEXTURE_GEN_T:
+      case GL_TEXTURE_STACK_DEPTH:
+      case GL_UNPACK_ALIGNMENT:
+      case GL_UNPACK_IMAGE_HEIGHT:
+      case GL_UNPACK_LSB_FIRST:
+      case GL_UNPACK_ROW_LENGTH:
+      case GL_UNPACK_SKIP_IMAGES:
+      case GL_UNPACK_SKIP_PIXELS:
+      case GL_UNPACK_SKIP_ROWS:
+      case GL_UNPACK_SWAP_BYTES:
+      case GL_VERTEX_ARRAY:
+      case GL_VERTEX_ARRAY_SIZE:
+      case GL_VERTEX_ARRAY_STRIDE:
+      case GL_VERTEX_ARRAY_TYPE:
+      case GL_ZOOM_X:
+      case GL_ZOOM_Y:
+         trWriteBool( params[0] );
+         break;
+
+      default:
+         /* Bad enum.  What should we do? */
+         break;
+   }
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetBooleanv( pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetClipPlane( GLenum plane, GLdouble *equation ) {
+	trWriteCMD( CMD_GETCLIPPLANE );
+	trWriteEnum( plane );
+	trWritePointer( (void *)equation  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetClipPlane( plane, equation  );
+		trError();
+	}
+
+	if( !(trCtx()->doExec) ) {
+		memset( equation, 0, sizeof(GLdouble) );
+	}
+
+	trWriteArrayd( 4, equation );
+}
+
+
+GLAPI void GLAPIENTRY trGetColorTableEXT( GLenum target, GLenum format, GLenum type, GLvoid *table ) { /* TODO */
+
+	trWriteCMD( CMD_GETCOLORTABLEEXT );
+	trWriteEnum( target );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)table  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetColorTableEXT( target, format, type, table  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *table ) { /* TODO */
+	trWriteCMD( CMD_GETCOLORTABLE );
+	trWriteEnum( target );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)table  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetColorTable( target, format, type, table  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETCOLORTABLEPARAMETERFVEXT );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetColorTableParameterfvEXT( target, pname, params  );
+		trError();
+	} else {
+		if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+			memset( params, 0, sizeof(GLfloat) * 4 );
+		} else {
+			params[0] = 0.0;
+		}
+	}
+
+	if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+		trWriteArrayf( 4, params );
+	} else {
+		trWritef( params[0] );
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETCOLORTABLEPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetColorTableParameterfv( target, pname, params  );
+		trError();
+	} else {
+		if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+			memset( params, 0, sizeof(GLfloat) * 4 );
+		} else {
+			params[0] = 0.0;
+		}
+	}
+
+	if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+		trWriteArrayf( 4, params );
+	} else {
+		trWritef( params[0] );
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETCOLORTABLEPARAMETERIVEXT );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetColorTableParameterivEXT( target, pname, params  );
+		trError();
+	} else {
+		if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+			memset( params, 0, sizeof(GLint) * 4 );
+		} else {
+			params[0] = 0;
+		}
+	}
+
+	if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+		trWriteArrayi( 4, params );
+	} else {
+		trWritei( params[0] );
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETCOLORTABLEPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetColorTableParameteriv( target, pname, params  );
+		trError();
+	} else {
+		if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+			memset( params, 0, sizeof(GLint) * 4 );
+		} else {
+			params[0] = 0;
+		}
+	}
+
+	if( pname == GL_COLOR_TABLE_BIAS || pname == GL_COLOR_TABLE_SCALE ) {
+		trWriteArrayi( 4, params );
+	} else {
+		trWritei( params[0] );
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid *image ) {
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_GETCONVOLUTIONFILTER );
+	trWriteEnum( target );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)image  );
+	trFileFlush();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->GetConvolutionFilter( target, format, type, image  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETCONVOLUTIONPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetConvolutionParameterfv( target, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_CONVOLUTION_FILTER_SCALE:
+			case GL_CONVOLUTION_FILTER_BIAS:
+				memset( params, 0, 4 * sizeof(GLfloat) );
+				break;
+			case GL_CONVOLUTION_BORDER_MODE:
+			case GL_CONVOLUTION_BORDER_COLOR:
+			case GL_CONVOLUTION_FORMAT:
+			case GL_CONVOLUTION_WIDTH:
+			case GL_CONVOLUTION_HEIGHT:
+			case GL_MAX_CONVOLUTION_WIDTH:
+			case GL_MAX_CONVOLUTION_HEIGHT:
+				params[0] = 0;
+				break;
+			default:
+				/* The 2nd pass should catch this */
+				break;
+		}
+	}
+
+	switch( pname ) {
+		case GL_CONVOLUTION_FILTER_SCALE:
+		case GL_CONVOLUTION_FILTER_BIAS:
+			trWriteArrayf( 4, params );
+			break;
+		case GL_CONVOLUTION_BORDER_MODE:
+		case GL_CONVOLUTION_BORDER_COLOR:
+		case GL_CONVOLUTION_FORMAT:
+		case GL_CONVOLUTION_WIDTH:
+		case GL_CONVOLUTION_HEIGHT:
+		case GL_MAX_CONVOLUTION_WIDTH:
+		case GL_MAX_CONVOLUTION_HEIGHT:
+			trWritef( params[0] );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETCONVOLUTIONPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetConvolutionParameteriv( target, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_CONVOLUTION_FILTER_SCALE:
+			case GL_CONVOLUTION_FILTER_BIAS:
+				memset( params, 0, 4 * sizeof(GLint) );
+				break;
+			case GL_CONVOLUTION_BORDER_MODE:
+			case GL_CONVOLUTION_BORDER_COLOR:
+			case GL_CONVOLUTION_FORMAT:
+			case GL_CONVOLUTION_WIDTH:
+			case GL_CONVOLUTION_HEIGHT:
+			case GL_MAX_CONVOLUTION_WIDTH:
+			case GL_MAX_CONVOLUTION_HEIGHT:
+				params[0] = 0;
+				break;
+			default:
+				/* The 2nd pass should catch this */
+				break;
+		}
+	}
+
+	switch( pname ) {
+		case GL_CONVOLUTION_FILTER_SCALE:
+		case GL_CONVOLUTION_FILTER_BIAS:
+			trWriteArrayi( 4, params );
+			break;
+		case GL_CONVOLUTION_BORDER_MODE:
+		case GL_CONVOLUTION_BORDER_COLOR:
+		case GL_CONVOLUTION_FORMAT:
+		case GL_CONVOLUTION_WIDTH:
+		case GL_CONVOLUTION_HEIGHT:
+		case GL_MAX_CONVOLUTION_WIDTH:
+		case GL_MAX_CONVOLUTION_HEIGHT:
+			trWritei( params[0] );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetDoublev( GLenum pname, GLdouble *params ) {
+	trWriteCMD( CMD_GETDOUBLEV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetDoublev( pname, params  );
+		trError();
+	} else {
+		trZeroGetterData( pname, sizeof(GLdouble), params );
+   }
+
+   switch( pname ) {
+      case GL_COLOR_MATRIX:
+      case GL_MODELVIEW_MATRIX:
+      case GL_PROJECTION_MATRIX:
+      case GL_TEXTURE_MATRIX:
+         trWriteArrayd( 16, params );
+         break;
+
+      case GL_ACCUM_CLEAR_VALUE:
+      case GL_BLEND_COLOR:
+      case GL_COLOR_CLEAR_VALUE:
+      case GL_COLOR_WRITEMASK:
+      case GL_CURRENT_COLOR:
+      case GL_CURRENT_RASTER_COLOR:
+      case GL_CURRENT_RASTER_POSITION:
+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
+      case GL_CURRENT_TEXTURE_COORDS:
+      case GL_LIGHT_MODEL_AMBIENT:
+      case GL_MAP2_GRID_DOMAIN:
+      case GL_SCISSOR_BOX:
+      case GL_VIEWPORT:
+         trWriteArrayd( 4, params );
+         break;
+
+      case GL_CURRENT_NORMAL:
+         trWriteArrayd( 3, params );
+         break;
+
+      case GL_ALIASED_POINT_SIZE_RANGE:
+      case GL_ALIASED_LINE_WIDTH_RANGE:
+      case GL_DEPTH_RANGE:
+      case GL_MAP1_GRID_DOMAIN:
+      case GL_MAP2_GRID_SEGMENTS:
+      case GL_MAX_VIEWPORT_DIMS:
+      case GL_POLYGON_MODE:
+      case GL_SMOOTH_LINE_WIDTH_RANGE:
+      case GL_SMOOTH_POINT_SIZE_RANGE:
+         trWriteArrayd( 2, params );
+         break;
+
+      case GL_ACCUM_ALPHA_BITS:
+      case GL_ACCUM_BLUE_BITS:
+      case GL_ACCUM_GREEN_BITS:
+      case GL_ACCUM_RED_BITS:
+      case GL_ACTIVE_TEXTURE_ARB:
+      case GL_ALPHA_BIAS:
+      case GL_ALPHA_BITS:
+      case GL_ALPHA_SCALE:
+      case GL_ALPHA_TEST:
+      case GL_ALPHA_TEST_FUNC:
+      case GL_ALPHA_TEST_REF:
+      case GL_ATTRIB_STACK_DEPTH:
+      case GL_AUTO_NORMAL:
+      case GL_AUX_BUFFERS:
+      case GL_BLEND:
+      case GL_BLEND_SRC:
+      case GL_BLUE_BIAS:
+      case GL_BLUE_BITS:
+      case GL_BLUE_SCALE:
+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_CLIP_PLANE0:
+      case GL_CLIP_PLANE1:
+      case GL_CLIP_PLANE2:
+      case GL_CLIP_PLANE3:
+      case GL_CLIP_PLANE4:
+      case GL_CLIP_PLANE5:
+      case GL_COLOR_ARRAY:
+      case GL_COLOR_ARRAY_SIZE:
+      case GL_COLOR_ARRAY_STRIDE:
+      case GL_COLOR_ARRAY_TYPE:
+      case GL_COLOR_LOGIC_OP:
+      case GL_COLOR_MATERIAL:
+      case GL_COLOR_MATERIAL_FACE:
+      case GL_COLOR_MATERIAL_PARAMETER:
+      case GL_COLOR_MATRIX_STACK_DEPTH:
+      case GL_COLOR_TABLE:
+      case GL_CONVOLUTION_1D:
+      case GL_CONVOLUTION_2D:
+      case GL_CULL_FACE:
+      case GL_CULL_FACE_MODE:
+      case GL_CURRENT_INDEX:
+      case GL_CURRENT_RASTER_DISTANCE:
+      case GL_CURRENT_RASTER_INDEX:
+      case GL_CURRENT_RASTER_POSITION_VALID:
+      case GL_DEPTH_BIAS:
+      case GL_DEPTH_CLEAR_VALUE:
+      case GL_DEPTH_FUNC:
+      case GL_DEPTH_SCALE:
+      case GL_DEPTH_TEST:
+      case GL_DEPTH_WRITEMASK:
+      case GL_DITHER:
+      case GL_DOUBLEBUFFER:
+      case GL_DRAW_BUFFER:
+      case GL_EDGE_FLAG:
+      case GL_EDGE_FLAG_ARRAY:
+      case GL_EDGE_FLAG_ARRAY_STRIDE:
+      case GL_FEEDBACK_BUFFER_SIZE:
+      case GL_FEEDBACK_BUFFER_TYPE:
+      case GL_FOG:
+      case GL_FOG_DENSITY:
+      case GL_FOG_END:
+      case GL_FOG_HINT:
+      case GL_FOG_INDEX:
+      case GL_FOG_MODE:
+      case GL_FOG_START:
+      case GL_FRONT_FACE:
+      case GL_GREEN_BIAS:
+      case GL_GREEN_BITS:
+      case GL_GREEN_SCALE:
+      case GL_HISTOGRAM:
+      case GL_INDEX_ARRAY:
+      case GL_INDEX_ARRAY_STRIDE:
+      case GL_INDEX_ARRAY_TYPE:
+      case GL_INDEX_BITS:
+      case GL_INDEX_CLEAR_VALUE:
+      case GL_INDEX_LOGIC_OP:
+      case GL_INDEX_MODE:
+      case GL_INDEX_OFFSET:
+      case GL_INDEX_SHIFT:
+      case GL_INDEX_WRITEMASK:
+      case GL_LIGHT0:
+      case GL_LIGHT1:
+      case GL_LIGHT2:
+      case GL_LIGHT3:
+      case GL_LIGHT4:
+      case GL_LIGHT5:
+      case GL_LIGHT6:
+      case GL_LIGHT7:
+      case GL_LIGHTING:
+      case GL_LIGHT_MODEL_COLOR_CONTROL:
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
+      case GL_LIGHT_MODEL_TWO_SIDE:
+      case GL_LINE_SMOOTH:
+      case GL_LINE_SMOOTH_HINT:
+      case GL_LINE_STIPPLE:
+      case GL_LINE_STIPPLE_PATTERN:
+      case GL_LINE_STIPPLE_REPEAT:
+      case GL_LINE_WIDTH:
+      case GL_LIST_BASE:
+      case GL_LIST_INDEX:
+      case GL_LIST_MODE:
+      case GL_LOGIC_OP_MODE:
+      case GL_MAP1_COLOR_4:
+      case GL_MAP1_GRID_SEGMENTS:
+      case GL_MAP1_INDEX:
+      case GL_MAP1_NORMAL:
+      case GL_MAP1_TEXTURE_COORD_1:
+      case GL_MAP1_TEXTURE_COORD_2:
+      case GL_MAP1_TEXTURE_COORD_3:
+      case GL_MAP1_TEXTURE_COORD_4:
+      case GL_MAP1_VERTEX_3:
+      case GL_MAP1_VERTEX_4:
+      case GL_MAP2_COLOR_4:
+      case GL_MAP2_INDEX:
+      case GL_MAP2_NORMAL:
+      case GL_MAP2_TEXTURE_COORD_1:
+      case GL_MAP2_TEXTURE_COORD_2:
+      case GL_MAP2_TEXTURE_COORD_3:
+      case GL_MAP2_TEXTURE_COORD_4:
+      case GL_MAP2_VERTEX_3:
+      case GL_MAP2_VERTEX_4:
+      case GL_MAP_COLOR:
+      case GL_MAP_STENCIL:
+      case GL_MATRIX_MODE:
+      case GL_MAX_3D_TEXTURE_SIZE:
+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_MAX_ATTRIB_STACK_DEPTH:
+      case GL_MAX_CLIP_PLANES:
+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
+      case GL_MAX_ELEMENTS_VERTICES:
+      case GL_MAX_EVAL_ORDER:
+      case GL_MAX_LIGHTS:
+      case GL_MAX_LIST_NESTING:
+      case GL_MAX_MODELVIEW_STACK_DEPTH:
+      case GL_MAX_NAME_STACK_DEPTH:
+      case GL_MAX_PIXEL_MAP_TABLE:
+      case GL_MAX_PROJECTION_STACK_DEPTH:
+      case GL_MAX_TEXTURE_SIZE:
+      case GL_MAX_TEXTURE_STACK_DEPTH:
+      case GL_MAX_TEXTURE_UNITS_ARB:
+      case GL_MINMAX:
+      case GL_MODELVIEW_STACK_DEPTH:
+      case GL_NAME_STACK_DEPTH:
+      case GL_NORMAL_ARRAY:
+      case GL_NORMAL_ARRAY_STRIDE:
+      case GL_NORMAL_ARRAY_TYPE:
+      case GL_NORMALIZE:
+      case GL_PACK_ALIGNMENT:
+      case GL_PACK_IMAGE_HEIGHT:
+      case GL_PACK_LSB_FIRST:
+      case GL_PACK_ROW_LENGTH:
+      case GL_PACK_SKIP_IMAGES:
+      case GL_PACK_SKIP_PIXELS:
+      case GL_PACK_SKIP_ROWS:
+      case GL_PACK_SWAP_BYTES:
+      case GL_PERSPECTIVE_CORRECTION_HINT:
+      case GL_PIXEL_MAP_A_TO_A_SIZE:
+      case GL_PIXEL_MAP_B_TO_B_SIZE:
+      case GL_PIXEL_MAP_G_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_A_SIZE:
+      case GL_PIXEL_MAP_I_TO_B_SIZE:
+      case GL_PIXEL_MAP_I_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_I_SIZE:
+      case GL_PIXEL_MAP_I_TO_R_SIZE:
+      case GL_PIXEL_MAP_R_TO_R_SIZE:
+      case GL_PIXEL_MAP_S_TO_S_SIZE:
+      case GL_POINT_SIZE:
+      case GL_POINT_SMOOTH:
+      case GL_POINT_SMOOTH_HINT:
+      case GL_POLYGON_OFFSET_FACTOR:
+      case GL_POLYGON_OFFSET_UNITS:
+      case GL_POLYGON_OFFSET_FILL:
+      case GL_POLYGON_OFFSET_LINE:
+      case GL_POLYGON_OFFSET_POINT:
+      case GL_POLYGON_SMOOTH:
+      case GL_POLYGON_SMOOTH_HINT:
+      case GL_POLYGON_STIPPLE:
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE:
+      case GL_POST_COLOR_MATRIX_RED_BIAS:
+      case GL_POST_COLOR_MATRIX_GREEN_BIAS:
+      case GL_POST_COLOR_MATRIX_BLUE_BIAS:
+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
+      case GL_POST_COLOR_MATRIX_RED_SCALE:
+      case GL_POST_COLOR_MATRIX_GREEN_SCALE:
+      case GL_POST_COLOR_MATRIX_BLUE_SCALE:
+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
+      case GL_POST_CONVOLUTION_COLOR_TABLE:
+      case GL_POST_CONVOLUTION_RED_BIAS:
+      case GL_POST_CONVOLUTION_GREEN_BIAS:
+      case GL_POST_CONVOLUTION_BLUE_BIAS:
+      case GL_POST_CONVOLUTION_ALPHA_BIAS:
+      case GL_POST_CONVOLUTION_RED_SCALE:
+      case GL_POST_CONVOLUTION_GREEN_SCALE:
+      case GL_POST_CONVOLUTION_BLUE_SCALE:
+      case GL_POST_CONVOLUTION_ALPHA_SCALE:
+      case GL_PROJECTION_STACK_DEPTH:
+      case GL_READ_BUFFER:
+      case GL_RED_BIAS:
+      case GL_RED_BITS:
+      case GL_RED_SCALE:
+      case GL_RENDER_MODE:
+      case GL_RESCALE_NORMAL:
+      case GL_RGBA_MODE:
+      case GL_SCISSOR_TEST:
+      case GL_SELECTION_BUFFER_SIZE:
+      case GL_SEPARABLE_2D:
+      case GL_SHADE_MODEL:
+      case GL_SMOOTH_LINE_WIDTH_GRANULARITY:
+      case GL_SMOOTH_POINT_SIZE_GRANULARITY:
+      case GL_STENCIL_BITS:
+      case GL_STENCIL_CLEAR_VALUE:
+      case GL_STENCIL_FAIL:
+      case GL_STENCIL_FUNC:
+      case GL_STENCIL_PASS_DEPTH_FAIL:
+      case GL_STENCIL_PASS_DEPTH_PASS:
+      case GL_STENCIL_REF:
+      case GL_STENCIL_TEST:
+      case GL_STENCIL_VALUE_MASK:
+      case GL_STENCIL_WRITEMASK:
+      case GL_STEREO:
+      case GL_SUBPIXEL_BITS:
+      case GL_TEXTURE_1D:
+      case GL_TEXTURE_BINDING_1D:
+      case GL_TEXTURE_2D:
+      case GL_TEXTURE_BINDING_2D:
+      case GL_TEXTURE_3D:
+      case GL_TEXTURE_BINDING_3D:
+      case GL_TEXTURE_COORD_ARRAY:
+      case GL_TEXTURE_COORD_ARRAY_SIZE:
+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
+      case GL_TEXTURE_COORD_ARRAY_TYPE:
+      case GL_TEXTURE_GEN_Q:
+      case GL_TEXTURE_GEN_R:
+      case GL_TEXTURE_GEN_S:
+      case GL_TEXTURE_GEN_T:
+      case GL_TEXTURE_STACK_DEPTH:
+      case GL_UNPACK_ALIGNMENT:
+      case GL_UNPACK_IMAGE_HEIGHT:
+      case GL_UNPACK_LSB_FIRST:
+      case GL_UNPACK_ROW_LENGTH:
+      case GL_UNPACK_SKIP_IMAGES:
+      case GL_UNPACK_SKIP_PIXELS:
+      case GL_UNPACK_SKIP_ROWS:
+      case GL_UNPACK_SWAP_BYTES:
+      case GL_VERTEX_ARRAY:
+      case GL_VERTEX_ARRAY_SIZE:
+      case GL_VERTEX_ARRAY_STRIDE:
+      case GL_VERTEX_ARRAY_TYPE:
+      case GL_ZOOM_X:
+      case GL_ZOOM_Y:
+         trWrited( params[0] );
+         break;
+
+      default:
+         /* Bad enum.  What should we do? */
+         break;
+   }
+
+}
+
+
+GLAPI GLenum GLAPIENTRY trGetError( void ) {
+	GLenum retval;
+	trWriteCMD( CMD_GETERROR );
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->GetError(  );
+		trError();
+	} else {
+		retval = GL_NO_ERROR;
+	}
+
+	trWriteEnum( retval );
+	return retval;
+}
+
+
+GLAPI void GLAPIENTRY trGetFloatv( GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETFLOATV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetFloatv( pname, params  );
+		trError();
+	} else {
+		trZeroGetterData( pname, sizeof(GLfloat), params );
+   }
+
+   switch( pname ) {
+      case GL_COLOR_MATRIX:
+      case GL_MODELVIEW_MATRIX:
+      case GL_PROJECTION_MATRIX:
+      case GL_TEXTURE_MATRIX:
+         trWriteArrayf( 16, params );
+         break;
+
+      case GL_ACCUM_CLEAR_VALUE:
+      case GL_BLEND_COLOR:
+      case GL_COLOR_CLEAR_VALUE:
+      case GL_COLOR_WRITEMASK:
+      case GL_CURRENT_COLOR:
+      case GL_CURRENT_RASTER_COLOR:
+      case GL_CURRENT_RASTER_POSITION:
+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
+      case GL_CURRENT_TEXTURE_COORDS:
+      case GL_LIGHT_MODEL_AMBIENT:
+      case GL_MAP2_GRID_DOMAIN:
+      case GL_SCISSOR_BOX:
+      case GL_VIEWPORT:
+         trWriteArrayf( 4, params );
+         break;
+
+      case GL_CURRENT_NORMAL:
+         trWriteArrayf( 3, params );
+         break;
+
+      case GL_ALIASED_POINT_SIZE_RANGE:
+      case GL_ALIASED_LINE_WIDTH_RANGE:
+      case GL_DEPTH_RANGE:
+      case GL_MAP1_GRID_DOMAIN:
+      case GL_MAP2_GRID_SEGMENTS:
+      case GL_MAX_VIEWPORT_DIMS:
+      case GL_POLYGON_MODE:
+      case GL_SMOOTH_LINE_WIDTH_RANGE:
+      case GL_SMOOTH_POINT_SIZE_RANGE:
+         trWriteArrayf( 2, params );
+         break;
+
+      case GL_ACCUM_ALPHA_BITS:
+      case GL_ACCUM_BLUE_BITS:
+      case GL_ACCUM_GREEN_BITS:
+      case GL_ACCUM_RED_BITS:
+      case GL_ACTIVE_TEXTURE_ARB:
+      case GL_ALPHA_BIAS:
+      case GL_ALPHA_BITS:
+      case GL_ALPHA_SCALE:
+      case GL_ALPHA_TEST:
+      case GL_ALPHA_TEST_FUNC:
+      case GL_ALPHA_TEST_REF:
+      case GL_ATTRIB_STACK_DEPTH:
+      case GL_AUTO_NORMAL:
+      case GL_AUX_BUFFERS:
+      case GL_BLEND:
+      case GL_BLEND_SRC:
+      case GL_BLUE_BIAS:
+      case GL_BLUE_BITS:
+      case GL_BLUE_SCALE:
+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_CLIP_PLANE0:
+      case GL_CLIP_PLANE1:
+      case GL_CLIP_PLANE2:
+      case GL_CLIP_PLANE3:
+      case GL_CLIP_PLANE4:
+      case GL_CLIP_PLANE5:
+      case GL_COLOR_ARRAY:
+      case GL_COLOR_ARRAY_SIZE:
+      case GL_COLOR_ARRAY_STRIDE:
+      case GL_COLOR_ARRAY_TYPE:
+      case GL_COLOR_LOGIC_OP:
+      case GL_COLOR_MATERIAL:
+      case GL_COLOR_MATERIAL_FACE:
+      case GL_COLOR_MATERIAL_PARAMETER:
+      case GL_COLOR_MATRIX_STACK_DEPTH:
+      case GL_COLOR_TABLE:
+      case GL_CONVOLUTION_1D:
+      case GL_CONVOLUTION_2D:
+      case GL_CULL_FACE:
+      case GL_CULL_FACE_MODE:
+      case GL_CURRENT_INDEX:
+      case GL_CURRENT_RASTER_DISTANCE:
+      case GL_CURRENT_RASTER_INDEX:
+      case GL_CURRENT_RASTER_POSITION_VALID:
+      case GL_DEPTH_BIAS:
+      case GL_DEPTH_CLEAR_VALUE:
+      case GL_DEPTH_FUNC:
+      case GL_DEPTH_SCALE:
+      case GL_DEPTH_TEST:
+      case GL_DEPTH_WRITEMASK:
+      case GL_DITHER:
+      case GL_DOUBLEBUFFER:
+      case GL_DRAW_BUFFER:
+      case GL_EDGE_FLAG:
+      case GL_EDGE_FLAG_ARRAY:
+      case GL_EDGE_FLAG_ARRAY_STRIDE:
+      case GL_FEEDBACK_BUFFER_SIZE:
+      case GL_FEEDBACK_BUFFER_TYPE:
+      case GL_FOG:
+      case GL_FOG_DENSITY:
+      case GL_FOG_END:
+      case GL_FOG_HINT:
+      case GL_FOG_INDEX:
+      case GL_FOG_MODE:
+      case GL_FOG_START:
+      case GL_FRONT_FACE:
+      case GL_GREEN_BIAS:
+      case GL_GREEN_BITS:
+      case GL_GREEN_SCALE:
+      case GL_HISTOGRAM:
+      case GL_INDEX_ARRAY:
+      case GL_INDEX_ARRAY_STRIDE:
+      case GL_INDEX_ARRAY_TYPE:
+      case GL_INDEX_BITS:
+      case GL_INDEX_CLEAR_VALUE:
+      case GL_INDEX_LOGIC_OP:
+      case GL_INDEX_MODE:
+      case GL_INDEX_OFFSET:
+      case GL_INDEX_SHIFT:
+      case GL_INDEX_WRITEMASK:
+      case GL_LIGHT0:
+      case GL_LIGHT1:
+      case GL_LIGHT2:
+      case GL_LIGHT3:
+      case GL_LIGHT4:
+      case GL_LIGHT5:
+      case GL_LIGHT6:
+      case GL_LIGHT7:
+      case GL_LIGHTING:
+      case GL_LIGHT_MODEL_COLOR_CONTROL:
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
+      case GL_LIGHT_MODEL_TWO_SIDE:
+      case GL_LINE_SMOOTH:
+      case GL_LINE_SMOOTH_HINT:
+      case GL_LINE_STIPPLE:
+      case GL_LINE_STIPPLE_PATTERN:
+      case GL_LINE_STIPPLE_REPEAT:
+      case GL_LINE_WIDTH:
+      case GL_LIST_BASE:
+      case GL_LIST_INDEX:
+      case GL_LIST_MODE:
+      case GL_LOGIC_OP_MODE:
+      case GL_MAP1_COLOR_4:
+      case GL_MAP1_GRID_SEGMENTS:
+      case GL_MAP1_INDEX:
+      case GL_MAP1_NORMAL:
+      case GL_MAP1_TEXTURE_COORD_1:
+      case GL_MAP1_TEXTURE_COORD_2:
+      case GL_MAP1_TEXTURE_COORD_3:
+      case GL_MAP1_TEXTURE_COORD_4:
+      case GL_MAP1_VERTEX_3:
+      case GL_MAP1_VERTEX_4:
+      case GL_MAP2_COLOR_4:
+      case GL_MAP2_INDEX:
+      case GL_MAP2_NORMAL:
+      case GL_MAP2_TEXTURE_COORD_1:
+      case GL_MAP2_TEXTURE_COORD_2:
+      case GL_MAP2_TEXTURE_COORD_3:
+      case GL_MAP2_TEXTURE_COORD_4:
+      case GL_MAP2_VERTEX_3:
+      case GL_MAP2_VERTEX_4:
+      case GL_MAP_COLOR:
+      case GL_MAP_STENCIL:
+      case GL_MATRIX_MODE:
+      case GL_MAX_3D_TEXTURE_SIZE:
+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_MAX_ATTRIB_STACK_DEPTH:
+      case GL_MAX_CLIP_PLANES:
+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
+      case GL_MAX_ELEMENTS_VERTICES:
+      case GL_MAX_EVAL_ORDER:
+      case GL_MAX_LIGHTS:
+      case GL_MAX_LIST_NESTING:
+      case GL_MAX_MODELVIEW_STACK_DEPTH:
+      case GL_MAX_NAME_STACK_DEPTH:
+      case GL_MAX_PIXEL_MAP_TABLE:
+      case GL_MAX_PROJECTION_STACK_DEPTH:
+      case GL_MAX_TEXTURE_SIZE:
+      case GL_MAX_TEXTURE_STACK_DEPTH:
+      case GL_MAX_TEXTURE_UNITS_ARB:
+      case GL_MINMAX:
+      case GL_MODELVIEW_STACK_DEPTH:
+      case GL_NAME_STACK_DEPTH:
+      case GL_NORMAL_ARRAY:
+      case GL_NORMAL_ARRAY_STRIDE:
+      case GL_NORMAL_ARRAY_TYPE:
+      case GL_NORMALIZE:
+      case GL_PACK_ALIGNMENT:
+      case GL_PACK_IMAGE_HEIGHT:
+      case GL_PACK_LSB_FIRST:
+      case GL_PACK_ROW_LENGTH:
+      case GL_PACK_SKIP_IMAGES:
+      case GL_PACK_SKIP_PIXELS:
+      case GL_PACK_SKIP_ROWS:
+      case GL_PACK_SWAP_BYTES:
+      case GL_PERSPECTIVE_CORRECTION_HINT:
+      case GL_PIXEL_MAP_A_TO_A_SIZE:
+      case GL_PIXEL_MAP_B_TO_B_SIZE:
+      case GL_PIXEL_MAP_G_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_A_SIZE:
+      case GL_PIXEL_MAP_I_TO_B_SIZE:
+      case GL_PIXEL_MAP_I_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_I_SIZE:
+      case GL_PIXEL_MAP_I_TO_R_SIZE:
+      case GL_PIXEL_MAP_R_TO_R_SIZE:
+      case GL_PIXEL_MAP_S_TO_S_SIZE:
+      case GL_POINT_SIZE:
+      case GL_POINT_SMOOTH:
+      case GL_POINT_SMOOTH_HINT:
+      case GL_POLYGON_OFFSET_FACTOR:
+      case GL_POLYGON_OFFSET_UNITS:
+      case GL_POLYGON_OFFSET_FILL:
+      case GL_POLYGON_OFFSET_LINE:
+      case GL_POLYGON_OFFSET_POINT:
+      case GL_POLYGON_SMOOTH:
+      case GL_POLYGON_SMOOTH_HINT:
+      case GL_POLYGON_STIPPLE:
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE:
+      case GL_POST_COLOR_MATRIX_RED_BIAS:
+      case GL_POST_COLOR_MATRIX_GREEN_BIAS:
+      case GL_POST_COLOR_MATRIX_BLUE_BIAS:
+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
+      case GL_POST_COLOR_MATRIX_RED_SCALE:
+      case GL_POST_COLOR_MATRIX_GREEN_SCALE:
+      case GL_POST_COLOR_MATRIX_BLUE_SCALE:
+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
+      case GL_POST_CONVOLUTION_COLOR_TABLE:
+      case GL_POST_CONVOLUTION_RED_BIAS:
+      case GL_POST_CONVOLUTION_GREEN_BIAS:
+      case GL_POST_CONVOLUTION_BLUE_BIAS:
+      case GL_POST_CONVOLUTION_ALPHA_BIAS:
+      case GL_POST_CONVOLUTION_RED_SCALE:
+      case GL_POST_CONVOLUTION_GREEN_SCALE:
+      case GL_POST_CONVOLUTION_BLUE_SCALE:
+      case GL_POST_CONVOLUTION_ALPHA_SCALE:
+      case GL_PROJECTION_STACK_DEPTH:
+      case GL_READ_BUFFER:
+      case GL_RED_BIAS:
+      case GL_RED_BITS:
+      case GL_RED_SCALE:
+      case GL_RENDER_MODE:
+      case GL_RESCALE_NORMAL:
+      case GL_RGBA_MODE:
+      case GL_SCISSOR_TEST:
+      case GL_SELECTION_BUFFER_SIZE:
+      case GL_SEPARABLE_2D:
+      case GL_SHADE_MODEL:
+      case GL_SMOOTH_LINE_WIDTH_GRANULARITY:
+      case GL_SMOOTH_POINT_SIZE_GRANULARITY:
+      case GL_STENCIL_BITS:
+      case GL_STENCIL_CLEAR_VALUE:
+      case GL_STENCIL_FAIL:
+      case GL_STENCIL_FUNC:
+      case GL_STENCIL_PASS_DEPTH_FAIL:
+      case GL_STENCIL_PASS_DEPTH_PASS:
+      case GL_STENCIL_REF:
+      case GL_STENCIL_TEST:
+      case GL_STENCIL_VALUE_MASK:
+      case GL_STENCIL_WRITEMASK:
+      case GL_STEREO:
+      case GL_SUBPIXEL_BITS:
+      case GL_TEXTURE_1D:
+      case GL_TEXTURE_BINDING_1D:
+      case GL_TEXTURE_2D:
+      case GL_TEXTURE_BINDING_2D:
+      case GL_TEXTURE_3D:
+      case GL_TEXTURE_BINDING_3D:
+      case GL_TEXTURE_COORD_ARRAY:
+      case GL_TEXTURE_COORD_ARRAY_SIZE:
+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
+      case GL_TEXTURE_COORD_ARRAY_TYPE:
+      case GL_TEXTURE_GEN_Q:
+      case GL_TEXTURE_GEN_R:
+      case GL_TEXTURE_GEN_S:
+      case GL_TEXTURE_GEN_T:
+      case GL_TEXTURE_STACK_DEPTH:
+      case GL_UNPACK_ALIGNMENT:
+      case GL_UNPACK_IMAGE_HEIGHT:
+      case GL_UNPACK_LSB_FIRST:
+      case GL_UNPACK_ROW_LENGTH:
+      case GL_UNPACK_SKIP_IMAGES:
+      case GL_UNPACK_SKIP_PIXELS:
+      case GL_UNPACK_SKIP_ROWS:
+      case GL_UNPACK_SWAP_BYTES:
+      case GL_VERTEX_ARRAY:
+      case GL_VERTEX_ARRAY_SIZE:
+      case GL_VERTEX_ARRAY_STRIDE:
+      case GL_VERTEX_ARRAY_TYPE:
+      case GL_ZOOM_X:
+      case GL_ZOOM_Y:
+         trWritef( params[0] );
+         break;
+
+      default:
+         /* Bad enum.  What should we do? */
+         break;
+   }
+}
+
+
+GLAPI void GLAPIENTRY trGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values ) { /* TODO */
+	trWriteCMD( CMD_GETHISTOGRAM );
+	trWriteEnum( target );
+	trWriteBool( reset );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetHistogram( target, reset, format, type, values  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETHISTOGRAMPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetHistogramParameterfv( target, pname, params  );
+		trError();
+	} else {
+		params[0] = 0;
+	}
+
+	trWritef( params[0] );
+}
+
+
+GLAPI void GLAPIENTRY trGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETHISTOGRAMPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetHistogramParameteriv( target, pname, params  );
+		trError();
+	} else {
+		params[0] = 0;
+	}
+
+	trWritei( params[0] );
+}
+
+
+GLAPI void GLAPIENTRY trGetIntegerv( GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETINTEGERV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetIntegerv( pname, params  );
+		trError();
+	} else {
+		trZeroGetterData( pname, sizeof(GLint), params );
+   }
+
+   switch( pname ) {
+      case GL_COLOR_MATRIX:
+      case GL_MODELVIEW_MATRIX:
+      case GL_PROJECTION_MATRIX:
+      case GL_TEXTURE_MATRIX:
+         trWriteArrayi( 16, params );
+         break;
+
+      case GL_ACCUM_CLEAR_VALUE:
+      case GL_BLEND_COLOR:
+      case GL_COLOR_CLEAR_VALUE:
+      case GL_COLOR_WRITEMASK:
+      case GL_CURRENT_COLOR:
+      case GL_CURRENT_RASTER_COLOR:
+      case GL_CURRENT_RASTER_POSITION:
+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
+      case GL_CURRENT_TEXTURE_COORDS:
+      case GL_LIGHT_MODEL_AMBIENT:
+      case GL_MAP2_GRID_DOMAIN:
+      case GL_SCISSOR_BOX:
+      case GL_VIEWPORT:
+         trWriteArrayi( 4, params );
+         break;
+
+      case GL_CURRENT_NORMAL:
+         trWriteArrayi( 3, params );
+         break;
+
+      case GL_ALIASED_POINT_SIZE_RANGE:
+      case GL_ALIASED_LINE_WIDTH_RANGE:
+      case GL_DEPTH_RANGE:
+      case GL_MAP1_GRID_DOMAIN:
+      case GL_MAP2_GRID_SEGMENTS:
+      case GL_MAX_VIEWPORT_DIMS:
+      case GL_POLYGON_MODE:
+      case GL_SMOOTH_LINE_WIDTH_RANGE:
+      case GL_SMOOTH_POINT_SIZE_RANGE:
+         trWriteArrayi( 2, params );
+         break;
+
+      case GL_ACCUM_ALPHA_BITS:
+      case GL_ACCUM_BLUE_BITS:
+      case GL_ACCUM_GREEN_BITS:
+      case GL_ACCUM_RED_BITS:
+      case GL_ACTIVE_TEXTURE_ARB:
+      case GL_ALPHA_BIAS:
+      case GL_ALPHA_BITS:
+      case GL_ALPHA_SCALE:
+      case GL_ALPHA_TEST:
+      case GL_ALPHA_TEST_FUNC:
+      case GL_ALPHA_TEST_REF:
+      case GL_ATTRIB_STACK_DEPTH:
+      case GL_AUTO_NORMAL:
+      case GL_AUX_BUFFERS:
+      case GL_BLEND:
+      case GL_BLEND_SRC:
+      case GL_BLUE_BIAS:
+      case GL_BLUE_BITS:
+      case GL_BLUE_SCALE:
+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_CLIP_PLANE0:
+      case GL_CLIP_PLANE1:
+      case GL_CLIP_PLANE2:
+      case GL_CLIP_PLANE3:
+      case GL_CLIP_PLANE4:
+      case GL_CLIP_PLANE5:
+      case GL_COLOR_ARRAY:
+      case GL_COLOR_ARRAY_SIZE:
+      case GL_COLOR_ARRAY_STRIDE:
+      case GL_COLOR_ARRAY_TYPE:
+      case GL_COLOR_LOGIC_OP:
+      case GL_COLOR_MATERIAL:
+      case GL_COLOR_MATERIAL_FACE:
+      case GL_COLOR_MATERIAL_PARAMETER:
+      case GL_COLOR_MATRIX_STACK_DEPTH:
+      case GL_COLOR_TABLE:
+      case GL_CONVOLUTION_1D:
+      case GL_CONVOLUTION_2D:
+      case GL_CULL_FACE:
+      case GL_CULL_FACE_MODE:
+      case GL_CURRENT_INDEX:
+      case GL_CURRENT_RASTER_DISTANCE:
+      case GL_CURRENT_RASTER_INDEX:
+      case GL_CURRENT_RASTER_POSITION_VALID:
+      case GL_DEPTH_BIAS:
+      case GL_DEPTH_CLEAR_VALUE:
+      case GL_DEPTH_FUNC:
+      case GL_DEPTH_SCALE:
+      case GL_DEPTH_TEST:
+      case GL_DEPTH_WRITEMASK:
+      case GL_DITHER:
+      case GL_DOUBLEBUFFER:
+      case GL_DRAW_BUFFER:
+      case GL_EDGE_FLAG:
+      case GL_EDGE_FLAG_ARRAY:
+      case GL_EDGE_FLAG_ARRAY_STRIDE:
+      case GL_FEEDBACK_BUFFER_SIZE:
+      case GL_FEEDBACK_BUFFER_TYPE:
+      case GL_FOG:
+      case GL_FOG_DENSITY:
+      case GL_FOG_END:
+      case GL_FOG_HINT:
+      case GL_FOG_INDEX:
+      case GL_FOG_MODE:
+      case GL_FOG_START:
+      case GL_FRONT_FACE:
+      case GL_GREEN_BIAS:
+      case GL_GREEN_BITS:
+      case GL_GREEN_SCALE:
+      case GL_HISTOGRAM:
+      case GL_INDEX_ARRAY:
+      case GL_INDEX_ARRAY_STRIDE:
+      case GL_INDEX_ARRAY_TYPE:
+      case GL_INDEX_BITS:
+      case GL_INDEX_CLEAR_VALUE:
+      case GL_INDEX_LOGIC_OP:
+      case GL_INDEX_MODE:
+      case GL_INDEX_OFFSET:
+      case GL_INDEX_SHIFT:
+      case GL_INDEX_WRITEMASK:
+      case GL_LIGHT0:
+      case GL_LIGHT1:
+      case GL_LIGHT2:
+      case GL_LIGHT3:
+      case GL_LIGHT4:
+      case GL_LIGHT5:
+      case GL_LIGHT6:
+      case GL_LIGHT7:
+      case GL_LIGHTING:
+      case GL_LIGHT_MODEL_COLOR_CONTROL:
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
+      case GL_LIGHT_MODEL_TWO_SIDE:
+      case GL_LINE_SMOOTH:
+      case GL_LINE_SMOOTH_HINT:
+      case GL_LINE_STIPPLE:
+      case GL_LINE_STIPPLE_PATTERN:
+      case GL_LINE_STIPPLE_REPEAT:
+      case GL_LINE_WIDTH:
+      case GL_LIST_BASE:
+      case GL_LIST_INDEX:
+      case GL_LIST_MODE:
+      case GL_LOGIC_OP_MODE:
+      case GL_MAP1_COLOR_4:
+      case GL_MAP1_GRID_SEGMENTS:
+      case GL_MAP1_INDEX:
+      case GL_MAP1_NORMAL:
+      case GL_MAP1_TEXTURE_COORD_1:
+      case GL_MAP1_TEXTURE_COORD_2:
+      case GL_MAP1_TEXTURE_COORD_3:
+      case GL_MAP1_TEXTURE_COORD_4:
+      case GL_MAP1_VERTEX_3:
+      case GL_MAP1_VERTEX_4:
+      case GL_MAP2_COLOR_4:
+      case GL_MAP2_INDEX:
+      case GL_MAP2_NORMAL:
+      case GL_MAP2_TEXTURE_COORD_1:
+      case GL_MAP2_TEXTURE_COORD_2:
+      case GL_MAP2_TEXTURE_COORD_3:
+      case GL_MAP2_TEXTURE_COORD_4:
+      case GL_MAP2_VERTEX_3:
+      case GL_MAP2_VERTEX_4:
+      case GL_MAP_COLOR:
+      case GL_MAP_STENCIL:
+      case GL_MATRIX_MODE:
+      case GL_MAX_3D_TEXTURE_SIZE:
+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+      case GL_MAX_ATTRIB_STACK_DEPTH:
+      case GL_MAX_CLIP_PLANES:
+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
+      case GL_MAX_ELEMENTS_VERTICES:
+      case GL_MAX_EVAL_ORDER:
+      case GL_MAX_LIGHTS:
+      case GL_MAX_LIST_NESTING:
+      case GL_MAX_MODELVIEW_STACK_DEPTH:
+      case GL_MAX_NAME_STACK_DEPTH:
+      case GL_MAX_PIXEL_MAP_TABLE:
+      case GL_MAX_PROJECTION_STACK_DEPTH:
+      case GL_MAX_TEXTURE_SIZE:
+      case GL_MAX_TEXTURE_STACK_DEPTH:
+      case GL_MAX_TEXTURE_UNITS_ARB:
+      case GL_MINMAX:
+      case GL_MODELVIEW_STACK_DEPTH:
+      case GL_NAME_STACK_DEPTH:
+      case GL_NORMAL_ARRAY:
+      case GL_NORMAL_ARRAY_STRIDE:
+      case GL_NORMAL_ARRAY_TYPE:
+      case GL_NORMALIZE:
+      case GL_PACK_ALIGNMENT:
+      case GL_PACK_IMAGE_HEIGHT:
+      case GL_PACK_LSB_FIRST:
+      case GL_PACK_ROW_LENGTH:
+      case GL_PACK_SKIP_IMAGES:
+      case GL_PACK_SKIP_PIXELS:
+      case GL_PACK_SKIP_ROWS:
+      case GL_PACK_SWAP_BYTES:
+      case GL_PERSPECTIVE_CORRECTION_HINT:
+      case GL_PIXEL_MAP_A_TO_A_SIZE:
+      case GL_PIXEL_MAP_B_TO_B_SIZE:
+      case GL_PIXEL_MAP_G_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_A_SIZE:
+      case GL_PIXEL_MAP_I_TO_B_SIZE:
+      case GL_PIXEL_MAP_I_TO_G_SIZE:
+      case GL_PIXEL_MAP_I_TO_I_SIZE:
+      case GL_PIXEL_MAP_I_TO_R_SIZE:
+      case GL_PIXEL_MAP_R_TO_R_SIZE:
+      case GL_PIXEL_MAP_S_TO_S_SIZE:
+      case GL_POINT_SIZE:
+      case GL_POINT_SMOOTH:
+      case GL_POINT_SMOOTH_HINT:
+      case GL_POLYGON_OFFSET_FACTOR:
+      case GL_POLYGON_OFFSET_UNITS:
+      case GL_POLYGON_OFFSET_FILL:
+      case GL_POLYGON_OFFSET_LINE:
+      case GL_POLYGON_OFFSET_POINT:
+      case GL_POLYGON_SMOOTH:
+      case GL_POLYGON_SMOOTH_HINT:
+      case GL_POLYGON_STIPPLE:
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE:
+      case GL_POST_COLOR_MATRIX_RED_BIAS:
+      case GL_POST_COLOR_MATRIX_GREEN_BIAS:
+      case GL_POST_COLOR_MATRIX_BLUE_BIAS:
+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
+      case GL_POST_COLOR_MATRIX_RED_SCALE:
+      case GL_POST_COLOR_MATRIX_GREEN_SCALE:
+      case GL_POST_COLOR_MATRIX_BLUE_SCALE:
+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
+      case GL_POST_CONVOLUTION_COLOR_TABLE:
+      case GL_POST_CONVOLUTION_RED_BIAS:
+      case GL_POST_CONVOLUTION_GREEN_BIAS:
+      case GL_POST_CONVOLUTION_BLUE_BIAS:
+      case GL_POST_CONVOLUTION_ALPHA_BIAS:
+      case GL_POST_CONVOLUTION_RED_SCALE:
+      case GL_POST_CONVOLUTION_GREEN_SCALE:
+      case GL_POST_CONVOLUTION_BLUE_SCALE:
+      case GL_POST_CONVOLUTION_ALPHA_SCALE:
+      case GL_PROJECTION_STACK_DEPTH:
+      case GL_READ_BUFFER:
+      case GL_RED_BIAS:
+      case GL_RED_BITS:
+      case GL_RED_SCALE:
+      case GL_RENDER_MODE:
+      case GL_RESCALE_NORMAL:
+      case GL_RGBA_MODE:
+      case GL_SCISSOR_TEST:
+      case GL_SELECTION_BUFFER_SIZE:
+      case GL_SEPARABLE_2D:
+      case GL_SHADE_MODEL:
+      case GL_SMOOTH_LINE_WIDTH_GRANULARITY:
+      case GL_SMOOTH_POINT_SIZE_GRANULARITY:
+      case GL_STENCIL_BITS:
+      case GL_STENCIL_CLEAR_VALUE:
+      case GL_STENCIL_FAIL:
+      case GL_STENCIL_FUNC:
+      case GL_STENCIL_PASS_DEPTH_FAIL:
+      case GL_STENCIL_PASS_DEPTH_PASS:
+      case GL_STENCIL_REF:
+      case GL_STENCIL_TEST:
+      case GL_STENCIL_VALUE_MASK:
+      case GL_STENCIL_WRITEMASK:
+      case GL_STEREO:
+      case GL_SUBPIXEL_BITS:
+      case GL_TEXTURE_1D:
+      case GL_TEXTURE_BINDING_1D:
+      case GL_TEXTURE_2D:
+      case GL_TEXTURE_BINDING_2D:
+      case GL_TEXTURE_3D:
+      case GL_TEXTURE_BINDING_3D:
+      case GL_TEXTURE_COORD_ARRAY:
+      case GL_TEXTURE_COORD_ARRAY_SIZE:
+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
+      case GL_TEXTURE_COORD_ARRAY_TYPE:
+      case GL_TEXTURE_GEN_Q:
+      case GL_TEXTURE_GEN_R:
+      case GL_TEXTURE_GEN_S:
+      case GL_TEXTURE_GEN_T:
+      case GL_TEXTURE_STACK_DEPTH:
+      case GL_UNPACK_ALIGNMENT:
+      case GL_UNPACK_IMAGE_HEIGHT:
+      case GL_UNPACK_LSB_FIRST:
+      case GL_UNPACK_ROW_LENGTH:
+      case GL_UNPACK_SKIP_IMAGES:
+      case GL_UNPACK_SKIP_PIXELS:
+      case GL_UNPACK_SKIP_ROWS:
+      case GL_UNPACK_SWAP_BYTES:
+      case GL_VERTEX_ARRAY:
+      case GL_VERTEX_ARRAY_SIZE:
+      case GL_VERTEX_ARRAY_STRIDE:
+      case GL_VERTEX_ARRAY_TYPE:
+      case GL_ZOOM_X:
+      case GL_ZOOM_Y:
+         trWritei( params[0] );
+         break;
+
+      default:
+         /* Bad enum.  What should we do? */
+         break;
+   }
+}
+
+
+GLAPI void GLAPIENTRY trGetLightfv( GLenum light, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETLIGHTFV );
+	trWriteEnum( light );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetLightfv( light, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_AMBIENT:
+			case GL_DIFFUSE:
+			case GL_SPECULAR:
+			case GL_POSITION:
+				memset( params, 0, 4 * sizeof(GLfloat) );
+				break;
+			case GL_SPOT_DIRECTION:
+				memset( params, 0, 3 * sizeof(GLfloat) );
+				break;
+			case GL_SPOT_EXPONENT:
+			case GL_SPOT_CUTOFF:
+			case GL_CONSTANT_ATTENUATION:
+			case GL_LINEAR_ATTENUATION:
+			case GL_QUADRATIC_ATTENUATION:	
+				params[0] = 0;
+				break;
+			default:
+				/* The 2nd pass should catch this */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_POSITION:
+			trWriteArrayf( 4, params );
+			break;
+		case GL_SPOT_DIRECTION:
+			trWriteArrayf( 3, params );
+			break;
+		case GL_SPOT_EXPONENT:
+		case GL_SPOT_CUTOFF:
+		case GL_CONSTANT_ATTENUATION:
+		case GL_LINEAR_ATTENUATION:
+		case GL_QUADRATIC_ATTENUATION:	
+			trWritef( params[0] );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetLightiv( GLenum light, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETLIGHTIV );
+	trWriteEnum( light );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetLightiv( light, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_AMBIENT:
+			case GL_DIFFUSE:
+			case GL_SPECULAR:
+			case GL_POSITION:
+				memset( params, 0, 4 * sizeof(GLint) );
+				break;
+			case GL_SPOT_DIRECTION:
+				memset( params, 0, 3 * sizeof(GLint) );
+				break;
+			case GL_SPOT_EXPONENT:
+			case GL_SPOT_CUTOFF:
+			case GL_CONSTANT_ATTENUATION:
+			case GL_LINEAR_ATTENUATION:
+			case GL_QUADRATIC_ATTENUATION:	
+				params[0] = 0;
+				break;
+			default:
+				/* The 2nd pass should catch this */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_POSITION:
+			trWriteArrayi( 4, params );
+			break;
+		case GL_SPOT_DIRECTION:
+			trWriteArrayi( 3, params );
+			break;
+		case GL_SPOT_EXPONENT:
+		case GL_SPOT_CUTOFF:
+		case GL_CONSTANT_ATTENUATION:
+		case GL_LINEAR_ATTENUATION:
+		case GL_QUADRATIC_ATTENUATION:	
+			trWritei( params[0] );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetMapdv( GLenum target, GLenum query, GLdouble *v ) { /* TODO */
+	trWriteCMD( CMD_GETMAPDV );
+	trWriteEnum( target );
+	trWriteEnum( query );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMapdv( target, query, v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetMapfv( GLenum target, GLenum query, GLfloat *v ) { /* TODO */
+	trWriteCMD( CMD_GETMAPFV );
+	trWriteEnum( target );
+	trWriteEnum( query );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMapfv( target, query, v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetMapiv( GLenum target, GLenum query, GLint *v ) { /* TODO */
+	trWriteCMD( CMD_GETMAPIV );
+	trWriteEnum( target );
+	trWriteEnum( query );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMapiv( target, query, v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETMATERIALFV );
+	trWriteEnum( face );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMaterialfv( face, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_AMBIENT:
+			case GL_DIFFUSE:
+			case GL_SPECULAR:
+			case GL_EMISSION:
+				memset( params, 0, 4 * sizeof(GLfloat) );
+				break;
+			case GL_COLOR_INDEXES:
+				memset( params, 0, 3 * sizeof(GLfloat) );
+				break;
+			case GL_SHININESS:
+				params[0] = 0;
+				break;
+			default:
+				/* The 2nd pass will pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_EMISSION:
+			trWriteArrayf( 4, params );
+			break;
+		case GL_COLOR_INDEXES:
+			trWriteArrayf( 3, params );
+			break;
+		case GL_SHININESS:
+			trWritef( params[0] );
+			break;
+		default:
+			/* The 2nd pass will pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetMaterialiv( GLenum face, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETMATERIALIV );
+	trWriteEnum( face );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMaterialiv( face, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_AMBIENT:
+			case GL_DIFFUSE:
+			case GL_SPECULAR:
+			case GL_EMISSION:
+				memset( params, 0, 4 * sizeof(GLint) );
+				break;
+			case GL_COLOR_INDEXES:
+				memset( params, 0, 3 * sizeof(GLint) );
+				break;
+			case GL_SHININESS:
+				params[0] = 0;
+				break;
+			default:
+				/* The 2nd pass will pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_EMISSION:
+			trWriteArrayi( 4, params );
+			break;
+		case GL_COLOR_INDEXES:
+			trWriteArrayi( 3, params );
+			break;
+		case GL_SHININESS:
+			trWritei( params[0] );
+			break;
+		default:
+			/* The 2nd pass will pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values ) {
+	GLint pixelsize;
+
+	trWriteCMD( CMD_GETMINMAX );
+	trWriteEnum( target );
+	trWriteBool( reset );
+	trWriteEnum( format );
+	trWriteEnum( types );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMinmax( target, reset, format, types, values  );
+		trError();
+	} else {
+		switch( types ) {
+			case GL_BYTE:
+				((GLbyte *)values)[0] = 0;
+				((GLbyte *)values)[1] = 0;
+				break;
+
+			case GL_UNSIGNED_BYTE:
+			case GL_UNSIGNED_BYTE_3_3_2:
+			case GL_UNSIGNED_BYTE_2_3_3_REV:
+				((GLubyte *)values)[0] = 0;
+				((GLubyte *)values)[1] = 0;
+				break;
+
+			case GL_SHORT:
+				((GLshort *)values)[0] = 0;
+				((GLshort *)values)[1] = 0;
+				break;
+
+			case GL_UNSIGNED_SHORT:
+			case GL_UNSIGNED_SHORT_5_6_5:
+			case GL_UNSIGNED_SHORT_5_6_5_REV:
+			case GL_UNSIGNED_SHORT_4_4_4_4:
+			case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+			case GL_UNSIGNED_SHORT_5_5_5_1:
+			case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+				((GLshort *)values)[0] = 0;
+				((GLshort *)values)[1] = 0;
+				break;
+
+			case GL_INT:
+				((GLint *)values)[0] = 0;
+				((GLint *)values)[1] = 0;
+				break;
+
+			case GL_UNSIGNED_INT:
+			case GL_UNSIGNED_INT_8_8_8_8:
+			case GL_UNSIGNED_INT_8_8_8_8_REV:
+			case GL_UNSIGNED_INT_10_10_10_2:
+			case GL_UNSIGNED_INT_2_10_10_10_REV:
+				((GLuint *)values)[0] = 0;
+				((GLuint *)values)[1] = 0;
+				break;
+
+			case GL_FLOAT:
+				((GLfloat *)values)[0] = 0.0;
+				((GLfloat *)values)[1] = 0.0;
+				break;
+
+			default:
+				/* The 2nd pass should catch this. */
+				break;
+		}
+	}
+
+	pixelsize = trGetPixelSize( format, types );
+	trWriteTypeArray( types, 2, pixelsize, 0, values );
+}
+
+
+GLAPI void GLAPIENTRY trGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params ) { /* TODO */
+	trWriteCMD( CMD_GETMINMAXPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMinmaxParameterfv( target, pname, params  );
+		trError();
+	} else {
+      params[0] = 0.0;
+   }
+
+   trWritef( params[0] );
+}
+
+
+GLAPI void GLAPIENTRY trGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params ) { /* TODO */
+	trWriteCMD( CMD_GETMINMAXPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetMinmaxParameteriv( target, pname, params  );
+		trError();
+	} else {
+      params[0] = 0;
+   }
+
+   trWritei( params[0] );
+}
+
+
+GLAPI void GLAPIENTRY trGetPixelMapfv( GLenum map, GLfloat *values ) { /* TODO */
+	trWriteCMD( CMD_GETPIXELMAPFV );
+	trWriteEnum( map );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetPixelMapfv( map, values  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetPixelMapuiv( GLenum map, GLuint *values ) { /* TODO */
+	trWriteCMD( CMD_GETPIXELMAPUIV );
+	trWriteEnum( map );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetPixelMapuiv( map, values  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetPixelMapusv( GLenum map, GLushort *values ) { /* TODO */
+	trWriteCMD( CMD_GETPIXELMAPUSV );
+	trWriteEnum( map );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetPixelMapusv( map, values  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trGetPointervEXT( GLenum pname, void **params ) {
+	trWriteCMD( CMD_GETPOINTERVEXT );
+	trWriteEnum( pname );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetPointervEXT( pname, params );
+		trError();
+	} else {
+		*params = NULL;
+	}
+	trWritePointer( (void *)(*params) );
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trGetPointerv( GLenum pname, void **params ) {
+	trWriteCMD( CMD_GETPOINTERV );
+	trWriteEnum( pname );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetPointerv( pname, params );
+		trError();
+	} else {
+		*params = NULL;
+	}
+	trWritePointer( (void *)(*params) );
+}
+
+
+GLAPI void GLAPIENTRY trGetPolygonStipple( GLubyte *mask ) {
+	GLint i;
+
+	trWriteCMD( CMD_GETPOLYGONSTIPPLE );
+	trWritePointer( (void *)mask  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetPolygonStipple( mask  );
+		trError();
+	} else {
+		for( i = 0; i < 8 * 8; i++ ) {
+			mask[i] = 0x0;
+		}
+	}
+	for( i = 0; i < 8 * 8; i++ ) {
+		trWriteub( mask[i] );
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span ) {
+
+	trWriteCMD( CMD_GETSEPARABLEFILTER );
+	trWriteEnum( target );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)row );
+	trFileFlush();
+	trWritePointer( (void *)column );
+	trFileFlush();
+	trWritePointer( (void *)span  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetSeparableFilter( target, format, type, row, column, span  );
+		trError();
+	}
+}
+
+
+GLAPI const GLubyte* GLAPIENTRY trGetString( GLenum name ) {
+	const GLubyte * tmpstring;
+
+	trWriteCMD( CMD_GETSTRING );
+	trWriteEnum( name );
+
+	if( trCtx()->doExec ) {
+		tmpstring = trGetDispatch()->GetString( name );
+		trError();
+	} else {
+		tmpstring = NULL;
+	}
+
+	trWriteString( (char *)tmpstring );
+	return tmpstring;
+}
+
+
+GLAPI void GLAPIENTRY trGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETTEXENVFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexEnvfv( target, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_TEXTURE_ENV_MODE:
+				params[0] = 0.0;
+				break;
+			case GL_TEXTURE_ENV_COLOR:
+				memset( params, 0, 4 * sizeof(GLfloat) );
+				break;
+			default:
+				/* The 2nd pass should pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_TEXTURE_ENV_MODE:
+			trWritef( params[0] );
+			break;
+		case GL_TEXTURE_ENV_COLOR:
+			trWriteArrayf( 4, params );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetTexEnviv( GLenum target, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETTEXENVIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexEnviv( target, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_TEXTURE_ENV_MODE:
+				params[0] = 0;
+				break;
+			case GL_TEXTURE_ENV_COLOR:
+				memset( params, 0, 4 * sizeof(GLint) );
+				break;
+			default:
+				/* The 2nd pass should pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_TEXTURE_ENV_MODE:
+			trWritei( params[0] );
+			break;
+		case GL_TEXTURE_ENV_COLOR:
+			trWriteArrayi( 4, params );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetTexGendv( GLenum coord, GLenum pname, GLdouble *params ) {
+	trWriteCMD( CMD_GETTEXGENDV );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexGendv( coord, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_TEXTURE_GEN_MODE:
+				params[0] = 0.0;
+				break;
+			case GL_OBJECT_PLANE:
+			case GL_EYE_PLANE:
+				memset( params, 0, 4 * sizeof(GLdouble) );
+				break;
+			default:
+				/* The 2nd pass should pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_TEXTURE_GEN_MODE:
+			trWrited( params[0] );
+			break;
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			trWriteArrayd( 4, params );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETTEXGENFV );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexGenfv( coord, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_TEXTURE_GEN_MODE:
+				params[0] = 0.0;
+				break;
+			case GL_OBJECT_PLANE:
+			case GL_EYE_PLANE:
+				memset( params, 0, 4 * sizeof(GLfloat) );
+				break;
+			default:
+				/* The 2nd pass should pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_TEXTURE_GEN_MODE:
+			trWritef( params[0] );
+			break;
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			trWriteArrayf( 4, params );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetTexGeniv( GLenum coord, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETTEXGENIV );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexGeniv( coord, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_TEXTURE_GEN_MODE:
+				params[0] = 0;
+				break;
+			case GL_OBJECT_PLANE:
+			case GL_EYE_PLANE:
+				memset( params, 0, 4 * sizeof(GLint) );
+				break;
+			default:
+				/* The 2nd pass should pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_TEXTURE_GEN_MODE:
+			trWritei( params[0] );
+			break;
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			trWriteArrayi( 4, params );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels ) { /* TODO */
+
+	trWriteCMD( CMD_GETTEXIMAGE );
+	trWriteEnum( target );
+	trWritei( level );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexImage( target, level, format, type, pixels  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params ) {
+	trWriteCMD( CMD_GETTEXLEVELPARAMETERFV );
+	trWriteEnum( target );
+	trWritei( level );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexLevelParameterfv( target, level, pname, params  );
+		trError();
+	} else {
+		params[0] = 0.0;
+	}
+	trWritef( params[0] );
+}
+
+
+GLAPI void GLAPIENTRY trGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETTEXLEVELPARAMETERIV );
+	trWriteEnum( target );
+	trWritei( level );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexLevelParameteriv( target, level, pname, params  );
+		trError();
+	} else {
+		params[0] = 0;
+	}
+	trWritei( params[0] );
+}
+
+
+GLAPI void GLAPIENTRY trGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params) {
+	trWriteCMD( CMD_GETTEXPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexParameterfv( target, pname, params );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_TEXTURE_MAG_FILTER:
+			case GL_TEXTURE_MIN_FILTER:
+			case GL_TEXTURE_MIN_LOD:
+			case GL_TEXTURE_MAX_LOD:
+			case GL_TEXTURE_BASE_LEVEL:
+			case GL_TEXTURE_MAX_LEVEL:
+			case GL_TEXTURE_WRAP_S:
+			case GL_TEXTURE_WRAP_T:
+			case GL_TEXTURE_WRAP_R:
+			case GL_TEXTURE_PRIORITY:
+			case GL_TEXTURE_RESIDENT:
+				params[0] = 0.0;
+				break;
+			case GL_TEXTURE_BORDER_COLOR:
+				memset( params, 0, 4 * sizeof(GLfloat) );
+			default:
+				/* The 2nd pass should pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_TEXTURE_MAG_FILTER:
+		case GL_TEXTURE_MIN_FILTER:
+		case GL_TEXTURE_MIN_LOD:
+		case GL_TEXTURE_MAX_LOD:
+		case GL_TEXTURE_BASE_LEVEL:
+		case GL_TEXTURE_MAX_LEVEL:
+		case GL_TEXTURE_WRAP_S:
+		case GL_TEXTURE_WRAP_T:
+		case GL_TEXTURE_WRAP_R:
+		case GL_TEXTURE_PRIORITY:
+		case GL_TEXTURE_RESIDENT:
+			trWritef( params[0] );
+			break;
+		case GL_TEXTURE_BORDER_COLOR:
+			trWriteArrayf( 4, params );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trGetTexParameteriv( GLenum target, GLenum pname, GLint *params ) {
+	trWriteCMD( CMD_GETTEXPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->GetTexParameteriv( target, pname, params  );
+		trError();
+	} else {
+		switch( pname ) {
+			case GL_TEXTURE_MAG_FILTER:
+			case GL_TEXTURE_MIN_FILTER:
+			case GL_TEXTURE_MIN_LOD:
+			case GL_TEXTURE_MAX_LOD:
+			case GL_TEXTURE_BASE_LEVEL:
+			case GL_TEXTURE_MAX_LEVEL:
+			case GL_TEXTURE_WRAP_S:
+			case GL_TEXTURE_WRAP_T:
+			case GL_TEXTURE_WRAP_R:
+			case GL_TEXTURE_PRIORITY:
+			case GL_TEXTURE_RESIDENT:
+				params[0] = 0;
+				break;
+			case GL_TEXTURE_BORDER_COLOR:
+				memset( params, 0, 4 * sizeof(GLint) );
+			default:
+				/* The 2nd pass should pick this up. */
+				break;
+		}
+	}
+	switch( pname ) {
+		case GL_TEXTURE_MAG_FILTER:
+		case GL_TEXTURE_MIN_FILTER:
+		case GL_TEXTURE_MIN_LOD:
+		case GL_TEXTURE_MAX_LOD:
+		case GL_TEXTURE_BASE_LEVEL:
+		case GL_TEXTURE_MAX_LEVEL:
+		case GL_TEXTURE_WRAP_S:
+		case GL_TEXTURE_WRAP_T:
+		case GL_TEXTURE_WRAP_R:
+		case GL_TEXTURE_PRIORITY:
+		case GL_TEXTURE_RESIDENT:
+			trWritei( params[0] );
+			break;
+		case GL_TEXTURE_BORDER_COLOR:
+			trWriteArrayi( 4, params );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+}
+
+
+GLAPI void GLAPIENTRY trHint( GLenum target, GLenum mode ) {
+	trWriteCMD( CMD_HINT );
+	trWriteEnum( target );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Hint( target, mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) {
+	trWriteCMD( CMD_HISTOGRAM );
+	trWriteEnum( target );
+	trWriteSizei( width );
+	trWriteEnum( internalformat );
+	trWriteBool( sink );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Histogram( target, width, internalformat, sink );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexd( GLdouble c ) {
+	trWriteCMD( CMD_INDEXD );
+	trWrited( c );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexd( c );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexdv( const GLdouble *c ) {
+	trWriteCMD( CMD_INDEXDV );
+	trWritePointer( (void *)c  );
+	trFileFlush();
+	trWrited( c[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexdv( c  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexf( GLfloat c ) {
+	trWriteCMD( CMD_INDEXF );
+	trWritef( c );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexf( c );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexfv( const GLfloat *c ) {
+	trWriteCMD( CMD_INDEXFV );
+	trWritePointer( (void *)c  );
+	trFileFlush();
+	trWritef( c[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexfv( c  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexi( GLint c ) {
+	trWriteCMD( CMD_INDEXI );
+	trWritei( c );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexi( c );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexiv( const GLint *c ) {
+	trWriteCMD( CMD_INDEXIV );
+	trWritePointer( (void *)c  );
+	trFileFlush();
+	trWritei( c[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexiv( c  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexMask( GLuint mask ) {
+	trWriteCMD( CMD_INDEXMASK );
+	trWriteui( mask );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->IndexMask( mask );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */
+	trWriteCMD( CMD_INDEXPOINTEREXT );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWriteSizei( count );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->IndexPointerEXT( type, stride, count, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_INDEXPOINTER );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	tctx = trCtx();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->IndexPointer( type, stride, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexs( GLshort c ) {
+	trWriteCMD( CMD_INDEXS );
+	trWrites( c );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexs( c );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexsv( const GLshort *c ) {
+	trWriteCMD( CMD_INDEXSV );
+	trWritePointer( (void *)c  );
+	trFileFlush();
+	trWrites( c[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexsv( c  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexub( GLubyte c ) {
+	trWriteCMD( CMD_INDEXUB );
+	trWriteub( c );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexub( c );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trIndexubv( const GLubyte *c ) {
+	trWriteCMD( CMD_INDEXUBV );
+	trWritePointer( (void *)c  );
+	trFileFlush();
+	trWriteub( c[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Indexubv( c  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trInitNames( void ) {
+	trWriteCMD( CMD_INITNAMES );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->InitNames(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trInterleavedArrays( GLenum format, GLsizei stride, const GLvoid *pointer ) { /* TODO */
+	trace_context_t * tctx = trCtx();
+
+	trWriteCMD( CMD_INTERLEAVEDARRAYS );
+	trWriteEnum( format );
+	trWriteSizei( stride );
+	trWritePointer( (void *)pointer  );
+	trFileFlush();
+
+	if( tctx->doExec ) {
+		trSetOriginalDispatch();
+		trGetDispatch()->InterleavedArrays( format, stride, pointer  );
+		trSetTraceDispatch();
+		trError();
+	}
+}
+
+
+GLAPI GLboolean GLAPIENTRY trIsEnabled( GLenum cap ) {
+	GLboolean retval;
+
+	trWriteCMD( CMD_ISENABLED );
+	trWriteEnum( cap );
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->IsEnabled( cap );
+		trError();
+	} else {
+		retval = GL_FALSE;
+	}
+	trWriteBool( retval );
+	return retval;
+}
+
+
+GLAPI GLboolean GLAPIENTRY trIsList( GLuint list ) {
+	GLboolean retval;
+
+	trWriteCMD( CMD_ISLIST );
+	trWriteui( list );
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->IsList( list );
+		trError();
+	} else {
+		retval = GL_FALSE;
+	}
+	trWriteBool( retval );
+	return retval;
+}
+
+
+GLAPI GLboolean GLAPIENTRY trIsTexture( GLuint texture ) {
+	GLboolean retval;
+
+	trWriteCMD( CMD_ISTEXTURE );
+	trWriteui( texture );
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->IsTexture( texture );
+		trError();
+	} else {
+		retval = GL_FALSE;
+	}
+	trWriteBool( retval );
+	return retval;
+}
+
+
+GLAPI GLboolean GLAPIENTRY trIsTextureEXT( GLuint texture ) {
+	GLboolean retval;
+
+	trWriteCMD( CMD_ISTEXTUREEXT );
+	trWriteui( texture );
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->IsTextureEXT( texture );
+		trError();
+	} else {
+		retval = GL_FALSE;
+	}
+	trWriteBool( retval );
+	return retval;
+}
+
+
+GLAPI void GLAPIENTRY trLightf( GLenum light, GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_LIGHTF );
+	trWriteEnum( light );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Lightf( light, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLightfv( GLenum light, GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_LIGHTFV );
+	trWriteEnum( light );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_POSITION:
+			trWriteArrayf( 4, params );
+			break;
+		case GL_SPOT_DIRECTION:
+			trWriteArrayf( 3, params );
+			break;
+		case GL_SPOT_EXPONENT:
+		case GL_SPOT_CUTOFF:
+		case GL_CONSTANT_ATTENUATION:
+		case GL_LINEAR_ATTENUATION:
+		case GL_QUADRATIC_ATTENUATION:
+			trWritef( params[0] );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Lightfv( light, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLighti( GLenum light, GLenum pname, GLint param ) {
+	trWriteCMD( CMD_LIGHTI );
+	trWriteEnum( light );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Lighti( light, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLightiv( GLenum light, GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_LIGHTIV );
+	trWriteEnum( light );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_POSITION:
+			trWriteArrayi( 4, params );
+			break;
+		case GL_SPOT_DIRECTION:
+			trWriteArrayi( 3, params );
+			break;
+		case GL_SPOT_EXPONENT:
+		case GL_SPOT_CUTOFF:
+		case GL_CONSTANT_ATTENUATION:
+		case GL_LINEAR_ATTENUATION:
+		case GL_QUADRATIC_ATTENUATION:
+			trWritei( params[0] );
+			break;
+		default:
+			/* The 2nd pass should pick this up. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Lightiv( light, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLightModelf( GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_LIGHTMODELF );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LightModelf( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLightModelfv( GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_LIGHTMODELFV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_LIGHT_MODEL_AMBIENT:
+			trWriteArrayf( 4, params );
+			break;
+		case GL_LIGHT_MODEL_COLOR_CONTROL:
+		case GL_LIGHT_MODEL_LOCAL_VIEWER:
+		case GL_LIGHT_MODEL_TWO_SIDE:
+			trWritef( params[0] );
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LightModelfv( pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLightModeli( GLenum pname, GLint param ) {
+	trWriteCMD( CMD_LIGHTMODELI );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LightModeli( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLightModeliv( GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_LIGHTMODELIV );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_LIGHT_MODEL_AMBIENT:
+			trWriteArrayi( 4, params );
+			break;
+		case GL_LIGHT_MODEL_COLOR_CONTROL:
+		case GL_LIGHT_MODEL_LOCAL_VIEWER:
+		case GL_LIGHT_MODEL_TWO_SIDE:
+			trWritei( params[0] );
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LightModeliv( pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLineStipple( GLint factor, GLushort pattern ) {
+	trWriteCMD( CMD_LINESTIPPLE );
+	trWritei( factor );
+	trWriteus( pattern );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LineStipple( factor, pattern );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLineWidth( GLfloat width ) {
+	trWriteCMD( CMD_LINEWIDTH );
+	trWritef( width );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LineWidth( width );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trListBase( GLuint base ) {
+	trWriteCMD( CMD_LISTBASE );
+	trWriteui( base );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ListBase( base );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLoadIdentity( void ) {
+	trWriteCMD( CMD_LOADIDENTITY );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LoadIdentity(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLoadMatrixd( const GLdouble *m ) {
+	trWriteCMD( CMD_LOADMATRIXD );
+	trWritePointer( (void *)m  );
+	trFileFlush();
+	trWriteArrayd( 16, m );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LoadMatrixd( m  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLoadMatrixf( const GLfloat *m ) {
+	trWriteCMD( CMD_LOADMATRIXF );
+	trWritePointer( (void *)m  );
+	trFileFlush();
+	trWriteArrayf( 16, m );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LoadMatrixf( m  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLoadName( GLuint name ) {
+	trWriteCMD( CMD_LOADNAME );
+	trWriteui( name );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LoadName( name );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLockArraysEXT( GLint first, GLsizei count ) {
+	trWriteCMD( CMD_LOCKARRAYSEXT );
+	trWritei( first );
+	trWriteSizei( count );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LockArraysEXT( first, count );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trLogicOp( GLenum opcode ) {
+	trWriteCMD( CMD_LOGICOP );
+	trWriteEnum( opcode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->LogicOp( opcode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points ) {
+	GLint i;
+
+	trWriteCMD( CMD_MAP1D );
+	trWriteEnum( target );
+	trWrited( u1 );
+	trWrited( u2 );
+	trWritei( stride );
+	trWritei( order );
+	trWritePointer( (void *)points  );
+	trFileFlush();
+
+	switch( target ) {
+		case GL_MAP1_INDEX:
+		case GL_MAP1_TEXTURE_COORD_1:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWrited( points[i] );
+			}
+			break;
+		case GL_MAP1_TEXTURE_COORD_2:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWrited( points[i] );
+				trWrited( points[i + 1] );
+			}
+			break;
+		case GL_MAP1_VERTEX_3:
+		case GL_MAP1_NORMAL:
+		case GL_MAP1_TEXTURE_COORD_3:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWrited( points[i] );
+				trWrited( points[i + 1] );
+				trWrited( points[i + 2] );
+			}
+			break;
+		case GL_MAP1_VERTEX_4:
+		case GL_MAP1_TEXTURE_COORD_4:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWrited( points[i] );
+				trWrited( points[i + 1] );
+				trWrited( points[i + 2] );
+				trWrited( points[i + 3] );
+			}
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Map1d( target, u1, u2, stride, order, points  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points ) {
+	GLint i;
+
+	trWriteCMD( CMD_MAP1F );
+	trWriteEnum( target );
+	trWritef( u1 );
+	trWritef( u2 );
+	trWritei( stride );
+	trWritei( order );
+	trWritePointer( (void *)points  );
+	trFileFlush();
+
+	switch( target ) {
+		case GL_MAP1_INDEX:
+		case GL_MAP1_TEXTURE_COORD_1:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWritef( points[i] );
+			}
+			break;
+		case GL_MAP1_TEXTURE_COORD_2:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWritef( points[i] );
+				trWritef( points[i + 1] );
+			}
+			break;
+		case GL_MAP1_VERTEX_3:
+		case GL_MAP1_NORMAL:
+		case GL_MAP1_TEXTURE_COORD_3:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWritef( points[i] );
+				trWritef( points[i + 1] );
+				trWritef( points[i + 2] );
+			}
+			break;
+		case GL_MAP1_VERTEX_4:
+		case GL_MAP1_TEXTURE_COORD_4:
+			for( i = 0; i < stride * order; i += stride ) {
+				trWritef( points[i] );
+				trWritef( points[i + 1] );
+				trWritef( points[i + 2] );
+				trWritef( points[i + 3] );
+			}
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Map1f( target, u1, u2, stride, order, points  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points ) {
+	GLint i;
+	GLint j;
+
+	trWriteCMD( CMD_MAP2D );
+	trWriteEnum( target );
+	trWrited( u1 );
+	trWrited( u2 );
+	trWritei( ustride );
+	trWritei( uorder );
+	trWrited( v1 );
+	trWrited( v2 );
+	trWritei( vstride );
+	trWritei( vorder );
+	trWritePointer( (void *)points  );
+	trFileFlush();
+
+	switch( target ) {
+		case GL_MAP1_INDEX:
+		case GL_MAP1_TEXTURE_COORD_1:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWrited( points[i + j] );
+				}
+			}
+			break;
+		case GL_MAP1_TEXTURE_COORD_2:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWrited( points[i + j] );
+					trWrited( points[i + j + 1] );
+				}
+			}
+			break;
+		case GL_MAP1_VERTEX_3:
+		case GL_MAP1_NORMAL:
+		case GL_MAP1_TEXTURE_COORD_3:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWrited( points[i + j] );
+					trWrited( points[i + j + 1] );
+					trWrited( points[i + j + 2] );
+				}
+			}
+			break;
+		case GL_MAP1_VERTEX_4:
+		case GL_MAP1_TEXTURE_COORD_4:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWrited( points[i + j] );
+					trWrited( points[i + j + 1] );
+					trWrited( points[i + j + 2] );
+					trWrited( points[i + j + 3] );
+				}
+			}
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Map2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points ) {
+	GLint i;
+	GLint j;
+
+	trWriteCMD( CMD_MAP2F );
+	trWriteEnum( target );
+	trWritef( u1 );
+	trWritef( u2 );
+	trWritei( ustride );
+	trWritei( uorder );
+	trWritef( v1 );
+	trWritef( v2 );
+	trWritei( vstride );
+	trWritei( vorder );
+	trWritePointer( (void *)points  );
+	trFileFlush();
+
+	switch( target ) {
+		case GL_MAP1_INDEX:
+		case GL_MAP1_TEXTURE_COORD_1:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWritef( points[i + j] );
+				}
+			}
+			break;
+		case GL_MAP1_TEXTURE_COORD_2:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWritef( points[i + j] );
+					trWritef( points[i + j + 1] );
+				}
+			}
+			break;
+		case GL_MAP1_VERTEX_3:
+		case GL_MAP1_NORMAL:
+		case GL_MAP1_TEXTURE_COORD_3:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWritef( points[i + j] );
+					trWritef( points[i + j + 1] );
+					trWritef( points[i + j + 2] );
+				}
+			}
+			break;
+		case GL_MAP1_VERTEX_4:
+		case GL_MAP1_TEXTURE_COORD_4:
+			for( j = 0; j < vstride * vorder; j += vstride ) {
+				for( i = 0; i < ustride * uorder; i += ustride ) {
+					trWritef( points[i + j] );
+					trWritef( points[i + j + 1] );
+					trWritef( points[i + j + 2] );
+					trWritef( points[i + j + 3] );
+				}
+			}
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Map2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) {
+	trWriteCMD( CMD_MAPGRID1D );
+	trWritei( un );
+	trWrited( u1 );
+	trWrited( u2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MapGrid1d( un, u1, u2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) {
+	trWriteCMD( CMD_MAPGRID1F );
+	trWritei( un );
+	trWritef( u1 );
+	trWritef( u2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MapGrid1f( un, u1, u2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) {
+	trWriteCMD( CMD_MAPGRID2D );
+	trWritei( un );
+	trWrited( u1 );
+	trWrited( u2 );
+	trWritei( vn );
+	trWrited( v1 );
+	trWrited( v2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MapGrid2d( un, u1, u2, vn, v1, v2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) {
+	trWriteCMD( CMD_MAPGRID2F );
+	trWritei( un );
+	trWritef( u1 );
+	trWritef( u2 );
+	trWritei( vn );
+	trWritef( v1 );
+	trWritef( v2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MapGrid2f( un, u1, u2, vn, v1, v2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMaterialf( GLenum face, GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_MATERIALF );
+	trWriteEnum( face );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Materialf( face, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMaterialfv( GLenum face, GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_MATERIALFV );
+	trWriteEnum( face );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_AMBIENT_AND_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_EMISSION:
+			trWriteArrayf( 4, params );
+			break;
+		case GL_SHININESS:
+			trWritef( params[0] );
+			break;
+		case GL_COLOR_INDEXES:
+			trWriteArrayf( 3, params );
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Materialfv( face, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMateriali( GLenum face, GLenum pname, GLint param ) {
+	trWriteCMD( CMD_MATERIALI );
+	trWriteEnum( face );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Materiali( face, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMaterialiv( GLenum face, GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_MATERIALIV );
+	trWriteEnum( face );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_AMBIENT:
+		case GL_DIFFUSE:
+		case GL_AMBIENT_AND_DIFFUSE:
+		case GL_SPECULAR:
+		case GL_EMISSION:
+			trWriteArrayi( 4, params );
+			break;
+		case GL_SHININESS:
+			trWritei( params[0] );
+			break;
+		case GL_COLOR_INDEXES:
+			trWriteArrayi( 3, params );
+			break;
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Materialiv( face, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMatrixMode( GLenum mode ) {
+	trWriteCMD( CMD_MATRIXMODE );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MatrixMode( mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMinmax( GLenum target, GLenum internalformat, GLboolean sink ) {
+	trWriteCMD( CMD_MINMAX );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWriteBool( sink );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Minmax( target, internalformat, sink );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1dARB( GLenum target, GLdouble s) {
+	trWriteCMD( CMD_MULTITEXCOORD1DARB );
+	trWriteEnum( target );
+	trWrited( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1dARB( target, s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1dvARB( GLenum target, const GLdouble *v) {
+	trWriteCMD( CMD_MULTITEXCOORD1DVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWrited( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1dvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1fARB( GLenum target, GLfloat s) {
+	trWriteCMD( CMD_MULTITEXCOORD1FARB );
+	trWriteEnum( target );
+	trWritef( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1fARB( target, s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1fvARB( GLenum target, const GLfloat *v) {
+	trWriteCMD( CMD_MULTITEXCOORD1FVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWritef( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1fvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1iARB( GLenum target, GLint s) {
+	trWriteCMD( CMD_MULTITEXCOORD1IARB );
+	trWriteEnum( target );
+	trWritei( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1iARB( target, s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1ivARB( GLenum target, const GLint *v) {
+	trWriteCMD( CMD_MULTITEXCOORD1IVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWritei( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1ivARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1sARB( GLenum target, GLshort s) {
+	trWriteCMD( CMD_MULTITEXCOORD1SARB );
+	trWriteEnum( target );
+	trWrites( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1sARB( target, s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord1svARB( GLenum target, const GLshort *v) {
+	trWriteCMD( CMD_MULTITEXCOORD1SVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWrites( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord1svARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t) {
+	trWriteCMD( CMD_MULTITEXCOORD2DARB );
+	trWriteEnum( target );
+	trWrited( s );
+	trWrited( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2dARB( target, s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2dvARB( GLenum target, const GLdouble *v) {
+	trWriteCMD( CMD_MULTITEXCOORD2DVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayd( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2dvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t) {
+	trWriteCMD( CMD_MULTITEXCOORD2FARB );
+	trWriteEnum( target );
+	trWritef( s );
+	trWritef( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2fARB( target, s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2fvARB( GLenum target, const GLfloat *v) {
+	trWriteCMD( CMD_MULTITEXCOORD2FVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayf( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2fvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2iARB( GLenum target, GLint s, GLint t) {
+	trWriteCMD( CMD_MULTITEXCOORD2IARB );
+	trWriteEnum( target );
+	trWritei( s );
+	trWritei( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2iARB( target, s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2ivARB( GLenum target, const GLint *v) {
+	trWriteCMD( CMD_MULTITEXCOORD2IVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayi( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2ivARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t) {
+	trWriteCMD( CMD_MULTITEXCOORD2SARB );
+	trWriteEnum( target );
+	trWrites( s );
+	trWrites( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2sARB( target, s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord2svARB( GLenum target, const GLshort *v) {
+	trWriteCMD( CMD_MULTITEXCOORD2SVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrays( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord2svARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r) {
+	trWriteCMD( CMD_MULTITEXCOORD3DARB );
+	trWriteEnum( target );
+	trWrited( s );
+	trWrited( t );
+	trWrited( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3dARB( target, s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3dvARB( GLenum target, const GLdouble *v) {
+	trWriteCMD( CMD_MULTITEXCOORD3DVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayd( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3dvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r) {
+	trWriteCMD( CMD_MULTITEXCOORD3FARB );
+	trWriteEnum( target );
+	trWritef( s );
+	trWritef( t );
+	trWritef( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3fARB( target, s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3fvARB( GLenum target, const GLfloat *v) {
+	trWriteCMD( CMD_MULTITEXCOORD3FVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayf( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3fvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r) {
+	trWriteCMD( CMD_MULTITEXCOORD3IARB );
+	trWriteEnum( target );
+	trWritei( s );
+	trWritei( t );
+	trWritei( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3iARB( target, s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3ivARB( GLenum target, const GLint *v) {
+	trWriteCMD( CMD_MULTITEXCOORD3IVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayi( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3ivARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r) {
+	trWriteCMD( CMD_MULTITEXCOORD3SARB );
+	trWriteEnum( target );
+	trWrites( s );
+	trWrites( t );
+	trWrites( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3sARB( target, s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord3svARB( GLenum target, const GLshort *v) {
+	trWriteCMD( CMD_MULTITEXCOORD3SVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrays( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord3svARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
+	trWriteCMD( CMD_MULTITEXCOORD4DARB );
+	trWriteEnum( target );
+	trWrited( s );
+	trWrited( t );
+	trWrited( r );
+	trWrited( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4dARB( target, s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4dvARB( GLenum target, const GLdouble *v) {
+	trWriteCMD( CMD_MULTITEXCOORD4DVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayd( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4dvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
+	trWriteCMD( CMD_MULTITEXCOORD4FARB );
+	trWriteEnum( target );
+	trWritef( s );
+	trWritef( t );
+	trWritef( r );
+	trWritef( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4fARB( target, s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4fvARB( GLenum target, const GLfloat *v) {
+	trWriteCMD( CMD_MULTITEXCOORD4FVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayf( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4fvARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q) {
+	trWriteCMD( CMD_MULTITEXCOORD4IARB );
+	trWriteEnum( target );
+	trWritei( s );
+	trWritei( t );
+	trWritei( r );
+	trWritei( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4iARB( target, s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4ivARB( GLenum target, const GLint *v) {
+	trWriteCMD( CMD_MULTITEXCOORD4IVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrayi( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4ivARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) {
+	trWriteCMD( CMD_MULTITEXCOORD4SARB );
+	trWriteEnum( target );
+	trWrites( s );
+	trWrites( t );
+	trWrites( r );
+	trWrites( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4sARB( target, s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultiTexCoord4svARB( GLenum target, const GLshort *v) {
+	trWriteCMD( CMD_MULTITEXCOORD4SVARB );
+	trWriteEnum( target );
+	trWritePointer( (void *)v );
+	trFileFlush();
+	trWriteArrays( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultiTexCoord4svARB( target, v );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultMatrixd( const GLdouble *m ) {
+	trWriteCMD( CMD_MULTMATRIXD );
+	trWritePointer( (void *)m  );
+	trFileFlush();
+	trWriteArrayd( 16, m );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultMatrixd( m  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trMultMatrixf( const GLfloat *m ) {
+	trWriteCMD( CMD_MULTMATRIXF );
+	trWritePointer( (void *)m  );
+	trFileFlush();
+	trWriteArrayf( 16, m );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->MultMatrixf( m  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNewList( GLuint list, GLenum mode ) {
+	trWriteCMD( CMD_NEWLIST );
+	trWriteui( list );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->NewList( list, mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3b( GLbyte nx, GLbyte ny, GLbyte nz ) {
+	trWriteCMD( CMD_NORMAL3B );
+	trWriteb( nx );
+	trWriteb( ny );
+	trWriteb( nz );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3b( nx, ny, nz );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3bv( const GLbyte *v ) {
+	trWriteCMD( CMD_NORMAL3BV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayb( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3bv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3d( GLdouble nx, GLdouble ny, GLdouble nz ) {
+	trWriteCMD( CMD_NORMAL3D );
+	trWrited( nx );
+	trWrited( ny );
+	trWrited( nz );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3d( nx, ny, nz );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3dv( const GLdouble *v ) {
+	trWriteCMD( CMD_NORMAL3DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3f( GLfloat nx, GLfloat ny, GLfloat nz ) {
+	trWriteCMD( CMD_NORMAL3F );
+	trWritef( nx );
+	trWritef( ny );
+	trWritef( nz );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3f( nx, ny, nz );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3fv( const GLfloat *v ) {
+	trWriteCMD( CMD_NORMAL3FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3i( GLint nx, GLint ny, GLint nz ) {
+	trWriteCMD( CMD_NORMAL3I );
+	trWritei( nx );
+	trWritei( ny );
+	trWritei( nz );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3i( nx, ny, nz );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3iv( const GLint *v ) {
+	trWriteCMD( CMD_NORMAL3IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3s( GLshort nx, GLshort ny, GLshort nz ) {
+	trWriteCMD( CMD_NORMAL3S );
+	trWrites( nx );
+	trWrites( ny );
+	trWrites( nz );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3s( nx, ny, nz );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormal3sv( const GLshort *v ) {
+	trWriteCMD( CMD_NORMAL3SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Normal3sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */
+	trWriteCMD( CMD_NORMALPOINTEREXT );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWriteSizei( count );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->NormalPointerEXT( type, stride, count, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trNormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */
+	trWriteCMD( CMD_NORMALPOINTER );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->NormalPointer( type, stride, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) {
+	trWriteCMD( CMD_ORTHO );
+	trWrited( left );
+	trWrited( right );
+	trWrited( bottom );
+	trWrited( top );
+	trWrited( near_val );
+	trWrited( far_val );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Ortho( left, right, bottom, top, near_val, far_val );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPassThrough( GLfloat token ) {
+	trWriteCMD( CMD_PASSTHROUGH );
+	trWritef( token );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PassThrough( token );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelMapfv( GLenum map, GLint mapsize, const GLfloat *values ) {
+	trWriteCMD( CMD_PIXELMAPFV );
+	trWriteEnum( map );
+	trWritei( mapsize );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+	trWriteArrayf( mapsize, values );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelMapfv( map, mapsize, values  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelMapuiv( GLenum map, GLint mapsize, const GLuint *values ) {
+	trWriteCMD( CMD_PIXELMAPUIV );
+	trWriteEnum( map );
+	trWritei( mapsize );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+	trWriteArrayui( mapsize, values );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelMapuiv( map, mapsize, values  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelMapusv( GLenum map, GLint mapsize, const GLushort *values ) {
+	trWriteCMD( CMD_PIXELMAPUSV );
+	trWriteEnum( map );
+	trWritei( mapsize );
+	trWritePointer( (void *)values  );
+	trFileFlush();
+	trWriteArrayus( mapsize, values );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelMapusv( map, mapsize, values  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelStoref( GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_PIXELSTOREF );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelStoref( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelStorei( GLenum pname, GLint param ) {
+	trWriteCMD( CMD_PIXELSTOREI );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelStorei( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelTransferf( GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_PIXELTRANSFERF );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelTransferf( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelTransferi( GLenum pname, GLint param ) {
+	trWriteCMD( CMD_PIXELTRANSFERI );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelTransferi( pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPixelZoom( GLfloat xfactor, GLfloat yfactor ) {
+	trWriteCMD( CMD_PIXELZOOM );
+	trWritef( xfactor );
+	trWritef( yfactor );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PixelZoom( xfactor, yfactor );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPointParameterfEXT( GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_POINTPARAMETERFEXT );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PointParameterfEXT( pname, param );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trPointParameterfSGIS( GLenum pname, GLfloat param) {
+	trWriteCMD( CMD_POINTPARAMETERFSGIS );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PointParameterfSGIS( pname, param );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trPointParameterfvEXT( GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_POINTPARAMETERFVEXT );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_POINT_SIZE_MIN_EXT:
+		case GL_POINT_SIZE_MAX_EXT:
+		case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
+			trWritef( params[0] );
+			break;
+
+		case GL_DISTANCE_ATTENUATION_EXT:
+			trWriteArrayf( 3, params );
+			break;
+
+		default:
+			/* The 2nd pass should handle this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PointParameterfvEXT( pname, params  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trPointParameterfvSGIS( GLenum pname, const GLfloat *params) { /* TODO */
+	trWriteCMD( CMD_POINTPARAMETERFVSGIS );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PointParameterfvSGIS( pname, params );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trPointSize( GLfloat size ) {
+	trWriteCMD( CMD_POINTSIZE );
+	trWritef( size );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PointSize( size );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPolygonMode( GLenum face, GLenum mode ) {
+	trWriteCMD( CMD_POLYGONMODE );
+	trWriteEnum( face );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PolygonMode( face, mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPolygonOffsetEXT( GLfloat factor, GLfloat bias ) {
+	trWriteCMD( CMD_POLYGONOFFSETEXT );
+	trWritef( factor );
+	trWritef( bias );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PolygonOffsetEXT( factor, bias );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPolygonOffset( GLfloat factor, GLfloat units ) {
+	trWriteCMD( CMD_POLYGONOFFSET );
+	trWritef( factor );
+	trWritef( units );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PolygonOffset( factor, units );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPolygonStipple( const GLubyte *mask ) {
+	trWriteCMD( CMD_POLYGONSTIPPLE );
+	trWritePointer( (void *)mask  );
+	trFileFlush();
+	trWriteArrayub( 64, mask );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PolygonStipple( mask  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPopAttrib( void ) {
+	trWriteCMD( CMD_POPATTRIB );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PopAttrib(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPopClientAttrib( void ) {
+	trWriteCMD( CMD_POPCLIENTATTRIB );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PopClientAttrib(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPopMatrix( void ) {
+	trWriteCMD( CMD_POPMATRIX );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PopMatrix(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPopName( void ) {
+	trWriteCMD( CMD_POPNAME );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PopName(  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trPrioritizeTexturesEXT( GLsizei n, const GLuint *textures, const GLclampf *priorities ) {
+	trWriteCMD( CMD_PRIORITIZETEXTURESEXT );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures );
+	trFileFlush();
+	trWriteArrayui( n, textures );
+
+	trWritePointer( (void *)priorities  );
+	trFileFlush();
+	/* FIXME!!! */
+	trWriteArrayf( n, priorities );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PrioritizeTexturesEXT( n, textures, priorities  );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities ) {
+	trWriteCMD( CMD_PRIORITIZETEXTURES );
+	trWriteSizei( n );
+	trWritePointer( (void *)textures );
+	trFileFlush();
+	trWriteArrayui( n, textures );
+
+	trWritePointer( (void *)priorities  );
+	trFileFlush();
+	/* FIXME!!! */
+	trWriteArrayf( n, priorities );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PrioritizeTextures( n, textures, priorities  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPushAttrib( GLbitfield mask ) {
+	trWriteCMD( CMD_PUSHATTRIB );
+	trWriteBits( mask );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PushAttrib( mask );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPushClientAttrib( GLbitfield mask ) {
+	trWriteCMD( CMD_PUSHCLIENTATTRIB );
+	trWriteBits( mask );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PushClientAttrib( mask );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPushMatrix( void ) {
+	trWriteCMD( CMD_PUSHMATRIX );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PushMatrix(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trPushName( GLuint name ) {
+	trWriteCMD( CMD_PUSHNAME );
+	trWriteui( name );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->PushName( name );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2d( GLdouble x, GLdouble y ) {
+	trWriteCMD( CMD_RASTERPOS2D );
+	trWrited( x );
+	trWrited( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2d( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2dv( const GLdouble *v ) {
+	trWriteCMD( CMD_RASTERPOS2DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2f( GLfloat x, GLfloat y ) {
+	trWriteCMD( CMD_RASTERPOS2F );
+	trWritef( x );
+	trWritef( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2f( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2fv( const GLfloat *v ) {
+	trWriteCMD( CMD_RASTERPOS2FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2i( GLint x, GLint y ) {
+	trWriteCMD( CMD_RASTERPOS2I );
+	trWritei( x );
+	trWritei( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2i( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2iv( const GLint *v ) {
+	trWriteCMD( CMD_RASTERPOS2IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2s( GLshort x, GLshort y ) {
+	trWriteCMD( CMD_RASTERPOS2S );
+	trWrites( x );
+	trWrites( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2s( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos2sv( const GLshort *v ) {
+	trWriteCMD( CMD_RASTERPOS2SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos2sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3d( GLdouble x, GLdouble y, GLdouble z ) {
+	trWriteCMD( CMD_RASTERPOS3D );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3d( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3dv( const GLdouble *v ) {
+	trWriteCMD( CMD_RASTERPOS3DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3f( GLfloat x, GLfloat y, GLfloat z ) {
+	trWriteCMD( CMD_RASTERPOS3F );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3f( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3fv( const GLfloat *v ) {
+	trWriteCMD( CMD_RASTERPOS3FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3i( GLint x, GLint y, GLint z ) {
+	trWriteCMD( CMD_RASTERPOS3I );
+	trWritei( x );
+	trWritei( y );
+	trWritei( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3i( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3iv( const GLint *v ) {
+	trWriteCMD( CMD_RASTERPOS3IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3s( GLshort x, GLshort y, GLshort z ) {
+	trWriteCMD( CMD_RASTERPOS3S );
+	trWrites( x );
+	trWrites( y );
+	trWrites( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3s( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos3sv( const GLshort *v ) {
+	trWriteCMD( CMD_RASTERPOS3SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos3sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+	trWriteCMD( CMD_RASTERPOS4D );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+	trWrited( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4d( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4dv( const GLdouble *v ) {
+	trWriteCMD( CMD_RASTERPOS4DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+	trWriteCMD( CMD_RASTERPOS4F );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+	trWritef( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4f( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4fv( const GLfloat *v ) {
+	trWriteCMD( CMD_RASTERPOS4FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4i( GLint x, GLint y, GLint z, GLint w ) {
+	trWriteCMD( CMD_RASTERPOS4I );
+	trWritei( x );
+	trWritei( y );
+	trWritei( z );
+	trWritei( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4i( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4iv( const GLint *v ) {
+	trWriteCMD( CMD_RASTERPOS4IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
+	trWriteCMD( CMD_RASTERPOS4S );
+	trWrites( x );
+	trWrites( y );
+	trWrites( z );
+	trWrites( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4s( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRasterPos4sv( const GLshort *v ) {
+	trWriteCMD( CMD_RASTERPOS4SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->RasterPos4sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trReadBuffer( GLenum mode ) {
+	trWriteCMD( CMD_READBUFFER );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ReadBuffer( mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) {
+	GLint pixelsize;
+
+	trWriteCMD( CMD_READPIXELS );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+   pixelsize = trGetPixelSize( format, type );
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ReadPixels( x, y, width, height, format, type, pixels  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) {
+	trWriteCMD( CMD_RECTD );
+	trWrited( x1 );
+	trWrited( y1 );
+	trWrited( x2 );
+	trWrited( y2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rectd( x1, y1, x2, y2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRectdv( const GLdouble *v1, const GLdouble *v2 ) {
+	trWriteCMD( CMD_RECTDV );
+	trWritePointer( (void *)v1 );
+	trFileFlush();
+	trWriteArrayd( 2, v1 );
+
+	trWritePointer( (void *)v2  );
+	trFileFlush();
+	trWriteArrayd( 2, v2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rectdv( v1, v2  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) {
+	trWriteCMD( CMD_RECTF );
+	trWritef( x1 );
+	trWritef( y1 );
+	trWritef( x2 );
+	trWritef( y2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rectf( x1, y1, x2, y2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRectfv( const GLfloat *v1, const GLfloat *v2 ) {
+	trWriteCMD( CMD_RECTFV );
+	trWritePointer( (void *)v1 );
+	trFileFlush();
+	trWriteArrayf( 2, v1 );
+
+	trWritePointer( (void *)v2  );
+	trFileFlush();
+	trWriteArrayf( 2, v2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rectfv( v1, v2  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRecti( GLint x1, GLint y1, GLint x2, GLint y2 ) {
+	trWriteCMD( CMD_RECTI );
+	trWritei( x1 );
+	trWritei( y1 );
+	trWritei( x2 );
+	trWritei( y2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Recti( x1, y1, x2, y2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRectiv( const GLint *v1, const GLint *v2 ) {
+	trWriteCMD( CMD_RECTIV );
+	trWritePointer( (void *)v1 );
+	trFileFlush();
+	trWriteArrayi( 2, v1 );
+
+	trWritePointer( (void *)v2  );
+	trFileFlush();
+	trWriteArrayi( 2, v2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rectiv( v1, v2  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) {
+	trWriteCMD( CMD_RECTS );
+	trWrites( x1 );
+	trWrites( y1 );
+	trWrites( x2 );
+	trWrites( y2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rects( x1, y1, x2, y2 );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRectsv( const GLshort *v1, const GLshort *v2 ) {
+	trWriteCMD( CMD_RECTSV );
+	trWritePointer( (void *)v1 );
+	trFileFlush();
+	trWriteArrays( 2, v1 );
+
+	trWritePointer( (void *)v2  );
+	trFileFlush();
+	trWriteArrays( 2, v2 );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rectsv( v1, v2  );
+		trError();
+	}
+}
+
+
+GLAPI GLint GLAPIENTRY trRenderMode( GLenum mode ) {
+	GLint retval;
+
+	trWriteCMD( CMD_RENDERMODE );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		retval = trGetDispatch()->RenderMode( mode );
+		trError();
+	} else {
+		retval = 0;
+	}
+
+	trWritei( retval );
+	return retval;
+}
+
+
+GLAPI void GLAPIENTRY trResetHistogram( GLenum target ) {
+	trWriteCMD( CMD_RESETHISTOGRAM );
+	trWriteEnum( target );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ResetHistogram( target );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trResetMinmax( GLenum target ) {
+	trWriteCMD( CMD_RESETMINMAX );
+	trWriteEnum( target );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ResetMinmax( target );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trResizeBuffersMESA( void ) {
+	trWriteCMD( CMD_RESIZEBUFFERSMESA );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ResizeBuffersMESA(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) {
+	trWriteCMD( CMD_ROTATED );
+	trWrited( angle );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rotated( angle, x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) {
+	trWriteCMD( CMD_ROTATEF );
+	trWritef( angle );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Rotatef( angle, x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trScaled( GLdouble x, GLdouble y, GLdouble z ) {
+	trWriteCMD( CMD_SCALED );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Scaled( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trScalef( GLfloat x, GLfloat y, GLfloat z ) {
+	trWriteCMD( CMD_SCALEF );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Scalef( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trScissor( GLint x, GLint y, GLsizei width, GLsizei height) {
+	trWriteCMD( CMD_SCISSOR );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Scissor( x, y, width, height );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trSelectBuffer( GLsizei size, GLuint *buffer ) {
+	trWriteCMD( CMD_SELECTBUFFER );
+	trWriteSizei( size );
+	trWritePointer( (void *)buffer  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->SelectBuffer( size, buffer  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column ) {
+	GLint pixelsize;
+
+	trWriteCMD( CMD_SEPARABLEFILTER2D );
+	trWriteEnum( target );
+	trWriteEnum( internalformat );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)row );
+	trFileFlush();
+	trWritePointer( (void *)column  );
+	trFileFlush();
+
+	pixelsize = trGetPixelSize( format, type );
+	trWriteTypeArray( type, width, pixelsize, 0, row );
+	trWriteTypeArray( type, height, pixelsize, 0, column );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->SeparableFilter2D( target, internalformat, width, height, format, type, row, column  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trShadeModel( GLenum mode ) {
+	trWriteCMD( CMD_SHADEMODEL );
+	trWriteEnum( mode );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->ShadeModel( mode );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trStencilFunc( GLenum func, GLint ref, GLuint mask ) {
+	trWriteCMD( CMD_STENCILFUNC );
+	trWriteEnum( func );
+	trWritei( ref );
+	trWriteui( mask );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->StencilFunc( func, ref, mask );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trStencilMask( GLuint mask ) {
+	trWriteCMD( CMD_STENCILMASK );
+	trWriteui( mask );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->StencilMask( mask );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) {
+	trWriteCMD( CMD_STENCILOP );
+	trWriteEnum( fail );
+	trWriteEnum( zfail );
+	trWriteEnum( zpass );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->StencilOp( fail, zfail, zpass );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1d( GLdouble s ) {
+	trWriteCMD( CMD_TEXCOORD1D );
+	trWrited( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1d( s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1dv( const GLdouble *v ) {
+	trWriteCMD( CMD_TEXCOORD1DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWrited( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1f( GLfloat s ) {
+	trWriteCMD( CMD_TEXCOORD1F );
+	trWritef( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1f( s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1fv( const GLfloat *v ) {
+	trWriteCMD( CMD_TEXCOORD1FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWritef( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1i( GLint s ) {
+	trWriteCMD( CMD_TEXCOORD1I );
+	trWritei( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1i( s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1iv( const GLint *v ) {
+	trWriteCMD( CMD_TEXCOORD1IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWritei( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1s( GLshort s ) {
+	trWriteCMD( CMD_TEXCOORD1S );
+	trWrites( s );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1s( s );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord1sv( const GLshort *v ) {
+	trWriteCMD( CMD_TEXCOORD1SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWrites( v[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord1sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2d( GLdouble s, GLdouble t ) {
+	trWriteCMD( CMD_TEXCOORD2D );
+	trWrited( s );
+	trWrited( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2d( s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2dv( const GLdouble *v ) {
+	trWriteCMD( CMD_TEXCOORD2DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2f( GLfloat s, GLfloat t ) {
+	trWriteCMD( CMD_TEXCOORD2F );
+	trWritef( s );
+	trWritef( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2f( s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2fv( const GLfloat *v ) {
+	trWriteCMD( CMD_TEXCOORD2FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2i( GLint s, GLint t ) {
+	trWriteCMD( CMD_TEXCOORD2I );
+	trWritei( s );
+	trWritei( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2i( s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2iv( const GLint *v ) {
+	trWriteCMD( CMD_TEXCOORD2IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2s( GLshort s, GLshort t ) {
+	trWriteCMD( CMD_TEXCOORD2S );
+	trWrites( s );
+	trWrites( t );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2s( s, t );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord2sv( const GLshort *v ) {
+	trWriteCMD( CMD_TEXCOORD2SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord2sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3d( GLdouble s, GLdouble t, GLdouble r ) {
+	trWriteCMD( CMD_TEXCOORD3D );
+	trWrited( s );
+	trWrited( t );
+	trWrited( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3d( s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3dv( const GLdouble *v ) {
+	trWriteCMD( CMD_TEXCOORD3DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3f( GLfloat s, GLfloat t, GLfloat r ) {
+	trWriteCMD( CMD_TEXCOORD3F );
+	trWritef( s );
+	trWritef( t );
+	trWritef( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3f( s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3fv( const GLfloat *v ) {
+	trWriteCMD( CMD_TEXCOORD3FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3i( GLint s, GLint t, GLint r ) {
+	trWriteCMD( CMD_TEXCOORD3I );
+	trWritei( s );
+	trWritei( t );
+	trWritei( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3i( s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3iv( const GLint *v ) {
+	trWriteCMD( CMD_TEXCOORD3IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3s( GLshort s, GLshort t, GLshort r ) {
+	trWriteCMD( CMD_TEXCOORD3S );
+	trWrites( s );
+	trWrites( t );
+	trWrites( r );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3s( s, t, r );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord3sv( const GLshort *v ) {
+	trWriteCMD( CMD_TEXCOORD3SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord3sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
+	trWriteCMD( CMD_TEXCOORD4D );
+	trWrited( s );
+	trWrited( t );
+	trWrited( r );
+	trWrited( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4d( s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4dv( const GLdouble *v ) {
+	trWriteCMD( CMD_TEXCOORD4DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
+	trWriteCMD( CMD_TEXCOORD4F );
+	trWritef( s );
+	trWritef( t );
+	trWritef( r );
+	trWritef( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4f( s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4fv( const GLfloat *v ) {
+	trWriteCMD( CMD_TEXCOORD4FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4i( GLint s, GLint t, GLint r, GLint q ) {
+	trWriteCMD( CMD_TEXCOORD4I );
+	trWritei( s );
+	trWritei( t );
+	trWritei( r );
+	trWritei( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4i( s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4iv( const GLint *v ) {
+	trWriteCMD( CMD_TEXCOORD4IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q ) {
+	trWriteCMD( CMD_TEXCOORD4S );
+	trWrites( s );
+	trWrites( t );
+	trWrites( r );
+	trWrites( q );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4s( s, t, r, q );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoord4sv( const GLshort *v ) {
+	trWriteCMD( CMD_TEXCOORD4SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoord4sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */
+	trWriteCMD( CMD_TEXCOORDPOINTEREXT );
+	trWritei( size );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWriteSizei( count );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexCoordPointerEXT( size, type, stride, count, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */
+	trace_context_t * tctx;
+
+	trWriteCMD( CMD_TEXCOORDPOINTER );
+	trWritei( size );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( tctx->doExec ) {
+		trGetDispatch()->TexCoordPointer( size, type, stride, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexEnvf( GLenum target, GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_TEXENVF );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexEnvf( target, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexEnvfv( GLenum target, GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_TEXENVFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_TEXTURE_ENV_MODE:
+			trWritef( params[0] );
+			break;
+		case GL_TEXTURE_ENV_COLOR:
+			trWriteArrayf( 4, params );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexEnvfv( target, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexEnvi( GLenum target, GLenum pname, GLint param ) {
+	trWriteCMD( CMD_TEXENVI );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexEnvi( target, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexEnviv( GLenum target, GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_TEXENVIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_TEXTURE_ENV_MODE:
+			trWritei( params[0] );
+			break;
+		case GL_TEXTURE_ENV_COLOR:
+			trWriteArrayi( 4, params );
+			break;
+		default:
+			/* The 2nd pass should catch this */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexEnviv( target, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexGend( GLenum coord, GLenum pname, GLdouble param ) {
+	trWriteCMD( CMD_TEXGEND );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWrited( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexGend( coord, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexGendv( GLenum coord, GLenum pname, const GLdouble *params ) {
+	trWriteCMD( CMD_TEXGENDV );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_TEXTURE_GEN_MODE:
+			trWrited( params[0] );
+			break;
+
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			trWriteArrayd( 4, params );
+			break;
+
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexGendv( coord, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexGenf( GLenum coord, GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_TEXGENF );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexGenf( coord, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexGenfv( GLenum coord, GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_TEXGENFV );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_TEXTURE_GEN_MODE:
+			trWritef( params[0] );
+			break;
+
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			trWriteArrayf( 4, params );
+			break;
+
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexGenfv( coord, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexGeni( GLenum coord, GLenum pname, GLint param ) {
+	trWriteCMD( CMD_TEXGENI );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexGeni( coord, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexGeniv( GLenum coord, GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_TEXGENIV );
+	trWriteEnum( coord );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+
+	switch( pname ) {
+		case GL_TEXTURE_GEN_MODE:
+			trWritei( params[0] );
+			break;
+
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			trWriteArrayi( 4, params );
+			break;
+
+		default:
+			/* The 2nd pass should catch this. */
+			break;
+	}
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexGeniv( coord, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexImage1D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */
+   GLint pixelsize;
+
+	trWriteCMD( CMD_TEXIMAGE1D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( internalFormat );
+	trWriteSizei( width );
+	trWritei( border );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexImage1D( target, level, internalFormat, width, border, format, type, pixels  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexImage2D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */
+   GLint pixelsize;
+
+	trWriteCMD( CMD_TEXIMAGE2D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( internalFormat );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWritei( border );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexImage2D( target, level, internalFormat, width, height, border, format, type, pixels  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trTexImage3DEXT( GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */
+
+	trWriteCMD( CMD_TEXIMAGE3DEXT );
+	trWriteEnum( target );
+	trWritei( level );
+	trWriteEnum( internalFormat );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteSizei( depth );
+	trWritei( border );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+   /* Pixels isn't touched if target is GL_PROXY_TEXTURE_3D */
+   if( target != GL_PROXY_TEXTURE_3D ) {
+      pixelsize = trGetPixelSize( format, type );
+      trWritePixelArray( GL_FALSE, type, width, height, depth, pixelsize, pixels );
+   }
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexImage3DEXT( target, level, internalFormat, width, height, depth, border, format, type, pixels  );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trTexImage3D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */
+   GLint pixelsize;
+
+	trWriteCMD( CMD_TEXIMAGE3D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( internalFormat );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteSizei( depth );
+	trWritei( border );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexImage3D( target, level, internalFormat, width, height, depth, border, format, type, pixels  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexParameterf( GLenum target, GLenum pname, GLfloat param ) {
+	trWriteCMD( CMD_TEXPARAMETERF );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritef( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexParameterf( target, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexParameterfv( GLenum target, GLenum pname, const GLfloat *params ) {
+	trWriteCMD( CMD_TEXPARAMETERFV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+  	trWritef( params[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexParameterfv( target, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexParameteri( GLenum target, GLenum pname, GLint param ) {
+	trWriteCMD( CMD_TEXPARAMETERI );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritei( param );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexParameteri( target, pname, param );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexParameteriv( GLenum target, GLenum pname, const GLint *params ) {
+	trWriteCMD( CMD_TEXPARAMETERIV );
+	trWriteEnum( target );
+	trWriteEnum( pname );
+	trWritePointer( (void *)params  );
+	trFileFlush();
+  	trWritei( params[0] );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexParameteriv( target, pname, params  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */
+   GLint pixelsize;
+
+	trWriteCMD( CMD_TEXSUBIMAGE1D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWriteSizei( width );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexSubImage1D( target, level, xoffset, width, format, type, pixels  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) { /* TODO */
+   GLint pixelsize;
+
+	trWriteCMD( CMD_TEXSUBIMAGE2D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWritei( yoffset );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels  );
+		trError();
+	}
+}
+
+
+#if 0
+// Not in MESAs dispatch table
+GLAPI void GLAPIENTRY trTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { /* TODO */
+   GLint pixelsize;
+
+	trWriteCMD( CMD_TEXSUBIMAGE3DEXT );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWritei( yoffset );
+	trWritei( zoffset );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteSizei( depth );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels );
+	trFileFlush();
+
+   /* Pixels isn't touched if target is GL_PROXY_TEXTURE_3D */
+   if( target != GL_PROXY_TEXTURE_3D ) {
+      pixelsize = trGetPixelSize( format, type );
+      trWritePixelArray( GL_FALSE, type, width, height, depth, pixelsize, pixels );
+   }
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
+		trError();
+	}
+}
+#endif
+
+
+GLAPI void GLAPIENTRY trTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { /* TODO */
+   GLint pixelsize;
+
+	trWriteCMD( CMD_TEXSUBIMAGE3D );
+	trWriteEnum( target );
+	trWritei( level );
+	trWritei( xoffset );
+	trWritei( yoffset );
+	trWritei( zoffset );
+	trWriteSizei( width );
+	trWriteSizei( height );
+	trWriteSizei( depth );
+	trWriteEnum( format );
+	trWriteEnum( type );
+	trWritePointer( (void *)pixels );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->TexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTranslated( GLdouble x, GLdouble y, GLdouble z ) {
+	trWriteCMD( CMD_TRANSLATED );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Translated( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trTranslatef( GLfloat x, GLfloat y, GLfloat z ) {
+	trWriteCMD( CMD_TRANSLATEF );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Translatef( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trUnlockArraysEXT( void ) {
+	trWriteCMD( CMD_UNLOCKARRAYSEXT );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->UnlockArraysEXT(  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2d( GLdouble x, GLdouble y ) {
+	trWriteCMD( CMD_VERTEX2D );
+	trWrited( x );
+	trWrited( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2d( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2dv( const GLdouble *v ) {
+	trWriteCMD( CMD_VERTEX2DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2f( GLfloat x, GLfloat y ) {
+	trWriteCMD( CMD_VERTEX2F );
+	trWritef( x );
+	trWritef( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2f( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2fv( const GLfloat *v ) {
+	trWriteCMD( CMD_VERTEX2FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2i( GLint x, GLint y ) {
+	trWriteCMD( CMD_VERTEX2I );
+	trWritei( x );
+	trWritei( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2i( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2iv( const GLint *v ) {
+	trWriteCMD( CMD_VERTEX2IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2s( GLshort x, GLshort y ) {
+	trWriteCMD( CMD_VERTEX2S );
+	trWrites( x );
+	trWrites( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2s( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex2sv( const GLshort *v ) {
+	trWriteCMD( CMD_VERTEX2SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 2, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex2sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3d( GLdouble x, GLdouble y, GLdouble z ) {
+	trWriteCMD( CMD_VERTEX3D );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3d( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3dv( const GLdouble *v ) {
+	trWriteCMD( CMD_VERTEX3DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3f( GLfloat x, GLfloat y, GLfloat z ) {
+	trWriteCMD( CMD_VERTEX3F );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3f( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3fv( const GLfloat *v ) {
+	trWriteCMD( CMD_VERTEX3FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3i( GLint x, GLint y, GLint z ) {
+	trWriteCMD( CMD_VERTEX3I );
+	trWritei( x );
+	trWritei( y );
+	trWritei( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3i( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3iv( const GLint *v ) {
+	trWriteCMD( CMD_VERTEX3IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3s( GLshort x, GLshort y, GLshort z ) {
+	trWriteCMD( CMD_VERTEX3S );
+	trWrites( x );
+	trWrites( y );
+	trWrites( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3s( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex3sv( const GLshort *v ) {
+	trWriteCMD( CMD_VERTEX3SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 3, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex3sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+	trWriteCMD( CMD_VERTEX4D );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+	trWrited( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4d( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4dv( const GLdouble *v ) {
+	trWriteCMD( CMD_VERTEX4DV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayd( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4dv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+	trWriteCMD( CMD_VERTEX4F );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+	trWritef( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4f( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4fv( const GLfloat *v ) {
+	trWriteCMD( CMD_VERTEX4FV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayf( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4fv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4i( GLint x, GLint y, GLint z, GLint w ) {
+	trWriteCMD( CMD_VERTEX4I );
+	trWritei( x );
+	trWritei( y );
+	trWritei( z );
+	trWritei( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4i( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4iv( const GLint *v ) {
+	trWriteCMD( CMD_VERTEX4IV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrayi( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4iv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
+	trWriteCMD( CMD_VERTEX4S );
+	trWrites( x );
+	trWrites( y );
+	trWrites( z );
+	trWrites( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4s( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertex4sv( const GLshort *v ) {
+	trWriteCMD( CMD_VERTEX4SV );
+	trWritePointer( (void *)v  );
+	trFileFlush();
+	trWriteArrays( 4, v );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Vertex4sv( v  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *ptr ) { /* TODO */
+	trWriteCMD( CMD_VERTEXPOINTEREXT );
+	trWritei( size );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWriteSizei( count );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->VertexPointerEXT( size, type, stride, count, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) { /* TODO */
+	trWriteCMD( CMD_VERTEXPOINTER );
+	trWritei( size );
+	trWriteEnum( type );
+	trWriteSizei( stride );
+	trWritePointer( (void *)ptr  );
+	trFileFlush();
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->VertexPointer( size, type, stride, ptr  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trViewport( GLint x, GLint y, GLsizei width, GLsizei height ) {
+	trWriteCMD( CMD_VIEWPORT );
+	trWritei( x );
+	trWritei( y );
+	trWriteSizei( width );
+	trWriteSizei( height );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->Viewport( x, y, width, height );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2dMESA( GLdouble x, GLdouble y ) {
+	trWriteCMD( CMD_WINDOWPOS2DMESA );
+	trWrited( x );
+	trWrited( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2dMESA( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2dvMESA( const GLdouble *p ) {
+	trWriteCMD( CMD_WINDOWPOS2DVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayd( 2, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2dvMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2fMESA( GLfloat x, GLfloat y ) {
+	trWriteCMD( CMD_WINDOWPOS2FMESA );
+	trWritef( x );
+	trWritef( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2fMESA( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2fvMESA( const GLfloat *p ) {
+	trWriteCMD( CMD_WINDOWPOS2FVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayf( 2, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2fvMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2iMESA( GLint x, GLint y ) {
+	trWriteCMD( CMD_WINDOWPOS2IMESA );
+	trWritei( x );
+	trWritei( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2iMESA( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2ivMESA( const GLint *p ) {
+	trWriteCMD( CMD_WINDOWPOS2IVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayi( 2, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2ivMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2sMESA( GLshort x, GLshort y ) {
+	trWriteCMD( CMD_WINDOWPOS2SMESA );
+	trWrites( x );
+	trWrites( y );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2sMESA( x, y );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos2svMESA( const GLshort *p ) {
+	trWriteCMD( CMD_WINDOWPOS2SVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrays( 2, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos2svMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z ) {
+	trWriteCMD( CMD_WINDOWPOS3DMESA );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3dMESA( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3dvMESA( const GLdouble *p ) {
+	trWriteCMD( CMD_WINDOWPOS3DVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayd( 3, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3dvMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z ) {
+	trWriteCMD( CMD_WINDOWPOS3FMESA );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3fMESA( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3fvMESA( const GLfloat *p ) {
+	trWriteCMD( CMD_WINDOWPOS3FVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayf( 3, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3fvMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3iMESA( GLint x, GLint y, GLint z ) {
+	trWriteCMD( CMD_WINDOWPOS3IMESA );
+	trWritei( x );
+	trWritei( y );
+	trWritei( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3iMESA( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3ivMESA( const GLint *p ) {
+	trWriteCMD( CMD_WINDOWPOS3IVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayi( 3, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3ivMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3sMESA( GLshort x, GLshort y, GLshort z ) {
+	trWriteCMD( CMD_WINDOWPOS3SMESA );
+	trWrites( x );
+	trWrites( y );
+	trWrites( z );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3sMESA( x, y, z );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos3svMESA( const GLshort *p ) {
+	trWriteCMD( CMD_WINDOWPOS3SVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrays( 3, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos3svMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
+	trWriteCMD( CMD_WINDOWPOS4DMESA );
+	trWrited( x );
+	trWrited( y );
+	trWrited( z );
+	trWrited( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4dMESA( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4dvMESA( const GLdouble *p ) {
+	trWriteCMD( CMD_WINDOWPOS4DVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayd( 4, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4dvMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+	trWriteCMD( CMD_WINDOWPOS4FMESA );
+	trWritef( x );
+	trWritef( y );
+	trWritef( z );
+	trWritef( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4fMESA( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4fvMESA( const GLfloat *p ) {
+	trWriteCMD( CMD_WINDOWPOS4FVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayf( 4, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4fvMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w ) {
+	trWriteCMD( CMD_WINDOWPOS4IMESA );
+	trWritei( x );
+	trWritei( y );
+	trWritei( z );
+	trWritei( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4iMESA( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4ivMESA( const GLint *p ) {
+	trWriteCMD( CMD_WINDOWPOS4IVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrayi( 4, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4ivMESA( p  );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w ) {
+	trWriteCMD( CMD_WINDOWPOS4SMESA );
+	trWrites( x );
+	trWrites( y );
+	trWrites( z );
+	trWrites( w );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4sMESA( x, y, z, w );
+		trError();
+	}
+}
+
+
+GLAPI void GLAPIENTRY trWindowPos4svMESA( const GLshort *p ) {
+	trWriteCMD( CMD_WINDOWPOS4SVMESA );
+	trWritePointer( (void *)p  );
+	trFileFlush();
+	trWriteArrays( 4, p );
+
+	if( trCtx()->doExec ) {
+		trGetDispatch()->WindowPos4svMESA( p  );
+		trError();
+	}
+}
+
+
+void trInitDispatch( struct _glapi_table* dispatch ) {
+	
+	/* assert(dispatch); */
+	if (!dispatch)
+		return;
+
+	memset(dispatch,0,sizeof(struct _glapi_table));
+
+	dispatch->NewList =                      trNewList;                    /* 0 */
+	dispatch->EndList =                      trEndList;                    /* 1 */
+	dispatch->CallList =                     trCallList;                   /* 2 */
+	dispatch->CallLists =                    trCallLists;                  /* 3 */
+	dispatch->DeleteLists =                  trDeleteLists;                /* 4 */
+	dispatch->GenLists =                     trGenLists;                   /* 5 */
+	dispatch->ListBase =                     trListBase;                   /* 6 */
+	dispatch->Begin =                        trBegin;                      /* 7 */
+	dispatch->Bitmap =                       trBitmap;                     /* 8 */
+	dispatch->Color3b =                      trColor3b;                    /* 9 */
+	dispatch->Color3bv =                     trColor3bv;                  /* 10 */
+	dispatch->Color3d =                      trColor3d;                   /* 11 */
+	dispatch->Color3dv =                     trColor3dv;                  /* 12 */
+	dispatch->Color3f =                      trColor3f;                   /* 13 */
+	dispatch->Color3fv =                     trColor3fv;                  /* 14 */
+	dispatch->Color3i =                      trColor3i;                   /* 15 */
+	dispatch->Color3iv =                     trColor3iv;                  /* 16 */
+	dispatch->Color3s =                      trColor3s;                   /* 17 */
+	dispatch->Color3sv =                     trColor3sv;                  /* 18 */
+	dispatch->Color3ub =                     trColor3ub;                  /* 19 */
+	dispatch->Color3ubv =                    trColor3ubv;                 /* 20 */
+	dispatch->Color3ui =                     trColor3ui;                  /* 21 */
+	dispatch->Color3uiv =                    trColor3uiv;                 /* 22 */
+	dispatch->Color3us =                     trColor3us;                  /* 23 */
+	dispatch->Color3usv =                    trColor3usv;                 /* 24 */
+	dispatch->Color4b =                      trColor4b;                   /* 25 */
+	dispatch->Color4bv =                     trColor4bv;                  /* 26 */
+	dispatch->Color4d =                      trColor4d;                   /* 27 */
+	dispatch->Color4dv =                     trColor4dv;                  /* 28 */
+	dispatch->Color4f =                      trColor4f;                   /* 29 */
+	dispatch->Color4fv =                     trColor4fv;                  /* 30 */
+	dispatch->Color4i =                      trColor4i;                   /* 31 */
+	dispatch->Color4iv =                     trColor4iv;                  /* 32 */
+	dispatch->Color4s =                      trColor4s;                   /* 33 */
+	dispatch->Color4sv =                     trColor4sv;                  /* 34 */
+	dispatch->Color4ub =                     trColor4ub;                  /* 35 */
+	dispatch->Color4ubv =                    trColor4ubv;                 /* 36 */
+	dispatch->Color4ui =                     trColor4ui;                  /* 37 */
+	dispatch->Color4uiv =                    trColor4uiv;                 /* 38 */
+	dispatch->Color4us =                     trColor4us;                  /* 39 */
+	dispatch->Color4usv =                    trColor4usv;                 /* 40 */
+	dispatch->EdgeFlag =                     trEdgeFlag;                  /* 41 */
+	dispatch->EdgeFlagv =                    trEdgeFlagv;                 /* 42 */
+	dispatch->End =                          trEnd;                       /* 43 */
+	dispatch->Indexd =                       trIndexd;                    /* 44 */
+	dispatch->Indexdv =                      trIndexdv;                   /* 45 */
+	dispatch->Indexf =                       trIndexf;                    /* 46 */
+	dispatch->Indexfv =                      trIndexfv;                   /* 47 */
+	dispatch->Indexi =                       trIndexi;                    /* 48 */
+	dispatch->Indexiv =                      trIndexiv;                   /* 49 */
+	dispatch->Indexs =                       trIndexs;                    /* 50 */
+	dispatch->Indexsv =                      trIndexsv;                   /* 51 */
+	dispatch->Normal3b =                     trNormal3b;                  /* 52 */
+	dispatch->Normal3bv =                    trNormal3bv;                 /* 53 */
+	dispatch->Normal3d =                     trNormal3d;                  /* 54 */
+	dispatch->Normal3dv =                    trNormal3dv;                 /* 55 */
+	dispatch->Normal3f =                     trNormal3f;                  /* 56 */
+	dispatch->Normal3fv =                    trNormal3fv;                 /* 57 */
+	dispatch->Normal3i =                     trNormal3i;                  /* 58 */
+	dispatch->Normal3iv =                    trNormal3iv;                 /* 59 */
+	dispatch->Normal3s =                     trNormal3s;                  /* 60 */
+	dispatch->Normal3sv =                    trNormal3sv;                 /* 61 */
+	dispatch->RasterPos2d =                  trRasterPos2d;               /* 62 */
+	dispatch->RasterPos2dv =                 trRasterPos2dv;              /* 63 */
+	dispatch->RasterPos2f =                  trRasterPos2f;               /* 64 */
+	dispatch->RasterPos2fv =                 trRasterPos2fv;              /* 65 */
+	dispatch->RasterPos2i =                  trRasterPos2i;               /* 66 */
+	dispatch->RasterPos2iv =                 trRasterPos2iv;              /* 67 */
+	dispatch->RasterPos2s =                  trRasterPos2s;               /* 68 */
+	dispatch->RasterPos2sv =                 trRasterPos2sv;              /* 69 */
+	dispatch->RasterPos3d =                  trRasterPos3d;               /* 70 */
+	dispatch->RasterPos3dv =                 trRasterPos3dv;              /* 71 */
+	dispatch->RasterPos3f =                  trRasterPos3f;               /* 72 */
+	dispatch->RasterPos3fv =                 trRasterPos3fv;              /* 73 */
+	dispatch->RasterPos3i =                  trRasterPos3i;               /* 74 */
+	dispatch->RasterPos3iv =                 trRasterPos3iv;              /* 75 */
+	dispatch->RasterPos3s =                  trRasterPos3s;               /* 76 */
+	dispatch->RasterPos3sv =                 trRasterPos3sv;              /* 77 */
+	dispatch->RasterPos4d =                  trRasterPos4d;               /* 78 */
+	dispatch->RasterPos4dv =                 trRasterPos4dv;              /* 79 */
+	dispatch->RasterPos4f =                  trRasterPos4f;               /* 80 */
+	dispatch->RasterPos4fv =                 trRasterPos4fv;              /* 81 */
+	dispatch->RasterPos4i =                  trRasterPos4i;               /* 82 */
+	dispatch->RasterPos4iv =                 trRasterPos4iv;              /* 83 */
+	dispatch->RasterPos4s =                  trRasterPos4s;               /* 84 */
+	dispatch->RasterPos4sv =                 trRasterPos4sv;              /* 85 */
+	dispatch->Rectd =                        trRectd;                     /* 86 */
+	dispatch->Rectdv =                       trRectdv;                    /* 87 */
+	dispatch->Rectf =                        trRectf;                     /* 88 */
+	dispatch->Rectfv =                       trRectfv;                    /* 89 */
+	dispatch->Recti =                        trRecti;                     /* 90 */
+	dispatch->Rectiv =                       trRectiv;                    /* 91 */
+	dispatch->Rects =                        trRects;                     /* 92 */
+	dispatch->Rectsv =                       trRectsv;                    /* 93 */
+	dispatch->TexCoord1d =                   trTexCoord1d;                /* 94 */
+	dispatch->TexCoord1dv =                  trTexCoord1dv;               /* 95 */
+	dispatch->TexCoord1f =                   trTexCoord1f;                /* 96 */
+	dispatch->TexCoord1fv =                  trTexCoord1fv;               /* 97 */
+	dispatch->TexCoord1i =                   trTexCoord1i;                /* 98 */
+	dispatch->TexCoord1iv =                  trTexCoord1iv;               /* 99 */
+	dispatch->TexCoord1s =                   trTexCoord1s;               /* 100 */
+	dispatch->TexCoord1sv =                  trTexCoord1sv;              /* 101 */
+	dispatch->TexCoord2d =                   trTexCoord2d;               /* 102 */
+	dispatch->TexCoord2dv =                  trTexCoord2dv;              /* 103 */
+	dispatch->TexCoord2f =                   trTexCoord2f;               /* 104 */
+	dispatch->TexCoord2fv =                  trTexCoord2fv;              /* 105 */
+	dispatch->TexCoord2i =                   trTexCoord2i;               /* 106 */
+	dispatch->TexCoord2iv =                  trTexCoord2iv;              /* 107 */
+	dispatch->TexCoord2s =                   trTexCoord2s;               /* 108 */
+	dispatch->TexCoord2sv =                  trTexCoord2sv;              /* 109 */
+	dispatch->TexCoord3d =                   trTexCoord3d;               /* 110 */
+	dispatch->TexCoord3dv =                  trTexCoord3dv;              /* 111 */
+	dispatch->TexCoord3f =                   trTexCoord3f;               /* 112 */
+	dispatch->TexCoord3fv =                  trTexCoord3fv;              /* 113 */
+	dispatch->TexCoord3i =                   trTexCoord3i;               /* 114 */
+	dispatch->TexCoord3iv =                  trTexCoord3iv;              /* 115 */
+	dispatch->TexCoord3s =                   trTexCoord3s;               /* 116 */
+	dispatch->TexCoord3sv =                  trTexCoord3sv;              /* 117 */
+	dispatch->TexCoord4d =                   trTexCoord4d;               /* 118 */
+	dispatch->TexCoord4dv =                  trTexCoord4dv;              /* 119 */
+	dispatch->TexCoord4f =                   trTexCoord4f;               /* 120 */
+	dispatch->TexCoord4fv =                  trTexCoord4fv;              /* 121 */
+	dispatch->TexCoord4i =                   trTexCoord4i;               /* 122 */
+	dispatch->TexCoord4iv =                  trTexCoord4iv;              /* 123 */
+	dispatch->TexCoord4s =                   trTexCoord4s;               /* 124 */
+	dispatch->TexCoord4sv =                  trTexCoord4sv;              /* 125 */
+	dispatch->Vertex2d =                     trVertex2d;                 /* 126 */
+	dispatch->Vertex2dv =                    trVertex2dv;                /* 127 */
+	dispatch->Vertex2f =                     trVertex2f;                 /* 128 */
+	dispatch->Vertex2fv =                    trVertex2fv;                /* 129 */
+	dispatch->Vertex2i =                     trVertex2i;                 /* 130 */
+	dispatch->Vertex2iv =                    trVertex2iv;                /* 131 */
+	dispatch->Vertex2s =                     trVertex2s;                 /* 132 */
+	dispatch->Vertex2sv =                    trVertex2sv;                /* 133 */
+	dispatch->Vertex3d =                     trVertex3d;                 /* 134 */
+	dispatch->Vertex3dv =                    trVertex3dv;                /* 135 */
+	dispatch->Vertex3f =                     trVertex3f;                 /* 136 */
+	dispatch->Vertex3fv =                    trVertex3fv;                /* 137 */
+	dispatch->Vertex3i =                     trVertex3i;                 /* 138 */
+	dispatch->Vertex3iv =                    trVertex3iv;                /* 139 */
+	dispatch->Vertex3s =                     trVertex3s;                 /* 140 */
+	dispatch->Vertex3sv =                    trVertex3sv;                /* 141 */
+	dispatch->Vertex4d =                     trVertex4d;                 /* 142 */
+	dispatch->Vertex4dv =                    trVertex4dv;                /* 143 */
+	dispatch->Vertex4f =                     trVertex4f;                 /* 144 */
+	dispatch->Vertex4fv =                    trVertex4fv;                /* 145 */
+	dispatch->Vertex4i =                     trVertex4i;                 /* 146 */
+	dispatch->Vertex4iv =                    trVertex4iv;                /* 147 */
+	dispatch->Vertex4s =                     trVertex4s;                 /* 148 */
+	dispatch->Vertex4sv =                    trVertex4sv;                /* 149 */
+	dispatch->ClipPlane =                    trClipPlane;                /* 150 */
+	dispatch->ColorMaterial =                trColorMaterial;            /* 151 */
+	dispatch->CullFace =                     trCullFace;                 /* 152 */
+	dispatch->Fogf =                         trFogf;                     /* 153 */
+	dispatch->Fogfv =                        trFogfv;                    /* 154 */
+	dispatch->Fogi =                         trFogi;                     /* 155 */
+	dispatch->Fogiv =                        trFogiv;                    /* 156 */
+	dispatch->FrontFace =                    trFrontFace;                /* 157 */
+	dispatch->Hint =                         trHint;                     /* 158 */
+	dispatch->Lightf =                       trLightf;                   /* 159 */
+	dispatch->Lightfv =                      trLightfv;                  /* 160 */
+	dispatch->Lighti =                       trLighti;                   /* 161 */
+	dispatch->Lightiv =                      trLightiv;                  /* 162 */
+	dispatch->LightModelf =                  trLightModelf;              /* 163 */
+	dispatch->LightModelfv =                 trLightModelfv;             /* 164 */
+	dispatch->LightModeli =                  trLightModeli;              /* 165 */
+	dispatch->LightModeliv =                 trLightModeliv;             /* 166 */
+	dispatch->LineStipple =                  trLineStipple;              /* 167 */
+	dispatch->LineWidth =                    trLineWidth;                /* 168 */
+	dispatch->Materialf =                    trMaterialf;                /* 169 */
+	dispatch->Materialfv =                   trMaterialfv;               /* 170 */
+	dispatch->Materiali =                    trMateriali;                /* 171 */
+	dispatch->Materialiv =                   trMaterialiv;               /* 172 */
+	dispatch->PointSize =                    trPointSize;                /* 173 */
+	dispatch->PolygonMode =                  trPolygonMode;              /* 174 */
+	dispatch->PolygonStipple =               trPolygonStipple;           /* 175 */
+	dispatch->Scissor =                      trScissor;                  /* 176 */
+	dispatch->ShadeModel =                   trShadeModel;               /* 177 */
+	dispatch->TexParameterf =                trTexParameterf;            /* 178 */
+	dispatch->TexParameterfv =               trTexParameterfv;           /* 179 */
+	dispatch->TexParameteri =                trTexParameteri;            /* 180 */
+	dispatch->TexParameteriv =               trTexParameteriv;           /* 181 */
+	dispatch->TexImage1D =                   trTexImage1D;               /* 182 */
+	dispatch->TexImage2D =                   trTexImage2D;               /* 183 */
+	dispatch->TexEnvf =                      trTexEnvf;                  /* 184 */
+	dispatch->TexEnvfv =                     trTexEnvfv;                 /* 185 */
+	dispatch->TexEnvi =                      trTexEnvi;                  /* 186 */
+	dispatch->TexEnviv =                     trTexEnviv;                 /* 187 */
+	dispatch->TexGend =                      trTexGend;                  /* 188 */
+	dispatch->TexGendv =                     trTexGendv;                 /* 189 */
+	dispatch->TexGenf =                      trTexGenf;                  /* 190 */
+	dispatch->TexGenfv =                     trTexGenfv;                 /* 191 */
+	dispatch->TexGeni =                      trTexGeni;                  /* 192 */
+	dispatch->TexGeniv =                     trTexGeniv;                 /* 193 */
+	dispatch->FeedbackBuffer =               trFeedbackBuffer;           /* 194 */
+	dispatch->SelectBuffer =                 trSelectBuffer;             /* 195 */
+	dispatch->RenderMode =                   trRenderMode;               /* 196 */
+	dispatch->InitNames =                    trInitNames;                /* 197 */
+	dispatch->LoadName =                     trLoadName;                 /* 198 */
+	dispatch->PassThrough =                  trPassThrough;              /* 199 */
+	dispatch->PopName =                      trPopName;                  /* 200 */
+	dispatch->PushName =                     trPushName;                 /* 201 */
+	dispatch->DrawBuffer =                   trDrawBuffer;               /* 202 */
+	dispatch->Clear =                        trClear;                    /* 203 */
+	dispatch->ClearAccum =                   trClearAccum;               /* 204 */
+	dispatch->ClearIndex =                   trClearIndex;               /* 205 */
+	dispatch->ClearColor =                   trClearColor;               /* 206 */
+	dispatch->ClearStencil =                 trClearStencil;             /* 207 */
+	dispatch->ClearDepth =                   trClearDepth;               /* 208 */
+	dispatch->StencilMask =                  trStencilMask;              /* 209 */
+	dispatch->ColorMask =                    trColorMask;                /* 210 */
+	dispatch->DepthMask =                    trDepthMask;                /* 211 */
+	dispatch->IndexMask =                    trIndexMask;                /* 212 */
+	dispatch->Accum =                        trAccum;                    /* 213 */
+	dispatch->Disable =                      trDisable;                  /* 214 */
+	dispatch->Enable =                       trEnable;                   /* 215 */
+	dispatch->Finish =                       trFinish;                   /* 216 */
+	dispatch->Flush =                        trFlush;                    /* 217 */
+	dispatch->PopAttrib =                    trPopAttrib;                /* 218 */
+	dispatch->PushAttrib =                   trPushAttrib;               /* 219 */
+	dispatch->Map1d =                        trMap1d;                    /* 220 */
+	dispatch->Map1f =                        trMap1f;                    /* 221 */
+	dispatch->Map2d =                        trMap2d;                    /* 222 */
+	dispatch->Map2f =                        trMap2f;                    /* 223 */
+	dispatch->MapGrid1d =                    trMapGrid1d;                /* 224 */
+	dispatch->MapGrid1f =                    trMapGrid1f;                /* 225 */
+	dispatch->MapGrid2d =                    trMapGrid2d;                /* 226 */
+	dispatch->MapGrid2f =                    trMapGrid2f;                /* 227 */
+	dispatch->EvalCoord1d =                  trEvalCoord1d;              /* 228 */
+	dispatch->EvalCoord1dv =                 trEvalCoord1dv;             /* 229 */
+	dispatch->EvalCoord1f =                  trEvalCoord1f;              /* 230 */
+	dispatch->EvalCoord1fv =                 trEvalCoord1fv;             /* 231 */
+	dispatch->EvalCoord2d =                  trEvalCoord2d;              /* 232 */
+	dispatch->EvalCoord2dv =                 trEvalCoord2dv;             /* 233 */
+	dispatch->EvalCoord2f =                  trEvalCoord2f;              /* 234 */
+	dispatch->EvalCoord2fv =                 trEvalCoord2fv;             /* 235 */
+	dispatch->EvalMesh1 =                    trEvalMesh1;                /* 236 */
+	dispatch->EvalPoint1 =                   trEvalPoint1;               /* 237 */
+	dispatch->EvalMesh2 =                    trEvalMesh2;                /* 238 */
+	dispatch->EvalPoint2 =                   trEvalPoint2;               /* 239 */
+	dispatch->AlphaFunc =                    trAlphaFunc;                /* 240 */
+	dispatch->BlendFunc =                    trBlendFunc;                /* 241 */
+	dispatch->LogicOp =                      trLogicOp;                  /* 242 */
+	dispatch->StencilFunc =                  trStencilFunc;              /* 243 */
+	dispatch->StencilOp =                    trStencilOp;                /* 244 */
+	dispatch->DepthFunc =                    trDepthFunc;                /* 245 */
+	dispatch->PixelZoom =                    trPixelZoom;                /* 246 */
+	dispatch->PixelTransferf =               trPixelTransferf;           /* 247 */
+	dispatch->PixelTransferi =               trPixelTransferi;           /* 248 */
+	dispatch->PixelStoref =                  trPixelStoref;              /* 249 */
+	dispatch->PixelStorei =                  trPixelStorei;              /* 250 */
+	dispatch->PixelMapfv =                   trPixelMapfv;               /* 251 */
+	dispatch->PixelMapuiv =                  trPixelMapuiv;              /* 252 */
+	dispatch->PixelMapusv =                  trPixelMapusv;              /* 253 */
+	dispatch->ReadBuffer =                   trReadBuffer;               /* 254 */
+	dispatch->CopyPixels =                   trCopyPixels;               /* 255 */
+	dispatch->ReadPixels =                   trReadPixels;               /* 256 */
+	dispatch->DrawPixels =                   trDrawPixels;               /* 257 */
+	dispatch->GetBooleanv =                  trGetBooleanv;              /* 258 */
+	dispatch->GetClipPlane =                 trGetClipPlane;             /* 259 */
+	dispatch->GetDoublev =                   trGetDoublev;               /* 260 */
+	dispatch->GetError =                     trGetError;                 /* 261 */
+	dispatch->GetFloatv =                    trGetFloatv;                /* 262 */
+	dispatch->GetIntegerv =                  trGetIntegerv;              /* 263 */
+	dispatch->GetLightfv =                   trGetLightfv;               /* 264 */
+	dispatch->GetLightiv =                   trGetLightiv;               /* 265 */
+	dispatch->GetMapdv =                     trGetMapdv;                 /* 266 */
+	dispatch->GetMapfv =                     trGetMapfv;                 /* 267 */
+	dispatch->GetMapiv =                     trGetMapiv;                 /* 268 */
+	dispatch->GetMaterialfv =                trGetMaterialfv;            /* 269 */
+	dispatch->GetMaterialiv =                trGetMaterialiv;            /* 270 */
+	dispatch->GetPixelMapfv =                trGetPixelMapfv;            /* 271 */
+	dispatch->GetPixelMapuiv =               trGetPixelMapuiv;           /* 272 */
+	dispatch->GetPixelMapusv =               trGetPixelMapusv;           /* 273 */
+	dispatch->GetPolygonStipple =            trGetPolygonStipple;        /* 274 */
+	dispatch->GetString =                    trGetString;                /* 275 */
+	dispatch->GetTexEnvfv =                  trGetTexEnvfv;              /* 276 */
+	dispatch->GetTexEnviv =                  trGetTexEnviv;              /* 277 */
+	dispatch->GetTexGendv =                  trGetTexGendv;              /* 278 */
+	dispatch->GetTexGenfv =                  trGetTexGenfv;              /* 279 */
+	dispatch->GetTexGeniv =                  trGetTexGeniv;              /* 280 */
+	dispatch->GetTexImage =                  trGetTexImage;              /* 281 */
+	dispatch->GetTexParameterfv =            trGetTexParameterfv;        /* 282 */
+	dispatch->GetTexParameteriv =            trGetTexParameteriv;        /* 283 */
+	dispatch->GetTexLevelParameterfv =       trGetTexLevelParameterfv;   /* 284 */
+	dispatch->GetTexLevelParameteriv =       trGetTexLevelParameteriv;   /* 285 */
+	dispatch->IsEnabled =                    trIsEnabled;                /* 286 */
+	dispatch->IsList =                       trIsList;                   /* 287 */
+	dispatch->DepthRange =                   trDepthRange;               /* 288 */
+	dispatch->Frustum =                      trFrustum;                  /* 289 */
+	dispatch->LoadIdentity =                 trLoadIdentity;             /* 290 */
+	dispatch->LoadMatrixf =                  trLoadMatrixf;              /* 291 */
+	dispatch->LoadMatrixd =                  trLoadMatrixd;              /* 292 */
+	dispatch->MatrixMode =                   trMatrixMode;               /* 293 */
+	dispatch->MultMatrixf =                  trMultMatrixf;              /* 294 */
+	dispatch->MultMatrixd =                  trMultMatrixd;              /* 295 */
+	dispatch->Ortho =                        trOrtho;                    /* 296 */
+	dispatch->PopMatrix =                    trPopMatrix;                /* 297 */
+	dispatch->PushMatrix =                   trPushMatrix;               /* 298 */
+	dispatch->Rotated =                      trRotated;                  /* 299 */
+	dispatch->Rotatef =                      trRotatef;                  /* 300 */
+	dispatch->Scaled =                       trScaled;                   /* 301 */
+	dispatch->Scalef =                       trScalef;                   /* 302 */
+	dispatch->Translated =                   trTranslated;               /* 303 */
+	dispatch->Translatef =                   trTranslatef;               /* 304 */
+	dispatch->Viewport =                     trViewport;                 /* 305 */
+	dispatch->ArrayElement =                 trArrayElement;             /* 306 */
+	dispatch->BindTexture =                  trBindTexture;              /* 307 */
+	dispatch->ColorPointer =                 trColorPointer;             /* 308 */
+	dispatch->DisableClientState =           trDisableClientState;       /* 309 */
+	dispatch->DrawArrays =                   trDrawArrays;               /* 310 */
+	dispatch->DrawElements =                 trDrawElements;             /* 311 */
+	dispatch->EdgeFlagPointer =              trEdgeFlagPointer;          /* 312 */
+	dispatch->EnableClientState =            trEnableClientState;        /* 313 */
+	dispatch->IndexPointer =                 trIndexPointer;             /* 314 */
+	dispatch->Indexub =                      trIndexub;                  /* 315 */
+	dispatch->Indexubv =                     trIndexubv;                 /* 316 */
+	dispatch->InterleavedArrays =            trInterleavedArrays;        /* 317 */
+	dispatch->NormalPointer =                trNormalPointer;            /* 318 */
+	dispatch->PolygonOffset =                trPolygonOffset;            /* 319 */
+	dispatch->TexCoordPointer =              trTexCoordPointer;          /* 320 */
+	dispatch->VertexPointer =                trVertexPointer;            /* 321 */
+	dispatch->AreTexturesResident =          trAreTexturesResident;      /* 322 */
+	dispatch->CopyTexImage1D =               trCopyTexImage1D;           /* 323 */
+	dispatch->CopyTexImage2D =               trCopyTexImage2D;           /* 324 */
+	dispatch->CopyTexSubImage1D =            trCopyTexSubImage1D;        /* 325 */
+	dispatch->CopyTexSubImage2D =            trCopyTexSubImage2D;        /* 326 */
+	dispatch->DeleteTextures =               trDeleteTextures;           /* 327 */
+	dispatch->GenTextures =                  trGenTextures;              /* 328 */
+	dispatch->GetPointerv =                  trGetPointerv;              /* 329 */
+	dispatch->IsTexture =                    trIsTexture;                /* 330 */
+	dispatch->PrioritizeTextures =           trPrioritizeTextures;       /* 331 */
+	dispatch->TexSubImage1D =                trTexSubImage1D;            /* 332 */
+	dispatch->TexSubImage2D =                trTexSubImage2D;            /* 333 */
+	dispatch->PopClientAttrib =              trPopClientAttrib;          /* 334 */
+	dispatch->PushClientAttrib =             trPushClientAttrib;         /* 335 */
+#if 1
+	dispatch->BlendColor =                   trBlendColor;               /* 336 */
+	dispatch->BlendEquation =                trBlendEquation;            /* 337 */
+	dispatch->DrawRangeElements =            trDrawRangeElements;        /* 338 */
+	dispatch->ColorTable =                   trColorTable;               /* 339 */
+	dispatch->ColorTableParameterfv =        trColorTableParameterfv;    /* 340 */
+	dispatch->ColorTableParameteriv =        trColorTableParameteriv;    /* 341 */
+	dispatch->CopyColorTable =               trCopyColorTable;           /* 342 */
+	dispatch->GetColorTable =                trGetColorTable;            /* 343 */
+	dispatch->GetColorTableParameterfv =     trGetColorTableParameterfv; /* 344 */
+	dispatch->GetColorTableParameteriv =     trGetColorTableParameteriv; /* 345 */
+	dispatch->ColorSubTable =                trColorSubTable;            /* 346 */
+	dispatch->CopyColorSubTable =            trCopyColorSubTable;        /* 347 */
+	dispatch->ConvolutionFilter1D =          trConvolutionFilter1D;      /* 348 */
+	dispatch->ConvolutionFilter2D =          trConvolutionFilter2D;      /* 349 */
+	dispatch->ConvolutionParameterf =        trConvolutionParameterf;    /* 350 */
+	dispatch->ConvolutionParameterfv =       trConvolutionParameterfv;   /* 351 */
+	dispatch->ConvolutionParameteri =        trConvolutionParameteri;    /* 352 */
+	dispatch->ConvolutionParameteriv =       trConvolutionParameteriv;   /* 353 */
+	dispatch->CopyConvolutionFilter1D =      trCopyConvolutionFilter1D;  /* 354 */
+	dispatch->CopyConvolutionFilter2D =      trCopyConvolutionFilter2D;  /* 355 */
+	dispatch->GetConvolutionFilter =         trGetConvolutionFilter;     /* 356 */
+	dispatch->GetConvolutionParameterfv =    trGetConvolutionParameterfv;/* 357 */
+	dispatch->GetConvolutionParameteriv =    trGetConvolutionParameteriv;/* 358 */
+	dispatch->GetSeparableFilter =           trGetSeparableFilter;       /* 359 */
+	dispatch->SeparableFilter2D =            trSeparableFilter2D;        /* 360 */
+	dispatch->GetHistogram =                 trGetHistogram;             /* 361 */
+	dispatch->GetHistogramParameterfv =      trGetHistogramParameterfv;  /* 362 */
+	dispatch->GetHistogramParameteriv =      trGetHistogramParameteriv;  /* 363 */
+	dispatch->GetMinmax =                    trGetMinmax;                /* 364 */
+	dispatch->GetMinmaxParameterfv =         trGetMinmaxParameterfv;     /* 365 */
+	dispatch->GetMinmaxParameteriv =         trGetMinmaxParameteriv;     /* 366 */
+#endif
+#if 0
+	dispatch->Histogram =                    trHistogram                 /* 367 */
+	dispatch->Minmax =                       trMinmax                    /* 368 */
+	dispatch->ResetHistogram =               trResetHistogram            /* 369 */
+	dispatch->ResetMinmax =                  trResetMinmax               /* 370 */
+	dispatch->TexImage3D =                   trTexImage3D                /* 371 */
+	dispatch->TexSubImage3D =                trTexSubImage3D             /* 372 */
+	dispatch->CopyTexSubImage3D =            trCopyTexSubImage3D         /* 373 */
+	dispatch->ActiveTextureARB =             trActiveTextureARB          /* 374 */
+	dispatch->ClientActiveTextureARB =       trClientActiveTextureARB    /* 375 */
+	dispatch->MultiTexCoord1dARB =           trMultiTexCoord1dARB        /* 376 */
+	dispatch->MultiTexCoord1dvARB =          trMultiTexCoord1dvARB       /* 377 */
+	dispatch->MultiTexCoord1fARB =           trMultiTexCoord1fARB        /* 378 */
+	dispatch->MultiTexCoord1fvARB =          trMultiTexCoord1fvARB       /* 379 */
+	dispatch->MultiTexCoord1iARB =           trMultiTexCoord1iARB        /* 380 */
+	dispatch->MultiTexCoord1ivARB =          trMultiTexCoord1ivARB       /* 381 */
+	dispatch->MultiTexCoord1sARB =           trMultiTexCoord1sARB        /* 382 */
+	dispatch->MultiTexCoord1svARB =          trMultiTexCoord1svARB       /* 383 */
+	dispatch->MultiTexCoord2dARB =           trMultiTexCoord2dARB        /* 384 */
+	dispatch->MultiTexCoord2dvARB =          trMultiTexCoord2dvARB       /* 385 */
+	dispatch->MultiTexCoord2fARB =           trMultiTexCoord2fARB        /* 386 */
+	dispatch->MultiTexCoord2fvARB =          trMultiTexCoord2fvARB       /* 387 */
+	dispatch->MultiTexCoord2iARB =           trMultiTexCoord2iARB        /* 388 */
+	dispatch->MultiTexCoord2ivARB =          trMultiTexCoord2ivARB       /* 389 */
+	dispatch->MultiTexCoord2sARB =           trMultiTexCoord2sARB        /* 390 */
+	dispatch->MultiTexCoord2svARB =          trMultiTexCoord2svARB       /* 391 */
+	dispatch->MultiTexCoord3dARB =           trMultiTexCoord3dARB        /* 392 */
+	dispatch->MultiTexCoord3dvARB =          trMultiTexCoord3dvARB       /* 393 */
+	dispatch->MultiTexCoord3fARB =           trMultiTexCoord3fARB        /* 394 */
+	dispatch->MultiTexCoord3fvARB =          trMultiTexCoord3fvARB       /* 395 */
+	dispatch->MultiTexCoord3iARB =           trMultiTexCoord3iARB        /* 396 */
+	dispatch->MultiTexCoord3ivARB =          trMultiTexCoord3ivARB       /* 397 */
+	dispatch->MultiTexCoord3sARB =           trMultiTexCoord3sARB        /* 398 */
+	dispatch->MultiTexCoord3svARB =          trMultiTexCoord3svARB       /* 399 */
+	dispatch->MultiTexCoord4dARB =           trMultiTexCoord4dARB        /* 400 */
+	dispatch->MultiTexCoord4dvARB =          trMultiTexCoord4dvARB       /* 401 */
+	dispatch->MultiTexCoord4fARB =           trMultiTexCoord4fARB        /* 402 */
+	dispatch->MultiTexCoord4fvARB =          trMultiTexCoord4fvARB       /* 403 */
+	dispatch->MultiTexCoord4iARB =           trMultiTexCoord4iARB        /* 404 */
+	dispatch->MultiTexCoord4ivARB =          trMultiTexCoord4ivARB       /* 405 */
+	dispatch->MultiTexCoord4sARB =           trMultiTexCoord4sARB        /* 406 */
+	dispatch->MultiTexCoord4svARB =          trMultiTexCoord4svARB       /* 407 */
+	dispatch->LoadTransposeMatrixfARB =      trLoadTransposeMatrixfARB   /* 408 */
+	dispatch->LoadTransposeMatrixdARB =      trLoadTransposeMatrixdARB   /* 409 */
+	dispatch->MultTransposeMatrixfARB =      trMultTransposeMatrixfARB   /* 410 */
+	dispatch->MultTransposeMatrixdARB =      trMultTransposeMatrixdARB   /* 411 */
+	dispatch->SampleCoverageARB =            trSampleCoverageARB         /* 412 */
+	dispatch->SamplePassARB =                trSamplePassARB             /* 413 */
+	dispatch->PolygonOffsetEXT =             trPolygonOffsetEXT          /* 414 */
+	dispatch->GetTexFilterFuncSGIS =         trGetTexFilterFuncSGIS      /* 415 */
+	dispatch->TexFilterFuncSGIS =            trTexFilterFuncSGIS         /* 416 */
+	dispatch->GetHistogramEXT =              trGetHistogramEXT           /* 417 */
+	dispatch->GetHistogramParameterfvEXT =   trGetHistogramParameterfvEXT /* 418 */
+	dispatch->GetHistogramParameterivEXT =   trGetHistogramParameterivEXT /* 419 */
+	dispatch->GetMinmaxEXT =                 trGetMinmaxEXT              /* 420 */
+	dispatch->GetMinmaxParameterfvEXT =      trGetMinmaxParameterfvEXT   /* 421 */
+	dispatch->GetMinmaxParameterivEXT =      trGetMinmaxParameterivEXT   /* 422 */
+	dispatch->GetConvolutionFilterEXT =      trGetConvolutionFilterEXT   /* 423 */
+	dispatch->GetConvolutionParameterfvEXT = trGetConvolutionParameterfvEXT /* 424 */
+	dispatch->GetConvolutionParameterivEXT = trGetConvolutionParameterivEXT /* 425 */
+	dispatch->GetSeparableFilterEXT =        trGetSeparableFilterEXT     /* 426 */
+	dispatch->GetColorTableSGI =             trGetColorTableSGI          /* 427 */
+	dispatch->GetColorTableParameterfvSGI =  trGetColorTableParameterfvSGI /* 428 */
+	dispatch->GetColorTableParameterivSGI =  trGetColorTableParameterivSGI /* 429 */
+	dispatch->PixelTexGenSGIX =              trPixelTexGenSGIX           /* 430 */
+	dispatch->PixelTexGenParameteriSGIS =    trPixelTexGenParameteriSGIS /* 431 */
+	dispatch->PixelTexGenParameterivSGIS =   trPixelTexGenParameterivSGIS /* 432 */
+	dispatch->PixelTexGenParameterfSGIS =    trPixelTexGenParameterfSGIS /* 433 */
+	dispatch->PixelTexGenParameterfvSGIS =   trPixelTexGenParameterfvSGIS /* 434 */
+	dispatch->GetPixelTexGenParameterivSGIS = trGetPixelTexGenParameterivSGIS /* 435 */
+	dispatch->GetPixelTexGenParameterfvSGIS = trGetPixelTexGenParameterfvSGIS /* 436 */
+	dispatch->TexImage4DSGIS =               trTexImage4DSGIS            /* 437 */
+	dispatch->TexSubImage4DSGIS =            trTexSubImage4DSGIS         /* 438 */
+	dispatch->AreTexturesResidentEXT =       trAreTexturesResidentEXT    /* 439 */
+	dispatch->GenTexturesEXT =               trGenTexturesEXT            /* 440 */
+	dispatch->IsTextureEXT =                 trIsTextureEXT              /* 441 */
+	dispatch->DetailTexFuncSGIS =            trDetailTexFuncSGIS         /* 442 */
+	dispatch->GetDetailTexFuncSGIS =         trGetDetailTexFuncSGIS      /* 443 */
+	dispatch->SharpenTexFuncSGIS =           trSharpenTexFuncSGIS        /* 444 */
+	dispatch->GetSharpenTexFuncSGIS =        trGetSharpenTexFuncSGIS     /* 445 */
+	dispatch->SampleMaskSGIS =               trSampleMaskSGIS            /* 446 */
+	dispatch->SamplePatternSGIS =            trSamplePatternSGIS         /* 447 */
+	dispatch->ColorPointerEXT =              trColorPointerEXT           /* 448 */
+	dispatch->EdgeFlagPointerEXT =           trEdgeFlagPointerEXT        /* 449 */
+	dispatch->IndexPointerEXT =              trIndexPointerEXT           /* 450 */
+	dispatch->NormalPointerEXT =             trNormalPointerEXT          /* 451 */
+	dispatch->TexCoordPointerEXT =           trTexCoordPointerEXT        /* 452 */
+	dispatch->VertexPointerEXT =             trVertexPointerEXT          /* 453 */
+	dispatch->SpriteParameterfSGIX =         trSpriteParameterfSGIX      /* 454 */
+	dispatch->SpriteParameterfvSGIX =        trSpriteParameterfvSGIX     /* 455 */
+	dispatch->SpriteParameteriSGIX =         trSpriteParameteriSGIX      /* 456 */
+	dispatch->SpriteParameterivSGIX =        trSpriteParameterivSGIX     /* 457 */
+	dispatch->PointParameterfEXT =           trPointParameterfEXT        /* 458 */
+	dispatch->PointParameterfvEXT =          trPointParameterfvEXT       /* 459 */
+	dispatch->GetInstrumentsSGIX =           trGetInstrumentsSGIX        /* 460 */
+	dispatch->InstrumentsBufferSGIX =        trInstrumentsBufferSGIX     /* 461 */
+	dispatch->PollInstrumentsSGIX =          trPollInstrumentsSGIX       /* 462 */
+	dispatch->ReadInstrumentsSGIX =          trReadInstrumentsSGIX       /* 463 */
+	dispatch->StartInstrumentsSGIX =         trStartInstrumentsSGIX      /* 464 */
+	dispatch->StopInstrumentsSGIX =          trStopInstrumentsSGIX       /* 465 */
+	dispatch->FrameZoomSGIX =                trFrameZoomSGIX             /* 466 */
+	dispatch->TagSampleBufferSGIX =          trTagSampleBufferSGIX       /* 467 */
+	dispatch->ReferencePlaneSGIX =           trReferencePlaneSGIX        /* 468 */
+	dispatch->FlushRasterSGIX =              trFlushRasterSGIX           /* 469 */
+	dispatch->GetListParameterfvSGIX =       trGetListParameterfvSGIX    /* 470 */
+	dispatch->GetListParameterivSGIX =       trGetListParameterivSGIX    /* 471 */
+	dispatch->ListParameterfSGIX =           trListParameterfSGIX        /* 472 */
+	dispatch->ListParameterfvSGIX =          trListParameterfvSGIX       /* 473 */
+	dispatch->ListParameteriSGIX =           trListParameteriSGIX        /* 474 */
+	dispatch->ListParameterivSGIX =          trListParameterivSGIX       /* 475 */
+	dispatch->FragmentColorMaterialSGIX =    trFragmentColorMaterialSGIX /* 476 */
+	dispatch->FragmentLightfSGIX =           trFragmentLightfSGIX        /* 477 */
+	dispatch->FragmentLightfvSGIX =          trFragmentLightfvSGIX       /* 478 */
+	dispatch->FragmentLightiSGIX =           trFragmentLightiSGIX        /* 479 */
+	dispatch->FragmentLightivSGIX =          trFragmentLightivSGIX       /* 480 */
+	dispatch->FragmentLightModelfSGIX =      trFragmentLightModelfSGIX   /* 481 */
+	dispatch->FragmentLightModelfvSGIX =     trFragmentLightModelfvSGIX  /* 482 */
+	dispatch->FragmentLightModeliSGIX =      trFragmentLightModeliSGIX   /* 483 */
+	dispatch->FragmentLightModelivSGIX =     trFragmentLightModelivSGIX  /* 484 */
+	dispatch->FragmentMaterialfSGIX =        trFragmentMaterialfSGIX     /* 485 */
+	dispatch->FragmentMaterialfvSGIX =       trFragmentMaterialfvSGIX    /* 486 */
+	dispatch->FragmentMaterialiSGIX =        trFragmentMaterialiSGIX     /* 487 */
+	dispatch->FragmentMaterialivSGIX =       trFragmentMaterialivSGIX    /* 488 */
+	dispatch->GetFragmentLightfvSGIX =       trGetFragmentLightfvSGIX    /* 489 */
+	dispatch->GetFragmentLightivSGIX =       trGetFragmentLightivSGIX    /* 490 */
+	dispatch->GetFragmentMaterialfvSGIX =    trGetFragmentMaterialfvSGIX /* 491 */
+	dispatch->GetFragmentMaterialivSGIX =    trGetFragmentMaterialivSGIX /* 492 */
+	dispatch->LightEnviSGIX =                trLightEnviSGIX             /* 493 */
+	dispatch->VertexWeightfEXT =             trVertexWeightfEXT          /* 494 */
+	dispatch->VertexWeightfvEXT =            trVertexWeightfvEXT         /* 495 */
+	dispatch->VertexWeightPointerEXT =       trVertexWeightPointerEXT    /* 496 */
+	dispatch->FlushVertexArrayRangeNV =      trFlushVertexArrayRangeNV   /* 497 */
+	dispatch->VertexArrayRangeNV =           trVertexArrayRangeNV        /* 498 */
+	dispatch->CombinerParameterfvNV =        trCombinerParameterfvNV     /* 499 */
+	dispatch->CombinerParameterfNV =         trCombinerParameterfNV      /* 500 */
+	dispatch->CombinerParameterivNV =        trCombinerParameterivNV     /* 501 */
+	dispatch->CombinerParameteriNV =         trCombinerParameteriNV      /* 502 */
+	dispatch->CombinerInputNV =              trCombinerInputNV           /* 503 */
+	dispatch->CombinerOutputNV =             trCombinerOutputNV          /* 504 */
+	dispatch->FinalCombinerInputNV =         trFinalCombinerInputNV      /* 505 */
+	dispatch->GetCombinerInputParameterfvNV = trGetCombinerInputParameterfvNV /* 506 */
+	dispatch->GetCombinerInputParameterivNV = trGetCombinerInputParameterivNV /* 507 */
+	dispatch->GetCombinerOutputParameterfvNV = trGetCombinerOutputParameterfvNV /* 508 */
+	dispatch->GetCombinerOutputParameterivNV = trGetCombinerOutputParameterivNV /* 509 */
+	dispatch->GetFinalCombinerInputParameterfvNV = trGetFinalCombinerInputParameterfvNV /* 510 */
+	dispatch->GetFinalCombinerInputParameterivNV = trGetFinalCombinerInputParameterivNV /* 511 */
+	dispatch->ResizeBuffersMESA =            trResizeBuffersMESA         /* 512 */
+	dispatch->WindowPos2dMESA =              trWindowPos2dMESA           /* 513 */
+	dispatch->WindowPos2dvMESA =             trWindowPos2dvMESA          /* 514 */
+	dispatch->WindowPos2fMESA =              trWindowPos2fMESA           /* 515 */
+	dispatch->WindowPos2fvMESA =             trWindowPos2fvMESA          /* 516 */
+	dispatch->WindowPos2iMESA =              trWindowPos2iMESA           /* 517 */
+	dispatch->WindowPos2ivMESA =             trWindowPos2ivMESA          /* 518 */
+	dispatch->WindowPos2sMESA =              trWindowPos2sMESA           /* 519 */
+	dispatch->WindowPos2svMESA =             trWindowPos2svMESA          /* 520 */
+	dispatch->WindowPos3dMESA =              trWindowPos3dMESA           /* 521 */
+	dispatch->WindowPos3dvMESA =             trWindowPos3dvMESA          /* 522 */
+	dispatch->WindowPos3fMESA =              trWindowPos3fMESA           /* 523 */
+	dispatch->WindowPos3fvMESA =             trWindowPos3fvMESA          /* 524 */
+	dispatch->WindowPos3iMESA =              trWindowPos3iMESA           /* 525 */
+	dispatch->WindowPos3ivMESA =             trWindowPos3ivMESA          /* 526 */
+	dispatch->WindowPos3sMESA =              trWindowPos3sMESA           /* 527 */
+	dispatch->WindowPos3svMESA =             trWindowPos3svMESA          /* 528 */
+	dispatch->WindowPos4dMESA =              trWindowPos4dMESA           /* 529 */
+	dispatch->WindowPos4dvMESA =             trWindowPos4dvMESA          /* 530 */
+	dispatch->WindowPos4fMESA =              trWindowPos4fMESA           /* 531 */
+	dispatch->WindowPos4fvMESA =             trWindowPos4fvMESA          /* 532 */
+	dispatch->WindowPos4iMESA =              trWindowPos4iMESA           /* 533 */
+	dispatch->WindowPos4ivMESA =             trWindowPos4ivMESA          /* 534 */
+	dispatch->WindowPos4sMESA =              trWindowPos4sMESA           /* 535 */
+	dispatch->WindowPos4svMESA =             trWindowPos4svMESA          /* 536 */
+	dispatch->BlendFuncSeparateEXT =         trBlendFuncSeparateEXT      /* 537 */
+	dispatch->IndexMaterialEXT =             trIndexMaterialEXT          /* 538 */
+	dispatch->IndexFuncEXT =                 trIndexFuncEXT              /* 539 */
+	dispatch->LockArraysEXT =                trLockArraysEXT             /* 540 */
+	dispatch->UnlockArraysEXT =              trUnlockArraysEXT           /* 541 */
+	dispatch->CullParameterdvEXT =           trCullParameterdvEXT        /* 542 */
+	dispatch->CullParameterfvEXT =           trCullParameterfvEXT        /* 543 */
+	dispatch->HintPGI =                      trHintPGI                   /* 544 */
+	dispatch->FogCoordfEXT =                 trFogCoordfEXT              /* 545 */
+	dispatch->FogCoordfvEXT =                trFogCoordfvEXT             /* 546 */
+	dispatch->FogCoorddEXT =                 trFogCoorddEXT              /* 547 */
+	dispatch->FogCoorddvEXT =                trFogCoorddvEXT             /* 548 */
+	dispatch->FogCoordPointerEXT =           trFogCoordPointerEXT        /* 549 */
+	dispatch->GetColorTableEXT =             trGetColorTableEXT          /* 550 */
+	dispatch->GetColorTableParameterivEXT =  trGetColorTableParameterivEXT /* 551 */
+	dispatch->GetColorTableParameterfvEXT =  trGetColorTableParameterfvEXT /* 552 */
+#endif
+}
+
+
+#else
+extern void tr_wrapper_dummy_func(void);
+void tr_wrapper_dummy_func(void)
+{
+}
+#endif
Index: xc/extras/Mesa/src/Trace/tr_wrapper.h
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_wrapper.h:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_wrapper.h	Wed Dec 11 16:13:34 2002
@@ -0,0 +1,8 @@
+#ifndef TR_WRAPPER_H
+#define TR_WRAPPER_H
+
+#include "glapitable.h"
+
+void trInitDispatch( struct _glapi_table* dispatch );
+
+#endif
Index: xc/extras/Mesa/src/Trace/tr_write.c
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_write.c:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_write.c	Wed Dec 11 16:13:34 2002
@@ -0,0 +1,238 @@
+#ifdef MESA_TRACE
+
+#include "glheader.h"
+#include <time.h>  /* XXX move into glheader.h */
+#include "tr_write.h"
+#include "tr_context.h"
+
+#define PATH_MAX 4098
+
+
+static void trWriteFile( const void * buf, GLint recsize, GLint numrecs, const char * funcname ) {
+	GLint recswritten;
+
+	if( !(trCtx()->trDoPrint) ) {
+		return;
+	}
+
+	recswritten = fwrite( buf, recsize, numrecs, trCtx()->logFP );
+	if( recswritten != numrecs ) {
+		fprintf( stderr, "Error writing to file in %s\n", funcname );
+		fprintf( stderr, "Perhaps the disk is full?\n" );
+		/* Should we abort ? */
+		trCtx()->trDoPrint = GL_FALSE;
+	}
+}
+
+
+static void (*trWrite)( const void *, GLint, GLint, const char *) = trWriteFile;
+
+
+void trWriteCMD( GLint cmd ) {
+	trWrite( (void*)&cmd, sizeof(GLint), 1, "trWriteCMD" );
+}
+
+void trWriteb( GLbyte b ) {
+	trWrite( (void*)&b, sizeof(GLbyte), 1, "trWriteb" );
+}
+
+void trWrited( GLdouble d ) {
+	trWrite( (void*)&d, sizeof(GLdouble), 1, "trWrited" );
+}
+
+void trWriteClampd( GLclampd cd ) {
+	trWrite( (void*)&cd, sizeof(GLclampd), 1, "trWriteClampd" );
+}
+
+void trWritef( GLfloat f ) {
+	trWrite( (void*)&f, sizeof(GLfloat), 1, "trWritef" );
+}
+
+void trWriteClampf( GLclampf cf ) {
+	trWrite( (void*)&cf, sizeof(GLclampf), 1, "trWriteClampf" );
+}
+
+void trWritei( GLint i ) {
+	trWrite( (void*)&i, sizeof(GLint), 1, "trWritei" );
+}
+
+void trWrites( GLshort s ) {
+	trWrite( (void*)&s, sizeof(GLshort), 1, "trWrites" );
+}
+
+void trWriteub( GLubyte ub ) {
+	trWrite( (void*)&ub, sizeof(GLubyte), 1, "trWriteub" );
+}
+
+void trWriteui( GLuint ui ) {
+	trWrite( (void*)&ui, sizeof(GLuint), 1, "trWriteui" );
+}
+
+void trWriteus( GLushort us ) {
+	trWrite( (void*)&us, sizeof(GLushort), 1, "trWriteus" );
+}
+
+void trWriteBool( GLboolean b ) {
+	trWrite( (void*)&b, sizeof(GLboolean), 1, "trWriteBool" );
+}
+
+void trWriteBits( GLbitfield bf ) {
+	trWrite( (void*)&bf, sizeof(GLbitfield), 1, "trWriteBits" );
+}
+
+void trWriteEnum( GLenum en ) {
+	trWrite( (void*)&en, sizeof(GLenum), 1, "trWriteEnum" );
+}
+
+void trWriteSizei( GLsizei si ) {
+	trWrite( (void*)&si, sizeof(GLsizei), 1, "trWriteSizei" );
+}
+
+
+void trWritePointer( const void * p ) {
+	trWrite( (void*)&p, sizeof(void *), 1, "trWritePointer" );
+}
+
+
+void trWriteArrayb( GLsizei n, const GLbyte * b ) {
+	trWrite( (void *)b, sizeof(GLbyte), n, "trWriteArrayb" );
+}
+
+
+void trWriteArrayub( GLsizei n, const GLubyte * ub ) {
+	trWrite( (void *)ub, sizeof(GLubyte), n, "trWriteArrayub" );
+}
+
+
+void trWriteArrays( GLsizei n, const GLshort * s ) {
+	trWrite( (void *)s, sizeof(GLshort), n, "trWriteArrays" );
+}
+
+
+void trWriteArrayus( GLsizei n, const GLushort * us ) {
+	trWrite( (void *)us, sizeof(GLushort), n, "trWriteArrayus" );
+}
+
+
+void trWriteArrayi( GLsizei n, const GLint * i ) {
+	trWrite( (void *)i, sizeof(GLint), n, "trWriteArrayi" );
+}
+
+
+void trWriteArrayui( GLsizei n, const GLuint * ui ) {
+	trWrite( (void *)ui, sizeof(GLuint), n, "trWriteArrayui" );
+}
+
+
+void trWriteArrayBool( GLsizei n, const GLboolean * b ) {
+	trWrite( (void *)b, sizeof(GLboolean), n, "trWriteArrayBool" );
+}
+
+
+void trWriteArrayf( GLsizei n, const GLfloat * f ) {
+	trWrite( (void *)f, sizeof(GLfloat), n, "trWriteArrayf" );
+}
+
+
+void trWriteArrayd( GLsizei n, const GLdouble * d ) {
+	trWrite( (void *)d, sizeof(GLdouble), n, "trWriteArrayd" );
+}
+
+
+void trWriteString( const char * str ) {
+	GLuint length = strlen(str);
+	trWriteui( length );
+	trWrite( (void *)str, sizeof(GLubyte), length, "trWriteString" );
+}
+
+
+void trFileFlush( void ) {
+  fflush( trCtx()->logFP );
+}
+
+
+static void trWriteTypeInformation( void ) {
+	
+	trWriteub( sizeof(GLint) );
+	trWriteub( sizeof(GLshort) );
+	trWriteub( sizeof(GLfloat) );
+	trWriteub( sizeof(GLdouble) );
+	trWriteub( sizeof(GLboolean) );
+	trWriteub( sizeof(GLenum) );
+	trWriteub( sizeof(GLsizei) );
+	trWriteub( sizeof(GLbitfield) );
+	trWriteub( sizeof(GLclampf) );
+	trWriteub( sizeof(GLclampd) );
+	trWriteub( sizeof(GLvoid *) );
+
+}
+
+
+static void trWriteHeader( void ) {
+	struct tm *newtime;
+	time_t aclock;
+	char timestring[256];
+
+	trWriteString( "0.0.1" );
+	trWriteString( trCtx()->traceName );
+	trWritei( trCtx()->framecounter );
+
+	/* Always print this! */
+	time( &aclock );
+	newtime = localtime( &aclock );
+	asctime( newtime );
+	snprintf( timestring, sizeof(timestring), "Time: %s", asctime( newtime ) );
+	trWriteString( timestring );
+}
+
+
+static void trWriteGLState( void ) {
+	/*
+	 * This function will write all the queryable GL state at
+	 * the time the trace is started.
+	 */
+}
+
+
+void trOpenLogFile( void ) {
+	GLint numchars;
+	char buffer[PATH_MAX];
+
+	numchars = snprintf( buffer, sizeof(buffer), "%s-gl.log.%d",
+	                     trCtx()->traceName, trCtx()->framecounter ); 
+	if( numchars > -1 && numchars < sizeof(buffer) ) {
+		trCtx()->logFP = fopen( buffer, "wb" );
+
+		/* This information is needed before we can extract _anything_ */
+		trWriteTypeInformation();
+		trWriteHeader();
+		trWriteGLState();
+
+		(trCtx()->framecounter)++;
+	} else if( numchars > -1 ) {
+		fprintf( stderr, "buffer needs to be %d bytes long for logging to work.\n",
+		         numchars + 1 );
+		exit( -1 );
+	} else {
+		fprintf( stderr, "buffer needs to grow for logging to work.  Try %d bytes.\n",
+		         sizeof(buffer) * 2 );
+		exit( -1 );
+	}
+}
+
+
+void trCloseLogFile( void ) {
+	if( trCtx()->logFP != NULL ) {
+		fclose(trCtx()->logFP);
+	}
+
+	trCtx()->logFP = NULL;
+}
+
+
+#else
+extern void tr_write_dummy_func(void);
+void tr_write_dummy_func(void)
+{
+}
+#endif
Index: xc/extras/Mesa/src/Trace/tr_write.h
diff -u /dev/null xc/extras/Mesa/src/Trace/tr_write.h:1.3
--- /dev/null	Thu Feb 27 12:15:51 2003
+++ xc/extras/Mesa/src/Trace/tr_write.h	Wed Dec 11 16:13:34 2002
@@ -0,0 +1,68 @@
+/* This may look like C code, but it is really -*- C++ -*-  */
+/* $Id: tr_write.h,v 1.1 2000/11/11 01:42:30 brianp Exp $ */
+
+/*
+ * DebugGL
+ * Version:  1.0
+ * 
+ * Copyright (C) 1999-2000  Loki Entertainment
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef __TR_WRITE_H
+#define __TR_WRITE_H
+
+#include "GL/gl.h"
+
+void trWriteCMD( GLint opcode );
+void trWriteb( GLbyte byte );
+void trWriteub( GLubyte ub );
+void trWrited( GLdouble d );
+void trWritef( GLfloat f );
+void trWritei( GLint i );
+void trWriteui( GLuint ui );
+void trWrites( GLshort s );
+void trWriteus( GLushort us );
+void trWriteBool( GLboolean b );
+void trWriteBits( GLbitfield bf );
+void trWriteEnum( GLenum en );
+void trWriteSizei( GLsizei si );
+void trWriteClampf( GLclampf cf );
+void trWriteClampd( GLclampd cd );
+void trWritePointer( const void * p );
+
+void trWriteArrayb( GLsizei n, const GLbyte * b );
+void trWriteArrayub( GLsizei n, const GLubyte * ub );
+void trWriteArrays( GLsizei n, const GLshort * s );
+void trWriteArrayus( GLsizei n, const GLushort * us );
+void trWriteArrayi( GLsizei n, const GLint * i );
+void trWriteArrayui( GLsizei n, const GLuint * ui );
+void trWriteArrayBool( GLsizei n, const GLboolean * b );
+void trWriteArrayf( GLsizei n, const GLfloat * f );
+void trWriteArrayd( GLsizei n, const GLdouble * d );
+
+void trWriteString( const char * str );
+
+void trFileFlush( void );
+
+void trOpenLogFile( void );
+void trCloseLogFile( void );
+
+#endif
Index: xc/extras/Mesa/src/X/Makefile.am
diff -u xc/extras/Mesa/src/X/Makefile.am:1.1.1.2 xc/extras/Mesa/src/X/Makefile.am:removed
--- xc/extras/Mesa/src/X/Makefile.am:1.1.1.2	Thu Nov 30 10:24:45 2000
+++ xc/extras/Mesa/src/X/Makefile.am	Thu Feb 27 12:15:51 2003
@@ -1,23 +0,0 @@
-## Process this file with automake to produce Makefile.in
-
-#AUTOMAKE_OPTIONS = no-dependencies
-
-INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/src $(X_CFLAGS) $(FX_CFLAGS)
-
-if HAVE_X11
-# Build a libtool convenience library.
-noinst_LTLIBRARIES = libMesaX11.la
-endif
-
-libMesaX11_la_SOURCES = \
-	glxapi.c \
-	glxapi.h \
-	fakeglx.c \
-	xfonts.c \
-	xmesa1.c \
-	xmesa2.c \
-	xmesa3.c \
-	xmesa4.c \
-	xmesaP.h
-
-libMesaX11_la_LIBADD = $(X_LIBS) $(X_PRE_LIBS) $(X_LIBADD)
Index: xc/extras/Mesa/src/X/fakeglx.c
diff -u xc/extras/Mesa/src/X/fakeglx.c:1.12 xc/extras/Mesa/src/X/fakeglx.c:1.17
--- xc/extras/Mesa/src/X/fakeglx.c:1.12	Fri May 18 13:00:05 2001
+++ xc/extras/Mesa/src/X/fakeglx.c	Tue Oct 29 13:19:41 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4.2
- * 
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -47,24 +47,25 @@
 #include "context.h"
 #include "config.h"
 #include "macros.h"
+#include "mem.h"
 #include "mmath.h"
-#include "types.h"
+#include "mtypes.h"
 #include "xfonts.h"
 #include "xmesaP.h"
 
 
 /* This indicates the client-side GLX API and GLX encoder version. */
 #define CLIENT_MAJOR_VERSION 1
-#define CLIENT_MINOR_VERSION 2
+#define CLIENT_MINOR_VERSION 4  /* but don't have 1.3's pbuffers, etc yet */
 
 /* This indicates the server-side GLX decoder version.
- * GLX 1.3 indicates OpenGL 1.2 support
+ * GLX 1.4 indicates OpenGL 1.3 support
  */
 #define SERVER_MAJOR_VERSION 1
-#define SERVER_MINOR_VERSION 3
+#define SERVER_MINOR_VERSION 4
 
 /* This is appended onto the glXGetClient/ServerString version strings. */
-#define MESA_GLX_VERSION "Mesa 3.4.2"
+#define MESA_GLX_VERSION "Mesa 4.0.4"
 
 /* Who implemented this GLX? */
 #define VENDOR "Brian Paul"
@@ -82,9 +83,28 @@
 }
 
 
+/*
+ * Our fake GLX context will contain a "real" GLX context and an XMesa context.
+ *
+ * Note that a pointer to a __GLXcontext is a pointer to a fake_glx_context,
+ * and vice versa.
+ *
+ * We really just need this structure in order to make the libGL functions
+ * glXGetCurrentContext(), glXGetCurrentDrawable() and glXGetCurrentDisplay()
+ * work correctly.
+ */
+struct fake_glx_context {
+   __GLXcontext glxContext;   /* this MUST be first! */
+   XMesaContext xmesaContext;
+};
+
+
 
-#define DONT_CARE -1
+/**********************************************************************/
+/***                       GLX Visual Code                          ***/
+/**********************************************************************/
 
+#define DONT_CARE -1
 
 
 #define MAX_VISUALS 100
@@ -92,7 +112,6 @@
 static int NumVisuals = 0;
 
 
-
 /*
  * This struct and some code fragments borrowed
  * from Mark Kilgard's GLUT library.
@@ -268,16 +287,16 @@
       if (v->display == dpy
           && v->level == level
           && v->ximage_flag == ximageFlag
-          && v->gl_visual->RGBAflag == rgbFlag
-          && v->gl_visual->DBflag == dbFlag
-          && v->gl_visual->StereoFlag == stereoFlag
-          && (v->gl_visual->AlphaBits > 0) == alphaFlag
-          && (v->gl_visual->DepthBits >= depth_size || depth_size == 0)
-          && (v->gl_visual->StencilBits >= stencil_size || stencil_size == 0)
-          && (v->gl_visual->AccumRedBits >= accumRedSize || accumRedSize == 0)
-          && (v->gl_visual->AccumGreenBits >= accumGreenSize || accumGreenSize == 0)
-          && (v->gl_visual->AccumBlueBits >= accumBlueSize || accumBlueSize == 0)
-          && (v->gl_visual->AccumAlphaBits >= accumAlphaSize || accumAlphaSize == 0)) {
+          && v->mesa_visual.rgbMode == rgbFlag
+          && v->mesa_visual.doubleBufferMode == dbFlag
+          && v->mesa_visual.stereoMode == stereoFlag
+          && (v->mesa_visual.alphaBits > 0) == alphaFlag
+          && (v->mesa_visual.depthBits >= depth_size || depth_size == 0)
+          && (v->mesa_visual.stencilBits >= stencil_size || stencil_size == 0)
+          && (v->mesa_visual.accumRedBits >= accumRedSize || accumRedSize == 0)
+          && (v->mesa_visual.accumGreenBits >= accumGreenSize || accumGreenSize == 0)
+          && (v->mesa_visual.accumBlueBits >= accumBlueSize || accumBlueSize == 0)
+          && (v->mesa_visual.accumAlphaBits >= accumAlphaSize || accumAlphaSize == 0)) {
          /* now either compare XVisualInfo pointers or visual IDs */
          if ((!comparePointers && v->visinfo->visualid == vinfo->visualid)
              || (comparePointers && v->vishandle == vinfo)) {
@@ -868,6 +887,10 @@
 }
 
 
+/**********************************************************************/
+/***                  Begin Fake GLX API Functions                  ***/
+/**********************************************************************/
+
 
 static XVisualInfo *
 Fake_glXChooseVisual( Display *dpy, int screen, int *list )
@@ -875,7 +898,7 @@
    int *parselist;
    XVisualInfo *vis;
    int min_ci = 0;
-   int min_red=0, min_green=0, min_blue=0, min_alpha=0;
+   int min_red=0, min_green=0, min_blue=0;
    GLboolean rgb_flag = GL_FALSE;
    GLboolean alpha_flag = GL_FALSE;
    GLboolean double_flag = GL_FALSE;
@@ -939,8 +962,10 @@
 	    break;
 	 case GLX_ALPHA_SIZE:
 	    parselist++;
-            min_alpha = *parselist++;
-            alpha_flag = (min_alpha > 0);
+            {
+               GLint size = *parselist++;
+               alpha_flag = size>0 ? 1 : 0;
+            }
 	    break;
 	 case GLX_DEPTH_SIZE:
 	    parselist++;
@@ -1002,7 +1027,7 @@
 	    parselist++;
 	    parselist++;
 	    break;
-         
+
          /*
           * GLX_EXT_visual_info extension
           */
@@ -1019,16 +1044,6 @@
       }
    }
 
-   /* DEBUG
-   printf("glXChooseVisual:\n");
-   printf("  GLX_RED_SIZE = %d\n", min_red);
-   printf("  GLX_GREEN_SIZE = %d\n", min_green);
-   printf("  GLX_BLUE_SIZE = %d\n", min_blue);
-   printf("  GLX_ALPHA_SIZE = %d\n", min_alpha);
-   printf("  GLX_DEPTH_SIZE = %d\n", depth_size);
-   printf("  GLX_STENCIL_SIZE = %d\n", stencil_size);
-   */
-
    /*
     * Since we're only simulating the GLX extension this function will never
     * find any real GL visuals.  Instead, all we can do is try to find an RGB
@@ -1085,33 +1100,17 @@
       else if (depth_size > 0)
          depth_size = DEFAULT_SOFTWARE_DEPTH_BITS; /*16*/
 
-      /* If using Glide, make sure we don't try to setup an impossible
-       * visual.  This fixes the Q3 bug in which 24-bit Z was being reported.
-       */
-      {
-         const char *fx = getenv("MESA_GLX_FX");
-         if (fx && fx[0] != 'd')
-            if (depth_size > 16 ||
-                stencil_size > 0 ||
-                (min_red > 1 && min_red > 5) ||
-                (min_green > 1 && min_green > 6) ||
-                (min_blue > 1 && min_blue > 5) ||
-                alpha_flag)
-               return NULL;
-      }
-
-
       /* we only support one size of stencil and accum buffers. */
       if (stencil_size > 0)
          stencil_size = STENCIL_BITS;
-      if (accumRedSize > 0)
+      if (accumRedSize > 0 || accumGreenSize > 0 || accumBlueSize > 0 ||
+          accumAlphaSize > 0) {
          accumRedSize = ACCUM_BITS;
-      if (accumGreenSize > 0)
          accumGreenSize = ACCUM_BITS;
-      if (accumBlueSize > 0)
          accumBlueSize = ACCUM_BITS;
-      if (accumAlphaSize > 0)
-         accumAlphaSize = ACCUM_BITS;
+         accumAlphaSize = alpha_flag ? ACCUM_BITS : 0;
+      }
+
       if (!save_glx_visual( dpy, vis, rgb_flag, alpha_flag, double_flag,
                             stereo_flag, depth_size, stencil_size,
                             accumRedSize, accumGreenSize,
@@ -1131,7 +1130,11 @@
                        GLXContext share_list, Bool direct )
 {
    XMesaVisual glxvis;
-   XMesaContext xmctx;
+   struct fake_glx_context *glxCtx;
+   struct fake_glx_context *shareCtx = (struct fake_glx_context *) share_list;
+   glxCtx = CALLOC_STRUCT(fake_glx_context);
+   if (!glxCtx)
+      return 0;
 
    /* deallocate unused windows/buffers */
    XMesaGarbageCollect();
@@ -1142,33 +1145,47 @@
       glxvis = create_glx_visual( dpy, visinfo );
       if (!glxvis) {
          /* unusable visual */
+         FREE(glxCtx);
          return NULL;
       }
    }
 
-   xmctx = XMesaCreateContext( glxvis, (XMesaContext) share_list );
-   if (xmctx) {
-      /* set the direct/indirect flag */
-      xmctx->direct = direct;
+   glxCtx->xmesaContext = XMesaCreateContext(glxvis,
+                                   shareCtx ? shareCtx->xmesaContext : NULL);
+   if (!glxCtx->xmesaContext) {
+      FREE(glxCtx);
+      return NULL;
    }
-   return (GLXContext) xmctx;
+
+   glxCtx->xmesaContext->direct = GL_FALSE;
+   glxCtx->glxContext.isDirect = GL_FALSE;
+   glxCtx->glxContext.currentDpy = dpy;
+   glxCtx->glxContext.xid = (XID) glxCtx;  /* self pointer */
+
+   assert((void *) glxCtx == (void *) &(glxCtx->glxContext));
+
+   return (GLXContext) glxCtx;
 }
 
 
+/* XXX these may have to be removed due to thread-safety issues. */
 static GLXContext MakeCurrent_PrevContext = 0;
 static GLXDrawable MakeCurrent_PrevDrawable = 0;
 static GLXDrawable MakeCurrent_PrevReadable = 0;
 static XMesaBuffer MakeCurrent_PrevDrawBuffer = 0;
 static XMesaBuffer MakeCurrent_PrevReadBuffer = 0;
 
+
 /* GLX 1.3 and later */
 static Bool
 Fake_glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
                             GLXDrawable read, GLXContext ctx )
 {
+   struct fake_glx_context *glxCtx = (struct fake_glx_context *) ctx;
+
    if (ctx && draw && read) {
       XMesaBuffer drawBuffer, readBuffer;
-      XMesaContext xmctx = (XMesaContext) ctx;
+      XMesaContext xmctx = glxCtx->xmesaContext;
 
       /* Find the XMesaBuffer which corresponds to the GLXDrawable 'draw' */
       if (ctx == MakeCurrent_PrevContext
@@ -1180,7 +1197,7 @@
       }
       if (!drawBuffer) {
          /* drawable must be a new window! */
-         drawBuffer = XMesaCreateWindowBuffer2( xmctx->xm_visual, draw, (XMesaContext) ctx );
+         drawBuffer = XMesaCreateWindowBuffer2( xmctx->xm_visual, draw, xmctx);
          if (!drawBuffer) {
             /* Out of memory, or context/drawable depth mismatch */
             return False;
@@ -1197,7 +1214,8 @@
       }
       if (!readBuffer) {
          /* drawable must be a new window! */
-         readBuffer = XMesaCreateWindowBuffer2( xmctx->xm_visual, read, (XMesaContext) ctx );
+         readBuffer = XMesaCreateWindowBuffer2(glxCtx->xmesaContext->xm_visual,
+                                               read, xmctx);
          if (!readBuffer) {
             /* Out of memory, or context/drawable depth mismatch */
             return False;
@@ -1211,7 +1229,19 @@
       MakeCurrent_PrevReadBuffer = readBuffer;
 
       /* Now make current! */
-      return (Bool) XMesaMakeCurrent2((XMesaContext) ctx, drawBuffer, readBuffer);
+      if (XMesaMakeCurrent2(xmctx, drawBuffer, readBuffer)) {
+         ((__GLXcontext *) ctx)->currentDpy = dpy;
+         ((__GLXcontext *) ctx)->currentDrawable = draw;
+#ifndef GLX_BUILT_IN_XMESA
+         ((__GLXcontext *) ctx)->currentReadable = read;
+#else
+         __glXSetCurrentContext(ctx);
+#endif
+         return True;
+      }
+      else {
+         return False;
+      }
    }
    else if (!ctx && !draw && !read) {
       /* release current context w/out assigning new one. */
@@ -1221,6 +1251,9 @@
       MakeCurrent_PrevReadable = 0;
       MakeCurrent_PrevDrawBuffer = 0;
       MakeCurrent_PrevReadBuffer = 0;
+#ifdef GLX_BUILT_IN_XMESA
+      /* XXX bind dummy context with __glXSetCurrentContext(ctx); */
+#endif
       return True;
    }
    else {
@@ -1263,8 +1296,9 @@
    return b->frontbuffer;
 }
 
+
+/*** GLX_MESA_pixmap_colormap ***/
 
-#ifdef GLX_MESA_pixmap_colormap
 static GLXPixmap
 Fake_glXCreateGLXPixmapMESA( Display *dpy, XVisualInfo *visinfo,
                              Pixmap pixmap, Colormap cmap )
@@ -1287,7 +1321,6 @@
    }
    return b->frontbuffer;
 }
-#endif
 
 
 static void
@@ -1308,10 +1341,12 @@
 Fake_glXCopyContext( Display *dpy, GLXContext src, GLXContext dst,
                      unsigned long mask )
 {
-   XMesaContext xm_src = (XMesaContext) src;
-   XMesaContext xm_dst = (XMesaContext) dst;
+   struct fake_glx_context *fakeSrc = (struct fake_glx_context *) src;
+   struct fake_glx_context *fakeDst = (struct fake_glx_context *) dst;
+   XMesaContext xm_src = fakeSrc->xmesaContext;
+   XMesaContext xm_dst = fakeDst->xmesaContext;
    (void) dpy;
-   gl_copy_context( xm_src->gl_ctx, xm_dst->gl_ctx, (GLuint) mask );
+   _mesa_copy_context( xm_src->gl_ctx, xm_dst->gl_ctx, (GLuint) mask );
 }
 
 
@@ -1338,13 +1373,14 @@
 static void
 Fake_glXDestroyContext( Display *dpy, GLXContext ctx )
 {
+   struct fake_glx_context *glxCtx = (struct fake_glx_context *) ctx;
    (void) dpy;
    MakeCurrent_PrevContext = 0;
    MakeCurrent_PrevDrawable = 0;
    MakeCurrent_PrevReadable = 0;
    MakeCurrent_PrevDrawBuffer = 0;
    MakeCurrent_PrevReadBuffer = 0;
-   XMesaDestroyContext( (XMesaContext) ctx );
+   XMesaDestroyContext( glxCtx->xmesaContext );
    XMesaGarbageCollect();
 }
 
@@ -1353,8 +1389,9 @@
 static Bool
 Fake_glXIsDirect( Display *dpy, GLXContext ctx )
 {
+   struct fake_glx_context *glxCtx = (struct fake_glx_context *) ctx;
    (void) dpy;
-   return ((XMesaContext) ctx)->direct;
+   return glxCtx->xmesaContext->direct;
 }
 
 
@@ -1373,8 +1410,9 @@
 }
 
 
+
+/*** GLX_MESA_copy_sub_buffer ***/
 
-#ifdef GLX_MESA_copy_sub_buffer
 static void
 Fake_glXCopySubBufferMESA( Display *dpy, GLXDrawable drawable,
                            int x, int y, int width, int height )
@@ -1387,7 +1425,6 @@
       fprintf(stderr, "Mesa Warning: glXCopySubBufferMESA: invalid drawable\n");
    }
 }
-#endif
 
 
 
@@ -1441,7 +1478,7 @@
 	 *value = glxvis->level;
 	 return 0;
       case GLX_RGBA:
-	 if (glxvis->gl_visual->RGBAflag) {
+	 if (glxvis->mesa_visual.rgbMode) {
 	    *value = True;
 	 }
 	 else {
@@ -1449,43 +1486,43 @@
 	 }
 	 return 0;
       case GLX_DOUBLEBUFFER:
-	 *value = (int) glxvis->gl_visual->DBflag;
+	 *value = (int) glxvis->mesa_visual.doubleBufferMode;
 	 return 0;
       case GLX_STEREO:
-	 *value = (int) glxvis->gl_visual->StereoFlag;
+	 *value = (int) glxvis->mesa_visual.stereoMode;
 	 return 0;
       case GLX_AUX_BUFFERS:
 	 *value = (int) False;
 	 return 0;
       case GLX_RED_SIZE:
-         *value = glxvis->gl_visual->RedBits;
+         *value = glxvis->mesa_visual.redBits;
 	 return 0;
       case GLX_GREEN_SIZE:
-         *value = glxvis->gl_visual->GreenBits;
+         *value = glxvis->mesa_visual.greenBits;
 	 return 0;
       case GLX_BLUE_SIZE:
-         *value = glxvis->gl_visual->BlueBits;
+         *value = glxvis->mesa_visual.blueBits;
 	 return 0;
       case GLX_ALPHA_SIZE:
-         *value = glxvis->gl_visual->AlphaBits;
+         *value = glxvis->mesa_visual.alphaBits;
 	 return 0;
       case GLX_DEPTH_SIZE:
-         *value = glxvis->gl_visual->DepthBits;
+         *value = glxvis->mesa_visual.depthBits;
 	 return 0;
       case GLX_STENCIL_SIZE:
-	 *value = glxvis->gl_visual->StencilBits;
+	 *value = glxvis->mesa_visual.stencilBits;
 	 return 0;
       case GLX_ACCUM_RED_SIZE:
-	 *value = glxvis->gl_visual->AccumRedBits;
+	 *value = glxvis->mesa_visual.accumRedBits;
 	 return 0;
       case GLX_ACCUM_GREEN_SIZE:
-	 *value = glxvis->gl_visual->AccumGreenBits;
+	 *value = glxvis->mesa_visual.accumGreenBits;
 	 return 0;
       case GLX_ACCUM_BLUE_SIZE:
-	 *value = glxvis->gl_visual->AccumBlueBits;
+	 *value = glxvis->mesa_visual.accumBlueBits;
 	 return 0;
       case GLX_ACCUM_ALPHA_SIZE:
-         *value = glxvis->gl_visual->AccumAlphaBits;
+         *value = glxvis->mesa_visual.accumAlphaBits;
 	 return 0;
 
       /*
@@ -1508,7 +1545,7 @@
          }
          else if (glxvis->level>0) {
             /* overlay */
-            if (glxvis->gl_visual->RGBAflag) {
+            if (glxvis->mesa_visual.rgbMode) {
                *value = GLX_TRANSPARENT_RGB_EXT;
             }
             else {
@@ -1660,6 +1697,15 @@
  * GLX 1.3 and later
  */
 
+/* XXX Move this when done.
+ * Create an XMesaBuffer as a Pbuffer.
+ * New in Mesa 4.0 but untested.
+ */
+extern XMesaBuffer XMesaCreatePBuffer( XMesaVisual v, XMesaColormap cmap,
+                                    unsigned int width, unsigned int height );
+
+
+
 static GLXFBConfig *
 Fake_glXChooseFBConfig( Display *dpy, int screen,
                         const int *attribList, int *nitems )
@@ -1676,11 +1722,158 @@
 Fake_glXGetFBConfigAttrib( Display *dpy, GLXFBConfig config,
                            int attribute, int *value )
 {
+   XMesaVisual v = NULL; /* XXX Fix this */
    (void) dpy;
    (void) config;
    (void) attribute;
    (void) value;
-   return 0;
+
+   if (!dpy || !config || !value)
+      return -1;
+
+   switch (attribute) {
+      case GLX_FBCONFIG_ID:
+      case GLX_BUFFER_SIZE:
+         if (v->mesa_visual.rgbMode)
+            *value = v->mesa_visual.redBits + v->mesa_visual.greenBits +
+                     v->mesa_visual.blueBits + v->mesa_visual.alphaBits;
+         else
+            *value = v->mesa_visual.indexBits;
+         break;
+      case GLX_LEVEL:
+         *value = v->level;
+         break;
+      case GLX_DOUBLEBUFFER:
+         *value = v->mesa_visual.doubleBufferMode;
+         break;
+      case GLX_STEREO:
+         *value = v->mesa_visual.stereoMode;
+         break;
+      case GLX_AUX_BUFFERS:
+         *value = v->mesa_visual.numAuxBuffers;
+         break;
+      case GLX_RED_SIZE:
+         *value = v->mesa_visual.redBits;
+         break;
+      case GLX_GREEN_SIZE:
+         *value = v->mesa_visual.greenBits;
+         break;
+      case GLX_BLUE_SIZE:
+         *value = v->mesa_visual.blueBits;
+         break;
+      case GLX_ALPHA_SIZE:
+         *value = v->mesa_visual.alphaBits;
+         break;
+      case GLX_DEPTH_SIZE:
+         *value = v->mesa_visual.depthBits;
+         break;
+      case GLX_STENCIL_SIZE:
+         *value = v->mesa_visual.stencilBits;
+         break;
+      case GLX_ACCUM_RED_SIZE:
+         *value = v->mesa_visual.accumRedBits;
+         break;
+      case GLX_ACCUM_GREEN_SIZE:
+         *value = v->mesa_visual.accumGreenBits;
+         break;
+      case GLX_ACCUM_BLUE_SIZE:
+         *value = v->mesa_visual.accumBlueBits;
+         break;
+      case GLX_ACCUM_ALPHA_SIZE:
+         *value = v->mesa_visual.accumAlphaBits;
+         break;
+      case GLX_RENDER_TYPE:
+         *value = 0; /* XXX ??? */
+         break;
+      case GLX_DRAWABLE_TYPE:
+         *value = GLX_PBUFFER_BIT; /* XXX fix? */
+         break;
+      case GLX_X_RENDERABLE:
+         *value = False; /* XXX ??? */
+         break;
+      case GLX_X_VISUAL_TYPE:
+#if defined(__cplusplus) || defined(c_plusplus)
+         switch (v->vishandle->c_class) {
+#else
+         switch (v->vishandle->class) {
+#endif
+            case GrayScale:
+               *value = GLX_GRAY_SCALE;
+               break;
+            case StaticGray:
+               *value = GLX_STATIC_GRAY;
+               break;
+            case StaticColor:
+               *value = GLX_STATIC_COLOR;
+               break;
+            case PseudoColor:
+               *value = GLX_PSEUDO_COLOR;
+               break;
+            case TrueColor:
+               *value = GLX_TRUE_COLOR;
+               break;
+            case DirectColor:
+               *value = GLX_DIRECT_COLOR;
+               break;
+            default:
+               *value = 0;
+         }
+         break;
+      case GLX_CONFIG_CAVEAT:
+         *value = 0; /* XXX ??? */
+         break;
+      case GLX_TRANSPARENT_TYPE:
+         if (v->level == 0) {
+            /* normal planes */
+            *value = GLX_NONE_EXT;
+         }
+         else if (v->level > 0) {
+            /* overlay */
+            if (v->mesa_visual.rgbMode) {
+               *value = GLX_TRANSPARENT_RGB_EXT;
+            }
+            else {
+               *value = GLX_TRANSPARENT_INDEX_EXT;
+            }
+         }
+         else if (v->level < 0) {
+            /* underlay */
+            *value = GLX_NONE_EXT;
+         }
+         break;
+      case GLX_TRANSPARENT_INDEX_VALUE:
+         *value = transparent_pixel( v );
+         break;
+      case GLX_TRANSPARENT_RED_VALUE:
+         *value = 0;  /* not implemented */
+         break;
+      case GLX_TRANSPARENT_GREEN_VALUE:
+         *value = 0;  /* not implemented */
+         break;
+      case GLX_TRANSPARENT_BLUE_VALUE:
+         *value = 0;  /* not implemented */
+         break;
+      case GLX_TRANSPARENT_ALPHA_VALUE:
+         *value = 0;  /* not implemented */
+         break;
+      case GLX_MAX_PBUFFER_WIDTH:
+         *value = DisplayWidth(dpy, v->vishandle->screen);
+         break;
+      case GLX_MAX_PBUFFER_HEIGHT:
+         *value = DisplayHeight(dpy, v->vishandle->screen);
+         break;
+      case GLX_MAX_PBUFFER_PIXELS:
+         *value = DisplayWidth(dpy, v->vishandle->screen) *
+                  DisplayHeight(dpy, v->vishandle->screen);
+         break;
+      case GLX_VISUAL_ID:
+         *value = v->vishandle->visualid;
+         break;
+      default:
+         return GLX_BAD_ATTRIBUTE;
+   }
+
+   return Success;
 }
 
 
@@ -1697,9 +1890,13 @@
 static XVisualInfo *
 Fake_glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config )
 {
-   (void) dpy;
-   (void) config;
-   return 0;
+   if (dpy && config) {
+      XMesaVisual v = (XMesaVisual) config;
+      return v->vishandle;
+   }
+   else {
+      return NULL;
+   }
 }
 
 
@@ -1710,38 +1907,66 @@
    (void) dpy;
    (void) config;
    (void) win;
-   (void) attribList;
-   return 0;
+   (void) attribList;  /* Ignored in GLX 1.3 */
+
+   return win;  /* A hack for now */
 }
 
 
 static void
 Fake_glXDestroyWindow( Display *dpy, GLXWindow window )
 {
-   (void) dpy;
-   (void) window;
-   return;
+   XMesaBuffer b = XMesaFindBuffer(dpy, (XMesaDrawable) window);
+   if (b)
+      XMesaDestroyBuffer(b);
+   /* don't destroy X window */
 }
 
 
+/* XXX untested */
 static GLXPixmap
 Fake_glXCreatePixmap( Display *dpy, GLXFBConfig config, Pixmap pixmap,
                       const int *attribList )
 {
+   XMesaVisual v = (XMesaVisual) config;
+   XVisualInfo *visinfo;
+   XMesaBuffer b;
+
    (void) dpy;
    (void) config;
    (void) pixmap;
-   (void) attribList;
-   return 0;
+   (void) attribList;  /* Ignored in GLX 1.3 */
+
+   if (!dpy || !config || !pixmap)
+      return 0;
+
+   visinfo = v->vishandle;
+
+   v = find_glx_visual( dpy, visinfo );
+   if (!v) {
+      v = create_glx_visual( dpy, visinfo );
+      if (!v) {
+         /* unusable visual */
+         return 0;
+      }
+   }
+
+   b = XMesaCreatePixmapBuffer( v, pixmap, 0 );
+   if (!b) {
+      return 0;
+   }
+
+   return pixmap;
 }
 
 
 static void
 Fake_glXDestroyPixmap( Display *dpy, GLXPixmap pixmap )
 {
-   (void) dpy;
-   (void) pixmap;
-   return;
+   XMesaBuffer b = XMesaFindBuffer(dpy, (XMesaDrawable)pixmap);
+   if (b)
+      XMesaDestroyBuffer(b);
+   /* don't destroy X pixmap */
 }
 
 
@@ -1749,9 +1974,36 @@
 Fake_glXCreatePbuffer( Display *dpy, GLXFBConfig config,
                        const int *attribList )
 {
+   const int *attrib;
+   int width = 0, height = 0;
+   GLboolean useLargest = GL_FALSE, preserveContents = GL_FALSE;
+
    (void) dpy;
    (void) config;
-   (void) attribList;
+
+   for (attrib = attribList; attrib; attrib++) {
+      switch (*attrib) {
+         case GLX_PBUFFER_WIDTH:
+            width = *(++attrib);
+            break;
+         case GLX_PBUFFER_HEIGHT:
+            height = *(++attrib);
+            break;
+         case GLX_PRESERVED_CONTENTS:
+            preserveContents = GL_TRUE; /* ignored */
+            break;
+         case GLX_LARGEST_PBUFFER:
+            useLargest = GL_TRUE; /* ignored */
+            break;
+         default:
+            return 0;
+      }
+   }
+
+   if (width == 0 || height == 0)
+      return 0;
+
+
    return 0;
 }
 
@@ -1770,8 +2022,18 @@
 {
    (void) dpy;
    (void) draw;
-   (void) attribute;
-   (void) value;
+
+   switch (attribute) {
+      case GLX_WIDTH:
+      case GLX_HEIGHT:
+      case GLX_PRESERVED_CONTENTS:
+      case GLX_LARGEST_PBUFFER:
+      case GLX_FBCONFIG_ID:
+         *value = 0;
+         return;
+      default:
+         return;  /* GLX_BAD_ATTRIBUTE? */
+   }
 }
 
 
@@ -1779,28 +2041,267 @@
 Fake_glXCreateNewContext( Display *dpy, GLXFBConfig config,
                           int renderType, GLXContext shareList, Bool direct )
 {
+   XMesaVisual v = (XMesaVisual) config;
+
+   if (!dpy || !config ||
+       (renderType != GLX_RGBA_TYPE && renderType != GLX_COLOR_INDEX_TYPE))
+      return 0;
+
+   return Fake_glXCreateContext(dpy, v->vishandle, shareList, direct);
+}
+
+
+static int
+Fake_glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value )
+{
+   (void) dpy;
+   (void) ctx;
+
+   switch (attribute) {
+   case GLX_FBCONFIG_ID:
+   case GLX_RENDER_TYPE:
+   case GLX_SCREEN:
+      *value = 0;
+      return Success;
+   default:
+      return GLX_BAD_ATTRIBUTE;
+   }
+}
+
+
+static void
+Fake_glXSelectEvent( Display *dpy, GLXDrawable drawable, unsigned long mask )
+{
+   (void) dpy;
+   (void) drawable;
+   (void) mask;
+}
+
+
+static void
+Fake_glXGetSelectedEvent( Display *dpy, GLXDrawable drawable,
+                          unsigned long *mask )
+{
+   (void) dpy;
+   (void) drawable;
+   (void) mask;
+}
+
+
+
+/*** GLX_SGI_swap_control ***/
+
+static int
+Fake_glXSwapIntervalSGI(int interval)
+{
+   (void) interval;
+   return 0;
+}
+
+
+
+/*** GLX_SGI_video_sync ***/
+
+static int
+Fake_glXGetVideoSyncSGI(unsigned int *count)
+{
+   (void) count;
+   return 0;
+}
+
+static int
+Fake_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+{
+   (void) divisor;
+   (void) remainder;
+   (void) count;
+   return 0;
+}
+
+
+
+/*** GLX_SGI_make_current_read ***/
+
+static Bool
+Fake_glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
+{
+   (void) dpy;
+   (void) draw;
+   (void) read;
+   (void) ctx;
+   return False;
+}
+
+/* not used
+static GLXDrawable
+Fake_glXGetCurrentReadDrawableSGI(void)
+{
+   return 0;
+}
+*/
+
+
+/*** GLX_SGIX_video_source ***/
+#if defined(_VL_H)
+
+static GLXVideoSourceSGIX
+Fake_glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode)
+{
+   (void) dpy;
+   (void) screen;
+   (void) server;
+   (void) path;
+   (void) nodeClass;
+   (void) drainNode;
+   return 0;
+}
+
+static void
+Fake_glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src)
+{
+   (void) dpy;
+   (void) src;
+}
+
+#endif
+
+
+/*** GLX_EXT_import_context ***/
+
+static void
+Fake_glXFreeContextEXT(Display *dpy, GLXContext context)
+{
+   (void) dpy;
+   (void) context;
+}
+
+static GLXContextID
+Fake_glXGetContextIDEXT(const GLXContext context)
+{
+   (void) context;
+   return 0;
+}
+
+static GLXContext
+Fake_glXImportContextEXT(Display *dpy, GLXContextID contextID)
+{
+   (void) dpy;
+   (void) contextID;
+   return 0;
+}
+
+static int
+Fake_glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, int *value)
+{
+   (void) dpy;
+   (void) context;
+   (void) attribute;
+   (void) value;
+   return 0;
+}
+
+
+
+/*** GLX_SGIX_fbconfig ***/
+
+static int
+Fake_glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value)
+{
+   (void) dpy;
+   (void) config;
+   (void) attribute;
+   (void) value;
+   return 0;
+}
+
+static GLXFBConfigSGIX *
+Fake_glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements)
+{
+   (void) dpy;
+   (void) screen;
+   (void) attrib_list;
+   (void) nelements;
+   return 0;
+}
+
+static GLXPixmap
+Fake_glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap)
+{
+   (void) dpy;
+   (void) config;
+   (void) pixmap;
+   return 0;
+}
+
+static GLXContext
+Fake_glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct)
+{
    (void) dpy;
    (void) config;
-   (void) renderType;
-   (void) shareList;
+   (void) render_type;
+   (void) share_list;
    (void) direct;
    return 0;
 }
 
+static XVisualInfo *
+Fake_glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config)
+{
+   (void) dpy;
+   (void) config;
+   return NULL;
+}
+
+static GLXFBConfigSGIX
+Fake_glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
+{
+   (void) dpy;
+   (void) vis;
+   return 0;
+}
+
 
+
+/*** GLX_SGIX_pbuffer ***/
+
+static GLXPbufferSGIX
+Fake_glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list)
+{
+   (void) dpy;
+   (void) config;
+   (void) width;
+   (void) height;
+   (void) attrib_list;
+   return 0;
+}
+
+static void
+Fake_glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf)
+{
+   (void) dpy;
+   (void) pbuf;
+}
+
 static int
-Fake_glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value )
+Fake_glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value)
 {
    (void) dpy;
-   (void) ctx;
+   (void) pbuf;
    (void) attribute;
    (void) value;
    return 0;
 }
 
+static void
+Fake_glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask)
+{
+   (void) dpy;
+   (void) drawable;
+   (void) mask;
+}
 
 static void
-Fake_glXSelectEvent( Display *dpy, GLXDrawable drawable, unsigned long mask )
+Fake_glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask)
 {
    (void) dpy;
    (void) drawable;
@@ -1808,18 +2309,146 @@
 }
 
 
+
+/*** GLX_SGI_cushion ***/
+
 static void
-Fake_glXGetSelectedEvent( Display *dpy, GLXDrawable drawable,
-                          unsigned long *mask )
+Fake_glXCushionSGI(Display *dpy, Window win, float cushion)
+{
+   (void) dpy;
+   (void) win;
+   (void) cushion;
+}
+
+
+
+/*** GLX_SGIX_video_resize ***/
+
+static int
+Fake_glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) window;
+   return 0;
+}
+
+static int
+Fake_glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) x;
+   (void) y;
+   (void) w;
+   (void) h;
+   return 0;
+}
+
+static int
+Fake_glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) x;
+   (void) y;
+   (void) w;
+   (void) h;
+   return 0;
+}
+
+static int
+Fake_glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh)
 {
    (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) dx;
+   (void) dy;
+   (void) dw;
+   (void) dh;
+   return 0;
+}
+
+static int
+Fake_glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) synctype;
+   return 0;
+}
+
+
+
+/*** GLX_SGIX_dmbuffer **/
+
+#if defined(_DM_BUFFER_H_)
+static Bool
+Fake_glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer)
+{
+   (void) dpy;
+   (void) pbuffer;
+   (void) params;
+   (void) dmbuffer;
+   return False;
+}
+#endif
+
+
+/*** GLX_SGIX_swap_group ***/
+
+static void
+Fake_glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member)
+{
+   (void) dpy;
    (void) drawable;
-   (void) mask;
+   (void) member;
+}
+
+
+
+/*** GLX_SGIX_swap_barrier ***/
+
+static void
+Fake_glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier)
+{
+   (void) dpy;
+   (void) drawable;
+   (void) barrier;
+}
+
+static Bool
+Fake_glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max)
+{
+   (void) dpy;
+   (void) screen;
+   (void) max;
+   return False;
+}
+
+
+
+/*** GLX_SUN_get_transparent_index ***/
+
+static Status
+Fake_glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent)
+{
+   (void) dpy;
+   (void) overlay;
+   (void) underlay;
+   (void) pTransparent;
+   return 0;
 }
 
 
 
-#ifdef GLX_MESA_release_buffers
+/*** GLX_MESA_release_buffers ***/
+
 /*
  * Release the depth, stencil, accum buffers attached to a GLXDrawable
  * (a window or pixmap) prior to destroying the GLXDrawable.
@@ -1834,42 +2463,47 @@
    }
    return False;
 }
-#endif
 
 
 
-#ifdef GLX_MESA_set_3dfx_mode
-static GLboolean
-Fake_glXSet3DfxModeMESA( GLint mode )
+/*** GLX_MESA_set_3dfx_mode ***/
+
+static Bool
+Fake_glXSet3DfxModeMESA( int mode )
 {
    return XMesaSetFXmode( mode );
 }
-#endif
 
 
 
-/*
- * GLX_SGI_video_sync
- */
+/*** AGP memory allocation ***/
+static void *
+Fake_glXAllocateMemoryNV( GLsizei size,
+                          GLfloat readFrequency,
+                          GLfloat writeFrequency,
+                          GLfloat priority )
+{
+   (void) size;
+   (void) readFrequency;
+   (void) writeFrequency;
+   (void) priority;
+   return NULL;
+}
 
-#ifdef GLX_SGI_video_sync
 
-static int
-Fake_glXGetVideoSyncSGI(unsigned int *count)
+static void 
+Fake_glXFreeMemoryNV( GLvoid *pointer )
 {
-   return 0;
+   (void) pointer;
 }
 
 
-static int
-Fake_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+static GLuint
+Fake_glXGetAGPOffsetMESA( const GLvoid *pointer )
 {
-   return 0;
+   return ~0;
 }
 
-#endif
-
-
 
 extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void);
 struct _glxapi_table *_mesa_GetGLXDispatchTable(void)
@@ -1878,9 +2512,9 @@
 
    /* be sure our dispatch table size <= libGL's table */
    {
-      int size = sizeof(struct _glxapi_table) / sizeof(void *);
+      GLuint size = sizeof(struct _glxapi_table) / sizeof(void *);
       (void) size;
-      assert((GLint) _glxapi_get_dispatch_table_size() >= size);
+      assert(_glxapi_get_dispatch_table_size() >= size);
    }
 
    /* initialize the whole table to no-ops */
@@ -1905,17 +2539,15 @@
    glx.WaitGL = Fake_glXWaitGL;
    glx.WaitX = Fake_glXWaitX;
 
-#ifdef GLX_VERSION_1_1
+   /*** GLX_VERSION_1_1 ***/
    glx.GetClientString = Fake_glXGetClientString;
    glx.QueryExtensionsString = Fake_glXQueryExtensionsString;
    glx.QueryServerString = Fake_glXQueryServerString;
-#endif
 
-#ifdef GLX_VERSION_1_2
+   /*** GLX_VERSION_1_2 ***/
    /*glx.GetCurrentDisplay = Fake_glXGetCurrentDisplay;*/
-#endif
 
-#ifdef GLX_VERSION_1_3
+   /*** GLX_VERSION_1_3 ***/
    glx.ChooseFBConfig = Fake_glXChooseFBConfig;
    glx.CreateNewContext = Fake_glXCreateNewContext;
    glx.CreatePbuffer = Fake_glXCreatePbuffer;
@@ -1933,28 +2565,89 @@
    glx.QueryContext = Fake_glXQueryContext;
    glx.QueryDrawable = Fake_glXQueryDrawable;
    glx.SelectEvent = Fake_glXSelectEvent;
-#endif
 
-#ifdef GLX_SGI_video_sync
+   /*** GLX_SGI_swap_control ***/
+   glx.SwapIntervalSGI = Fake_glXSwapIntervalSGI;
+
+   /*** GLX_SGI_video_sync ***/
    glx.GetVideoSyncSGI = Fake_glXGetVideoSyncSGI;
    glx.WaitVideoSyncSGI = Fake_glXWaitVideoSyncSGI;
+
+   /*** GLX_SGI_make_current_read ***/
+   glx.MakeCurrentReadSGI = Fake_glXMakeCurrentReadSGI;
+   /*glx.GetCurrentReadDrawableSGI = Fake_glXGetCurrentReadDrawableSGI;*/
+
+/*** GLX_SGIX_video_source ***/
+#if defined(_VL_H)
+   glx.CreateGLXVideoSourceSGIX = Fake_glXCreateGLXVideoSourceSGIX;
+   glx.DestroyGLXVideoSourceSGIX = Fake_glXDestroyGLXVideoSourceSGIX;
 #endif
 
-#ifdef GLX_MESA_copy_sub_buffer
-   glx.CopySubBufferMESA = Fake_glXCopySubBufferMESA;
+   /*** GLX_EXT_import_context ***/
+   glx.FreeContextEXT = Fake_glXFreeContextEXT;
+   glx.GetContextIDEXT = Fake_glXGetContextIDEXT;
+   /*glx.GetCurrentDisplayEXT = Fake_glXGetCurrentDisplayEXT;*/
+   glx.ImportContextEXT = Fake_glXImportContextEXT;
+   glx.QueryContextInfoEXT = Fake_glXQueryContextInfoEXT;
+
+   /*** GLX_SGIX_fbconfig ***/
+   glx.GetFBConfigAttribSGIX = Fake_glXGetFBConfigAttribSGIX;
+   glx.ChooseFBConfigSGIX = Fake_glXChooseFBConfigSGIX;
+   glx.CreateGLXPixmapWithConfigSGIX = Fake_glXCreateGLXPixmapWithConfigSGIX;
+   glx.CreateContextWithConfigSGIX = Fake_glXCreateContextWithConfigSGIX;
+   glx.GetVisualFromFBConfigSGIX = Fake_glXGetVisualFromFBConfigSGIX;
+   glx.GetFBConfigFromVisualSGIX = Fake_glXGetFBConfigFromVisualSGIX;
+
+   /*** GLX_SGIX_pbuffer ***/
+   glx.CreateGLXPbufferSGIX = Fake_glXCreateGLXPbufferSGIX;
+   glx.DestroyGLXPbufferSGIX = Fake_glXDestroyGLXPbufferSGIX;
+   glx.QueryGLXPbufferSGIX = Fake_glXQueryGLXPbufferSGIX;
+   glx.SelectEventSGIX = Fake_glXSelectEventSGIX;
+   glx.GetSelectedEventSGIX = Fake_glXGetSelectedEventSGIX;
+
+   /*** GLX_SGI_cushion ***/
+   glx.CushionSGI = Fake_glXCushionSGI;
+
+   /*** GLX_SGIX_video_resize ***/
+   glx.BindChannelToWindowSGIX = Fake_glXBindChannelToWindowSGIX;
+   glx.ChannelRectSGIX = Fake_glXChannelRectSGIX;
+   glx.QueryChannelRectSGIX = Fake_glXQueryChannelRectSGIX;
+   glx.QueryChannelDeltasSGIX = Fake_glXQueryChannelDeltasSGIX;
+   glx.ChannelRectSyncSGIX = Fake_glXChannelRectSyncSGIX;
+
+   /*** GLX_SGIX_dmbuffer **/
+#if defined(_DM_BUFFER_H_)
+   glx.AssociateDMPbufferSGIX = NULL;
 #endif
+
+   /*** GLX_SGIX_swap_group ***/
+   glx.JoinSwapGroupSGIX = Fake_glXJoinSwapGroupSGIX;
 
-#ifdef GLX_MESA_release_buffers
+   /*** GLX_SGIX_swap_barrier ***/
+   glx.BindSwapBarrierSGIX = Fake_glXBindSwapBarrierSGIX;
+   glx.QueryMaxSwapBarriersSGIX = Fake_glXQueryMaxSwapBarriersSGIX;
+
+   /*** GLX_SUN_get_transparent_index ***/
+   glx.GetTransparentIndexSUN = Fake_glXGetTransparentIndexSUN;
+
+   /*** GLX_MESA_copy_sub_buffer ***/
+   glx.CopySubBufferMESA = Fake_glXCopySubBufferMESA;
+
+   /*** GLX_MESA_release_buffers ***/
    glx.ReleaseBuffersMESA = Fake_glXReleaseBuffersMESA;
-#endif
 
-#ifdef GLX_MESA_pixmap_colormap
+   /*** GLX_MESA_pixmap_colormap ***/
    glx.CreateGLXPixmapMESA = Fake_glXCreateGLXPixmapMESA;
-#endif
 
-#ifdef GLX_MESA_set_3dfx_mode
+   /*** GLX_MESA_set_3dfx_mode ***/
    glx.Set3DfxModeMESA = Fake_glXSet3DfxModeMESA;
-#endif
+
+   /*** GLX_NV_vertex_array_range ***/
+   glx.AllocateMemoryNV = Fake_glXAllocateMemoryNV;
+   glx.FreeMemoryNV = Fake_glXFreeMemoryNV;
+
+   /*** GLX_MESA_agp_offset ***/
+   glx.GetAGPOffsetMESA = Fake_glXGetAGPOffsetMESA;
 
    return &glx;
 }
Index: xc/extras/Mesa/src/X/glxapi.c
diff -u xc/extras/Mesa/src/X/glxapi.c:1.5 xc/extras/Mesa/src/X/glxapi.c:1.9
--- xc/extras/Mesa/src/X/glxapi.c:1.5	Fri Jun 16 20:02:38 2000
+++ xc/extras/Mesa/src/X/glxapi.c	Mon Dec 16 11:18:30 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  4.0.4
  * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -26,37 +26,23 @@
 
 /*
  * This is the GLX API dispatcher.  Calls to the glX* functions are
- * either routed to real (SGI / Utah) GLX encoders or to Mesa's
- * pseudo-GLX module.
+ * either routed to the real GLX encoders or to Mesa's pseudo-GLX functions.
+ * See the glxapi.h file for more details.
  */
 
 
 #include <assert.h>
 #include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
 #include "glapi.h"
 #include "glxapi.h"
 
 
-/*
- * XXX - this really shouldn't be here.
- * Instead, add -DUSE_MESA_GLX to the compiler flags when needed.
- */
-#define USE_MESA_GLX 1
-
-
-/* Rather than include possibly non-existant headers... */
-#ifdef USE_SGI_GLX
-extern struct _glxapi_table *_sgi_GetGLXDispatchtable(void);
-#endif
-#ifdef USE_UTAH_GLX
-extern struct _glxapi_table *_utah_GetGLXDispatchTable(void);
-#endif
-#ifdef USE_MESA_GLX
+extern struct _glxapi_table *_real_GetGLXDispatchTable(void);
 extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void);
-#endif
 
 
-
 struct display_dispatch {
    Display *Dpy;
    struct _glxapi_table *Table;
@@ -66,20 +52,17 @@
 static struct display_dispatch *DispatchList = NULL;
 
 
+/* Display -> Dispatch caching */
+static Display *prevDisplay = NULL;
+static struct _glxapi_table *prevTable = NULL;
+
+
 static struct _glxapi_table *
 get_dispatch(Display *dpy)
 {
-   static Display *prevDisplay = NULL;
-   static struct _glxapi_table *prevTable = NULL;
-
    if (!dpy)
       return NULL;
 
-   /* try cached display */
-   if (dpy == prevDisplay) {
-      return prevTable;
-   }
-
    /* search list of display/dispatch pairs for this display */
    {
       const struct display_dispatch *d = DispatchList;
@@ -93,32 +76,35 @@
       }
    }
 
-   /* A new display, determine if we should use real GLX (SGI / Utah)
+   /* A new display, determine if we should use real GLX
     * or Mesa's pseudo-GLX.
     */
    {
       struct _glxapi_table *t = NULL;
 
-#if defined(USE_SGI_GLX) || defined(USE_UTAH_GLX)
-      if (!getenv("MESA_FORCE_SOFTX")) {
+#ifdef GLX_BUILT_IN_XMESA
+      if (!getenv("LIBGL_FORCE_XMESA")) {
          int ignore;
          if (XQueryExtension( dpy, "GLX", &ignore, &ignore, &ignore )) {
             /* the X server has the GLX extension */
-#if defined(USE_SGI_GLX)
-            t = _sgi_GetGLXDispatchtable();
-#elif defined(USE_UTAH_GLX)
-            t = _utah_GetGLXDispatchTable();
-#endif
+            t = _real_GetGLXDispatchTable();
          }
       }
 #endif
 
-#if defined(USE_MESA_GLX)
       if (!t) {
+         /* Fallback to Mesa with Xlib driver */
+#ifdef GLX_BUILT_IN_XMESA
+         if (getenv("LIBGL_DEBUG")) {
+            fprintf(stderr,
+                    "libGL: server %s lacks the GLX extension.",
+                    dpy->display_name);
+            fprintf(stderr, " Using Mesa Xlib renderer.\n");
+         }
+#endif
          t = _mesa_GetGLXDispatchTable();
          assert(t);  /* this has to work */
       }
-#endif
 
       if (t) {
          struct display_dispatch *d;
@@ -145,23 +131,37 @@
 }
 
 
+#define GET_DISPATCH(DPY, TABLE)	\
+   if (DPY == prevDisplay) {		\
+      TABLE = prevTable;		\
+   }					\
+   else if (!DPY) {			\
+      TABLE = NULL;			\
+   }					\
+   else {				\
+      TABLE = get_dispatch(DPY);	\
+   }
+
+   
+
 
 /* Set by glXMakeCurrent() and glXMakeContextCurrent() only */
-static Display *CurrentDisplay = NULL;
+#ifndef GLX_BUILT_IN_XMESA
 static GLXContext CurrentContext = 0;
-static GLXDrawable CurrentDrawable = 0;
-static GLXDrawable CurrentReadDrawable = 0;
-
+#define __glXGetCurrentContext() CurrentContext;
+#endif
 
 
 /*
  * GLX API entrypoints
  */
 
+/*** GLX_VERSION_1_0 ***/
 
 XVisualInfo *glXChooseVisual(Display *dpy, int screen, int *list)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return NULL;
    return (t->ChooseVisual)(dpy, screen, list);
@@ -170,7 +170,8 @@
 
 void glXCopyContext(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->CopyContext)(dpy, src, dst, mask);
@@ -179,7 +180,8 @@
 
 GLXContext glXCreateContext(Display *dpy, XVisualInfo *visinfo, GLXContext shareList, Bool direct)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->CreateContext)(dpy, visinfo, shareList, direct);
@@ -188,7 +190,8 @@
 
 GLXPixmap glXCreateGLXPixmap(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->CreateGLXPixmap)(dpy, visinfo, pixmap);
@@ -197,7 +200,8 @@
 
 void glXDestroyContext(Display *dpy, GLXContext ctx)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->DestroyContext)(dpy, ctx);
@@ -206,7 +210,8 @@
 
 void glXDestroyGLXPixmap(Display *dpy, GLXPixmap pixmap)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->DestroyGLXPixmap)(dpy, pixmap);
@@ -215,28 +220,41 @@
 
 int glXGetConfig(Display *dpy, XVisualInfo *visinfo, int attrib, int *value)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return GLX_NO_EXTENSION;
    return (t->GetConfig)(dpy, visinfo, attrib, value);
 }
 
 
+#ifdef GLX_BUILT_IN_XMESA
+/* Use real libGL's glXGetCurrentContext() function */
+#else
+/* stand-alone Mesa */
 GLXContext glXGetCurrentContext(void)
 {
    return CurrentContext;
 }
+#endif
 
 
+#ifdef GLX_BUILT_IN_XMESA
+/* Use real libGL's glXGetCurrentContext() function */
+#else
+/* stand-alone Mesa */
 GLXDrawable glXGetCurrentDrawable(void)
 {
-   return CurrentDrawable;
+   __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext();
+   return gc ? gc->currentDrawable : 0;
 }
+#endif
 
 
 Bool glXIsDirect(Display *dpy, GLXContext ctx)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return False;
    return (t->IsDirect)(dpy, ctx);
@@ -246,23 +264,25 @@
 Bool glXMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx)
 {
    Bool b;
-   struct _glxapi_table *t = get_dispatch(dpy);
-   if (!t)
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t) {
       return False;
+   }
    b = (*t->MakeCurrent)(dpy, drawable, ctx);
+#ifndef  GLX_BUILT_IN_XMESA
    if (b) {
-      CurrentDisplay = dpy;
       CurrentContext = ctx;
-      CurrentDrawable = drawable;
-      CurrentReadDrawable = drawable;
    }
+#endif
    return b;
 }
 
 
 Bool glXQueryExtension(Display *dpy, int *errorb, int *event)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return False;
    return (t->QueryExtension)(dpy, errorb, event);
@@ -271,7 +291,8 @@
 
 Bool glXQueryVersion(Display *dpy, int *maj, int *min)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return False;
    return (t->QueryVersion)(dpy, maj, min);
@@ -280,7 +301,8 @@
 
 void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->SwapBuffers)(dpy, drawable);
@@ -289,7 +311,9 @@
 
 void glXUseXFont(Font font, int first, int count, int listBase)
 {
-   struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->UseXFont)(font, first, count, listBase);
@@ -298,7 +322,9 @@
 
 void glXWaitGL(void)
 {
-   struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->WaitGL)();
@@ -307,7 +333,9 @@
 
 void glXWaitX(void)
 {
-   struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->WaitX)();
@@ -315,11 +343,12 @@
 
 
 
-#ifdef GLX_VERSION_1_1
+/*** GLX_VERSION_1_1 ***/
 
 const char *glXGetClientString(Display *dpy, int name)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return NULL;
    return (t->GetClientString)(dpy, name);
@@ -328,7 +357,8 @@
 
 const char *glXQueryExtensionsString(Display *dpy, int screen)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return NULL;
    return (t->QueryExtensionsString)(dpy, screen);
@@ -337,30 +367,34 @@
 
 const char *glXQueryServerString(Display *dpy, int screen, int name)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return NULL;
    return (t->QueryServerString)(dpy, screen, name);
 }
 
-#endif
-
 
+/*** GLX_VERSION_1_2 ***/
 
-#ifdef GLX_VERSION_1_2
+#if !defined(GLX_BUILT_IN_XMESA)
 Display *glXGetCurrentDisplay(void)
 {
-   return CurrentDisplay;
+   /* Same code as in libGL's glxext.c */
+   __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext();
+   if (NULL == gc) return NULL;
+   return gc->currentDpy;
 }
 #endif
 
 
 
-#ifdef GLX_VERSION_1_3
+/*** GLX_VERSION_1_3 ***/
 
 GLXFBConfig *glXChooseFBConfig(Display *dpy, int screen, const int *attribList, int *nitems)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->ChooseFBConfig)(dpy, screen, attribList, nitems);
@@ -369,7 +403,8 @@
 
 GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->CreateNewContext)(dpy, config, renderType, shareList, direct);
@@ -378,7 +413,8 @@
 
 GLXPbuffer glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->CreatePbuffer)(dpy, config, attribList);
@@ -387,7 +423,8 @@
 
 GLXPixmap glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attribList)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->CreatePixmap)(dpy, config, pixmap, attribList);
@@ -396,7 +433,8 @@
 
 GLXWindow glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, const int *attribList)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->CreateWindow)(dpy, config, win, attribList);
@@ -405,7 +443,8 @@
 
 void glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->DestroyPbuffer)(dpy, pbuf);
@@ -414,7 +453,8 @@
 
 void glXDestroyPixmap(Display *dpy, GLXPixmap pixmap)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->DestroyPixmap)(dpy, pixmap);
@@ -423,22 +463,29 @@
 
 void glXDestroyWindow(Display *dpy, GLXWindow window)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->DestroyWindow)(dpy, window);
 }
 
 
+#ifdef GLX_BUILT_IN_XMESA
+/* Use the glXGetCurrentReadDrawable() function from libGL */
+#else
 GLXDrawable glXGetCurrentReadDrawable(void)
 {
-   return CurrentReadDrawable;
+   __GLXcontext *gc = (__GLXcontext *) glXGetCurrentContext();
+   return gc ? gc->currentReadable : 0;
 }
+#endif
 
 
 int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, int attribute, int *value)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return GLX_NO_EXTENSION;
    return (t->GetFBConfigAttrib)(dpy, config, attribute, value);
@@ -447,7 +494,8 @@
 
 GLXFBConfig *glXGetFBConfigs(Display *dpy, int screen, int *nelements)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->GetFBConfigs)(dpy, screen, nelements);
@@ -455,7 +503,8 @@
 
 void glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->GetSelectedEvent)(dpy, drawable, mask);
@@ -464,7 +513,8 @@
 
 XVisualInfo *glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return NULL;
    return (t->GetVisualFromFBConfig)(dpy, config);
@@ -473,24 +523,25 @@
 
 Bool glXMakeContextCurrent(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
    Bool b;
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return False;
    b = (t->MakeContextCurrent)(dpy, draw, read, ctx);
+#ifndef GLX_BUILT_IN_XMESA
    if (b) {
-      CurrentDisplay = dpy;
       CurrentContext = ctx;
-      CurrentDrawable = draw;
-      CurrentReadDrawable = read;
    }
+#endif
    return b;
 }
 
 
 int glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    assert(t);
    if (!t)
       return 0; /* XXX correct? */
@@ -500,7 +551,8 @@
 
 void glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->QueryDrawable)(dpy, draw, attribute, value);
@@ -509,45 +561,133 @@
 
 void glXSelectEvent(Display *dpy, GLXDrawable drawable, unsigned long mask)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->SelectEvent)(dpy, drawable, mask);
 }
 
-#endif /* GLX_VERSION_1_3 */
 
 
-#ifdef GLX_EXT_import_context
+/*** GLX_SGI_swap_control ***/
 
-void glXFreeContextEXT(Display *dpy, GLXContext context)
+int glXSwapIntervalSGI(int interval)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
    if (!t)
-      return;
-   (t->FreeContextEXT)(dpy, context);
+      return 0;
+   return (t->SwapIntervalSGI)(interval);
 }
 
 
-GLXContextID glXGetContextIDEXT(const GLXContext context)
+
+/*** GLX_SGI_video_sync ***/
+
+int glXGetVideoSyncSGI(unsigned int *count)
 {
-   /* XXX is this function right? */
-   struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
-   return (t->GetContextIDEXT)(context);
+   return (t->GetVideoSyncSGI)(count);
 }
 
+int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+{
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->WaitVideoSyncSGI)(divisor, remainder, count);
+}
 
-Display *glXGetCurrentDisplayEXT(void)
+
+
+/*** GLX_SGI_make_current_read ***/
+
+Bool glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->MakeCurrentReadSGI)(dpy, draw, read, ctx);
+}
+
+#ifdef GLX_BUILT_IN_XMESA
+/* Use glXGetCurrentReadDrawableSGI() from libGL */
+#else
+/* stand-alone Mesa */
+GLXDrawable glXGetCurrentReadDrawableSGI(void)
+{
+   return glXGetCurrentReadDrawable();
+}
+#endif
+
+
+#if defined(_VL_H)
+
+GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->CreateGLXVideoSourceSGIX)(dpy, screen, server, path, nodeClass, drainNode);
+}
+
+void glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src)
 {
-   return CurrentDisplay;
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->DestroyGLXVideoSourceSGIX)(dpy, src);
+}
+
+#endif
+
+
+/*** GLX_EXT_import_context ***/
+
+void glXFreeContextEXT(Display *dpy, GLXContext context)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (t->FreeContextEXT)(dpy, context);
+}
+
+#ifdef GLX_BUILT_IN_XMESA
+/* Use real libGL's glXGetContextIDEXT() function */
+#else
+/* stand-alone Mesa */
+GLXContextID glXGetContextIDEXT(const GLXContext context)
+{
+   return ((__GLXcontext *) context)->xid;
 }
+#endif
 
+#ifdef GLX_BUILT_IN_XMESA
+/* Use real libGL's glXGetCurrentDisplayEXT() function */
+#else
+/* stand-alone Mesa */
+Display *glXGetCurrentDisplayEXT(void)
+{
+   return glXGetCurrentDisplay();
+}
+#endif
 
 GLXContext glXImportContextEXT(Display *dpy, GLXContextID contextID)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->ImportContextEXT)(dpy, contextID);
@@ -555,90 +695,342 @@
 
 int glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute,int *value)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;  /* XXX ok? */
    return (t->QueryContextInfoEXT)(dpy, context, attribute, value);
 }
 
-#endif
 
 
-#ifdef GLX_SGI_video_sync
+/*** GLX_SGIX_fbconfig ***/
 
-int glXGetVideoSyncSGI(unsigned int *count)
+int glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value)
 {
-   struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
-   return (t->GetVideoSyncSGI)(count);
+   return (t->GetFBConfigAttribSGIX)(dpy, config, attribute, value);
 }
 
+GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->ChooseFBConfigSGIX)(dpy, screen, attrib_list, nelements);
+}
 
-int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap)
 {
-   struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
-   return (t->WaitVideoSyncSGI)(divisor, remainder, count);
+   return (t->CreateGLXPixmapWithConfigSGIX)(dpy, config, pixmap);
+}
+
+GLXContext glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->CreateContextWithConfigSGIX)(dpy, config, render_type, share_list, direct);
+}
+
+XVisualInfo * glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->GetVisualFromFBConfigSGIX)(dpy, config);
+}
+
+GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->GetFBConfigFromVisualSGIX)(dpy, vis);
+}
+
+
+
+/*** GLX_SGIX_pbuffer ***/
+
+GLXPbufferSGIX glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->CreateGLXPbufferSGIX)(dpy, config, width, height, attrib_list);
+}
+
+void glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (t->DestroyGLXPbufferSGIX)(dpy, pbuf);
+}
+
+int glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->QueryGLXPbufferSGIX)(dpy, pbuf, attribute, value);
+}
+
+void glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (t->SelectEventSGIX)(dpy, drawable, mask);
+}
+
+void glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (t->GetSelectedEventSGIX)(dpy, drawable, mask);
+}
+
+
+
+/*** GLX_SGI_cushion ***/
+
+void glXCushionSGI(Display *dpy, Window win, float cushion)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (t->CushionSGI)(dpy, win, cushion);
+}
+
+
+
+/*** GLX_SGIX_video_resize ***/
+
+int glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->BindChannelToWindowSGIX)(dpy, screen, channel, window);
+}
+
+int glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->ChannelRectSGIX)(dpy, screen, channel, x, y, w, h);
+}
+
+int glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->QueryChannelRectSGIX)(dpy, screen, channel, x, y, w, h);
 }
 
+int glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->QueryChannelDeltasSGIX)(dpy, screen, channel, dx, dy, dw, dh);
+}
+
+int glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return 0;
+   return (t->ChannelRectSyncSGIX)(dpy, screen, channel, synctype);
+}
+
+
+
+#if defined(_DM_BUFFER_H_)
+
+Bool glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return False;
+   return (t->AssociateDMPbufferSGIX)(dpy, pbuffer, params, dmbuffer);
+}
+
 #endif
 
 
-#ifdef GLX_MESA_copy_sub_buffer
+/*** GLX_SGIX_swap_group ***/
+
+void glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (*t->JoinSwapGroupSGIX)(dpy, drawable, member);
+}
+
+
+/*** GLX_SGIX_swap_barrier ***/
+
+void glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (*t->BindSwapBarrierSGIX)(dpy, drawable, barrier);
+}
+
+Bool glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return False;
+   return (*t->QueryMaxSwapBarriersSGIX)(dpy, screen, max);
+}
+
+
 
+/*** GLX_SUN_get_transparent_index ***/
+
+Status glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent)
+{
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return False;
+   return (*t->GetTransparentIndexSUN)(dpy, overlay, underlay, pTransparent);
+}
+
+
+
+/*** GLX_MESA_copy_sub_buffer ***/
+
 void glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return;
    (t->CopySubBufferMESA)(dpy, drawable, x, y, width, height);
 }
 
-#endif
 
 
-#ifdef GLX_MESA_release_buffers
+/*** GLX_MESA_release_buffers ***/
 
 Bool glXReleaseBuffersMESA(Display *dpy, Window w)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return False;
    return (t->ReleaseBuffersMESA)(dpy, w);
 }
 
-#endif
 
 
-#ifdef GLX_MESA_pixmap_colormap
+/*** GLX_MESA_pixmap_colormap ***/
 
 GLXPixmap glXCreateGLXPixmapMESA(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap, Colormap cmap)
 {
-   struct _glxapi_table *t = get_dispatch(dpy);
+   struct _glxapi_table *t;
+   GET_DISPATCH(dpy, t);
    if (!t)
       return 0;
    return (t->CreateGLXPixmapMESA)(dpy, visinfo, pixmap, cmap);
 }
 
-#endif
 
 
-#ifdef GLX_MESA_set_3dfx_mode
+/*** GLX_MESA_set_3dfx_mode ***/
 
-GLboolean glXSet3DfxModeMESA(GLint mode)
+Bool glXSet3DfxModeMESA(int mode)
 {
-   struct _glxapi_table *t = get_dispatch(CurrentDisplay);
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
    if (!t)
       return False;
    return (t->Set3DfxModeMESA)(mode);
 }
 
-#endif
 
 
 
+/*** GLX_NV_vertex_array_range ***/
+
+void *
+glXAllocateMemoryNV( GLsizei size,
+                     GLfloat readFrequency,
+                     GLfloat writeFrequency,
+                     GLfloat priority )
+{
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return NULL;
+   return (t->AllocateMemoryNV)(size, readFrequency, writeFrequency, priority);
+}
+
+
+void 
+glXFreeMemoryNV( GLvoid *pointer )
+{
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return;
+   (t->FreeMemoryNV)(pointer);
+}
+
+
+/*** GLX_MESA_agp_offset */
+
+GLuint
+glXGetAGPOffsetMESA( const GLvoid *pointer )
+{
+   struct _glxapi_table *t;
+   Display *dpy = glXGetCurrentDisplay();
+   GET_DISPATCH(dpy, t);
+   if (!t)
+      return ~0;
+   return (t->GetAGPOffsetMESA)(pointer);
+}
+
+
 /**********************************************************************/
 /* GLX API management functions                                       */
 /**********************************************************************/
@@ -714,13 +1106,13 @@
 }
 
 
-
 struct name_address_pair {
    const char *Name;
    GLvoid *Address;
 };
 
 static struct name_address_pair GLX_functions[] = {
+   /*** GLX_VERSION_1_0 ***/
    { "glXChooseVisual", (GLvoid *) glXChooseVisual },
    { "glXCopyContext", (GLvoid *) glXCopyContext },
    { "glXCreateContext", (GLvoid *) glXCreateContext },
@@ -739,17 +1131,15 @@
    { "glXWaitGL", (GLvoid *) glXWaitGL },
    { "glXWaitX", (GLvoid *) glXWaitX },
 
-#ifdef GLX_VERSION_1_1
+   /*** GLX_VERSION_1_1 ***/
    { "glXGetClientString", (GLvoid *) glXGetClientString },
    { "glXQueryExtensionsString", (GLvoid *) glXQueryExtensionsString },
    { "glXQueryServerString", (GLvoid *) glXQueryServerString },
-#endif
 
-#ifdef GLX_VERSION_1_2
+   /*** GLX_VERSION_1_2 ***/
    { "glXGetCurrentDisplay", (GLvoid *) glXGetCurrentDisplay },
-#endif
 
-#ifdef GLX_VERSION_1_3
+   /*** GLX_VERSION_1_3 ***/
    { "glXChooseFBConfig", (GLvoid *) glXChooseFBConfig },
    { "glXCreateNewContext", (GLvoid *) glXCreateNewContext },
    { "glXCreatePbuffer", (GLvoid *) glXCreatePbuffer },
@@ -760,37 +1150,100 @@
    { "glXDestroyWindow", (GLvoid *) glXDestroyWindow },
    { "glXGetCurrentReadDrawable", (GLvoid *) glXGetCurrentReadDrawable },
    { "glXGetFBConfigAttrib", (GLvoid *) glXGetFBConfigAttrib },
+   { "glXGetFBConfigs", (GLvoid *) glXGetFBConfigs },
    { "glXGetSelectedEvent", (GLvoid *) glXGetSelectedEvent },
    { "glXGetVisualFromFBConfig", (GLvoid *) glXGetVisualFromFBConfig },
    { "glXMakeContextCurrent", (GLvoid *) glXMakeContextCurrent },
    { "glXQueryContext", (GLvoid *) glXQueryContext },
    { "glXQueryDrawable", (GLvoid *) glXQueryDrawable },
    { "glXSelectEvent", (GLvoid *) glXSelectEvent },
-#endif
 
-#ifdef GLX_SGI_video_sync
+   /*** GLX_VERSION_1_4 ***/
+   { "glXGetProcAddress", (GLvoid *) glXGetProcAddress },
+
+   /*** GLX_SGI_swap_control ***/
+   { "glXSwapIntervalSGI", (GLvoid *) glXSwapIntervalSGI },
+
+   /*** GLX_SGI_video_sync ***/
    { "glXGetVideoSyncSGI", (GLvoid *) glXGetVideoSyncSGI },
    { "glXWaitVideoSyncSGI", (GLvoid *) glXWaitVideoSyncSGI },
-#endif
 
-#ifdef GLX_MESA_copy_sub_buffer
-   { "glXCopySubBufferMESA", (GLvoid *) glXCopySubBufferMESA },
-#endif
+   /*** GLX_SGI_make_current_read ***/
+   { "glXMakeCurrentReadSGI", (GLvoid *) glXMakeCurrentReadSGI },
+   { "glXGetCurrentReadDrawableSGI", (GLvoid *) glXGetCurrentReadDrawableSGI },
+
+   /*** GLX_SGIX_video_source ***/
+#if defined(_VL_H)
+   { "glXCreateGLXVideoSourceSGIX", (GLvoid *) glXCreateGLXVideoSourceSGIX },
+   { "glXDestroyGLXVideoSourceSGIX", (GLvoid *) glXDestroyGLXVideoSourceSGIX },
+#endif
+
+   /*** GLX_EXT_import_context ***/
+   { "glXFreeContextEXT", (GLvoid *) glXFreeContextEXT },
+   { "glXGetContextIDEXT", (GLvoid *) glXGetContextIDEXT },
+   { "glXGetCurrentDisplayEXT", (GLvoid *) glXGetCurrentDisplayEXT },
+   { "glXImportContextEXT", (GLvoid *) glXImportContextEXT },
+   { "glXQueryContextInfoEXT", (GLvoid *) glXQueryContextInfoEXT },
+
+   /*** GLX_SGIX_fbconfig ***/
+   { "glXGetFBConfigAttribSGIX", (GLvoid *) glXGetFBConfigAttribSGIX },
+   { "glXChooseFBConfigSGIX", (GLvoid *) glXChooseFBConfigSGIX },
+   { "glXCreateGLXPixmapWithConfigSGIX", (GLvoid *) glXCreateGLXPixmapWithConfigSGIX },
+   { "glXCreateContextWithConfigSGIX", (GLvoid *) glXCreateContextWithConfigSGIX },
+   { "glXGetVisualFromFBConfigSGIX", (GLvoid *) glXGetVisualFromFBConfigSGIX },
+   { "glXGetFBConfigFromVisualSGIX", (GLvoid *) glXGetFBConfigFromVisualSGIX },
+
+   /*** GLX_SGIX_pbuffer ***/
+   { "glXCreateGLXPbufferSGIX", (GLvoid *) glXCreateGLXPbufferSGIX },
+   { "glXDestroyGLXPbufferSGIX", (GLvoid *) glXDestroyGLXPbufferSGIX },
+   { "glXQueryGLXPbufferSGIX", (GLvoid *) glXQueryGLXPbufferSGIX },
+   { "glXSelectEventSGIX", (GLvoid *) glXSelectEventSGIX },
+   { "glXGetSelectedEventSGIX", (GLvoid *) glXGetSelectedEventSGIX },
+
+   /*** GLX_SGI_cushion ***/
+   { "glXCushionSGI", (GLvoid *) glXCushionSGI },
+
+   /*** GLX_SGIX_video_resize ***/
+   { "glXBindChannelToWindowSGIX", (GLvoid *) glXBindChannelToWindowSGIX },
+   { "glXChannelRectSGIX", (GLvoid *) glXChannelRectSGIX },
+   { "glXQueryChannelRectSGIX", (GLvoid *) glXQueryChannelRectSGIX },
+   { "glXQueryChannelDeltasSGIX", (GLvoid *) glXQueryChannelDeltasSGIX },
+   { "glXChannelRectSyncSGIX", (GLvoid *) glXChannelRectSyncSGIX },
+
+   /*** GLX_SGIX_dmbuffer **/
+#if defined(_DM_BUFFER_H_)
+   { "glXAssociateDMPbufferSGIX", (GLvoid *) glXAssociateDMPbufferSGIX },
+#endif
+
+   /*** GLX_SGIX_swap_group ***/
+   { "glXJoinSwapGroupSGIX", (GLvoid *) glXJoinSwapGroupSGIX },
+
+   /*** GLX_SGIX_swap_barrier ***/
+   { "glXBindSwapBarrierSGIX", (GLvoid *) glXBindSwapBarrierSGIX },
+   { "glXQueryMaxSwapBarriersSGIX", (GLvoid *) glXQueryMaxSwapBarriersSGIX },
 
-#ifdef GLX_MESA_release_buffers
-   { "glXReleaseBuffersMESA", (GLvoid *) glXReleaseBuffersMESA },
-#endif
+   /*** GLX_SUN_get_transparent_index ***/
+   { "glXGetTransparentIndexSUN", (GLvoid *) glXGetTransparentIndexSUN },
 
-#ifdef GLX_MESA_pixmap_colormap
+   /*** GLX_MESA_copy_sub_buffer ***/
+   { "glXCopySubBufferMESA", (GLvoid *) glXCopySubBufferMESA },
+
+   /*** GLX_MESA_pixmap_colormap ***/
    { "glXCreateGLXPixmapMESA", (GLvoid *) glXCreateGLXPixmapMESA },
-#endif
 
-#ifdef GLX_MESA_set_3dfx_mode
+   /*** GLX_MESA_release_buffers ***/
+   { "glXReleaseBuffersMESA", (GLvoid *) glXReleaseBuffersMESA },
+
+   /*** GLX_MESA_set_3dfx_mode ***/
    { "glXSet3DfxModeMESA", (GLvoid *) glXSet3DfxModeMESA },
-#endif
 
+   /*** GLX_ARB_get_proc_address ***/
    { "glXGetProcAddressARB", (GLvoid *) glXGetProcAddressARB },
 
+   /*** GLX AGP memory allocation ***/
+   { "glXAllocateMemoryNV", (GLvoid *) glXAllocateMemoryNV },
+   { "glXFreeMemoryNV", (GLvoid *) glXFreeMemoryNV },
+
    { NULL, NULL }   /* end of list */
 };
 
@@ -828,4 +1281,11 @@
 
    f = (gl_function) _glapi_get_proc_address((const char *) procName);
    return f;
+}
+
+
+/* GLX 1.4 */
+void (*glXGetProcAddress(const GLubyte *procName))()
+{
+   return glXGetProcAddressARB(procName);
 }
Index: xc/extras/Mesa/src/X/glxapi.h
diff -u xc/extras/Mesa/src/X/glxapi.h:1.4 xc/extras/Mesa/src/X/glxapi.h:1.8
--- xc/extras/Mesa/src/X/glxapi.h:1.4	Fri Jun 16 20:02:38 2000
+++ xc/extras/Mesa/src/X/glxapi.h	Mon Dec 16 11:18:30 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  4.0.4
  * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -28,11 +28,31 @@
 #define _glxapi_h_
 
 
-#define GLX_GLXEXT_LEGACY
-#define GL_GLEXT_PROTOTYPES
+#define GLX_GLXEXT_PROTOTYPES
 #include "GL/glx.h"
 
 
+#ifdef GLX_BUILT_IN_XMESA
+/* The GLX API dispatcher (i.e. this code) is being built into XFree86's
+ * libGL so we'll use the __GLXContextRec defined in xc/lib/GL/glx/glxclient.h
+*/
+#include "glxclient.h"
+#else
+/* The GLX API dispatcher (i.e. this code) is being built into stand-alone
+ * Mesa.  We don't know anything about XFree86 or real GLX so we define a
+ * minimal __GLXContextRec here so some of the functions in this file can
+ * work properly.
+ */
+typedef struct __GLXcontextRec {
+   Display *currentDpy;
+   GLboolean isDirect;
+   GLXDrawable currentDrawable;
+   GLXDrawable currentReadable;
+   XID xid;
+} __GLXcontext;
+#endif
+
+
 /*
  * Almost all the GLX API functions get routed through this dispatch table.
  * The exceptions are the glXGetCurrentXXX() functions.
@@ -41,9 +61,14 @@
  * Specifically, a real GLX library (like SGI's or the Utah GLX) and Mesa's
  * pseudo-GLX can be present at the same time.  The former being used on
  * GLX-enabled X servers and the later on non-GLX X servers.
+ *
+ * Red Hat has been using this since Red Hat Linux 7.0 (I think).
+ * This'll be a standard feature in XFree86 4.3.  It basically allows one
+ * libGL to do both DRI-rendering and "fake GLX" rendering to X displays
+ * that lack the GLX extension.
  */
 struct _glxapi_table {
-   /* GLX 1.0 functions */
+   /*** GLX_VERSION_1_0 ***/
    XVisualInfo *(*ChooseVisual)(Display *dpy, int screen, int *list);
    void (*CopyContext)(Display *dpy, GLXContext src, GLXContext dst, unsigned long mask);
    GLXContext (*CreateContext)(Display *dpy, XVisualInfo *visinfo, GLXContext shareList, Bool direct);
@@ -62,17 +87,15 @@
    void (*WaitGL)(void);
    void (*WaitX)(void);
 
-#ifdef GLX_VERSION_1_1
+   /*** GLX_VERSION_1_1 ***/
    const char *(*GetClientString)(Display *dpy, int name);
    const char *(*QueryExtensionsString)(Display *dpy, int screen);
    const char *(*QueryServerString)(Display *dpy, int screen, int name);
-#endif
 
-#ifdef GLX_VERSION_1_2
+   /*** GLX_VERSION_1_2 ***/
    /*Display *(*GetCurrentDisplay)(void);*/
-#endif
 
-#ifdef GLX_VERSION_1_3
+   /*** GLX_VERSION_1_3 ***/
    GLXFBConfig *(*ChooseFBConfig)(Display *dpy, int screen, const int *attribList, int *nitems);
    GLXContext (*CreateNewContext)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct);
    GLXPbuffer (*CreatePbuffer)(Display *dpy, GLXFBConfig config, const int *attribList);
@@ -90,41 +113,97 @@
    int (*QueryContext)(Display *dpy, GLXContext ctx, int attribute, int *value);
    void (*QueryDrawable)(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
    void (*SelectEvent)(Display *dpy, GLXDrawable drawable, unsigned long mask);
+
+   /*** GLX_SGI_swap_control ***/
+   int (*SwapIntervalSGI)(int);
+
+   /*** GLX_SGI_video_sync ***/
+   int (*GetVideoSyncSGI)(unsigned int *count);
+   int (*WaitVideoSyncSGI)(int divisor, int remainder, unsigned int *count);
+
+   /*** GLX_SGI_make_current_read ***/
+   Bool (*MakeCurrentReadSGI)(Display *, GLXDrawable, GLXDrawable, GLXContext);
+   /*GLXDrawable (*GetCurrentReadDrawableSGI)(void);*/
+
+   /*** GLX_SGIX_video_source (needs video library) ***/
+#if defined(_VL_H_)
+   GLXVideoSourceSGIX (*CreateGLXVideoSourceSGIX)(Display *, int, VLServer, VLPath, int, VLNode);
+   void (*DestroyGLXVideoSourceSGIX)(Display *, GLXVideoSourceSGIX);
+#else
+   void *CreateGLXVideoSourceSGIX;
+   void *DestroyGLXVideoSourceSGIX;
 #endif
 
-#ifdef GLX_EXT_import_context
+   /*** GLX_EXT_import_context ***/
    void (*FreeContextEXT)(Display *dpy, GLXContext context);
    GLXContextID (*GetContextIDEXT)(const GLXContext context);
-   Display *(*GetCurrentDisplayEXT)(void);
+   /*Display *(*GetCurrentDisplayEXT)(void);*/
    GLXContext (*ImportContextEXT)(Display *dpy, GLXContextID contextID);
    int (*QueryContextInfoEXT)(Display *dpy, GLXContext context, int attribute,int *value);
-#endif
 
-#ifdef GLX_SGI_video_sync
-   int (*GetVideoSyncSGI)(unsigned int *count);
-   int (*WaitVideoSyncSGI)(int divisor, int remainder, unsigned int *count);
-#endif
+   /*** GLX_SGIX_fbconfig ***/
+   int (*GetFBConfigAttribSGIX)(Display *, GLXFBConfigSGIX, int, int *);
+   GLXFBConfigSGIX * (*ChooseFBConfigSGIX)(Display *, int, int *, int *);
+   GLXPixmap (*CreateGLXPixmapWithConfigSGIX)(Display *, GLXFBConfigSGIX, Pixmap);
+   GLXContext (*CreateContextWithConfigSGIX)(Display *, GLXFBConfigSGIX, int, GLXContext, Bool);
+   XVisualInfo * (*GetVisualFromFBConfigSGIX)(Display *, GLXFBConfigSGIX);
+   GLXFBConfigSGIX (*GetFBConfigFromVisualSGIX)(Display *, XVisualInfo *);
+
+   /*** GLX_SGIX_pbuffer ***/
+   GLXPbufferSGIX (*CreateGLXPbufferSGIX)(Display *, GLXFBConfigSGIX, unsigned int, unsigned int, int *);
+   void (*DestroyGLXPbufferSGIX)(Display *, GLXPbufferSGIX);
+   int (*QueryGLXPbufferSGIX)(Display *, GLXPbufferSGIX, int, unsigned int *);
+   void (*SelectEventSGIX)(Display *, GLXDrawable, unsigned long);
+   void (*GetSelectedEventSGIX)(Display *, GLXDrawable, unsigned long *);
+
+   /*** GLX_SGI_cushion ***/
+   void (*CushionSGI)(Display *, Window, float);
+
+   /*** GLX_SGIX_video_resize ***/
+   int (*BindChannelToWindowSGIX)(Display *, int, int, Window);
+   int (*ChannelRectSGIX)(Display *, int, int, int, int, int, int);
+   int (*QueryChannelRectSGIX)(Display *, int, int, int *, int *, int *, int *);
+   int (*QueryChannelDeltasSGIX)(Display *, int, int, int *, int *, int *, int *);
+   int (*ChannelRectSyncSGIX)(Display *, int, int, GLenum);
+
+   /*** GLX_SGIX_dmbuffer (needs dmedia library) ***/
+#if defined (_DM_BUFFER_H_)
+   Bool (*AssociateDMPbufferSGIX)(Display *, GLXPbufferSGIX, DMparams *, DMbuffer);
+#else
+   void *AssociciateDMPbufferSGIX;
+#endif
+
+   /*** GLX_SGIX_swap_group ***/
+   void (*JoinSwapGroupSGIX)(Display *, GLXDrawable, GLXDrawable);
+
+   /*** GLX_SGIX_swap_barrier ***/
+   void (*BindSwapBarrierSGIX)(Display *, GLXDrawable, int);
+   Bool (*QueryMaxSwapBarriersSGIX)(Display *, int, int *);
 
-   /*
-    * XXX thesa Mesa-specific functions might not belong here
-    */
+   /*** GLX_SUN_get_transparent_index ***/
+   Status (*GetTransparentIndexSUN)(Display *, Window, Window, long *);
 
-#ifdef GLX_MESA_copy_sub_buffer
+   /*** GLX_MESA_copy_sub_buffer ***/
    void (*CopySubBufferMESA)(Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
-#endif
 
-#ifdef GLX_MESA_release_buffers
+   /*** GLX_MESA_release_buffers ***/
    Bool (*ReleaseBuffersMESA)(Display *dpy, Window w);
-#endif
 
-#ifdef GLX_MESA_pixmap_colormap
+   /*** GLX_MESA_pixmap_colormap ***/
    GLXPixmap (*CreateGLXPixmapMESA)(Display *dpy, XVisualInfo *visinfo, Pixmap pixmap, Colormap cmap);
-#endif
 
-#ifdef GLX_MESA_set_3dfx_mode
-   GLboolean (*Set3DfxModeMESA)(GLint mode);
-#endif
+   /*** GLX_MESA_set_3dfx_mode ***/
+   Bool (*Set3DfxModeMESA)(int mode);
+
+   /*** GLX_NV_vertex_array_range ***/
+   void * (*AllocateMemoryNV)( GLsizei size,
+                               GLfloat readFrequency,
+                               GLfloat writeFrequency,
+                               GLfloat priority );
+   void (*FreeMemoryNV)( GLvoid *pointer );
 
+   /*** GLX_MESA_agp_offset ***/
+   GLuint (*GetAGPOffsetMESA)( const GLvoid *pointer );
 };
 
 
Index: xc/extras/Mesa/src/X/glxheader.h
diff -u xc/extras/Mesa/src/X/glxheader.h:1.3 xc/extras/Mesa/src/X/glxheader.h:1.4
--- xc/extras/Mesa/src/X/glxheader.h:1.3	Tue Mar 20 21:48:54 2001
+++ xc/extras/Mesa/src/X/glxheader.h	Fri Feb 22 14:28:22 2002
@@ -1,7 +1,7 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  * 
  * Copyright (C) 1999  Brian Paul   All Rights Reserved.
  * 
@@ -27,11 +27,10 @@
 #ifndef GLX_HEADER_H
 #define GLX_HEADER_H
 
-#ifdef VMS
-#include <vms_x_fix.h>
+#ifdef __VMS
+#include <GL/vms_x_fix.h>
 #endif
 
-
 #ifdef HAVE_CONFIG_H
 #include "conf.h"
 #endif
@@ -50,9 +49,6 @@
 
 #else
 
-# ifdef GLX_DIRECT_RENDERING
-#  include "dri_mesaint.h"
-# endif
 # include <X11/Xlib.h>
 # include <X11/Xutil.h>
 # ifdef USE_XSHM  /* was SHM */
Index: xc/extras/Mesa/src/X/realglx.c
diff -u /dev/null xc/extras/Mesa/src/X/realglx.c:1.7
--- /dev/null	Thu Feb 27 12:15:52 2003
+++ xc/extras/Mesa/src/X/realglx.c	Mon Dec 16 11:18:31 2002
@@ -0,0 +1,180 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ * 
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include <assert.h>
+#include <GL/glx.h>
+#include "realglx.h"
+#include "glxapi.h"
+
+
+struct _glxapi_table *
+_real_GetGLXDispatchTable(void)
+{
+   static struct _glxapi_table glx;
+
+   /* be sure our dispatch table size <= libGL's table */
+   {
+      GLuint size = sizeof(struct _glxapi_table) / sizeof(void *);
+      (void) size;
+      assert(_glxapi_get_dispatch_table_size() >= size);
+   }
+
+   /* initialize the whole table to no-ops */
+   _glxapi_set_no_op_table(&glx);
+
+   /* now initialize the table with the functions I implement */
+
+   /*** GLX_VERSION_1_0 ***/
+   glx.ChooseVisual = _real_glXChooseVisual;
+   glx.CopyContext = _real_glXCopyContext;
+   glx.CreateContext = _real_glXCreateContext;
+   glx.CreateGLXPixmap = _real_glXCreateGLXPixmap;
+   glx.DestroyContext = _real_glXDestroyContext;
+   glx.DestroyGLXPixmap = _real_glXDestroyGLXPixmap;
+   glx.GetConfig = _real_glXGetConfig;
+   /*glx.GetCurrentContext = _real_glXGetCurrentContext;*/
+   /*glx.GetCurrentDrawable = _real_glXGetCurrentDrawable;*/
+   glx.IsDirect = _real_glXIsDirect;
+   glx.MakeCurrent = _real_glXMakeCurrent;
+   glx.QueryExtension = _real_glXQueryExtension;
+   glx.QueryVersion = _real_glXQueryVersion;
+   glx.SwapBuffers = _real_glXSwapBuffers;
+   glx.UseXFont = _real_glXUseXFont;
+   glx.WaitGL = _real_glXWaitGL;
+   glx.WaitX = _real_glXWaitX;
+
+   /*** GLX_VERSION_1_1 ***/
+   glx.GetClientString = _real_glXGetClientString;
+   glx.QueryExtensionsString = _real_glXQueryExtensionsString;
+   glx.QueryServerString = _real_glXQueryServerString;
+
+   /*** GLX_VERSION_1_2 ***/
+   /*glx.GetCurrentDisplay = _real_glXGetCurrentDisplay;*/
+
+   /*** GLX_VERSION_1_3 ***/
+   glx.ChooseFBConfig = _real_glXChooseFBConfig;
+   glx.CreateNewContext = _real_glXCreateNewContext;
+   glx.CreatePbuffer = _real_glXCreatePbuffer;
+   glx.CreatePixmap = _real_glXCreatePixmap;
+   glx.CreateWindow = _real_glXCreateWindow;
+   glx.DestroyPbuffer = _real_glXDestroyPbuffer;
+   glx.DestroyPixmap = _real_glXDestroyPixmap;
+   glx.DestroyWindow = _real_glXDestroyWindow;
+   /*glx.GetCurrentReadDrawable = _real_glXGetCurrentReadDrawable;*/
+   glx.GetFBConfigAttrib = _real_glXGetFBConfigAttrib;
+   glx.GetFBConfigs = _real_glXGetFBConfigs;
+   glx.GetSelectedEvent = _real_glXGetSelectedEvent;
+   glx.GetVisualFromFBConfig = _real_glXGetVisualFromFBConfig;
+   glx.MakeContextCurrent = _real_glXMakeContextCurrent;
+   glx.QueryContext = _real_glXQueryContext;
+   glx.QueryDrawable = _real_glXQueryDrawable;
+   glx.SelectEvent = _real_glXSelectEvent;
+
+   /*** GLX_SGI_swap_control ***/
+   glx.SwapIntervalSGI = _real_glXSwapIntervalSGI;
+
+   /*** GLX_SGI_video_sync ***/
+   glx.GetVideoSyncSGI = _real_glXGetVideoSyncSGI;
+   glx.WaitVideoSyncSGI = _real_glXWaitVideoSyncSGI;
+
+   /*** GLX_SGI_make_current_read ***/
+   glx.MakeCurrentReadSGI = _real_glXMakeCurrentReadSGI;
+   /*glx.GetCurrentReadDrawableSGI = _real_glXGetCurrentReadDrawableSGI;*/
+
+#if defined(_VL_H)
+   /*** GLX_SGIX_video_source ***/
+   glx.CreateGLXVideoSourceSGIX = _real_glXCreateGLXVideoSourceSGIX;
+   glx.DestroyGLXVideoSourceSGIX = _real_glXDestroyGLXVideoSourceSGIX;
+#endif
+
+   /*** GLX_EXT_import_context ***/
+   glx.FreeContextEXT = _real_glXFreeContextEXT;
+   /*glx.GetContextIDEXT = _real_glXGetContextIDEXT;*/
+   /*glx.GetCurrentDisplayEXT = _real_glXGetCurrentDisplayEXT;*/
+   glx.ImportContextEXT = _real_glXImportContextEXT;
+   glx.QueryContextInfoEXT = _real_glXQueryContextInfoEXT;
+
+   /*** GLX_SGIX_fbconfig ***/
+   glx.GetFBConfigAttribSGIX = _real_glXGetFBConfigAttribSGIX;
+   glx.ChooseFBConfigSGIX = _real_glXChooseFBConfigSGIX;
+   glx.CreateGLXPixmapWithConfigSGIX = _real_glXCreateGLXPixmapWithConfigSGIX;
+   glx.CreateContextWithConfigSGIX = _real_glXCreateContextWithConfigSGIX;
+   glx.GetVisualFromFBConfigSGIX = _real_glXGetVisualFromFBConfigSGIX;
+   glx.GetFBConfigFromVisualSGIX = _real_glXGetFBConfigFromVisualSGIX;
+
+   /*** GLX_SGIX_pbuffer ***/
+   glx.CreateGLXPbufferSGIX = _real_glXCreateGLXPbufferSGIX;
+   glx.DestroyGLXPbufferSGIX = _real_glXDestroyGLXPbufferSGIX;
+   glx.QueryGLXPbufferSGIX = _real_glXQueryGLXPbufferSGIX;
+   glx.SelectEventSGIX = _real_glXSelectEventSGIX;
+   glx.GetSelectedEventSGIX = _real_glXGetSelectedEventSGIX;
+
+   /*** GLX_SGI_cushion ***/
+   glx.CushionSGI = _real_glXCushionSGI;
+
+   /*** GLX_SGIX_video_resize ***/
+   glx.BindChannelToWindowSGIX = _real_glXBindChannelToWindowSGIX;
+   glx.ChannelRectSGIX = _real_glXChannelRectSGIX;
+   glx.QueryChannelRectSGIX = _real_glXQueryChannelRectSGIX;
+   glx.QueryChannelDeltasSGIX = _real_glXQueryChannelDeltasSGIX;
+   glx.ChannelRectSyncSGIX = _real_glXChannelRectSyncSGIX;
+
+#if defined(_DM_BUFFER_H_)
+   /*** (GLX_SGIX_dmbuffer ***/
+   glx.AssociateDMPbufferSGIX = NULL;
+#endif
+
+   /*** GLX_SGIX_swap_group ***/
+   glx.JoinSwapGroupSGIX = _real_glXJoinSwapGroupSGIX;
+
+   /*** GLX_SGIX_swap_barrier ***/
+   glx.BindSwapBarrierSGIX = _real_glXBindSwapBarrierSGIX;
+   glx.QueryMaxSwapBarriersSGIX = _real_glXQueryMaxSwapBarriersSGIX;
+
+   /*** GLX_SUN_get_transparent_index ***/
+   glx.GetTransparentIndexSUN = _real_glXGetTransparentIndexSUN;
+
+   /*** GLX_MESA_copy_sub_buffer ***/
+   glx.CopySubBufferMESA = _real_glXCopySubBufferMESA;
+
+   /*** GLX_MESA_release_buffers ***/
+   glx.ReleaseBuffersMESA = _real_glXReleaseBuffersMESA;
+
+   /*** GLX_MESA_pixmap_colormap ***/
+   glx.CreateGLXPixmapMESA = _real_glXCreateGLXPixmapMESA;
+
+   /*** GLX_MESA_set_3dfx_mode ***/
+   glx.Set3DfxModeMESA = _real_glXSet3DfxModeMESA;
+
+   /*** GLX_NV_vertex_array_range ***/
+   glx.AllocateMemoryNV = _real_glXAllocateMemoryNV;
+   glx.FreeMemoryNV = _real_glXFreeMemoryNV;
+
+   /*** GLX_MESA_agp_offset ***/
+   glx.GetAGPOffsetMESA = _real_glXGetAGPOffsetMESA;
+
+   return &glx;
+}
Index: xc/extras/Mesa/src/X/realglx.h
diff -u /dev/null xc/extras/Mesa/src/X/realglx.h:1.7
--- /dev/null	Thu Feb 27 12:15:52 2003
+++ xc/extras/Mesa/src/X/realglx.h	Mon Dec 16 11:18:31 2002
@@ -0,0 +1,331 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ * 
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef REALGLX_H
+#define REALGLX_H
+
+
+extern struct _glxapi_table *
+_real_GetGLXDispatchTable(void);
+
+
+/*
+ * Basically just need these to prevent compiler warnings.
+ */
+
+
+extern XVisualInfo *
+_real_glXChooseVisual( Display *dpy, int screen, int *list );
+
+extern GLXContext
+_real_glXCreateContext( Display *dpy, XVisualInfo *visinfo,
+                        GLXContext share_list, Bool direct );
+
+extern GLXPixmap
+_real_glXCreateGLXPixmap( Display *dpy, XVisualInfo *visinfo, Pixmap pixmap );
+
+extern GLXPixmap
+_real_glXCreateGLXPixmapMESA( Display *dpy, XVisualInfo *visinfo,
+                              Pixmap pixmap, Colormap cmap );
+
+extern void
+_real_glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap );
+
+extern void
+_real_glXCopyContext( Display *dpy, GLXContext src, GLXContext dst,
+                      unsigned long mask );
+
+extern Bool
+_real_glXMakeCurrent( Display *dpy, GLXDrawable drawable, GLXContext ctx );
+
+extern Bool
+_real_glXQueryExtension( Display *dpy, int *errorb, int *event );
+
+extern void
+_real_glXDestroyContext( Display *dpy, GLXContext ctx );
+
+extern Bool
+_real_glXIsDirect( Display *dpy, GLXContext ctx );
+
+extern void
+_real_glXSwapBuffers( Display *dpy, GLXDrawable drawable );
+
+extern void
+_real_glXUseXFont( Font font, int first, int count, int listbase );
+
+extern Bool
+_real_glXQueryVersion( Display *dpy, int *maj, int *min );
+
+extern int
+_real_glXGetConfig( Display *dpy, XVisualInfo *visinfo,
+                    int attrib, int *value );
+
+extern void
+_real_glXWaitGL( void );
+
+
+extern void
+_real_glXWaitX( void );
+
+/* GLX 1.1 and later */
+extern const char *
+_real_glXQueryExtensionsString( Display *dpy, int screen );
+
+/* GLX 1.1 and later */
+extern const char *
+_real_glXQueryServerString( Display *dpy, int screen, int name );
+
+/* GLX 1.1 and later */
+extern const char *
+_real_glXGetClientString( Display *dpy, int name );
+
+
+/*
+ * GLX 1.3 and later
+ */
+
+extern GLXFBConfig *
+_real_glXChooseFBConfig( Display *dpy, int screen,
+                         const int *attribList, int *nitems );
+
+extern int
+_real_glXGetFBConfigAttrib( Display *dpy, GLXFBConfig config,
+                            int attribute, int *value );
+
+extern GLXFBConfig *
+_real_glXGetFBConfigs( Display *dpy, int screen, int *nelements );
+
+extern XVisualInfo *
+_real_glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config );
+
+extern GLXWindow
+_real_glXCreateWindow( Display *dpy, GLXFBConfig config, Window win,
+                       const int *attribList );
+
+extern void
+_real_glXDestroyWindow( Display *dpy, GLXWindow window );
+
+extern GLXPixmap
+_real_glXCreatePixmap( Display *dpy, GLXFBConfig config, Pixmap pixmap,
+                       const int *attribList );
+
+extern void
+_real_glXDestroyPixmap( Display *dpy, GLXPixmap pixmap );
+
+extern GLXPbuffer
+_real_glXCreatePbuffer( Display *dpy, GLXFBConfig config,
+                        const int *attribList );
+
+extern void
+_real_glXDestroyPbuffer( Display *dpy, GLXPbuffer pbuf );
+
+extern void
+_real_glXQueryDrawable( Display *dpy, GLXDrawable draw, int attribute,
+                        unsigned int *value );
+
+extern GLXContext
+_real_glXCreateNewContext( Display *dpy, GLXFBConfig config,
+                           int renderType, GLXContext shareList, Bool direct );
+
+
+extern Bool
+_real_glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
+                             GLXDrawable read, GLXContext ctx );
+
+extern int
+_real_glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value );
+
+extern void
+_real_glXSelectEvent( Display *dpy, GLXDrawable drawable, unsigned long mask );
+
+extern void
+_real_glXGetSelectedEvent( Display *dpy, GLXDrawable drawable,
+                           unsigned long *mask );
+
+#ifdef GLX_SGI_swap_control
+extern int
+_real_glXSwapIntervalSGI(int interval);
+#endif
+
+
+#ifdef GLX_SGI_video_sync
+extern int
+_real_glXGetVideoSyncSGI(unsigned int *count);
+
+extern int
+_real_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count);
+#endif
+
+
+#ifdef GLX_SGI_make_current_read
+extern Bool
+_real_glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+
+extern GLXDrawable
+_real_glXGetCurrentReadDrawableSGI(void);
+#endif
+
+#if defined(_VL_H) && defined(GLX_SGIX_video_source)
+extern GLXVideoSourceSGIX
+_real_glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode);
+
+extern void
+_real_glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src);
+#endif
+
+#ifdef GLX_EXT_import_context
+extern void
+_real_glXFreeContextEXT(Display *dpy, GLXContext context);
+
+extern GLXContextID
+_real_glXGetContextIDEXT(const GLXContext context);
+
+extern Display *
+_real_glXGetCurrentDisplayEXT(void);
+
+extern GLXContext
+_real_glXImportContextEXT(Display *dpy, GLXContextID contextID);
+
+extern int
+_real_glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, int *value);
+#endif
+
+#ifdef GLX_SGIX_fbconfig
+extern int
+_real_glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
+
+extern GLXFBConfigSGIX *
+_real_glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements);
+
+extern GLXPixmap
+_real_glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
+
+extern GLXContext
+_real_glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
+
+extern XVisualInfo *
+_real_glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config);
+
+extern GLXFBConfigSGIX
+_real_glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis);
+#endif
+
+#ifdef GLX_SGIX_pbuffer
+extern GLXPbufferSGIX
+_real_glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
+
+extern void
+_real_glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf);
+
+extern int
+_real_glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
+
+extern void
+_real_glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask);
+
+extern void
+_real_glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask);
+#endif
+
+#ifdef GLX_SGI_cushion
+extern void
+_real_glXCushionSGI(Display *dpy, Window win, float cushion);
+#endif
+
+#ifdef GLX_SGIX_video_resize
+extern int
+_real_glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window);
+
+extern int
+_real_glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h);
+
+extern int
+_real_glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h);
+
+extern int
+_real_glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh);
+
+extern int
+_real_glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype);
+#endif
+
+#if defined(_DM_BUFFER_H_) && defined(GLX_SGIX_dmbuffer)
+extern Bool
+_real_glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer);
+#endif
+
+#ifdef GLX_SGIX_swap_group
+extern void
+_real_glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member);
+#endif
+
+#ifdef GLX_SGIX_swap_barrier
+extern void
+_real_glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier);
+
+extern Bool
+_real_glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max);
+#endif
+
+#ifdef GLX_SUN_get_transparent_index
+extern Status
+_real_glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent);
+#endif
+
+#ifdef GLX_MESA_release_buffers
+extern Bool
+_real_glXReleaseBuffersMESA( Display *dpy, GLXDrawable d );
+#endif
+
+#ifdef GLX_MESA_set_3dfx_mode
+extern Bool
+_real_glXSet3DfxModeMESA( int mode );
+#endif
+
+#ifdef GLX_MESA_copy_sub_buffer
+extern void
+_real_glXCopySubBufferMESA( Display *dpy, GLXDrawable drawable,
+                            int x, int y, int width, int height );
+#endif
+
+
+#ifdef GLX_NV_vertex_array_range
+extern void *
+_real_glXAllocateMemoryNV( GLsizei size, GLfloat readFrequency,
+                           GLfloat writeFrequency, GLfloat priority );
+
+
+extern void
+_real_glXFreeMemoryNV( GLvoid *pointer );
+#endif
+
+#ifdef GLX_MESA_agp_offset
+extern GLuint
+_real_glXGetAGPOffsetMESA( const GLvoid *pointer );
+#endif
+
+
+#endif /* REALGLX_H */
Index: xc/extras/Mesa/src/X/xfonts.c
diff -u xc/extras/Mesa/src/X/xfonts.c:1.8 xc/extras/Mesa/src/X/xfonts.c:1.9
--- xc/extras/Mesa/src/X/xfonts.c:1.8	Tue May  1 17:36:52 2001
+++ xc/extras/Mesa/src/X/xfonts.c	Fri Feb 22 14:28:22 2002
@@ -1,7 +1,7 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
  *
@@ -28,16 +28,14 @@
  * Copyright (C) 1995 Thorsten.Ohl @ Physik.TH-Darmstadt.de
  */
 
+#ifdef __VMS
+#include <GL/vms_x_fix.h>
+#endif
 
 #ifdef HAVE_CONFIG_H
 #include "conf.h"
 #endif
 
-#ifdef VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -181,10 +179,10 @@
  * determine if a given glyph is valid and return the
  * corresponding XCharStruct.
  */
-static XCharStruct *isvalid(XFontStruct *fs, int which)
+static XCharStruct *isvalid(XFontStruct *fs, unsigned int which)
 {
   unsigned int  rows,pages;
-  int           byte1 = 0,byte2 = 0;
+  unsigned int byte1 = 0,byte2 = 0;
   int           i,valid = 1;
 
   rows = fs->max_byte1 - fs->min_byte1 + 1;
@@ -245,7 +243,7 @@
 
   fs = XQueryFont (dpy, font);
   if (!fs) {
-      gl_error(NULL, GL_INVALID_VALUE,
+      _mesa_error(NULL, GL_INVALID_VALUE,
                "Couldn't get font structure information");
       return;
   }
@@ -260,7 +258,7 @@
 (GLubyte));
   if (!bm) {
       XFreeFontInfo( NULL, fs, 1 );
-      gl_error(NULL, GL_OUT_OF_MEMORY,
+      _mesa_error(NULL, GL_OUT_OF_MEMORY,
                 "Couldn't allocate bitmap in glXUseXFont()");
       return;
   }
Index: xc/extras/Mesa/src/X/xfonts.h
diff -u xc/extras/Mesa/src/X/xfonts.h:1.2 xc/extras/Mesa/src/X/xfonts.h:1.3
--- xc/extras/Mesa/src/X/xfonts.h:1.2	Tue Mar 20 21:48:54 2001
+++ xc/extras/Mesa/src/X/xfonts.h	Fri Feb 22 14:28:22 2002
@@ -1,7 +1,7 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
+ * Version:  3.5
  *
  * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
  *
@@ -27,10 +27,9 @@
 #ifndef XFONTS_H
 #define XFONTS_H
 
-#ifdef VMS
-#include <vms_x_fix.h>
+#ifdef __VMS
+#include <GL/vms_x_fix.h>
 #endif
-
 
 #include <X11/Xlib.h>
 
Index: xc/extras/Mesa/src/X/xm_api.c
diff -u /dev/null xc/extras/Mesa/src/X/xm_api.c:1.6
--- /dev/null	Thu Feb 27 12:15:52 2003
+++ xc/extras/Mesa/src/X/xm_api.c	Mon Dec 16 11:18:31 2002
@@ -0,0 +1,2639 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/X/xm_api.c,v 1.6 2002/12/16 16:18:31 dawes Exp $ */
+
+/*
+ * This file contains the implementations of all the XMesa* functions.
+ *
+ *
+ * NOTES:
+ *
+ * The window coordinate system origin (0,0) is in the lower-left corner
+ * of the window.  X11's window coordinate origin is in the upper-left
+ * corner of the window.  Therefore, most drawing functions in this
+ * file have to flip Y coordinates.
+ *
+ * Define USE_XSHM in the Makefile with -DUSE_XSHM if you want to compile
+ * in support for the MIT Shared Memory extension.  If enabled, when you
+ * use an Ximage for the back buffer in double buffered mode, the "swap"
+ * operation will be faster.  You must also link with -lXext.
+ *
+ * Byte swapping:  If the Mesa host and the X display use a different
+ * byte order then there's some trickiness to be aware of when using
+ * XImages.  The byte ordering used for the XImage is that of the X
+ * display, not the Mesa host.
+ * The color-to-pixel encoding for True/DirectColor must be done
+ * according to the display's visual red_mask, green_mask, and blue_mask.
+ * If XPutPixel is used to put a pixel into an XImage then XPutPixel will
+ * do byte swapping if needed.  If one wants to directly "poke" the pixel
+ * into the XImage's buffer then the pixel must be byte swapped first.  In
+ * Mesa, when byte swapping is needed we use the PF_TRUECOLOR pixel format
+ * and use XPutPixel everywhere except in the implementation of
+ * glClear(GL_COLOR_BUFFER_BIT).  We want this function to be fast so
+ * instead of using XPutPixel we "poke" our values after byte-swapping
+ * the clear pixel value if needed.
+ *
+ */
+
+#ifdef __CYGWIN__
+#undef WIN32
+#undef __WIN32__
+#endif
+
+#include "glxheader.h"
+#include "GL/xmesa.h"
+#include "xmesaP.h"
+#include "context.h"
+#include "extensions.h"
+#include "glthread.h"
+#include "matrix.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+#ifdef HAVE_CONFIG_H
+#include "conf.h"
+#endif
+#include "macros.h"
+#include "texformat.h"
+#include "texstore.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
+#include "array_cache/acache.h"
+#include "tnl/tnl.h"
+
+#ifndef GLX_NONE_EXT
+#define GLX_NONE_EXT 0x8000
+#endif
+
+
+/*
+ * Global X driver lock
+ */
+_glthread_Mutex _xmesa_lock;
+
+
+
+/*
+ * Lookup tables for HPCR pixel format:
+ */
+static short hpcr_rgbTbl[3][256] = {
+{
+ 16,  16,  17,  17,  18,  18,  19,  19,  20,  20,  21,  21,  22,  22,  23,  23,
+ 24,  24,  25,  25,  26,  26,  27,  27,  28,  28,  29,  29,  30,  30,  31,  31,
+ 32,  32,  33,  33,  34,  34,  35,  35,  36,  36,  37,  37,  38,  38,  39,  39,
+ 32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
+ 48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
+ 64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
+ 80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
+ 96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
+},
+{
+ 16,  16,  17,  17,  18,  18,  19,  19,  20,  20,  21,  21,  22,  22,  23,  23,
+ 24,  24,  25,  25,  26,  26,  27,  27,  28,  28,  29,  29,  30,  30,  31,  31,
+ 32,  32,  33,  33,  34,  34,  35,  35,  36,  36,  37,  37,  38,  38,  39,  39,
+ 32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
+ 48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
+ 64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
+ 80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
+ 96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
+},
+{
+ 32,  32,  33,  33,  34,  34,  35,  35,  36,  36,  37,  37,  38,  38,  39,  39,
+ 40,  40,  41,  41,  42,  42,  43,  43,  44,  44,  45,  45,  46,  46,  47,  47,
+ 48,  48,  49,  49,  50,  50,  51,  51,  52,  52,  53,  53,  54,  54,  55,  55,
+ 56,  56,  57,  57,  58,  58,  59,  59,  60,  60,  61,  61,  62,  62,  63,  63,
+ 64,  64,  65,  65,  66,  66,  67,  67,  68,  68,  69,  69,  70,  70,  71,  71,
+ 72,  72,  73,  73,  74,  74,  75,  75,  76,  76,  77,  77,  78,  78,  79,  79,
+ 80,  80,  81,  81,  82,  82,  83,  83,  84,  84,  85,  85,  86,  86,  87,  87,
+ 80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
+ 96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223
+}
+};
+
+
+
+/**********************************************************************/
+/*****                     X Utility Functions                    *****/
+/**********************************************************************/
+
+
+/*
+ * X/Mesa error reporting function:
+ */
+static void error( const char *msg )
+{
+   (void)DitherValues;		/* Muffle compiler */
+
+   if (getenv("MESA_DEBUG"))
+      fprintf( stderr, "X/Mesa error: %s\n", msg );
+}
+
+
+/*
+ * Return the host's byte order as LSBFirst or MSBFirst ala X.
+ */
+#ifndef XFree86Server
+static int host_byte_order( void )
+{
+   int i = 1;
+   char *cptr = (char *) &i;
+   return (*cptr==1) ? LSBFirst : MSBFirst;
+}
+#endif
+
+
+/*
+ * Error handling.
+ */
+#ifndef XFree86Server
+static int mesaXErrorFlag = 0;
+
+static int mesaHandleXError( XMesaDisplay *dpy, XErrorEvent *event )
+{
+   (void) dpy;
+   (void) event;
+   mesaXErrorFlag = 1;
+   return 0;
+}
+#endif
+
+
+/*
+ * Check if the X Shared Memory extension is available.
+ * Return:  0 = not available
+ *          1 = shared XImage support available
+ *          2 = shared Pixmap support available also
+ */
+#ifndef XFree86Server
+static int check_for_xshm( XMesaDisplay *display )
+{
+#ifdef USE_XSHM
+   int major, minor, ignore;
+   Bool pixmaps;
+
+   if (XQueryExtension( display, "MIT-SHM", &ignore, &ignore, &ignore )) {
+      if (XShmQueryVersion( display, &major, &minor, &pixmaps )==True) {
+	 return (pixmaps==True) ? 2 : 1;
+      }
+      else {
+	 return 0;
+      }
+   }
+   else {
+      return 0;
+   }
+#else
+   /* Can't compile XSHM support */
+   return 0;
+#endif
+}
+#endif
+
+
+/*
+ * Return the width and height of the given drawable.
+ */
+static void get_drawable_size( XMesaDisplay *dpy, XMesaDrawable d,
+                               unsigned int *width, unsigned int *height)
+{
+#ifdef XFree86Server
+    (void) dpy;
+    *width = d->width;
+    *height = d->height;
+#else
+   Window root;
+   int x, y;
+   unsigned int bw, depth;
+
+   _glthread_LOCK_MUTEX(_xmesa_lock);
+   XGetGeometry( dpy, d, &root, &x, &y, width, height, &bw, &depth );
+   _glthread_UNLOCK_MUTEX(_xmesa_lock);
+#endif
+}
+
+
+/*
+ * Apply gamma correction to an intensity value in [0..max].  Return the
+ * new intensity value.
+ */
+static GLint gamma_adjust( GLfloat gamma, GLint value, GLint max )
+{
+   if (gamma == 1.0) {
+      return value;
+   }
+   else {
+      double x = (double) value / (double) max;
+      return IROUND_POS((GLfloat) max * pow(x, 1.0F/gamma));
+   }
+}
+
+
+
+/*
+ * Return the true number of bits per pixel for XImages.
+ * For example, if we request a 24-bit deep visual we may actually need/get
+ * 32bpp XImages.  This function returns the appropriate bpp.
+ * Input:  dpy - the X display
+ *         visinfo - desribes the visual to be used for XImages
+ * Return:  true number of bits per pixel for XImages
+ */
+#define GET_BITS_PER_PIXEL(xmv) bits_per_pixel(xmv)
+
+#ifdef XFree86Server
+
+static int bits_per_pixel( XMesaVisual xmv )
+{
+   XMesaVisualInfo visinfo = xmv->visinfo;
+   const int depth = visinfo->nplanes;
+   int i;
+   for (i = 0; i < screenInfo.numPixmapFormats; i++) {
+      if (screenInfo.formats[i].depth == depth)
+         return screenInfo.formats[i].bitsPerPixel;
+   }
+   return depth;  /* should never get here, but this should be safe */
+}
+
+#else
+
+static int bits_per_pixel( XMesaVisual xmv )
+{
+   XMesaDisplay *dpy = xmv->display;
+   XMesaVisualInfo visinfo = xmv->visinfo;
+   XMesaImage *img;
+   int bitsPerPixel;
+   /* Create a temporary XImage */
+   img = XCreateImage( dpy, visinfo->visual, visinfo->depth,
+		       ZPixmap, 0,           /*format, offset*/
+		       (char*) MALLOC(8),    /*data*/
+		       1, 1,                 /*width, height*/
+		       32,                   /*bitmap_pad*/
+		       0                     /*bytes_per_line*/
+                     );
+   assert(img);
+   /* grab the bits/pixel value */
+   bitsPerPixel = img->bits_per_pixel;
+   /* free the XImage */
+   FREE( img->data );
+   img->data = NULL;
+   XMesaDestroyImage( img );
+   return bitsPerPixel;
+}
+#endif
+
+
+
+/*
+ * Determine if a given X window ID is valid (window exists).
+ * Do this by calling XGetWindowAttributes() for the window and
+ * checking if we catch an X error.
+ * Input:  dpy - the display
+ *         win - the window to check for existance
+ * Return:  GL_TRUE - window exists
+ *          GL_FALSE - window doesn't exist
+ */
+#ifndef XFree86Server
+static GLboolean WindowExistsFlag;
+
+static int window_exists_err_handler( XMesaDisplay* dpy, XErrorEvent* xerr )
+{
+   (void) dpy;
+   if (xerr->error_code == BadWindow) {
+      WindowExistsFlag = GL_FALSE;
+   }
+   return 0;
+}
+
+static GLboolean window_exists( XMesaDisplay *dpy, Window win )
+{
+   XWindowAttributes wa;
+   int (*old_handler)( XMesaDisplay*, XErrorEvent* );
+   WindowExistsFlag = GL_TRUE;
+   old_handler = XSetErrorHandler(window_exists_err_handler);
+   XGetWindowAttributes( dpy, win, &wa ); /* dummy request */
+   XSetErrorHandler(old_handler);
+   return WindowExistsFlag;
+}
+#endif
+
+
+
+/**********************************************************************/
+/*****                Linked list of XMesaBuffers                 *****/
+/**********************************************************************/
+
+static XMesaBuffer XMesaBufferList = NULL;
+
+
+/* Allocate a new XMesaBuffer, add to linked list */
+static XMesaBuffer alloc_xmesa_buffer(void)
+{
+   XMesaBuffer b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer);
+   if (b) {
+      b->Next = XMesaBufferList;
+      XMesaBufferList = b;
+   }
+   return b;
+}
+
+
+/*
+ * Find an XMesaBuffer by matching X display and colormap but NOT matching
+ * the notThis buffer.
+ */
+static XMesaBuffer find_xmesa_buffer(XMesaDisplay *dpy,
+                                     XMesaColormap cmap,
+                                     XMesaBuffer notThis)
+{
+   XMesaBuffer b;
+   for (b=XMesaBufferList; b; b=b->Next) {
+      if (b->display==dpy && b->cmap==cmap && b!=notThis) {
+         return b;
+      }
+   }
+   return NULL;
+}
+
+
+/*
+ * Free an XMesaBuffer, remove from linked list, perhaps free X colormap
+ * entries.
+ */
+static void free_xmesa_buffer(int client, XMesaBuffer buffer)
+{
+   XMesaBuffer prev = NULL, b;
+   (void) client;
+   for (b=XMesaBufferList; b; b=b->Next) {
+      if (b==buffer) {
+         /* unlink bufer from list */
+         if (prev)
+            prev->Next = buffer->Next;
+         else
+            XMesaBufferList = buffer->Next;
+         /* Check to free X colors */
+         if (buffer->num_alloced>0) {
+            /* If no other buffer uses this X colormap then free the colors. */
+            if (!find_xmesa_buffer(buffer->display, buffer->cmap, buffer)) {
+#ifdef XFree86Server
+               (void)FreeColors(buffer->cmap, client,
+				buffer->num_alloced, buffer->alloced_colors,
+				0);
+#else
+               XFreeColors(buffer->display, buffer->cmap,
+                           buffer->alloced_colors, buffer->num_alloced, 0);
+#endif
+            }
+         }
+
+         _mesa_free_framebuffer_data(&buffer->mesa_buffer);
+         FREE(buffer);
+
+         return;
+      }
+      /* continue search */
+      prev = b;
+   }
+   /* buffer not found in XMesaBufferList */
+   _mesa_problem(NULL,"free_xmesa_buffer() - buffer not found\n");
+}
+
+
+/* Copy X color table stuff from one XMesaBuffer to another. */
+static void copy_colortable_info(XMesaBuffer dst, const XMesaBuffer src)
+{
+   MEMCPY(dst->color_table, src->color_table, sizeof(src->color_table));
+   MEMCPY(dst->pixel_to_r, src->pixel_to_r, sizeof(src->pixel_to_r));
+   MEMCPY(dst->pixel_to_g, src->pixel_to_g, sizeof(src->pixel_to_g));
+   MEMCPY(dst->pixel_to_b, src->pixel_to_b, sizeof(src->pixel_to_b));
+   dst->num_alloced = src->num_alloced;
+   MEMCPY(dst->alloced_colors, src->alloced_colors,
+          sizeof(src->alloced_colors));
+}
+
+
+
+/**********************************************************************/
+/*****                   Misc Private Functions                   *****/
+/**********************************************************************/
+
+
+/*
+ * Return number of bits set in n.
+ */
+static int bitcount( unsigned long n )
+{
+   int bits;
+   for (bits=0; n>0; n=n>>1) {
+      if (n&1) {
+         bits++;
+      }
+   }
+   return bits;
+}
+
+
+
+/*
+ * Allocate a shared memory XImage back buffer for the given XMesaBuffer.
+ * Return:  GL_TRUE if success, GL_FALSE if error
+ */
+#ifndef XFree86Server
+static GLboolean alloc_shm_back_buffer( XMesaBuffer b )
+{
+#ifdef USE_XSHM
+   /*
+    * We have to do a _lot_ of error checking here to be sure we can
+    * really use the XSHM extension.  It seems different servers trigger
+    * errors at different points if the extension won't work.  Therefore
+    * we have to be very careful...
+    */
+   GC gc;
+   int (*old_handler)( XMesaDisplay *, XErrorEvent * );
+
+   b->backimage = XShmCreateImage( b->xm_visual->display,
+                                   b->xm_visual->visinfo->visual,
+                                   b->xm_visual->visinfo->depth,
+				   ZPixmap, NULL, &b->shminfo,
+				   b->width, b->height );
+   if (b->backimage == NULL) {
+      error("alloc_back_buffer: Shared memory error (XShmCreateImage), disabling.");
+      b->shm = 0;
+      return GL_FALSE;
+   }
+
+   b->shminfo.shmid = shmget( IPC_PRIVATE, b->backimage->bytes_per_line
+			     * b->backimage->height, IPC_CREAT|0777 );
+   if (b->shminfo.shmid < 0) {
+      if (getenv("MESA_DEBUG"))
+          perror("alloc_back_buffer");
+      XDestroyImage( b->backimage );
+      b->backimage = NULL;
+      error("alloc_back_buffer: Shared memory error (shmget), disabling.");
+      b->shm = 0;
+      return GL_FALSE;
+   }
+
+   b->shminfo.shmaddr = b->backimage->data
+                      = (char*)shmat( b->shminfo.shmid, 0, 0 );
+   if (b->shminfo.shmaddr == (char *) -1) {
+      if (getenv("MESA_DEBUG"))
+          perror("alloc_back_buffer");
+      XDestroyImage( b->backimage );
+      shmctl( b->shminfo.shmid, IPC_RMID, 0 );
+      b->backimage = NULL;
+      error("alloc_back_buffer: Shared memory error (shmat), disabling.");
+      b->shm = 0;
+      return GL_FALSE;
+   }
+
+   b->shminfo.readOnly = False;
+   mesaXErrorFlag = 0;
+   old_handler = XSetErrorHandler( mesaHandleXError );
+   /* This may trigger the X protocol error we're ready to catch: */
+   XShmAttach( b->xm_visual->display, &b->shminfo );
+   XSync( b->xm_visual->display, False );
+
+   if (mesaXErrorFlag) {
+      /* we are on a remote display, this error is normal, don't print it */
+      XFlush( b->xm_visual->display );
+      mesaXErrorFlag = 0;
+      XDestroyImage( b->backimage );
+      shmdt( b->shminfo.shmaddr );
+      shmctl( b->shminfo.shmid, IPC_RMID, 0 );
+      b->backimage = NULL;
+      b->shm = 0;
+      (void) XSetErrorHandler( old_handler );
+      return GL_FALSE;
+   }
+
+   shmctl( b->shminfo.shmid, IPC_RMID, 0 ); /* nobody else needs it */
+
+   /* Finally, try an XShmPutImage to be really sure the extension works */
+   gc = XCreateGC( b->xm_visual->display, b->frontbuffer, 0, NULL );
+   XShmPutImage( b->xm_visual->display, b->frontbuffer, gc,
+		 b->backimage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False );
+   XSync( b->xm_visual->display, False );
+   XFreeGC( b->xm_visual->display, gc );
+   (void) XSetErrorHandler( old_handler );
+   if (mesaXErrorFlag) {
+      XFlush( b->xm_visual->display );
+      mesaXErrorFlag = 0;
+      XDestroyImage( b->backimage );
+      shmdt( b->shminfo.shmaddr );
+      shmctl( b->shminfo.shmid, IPC_RMID, 0 );
+      b->backimage = NULL;
+      b->shm = 0;
+      return GL_FALSE;
+   }
+
+   if (b->backimage) {
+      int height = b->backimage->height;
+      /* Needed by PIXELADDR1 macro */
+      b->ximage_width1 = b->backimage->bytes_per_line;
+      b->ximage_origin1 = (GLubyte *) b->backimage->data
+                        + b->ximage_width1 * (height-1);
+      /* Needed by PIXELADDR2 macro */
+      b->ximage_width2 = b->backimage->bytes_per_line / 2;
+      b->ximage_origin2 = (GLushort *) b->backimage->data
+                        + b->ximage_width2 * (height-1);
+      /* Needed by PIXELADDR3 macro */
+      b->ximage_width3 = b->backimage->bytes_per_line;
+      b->ximage_origin3 = (GLubyte *) b->backimage->data
+                        + b->ximage_width3 * (height-1);
+      /* Needed by PIXELADDR4 macro */
+      b->ximage_width4 = b->backimage->width;
+      b->ximage_origin4 = (GLuint *) b->backimage->data
+                        + b->ximage_width4 * (height-1);
+   }
+
+   return GL_TRUE;
+#else
+   /* Can't compile XSHM support */
+   return GL_FALSE;
+#endif
+}
+#endif
+
+
+
+/*
+ * Setup an off-screen pixmap or Ximage to use as the back buffer.
+ * Input:  b - the X/Mesa buffer
+ */
+void xmesa_alloc_back_buffer( XMesaBuffer b )
+{
+   if (b->db_state==BACK_XIMAGE) {
+      /* Deallocate the old backimage, if any */
+      if (b->backimage) {
+#if defined(USE_XSHM) && !defined(XFree86Server)
+	 if (b->shm) {
+	    XShmDetach( b->xm_visual->display, &b->shminfo );
+	    XDestroyImage( b->backimage );
+	    shmdt( b->shminfo.shmaddr );
+	 }
+	 else
+#endif
+	   XMesaDestroyImage( b->backimage );
+	 b->backimage = NULL;
+      }
+
+      /* Allocate new back buffer */
+#ifdef XFree86Server
+      {
+	 /* Allocate a regular XImage for the back buffer. */
+	 b->backimage = XMesaCreateImage(b->xm_visual->BitsPerPixel,
+					 b->width, b->height, NULL);
+#else
+      if (b->shm==0
+	  || alloc_shm_back_buffer(b)==GL_FALSE
+	  ) {
+	 /* Allocate a regular XImage for the back buffer. */
+	 b->backimage = XCreateImage( b->xm_visual->display,
+                                      b->xm_visual->visinfo->visual,
+                                      GET_VISUAL_DEPTH(b->xm_visual),
+				      ZPixmap, 0,   /* format, offset */
+				      NULL, b->width, b->height,
+				      8, 0 );  /* pad, bytes_per_line */
+#endif
+	 if (!b->backimage) {
+	    error("alloc_back_buffer: XCreateImage failed.");
+	 }
+         b->backimage->data = (char *) MALLOC( b->backimage->height
+                                             * b->backimage->bytes_per_line );
+         if (!b->backimage->data) {
+            error("alloc_back_buffer: MALLOC failed.");
+            XMesaDestroyImage( b->backimage );
+            b->backimage = NULL;
+         }
+      }
+      b->backpixmap = None;
+   }
+   else if (b->db_state==BACK_PIXMAP) {
+      XMesaPixmap old_pixmap = b->backpixmap;
+      /* Free the old back pixmap */
+      if (b->backpixmap) {
+	 XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
+      }
+      /* Allocate new back pixmap */
+      b->backpixmap = XMesaCreatePixmap( b->xm_visual->display, b->frontbuffer,
+					 b->width, b->height,
+					 GET_VISUAL_DEPTH(b->xm_visual) );
+      b->backimage = NULL;
+      /* update other references to backpixmap */
+      if (b->buffer==(XMesaDrawable)old_pixmap) {
+	 b->buffer = (XMesaDrawable)b->backpixmap;
+      }
+   }
+}
+
+
+
+/*
+ * A replacement for XAllocColor.  This function should never
+ * fail to allocate a color.  When XAllocColor fails, we return
+ * the nearest matching color.  If we have to allocate many colors
+ * this function isn't too efficient; the XQueryColors() could be
+ * done just once.
+ * Written by Michael Pichler, Brian Paul, Mark Kilgard
+ * Input:  dpy - X display
+ *         cmap - X colormap
+ *         cmapSize - size of colormap
+ * In/Out: color - the XColor struct
+ * Output:  exact - 1=exact color match, 0=closest match
+ *          alloced - 1=XAlloc worked, 0=XAlloc failed
+ */
+static void
+noFaultXAllocColor( int client,
+                    XMesaDisplay *dpy,
+                    XMesaColormap cmap,
+                    int cmapSize,
+                    XMesaColor *color,
+                    int *exact, int *alloced )
+{
+#ifdef XFree86Server
+   Pixel *ppixIn;
+   xrgb *ctable;
+#else
+   /* we'll try to cache ctable for better remote display performance */
+   static Display *prevDisplay = NULL;
+   static XMesaColormap prevCmap = 0;
+   static int prevCmapSize = 0;
+   static XMesaColor *ctable = NULL;
+#endif
+   XMesaColor subColor;
+   int i, bestmatch;
+   double mindist;       /* 3*2^16^2 exceeds long int precision. */
+
+   (void) client;
+
+   /* First try just using XAllocColor. */
+#ifdef XFree86Server
+   if (AllocColor(cmap,
+		  &color->red, &color->green, &color->blue,
+		  &color->pixel,
+		  client) == Success) {
+#else
+   if (XAllocColor(dpy, cmap, color)) {
+#endif
+      *exact = 1;
+      *alloced = 1;
+      return;
+   }
+
+   /* Alloc failed, search for closest match */
+
+   /* Retrieve color table entries. */
+   /* XXX alloca candidate. */
+#ifdef XFree86Server
+   ppixIn = (Pixel *) MALLOC(cmapSize * sizeof(Pixel));
+   ctable = (xrgb *) MALLOC(cmapSize * sizeof(xrgb));
+   for (i = 0; i < cmapSize; i++) {
+      ppixIn[i] = i;
+   }
+   QueryColors(cmap, cmapSize, ppixIn, ctable);
+#else
+   if (prevDisplay != dpy || prevCmap != cmap
+       || prevCmapSize != cmapSize || !ctable) {
+      /* free previously cached color table */
+      if (ctable)
+         FREE(ctable);
+      /* Get the color table from X */
+      ctable = (XMesaColor *) MALLOC(cmapSize * sizeof(XMesaColor));
+      assert(ctable);
+      for (i = 0; i < cmapSize; i++) {
+         ctable[i].pixel = i;
+      }
+      XQueryColors(dpy, cmap, ctable, cmapSize);
+      prevDisplay = dpy;
+      prevCmap = cmap;
+      prevCmapSize = cmapSize;
+   }
+#endif
+
+   /* Find best match. */
+   bestmatch = -1;
+   mindist = 0.0;
+   for (i = 0; i < cmapSize; i++) {
+      double dr = 0.30 * ((double) color->red - (double) ctable[i].red);
+      double dg = 0.59 * ((double) color->green - (double) ctable[i].green);
+      double db = 0.11 * ((double) color->blue - (double) ctable[i].blue);
+      double dist = dr * dr + dg * dg + db * db;
+      if (bestmatch < 0 || dist < mindist) {
+         bestmatch = i;
+         mindist = dist;
+      }
+   }
+
+   /* Return result. */
+   subColor.red   = ctable[bestmatch].red;
+   subColor.green = ctable[bestmatch].green;
+   subColor.blue  = ctable[bestmatch].blue;
+   /* Try to allocate the closest match color.  This should only
+    * fail if the cell is read/write.  Otherwise, we're incrementing
+    * the cell's reference count.
+    */
+#ifdef XFree86Server
+   if (AllocColor(cmap,
+		  &subColor.red, &subColor.green, &subColor.blue,
+		  &subColor.pixel,
+		  client) == Success) {
+#else
+   if (XAllocColor(dpy, cmap, &subColor)) {
+#endif
+      *alloced = 1;
+   }
+   else {
+      /* do this to work around a problem reported by Frank Ortega */
+      subColor.pixel = (unsigned long) bestmatch;
+      subColor.red   = ctable[bestmatch].red;
+      subColor.green = ctable[bestmatch].green;
+      subColor.blue  = ctable[bestmatch].blue;
+      subColor.flags = DoRed | DoGreen | DoBlue;
+      *alloced = 0;
+   }
+#ifdef XFree86Server
+   FREE(ppixIn);
+   FREE(ctable);
+#else
+   /* don't free table, save it for next time */
+#endif
+
+   *color = subColor;
+   *exact = 0;
+}
+
+
+
+
+/*
+ * Do setup for PF_GRAYSCALE pixel format.
+ * Note that buffer may be NULL.
+ */
+static GLboolean setup_grayscale( int client, XMesaVisual v,
+                                  XMesaBuffer buffer, XMesaColormap cmap )
+{
+   if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
+      return GL_FALSE;
+   }
+
+   if (buffer) {
+      XMesaBuffer prevBuffer;
+
+      if (!cmap) {
+         return GL_FALSE;
+      }
+
+      prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
+      if (prevBuffer &&
+          (buffer->xm_visual->mesa_visual.rgbMode ==
+           prevBuffer->xm_visual->mesa_visual.rgbMode)) {
+         /* Copy colormap stuff from previous XMesaBuffer which uses same
+          * X colormap.  Do this to avoid time spent in noFaultXAllocColor.
+          */
+         copy_colortable_info(buffer, prevBuffer);
+      }
+      else {
+         /* Allocate 256 shades of gray */
+         int gray;
+         int colorsfailed = 0;
+         for (gray=0;gray<256;gray++) {
+            GLint r = gamma_adjust( v->RedGamma,   gray, 255 );
+            GLint g = gamma_adjust( v->GreenGamma, gray, 255 );
+            GLint b = gamma_adjust( v->BlueGamma,  gray, 255 );
+            int exact, alloced;
+            XMesaColor xcol;
+            xcol.red   = (r << 8) | r;
+            xcol.green = (g << 8) | g;
+            xcol.blue  = (b << 8) | b;
+            noFaultXAllocColor( client, v->display,
+                                cmap, GET_COLORMAP_SIZE(v),
+                                &xcol, &exact, &alloced );
+            if (!exact) {
+               colorsfailed++;
+            }
+            if (alloced) {
+               assert(buffer->num_alloced<256);
+               buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
+               buffer->num_alloced++;
+            }
+
+            /*OLD
+            assert(gray < 576);
+            buffer->color_table[gray*3+0] = xcol.pixel;
+            buffer->color_table[gray*3+1] = xcol.pixel;
+            buffer->color_table[gray*3+2] = xcol.pixel;
+            assert(xcol.pixel < 65536);
+            buffer->pixel_to_r[xcol.pixel] = gray * 30 / 100;
+            buffer->pixel_to_g[xcol.pixel] = gray * 59 / 100;
+            buffer->pixel_to_b[xcol.pixel] = gray * 11 / 100;
+            */
+            buffer->color_table[gray] = xcol.pixel;
+            assert(xcol.pixel < 65536);
+            buffer->pixel_to_r[xcol.pixel] = gray;
+            buffer->pixel_to_g[xcol.pixel] = gray;
+            buffer->pixel_to_b[xcol.pixel] = gray;
+         }
+
+         if (colorsfailed && getenv("MESA_DEBUG")) {
+            fprintf( stderr,
+                  "Note: %d out of 256 needed colors do not match exactly.\n",
+                  colorsfailed );
+         }
+      }
+   }
+
+   v->dithered_pf = PF_GRAYSCALE;
+   v->undithered_pf = PF_GRAYSCALE;
+   return GL_TRUE;
+}
+
+
+
+/*
+ * Setup RGB rendering for a window with a PseudoColor, StaticColor,
+ * or 8-bit TrueColor visual visual.  We try to allocate a palette of 225
+ * colors (5 red, 9 green, 5 blue) and dither to approximate a 24-bit RGB
+ * color.  While this function was originally designed just for 8-bit
+ * visuals, it has also proven to work from 4-bit up to 16-bit visuals.
+ * Dithering code contributed by Bob Mercier.
+ */
+static GLboolean setup_dithered_color( int client, XMesaVisual v,
+                                       XMesaBuffer buffer, XMesaColormap cmap )
+{
+   if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
+      return GL_FALSE;
+   }
+
+   if (buffer) {
+      XMesaBuffer prevBuffer;
+
+      if (!cmap) {
+         return GL_FALSE;
+      }
+
+      prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
+      if (prevBuffer &&
+          (buffer->xm_visual->mesa_visual.rgbMode ==
+           prevBuffer->xm_visual->mesa_visual.rgbMode)) {
+         /* Copy colormap stuff from previous, matching XMesaBuffer.
+          * Do this to avoid time spent in noFaultXAllocColor.
+          */
+         copy_colortable_info(buffer, prevBuffer);
+      }
+      else {
+         /* Allocate X colors and initialize color_table[], red_table[], etc */
+         int r, g, b, i;
+         int colorsfailed = 0;
+         for (r = 0; r < _R; r++) {
+            for (g = 0; g < _G; g++) {
+               for (b = 0; b < _B; b++) {
+                  XMesaColor xcol;
+                  int exact, alloced;
+                  xcol.red  =gamma_adjust(v->RedGamma,   r*65535/(_R-1),65535);
+                  xcol.green=gamma_adjust(v->GreenGamma, g*65535/(_G-1),65535);
+                  xcol.blue =gamma_adjust(v->BlueGamma,  b*65535/(_B-1),65535);
+                  noFaultXAllocColor( client, v->display,
+                                      cmap, GET_COLORMAP_SIZE(v),
+                                      &xcol, &exact, &alloced );
+                  if (!exact) {
+                     colorsfailed++;
+                  }
+                  if (alloced) {
+                     assert(buffer->num_alloced<256);
+                     buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
+                     buffer->num_alloced++;
+                  }
+                  i = _MIX( r, g, b );
+                  assert(i < 576);
+                  buffer->color_table[i] = xcol.pixel;
+                  assert(xcol.pixel < 65536);
+                  buffer->pixel_to_r[xcol.pixel] = r * 255 / (_R-1);
+                  buffer->pixel_to_g[xcol.pixel] = g * 255 / (_G-1);
+                  buffer->pixel_to_b[xcol.pixel] = b * 255 / (_B-1);
+               }
+            }
+         }
+
+         if (colorsfailed && getenv("MESA_DEBUG")) {
+            fprintf( stderr,
+                  "Note: %d out of %d needed colors do not match exactly.\n",
+                  colorsfailed, _R*_G*_B );
+         }
+      }
+   }
+
+   v->dithered_pf = PF_DITHER;
+   v->undithered_pf = PF_LOOKUP;
+   return GL_TRUE;
+}
+
+
+/*
+ * Setup for Hewlett Packard Color Recovery 8-bit TrueColor mode.
+ * HPCR simulates 24-bit color fidelity with an 8-bit frame buffer.
+ * Special dithering tables have to be initialized.
+ */
+static void setup_8bit_hpcr( XMesaVisual v )
+{
+   /* HP Color Recovery contributed by:  Alex De Bruyn (ad@lms.be)
+    * To work properly, the atom _HP_RGB_SMOOTH_MAP_LIST must be defined
+    * on the root window AND the colormap obtainable by XGetRGBColormaps
+    * for that atom must be set on the window.  (see also tkInitWindow)
+    * If that colormap is not set, the output will look stripy.
+    */
+
+   /* Setup color tables with gamma correction */
+   int i;
+   double g;
+
+   g = 1.0 / v->RedGamma;
+   for (i=0; i<256; i++) {
+      GLint red = IROUND_POS(255.0 * pow( hpcr_rgbTbl[0][i]/255.0, g ));
+      v->hpcr_rgbTbl[0][i] = CLAMP( red, 16, 239 );
+   }
+
+   g = 1.0 / v->GreenGamma;
+   for (i=0; i<256; i++) {
+      GLint green = IROUND_POS(255.0 * pow( hpcr_rgbTbl[1][i]/255.0, g ));
+      v->hpcr_rgbTbl[1][i] = CLAMP( green, 16, 239 );
+   }
+
+   g = 1.0 / v->BlueGamma;
+   for (i=0; i<256; i++) {
+      GLint blue = IROUND_POS(255.0 * pow( hpcr_rgbTbl[2][i]/255.0, g ));
+      v->hpcr_rgbTbl[2][i] = CLAMP( blue, 32, 223 );
+   }
+   v->undithered_pf = PF_HPCR;  /* can't really disable dithering for now */
+   v->dithered_pf = PF_HPCR;
+
+   /* which method should I use to clear */
+   /* GL_FALSE: keep the ordinary method  */
+   /* GL_TRUE : clear with dither pattern */
+   v->hpcr_clear_flag = getenv("MESA_HPCR_CLEAR") ? GL_TRUE : GL_FALSE;
+
+   if (v->hpcr_clear_flag) {
+      v->hpcr_clear_pixmap = XMesaCreatePixmap(v->display,
+                                               DefaultRootWindow(v->display),
+                                               16, 2, 8);
+#ifndef XFree86Server
+      v->hpcr_clear_ximage = XGetImage(v->display, v->hpcr_clear_pixmap,
+                                       0, 0, 16, 2, AllPlanes, ZPixmap);
+#endif
+   }
+}
+
+
+/*
+ * Setup RGB rendering for a window with a True/DirectColor visual.
+ */
+static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer,
+                             XMesaColormap cmap )
+{
+   unsigned long rmask, gmask, bmask;
+   (void) buffer;
+   (void) cmap;
+
+   /* Compute red multiplier (mask) and bit shift */
+   v->rshift = 0;
+   rmask = GET_REDMASK(v);
+   while ((rmask & 1)==0) {
+      v->rshift++;
+      rmask = rmask >> 1;
+   }
+
+   /* Compute green multiplier (mask) and bit shift */
+   v->gshift = 0;
+   gmask = GET_GREENMASK(v);
+   while ((gmask & 1)==0) {
+      v->gshift++;
+      gmask = gmask >> 1;
+   }
+
+   /* Compute blue multiplier (mask) and bit shift */
+   v->bshift = 0;
+   bmask = GET_BLUEMASK(v);
+   while ((bmask & 1)==0) {
+      v->bshift++;
+      bmask = bmask >> 1;
+   }
+
+   /*
+    * Compute component-to-pixel lookup tables and dithering kernel
+    */
+   {
+      static GLubyte kernel[16] = {
+          0*16,  8*16,  2*16, 10*16,
+         12*16,  4*16, 14*16,  6*16,
+          3*16, 11*16,  1*16,  9*16,
+         15*16,  7*16, 13*16,  5*16,
+      };
+      GLint rBits = bitcount(rmask);
+      GLint gBits = bitcount(gmask);
+      GLint bBits = bitcount(bmask);
+      GLint maxBits;
+      GLuint i;
+
+      /* convert pixel components in [0,_mask] to RGB values in [0,255] */
+      for (i=0; i<=rmask; i++)
+         v->PixelToR[i] = (unsigned char) ((i * 255) / rmask);
+      for (i=0; i<=gmask; i++)
+         v->PixelToG[i] = (unsigned char) ((i * 255) / gmask);
+      for (i=0; i<=bmask; i++)
+         v->PixelToB[i] = (unsigned char) ((i * 255) / bmask);
+
+      /* convert RGB values from [0,255] to pixel components */
+
+      for (i=0;i<256;i++) {
+         GLint r = gamma_adjust(v->RedGamma,   i, 255);
+         GLint g = gamma_adjust(v->GreenGamma, i, 255);
+         GLint b = gamma_adjust(v->BlueGamma,  i, 255);
+         v->RtoPixel[i] = (r >> (8-rBits)) << v->rshift;
+         v->GtoPixel[i] = (g >> (8-gBits)) << v->gshift;
+         v->BtoPixel[i] = (b >> (8-bBits)) << v->bshift;
+      }
+      /* overflow protection */
+      for (i=256;i<512;i++) {
+         v->RtoPixel[i] = v->RtoPixel[255];
+         v->GtoPixel[i] = v->GtoPixel[255];
+         v->BtoPixel[i] = v->BtoPixel[255];
+      }
+
+      /* setup dithering kernel */
+      maxBits = rBits;
+      if (gBits > maxBits)  maxBits = gBits;
+      if (bBits > maxBits)  maxBits = bBits;
+      for (i=0;i<16;i++) {
+         v->Kernel[i] = kernel[i] >> maxBits;
+      }
+
+      v->undithered_pf = PF_TRUECOLOR;
+      v->dithered_pf = (GET_VISUAL_DEPTH(v)<24) ? PF_TRUEDITHER : PF_TRUECOLOR;
+   }
+
+   /*
+    * Now check for TrueColor visuals which we can optimize.
+    */
+   if (   GET_REDMASK(v)  ==0x0000ff
+       && GET_GREENMASK(v)==0x00ff00
+       && GET_BLUEMASK(v) ==0xff0000
+       && CHECK_BYTE_ORDER(v)
+       && v->BitsPerPixel==32
+       && sizeof(GLuint)==4
+       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+      /* common 32 bpp config used on SGI, Sun */
+      v->undithered_pf = v->dithered_pf = PF_8A8B8G8R;
+   }
+   else if (GET_REDMASK(v)  ==0xff0000
+       &&   GET_GREENMASK(v)==0x00ff00
+       &&   GET_BLUEMASK(v) ==0x0000ff
+       && CHECK_BYTE_ORDER(v)
+       && v->BitsPerPixel==32
+       && sizeof(GLuint)==4
+       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+      /* common 32 bpp config used on Linux, HP, IBM */
+      v->undithered_pf = v->dithered_pf = PF_8R8G8B;
+   }
+   else if (GET_REDMASK(v)  ==0xff0000
+       &&   GET_GREENMASK(v)==0x00ff00
+       &&   GET_BLUEMASK(v) ==0x0000ff
+       && CHECK_BYTE_ORDER(v)
+       && v->BitsPerPixel==24
+       && sizeof(GLuint)==4
+       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+      /* common packed 24 bpp config used on Linux */
+      v->undithered_pf = v->dithered_pf = PF_8R8G8B24;
+   }
+   else if (GET_REDMASK(v)  ==0xf800
+       &&   GET_GREENMASK(v)==0x07e0
+       &&   GET_BLUEMASK(v) ==0x001f
+       && CHECK_BYTE_ORDER(v)
+       && v->BitsPerPixel==16
+       && sizeof(GLushort)==2
+       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
+      /* 5-6-5 color weight on common PC VGA boards */
+      v->undithered_pf = PF_5R6G5B;
+      v->dithered_pf = PF_DITHER_5R6G5B;
+   }
+   else if (GET_REDMASK(v)  ==0xe0
+       &&   GET_GREENMASK(v)==0x1c
+       &&   GET_BLUEMASK(v) ==0x03
+       && CHECK_FOR_HPCR(v)) {
+      setup_8bit_hpcr( v );
+   }
+}
+
+
+
+/*
+ * Setup RGB rendering for a window with a monochrome visual.
+ */
+static void setup_monochrome( XMesaVisual v, XMesaBuffer b )
+{
+   (void) b;
+   v->dithered_pf = v->undithered_pf = PF_1BIT;
+   /* if black=1 then we must flip pixel values */
+   v->bitFlip = (GET_BLACK_PIXEL(v) != 0);
+}
+
+
+
+/*
+ * When a context is "made current" for the first time, we can finally
+ * finish initializing the context's visual and buffer information.
+ * Input:  v - the XMesaVisual to initialize
+ *         b - the XMesaBuffer to initialize (may be NULL)
+ *         rgb_flag - TRUE = RGBA mode, FALSE = color index mode
+ *         window - the window/pixmap we're rendering into
+ *         cmap - the colormap associated with the window/pixmap
+ * Return:  GL_TRUE=success, GL_FALSE=failure
+ */
+static GLboolean initialize_visual_and_buffer( int client,
+                                               XMesaVisual v,
+                                               XMesaBuffer b,
+                                               GLboolean rgb_flag,
+                                               XMesaDrawable window,
+                                               XMesaColormap cmap
+                                             )
+{
+#ifndef XFree86Server
+   XGCValues gcvalues;
+#endif
+
+   if (b) {
+      assert(b->xm_visual == v);
+   }
+
+   /* Save true bits/pixel */
+   v->BitsPerPixel = GET_BITS_PER_PIXEL(v);
+   assert(v->BitsPerPixel > 0);
+
+
+   if (rgb_flag==GL_FALSE) {
+      /* COLOR-INDEXED WINDOW:
+       * Even if the visual is TrueColor or DirectColor we treat it as
+       * being color indexed.  This is weird but might be useful to someone.
+       */
+      v->dithered_pf = v->undithered_pf = PF_INDEX;
+      v->index_bits = GET_VISUAL_DEPTH(v);
+   }
+   else {
+      /* RGB WINDOW:
+       * We support RGB rendering into almost any kind of visual.
+       */
+      int xclass;
+      xclass = GET_VISUAL_CLASS(v);
+      if (xclass==TrueColor || xclass==DirectColor) {
+	 setup_truecolor( v, b, cmap );
+      }
+      else if (xclass==StaticGray && GET_VISUAL_DEPTH(v)==1) {
+	 setup_monochrome( v, b );
+      }
+      else if (xclass==GrayScale || xclass==StaticGray) {
+         if (!setup_grayscale( client, v, b, cmap )) {
+            return GL_FALSE;
+         }
+      }
+      else if ((xclass==PseudoColor || xclass==StaticColor)
+               && GET_VISUAL_DEPTH(v)>=4 && GET_VISUAL_DEPTH(v)<=16) {
+	 if (!setup_dithered_color( client, v, b, cmap )) {
+            return GL_FALSE;
+         }
+      }
+      else {
+	 error("XMesa: RGB mode rendering not supported in given visual.");
+	 return GL_FALSE;
+      }
+      v->index_bits = 0;
+
+      if (getenv("MESA_NO_DITHER")) {
+	 v->dithered_pf = v->undithered_pf;
+      }
+   }
+
+
+   /*
+    * If MESA_INFO env var is set print out some debugging info
+    * which can help Brian figure out what's going on when a user
+    * reports bugs.
+    */
+   if (getenv("MESA_INFO")) {
+      fprintf(stderr, "X/Mesa visual = %p\n", (void *) v);
+      fprintf(stderr, "X/Mesa dithered pf = %u\n", v->dithered_pf);
+      fprintf(stderr, "X/Mesa undithered pf = %u\n", v->undithered_pf);
+      fprintf(stderr, "X/Mesa level = %d\n", v->level);
+      fprintf(stderr, "X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v));
+      fprintf(stderr, "X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
+   }
+
+   if (b && window) {
+      /* Do window-specific initializations */
+
+      /* Window dimensions */
+      unsigned int w, h;
+      get_drawable_size( v->display, window, &w, &h );
+      b->width = w;
+      b->height = h;
+
+      b->frontbuffer = window;
+
+      /* Setup for single/double buffering */
+      if (v->mesa_visual.doubleBufferMode) {
+         /* Double buffered */
+#ifndef XFree86Server
+         b->shm = check_for_xshm( v->display );
+#endif
+         xmesa_alloc_back_buffer( b );
+         if (b->db_state==BACK_PIXMAP) {
+            b->buffer = (XMesaDrawable)b->backpixmap;
+         }
+         else {
+            b->buffer = XIMAGE;
+         }
+      }
+      else {
+         /* Single Buffered */
+         b->buffer = b->frontbuffer;
+      }
+
+      /* X11 graphics contexts */
+#ifdef XFree86Server
+      b->gc = CreateScratchGC(v->display, window->depth);
+#else
+      b->gc = XCreateGC( v->display, window, 0, NULL );
+#endif
+      XMesaSetFunction( v->display, b->gc, GXcopy );
+
+      /* cleargc - for glClear() */
+#ifdef XFree86Server
+      b->cleargc = CreateScratchGC(v->display, window->depth);
+#else
+      b->cleargc = XCreateGC( v->display, window, 0, NULL );
+#endif
+      XMesaSetFunction( v->display, b->cleargc, GXcopy );
+
+      /*
+       * Don't generate Graphics Expose/NoExpose events in swapbuffers().
+       * Patch contributed by Michael Pichler May 15, 1995.
+       */
+#ifdef XFree86Server
+      b->swapgc = CreateScratchGC(v->display, window->depth);
+      {
+	  CARD32 v[1];
+	  v[0] = FALSE;
+	  dixChangeGC(NullClient, b->swapgc, GCGraphicsExposures, v, NULL);
+      }
+#else
+      gcvalues.graphics_exposures = False;
+      b->swapgc = XCreateGC( v->display, window,
+                              GCGraphicsExposures, &gcvalues);
+#endif
+      XMesaSetFunction( v->display, b->swapgc, GXcopy );
+      /*
+       * Set fill style and tile pixmap once for all for HPCR stuff
+       * (instead of doing it each time in clear_color_HPCR_pixmap())
+       * Initialize whole stuff
+       * Patch contributed by Jacques Leroy March 8, 1998.
+       */
+      if (v->hpcr_clear_flag && b->buffer!=XIMAGE) {
+	int i;
+	for (i=0; i<16; i++)
+        {
+	   XMesaPutPixel(v->hpcr_clear_ximage, i, 0, 0);
+	   XMesaPutPixel(v->hpcr_clear_ximage, i, 1, 0);
+        }
+        XMesaPutImage(b->display, (XMesaDrawable)v->hpcr_clear_pixmap,
+		      b->cleargc, v->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
+	XMesaSetFillStyle( v->display, b->cleargc, FillTiled);
+	XMesaSetTile( v->display, b->cleargc, v->hpcr_clear_pixmap );
+      }
+
+      /* Initialize the row buffer XImage for use in write_color_span() */
+#ifdef XFree86Server
+      b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1,
+				     (char *)MALLOC(MAX_WIDTH*4));
+#else
+      b->rowimage = XCreateImage( v->display,
+                                  v->visinfo->visual,
+                                  v->visinfo->depth,
+                                  ZPixmap, 0,           /*format, offset*/
+                                  (char*) MALLOC(MAX_WIDTH*4),  /*data*/
+                                  MAX_WIDTH, 1,         /*width, height*/
+                                  32,                   /*bitmap_pad*/
+                                  0                     /*bytes_per_line*/ );
+#endif
+   }
+
+   return GL_TRUE;
+}
+
+
+
+/*
+ * Convert an RGBA color to a pixel value.
+ */
+unsigned long
+xmesa_color_to_pixel( XMesaContext xmesa, GLubyte r, GLubyte g, GLubyte b, GLubyte a,
+                      GLuint pixelFormat)
+{
+   switch (pixelFormat) {
+      case PF_INDEX:
+         return 0;
+      case PF_TRUECOLOR:
+         {
+            unsigned long p;
+            PACK_TRUECOLOR( p, r, g, b );
+            return p;
+         }
+      case PF_8A8B8G8R:
+         return PACK_8A8B8G8R( r, g, b, a );
+      case PF_8R8G8B:
+         /* fall through */
+      case PF_8R8G8B24:
+         return PACK_8R8G8B( r, g, b );
+      case PF_5R6G5B:
+         return PACK_5R6G5B( r, g, b );
+      case PF_DITHER:
+         {
+            DITHER_SETUP;
+            return DITHER( 1, 0, r, g, b );
+         }
+      case PF_1BIT:
+         /* 382 = (3*255)/2 */
+         return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
+      case PF_HPCR:
+         return DITHER_HPCR(1, 1, r, g, b);
+      case PF_LOOKUP:
+         {
+            LOOKUP_SETUP;
+            return LOOKUP( r, g, b );
+         }
+      case PF_GRAYSCALE:
+         return GRAY_RGB( r, g, b );
+      case PF_TRUEDITHER:
+         /* fall through */
+      case PF_DITHER_5R6G5B:
+         {
+            unsigned long p;
+            PACK_TRUEDITHER(p, 1, 0, r, g, b);
+            return p;
+         }
+      default:
+         _mesa_problem(NULL, "Bad pixel format in xmesa_color_to_pixel");
+   }
+   return 0;
+}
+
+
+/**********************************************************************/
+/*****                       Public Functions                     *****/
+/**********************************************************************/
+
+
+/*
+ * Create a new X/Mesa visual.
+ * Input:  display - X11 display
+ *         visinfo - an XVisualInfo pointer
+ *         rgb_flag - GL_TRUE = RGB mode,
+ *                    GL_FALSE = color index mode
+ *         alpha_flag - alpha buffer requested?
+ *         db_flag - GL_TRUE = double-buffered,
+ *                   GL_FALSE = single buffered
+ *         stereo_flag - stereo visual?
+ *         ximage_flag - GL_TRUE = use an XImage for back buffer,
+ *                       GL_FALSE = use an off-screen pixmap for back buffer
+ *         depth_size - requested bits/depth values, or zero
+ *         stencil_size - requested bits/stencil values, or zero
+ *         accum_red_size - requested bits/red accum values, or zero
+ *         accum_green_size - requested bits/green accum values, or zero
+ *         accum_blue_size - requested bits/blue accum values, or zero
+ *         accum_alpha_size - requested bits/alpha accum values, or zero
+ *         num_samples - number of samples/pixel if multisampling, or zero
+ *         level - visual level, usually 0
+ *         visualCaveat - ala the GLX extension, usually GLX_NONE_EXT
+ * Return;  a new XMesaVisual or 0 if error.
+ */
+XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
+                               XMesaVisualInfo visinfo,
+                               GLboolean rgb_flag,
+                               GLboolean alpha_flag,
+                               GLboolean db_flag,
+                               GLboolean stereo_flag,
+                               GLboolean ximage_flag,
+                               GLint depth_size,
+                               GLint stencil_size,
+                               GLint accum_red_size,
+                               GLint accum_green_size,
+                               GLint accum_blue_size,
+                               GLint accum_alpha_size,
+                               GLint num_samples,
+                               GLint level,
+                               GLint visualCaveat )
+{
+   char *gamma;
+   XMesaVisual v;
+   GLint red_bits, green_bits, blue_bits, alpha_bits;
+
+   /* For debugging only */
+   if (getenv("MESA_XSYNC")) {
+      /* This makes debugging X easier.
+       * In your debugger, set a breakpoint on _XError to stop when an
+       * X protocol error is generated.
+       */
+#ifdef XFree86Server
+      /* NOT_NEEDED */
+#else
+      XSynchronize( display, 1 );
+#endif
+   }
+
+   v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
+   if (!v) {
+      return NULL;
+   }
+
+   /*
+    * In the X server, NULL is passed in for the display.  It will have
+    * to be set before using this visual.  See XMesaSetVisualDisplay()
+    * below.
+    */
+   v->display = display;
+
+   /* Save a copy of the XVisualInfo struct because the user may XFREE()
+    * the struct but we may need some of the information contained in it
+    * at a later time.
+    */
+#ifdef XFree86Server
+   v->visinfo = visinfo;
+#else
+   v->visinfo = (XVisualInfo *) MALLOC(sizeof(*visinfo));
+   if(!v->visinfo) {
+      FREE(v);
+      return NULL;
+   }
+   MEMCPY(v->visinfo, visinfo, sizeof(*visinfo));
+
+   /* Save a copy of the pointer now so we can find this visual again
+    * if we need to search for it in find_glx_visual().
+    */
+   v->vishandle = visinfo;
+#endif
+
+#ifdef XFree86Server
+   /* Initialize the depth of the screen */
+   {
+       PixmapFormatRec *format;
+
+       for (format = screenInfo.formats;
+	    format->depth != display->rootDepth;
+	    format++)
+	   ;
+       v->screen_depth = format->bitsPerPixel;
+   }
+#endif
+
+   /* check for MESA_GAMMA environment variable */
+   gamma = getenv("MESA_GAMMA");
+   if (gamma) {
+      v->RedGamma = v->GreenGamma = v->BlueGamma = 0.0;
+      sscanf( gamma, "%f %f %f", &v->RedGamma, &v->GreenGamma, &v->BlueGamma );
+      if (v->RedGamma<=0.0)    v->RedGamma = 1.0;
+      if (v->GreenGamma<=0.0)  v->GreenGamma = v->RedGamma;
+      if (v->BlueGamma<=0.0)   v->BlueGamma = v->RedGamma;
+   }
+   else {
+      v->RedGamma = v->GreenGamma = v->BlueGamma = 1.0;
+   }
+
+   v->ximage_flag = ximage_flag;
+   v->level = level;
+   v->VisualCaveat = visualCaveat;
+
+   (void) initialize_visual_and_buffer( 0, v, NULL, rgb_flag, 0, 0 );
+
+   {
+      int xclass;
+      xclass = GET_VISUAL_CLASS(v);
+      if (xclass==TrueColor || xclass==DirectColor) {
+         red_bits   = bitcount(GET_REDMASK(v));
+         green_bits = bitcount(GET_GREENMASK(v));
+         blue_bits  = bitcount(GET_BLUEMASK(v));
+         alpha_bits = 0;
+      }
+      else {
+         /* this is an approximation */
+         int depth;
+         depth = GET_VISUAL_DEPTH(v);
+         red_bits = depth / 3;
+         depth -= red_bits;
+         green_bits = depth / 2;
+         depth -= green_bits;
+         blue_bits = depth;
+         alpha_bits = 0;
+         assert( red_bits + green_bits + blue_bits == GET_VISUAL_DEPTH(v) );
+      }
+   }
+
+   if (alpha_flag && alpha_bits == 0)
+      alpha_bits = 8;
+
+   _mesa_initialize_visual( &v->mesa_visual,
+                            rgb_flag, db_flag, stereo_flag,
+                            red_bits, green_bits,
+                            blue_bits, alpha_bits,
+                            v->index_bits,
+                            depth_size,
+                            stencil_size,
+                            accum_red_size, accum_green_size,
+                            accum_blue_size, accum_alpha_size,
+                            0 );
+   return v;
+}
+
+
+void XMesaSetVisualDisplay( XMesaDisplay *dpy, XMesaVisual v )
+{
+    v->display = dpy;
+}
+
+
+void XMesaDestroyVisual( XMesaVisual v )
+{
+#ifndef XFree86Server
+   FREE(v->visinfo);
+#endif
+   FREE(v);
+}
+
+
+
+/*
+ * Create a new XMesaContext.
+ * Input:  v - XMesaVisual
+ *         share_list - another XMesaContext with which to share display
+ *                      lists or NULL if no sharing is wanted.
+ * Return:  an XMesaContext or NULL if error.
+ */
+XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
+{
+   XMesaContext c;
+   GLcontext *ctx;
+   GLboolean direct = GL_TRUE; /* XXXX */
+   /* NOT_DONE: should this be GL_FALSE??? */
+   static GLboolean firstTime = GL_TRUE;
+
+   if (firstTime) {
+      _glthread_INIT_MUTEX(_xmesa_lock);
+      firstTime = GL_FALSE;
+   }
+
+   c = (XMesaContext) CALLOC_STRUCT(xmesa_context);
+   if (!c) {
+      return NULL;
+   }
+
+   ctx = c->gl_ctx = _mesa_create_context( &v->mesa_visual,
+                      share_list ? share_list->gl_ctx : (GLcontext *) NULL,
+                      (void *) c, direct );
+   if (!c->gl_ctx) {
+      FREE(c);
+      return NULL;
+   }
+
+   _mesa_enable_sw_extensions(ctx);
+   _mesa_enable_1_3_extensions(ctx);
+
+   if (CHECK_BYTE_ORDER(v)) {
+      c->swapbytes = GL_FALSE;
+   }
+   else {
+      c->swapbytes = GL_TRUE;
+   }
+
+   c->xm_visual = v;
+   c->xm_buffer = NULL;   /* set later by XMesaMakeCurrent */
+   c->display = v->display;
+   c->pixelformat = v->dithered_pf;      /* Dithering is enabled by default */
+
+   ctx->Driver.UpdateState = xmesa_update_state;
+
+   /* Initialize the software rasterizer and helper modules.
+    */
+   _swrast_CreateContext( ctx );
+   _ac_CreateContext( ctx );
+   _tnl_CreateContext( ctx );
+   _swsetup_CreateContext( ctx );
+
+   xmesa_register_swrast_functions( ctx );
+
+   /* Set up some constant pointers:
+    */
+   xmesa_init_pointers( ctx );
+
+
+   /* Run the config file
+    */
+   _mesa_read_config_file( ctx );
+
+
+   return c;
+}
+
+
+
+
+void XMesaDestroyContext( XMesaContext c )
+{
+#ifdef FX
+   if (c->xm_buffer && c->xm_buffer->FXctx)
+      fxMesaDestroyContext(c->xm_buffer->FXctx);
+#endif
+   if (c->gl_ctx) {
+      _swsetup_DestroyContext( c->gl_ctx );
+      _swrast_DestroyContext( c->gl_ctx );
+      _tnl_DestroyContext( c->gl_ctx );
+      _ac_DestroyContext( c->gl_ctx );
+      _mesa_destroy_context( c->gl_ctx );
+   }
+
+   FREE( c );
+}
+
+
+
+/*
+ * XXX this isn't a public function!  It's a hack for the 3Dfx driver.
+ * Create a new XMesaBuffer from an X window.
+ * Input:  v - the XMesaVisual
+ *         w - the window
+ *         c - the context
+ * Return:  new XMesaBuffer or NULL if error
+ */
+XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v, XMesaWindow w,
+                                      XMesaContext c )
+{
+#ifndef XFree86Server
+   XWindowAttributes attr;
+#endif
+#ifdef FX
+   char *fxEnvVar;
+#endif
+   int client = 0;
+
+   XMesaBuffer b = alloc_xmesa_buffer();
+   if (!b) {
+      return NULL;
+   }
+
+   (void) c;
+
+#ifdef XFree86Server
+   client = CLIENT_ID(((XMesaDrawable)w)->id);
+#endif
+
+   assert(v);
+
+#ifdef XFree86Server
+   if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) {
+#else
+   XGetWindowAttributes( v->display, w, &attr );
+
+   if (GET_VISUAL_DEPTH(v) != attr.depth) {
+#endif
+      if (getenv("MESA_DEBUG")) {
+         fprintf(stderr, "XMesaCreateWindowBuffer: depth mismatch between visual and window!\n");
+      }
+      return NULL;
+   }
+
+   b->xm_visual = v;
+   b->pixmap_flag = GL_FALSE;
+   b->display = v->display;
+#ifdef XFree86Server
+   b->cmap = (ColormapPtr)LookupIDByType(wColormap(w), RT_COLORMAP);
+#else
+   if (attr.colormap) {
+      b->cmap = attr.colormap;
+   }
+   else {
+      if (getenv("MESA_DEBUG")) {
+         fprintf(stderr, "Window %u has no colormap!\n", (unsigned int) w);
+      }
+      /* this is weird, a window w/out a colormap!? */
+      /* OK, let's just allocate a new one and hope for the best */
+      b->cmap = XCreateColormap(v->display, w, attr.visual, AllocNone);
+   }
+#endif
+
+   /* determine back buffer implementation */
+   if (v->mesa_visual.doubleBufferMode) {
+      if (v->ximage_flag) {
+	 b->db_state = BACK_XIMAGE;
+      }
+      else {
+	 b->db_state = BACK_PIXMAP;
+      }
+   }
+   else {
+      b->db_state = 0;
+   }
+
+   _mesa_initialize_framebuffer(&b->mesa_buffer,
+                                &v->mesa_visual,
+                                v->mesa_visual.depthBits > 0,
+                                v->mesa_visual.stencilBits > 0,
+                                v->mesa_visual.accumRedBits > 0,
+                                v->mesa_visual.alphaBits > 0 );
+
+   if (!initialize_visual_and_buffer( client, v, b, v->mesa_visual.rgbMode,
+                                      (XMesaDrawable)w, b->cmap )) {
+      free_xmesa_buffer(client, b);
+      return NULL;
+   }
+
+#ifdef FX
+   fxEnvVar = getenv("MESA_GLX_FX");
+   if (fxEnvVar) {
+     if (fxEnvVar[0]!='d') {
+       int attribs[100];
+       int numAttribs = 0;
+       int hw;
+       if (v->mesa_visual.depthBits > 0) {
+	 attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
+	 attribs[numAttribs++] = 1;
+       }
+       if (v->mesa_visual.doubleBufferMode) {
+	 attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
+       }
+       if (v->mesa_visual.accumRedBits > 0) {
+	 attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
+	 attribs[numAttribs++] = v->mesa_visual.accumRedBits;
+       }
+       if (v->mesa_visual.stencilBits > 0) {
+         attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
+         attribs[numAttribs++] = v->mesa_visual.stencilBits;
+       }
+       if (v->mesa_visual.alphaBits > 0) {
+         attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
+         attribs[numAttribs++] = 1;
+       }
+       if (c->gl_ctx) {
+#define FXMESA_SHARE_CONTEXT 990099  /* keep in sync with fxapi.c! */
+         attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
+         attribs[numAttribs++] = (int) c->gl_ctx;
+       }
+       attribs[numAttribs++] = FXMESA_NONE;
+
+       if ((hw = fxQueryHardware())==GR_SSTTYPE_VOODOO) {
+         b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
+         if ((v->undithered_pf!=PF_INDEX) && (b->backimage)) {
+	   b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
+	   if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
+	     b->FXwindowHack = b->FXctx ? GL_TRUE : GL_FALSE;
+	   else
+	     b->FXwindowHack = GL_FALSE;
+         }
+       }
+       else {
+         if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
+	   b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
+					  GR_REFRESH_75Hz, attribs);
+         else
+	   b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
+         b->FXisHackUsable = GL_FALSE;
+         b->FXwindowHack = GL_FALSE;
+       }
+       /*
+       fprintf(stderr,
+               "voodoo %d, wid %d height %d hack: usable %d active %d\n",
+               hw, b->width, b->height, b->FXisHackUsable, b->FXwindowHack);
+       */
+     }
+   }
+   else {
+      fprintf(stderr,"WARNING: This Mesa Library includes the Glide driver but\n");
+      fprintf(stderr,"         you have not defined the MESA_GLX_FX env. var.\n");
+      fprintf(stderr,"         (check the README.3DFX file for more information).\n\n");
+      fprintf(stderr,"         you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
+   }
+#endif
+
+   return b;
+}
+
+
+XMesaBuffer XMesaCreateWindowBuffer( XMesaVisual v, XMesaWindow w )
+{
+   return XMesaCreateWindowBuffer2( v, w, NULL );
+}
+
+
+/*
+ * Create a new XMesaBuffer from an X pixmap.
+ * Input:  v - the XMesaVisual
+ *         p - the pixmap
+ *         cmap - the colormap, may be 0 if using a TrueColor or DirectColor
+ *                visual for the pixmap
+ * Return:  new XMesaBuffer or NULL if error
+ */
+XMesaBuffer XMesaCreatePixmapBuffer( XMesaVisual v,
+				     XMesaPixmap p, XMesaColormap cmap )
+{
+   int client = 0;
+   XMesaBuffer b = alloc_xmesa_buffer();
+   if (!b) {
+      return NULL;
+   }
+
+
+#ifdef XFree86Server
+   client = CLIENT_ID(((XMesaDrawable)p)->id);
+#endif
+
+   assert(v);
+
+   b->xm_visual = v;
+   b->pixmap_flag = GL_TRUE;
+   b->display = v->display;
+   b->cmap = cmap;
+
+   /* determine back buffer implementation */
+   if (v->mesa_visual.doubleBufferMode) {
+      if (v->ximage_flag) {
+	 b->db_state = BACK_XIMAGE;
+      }
+      else {
+	 b->db_state = BACK_PIXMAP;
+      }
+   }
+   else {
+      b->db_state = 0;
+   }
+
+   _mesa_initialize_framebuffer(&b->mesa_buffer,
+                                &v->mesa_visual,
+                                v->mesa_visual.depthBits > 0,
+                                v->mesa_visual.stencilBits > 0,
+                                v->mesa_visual.accumRedBits +
+                                v->mesa_visual.accumGreenBits +
+                                v->mesa_visual.accumBlueBits > 0,
+                                v->mesa_visual.alphaBits > 0 );
+
+   if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
+				     (XMesaDrawable)p, cmap)) {
+      free_xmesa_buffer(client, b);
+      return NULL;
+   }
+
+   return b;
+}
+
+
+
+#if 0 /* not done */
+XMesaBuffer XMesaCreatePBuffer( XMesaVisual v, XMesaColormap cmap,
+                                unsigned int width, unsigned int height )
+{
+   int client = 0;
+   XMesaBuffer b = alloc_xmesa_buffer();
+   if (!b) {
+      return NULL;
+   }
+
+   b->xm_visual = v;
+   b->pbuffer_flag = GL_TRUE;
+   b->display = v->display;
+   b->cmap = cmap;
+
+   /* determine back buffer implementation */
+   if (v->mesa_visual.doubleBufferMode) {
+      if (v->ximage_flag) {
+	 b->db_state = BACK_XIMAGE;
+      }
+      else {
+	 b->db_state = BACK_PIXMAP;
+      }
+   }
+   else {
+      b->db_state = 0;
+   }
+
+   _mesa_initialize_framebuffer(&b->mesa_buffer,
+                                &v->mesa_visual,
+                                v->mesa_visual.depthBits > 0,
+                                v->mesa_visual.stencilBits > 0,
+                                v->mesa_visual.accumRedBits +
+                                v->mesa_visual.accumGreenBits +
+                                v->mesa_visual.accumBlueBits > 0,
+                                v->mesa_visual.alphaBits > 0 );
+
+   if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
+				     0, cmap)) {
+      free_xmesa_buffer(client, b);
+      return NULL;
+   }
+
+   return b;
+}
+#endif
+
+
+
+/*
+ * Deallocate an XMesaBuffer structure and all related info.
+ */
+void XMesaDestroyBuffer( XMesaBuffer b )
+{
+   int client = 0;
+
+#ifdef XFree86Server
+   if (b->frontbuffer)
+       client = CLIENT_ID(b->frontbuffer->id);
+#endif
+
+   if (b->gc)  XMesaFreeGC( b->xm_visual->display, b->gc );
+   if (b->cleargc)  XMesaFreeGC( b->xm_visual->display, b->cleargc );
+   if (b->swapgc)  XMesaFreeGC( b->xm_visual->display, b->swapgc );
+
+   if (b->backimage) {
+#if defined(USE_XSHM) && !defined(XFree86Server)
+       if (b->shm) {
+	   XShmDetach( b->xm_visual->display, &b->shminfo );
+	   XDestroyImage( b->backimage );
+	   shmdt( b->shminfo.shmaddr );
+       }
+       else
+#endif
+	   XMesaDestroyImage( b->backimage );
+   }
+   if (b->backpixmap) {
+      XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
+      if (b->xm_visual->hpcr_clear_flag) {
+	XMesaFreePixmap( b->xm_visual->display,
+			 b->xm_visual->hpcr_clear_pixmap );
+	XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage );
+      }
+   }
+   if (b->rowimage) {
+      FREE( b->rowimage->data );
+      b->rowimage->data = NULL;
+      XMesaDestroyImage( b->rowimage );
+   }
+
+   free_xmesa_buffer(client, b);
+}
+
+
+
+/*
+ * Bind buffer b to context c and make c the current rendering context.
+ */
+GLboolean XMesaMakeCurrent( XMesaContext c, XMesaBuffer b )
+{
+   return XMesaMakeCurrent2( c, b, b );
+}
+
+
+/*
+ * Bind buffer b to context c and make c the current rendering context.
+ */
+GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
+                             XMesaBuffer readBuffer )
+{
+   if (c) {
+      if (!drawBuffer || !readBuffer)
+         return GL_FALSE;  /* must specify buffers! */
+
+#ifdef FX
+      if (drawBuffer->FXctx) {
+         fxMesaMakeCurrent(drawBuffer->FXctx);
+
+         c->xm_buffer = drawBuffer;
+         c->xm_read_buffer = readBuffer;
+         c->use_read_buffer = (drawBuffer != readBuffer);
+
+         return GL_TRUE;
+      }
+#endif
+      if (c->gl_ctx == _mesa_get_current_context()
+          && c->xm_buffer == drawBuffer
+          && c->xm_read_buffer == readBuffer
+          && c->xm_buffer->wasCurrent) {
+         /* same context and buffer, do nothing */
+         return GL_TRUE;
+      }
+
+      c->xm_buffer = drawBuffer;
+      c->xm_read_buffer = readBuffer;
+      c->use_read_buffer = (drawBuffer != readBuffer);
+
+      _mesa_make_current2(c->gl_ctx,
+                          &drawBuffer->mesa_buffer,
+                          &readBuffer->mesa_buffer);
+
+      if (c->gl_ctx->Viewport.Width == 0) {
+	 /* initialize viewport to window size */
+	 _mesa_Viewport( 0, 0, drawBuffer->width, drawBuffer->height );
+	 c->gl_ctx->Scissor.Width = drawBuffer->width;
+	 c->gl_ctx->Scissor.Height = drawBuffer->height;
+      }
+
+      if (c->xm_visual->mesa_visual.rgbMode) {
+         /*
+          * Must recompute and set these pixel values because colormap
+          * can be different for different windows.
+          */
+         c->clearpixel = xmesa_color_to_pixel( c,
+                                               c->clearcolor[0],
+                                               c->clearcolor[1],
+                                               c->clearcolor[2],
+                                               c->clearcolor[3],
+                                               c->xm_visual->undithered_pf);
+         XMesaSetForeground(c->display, c->xm_buffer->cleargc, c->clearpixel);
+      }
+
+      /* Solution to Stephane Rehel's problem with glXReleaseBuffersMESA(): */
+      c->xm_buffer->wasCurrent = GL_TRUE;
+   }
+   else {
+      /* Detach */
+      _mesa_make_current2( NULL, NULL, NULL );
+   }
+   return GL_TRUE;
+}
+
+
+/*
+ * Unbind the context c from its buffer.
+ */
+GLboolean XMesaUnbindContext( XMesaContext c )
+{
+   /* A no-op for XFree86 integration purposes */
+   return GL_TRUE;
+}
+
+
+XMesaContext XMesaGetCurrentContext( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (ctx) {
+      XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+      return xmesa;
+   }
+   else {
+      return 0;
+   }
+}
+
+
+XMesaBuffer XMesaGetCurrentBuffer( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (ctx) {
+      XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+      return xmesa->xm_buffer;
+   }
+   else {
+      return 0;
+   }
+}
+
+
+/* New in Mesa 3.1 */
+XMesaBuffer XMesaGetCurrentReadBuffer( void )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (ctx) {
+      XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+      return xmesa->xm_buffer;
+   }
+   else {
+      return 0;
+   }
+}
+
+
+GLboolean XMesaForceCurrent(XMesaContext c)
+{
+   if (c) {
+      if (c->gl_ctx != _mesa_get_current_context()) {
+	 _mesa_make_current(c->gl_ctx, &c->xm_buffer->mesa_buffer);
+      }
+   }
+   else {
+      _mesa_make_current(NULL, NULL);
+   }
+   return GL_TRUE;
+}
+
+
+GLboolean XMesaLoseCurrent(XMesaContext c)
+{
+   (void) c;
+   _mesa_make_current(NULL, NULL);
+   return GL_TRUE;
+}
+
+
+/*
+ * Switch 3Dfx support hack between window and full-screen mode.
+ */
+GLboolean XMesaSetFXmode( GLint mode )
+{
+#ifdef FX
+   const char *fx = getenv("MESA_GLX_FX");
+   if (fx && fx[0] != 'd') {
+      GET_CURRENT_CONTEXT(ctx);
+      GrHwConfiguration hw;
+      if (!FX_grSstQueryHardware(&hw)) {
+         /*fprintf(stderr, "!grSstQueryHardware\n");*/
+         return GL_FALSE;
+      }
+      if (hw.num_sst < 1) {
+         /*fprintf(stderr, "hw.num_sst < 1\n");*/
+         return GL_FALSE;
+      }
+      if (ctx) {
+         XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+         if (mode == XMESA_FX_WINDOW) {
+	    if (xmesa->xm_buffer->FXisHackUsable) {
+	       FX_grSstControl(GR_CONTROL_DEACTIVATE);
+	       xmesa->xm_buffer->FXwindowHack = GL_TRUE;
+	       return GL_TRUE;
+	    }
+	 }
+	 else if (mode == XMESA_FX_FULLSCREEN) {
+	    FX_grSstControl(GR_CONTROL_ACTIVATE);
+	    xmesa->xm_buffer->FXwindowHack = GL_FALSE;
+	    return GL_TRUE;
+	 }
+	 else {
+	    /* Error: Bad mode value */
+	 }
+      }
+   }
+   /*fprintf(stderr, "fallthrough\n");*/
+#else
+   (void) mode;
+#endif
+   return GL_FALSE;
+}
+
+
+
+#ifdef FX
+/*
+ * Read image from VooDoo frame buffer into X/Mesa's back XImage.
+ */
+static void FXgetImage( XMesaBuffer b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   static unsigned short pixbuf[MAX_WIDTH];
+   GLuint x, y;
+   int xpos, ypos;
+   XMesaWindow root;
+   unsigned int bw, depth, width, height;
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+#ifdef XFree86Server
+   x = b->frontbuffer->x;
+   y = b->frontbuffer->y;
+   width = b->frontbuffer->width;
+   height = b->frontbuffer->height;
+   depth = b->frontbuffer->depth;
+#else
+   XGetGeometry( b->xm_visual->display, b->frontbuffer,
+                 &root, &xpos, &ypos, &width, &height, &bw, &depth);
+#endif
+   if (b->width != width || b->height != height) {
+      b->width = MIN2((int)width, b->FXctx->width);
+      b->height = MIN2((int)height, b->FXctx->height);
+      if (b->width & 1)
+         b->width--;  /* prevent odd width */
+      xmesa_alloc_back_buffer( b );
+   }
+
+   grLfbWriteColorFormat(GR_COLORFORMAT_ARGB);
+   if (b->xm_visual->undithered_pf==PF_5R6G5B) {
+      /* Special case: 16bpp RGB */
+      grLfbReadRegion( GR_BUFFER_FRONTBUFFER,       /* src buffer */
+                       0, b->FXctx->height - b->height,  /*pos*/
+                       b->width, b->height,         /* size */
+                       b->width * sizeof(GLushort), /* stride */
+                       b->backimage->data);         /* dest buffer */
+   }
+   else if (b->xm_visual->dithered_pf==PF_DITHER
+	    && GET_VISUAL_DEPTH(b->xm_visual)==8) {
+      /* Special case: 8bpp RGB */
+      for (y=0;y<b->height;y++) {
+         GLubyte *ptr = (GLubyte*) b->backimage->data
+                        + b->backimage->bytes_per_line * y;
+         XDITHER_SETUP(y);
+
+         /* read row from 3Dfx frame buffer */
+         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
+                          0, b->FXctx->height-(b->height-y),
+                          b->width, 1,
+                          0,
+                          pixbuf );
+
+         /* write to XImage back buffer */
+         for (x=0;x<b->width;x++) {
+            GLubyte r = (pixbuf[x] & 0xf800) >> 8;
+            GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
+            GLubyte b = (pixbuf[x] & 0x001f) << 3;
+            *ptr++ = XDITHER( x, r, g, b);
+         }
+      }
+   }
+   else {
+      /* General case: slow! */
+      for (y=0;y<b->height;y++) {
+         /* read row from 3Dfx frame buffer */
+         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
+                          0, b->FXctx->height-(b->height-y),
+                          b->width, 1,
+                          0,
+                          pixbuf );
+
+         /* write to XImage back buffer */
+         for (x=0;x<b->width;x++) {
+            XMesaPutPixel(b->backimage,x,y,
+			  xmesa_color_to_pixel(xmesa,
+					       (pixbuf[x] & 0xf800) >> 8,
+					       (pixbuf[x] & 0x07e0) >> 3,
+					       (pixbuf[x] & 0x001f) << 3,
+					       0xff,
+                                               b->xm_visual->undithered_pf));
+         }
+      }
+   }
+   grLfbWriteColorFormat(GR_COLORFORMAT_ABGR);
+}
+#endif
+
+
+/*
+ * Copy the back buffer to the front buffer.  If there's no back buffer
+ * this is a no-op.
+ */
+void XMesaSwapBuffers( XMesaBuffer b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   /* If we're swapping the buffer associated with the current context
+    * we have to flush any pending rendering commands first.
+    */
+   if (ctx && ctx->DrawBuffer == &(b->mesa_buffer))
+      _mesa_swapbuffers(ctx);
+
+   if (b->db_state) {
+#ifdef FX
+      if (b->FXctx) {
+         fxMesaSwapBuffers();
+
+         if (b->FXwindowHack)
+            FXgetImage(b);
+         else
+            return;
+      }
+#endif
+     if (b->backimage) {
+	 /* Copy Ximage from host's memory to server's window */
+#if defined(USE_XSHM) && !defined(XFree86Server)
+	 if (b->shm) {
+            /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
+	    XShmPutImage( b->xm_visual->display, b->frontbuffer,
+			  b->swapgc,
+			  b->backimage, 0, 0,
+			  0, 0, b->width, b->height, False );
+            /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
+	 }
+	 else
+#endif
+         {
+            /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
+            XMesaPutImage( b->xm_visual->display, b->frontbuffer,
+			   b->swapgc,
+			   b->backimage, 0, 0,
+			   0, 0, b->width, b->height );
+            /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
+         }
+      }
+      else {
+	 /* Copy pixmap to window on server */
+         /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
+	 XMesaCopyArea( b->xm_visual->display,
+			b->backpixmap,   /* source drawable */
+			b->frontbuffer,  /* dest. drawable */
+			b->swapgc,
+			0, 0, b->width, b->height,  /* source region */
+			0, 0                 /* dest region */
+		      );
+         /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
+      }
+   }
+#if !defined(XFree86Server)
+   XSync( b->xm_visual->display, False );
+#endif
+}
+
+
+
+/*
+ * Copy sub-region of back buffer to front buffer
+ */
+void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   /* If we're swapping the buffer associated with the current context
+    * we have to flush any pending rendering commands first.
+    */
+   if (ctx && ctx->DrawBuffer == &(b->mesa_buffer))
+      _mesa_swapbuffers(ctx);
+
+   if (b->db_state) {
+      int yTop = b->height - y - height;
+#ifdef FX
+      if (b->FXctx) {
+         fxMesaSwapBuffers();
+         if (b->FXwindowHack)
+            FXgetImage(b);
+         else
+            return;
+      }
+#endif
+      if (b->backimage) {
+         /* Copy Ximage from host's memory to server's window */
+#if defined(USE_XSHM) && !defined(XFree86Server)
+         if (b->shm) {
+            /* XXX assuming width and height aren't too large! */
+            XShmPutImage( b->xm_visual->display, b->frontbuffer,
+                          b->swapgc,
+                          b->backimage, x, yTop,
+                          x, yTop, width, height, False );
+            /* wait for finished event??? */
+         }
+         else
+#endif
+         {
+            /* XXX assuming width and height aren't too large! */
+            XMesaPutImage( b->xm_visual->display, b->frontbuffer,
+			   b->swapgc,
+			   b->backimage, x, yTop,
+			   x, yTop, width, height );
+         }
+      }
+      else {
+         /* Copy pixmap to window on server */
+         XMesaCopyArea( b->xm_visual->display,
+			b->backpixmap,           /* source drawable */
+			b->frontbuffer,          /* dest. drawable */
+			b->swapgc,
+			x, yTop, width, height,  /* source region */
+			x, yTop                  /* dest region */
+                      );
+      }
+   }
+}
+
+
+/*
+ * Return a pointer to the XMesa backbuffer Pixmap or XImage.  This function
+ * is a way to get "under the hood" of X/Mesa so one can manipulate the
+ * back buffer directly.
+ * Output:  pixmap - pointer to back buffer's Pixmap, or 0
+ *          ximage - pointer to back buffer's XImage, or NULL
+ * Return:  GL_TRUE = context is double buffered
+ *          GL_FALSE = context is single buffered
+ */
+GLboolean XMesaGetBackBuffer( XMesaBuffer b,
+                              XMesaPixmap *pixmap,
+                              XMesaImage **ximage )
+{
+   if (b->db_state) {
+      if (pixmap)  *pixmap = b->backpixmap;
+      if (ximage)  *ximage = b->backimage;
+      return GL_TRUE;
+   }
+   else {
+      *pixmap = 0;
+      *ximage = NULL;
+      return GL_FALSE;
+   }
+}
+
+
+/*
+ * Return the depth buffer associated with an XMesaBuffer.
+ * Input:  b - the XMesa buffer handle
+ * Output:  width, height - size of buffer in pixels
+ *          bytesPerValue - bytes per depth value (2 or 4)
+ *          buffer - pointer to depth buffer values
+ * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
+ */
+GLboolean XMesaGetDepthBuffer( XMesaBuffer b, GLint *width, GLint *height,
+                               GLint *bytesPerValue, void **buffer )
+{
+   if (!b->mesa_buffer.DepthBuffer) {
+      *width = 0;
+      *height = 0;
+      *bytesPerValue = 0;
+      *buffer = 0;
+      return GL_FALSE;
+   }
+   else {
+      *width = b->mesa_buffer.Width;
+      *height = b->mesa_buffer.Height;
+      *bytesPerValue = sizeof(GLdepth);
+      *buffer = b->mesa_buffer.DepthBuffer;
+      return GL_TRUE;
+   }
+}
+
+
+void XMesaFlush( XMesaContext c )
+{
+   if (c && c->xm_visual) {
+#ifdef XFree86Server
+      /* NOT_NEEDED */
+#else
+      XSync( c->xm_visual->display, False );
+#endif
+   }
+}
+
+
+
+const char *XMesaGetString( XMesaContext c, int name )
+{
+   (void) c;
+   if (name==XMESA_VERSION) {
+      return "4.0.3";
+   }
+   else if (name==XMESA_EXTENSIONS) {
+      return "";
+   }
+   else {
+      return NULL;
+   }
+}
+
+
+
+XMesaBuffer XMesaFindBuffer( XMesaDisplay *dpy, XMesaDrawable d )
+{
+   XMesaBuffer b;
+   for (b=XMesaBufferList; b; b=b->Next) {
+      if (b->frontbuffer==d && b->display==dpy) {
+         return b;
+      }
+   }
+   return NULL;
+}
+
+
+
+/*
+ * Look for XMesaBuffers whose X window has been destroyed.
+ * Deallocate any such XMesaBuffers.
+ */
+void XMesaGarbageCollect( void )
+{
+   XMesaBuffer b, next;
+   for (b=XMesaBufferList; b; b=next) {
+      next = b->Next;
+      if (b->display && b->frontbuffer && !b->pixmap_flag) {
+#ifdef XFree86Server
+	 /* NOT_NEEDED */
+#else
+         XSync(b->display, False);
+         if (!window_exists( b->display, b->frontbuffer )) {
+            /* found a dead window, free the ancillary info */
+            XMesaDestroyBuffer( b );
+         }
+#endif
+      }
+   }
+}
+
+
+void XMesaReset( void )
+{
+    while (XMesaBufferList)
+	XMesaDestroyBuffer(XMesaBufferList);
+
+    XMesaBufferList = NULL;
+}
+
+
+unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y,
+                                GLfloat red, GLfloat green,
+                                GLfloat blue, GLfloat alpha )
+{
+   GLint r = (GLint) (red   * 255.0F);
+   GLint g = (GLint) (green * 255.0F);
+   GLint b = (GLint) (blue  * 255.0F);
+   GLint a = (GLint) (alpha * 255.0F);
+
+   switch (xmesa->pixelformat) {
+      case PF_INDEX:
+         return 0;
+      case PF_TRUECOLOR:
+         {
+            unsigned long p;
+            PACK_TRUECOLOR( p, r, g, b );
+            return p;
+         }
+      case PF_8A8B8G8R:
+         return PACK_8A8B8G8R( r, g, b, a );
+      case PF_8R8G8B:
+         return PACK_8R8G8B( r, g, b );
+      case PF_5R6G5B:
+         return PACK_5R6G5B( r, g, b );
+      case PF_DITHER:
+         {
+            DITHER_SETUP;
+            return DITHER( x, y, r, g, b );
+         }
+      case PF_1BIT:
+         /* 382 = (3*255)/2 */
+         return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
+      case PF_HPCR:
+         return DITHER_HPCR(x, y, r, g, b);
+      case PF_LOOKUP:
+         {
+            LOOKUP_SETUP;
+            return LOOKUP( r, g, b );
+         }
+      case PF_GRAYSCALE:
+         return GRAY_RGB( r, g, b );
+      case PF_DITHER_5R6G5B:
+         /* fall through */
+      case PF_TRUEDITHER:
+         {
+            unsigned long p;
+            PACK_TRUEDITHER(p, x, y, r, g, b);
+            return p;
+         }
+      default:
+         _mesa_problem(NULL, "Bad pixel format in XMesaDitherColor");
+   }
+   return 0;
+}
+
+
+/*
+ * This is typically called when the window size changes and we need
+ * to reallocate the buffer's back/depth/stencil/accum buffers.
+ */
+void XMesaResizeBuffers( XMesaBuffer b )
+{
+   xmesa_resize_buffers( &(b->mesa_buffer) );
+
+}
+
Index: xc/extras/Mesa/src/X/xm_dd.c
diff -u /dev/null xc/extras/Mesa/src/X/xm_dd.c:1.7
--- /dev/null	Thu Feb 27 12:15:52 2003
+++ xc/extras/Mesa/src/X/xm_dd.c	Thu Jan 16 14:13:08 2003
@@ -0,0 +1,1053 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/X/xm_dd.c,v 1.7 2003/01/16 19:13:08 alanh Exp $ */
+
+#include "glxheader.h"
+#include "context.h"
+#include "depth.h"
+#include "drawpix.h"
+#include "extensions.h"
+#include "macros.h"
+#include "mem.h"
+#include "mtypes.h"
+#include "state.h"
+#include "texstore.h"
+#include "texformat.h"
+#include "xmesaP.h"
+#include "array_cache/acache.h"
+#include "swrast/s_context.h"
+#include "swrast/swrast.h"
+#include "swrast/s_alphabuf.h"
+#include "swrast_setup/swrast_setup.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
+
+
+/*
+ * Return the size (width, height) of the X window for the given GLframebuffer.
+ * Output:  width - width of buffer in pixels.
+ *          height - height of buffer in pixels.
+ */
+static void
+get_buffer_size( GLframebuffer *buffer, GLuint *width, GLuint *height )
+{
+   /* We can do this cast because the first field in the XMesaBuffer
+    * struct is a GLframebuffer struct.  If this weren't true, we'd
+    * need a pointer from the GLframebuffer to the XMesaBuffer.
+    */
+   const XMesaBuffer xmBuffer = (XMesaBuffer) buffer;
+   unsigned int winwidth, winheight;
+#ifdef XFree86Server
+   /* XFree86 GLX renderer */
+   if (xmBuffer->frontbuffer->width > MAX_WIDTH ||
+       xmBuffer->frontbuffer->height > MAX_HEIGHT) {
+     winwidth = buffer->Width;
+     winheight = buffer->Height;
+   } else {
+     winwidth = xmBuffer->frontbuffer->width;
+     winheight = xmBuffer->frontbuffer->height;
+   }
+#else
+   Window root;
+   int winx, winy;
+   unsigned int bw, d;
+
+   _glthread_LOCK_MUTEX(_xmesa_lock);
+   XSync(xmBuffer->xm_visual->display, 0); /* added for Chromium */
+   XGetGeometry( xmBuffer->xm_visual->display, xmBuffer->frontbuffer, &root,
+		 &winx, &winy, &winwidth, &winheight, &bw, &d );
+   _glthread_UNLOCK_MUTEX(_xmesa_lock);
+#endif
+
+   (void)kernel8;		/* Muffle compiler */
+
+   *width = winwidth;
+   *height = winheight;
+}
+
+
+static void
+finish( GLcontext *ctx )
+{
+#ifdef XFree86Server
+      /* NOT_NEEDED */
+#else
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (xmesa) {
+      _glthread_LOCK_MUTEX(_xmesa_lock);
+      XSync( xmesa->display, False );
+      _glthread_UNLOCK_MUTEX(_xmesa_lock);
+   }
+#endif
+}
+
+
+static void
+flush( GLcontext *ctx )
+{
+#ifdef XFree86Server
+      /* NOT_NEEDED */
+#else
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (xmesa) {
+      _glthread_LOCK_MUTEX(_xmesa_lock);
+      XFlush( xmesa->display );
+      _glthread_UNLOCK_MUTEX(_xmesa_lock);
+   }
+#endif
+}
+
+
+static void
+set_draw_buffer( GLcontext *ctx, GLenum mode )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (mode == GL_FRONT_LEFT) {
+      /* write to front buffer */
+      xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
+      xmesa_update_span_funcs(ctx);
+   }
+   else if (mode==GL_BACK_LEFT && xmesa->xm_buffer->db_state) {
+      /* write to back buffer */
+      if (xmesa->xm_buffer->backpixmap) {
+         xmesa->xm_buffer->buffer =
+	     (XMesaDrawable)xmesa->xm_buffer->backpixmap;
+      }
+      else if (xmesa->xm_buffer->backimage) {
+         xmesa->xm_buffer->buffer = None;
+      }
+      else {
+         /* just in case there wasn't enough memory for back buffer */
+         xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
+      }
+      xmesa_update_span_funcs(ctx);
+   }
+   else {
+      /* the swrast->_RasterMask MULTI_DRAW_BIT will be set and
+       * we'll fall back to swrast to draw points/lines/triangles.
+       */
+   }
+}
+
+
+void
+xmesa_set_read_buffer( GLcontext *ctx, GLframebuffer *buffer, GLenum mode )
+{
+   XMesaBuffer target;
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+   if (buffer == ctx->DrawBuffer) {
+      target = xmesa->xm_buffer;
+      xmesa->use_read_buffer = GL_FALSE;
+   }
+   else {
+      ASSERT(buffer == ctx->ReadBuffer);
+      target = xmesa->xm_read_buffer;
+      xmesa->use_read_buffer = GL_TRUE;
+   }
+
+   if (mode == GL_FRONT_LEFT) {
+      target->buffer = target->frontbuffer;
+      xmesa_update_span_funcs(ctx);
+   }
+   else if (mode==GL_BACK_LEFT && xmesa->xm_read_buffer->db_state) {
+      if (target->backpixmap) {
+         target->buffer = (XMesaDrawable)xmesa->xm_buffer->backpixmap;
+      }
+      else if (target->backimage) {
+         target->buffer = None;
+      }
+      else {
+         /* just in case there wasn't enough memory for back buffer */
+         target->buffer = target->frontbuffer;
+      }
+      xmesa_update_span_funcs(ctx);
+   }
+   else {
+      _mesa_problem(ctx, "invalid buffer in set_read_buffer() in xmesa2.c");
+   }
+}
+
+
+
+static void
+clear_index( GLcontext *ctx, GLuint index )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   xmesa->clearpixel = (unsigned long) index;
+   XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
+                       (unsigned long) index );
+}
+
+
+static void
+clear_color( GLcontext *ctx, const GLchan color[4] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   xmesa->clearcolor[0] = color[0];
+   xmesa->clearcolor[1] = color[1];
+   xmesa->clearcolor[2] = color[2];
+   xmesa->clearcolor[3] = color[3];
+   xmesa->clearpixel = xmesa_color_to_pixel( xmesa, color[0], color[1],
+                                             color[2], color[3],
+                                             xmesa->xm_visual->undithered_pf );
+   _glthread_LOCK_MUTEX(_xmesa_lock);
+   XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
+                       xmesa->clearpixel );
+   _glthread_UNLOCK_MUTEX(_xmesa_lock);
+}
+
+
+
+/* Set index mask ala glIndexMask */
+static void
+index_mask( GLcontext *ctx, GLuint mask )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (xmesa->xm_buffer->buffer != XIMAGE) {
+      unsigned long m;
+      if (mask==0xffffffff) {
+	 m = ((unsigned long)~0L);
+      }
+      else {
+         m = (unsigned long) mask;
+      }
+      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
+      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc, m );
+   }
+}
+
+
+/* Implements glColorMask() */
+static void
+color_mask(GLcontext *ctx,
+           GLboolean rmask, GLboolean gmask, GLboolean bmask, GLboolean amask)
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   int xclass = GET_VISUAL_CLASS(xmesa->xm_visual);
+   (void) amask;
+
+   if (xclass == TrueColor || xclass == DirectColor) {
+      unsigned long m;
+      if (rmask && gmask && bmask) {
+         m = ((unsigned long)~0L);
+      }
+      else {
+         m = 0;
+         if (rmask)   m |= GET_REDMASK(xmesa->xm_visual);
+         if (gmask)   m |= GET_GREENMASK(xmesa->xm_visual);
+         if (bmask)   m |= GET_BLUEMASK(xmesa->xm_visual);
+      }
+      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
+   }
+}
+
+
+
+/**********************************************************************/
+/*** glClear implementations                                        ***/
+/**********************************************************************/
+
+
+static void
+clear_front_pixmap( GLcontext *ctx, GLboolean all,
+                    GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (all) {
+      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer,
+                          xmesa->xm_buffer->cleargc,
+                          0, 0,
+                          xmesa->xm_buffer->width+1,
+                          xmesa->xm_buffer->height+1 );
+   }
+   else {
+      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer,
+                          xmesa->xm_buffer->cleargc,
+                          x, xmesa->xm_buffer->height - y - height,
+                          width, height );
+   }
+}
+
+
+static void
+clear_back_pixmap( GLcontext *ctx, GLboolean all,
+                   GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (all) {
+      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap,
+                          xmesa->xm_buffer->cleargc,
+                          0, 0,
+                          xmesa->xm_buffer->width+1,
+                          xmesa->xm_buffer->height+1 );
+   }
+   else {
+      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap,
+                          xmesa->xm_buffer->cleargc,
+                          x, xmesa->xm_buffer->height - y - height,
+                          width, height );
+   }
+}
+
+
+static void
+clear_8bit_ximage( GLcontext *ctx, GLboolean all,
+                   GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (all) {
+      size_t n = xmesa->xm_buffer->backimage->bytes_per_line
+         * xmesa->xm_buffer->backimage->height;
+      MEMSET( xmesa->xm_buffer->backimage->data, xmesa->clearpixel, n );
+   }
+   else {
+      GLint i;
+      for (i=0;i<height;i++) {
+         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y+i );
+         MEMSET( ptr, xmesa->clearpixel, width );
+      }
+   }
+}
+
+
+static void
+clear_HPCR_ximage( GLcontext *ctx, GLboolean all,
+                   GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (all) {
+      GLint i, c16 = (xmesa->xm_buffer->backimage->bytes_per_line>>4)<<4;
+      GLubyte *ptr  = (GLubyte *)xmesa->xm_buffer->backimage->data;
+      for (i=0; i<xmesa->xm_buffer->backimage->height; i++) {
+         GLint j;
+         GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
+         if (i&1) {
+            sptr += 16;
+         }
+         for (j=0; j<c16; j+=16) {
+            ptr[0] = sptr[0];
+            ptr[1] = sptr[1];
+            ptr[2] = sptr[2];
+            ptr[3] = sptr[3];
+            ptr[4] = sptr[4];
+            ptr[5] = sptr[5];
+            ptr[6] = sptr[6];
+            ptr[7] = sptr[7];
+            ptr[8] = sptr[8];
+            ptr[9] = sptr[9];
+            ptr[10] = sptr[10];
+            ptr[11] = sptr[11];
+            ptr[12] = sptr[12];
+            ptr[13] = sptr[13];
+            ptr[14] = sptr[14];
+            ptr[15] = sptr[15];
+            ptr += 16;
+         }
+         for (; j<xmesa->xm_buffer->backimage->bytes_per_line; j++) {
+            *ptr = sptr[j&15];
+            ptr++;
+         }
+      }
+   }
+   else {
+      GLint i;
+      for (i=y; i<y+height; i++) {
+         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, i );
+         int j;
+         GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
+         if (i&1) {
+            sptr += 16;
+         }
+         for (j=x; j<x+width; j++) {
+            *ptr = sptr[j&15];
+            ptr++;
+         }
+      }
+   }
+}
+
+
+static void
+clear_16bit_ximage( GLcontext *ctx, GLboolean all,
+                    GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint pixel = (GLuint) xmesa->clearpixel;
+   if (xmesa->swapbytes) {
+      pixel = ((pixel >> 8) & 0x00ff) | ((pixel << 8) & 0xff00);
+   }
+   if (all) {
+      register GLuint n;
+      register GLuint *ptr4 = (GLuint *) xmesa->xm_buffer->backimage->data;
+      if ((pixel & 0xff) == ((pixel >> 8) & 0xff)) {
+         /* low and high bytes are equal so use memset() */
+         n = xmesa->xm_buffer->backimage->bytes_per_line
+            * xmesa->xm_buffer->height;
+         MEMSET( ptr4, pixel & 0xff, n );
+      }
+      else {
+         pixel = pixel | (pixel<<16);
+         n = xmesa->xm_buffer->backimage->bytes_per_line
+            * xmesa->xm_buffer->height / 4;
+         do {
+            *ptr4++ = pixel;
+               n--;
+         } while (n!=0);
+
+         if ((xmesa->xm_buffer->backimage->bytes_per_line *
+              xmesa->xm_buffer->height) & 0x2)
+            *(GLushort *)ptr4 = pixel & 0xffff;
+      }
+   }
+   else {
+      register int i, j;
+      for (j=0;j<height;j++) {
+         register GLushort *ptr2 = PIXELADDR2( xmesa->xm_buffer, x, y+j );
+         for (i=0;i<width;i++) {
+            *ptr2++ = pixel;
+         }
+      }
+   }
+}
+
+
+/* Optimized code provided by Nozomi Ytow <noz@xfree86.org> */
+static void
+clear_24bit_ximage( GLcontext *ctx, GLboolean all,
+                    GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = xmesa->clearcolor[0];
+   const GLubyte g = xmesa->clearcolor[1];
+   const GLubyte b = xmesa->clearcolor[2];
+   register GLuint clearPixel;
+   if (xmesa->swapbytes) {
+      clearPixel = (b << 16) | (g << 8) | r;
+   }
+   else {
+      clearPixel = (r << 16) | (g << 8) | b;
+   }
+
+   if (all) {
+      if (r==g && g==b) {
+         /* same value for all three components (gray) */
+         const GLint w3 = xmesa->xm_buffer->width * 3;
+         const GLint h = xmesa->xm_buffer->height;
+         GLint i;
+         for (i = 0; i < h; i++) {
+            bgr_t *ptr3 = PIXELADDR3(xmesa->xm_buffer, 0, i);
+            MEMSET(ptr3, r, w3);
+         }
+      }
+      else {
+         /* the usual case */
+         const GLint w = xmesa->xm_buffer->width;
+         const GLint h = xmesa->xm_buffer->height;
+         GLint i, j;
+         for (i = 0; i < h; i++) {
+            bgr_t *ptr3 = PIXELADDR3(xmesa->xm_buffer, 0, i);
+            for (j = 0; j < w; j++) {
+               ptr3->r = r;
+               ptr3->g = g;
+               ptr3->b = b;
+               ptr3++;
+            }
+         }
+#if 0 /* this code doesn't work for all window widths */
+         register GLuint *ptr4 = (GLuint *) ptr3;
+         register GLuint px;
+         GLuint pixel4[3];
+         register GLuint *p = pixel4;
+         pixel4[0] = clearPixel | (clearPixel << 24);
+         pixel4[1] = (clearPixel << 16) | (clearPixel >> 8);
+         pixel4[2] = (clearPixel << 8) | (clearPixel >>  16);
+         switch (3 & (int)(ptr3 - (bgr_t*) ptr4)){
+            case 0:
+               break;
+            case 1:
+               px = *ptr4 & 0x00ffffff;
+               px |= pixel4[0] & 0xff000000;
+               *ptr4++ = px;
+               px = *ptr4 & 0xffff0000;
+               px |= pixel4[2] & 0x0000ffff;
+               *ptr4 = px;
+               if (0 == --n)
+                  break;
+            case 2:
+               px = *ptr4 & 0x0000fffff;
+               px |= pixel4[1] & 0xffff0000;
+               *ptr4++ = px;
+               px = *ptr4 & 0xffffff00;
+               px |= pixel4[2] & 0x000000ff;
+               *ptr4 = px;
+               if (0 == --n)
+                  break;
+            case 3:
+               px = *ptr4 & 0x000000ff;
+               px |= pixel4[2] & 0xffffff00;
+               *ptr4++ = px;
+               --n;
+               break;
+         }
+         while (n > 3) {
+            p = pixel4;
+            *ptr4++ = *p++;
+            *ptr4++ = *p++;
+            *ptr4++ = *p++;
+            n -= 4;
+         }
+         switch (n) {
+            case 3:
+               p = pixel4;
+               *ptr4++ = *p++;
+               *ptr4++ = *p++;
+               px = *ptr4 & 0xffffff00;
+               px |= clearPixel & 0xff;
+               *ptr4 = px;
+               break;
+            case 2:
+               p = pixel4;
+               *ptr4++ = *p++;
+               px = *ptr4 & 0xffff0000;
+               px |= *p & 0xffff;
+               *ptr4 = px;
+               break;
+            case 1:
+               px = *ptr4 & 0xff000000;
+               px |= *p & 0xffffff;
+               *ptr4 = px;
+               break;
+            case 0:
+               break;
+         }
+#endif
+      }
+   }
+   else {
+      /* only clear subrect of color buffer */
+      if (r==g && g==b) {
+         /* same value for all three components (gray) */
+         GLint j;
+         for (j=0;j<height;j++) {
+            bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
+            MEMSET(ptr3, r, 3 * width);
+         }
+      }
+      else {
+         /* non-gray clear color */
+         GLint i, j;
+         for (j = 0; j < height; j++) {
+            bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
+            for (i = 0; i < width; i++) {
+               ptr3->r = r;
+               ptr3->g = g;
+               ptr3->b = b;
+               ptr3++;
+            }
+         }
+#if 0 /* this code might not always (seems ptr3 always == ptr4) */
+         GLint j;
+         GLuint pixel4[3];
+         pixel4[0] = clearPixel | (clearPixel << 24);
+         pixel4[1] = (clearPixel << 16) | (clearPixel >> 8);
+         pixel4[2] = (clearPixel << 8) | (clearPixel >>  16);
+         for (j=0;j<height;j++) {
+            bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
+            register GLuint *ptr4 = (GLuint *)ptr3;
+            register GLuint *p, px;
+            GLuint w = width;
+            switch (3 & (int)(ptr3 - (bgr_t*) ptr4)){
+               case 0:
+                  break;
+               case 1:
+                  px = *ptr4 & 0x00ffffff;
+                  px |= pixel4[0] & 0xff000000;
+                  *ptr4++ = px;
+                  px = *ptr4 & 0xffff0000;
+                  px |= pixel4[2] & 0x0000ffff;
+                  *ptr4 = px;
+                  if (0 == --w)
+                     break;
+               case 2:
+                  px = *ptr4 & 0x0000fffff;
+                  px |= pixel4[1] & 0xffff0000;
+                  *ptr4++ = px;
+                  px = *ptr4 & 0xffffff00;
+                  px |= pixel4[2] & 0x000000ff;
+                  *ptr4 = px;
+                  if (0 == --w)
+                     break;
+               case 3:
+                  px = *ptr4 & 0x000000ff;
+                  px |= pixel4[2] & 0xffffff00;
+                  *ptr4++ = px;
+                  --w;
+                  break;
+            }
+            while (w > 3){
+               p = pixel4;
+               *ptr4++ = *p++;
+               *ptr4++ = *p++;
+               *ptr4++ = *p++;
+               w -= 4;
+            }
+            switch (w) {
+               case 3:
+                  p = pixel4;
+                  *ptr4++ = *p++;
+                  *ptr4++ = *p++;
+                  px = *ptr4 & 0xffffff00;
+                  px |= *p & 0xff;
+                  *ptr4 = px;
+                  break;
+               case 2:
+                  p = pixel4;
+                  *ptr4++ = *p++;
+                  px = *ptr4 & 0xffff0000;
+                  px |= *p & 0xffff;
+                  *ptr4 = px;
+                  break;
+               case 1:
+                  px = *ptr4 & 0xff000000;
+                  px |= pixel4[0] & 0xffffff;
+                  *ptr4 = px;
+                  break;
+               case 0:
+                  break;
+            }
+         }
+#endif
+      }
+   }
+}
+
+
+static void
+clear_32bit_ximage( GLcontext *ctx, GLboolean all,
+                    GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint pixel = (GLuint) xmesa->clearpixel;
+   if (xmesa->swapbytes) {
+      pixel = ((pixel >> 24) & 0x000000ff)
+            | ((pixel >> 8)  & 0x0000ff00)
+            | ((pixel << 8)  & 0x00ff0000)
+            | ((pixel << 24) & 0xff000000);
+   }
+   if (all) {
+      register GLint n = xmesa->xm_buffer->width * xmesa->xm_buffer->height;
+      register GLuint *ptr4 = (GLuint *) xmesa->xm_buffer->backimage->data;
+      if (pixel==0) {
+         MEMSET( ptr4, pixel, 4*n );
+      }
+      else {
+         do {
+            *ptr4++ = pixel;
+            n--;
+         } while (n!=0);
+      }
+   }
+   else {
+      register int i, j;
+      for (j=0;j<height;j++) {
+         register GLuint *ptr4 = PIXELADDR4( xmesa->xm_buffer, x, y+j );
+         for (i=0;i<width;i++) {
+            *ptr4++ = pixel;
+         }
+      }
+   }
+}
+
+
+static void
+clear_nbit_ximage( GLcontext *ctx, GLboolean all,
+                   GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   if (all) {
+      register int i, j;
+      width = xmesa->xm_buffer->width;
+      height = xmesa->xm_buffer->height;
+      for (j=0;j<height;j++) {
+         for (i=0;i<width;i++) {
+            XMesaPutPixel( img, i, j, xmesa->clearpixel );
+         }
+      }
+   }
+   else {
+      /* TODO: optimize this */
+      register int i, j;
+      y = FLIP(xmesa->xm_buffer, y);
+      for (j=0;j<height;j++) {
+         for (i=0;i<width;i++) {
+            XMesaPutPixel( img, x+i, y-j, xmesa->clearpixel );
+         }
+      }
+   }
+}
+
+
+
+static void
+clear_buffers( GLcontext *ctx, GLbitfield mask,
+               GLboolean all, GLint x, GLint y, GLint width, GLint height )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLuint *colorMask = (GLuint *) &ctx->Color.ColorMask;
+
+   if ((mask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)) &&
+       xmesa->xm_buffer->mesa_buffer.UseSoftwareAlphaBuffers &&
+       ctx->Color.ColorMask[ACOMP]) {
+      _mesa_clear_alpha_buffers(ctx);
+   }
+
+   /* we can't handle color or index masking */
+   if (*colorMask == 0xffffffff && ctx->Color.IndexMask == 0xffffffff) {
+      if (mask & DD_FRONT_LEFT_BIT) {
+	 ASSERT(xmesa->xm_buffer->front_clear_func);
+	 (*xmesa->xm_buffer->front_clear_func)( ctx, all, x, y, width, height );
+	 mask &= ~DD_FRONT_LEFT_BIT;
+      }
+      if (mask & DD_BACK_LEFT_BIT) {
+	 ASSERT(xmesa->xm_buffer->back_clear_func);
+	 (*xmesa->xm_buffer->back_clear_func)( ctx, all, x, y, width, height );
+	 mask &= ~DD_BACK_LEFT_BIT;
+      }
+   }
+
+   if (mask)
+      _swrast_Clear( ctx, mask, all, x, y, width, height );
+}
+
+
+/*
+ * When we detect that the user has resized the window this function will
+ * get called.  Here we'll reallocate the back buffer, depth buffer,
+ * stencil buffer etc. to match the new window size.
+ */
+void
+xmesa_resize_buffers( GLframebuffer *buffer )
+{
+   int height = (int) buffer->Height;
+   /* We can do this cast because the first field in the XMesaBuffer
+    * struct is a GLframebuffer struct.  If this weren't true, we'd
+    * need a pointer from the GLframebuffer to the XMesaBuffer.
+    */
+   XMesaBuffer xmBuffer = (XMesaBuffer) buffer;
+
+   xmBuffer->width = buffer->Width;
+   xmBuffer->height = buffer->Height;
+   xmesa_alloc_back_buffer( xmBuffer );
+
+   /* Needed by FLIP macro */
+   xmBuffer->bottom = height - 1;
+
+   if (xmBuffer->backimage) {
+      /* Needed by PIXELADDR1 macro */
+      xmBuffer->ximage_width1 = xmBuffer->backimage->bytes_per_line;
+      xmBuffer->ximage_origin1 = (GLubyte *) xmBuffer->backimage->data
+         + xmBuffer->ximage_width1 * (height-1);
+
+      /* Needed by PIXELADDR2 macro */
+      xmBuffer->ximage_width2 = xmBuffer->backimage->bytes_per_line / 2;
+      xmBuffer->ximage_origin2 = (GLushort *) xmBuffer->backimage->data
+         + xmBuffer->ximage_width2 * (height-1);
+
+      /* Needed by PIXELADDR3 macro */
+      xmBuffer->ximage_width3 = xmBuffer->backimage->bytes_per_line;
+      xmBuffer->ximage_origin3 = (GLubyte *) xmBuffer->backimage->data
+         + xmBuffer->ximage_width3 * (height-1);
+
+      /* Needed by PIXELADDR4 macro */
+      xmBuffer->ximage_width4 = xmBuffer->backimage->width;
+      xmBuffer->ximage_origin4 = (GLuint *) xmBuffer->backimage->data
+         + xmBuffer->ximage_width4 * (height-1);
+   }
+
+   _swrast_alloc_buffers( buffer );
+}
+
+#if 0
+/*
+ * This function implements glDrawPixels() with an XPutImage call when
+ * drawing to the front buffer (X Window drawable).
+ * The image format must be GL_BGRA to match the PF_8R8G8B pixel format.
+ * XXX top/bottom edge clipping is broken!
+ */
+static GLboolean
+drawpixels_8R8G8B( GLcontext *ctx,
+                   GLint x, GLint y, GLsizei width, GLsizei height,
+                   GLenum format, GLenum type,
+                   const struct gl_pixelstore_attrib *unpack,
+                   const GLvoid *pixels )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   assert(dpy);
+   assert(buffer);
+   assert(gc);
+
+   /* XXX also check for pixel scale/bias/lookup/zooming! */
+   if (format == GL_BGRA && type == GL_UNSIGNED_BYTE) {
+      int dstX = x;
+      int dstY = y;
+      int w = width;
+      int h = height;
+      int srcX = unpack->SkipPixels;
+      int srcY = unpack->SkipRows;
+      if (_mesa_clip_pixelrect(ctx, &dstX, &dstY, &w, &h, &srcX, &srcY)) {
+         XMesaImage ximage;
+         MEMSET(&ximage, 0, sizeof(XMesaImage));
+         ximage.width = width;
+         ximage.height = height;
+         ximage.format = ZPixmap;
+         ximage.data = (char *) pixels + (height - 1) * width * 4;
+         ximage.byte_order = LSBFirst;
+         ximage.bitmap_unit = 32;
+         ximage.bitmap_bit_order = LSBFirst;
+         ximage.bitmap_pad = 32;
+         ximage.depth = 24;
+         ximage.bytes_per_line = -width * 4;
+         ximage.bits_per_pixel = 32;
+         ximage.red_mask   = 0xff0000;
+         ximage.green_mask = 0x00ff00;
+         ximage.blue_mask  = 0x0000ff;
+         dstY = FLIP(xmesa->xm_buffer,dstY) - height + 1;
+         XPutImage(dpy, buffer, gc, &ximage, srcX, srcY, dstX, dstY, w, h);
+         return GL_TRUE;
+      }
+   }
+   return GL_FALSE;
+}
+#endif
+
+
+
+static const GLubyte *
+get_string( GLcontext *ctx, GLenum name )
+{
+   (void) ctx;
+   switch (name) {
+      case GL_RENDERER:
+#ifdef XFree86Server
+         return (const GLubyte *) "Mesa GLX Indirect";
+#else
+         return (const GLubyte *) "Mesa X11";
+#endif
+      case GL_VENDOR:
+#ifdef XFree86Server
+         return (const GLubyte *) "Mesa project: www.mesa3d.org";
+#else
+         return NULL;
+#endif
+      default:
+         return NULL;
+   }
+}
+
+
+static void
+enable( GLcontext *ctx, GLenum pname, GLboolean state )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+   switch (pname) {
+      case GL_DITHER:
+         if (state)
+            xmesa->pixelformat = xmesa->xm_visual->dithered_pf;
+         else
+            xmesa->pixelformat = xmesa->xm_visual->undithered_pf;
+         break;
+      default:
+         ;  /* silence compiler warning */
+   }
+}
+
+
+void xmesa_update_state( GLcontext *ctx, GLuint new_state )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+   /* Propogate statechange information to swrast and swrast_setup
+    * modules.  The X11 driver has no internal GL-dependent state.
+    */
+   _swrast_InvalidateState( ctx, new_state );
+   _ac_InvalidateState( ctx, new_state );
+   _tnl_InvalidateState( ctx, new_state );
+   _swsetup_InvalidateState( ctx, new_state );
+
+
+   /* setup pointers to front and back buffer clear functions */
+   xmesa->xm_buffer->front_clear_func = clear_front_pixmap;
+   if (xmesa->xm_buffer->backpixmap != XIMAGE) {
+      xmesa->xm_buffer->back_clear_func = clear_back_pixmap;
+   }
+   else if (sizeof(GLushort)!=2 || sizeof(GLuint)!=4) {
+      xmesa->xm_buffer->back_clear_func = clear_nbit_ximage;
+   }
+   else switch (xmesa->xm_visual->BitsPerPixel) {
+   case 8:
+      if (xmesa->xm_visual->hpcr_clear_flag) {
+	 xmesa->xm_buffer->back_clear_func = clear_HPCR_ximage;
+      }
+      else {
+	 xmesa->xm_buffer->back_clear_func = clear_8bit_ximage;
+      }
+      break;
+   case 16:
+      xmesa->xm_buffer->back_clear_func = clear_16bit_ximage;
+      break;
+   case 24:
+      xmesa->xm_buffer->back_clear_func = clear_24bit_ximage;
+      break;
+   case 32:
+      xmesa->xm_buffer->back_clear_func = clear_32bit_ximage;
+      break;
+   default:
+      xmesa->xm_buffer->back_clear_func = clear_nbit_ximage;
+      break;
+   }
+
+   xmesa_update_span_funcs(ctx);
+}
+
+
+
+/* Setup pointers and other driver state that is constant for the life
+ * of a context.
+ */
+void xmesa_init_pointers( GLcontext *ctx )
+{
+   TNLcontext *tnl;
+
+   ctx->Driver.GetString = get_string;
+   ctx->Driver.GetBufferSize = get_buffer_size;
+   ctx->Driver.Flush = flush;
+   ctx->Driver.Finish = finish;
+    
+   /* Software rasterizer pixel paths:
+    */
+   ctx->Driver.Accum = _swrast_Accum;
+   ctx->Driver.Bitmap = _swrast_Bitmap;
+   ctx->Driver.Clear = clear_buffers;
+   ctx->Driver.ResizeBuffers = xmesa_resize_buffers;
+   ctx->Driver.CopyPixels = _swrast_CopyPixels;
+   ctx->Driver.DrawPixels = _swrast_DrawPixels;
+   ctx->Driver.ReadPixels = _swrast_ReadPixels;
+
+   /* Software texture functions:
+    */
+   ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
+   ctx->Driver.TexImage1D = _mesa_store_teximage1d;
+   ctx->Driver.TexImage2D = _mesa_store_teximage2d;
+   ctx->Driver.TexImage3D = _mesa_store_teximage3d;
+   ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
+   ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
+   ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
+   ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
+
+   ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
+   ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
+   ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
+   ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
+   ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
+
+   ctx->Driver.BaseCompressedTexFormat = _mesa_base_compressed_texformat;
+   ctx->Driver.CompressedTextureSize = _mesa_compressed_texture_size;
+   ctx->Driver.GetCompressedTexImage = _mesa_get_compressed_teximage;
+
+   /* Swrast hooks for imaging extensions:
+    */
+   ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
+   ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
+   ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
+   ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
+
+
+   /* Statechange callbacks:
+    */
+   ctx->Driver.SetDrawBuffer = set_draw_buffer;
+   ctx->Driver.ClearIndex = clear_index;
+   ctx->Driver.ClearColor = clear_color;
+   ctx->Driver.IndexMask = index_mask;
+   ctx->Driver.ColorMask = color_mask;
+   ctx->Driver.Enable = enable;
+
+
+   /* Initialize the TNL driver interface:
+    */
+   tnl = TNL_CONTEXT(ctx);
+   tnl->Driver.RunPipeline = _tnl_run_pipeline;
+   
+   /* Install swsetup for tnl->Driver.Render.*:
+    */
+   _swsetup_Wakeup(ctx);
+
+   (void) DitherValues;  /* silenced unused var warning */
+}
+
+
+
+
+
+#define XMESA_NEW_POINT  (_NEW_POINT | \
+                          _NEW_RENDERMODE | \
+                          _SWRAST_NEW_RASTERMASK)
+
+#define XMESA_NEW_LINE   (_NEW_LINE | \
+                          _NEW_TEXTURE | \
+                          _NEW_LIGHT | \
+                          _NEW_DEPTH | \
+                          _NEW_RENDERMODE | \
+                          _SWRAST_NEW_RASTERMASK)
+
+#define XMESA_NEW_TRIANGLE (_NEW_POLYGON | \
+                            _NEW_TEXTURE | \
+                            _NEW_LIGHT | \
+                            _NEW_DEPTH | \
+                            _NEW_RENDERMODE | \
+                            _SWRAST_NEW_RASTERMASK)
+
+
+/* Extend the software rasterizer with our line/point/triangle
+ * functions.
+ */
+void xmesa_register_swrast_functions( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT( ctx );
+
+   swrast->choose_point = xmesa_choose_point;
+   swrast->choose_line = xmesa_choose_line;
+   swrast->choose_triangle = xmesa_choose_triangle;
+
+   swrast->invalidate_point |= XMESA_NEW_POINT;
+   swrast->invalidate_line |= XMESA_NEW_LINE;
+   swrast->invalidate_triangle |= XMESA_NEW_TRIANGLE;
+}
Index: xc/extras/Mesa/src/X/xm_line.c
diff -u /dev/null xc/extras/Mesa/src/X/xm_line.c:1.2
--- /dev/null	Thu Feb 27 12:15:52 2003
+++ xc/extras/Mesa/src/X/xm_line.c	Mon Dec 16 11:18:31 2002
@@ -0,0 +1,633 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * This file contains "accelerated" point, line, and triangle functions.
+ * It should be fairly easy to write new special-purpose point, line or
+ * triangle functions and hook them into this module.
+ */
+
+
+#include "glxheader.h"
+#include "depth.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mtypes.h"
+#include "xmesaP.h"
+
+/* Internal swrast includes:
+ */
+#include "swrast/s_depth.h"
+#include "swrast/s_points.h"
+#include "swrast/s_lines.h"
+#include "swrast/s_context.h"
+
+
+/**********************************************************************/
+/***                    Point rendering                             ***/
+/**********************************************************************/
+
+
+/*
+ * Render an array of points into a pixmap, any pixel format.
+ */
+#if 000
+/* XXX don't use this, it doesn't dither correctly */
+static void draw_points_ANY_pixmap( GLcontext *ctx, const SWvertex *vert )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+
+   if (xmesa->xm_visual->mesa_visual.RGBAflag) {
+      register int x, y;
+      const GLubyte *color = vert->color;
+      unsigned long pixel = xmesa_color_to_pixel( xmesa,
+						  color[0], color[1],
+						  color[2], color[3],
+						  xmesa->pixelformat);
+      XMesaSetForeground( dpy, gc, pixel );
+      x =                         (GLint) vert->win[0];
+      y = FLIP( xmesa->xm_buffer, (GLint) vert->win[1] );
+      XMesaDrawPoint( dpy, buffer, gc, x, y);
+   }
+   else {
+      /* Color index mode */
+      register int x, y;
+      XMesaSetForeground( dpy, gc, vert->index );
+      x =                         (GLint) vert->win[0];
+      y = FLIP( xmesa->xm_buffer, (GLint) vert->win[1] );
+      XMesaDrawPoint( dpy, buffer, gc, x, y);
+   }
+}
+#endif
+
+
+/* Override the swrast point-selection function.  Try to use one of
+ * our internal point functions, otherwise fall back to the standard
+ * swrast functions.
+ */
+void xmesa_choose_point( GLcontext *ctx )
+{
+#if 0
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (ctx->RenderMode == GL_RENDER
+       && ctx->Point.Size == 1.0F && !ctx->Point.SmoothFlag
+       && swrast->_RasterMask == 0
+       && !ctx->Texture._ReallyEnabled
+       && xmesa->xm_buffer->buffer != XIMAGE) {
+      swrast->Point = draw_points_ANY_pixmap;
+   }
+   else {
+      _swrast_choose_point( ctx );
+   }
+#else
+   _swrast_choose_point( ctx );
+#endif
+}
+
+
+
+/**********************************************************************/
+/***                      Line rendering                            ***/
+/**********************************************************************/
+
+
+/*
+ * Draw a flat-shaded, PF_TRUECOLOR line into an XImage.
+ */
+static void flat_TRUECOLOR_line( GLcontext *ctx,
+                                 const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   unsigned long pixel;
+   PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
+
+#define INTERP_XY 1
+#define CLIP_HACK 1
+#define PLOT(X,Y) XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel );
+
+#include "swrast/s_linetemp.h"
+}
+
+
+
+/*
+ * Draw a flat-shaded, PF_8A8B8G8R line into an XImage.
+ */
+static void flat_8A8B8G8R_line( GLcontext *ctx,
+                                const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_8R8G8B line into an XImage.
+ */
+static void flat_8R8G8B_line( GLcontext *ctx,
+                              const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_8R8G8B24 line into an XImage.
+ */
+static void flat_8R8G8B24_line( GLcontext *ctx,
+                              const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) {			\
+      pixelPtr->r = color[RCOMP];	\
+      pixelPtr->g = color[GCOMP];	\
+      pixelPtr->b = color[BCOMP];	\
+}
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_5R6G5B line into an XImage.
+ */
+static void flat_5R6G5B_line( GLcontext *ctx,
+                              const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_DITHER_5R6G5B line into an XImage.
+ */
+static void flat_DITHER_5R6G5B_line( GLcontext *ctx,
+                                     const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) PACK_TRUEDITHER( *pixelPtr, X, Y, color[0], color[1], color[2] );
+
+#include "swrast/s_linetemp.h"
+}
+
+
+
+/*
+ * Draw a flat-shaded, PF_DITHER 8-bit line into an XImage.
+ */
+static void flat_DITHER8_line( GLcontext *ctx,
+                               const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLint r = color[0], g = color[1], b = color[2];
+   DITHER_SETUP;
+
+#define INTERP_XY 1
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = DITHER(X,Y,r,g,b);
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_LOOKUP 8-bit line into an XImage.
+ */
+static void flat_LOOKUP8_line( GLcontext *ctx,
+                               const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLubyte pixel;
+   LOOKUP_SETUP;
+   pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
+
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = pixel;
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, PF_HPCR line into an XImage.
+ */
+static void flat_HPCR_line( GLcontext *ctx,
+                            const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLint r = color[0], g = color[1], b = color[2];
+
+#define INTERP_XY 1
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y) *pixelPtr = (GLubyte) DITHER_HPCR(X,Y,r,g,b);
+
+#include "swrast/s_linetemp.h"
+}
+
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_TRUECOLOR line into an XImage.
+ */
+static void flat_TRUECOLOR_z_line( GLcontext *ctx,
+                                   const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   unsigned long pixel;
+   PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define CLIP_HACK 1
+#define PLOT(X,Y)							\
+	if (Z < *zPtr) {						\
+	   *zPtr = Z;							\
+           XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel );	\
+	}
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_8A8B8G8R line into an XImage.
+ */
+static void flat_8A8B8G8R_z_line( GLcontext *ctx,
+                                  const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)		\
+	if (Z < *zPtr) {	\
+	   *zPtr = Z;		\
+	   *pixelPtr = pixel;	\
+	}
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_8R8G8B line into an XImage.
+ */
+static void flat_8R8G8B_z_line( GLcontext *ctx,
+                                const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)		\
+	if (Z < *zPtr) {	\
+	   *zPtr = Z;		\
+	   *pixelPtr = pixel;	\
+	}
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_8R8G8B24 line into an XImage.
+ */
+static void flat_8R8G8B24_z_line( GLcontext *ctx,
+                                    const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)			\
+	if (Z < *zPtr) {		\
+	   *zPtr = Z;			\
+           pixelPtr->r = color[RCOMP];	\
+           pixelPtr->g = color[GCOMP];	\
+           pixelPtr->b = color[BCOMP];	\
+	}
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_5R6G5B line into an XImage.
+ */
+static void flat_5R6G5B_z_line( GLcontext *ctx,
+                                const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)		\
+	if (Z < *zPtr) {	\
+	   *zPtr = Z;		\
+	   *pixelPtr = pixel;	\
+	}
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_DITHER_5R6G5B line into an XImage.
+ */
+static void flat_DITHER_5R6G5B_z_line( GLcontext *ctx,
+                                       const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)		\
+	if (Z < *zPtr) {	\
+	   *zPtr = Z;		\
+	   PACK_TRUEDITHER(*pixelPtr, X, Y, color[0], color[1], color[2]); \
+	}
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_DITHER 8-bit line into an XImage.
+ */
+static void flat_DITHER8_z_line( GLcontext *ctx,
+                                 const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLint r = color[0], g = color[1], b = color[2];
+   DITHER_SETUP;
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)						\
+	if (Z < *zPtr) {					\
+	   *zPtr = Z;						\
+	   *pixelPtr = (GLubyte) DITHER( X, Y, r, g, b);	\
+	}
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_LOOKUP 8-bit line into an XImage.
+ */
+static void flat_LOOKUP8_z_line( GLcontext *ctx,
+                                 const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLubyte pixel;
+   LOOKUP_SETUP;
+   pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
+
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)		\
+	if (Z < *zPtr) {	\
+	   *zPtr = Z;		\
+	   *pixelPtr = pixel;	\
+	}
+
+#include "swrast/s_linetemp.h"
+}
+
+
+/*
+ * Draw a flat-shaded, Z-less, PF_HPCR line into an XImage.
+ */
+static void flat_HPCR_z_line( GLcontext *ctx,
+                              const SWvertex *vert0, const SWvertex *vert1 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = vert1->color;
+   GLint r = color[0], g = color[1], b = color[2];
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define CLIP_HACK 1
+#define PLOT(X,Y)						\
+	if (Z < *zPtr) {					\
+	   *zPtr = Z;						\
+	   *pixelPtr = (GLubyte) DITHER_HPCR( X, Y, r, g, b);	\
+	}
+
+#include "swrast/s_linetemp.h"
+}
+
+
+static swrast_line_func get_line_func( GLcontext *ctx )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
+
+   (void) DitherValues;  /* silence unused var warning */
+   (void) kernel1;  /* silence unused var warning */
+
+   if (ctx->RenderMode != GL_RENDER)      return (swrast_line_func) NULL;
+   if (ctx->Line.SmoothFlag)              return (swrast_line_func) NULL;
+   if (ctx->Texture._ReallyEnabled)       return (swrast_line_func) NULL;
+   if (ctx->Light.ShadeModel != GL_FLAT)  return (swrast_line_func) NULL;
+   if (ctx->Line.StippleFlag)             return (swrast_line_func) NULL;
+   if (swrast->_RasterMask & MULTI_DRAW_BIT) return (swrast_line_func) NULL;
+
+   if (xmesa->xm_buffer->buffer==XIMAGE
+       && swrast->_RasterMask==DEPTH_BIT
+       && ctx->Depth.Func==GL_LESS
+       && ctx->Depth.Mask==GL_TRUE
+       && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+       && ctx->Line.Width==1.0F) {
+      switch (xmesa->pixelformat) {
+         case PF_TRUECOLOR:
+            return flat_TRUECOLOR_z_line;
+         case PF_8A8B8G8R:
+            return flat_8A8B8G8R_z_line;
+         case PF_8R8G8B:
+            return flat_8R8G8B_z_line;
+         case PF_8R8G8B24:
+            return flat_8R8G8B24_z_line;
+         case PF_5R6G5B:
+            return flat_5R6G5B_z_line;
+         case PF_DITHER_5R6G5B:
+            return flat_DITHER_5R6G5B_z_line;
+         case PF_DITHER:
+            return (depth==8) ? flat_DITHER8_z_line : (swrast_line_func) NULL;
+         case PF_LOOKUP:
+            return (depth==8) ? flat_LOOKUP8_z_line : (swrast_line_func) NULL;
+         case PF_HPCR:
+            return flat_HPCR_z_line;
+         default:
+            return (swrast_line_func)NULL;
+      }
+   }
+   if (xmesa->xm_buffer->buffer==XIMAGE
+       && swrast->_RasterMask==0
+       && ctx->Line.Width==1.0F) {
+      switch (xmesa->pixelformat) {
+         case PF_TRUECOLOR:
+            return flat_TRUECOLOR_line;
+         case PF_8A8B8G8R:
+            return flat_8A8B8G8R_line;
+         case PF_8R8G8B:
+            return flat_8R8G8B_line;
+         case PF_8R8G8B24:
+            return flat_8R8G8B24_line;
+         case PF_5R6G5B:
+            return flat_5R6G5B_line;
+         case PF_DITHER_5R6G5B:
+            return flat_DITHER_5R6G5B_line;
+         case PF_DITHER:
+            return (depth==8) ? flat_DITHER8_line : (swrast_line_func) NULL;
+         case PF_LOOKUP:
+            return (depth==8) ? flat_LOOKUP8_line : (swrast_line_func) NULL;
+         case PF_HPCR:
+            return flat_HPCR_line;
+	 default:
+	    return (swrast_line_func)NULL;
+      }
+   }
+
+   return (swrast_line_func) NULL;
+}
+
+/* Override for the swrast line-selection function.  Try to use one
+ * of our internal line functions, otherwise fall back to the
+ * standard swrast functions.
+ */
+void xmesa_choose_line( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (!(swrast->Line = get_line_func( ctx )))
+      _swrast_choose_line( ctx );
+}
Index: xc/extras/Mesa/src/X/xm_span.c
diff -u /dev/null xc/extras/Mesa/src/X/xm_span.c:1.5
--- /dev/null	Thu Feb 27 12:15:52 2003
+++ xc/extras/Mesa/src/X/xm_span.c	Mon Dec 16 11:18:31 2002
@@ -0,0 +1,4495 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/X/xm_span.c,v 1.5 2002/12/16 16:18:31 dawes Exp $ */
+
+#include "glxheader.h"
+#include "context.h"
+#include "drawpix.h"
+#include "mem.h"
+#include "state.h"
+#include "depth.h"
+#include "macros.h"
+#include "mtypes.h"
+#include "xmesaP.h"
+#include "extensions.h"
+
+#include "swrast/swrast.h"
+
+
+/*
+ * The following functions are used to trap XGetImage() calls which
+ * generate BadMatch errors if the drawable isn't mapped.
+ */
+
+#ifndef XFree86Server
+static int caught_xgetimage_error = 0;
+static int (*old_xerror_handler)( XMesaDisplay *dpy, XErrorEvent *ev );
+static unsigned long xgetimage_serial;
+
+/*
+ * This is the error handler which will be called if XGetImage fails.
+ */
+static int xgetimage_error_handler( XMesaDisplay *dpy, XErrorEvent *ev )
+{
+   if (ev->serial==xgetimage_serial && ev->error_code==BadMatch) {
+      /* caught the expected error */
+      caught_xgetimage_error = 0;
+   }
+   else {
+      /* call the original X error handler, if any.  otherwise ignore */
+      if (old_xerror_handler) {
+         (*old_xerror_handler)( dpy, ev );
+      }
+   }
+   return 0;
+}
+
+
+/*
+ * Call this right before XGetImage to setup error trap.
+ */
+static void catch_xgetimage_errors( XMesaDisplay *dpy )
+{
+   xgetimage_serial = NextRequest( dpy );
+   old_xerror_handler = XSetErrorHandler( xgetimage_error_handler );
+   caught_xgetimage_error = 0;
+}
+
+
+/*
+ * Call this right after XGetImage to check if an error occured.
+ */
+static int check_xgetimage_errors( void )
+{
+   /* restore old handler */
+   (void) XSetErrorHandler( old_xerror_handler );
+   /* return 0=no error, 1=error caught */
+   return caught_xgetimage_error;
+}
+#endif
+
+
+/*
+ * Read a pixel from an X drawable.
+ */
+static unsigned long read_pixel( XMesaDisplay *dpy,
+                                 XMesaDrawable d, int x, int y )
+{
+   unsigned long p;
+#ifndef XFree86Server
+   XMesaImage *pixel = NULL;
+   int error;
+
+   catch_xgetimage_errors( dpy );
+   pixel = XGetImage( dpy, d, x, y, 1, 1, AllPlanes, ZPixmap );
+   error = check_xgetimage_errors();
+   if (pixel && !error) {
+      p = XMesaGetPixel( pixel, 0, 0 );
+   }
+   else {
+      p = 0;
+   }
+   if (pixel) {
+      XMesaDestroyImage( pixel );
+   }
+#else
+   (*dpy->GetImage)(d, x, y, 1, 1, ZPixmap, ~0L, (pointer)&p);
+#endif
+   return p;
+}
+
+
+
+/*
+ * The Mesa library needs to be able to draw pixels in a number of ways:
+ *   1. RGB vs Color Index
+ *   2. as horizontal spans (polygons, images) vs random locations (points,
+ *      lines)
+ *   3. different color per-pixel or same color for all pixels
+ *
+ * Furthermore, the X driver needs to support rendering to 3 possible
+ * "buffers", usually one, but sometimes two at a time:
+ *   1. The front buffer as an X window
+ *   2. The back buffer as a Pixmap
+ *   3. The back buffer as an XImage
+ *
+ * Finally, if the back buffer is an XImage, we can avoid using XPutPixel and
+ * optimize common cases such as 24-bit and 8-bit modes.
+ *
+ * By multiplication, there's at least 48 possible combinations of the above.
+ *
+ * Below are implementations of the most commonly used combinations.  They are
+ * accessed through function pointers which get initialized here and are used
+ * directly from the Mesa library.  The 8 function pointers directly correspond
+ * to the first 3 cases listed above.
+ *
+ *
+ * The function naming convention is:
+ *
+ *   write_[span|pixels]_[mono]_[format]_[pixmap|ximage]
+ *
+ * New functions optimized for specific cases can be added without too much
+ * trouble.  An example might be the 24-bit TrueColor mode 8A8R8G8B which is
+ * found on IBM RS/6000 X servers.
+ */
+
+
+
+
+/**********************************************************************/
+/*** Write COLOR SPAN functions                                     ***/
+/**********************************************************************/
+
+
+#define RGBA_SPAN_ARGS	const GLcontext *ctx,				\
+			GLuint n, GLint x, GLint y,			\
+			CONST GLubyte rgba[][4], const GLubyte mask[]
+
+#define RGB_SPAN_ARGS	const GLcontext *ctx,				\
+			GLuint n, GLint x, GLint y,			\
+			CONST GLubyte rgb[][3], const GLubyte mask[]
+
+
+/* NOTE: if mask==NULL, draw all pixels */
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to a pixmap.
+ */
+static void write_span_TRUECOLOR_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+
+   (void)DitherValues;		/* Muffle compiler */
+
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+            XMesaSetForeground( dpy, gc, p );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         unsigned long p;
+         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         XMesaPutPixel( rowimg, i, 0, p );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to a pixmap.
+ */
+static void write_span_rgb_TRUECOLOR_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+            XMesaSetForeground( dpy, gc, p );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         unsigned long p;
+         PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+         XMesaPutPixel( rowimg, i, 0, p );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to a pixmap.
+ */
+static void write_span_TRUEDITHER_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+            XMesaSetForeground( dpy, gc, p );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+         XMesaPutPixel( rowimg, i, 0, p );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_TRUEDITHER_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+            XMesaSetForeground( dpy, gc, p );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         XMesaPutPixel( rowimg, i, 0, p );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+
+/*
+ * Write a span of PF_8A8B8G8R pixels to a pixmap.
+ */
+static void write_span_8A8B8G8R_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+                         PACK_8A8B8G8R(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP]) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLuint *ptr4 = (GLuint *) rowimg->data;
+      for (i=0;i<n;i++) {
+         *ptr4++ = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_8A8B8G8R pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_8A8B8G8R_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+                   PACK_8B8G8R(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLuint *ptr4 = (GLuint *) rowimg->data;
+      for (i=0;i<n;i++) {
+         *ptr4++ = PACK_8B8G8R(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B pixels to a pixmap.
+ */
+static void write_span_8R8G8B_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLuint *ptr4 = (GLuint *) rowimg->data;
+      for (i=0;i<n;i++) {
+         *ptr4++ = PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24 pixels to a pixmap.
+ */
+static void write_span_8R8G8B24_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      register GLuint i;
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+               PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLuint *ptr4 = (GLuint *) rowimg->data;
+      register GLuint pixel;
+      static const GLuint shift[4] = {0, 8, 16, 24};
+      register GLuint i = 0;
+      int w = n;
+      while (w > 3) {
+         pixel  = rgba[i][BCOMP] /* << shift[0]*/;
+         pixel |= rgba[i][GCOMP]    << shift[1];
+         pixel |= rgba[i++][RCOMP]  << shift[2];
+         pixel |= rgba[i][BCOMP]    << shift[3];
+         *ptr4++ = pixel;
+
+         pixel  = rgba[i][GCOMP] /* << shift[0]*/;
+         pixel |= rgba[i++][RCOMP]  << shift[1];
+         pixel |= rgba[i][BCOMP]    << shift[2];
+         pixel |= rgba[i][GCOMP]    << shift[3];
+         *ptr4++ = pixel;
+
+         pixel  = rgba[i++][RCOMP]/* << shift[0]*/;
+         pixel |= rgba[i][BCOMP]     << shift[1];
+         pixel |= rgba[i][GCOMP]     << shift[2];
+         pixel |= rgba[i++][RCOMP]   << shift[3];
+         *ptr4++ = pixel;
+
+         w -= 4;
+      }
+      switch (w) {
+         case 3:
+            pixel = 0;
+            pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
+            pixel |= rgba[i][GCOMP]   << shift[1];
+            pixel |= rgba[i++][RCOMP] << shift[2];
+            pixel |= rgba[i][BCOMP]   << shift[3];
+            *ptr4++ = pixel;
+            pixel = 0;
+            pixel |= rgba[i][GCOMP] /*<< shift[0]*/;
+            pixel |= rgba[i++][RCOMP] << shift[1];
+            pixel |= rgba[i][BCOMP]   << shift[2];
+            pixel |= rgba[i][GCOMP]   << shift[3];
+            *ptr4++ = pixel;
+            pixel = 0xffffff00 & *ptr4;
+            pixel |= rgba[i][RCOMP] /*<< shift[0]*/;
+            *ptr4 = pixel;
+            break;
+         case 2:
+            pixel = 0;
+            pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
+            pixel |= rgba[i][GCOMP]   << shift[1];
+            pixel |= rgba[i++][RCOMP] << shift[2];
+            pixel |= rgba[i][BCOMP]   << shift[3];
+            *ptr4++ = pixel;
+            pixel = 0xffff0000 & *ptr4;
+            pixel |= rgba[i][GCOMP] /*<< shift[0]*/;
+            pixel |= rgba[i][RCOMP]   << shift[1];
+            *ptr4 = pixel;
+            break;
+         case 1:
+            pixel = 0xff000000 & *ptr4;
+            pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
+            pixel |= rgba[i][GCOMP] << shift[1];
+            pixel |= rgba[i][RCOMP] << shift[2];
+            *ptr4 = pixel;
+            break;
+         case 0:
+            break;
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_8R8G8B_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLuint *ptr4 = (GLuint *) rowimg->data;
+      for (i=0;i<n;i++) {
+         *ptr4++ = PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24 pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_8R8G8B24_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      register GLuint i;
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+                  PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLuint *ptr4 = (GLuint *) rowimg->data;
+      register GLuint pixel;
+      static const GLuint shift[4] = {0, 8, 16, 24};
+      unsigned w = n;
+      register GLuint i = 0;
+      while (w > 3) {
+         pixel = 0;
+         pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+         pixel |= rgb[i][GCOMP] << shift[1];
+         pixel |= rgb[i++][RCOMP] << shift[2];
+         pixel |= rgb[i][BCOMP] <<shift[3];
+         *ptr4++ = pixel;
+
+         pixel = 0;
+         pixel |= rgb[i][GCOMP]/* << shift[0]*/;
+         pixel |= rgb[i++][RCOMP] << shift[1];
+         pixel |= rgb[i][BCOMP] << shift[2];
+         pixel |= rgb[i][GCOMP] << shift[3];
+         *ptr4++ = pixel;
+
+         pixel = 0;
+         pixel |= rgb[i++][RCOMP]/* << shift[0]*/;
+         pixel |= rgb[i][BCOMP] << shift[1];
+         pixel |= rgb[i][GCOMP] << shift[2];
+         pixel |= rgb[i++][RCOMP] << shift[3];
+         *ptr4++ = pixel;
+         w -= 4;
+      }
+      switch (w) {
+         case 3:
+            pixel = 0;
+            pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+            pixel |= rgb[i][GCOMP] << shift[1];
+            pixel |= rgb[i++][RCOMP] << shift[2];
+            pixel |= rgb[i][BCOMP] << shift[3];
+            *ptr4++ = pixel;
+            pixel = 0;
+            pixel |= rgb[i][GCOMP]/* << shift[0]*/;
+            pixel |= rgb[i++][RCOMP] << shift[1];
+            pixel |= rgb[i][BCOMP] << shift[2];
+            pixel |= rgb[i][GCOMP] << shift[3];
+            *ptr4++ = pixel;
+            pixel = *ptr4;
+            pixel &= 0xffffff00;
+            pixel |= rgb[i++][RCOMP]/* << shift[0]*/;
+            *ptr4++ = pixel;
+            break;
+         case 2:
+            pixel = 0;
+            pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+            pixel |= rgb[i][GCOMP] << shift[1];
+            pixel |= rgb[i++][RCOMP] << shift[2];
+            pixel |= rgb[i][BCOMP]  << shift[3];
+            *ptr4++ = pixel;
+            pixel = *ptr4;
+            pixel &= 0xffff0000;
+            pixel |= rgb[i][GCOMP]/* << shift[0]*/;
+            pixel |= rgb[i++][RCOMP] << shift[1];
+            *ptr4++ = pixel;
+            break;
+         case 1:
+            pixel = *ptr4;
+            pixel &= 0xff000000;
+            pixel |= rgb[i][BCOMP]/* << shift[0]*/;
+            pixel |= rgb[i][GCOMP] << shift[1];
+            pixel |= rgb[i++][RCOMP] << shift[2];
+            *ptr4++ = pixel;
+            break;
+         case 0:
+            break;
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B pixels to a pixmap.
+ */
+static void write_span_5R6G5B_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLushort *ptr2 = (GLushort *) rowimg->data;
+      for (i=0;i<n;i++) {
+         ptr2[i] = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B pixels to a pixmap.
+ */
+static void write_span_DITHER_5R6G5B_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+            XMesaSetForeground( dpy, gc, p );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLushort *ptr2 = (GLushort *) rowimg->data;
+      for (i=0;i<n;i++) {
+         PACK_TRUEDITHER( ptr2[i], x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_5R6G5B_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLushort *ptr2 = (GLushort *) rowimg->data;
+      for (i=0;i<n;i++) {
+         ptr2[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_DITHER_5R6G5B_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+            XMesaSetForeground( dpy, gc, p );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLushort *ptr2 = (GLushort *) rowimg->data;
+      for (i=0;i<n;i++) {
+         PACK_TRUEDITHER( ptr2[i], x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+
+/*
+ * Write a span of PF_DITHER pixels to a pixmap.
+ */
+static void write_span_DITHER_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   XDITHER_SETUP(y);
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, XDITHER(x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_DITHER_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   XDITHER_SETUP(y);
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, XDITHER(x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to a pixmap.
+ */
+static void write_span_1BIT_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   SETUP_1BIT;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+                            DITHER_1BIT( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0,
+                    DITHER_1BIT( x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_1BIT_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   SETUP_1BIT;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+              DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0,
+          DITHER_1BIT(x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to a pixmap.
+ */
+static void write_span_HPCR_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+                            DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
+      for (i=0;i<n;i++) {
+         ptr[i] = DITHER_HPCR( (x+i), y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_HPCR_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc,
+              DITHER_HPCR(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
+      for (i=0;i<n;i++) {
+         ptr[i] = DITHER_HPCR( (x+i), y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to a pixmap.
+ */
+static void write_span_LOOKUP_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   LOOKUP_SETUP;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0, LOOKUP(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_LOOKUP_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   LOOKUP_SETUP;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0, LOOKUP(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to a pixmap.
+ */
+static void write_span_GRAYSCALE_pixmap( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to a pixmap (no alpha).
+ */
+static void write_span_rgb_GRAYSCALE_pixmap( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
+      }
+      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
+   }
+}
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to an XImage.
+ */
+static void write_span_TRUECOLOR_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+            XMesaPutPixel( img, x, y, p );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         unsigned long p;
+         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         XMesaPutPixel( img, x, y, p );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_TRUECOLOR pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_TRUECOLOR_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+            XMesaPutPixel( img, x, y, p );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         unsigned long p;
+         PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+         XMesaPutPixel( img, x, y, p );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to an XImage.
+ */
+static void write_span_TRUEDITHER_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+            XMesaPutPixel( img, x, y, p );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+         XMesaPutPixel( img, x, y, p );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_TRUEDITHER_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            unsigned long p;
+            PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+            XMesaPutPixel( img, x, y, p );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         XMesaPutPixel( img, x, y, p );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_8A8B8G8R-format pixels to an ximage.
+ */
+static void write_span_8A8B8G8R_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++) {
+         ptr[i] = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_8A8B8G8R-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_8A8B8G8R_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = PACK_8A8B8G8R( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++) {
+         ptr[i] = PACK_8A8B8G8R( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B-format pixels to an ximage.
+ */
+static void write_span_8R8G8B_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = PACK_8R8G8B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++) {
+         ptr[i] = PACK_8R8G8B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24-format pixels to an ximage.
+ */
+static void write_span_8R8G8B24_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = (GLubyte *) PIXELADDR3( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            GLuint *ptr4 = (GLuint *) ptr;
+            register GLuint pixel = *ptr4;
+            switch (3 & (int)(ptr - (GLubyte*)ptr4)) {
+               case 0:
+                  pixel &= 0xff000000;
+                  pixel |= rgba[i][BCOMP];
+                  pixel |= rgba[i][GCOMP] << 8;
+                  pixel |= rgba[i][RCOMP] << 16;
+                  *ptr4 = pixel;
+                  break;
+               case 3:
+                  pixel &= 0x00ffffff;
+                  pixel |= rgba[i][BCOMP] << 24;
+                  *ptr4++ = pixel;
+                  pixel = *ptr4 && 0xffff0000;
+                  pixel |= rgba[i][GCOMP];
+                  pixel |= rgba[i][RCOMP] << 8;
+                  *ptr4 = pixel;
+                  break;
+               case 2:
+                  pixel &= 0x0000ffff;
+                  pixel |= rgba[i][BCOMP] << 16;
+                  pixel |= rgba[i][GCOMP] << 24;
+                  *ptr4++ = pixel;
+                  pixel = *ptr4 && 0xffffff00;
+                  pixel |= rgba[i][RCOMP];
+                  *ptr4 = pixel;
+                  break;
+               case 1:
+                  pixel &= 0x000000ff;
+                  pixel |= rgba[i][BCOMP] << 8;
+                  pixel |= rgba[i][GCOMP] << 16;
+                  pixel |= rgba[i][RCOMP] << 24;
+                  *ptr4 = pixel;
+                  break;
+            }
+         }
+	 ptr += 3;
+      }
+   }
+   else {
+      /* write all pixels */
+      int w = n;
+      GLuint *ptr4 = (GLuint *) ptr;
+      register GLuint pixel = *ptr4;
+      int index = (int)(ptr - (GLubyte *)ptr4);
+      register GLuint i = 0;
+      switch (index) {
+         case 0:
+            break;
+         case 1:
+            pixel &= 0x00ffffff;
+            pixel |= rgba[i][BCOMP] << 24;
+            *ptr4++ = pixel;
+            pixel = *ptr4 && 0xffff0000;
+            pixel |= rgba[i][GCOMP];
+            pixel |= rgba[i++][RCOMP] << 8;
+            *ptr4 = pixel;
+            if (0 == --w)
+               break;
+         case 2:
+            pixel &= 0x0000ffff;
+            pixel |= rgba[i][BCOMP] << 16;
+            pixel |= rgba[i][GCOMP] << 24;
+            *ptr4++ = pixel;
+            pixel = *ptr4 && 0xffffff00;
+            pixel |= rgba[i++][RCOMP];
+            *ptr4 = pixel;
+            if (0 == --w)
+               break;
+         case 3:
+            pixel &= 0x000000ff;
+            pixel |= rgba[i][BCOMP] << 8;
+            pixel |= rgba[i][GCOMP] << 16;
+            pixel |= rgba[i++][RCOMP] << 24;
+            *ptr4++ = pixel;
+            if (0 == --w)
+               break;
+            break;
+      }
+      while (w > 3) {
+         pixel = rgba[i][BCOMP];
+         pixel |= rgba[i][GCOMP] << 8;
+         pixel |= rgba[i++][RCOMP] << 16;
+         pixel |= rgba[i][BCOMP] << 24;
+         *ptr4++ = pixel;
+         pixel = rgba[i][GCOMP];
+         pixel |= rgba[i++][RCOMP] << 8;
+         pixel |= rgba[i][BCOMP] << 16;
+         pixel |= rgba[i][GCOMP] << 24;
+         *ptr4++ = pixel;
+         pixel = rgba[i++][RCOMP];
+         pixel |= rgba[i][BCOMP] << 8;
+         pixel |= rgba[i][GCOMP] << 16;
+         pixel |= rgba[i++][RCOMP] << 24;
+         *ptr4++ = pixel;
+         w -= 4;
+      }
+      switch (w) {
+         case 0:
+            break;
+         case 1:
+            pixel = *ptr4 & 0xff000000;
+            pixel |= rgba[i][BCOMP];
+            pixel |= rgba[i][GCOMP] << 8;
+            pixel |= rgba[i][RCOMP] << 16;
+            *ptr4 = pixel;
+            break;
+         case 2:
+            pixel = rgba[i][BCOMP];
+            pixel |= rgba[i][GCOMP] << 8;
+            pixel |= rgba[i++][RCOMP] << 16;
+            pixel |= rgba[i][BCOMP] << 24;
+            *ptr4++ = pixel;
+            pixel = *ptr4 & 0xffff0000;
+            pixel |= rgba[i][GCOMP];
+            pixel |= rgba[i][RCOMP] << 8;
+            *ptr4 = pixel;
+            break;
+         case 3:
+            pixel = rgba[i][BCOMP];
+            pixel |= rgba[i][GCOMP] << 8;
+            pixel |= rgba[i++][RCOMP] << 16;
+            pixel |= rgba[i][BCOMP] << 24;
+            *ptr4++ = pixel;
+            pixel = rgba[i][GCOMP];
+            pixel |= rgba[i++][RCOMP] << 8;
+            pixel |= rgba[i][BCOMP] << 16;
+            pixel |= rgba[i][GCOMP] << 24;
+            *ptr4++ = pixel;
+            pixel = *ptr4 & 0xffffff00;
+            pixel |= rgba[i][RCOMP];
+            *ptr4 = pixel;
+            break;
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_8R8G8B_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = PACK_8R8G8B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++) {
+         ptr[i] = PACK_8R8G8B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_8R8G8B24-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_8R8G8B24_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = (GLubyte *) PIXELADDR3( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            *ptr++ = rgb[i][BCOMP];
+            *ptr++ = rgb[i][GCOMP];
+            *ptr++ = rgb[i][RCOMP];
+         }
+         else {
+            ptr += 3;
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++) {
+         *ptr++ = rgb[i][BCOMP];
+         *ptr++ = rgb[i][GCOMP];
+         *ptr++ = rgb[i][RCOMP];
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B-format pixels to an ximage.
+ */
+static void write_span_5R6G5B_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+      GLuint *ptr32 = (GLuint *) ptr;
+      GLuint extraPixel = (n & 1);
+      n -= extraPixel;
+      for (i = 0; i < n; i += 2) {
+         GLuint p0, p1;
+         p0 = PACK_5R6G5B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+         p1 = PACK_5R6G5B(rgba[i+1][RCOMP], rgba[i+1][GCOMP], rgba[i+1][BCOMP]);
+         *ptr32++ = (p1 << 16) | p0;
+      }
+      if (extraPixel) {
+         ptr[n] = PACK_5R6G5B(rgba[n][RCOMP], rgba[n][GCOMP], rgba[n][BCOMP]);
+      }
+#else
+      for (i = 0; i < n; i++) {
+         ptr[i] = PACK_5R6G5B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+#endif
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B-format pixels to an ximage.
+ */
+static void write_span_DITHER_5R6G5B_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+   const GLint y2 = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            PACK_TRUEDITHER( ptr[i], x, y2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+      GLuint *ptr32 = (GLuint *) ptr;
+      GLuint extraPixel = (n & 1);
+      n -= extraPixel;
+      for (i = 0; i < n; i += 2, x += 2) {
+         GLuint p0, p1;
+         PACK_TRUEDITHER( p0, x, y2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         PACK_TRUEDITHER( p1, x+1, y2, rgba[i+1][RCOMP], rgba[i+1][GCOMP], rgba[i+1][BCOMP] );
+         *ptr32++ = (p1 << 16) | p0;
+      }
+      if (extraPixel) {
+         PACK_TRUEDITHER( ptr[n], x+n, y2, rgba[n][RCOMP], rgba[n][GCOMP], rgba[n][BCOMP]);
+      }
+#else
+      for (i = 0; i < n; i++, x++) {
+         PACK_TRUEDITHER( ptr[i], x, y2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+      }
+#endif
+   }
+}
+
+
+/*
+ * Write a span of PF_5R6G5B-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_5R6G5B_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+      GLuint *ptr32 = (GLuint *) ptr;
+      GLuint extraPixel = (n & 1);
+      n -= extraPixel;
+      for (i = 0; i < n; i += 2) {
+         GLuint p0, p1;
+         p0 = PACK_5R6G5B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
+         p1 = PACK_5R6G5B(rgb[i+1][RCOMP], rgb[i+1][GCOMP], rgb[i+1][BCOMP]);
+         *ptr32++ = (p1 << 16) | p0;
+      }
+      if (extraPixel) {
+         ptr[n] = PACK_5R6G5B(rgb[n][RCOMP], rgb[n][GCOMP], rgb[n][BCOMP]);
+      }
+#else
+      for (i=0;i<n;i++) {
+         ptr[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+#endif
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER_5R6G5B-format pixels to an ximage (no alpha).
+ */
+static void write_span_rgb_DITHER_5R6G5B_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            PACK_TRUEDITHER( ptr[i], x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+      GLuint *ptr32 = (GLuint *) ptr;
+      GLuint extraPixel = (n & 1);
+      n -= extraPixel;
+      for (i = 0; i < n; i += 2, x += 2) {
+         GLuint p0, p1;
+         PACK_TRUEDITHER( p0, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+         PACK_TRUEDITHER( p1, x+1, y, rgb[i+1][RCOMP], rgb[i+1][GCOMP], rgb[i+1][BCOMP] );
+         *ptr32++ = (p1 << 16) | p0;
+      }
+      if (extraPixel) {
+         PACK_TRUEDITHER( ptr[n], x+n, y, rgb[n][RCOMP], rgb[n][GCOMP], rgb[n][BCOMP]);
+      }
+#else
+      for (i=0;i<n;i++,x++) {
+         PACK_TRUEDITHER( ptr[i], x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+#endif
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to an XImage.
+ */
+static void write_span_DITHER_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   int yy = FLIP(xmesa->xm_buffer, y);
+   XDITHER_SETUP(yy);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel( img, x, yy, XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, yy, XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_DITHER_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   int yy = FLIP(xmesa->xm_buffer, y);
+   XDITHER_SETUP(yy);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel( img, x, yy, XDITHER( x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, yy, XDITHER( x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+      }
+   }
+}
+
+
+
+/*
+ * Write a span of 8-bit PF_DITHER pixels to an XImage.
+ */
+static void write_span_DITHER8_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   XDITHER_SETUP(y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            ptr[i] = (GLubyte) XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++,x++) {
+         ptr[i] = (GLubyte) XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+static void write_span_rgb_DITHER8_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   XDITHER_SETUP(y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            ptr[i] = (GLubyte) XDITHER( x, rgb[i][0], rgb[i][1], rgb[i][2] );
+         }
+      }
+   }
+   else {
+      const GLubyte *data = (GLubyte *) rgb;
+      for (i=0;i<n;i++,x++) {
+         /*ptr[i] = XDITHER( x, rgb[i][0], rgb[i][1], rgb[i][2] );*/
+         ptr[i] = (GLubyte) XDITHER( x, data[i+i+i], data[i+i+i+1], data[i+i+i+2] );
+      }
+   }
+}
+
+
+
+/*
+ * Write a span of PF_1BIT pixels to an XImage.
+ */
+static void write_span_1BIT_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   SETUP_1BIT;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel(img, x, y, DITHER_1BIT(x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, y, DITHER_1BIT(x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_1BIT_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   SETUP_1BIT;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel(img, x, y, DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, y, DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to an XImage.
+ */
+static void write_span_HPCR_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            ptr[i] = DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         ptr[i] = DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_HPCR pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_HPCR_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            ptr[i] = DITHER_HPCR( x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         ptr[i] = DITHER_HPCR( x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to an XImage.
+ */
+static void write_span_LOOKUP_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   LOOKUP_SETUP;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel( img, x, y, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, y, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_LOOKUP pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_LOOKUP_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   LOOKUP_SETUP;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel( img, x, y, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, y, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of 8-bit PF_LOOKUP pixels to an XImage.
+ */
+static void write_span_LOOKUP8_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   LOOKUP_SETUP;
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            ptr[i] = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         ptr[i] = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+static void write_rgb_LOOKUP8_ximage( const GLcontext *ctx,
+                                      GLuint n, GLint x, GLint y,
+                                      CONST GLubyte rgb[][3],
+                                      const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   LOOKUP_SETUP;
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            ptr[i] = (GLubyte) LOOKUP( rgb[i][0], rgb[i][1], rgb[i][2] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      const GLubyte *data = (GLubyte *) rgb;
+      for (i=0;i<n;i++,x++) {
+         /*ptr[i] = LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );*/
+         ptr[i] = (GLubyte) LOOKUP( data[i+i+i], data[i+i+i+1], data[i+i+i+2] );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_span_GRAYSCALE_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel( img, x, y, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, y, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_GRAYSCALE pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_GRAYSCALE_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel( img, x, y, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, y, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of 8-bit PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_span_GRAYSCALE8_ximage( RGBA_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++) {
+         ptr[i] = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write a span of 8-bit PF_GRAYSCALE pixels to an XImage (no alpha).
+ */
+static void write_span_rgb_GRAYSCALE8_ximage( RGB_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            ptr[i] = (GLubyte) GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+         }
+      }
+   }
+   else {
+      /* draw all pixels */
+      for (i=0;i<n;i++) {
+         ptr[i] = (GLubyte) GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
+      }
+   }
+}
+
+
+
+
+/**********************************************************************/
+/*** Write COLOR PIXEL functions                                    ***/
+/**********************************************************************/
+
+
+#define RGBA_PIXEL_ARGS   const GLcontext *ctx,				\
+			  GLuint n, const GLint x[], const GLint y[],	\
+			  CONST GLubyte rgba[][4], const GLubyte mask[]
+
+
+/*
+ * Write an array of PF_TRUECOLOR pixels to a pixmap.
+ */
+static void write_pixels_TRUECOLOR_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+	 XMesaSetForeground( dpy, gc, p );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_TRUEDITHER pixels to a pixmap.
+ */
+static void write_pixels_TRUEDITHER_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+         XMesaSetForeground( dpy, gc, p );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_8A8B8G8R pixels to a pixmap.
+ */
+static void write_pixels_8A8B8G8R_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaSetForeground( dpy, gc,
+                         PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] ));
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B pixels to a pixmap.
+ */
+static void write_pixels_8R8G8B_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B24 pixels to a pixmap.
+ */
+static void write_pixels_8R8G8B24_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_5R6G5B pixels to a pixmap.
+ */
+static void write_pixels_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_DITHER_5R6G5B pixels to a pixmap.
+ */
+static void write_pixels_DITHER_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+	 XMesaSetForeground( dpy, gc, p );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_DITHER pixels to a pixmap.
+ */
+static void write_pixels_DITHER_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   DITHER_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaSetForeground( dpy, gc,
+                         DITHER(x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_1BIT pixels to a pixmap.
+ */
+static void write_pixels_1BIT_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   SETUP_1BIT;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaSetForeground( dpy, gc,
+                         DITHER_1BIT( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_HPCR pixels to a pixmap.
+ */
+static void write_pixels_HPCR_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         XMesaSetForeground( dpy, gc,
+                         DITHER_HPCR( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_LOOKUP pixels to a pixmap.
+ */
+static void write_pixels_LOOKUP_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   LOOKUP_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         XMesaSetForeground( dpy, gc, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_GRAYSCALE pixels to a pixmap.
+ */
+static void write_pixels_GRAYSCALE_pixmap( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         XMesaSetForeground( dpy, gc, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_TRUECOLOR pixels to an ximage.
+ */
+static void write_pixels_TRUECOLOR_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_TRUEDITHER pixels to an XImage.
+ */
+static void write_pixels_TRUEDITHER_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_8A8B8G8R pixels to an ximage.
+ */
+static void write_pixels_8A8B8G8R_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+         *ptr = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B pixels to an ximage.
+ */
+static void write_pixels_8R8G8B_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+         *ptr = PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_8R8G8B24 pixels to an ximage.
+ */
+static void write_pixels_8R8G8B24_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x[i], y[i] );
+         ptr->r = rgba[i][RCOMP];
+         ptr->g = rgba[i][GCOMP];
+         ptr->b = rgba[i][BCOMP];
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_5R6G5B pixels to an ximage.
+ */
+static void write_pixels_5R6G5B_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
+         *ptr = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_DITHER_5R6G5B pixels to an ximage.
+ */
+static void write_pixels_DITHER_5R6G5B_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
+         PACK_TRUEDITHER( *ptr, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_DITHER pixels to an XImage.
+ */
+static void write_pixels_DITHER_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   DITHER_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
+                    DITHER( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of 8-bit PF_DITHER pixels to an XImage.
+ */
+static void write_pixels_DITHER8_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   DITHER_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+	 *ptr = (GLubyte) DITHER( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_1BIT pixels to an XImage.
+ */
+static void write_pixels_1BIT_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   SETUP_1BIT;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
+                    DITHER_1BIT( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_HPCR pixels to an XImage.
+ */
+static void write_pixels_HPCR_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+         *ptr = (GLubyte) DITHER_HPCR( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_LOOKUP pixels to an XImage.
+ */
+static void write_pixels_LOOKUP_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   LOOKUP_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), LOOKUP(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of 8-bit PF_LOOKUP pixels to an XImage.
+ */
+static void write_pixels_LOOKUP8_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   LOOKUP_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+	 *ptr = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_pixels_GRAYSCALE_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
+                    GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of 8-bit PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_pixels_GRAYSCALE8_ximage( RGBA_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x[i], y[i] );
+	 *ptr = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
+      }
+   }
+}
+
+
+
+
+/**********************************************************************/
+/*** Write MONO COLOR SPAN functions                                ***/
+/**********************************************************************/
+
+#define MONO_SPAN_ARGS	const GLcontext *ctx,	\
+		 	GLuint n, GLint x, GLint y, const GLchan color[4], \
+                        const GLubyte mask[]
+
+
+/*
+ * Write a span of identical pixels to a pixmap.
+ */
+static void write_span_mono_pixmap( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+               color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
+   register GLuint i;
+   XMesaSetForeground( xmesa->display, gc, pixel );
+   y = FLIP(xmesa->xm_buffer, y);
+
+   /* New code contributed by Jeff Epler and cleaned up by Keith
+    * Whitwell.  
+    */
+   for (i = 0; i < n; ) {
+      GLuint start = i;
+
+      /* Identify and emit contiguous rendered pixels
+       */
+      while (i < n && mask[i])
+	 i++;
+
+      if (start < i) 
+	 XMesaFillRectangle( dpy, buffer, gc,
+			     (int)(x+start), (int) y,
+			     (int)(i-start), 1);
+
+      /* Eat up non-rendered pixels
+       */
+      while (i < n && !mask[i])
+	 i++;
+   }
+}
+
+
+
+static void write_span_mono_index_pixmap( const GLcontext *ctx, GLuint n,
+                                          GLint x, GLint y, GLuint colorIndex,
+                                          const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   XMesaSetForeground( xmesa->display, gc, colorIndex );
+   y = FLIP(xmesa->xm_buffer, y);
+
+   for (i = 0 ; i < n ;) {
+      GLuint start = i;
+      
+      /* Identify and emit contiguous rendered pixels 
+       */
+      while (i < n && mask[i])
+	 i++;
+
+      if (start < i) 
+	 XMesaFillRectangle( dpy, buffer, gc, 
+			     (int)(x+start), (int) y, 
+			     (int)(i-start), 1);
+
+      /* Eat up non-rendered pixels
+       */
+      while (i < n && !mask[i])
+	 i++;
+   }
+}
+
+
+
+/*
+ * Write a span of PF_TRUEDITHER pixels to a pixmap.
+ */
+static void write_span_mono_TRUEDITHER_pixmap( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLuint i;
+   int yy = FLIP(xmesa->xm_buffer, y);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x, yy, r, g, b);
+         XMesaSetForeground( dpy, gc, p );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) yy );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_DITHER pixels to a pixmap.
+ */
+static void write_span_mono_DITHER_pixmap( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLuint i;
+   int yy = FLIP(xmesa->xm_buffer, y);
+   XDITHER_SETUP(yy);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+         XMesaSetForeground( dpy, gc, XDITHER( x, r, g, b ) );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) yy );
+      }
+   }
+}
+
+
+/*
+ * Write a span of PF_1BIT pixels to a pixmap.
+ */
+static void write_span_mono_1BIT_pixmap( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLuint i;
+   SETUP_1BIT;
+   y = FLIP(xmesa->xm_buffer, y);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+         XMesaSetForeground( dpy, gc, DITHER_1BIT( x, y, r, g, b ) );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical pixels to an XImage.
+ */
+static void write_span_mono_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+               color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
+   y = FLIP(xmesa->xm_buffer, y);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x, y, pixel );
+      }
+   }
+}
+
+
+static void write_span_mono_index_ximage( const GLcontext *ctx, GLuint n,
+                                          GLint x, GLint y,
+                                          GLuint colorIndex,
+                                          const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x, y, colorIndex );
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical PF_TRUEDITHER pixels to an XImage.
+ */
+static void write_span_mono_TRUEDITHER_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   const GLint r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUEDITHER( p, x+i, y, r, g, b);
+	 XMesaPutPixel( img, x+i, y, p );
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical 8A8B8G8R pixels to an XImage.
+ */
+static void write_span_mono_8A8B8G8R_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   GLuint i, *ptr;
+   const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+               color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
+   ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 ptr[i] = pixel;
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical 8R8G8B pixels to an XImage.
+ */
+static void write_span_mono_8R8G8B_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLuint pixel = PACK_8R8G8B(color[RCOMP], color[GCOMP], color[BCOMP]);
+   GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
+   GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 ptr[i] = pixel;
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical 8R8G8B pixels to an XImage.
+ */
+static void write_span_mono_8R8G8B24_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP];
+   const GLubyte g = color[GCOMP];
+   const GLubyte b = color[BCOMP];
+   GLuint i;
+   bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x, y );
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         ptr[i].r = r;
+         ptr[i].g = g;
+         ptr[i].b = b;
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical DITHER pixels to an XImage.
+ */
+static void write_span_mono_DITHER_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   int yy = FLIP(xmesa->xm_buffer, y);
+   register GLuint i;
+   XDITHER_SETUP(yy);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x, yy, XDITHER( x, r, g, b ) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical 8-bit DITHER pixels to an XImage.
+ */
+static void write_span_mono_DITHER8_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
+   register GLuint i;
+   XDITHER_SETUP(y);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+	 ptr[i] = (GLubyte) XDITHER( x, r, g, b );
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical 8-bit LOOKUP pixels to an XImage.
+ */
+static void write_span_mono_LOOKUP8_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
+   GLubyte pixel;
+   LOOKUP_SETUP;
+   pixel = LOOKUP(color[RCOMP], color[GCOMP], color[BCOMP]);
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 ptr[i] = pixel;
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical PF_1BIT pixels to an XImage.
+ */
+static void write_span_mono_1BIT_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   SETUP_1BIT;
+   y = FLIP(xmesa->xm_buffer, y);
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x, y, DITHER_1BIT( x, y, r, g, b ) );
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical HPCR pixels to an XImage.
+ */
+static void write_span_mono_HPCR_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
+   register GLuint i;
+   for (i=0;i<n;i++,x++) {
+      if (mask[i]) {
+         ptr[i] = DITHER_HPCR( x, y, r, g, b );
+      }
+   }
+}
+
+
+/*
+ * Write a span of identical 8-bit GRAYSCALE pixels to an XImage.
+ */
+static void write_span_mono_GRAYSCALE8_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte p = GRAY_RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
+   GLubyte *ptr = (GLubyte *) PIXELADDR1( xmesa->xm_buffer,x,y);
+   GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 ptr[i] = p;
+      }
+   }
+}
+
+
+
+/*
+ * Write a span of identical PF_DITHER_5R6G5B pixels to an XImage.
+ */
+static void write_span_mono_DITHER_5R6G5B_ximage( MONO_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
+   const GLint r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         PACK_TRUEDITHER(ptr[i], x+i, y, r, g, b);
+      }
+   }
+}
+
+
+
+/**********************************************************************/
+/*** Write MONO COLOR PIXELS functions                              ***/
+/**********************************************************************/
+
+#define MONO_PIXEL_ARGS	const GLcontext *ctx,				\
+			GLuint n, const GLint x[], const GLint y[],	\
+			const GLchan color[4], const GLubyte mask[]
+
+/*
+ * Write an array of identical pixels to a pixmap.
+ */
+static void write_pixels_mono_pixmap( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+               color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
+   XMesaSetForeground( xmesa->display, gc, pixel );
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaDrawPoint( dpy, buffer, gc,
+                         (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+static void write_pixels_mono_index_pixmap(const GLcontext *ctx,
+                                           GLuint n,
+                                           const GLint x[], const GLint y[],
+                                           GLuint colorIndex,
+                                           const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   XMesaSetForeground( xmesa->display, gc, colorIndex );
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaDrawPoint( dpy, buffer, gc,
+                         (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_TRUEDITHER pixels to a pixmap.
+ */
+static void write_pixels_mono_TRUEDITHER_pixmap( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x[i], y[i], r, g, b);
+         XMesaSetForeground( dpy, gc, p );
+	 XMesaDrawPoint( dpy, buffer, gc,
+                         (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_DITHER pixels to a pixmap.
+ */
+static void write_pixels_mono_DITHER_pixmap( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   DITHER_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         XMesaSetForeground( dpy, gc, DITHER( x[i], y[i], r, g, b ) );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of PF_1BIT pixels to a pixmap.
+ */
+static void write_pixels_mono_1BIT_pixmap( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   SETUP_1BIT;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         XMesaSetForeground( dpy, gc, DITHER_1BIT( x[i], y[i], r, g, b ) );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical pixels to an XImage.
+ */
+static void write_pixels_mono_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   const unsigned long pixel = xmesa_color_to_pixel(xmesa, color[RCOMP],
+               color[GCOMP], color[BCOMP], color[ACOMP], xmesa->pixelformat);
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), pixel );
+      }
+   }
+}
+
+
+static void write_pixels_mono_index_ximage( const GLcontext *ctx, GLuint n,
+                                            const GLint x[], const GLint y[],
+                                            GLuint colorIndex,
+                                            const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), colorIndex );
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical TRUEDITHER pixels to an XImage.
+ */
+static void write_pixels_mono_TRUEDITHER_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   const int r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         unsigned long p;
+         PACK_TRUEDITHER(p, x[i], FLIP(xmesa->xm_buffer, y[i]), r, g, b);
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
+      }
+   }
+}
+
+
+
+/*
+ * Write an array of identical 8A8B8G8R pixels to an XImage
+ */
+static void write_pixels_mono_8A8B8G8R_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLuint p = PACK_8A8B8G8R(color[RCOMP], color[GCOMP],
+                                  color[BCOMP], color[ACOMP]);
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+	 *ptr = p;
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical 8R8G8B pixels to an XImage.
+ */
+static void write_pixels_mono_8R8G8B_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   const GLuint p = PACK_8R8G8B(color[RCOMP], color[GCOMP], color[BCOMP]);
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
+	 *ptr = p;
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical 8R8G8B pixels to an XImage.
+ */
+static void write_pixels_mono_8R8G8B24_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x[i], y[i] );
+         ptr->r = r;
+         ptr->g = g;
+         ptr->b = b;
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical PF_DITHER pixels to an XImage.
+ */
+static void write_pixels_mono_DITHER_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   DITHER_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), DITHER( x[i], y[i], r, g, b ) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical 8-bit PF_DITHER pixels to an XImage.
+ */
+static void write_pixels_mono_DITHER8_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLuint i;
+   DITHER_SETUP;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+	 *ptr = (GLubyte) DITHER( x[i], y[i], r, g, b );
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical 8-bit PF_LOOKUP pixels to an XImage.
+ */
+static void write_pixels_mono_LOOKUP8_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   GLubyte pixel;
+   LOOKUP_SETUP;
+   pixel = LOOKUP(color[RCOMP], color[GCOMP], color[BCOMP]);
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+	 *ptr = pixel;
+      }
+   }
+}
+
+
+
+/*
+ * Write an array of identical PF_1BIT pixels to an XImage.
+ */
+static void write_pixels_mono_1BIT_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   SETUP_1BIT;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
+                        DITHER_1BIT( x[i], y[i], r, g, b ));
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical PF_HPCR pixels to an XImage.
+ */
+static void write_pixels_mono_HPCR_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+         *ptr = DITHER_HPCR( x[i], y[i], r, g, b );
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical 8-bit PF_GRAYSCALE pixels to an XImage.
+ */
+static void write_pixels_mono_GRAYSCALE8_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   register GLubyte p = GRAY_RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
+	 *ptr = p;
+      }
+   }
+}
+
+
+/*
+ * Write an array of identical PF_DITHER_5R6G5B pixels to an XImage.
+ */
+static void write_pixels_mono_DITHER_5R6G5B_ximage( MONO_PIXEL_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const int r = color[RCOMP], g = color[GCOMP], b = color[BCOMP];
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
+         PACK_TRUEDITHER(*ptr, x[i], y[i], r, g, b);
+      }
+   }
+}
+
+
+
+/**********************************************************************/
+/*** Write INDEX SPAN functions                                     ***/
+/**********************************************************************/
+
+#define INDEX_SPAN_ARGS	const GLcontext *ctx,				\
+			GLuint n, GLint x, GLint y, const GLuint index[], \
+			const GLubyte mask[]
+
+#define INDEX8_SPAN_ARGS const GLcontext *ctx,				\
+			 GLuint n, GLint x, GLint y, const GLubyte index[], \
+			 const GLubyte mask[]
+
+
+/*
+ * Write a span of CI pixels to a Pixmap.
+ */
+static void write_span_index_pixmap( INDEX_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++,x++) {
+         XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+      }
+   }
+}
+
+
+/*
+ * Write a span of 8-bit CI pixels to a Pixmap.
+ */
+static void write_span_index8_pixmap( INDEX8_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++,x++) {
+         XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
+      }
+   }
+}
+
+
+/*
+ * Write a span of CI pixels to an XImage.
+ */
+static void write_span_index_ximage( INDEX_SPAN_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   y = FLIP(xmesa->xm_buffer, y);
+   if (mask) {
+      for (i=0;i<n;i++,x++) {
+         if (mask[i]) {
+            XMesaPutPixel( img, x, y, (unsigned long) index[i] );
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++,x++) {
+         XMesaPutPixel( img, x, y, (unsigned long) index[i] );
+      }
+   }
+}
+
+
+/*
+ * Write a span of 8-bit CI pixels to a non 8-bit XImage.
+ */
+static void write_span_index8_ximage( const GLcontext *ctx, GLuint n,
+                                      GLint x, GLint y, const GLubyte index[],
+                                      const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   if (mask) {
+      GLuint i;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
+         }
+      }
+   }
+   else {
+      GLuint i;
+      for (i=0;i<n;i++) {
+         XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
+      }
+   }
+}
+
+/*
+ * Write a span of 8-bit CI pixels to an 8-bit XImage.
+ */
+static void write_span_index8_ximage8( const GLcontext *ctx, GLuint n,
+                                      GLint x, GLint y, const GLubyte index[],
+                                      const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   GLubyte *dst = PIXELADDR1( xmesa->xm_buffer,x,y);
+   if (mask) {
+      GLuint i;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            dst[i] = index[i];
+         }
+      }
+   }
+   else {
+      MEMCPY( dst, index, n );
+   }
+}
+
+
+
+/**********************************************************************/
+/*** Write INDEX PIXELS functions                                   ***/
+/**********************************************************************/
+
+#define INDEX_PIXELS_ARGS	const GLcontext *ctx,			\
+				GLuint n, const GLint x[], const GLint y[], \
+				const GLuint index[], const GLubyte mask[]
+
+
+/*
+ * Write an array of CI pixels to a Pixmap.
+ */
+static void write_pixels_index_pixmap( INDEX_PIXELS_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
+   XMesaGC gc = xmesa->xm_buffer->gc;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
+	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
+      }
+   }
+}
+
+
+/*
+ * Write an array of CI pixels to an XImage.
+ */
+static void write_pixels_index_ximage( INDEX_PIXELS_ARGS )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+   register GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), (unsigned long) index[i] );
+      }
+   }
+}
+
+
+
+
+/**********************************************************************/
+/*****                      Pixel reading                         *****/
+/**********************************************************************/
+
+
+
+/*
+ * Read a horizontal span of color-index pixels.
+ */
+static void read_index_span( const GLcontext *ctx,
+			     GLuint n, GLint x, GLint y, GLuint index[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaBuffer source;
+   GLuint i;
+
+   if (xmesa->use_read_buffer)
+      source = xmesa->xm_read_buffer;
+   else
+      source = xmesa->xm_buffer;
+
+   y = FLIP(source, y);
+
+   if (source->buffer) {
+#ifndef XFree86Server
+      XMesaImage *span = NULL;
+      int error;
+      catch_xgetimage_errors( xmesa->display );
+      span = XGetImage( xmesa->display, source->buffer,
+		        x, y, n, 1, AllPlanes, ZPixmap );
+      error = check_xgetimage_errors();
+      if (span && !error) {
+	 for (i=0;i<n;i++) {
+	    index[i] = (GLuint) XMesaGetPixel( span, i, 0 );
+	 }
+      }
+      else {
+	 /* return 0 pixels */
+	 for (i=0;i<n;i++) {
+	    index[i] = 0;
+	 }
+      }
+      if (span) {
+	 XMesaDestroyImage( span );
+      }
+#else
+      (*xmesa->display->GetImage)(source->buffer,
+				  x, y, n, 1, ZPixmap,
+				  ~0L, (pointer)index);
+#endif
+   }
+   else if (source->backimage) {
+      XMesaImage *img = source->backimage;
+      for (i=0;i<n;i++,x++) {
+	 index[i] = (GLuint) XMesaGetPixel( img, x, y );
+      }
+   }
+}
+
+
+
+/*
+ * Read a horizontal span of color pixels.
+ */
+static void read_color_span( const GLcontext *ctx,
+			     GLuint n, GLint x, GLint y,
+                             GLubyte rgba[][4] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaBuffer source;
+
+   if (xmesa->use_read_buffer)
+      source = xmesa->xm_read_buffer;
+   else
+      source = xmesa->xm_buffer;
+
+   if (source->buffer) {
+      /* Read from Pixmap or Window */
+      XMesaImage *span = NULL;
+      int error;
+#ifdef XFree86Server
+      span = XMesaCreateImage(xmesa->xm_visual->BitsPerPixel, n, 1, NULL);
+      span->data = (char *)MALLOC(span->height * span->bytes_per_line);
+      error = (!span->data);
+      (*xmesa->display->GetImage)(source->buffer,
+				  x, FLIP(source, y), n, 1, ZPixmap,
+				  ~0L, (pointer)span->data);
+#else
+      catch_xgetimage_errors( xmesa->display );
+      span = XGetImage( xmesa->display, source->buffer,
+		        x, FLIP(source, y), n, 1, AllPlanes, ZPixmap );
+      error = check_xgetimage_errors();
+#endif
+      if (span && !error) {
+	 switch (xmesa->pixelformat) {
+	    case PF_TRUECOLOR:
+	    case PF_TRUEDITHER:
+               {
+                  const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+                  const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+                  const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+                  unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+                  unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+                  unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+                  GLint rShift = xmesa->xm_visual->rshift;
+                  GLint gShift = xmesa->xm_visual->gshift;
+                  GLint bShift = xmesa->xm_visual->bshift;
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     unsigned long p;
+                     p = XMesaGetPixel( span, i, 0 );
+                     rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+                     rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+                     rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+	       break;
+            case PF_5R6G5B:
+            case PF_DITHER_5R6G5B:
+               {
+                  const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+                  const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+                  const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     unsigned long p = XMesaGetPixel( span, i, 0 );
+                     /* fast, but not quite accurate
+                     rgba[i][RCOMP] = ((p >> 8) & 0xf8);
+                     rgba[i][GCOMP] = ((p >> 3) & 0xfc);
+                     rgba[i][BCOMP] = ((p << 3) & 0xff);
+                     */
+                     rgba[i][RCOMP] = pixelToR[p >> 11];
+                     rgba[i][GCOMP] = pixelToG[(p >> 5) & 0x3f];
+                     rgba[i][BCOMP] = pixelToB[p & 0x1f];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+	       break;
+	    case PF_8A8B8G8R:
+               {
+                  const GLuint *ptr4 = (GLuint *) span->data;
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     GLuint p4 = *ptr4++;
+                     rgba[i][RCOMP] = (GLubyte) ( p4        & 0xff);
+                     rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
+                     rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+                     rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
+                  }
+	       }
+	       break;
+            case PF_8R8G8B:
+               {
+                  const GLuint *ptr4 = (GLuint *) span->data;
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     GLuint p4 = *ptr4++;
+                     rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+                     rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
+                     rgba[i][BCOMP] = (GLubyte) ( p4        & 0xff);
+                     rgba[i][ACOMP] = 255;
+                  }
+	       }
+	       break;
+            case PF_8R8G8B24:
+               {
+                  const bgr_t *ptr3 = (bgr_t *) span->data;
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     rgba[i][RCOMP] = ptr3[i].r;
+                     rgba[i][GCOMP] = ptr3[i].g;
+                     rgba[i][BCOMP] = ptr3[i].b;
+                     rgba[i][ACOMP] = 255;
+                  }
+	       }
+	       break;
+            case PF_HPCR:
+               {
+                  GLubyte *ptr1 = (GLubyte *) span->data;
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     GLubyte p = *ptr1++;
+                     rgba[i][RCOMP] =  p & 0xE0;
+                     rgba[i][GCOMP] = (p & 0x1C) << 3;
+                     rgba[i][BCOMP] = (p & 0x03) << 6;
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+               break;
+	    case PF_DITHER:
+	    case PF_LOOKUP:
+	    case PF_GRAYSCALE:
+               {
+                  GLubyte *rTable = source->pixel_to_r;
+                  GLubyte *gTable = source->pixel_to_g;
+                  GLubyte *bTable = source->pixel_to_b;
+                  if (GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
+                     const GLubyte *ptr1 = (GLubyte *) span->data;
+                     GLuint i;
+                     for (i=0;i<n;i++) {
+                        unsigned long p = *ptr1++;
+                        rgba[i][RCOMP] = rTable[p];
+                        rgba[i][GCOMP] = gTable[p];
+                        rgba[i][BCOMP] = bTable[p];
+                        rgba[i][ACOMP] = 255;
+                     }
+                  }
+                  else {
+                     GLuint i;
+                     for (i=0;i<n;i++) {
+                        unsigned long p = XMesaGetPixel( span, i, 0 );
+                        rgba[i][RCOMP] = rTable[p];
+                        rgba[i][GCOMP] = gTable[p];
+                        rgba[i][BCOMP] = bTable[p];
+                        rgba[i][ACOMP] = 255;
+                     }
+                  }
+               }
+	       break;
+	    case PF_1BIT:
+               {
+                  int bitFlip = xmesa->xm_visual->bitFlip;
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     unsigned long p;
+                     p = XMesaGetPixel( span, i, 0 ) ^ bitFlip;
+                     rgba[i][RCOMP] = (GLubyte) (p * 255);
+                     rgba[i][GCOMP] = (GLubyte) (p * 255);
+                     rgba[i][BCOMP] = (GLubyte) (p * 255);
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+	       break;
+	    default:
+	       _mesa_problem(NULL,"Problem in DD.read_color_span (1)");
+               return;
+	 }
+      }
+      else {
+	 /* return black pixels */
+         GLuint i;
+	 for (i=0;i<n;i++) {
+	    rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = rgba[i][ACOMP] = 0;
+	 }
+      }
+      if (span) {
+	 XMesaDestroyImage( span );
+      }
+   }
+   else if (source->backimage) {
+      /* Read from XImage back buffer */
+      switch (xmesa->pixelformat) {
+         case PF_TRUECOLOR:
+         case PF_TRUEDITHER:
+            {
+               const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+               const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+               const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+               unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+               unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+               unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+               GLint rShift = xmesa->xm_visual->rshift;
+               GLint gShift = xmesa->xm_visual->gshift;
+               GLint bShift = xmesa->xm_visual->bshift;
+               XMesaImage *img = source->backimage;
+               GLuint i;
+               y = FLIP(source, y);
+               for (i=0;i<n;i++) {
+                  unsigned long p;
+		  p = XMesaGetPixel( img, x+i, y );
+                  rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+                  rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+                  rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+                  rgba[i][ACOMP] = 255;
+               }
+            }
+            break;
+         case PF_5R6G5B:
+         case PF_DITHER_5R6G5B:
+            {
+               const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+               const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+               const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+               const GLushort *ptr2 = PIXELADDR2( source, x, y );
+               GLuint i;
+#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
+               const GLuint *ptr4 = (const GLuint *) ptr2;
+               GLuint extraPixel = (n & 1);
+               n -= extraPixel;
+               for (i = 0; i < n; i += 2) {
+                  const GLuint p = *ptr4++;
+                  const GLuint p0 = p & 0xffff;
+                  const GLuint p1 = p >> 16;
+                  /* fast, but not quite accurate
+                  rgba[i][RCOMP] = ((p >> 8) & 0xf8);
+                  rgba[i][GCOMP] = ((p >> 3) & 0xfc);
+                  rgba[i][BCOMP] = ((p << 3) & 0xff);
+                  */
+                  rgba[i][RCOMP] = pixelToR[p0 >> 11];
+                  rgba[i][GCOMP] = pixelToG[(p0 >> 5) & 0x3f];
+                  rgba[i][BCOMP] = pixelToB[p0 & 0x1f];
+                  rgba[i][ACOMP] = 255;
+                  rgba[i+1][RCOMP] = pixelToR[p1 >> 11];
+                  rgba[i+1][GCOMP] = pixelToG[(p1 >> 5) & 0x3f];
+                  rgba[i+1][BCOMP] = pixelToB[p1 & 0x1f];
+                  rgba[i+1][ACOMP] = 255;
+               }
+               if (extraPixel) {
+                  GLushort p = ptr2[n];
+                  rgba[n][RCOMP] = pixelToR[p >> 11];
+                  rgba[n][GCOMP] = pixelToG[(p >> 5) & 0x3f];
+                  rgba[n][BCOMP] = pixelToB[p & 0x1f];
+                  rgba[n][ACOMP] = 255;
+               }
+#else
+               for (i = 0; i < n; i++) {
+                  const GLushort p = ptr2[i];
+                  rgba[i][RCOMP] = pixelToR[p >> 11];
+                  rgba[i][GCOMP] = pixelToG[(p >> 5) & 0x3f];
+                  rgba[i][BCOMP] = pixelToB[p & 0x1f];
+                  rgba[i][ACOMP] = 255;
+               }
+#endif
+            }
+            break;
+	 case PF_8A8B8G8R:
+            {
+               const GLuint *ptr4 = PIXELADDR4( source, x, y );
+               GLuint i;
+               for (i=0;i<n;i++) {
+                  GLuint p4 = *ptr4++;
+                  rgba[i][RCOMP] = (GLubyte) ( p4        & 0xff);
+                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
+                  rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+                  rgba[i][ACOMP] = (GLint)   ((p4 >> 24) & 0xff);
+               }
+            }
+	    break;
+	 case PF_8R8G8B:
+            {
+               const GLuint *ptr4 = PIXELADDR4( source, x, y );
+               GLuint i;
+               for (i=0;i<n;i++) {
+                  GLuint p4 = *ptr4++;
+                  rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
+                  rgba[i][BCOMP] = (GLubyte) ( p4        & 0xff);
+                  rgba[i][ACOMP] = 255;
+               }
+            }
+	    break;
+	 case PF_8R8G8B24:
+            {
+               const bgr_t *ptr3 = PIXELADDR3( source, x, y );
+               GLuint i;
+               for (i=0;i<n;i++) {
+                  rgba[i][RCOMP] = ptr3[i].r;
+                  rgba[i][GCOMP] = ptr3[i].g;
+                  rgba[i][BCOMP] = ptr3[i].b;
+                  rgba[i][ACOMP] = 255;
+               }
+            }
+	    break;
+         case PF_HPCR:
+            {
+               const GLubyte *ptr1 = PIXELADDR1( source, x, y );
+               GLuint i;
+               for (i=0;i<n;i++) {
+                  GLubyte p = *ptr1++;
+                  rgba[i][RCOMP] =  p & 0xE0;
+                  rgba[i][GCOMP] = (p & 0x1C) << 3;
+                  rgba[i][BCOMP] = (p & 0x03) << 6;
+                  rgba[i][ACOMP] = 255;
+               }
+            }
+            break;
+	 case PF_DITHER:
+	 case PF_LOOKUP:
+	 case PF_GRAYSCALE:
+            {
+               const GLubyte *rTable = source->pixel_to_r;
+               const GLubyte *gTable = source->pixel_to_g;
+               const GLubyte *bTable = source->pixel_to_b;
+               if (GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
+                  GLubyte *ptr1 = PIXELADDR1( source, x, y );
+                  GLuint i;
+                  for (i=0;i<n;i++) {
+                     unsigned long p = *ptr1++;
+                     rgba[i][RCOMP] = rTable[p];
+                     rgba[i][GCOMP] = gTable[p];
+                     rgba[i][BCOMP] = bTable[p];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+               else {
+                  XMesaImage *img = source->backimage;
+                  GLuint i;
+                  y = FLIP(source, y);
+                  for (i=0;i<n;i++,x++) {
+                     unsigned long p = XMesaGetPixel( img, x, y );
+                     rgba[i][RCOMP] = rTable[p];
+                     rgba[i][GCOMP] = gTable[p];
+                     rgba[i][BCOMP] = bTable[p];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+            }
+	    break;
+	 case PF_1BIT:
+            {
+               XMesaImage *img = source->backimage;
+               int bitFlip = xmesa->xm_visual->bitFlip;
+               GLuint i;
+               y = FLIP(source, y);
+               for (i=0;i<n;i++,x++) {
+                  unsigned long p;
+		  p = XMesaGetPixel( img, x, y ) ^ bitFlip;
+                  rgba[i][RCOMP] = (GLubyte) (p * 255);
+                  rgba[i][GCOMP] = (GLubyte) (p * 255);
+                  rgba[i][BCOMP] = (GLubyte) (p * 255);
+                  rgba[i][ACOMP] = 255;
+               }
+	    }
+	    break;
+	 default:
+	    _mesa_problem(NULL,"Problem in DD.read_color_span (2)");
+            return;
+      }
+   }
+}
+
+
+
+/*
+ * Read an array of color index pixels.
+ */
+static void read_index_pixels( const GLcontext *ctx,
+			       GLuint n, const GLint x[], const GLint y[],
+                               GLuint indx[], const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   register GLuint i;
+   XMesaBuffer source;
+
+   if (xmesa->use_read_buffer)
+      source = xmesa->xm_read_buffer;
+   else
+      source = xmesa->xm_buffer;
+
+   if (source->buffer) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            indx[i] = (GLuint) read_pixel( xmesa->display,
+                                           source->buffer,
+                                           x[i], FLIP(source, y[i]) );
+         }
+      }
+   }
+   else if (source->backimage) {
+      XMesaImage *img = source->backimage;
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            indx[i] = (GLuint) XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
+         }
+      }
+   }
+}
+
+
+
+static void read_color_pixels( const GLcontext *ctx,
+			       GLuint n, const GLint x[], const GLint y[],
+                               GLubyte rgba[][4], const GLubyte mask[] )
+{
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaDisplay *dpy = xmesa->xm_visual->display;
+   register GLuint i;
+   XMesaBuffer source;
+   XMesaDrawable buffer;
+
+   if (xmesa->use_read_buffer)
+      source = xmesa->xm_read_buffer;
+   else
+      source = xmesa->xm_buffer;
+
+   buffer = source->buffer;  /* the X drawable */
+
+   if (source->buffer) {
+      switch (xmesa->pixelformat) {
+	 case PF_TRUECOLOR:
+         case PF_TRUEDITHER:
+         case PF_5R6G5B:
+         case PF_DITHER_5R6G5B:
+            {
+               unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+               unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+               unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+               GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+               GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+               GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+               GLint rShift = xmesa->xm_visual->rshift;
+               GLint gShift = xmesa->xm_visual->gshift;
+               GLint bShift = xmesa->xm_visual->bshift;
+               for (i=0;i<n;i++) {
+                  if (mask[i]) {
+                     unsigned long p = read_pixel( dpy, buffer,
+                                                   x[i], FLIP(source, y[i]) );
+                     rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+                     rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+                     rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+            }
+            break;
+	 case PF_8A8B8G8R:
+	    for (i=0;i<n;i++) {
+               if (mask[i]) {
+                  unsigned long p = read_pixel( dpy, buffer,
+                                                x[i], FLIP(source, y[i]) );
+                  rgba[i][RCOMP] = (GLubyte) ( p        & 0xff);
+                  rgba[i][GCOMP] = (GLubyte) ((p >> 8)  & 0xff);
+                  rgba[i][BCOMP] = (GLubyte) ((p >> 16) & 0xff);
+                  rgba[i][ACOMP] = (GLubyte) ((p >> 24) & 0xff);
+               }
+	    }
+	    break;
+	 case PF_8R8G8B:
+	    for (i=0;i<n;i++) {
+               if (mask[i]) {
+                  unsigned long p = read_pixel( dpy, buffer,
+                                                x[i], FLIP(source, y[i]) );
+                  rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
+                  rgba[i][GCOMP] = (GLubyte) ((p >> 8)  & 0xff);
+                  rgba[i][BCOMP] = (GLubyte) ( p        & 0xff);
+                  rgba[i][ACOMP] = 255;
+               }
+	    }
+	    break;
+	 case PF_8R8G8B24:
+	    for (i=0;i<n;i++) {
+               if (mask[i]) {
+                  unsigned long p = read_pixel( dpy, buffer,
+                                                x[i], FLIP(source, y[i]) );
+                  rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
+                  rgba[i][GCOMP] = (GLubyte) ((p >> 8)  & 0xff);
+                  rgba[i][BCOMP] = (GLubyte) ( p        & 0xff);
+                  rgba[i][ACOMP] = 255;
+               }
+	    }
+	    break;
+         case PF_HPCR:
+            {
+               for (i=0;i<n;i++) {
+                  if (mask[i]) {
+                     unsigned long p = read_pixel( dpy, buffer,
+                                                   x[i], FLIP(source, y[i]) );
+                     rgba[i][RCOMP] = (GLubyte) ( p & 0xE0      );
+                     rgba[i][GCOMP] = (GLubyte) ((p & 0x1C) << 3);
+                     rgba[i][BCOMP] = (GLubyte) ((p & 0x03) << 6);
+                     rgba[i][ACOMP] = (GLubyte) 255;
+                  }
+               }
+            }
+            break;
+	 case PF_DITHER:
+	 case PF_LOOKUP:
+	 case PF_GRAYSCALE:
+            {
+               GLubyte *rTable = source->pixel_to_r;
+               GLubyte *gTable = source->pixel_to_g;
+               GLubyte *bTable = source->pixel_to_b;
+               for (i=0;i<n;i++) {
+                  if (mask[i]) {
+                     unsigned long p = read_pixel( dpy, buffer,
+                                                   x[i], FLIP(source, y[i]) );
+                     rgba[i][RCOMP] = rTable[p];
+                     rgba[i][GCOMP] = gTable[p];
+                     rgba[i][BCOMP] = bTable[p];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+	    }
+	    break;
+	 case PF_1BIT:
+            {
+               int bitFlip = xmesa->xm_visual->bitFlip;
+               for (i=0;i<n;i++) {
+                  if (mask[i]) {
+                     unsigned long p = read_pixel( dpy, buffer,
+                                     x[i], FLIP(source, y[i])) ^ bitFlip;
+                     rgba[i][RCOMP] = (GLubyte) (p * 255);
+                     rgba[i][GCOMP] = (GLubyte) (p * 255);
+                     rgba[i][BCOMP] = (GLubyte) (p * 255);
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+	    }
+	    break;
+	 default:
+	    _mesa_problem(NULL,"Problem in DD.read_color_pixels (1)");
+            return;
+      }
+   }
+   else if (source->backimage) {
+      switch (xmesa->pixelformat) {
+	 case PF_TRUECOLOR:
+         case PF_TRUEDITHER:
+         case PF_5R6G5B:
+         case PF_DITHER_5R6G5B:
+            {
+               unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
+               unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
+               unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
+               GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
+               GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
+               GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
+               GLint rShift = xmesa->xm_visual->rshift;
+               GLint gShift = xmesa->xm_visual->gshift;
+               GLint bShift = xmesa->xm_visual->bshift;
+               XMesaImage *img = source->backimage;
+               for (i=0;i<n;i++) {
+                  if (mask[i]) {
+                     unsigned long p;
+                     p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
+                     rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
+                     rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
+                     rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+            }
+            break;
+	 case PF_8A8B8G8R:
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLuint *ptr4 = PIXELADDR4( source, x[i], y[i] );
+                  GLuint p4 = *ptr4;
+                  rgba[i][RCOMP] = (GLubyte) ( p4        & 0xff);
+                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
+                  rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+                  rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
+               }
+	    }
+	    break;
+	 case PF_8R8G8B:
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLuint *ptr4 = PIXELADDR4( source, x[i], y[i] );
+                  GLuint p4 = *ptr4;
+                  rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
+                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
+                  rgba[i][BCOMP] = (GLubyte) ( p4        & 0xff);
+                  rgba[i][ACOMP] = 255;
+               }
+	    }
+	    break;
+	 case PF_8R8G8B24:
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  bgr_t *ptr3 = PIXELADDR3( source, x[i], y[i] );
+                  rgba[i][RCOMP] = ptr3->r;
+                  rgba[i][GCOMP] = ptr3->g;
+                  rgba[i][BCOMP] = ptr3->b;
+                  rgba[i][ACOMP] = 255;
+               }
+	    }
+	    break;
+         case PF_HPCR:
+            for (i=0;i<n;i++) {
+               if (mask[i]) {
+                  GLubyte *ptr1 = PIXELADDR1( source, x[i], y[i] );
+                  GLubyte p = *ptr1;
+                  rgba[i][RCOMP] =  p & 0xE0;
+                  rgba[i][GCOMP] = (p & 0x1C) << 3;
+                  rgba[i][BCOMP] = (p & 0x03) << 6;
+                  rgba[i][ACOMP] = 255;
+               }
+            }
+            break;
+	 case PF_DITHER:
+	 case PF_LOOKUP:
+	 case PF_GRAYSCALE:
+            {
+               GLubyte *rTable = source->pixel_to_r;
+               GLubyte *gTable = source->pixel_to_g;
+               GLubyte *bTable = source->pixel_to_b;
+               XMesaImage *img = source->backimage;
+               for (i=0;i<n;i++) {
+                  if (mask[i]) {
+                     unsigned long p;
+                     p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
+                     rgba[i][RCOMP] = rTable[p];
+                     rgba[i][GCOMP] = gTable[p];
+                     rgba[i][BCOMP] = bTable[p];
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+	    }
+	    break;
+	 case PF_1BIT:
+            {
+               XMesaImage *img = source->backimage;
+               int bitFlip = xmesa->xm_visual->bitFlip;
+               for (i=0;i<n;i++) {
+                  if (mask[i]) {
+                     unsigned long p;
+                     p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) ) ^ bitFlip;
+                     rgba[i][RCOMP] = (GLubyte) (p * 255);
+                     rgba[i][GCOMP] = (GLubyte) (p * 255);
+                     rgba[i][BCOMP] = (GLubyte) (p * 255);
+                     rgba[i][ACOMP] = 255;
+                  }
+               }
+	    }
+	    break;
+	 default:
+	    _mesa_problem(NULL,"Problem in DD.read_color_pixels (1)");
+            return;
+      }
+   }
+}
+
+
+static void
+clear_color_HPCR_ximage( GLcontext *ctx, const GLchan color[4] )
+{
+   int i;
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+   COPY_4V(xmesa->clearcolor, color);
+
+   if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
+      /* black is black */
+      MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
+              sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
+   }
+   else {
+      /* build clear pattern */
+      for (i=0; i<16; i++) {
+         xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i]    =
+            DITHER_HPCR(i, 0, color[0], color[1], color[2]);
+         xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i]    =
+            DITHER_HPCR(i, 1, color[0], color[1], color[2]);
+      }
+   }
+}
+
+
+static void
+clear_color_HPCR_pixmap( GLcontext *ctx, const GLchan color[4] )
+{
+   int i;
+   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+   COPY_4V(xmesa->clearcolor, color);
+
+   if (color[0] == 0 && color[1] == 0 && color[2] == 0) {
+      /* black is black */
+      for (i=0; i<16; i++) {
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, 0);
+      }
+   }
+   else {
+      for (i=0; i<16; i++) {
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0,
+                       DITHER_HPCR(i, 0, color[0], color[1], color[2]));
+         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1,
+                       DITHER_HPCR(i, 1, color[0], color[1], color[2]));
+      }
+   }
+   /* change tile pixmap content */
+   XMesaPutImage(xmesa->display,
+		 (XMesaDrawable)xmesa->xm_visual->hpcr_clear_pixmap,
+		 xmesa->xm_buffer->cleargc,
+		 xmesa->xm_visual->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
+}
+
+
+
+void xmesa_update_span_funcs( GLcontext *ctx )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   int depth=GET_VISUAL_DEPTH(xmesa->xm_visual);
+   struct swrast_device_driver *dd = _swrast_GetDeviceDriverReference( ctx );
+
+   /*
+    * These drawing functions depend on color buffer config:
+    */
+   if (xmesa->xm_buffer->buffer!=XIMAGE) {
+      /* Writing to window or back pixmap */
+      switch (xmesa->pixelformat) {
+	 case PF_INDEX:
+	    dd->WriteCI32Span     = write_span_index_pixmap;
+	    dd->WriteCI8Span      = write_span_index8_pixmap;
+	    dd->WriteMonoCISpan   = write_span_mono_index_pixmap;
+	    dd->WriteCI32Pixels   = write_pixels_index_pixmap;
+	    dd->WriteMonoCIPixels = write_pixels_mono_index_pixmap;
+	    break;
+	 case PF_TRUECOLOR:
+	    dd->WriteRGBASpan       = write_span_TRUECOLOR_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_TRUECOLOR_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_TRUECOLOR_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+	    break;
+	 case PF_TRUEDITHER:
+	    dd->WriteRGBASpan       = write_span_TRUEDITHER_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_TRUEDITHER_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_TRUEDITHER_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_TRUEDITHER_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
+	    break;
+	 case PF_8A8B8G8R:
+	    dd->WriteRGBASpan       = write_span_8A8B8G8R_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_8A8B8G8R_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_8A8B8G8R_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+	    break;
+	 case PF_8R8G8B:
+	    dd->WriteRGBASpan       = write_span_8R8G8B_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_8R8G8B_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_8R8G8B_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+	    break;
+	 case PF_8R8G8B24:
+	    dd->WriteRGBASpan       = write_span_8R8G8B24_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_8R8G8B24_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_8R8G8B24_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+	    break;
+	 case PF_5R6G5B:
+	    dd->WriteRGBASpan       = write_span_5R6G5B_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_5R6G5B_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_5R6G5B_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+	    break;
+	 case PF_DITHER_5R6G5B:
+	    dd->WriteRGBASpan       = write_span_DITHER_5R6G5B_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_DITHER_5R6G5B_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_TRUEDITHER_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_DITHER_5R6G5B_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
+	    break;
+	 case PF_DITHER:
+	    dd->WriteRGBASpan       = write_span_DITHER_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_DITHER_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_DITHER_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_DITHER_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_pixmap;
+	    break;
+	 case PF_1BIT:
+	    dd->WriteRGBASpan       = write_span_1BIT_pixmap;
+	    dd->WriteRGBSpan        = write_span_rgb_1BIT_pixmap;
+	    dd->WriteMonoRGBASpan   = write_span_mono_1BIT_pixmap;
+	    dd->WriteRGBAPixels     = write_pixels_1BIT_pixmap;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_1BIT_pixmap;
+	    break;
+         case PF_HPCR:
+            dd->WriteRGBASpan       = write_span_HPCR_pixmap;
+            dd->WriteRGBSpan        = write_span_rgb_HPCR_pixmap;
+            dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+            dd->WriteRGBAPixels     = write_pixels_HPCR_pixmap;
+            dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+	    if (xmesa->xm_visual->hpcr_clear_flag) {
+	       ctx->Driver.ClearColor = clear_color_HPCR_pixmap;
+	    }
+            break;
+         case PF_LOOKUP:
+            dd->WriteRGBASpan       = write_span_LOOKUP_pixmap;
+            dd->WriteRGBSpan        = write_span_rgb_LOOKUP_pixmap;
+            dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+            dd->WriteRGBAPixels     = write_pixels_LOOKUP_pixmap;
+            dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+            break;
+         case PF_GRAYSCALE:
+            dd->WriteRGBASpan       = write_span_GRAYSCALE_pixmap;
+            dd->WriteRGBSpan        = write_span_rgb_GRAYSCALE_pixmap;
+            dd->WriteMonoRGBASpan   = write_span_mono_pixmap;
+            dd->WriteRGBAPixels     = write_pixels_GRAYSCALE_pixmap;
+            dd->WriteMonoRGBAPixels = write_pixels_mono_pixmap;
+            break;
+	 default:
+	    _mesa_problem(NULL,"Bad pixel format in xmesa_update_state (1)");
+            return;
+      }
+   }
+   else if (xmesa->xm_buffer->buffer==XIMAGE) {
+      /* Writing to back XImage */
+      switch (xmesa->pixelformat) {
+	 case PF_INDEX:
+	    dd->WriteCI32Span     = write_span_index_ximage;
+	    if (depth==8)
+               dd->WriteCI8Span   = write_span_index8_ximage8;
+            else
+               dd->WriteCI8Span   = write_span_index8_ximage;
+	    dd->WriteMonoCISpan   = write_span_mono_index_ximage;
+	    dd->WriteCI32Pixels   = write_pixels_index_ximage;
+	    dd->WriteMonoCIPixels = write_pixels_mono_index_ximage;
+	    break;
+	 case PF_TRUECOLOR:
+	    /* Generic RGB */
+	    dd->WriteRGBASpan       = write_span_TRUECOLOR_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_TRUECOLOR_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_TRUECOLOR_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
+	    break;
+	 case PF_TRUEDITHER:
+	    dd->WriteRGBASpan       = write_span_TRUEDITHER_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_TRUEDITHER_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_TRUEDITHER_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_TRUEDITHER_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_ximage;
+	    break;
+	 case PF_8A8B8G8R:
+	    dd->WriteRGBASpan       = write_span_8A8B8G8R_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_8A8B8G8R_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_8A8B8G8R_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_8A8B8G8R_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_8A8B8G8R_ximage;
+	    break;
+	 case PF_8R8G8B:
+	    dd->WriteRGBASpan       = write_span_8R8G8B_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_8R8G8B_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_8R8G8B_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_8R8G8B_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_8R8G8B_ximage;
+	    break;
+	 case PF_8R8G8B24:
+	    dd->WriteRGBASpan       = write_span_8R8G8B24_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_8R8G8B24_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_8R8G8B24_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_8R8G8B24_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_8R8G8B24_ximage;
+	    break;
+	 case PF_5R6G5B:
+	    dd->WriteRGBASpan       = write_span_5R6G5B_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_5R6G5B_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_5R6G5B_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
+	    break;
+	 case PF_DITHER_5R6G5B:
+	    dd->WriteRGBASpan       = write_span_DITHER_5R6G5B_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_DITHER_5R6G5B_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_DITHER_5R6G5B_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_DITHER_5R6G5B_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_5R6G5B_ximage;
+	    break;
+	 case PF_DITHER:
+	    if (depth==8) {
+	       dd->WriteRGBASpan      = write_span_DITHER8_ximage;
+	       dd->WriteRGBSpan       = write_span_rgb_DITHER8_ximage;
+	       dd->WriteMonoRGBASpan  = write_span_mono_DITHER8_ximage;
+	       dd->WriteRGBAPixels    = write_pixels_DITHER8_ximage;
+	       dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER8_ximage;
+	    }
+	    else {
+	       dd->WriteRGBASpan       = write_span_DITHER_ximage;
+	       dd->WriteRGBSpan        = write_span_rgb_DITHER_ximage;
+	       dd->WriteMonoRGBASpan   = write_span_mono_DITHER_ximage;
+	       dd->WriteRGBAPixels     = write_pixels_DITHER_ximage;
+	       dd->WriteMonoRGBAPixels = write_pixels_mono_DITHER_ximage;
+	    }
+	    break;
+	 case PF_1BIT:
+	    dd->WriteRGBASpan       = write_span_1BIT_ximage;
+	    dd->WriteRGBSpan        = write_span_rgb_1BIT_ximage;
+	    dd->WriteMonoRGBASpan   = write_span_mono_1BIT_ximage;
+	    dd->WriteRGBAPixels     = write_pixels_1BIT_ximage;
+	    dd->WriteMonoRGBAPixels = write_pixels_mono_1BIT_ximage;
+	    break;
+         case PF_HPCR:
+            dd->WriteRGBASpan       = write_span_HPCR_ximage;
+            dd->WriteRGBSpan        = write_span_rgb_HPCR_ximage;
+            dd->WriteMonoRGBASpan   = write_span_mono_HPCR_ximage;
+            dd->WriteRGBAPixels     = write_pixels_HPCR_ximage;
+            dd->WriteMonoRGBAPixels = write_pixels_mono_HPCR_ximage;
+	    if (xmesa->xm_visual->hpcr_clear_flag) {
+               ctx->Driver.ClearColor = clear_color_HPCR_ximage;
+	    }
+            break;
+         case PF_LOOKUP:
+	    if (depth==8) {
+               dd->WriteRGBASpan       = write_span_LOOKUP8_ximage;
+               dd->WriteRGBSpan        = write_rgb_LOOKUP8_ximage;
+               dd->WriteMonoRGBASpan   = write_span_mono_LOOKUP8_ximage;
+               dd->WriteRGBAPixels     = write_pixels_LOOKUP8_ximage;
+               dd->WriteMonoRGBAPixels = write_pixels_mono_LOOKUP8_ximage;
+            }
+            else {
+               dd->WriteRGBASpan       = write_span_LOOKUP_ximage;
+               dd->WriteRGBSpan        = write_span_rgb_LOOKUP_ximage;
+               dd->WriteMonoRGBASpan   = write_span_mono_ximage;
+               dd->WriteRGBAPixels     = write_pixels_LOOKUP_ximage;
+               dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
+            }
+            break;
+         case PF_GRAYSCALE:
+	    if (depth==8) {
+	       dd->WriteRGBASpan       = write_span_GRAYSCALE8_ximage;
+	       dd->WriteRGBSpan        = write_span_rgb_GRAYSCALE8_ximage;
+	       dd->WriteMonoRGBASpan   = write_span_mono_GRAYSCALE8_ximage;
+	       dd->WriteRGBAPixels     = write_pixels_GRAYSCALE8_ximage;
+	       dd->WriteMonoRGBAPixels = write_pixels_mono_GRAYSCALE8_ximage;
+	    }
+	    else {
+	       dd->WriteRGBASpan       = write_span_GRAYSCALE_ximage;
+	       dd->WriteRGBSpan        = write_span_rgb_GRAYSCALE_ximage;
+	       dd->WriteMonoRGBASpan   = write_span_mono_ximage;
+	       dd->WriteRGBAPixels     = write_pixels_GRAYSCALE_ximage;
+	       dd->WriteMonoRGBAPixels = write_pixels_mono_ximage;
+	    }
+	    break;
+	 default:
+	    _mesa_problem(NULL,"Bad pixel format in xmesa_update_state (2)");
+            return;
+      }
+   }
+
+   /* Pixel/span reading functions: */
+   dd->ReadCI32Span = read_index_span;
+   dd->ReadRGBASpan = read_color_span;
+   dd->ReadCI32Pixels = read_index_pixels;
+   dd->ReadRGBAPixels = read_color_pixels;
+
+   dd->SetReadBuffer = xmesa_set_read_buffer;
+}
Index: xc/extras/Mesa/src/X/xm_tri.c
diff -u /dev/null xc/extras/Mesa/src/X/xm_tri.c:1.2
--- /dev/null	Thu Feb 27 12:15:52 2003
+++ xc/extras/Mesa/src/X/xm_tri.c	Mon Dec 16 11:18:32 2002
@@ -0,0 +1,1705 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * This file contains "accelerated" triangle functions.  It should be
+ * fairly easy to write new special-purpose triangle functions and hook
+ * them into this module.
+ */
+
+
+#include "glxheader.h"
+#include "depth.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mtypes.h"
+#include "xmesaP.h"
+
+/* Internal swrast includes:
+ */
+#include "swrast/s_context.h"
+#include "swrast/s_depth.h"
+#include "swrast/s_triangle.h"
+#include "swrast/s_trispan.h"
+
+
+
+/**********************************************************************/
+/***                   Triangle rendering                           ***/
+/**********************************************************************/
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
+                                         const SWvertex *v0,
+					 const SWvertex *v1,
+					 const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+
+#define RENDER_SPAN( span )					\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p;					\
+         PACK_TRUECOLOR(p, FixedToInt(span.red),		\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+         XMesaPutPixel(img, x, y, p);				\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
+					const SWvertex *v0,
+					const SWvertex *v1,
+					const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++) {				\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         pRow[i] = PACK_8B8G8R(FixedToInt(span.red),		\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++) {				\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         pRow[i] = PACK_8R8G8B(FixedToInt(span.red),		\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void smooth_8R8G8B24_z_triangle( GLcontext *ctx,
+                                        const SWvertex *v0,
+					const SWvertex *v1,
+					const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span ) 					\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++) {				\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+	 PIXEL_TYPE *ptr = pRow + i;				\
+         ptr->r = FixedToInt(span.red);				\
+         ptr->g = FixedToInt(span.green);			\
+         ptr->b = FixedToInt(span.blue);			\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void smooth_TRUEDITHER_z_triangle( GLcontext *ctx,
+					  const SWvertex *v0,
+					  const SWvertex *v1,
+					  const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p;					\
+         PACK_TRUEDITHER(p, x, y, FixedToInt(span.red),		\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+         XMesaPutPixel(img, x, y, p);				\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
+ */
+static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
+                                      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++) {				\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         pRow[i] = PACK_5R6G5B(FixedToInt(span.red),		\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void smooth_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
+                                             const SWvertex *v0,
+					     const SWvertex *v1,
+					     const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red),	\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
+ */
+static void smooth_DITHER8_z_triangle( GLcontext *ctx,
+                                       const SWvertex *v0,
+				       const SWvertex *v1,
+				       const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   XDITHER_SETUP(y);						\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
+            FixedToInt(span.green), FixedToInt(span.blue) );	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, PF_DITHER triangle.
+ */
+static void smooth_DITHER_z_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   XDITHER_SETUP(y);						\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p = XDITHER(x, FixedToInt(span.red),	\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+	 XMesaPutPixel(img, x, y, p);			       	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void smooth_LOOKUP8_z_triangle( GLcontext *ctx,
+				       const SWvertex *v0,
+				       const SWvertex *v1,
+				       const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   LOOKUP_SETUP;						\
+   for (i = 0; i < span.count; i++) {				\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         pRow[i] = LOOKUP(FixedToInt(span.red),			\
+            FixedToInt(span.green), FixedToInt(span.blue));	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void smooth_HPCR_z_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red),	\
+            FixedToInt(span.green), FixedToInt(span.blue) );	\
+         zRow[i] = z;						\
+      }								\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void flat_TRUECOLOR_z_triangle( GLcontext *ctx,
+                        	       const SWvertex *v0,
+				       const SWvertex *v1,
+				       const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define SETUP_CODE						\
+   unsigned long pixel;						\
+   PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         XMesaPutPixel(img, x, y, pixel);			\
+         zRow[i] = z;						\
+      }								\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void flat_8A8B8G8R_z_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE					\
+   unsigned long p = PACK_8B8G8R( v2->color[0],	\
+		 v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   for (i = 0; i < span.count; i++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);	\
+      if (z < zRow[i]) {				\
+	 pRow[i] = (PIXEL_TYPE) p;			\
+         zRow[i] = z;					\
+      }							\
+      span.z += span.zStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8R8G8B triangle.
+ */
+static void flat_8R8G8B_z_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE				\
+   unsigned long p = PACK_8R8G8B( v2->color[0],	\
+		 v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span )			\
+   GLuint i;					\
+   for (i = 0; i < span.count; i++) {		\
+      DEPTH_TYPE z = FixedToDepth(span.z);	\
+      if (z < zRow[i]) {			\
+	 pRow[i] = (PIXEL_TYPE) p;		\
+         zRow[i] = z;				\
+      }						\
+      span.z += span.zStep;			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void flat_8R8G8B24_z_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = v2->color;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   for (i = 0; i < span.count; i++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);	\
+      if (z < zRow[i]) {				\
+	 PIXEL_TYPE *ptr = pRow + i;			\
+         ptr->r = color[RCOMP];				\
+         ptr->g = color[GCOMP];				\
+         ptr->b = color[BCOMP];				\
+         zRow[i] = z;					\
+      }							\
+      span.z += span.zStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void flat_TRUEDITHER_z_triangle( GLcontext *ctx,
+					const SWvertex *v0,
+					const SWvertex *v1,
+					const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p;					\
+         PACK_TRUEDITHER(p, x, y, v2->color[0],			\
+            v2->color[1], v2->color[2]);			\
+         XMesaPutPixel(img, x, y, p);				\
+         zRow[i] = z;						\
+      }								\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_5R6G5B triangle.
+ */
+static void flat_5R6G5B_z_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE					\
+   unsigned long p = PACK_5R6G5B( v2->color[0],		\
+            v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   for (i = 0; i < span.count; i++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);	\
+      if (z < zRow[i]) {				\
+	 pRow[i] = (PIXEL_TYPE) p;			\
+         zRow[i] = z;					\
+      }							\
+      span.z += span.zStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void flat_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
+					   const SWvertex *v0,
+					   const SWvertex *v1,
+					   const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = v2->color;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+	 PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP],		\
+			 color[GCOMP], color[BCOMP]);		\
+         zRow[i] = z;						\
+      }								\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void flat_DITHER8_z_triangle( GLcontext *ctx,
+				     const SWvertex *v0,
+				     const SWvertex *v1,
+				     const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE	\
+   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y));		\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+	 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x);			\
+         zRow[i] = z;						\
+      }								\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, PF_DITHER triangle.
+ */
+static void flat_DITHER_z_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define SETUP_CODE	\
+   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   FLAT_DITHER_ROW_SETUP(y);					\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+         unsigned long p = FLAT_DITHER(x);			\
+	 XMesaPutPixel(img, x, y, p);				\
+         zRow[i] = z;						\
+      }								\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void flat_HPCR_z_triangle( GLcontext *ctx,
+				  const SWvertex *v0,
+				  const SWvertex *v1,
+				  const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE		\
+   GLubyte r = v2->color[0];	\
+   GLubyte g = v2->color[1];	\
+   GLubyte b = v2->color[2];
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);		\
+      if (z < zRow[i]) {					\
+	 pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b);	\
+         zRow[i] = z;						\
+      }								\
+      span.z += span.zStep;					\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void flat_LOOKUP8_z_triangle( GLcontext *ctx,
+				     const SWvertex *v0,
+				     const SWvertex *v1,
+				     const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE				\
+   LOOKUP_SETUP;				\
+   GLubyte r = v2->color[0];	\
+   GLubyte g = v2->color[1];	\
+   GLubyte b = v2->color[2];	\
+   GLubyte p = LOOKUP(r,g,b);
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   for (i = 0; i < span.count; i++) {			\
+      const DEPTH_TYPE z = FixedToDepth(span.z);	\
+      if (z < zRow[i]) {				\
+	 pRow[i] = p;					\
+         zRow[i] = z;					\
+      }							\
+      span.z += span.zStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void smooth_TRUECOLOR_triangle( GLcontext *ctx,
+				       const SWvertex *v0,
+				       const SWvertex *v1,
+				       const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_RGB 1
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      unsigned long p;						\
+      PACK_TRUECOLOR(p, FixedToInt(span.red),			\
+         FixedToInt(span.green), FixedToInt(span.blue));	\
+      XMesaPutPixel(img, x, y, p);				\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void smooth_8A8B8G8R_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++) {				\
+      pRow[i] = PACK_8B8G8R(FixedToInt(span.red),		\
+         FixedToInt(span.green), FixedToInt(span.blue) );	\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }								\
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++) {				\
+      pRow[i] = PACK_8R8G8B(FixedToInt(span.red),		\
+         FixedToInt(span.green), FixedToInt(span.blue) );	\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void smooth_8R8G8B24_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   PIXEL_TYPE *pixel = pRow;				\
+   for (i = 0; i < span.count; i++, pixel++) {		\
+      pixel->r = FixedToInt(span.red);			\
+      pixel->g = FixedToInt(span.green);		\
+      pixel->b = FixedToInt(span.blue);			\
+      span.red += span.redStep;				\
+      span.green += span.greenStep;			\
+      span.blue += span.blueStep;			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void smooth_TRUEDITHER_triangle( GLcontext *ctx,
+					const SWvertex *v0,
+					const SWvertex *v1,
+					const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define INTERP_RGB 1
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      unsigned long p;						\
+      PACK_TRUEDITHER(p, x, y, FixedToInt(span.red),		\
+         FixedToInt(span.green), FixedToInt(span.blue));	\
+      XMesaPutPixel(img, x, y, p );				\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
+ */
+static void smooth_5R6G5B_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   for (i = 0; i < span.count; i++) {				\
+      pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red),	\
+         FixedToInt(span.green), FixedToInt(span.blue));	\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void smooth_DITHER_5R6G5B_triangle( GLcontext *ctx,
+					   const SWvertex *v0,
+					   const SWvertex *v1,
+					   const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red),	\
+         FixedToInt(span.green), FixedToInt(span.blue));	\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void smooth_DITHER8_triangle( GLcontext *ctx,
+				     const SWvertex *v0,
+				     const SWvertex *v1,
+				     const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   XDITHER_SETUP(y);						\
+   for (i = 0; i < span.count; i++, x++) {			\
+      pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),	\
+         FixedToInt(span.green), FixedToInt(span.blue) );	\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
+ */
+static void smooth_DITHER_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+
+#define INTERP_RGB 1
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   XDITHER_SETUP(y);						\
+   for (i = 0; i < span.count; i++, x++) {			\
+      unsigned long p = XDITHER(x, FixedToInt(span.red),	\
+         FixedToInt(span.green), FixedToInt(span.blue) );	\
+      XMesaPutPixel(img, x, y, p);				\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void smooth_LOOKUP8_triangle( GLcontext *ctx,
+				     const SWvertex *v0,
+				     const SWvertex *v1,
+				     const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   LOOKUP_SETUP;					\
+   for (i = 0; i < span.count; i++) {			\
+      pRow[i] = LOOKUP(FixedToInt(span.red),		\
+         FixedToInt(span.green), FixedToInt(span.blue));\
+      span.red += span.redStep;				\
+      span.green += span.greenStep;			\
+      span.blue += span.blueStep;			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+
+/*
+ * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void smooth_HPCR_triangle( GLcontext *ctx,
+				  const SWvertex *v0,
+				  const SWvertex *v1,
+				  const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+
+#define INTERP_RGB 1
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red),		\
+         FixedToInt(span.green), FixedToInt(span.blue));	\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
+ */
+static void flat_TRUECOLOR_triangle( GLcontext *ctx,
+				     const SWvertex *v0,
+				     const SWvertex *v1,
+				     const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define SETUP_CODE						\
+   unsigned long pixel;						\
+   PACK_TRUECOLOR(pixel, v2->color[0], v2->color[1], v2->color[2]);
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      XMesaPutPixel(img, x, y, pixel);				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
+ */
+static void flat_8A8B8G8R_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE					\
+   unsigned long p = PACK_8B8G8R( v2->color[0],		\
+		 v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span )			\
+   GLuint i;					\
+   for (i = 0; i < span.count; i++) {		\
+      pRow[i] = (PIXEL_TYPE) p;			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
+ */
+static void flat_8R8G8B_triangle( GLcontext *ctx,
+				  const SWvertex *v0,
+				  const SWvertex *v1,
+				  const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLuint
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE				\
+   unsigned long p = PACK_8R8G8B( v2->color[0],	\
+		 v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span )			\
+   GLuint i;					\
+   for (i = 0; i < span.count; i++) {		\
+      pRow[i] = (PIXEL_TYPE) p;			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
+ */
+static void flat_8R8G8B24_triangle( GLcontext *ctx,
+				    const SWvertex *v0,
+				    const SWvertex *v1,
+				    const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = v2->color;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE bgr_t
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   PIXEL_TYPE *pixel = pRow;				\
+   for (i = 0; i < span.count; i++, pixel++) {		\
+      pixel->r = color[RCOMP];				\
+      pixel->g = color[GCOMP];				\
+      pixel->b = color[BCOMP];				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
+ */
+static void flat_TRUEDITHER_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      unsigned long p;						\
+      PACK_TRUEDITHER(p, x, y, v2->color[0],			\
+               v2->color[1], v2->color[2] );			\
+      XMesaPutPixel(img, x, y, p);				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
+ */
+static void flat_5R6G5B_triangle( GLcontext *ctx,
+				  const SWvertex *v0,
+				  const SWvertex *v1,
+				  const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE					\
+   unsigned long p = PACK_5R6G5B( v2->color[0],	\
+		 v2->color[1], v2->color[2] );
+#define RENDER_SPAN( span )			\
+   GLuint i;					\
+   for (i = 0; i < span.count; i++) {		\
+      pRow[i] = (PIXEL_TYPE) p;			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
+ */
+static void flat_DITHER_5R6G5B_triangle( GLcontext *ctx,
+					 const SWvertex *v0,
+					 const SWvertex *v1,
+					 const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   const GLubyte *color = v2->color;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLushort
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP],		\
+         color[GCOMP], color[BCOMP]);				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
+ */
+static void flat_DITHER8_triangle( GLcontext *ctx,
+				   const SWvertex *v0,
+				   const SWvertex *v1,
+				   const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE	\
+   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y));		\
+   for (i = 0; i < span.count; i++, x++) {			\
+      pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x);			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
+ */
+static void flat_DITHER_triangle( GLcontext *ctx,
+				  const SWvertex *v0,
+				  const SWvertex *v1,
+				  const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   XMesaImage *img = xmesa->xm_buffer->backimage;
+#define SETUP_CODE	\
+   FLAT_DITHER_SETUP( v2->color[0], v2->color[1], v2->color[2] );
+
+#define RENDER_SPAN( span )					\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   FLAT_DITHER_ROW_SETUP(y);					\
+   for (i = 0; i < span.count; i++, x++) {			\
+      unsigned long p = FLAT_DITHER(x);				\
+      XMesaPutPixel(img, x, y, p );				\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
+ */
+static void flat_HPCR_triangle( GLcontext *ctx,
+				const SWvertex *v0,
+				const SWvertex *v1,
+				const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE				\
+   GLubyte r = v2->color[0];	\
+   GLubyte g = v2->color[1];	\
+   GLubyte b = v2->color[2];
+#define RENDER_SPAN( span )				\
+   GLuint i;							\
+   GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y);	\
+   for (i = 0; i < span.count; i++, x++) {			\
+      pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b);	\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+/*
+ * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
+ */
+static void flat_LOOKUP8_triangle( GLcontext *ctx,
+				   const SWvertex *v0,
+				   const SWvertex *v1,
+				   const SWvertex *v2 )
+{
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
+#define PIXEL_TYPE GLubyte
+#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
+#define SETUP_CODE				\
+   LOOKUP_SETUP;				\
+   GLubyte r = v2->color[0];			\
+   GLubyte g = v2->color[1];			\
+   GLubyte b = v2->color[2];			\
+   GLubyte p = LOOKUP(r,g,b);
+#define RENDER_SPAN( span )          		\
+   GLuint i;					\
+   for (i = 0; i < span.count; i++) {		\
+      pRow[i] = (PIXEL_TYPE) p;			\
+   }
+
+#include "swrast/s_tritemp.h"
+}
+
+
+#ifdef DEBUG
+extern void _xmesa_print_triangle_func( swrast_tri_func triFunc );
+void _xmesa_print_triangle_func( swrast_tri_func triFunc )
+{
+   printf("XMesa tri func = ");
+   if (triFunc ==smooth_TRUECOLOR_z_triangle)
+      printf("smooth_TRUECOLOR_z_triangle\n");
+   else if (triFunc ==smooth_8A8B8G8R_z_triangle)
+      printf("smooth_8A8B8G8R_z_triangle\n");
+   else if (triFunc ==smooth_8R8G8B_z_triangle)
+      printf("smooth_8R8G8B_z_triangle\n");
+   else if (triFunc ==smooth_8R8G8B24_z_triangle)
+      printf("smooth_8R8G8B24_z_triangle\n");
+   else if (triFunc ==smooth_TRUEDITHER_z_triangle)
+      printf("smooth_TRUEDITHER_z_triangle\n");
+   else if (triFunc ==smooth_5R6G5B_z_triangle)
+      printf("smooth_5R6G5B_z_triangle\n");
+   else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
+      printf("smooth_DITHER_5R6G5B_z_triangle\n");
+   else if (triFunc ==smooth_HPCR_z_triangle)
+      printf("smooth_HPCR_z_triangle\n");
+   else if (triFunc ==smooth_DITHER8_z_triangle)
+      printf("smooth_DITHER8_z_triangle\n");
+   else if (triFunc ==smooth_LOOKUP8_z_triangle)
+      printf("smooth_LOOKUP8_z_triangle\n");
+   else if (triFunc ==flat_TRUECOLOR_z_triangle)
+      printf("flat_TRUECOLOR_z_triangle\n");
+   else if (triFunc ==flat_8A8B8G8R_z_triangle)
+      printf("flat_8A8B8G8R_z_triangle\n");
+   else if (triFunc ==flat_8R8G8B_z_triangle)
+      printf("flat_8R8G8B_z_triangle\n");
+   else if (triFunc ==flat_8R8G8B24_z_triangle)
+      printf("flat_8R8G8B24_z_triangle\n");
+   else if (triFunc ==flat_TRUEDITHER_z_triangle)
+      printf("flat_TRUEDITHER_z_triangle\n");
+   else if (triFunc ==flat_5R6G5B_z_triangle)
+      printf("flat_5R6G5B_z_triangle\n");
+   else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
+      printf("flat_DITHER_5R6G5B_z_triangle\n");
+   else if (triFunc ==flat_HPCR_z_triangle)
+      printf("flat_HPCR_z_triangle\n");
+   else if (triFunc ==flat_DITHER8_z_triangle)
+      printf("flat_DITHER8_z_triangle\n");
+   else if (triFunc ==flat_LOOKUP8_z_triangle)
+      printf("flat_LOOKUP8_z_triangle\n");
+   else if (triFunc ==smooth_TRUECOLOR_triangle)
+      printf("smooth_TRUECOLOR_triangle\n");
+   else if (triFunc ==smooth_8A8B8G8R_triangle)
+      printf("smooth_8A8B8G8R_triangle\n");
+   else if (triFunc ==smooth_8R8G8B_triangle)
+      printf("smooth_8R8G8B_triangle\n");
+   else if (triFunc ==smooth_8R8G8B24_triangle)
+      printf("smooth_8R8G8B24_triangle\n");
+   else if (triFunc ==smooth_TRUEDITHER_triangle)
+      printf("smooth_TRUEDITHER_triangle\n");
+   else if (triFunc ==smooth_5R6G5B_triangle)
+      printf("smooth_5R6G5B_triangle\n");
+   else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
+      printf("smooth_DITHER_5R6G5B_triangle\n");
+   else if (triFunc ==smooth_HPCR_triangle)
+      printf("smooth_HPCR_triangle\n");
+   else if (triFunc ==smooth_DITHER8_triangle)
+      printf("smooth_DITHER8_triangle\n");
+   else if (triFunc ==smooth_LOOKUP8_triangle)
+      printf("smooth_LOOKUP8_triangle\n");
+   else if (triFunc ==flat_TRUECOLOR_triangle)
+      printf("flat_TRUECOLOR_triangle\n");
+   else if (triFunc ==flat_TRUEDITHER_triangle)
+      printf("flat_TRUEDITHER_triangle\n");
+   else if (triFunc ==flat_8A8B8G8R_triangle)
+      printf("flat_8A8B8G8R_triangle\n");
+   else if (triFunc ==flat_8R8G8B_triangle)
+      printf("flat_8R8G8B_triangle\n");
+   else if (triFunc ==flat_8R8G8B24_triangle)
+      printf("flat_8R8G8B24_triangle\n");
+   else if (triFunc ==flat_5R6G5B_triangle)
+      printf("flat_5R6G5B_triangle\n");
+   else if (triFunc ==flat_DITHER_5R6G5B_triangle)
+      printf("flat_DITHER_5R6G5B_triangle\n");
+   else if (triFunc ==flat_HPCR_triangle)
+      printf("flat_HPCR_triangle\n");
+   else if (triFunc ==flat_DITHER8_triangle)
+      printf("flat_DITHER8_triangle\n");
+   else if (triFunc ==flat_LOOKUP8_triangle)
+      printf("flat_LOOKUP8_triangle\n");
+   else
+      printf("???\n");
+}
+#endif
+
+
+#ifdef DEBUG
+
+/* record the current triangle function name */
+static const char *triFuncName = NULL;
+
+#define USE(triFunc)                   \
+do {                                   \
+    triFuncName = #triFunc;            \
+    return triFunc;                    \
+} while (0)
+
+#else
+
+#define USE(triFunc)  return triFunc
+
+#endif
+
+
+static swrast_tri_func get_triangle_func( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
+   int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
+
+   (void) kernel1;
+
+#ifdef DEBUG
+   triFuncName = NULL;
+#endif
+
+   if (ctx->RenderMode != GL_RENDER ||
+       ctx->Polygon.SmoothFlag ||
+       ctx->Texture._ReallyEnabled ||
+       (swrast->_RasterMask & MULTI_DRAW_BIT) ||
+       (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK))
+      return (swrast_tri_func) NULL;
+
+   if (xmesa->xm_buffer->buffer==XIMAGE) {
+      if (   ctx->Light.ShadeModel==GL_SMOOTH
+          && swrast->_RasterMask==DEPTH_BIT
+          && ctx->Depth.Func==GL_LESS
+          && ctx->Depth.Mask==GL_TRUE
+          && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+          && ctx->Polygon.StippleFlag==GL_FALSE) {
+         switch (xmesa->pixelformat) {
+            case PF_TRUECOLOR:
+	       USE(smooth_TRUECOLOR_z_triangle);
+            case PF_8A8B8G8R:
+               USE(smooth_8A8B8G8R_z_triangle);
+            case PF_8R8G8B:
+               USE(smooth_8R8G8B_z_triangle);
+            case PF_8R8G8B24:
+               USE(smooth_8R8G8B24_z_triangle);
+            case PF_TRUEDITHER:
+               USE(smooth_TRUEDITHER_z_triangle);
+            case PF_5R6G5B:
+               USE(smooth_5R6G5B_z_triangle);
+            case PF_DITHER_5R6G5B:
+               USE(smooth_DITHER_5R6G5B_z_triangle);
+            case PF_HPCR:
+	       USE(smooth_HPCR_z_triangle);
+            case PF_DITHER:
+               if (depth == 8)
+                  USE(smooth_DITHER8_z_triangle);
+               else
+                  USE(smooth_DITHER_z_triangle);
+               break;
+            case PF_LOOKUP:
+               if (depth == 8)
+                  USE(smooth_LOOKUP8_z_triangle);
+               else
+                  return (swrast_tri_func) NULL;
+            default:
+               return (swrast_tri_func) NULL;
+         }
+      }
+      if (   ctx->Light.ShadeModel==GL_FLAT
+          && swrast->_RasterMask==DEPTH_BIT
+          && ctx->Depth.Func==GL_LESS
+          && ctx->Depth.Mask==GL_TRUE
+          && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
+          && ctx->Polygon.StippleFlag==GL_FALSE) {
+         switch (xmesa->pixelformat) {
+            case PF_TRUECOLOR:
+	       USE(flat_TRUECOLOR_z_triangle);
+            case PF_8A8B8G8R:
+               USE(flat_8A8B8G8R_z_triangle);
+            case PF_8R8G8B:
+               USE(flat_8R8G8B_z_triangle);
+            case PF_8R8G8B24:
+               USE(flat_8R8G8B24_z_triangle);
+            case PF_TRUEDITHER:
+               USE(flat_TRUEDITHER_z_triangle);
+            case PF_5R6G5B:
+               USE(flat_5R6G5B_z_triangle);
+            case PF_DITHER_5R6G5B:
+               USE(flat_DITHER_5R6G5B_z_triangle);
+            case PF_HPCR:
+	       USE(flat_HPCR_z_triangle);
+            case PF_DITHER:
+               if (depth == 8)
+                  USE(flat_DITHER8_z_triangle);
+               else
+                  USE(flat_DITHER_z_triangle);
+               break;
+            case PF_LOOKUP:
+               if (depth == 8)
+                  USE(flat_LOOKUP8_z_triangle);
+               else
+                  return (swrast_tri_func) NULL;
+            default:
+               return (swrast_tri_func) NULL;
+         }
+      }
+      if (   swrast->_RasterMask==0   /* no depth test */
+          && ctx->Light.ShadeModel==GL_SMOOTH
+          && ctx->Polygon.StippleFlag==GL_FALSE) {
+         switch (xmesa->pixelformat) {
+            case PF_TRUECOLOR:
+	       USE(smooth_TRUECOLOR_triangle);
+            case PF_8A8B8G8R:
+               USE(smooth_8A8B8G8R_triangle);
+            case PF_8R8G8B:
+               USE(smooth_8R8G8B_triangle);
+            case PF_8R8G8B24:
+               USE(smooth_8R8G8B24_triangle);
+            case PF_TRUEDITHER:
+               USE(smooth_TRUEDITHER_triangle);
+            case PF_5R6G5B:
+               USE(smooth_5R6G5B_triangle);
+            case PF_DITHER_5R6G5B:
+               USE(smooth_DITHER_5R6G5B_triangle);
+            case PF_HPCR:
+	       USE(smooth_HPCR_triangle);
+            case PF_DITHER:
+               if (depth == 8)
+                  USE(smooth_DITHER8_triangle);
+               else
+                  USE(smooth_DITHER_triangle);
+               break;
+            case PF_LOOKUP:
+               if (depth == 8)
+                  USE(smooth_LOOKUP8_triangle);
+               else
+                  return (swrast_tri_func) NULL;
+            default:
+               return (swrast_tri_func) NULL;
+         }
+      }
+
+      if (   swrast->_RasterMask==0   /* no depth test */
+          && ctx->Light.ShadeModel==GL_FLAT
+          && ctx->Polygon.StippleFlag==GL_FALSE) {
+         switch (xmesa->pixelformat) {
+            case PF_TRUECOLOR:
+	       USE(flat_TRUECOLOR_triangle);
+            case PF_TRUEDITHER:
+	       USE(flat_TRUEDITHER_triangle);
+            case PF_8A8B8G8R:
+               USE(flat_8A8B8G8R_triangle);
+            case PF_8R8G8B:
+               USE(flat_8R8G8B_triangle);
+            case PF_8R8G8B24:
+               USE(flat_8R8G8B24_triangle);
+            case PF_5R6G5B:
+               USE(flat_5R6G5B_triangle);
+            case PF_DITHER_5R6G5B:
+               USE(flat_DITHER_5R6G5B_triangle);
+            case PF_HPCR:
+	       USE(flat_HPCR_triangle);
+            case PF_DITHER:
+               if (depth == 8)
+                  USE(flat_DITHER8_triangle);
+               else
+                  USE(flat_DITHER_triangle);
+               break;
+            case PF_LOOKUP:
+               if (depth == 8)
+                  USE(flat_LOOKUP8_triangle);
+               else
+                  return (swrast_tri_func) NULL;
+            default:
+               return (swrast_tri_func) NULL;
+         }
+      }
+
+      return (swrast_tri_func) NULL;
+   }
+   else {
+      /* draw to pixmap */
+      return (swrast_tri_func) NULL;
+   }
+}
+
+
+/* Override for the swrast tri-selection function.  Try to use one
+ * of our internal tri functions, otherwise fall back to the
+ * standard swrast functions.
+ */
+void xmesa_choose_triangle( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (!(swrast->Triangle = get_triangle_func( ctx )))
+      _swrast_choose_triangle( ctx );
+}
+
Index: xc/extras/Mesa/src/X/xmesa1.c
diff -u xc/extras/Mesa/src/X/xmesa1.c:1.17 xc/extras/Mesa/src/X/xmesa1.c:removed
--- xc/extras/Mesa/src/X/xmesa1.c:1.17	Wed Nov 14 05:28:07 2001
+++ xc/extras/Mesa/src/X/xmesa1.c	Thu Feb 27 12:15:52 2003
@@ -1,2636 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/X/xmesa1.c,v 1.17 2001/11/14 10:28:07 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.4.2
- *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Mesa/X11 interface, part 1.
- *
- * This file contains the implementations of all the XMesa* functions.
- *
- *
- * NOTES:
- *
- * The window coordinate system origin (0,0) is in the lower-left corner
- * of the window.  X11's window coordinate origin is in the upper-left
- * corner of the window.  Therefore, most drawing functions in this
- * file have to flip Y coordinates.
- *
- * Define USE_XSHM in the Makefile with -DUSE_XSHM if you want to compile
- * in support for the MIT Shared Memory extension.  If enabled, when you
- * use an Ximage for the back buffer in double buffered mode, the "swap"
- * operation will be faster.  You must also link with -lXext.
- *
- * Byte swapping:  If the Mesa host and the X display use a different
- * byte order then there's some trickiness to be aware of when using
- * XImages.  The byte ordering used for the XImage is that of the X
- * display, not the Mesa host.
- * The color-to-pixel encoding for True/DirectColor must be done
- * according to the display's visual red_mask, green_mask, and blue_mask.
- * If XPutPixel is used to put a pixel into an XImage then XPutPixel will
- * do byte swapping if needed.  If one wants to directly "poke" the pixel
- * into the XImage's buffer then the pixel must be byte swapped first.  In
- * Mesa, when byte swapping is needed we use the PF_TRUECOLOR pixel format
- * and use XPutPixel everywhere except in the implementation of
- * glClear(GL_COLOR_BUFFER_BIT).  We want this function to be fast so
- * instead of using XPutPixel we "poke" our values after byte-swapping
- * the clear pixel value if needed.
- *
- */
-
-#ifdef __CYGWIN__
-#undef WIN32
-#undef __WIN32__
-#endif
-
-#include "glxheader.h"
-#include "GL/xmesa.h"
-#include "xmesaP.h"
-#include "context.h"
-#include "extensions.h"
-#include "glthread.h"
-#include "matrix.h"
-#include "mem.h"
-#include "types.h"
-#ifdef HAVE_CONFIG_H
-#include "conf.h"
-#endif
-
-
-#ifndef GLX_NONE_EXT
-#define GLX_NONE_EXT 0x8000
-#endif
-
-
-/*
- * Global X driver lock
- */
-_glthread_Mutex _xmesa_lock;
-
-
-
-/*
- * Lookup tables for HPCR pixel format:
- */
-static short hpcr_rgbTbl[3][256] = {
-{
- 16,  16,  17,  17,  18,  18,  19,  19,  20,  20,  21,  21,  22,  22,  23,  23,
- 24,  24,  25,  25,  26,  26,  27,  27,  28,  28,  29,  29,  30,  30,  31,  31,
- 32,  32,  33,  33,  34,  34,  35,  35,  36,  36,  37,  37,  38,  38,  39,  39,
- 32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
- 48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
- 64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
- 80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
- 96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
-112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
-128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
-144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
-160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
-192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
-208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
-224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
-},
-{
- 16,  16,  17,  17,  18,  18,  19,  19,  20,  20,  21,  21,  22,  22,  23,  23,
- 24,  24,  25,  25,  26,  26,  27,  27,  28,  28,  29,  29,  30,  30,  31,  31,
- 32,  32,  33,  33,  34,  34,  35,  35,  36,  36,  37,  37,  38,  38,  39,  39,
- 32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
- 48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
- 64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
- 80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
- 96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
-112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
-128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
-144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
-160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
-192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
-208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
-224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
-},
-{
- 32,  32,  33,  33,  34,  34,  35,  35,  36,  36,  37,  37,  38,  38,  39,  39,
- 40,  40,  41,  41,  42,  42,  43,  43,  44,  44,  45,  45,  46,  46,  47,  47,
- 48,  48,  49,  49,  50,  50,  51,  51,  52,  52,  53,  53,  54,  54,  55,  55,
- 56,  56,  57,  57,  58,  58,  59,  59,  60,  60,  61,  61,  62,  62,  63,  63,
- 64,  64,  65,  65,  66,  66,  67,  67,  68,  68,  69,  69,  70,  70,  71,  71,
- 72,  72,  73,  73,  74,  74,  75,  75,  76,  76,  77,  77,  78,  78,  79,  79,
- 80,  80,  81,  81,  82,  82,  83,  83,  84,  84,  85,  85,  86,  86,  87,  87,
- 80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
- 96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
-112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
-128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
-144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
-160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
-192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
-208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223
-}
-};
-
-
-
-/**********************************************************************/
-/*****                     X Utility Functions                    *****/
-/**********************************************************************/
-
-
-/*
- * X/Mesa error reporting function:
- */
-static void error( const char *msg )
-{
-   if (getenv("MESA_DEBUG"))
-      fprintf( stderr, "X/Mesa error: %s\n", msg );
-}
-
-
-/*
- * Return the host's byte order as LSBFirst or MSBFirst ala X.
- */
-#ifndef XFree86Server
-static int host_byte_order( void )
-{
-   int i = 1;
-   char *cptr = (char *) &i;
-   return (*cptr==1) ? LSBFirst : MSBFirst;
-}
-#endif
-
-
-/*
- * Error handling.
- */
-#ifndef XFree86Server
-static int mesaXErrorFlag = 0;
-
-static int mesaHandleXError( XMesaDisplay *dpy, XErrorEvent *event )
-{
-   (void) dpy;
-   (void) event;
-   mesaXErrorFlag = 1;
-   return 0;
-}
-#endif
-
-
-/*
- * Check if the X Shared Memory extension is available.
- * Return:  0 = not available
- *          1 = shared XImage support available
- *          2 = shared Pixmap support available also
- */
-#ifndef XFree86Server
-static int check_for_xshm( XMesaDisplay *display )
-{
-#ifdef USE_XSHM
-   int major, minor, ignore;
-   Bool pixmaps;
-
-   if (XQueryExtension( display, "MIT-SHM", &ignore, &ignore, &ignore )) {
-      if (XShmQueryVersion( display, &major, &minor, &pixmaps )==True) {
-	 return (pixmaps==True) ? 2 : 1;
-      }
-      else {
-	 return 0;
-      }
-   }
-   else {
-      return 0;
-   }
-#else
-   /* Can't compile XSHM support */
-   return 0;
-#endif
-}
-#endif
-
-
-/*
- * Return the width and height of the given drawable.
- */
-static void get_drawable_size( XMesaDisplay *dpy, XMesaDrawable d,
-                               unsigned int *width, unsigned int *height)
-{
-#ifdef XFree86Server
-    (void) dpy;
-    *width = d->width;
-    *height = d->height;
-#else
-   Window root;
-   int x, y;
-   unsigned int bw, depth;
-
-   _glthread_LOCK_MUTEX(_xmesa_lock);
-   XGetGeometry( dpy, d, &root, &x, &y, width, height, &bw, &depth );
-   _glthread_UNLOCK_MUTEX(_xmesa_lock);
-#endif
-}
-
-
-/*
- * Apply gamma correction to an intensity value in [0..max].  Return the
- * new intensity value.
- */
-static GLint gamma_adjust( GLfloat gamma, GLint value, GLint max )
-{
-   if (gamma == 1.0) {
-      return value;
-   }
-   else {
-      double x = (double) value / (double) max;
-      return (GLint) ((GLfloat) max * pow( x, 1.0F/gamma ) + 0.5F);
-   }
-}
-
-
-
-/*
- * Return the true number of bits per pixel for XImages.
- * For example, if we request a 24-bit deep visual we may actually need/get
- * 32bpp XImages.  This function returns the appropriate bpp.
- * Input:  dpy - the X display
- *         visinfo - desribes the visual to be used for XImages
- * Return:  true number of bits per pixel for XImages
- */
-#define GET_BITS_PER_PIXEL(xmv) bits_per_pixel(xmv)
-
-#ifdef XFree86Server
-
-static int bits_per_pixel( XMesaVisual xmv )
-{
-   XMesaVisualInfo visinfo = xmv->visinfo;
-   const int depth = visinfo->nplanes;
-   int i;
-   for (i = 0; i < screenInfo.numPixmapFormats; i++) {
-      if (screenInfo.formats[i].depth == depth)
-         return screenInfo.formats[i].bitsPerPixel;
-   }
-   return depth;  /* should never get here, but this should be safe */
-}
-
-#else
-
-static int bits_per_pixel( XMesaVisual xmv )
-{
-   XMesaDisplay *dpy = xmv->display;
-   XMesaVisualInfo visinfo = xmv->visinfo;
-   XMesaImage *img;
-   int bitsPerPixel;
-   /* Create a temporary XImage */
-   img = XCreateImage( dpy, visinfo->visual, visinfo->depth,
-		       ZPixmap, 0,           /*format, offset*/
-		       (char*) MALLOC(8),    /*data*/
-		       1, 1,                 /*width, height*/
-		       32,                   /*bitmap_pad*/
-		       0                     /*bytes_per_line*/
-                     );
-   assert(img);
-   /* grab the bits/pixel value */
-   bitsPerPixel = img->bits_per_pixel;
-   /* free the XImage */
-   FREE( img->data );
-   img->data = NULL;
-   XMesaDestroyImage( img );
-   return bitsPerPixel;
-}
-#endif
-
-
-
-/*
- * Determine if a given X window ID is valid (window exists).
- * Do this by calling XGetIconName() for the window and
- * checking if we catch an X error.
- * Input:  dpy - the display
- *         win - the window to check for existance
- * Return:  GL_TRUE - window exists
- *          GL_FALSE - window doesn't exist
- */
-#ifndef XFree86Server
-static GLboolean WindowExistsFlag;
-
-static int window_exists_err_handler( XMesaDisplay* dpy, XErrorEvent* xerr )
-{
-   (void) dpy;
-   if (xerr->error_code == BadWindow) {
-      WindowExistsFlag = GL_FALSE;
-   }
-   return 0;
-}
-
-static GLboolean window_exists( XMesaDisplay *dpy, Window win )
-{
-   char *name;
-   int (*old_handler)( XMesaDisplay*, XErrorEvent* );
-   WindowExistsFlag = GL_TRUE;
-   old_handler = XSetErrorHandler(window_exists_err_handler);
-   XGetIconName(dpy, win, &name); /* dummy request */
-   XSetErrorHandler(old_handler);
-   if (name)
-      XFree(name);
-   return WindowExistsFlag;
-}
-#endif
-
-
-
-/**********************************************************************/
-/*****                Linked list of XMesaBuffers                 *****/
-/**********************************************************************/
-
-static XMesaBuffer XMesaBufferList = NULL;
-
-
-/* Allocate a new XMesaBuffer, add to linked list */
-static XMesaBuffer alloc_xmesa_buffer(void)
-{
-   XMesaBuffer b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer);
-   if (b) {
-      b->Next = XMesaBufferList;
-      XMesaBufferList = b;
-   }
-   return b;
-}
-
-
-/*
- * Find an XMesaBuffer by matching X display and colormap but NOT matching
- * the notThis buffer.
- */
-static XMesaBuffer find_xmesa_buffer(XMesaDisplay *dpy,
-                                     XMesaColormap cmap,
-                                     XMesaBuffer notThis)
-{
-   XMesaBuffer b;
-   for (b=XMesaBufferList; b; b=b->Next) {
-      if (b->display==dpy && b->cmap==cmap && b!=notThis) {
-         return b;
-      }
-   }
-   return NULL;
-}
-
-
-/*
- * Free an XMesaBuffer, remove from linked list, perhaps free X colormap
- * entries.
- */
-static void free_xmesa_buffer(int client, XMesaBuffer buffer)
-{
-   XMesaBuffer prev = NULL, b;
-   (void) client;
-   for (b=XMesaBufferList; b; b=b->Next) {
-      if (b==buffer) {
-         /* unlink bufer from list */
-         if (prev)
-            prev->Next = buffer->Next;
-         else
-            XMesaBufferList = buffer->Next;
-         /* Check to free X colors */
-         if (buffer->num_alloced>0) {
-            /* If no other buffer uses this X colormap then free the colors. */
-            if (!find_xmesa_buffer(buffer->display, buffer->cmap, buffer)) {
-#ifdef XFree86Server
-               (void)FreeColors(buffer->cmap, client,
-				buffer->num_alloced, buffer->alloced_colors,
-				0);
-#else
-               XFreeColors(buffer->display, buffer->cmap,
-                           buffer->alloced_colors, buffer->num_alloced, 0);
-#endif
-            }
-         }
-         FREE(buffer);
-         return;
-      }
-      /* continue search */
-      prev = b;
-   }
-   /* buffer not found in XMesaBufferList */
-   gl_problem(NULL,"free_xmesa_buffer() - buffer not found\n");
-}
-
-
-/* Copy X color table stuff from one XMesaBuffer to another. */
-static void copy_colortable_info(XMesaBuffer dst, const XMesaBuffer src)
-{
-   MEMCPY(dst->color_table, src->color_table, sizeof(src->color_table));
-   MEMCPY(dst->pixel_to_r, src->pixel_to_r, sizeof(src->pixel_to_r));
-   MEMCPY(dst->pixel_to_g, src->pixel_to_g, sizeof(src->pixel_to_g));
-   MEMCPY(dst->pixel_to_b, src->pixel_to_b, sizeof(src->pixel_to_b));
-   dst->num_alloced = src->num_alloced;
-   MEMCPY(dst->alloced_colors, src->alloced_colors,
-          sizeof(src->alloced_colors));
-}
-
-
-
-/**********************************************************************/
-/*****                   Misc Private Functions                   *****/
-/**********************************************************************/
-
-
-/*
- * Return number of bits set in n.
- */
-static int bitcount( unsigned long n )
-{
-   int bits;
-   for (bits=0; n>0; n=n>>1) {
-      if (n&1) {
-         bits++;
-      }
-   }
-   return bits;
-}
-
-
-
-/*
- * Allocate a shared memory XImage back buffer for the given XMesaBuffer.
- * Return:  GL_TRUE if success, GL_FALSE if error
- */
-#ifndef XFree86Server
-static GLboolean alloc_shm_back_buffer( XMesaBuffer b )
-{
-#ifdef USE_XSHM
-   /*
-    * We have to do a _lot_ of error checking here to be sure we can
-    * really use the XSHM extension.  It seems different servers trigger
-    * errors at different points if the extension won't work.  Therefore
-    * we have to be very careful...
-    */
-   GC gc;
-   int (*old_handler)( XMesaDisplay *, XErrorEvent * );
-
-   b->backimage = XShmCreateImage( b->xm_visual->display,
-                                   b->xm_visual->visinfo->visual,
-                                   b->xm_visual->visinfo->depth,
-				   ZPixmap, NULL, &b->shminfo,
-				   b->width, b->height );
-   if (b->backimage == NULL) {
-      error("alloc_back_buffer: Shared memory error (XShmCreateImage), disabling.");
-      b->shm = 0;
-      return GL_FALSE;
-   }
-
-   b->shminfo.shmid = shmget( IPC_PRIVATE, b->backimage->bytes_per_line
-			     * b->backimage->height, IPC_CREAT|0777 );
-   if (b->shminfo.shmid < 0) {
-      if (getenv("MESA_DEBUG"))
-          perror("alloc_back_buffer");
-      XDestroyImage( b->backimage );
-      b->backimage = NULL;
-      error("alloc_back_buffer: Shared memory error (shmget), disabling.");
-      b->shm = 0;
-      return GL_FALSE;
-   }
-
-   b->shminfo.shmaddr = b->backimage->data
-                      = (char*)shmat( b->shminfo.shmid, 0, 0 );
-   if (b->shminfo.shmaddr == (char *) -1) {
-      if (getenv("MESA_DEBUG"))
-          perror("alloc_back_buffer");
-      XDestroyImage( b->backimage );
-      shmctl( b->shminfo.shmid, IPC_RMID, 0 );
-      b->backimage = NULL;
-      error("alloc_back_buffer: Shared memory error (shmat), disabling.");
-      b->shm = 0;
-      return GL_FALSE;
-   }
-
-   b->shminfo.readOnly = False;
-   mesaXErrorFlag = 0;
-   old_handler = XSetErrorHandler( mesaHandleXError );
-   /* This may trigger the X protocol error we're ready to catch: */
-   XShmAttach( b->xm_visual->display, &b->shminfo );
-   XSync( b->xm_visual->display, False );
-
-   if (mesaXErrorFlag) {
-      /* we are on a remote display, this error is normal, don't print it */
-      XFlush( b->xm_visual->display );
-      mesaXErrorFlag = 0;
-      XDestroyImage( b->backimage );
-      shmdt( b->shminfo.shmaddr );
-      shmctl( b->shminfo.shmid, IPC_RMID, 0 );
-      b->backimage = NULL;
-      b->shm = 0;
-      (void) XSetErrorHandler( old_handler );
-      return GL_FALSE;
-   }
-
-   shmctl( b->shminfo.shmid, IPC_RMID, 0 ); /* nobody else needs it */
-
-   /* Finally, try an XShmPutImage to be really sure the extension works */
-   gc = XCreateGC( b->xm_visual->display, b->frontbuffer, 0, NULL );
-   XShmPutImage( b->xm_visual->display, b->frontbuffer, gc,
-		 b->backimage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False );
-   XSync( b->xm_visual->display, False );
-   XFreeGC( b->xm_visual->display, gc );
-   (void) XSetErrorHandler( old_handler );
-   if (mesaXErrorFlag) {
-      XFlush( b->xm_visual->display );
-      mesaXErrorFlag = 0;
-      XDestroyImage( b->backimage );
-      shmdt( b->shminfo.shmaddr );
-      shmctl( b->shminfo.shmid, IPC_RMID, 0 );
-      b->backimage = NULL;
-      b->shm = 0;
-      return GL_FALSE;
-   }
-
-   if (b->backimage) {
-      int height = b->backimage->height;
-      /* Needed by PIXELADDR1 macro */
-      b->ximage_width1 = b->backimage->bytes_per_line;
-      b->ximage_origin1 = (GLubyte *) b->backimage->data
-                        + b->ximage_width1 * (height-1);
-      /* Needed by PIXELADDR2 macro */
-      b->ximage_width2 = b->backimage->bytes_per_line / 2;
-      b->ximage_origin2 = (GLushort *) b->backimage->data
-                        + b->ximage_width2 * (height-1);
-      /* Needed by PIXELADDR3 macro */
-      b->ximage_width3 = b->backimage->bytes_per_line;
-      b->ximage_origin3 = (GLubyte *) b->backimage->data
-                        + b->ximage_width3 * (height-1);
-      /* Needed by PIXELADDR4 macro */
-      b->ximage_width4 = b->backimage->width;
-      b->ximage_origin4 = (GLuint *) b->backimage->data
-                        + b->ximage_width4 * (height-1);
-   }
-
-   return GL_TRUE;
-#else
-   /* Can't compile XSHM support */
-   return GL_FALSE;
-#endif
-}
-#endif
-
-
-
-/*
- * Setup an off-screen pixmap or Ximage to use as the back buffer.
- * Input:  b - the X/Mesa buffer
- */
-void xmesa_alloc_back_buffer( XMesaBuffer b )
-{
-   (void)DitherValues;
-   if (b->db_state==BACK_XIMAGE) {
-      /* Deallocate the old backimage, if any */
-      if (b->backimage) {
-#if defined(USE_XSHM) && !defined(XFree86Server)
-	 if (b->shm) {
-	    XShmDetach( b->xm_visual->display, &b->shminfo );
-	    XDestroyImage( b->backimage );
-	    shmdt( b->shminfo.shmaddr );
-	 }
-	 else
-#endif
-	   XMesaDestroyImage( b->backimage );
-	 b->backimage = NULL;
-      }
-
-      /* Allocate new back buffer */
-#ifdef XFree86Server
-      {
-	 /* Allocate a regular XImage for the back buffer. */
-	 b->backimage = XMesaCreateImage(b->xm_visual->BitsPerPixel,
-					 b->width, b->height, NULL);
-#else
-      if (b->shm==0
-	  || alloc_shm_back_buffer(b)==GL_FALSE
-	  ) {
-	 /* Allocate a regular XImage for the back buffer. */
-	 b->backimage = XCreateImage( b->xm_visual->display,
-                                      b->xm_visual->visinfo->visual,
-                                      GET_VISUAL_DEPTH(b->xm_visual),
-				      ZPixmap, 0,   /* format, offset */
-				      NULL, b->width, b->height,
-				      8, 0 );  /* pad, bytes_per_line */
-#endif
-	 if (!b->backimage) {
-	    error("alloc_back_buffer: XCreateImage failed.");
-	 }
-         b->backimage->data = (char *) MALLOC( b->backimage->height
-                                             * b->backimage->bytes_per_line );
-         if (!b->backimage->data) {
-            error("alloc_back_buffer: MALLOC failed.");
-            XMesaDestroyImage( b->backimage );
-            b->backimage = NULL;
-         }
-      }
-      b->backpixmap = None;
-   }
-   else if (b->db_state==BACK_PIXMAP) {
-      XMesaPixmap old_pixmap = b->backpixmap;
-      /* Free the old back pixmap */
-      if (b->backpixmap) {
-	 XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
-      }
-      /* Allocate new back pixmap */
-      b->backpixmap = XMesaCreatePixmap( b->xm_visual->display, b->frontbuffer,
-					 b->width, b->height,
-					 GET_VISUAL_DEPTH(b->xm_visual) );
-      b->backimage = NULL;
-      /* update other references to backpixmap */
-      if (b->buffer==(XMesaDrawable)old_pixmap) {
-	 b->buffer = (XMesaDrawable)b->backpixmap;
-      }
-   }
-}
-
-
-
-/*
- * A replacement for XAllocColor.  This function should never
- * fail to allocate a color.  When XAllocColor fails, we return
- * the nearest matching color.  If we have to allocate many colors
- * this function isn't too efficient; the XQueryColors() could be
- * done just once.
- * Written by Michael Pichler, Brian Paul, Mark Kilgard
- * Input:  dpy - X display
- *         cmap - X colormap
- *         cmapSize - size of colormap
- * In/Out: color - the XColor struct
- * Output:  exact - 1=exact color match, 0=closest match
- *          alloced - 1=XAlloc worked, 0=XAlloc failed
- */
-static void
-noFaultXAllocColor( int client,
-                    XMesaDisplay *dpy,
-                    XMesaColormap cmap,
-                    int cmapSize,
-                    XMesaColor *color,
-                    int *exact, int *alloced )
-{
-#ifdef XFree86Server
-   Pixel *ppixIn;
-   xrgb *ctable;
-#else
-   /* we'll try to cache ctable for better remote display performance */
-   static Display *prevDisplay = NULL;
-   static XMesaColormap prevCmap = 0;
-   static int prevCmapSize = 0;
-   static XMesaColor *ctable = NULL;
-#endif
-   XMesaColor subColor;
-   int i, bestmatch;
-   double mindist;       /* 3*2^16^2 exceeds long int precision. */
-
-   (void) client;
-
-   /* First try just using XAllocColor. */
-#ifdef XFree86Server
-   if (AllocColor(cmap,
-		  &color->red, &color->green, &color->blue,
-		  &color->pixel,
-		  client) == Success) {
-#else
-   if (XAllocColor(dpy, cmap, color)) {
-#endif
-      *exact = 1;
-      *alloced = 1;
-      return;
-   }
-
-   /* Alloc failed, search for closest match */
-
-   /* Retrieve color table entries. */
-   /* XXX alloca candidate. */
-#ifdef XFree86Server
-   ppixIn = (Pixel *) MALLOC(cmapSize * sizeof(Pixel));
-   ctable = (xrgb *) MALLOC(cmapSize * sizeof(xrgb));
-   for (i = 0; i < cmapSize; i++) {
-      ppixIn[i] = i;
-   }
-   QueryColors(cmap, cmapSize, ppixIn, ctable);
-#else
-   if (prevDisplay != dpy || prevCmap != cmap
-       || prevCmapSize != cmapSize || !ctable) {
-      /* free previously cached color table */
-      if (ctable)
-         FREE(ctable);
-      /* Get the color table from X */
-      ctable = (XMesaColor *) MALLOC(cmapSize * sizeof(XMesaColor));
-      assert(ctable);
-      for (i = 0; i < cmapSize; i++) {
-         ctable[i].pixel = i;
-      }
-      XQueryColors(dpy, cmap, ctable, cmapSize);
-      prevDisplay = dpy;
-      prevCmap = cmap;
-      prevCmapSize = cmapSize;
-   }
-#endif
-
-   /* Find best match. */
-   bestmatch = -1;
-   mindist = 0.0;
-   for (i = 0; i < cmapSize; i++) {
-      double dr = 0.30 * ((double) color->red - (double) ctable[i].red);
-      double dg = 0.59 * ((double) color->green - (double) ctable[i].green);
-      double db = 0.11 * ((double) color->blue - (double) ctable[i].blue);
-      double dist = dr * dr + dg * dg + db * db;
-      if (bestmatch < 0 || dist < mindist) {
-         bestmatch = i;
-         mindist = dist;
-      }
-   }
-
-   /* Return result. */
-   subColor.red   = ctable[bestmatch].red;
-   subColor.green = ctable[bestmatch].green;
-   subColor.blue  = ctable[bestmatch].blue;
-   /* Try to allocate the closest match color.  This should only
-    * fail if the cell is read/write.  Otherwise, we're incrementing
-    * the cell's reference count.
-    */
-#ifdef XFree86Server
-   if (AllocColor(cmap,
-		  &subColor.red, &subColor.green, &subColor.blue,
-		  &subColor.pixel,
-		  client) == Success) {
-#else
-   if (XAllocColor(dpy, cmap, &subColor)) {
-#endif
-      *alloced = 1;
-   }
-   else {
-      /* do this to work around a problem reported by Frank Ortega */
-      subColor.pixel = (unsigned long) bestmatch;
-      subColor.red   = ctable[bestmatch].red;
-      subColor.green = ctable[bestmatch].green;
-      subColor.blue  = ctable[bestmatch].blue;
-      subColor.flags = DoRed | DoGreen | DoBlue;
-      *alloced = 0;
-   }
-#ifdef XFree86Server
-   FREE(ppixIn);
-   FREE(ctable);
-#else
-   /* don't free table, save it for next time */
-#endif
-
-   *color = subColor;
-   *exact = 0;
-}
-
-
-
-
-/*
- * Do setup for PF_GRAYSCALE pixel format.
- * Note that buffer may be NULL.
- */
-static GLboolean setup_grayscale( int client, XMesaVisual v,
-                                  XMesaBuffer buffer, XMesaColormap cmap )
-{
-   if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
-      return GL_FALSE;
-   }
-
-   if (buffer) {
-      XMesaBuffer prevBuffer;
-
-      if (!cmap) {
-         return GL_FALSE;
-      }
-
-      prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
-      if (prevBuffer &&
-          (buffer->xm_visual->gl_visual->RGBAflag ==
-           prevBuffer->xm_visual->gl_visual->RGBAflag)) {
-         /* Copy colormap stuff from previous XMesaBuffer which uses same
-          * X colormap.  Do this to avoid time spent in noFaultXAllocColor.
-          */
-         copy_colortable_info(buffer, prevBuffer);
-      }
-      else {
-         /* Allocate 256 shades of gray */
-         int gray;
-         int colorsfailed = 0;
-         for (gray=0;gray<256;gray++) {
-            GLint r = gamma_adjust( v->RedGamma,   gray, 255 );
-            GLint g = gamma_adjust( v->GreenGamma, gray, 255 );
-            GLint b = gamma_adjust( v->BlueGamma,  gray, 255 );
-            int exact, alloced;
-            XMesaColor xcol;
-            xcol.red   = (r << 8) | r;
-            xcol.green = (g << 8) | g;
-            xcol.blue  = (b << 8) | b;
-            noFaultXAllocColor( client, v->display,
-                                cmap, GET_COLORMAP_SIZE(v),
-                                &xcol, &exact, &alloced );
-            if (!exact) {
-               colorsfailed++;
-            }
-            if (alloced) {
-               assert(buffer->num_alloced<256);
-               buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
-               buffer->num_alloced++;
-            }
-
-            /*OLD
-            assert(gray < 576);
-            buffer->color_table[gray*3+0] = xcol.pixel;
-            buffer->color_table[gray*3+1] = xcol.pixel;
-            buffer->color_table[gray*3+2] = xcol.pixel;
-            assert(xcol.pixel < 65536);
-            buffer->pixel_to_r[xcol.pixel] = gray * 30 / 100;
-            buffer->pixel_to_g[xcol.pixel] = gray * 59 / 100;
-            buffer->pixel_to_b[xcol.pixel] = gray * 11 / 100;
-            */
-            buffer->color_table[gray] = xcol.pixel;
-            assert(xcol.pixel < 65536);
-            buffer->pixel_to_r[xcol.pixel] = gray;
-            buffer->pixel_to_g[xcol.pixel] = gray;
-            buffer->pixel_to_b[xcol.pixel] = gray;
-         }
-
-         if (colorsfailed && getenv("MESA_DEBUG")) {
-            fprintf( stderr,
-                  "Note: %d out of 256 needed colors do not match exactly.\n",
-                  colorsfailed );
-         }
-      }
-   }
-
-   v->dithered_pf = PF_GRAYSCALE;
-   v->undithered_pf = PF_GRAYSCALE;
-   return GL_TRUE;
-}
-
-
-
-/*
- * Setup RGB rendering for a window with a PseudoColor, StaticColor,
- * or 8-bit TrueColor visual visual.  We try to allocate a palette of 225
- * colors (5 red, 9 green, 5 blue) and dither to approximate a 24-bit RGB
- * color.  While this function was originally designed just for 8-bit
- * visuals, it has also proven to work from 4-bit up to 16-bit visuals.
- * Dithering code contributed by Bob Mercier.
- */
-static GLboolean setup_dithered_color( int client, XMesaVisual v,
-                                       XMesaBuffer buffer, XMesaColormap cmap )
-{
-   if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
-      return GL_FALSE;
-   }
-
-   if (buffer) {
-      XMesaBuffer prevBuffer;
-
-      if (!cmap) {
-         return GL_FALSE;
-      }
-
-      prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
-      if (prevBuffer &&
-          (buffer->xm_visual->gl_visual->RGBAflag ==
-           prevBuffer->xm_visual->gl_visual->RGBAflag)) {
-         /* Copy colormap stuff from previous, matching XMesaBuffer.
-          * Do this to avoid time spent in noFaultXAllocColor.
-          */
-         copy_colortable_info(buffer, prevBuffer);
-      }
-      else {
-         /* Allocate X colors and initialize color_table[], red_table[], etc */
-         int r, g, b, i;
-         int colorsfailed = 0;
-         for (r = 0; r < _R; r++) {
-            for (g = 0; g < _G; g++) {
-               for (b = 0; b < _B; b++) {
-                  XMesaColor xcol;
-                  int exact, alloced;
-                  xcol.red  =gamma_adjust(v->RedGamma,   r*65535/(_R-1),65535);
-                  xcol.green=gamma_adjust(v->GreenGamma, g*65535/(_G-1),65535);
-                  xcol.blue =gamma_adjust(v->BlueGamma,  b*65535/(_B-1),65535);
-                  noFaultXAllocColor( client, v->display,
-                                      cmap, GET_COLORMAP_SIZE(v),
-                                      &xcol, &exact, &alloced );
-                  if (!exact) {
-                     colorsfailed++;
-                  }
-                  if (alloced) {
-                     assert(buffer->num_alloced<256);
-                     buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
-                     buffer->num_alloced++;
-                  }
-                  i = _MIX( r, g, b );
-                  assert(i < 576);
-                  buffer->color_table[i] = xcol.pixel;
-                  assert(xcol.pixel < 65536);
-                  buffer->pixel_to_r[xcol.pixel] = r * 255 / (_R-1);
-                  buffer->pixel_to_g[xcol.pixel] = g * 255 / (_G-1);
-                  buffer->pixel_to_b[xcol.pixel] = b * 255 / (_B-1);
-               }
-            }
-         }
-
-         if (colorsfailed && getenv("MESA_DEBUG")) {
-            fprintf( stderr,
-                  "Note: %d out of %d needed colors do not match exactly.\n",
-                  colorsfailed, _R*_G*_B );
-         }
-      }
-   }
-
-   v->dithered_pf = PF_DITHER;
-   v->undithered_pf = PF_LOOKUP;
-   return GL_TRUE;
-}
-
-
-/*
- * Setup for Hewlett Packard Color Recovery 8-bit TrueColor mode.
- * HPCR simulates 24-bit color fidelity with an 8-bit frame buffer.
- * Special dithering tables have to be initialized.
- */
-static void setup_8bit_hpcr( XMesaVisual v )
-{
-   /* HP Color Recovery contributed by:  Alex De Bruyn (ad@lms.be)
-    * To work properly, the atom _HP_RGB_SMOOTH_MAP_LIST must be defined
-    * on the root window AND the colormap obtainable by XGetRGBColormaps
-    * for that atom must be set on the window.  (see also tkInitWindow)
-    * If that colormap is not set, the output will look stripy.
-    */
-
-   /* Setup color tables with gamma correction */
-   int i;
-   double g;
-
-   g = 1.0 / v->RedGamma;
-   for (i=0; i<256; i++) {
-      GLint red = (GLint) (255.0 * pow( hpcr_rgbTbl[0][i]/255.0, g ) + 0.5);
-      v->hpcr_rgbTbl[0][i] = CLAMP( red, 16, 239 );
-   }
-
-   g = 1.0 / v->GreenGamma;
-   for (i=0; i<256; i++) {
-      GLint green = (GLint) (255.0 * pow( hpcr_rgbTbl[1][i]/255.0, g ) + 0.5);
-      v->hpcr_rgbTbl[1][i] = CLAMP( green, 16, 239 );
-   }
-
-   g = 1.0 / v->BlueGamma;
-   for (i=0; i<256; i++) {
-      GLint blue = (GLint) (255.0 * pow( hpcr_rgbTbl[2][i]/255.0, g ) + 0.5);
-      v->hpcr_rgbTbl[2][i] = CLAMP( blue, 32, 223 );
-   }
-   v->undithered_pf = PF_HPCR;  /* can't really disable dithering for now */
-   v->dithered_pf = PF_HPCR;
-
-   /* which method should I use to clear */
-   /* GL_FALSE: keep the ordinary method  */
-   /* GL_TRUE : clear with dither pattern */
-   v->hpcr_clear_flag = getenv("MESA_HPCR_CLEAR") ? GL_TRUE : GL_FALSE;
-
-   if (v->hpcr_clear_flag) {
-      v->hpcr_clear_pixmap = XMesaCreatePixmap(v->display,
-                                               DefaultRootWindow(v->display),
-                                               16, 2, 8);
-#ifndef XFree86Server
-      v->hpcr_clear_ximage = XGetImage(v->display, v->hpcr_clear_pixmap,
-                                       0, 0, 16, 2, AllPlanes, ZPixmap);
-#endif
-   }
-}
-
-
-/*
- * Setup RGB rendering for a window with a True/DirectColor visual.
- */
-static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer,
-                             XMesaWindow window, XMesaColormap cmap )
-{
-   unsigned long rmask, gmask, bmask;
-   (void) buffer;
-   (void) window;
-   (void) cmap;
-
-   /* Compute red multiplier (mask) and bit shift */
-   v->rshift = 0;
-   rmask = GET_REDMASK(v);
-   while ((rmask & 1)==0) {
-      v->rshift++;
-      rmask = rmask >> 1;
-   }
-
-   /* Compute green multiplier (mask) and bit shift */
-   v->gshift = 0;
-   gmask = GET_GREENMASK(v);
-   while ((gmask & 1)==0) {
-      v->gshift++;
-      gmask = gmask >> 1;
-   }
-
-   /* Compute blue multiplier (mask) and bit shift */
-   v->bshift = 0;
-   bmask = GET_BLUEMASK(v);
-   while ((bmask & 1)==0) {
-      v->bshift++;
-      bmask = bmask >> 1;
-   }
-
-   /*
-    * Compute component-to-pixel lookup tables and dithering kernel
-    */
-   {
-      static GLubyte kernel[16] = {
-          0*16,  8*16,  2*16, 10*16,
-         12*16,  4*16, 14*16,  6*16,
-          3*16, 11*16,  1*16,  9*16,
-         15*16,  7*16, 13*16,  5*16,
-      };
-      GLint rBits = bitcount(rmask);
-      GLint gBits = bitcount(gmask);
-      GLint bBits = bitcount(bmask);
-      GLint minBits;
-      GLuint i;
-
-      /* convert pixel components in [0,_mask] to RGB values in [0,255] */
-      for (i=0; i<=rmask; i++)
-         v->PixelToR[i] = (unsigned char) ((i * 255) / rmask);
-      for (i=0; i<=gmask; i++)
-         v->PixelToG[i] = (unsigned char) ((i * 255) / gmask);
-      for (i=0; i<=bmask; i++)
-         v->PixelToB[i] = (unsigned char) ((i * 255) / bmask);
-
-      /* convert RGB values from [0,255] to pixel components */
-
-      for (i=0;i<256;i++) {
-         GLint r = gamma_adjust(v->RedGamma,   i, 255);
-         GLint g = gamma_adjust(v->GreenGamma, i, 255);
-         GLint b = gamma_adjust(v->BlueGamma,  i, 255);
-         v->RtoPixel[i] = (r >> (8-rBits)) << v->rshift;
-         v->GtoPixel[i] = (g >> (8-gBits)) << v->gshift;
-         v->BtoPixel[i] = (b >> (8-bBits)) << v->bshift;
-      }
-      /* overflow protection */
-      for (i=256;i<512;i++) {
-         v->RtoPixel[i] = v->RtoPixel[255];
-         v->GtoPixel[i] = v->GtoPixel[255];
-         v->BtoPixel[i] = v->BtoPixel[255];
-      }
-
-      /* setup dithering kernel */
-      minBits = rBits;
-      if (gBits < minBits)  minBits = gBits;
-      if (bBits < minBits)  minBits = bBits;
-      for (i=0;i<16;i++) {
-         v->Kernel[i] = kernel[i] >> minBits;
-      }
-
-      v->undithered_pf = PF_TRUECOLOR;
-      v->dithered_pf = (GET_VISUAL_DEPTH(v)<24) ? PF_TRUEDITHER : PF_TRUECOLOR;
-   }
-
-   /*
-    * Now check for TrueColor visuals which we can optimize.
-    */
-   if (   GET_REDMASK(v)  ==0x0000ff
-       && GET_GREENMASK(v)==0x00ff00
-       && GET_BLUEMASK(v) ==0xff0000
-       && CHECK_BYTE_ORDER(v)
-       && v->BitsPerPixel==32
-       && sizeof(GLuint)==4
-       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
-      /* common 32 bpp config used on SGI, Sun */
-      v->undithered_pf = v->dithered_pf = PF_8A8B8G8R;
-   }
-   else if (GET_REDMASK(v)  ==0xff0000
-       &&   GET_GREENMASK(v)==0x00ff00
-       &&   GET_BLUEMASK(v) ==0x0000ff
-       && CHECK_BYTE_ORDER(v)
-       && v->BitsPerPixel==32
-       && sizeof(GLuint)==4
-       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
-      /* common 32 bpp config used on Linux, HP, IBM */
-      v->undithered_pf = v->dithered_pf = PF_8R8G8B;
-   }
-   else if (GET_REDMASK(v)  ==0xff0000
-       &&   GET_GREENMASK(v)==0x00ff00
-       &&   GET_BLUEMASK(v) ==0x0000ff
-       && CHECK_BYTE_ORDER(v)
-       && v->BitsPerPixel==24
-       && sizeof(GLuint)==4
-       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
-      /* common packed 24 bpp config used on Linux */
-      v->undithered_pf = v->dithered_pf = PF_8R8G8B24;
-   }
-   else if (GET_REDMASK(v)  ==0xf800
-       &&   GET_GREENMASK(v)==0x07e0
-       &&   GET_BLUEMASK(v) ==0x001f
-       && CHECK_BYTE_ORDER(v)
-       && v->BitsPerPixel==16
-       && sizeof(GLushort)==2
-       && v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
-      /* 5-6-5 color weight on common PC VGA boards */
-      v->undithered_pf = PF_5R6G5B;
-      v->dithered_pf = PF_DITHER_5R6G5B;
-   }
-   else if (GET_REDMASK(v)  ==0xe0
-       &&   GET_GREENMASK(v)==0x1c
-       &&   GET_BLUEMASK(v) ==0x03
-       && CHECK_FOR_HPCR(v)) {
-      setup_8bit_hpcr( v );
-   }
-}
-
-
-
-/*
- * Setup RGB rendering for a window with a monochrome visual.
- */
-static void setup_monochrome( XMesaVisual v, XMesaBuffer b )
-{
-   (void) b;
-   v->dithered_pf = v->undithered_pf = PF_1BIT;
-   /* if black=1 then we must flip pixel values */
-   v->bitFlip = (GET_BLACK_PIXEL(v) != 0);
-}
-
-
-
-/*
- * When a context is "made current" for the first time, we can finally
- * finish initializing the context's visual and buffer information.
- * Input:  v - the XMesaVisual to initialize
- *         b - the XMesaBuffer to initialize (may be NULL)
- *         rgb_flag - TRUE = RGBA mode, FALSE = color index mode
- *         window - the window/pixmap we're rendering into
- *         cmap - the colormap associated with the window/pixmap
- * Return:  GL_TRUE=success, GL_FALSE=failure
- */
-static GLboolean initialize_visual_and_buffer( int client,
-                                               XMesaVisual v,
-                                               XMesaBuffer b,
-                                               GLboolean rgb_flag,
-                                               XMesaDrawable window,
-                                               XMesaColormap cmap
-                                             )
-{
-#ifndef XFree86Server
-   XGCValues gcvalues;
-#endif
-
-   if (b) {
-      assert(b->xm_visual == v);
-   }
-
-   /* Save true bits/pixel */
-   v->BitsPerPixel = GET_BITS_PER_PIXEL(v);
-   assert(v->BitsPerPixel > 0);
-
-
-   if (rgb_flag==GL_FALSE) {
-      /* COLOR-INDEXED WINDOW:
-       * Even if the visual is TrueColor or DirectColor we treat it as
-       * being color indexed.  This is weird but might be useful to someone.
-       */
-      v->dithered_pf = v->undithered_pf = PF_INDEX;
-      v->index_bits = GET_VISUAL_DEPTH(v);
-   }
-   else {
-      /* RGB WINDOW:
-       * We support RGB rendering into almost any kind of visual.
-       */
-      int xclass;
-      xclass = GET_VISUAL_CLASS(v);
-      if (xclass==TrueColor || xclass==DirectColor) {
-	 setup_truecolor( v, b, (XMesaWindow)window, cmap );
-      }
-      else if (xclass==StaticGray && GET_VISUAL_DEPTH(v)==1) {
-	 setup_monochrome( v, b );
-      }
-      else if (xclass==GrayScale || xclass==StaticGray) {
-         if (!setup_grayscale( client, v, b, cmap )) {
-            return GL_FALSE;
-         }
-      }
-      else if ((xclass==PseudoColor || xclass==StaticColor)
-               && GET_VISUAL_DEPTH(v)>=4 && GET_VISUAL_DEPTH(v)<=16) {
-	 if (!setup_dithered_color( client, v, b, cmap )) {
-            return GL_FALSE;
-         }
-      }
-      else {
-	 error("XMesa: RGB mode rendering not supported in given visual.");
-	 return GL_FALSE;
-      }
-      v->index_bits = 0;
-
-      if (getenv("MESA_NO_DITHER")) {
-	 v->dithered_pf = v->undithered_pf;
-      }
-   }
-
-
-   /*
-    * If MESA_INFO env var is set print out some debugging info
-    * which can help Brian figure out what's going on when a user
-    * reports bugs.
-    */
-   if (getenv("MESA_INFO")) {
-      fprintf(stderr, "X/Mesa visual = %p\n", v);
-      fprintf(stderr, "X/Mesa dithered pf = %u\n", v->dithered_pf);
-      fprintf(stderr, "X/Mesa undithered pf = %u\n", v->undithered_pf);
-      fprintf(stderr, "X/Mesa level = %d\n", v->level);
-      fprintf(stderr, "X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v));
-      fprintf(stderr, "X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
-   }
-
-   if (b && window) {
-      /* Do window-specific initializations */
-
-      /* Window dimensions */
-      unsigned int w, h;
-      get_drawable_size( v->display, window, &w, &h );
-      b->width = w;
-      b->height = h;
-
-      b->frontbuffer = window;
-
-      assert( v->gl_visual );
-
-      /* Setup for single/double buffering */
-      if (v->gl_visual->DBflag) {
-         /* Double buffered */
-#ifndef XFree86Server
-         b->shm = check_for_xshm( v->display );
-#endif
-         xmesa_alloc_back_buffer( b );
-         if (b->db_state==BACK_PIXMAP) {
-            b->buffer = (XMesaDrawable)b->backpixmap;
-         }
-         else {
-            b->buffer = XIMAGE;
-         }
-      }
-      else {
-         /* Single Buffered */
-         b->buffer = b->frontbuffer;
-      }
-
-      /* X11 graphics contexts */
-#ifdef XFree86Server
-      b->gc1 = CreateScratchGC(v->display, window->depth);
-      b->gc2 = CreateScratchGC(v->display, window->depth);
-#else
-      b->gc1 = XCreateGC( v->display, window, 0, NULL );
-      b->gc2 = XCreateGC( v->display, window, 0, NULL );
-#endif
-      XMesaSetFunction( v->display, b->gc1, GXcopy );
-      XMesaSetFunction( v->display, b->gc2, GXcopy );
-
-      /*
-       * Don't generate Graphics Expose/NoExpose events in swapbuffers().
-       * Patch contributed by Michael Pichler May 15, 1995.
-       */
-#ifdef XFree86Server
-      b->cleargc = CreateScratchGC(v->display, window->depth);
-      {
-	  CARD32 v[1];
-	  v[0] = FALSE;
-	  dixChangeGC(NullClient, b->cleargc, GCGraphicsExposures, v, NULL);
-      }
-#else
-      gcvalues.graphics_exposures = False;
-      b->cleargc = XCreateGC( v->display, window,
-                              GCGraphicsExposures, &gcvalues);
-#endif
-      XMesaSetFunction( v->display, b->cleargc, GXcopy );
-      /*
-       * Set fill style and tile pixmap once for all for HPCR stuff
-       * (instead of doing it each time in clear_color_HPCR_pixmap())
-       * Initialize whole stuff
-       * Patch contributed by Jacques Leroy March 8, 1998.
-       */
-      if (v->hpcr_clear_flag && b->buffer!=XIMAGE) {
-	int i;
-	for (i=0; i<16; i++)
-        {
-	   XMesaPutPixel(v->hpcr_clear_ximage, i, 0, 0);
-	   XMesaPutPixel(v->hpcr_clear_ximage, i, 1, 0);
-        }
-        XMesaPutImage(b->display, (XMesaDrawable)v->hpcr_clear_pixmap,
-		      b->cleargc, v->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
-	XMesaSetFillStyle( v->display, b->cleargc, FillTiled);
-	XMesaSetTile( v->display, b->cleargc, v->hpcr_clear_pixmap );
-      }
-
-      /* Initialize the row buffer XImage for use in write_color_span() */
-#ifdef XFree86Server
-      b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1,
-				     (char *)MALLOC(MAX_WIDTH*4));
-#else
-      b->rowimage = XCreateImage( v->display,
-                                  v->visinfo->visual,
-                                  v->visinfo->depth,
-                                  ZPixmap, 0,           /*format, offset*/
-                                  (char*) MALLOC(MAX_WIDTH*4),  /*data*/
-                                  MAX_WIDTH, 1,         /*width, height*/
-                                  32,                   /*bitmap_pad*/
-                                  0                     /*bytes_per_line*/ );
-#endif
-   }
-
-   return GL_TRUE;
-}
-
-
-
-/*
- * Convert an RGBA color to a pixel value.
- */
-unsigned long
-xmesa_color_to_pixel( XMesaContext xmesa, GLubyte r, GLubyte g, GLubyte b, GLubyte a,
-                      GLuint pixelFormat)
-{
-   switch (pixelFormat) {
-      case PF_INDEX:
-         return 0;
-      case PF_TRUECOLOR:
-         {
-            unsigned long p;
-            PACK_TRUECOLOR( p, r, g, b );
-            return p;
-         }
-      case PF_8A8B8G8R:
-         return PACK_8A8B8G8R( r, g, b, a );
-      case PF_8R8G8B:
-         /* fall through */
-      case PF_8R8G8B24:
-         return PACK_8R8G8B( r, g, b );
-      case PF_5R6G5B:
-         return PACK_5R6G5B( r, g, b );
-      case PF_DITHER:
-         {
-            DITHER_SETUP;
-            return DITHER( 1, 0, r, g, b );
-         }
-      case PF_1BIT:
-         /* 382 = (3*255)/2 */
-         return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
-      case PF_HPCR:
-         return DITHER_HPCR(1, 1, r, g, b);
-      case PF_LOOKUP:
-         {
-            LOOKUP_SETUP;
-            return LOOKUP( r, g, b );
-         }
-      case PF_GRAYSCALE:
-         return GRAY_RGB( r, g, b );
-      case PF_TRUEDITHER:
-         /* fall through */
-      case PF_DITHER_5R6G5B:
-         {
-            unsigned long p;
-            PACK_TRUEDITHER(p, 1, 0, r, g, b);
-            return p;
-         }
-      default:
-         gl_problem(NULL, "Bad pixel format in xmesa_color_to_pixel");
-   }
-   return 0;
-}
-
-
-/**********************************************************************/
-/*****                       Public Functions                     *****/
-/**********************************************************************/
-
-
-/*
- * Create a new X/Mesa visual.
- * Input:  display - X11 display
- *         visinfo - an XVisualInfo pointer
- *         rgb_flag - GL_TRUE = RGB mode,
- *                    GL_FALSE = color index mode
- *         alpha_flag - alpha buffer requested?
- *         db_flag - GL_TRUE = double-buffered,
- *                   GL_FALSE = single buffered
- *         stereo_flag - stereo visual?
- *         ximage_flag - GL_TRUE = use an XImage for back buffer,
- *                       GL_FALSE = use an off-screen pixmap for back buffer
- *         depth_size - requested bits/depth values, or zero
- *         stencil_size - requested bits/stencil values, or zero
- *         accum_red_size - requested bits/red accum values, or zero
- *         accum_green_size - requested bits/green accum values, or zero
- *         accum_blue_size - requested bits/blue accum values, or zero
- *         accum_alpha_size - requested bits/alpha accum values, or zero
- *         num_samples - number of samples/pixel if multisampling, or zero
- *         level - visual level, usually 0
- *         visualCaveat - ala the GLX extension, usually GLX_NONE_EXT
- * Return;  a new XMesaVisual or 0 if error.
- */
-XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
-                               XMesaVisualInfo visinfo,
-                               GLboolean rgb_flag,
-                               GLboolean alpha_flag,
-                               GLboolean db_flag,
-                               GLboolean stereo_flag,
-                               GLboolean ximage_flag,
-                               GLint depth_size,
-                               GLint stencil_size,
-                               GLint accum_red_size,
-                               GLint accum_green_size,
-                               GLint accum_blue_size,
-                               GLint accum_alpha_size,
-                               GLint num_samples,
-                               GLint level,
-                               GLint visualCaveat )
-{
-   char *gamma;
-   XMesaVisual v;
-   GLint red_bits, green_bits, blue_bits, alpha_bits;
-
-   /* For debugging only */
-   if (getenv("MESA_XSYNC")) {
-      /* This makes debugging X easier.
-       * In your debugger, set a breakpoint on _XError to stop when an
-       * X protocol error is generated.
-       */
-#ifdef XFree86Server
-      /* NOT_NEEDED */
-#else
-      XSynchronize( display, 1 );
-#endif
-   }
-
-   v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
-   if (!v) {
-      return NULL;
-   }
-
-   /*
-    * In the X server, NULL is passed in for the display.  It will have
-    * to be set before using this visual.  See XMesaSetVisualDisplay()
-    * below.
-    */
-   v->display = display;
-
-   /* Save a copy of the XVisualInfo struct because the user may XFREE()
-    * the struct but we may need some of the information contained in it
-    * at a later time.
-    */
-#ifdef XFree86Server
-   v->visinfo = visinfo;
-#else
-   v->visinfo = (XVisualInfo *) MALLOC(sizeof(*visinfo));
-   if(!v->visinfo) {
-      FREE(v);
-      return NULL;
-   }
-   MEMCPY(v->visinfo, visinfo, sizeof(*visinfo));
-
-   /* Save a copy of the pointer now so we can find this visual again
-    * if we need to search for it in find_glx_visual().
-    */
-   v->vishandle = visinfo;
-#endif
-
-#ifdef XFree86Server
-   /* Initialize the depth of the screen */
-   {
-       PixmapFormatRec *format;
-
-       for (format = screenInfo.formats;
-	    format->depth != display->rootDepth;
-	    format++)
-	   ;
-       v->screen_depth = format->bitsPerPixel;
-   }
-#endif
-
-   /* check for MESA_GAMMA environment variable */
-   gamma = getenv("MESA_GAMMA");
-   if (gamma) {
-      v->RedGamma = v->GreenGamma = v->BlueGamma = 0.0;
-      sscanf( gamma, "%f %f %f", &v->RedGamma, &v->GreenGamma, &v->BlueGamma );
-      if (v->RedGamma<=0.0)    v->RedGamma = 1.0;
-      if (v->GreenGamma<=0.0)  v->GreenGamma = v->RedGamma;
-      if (v->BlueGamma<=0.0)   v->BlueGamma = v->RedGamma;
-   }
-   else {
-      v->RedGamma = v->GreenGamma = v->BlueGamma = 1.0;
-   }
-
-   v->ximage_flag = ximage_flag;
-   v->level = level;
-   v->VisualCaveat = visualCaveat;
-
-   (void) initialize_visual_and_buffer( 0, v, NULL, rgb_flag, 0, 0 );
-
-   {
-      int xclass;
-      xclass = GET_VISUAL_CLASS(v);
-      if (xclass==TrueColor || xclass==DirectColor) {
-         red_bits   = bitcount(GET_REDMASK(v));
-         green_bits = bitcount(GET_GREENMASK(v));
-         blue_bits  = bitcount(GET_BLUEMASK(v));
-         alpha_bits = 0;
-      }
-      else {
-         /* this is an approximation */
-         int depth;
-         depth = GET_VISUAL_DEPTH(v);
-         red_bits = depth / 3;
-         depth -= red_bits;
-         green_bits = depth / 2;
-         depth -= green_bits;
-         blue_bits = depth;
-         alpha_bits = 0;
-         assert( red_bits + green_bits + blue_bits == GET_VISUAL_DEPTH(v) );
-      }
-   }
-
-   if (alpha_flag && alpha_bits == 0)
-      alpha_bits = 8;
-
-   v->gl_visual = _mesa_create_visual( rgb_flag, db_flag, stereo_flag,
-                                       red_bits, green_bits,
-                                       blue_bits, alpha_bits,
-                                       v->index_bits,
-                                       depth_size,
-                                       stencil_size,
-                                       accum_red_size, accum_green_size,
-                                       accum_blue_size, accum_alpha_size,
-                                       0 );
-   if (!v->gl_visual) {
-#ifndef XFree86Server
-      FREE(v->visinfo);
-#endif
-      FREE(v);
-      return NULL;
-   }
-
-   return v;
-}
-
-
-void XMesaSetVisualDisplay( XMesaDisplay *dpy, XMesaVisual v )
-{
-    v->display = dpy;
-}
-
-
-void XMesaDestroyVisual( XMesaVisual v )
-{
-   _mesa_destroy_visual( v->gl_visual );
-#ifndef XFree86Server
-   FREE(v->visinfo);
-#endif
-   FREE(v);
-}
-
-
-
-/*
- * Create a new XMesaContext.
- * Input:  v - XMesaVisual
- *         share_list - another XMesaContext with which to share display
- *                      lists or NULL if no sharing is wanted.
- * Return:  an XMesaContext or NULL if error.
- */
-XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
-{
-   XMesaContext c;
-   GLboolean direct = GL_TRUE; /* XXXX */
-   /* NOT_DONE: should this be GL_FALSE??? */
-   static GLboolean firstTime = GL_TRUE;
-
-   if (firstTime) {
-      _glthread_INIT_MUTEX(_xmesa_lock);
-      firstTime = GL_FALSE;
-   }
-
-   c = (XMesaContext) CALLOC_STRUCT(xmesa_context);
-   if (!c) {
-      return NULL;
-   }
-
-   c->gl_ctx = gl_create_context( v->gl_visual,
-                      share_list ? share_list->gl_ctx : (GLcontext *) NULL,
-                      (void *) c, direct );
-   if (!c->gl_ctx) {
-      FREE(c);
-      return NULL;
-   }
-
-   gl_extensions_enable(c->gl_ctx, "GL_HP_occlusion_test");
-   gl_extensions_enable(c->gl_ctx, "GL_ARB_texture_cube_map");
-   gl_extensions_enable(c->gl_ctx, "GL_EXT_texture_env_combine");
-   gl_extensions_enable(c->gl_ctx, "GL_EXT_texture_env_dot3");
-
-   if (CHECK_BYTE_ORDER(v)) {
-      c->swapbytes = GL_FALSE;
-   }
-   else {
-      c->swapbytes = GL_TRUE;
-   }
-
-   c->xm_visual = v;
-   c->xm_buffer = NULL;   /* set later by XMesaMakeCurrent */
-   c->display = v->display;
-   c->pixelformat = v->dithered_pf;      /* Dithering is enabled by default */
-
-   c->gl_ctx->Driver.UpdateState = xmesa_update_state;
-
-#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-   c->driContextPriv = driContextPriv;
-#endif
-
-   /* Run the config file */
-   gl_context_initialize( c->gl_ctx );
-
-   return c;
-}
-
-
-
-
-void XMesaDestroyContext( XMesaContext c )
-{
-#ifdef FX
-   if (c->xm_buffer && c->xm_buffer->FXctx)
-      fxMesaDestroyContext(c->xm_buffer->FXctx);
-#endif
-   if (c->gl_ctx)
-      gl_destroy_context( c->gl_ctx );
-
-   /* Disassociate old buffer with this context */
-   if (c->xm_buffer)
-       c->xm_buffer->xm_context = NULL;
-
-   /* Destroy any buffers which are using this context.  If we don't
-    * we may have dangling references.  Hmm, maybe we should just
-    * set the buffer's context pointer to NULL instead of deleting it?
-    * Let's see if we get any bug reports...
-    * This contributed by Doug Rabson <dfr@calcaphon.com>
-    */
-   {
-      XMesaBuffer b, next;
-      for (b = XMesaBufferList; b; b = next) {
-         next = b->Next;
-         if (!b->pixmap_flag) {
-#ifndef XFree86Server
-            XSync(b->display, False);
-#endif
-            if (b->xm_context == c) {
-               /* found a context created for this context */
-               XMesaDestroyBuffer( b );
-            }
-         }
-      }
-   }
-
-   FREE( c );
-}
-
-
-
-/*
- * XXX this isn't a public function!  It's a hack for the 3Dfx driver.
- * Create a new XMesaBuffer from an X window.
- * Input:  v - the XMesaVisual
- *         w - the window
- *         c - the context
- * Return:  new XMesaBuffer or NULL if error
- */
-XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v, XMesaWindow w,
-                                      XMesaContext c )
-{
-#ifndef XFree86Server
-   XWindowAttributes attr;
-#endif
-#ifdef FX
-   char *fxEnvVar;
-#endif
-   int client = 0;
-
-   XMesaBuffer b = alloc_xmesa_buffer();
-   if (!b) {
-      return NULL;
-   }
-
-   (void) c;
-
-#ifdef XFree86Server
-   client = CLIENT_ID(((XMesaDrawable)w)->id);
-#endif
-
-   assert(v);
-
-#ifdef XFree86Server
-   if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) {
-#else
-   XGetWindowAttributes( v->display, w, &attr );
-
-   if (GET_VISUAL_DEPTH(v) != attr.depth) {
-#endif
-      if (getenv("MESA_DEBUG")) {
-         fprintf(stderr, "XMesaCreateWindowBuffer: depth mismatch between visual and window!\n");
-      }
-      return NULL;
-   }
-
-   b->xm_context = NULL; /* Associate no context with this buffer */
-
-   b->xm_visual = v;
-   b->pixmap_flag = GL_FALSE;
-   b->display = v->display;
-#ifdef XFree86Server
-   b->cmap = (ColormapPtr)LookupIDByType(wColormap(w), RT_COLORMAP);
-#else
-   if (attr.colormap) {
-      b->cmap = attr.colormap;
-   }
-   else {
-      if (getenv("MESA_DEBUG")) {
-         fprintf(stderr, "Window %u has no colormap!\n", (unsigned int) w);
-      }
-      /* this is weird, a window w/out a colormap!? */
-      /* OK, let's just allocate a new one and hope for the best */
-      b->cmap = XCreateColormap(v->display, w, attr.visual, AllocNone);
-   }
-#endif
-
-   /* determine back buffer implementation */
-   if (v->gl_visual->DBflag) {
-      if (v->ximage_flag) {
-	 b->db_state = BACK_XIMAGE;
-      }
-      else {
-	 b->db_state = BACK_PIXMAP;
-      }
-   }
-   else {
-      b->db_state = 0;
-   }
-
-   b->gl_buffer = gl_create_framebuffer( v->gl_visual,
-                                         v->gl_visual->DepthBits > 0,
-                                         v->gl_visual->StencilBits > 0,
-                                         v->gl_visual->AccumRedBits > 0,
-                                         v->gl_visual->AlphaBits > 0 );
-   if (!b->gl_buffer) {
-      free_xmesa_buffer(client, b);
-      return NULL;
-   }
-
-   if (!initialize_visual_and_buffer( client, v, b, v->gl_visual->RGBAflag,
-                                      (XMesaDrawable)w, b->cmap )) {
-      gl_destroy_framebuffer( b->gl_buffer );
-      free_xmesa_buffer(client, b);
-      return NULL;
-   }
-
-#ifdef FX
-   fxEnvVar = getenv("MESA_GLX_FX");
-   if (fxEnvVar) {
-     if (fxEnvVar[0]!='d') {
-       int attribs[100];
-       int numAttribs = 0;
-       int hw;
-       if (v->gl_visual->DepthBits > 0) {
-	 attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
-	 attribs[numAttribs++] = 1;
-       }
-       if (v->gl_visual->DBflag) {
-	 attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
-       }
-       if (v->gl_visual->AccumRedBits > 0) {
-	 attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
-	 attribs[numAttribs++] = v->gl_visual->AccumRedBits;
-       }
-       if (v->gl_visual->StencilBits > 0) {
-         attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
-         attribs[numAttribs++] = v->gl_visual->StencilBits;
-       }
-       if (v->gl_visual->AlphaBits > 0) {
-         attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
-         attribs[numAttribs++] = 1;
-       }
-       if (c->gl_ctx) {
-#define FXMESA_SHARE_CONTEXT 990099  /* keep in sync with fxapi.c! */
-         attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
-         attribs[numAttribs++] = (int) c->gl_ctx;
-       }
-       attribs[numAttribs++] = FXMESA_NONE;
-
-       if ((hw = fxQueryHardware())==GR_SSTTYPE_VOODOO) {
-         b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
-         if ((v->undithered_pf!=PF_INDEX) && (b->backimage)) {
-	   b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
-	   if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
-	     b->FXwindowHack = b->FXctx ? GL_TRUE : GL_FALSE;
-	   else
-	     b->FXwindowHack = GL_FALSE;
-         }
-       }
-       else {
-         if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
-	   b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
-					  GR_REFRESH_75Hz, attribs);
-         else
-	   b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
-         b->FXisHackUsable = GL_FALSE;
-         b->FXwindowHack = GL_FALSE;
-       }
-       /*
-       fprintf(stderr,
-               "voodoo %d, wid %d height %d hack: usable %d active %d\n",
-               hw, b->width, b->height, b->FXisHackUsable, b->FXwindowHack);
-       */
-     }
-   }
-   else {
-      fprintf(stderr,"WARNING: This Mesa Library includes the Glide driver but\n");
-      fprintf(stderr,"         you have not defined the MESA_GLX_FX env. var.\n");
-      fprintf(stderr,"         (check the README.3DFX file for more information).\n\n");
-      fprintf(stderr,"         you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
-   }
-#endif
-
-#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-   b->driDrawPriv = driDrawPriv;
-#endif
-
-   return b;
-}
-
-
-XMesaBuffer XMesaCreateWindowBuffer( XMesaVisual v, XMesaWindow w )
-{
-   return XMesaCreateWindowBuffer2( v, w, NULL );
-}
-
-
-/*
- * Create a new XMesaBuffer from an X pixmap.
- * Input:  v - the XMesaVisual
- *         p - the pixmap
- *         cmap - the colormap, may be 0 if using a TrueColor or DirectColor
- *                visual for the pixmap
- * Return:  new XMesaBuffer or NULL if error
- */
-XMesaBuffer XMesaCreatePixmapBuffer( XMesaVisual v,
-				     XMesaPixmap p, XMesaColormap cmap )
-{
-   int client = 0;
-   XMesaBuffer b = alloc_xmesa_buffer();
-   if (!b) {
-      return NULL;
-   }
-
-
-#ifdef XFree86Server
-   client = CLIENT_ID(((XMesaDrawable)p)->id);
-#endif
-
-   assert(v);
-
-   b->xm_context = NULL; /* Associate no context with this buffer */
-
-   b->xm_visual = v;
-   b->pixmap_flag = GL_TRUE;
-   b->display = v->display;
-   b->cmap = cmap;
-
-   /* determine back buffer implementation */
-   if (v->gl_visual->DBflag) {
-      if (v->ximage_flag) {
-	 b->db_state = BACK_XIMAGE;
-      }
-      else {
-	 b->db_state = BACK_PIXMAP;
-      }
-   }
-   else {
-      b->db_state = 0;
-   }
-
-   b->gl_buffer = gl_create_framebuffer( v->gl_visual,
-                                         v->gl_visual->DepthBits > 0,
-                                         v->gl_visual->StencilBits > 0,
-                                         v->gl_visual->AccumRedBits +
-                                         v->gl_visual->AccumGreenBits +
-                                         v->gl_visual->AccumBlueBits > 0,
-                                         v->gl_visual->AlphaBits > 0 );
-   if (!b->gl_buffer) {
-      free_xmesa_buffer(client, b);
-      return NULL;
-   }
-
-   if (!initialize_visual_and_buffer(client, v, b, v->gl_visual->RGBAflag,
-				     (XMesaDrawable)p, cmap)) {
-      gl_destroy_framebuffer( b->gl_buffer );
-      free_xmesa_buffer(client, b);
-      return NULL;
-   }
-
-#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-   b->driDrawPriv = driDrawPriv;
-#endif
-
-   return b;
-}
-
-
-
-/*
- * Deallocate an XMesaBuffer structure and all related info.
- */
-void XMesaDestroyBuffer( XMesaBuffer b )
-{
-   int client = 0;
-
-#ifdef XFree86Server
-   if (b->frontbuffer)
-       client = CLIENT_ID(b->frontbuffer->id);
-#endif
-
-   if (b->gc1)  XMesaFreeGC( b->xm_visual->display, b->gc1 );
-   if (b->gc2)  XMesaFreeGC( b->xm_visual->display, b->gc2 );
-   if (b->cleargc)  XMesaFreeGC( b->xm_visual->display, b->cleargc );
-
-   if (b->backimage) {
-#if defined(USE_XSHM) && !defined(XFree86Server)
-       if (b->shm) {
-	   XShmDetach( b->xm_visual->display, &b->shminfo );
-	   XDestroyImage( b->backimage );
-	   shmdt( b->shminfo.shmaddr );
-       }
-       else
-#endif
-	   XMesaDestroyImage( b->backimage );
-   }
-   if (b->backpixmap) {
-      XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
-      if (b->xm_visual->hpcr_clear_flag) {
-	XMesaFreePixmap( b->xm_visual->display,
-			 b->xm_visual->hpcr_clear_pixmap );
-	XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage );
-      }
-   }
-   if (b->rowimage) {
-      FREE( b->rowimage->data );
-      b->rowimage->data = NULL;
-      XMesaDestroyImage( b->rowimage );
-   }
-
-   if (b->xm_context)
-       b->xm_context->xm_buffer = NULL;
-
-   gl_destroy_framebuffer( b->gl_buffer );
-   free_xmesa_buffer(client, b);
-}
-
-
-
-/*
- * Bind buffer b to context c and make c the current rendering context.
- */
-GLboolean XMesaMakeCurrent( XMesaContext c, XMesaBuffer b )
-{
-   return XMesaMakeCurrent2( c, b, b );
-}
-
-
-/*
- * Bind buffer b to context c and make c the current rendering context.
- */
-GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
-                             XMesaBuffer readBuffer )
-{
-   if (c) {
-      if (!drawBuffer || !readBuffer)
-         return GL_FALSE;  /* must specify buffers! */
-
-#ifdef FX
-      if (drawBuffer->FXctx) {
-         fxMesaMakeCurrent(drawBuffer->FXctx);
-
-         /* Disassociate drawBuffer's current context from drawBuffer */
-         if (drawBuffer->xm_context)
-            drawBuffer->xm_context->xm_buffer = NULL;
-
-         /* Disassociate old buffer from this context */
-         if (c->xm_buffer)
-            c->xm_buffer->xm_context = NULL;
-
-         /* Associate the context with this buffer */
-         drawBuffer->xm_context = c;
-
-         c->xm_buffer = drawBuffer;
-         c->xm_read_buffer = readBuffer;
-         c->use_read_buffer = (drawBuffer != readBuffer);
-
-         return GL_TRUE;
-      }
-#endif
-      if (c->gl_ctx == gl_get_current_context()
-          && c->xm_buffer == drawBuffer
-          && c->xm_read_buffer == readBuffer
-          && c->xm_buffer->wasCurrent) {
-         /* same context and buffer, do nothing */
-         return GL_TRUE;
-      }
-
-      /* Disassociate drawBuffer's current context from drawBuffer */
-      if (drawBuffer->xm_context)
-         drawBuffer->xm_context->xm_buffer = NULL;
- 
-      /* Disassociate old buffer with this context */
-      if (c->xm_buffer)
-	  c->xm_buffer->xm_context = NULL;
-
-      drawBuffer->xm_context = c; /* Associate the context with this buffer */
-
-      c->xm_buffer = drawBuffer;
-      c->xm_read_buffer = readBuffer;
-      c->use_read_buffer = (drawBuffer != readBuffer);
-
-      gl_make_current2(c->gl_ctx, drawBuffer->gl_buffer, readBuffer->gl_buffer);
-
-      if (c->gl_ctx->Viewport.Width == 0) {
-	 /* initialize viewport to window size */
-	 _mesa_Viewport( 0, 0, drawBuffer->width, drawBuffer->height );
-	 c->gl_ctx->Scissor.Width = drawBuffer->width;
-	 c->gl_ctx->Scissor.Height = drawBuffer->height;
-      }
-
-      if (c->xm_visual->gl_visual->RGBAflag) {
-         /*
-          * Must recompute and set these pixel values because colormap
-          * can be different for different windows.
-          */
-         c->pixel = xmesa_color_to_pixel( c, c->red, c->green,
-                                          c->blue, c->alpha, c->pixelformat );
-         XMesaSetForeground( c->display, c->xm_buffer->gc1, c->pixel );
-         c->clearpixel = xmesa_color_to_pixel( c,
-                                               c->clearcolor[0],
-                                               c->clearcolor[1],
-                                               c->clearcolor[2],
-                                               c->clearcolor[3],
-                                               c->xm_visual->undithered_pf);
-         XMesaSetForeground(c->display, c->xm_buffer->cleargc, c->clearpixel);
-      }
-
-      /* Solution to Stephane Rehel's problem with glXReleaseBuffersMESA(): */
-      c->xm_buffer->wasCurrent = GL_TRUE;
-   }
-   else {
-      /* Detach */
-      gl_make_current2( NULL, NULL, NULL );
-   }
-   return GL_TRUE;
-}
-
-
-/*
- * Unbind the context c from its buffer.
- */
-GLboolean XMesaUnbindContext( XMesaContext c )
-{
-   /* A no-op for XFree86 integration purposes */
-   return GL_TRUE;
-}
-
-
-XMesaContext XMesaGetCurrentContext( void )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (ctx) {
-      XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-      return xmesa;
-   }
-   else {
-      return 0;
-   }
-}
-
-
-XMesaBuffer XMesaGetCurrentBuffer( void )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (ctx) {
-      XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-      return xmesa->xm_buffer;
-   }
-   else {
-      return 0;
-   }
-}
-
-
-/* New in Mesa 3.1 */
-XMesaBuffer XMesaGetCurrentReadBuffer( void )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (ctx) {
-      XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-      return xmesa->xm_buffer;
-   }
-   else {
-      return 0;
-   }
-}
-
-
-GLboolean XMesaForceCurrent(XMesaContext c)
-{
-   if (c) {
-      if (c->gl_ctx != gl_get_current_context()) {
-	 gl_make_current(c->gl_ctx, c->xm_buffer->gl_buffer);
-      }
-   }
-   else {
-      gl_make_current(NULL, NULL);
-   }
-   return GL_TRUE;
-}
-
-
-GLboolean XMesaLoseCurrent(XMesaContext c)
-{
-   (void) c;
-   gl_make_current(NULL, NULL);
-   return GL_TRUE;
-}
-
-
-/*
- * Switch 3Dfx support hack between window and full-screen mode.
- */
-GLboolean XMesaSetFXmode( GLint mode )
-{
-#ifdef FX
-   const char *fx = getenv("MESA_GLX_FX");
-   if (fx && fx[0] != 'd') {
-      GET_CURRENT_CONTEXT(ctx);
-      GrHwConfiguration hw;
-      if (!FX_grSstQueryHardware(&hw)) {
-         /*fprintf(stderr, "!grSstQueryHardware\n");*/
-         return GL_FALSE;
-      }
-      if (hw.num_sst < 1) {
-         /*fprintf(stderr, "hw.num_sst < 1\n");*/
-         return GL_FALSE;
-      }
-      if (ctx) {
-         XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-         if (mode == XMESA_FX_WINDOW) {
-	    if (xmesa->xm_buffer->FXisHackUsable) {
-	       FX_grSstControl(GR_CONTROL_DEACTIVATE);
-	       xmesa->xm_buffer->FXwindowHack = GL_TRUE;
-	       return GL_TRUE;
-	    }
-	 }
-	 else if (mode == XMESA_FX_FULLSCREEN) {
-	    FX_grSstControl(GR_CONTROL_ACTIVATE);
-	    xmesa->xm_buffer->FXwindowHack = GL_FALSE;
-	    return GL_TRUE;
-	 }
-	 else {
-	    /* Error: Bad mode value */
-	 }
-      }
-   }
-   /*fprintf(stderr, "fallthrough\n");*/
-#else
-   (void) mode;
-#endif
-   return GL_FALSE;
-}
-
-
-
-#ifdef FX
-/*
- * Read image from VooDoo frame buffer into X/Mesa's back XImage.
- */
-static void FXgetImage( XMesaBuffer b )
-{
-   static unsigned short pixbuf[MAX_WIDTH];
-   int x, y;
-   XMesaWindow root;
-   unsigned int bw, depth, width, height;
-   XMesaContext xmesa = (XMesaContext) b->xm_context->gl_ctx->DriverCtx;
-
-   assert(xmesa->xm_buffer->FXctx);
-
-#ifdef XFree86Server
-   x = b->frontbuffer->x;
-   y = b->frontbuffer->y;
-   width = b->frontbuffer->width;
-   height = b->frontbuffer->height;
-   depth = b->frontbuffer->depth;
-#else
-   XGetGeometry( xmesa->xm_visual->display, b->frontbuffer,
-                 &root, &x, &y, &width, &height, &bw, &depth);
-#endif
-   if (b->width != width || b->height != height) {
-      b->width = MIN2((int)width, xmesa->xm_buffer->FXctx->width);
-      b->height = MIN2((int)height, xmesa->xm_buffer->FXctx->height);
-      if (b->width & 1)
-         b->width--;  /* prevent odd width */
-      xmesa_alloc_back_buffer( b );
-   }
-
-   grLfbWriteColorFormat(GR_COLORFORMAT_ARGB);
-   if (xmesa->xm_visual->undithered_pf==PF_5R6G5B) {
-      /* Special case: 16bpp RGB */
-      grLfbReadRegion( GR_BUFFER_FRONTBUFFER,       /* src buffer */
-                       0, xmesa->xm_buffer->FXctx->height - b->height,  /*pos*/
-                       b->width, b->height,         /* size */
-                       b->width * sizeof(GLushort), /* stride */
-                       b->backimage->data);         /* dest buffer */
-   }
-   else if (xmesa->xm_visual->dithered_pf==PF_DITHER
-	    && GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
-      /* Special case: 8bpp RGB */
-      for (y=0;y<b->height;y++) {
-         GLubyte *ptr = (GLubyte*) xmesa->xm_buffer->backimage->data
-                        + xmesa->xm_buffer->backimage->bytes_per_line * y;
-         XDITHER_SETUP(y);
-
-         /* read row from 3Dfx frame buffer */
-         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
-                          0, xmesa->xm_buffer->FXctx->height-(b->height-y),
-                          b->width, 1,
-                          0,
-                          pixbuf );
-
-         /* write to XImage back buffer */
-         for (x=0;x<b->width;x++) {
-            GLubyte r = (pixbuf[x] & 0xf800) >> 8;
-            GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
-            GLubyte b = (pixbuf[x] & 0x001f) << 3;
-            *ptr++ = XDITHER( x, r, g, b);
-         }
-      }
-   }
-   else {
-      /* General case: slow! */
-      for (y=0;y<b->height;y++) {
-         /* read row from 3Dfx frame buffer */
-         grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
-                          0, xmesa->xm_buffer->FXctx->height-(b->height-y),
-                          b->width, 1,
-                          0,
-                          pixbuf );
-
-         /* write to XImage back buffer */
-         for (x=0;x<b->width;x++) {
-            XMesaPutPixel(b->backimage,x,y,
-			  xmesa_color_to_pixel(xmesa,
-					       (pixbuf[x] & 0xf800) >> 8,
-					       (pixbuf[x] & 0x07e0) >> 3,
-					       (pixbuf[x] & 0x001f) << 3,
-					       0xff, xmesa->pixelformat));
-         }
-      }
-   }
-   grLfbWriteColorFormat(GR_COLORFORMAT_ABGR);
-}
-#endif
-
-
-/*
- * Copy the back buffer to the front buffer.  If there's no back buffer
- * this is a no-op.
- */
-void XMesaSwapBuffers( XMesaBuffer b )
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   /* If we're swapping the buffer associated with the current context
-    * we have to flush any pending rendering commands first.
-    */
-   if (b->xm_context && b->xm_context->gl_ctx == ctx)
-      _mesa_swapbuffers(ctx);
-
-   if (b->db_state) {
-#ifdef FX
-      if (b->FXctx) {
-         fxMesaSwapBuffers();
-
-         if (b->FXwindowHack)
-            FXgetImage(b);
-         else
-            return;
-      }
-#endif
-     if (b->backimage) {
-	 /* Copy Ximage from host's memory to server's window */
-#if defined(USE_XSHM) && !defined(XFree86Server)
-	 if (b->shm) {
-            /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
-	    XShmPutImage( b->xm_visual->display, b->frontbuffer,
-			  b->cleargc,
-			  b->backimage, 0, 0,
-			  0, 0, b->width, b->height, False );
-            /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
-	 }
-	 else
-#endif
-         {
-#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-	    XMesaDriSwapBuffers( b );
-#else
-            /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
-            XMesaPutImage( b->xm_visual->display, b->frontbuffer,
-			   b->cleargc,
-			   b->backimage, 0, 0,
-			   0, 0, b->width, b->height );
-            /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
-#endif
-         }
-      }
-      else {
-	 /* Copy pixmap to window on server */
-         /*_glthread_LOCK_MUTEX(_xmesa_lock);*/
-	 XMesaCopyArea( b->xm_visual->display,
-			b->backpixmap,   /* source drawable */
-			b->frontbuffer,  /* dest. drawable */
-			b->cleargc,
-			0, 0, b->width, b->height,  /* source region */
-			0, 0                 /* dest region */
-		      );
-         /*_glthread_UNLOCK_MUTEX(_xmesa_lock);*/
-      }
-   }
-#if !defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-   XSync( b->xm_visual->display, False );
-#endif
-}
-
-
-
-/*
- * Copy sub-region of back buffer to front buffer
- */
-void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   /* If we're swapping the buffer associated with the current context
-    * we have to flush any pending rendering commands first.
-    */
-   if (b->xm_context->gl_ctx == ctx)
-      _mesa_swapbuffers(ctx);
-
-   if (b->db_state) {
-      int yTop = b->height - y - height;
-#ifdef FX
-      if (b->FXctx) {
-         fxMesaSwapBuffers();
-         if (b->FXwindowHack)
-            FXgetImage(b);
-         else
-            return;
-      }
-#endif
-      if (b->backimage) {
-         /* Copy Ximage from host's memory to server's window */
-#if defined(USE_XSHM) && !defined(XFree86Server)
-         if (b->shm) {
-            /* XXX assuming width and height aren't too large! */
-            XShmPutImage( b->xm_visual->display, b->frontbuffer,
-                          b->cleargc,
-                          b->backimage, x, yTop,
-                          x, yTop, width, height, False );
-            /* wait for finished event??? */
-         }
-         else
-#endif
-         {
-            /* XXX assuming width and height aren't too large! */
-            XMesaPutImage( b->xm_visual->display, b->frontbuffer,
-			   b->cleargc,
-			   b->backimage, x, yTop,
-			   x, yTop, width, height );
-         }
-      }
-      else {
-         /* Copy pixmap to window on server */
-         XMesaCopyArea( b->xm_visual->display,
-			b->backpixmap,           /* source drawable */
-			b->frontbuffer,          /* dest. drawable */
-			b->cleargc,
-			x, yTop, width, height,  /* source region */
-			x, yTop                  /* dest region */
-                      );
-      }
-   }
-}
-
-
-/*
- * Return a pointer to the XMesa backbuffer Pixmap or XImage.  This function
- * is a way to get "under the hood" of X/Mesa so one can manipulate the
- * back buffer directly.
- * Output:  pixmap - pointer to back buffer's Pixmap, or 0
- *          ximage - pointer to back buffer's XImage, or NULL
- * Return:  GL_TRUE = context is double buffered
- *          GL_FALSE = context is single buffered
- */
-GLboolean XMesaGetBackBuffer( XMesaBuffer b,
-                              XMesaPixmap *pixmap,
-                              XMesaImage **ximage )
-{
-   if (b->db_state) {
-      if (pixmap)  *pixmap = b->backpixmap;
-      if (ximage)  *ximage = b->backimage;
-      return GL_TRUE;
-   }
-   else {
-      *pixmap = 0;
-      *ximage = NULL;
-      return GL_FALSE;
-   }
-}
-
-
-/*
- * Return the depth buffer associated with an XMesaBuffer.
- * Input:  b - the XMesa buffer handle
- * Output:  width, height - size of buffer in pixels
- *          bytesPerValue - bytes per depth value (2 or 4)
- *          buffer - pointer to depth buffer values
- * Return:  GL_TRUE or GL_FALSE to indicate success or failure.
- */
-GLboolean XMesaGetDepthBuffer( XMesaBuffer b, GLint *width, GLint *height,
-                               GLint *bytesPerValue, void **buffer )
-{
-   if ((!b->gl_buffer) || (!b->gl_buffer->DepthBuffer)) {
-      *width = 0;
-      *height = 0;
-      *bytesPerValue = 0;
-      *buffer = 0;
-      return GL_FALSE;
-   }
-   else {
-      *width = b->gl_buffer->Width;
-      *height = b->gl_buffer->Height;
-      *bytesPerValue = sizeof(GLdepth);
-      *buffer = b->gl_buffer->DepthBuffer;
-      return GL_TRUE;
-   }
-}
-
-
-void XMesaFlush( XMesaContext c )
-{
-   if (c && c->xm_visual) {
-#ifdef XFree86Server
-      /* NOT_NEEDED */
-#else
-      XSync( c->xm_visual->display, False );
-#endif
-   }
-}
-
-
-
-const char *XMesaGetString( XMesaContext c, int name )
-{
-   (void) c;
-   if (name==XMESA_VERSION) {
-      return "3.4.2";
-   }
-   else if (name==XMESA_EXTENSIONS) {
-      return "";
-   }
-   else {
-      return NULL;
-   }
-}
-
-
-
-XMesaBuffer XMesaFindBuffer( XMesaDisplay *dpy, XMesaDrawable d )
-{
-   XMesaBuffer b;
-   for (b=XMesaBufferList; b; b=b->Next) {
-      if (b->frontbuffer==d && b->display==dpy) {
-         return b;
-      }
-   }
-   return NULL;
-}
-
-
-
-/*
- * Look for XMesaBuffers whose X window has been destroyed.
- * Deallocate any such XMesaBuffers.
- */
-void XMesaGarbageCollect( void )
-{
-   XMesaBuffer b, next;
-   for (b=XMesaBufferList; b; b=next) {
-      next = b->Next;
-      if (!b->pixmap_flag) {
-#ifdef XFree86Server
-	 /* NOT_NEEDED */
-#else
-         XSync(b->display, False);
-         if (!window_exists( b->display, b->frontbuffer )) {
-            /* found a dead window, free the ancillary info */
-            XMesaDestroyBuffer( b );
-         }
-#endif
-      }
-   }
-}
-
-
-void XMesaReset( void )
-{
-    while (XMesaBufferList)
-	XMesaDestroyBuffer(XMesaBufferList);
-
-    XMesaBufferList = NULL;
-}
-
-
-unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y,
-                                GLfloat red, GLfloat green,
-                                GLfloat blue, GLfloat alpha )
-{
-   GLint r = (GLint) (red   * 255.0F);
-   GLint g = (GLint) (green * 255.0F);
-   GLint b = (GLint) (blue  * 255.0F);
-   GLint a = (GLint) (alpha * 255.0F);
-
-   switch (xmesa->pixelformat) {
-      case PF_INDEX:
-         return 0;
-      case PF_TRUECOLOR:
-         {
-            unsigned long p;
-            PACK_TRUECOLOR( p, r, g, b );
-            return p;
-         }
-      case PF_8A8B8G8R:
-         return PACK_8A8B8G8R( r, g, b, a );
-      case PF_8R8G8B:
-         return PACK_8R8G8B( r, g, b );
-      case PF_5R6G5B:
-         return PACK_5R6G5B( r, g, b );
-      case PF_DITHER:
-         {
-            DITHER_SETUP;
-            return DITHER( x, y, r, g, b );
-         }
-      case PF_1BIT:
-         /* 382 = (3*255)/2 */
-         return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
-      case PF_HPCR:
-         return DITHER_HPCR(x, y, r, g, b);
-      case PF_LOOKUP:
-         {
-            LOOKUP_SETUP;
-            return LOOKUP( r, g, b );
-         }
-      case PF_GRAYSCALE:
-         return GRAY_RGB( r, g, b );
-      case PF_DITHER_5R6G5B:
-         /* fall through */
-      case PF_TRUEDITHER:
-         {
-            unsigned long p;
-            PACK_TRUEDITHER(p, x, y, r, g, b);
-            return p;
-         }
-      default:
-         gl_problem(NULL, "Bad pixel format in XMesaDitherColor");
-   }
-   return 0;
-}
Index: xc/extras/Mesa/src/X/xmesa2.c
diff -u xc/extras/Mesa/src/X/xmesa2.c:1.12 xc/extras/Mesa/src/X/xmesa2.c:removed
--- xc/extras/Mesa/src/X/xmesa2.c:1.12	Wed Nov  7 23:00:11 2001
+++ xc/extras/Mesa/src/X/xmesa2.c	Thu Feb 27 12:15:52 2003
@@ -1,5497 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/X/xmesa2.c,v 1.12 2001/11/08 04:00:11 tsi Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Mesa/X11 interface, part 2.
- *
- * This file contains the implementations of all the device driver functions.
- */
-
-
-#include "glxheader.h"
-#include "context.h"
-#include "drawpix.h"
-#include "mem.h"
-#include "state.h"
-#include "depth.h"
-#include "macros.h"
-#include "vb.h"
-#include "types.h"
-#include "xmesaP.h"
-#include "extensions.h"
-
-
-
-static void update_span_funcs( GLcontext *ctx );
-
-
-/*
- * The following functions are used to trap XGetImage() calls which
- * generate BadMatch errors if the drawable isn't mapped.
- */
-
-#ifndef XFree86Server
-static int caught_xgetimage_error = 0;
-static int (*old_xerror_handler)( XMesaDisplay *dpy, XErrorEvent *ev );
-static unsigned long xgetimage_serial;
-
-/*
- * This is the error handler which will be called if XGetImage fails.
- */
-static int xgetimage_error_handler( XMesaDisplay *dpy, XErrorEvent *ev )
-{
-   if (ev->serial==xgetimage_serial && ev->error_code==BadMatch) {
-      /* caught the expected error */
-      caught_xgetimage_error = 0;
-   }
-   else {
-      /* call the original X error handler, if any.  otherwise ignore */
-      if (old_xerror_handler) {
-         (*old_xerror_handler)( dpy, ev );
-      }
-   }
-   return 0;
-}
-
-
-/*
- * Call this right before XGetImage to setup error trap.
- */
-static void catch_xgetimage_errors( XMesaDisplay *dpy )
-{
-   xgetimage_serial = NextRequest( dpy );
-   old_xerror_handler = XSetErrorHandler( xgetimage_error_handler );
-   caught_xgetimage_error = 0;
-}
-
-
-/*
- * Call this right after XGetImage to check if an error occured.
- */
-static int check_xgetimage_errors( void )
-{
-   /* restore old handler */
-   (void) XSetErrorHandler( old_xerror_handler );
-   /* return 0=no error, 1=error caught */
-   return caught_xgetimage_error;
-}
-#endif
-
-
-/*
- * Read a pixel from an X drawable.
- */
-static unsigned long read_pixel( XMesaDisplay *dpy,
-                                 XMesaDrawable d, int x, int y )
-{
-   unsigned long p;
-#ifndef XFree86Server
-   XMesaImage *pixel = NULL;
-   int error;
-
-   catch_xgetimage_errors( dpy );
-   pixel = XGetImage( dpy, d, x, y, 1, 1, AllPlanes, ZPixmap );
-   error = check_xgetimage_errors();
-   if (pixel && !error) {
-      p = XMesaGetPixel( pixel, 0, 0 );
-   }
-   else {
-      p = 0;
-   }
-   if (pixel) {
-      XMesaDestroyImage( pixel );
-   }
-#else
-   (*dpy->GetImage)(d, x, y, 1, 1, ZPixmap, ~0L, (pointer)&p);
-#endif
-   return p;
-}
-
-
-
-
-/*
- * Return the size (width,height of the current color buffer.
- * This function should be called by the glViewport function because
- * glViewport is often called when the window gets resized.  We need to
- * update some X/Mesa stuff when that happens.
- * Output:  width - width of buffer in pixels.
- *          height - height of buffer in pixels.
- */
-static void get_buffer_size( GLcontext *ctx, GLuint *width, GLuint *height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   unsigned int winwidth, winheight;
-#ifndef XFree86Server
-   Window root;
-   int winx, winy;
-   unsigned int bw, d;
-
-   _glthread_LOCK_MUTEX(_xmesa_lock);
-   XGetGeometry( xmesa->display, xmesa->xm_buffer->frontbuffer, &root,
-		 &winx, &winy, &winwidth, &winheight, &bw, &d );
-   _glthread_UNLOCK_MUTEX(_xmesa_lock);
-#else
-
-   winwidth = xmesa->xm_buffer->frontbuffer->width;
-   winheight = xmesa->xm_buffer->frontbuffer->height;
-#endif
-
-   *width = winwidth;
-   *height = winheight;
-
-   if (   winwidth!=xmesa->xm_buffer->width
-       || winheight!=xmesa->xm_buffer->height) {
-      xmesa->xm_buffer->width = winwidth;
-      xmesa->xm_buffer->height = winheight;
-      xmesa_alloc_back_buffer( xmesa->xm_buffer );
-   }
-
-   /* Needed by FLIP macro */
-   xmesa->xm_buffer->bottom = (int) winheight - 1;
-
-   if (xmesa->xm_buffer->backimage) {
-      /* Needed by PIXELADDR1 macro */
-      xmesa->xm_buffer->ximage_width1
-                  = xmesa->xm_buffer->backimage->bytes_per_line;
-      xmesa->xm_buffer->ximage_origin1
-                  = (GLubyte *) xmesa->xm_buffer->backimage->data
-                    + xmesa->xm_buffer->ximage_width1 * (winheight-1);
-
-      /* Needed by PIXELADDR2 macro */
-      xmesa->xm_buffer->ximage_width2
-                  = xmesa->xm_buffer->backimage->bytes_per_line / 2;
-      xmesa->xm_buffer->ximage_origin2
-                  = (GLushort *) xmesa->xm_buffer->backimage->data
-                    + xmesa->xm_buffer->ximage_width2 * (winheight-1);
-
-      /* Needed by PIXELADDR3 macro */
-      xmesa->xm_buffer->ximage_width3
-                  = xmesa->xm_buffer->backimage->bytes_per_line;
-      xmesa->xm_buffer->ximage_origin3
-                  = (GLubyte *) xmesa->xm_buffer->backimage->data
-                    + xmesa->xm_buffer->ximage_width3 * (winheight-1);
-
-      /* Needed by PIXELADDR4 macro */
-      xmesa->xm_buffer->ximage_width4 = xmesa->xm_buffer->backimage->width;
-      xmesa->xm_buffer->ximage_origin4
-                  = (GLuint *) xmesa->xm_buffer->backimage->data
-                    + xmesa->xm_buffer->ximage_width4 * (winheight-1);
-   }
-}
-
-
-static void finish( GLcontext *ctx )
-{
-#ifdef XFree86Server
-      /* NOT_NEEDED */
-#else
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (xmesa) {
-      _glthread_LOCK_MUTEX(_xmesa_lock);
-      XSync( xmesa->display, False );
-      _glthread_UNLOCK_MUTEX(_xmesa_lock);
-   }
-#endif
-}
-
-
-static void flush( GLcontext *ctx )
-{
-#ifdef XFree86Server
-      /* NOT_NEEDED */
-#else
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (xmesa) {
-      _glthread_LOCK_MUTEX(_xmesa_lock);
-      XFlush( xmesa->display );
-      _glthread_UNLOCK_MUTEX(_xmesa_lock);
-   }
-#endif
-}
-
-
-#if 0
-static GLboolean set_buffer( GLcontext *ctx, GLenum mode )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (mode == GL_FRONT_LEFT) {
-      /* read/write front buffer */
-      xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
-      ctx->NewState |= NEW_RASTER_OPS;
-      gl_update_state(ctx);
-      return GL_TRUE;
-   }
-   else if (mode==GL_BACK_LEFT && xmesa->xm_buffer->db_state) {
-      /* read/write back buffer */
-      if (xmesa->xm_buffer->backpixmap) {
-         xmesa->xm_buffer->buffer =
-	     (XMesaDrawable)xmesa->xm_buffer->backpixmap;
-      }
-      else if (xmesa->xm_buffer->backimage) {
-         xmesa->xm_buffer->buffer = None;
-      }
-      else {
-         /* just in case there wasn't enough memory for back buffer */
-         xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
-      }
-      ctx->NewState |= NEW_RASTER_OPS;
-      gl_update_state(ctx);
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-#endif
-
-
-static GLboolean set_draw_buffer( GLcontext *ctx, GLenum mode )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (mode == GL_FRONT_LEFT) {
-      /* write to front buffer */
-      xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
-      update_span_funcs(ctx);
-      return GL_TRUE;
-   }
-   else if (mode==GL_BACK_LEFT && xmesa->xm_buffer->db_state) {
-      /* write to back buffer */
-      if (xmesa->xm_buffer->backpixmap) {
-         xmesa->xm_buffer->buffer =
-	     (XMesaDrawable)xmesa->xm_buffer->backpixmap;
-      }
-      else if (xmesa->xm_buffer->backimage) {
-         xmesa->xm_buffer->buffer = None;
-      }
-      else {
-         /* just in case there wasn't enough memory for back buffer */
-         xmesa->xm_buffer->buffer = xmesa->xm_buffer->frontbuffer;
-      }
-      update_span_funcs(ctx);
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-static void set_read_buffer( GLcontext *ctx, GLframebuffer *buffer,
-                             GLenum mode )
-{
-   XMesaBuffer target;
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-
-   if (buffer == ctx->DrawBuffer) {
-      target = xmesa->xm_buffer;
-      xmesa->use_read_buffer = GL_FALSE;
-   }
-   else {
-      ASSERT(buffer == ctx->ReadBuffer);
-      target = xmesa->xm_read_buffer;
-      xmesa->use_read_buffer = GL_TRUE;
-   }
-
-   if (mode == GL_FRONT_LEFT) {
-      target->buffer = target->frontbuffer;
-      update_span_funcs(ctx);
-   }
-   else if (mode==GL_BACK_LEFT && xmesa->xm_read_buffer->db_state) {
-      if (target->backpixmap) {
-         target->buffer = (XMesaDrawable)xmesa->xm_buffer->backpixmap;
-      }
-      else if (target->backimage) {
-         target->buffer = None;
-      }
-      else {
-         /* just in case there wasn't enough memory for back buffer */
-         target->buffer = target->frontbuffer;
-      }
-      update_span_funcs(ctx);
-   }
-   else {
-      gl_problem(ctx, "invalid buffer in set_read_buffer() in xmesa2.c");
-   }
-}
-
-
-
-static void clear_index( GLcontext *ctx, GLuint index )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearpixel = (unsigned long) index;
-   XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
-                       (unsigned long) index );
-}
-
-
-static void clear_color( GLcontext *ctx,
-                         GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
-   xmesa->clearpixel = xmesa_color_to_pixel( xmesa, r, g, b, a,
-                                             xmesa->xm_visual->undithered_pf );
-   _glthread_LOCK_MUTEX(_xmesa_lock);
-   XMesaSetForeground( xmesa->display, xmesa->xm_buffer->cleargc,
-                       xmesa->clearpixel );
-   _glthread_UNLOCK_MUTEX(_xmesa_lock);
-}
-
-
-static void clear_color_HPCR_ximage( GLcontext *ctx,
-                         GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   int i;
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
-
-   if (r == 0 && g == 0 && b == 0) {
-      /* black is black */
-      MEMSET( xmesa->xm_visual->hpcr_clear_ximage_pattern, 0x0 ,
-              sizeof(xmesa->xm_visual->hpcr_clear_ximage_pattern));
-   }
-   else {
-      /* build clear pattern */
-      for (i=0; i<16; i++) {
-         xmesa->xm_visual->hpcr_clear_ximage_pattern[0][i]    =
-            DITHER_HPCR(i, 0, r, g, b);
-         xmesa->xm_visual->hpcr_clear_ximage_pattern[1][i]    =
-            DITHER_HPCR(i, 1, r, g, b);
-      }
-   }
-}
-
-
-static void clear_color_HPCR_pixmap( GLcontext *ctx,
-                             GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   int i;
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->clearcolor[0] = r;
-   xmesa->clearcolor[1] = g;
-   xmesa->clearcolor[2] = b;
-   xmesa->clearcolor[3] = a;
-
- 
-   if (0x0==r && 0x0==g && 0x0==b) {
-      /* black is black */
-      for (i=0; i<16; i++) {
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, 0);
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, 0);
-      }
-   }
-   else {
-      for (i=0; i<16; i++) {
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 0, DITHER_HPCR(i, 0, r, g, b));
-         XMesaPutPixel(xmesa->xm_visual->hpcr_clear_ximage, i, 1, DITHER_HPCR(i, 1, r, g, b));
-      }
-   }
-   /* change tile pixmap content */
-   XMesaPutImage(xmesa->display, 
-		 (XMesaDrawable)xmesa->xm_visual->hpcr_clear_pixmap, 
-		 xmesa->xm_buffer->cleargc, 
-		 xmesa->xm_visual->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
-}
-
-/* Set current color index */
-static void set_index( GLcontext *ctx, GLuint index )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   unsigned long p = (unsigned long) index;
-   xmesa->pixel = p;
-   XMesaSetForeground( xmesa->display, xmesa->xm_buffer->gc1, p );
-}
-
-
-/* Set current drawing color */
-static void set_color( GLcontext *ctx,
-                       GLubyte r, GLubyte g, GLubyte b, GLubyte a )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   xmesa->red   = r;
-   xmesa->green = g;
-   xmesa->blue  = b;
-   xmesa->alpha = a;
-   xmesa->pixel = xmesa_color_to_pixel( xmesa, r, g, b, a, xmesa->pixelformat );;
-   XMesaSetForeground( xmesa->display, xmesa->xm_buffer->gc1, xmesa->pixel );
-}
-
-
-
-/* Set index mask ala glIndexMask */
-static GLboolean index_mask( GLcontext *ctx, GLuint mask )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (xmesa->xm_buffer->buffer==XIMAGE) {
-      return GL_FALSE;
-   }
-   else {
-      unsigned long m;
-      if (mask==0xffffffff) {
-	 m = ((unsigned long)~0L);
-      }
-      else {
-         m = (unsigned long) mask;
-      }
-      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc1, m );
-      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc2, m );
-      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
-      return GL_TRUE;
-   }
-}
-
-
-/* Implements glColorMask() */
-static GLboolean color_mask( GLcontext *ctx,
-                             GLboolean rmask, GLboolean gmask,
-                             GLboolean bmask, GLboolean amask )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int xclass = GET_VISUAL_CLASS(xmesa->xm_visual);
-   (void) amask;
-
-   if (xmesa->xm_buffer->buffer!=XIMAGE
-       && (xclass==TrueColor || xclass==DirectColor)) {
-      unsigned long m;
-      if (rmask && gmask && bmask) {
-         m = ((unsigned long)~0L);
-      }
-      else {
-         m = 0;
-         if (rmask)   m |= GET_REDMASK(xmesa->xm_visual);
-         if (gmask)   m |= GET_GREENMASK(xmesa->xm_visual);
-         if (bmask)   m |= GET_BLUEMASK(xmesa->xm_visual);
-      }
-      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc1, m );
-      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->gc2, m );
-      XMesaSetPlaneMask( xmesa->display, xmesa->xm_buffer->cleargc, m );
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-/*
- * Set the pixel logic operation.  Return GL_TRUE if the device driver
- * can perform the operation, otherwise return GL_FALSE.  GL_COPY _must_
- * be operational, obviously.
- */
-static GLboolean logicop( GLcontext *ctx, GLenum op )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int func;
-   if ((xmesa->xm_buffer->buffer==XIMAGE) && op!=GL_COPY) {
-      /* X can't do logic ops in Ximages, except for GL_COPY */
-      return GL_FALSE;
-   }
-   switch (op) {
-      case GL_CLEAR:		func = GXclear;		break;
-      case GL_SET:		func = GXset;		break;
-      case GL_COPY:		func = GXcopy;		break;
-      case GL_COPY_INVERTED:	func = GXcopyInverted;	break;
-      case GL_NOOP:		func = GXnoop;		break;
-      case GL_INVERT:		func = GXinvert;	break;
-      case GL_AND:		func = GXand;		break;
-      case GL_NAND:		func = GXnand;		break;
-      case GL_OR:		func = GXor;		break;
-      case GL_NOR:		func = GXnor;		break;
-      case GL_XOR:		func = GXxor;		break;
-      case GL_EQUIV:		func = GXequiv;		break;
-      case GL_AND_REVERSE:	func = GXandReverse;	break;
-      case GL_AND_INVERTED:	func = GXandInverted;	break;
-      case GL_OR_REVERSE:	func = GXorReverse;	break;
-      case GL_OR_INVERTED:	func = GXorInverted;	break;
-      default:  return GL_FALSE;
-   }
-   _glthread_LOCK_MUTEX(_xmesa_lock);
-   XMesaSetFunction( xmesa->display, xmesa->xm_buffer->gc1, func );
-   XMesaSetFunction( xmesa->display, xmesa->xm_buffer->gc2, func );
-   _glthread_UNLOCK_MUTEX(_xmesa_lock);
-   return GL_TRUE;
-}
-
-
-/*
- * Enable/disable dithering
- */
-static void dither( GLcontext *ctx, GLboolean enable )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (enable) {
-      xmesa->pixelformat = xmesa->xm_visual->dithered_pf;
-   }
-   else {
-      xmesa->pixelformat = xmesa->xm_visual->undithered_pf;
-   }
-}
-
-
-
-/**********************************************************************/
-/*** glClear implementations                                        ***/
-/**********************************************************************/
-
-
-static void
-clear_front_pixmap( GLcontext *ctx, GLboolean all,
-                    GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (all) {
-      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer,
-                          xmesa->xm_buffer->cleargc,
-                          0, 0,
-                          xmesa->xm_buffer->width+1,
-                          xmesa->xm_buffer->height+1 );
-   }
-   else {
-      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->frontbuffer,
-                          xmesa->xm_buffer->cleargc,
-                          x, xmesa->xm_buffer->height - y - height,
-                          width, height );
-   }
-}
-
-
-static void
-clear_back_pixmap( GLcontext *ctx, GLboolean all,
-                   GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (all) {
-      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap,
-                          xmesa->xm_buffer->cleargc,
-                          0, 0,
-                          xmesa->xm_buffer->width+1,
-                          xmesa->xm_buffer->height+1 );
-   }
-   else {
-      XMesaFillRectangle( xmesa->display, xmesa->xm_buffer->backpixmap,
-                          xmesa->xm_buffer->cleargc,
-                          x, xmesa->xm_buffer->height - y - height,
-                          width, height );
-   }
-}
-
-
-static void
-clear_8bit_ximage( GLcontext *ctx, GLboolean all,
-                   GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (all) {
-      size_t n = xmesa->xm_buffer->backimage->bytes_per_line
-         * xmesa->xm_buffer->backimage->height;
-      MEMSET( xmesa->xm_buffer->backimage->data, xmesa->clearpixel, n );
-   }
-   else {
-      GLint i;
-      for (i=0;i<height;i++) {
-         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y+i );
-         MEMSET( ptr, xmesa->clearpixel, width );
-      }
-   }
-}
-
-
-static void
-clear_HPCR_ximage( GLcontext *ctx, GLboolean all,
-                   GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (all) {
-      GLint i, c16 = (xmesa->xm_buffer->backimage->bytes_per_line>>4)<<4;
-      GLubyte *ptr  = (GLubyte *)xmesa->xm_buffer->backimage->data;
-      for (i=0; i<xmesa->xm_buffer->backimage->height; i++) {
-         GLint j;
-         GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
-         if (i&1) {
-            sptr += 16;
-         }
-         for (j=0; j<c16; j+=16) {
-            ptr[0] = sptr[0];
-            ptr[1] = sptr[1];
-            ptr[2] = sptr[2];
-            ptr[3] = sptr[3];
-            ptr[4] = sptr[4];
-            ptr[5] = sptr[5];
-            ptr[6] = sptr[6];
-            ptr[7] = sptr[7];
-            ptr[8] = sptr[8];
-            ptr[9] = sptr[9];
-            ptr[10] = sptr[10];
-            ptr[11] = sptr[11];
-            ptr[12] = sptr[12];
-            ptr[13] = sptr[13];
-            ptr[14] = sptr[14];
-            ptr[15] = sptr[15];
-            ptr += 16;
-         }
-         for (; j<xmesa->xm_buffer->backimage->bytes_per_line; j++) {
-            *ptr = sptr[j&15];
-            ptr++;
-         }
-      }
-   }
-   else {
-      GLint i;
-      for (i=y; i<y+height; i++) {
-         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, i );
-         int j;
-         GLubyte *sptr = xmesa->xm_visual->hpcr_clear_ximage_pattern[0];
-         if (i&1) {
-            sptr += 16;
-         }
-         for (j=x; j<x+width; j++) {
-            *ptr = sptr[j&15];
-            ptr++;
-         }
-      }
-   }
-}
-
-
-static void
-clear_16bit_ximage( GLcontext *ctx, GLboolean all,
-                    GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint pixel = (GLuint) xmesa->clearpixel;
-   if (xmesa->swapbytes) {
-      pixel = ((pixel >> 8) & 0x00ff) | ((pixel << 8) & 0xff00);
-   }
-   if (all) {
-      register GLuint n;
-      register GLuint *ptr4 = (GLuint *) xmesa->xm_buffer->backimage->data;
-      if ((pixel & 0xff) == ((pixel >> 8) & 0xff)) {
-         /* low and high bytes are equal so use memset() */
-         n = xmesa->xm_buffer->backimage->bytes_per_line
-            * xmesa->xm_buffer->height;
-         MEMSET( ptr4, pixel & 0xff, n );
-      }
-      else {
-         pixel = pixel | (pixel<<16);
-         n = xmesa->xm_buffer->backimage->bytes_per_line 
-            * xmesa->xm_buffer->height / 4;
-         do {
-            *ptr4++ = pixel;
-               n--;
-         } while (n!=0);
-         
-         if ((xmesa->xm_buffer->backimage->bytes_per_line * 
-              xmesa->xm_buffer->height) & 0x2)
-            *(GLushort *)ptr4 = pixel & 0xffff;
-      }
-   }
-   else {
-      register int i, j;
-      for (j=0;j<height;j++) {
-         register GLushort *ptr2 = PIXELADDR2( xmesa->xm_buffer, x, y+j );
-         for (i=0;i<width;i++) {
-            *ptr2++ = pixel;
-         }
-      }
-   }
-}
-
-
-/* Optimized code provided by Nozomi Ytow <noz@xfree86.org> */
-static void
-clear_24bit_ximage( GLcontext *ctx, GLboolean all,
-                    GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte r = xmesa->clearcolor[0];
-   const GLubyte g = xmesa->clearcolor[1];
-   const GLubyte b = xmesa->clearcolor[2];
-   register GLuint clearPixel;
-   if (xmesa->swapbytes) {
-      clearPixel = (b << 16) | (g << 8) | r;
-   }
-   else {
-      clearPixel = (r << 16) | (g << 8) | b;
-   }
-
-   if (all) {
-      if (r==g && g==b) {
-         /* same value for all three components (gray) */
-         const GLint w3 = xmesa->xm_buffer->width * 3;
-         const GLint h = xmesa->xm_buffer->height;
-         GLint i;
-         for (i = 0; i < h; i++) {
-            bgr_t *ptr3 = PIXELADDR3(xmesa->xm_buffer, 0, i);
-            MEMSET(ptr3, r, w3);
-         }
-      }
-      else {
-         /* the usual case */
-         const GLint w = xmesa->xm_buffer->width;
-         const GLint h = xmesa->xm_buffer->height;
-         GLint i, j;
-         for (i = 0; i < h; i++) {
-            bgr_t *ptr3 = PIXELADDR3(xmesa->xm_buffer, 0, i);
-            for (j = 0; j < w; j++) {
-               ptr3->r = r;
-               ptr3->g = g;
-               ptr3->b = b;
-               ptr3++;
-            }
-         }
-#if 0 /* this code doesn't work for all window widths */
-         register GLuint *ptr4 = (GLuint *) ptr3;
-         register GLuint px;
-         GLuint pixel4[3];
-         register GLuint *p = pixel4;
-         pixel4[0] = clearPixel | (clearPixel << 24);
-         pixel4[1] = (clearPixel << 16) | (clearPixel >> 8);
-         pixel4[2] = (clearPixel << 8) | (clearPixel >>  16);
-         switch (3 & (int)(ptr3 - (bgr_t*) ptr4)){
-            case 0:
-               break;
-            case 1:
-               px = *ptr4 & 0x00ffffff;
-               px |= pixel4[0] & 0xff000000;
-               *ptr4++ = px;
-               px = *ptr4 & 0xffff0000;
-               px |= pixel4[2] & 0x0000ffff;
-               *ptr4 = px;
-               if (0 == --n)
-                  break;
-            case 2:
-               px = *ptr4 & 0x0000fffff;
-               px |= pixel4[1] & 0xffff0000;
-               *ptr4++ = px;
-               px = *ptr4 & 0xffffff00;
-               px |= pixel4[2] & 0x000000ff;
-               *ptr4 = px;
-               if (0 == --n)
-                  break;
-            case 3:
-               px = *ptr4 & 0x000000ff;
-               px |= pixel4[2] & 0xffffff00;
-               *ptr4++ = px;
-               --n;
-               break;
-         }
-         while (n > 3) {
-            p = pixel4;
-            *ptr4++ = *p++;
-            *ptr4++ = *p++;
-            *ptr4++ = *p++;
-            n -= 4;
-         }
-         switch (n) {
-            case 3:
-               p = pixel4;
-               *ptr4++ = *p++;
-               *ptr4++ = *p++;
-               px = *ptr4 & 0xffffff00;
-               px |= clearPixel & 0xff;
-               *ptr4 = px;
-               break;
-            case 2:
-               p = pixel4;
-               *ptr4++ = *p++;
-               px = *ptr4 & 0xffff0000;
-               px |= *p & 0xffff;
-               *ptr4 = px;
-               break;
-            case 1:
-               px = *ptr4 & 0xff000000;
-               px |= *p & 0xffffff;
-               *ptr4 = px;
-               break;
-            case 0:
-               break;
-         }
-#endif
-      }
-   }
-   else {
-      /* only clear subrect of color buffer */
-      if (r==g && g==b) {
-         /* same value for all three components (gray) */
-         GLint j;
-         for (j=0;j<height;j++) {
-            bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
-            MEMSET(ptr3, r, 3 * width);
-         }
-      }
-      else {
-         /* non-gray clear color */
-         GLint i, j;
-         for (j = 0; j < height; j++) {
-            bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
-            for (i = 0; i < width; i++) {
-               ptr3->r = r;
-               ptr3->g = g;
-               ptr3->b = b;
-               ptr3++;
-            }
-         }
-#if 0 /* this code might not always (seems ptr3 always == ptr4) */
-         GLint j;
-         GLuint pixel4[3];
-         pixel4[0] = clearPixel | (clearPixel << 24);
-         pixel4[1] = (clearPixel << 16) | (clearPixel >> 8);
-         pixel4[2] = (clearPixel << 8) | (clearPixel >>  16);
-         for (j=0;j<height;j++) {
-            bgr_t *ptr3 = PIXELADDR3( xmesa->xm_buffer, x, y+j );
-            register GLuint *ptr4 = (GLuint *)ptr3;
-            register GLuint *p, px;
-            GLuint w = width;
-            switch (3 & (int)(ptr3 - (bgr_t*) ptr4)){
-               case 0:
-                  break;
-               case 1:
-                  px = *ptr4 & 0x00ffffff;
-                  px |= pixel4[0] & 0xff000000;
-                  *ptr4++ = px;
-                  px = *ptr4 & 0xffff0000;
-                  px |= pixel4[2] & 0x0000ffff;
-                  *ptr4 = px;
-                  if (0 == --w)
-                     break;
-               case 2:
-                  px = *ptr4 & 0x0000fffff;
-                  px |= pixel4[1] & 0xffff0000;
-                  *ptr4++ = px;
-                  px = *ptr4 & 0xffffff00;
-                  px |= pixel4[2] & 0x000000ff;
-                  *ptr4 = px;
-                  if (0 == --w)
-                     break;
-               case 3:
-                  px = *ptr4 & 0x000000ff;
-                  px |= pixel4[2] & 0xffffff00;
-                  *ptr4++ = px;
-                  --w;
-                  break;
-            }
-            while (w > 3){
-               p = pixel4;
-               *ptr4++ = *p++;
-               *ptr4++ = *p++;
-               *ptr4++ = *p++;
-               w -= 4;
-            }
-            switch (w) {
-               case 3:
-                  p = pixel4;
-                  *ptr4++ = *p++;
-                  *ptr4++ = *p++;
-                  px = *ptr4 & 0xffffff00;
-                  px |= *p & 0xff;
-                  *ptr4 = px;
-                  break;
-               case 2:
-                  p = pixel4;
-                  *ptr4++ = *p++;
-                  px = *ptr4 & 0xffff0000;
-                  px |= *p & 0xffff;
-                  *ptr4 = px;
-                  break;
-               case 1:
-                  px = *ptr4 & 0xff000000;
-                  px |= pixel4[0] & 0xffffff;
-                  *ptr4 = px;
-                  break;
-               case 0:
-                  break;
-            }
-         }
-#endif
-      }
-   }
-}
-
-
-static void
-clear_32bit_ximage( GLcontext *ctx, GLboolean all,
-                    GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint pixel = (GLuint) xmesa->clearpixel;
-   if (xmesa->swapbytes) {
-      pixel = ((pixel >> 24) & 0x000000ff)
-            | ((pixel >> 8)  & 0x0000ff00)
-            | ((pixel << 8)  & 0x00ff0000)
-            | ((pixel << 24) & 0xff000000);
-   }
-   if (all) {
-      register GLint n = xmesa->xm_buffer->width * xmesa->xm_buffer->height;
-      register GLuint *ptr4 = (GLuint *) xmesa->xm_buffer->backimage->data;
-      if (pixel==0) {
-         MEMSET( ptr4, pixel, 4*n );
-      }
-      else {
-         do {
-            *ptr4++ = pixel;
-            n--;
-         } while (n!=0);
-      }
-   }
-   else {
-      register int i, j;
-      for (j=0;j<height;j++) {
-         register GLuint *ptr4 = PIXELADDR4( xmesa->xm_buffer, x, y+j );
-         for (i=0;i<width;i++) {
-            *ptr4++ = pixel;
-         }
-      }
-   }
-}
-
-
-static void
-clear_nbit_ximage( GLcontext *ctx, GLboolean all,
-                   GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   if (all) {
-      register int i, j;
-      width = xmesa->xm_buffer->width;
-      height = xmesa->xm_buffer->height;
-      for (j=0;j<height;j++) {
-         for (i=0;i<width;i++) {
-            XMesaPutPixel( img, i, j, xmesa->clearpixel );
-         }
-      }
-   }
-   else {
-      /* TODO: optimize this */
-      register int i, j;
-      y = FLIP(xmesa->xm_buffer, y);
-      for (j=0;j<height;j++) {
-         for (i=0;i<width;i++) {
-            XMesaPutPixel( img, x+i, y-j, xmesa->clearpixel );
-         }
-      }
-   }
-}
-
-
-
-static GLbitfield
-clear_buffers( GLcontext *ctx, GLbitfield mask,
-               GLboolean all, GLint x, GLint y, GLint width, GLint height )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLuint *colorMask = (GLuint *) &ctx->Color.ColorMask;
-
-   /* we can't handle color or index masking */
-   if (mask & (DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT)) {
-      if (*colorMask != 0xffffffff || ctx->Color.IndexMask != 0xffffffff)
-         return mask;
-   }
-
-   if (mask & DD_FRONT_LEFT_BIT) {
-      ASSERT(xmesa->xm_buffer->front_clear_func);
-      (*xmesa->xm_buffer->front_clear_func)( ctx, all, x, y, width, height );
-   }
-   if (mask & DD_BACK_LEFT_BIT) {
-      ASSERT(xmesa->xm_buffer->back_clear_func);
-      (*xmesa->xm_buffer->back_clear_func)( ctx, all, x, y, width, height );
-   }
-   return mask & (~(DD_FRONT_LEFT_BIT | DD_BACK_LEFT_BIT));
-}
-
-
-
-/*
- * The Mesa library needs to be able to draw pixels in a number of ways:
- *   1. RGB vs Color Index
- *   2. as horizontal spans (polygons, images) vs random locations (points,
- *      lines)
- *   3. different color per-pixel or same color for all pixels
- *
- * Furthermore, the X driver needs to support rendering to 3 possible
- * "buffers", usually one, but sometimes two at a time:
- *   1. The front buffer as an X window
- *   2. The back buffer as a Pixmap
- *   3. The back buffer as an XImage
- *
- * Finally, if the back buffer is an XImage, we can avoid using XPutPixel and
- * optimize common cases such as 24-bit and 8-bit modes.
- *
- * By multiplication, there's at least 48 possible combinations of the above.
- *
- * Below are implementations of the most commonly used combinations.  They are
- * accessed through function pointers which get initialized here and are used
- * directly from the Mesa library.  The 8 function pointers directly correspond
- * to the first 3 cases listed above.
- *
- *
- * The function naming convention is:
- *
- *   write_[span|pixels]_[mono]_[format]_[pixmap|ximage]
- *
- * New functions optimized for specific cases can be added without too much
- * trouble.  An example might be the 24-bit TrueColor mode 8A8R8G8B which is
- * found on IBM RS/6000 X servers.
- */
-
-
-
-
-/**********************************************************************/
-/*** Write COLOR SPAN functions                                     ***/
-/**********************************************************************/
-
-
-#define RGBA_SPAN_ARGS	const GLcontext *ctx,				\
-			GLuint n, GLint x, GLint y,			\
-			CONST GLubyte rgba[][4], const GLubyte mask[]
-
-#define RGB_SPAN_ARGS	const GLcontext *ctx,				\
-			GLuint n, GLint x, GLint y,			\
-			CONST GLubyte rgb[][3], const GLubyte mask[]
-
-
-/* NOTE: if mask==NULL, draw all pixels */
-
-
-/*
- * Write a span of PF_TRUECOLOR pixels to a pixmap.
- */
-static void write_span_TRUECOLOR_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-            XMesaSetForeground( dpy, gc, p );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         unsigned long p;
-         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         XMesaPutPixel( rowimg, i, 0, p );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_TRUECOLOR pixels to a pixmap.
- */
-static void write_span_rgb_TRUECOLOR_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-            XMesaSetForeground( dpy, gc, p );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         unsigned long p;
-         PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-         XMesaPutPixel( rowimg, i, 0, p );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_TRUEDITHER pixels to a pixmap.
- */
-static void write_span_TRUEDITHER_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-            XMesaSetForeground( dpy, gc, p );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-         XMesaPutPixel( rowimg, i, 0, p );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_TRUEDITHER pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_TRUEDITHER_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-            XMesaSetForeground( dpy, gc, p );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-         XMesaPutPixel( rowimg, i, 0, p );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-
-/*
- * Write a span of PF_8A8B8G8R pixels to a pixmap.
- */
-static void write_span_8A8B8G8R_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-                         PACK_8A8B8G8R(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP]) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLuint *ptr4 = (GLuint *) rowimg->data;
-      for (i=0;i<n;i++) {
-         *ptr4++ = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_8A8B8G8R pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_8A8B8G8R_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-                   PACK_8B8G8R(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLuint *ptr4 = (GLuint *) rowimg->data;
-      for (i=0;i<n;i++) {
-         *ptr4++ = PACK_8B8G8R(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B pixels to a pixmap.
- */
-static void write_span_8R8G8B_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLuint *ptr4 = (GLuint *) rowimg->data;
-      for (i=0;i<n;i++) {
-         *ptr4++ = PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B24 pixels to a pixmap.
- */
-static void write_span_8R8G8B24_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      register GLuint i;
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-               PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLuint *ptr4 = (GLuint *) rowimg->data;
-      register GLuint pixel;
-      static const GLuint shift[4] = {0, 8, 16, 24};
-      register GLuint i = 0;
-      int w = n;
-      while (w > 3) {
-         pixel  = rgba[i][BCOMP] /* << shift[0]*/;
-         pixel |= rgba[i][GCOMP]    << shift[1];
-         pixel |= rgba[i++][RCOMP]  << shift[2];
-         pixel |= rgba[i][BCOMP]    << shift[3];
-         *ptr4++ = pixel;
-
-         pixel  = rgba[i][GCOMP] /* << shift[0]*/;
-         pixel |= rgba[i++][RCOMP]  << shift[1];
-         pixel |= rgba[i][BCOMP]    << shift[2];
-         pixel |= rgba[i][GCOMP]    << shift[3];
-         *ptr4++ = pixel;
-
-         pixel  = rgba[i++][RCOMP]/* << shift[0]*/;
-         pixel |= rgba[i][BCOMP]     << shift[1];
-         pixel |= rgba[i][GCOMP]     << shift[2];
-         pixel |= rgba[i++][RCOMP]   << shift[3];
-         *ptr4++ = pixel;
-
-         w -= 4;
-      }
-      switch (w) {
-         case 3:
-            pixel = 0;
-            pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
-            pixel |= rgba[i][GCOMP]   << shift[1];
-            pixel |= rgba[i++][RCOMP] << shift[2];
-            pixel |= rgba[i][BCOMP]   << shift[3];
-            *ptr4++ = pixel;
-            pixel = 0;
-            pixel |= rgba[i][GCOMP] /*<< shift[0]*/;
-            pixel |= rgba[i++][RCOMP] << shift[1];
-            pixel |= rgba[i][BCOMP]   << shift[2];
-            pixel |= rgba[i][GCOMP]   << shift[3];
-            *ptr4++ = pixel;
-            pixel = 0xffffff00 & *ptr4;
-            pixel |= rgba[i][RCOMP] /*<< shift[0]*/;
-            *ptr4 = pixel;
-            break;
-         case 2:
-            pixel = 0;
-            pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
-            pixel |= rgba[i][GCOMP]   << shift[1];
-            pixel |= rgba[i++][RCOMP] << shift[2];
-            pixel |= rgba[i][BCOMP]   << shift[3];
-            *ptr4++ = pixel;
-            pixel = 0xffff0000 & *ptr4;
-            pixel |= rgba[i][GCOMP] /*<< shift[0]*/;
-            pixel |= rgba[i][RCOMP]   << shift[1];
-            *ptr4 = pixel;
-            break;
-         case 1:
-            pixel = 0xff000000 & *ptr4;
-            pixel |= rgba[i][BCOMP] /*<< shift[0]*/;
-            pixel |= rgba[i][GCOMP] << shift[1];
-            pixel |= rgba[i][RCOMP] << shift[2];
-            *ptr4 = pixel;
-            break;
-         case 0:
-            break;
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_8R8G8B_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLuint *ptr4 = (GLuint *) rowimg->data;
-      for (i=0;i<n;i++) {
-         *ptr4++ = PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B24 pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_8R8G8B24_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      register GLuint i;
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-                  PACK_8R8G8B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLuint *ptr4 = (GLuint *) rowimg->data;
-      register GLuint pixel;
-      static const GLuint shift[4] = {0, 8, 16, 24};
-      unsigned w = n;
-      register GLuint i = 0;
-      while (w > 3) {
-         pixel = 0;
-         pixel |= rgb[i][BCOMP]/* << shift[0]*/;
-         pixel |= rgb[i][GCOMP] << shift[1];
-         pixel |= rgb[i++][RCOMP] << shift[2];
-         pixel |= rgb[i][BCOMP] <<shift[3];
-         *ptr4++ = pixel;
-
-         pixel = 0;
-         pixel |= rgb[i][GCOMP]/* << shift[0]*/;
-         pixel |= rgb[i++][RCOMP] << shift[1];
-         pixel |= rgb[i][BCOMP] << shift[2];
-         pixel |= rgb[i][GCOMP] << shift[3];
-         *ptr4++ = pixel;
-
-         pixel = 0;
-         pixel |= rgb[i++][RCOMP]/* << shift[0]*/;
-         pixel |= rgb[i][BCOMP] << shift[1];
-         pixel |= rgb[i][GCOMP] << shift[2];
-         pixel |= rgb[i++][RCOMP] << shift[3];
-         *ptr4++ = pixel;
-         w -= 4;
-      }
-      switch (w) {
-         case 3:
-            pixel = 0;
-            pixel |= rgb[i][BCOMP]/* << shift[0]*/;
-            pixel |= rgb[i][GCOMP] << shift[1];
-            pixel |= rgb[i++][RCOMP] << shift[2];
-            pixel |= rgb[i][BCOMP] << shift[3];
-            *ptr4++ = pixel;
-            pixel = 0;
-            pixel |= rgb[i][GCOMP]/* << shift[0]*/;
-            pixel |= rgb[i++][RCOMP] << shift[1];
-            pixel |= rgb[i][BCOMP] << shift[2];
-            pixel |= rgb[i][GCOMP] << shift[3];
-            *ptr4++ = pixel;
-            pixel = *ptr4;
-            pixel &= 0xffffff00;
-            pixel |= rgb[i++][RCOMP]/* << shift[0]*/;
-            *ptr4++ = pixel;
-            break;
-         case 2:
-            pixel = 0;
-            pixel |= rgb[i][BCOMP]/* << shift[0]*/;
-            pixel |= rgb[i][GCOMP] << shift[1];
-            pixel |= rgb[i++][RCOMP] << shift[2];
-            pixel |= rgb[i][BCOMP]  << shift[3];
-            *ptr4++ = pixel;
-            pixel = *ptr4;
-            pixel &= 0xffff0000;
-            pixel |= rgb[i][GCOMP]/* << shift[0]*/;
-            pixel |= rgb[i++][RCOMP] << shift[1];
-            *ptr4++ = pixel;
-            break;
-         case 1:
-            pixel = *ptr4;
-            pixel &= 0xff000000;
-            pixel |= rgb[i][BCOMP]/* << shift[0]*/;
-            pixel |= rgb[i][GCOMP] << shift[1];
-            pixel |= rgb[i++][RCOMP] << shift[2];
-            *ptr4++ = pixel;
-            break;
-         case 0:
-            break;
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_5R6G5B pixels to a pixmap.
- */
-static void write_span_5R6G5B_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLushort *ptr2 = (GLushort *) rowimg->data;
-      for (i=0;i<n;i++) {
-         ptr2[i] = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER_5R6G5B pixels to a pixmap.
- */
-static void write_span_DITHER_5R6G5B_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-            XMesaSetForeground( dpy, gc, p );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLushort *ptr2 = (GLushort *) rowimg->data;
-      for (i=0;i<n;i++) {
-         PACK_TRUEDITHER( ptr2[i], x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_5R6G5B pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_5R6G5B_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ));
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLushort *ptr2 = (GLushort *) rowimg->data;
-      for (i=0;i<n;i++) {
-         ptr2[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER_5R6G5B pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_DITHER_5R6G5B_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-            XMesaSetForeground( dpy, gc, p );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLushort *ptr2 = (GLushort *) rowimg->data;
-      for (i=0;i<n;i++) {
-         PACK_TRUEDITHER( ptr2[i], x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-
-/*
- * Write a span of PF_DITHER pixels to a pixmap.
- */
-static void write_span_DITHER_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   XDITHER_SETUP(y);
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, XDITHER(x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_DITHER_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   XDITHER_SETUP(y);
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, XDITHER(x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0, XDITHER(x+i, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_1BIT pixels to a pixmap.
- */
-static void write_span_1BIT_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   SETUP_1BIT;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-                            DITHER_1BIT( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0,
-                    DITHER_1BIT( x+i, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_1BIT pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_1BIT_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   SETUP_1BIT;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-              DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0,
-          DITHER_1BIT(x+i, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_HPCR pixels to a pixmap.
- */
-static void write_span_HPCR_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-                            DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
-      for (i=0;i<n;i++) {
-         ptr[i] = DITHER_HPCR( (x+i), y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_HPCR pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_HPCR_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc,
-              DITHER_HPCR(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      register GLubyte *ptr = (GLubyte *) xmesa->xm_buffer->rowimage->data;
-      for (i=0;i<n;i++) {
-         ptr[i] = DITHER_HPCR( (x+i), y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_LOOKUP pixels to a pixmap.
- */
-static void write_span_LOOKUP_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   LOOKUP_SETUP;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0, LOOKUP(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_LOOKUP pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_LOOKUP_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   LOOKUP_SETUP;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0, LOOKUP(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-
-/*
- * Write a span of PF_GRAYSCALE pixels to a pixmap.
- */
-static void write_span_GRAYSCALE_pixmap( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgba[i][RCOMP],rgba[i][GCOMP],rgba[i][BCOMP]) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_GRAYSCALE pixels to a pixmap (no alpha).
- */
-static void write_span_rgb_GRAYSCALE_pixmap( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      XMesaImage *rowimg = xmesa->xm_buffer->rowimage;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel( rowimg, i, 0, GRAY_RGB(rgb[i][RCOMP],rgb[i][GCOMP],rgb[i][BCOMP]) );
-      }
-      XMesaPutImage( dpy, buffer, gc, rowimg, 0, 0, x, y, n, 1 );
-   }
-}
-
-
-/*
- * Write a span of PF_TRUECOLOR pixels to an XImage.
- */
-static void write_span_TRUECOLOR_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-            XMesaPutPixel( img, x, y, p );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         unsigned long p;
-         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         XMesaPutPixel( img, x, y, p );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_TRUECOLOR pixels to an XImage (no alpha).
- */
-static void write_span_rgb_TRUECOLOR_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-            XMesaPutPixel( img, x, y, p );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         unsigned long p;
-         PACK_TRUECOLOR( p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-         XMesaPutPixel( img, x, y, p );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_TRUEDITHER pixels to an XImage.
- */
-static void write_span_TRUEDITHER_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-            XMesaPutPixel( img, x, y, p );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-         XMesaPutPixel( img, x, y, p );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_TRUEDITHER pixels to an XImage (no alpha).
- */
-static void write_span_rgb_TRUEDITHER_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            unsigned long p;
-            PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-            XMesaPutPixel( img, x, y, p );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-         XMesaPutPixel( img, x, y, p );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_8A8B8G8R-format pixels to an ximage.
- */
-static void write_span_8A8B8G8R_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++) {
-         ptr[i] = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_8A8B8G8R-format pixels to an ximage (no alpha).
- */
-static void write_span_rgb_8A8B8G8R_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = PACK_8A8B8G8R( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++) {
-         ptr[i] = PACK_8A8B8G8R( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], 255 );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B-format pixels to an ximage.
- */
-static void write_span_8R8G8B_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = PACK_8R8G8B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++) {
-         ptr[i] = PACK_8R8G8B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B24-format pixels to an ximage.
- */
-static void write_span_8R8G8B24_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = (GLubyte *) PIXELADDR3( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            GLuint *ptr4 = (GLuint *) ptr;
-            register GLuint pixel = *ptr4;
-            switch (3 & (int)(ptr - (GLubyte*)ptr4)) {
-               case 0:
-                  pixel &= 0xff000000;
-                  pixel |= rgba[i][BCOMP];
-                  pixel |= rgba[i][GCOMP] << 8;
-                  pixel |= rgba[i][RCOMP] << 16;
-                  *ptr4 = pixel;
-                  break;
-               case 3:
-                  pixel &= 0x00ffffff;
-                  pixel |= rgba[i][BCOMP] << 24;
-                  *ptr4++ = pixel;
-                  pixel = *ptr4 && 0xffff0000;
-                  pixel |= rgba[i][GCOMP];
-                  pixel |= rgba[i][RCOMP] << 8;
-                  *ptr4 = pixel;
-                  break;
-               case 2:
-                  pixel &= 0x0000ffff;
-                  pixel |= rgba[i][BCOMP] << 16;
-                  pixel |= rgba[i][GCOMP] << 24;
-                  *ptr4++ = pixel;
-                  pixel = *ptr4 && 0xffffff00;
-                  pixel |= rgba[i][RCOMP];
-                  *ptr4 = pixel;
-                  break;
-               case 1:
-                  pixel &= 0x000000ff;
-                  pixel |= rgba[i][BCOMP] << 8;
-                  pixel |= rgba[i][GCOMP] << 16;
-                  pixel |= rgba[i][RCOMP] << 24;
-                  *ptr4 = pixel;
-                  break;
-            }
-         }
-	 ptr += 3;
-      }
-   }
-   else {
-      /* write all pixels */
-      int w = n;
-      GLuint *ptr4 = (GLuint *) ptr;
-      register GLuint pixel = *ptr4;
-      int index = (int)(ptr - (GLubyte *)ptr4);
-      register GLuint i = 0;
-      switch (index) {
-         case 0:
-            break;
-         case 1:
-            pixel &= 0x00ffffff;
-            pixel |= rgba[i][BCOMP] << 24;
-            *ptr4++ = pixel;
-            pixel = *ptr4 && 0xffff0000;
-            pixel |= rgba[i][GCOMP];
-            pixel |= rgba[i++][RCOMP] << 8;
-            *ptr4 = pixel;
-            if (0 == --w)
-               break;
-         case 2:
-            pixel &= 0x0000ffff;
-            pixel |= rgba[i][BCOMP] << 16;
-            pixel |= rgba[i][GCOMP] << 24;
-            *ptr4++ = pixel;
-            pixel = *ptr4 && 0xffffff00;
-            pixel |= rgba[i++][RCOMP];
-            *ptr4 = pixel;
-            if (0 == --w)
-               break;
-         case 3:
-            pixel &= 0x000000ff;
-            pixel |= rgba[i][BCOMP] << 8;
-            pixel |= rgba[i][GCOMP] << 16;
-            pixel |= rgba[i++][RCOMP] << 24;
-            *ptr4++ = pixel;
-            if (0 == --w)
-               break;
-            break;
-      }
-      while (w > 3) {
-         pixel = rgba[i][BCOMP];
-         pixel |= rgba[i][GCOMP] << 8;
-         pixel |= rgba[i++][RCOMP] << 16;
-         pixel |= rgba[i][BCOMP] << 24;
-         *ptr4++ = pixel;
-         pixel = rgba[i][GCOMP];
-         pixel |= rgba[i++][RCOMP] << 8;
-         pixel |= rgba[i][BCOMP] << 16;
-         pixel |= rgba[i][GCOMP] << 24;
-         *ptr4++ = pixel;
-         pixel = rgba[i++][RCOMP];
-         pixel |= rgba[i][BCOMP] << 8;
-         pixel |= rgba[i][GCOMP] << 16;
-         pixel |= rgba[i++][RCOMP] << 24;
-         *ptr4++ = pixel;
-         w -= 4;
-      }
-      switch (w) {
-         case 0:
-            break;
-         case 1:
-            pixel = *ptr4 & 0xff000000;
-            pixel |= rgba[i][BCOMP];
-            pixel |= rgba[i][GCOMP] << 8;
-            pixel |= rgba[i][RCOMP] << 16;
-            *ptr4 = pixel;
-            break;
-         case 2:
-            pixel = rgba[i][BCOMP];
-            pixel |= rgba[i][GCOMP] << 8;
-            pixel |= rgba[i++][RCOMP] << 16;
-            pixel |= rgba[i][BCOMP] << 24;
-            *ptr4++ = pixel;
-            pixel = *ptr4 & 0xffff0000;
-            pixel |= rgba[i][GCOMP];
-            pixel |= rgba[i][RCOMP] << 8;
-            *ptr4 = pixel;
-            break;
-         case 3:
-            pixel = rgba[i][BCOMP];
-            pixel |= rgba[i][GCOMP] << 8;
-            pixel |= rgba[i++][RCOMP] << 16;
-            pixel |= rgba[i][BCOMP] << 24;
-            *ptr4++ = pixel;
-            pixel = rgba[i][GCOMP];
-            pixel |= rgba[i++][RCOMP] << 8;
-            pixel |= rgba[i][BCOMP] << 16;
-            pixel |= rgba[i][GCOMP] << 24;
-            *ptr4++ = pixel;
-            pixel = *ptr4 & 0xffffff00;
-            pixel |= rgba[i][RCOMP];
-            *ptr4 = pixel;
-            break;
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B-format pixels to an ximage (no alpha).
- */
-static void write_span_rgb_8R8G8B_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = PACK_8R8G8B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++) {
-         ptr[i] = PACK_8R8G8B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_8R8G8B24-format pixels to an ximage (no alpha).
- */
-static void write_span_rgb_8R8G8B24_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = (GLubyte *) PIXELADDR3( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            *ptr++ = rgb[i][BCOMP];
-            *ptr++ = rgb[i][GCOMP];
-            *ptr++ = rgb[i][RCOMP];
-         }
-         else {
-            ptr += 3;
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++) {
-         *ptr++ = rgb[i][BCOMP];
-         *ptr++ = rgb[i][GCOMP];
-         *ptr++ = rgb[i][RCOMP];
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_5R6G5B-format pixels to an ximage.
- */
-static void write_span_5R6G5B_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
-      GLuint *ptr32 = (GLuint *) ptr;
-      GLuint extraPixel = (n & 1);
-      n -= extraPixel;
-      for (i = 0; i < n; i += 2) {
-         GLuint p0, p1;
-         p0 = PACK_5R6G5B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-         p1 = PACK_5R6G5B(rgba[i+1][RCOMP], rgba[i+1][GCOMP], rgba[i+1][BCOMP]);
-         *ptr32++ = (p1 << 16) | p0;
-      }
-      if (extraPixel) {
-         ptr[n] = PACK_5R6G5B(rgba[n][RCOMP], rgba[n][GCOMP], rgba[n][BCOMP]);
-      }
-#else
-      for (i = 0; i < n; i++) {
-         ptr[i] = PACK_5R6G5B(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-      }
-#endif
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER_5R6G5B-format pixels to an ximage.
- */
-static void write_span_DITHER_5R6G5B_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            PACK_TRUEDITHER( ptr[i], x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
-      GLuint *ptr32 = (GLuint *) ptr;
-      GLuint extraPixel = (n & 1);
-      n -= extraPixel;
-      for (i = 0; i < n; i += 2, x += 2) {
-         GLuint p0, p1;
-         PACK_TRUEDITHER( p0, x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         PACK_TRUEDITHER( p1, x+1, y, rgba[i+1][RCOMP], rgba[i+1][GCOMP], rgba[i+1][BCOMP] );
-         *ptr32++ = (p1 << 16) | p0;
-      }
-      if (extraPixel) {
-         PACK_TRUEDITHER( ptr[n], x+n, y, rgba[n][RCOMP], rgba[n][GCOMP], rgba[n][BCOMP]);
-      }
-#else
-      for (i = 0; i < n; i++, x++) {
-         PACK_TRUEDITHER( ptr[i], x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-      }
-#endif
-   }
-}
-
-
-/*
- * Write a span of PF_5R6G5B-format pixels to an ximage (no alpha).
- */
-static void write_span_rgb_5R6G5B_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
-      GLuint *ptr32 = (GLuint *) ptr;
-      GLuint extraPixel = (n & 1);
-      n -= extraPixel;
-      for (i = 0; i < n; i += 2) {
-         GLuint p0, p1;
-         p0 = PACK_5R6G5B(rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
-         p1 = PACK_5R6G5B(rgb[i+1][RCOMP], rgb[i+1][GCOMP], rgb[i+1][BCOMP]);
-         *ptr32++ = (p1 << 16) | p0;
-      }
-      if (extraPixel) {
-         ptr[n] = PACK_5R6G5B(rgb[n][RCOMP], rgb[n][GCOMP], rgb[n][BCOMP]);
-      }
-#else
-      for (i=0;i<n;i++) {
-         ptr[i] = PACK_5R6G5B( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-#endif
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER_5R6G5B-format pixels to an ximage (no alpha).
- */
-static void write_span_rgb_DITHER_5R6G5B_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            PACK_TRUEDITHER( ptr[i], x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
-      GLuint *ptr32 = (GLuint *) ptr;
-      GLuint extraPixel = (n & 1);
-      n -= extraPixel;
-      for (i = 0; i < n; i += 2, x += 2) {
-         GLuint p0, p1;
-         PACK_TRUEDITHER( p0, x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-         PACK_TRUEDITHER( p1, x+1, y, rgb[i+1][RCOMP], rgb[i+1][GCOMP], rgb[i+1][BCOMP] );
-         *ptr32++ = (p1 << 16) | p0;
-      }
-      if (extraPixel) {
-         PACK_TRUEDITHER( ptr[n], x+n, y, rgb[n][RCOMP], rgb[n][GCOMP], rgb[n][BCOMP]);
-      }
-#else
-      for (i=0;i<n;i++,x++) {
-         PACK_TRUEDITHER( ptr[i], x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-#endif
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER pixels to an XImage.
- */
-static void write_span_DITHER_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   int yy = FLIP(xmesa->xm_buffer, y);
-   XDITHER_SETUP(yy);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel( img, x, yy, XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, yy, XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER pixels to an XImage (no alpha).
- */
-static void write_span_rgb_DITHER_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   int yy = FLIP(xmesa->xm_buffer, y);
-   XDITHER_SETUP(yy);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel( img, x, yy, XDITHER( x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, yy, XDITHER( x, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-      }
-   }
-}
-
-
-
-/*
- * Write a span of 8-bit PF_DITHER pixels to an XImage.
- */
-static void write_span_DITHER8_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   XDITHER_SETUP(y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            ptr[i] = (GLubyte) XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++,x++) {
-         ptr[i] = (GLubyte) XDITHER( x, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-static void write_span_rgb_DITHER8_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   XDITHER_SETUP(y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            ptr[i] = (GLubyte) XDITHER( x, rgb[i][0], rgb[i][1], rgb[i][2] );
-         }
-      }
-   }
-   else {
-      const GLubyte *data = (GLubyte *) rgb;
-      for (i=0;i<n;i++,x++) {
-         /*ptr[i] = XDITHER( x, rgb[i][0], rgb[i][1], rgb[i][2] );*/
-         ptr[i] = (GLubyte) XDITHER( x, data[i+i+i], data[i+i+i+1], data[i+i+i+2] );
-      }
-   }
-}
-
-
-
-/*
- * Write a span of PF_1BIT pixels to an XImage.
- */
-static void write_span_1BIT_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   SETUP_1BIT;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel(img, x, y, DITHER_1BIT(x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, y, DITHER_1BIT(x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_1BIT pixels to an XImage (no alpha).
- */
-static void write_span_rgb_1BIT_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   SETUP_1BIT;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel(img, x, y, DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]));
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, y, DITHER_1BIT(x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]) );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_HPCR pixels to an XImage.
- */
-static void write_span_HPCR_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            ptr[i] = DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         ptr[i] = DITHER_HPCR( x, y, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_HPCR pixels to an XImage (no alpha).
- */
-static void write_span_rgb_HPCR_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            ptr[i] = DITHER_HPCR( x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         ptr[i] = DITHER_HPCR( x, y, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_LOOKUP pixels to an XImage.
- */
-static void write_span_LOOKUP_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   LOOKUP_SETUP;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel( img, x, y, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, y, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_LOOKUP pixels to an XImage (no alpha).
- */
-static void write_span_rgb_LOOKUP_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   LOOKUP_SETUP;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel( img, x, y, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, y, LOOKUP( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-      }
-   }
-}
-
-
-/*
- * Write a span of 8-bit PF_LOOKUP pixels to an XImage.
- */
-static void write_span_LOOKUP8_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   LOOKUP_SETUP;
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            ptr[i] = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         ptr[i] = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-static void write_rgb_LOOKUP8_ximage( const GLcontext *ctx,
-                                      GLuint n, GLint x, GLint y,
-                                      CONST GLubyte rgb[][3],
-                                      const GLubyte mask[] )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   LOOKUP_SETUP;
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            ptr[i] = (GLubyte) LOOKUP( rgb[i][0], rgb[i][1], rgb[i][2] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      const GLubyte *data = (GLubyte *) rgb;
-      for (i=0;i<n;i++,x++) {
-         /*ptr[i] = LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );*/
-         ptr[i] = (GLubyte) LOOKUP( data[i+i+i], data[i+i+i+1], data[i+i+i+2] );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_GRAYSCALE pixels to an XImage.
- */
-static void write_span_GRAYSCALE_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel( img, x, y, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, y, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_GRAYSCALE pixels to an XImage (no alpha).
- */
-static void write_span_rgb_GRAYSCALE_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel( img, x, y, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, y, GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] ) );
-      }
-   }
-}
-
-
-/*
- * Write a span of 8-bit PF_GRAYSCALE pixels to an XImage.
- */
-static void write_span_GRAYSCALE8_ximage( RGBA_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++) {
-         ptr[i] = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write a span of 8-bit PF_GRAYSCALE pixels to an XImage (no alpha).
- */
-static void write_span_rgb_GRAYSCALE8_ximage( RGB_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x, y );
-   if (mask) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            ptr[i] = (GLubyte) GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-         }
-      }
-   }
-   else {
-      /* draw all pixels */
-      for (i=0;i<n;i++) {
-         ptr[i] = (GLubyte) GRAY_RGB( rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP] );
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*** Write COLOR PIXEL functions                                    ***/
-/**********************************************************************/
-
-
-#define RGBA_PIXEL_ARGS   const GLcontext *ctx,				\
-			  GLuint n, const GLint x[], const GLint y[],	\
-			  CONST GLubyte rgba[][4], const GLubyte mask[]
-
-
-/*
- * Write an array of PF_TRUECOLOR pixels to a pixmap.
- */
-static void write_pixels_TRUECOLOR_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-	 XMesaSetForeground( dpy, gc, p );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_TRUEDITHER pixels to a pixmap.
- */
-static void write_pixels_TRUEDITHER_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-         XMesaSetForeground( dpy, gc, p );
-         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_8A8B8G8R pixels to a pixmap.
- */
-static void write_pixels_8A8B8G8R_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc,
-                         PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] ));
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_8R8G8B pixels to a pixmap.
- */
-static void write_pixels_8R8G8B_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_8R8G8B24 pixels to a pixmap.
- */
-static void write_pixels_8R8G8B24_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc, PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_5R6G5B pixels to a pixmap.
- */
-static void write_pixels_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc, PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_DITHER_5R6G5B pixels to a pixmap.
- */
-static void write_pixels_DITHER_5R6G5B_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-	 XMesaSetForeground( dpy, gc, p );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_DITHER pixels to a pixmap.
- */
-static void write_pixels_DITHER_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   DITHER_SETUP;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc,
-                         DITHER(x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_1BIT pixels to a pixmap.
- */
-static void write_pixels_1BIT_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   SETUP_1BIT;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc,
-                         DITHER_1BIT( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_HPCR pixels to a pixmap.
- */
-static void write_pixels_HPCR_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         XMesaSetForeground( dpy, gc,
-                         DITHER_HPCR( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
-         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_LOOKUP pixels to a pixmap.
- */
-static void write_pixels_LOOKUP_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   LOOKUP_SETUP;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         XMesaSetForeground( dpy, gc, LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_GRAYSCALE pixels to a pixmap.
- */
-static void write_pixels_GRAYSCALE_pixmap( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         XMesaSetForeground( dpy, gc, GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-         XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_TRUECOLOR pixels to an ximage.
- */
-static void write_pixels_TRUECOLOR_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUECOLOR( p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_TRUEDITHER pixels to an XImage.
- */
-static void write_pixels_TRUEDITHER_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x[i], FLIP(xmesa->xm_buffer, y[i]), rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_8A8B8G8R pixels to an ximage.
- */
-static void write_pixels_8A8B8G8R_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
-         *ptr = PACK_8A8B8G8R( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP], rgba[i][ACOMP] );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_8R8G8B pixels to an ximage.
- */
-static void write_pixels_8R8G8B_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
-         *ptr = PACK_8R8G8B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_8R8G8B24 pixels to an ximage.
- */
-static void write_pixels_8R8G8B24_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x[i], y[i] );
-         ptr->r = rgba[i][RCOMP];
-         ptr->g = rgba[i][GCOMP];
-         ptr->b = rgba[i][BCOMP];
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_5R6G5B pixels to an ximage.
- */
-static void write_pixels_5R6G5B_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
-         *ptr = PACK_5R6G5B( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_DITHER_5R6G5B pixels to an ximage.
- */
-static void write_pixels_DITHER_5R6G5B_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
-         PACK_TRUEDITHER( *ptr, x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_DITHER pixels to an XImage.
- */
-static void write_pixels_DITHER_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   DITHER_SETUP;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
-                    DITHER( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-      }
-   }
-}
-
-
-/*
- * Write an array of 8-bit PF_DITHER pixels to an XImage.
- */
-static void write_pixels_DITHER8_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   DITHER_SETUP;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
-	 *ptr = (GLubyte) DITHER( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_1BIT pixels to an XImage.
- */
-static void write_pixels_1BIT_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   SETUP_1BIT;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
-                    DITHER_1BIT( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ));
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_HPCR pixels to an XImage.
- */
-static void write_pixels_HPCR_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
-         *ptr = (GLubyte) DITHER_HPCR( x[i], y[i], rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_LOOKUP pixels to an XImage.
- */
-static void write_pixels_LOOKUP_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   LOOKUP_SETUP;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), LOOKUP(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of 8-bit PF_LOOKUP pixels to an XImage.
- */
-static void write_pixels_LOOKUP8_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   LOOKUP_SETUP;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
-	 *ptr = (GLubyte) LOOKUP( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_GRAYSCALE pixels to an XImage.
- */
-static void write_pixels_GRAYSCALE_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]),
-                    GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] ) );
-      }
-   }
-}
-
-
-/*
- * Write an array of 8-bit PF_GRAYSCALE pixels to an XImage.
- */
-static void write_pixels_GRAYSCALE8_ximage( RGBA_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer, x[i], y[i] );
-	 *ptr = (GLubyte) GRAY_RGB( rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP] );
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*** Write MONO COLOR SPAN functions                                ***/
-/**********************************************************************/
-
-#define MONO_SPAN_ARGS	const GLcontext *ctx,	\
-		 	GLuint n, GLint x, GLint y, const GLubyte mask[]
-
-
-/*
- * Write a span of identical pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index().
- */
-static void write_span_mono_pixmap( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc1;
-   register GLuint i;
-   register GLboolean write_all;
-   y = FLIP(xmesa->xm_buffer, y);
-   write_all = GL_TRUE;
-   for (i=0;i<n;i++) {
-      if (!mask[i]) {
-	 write_all = GL_FALSE;
-	 break;
-      }
-   }
-   if (write_all) {
-      XMesaFillRectangle( dpy, buffer, gc, (int) x, (int) y, n, 1 );
-   }
-   else {
-#if 0
-      for (i=0;i<n;i++,x++) {
-	 if (mask[i]) {
-	    XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-	 }
-      }
-#else
-      /* This version is usually faster.  Contributed by Jeff Epler
-       * and cleaned up by Keith Whitwell.
-       */
-      for (i = 0; i < n; ) {
-         GLuint start = i;
-         /* Identify and emit contiguous rendered pixels
-          */
-         for( ; i < n && mask[i]; i++)
-            /* Nothing */;
-         if (start < i) 
-            XMesaFillRectangle( dpy, buffer, gc,
-                                (int)(x+start), (int) y,
-                                (int)(i-start), 1);
-         /* Eat up non-rendered pixels
-          */
-         for(; i < n && !mask[i]; i++)
-            /* Nothing */;
-      }
-#endif
-   }
-}
-
-
-/*
- * Write a span of PF_TRUEDITHER pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index().
- */
-static void write_span_mono_TRUEDITHER_pixmap( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   register GLubyte r, g, b;
-   int yy = FLIP(xmesa->xm_buffer, y);
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x, yy, r, g, b);
-         XMesaSetForeground( dpy, gc, p );
-         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) yy );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_DITHER pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index().
- */
-static void write_span_mono_DITHER_pixmap( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   register GLubyte r, g, b;
-   int yy = FLIP(xmesa->xm_buffer, y);
-   XDITHER_SETUP(yy);
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-         XMesaSetForeground( dpy, gc, XDITHER( x, r, g, b ) );
-         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) yy );
-      }
-   }
-}
-
-
-/*
- * Write a span of PF_1BIT pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index().
- */
-static void write_span_mono_1BIT_pixmap( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   register GLubyte r, g, b;
-   SETUP_1BIT;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   y = FLIP(xmesa->xm_buffer, y);
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-         XMesaSetForeground( dpy, gc, DITHER_1BIT( x, y, r, g, b ) );
-         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-      }
-   }
-}
-
-
-/*
- * Write a span of identical pixels to an XImage.  The pixel value is
- * the one set by DD.color() or DD.index().
- */
-static void write_span_mono_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   register unsigned long p = xmesa->pixel;
-   y = FLIP(xmesa->xm_buffer, y);
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x, y, p );
-      }
-   }
-}
-
-
-/*
- * Write a span of identical PF_TRUEDITHER pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_TRUEDITHER_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   GLuint i;
-   GLint r = xmesa->red;
-   GLint g = xmesa->green;
-   GLint b = xmesa->blue;
-   y = FLIP(xmesa->xm_buffer, y);
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUEDITHER( p, x+i, y, r, g, b);
-	 XMesaPutPixel( img, x+i, y, p );
-      }
-   }
-}
-
-
-/*
- * Write a span of identical 8A8B8G8R pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_8A8B8G8R_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   GLuint i, p, *ptr;
-   p = (GLuint) xmesa->pixel;
-   ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 ptr[i] = p;
-      }
-   }
-}
-
-
-/*
- * Write a span of identical 8R8G8B pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_8R8G8B_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   GLuint i, p, *ptr;
-   p = (GLuint) xmesa->pixel;
-   ptr = PIXELADDR4( xmesa->xm_buffer, x, y );
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 ptr[i] = p;
-      }
-   }
-}
-
-
-/*
- * Write a span of identical 8R8G8B pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_8R8G8B24_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte r = (GLubyte) ((xmesa->pixel >> 16) & 0xff);
-   const GLubyte g = (GLubyte) ((xmesa->pixel >> 8 ) & 0xff);
-   const GLubyte b = (GLubyte) ((xmesa->pixel      ) & 0xff);
-   GLuint i;
-   bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x, y );
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         ptr[i].r = r;
-         ptr[i].g = g;
-         ptr[i].b = b;
-      }
-   }
-}
-
-
-/*
- * Write a span of identical DITHER pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_DITHER_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   register GLubyte r, g, b;
-   int yy = FLIP(xmesa->xm_buffer, y);
-   XDITHER_SETUP(yy);
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x, yy, XDITHER( x, r, g, b ) );
-      }
-   }
-}
-
-
-/*
- * Write a span of identical 8-bit DITHER pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_DITHER8_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
-   register GLubyte r, g, b;
-   XDITHER_SETUP(y);
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-	 ptr[i] = (GLubyte) XDITHER( x, r, g, b );
-      }
-   }
-}
-
-
-/*
- * Write a span of identical 8-bit LOOKUP pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_LOOKUP8_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
-   register GLubyte pixel = (GLubyte) xmesa->pixel;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 ptr[i] = pixel;
-      }
-   }
-}
-
-
-/*
- * Write a span of identical PF_1BIT pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_1BIT_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   register GLubyte r, g, b;
-   SETUP_1BIT;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   y = FLIP(xmesa->xm_buffer, y);
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x, y, DITHER_1BIT( x, y, r, g, b ) );
-      }
-   }
-}
-
-
-/*
- * Write a span of identical HPCR pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_HPCR_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x,y);
-   register GLubyte r, g, b;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-         ptr[i] = DITHER_HPCR( x, y, r, g, b );
-      }
-   }
-}
-
-
-/*
- * Write a span of identical 8-bit GRAYSCALE pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_GRAYSCALE8_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   GLuint i;
-   GLubyte p = (GLubyte) xmesa->pixel;
-   GLubyte *ptr = (GLubyte *) PIXELADDR1( xmesa->xm_buffer,x,y);
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 ptr[i] = p;
-      }
-   }
-}
-
-
-
-/*
- * Write a span of identical PF_DITHER_5R6G5B pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_span_mono_DITHER_5R6G5B_ximage( MONO_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x, y );
-   GLuint i;
-   GLint r = xmesa->red;
-   GLint g = xmesa->green;
-   GLint b = xmesa->blue;
-   y = FLIP(xmesa->xm_buffer, y);
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         PACK_TRUEDITHER(ptr[i], x+i, y, r, g, b);
-      }
-   }
-}
-
-
-
-/**********************************************************************/
-/*** Write MONO COLOR PIXELS functions                              ***/
-/**********************************************************************/
-
-#define MONO_PIXEL_ARGS	const GLcontext *ctx,				\
-			GLuint n, const GLint x[], const GLint y[],	\
-			const GLubyte mask[]
-
-/*
- * Write an array of identical pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index.
- */
-static void write_pixels_mono_pixmap( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc1;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_TRUEDITHER pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index.
- */
-static void write_pixels_mono_TRUEDITHER_pixmap( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   register GLubyte r, g, b;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x[i], y[i], r, g, b);
-         XMesaSetForeground( dpy, gc, p );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_DITHER pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index.
- */
-static void write_pixels_mono_DITHER_pixmap( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   register GLubyte r, g, b;
-   DITHER_SETUP;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         XMesaSetForeground( dpy, gc, DITHER( x[i], y[i], r, g, b ) );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of PF_1BIT pixels to a pixmap.  The pixel value is
- * the one set by DD.color() or DD.index.
- */
-static void write_pixels_mono_1BIT_pixmap( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   register GLubyte r, g, b;
-   SETUP_1BIT;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         XMesaSetForeground( dpy, gc, DITHER_1BIT( x[i], y[i], r, g, b ) );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of identical pixels to an XImage.  The pixel value is
- * the one set by DD.color() or DD.index.
- */
-static void write_pixels_mono_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   register unsigned long p = xmesa->pixel;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
-      }
-   }
-}
-
-
-/*
- * Write an array of identical TRUEDITHER pixels to an XImage.
- * The pixel value is the one set by DD.color() or DD.index.
- */
-static void write_pixels_mono_TRUEDITHER_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   int r = xmesa->red;
-   int g = xmesa->green;
-   int b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         unsigned long p;
-         PACK_TRUEDITHER(p, x[i], FLIP(xmesa->xm_buffer, y[i]), r, g, b);
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), p );
-      }
-   }
-}
-
-
-
-/*
- * Write an array of identical 8A8B8G8R pixels to an XImage.  The pixel value
- * is the one set by DD.color().
- */
-static void write_pixels_mono_8A8B8G8R_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLuint p = (GLuint) xmesa->pixel;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
-	 *ptr = p;
-      }
-   }
-}
-
-
-/*
- * Write an array of identical 8R8G8B pixels to an XImage.  The pixel value
- * is the one set by DD.color().
- */
-static void write_pixels_mono_8R8G8B_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLuint p = (GLuint) xmesa->pixel;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLuint *ptr = PIXELADDR4( xmesa->xm_buffer, x[i], y[i] );
-	 *ptr = p;
-      }
-   }
-}
-
-
-/*
- * Write an array of identical 8R8G8B pixels to an XImage.  The pixel value
- * is the one set by DD.color().
- */
-static void write_pixels_mono_8R8G8B24_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte r = (GLubyte) ((xmesa->pixel >> 16) & 0xff);
-   const GLubyte g = (GLubyte) ((xmesa->pixel >> 8 ) & 0xff);
-   const GLubyte b = (GLubyte) ((xmesa->pixel      ) & 0xff);
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 bgr_t *ptr = PIXELADDR3( xmesa->xm_buffer, x[i], y[i] );
-         ptr->r = r;
-         ptr->g = g;
-         ptr->b = b;
-      }
-   }
-}
-
-
-/*
- * Write an array of identical PF_DITHER pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_pixels_mono_DITHER_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   register GLubyte r, g, b;
-   DITHER_SETUP;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), DITHER( x[i], y[i], r, g, b ) );
-      }
-   }
-}
-
-
-/*
- * Write an array of identical 8-bit PF_DITHER pixels to an XImage.  The
- * pixel value is the one set by DD.color().
- */
-static void write_pixels_mono_DITHER8_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte r, g, b;
-   DITHER_SETUP;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
-	 *ptr = (GLubyte) DITHER( x[i], y[i], r, g, b );
-      }
-   }
-}
-
-
-/*
- * Write an array of identical 8-bit PF_LOOKUP pixels to an XImage.  The
- * pixel value is the one set by DD.color().
- */
-static void write_pixels_mono_LOOKUP8_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte pixel = (GLubyte) xmesa->pixel;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
-	 *ptr = pixel;
-      }
-   }
-}
-
-
-
-/*
- * Write an array of identical PF_1BIT pixels to an XImage.  The pixel
- * value is the one set by DD.color().
- */
-static void write_pixels_mono_1BIT_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   register GLubyte r, g, b;
-   SETUP_1BIT;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), DITHER_1BIT( x[i], y[i], r, g, b ));
-      }
-   }
-}
-
-
-/*
- * Write an array of identical PF_HPCR pixels to an XImage.  The
- * pixel value is the one set by DD.color().
- */
-static void write_pixels_mono_HPCR_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte r, g, b;
-   r = xmesa->red;
-   g = xmesa->green;
-   b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-         GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
-         *ptr = DITHER_HPCR( x[i], y[i], r, g, b );
-      }
-   }
-}
-
-
-/*
- * Write an array of identical 8-bit PF_GRAYSCALE pixels to an XImage.  The
- * pixel value is the one set by DD.color().
- */
-static void write_pixels_mono_GRAYSCALE8_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   register GLubyte p = (GLubyte) xmesa->pixel;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLubyte *ptr = PIXELADDR1( xmesa->xm_buffer,x[i],y[i]);
-	 *ptr = p;
-      }
-   }
-}
-
-
-/*
- * Write an array of identical PF_DITHER_5R6G5B pixels to an XImage.
- * The pixel value is the one set by DD.color() or DD.index.
- */
-static void write_pixels_mono_DITHER_5R6G5B_ximage( MONO_PIXEL_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   int r = xmesa->red;
-   int g = xmesa->green;
-   int b = xmesa->blue;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 GLushort *ptr = PIXELADDR2( xmesa->xm_buffer, x[i], y[i] );
-         PACK_TRUEDITHER(*ptr, x[i], y[i], r, g, b);
-      }
-   }
-}
-
-
-
-/**********************************************************************/
-/*** Write INDEX SPAN functions                                     ***/
-/**********************************************************************/
-
-#define INDEX_SPAN_ARGS	const GLcontext *ctx,				\
-			GLuint n, GLint x, GLint y, const GLuint index[], \
-			const GLubyte mask[]
-
-#define INDEX8_SPAN_ARGS const GLcontext *ctx,				\
-			 GLuint n, GLint x, GLint y, const GLubyte index[], \
-			 const GLubyte mask[]
-
-
-/*
- * Write a span of CI pixels to a Pixmap.
- */
-static void write_span_index_pixmap( INDEX_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   for (i=0;i<n;i++,x++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-      }
-   }
-}
-
-
-/*
- * Write a span of 8-bit CI pixels to a Pixmap.
- */
-static void write_span_index8_pixmap( INDEX8_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
-            XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++,x++) {
-         XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
-         XMesaDrawPoint( dpy, buffer, gc, (int) x, (int) y );
-      }
-   }
-}
-
-
-/*
- * Write a span of CI pixels to an XImage.
- */
-static void write_span_index_ximage( INDEX_SPAN_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   y = FLIP(xmesa->xm_buffer, y);
-   if (mask) {
-      for (i=0;i<n;i++,x++) {
-         if (mask[i]) {
-            XMesaPutPixel( img, x, y, (unsigned long) index[i] );
-         }
-      }
-   }
-   else {
-      for (i=0;i<n;i++,x++) {
-         XMesaPutPixel( img, x, y, (unsigned long) index[i] );
-      }
-   }
-}
-
-
-/*
- * Write a span of 8-bit CI pixels to a non 8-bit XImage.
- */
-static void write_span_index8_ximage( const GLcontext *ctx, GLuint n,
-                                      GLint x, GLint y, const GLubyte index[],
-                                      const GLubyte mask[] )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   if (mask) {
-      GLuint i;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
-         }
-      }
-   }
-   else {
-      GLuint i;
-      for (i=0;i<n;i++) {
-         XMesaPutPixel(xmesa->xm_buffer->backimage, x+i, y, index[i]);
-      }
-   }
-}
-
-/*
- * Write a span of 8-bit CI pixels to an 8-bit XImage.
- */
-static void write_span_index8_ximage8( const GLcontext *ctx, GLuint n,
-                                      GLint x, GLint y, const GLubyte index[],
-                                      const GLubyte mask[] )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   GLubyte *dst = PIXELADDR1( xmesa->xm_buffer,x,y);
-   if (mask) {
-      GLuint i;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            dst[i] = index[i];
-         }
-      }
-   }
-   else {
-      MEMCPY( dst, index, n );
-   }
-}
-
-
-
-/**********************************************************************/
-/*** Write INDEX PIXELS functions                                   ***/
-/**********************************************************************/
-
-#define INDEX_PIXELS_ARGS	const GLcontext *ctx,			\
-				GLuint n, const GLint x[], const GLint y[], \
-				const GLuint index[], const GLubyte mask[]
-
-
-/*
- * Write an array of CI pixels to a Pixmap.
- */
-static void write_pixels_index_pixmap( INDEX_PIXELS_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaSetForeground( dpy, gc, (unsigned long) index[i] );
-	 XMesaDrawPoint( dpy, buffer, gc, (int) x[i], (int) FLIP(xmesa->xm_buffer, y[i]) );
-      }
-   }
-}
-
-
-/*
- * Write an array of CI pixels to an XImage.
- */
-static void write_pixels_index_ximage( INDEX_PIXELS_ARGS )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   register GLuint i;
-   for (i=0;i<n;i++) {
-      if (mask[i]) {
-	 XMesaPutPixel( img, x[i], FLIP(xmesa->xm_buffer, y[i]), (unsigned long) index[i] );
-      }
-   }
-}
-
-
-
-
-/**********************************************************************/
-/*****                      Pixel reading                         *****/
-/**********************************************************************/
-
-
-
-/*
- * Read a horizontal span of color-index pixels.
- */
-static void read_index_span( const GLcontext *ctx,
-			     GLuint n, GLint x, GLint y, GLuint index[] )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaBuffer source;
-   GLuint i;
-
-   if (xmesa->use_read_buffer)
-      source = xmesa->xm_read_buffer;
-   else
-      source = xmesa->xm_buffer;
-
-   y = FLIP(source, y);
-
-   if (source->buffer) {
-#ifndef XFree86Server
-      XMesaImage *span = NULL;
-      int error;
-      catch_xgetimage_errors( xmesa->display );
-      span = XGetImage( xmesa->display, source->buffer,
-		        x, y, n, 1, AllPlanes, ZPixmap );
-      error = check_xgetimage_errors();
-      if (span && !error) {
-	 for (i=0;i<n;i++) {
-	    index[i] = (GLuint) XMesaGetPixel( span, i, 0 );
-	 }
-      }
-      else {
-	 /* return 0 pixels */
-	 for (i=0;i<n;i++) {
-	    index[i] = 0;
-	 }
-      }
-      if (span) {
-	 XMesaDestroyImage( span );
-      }
-#else
-      (*xmesa->display->GetImage)(source->buffer,
-				  x, y, n, 1, ZPixmap,
-				  ~0L, (pointer)index);
-#endif
-   }
-   else if (source->backimage) {
-      XMesaImage *img = source->backimage;
-      for (i=0;i<n;i++,x++) {
-	 index[i] = (GLuint) XMesaGetPixel( img, x, y );
-      }
-   }
-}
-
-
-
-/*
- * Read a horizontal span of color pixels.
- */
-static void read_color_span( const GLcontext *ctx,
-			     GLuint n, GLint x, GLint y,
-                             GLubyte rgba[][4] )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaBuffer source;
-
-   if (xmesa->use_read_buffer)
-      source = xmesa->xm_read_buffer;
-   else
-      source = xmesa->xm_buffer;
-
-   if (source->buffer) {
-      /* Read from Pixmap or Window */
-      XMesaImage *span = NULL;
-      int error;
-#ifdef XFree86Server
-      span = XMesaCreateImage(xmesa->xm_visual->BitsPerPixel, n, 1, NULL);
-      span->data = (char *)MALLOC(span->height * span->bytes_per_line);
-      error = (!span->data);
-      (*xmesa->display->GetImage)(source->buffer,
-				  x, FLIP(source, y), n, 1, ZPixmap,
-				  ~0L, (pointer)span->data);
-#else
-      catch_xgetimage_errors( xmesa->display );
-      span = XGetImage( xmesa->display, source->buffer,
-		        x, FLIP(source, y), n, 1, AllPlanes, ZPixmap );
-      error = check_xgetimage_errors();
-#endif
-      if (span && !error) {
-	 switch (xmesa->pixelformat) {
-	    case PF_TRUECOLOR:
-	    case PF_TRUEDITHER:
-               {
-                  const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
-                  const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
-                  const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
-                  unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
-                  unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
-                  unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
-                  GLint rShift = xmesa->xm_visual->rshift;
-                  GLint gShift = xmesa->xm_visual->gshift;
-                  GLint bShift = xmesa->xm_visual->bshift;
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     unsigned long p;
-                     p = XMesaGetPixel( span, i, 0 );
-                     rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
-                     rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
-                     rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-	       break;
-            case PF_5R6G5B:
-            case PF_DITHER_5R6G5B:
-               {
-                  const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
-                  const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
-                  const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     unsigned long p = XMesaGetPixel( span, i, 0 );
-                     /* fast, but not quite accurate
-                     rgba[i][RCOMP] = ((p >> 8) & 0xf8);
-                     rgba[i][GCOMP] = ((p >> 3) & 0xfc);
-                     rgba[i][BCOMP] = ((p << 3) & 0xff);
-                     */
-                     rgba[i][RCOMP] = pixelToR[p >> 11];
-                     rgba[i][GCOMP] = pixelToG[(p >> 5) & 0x3f];
-                     rgba[i][BCOMP] = pixelToB[p & 0x1f];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-	       break;
-	    case PF_8A8B8G8R:
-               {
-                  const GLuint *ptr4 = (GLuint *) span->data;
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     GLuint p4 = *ptr4++;
-                     rgba[i][RCOMP] = (GLubyte) ( p4        & 0xff);
-                     rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
-                     rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
-                     rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
-                  }
-	       }
-	       break;
-            case PF_8R8G8B:
-               {
-                  const GLuint *ptr4 = (GLuint *) span->data;
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     GLuint p4 = *ptr4++;
-                     rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
-                     rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
-                     rgba[i][BCOMP] = (GLubyte) ( p4        & 0xff);
-                     rgba[i][ACOMP] = 255;
-                  }
-	       }
-	       break;
-            case PF_8R8G8B24:
-               {
-                  const bgr_t *ptr3 = (bgr_t *) span->data;
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     rgba[i][RCOMP] = ptr3[i].r;
-                     rgba[i][GCOMP] = ptr3[i].g;
-                     rgba[i][BCOMP] = ptr3[i].b;
-                     rgba[i][ACOMP] = 255;
-                  }
-	       }
-	       break;
-            case PF_HPCR:
-               {
-                  GLubyte *ptr1 = (GLubyte *) span->data;
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     GLubyte p = *ptr1++;
-                     rgba[i][RCOMP] =  p & 0xE0;
-                     rgba[i][GCOMP] = (p & 0x1C) << 3;
-                     rgba[i][BCOMP] = (p & 0x03) << 6;
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-               break;
-	    case PF_DITHER:
-	    case PF_LOOKUP:
-	    case PF_GRAYSCALE:
-               {
-                  GLubyte *rTable = source->pixel_to_r;
-                  GLubyte *gTable = source->pixel_to_g;
-                  GLubyte *bTable = source->pixel_to_b;
-                  if (GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
-                     const GLubyte *ptr1 = (GLubyte *) span->data;
-                     GLuint i;
-                     for (i=0;i<n;i++) {
-                        unsigned long p = *ptr1++;
-                        rgba[i][RCOMP] = rTable[p];
-                        rgba[i][GCOMP] = gTable[p];
-                        rgba[i][BCOMP] = bTable[p];
-                        rgba[i][ACOMP] = 255;
-                     }
-                  }
-                  else {
-                     GLuint i;
-                     for (i=0;i<n;i++) {
-                        unsigned long p = XMesaGetPixel( span, i, 0 );
-                        rgba[i][RCOMP] = rTable[p];
-                        rgba[i][GCOMP] = gTable[p];
-                        rgba[i][BCOMP] = bTable[p];
-                        rgba[i][ACOMP] = 255;
-                     }
-                  }
-               }
-	       break;
-	    case PF_1BIT:
-               {
-                  int bitFlip = xmesa->xm_visual->bitFlip;
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     unsigned long p;
-                     p = XMesaGetPixel( span, i, 0 ) ^ bitFlip;
-                     rgba[i][RCOMP] = (GLubyte) (p * 255);
-                     rgba[i][GCOMP] = (GLubyte) (p * 255);
-                     rgba[i][BCOMP] = (GLubyte) (p * 255);
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-	       break;
-	    default:
-	       gl_problem(NULL,"Problem in DD.read_color_span (1)");
-               return;
-	 }
-      }
-      else {
-	 /* return black pixels */
-         GLuint i;
-	 for (i=0;i<n;i++) {
-	    rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = rgba[i][ACOMP] = 0;
-	 }
-      }
-      if (span) {
-	 XMesaDestroyImage( span );
-      }
-   }
-   else if (source->backimage) {
-      /* Read from XImage back buffer */
-      switch (xmesa->pixelformat) {
-         case PF_TRUECOLOR:
-         case PF_TRUEDITHER:
-            {
-               const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
-               const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
-               const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
-               unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
-               unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
-               unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
-               GLint rShift = xmesa->xm_visual->rshift;
-               GLint gShift = xmesa->xm_visual->gshift;
-               GLint bShift = xmesa->xm_visual->bshift;
-               XMesaImage *img = source->backimage;
-               GLuint i;
-               y = FLIP(source, y);
-               for (i=0;i<n;i++) {
-                  unsigned long p;
-		  p = XMesaGetPixel( img, x+i, y );
-                  rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
-                  rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
-                  rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
-                  rgba[i][ACOMP] = 255;
-               }
-            }
-            break;
-         case PF_5R6G5B:
-         case PF_DITHER_5R6G5B:
-            {
-               const GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
-               const GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
-               const GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
-               const GLushort *ptr2 = PIXELADDR2( source, x, y );
-               GLuint i;
-#if defined(__i386__) /* word stores don't have to be on 4-byte boundaries */
-               const GLuint *ptr4 = (const GLuint *) ptr2;
-               GLuint extraPixel = (n & 1);
-               n -= extraPixel;
-               for (i = 0; i < n; i += 2) {
-                  const GLuint p = *ptr4++;
-                  const GLuint p0 = p & 0xffff;
-                  const GLuint p1 = p >> 16;
-                  /* fast, but not quite accurate
-                  rgba[i][RCOMP] = ((p >> 8) & 0xf8);
-                  rgba[i][GCOMP] = ((p >> 3) & 0xfc);
-                  rgba[i][BCOMP] = ((p << 3) & 0xff);
-                  */
-                  rgba[i][RCOMP] = pixelToR[p0 >> 11];
-                  rgba[i][GCOMP] = pixelToG[(p0 >> 5) & 0x3f];
-                  rgba[i][BCOMP] = pixelToB[p0 & 0x1f];
-                  rgba[i][ACOMP] = 255;
-                  rgba[i+1][RCOMP] = pixelToR[p1 >> 11];
-                  rgba[i+1][GCOMP] = pixelToG[(p1 >> 5) & 0x3f];
-                  rgba[i+1][BCOMP] = pixelToB[p1 & 0x1f];
-                  rgba[i+1][ACOMP] = 255;
-               }
-               if (extraPixel) {
-                  GLushort p = ptr2[n];
-                  rgba[n][RCOMP] = pixelToR[p >> 11];
-                  rgba[n][GCOMP] = pixelToG[(p >> 5) & 0x3f];
-                  rgba[n][BCOMP] = pixelToB[p & 0x1f];
-                  rgba[n][ACOMP] = 255;
-               }
-#else
-               for (i = 0; i < n; i++) {
-                  const GLushort p = ptr2[i];
-                  rgba[i][RCOMP] = pixelToR[p >> 11];
-                  rgba[i][GCOMP] = pixelToG[(p >> 5) & 0x3f];
-                  rgba[i][BCOMP] = pixelToB[p & 0x1f];
-                  rgba[i][ACOMP] = 255;
-               }
-#endif
-            }
-            break;
-	 case PF_8A8B8G8R:
-            {
-               const GLuint *ptr4 = PIXELADDR4( source, x, y );
-               GLuint i;
-               for (i=0;i<n;i++) {
-                  GLuint p4 = *ptr4++;
-                  rgba[i][RCOMP] = (GLubyte) ( p4        & 0xff);
-                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
-                  rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
-                  rgba[i][ACOMP] = (GLint)   ((p4 >> 24) & 0xff);
-               }
-            }
-	    break;
-	 case PF_8R8G8B:
-            {
-               const GLuint *ptr4 = PIXELADDR4( source, x, y );
-               GLuint i;
-               for (i=0;i<n;i++) {
-                  GLuint p4 = *ptr4++;
-                  rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
-                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
-                  rgba[i][BCOMP] = (GLubyte) ( p4        & 0xff);
-                  rgba[i][ACOMP] = 255;
-               }
-            }
-	    break;
-	 case PF_8R8G8B24:
-            {
-               const bgr_t *ptr3 = PIXELADDR3( source, x, y );
-               GLuint i;
-               for (i=0;i<n;i++) {
-                  rgba[i][RCOMP] = ptr3[i].r;
-                  rgba[i][GCOMP] = ptr3[i].g;
-                  rgba[i][BCOMP] = ptr3[i].b;
-                  rgba[i][ACOMP] = 255;
-               }
-            }
-	    break;
-         case PF_HPCR:
-            {
-               const GLubyte *ptr1 = PIXELADDR1( source, x, y );
-               GLuint i;
-               for (i=0;i<n;i++) {
-                  GLubyte p = *ptr1++;
-                  rgba[i][RCOMP] =  p & 0xE0;
-                  rgba[i][GCOMP] = (p & 0x1C) << 3;
-                  rgba[i][BCOMP] = (p & 0x03) << 6;
-                  rgba[i][ACOMP] = 255;
-               }
-            }
-            break;
-	 case PF_DITHER:
-	 case PF_LOOKUP:
-	 case PF_GRAYSCALE:
-            {
-               const GLubyte *rTable = source->pixel_to_r;
-               const GLubyte *gTable = source->pixel_to_g;
-               const GLubyte *bTable = source->pixel_to_b;
-               if (GET_VISUAL_DEPTH(xmesa->xm_visual)==8) {
-                  GLubyte *ptr1 = PIXELADDR1( source, x, y );
-                  GLuint i;
-                  for (i=0;i<n;i++) {
-                     unsigned long p = *ptr1++;
-                     rgba[i][RCOMP] = rTable[p];
-                     rgba[i][GCOMP] = gTable[p];
-                     rgba[i][BCOMP] = bTable[p];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-               else {
-                  XMesaImage *img = source->backimage;
-                  GLuint i;
-                  y = FLIP(source, y);
-                  for (i=0;i<n;i++,x++) {
-                     unsigned long p = XMesaGetPixel( img, x, y );
-                     rgba[i][RCOMP] = rTable[p];
-                     rgba[i][GCOMP] = gTable[p];
-                     rgba[i][BCOMP] = bTable[p];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-            }
-	    break;
-	 case PF_1BIT:
-            {
-               XMesaImage *img = source->backimage;
-               int bitFlip = xmesa->xm_visual->bitFlip;
-               GLuint i;
-               y = FLIP(source, y);
-               for (i=0;i<n;i++,x++) {
-                  unsigned long p;
-		  p = XMesaGetPixel( img, x, y ) ^ bitFlip;
-                  rgba[i][RCOMP] = (GLubyte) (p * 255);
-                  rgba[i][GCOMP] = (GLubyte) (p * 255);
-                  rgba[i][BCOMP] = (GLubyte) (p * 255);
-                  rgba[i][ACOMP] = 255;
-               }
-	    }
-	    break;
-	 default:
-	    gl_problem(NULL,"Problem in DD.read_color_span (2)");
-            return;
-      }
-   }
-}
-
-
-
-/*
- * Read an array of color index pixels.
- */
-static void read_index_pixels( const GLcontext *ctx,
-			       GLuint n, const GLint x[], const GLint y[],
-                               GLuint indx[], const GLubyte mask[] )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   register GLuint i;
-   XMesaBuffer source;
-
-   if (xmesa->use_read_buffer)
-      source = xmesa->xm_read_buffer;
-   else
-      source = xmesa->xm_buffer;
-
-   if (source->buffer) {
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            indx[i] = (GLuint) read_pixel( xmesa->display,
-                                           source->buffer,
-                                           x[i], FLIP(source, y[i]) );
-         }
-      }
-   }
-   else if (source->backimage) {
-      XMesaImage *img = source->backimage;
-      for (i=0;i<n;i++) {
-         if (mask[i]) {
-            indx[i] = (GLuint) XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
-         }
-      }
-   }
-}
-
-
-
-static void read_color_pixels( const GLcontext *ctx,
-			       GLuint n, const GLint x[], const GLint y[],
-                               GLubyte rgba[][4], const GLubyte mask[] )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   register GLuint i;
-   XMesaBuffer source;
-   XMesaDrawable buffer;
-
-   if (xmesa->use_read_buffer)
-      source = xmesa->xm_read_buffer;
-   else
-      source = xmesa->xm_buffer;
-
-   buffer = source->buffer;  /* the X drawable */
-
-   if (source->buffer) {
-      switch (xmesa->pixelformat) {
-	 case PF_TRUECOLOR:
-         case PF_TRUEDITHER:
-         case PF_5R6G5B:
-         case PF_DITHER_5R6G5B:
-            {
-               unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
-               unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
-               unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
-               GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
-               GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
-               GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
-               GLint rShift = xmesa->xm_visual->rshift;
-               GLint gShift = xmesa->xm_visual->gshift;
-               GLint bShift = xmesa->xm_visual->bshift;
-               for (i=0;i<n;i++) {
-                  if (mask[i]) {
-                     unsigned long p = read_pixel( dpy, buffer,
-                                                   x[i], FLIP(source, y[i]) );
-                     rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
-                     rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
-                     rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-            }
-            break;
-	 case PF_8A8B8G8R:
-	    for (i=0;i<n;i++) {
-               if (mask[i]) {
-                  unsigned long p = read_pixel( dpy, buffer,
-                                                x[i], FLIP(source, y[i]) );
-                  rgba[i][RCOMP] = (GLubyte) ( p        & 0xff);
-                  rgba[i][GCOMP] = (GLubyte) ((p >> 8)  & 0xff);
-                  rgba[i][BCOMP] = (GLubyte) ((p >> 16) & 0xff);
-                  rgba[i][ACOMP] = (GLubyte) ((p >> 24) & 0xff);
-               }
-	    }
-	    break;
-	 case PF_8R8G8B:
-	    for (i=0;i<n;i++) {
-               if (mask[i]) {
-                  unsigned long p = read_pixel( dpy, buffer,
-                                                x[i], FLIP(source, y[i]) );
-                  rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
-                  rgba[i][GCOMP] = (GLubyte) ((p >> 8)  & 0xff);
-                  rgba[i][BCOMP] = (GLubyte) ( p        & 0xff);
-                  rgba[i][ACOMP] = 255;
-               }
-	    }
-	    break;
-	 case PF_8R8G8B24:
-	    for (i=0;i<n;i++) {
-               if (mask[i]) {
-                  unsigned long p = read_pixel( dpy, buffer,
-                                                x[i], FLIP(source, y[i]) );
-                  rgba[i][RCOMP] = (GLubyte) ((p >> 16) & 0xff);
-                  rgba[i][GCOMP] = (GLubyte) ((p >> 8)  & 0xff);
-                  rgba[i][BCOMP] = (GLubyte) ( p        & 0xff);
-                  rgba[i][ACOMP] = 255;
-               }
-	    }
-	    break;
-         case PF_HPCR:
-            {
-               for (i=0;i<n;i++) {
-                  if (mask[i]) {
-                     unsigned long p = read_pixel( dpy, buffer,
-                                                   x[i], FLIP(source, y[i]) );
-                     rgba[i][RCOMP] = (GLubyte) ( p & 0xE0      );
-                     rgba[i][GCOMP] = (GLubyte) ((p & 0x1C) << 3);
-                     rgba[i][BCOMP] = (GLubyte) ((p & 0x03) << 6);
-                     rgba[i][ACOMP] = (GLubyte) 255;
-                  }
-               }
-            }
-            break;
-	 case PF_DITHER:
-	 case PF_LOOKUP:
-	 case PF_GRAYSCALE:
-            {
-               GLubyte *rTable = source->pixel_to_r;
-               GLubyte *gTable = source->pixel_to_g;
-               GLubyte *bTable = source->pixel_to_b;
-               for (i=0;i<n;i++) {
-                  if (mask[i]) {
-                     unsigned long p = read_pixel( dpy, buffer,
-                                                   x[i], FLIP(source, y[i]) );
-                     rgba[i][RCOMP] = rTable[p];
-                     rgba[i][GCOMP] = gTable[p];
-                     rgba[i][BCOMP] = bTable[p];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-	    }
-	    break;
-	 case PF_1BIT:
-            {
-               int bitFlip = xmesa->xm_visual->bitFlip;
-               for (i=0;i<n;i++) {
-                  if (mask[i]) {
-                     unsigned long p = read_pixel( dpy, buffer,
-                                     x[i], FLIP(source, y[i])) ^ bitFlip;
-                     rgba[i][RCOMP] = (GLubyte) (p * 255);
-                     rgba[i][GCOMP] = (GLubyte) (p * 255);
-                     rgba[i][BCOMP] = (GLubyte) (p * 255);
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-	    }
-	    break;
-	 default:
-	    gl_problem(NULL,"Problem in DD.read_color_pixels (1)");
-            return;
-      }
-   }
-   else if (source->backimage) {
-      switch (xmesa->pixelformat) {
-	 case PF_TRUECOLOR:
-         case PF_TRUEDITHER:
-         case PF_5R6G5B:
-         case PF_DITHER_5R6G5B:
-            {
-               unsigned long rMask = GET_REDMASK(xmesa->xm_visual);
-               unsigned long gMask = GET_GREENMASK(xmesa->xm_visual);
-               unsigned long bMask = GET_BLUEMASK(xmesa->xm_visual);
-               GLubyte *pixelToR = xmesa->xm_visual->PixelToR;
-               GLubyte *pixelToG = xmesa->xm_visual->PixelToG;
-               GLubyte *pixelToB = xmesa->xm_visual->PixelToB;
-               GLint rShift = xmesa->xm_visual->rshift;
-               GLint gShift = xmesa->xm_visual->gshift;
-               GLint bShift = xmesa->xm_visual->bshift;
-               XMesaImage *img = source->backimage;
-               for (i=0;i<n;i++) {
-                  if (mask[i]) {
-                     unsigned long p;
-                     p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
-                     rgba[i][RCOMP] = pixelToR[(p & rMask) >> rShift];
-                     rgba[i][GCOMP] = pixelToG[(p & gMask) >> gShift];
-                     rgba[i][BCOMP] = pixelToB[(p & bMask) >> bShift];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-            }
-            break;
-	 case PF_8A8B8G8R:
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLuint *ptr4 = PIXELADDR4( source, x[i], y[i] );
-                  GLuint p4 = *ptr4;
-                  rgba[i][RCOMP] = (GLubyte) ( p4        & 0xff);
-                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
-                  rgba[i][BCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
-                  rgba[i][ACOMP] = (GLubyte) ((p4 >> 24) & 0xff);
-               }
-	    }
-	    break;
-	 case PF_8R8G8B:
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  GLuint *ptr4 = PIXELADDR4( source, x[i], y[i] );
-                  GLuint p4 = *ptr4;
-                  rgba[i][RCOMP] = (GLubyte) ((p4 >> 16) & 0xff);
-                  rgba[i][GCOMP] = (GLubyte) ((p4 >> 8)  & 0xff);
-                  rgba[i][BCOMP] = (GLubyte) ( p4        & 0xff);
-                  rgba[i][ACOMP] = 255;
-               }
-	    }
-	    break;
-	 case PF_8R8G8B24:
-	    for (i=0;i<n;i++) {
-	       if (mask[i]) {
-                  bgr_t *ptr3 = PIXELADDR3( source, x[i], y[i] );
-                  rgba[i][RCOMP] = ptr3->r;
-                  rgba[i][GCOMP] = ptr3->g;
-                  rgba[i][BCOMP] = ptr3->b;
-                  rgba[i][ACOMP] = 255;
-               }
-	    }
-	    break;
-         case PF_HPCR:
-            for (i=0;i<n;i++) {
-               if (mask[i]) {
-                  GLubyte *ptr1 = PIXELADDR1( source, x[i], y[i] );
-                  GLubyte p = *ptr1;
-                  rgba[i][RCOMP] =  p & 0xE0;
-                  rgba[i][GCOMP] = (p & 0x1C) << 3;
-                  rgba[i][BCOMP] = (p & 0x03) << 6;
-                  rgba[i][ACOMP] = 255;
-               }
-            }
-            break;
-	 case PF_DITHER:
-	 case PF_LOOKUP:
-	 case PF_GRAYSCALE:
-            {
-               GLubyte *rTable = source->pixel_to_r;
-               GLubyte *gTable = source->pixel_to_g;
-               GLubyte *bTable = source->pixel_to_b;
-               XMesaImage *img = source->backimage;
-               for (i=0;i<n;i++) {
-                  if (mask[i]) {
-                     unsigned long p;
-                     p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) );
-                     rgba[i][RCOMP] = rTable[p];
-                     rgba[i][GCOMP] = gTable[p];
-                     rgba[i][BCOMP] = bTable[p];
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-	    }
-	    break;
-	 case PF_1BIT:
-            {
-               XMesaImage *img = source->backimage;
-               int bitFlip = xmesa->xm_visual->bitFlip;
-               for (i=0;i<n;i++) {
-                  if (mask[i]) {
-                     unsigned long p;
-                     p = XMesaGetPixel( img, x[i], FLIP(source, y[i]) ) ^ bitFlip;
-                     rgba[i][RCOMP] = (GLubyte) (p * 255);
-                     rgba[i][GCOMP] = (GLubyte) (p * 255);
-                     rgba[i][BCOMP] = (GLubyte) (p * 255);
-                     rgba[i][ACOMP] = 255;
-                  }
-               }
-	    }
-	    break;
-	 default:
-	    gl_problem(NULL,"Problem in DD.read_color_pixels (1)");
-            return;
-      }
-   }
-}
-
-
-
-#ifndef XFree86Server
-/*
- * This function implements glDrawPixels() with an XPutImage call when
- * drawing to the front buffer (X Window drawable).
- * The image format must be GL_BGRA to match the PF_8R8G8B pixel format.
- * XXX top/bottom edge clipping is broken!
- */
-static GLboolean
-drawpixels_8R8G8B( GLcontext *ctx,
-                   GLint x, GLint y, GLsizei width, GLsizei height,
-                   GLenum format, GLenum type,
-                   const struct gl_pixelstore_attrib *unpack,
-                   const GLvoid *pixels )
-{
-   const XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc1;
-   assert(dpy);
-   assert(buffer);
-   assert(gc);
-
-   /* XXX also check for pixel scale/bias/lookup/zooming! */
-   if (format == GL_BGRA && type == GL_UNSIGNED_BYTE) {
-      int dstX = x;
-      int dstY = y;
-      int w = width;
-      int h = height;
-      int srcX = unpack->SkipPixels;
-      int srcY = unpack->SkipRows;
-      if (_mesa_clip_pixelrect(ctx, &dstX, &dstY, &w, &h, &srcX, &srcY)) {
-         XMesaImage ximage;
-         MEMSET(&ximage, 0, sizeof(XMesaImage));
-         ximage.width = width;
-         ximage.height = height;
-         ximage.format = ZPixmap;
-         ximage.data = (char *) pixels + (height - 1) * width * 4;
-         ximage.byte_order = LSBFirst;
-         ximage.bitmap_unit = 32;
-         ximage.bitmap_bit_order = LSBFirst;
-         ximage.bitmap_pad = 32;
-         ximage.depth = 24;
-         ximage.bytes_per_line = -width * 4;
-         ximage.bits_per_pixel = 32;
-         ximage.red_mask   = 0xff0000;
-         ximage.green_mask = 0x00ff00;
-         ximage.blue_mask  = 0x0000ff;
-         dstY = FLIP(xmesa->xm_buffer,dstY) - height + 1;
-         XPutImage(dpy, buffer, gc, &ximage, srcX, srcY, dstX, dstY, w, h);
-         return GL_TRUE;
-      }
-   }
-   return GL_FALSE;
-}
-#endif
-
-
-
-
-static const GLubyte *get_string( GLcontext *ctx, GLenum name )
-{
-   (void) ctx;
-   switch (name) {
-      case GL_RENDERER:
-#ifdef XFree86Server
-         return (const GLubyte *) "Mesa GLX Indirect";
-#else
-         return (const GLubyte *) "Mesa X11";
-#endif
-      case GL_VENDOR:
-#ifdef XFree86Server
-         return (const GLubyte *) "VA Linux Systems, Inc.";
-#else
-         return NULL;
-#endif
-      default:
-         return NULL;
-   }
-}
-
-
-static void update_span_funcs( GLcontext *ctx )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int depth=GET_VISUAL_DEPTH(xmesa->xm_visual);
-
-   /*
-    * These drawing functions depend on color buffer config:
-    */
-   if (xmesa->xm_buffer->buffer!=XIMAGE) {
-      /* Writing to window or back pixmap */
-      switch (xmesa->pixelformat) {
-	 case PF_INDEX:
-	    ctx->Driver.WriteCI32Span     = write_span_index_pixmap;
-	    ctx->Driver.WriteCI8Span      = write_span_index8_pixmap;
-	    ctx->Driver.WriteMonoCISpan   = write_span_mono_pixmap;
-	    ctx->Driver.WriteCI32Pixels   = write_pixels_index_pixmap;
-	    ctx->Driver.WriteMonoCIPixels = write_pixels_mono_pixmap;
-	    break;
-	 case PF_TRUECOLOR:
-	    ctx->Driver.WriteRGBASpan       = write_span_TRUECOLOR_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_TRUECOLOR_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_TRUECOLOR_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-	    break;
-	 case PF_TRUEDITHER:
-	    ctx->Driver.WriteRGBASpan       = write_span_TRUEDITHER_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_TRUEDITHER_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_TRUEDITHER_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_TRUEDITHER_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
-	    break;
-	 case PF_8A8B8G8R:
-	    ctx->Driver.WriteRGBASpan       = write_span_8A8B8G8R_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_8A8B8G8R_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_8A8B8G8R_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-	    break;
-	 case PF_8R8G8B:
-	    ctx->Driver.WriteRGBASpan       = write_span_8R8G8B_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_8R8G8B_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_8R8G8B_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-            ctx->Driver.DrawPixels          = NULL; /*drawpixels_8R8G8B;*/
-	    break;
-	 case PF_8R8G8B24:
-	    ctx->Driver.WriteRGBASpan       = write_span_8R8G8B24_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_8R8G8B24_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_8R8G8B24_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-	    break;
-	 case PF_5R6G5B:
-	    ctx->Driver.WriteRGBASpan       = write_span_5R6G5B_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_5R6G5B_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_5R6G5B_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-	    break;
-	 case PF_DITHER_5R6G5B:
-	    ctx->Driver.WriteRGBASpan       = write_span_DITHER_5R6G5B_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_DITHER_5R6G5B_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_TRUEDITHER_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_DITHER_5R6G5B_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_pixmap;
-	    break;
-	 case PF_DITHER:
-	    ctx->Driver.WriteRGBASpan       = write_span_DITHER_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_DITHER_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_DITHER_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_DITHER_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER_pixmap;
-	    break;
-	 case PF_1BIT:
-	    ctx->Driver.WriteRGBASpan       = write_span_1BIT_pixmap;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_1BIT_pixmap;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_1BIT_pixmap;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_1BIT_pixmap;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_1BIT_pixmap;
-	    break;
-         case PF_HPCR:
-            ctx->Driver.WriteRGBASpan       = write_span_HPCR_pixmap;
-            ctx->Driver.WriteRGBSpan        = write_span_rgb_HPCR_pixmap;
-            ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-            ctx->Driver.WriteRGBAPixels     = write_pixels_HPCR_pixmap;
-            ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-	    if (xmesa->xm_visual->hpcr_clear_flag) {
-   		ctx->Driver.ClearColor = clear_color_HPCR_pixmap;
-	    }
-            break;
-         case PF_LOOKUP:
-            ctx->Driver.WriteRGBASpan       = write_span_LOOKUP_pixmap;
-            ctx->Driver.WriteRGBSpan        = write_span_rgb_LOOKUP_pixmap;
-            ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-            ctx->Driver.WriteRGBAPixels     = write_pixels_LOOKUP_pixmap;
-            ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-            break;
-         case PF_GRAYSCALE:
-            ctx->Driver.WriteRGBASpan       = write_span_GRAYSCALE_pixmap;
-            ctx->Driver.WriteRGBSpan        = write_span_rgb_GRAYSCALE_pixmap;
-            ctx->Driver.WriteMonoRGBASpan   = write_span_mono_pixmap;
-            ctx->Driver.WriteRGBAPixels     = write_pixels_GRAYSCALE_pixmap;
-            ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_pixmap;
-            break;
-	 default:
-	    gl_problem(NULL,"Bad pixel format in xmesa_update_state (1)");
-            return;
-      }
-   }
-   else if (xmesa->xm_buffer->buffer==XIMAGE) {
-      /* Writing to back XImage */
-      switch (xmesa->pixelformat) {
-	 case PF_INDEX:
-	    ctx->Driver.WriteCI32Span     = write_span_index_ximage;
-	    if (depth==8)
-               ctx->Driver.WriteCI8Span   = write_span_index8_ximage8;
-            else
-               ctx->Driver.WriteCI8Span   = write_span_index8_ximage;
-	    ctx->Driver.WriteMonoCISpan   = write_span_mono_ximage;
-	    ctx->Driver.WriteCI32Pixels   = write_pixels_index_ximage;
-	    ctx->Driver.WriteMonoCIPixels = write_pixels_mono_ximage;
-	    break;
-	 case PF_TRUECOLOR:
-	    /* Generic RGB */
-	    ctx->Driver.WriteRGBASpan       = write_span_TRUECOLOR_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_TRUECOLOR_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_TRUECOLOR_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
-	    break;
-	 case PF_TRUEDITHER:
-	    ctx->Driver.WriteRGBASpan       = write_span_TRUEDITHER_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_TRUEDITHER_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_TRUEDITHER_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_TRUEDITHER_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_TRUEDITHER_ximage;
-	    break;
-	 case PF_8A8B8G8R:
-	    ctx->Driver.WriteRGBASpan       = write_span_8A8B8G8R_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_8A8B8G8R_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_8A8B8G8R_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_8A8B8G8R_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_8A8B8G8R_ximage;
-	    break;
-	 case PF_8R8G8B:
-	    ctx->Driver.WriteRGBASpan       = write_span_8R8G8B_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_8R8G8B_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_8R8G8B_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_8R8G8B_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_8R8G8B_ximage;
-            ctx->Driver.DrawPixels          = NULL;
-	    break;
-	 case PF_8R8G8B24:
-	    ctx->Driver.WriteRGBASpan       = write_span_8R8G8B24_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_8R8G8B24_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_8R8G8B24_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_8R8G8B24_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_8R8G8B24_ximage;
-	    break;
-	 case PF_5R6G5B:
-	    ctx->Driver.WriteRGBASpan       = write_span_5R6G5B_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_5R6G5B_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_5R6G5B_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
-	    break;
-	 case PF_DITHER_5R6G5B:
-	    ctx->Driver.WriteRGBASpan       = write_span_DITHER_5R6G5B_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_DITHER_5R6G5B_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_DITHER_5R6G5B_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_DITHER_5R6G5B_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER_5R6G5B_ximage;
-	    break;
-	 case PF_DITHER:
-	    if (depth==8) {
-	       ctx->Driver.WriteRGBASpan      = write_span_DITHER8_ximage;
-	       ctx->Driver.WriteRGBSpan       = write_span_rgb_DITHER8_ximage;
-	       ctx->Driver.WriteMonoRGBASpan  = write_span_mono_DITHER8_ximage;
-	       ctx->Driver.WriteRGBAPixels    = write_pixels_DITHER8_ximage;
-	       ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER8_ximage;
-	    }
-	    else {
-	       ctx->Driver.WriteRGBASpan       = write_span_DITHER_ximage;
-	       ctx->Driver.WriteRGBSpan        = write_span_rgb_DITHER_ximage;
-	       ctx->Driver.WriteMonoRGBASpan   = write_span_mono_DITHER_ximage;
-	       ctx->Driver.WriteRGBAPixels     = write_pixels_DITHER_ximage;
-	       ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_DITHER_ximage;
-	    }
-	    break;
-	 case PF_1BIT:
-	    ctx->Driver.WriteRGBASpan       = write_span_1BIT_ximage;
-	    ctx->Driver.WriteRGBSpan        = write_span_rgb_1BIT_ximage;
-	    ctx->Driver.WriteMonoRGBASpan   = write_span_mono_1BIT_ximage;
-	    ctx->Driver.WriteRGBAPixels     = write_pixels_1BIT_ximage;
-	    ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_1BIT_ximage;
-	    break;
-         case PF_HPCR:
-            ctx->Driver.WriteRGBASpan       = write_span_HPCR_ximage;
-            ctx->Driver.WriteRGBSpan        = write_span_rgb_HPCR_ximage;
-            ctx->Driver.WriteMonoRGBASpan   = write_span_mono_HPCR_ximage;
-            ctx->Driver.WriteRGBAPixels     = write_pixels_HPCR_ximage;
-            ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_HPCR_ximage;
-	    if (xmesa->xm_visual->hpcr_clear_flag) {
-               ctx->Driver.ClearColor = clear_color_HPCR_ximage;
-	    }
-            break;
-         case PF_LOOKUP:
-	    if (depth==8) {
-               ctx->Driver.WriteRGBASpan       = write_span_LOOKUP8_ximage;
-               ctx->Driver.WriteRGBSpan        = write_rgb_LOOKUP8_ximage;
-               ctx->Driver.WriteMonoRGBASpan   = write_span_mono_LOOKUP8_ximage;
-               ctx->Driver.WriteRGBAPixels     = write_pixels_LOOKUP8_ximage;
-               ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_LOOKUP8_ximage;
-            }
-            else {
-               ctx->Driver.WriteRGBASpan       = write_span_LOOKUP_ximage;
-               ctx->Driver.WriteRGBSpan        = write_span_rgb_LOOKUP_ximage;
-               ctx->Driver.WriteMonoRGBASpan   = write_span_mono_ximage;
-               ctx->Driver.WriteRGBAPixels     = write_pixels_LOOKUP_ximage;
-               ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
-            }
-            break;
-         case PF_GRAYSCALE:
-	    if (depth==8) {
-	       ctx->Driver.WriteRGBASpan       = write_span_GRAYSCALE8_ximage;
-	       ctx->Driver.WriteRGBSpan        = write_span_rgb_GRAYSCALE8_ximage;
-	       ctx->Driver.WriteMonoRGBASpan   = write_span_mono_GRAYSCALE8_ximage;
-	       ctx->Driver.WriteRGBAPixels     = write_pixels_GRAYSCALE8_ximage;
-	       ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_GRAYSCALE8_ximage;
-	    }
-	    else {
-	       ctx->Driver.WriteRGBASpan       = write_span_GRAYSCALE_ximage;
-	       ctx->Driver.WriteRGBSpan        = write_span_rgb_GRAYSCALE_ximage;
-	       ctx->Driver.WriteMonoRGBASpan   = write_span_mono_ximage;
-	       ctx->Driver.WriteRGBAPixels     = write_pixels_GRAYSCALE_ximage;
-	       ctx->Driver.WriteMonoRGBAPixels = write_pixels_mono_ximage;
-	    }
-	    break;
-	 default:
-	    gl_problem(NULL,"Bad pixel format in xmesa_update_state (2)");
-            return;
-      }
-   }
-
-   /* Pixel/span reading functions: */
-   ctx->Driver.ReadCI32Span = read_index_span;
-   ctx->Driver.ReadRGBASpan = read_color_span;
-   ctx->Driver.ReadCI32Pixels = read_index_pixels;
-   ctx->Driver.ReadRGBAPixels = read_color_pixels;
-}
-
-
-/*
- * Initialize all the DD.* function pointers depending on the color
- * buffer configuration.  This is mainly called by XMesaMakeCurrent.
- */
-void xmesa_update_state( GLcontext *ctx )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   /*int depth=GET_VISUAL_DEPTH(xmesa->xm_visual);*/
-
-   (void) DitherValues;  /* silenced unused var warning */
-#ifndef XFree86Server
-   (void) drawpixels_8R8G8B;
-#endif
-
-   /*
-    * Always the same:
-    */
-   ctx->Driver.GetString = get_string;
-   ctx->Driver.UpdateState = xmesa_update_state;
-   ctx->Driver.GetBufferSize = get_buffer_size;
-   ctx->Driver.Flush = flush;
-   ctx->Driver.Finish = finish;
-   
-   ctx->Driver.RenderStart = 0;
-   ctx->Driver.RenderFinish = 0;
-
-   ctx->Driver.SetDrawBuffer = set_draw_buffer;
-   ctx->Driver.SetReadBuffer = set_read_buffer;
-
-   ctx->Driver.Index = set_index;
-   ctx->Driver.Color = set_color;
-   ctx->Driver.ClearIndex = clear_index;
-   ctx->Driver.ClearColor = clear_color;
-   ctx->Driver.Clear = clear_buffers;
-   ctx->Driver.IndexMask = index_mask;
-   ctx->Driver.ColorMask = color_mask;
-   ctx->Driver.LogicOp = logicop;
-   ctx->Driver.Dither = dither;
-
-   ctx->Driver.PointsFunc = xmesa_get_points_func( ctx );
-   ctx->Driver.LineFunc = xmesa_get_line_func( ctx );
-   ctx->Driver.TriangleFunc = xmesa_get_triangle_func( ctx );
-
-/*     ctx->Driver.TriangleCaps = DD_TRI_CULL; */
-
-   /* setup pointers to front and back buffer clear functions */
-   /* XXX this bit of code could be moved to a one-time init */
-   xmesa->xm_buffer->front_clear_func = clear_front_pixmap;
-   if (xmesa->xm_buffer->backpixmap != XIMAGE) {
-      /* back buffer is a pixmap */
-      xmesa->xm_buffer->back_clear_func = clear_back_pixmap;
-   }
-   else if (sizeof(GLushort)!=2 || sizeof(GLuint)!=4) {
-      /* Do this on Crays */
-      xmesa->xm_buffer->back_clear_func = clear_nbit_ximage;
-   }
-   else {
-      /* Do this on most machines */
-      switch (xmesa->xm_visual->BitsPerPixel) {
-         case 8:
-	    if (xmesa->xm_visual->hpcr_clear_flag) {
-               xmesa->xm_buffer->back_clear_func = clear_HPCR_ximage;
-            }
-            else {
-               xmesa->xm_buffer->back_clear_func = clear_8bit_ximage;
-            }
-            break;
-         case 16:
-            xmesa->xm_buffer->back_clear_func = clear_16bit_ximage;
-            break;
-         case 24:
-            xmesa->xm_buffer->back_clear_func = clear_24bit_ximage;
-            break;
-         case 32:
-            xmesa->xm_buffer->back_clear_func = clear_32bit_ximage;
-            break;
-         default:
-            xmesa->xm_buffer->back_clear_func = clear_nbit_ximage;
-            break;
-      }
-   }
-
-   update_span_funcs(ctx);
-}
Index: xc/extras/Mesa/src/X/xmesa3.c
diff -u xc/extras/Mesa/src/X/xmesa3.c:1.11 xc/extras/Mesa/src/X/xmesa3.c:removed
--- xc/extras/Mesa/src/X/xmesa3.c:1.11	Tue Dec 11 04:18:55 2001
+++ xc/extras/Mesa/src/X/xmesa3.c	Thu Feb 27 12:15:53 2003
@@ -1,756 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/X/xmesa3.c,v 1.11 2001/12/11 09:18:55 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Mesa/X11 interface, part 3.
- *
- * This file contains "accelerated" point, line, and triangle functions.
- * It should be fairly easy to write new special-purpose point, line or
- * triangle functions and hook them into this module.
- */
-
-
-#include "glxheader.h"
-#include "depth.h"
-#include "macros.h"
-#include "mmath.h"
-#include "vb.h"
-#include "types.h"
-#include "xmesaP.h"
-
-
-
-/**********************************************************************/
-/***                    Point rendering                             ***/
-/**********************************************************************/
-
-
-/*
- * Render an array of points into a pixmap, any pixel format.
- */
-static void draw_points_ANY_pixmap( GLcontext *ctx, GLuint first, GLuint last )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaDisplay *dpy = xmesa->xm_visual->display;
-   XMesaDrawable buffer = xmesa->xm_buffer->buffer;
-   XMesaGC gc = xmesa->xm_buffer->gc2;
-   struct vertex_buffer *VB = ctx->VB;
-   register GLuint i;
-
-   if (xmesa->xm_visual->gl_visual->RGBAflag) {
-      /* RGB mode */
-      for (i=first;i<last;i++) {
-         if (VB->ClipMask[i]==0) {
-            register int x, y;
-	    const GLubyte *color = VB->ColorPtr->data[i];
-            unsigned long pixel = xmesa_color_to_pixel( xmesa,
-                          color[0], color[1], color[2], color[3], xmesa->pixelformat);
-	    GLfloat *win = VB->Win.data[i];
-
-	    if (IS_INF_OR_NAN(win[0] + win[1]))
-		    continue;
-
-            XMesaSetForeground( dpy, gc, pixel );
-            x =                         (GLint) win[0];
-            y = FLIP( xmesa->xm_buffer, (GLint) win[1] );
-            XMesaDrawPoint( dpy, buffer, gc, x, y);
-         }
-      }
-   }
-   else {
-      /* Color index mode */
-      for (i=first;i<=last;i++) {
-         if (VB->ClipMask[i]==0) {
-            register int x, y;
-	    GLfloat *win = VB->Win.data[i];
-
-	    if (IS_INF_OR_NAN(win[0] + win[1]))
-		    continue;
-
-            XMesaSetForeground( dpy, gc, VB->IndexPtr->data[i] );
-            x =                         (GLint) win[0];
-            y = FLIP( xmesa->xm_buffer, (GLint) win[1] );
-            XMesaDrawPoint( dpy, buffer, gc, x, y);
-         }
-      }
-   }
-}
-
-
-
-/*
- * Analyze context state to see if we can provide a fast points drawing
- * function, like those in points.c.  Otherwise, return NULL.
- */
-points_func xmesa_get_points_func( GLcontext *ctx )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-
-   if (ctx->Point.Size==1.0F && !ctx->Point.SmoothFlag && ctx->RasterMask==0
-       && !ctx->Texture.ReallyEnabled) {
-      if (xmesa->xm_buffer->buffer==XIMAGE) {
-         return (points_func)NULL; /*draw_points_ximage;*/
-      }
-      else {
-         return draw_points_ANY_pixmap;
-      }
-   }
-   else {
-      return (points_func)NULL;
-   }
-}
-
-
-
-/**********************************************************************/
-/***                      Line rendering                            ***/
-/**********************************************************************/
-#if 0
-/*
- * Render a line into a pixmap, any pixel format.
- */
-static void flat_pixmap_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   struct vertex_buffer *VB = ctx->VB;
-   register int x0, y0, x1, y1;
-   XMesaGC gc;
-   unsigned long pixel;
-   if (xmesa->xm_visual->gl_visual->RGBAflag) {
-      const GLubyte *color = VB->ColorPtr->data[pv];
-      pixel = xmesa_color_to_pixel( xmesa, color[0], color[1], color[2], color[3],
-                                    xmesa->pixelformat );
-   }
-   else {
-      pixel = VB->IndexPtr->data[pv];
-   }
-   gc = xmesa->xm_buffer->gc2;
-   XMesaSetForeground( xmesa->display, gc, pixel );
-
-   x0 =                         (GLint) VB->Win.data[vert0][0];
-   y0 = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[vert0][1] );
-   x1 =                         (GLint) VB->Win.data[vert1][0];
-   y1 = FLIP( xmesa->xm_buffer, (GLint) VB->Win.data[vert1][1] );
-   XMesaDrawLine( xmesa->display, xmesa->xm_buffer->buffer, gc,
-		  x0, y0, x1, y1 );
-}
-#endif
-
-
-/*
- * Draw a flat-shaded, PF_TRUECOLOR line into an XImage.
- */
-static void flat_TRUECOLOR_line( GLcontext *ctx,
-                                 GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   unsigned long pixel;
-   PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
-
-#define INTERP_XY 1
-#define CLIP_HACK 1
-#define PLOT(X,Y) XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel );
-
-#include "linetemp.h"
-}
-
-
-
-/*
- * Draw a flat-shaded, PF_8A8B8G8R line into an XImage.
- */
-static void flat_8A8B8G8R_line( GLcontext *ctx,
-                                GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
-
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) *pixelPtr = pixel;
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, PF_8R8G8B line into an XImage.
- */
-static void flat_8R8G8B_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
-
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) *pixelPtr = pixel;
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, PF_8R8G8B24 line into an XImage.
- */
-static void flat_8R8G8B24_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-
-#define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) {			\
-      pixelPtr->r = color[RCOMP];	\
-      pixelPtr->g = color[GCOMP];	\
-      pixelPtr->b = color[BCOMP];	\
-}
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, PF_5R6G5B line into an XImage.
- */
-static void flat_5R6G5B_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
-
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) *pixelPtr = pixel;
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, PF_DITHER_5R6G5B line into an XImage.
- */
-static void flat_DITHER_5R6G5B_line( GLcontext *ctx,
-                                     GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) PACK_TRUEDITHER( *pixelPtr, X, Y, color[0], color[1], color[2] );
-
-#include "linetemp.h"
-}
-
-
-
-/*
- * Draw a flat-shaded, PF_DITHER 8-bit line into an XImage.
- */
-static void flat_DITHER8_line( GLcontext *ctx,
-                               GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLint r = color[0], g = color[1], b = color[2];
-   DITHER_SETUP;
-
-#define INTERP_XY 1
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) *pixelPtr = DITHER(X,Y,r,g,b);
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, PF_LOOKUP 8-bit line into an XImage.
- */
-static void flat_LOOKUP8_line( GLcontext *ctx,
-                               GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLubyte pixel;
-   LOOKUP_SETUP;
-   pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
-
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) *pixelPtr = pixel;
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, PF_HPCR line into an XImage.
- */
-static void flat_HPCR_line( GLcontext *ctx,
-                            GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLint r = color[0], g = color[1], b = color[2];
-
-#define INTERP_XY 1
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y) *pixelPtr = (GLubyte) DITHER_HPCR(X,Y,r,g,b);
-
-#include "linetemp.h"
-}
-
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_TRUECOLOR line into an XImage.
- */
-static void flat_TRUECOLOR_z_line( GLcontext *ctx,
-                                   GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   unsigned long pixel;
-   PACK_TRUECOLOR( pixel, color[0], color[1], color[2] );
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define CLIP_HACK 1
-#define PLOT(X,Y)							\
-	if (Z < *zPtr) {						\
-	   *zPtr = Z;							\
-           XMesaPutPixel( img, X, FLIP(xmesa->xm_buffer, Y), pixel );	\
-	}
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_8A8B8G8R line into an XImage.
- */
-static void flat_8A8B8G8R_z_line( GLcontext *ctx,
-                                  GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)		\
-	if (Z < *zPtr) {	\
-	   *zPtr = Z;		\
-	   *pixelPtr = pixel;	\
-	}
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_8R8G8B line into an XImage.
- */
-static void flat_8R8G8B_z_line( GLcontext *ctx,
-                                GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)		\
-	if (Z < *zPtr) {	\
-	   *zPtr = Z;		\
-	   *pixelPtr = pixel;	\
-	}
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_8R8G8B24 line into an XImage.
- */
-static void flat_8R8G8B24_z_line( GLcontext *ctx,
-                                    GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)			\
-	if (Z < *zPtr) {		\
-	   *zPtr = Z;			\
-           pixelPtr->r = color[RCOMP];	\
-           pixelPtr->g = color[GCOMP];	\
-           pixelPtr->b = color[BCOMP];	\
-	}
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_5R6G5B line into an XImage.
- */
-static void flat_5R6G5B_z_line( GLcontext *ctx,
-                                GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLushort pixel = PACK_5R6G5B( color[0], color[1], color[2] );
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)		\
-	if (Z < *zPtr) {	\
-	   *zPtr = Z;		\
-	   *pixelPtr = pixel;	\
-	}
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_DITHER_5R6G5B line into an XImage.
- */
-static void flat_DITHER_5R6G5B_z_line( GLcontext *ctx,
-                                       GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)		\
-	if (Z < *zPtr) {	\
-	   *zPtr = Z;		\
-	   PACK_TRUEDITHER(*pixelPtr, X, Y, color[0], color[1], color[2]); \
-	}
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_DITHER 8-bit line into an XImage.
- */
-static void flat_DITHER8_z_line( GLcontext *ctx,
-                                 GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLint r = color[0], g = color[1], b = color[2];
-   DITHER_SETUP;
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)						\
-	if (Z < *zPtr) {					\
-	   *zPtr = Z;						\
-	   *pixelPtr = (GLubyte) DITHER( X, Y, r, g, b);	\
-	}
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_LOOKUP 8-bit line into an XImage.
- */
-static void flat_LOOKUP8_z_line( GLcontext *ctx,
-                                 GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLubyte pixel;
-   LOOKUP_SETUP;
-   pixel = (GLubyte) LOOKUP( color[0], color[1], color[2] );
-
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)		\
-	if (Z < *zPtr) {	\
-	   *zPtr = Z;		\
-	   *pixelPtr = pixel;	\
-	}
-
-#include "linetemp.h"
-}
-
-
-/*
- * Draw a flat-shaded, Z-less, PF_HPCR line into an XImage.
- */
-static void flat_HPCR_z_line( GLcontext *ctx,
-                              GLuint vert0, GLuint vert1, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-   GLint r = color[0], g = color[1], b = color[2];
-
-#define INTERP_XY 1
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define CLIP_HACK 1
-#define PLOT(X,Y)						\
-	if (Z < *zPtr) {					\
-	   *zPtr = Z;						\
-	   *pixelPtr = (GLubyte) DITHER_HPCR( X, Y, r, g, b);	\
-	}
-
-#include "linetemp.h"
-}
-
-#if 0
-/*
- * Examine ctx->Line attributes and set xmesa->xm_buffer->gc1
- * and xmesa->xm_buffer->gc2 appropriately.
- */
-static void setup_x_line_options( GLcontext *ctx )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int i, state, state0, new_state, len, offs;
-   int tbit;
-   char *dptr;
-   int n_segments = 0;
-   char dashes[20];
-   int line_width, line_style;
-
-   /*** Line Stipple ***/
-   if (ctx->Line.StippleFlag) {
-      const int pattern = ctx->Line.StipplePattern;
-
-      dptr = dashes;
-      state0 = state = ((pattern & 1) != 0);
-
-      /* Decompose the pattern */
-      for (i=1,tbit=2,len=1;i<16;++i,tbit=(tbit<<1))
-	{
-	  new_state = ((tbit & pattern) != 0);
-	  if (state != new_state)
-	    {
-	      *dptr++ = ctx->Line.StippleFactor * len;
-	      len = 1;
-	      state = new_state;
-	    }
-	  else
-	    ++len;
-	}
-      *dptr = ctx->Line.StippleFactor * len;
-      n_segments = 1 + (dptr - dashes);
-
-      /* ensure an even no. of segments, or X may toggle on/off for consecutive patterns */
-      /* if (n_segments & 1)  dashes [n_segments++] = 0;  value of 0 not allowed in dash list */
-
-      /* Handle case where line style starts OFF */
-      if (state0 == 0)
-        offs = dashes[0];
-      else
-        offs = 0;
-
-#if 0
-fprintf (stderr, "input pattern: 0x%04x, offset %d, %d segments:", pattern, offs, n_segments);
-for (i = 0;  i < n_segments;  i++)
-fprintf (stderr, " %d", dashes[i]);
-fprintf (stderr, "\n");
-#endif
-
-      XMesaSetDashes( xmesa->display, xmesa->xm_buffer->gc1,
-		      offs, dashes, n_segments );
-      XMesaSetDashes( xmesa->display, xmesa->xm_buffer->gc2,
-		      offs, dashes, n_segments );
-
-      line_style = LineOnOffDash;
-   }
-   else {
-      line_style = LineSolid;
-   }
-
-   /*** Line Width ***/
-   line_width = (int) (ctx->Line.Width+0.5F);
-   if (line_width < 2) {
-      /* Use fast lines when possible */
-      line_width = 0;
-   }
-
-   /*** Set GC attributes ***/
-   XMesaSetLineAttributes( xmesa->display, xmesa->xm_buffer->gc1,
-			   line_width, line_style, CapButt, JoinBevel);
-   XMesaSetLineAttributes( xmesa->display, xmesa->xm_buffer->gc2,
-			   line_width, line_style, CapButt, JoinBevel);
-   XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc1, FillSolid );
-   XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc2, FillSolid );
-}
-#endif
-
-
-/*
- * Analyze context state to see if we can provide a fast line drawing
- * function, like those in lines.c.  Otherwise, return NULL.
- */
-line_func xmesa_get_line_func( GLcontext *ctx )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
-
-   (void) DitherValues;  /* silence unused var warning */
-   (void) kernel1;  /* silence unused var warning */
-
-   if (ctx->Line.SmoothFlag)              return (line_func)NULL;
-   if (ctx->Texture.ReallyEnabled)        return (line_func)NULL;
-   if (ctx->Light.ShadeModel!=GL_FLAT)    return (line_func)NULL;
-   /* X line stippling doesn't match OpenGL stippling */
-   if (ctx->Line.StippleFlag==GL_TRUE)    return (line_func)NULL;
-
-   if (xmesa->xm_buffer->buffer==XIMAGE
-       && ctx->RasterMask==DEPTH_BIT
-       && ctx->Depth.Func==GL_LESS
-       && ctx->Depth.Mask==GL_TRUE
-       && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-       && ctx->Line.Width==1.0F) {
-      switch (xmesa->pixelformat) {
-         case PF_TRUECOLOR:
-            return flat_TRUECOLOR_z_line;
-         case PF_8A8B8G8R:
-            return flat_8A8B8G8R_z_line;
-         case PF_8R8G8B:
-            return flat_8R8G8B_z_line;
-         case PF_8R8G8B24:
-            return flat_8R8G8B24_z_line;
-         case PF_5R6G5B:
-            return flat_5R6G5B_z_line;
-         case PF_DITHER_5R6G5B:
-            return flat_DITHER_5R6G5B_z_line;
-         case PF_DITHER:
-            return (depth==8) ? flat_DITHER8_z_line : (line_func)NULL;
-         case PF_LOOKUP:
-            return (depth==8) ? flat_LOOKUP8_z_line : (line_func)NULL;
-         case PF_HPCR:
-            return flat_HPCR_z_line;
-         default:
-            return NULL;
-      }
-   }
-   if (xmesa->xm_buffer->buffer==XIMAGE
-       && ctx->RasterMask==0
-       && ctx->Line.Width==1.0F) {
-      switch (xmesa->pixelformat) {
-         case PF_TRUECOLOR:
-            return flat_TRUECOLOR_line;
-         case PF_8A8B8G8R:
-            return flat_8A8B8G8R_line;
-         case PF_8R8G8B:
-            return flat_8R8G8B_line;
-         case PF_8R8G8B24:
-            return flat_8R8G8B24_line;
-         case PF_5R6G5B:
-            return flat_5R6G5B_line;
-         case PF_DITHER_5R6G5B:
-            return flat_DITHER_5R6G5B_line;
-         case PF_DITHER:
-            return (depth==8) ? flat_DITHER8_line : (line_func)NULL;
-         case PF_LOOKUP:
-            return (depth==8) ? flat_LOOKUP8_line : (line_func)NULL;
-         case PF_HPCR:
-            return flat_HPCR_line;
-	 default:
-	    return NULL;
-      }
-   }
-#if 0
-   /* XXX have to disable this because X's rasterization rules don't match
-    * software Mesa's.  This causes the linehv.c conformance test to fail.
-    * In the future, we might provide a config option to enable this.
-    */
-   if (xmesa->xm_buffer->buffer!=XIMAGE && ctx->RasterMask==0) {
-      setup_x_line_options( ctx );
-      return flat_pixmap_line;
-   }
-#endif
-   return (line_func)NULL;
-}
Index: xc/extras/Mesa/src/X/xmesa4.c
diff -u xc/extras/Mesa/src/X/xmesa4.c:1.10 xc/extras/Mesa/src/X/xmesa4.c:removed
--- xc/extras/Mesa/src/X/xmesa4.c:1.10	Tue Dec 11 04:18:55 2001
+++ xc/extras/Mesa/src/X/xmesa4.c	Thu Feb 27 12:15:53 2003
@@ -1,1695 +0,0 @@
-/* $XFree86: xc/extras/Mesa/src/X/xmesa4.c,v 1.10 2001/12/11 09:18:55 alanh Exp $ */
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-
-/*
- * Mesa/X11 interface, part 4.
- *
- * This file contains "accelerated" triangle functions.  It should be
- * fairly easy to write new special-purpose triangle functions and hook
- * them into this module.
- */
-
-
-#include "glxheader.h"
-#include "depth.h"
-#include "macros.h"
-#include "mmath.h"
-#include "vb.h"
-#include "types.h"
-#include "xmesaP.h"
-
-
-
-
-/**********************************************************************/
-/***                   Triangle rendering                           ***/
-/**********************************************************************/
-
-#if 0
-/*
- * Render a triangle into a pixmap, any pixel format, flat shaded and
- * no raster ops.
- */
-static void flat_pixmap_triangle( GLcontext *ctx,
-				  GLuint v0, GLuint v1, GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   struct vertex_buffer *VB = ctx->VB;
-   XMesaPoint p[3];
-   XMesaGC gc;
-
-   if (0 /*VB->MonoColor*/) {
-      gc = xmesa->xm_buffer->gc1;  /* use current color */
-   }
-   else {
-      unsigned long pixel;
-      if (xmesa->xm_visual->gl_visual->RGBAflag) {
-         pixel = xmesa_color_to_pixel( xmesa,
-                         VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1],
-                         VB->ColorPtr->data[pv][2], VB->ColorPtr->data[pv][3],
-                         xmesa->pixelformat );
-      }
-      else {
-         pixel = VB->IndexPtr->data[pv];
-      }
-      gc = xmesa->xm_buffer->gc2;
-      XMesaSetForeground( xmesa->display, gc, pixel );
-   }
-   p[0].x =                         (GLint) (VB->Win.data[v0][0] + 0.5f);
-   p[0].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v0][1] - 0.5f) );
-   p[1].x =                         (GLint) (VB->Win.data[v1][0] + 0.5f);
-   p[1].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v1][1] - 0.5f) );
-   p[2].x =                         (GLint) (VB->Win.data[v2][0] + 0.5f);
-   p[2].y = FLIP( xmesa->xm_buffer, (GLint) (VB->Win.data[v2][1] - 0.5f) );
-   XMesaFillPolygon( xmesa->display, xmesa->xm_buffer->buffer, gc,
-		     p, 3, Convex, CoordModeOrigin );
-}
-#endif
-
-
-/*
- * XImage, smooth, depth-buffered, PF_TRUECOLOR triangle.
- */
-static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
-                                         GLuint v0, GLuint v1, GLuint v2,
-                                         GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer, Y);			\
-   GLint len = RIGHT-LEFT;						\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p;						\
-         PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
-         XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-
-/*
- * XImage, smooth, depth-buffered, PF_8A8B8G8R triangle.
- */
-static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
-                                         GLuint v0, GLuint v1, GLuint v2,
-                                         GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),	\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_8R8G8B triangle.
- */
-static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
-                                         GLuint v0, GLuint v1, GLuint v2,
-                                         GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),	\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_8R8G8B24 triangle.
- */
-static void smooth_8R8G8B24_z_triangle( GLcontext *ctx,
-                                        GLuint v0, GLuint v1, GLuint v2,
-                                        GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 PIXEL_TYPE *ptr = pRow + i;					\
-         ptr->r = FixedToInt(ffr);					\
-         ptr->g = FixedToInt(ffg);					\
-         ptr->b = FixedToInt(ffb);					\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_TRUEDITHER triangle.
- */
-static void smooth_TRUEDITHER_z_triangle( GLcontext *ctx,
-                                         GLuint v0, GLuint v1, GLuint v2,
-                                         GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p;						\
-         PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr),			\
-                          FixedToInt(ffg), FixedToInt(ffb) );		\
-         XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_5R6G5B triangle.
- */
-static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
-                                      GLuint v0, GLuint v1, GLuint v2,
-                                      GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   for (i=0;i<len;i++) {						\
-      DEPTH_TYPE z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = PACK_5R6G5B( FixedToInt(ffr), FixedToInt(ffg),	\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_DITHER_5R6G5B triangle.
- */
-static void smooth_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
-                                             GLuint v0, GLuint v1, GLuint v2,
-                                             GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         PACK_TRUEDITHER(pRow[i], LEFT+i, Y, FixedToInt(ffr),		\
-			 FixedToInt(ffg), FixedToInt(ffb) );		\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, 8-bit, PF_DITHER8 triangle.
- */
-static void smooth_DITHER8_z_triangle( GLcontext *ctx,
-                                       GLuint v0, GLuint v1, GLuint v2,
-                                       GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   XDITHER_SETUP(yy);							\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr),		\
-			FixedToInt(ffg), FixedToInt(ffb) );		\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, PF_DITHER triangle.
- */
-static void smooth_DITHER_z_triangle( GLcontext *ctx,
-                                       GLuint v0, GLuint v1, GLuint v2,
-                                       GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   XDITHER_SETUP(yy);							\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 unsigned long p = XDITHER( xx, FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-	 XMesaPutPixel( img, xx, yy, p );			       	\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, depth-buffered, 8-bit PF_LOOKUP triangle.
- */
-static void smooth_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                       GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   LOOKUP_SETUP;							\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = LOOKUP( FixedToInt(ffr), FixedToInt(ffg),		\
-				 FixedToInt(ffb) );			\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-
-/*
- * XImage, smooth, depth-buffered, 8-bit PF_HPCR triangle.
- */
-static void smooth_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         pRow[i] = DITHER_HPCR( xx, yy, FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-         zRow[i] = z;							\
-      }									\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_TRUECOLOR triangle.
- */
-static void flat_TRUECOLOR_z_triangle( GLcontext *ctx,
-                        	       GLuint v0, GLuint v1, GLuint v2,
-                                       GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE						\
-   unsigned long pixel;						\
-   PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2]);
-
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         XMesaPutPixel( img, xx, yy, pixel );				\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_8A8B8G8R triangle.
- */
-static void flat_8A8B8G8R_z_triangle( GLcontext *ctx, GLuint v0,
-                        	      GLuint v1, GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE					\
-   unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0],	\
-		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, len = RIGHT-LEFT;						\
-   for (i=0;i<len;i++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 pRow[i] = (PIXEL_TYPE) p;					\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_8R8G8B triangle.
- */
-static void flat_8R8G8B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE					\
-   unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0],	\
-		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   for (i=0;i<len;i++) {				\
-      GLdepth z = FixedToDepth(ffz);			\
-      if (z < zRow[i]) {				\
-	 pRow[i] = (PIXEL_TYPE) p;			\
-         zRow[i] = z;					\
-      }							\
-      ffz += fdzdx;					\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_8R8G8B24 triangle.
- */
-static void flat_8R8G8B24_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                      GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   for (i=0;i<len;i++) {				\
-      GLdepth z = FixedToDepth(ffz);			\
-      if (z < zRow[i]) {				\
-	 PIXEL_TYPE *ptr = pRow+i;			\
-         ptr->r = color[RCOMP];				\
-         ptr->g = color[GCOMP];				\
-         ptr->b = color[BCOMP];				\
-         zRow[i] = z;					\
-      }							\
-      ffz += fdzdx;					\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_TRUEDITHER triangle.
- */
-static void flat_TRUEDITHER_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p;						\
-         PACK_TRUEDITHER( p, xx, yy, VB->ColorPtr->data[pv][0],		\
-            VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );	\
-         XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_5R6G5B triangle.
- */
-static void flat_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE							\
-   unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0],		\
-            VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   for (i=0;i<len;i++) {				\
-      DEPTH_TYPE z = FixedToDepth(ffz);			\
-      if (z < zRow[i]) {				\
-	 pRow[i] = (PIXEL_TYPE) p;			\
-         zRow[i] = z;					\
-      }							\
-      ffz += fdzdx;					\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_DITHER_5R6G5B triangle.
- */
-static void flat_DITHER_5R6G5B_z_triangle( GLcontext *ctx, GLuint v0,
-                                           GLuint v1, GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint i, len = RIGHT-LEFT;					\
-   for (i=0;i<len;i++) {					\
-      DEPTH_TYPE z = FixedToDepth(ffz);				\
-      if (z < zRow[i]) {					\
-	 PACK_TRUEDITHER(pRow[i], LEFT+i, Y, color[RCOMP],	\
-			 color[GCOMP], color[BCOMP]);		\
-         zRow[i] = z;						\
-      }								\
-      ffz += fdzdx;						\
-   }								\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, 8-bit PF_DITHER triangle.
- */
-static void flat_DITHER8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                     GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint i, xx = LEFT, len = RIGHT-LEFT;			\
-   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y));		\
-   for (i=0;i<len;i++,xx++) {					\
-      GLdepth z = FixedToDepth(ffz);				\
-      if (z < zRow[i]) {					\
-	 pRow[i] = (PIXEL_TYPE) FLAT_DITHER(xx);		\
-         zRow[i] = z;						\
-      }								\
-      ffz += fdzdx;						\
-   }								\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, PF_DITHER triangle.
- */
-static void flat_DITHER_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   FLAT_DITHER_ROW_SETUP(yy);						\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-         unsigned long p = FLAT_DITHER(xx);				\
-	 XMesaPutPixel( img, xx, yy, p );				\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, 8-bit PF_HPCR triangle.
- */
-static void flat_HPCR_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                  GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   GLubyte r = VB->ColorPtr->data[pv][0];	\
-   GLubyte g = VB->ColorPtr->data[pv][1];	\
-   GLubyte b = VB->ColorPtr->data[pv][2];
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint i, xx = LEFT, yy = FLIP(xmesa->xm_buffer,Y), len = RIGHT-LEFT;	\
-   for (i=0;i<len;i++,xx++) {						\
-      GLdepth z = FixedToDepth(ffz);					\
-      if (z < zRow[i]) {						\
-	 pRow[i] = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b );		\
-         zRow[i] = z;							\
-      }									\
-      ffz += fdzdx;							\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, depth-buffered, 8-bit PF_LOOKUP triangle.
- */
-static void flat_LOOKUP8_z_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                        	     GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define INTERP_Z 1
-#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   LOOKUP_SETUP;				\
-   GLubyte r = VB->ColorPtr->data[pv][0];	\
-   GLubyte g = VB->ColorPtr->data[pv][1];	\
-   GLubyte b = VB->ColorPtr->data[pv][2];	\
-   GLubyte p = LOOKUP(r,g,b);
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint i, len = RIGHT-LEFT;				\
-   for (i=0;i<len;i++) {				\
-      GLdepth z = FixedToDepth(ffz);			\
-      if (z < zRow[i]) {				\
-	 pRow[i] = p;					\
-         zRow[i] = z;					\
-      }							\
-      ffz += fdzdx;					\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_TRUECOLOR triangle.
- */
-static void smooth_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                       GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   (void) pv;
-#define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p;							\
-      PACK_TRUECOLOR(p, FixedToInt(ffr), FixedToInt(ffg), FixedToInt(ffb));\
-      XMesaPutPixel( img, xx, yy, p );					\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_8A8B8G8R triangle.
- */
-static void smooth_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				      GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = PACK_8B8G8R( FixedToInt(ffr), FixedToInt(ffg),		\
-				FixedToInt(ffb) );			\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
- */
-static void smooth_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = PACK_8R8G8B( FixedToInt(ffr), FixedToInt(ffg),		\
-				FixedToInt(ffb) );			\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_8R8G8B triangle.
- */
-static void smooth_8R8G8B24_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                      GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint xx;							\
-   PIXEL_TYPE *pixel = pRow;					\
-   for (xx=LEFT;xx<RIGHT;xx++) {				\
-      pixel->r = FixedToInt(ffr);				\
-      pixel->g = FixedToInt(ffg);				\
-      pixel->b = FixedToInt(ffb);				\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;		\
-      pixel++;							\
-   }								\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_TRUEDITHER triangle.
- */
-static void smooth_TRUEDITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   (void) pv;
-#define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p;							\
-      PACK_TRUEDITHER( p, xx, yy, FixedToInt(ffr), FixedToInt(ffg),	\
-				FixedToInt(ffb) );			\
-      XMesaPutPixel( img, xx, yy, p );					\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_5R6G5B triangle.
- */
-static void smooth_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = (PIXEL_TYPE) PACK_5R6G5B( FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
- */
-static void smooth_DITHER_5R6G5B_triangle( GLcontext *ctx, GLuint v0,
-                                           GLuint v1, GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      PACK_TRUEDITHER(*pixel, xx, Y, FixedToInt(ffr),			\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, 8-bit PF_DITHER triangle.
- */
-static void smooth_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				     GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   PIXEL_TYPE *pixel = pRow;						\
-   XDITHER_SETUP(yy);							\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = (PIXEL_TYPE) XDITHER( xx, FixedToInt(ffr),		\
-				 FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, PF_DITHER triangle.
- */
-static void smooth_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-   (void) pv;
-#define INTERP_RGB 1
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   XDITHER_SETUP(yy);							\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p = XDITHER( xx, FixedToInt(ffr),			\
-				FixedToInt(ffg), FixedToInt(ffb) );	\
-      XMesaPutPixel( img, xx, yy, p );					\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, smooth, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
- */
-static void smooth_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                     GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx;								\
-   PIXEL_TYPE *pixel = pRow;						\
-   LOOKUP_SETUP;							\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = LOOKUP( FixedToInt(ffr), FixedToInt(ffg),		\
-			FixedToInt(ffb) );				\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-
-/*
- * XImage, smooth, NON-depth-buffered, 8-bit PF_HPCR triangle.
- */
-static void smooth_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                  GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   (void) pv;
-#define INTERP_RGB 1
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   PIXEL_TYPE *pixel = pRow;						\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {				\
-      *pixel = DITHER_HPCR( xx, yy, FixedToInt(ffr),			\
-				FixedToInt(ffg), FixedToInt(ffb) );	\
-      ffr += fdrdx;  ffg += fdgdx;  ffb += fdbdx;			\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_TRUECOLOR triangle.
- */
-static void flat_TRUECOLOR_triangle( GLcontext *ctx, GLuint v0,
-                                     GLuint v1, GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define SETUP_CODE						\
-   unsigned long pixel;						\
-   PACK_TRUECOLOR(pixel, VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2]);
-
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);			\
-   for (xx=LEFT;xx<RIGHT;xx++) {				\
-      XMesaPutPixel( img, xx, yy, pixel );			\
-   }								\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_8A8B8G8R triangle.
- */
-static void flat_8A8B8G8R_triangle( GLcontext *ctx, GLuint v0,
-                        	    GLuint v1, GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE					\
-   unsigned long p = PACK_8B8G8R( VB->ColorPtr->data[pv][0],	\
-		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) p;				\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_8R8G8B triangle.
- */
-static void flat_8R8G8B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                  GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR4(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLuint
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE					\
-   unsigned long p = PACK_8R8G8B( VB->ColorPtr->data[pv][0],	\
-		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) p;				\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_8R8G8B24 triangle.
- */
-static void flat_8R8G8B24_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                    GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-#define PIXEL_ADDRESS(X,Y) PIXELADDR3(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE bgr_t
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++) {			\
-      pixel->r = color[RCOMP];				\
-      pixel->g = color[GCOMP];				\
-      pixel->b = color[BCOMP];				\
-      pixel++;						\
-   }							\
-}
-#include "tritemp.h"
-}
-
-/*
- * XImage, flat, NON-depth-buffered, PF_TRUEDITHER triangle.
- */
-static void flat_TRUEDITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-				      GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define INNER_LOOP( LEFT, RIGHT, Y )					\
-{									\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {					\
-      unsigned long p;							\
-      PACK_TRUEDITHER( p, xx, yy, VB->ColorPtr->data[pv][0],		\
-               VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );	\
-      XMesaPutPixel( img, xx, yy, p );					\
-   }									\
-}
-#include "tritemp.h"
-}
-
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_5R6G5B triangle.
- */
-static void flat_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                  GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE					\
-   unsigned long p = PACK_5R6G5B( VB->ColorPtr->data[pv][0],	\
-		 VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) p;				\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_DITHER_5R6G5B triangle.
- */
-static void flat_DITHER_5R6G5B_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                         GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   const GLubyte *color = ctx->VB->ColorPtr->data[pv];
-#define PIXEL_ADDRESS(X,Y) PIXELADDR2(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLushort
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      PACK_TRUEDITHER(*pixel, xx, Y, color[RCOMP],	\
-                     color[GCOMP], color[BCOMP]);	\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, 8-bit PF_DITHER triangle.
- */
-static void flat_DITHER8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                   GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx;						\
-   PIXEL_TYPE *pixel = pRow;				\
-   FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, Y));	\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {		\
-      *pixel = (PIXEL_TYPE) FLAT_DITHER(xx);		\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, PF_DITHER triangle.
- */
-static void flat_DITHER_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                  GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   XMesaImage *img = xmesa->xm_buffer->backimage;
-#define SETUP_CODE	\
-   FLAT_DITHER_SETUP( VB->ColorPtr->data[pv][0], VB->ColorPtr->data[pv][1], VB->ColorPtr->data[pv][2] );
-
-#define INNER_LOOP( LEFT, RIGHT, Y )			\
-{							\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);		\
-   FLAT_DITHER_ROW_SETUP(yy);				\
-   for (xx=LEFT;xx<RIGHT;xx++) {			\
-      unsigned long p = FLAT_DITHER(xx);		\
-      XMesaPutPixel( img, xx, yy, p );			\
-   }							\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, 8-bit PF_HPCR triangle.
- */
-static void flat_HPCR_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                                GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   GLubyte r = VB->ColorPtr->data[pv][0];	\
-   GLubyte g = VB->ColorPtr->data[pv][1];	\
-   GLubyte b = VB->ColorPtr->data[pv][2];
-#define INNER_LOOP( LEFT, RIGHT, Y )				\
-{								\
-   GLint xx, yy = FLIP(xmesa->xm_buffer, Y);			\
-   PIXEL_TYPE *pixel = pRow;					\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {			\
-      *pixel = (PIXEL_TYPE) DITHER_HPCR( xx, yy, r, g, b );	\
-   }								\
-}
-#include "tritemp.h"
-}
-
-
-/*
- * XImage, flat, NON-depth-buffered, 8-bit PF_LOOKUP triangle.
- */
-static void flat_LOOKUP8_triangle( GLcontext *ctx, GLuint v0, GLuint v1,
-                        	   GLuint v2, GLuint pv )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-#define PIXEL_ADDRESS(X,Y) PIXELADDR1(xmesa->xm_buffer,X,Y)
-#define PIXEL_TYPE GLubyte
-#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
-#define SETUP_CODE				\
-   LOOKUP_SETUP;				\
-   GLubyte r = VB->ColorPtr->data[pv][0];		\
-   GLubyte g = VB->ColorPtr->data[pv][1];		\
-   GLubyte b = VB->ColorPtr->data[pv][2];		\
-   GLubyte p = LOOKUP(r,g,b);
-#define INNER_LOOP( LEFT, RIGHT, Y )		\
-{						\
-   GLint xx;					\
-   PIXEL_TYPE *pixel = pRow;			\
-   for (xx=LEFT;xx<RIGHT;xx++,pixel++) {	\
-      *pixel = p;				\
-   }						\
-}
-#include "tritemp.h"
-}
-
-
-
-#if 0
-/*
- * This function is called if we're about to render triangles into an
- * X window/pixmap.  It sets the polygon stipple pattern if enabled.
- */
-static void setup_x_polygon_options( GLcontext *ctx )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int fill_type;
-
-   if (ctx->Polygon.StippleFlag) {
-      if (xmesa->xm_buffer->stipple_pixmap == 0) {
-         /* Allocate polygon stippling stuff once for this context. */
-         XMesaBuffer b = xmesa->xm_buffer;
-         b->stipple_pixmap = XMesaCreatePixmap( xmesa->display,
-						b->buffer, 32, 32, 1 );
-#ifdef XFree86Server
-	 b->stipple_gc = CreateScratchGC(xmesa->display, 1);
-#else
-         b->stipple_gc = XCreateGC(xmesa->display, b->stipple_pixmap, 0, NULL);
-#endif
-	 XMesaSetFunction(xmesa->display, b->stipple_gc, GXcopy);
-	 XMesaSetForeground(xmesa->display, b->stipple_gc, 1);
-	 XMesaSetBackground(xmesa->display, b->stipple_gc, 0);
-      }
-
-      /*
-       * NOTE: We don't handle the following here!
-       *    GL_UNPACK_SWAP_BYTES
-       *    GL_UNPACK_LSB_FIRST
-       */
-      /* Copy Mesa stipple pattern to an XImage then to Pixmap */
-      {
-         XMesaImage *stipple_ximage;
-         GLuint stipple[32];
-         int i;
-         int shift = xmesa->xm_buffer->height % 32;
-         for (i=0;i<32;i++) {
-            stipple[31-i] = ctx->PolygonStipple[(i+shift) % 32];
-         }
-#ifdef XFree86Server
-         stipple_ximage = XMesaCreateImage(1, 32, 32, (char *)stipple);
-#else
-         stipple_ximage = XCreateImage( xmesa->display,
-                                        xmesa->xm_visual->visinfo->visual,
-                                        1, ZPixmap, 0,
-                                        (char *)stipple,
-                                        32, 32, 8, 0 );
-         stipple_ximage->byte_order = LSBFirst;
-         stipple_ximage->bitmap_bit_order = LSBFirst;
-         stipple_ximage->bitmap_unit = 32;
-#endif
-         XMesaPutImage( xmesa->display,
-			(XMesaDrawable)xmesa->xm_buffer->stipple_pixmap,
-			xmesa->xm_buffer->stipple_gc,
-			stipple_ximage, 0, 0, 0, 0, 32, 32 );
-         stipple_ximage->data = NULL;
-         XMesaDestroyImage( stipple_ximage );
-      }
-
-      XMesaSetStipple( xmesa->display, xmesa->xm_buffer->gc1,
-		       xmesa->xm_buffer->stipple_pixmap );
-      XMesaSetStipple( xmesa->display, xmesa->xm_buffer->gc2,
-		       xmesa->xm_buffer->stipple_pixmap );
-      fill_type = FillStippled;
-   }
-   else {
-      fill_type = FillSolid;
-   }
-
-   XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc1, fill_type );
-   XMesaSetFillStyle( xmesa->display, xmesa->xm_buffer->gc2, fill_type );
-}
-#endif
-
-
-#ifdef DEBUG
-void
-_xmesa_print_triangle_func( triangle_func triFunc )
-{
-   printf("XMesa tri func = ");
-   if (triFunc ==smooth_TRUECOLOR_z_triangle)
-      printf("smooth_TRUECOLOR_z_triangle\n");
-   else if (triFunc ==smooth_8A8B8G8R_z_triangle)
-      printf("smooth_8A8B8G8R_z_triangle\n");
-   else if (triFunc ==smooth_8R8G8B_z_triangle)
-      printf("smooth_8R8G8B_z_triangle\n");
-   else if (triFunc ==smooth_8R8G8B24_z_triangle)
-      printf("smooth_8R8G8B24_z_triangle\n");
-   else if (triFunc ==smooth_TRUEDITHER_z_triangle)
-      printf("smooth_TRUEDITHER_z_triangle\n");
-   else if (triFunc ==smooth_5R6G5B_z_triangle)
-      printf("smooth_5R6G5B_z_triangle\n");
-   else if (triFunc ==smooth_DITHER_5R6G5B_z_triangle)
-      printf("smooth_DITHER_5R6G5B_z_triangle\n");
-   else if (triFunc ==smooth_HPCR_z_triangle)
-      printf("smooth_HPCR_z_triangle\n");
-   else if (triFunc ==smooth_DITHER8_z_triangle)
-      printf("smooth_DITHER8_z_triangle\n");
-   else if (triFunc ==smooth_LOOKUP8_z_triangle)
-      printf("smooth_LOOKUP8_z_triangle\n");
-   else if (triFunc ==flat_TRUECOLOR_z_triangle)
-      printf("flat_TRUECOLOR_z_triangle\n");
-   else if (triFunc ==flat_8A8B8G8R_z_triangle)
-      printf("flat_8A8B8G8R_z_triangle\n");
-   else if (triFunc ==flat_8R8G8B_z_triangle)
-      printf("flat_8R8G8B_z_triangle\n");
-   else if (triFunc ==flat_8R8G8B24_z_triangle)
-      printf("flat_8R8G8B24_z_triangle\n");
-   else if (triFunc ==flat_TRUEDITHER_z_triangle)
-      printf("flat_TRUEDITHER_z_triangle\n");
-   else if (triFunc ==flat_5R6G5B_z_triangle)
-      printf("flat_5R6G5B_z_triangle\n");
-   else if (triFunc ==flat_DITHER_5R6G5B_z_triangle)
-      printf("flat_DITHER_5R6G5B_z_triangle\n");
-   else if (triFunc ==flat_HPCR_z_triangle)
-      printf("flat_HPCR_z_triangle\n");
-   else if (triFunc ==flat_DITHER8_z_triangle)
-      printf("flat_DITHER8_z_triangle\n");
-   else if (triFunc ==flat_LOOKUP8_z_triangle)
-      printf("flat_LOOKUP8_z_triangle\n");
-   else if (triFunc ==smooth_TRUECOLOR_triangle)
-      printf("smooth_TRUECOLOR_triangle\n");
-   else if (triFunc ==smooth_8A8B8G8R_triangle)
-      printf("smooth_8A8B8G8R_triangle\n");
-   else if (triFunc ==smooth_8R8G8B_triangle)
-      printf("smooth_8R8G8B_triangle\n");
-   else if (triFunc ==smooth_8R8G8B24_triangle)
-      printf("smooth_8R8G8B24_triangle\n");
-   else if (triFunc ==smooth_TRUEDITHER_triangle)
-      printf("smooth_TRUEDITHER_triangle\n");
-   else if (triFunc ==smooth_5R6G5B_triangle)
-      printf("smooth_5R6G5B_triangle\n");
-   else if (triFunc ==smooth_DITHER_5R6G5B_triangle)
-      printf("smooth_DITHER_5R6G5B_triangle\n");
-   else if (triFunc ==smooth_HPCR_triangle)
-      printf("smooth_HPCR_triangle\n");
-   else if (triFunc ==smooth_DITHER8_triangle)
-      printf("smooth_DITHER8_triangle\n");
-   else if (triFunc ==smooth_LOOKUP8_triangle)
-      printf("smooth_LOOKUP8_triangle\n");
-   else if (triFunc ==flat_TRUECOLOR_triangle)
-      printf("flat_TRUECOLOR_triangle\n");
-   else if (triFunc ==flat_TRUEDITHER_triangle)
-      printf("flat_TRUEDITHER_triangle\n");
-   else if (triFunc ==flat_8A8B8G8R_triangle)
-      printf("flat_8A8B8G8R_triangle\n");
-   else if (triFunc ==flat_8R8G8B_triangle)
-      printf("flat_8R8G8B_triangle\n");
-   else if (triFunc ==flat_8R8G8B24_triangle)
-      printf("flat_8R8G8B24_triangle\n");
-   else if (triFunc ==flat_5R6G5B_triangle)
-      printf("flat_5R6G5B_triangle\n");
-   else if (triFunc ==flat_DITHER_5R6G5B_triangle)
-      printf("flat_DITHER_5R6G5B_triangle\n");
-   else if (triFunc ==flat_HPCR_triangle)
-      printf("flat_HPCR_triangle\n");
-   else if (triFunc ==flat_DITHER8_triangle)
-      printf("flat_DITHER8_triangle\n");
-   else if (triFunc ==flat_LOOKUP8_triangle)
-      printf("flat_LOOKUP8_triangle\n");
-#if 0
-   else if (triFunc ==flat_pixmap_triangle)
-      printf("flat_pixmap_triangle\n");
-#endif
-   else
-      printf("???\n");
-}
-#endif
-
-
-triangle_func xmesa_get_triangle_func( GLcontext *ctx )
-{
-   XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
-   int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
-
-   (void) kernel1;
-
-   if (ctx->Polygon.SmoothFlag)     return (triangle_func)NULL;
-   if (ctx->Texture.ReallyEnabled)  return (triangle_func)NULL;
-
-   if (xmesa->xm_buffer->buffer==XIMAGE) {
-      if (   ctx->Light.ShadeModel==GL_SMOOTH
-          && ctx->RasterMask==DEPTH_BIT
-          && ctx->Depth.Func==GL_LESS
-          && ctx->Depth.Mask==GL_TRUE
-          && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-          && ctx->Polygon.StippleFlag==GL_FALSE) {
-         switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
-	       return smooth_TRUECOLOR_z_triangle;
-            case PF_8A8B8G8R:
-               return smooth_8A8B8G8R_z_triangle;
-            case PF_8R8G8B:
-               return smooth_8R8G8B_z_triangle;
-            case PF_8R8G8B24:
-               return smooth_8R8G8B24_z_triangle;
-            case PF_TRUEDITHER:
-               return smooth_TRUEDITHER_z_triangle;
-            case PF_5R6G5B:
-               return smooth_5R6G5B_z_triangle;
-            case PF_DITHER_5R6G5B:
-               return smooth_DITHER_5R6G5B_z_triangle;
-            case PF_HPCR:
-	       return smooth_HPCR_z_triangle;
-            case PF_DITHER:
-               return (depth==8) ? smooth_DITHER8_z_triangle
-                                        : smooth_DITHER_z_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? smooth_LOOKUP8_z_triangle : (triangle_func)NULL;
-            default:
-               return (triangle_func)NULL;
-         }
-      }
-      if (   ctx->Light.ShadeModel==GL_FLAT
-          && ctx->RasterMask==DEPTH_BIT
-          && ctx->Depth.Func==GL_LESS
-          && ctx->Depth.Mask==GL_TRUE
-          && ctx->Visual->DepthBits == DEFAULT_SOFTWARE_DEPTH_BITS
-          && ctx->Polygon.StippleFlag==GL_FALSE) {
-         switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
-	       return flat_TRUECOLOR_z_triangle;
-            case PF_8A8B8G8R:
-               return flat_8A8B8G8R_z_triangle;
-            case PF_8R8G8B:
-               return flat_8R8G8B_z_triangle;
-            case PF_8R8G8B24:
-               return flat_8R8G8B24_z_triangle;
-            case PF_TRUEDITHER:
-               return flat_TRUEDITHER_z_triangle;
-            case PF_5R6G5B:
-               return flat_5R6G5B_z_triangle;
-            case PF_DITHER_5R6G5B:
-               return flat_DITHER_5R6G5B_z_triangle;
-            case PF_HPCR:
-	       return flat_HPCR_z_triangle;
-            case PF_DITHER:
-               return (depth==8) ? flat_DITHER8_z_triangle
-                                        : flat_DITHER_z_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? flat_LOOKUP8_z_triangle : (triangle_func)NULL;
-            default:
-               return (triangle_func)NULL;
-         }
-      }
-      if (   ctx->RasterMask==0   /* no depth test */
-          && ctx->Light.ShadeModel==GL_SMOOTH
-          && ctx->Polygon.StippleFlag==GL_FALSE) {
-         switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
-	       return smooth_TRUECOLOR_triangle;
-            case PF_8A8B8G8R:
-               return smooth_8A8B8G8R_triangle;
-            case PF_8R8G8B:
-               return smooth_8R8G8B_triangle;
-            case PF_8R8G8B24:
-               return smooth_8R8G8B24_triangle;
-            case PF_TRUEDITHER:
-               return smooth_TRUEDITHER_triangle;
-            case PF_5R6G5B:
-               return smooth_5R6G5B_triangle;
-            case PF_DITHER_5R6G5B:
-               return smooth_DITHER_5R6G5B_triangle;
-            case PF_HPCR:
-	       return smooth_HPCR_triangle;
-            case PF_DITHER:
-               return (depth==8) ? smooth_DITHER8_triangle
-                                        : smooth_DITHER_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? smooth_LOOKUP8_triangle : (triangle_func)NULL;
-            default:
-               return (triangle_func)NULL;
-         }
-      }
-
-      if (   ctx->RasterMask==0   /* no depth test */
-          && ctx->Light.ShadeModel==GL_FLAT
-          && ctx->Polygon.StippleFlag==GL_FALSE) {
-         switch (xmesa->pixelformat) {
-            case PF_TRUECOLOR:
-	       return flat_TRUECOLOR_triangle;
-            case PF_TRUEDITHER:
-	       return flat_TRUEDITHER_triangle;
-            case PF_8A8B8G8R:
-               return flat_8A8B8G8R_triangle;
-            case PF_8R8G8B:
-               return flat_8R8G8B_triangle;
-            case PF_8R8G8B24:
-               return flat_8R8G8B24_triangle;
-            case PF_5R6G5B:
-               return flat_5R6G5B_triangle;
-            case PF_DITHER_5R6G5B:
-               return flat_DITHER_5R6G5B_triangle;
-            case PF_HPCR:
-	       return flat_HPCR_triangle;
-            case PF_DITHER:
-               return (depth==8) ? flat_DITHER8_triangle
-                                        : flat_DITHER_triangle;
-            case PF_LOOKUP:
-               return (depth==8) ? flat_LOOKUP8_triangle : (triangle_func)NULL;
-            default:
-               return (triangle_func)NULL;
-         }
-      }
-
-      return (triangle_func)NULL;
-   }
-   else {
-      /* draw to pixmap */
-#if 0
-      /* XXX have to disable this because X's rasterization rules
-       * don't match software Mesa's.  This causes a buffer invariance
-       * test failure in the conformance tests.
-       * In the future, we might provide a config option to enable this.
-       */
-      if (ctx->Light.ShadeModel==GL_FLAT && ctx->RasterMask==0) {
-         if (ctx->Color.DitherFlag && depth < 24)
-            return NULL;
-         setup_x_polygon_options( ctx );
-         return flat_pixmap_triangle;
-      }
-#endif
-      return (triangle_func)NULL;
-   }
-}
Index: xc/extras/Mesa/src/X/xmesaP.h
diff -u xc/extras/Mesa/src/X/xmesaP.h:1.9 xc/extras/Mesa/src/X/xmesaP.h:1.11
--- xc/extras/Mesa/src/X/xmesaP.h:1.9	Fri May 18 13:00:06 2001
+++ xc/extras/Mesa/src/X/xmesaP.h	Mon Sep  9 17:07:28 2002
@@ -1,20 +1,20 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.3
- * 
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- * 
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
@@ -32,30 +32,18 @@
 # include "GL/xf86glx.h"
 # include "xf86glx_util.h"
 #else
-# ifdef GLX_DIRECT_RENDERING
-#  include "dri_mesa.h"
-# endif
 # ifdef USE_XSHM
 #  include <X11/extensions/XShm.h>
 # endif
 #endif
 #include "GL/xmesa.h"
-#include "types.h"
-#if defined(FX) && !defined(GLX_DIRECT_RENDERING)
+#include "mtypes.h"
+#if defined(FX)
 #include "GL/fxmesa.h"
-#include "../FX/fxdrv.h"
+#include "FX/fxdrv.h"
 #endif
 
 
-#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-#  include "xdriP.h"
-#else
-#  define DRI_DRAWABLE_ARG
-#  define DRI_DRAWABLE_PARM
-#  define DRI_CTX_ARG
-#endif
-
-
 extern _glthread_Mutex _xmesa_lock;
 
 
@@ -74,10 +62,10 @@
 
 
 /*
- * "Derived" from gl_visual.  Basically corresponds to an XVisualInfo.
+ * "Derived" from GLvisual.  Basically corresponds to an XVisualInfo.
  */
 struct xmesa_visual {
-   GLvisual *gl_visual;		/* Device independent visual parameters */
+   GLvisual mesa_visual;	/* Device independent visual parameters */
    XMesaDisplay *display;	/* The X11 display */
 #ifdef XFree86Server
    GLint screen_depth;		/* The depth of the screen */
@@ -126,7 +114,7 @@
 
 
 /*
- * "Derived" from gl_context.  Basically corresponds to a GLXContext.
+ * "Derived" from __GLcontextRec.  Basically corresponds to a GLXContext.
  */
 struct xmesa_context {
    GLcontext *gl_ctx;		/* the core library context */
@@ -141,33 +129,23 @@
 
    GLuint pixelformat;		/* Current pixel format */
 
-   GLubyte red, green, blue, alpha;	/* current drawing color */
-   unsigned long pixel;			/* current drawing pixel value */
-
    GLubyte clearcolor[4];		/* current clearing color */
    unsigned long clearpixel;		/* current clearing pixel value */
-
-#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-  __DRIcontextPrivate *driContextPriv; /* back pointer to DRI context
-					* used for locking
-					*/
-  void *private;			/* device-specific private context */
-#endif
 };
 
 
 
 /*
- * "Derived" from gl_buffer.  Basically corresponds to a GLXDrawable.
+ * "Derived" from GLframebuffer.  Basically corresponds to a GLXDrawable.
  */
 struct xmesa_buffer {
+   GLframebuffer mesa_buffer;	/* depth, stencil, accum, etc buffers */
    GLboolean wasCurrent;	/* was ever the current buffer? */
-   GLframebuffer *gl_buffer;	/* depth, stencil, accum, etc buffers */
    XMesaVisual xm_visual;	/* the X/Mesa visual */
 
-   XMesaContext xm_context;     /* the context associated with this buffer */
    XMesaDisplay *display;
    GLboolean pixmap_flag;	/* is the buffer a Pixmap? */
+   GLboolean pbuffer_flag;	/* is the buffer a Pbuffer? */
    XMesaDrawable frontbuffer;	/* either a window or pixmap */
    XMesaPixmap backpixmap;	/* back buffer Pixmap */
    XMesaImage *backimage;	/* back buffer simulated XImage */
@@ -208,9 +186,9 @@
    XMesaPixmap stipple_pixmap;	/* For polygon stippling */
    XMesaGC stipple_gc;		/* For polygon stippling */
 
-   XMesaGC gc1;			/* GC for infrequent color changes */
-   XMesaGC gc2;			/* GC for frequent color changes */
+   XMesaGC gc;			/* scratch GC for span, line, tri drawing */
    XMesaGC cleargc;		/* GC for clearing the color buffer */
+   XMesaGC swapgc;		/* GC for swapping the color buffers */
 
    /* The following are here instead of in the XMesaVisual
     * because they depend on the window's colormap.
@@ -232,14 +210,7 @@
    unsigned long alloced_colors[256];
 #endif
 
-#if defined(GLX_DIRECT_RENDERING) && !defined(XFree86Server)
-  __DRIdrawablePrivate *driDrawPriv;	/* back pointer to DRI drawable
-					 * used for direct access to framebuffer
-					 */
-  void *private;			/* device-specific private drawable */
-#endif
-
-#if defined( FX ) && !defined(GLX_DIRECT_RENDERING)
+#if defined( FX )
    /* For 3Dfx Glide only */
    GLboolean FXisHackUsable;	/* Can we render into window? */
    GLboolean FXwindowHack;	/* Are we rendering into a window? */
@@ -445,15 +416,15 @@
 static const short HPCR_DRGB[3][2][16] = {
 {
     { 16, -4,  1,-11, 14, -6,  3, -9, 15, -5,  2,-10, 13, -7,  4, -8},
-    {-15,  5,  0, 12,-13,  7, -2, 10,-14,  6, -1, 11,-12,  8, -3,  9} 
+    {-15,  5,  0, 12,-13,  7, -2, 10,-14,  6, -1, 11,-12,  8, -3,  9}
 },
 {
     {-11, 15, -7,  3, -8, 14, -4,  2,-10, 16, -6,  4, -9, 13, -5,  1},
-    { 12,-14,  8, -2,  9,-13,  5, -1, 11,-15,  7, -3, 10,-12,  6,  0} 
+    { 12,-14,  8, -2,  9,-13,  5, -1, 11,-15,  7, -3, 10,-12,  6,  0}
 },
 {
     {  6,-18, 26,-14,  2,-22, 30,-10,  8,-16, 28,-12,  4,-20, 32, -8},
-    { -4, 20,-24, 16,  0, 24,-28, 12, -6, 18,-26, 14, -2, 22,-30, 10} 
+    { -4, 20,-24, 16,  0, 24,-28, 12, -6, 18,-26, 14, -2, 22,-30, 10}
 }
 };
 
@@ -519,25 +490,33 @@
  */
 
 extern unsigned long
-xmesa_color_to_pixel( XMesaContext xmesa, GLubyte r, GLubyte g, GLubyte b, GLubyte a,
+xmesa_color_to_pixel( XMesaContext xmesa,
+                      GLubyte r, GLubyte g, GLubyte b, GLubyte a,
                       GLuint pixelFormat );
 
 extern void xmesa_alloc_back_buffer( XMesaBuffer b );
 
-extern void xmesa_update_state( GLcontext *ctx );
+extern void xmesa_init_pointers( GLcontext *ctx );
+extern void xmesa_update_state( GLcontext *ctx, GLuint new_state );
 
-extern points_func xmesa_get_points_func( GLcontext *ctx );
+extern void xmesa_update_span_funcs( GLcontext *ctx );
 
-extern line_func xmesa_get_line_func( GLcontext *ctx );
+/* Plugged into the software rasterizer.  Try to use internal
+ * swrast-style point, line and triangle functions.
+ */
+extern void xmesa_choose_point( GLcontext *ctx );
+extern void xmesa_choose_line( GLcontext *ctx );
+extern void xmesa_choose_triangle( GLcontext *ctx );
 
-extern triangle_func xmesa_get_triangle_func( GLcontext *ctx );
 
+extern void xmesa_register_swrast_functions( GLcontext *ctx );
 
+
+
 /* XXX this is a hack to implement shared display lists with 3Dfx */
 extern XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v,
 					     XMesaWindow w,
 					     XMesaContext c
-					     DRI_DRAWABLE_ARG
 					   );
 
 /*
@@ -548,5 +527,10 @@
 extern GLboolean XMesaForceCurrent(XMesaContext c);
 extern GLboolean XMesaLoseCurrent(XMesaContext c);
 extern void XMesaReset( void );
+
+extern void xmesa_set_read_buffer( GLcontext *ctx, 
+				   GLframebuffer *buffer, GLenum mode );
+
+extern void xmesa_resize_buffers( GLframebuffer *buffer );
 
 #endif
Index: xc/extras/Mesa/src/X86/3dnow.c
diff -u xc/extras/Mesa/src/X86/3dnow.c:1.9 xc/extras/Mesa/src/X86/3dnow.c:1.10
--- xc/extras/Mesa/src/X86/3dnow.c:1.9	Thu Nov 30 10:39:21 2000
+++ xc/extras/Mesa/src/X86/3dnow.c	Fri Feb 22 14:31:29 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -30,168 +30,76 @@
 
 #include "glheader.h"
 #include "context.h"
-#include "shade.h"
-#include "types.h"
-#include "vertices.h"
-#include "xform.h"
+#include "math/m_vertices.h"
+#include "math/m_xform.h"
+#include "tnl/t_context.h"
+
 #include "3dnow.h"
+#include "common_x86_macros.h"
 
 #ifdef DEBUG
-#include "debug_xform.h"
+#include "math/m_debug.h"
 #endif
 
+
+#ifdef USE_3DNOW_ASM
+DECLARE_XFORM_GROUP( 3dnow, 2 )
+DECLARE_XFORM_GROUP( 3dnow, 3 )
+DECLARE_XFORM_GROUP( 3dnow, 4 )
 
-#define XFORM_ARGS	GLvector4f *to_vec,				\
-			const GLfloat m[16],				\
-			const GLvector4f *from_vec,			\
-			const GLubyte *mask,				\
-			const GLubyte flag
-
-
-#define DECLARE_XFORM_GROUP( pfx, sz, masked ) \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_general_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_identity_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_3d_no_rot_##masked( XFORM_ARGS );    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_perspective_##masked( XFORM_ARGS );  \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_2d_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_2d_no_rot_##masked( XFORM_ARGS );    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_3d_##masked( XFORM_ARGS );
-
-
-#define ASSIGN_XFORM_GROUP( pfx, cma, sz, masked )			\
-   gl_transform_tab[cma][sz][MATRIX_GENERAL] =				\
-      gl_##pfx##_transform_points##sz##_general_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_IDENTITY] =				\
-      gl_##pfx##_transform_points##sz##_identity_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_3D_NO_ROT] =			\
-      gl_##pfx##_transform_points##sz##_3d_no_rot_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_PERSPECTIVE] =			\
-      gl_##pfx##_transform_points##sz##_perspective_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_2D] =				\
-      gl_##pfx##_transform_points##sz##_2d_##masked;			\
-   gl_transform_tab[cma][sz][MATRIX_2D_NO_ROT] =			\
-      gl_##pfx##_transform_points##sz##_2d_no_rot_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_3D] =				\
-      gl_##pfx##_transform_points##sz##_3d_##masked;
-
-
-
-#define NORM_ARGS	const GLmatrix *mat,				\
-			GLfloat scale,					\
-			const GLvector3f *in,				\
-			const GLfloat *lengths,				\
-			const GLubyte mask[],				\
-			GLvector3f *dest
-
-
-#define DECLARE_NORM_GROUP( pfx, masked ) \
- extern void _ASMAPI gl_##pfx##_rescale_normals_##masked( NORM_ARGS );			    \
- extern void _ASMAPI gl_##pfx##_normalize_normals_##masked( NORM_ARGS );		    \
- extern void _ASMAPI gl_##pfx##_transform_normals_##masked( NORM_ARGS );		    \
- extern void _ASMAPI gl_##pfx##_transform_normals_no_rot_##masked( NORM_ARGS );		    \
- extern void _ASMAPI gl_##pfx##_transform_rescale_normals_##masked( NORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_rescale_normals_no_rot_##masked( NORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_normalize_normals_##masked( NORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_normalize_normals_no_rot_##masked( NORM_ARGS );
-
-
-#define ASSIGN_NORM_GROUP( pfx, cma, masked )				\
-   gl_normal_tab[NORM_RESCALE][cma] =					\
-      gl_##pfx##_rescale_normals_##masked;				\
-   gl_normal_tab[NORM_NORMALIZE][cma] =					\
-      gl_##pfx##_normalize_normals_##masked;				\
-   gl_normal_tab[NORM_TRANSFORM][cma] =					\
-      gl_##pfx##_transform_normals_##masked;				\
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT][cma] =				\
-      gl_##pfx##_transform_normals_no_rot_##masked;			\
-   gl_normal_tab[NORM_TRANSFORM | NORM_RESCALE][cma] =			\
-      gl_##pfx##_transform_rescale_normals_##masked;			\
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE][cma] =		\
-      gl_##pfx##_transform_rescale_normals_no_rot_##masked;		\
-   gl_normal_tab[NORM_TRANSFORM | NORM_NORMALIZE][cma] =		\
-      gl_##pfx##_transform_normalize_normals_##masked;			\
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE][cma] =		\
-      gl_##pfx##_transform_normalize_normals_no_rot_##masked;
+DECLARE_NORM_GROUP( 3dnow )
 
 
-#ifdef USE_3DNOW_ASM
-DECLARE_XFORM_GROUP( 3dnow, 1, raw )
-DECLARE_XFORM_GROUP( 3dnow, 2, raw )
-DECLARE_XFORM_GROUP( 3dnow, 3, raw )
-DECLARE_XFORM_GROUP( 3dnow, 4, raw )
-
-DECLARE_XFORM_GROUP( 3dnow, 1, masked )
-DECLARE_XFORM_GROUP( 3dnow, 2, masked )
-DECLARE_XFORM_GROUP( 3dnow, 3, masked )
-DECLARE_XFORM_GROUP( 3dnow, 4, masked )
-
-DECLARE_NORM_GROUP( 3dnow, raw )
-/*DECLARE_NORM_GROUP( 3dnow, masked )*/
-
-
-extern void _ASMAPI gl_v16_3dnow_general_xform( GLfloat *first_vert,
-						const GLfloat *m,
-						const GLfloat *src,
-						GLuint src_stride,
-						GLuint count );
-
-extern void _ASMAPI gl_3dnow_project_vertices( GLfloat *first,
-					       GLfloat *last,
-					       const GLfloat *m,
-					       GLuint stride );
-
-extern void _ASMAPI gl_3dnow_project_clipped_vertices( GLfloat *first,
-						       GLfloat *last,
-						       const GLfloat *m,
-						       GLuint stride,
-						       const GLubyte *clipmask );
+extern void _ASMAPI
+_mesa_v16_3dnow_general_xform( GLfloat *first_vert,
+			       const GLfloat *m,
+			       const GLfloat *src,
+			       GLuint src_stride,
+			       GLuint count );
+
+extern void _ASMAPI
+_mesa_3dnow_project_vertices( GLfloat *first,
+			      GLfloat *last,
+			      const GLfloat *m,
+			      GLuint stride );
+
+extern void _ASMAPI
+_mesa_3dnow_project_clipped_vertices( GLfloat *first,
+				      GLfloat *last,
+				      const GLfloat *m,
+				      GLuint stride,
+				      const GLubyte *clipmask );
 #endif
 
 
-void gl_init_3dnow_transform_asm( void )
+void _mesa_init_3dnow_transform_asm( void )
 {
 #ifdef USE_3DNOW_ASM
-   ASSIGN_XFORM_GROUP( 3dnow, 0, 1, raw );
-   ASSIGN_XFORM_GROUP( 3dnow, 0, 2, raw );
-   ASSIGN_XFORM_GROUP( 3dnow, 0, 3, raw );
-   ASSIGN_XFORM_GROUP( 3dnow, 0, 4, raw );
-
-   ASSIGN_XFORM_GROUP( 3dnow, CULL_MASK_ACTIVE, 1, masked );
-   ASSIGN_XFORM_GROUP( 3dnow, CULL_MASK_ACTIVE, 2, masked );
-   ASSIGN_XFORM_GROUP( 3dnow, CULL_MASK_ACTIVE, 3, masked );
-   ASSIGN_XFORM_GROUP( 3dnow, CULL_MASK_ACTIVE, 4, masked );
+   ASSIGN_XFORM_GROUP( 3dnow, 2 );
+   ASSIGN_XFORM_GROUP( 3dnow, 3 );
+   ASSIGN_XFORM_GROUP( 3dnow, 4 );
 
-   ASSIGN_NORM_GROUP( 3dnow, 0, raw );
-/* ASSIGN_NORM_GROUP( 3dnow, CULL_MASK_ACTIVE, masked ); */
+/* Normalize function is broken - see demos/morph3d for example.
+ */
+/*     ASSIGN_NORM_GROUP( 3dnow ); */
 
 #ifdef DEBUG
-   gl_test_all_transform_functions( "3DNow!" );
-   gl_test_all_normal_transform_functions( "3DNow!" );
+   _math_test_all_transform_functions( "3DNow!" );
+   _math_test_all_normal_transform_functions( "3DNow!" );
 #endif
 #endif
 }
 
-void gl_init_3dnow_shade_asm( void )
+void _mesa_init_3dnow_vertex_asm( void )
 {
 #ifdef USE_3DNOW_ASM
-   /* When the time comes, initialize optimized lighting here.
-    */
+   _mesa_xform_points3_v16_general = _mesa_v16_3dnow_general_xform;
 
-#if 0
-   gl_test_all_shade_functions( "3DNow!" );
-#endif
-#endif
-}
-
-void gl_init_3dnow_vertex_asm( void )
-{
-#ifdef USE_3DNOW_ASM
-   gl_xform_points3_v16_general	= gl_v16_3dnow_general_xform;
-   gl_project_v16		= gl_3dnow_project_vertices;
-   gl_project_clipped_v16	= gl_3dnow_project_clipped_vertices;
+   _mesa_project_v16 = _mesa_3dnow_project_vertices;
+   _mesa_project_clipped_v16 = _mesa_3dnow_project_clipped_vertices;
 
-#if 0
-   gl_test_all_vertex_functions( "3DNow!" );
+#ifdef DEBUG_NOT
+   _math_test_all_vertex_functions( "3DNow!" );
 #endif
 #endif
 }
Index: xc/extras/Mesa/src/X86/3dnow.h
diff -u xc/extras/Mesa/src/X86/3dnow.h:1.5 xc/extras/Mesa/src/X86/3dnow.h:1.6
--- xc/extras/Mesa/src/X86/3dnow.h:1.5	Thu Nov 30 10:39:21 2000
+++ xc/extras/Mesa/src/X86/3dnow.h	Fri Feb 22 14:31:29 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -31,8 +31,9 @@
 #ifndef __3DNOW_H__
 #define __3DNOW_H__
 
-void gl_init_3dnow_transform_asm( void );
-void gl_init_3dnow_shade_asm( void );
-void gl_init_3dnow_vertex_asm( void );
+#include "math/m_xform.h"
+
+void _mesa_init_3dnow_transform_asm( void );
+void _mesa_init_3dnow_vertex_asm( void );
 
 #endif
Index: xc/extras/Mesa/src/X86/3dnow_norm_raw.S
diff -u xc/extras/Mesa/src/X86/3dnow_norm_raw.S:1.7 xc/extras/Mesa/src/X86/3dnow_norm_raw.S:removed
--- xc/extras/Mesa/src/X86/3dnow_norm_raw.S:1.7	Wed Nov 14 05:28:07 2001
+++ xc/extras/Mesa/src/X86/3dnow_norm_raw.S	Thu Feb 27 12:15:53 2003
@@ -1,865 +0,0 @@
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * 3Dnow assembly code by Holger Waechtler
- */
-
-
-#include "assyntax.h"
-
-        SEG_TEXT
-
-
-
-/*
- * typedef void (*normal_transform_function) ( const GLmatrix *mat,
- *                                             GLfloat scale,
- *                                             const GLvector3f *in,
- *                                             const GLfloat *lengths,
- *                                             const GLubyte mask[],
- *                                             GLvector3f *dest )
- */
-
-#define OFFSET_MAT 4
-#define OFFSET_SCALE 8
-#define OFFSET_IN 12
-#define OFFSET_LENGTHS 16
-#define OFFSET_MASK 20
-#define OFFSET_DEST 24
-
-#define ARG_MAT         REGOFF(FRAME_OFFSET+OFFSET_MAT, ESP)
-#define ARG_SCALE       REGOFF(FRAME_OFFSET+OFFSET_SCALE, ESP)
-#define ARG_IN          REGOFF(FRAME_OFFSET+OFFSET_IN, ESP)
-#define ARG_LENGTHS     REGOFF(FRAME_OFFSET+OFFSET_LENGTHS, ESP)
-#define ARG_MASK        REGOFF(FRAME_OFFSET+OFFSET_MASK, ESP)
-#define ARG_DEST        REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-
-
-#define V3F_START       4
-#define V3F_COUNT       8
-#define V3F_STRIDE      12
-
-#define MAT_INV         4
-
-#define M(i)    REGOFF(i * 4, ECX)
-#define STRIDE  REGOFF(12, ESI)
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_normalize_normals_raw)
-GLNAME(gl_3dnow_transform_normalize_normals_raw):
-
- #define FRAME_OFFSET 12
-
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-    PUSH_L     ( EBP )
-
-    MOV_L      ( ARG_LENGTHS, EDI )
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_DEST, EAX )
-    MOV_L      ( REGOFF(V3F_COUNT, ESI), EBP ) /*  dest->count = in->count   */
-    MOV_L      ( EBP, REGOFF(V3F_COUNT, EAX) )
-    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
-    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
-    MOV_L      ( ARG_MAT, ECX )
-    MOV_L      ( REGOFF(MAT_INV, ECX), ECX ) /*  mat->inv     */
-
-    CMP_L      ( CONST(0), EBP )        /*   count > 0 ??  */
-    JE         ( LLBL (G3TN_end) )
-
-    MOV_L      ( REGOFF (V3F_COUNT, ESI), EBP )
-    FEMMS
-
-    PUSH_L     ( EBP )
-    PUSH_L     ( EAX )
-    PUSH_L     ( EDX )                  /*  save counter & pointer for   */
-                                        /*  the normalize pass           */
- #undef  FRAME_OFFSET
- #define FRAME_OFFSET 24
-
-    MOVQ       ( M(0), MM3 )            /*  m1              | m0         */
-    MOVQ       ( M(4), MM4 )            /*  m5              | m4         */
-
-    MOVD       ( M(2), MM5 )            /*                  | m2         */
-    PUNPCKLDQ  ( M(6), MM5 )            /*  m6              | m2         */
-
-    MOVQ       ( M(8), MM6 )            /*  m9              | m8         */
-    MOVQ       ( M(10), MM7 )           /*                  | m10        */
-
-    CMP_L      ( CONST(0), EDI )        /*  lengths == 0 ?                 */
-    JNE        ( LLBL (G3TN_scale_end ) )
-
-    MOVD       ( ARG_SCALE, MM0 )       /*               | scale           */
-    PUNPCKLDQ  ( MM0, MM0 )             /* scale         | scale           */
-
-    PFMUL      ( MM0, MM3 )             /* scale * m1    | scale * m0      */
-    PFMUL      ( MM0, MM4 )             /* scale * m5    | scale * m4      */
-    PFMUL      ( MM0, MM5 )             /* scale * m6    | scale * m2      */
-    PFMUL      ( MM0, MM6 )             /* scale * m9    | scale * m8      */
-    PFMUL      ( MM0, MM7 )             /*               | scale * m10     */
-
-ALIGNTEXT32
-LLBL (G3TN_scale_end):
-LLBL (G3TN_transform):
-    MOVQ       ( REGIND (EDX), MM0 )    /*  x1              | x0         */
-    MOVD       ( REGOFF (8, EDX), MM2 ) /*                  | x2         */
-
-    MOVQ       ( MM0, MM1 )             /*  x1              | x0           */
-    PUNPCKLDQ  ( MM2, MM2 )             /*  x2              | x2           */
-
-    PFMUL      ( MM3, MM0 )             /*  x1*m1           | x0*m0        */
-    ADD_L      ( CONST(12), EAX )       /*  next r                         */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    PFMUL      ( MM4, MM1 )             /*  x1*m5           | x0*m4        */
-    PFACC      ( MM1, MM0 )             /*  x0*m4+x1*m5     | x0*m0+x1*m1  */
-
-    PFMUL      ( MM5, MM2 )             /*  x2*m6           | x2*m2        */
-    PFADD      ( MM2, MM0 )             /* x0*m4+x1*m5+x2*m6| x0*m0+...+x2**/
-
-    MOVQ       ( REGIND (EDX), MM1 )    /*  x1           | x0              */
-    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write r0, r1                   */
-
-    PFMUL      ( MM6, MM1 )             /* x1*m9         | x0*m8           */
-    MOVD       ( REGOFF (8, EDX), MM2 ) /*               | x2              */
-
-    PFMUL      ( MM7, MM2 )             /*               | x2*m10          */
-    PFACC      ( MM1, MM1 )             /*  *not used*   | x0*m8+x1*m9     */
-
-    PFADD      ( MM2, MM1 )             /*  *not used*   | x0*m8+x1*m9+x2*m*/
-    ADD_L      ( STRIDE, EDX )          /*  next normal                    */
-
-    PREFETCH   ( REGIND(EDX) )
-
-    MOVD       ( MM1, REGOFF(-4, EAX) ) /*  write r2                       */
-    DEC_L      ( EBP )                  /*  decrement normal counter       */
-    JA         ( LLBL (G3TN_transform) )
-
-
-    POP_L      ( EDX )                  /*  end of transform ---           */
-    POP_L      ( EAX )                  /*    now normalizing ...          */
-    POP_L      ( EBP )
-
-    MOVQ       ( REGIND(EAX), MM0 )     /*  x1              | x0           */
-    MOVD       ( REGOFF(8, EAX), MM1 )  /*                  | x2           */
-
-    CMP_L      ( CONST(0), EDI )        /*  lengths == 0 ?                 */
-    JE         ( LLBL (G3TN_norm ) )    /*  calculate lengths              */
-
-
-ALIGNTEXT32
-LLBL (G3TN_norm_w_lengths):
-
-    PREFETCHW  ( REGOFF(12,EAX) )
-
-    MOVD       ( REGIND (EDI), MM3 )    /*                  | length (x)   */
-    PFMUL      ( MM3, MM1 )             /*                  | x2 (normalize*/
-
-    PUNPCKLDQ  ( MM3, MM3 )             /*  length (x)      | length (x)   */
-    PFMUL      ( MM3, MM0 )             /*  x1 (normalized) | x0 (normalize*/
-
-    ADD_L      ( STRIDE, EDX )          /*  next normal                    */
-    ADD_L      ( CONST(4), EDI )        /*  next length                    */
-
-    PREFETCH   ( REGIND(EDI) )
-
-    MOVQ       ( MM0, REGIND(EAX) )     /*  write new x0, x1               */
-    MOVD       ( MM1, REGOFF(8, EAX) )  /*  write new x2                   */
-
-    ADD_L      ( CONST(12), EAX )       /*  next r                         */
-    DEC_L      ( EBP )                  /*  decrement normal counter       */
-
-    MOVQ       ( REGIND(EAX), MM0 )     /*  x1              | x0           */
-    MOVD       ( REGOFF(8, EAX), MM1 )  /*                  | x2           */
-    JA         ( LLBL (G3TN_norm_w_lengths) )
-    JMP        ( LLBL (G3TN_exit_3dnow) )
-
-ALIGNTEXT32
-LLBL (G3TN_norm):
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    MOVQ       ( MM0, MM3 )             /*  x1              | x0           */
-    MOVQ       ( MM1, MM4 )             /*                  | x2           */
-
-    PFMUL      ( MM0, MM3 )             /*  x1*x1           | x0*x0        */
-    ADD_L      ( CONST(12), EAX )       /*  next r                         */
-
-    PFMUL      ( MM1, MM4 )             /*                  | x2*x2        */
-    PFADD      ( MM4, MM3 )             /*                  | x0*x0+x2*x2  */
-
-    PFACC      ( MM3, MM3 )             /* **not used**    | x0*x0+x1*x1+x2**/
-    PFRSQRT    ( MM3, MM5 )             /*  1/sqrt (x0*x0+x1*x1+x2*x2)     */
-
-    MOVQ       ( MM5, MM4 )
-    PUNPCKLDQ  ( MM3, MM3 )
-
-    DEC_L      ( EBP )                  /*  decrement normal counter       */
-    PFMUL      ( MM5, MM5 )
-
-    PFRSQIT1   ( MM3, MM5 )
-    PFRCPIT2   ( MM4, MM5 )
-
-    PFMUL      ( MM5, MM0 )             /*  x1 (normalized) | x0 (normalize*/
-
-    MOVQ       ( MM0, REGOFF(-12, EAX) ) /*  write new x0, x1              */
-    PFMUL      ( MM5, MM1 )             /*                 | x2 (normalize*/
-
-    MOVD       ( MM1, REGOFF(-4, EAX) ) /*  write new x2                  */
-    MOVQ       ( REGIND (EAX), MM0 )    /*  x1             | x0           */
-
-    MOVD       ( REGOFF(8, EAX), MM1 )  /*                 | x2           */
-    JA         ( LLBL (G3TN_norm) )
-
-LLBL (G3TN_exit_3dnow):
-    FEMMS
-
-LLBL (G3TN_end):
-    POP_L      ( EBP )
-    POP_L      ( ESI )
-    POP_L      ( EDI )
-    RET
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_normalize_normals_no_rot_raw)
-GLNAME(gl_3dnow_transform_normalize_normals_no_rot_raw):
-
- #undef FRAME_OFFSET
- #define FRAME_OFFSET 12
-
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-    PUSH_L     ( EBP )
-
-    MOV_L      ( ARG_LENGTHS, EDI )
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_DEST, EAX )
-    MOV_L      ( REGOFF(V3F_COUNT, ESI), EBP ) /*  dest->count = in->count   */
-    MOV_L      ( EBP, REGOFF(V3F_COUNT, EAX) )
-    MOV_L      ( ARG_MAT, ECX )
-    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
-    MOV_L      ( REGOFF(MAT_INV, ECX), ECX ) /*  mat->inv     */
-    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
-
-    CMP_L      ( CONST(0), EBP ) /*   count > 0 ??  */
-    JE         ( LLBL (G3TNNR_end) )
-
-    FEMMS
-
-    MOVD       ( M(0), MM0 )            /*               | m0                 */
-    PUNPCKLDQ  ( M(5), MM0 )            /* m5            | m0                 */
-
-    MOVD       ( M(10), MM2 )           /*               | m10                */
-    PUNPCKLDQ  ( MM2, MM2 )             /* m10           | m10                */
-
-    CMP_L      ( CONST(0), EDI )        /*  lengths == 0 ?                    */
-    JNE        ( LLBL (G3TNNR_scale_end ) )
-
-    MOVD       ( ARG_SCALE, MM7 )       /*               | scale              */
-    PUNPCKLDQ  ( MM7, MM7 )             /* scale         | scale              */
-
-    PFMUL      ( MM7, MM0 )             /* scale * m5    | scale * m0         */
-    PFMUL      ( MM7, MM2 )             /* scale * m10   | scale * m10        */
-
-ALIGNTEXT32
-LLBL (G3TNNR_scale_end):
-    CMP_L      ( CONST(0), EDI )        /* lengths == 0 ?                     */
-    JE         ( LLBL (G3TNNR_norm) )   /* need to calculate lengths          */
-
-ALIGNTEXT32
-LLBL (G3TNNR_norm_w_lengths):           /* use precalculated lengths          */
-
-    MOVQ       ( REGIND(EDX), MM6 )     /* x1            | x0                 */
-    MOVD       ( REGOFF(8, EDX), MM7 )  /*               | x2                 */
-
-    MOVD       ( REGIND(EDI), MM3 )     /*                 | length (x)       */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    PFMUL      ( MM0, MM6 )             /* x1*m5         | x0*m0              */
-    ADD_L      ( STRIDE, EDX )          /* next normal                        */
-
-    PREFETCH   ( REGIND(EDX) )
-
-    PFMUL      ( MM2, MM7 )             /*               | x2*m10             */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    PFMUL      ( MM3, MM7 )             /*               | x2 (normalized)  */
-    PUNPCKLDQ  ( MM3, MM3 )             /* length (x)    | length (x)       */
-
-    ADD_L      ( CONST(4), EDI )        /* next length                        */
-    PFMUL      ( MM3, MM6 )             /* x1 (normalized) | x0 (normalized)  */
-
-    DEC_L      ( EBP )                  /* decrement normal counter           */
-    MOVQ       ( MM6, REGOFF(-12, EAX) ) /* write r0, r1                      */
-
-    MOVD       ( MM7, REGOFF(-4, EAX) ) /* write r2                           */
-
-    JA         ( LLBL (G3TNNR_norm_w_lengths) )
-    JMP        ( LLBL (G3TNNR_exit_3dnow) )
-
-ALIGNTEXT32
-LLBL (G3TNNR_norm):                     /* need to calculate lengths          */
-
-    MOVQ       ( REGIND(EDX), MM6 )     /* x1            | x0                 */
-    MOVD       ( REGOFF(8, EDX), MM7 )  /*               | x2                 */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    PFMUL      ( MM0, MM6 )             /* x1*m5           | x0*m0            */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    PFMUL      ( MM2, MM7 )             /*                 | x2*m10           */
-    MOVQ       ( MM6, MM3 )             /* x1 (transformed)| x0 (transformed) */
-
-    MOVQ       ( MM7, MM4 )             /*                 | x2 (transformed) */
-    PFMUL      ( MM6, MM3 )             /* x1*x1           | x0*x0            */
-
-
-    PFMUL      ( MM7, MM4 )             /*                 | x2*x2            */
-    PFACC      ( MM3, MM3 )             /* **not used**    | x0*x0+x1*x1      */
-
-    PFADD      ( MM4, MM3 )             /*                 | x0*x0+x1*x1+x2*x2*/
-    ADD_L      ( STRIDE, EDX )          /* next normal            */
-
-    PREFETCH   ( REGIND(EDX) )
-
-    PFRSQRT    ( MM3, MM5 )             /* 1/sqrt (x0*x0+x1*x1+x2*x2)         */
-    MOVQ       ( MM5, MM4 )
-
-    PUNPCKLDQ  ( MM3, MM3 )
-    PFMUL      ( MM5, MM5 )
-
-    PFRSQIT1   ( MM3, MM5 )
-    DEC_L      ( EBP )                  /* decrement normal counter           */
-
-    PFRCPIT2   ( MM4, MM5 )
-    PFMUL      ( MM5, MM6 )             /* x1 (normalized) | x0 (normalized)  */
-
-    MOVQ       ( MM6, REGOFF(-12, EAX) ) /* write r0, r1                      */
-    PFMUL      ( MM5, MM7 )             /*                 | x2 (normalized)  */
-
-    MOVD       ( MM7, REGOFF(-4, EAX) ) /* write r2                           */
-    JA         ( LLBL (G3TNNR_norm) )
-
-
-LLBL (G3TNNR_exit_3dnow):
-    FEMMS
-
-LLBL (G3TNNR_end):
-    POP_L      ( EBP )
-    POP_L      ( ESI )
-    POP_L      ( EDI )
-    RET
-
-
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_rescale_normals_no_rot_raw)
-GLNAME(gl_3dnow_transform_rescale_normals_no_rot_raw):
-
- #undef FRAME_OFFSET
- #define FRAME_OFFSET 12
-
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-    PUSH_L     ( EBP )
-
-    MOV_L      ( ARG_IN, EAX )
-    MOV_L      ( ARG_DEST, EDX )
-    MOV_L      ( REGOFF(V3F_COUNT, EAX), EBP ) /*  dest->count = in->count   */
-    MOV_L      ( EBP, REGOFF(V3F_COUNT, EDX) )
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_MAT, ECX )
-    MOV_L      ( REGOFF(MAT_INV, ECX), ECX ) /*  mat->inv     */
-    MOV_L      ( REGOFF(V3F_START, EDX), EAX ) /*  dest->start  */
-    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
-
-    CMP_L      ( CONST(0), EBP )
-    JE         ( LLBL (G3TRNR_end) )
-
-    FEMMS
-
-    MOVD       ( ARG_SCALE, MM6 )       /*               | scale              */
-    PUNPCKLDQ  ( MM6, MM6 )             /* scale         | scale              */
-
-    MOVD       ( REGIND(ECX), MM0 )     /*               | m0                 */
-    PUNPCKLDQ  ( REGOFF(20, ECX), MM0 ) /* m5            | m0                 */
-
-    PFMUL      ( MM6, MM0 )             /* scale*m5      | scale*m0           */
-    MOVD       ( REGOFF(40, ECX), MM2 ) /*               | m10                */
-
-    PFMUL      ( MM6, MM2 )             /*               | scale*m10          */
-
-ALIGNTEXT32
-LLBL (G3TRNR_rescale):
-
-    MOVQ       ( REGIND(EDX), MM4 )     /* x1            | x0                 */
-    MOVD       ( REGOFF(8, EDX), MM5 )  /*               | x2                 */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    PFMUL      ( MM0, MM4 )             /* x1*m5         | x0*m0              */
-    ADD_L      ( STRIDE, EDX )          /* next normal                        */
-
-    PREFETCH   ( REGIND(EDX) )
-
-    PFMUL      ( MM2, MM5 )             /*               | x2*m10             */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    DEC_L      ( EBP )                  /* decrement normal counter           */
-    MOVQ       ( MM4, REGOFF(-12, EAX) ) /* write r0, r1                      */
-
-    MOVD       ( MM5, REGOFF(-4, EAX) ) /* write r2                           */
-    JA         ( LLBL (G3TRNR_rescale) ) /* cnt > 0 ? -> process next normal  */
-
-    FEMMS
-
-LLBL (G3TRNR_end):
-    POP_L      ( EBP )
-    POP_L      ( ESI )
-    POP_L      ( EDI )
-    RET
-
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_rescale_normals_raw)
-GLNAME(gl_3dnow_transform_rescale_normals_raw):
-
- #undef  FRAME_OFFSET
- #define FRAME_OFFSET 8
-
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_DEST, EAX )
-    MOV_L      ( ARG_MAT, ECX )
-    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDI ) /*  dest->count = in->count   */
-    MOV_L      ( EDI, REGOFF(V3F_COUNT, EAX) )
-    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
-    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
-    MOV_L      ( REGOFF(MAT_INV, ECX), ECX ) /*  mat->inv     */
-
-    CMP_L      ( CONST(0), EDI )
-    JE         ( LLBL (G3TR_end) )
-
-    FEMMS
-
-    MOVQ       ( REGIND(ECX), MM3 )     /* m1            | m0                 */
-
-    MOVQ       ( REGOFF(16,ECX), MM4 )  /* m5            | m4                 */
-    MOVD       ( ARG_SCALE, MM0 )       /* scale       */
-
-    MOVD       ( REGOFF(8,ECX), MM5 )   /*               | m2                 */
-    PUNPCKLDQ  ( MM0, MM0 )             /* scale         | scale              */
-
-    PUNPCKLDQ  ( REGOFF(24, ECX), MM5 )
-    PFMUL      ( MM0, MM3 )             /* scale*m1      | scale*m0           */
-
-    MOVQ       ( REGOFF(32, ECX), MM6 ) /* m9            | m8*/
-    PFMUL      ( MM0, MM4 )             /* scale*m5      | scale*m4           */
-
-    MOVD       ( REGOFF(40, ECX), MM7 ) /*               | m10                */
-    PFMUL      ( MM0, MM5 )             /* scale*m6      | scale*m2           */
-
-    PFMUL      ( MM0, MM6 )             /* scale*m9      | scale*m8           */
-
-    PFMUL      ( MM0, MM7 )             /*               | scale*m10          */
-
-ALIGNTEXT32
-LLBL (G3TR_rescale):
-
-    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
-    MOVQ       ( REGIND(EDX), MM0 )     /* x1            | x0                 */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    MOVQ       ( MM0, MM1 )             /* x1            | x0                 */
-    PUNPCKLDQ  ( MM2, MM2 )             /* x2            | x2                 */
-
-    PFMUL      ( MM3, MM0 )             /* x1*m1         | x0*m0              */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    PFMUL      ( MM4, MM1 )             /* x1*m5         | x0*m4              */
-    PFACC      ( MM1, MM0 )             /* x0*m4+x1*m5   | x0*m0+x1*m1        */
-
-    MOVQ       ( REGIND(EDX), MM1 )     /* x1            | x0                 */
-
-    PFMUL      ( MM5, MM2 )             /* x2*m6         | x2*m2              */
-    PFADD      ( MM2, MM0 )             /* x0*m4...+x2*m6| x0*m0+x1*m1+x2*m2  */
-
-    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
-    ADD_L      ( STRIDE, EDX )          /* next normal                    */
-
-    PREFETCH   ( REGIND(EDX) )
-
-    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write r0, r1                      */
-    PFMUL      ( MM6, MM1 )             /* x1*m9         | x0*m8              */
-
-    PFMUL      ( MM7, MM2 )             /*               | x2*m10             */
-    PFACC      ( MM1, MM1 )             /* *not used*    | x0*m8+x1*m9        */
-
-    PFADD      ( MM2, MM1 )             /* *not used*    | x0*m8+x1*m9+x2*m10 */
-    MOVD       ( MM1, REGOFF(-4, EAX) ) /* write r2                           */
-
-    DEC_L      ( EDI )                  /* decrement normal counter           */
-    JA         ( LLBL (G3TR_rescale) )
-
-    FEMMS
-
-LLBL (G3TR_end):
-    POP_L       ( ESI )
-    POP_L       ( EDI )
-    RET
-
-
-
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_normals_no_rot_raw)
-GLNAME(gl_3dnow_transform_normals_no_rot_raw):
-
- #undef  FRAME_OFFSET
- #define FRAME_OFFSET 8
-
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_DEST, EAX )
-    MOV_L      ( ARG_MAT, ECX )
-    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDI ) /*  dest->count = in->count   */
-    MOV_L      ( EDI, REGOFF(V3F_COUNT, EAX) )
-    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
-    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
-    MOV_L      ( REGOFF(MAT_INV, ECX), ECX ) /*  mat->inv     */
-
-    CMP_L      ( CONST(0), EDI )
-    JE         ( LLBL (G3TNR_end) )
-
-    FEMMS
-
-    MOVD       ( REGIND(ECX), MM0 )     /*               | m0                 */
-    PUNPCKLDQ  ( REGOFF(20, ECX), MM0 ) /* m5            | m0                 */
-
-    MOVD       ( REGOFF(40, ECX), MM2 ) /*               | m10                */
-    PUNPCKLDQ  ( MM2, MM2 )             /* m10           | m10                */
-
-ALIGNTEXT32
-LLBL (G3TNR_transform):
-
-    MOVQ       ( REGIND(EDX), MM4 )     /* x1            | x0                 */
-    MOVD       ( REGOFF(8, EDX), MM5 )  /*               | x2                 */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    PFMUL      ( MM0, MM4 )             /* x1*m5         | x0*m0              */
-    ADD_L      ( STRIDE, EDX)           /* next normal      */
-
-    PREFETCH   ( REGIND(EDX) )
-
-    PFMUL      ( MM2, MM5 )             /*               | x2*m10             */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    DEC_L      ( EDI )                  /* decrement normal counter           */
-    MOVQ       ( MM4, REGOFF(-12, EAX) ) /* write r0, r1                      */
-
-    MOVD       ( MM5, REGOFF(-4, EAX) ) /* write r2                           */
-    JA         ( LLBL (G3TNR_transform) )
-
-    FEMMS
-
-LLBL (G3TNR_end):
-    POP_L       ( ESI )
-    POP_L       ( EDI )
-    RET
-
-
-
-
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_normals_raw)
-GLNAME(gl_3dnow_transform_normals_raw):
-
- #undef  FRAME_OFFSET
- #define FRAME_OFFSET 8
-
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_DEST, EAX )
-    MOV_L      ( ARG_MAT, ECX )
-    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDI ) /*  dest->count = in->count   */
-    MOV_L      ( EDI, REGOFF(V3F_COUNT, EAX) )
-    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
-    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
-    MOV_L      ( REGOFF(MAT_INV, ECX), ECX ) /*  mat->inv     */
-
-    CMP_L      ( CONST(0), EDI )        /* count > 0 ??                       */
-    JE         ( LLBL (G3T_end) )
-
-    FEMMS
-
-    MOVQ       ( REGIND(ECX), MM3 )     /* m1            | m0                 */
-    MOVQ       ( REGOFF(16, ECX), MM4 ) /* m5            | m4                 */
-
-    MOVD       ( REGOFF(8, ECX), MM5 )  /*               | m2                 */
-    PUNPCKLDQ  ( REGOFF(24, ECX), MM5 ) /* m6            | m2                 */
-
-    MOVQ       ( REGOFF(32, ECX), MM6 ) /* m9            | m8                 */
-    MOVD       ( REGOFF(40, ECX), MM7 ) /*               | m10                */
-
-ALIGNTEXT32
-LLBL (G3T_transform):
-
-    MOVQ       ( REGIND(EDX), MM0 )     /* x1            | x0                 */
-    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    MOVQ       ( MM0, MM1 )             /* x1            | x0                 */
-    PUNPCKLDQ  ( MM2, MM2 )             /* x2            | x2                 */
-
-    PFMUL      ( MM3, MM0 )             /* x1*m1         | x0*m0              */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    PFMUL      ( MM4, MM1 )             /* x1*m5         | x0*m4              */
-    PFACC      ( MM1, MM0 )             /* x0*m4+x1*m5   | x0*m0+x1*m1        */
-
-    PFMUL      ( MM5, MM2 )             /* x2*m6         | x2*m2              */
-    PFADD      ( MM2, MM0 )             /* x0*m4...+x2*m6| x0*m0+x1*m1+x2*m2  */
-
-    MOVQ       ( REGIND(EDX), MM1 )     /* x1            | x0                 */
-    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write r0, r1                      */
-
-    PFMUL      ( MM6, MM1 )             /* x1*m9         | x0*m8              */
-    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
-
-    PFMUL      ( MM7, MM2 )             /*               | x2*m10             */
-    ADD_L      ( STRIDE, EDX )          /* next normal               */
-
-    PREFETCH   ( REGIND(EDX) )
-
-    PFACC      ( MM1, MM1 )             /* *not used*    | x0*m8+x1*m9        */
-    PFADD      ( MM2, MM1 )             /* *not used*    | x0*m8+x1*m9+x2*m10 */
-
-    MOVD       ( MM1, REGOFF(-4, EAX) ) /* write r2                           */
-    DEC_L      ( EDI )                  /* decrement normal counter           */
-    JA         ( LLBL (G3T_transform) )
-
-    FEMMS
-
-LLBL (G3T_end):
-    POP_L  ( ESI )
-    POP_L  ( EDI )
-    RET
-
-
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_normalize_normals_raw)
-GLNAME(gl_3dnow_normalize_normals_raw):
-
- #undef  FRAME_OFFSET
- #define FRAME_OFFSET 12
-
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-    PUSH_L     ( EBP )
-
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_DEST, EAX )
-    MOV_L      ( REGOFF(V3F_COUNT, ESI), EBP ) /*  dest->count = in->count   */
-    MOV_L      ( EBP, REGOFF(V3F_COUNT, EAX) )
-    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
-    MOV_L      ( REGOFF(V3F_START, ESI), ECX ) /*  in->start    */
-    MOV_L      ( ARG_LENGTHS, EDX )
-
-    CMP_L      ( CONST(0), EBP ) /* count > 0 ?? */
-    JE         ( LLBL (G3N_end) )
-
-    FEMMS
-
-    CMP_L      ( CONST(0), EDX )        /* lengths == 0 ?                     */
-    JE         ( LLBL (G3N_norm2) )     /* calculate lengths                  */
-
-ALIGNTEXT32
-LLBL (G3N_norm1):                       /* use precalculated lengths          */
-
-    MOVQ       ( REGIND(ECX), MM0 )     /* x1              | x0               */
-    MOVD       ( REGOFF(8, ECX), MM1 )  /*                 | x2               */
-
-    PREFETCH   ( REGIND(EAX) )
-
-    MOVD       ( REGIND(EDX), MM3 )     /*                 | length (x)       */
-    PFMUL      ( MM3, MM1 )             /*                 | x2 (normalized)  */
-
-    PUNPCKLDQ  ( MM3, MM3 )             /* length (x)      | length (x)       */
-    ADD_L      ( STRIDE, ECX )          /* next normal            */
-
-    PREFETCH   ( REGIND(ECX) )
-
-    PFMUL      ( MM3, MM0 )             /* x1 (normalized) | x0 (normalized)  */
-    MOVQ       ( MM0, REGIND(EAX) )     /* write new x0, x1                   */
-
-    MOVD       ( MM1, REGOFF(8, EAX) )  /* write new x2                       */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    ADD_L      ( CONST(4), EDX )        /* next length                        */
-    DEC_L      ( EBP )                  /* decrement normal counter           */
-
-    JA         ( LLBL (G3N_norm1) )
-
-    JMP        ( LLBL (G3N_end1) )
-
-ALIGNTEXT32
-LLBL (G3N_norm2):                       /* need to calculate lengths          */
-
-    MOVQ       ( REGIND(ECX), MM0 )     /* x1              | x0               */
-    MOVD       ( REGOFF(8, ECX), MM1 )  /*                 | x2               */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    MOVQ       ( MM0, MM3 )             /* x1              | x0               */
-    ADD_L      ( STRIDE, ECX )          /* next normal    */
-
-    PREFETCH   ( REGIND(ECX) )
-
-    PFMUL      ( MM0, MM3 )             /* x1*x1           | x0*x0            */
-    MOVQ       ( MM1, MM4 )             /*                 | x2               */
-
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-    PFMUL      ( MM1, MM4 )             /*                 | x2*x2            */
-
-    PFADD      ( MM4, MM3 )             /*                 | x0*x0+x2*x2      */
-    PFACC      ( MM3, MM3 )             /* x0*x0+...+x2*x2 | x0*x0+x1*x1+x2*x2*/
-
-    PFRSQRT    ( MM3, MM5 )             /* 1/sqrt (x0*x0+x1*x1+x2*x2)         */
-    MOVQ       ( MM5, MM4 )
-
-    PUNPCKLDQ  ( MM3, MM3 )
-    PFMUL      ( MM5, MM5 )
-
-    PFRSQIT1   ( MM3, MM5 )
-    DEC_L      ( EBP )                  /* decrement normal counter           */
-
-    PFRCPIT2   ( MM4, MM5 )
-
-    PFMUL      ( MM5, MM0 )             /* x1 (normalized) | x0 (normalized)  */
-    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write new x0, x1                  */
-
-    PFMUL      ( MM5, MM1 )             /*                 | x2 (normalized)  */
-    MOVD       ( MM1, REGOFF(-4, EAX) ) /* write new x2                       */
-
-    JA         ( LLBL (G3N_norm2) )
-
-LLBL (G3N_end1):
-    FEMMS
-
-LLBL (G3N_end):
-    POP_L      ( EBP )
-    POP_L      ( ESI )
-    POP_L      ( EDI )
-    RET
-
-
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_rescale_normals_raw)
-GLNAME(gl_3dnow_rescale_normals_raw):
-
- #undef  FRAME_OFFSET
- #define FRAME_OFFSET 8
-    PUSH_L     ( EDI )
-    PUSH_L     ( ESI )
-
-    MOV_L      ( ARG_IN, ESI )
-    MOV_L      ( ARG_DEST, EAX )
-    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDX ) /*  dest->count = in->count   */
-    MOV_L      ( EDX, REGOFF(V3F_COUNT, EAX) )
-    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
-    MOV_L      ( REGOFF(V3F_START, ESI), ECX ) /*  in->start    */
-
-    CMP_L      ( CONST(0), EDX )
-    JE         ( LLBL (G3R_end) )
-
-    FEMMS
-
-    MOVD       ( ARG_SCALE, MM0 )       /* scale                              */
-    PUNPCKLDQ  ( MM0, MM0 )
-
-ALIGNTEXT32
-LLBL (G3R_rescale):
-
-    MOVQ       ( REGIND(ECX), MM1 )     /* x1            | x0                 */
-    MOVD       ( REGOFF(8, ECX), MM2 )  /*               | x2                 */
-
-    PREFETCHW  ( REGIND(EAX) )
-
-    PFMUL      ( MM0, MM1 )             /* x1*scale      | x0*scale           */
-    ADD_L      ( STRIDE, ECX )          /* next normal                  */
-
-    PREFETCH   ( REGIND(ECX) )
-
-    PFMUL      ( MM0, MM2 )             /*               | x2*scale           */
-    ADD_L      ( CONST(12), EAX )       /* next r                             */
-
-    MOVQ       ( MM1, REGOFF(-12, EAX) ) /* write r0, r1                      */
-    MOVD       ( MM2, REGOFF(-4, EAX) ) /* write r2                           */
-
-    DEC_L      ( EDX )                  /* decrement normal counter           */
-    JA         ( LLBL (G3R_rescale) )
-
-    FEMMS
-
-LLBL (G3R_end):
-    POP_L      ( ESI )
-    POP_L      ( EDI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_normal.S
diff -u /dev/null xc/extras/Mesa/src/X86/3dnow_normal.S:1.3
--- /dev/null	Thu Feb 27 12:15:53 2003
+++ xc/extras/Mesa/src/X86/3dnow_normal.S	Sat Jan 11 22:55:44 2003
@@ -0,0 +1,836 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/X86/3dnow_normal.S,v 1.3 2003/01/12 03:55:44 tsi Exp $ */
+
+/*
+ * 3Dnow assembly code by Holger Waechtler
+ */
+
+#include "matypes.h"
+#include "norm_args.h"
+
+        SEG_TEXT
+
+#define M(i)    REGOFF(i * 4, ECX)
+#define STRIDE  REGOFF(12, ESI)
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_transform_normalize_normals)
+GLNAME(_mesa_3dnow_transform_normalize_normals):
+
+#define FRAME_OFFSET 12
+
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+    PUSH_L     ( EBP )
+
+    MOV_L      ( ARG_LENGTHS, EDI )
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_DEST, EAX )
+    MOV_L      ( REGOFF(V3F_COUNT, ESI), EBP ) /*  dest->count = in->count   */
+    MOV_L      ( EBP, REGOFF(V3F_COUNT, EAX) )
+    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
+    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
+    MOV_L      ( ARG_MAT, ECX )
+    MOV_L      ( REGOFF(MATRIX_INV, ECX), ECX ) /*  mat->inv     */
+
+    CMP_L      ( CONST(0), EBP )        /*   count > 0 ??  */
+    JE         ( LLBL (G3TN_end) )
+
+    MOV_L      ( REGOFF (V3F_COUNT, ESI), EBP )
+    FEMMS
+
+    PUSH_L     ( EBP )
+    PUSH_L     ( EAX )
+    PUSH_L     ( EDX )                  /*  save counter & pointer for   */
+                                        /*  the normalize pass           */
+#undef  FRAME_OFFSET
+#define FRAME_OFFSET 24
+
+    MOVQ       ( M(0), MM3 )            /*  m1              | m0         */
+    MOVQ       ( M(4), MM4 )            /*  m5              | m4         */
+
+    MOVD       ( M(2), MM5 )            /*                  | m2         */
+    PUNPCKLDQ  ( M(6), MM5 )            /*  m6              | m2         */
+
+    MOVQ       ( M(8), MM6 )            /*  m9              | m8         */
+    MOVQ       ( M(10), MM7 )           /*                  | m10        */
+
+    CMP_L      ( CONST(0), EDI )        /*  lengths == 0 ?                 */
+    JNE        ( LLBL (G3TN_scale_end ) )
+
+    MOVD       ( ARG_SCALE, MM0 )       /*               | scale           */
+    PUNPCKLDQ  ( MM0, MM0 )             /* scale         | scale           */
+
+    PFMUL      ( MM0, MM3 )             /* scale * m1    | scale * m0      */
+    PFMUL      ( MM0, MM4 )             /* scale * m5    | scale * m4      */
+    PFMUL      ( MM0, MM5 )             /* scale * m6    | scale * m2      */
+    PFMUL      ( MM0, MM6 )             /* scale * m9    | scale * m8      */
+    PFMUL      ( MM0, MM7 )             /*               | scale * m10     */
+
+ALIGNTEXT32
+LLBL (G3TN_scale_end):
+LLBL (G3TN_transform):
+    MOVQ       ( REGIND (EDX), MM0 )    /*  x1              | x0         */
+    MOVD       ( REGOFF (8, EDX), MM2 ) /*                  | x2         */
+
+    MOVQ       ( MM0, MM1 )             /*  x1              | x0           */
+    PUNPCKLDQ  ( MM2, MM2 )             /*  x2              | x2           */
+
+    PFMUL      ( MM3, MM0 )             /*  x1*m1           | x0*m0        */
+    ADD_L      ( CONST(12), EAX )       /*  next r                         */
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    PFMUL      ( MM4, MM1 )             /*  x1*m5           | x0*m4        */
+    PFACC      ( MM1, MM0 )             /*  x0*m4+x1*m5     | x0*m0+x1*m1  */
+
+    PFMUL      ( MM5, MM2 )             /*  x2*m6           | x2*m2        */
+    PFADD      ( MM2, MM0 )             /* x0*m4+x1*m5+x2*m6| x0*m0+...+x2**/
+
+    MOVQ       ( REGIND (EDX), MM1 )    /*  x1           | x0              */
+    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write r0, r1                   */
+
+    PFMUL      ( MM6, MM1 )             /* x1*m9         | x0*m8           */
+    MOVD       ( REGOFF (8, EDX), MM2 ) /*               | x2              */
+
+    PFMUL      ( MM7, MM2 )             /*               | x2*m10          */
+    PFACC      ( MM1, MM1 )             /*  *not used*   | x0*m8+x1*m9     */
+
+    PFADD      ( MM2, MM1 )             /*  *not used*   | x0*m8+x1*m9+x2*m*/
+    ADD_L      ( STRIDE, EDX )          /*  next normal                    */
+
+    PREFETCH   ( REGIND(EDX) )
+
+    MOVD       ( MM1, REGOFF(-4, EAX) ) /*  write r2                       */
+    DEC_L      ( EBP )                  /*  decrement normal counter       */
+    JA         ( LLBL (G3TN_transform) )
+
+
+    POP_L      ( EDX )                  /*  end of transform ---           */
+    POP_L      ( EAX )                  /*    now normalizing ...          */
+    POP_L      ( EBP )
+
+    CMP_L      ( CONST(0), EDI )        /*  lengths == 0 ?                 */
+    JE         ( LLBL (G3TN_norm ) )    /*  calculate lengths              */
+
+
+ALIGNTEXT32
+LLBL (G3TN_norm_w_lengths):
+
+    PREFETCHW  ( REGOFF(12,EAX) )
+
+    MOVQ       ( REGIND(EAX), MM0 )     /*  x1              | x0           */
+    MOVD       ( REGOFF(8, EAX), MM1 )  /*                  | x2           */
+
+    MOVD       ( REGIND (EDI), MM3 )    /*                  | length (x)   */
+    PFMUL      ( MM3, MM1 )             /*                  | x2 (normalize*/
+
+    PUNPCKLDQ  ( MM3, MM3 )             /*  length (x)      | length (x)   */
+    PFMUL      ( MM3, MM0 )             /*  x1 (normalized) | x0 (normalize*/
+
+    ADD_L      ( STRIDE, EDX )          /*  next normal                    */
+    ADD_L      ( CONST(4), EDI )        /*  next length                    */
+
+    PREFETCH   ( REGIND(EDI) )
+
+    MOVQ       ( MM0, REGIND(EAX) )     /*  write new x0, x1               */
+    MOVD       ( MM1, REGOFF(8, EAX) )  /*  write new x2                   */
+
+    ADD_L      ( CONST(12), EAX )       /*  next r                         */
+    DEC_L      ( EBP )                  /*  decrement normal counter       */
+
+    JA         ( LLBL (G3TN_norm_w_lengths) )
+    JMP        ( LLBL (G3TN_exit_3dnow) )
+
+ALIGNTEXT32
+LLBL (G3TN_norm):
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( MM0, MM3 )             /*  x1              | x0           */
+    MOVQ       ( MM1, MM4 )             /*                  | x2           */
+
+    PFMUL      ( MM0, MM3 )             /*  x1*x1           | x0*x0        */
+    ADD_L      ( CONST(12), EAX )       /*  next r                         */
+
+    PFMUL      ( MM1, MM4 )             /*                  | x2*x2        */
+    PFADD      ( MM4, MM3 )             /*                  | x0*x0+x2*x2  */
+
+    PFACC      ( MM3, MM3 )             /* **not used**    | x0*x0+x1*x1+x2**/
+    PFRSQRT    ( MM3, MM5 )             /*  1/sqrt (x0*x0+x1*x1+x2*x2)     */
+
+    MOVQ       ( MM5, MM4 )
+    PUNPCKLDQ  ( MM3, MM3 )
+
+    DEC_L      ( EBP )                  /*  decrement normal counter       */
+    PFMUL      ( MM5, MM5 )
+
+    PFRSQIT1   ( MM3, MM5 )
+    PFRCPIT2   ( MM4, MM5 )
+
+    PFMUL      ( MM5, MM0 )             /*  x1 (normalized) | x0 (normalize*/
+
+    MOVQ       ( MM0, REGOFF(-12, EAX) ) /*  write new x0, x1              */
+    PFMUL      ( MM5, MM1 )             /*                 | x2 (normalize*/
+
+    MOVD       ( MM1, REGOFF(-4, EAX) ) /*  write new x2                  */
+    MOVQ       ( REGIND (EAX), MM0 )    /*  x1             | x0           */
+
+    MOVD       ( REGOFF(8, EAX), MM1 )  /*                 | x2           */
+    JA         ( LLBL (G3TN_norm) )
+
+LLBL (G3TN_exit_3dnow):
+    FEMMS
+
+LLBL (G3TN_end):
+    POP_L      ( EBP )
+    POP_L      ( ESI )
+    POP_L      ( EDI )
+    RET
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_transform_normalize_normals_no_rot)
+GLNAME(_mesa_3dnow_transform_normalize_normals_no_rot):
+
+#undef FRAME_OFFSET
+#define FRAME_OFFSET 12
+
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+    PUSH_L     ( EBP )
+
+    MOV_L      ( ARG_LENGTHS, EDI )
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_DEST, EAX )
+    MOV_L      ( REGOFF(V3F_COUNT, ESI), EBP ) /*  dest->count = in->count   */
+    MOV_L      ( EBP, REGOFF(V3F_COUNT, EAX) )
+    MOV_L      ( ARG_MAT, ECX )
+    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
+    MOV_L      ( REGOFF(MATRIX_INV, ECX), ECX ) /*  mat->inv     */
+    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
+
+    CMP_L      ( CONST(0), EBP ) /*   count > 0 ??  */
+    JE         ( LLBL (G3TNNR_end) )
+
+    FEMMS
+
+    MOVD       ( M(0), MM0 )            /*               | m0                 */
+    PUNPCKLDQ  ( M(5), MM0 )            /* m5            | m0                 */
+
+    MOVD       ( M(10), MM2 )           /*               | m10                */
+    PUNPCKLDQ  ( MM2, MM2 )             /* m10           | m10                */
+
+    CMP_L      ( CONST(0), EDI )        /*  lengths == 0 ?                    */
+    JNE        ( LLBL (G3TNNR_scale_end ) )
+
+    MOVD       ( ARG_SCALE, MM7 )       /*               | scale              */
+    PUNPCKLDQ  ( MM7, MM7 )             /* scale         | scale              */
+
+    PFMUL      ( MM7, MM0 )             /* scale * m5    | scale * m0         */
+    PFMUL      ( MM7, MM2 )             /* scale * m10   | scale * m10        */
+
+ALIGNTEXT32
+LLBL (G3TNNR_scale_end):
+    CMP_L      ( CONST(0), EDI )        /* lengths == 0 ?                     */
+    JE         ( LLBL (G3TNNR_norm) )   /* need to calculate lengths          */
+
+    MOVD       ( REGIND(EDI), MM3 )     /*                 | length (x)       */
+
+
+ALIGNTEXT32
+LLBL (G3TNNR_norm_w_lengths):           /* use precalculated lengths          */
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( REGIND(EDX), MM6 )     /* x1            | x0                 */
+    MOVD       ( REGOFF(8, EDX), MM7 )  /*               | x2                 */
+
+    PFMUL      ( MM0, MM6 )             /* x1*m5         | x0*m0              */
+    ADD_L      ( STRIDE, EDX )          /* next normal                        */
+
+    PREFETCH   ( REGIND(EDX) )
+
+    PFMUL      ( MM2, MM7 )             /*               | x2*m10             */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    PFMUL      ( MM3, MM7 )             /*               | x2 (normalized)  */
+    PUNPCKLDQ  ( MM3, MM3 )             /* length (x)    | length (x)       */
+
+    ADD_L      ( CONST(4), EDI )        /* next length                        */
+    PFMUL      ( MM3, MM6 )             /* x1 (normalized) | x0 (normalized)  */
+
+    DEC_L      ( EBP )                  /* decrement normal counter           */
+    MOVQ       ( MM6, REGOFF(-12, EAX) ) /* write r0, r1                      */
+
+    MOVD       ( MM7, REGOFF(-4, EAX) ) /* write r2                           */
+    MOVD       ( REGIND(EDI), MM3 )     /*                 | length (x)       */
+
+    JA         ( LLBL (G3TNNR_norm_w_lengths) )
+    JMP        ( LLBL (G3TNNR_exit_3dnow) )
+
+ALIGNTEXT32
+LLBL (G3TNNR_norm):                     /* need to calculate lengths          */
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( REGIND(EDX), MM6 )     /* x1              | x0               */
+    MOVD       ( REGOFF(8, EDX), MM7 )  /*                 | x2               */
+
+    PFMUL      ( MM0, MM6 )             /* x1*m5           | x0*m0            */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    PFMUL      ( MM2, MM7 )             /*                 | x2*m10           */
+    MOVQ       ( MM6, MM3 )             /* x1 (transformed)| x0 (transformed) */
+
+    MOVQ       ( MM7, MM4 )             /*                 | x2 (transformed) */
+    PFMUL      ( MM6, MM3 )             /* x1*x1           | x0*x0            */
+
+
+    PFMUL      ( MM7, MM4 )             /*                 | x2*x2            */
+    PFACC      ( MM3, MM3 )             /* **not used**    | x0*x0+x1*x1      */
+
+    PFADD      ( MM4, MM3 )             /*                 | x0*x0+x1*x1+x2*x2*/
+    ADD_L      ( STRIDE, EDX )          /* next normal            */
+
+    PREFETCH   ( REGIND(EDX) )
+
+    PFRSQRT    ( MM3, MM5 )             /* 1/sqrt (x0*x0+x1*x1+x2*x2)         */
+    MOVQ       ( MM5, MM4 )
+
+    PUNPCKLDQ  ( MM3, MM3 )
+    PFMUL      ( MM5, MM5 )
+
+    PFRSQIT1   ( MM3, MM5 )
+    DEC_L      ( EBP )                  /* decrement normal counter           */
+
+    PFRCPIT2   ( MM4, MM5 )
+    PFMUL      ( MM5, MM6 )             /* x1 (normalized) | x0 (normalized)  */
+
+    MOVQ       ( MM6, REGOFF(-12, EAX) ) /* write r0, r1                      */
+    PFMUL      ( MM5, MM7 )             /*                 | x2 (normalized)  */
+
+    MOVD       ( MM7, REGOFF(-4, EAX) ) /* write r2                           */
+    JA         ( LLBL (G3TNNR_norm) )
+
+
+LLBL (G3TNNR_exit_3dnow):
+    FEMMS
+
+LLBL (G3TNNR_end):
+    POP_L      ( EBP )
+    POP_L      ( ESI )
+    POP_L      ( EDI )
+    RET
+
+
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_transform_rescale_normals_no_rot)
+GLNAME(_mesa_3dnow_transform_rescale_normals_no_rot):
+
+#undef FRAME_OFFSET
+#define FRAME_OFFSET 12
+
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+    PUSH_L     ( EBP )
+
+    MOV_L      ( ARG_IN, EAX )
+    MOV_L      ( ARG_DEST, EDX )
+    MOV_L      ( REGOFF(V3F_COUNT, EAX), EBP ) /*  dest->count = in->count   */
+    MOV_L      ( EBP, REGOFF(V3F_COUNT, EDX) )
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_MAT, ECX )
+    MOV_L      ( REGOFF(MATRIX_INV, ECX), ECX ) /*  mat->inv     */
+    MOV_L      ( REGOFF(V3F_START, EDX), EAX ) /*  dest->start  */
+    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
+
+    CMP_L      ( CONST(0), EBP )
+    JE         ( LLBL (G3TRNR_end) )
+
+    FEMMS
+
+    MOVD       ( ARG_SCALE, MM6 )       /*               | scale              */
+    PUNPCKLDQ  ( MM6, MM6 )             /* scale         | scale              */
+
+    MOVD       ( REGIND(ECX), MM0 )     /*               | m0                 */
+    PUNPCKLDQ  ( REGOFF(20, ECX), MM0 ) /* m5            | m0                 */
+
+    PFMUL      ( MM6, MM0 )             /* scale*m5      | scale*m0           */
+    MOVD       ( REGOFF(40, ECX), MM2 ) /*               | m10                */
+
+    PFMUL      ( MM6, MM2 )             /*               | scale*m10          */
+
+ALIGNTEXT32
+LLBL (G3TRNR_rescale):
+
+    PREFETCHW  ( REGIND(EAX) )
+	
+    MOVQ       ( REGIND(EDX), MM4 )     /* x1            | x0                 */
+    MOVD       ( REGOFF(8, EDX), MM5 )  /*               | x2                 */
+	
+    PFMUL      ( MM0, MM4 )             /* x1*m5         | x0*m0              */
+    ADD_L      ( STRIDE, EDX )          /* next normal                        */
+
+    PREFETCH   ( REGIND(EDX) )
+
+    PFMUL      ( MM2, MM5 )             /*               | x2*m10             */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    DEC_L      ( EBP )                  /* decrement normal counter           */
+    MOVQ       ( MM4, REGOFF(-12, EAX) ) /* write r0, r1                      */
+
+    MOVD       ( MM5, REGOFF(-4, EAX) ) /* write r2                           */
+    JA         ( LLBL (G3TRNR_rescale) ) /* cnt > 0 ? -> process next normal  */
+
+    FEMMS
+
+LLBL (G3TRNR_end):
+    POP_L      ( EBP )
+    POP_L      ( ESI )
+    POP_L      ( EDI )
+    RET
+
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_transform_rescale_normals)
+GLNAME(_mesa_3dnow_transform_rescale_normals):
+
+#undef  FRAME_OFFSET
+#define FRAME_OFFSET 8
+
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_DEST, EAX )
+    MOV_L      ( ARG_MAT, ECX )
+    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDI ) /*  dest->count = in->count   */
+    MOV_L      ( EDI, REGOFF(V3F_COUNT, EAX) )
+    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
+    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
+    MOV_L      ( REGOFF(MATRIX_INV, ECX), ECX ) /*  mat->inv     */
+
+    CMP_L      ( CONST(0), EDI )
+    JE         ( LLBL (G3TR_end) )
+
+    FEMMS
+
+    MOVQ       ( REGIND(ECX), MM3 )     /* m1            | m0                 */
+
+    MOVQ       ( REGOFF(16,ECX), MM4 )  /* m5            | m4                 */
+    MOVD       ( ARG_SCALE, MM0 )       /* scale       */
+
+    MOVD       ( REGOFF(8,ECX), MM5 )   /*               | m2                 */
+    PUNPCKLDQ  ( MM0, MM0 )             /* scale         | scale              */
+
+    PUNPCKLDQ  ( REGOFF(24, ECX), MM5 )
+    PFMUL      ( MM0, MM3 )             /* scale*m1      | scale*m0           */
+
+    MOVQ       ( REGOFF(32, ECX), MM6 ) /* m9            | m8*/
+    PFMUL      ( MM0, MM4 )             /* scale*m5      | scale*m4           */
+
+    MOVD       ( REGOFF(40, ECX), MM7 ) /*               | m10                */
+    PFMUL      ( MM0, MM5 )             /* scale*m6      | scale*m2           */
+
+    PFMUL      ( MM0, MM6 )             /* scale*m9      | scale*m8           */
+
+    PFMUL      ( MM0, MM7 )             /*               | scale*m10          */
+
+ALIGNTEXT32
+LLBL (G3TR_rescale):
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( REGIND(EDX), MM0 )     /* x1            | x0                 */
+    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
+
+    MOVQ       ( MM0, MM1 )             /* x1            | x0                 */
+    PUNPCKLDQ  ( MM2, MM2 )             /* x2            | x2                 */
+
+    PFMUL      ( MM3, MM0 )             /* x1*m1         | x0*m0              */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    PFMUL      ( MM4, MM1 )             /* x1*m5         | x0*m4              */
+    PFACC      ( MM1, MM0 )             /* x0*m4+x1*m5   | x0*m0+x1*m1        */
+
+    MOVQ       ( REGIND(EDX), MM1 )     /* x1            | x0                 */
+
+    PFMUL      ( MM5, MM2 )             /* x2*m6         | x2*m2              */
+    PFADD      ( MM2, MM0 )             /* x0*m4...+x2*m6| x0*m0+x1*m1+x2*m2  */
+
+    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
+    ADD_L      ( STRIDE, EDX )          /* next normal                    */
+
+    PREFETCH   ( REGIND(EDX) )
+
+    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write r0, r1                      */
+    PFMUL      ( MM6, MM1 )             /* x1*m9         | x0*m8              */
+
+    PFMUL      ( MM7, MM2 )             /*               | x2*m10             */
+    PFACC      ( MM1, MM1 )             /* *not used*    | x0*m8+x1*m9        */
+
+    PFADD      ( MM2, MM1 )             /* *not used*    | x0*m8+x1*m9+x2*m10 */
+    MOVD       ( MM1, REGOFF(-4, EAX) ) /* write r2                           */
+
+    DEC_L      ( EDI )                  /* decrement normal counter           */
+    JA         ( LLBL (G3TR_rescale) )
+
+    FEMMS
+
+LLBL (G3TR_end):
+    POP_L       ( ESI )
+    POP_L       ( EDI )
+    RET
+
+
+
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_transform_normals_no_rot)
+GLNAME(_mesa_3dnow_transform_normals_no_rot):
+
+#undef  FRAME_OFFSET
+#define FRAME_OFFSET 8
+
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_DEST, EAX )
+    MOV_L      ( ARG_MAT, ECX )
+    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDI ) /*  dest->count = in->count   */
+    MOV_L      ( EDI, REGOFF(V3F_COUNT, EAX) )
+    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
+    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
+    MOV_L      ( REGOFF(MATRIX_INV, ECX), ECX ) /*  mat->inv     */
+
+    CMP_L      ( CONST(0), EDI )
+    JE         ( LLBL (G3TNR_end) )
+
+    FEMMS
+
+    MOVD       ( REGIND(ECX), MM0 )     /*               | m0                 */
+    PUNPCKLDQ  ( REGOFF(20, ECX), MM0 ) /* m5            | m0                 */
+
+    MOVD       ( REGOFF(40, ECX), MM2 ) /*               | m10                */
+    PUNPCKLDQ  ( MM2, MM2 )             /* m10           | m10                */
+
+ALIGNTEXT32
+LLBL (G3TNR_transform):
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( REGIND(EDX), MM4 )     /* x1            | x0                 */
+    MOVD       ( REGOFF(8, EDX), MM5 )  /*               | x2                 */
+
+    PFMUL      ( MM0, MM4 )             /* x1*m5         | x0*m0              */
+    ADD_L      ( STRIDE, EDX)           /* next normal      */
+
+    PREFETCH   ( REGIND(EDX) )
+
+    PFMUL      ( MM2, MM5 )             /*               | x2*m10             */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    DEC_L      ( EDI )                  /* decrement normal counter           */
+    MOVQ       ( MM4, REGOFF(-12, EAX) ) /* write r0, r1                      */
+
+    MOVD       ( MM5, REGOFF(-4, EAX) ) /* write r2                           */
+    JA         ( LLBL (G3TNR_transform) )
+
+    FEMMS
+
+LLBL (G3TNR_end):
+    POP_L       ( ESI )
+    POP_L       ( EDI )
+    RET
+
+
+
+
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_transform_normals)
+GLNAME(_mesa_3dnow_transform_normals):
+
+#undef  FRAME_OFFSET
+#define FRAME_OFFSET 8
+
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_DEST, EAX )
+    MOV_L      ( ARG_MAT, ECX )
+    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDI ) /*  dest->count = in->count   */
+    MOV_L      ( EDI, REGOFF(V3F_COUNT, EAX) )
+    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
+    MOV_L      ( REGOFF(V3F_START, ESI), EDX ) /*  in->start    */
+    MOV_L      ( REGOFF(MATRIX_INV, ECX), ECX ) /*  mat->inv     */
+
+    CMP_L      ( CONST(0), EDI )        /* count > 0 ??                       */
+    JE         ( LLBL (G3T_end) )
+
+    FEMMS
+
+    MOVQ       ( REGIND(ECX), MM3 )     /* m1            | m0                 */
+    MOVQ       ( REGOFF(16, ECX), MM4 ) /* m5            | m4                 */
+
+    MOVD       ( REGOFF(8, ECX), MM5 )  /*               | m2                 */
+    PUNPCKLDQ  ( REGOFF(24, ECX), MM5 ) /* m6            | m2                 */
+
+    MOVQ       ( REGOFF(32, ECX), MM6 ) /* m9            | m8                 */
+    MOVD       ( REGOFF(40, ECX), MM7 ) /*               | m10                */
+
+ALIGNTEXT32
+LLBL (G3T_transform):
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( REGIND(EDX), MM0 )     /* x1            | x0                 */
+    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
+
+    MOVQ       ( MM0, MM1 )             /* x1            | x0                 */
+    PUNPCKLDQ  ( MM2, MM2 )             /* x2            | x2                 */
+
+    PFMUL      ( MM3, MM0 )             /* x1*m1         | x0*m0              */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    PFMUL      ( MM4, MM1 )             /* x1*m5         | x0*m4              */
+    PFACC      ( MM1, MM0 )             /* x0*m4+x1*m5   | x0*m0+x1*m1        */
+
+    PFMUL      ( MM5, MM2 )             /* x2*m6         | x2*m2              */
+    PFADD      ( MM2, MM0 )             /* x0*m4...+x2*m6| x0*m0+x1*m1+x2*m2  */
+
+    MOVQ       ( REGIND(EDX), MM1 )     /* x1            | x0                 */
+    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write r0, r1                      */
+
+    PFMUL      ( MM6, MM1 )             /* x1*m9         | x0*m8              */
+    MOVD       ( REGOFF(8, EDX), MM2 )  /*               | x2                 */
+
+    PFMUL      ( MM7, MM2 )             /*               | x2*m10             */
+    ADD_L      ( STRIDE, EDX )          /* next normal               */
+
+    PREFETCH   ( REGIND(EDX) )
+
+    PFACC      ( MM1, MM1 )             /* *not used*    | x0*m8+x1*m9        */
+    PFADD      ( MM2, MM1 )             /* *not used*    | x0*m8+x1*m9+x2*m10 */
+
+    MOVD       ( MM1, REGOFF(-4, EAX) ) /* write r2                           */
+    DEC_L      ( EDI )                  /* decrement normal counter           */
+
+    JA         ( LLBL (G3T_transform) )
+
+    FEMMS
+
+LLBL (G3T_end):
+    POP_L  ( ESI )
+    POP_L  ( EDI )
+    RET
+
+
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_normalize_normals)
+GLNAME(_mesa_3dnow_normalize_normals):
+
+#undef  FRAME_OFFSET
+#define FRAME_OFFSET 12
+
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+    PUSH_L     ( EBP )
+
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_DEST, EAX )
+    MOV_L      ( REGOFF(V3F_COUNT, ESI), EBP ) /*  dest->count = in->count   */
+    MOV_L      ( EBP, REGOFF(V3F_COUNT, EAX) )
+    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
+    MOV_L      ( REGOFF(V3F_START, ESI), ECX ) /*  in->start    */
+    MOV_L      ( ARG_LENGTHS, EDX )
+
+    CMP_L      ( CONST(0), EBP ) /* count > 0 ?? */
+    JE         ( LLBL (G3N_end) )
+
+    FEMMS
+
+    CMP_L      ( CONST(0), EDX )        /* lengths == 0 ?                     */
+    JE         ( LLBL (G3N_norm2) )     /* calculate lengths                  */
+
+ALIGNTEXT32
+LLBL (G3N_norm1):                       /* use precalculated lengths          */
+
+    PREFETCH   ( REGIND(EAX) )
+
+    MOVQ       ( REGIND(ECX), MM0 )     /* x1              | x0               */
+    MOVD       ( REGOFF(8, ECX), MM1 )  /*                 | x2               */
+
+    MOVD       ( REGIND(EDX), MM3 )     /*                 | length (x)       */
+    PFMUL      ( MM3, MM1 )             /*                 | x2 (normalized)  */
+
+    PUNPCKLDQ  ( MM3, MM3 )             /* length (x)      | length (x)       */
+    ADD_L      ( STRIDE, ECX )          /* next normal            */
+
+    PREFETCH   ( REGIND(ECX) )
+
+    PFMUL      ( MM3, MM0 )             /* x1 (normalized) | x0 (normalized)  */
+    MOVQ       ( MM0, REGIND(EAX) )     /* write new x0, x1                   */
+
+    MOVD       ( MM1, REGOFF(8, EAX) )  /* write new x2                       */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    ADD_L      ( CONST(4), EDX )        /* next length                        */
+    DEC_L      ( EBP )                  /* decrement normal counter           */
+
+    JA         ( LLBL (G3N_norm1) )
+
+    JMP        ( LLBL (G3N_end1) )
+
+ALIGNTEXT32
+LLBL (G3N_norm2):                       /* need to calculate lengths          */
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( MM0, MM3 )             /* x1              | x0               */
+    ADD_L      ( STRIDE, ECX )          /* next normal    */
+
+    PREFETCH   ( REGIND(ECX) )
+
+    MOVQ       ( REGIND(ECX), MM0 )     /* x1              | x0               */
+    MOVD       ( REGOFF(8, ECX), MM1 )  /*                 | x2               */
+
+    PFMUL      ( MM0, MM3 )             /* x1*x1           | x0*x0            */
+    MOVQ       ( MM1, MM4 )             /*                 | x2               */
+
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+    PFMUL      ( MM1, MM4 )             /*                 | x2*x2            */
+
+    PFADD      ( MM4, MM3 )             /*                 | x0*x0+x2*x2      */
+    PFACC      ( MM3, MM3 )             /* x0*x0+...+x2*x2 | x0*x0+x1*x1+x2*x2*/
+
+    PFRSQRT    ( MM3, MM5 )             /* 1/sqrt (x0*x0+x1*x1+x2*x2)         */
+    MOVQ       ( MM5, MM4 )
+
+    PUNPCKLDQ  ( MM3, MM3 )
+    PFMUL      ( MM5, MM5 )
+
+    PFRSQIT1   ( MM3, MM5 )
+    DEC_L      ( EBP )                  /* decrement normal counter           */
+
+    PFRCPIT2   ( MM4, MM5 )
+
+    PFMUL      ( MM5, MM0 )             /* x1 (normalized) | x0 (normalized)  */
+    MOVQ       ( MM0, REGOFF(-12, EAX) ) /* write new x0, x1                  */
+
+    PFMUL      ( MM5, MM1 )             /*                 | x2 (normalized)  */
+    MOVD       ( MM1, REGOFF(-4, EAX) ) /* write new x2                       */
+
+    JA         ( LLBL (G3N_norm2) )
+
+LLBL (G3N_end1):
+    FEMMS
+
+LLBL (G3N_end):
+    POP_L      ( EBP )
+    POP_L      ( ESI )
+    POP_L      ( EDI )
+    RET
+
+
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_3dnow_rescale_normals)
+GLNAME(_mesa_3dnow_rescale_normals):
+
+#undef  FRAME_OFFSET
+#define FRAME_OFFSET 8
+    PUSH_L     ( EDI )
+    PUSH_L     ( ESI )
+
+    MOV_L      ( ARG_IN, ESI )
+    MOV_L      ( ARG_DEST, EAX )
+    MOV_L      ( REGOFF(V3F_COUNT, ESI), EDX ) /*  dest->count = in->count   */
+    MOV_L      ( EDX, REGOFF(V3F_COUNT, EAX) )
+    MOV_L      ( REGOFF(V3F_START, EAX), EAX ) /*  dest->start  */
+    MOV_L      ( REGOFF(V3F_START, ESI), ECX ) /*  in->start    */
+
+    CMP_L      ( CONST(0), EDX )
+    JE         ( LLBL (G3R_end) )
+
+    FEMMS
+
+    MOVD       ( ARG_SCALE, MM0 )       /* scale                              */
+    PUNPCKLDQ  ( MM0, MM0 )
+
+ALIGNTEXT32
+LLBL (G3R_rescale):
+
+    PREFETCHW  ( REGIND(EAX) )
+
+    MOVQ       ( REGIND(ECX), MM1 )     /* x1            | x0                 */
+    MOVD       ( REGOFF(8, ECX), MM2 )  /*               | x2                 */
+
+    PFMUL      ( MM0, MM1 )             /* x1*scale      | x0*scale           */
+    ADD_L      ( STRIDE, ECX )          /* next normal                  */
+
+    PREFETCH   ( REGIND(ECX) )
+
+    PFMUL      ( MM0, MM2 )             /*               | x2*scale           */
+    ADD_L      ( CONST(12), EAX )       /* next r                             */
+
+    MOVQ       ( MM1, REGOFF(-12, EAX) ) /* write r0, r1                      */
+    MOVD       ( MM2, REGOFF(-4, EAX) ) /* write r2                           */
+
+    DEC_L      ( EDX )                  /* decrement normal counter           */
+    JA         ( LLBL (G3R_rescale) )
+
+    FEMMS
+
+LLBL (G3R_end):
+    POP_L      ( ESI )
+    POP_L      ( EDI )
+    RET
Index: xc/extras/Mesa/src/X86/3dnow_vertex.S
diff -u xc/extras/Mesa/src/X86/3dnow_vertex.S:1.1.1.1 xc/extras/Mesa/src/X86/3dnow_vertex.S:1.1.1.2
--- xc/extras/Mesa/src/X86/3dnow_vertex.S:1.1.1.1	Mon Nov 13 16:34:04 2000
+++ xc/extras/Mesa/src/X86/3dnow_vertex.S	Fri Feb 22 12:14:08 2002
@@ -1,4 +1,4 @@
-#include "assyntax.h"
+#include "matypes.h"
 
    SEG_TEXT
 
@@ -10,7 +10,7 @@
 
 
 /*
- * void gl_v16_3dnow_general_xform( GLfloat *dest,
+ * void _mesa_v16_3dnow_general_xform( GLfloat *dest,
  *		        	    const GLfloat *m,
  *				    const GLfloat *src,
  *                                  GLuint src_stride,
@@ -19,8 +19,8 @@
  * These tranformation functions could disappear if the standard ones
  * took an output stride.
  */
-GLOBL GLNAME( gl_v16_3dnow_general_xform )
-GLNAME( gl_v16_3dnow_general_xform ):
+GLOBL GLNAME( _mesa_v16_3dnow_general_xform )
+GLNAME( _mesa_v16_3dnow_general_xform ):
 
     PUSH_L    ( EDI )
     PUSH_L    ( ESI )
@@ -80,7 +80,7 @@
 
 /* Do viewport map and perspective projection.  Args should look like:
  *
- * gl_3dnow_project_vertices( float *first_vertex,
+ * _mesa_3dnow_project_vertices( float *first_vertex,
  *                            const float *last_vertex,
  *                            float *matrix,
  *                            GLuint stride )
@@ -99,8 +99,8 @@
  * Holger.
  */
 
-GLOBL GLNAME( gl_3dnow_project_vertices )
-GLNAME( gl_3dnow_project_vertices ):
+GLOBL GLNAME( _mesa_3dnow_project_vertices )
+GLNAME( _mesa_3dnow_project_vertices ):
 
     PUSH_L    ( EBP )
     FEMMS
@@ -151,14 +151,14 @@
 
 
 /*
- * gl_3dnow_project_clipped_vertices( float *first_vertex,
+ * _mesa_3dnow_project_clipped_vertices( float *first_vertex,
  *                                    const float *last_vertex,
  *                                    float *matrix,
  *                                    GLuint stride,
  *                                    const GLubyte *clip_mask )
  */
-GLOBL GLNAME( gl_3dnow_project_clipped_vertices )
-GLNAME( gl_3dnow_project_clipped_vertices ):
+GLOBL GLNAME( _mesa_3dnow_project_clipped_vertices )
+GLNAME( _mesa_3dnow_project_clipped_vertices ):
 
     PUSH_L    ( EBP )
     PUSH_L    ( ESI )
Index: xc/extras/Mesa/src/X86/3dnow_xform1.S
diff -u /dev/null xc/extras/Mesa/src/X86/3dnow_xform1.S:1.2
--- /dev/null	Thu Feb 27 12:15:53 2003
+++ xc/extras/Mesa/src/X86/3dnow_xform1.S	Mon Dec 16 11:18:32 2002
@@ -0,0 +1,422 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+    SEG_TEXT
+
+#define FRAME_OFFSET	4
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points1_general )
+GLNAME( _mesa_3dnow_transform_points1_general ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(4, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPGR_3 ) )
+
+    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
+    MOVQ      ( REGOFF(8, ECX), MM1 )	/* m03             | m02             */
+
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+    MOVQ      ( REGOFF(56, ECX), MM3 )	/* m33             | m32             */
+
+ALIGNTEXT16
+LLBL( G3TPGR_2 ):
+
+    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
+    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
+
+    MOVQ      ( MM4, MM5 )		/* x0              | x0              */
+    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
+
+    PFMUL     ( MM1, MM5 )		/* x0*m03          | x0*m02          */
+    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
+
+    PFADD     ( MM3, MM5 )		/* x0*m03+m33      | x0*m02+m32      */
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+
+    MOVQ      ( MM5, REGOFF(8, EDX) )	/* write r3, r2                      */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TPGR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPGR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points1_identity )
+GLNAME( _mesa_3dnow_transform_points1_identity ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(1), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_1), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(4, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPIR_4) )
+
+ALIGNTEXT16
+LLBL( G3TPIR_3 ):
+
+    MOVD      ( REGIND(EAX), MM0 )	/*                 | x0              */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    MOVD      ( MM0, REGIND(EDX) )	/*                 | r0              */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPIR_3 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPIR_4 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points1_3d_no_rot )
+GLNAME( _mesa_3dnow_transform_points1_3d_no_rot ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(4, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3NRR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+
+    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
+
+ALIGNTEXT16
+LLBL( G3TP3NRR_2 ):
+
+    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
+    PFMUL     ( MM0, MM4 )		/*                 | x0*m00          */
+
+    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+
+    MOVD      ( MM3, REGOFF(8, EDX) )	/* write r2                          */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TP3NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3NRR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points1_perspective )
+GLNAME( _mesa_3dnow_transform_points1_perspective ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(4, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPPR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
+
+ALIGNTEXT16
+LLBL( G3TPPR_2 ):
+
+    MOVD      ( REGIND(EAX), MM4 )	/* 0               | x0              */
+    PFMUL     ( MM0, MM4 )		/* 0               | x0*m00          */
+
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+    MOVQ      ( MM3, REGOFF(8, EDX) )	/* write r2  (=m32), r3 (=0)         */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPPR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPPR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points1_2d )
+GLNAME( _mesa_3dnow_transform_points1_2d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(4, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2R_3 ) )
+
+    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP2R_2 ):
+
+    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
+    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
+
+    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
+    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
+
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TP2R_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2R_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points1_2d_no_rot )
+GLNAME( _mesa_3dnow_transform_points1_2d_no_rot ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(4, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2NRR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP2NRR_2 ):
+
+    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    PFMUL     ( MM0, MM4 )		/*                 | x0*m00          */
+    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
+
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP2NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2NRR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points1_3d )
+GLNAME( _mesa_3dnow_transform_points1_3d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(4, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3R_3 ) )
+
+    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
+    MOVD      ( REGOFF(8, ECX), MM1 )	/*                 | m02             */
+
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
+
+ALIGNTEXT16
+LLBL( G3TP3R_2 ):
+
+    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
+    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
+
+    MOVQ      ( MM4, MM5 )		/*                 | x0              */
+    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
+
+    PFMUL     ( MM1, MM5 )		/*                 | x0*m02          */
+    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
+
+    PFADD     ( MM3, MM5 )		/*                 | x0*m02+m32      */
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+
+    MOVD      ( MM5, REGOFF(8, EDX) )	/* write r2                          */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TP3R_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3R_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform2.S
diff -u /dev/null xc/extras/Mesa/src/X86/3dnow_xform2.S:1.2
--- /dev/null	Thu Feb 27 12:15:53 2003
+++ xc/extras/Mesa/src/X86/3dnow_xform2.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,463 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+    SEG_TEXT
+
+#define FRAME_OFFSET	4
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points2_general )
+GLNAME( _mesa_3dnow_transform_points2_general ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPGR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
+
+    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
+
+    MOVD      ( REGOFF(8, ECX), MM2 )	/*                 | m02             */
+    PUNPCKLDQ ( REGOFF(24, ECX), MM2 )	/* m12             | m02             */
+
+    MOVD      ( REGOFF(12, ECX), MM3 )	/*                 | m03             */
+    PUNPCKLDQ ( REGOFF(28, ECX), MM3 )	/* m13             | m03             */
+
+    MOVQ      ( REGOFF(48, ECX), MM4 )	/* m31             | m30             */
+    MOVQ      ( REGOFF(56, ECX), MM5 )	/* m33             | m32             */
+
+ALIGNTEXT16
+LLBL( G3TPGR_2 ):
+
+    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
+    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
+
+    PFMUL     ( MM0, MM6 )		/* x1*m10          | x0*m00          */
+    PFMUL     ( MM1, MM7 )		/* x1*m11          | x0*m01          */
+
+    PFACC     ( MM7, MM6 )		/* x0*m01+x1*m11   | x0*x00+x1*m10   */
+    PFADD     ( MM4, MM6 )		/* x0*...*m11+m31  | x0*...*m10+m30  */
+
+    MOVQ      ( MM6, REGIND(EDX) )	/* write r1, r0                      */
+    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
+
+    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
+    PFMUL     ( MM2, MM6 )		/* x1*m12          | x0*m02          */
+
+    PFMUL     ( MM3, MM7 )		/* x1*m13          | x0*m03          */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    PFACC     ( MM7, MM6 )		/* x0*m03+x1*m13   | x0*x02+x1*m12   */
+    PFADD     ( MM5, MM6 )		/* x0*...*m13+m33  | x0*...*m12+m32  */
+
+    MOVQ      ( MM6, REGOFF(8, EDX) )	/* write r3, r2                      */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPGR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPGR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points2_perspective )
+GLNAME( _mesa_3dnow_transform_points2_perspective ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPPR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
+
+ALIGNTEXT16
+LLBL( G3TPPR_2 ):
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+    MOVQ      ( MM3, REGOFF(8, EDX) )	/* write r2  (=m32), r3 (=0)         */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPPR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPPR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points2_3d )
+GLNAME( _mesa_3dnow_transform_points2_3d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3 ), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3R_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
+
+    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
+
+    MOVD      ( REGOFF(8, ECX), MM2 )	/*                 | m02             */
+    PUNPCKLDQ ( REGOFF(24, ECX), MM2 )	/* m12             | m02             */
+
+    MOVQ      ( REGOFF(48, ECX), MM4 )	/* m31             | m30             */
+    MOVD      ( REGOFF(56, ECX), MM5 )	/*                 | m32             */
+
+ALIGNTEXT16
+LLBL( G3TP3R_2 ):
+
+    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
+    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
+
+    PFMUL     ( MM0, MM6 )		/* x1*m10          | x0*m00          */
+    PFMUL     ( MM1, MM7 )		/* x1*m11          | x0*m01          */
+
+    PFACC     ( MM7, MM6 )		/* x0*m01+x1*m11   | x0*x00+x1*m10   */
+    PFADD     ( MM4, MM6 )		/* x0*...*m11+m31  | x0*...*m10+m30  */
+
+    MOVQ      ( MM6, REGIND(EDX) )	/* write r1, r0                      */
+    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
+
+    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
+    PFMUL     ( MM2, MM6 )		/* x1*m12          | x0*m02          */
+
+    PFACC     ( MM7, MM6 )		/* ***trash***     | x0*x02+x1*m12   */
+    PFADD     ( MM5, MM6 )		/* ***trash***     | x0*...*m12+m32  */
+
+    MOVD      ( MM6, REGOFF(8, EDX) )	/* write r2                          */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TP3R_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3R_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points2_3d_no_rot )
+GLNAME( _mesa_3dnow_transform_points2_3d_no_rot ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3 ), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3NRR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
+
+ALIGNTEXT16
+LLBL( G3TP3NRR_2 ):
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+
+    PFADD     ( MM2, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+
+    MOVD      ( MM3, REGOFF(8, EDX) )	/* write r2                          */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TP3NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3NRR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points2_2d )
+GLNAME( _mesa_3dnow_transform_points2_2d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2R_3 ) )
+
+    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
+    MOVQ      ( REGOFF(16, ECX), MM1 )	/* m11             | m10             */
+
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP2R_2 ):
+
+    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
+    MOVD      ( REGOFF(4, EAX), MM5 )	/*                 | x1              */
+
+    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
+    PUNPCKLDQ ( MM5, MM5 )		/* x1              | x1              */
+
+    PFMUL     ( MM1, MM5 )		/* x1*m11          | x1*m10          */
+    PFADD     ( MM2, MM4 )		/* x...x1*m11+31   | x0*..*m10+m30   */
+
+    PFADD     ( MM5, MM4 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TP2R_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2R_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points2_2d_no_rot )
+GLNAME( _mesa_3dnow_transform_points2_2d_no_rot ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2NRR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP2NRR_2 ):
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
+
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP2NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2NRR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points2_identity )
+GLNAME( _mesa_3dnow_transform_points2_identity ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPIR_3 ) )
+
+ALIGNTEXT16
+LLBL( G3TPIR_3 ):
+
+    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+
+    MOVQ      ( MM0, REGIND(EDX) )	/* r1              | r0              */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPIR_3 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPIR_4 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform3.S
diff -u /dev/null xc/extras/Mesa/src/X86/3dnow_xform3.S:1.2
--- /dev/null	Thu Feb 27 12:15:54 2003
+++ xc/extras/Mesa/src/X86/3dnow_xform3.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,547 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+    SEG_TEXT
+
+#define FRAME_OFFSET	4
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points3_general )
+GLNAME( _mesa_3dnow_transform_points3_general ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPGR_2 ) )
+
+    PREFETCHW ( REGIND(EDX) )
+
+ALIGNTEXT16
+LLBL( G3TPGR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
+    MOVD      ( REGOFF(8, EAX), MM2 )	/*                 | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    MOVQ      ( MM0, MM1 )		/* x1              | x0              */
+    PUNPCKLDQ ( MM2, MM2 )		/* x2              | x2              */
+
+    PUNPCKLDQ ( MM0, MM0 )		/* x0              | x0              */
+    MOVQ      ( MM2, MM5 )		/* x2              | x2              */
+
+    PUNPCKHDQ ( MM1, MM1 )		/* x1              | x1              */
+    PFMUL     ( REGOFF(32, ECX), MM2 )	/* x2*m9           | x2*m8           */
+
+    MOVQ      ( MM0, MM3 )		/* x0              | x0              */
+    PFMUL     ( REGOFF(40, ECX), MM5 )	/* x2*m11          | x2*m10          */
+
+    MOVQ      ( MM1, MM4 )		/* x1              | x1              */
+    PFMUL     ( REGIND(ECX), MM0 )	/* x0*m1           | x0*m0           */
+
+    PFADD     ( REGOFF(48, ECX), MM2 )	/* x2*m9+m13       | x2*m8+m12       */
+    PFMUL     ( REGOFF(16, ECX), MM1 )	/* x1*m5           | x1*m4           */
+
+    PFADD     ( REGOFF(56, ECX), MM5 )	/* x2*m11+m15      | x2*m10+m14      */
+    PFADD     ( MM0, MM1 )		/* x0*m1+x1*m5     | x0*m0+x1*m4     */
+
+    PFMUL     ( REGOFF(8, ECX), MM3 )	/* x0*m3           | x0*m2           */
+    PFADD     ( MM1, MM2 )		/* r1              | r0              */
+
+    PFMUL     ( REGOFF(24, ECX), MM4 )	/* x1*m7           | x1*m6           */
+    ADD_L     ( CONST(16), EDX )	/* next output vertex                */
+
+    PFADD     ( MM3, MM4 )		/* x0*m3+x1*m7     | x0*m2+x1*m6     */
+    MOVQ      ( MM2, REGOFF(-16, EDX) )	/* write r0, r1                      */
+
+    PFADD     ( MM4, MM5 )		/* r3              | r2              */
+    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPGR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPGR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points3_perspective )
+GLNAME( _mesa_3dnow_transform_points3_perspective ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPPR_2 ) )
+
+    PREFETCH  ( REGIND(EAX) )
+    PREFETCHW ( REGIND(EDX) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVQ      ( REGOFF(32, ECX), MM1 )	/* m21             | m20             */
+    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
+
+    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
+
+ALIGNTEXT16
+LLBL( G3TPPR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    PXOR      ( MM7, MM7 )		/* 0               | 0               */
+    MOVQ      ( MM5, MM6 )		/*                 | x2              */
+
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+    PFSUB     ( MM5, MM7 )		/*                 | -x2             */
+
+    PFMUL     ( MM2, MM6 )		/*                 | x2*m22          */
+    PUNPCKLDQ ( MM5, MM5 )		/* x2              | x2              */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    PFMUL     ( MM1, MM5 )		/* x2*m21          | x2*m20          */
+
+    PFADD     ( MM3, MM6 )		/*                 | x2*m22+m32      */
+    PFADD     ( MM4, MM5 )		/* x1*m11+x2*m21   | x0*m00+x2*m20   */
+
+    MOVQ      ( MM5, REGOFF(-16, EDX) )	/* write r0, r1                      */
+    MOVD      ( MM6, REGOFF(-8, EDX) )	/* write r2                          */
+
+    MOVD      ( MM7, REGOFF(-4, EDX) )	/* write r3                          */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPPR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPPR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points3_3d )
+GLNAME( _mesa_3dnow_transform_points3_3d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3R_2 ) )
+
+    PREFETCH  ( REGIND(EAX) )
+    PREFETCH  ( REGIND(EDX) )
+
+    MOVD      ( REGOFF(8, ECX), MM7 )	/*                 | m2              */
+    PUNPCKLDQ ( REGOFF(24, ECX), MM7 )	/* m6              | m2              */
+
+
+ALIGNTEXT16
+LLBL( G3TP3R_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
+    MOVD      ( REGOFF(8, EAX), MM1 )	/*                 | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    MOVQ      ( MM0, MM2 )		/* x1              | x0              */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    PUNPCKLDQ ( MM2, MM2 )		/* x0              | x0              */
+    MOVQ      ( MM0, MM3 )		/* x1              | x0              */
+
+    PFMUL     ( REGIND(ECX), MM2 )	/* x0*m1           | x0*m0           */
+    PUNPCKHDQ ( MM3, MM3 )		/* x1              | x1              */
+
+    MOVQ      ( MM1, MM4 )		/*                 | x2              */
+    PFMUL     ( REGOFF(16, ECX), MM3 )	/* x1*m5           | x1*m4           */
+
+    PUNPCKLDQ ( MM4, MM4 )		/* x2              | x2              */
+    PFADD     ( MM2, MM3 )		/* x0*m1+x1*m5     | x0*m0+x1*m4     */
+
+    PFMUL     ( REGOFF(32, ECX), MM4 )	/* x2*m9           | x2*m8           */
+    PFADD     ( REGOFF(48, ECX), MM3 )	/* x0*m1+...+m11   | x0*m0+x1*m4+m12 */
+
+    PFMUL     ( MM7, MM0 )		/* x1*m6           | x0*m2           */
+    PFADD     ( MM4, MM3 )		/* r1              | r0              */
+
+    PFMUL     ( REGOFF(40, ECX), MM1 )	/*                 | x2*m10          */
+    PUNPCKLDQ ( REGOFF(56, ECX), MM1 )	/* m14             | x2*m10          */
+
+    PFACC     ( MM0, MM1 )
+
+    MOVQ      ( MM3, REGOFF(-16, EDX) )	/* write r0, r1                      */
+    PFACC     ( MM1, MM1 )		/*                 | r2              */
+
+    MOVD      ( MM1, REGOFF(-8, EDX) )	/* write r2                          */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP3R_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3R_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points3_3d_no_rot )
+GLNAME( _mesa_3dnow_transform_points3_3d_no_rot ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3NRR_2 ) )
+
+    PREFETCH  ( REGIND(EAX) )
+    PREFETCHW ( REGIND(EDX) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
+    PUNPCKLDQ ( MM2, MM2 )		/* m22             | m22             */
+
+    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
+    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
+
+    PUNPCKLDQ ( MM3, MM3 )		/* m32             | m32             */
+
+
+ALIGNTEXT16
+LLBL( G3TP3NRR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCHW ( REGIND(EAX) )
+	
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+
+    PFADD     ( MM1, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
+    PFMUL     ( MM2, MM5 )		/*                 | x2*m22          */
+
+    PFADD     ( MM3, MM5 )		/*                 | x2*m22+m32      */
+    MOVQ      ( MM4, REGIND(EDX) )	/* write r0, r1                      */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    MOVD      ( MM5, REGOFF(-8, EDX) )	/* write r2                          */
+    JNZ       ( LLBL( G3TP3NRR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3NRR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points3_2d )
+GLNAME( _mesa_3dnow_transform_points3_2d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2R_3) )
+
+    PREFETCH  ( REGIND(EAX) )
+    PREFETCHW ( REGIND(EDX) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
+
+    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
+
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP2R_2 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM3 )	/* x1              | x0              */
+    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    MOVQ      ( MM3, MM4 )		/* x1              | x0              */
+    PFMUL     ( MM0, MM3 )		/* x1*m10          | x0*m00          */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    PFMUL     ( MM1, MM4 )		/* x1*m11          | x0*m01          */
+
+    PFACC     ( MM4, MM3 )		/* x0*m00+x1*m10   | x0*m01+x1*m11   */
+    MOVD      ( MM5, REGOFF(-8, EDX) )	/* write r2 (=x2)                    */
+
+    PFADD     ( MM2, MM3 )		/* x0*...*m10+m30  | x0*...*m11+m31  */
+    MOVQ      ( MM3, REGOFF(-16, EDX) )	/* write r0, r1                      */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP2R_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2R_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points3_2d_no_rot )
+GLNAME( _mesa_3dnow_transform_points3_2d_no_rot ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2NRR_2 ) )
+
+    PREFETCH  ( REGIND(EAX) )
+    PREFETCHW ( REGIND(EDX) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
+
+
+ALIGNTEXT16
+LLBL( G3TP2NRR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    PFADD     ( MM1, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
+
+    MOVQ      ( MM4, REGOFF(-16, EDX) )	/* write r0, r1                      */
+    MOVD      ( MM5, REGOFF(-8, EDX) )	/* write r2 (=x2)                    */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP2NRR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2NRR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points3_identity )
+GLNAME( _mesa_3dnow_transform_points3_identity ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPIR_2 ) )
+
+    PREFETCHW ( REGIND(EDX) )
+
+ALIGNTEXT16
+LLBL( G3TPIR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )
+
+    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
+    MOVD      ( REGOFF(8, EAX), MM1 )	/*                 | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    MOVQ      ( MM0, REGOFF(-16, EDX) )	/* r1              | r0              */
+
+    MOVD      ( MM1, REGOFF(-8, EDX) )	/*                 | r2              */
+    JNZ       ( LLBL( G3TPIR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPIR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform4.S
diff -u /dev/null xc/extras/Mesa/src/X86/3dnow_xform4.S:1.2
--- /dev/null	Thu Feb 27 12:15:54 2003
+++ xc/extras/Mesa/src/X86/3dnow_xform4.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,556 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+    SEG_TEXT
+
+#define FRAME_OFFSET	4
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points4_general )
+GLNAME( _mesa_3dnow_transform_points4_general ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPGR_2 ) )
+
+    PREFETCHW ( REGIND(EDX) )
+
+ALIGNTEXT16
+LLBL( G3TPGR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM0 )	/* x1            | x0                */
+    MOVQ      ( REGOFF(8, EAX), MM4 )	/* x3            | x2                */
+	
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+	
+    MOVQ      ( MM0, MM2 )		/* x1              | x0              */
+    MOVQ      ( MM4, MM6 )		/* x3              | x2              */
+
+    PUNPCKLDQ ( MM0, MM0 )		/* x0              | x0              */
+    PUNPCKHDQ ( MM2, MM2 )		/* x1              | x1              */
+
+    MOVQ      ( MM0, MM1 )		/* x0              | x0              */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    PFMUL     ( REGIND(ECX), MM0 )	/* x0*m1           | x0*m0           */
+    MOVQ      ( MM2, MM3 )		/* x1              | x1              */
+
+    PFMUL     ( REGOFF(8, ECX), MM1 )	/* x0*m3           | x0*m2           */
+    PUNPCKLDQ ( MM4, MM4 )		/* x2              | x2              */
+
+    PFMUL     ( REGOFF(16, ECX), MM2 )	/* x1*m5           | x1*m4           */
+    MOVQ      ( MM4, MM5 )		/* x2              | x2              */
+
+    PFMUL     ( REGOFF(24, ECX), MM3 )	/* x1*m7           | x1*m6           */
+    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
+
+    PFMUL     ( REGOFF(32, ECX), MM4 )	/* x2*m9           | x2*m8           */
+    MOVQ      ( MM6, MM7 )		/* x3              | x3              */
+
+    PFMUL     ( REGOFF(40, ECX), MM5 )	/* x2*m11          | x2*m10          */
+    PFADD     ( MM0, MM2 )
+
+    PFMUL     ( REGOFF(48, ECX), MM6 )	/* x3*m13          | x3*m12          */
+    PFADD     ( MM1, MM3 )
+
+    PFMUL     ( REGOFF(56, ECX), MM7 )	/* x3*m15          | x3*m14          */
+    PFADD     ( MM4, MM6 )
+
+    PFADD     ( MM5, MM7 )
+    PFADD     ( MM2, MM6 )
+
+    PFADD     ( MM3, MM7 )
+    MOVQ      ( MM6, REGOFF(-16, EDX) )
+
+    MOVQ      ( MM7, REGOFF(-8, EDX) )
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPGR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPGR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points4_perspective )
+GLNAME( _mesa_3dnow_transform_points4_perspective ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPPR_2 ) )
+
+    PREFETCH  ( REGIND(EAX) )
+    PREFETCHW ( REGIND(EDX) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVD      ( REGOFF(40, ECX), MM1 )	/*                 | m22             */
+    PUNPCKLDQ ( REGOFF(56, ECX), MM1 )	/* m32             | m22             */
+
+    MOVQ      ( REGOFF(32, ECX), MM2 )	/* m21             | m20             */
+    PXOR      ( MM7, MM7 )		/* 0               | 0               */
+
+ALIGNTEXT16
+LLBL( G3TPPR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
+    MOVD      ( REGOFF(8, EAX), MM3 )	/*                 | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGOFF(32, EAX) )	/* hopefully stride is zero          */
+
+    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+
+    PUNPCKLDQ ( MM5, MM5 )		/* x2              | x2              */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    PFMUL     ( MM2, MM5 )		/* x2*m21          | x2*m20          */
+    PFSUBR    ( MM7, MM3 )		/*                 | -x2             */
+
+    PFMUL     ( MM1, MM6 )		/* x3*m32          | x2*m22          */
+    PFADD     ( MM4, MM5 )		/* x1*m11+x2*m21   | x0*m00+x2*m20   */
+
+    PFACC     ( MM3, MM6 )		/* -x2             | x2*m22+x3*m32   */
+    MOVQ      ( MM5, REGOFF(-16, EDX) )	/* write r0, r1                      */
+
+    MOVQ      ( MM6, REGOFF(-8, EDX) )	/* write r2, r3                      */
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TPPR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPPR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points4_3d )
+GLNAME( _mesa_3dnow_transform_points4_3d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3R_2 ) )
+
+    MOVD      ( REGOFF(8, ECX), MM6 )	/*                 | m2              */
+    PUNPCKLDQ ( REGOFF(24, ECX), MM6 )	/* m6              | m2              */
+
+    MOVD      ( REGOFF(40, ECX), MM7 )	/*                 | m10             */
+    PUNPCKLDQ ( REGOFF(56, ECX), MM7 )	/* m14             | m10             */
+
+ALIGNTEXT16
+LLBL( G3TP3R_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+    PREFETCH  ( REGOFF(32, EAX) )	/* hopefully array is tightly packed */
+
+    MOVQ      ( REGIND(EAX), MM2 )	/* x1              | x0              */
+    MOVQ      ( REGOFF(8, EAX), MM3 )	/* x3              | x2              */
+
+    MOVQ      ( MM2, MM0 )		/* x1              | x0              */
+    MOVQ      ( MM3, MM4 )		/* x3              | x2              */
+
+    MOVQ      ( MM0, MM1 )		/* x1              | x0              */
+    MOVQ      ( MM4, MM5 )		/* x3              | x2              */
+
+    PUNPCKLDQ ( MM0, MM0 )		/* x0              | x0              */
+    PUNPCKHDQ ( MM1, MM1 )		/* x1              | x1              */
+
+    PFMUL     ( REGIND(ECX), MM0 )	/* x0*m1           | x0*m0           */
+    PUNPCKLDQ ( MM3, MM3 )		/* x2              | x2              */
+
+    PFMUL     ( REGOFF(16, ECX), MM1 )	/* x1*m5           | x1*m4           */
+    PUNPCKHDQ ( MM4, MM4 )		/* x3              | x3              */
+
+    PFMUL     ( MM6, MM2 )		/* x1*m6           | x0*m2           */
+    PFADD     ( MM0, MM1 )		/* x0*m1+x1*m5     | x0*m0+x1*m4     */
+
+    PFMUL     ( REGOFF(32, ECX), MM3 )	/* x2*m9           | x2*m8           */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    PFMUL     ( REGOFF(48, ECX), MM4 )	/* x3*m13          | x3*m12          */
+    PFADD     ( MM1, MM3 )		/* x0*m1+..+x2*m9  | x0*m0+...+x2*m8 */
+
+    PFMUL     ( MM7, MM5 )		/* x3*m14          | x2*m10          */
+    PFADD     ( MM3, MM4 )		/* r1              | r0              */
+
+    PFACC     ( MM2, MM5 )		/* x0*m2+x1*m6     | x2*m10+x3*m14   */
+    MOVD      ( REGOFF(12, EAX), MM0 )	/*                 | x3              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PFACC     ( MM0, MM5 )		/* r3              | r2              */
+
+    MOVQ      ( MM4, REGOFF(-16, EDX) )	/* write r0, r1                      */
+    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP3R_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3R_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points4_3d_no_rot )
+GLNAME( _mesa_3dnow_transform_points4_3d_no_rot ):
+
+    PUSH_L    ( ESI )
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP3NRR_2 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
+    PUNPCKLDQ ( REGOFF(56, ECX), MM2 )	/* m32             | m22             */
+
+    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP3NRR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
+    MOVD      ( REGOFF(12, EAX), MM7 )	/*                 | x3              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGOFF(32, EAX) )	/* hopefully stride is zero          */
+
+    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+
+    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
+    PFMUL     ( MM2, MM5 )		/* x3*m32          | x2*m22          */
+
+    PFMUL     ( MM1, MM6 )		/* x3*m31          | x3*m30          */
+    PFACC     ( MM7, MM5 )		/* x3              | x2*m22+x3*m32   */
+
+    PFADD     ( MM6, MM4 )		/* x1*m11+x3*m31   | x0*m00+x3*m30   */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    MOVQ      ( MM4, REGOFF(-16, EDX) )	/* write r0, r1                      */
+    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP3NRR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP3NRR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points4_2d )
+GLNAME( _mesa_3dnow_transform_points4_2d ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2R_2 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
+
+    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
+
+    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP2R_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )       /* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM3 )	/* x1              | x0              */
+    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    MOVQ      ( MM3, MM4 )		/* x1              | x0              */
+    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
+
+    PFMUL     ( MM1, MM4 )		/* x1*m11          | x0*m01          */
+    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
+
+    PFMUL     ( MM0, MM3 )		/* x1*m10          | x0*m00          */
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+
+    PFACC     ( MM4, MM3 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
+    PFMUL     ( MM2, MM6 )		/* x3*m31          | x3*m30          */
+
+    PFADD     ( MM6, MM3 )		/* r1              | r0              */
+    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
+
+    MOVQ      ( MM3, REGOFF(-16, EDX) )	/* write r0, r1                      */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TP2R_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2R_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points4_2d_no_rot )
+GLNAME( _mesa_3dnow_transform_points4_2d_no_rot ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TP2NRR_3 ) )
+
+    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
+    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
+
+    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
+
+ALIGNTEXT16
+LLBL( G3TP2NRR_2 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
+
+    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
+    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
+    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
+
+    PFMUL     ( MM1, MM6 )		/* x3*m31          | x3*m30          */
+    PFADD     ( MM4, MM6 )		/* x1*m11+x3*m31   | x0*m00+x3*m30   */
+
+    MOVQ      ( MM6, REGOFF(-16, EDX) )	/* write r0, r1                      */
+    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+
+    JNZ       ( LLBL( G3TP2NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TP2NRR_3 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_3dnow_transform_points4_identity )
+GLNAME( _mesa_3dnow_transform_points4_identity ):
+
+    PUSH_L    ( ESI )
+
+    MOV_L     ( ARG_DEST, ECX )
+    MOV_L     ( ARG_MATRIX, ESI )
+    MOV_L     ( ARG_SOURCE, EAX )
+    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
+    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
+    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
+
+    PUSH_L    ( EDI )
+
+    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
+    MOV_L     ( ESI, ECX )
+    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
+    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
+    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
+
+    TEST_L    ( ESI, ESI )
+    JZ        ( LLBL( G3TPIR_2 ) )
+
+ALIGNTEXT16
+LLBL( G3TPIR_1 ):
+
+    PREFETCHW ( REGOFF(32, EDX) )       /* prefetch 2 vertices ahead         */
+	
+    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
+    MOVQ      ( REGOFF(8, EAX), MM1 )	/* x3              | x2              */
+
+    ADD_L     ( EDI, EAX )		/* next vertex                       */
+    PREFETCH  ( REGIND(EAX) )
+
+    ADD_L     ( CONST(16), EDX )	/* next r                            */
+    MOVQ      ( MM0, REGOFF(-16, EDX) )	/* r1              | r0              */
+
+    MOVQ      ( MM1, REGOFF(-8, EDX) )	/* r3              | r2              */
+
+    DEC_L     ( ESI )			/* decrement vertex counter          */
+    JNZ       ( LLBL( G3TPIR_1 ) )	/* cnt > 0 ? -> process next vertex  */
+
+LLBL( G3TPIR_2 ):
+
+    FEMMS
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_masked1.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_masked1.S:1.4 xc/extras/Mesa/src/X86/3dnow_xform_masked1.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_masked1.S:1.4	Mon Nov 13 18:31:06 2000
+++ xc/extras/Mesa/src/X86/3dnow_xform_masked1.S	Thu Feb 27 12:15:54 2003
@@ -1,501 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	16
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_general_masked )
-GLNAME( gl_3dnow_transform_points1_general_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVQ      ( REGOFF(8, ECX), MM1 )	/* m03             | m02             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-    MOVQ      ( REGOFF(56, ECX), MM3 )	/* m33             | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TPGM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPGM_3 ) )	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-
-    MOVQ      ( MM4, MM5 )		/* x0              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-
-    PFMUL     ( MM1, MM5 )		/* x0*m03          | x0*m02          */
-    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
-
-    PFADD     ( MM3, MM5 )		/* x0*m03+m33      | x0*m02+m32      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVQ      ( MM5, REGOFF(8, EDX) )	/* write r3, r2                      */
-
-LLBL( G3TPGM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPGM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_perspective_masked )
-GLNAME( gl_3dnow_transform_points1_perspective_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TPPM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPPM_3 ) )	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM4 )	/* 0               | x0              */
-    PFMUL     ( MM0, MM4 )		/* 0               | x0*m00          */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( MM3, REGOFF(8, EDX) )	/* write r2  (=m32), r3 (=0)         */
-
-LLBL( G3TPPM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPPM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_3d_masked )
-GLNAME( gl_3dnow_transform_points1_3d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVD      ( REGOFF(8, ECX), MM1 )	/*                 | m02             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3M_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP3M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3M_3 ) )	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-
-    MOVQ      ( MM4, MM5 )		/*                 | x0              */
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-
-    PFMUL     ( MM1, MM5 )		/*                 | x0*m02          */
-    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
-
-    PFADD     ( MM3, MM5 )		/*                 | x0*m02+m32      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVD      ( MM5, REGOFF(8, EDX) )	/* write r2                          */
-
-LLBL( G3TP3M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP3M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3M_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_3d_no_rot_masked )
-GLNAME( gl_3dnow_transform_points1_3d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP3NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3NRM_3))	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PFMUL     ( MM0, MM4 )		/*                 | x0*m00          */
-
-    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVD      ( MM3, REGOFF(8, EDX) )	/* write r2                          */
-
-LLBL( G3TP3NRM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP3NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_2d_masked )
-GLNAME( gl_3dnow_transform_points1_2d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2M_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP2M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2M_3 ) )	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-LLBL( G3TP2M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    INC_L     ( EBP )			/* next clipmask                     */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP2M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2M_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_points1_2d_no_rot_masked)
-GLNAME( gl_3dnow_transform_points1_2d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP2NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2NRM_3 ) )	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PFMUL     ( MM0, MM4 )		/*                 | x0*m00          */
-
-    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-LLBL( G3TP2NRM_3 ):
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_identity_masked )
-GLNAME( gl_3dnow_transform_points1_identity_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(1), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_1), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-ALIGNTEXT16
-LLBL( G3TPIM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPIM_3 ) )	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM0 )	/*                 | x0              */
-    MOVD      ( MM0, REGIND(EDX) )	/*                 | r0              */
-
-LLBL( G3TPIM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPIM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_masked2.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_masked2.S:1.4 xc/extras/Mesa/src/X86/3dnow_xform_masked2.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_masked2.S:1.4	Mon Nov 13 18:31:06 2000
+++ xc/extras/Mesa/src/X86/3dnow_xform_masked2.S	Thu Feb 27 12:15:54 2003
@@ -1,568 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	16
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_general_masked )
-GLNAME( gl_3dnow_transform_points2_general_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVD      ( REGOFF(8, ECX), MM2 )	/*                 | m02             */
-    MOVD      ( REGOFF(24, ECX), MM7 )	/*                 | m12             */
-    PSLLQ     ( CONST(32), MM7 )	/* m12             |                 */
-    POR       ( MM7, MM2 )		/* m12             | m02             */
-
-    MOVD      ( REGOFF(12, ECX), MM3 )	/*                 | m03             */
-    MOVD      ( REGOFF(28, ECX), MM7 )	/*                 | m13             */
-    PSLLQ     ( CONST(32), MM7 )	/* m13             |                 */
-    POR       ( MM7, MM3 )		/* m13             | m03             */
-
-    MOVQ      ( REGOFF(48, ECX), MM4 )	/* m31             | m30             */
-    MOVQ      ( REGOFF(56, ECX), MM5 )	/* m33             | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TPGM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPGM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-
-    PFMUL     ( MM0, MM6 )		/* x1*m10          | x0*m00          */
-    PFMUL     ( MM1, MM7 )		/* x1*m11          | x0*m01          */
-
-    PFACC     ( MM7, MM6 )		/* x0*m01+x1*m11   | x0*x00+x1*m10   */
-    PFADD     ( MM4, MM6 )		/* x0*...*m11+m31  | x0*...*m10+m30  */
-
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-    PFMUL     ( MM2, MM6 )		/* x1*m12          | x0*m02          */
-
-    PFMUL     ( MM3, MM7 )		/* x1*m13          | x0*m03          */
-    PFACC     ( MM7, MM6 )		/* x0*m03+x1*m13   | x0*x02+x1*m12   */
-
-    PFADD     ( MM5, MM6 )		/* x0*...*m13+m33  | x0*...*m12+m32  */
-    MOVQ      ( MM6, REGOFF(8, EDX) )	/* write r3, r2                      */
-
-ALIGNTEXT16
-LLBL( G3TPGM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPGM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_perspective_masked )
-GLNAME( gl_3dnow_transform_points2_perspective_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM1 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM1 )	/* m11             |                 */
-    POR       ( MM1, MM0 )		/* m11             | m00             */
-
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TPPM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPPM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( MM3, REGOFF(8, EDX) )	/* write r2  (=m32), r3 (=0)         */
-
-LLBL( G3TPPM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPPM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_3d_masked )
-GLNAME( gl_3dnow_transform_points2_3d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVD      ( REGOFF(8, ECX), MM2 )	/*                 | m02             */
-    MOVD      ( REGOFF(24, ECX), MM7 )	/*                 | m12             */
-    PSLLQ     ( CONST(32), MM7 )	/* m12             |                 */
-    POR       ( MM7, MM2 )		/* m12             | m02             */
-
-    MOVQ      ( REGOFF(48, ECX), MM4 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM5 )	/*                 | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3M_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP3M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3M_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-
-    PFMUL     ( MM0, MM6 )		/* x1*m10          | x0*m00          */
-    PFMUL     ( MM1, MM7 )		/* x1*m11          | x0*m01          */
-
-    PFACC     ( MM7, MM6 )		/* x0*m01+x1*m11   | x0*x00+x1*m10   */
-    PFADD     ( MM4, MM6 )		/* x0*...*m11+m31  | x0*...*m10+m30  */
-
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-    PFMUL     ( MM2, MM6 )		/* x1*m12          | x0*m02          */
-
-    PFACC     ( MM7, MM6 )		/* ***trash***     | x0*x02+x1*m12   */
-
-    PFADD     ( MM5, MM6 )		/* ***trash***     | x0*...*m12+m32  */
-    MOVD      ( MM6, REGOFF(8, EDX) )	/* write r2                          */
-
-LLBL( G3TP3M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3M_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_3d_no_rot_masked )
-GLNAME( gl_3dnow_transform_points2_3d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM1 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM1 )	/* m11             |                 */
-    POR       ( MM1, MM0 )		/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP3NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3NRM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    PFADD     ( MM2, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVD      ( MM3, REGOFF(8, EDX) )	/* write r2                          */
-
-LLBL( G3TP3NRM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_2d_masked )
-GLNAME( gl_3dnow_transform_points2_2d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVQ      ( REGOFF(16, ECX), MM1 )	/* m11             | m10             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2M_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP2M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2M_3 ) )	/* skip vertex                       */
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    MOVD      ( REGOFF(4, EAX), MM5 )	/*                 | x1              */
-
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-
-    PUNPCKLDQ ( MM5, MM5 )		/* x1              | x1              */
-    PFMUL     ( MM1, MM5 )		/* x1*m11          | x1*m10          */
-
-    PFADD     ( MM5, MM4 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-    PFADD     ( MM2, MM4 )		/* x...x1*m11+31   | x0*...*m10+m30  */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-LLBL( G3TP2M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP2M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2M_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_2d_no_rot_masked )
-GLNAME( gl_3dnow_transform_points2_2d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM1 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM1 )	/* m11             |                 */
-    POR       ( MM1, MM0 )		/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP2NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2NRM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-LLBL( G3TP2NRM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_identity_masked )
-GLNAME( gl_3dnow_transform_points2_identity_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-ALIGNTEXT16
-LLBL( G3TPIM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPIM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVQ      ( MM0, REGIND(EDX) )	/* r1              | r0              */
-
-LLBL( G3TPIM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPIM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_masked3.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_masked3.S:1.4 xc/extras/Mesa/src/X86/3dnow_xform_masked3.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_masked3.S:1.4	Mon Nov 13 18:31:07 2000
+++ xc/extras/Mesa/src/X86/3dnow_xform_masked3.S	Thu Feb 27 12:15:54 2003
@@ -1,709 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	16
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_general_masked )
-GLNAME( gl_3dnow_transform_points3_general_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVQ      ( REGOFF(32, ECX), MM2 )	/* m21             | m20             */
-    MOVQ      ( REGOFF(48, ECX), MM3 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGM_6 ) )
-
-    PUSH_L    ( EBP )
-    PUSH_L    ( EAX )
-    PUSH_L    ( EDX )
-    PUSH_L    ( ESI )
-
-ALIGNTEXT16
-LLBL( G3TPGM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPGM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM6 )	/*                 | x2              */
-
-    MOVQ      ( MM4, MM5 )		/* x1              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x1*m10          | x0*m00          */
-
-    PUNPCKLDQ ( MM6, MM6 )		/* x2              | x2              */
-    PFMUL     ( MM1, MM5 )		/* x1*m11          | x0*m01          */
-
-    PFMUL     ( MM2, MM6 )		/* x2*m21          | x2*m20          */
-    PFACC     ( MM5, MM4 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-
-    PFADD     ( MM3, MM6 )		/* x2*m21+m31      | x2*m20+m30      */
-    PFADD     ( MM4, MM6 )		/* r1              | r0              */
-
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r0, r1                      */
-
-ALIGNTEXT16
-LLBL( G3TPGM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPGM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-                                	/* and now the second stripe ...     */
-    POP_L     ( ESI )			/* reset counter & pointers          */
-    POP_L     ( EDX )
-    POP_L     ( EAX )
-    POP_L     ( EBP )
-
-    MOVD      ( REGOFF(8, ECX), MM0 )	/*                 | m02             */
-    MOVD      ( REGOFF(24, ECX), MM7 )	/*                 | m12             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m12             |                 */
-    POR       ( MM7, MM0 )		/* m12             | m02             */
-
-    MOVD      ( REGOFF(12, ECX), MM1 )	/*                 | m03             */
-    MOVD      ( REGOFF(28, ECX), MM7 )	/*                 | m13             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m13             |                 */
-    POR       ( MM7, MM1 )		/* m13             | m03             */
-
-    MOVQ      ( REGOFF(40, ECX), MM2 )	/* m23             | m22             */
-    MOVQ      ( REGOFF(56, ECX), MM3 )	/* m33             | m32             */
-
-ALIGNTEXT16
-LLBL( G3TPGM_4 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPGM_5 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM6 )	/*                 | x2              */
-
-    MOVQ      ( MM4, MM5 )		/* x1              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x1*m12          | x0*m02          */
-
-    PUNPCKLDQ ( MM6, MM6 )		/* x2              | x2              */
-    PFMUL     ( MM1, MM5 )		/* x1*m13          | x0*m03          */
-
-    PFMUL     ( MM2, MM6 )		/* x2*m23          | x2*m22          */
-    PFACC     ( MM5, MM4 )		/* x0*m03+x1*m13   | x0*m02+x1*m12   */
-
-    PFADD     ( MM3, MM6 )		/* x2*m23+m33      | x2*m22+m32      */
-    PFADD     ( MM4, MM6 )		/* r3              | r2              */
-
-    MOVQ      ( MM6, REGOFF(8, EDX) )	/* write r2, r3                      */
-
-ALIGNTEXT16
-LLBL( G3TPGM_5 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPGM_4 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGM_6 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_perspective_masked )
-GLNAME( gl_3dnow_transform_points3_perspective_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM0 )		/* m11             | m00             */
-
-    MOVQ      ( REGOFF(32, ECX), MM1 )	/* m21             | m20             */
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TPPM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPPM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    MOVQ      ( MM5, MM6 )		/*                 | x2              */
-
-    PUNPCKLDQ ( MM5, MM5 )		/* x2              | x2              */
-    PFMUL     ( MM1, MM5 )		/* x2*m21          | x2*m20          */
-
-    PFADD     ( MM4, MM5 )		/* x1*m11+x2*m21   | x0*m00+x2*m20   */
-    MOVQ      ( MM5, REGIND(EDX) )	/* write r0, r1                      */
-
-    MOVQ      ( MM6, MM5 )		/*                 | x2              */
-    PFMUL     ( MM2, MM5 )		/*                 | x2*m22          */
-
-    PFADD     ( MM3, MM5 )		/*                 | x2*m22+m32      */
-    PFSUBR    ( MM7, MM6 )		/* (LO mm7 == 0)   | -x2             */
-
-    MOVD      ( MM5, REGOFF(8, EDX) )	/* write r2                          */
-    MOVD      ( MM6, REGOFF(12, EDX) )	/* write r3                          */
-
-ALIGNTEXT16
-LLBL( G3TPPM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPPM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_3d_masked )
-GLNAME( gl_3dnow_transform_points3_3d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVQ      ( REGOFF(32, ECX), MM2 )	/* m21             | m20             */
-    MOVQ      ( REGOFF(48, ECX), MM3 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3M_6 ) )
-
-    PUSH_L    ( EBP )
-    PUSH_L    ( EAX )
-    PUSH_L    ( EDX )
-    PUSH_L    ( ESI )
-
-ALIGNTEXT16
-LLBL( G3TP3M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3M_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( MM4, MM5 )		/* x1              | x0              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m10          | x0*m00          */
-    MOVD      ( REGOFF(8, EAX), MM6 )	/*                 | x2              */
-
-    PFMUL     ( MM1, MM5 )		/* x1*m11          | x0*m01          */
-    PUNPCKLDQ ( MM6, MM6 )		/* x2              | x2              */
-
-    PFMUL     ( MM2, MM6 )		/* x2*m21          | x2*m20          */
-    PFACC     ( MM5, MM4 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-
-    PFADD     ( MM3, MM6 )		/* x2*m21+m31      | x2*m20+m30      */
-    PFADD     ( MM4, MM6 )		/* r1              | r0              */
-
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r0, r1                      */
-
-ALIGNTEXT16
-LLBL( G3TP3M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-                                	/* and now the second stripe ...     */
-    MOVD      ( REGOFF(8, ECX), MM0 )	/*                 | m02             */
-
-    MOVD      ( REGOFF(24, ECX), MM7 )	/*                 | m12             */
-    PSLLQ     ( CONST(32), MM7 )	/* m12             |                 */
-
-    POR       ( MM7, MM0 )		/* m12             | m02             */
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    POP_L     ( ESI )			/* reset counter & pointers          */
-    POP_L     ( EDX )
-    POP_L     ( EAX )
-    POP_L     ( EBP )
-
-ALIGNTEXT16
-LLBL( G3TP3M_4 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3M_5 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( MM4, MM5 )		/* x1              | x0              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m12          | x0*m02          */
-    MOVD      ( REGOFF(8, EAX), MM6 )	/*                 | x2              */
-
-    PFMUL     ( MM1, MM5 )		/* x1*m13          | x0*m03          */
-    PFACC     ( MM5, MM4 )		/* x0*m03+x1*m13   | x0*m02+x1*m12   */
-
-    PFMUL     ( MM2, MM6 )		/*                 | x2*m22          */
-    PFADD     ( MM3, MM6 )		/*                 | x2*m22+m32      */
-
-    PFADD     ( MM4, MM6 )		/*                 | r2              */
-    MOVD      ( MM6, REGOFF(8, EDX) )	/* write r2                          */
-
-ALIGNTEXT16
-LLBL( G3TP3M_5 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3M_4 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3M_6 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_3d_no_rot_masked )
-GLNAME( gl_3dnow_transform_points3_3d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM0 )		/* m11             | m00             */
-
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-    PUNPCKLDQ ( MM2, MM2 )		/* m22             | m22             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    PUNPCKLDQ ( MM3, MM3 )		/* m32             | m32             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP3NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3NRM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    PFMUL     ( MM2, MM5 )		/*                 | x2*m22          */
-
-    PFADD     ( MM1, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
-    PFADD     ( MM3, MM5 )		/*                 | x2*m22+m32      */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r0, r1                      */
-    MOVD      ( MM5, REGOFF(8, EDX) )	/* write r2                          */
-
-LLBL( G3TP3NRM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_2d_masked )
-GLNAME( gl_3dnow_transform_points3_2d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2M_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP2M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2M_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM3 )	/* x1              | x0              */
-    MOVQ      ( MM3, MM4 )		/* x1              | x0              */
-
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-    PFMUL     ( MM0, MM3 )		/* x1*m10          | x0*m00          */
-
-    PFMUL     ( MM1, MM4 )		/* x1*m11          | x0*m01          */
-    PFACC     ( MM4, MM3 )		/* x0*m00+x1*m10   | x0*m01+x1*m11   */
-
-    PFADD     ( MM2, MM3 )		/* x0*...*m10+m30  | x0*...*m11+m31  */
-    MOVQ      ( MM3, REGIND(EDX) )	/* write r0, r1                      */
-
-    MOVD      ( MM5, REGOFF(8, EDX) )	/* write r2 (=x2)                    */
-
-ALIGNTEXT16
-LLBL( G3TP2M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2M_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_2d_no_rot_masked )
-GLNAME( gl_3dnow_transform_points3_2d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM0 )		/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRM_4 ) )
-
-ALIGNTEXT16
-LLBL( G3TP2NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2NRM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    MOVD      ( MM5, REGOFF(8, EDX) )	/* write r2 (=x2)                    */
-
-    PFADD     ( MM1, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r0, r1                      */
-
-ALIGNTEXT16
-LLBL( G3TP2NRM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_identity_masked )
-GLNAME( gl_3dnow_transform_points3_identity_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-ALIGNTEXT16
-LLBL( G3TPIM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPIM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM1 )	/*                 | x2              */
-
-    MOVQ      ( MM0, REGIND(EDX) )	/* r1              | r0              */
-    MOVD      ( MM1, REGOFF(8, EDX) )	/*                 | r2              */
-
-LLBL( G3TPIM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPIM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_masked4.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_masked4.S:1.4 xc/extras/Mesa/src/X86/3dnow_xform_masked4.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_masked4.S:1.4	Mon Nov 13 18:31:07 2000
+++ xc/extras/Mesa/src/X86/3dnow_xform_masked4.S	Thu Feb 27 12:15:54 2003
@@ -1,752 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	16
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_general_masked )
-GLNAME( gl_3dnow_transform_points4_general_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVD      ( REGOFF(32, ECX), MM2 )	/*                 | m20             */
-    MOVD      ( REGOFF(48, ECX), MM7 )	/*                 | m30             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m30             |                 */
-    POR       ( MM7, MM2 )		/* m30             | m20             */
-
-    MOVD      ( REGOFF(36, ECX), MM3 )	/*                 | m21             */
-    MOVD      ( REGOFF(52, ECX), MM7 )	/*                 | m31             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m31             |                 */
-    POR       ( MM7, MM3 )		/* m31             | m21             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGM_6 ) )
-
-    PUSH_L    ( EBP )
-    PUSH_L    ( EAX )
-    PUSH_L    ( EDX )
-    PUSH_L    ( ESI )
-
-ALIGNTEXT32
-LLBL( G3TPGM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPGM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( MM4, MM5 )		/* x1              | x0              */
-
-    MOVQ      ( REGOFF(8, EAX), MM6 )	/* x3              | x2              */
-    PFMUL     ( MM0, MM4 )		/* x1*m10          | x0*m00          */
-
-    MOVQ      ( MM6, MM7 )		/* x3              | x2              */
-    PFMUL     ( MM1, MM5 )		/* x1*m11          | x0*m01          */
-
-    PFMUL     ( MM2, MM6 )		/* x3*m30          | x2*m20          */
-    PFACC     ( MM5, MM4 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-
-    PFMUL     ( MM3, MM7 )		/* x3*m31          | x2*m21          */
-    PFACC     ( MM7, MM6 )		/* x2*m21+x3*m31   | x2*m20+x3*m30   */
-
-    PFADD     ( MM4, MM6 )		/* r1              | r0              */
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r0, r1                      */
-
-LLBL( G3TPGM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPGM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-                                        /* and now the second stripe ...     */
-    MOVD      ( REGOFF(8, ECX), MM0 )	/*                 | m02             */
-    MOVD      ( REGOFF(24, ECX), MM7 )	/*                 | m12             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m12             |                 */
-    POR       ( MM7, MM0 )		/* m12             | m02             */
-
-    MOVD      ( REGOFF(12, ECX), MM1 )	/*                 | m03             */
-    MOVD      ( REGOFF(28, ECX), MM7 )	/*                 | m13             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m13             |                 */
-    POR       ( MM7, MM1 )		/* m13             | m03             */
-
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-    MOVD      ( REGOFF(56, ECX), MM7 )	/*                 | m32             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m32             |                 */
-    POR       ( MM7, MM2 )		/* m32             | m22             */
-
-    MOVD      ( REGOFF(44, ECX), MM3 )	/*                 | m23             */
-    MOVD      ( REGOFF(60, ECX), MM7 )	/*                 | m33             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m33             |                 */
-    POR       ( MM7, MM3 )		/* m33             | m23             */
-
-    POP_L     ( ESI )			/* reset counter & pointers          */
-    POP_L     ( EDX )
-    POP_L     ( EAX )
-    POP_L     ( EBP )
-
-ALIGNTEXT32
-LLBL( G3TPGM_4 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPGM_5 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( MM4, MM5 )		/* x1              | x0              */
-
-    MOVQ      ( REGOFF(8, EAX), MM6 )	/* x3              | x2              */
-    PFMUL     ( MM0, MM4 )		/* x1*m12          | x0*m02          */
-
-    MOVQ      ( MM6, MM7 )		/* x3              | x2              */
-    PFMUL     ( MM1, MM5 )		/* x1*m13          | x0*m03          */
-
-    PFMUL     ( MM2, MM6 )		/* x3*m32          | x2*m22          */
-    PFACC     ( MM5, MM4 )		/* x0*m03+x1*m13   | x0*m02+x1*m12   */
-
-    PFMUL     ( MM3, MM7 )		/* x3*m33          | x2*m23          */
-    PFACC     ( MM7, MM6 )		/* x2*m23+x3*m33   | x2*m22+x3*m32   */
-
-    PFADD     ( MM4, MM6 )		/* r3              | r2              */
-    MOVQ      ( MM6, REGOFF(8, EDX) )	/* write r2, r3                      */
-
-LLBL( G3TPGM_5 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPGM_4 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGM_6 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_perspective_masked )
-GLNAME( gl_3dnow_transform_points4_perspective_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM0 )		/* m11             | m00             */
-
-    MOVD      ( REGOFF(40, ECX), MM1 )	/*                 | m22             */
-    MOVD      ( REGOFF(56, ECX), MM7 )	/*                 | m32             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m32             |                 */
-    POR       ( MM7, MM1 )		/* m32             | m22             */
-
-    MOVQ      ( REGOFF(32, ECX), MM2 )	/* m21             | m20             */
-    PUNPCKLDQ ( MM7, MM7 )		/* 0               | 0               */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPM_4 ) )
-
-ALIGNTEXT32
-LLBL( G3TPPM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPPM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-
-    PUNPCKLDQ ( MM5, MM5 )		/* x2              | x2              */
-    PFMUL     ( MM1, MM6 )		/* x3*m32          | x2*m22          */
-
-    PFMUL     ( MM2, MM5 )		/* x2*m21          | x2*m20          */
-    PFADD     ( MM4, MM5 )		/* x1*m11+x2*m21   | x0*m00+x2*m20   */
-
-    MOVQ      ( MM5, REGIND(EDX) )	/* write r0, r1                      */
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-
-    PFSUBR    ( MM7, MM5 )		/*                 | -x2             */
-    PFACC     ( MM5, MM6 )		/* -x2             | x2*m22+x3*m32   */
-
-    MOVQ      ( MM6, REGOFF(8, EDX) )	/* write r2, r3                      */
-
-LLBL( G3TPPM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPPM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_3dnow_transform_points4_3d_masked)
-GLNAME( gl_3dnow_transform_points4_3d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVD      ( REGOFF(32, ECX), MM2 )	/*                 | m20             */
-    MOVD      ( REGOFF(48, ECX), MM7 )	/*                 | m30             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m30             |                 */
-    POR       ( MM7, MM2 )		/* m30             | m20             */
-
-    MOVD      ( REGOFF(36, ECX), MM3 )	/*                 | m21             */
-    MOVD      ( REGOFF(52, ECX), MM7 )	/*                 | m31             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m31             |                 */
-    POR       ( MM7, MM3 )		/* m31             | m21             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3M_6 ) )
-
-    PUSH_L    ( EBP )
-    PUSH_L    ( EAX )
-    PUSH_L    ( EDX )
-    PUSH_L    ( ESI )
-
-ALIGNTEXT32
-LLBL( G3TP3M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3M_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( MM4, MM5 )		/* x1              | x0              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m10          | x0*m00          */
-    MOVQ      ( REGOFF(8, EAX), MM6 )	/* x3              | x2              */
-
-    PFMUL     ( MM1, MM5 )		/* x1*m11          | x0*m01          */
-    MOVQ      ( MM6, MM7 )		/* x3              | x2              */
-
-    PFMUL     ( MM2, MM6 )		/* x3*m30          | x2*m20          */
-    PFACC     ( MM5, MM4 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-
-    PFMUL     ( MM3, MM7 )		/* x3*m31          | x2*m21          */
-    PFACC     ( MM7, MM6 )		/* x2*m21+x3*m31   | x2*m20+x3*m30   */
-
-    PFADD     ( MM4, MM6 )		/* r1              | r0              */
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r0, r1                      */
-
-LLBL( G3TP3M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-                                        /* and now the second stripe ...     */
-    MOVD      ( REGOFF(8, ECX), MM0 )	/*                 | m02             */
-    MOVD      ( REGOFF(24, ECX), MM7 )	/*                 | m12             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m12             |                 */
-    POR       ( MM7, MM0 )		/* m12             | m02             */
-
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-    MOVD      ( REGOFF(56, ECX), MM7 )	/*                 | m32             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m32             |                 */
-    POR       ( MM7, MM2 )		/* m32             | m22             */
-
-    POP_L     ( ESI )			/* reset counter & pointers          */
-    POP_L     ( EDX )
-    POP_L     ( EAX )
-    POP_L     ( EBP )
-
-ALIGNTEXT32
-LLBL( G3TP3M_4 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3M_5 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM6 )	/* x3              | x2              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m12          | x0*m02          */
-    MOVD      ( REGOFF(12, EAX), MM7 )	/*                 | x3              */
-
-    PFMUL     ( MM2, MM6 )		/* x3*m32          | x2*m22          */
-    PFACC     ( MM4, MM6 )		/* x0*m03+x1*m13   | x0*m02+x1*m12   */
-
-    PFACC     ( MM7, MM6 )		/* x3              | x2*m22+x3*m32   */
-    MOVQ      ( MM6, REGOFF(8, EDX) )	/* write r2, r3                      */
-
-LLBL( G3TP3M_5 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3M_4 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3M_6 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_3d_no_rot_masked )
-GLNAME( gl_3dnow_transform_points4_3d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM0 )		/* m11             | m00             */
-
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    PSLLQ     ( CONST(32), MM3 )	/* m32             |                 */
-    POR       ( MM3, MM2 )		/* m32             | m22             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRM_4 ) )
-
-ALIGNTEXT32
-LLBL( G3TP3NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP3NRM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    MOVD      ( REGOFF(12, EAX), MM7 )	/*                 | x3              */
-    PFMUL     ( MM2, MM5 )		/* x3*m32          | x2*m22          */
-
-    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
-    PFACC     ( MM7, MM5 )		/* x3              | x2*m22+x3*m32   */
-
-    PFMUL     ( MM1, MM6 )		/* x3*m31          | x3*m30          */
-    PFADD     ( MM6, MM4 )		/* x1*m11+x3*m31   | x0*m00+x3*m30   */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r0, r1                      */
-    MOVQ      ( MM5, REGOFF(8, EDX) )	/* write r2, r3                      */
-
-LLBL( G3TP3NRM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_2d_masked )
-GLNAME( gl_3dnow_transform_points4_2d_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(16, ECX), MM7 )	/*                 | m10             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m10             |                 */
-    POR       ( MM7, MM0 )		/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM1 )		/* m11             | m01             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2M_4 ) )
-
-ALIGNTEXT32
-LLBL( G3TP2M_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2M_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM3 )	/* x1              | x0              */
-    MOVQ      ( MM3, MM4 )		/* x1              | x0              */
-
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-    PFMUL     ( MM0, MM3 )		/* x1*m10          | x0*m00          */
-
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-    PFMUL     ( MM1, MM4 )		/* x1*m11          | x0*m01          */
-
-    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
-    PFACC     ( MM4, MM3 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-
-    PFMUL     ( MM2, MM6 )		/* x3*m31          | x3*m30          */
-    PFADD     ( MM6, MM3 )		/* r1              | r0              */
-
-    MOVQ      ( MM3, REGIND(EDX) )	/* write r0, r1                      */
-    MOVQ      ( MM5, REGOFF(8, EDX) )	/* write r2, r3                      */
-
-LLBL( G3TP2M_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2M_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2M_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_2d_no_rot_masked )
-GLNAME( gl_3dnow_transform_points4_2d_no_rot_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(20, ECX), MM7 )	/*                 | m11             */
-
-    PSLLQ     ( CONST(32), MM7 )	/* m11             |                 */
-    POR       ( MM7, MM0 )		/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRM_4 ) )
-
-ALIGNTEXT32
-LLBL( G3TP2NRM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TP2NRM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x2              */
-    PFMUL     ( MM1, MM6 )		/* x3*m31          | x3*m30          */
-
-    PFADD     ( MM6, MM4 )		/* x1*m11+x3*m31   | x0*m00+x3*m30   */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r0, r1                      */
-
-    MOVQ      ( MM5, REGOFF(8, EDX) )	/* write r2, r3                      */
-
-LLBL( G3TP2NRM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2NRM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_identity_masked )
-GLNAME( gl_3dnow_transform_points4_identity_masked ):
-
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-    MOV_L     ( ARG_CLIP, EBP )
-    MOV_B     ( ARG_FLAG, BL )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPIM_4 ) )
-
-ALIGNTEXT32
-LLBL( G3TPIM_2 ):
-
-    TEST_B    ( BL, REGIND(EBP) )	/* mask [i] != clip flag ??          */
-    JNZ       ( LLBL( G3TPIM_3 ) )	/* skip vertex                       */
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVQ      ( MM0, REGIND(EDX) )	/* r1              | r0              */
-
-    MOVQ      ( REGOFF(8, EAX), MM1 )	/* x3              | x2              */
-    MOVQ      ( MM1, REGOFF(8, EDX) )	/* r3              | r2              */
-
-LLBL( G3TPIM_3 ):
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    INC_L     ( EBP )			/* next clipmask                     */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPIM_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIM_4 ):
-
-    FEMMS
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_raw1.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_raw1.S:1.4 xc/extras/Mesa/src/X86/3dnow_xform_raw1.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_raw1.S:1.4	Mon Nov 13 18:31:07 2000
+++ xc/extras/Mesa/src/X86/3dnow_xform_raw1.S	Thu Feb 27 12:15:54 2003
@@ -1,422 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	4
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_general_raw )
-GLNAME( gl_3dnow_transform_points1_general_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(4, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGR_3 ) )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVQ      ( REGOFF(8, ECX), MM1 )	/* m03             | m02             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-    MOVQ      ( REGOFF(56, ECX), MM3 )	/* m33             | m32             */
-
-ALIGNTEXT16
-LLBL( G3TPGR_2 ):
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-
-    MOVQ      ( MM4, MM5 )		/* x0              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-
-    PFMUL     ( MM1, MM5 )		/* x0*m03          | x0*m02          */
-    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
-
-    PFADD     ( MM3, MM5 )		/* x0*m03+m33      | x0*m02+m32      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVQ      ( MM5, REGOFF(8, EDX) )	/* write r3, r2                      */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPGR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_identity_raw )
-GLNAME( gl_3dnow_transform_points1_identity_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(1), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_1), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(4, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPIR_4) )
-
-ALIGNTEXT16
-LLBL( G3TPIR_3 ):
-
-    MOVD      ( REGIND(EAX), MM0 )	/*                 | x0              */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    MOVD      ( MM0, REGIND(EDX) )	/*                 | r0              */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPIR_3 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIR_4 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_3d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points1_3d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(4, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-ALIGNTEXT16
-LLBL( G3TP3NRR_2 ):
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PFMUL     ( MM0, MM4 )		/*                 | x0*m00          */
-
-    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVD      ( MM3, REGOFF(8, EDX) )	/* write r2                          */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_perspective_raw )
-GLNAME( gl_3dnow_transform_points1_perspective_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(4, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-ALIGNTEXT16
-LLBL( G3TPPR_2 ):
-
-    MOVD      ( REGIND(EAX), MM4 )	/* 0               | x0              */
-    PFMUL     ( MM0, MM4 )		/* 0               | x0*m00          */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( MM3, REGOFF(8, EDX) )	/* write r2  (=m32), r3 (=0)         */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPPR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_2d_raw )
-GLNAME( gl_3dnow_transform_points1_2d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(4, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2R_3 ) )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2R_2 ):
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2R_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2R_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_2d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points1_2d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(4, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2NRR_2 ):
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    PFMUL     ( MM0, MM4 )		/*                 | x0*m00          */
-    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP2NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points1_3d_raw )
-GLNAME( gl_3dnow_transform_points1_3d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(4, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3R_3 ) )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVD      ( REGOFF(8, ECX), MM1 )	/*                 | m02             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-ALIGNTEXT16
-LLBL( G3TP3R_2 ):
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-
-    MOVQ      ( MM4, MM5 )		/*                 | x0              */
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-
-    PFMUL     ( MM1, MM5 )		/*                 | x0*m02          */
-    PFADD     ( MM2, MM4 )		/* x0*m01+m31      | x0*m00+m30      */
-
-    PFADD     ( MM3, MM5 )		/*                 | x0*m02+m32      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVD      ( MM5, REGOFF(8, EDX) )	/* write r2                          */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3R_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3R_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_raw2.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_raw2.S:1.4 xc/extras/Mesa/src/X86/3dnow_xform_raw2.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_raw2.S:1.4	Mon Nov 13 18:31:08 2000
+++ xc/extras/Mesa/src/X86/3dnow_xform_raw2.S	Thu Feb 27 12:15:54 2003
@@ -1,463 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	4
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_general_raw )
-GLNAME( gl_3dnow_transform_points2_general_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
-
-    MOVD      ( REGOFF(8, ECX), MM2 )	/*                 | m02             */
-    PUNPCKLDQ ( REGOFF(24, ECX), MM2 )	/* m12             | m02             */
-
-    MOVD      ( REGOFF(12, ECX), MM3 )	/*                 | m03             */
-    PUNPCKLDQ ( REGOFF(28, ECX), MM3 )	/* m13             | m03             */
-
-    MOVQ      ( REGOFF(48, ECX), MM4 )	/* m31             | m30             */
-    MOVQ      ( REGOFF(56, ECX), MM5 )	/* m33             | m32             */
-
-ALIGNTEXT16
-LLBL( G3TPGR_2 ):
-
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-
-    PFMUL     ( MM0, MM6 )		/* x1*m10          | x0*m00          */
-    PFMUL     ( MM1, MM7 )		/* x1*m11          | x0*m01          */
-
-    PFACC     ( MM7, MM6 )		/* x0*m01+x1*m11   | x0*x00+x1*m10   */
-    PFADD     ( MM4, MM6 )		/* x0*...*m11+m31  | x0*...*m10+m30  */
-
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-    PFMUL     ( MM2, MM6 )		/* x1*m12          | x0*m02          */
-
-    PFMUL     ( MM3, MM7 )		/* x1*m13          | x0*m03          */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    PFACC     ( MM7, MM6 )		/* x0*m03+x1*m13   | x0*x02+x1*m12   */
-    PFADD     ( MM5, MM6 )		/* x0*...*m13+m33  | x0*...*m12+m32  */
-
-    MOVQ      ( MM6, REGOFF(8, EDX) )	/* write r3, r2                      */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPGR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_perspective_raw )
-GLNAME( gl_3dnow_transform_points2_perspective_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-ALIGNTEXT16
-LLBL( G3TPPR_2 ):
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( MM3, REGOFF(8, EDX) )	/* write r2  (=m32), r3 (=0)         */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPPR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_3d_raw )
-GLNAME( gl_3dnow_transform_points2_3d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3 ), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3R_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
-
-    MOVD      ( REGOFF(8, ECX), MM2 )	/*                 | m02             */
-    PUNPCKLDQ ( REGOFF(24, ECX), MM2 )	/* m12             | m02             */
-
-    MOVQ      ( REGOFF(48, ECX), MM4 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM5 )	/*                 | m32             */
-
-ALIGNTEXT16
-LLBL( G3TP3R_2 ):
-
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-
-    PFMUL     ( MM0, MM6 )		/* x1*m10          | x0*m00          */
-    PFMUL     ( MM1, MM7 )		/* x1*m11          | x0*m01          */
-
-    PFACC     ( MM7, MM6 )		/* x0*m01+x1*m11   | x0*x00+x1*m10   */
-    PFADD     ( MM4, MM6 )		/* x0*...*m11+m31  | x0*...*m10+m30  */
-
-    MOVQ      ( MM6, REGIND(EDX) )	/* write r1, r0                      */
-    MOVQ      ( REGIND(EAX), MM6 )	/* x1              | x0              */
-
-    MOVQ      ( MM6, MM7 )		/* x1              | x0              */
-    PFMUL     ( MM2, MM6 )		/* x1*m12          | x0*m02          */
-
-    PFACC     ( MM7, MM6 )		/* ***trash***     | x0*x02+x1*m12   */
-    PFADD     ( MM5, MM6 )		/* ***trash***     | x0*...*m12+m32  */
-
-    MOVD      ( MM6, REGOFF(8, EDX) )	/* write r2                          */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3R_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3R_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_3d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points2_3d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3 ), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-ALIGNTEXT16
-LLBL( G3TP3NRR_2 ):
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    PFADD     ( MM2, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    MOVD      ( MM3, REGOFF(8, EDX) )	/* write r2                          */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP3NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_2d_raw )
-GLNAME( gl_3dnow_transform_points2_2d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2R_3 ) )
-
-    MOVQ      ( REGIND(ECX), MM0 )	/* m01             | m00             */
-    MOVQ      ( REGOFF(16, ECX), MM1 )	/* m11             | m10             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2R_2 ):
-
-    MOVD      ( REGIND(EAX), MM4 )	/*                 | x0              */
-    MOVD      ( REGOFF(4, EAX), MM5 )	/*                 | x1              */
-
-    PUNPCKLDQ ( MM4, MM4 )		/* x0              | x0              */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    PFMUL     ( MM0, MM4 )		/* x0*m01          | x0*m00          */
-    PUNPCKLDQ ( MM5, MM5 )		/* x1              | x1              */
-
-    PFMUL     ( MM1, MM5 )		/* x1*m11          | x1*m10          */
-    PFADD     ( MM2, MM4 )		/* x...x1*m11+31   | x0*..*m10+m30   */
-
-    PFADD     ( MM5, MM4 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2R_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2R_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_2d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points2_2d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2NRR_2 ):
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    PFADD     ( MM2, MM4 )		/* m31             | x0*m00+m30      */
-
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r1, r0                      */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP2NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points2_identity_raw )
-GLNAME( gl_3dnow_transform_points2_identity_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(2), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPIR_3 ) )
-
-ALIGNTEXT16
-LLBL( G3TPIR_3 ):
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    MOVQ      ( MM0, REGIND(EDX) )	/* r1              | r0              */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPIR_3 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIR_4 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_raw3.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_raw3.S:1.6 xc/extras/Mesa/src/X86/3dnow_xform_raw3.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_raw3.S:1.6	Wed Nov 14 05:28:07 2001
+++ xc/extras/Mesa/src/X86/3dnow_xform_raw3.S	Thu Feb 27 12:15:54 2003
@@ -1,544 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	4
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_general_raw )
-GLNAME( gl_3dnow_transform_points3_general_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGR_2 ) )
-
-    PREFETCHW ( REGIND(EDX) )
-
-ALIGNTEXT16
-LLBL( G3TPGR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM2 )	/*                 | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    MOVQ      ( MM0, MM1 )		/* x1              | x0              */
-    PUNPCKLDQ ( MM2, MM2 )		/* x2              | x2              */
-
-    PUNPCKLDQ ( MM0, MM0 )		/* x0              | x0              */
-    MOVQ      ( MM2, MM5 )		/* x2              | x2              */
-
-    PUNPCKHDQ ( MM1, MM1 )		/* x1              | x1              */
-    PFMUL     ( REGOFF(32, ECX), MM2 )	/* x2*m9           | x2*m8           */
-
-    MOVQ      ( MM0, MM3 )		/* x0              | x0              */
-    PFMUL     ( REGOFF(40, ECX), MM5 )	/* x2*m11          | x2*m10          */
-
-    MOVQ      ( MM1, MM4 )		/* x1              | x1              */
-    PFMUL     ( REGIND(ECX), MM0 )	/* x0*m1           | x0*m0           */
-
-    PFADD     ( REGOFF(48, ECX), MM2 )	/* x2*m9+m13       | x2*m8+m12       */
-    PFMUL     ( REGOFF(16, ECX), MM1 )	/* x1*m5           | x1*m4           */
-
-    PFADD     ( REGOFF(56, ECX), MM5 )	/* x2*m11+m15      | x2*m10+m14      */
-    PFADD     ( MM0, MM1 )		/* x0*m1+x1*m5     | x0*m0+x1*m4     */
-
-    PFMUL     ( REGOFF(8, ECX), MM3 )	/* x0*m3           | x0*m2           */
-    PFADD     ( MM1, MM2 )		/* r1              | r0              */
-
-    PFMUL     ( REGOFF(24, ECX), MM4 )	/* x1*m7           | x1*m6           */
-    ADD_L     ( CONST(16), EDX )	/* next output vertex                */
-
-    PFADD     ( MM3, MM4 )		/* x0*m3+x1*m7     | x0*m2+x1*m6     */
-    MOVQ      ( MM2, REGOFF(-16, EDX) )	/* write r0, r1                      */
-
-    PFADD     ( MM4, MM5 )		/* r3              | r2              */
-    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPGR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_perspective_raw )
-GLNAME( gl_3dnow_transform_points3_perspective_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPR_2 ) )
-
-    PREFETCH  ( REGIND(EAX) )
-    PREFETCHW ( REGIND(EDX) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVQ      ( REGOFF(32, ECX), MM1 )	/* m21             | m20             */
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-ALIGNTEXT16
-LLBL( G3TPPR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    PXOR      ( MM7, MM7 )		/* 0               | 0               */
-    MOVQ      ( MM5, MM6 )		/*                 | x2              */
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    PFSUB     ( MM5, MM7 )		/*                 | -x2             */
-
-    PFMUL     ( MM2, MM6 )		/*                 | x2*m22          */
-    PUNPCKLDQ ( MM5, MM5 )		/* x2              | x2              */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    PFMUL     ( MM1, MM5 )		/* x2*m21          | x2*m20          */
-
-    PFADD     ( MM3, MM6 )		/*                 | x2*m22+m32      */
-    PFADD     ( MM4, MM5 )		/* x1*m11+x2*m21   | x0*m00+x2*m20   */
-
-    MOVQ      ( MM5, REGOFF(-16, EDX) )	/* write r0, r1                      */
-    MOVD      ( MM6, REGOFF(-8, EDX) )	/* write r2                          */
-
-    MOVD      ( MM7, REGOFF(-4, EDX) )	/* write r3                          */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPPR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_3d_raw )
-GLNAME( gl_3dnow_transform_points3_3d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3R_2 ) )
-
-    PREFETCH  ( REGIND(EAX) )
-    PREFETCH  ( REGIND(EDX) )
-
-    MOVD      ( REGOFF(8, ECX), MM7 )	/*                 | m2              */
-    PUNPCKLDQ ( REGOFF(24, ECX), MM7 )	/* m6              | m2              */
-
-ALIGNTEXT16
-LLBL( G3TP3R_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM1 )	/*                 | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    MOVQ      ( MM0, MM2 )		/* x1              | x0              */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    PUNPCKLDQ ( MM2, MM2 )		/* x0              | x0              */
-    MOVQ      ( MM0, MM3 )		/* x1              | x0              */
-
-    PFMUL     ( REGIND(ECX), MM2 )	/* x0*m1           | x0*m0           */
-    PUNPCKHDQ ( MM3, MM3 )		/* x1              | x1              */
-
-    MOVQ      ( MM1, MM4 )		/*                 | x2              */
-    PFMUL     ( REGOFF(16, ECX), MM3 )	/* x1*m5           | x1*m4           */
-
-    PUNPCKLDQ ( MM4, MM4 )		/* x2              | x2              */
-    PFADD     ( MM2, MM3 )		/* x0*m1+x1*m5     | x0*m0+x1*m4     */
-
-    PFMUL     ( REGOFF(32, ECX), MM4 )	/* x2*m9           | x2*m8           */
-    PFADD     ( REGOFF(48, ECX), MM3 )	/* x0*m1+...+m11   | x0*m0+x1*m4+m12 */
-
-    PFMUL     ( MM7, MM0 )		/* x1*m6           | x0*m2           */
-    PFADD     ( MM4, MM3 )		/* r1              | r0              */
-
-    PFMUL     ( REGOFF(40, ECX), MM1 )	/*                 | x2*m10          */
-    PUNPCKLDQ ( REGOFF(56, ECX), MM1 )	/* m14             | x2*m10          */
-
-    PFACC     ( MM0, MM1 )
-
-    MOVQ      ( MM3, REGOFF(-16, EDX) )	/* write r0, r1                      */
-    PFACC     ( MM1, MM1 )		/*                 | r2              */
-
-    MOVD      ( MM1, REGOFF(-8, EDX) )	/* write r2                          */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP3R_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3R_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_3d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points3_3d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRR_2 ) )
-
-    PREFETCH  ( REGIND(EAX) )
-    PREFETCHW ( REGIND(EDX) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-    PUNPCKLDQ ( MM2, MM2 )		/* m22             | m22             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-    MOVD      ( REGOFF(56, ECX), MM3 )	/*                 | m32             */
-
-    PUNPCKLDQ ( MM3, MM3 )		/* m32             | m32             */
-
-ALIGNTEXT16
-LLBL( G3TP3NRR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    PREFETCHW ( REGIND(EAX) )
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    PFADD     ( MM1, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
-    PFMUL     ( MM2, MM5 )		/*                 | x2*m22          */
-
-    PFADD     ( MM3, MM5 )		/*                 | x2*m22+m32      */
-    MOVQ      ( MM4, REGIND(EDX) )	/* write r0, r1                      */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    MOVD      ( MM5, REGOFF(-8, EDX) )	/* write r2                          */
-    JNZ       ( LLBL( G3TP3NRR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_2d_raw )
-GLNAME( gl_3dnow_transform_points3_2d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2R_3) )
-
-    PREFETCH  ( REGIND(EAX) )
-    PREFETCHW ( REGIND(EDX) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2R_2 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM3 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    MOVQ      ( MM3, MM4 )		/* x1              | x0              */
-    PFMUL     ( MM0, MM3 )		/* x1*m10          | x0*m00          */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    PFMUL     ( MM1, MM4 )		/* x1*m11          | x0*m01          */
-
-    PFACC     ( MM4, MM3 )		/* x0*m00+x1*m10   | x0*m01+x1*m11   */
-    MOVD      ( MM5, REGOFF(-8, EDX) )	/* write r2 (=x2)                    */
-
-    PFADD     ( MM2, MM3 )		/* x0*...*m10+m30  | x0*...*m11+m31  */
-    MOVQ      ( MM3, REGOFF(-16, EDX) )	/* write r0, r1                      */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP2R_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2R_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_2d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points3_2d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRR_2 ) )
-
-    PREFETCH  ( REGIND(EAX) )
-    PREFETCHW ( REGIND(EDX) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2NRR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM5 )	/*                 | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    PFADD     ( MM1, MM4 )		/* x1*m11+m31      | x0*m00+m30      */
-
-    MOVQ      ( MM4, REGOFF(-16, EDX) )	/* write r0, r1                      */
-    MOVD      ( MM5, REGOFF(-8, EDX) )	/* write r2 (=x2)                    */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP2NRR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points3_identity_raw )
-GLNAME( gl_3dnow_transform_points3_identity_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(3), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPIR_2 ) )
-
-    PREFETCHW ( REGIND(EDX) )
-
-ALIGNTEXT16
-LLBL( G3TPIR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVD      ( REGOFF(8, EAX), MM1 )	/*                 | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    MOVQ      ( MM0, REGOFF(-16, EDX) )	/* r1              | r0              */
-
-    MOVD      ( MM1, REGOFF(-8, EDX) )	/*                 | r2              */
-    JNZ       ( LLBL( G3TPIR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/3dnow_xform_raw4.S
diff -u xc/extras/Mesa/src/X86/3dnow_xform_raw4.S:1.6 xc/extras/Mesa/src/X86/3dnow_xform_raw4.S:removed
--- xc/extras/Mesa/src/X86/3dnow_xform_raw4.S:1.6	Wed Nov 14 05:28:07 2001
+++ xc/extras/Mesa/src/X86/3dnow_xform_raw4.S	Thu Feb 27 12:15:54 2003
@@ -1,557 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-    SEG_TEXT
-
-#define FRAME_OFFSET	4
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_general_raw )
-GLNAME( gl_3dnow_transform_points4_general_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPGR_2 ) )
-
-    PREFETCHW ( REGIND(EDX) )
-
-ALIGNTEXT16
-LLBL( G3TPGR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM4 )	/* x3              | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    MOVQ      ( MM0, MM2 )		/* x1              | x0              */
-    MOVQ      ( MM4, MM6 )		/* x3              | x2              */
-
-    PUNPCKLDQ ( MM0, MM0 )		/* x0              | x0              */
-    PUNPCKHDQ ( MM2, MM2 )		/* x1              | x1              */
-
-    MOVQ      ( MM0, MM1 )		/* x0              | x0              */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    PFMUL     ( REGIND(ECX), MM0 )	/* x0*m1           | x0*m0           */
-    MOVQ      ( MM2, MM3 )		/* x1              | x1              */
-
-    PFMUL     ( REGOFF(8, ECX), MM1 )	/* x0*m3           | x0*m2           */
-    PUNPCKLDQ ( MM4, MM4 )		/* x2              | x2              */
-
-    PFMUL     ( REGOFF(16, ECX), MM2 )	/* x1*m5           | x1*m4           */
-    MOVQ      ( MM4, MM5 )		/* x2              | x2              */
-
-    PFMUL     ( REGOFF(24, ECX), MM3 )	/* x1*m7           | x1*m6           */
-    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
-
-    PFMUL     ( REGOFF(32, ECX), MM4 )	/* x2*m9           | x2*m8           */
-    MOVQ      ( MM6, MM7 )		/* x3              | x3              */
-
-    PFMUL     ( REGOFF(40, ECX), MM5 )	/* x2*m11          | x2*m10          */
-    PFADD     ( MM0, MM2 )
-
-    PFMUL     ( REGOFF(48, ECX), MM6 )	/* x3*m13          | x3*m12          */
-    PFADD     ( MM1, MM3 )
-
-    PFMUL     ( REGOFF(56, ECX), MM7 )	/* x3*m15          | x3*m14          */
-    PFADD     ( MM4, MM6 )
-
-    PFADD     ( MM5, MM7 )
-    PFADD     ( MM2, MM6 )
-
-    PFADD     ( MM3, MM7 )
-    MOVQ      ( MM6, REGOFF(-16, EDX) )
-
-    MOVQ      ( MM7, REGOFF(-8, EDX) )
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPGR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPGR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_perspective_raw )
-GLNAME( gl_3dnow_transform_points4_perspective_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPPR_2 ) )
-
-    PREFETCH  ( REGIND(EAX) )
-    PREFETCHW ( REGIND(EDX) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVD      ( REGOFF(40, ECX), MM1 )	/*                 | m22             */
-    PUNPCKLDQ ( REGOFF(56, ECX), MM1 )	/* m32             | m22             */
-
-    MOVQ      ( REGOFF(32, ECX), MM2 )	/* m21             | m20             */
-    PXOR      ( MM7, MM7 )		/* 0               | 0               */
-
-ALIGNTEXT16
-LLBL( G3TPPR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-    MOVD      ( REGOFF(8, EAX), MM3 )	/*                 | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGOFF(32, EAX) )	/* hopefully stride is zero          */
-
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    PUNPCKLDQ ( MM5, MM5 )		/* x2              | x2              */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    PFMUL     ( MM2, MM5 )		/* x2*m21          | x2*m20          */
-    PFSUBR    ( MM7, MM3 )		/*                 | -x2             */
-
-    PFMUL     ( MM1, MM6 )		/* x3*m32          | x2*m22          */
-    PFADD     ( MM4, MM5 )		/* x1*m11+x2*m21   | x0*m00+x2*m20   */
-
-    PFACC     ( MM3, MM6 )		/* -x2             | x2*m22+x3*m32   */
-    MOVQ      ( MM5, REGOFF(-16, EDX) )	/* write r0, r1                      */
-
-    MOVQ      ( MM6, REGOFF(-8, EDX) )	/* write r2, r3                      */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TPPR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPPR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_3d_raw )
-GLNAME( gl_3dnow_transform_points4_3d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3R_2 ) )
-
-    MOVD      ( REGOFF(8, ECX), MM6 )	/*                 | m2              */
-    PUNPCKLDQ ( REGOFF(24, ECX), MM6 )	/* m6              | m2              */
-
-    MOVD      ( REGOFF(40, ECX), MM7 )	/*                 | m10             */
-    PUNPCKLDQ ( REGOFF(56, ECX), MM7 )	/* m14             | m10             */
-
-ALIGNTEXT16
-LLBL( G3TP3R_1 ):
-
-    MOVQ      ( REGIND(EAX), MM2 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM3 )	/* x3              | x2              */
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-    PREFETCH  ( REGOFF(32, EAX) )	/* hopefully array is tightly packed */
-
-    MOVQ      ( MM2, MM0 )		/* x1              | x0              */
-    MOVQ      ( MM3, MM4 )		/* x3              | x2              */
-
-    MOVQ      ( MM0, MM1 )		/* x1              | x0              */
-    MOVQ      ( MM4, MM5 )		/* x3              | x2              */
-
-    PUNPCKLDQ ( MM0, MM0 )		/* x0              | x0              */
-    PUNPCKHDQ ( MM1, MM1 )		/* x1              | x1              */
-
-    PFMUL     ( REGIND(ECX), MM0 )	/* x0*m1           | x0*m0           */
-    PUNPCKLDQ ( MM3, MM3 )		/* x2              | x2              */
-
-    PFMUL     ( REGOFF(16, ECX), MM1 )	/* x1*m5           | x1*m4           */
-    PUNPCKHDQ ( MM4, MM4 )		/* x3              | x3              */
-
-    PFMUL     ( MM6, MM2 )		/* x1*m6           | x0*m2           */
-    PFADD     ( MM0, MM1 )		/* x0*m1+x1*m5     | x0*m0+x1*m4     */
-
-    PFMUL     ( REGOFF(32, ECX), MM3 )	/* x2*m9           | x2*m8           */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    PFMUL     ( REGOFF(48, ECX), MM4 )	/* x3*m13          | x3*m12          */
-    PFADD     ( MM1, MM3 )		/* x0*m1+..+x2*m9  | x0*m0+...+x2*m8 */
-
-    PFMUL     ( MM7, MM5 )		/* x3*m14          | x2*m10          */
-    PFADD     ( MM3, MM4 )		/* r1              | r0              */
-
-    PFACC     ( MM2, MM5 )		/* x0*m2+x1*m6     | x2*m10+x3*m14   */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PFACC     ( MM0, MM5 )		/* r3              | r2              */
-
-    MOVQ      ( MM4, REGOFF(-16, EDX) )	/* write r0, r1                      */
-    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP3R_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3R_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_3d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points4_3d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP3NRR_2 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVD      ( REGOFF(40, ECX), MM2 )	/*                 | m22             */
-    PUNPCKLDQ ( REGOFF(56, ECX), MM2 )	/* m32             | m22             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP3NRR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-    MOVD      ( REGOFF(12, EAX), MM7 )	/*                 | x3              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-
-    PREFETCH  ( REGOFF(32, EAX) )	/* hopefully stride is zero          */
-
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-
-    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
-    PFMUL     ( MM2, MM5 )		/* x3*m32          | x2*m22          */
-
-    PFMUL     ( MM1, MM6 )		/* x3*m31          | x3*m30          */
-    PFACC     ( MM7, MM5 )		/* x3              | x2*m22+x3*m32   */
-
-    PFADD     ( MM6, MM4 )		/* x1*m11+x3*m31   | x0*m00+x3*m30   */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    MOVQ      ( MM4, REGOFF(-16, EDX) )	/* write r0, r1                      */
-    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP3NRR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP3NRR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_2d_raw )
-GLNAME( gl_3dnow_transform_points4_2d_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2R_2 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(16, ECX), MM0 )	/* m10             | m00             */
-
-    MOVD      ( REGOFF(4, ECX), MM1 )	/*                 | m01             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM1 )	/* m11             | m01             */
-
-    MOVQ      ( REGOFF(48, ECX), MM2 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2R_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )       /* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM3 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    MOVQ      ( MM3, MM4 )		/* x1              | x0              */
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-
-    PFMUL     ( MM1, MM4 )		/* x1*m11          | x0*m01          */
-    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
-
-    PFMUL     ( MM0, MM3 )		/* x1*m10          | x0*m00          */
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-
-    PFACC     ( MM4, MM3 )		/* x0*m01+x1*m11   | x0*m00+x1*m10   */
-    PFMUL     ( MM2, MM6 )		/* x3*m31          | x3*m30          */
-
-    PFADD     ( MM6, MM3 )		/* r1              | r0              */
-    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
-
-    MOVQ      ( MM3, REGOFF(-16, EDX) )	/* write r0, r1                      */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TP2R_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2R_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_2d_no_rot_raw )
-GLNAME( gl_3dnow_transform_points4_2d_no_rot_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TP2NRR_3 ) )
-
-    MOVD      ( REGIND(ECX), MM0 )	/*                 | m00             */
-    PUNPCKLDQ ( REGOFF(20, ECX), MM0 )	/* m11             | m00             */
-
-    MOVQ      ( REGOFF(48, ECX), MM1 )	/* m31             | m30             */
-
-ALIGNTEXT16
-LLBL( G3TP2NRR_2 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )	/* prefetch 2 vertices ahead         */
-
-    MOVQ      ( REGIND(EAX), MM4 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM5 )	/* x3              | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    PFMUL     ( MM0, MM4 )		/* x1*m11          | x0*m00          */
-    MOVQ      ( MM5, MM6 )		/* x3              | x2              */
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    PUNPCKHDQ ( MM6, MM6 )		/* x3              | x3              */
-
-    PFMUL     ( MM1, MM6 )		/* x3*m31          | x3*m30          */
-    PFADD     ( MM4, MM6 )		/* x1*m11+x3*m31   | x0*m00+x3*m30   */
-
-    MOVQ      ( MM6, REGOFF(-16, EDX) )	/* write r0, r1                      */
-    MOVQ      ( MM5, REGOFF(-8, EDX) )	/* write r2, r3                      */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-
-    JNZ       ( LLBL( G3TP2NRR_2 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TP2NRR_3 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_3dnow_transform_points4_identity_raw )
-GLNAME( gl_3dnow_transform_points4_identity_raw ):
-
-    PUSH_L    ( ESI )
-
-    MOV_L     ( ARG_DEST, ECX )
-    MOV_L     ( ARG_MATRIX, ESI )
-    MOV_L     ( ARG_SOURCE, EAX )
-    MOV_L     ( CONST(4), REGOFF(V4F_SIZE, ECX) )
-    OR_B      ( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, ECX) )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), EDX )
-    MOV_L     ( EDX, REGOFF(V4F_COUNT, ECX) )
-
-    PUSH_L    ( EDI )
-
-    MOV_L     ( REGOFF(V4F_START, ECX), EDX )
-    MOV_L     ( ESI, ECX )
-    MOV_L     ( REGOFF(V4F_COUNT, EAX), ESI )
-    MOV_L     ( REGOFF(V4F_STRIDE, EAX), EDI )
-    MOV_L     ( REGOFF(V4F_START, EAX), EAX )
-
-    TEST_L    ( ESI, ESI )
-    JZ        ( LLBL( G3TPIR_2 ) )
-
-ALIGNTEXT16
-LLBL( G3TPIR_1 ):
-
-    PREFETCHW ( REGOFF(32, EDX) )       /* prefetch 2 vertices ahead         */
-	
-    MOVQ      ( REGIND(EAX), MM0 )	/* x1              | x0              */
-    MOVQ      ( REGOFF(8, EAX), MM1 )	/* x3              | x2              */
-
-    ADD_L     ( EDI, EAX )		/* next vertex                       */
-    PREFETCH  ( REGIND(EAX) )
-
-    ADD_L     ( CONST(16), EDX )	/* next r                            */
-    MOVQ      ( MM0, REGOFF(-16, EDX) )	/* r1              | r0              */
-
-    MOVQ      ( MM1, REGOFF(-8, EDX) )	/* r3              | r2              */
-
-    DEC_L     ( ESI )			/* decrement vertex counter          */
-    JNZ       ( LLBL( G3TPIR_1 ) )	/* cnt > 0 ? -> process next vertex  */
-
-LLBL( G3TPIR_2 ):
-
-    FEMMS
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
Index: xc/extras/Mesa/src/X86/Makefile.am
diff -u xc/extras/Mesa/src/X86/Makefile.am:1.1.1.4 xc/extras/Mesa/src/X86/Makefile.am:removed
--- xc/extras/Mesa/src/X86/Makefile.am:1.1.1.4	Tue Mar 20 21:37:54 2001
+++ xc/extras/Mesa/src/X86/Makefile.am	Thu Feb 27 12:15:54 2003
@@ -1,83 +0,0 @@
-## Process this file with automake to produce Makefile.in
-
-#AUTOMAKE_OPTIONS = no-dependencies
-
-
-
-x86_files = \
-	assyntax.h \
-	common_x86.c \
-	common_x86_asm.S \
-	common_x86_asm.h \
-	common_x86_features.h \
-	glapi_x86.S \
-	x86.c \
-	x86.h \
-	x86_cliptest.S \
-	clip_args.h \
-	x86_vertex.S \
-	x86_xform_masked2.S \
-	xform_args.h \
-	x86_xform_masked3.S \
-	x86_xform_masked4.S \
-	x86_xform_raw2.S \
-	x86_xform_raw3.S \
-	x86_xform_raw4.S
-
-x3dnow_files = \
-	3dnow.c \
-	3dnow.h \
-	3dnow_norm_raw.S \
-	3dnow_xform_masked1.S \
-	3dnow_xform_masked2.S \
-	3dnow_xform_masked3.S \
-	3dnow_xform_masked4.S \
-	3dnow_xform_raw1.S \
-	3dnow_xform_raw2.S \
-	3dnow_xform_raw3.S \
-	3dnow_xform_raw4.S \
-	3dnow_vertex.S
-
-katmai_files = \
-	katmai.c \
-	katmai.h \
-	katmai_norm_raw.S \
-	katmai_xform_raw1.S \
-	katmai_xform_masked1.S \
-	katmai_xform_raw2.S \
-	katmai_xform_masked2.S \
-	katmai_xform_raw3.S \
-	katmai_xform_masked3.S \
-	katmai_xform_raw4.S \
-	katmai_xform_masked4.S \
-	katmai_vertex.S
-
-mmx_files = mmx.h mmx_blend.S
-
-if HAVE_3DNOW
-x3dnow_sources = $(x3dnow_files)
-CFLAGS_3DNOW = -DUSE_3DNOW_ASM
-endif
-
-if HAVE_SSE
-katmai_sources = $(katmai_files)
-CFLAGS_KATMAI = -DUSE_KATMAI_ASM
-endif
-
-if HAVE_MMX
-mmx_sources = $(mmx_files)
-CFLAGS_MMX = -DUSE_MMX_ASM
-endif
-
-if HAVE_X86
-# Build a libtool convenience library.
-noinst_LTLIBRARIES = libMesaX86.la
-x86_sources = $(x86_files)
-CFLAGS_X86 = -DUSE_X86_ASM
-endif
-
-libMesaX86_la_SOURCES = $(x86_sources) $(mmx_sources) $(x3dnow_sources) $(katmai_sources)
-
-INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/src $(CFLAGS_X86) $(CFLAGS_MMX) $(CFLAGS_3DNOW) $(CFLAGS_KATMAI)
-
-EXTRA_DIST = $(x3dnow_files) $(mmx_files) $(katmai_files)
Index: xc/extras/Mesa/src/X86/assyntax.h
diff -u xc/extras/Mesa/src/X86/assyntax.h:1.8 xc/extras/Mesa/src/X86/assyntax.h:1.12
--- xc/extras/Mesa/src/X86/assyntax.h:1.8	Mon Nov 13 18:31:09 2000
+++ xc/extras/Mesa/src/X86/assyntax.h	Mon Sep  9 17:30:02 2002
@@ -23,6 +23,7 @@
  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
+/* $XFree86: xc/extras/Mesa/src/X86/assyntax.h,v 1.12 2002/09/09 21:30:02 dawes Exp $ */
 
 /*
  * assyntax.h
@@ -68,6 +69,11 @@
 
 #if !(defined(NASM_ASSEMBLER) || defined(MASM_ASSEMBLER))
 
+/* Default to ATT_ASSEMBLER when SVR4 or SYSV are defined */
+#if (defined(SVR4) || defined(SYSV)) && !defined(GNU_ASSEMBLER)
+#define ATT_ASSEMBLER
+#endif
+
 #if !defined(ATT_ASSEMBLER) && !defined(GNU_ASSEMBLER) && !defined(ACK_ASSEMBLER)
 #define GNU_ASSEMBLER
 #endif
@@ -199,6 +205,11 @@
 #define _STX6		%st(6)
 #define _STX7		%st(7)
 #define ST(x)		CONCAT(_STX,x)
+#ifdef GNU_ASSEMBLER
+#define ST0		%st(0)
+#else
+#define ST0		%st
+#endif
 /* MMX Registers */
 #define MM0		%mm0
 #define MM1		%mm1
@@ -243,7 +254,7 @@
 #endif /* ACK_ASSEMBLER */
 
 
-#if defined(__QNX__) || defined(Lynx) || (defined(SYSV) || defined(SVR4)) && !defined(ACK_ASSEMBLER) || defined(__ELF__) || defined(__GNU__)
+#if defined(__QNX__) || defined(Lynx) || (defined(SYSV) || defined(SVR4)) && !defined(ACK_ASSEMBLER) || defined(__ELF__) || defined(__GNU__) || defined(__GNUC__) && !defined(DJGPP)
 #define GLNAME(a)	a
 #else
 #define GLNAME(a)	CONCAT(_,a)
@@ -857,6 +868,7 @@
 #if defined(NASM_ASSEMBLER)
 
 #define ST(n)		st ## n
+#define ST0		st0
 
 #define TBYTE_PTR	tword
 #define QWORD_PTR	qword
@@ -979,12 +991,21 @@
 #define B_CONST(a)		a
 
 /* Indirect Mode */
+#ifdef NASM_ASSEMBLER
+#define P_CONTENT(a)		[a]
+#define X_CONTENT(a)		TBYTE_PTR [a]
+#define D_CONTENT(a)		QWORD_PTR [a]
+#define L_CONTENT(a)		DWORD_PTR [a]
+#define W_CONTENT(a)		WORD_PTR [a]
+#define B_CONTENT(a)		BYTE_PTR [a]
+#else
 #define P_CONTENT(a)		a
 #define X_CONTENT(a)		TBYTE_PTR a
 #define D_CONTENT(a)		QWORD_PTR a
 #define L_CONTENT(a)		DWORD_PTR a
 #define W_CONTENT(a)		WORD_PTR a
 #define B_CONTENT(a)		BYTE_PTR a
+#endif
 
 /* Register a indirect */
 #define P_REGIND(a)		[a]
Index: xc/extras/Mesa/src/X86/clip_args.h
diff -u xc/extras/Mesa/src/X86/clip_args.h:1.2 xc/extras/Mesa/src/X86/clip_args.h:1.3
--- xc/extras/Mesa/src/X86/clip_args.h:1.2	Mon Nov 13 18:31:10 2000
+++ xc/extras/Mesa/src/X86/clip_args.h	Fri Feb 22 14:31:33 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -34,27 +34,11 @@
 #ifndef __CLIP_ARGS_H__
 #define __CLIP_ARGS_H__
 
-/* Offsets into GLvector4f
- */
-#define V4F_DATA	0
-#define V4F_START	4
-#define V4F_COUNT	8
-#define V4F_STRIDE	12
-#define V4F_SIZE	16
-#define V4F_FLAGS	20
-
-/* GLvector4f flags
- */
-#define VEC_SIZE_1	1
-#define VEC_SIZE_2	3
-#define VEC_SIZE_3	7
-#define VEC_SIZE_4	15
-
 /*
  * Offsets for clip_func arguments
  *
- * typedef GLvector4f *(*clip_func)( GLvector4f *vClip,
- *	                             GLvector4f *vProj,
+ * typedef GLvector4f *(*clip_func)( GLvector4f *clip_vec,
+ *	                             GLvector4f *proj_vec,
  *	                             GLubyte clipMask[],
  *	                             GLubyte *orMask,
  *	                             GLubyte *andMask );
Index: xc/extras/Mesa/src/X86/common_x86.c
diff -u xc/extras/Mesa/src/X86/common_x86.c:1.9 xc/extras/Mesa/src/X86/common_x86.c:1.12
--- xc/extras/Mesa/src/X86/common_x86.c:1.9	Fri Aug 17 14:40:11 2001
+++ xc/extras/Mesa/src/X86/common_x86.c	Mon Nov 25 20:04:20 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -23,31 +23,34 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-
 /*
  * Check CPU capabilities & initialize optimized funtions for this particular
  * processor.
  *
  * Written by Holger Waechtler <holger@akaflieg.extern.tu-berlin.de>
  * Changed by Andre Werthmann <wertmann@cs.uni-potsdam.de> for using the
- * new Katmai functions.
+ * new SSE functions.
  */
 
 #include <stdlib.h>
 #include <stdio.h>
-#if defined(USE_KATMAI_ASM) && defined(__linux__)
+#if defined(USE_SSE_ASM) && defined(__linux__)
 #include <signal.h>
 #endif
+#if defined(USE_SSE_ASM) && defined(__FreeBSD__)
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#endif
 
 #include "context.h"
 #include "common_x86_asm.h"
 
 
-int gl_x86_cpu_features = 0;
+int _mesa_x86_cpu_features = 0;
 
 /* No reason for this to be public.
  */
-extern int gl_identify_x86_cpu_features( void );
+extern int _mesa_identify_x86_cpu_features( void );
 
 
 static void message( const char *msg )
@@ -67,7 +70,7 @@
    }
 }
 
-#if defined(USE_KATMAI_ASM)
+#if defined(USE_SSE_ASM)
 /*
  * We must verify that the Streaming SIMD Extensions are truly supported
  * on this processor before we go ahead and hook out the optimized code.
@@ -84,8 +87,8 @@
  * not good.
  */
 
-extern void gl_test_os_katmai_support( void );
-extern void gl_test_os_katmai_exception_support( void );
+extern void _mesa_test_os_sse_support( void );
+extern void _mesa_test_os_sse_exception_support( void );
 
 #if defined(__linux__) && defined(_POSIX_SOURCE) && defined(X86_FXSR_MAGIC)
 static void sigill_handler( int signal, struct sigcontext sc )
@@ -104,7 +107,7 @@
     */
    sc.eip += 3;
 
-   gl_x86_cpu_features &= ~(X86_FEATURE_XMM);
+   _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
 }
 
 static void sigfpe_handler( int signal, struct sigcontext sc )
@@ -122,7 +125,7 @@
       /* If we ever get here, we're completely hosed.
        */
       message( "\n\n" );
-      gl_problem( NULL, "SSE enabling test failed badly!" );
+      _mesa_problem( NULL, "SSE enabling test failed badly!" );
    }
 }
 #endif /* __linux__ && _POSIX_SOURCE && X86_FXSR_MAGIC */
@@ -135,7 +138,7 @@
  *
  * GH: Isn't this just awful?
  */
-static void check_os_katmai_support( void )
+static void check_os_sse_support( void )
 {
 #if defined(__linux__)
 #if defined(_POSIX_SOURCE) && defined(X86_FXSR_MAGIC)
@@ -159,7 +162,7 @@
    if ( cpu_has_xmm ) {
       message( "Testing OS support for SSE... " );
 
-      gl_test_os_katmai_support();
+      _mesa_test_os_sse_support();
 
       if ( cpu_has_xmm ) {
 	 message( "yes.\n" );
@@ -184,7 +187,7 @@
    if ( cpu_has_xmm ) {
       message( "Testing OS support for SSE unmasked exceptions... " );
 
-      gl_test_os_katmai_exception_support();
+      _mesa_test_os_sse_exception_support();
 
       if ( cpu_has_xmm ) {
 	 message( "yes.\n" );
@@ -211,29 +214,37 @@
     * SSE, so we disable it by default.
     */
    message( "Cannot test OS support for SSE, disabling to be safe.\n" );
-   gl_x86_cpu_features &= ~(X86_FEATURE_XMM);
+   _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
 #endif /* _POSIX_SOURCE && X86_FXSR_MAGIC */
+#elif defined(__FreeBSD__)
+   {
+      int ret, len, enabled;
+      len = sizeof(enabled);
+      ret = sysctlbyname("hw.instruction_sse", &enabled, &len, NULL, 0);
+      if (ret || !enabled)
+         _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
+   }
 #else
-   /* Do nothing on non-Linux platforms for now.
+   /* Do nothing on other platforms for now.
     */
    message( "Not testing OS support for SSE, leaving enabled.\n" );
 #endif /* __linux__ */
 }
 
-#endif /* USE_KATMAI_ASM */
+#endif /* USE_SSE_ASM */
 
 
-void gl_init_all_x86_transform_asm( void )
+void _mesa_init_all_x86_transform_asm( void )
 {
 #ifdef USE_X86_ASM
-   gl_x86_cpu_features = gl_identify_x86_cpu_features();
+   _mesa_x86_cpu_features = _mesa_identify_x86_cpu_features();
 
    if ( getenv( "MESA_NO_ASM" ) ) {
-      gl_x86_cpu_features = 0;
+      _mesa_x86_cpu_features = 0;
    }
 
-   if ( gl_x86_cpu_features ) {
-      gl_init_x86_transform_asm();
+   if ( _mesa_x86_cpu_features ) {
+      _mesa_init_x86_transform_asm();
    }
 
 #ifdef USE_MMX_ASM
@@ -241,7 +252,7 @@
       if ( getenv( "MESA_NO_MMX" ) == 0 ) {
          message( "MMX cpu detected.\n" );
       } else {
-         gl_x86_cpu_features &= ~(X86_FEATURE_MMX);
+         _mesa_x86_cpu_features &= ~(X86_FEATURE_MMX);
       }
    }
 #endif
@@ -250,23 +261,23 @@
    if ( cpu_has_3dnow ) {
       if ( getenv( "MESA_NO_3DNOW" ) == 0 ) {
          message( "3DNow! cpu detected.\n" );
-         gl_init_3dnow_transform_asm();
+         _mesa_init_3dnow_transform_asm();
       } else {
-         gl_x86_cpu_features &= ~(X86_FEATURE_3DNOW);
+         _mesa_x86_cpu_features &= ~(X86_FEATURE_3DNOW);
       }
    }
 #endif
 
-#ifdef USE_KATMAI_ASM
-   if ( cpu_has_xmm && getenv( "MESA_FORCE_KATMAI" ) == 0 ) {
-      check_os_katmai_support();
+#ifdef USE_SSE_ASM
+   if ( cpu_has_xmm && getenv( "MESA_FORCE_SSE" ) == 0 ) {
+      check_os_sse_support();
    }
    if ( cpu_has_xmm ) {
-      if ( getenv( "MESA_NO_KATMAI" ) == 0 ) {
-         message( "Katmai cpu detected.\n" );
-         gl_init_katmai_transform_asm();
+      if ( getenv( "MESA_NO_SSE" ) == 0 ) {
+         message( "SSE cpu detected.\n" );
+         _mesa_init_sse_transform_asm();
       } else {
-         gl_x86_cpu_features &= ~(X86_FEATURE_XMM);
+         _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
       }
    }
 #endif
@@ -274,39 +285,24 @@
 }
 
 /* Note: the above function must be called before this one, so that
- * gl_x86_cpu_features gets correctly initialized.
+ * _mesa_x86_cpu_features gets correctly initialized.
  */
-void gl_init_all_x86_shade_asm( void )
-{
-#ifdef USE_X86_ASM
-   if ( gl_x86_cpu_features ) {
-      /* Nothing here yet... */
-   }
-
-#ifdef USE_3DNOW_ASM
-   if ( cpu_has_3dnow && getenv( "MESA_NO_3DNOW" ) == 0 ) {
-      gl_init_3dnow_shade_asm();
-   }
-#endif
-#endif
-}
-
-void gl_init_all_x86_vertex_asm( void )
+void _mesa_init_all_x86_vertex_asm( void )
 {
 #ifdef USE_X86_ASM
-   if ( gl_x86_cpu_features ) {
-      gl_init_x86_vertex_asm();
+   if ( _mesa_x86_cpu_features ) {
+      _mesa_init_x86_vertex_asm();
    }
 
 #ifdef USE_3DNOW_ASM
    if ( cpu_has_3dnow && getenv( "MESA_NO_3DNOW" ) == 0 ) {
-      gl_init_3dnow_vertex_asm();
+      _mesa_init_3dnow_vertex_asm();
    }
 #endif
 
-#ifdef USE_KATMAI_ASM
-   if ( cpu_has_xmm && getenv( "MESA_NO_KATMAI" ) == 0 ) {
-      gl_init_katmai_vertex_asm();
+#ifdef USE_SSE_ASM
+   if ( cpu_has_xmm && getenv( "MESA_NO_SSE" ) == 0 ) {
+      _mesa_init_sse_vertex_asm();
    }
 #endif
 #endif
Index: xc/extras/Mesa/src/X86/common_x86_asm.S
diff -u xc/extras/Mesa/src/X86/common_x86_asm.S:1.9 xc/extras/Mesa/src/X86/common_x86_asm.S:1.16
--- xc/extras/Mesa/src/X86/common_x86_asm.S:1.9	Fri May 18 13:10:13 2001
+++ xc/extras/Mesa/src/X86/common_x86_asm.S	Mon Dec 16 11:18:33 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  4.0.3
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,6 +22,7 @@
  * 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.
  */
+/* $XFree86: xc/extras/Mesa/src/X86/common_x86_asm.S,v 1.16 2002/12/16 16:18:33 dawes Exp $ */
 
 /*
  * Check extended CPU capabilities.  Now justs returns the raw CPUID
@@ -33,7 +34,13 @@
  * Cleaned up and simplified by Gareth Hughes <gareth@valinux.com>
  */
 
-#include "assyntax.h"
+/*
+ * NOTE: Avoid using spaces in between '(' ')' and arguments, especially
+ * with macros like CONST, LLBL that expand to CONCAT(...).  Putting spaces
+ * in there will break the build on some platforms.
+ */
+
+#include "matypes.h"
 #include "common_x86_features.h"
 
 
@@ -57,8 +64,8 @@
 GLNAME( found_intel ):	STRING( "Genuine Intel processor found\n\0" )
 GLNAME( found_amd ):	STRING( "Authentic AMD processor found\n\0" )
 
-#ifdef USE_KATMAI_ASM
-GLNAME( katmai_test_dummy ):
+#ifdef USE_SSE_ASM
+GLNAME( sse_test_dummy ):
 	D_LONG 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000
 #endif
 
@@ -66,10 +73,11 @@
 	SEG_TEXT
 
 ALIGNTEXT4
-GLOBL GLNAME( gl_identify_x86_cpu_features )
-GLNAME( gl_identify_x86_cpu_features ):
+GLOBL GLNAME( _mesa_identify_x86_cpu_features )
+GLNAME( _mesa_identify_x86_cpu_features ):
 
 	PUSH_L	( EBX )
+	PUSH_L	( ESI )
 
 	/* Test for the CPUID command.  If the ID Flag bit in EFLAGS
 	 * (bit 21) is writable, the CPUID command is present.
@@ -86,7 +94,7 @@
 	/* Verify the ID Flag bit has been written.
 	 */
 	CMP_L	( ECX, EAX )
-	JZ	( LLBL ( cpuid_done ) )
+	JZ	( LLBL (cpuid_done) )
 
 	/* Get the CPU vendor info.
 	 */
@@ -97,11 +105,11 @@
 	 * "GenuineIntel" string in EBX, ECX and EDX.
 	 */
 	CMP_L	( CONST(GENU), EBX )
-	JNE	( LLBL( cpuid_amd ) )
+	JNE	( LLBL(cpuid_amd) )
 	CMP_L	( CONST(INEI), EDX )
-	JNE	( LLBL( cpuid_amd ) )
+	JNE	( LLBL(cpuid_amd) )
 	CMP_L	( CONST(NTEL), ECX )
-	JNE	( LLBL( cpuid_amd ) )
+	JNE	( LLBL(cpuid_amd) )
 
 	/* We have an Intel processor, so we can get the feature
 	 * information with an CPUID input value of 1.
@@ -109,40 +117,58 @@
 	MOV_L	( CONST(0x1), EAX )
 	CPUID
 	MOV_L	( EDX, EAX )
-	JMP	( LLBL( cpuid_done ) )
+
+	/* Mask out highest bit, which is used by AMD for 3dnow.
+	 * Newer Intel have this bit set, but do not support 3dnow.
+	 */
+	AND_L	( CONST(0X7FFFFFFF), EAX)
+	JMP	( LLBL(cpuid_done) )
 
-LLBL( cpuid_amd ):
+LLBL(cpuid_amd):
 
 	/* Test for AMD processors.  We must look for the
 	 * "AuthenticAMD" string in EBX, ECX and EDX.
 	 */
 	CMP_L	( CONST(AUTH), EBX )
-	JNE	( LLBL( cpuid_other ) )
+	JNE	( LLBL(cpuid_other) )
 	CMP_L	( CONST(ENTI), EDX )
-	JNE	( LLBL( cpuid_other ) )
+	JNE	( LLBL(cpuid_other) )
 	CMP_L	( CONST(CAMD), ECX )
-	JNE	( LLBL( cpuid_other ) )
+	JNE	( LLBL(cpuid_other) )
 
 	/* We have an AMD processor, so we can get the feature
 	 * information after we verify that the extended functions are
 	 * supported.
 	 */
+	/* The features we need are almost all in the extended set.  The
+	 * exception is SSE enable, which is in the standard set (0x1).
+	 */
+	MOV_L	( CONST(0x1), EAX )
+	CPUID
+	TEST_L	( EAX, EAX )
+	JZ	( LLBL (cpuid_failed) )
+	MOV_L	( EDX, ESI )
+
 	MOV_L	( CONST(0x80000000), EAX )
 	CPUID
 	TEST_L	( EAX, EAX )
-	JZ	( LLBL ( cpuid_failed ) )
+	JZ	( LLBL (cpuid_failed) )
 
 	MOV_L	( CONST(0x80000001), EAX )
 	CPUID
 	MOV_L	( EDX, EAX )
-	JMP	( LLBL ( cpuid_done ) )
+	
+	AND_L	( CONST(0x02000000), ESI )	/* OR in the SSE bit */
+	OR_L	( ESI, EAX )
+	
+	JMP	( LLBL (cpuid_done) )
 
-LLBL( cpuid_other ):
+LLBL(cpuid_other):
 
 	/* Test for other processors here when required.
 	 */
 
-LLBL( cpuid_failed ):
+LLBL(cpuid_failed):
 
 	/* If we can't determine the feature information, we must
 	 * return zero to indicate that no platform-specific
@@ -150,21 +176,22 @@
 	 */
 	MOV_L	( CONST(0), EAX )
 
-LLBL ( cpuid_done ):
+LLBL (cpuid_done):
 
+	POP_L	( ESI )
 	POP_L	( EBX )
 	RET
 
 
-#ifdef USE_KATMAI_ASM
+#ifdef USE_SSE_ASM
 /* Execute an SSE instruction to see if the operating system correctly
  * supports SSE.  A signal handler for SIGILL should have been set
  * before calling this function, otherwise this could kill the client
  * application.
  */
 ALIGNTEXT4
-GLOBL GLNAME( gl_test_os_katmai_support )
-GLNAME( gl_test_os_katmai_support ):
+GLOBL GLNAME( _mesa_test_os_sse_support )
+GLNAME( _mesa_test_os_sse_support ):
 
 	XORPS	( XMM0, XMM0 )
 
@@ -177,8 +204,8 @@
  * otherwise this could kill the client application.
  */
 ALIGNTEXT4
-GLOBL GLNAME( gl_test_os_katmai_exception_support )
-GLNAME( gl_test_os_katmai_exception_support ):
+GLOBL GLNAME( _mesa_test_os_sse_exception_support )
+GLNAME( _mesa_test_os_sse_exception_support ):
 
 	PUSH_L	( EBP )
 	MOV_L	( ESP, EBP )
@@ -195,7 +222,7 @@
 	LDMXCSR	( REGOFF( -8, EBP ) )
 
 	XORPS	( XMM0, XMM0 )
-	MOVUPS	( GLNAME( katmai_test_dummy ), XMM1 )
+	MOVUPS	( CONTENT( GLNAME( sse_test_dummy ) ), XMM1 )
 
 	DIVPS	( XMM0, XMM1 )
 
Index: xc/extras/Mesa/src/X86/common_x86_asm.h
diff -u xc/extras/Mesa/src/X86/common_x86_asm.h:1.3 xc/extras/Mesa/src/X86/common_x86_asm.h:1.5
--- xc/extras/Mesa/src/X86/common_x86_asm.h:1.3	Thu Nov 30 10:39:21 2000
+++ xc/extras/Mesa/src/X86/common_x86_asm.h	Mon Nov 25 20:04:20 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -29,7 +29,7 @@
  *
  * Written by Holger Waechtler <holger@akaflieg.extern.tu-berlin.de>
  * Changed by Andre Werthmann <wertmann@cs.uni-potsdam.de> for using the
- * new Katmai functions
+ * new SSE functions
  *
  * Reimplemented by Gareth Hughes <gareth@valinux.com> in a more
  * future-proof manner, based on code in the Linux kernel.
@@ -38,6 +38,8 @@
 #ifndef __COMMON_X86_ASM_H__
 #define __COMMON_X86_ASM_H__
 
+/* Do not reference mtypes.h from this file.
+ */
 #include "common_x86_features.h"
 
 #ifdef HAVE_CONFIG_H
@@ -49,15 +51,14 @@
 #ifdef USE_3DNOW_ASM
 #include "3dnow.h"
 #endif
-#ifdef USE_KATMAI_ASM
-#include "katmai.h"
+#ifdef USE_SSE_ASM
+#include "sse.h"
 #endif
 #endif
 
-extern int gl_x86_cpu_features;
+extern int _mesa_x86_cpu_features;
 
-extern void gl_init_all_x86_transform_asm( void );
-extern void gl_init_all_x86_shade_asm( void );
-extern void gl_init_all_x86_vertex_asm( void );
+extern void _mesa_init_all_x86_transform_asm( void );
+extern void _mesa_init_all_x86_vertex_asm( void );
 
 #endif
Index: xc/extras/Mesa/src/X86/common_x86_features.h
diff -u xc/extras/Mesa/src/X86/common_x86_features.h:1.2 xc/extras/Mesa/src/X86/common_x86_features.h:1.3
--- xc/extras/Mesa/src/X86/common_x86_features.h:1.2	Mon Nov 13 18:31:11 2000
+++ xc/extras/Mesa/src/X86/common_x86_features.h	Fri Feb 22 14:31:34 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -25,7 +25,7 @@
 
 /*
  * x86 CPUID feature information.  The raw data is returned by
- * gl_identify_x86_cpu_features() and interpreted with the cpu_has_*
+ * _mesa_identify_x86_cpu_features() and interpreted with the cpu_has_*
  * helper macros.
  *
  * Gareth Hughes <gareth@valinux.com>
@@ -62,15 +62,18 @@
 #define X86_FEATURE_MMX		0x00800000
 #define X86_FEATURE_FXSR	0x01000000
 #define X86_FEATURE_XMM		0x02000000
-#define X86_FEATURE_26		0x04000000
+#define X86_FEATURE_XMM2	0x04000000
 #define X86_FEATURE_27		0x08000000
 #define X86_FEATURE_28		0x10000000
 #define X86_FEATURE_29		0x20000000
 #define X86_FEATURE_3DNOWEXT	0x40000000
 #define X86_FEATURE_3DNOW	0x80000000
 
-#define cpu_has_mmx		(gl_x86_cpu_features & X86_FEATURE_MMX)
-#define cpu_has_xmm		(gl_x86_cpu_features & X86_FEATURE_XMM)
-#define cpu_has_3dnow		(gl_x86_cpu_features & X86_FEATURE_3DNOW)
+#define cpu_has_mmx		(_mesa_x86_cpu_features & X86_FEATURE_MMX)
+#define cpu_has_mmxext		(_mesa_x86_cpu_features & X86_FEATURE_MMXEXT)
+#define cpu_has_xmm		(_mesa_x86_cpu_features & X86_FEATURE_XMM)
+#define cpu_has_xmm2		(_mesa_x86_cpu_features & X86_FEATURE_XMM2)
+#define cpu_has_3dnow		(_mesa_x86_cpu_features & X86_FEATURE_3DNOW)
+#define cpu_has_3dnowext	(_mesa_x86_cpu_features & X86_FEATURE_3DNOWEXT)
 
 #endif
Index: xc/extras/Mesa/src/X86/common_x86_macros.h
diff -u /dev/null xc/extras/Mesa/src/X86/common_x86_macros.h:1.2
--- /dev/null	Thu Feb 27 12:15:55 2003
+++ xc/extras/Mesa/src/X86/common_x86_macros.h	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,106 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __COMMON_X86_MACROS_H__
+#define __COMMON_X86_MACROS_H__
+
+
+/* =============================================================
+ * Transformation function declarations:
+ */
+
+#define XFORM_ARGS	GLvector4f *to_vec,				\
+			const GLfloat m[16],				\
+			const GLvector4f *from_vec
+
+#define DECLARE_XFORM_GROUP( pfx, sz ) \
+extern void _ASMAPI _mesa_##pfx##_transform_points##sz##_general( XFORM_ARGS );		\
+extern void _ASMAPI _mesa_##pfx##_transform_points##sz##_identity( XFORM_ARGS );	\
+extern void _ASMAPI _mesa_##pfx##_transform_points##sz##_3d_no_rot( XFORM_ARGS );	\
+extern void _ASMAPI _mesa_##pfx##_transform_points##sz##_perspective( XFORM_ARGS );	\
+extern void _ASMAPI _mesa_##pfx##_transform_points##sz##_2d( XFORM_ARGS );		\
+extern void _ASMAPI _mesa_##pfx##_transform_points##sz##_2d_no_rot( XFORM_ARGS );	\
+extern void _ASMAPI _mesa_##pfx##_transform_points##sz##_3d( XFORM_ARGS );
+
+#define ASSIGN_XFORM_GROUP( pfx, sz )					\
+   _mesa_transform_tab[sz][MATRIX_GENERAL] =				\
+      _mesa_##pfx##_transform_points##sz##_general;			\
+   _mesa_transform_tab[sz][MATRIX_IDENTITY] =				\
+      _mesa_##pfx##_transform_points##sz##_identity;			\
+   _mesa_transform_tab[sz][MATRIX_3D_NO_ROT] =				\
+      _mesa_##pfx##_transform_points##sz##_3d_no_rot;			\
+   _mesa_transform_tab[sz][MATRIX_PERSPECTIVE] =			\
+      _mesa_##pfx##_transform_points##sz##_perspective;			\
+   _mesa_transform_tab[sz][MATRIX_2D] =					\
+      _mesa_##pfx##_transform_points##sz##_2d;				\
+   _mesa_transform_tab[sz][MATRIX_2D_NO_ROT] =				\
+      _mesa_##pfx##_transform_points##sz##_2d_no_rot;			\
+   _mesa_transform_tab[sz][MATRIX_3D] =					\
+      _mesa_##pfx##_transform_points##sz##_3d;
+
+
+/* =============================================================
+ * Normal transformation function declarations:
+ */
+
+#define NORM_ARGS	const GLmatrix *mat,				\
+			GLfloat scale,					\
+			const GLvector3f *in,				\
+			const GLfloat *lengths,				\
+			GLvector3f *dest
+
+#define DECLARE_NORM_GROUP( pfx ) \
+extern void _ASMAPI _mesa_##pfx##_rescale_normals( NORM_ARGS );				\
+extern void _ASMAPI _mesa_##pfx##_normalize_normals( NORM_ARGS );			\
+extern void _ASMAPI _mesa_##pfx##_transform_normals( NORM_ARGS );			\
+extern void _ASMAPI _mesa_##pfx##_transform_normals_no_rot( NORM_ARGS );		\
+extern void _ASMAPI _mesa_##pfx##_transform_rescale_normals( NORM_ARGS );		\
+extern void _ASMAPI _mesa_##pfx##_transform_rescale_normals_no_rot( NORM_ARGS );	\
+extern void _ASMAPI _mesa_##pfx##_transform_normalize_normals( NORM_ARGS );		\
+extern void _ASMAPI _mesa_##pfx##_transform_normalize_normals_no_rot( NORM_ARGS );
+
+#define ASSIGN_NORM_GROUP( pfx )					\
+   _mesa_normal_tab[NORM_RESCALE] =					\
+      _mesa_##pfx##_rescale_normals;					\
+   _mesa_normal_tab[NORM_NORMALIZE] =					\
+      _mesa_##pfx##_normalize_normals;					\
+   _mesa_normal_tab[NORM_TRANSFORM] =					\
+      _mesa_##pfx##_transform_normals;					\
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT] =				\
+      _mesa_##pfx##_transform_normals_no_rot;				\
+   _mesa_normal_tab[NORM_TRANSFORM | NORM_RESCALE] =			\
+      _mesa_##pfx##_transform_rescale_normals;				\
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE] =		\
+      _mesa_##pfx##_transform_rescale_normals_no_rot;			\
+   _mesa_normal_tab[NORM_TRANSFORM | NORM_NORMALIZE] =			\
+      _mesa_##pfx##_transform_normalize_normals;			\
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE] =		\
+      _mesa_##pfx##_transform_normalize_normals_no_rot;
+
+
+#endif
Index: xc/extras/Mesa/src/X86/gen_matypes.c
diff -u /dev/null xc/extras/Mesa/src/X86/gen_matypes.c:1.2
--- /dev/null	Thu Feb 27 12:15:55 2003
+++ xc/extras/Mesa/src/X86/gen_matypes.c	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,283 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+/*
+ * This generates an asm version of mtypes.h (called matypes.h), so that
+ * Mesa's x86 assembly code can access the internal structures easily.
+ * This will be particularly useful when developing new x86 asm code for
+ * Mesa, including lighting, clipping, texture image conversion etc.
+ */
+
+#ifdef PC_HEADER
+#include "all.h"
+#else
+#include "glheader.h"
+#include "mtypes.h"
+#include "tnl/t_context.h"
+#endif
+
+#undef offsetof
+#define offsetof( type, member ) ((size_t) &((type *)0)->member)
+
+
+#define OFFSET_HEADER( x )						\
+do {									\
+   printf( "\n" );							\
+   printf( "\n" );							\
+   printf( "/* ====================================================="	\
+	   "========\n" );						\
+   printf( " * Offsets for %s\n", x );					\
+   printf( " */\n" );							\
+   printf( "\n" );							\
+} while (0)
+
+#define DEFINE_HEADER( x )						\
+do {									\
+   printf( "\n" );							\
+   printf( "/*\n" );							\
+   printf( " * Flags for %s\n", x );					\
+   printf( " */\n" );							\
+   printf( "\n" );							\
+} while (0)
+
+#define OFFSET( s, t, m )						\
+   printf( "#define %s\t%d\n", s, offsetof( t, m ) );
+
+#define SIZEOF( s, t )							\
+   printf( "#define %s\t%d\n", s, sizeof(t) );
+
+#define DEFINE( s, d )							\
+   printf( "#define %s\t0x%x\n", s, d );
+
+
+
+int main( int argc, char **argv )
+{
+   printf( "/*\n" );
+   printf( " * This file is automatically generated from the Mesa internal type\n" );
+   printf( " * definitions.  Do not edit directly.\n" );
+   printf( " */\n" );
+   printf( "\n" );
+   printf( "#ifndef __ASM_TYPES_H__\n" );
+   printf( "#define __ASM_TYPES_H__\n" );
+   printf( "\n" );
+   printf( "#include \"assyntax.h\"\n" );
+
+
+   /* GLcontext offsets:
+    */
+   OFFSET_HEADER( "GLcontext" );
+
+   OFFSET( "CTX_DRIVER_CTX              ", GLcontext, DriverCtx );
+   printf( "\n" );
+   OFFSET( "CTX_LIGHT_ENABLED           ", GLcontext, Light.Enabled );
+   OFFSET( "CTX_LIGHT_SHADE_MODEL       ", GLcontext, Light.ShadeModel );
+   OFFSET( "CTX_LIGHT_COLOR_MAT_FACE    ", GLcontext, Light.ColorMaterialFace );
+   OFFSET( "CTX_LIGHT_COLOR_MAT_MODE    ", GLcontext, Light.ColorMaterialMode );
+   OFFSET( "CTX_LIGHT_COLOR_MAT_MASK    ", GLcontext, Light.ColorMaterialBitmask );
+   OFFSET( "CTX_LIGHT_COLOR_MAT_ENABLED ", GLcontext, Light.ColorMaterialEnabled );
+   OFFSET( "CTX_LIGHT_ENABLED_LIST      ", GLcontext, Light.EnabledList );
+   OFFSET( "CTX_LIGHT_NEED_VERTS        ", GLcontext, Light._NeedVertices );
+   OFFSET( "CTX_LIGHT_FLAGS             ", GLcontext, Light._Flags );
+   OFFSET( "CTX_LIGHT_BASE_COLOR        ", GLcontext, Light._BaseColor );
+
+
+   /* struct vertex_buffer offsets:
+    */
+   OFFSET_HEADER( "struct vertex_buffer" );
+
+   OFFSET( "VB_SIZE                ", struct vertex_buffer, Size );
+   OFFSET( "VB_COUNT               ", struct vertex_buffer, Count );
+   printf( "\n" );
+   OFFSET( "VB_FIRST_CLIPPED       ", struct vertex_buffer, FirstClipped );
+   OFFSET( "VB_FIRST_PRIMITIVE     ", struct vertex_buffer, FirstPrimitive );
+   printf( "\n" );
+   OFFSET( "VB_ELTS                ", struct vertex_buffer, Elts );
+   OFFSET( "VB_OBJ_PTR             ", struct vertex_buffer, ObjPtr );
+   OFFSET( "VB_EYE_PTR             ", struct vertex_buffer, EyePtr );
+   OFFSET( "VB_CLIP_PTR            ", struct vertex_buffer, ClipPtr );
+   OFFSET( "VB_PROJ_CLIP_PTR       ", struct vertex_buffer, ProjectedClipPtr );
+   OFFSET( "VB_CLIP_OR_MASK        ", struct vertex_buffer, ClipOrMask );
+   OFFSET( "VB_CLIP_MASK           ", struct vertex_buffer, ClipMask );
+   OFFSET( "VB_NORMAL_PTR          ", struct vertex_buffer, NormalPtr );
+   OFFSET( "VB_EDGE_FLAG           ", struct vertex_buffer, EdgeFlag );
+   OFFSET( "VB_TEX0_COORD_PTR      ", struct vertex_buffer, TexCoordPtr[0] );
+   OFFSET( "VB_TEX1_COORD_PTR      ", struct vertex_buffer, TexCoordPtr[1] );
+   OFFSET( "VB_TEX2_COORD_PTR      ", struct vertex_buffer, TexCoordPtr[2] );
+   OFFSET( "VB_TEX3_COORD_PTR      ", struct vertex_buffer, TexCoordPtr[3] );
+   OFFSET( "VB_INDEX_PTR           ", struct vertex_buffer, IndexPtr );
+   OFFSET( "VB_COLOR_PTR           ", struct vertex_buffer, ColorPtr );
+   OFFSET( "VB_SECONDARY_COLOR_PTR ", struct vertex_buffer, SecondaryColorPtr );
+   OFFSET( "VB_FOG_COORD_PTR       ", struct vertex_buffer, FogCoordPtr );
+   OFFSET( "VB_POINT_SIZE_PTR      ", struct vertex_buffer, PointSizePtr );
+   OFFSET( "VB_MATERIAL            ", struct vertex_buffer, Material );
+   OFFSET( "VB_MATERIAL_MASK       ", struct vertex_buffer, MaterialMask );
+   OFFSET( "VB_FLAG                ", struct vertex_buffer, Flag );
+   OFFSET( "VB_PRIMITIVE           ", struct vertex_buffer, Primitive );
+   OFFSET( "VB_PRIMITIVE_LENGTH    ", struct vertex_buffer, PrimitiveLength );
+   printf( "\n" );
+   OFFSET( "VB_IMPORTABLE_DATA     ", struct vertex_buffer, importable_data );
+   printf( "\n" );
+   OFFSET( "VB_LAST_CLIPPED        ", struct vertex_buffer, LastClipped );
+
+   DEFINE_HEADER( "struct vertex_buffer" );
+
+   DEFINE( "VERT_OBJ               ", VERT_OBJ );
+   DEFINE( "VERT_RGBA              ", VERT_RGBA );
+   DEFINE( "VERT_NORM              ", VERT_NORM );
+   DEFINE( "VERT_INDEX             ", VERT_INDEX );
+   DEFINE( "VERT_EDGE              ", VERT_EDGE );
+   DEFINE( "VERT_SPEC_RGB          ", VERT_SPEC_RGB );
+   DEFINE( "VERT_FOG_COORD         ", VERT_FOG_COORD );
+   DEFINE( "VERT_TEX0              ", VERT_TEX0 );
+   DEFINE( "VERT_TEX1              ", VERT_TEX1 );
+   DEFINE( "VERT_TEX2              ", VERT_TEX2 );
+   DEFINE( "VERT_TEX3              ", VERT_TEX3 );
+   DEFINE( "VERT_EVAL_C1           ", VERT_EVAL_C1 );
+   DEFINE( "VERT_EVAL_C2           ", VERT_EVAL_C2 );
+   DEFINE( "VERT_EVAL_P1           ", VERT_EVAL_P1 );
+   DEFINE( "VERT_EVAL_P2           ", VERT_EVAL_P2 );
+   DEFINE( "VERT_OBJ_3             ", VERT_OBJ_3 );
+   DEFINE( "VERT_OBJ_4             ", VERT_OBJ_4 );
+   DEFINE( "VERT_MATERIAL          ", VERT_MATERIAL );
+   DEFINE( "VERT_ELT               ", VERT_ELT );
+   DEFINE( "VERT_BEGIN             ", VERT_BEGIN );
+   DEFINE( "VERT_END               ", VERT_END );
+   DEFINE( "VERT_END_VB            ", VERT_END_VB );
+   DEFINE( "VERT_POINT_SIZE        ", VERT_POINT_SIZE );
+   DEFINE( "VERT_EYE               ", VERT_EYE );
+   DEFINE( "VERT_CLIP              ", VERT_CLIP );
+   printf( "\n" );
+   DEFINE( "VERT_OBJ_23            ", VERT_OBJ_3 );
+   DEFINE( "VERT_OBJ_234           ", VERT_OBJ_4 );
+
+
+   /* GLvector3f offsets:
+    */
+   OFFSET_HEADER( "GLvector3f" );
+
+   OFFSET( "V3F_DATA          ", GLvector3f, data );
+   OFFSET( "V3F_START         ", GLvector3f, start );
+   OFFSET( "V3F_COUNT         ", GLvector3f, count );
+   OFFSET( "V3F_STRIDE        ", GLvector3f, stride );
+   OFFSET( "V3F_FLAGS         ", GLvector3f, flags );
+
+
+   /* GLvector4f offsets:
+    */
+   OFFSET_HEADER( "GLvector4f" );
+
+   OFFSET( "V4F_DATA          ", GLvector4f, data );
+   OFFSET( "V4F_START         ", GLvector4f, start );
+   OFFSET( "V4F_COUNT         ", GLvector4f, count );
+   OFFSET( "V4F_STRIDE        ", GLvector4f, stride );
+   OFFSET( "V4F_SIZE          ", GLvector4f, size );
+   OFFSET( "V4F_FLAGS         ", GLvector4f, flags );
+
+   DEFINE_HEADER( "GLvector4f" );
+
+   DEFINE( "VEC_MALLOC        ", VEC_MALLOC );
+   DEFINE( "VEC_NOT_WRITEABLE ", VEC_NOT_WRITEABLE );
+   DEFINE( "VEC_BAD_STRIDE    ", VEC_BAD_STRIDE );
+   printf( "\n" );
+   DEFINE( "VEC_SIZE_1        ", VEC_SIZE_1 );
+   DEFINE( "VEC_SIZE_2        ", VEC_SIZE_2 );
+   DEFINE( "VEC_SIZE_3        ", VEC_SIZE_3 );
+   DEFINE( "VEC_SIZE_4        ", VEC_SIZE_4 );
+
+
+   /* GLmatrix offsets:
+    */
+   OFFSET_HEADER( "GLmatrix" );
+
+   OFFSET( "MATRIX_DATA   ", GLmatrix, m );
+   OFFSET( "MATRIX_INV    ", GLmatrix, inv );
+   OFFSET( "MATRIX_FLAGS  ", GLmatrix, flags );
+   OFFSET( "MATRIX_TYPE   ", GLmatrix, type );
+
+
+   /* struct gl_light offsets:
+    */
+   OFFSET_HEADER( "struct gl_light" );
+
+   OFFSET( "LIGHT_NEXT              ", struct gl_light, next );
+   OFFSET( "LIGHT_PREV              ", struct gl_light, prev );
+   printf( "\n" );
+   OFFSET( "LIGHT_AMBIENT           ", struct gl_light, Ambient );
+   OFFSET( "LIGHT_DIFFUSE           ", struct gl_light, Diffuse );
+   OFFSET( "LIGHT_SPECULAR          ", struct gl_light, Specular );
+   OFFSET( "LIGHT_EYE_POSITION      ", struct gl_light, EyePosition );
+   OFFSET( "LIGHT_EYE_DIRECTION     ", struct gl_light, EyeDirection );
+   OFFSET( "LIGHT_SPOT_EXPONENT     ", struct gl_light, SpotExponent );
+   OFFSET( "LIGHT_SPOT_CUTOFF       ", struct gl_light, SpotCutoff );
+   OFFSET( "LIGHT_COS_CUTOFF        ", struct gl_light, _CosCutoff );
+   OFFSET( "LIGHT_CONST_ATTEN       ", struct gl_light, ConstantAttenuation );
+   OFFSET( "LIGHT_LINEAR_ATTEN      ", struct gl_light, LinearAttenuation );
+   OFFSET( "LIGHT_QUADRATIC_ATTEN   ", struct gl_light, QuadraticAttenuation );
+   OFFSET( "LIGHT_ENABLED           ", struct gl_light, Enabled );
+   printf( "\n" );
+   OFFSET( "LIGHT_FLAGS             ", struct gl_light, _Flags );
+   printf( "\n" );
+   OFFSET( "LIGHT_POSITION          ", struct gl_light, _Position );
+   OFFSET( "LIGHT_VP_INF_NORM       ", struct gl_light, _VP_inf_norm );
+   OFFSET( "LIGHT_H_INF_NORM        ", struct gl_light, _h_inf_norm );
+   OFFSET( "LIGHT_NORM_DIRECTION    ", struct gl_light, _NormDirection );
+   OFFSET( "LIGHT_VP_INF_SPOT_ATTEN ", struct gl_light, _VP_inf_spot_attenuation );
+   printf( "\n" );
+   OFFSET( "LIGHT_SPOT_EXP_TABLE    ", struct gl_light, _SpotExpTable );
+   OFFSET( "LIGHT_MAT_AMBIENT       ", struct gl_light, _MatAmbient );
+   OFFSET( "LIGHT_MAT_DIFFUSE       ", struct gl_light, _MatDiffuse );
+   OFFSET( "LIGHT_MAT_SPECULAR      ", struct gl_light, _MatSpecular );
+   printf( "\n" );
+   SIZEOF( "SIZEOF_GL_LIGHT         ", struct gl_light );
+
+   DEFINE_HEADER( "struct gl_light" );
+
+   DEFINE( "LIGHT_SPOT              ", LIGHT_SPOT );
+   DEFINE( "LIGHT_LOCAL_VIEWER      ", LIGHT_LOCAL_VIEWER );
+   DEFINE( "LIGHT_POSITIONAL        ", LIGHT_POSITIONAL );
+   printf( "\n" );
+   DEFINE( "LIGHT_NEED_VERTICES     ", LIGHT_NEED_VERTICES );
+
+
+   /* struct gl_lightmodel offsets:
+    */
+   OFFSET_HEADER( "struct gl_lightmodel" );
+
+   OFFSET( "LIGHT_MODEL_AMBIENT       ", struct gl_lightmodel, Ambient );
+   OFFSET( "LIGHT_MODEL_LOCAL_VIEWER  ", struct gl_lightmodel, LocalViewer );
+   OFFSET( "LIGHT_MODEL_TWO_SIDE      ", struct gl_lightmodel, TwoSide );
+   OFFSET( "LIGHT_MODEL_COLOR_CONTROL ", struct gl_lightmodel, ColorControl );
+
+
+   printf( "\n" );
+   printf( "\n" );
+   printf( "#endif /* __ASM_TYPES_H__ */\n" );
+
+   return 0;
+}
Index: xc/extras/Mesa/src/X86/glapi_x86.S
diff -u xc/extras/Mesa/src/X86/glapi_x86.S:1.5 xc/extras/Mesa/src/X86/glapi_x86.S:1.7
--- xc/extras/Mesa/src/X86/glapi_x86.S:1.5	Fri Jun 30 13:15:06 2000
+++ xc/extras/Mesa/src/X86/glapi_x86.S	Mon Sep  9 17:07:33 2002
@@ -12,7 +12,7 @@
 
 #define GL_OFFSET(x) CODEPTR(REGOFF(4 * x, EAX))
 
-#ifdef GNU_ASSEMBLER
+#if defined(GNU_ASSEMBLER) && !defined(DJGPP)
 #define GLOBL_FN(x) GLOBL x ; .type x,@function
 #else
 #define GLOBL_FN(x) GLOBL x
@@ -23,4825 +23,3999 @@
 GLOBL_FN(GL_PREFIX(NewList))
 GL_PREFIX(NewList):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_NewList))
 	JMP(GL_OFFSET(_gloffset_NewList))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EndList))
 GL_PREFIX(EndList):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EndList))
 	JMP(GL_OFFSET(_gloffset_EndList))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CallList))
 GL_PREFIX(CallList):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CallList))
 	JMP(GL_OFFSET(_gloffset_CallList))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CallLists))
 GL_PREFIX(CallLists):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CallLists))
 	JMP(GL_OFFSET(_gloffset_CallLists))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DeleteLists))
 GL_PREFIX(DeleteLists):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DeleteLists))
 	JMP(GL_OFFSET(_gloffset_DeleteLists))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GenLists))
 GL_PREFIX(GenLists):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GenLists))
 	JMP(GL_OFFSET(_gloffset_GenLists))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ListBase))
 GL_PREFIX(ListBase):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ListBase))
 	JMP(GL_OFFSET(_gloffset_ListBase))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Begin))
 GL_PREFIX(Begin):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Begin))
 	JMP(GL_OFFSET(_gloffset_Begin))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Bitmap))
 GL_PREFIX(Bitmap):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Bitmap))
 	JMP(GL_OFFSET(_gloffset_Bitmap))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3b))
 GL_PREFIX(Color3b):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3b))
 	JMP(GL_OFFSET(_gloffset_Color3b))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3bv))
 GL_PREFIX(Color3bv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3bv))
 	JMP(GL_OFFSET(_gloffset_Color3bv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3d))
 GL_PREFIX(Color3d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3d))
 	JMP(GL_OFFSET(_gloffset_Color3d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3dv))
 GL_PREFIX(Color3dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3dv))
 	JMP(GL_OFFSET(_gloffset_Color3dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3f))
 GL_PREFIX(Color3f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3f))
 	JMP(GL_OFFSET(_gloffset_Color3f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3fv))
 GL_PREFIX(Color3fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3fv))
 	JMP(GL_OFFSET(_gloffset_Color3fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3i))
 GL_PREFIX(Color3i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3i))
 	JMP(GL_OFFSET(_gloffset_Color3i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3iv))
 GL_PREFIX(Color3iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3iv))
 	JMP(GL_OFFSET(_gloffset_Color3iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3s))
 GL_PREFIX(Color3s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3s))
 	JMP(GL_OFFSET(_gloffset_Color3s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3sv))
 GL_PREFIX(Color3sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3sv))
 	JMP(GL_OFFSET(_gloffset_Color3sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3ub))
 GL_PREFIX(Color3ub):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3ub))
 	JMP(GL_OFFSET(_gloffset_Color3ub))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3ubv))
 GL_PREFIX(Color3ubv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3ubv))
 	JMP(GL_OFFSET(_gloffset_Color3ubv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3ui))
 GL_PREFIX(Color3ui):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3ui))
 	JMP(GL_OFFSET(_gloffset_Color3ui))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3uiv))
 GL_PREFIX(Color3uiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3uiv))
 	JMP(GL_OFFSET(_gloffset_Color3uiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3us))
 GL_PREFIX(Color3us):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3us))
 	JMP(GL_OFFSET(_gloffset_Color3us))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color3usv))
 GL_PREFIX(Color3usv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color3usv))
 	JMP(GL_OFFSET(_gloffset_Color3usv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4b))
 GL_PREFIX(Color4b):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4b))
 	JMP(GL_OFFSET(_gloffset_Color4b))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4bv))
 GL_PREFIX(Color4bv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4bv))
 	JMP(GL_OFFSET(_gloffset_Color4bv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4d))
 GL_PREFIX(Color4d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4d))
 	JMP(GL_OFFSET(_gloffset_Color4d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4dv))
 GL_PREFIX(Color4dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4dv))
 	JMP(GL_OFFSET(_gloffset_Color4dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4f))
 GL_PREFIX(Color4f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4f))
 	JMP(GL_OFFSET(_gloffset_Color4f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4fv))
 GL_PREFIX(Color4fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4fv))
 	JMP(GL_OFFSET(_gloffset_Color4fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4i))
 GL_PREFIX(Color4i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4i))
 	JMP(GL_OFFSET(_gloffset_Color4i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4iv))
 GL_PREFIX(Color4iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4iv))
 	JMP(GL_OFFSET(_gloffset_Color4iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4s))
 GL_PREFIX(Color4s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4s))
 	JMP(GL_OFFSET(_gloffset_Color4s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4sv))
 GL_PREFIX(Color4sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4sv))
 	JMP(GL_OFFSET(_gloffset_Color4sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4ub))
 GL_PREFIX(Color4ub):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4ub))
 	JMP(GL_OFFSET(_gloffset_Color4ub))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4ubv))
 GL_PREFIX(Color4ubv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4ubv))
 	JMP(GL_OFFSET(_gloffset_Color4ubv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4ui))
 GL_PREFIX(Color4ui):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4ui))
 	JMP(GL_OFFSET(_gloffset_Color4ui))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4uiv))
 GL_PREFIX(Color4uiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4uiv))
 	JMP(GL_OFFSET(_gloffset_Color4uiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4us))
 GL_PREFIX(Color4us):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4us))
 	JMP(GL_OFFSET(_gloffset_Color4us))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Color4usv))
 GL_PREFIX(Color4usv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Color4usv))
 	JMP(GL_OFFSET(_gloffset_Color4usv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EdgeFlag))
 GL_PREFIX(EdgeFlag):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EdgeFlag))
 	JMP(GL_OFFSET(_gloffset_EdgeFlag))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EdgeFlagv))
 GL_PREFIX(EdgeFlagv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EdgeFlagv))
 	JMP(GL_OFFSET(_gloffset_EdgeFlagv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(End))
 GL_PREFIX(End):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_End))
 	JMP(GL_OFFSET(_gloffset_End))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexd))
 GL_PREFIX(Indexd):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexd))
 	JMP(GL_OFFSET(_gloffset_Indexd))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexdv))
 GL_PREFIX(Indexdv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexdv))
 	JMP(GL_OFFSET(_gloffset_Indexdv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexf))
 GL_PREFIX(Indexf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexf))
 	JMP(GL_OFFSET(_gloffset_Indexf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexfv))
 GL_PREFIX(Indexfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexfv))
 	JMP(GL_OFFSET(_gloffset_Indexfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexi))
 GL_PREFIX(Indexi):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexi))
 	JMP(GL_OFFSET(_gloffset_Indexi))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexiv))
 GL_PREFIX(Indexiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexiv))
 	JMP(GL_OFFSET(_gloffset_Indexiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexs))
 GL_PREFIX(Indexs):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexs))
 	JMP(GL_OFFSET(_gloffset_Indexs))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexsv))
 GL_PREFIX(Indexsv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexsv))
 	JMP(GL_OFFSET(_gloffset_Indexsv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3b))
 GL_PREFIX(Normal3b):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3b))
 	JMP(GL_OFFSET(_gloffset_Normal3b))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3bv))
 GL_PREFIX(Normal3bv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3bv))
 	JMP(GL_OFFSET(_gloffset_Normal3bv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3d))
 GL_PREFIX(Normal3d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3d))
 	JMP(GL_OFFSET(_gloffset_Normal3d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3dv))
 GL_PREFIX(Normal3dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3dv))
 	JMP(GL_OFFSET(_gloffset_Normal3dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3f))
 GL_PREFIX(Normal3f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3f))
 	JMP(GL_OFFSET(_gloffset_Normal3f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3fv))
 GL_PREFIX(Normal3fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3fv))
 	JMP(GL_OFFSET(_gloffset_Normal3fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3i))
 GL_PREFIX(Normal3i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3i))
 	JMP(GL_OFFSET(_gloffset_Normal3i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3iv))
 GL_PREFIX(Normal3iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3iv))
 	JMP(GL_OFFSET(_gloffset_Normal3iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3s))
 GL_PREFIX(Normal3s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3s))
 	JMP(GL_OFFSET(_gloffset_Normal3s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Normal3sv))
 GL_PREFIX(Normal3sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Normal3sv))
 	JMP(GL_OFFSET(_gloffset_Normal3sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2d))
 GL_PREFIX(RasterPos2d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2d))
 	JMP(GL_OFFSET(_gloffset_RasterPos2d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2dv))
 GL_PREFIX(RasterPos2dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2dv))
 	JMP(GL_OFFSET(_gloffset_RasterPos2dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2f))
 GL_PREFIX(RasterPos2f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2f))
 	JMP(GL_OFFSET(_gloffset_RasterPos2f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2fv))
 GL_PREFIX(RasterPos2fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2fv))
 	JMP(GL_OFFSET(_gloffset_RasterPos2fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2i))
 GL_PREFIX(RasterPos2i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2i))
 	JMP(GL_OFFSET(_gloffset_RasterPos2i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2iv))
 GL_PREFIX(RasterPos2iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2iv))
 	JMP(GL_OFFSET(_gloffset_RasterPos2iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2s))
 GL_PREFIX(RasterPos2s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2s))
 	JMP(GL_OFFSET(_gloffset_RasterPos2s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos2sv))
 GL_PREFIX(RasterPos2sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos2sv))
 	JMP(GL_OFFSET(_gloffset_RasterPos2sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3d))
 GL_PREFIX(RasterPos3d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3d))
 	JMP(GL_OFFSET(_gloffset_RasterPos3d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3dv))
 GL_PREFIX(RasterPos3dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3dv))
 	JMP(GL_OFFSET(_gloffset_RasterPos3dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3f))
 GL_PREFIX(RasterPos3f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3f))
 	JMP(GL_OFFSET(_gloffset_RasterPos3f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3fv))
 GL_PREFIX(RasterPos3fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3fv))
 	JMP(GL_OFFSET(_gloffset_RasterPos3fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3i))
 GL_PREFIX(RasterPos3i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3i))
 	JMP(GL_OFFSET(_gloffset_RasterPos3i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3iv))
 GL_PREFIX(RasterPos3iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3iv))
 	JMP(GL_OFFSET(_gloffset_RasterPos3iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3s))
 GL_PREFIX(RasterPos3s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3s))
 	JMP(GL_OFFSET(_gloffset_RasterPos3s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos3sv))
 GL_PREFIX(RasterPos3sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos3sv))
 	JMP(GL_OFFSET(_gloffset_RasterPos3sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4d))
 GL_PREFIX(RasterPos4d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4d))
 	JMP(GL_OFFSET(_gloffset_RasterPos4d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4dv))
 GL_PREFIX(RasterPos4dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4dv))
 	JMP(GL_OFFSET(_gloffset_RasterPos4dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4f))
 GL_PREFIX(RasterPos4f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4f))
 	JMP(GL_OFFSET(_gloffset_RasterPos4f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4fv))
 GL_PREFIX(RasterPos4fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4fv))
 	JMP(GL_OFFSET(_gloffset_RasterPos4fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4i))
 GL_PREFIX(RasterPos4i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4i))
 	JMP(GL_OFFSET(_gloffset_RasterPos4i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4iv))
 GL_PREFIX(RasterPos4iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4iv))
 	JMP(GL_OFFSET(_gloffset_RasterPos4iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4s))
 GL_PREFIX(RasterPos4s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4s))
 	JMP(GL_OFFSET(_gloffset_RasterPos4s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RasterPos4sv))
 GL_PREFIX(RasterPos4sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RasterPos4sv))
 	JMP(GL_OFFSET(_gloffset_RasterPos4sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rectd))
 GL_PREFIX(Rectd):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rectd))
 	JMP(GL_OFFSET(_gloffset_Rectd))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rectdv))
 GL_PREFIX(Rectdv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rectdv))
 	JMP(GL_OFFSET(_gloffset_Rectdv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rectf))
 GL_PREFIX(Rectf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rectf))
 	JMP(GL_OFFSET(_gloffset_Rectf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rectfv))
 GL_PREFIX(Rectfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rectfv))
 	JMP(GL_OFFSET(_gloffset_Rectfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Recti))
 GL_PREFIX(Recti):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Recti))
 	JMP(GL_OFFSET(_gloffset_Recti))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rectiv))
 GL_PREFIX(Rectiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rectiv))
 	JMP(GL_OFFSET(_gloffset_Rectiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rects))
 GL_PREFIX(Rects):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rects))
 	JMP(GL_OFFSET(_gloffset_Rects))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rectsv))
 GL_PREFIX(Rectsv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rectsv))
 	JMP(GL_OFFSET(_gloffset_Rectsv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1d))
 GL_PREFIX(TexCoord1d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1d))
 	JMP(GL_OFFSET(_gloffset_TexCoord1d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1dv))
 GL_PREFIX(TexCoord1dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1dv))
 	JMP(GL_OFFSET(_gloffset_TexCoord1dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1f))
 GL_PREFIX(TexCoord1f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1f))
 	JMP(GL_OFFSET(_gloffset_TexCoord1f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1fv))
 GL_PREFIX(TexCoord1fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1fv))
 	JMP(GL_OFFSET(_gloffset_TexCoord1fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1i))
 GL_PREFIX(TexCoord1i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1i))
 	JMP(GL_OFFSET(_gloffset_TexCoord1i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1iv))
 GL_PREFIX(TexCoord1iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1iv))
 	JMP(GL_OFFSET(_gloffset_TexCoord1iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1s))
 GL_PREFIX(TexCoord1s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1s))
 	JMP(GL_OFFSET(_gloffset_TexCoord1s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord1sv))
 GL_PREFIX(TexCoord1sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord1sv))
 	JMP(GL_OFFSET(_gloffset_TexCoord1sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2d))
 GL_PREFIX(TexCoord2d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2d))
 	JMP(GL_OFFSET(_gloffset_TexCoord2d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2dv))
 GL_PREFIX(TexCoord2dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2dv))
 	JMP(GL_OFFSET(_gloffset_TexCoord2dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2f))
 GL_PREFIX(TexCoord2f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2f))
 	JMP(GL_OFFSET(_gloffset_TexCoord2f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2fv))
 GL_PREFIX(TexCoord2fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2fv))
 	JMP(GL_OFFSET(_gloffset_TexCoord2fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2i))
 GL_PREFIX(TexCoord2i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2i))
 	JMP(GL_OFFSET(_gloffset_TexCoord2i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2iv))
 GL_PREFIX(TexCoord2iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2iv))
 	JMP(GL_OFFSET(_gloffset_TexCoord2iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2s))
 GL_PREFIX(TexCoord2s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2s))
 	JMP(GL_OFFSET(_gloffset_TexCoord2s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord2sv))
 GL_PREFIX(TexCoord2sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord2sv))
 	JMP(GL_OFFSET(_gloffset_TexCoord2sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3d))
 GL_PREFIX(TexCoord3d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3d))
 	JMP(GL_OFFSET(_gloffset_TexCoord3d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3dv))
 GL_PREFIX(TexCoord3dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3dv))
 	JMP(GL_OFFSET(_gloffset_TexCoord3dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3f))
 GL_PREFIX(TexCoord3f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3f))
 	JMP(GL_OFFSET(_gloffset_TexCoord3f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3fv))
 GL_PREFIX(TexCoord3fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3fv))
 	JMP(GL_OFFSET(_gloffset_TexCoord3fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3i))
 GL_PREFIX(TexCoord3i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3i))
 	JMP(GL_OFFSET(_gloffset_TexCoord3i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3iv))
 GL_PREFIX(TexCoord3iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3iv))
 	JMP(GL_OFFSET(_gloffset_TexCoord3iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3s))
 GL_PREFIX(TexCoord3s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3s))
 	JMP(GL_OFFSET(_gloffset_TexCoord3s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord3sv))
 GL_PREFIX(TexCoord3sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord3sv))
 	JMP(GL_OFFSET(_gloffset_TexCoord3sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4d))
 GL_PREFIX(TexCoord4d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4d))
 	JMP(GL_OFFSET(_gloffset_TexCoord4d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4dv))
 GL_PREFIX(TexCoord4dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4dv))
 	JMP(GL_OFFSET(_gloffset_TexCoord4dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4f))
 GL_PREFIX(TexCoord4f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4f))
 	JMP(GL_OFFSET(_gloffset_TexCoord4f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4fv))
 GL_PREFIX(TexCoord4fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4fv))
 	JMP(GL_OFFSET(_gloffset_TexCoord4fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4i))
 GL_PREFIX(TexCoord4i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4i))
 	JMP(GL_OFFSET(_gloffset_TexCoord4i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4iv))
 GL_PREFIX(TexCoord4iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4iv))
 	JMP(GL_OFFSET(_gloffset_TexCoord4iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4s))
 GL_PREFIX(TexCoord4s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4s))
 	JMP(GL_OFFSET(_gloffset_TexCoord4s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoord4sv))
 GL_PREFIX(TexCoord4sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoord4sv))
 	JMP(GL_OFFSET(_gloffset_TexCoord4sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2d))
 GL_PREFIX(Vertex2d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2d))
 	JMP(GL_OFFSET(_gloffset_Vertex2d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2dv))
 GL_PREFIX(Vertex2dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2dv))
 	JMP(GL_OFFSET(_gloffset_Vertex2dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2f))
 GL_PREFIX(Vertex2f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2f))
 	JMP(GL_OFFSET(_gloffset_Vertex2f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2fv))
 GL_PREFIX(Vertex2fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2fv))
 	JMP(GL_OFFSET(_gloffset_Vertex2fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2i))
 GL_PREFIX(Vertex2i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2i))
 	JMP(GL_OFFSET(_gloffset_Vertex2i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2iv))
 GL_PREFIX(Vertex2iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2iv))
 	JMP(GL_OFFSET(_gloffset_Vertex2iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2s))
 GL_PREFIX(Vertex2s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2s))
 	JMP(GL_OFFSET(_gloffset_Vertex2s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex2sv))
 GL_PREFIX(Vertex2sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex2sv))
 	JMP(GL_OFFSET(_gloffset_Vertex2sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3d))
 GL_PREFIX(Vertex3d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3d))
 	JMP(GL_OFFSET(_gloffset_Vertex3d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3dv))
 GL_PREFIX(Vertex3dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3dv))
 	JMP(GL_OFFSET(_gloffset_Vertex3dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3f))
 GL_PREFIX(Vertex3f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3f))
 	JMP(GL_OFFSET(_gloffset_Vertex3f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3fv))
 GL_PREFIX(Vertex3fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3fv))
 	JMP(GL_OFFSET(_gloffset_Vertex3fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3i))
 GL_PREFIX(Vertex3i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3i))
 	JMP(GL_OFFSET(_gloffset_Vertex3i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3iv))
 GL_PREFIX(Vertex3iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3iv))
 	JMP(GL_OFFSET(_gloffset_Vertex3iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3s))
 GL_PREFIX(Vertex3s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3s))
 	JMP(GL_OFFSET(_gloffset_Vertex3s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex3sv))
 GL_PREFIX(Vertex3sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex3sv))
 	JMP(GL_OFFSET(_gloffset_Vertex3sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4d))
 GL_PREFIX(Vertex4d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4d))
 	JMP(GL_OFFSET(_gloffset_Vertex4d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4dv))
 GL_PREFIX(Vertex4dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4dv))
 	JMP(GL_OFFSET(_gloffset_Vertex4dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4f))
 GL_PREFIX(Vertex4f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4f))
 	JMP(GL_OFFSET(_gloffset_Vertex4f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4fv))
 GL_PREFIX(Vertex4fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4fv))
 	JMP(GL_OFFSET(_gloffset_Vertex4fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4i))
 GL_PREFIX(Vertex4i):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4i))
 	JMP(GL_OFFSET(_gloffset_Vertex4i))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4iv))
 GL_PREFIX(Vertex4iv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4iv))
 	JMP(GL_OFFSET(_gloffset_Vertex4iv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4s))
 GL_PREFIX(Vertex4s):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4s))
 	JMP(GL_OFFSET(_gloffset_Vertex4s))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Vertex4sv))
 GL_PREFIX(Vertex4sv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Vertex4sv))
 	JMP(GL_OFFSET(_gloffset_Vertex4sv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ClipPlane))
 GL_PREFIX(ClipPlane):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ClipPlane))
 	JMP(GL_OFFSET(_gloffset_ClipPlane))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorMaterial))
 GL_PREFIX(ColorMaterial):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorMaterial))
 	JMP(GL_OFFSET(_gloffset_ColorMaterial))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CullFace))
 GL_PREFIX(CullFace):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CullFace))
 	JMP(GL_OFFSET(_gloffset_CullFace))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Fogf))
 GL_PREFIX(Fogf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Fogf))
 	JMP(GL_OFFSET(_gloffset_Fogf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Fogfv))
 GL_PREFIX(Fogfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Fogfv))
 	JMP(GL_OFFSET(_gloffset_Fogfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Fogi))
 GL_PREFIX(Fogi):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Fogi))
 	JMP(GL_OFFSET(_gloffset_Fogi))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Fogiv))
 GL_PREFIX(Fogiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Fogiv))
 	JMP(GL_OFFSET(_gloffset_Fogiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FrontFace))
 GL_PREFIX(FrontFace):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FrontFace))
 	JMP(GL_OFFSET(_gloffset_FrontFace))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Hint))
 GL_PREFIX(Hint):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Hint))
 	JMP(GL_OFFSET(_gloffset_Hint))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Lightf))
 GL_PREFIX(Lightf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Lightf))
 	JMP(GL_OFFSET(_gloffset_Lightf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Lightfv))
 GL_PREFIX(Lightfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Lightfv))
 	JMP(GL_OFFSET(_gloffset_Lightfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Lighti))
 GL_PREFIX(Lighti):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Lighti))
 	JMP(GL_OFFSET(_gloffset_Lighti))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Lightiv))
 GL_PREFIX(Lightiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Lightiv))
 	JMP(GL_OFFSET(_gloffset_Lightiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LightModelf))
 GL_PREFIX(LightModelf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LightModelf))
 	JMP(GL_OFFSET(_gloffset_LightModelf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LightModelfv))
 GL_PREFIX(LightModelfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LightModelfv))
 	JMP(GL_OFFSET(_gloffset_LightModelfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LightModeli))
 GL_PREFIX(LightModeli):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LightModeli))
 	JMP(GL_OFFSET(_gloffset_LightModeli))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LightModeliv))
 GL_PREFIX(LightModeliv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LightModeliv))
 	JMP(GL_OFFSET(_gloffset_LightModeliv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LineStipple))
 GL_PREFIX(LineStipple):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LineStipple))
 	JMP(GL_OFFSET(_gloffset_LineStipple))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LineWidth))
 GL_PREFIX(LineWidth):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LineWidth))
 	JMP(GL_OFFSET(_gloffset_LineWidth))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Materialf))
 GL_PREFIX(Materialf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Materialf))
 	JMP(GL_OFFSET(_gloffset_Materialf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Materialfv))
 GL_PREFIX(Materialfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Materialfv))
 	JMP(GL_OFFSET(_gloffset_Materialfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Materiali))
 GL_PREFIX(Materiali):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Materiali))
 	JMP(GL_OFFSET(_gloffset_Materiali))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Materialiv))
 GL_PREFIX(Materialiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Materialiv))
 	JMP(GL_OFFSET(_gloffset_Materialiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PointSize))
 GL_PREFIX(PointSize):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PointSize))
 	JMP(GL_OFFSET(_gloffset_PointSize))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PolygonMode))
 GL_PREFIX(PolygonMode):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PolygonMode))
 	JMP(GL_OFFSET(_gloffset_PolygonMode))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PolygonStipple))
 GL_PREFIX(PolygonStipple):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PolygonStipple))
 	JMP(GL_OFFSET(_gloffset_PolygonStipple))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Scissor))
 GL_PREFIX(Scissor):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Scissor))
 	JMP(GL_OFFSET(_gloffset_Scissor))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ShadeModel))
 GL_PREFIX(ShadeModel):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ShadeModel))
 	JMP(GL_OFFSET(_gloffset_ShadeModel))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexParameterf))
 GL_PREFIX(TexParameterf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexParameterf))
 	JMP(GL_OFFSET(_gloffset_TexParameterf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexParameterfv))
 GL_PREFIX(TexParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexParameterfv))
 	JMP(GL_OFFSET(_gloffset_TexParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexParameteri))
 GL_PREFIX(TexParameteri):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexParameteri))
 	JMP(GL_OFFSET(_gloffset_TexParameteri))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexParameteriv))
 GL_PREFIX(TexParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexParameteriv))
 	JMP(GL_OFFSET(_gloffset_TexParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexImage1D))
 GL_PREFIX(TexImage1D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexImage1D))
 	JMP(GL_OFFSET(_gloffset_TexImage1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexImage2D))
 GL_PREFIX(TexImage2D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexImage2D))
 	JMP(GL_OFFSET(_gloffset_TexImage2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexEnvf))
 GL_PREFIX(TexEnvf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexEnvf))
 	JMP(GL_OFFSET(_gloffset_TexEnvf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexEnvfv))
 GL_PREFIX(TexEnvfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexEnvfv))
 	JMP(GL_OFFSET(_gloffset_TexEnvfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexEnvi))
 GL_PREFIX(TexEnvi):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexEnvi))
 	JMP(GL_OFFSET(_gloffset_TexEnvi))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexEnviv))
 GL_PREFIX(TexEnviv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexEnviv))
 	JMP(GL_OFFSET(_gloffset_TexEnviv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexGend))
 GL_PREFIX(TexGend):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexGend))
 	JMP(GL_OFFSET(_gloffset_TexGend))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexGendv))
 GL_PREFIX(TexGendv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexGendv))
 	JMP(GL_OFFSET(_gloffset_TexGendv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexGenf))
 GL_PREFIX(TexGenf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexGenf))
 	JMP(GL_OFFSET(_gloffset_TexGenf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexGenfv))
 GL_PREFIX(TexGenfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexGenfv))
 	JMP(GL_OFFSET(_gloffset_TexGenfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexGeni))
 GL_PREFIX(TexGeni):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexGeni))
 	JMP(GL_OFFSET(_gloffset_TexGeni))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexGeniv))
 GL_PREFIX(TexGeniv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexGeniv))
 	JMP(GL_OFFSET(_gloffset_TexGeniv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FeedbackBuffer))
 GL_PREFIX(FeedbackBuffer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FeedbackBuffer))
 	JMP(GL_OFFSET(_gloffset_FeedbackBuffer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SelectBuffer))
 GL_PREFIX(SelectBuffer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SelectBuffer))
 	JMP(GL_OFFSET(_gloffset_SelectBuffer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(RenderMode))
 GL_PREFIX(RenderMode):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_RenderMode))
 	JMP(GL_OFFSET(_gloffset_RenderMode))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(InitNames))
 GL_PREFIX(InitNames):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_InitNames))
 	JMP(GL_OFFSET(_gloffset_InitNames))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LoadName))
 GL_PREFIX(LoadName):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LoadName))
 	JMP(GL_OFFSET(_gloffset_LoadName))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PassThrough))
 GL_PREFIX(PassThrough):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PassThrough))
 	JMP(GL_OFFSET(_gloffset_PassThrough))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PopName))
 GL_PREFIX(PopName):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PopName))
 	JMP(GL_OFFSET(_gloffset_PopName))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PushName))
 GL_PREFIX(PushName):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PushName))
 	JMP(GL_OFFSET(_gloffset_PushName))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DrawBuffer))
 GL_PREFIX(DrawBuffer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DrawBuffer))
 	JMP(GL_OFFSET(_gloffset_DrawBuffer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Clear))
 GL_PREFIX(Clear):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Clear))
 	JMP(GL_OFFSET(_gloffset_Clear))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ClearAccum))
 GL_PREFIX(ClearAccum):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ClearAccum))
 	JMP(GL_OFFSET(_gloffset_ClearAccum))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ClearIndex))
 GL_PREFIX(ClearIndex):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ClearIndex))
 	JMP(GL_OFFSET(_gloffset_ClearIndex))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ClearColor))
 GL_PREFIX(ClearColor):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ClearColor))
 	JMP(GL_OFFSET(_gloffset_ClearColor))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ClearStencil))
 GL_PREFIX(ClearStencil):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ClearStencil))
 	JMP(GL_OFFSET(_gloffset_ClearStencil))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ClearDepth))
 GL_PREFIX(ClearDepth):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ClearDepth))
 	JMP(GL_OFFSET(_gloffset_ClearDepth))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(StencilMask))
 GL_PREFIX(StencilMask):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_StencilMask))
 	JMP(GL_OFFSET(_gloffset_StencilMask))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorMask))
 GL_PREFIX(ColorMask):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorMask))
 	JMP(GL_OFFSET(_gloffset_ColorMask))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DepthMask))
 GL_PREFIX(DepthMask):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DepthMask))
 	JMP(GL_OFFSET(_gloffset_DepthMask))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IndexMask))
 GL_PREFIX(IndexMask):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IndexMask))
 	JMP(GL_OFFSET(_gloffset_IndexMask))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Accum))
 GL_PREFIX(Accum):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Accum))
 	JMP(GL_OFFSET(_gloffset_Accum))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Disable))
 GL_PREFIX(Disable):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Disable))
 	JMP(GL_OFFSET(_gloffset_Disable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Enable))
 GL_PREFIX(Enable):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Enable))
 	JMP(GL_OFFSET(_gloffset_Enable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Finish))
 GL_PREFIX(Finish):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Finish))
 	JMP(GL_OFFSET(_gloffset_Finish))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Flush))
 GL_PREFIX(Flush):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Flush))
 	JMP(GL_OFFSET(_gloffset_Flush))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PopAttrib))
 GL_PREFIX(PopAttrib):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PopAttrib))
 	JMP(GL_OFFSET(_gloffset_PopAttrib))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PushAttrib))
 GL_PREFIX(PushAttrib):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PushAttrib))
 	JMP(GL_OFFSET(_gloffset_PushAttrib))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Map1d))
 GL_PREFIX(Map1d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Map1d))
 	JMP(GL_OFFSET(_gloffset_Map1d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Map1f))
 GL_PREFIX(Map1f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Map1f))
 	JMP(GL_OFFSET(_gloffset_Map1f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Map2d))
 GL_PREFIX(Map2d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Map2d))
 	JMP(GL_OFFSET(_gloffset_Map2d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Map2f))
 GL_PREFIX(Map2f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Map2f))
 	JMP(GL_OFFSET(_gloffset_Map2f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MapGrid1d))
 GL_PREFIX(MapGrid1d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MapGrid1d))
 	JMP(GL_OFFSET(_gloffset_MapGrid1d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MapGrid1f))
 GL_PREFIX(MapGrid1f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MapGrid1f))
 	JMP(GL_OFFSET(_gloffset_MapGrid1f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MapGrid2d))
 GL_PREFIX(MapGrid2d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MapGrid2d))
 	JMP(GL_OFFSET(_gloffset_MapGrid2d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MapGrid2f))
 GL_PREFIX(MapGrid2f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MapGrid2f))
 	JMP(GL_OFFSET(_gloffset_MapGrid2f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord1d))
 GL_PREFIX(EvalCoord1d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord1d))
 	JMP(GL_OFFSET(_gloffset_EvalCoord1d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord1dv))
 GL_PREFIX(EvalCoord1dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord1dv))
 	JMP(GL_OFFSET(_gloffset_EvalCoord1dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord1f))
 GL_PREFIX(EvalCoord1f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord1f))
 	JMP(GL_OFFSET(_gloffset_EvalCoord1f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord1fv))
 GL_PREFIX(EvalCoord1fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord1fv))
 	JMP(GL_OFFSET(_gloffset_EvalCoord1fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord2d))
 GL_PREFIX(EvalCoord2d):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord2d))
 	JMP(GL_OFFSET(_gloffset_EvalCoord2d))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord2dv))
 GL_PREFIX(EvalCoord2dv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord2dv))
 	JMP(GL_OFFSET(_gloffset_EvalCoord2dv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord2f))
 GL_PREFIX(EvalCoord2f):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord2f))
 	JMP(GL_OFFSET(_gloffset_EvalCoord2f))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalCoord2fv))
 GL_PREFIX(EvalCoord2fv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalCoord2fv))
 	JMP(GL_OFFSET(_gloffset_EvalCoord2fv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalMesh1))
 GL_PREFIX(EvalMesh1):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalMesh1))
 	JMP(GL_OFFSET(_gloffset_EvalMesh1))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalPoint1))
 GL_PREFIX(EvalPoint1):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalPoint1))
 	JMP(GL_OFFSET(_gloffset_EvalPoint1))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalMesh2))
 GL_PREFIX(EvalMesh2):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalMesh2))
 	JMP(GL_OFFSET(_gloffset_EvalMesh2))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EvalPoint2))
 GL_PREFIX(EvalPoint2):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EvalPoint2))
 	JMP(GL_OFFSET(_gloffset_EvalPoint2))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(AlphaFunc))
 GL_PREFIX(AlphaFunc):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_AlphaFunc))
 	JMP(GL_OFFSET(_gloffset_AlphaFunc))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BlendFunc))
 GL_PREFIX(BlendFunc):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BlendFunc))
 	JMP(GL_OFFSET(_gloffset_BlendFunc))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LogicOp))
 GL_PREFIX(LogicOp):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LogicOp))
 	JMP(GL_OFFSET(_gloffset_LogicOp))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(StencilFunc))
 GL_PREFIX(StencilFunc):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_StencilFunc))
 	JMP(GL_OFFSET(_gloffset_StencilFunc))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(StencilOp))
 GL_PREFIX(StencilOp):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_StencilOp))
 	JMP(GL_OFFSET(_gloffset_StencilOp))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DepthFunc))
 GL_PREFIX(DepthFunc):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DepthFunc))
 	JMP(GL_OFFSET(_gloffset_DepthFunc))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelZoom))
 GL_PREFIX(PixelZoom):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelZoom))
 	JMP(GL_OFFSET(_gloffset_PixelZoom))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelTransferf))
 GL_PREFIX(PixelTransferf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelTransferf))
 	JMP(GL_OFFSET(_gloffset_PixelTransferf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelTransferi))
 GL_PREFIX(PixelTransferi):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelTransferi))
 	JMP(GL_OFFSET(_gloffset_PixelTransferi))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelStoref))
 GL_PREFIX(PixelStoref):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelStoref))
 	JMP(GL_OFFSET(_gloffset_PixelStoref))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelStorei))
 GL_PREFIX(PixelStorei):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelStorei))
 	JMP(GL_OFFSET(_gloffset_PixelStorei))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelMapfv))
 GL_PREFIX(PixelMapfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelMapfv))
 	JMP(GL_OFFSET(_gloffset_PixelMapfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelMapuiv))
 GL_PREFIX(PixelMapuiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelMapuiv))
 	JMP(GL_OFFSET(_gloffset_PixelMapuiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelMapusv))
 GL_PREFIX(PixelMapusv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelMapusv))
 	JMP(GL_OFFSET(_gloffset_PixelMapusv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ReadBuffer))
 GL_PREFIX(ReadBuffer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ReadBuffer))
 	JMP(GL_OFFSET(_gloffset_ReadBuffer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyPixels))
 GL_PREFIX(CopyPixels):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyPixels))
 	JMP(GL_OFFSET(_gloffset_CopyPixels))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ReadPixels))
 GL_PREFIX(ReadPixels):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ReadPixels))
 	JMP(GL_OFFSET(_gloffset_ReadPixels))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DrawPixels))
 GL_PREFIX(DrawPixels):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DrawPixels))
 	JMP(GL_OFFSET(_gloffset_DrawPixels))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetBooleanv))
 GL_PREFIX(GetBooleanv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetBooleanv))
 	JMP(GL_OFFSET(_gloffset_GetBooleanv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetClipPlane))
 GL_PREFIX(GetClipPlane):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetClipPlane))
 	JMP(GL_OFFSET(_gloffset_GetClipPlane))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetDoublev))
 GL_PREFIX(GetDoublev):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetDoublev))
 	JMP(GL_OFFSET(_gloffset_GetDoublev))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetError))
 GL_PREFIX(GetError):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetError))
 	JMP(GL_OFFSET(_gloffset_GetError))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetFloatv))
 GL_PREFIX(GetFloatv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetFloatv))
 	JMP(GL_OFFSET(_gloffset_GetFloatv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetIntegerv))
 GL_PREFIX(GetIntegerv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetIntegerv))
 	JMP(GL_OFFSET(_gloffset_GetIntegerv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetLightfv))
 GL_PREFIX(GetLightfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetLightfv))
 	JMP(GL_OFFSET(_gloffset_GetLightfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetLightiv))
 GL_PREFIX(GetLightiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetLightiv))
 	JMP(GL_OFFSET(_gloffset_GetLightiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMapdv))
 GL_PREFIX(GetMapdv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMapdv))
 	JMP(GL_OFFSET(_gloffset_GetMapdv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMapfv))
 GL_PREFIX(GetMapfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMapfv))
 	JMP(GL_OFFSET(_gloffset_GetMapfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMapiv))
 GL_PREFIX(GetMapiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMapiv))
 	JMP(GL_OFFSET(_gloffset_GetMapiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMaterialfv))
 GL_PREFIX(GetMaterialfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMaterialfv))
 	JMP(GL_OFFSET(_gloffset_GetMaterialfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMaterialiv))
 GL_PREFIX(GetMaterialiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMaterialiv))
 	JMP(GL_OFFSET(_gloffset_GetMaterialiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPixelMapfv))
 GL_PREFIX(GetPixelMapfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPixelMapfv))
 	JMP(GL_OFFSET(_gloffset_GetPixelMapfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPixelMapuiv))
 GL_PREFIX(GetPixelMapuiv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPixelMapuiv))
 	JMP(GL_OFFSET(_gloffset_GetPixelMapuiv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPixelMapusv))
 GL_PREFIX(GetPixelMapusv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPixelMapusv))
 	JMP(GL_OFFSET(_gloffset_GetPixelMapusv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPolygonStipple))
 GL_PREFIX(GetPolygonStipple):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPolygonStipple))
 	JMP(GL_OFFSET(_gloffset_GetPolygonStipple))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetString))
 GL_PREFIX(GetString):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetString))
 	JMP(GL_OFFSET(_gloffset_GetString))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexEnvfv))
 GL_PREFIX(GetTexEnvfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexEnvfv))
 	JMP(GL_OFFSET(_gloffset_GetTexEnvfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexEnviv))
 GL_PREFIX(GetTexEnviv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexEnviv))
 	JMP(GL_OFFSET(_gloffset_GetTexEnviv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexGendv))
 GL_PREFIX(GetTexGendv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexGendv))
 	JMP(GL_OFFSET(_gloffset_GetTexGendv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexGenfv))
 GL_PREFIX(GetTexGenfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexGenfv))
 	JMP(GL_OFFSET(_gloffset_GetTexGenfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexGeniv))
 GL_PREFIX(GetTexGeniv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexGeniv))
 	JMP(GL_OFFSET(_gloffset_GetTexGeniv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexImage))
 GL_PREFIX(GetTexImage):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexImage))
 	JMP(GL_OFFSET(_gloffset_GetTexImage))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexParameterfv))
 GL_PREFIX(GetTexParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexParameterfv))
 	JMP(GL_OFFSET(_gloffset_GetTexParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexParameteriv))
 GL_PREFIX(GetTexParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexParameteriv))
 	JMP(GL_OFFSET(_gloffset_GetTexParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexLevelParameterfv))
 GL_PREFIX(GetTexLevelParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexLevelParameterfv))
 	JMP(GL_OFFSET(_gloffset_GetTexLevelParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexLevelParameteriv))
 GL_PREFIX(GetTexLevelParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexLevelParameteriv))
 	JMP(GL_OFFSET(_gloffset_GetTexLevelParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IsEnabled))
 GL_PREFIX(IsEnabled):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IsEnabled))
 	JMP(GL_OFFSET(_gloffset_IsEnabled))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IsList))
 GL_PREFIX(IsList):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IsList))
 	JMP(GL_OFFSET(_gloffset_IsList))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DepthRange))
 GL_PREFIX(DepthRange):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DepthRange))
 	JMP(GL_OFFSET(_gloffset_DepthRange))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Frustum))
 GL_PREFIX(Frustum):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Frustum))
 	JMP(GL_OFFSET(_gloffset_Frustum))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LoadIdentity))
 GL_PREFIX(LoadIdentity):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LoadIdentity))
 	JMP(GL_OFFSET(_gloffset_LoadIdentity))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LoadMatrixf))
 GL_PREFIX(LoadMatrixf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LoadMatrixf))
 	JMP(GL_OFFSET(_gloffset_LoadMatrixf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LoadMatrixd))
 GL_PREFIX(LoadMatrixd):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LoadMatrixd))
 	JMP(GL_OFFSET(_gloffset_LoadMatrixd))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MatrixMode))
 GL_PREFIX(MatrixMode):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MatrixMode))
 	JMP(GL_OFFSET(_gloffset_MatrixMode))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultMatrixf))
 GL_PREFIX(MultMatrixf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultMatrixf))
 	JMP(GL_OFFSET(_gloffset_MultMatrixf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultMatrixd))
 GL_PREFIX(MultMatrixd):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultMatrixd))
 	JMP(GL_OFFSET(_gloffset_MultMatrixd))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Ortho))
 GL_PREFIX(Ortho):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Ortho))
 	JMP(GL_OFFSET(_gloffset_Ortho))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PopMatrix))
 GL_PREFIX(PopMatrix):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PopMatrix))
 	JMP(GL_OFFSET(_gloffset_PopMatrix))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PushMatrix))
 GL_PREFIX(PushMatrix):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PushMatrix))
 	JMP(GL_OFFSET(_gloffset_PushMatrix))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rotated))
 GL_PREFIX(Rotated):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rotated))
 	JMP(GL_OFFSET(_gloffset_Rotated))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Rotatef))
 GL_PREFIX(Rotatef):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Rotatef))
 	JMP(GL_OFFSET(_gloffset_Rotatef))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Scaled))
 GL_PREFIX(Scaled):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Scaled))
 	JMP(GL_OFFSET(_gloffset_Scaled))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Scalef))
 GL_PREFIX(Scalef):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Scalef))
 	JMP(GL_OFFSET(_gloffset_Scalef))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Translated))
 GL_PREFIX(Translated):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Translated))
 	JMP(GL_OFFSET(_gloffset_Translated))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Translatef))
 GL_PREFIX(Translatef):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Translatef))
 	JMP(GL_OFFSET(_gloffset_Translatef))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Viewport))
 GL_PREFIX(Viewport):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Viewport))
 	JMP(GL_OFFSET(_gloffset_Viewport))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ArrayElement))
 GL_PREFIX(ArrayElement):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ArrayElement))
 	JMP(GL_OFFSET(_gloffset_ArrayElement))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorPointer))
 GL_PREFIX(ColorPointer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorPointer))
 	JMP(GL_OFFSET(_gloffset_ColorPointer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DisableClientState))
 GL_PREFIX(DisableClientState):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DisableClientState))
 	JMP(GL_OFFSET(_gloffset_DisableClientState))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DrawArrays))
 GL_PREFIX(DrawArrays):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DrawArrays))
 	JMP(GL_OFFSET(_gloffset_DrawArrays))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DrawElements))
 GL_PREFIX(DrawElements):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DrawElements))
 	JMP(GL_OFFSET(_gloffset_DrawElements))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EdgeFlagPointer))
 GL_PREFIX(EdgeFlagPointer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EdgeFlagPointer))
 	JMP(GL_OFFSET(_gloffset_EdgeFlagPointer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EnableClientState))
 GL_PREFIX(EnableClientState):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EnableClientState))
 	JMP(GL_OFFSET(_gloffset_EnableClientState))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPointerv))
 GL_PREFIX(GetPointerv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPointerv))
 	JMP(GL_OFFSET(_gloffset_GetPointerv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IndexPointer))
 GL_PREFIX(IndexPointer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IndexPointer))
 	JMP(GL_OFFSET(_gloffset_IndexPointer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(InterleavedArrays))
 GL_PREFIX(InterleavedArrays):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_InterleavedArrays))
 	JMP(GL_OFFSET(_gloffset_InterleavedArrays))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(NormalPointer))
 GL_PREFIX(NormalPointer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_NormalPointer))
 	JMP(GL_OFFSET(_gloffset_NormalPointer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoordPointer))
 GL_PREFIX(TexCoordPointer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoordPointer))
 	JMP(GL_OFFSET(_gloffset_TexCoordPointer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(VertexPointer))
 GL_PREFIX(VertexPointer):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_VertexPointer))
 	JMP(GL_OFFSET(_gloffset_VertexPointer))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PolygonOffset))
 GL_PREFIX(PolygonOffset):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PolygonOffset))
 	JMP(GL_OFFSET(_gloffset_PolygonOffset))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexImage1D))
 GL_PREFIX(CopyTexImage1D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexImage1D))
 	JMP(GL_OFFSET(_gloffset_CopyTexImage1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexImage2D))
 GL_PREFIX(CopyTexImage2D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexImage2D))
 	JMP(GL_OFFSET(_gloffset_CopyTexImage2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexSubImage1D))
 GL_PREFIX(CopyTexSubImage1D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexSubImage1D))
 	JMP(GL_OFFSET(_gloffset_CopyTexSubImage1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexSubImage2D))
 GL_PREFIX(CopyTexSubImage2D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexSubImage2D))
 	JMP(GL_OFFSET(_gloffset_CopyTexSubImage2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexSubImage1D))
 GL_PREFIX(TexSubImage1D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexSubImage1D))
 	JMP(GL_OFFSET(_gloffset_TexSubImage1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexSubImage2D))
 GL_PREFIX(TexSubImage2D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexSubImage2D))
 	JMP(GL_OFFSET(_gloffset_TexSubImage2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(AreTexturesResident))
 GL_PREFIX(AreTexturesResident):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_AreTexturesResident))
 	JMP(GL_OFFSET(_gloffset_AreTexturesResident))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BindTexture))
 GL_PREFIX(BindTexture):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BindTexture))
 	JMP(GL_OFFSET(_gloffset_BindTexture))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DeleteTextures))
 GL_PREFIX(DeleteTextures):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DeleteTextures))
 	JMP(GL_OFFSET(_gloffset_DeleteTextures))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GenTextures))
 GL_PREFIX(GenTextures):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GenTextures))
 	JMP(GL_OFFSET(_gloffset_GenTextures))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IsTexture))
 GL_PREFIX(IsTexture):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IsTexture))
 	JMP(GL_OFFSET(_gloffset_IsTexture))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PrioritizeTextures))
 GL_PREFIX(PrioritizeTextures):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PrioritizeTextures))
 	JMP(GL_OFFSET(_gloffset_PrioritizeTextures))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexub))
 GL_PREFIX(Indexub):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexub))
 	JMP(GL_OFFSET(_gloffset_Indexub))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Indexubv))
 GL_PREFIX(Indexubv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Indexubv))
 	JMP(GL_OFFSET(_gloffset_Indexubv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PopClientAttrib))
 GL_PREFIX(PopClientAttrib):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PopClientAttrib))
 	JMP(GL_OFFSET(_gloffset_PopClientAttrib))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PushClientAttrib))
 GL_PREFIX(PushClientAttrib):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PushClientAttrib))
 	JMP(GL_OFFSET(_gloffset_PushClientAttrib))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BlendColor))
 GL_PREFIX(BlendColor):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BlendColor))
 	JMP(GL_OFFSET(_gloffset_BlendColor))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BlendEquation))
 GL_PREFIX(BlendEquation):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BlendEquation))
 	JMP(GL_OFFSET(_gloffset_BlendEquation))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DrawRangeElements))
 GL_PREFIX(DrawRangeElements):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DrawRangeElements))
 	JMP(GL_OFFSET(_gloffset_DrawRangeElements))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorTable))
 GL_PREFIX(ColorTable):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorTable))
 	JMP(GL_OFFSET(_gloffset_ColorTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorTableParameterfv))
 GL_PREFIX(ColorTableParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorTableParameterfv))
 	JMP(GL_OFFSET(_gloffset_ColorTableParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorTableParameteriv))
 GL_PREFIX(ColorTableParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorTableParameteriv))
 	JMP(GL_OFFSET(_gloffset_ColorTableParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyColorTable))
 GL_PREFIX(CopyColorTable):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyColorTable))
 	JMP(GL_OFFSET(_gloffset_CopyColorTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTable))
 GL_PREFIX(GetColorTable):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTable))
 	JMP(GL_OFFSET(_gloffset_GetColorTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableParameterfv))
 GL_PREFIX(GetColorTableParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableParameterfv))
 	JMP(GL_OFFSET(_gloffset_GetColorTableParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableParameteriv))
 GL_PREFIX(GetColorTableParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableParameteriv))
 	JMP(GL_OFFSET(_gloffset_GetColorTableParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorSubTable))
 GL_PREFIX(ColorSubTable):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorSubTable))
 	JMP(GL_OFFSET(_gloffset_ColorSubTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyColorSubTable))
 GL_PREFIX(CopyColorSubTable):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyColorSubTable))
 	JMP(GL_OFFSET(_gloffset_CopyColorSubTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionFilter1D))
 GL_PREFIX(ConvolutionFilter1D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionFilter1D))
 	JMP(GL_OFFSET(_gloffset_ConvolutionFilter1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionFilter2D))
 GL_PREFIX(ConvolutionFilter2D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionFilter2D))
 	JMP(GL_OFFSET(_gloffset_ConvolutionFilter2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameterf))
 GL_PREFIX(ConvolutionParameterf):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameterf))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameterf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameterfv))
 GL_PREFIX(ConvolutionParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameterfv))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameteri))
 GL_PREFIX(ConvolutionParameteri):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameteri))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameteri))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameteriv))
 GL_PREFIX(ConvolutionParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameteriv))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyConvolutionFilter1D))
 GL_PREFIX(CopyConvolutionFilter1D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter1D))
 	JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyConvolutionFilter2D))
 GL_PREFIX(CopyConvolutionFilter2D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter2D))
 	JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetConvolutionFilter))
 GL_PREFIX(GetConvolutionFilter):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetConvolutionFilter))
 	JMP(GL_OFFSET(_gloffset_GetConvolutionFilter))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetConvolutionParameterfv))
 GL_PREFIX(GetConvolutionParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetConvolutionParameterfv))
 	JMP(GL_OFFSET(_gloffset_GetConvolutionParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetConvolutionParameteriv))
 GL_PREFIX(GetConvolutionParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetConvolutionParameteriv))
 	JMP(GL_OFFSET(_gloffset_GetConvolutionParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetSeparableFilter))
 GL_PREFIX(GetSeparableFilter):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetSeparableFilter))
 	JMP(GL_OFFSET(_gloffset_GetSeparableFilter))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SeparableFilter2D))
 GL_PREFIX(SeparableFilter2D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SeparableFilter2D))
 	JMP(GL_OFFSET(_gloffset_SeparableFilter2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetHistogram))
 GL_PREFIX(GetHistogram):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetHistogram))
 	JMP(GL_OFFSET(_gloffset_GetHistogram))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetHistogramParameterfv))
 GL_PREFIX(GetHistogramParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetHistogramParameterfv))
 	JMP(GL_OFFSET(_gloffset_GetHistogramParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetHistogramParameteriv))
 GL_PREFIX(GetHistogramParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetHistogramParameteriv))
 	JMP(GL_OFFSET(_gloffset_GetHistogramParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMinmax))
 GL_PREFIX(GetMinmax):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMinmax))
 	JMP(GL_OFFSET(_gloffset_GetMinmax))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMinmaxParameterfv))
 GL_PREFIX(GetMinmaxParameterfv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMinmaxParameterfv))
 	JMP(GL_OFFSET(_gloffset_GetMinmaxParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMinmaxParameteriv))
 GL_PREFIX(GetMinmaxParameteriv):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMinmaxParameteriv))
 	JMP(GL_OFFSET(_gloffset_GetMinmaxParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Histogram))
 GL_PREFIX(Histogram):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Histogram))
 	JMP(GL_OFFSET(_gloffset_Histogram))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(Minmax))
 GL_PREFIX(Minmax):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_Minmax))
 	JMP(GL_OFFSET(_gloffset_Minmax))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ResetHistogram))
 GL_PREFIX(ResetHistogram):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ResetHistogram))
 	JMP(GL_OFFSET(_gloffset_ResetHistogram))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ResetMinmax))
 GL_PREFIX(ResetMinmax):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ResetMinmax))
 	JMP(GL_OFFSET(_gloffset_ResetMinmax))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexImage3D))
 GL_PREFIX(TexImage3D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexImage3D))
 	JMP(GL_OFFSET(_gloffset_TexImage3D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexSubImage3D))
 GL_PREFIX(TexSubImage3D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexSubImage3D))
 	JMP(GL_OFFSET(_gloffset_TexSubImage3D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexSubImage3D))
 GL_PREFIX(CopyTexSubImage3D):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexSubImage3D))
 	JMP(GL_OFFSET(_gloffset_CopyTexSubImage3D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ActiveTextureARB))
 GL_PREFIX(ActiveTextureARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ActiveTextureARB))
 	JMP(GL_OFFSET(_gloffset_ActiveTextureARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ClientActiveTextureARB))
 GL_PREFIX(ClientActiveTextureARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ClientActiveTextureARB))
 	JMP(GL_OFFSET(_gloffset_ClientActiveTextureARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1dARB))
 GL_PREFIX(MultiTexCoord1dARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1dARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1dARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1dvARB))
 GL_PREFIX(MultiTexCoord1dvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1dvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1dvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1fARB))
 GL_PREFIX(MultiTexCoord1fARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1fARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1fARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1fvARB))
 GL_PREFIX(MultiTexCoord1fvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1fvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1fvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1iARB))
 GL_PREFIX(MultiTexCoord1iARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1iARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1iARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1ivARB))
 GL_PREFIX(MultiTexCoord1ivARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1ivARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1ivARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1sARB))
 GL_PREFIX(MultiTexCoord1sARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1sARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1sARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord1svARB))
 GL_PREFIX(MultiTexCoord1svARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord1svARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord1svARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2dARB))
 GL_PREFIX(MultiTexCoord2dARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2dARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2dARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2dvARB))
 GL_PREFIX(MultiTexCoord2dvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2dvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2dvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2fARB))
 GL_PREFIX(MultiTexCoord2fARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2fARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2fARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2fvARB))
 GL_PREFIX(MultiTexCoord2fvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2fvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2fvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2iARB))
 GL_PREFIX(MultiTexCoord2iARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2iARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2iARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2ivARB))
 GL_PREFIX(MultiTexCoord2ivARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2ivARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2ivARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2sARB))
 GL_PREFIX(MultiTexCoord2sARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2sARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2sARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord2svARB))
 GL_PREFIX(MultiTexCoord2svARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord2svARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord2svARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3dARB))
 GL_PREFIX(MultiTexCoord3dARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3dARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3dARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3dvARB))
 GL_PREFIX(MultiTexCoord3dvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3dvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3dvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3fARB))
 GL_PREFIX(MultiTexCoord3fARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3fARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3fARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3fvARB))
 GL_PREFIX(MultiTexCoord3fvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3fvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3fvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3iARB))
 GL_PREFIX(MultiTexCoord3iARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3iARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3iARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3ivARB))
 GL_PREFIX(MultiTexCoord3ivARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3ivARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3ivARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3sARB))
 GL_PREFIX(MultiTexCoord3sARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3sARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3sARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord3svARB))
 GL_PREFIX(MultiTexCoord3svARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord3svARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord3svARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4dARB))
 GL_PREFIX(MultiTexCoord4dARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4dARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4dARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4dvARB))
 GL_PREFIX(MultiTexCoord4dvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4dvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4dvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4fARB))
 GL_PREFIX(MultiTexCoord4fARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4fARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4fARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4fvARB))
 GL_PREFIX(MultiTexCoord4fvARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4fvARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4fvARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4iARB))
 GL_PREFIX(MultiTexCoord4iARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4iARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4iARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4ivARB))
 GL_PREFIX(MultiTexCoord4ivARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4ivARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4ivARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4sARB))
 GL_PREFIX(MultiTexCoord4sARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4sARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4sARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultiTexCoord4svARB))
 GL_PREFIX(MultiTexCoord4svARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultiTexCoord4svARB))
 	JMP(GL_OFFSET(_gloffset_MultiTexCoord4svARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LoadTransposeMatrixfARB))
 GL_PREFIX(LoadTransposeMatrixfARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LoadTransposeMatrixfARB))
 	JMP(GL_OFFSET(_gloffset_LoadTransposeMatrixfARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LoadTransposeMatrixdARB))
 GL_PREFIX(LoadTransposeMatrixdARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LoadTransposeMatrixdARB))
 	JMP(GL_OFFSET(_gloffset_LoadTransposeMatrixdARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultTransposeMatrixfARB))
 GL_PREFIX(MultTransposeMatrixfARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultTransposeMatrixfARB))
 	JMP(GL_OFFSET(_gloffset_MultTransposeMatrixfARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MultTransposeMatrixdARB))
 GL_PREFIX(MultTransposeMatrixdARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MultTransposeMatrixdARB))
 	JMP(GL_OFFSET(_gloffset_MultTransposeMatrixdARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SampleCoverageARB))
 GL_PREFIX(SampleCoverageARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SampleCoverageARB))
 	JMP(GL_OFFSET(_gloffset_SampleCoverageARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SamplePassARB))
 GL_PREFIX(SamplePassARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SamplePassARB))
 	JMP(GL_OFFSET(_gloffset_SamplePassARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CompressedTexImage3DARB))
 GL_PREFIX(CompressedTexImage3DARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CompressedTexImage3DARB))
 	JMP(GL_OFFSET(_gloffset_CompressedTexImage3DARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CompressedTexImage2DARB))
 GL_PREFIX(CompressedTexImage2DARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CompressedTexImage2DARB))
 	JMP(GL_OFFSET(_gloffset_CompressedTexImage2DARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CompressedTexImage1DARB))
 GL_PREFIX(CompressedTexImage1DARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CompressedTexImage1DARB))
 	JMP(GL_OFFSET(_gloffset_CompressedTexImage1DARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CompressedTexSubImage3DARB))
 GL_PREFIX(CompressedTexSubImage3DARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CompressedTexSubImage3DARB))
 	JMP(GL_OFFSET(_gloffset_CompressedTexSubImage3DARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CompressedTexSubImage2DARB))
 GL_PREFIX(CompressedTexSubImage2DARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CompressedTexSubImage2DARB))
 	JMP(GL_OFFSET(_gloffset_CompressedTexSubImage2DARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CompressedTexSubImage1DARB))
 GL_PREFIX(CompressedTexSubImage1DARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CompressedTexSubImage1DARB))
 	JMP(GL_OFFSET(_gloffset_CompressedTexSubImage1DARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetCompressedTexImageARB))
 GL_PREFIX(GetCompressedTexImageARB):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetCompressedTexImageARB))
 	JMP(GL_OFFSET(_gloffset_GetCompressedTexImageARB))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BlendColorEXT))
 GL_PREFIX(BlendColorEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BlendColorEXT))
 	JMP(GL_OFFSET(_gloffset_BlendColor))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PolygonOffsetEXT))
 GL_PREFIX(PolygonOffsetEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PolygonOffsetEXT))
 	JMP(GL_OFFSET(_gloffset_PolygonOffsetEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexImage3DEXT))
 GL_PREFIX(TexImage3DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexImage3DEXT))
 	JMP(GL_OFFSET(_gloffset_TexImage3D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexSubImage3DEXT))
 GL_PREFIX(TexSubImage3DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexSubImage3DEXT))
 	JMP(GL_OFFSET(_gloffset_TexSubImage3D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetTexFilterFuncSGIS))
 GL_PREFIX(GetTexFilterFuncSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetTexFilterFuncSGIS))
 	JMP(GL_OFFSET(_gloffset_GetTexFilterFuncSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexFilterFuncSGIS))
 GL_PREFIX(TexFilterFuncSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexFilterFuncSGIS))
 	JMP(GL_OFFSET(_gloffset_TexFilterFuncSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexSubImage1DEXT))
 GL_PREFIX(TexSubImage1DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexSubImage1DEXT))
 	JMP(GL_OFFSET(_gloffset_TexSubImage1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexSubImage2DEXT))
 GL_PREFIX(TexSubImage2DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexSubImage2DEXT))
 	JMP(GL_OFFSET(_gloffset_TexSubImage2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexImage1DEXT))
 GL_PREFIX(CopyTexImage1DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexImage1DEXT))
 	JMP(GL_OFFSET(_gloffset_CopyTexImage1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexImage2DEXT))
 GL_PREFIX(CopyTexImage2DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexImage2DEXT))
 	JMP(GL_OFFSET(_gloffset_CopyTexImage2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexSubImage1DEXT))
 GL_PREFIX(CopyTexSubImage1DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexSubImage1DEXT))
 	JMP(GL_OFFSET(_gloffset_CopyTexSubImage1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexSubImage2DEXT))
 GL_PREFIX(CopyTexSubImage2DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexSubImage2DEXT))
 	JMP(GL_OFFSET(_gloffset_CopyTexSubImage2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyTexSubImage3DEXT))
 GL_PREFIX(CopyTexSubImage3DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyTexSubImage3DEXT))
 	JMP(GL_OFFSET(_gloffset_CopyTexSubImage3D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetHistogramEXT))
 GL_PREFIX(GetHistogramEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetHistogramEXT))
 	JMP(GL_OFFSET(_gloffset_GetHistogramEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetHistogramParameterfvEXT))
 GL_PREFIX(GetHistogramParameterfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetHistogramParameterfvEXT))
 	JMP(GL_OFFSET(_gloffset_GetHistogramParameterfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetHistogramParameterivEXT))
 GL_PREFIX(GetHistogramParameterivEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetHistogramParameterivEXT))
 	JMP(GL_OFFSET(_gloffset_GetHistogramParameterivEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMinmaxEXT))
 GL_PREFIX(GetMinmaxEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMinmaxEXT))
 	JMP(GL_OFFSET(_gloffset_GetMinmaxEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMinmaxParameterfvEXT))
 GL_PREFIX(GetMinmaxParameterfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMinmaxParameterfvEXT))
 	JMP(GL_OFFSET(_gloffset_GetMinmaxParameterfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetMinmaxParameterivEXT))
 GL_PREFIX(GetMinmaxParameterivEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetMinmaxParameterivEXT))
 	JMP(GL_OFFSET(_gloffset_GetMinmaxParameterivEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(HistogramEXT))
 GL_PREFIX(HistogramEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_HistogramEXT))
 	JMP(GL_OFFSET(_gloffset_Histogram))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(MinmaxEXT))
 GL_PREFIX(MinmaxEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_MinmaxEXT))
 	JMP(GL_OFFSET(_gloffset_Minmax))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ResetHistogramEXT))
 GL_PREFIX(ResetHistogramEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ResetHistogramEXT))
 	JMP(GL_OFFSET(_gloffset_ResetHistogram))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ResetMinmaxEXT))
 GL_PREFIX(ResetMinmaxEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ResetMinmaxEXT))
 	JMP(GL_OFFSET(_gloffset_ResetMinmax))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionFilter1DEXT))
 GL_PREFIX(ConvolutionFilter1DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionFilter1DEXT))
 	JMP(GL_OFFSET(_gloffset_ConvolutionFilter1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionFilter2DEXT))
 GL_PREFIX(ConvolutionFilter2DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionFilter2DEXT))
 	JMP(GL_OFFSET(_gloffset_ConvolutionFilter2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameterfEXT))
 GL_PREFIX(ConvolutionParameterfEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameterfEXT))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameterf))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameterfvEXT))
 GL_PREFIX(ConvolutionParameterfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameterfvEXT))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameteriEXT))
 GL_PREFIX(ConvolutionParameteriEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameteriEXT))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameteri))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ConvolutionParameterivEXT))
 GL_PREFIX(ConvolutionParameterivEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ConvolutionParameterivEXT))
 	JMP(GL_OFFSET(_gloffset_ConvolutionParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyConvolutionFilter1DEXT))
 GL_PREFIX(CopyConvolutionFilter1DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter1DEXT))
 	JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter1D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyConvolutionFilter2DEXT))
 GL_PREFIX(CopyConvolutionFilter2DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyConvolutionFilter2DEXT))
 	JMP(GL_OFFSET(_gloffset_CopyConvolutionFilter2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetConvolutionFilterEXT))
 GL_PREFIX(GetConvolutionFilterEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetConvolutionFilterEXT))
 	JMP(GL_OFFSET(_gloffset_GetConvolutionFilterEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetConvolutionParameterfvEXT))
 GL_PREFIX(GetConvolutionParameterfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetConvolutionParameterfvEXT))
 	JMP(GL_OFFSET(_gloffset_GetConvolutionParameterfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetConvolutionParameterivEXT))
 GL_PREFIX(GetConvolutionParameterivEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetConvolutionParameterivEXT))
 	JMP(GL_OFFSET(_gloffset_GetConvolutionParameterivEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetSeparableFilterEXT))
 GL_PREFIX(GetSeparableFilterEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetSeparableFilterEXT))
 	JMP(GL_OFFSET(_gloffset_GetSeparableFilterEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SeparableFilter2DEXT))
 GL_PREFIX(SeparableFilter2DEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SeparableFilter2DEXT))
 	JMP(GL_OFFSET(_gloffset_SeparableFilter2D))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorTableSGI))
 GL_PREFIX(ColorTableSGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorTableSGI))
 	JMP(GL_OFFSET(_gloffset_ColorTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorTableParameterfvSGI))
 GL_PREFIX(ColorTableParameterfvSGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorTableParameterfvSGI))
 	JMP(GL_OFFSET(_gloffset_ColorTableParameterfv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorTableParameterivSGI))
 GL_PREFIX(ColorTableParameterivSGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorTableParameterivSGI))
 	JMP(GL_OFFSET(_gloffset_ColorTableParameteriv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyColorTableSGI))
 GL_PREFIX(CopyColorTableSGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyColorTableSGI))
 	JMP(GL_OFFSET(_gloffset_CopyColorTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableSGI))
 GL_PREFIX(GetColorTableSGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableSGI))
 	JMP(GL_OFFSET(_gloffset_GetColorTableSGI))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableParameterfvSGI))
 GL_PREFIX(GetColorTableParameterfvSGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableParameterfvSGI))
 	JMP(GL_OFFSET(_gloffset_GetColorTableParameterfvSGI))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableParameterivSGI))
 GL_PREFIX(GetColorTableParameterivSGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableParameterivSGI))
 	JMP(GL_OFFSET(_gloffset_GetColorTableParameterivSGI))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelTexGenSGIX))
 GL_PREFIX(PixelTexGenSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelTexGenSGIX))
 	JMP(GL_OFFSET(_gloffset_PixelTexGenSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelTexGenParameteriSGIS))
 GL_PREFIX(PixelTexGenParameteriSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelTexGenParameteriSGIS))
 	JMP(GL_OFFSET(_gloffset_PixelTexGenParameteriSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelTexGenParameterivSGIS))
 GL_PREFIX(PixelTexGenParameterivSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelTexGenParameterivSGIS))
 	JMP(GL_OFFSET(_gloffset_PixelTexGenParameterivSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelTexGenParameterfSGIS))
 GL_PREFIX(PixelTexGenParameterfSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelTexGenParameterfSGIS))
 	JMP(GL_OFFSET(_gloffset_PixelTexGenParameterfSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PixelTexGenParameterfvSGIS))
 GL_PREFIX(PixelTexGenParameterfvSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PixelTexGenParameterfvSGIS))
 	JMP(GL_OFFSET(_gloffset_PixelTexGenParameterfvSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPixelTexGenParameterivSGIS))
 GL_PREFIX(GetPixelTexGenParameterivSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPixelTexGenParameterivSGIS))
 	JMP(GL_OFFSET(_gloffset_GetPixelTexGenParameterivSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPixelTexGenParameterfvSGIS))
 GL_PREFIX(GetPixelTexGenParameterfvSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPixelTexGenParameterfvSGIS))
 	JMP(GL_OFFSET(_gloffset_GetPixelTexGenParameterfvSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexImage4DSGIS))
 GL_PREFIX(TexImage4DSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexImage4DSGIS))
 	JMP(GL_OFFSET(_gloffset_TexImage4DSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexSubImage4DSGIS))
 GL_PREFIX(TexSubImage4DSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexSubImage4DSGIS))
 	JMP(GL_OFFSET(_gloffset_TexSubImage4DSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(AreTexturesResidentEXT))
 GL_PREFIX(AreTexturesResidentEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_AreTexturesResidentEXT))
 	JMP(GL_OFFSET(_gloffset_AreTexturesResidentEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BindTextureEXT))
 GL_PREFIX(BindTextureEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BindTextureEXT))
 	JMP(GL_OFFSET(_gloffset_BindTexture))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DeleteTexturesEXT))
 GL_PREFIX(DeleteTexturesEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DeleteTexturesEXT))
 	JMP(GL_OFFSET(_gloffset_DeleteTextures))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GenTexturesEXT))
 GL_PREFIX(GenTexturesEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GenTexturesEXT))
 	JMP(GL_OFFSET(_gloffset_GenTexturesEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IsTextureEXT))
 GL_PREFIX(IsTextureEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IsTextureEXT))
 	JMP(GL_OFFSET(_gloffset_IsTextureEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PrioritizeTexturesEXT))
 GL_PREFIX(PrioritizeTexturesEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PrioritizeTexturesEXT))
 	JMP(GL_OFFSET(_gloffset_PrioritizeTextures))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DetailTexFuncSGIS))
 GL_PREFIX(DetailTexFuncSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DetailTexFuncSGIS))
 	JMP(GL_OFFSET(_gloffset_DetailTexFuncSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetDetailTexFuncSGIS))
 GL_PREFIX(GetDetailTexFuncSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetDetailTexFuncSGIS))
 	JMP(GL_OFFSET(_gloffset_GetDetailTexFuncSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SharpenTexFuncSGIS))
 GL_PREFIX(SharpenTexFuncSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SharpenTexFuncSGIS))
 	JMP(GL_OFFSET(_gloffset_SharpenTexFuncSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetSharpenTexFuncSGIS))
 GL_PREFIX(GetSharpenTexFuncSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetSharpenTexFuncSGIS))
 	JMP(GL_OFFSET(_gloffset_GetSharpenTexFuncSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SampleMaskSGIS))
 GL_PREFIX(SampleMaskSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SampleMaskSGIS))
 	JMP(GL_OFFSET(_gloffset_SampleMaskSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SamplePatternSGIS))
 GL_PREFIX(SamplePatternSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SamplePatternSGIS))
 	JMP(GL_OFFSET(_gloffset_SamplePatternSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ArrayElementEXT))
 GL_PREFIX(ArrayElementEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ArrayElementEXT))
 	JMP(GL_OFFSET(_gloffset_ArrayElement))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorPointerEXT))
 GL_PREFIX(ColorPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorPointerEXT))
 	JMP(GL_OFFSET(_gloffset_ColorPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DrawArraysEXT))
 GL_PREFIX(DrawArraysEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DrawArraysEXT))
 	JMP(GL_OFFSET(_gloffset_DrawArrays))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(EdgeFlagPointerEXT))
 GL_PREFIX(EdgeFlagPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_EdgeFlagPointerEXT))
 	JMP(GL_OFFSET(_gloffset_EdgeFlagPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetPointervEXT))
 GL_PREFIX(GetPointervEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetPointervEXT))
 	JMP(GL_OFFSET(_gloffset_GetPointerv))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IndexPointerEXT))
 GL_PREFIX(IndexPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IndexPointerEXT))
 	JMP(GL_OFFSET(_gloffset_IndexPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(NormalPointerEXT))
 GL_PREFIX(NormalPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_NormalPointerEXT))
 	JMP(GL_OFFSET(_gloffset_NormalPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TexCoordPointerEXT))
 GL_PREFIX(TexCoordPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TexCoordPointerEXT))
 	JMP(GL_OFFSET(_gloffset_TexCoordPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(VertexPointerEXT))
 GL_PREFIX(VertexPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_VertexPointerEXT))
 	JMP(GL_OFFSET(_gloffset_VertexPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BlendEquationEXT))
 GL_PREFIX(BlendEquationEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BlendEquationEXT))
 	JMP(GL_OFFSET(_gloffset_BlendEquation))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SpriteParameterfSGIX))
 GL_PREFIX(SpriteParameterfSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SpriteParameterfSGIX))
 	JMP(GL_OFFSET(_gloffset_SpriteParameterfSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SpriteParameterfvSGIX))
 GL_PREFIX(SpriteParameterfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SpriteParameterfvSGIX))
 	JMP(GL_OFFSET(_gloffset_SpriteParameterfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SpriteParameteriSGIX))
 GL_PREFIX(SpriteParameteriSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SpriteParameteriSGIX))
 	JMP(GL_OFFSET(_gloffset_SpriteParameteriSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SpriteParameterivSGIX))
 GL_PREFIX(SpriteParameterivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SpriteParameterivSGIX))
 	JMP(GL_OFFSET(_gloffset_SpriteParameterivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PointParameterfEXT))
 GL_PREFIX(PointParameterfEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PointParameterfEXT))
 	JMP(GL_OFFSET(_gloffset_PointParameterfEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PointParameterfvEXT))
 GL_PREFIX(PointParameterfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PointParameterfvEXT))
 	JMP(GL_OFFSET(_gloffset_PointParameterfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PointParameterfSGIS))
 GL_PREFIX(PointParameterfSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PointParameterfSGIS))
 	JMP(GL_OFFSET(_gloffset_PointParameterfEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PointParameterfvSGIS))
 GL_PREFIX(PointParameterfvSGIS):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PointParameterfvSGIS))
 	JMP(GL_OFFSET(_gloffset_PointParameterfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetInstrumentsSGIX))
 GL_PREFIX(GetInstrumentsSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetInstrumentsSGIX))
 	JMP(GL_OFFSET(_gloffset_GetInstrumentsSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(InstrumentsBufferSGIX))
 GL_PREFIX(InstrumentsBufferSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_InstrumentsBufferSGIX))
 	JMP(GL_OFFSET(_gloffset_InstrumentsBufferSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(PollInstrumentsSGIX))
 GL_PREFIX(PollInstrumentsSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_PollInstrumentsSGIX))
 	JMP(GL_OFFSET(_gloffset_PollInstrumentsSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ReadInstrumentsSGIX))
 GL_PREFIX(ReadInstrumentsSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ReadInstrumentsSGIX))
 	JMP(GL_OFFSET(_gloffset_ReadInstrumentsSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(StartInstrumentsSGIX))
 GL_PREFIX(StartInstrumentsSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_StartInstrumentsSGIX))
 	JMP(GL_OFFSET(_gloffset_StartInstrumentsSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(StopInstrumentsSGIX))
 GL_PREFIX(StopInstrumentsSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_StopInstrumentsSGIX))
 	JMP(GL_OFFSET(_gloffset_StopInstrumentsSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FrameZoomSGIX))
 GL_PREFIX(FrameZoomSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FrameZoomSGIX))
 	JMP(GL_OFFSET(_gloffset_FrameZoomSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TagSampleBufferSGIX))
 GL_PREFIX(TagSampleBufferSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TagSampleBufferSGIX))
 	JMP(GL_OFFSET(_gloffset_TagSampleBufferSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ReferencePlaneSGIX))
 GL_PREFIX(ReferencePlaneSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ReferencePlaneSGIX))
 	JMP(GL_OFFSET(_gloffset_ReferencePlaneSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FlushRasterSGIX))
 GL_PREFIX(FlushRasterSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FlushRasterSGIX))
 	JMP(GL_OFFSET(_gloffset_FlushRasterSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorSubTableEXT))
 GL_PREFIX(ColorSubTableEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorSubTableEXT))
 	JMP(GL_OFFSET(_gloffset_ColorSubTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CopyColorSubTableEXT))
 GL_PREFIX(CopyColorSubTableEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CopyColorSubTableEXT))
 	JMP(GL_OFFSET(_gloffset_CopyColorSubTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(HintPGI))
 GL_PREFIX(HintPGI):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_HintPGI))
 	JMP(GL_OFFSET(_gloffset_HintPGI))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ColorTableEXT))
 GL_PREFIX(ColorTableEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ColorTableEXT))
 	JMP(GL_OFFSET(_gloffset_ColorTable))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableEXT))
 GL_PREFIX(GetColorTableEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableEXT))
 	JMP(GL_OFFSET(_gloffset_GetColorTableEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableParameterivEXT))
 GL_PREFIX(GetColorTableParameterivEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableParameterivEXT))
 	JMP(GL_OFFSET(_gloffset_GetColorTableParameterivEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetColorTableParameterfvEXT))
 GL_PREFIX(GetColorTableParameterfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetColorTableParameterfvEXT))
 	JMP(GL_OFFSET(_gloffset_GetColorTableParameterfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetListParameterfvSGIX))
 GL_PREFIX(GetListParameterfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetListParameterfvSGIX))
 	JMP(GL_OFFSET(_gloffset_GetListParameterfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetListParameterivSGIX))
 GL_PREFIX(GetListParameterivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetListParameterivSGIX))
 	JMP(GL_OFFSET(_gloffset_GetListParameterivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ListParameterfSGIX))
 GL_PREFIX(ListParameterfSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ListParameterfSGIX))
 	JMP(GL_OFFSET(_gloffset_ListParameterfSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ListParameterfvSGIX))
 GL_PREFIX(ListParameterfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ListParameterfvSGIX))
 	JMP(GL_OFFSET(_gloffset_ListParameterfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ListParameteriSGIX))
 GL_PREFIX(ListParameteriSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ListParameteriSGIX))
 	JMP(GL_OFFSET(_gloffset_ListParameteriSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ListParameterivSGIX))
 GL_PREFIX(ListParameterivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ListParameterivSGIX))
 	JMP(GL_OFFSET(_gloffset_ListParameterivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IndexMaterialEXT))
 GL_PREFIX(IndexMaterialEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IndexMaterialEXT))
 	JMP(GL_OFFSET(_gloffset_IndexMaterialEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(IndexFuncEXT))
 GL_PREFIX(IndexFuncEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_IndexFuncEXT))
 	JMP(GL_OFFSET(_gloffset_IndexFuncEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LockArraysEXT))
 GL_PREFIX(LockArraysEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LockArraysEXT))
 	JMP(GL_OFFSET(_gloffset_LockArraysEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(UnlockArraysEXT))
 GL_PREFIX(UnlockArraysEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_UnlockArraysEXT))
 	JMP(GL_OFFSET(_gloffset_UnlockArraysEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CullParameterdvEXT))
 GL_PREFIX(CullParameterdvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CullParameterdvEXT))
 	JMP(GL_OFFSET(_gloffset_CullParameterdvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CullParameterfvEXT))
 GL_PREFIX(CullParameterfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CullParameterfvEXT))
 	JMP(GL_OFFSET(_gloffset_CullParameterfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentColorMaterialSGIX))
 GL_PREFIX(FragmentColorMaterialSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentColorMaterialSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentColorMaterialSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightfSGIX))
 GL_PREFIX(FragmentLightfSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightfSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightfSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightfvSGIX))
 GL_PREFIX(FragmentLightfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightfvSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightiSGIX))
 GL_PREFIX(FragmentLightiSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightiSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightiSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightivSGIX))
 GL_PREFIX(FragmentLightivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightivSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightModelfSGIX))
 GL_PREFIX(FragmentLightModelfSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightModelfSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightModelfSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightModelfvSGIX))
 GL_PREFIX(FragmentLightModelfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightModelfvSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightModelfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightModeliSGIX))
 GL_PREFIX(FragmentLightModeliSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightModeliSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightModeliSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentLightModelivSGIX))
 GL_PREFIX(FragmentLightModelivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentLightModelivSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentLightModelivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentMaterialfSGIX))
 GL_PREFIX(FragmentMaterialfSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentMaterialfSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentMaterialfSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentMaterialfvSGIX))
 GL_PREFIX(FragmentMaterialfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentMaterialfvSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentMaterialfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentMaterialiSGIX))
 GL_PREFIX(FragmentMaterialiSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentMaterialiSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentMaterialiSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FragmentMaterialivSGIX))
 GL_PREFIX(FragmentMaterialivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FragmentMaterialivSGIX))
 	JMP(GL_OFFSET(_gloffset_FragmentMaterialivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetFragmentLightfvSGIX))
 GL_PREFIX(GetFragmentLightfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetFragmentLightfvSGIX))
 	JMP(GL_OFFSET(_gloffset_GetFragmentLightfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetFragmentLightivSGIX))
 GL_PREFIX(GetFragmentLightivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetFragmentLightivSGIX))
 	JMP(GL_OFFSET(_gloffset_GetFragmentLightivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetFragmentMaterialfvSGIX))
 GL_PREFIX(GetFragmentMaterialfvSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetFragmentMaterialfvSGIX))
 	JMP(GL_OFFSET(_gloffset_GetFragmentMaterialfvSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetFragmentMaterialivSGIX))
 GL_PREFIX(GetFragmentMaterialivSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetFragmentMaterialivSGIX))
 	JMP(GL_OFFSET(_gloffset_GetFragmentMaterialivSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(LightEnviSGIX))
 GL_PREFIX(LightEnviSGIX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_LightEnviSGIX))
 	JMP(GL_OFFSET(_gloffset_LightEnviSGIX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(DrawRangeElementsEXT))
 GL_PREFIX(DrawRangeElementsEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_DrawRangeElementsEXT))
 	JMP(GL_OFFSET(_gloffset_DrawRangeElements))
 
 ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3bEXT))
+GL_PREFIX(SecondaryColor3bEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3bEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3bvEXT))
+GL_PREFIX(SecondaryColor3bvEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3bvEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3dEXT))
+GL_PREFIX(SecondaryColor3dEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3dEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3dvEXT))
+GL_PREFIX(SecondaryColor3dvEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3dvEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3fEXT))
+GL_PREFIX(SecondaryColor3fEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3fEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3fvEXT))
+GL_PREFIX(SecondaryColor3fvEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3fvEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3iEXT))
+GL_PREFIX(SecondaryColor3iEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3iEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3ivEXT))
+GL_PREFIX(SecondaryColor3ivEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3ivEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3sEXT))
+GL_PREFIX(SecondaryColor3sEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3sEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3svEXT))
+GL_PREFIX(SecondaryColor3svEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3svEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3ubEXT))
+GL_PREFIX(SecondaryColor3ubEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3ubEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3ubvEXT))
+GL_PREFIX(SecondaryColor3ubvEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3ubvEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3uiEXT))
+GL_PREFIX(SecondaryColor3uiEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3uiEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3uivEXT))
+GL_PREFIX(SecondaryColor3uivEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3uivEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3usEXT))
+GL_PREFIX(SecondaryColor3usEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3usEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColor3usvEXT))
+GL_PREFIX(SecondaryColor3usvEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColor3usvEXT))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SecondaryColorPointerEXT))
+GL_PREFIX(SecondaryColorPointerEXT):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SecondaryColorPointerEXT))
+
+ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FogCoordfEXT))
 GL_PREFIX(FogCoordfEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FogCoordfEXT))
 	JMP(GL_OFFSET(_gloffset_FogCoordfEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FogCoordfvEXT))
 GL_PREFIX(FogCoordfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FogCoordfvEXT))
 	JMP(GL_OFFSET(_gloffset_FogCoordfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FogCoorddEXT))
 GL_PREFIX(FogCoorddEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FogCoorddEXT))
 	JMP(GL_OFFSET(_gloffset_FogCoorddEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FogCoorddvEXT))
 GL_PREFIX(FogCoorddvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FogCoorddvEXT))
 	JMP(GL_OFFSET(_gloffset_FogCoorddvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FogCoordPointerEXT))
 GL_PREFIX(FogCoordPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FogCoordPointerEXT))
 	JMP(GL_OFFSET(_gloffset_FogCoordPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(BlendFuncSeparateEXT))
 GL_PREFIX(BlendFuncSeparateEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_BlendFuncSeparateEXT))
 	JMP(GL_OFFSET(_gloffset_BlendFuncSeparateEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(VertexWeightfEXT))
 GL_PREFIX(VertexWeightfEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_VertexWeightfEXT))
 	JMP(GL_OFFSET(_gloffset_VertexWeightfEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(VertexWeightfvEXT))
 GL_PREFIX(VertexWeightfvEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_VertexWeightfvEXT))
 	JMP(GL_OFFSET(_gloffset_VertexWeightfvEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(VertexWeightPointerEXT))
 GL_PREFIX(VertexWeightPointerEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_VertexWeightPointerEXT))
 	JMP(GL_OFFSET(_gloffset_VertexWeightPointerEXT))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FlushVertexArrayRangeNV))
 GL_PREFIX(FlushVertexArrayRangeNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FlushVertexArrayRangeNV))
 	JMP(GL_OFFSET(_gloffset_FlushVertexArrayRangeNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(VertexArrayRangeNV))
 GL_PREFIX(VertexArrayRangeNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_VertexArrayRangeNV))
 	JMP(GL_OFFSET(_gloffset_VertexArrayRangeNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CombinerParameterfvNV))
 GL_PREFIX(CombinerParameterfvNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CombinerParameterfvNV))
 	JMP(GL_OFFSET(_gloffset_CombinerParameterfvNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CombinerParameterfNV))
 GL_PREFIX(CombinerParameterfNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CombinerParameterfNV))
 	JMP(GL_OFFSET(_gloffset_CombinerParameterfNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CombinerParameterivNV))
 GL_PREFIX(CombinerParameterivNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CombinerParameterivNV))
 	JMP(GL_OFFSET(_gloffset_CombinerParameterivNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CombinerParameteriNV))
 GL_PREFIX(CombinerParameteriNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CombinerParameteriNV))
 	JMP(GL_OFFSET(_gloffset_CombinerParameteriNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CombinerInputNV))
 GL_PREFIX(CombinerInputNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CombinerInputNV))
 	JMP(GL_OFFSET(_gloffset_CombinerInputNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(CombinerOutputNV))
 GL_PREFIX(CombinerOutputNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_CombinerOutputNV))
 	JMP(GL_OFFSET(_gloffset_CombinerOutputNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(FinalCombinerInputNV))
 GL_PREFIX(FinalCombinerInputNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_FinalCombinerInputNV))
 	JMP(GL_OFFSET(_gloffset_FinalCombinerInputNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetCombinerInputParameterfvNV))
 GL_PREFIX(GetCombinerInputParameterfvNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetCombinerInputParameterfvNV))
 	JMP(GL_OFFSET(_gloffset_GetCombinerInputParameterfvNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetCombinerInputParameterivNV))
 GL_PREFIX(GetCombinerInputParameterivNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetCombinerInputParameterivNV))
 	JMP(GL_OFFSET(_gloffset_GetCombinerInputParameterivNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetCombinerOutputParameterfvNV))
 GL_PREFIX(GetCombinerOutputParameterfvNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetCombinerOutputParameterfvNV))
 	JMP(GL_OFFSET(_gloffset_GetCombinerOutputParameterfvNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetCombinerOutputParameterivNV))
 GL_PREFIX(GetCombinerOutputParameterivNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetCombinerOutputParameterivNV))
 	JMP(GL_OFFSET(_gloffset_GetCombinerOutputParameterivNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetFinalCombinerInputParameterfvNV))
 GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetFinalCombinerInputParameterfvNV))
 	JMP(GL_OFFSET(_gloffset_GetFinalCombinerInputParameterfvNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(GetFinalCombinerInputParameterivNV))
 GL_PREFIX(GetFinalCombinerInputParameterivNV):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_GetFinalCombinerInputParameterivNV))
 	JMP(GL_OFFSET(_gloffset_GetFinalCombinerInputParameterivNV))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(ResizeBuffersMESA))
 GL_PREFIX(ResizeBuffersMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_ResizeBuffersMESA))
 	JMP(GL_OFFSET(_gloffset_ResizeBuffersMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2dMESA))
 GL_PREFIX(WindowPos2dMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2dMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2dMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2dvMESA))
 GL_PREFIX(WindowPos2dvMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2dvMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2dvMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2fMESA))
 GL_PREFIX(WindowPos2fMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2fMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2fMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2fvMESA))
 GL_PREFIX(WindowPos2fvMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2fvMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2fvMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2iMESA))
 GL_PREFIX(WindowPos2iMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2iMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2iMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2ivMESA))
 GL_PREFIX(WindowPos2ivMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2ivMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2ivMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2sMESA))
 GL_PREFIX(WindowPos2sMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2sMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2sMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos2svMESA))
 GL_PREFIX(WindowPos2svMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos2svMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos2svMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3dMESA))
 GL_PREFIX(WindowPos3dMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3dMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3dMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3dvMESA))
 GL_PREFIX(WindowPos3dvMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3dvMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3dvMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3fMESA))
 GL_PREFIX(WindowPos3fMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3fMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3fMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3fvMESA))
 GL_PREFIX(WindowPos3fvMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3fvMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3fvMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3iMESA))
 GL_PREFIX(WindowPos3iMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3iMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3iMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3ivMESA))
 GL_PREFIX(WindowPos3ivMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3ivMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3ivMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3sMESA))
 GL_PREFIX(WindowPos3sMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3sMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3sMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos3svMESA))
 GL_PREFIX(WindowPos3svMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos3svMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos3svMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4dMESA))
 GL_PREFIX(WindowPos4dMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4dMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4dMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4dvMESA))
 GL_PREFIX(WindowPos4dvMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4dvMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4dvMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4fMESA))
 GL_PREFIX(WindowPos4fMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4fMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4fMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4fvMESA))
 GL_PREFIX(WindowPos4fvMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4fvMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4fvMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4iMESA))
 GL_PREFIX(WindowPos4iMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4iMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4iMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4ivMESA))
 GL_PREFIX(WindowPos4ivMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4ivMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4ivMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4sMESA))
 GL_PREFIX(WindowPos4sMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4sMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4sMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(WindowPos4svMESA))
 GL_PREFIX(WindowPos4svMESA):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_WindowPos4svMESA))
 	JMP(GL_OFFSET(_gloffset_WindowPos4svMESA))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(TbufferMask3DFX))
 GL_PREFIX(TbufferMask3DFX):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_TbufferMask3DFX))
 	JMP(GL_OFFSET(_gloffset_TbufferMask3DFX))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SampleMaskEXT))
 GL_PREFIX(SampleMaskEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SampleMaskEXT))
 	JMP(GL_OFFSET(_gloffset_SampleMaskSGIS))
 
 ALIGNTEXT16
 GLOBL_FN(GL_PREFIX(SamplePatternEXT))
 GL_PREFIX(SamplePatternEXT):
 	MOV_L(GLNAME(_glapi_Dispatch), EAX)
-	TEST_L(EAX, EAX)
-	JZ(GLNAME(_glapi_fallback_SamplePatternEXT))
 	JMP(GL_OFFSET(_gloffset_SamplePatternSGIS))
+
+/* XXX these were added by hand because we need a new gl.spec file */
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ActiveTexture))
+GL_PREFIX(ActiveTexture):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ActiveTextureARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(ClientActiveTexture))
+GL_PREFIX(ClientActiveTexture):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_ClientActiveTextureARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(CompressedTexImage1D))
+GL_PREFIX(CompressedTexImage1D):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_CompressedTexImage1DARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(CompressedTexImage2D))
+GL_PREFIX(CompressedTexImage2D):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_CompressedTexImage2DARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(CompressedTexImage3D))
+GL_PREFIX(CompressedTexImage3D):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_CompressedTexImage3DARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(CompressedTexSubImage1D))
+GL_PREFIX(CompressedTexSubImage1D):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_CompressedTexSubImage1DARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(CompressedTexSubImage2D))
+GL_PREFIX(CompressedTexSubImage2D):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_CompressedTexSubImage2DARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(CompressedTexSubImage3D))
+GL_PREFIX(CompressedTexSubImage3D):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_CompressedTexSubImage3DARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(GetCompressedTexImage))
+GL_PREFIX(GetCompressedTexImage):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_GetCompressedTexImageARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1d))
+GL_PREFIX(MultiTexCoord1d):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1dARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1dv))
+GL_PREFIX(MultiTexCoord1dv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1dvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1f))
+GL_PREFIX(MultiTexCoord1f):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1fARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1fv))
+GL_PREFIX(MultiTexCoord1fv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1fvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1i))
+GL_PREFIX(MultiTexCoord1i):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1iARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1iv))
+GL_PREFIX(MultiTexCoord1iv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1ivARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1s))
+GL_PREFIX(MultiTexCoord1s):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1sARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord1sv))
+GL_PREFIX(MultiTexCoord1sv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord1svARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2d))
+GL_PREFIX(MultiTexCoord2d):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2dARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2dv))
+GL_PREFIX(MultiTexCoord2dv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2dvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2f))
+GL_PREFIX(MultiTexCoord2f):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2fARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2fv))
+GL_PREFIX(MultiTexCoord2fv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2fvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2i))
+GL_PREFIX(MultiTexCoord2i):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2iARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2iv))
+GL_PREFIX(MultiTexCoord2iv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2ivARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2s))
+GL_PREFIX(MultiTexCoord2s):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2sARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord2sv))
+GL_PREFIX(MultiTexCoord2sv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord2svARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3d))
+GL_PREFIX(MultiTexCoord3d):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3dARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3dv))
+GL_PREFIX(MultiTexCoord3dv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3dvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3f))
+GL_PREFIX(MultiTexCoord3f):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3fARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3fv))
+GL_PREFIX(MultiTexCoord3fv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3fvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3i))
+GL_PREFIX(MultiTexCoord3i):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3iARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3iv))
+GL_PREFIX(MultiTexCoord3iv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3ivARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3s))
+GL_PREFIX(MultiTexCoord3s):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3sARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord3sv))
+GL_PREFIX(MultiTexCoord3sv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord3svARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4d))
+GL_PREFIX(MultiTexCoord4d):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4dARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4dv))
+GL_PREFIX(MultiTexCoord4dv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4dvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4f))
+GL_PREFIX(MultiTexCoord4f):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4fARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4fv))
+GL_PREFIX(MultiTexCoord4fv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4fvARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4i))
+GL_PREFIX(MultiTexCoord4i):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4iARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4iv))
+GL_PREFIX(MultiTexCoord4iv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4ivARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4s))
+GL_PREFIX(MultiTexCoord4s):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4sARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultiTexCoord4sv))
+GL_PREFIX(MultiTexCoord4sv):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultiTexCoord4svARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(LoadTransposeMatrixd))
+GL_PREFIX(LoadTransposeMatrixd):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_LoadTransposeMatrixdARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(LoadTransposeMatrixf))
+GL_PREFIX(LoadTransposeMatrixf):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_LoadTransposeMatrixfARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultTransposeMatrixd))
+GL_PREFIX(MultTransposeMatrixd):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultTransposeMatrixdARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(MultTransposeMatrixf))
+GL_PREFIX(MultTransposeMatrixf):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_MultTransposeMatrixfARB))
+
+ALIGNTEXT16
+GLOBL_FN(GL_PREFIX(SampleCoverage))
+GL_PREFIX(SampleCoverage):
+	MOV_L(GLNAME(_glapi_Dispatch), EAX)
+	JMP(GL_OFFSET(_gloffset_SampleCoverageARB))
 
 
 #endif  /* __WIN32__ */
Index: xc/extras/Mesa/src/X86/katmai.c
diff -u xc/extras/Mesa/src/X86/katmai.c:1.7 xc/extras/Mesa/src/X86/katmai.c:removed
--- xc/extras/Mesa/src/X86/katmai.c:1.7	Thu Nov 30 10:55:39 2000
+++ xc/extras/Mesa/src/X86/katmai.c	Thu Feb 27 12:15:55 2003
@@ -1,220 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * PentiumIII-SIMD (SSE) optimizations contributed by
- * Andre Werthmann <wertmann@cs.uni-potsdam.de>
- */
-
-#include "glheader.h"
-#include "context.h"
-#include "types.h"
-#include "vertices.h"
-#include "xform.h"
-#include "katmai.h"
-
-#ifdef DEBUG
-#include "debug_xform.h"
-#endif
-
-
-#define XFORM_ARGS	GLvector4f *to_vec,				\
-			const GLfloat m[16],				\
-			const GLvector4f *from_vec,			\
-			const GLubyte *mask,				\
-			const GLubyte flag
-
-
-#define DECLARE_XFORM_GROUP( pfx, sz, masked ) \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_general_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_identity_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_3d_no_rot_##masked( XFORM_ARGS );    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_perspective_##masked( XFORM_ARGS );  \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_2d_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_2d_no_rot_##masked( XFORM_ARGS );    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_3d_##masked( XFORM_ARGS );
-
-
-#define ASSIGN_XFORM_GROUP( pfx, cma, sz, masked )			\
-   gl_transform_tab[cma][sz][MATRIX_GENERAL] =				\
-      gl_##pfx##_transform_points##sz##_general_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_IDENTITY] =				\
-      gl_##pfx##_transform_points##sz##_identity_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_3D_NO_ROT] =			\
-      gl_##pfx##_transform_points##sz##_3d_no_rot_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_PERSPECTIVE] =			\
-      gl_##pfx##_transform_points##sz##_perspective_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_2D] =				\
-      gl_##pfx##_transform_points##sz##_2d_##masked;			\
-   gl_transform_tab[cma][sz][MATRIX_2D_NO_ROT] =			\
-      gl_##pfx##_transform_points##sz##_2d_no_rot_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_3D] =				\
-      gl_##pfx##_transform_points##sz##_3d_##masked;
-
-
-
-#define NORM_ARGS	const GLmatrix *mat,				\
-			GLfloat scale,					\
-			const GLvector3f *in,				\
-			const GLfloat *lengths,				\
-			const GLubyte mask[],				\
-			GLvector3f *dest
-
-
-#define DECLARE_NORM_GROUP( pfx, masked ) \
- extern void _ASMAPI gl_##pfx##_rescale_normals_##masked( NORM_ARGS );			    \
- extern void _ASMAPI gl_##pfx##_normalize_normals_##masked( NORM_ARGS );		    \
- extern void _ASMAPI gl_##pfx##_transform_normals_##masked( NORM_ARGS );		    \
- extern void _ASMAPI gl_##pfx##_transform_normals_no_rot_##masked( NORM_ARGS );		    \
- extern void _ASMAPI gl_##pfx##_transform_rescale_normals_##masked( NORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_rescale_normals_no_rot_##masked( NORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_normalize_normals_##masked( NORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_normalize_normals_no_rot_##masked( NORM_ARGS );
-
-
-#define ASSIGN_NORM_GROUP( pfx, cma, masked )				\
-   gl_normal_tab[NORM_RESCALE][cma] =					\
-      gl_##pfx##_rescale_normals_##masked;				\
-   gl_normal_tab[NORM_NORMALIZE][cma] =					\
-      gl_##pfx##_normalize_normals_##masked;				\
-   gl_normal_tab[NORM_TRANSFORM][cma] =					\
-      gl_##pfx##_transform_normals_##masked;				\
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT][cma] =				\
-      gl_##pfx##_transform_normals_no_rot_##masked;			\
-   gl_normal_tab[NORM_TRANSFORM | NORM_RESCALE][cma] =			\
-      gl_##pfx##_transform_rescale_normals_##masked;			\
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE][cma] =		\
-      gl_##pfx##_transform_rescale_normals_no_rot_##masked;		\
-   gl_normal_tab[NORM_TRANSFORM | NORM_NORMALIZE][cma] =		\
-      gl_##pfx##_transform_normalize_normals_##masked;			\
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE][cma] =		\
-      gl_##pfx##_transform_normalize_normals_no_rot_##masked;
-
-
-#ifdef USE_KATMAI_ASM
-DECLARE_XFORM_GROUP( katmai, 1, raw )
-DECLARE_XFORM_GROUP( katmai, 2, raw )
-DECLARE_XFORM_GROUP( katmai, 3, raw )
-
-DECLARE_XFORM_GROUP( katmai, 1, masked )
-DECLARE_XFORM_GROUP( katmai, 2, masked )
-DECLARE_XFORM_GROUP( katmai, 3, masked )
-
-#if 1
-/* Some functions are not written in SSE-assembly, because the fpu ones are faster */
-extern void gl_katmai_transform_normals_no_rot_raw(NORM_ARGS);
-extern void gl_katmai_transform_rescale_normals_raw(NORM_ARGS);
-extern void gl_katmai_transform_rescale_normals_no_rot_raw(NORM_ARGS);
-
-extern void gl_katmai_transform_points4_general_raw(XFORM_ARGS);
-extern void gl_katmai_transform_points4_general_masked(XFORM_ARGS);
-extern void gl_katmai_transform_points4_identity_masked(XFORM_ARGS);
-extern void gl_katmai_transform_points4_3d_no_rot_masked(XFORM_ARGS);
-extern void gl_katmai_transform_points4_3d_raw(XFORM_ARGS);
-extern void gl_katmai_transform_points4_3d_masked(XFORM_ARGS);
-#else
-DECLARE_NORM_GROUP( katmai, raw )
-#endif
-
-
-extern void _ASMAPI gl_v16_katmai_general_xform( GLfloat *first_vert,
-						 const GLfloat *m,
-						 const GLfloat *src,
-						 GLuint src_stride,
-						 GLuint count );
-extern void _ASMAPI gl_katmai_project_vertices( GLfloat *first,
-						GLfloat *last,
-						const GLfloat *m,
-						GLuint stride );
-
-extern void _ASMAPI gl_katmai_project_clipped_vertices( GLfloat *first,
-							GLfloat *last,
-							const GLfloat *m,
-							GLuint stride,
-							const GLubyte *clipmask );
-#endif
-
-
-void gl_init_katmai_transform_asm( void )
-{
-#ifdef USE_KATMAI_ASM
-   ASSIGN_XFORM_GROUP( katmai, 0, 1, raw );
-   ASSIGN_XFORM_GROUP( katmai, 0, 2, raw );
-   ASSIGN_XFORM_GROUP( katmai, 0, 3, raw );
-
-   ASSIGN_XFORM_GROUP( katmai, CULL_MASK_ACTIVE, 1, masked );
-   ASSIGN_XFORM_GROUP( katmai, CULL_MASK_ACTIVE, 2, masked );
-   ASSIGN_XFORM_GROUP( katmai, CULL_MASK_ACTIVE, 3, masked );
-
-#if 1
-   /* TODO: Finish these off.
-    */
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT][0] =
-      gl_katmai_transform_normals_no_rot_raw;
-   gl_normal_tab[NORM_TRANSFORM | NORM_RESCALE][0] =
-      gl_katmai_transform_rescale_normals_raw;
-   gl_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE][0] =
-      gl_katmai_transform_rescale_normals_no_rot_raw;
-
-   gl_transform_tab[0][4][MATRIX_GENERAL] =
-      gl_katmai_transform_points4_general_raw;
-   gl_transform_tab[0][4][MATRIX_3D] =
-      gl_katmai_transform_points4_3d_raw;
-
-   gl_transform_tab[CULL_MASK_ACTIVE][4][MATRIX_GENERAL] =
-      gl_katmai_transform_points4_general_masked;
-   gl_transform_tab[CULL_MASK_ACTIVE][4][MATRIX_IDENTITY] =
-      gl_katmai_transform_points4_identity_masked;
-   gl_transform_tab[CULL_MASK_ACTIVE][4][MATRIX_3D_NO_ROT] =
-      gl_katmai_transform_points4_3d_no_rot_masked;
-   gl_transform_tab[CULL_MASK_ACTIVE][4][MATRIX_3D] =
-      gl_katmai_transform_points4_3d_masked;
-#else
-   ASSIGN_NORM_GROUP( katmai, 0, raw );
-#endif
-
-#ifdef DEBUG
-   gl_test_all_transform_functions( "SSE" );
-   gl_test_all_normal_transform_functions( "SSE" );
-#endif
-#endif
-}
-
-void gl_init_katmai_vertex_asm( void )
-{
-#ifdef USE_KATMAI_ASM
-   gl_xform_points3_v16_general	= gl_v16_katmai_general_xform;
-#if 0
-   /* GH: These are broken.  I'm fixing them now.
-    */
-   gl_project_v16		= gl_katmai_project_vertices;
-   gl_project_clipped_v16	= gl_katmai_project_clipped_vertices;
-#endif
-
-#if 0
-   gl_test_all_vertex_functions( "SSE" );
-#endif
-#endif
-}
Index: xc/extras/Mesa/src/X86/katmai.h
diff -u xc/extras/Mesa/src/X86/katmai.h:1.4 xc/extras/Mesa/src/X86/katmai.h:removed
--- xc/extras/Mesa/src/X86/katmai.h:1.4	Thu Nov 30 10:39:21 2000
+++ xc/extras/Mesa/src/X86/katmai.h	Thu Feb 27 12:15:55 2003
@@ -1,37 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-/*
- * PentiumIII-SIMD (SSE) optimizations contributed by
- * Andre Werthmann <wertmann@cs.uni-potsdam.de>
- */
-
-#ifndef __KATMAI_H__
-#define __KATMAI_H__
-
-void gl_init_katmai_transform_asm( void );
-void gl_init_katmai_vertex_asm( void );
-
-#endif
Index: xc/extras/Mesa/src/X86/katmai_norm_raw.S
diff -u xc/extras/Mesa/src/X86/katmai_norm_raw.S:1.3 xc/extras/Mesa/src/X86/katmai_norm_raw.S:removed
--- xc/extras/Mesa/src/X86/katmai_norm_raw.S:1.3	Mon Nov 13 16:55:43 2000
+++ xc/extras/Mesa/src/X86/katmai_norm_raw.S	Thu Feb 27 12:15:55 2003
@@ -1,258 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define OFFSET_MAT 4
-#define OFFSET_SCALE 8
-#define OFFSET_IN 12
-#define OFFSET_LENGTHS 16
-#define OFFSET_MASK 20
-#define OFFSET_DEST 24
-
-#define ARG_MAT         REGOFF(FRAME_OFFSET+OFFSET_MAT, ESP)
-#define ARG_SCALE       REGOFF(FRAME_OFFSET+OFFSET_SCALE, ESP)
-#define ARG_IN          REGOFF(FRAME_OFFSET+OFFSET_IN, ESP)
-#define ARG_LENGTHS     REGOFF(FRAME_OFFSET+OFFSET_LENGTHS, ESP)
-#define ARG_MASK        REGOFF(FRAME_OFFSET+OFFSET_MASK, ESP)
-#define ARG_DEST        REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-
-
-#define V3F_START       4
-#define V3F_COUNT       8
-#define V3F_STRIDE      12
-
-#define MAT_INV         4
-
-#define M(i)    REGOFF(i * 4, EDX)
-#define S(i)	REGOFF(i * 4, ESI)
-#define D(i)	REGOFF(i * 4, EDI)
-#define STRIDE  REGOFF(12, ESI)
-
-#undef FRAME_OFFSET
-
-/*
- *	Offsets for norm_func arguments
- *
- * static void TAG(transform_rescale_normals_no_rot)( const GLmatrix *mat,
- *						   GLfloat scale,
- *						   const GLvector3f *in,
- *						   const GLfloat *lengths,
- *						   const GLubyte mask[],
- *						   GLvector3f *dest )
- */
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_katmai_transform_rescale_normals_no_rot_raw)
-GLNAME(gl_katmai_transform_rescale_normals_no_rot_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L  ( ESI )
-	PUSH_L  ( EDI )
-
-	MOV_L	( ARG_IN, ESI )				/* ptr to source GLvector3f */
-	MOV_L	( ARG_DEST, EDI )			/* ptr to dest GLvector3f */
-
-	MOV_L	( ARG_MAT, EDX )			/* ptr to matrix */
-	MOV_L	( REGOFF(MAT_INV, EDX), EDX)		/* matrix->inv */
-
-	MOV_L	( REGOFF(V3F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L	( ECX, ECX )
-	JZ( LLBL(K_G3TRNNRR_finish) )			/* count was zero; go to finish */
-
-	MOV_L	( STRIDE, EAX )				/* stride */
-	MOV_L	( ECX, REGOFF(V3F_COUNT, EDI) )		/* set dest-count */
-
-	IMUL_L( CONST(12), ECX )			/* count *= 12 */
-	MOV_L( REGOFF(V3F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V3F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS	( M(0), XMM1 )				/* m0 */
-	MOVSS	( M(5), XMM2 )				/* m5 */
-	UNPCKLPS( XMM2, XMM1 )				/* m5 | m0 */
-	MOVSS	( ARG_SCALE, XMM0 )			/* scale */
-	SHUFPS	( CONST(0x0), XMM0, XMM0 )		/* scale | scale */
-	MULPS	( XMM0, XMM1 )				/* m5*scale | m0*scale */
-	MULSS	( M(10), XMM0 )				/* m10*scale */
-
-ALIGNTEXT32
-LLBL(K_G3TRNNRR_top):
-	MOVLPS	( S(0), XMM2 )				/* uy | ux */
-	MULPS	( XMM1, XMM2 )				/* uy*m5*scale | ux*m0*scale */
-	MOVLPS	( XMM2, D(0) )				/* ->D(1) | D(0) */
-
-	MOVSS	( S(2), XMM2 )				/* uz */
-	MULSS	( XMM0, XMM2 )				/* uz*m10*scale */
-	MOVSS	( XMM2, D(2) )				/* ->D(2) */
-
-LLBL(K_G3TRNNRR_skip):
-	ADD_L	( CONST(12), EDI )
-	ADD_L	( EAX, ESI )
-	CMP_L	( ECX, EDI )
-	JNE	( LLBL(K_G3TRNNRR_top) )
-
-LLBL(K_G3TRNNRR_finish):
-	POP_L	( EDI )
-	POP_L	( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_katmai_transform_rescale_normals_raw)
-GLNAME(gl_katmai_transform_rescale_normals_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L  ( ESI )
-	PUSH_L  ( EDI )
-
-	MOV_L	( ARG_IN, ESI )				/* ptr to source GLvector3f */
-	MOV_L	( ARG_DEST, EDI )			/* ptr to dest GLvector3f */
-
-	MOV_L	( ARG_MAT, EDX )			/* ptr to matrix */
-	MOV_L	( REGOFF(MAT_INV, EDX), EDX)		/* matrix->inv */
-
-	MOV_L	( REGOFF(V3F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L	( ECX, ECX )
-	JZ( LLBL(K_G3TRNR_finish) )			/* count was zero; go to finish */
-
-	MOV_L	( STRIDE, EAX )				/* stride */
-	MOV_L	( ECX, REGOFF(V3F_COUNT, EDI) )		/* set dest-count */
-
-	IMUL_L( CONST(12), ECX )			/* count *= 12 */
-	MOV_L( REGOFF(V3F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V3F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS	( M(0), XMM0 )				/* m0 */
-	MOVSS	( M(4), XMM1 )				/* m4 */
-	UNPCKLPS( XMM1, XMM0 )				/* m4 | m0 */
-
-	MOVSS	( ARG_SCALE, XMM4 )			/* scale */
-	SHUFPS	( CONST(0x0), XMM4, XMM4 )		/* scale | scale */
-
-	MULPS	( XMM4, XMM0 )				/* m4*scale | m0*scale */
-	MOVSS	( M(1), XMM1 )				/* m1 */
-	MOVSS	( M(5), XMM2 )				/* m5 */
-	UNPCKLPS( XMM2, XMM1 )				/* m5 | m1 */
-	MULPS	( XMM4, XMM1 )				/* m5*scale | m1*scale */
-	MOVSS	( M(2), XMM2 )				/* m2 */
-	MOVSS	( M(6), XMM3 )				/* m6 */
-	UNPCKLPS( XMM3, XMM2 )				/* m6 | m2 */
-	MULPS	( XMM4, XMM2 )				/* m6*scale | m2*scale */
-
-	MOVSS	( M(8), XMM6 )				/* m8 */
-	MULSS	( ARG_SCALE, XMM6 )			/* m8*scale */
-	MOVSS	( M(9), XMM7 )				/* m9 */
-	MULSS	( ARG_SCALE, XMM7 )			/* m9*scale */
-
-ALIGNTEXT32
-LLBL(K_G3TRNR_top):
-	MOVSS	( S(0), XMM3 )				/* ux */
-	SHUFPS	( CONST(0x0), XMM3, XMM3 )		/* ux | ux */
-	MULPS	( XMM0, XMM3 )				/* ux*m4 | ux*m0 */
-	MOVSS	( S(1), XMM4 )				/* uy */
-	SHUFPS	( CONST(0x0), XMM4, XMM4 )		/* uy | uy */
-	MULPS	( XMM1, XMM4 )				/* uy*m5 | uy*m1 */
-	MOVSS	( S(2), XMM5 )				/* uz */
-	SHUFPS	( CONST(0x0), XMM5, XMM5 )		/* uz | uz */
-	MULPS	( XMM2, XMM5 )				/* uz*m6 | uz*m2 */
-
-	ADDPS	( XMM4, XMM3 )
-	ADDPS	( XMM5, XMM3 )
-	MOVLPS	( XMM3, D(0) )
-
-	MOVSS	( M(10), XMM3 )				/* m10 */
-	MULSS	( ARG_SCALE, XMM3 )			/* m10*scale */
-	MULSS	( S(2), XMM3 )				/* m10*scale*uz */
-	MOVSS	( S(1), XMM4 )				/* uy */
-	MULSS	( XMM7, XMM4 )				/* uy*m9*scale */
-	MOVSS	( S(0), XMM5 )				/* ux */
-	MULSS	( XMM6, XMM5 )				/* ux*m8*scale */
-
-	ADDSS	( XMM4, XMM3 )
-	ADDSS	( XMM5, XMM3 )
-	MOVSS	( XMM3, D(2) )
-
-LLBL(K_G3TRNR_skip):
-	ADD_L	( CONST(12), EDI )
-	ADD_L	( EAX, ESI )
-	CMP_L	( ECX, EDI )
-	JNE	( LLBL(K_G3TRNR_top) )
-
-LLBL(K_G3TRNR_finish):
-	POP_L	( EDI )
-	POP_L	( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_katmai_transform_normals_no_rot_raw)
-GLNAME(gl_katmai_transform_normals_no_rot_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L  ( ESI )
-	PUSH_L  ( EDI )
-
-	MOV_L	( ARG_IN, ESI )				/* ptr to source GLvector3f */
-	MOV_L	( ARG_DEST, EDI )			/* ptr to dest GLvector3f */
-
-	MOV_L	( ARG_MAT, EDX )			/* ptr to matrix */
-	MOV_L	( REGOFF(MAT_INV, EDX), EDX)		/* matrix->inv */
-
-	MOV_L	( REGOFF(V3F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L	( ECX, ECX )
-	JZ( LLBL(K_G3TNNRR_finish) )			/* count was zero; go to finish */
-
-	MOV_L	( STRIDE, EAX )				/* stride */
-	MOV_L	( ECX, REGOFF(V3F_COUNT, EDI) )		/* set dest-count */
-
-	IMUL_L( CONST(12), ECX )			/* count *= 12 */
-	MOV_L( REGOFF(V3F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V3F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS( M(0), XMM0 )				/* m0 */
-	MOVSS( M(5), XMM1 )				/* m5 */
-	UNPCKLPS( XMM1, XMM0 )				/* m5 | m0 */
-	MOVSS( M(10), XMM1 )				/* m10 */
-
-ALIGNTEXT32
-LLBL(K_G3TNNRR_top):
-	MOVLPS( S(0), XMM2 )				/* uy | ux */
-	MULPS( XMM0, XMM2 )				/* uy*m5 | ux*m0 */
-	MOVLPS( XMM2, D(0) )
-
-	MOVSS( S(2), XMM2 )				/* uz */
-	MULSS( XMM1, XMM2 )				/* uz*m10 */
-	MOVSS( XMM2, D(2) )
-
-LLBL(K_G3TNNRR_skip):
-	ADD_L	( CONST(12), EDI )
-	ADD_L	( EAX, ESI )
-	CMP_L	( ECX, EDI )
-	JNE	( LLBL(K_G3TNNRR_top) )
-
-LLBL(K_G3TNNRR_finish):
-	POP_L	( EDI )
-	POP_L	( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_vertex.S
diff -u xc/extras/Mesa/src/X86/katmai_vertex.S:1.1.1.1 xc/extras/Mesa/src/X86/katmai_vertex.S:removed
--- xc/extras/Mesa/src/X86/katmai_vertex.S:1.1.1.1	Mon Nov 13 16:34:09 2000
+++ xc/extras/Mesa/src/X86/katmai_vertex.S	Thu Feb 27 12:15:55 2003
@@ -1,182 +0,0 @@
-#include "assyntax.h"
-
-	SEG_TEXT
-
-#define MAT_SY 20
-#define MAT_SZ 40
-#define MAT_TX 48
-#define MAT_TY 52
-#define MAT_TZ 56
-
-
-/*
- * void gl_v16_katmai_general_xform( GLfloat *dest,
- *		        	     const GLfloat *m,
- *				     const GLfloat *src,
- *                                   GLuint src_stride,
- *				     GLuint count )
- *
- */
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_v16_katmai_general_xform )
-GLNAME( gl_v16_katmai_general_xform ):
-
-    PUSH_L( EDI )
-    PUSH_L( ESI )
-
-    MOV_L( REGOFF(12, ESP), EAX )		/* destination                       */
-    MOV_L( REGOFF(16, ESP), ESI )		/* matrix                            */
-    MOV_L( REGOFF(20, ESP), EDX )		/* source                            */
-    MOV_L( REGOFF(24, ESP), EDI )		/* src_stride                        */
-    MOV_L( REGOFF(28, ESP), ECX )		/* count                             */
-
-    MOVAPS( REGOFF(0, ESI), XMM4 )		/* m3     | m2     | m1     | m0     */
-    MOVAPS( REGOFF(16, ESI), XMM5 )		/* m7     | m6     | m5     | m4     */
-    MOVAPS( REGOFF(32, ESI), XMM6 )		/* m11    | m10    | m9     | m8     */
-    MOVAPS( REGOFF(48, ESI), XMM7 )		/* m15    | m14    | m13    | m12    */
-
-ALIGNTEXT32
-LLBL(v16_katmai_general_loop):
-
-    MOVSS( REGOFF(0, EDX), XMM0 )		/*        |        |        | x0     */
-    SHUFPS( CONST(0x0), XMM0, XMM0 )		/* x0     | x0     | x0     | x0     */
-    MULPS( XMM4, XMM0 )				/* x0*m3  | x0*m2  | x0*m1  | x0*m0  */
-
-    MOVSS( REGOFF(4, EDX), XMM1 )		/*        |        |        | x1     */
-    SHUFPS( CONST(0x0), XMM1, XMM1 )		/* x1     | x1     | x1     | x1     */
-    MULPS( XMM5, XMM1 )				/* x1*m7  | x1*m6  | x1*m5  | x1*m4  */
-
-    MOVSS( REGOFF(8, EDX), XMM2 )		/*        |        |        | x2     */
-    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* x2     | x2     | x2     | x2     */
-    MULPS( XMM6, XMM2 )				/* x2*m11 | x2*m10 | x2*m9  | x2*m8  */
-
-    ADDPS( XMM1, XMM0 )
-    ADDPS( XMM2, XMM0 )
-    ADDPS( XMM7, XMM0 )				/* r3     | r2     | r1     | r1     */
-
-    MOVAPS( XMM0, REGOFF(0, EAX) )
-
-    ADD_L( CONST(64), EAX )			/* next output vertex                */
-    ADD_L( EDI, EDX )				/* next input vertex                 */
-
-    DEC_L( ECX )
-    JNE( LLBL(v16_katmai_general_loop) )
-
-    POP_L( ESI )
-    POP_L( EDI )
-
-    RET
-
-
-/* void gl_katmai_project_vertices(GLfloat *first,
- *	              		   GLfloat *last,
- *	              		   const GLfloat *m,
- *	              		   GLuint stride )
- */
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_katmai_project_vertices )
-GLNAME( gl_katmai_project_vertices ):
-
-	PUSH_L( EBP )
-
-	MOV_L( REGOFF(8, ESP), ECX )	/* first_vert */
-	MOV_L( REGOFF(12, ESP), EDX )	/* last_vert */
-	MOV_L( REGOFF(16, ESP), EBP )	/* matrix */
-	MOV_L( REGOFF(20, ESP), EAX )	/* stride */
-
-
-ALIGNTEXT32
-	MOVAPS( REGOFF(MAT_TX, EBP), XMM0 )	/* (x44), x43, x42, x41 => xmm0 */
-	MOVSS( REGOFF(0, EBP), XMM1 )		/* -, -, -, x11 => xmm1 */
-	UNPCKLPS( REGOFF(MAT_SY, EBP), XMM1 )	/* -, -, x22, x11 => xmm1 */
-	SHUFPS( CONST(0x44), REGOFF(MAT_SZ, EBP), XMM1 )
-						/* -, x33, x22, x11 => xmm1 */
-
-	SUB_L( ECX, EDX )			/* last -= first */
-
-LLBL(v16_katmai_pv_loop_start):
-	MOVAPS( REGOFF(0, ECX), XMM3 )		/* f[3], f[2], f[1], f[0] */
-
-	MOVSS( REGOFF(12, ECX), XMM2 )		/* -, -, -, f[3] */
-	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* f[3], f[3], f[3], f[3] */
-	RCPPS( XMM2, XMM2 )			/* 1/f[3], 1/f[3], 1/f[3], 1/f[3] */
-
-	MULPS( XMM2, XMM1 )			/* -, x33*1/f[3]... */
-	MULPS( XMM3, XMM1 )			/* -, x33*1/f[3]*f[2]... */
-	ADDPS( XMM0, XMM1 )			/* -, x33*1/f[3]*f[2]+x43... */
-
-	MOVAPS( XMM1, REGOFF(0, ECX) )		/* back to f */
-	MOVSS( XMM2, REGOFF(12, ECX) )		/* 1/f[3] into f[3] ! */
-
-
-	ADD_L( EAX, ECX )			/* f += stride */
-	SUB_L( EAX, EDX )			/* (last-first)-stride */
-	JA ( LLBL(v16_katmai_pv_loop_start) )
-
-	POP_L( EBP )
-	RET
-
-
-
-/* void gl_katmai_project_clipped_vertices(GLfloat *first,
- *	              		   	   GLfloat *last,
- *	              		   	   const GLfloat *m,
- *	              		   	   GLuint stride,
- *					   const GLubyte *clipmask );
- */
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_katmai_project_clipped_vertices )
-GLNAME( gl_katmai_project_clipped_vertices ):
-
-	PUSH_L( EBP )
-	PUSH_L( ESI )
-
-	MOV_L( REGOFF(12, ESP), ECX )	/* first_vert */
-	MOV_L( REGOFF(16, ESP), EDX )	/* last_vert */
-	MOV_L( REGOFF(20, ESP), EBP )	/* matrix */
-	MOV_L( REGOFF(24, ESP), EAX )	/* stride */
-	MOV_L( REGOFF(28, ESP), ESI )	/* clip_mask */
-
-
-
-ALIGNTEXT32
-
-	MOVAPS( REGOFF(MAT_TX, EBP), XMM0 )	/* (x44), x43, x42, x41 => xmm0 */
-	MOVSS( REGOFF(0, EBP), XMM1 )		/* -, -, -, x11 => xmm1 */
-	UNPCKLPS( REGOFF(MAT_SY, EBP), XMM1 )	/* -, -, x22, x11 => xmm1 */
-	SHUFPS( CONST(0x44), REGOFF(MAT_SZ, EBP), XMM1 )
-						/* -, x33, x22, x11 => xmm1 */
-
-LLBL(v16_katmai_pcv_loop_start):
-	CMP_B ( CONST(0), REGIND(ESI) )		/* clip_mask == 0 ? */
-	JNE( LLBL(v16_katmai_pcv_skip) )	/* no -> skip ! */
-
-	MOVAPS( REGOFF(0, ECX), XMM3 )		/* f[3], f[2], f[1], f[0] */
-
-	MOVSS( REGOFF(12, ECX), XMM2 )		/* -, -, -, f[3] */
-	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* f[3], f[3], f[3], f[3] */
-	RCPPS( XMM2, XMM2 )			/* 1/f[3], 1/f[3], 1/f[3], 1/f[3] */
-
-	MULPS( XMM2, XMM1 )			/* -, x33*1/f[3]... */
-	MULPS( XMM3, XMM1 )			/* -, x33*1/f[3]*f[2]... */
-	ADDPS( XMM0, XMM1 )			/* -, x33*1/f[3]*f[2]+x43... */
-
-	MOVAPS( XMM1, REGOFF(0, ECX) )		/* back to f */
-	MOVSS( XMM2, REGOFF(12, ECX) )		/* 1/f[3] into f[3] ! */
-
-LLBL(v16_katmai_pcv_skip):
-	ADD_L( EAX, ECX )			/* f += stride */
-	INC_L( ESI )				/* nect ClipMask */
-
-	CMP_L( ECX, EDX )			/* p_first_vertex == p_last_vertex */
-	JNE( LLBL(v16_katmai_pcv_loop_start) )
-						/* no -> go on with next vertex */
-
-	POP_L( ESI )
-	POP_L( EBP )
-	RET
Index: xc/extras/Mesa/src/X86/katmai_xform_masked1.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_masked1.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_masked1.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_masked1.S:1.6	Mon Nov 13 18:31:11 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_masked1.S	Thu Feb 27 12:15:55 2003
@@ -1,512 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define S(i) 	REGOFF(i * 4, ESI)
-#define D(i) 	REGOFF(i * 4, EDI)
-#define M(i) 	REGOFF(i * 4, EDX)
-
-/*
- * 	Offsets into GLvector4f
- */
-#define V4F_DATA 	0
-#define V4F_START 	4
-#define V4F_COUNT 	8
-#define V4F_STRIDE 	12
-#define V4F_SIZE 	16
-#define V4F_FLAGS 	20
-
-#define VEC_SIZE_1   1
-#define VEC_SIZE_2   3
-#define VEC_SIZE_3   7
-#define VEC_SIZE_4   15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST 4
-#define OFFSET_MATRIX 8
-#define OFFSET_SOURCE 12
-#define OFFSET_CLIP 16
-#define OFFSET_FLAG 20
-
-#define ARG_DEST 	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_general_masked)
-GLNAME( gl_katmai_transform_points1_general_masked ):
-
-#define FRAME_OFFSET 16
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    TEST_L( ECX, ECX )				/* count was zero ? */
-    JZ( LLBL(K_GTP1GM_finish) )			/* yes -> nothing to do. */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  | m0  */
-    MOVAPS( M(12), XMM1 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP1GM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP1GM_skip) )
-
-    MOVSS( S(0), XMM2 )				/* ox */
-    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* ox | ox | ox | ox */
-    MULPS( XMM0, XMM2 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-    ADDPS( XMM1, XMM2 )				/* + | + | + | + */
-    MOVAPS( XMM2, D(0) )
-
-LLBL(K_GTP1GM_skip):
-    INC_L     ( EBP )
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP1GM_top) )
-
-LLBL(K_GTP1GM_finish):
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_identity_masked)
-GLNAME( gl_katmai_transform_points1_identity_masked ):
-
-#define FRAME_OFFSET 16
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTP1IM_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_1), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(1), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-    CMP_L( ESI, EDI )
-    JE( LLBL(K_GTP1IM_finish) )
-
-ALIGNTEXT32
-LLBL(K_GTP1IM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP1IM_skip) )
-
-    MOV_L( S(0), EDX )
-    MOV_L( EDX, D(0) )
-
-LLBL(K_GTP1IM_skip):
-    INC_L     ( EBP )
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP1IM_top) )
-
-LLBL(K_GTP1IM_finish):
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_3d_no_rot_masked)
-GLNAME(gl_katmai_transform_points1_3d_no_rot_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-    PUSH_L( EBX )
-    PUSH_L( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTP13DNRM_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVSS( M(0), XMM0 )				/* m0 */
-    MOVSS( M(12), XMM1 )			/* m12 */
-    MOVSS( M(13), XMM2 )			/* m13 */
-    MOVSS( M(14), XMM3 )			/* m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP13DNRM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP13DNRM_skip) )
-
-    MOVSS( S(0), XMM4 )				/* ox */
-    MULSS( XMM0, XMM4 )				/* ox*m0 */
-    ADDSS( XMM1, XMM4 )				/* ox*m0+m12 */
-    MOVSS( XMM4, D(0) )
-
-    MOVSS( XMM2, D(1) )
-    MOVSS( XMM3, D(2) )
-
-LLBL(K_GTP13DNRM_skip):
-    INC_L    ( EBP )
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP13DNRM_top) )
-
-LLBL(K_GTP13DNRM_finish):
-    POP_L    ( EBP )
-    POP_L    ( EBX )
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_perspective_masked)
-GLNAME(gl_katmai_transform_points1_perspective_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L   ( ESI )
-    PUSH_L   ( EDI )
-    PUSH_L   ( EBX )
-    PUSH_L   ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP13PM_finish) )		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    XORPS( XMM0, XMM0 )				/* 0 | 0 | 0 | 0 */
-    MOVSS( M(0), XMM1 )				/* m0 */
-    MOVSS( M(14), XMM2 )			/* m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP13PM_top):
-    TEST_B   ( BL, REGIND(EBP) )
-    JNZ      ( LLBL(K_GTP13PM_skip) )
-
-    MOVSS( S(0), XMM3 )				/* ox */
-    MULSS( XMM1, XMM3 )				/* ox*m0 */
-    MOVSS( XMM3, D(0) )				/* ox*m0->D(0) */
-    MOVSS( XMM2, D(2) )				/* m14->D(2) */
-
-    MOVSS( XMM0, D(1) )
-    MOVSS( XMM0, D(3) )
-
-LLBL(K_GTP13PM_skip):
-    INC_L( EBP )
-    ADD_L( CONST(16), EDI )
-    ADD_L( EAX, ESI )
-    CMP_L( ECX, EDI )
-    JNE( LLBL(K_GTP13PM_top) )
-
-LLBL(K_GTP13PM_finish):
-    POP_L    ( EBP )
-    POP_L    ( EBX )
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_2d_masked)
-GLNAME(gl_katmai_transform_points1_2d_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-    PUSH_L( EBX )
-    PUSH_L( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP13P2DM_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVLPS( M(0), XMM0 )			/* m1  | m0  */
-    MOVLPS( M(12), XMM1 )			/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP13P2DM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP13P2DM_skip) )
-
-    MOVSS( S(0), XMM2 )				/* ox */
-    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* ox | ox | ox | ox */
-    MULPS( XMM0, XMM2 )				/* - | - | ox*m1 | ox*m0 */
-    ADDPS( XMM1, XMM2 )				/* - | - | ox*m1+m13 | ox*m0+m12 */
-    MOVLPS( XMM2, D(0) )
-
-LLBL(K_GTP13P2DM_skip):
-    INC_L    ( EBP )
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP13P2DM_top) )
-
-LLBL(K_GTP13P2DM_finish):
-    POP_L    ( EBP )
-    POP_L    ( EBX )
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_2d_no_rot_masked)
-GLNAME(gl_katmai_transform_points1_2d_no_rot_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )				/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX )			/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP )				/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )		/* source count */
-	MOV_B( ARG_FLAG, BL )				/* clip mask flags */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP13P2DNRM_finish) )		/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )		/* stride */
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )		/* set dest count */
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX )				/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX )				/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS( M(0), XMM0 )			/* m0 */
-	MOVSS( M(12), XMM1 )			/* m12 */
-	MOVSS( M(13), XMM2 )			/* m13 */
-
-ALIGNTEXT32
-LLBL(K_GTP13P2DNRM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP13P2DNRM_skip) )
-
-	MOVSS( S(0), XMM3 )			/* ox */
-	MULSS( XMM0, XMM3 )			/* ox*m0 */
-	ADDSS( XMM1, XMM3 )			/* ox*m0+m12 */
-	MOVSS( XMM3, D(0) )
-	MOVSS( XMM2, D(1) )
-
-LLBL(K_GTP13P2DNRM_skip):
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP13P2DNRM_top) )
-
-LLBL(K_GTP13P2DNRM_finish):
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_3d_masked)
-GLNAME(gl_katmai_transform_points1_3d_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )		/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP ) 			/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-	MOV_B( ARG_FLAG, BL ) 			/* clip mask flags */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP13P3DM_finish) )		/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  |  m0 */
-	MOVAPS( M(12), XMM1 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP13P3DM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP13P3DM_skip) )
-
-	MOVSS( S(0), XMM2 )			/* ox */
-	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* ox | ox | ox | ox */
-	MULPS( XMM0, XMM2 )			/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-	ADDPS( XMM1, XMM2 )			/* +m15  | +m14  | +m13  | +m12  */
-	MOVLPS( XMM2, D(0) )			/*   -   |   -   | ->D(1)| ->D(0)*/
-	UNPCKHPS( XMM2, XMM2 )			/* ox*m3+m15 | ox*m3+m15 | ox*m2+m14 | ox*m2+m14 */
-	MOVSS( XMM2, D(2) )			/* ->D(2) */
-
-LLBL(K_GTP13P3DM_skip):
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP13P3DM_top) )
-
-LLBL(K_GTP13P3DM_finish):
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_xform_masked2.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_masked2.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_masked2.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_masked2.S:1.6	Mon Nov 13 18:31:12 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_masked2.S	Thu Feb 27 12:15:55 2003
@@ -1,538 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define S(i) 	REGOFF(i * 4, ESI)
-#define D(i) 	REGOFF(i * 4, EDI)
-#define M(i) 	REGOFF(i * 4, EDX)
-
-/*
- * 	Offsets into GLvector4f
- */
-#define V4F_DATA 	0
-#define V4F_START 	4
-#define V4F_COUNT 	8
-#define V4F_STRIDE 	12
-#define V4F_SIZE 	16
-#define V4F_FLAGS 	20
-
-#define VEC_SIZE_1   1
-#define VEC_SIZE_2   3
-#define VEC_SIZE_3   7
-#define VEC_SIZE_4   15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST 4
-#define OFFSET_MATRIX 8
-#define OFFSET_SOURCE 12
-#define OFFSET_CLIP 16
-#define OFFSET_FLAG 20
-
-#define ARG_DEST 	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_general_masked)
-GLNAME( gl_katmai_transform_points2_general_masked ):
-
-#define FRAME_OFFSET 16
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTP2GM_finish) )			/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  | m0 */
-    MOVAPS( M(4), XMM1 )			/* m7  | m6  | m5  | m4 */
-    MOVAPS( M(12), XMM2 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP2GM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP2GM_skip) )
-
-    MOVSS( S(0), XMM3 )				/* ox */
-    SHUFPS( CONST(0x0), XMM3, XMM3 )		/* ox | ox | ox | ox */
-    MULPS( XMM0, XMM3 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-    MOVSS( S(1), XMM4 )				/* oy */
-    SHUFPS( CONST(0x0), XMM4, XMM4 )		/* oy | oy | oy | oy */
-    MULPS( XMM1, XMM4 )				/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
-
-    ADDPS( XMM4, XMM3 )
-    ADDPS( XMM2, XMM3 )
-    MOVAPS( XMM3, D(0) )
-
-LLBL(K_GTP2GM_skip):
-    INC_L     ( EBP )
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP2GM_top) )
-
-LLBL(K_GTP2GM_finish):
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_identity_masked)
-GLNAME( gl_katmai_transform_points2_identity_masked ):
-
-#define FRAME_OFFSET 16
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP2IM_finish) )			/* count was zero; go to finish */
-
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-    CMP_L( ESI, EDI )
-    JE( LLBL(K_GTP2IM_finish) )
-
-ALIGNTEXT32
-LLBL(K_GTP2IM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP2IM_skip) )
-
-    MOV_L( S(0), EDX )
-    MOV_L( EDX, D(0) )
-    MOV_L( S(1), EDX )
-    MOV_L( EDX, D(1) )
-
-LLBL(K_GTP2IM_skip):
-    INC_L     ( EBP )
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP2IM_top) )
-
-LLBL(K_GTP2IM_finish):
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_3d_no_rot_masked)
-GLNAME(gl_katmai_transform_points2_3d_no_rot_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-    PUSH_L( EBX )
-    PUSH_L( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP23DNRM_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* - | - |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* - | - |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* - | - | m5  | m0  */
-    MOVLPS   ( M(12), XMM2 )			/* - | - | m13 | m12 */
-    MOVSS    ( M(14), XMM3 )			/* - | - |  -  | m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP23DNRM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP23DNRM_skip) )
-
-    MOVLPS   ( S(0), XMM0 )			/* - | - |  oy   | ox */
-    MULPS    ( XMM1, XMM0 )			/* - | - | oy*m5 | ox*m0 */
-    ADDPS    ( XMM2, XMM0 )			/* - | - | +m13  | +m12 */
-    MOVLPS   ( XMM0, D(0) )			/* -> D(1) | -> D(0) */
-
-    MOVSS    ( XMM3, D(2) )			/* -> D(2) */
-
-LLBL(K_GTP23DNRM_skip):
-    INC_L    ( EBP )
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP23DNRM_top) )
-
-LLBL(K_GTP23DNRM_finish):
-    POP_L    ( EBP )
-    POP_L    ( EBX )
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_perspective_masked)
-GLNAME(gl_katmai_transform_points2_perspective_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L   ( ESI )
-    PUSH_L   ( EDI )
-    PUSH_L   ( EBX )
-    PUSH_L   ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP23PM_finish) )		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* -  | -  |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* -  | -  |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* -  | -  | m5  | m0  */
-    MOVSS    ( M(14), XMM3 )			/* m14 */
-    XORPS    ( XMM0, XMM0 )			/* 0 | 0 | 0 | 0 */
-
-ALIGNTEXT32
-LLBL(K_GTP23PM_top):
-    TEST_B   ( BL, REGIND(EBP) )
-    JNZ      ( LLBL(K_GTP23PM_skip) )
-
-    MOVLPS( S(0), XMM4 )			/* oy | ox */
-    MULPS( XMM1, XMM4 )				/* oy*m5 | ox*m0 */
-    MOVLPS( XMM4, D(0) )			/* ->D(1) | ->D(0) */
-    MOVSS( XMM3, D(2) )				/* ->D(2) */
-    MOVSS( XMM0, D(3) )				/* ->D(3) */
-
-LLBL(K_GTP23PM_skip):
-    INC_L( EBP )
-    ADD_L( CONST(16), EDI )
-    ADD_L( EAX, ESI )
-    CMP_L( ECX, EDI )
-    JNE( LLBL(K_GTP23PM_top) )
-
-LLBL(K_GTP23PM_finish):
-    POP_L    ( EBP )
-    POP_L    ( EBX )
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_2d_masked)
-GLNAME(gl_katmai_transform_points2_2d_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-    PUSH_L( EBX )
-    PUSH_L( EBP )
-
-    MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP )			/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-    MOV_B( ARG_FLAG, BL )			/* clip mask flags */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP23P2DM_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVLPS( M(0), XMM0 )			/* m1  | m0 */
-    MOVLPS( M(4), XMM1 )			/* m5  | m4 */
-    MOVLPS( M(12), XMM2 )			/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP23P2DM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP23P2DM_skip) )
-
-    MOVSS( S(0), XMM3 )				/* ox */
-    SHUFPS( CONST(0x0), XMM3, XMM3 )		/* ox | ox */
-    MULPS( XMM0, XMM3 )				/* ox*m1 | ox*m0 */
-
-    MOVSS( S(1), XMM4 )				/* oy */
-    SHUFPS( CONST(0x0), XMM4, XMM4 )		/* oy | oy */
-    MULPS( XMM1, XMM4 )				/* oy*m5 | oy*m4 */
-
-    ADDPS( XMM4, XMM3 )
-    ADDPS( XMM2, XMM3 )
-    MOVLPS( XMM3, D(0) )			/* ->D(1) | ->D(0) */
-
-LLBL(K_GTP23P2DM_skip):
-    INC_L    ( EBP )
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP23P2DM_top) )
-
-LLBL(K_GTP23P2DM_finish):
-    POP_L    ( EBP )
-    POP_L    ( EBX )
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_2d_no_rot_masked)
-GLNAME(gl_katmai_transform_points2_2d_no_rot_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )				/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX )			/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP )				/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )		/* source count */
-	MOV_B( ARG_FLAG, BL )				/* clip mask flags */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP23P2DNRM_finish) )		/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )		/* stride */
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )		/* set dest count */
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX )				/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX )				/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS    ( M(0), XMM1 )				/* m0 */
-	MOVSS    ( M(5), XMM2 )				/* m5 */
-	UNPCKLPS ( XMM2, XMM1 )				/* m5 | m0 */
-	MOVLPS   ( M(12), XMM2 )			/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP23P2DNRM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP23P2DNRM_skip) )
-
-	MOVLPS( S(0), XMM0 )				/* oy | ox */
-	MULPS( XMM1, XMM0 )				/* oy*m5 | ox*m0 */
-	ADDPS( XMM2, XMM0 )				/* +m13 | +m12 */
-	MOVLPS( XMM0, D(0) )				/* ->D(1) | ->D(0) */
-
-LLBL(K_GTP23P2DNRM_skip):
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP23P2DNRM_top) )
-
-LLBL(K_GTP23P2DNRM_finish):
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_3d_masked)
-GLNAME(gl_katmai_transform_points2_3d_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )		/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX )		/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP ) 			/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-	MOV_B( ARG_FLAG, BL ) 			/* clip mask flags */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP23P3DM_finish) )		/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )			/* m2  | m1  | m0 */
-	MOVAPS( M(4), XMM1 )			/* m6  | m5  | m4 */
-	MOVAPS( M(12), XMM2 )			/* m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP23P3DM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP23P3DM_skip) )
-
-	MOVSS( S(0), XMM3 )			/* ox */
-	SHUFPS( CONST(0x0), XMM3, XMM3 )	/* ox | ox | ox */
-	MULPS( XMM0, XMM3 )			/* ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM4 )			/* oy */
-	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* oy | oy | oy */
-	MULPS( XMM1, XMM4 )			/* oy*m6 | oy*m5 | oy*m4 */
-
-	ADDPS( XMM4, XMM3 )
-	ADDPS( XMM2, XMM3 )
-
-	MOVLPS( XMM3, D(0) )			/* ->D(1) | ->D(0) */
-	UNPCKHPS( XMM3, XMM3 )
-	MOVSS( XMM3, D(2) )			/* ->D(2) */
-
-LLBL(K_GTP23P3DM_skip):
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP23P3DM_top) )
-
-LLBL(K_GTP23P3DM_finish):
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_xform_masked3.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_masked3.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_masked3.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_masked3.S:1.6	Mon Nov 13 18:31:12 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_masked3.S	Thu Feb 27 12:15:55 2003
@@ -1,578 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define S(i) 	REGOFF(i * 4, ESI)
-#define D(i) 	REGOFF(i * 4, EDI)
-#define M(i) 	REGOFF(i * 4, EDX)
-
-/*
- * 	Offsets into GLvector4f
- */
-#define V4F_DATA 	0
-#define V4F_START 	4
-#define V4F_COUNT 	8
-#define V4F_STRIDE 	12
-#define V4F_SIZE 	16
-#define V4F_FLAGS 	20
-
-#define VEC_SIZE_1   1
-#define VEC_SIZE_2   3
-#define VEC_SIZE_3   7
-#define VEC_SIZE_4   15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST 4
-#define OFFSET_MATRIX 8
-#define OFFSET_SOURCE 12
-#define OFFSET_CLIP 16
-#define OFFSET_FLAG 20
-
-#define ARG_DEST 	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_katmai_transform_points3_general_masked)
-GLNAME( gl_katmai_transform_points3_general_masked ):
-
-#define FRAME_OFFSET 16
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI ) 		/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI ) 		/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP ) 		/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) /* source count */
-    MOV_B( ARG_FLAG, BL ) 		/* clip mask flags */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTPGM_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVAPS    ( REGOFF(0, EDX), XMM0 )	/* m0  | m1  | m2  | m3 */
-    MOVAPS    ( REGOFF(16, EDX), XMM1 )	/* m4  | m5  | m6  | m7 */
-    MOVAPS    ( REGOFF(32, EDX), XMM2 )	/* m8  | m9  | m10 | m11 */
-    MOVAPS    ( REGOFF(48, EDX), XMM3 )	/* m12 | m13 | m14 | m15 */
-
-
-ALIGNTEXT32
-LLBL(K_GTPGM_top):
-    TEST_B    ( BL, REGIND(EBP) )
-    JNZ       ( LLBL(K_GTPGM_skip) )
-
-    MOVSS     ( REGOFF(0, ESI), XMM4 )		/*    |    |    | ox */
-    SHUFPS    ( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox | ox */
-    MOVSS     ( REGOFF(4, ESI), XMM5 )		/*    |    |    | oy */
-    SHUFPS    ( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy | oy */
-    MOVSS     ( REGOFF(8, ESI), XMM6 )		/*    |    |    | oz */
-    SHUFPS    ( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz | oz */
-
-    MULPS     ( XMM0, XMM4 )		/* m3*ox  | m2*ox  | m1*ox | m0*ox */
-    MULPS     ( XMM1, XMM5 )		/* m7*oy  | m6*oy  | m5*oy | m4*oy */
-    MULPS     ( XMM2, XMM6 )		/* m11*oz | m10*oz | m9*oz | m8*oz */
-
-    ADDPS     ( XMM5, XMM4 )
-    ADDPS     ( XMM6, XMM4 )
-    ADDPS     ( XMM3, XMM4 )
-
-    MOVAPS    ( XMM4, REGOFF(0, EDI) )
-
-LLBL(K_GTPGM_skip):
-    INC_L     ( EBP )
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTPGM_top) )
-
-LLBL(K_GTPGM_finish):
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_katmai_transform_points3_identity_masked)
-GLNAME( gl_katmai_transform_points3_identity_masked ):
-
-#define FRAME_OFFSET 16
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-    PUSH_L    ( EBX )
-    PUSH_L    ( EBP )
-
-    MOV_L( ARG_SOURCE, ESI ) 		/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI ) 		/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_CLIP, EBP ) 		/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) /* source count */
-    MOV_B( ARG_FLAG, BL ) 		/* clip mask flags */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTPIM_finish) ) 		 /* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) /* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-    CMP_L( ESI, EDI )
-    JE( LLBL(K_GTPIM_finish) )
-
-
-ALIGNTEXT32
-LLBL(K_GTPIM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTPIM_skip) )
-
-    MOVLPS    ( S(0), XMM0 )
-    MOVLPS    ( XMM0, D(0) )
-    MOVSS     ( S(2), XMM0 )
-    MOVSS     ( XMM0, D(2) )
-
-LLBL(K_GTPIM_skip):
-    INC_L     ( EBP )
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTPIM_top) )
-
-LLBL(K_GTPIM_finish):
-    POP_L     ( EBP )
-    POP_L     ( EBX )
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_3d_no_rot_masked)
-GLNAME(gl_katmai_transform_points3_3d_no_rot_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    PUSH_L( EBX )
-    PUSH_L( EBP )
-
-    MOV_L( ARG_SOURCE, ESI ) 		/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI ) 		/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP ) 		/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) /* source count */
-    MOV_B( ARG_FLAG, BL ) 		/* clip mask flags */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTP3DNRM_finish) ) 	/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) /* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) /* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 		/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) /* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) /* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* - | - |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* - | - |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* - | - | m5  | m0  */
-    MOVLPS   ( M(12), XMM2 )			/* - | - | m13 | m12 */
-    MOVSS    ( M(10), XMM3 )			/* - | - |  -  | m10 */
-    MOVSS    ( M(14), XMM4 )			/* - | - |  -  | m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP3DNRM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP3DNRM_skip) )
-
-    MOVLPS   ( S(0), XMM0 )			/* - | - |  s1   | s0 */
-    MULPS    ( XMM1, XMM0 )			/* - | - | s1*m5 | s0*m0 */
-    ADDPS    ( XMM2, XMM0 )			/* - | - | +m13  | +m12 */
-    MOVLPS   ( XMM0, D(0) )			/* -> D(1) | -> D(0) */
-
-    MOVSS    ( S(2), XMM0 )			/* sz */
-    MULSS    ( XMM3, XMM0 )			/* sz*m10 */
-    ADDSS    ( XMM4, XMM0 )			/* +m14 */
-    MOVSS    ( XMM0, D(2) )			/* -> D(2) */
-
-LLBL(K_GTP3DNRM_skip):
-    INC_L( EBP )
-    ADD_L( CONST(16), EDI )
-    ADD_L( EAX, ESI )
-    CMP_L( ECX, EDI )
-    JNE( LLBL(K_GTP3DNRM_top) )
-
-LLBL(K_GTP3DNRM_finish):
-    POP_L    ( EBP )
-    POP_L    ( EBX )
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_perspective_masked)
-GLNAME(gl_katmai_transform_points3_perspective_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    PUSH_L( EBX )
-    PUSH_L( EBP )
-
-    MOV_L( ARG_SOURCE, ESI ) 		/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI ) 		/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP ) 		/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) /* source count */
-    MOV_B( ARG_FLAG, BL ) 		/* clip mask flags */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTP3PM_finish) ) 	/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) /* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 		/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* -  | -  |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* -  | -  |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* -  | -  | m5  | m0  */
-    MOVLPS   ( M(8), XMM2 )			/* -  | -  | m9  | m8  */
-    MOVSS    ( M(10), XMM3 )			/* m10 */
-    MOVSS    ( M(14), XMM4 )			/* m14 */
-    XORPS    ( XMM6, XMM6 )			/* 0 */
-
-ALIGNTEXT32
-LLBL(K_GTP3PM_top):
-    TEST_B   ( BL, REGIND(EBP) )
-    JNZ      ( LLBL(K_GTP3PM_skip) )
-
-    MOVLPS   ( S(0), XMM0 )			/* oy | ox */
-    MULPS    ( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
-    MOVSS    ( S(2), XMM5 )			/* oz */
-    SHUFPS   ( CONST(0x0), XMM5, XMM5 )		/* oz | oz */
-    MULPS    ( XMM2, XMM5 )			/* oz*m9 | oz*m8 */
-    ADDPS    ( XMM5, XMM0 )			/* +oy*m5 | +ox*m0 */
-    MOVLPS   ( XMM0, D(0) )			/* ->D(1) | ->D(0) */
-
-    MOVSS    ( S(2), XMM0 )			/* oz */
-    MULSS    ( XMM3, XMM0 )			/* oz*m10 */
-    ADDSS    ( XMM4, XMM0 )			/* +m14 */
-    MOVSS    ( XMM0, D(2) )			/* ->D(2) */
-
-    MOVSS    ( S(2), XMM0 )			/* oz */
-    MOVSS    ( XMM6, XMM5 )			/* 0 */
-    SUBPS    ( XMM0, XMM5 )			/* -oz */
-    MOVSS    ( XMM5, D(3) )
-
-LLBL(K_GTP3PM_skip):
-    INC_L    ( EBP )
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP3PM_top) )
-
-LLBL(K_GTP3PM_finish):
-    POP_L( EBP )
-    POP_L( EBX )
-    POP_L( EDI )
-    POP_L( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_2d_masked)
-GLNAME(gl_katmai_transform_points3_2d_masked):
-
-#define FRAME_OFFSET 16
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    PUSH_L( EBX )
-    PUSH_L( EBP )
-
-    MOV_L( ARG_SOURCE, ESI ) 		/* ptr to source GLvector4f */
-    MOV_L( ARG_DEST, EDI ) 		/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-    MOV_L( ARG_CLIP, EBP ) 		/* ptr to clip mask array */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) /* source count */
-    MOV_B( ARG_FLAG, BL ) 		/* clip mask flags */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTP3P2DM_finish) ) 	/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX )				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVLPS( M(0), XMM0 )			/* m1  | m0 */
-    MOVLPS( M(4), XMM1 )			/* m5  | m4 */
-    MOVLPS( M(12), XMM2 )			/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP3P2DM_top):
-    TEST_B( BL, REGIND(EBP) )
-    JNZ( LLBL(K_GTP3P2DM_skip) )
-
-    MOVSS    ( S(0), XMM3 )			/* ox */
-    SHUFPS   ( CONST(0x0), XMM3, XMM3 )		/* ox | ox */
-    MULPS    ( XMM0, XMM3 )			/* ox*m1 | ox*m0 */
-    MOVSS    ( S(1), XMM4 )			/* oy */
-    SHUFPS   ( CONST(0x0), XMM4, XMM4 )		/* oy | oy */
-    MULPS    ( XMM1, XMM4 )			/* oy*m5 | oy*m4 */
-
-    ADDPS    ( XMM4, XMM3 )
-    ADDPS    ( XMM2, XMM3 )
-    MOVLPS   ( XMM3, D(0) )
-
-    MOVSS    ( S(2), XMM3 )
-    MOVSS    ( XMM3, D(2) )
-
-LLBL(K_GTP3P2DM_skip):
-    INC_L( EBP )
-    ADD_L( CONST(16), EDI )
-    ADD_L( EAX, ESI )
-    CMP_L( ECX, EDI )
-    JNE( LLBL(K_GTP3P2DM_top) )
-
-LLBL(K_GTP3P2DM_finish):
-    POP_L( EBP )
-    POP_L( EBX )
-    POP_L( EDI )
-    POP_L( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_2d_no_rot_masked)
-GLNAME(gl_katmai_transform_points3_2d_no_rot_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI ) 		/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI ) 			/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP ) 			/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-	MOV_B( ARG_FLAG, BL ) 			/* clip mask flags */
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL(K_GTP3P2DNRM_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS    ( M(0), XMM1 )			/* m0 */
-	MOVSS    ( M(5), XMM2 )			/* m5 */
-	UNPCKLPS ( XMM2, XMM1 )			/* m5 | m0 */
-	MOVLPS   ( M(12), XMM2 )		/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP3P2DNRM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP3P2DNRM_skip) )
-
-	MOVLPS( S(0), XMM0 )			/* oy | ox */
-	MULPS( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
-	ADDPS( XMM2, XMM0 )			/* +m13 | +m12 */
-	MOVLPS( XMM0, D(0) )			/* ->D(1) | ->D(0) */
-
-	MOVSS( S(2), XMM0 )
-	MOVSS( XMM0, D(2) )
-
-LLBL(K_GTP3P2DNRM_skip):
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP3P2DNRM_top) )
-
-LLBL(K_GTP3P2DNRM_finish):
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_3d_masked)
-GLNAME(gl_katmai_transform_points3_3d_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI ) 		/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI ) 			/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP ) 			/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-	MOV_B( ARG_FLAG, BL ) 			/* clip mask flags */
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL(K_GTP3P3DM_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )			/* m2  | m1  | m0 */
-	MOVAPS( M(4), XMM1 )			/* m6  | m5  | m4 */
-	MOVAPS( M(8), XMM2 )			/* m10 | m9  | m8 */
-	MOVAPS( M(12), XMM3 )			/* m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP3P3DM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP3P3DM_skip) )
-
-	MOVSS( S(0), XMM4 )
-	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox */
-	MULPS( XMM0, XMM4 )			/* ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM5 )
-	SHUFPS( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy */
-	MULPS( XMM1, XMM5 )			/* oy*m6 | oy*m5 | oy*m4 */
-
-	MOVSS( S(2), XMM6 )
-	SHUFPS( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz */
-	MULPS( XMM2, XMM6 )			/* oz*m10 | oz*m9 | oz*m8 */
-
-	ADDPS( XMM5, XMM4 )			/* + | + | + */
-	ADDPS( XMM6, XMM4 )			/* + | + | + */
-	ADDPS( XMM3, XMM4 )			/* + | + | + */
-
-	MOVLPS( XMM4, D(0) )			/* => D(1) | => D(0) */
-	UNPCKHPS( XMM4, XMM4 )
-	MOVSS( XMM4, D(2) )
-
-LLBL(K_GTP3P3DM_skip):
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP3P3DM_top) )
-
-LLBL(K_GTP3P3DM_finish):
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_xform_masked4.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_masked4.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_masked4.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_masked4.S:1.6	Mon Nov 13 18:31:12 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_masked4.S	Thu Feb 27 12:15:55 2003
@@ -1,367 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define S(i) 	REGOFF(i * 4, ESI)
-#define D(i) 	REGOFF(i * 4, EDI)
-#define M(i) 	REGOFF(i * 4, EDX)
-
-/*
- * 	Offsets into GLvector4f
- */
-#define V4F_DATA 	0
-#define V4F_START 	4
-#define V4F_COUNT 	8
-#define V4F_STRIDE 	12
-#define V4F_SIZE 	16
-#define V4F_FLAGS 	20
-
-#define VEC_SIZE_1   1
-#define VEC_SIZE_2   3
-#define VEC_SIZE_3   7
-#define VEC_SIZE_4   15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST 4
-#define OFFSET_MATRIX 8
-#define OFFSET_SOURCE 12
-#define OFFSET_CLIP 16
-#define OFFSET_FLAG 20
-
-#define ARG_DEST 	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points4_general_masked)
-GLNAME( gl_katmai_transform_points4_general_masked ):
-
-#define FRAME_OFFSET 16
-	PUSH_L    ( ESI )
-	PUSH_L    ( EDI )
-	PUSH_L    ( EBX )
-	PUSH_L    ( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )				/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP )				/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )		/* source count */
-	MOV_B( ARG_FLAG, BL )				/* clip mask flags */
-
-	TEST_L( ECX, ECX )				/* count was zero ? */
-	JZ( LLBL(K_GTP4GM_finish) )			/* yes -> nothing to do. */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )		/* stride */
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )		/* set dest count */
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX )				/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )				/* m3  | m2  | m1  | m0 */
-	MOVAPS( M(4), XMM1 )				/* m7  | m6  | m5  | m4 */
-	MOVAPS( M(8), XMM2 )				/* m11 | m10 | m9  | m8 */
-	MOVAPS( M(12), XMM3 )				/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP4GM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP4GM_skip) )
-
-	MOVSS( S(0), XMM4 )				/* ox */
-	SHUFPS( CONST(0x0), XMM4, XMM4 )		/* ox | ox | ox | ox */
-	MULPS( XMM0, XMM4 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM5 )				/* oy */
-	SHUFPS( CONST(0x0), XMM5, XMM5 )		/* oy | oy | oy | oy */
-	MULPS( XMM1, XMM5 )				/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
-
-	MOVSS( S(2), XMM6 )				/* oz */
-	SHUFPS( CONST(0x0), XMM6, XMM6 )		/* oz | oz | oz | oz */
-	MULPS( XMM2, XMM6 )				/* oz*m11 | oz*m10 | oz*m9 | oz*m8 */
-
-	MOVSS( S(3), XMM7 )				/* ow */
-	SHUFPS( CONST(0x0), XMM7, XMM7 )		/* ow | ow | ow | ow */
-	MULPS( XMM3, XMM7 )				/* ow*m15 | ow*m14 | ow*m13 | ow*m12 */
-
-	ADDPS( XMM5, XMM4 )				/* ox*m3+oy*m7 | ... */
-	ADDPS( XMM6, XMM4 )				/* ox*m3+oy*m7+oz*m11 | ... */
-	ADDPS( XMM7, XMM4 )				/* ox*m3+oy*m7+oz*m11+ow*m15 | ... */
-	MOVAPS( XMM4, D(0) )				/* ->D(3) | ->D(2) | ->D(1) | ->D(0) */
-
-LLBL(K_GTP4GM_skip):
-	INC_L     ( EBP )
-	ADD_L     ( CONST(16), EDI )
-	ADD_L     ( EAX, ESI )
-	CMP_L     ( ECX, EDI )
-	JNE       ( LLBL(K_GTP4GM_top) )
-
-LLBL(K_GTP4GM_finish):
-	POP_L     ( EBP )
-	POP_L     ( EBX )
-	POP_L     ( EDI )
-	POP_L     ( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points4_identity_masked)
-GLNAME( gl_katmai_transform_points4_identity_masked ):
-
-#define FRAME_OFFSET 16
-	PUSH_L    ( ESI )
-	PUSH_L    ( EDI )
-	PUSH_L    ( EBX )
-	PUSH_L    ( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )				/* ptr to dest GLvector4f */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )		/* source count */
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL(K_GTP4IM_finish) )			/* count was zero; go to finish */
-
-	MOV_L( ARG_CLIP, EBP )				/* ptr to clip mask array */
-	MOV_B( ARG_FLAG, BL )				/* clip mask flags */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )		/* stride */
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )		/* set dest count */
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX )				/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-	MOV_L( EAX, ARG_SOURCE )
-
-	CMP_L( ESI, EDI )
-	JE( LLBL(K_GTP4IM_finish) )
-
-ALIGNTEXT16
-LLBL(K_GTP4IM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP4IM_skip) )
-
-	MOV_L( S(0), EAX )
-	MOV_L( S(1), EDX )
-	MOV_L( EAX, D(0) )
-	MOV_L( EDX, D(1) )
-
-	MOV_L( S(2), EAX )
-	MOV_L( S(3), EDX )
-	MOV_L( EAX, D(2) )
-	MOV_L( EDX, D(3) )
-
-LLBL(K_GTP4IM_skip):
-	INC_L     ( EBP )
-	ADD_L     ( CONST(16), EDI )
-	ADD_L     ( ARG_SOURCE, ESI )
-	CMP_L     ( ECX, EDI )
-	JNE       ( LLBL(K_GTP4IM_top) )
-
-LLBL(K_GTP4IM_finish):
-	POP_L     ( EBP )
-	POP_L     ( EBX )
-	POP_L     ( EDI )
-	POP_L     ( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points4_3d_no_rot_masked)
-GLNAME(gl_katmai_transform_points4_3d_no_rot_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )			/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )				/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX )			/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP )				/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )		/* source count */
-	MOV_B( ARG_FLAG, BL )				/* clip mask flags */
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL(K_GTP43DNRM_finish) )			/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )		/* stride */
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )		/* set dest count */
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )	/* set dest size */
-
-	SHL_L( CONST(4), ECX )				/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI )		/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )		/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-	MOVSS( M(0), XMM0 )			/* m0 */
-	MOVSS( M(5), XMM1 )			/* m5 */
-	UNPCKLPS( XMM1, XMM0 )			/* m5 | m0 */
-	MOVSS( M(10), XMM1 )			/* m10 */
-	MOVLPS( M(12), XMM2 )			/* m13 | m12 */
-	MOVSS( M(14), XMM3 )			/* m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP43DNRM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP43DNRM_skip) )
-
-	MOVLPS( S(0), XMM4 )			/* oy | ox */
-	MULPS( XMM0, XMM4 )			/* oy*m5 | ox*m0 */
-	MOVSS( S(3), XMM5 )			/* ow */
-	SHUFPS( CONST(0x0), XMM5, XMM5 )	/* ow | ow | ow | ow */
-	MULPS( XMM2, XMM5 )			/* ow*m13 | ow*m12 */
-	ADDPS( XMM5, XMM4 )			/* oy*m5+ow*m13 | ox*m0+ow*m12 */
-	MOVLPS( XMM4, D(0) )			/* ->D(1) | ->D(0) */
-
-	MOVSS( S(2), XMM4 )			/* oz */
-	MULSS( XMM1, XMM4 )			/* oz*m10 */
-	MOVSS( S(3), XMM5 )			/* ow */
-	MOVSS( XMM5, D(3) )			/* ->D(3) */
-	MULSS( XMM3, XMM5 )			/* ow*m14 */
-	ADDSS( XMM5, XMM4 )			/* ow*m14+oz*m10 */
-	MOVSS( XMM4, D(2) )			/* ->D(2) */
-
-LLBL(K_GTP43DNRM_skip):
-	INC_L    ( EBP )
-	ADD_L    ( CONST(16), EDI )
-	ADD_L    ( EAX, ESI )
-	CMP_L    ( ECX, EDI )
-	JNE      ( LLBL(K_GTP43DNRM_top) )
-
-LLBL(K_GTP43DNRM_finish):
-	POP_L    ( EBP )
-	POP_L    ( EBX )
-	POP_L    ( EDI )
-	POP_L    ( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points4_3d_masked)
-GLNAME(gl_katmai_transform_points4_3d_masked):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )		/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( ARG_CLIP, EBP ) 			/* ptr to clip mask array */
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-	MOV_B( ARG_FLAG, BL ) 			/* clip mask flags */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP43P3DM_finish) )		/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  |  m0 */
-	MOVAPS( M(4), XMM1 )			/* m7  | m6  | m5  |  m4 */
-	MOVAPS( M(8), XMM2 )			/* m11 | m10 | m9  |  m8 */
-	MOVAPS( M(12), XMM3 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP43P3DM_top):
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL(K_GTP43P3DM_skip) )
-
-	MOVSS( S(0), XMM4 )				/* ox */
-	SHUFPS( CONST(0x0), XMM4, XMM4 )		/* ox | ox | ox | ox */
-	MULPS( XMM0, XMM4 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM5 )				/* oy */
-	SHUFPS( CONST(0x0), XMM5, XMM5 )		/* oy | oy | oy | oy */
-	MULPS( XMM1, XMM5 )				/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
-
-	MOVSS( S(2), XMM6 )				/* oz */
-	SHUFPS( CONST(0x0), XMM6, XMM6 )		/* oz | oz | oz | oz */
-	MULPS( XMM2, XMM6 )				/* oz*m11 | oz*m10 | oz*m9 | oz*m8 */
-
-	MOVSS( S(3), XMM7 )				/* ow */
-	SHUFPS( CONST(0x0), XMM7, XMM7 )		/* ow | ow | ow | ow */
-	MULPS( XMM3, XMM7 )				/* ow*m15 | ow*m14 | ow*m13 | ow*m12 */
-
-	ADDPS( XMM5, XMM4 )				/* ox*m3+oy*m7 | ... */
-	ADDPS( XMM6, XMM4 )				/* ox*m3+oy*m7+oz*m11 | ... */
-	ADDPS( XMM7, XMM4 )				/* ox*m3+oy*m7+oz*m11+ow*m15 | ... */
-	MOVAPS( XMM4, D(0) )				/* ->D(3) | ->D(2) | ->D(1) | ->D(0) */
-
-	MOVSS( S(3), XMM4 )				/* ow */
-	MOVSS( XMM4, D(3) )				/* ->D(3) */
-
-LLBL(K_GTP43P3DM_skip):
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP43P3DM_top) )
-
-LLBL(K_GTP43P3DM_finish):
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_xform_raw1.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_raw1.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_raw1.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_raw1.S:1.6	Mon Nov 13 18:31:13 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_raw1.S	Thu Feb 27 12:15:55 2003
@@ -1,442 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define S(i) 	REGOFF(i * 4, ESI)
-#define D(i) 	REGOFF(i * 4, EDI)
-#define M(i) 	REGOFF(i * 4, EDX)
-
-/*
- * 	Offsets into GLvector4f
- */
-#define V4F_DATA 	0
-#define V4F_START 	4
-#define V4F_COUNT 	8
-#define V4F_STRIDE 	12
-#define V4F_SIZE 	16
-#define V4F_FLAGS 	20
-
-#define VEC_SIZE_1   1
-#define VEC_SIZE_2   3
-#define VEC_SIZE_3   7
-#define VEC_SIZE_4   15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST 4
-#define OFFSET_MATRIX 8
-#define OFFSET_SOURCE 12
-#define OFFSET_CLIP 16
-#define OFFSET_FLAG 20
-
-#define ARG_DEST 	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_general_raw)
-GLNAME( gl_katmai_transform_points1_general_raw ):
-
-#define FRAME_OFFSET 8
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    CMP_L( CONST(0), ECX )			/* count == 0 ? */
-    JE( LLBL(K_GTP1GR_finish) )			/* yes -> nothing to do. */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  | m0  */
-    MOVAPS( M(12), XMM1 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP1GR_top):
-    MOVSS( S(0), XMM2 )				/* ox */
-    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* ox | ox | ox | ox */
-    MULPS( XMM0, XMM2 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-    ADDPS( XMM1, XMM2 )				/* + | + | + | + */
-    MOVUPS( XMM2, D(0) )
-
-LLBL(K_GTP1GR_skip):
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP1GR_top) )
-
-LLBL(K_GTP1GR_finish):
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_identity_raw)
-GLNAME( gl_katmai_transform_points1_identity_raw ):
-
-#define FRAME_OFFSET 8
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP1IR_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_1), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(1), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-    CMP_L( ESI, EDI )
-    JE( LLBL(K_GTP1IR_finish) )
-
-
-ALIGNTEXT32
-LLBL(K_GTP1IR_top):
-    MOV_L( S(0), EDX )
-    MOV_L( EDX, D(0) )
-
-LLBL(K_GTP1IR_skip):
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP1IR_top) )
-
-LLBL(K_GTP1IR_finish):
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_3d_no_rot_raw)
-GLNAME(gl_katmai_transform_points1_3d_no_rot_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI )	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP13DNRR_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVSS( M(0), XMM0 )				/* m0 */
-    MOVSS( M(12), XMM1 )			/* m12 */
-    MOVSS( M(13), XMM2 )			/* m13 */
-    MOVSS( M(14), XMM3 )			/* m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP13DNRR_top):
-    MOVSS( S(0), XMM4 )				/* ox */
-    MULSS( XMM0, XMM4 )				/* ox*m0 */
-    ADDSS( XMM1, XMM4 )				/* ox*m0+m12 */
-    MOVSS( XMM4, D(0) )
-
-    MOVSS( XMM2, D(1) )
-    MOVSS( XMM3, D(2) )
-
-LLBL(K_GTP13DNRR_skip):
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP13DNRR_top) )
-
-LLBL(K_GTP13DNRR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_perspective_raw)
-GLNAME(gl_katmai_transform_points1_perspective_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L   ( ESI )
-    PUSH_L   ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP13PR_finish) )		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    XORPS( XMM0, XMM0 )				/* 0 | 0 | 0 | 0 */
-    MOVSS( M(0), XMM1 )				/* m0 */
-    MOVSS( M(14), XMM2 )			/* m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP13PR_top):
-    MOVSS( S(0), XMM3 )				/* ox */
-    MULSS( XMM1, XMM3 )				/* ox*m0 */
-    MOVSS( XMM3, D(0) )				/* ox*m0->D(0) */
-    MOVSS( XMM2, D(2) )				/* m14->D(2) */
-
-    MOVSS( XMM0, D(1) )
-    MOVSS( XMM0, D(3) )
-
-LLBL(K_GTP13PR_skip):
-    ADD_L( CONST(16), EDI )
-    ADD_L( EAX, ESI )
-    CMP_L( ECX, EDI )
-    JNE( LLBL(K_GTP13PR_top) )
-
-LLBL(K_GTP13PR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_2d_raw)
-GLNAME(gl_katmai_transform_points1_2d_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP13P2DR_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVLPS( M(0), XMM0 )			/* m1  | m0  */
-    MOVLPS( M(12), XMM1 )			/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP13P2DR_top):
-    MOVSS( S(0), XMM2 )				/* ox */
-    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* ox | ox | ox | ox */
-    MULPS( XMM0, XMM2 )				/* - | - | ox*m1 | ox*m0 */
-    ADDPS( XMM1, XMM2 )				/* - | - | ox*m1+m13 | ox*m0+m12 */
-    MOVLPS( XMM2, D(0) )
-
-LLBL(K_GTP13P2DR_skip):
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP13P2DR_top) )
-
-LLBL(K_GTP13P2DR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_2d_no_rot_raw)
-GLNAME(gl_katmai_transform_points1_2d_no_rot_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP13P2DNRR_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS( M(0), XMM0 )			/* m0 */
-	MOVSS( M(12), XMM1 )			/* m12 */
-	MOVSS( M(13), XMM2 )			/* m13 */
-
-ALIGNTEXT32
-LLBL(K_GTP13P2DNRR_top):
-	MOVSS( S(0), XMM3 )			/* ox */
-	MULSS( XMM0, XMM3 )			/* ox*m0 */
-	ADDSS( XMM1, XMM3 )			/* ox*m0+m12 */
-	MOVSS( XMM3, D(0) )
-	MOVSS( XMM2, D(1) )
-
-LLBL(K_GTP13P2DNRR_skip):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP13P2DNRR_top) )
-
-LLBL(K_GTP13P2DNRR_finish):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points1_3d_raw)
-GLNAME(gl_katmai_transform_points1_3d_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP13P3DR_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  |  m0 */
-	MOVAPS( M(12), XMM1 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP13P3DR_top):
-	MOVSS( S(0), XMM2 )			/* ox */
-	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* ox | ox | ox | ox */
-	MULPS( XMM0, XMM2 )			/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-	ADDPS( XMM1, XMM2 )			/* +m15  | +m14  | +m13  | +m12  */
-	MOVLPS( XMM2, D(0) )			/*   -   |   -   | ->D(1)| ->D(0)*/
-	UNPCKHPS( XMM2, XMM2 )			/* ox*m3+m15 | ox*m3+m15 | ox*m2+m14 | ox*m2+m14 */
-	MOVSS( XMM2, D(2) )
-
-LLBL(K_GTP13P3DR_skip):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP13P3DR_top) )
-
-LLBL(K_GTP13P3DR_finish):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_xform_raw2.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_raw2.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_raw2.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_raw2.S:1.6	Mon Nov 13 18:31:13 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_raw2.S	Thu Feb 27 12:15:55 2003
@@ -1,461 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define S(i) 	REGOFF(i * 4, ESI)
-#define D(i) 	REGOFF(i * 4, EDI)
-#define M(i) 	REGOFF(i * 4, EDX)
-
-/*
- * 	Offsets into GLvector4f
- */
-#define V4F_DATA 	0
-#define V4F_START 	4
-#define V4F_COUNT 	8
-#define V4F_STRIDE 	12
-#define V4F_SIZE 	16
-#define V4F_FLAGS 	20
-
-#define VEC_SIZE_1   1
-#define VEC_SIZE_2   3
-#define VEC_SIZE_3   7
-#define VEC_SIZE_4   15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST 4
-#define OFFSET_MATRIX 8
-#define OFFSET_SOURCE 12
-#define OFFSET_CLIP 16
-#define OFFSET_FLAG 20
-
-#define ARG_DEST 	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_general_raw)
-GLNAME( gl_katmai_transform_points2_general_raw ):
-
-#define FRAME_OFFSET 8
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX )
-    JZ( LLBL(K_GTP2GR_finish) )			/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  | m0 */
-    MOVAPS( M(4), XMM1 )			/* m7  | m6  | m5  | m4 */
-    MOVAPS( M(12), XMM2 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP2GR_top):
-    MOVSS( S(0), XMM3 )				/* ox */
-    SHUFPS( CONST(0x0), XMM3, XMM3 )		/* ox | ox | ox | ox */
-    MULPS( XMM0, XMM3 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-    MOVSS( S(1), XMM4 )				/* oy */
-    SHUFPS( CONST(0x0), XMM4, XMM4 )		/* oy | oy | oy | oy */
-    MULPS( XMM1, XMM4 )				/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
-
-    ADDPS( XMM4, XMM3 )
-    ADDPS( XMM2, XMM3 )
-    MOVAPS( XMM3, D(0) )
-
-LLBL(K_GTP2GR_skip):
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP2GR_top) )
-
-LLBL(K_GTP2GR_finish):
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_identity_raw)
-GLNAME( gl_katmai_transform_points2_identity_raw ):
-
-#define FRAME_OFFSET 8
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) /* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP2IR_finish) )			/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-    CMP_L( ESI, EDI )
-    JE( LLBL(K_GTP2IR_finish) )
-
-
-ALIGNTEXT32
-LLBL(K_GTP2IR_top):
-    MOV_L     ( S(0), EDX )
-    MOV_L     ( EDX, D(0) )
-    MOV_L     ( S(1), EDX )
-    MOV_L     ( EDX, D(1) )
-
-LLBL(K_GTP2IR_skip):
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTP2IR_top) )
-
-LLBL(K_GTP2IR_finish):
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_3d_no_rot_raw)
-GLNAME(gl_katmai_transform_points2_3d_no_rot_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP23DNRR_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* - | - |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* - | - |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* - | - | m5  | m0  */
-    MOVLPS   ( M(12), XMM2 )			/* - | - | m13 | m12 */
-    MOVSS    ( M(14), XMM3 )			/* - | - |  -  | m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP23DNRR_top):
-    MOVLPS   ( S(0), XMM0 )			/* - | - |  oy   | ox */
-    MULPS    ( XMM1, XMM0 )			/* - | - | oy*m5 | ox*m0 */
-    ADDPS    ( XMM2, XMM0 )			/* - | - | +m13  | +m12 */
-    MOVLPS   ( XMM0, D(0) )			/* -> D(1) | -> D(0) */
-
-    MOVSS    ( XMM3, D(2) )			/* -> D(2) */
-
-LLBL(K_GTP23DNRR_skip):
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP23DNRR_top) )
-
-LLBL(K_GTP23DNRR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_perspective_raw)
-GLNAME(gl_katmai_transform_points2_perspective_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L   ( ESI )
-    PUSH_L   ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI )	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP23PR_finish) )		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* -  | -  |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* -  | -  |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* -  | -  | m5  | m0  */
-    MOVSS    ( M(14), XMM3 )			/* m14 */
-    XORPS    ( XMM0, XMM0 )			/* 0 | 0 | 0 | 0 */
-
-ALIGNTEXT32
-LLBL(K_GTP23PR_top):
-    MOVLPS( S(0), XMM4 )			/* oy | ox */
-    MULPS( XMM1, XMM4 )				/* oy*m5 | ox*m0 */
-    MOVLPS( XMM4, D(0) )			/* ->D(1) | ->D(0) */
-    MOVSS( XMM3, D(2) )				/* ->D(2) */
-    MOVSS( XMM0, D(3) )				/* ->D(3) */
-
-LLBL(K_GTP23PR_skip):
-    ADD_L( CONST(16), EDI )
-    ADD_L( EAX, ESI )
-    CMP_L( ECX, EDI )
-    JNE( LLBL(K_GTP23PR_top) )
-
-LLBL(K_GTP23PR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_2d_raw)
-GLNAME(gl_katmai_transform_points2_2d_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP23P2DR_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVLPS( M(0), XMM0 )			/* m1  | m0 */
-    MOVLPS( M(4), XMM1 )			/* m5  | m4 */
-    MOVLPS( M(12), XMM2 )			/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP23P2DR_top):
-    MOVSS( S(0), XMM3 )				/* ox */
-    SHUFPS( CONST(0x0), XMM3, XMM3 )		/* ox | ox */
-    MULPS( XMM0, XMM3 )				/* ox*m1 | ox*m0 */
-
-    MOVSS( S(1), XMM4 )				/* oy */
-    SHUFPS( CONST(0x0), XMM4, XMM4 )		/* oy | oy */
-    MULPS( XMM1, XMM4 )				/* oy*m5 | oy*m4 */
-
-    ADDPS( XMM4, XMM3 )
-    ADDPS( XMM2, XMM3 )
-    MOVLPS( XMM3, D(0) )			/* ->D(1) | ->D(0) */
-
-LLBL(K_GTP23P2DR_skip):
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP23P2DR_top) )
-
-LLBL(K_GTP23P2DR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_2d_no_rot_raw)
-GLNAME(gl_katmai_transform_points2_2d_no_rot_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP23P2DNRR_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS    ( M(0), XMM1 )			/* m0 */
-	MOVSS    ( M(5), XMM2 )			/* m5 */
-	UNPCKLPS ( XMM2, XMM1 )			/* m5 | m0 */
-	MOVLPS   ( M(12), XMM2 )		/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP23P2DNRR_top):
-	MOVLPS( S(0), XMM0 )			/* oy | ox */
-	MULPS( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
-	ADDPS( XMM2, XMM0 )			/* +m13 | +m12 */
-	MOVLPS( XMM0, D(0) )			/* ->D(1) | ->D(0) */
-
-LLBL(K_GTP23P2DNRR_skip):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP23P2DNRR_top) )
-
-LLBL(K_GTP23P2DNRR_finish):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points2_3d_raw)
-GLNAME(gl_katmai_transform_points2_3d_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP23P3DR_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )			/* m2  | m1  | m0 */
-	MOVAPS( M(4), XMM1 )			/* m6  | m5  | m4 */
-	MOVAPS( M(12), XMM2 )			/* m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP23P3DR_top):
-	MOVSS( S(0), XMM3 )			/* ox */
-	SHUFPS( CONST(0x0), XMM3, XMM3 )	/* ox | ox | ox */
-	MULPS( XMM0, XMM3 )			/* ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM4 )			/* oy */
-	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* oy | oy | oy */
-	MULPS( XMM1, XMM4 )			/* oy*m6 | oy*m5 | oy*m4 */
-
-	ADDPS( XMM4, XMM3 )
-	ADDPS( XMM2, XMM3 )
-
-	MOVLPS( XMM3, D(0) )			/* ->D(1) | ->D(0) */
-	UNPCKHPS( XMM3, XMM3 )
-	MOVSS( XMM3, D(2) )			/* ->D(2) */
-
-LLBL(K_GTP23P3DR_skip):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP23P3DR_top) )
-
-LLBL(K_GTP23P3DR_finish):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_xform_raw3.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_raw3.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_raw3.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_raw3.S:1.6	Mon Nov 13 18:31:14 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_raw3.S	Thu Feb 27 12:15:55 2003
@@ -1,507 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-   SEG_TEXT
-
-
-#define S(i) 	REGOFF(i * 4, ESI)
-#define D(i) 	REGOFF(i * 4, EDI)
-#define M(i) 	REGOFF(i * 4, EDX)
-
-/*
- * 	Offsets into GLvector4f
- */
-#define V4F_DATA 	0
-#define V4F_START 	4
-#define V4F_COUNT 	8
-#define V4F_STRIDE 	12
-#define V4F_SIZE 	16
-#define V4F_FLAGS 	20
-
-#define VEC_SIZE_1   1
-#define VEC_SIZE_2   3
-#define VEC_SIZE_3   7
-#define VEC_SIZE_4   15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST 4
-#define OFFSET_MATRIX 8
-#define OFFSET_SOURCE 12
-#define OFFSET_CLIP 16
-#define OFFSET_FLAG 20
-
-#define ARG_DEST 	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_general_raw)
-GLNAME( gl_katmai_transform_points3_general_raw ):
-
-#define FRAME_OFFSET 8
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    CMP_L     ( CONST(0), ECX )			/* count == 0 ? */
-    JE        ( LLBL(K_GTPGR_finish) )		/* yes -> nothing to do. */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVAPS    ( REGOFF(0, EDX), XMM0 )	/* m0  | m1  | m2  | m3 */
-    MOVAPS    ( REGOFF(16, EDX), XMM1 )	/* m4  | m5  | m6  | m7 */
-    MOVAPS    ( REGOFF(32, EDX), XMM2 )	/* m8  | m9  | m10 | m11 */
-    MOVAPS    ( REGOFF(48, EDX), XMM3 )	/* m12 | m13 | m14 | m15 */
-
-
-ALIGNTEXT32
-LLBL(K_GTPGR_top):
-    MOVSS     ( REGOFF(0, ESI), XMM4 )		/*    |    |    | ox */
-    SHUFPS    ( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox | ox */
-    MOVSS     ( REGOFF(4, ESI), XMM5 )		/*    |    |    | oy */
-    SHUFPS    ( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy | oy */
-    MOVSS     ( REGOFF(8, ESI), XMM6 )		/*    |    |    | oz */
-    SHUFPS    ( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz | oz */
-
-    MULPS     ( XMM0, XMM4 )		/* m3*ox  | m2*ox  | m1*ox | m0*ox */
-    MULPS     ( XMM1, XMM5 )		/* m7*oy  | m6*oy  | m5*oy | m4*oy */
-    MULPS     ( XMM2, XMM6 )		/* m11*oz | m10*oz | m9*oz | m8*oz */
-
-    ADDPS     ( XMM5, XMM4 )
-    ADDPS     ( XMM6, XMM4 )
-    ADDPS     ( XMM3, XMM4 )
-
-    MOVAPS    ( XMM4, REGOFF(0, EDI) )
-
-LLBL(K_GTPGR_skip):
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTPGR_top) )
-
-LLBL(K_GTPGR_finish):
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_identity_raw)
-GLNAME( gl_katmai_transform_points3_identity_raw ):
-
-#define FRAME_OFFSET 8
-    PUSH_L    ( ESI )
-    PUSH_L    ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTPIR_finish) ) 			/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-    CMP_L( ESI, EDI )
-    JE( LLBL(K_GTPIR_finish) )
-
-
-ALIGNTEXT32
-LLBL(K_GTPIR_top):
-    MOVLPS    ( S(0), XMM0 )
-    MOVLPS    ( XMM0, D(0) )
-    MOVSS     ( S(2), XMM0 )
-    MOVSS     ( XMM0, D(2) )
-
-LLBL(K_GTPIR_skip):
-    ADD_L     ( CONST(16), EDI )
-    ADD_L     ( EAX, ESI )
-    CMP_L     ( ECX, EDI )
-    JNE       ( LLBL(K_GTPIR_top) )
-
-LLBL(K_GTPIR_finish):
-    POP_L     ( EDI )
-    POP_L     ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_3d_no_rot_raw)
-GLNAME(gl_katmai_transform_points3_3d_no_rot_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP3DNRR_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* - | - |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* - | - |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* - | - | m5  | m0  */
-    MOVLPS   ( M(12), XMM2 )			/* - | - | m13 | m12 */
-    MOVSS    ( M(10), XMM3 )			/* - | - |  -  | m10 */
-    MOVSS    ( M(14), XMM4 )			/* - | - |  -  | m14 */
-
-ALIGNTEXT32
-LLBL(K_GTP3DNRR_top):
-
-    MOVLPS   ( S(0), XMM0 )			/* - | - |  s1   | s0 */
-    MULPS    ( XMM1, XMM0 )			/* - | - | s1*m5 | s0*m0 */
-    ADDPS    ( XMM2, XMM0 )			/* - | - | +m13  | +m12 */
-    MOVLPS   ( XMM0, D(0) )			/* -> D(1) | -> D(0) */
-
-    MOVSS    ( S(2), XMM0 )			/* sz */
-    MULSS    ( XMM3, XMM0 )			/* sz*m10 */
-    ADDSS    ( XMM4, XMM0 )			/* +m14 */
-    MOVSS    ( XMM0, D(2) )			/* -> D(2) */
-
-LLBL(K_GTP3DNRR_skip):
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP3DNRR_top) )
-
-LLBL(K_GTP3DNRR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_perspective_raw)
-GLNAME(gl_katmai_transform_points3_perspective_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L   ( ESI )
-    PUSH_L   ( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP3PR_finish) )			/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVSS    ( M(0), XMM1 )			/* -  | -  |  -  | m0  */
-    MOVSS    ( M(5), XMM2 )			/* -  | -  |  -  | m5  */
-    UNPCKLPS ( XMM2, XMM1 )			/* -  | -  | m5  | m0  */
-    MOVLPS   ( M(8), XMM2 )			/* -  | -  | m9  | m8  */
-    MOVSS    ( M(10), XMM3 )			/* m10 */
-    MOVSS    ( M(14), XMM4 )			/* m14 */
-    XORPS    ( XMM6, XMM6 )			/* 0 */
-
-ALIGNTEXT32
-LLBL(K_GTP3PR_top):
-    MOVLPS   ( S(0), XMM0 )			/* oy | ox */
-    MULPS    ( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
-    MOVSS    ( S(2), XMM5 )			/* oz */
-    SHUFPS   ( CONST(0x0), XMM5, XMM5 )		/* oz | oz */
-    MULPS    ( XMM2, XMM5 )			/* oz*m9 | oz*m8 */
-    ADDPS    ( XMM5, XMM0 )			/* +oy*m5 | +ox*m0 */
-    MOVLPS   ( XMM0, D(0) )			/* ->D(1) | ->D(0) */
-
-    MOVSS    ( S(2), XMM0 )			/* oz */
-    MULSS    ( XMM3, XMM0 )			/* oz*m10 */
-    ADDSS    ( XMM4, XMM0 )			/* +m14 */
-    MOVSS    ( XMM0, D(2) )			/* ->D(2) */
-
-    MOVSS    ( S(2), XMM0 )			/* oz */
-    MOVSS    ( XMM6, XMM5 )			/* 0 */
-    SUBPS    ( XMM0, XMM5 )			/* -oz */
-    MOVSS    ( XMM5, D(3) )			/* ->D(3) */
-
-LLBL(K_GTP3PR_skip):
-    ADD_L( CONST(16), EDI )
-    ADD_L( EAX, ESI )
-    CMP_L( ECX, EDI )
-    JNE( LLBL(K_GTP3PR_top) )
-
-LLBL(K_GTP3PR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_2d_raw)
-GLNAME(gl_katmai_transform_points3_2d_raw):
-
-#define FRAME_OFFSET 8
-    PUSH_L( ESI )
-    PUSH_L( EDI )
-
-    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
-    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-    TEST_L( ECX, ECX)
-    JZ( LLBL(K_GTP3P2DR_finish) ) 		/* count was zero; go to finish */
-
-    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-    ADD_L( EDI, ECX ) 				/* count += dest ptr */
-
-ALIGNTEXT32
-    MOVLPS( M(0), XMM0 )			/* m1  | m0 */
-    MOVLPS( M(4), XMM1 )			/* m5  | m4 */
-    MOVLPS( M(12), XMM2 )			/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP3P2DR_top):
-    MOVSS    ( S(0), XMM3 )			/* ox */
-    SHUFPS   ( CONST(0x0), XMM3, XMM3 )		/* ox | ox */
-    MULPS    ( XMM0, XMM3 )			/* ox*m1 | ox*m0 */
-    MOVSS    ( S(1), XMM4 )			/* oy */
-    SHUFPS   ( CONST(0x0), XMM4, XMM4 )		/* oy | oy */
-    MULPS    ( XMM1, XMM4 )			/* oy*m5 | oy*m4 */
-
-    ADDPS    ( XMM4, XMM3 )
-    ADDPS    ( XMM2, XMM3 )
-    MOVLPS   ( XMM3, D(0) )
-
-    MOVSS    ( S(2), XMM3 )
-    MOVSS    ( XMM3, D(2) )
-
-LLBL(K_GTP3P2DR_skip):
-    ADD_L    ( CONST(16), EDI )
-    ADD_L    ( EAX, ESI )
-    CMP_L    ( ECX, EDI )
-    JNE      ( LLBL(K_GTP3P2DR_top) )
-
-LLBL(K_GTP3P2DR_finish):
-    POP_L    ( EDI )
-    POP_L    ( ESI )
-    RET
-#undef FRAME_OFFSET
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_2d_no_rot_raw)
-GLNAME(gl_katmai_transform_points3_2d_no_rot_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP3P2DNRR_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-ALIGNTEXT32
-	MOVSS    ( M(0), XMM1 )			/* m0 */
-	MOVSS    ( M(5), XMM2 )			/* m5 */
-	UNPCKLPS ( XMM2, XMM1 )			/* m5 | m0 */
-	MOVLPS   ( M(12), XMM2 )		/* m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP3P2DNRR_top):
-	MOVLPS( S(0), XMM0 )			/* oy | ox */
-	MULPS( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
-	ADDPS( XMM2, XMM0 )			/* +m13 | +m12 */
-	MOVLPS( XMM0, D(0) )			/* ->D(1) | ->D(0) */
-
-	MOVSS( S(2), XMM0 )
-	MOVSS( XMM0, D(2) )
-
-LLBL(K_GTP3P2DNRR_skip):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP3P2DNRR_top) )
-
-LLBL(K_GTP3P2DNRR_finish):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME(gl_katmai_transform_points3_3d_raw)
-GLNAME(gl_katmai_transform_points3_3d_raw):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
-	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
-
-
-	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP3P3DR_finish) ) 	/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
-
-	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX ) 			/* count += dest ptr */
-
-
-ALIGNTEXT32
-	MOVAPS( M(0), XMM0 )			/* m2  | m1  | m0 */
-	MOVAPS( M(4), XMM1 )			/* m6  | m5  | m4 */
-	MOVAPS( M(8), XMM2 )			/* m10 | m9  | m8 */
-	MOVAPS( M(12), XMM3 )			/* m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL(K_GTP3P3DR_top):
-	MOVSS( S(0), XMM4 )
-	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox */
-	MULPS( XMM0, XMM4 )			/* ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM5 )
-	SHUFPS( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy */
-	MULPS( XMM1, XMM5 )			/* oy*m6 | oy*m5 | oy*m4 */
-
-	MOVSS( S(2), XMM6 )
-	SHUFPS( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz */
-	MULPS( XMM2, XMM6 )			/* oz*m10 | oz*m9 | oz*m8 */
-
-	ADDPS( XMM5, XMM4 )			/* + | + | + */
-	ADDPS( XMM6, XMM4 )			/* + | + | + */
-	ADDPS( XMM3, XMM4 )			/* + | + | + */
-
-	MOVLPS( XMM4, D(0) )			/* => D(1) | => D(0) */
-	UNPCKHPS( XMM4, XMM4 )
-	MOVSS( XMM4, D(2) )
-
-LLBL(K_GTP3P3DR_skip):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP3P3DR_top) )
-
-LLBL(K_GTP3P3DR_finish):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/katmai_xform_raw4.S
diff -u xc/extras/Mesa/src/X86/katmai_xform_raw4.S:1.6 xc/extras/Mesa/src/X86/katmai_xform_raw4.S:removed
--- xc/extras/Mesa/src/X86/katmai_xform_raw4.S:1.6	Mon Nov 13 18:31:16 2000
+++ xc/extras/Mesa/src/X86/katmai_xform_raw4.S	Thu Feb 27 12:15:56 2003
@@ -1,193 +0,0 @@
-#include "assyntax.h"
-/** TODO:
-  * - insert PREFETCH instructions to avoid cache-misses !
-  * - some more optimizations are possible...
-  * - for 40-50% more performance in the SSE-functions, the
-  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
-  */
-
-	SEG_TEXT
-
-
-#define S(i)	REGOFF(i * 4, ESI)
-#define D(i)	REGOFF(i * 4, EDI)
-#define M(i)	REGOFF(i * 4, EDX)
-
-/*
- *	Offsets into GLvector4f
- */
-#define V4F_DATA	0
-#define V4F_START	4
-#define V4F_COUNT	8
-#define V4F_STRIDE	12
-#define V4F_SIZE	16
-#define V4F_FLAGS	20
-
-#define VEC_SIZE_1	1
-#define VEC_SIZE_2	3
-#define VEC_SIZE_3	7
-#define VEC_SIZE_4	15
-
-/*
- *	Offsets for transform_func arguments
- *
- *	typedef void (*transform_func)( GLvector4f *to_vec,
- *	                                const GLfloat m[16],
- *	                                const GLvector4f *from_vec,
- *	                                const GLubyte *clipmask,
- *	                                const GLubyte flag );
- */
-#define OFFSET_DEST	4
-#define OFFSET_MATRIX	8
-#define OFFSET_SOURCE	12
-#define OFFSET_CLIP	16
-#define OFFSET_FLAG	20
-
-#define ARG_DEST	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
-#define ARG_MATRIX	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
-#define ARG_SOURCE	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
-
-
-ALIGNTEXT4
-GLOBL GLNAME( gl_katmai_transform_points4_general_raw )
-GLNAME( gl_katmai_transform_points4_general_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )		/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX )		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )	/* source count */
-
-	CMP_L( CONST(0), ECX )			/* count == 0 ? */
-	JE( LLBL(K_GTP4GR_finish) )		/* yes -> nothing to do. */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )	/* stride */
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) /* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )	/* set dest count */
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )/* set dest size */
-
-	SHL_L( CONST(4), ECX )			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI )	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX )			/* count += dest ptr */
-
-	MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  | m0 */
-	MOVAPS( M(4), XMM1 )			/* m7  | m6  | m5  | m4 */
-	MOVAPS( M(8), XMM2 )			/* m11 | m10 | m9  | m8 */
-	MOVAPS( M(12), XMM3 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL( K_GTP4GR_top ):
-	MOVSS( S(0), XMM4 )			/* ox */
-	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox | ox */
-	MULPS( XMM0, XMM4 )			/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM5 )			/* oy */
-	SHUFPS( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy | oy */
-	MULPS( XMM1, XMM5 )			/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
-
-	MOVSS( S(2), XMM6 )			/* oz */
-	SHUFPS( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz | oz */
-	MULPS( XMM2, XMM6 )			/* oz*m11 | oz*m10 | oz*m9 | oz*m8 */
-
-	MOVSS( S(3), XMM7 )			/* ow */
-	SHUFPS( CONST(0x0), XMM7, XMM7 )	/* ow | ow | ow | ow */
-	MULPS( XMM3, XMM7 )			/* ow*m15 | ow*m14 | ow*m13 | ow*m12 */
-
-	ADDPS( XMM5, XMM4 )			/* ox*m3+oy*m7 | ... */
-	ADDPS( XMM6, XMM4 )			/* ox*m3+oy*m7+oz*m11 | ... */
-	ADDPS( XMM7, XMM4 )			/* ox*m3+oy*m7+oz*m11+ow*m15 | ... */
-	MOVAPS( XMM4, D(0) )			/* ->D(3) | ->D(2) | ->D(1) | ->D(0) */
-
-LLBL( K_GTP4GR_skip ):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP4GR_top) )
-
-LLBL( K_GTP4GR_finish ):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-ALIGNTEXT4
-GLOBL GLNAME( gl_katmai_transform_points4_3d_raw )
-GLNAME( gl_katmai_transform_points4_3d_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )		/* ptr to source GLvector4f */
-	MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
-
-	MOV_L( ARG_MATRIX, EDX )		/* ptr to matrix */
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )	/* source count */
-
-	TEST_L( ECX, ECX)
-	JZ( LLBL(K_GTP43P3DR_finish) )		/* count was zero; go to finish */
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )	/* stride */
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) /* set dest flags */
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )	/* set dest count */
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )/* set dest size */
-
-	SHL_L( CONST(4), ECX )			/* count *= 16 */
-	MOV_L( REGOFF(V4F_START, ESI), ESI )	/* ptr to first source vertex */
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )	/* ptr to first dest vertex */
-	ADD_L( EDI, ECX )			/* count += dest ptr */
-
-	MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  |  m0 */
-	MOVAPS( M(4), XMM1 )			/* m7  | m6  | m5  |  m4 */
-	MOVAPS( M(8), XMM2 )			/* m11 | m10 | m9  |  m8 */
-	MOVAPS( M(12), XMM3 )			/* m15 | m14 | m13 | m12 */
-
-ALIGNTEXT32
-LLBL( K_GTP43P3DR_top ):
-	MOVSS( S(0), XMM4 )			/* ox */
-	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox | ox */
-	MULPS( XMM0, XMM4 )			/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
-
-	MOVSS( S(1), XMM5 )			/* oy */
-	SHUFPS( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy | oy */
-	MULPS( XMM1, XMM5 )			/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
-
-	MOVSS( S(2), XMM6 )			/* oz */
-	SHUFPS( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz | oz */
-	MULPS( XMM2, XMM6 )			/* oz*m11 | oz*m10 | oz*m9 | oz*m8 */
-
-	MOVSS( S(3), XMM7 )			/* ow */
-	SHUFPS( CONST(0x0), XMM7, XMM7 )	/* ow | ow | ow | ow */
-	MULPS( XMM3, XMM7 )			/* ow*m15 | ow*m14 | ow*m13 | ow*m12 */
-
-	ADDPS( XMM5, XMM4 )			/* ox*m3+oy*m7 | ... */
-	ADDPS( XMM6, XMM4 )			/* ox*m3+oy*m7+oz*m11 | ... */
-	ADDPS( XMM7, XMM4 )			/* ox*m3+oy*m7+oz*m11+ow*m15 | ... */
-	MOVAPS( XMM4, D(0) )			/* ->D(3) | ->D(2) | ->D(1) | ->D(0) */
-
-	MOVSS( S(3), XMM4 )			/* ow */
-	MOVSS( XMM4, D(3) )			/* ->D(3) */
-
-LLBL( K_GTP43P3DR_skip ):
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL(K_GTP43P3DR_top) )
-
-LLBL( K_GTP43P3DR_finish ):
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/mmx.h
diff -u xc/extras/Mesa/src/X86/mmx.h:1.3 xc/extras/Mesa/src/X86/mmx.h:1.5
--- xc/extras/Mesa/src/X86/mmx.h:1.3	Mon Nov 13 16:55:48 2000
+++ xc/extras/Mesa/src/X86/mmx.h	Mon Dec 16 11:18:33 2002
@@ -1,9 +1,10 @@
+/* $Id: mmx.h,v 1.7 2002/10/22 23:38:09 alanh Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -24,54 +25,11 @@
  */
 
 
-
-
-
 #ifndef ASM_MMX_H
 #define ASM_MMX_H
 
-
 extern void _ASMAPI
-gl_mmx_blend_transparency( GLcontext *ctx, GLuint n, const GLubyte mask[],
-						   GLubyte rgba[][4], const GLubyte dest[][4] );
-
-
-void gl_mmx_set_blend_function( GLcontext *ctx )
-{
-   const GLenum eq = ctx->Color.BlendEquation;
-   const GLenum srcRGB = ctx->Color.BlendSrcRGB;
-   const GLenum dstRGB = ctx->Color.BlendDstRGB;
-   const GLenum srcA = ctx->Color.BlendSrcA;
-   const GLenum dstA = ctx->Color.BlendDstA;
-
-
-   if (srcRGB != srcA || dstRGB != dstA) {
-      ctx->Color.BlendFunc = blend_general;
-   }
-   else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_SRC_ALPHA
-       && dstRGB==GL_ONE_MINUS_SRC_ALPHA) {
-      ctx->Color.BlendFunc = gl_mmx_blend_transparency;
-   }
-   else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_ONE && dstRGB==GL_ONE) {
-      ctx->Color.BlendFunc = blend_add;
-   }
-   else if (((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_REVERSE_SUBTRACT_EXT)
-             && (srcRGB==GL_ZERO && dstRGB==GL_SRC_COLOR))
-            ||
-            ((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_SUBTRACT_EXT)
-             && (srcRGB==GL_DST_COLOR && dstRGB==GL_ZERO))) {
-      ctx->Color.BlendFunc = blend_modulate;
-   }
-   else if (eq==GL_MIN_EXT) {
-      ctx->Color.BlendFunc = blend_min;
-   }
-   else if (eq==GL_MAX_EXT) {
-      ctx->Color.BlendFunc = blend_max;
-   }
-   else {
-      ctx->Color.BlendFunc = blend_general;
-   }
-}
-
+_mesa_mmx_blend_transparency( GLcontext *ctx, GLuint n, const GLubyte mask[],
+                              GLubyte rgba[][4], const GLubyte dest[][4] );
 
 #endif
Index: xc/extras/Mesa/src/X86/mmx_blend.S
diff -u xc/extras/Mesa/src/X86/mmx_blend.S:1.3 xc/extras/Mesa/src/X86/mmx_blend.S:1.5
--- xc/extras/Mesa/src/X86/mmx_blend.S:1.3	Mon Nov 13 16:55:48 2000
+++ xc/extras/Mesa/src/X86/mmx_blend.S	Mon Sep  9 17:30:02 2002
@@ -1,352 +1,418 @@
-#include "assyntax.h"
+/*
+ * Written by José Fonseca <j_r_fonseca@yahoo.co.uk>
+ */
+
+#include "matypes.h"
+
+/*
+ * make the following approximation to the division (Sree)
+ *
+ *   rgb*a/255 ~= (rgb*(a+1)) >> 256
+ *
+ * which is the fastest method that satisfies the following OpenGL criteria
+ *
+ *   0*0 = 0 and 255*255 = 255
+ *
+ * note this one should be used alone
+ */
+#define GMBT_ALPHA_PLUS_ONE	0
+
+/*
+ * take the geometric series approximation to the division
+ *
+ *   t/255 = (t >> 8) + (t >> 16) + (t >> 24) ..
+ *
+ * in this case just the first two terms to fit in 16bit arithmetic
+ *
+ *   t/255 ~= (t + (t >> 8)) >> 8
+ *
+ * note that just by itself it doesn't satisfies the OpenGL criteria, as 255*255 = 254, 
+ * so the special case a = 255 must be accounted or roundoff must be used
+ */
+#define GMBT_GEOMETRIC_SERIES	1
+
+/*
+ * when using a geometric series division instead of truncating the result 
+ * use roundoff in the approximation (Jim Blinn)
+ *
+ *   t = rgb*a + 0x80
+ *
+ * achieving the exact results
+ */
+#define GMBT_ROUNDOFF		0
+
+/* instead of the roundoff this adds a small correction to satisfy the OpenGL criteria
+ *
+ *   t/255 ~= (t + (t >> 8) + (t >> 15)) >> 8
+ *
+ * note that although is faster than rounding off it doesn't give always the exact results
+ */
+#define GMBT_GEOMETRIC_CORRECTION	1
+
+/*
+ * do
+ *
+ *   s = (q - p)*a + q
+ *
+ * instead of
+ *
+ *   s = p*a + q*(1-a)
+ *
+ * this eliminates a multiply at the expense of
+ * complicating the roundoff but is generally worth it
+ */
+#define GMBT_SIGNED_ARITHMETIC	1
+
+#if GMBT_ROUNDOFF
+    SEG_DATA
+
+ALIGNDATA8
+const_80:
+	D_LONG 0x00800080, 0x00800080
+#endif 
 
+   SEG_TEXT
 
-SEG_TEXT
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_mmx_blend_transparency)
 
+/*
+ * void blend_transparency( GLcontext *ctx,
+ *                          GLuint n, 
+ *                          const GLubyte mask[],
+ *                          GLchan rgba[][4], 
+ *                          CONST GLchan dest[][4] )
+ * 
+ * Common transparency blending mode.
+ */
+GLNAME( _mesa_mmx_blend_transparency ):
 
-ALIGNTEXT16
-GLOBL GLNAME(gl_mmx_blend_transparency)
+    PUSH_L     ( EBP )
+    MOV_L      ( ESP, EBP )
+    PUSH_L     ( ESI )
+    PUSH_L     ( EDI )
+    PUSH_L     ( EBX )
 
-GLNAME( gl_mmx_blend_transparency ):
-    PUSH_L    ( EBP )
-    MOV_L     ( ESP, EBP )
-    SUB_L     ( CONST(52), ESP )
-    PUSH_L    ( EBX )
-    MOV_L     ( CONST(16711680), REGOFF(-8, EBP) )
-    MOV_L     ( CONST(16711680), REGOFF(-4, EBP) )
-    MOV_L     ( CONST(0), REGOFF(-16, EBP) )
-    MOV_L     ( CONST(-1), REGOFF(-12, EBP) )
-    MOV_L     ( CONST(-1), REGOFF(-24, EBP) )
-    MOV_L     ( CONST(0), REGOFF(-20, EBP) )
-    MOV_L     ( REGOFF(24, EBP), EAX )
-    ADD_L     ( CONST(4), EAX )
-    MOV_L     ( EAX, EDX )
-    AND_L     ( REGOFF(20, EBP), EDX )
-    MOV_L     ( EDX, EAX )
-    AND_L     ( CONST(4), EAX )
-    CMP_L     ( CONST(8), EAX )
-    JNE       ( LLBL(GMBT_2) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    ADD_L     ( CONST(3), EAX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(EAX), DL )
-    MOV_L     ( EDX, REGOFF(-32, EBP) )
-    MOV_L     ( CONST(255), EAX )
-    MOV_L     ( EAX, EBX )
-    SUB_L     ( REGOFF(-32, EBP), EBX )
-    MOV_L     ( EBX, REGOFF(-36, EBP) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(EAX), DL )
-    MOV_L     ( EDX, EAX )
-    IMUL_L    ( REGOFF(-32, EBP), EAX )
-    MOV_L     ( REGOFF(24, EBP), EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EDX )
-    IMUL_L    ( REGOFF(-36, EBP), EDX )
-    ADD_L     ( EDX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-40, EBP) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    INC_L     ( EAX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(EAX), DL )
-    MOV_L     ( EDX, EAX )
-    IMUL_L    ( REGOFF(-32, EBP), EAX )
-    MOV_L     ( REGOFF(24, EBP), EDX )
-    INC_L     ( EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EDX )
-    IMUL_L    ( REGOFF(-36, EBP), EDX )
-    ADD_L     ( EDX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-44, EBP) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    ADD_L     ( CONST(2), EAX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(EAX), DL )
-    MOV_L     ( EDX, EAX )
-    IMUL_L    ( REGOFF(-32, EBP), EAX )
-    MOV_L     ( REGOFF(24, EBP), EDX )
-    ADD_L     ( CONST(2), EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EDX )
-    IMUL_L    ( REGOFF(-36, EBP), EDX )
-    ADD_L     ( EDX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-48, EBP) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    ADD_L     ( CONST(3), EAX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(EAX), DL )
-    MOV_L     ( EDX, EAX )
-    IMUL_L    ( REGOFF(-32, EBP), EAX )
-    MOV_L     ( REGOFF(24, EBP), EDX )
-    ADD_L     ( CONST(3), EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EDX )
-    IMUL_L    ( REGOFF(-36, EBP), EDX )
-    ADD_L     ( EDX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-52, EBP) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    MOV_B     ( REGOFF(-40, EBP), DL )
-    MOV_B     ( DL, REGIND(EAX) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    INC_L     ( EAX )
-    MOV_B     ( REGOFF(-44, EBP), DL )
-    MOV_B     ( DL, REGIND(EAX) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    ADD_L     ( CONST(2), EAX )
-    MOV_B     ( REGOFF(-48, EBP), DL )
-    MOV_B     ( DL, REGIND(EAX) )
-    MOV_L     ( REGOFF(20, EBP), EAX )
-    ADD_L     ( CONST(3), EAX )
-    MOV_B     ( REGOFF(-52, EBP), DL )
-    MOV_B     ( DL, REGIND(EAX) )
-    INC_L     ( REGOFF(16, EBP) )
-    ADD_L     ( CONST(4), REGOFF(20, EBP) )
-    ADD_L     ( CONST(4), REGOFF(24, EBP) )
-    DEC_L     ( REGOFF(12, EBP) )
-LLBL(GMBT_2):
-
-    CMP_L     ( CONST(0), REGOFF(12, EBP) )
-    JE        ( LLBL(GMBT_3) )
-    MOV_L     ( CONST(0), REGOFF(-28, EBP) )
-ALIGNTEXT4
-LLBL(GMBT_4):
-
-    MOV_L     ( REGOFF(12, EBP), EDX )
-    MOV_L     ( EDX, EAX )
-    SHR_L     ( CONST(1), EAX )
-    CMP_L     ( EAX, REGOFF(-28, EBP) )
-    JB        ( LLBL(GMBT_7) )
-    JMP       ( LLBL(GMBT_5) )
-ALIGNTEXT16
-LLBL(GMBT_7):
+    MOV_L      ( REGOFF(12, EBP), ECX )		/* n */
+    CMP_L      ( CONST(0), ECX)
+    JE         ( LLBL (GMBT_return) )
+
+    MOV_L      ( REGOFF(16, EBP), EBX )		/* mask */
+    MOV_L      ( REGOFF(20, EBP), EDI )         /* rgba */
+    MOV_L      ( REGOFF(24, EBP), ESI )         /* dest */
+    
+    TEST_L     ( CONST(4), EDI )		/* align rgba on an 8-byte boundary */
+    JZ         ( LLBL (GMBT_align_end) )
+
+    CMP_B      ( CONST(0), REGIND(EBX) )	/* *mask == 0 */
+    JE         ( LLBL (GMBT_align_continue) )
+
+    PXOR       ( MM0, MM0 )			/*   0x0000  |   0x0000  |   0x0000  |   0x0000  */
+
+    MOVD       ( REGIND(ESI), MM1 )		/*     |     |     |     | qa1 | qb1 | qg1 | qr1 */
+    MOVD       ( REGIND(EDI), MM2 )		/*     |     |     |     | pa1 | pb1 | pg1 | pr1 */
+
+    PUNPCKLBW  ( MM0, MM1 )			/*    qa1    |    qb1    |    qg1    |    qr1    */
+    PUNPCKLBW  ( MM0, MM2 )			/*    pa1    |    pb1    |    pg1    |    pr1    */
+
+    MOVQ       ( MM2, MM3 )
+
+    PUNPCKHWD  ( MM3, MM3 )			/*    pa1    |    pa1    |           |           */
+    PUNPCKHDQ  ( MM3, MM3 )                     /*    pa1    |    pa1    |    pa1    |    pa1    */
+
+#if GMBT_ALPHA_PLUS_ONE
+    PCMPEQW    ( MM4, MM4 )			/*   0xffff  |   0xffff  |   0xffff  |   0xffff  */
+
+    PSUBW      ( MM4, MM3 )                     /*   pa1 + 1 |   pa1 + 1 |   pa1 + 1 |   pa1 + 1 */
+#endif
+
+#if GMBT_SIGNED_ARITHMETIC
+    PSUBW      ( MM1, MM2 )                     /* pa1 - qa1 | pb1 - qb1 | pg1 - qg1 | pr1 - qr1 */
+
+    PSLLW      ( CONST(8), MM1 )		/*                    q1 << 8                    */
+
+#if GMBT_ROUNDOFF
+    MOVQ       ( MM2, MM4 )
+#endif
+
+    PMULLW     ( MM3, MM2 )			/*              t1 = (q1 - p1)*pa1               */
+
+#if GMBT_ROUNDOFF
+    PSRLW      ( CONST(15), MM4 )		/*                 q1 > p1 ? 1 : 0               */
+
+    PSLLW      ( CONST(8), MM4 )		/*             q1 > p1 ? 0x100 : 0               */
+
+    PSUBW      ( MM4, MM2 )                     /*                  t1 -=? 0x100                 */
+#endif
+
+#else
+    PCMPEQW    ( MM4, MM4 )			/*   0xffff  |   0xffff  |   0xffff  |   0xffff  */
+    PUNPCKLBW  ( MM0, MM4 )			/*   0x00ff  |   0x00ff  |   0x00ff  |   0x00ff  */
+    MOVQ       ( MM4, MM0 )
+    
+    PMULLW     ( MM3, MM2 )			/*                     p1*pa1                    */
+
+    PSUBW      ( MM3, MM0 )			/* 255 - pa1 | 255 - pa1 | 255 - pa1 | 255 - pa1 */
+
+    PMULLW     ( MM0, MM1 )			/*                  q1*(255 - pa1)               */
+
+    PADDW      ( MM1, MM2 )			/*           t1 = p1*pa1 + q1*(255 - pa1)        */
+#endif
 
-    MOV_L     ( REGOFF(-28, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,2), EDX )
-    MOV_L     ( REGOFF(16, EBP), EAX )
-    CMP_B     ( CONST(0), REGBI(EAX,EDX) )
-    JE        ( LLBL(GMBT_6) )
-    MOV_L     ( REGOFF(-28, EBP), EAX )
-    MOV_L     ( EAX, EDX )
-    LEA_L     ( REGDIS(0,EDX,8), ECX )
-    MOV_L     ( ECX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    MOV_L     ( REGOFF(-28, EBP), EDX )
-    MOV_L     ( EDX, ECX )
-    LEA_L     ( REGDIS(0,ECX,8), EDX )
-    MOV_L     ( EDX, ECX )
-    ADD_L     ( REGOFF(24, EBP), ECX )
-
-    MOVQ      ( REGIND(EAX), MM4 )
-    PXOR      ( MM5, MM5 )
-    MOVQ      ( MM4, MM1 )
-    MOVQ      ( REGIND(ECX), MM7 )
-    PUNPCKLBW ( MM5, MM1 )
-    MOVQ      ( MM7, MM6 )
-    MOVQ      ( MM1, MM0 )
-    PUNPCKLBW ( MM5, MM6 )
-    MOVQ      ( MM1, MM2 )
-    PSRLQ     ( CONST(48), MM0 )
-    PUNPCKHBW ( MM5, MM4 )
-    PACKSSDW  ( MM0, MM0 )
-    MOVQ      ( MM0, MM3 )
-    PUNPCKHBW ( MM5, MM7 )
-    PSLLQ     ( CONST(16), MM3 )
-    POR       ( REGOFF(-8, EBP), MM0 )
-    PUNPCKLWD ( MM6, MM1 )
-    PSUBW     ( MM3, MM0 )
-    PUNPCKHWD ( MM6, MM2 )
-    MOVQ      ( MM4, MM3 )
-    PSRLQ     ( CONST(48), MM3 )
-    PACKSSDW  ( MM3, MM3 )
-    MOVQ      ( MM3, MM6 )
-    POR       ( REGOFF(-8, EBP), MM3 )
-    PSLLQ     ( CONST(16), MM6 )
-    PSUBW     ( MM6, MM3 )
-    MOVQ      ( MM4, MM5 )
-    PUNPCKLWD ( MM7, MM4 )
-    PUNPCKHWD ( MM7, MM5 )
-    PMADDWD   ( MM0, MM1 )
-    PMADDWD   ( MM3, MM4 )
-    PMADDWD   ( MM0, MM2 )
-    PMADDWD   ( MM3, MM5 )
-    PSRLD     ( CONST(8), MM1 )
-    PSRLD     ( CONST(8), MM2 )
-    PSRLD     ( CONST(8), MM4 )
-    PACKSSDW  ( MM2, MM1 )
-    PSRLD     ( CONST(8), MM5 )
-    PACKUSWB  ( MM1, MM1 )
-    PACKSSDW  ( MM5, MM4 )
-    PAND      ( REGOFF(-24, EBP), MM1 )
-    PACKUSWB  ( MM4, MM4 )
-    PAND      ( REGOFF(-16, EBP), MM4 )
-    POR       ( MM1, MM4 )
-    MOVQ      ( MM4, REGIND(EAX) )
+#if GMBT_ROUNDOFF
+    MOVQ       ( CONTENT(const_80), MM4 )
 
+    PADDW      ( MM4, MM2 )                     /*                 t1 += 0x80                    */
+#endif
 
-LLBL(GMBT_8):
+#if GMBT_GEOMETRIC_SERIES
+    MOVQ       ( MM2, MM3 )
 
-LLBL(GMBT_6):
+    PSRLW      ( CONST(8), MM3 )		/*                    t1 >> 8                    */
 
-    INC_L     ( REGOFF(-28, EBP) )
-    JMP       ( LLBL(GMBT_4) )
+    PADDW      ( MM3, MM2 )			/*        t1 + (t1 >> 8) ~= (t1/255) << 8        */
+#endif
+
+#if GMBT_SIGNED_ARITHMETIC
+    PADDW      ( MM1, MM2 )			/*              (t1/255 + q1) << 8               */
+#endif
+
+    PSRLW      ( CONST(8), MM2 )		/*    sa1    |    sb1    |    sg1    |    sr1    */
+    
+    PACKUSWB   ( MM0, MM2 )			/*     |     |     |     | sa1 | sb1 | sg1 | sr1 */
+    MOVD       ( MM2, REGIND(EDI) )
+
+LLBL (GMBT_align_continue):
+
+    DEC_L      ( ECX )				/* n -= 1 */
+    INC_L      ( EBX )		                /* mask += 1 */
+    ADD_L      ( CONST(4), EDI )		/* rgba += 1 */
+    ADD_L      ( CONST(4), ESI )		/* dest += 1 */ 
+
+LLBL (GMBT_align_end):
+
+    CMP_L      ( CONST(2), ECX)
+    JB         ( LLBL (GMBT_loop_end) )
+
 ALIGNTEXT16
-LLBL(GMBT_5):
+LLBL (GMBT_loop_begin):
+
+    CMP_W      ( CONST(0), REGIND(EBX) )	/* *mask == 0 && *(mask + 1) == 0 */
+    JE         ( LLBL (GMBT_loop_continue) )
+
+    /* NOTE: the instruction pairing when multiple pipelines are available must be checked */
+
+    PXOR       ( MM0, MM0 )			/*   0x0000  |   0x0000  |   0x0000  |   0x0000  */
+
+    MOVQ       ( REGIND(ESI), MM7 )		/* qa2 | qb2 | qg2 | qr2 | qa1 | qb1 | qg1 | qr1 */
+    MOVQ       ( REGIND(EDI), MM6 )		/* pa2 | pb2 | pg2 | pr2 | pa1 | pb1 | pg1 | pr1 */
+
+    MOVQ       ( MM7, MM1 )
+    MOVQ       ( MM6, MM2 )
+
+    PUNPCKLBW  ( MM0, MM1 )			/*    qa1    |    qb1    |    qg1    |    qr1    */
+    PUNPCKHBW  ( MM0, MM7 )                     /*    qa2    |    qb2    |    qg2    |    qr2    */
+    PUNPCKLBW  ( MM0, MM2 )			/*    pa1    |    pb1    |    pg1    |    pr1    */
+    PUNPCKHBW  ( MM0, MM6 )                     /*    pa2    |    pb2    |    pg2    |    pr2    */
+
+    MOVQ       ( MM2, MM3 )
+    MOVQ       ( MM6, MM5 )
+
+    PUNPCKHWD  ( MM3, MM3 )			/*    pa1    |    pa1    |           |           */
+    PUNPCKHWD  ( MM5, MM5 )			/*    pa2    |    pa2    |           |           */
+    PUNPCKHDQ  ( MM3, MM3 )                     /*    pa1    |    pa1    |    pa1    |    pa1    */
+    PUNPCKHDQ  ( MM5, MM5 )                     /*    pa2    |    pa2    |    pa2    |    pa2    */
+
+#if GMBT_ALPHA_PLUS_ONE
+    PCMPEQW    ( MM4, MM4 )			/*   0xffff  |   0xffff  |   0xffff  |   0xffff  */
+
+    PSUBW      ( MM4, MM3 )                     /*   pa1 + 1 |   pa1 + 1 |   pa1 + 1 |   pa1 + 1 */
+    PSUBW      ( MM4, MM5 )                     /*   pa2 + 1 |   pa2 + 1 |   pa2 + 1 |   pa2 + 1 */
+#endif
+
+#if GMBT_SIGNED_ARITHMETIC
+    PSUBW      ( MM1, MM2 )                     /* pa1 - qa1 | pb1 - qb1 | pg1 - qg1 | pr1 - qr1 */
+    PSUBW      ( MM7, MM6 )                     /* pa2 - qa2 | pb2 - qb2 | pg2 - qg2 | pr2 - qr2 */
+
+    PSLLW      ( CONST(8), MM1 )		/*                    q1 << 8                    */
+    PSLLW      ( CONST(8), MM7 )		/*                    q2 << 8                    */
+
+#if GMBT_ROUNDOFF
+    MOVQ       ( MM2, MM0 )
+    MOVQ       ( MM6, MM4 )
+#endif
+
+    PMULLW     ( MM3, MM2 )			/*              t1 = (q1 - p1)*pa1               */
+    PMULLW     ( MM5, MM6 )			/*              t2 = (q2 - p2)*pa2               */
+
+#if GMBT_ROUNDOFF
+    PSRLW      ( CONST(15), MM0 )		/*                 q1 > p1 ? 1 : 0               */
+    PSRLW      ( CONST(15), MM4 )		/*                 q2 > q2 ? 1 : 0               */
+
+    PSLLW      ( CONST(8), MM0 )		/*             q1 > p1 ? 0x100 : 0               */
+    PSLLW      ( CONST(8), MM4 )		/*             q2 > q2 ? 0x100 : 0               */
+
+    PSUBW      ( MM0, MM2 )                     /*                  t1 -=? 0x100                 */
+    PSUBW      ( MM4, MM7 )                     /*                  t2 -=? 0x100                 */ 
+#endif
+
+#else
+    PCMPEQW    ( MM4, MM4 )			/*   0xffff  |   0xffff  |   0xffff  |   0xffff  */
+    PUNPCKLBW  ( MM0, MM4 )			/*   0x00ff  |   0x00ff  |   0x00ff  |   0x00ff  */
+    MOVQ       ( MM4, MM0 )
+    
+    PMULLW     ( MM3, MM2 )			/*                     p1*pa1                    */
+    PMULLW     ( MM5, MM6 )			/*                     p2*pa2                    */
+
+    PSUBW      ( MM3, MM0 )			/* 255 - pa1 | 255 - pa1 | 255 - pa1 | 255 - pa1 */
+    PSUBW      ( MM5, MM4 )			/* 255 - pa2 | 255 - pa2 | 255 - pa2 | 255 - pa2 */
+
+    PMULLW     ( MM0, MM1 )			/*                  q1*(255 - pa1)               */
+    PMULLW     ( MM4, MM7 )			/*                  q2*(255 - pa2)               */
+
+    PADDW      ( MM1, MM2 )			/*           t1 = p1*pa1 + q1*(255 - pa1)        */
+    PADDW      ( MM7, MM6 )			/*           t2 = p2*pa2 + q2*(255 - pa2)        */
+#endif
+
+#if GMBT_ROUNDOFF
+    MOVQ       ( CONTENT(const_80), MM4 )
+
+    PADDW      ( MM4, MM2 )                     /*                 t1 += 0x80                    */
+    PADDW      ( MM4, MM6 )                     /*                 t2 += 0x80                    */
+#endif
+
+#if GMBT_GEOMETRIC_SERIES
+    MOVQ       ( MM2, MM3 )
+    MOVQ       ( MM6, MM5 )
+
+    PSRLW      ( CONST(8), MM3 )		/*                    t1 >> 8                    */
+    PSRLW      ( CONST(8), MM5 )		/*                    t2 >> 8                    */
+
+    PADDW      ( MM3, MM2 )			/*        t1 + (t1 >> 8) ~= (t1/255) << 8        */
+    PADDW      ( MM5, MM6 )			/*        t2 + (t2 >> 8) ~= (t2/255) << 8        */
+
+#if GMBT_GEOMETRIC_CORRECTION 
+    PSRLW      ( CONST(7), MM3 )		/*                    t1 >> 15                   */
+    PSRLW      ( CONST(7), MM5 )		/*                    t2 >> 15                   */
+
+    PADDW      ( MM3, MM2 )			/*  t1 + (t1 >> 8) + (t1 >>15) ~= (t1/255) << 8  */
+    PADDW      ( MM5, MM6 )			/*  t2 + (t2 >> 8) + (t2 >>15) ~= (t2/255) << 8  */
+#endif
+#endif
+
+#if GMBT_SIGNED_ARITHMETIC
+    PADDW      ( MM1, MM2 )			/*              (t1/255 + q1) << 8               */
+    PADDW      ( MM7, MM6 )			/*              (t2/255 + q2) << 8               */
+#endif
+
+    PSRLW      ( CONST(8), MM2 )		/*    sa1    |    sb1    |    sg1    |    sr1    */
+    PSRLW      ( CONST(8), MM6 )		/*    sa2    |    sb2    |    sg2    |    sr2    */
+    
+    PACKUSWB   ( MM6, MM2 )			/* sa2 | sb2 | sg2 | sr2 | sa1 | sb1 | sg1 | sr1 */
+    MOVQ       ( MM2, REGIND(EDI) )
+
+LLBL (GMBT_loop_continue):
+
+    DEC_L      ( ECX )
+    DEC_L      ( ECX )				/* n -= 2 */
+    ADD_L      ( CONST(2), EBX )		/* mask += 2 */
+    ADD_L      ( CONST(8), EDI )		/* rgba += 2 */
+    ADD_L      ( CONST(8), ESI )		/* dest += 2 */ 
+    CMP_L      ( CONST(2), ECX )
+    JAE        ( LLBL (GMBT_loop_begin) )
+
+LLBL (GMBT_loop_end):
+
+    CMP_L      ( CONST(1), ECX )
+    JB         ( LLBL (GMBT_done) )
+
+    CMP_B      ( CONST(0), REGIND(EBX) )	/* *mask == 0 */
+    JE         ( LLBL (GMBT_done) )
+
+    PXOR       ( MM0, MM0 )			/*   0x0000  |   0x0000  |   0x0000  |   0x0000  */
+
+    MOVD       ( REGIND(ESI), MM1 )		/*     |     |     |     | qa1 | qb1 | qg1 | qr1 */
+    MOVD       ( REGIND(EDI), MM2 )		/*     |     |     |     | pa1 | pb1 | pg1 | pr1 */
+
+    PUNPCKLBW  ( MM0, MM1 )			/*    qa1    |    qb1    |    qg1    |    qr1    */
+    PUNPCKLBW  ( MM0, MM2 )			/*    pa1    |    pb1    |    pg1    |    pr1    */
+
+    MOVQ       ( MM2, MM3 )
+
+    PUNPCKHWD  ( MM3, MM3 )			/*    pa1    |    pa1    |           |           */
+    PUNPCKHDQ  ( MM3, MM3 )                     /*    pa1    |    pa1    |    pa1    |    pa1    */
+
+#if GMBT_ALPHA_PLUS_ONE
+    PCMPEQW    ( MM4, MM4 )			/*   0xffff  |   0xffff  |   0xffff  |   0xffff  */
+
+    PSUBW      ( MM4, MM3 )                     /*   pa1 + 1 |   pa1 + 1 |   pa1 + 1 |   pa1 + 1 */
+#endif
+
+#if GMBT_SIGNED_ARITHMETIC
+    PSUBW      ( MM1, MM2 )                     /* pa1 - qa1 | pb1 - qb1 | pg1 - qg1 | pr1 - qr1 */
+
+    PSLLW      ( CONST(8), MM1 )		/*                    q1 << 8                    */
+
+#if GMBT_ROUNDOFF
+    MOVQ       ( MM2, MM4 )
+#endif
+
+    PMULLW     ( MM3, MM2 )			/*              t1 = (q1 - p1)*pa1               */
+
+#if GMBT_ROUNDOFF
+    PSRLW      ( CONST(15), MM4 )		/*                 q1 > p1 ? 1 : 0               */
+
+    PSLLW      ( CONST(8), MM4 )		/*             q1 > p1 ? 0x100 : 0               */
+
+    PSUBW      ( MM4, MM2 )                     /*                  t1 -=? 0x100                 */
+#endif
+
+#else
+    PCMPEQW    ( MM4, MM4 )			/*   0xffff  |   0xffff  |   0xffff  |   0xffff  */
+    PUNPCKLBW  ( MM0, MM4 )			/*   0x00ff  |   0x00ff  |   0x00ff  |   0x00ff  */
+    MOVQ       ( MM4, MM0 )
+    
+    PMULLW     ( MM3, MM2 )			/*                     p1*pa1                    */
+
+    PSUBW      ( MM3, MM0 )			/* 255 - pa1 | 255 - pa1 | 255 - pa1 | 255 - pa1 */
+
+    PMULLW     ( MM0, MM1 )			/*                  q1*(255 - pa1)               */
+
+    PADDW      ( MM1, MM2 )			/*           t1 = p1*pa1 + q1*(255 - pa1)        */
+#endif
+
+#if GMBT_ROUNDOFF
+    MOVQ       ( CONTENT(const_80), MM4 )
+
+    PADDW      ( MM4, MM2 )                     /*                 t1 += 0x80                    */
+#endif
+
+#if GMBT_GEOMETRIC_SERIES
+    MOVQ       ( MM2, MM3 )
+
+    PSRLW      ( CONST(8), MM3 )		/*                    t1 >> 8                    */
+
+    PADDW      ( MM3, MM2 )			/*        t1 + (t1 >> 8) ~= (t1/255) << 8        */
+#endif
+
+#if GMBT_SIGNED_ARITHMETIC
+    PADDW      ( MM1, MM2 )			/*              (t1/255 + q1) << 8               */
+#endif
+
+    PSRLW      ( CONST(8), MM2 )		/*    sa1    |    sb1    |    sg1    |    sr1    */
+    
+    PACKUSWB   ( MM0, MM2 )			/*     |     |     |     | sa1 | sb1 | sg1 | sr1 */
+    MOVD       ( MM2, REGIND(EDI) )
 
+LLBL (GMBT_done):
 
     EMMS
 
-LLBL(GMBT_3):
+LLBL (GMBT_return):
 
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    AND_L     ( CONST(1), EAX )
-    TEST_L    ( EAX, EAX )
-    JE        ( LLBL(GMBT_9) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-1, EAX), EDX )
-    XOR_L     ( EAX, EAX )
-    MOV_B     ( REGIND(EDX), AL )
-    MOV_L     ( EAX, REGOFF(-52, EBP) )
-    MOV_L     ( CONST(255), EAX )
-    MOV_L     ( EAX, EBX )
-    SUB_L     ( REGOFF(-52, EBP), EBX )
-    MOV_L     ( EBX, REGOFF(-48, EBP) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-4, EAX), EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EAX )
-    IMUL_L    ( REGOFF(-52, EBP), EAX )
-    MOV_L     ( REGOFF(12, EBP), EDX )
-    LEA_L     ( REGDIS(0,EDX,4), ECX )
-    MOV_L     ( ECX, EDX )
-    ADD_L     ( REGOFF(24, EBP), EDX )
-    LEA_L     ( REGOFF(-4, EDX), ECX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(ECX), DL )
-    MOV_L     ( EDX, ECX )
-    IMUL_L    ( REGOFF(-48, EBP), ECX )
-    ADD_L     ( ECX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-44, EBP) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-3, EAX), EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EAX )
-    IMUL_L    ( REGOFF(-52, EBP), EAX )
-    MOV_L     ( REGOFF(12, EBP), EDX )
-    LEA_L     ( REGDIS(0,EDX,4), ECX )
-    MOV_L     ( ECX, EDX )
-    ADD_L     ( REGOFF(24, EBP), EDX )
-    LEA_L     ( REGOFF(-3, EDX), ECX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(ECX), DL )
-    MOV_L     ( EDX, ECX )
-    IMUL_L    ( REGOFF(-48, EBP), ECX )
-    ADD_L     ( ECX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-40, EBP) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-2, EAX), EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EAX )
-    IMUL_L    ( REGOFF(-52, EBP), EAX )
-    MOV_L     ( REGOFF(12, EBP), EDX )
-    LEA_L     ( REGDIS(0,EDX,4), ECX )
-    MOV_L     ( ECX, EDX )
-    ADD_L     ( REGOFF(24, EBP), EDX )
-    LEA_L     ( REGOFF(-2, EDX), ECX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(ECX), DL )
-    MOV_L     ( EDX, ECX )
-    IMUL_L    ( REGOFF(-48, EBP), ECX )
-    ADD_L     ( ECX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-36, EBP) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-1, EAX), EDX )
-    XOR_L     ( ECX, ECX )
-    MOV_B     ( REGIND(EDX), CL )
-    MOV_L     ( ECX, EAX )
-    IMUL_L    ( REGOFF(-52, EBP), EAX )
-    MOV_L     ( REGOFF(12, EBP), EDX )
-    LEA_L     ( REGDIS(0,EDX,4), ECX )
-    MOV_L     ( ECX, EDX )
-    ADD_L     ( REGOFF(24, EBP), EDX )
-    LEA_L     ( REGOFF(-1, EDX), ECX )
-    XOR_L     ( EDX, EDX )
-    MOV_B     ( REGIND(ECX), DL )
-    MOV_L     ( EDX, ECX )
-    IMUL_L    ( REGOFF(-48, EBP), ECX )
-    ADD_L     ( ECX, EAX )
-    MOV_L     ( EAX, EBX )
-    SAR_L     ( CONST(8), EBX )
-    MOV_L     ( EBX, REGOFF(-32, EBP) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-4, EAX), EDX )
-    MOV_B     ( REGOFF(-44, EBP), AL )
-    MOV_B     ( AL, REGIND(EDX) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-3, EAX), EDX )
-    MOV_B     ( REGOFF(-40, EBP), AL )
-    MOV_B     ( AL, REGIND(EDX) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-2, EAX), EDX )
-    MOV_B     ( REGOFF(-36, EBP), AL )
-    MOV_B     ( AL, REGIND(EDX) )
-    MOV_L     ( REGOFF(12, EBP), EAX )
-    LEA_L     ( REGDIS(0,EAX,4), EDX )
-    MOV_L     ( EDX, EAX )
-    ADD_L     ( REGOFF(20, EBP), EAX )
-    LEA_L     ( REGOFF(-1, EAX), EDX )
-    MOV_B     ( REGOFF(-32, EBP), AL )
-    MOV_B     ( AL, REGIND(EDX) )
-LLBL(GMBT_9):
-
-LLBL(GMBT_1):
-
-    MOV_L     ( REGOFF(-56, EBP), EBX )
-    MOV_L     ( EBP, ESP )
-    POP_L     ( EBP )
+    POP_L      ( EBX )
+    POP_L      ( EDI )
+    POP_L      ( ESI )
+    MOV_L      ( EBP, ESP )
+    POP_L      ( EBP )
     RET
Index: xc/extras/Mesa/src/X86/norm_args.h
diff -u /dev/null xc/extras/Mesa/src/X86/norm_args.h:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/norm_args.h	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,57 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Normal transform function interface for assembly code.  Simply define
+ * FRAME_OFFSET to the number of bytes pushed onto the stack before
+ * using the ARG_* argument macros.
+ *
+ * Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __NORM_ARGS_H__
+#define __NORM_ARGS_H__
+
+/* Offsets for normal_func arguments
+ *
+ * typedef void (*normal_func)( CONST GLmatrix *mat,
+ *                              GLfloat scale,
+ *                              CONST GLvector3f *in,
+ *                              CONST GLfloat lengths[],
+ *                              GLvector3f *dest );
+ */
+#define OFFSET_MAT	4
+#define OFFSET_SCALE	8
+#define OFFSET_IN	12
+#define OFFSET_LENGTHS	16
+#define OFFSET_DEST	20
+
+#define ARG_MAT         REGOFF(FRAME_OFFSET+OFFSET_MAT, ESP)
+#define ARG_SCALE       REGOFF(FRAME_OFFSET+OFFSET_SCALE, ESP)
+#define ARG_IN          REGOFF(FRAME_OFFSET+OFFSET_IN, ESP)
+#define ARG_LENGTHS     REGOFF(FRAME_OFFSET+OFFSET_LENGTHS, ESP)
+#define ARG_DEST        REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
+
+#endif
Index: xc/extras/Mesa/src/X86/sse.c
diff -u /dev/null xc/extras/Mesa/src/X86/sse.c:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse.c	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,135 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * PentiumIII-SIMD (SSE) optimizations contributed by
+ * Andre Werthmann <wertmann@cs.uni-potsdam.de>
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "math/m_vertices.h"
+#include "math/m_xform.h"
+#include "tnl/t_context.h"
+
+#include "sse.h"
+#include "common_x86_macros.h"
+
+#ifdef DEBUG
+#include "math/m_debug.h"
+#endif
+
+
+#ifdef USE_SSE_ASM
+DECLARE_XFORM_GROUP( sse, 2 )
+DECLARE_XFORM_GROUP( sse, 3 )
+
+#if 1
+/* Some functions are not written in SSE-assembly, because the fpu ones are faster */
+extern void _mesa_sse_transform_normals_no_rot( NORM_ARGS );
+extern void _mesa_sse_transform_rescale_normals( NORM_ARGS );
+extern void _mesa_sse_transform_rescale_normals_no_rot( NORM_ARGS );
+
+extern void _mesa_sse_transform_points4_general( XFORM_ARGS );
+extern void _mesa_sse_transform_points4_3d( XFORM_ARGS );
+extern void _mesa_sse_transform_points4_identity( XFORM_ARGS );
+#else
+DECLARE_NORM_GROUP( sse )
+#endif
+
+
+extern void _ASMAPI
+_mesa_v16_sse_general_xform( GLfloat *first_vert,
+			     const GLfloat *m,
+			     const GLfloat *src,
+			     GLuint src_stride,
+			     GLuint count );
+
+extern void _ASMAPI
+_mesa_sse_project_vertices( GLfloat *first,
+			    GLfloat *last,
+			    const GLfloat *m,
+			    GLuint stride );
+
+extern void _ASMAPI
+_mesa_sse_project_clipped_vertices( GLfloat *first,
+				    GLfloat *last,
+				    const GLfloat *m,
+				    GLuint stride,
+				    const GLubyte *clipmask );
+#endif
+
+
+void _mesa_init_sse_transform_asm( void )
+{
+#ifdef USE_SSE_ASM
+   ASSIGN_XFORM_GROUP( sse, 2 );
+   ASSIGN_XFORM_GROUP( sse, 3 );
+
+#if 1
+   /* TODO: Finish these off.
+    */
+   _mesa_transform_tab[4][MATRIX_GENERAL] =
+      _mesa_sse_transform_points4_general;
+   _mesa_transform_tab[4][MATRIX_3D] =
+      _mesa_sse_transform_points4_3d;
+   _mesa_transform_tab[4][MATRIX_IDENTITY] =
+      _mesa_sse_transform_points4_identity;
+
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT] =
+      _mesa_sse_transform_normals_no_rot;
+   _mesa_normal_tab[NORM_TRANSFORM | NORM_RESCALE] =
+      _mesa_sse_transform_rescale_normals;
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE] =
+      _mesa_sse_transform_rescale_normals_no_rot;
+#else
+   ASSIGN_XFORM_GROUP( sse, 4 );
+
+   ASSIGN_NORM_GROUP( sse );
+#endif
+
+#ifdef DEBUG
+   _math_test_all_transform_functions( "SSE" );
+   _math_test_all_normal_transform_functions( "SSE" );
+#endif
+#endif
+}
+
+void _mesa_init_sse_vertex_asm( void )
+{
+#ifdef USE_SSE_ASM
+   _mesa_xform_points3_v16_general = _mesa_v16_sse_general_xform;
+#if 0
+   /* GH: These are broken.  I'm fixing them now.
+    */
+   _mesa_project_v16 = _mesa_sse_project_vertices;
+   _mesa_project_clipped_v16 = _mesa_sse_project_clipped_vertices;
+#endif
+
+#ifdef DEBUG_NOT
+   _math_test_all_vertex_functions( "SSE" );
+#endif
+#endif
+}
Index: xc/extras/Mesa/src/X86/sse.h
diff -u /dev/null xc/extras/Mesa/src/X86/sse.h:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse.h	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * PentiumIII-SIMD (SSE) optimizations contributed by
+ * Andre Werthmann <wertmann@cs.uni-potsdam.de>
+ */
+
+#ifndef __SSE_H__
+#define __SSE_H__
+
+#include "math/m_xform.h"
+
+void _mesa_init_sse_transform_asm( void );
+void _mesa_init_sse_vertex_asm( void );
+
+#endif
Index: xc/extras/Mesa/src/X86/sse_normal.S
diff -u /dev/null xc/extras/Mesa/src/X86/sse_normal.S:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse_normal.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,251 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/** TODO:
+  * - insert PREFETCH instructions to avoid cache-misses !
+  * - some more optimizations are possible...
+  * - for 40-50% more performance in the SSE-functions, the
+  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
+  */
+
+#include "matypes.h"
+#include "norm_args.h"
+
+   SEG_TEXT
+
+#define M(i)    REGOFF(i * 4, EDX)
+#define S(i)	REGOFF(i * 4, ESI)
+#define D(i)	REGOFF(i * 4, EDI)
+#define STRIDE  REGOFF(12, ESI)
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_sse_transform_rescale_normals_no_rot)
+GLNAME(_mesa_sse_transform_rescale_normals_no_rot):
+
+#define FRAME_OFFSET 8
+	PUSH_L  ( ESI )
+	PUSH_L  ( EDI )
+
+	MOV_L	( ARG_IN, ESI )				/* ptr to source GLvector3f */
+	MOV_L	( ARG_DEST, EDI )			/* ptr to dest GLvector3f */
+
+	MOV_L	( ARG_MAT, EDX )			/* ptr to matrix */
+	MOV_L	( REGOFF(MATRIX_INV, EDX), EDX)		/* matrix->inv */
+
+	MOV_L	( REGOFF(V3F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L	( ECX, ECX )
+	JZ( LLBL(K_G3TRNNRR_finish) )			/* count was zero; go to finish */
+
+	MOV_L	( STRIDE, EAX )				/* stride */
+	MOV_L	( ECX, REGOFF(V3F_COUNT, EDI) )		/* set dest-count */
+
+	IMUL_L( CONST(12), ECX )			/* count *= 12 */
+	MOV_L( REGOFF(V3F_START, ESI), ESI )		/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V3F_START, EDI), EDI )		/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+	MOVSS	( M(0), XMM1 )				/* m0 */
+	MOVSS	( M(5), XMM2 )				/* m5 */
+	UNPCKLPS( XMM2, XMM1 )				/* m5 | m0 */
+	MOVSS	( ARG_SCALE, XMM0 )			/* scale */
+	SHUFPS	( CONST(0x0), XMM0, XMM0 )		/* scale | scale */
+	MULPS	( XMM0, XMM1 )				/* m5*scale | m0*scale */
+	MULSS	( M(10), XMM0 )				/* m10*scale */
+
+ALIGNTEXT32
+LLBL(K_G3TRNNRR_top):
+	MOVLPS	( S(0), XMM2 )				/* uy | ux */
+	MULPS	( XMM1, XMM2 )				/* uy*m5*scale | ux*m0*scale */
+	MOVLPS	( XMM2, D(0) )				/* ->D(1) | D(0) */
+
+	MOVSS	( S(2), XMM2 )				/* uz */
+	MULSS	( XMM0, XMM2 )				/* uz*m10*scale */
+	MOVSS	( XMM2, D(2) )				/* ->D(2) */
+
+LLBL(K_G3TRNNRR_skip):
+	ADD_L	( CONST(12), EDI )
+	ADD_L	( EAX, ESI )
+	CMP_L	( ECX, EDI )
+	JNE	( LLBL(K_G3TRNNRR_top) )
+
+LLBL(K_G3TRNNRR_finish):
+	POP_L	( EDI )
+	POP_L	( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_sse_transform_rescale_normals)
+GLNAME(_mesa_sse_transform_rescale_normals):
+
+#define FRAME_OFFSET 8
+	PUSH_L  ( ESI )
+	PUSH_L  ( EDI )
+
+	MOV_L	( ARG_IN, ESI )				/* ptr to source GLvector3f */
+	MOV_L	( ARG_DEST, EDI )			/* ptr to dest GLvector3f */
+
+	MOV_L	( ARG_MAT, EDX )			/* ptr to matrix */
+	MOV_L	( REGOFF(MATRIX_INV, EDX), EDX)		/* matrix->inv */
+
+	MOV_L	( REGOFF(V3F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L	( ECX, ECX )
+	JZ( LLBL(K_G3TRNR_finish) )			/* count was zero; go to finish */
+
+	MOV_L	( STRIDE, EAX )				/* stride */
+	MOV_L	( ECX, REGOFF(V3F_COUNT, EDI) )		/* set dest-count */
+
+	IMUL_L( CONST(12), ECX )			/* count *= 12 */
+	MOV_L( REGOFF(V3F_START, ESI), ESI )		/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V3F_START, EDI), EDI )		/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+	MOVSS	( M(0), XMM0 )				/* m0 */
+	MOVSS	( M(4), XMM1 )				/* m4 */
+	UNPCKLPS( XMM1, XMM0 )				/* m4 | m0 */
+
+	MOVSS	( ARG_SCALE, XMM4 )			/* scale */
+	SHUFPS	( CONST(0x0), XMM4, XMM4 )		/* scale | scale */
+
+	MULPS	( XMM4, XMM0 )				/* m4*scale | m0*scale */
+	MOVSS	( M(1), XMM1 )				/* m1 */
+	MOVSS	( M(5), XMM2 )				/* m5 */
+	UNPCKLPS( XMM2, XMM1 )				/* m5 | m1 */
+	MULPS	( XMM4, XMM1 )				/* m5*scale | m1*scale */
+	MOVSS	( M(2), XMM2 )				/* m2 */
+	MOVSS	( M(6), XMM3 )				/* m6 */
+	UNPCKLPS( XMM3, XMM2 )				/* m6 | m2 */
+	MULPS	( XMM4, XMM2 )				/* m6*scale | m2*scale */
+
+	MOVSS	( M(8), XMM6 )				/* m8 */
+	MULSS	( ARG_SCALE, XMM6 )			/* m8*scale */
+	MOVSS	( M(9), XMM7 )				/* m9 */
+	MULSS	( ARG_SCALE, XMM7 )			/* m9*scale */
+
+ALIGNTEXT32
+LLBL(K_G3TRNR_top):
+	MOVSS	( S(0), XMM3 )				/* ux */
+	SHUFPS	( CONST(0x0), XMM3, XMM3 )		/* ux | ux */
+	MULPS	( XMM0, XMM3 )				/* ux*m4 | ux*m0 */
+	MOVSS	( S(1), XMM4 )				/* uy */
+	SHUFPS	( CONST(0x0), XMM4, XMM4 )		/* uy | uy */
+	MULPS	( XMM1, XMM4 )				/* uy*m5 | uy*m1 */
+	MOVSS	( S(2), XMM5 )				/* uz */
+	SHUFPS	( CONST(0x0), XMM5, XMM5 )		/* uz | uz */
+	MULPS	( XMM2, XMM5 )				/* uz*m6 | uz*m2 */
+
+	ADDPS	( XMM4, XMM3 )
+	ADDPS	( XMM5, XMM3 )
+	MOVLPS	( XMM3, D(0) )
+
+	MOVSS	( M(10), XMM3 )				/* m10 */
+	MULSS	( ARG_SCALE, XMM3 )			/* m10*scale */
+	MULSS	( S(2), XMM3 )				/* m10*scale*uz */
+	MOVSS	( S(1), XMM4 )				/* uy */
+	MULSS	( XMM7, XMM4 )				/* uy*m9*scale */
+	MOVSS	( S(0), XMM5 )				/* ux */
+	MULSS	( XMM6, XMM5 )				/* ux*m8*scale */
+
+	ADDSS	( XMM4, XMM3 )
+	ADDSS	( XMM5, XMM3 )
+	MOVSS	( XMM3, D(2) )
+
+LLBL(K_G3TRNR_skip):
+	ADD_L	( CONST(12), EDI )
+	ADD_L	( EAX, ESI )
+	CMP_L	( ECX, EDI )
+	JNE	( LLBL(K_G3TRNR_top) )
+
+LLBL(K_G3TRNR_finish):
+	POP_L	( EDI )
+	POP_L	( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_sse_transform_normals_no_rot)
+GLNAME(_mesa_sse_transform_normals_no_rot):
+
+#define FRAME_OFFSET 8
+	PUSH_L  ( ESI )
+	PUSH_L  ( EDI )
+
+	MOV_L	( ARG_IN, ESI )				/* ptr to source GLvector3f */
+	MOV_L	( ARG_DEST, EDI )			/* ptr to dest GLvector3f */
+
+	MOV_L	( ARG_MAT, EDX )			/* ptr to matrix */
+	MOV_L	( REGOFF(MATRIX_INV, EDX), EDX)		/* matrix->inv */
+
+	MOV_L	( REGOFF(V3F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L	( ECX, ECX )
+	JZ( LLBL(K_G3TNNRR_finish) )			/* count was zero; go to finish */
+
+	MOV_L	( STRIDE, EAX )				/* stride */
+	MOV_L	( ECX, REGOFF(V3F_COUNT, EDI) )		/* set dest-count */
+
+	IMUL_L( CONST(12), ECX )			/* count *= 12 */
+	MOV_L( REGOFF(V3F_START, ESI), ESI )		/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V3F_START, EDI), EDI )		/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+	MOVSS( M(0), XMM0 )				/* m0 */
+	MOVSS( M(5), XMM1 )				/* m5 */
+	UNPCKLPS( XMM1, XMM0 )				/* m5 | m0 */
+	MOVSS( M(10), XMM1 )				/* m10 */
+
+ALIGNTEXT32
+LLBL(K_G3TNNRR_top):
+	MOVLPS( S(0), XMM2 )				/* uy | ux */
+	MULPS( XMM0, XMM2 )				/* uy*m5 | ux*m0 */
+	MOVLPS( XMM2, D(0) )
+
+	MOVSS( S(2), XMM2 )				/* uz */
+	MULSS( XMM1, XMM2 )				/* uz*m10 */
+	MOVSS( XMM2, D(2) )
+
+LLBL(K_G3TNNRR_skip):
+	ADD_L	( CONST(12), EDI )
+	ADD_L	( EAX, ESI )
+	CMP_L	( ECX, EDI )
+	JNE	( LLBL(K_G3TNNRR_top) )
+
+LLBL(K_G3TNNRR_finish):
+	POP_L	( EDI )
+	POP_L	( ESI )
+	RET
+#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/sse_vertex.S
diff -u /dev/null xc/extras/Mesa/src/X86/sse_vertex.S:1.1.1.1
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse_vertex.S	Fri Feb 22 12:14:11 2002
@@ -0,0 +1,182 @@
+#include "matypes.h"
+
+	SEG_TEXT
+
+#define MAT_SY 20
+#define MAT_SZ 40
+#define MAT_TX 48
+#define MAT_TY 52
+#define MAT_TZ 56
+
+
+/*
+ * void _mesa_v16_katmai_general_xform( GLfloat *dest,
+ *		        	     const GLfloat *m,
+ *				     const GLfloat *src,
+ *                                   GLuint src_stride,
+ *				     GLuint count )
+ *
+ */
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_v16_sse_general_xform )
+GLNAME( _mesa_v16_sse_general_xform ):
+
+    PUSH_L( EDI )
+    PUSH_L( ESI )
+
+    MOV_L( REGOFF(12, ESP), EAX )		/* destination                       */
+    MOV_L( REGOFF(16, ESP), ESI )		/* matrix                            */
+    MOV_L( REGOFF(20, ESP), EDX )		/* source                            */
+    MOV_L( REGOFF(24, ESP), EDI )		/* src_stride                        */
+    MOV_L( REGOFF(28, ESP), ECX )		/* count                             */
+
+    MOVAPS( REGOFF(0, ESI), XMM4 )		/* m3     | m2     | m1     | m0     */
+    MOVAPS( REGOFF(16, ESI), XMM5 )		/* m7     | m6     | m5     | m4     */
+    MOVAPS( REGOFF(32, ESI), XMM6 )		/* m11    | m10    | m9     | m8     */
+    MOVAPS( REGOFF(48, ESI), XMM7 )		/* m15    | m14    | m13    | m12    */
+
+ALIGNTEXT32
+LLBL(v16_sse_general_loop):
+
+    MOVSS( REGOFF(0, EDX), XMM0 )		/*        |        |        | x0     */
+    SHUFPS( CONST(0x0), XMM0, XMM0 )		/* x0     | x0     | x0     | x0     */
+    MULPS( XMM4, XMM0 )				/* x0*m3  | x0*m2  | x0*m1  | x0*m0  */
+
+    MOVSS( REGOFF(4, EDX), XMM1 )		/*        |        |        | x1     */
+    SHUFPS( CONST(0x0), XMM1, XMM1 )		/* x1     | x1     | x1     | x1     */
+    MULPS( XMM5, XMM1 )				/* x1*m7  | x1*m6  | x1*m5  | x1*m4  */
+
+    MOVSS( REGOFF(8, EDX), XMM2 )		/*        |        |        | x2     */
+    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* x2     | x2     | x2     | x2     */
+    MULPS( XMM6, XMM2 )				/* x2*m11 | x2*m10 | x2*m9  | x2*m8  */
+
+    ADDPS( XMM1, XMM0 )
+    ADDPS( XMM2, XMM0 )
+    ADDPS( XMM7, XMM0 )				/* r3     | r2     | r1     | r1     */
+
+    MOVAPS( XMM0, REGOFF(0, EAX) )
+
+    ADD_L( CONST(64), EAX )			/* next output vertex                */
+    ADD_L( EDI, EDX )				/* next input vertex                 */
+
+    DEC_L( ECX )
+    JNE( LLBL(v16_sse_general_loop) )
+
+    POP_L( ESI )
+    POP_L( EDI )
+
+    RET
+
+
+/* void _mesa_sse_project_vertices(GLfloat *first,
+ *	              		   GLfloat *last,
+ *	              		   const GLfloat *m,
+ *	              		   GLuint stride )
+ */
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_sse_project_vertices )
+GLNAME( _mesa_sse_project_vertices ):
+
+	PUSH_L( EBP )
+
+	MOV_L( REGOFF(8, ESP), ECX )	/* first_vert */
+	MOV_L( REGOFF(12, ESP), EDX )	/* last_vert */
+	MOV_L( REGOFF(16, ESP), EBP )	/* matrix */
+	MOV_L( REGOFF(20, ESP), EAX )	/* stride */
+
+
+ALIGNTEXT32
+	MOVAPS( REGOFF(MAT_TX, EBP), XMM0 )	/* (x44), x43, x42, x41 => xmm0 */
+	MOVSS( REGOFF(0, EBP), XMM1 )		/* -, -, -, x11 => xmm1 */
+	UNPCKLPS( REGOFF(MAT_SY, EBP), XMM1 )	/* -, -, x22, x11 => xmm1 */
+	SHUFPS( CONST(0x44), REGOFF(MAT_SZ, EBP), XMM1 )
+						/* -, x33, x22, x11 => xmm1 */
+
+	SUB_L( ECX, EDX )			/* last -= first */
+
+LLBL(v16_sse_pv_loop_start):
+	MOVAPS( REGOFF(0, ECX), XMM3 )		/* f[3], f[2], f[1], f[0] */
+
+	MOVSS( REGOFF(12, ECX), XMM2 )		/* -, -, -, f[3] */
+	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* f[3], f[3], f[3], f[3] */
+	RCPPS( XMM2, XMM2 )			/* 1/f[3], 1/f[3], 1/f[3], 1/f[3] */
+
+	MULPS( XMM2, XMM1 )			/* -, x33*1/f[3]... */
+	MULPS( XMM3, XMM1 )			/* -, x33*1/f[3]*f[2]... */
+	ADDPS( XMM0, XMM1 )			/* -, x33*1/f[3]*f[2]+x43... */
+
+	MOVAPS( XMM1, REGOFF(0, ECX) )		/* back to f */
+	MOVSS( XMM2, REGOFF(12, ECX) )		/* 1/f[3] into f[3] ! */
+
+
+	ADD_L( EAX, ECX )			/* f += stride */
+	SUB_L( EAX, EDX )			/* (last-first)-stride */
+	JA ( LLBL(v16_sse_pv_loop_start) )
+
+	POP_L( EBP )
+	RET
+
+
+
+/* void _mesa_sse_project_clipped_vertices(GLfloat *first,
+ *	              		   	   GLfloat *last,
+ *	              		   	   const GLfloat *m,
+ *	              		   	   GLuint stride,
+ *					   const GLubyte *clipmask );
+ */
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_sse_project_clipped_vertices )
+GLNAME( _mesa_sse_project_clipped_vertices ):
+
+	PUSH_L( EBP )
+	PUSH_L( ESI )
+
+	MOV_L( REGOFF(12, ESP), ECX )	/* first_vert */
+	MOV_L( REGOFF(16, ESP), EDX )	/* last_vert */
+	MOV_L( REGOFF(20, ESP), EBP )	/* matrix */
+	MOV_L( REGOFF(24, ESP), EAX )	/* stride */
+	MOV_L( REGOFF(28, ESP), ESI )	/* clip_mask */
+
+
+
+ALIGNTEXT32
+
+	MOVAPS( REGOFF(MAT_TX, EBP), XMM0 )	/* (x44), x43, x42, x41 => xmm0 */
+	MOVSS( REGOFF(0, EBP), XMM1 )		/* -, -, -, x11 => xmm1 */
+	UNPCKLPS( REGOFF(MAT_SY, EBP), XMM1 )	/* -, -, x22, x11 => xmm1 */
+	SHUFPS( CONST(0x44), REGOFF(MAT_SZ, EBP), XMM1 )
+						/* -, x33, x22, x11 => xmm1 */
+
+LLBL(v16_sse_pcv_loop_start):
+	CMP_B ( CONST(0), REGIND(ESI) )		/* clip_mask == 0 ? */
+	JNE( LLBL(v16_sse_pcv_skip) )	/* no -> skip ! */
+
+	MOVAPS( REGOFF(0, ECX), XMM3 )		/* f[3], f[2], f[1], f[0] */
+
+	MOVSS( REGOFF(12, ECX), XMM2 )		/* -, -, -, f[3] */
+	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* f[3], f[3], f[3], f[3] */
+	RCPPS( XMM2, XMM2 )			/* 1/f[3], 1/f[3], 1/f[3], 1/f[3] */
+
+	MULPS( XMM2, XMM1 )			/* -, x33*1/f[3]... */
+	MULPS( XMM3, XMM1 )			/* -, x33*1/f[3]*f[2]... */
+	ADDPS( XMM0, XMM1 )			/* -, x33*1/f[3]*f[2]+x43... */
+
+	MOVAPS( XMM1, REGOFF(0, ECX) )		/* back to f */
+	MOVSS( XMM2, REGOFF(12, ECX) )		/* 1/f[3] into f[3] ! */
+
+LLBL(v16_sse_pcv_skip):
+	ADD_L( EAX, ECX )			/* f += stride */
+	INC_L( ESI )				/* nect ClipMask */
+
+	CMP_L( ECX, EDX )			/* p_first_vertex == p_last_vertex */
+	JNE( LLBL(v16_sse_pcv_loop_start) )
+						/* no -> go on with next vertex */
+
+	POP_L( ESI )
+	POP_L( EBP )
+	RET
Index: xc/extras/Mesa/src/X86/sse_xform1.S
diff -u /dev/null xc/extras/Mesa/src/X86/sse_xform1.S:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse_xform1.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,432 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/** TODO:
+  * - insert PREFETCH instructions to avoid cache-misses !
+  * - some more optimizations are possible...
+  * - for 40-50% more performance in the SSE-functions, the
+  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
+  */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+   SEG_TEXT
+
+#define S(i) 	REGOFF(i * 4, ESI)
+#define D(i) 	REGOFF(i * 4, EDI)
+#define M(i) 	REGOFF(i * 4, EDX)
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points1_general)
+GLNAME( _mesa_sse_transform_points1_general ):
+
+#define FRAME_OFFSET 8
+    PUSH_L    ( ESI )
+    PUSH_L    ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    CMP_L( CONST(0), ECX )			/* count == 0 ? */
+    JE( LLBL(K_GTP1GR_finish) )			/* yes -> nothing to do. */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+
+ALIGNTEXT32
+    MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  | m0  */
+    MOVAPS( M(12), XMM1 )			/* m15 | m14 | m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP1GR_top):
+    MOVSS( S(0), XMM2 )				/* ox */
+    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* ox | ox | ox | ox */
+    MULPS( XMM0, XMM2 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
+    ADDPS( XMM1, XMM2 )				/* + | + | + | + */
+    MOVUPS( XMM2, D(0) )
+
+LLBL(K_GTP1GR_skip):
+    ADD_L     ( CONST(16), EDI )
+    ADD_L     ( EAX, ESI )
+    CMP_L     ( ECX, EDI )
+    JNE       ( LLBL(K_GTP1GR_top) )
+
+LLBL(K_GTP1GR_finish):
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points1_identity)
+GLNAME( _mesa_sse_transform_points1_identity ):
+
+#define FRAME_OFFSET 8
+    PUSH_L    ( ESI )
+    PUSH_L    ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP1IR_finish) ) 		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_1), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(1), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+    CMP_L( ESI, EDI )
+    JE( LLBL(K_GTP1IR_finish) )
+
+
+ALIGNTEXT32
+LLBL(K_GTP1IR_top):
+    MOV_L( S(0), EDX )
+    MOV_L( EDX, D(0) )
+
+LLBL(K_GTP1IR_skip):
+    ADD_L     ( CONST(16), EDI )
+    ADD_L     ( EAX, ESI )
+    CMP_L     ( ECX, EDI )
+    JNE       ( LLBL(K_GTP1IR_top) )
+
+LLBL(K_GTP1IR_finish):
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points1_3d_no_rot)
+GLNAME(_mesa_sse_transform_points1_3d_no_rot):
+
+#define FRAME_OFFSET 8
+    PUSH_L( ESI )
+    PUSH_L( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI )	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP13DNRR_finish) ) 		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+
+ALIGNTEXT32
+    MOVSS( M(0), XMM0 )				/* m0 */
+    MOVSS( M(12), XMM1 )			/* m12 */
+    MOVSS( M(13), XMM2 )			/* m13 */
+    MOVSS( M(14), XMM3 )			/* m14 */
+
+ALIGNTEXT32
+LLBL(K_GTP13DNRR_top):
+    MOVSS( S(0), XMM4 )				/* ox */
+    MULSS( XMM0, XMM4 )				/* ox*m0 */
+    ADDSS( XMM1, XMM4 )				/* ox*m0+m12 */
+    MOVSS( XMM4, D(0) )
+
+    MOVSS( XMM2, D(1) )
+    MOVSS( XMM3, D(2) )
+
+LLBL(K_GTP13DNRR_skip):
+    ADD_L    ( CONST(16), EDI )
+    ADD_L    ( EAX, ESI )
+    CMP_L    ( ECX, EDI )
+    JNE      ( LLBL(K_GTP13DNRR_top) )
+
+LLBL(K_GTP13DNRR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points1_perspective)
+GLNAME(_mesa_sse_transform_points1_perspective):
+
+#define FRAME_OFFSET 8
+    PUSH_L   ( ESI )
+    PUSH_L   ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP13PR_finish) )		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+
+ALIGNTEXT32
+    XORPS( XMM0, XMM0 )				/* 0 | 0 | 0 | 0 */
+    MOVSS( M(0), XMM1 )				/* m0 */
+    MOVSS( M(14), XMM2 )			/* m14 */
+
+ALIGNTEXT32
+LLBL(K_GTP13PR_top):
+    MOVSS( S(0), XMM3 )				/* ox */
+    MULSS( XMM1, XMM3 )				/* ox*m0 */
+    MOVSS( XMM3, D(0) )				/* ox*m0->D(0) */
+    MOVSS( XMM2, D(2) )				/* m14->D(2) */
+
+    MOVSS( XMM0, D(1) )
+    MOVSS( XMM0, D(3) )
+
+LLBL(K_GTP13PR_skip):
+    ADD_L( CONST(16), EDI )
+    ADD_L( EAX, ESI )
+    CMP_L( ECX, EDI )
+    JNE( LLBL(K_GTP13PR_top) )
+
+LLBL(K_GTP13PR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points1_2d)
+GLNAME(_mesa_sse_transform_points1_2d):
+
+#define FRAME_OFFSET 8
+    PUSH_L( ESI )
+    PUSH_L( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP13P2DR_finish) ) 		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+    MOVLPS( M(0), XMM0 )			/* m1  | m0  */
+    MOVLPS( M(12), XMM1 )			/* m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP13P2DR_top):
+    MOVSS( S(0), XMM2 )				/* ox */
+    SHUFPS( CONST(0x0), XMM2, XMM2 )		/* ox | ox | ox | ox */
+    MULPS( XMM0, XMM2 )				/* - | - | ox*m1 | ox*m0 */
+    ADDPS( XMM1, XMM2 )				/* - | - | ox*m1+m13 | ox*m0+m12 */
+    MOVLPS( XMM2, D(0) )
+
+LLBL(K_GTP13P2DR_skip):
+    ADD_L    ( CONST(16), EDI )
+    ADD_L    ( EAX, ESI )
+    CMP_L    ( ECX, EDI )
+    JNE      ( LLBL(K_GTP13P2DR_top) )
+
+LLBL(K_GTP13P2DR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points1_2d_no_rot)
+GLNAME(_mesa_sse_transform_points1_2d_no_rot):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L( ECX, ECX)
+	JZ( LLBL(K_GTP13P2DNRR_finish) ) 	/* count was zero; go to finish */
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 			/* count += dest ptr */
+
+ALIGNTEXT32
+	MOVSS( M(0), XMM0 )			/* m0 */
+	MOVSS( M(12), XMM1 )			/* m12 */
+	MOVSS( M(13), XMM2 )			/* m13 */
+
+ALIGNTEXT32
+LLBL(K_GTP13P2DNRR_top):
+	MOVSS( S(0), XMM3 )			/* ox */
+	MULSS( XMM0, XMM3 )			/* ox*m0 */
+	ADDSS( XMM1, XMM3 )			/* ox*m0+m12 */
+	MOVSS( XMM3, D(0) )
+	MOVSS( XMM2, D(1) )
+
+LLBL(K_GTP13P2DNRR_skip):
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(K_GTP13P2DNRR_top) )
+
+LLBL(K_GTP13P2DNRR_finish):
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points1_3d)
+GLNAME(_mesa_sse_transform_points1_3d):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L( ECX, ECX)
+	JZ( LLBL(K_GTP13P3DR_finish) ) 	/* count was zero; go to finish */
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 			/* count += dest ptr */
+
+
+ALIGNTEXT32
+	MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  |  m0 */
+	MOVAPS( M(12), XMM1 )			/* m15 | m14 | m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP13P3DR_top):
+	MOVSS( S(0), XMM2 )			/* ox */
+	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* ox | ox | ox | ox */
+	MULPS( XMM0, XMM2 )			/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
+	ADDPS( XMM1, XMM2 )			/* +m15  | +m14  | +m13  | +m12  */
+	MOVLPS( XMM2, D(0) )			/*   -   |   -   | ->D(1)| ->D(0)*/
+	UNPCKHPS( XMM2, XMM2 )			/* ox*m3+m15 | ox*m3+m15 | ox*m2+m14 | ox*m2+m14 */
+	MOVSS( XMM2, D(2) )
+
+LLBL(K_GTP13P3DR_skip):
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(K_GTP13P3DR_top) )
+
+LLBL(K_GTP13P3DR_finish):
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/sse_xform2.S
diff -u /dev/null xc/extras/Mesa/src/X86/sse_xform2.S:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse_xform2.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,451 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/** TODO:
+  * - insert PREFETCH instructions to avoid cache-misses !
+  * - some more optimizations are possible...
+  * - for 40-50% more performance in the SSE-functions, the
+  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
+  */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+   SEG_TEXT
+
+#define S(i) 	REGOFF(i * 4, ESI)
+#define D(i) 	REGOFF(i * 4, EDI)
+#define M(i) 	REGOFF(i * 4, EDX)
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points2_general)
+GLNAME( _mesa_sse_transform_points2_general ):
+
+#define FRAME_OFFSET 8
+    PUSH_L    ( ESI )
+    PUSH_L    ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX )
+    JZ( LLBL(K_GTP2GR_finish) )			/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+    MOVAPS( M(0), XMM0 )			/* m3  | m2  | m1  | m0 */
+    MOVAPS( M(4), XMM1 )			/* m7  | m6  | m5  | m4 */
+    MOVAPS( M(12), XMM2 )			/* m15 | m14 | m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP2GR_top):
+    MOVSS( S(0), XMM3 )				/* ox */
+    SHUFPS( CONST(0x0), XMM3, XMM3 )		/* ox | ox | ox | ox */
+    MULPS( XMM0, XMM3 )				/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
+    MOVSS( S(1), XMM4 )				/* oy */
+    SHUFPS( CONST(0x0), XMM4, XMM4 )		/* oy | oy | oy | oy */
+    MULPS( XMM1, XMM4 )				/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
+
+    ADDPS( XMM4, XMM3 )
+    ADDPS( XMM2, XMM3 )
+    MOVAPS( XMM3, D(0) )
+
+LLBL(K_GTP2GR_skip):
+    ADD_L     ( CONST(16), EDI )
+    ADD_L     ( EAX, ESI )
+    CMP_L     ( ECX, EDI )
+    JNE       ( LLBL(K_GTP2GR_top) )
+
+LLBL(K_GTP2GR_finish):
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points2_identity)
+GLNAME( _mesa_sse_transform_points2_identity ):
+
+#define FRAME_OFFSET 8
+    PUSH_L    ( ESI )
+    PUSH_L    ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) /* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP2IR_finish) )			/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+    CMP_L( ESI, EDI )
+    JE( LLBL(K_GTP2IR_finish) )
+
+
+ALIGNTEXT32
+LLBL(K_GTP2IR_top):
+    MOV_L     ( S(0), EDX )
+    MOV_L     ( EDX, D(0) )
+    MOV_L     ( S(1), EDX )
+    MOV_L     ( EDX, D(1) )
+
+LLBL(K_GTP2IR_skip):
+    ADD_L     ( CONST(16), EDI )
+    ADD_L     ( EAX, ESI )
+    CMP_L     ( ECX, EDI )
+    JNE       ( LLBL(K_GTP2IR_top) )
+
+LLBL(K_GTP2IR_finish):
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points2_3d_no_rot)
+GLNAME(_mesa_sse_transform_points2_3d_no_rot):
+
+#define FRAME_OFFSET 8
+    PUSH_L( ESI )
+    PUSH_L( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP23DNRR_finish) ) 		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+
+ALIGNTEXT32
+    MOVSS    ( M(0), XMM1 )			/* - | - |  -  | m0  */
+    MOVSS    ( M(5), XMM2 )			/* - | - |  -  | m5  */
+    UNPCKLPS ( XMM2, XMM1 )			/* - | - | m5  | m0  */
+    MOVLPS   ( M(12), XMM2 )			/* - | - | m13 | m12 */
+    MOVSS    ( M(14), XMM3 )			/* - | - |  -  | m14 */
+
+ALIGNTEXT32
+LLBL(K_GTP23DNRR_top):
+    MOVLPS   ( S(0), XMM0 )			/* - | - |  oy   | ox */
+    MULPS    ( XMM1, XMM0 )			/* - | - | oy*m5 | ox*m0 */
+    ADDPS    ( XMM2, XMM0 )			/* - | - | +m13  | +m12 */
+    MOVLPS   ( XMM0, D(0) )			/* -> D(1) | -> D(0) */
+
+    MOVSS    ( XMM3, D(2) )			/* -> D(2) */
+
+LLBL(K_GTP23DNRR_skip):
+    ADD_L    ( CONST(16), EDI )
+    ADD_L    ( EAX, ESI )
+    CMP_L    ( ECX, EDI )
+    JNE      ( LLBL(K_GTP23DNRR_top) )
+
+LLBL(K_GTP23DNRR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points2_perspective)
+GLNAME(_mesa_sse_transform_points2_perspective):
+
+#define FRAME_OFFSET 8
+    PUSH_L   ( ESI )
+    PUSH_L   ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI )	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP23PR_finish) )		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+    MOVSS    ( M(0), XMM1 )			/* -  | -  |  -  | m0  */
+    MOVSS    ( M(5), XMM2 )			/* -  | -  |  -  | m5  */
+    UNPCKLPS ( XMM2, XMM1 )			/* -  | -  | m5  | m0  */
+    MOVSS    ( M(14), XMM3 )			/* m14 */
+    XORPS    ( XMM0, XMM0 )			/* 0 | 0 | 0 | 0 */
+
+ALIGNTEXT32
+LLBL(K_GTP23PR_top):
+    MOVLPS( S(0), XMM4 )			/* oy | ox */
+    MULPS( XMM1, XMM4 )				/* oy*m5 | ox*m0 */
+    MOVLPS( XMM4, D(0) )			/* ->D(1) | ->D(0) */
+    MOVSS( XMM3, D(2) )				/* ->D(2) */
+    MOVSS( XMM0, D(3) )				/* ->D(3) */
+
+LLBL(K_GTP23PR_skip):
+    ADD_L( CONST(16), EDI )
+    ADD_L( EAX, ESI )
+    CMP_L( ECX, EDI )
+    JNE( LLBL(K_GTP23PR_top) )
+
+LLBL(K_GTP23PR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points2_2d)
+GLNAME(_mesa_sse_transform_points2_2d):
+
+#define FRAME_OFFSET 8
+    PUSH_L( ESI )
+    PUSH_L( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP23P2DR_finish) ) 		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+    MOVLPS( M(0), XMM0 )			/* m1  | m0 */
+    MOVLPS( M(4), XMM1 )			/* m5  | m4 */
+    MOVLPS( M(12), XMM2 )			/* m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP23P2DR_top):
+    MOVSS( S(0), XMM3 )				/* ox */
+    SHUFPS( CONST(0x0), XMM3, XMM3 )		/* ox | ox */
+    MULPS( XMM0, XMM3 )				/* ox*m1 | ox*m0 */
+
+    MOVSS( S(1), XMM4 )				/* oy */
+    SHUFPS( CONST(0x0), XMM4, XMM4 )		/* oy | oy */
+    MULPS( XMM1, XMM4 )				/* oy*m5 | oy*m4 */
+
+    ADDPS( XMM4, XMM3 )
+    ADDPS( XMM2, XMM3 )
+    MOVLPS( XMM3, D(0) )			/* ->D(1) | ->D(0) */
+
+LLBL(K_GTP23P2DR_skip):
+    ADD_L    ( CONST(16), EDI )
+    ADD_L    ( EAX, ESI )
+    CMP_L    ( ECX, EDI )
+    JNE      ( LLBL(K_GTP23P2DR_top) )
+
+LLBL(K_GTP23P2DR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points2_2d_no_rot)
+GLNAME(_mesa_sse_transform_points2_2d_no_rot):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L( ECX, ECX)
+	JZ( LLBL(K_GTP23P2DNRR_finish) ) 	/* count was zero; go to finish */
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 			/* count += dest ptr */
+
+ALIGNTEXT32
+	MOVSS    ( M(0), XMM1 )			/* m0 */
+	MOVSS    ( M(5), XMM2 )			/* m5 */
+	UNPCKLPS ( XMM2, XMM1 )			/* m5 | m0 */
+	MOVLPS   ( M(12), XMM2 )		/* m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP23P2DNRR_top):
+	MOVLPS( S(0), XMM0 )			/* oy | ox */
+	MULPS( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
+	ADDPS( XMM2, XMM0 )			/* +m13 | +m12 */
+	MOVLPS( XMM0, D(0) )			/* ->D(1) | ->D(0) */
+
+LLBL(K_GTP23P2DNRR_skip):
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(K_GTP23P2DNRR_top) )
+
+LLBL(K_GTP23P2DNRR_finish):
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points2_3d)
+GLNAME(_mesa_sse_transform_points2_3d):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L( ECX, ECX)
+	JZ( LLBL(K_GTP23P3DR_finish) ) 	/* count was zero; go to finish */
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 			/* count += dest ptr */
+
+ALIGNTEXT32
+	MOVAPS( M(0), XMM0 )			/* m2  | m1  | m0 */
+	MOVAPS( M(4), XMM1 )			/* m6  | m5  | m4 */
+	MOVAPS( M(12), XMM2 )			/* m14 | m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP23P3DR_top):
+	MOVSS( S(0), XMM3 )			/* ox */
+	SHUFPS( CONST(0x0), XMM3, XMM3 )	/* ox | ox | ox */
+	MULPS( XMM0, XMM3 )			/* ox*m2 | ox*m1 | ox*m0 */
+
+	MOVSS( S(1), XMM4 )			/* oy */
+	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* oy | oy | oy */
+	MULPS( XMM1, XMM4 )			/* oy*m6 | oy*m5 | oy*m4 */
+
+	ADDPS( XMM4, XMM3 )
+	ADDPS( XMM2, XMM3 )
+
+	MOVLPS( XMM3, D(0) )			/* ->D(1) | ->D(0) */
+	UNPCKHPS( XMM3, XMM3 )
+	MOVSS( XMM3, D(2) )			/* ->D(2) */
+
+LLBL(K_GTP23P3DR_skip):
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(K_GTP23P3DR_top) )
+
+LLBL(K_GTP23P3DR_finish):
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/sse_xform3.S
diff -u /dev/null xc/extras/Mesa/src/X86/sse_xform3.S:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse_xform3.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,497 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/** TODO:
+  * - insert PREFETCH instructions to avoid cache-misses !
+  * - some more optimizations are possible...
+  * - for 40-50% more performance in the SSE-functions, the
+  *   data (trans-matrix, src_vert, dst_vert) needs to be 16byte aligned !
+  */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+   SEG_TEXT
+
+#define S(i) 	REGOFF(i * 4, ESI)
+#define D(i) 	REGOFF(i * 4, EDI)
+#define M(i) 	REGOFF(i * 4, EDX)
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points3_general)
+GLNAME( _mesa_sse_transform_points3_general ):
+
+#define FRAME_OFFSET 8
+    PUSH_L    ( ESI )
+    PUSH_L    ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    CMP_L     ( CONST(0), ECX )			/* count == 0 ? */
+    JE        ( LLBL(K_GTPGR_finish) )		/* yes -> nothing to do. */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+
+ALIGNTEXT32
+    MOVAPS    ( REGOFF(0, EDX), XMM0 )	/* m0  | m1  | m2  | m3 */
+    MOVAPS    ( REGOFF(16, EDX), XMM1 )	/* m4  | m5  | m6  | m7 */
+    MOVAPS    ( REGOFF(32, EDX), XMM2 )	/* m8  | m9  | m10 | m11 */
+    MOVAPS    ( REGOFF(48, EDX), XMM3 )	/* m12 | m13 | m14 | m15 */
+
+
+ALIGNTEXT32
+LLBL(K_GTPGR_top):
+    MOVSS     ( REGOFF(0, ESI), XMM4 )		/*    |    |    | ox */
+    SHUFPS    ( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox | ox */
+    MOVSS     ( REGOFF(4, ESI), XMM5 )		/*    |    |    | oy */
+    SHUFPS    ( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy | oy */
+    MOVSS     ( REGOFF(8, ESI), XMM6 )		/*    |    |    | oz */
+    SHUFPS    ( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz | oz */
+
+    MULPS     ( XMM0, XMM4 )		/* m3*ox  | m2*ox  | m1*ox | m0*ox */
+    MULPS     ( XMM1, XMM5 )		/* m7*oy  | m6*oy  | m5*oy | m4*oy */
+    MULPS     ( XMM2, XMM6 )		/* m11*oz | m10*oz | m9*oz | m8*oz */
+
+    ADDPS     ( XMM5, XMM4 )
+    ADDPS     ( XMM6, XMM4 )
+    ADDPS     ( XMM3, XMM4 )
+
+    MOVAPS    ( XMM4, REGOFF(0, EDI) )
+
+LLBL(K_GTPGR_skip):
+    ADD_L     ( CONST(16), EDI )
+    ADD_L     ( EAX, ESI )
+    CMP_L     ( ECX, EDI )
+    JNE       ( LLBL(K_GTPGR_top) )
+
+LLBL(K_GTPGR_finish):
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points3_identity)
+GLNAME( _mesa_sse_transform_points3_identity ):
+
+#define FRAME_OFFSET 8
+    PUSH_L    ( ESI )
+    PUSH_L    ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTPIR_finish) ) 			/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+    CMP_L( ESI, EDI )
+    JE( LLBL(K_GTPIR_finish) )
+
+
+ALIGNTEXT32
+LLBL(K_GTPIR_top):
+    MOVLPS    ( S(0), XMM0 )
+    MOVLPS    ( XMM0, D(0) )
+    MOVSS     ( S(2), XMM0 )
+    MOVSS     ( XMM0, D(2) )
+
+LLBL(K_GTPIR_skip):
+    ADD_L     ( CONST(16), EDI )
+    ADD_L     ( EAX, ESI )
+    CMP_L     ( ECX, EDI )
+    JNE       ( LLBL(K_GTPIR_top) )
+
+LLBL(K_GTPIR_finish):
+    POP_L     ( EDI )
+    POP_L     ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points3_3d_no_rot)
+GLNAME(_mesa_sse_transform_points3_3d_no_rot):
+
+#define FRAME_OFFSET 8
+    PUSH_L( ESI )
+    PUSH_L( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP3DNRR_finish) ) 		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+
+ALIGNTEXT32
+    MOVSS    ( M(0), XMM1 )			/* - | - |  -  | m0  */
+    MOVSS    ( M(5), XMM2 )			/* - | - |  -  | m5  */
+    UNPCKLPS ( XMM2, XMM1 )			/* - | - | m5  | m0  */
+    MOVLPS   ( M(12), XMM2 )			/* - | - | m13 | m12 */
+    MOVSS    ( M(10), XMM3 )			/* - | - |  -  | m10 */
+    MOVSS    ( M(14), XMM4 )			/* - | - |  -  | m14 */
+
+ALIGNTEXT32
+LLBL(K_GTP3DNRR_top):
+
+    MOVLPS   ( S(0), XMM0 )			/* - | - |  s1   | s0 */
+    MULPS    ( XMM1, XMM0 )			/* - | - | s1*m5 | s0*m0 */
+    ADDPS    ( XMM2, XMM0 )			/* - | - | +m13  | +m12 */
+    MOVLPS   ( XMM0, D(0) )			/* -> D(1) | -> D(0) */
+
+    MOVSS    ( S(2), XMM0 )			/* sz */
+    MULSS    ( XMM3, XMM0 )			/* sz*m10 */
+    ADDSS    ( XMM4, XMM0 )			/* +m14 */
+    MOVSS    ( XMM0, D(2) )			/* -> D(2) */
+
+LLBL(K_GTP3DNRR_skip):
+    ADD_L    ( CONST(16), EDI )
+    ADD_L    ( EAX, ESI )
+    CMP_L    ( ECX, EDI )
+    JNE      ( LLBL(K_GTP3DNRR_top) )
+
+LLBL(K_GTP3DNRR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points3_perspective)
+GLNAME(_mesa_sse_transform_points3_perspective):
+
+#define FRAME_OFFSET 8
+    PUSH_L   ( ESI )
+    PUSH_L   ( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP3PR_finish) )			/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+    MOVSS    ( M(0), XMM1 )			/* -  | -  |  -  | m0  */
+    MOVSS    ( M(5), XMM2 )			/* -  | -  |  -  | m5  */
+    UNPCKLPS ( XMM2, XMM1 )			/* -  | -  | m5  | m0  */
+    MOVLPS   ( M(8), XMM2 )			/* -  | -  | m9  | m8  */
+    MOVSS    ( M(10), XMM3 )			/* m10 */
+    MOVSS    ( M(14), XMM4 )			/* m14 */
+    XORPS    ( XMM6, XMM6 )			/* 0 */
+
+ALIGNTEXT32
+LLBL(K_GTP3PR_top):
+    MOVLPS   ( S(0), XMM0 )			/* oy | ox */
+    MULPS    ( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
+    MOVSS    ( S(2), XMM5 )			/* oz */
+    SHUFPS   ( CONST(0x0), XMM5, XMM5 )		/* oz | oz */
+    MULPS    ( XMM2, XMM5 )			/* oz*m9 | oz*m8 */
+    ADDPS    ( XMM5, XMM0 )			/* +oy*m5 | +ox*m0 */
+    MOVLPS   ( XMM0, D(0) )			/* ->D(1) | ->D(0) */
+
+    MOVSS    ( S(2), XMM0 )			/* oz */
+    MULSS    ( XMM3, XMM0 )			/* oz*m10 */
+    ADDSS    ( XMM4, XMM0 )			/* +m14 */
+    MOVSS    ( XMM0, D(2) )			/* ->D(2) */
+
+    MOVSS    ( S(2), XMM0 )			/* oz */
+    MOVSS    ( XMM6, XMM5 )			/* 0 */
+    SUBPS    ( XMM0, XMM5 )			/* -oz */
+    MOVSS    ( XMM5, D(3) )			/* ->D(3) */
+
+LLBL(K_GTP3PR_skip):
+    ADD_L( CONST(16), EDI )
+    ADD_L( EAX, ESI )
+    CMP_L( ECX, EDI )
+    JNE( LLBL(K_GTP3PR_top) )
+
+LLBL(K_GTP3PR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points3_2d)
+GLNAME(_mesa_sse_transform_points3_2d):
+
+#define FRAME_OFFSET 8
+    PUSH_L( ESI )
+    PUSH_L( EDI )
+
+    MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+    MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+    MOV_L( ARG_MATRIX, EDX ) 			/* ptr to matrix */
+    MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+    TEST_L( ECX, ECX)
+    JZ( LLBL(K_GTP3P2DR_finish) ) 		/* count was zero; go to finish */
+
+    MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+    OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+    MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+    MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+    SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+    MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+    MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+    ADD_L( EDI, ECX ) 				/* count += dest ptr */
+
+ALIGNTEXT32
+    MOVLPS( M(0), XMM0 )			/* m1  | m0 */
+    MOVLPS( M(4), XMM1 )			/* m5  | m4 */
+    MOVLPS( M(12), XMM2 )			/* m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP3P2DR_top):
+    MOVSS    ( S(0), XMM3 )			/* ox */
+    SHUFPS   ( CONST(0x0), XMM3, XMM3 )		/* ox | ox */
+    MULPS    ( XMM0, XMM3 )			/* ox*m1 | ox*m0 */
+    MOVSS    ( S(1), XMM4 )			/* oy */
+    SHUFPS   ( CONST(0x0), XMM4, XMM4 )		/* oy | oy */
+    MULPS    ( XMM1, XMM4 )			/* oy*m5 | oy*m4 */
+
+    ADDPS    ( XMM4, XMM3 )
+    ADDPS    ( XMM2, XMM3 )
+    MOVLPS   ( XMM3, D(0) )
+
+    MOVSS    ( S(2), XMM3 )
+    MOVSS    ( XMM3, D(2) )
+
+LLBL(K_GTP3P2DR_skip):
+    ADD_L    ( CONST(16), EDI )
+    ADD_L    ( EAX, ESI )
+    CMP_L    ( ECX, EDI )
+    JNE      ( LLBL(K_GTP3P2DR_top) )
+
+LLBL(K_GTP3P2DR_finish):
+    POP_L    ( EDI )
+    POP_L    ( ESI )
+    RET
+#undef FRAME_OFFSET
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points3_2d_no_rot)
+GLNAME(_mesa_sse_transform_points3_2d_no_rot):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L( ECX, ECX)
+	JZ( LLBL(K_GTP3P2DNRR_finish) ) 	/* count was zero; go to finish */
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 			/* count += dest ptr */
+
+ALIGNTEXT32
+	MOVSS    ( M(0), XMM1 )			/* m0 */
+	MOVSS    ( M(5), XMM2 )			/* m5 */
+	UNPCKLPS ( XMM2, XMM1 )			/* m5 | m0 */
+	MOVLPS   ( M(12), XMM2 )		/* m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP3P2DNRR_top):
+	MOVLPS( S(0), XMM0 )			/* oy | ox */
+	MULPS( XMM1, XMM0 )			/* oy*m5 | ox*m0 */
+	ADDPS( XMM2, XMM0 )			/* +m13 | +m12 */
+	MOVLPS( XMM0, D(0) )			/* ->D(1) | ->D(0) */
+
+	MOVSS( S(2), XMM0 )
+	MOVSS( XMM0, D(2) )
+
+LLBL(K_GTP3P2DNRR_skip):
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(K_GTP3P2DNRR_top) )
+
+LLBL(K_GTP3P2DNRR_finish):
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME(_mesa_sse_transform_points3_3d)
+GLNAME(_mesa_sse_transform_points3_3d):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( REGOFF(OFFSET_SOURCE+8, ESP), ESI ) 	/* ptr to source GLvector4f */
+	MOV_L( REGOFF(OFFSET_DEST+8, ESP), EDI ) 	/* ptr to dest GLvector4f */
+
+
+	MOV_L( ARG_MATRIX, EDX ) 		/* ptr to matrix */
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX ) 	/* source count */
+
+	TEST_L( ECX, ECX)
+	JZ( LLBL(K_GTP3P3DR_finish) ) 	/* count was zero; go to finish */
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX ) 	/* stride */
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) 	/* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) ) 	/* set dest count */
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) ) 	/* set dest size */
+
+	SHL_L( CONST(4), ECX ) 			/* count *= 16 */
+	MOV_L( REGOFF(V4F_START, ESI), ESI ) 	/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI ) 	/* ptr to first dest vertex */
+	ADD_L( EDI, ECX ) 			/* count += dest ptr */
+
+
+ALIGNTEXT32
+	MOVAPS( M(0), XMM0 )			/* m2  | m1  | m0 */
+	MOVAPS( M(4), XMM1 )			/* m6  | m5  | m4 */
+	MOVAPS( M(8), XMM2 )			/* m10 | m9  | m8 */
+	MOVAPS( M(12), XMM3 )			/* m14 | m13 | m12 */
+
+ALIGNTEXT32
+LLBL(K_GTP3P3DR_top):
+	MOVSS( S(0), XMM4 )
+	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox */
+	MULPS( XMM0, XMM4 )			/* ox*m2 | ox*m1 | ox*m0 */
+
+	MOVSS( S(1), XMM5 )
+	SHUFPS( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy */
+	MULPS( XMM1, XMM5 )			/* oy*m6 | oy*m5 | oy*m4 */
+
+	MOVSS( S(2), XMM6 )
+	SHUFPS( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz */
+	MULPS( XMM2, XMM6 )			/* oz*m10 | oz*m9 | oz*m8 */
+
+	ADDPS( XMM5, XMM4 )			/* + | + | + */
+	ADDPS( XMM6, XMM4 )			/* + | + | + */
+	ADDPS( XMM3, XMM4 )			/* + | + | + */
+
+	MOVLPS( XMM4, D(0) )			/* => D(1) | => D(0) */
+	UNPCKHPS( XMM4, XMM4 )
+	MOVSS( XMM4, D(2) )
+
+LLBL(K_GTP3P3DR_skip):
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(K_GTP3P3DR_top) )
+
+LLBL(K_GTP3P3DR_finish):
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/sse_xform4.S
diff -u /dev/null xc/extras/Mesa/src/X86/sse_xform4.S:1.2
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/sse_xform4.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,225 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+	SEG_TEXT
+
+#define FRAME_OFFSET	8
+
+#define SRC(i)		REGOFF(i * 4, ESI)
+#define DST(i)		REGOFF(i * 4, EDI)
+#define MAT(i)		REGOFF(i * 4, EDX)
+
+#define SELECT(r0, r1, r2, r3)	CONST( r0 * 64 + r1 * 16 + r2 * 4 + r3 )
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_sse_transform_points4_general )
+GLNAME( _mesa_sse_transform_points4_general ):
+
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )			/* verify non-zero count */
+	JE( LLBL( sse_general_done ) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )	/* stride */
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) /* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )	/* set dest count */
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )/* set dest size */
+
+	MOV_L( REGOFF(V4F_START, ESI), ESI )	/* ptr to first source vertex */
+	MOV_L( REGOFF(V4F_START, EDI), EDI )	/* ptr to first dest vertex */
+
+	PREFETCHT0( REGIND(ESI) )
+
+	MOVAPS( MAT(0), XMM4 )			/* m3  | m2  | m1  | m0  */
+	MOVAPS( MAT(4), XMM5 )			/* m7  | m6  | m5  | m4  */
+	MOVAPS( MAT(8), XMM6 )			/* m11 | m10 | m9  | m8  */
+	MOVAPS( MAT(12), XMM7 )			/* m15 | m14 | m13 | m12 */
+
+ALIGNTEXT16
+LLBL( sse_general_loop ):
+
+	MOVSS( SRC(0), XMM0 )			/* ox */
+	SHUFPS( CONST(0x0), XMM0, XMM0 )	/* ox | ox | ox | ox */
+	MULPS( XMM4, XMM0 )			/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
+
+	MOVSS( SRC(1), XMM1 )			/* oy */
+	SHUFPS( CONST(0x0), XMM1, XMM1 )	/* oy | oy | oy | oy */
+	MULPS( XMM5, XMM1 )			/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
+
+	MOVSS( SRC(2), XMM2 )			/* oz */
+	SHUFPS( CONST(0x0), XMM2, XMM2 )	/* oz | oz | oz | oz */
+	MULPS( XMM6, XMM2 )			/* oz*m11 | oz*m10 | oz*m9 | oz*m8 */
+
+	MOVSS( SRC(3), XMM3 )			/* ow */
+	SHUFPS( CONST(0x0), XMM3, XMM3 )	/* ow | ow | ow | ow */
+	MULPS( XMM7, XMM3 )			/* ow*m15 | ow*m14 | ow*m13 | ow*m12 */
+
+	ADDPS( XMM1, XMM0 )			/* ox*m3+oy*m7 | ... */
+	ADDPS( XMM2, XMM0 )			/* ox*m3+oy*m7+oz*m11 | ... */
+	ADDPS( XMM3, XMM0 )			/* ox*m3+oy*m7+oz*m11+ow*m15 | ... */
+	MOVAPS( XMM0, DST(0) )			/* ->D(3) | ->D(2) | ->D(1) | ->D(0) */
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+
+	DEC_L( ECX )
+	JNZ( LLBL( sse_general_loop ) )
+
+LLBL( sse_general_done ):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME( _mesa_sse_transform_points4_3d )
+GLNAME( _mesa_sse_transform_points4_3d ):
+
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )		/* ptr to source GLvector4f */
+	MOV_L( ARG_DEST, EDI )			/* ptr to dest GLvector4f */
+
+	MOV_L( ARG_MATRIX, EDX )		/* ptr to matrix */
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )	/* source count */
+
+	TEST_L( ECX, ECX)
+	JZ( LLBL(K_GTP43P3DR_finish) )		/* count was zero; go to finish */
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )	/* stride */
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) ) /* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )	/* set dest count */
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )/* set dest size */
+
+	SHL_L( CONST(4), ECX )			/* count *= 16 */
+	MOV_L( REGOFF(V4F_START, ESI), ESI )	/* ptr to first source vertex */
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )	/* ptr to first dest vertex */
+	ADD_L( EDI, ECX )			/* count += dest ptr */
+
+	MOVAPS( MAT(0), XMM0 )			/* m3  | m2  | m1  |  m0 */
+	MOVAPS( MAT(4), XMM1 )			/* m7  | m6  | m5  |  m4 */
+	MOVAPS( MAT(8), XMM2 )			/* m11 | m10 | m9  |  m8 */
+	MOVAPS( MAT(12), XMM3 )			/* m15 | m14 | m13 | m12 */
+
+ALIGNTEXT32
+LLBL( K_GTP43P3DR_top ):
+	MOVSS( SRC(0), XMM4 )			/* ox */
+	SHUFPS( CONST(0x0), XMM4, XMM4 )	/* ox | ox | ox | ox */
+	MULPS( XMM0, XMM4 )			/* ox*m3 | ox*m2 | ox*m1 | ox*m0 */
+
+	MOVSS( SRC(1), XMM5 )			/* oy */
+	SHUFPS( CONST(0x0), XMM5, XMM5 )	/* oy | oy | oy | oy */
+	MULPS( XMM1, XMM5 )			/* oy*m7 | oy*m6 | oy*m5 | oy*m4 */
+
+	MOVSS( SRC(2), XMM6 )			/* oz */
+	SHUFPS( CONST(0x0), XMM6, XMM6 )	/* oz | oz | oz | oz */
+	MULPS( XMM2, XMM6 )			/* oz*m11 | oz*m10 | oz*m9 | oz*m8 */
+
+	MOVSS( SRC(3), XMM7 )			/* ow */
+	SHUFPS( CONST(0x0), XMM7, XMM7 )	/* ow | ow | ow | ow */
+	MULPS( XMM3, XMM7 )			/* ow*m15 | ow*m14 | ow*m13 | ow*m12 */
+
+	ADDPS( XMM5, XMM4 )			/* ox*m3+oy*m7 | ... */
+	ADDPS( XMM6, XMM4 )			/* ox*m3+oy*m7+oz*m11 | ... */
+	ADDPS( XMM7, XMM4 )			/* ox*m3+oy*m7+oz*m11+ow*m15 | ... */
+	MOVAPS( XMM4, DST(0) )			/* ->D(3) | ->D(2) | ->D(1) | ->D(0) */
+
+	MOVSS( SRC(3), XMM4 )			/* ow */
+	MOVSS( XMM4, DST(3) )			/* ->D(3) */
+
+LLBL( K_GTP43P3DR_skip ):
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(K_GTP43P3DR_top) )
+
+LLBL( K_GTP43P3DR_finish ):
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_sse_transform_points4_identity )
+GLNAME( _mesa_sse_transform_points4_identity ):
+
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )			/* verify non-zero count */
+	JE( LLBL( sse_identity_done ) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )	/* stride */
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) ) /* set dest flags */
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )	/* set dest count */
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )/* set dest size */
+
+	MOV_L( REGOFF(V4F_START, ESI), ESI )	/* ptr to first source vertex */
+	MOV_L( REGOFF(V4F_START, EDI), EDI )	/* ptr to first dest vertex */
+
+ALIGNTEXT16
+LLBL( sse_identity_loop ):
+
+	PREFETCHNTA( REGOFF(32, ESI) )
+
+	MOVAPS( REGIND(ESI), XMM0 )
+	ADD_L( EAX, ESI )
+
+	MOVAPS( XMM0, REGIND(EDI) )
+	ADD_L( CONST(16), EDI )
+
+	DEC_L( ECX )
+	JNZ( LLBL( sse_identity_loop ) )
+
+LLBL( sse_identity_done ):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
Index: xc/extras/Mesa/src/X86/x86.c
diff -u xc/extras/Mesa/src/X86/x86.c:1.8 xc/extras/Mesa/src/X86/x86.c:1.9
--- xc/extras/Mesa/src/X86/x86.c:1.8	Mon Nov 13 18:31:17 2000
+++ xc/extras/Mesa/src/X86/x86.c	Fri Feb 22 14:31:38 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -29,109 +29,79 @@
 
 #include "glheader.h"
 #include "context.h"
-#include "types.h"
-#include "vertices.h"
-#include "xform.h"
+#include "math/m_vertices.h"
+#include "math/m_xform.h"
+#include "tnl/t_context.h"
+
 #include "x86.h"
+#include "common_x86_macros.h"
 
 #ifdef DEBUG
-#include "debug_xform.h"
+#include "math/m_debug.h"
 #endif
 
 
-#define XFORM_ARGS 	GLvector4f *to_vec, 				\
-			const GLfloat m[16], 				\
-			const GLvector4f *from_vec, 			\
-			const GLubyte *mask, 				\
-			const GLubyte flag
-
-
-#define DECLARE_XFORM_GROUP( pfx, sz, masked ) \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_general_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_identity_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_3d_no_rot_##masked( XFORM_ARGS );    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_perspective_##masked( XFORM_ARGS );  \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_2d_##masked( XFORM_ARGS );	    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_2d_no_rot_##masked( XFORM_ARGS );    \
- extern void _ASMAPI gl_##pfx##_transform_points##sz##_3d_##masked( XFORM_ARGS );
-
-
-#define ASSIGN_XFORM_GROUP( pfx, cma, sz, masked )			\
-   gl_transform_tab[cma][sz][MATRIX_GENERAL] =				\
-      gl_##pfx##_transform_points##sz##_general_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_IDENTITY] =				\
-      gl_##pfx##_transform_points##sz##_identity_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_3D_NO_ROT] =			\
-      gl_##pfx##_transform_points##sz##_3d_no_rot_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_PERSPECTIVE] =			\
-      gl_##pfx##_transform_points##sz##_perspective_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_2D] =				\
-      gl_##pfx##_transform_points##sz##_2d_##masked;			\
-   gl_transform_tab[cma][sz][MATRIX_2D_NO_ROT] =			\
-      gl_##pfx##_transform_points##sz##_2d_no_rot_##masked;		\
-   gl_transform_tab[cma][sz][MATRIX_3D] =				\
-      gl_##pfx##_transform_points##sz##_3d_##masked;
-
-
 #ifdef USE_X86_ASM
-DECLARE_XFORM_GROUP( x86, 2, raw )
-DECLARE_XFORM_GROUP( x86, 3, raw )
-DECLARE_XFORM_GROUP( x86, 4, raw )
-DECLARE_XFORM_GROUP( x86, 2, masked )
-DECLARE_XFORM_GROUP( x86, 3, masked )
-DECLARE_XFORM_GROUP( x86, 4, masked )
-
-
-extern GLvector4f * _ASMAPI gl_x86_cliptest_points4( GLvector4f *clip_vec,
-						     GLvector4f *proj_vec,
-						     GLubyte clipMask[],
-						     GLubyte *orMask,
-						     GLubyte *andMask );
-
-
-extern void _ASMAPI gl_v16_x86_cliptest_points4( GLfloat *first_vert,
-						 GLfloat *last_vert,
-						 GLubyte *or_mask,
-						 GLubyte *and_mask,
-						 GLubyte *clip_mask );
-
-
-extern void _ASMAPI gl_v16_x86_general_xform( GLfloat *dest,
-					      const GLfloat *m,
-					      const GLfloat *src,
-					      GLuint src_stride,
-					      GLuint count );
+DECLARE_XFORM_GROUP( x86, 2 )
+DECLARE_XFORM_GROUP( x86, 3 )
+DECLARE_XFORM_GROUP( x86, 4 )
+
+
+extern GLvector4f * _ASMAPI
+_mesa_x86_cliptest_points4( GLvector4f *clip_vec,
+			    GLvector4f *proj_vec,
+			    GLubyte clipMask[],
+			    GLubyte *orMask,
+			    GLubyte *andMask );
+
+extern GLvector4f * _ASMAPI
+_mesa_x86_cliptest_points4_np( GLvector4f *clip_vec,
+			       GLvector4f *proj_vec,
+			       GLubyte clipMask[],
+			       GLubyte *orMask,
+			       GLubyte *andMask );
+
+extern void _ASMAPI
+_mesa_v16_x86_cliptest_points4( GLfloat *first_vert,
+				GLfloat *last_vert,
+				GLubyte *or_mask,
+				GLubyte *and_mask,
+				GLubyte *clip_mask );
+
+extern void _ASMAPI
+_mesa_v16_x86_general_xform( GLfloat *dest,
+			     const GLfloat *m,
+			     const GLfloat *src,
+			     GLuint src_stride,
+			     GLuint count );
 #endif
 
 
-void gl_init_x86_transform_asm( void )
+void _mesa_init_x86_transform_asm( void )
 {
 #ifdef USE_X86_ASM
-   ASSIGN_XFORM_GROUP( x86, 0, 2, raw );
-   ASSIGN_XFORM_GROUP( x86, 0, 3, raw );
-   ASSIGN_XFORM_GROUP( x86, 0, 4, raw );
-
-   ASSIGN_XFORM_GROUP( x86, CULL_MASK_ACTIVE, 2, masked );
-   ASSIGN_XFORM_GROUP( x86, CULL_MASK_ACTIVE, 3, masked );
-   ASSIGN_XFORM_GROUP( x86, CULL_MASK_ACTIVE, 4, masked );
+   ASSIGN_XFORM_GROUP( x86, 2 );
+   ASSIGN_XFORM_GROUP( x86, 3 );
+   ASSIGN_XFORM_GROUP( x86, 4 );
 
-   /* XXX this function has been found to cause FP overflow exceptions */
-   gl_clip_tab[4] = gl_x86_cliptest_points4;
+   _mesa_clip_tab[4] = _mesa_x86_cliptest_points4;
+   _mesa_clip_np_tab[4] = _mesa_x86_cliptest_points4_np;
 
 #ifdef DEBUG
-   gl_test_all_transform_functions( "x86" );
+   _math_test_all_transform_functions( "x86" );
+   _math_test_all_cliptest_functions( "x86" );
 #endif
 #endif
 }
 
-void gl_init_x86_vertex_asm( void )
+void _mesa_init_x86_vertex_asm( void )
 {
 #ifdef USE_X86_ASM
-   gl_xform_points3_v16_general	= gl_v16_x86_general_xform;
-   gl_cliptest_points4_v16	= gl_v16_x86_cliptest_points4;
+   _mesa_xform_points3_v16_general = _mesa_v16_x86_general_xform;
+   _mesa_cliptest_points4_v16 = _mesa_v16_x86_cliptest_points4;
 
-#if 0
-   gl_test_all_vertex_functions( "x86" );
+#if 0 /* DEBUG */
+   _math_test_all_vertex_functions( "x86" );
 #endif
 #endif
 }
Index: xc/extras/Mesa/src/X86/x86.h
diff -u xc/extras/Mesa/src/X86/x86.h:1.4 xc/extras/Mesa/src/X86/x86.h:1.5
--- xc/extras/Mesa/src/X86/x86.h:1.4	Mon Nov 13 16:55:50 2000
+++ xc/extras/Mesa/src/X86/x86.h	Fri Feb 22 14:31:38 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -30,7 +30,7 @@
 #ifndef __X86_H__
 #define __X86_H__
 
-extern void gl_init_x86_transform_asm( void );
-extern void gl_init_x86_vertex_asm( void );
+extern void _mesa_init_x86_transform_asm( void );
+extern void _mesa_init_x86_vertex_asm( void );
 
 #endif
Index: xc/extras/Mesa/src/X86/x86_cliptest.S
diff -u xc/extras/Mesa/src/X86/x86_cliptest.S:1.2 xc/extras/Mesa/src/X86/x86_cliptest.S:1.4
--- xc/extras/Mesa/src/X86/x86_cliptest.S:1.2	Fri Dec  1 09:28:50 2000
+++ xc/extras/Mesa/src/X86/x86_cliptest.S	Tue Mar  5 15:27:24 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,55 +22,68 @@
  * 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.
  */
+/* $XFree86: xc/extras/Mesa/src/X86/x86_cliptest.S,v 1.4 2002/03/05 20:27:24 dawes Exp $ */
 
-#include "assyntax.h"
-#include "clip_args.h"
+/*
+ * NOTE: Avoid using spaces in between '(' ')' and arguments, especially
+ * with macros like CONST, LLBL that expand to CONCAT(...).  Putting spaces
+ * in there will break the build on some platforms.
+ */
 
-#define FP_ONE		1065353216
-#define FP_ZERO		0
+#include "matypes.h"
+#include "clip_args.h"
 
-#define SRC(i)		REGOFF(i * 4, ESI)
-#define DST(i)		REGOFF(i * 4, EDI)
-#define MAT(i)		REGOFF(i * 4, EDX)
+#define SRC0		REGOFF(0, ESI)
+#define SRC1		REGOFF(4, ESI)
+#define SRC2		REGOFF(8, ESI)
+#define SRC3		REGOFF(12, ESI)
+#define DST0		REGOFF(0, EDI)
+#define DST1		REGOFF(4, EDI)
+#define DST2		REGOFF(8, EDI)
+#define DST3		REGOFF(12, EDI)
+#define MAT0		REGOFF(0, EDX)
+#define MAT1		REGOFF(4, EDX)
+#define MAT2		REGOFF(8, EDX)
+#define MAT3		REGOFF(12, EDX)
 
 
 /*
  * Table for clip test.
  *
- * 	bit6 = SRC(3) < 0
- * 	bit5 = SRC(2) < 0
+ * 	bit6 = SRC3 < 0
+ * 	bit5 = SRC2 < 0
  * 	bit4 = abs(S(2)) > abs(S(3))
- * 	bit3 = SRC(1) < 0
+ * 	bit3 = SRC1 < 0
  * 	bit2 = abs(S(1)) > abs(S(3))
- * 	bit1 = SRC(0) < 0
+ * 	bit1 = SRC0 < 0
  * 	bit0 = abs(S(0)) > abs(S(3))
  */
 
 	SEG_DATA
 
 clip_table:
-	D_BYTE 0, 1, 0, 2, 4, 5, 4, 6
-	D_BYTE 0, 1, 0, 2, 8, 9, 8, 10
-	D_BYTE 32, 33, 32, 34, 36, 37, 36, 38
-	D_BYTE 32, 33, 32, 34, 40, 41, 40, 42
-	D_BYTE 0, 1, 0, 2, 4, 5, 4, 6
-	D_BYTE 0, 1, 0, 2, 8, 9, 8, 10
-	D_BYTE 16, 17, 16, 18, 20, 21, 20, 22
-	D_BYTE 16, 17, 16, 18, 24, 25, 24, 26
-	D_BYTE 63, 61, 63, 62, 55, 53, 55, 54
-	D_BYTE 63, 61, 63, 62, 59, 57, 59, 58
-	D_BYTE 47, 45, 47, 46, 39, 37, 39, 38
-	D_BYTE 47, 45, 47, 46, 43, 41, 43, 42
-	D_BYTE 63, 61, 63, 62, 55, 53, 55, 54
-	D_BYTE 63, 61, 63, 62, 59, 57, 59, 58
-	D_BYTE 31, 29, 31, 30, 23, 21, 23, 22
-	D_BYTE 31, 29, 31, 30, 27, 25, 27, 26
+	D_BYTE 0x00, 0x01, 0x00, 0x02, 0x04, 0x05, 0x04, 0x06
+	D_BYTE 0x00, 0x01, 0x00, 0x02, 0x08, 0x09, 0x08, 0x0a
+	D_BYTE 0x20, 0x21, 0x20, 0x22, 0x24, 0x25, 0x24, 0x26
+	D_BYTE 0x20, 0x21, 0x20, 0x22, 0x28, 0x29, 0x28, 0x2a
+	D_BYTE 0x00, 0x01, 0x00, 0x02, 0x04, 0x05, 0x04, 0x06
+	D_BYTE 0x00, 0x01, 0x00, 0x02, 0x08, 0x09, 0x08, 0x0a
+	D_BYTE 0x10, 0x11, 0x10, 0x12, 0x14, 0x15, 0x14, 0x16
+	D_BYTE 0x10, 0x11, 0x10, 0x12, 0x18, 0x19, 0x18, 0x1a
+	D_BYTE 0x3f, 0x3d, 0x3f, 0x3e, 0x37, 0x35, 0x37, 0x36
+	D_BYTE 0x3f, 0x3d, 0x3f, 0x3e, 0x3b, 0x39, 0x3b, 0x3a
+	D_BYTE 0x2f, 0x2d, 0x2f, 0x2e, 0x27, 0x25, 0x27, 0x26
+	D_BYTE 0x2f, 0x2d, 0x2f, 0x2e, 0x2b, 0x29, 0x2b, 0x2a
+	D_BYTE 0x3f, 0x3d, 0x3f, 0x3e, 0x37, 0x35, 0x37, 0x36
+	D_BYTE 0x3f, 0x3d, 0x3f, 0x3e, 0x3b, 0x39, 0x3b, 0x3a
+	D_BYTE 0x1f, 0x1d, 0x1f, 0x1e, 0x17, 0x15, 0x17, 0x16
+	D_BYTE 0x1f, 0x1d, 0x1f, 0x1e, 0x1b, 0x19, 0x1b, 0x1a
 
 
 	SEG_TEXT
 
 /*
- * gl_x86_cliptest_points4
+ * _mesa_x86_cliptest_points4
  *
  *   AL:  ormask
  *   AH:  andmask
@@ -87,8 +100,8 @@
 #endif
 
 ALIGNTEXT16
-GLOBL GLNAME( gl_x86_cliptest_points4 )
-GLNAME( gl_x86_cliptest_points4 ):
+GLOBL GLNAME( _mesa_x86_cliptest_points4 )
+GLNAME( _mesa_x86_cliptest_points4 ):
 
 #ifdef ELFPIC
 #define FRAME_OFFSET 20
@@ -102,18 +115,18 @@
 
 #ifdef ELFPIC
 	/* store pointer to clip_table on stack */
-	CALL( LLBL( ctp4_get_eip ) )
+	CALL( LLBL(ctp4_get_eip) )
 	ADD_L( CONST(_GLOBAL_OFFSET_TABLE_), EBX )
 	MOV_L( REGOFF(clip_table@GOT, EBX), EBX )
 	PUSH_L( EBX )
-	JMP( LLBL( ctp4_clip_table_ready ) )
+	JMP( LLBL(ctp4_clip_table_ready) )
 
-LLBL( ctp4_get_eip ):
+LLBL(ctp4_get_eip):
 	/* store eip in ebx */
 	MOV_L( REGIND(ESP), EBX )
 	RET
 
-LLBL( ctp4_clip_table_ready ):
+LLBL(ctp4_clip_table_ready):
 #endif
 
 	MOV_L( ARG_SOURCE, ESI )
@@ -131,7 +144,7 @@
 	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
 	MOV_L( EAX, ARG_SOURCE )	/* put stride in ARG_SOURCE */
 
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
 	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
 
 	MOV_L( REGOFF(V4F_START, EDI), EDI )
@@ -143,16 +156,16 @@
 	MOV_B( REGIND(EBX), AL )
 	MOV_B( REGIND(EBP), AH )
 
-	JZ( LLBL( ctp4_finish ) )
+	JZ( LLBL(ctp4_finish) )
 
 ALIGNTEXT16
-LLBL( ctp4_top ):
+LLBL(ctp4_top):
 
-	FLD1			/* F3 */
-	FDIV_S( SRC(3) )
+	FLD1				/* F3 */
+	FDIV_S( SRC3 )		/* GH: don't care about div-by-zero */
 
-	MOV_L( SRC(3), EBP )
-	MOV_L( SRC(2), EBX )
+	MOV_L( SRC3, EBP )
+	MOV_L( SRC2, EBX )
 
 	XOR_L( ECX, ECX )
 	ADD_L( EBP, EBP )	/* ebp = abs(S(3))*2 ; carry = sign of S(3) */
@@ -164,7 +177,7 @@
 	CMP_L( EBX, EBP )	/* carry = abs(S(2))*2 > abs(S(3))*2 */
 
 	ADC_L( ECX, ECX )
-	MOV_L( SRC(1), EBX )
+	MOV_L( SRC1, EBX )
 
 	ADD_L( EBX, EBX )	/* ebx = abs(S(1))*2 ; carry = sign of S(1) */
 
@@ -172,7 +185,7 @@
 	CMP_L( EBX, EBP )	/* carry = abs(S(1))*2 > abs(S(3))*2 */
 
 	ADC_L( ECX, ECX )
-	MOV_L( SRC(0), EBX )
+	MOV_L( SRC0, EBX )
 
 	ADD_L( EBX, EBX )	/* ebx = abs(S(0))*2 ; carry = sign of S(0) */
 
@@ -195,29 +208,37 @@
 	TEST_B( CL, CL )
 	MOV_B( CL, REGIND(EDX) )
 
-	JZ( LLBL( ctp4_proj ) )
+	JZ( LLBL(ctp4_proj) )
 
+LLBL(ctp4_noproj):
+
 	FSTP( ST(0) )			/* */
-	JMP( LLBL( ctp4_next ) )
+
+	MOV_L( CONST(0), DST0 )
+	MOV_L( CONST(0), DST1 )
+	MOV_L( CONST(0), DST2 )
+	MOV_L( CONST(0x3f800000), DST3 )
 
-LLBL( ctp4_proj ):
+	JMP( LLBL(ctp4_next) )
 
-	FLD_S( SRC(0) )			/* F0 F3 */
-	FMUL2( ST(1), ST(0) )
+LLBL(ctp4_proj):
 
-	FLD_S( SRC(1) )			/* F1 F0 F3 */
-	FMUL2( ST(2), ST(0) )
+	FLD_S( SRC0 )			/* F0 F3 */
+	FMUL2( ST(1), ST0 )
 
-	FLD_S( SRC(2) )			/* F2 F1 F0 F3 */
-	FMUL2( ST(3), ST(0) )
+	FLD_S( SRC1 )			/* F1 F0 F3 */
+	FMUL2( ST(2), ST0 )
 
+	FLD_S( SRC2 )			/* F2 F1 F0 F3 */
+	FMUL2( ST(3), ST0 )
+
 	FXCH( ST(2) )			/* F0 F1 F2 F3 */
-	FSTP_S( DST(0) )		/* F1 F2 F3 */
-	FSTP_S( DST(1) )		/* F2 F3 */
-	FSTP_S( DST(2) )		/* F3 */
-	FSTP_S( DST(3) )		/* */
+	FSTP_S( DST0 )		/* F1 F2 F3 */
+	FSTP_S( DST1 )		/* F2 F3 */
+	FSTP_S( DST2 )		/* F3 */
+	FSTP_S( DST3 )		/* */
 
-LLBL( ctp4_next ):
+LLBL(ctp4_next):
 
 	INC_L( EDX )
 	ADD_L( CONST(16), EDI )
@@ -225,7 +246,7 @@
 	ADD_L( ARG_SOURCE, ESI )
 	CMP_L( EDX, ARG_CLIP )
 
-	JNZ( LLBL( ctp4_top ) )
+	JNZ( LLBL(ctp4_top) )
 
 	MOV_L( ARG_OR, ECX )
 	MOV_L( ARG_AND, EDX )
@@ -233,9 +254,142 @@
 	MOV_B( AL, REGIND(ECX) )
 	MOV_B( AH, REGIND(EDX) )
 
-LLBL( ctp4_finish ):
+LLBL(ctp4_finish):
 
 	MOV_L( ARG_DEST, EAX )
+#ifdef ELFPIC
+	POP_L( ESI )			/* discard ptr to clip_table */
+#endif
+	POP_L( EBX )
+	POP_L( EBP )
+	POP_L( EDI )
+	POP_L( ESI )
+
+	RET
+
+
+
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_cliptest_points4_np )
+GLNAME( _mesa_x86_cliptest_points4_np ):
+
+#ifdef ELFPIC
+#define FRAME_OFFSET 20
+#else
+#define FRAME_OFFSET 16
+#endif
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBP )
+	PUSH_L( EBX )
+
+#ifdef ELFPIC
+	/* store pointer to clip_table on stack */
+	CALL( LLBL(ctp4_np_get_eip) )
+	ADD_L( CONST(_GLOBAL_OFFSET_TABLE_), EBX )
+	MOV_L( REGOFF(clip_table@GOT, EBX), EBX )
+	PUSH_L( EBX )
+	JMP( LLBL(ctp4_np_clip_table_ready) )
+
+LLBL(ctp4_np_get_eip):
+	/* store eip in ebx */
+	MOV_L( REGIND(ESP), EBX )
+	RET
+
+LLBL(ctp4_np_clip_table_ready):
+#endif
+
+	MOV_L( ARG_SOURCE, ESI )
+	/* slot */
+
+	MOV_L( ARG_CLIP, EDX )
+	MOV_L( ARG_OR, EBX )
+
+	MOV_L( ARG_AND, EBP )
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( EAX, ARG_DEST )   	/* put stride in ARG_DEST */
+	ADD_L( EDX, ECX )
+
+	MOV_L( ECX, EDI )		/* put clipmask + count in EDI */
+	CMP_L( ECX, EDX )
+
+	MOV_B( REGIND(EBX), AL )
+	MOV_B( REGIND(EBP), AH )
+
+	JZ( LLBL(ctp4_np_finish) )
+
+ALIGNTEXT16
+LLBL(ctp4_np_top):
+
+	MOV_L( SRC3, EBP )
+	MOV_L( SRC2, EBX )
+
+	XOR_L( ECX, ECX )
+	ADD_L( EBP, EBP )	/* ebp = abs(S(3))*2 ; carry = sign of S(3) */
+
+	ADC_L( ECX, ECX )
+	ADD_L( EBX, EBX )	/* ebx = abs(S(2))*2 ; carry = sign of S(2) */
+
+	ADC_L( ECX, ECX )
+	CMP_L( EBX, EBP )	/* carry = abs(S(2))*2 > abs(S(3))*2 */
+
+	ADC_L( ECX, ECX )
+	MOV_L( SRC1, EBX )
+
+	ADD_L( EBX, EBX )	/* ebx = abs(S(1))*2 ; carry = sign of S(1) */
+
+	ADC_L( ECX, ECX )
+	CMP_L( EBX, EBP )	/* carry = abs(S(1))*2 > abs(S(3))*2 */
+
+	ADC_L( ECX, ECX )
+	MOV_L( SRC0, EBX )
+
+	ADD_L( EBX, EBX )	/* ebx = abs(S(0))*2 ; carry = sign of S(0) */
+
+	ADC_L( ECX, ECX )
+	CMP_L( EBX, EBP )	/* carry = abs(S(0))*2 > abs(S(3))*2 */
+
+	ADC_L( ECX, ECX )
+
+#ifdef ELFPIC
+	MOV_L( REGIND(ESP), EBP )	/* clip_table */
+
+	MOV_B( REGBI(EBP, ECX), CL )
+#else
+	MOV_B( REGOFF(clip_table,ECX), CL )
+#endif
+
+	OR_B( CL, AL )
+	AND_B( CL, AH )
+
+	TEST_B( CL, CL )
+	MOV_B( CL, REGIND(EDX) )
+
+	INC_L( EDX )
+	/* slot */
+
+	ADD_L( ARG_DEST, ESI )
+	CMP_L( EDX, EDI )
+
+	JNZ( LLBL(ctp4_np_top) )
+
+	MOV_L( ARG_OR, ECX )
+	MOV_L( ARG_AND, EDX )
+
+	MOV_B( AL, REGIND(ECX) )
+	MOV_B( AH, REGIND(EDX) )
+
+LLBL(ctp4_np_finish):
+
+	MOV_L( ARG_SOURCE, EAX )
 #ifdef ELFPIC
 	POP_L( ESI )			/* discard ptr to clip_table */
 #endif
Index: xc/extras/Mesa/src/X86/x86_vertex.S
diff -u xc/extras/Mesa/src/X86/x86_vertex.S:1.1.1.1 xc/extras/Mesa/src/X86/x86_vertex.S:1.2
--- xc/extras/Mesa/src/X86/x86_vertex.S:1.1.1.1	Mon Nov 13 16:34:13 2000
+++ xc/extras/Mesa/src/X86/x86_vertex.S	Tue Mar  5 15:27:24 2002
@@ -1,6 +1,8 @@
-#include "assyntax.h"
+/* $XFree86: xc/extras/Mesa/src/X86/x86_vertex.S,v 1.2 2002/03/05 20:27:24 dawes Exp $ */
 
+#include "matypes.h"
 
+
 	SEG_TEXT
 
 /*#define MAT_SX 0*/        /*  accessed by REGIND !! */
@@ -14,14 +16,23 @@
 #define FP_ONE		1065353216
 #define FP_ZERO		0
 
-#define S(i)		REGOFF(i * 4, ESI)
-#define D(i)		REGOFF(i * 4, EDI)
-#define M(i)		REGOFF(i * 4, EDX)
+#define S0		REGOFF(0, ESI)
+#define S1		REGOFF(4, ESI)
+#define S2		REGOFF(8, ESI)
+#define S3		REGOFF(12, ESI)
+#define D0		REGOFF(0, EDI)
+#define D1		REGOFF(4, EDI)
+#define D2		REGOFF(8, EDI)
+#define D3		REGOFF(12, EDI)
+#define M0		REGOFF(0, EDX)
+#define M1		REGOFF(4, EDX)
+#define M2		REGOFF(8, EDX)
+#define M3		REGOFF(12, EDX)
 
 
 
 /*
- * void gl_v16_x86_general_xform (	GLfloat *dest,
+ * void _mesa_v16_x86_general_xform (	GLfloat *dest,
  *				const GLfloat *m,
  *				const GLfloat *src,
  *                              GLuint src_stride,
@@ -33,8 +44,8 @@
  * routines hacked to match the above.
  */
 ALIGNTEXT16
-GLOBL GLNAME( gl_v16_x86_general_xform )
-GLNAME( gl_v16_x86_general_xform ):
+GLOBL GLNAME( _mesa_v16_x86_general_xform )
+GLNAME( _mesa_v16_x86_general_xform ):
 
 
 	PUSH_L ( EDI )
@@ -65,11 +76,11 @@
         FLD_S   ( REGOFF( 0x4, EDX ) )
         FMUL_S  ( REGOFF( 0x1c, ESI ) )
         FXCH    ( ST(3) )
-        FADDP   ( ST(0),ST(7) )
+        FADDP   ( ST0,ST(7) )
         FXCH    ( ST(1) )
-        FADDP   ( ST(0),ST(5) )
-        FADDP   ( ST(0),ST(3) )
-        FADDP   ( ST(0),ST(1) )
+        FADDP   ( ST0,ST(5) )
+        FADDP   ( ST0,ST(3) )
+        FADDP   ( ST0,ST(1) )
         FLD_S   ( REGOFF( 0x8, EDX ) )
         FMUL_S  ( REGOFF( 0x20, ESI ) )
         FLD_S   ( REGOFF( 0x8, EDX ) )
@@ -79,11 +90,11 @@
         FLD_S   ( REGOFF( 0x8, EDX ) )
         FMUL_S  ( REGOFF( 0x2c, ESI ) )
         FXCH    ( ST(3) )
-        FADDP   ( ST(0),ST(7) )
+        FADDP   ( ST0,ST(7) )
         FXCH    ( ST(1) )
-        FADDP   ( ST(0),ST(5) )
-        FADDP   ( ST(0),ST(3) )
-        FADDP   ( ST(0),ST(1) )
+        FADDP   ( ST0,ST(5) )
+        FADDP   ( ST0,ST(3) )
+        FADDP   ( ST0,ST(1) )
         FXCH    ( ST(3) )
         FADD_S  ( REGOFF( 0x30, ESI ) )
         FXCH    ( ST(2) )
@@ -111,13 +122,13 @@
 /*
  * Table for clip test.
  *
- * 	bit6 = S(3) < 0
- * 	bit5 = S(2) < 0
- * 	bit4 = abs(S(2)) > abs(S(3))
- * 	bit3 = S(1) < 0
- * 	bit2 = abs(S(1)) > abs(S(3))
- * 	bit1 = S(0) < 0
- * 	bit0 = abs(S(0)) > abs(S(3))
+ * 	bit6 = S3 < 0
+ * 	bit5 = S2 < 0
+ * 	bit4 = abs(S2) > abs(S3)
+ * 	bit3 = S1 < 0
+ * 	bit2 = abs(S1) > abs(S3)
+ * 	bit1 = S0 < 0
+ * 	bit0 = abs(S0) > abs(S3)
  */
 
 
@@ -147,7 +158,7 @@
 /*
 ########################################
 ##
-## gl_v16_x86_cliptest_points4
+## _mesa_v16_x86_cliptest_points4
 ##
 ## Performs cliptesting equivalent to that done by cliptest_v16()
 ## in vertices.c
@@ -176,10 +187,10 @@
 #define ELFPIC
 #endif
 
-	GLOBL GLNAME(gl_v16_x86_cliptest_points4)
+	GLOBL GLNAME(_mesa_v16_x86_cliptest_points4)
 	ALIGNTEXT4
 
-GLNAME(gl_v16_x86_cliptest_points4):
+GLNAME(_mesa_v16_x86_cliptest_points4):
 #ifdef ELFPIC
 #define V16_FRAME_OFFSET 20
 #else
@@ -223,36 +234,36 @@
 LLBL(v16_ctp4_top):
 #if 0
 	FLD1 	/* F0 */
-	FDIV_S( S(3) )
+	FDIV_S( S3 )
 #endif
 
-	MOV_L( S(3), EBP )
-	MOV_L( S(2), EBX )
+	MOV_L( S3, EBP )
+	MOV_L( S2, EBX )
 
 	XOR_L( ECX, ECX )
-	ADD_L( EBP, EBP )	/* ebp = abs(S(3))*2 ; carry = sign of S(3) */
+	ADD_L( EBP, EBP )	/* ebp = abs(S3)*2 ; carry = sign of S3 */
 
 	ADC_L( ECX, ECX )
-	ADD_L( EBX, EBX )	/* ebx = abs(S(2))*2 ; carry = sign of S(2) */
+	ADD_L( EBX, EBX )	/* ebx = abs(S2)*2 ; carry = sign of S2 */
 
 	ADC_L( ECX, ECX )
-	CMP_L( EBX, EBP )	/* carry = abs(S(2))*2 > abs(S(3))*2 */
+	CMP_L( EBX, EBP )	/* carry = abs(S2)*2 > abs(S3)*2 */
 
 	ADC_L( ECX, ECX )
-	MOV_L( S(1), EBX )
+	MOV_L( S1, EBX )
 
-	ADD_L( EBX, EBX )	/* ebx = abs(S(1))*2 ; carry = sign of S(1) */
+	ADD_L( EBX, EBX )	/* ebx = abs(S1)*2 ; carry = sign of S1 */
 
 	ADC_L( ECX, ECX )
-	CMP_L( EBX, EBP )	/* carry = abs(S(1))*2 > abs(S(3))*2 */
+	CMP_L( EBX, EBP )	/* carry = abs(S1)*2 > abs(S3)*2 */
 
 	ADC_L( ECX, ECX )
-	MOV_L( S(0), EBX )
+	MOV_L( S0, EBX )
 
-	ADD_L( EBX, EBX )	/* ebx = abs(S(0))*2 ; carry = sign of S(0) */
+	ADD_L( EBX, EBX )	/* ebx = abs(S0)*2 ; carry = sign of S0 */
 
 	ADC_L( ECX, ECX )
-	CMP_L( EBX, EBP )	/* carry = abs(S(0))*2 > abs(S(3))*2 */
+	CMP_L( EBX, EBP )	/* carry = abs(S0)*2 > abs(S3)*2 */
 
 	ADC_L( ECX, ECX )
 
@@ -271,7 +282,7 @@
 	INC_L( EDI )                 /* next clipmask */
 
 #if 0
-	FSTP_S( S(8)   ) 	/* */ 	/* GR_VERTEX_OOW_OFFSET */
+	FSTP_S( S8   ) 	/* */ 	/* GR_VERTEX_OOW_OFFSET */
 #endif
 
 	ADD_L( CONST(64), ESI )      /* next fxVertex  */
Index: xc/extras/Mesa/src/X86/x86_xform2.S
diff -u /dev/null xc/extras/Mesa/src/X86/x86_xform2.S:1.4
--- /dev/null	Thu Feb 27 12:15:56 2003
+++ xc/extras/Mesa/src/X86/x86_xform2.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,563 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/X86/x86_xform2.S,v 1.4 2002/12/16 16:18:33 dawes Exp $ */
+
+/*
+ * NOTE: Avoid using spaces in between '(' ')' and arguments, especially
+ * with macros like CONST, LLBL that expand to CONCAT(...).  Putting spaces
+ * in there will break the build on some platforms.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+	SEG_TEXT
+
+#define FP_ONE		1065353216
+#define FP_ZERO		0
+
+#define SRC0		REGOFF(0, ESI)
+#define SRC1		REGOFF(4, ESI)
+#define SRC2		REGOFF(8, ESI)
+#define SRC3		REGOFF(12, ESI)
+#define DST0		REGOFF(0, EDI)
+#define DST1		REGOFF(4, EDI)
+#define DST2		REGOFF(8, EDI)
+#define DST3		REGOFF(12, EDI)
+#define MAT0		REGOFF(0, EDX)
+#define MAT1		REGOFF(4, EDX)
+#define MAT2		REGOFF(8, EDX)
+#define MAT3		REGOFF(12, EDX)
+#define MAT4		REGOFF(16, EDX)
+#define MAT5		REGOFF(20, EDX)
+#define MAT6		REGOFF(24, EDX)
+#define MAT7		REGOFF(28, EDX)
+#define MAT8		REGOFF(32, EDX)
+#define MAT9		REGOFF(36, EDX)
+#define MAT10		REGOFF(40, EDX)
+#define MAT11		REGOFF(44, EDX)
+#define MAT12		REGOFF(48, EDX)
+#define MAT13		REGOFF(52, EDX)
+#define MAT14		REGOFF(56, EDX)
+#define MAT15		REGOFF(60, EDX)
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points2_general )
+GLNAME( _mesa_x86_transform_points2_general ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p2_gr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p2_gr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+	FLD_S( SRC0 )			/* F6 F5 F4 */
+	FMUL_S( MAT2 )
+	FLD_S( SRC0 )			/* F7 F6 F5 F4 */
+	FMUL_S( MAT3 )
+
+	FLD_S( SRC1 )			/* F0 F7 F6 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT5 )
+	FLD_S( SRC1 )			/* F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT6 )
+	FLD_S( SRC1 )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT7 )
+
+	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
+	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F7 F6 F5 F4 */
+
+	FXCH( ST(3) )			/* F4 F6 F5 F7 */
+	FADD_S( MAT12 )
+	FXCH( ST(2) )			/* F5 F6 F4 F7 */
+	FADD_S( MAT13 )
+	FXCH( ST(1) )			/* F6 F5 F4 F7 */
+	FADD_S( MAT14 )
+	FXCH( ST(3) )			/* F7 F5 F4 F6 */
+	FADD_S( MAT15 )
+
+	FXCH( ST(2) )			/* F4 F5 F7 F6 */
+	FSTP_S( DST0 )			/* F5 F7 F6 */
+	FSTP_S( DST1 )			/* F7 F6 */
+	FXCH( ST(1) )			/* F6 F7 */
+	FSTP_S( DST2 )			/* F7 */
+	FSTP_S( DST3 )			/* */
+
+LLBL(x86_p2_gr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p2_gr_loop) )
+
+LLBL(x86_p2_gr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points2_perspective )
+GLNAME( _mesa_x86_transform_points2_perspective ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p2_pr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+	MOV_L( MAT14, EBX )
+
+ALIGNTEXT16
+LLBL(x86_p2_pr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F1 F4 */
+	FMUL_S( MAT5 )
+
+	FXCH( ST(1) )			/* F4 F1 */
+	FSTP_S( DST0   )		/* F1 */
+	FSTP_S( DST1   )		/* */
+	MOV_L( EBX, DST2 )
+	MOV_L( CONST(FP_ZERO), DST3 )
+
+LLBL(x86_p2_pr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p2_pr_loop) )
+
+LLBL(x86_p2_pr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points2_3d )
+GLNAME( _mesa_x86_transform_points2_3d ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p2_3dr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p2_3dr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+	FLD_S( SRC0 )			/* F6 F5 F4 */
+	FMUL_S( MAT2 )
+
+	FLD_S( SRC1 )			/* F0 F6 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F6 F5 F4 */
+	FMUL_S( MAT5 )
+	FLD_S( SRC1 )			/* F2 F1 F0 F6 F5 F4 */
+	FMUL_S( MAT6 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	FXCH( ST(2) )			/* F4 F5 F6 */
+	FADD_S( MAT12 )
+	FXCH( ST(1) )			/* F5 F4 F6 */
+	FADD_S( MAT13 )
+	FXCH( ST(2) )			/* F6 F4 F5 */
+	FADD_S( MAT14 )
+
+	FXCH( ST(1) )			/* F4 F6 F5 */
+	FSTP_S( DST0 )			/* F6 F5 */
+	FXCH( ST(1) )			/* F5 F6 */
+	FSTP_S( DST1 )			/* F6 */
+	FSTP_S( DST2 )			/* */
+
+LLBL(x86_p2_3dr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p2_3dr_loop) )
+
+LLBL(x86_p2_3dr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points2_3d_no_rot )
+GLNAME( _mesa_x86_transform_points2_3d_no_rot ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p2_3dnrr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+	MOV_L( MAT14, EBX )
+
+ALIGNTEXT16
+LLBL(x86_p2_3dnrr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F1 F4 */
+	FMUL_S( MAT5 )
+
+	FXCH( ST(1) )			/* F4 F1 */
+	FADD_S( MAT12 )
+	FLD_S( MAT13 )		/* F5 F4 F1 */
+	FXCH( ST(2) )			/* F1 F4 F5 */
+	FADDP( ST0, ST(2) )		/* F4 F5 */
+
+	FSTP_S( DST0 )		/* F5 */
+	FSTP_S( DST1 )		/* */
+	MOV_L( EBX, DST2 )
+
+LLBL(x86_p2_3dnrr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p2_3dnrr_loop) )
+
+LLBL(x86_p2_3dnrr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points2_2d )
+GLNAME( _mesa_x86_transform_points2_2d ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p2_2dr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p2_2dr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+
+	FLD_S( SRC1 )			/* F0 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F5 F4 */
+	FMUL_S( MAT5 )
+
+	FXCH( ST(1) )			/* F0 F1 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F1 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F5 F4 */
+
+	FXCH( ST(1) )			/* F4 F5 */
+	FADD_S( MAT12 )
+	FXCH( ST(1) )			/* F5 F4 */
+	FADD_S( MAT13 )
+
+	FXCH( ST(1) )			/* F4 F5 */
+	FSTP_S( DST0 )		/* F5 */
+	FSTP_S( DST1 )		/* */
+
+LLBL(x86_p2_2dr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p2_2dr_loop) )
+
+LLBL(x86_p2_2dr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT4
+GLOBL GLNAME( _mesa_x86_transform_points2_2d_no_rot )
+GLNAME( _mesa_x86_transform_points2_2d_no_rot ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p2_2dnrr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p2_2dnrr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F1 F4 */
+	FMUL_S( MAT5 )
+
+	FXCH( ST(1) )			/* F4 F1 */
+	FADD_S( MAT12 )
+	FLD_S( MAT13 )		/* F5 F4 F1 */
+	FXCH( ST(2) )			/* F1 F4 F5 */
+	FADDP( ST0, ST(2) )		/* F4 F5 */
+
+	FSTP_S( DST0   )		/* F5 */
+	FSTP_S( DST1   )		/* */
+
+LLBL(x86_p2_2dnrr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p2_2dnrr_loop) )
+
+LLBL(x86_p2_2dnrr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points2_identity )
+GLNAME( _mesa_x86_transform_points2_identity ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p2_ir_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+	CMP_L( ESI, EDI )
+	JE( LLBL(x86_p2_ir_done) )
+
+ALIGNTEXT16
+LLBL(x86_p2_ir_loop):
+
+	MOV_L( SRC0, EBX )
+	MOV_L( SRC1, EDX )
+
+	MOV_L( EBX, DST0 )
+	MOV_L( EDX, DST1 )
+
+LLBL(x86_p2_ir_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p2_ir_loop) )
+
+LLBL(x86_p2_ir_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/x86_xform3.S
diff -u /dev/null xc/extras/Mesa/src/X86/x86_xform3.S:1.4
--- /dev/null	Thu Feb 27 12:15:57 2003
+++ xc/extras/Mesa/src/X86/x86_xform3.S	Mon Dec 16 11:18:33 2002
@@ -0,0 +1,633 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/X86/x86_xform3.S,v 1.4 2002/12/16 16:18:33 dawes Exp $ */
+
+/*
+ * NOTE: Avoid using spaces in between '(' ')' and arguments, especially
+ * with macros like CONST, LLBL that expand to CONCAT(...).  Putting spaces
+ * in there will break the build on some platforms.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+	SEG_TEXT
+
+#define FP_ONE		1065353216
+#define FP_ZERO		0
+
+#define SRC0		REGOFF(0, ESI)
+#define SRC1		REGOFF(4, ESI)
+#define SRC2		REGOFF(8, ESI)
+#define SRC3		REGOFF(12, ESI)
+#define DST0		REGOFF(0, EDI)
+#define DST1		REGOFF(4, EDI)
+#define DST2		REGOFF(8, EDI)
+#define DST3		REGOFF(12, EDI)
+#define MAT0		REGOFF(0, EDX)
+#define MAT1		REGOFF(4, EDX)
+#define MAT2		REGOFF(8, EDX)
+#define MAT3		REGOFF(12, EDX)
+#define MAT4		REGOFF(16, EDX)
+#define MAT5		REGOFF(20, EDX)
+#define MAT6		REGOFF(24, EDX)
+#define MAT7		REGOFF(28, EDX)
+#define MAT8		REGOFF(32, EDX)
+#define MAT9		REGOFF(36, EDX)
+#define MAT10		REGOFF(40, EDX)
+#define MAT11		REGOFF(44, EDX)
+#define MAT12		REGOFF(48, EDX)
+#define MAT13		REGOFF(52, EDX)
+#define MAT14		REGOFF(56, EDX)
+#define MAT15		REGOFF(60, EDX)
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points3_general )
+GLNAME( _mesa_x86_transform_points3_general ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p3_gr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p3_gr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+	FLD_S( SRC0 )			/* F6 F5 F4 */
+	FMUL_S( MAT2 )
+	FLD_S( SRC0 )			/* F7 F6 F5 F4 */
+	FMUL_S( MAT3 )
+
+	FLD_S( SRC1 )			/* F0 F7 F6 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT5 )
+	FLD_S( SRC1 )			/* F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT6 )
+	FLD_S( SRC1 )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT7 )
+
+	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
+	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F7 F6 F5 F4 */
+
+	FLD_S( SRC2 )			/* F0 F7 F6 F5 F4 */
+	FMUL_S( MAT8 )
+	FLD_S( SRC2 )			/* F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT9 )
+	FLD_S( SRC2 )			/* F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT10 )
+	FLD_S( SRC2 )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT11 )
+
+	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
+	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F7 F6 F5 F4 */
+
+	FXCH( ST(3) )			/* F4 F6 F5 F7 */
+	FADD_S( MAT12 )
+	FXCH( ST(2) )			/* F5 F6 F4 F7 */
+	FADD_S( MAT13 )
+	FXCH( ST(1) )			/* F6 F5 F4 F7 */
+	FADD_S( MAT14 )
+	FXCH( ST(3) )			/* F7 F5 F4 F6 */
+	FADD_S( MAT15 )
+
+	FXCH( ST(2) )			/* F4 F5 F7 F6 */
+	FSTP_S( DST0 )		/* F5 F7 F6 */
+	FSTP_S( DST1 )		/* F7 F6 */
+	FXCH( ST(1) )			/* F6 F7 */
+	FSTP_S( DST2 )		/* F7 */
+	FSTP_S( DST3 )		/* */
+
+LLBL(x86_p3_gr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p3_gr_loop) )
+
+LLBL(x86_p3_gr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points3_perspective )
+GLNAME( _mesa_x86_transform_points3_perspective ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p3_pr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p3_pr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F5 F4 */
+	FMUL_S( MAT5 )
+
+	FLD_S( SRC2 )			/* F0 F5 F4 */
+	FMUL_S( MAT8 )
+	FLD_S( SRC2 )			/* F1 F0 F5 F4 */
+	FMUL_S( MAT9 )
+	FLD_S( SRC2 )			/* F2 F1 F0 F5 F4 */
+	FMUL_S( MAT10 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F5 F4 */
+	FADDP( ST0, ST(4) )		/* F1 F2 F5 F4 */
+	FADDP( ST0, ST(2) )		/* F2 F5 F4 */
+	FLD_S( MAT14 )		/* F6 F2 F5 F4 */
+	FXCH( ST(1) )			/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	MOV_L( SRC2, EBX )
+	XOR_L( CONST(-2147483648), EBX )/* change sign */
+
+	FXCH( ST(2) )			/* F4 F5 F6 */
+	FSTP_S( DST0 )		/* F5 F6 */
+	FSTP_S( DST1 )		/* F6 */
+	FSTP_S( DST2 )		/* */
+	MOV_L( EBX, DST3 )
+
+LLBL(x86_p3_pr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p3_pr_loop) )
+
+LLBL(x86_p3_pr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points3_3d )
+GLNAME( _mesa_x86_transform_points3_3d ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p3_3dr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p3_3dr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+	FLD_S( SRC0 )			/* F6 F5 F4 */
+	FMUL_S( MAT2 )
+
+	FLD_S( SRC1 )			/* F0 F6 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F6 F5 F4 */
+	FMUL_S( MAT5 )
+	FLD_S( SRC1 )			/* F2 F1 F0 F6 F5 F4 */
+	FMUL_S( MAT6 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	FLD_S( SRC2 )			/* F0 F6 F5 F4 */
+	FMUL_S( MAT8 )
+	FLD_S( SRC2 )			/* F1 F0 F6 F5 F4 */
+	FMUL_S( MAT9 )
+	FLD_S( SRC2 )			/* F2 F1 F0 F6 F5 F4 */
+	FMUL_S( MAT10 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	FXCH( ST(2) )			/* F4 F5 F6 */
+	FADD_S( MAT12 )
+	FXCH( ST(1) )			/* F5 F4 F6 */
+	FADD_S( MAT13 )
+	FXCH( ST(2) )			/* F6 F4 F5 */
+	FADD_S( MAT14 )
+
+	FXCH( ST(1) )			/* F4 F6 F5 */
+	FSTP_S( DST0   )		/* F6 F5 */
+	FXCH( ST(1) )			/* F5 F6 */
+	FSTP_S( DST1   )		/* F6 */
+	FSTP_S( DST2   )		/* */
+
+LLBL(x86_p3_3dr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p3_3dr_loop) )
+
+LLBL(x86_p3_3dr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points3_3d_no_rot )
+GLNAME( _mesa_x86_transform_points3_3d_no_rot ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p3_3dnrr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p3_3dnrr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F1 F4 */
+	FMUL_S( MAT5 )
+
+	FLD_S( SRC2 )			/* F2 F1 F4 */
+	FMUL_S( MAT10 )
+
+	FXCH( ST(2) )			/* F4 F1 F2 */
+	FADD_S( MAT12 )
+	FLD_S( MAT13 )		/* F5 F4 F1 F2 */
+	FXCH( ST(2) )			/* F1 F4 F5 F2 */
+	FADDP( ST0, ST(2) )		/* F4 F5 F2 */
+	FLD_S( MAT14 )		/* F6 F4 F5 F2 */
+	FXCH( ST(3) )			/* F2 F4 F5 F6 */
+	FADDP( ST0, ST(3) )		/* F4 F5 F6 */
+
+	FSTP_S( DST0   )		/* F5 F6 */
+	FSTP_S( DST1   )		/* F6 */
+	FSTP_S( DST2   )		/* */
+
+LLBL(x86_p3_3dnrr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p3_3dnrr_loop) )
+
+LLBL(x86_p3_3dnrr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points3_2d )
+GLNAME( _mesa_x86_transform_points3_2d ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p3_2dr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p3_2dr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+
+	FLD_S( SRC1 )			/* F0 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F5 F4 */
+	FMUL_S( MAT5 )
+
+	FXCH( ST(1) )			/* F0 F1 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F1 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F5 F4 */
+
+	FXCH( ST(1) )			/* F4 F5 */
+	FADD_S( MAT12 )
+	FXCH( ST(1) )			/* F5 F4 */
+	FADD_S( MAT13 )
+
+	MOV_L( SRC2, EBX )
+
+	FXCH( ST(1) )			/* F4 F5 */
+	FSTP_S( DST0   )		/* F5 */
+	FSTP_S( DST1   )		/* */
+	MOV_L( EBX, DST2 )
+
+LLBL(x86_p3_2dr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p3_2dr_loop) )
+
+LLBL(x86_p3_2dr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points3_2d_no_rot )
+GLNAME( _mesa_x86_transform_points3_2d_no_rot ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p3_2dnrr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p3_2dnrr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F1 F4 */
+	FMUL_S( MAT5 )
+
+	FXCH( ST(1) )			/* F4 F1 */
+	FADD_S( MAT12 )
+	FLD_S( MAT13 )		/* F5 F4 F1 */
+
+	FXCH( ST(2) )			/* F1 F4 F5 */
+	FADDP( ST0, ST(2) )		/* F4 F5 */
+
+	MOV_L( SRC2, EBX )
+
+	FSTP_S( DST0 )		/* F5 */
+	FSTP_S( DST1 )		/* */
+	MOV_L( EBX, DST2 )
+
+LLBL(x86_p3_2dnrr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p3_2dnrr_loop) )
+
+LLBL(x86_p3_2dnrr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points3_identity )
+GLNAME(_mesa_x86_transform_points3_identity ):
+
+#define FRAME_OFFSET 16
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+	PUSH_L( EBP )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p3_ir_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+	CMP_L( ESI, EDI )
+	JE( LLBL(x86_p3_ir_done) )
+
+ALIGNTEXT16
+LLBL(x86_p3_ir_loop):
+
+#if 1
+	MOV_L( SRC0, EBX )
+	MOV_L( SRC1, EBP )
+	MOV_L( SRC2, EDX )
+
+	MOV_L( EBX, DST0 )
+	MOV_L( EBP, DST1 )
+	MOV_L( EDX, DST2 )
+#else
+	FLD_S( SRC0 )
+	FLD_S( SRC1 )
+	FLD_S( SRC2 )
+
+	FSTP_S( DST2 )
+	FSTP_S( DST1 )
+	FSTP_S( DST0 )
+#endif
+
+LLBL(x86_p3_ir_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p3_ir_loop) )
+
+LLBL(x86_p3_ir_done):
+
+	POP_L( EBP )
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
Index: xc/extras/Mesa/src/X86/x86_xform4.S
diff -u /dev/null xc/extras/Mesa/src/X86/x86_xform4.S:1.4
--- /dev/null	Thu Feb 27 12:15:57 2003
+++ xc/extras/Mesa/src/X86/x86_xform4.S	Mon Dec 16 11:18:34 2002
@@ -0,0 +1,666 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/X86/x86_xform4.S,v 1.4 2002/12/16 16:18:34 dawes Exp $ */
+
+/*
+ * NOTE: Avoid using spaces in between '(' ')' and arguments, especially
+ * with macros like CONST, LLBL that expand to CONCAT(...).  Putting spaces
+ * in there will break the build on some platforms.
+ */
+
+#include "matypes.h"
+#include "xform_args.h"
+
+	SEG_TEXT
+
+#define FP_ONE		1065353216
+#define FP_ZERO		0
+
+#define SRC0		REGOFF(0, ESI)
+#define SRC1		REGOFF(4, ESI)
+#define SRC2		REGOFF(8, ESI)
+#define SRC3		REGOFF(12, ESI)
+#define DST0		REGOFF(0, EDI)
+#define DST1		REGOFF(4, EDI)
+#define DST2		REGOFF(8, EDI)
+#define DST3		REGOFF(12, EDI)
+#define MAT0		REGOFF(0, EDX)
+#define MAT1		REGOFF(4, EDX)
+#define MAT2		REGOFF(8, EDX)
+#define MAT3		REGOFF(12, EDX)
+#define MAT4		REGOFF(16, EDX)
+#define MAT5		REGOFF(20, EDX)
+#define MAT6		REGOFF(24, EDX)
+#define MAT7		REGOFF(28, EDX)
+#define MAT8		REGOFF(32, EDX)
+#define MAT9		REGOFF(36, EDX)
+#define MAT10		REGOFF(40, EDX)
+#define MAT11		REGOFF(44, EDX)
+#define MAT12		REGOFF(48, EDX)
+#define MAT13		REGOFF(52, EDX)
+#define MAT14		REGOFF(56, EDX)
+#define MAT15		REGOFF(60, EDX)
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points4_general )
+GLNAME( _mesa_x86_transform_points4_general ):
+
+#define FRAME_OFFSET 8
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p4_gr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p4_gr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+	FLD_S( SRC0 )			/* F6 F5 F4 */
+	FMUL_S( MAT2 )
+	FLD_S( SRC0 )			/* F7 F6 F5 F4 */
+	FMUL_S( MAT3 )
+
+	FLD_S( SRC1 )			/* F0 F7 F6 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT5 )
+	FLD_S( SRC1 )			/* F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT6 )
+	FLD_S( SRC1 )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT7 )
+
+	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
+	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F7 F6 F5 F4 */
+
+	FLD_S( SRC2 )			/* F0 F7 F6 F5 F4 */
+	FMUL_S( MAT8 )
+	FLD_S( SRC2 )			/* F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT9 )
+	FLD_S( SRC2 )			/* F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT10 )
+	FLD_S( SRC2 )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT11 )
+
+	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
+	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F7 F6 F5 F4 */
+
+	FLD_S( SRC3 )			/* F0 F7 F6 F5 F4 */
+	FMUL_S( MAT12 )
+	FLD_S( SRC3 )			/* F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT13 )
+	FLD_S( SRC3 )			/* F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT14 )
+	FLD_S( SRC3 )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
+	FMUL_S( MAT15 )
+
+	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
+	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F2 F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F3 F7 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F7 F6 F5 F4 */
+
+	FXCH( ST(3) )			/* F4 F6 F5 F7 */
+	FSTP_S( DST0 )		/* F6 F5 F7 */
+	FXCH( ST(1) )			/* F5 F6 F7 */
+	FSTP_S( DST1 )		/* F6 F7 */
+	FSTP_S( DST2 )		/* F7 */
+	FSTP_S( DST3 )		/* */
+
+LLBL(x86_p4_gr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p4_gr_loop) )
+
+LLBL(x86_p4_gr_done):
+
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points4_perspective )
+GLNAME( _mesa_x86_transform_points4_perspective ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p4_pr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p4_pr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F5 F4 */
+	FMUL_S( MAT5 )
+
+	FLD_S( SRC2 )			/* F0 F5 F4 */
+	FMUL_S( MAT8 )
+	FLD_S( SRC2 )			/* F1 F0 F5 F4 */
+	FMUL_S( MAT9 )
+	FLD_S( SRC2 )			/* F6 F1 F0 F5 F4 */
+	FMUL_S( MAT10 )
+
+	FXCH( ST(2) )			/* F0 F1 F6 F5 F4 */
+	FADDP( ST0, ST(4) )		/* F1 F6 F5 F4 */
+	FADDP( ST0, ST(2) )		/* F6 F5 F4 */
+
+	FLD_S( SRC3 )			/* F2 F6 F5 F4 */
+	FMUL_S( MAT14 )
+
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	MOV_L( SRC2, EBX )
+	XOR_L( CONST(-2147483648), EBX )/* change sign */
+
+	FXCH( ST(2) )			/* F4 F5 F6 */
+	FSTP_S( DST0 )		/* F5 F6 */
+	FSTP_S( DST1 )		/* F6 */
+	FSTP_S( DST2 )		/* */
+	MOV_L( EBX, DST3 )
+
+LLBL(x86_p4_pr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p4_pr_loop) )
+
+LLBL(x86_p4_pr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points4_3d )
+GLNAME( _mesa_x86_transform_points4_3d ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p4_3dr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p4_3dr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+	FLD_S( SRC0 )			/* F6 F5 F4 */
+	FMUL_S( MAT2 )
+
+	FLD_S( SRC1 )			/* F0 F6 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F6 F5 F4 */
+	FMUL_S( MAT5 )
+	FLD_S( SRC1 )			/* F2 F1 F0 F6 F5 F4 */
+	FMUL_S( MAT6 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	FLD_S( SRC2 )			/* F0 F6 F5 F4 */
+	FMUL_S( MAT8 )
+	FLD_S( SRC2 )			/* F1 F0 F6 F5 F4 */
+	FMUL_S( MAT9 )
+	FLD_S( SRC2 )			/* F2 F1 F0 F6 F5 F4 */
+	FMUL_S( MAT10 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	FLD_S( SRC3 )			/* F0 F6 F5 F4 */
+	FMUL_S( MAT12 )
+	FLD_S( SRC3 )			/* F1 F0 F6 F5 F4 */
+	FMUL_S( MAT13 )
+	FLD_S( SRC3 )			/* F2 F1 F0 F6 F5 F4 */
+	FMUL_S( MAT14 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	MOV_L( SRC3, EBX )
+
+	FXCH( ST(2) )			/* F4 F5 F6 */
+	FSTP_S( DST0 )		/* F5 F6 */
+	FSTP_S( DST1 )		/* F6 */
+	FSTP_S( DST2 )		/* */
+	MOV_L( EBX, DST3 )
+
+LLBL(x86_p4_3dr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p4_3dr_loop) )
+
+LLBL(x86_p4_3dr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME(_mesa_x86_transform_points4_3d_no_rot)
+GLNAME(_mesa_x86_transform_points4_3d_no_rot):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p4_3dnrr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p4_3dnrr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F5 F4 */
+	FMUL_S( MAT5 )
+
+	FLD_S( SRC2 )			/* F6 F5 F4 */
+	FMUL_S( MAT10 )
+
+	FLD_S( SRC3 )			/* F0 F6 F5 F4 */
+	FMUL_S( MAT12 )
+	FLD_S( SRC3 )			/* F1 F0 F6 F5 F4 */
+	FMUL_S( MAT13 )
+	FLD_S( SRC3 )			/* F2 F1 F0 F6 F5 F4 */
+	FMUL_S( MAT14 )
+
+	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(5) )		/* F1 F2 F6 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F2 F6 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F6 F5 F4 */
+
+	MOV_L( SRC3, EBX )
+
+	FXCH( ST(2) )			/* F4 F5 F6 */
+	FSTP_S( DST0   )		/* F5 F6 */
+	FSTP_S( DST1   )		/* F6 */
+	FSTP_S( DST2   )		/* */
+	MOV_L( EBX, DST3 )
+
+LLBL(x86_p4_3dnrr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p4_3dnrr_loop) )
+
+LLBL(x86_p4_3dnrr_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points4_2d )
+GLNAME( _mesa_x86_transform_points4_2d ):
+
+#define FRAME_OFFSET 16
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+	PUSH_L( EBP )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p4_2dr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p4_2dr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+	FLD_S( SRC0 )			/* F5 F4 */
+	FMUL_S( MAT1 )
+
+	FLD_S( SRC1 )			/* F0 F5 F4 */
+	FMUL_S( MAT4 )
+	FLD_S( SRC1 )			/* F1 F0 F5 F4 */
+	FMUL_S( MAT5 )
+
+	FXCH( ST(1) )			/* F0 F1 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F1 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F5 F4 */
+
+	FLD_S( SRC3 )			/* F0 F5 F4 */
+	FMUL_S( MAT12 )
+	FLD_S( SRC3 )			/* F1 F0 F5 F4 */
+	FMUL_S( MAT13 )
+
+	FXCH( ST(1) )			/* F0 F1 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F1 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F5 F4 */
+
+	MOV_L( SRC2, EBX )
+	MOV_L( SRC3, EBP )
+
+	FXCH( ST(1) )			/* F4 F5 */
+	FSTP_S( DST0 )		/* F5 */
+	FSTP_S( DST1 )		/* */
+	MOV_L( EBX, DST2 )
+	MOV_L( EBP, DST3 )
+
+LLBL(x86_p4_2dr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p4_2dr_loop) )
+
+LLBL(x86_p4_2dr_done):
+
+	POP_L( EBP )
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points4_2d_no_rot )
+GLNAME( _mesa_x86_transform_points4_2d_no_rot ):
+
+#define FRAME_OFFSET 16
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+	PUSH_L( EBP )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p4_2dnrr_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+ALIGNTEXT16
+LLBL(x86_p4_2dnrr_loop):
+
+	FLD_S( SRC0 )			/* F4 */
+	FMUL_S( MAT0 )
+
+	FLD_S( SRC1 )			/* F5 F4 */
+	FMUL_S( MAT5 )
+
+	FLD_S( SRC3 )			/* F0 F5 F4 */
+	FMUL_S( MAT12 )
+	FLD_S( SRC3 )			/* F1 F0 F5 F4 */
+	FMUL_S( MAT13 )
+
+	FXCH( ST(1) )			/* F0 F1 F5 F4 */
+	FADDP( ST0, ST(3) )		/* F1 F5 F4 */
+	FADDP( ST0, ST(1) )		/* F5 F4 */
+
+	MOV_L( SRC2, EBX )
+	MOV_L( SRC3, EBP )
+
+	FXCH( ST(1) )			/* F4 F5 */
+	FSTP_S( DST0   )		/* F5 */
+	FSTP_S( DST1   )		/* */
+	MOV_L( EBX, DST2 )
+	MOV_L( EBP, DST3 )
+
+LLBL(x86_p4_2dnrr_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p4_2dnrr_loop) )
+
+LLBL(x86_p4_2dnrr_done):
+
+	POP_L( EBP )
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
+#undef FRAME_OFFSET
+
+
+
+
+ALIGNTEXT16
+GLOBL GLNAME( _mesa_x86_transform_points4_identity )
+GLNAME( _mesa_x86_transform_points4_identity ):
+
+#define FRAME_OFFSET 12
+	PUSH_L( ESI )
+	PUSH_L( EDI )
+	PUSH_L( EBX )
+
+	MOV_L( ARG_SOURCE, ESI )
+	MOV_L( ARG_DEST, EDI )
+
+	MOV_L( ARG_MATRIX, EDX )
+	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
+
+	TEST_L( ECX, ECX )
+	JZ( LLBL(x86_p4_ir_done) )
+
+	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
+	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
+
+	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
+	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
+
+	SHL_L( CONST(4), ECX )
+	MOV_L( REGOFF(V4F_START, ESI), ESI )
+
+	MOV_L( REGOFF(V4F_START, EDI), EDI )
+	ADD_L( EDI, ECX )
+
+	CMP_L( ESI, EDI )
+	JE( LLBL(x86_p4_ir_done) )
+
+ALIGNTEXT16
+LLBL(x86_p4_ir_loop):
+
+	MOV_L( SRC0, EBX )
+	MOV_L( SRC1, EDX )
+
+	MOV_L( EBX, DST0 )
+	MOV_L( EDX, DST1 )
+
+	MOV_L( SRC2, EBX )
+	MOV_L( SRC3, EDX )
+
+	MOV_L( EBX, DST2 )
+	MOV_L( EDX, DST3 )
+
+LLBL(x86_p4_ir_skip):
+
+	ADD_L( CONST(16), EDI )
+	ADD_L( EAX, ESI )
+	CMP_L( ECX, EDI )
+	JNE( LLBL(x86_p4_ir_loop) )
+
+LLBL(x86_p4_ir_done):
+
+	POP_L( EBX )
+	POP_L( EDI )
+	POP_L( ESI )
+	RET
Index: xc/extras/Mesa/src/X86/x86_xform_masked2.S
diff -u xc/extras/Mesa/src/X86/x86_xform_masked2.S:1.2 xc/extras/Mesa/src/X86/x86_xform_masked2.S:removed
--- xc/extras/Mesa/src/X86/x86_xform_masked2.S:1.2	Mon Nov 13 18:31:18 2000
+++ xc/extras/Mesa/src/X86/x86_xform_masked2.S	Thu Feb 27 12:15:57 2003
@@ -1,610 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-	SEG_TEXT
-
-#define FRAME_OFFSET	16
-
-#define FP_ONE		1065353216
-#define FP_ZERO		0
-
-#define SRC(i)		REGOFF(i * 4, ESI)
-#define DST(i)		REGOFF(i * 4, EDI)
-#define MAT(i)		REGOFF(i * 4, EDX)
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_general_masked )
-GLNAME( gl_x86_transform_points2_general_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_gm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_gm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p2_gm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-	FLD_S( SRC(0) )			/* F7 F6 F5 F4 */
-	FMUL_S( MAT(3) )
-
-	FLD_S( SRC(1) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-	FLD_S( SRC(1) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(7) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FXCH( ST(3) )			/* F4 F6 F5 F7 */
-	FADD_S( MAT(12) )
-	FXCH( ST(2) )			/* F5 F6 F4 F7 */
-	FADD_S( MAT(13) )
-	FXCH( ST(1) )			/* F6 F5 F4 F7 */
-	FADD_S( MAT(14) )
-	FXCH( ST(3) )			/* F7 F5 F4 F6 */
-	FADD_S( MAT(15) )
-
-	FXCH( ST(2) )			/* F4 F5 F7 F6 */
-	FSTP_S( DST(0) )		/* F5 F7 F6 */
-	FSTP_S( DST(1) )		/* F7 F6 */
-	FXCH( ST(1) )			/* F6 F7 */
-	FSTP_S( DST(2) )		/* F7 */
-	FSTP_S( DST(3) )		/* */
-
-LLBL( x86_p2_gm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_gm_loop ) )
-
-LLBL( x86_p2_gm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_perspective_masked )
-GLNAME( gl_x86_transform_points2_perspective_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_pm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need eax; put stride in ARG_SOURCE */
-	MOV_L( EAX, ARG_SOURCE )
-
-	MOV_L( MAT(14), EAX )
-
-ALIGNTEXT16
-LLBL( x86_p2_pm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p2_pm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FSTP_S( DST(0)   )		/* F1 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EAX, DST(2) )
-	MOV_L( CONST(FP_ZERO), DST(3) )
-
-LLBL( x86_p2_pm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_pm_loop ) )
-
-LLBL( x86_p2_pm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_3d_masked )
-GLNAME( gl_x86_transform_points2_3d_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_3dm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_3dm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p2_3dm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-
-	FLD_S( SRC(1) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 F6 */
-	FADD_S( MAT(13) )
-	FXCH( ST(2) )			/* F6 F4 F5 */
-	FADD_S( MAT(14) )
-
-	FXCH( ST(1) )			/* F4 F6 F5 */
-	FSTP_S( DST(0) )		/* F6 F5 */
-	FXCH( ST(1) )			/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-
-LLBL( x86_p2_3dm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_3dm_loop ) )
-
-LLBL( x86_p2_3dm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_3d_no_rot_masked )
-GLNAME( gl_x86_transform_points2_3d_no_rot_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_3dnrm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need eax; put stride in ARG_SOURCE */
-	MOV_L( EAX, ARG_SOURCE )
-
-	MOV_L( MAT(14), EAX )
-
-ALIGNTEXT16
-LLBL( x86_p2_3dnrm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p2_3dnrm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 */
-	FXCH( ST(2) )			/* F1 F4 F5 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 */
-
-	FSTP_S( DST(0)   )		/* F5 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EAX, DST(2) )
-
-LLBL( x86_p2_3dnrm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_3dnrm_loop ) )
-
-LLBL( x86_p2_3dnrm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_2d_masked )
-GLNAME( gl_x86_transform_points2_2d_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_2dm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_2dm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p2_2dm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-
-	FLD_S( SRC(1) )			/* F0 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 */
-	FADD_S( MAT(13) )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0) )		/* F5 */
-	FSTP_S( DST(1) )		/* */
-
-LLBL( x86_p2_2dm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_2dm_loop ) )
-
-LLBL( x86_p2_2dm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_2d_no_rot_masked )
-GLNAME( gl_x86_transform_points2_2d_no_rot_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_2dnrm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_2dnrm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p2_2dnrm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 */
-	FXCH( ST(2) )			/* F1 F4 F5 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 */
-
-	FSTP_S( DST(0) )		/* F5 */
-	FSTP_S( DST(1) )		/* */
-
-LLBL( x86_p2_2dnrm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_2dnrm_loop ) )
-
-LLBL( x86_p2_2dnrm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_identity_masked )
-GLNAME( gl_x86_transform_points2_identity_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_im_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need eax; put stride in ARG_SOURCE */
-	MOV_L( EAX, ARG_SOURCE )
-
-	CMP_L( ESI, EDI )
-	JE( LLBL( x86_p2_im_done ) )
-
-ALIGNTEXT16
-LLBL( x86_p2_im_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p2_im_skip ) )
-
-	MOV_L( SRC(0), EAX )
-	MOV_L( SRC(1), EDX )
-
-	MOV_L( EAX, DST(0) )
-	MOV_L( EDX, DST(1) )
-
-LLBL( x86_p2_im_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_im_loop ) )
-
-LLBL( x86_p2_im_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
Index: xc/extras/Mesa/src/X86/x86_xform_masked3.S
diff -u xc/extras/Mesa/src/X86/x86_xform_masked3.S:1.2 xc/extras/Mesa/src/X86/x86_xform_masked3.S:removed
--- xc/extras/Mesa/src/X86/x86_xform_masked3.S:1.2	Mon Nov 13 18:31:19 2000
+++ xc/extras/Mesa/src/X86/x86_xform_masked3.S	Thu Feb 27 12:15:57 2003
@@ -1,670 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-	SEG_TEXT
-
-#define FRAME_OFFSET	16
-
-#define FP_ONE		1065353216
-#define FP_ZERO		0
-
-#define SRC(i)		REGOFF(i * 4, ESI)
-#define DST(i)		REGOFF(i * 4, EDI)
-#define MAT(i)		REGOFF(i * 4, EDX)
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_general_masked )
-GLNAME( gl_x86_transform_points3_general_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_gm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_gm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p3_gm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-	FLD_S( SRC(0) )			/* F7 F6 F5 F4 */
-	FMUL_S( MAT(3) )
-
-	FLD_S( SRC(1) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-	FLD_S( SRC(1) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(7) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-	FLD_S( SRC(2) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(11) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FXCH( ST(3) )			/* F4 F6 F5 F7 */
-	FADD_S( MAT(12) )
-	FXCH( ST(2) )			/* F5 F6 F4 F7 */
-	FADD_S( MAT(13) )
-	FXCH( ST(1) )			/* F6 F5 F4 F7 */
-	FADD_S( MAT(14) )
-	FXCH( ST(3) )			/* F7 F5 F4 F6 */
-	FADD_S( MAT(15) )
-
-	FXCH( ST(2) )			/* F4 F5 F7 F6 */
-	FSTP_S( DST(0) )		/* F5 F7 F6 */
-	FSTP_S( DST(1) )		/* F7 F6 */
-	FXCH( ST(1) )			/* F6 F7 */
-	FSTP_S( DST(2) )		/* F7 */
-	FSTP_S( DST(3) )		/* */
-
-LLBL( x86_p3_gm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_gm_loop ) )
-
-LLBL( x86_p3_gm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_perspective_masked )
-GLNAME( gl_x86_transform_points3_perspective_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_pm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need eax; put stride in ARG_SOURCE */
-	MOV_L( EAX, ARG_SOURCE )
-
-ALIGNTEXT16
-LLBL( x86_p3_pm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p3_pm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F0 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F5 F4 */
-	FADDP( ST(0), ST(4) )		/* F1 F2 F5 F4 */
-	FADDP( ST(0), ST(2) )		/* F2 F5 F4 */
-	FLD_S( MAT(14) )		/* F6 F2 F5 F4 */
-	FXCH( ST(1) )			/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(2), EAX )
-	XOR_L( CONST(-2147483648), EAX )/* change sign */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0)   )		/* F5 F6 */
-	FSTP_S( DST(1)   )		/* F6 */
-	FSTP_S( DST(2)   )		/* */
-	MOV_L( EAX, DST(3) )
-
-LLBL( x86_p3_pm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_pm_loop ) )
-
-LLBL( x86_p3_pm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_3d_masked )
-GLNAME( gl_x86_transform_points3_3d_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_3dm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_3dm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p3_3dm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-
-	FLD_S( SRC(1) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 F6 */
-	FADD_S( MAT(13) )
-	FXCH( ST(2) )			/* F6 F4 F5 */
-	FADD_S( MAT(14) )
-
-	FXCH( ST(1) )			/* F4 F6 F5 */
-	FSTP_S( DST(0) )		/* F6 F5 */
-	FXCH( ST(1) )			/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-
-LLBL( x86_p3_3dm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_3dm_loop ) )
-
-LLBL( x86_p3_3dm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_3d_no_rot_masked )
-GLNAME( gl_x86_transform_points3_3d_no_rot_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_3dnrm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_3dnrm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p3_3dnrm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F2 F1 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F4 F1 F2 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 F2 */
-	FXCH( ST(2) )			/* F1 F4 F5 F2 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 F2 */
-	FLD_S( MAT(14) )		/* F6 F4 F5 F2 */
-	FXCH( ST(3) )			/* F2 F4 F5 F6 */
-	FADDP( ST(0), ST(3) )		/* F4 F5 F6 */
-
-	FSTP_S( DST(0)   )		/* F5 F6 */
-	FSTP_S( DST(1)   )		/* F6 */
-	FSTP_S( DST(2)   )		/* */
-
-LLBL( x86_p3_3dnrm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_3dnrm_loop ) )
-
-LLBL( x86_p3_3dnrm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_2d_masked )
-GLNAME( gl_x86_transform_points3_2d_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_2dm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need eax; put stride in ARG_SOURCE */
-	MOV_L( EAX, ARG_SOURCE )
-
-ALIGNTEXT16
-LLBL( x86_p3_2dm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p3_2dm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-
-	FLD_S( SRC(1) )			/* F0 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 */
-	FADD_S( MAT(13) )
-
-	MOV_L( SRC(2), EAX )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0)   )		/* F5 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EAX, DST(2) )
-
-LLBL( x86_p3_2dm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_2dm_loop ) )
-
-LLBL( x86_p3_2dm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME( gl_x86_transform_points3_2d_no_rot_masked )
-GLNAME( gl_x86_transform_points3_2d_no_rot_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_2dnrm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need eax; put stride in ARG_SOURCE */
-	MOV_L( EAX, ARG_SOURCE )
-
-ALIGNTEXT16
-LLBL( x86_p3_2dnrm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p3_2dnrm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 */
-
-	FXCH( ST(2) )			/* F1 F4 F5 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 */
-
-	MOV_L( SRC(2), EAX )
-
-	FSTP_S( DST(0)   )		/* F5 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EAX, DST(2) )
-
-LLBL( x86_p3_2dnrm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_2dnrm_loop ) )
-
-LLBL( x86_p3_2dnrm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_identity_masked )
-GLNAME( gl_x86_transform_points3_identity_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_im_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need ecx; put dest+count in ARG_DEST */
-	MOV_L( EAX, ARG_SOURCE )
-	MOV_L( ECX, ARG_DEST )
-
-	CMP_L( ESI, EDI )
-	JE( LLBL( x86_p3_im_done ) )
-
-ALIGNTEXT16
-LLBL( x86_p3_im_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p3_im_skip ) )
-
-	MOV_L( SRC(0), EAX )
-	MOV_L( SRC(1), ECX )
-	MOV_L( SRC(2), EDX )
-
-	MOV_L( EAX, DST(0) )
-	MOV_L( ECX, DST(1) )
-	MOV_L( EDX, DST(2) )
-
-LLBL( x86_p3_im_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ARG_DEST, EDI )
-	JNE( LLBL( x86_p3_im_loop ) )
-
-LLBL( x86_p3_im_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
Index: xc/extras/Mesa/src/X86/x86_xform_masked4.S
diff -u xc/extras/Mesa/src/X86/x86_xform_masked4.S:1.2 xc/extras/Mesa/src/X86/x86_xform_masked4.S:removed
--- xc/extras/Mesa/src/X86/x86_xform_masked4.S:1.2	Mon Nov 13 18:31:19 2000
+++ xc/extras/Mesa/src/X86/x86_xform_masked4.S	Thu Feb 27 12:15:57 2003
@@ -1,710 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-	SEG_TEXT
-
-#define FRAME_OFFSET	16
-
-#define FP_ONE		1065353216
-#define FP_ZERO		0
-
-#define SRC(i)		REGOFF(i * 4, ESI)
-#define DST(i)		REGOFF(i * 4, EDI)
-#define MAT(i)		REGOFF(i * 4, EDX)
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_general_masked )
-GLNAME( gl_x86_transform_points4_general_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_gm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p4_gm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p4_gm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-	FLD_S( SRC(0) )			/* F7 F6 F5 F4 */
-	FMUL_S( MAT(3) )
-
-	FLD_S( SRC(1) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-	FLD_S( SRC(1) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(7) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-	FLD_S( SRC(2) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(11) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FLD_S( SRC(3) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(13) )
-	FLD_S( SRC(3) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-	FLD_S( SRC(3) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(15) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FXCH( ST(3) )			/* F4 F6 F5 F7 */
-	FSTP_S( DST(0) )		/* F6 F5 F7 */
-	FXCH( ST(1) )			/* F5 F6 F7 */
-	FSTP_S( DST(1) )		/* F6 F7 */
-	FSTP_S( DST(2) )		/* F7 */
-	FSTP_S( DST(3) )		/* */
-
-LLBL( x86_p4_gm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_gm_loop ) )
-
-LLBL( x86_p4_gm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_perspective_masked )
-GLNAME( gl_x86_transform_points4_perspective_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_pm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	MOV_L( EAX, ARG_SOURCE )	/* need eax; put stride in ARG_SOURCE */
-
-ALIGNTEXT16
-LLBL( x86_p4_pm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p4_pm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F0 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F6 F1 F0 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F6 F5 F4 */
-	FADDP( ST(0), ST(4) )		/* F1 F6 F5 F4 */
-	FADDP( ST(0), ST(2) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(3) )			/* F2 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(2), EAX )
-	XOR_L( CONST(-2147483648), EAX )/* change sign */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0) )		/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-	MOV_L( EAX, DST(3) )
-
-LLBL( x86_p4_pm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_pm_loop ) )
-
-LLBL( x86_p4_pm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_3d_masked )
-GLNAME( gl_x86_transform_points4_3d_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_3dm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	MOV_L( EAX, ARG_SOURCE )	/* need eax; put stride in ARG_SOURCE */
-
-ALIGNTEXT16
-LLBL( x86_p4_3dm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p4_3dm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-
-	FLD_S( SRC(1) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(3) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(13) )
-	FLD_S( SRC(3) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(3), EAX )
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0) )		/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-	MOV_L( EAX, DST(3) )
-
-LLBL( x86_p4_3dm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_3dm_loop ) )
-
-LLBL( x86_p4_3dm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_3d_no_rot_masked )
-GLNAME( gl_x86_transform_points4_3d_no_rot_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_3dnrm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	MOV_L( EAX, ARG_SOURCE )	/* need eax; put stride in ARG_SOURCE */
-
-ALIGNTEXT16
-LLBL( x86_p4_3dnrm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p4_3dnrm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F6 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FLD_S( SRC(3) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(13) )
-	FLD_S( SRC(3) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(3), EAX )
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0) )		/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-	MOV_L( EAX, DST(3) )
-
-LLBL( x86_p4_3dnrm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_3dnrm_loop ) )
-
-LLBL( x86_p4_3dnrm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_2d_masked )
-GLNAME( gl_x86_transform_points4_2d_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_2dm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	MOV_L( EAX, ARG_SOURCE )	/* need eax; put stride in ARG_SOURCE   */
-	MOV_L( ECX, ARG_DEST )		/* need ecx; put dest+count in ARG_DEST */
-
-ALIGNTEXT16
-LLBL( x86_p4_2dm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p4_2dm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-
-	FLD_S( SRC(1) )			/* F0 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	FLD_S( SRC(3) )			/* F0 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(13) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	MOV_L( SRC(2), EAX )
-	MOV_L( SRC(3), ECX )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0) )		/* F5 */
-	FSTP_S( DST(1) )		/* */
-	MOV_L( EAX, DST(2) )
-	MOV_L( ECX, DST(3) )
-
-LLBL( x86_p4_2dm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ARG_DEST, EDI )
-	JNE( LLBL( x86_p4_2dm_loop ) )
-
-LLBL( x86_p4_2dm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_2d_no_rot_masked )
-GLNAME( gl_x86_transform_points4_2d_no_rot_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_2dnrm_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	MOV_L( EAX, ARG_SOURCE )	/* need eax; put stride in ARG_SOURCE   */
-	MOV_L( ECX, ARG_DEST )		/* need ecx; put dest+count in ARG_DEST */
-
-ALIGNTEXT16
-LLBL( x86_p4_2dnrm_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p4_2dnrm_skip ) )
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(3) )			/* F0 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(13) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	MOV_L( SRC(2), EAX )
-	MOV_L( SRC(3), ECX )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0)   )		/* F5 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EAX, DST(2) )
-	MOV_L( ECX, DST(3) )
-
-LLBL( x86_p4_2dnrm_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ARG_DEST, EDI )
-	JNE( LLBL( x86_p4_2dnrm_loop ) )
-
-LLBL( x86_p4_2dnrm_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_identity_masked )
-GLNAME( gl_x86_transform_points4_identity_masked ):
-
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( ARG_CLIP, EBP )
-
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-	MOV_B( ARG_FLAG, BL )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_im_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	/* need eax; put stride in ARG_SOURCE */
-	MOV_L( EAX, ARG_SOURCE )
-
-	CMP_L( ESI, EDI )
-	JE( LLBL( x86_p4_im_done ) )
-
-ALIGNTEXT16
-LLBL( x86_p4_im_loop ):
-
-	TEST_B( BL, REGIND(EBP) )
-	JNZ( LLBL( x86_p4_im_skip ) )
-
-	MOV_L( SRC(0), EAX )
-	MOV_L( SRC(1), EDX )
-
-	MOV_L( EAX, DST(0) )
-	MOV_L( EDX, DST(1) )
-
-	MOV_L( SRC(2), EAX )
-	MOV_L( SRC(3), EDX )
-
-	MOV_L( EAX, DST(2) )
-	MOV_L( EDX, DST(3) )
-
-LLBL( x86_p4_im_skip ):
-
-	INC_L( EBP )
-	ADD_L( CONST(16), EDI )
-	ADD_L( ARG_SOURCE, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_im_loop ) )
-
-LLBL( x86_p4_im_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
Index: xc/extras/Mesa/src/X86/x86_xform_raw2.S
diff -u xc/extras/Mesa/src/X86/x86_xform_raw2.S:1.2 xc/extras/Mesa/src/X86/x86_xform_raw2.S:removed
--- xc/extras/Mesa/src/X86/x86_xform_raw2.S:1.2	Mon Nov 13 18:31:19 2000
+++ xc/extras/Mesa/src/X86/x86_xform_raw2.S	Thu Feb 27 12:15:57 2003
@@ -1,535 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-	SEG_TEXT
-
-#define FP_ONE		1065353216
-#define FP_ZERO		0
-
-#define SRC(i)		REGOFF(i * 4, ESI)
-#define DST(i)		REGOFF(i * 4, EDI)
-#define MAT(i)		REGOFF(i * 4, EDX)
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_general_raw )
-GLNAME( gl_x86_transform_points2_general_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_gr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_gr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-	FLD_S( SRC(0) )			/* F7 F6 F5 F4 */
-	FMUL_S( MAT(3) )
-
-	FLD_S( SRC(1) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-	FLD_S( SRC(1) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(7) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FXCH( ST(3) )			/* F4 F6 F5 F7 */
-	FADD_S( MAT(12) )
-	FXCH( ST(2) )			/* F5 F6 F4 F7 */
-	FADD_S( MAT(13) )
-	FXCH( ST(1) )			/* F6 F5 F4 F7 */
-	FADD_S( MAT(14) )
-	FXCH( ST(3) )			/* F7 F5 F4 F6 */
-	FADD_S( MAT(15) )
-
-	FXCH( ST(2) )			/* F4 F5 F7 F6 */
-	FSTP_S( DST(0) )		/* F5 F7 F6 */
-	FSTP_S( DST(1) )		/* F7 F6 */
-	FXCH( ST(1) )			/* F6 F7 */
-	FSTP_S( DST(2) )		/* F7 */
-	FSTP_S( DST(3) )		/* */
-
-LLBL( x86_p2_gr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_gr_loop ) )
-
-LLBL( x86_p2_gr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_perspective_raw )
-GLNAME( gl_x86_transform_points2_perspective_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_pr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	MOV_L( MAT(14), EBX )
-
-ALIGNTEXT16
-LLBL( x86_p2_pr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FSTP_S( DST(0)   )		/* F1 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EBX, DST(2) )
-	MOV_L( CONST(FP_ZERO), DST(3) )
-
-LLBL( x86_p2_pr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_pr_loop ) )
-
-LLBL( x86_p2_pr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_3d_raw )
-GLNAME( gl_x86_transform_points2_3d_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_3dr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_3dr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-
-	FLD_S( SRC(1) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 F6 */
-	FADD_S( MAT(13) )
-	FXCH( ST(2) )			/* F6 F4 F5 */
-	FADD_S( MAT(14) )
-
-	FXCH( ST(1) )			/* F4 F6 F5 */
-	FSTP_S( DST(0) )		/* F6 F5 */
-	FXCH( ST(1) )			/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-
-LLBL( x86_p2_3dr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_3dr_loop ) )
-
-LLBL( x86_p2_3dr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_3d_no_rot_raw )
-GLNAME( gl_x86_transform_points2_3d_no_rot_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_3dnrr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	MOV_L( MAT(14), EBX )
-
-ALIGNTEXT16
-LLBL( x86_p2_3dnrr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 */
-	FXCH( ST(2) )			/* F1 F4 F5 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 */
-
-	FSTP_S( DST(0) )		/* F5 */
-	FSTP_S( DST(1) )		/* */
-	MOV_L( EBX, DST(2) )
-
-LLBL( x86_p2_3dnrr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_3dnrr_loop ) )
-
-LLBL( x86_p2_3dnrr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_2d_raw )
-GLNAME( gl_x86_transform_points2_2d_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_2dr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_2dr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-
-	FLD_S( SRC(1) )			/* F0 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 */
-	FADD_S( MAT(13) )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0) )		/* F5 */
-	FSTP_S( DST(1) )		/* */
-
-LLBL( x86_p2_2dr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_2dr_loop ) )
-
-LLBL( x86_p2_2dr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT4
-GLOBL GLNAME( gl_x86_transform_points2_2d_no_rot_raw )
-GLNAME( gl_x86_transform_points2_2d_no_rot_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_2dnrr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p2_2dnrr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 */
-	FXCH( ST(2) )			/* F1 F4 F5 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 */
-
-	FSTP_S( DST(0)   )		/* F5 */
-	FSTP_S( DST(1)   )		/* */
-
-LLBL( x86_p2_2dnrr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_2dnrr_loop ) )
-
-LLBL( x86_p2_2dnrr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points2_identity_raw )
-GLNAME( gl_x86_transform_points2_identity_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p2_ir_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_2), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(2), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	CMP_L( ESI, EDI )
-	JE( LLBL( x86_p2_ir_done ) )
-
-ALIGNTEXT16
-LLBL( x86_p2_ir_loop ):
-
-	MOV_L( SRC(0), EBX )
-	MOV_L( SRC(1), EDX )
-
-	MOV_L( EBX, DST(0) )
-	MOV_L( EDX, DST(1) )
-
-LLBL( x86_p2_ir_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p2_ir_loop ) )
-
-LLBL( x86_p2_ir_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
Index: xc/extras/Mesa/src/X86/x86_xform_raw3.S
diff -u xc/extras/Mesa/src/X86/x86_xform_raw3.S:1.2 xc/extras/Mesa/src/X86/x86_xform_raw3.S:removed
--- xc/extras/Mesa/src/X86/x86_xform_raw3.S:1.2	Mon Nov 13 18:31:19 2000
+++ xc/extras/Mesa/src/X86/x86_xform_raw3.S	Thu Feb 27 12:15:57 2003
@@ -1,605 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-	SEG_TEXT
-
-#define FP_ONE		1065353216
-#define FP_ZERO		0
-
-#define SRC(i)		REGOFF(i * 4, ESI)
-#define DST(i)		REGOFF(i * 4, EDI)
-#define MAT(i)		REGOFF(i * 4, EDX)
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_general_raw )
-GLNAME( gl_x86_transform_points3_general_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_gr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_gr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-	FLD_S( SRC(0) )			/* F7 F6 F5 F4 */
-	FMUL_S( MAT(3) )
-
-	FLD_S( SRC(1) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-	FLD_S( SRC(1) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(7) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-	FLD_S( SRC(2) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(11) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FXCH( ST(3) )			/* F4 F6 F5 F7 */
-	FADD_S( MAT(12) )
-	FXCH( ST(2) )			/* F5 F6 F4 F7 */
-	FADD_S( MAT(13) )
-	FXCH( ST(1) )			/* F6 F5 F4 F7 */
-	FADD_S( MAT(14) )
-	FXCH( ST(3) )			/* F7 F5 F4 F6 */
-	FADD_S( MAT(15) )
-
-	FXCH( ST(2) )			/* F4 F5 F7 F6 */
-	FSTP_S( DST(0) )		/* F5 F7 F6 */
-	FSTP_S( DST(1) )		/* F7 F6 */
-	FXCH( ST(1) )			/* F6 F7 */
-	FSTP_S( DST(2) )		/* F7 */
-	FSTP_S( DST(3) )		/* */
-
-LLBL( x86_p3_gr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_gr_loop ) )
-
-LLBL( x86_p3_gr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_perspective_raw )
-GLNAME( gl_x86_transform_points3_perspective_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_pr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_pr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F0 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F5 F4 */
-	FADDP( ST(0), ST(4) )		/* F1 F2 F5 F4 */
-	FADDP( ST(0), ST(2) )		/* F2 F5 F4 */
-	FLD_S( MAT(14) )		/* F6 F2 F5 F4 */
-	FXCH( ST(1) )			/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(2), EBX )
-	XOR_L( CONST(-2147483648), EBX )/* change sign */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0) )		/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-	MOV_L( EBX, DST(3) )
-
-LLBL( x86_p3_pr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_pr_loop ) )
-
-LLBL( x86_p3_pr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_3d_raw )
-GLNAME( gl_x86_transform_points3_3d_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_3dr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_3dr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-
-	FLD_S( SRC(1) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 F6 */
-	FADD_S( MAT(13) )
-	FXCH( ST(2) )			/* F6 F4 F5 */
-	FADD_S( MAT(14) )
-
-	FXCH( ST(1) )			/* F4 F6 F5 */
-	FSTP_S( DST(0)   )		/* F6 F5 */
-	FXCH( ST(1) )			/* F5 F6 */
-	FSTP_S( DST(1)   )		/* F6 */
-	FSTP_S( DST(2)   )		/* */
-
-LLBL( x86_p3_3dr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_3dr_loop ) )
-
-LLBL( x86_p3_3dr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_3d_no_rot_raw )
-GLNAME( gl_x86_transform_points3_3d_no_rot_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_3dnrr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_3dnrr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F2 F1 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F4 F1 F2 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 F2 */
-	FXCH( ST(2) )			/* F1 F4 F5 F2 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 F2 */
-	FLD_S( MAT(14) )		/* F6 F4 F5 F2 */
-	FXCH( ST(3) )			/* F2 F4 F5 F6 */
-	FADDP( ST(0), ST(3) )		/* F4 F5 F6 */
-
-	FSTP_S( DST(0)   )		/* F5 F6 */
-	FSTP_S( DST(1)   )		/* F6 */
-	FSTP_S( DST(2)   )		/* */
-
-LLBL( x86_p3_3dnrr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_3dnrr_loop ) )
-
-LLBL( x86_p3_3dnrr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_2d_raw )
-GLNAME( gl_x86_transform_points3_2d_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_2dr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_2dr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-
-	FLD_S( SRC(1) )			/* F0 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FADD_S( MAT(12) )
-	FXCH( ST(1) )			/* F5 F4 */
-	FADD_S( MAT(13) )
-
-	MOV_L( SRC(2), EBX )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0)   )		/* F5 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EBX, DST(2) )
-
-LLBL( x86_p3_2dr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_2dr_loop ) )
-
-LLBL( x86_p3_2dr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_2d_no_rot_raw )
-GLNAME( gl_x86_transform_points3_2d_no_rot_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_2dnrr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p3_2dnrr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F1 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F4 F1 */
-	FADD_S( MAT(12) )
-	FLD_S( MAT(13) )		/* F5 F4 F1 */
-
-	FXCH( ST(2) )			/* F1 F4 F5 */
-	FADDP( ST(0), ST(2) )		/* F4 F5 */
-
-	MOV_L( SRC(2), EBX )
-
-	FSTP_S( DST(0) )		/* F5 */
-	FSTP_S( DST(1) )		/* */
-	MOV_L( EBX, DST(2) )
-
-LLBL( x86_p3_2dnrr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_2dnrr_loop ) )
-
-LLBL( x86_p3_2dnrr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points3_identity_raw )
-GLNAME(gl_x86_transform_points3_identity_raw ):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p3_ir_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_3), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(3), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	CMP_L( ESI, EDI )
-	JE( LLBL( x86_p3_ir_done ) )
-
-ALIGNTEXT16
-LLBL( x86_p3_ir_loop ):
-
-#if 1
-	MOV_L( SRC(0), EBX )
-	MOV_L( SRC(1), EBP )
-	MOV_L( SRC(2), EDX )
-
-	MOV_L( EBX, DST(0) )
-	MOV_L( EBP, DST(1) )
-	MOV_L( EDX, DST(2) )
-#else
-	FLD_S( SRC(0) )
-	FLD_S( SRC(1) )
-	FLD_S( SRC(2) )
-
-	FSTP_S( DST(2) )
-	FSTP_S( DST(1) )
-	FSTP_S( DST(0) )
-#endif
-
-LLBL( x86_p3_ir_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p3_ir_loop ) )
-
-LLBL( x86_p3_ir_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
Index: xc/extras/Mesa/src/X86/x86_xform_raw4.S
diff -u xc/extras/Mesa/src/X86/x86_xform_raw4.S:1.2 xc/extras/Mesa/src/X86/x86_xform_raw4.S:removed
--- xc/extras/Mesa/src/X86/x86_xform_raw4.S:1.2	Mon Nov 13 18:31:19 2000
+++ xc/extras/Mesa/src/X86/x86_xform_raw4.S	Thu Feb 27 12:15:57 2003
@@ -1,638 +0,0 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  3.4
- *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
- */
-
-#include "assyntax.h"
-#include "xform_args.h"
-
-	SEG_TEXT
-
-#define FP_ONE		1065353216
-#define FP_ZERO		0
-
-#define SRC(i)		REGOFF(i * 4, ESI)
-#define DST(i)		REGOFF(i * 4, EDI)
-#define MAT(i)		REGOFF(i * 4, EDX)
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_general_raw )
-GLNAME( gl_x86_transform_points4_general_raw ):
-
-#define FRAME_OFFSET 8
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_gr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p4_gr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-	FLD_S( SRC(0) )			/* F7 F6 F5 F4 */
-	FMUL_S( MAT(3) )
-
-	FLD_S( SRC(1) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-	FLD_S( SRC(1) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(7) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-	FLD_S( SRC(2) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(11) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FLD_S( SRC(3) )			/* F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(13) )
-	FLD_S( SRC(3) )			/* F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-	FLD_S( SRC(3) )			/* F3 F2 F1 F0 F7 F6 F5 F4 */
-	FMUL_S( MAT(15) )
-
-	FXCH( ST(3) )			/* F0 F2 F1 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(7) )		/* F2 F1 F3 F7 F6 F5 F4 */
-	FXCH( ST(1) )			/* F1 F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F2 F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F3 F7 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F7 F6 F5 F4 */
-
-	FXCH( ST(3) )			/* F4 F6 F5 F7 */
-	FSTP_S( DST(0) )		/* F6 F5 F7 */
-	FXCH( ST(1) )			/* F5 F6 F7 */
-	FSTP_S( DST(1) )		/* F6 F7 */
-	FSTP_S( DST(2) )		/* F7 */
-	FSTP_S( DST(3) )		/* */
-
-LLBL( x86_p4_gr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_gr_loop ) )
-
-LLBL( x86_p4_gr_done ):
-
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_perspective_raw )
-GLNAME( gl_x86_transform_points4_perspective_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_pr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p4_pr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F0 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F6 F1 F0 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F6 F5 F4 */
-	FADDP( ST(0), ST(4) )		/* F1 F6 F5 F4 */
-	FADDP( ST(0), ST(2) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(3) )			/* F2 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(2), EBX )
-	XOR_L( CONST(-2147483648), EBX )/* change sign */
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0) )		/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-	MOV_L( EBX, DST(3) )
-
-LLBL( x86_p4_pr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_pr_loop ) )
-
-LLBL( x86_p4_pr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_3d_raw )
-GLNAME( gl_x86_transform_points4_3d_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_3dr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p4_3dr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-	FLD_S( SRC(0) )			/* F6 F5 F4 */
-	FMUL_S( MAT(2) )
-
-	FLD_S( SRC(1) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(5) )
-	FLD_S( SRC(1) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(6) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(2) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(8) )
-	FLD_S( SRC(2) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(9) )
-	FLD_S( SRC(2) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	FLD_S( SRC(3) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(13) )
-	FLD_S( SRC(3) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(3), EBX )
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0) )		/* F5 F6 */
-	FSTP_S( DST(1) )		/* F6 */
-	FSTP_S( DST(2) )		/* */
-	MOV_L( EBX, DST(3) )
-
-LLBL( x86_p4_3dr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_3dr_loop ) )
-
-LLBL( x86_p4_3dr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME(gl_x86_transform_points4_3d_no_rot_raw)
-GLNAME(gl_x86_transform_points4_3d_no_rot_raw):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_3dnrr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p4_3dnrr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(2) )			/* F6 F5 F4 */
-	FMUL_S( MAT(10) )
-
-	FLD_S( SRC(3) )			/* F0 F6 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(13) )
-	FLD_S( SRC(3) )			/* F2 F1 F0 F6 F5 F4 */
-	FMUL_S( MAT(14) )
-
-	FXCH( ST(2) )			/* F0 F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(5) )		/* F1 F2 F6 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F2 F6 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F6 F5 F4 */
-
-	MOV_L( SRC(3), EBX )
-
-	FXCH( ST(2) )			/* F4 F5 F6 */
-	FSTP_S( DST(0)   )		/* F5 F6 */
-	FSTP_S( DST(1)   )		/* F6 */
-	FSTP_S( DST(2)   )		/* */
-	MOV_L( EBX, DST(3) )
-
-LLBL( x86_p4_3dnrr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_3dnrr_loop ) )
-
-LLBL( x86_p4_3dnrr_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_2d_raw )
-GLNAME( gl_x86_transform_points4_2d_raw ):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_2dr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p4_2dr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-	FLD_S( SRC(0) )			/* F5 F4 */
-	FMUL_S( MAT(1) )
-
-	FLD_S( SRC(1) )			/* F0 F5 F4 */
-	FMUL_S( MAT(4) )
-	FLD_S( SRC(1) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	FLD_S( SRC(3) )			/* F0 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(13) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	MOV_L( SRC(2), EBX )
-	MOV_L( SRC(3), EBP )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0) )		/* F5 */
-	FSTP_S( DST(1) )		/* */
-	MOV_L( EBX, DST(2) )
-	MOV_L( EBP, DST(3) )
-
-LLBL( x86_p4_2dr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_2dr_loop ) )
-
-LLBL( x86_p4_2dr_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_2d_no_rot_raw )
-GLNAME( gl_x86_transform_points4_2d_no_rot_raw ):
-
-#define FRAME_OFFSET 16
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-	PUSH_L( EBP )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_2dnrr_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-ALIGNTEXT16
-LLBL( x86_p4_2dnrr_loop ):
-
-	FLD_S( SRC(0) )			/* F4 */
-	FMUL_S( MAT(0) )
-
-	FLD_S( SRC(1) )			/* F5 F4 */
-	FMUL_S( MAT(5) )
-
-	FLD_S( SRC(3) )			/* F0 F5 F4 */
-	FMUL_S( MAT(12) )
-	FLD_S( SRC(3) )			/* F1 F0 F5 F4 */
-	FMUL_S( MAT(13) )
-
-	FXCH( ST(1) )			/* F0 F1 F5 F4 */
-	FADDP( ST(0), ST(3) )		/* F1 F5 F4 */
-	FADDP( ST(0), ST(1) )		/* F5 F4 */
-
-	MOV_L( SRC(2), EBX )
-	MOV_L( SRC(3), EBP )
-
-	FXCH( ST(1) )			/* F4 F5 */
-	FSTP_S( DST(0)   )		/* F5 */
-	FSTP_S( DST(1)   )		/* */
-	MOV_L( EBX, DST(2) )
-	MOV_L( EBP, DST(3) )
-
-LLBL( x86_p4_2dnrr_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_2dnrr_loop ) )
-
-LLBL( x86_p4_2dnrr_done ):
-
-	POP_L( EBP )
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
-#undef FRAME_OFFSET
-
-
-
-
-ALIGNTEXT16
-GLOBL GLNAME( gl_x86_transform_points4_identity_raw )
-GLNAME( gl_x86_transform_points4_identity_raw ):
-
-#define FRAME_OFFSET 12
-	PUSH_L( ESI )
-	PUSH_L( EDI )
-	PUSH_L( EBX )
-
-	MOV_L( ARG_SOURCE, ESI )
-	MOV_L( ARG_DEST, EDI )
-
-	MOV_L( ARG_MATRIX, EDX )
-	MOV_L( REGOFF(V4F_COUNT, ESI), ECX )
-
-	TEST_L( ECX, ECX )
-	JZ( LLBL( x86_p4_ir_done ) )
-
-	MOV_L( REGOFF(V4F_STRIDE, ESI), EAX )
-	OR_L( CONST(VEC_SIZE_4), REGOFF(V4F_FLAGS, EDI) )
-
-	MOV_L( ECX, REGOFF(V4F_COUNT, EDI) )
-	MOV_L( CONST(4), REGOFF(V4F_SIZE, EDI) )
-
-	SHL_L( CONST(4), ECX )
-	MOV_L( REGOFF(V4F_START, ESI), ESI )
-
-	MOV_L( REGOFF(V4F_START, EDI), EDI )
-	ADD_L( EDI, ECX )
-
-	CMP_L( ESI, EDI )
-	JE( LLBL( x86_p4_ir_done ) )
-
-ALIGNTEXT16
-LLBL( x86_p4_ir_loop ):
-
-	MOV_L( SRC(0), EBX )
-	MOV_L( SRC(1), EDX )
-
-	MOV_L( EBX, DST(0) )
-	MOV_L( EDX, DST(1) )
-
-	MOV_L( SRC(2), EBX )
-	MOV_L( SRC(3), EDX )
-
-	MOV_L( EBX, DST(2) )
-	MOV_L( EDX, DST(3) )
-
-LLBL( x86_p4_ir_skip ):
-
-	ADD_L( CONST(16), EDI )
-	ADD_L( EAX, ESI )
-	CMP_L( ECX, EDI )
-	JNE( LLBL( x86_p4_ir_loop ) )
-
-LLBL( x86_p4_ir_done ):
-
-	POP_L( EBX )
-	POP_L( EDI )
-	POP_L( ESI )
-	RET
Index: xc/extras/Mesa/src/X86/xform_args.h
diff -u xc/extras/Mesa/src/X86/xform_args.h:1.2 xc/extras/Mesa/src/X86/xform_args.h:1.3
--- xc/extras/Mesa/src/X86/xform_args.h:1.2	Mon Nov 13 18:31:20 2000
+++ xc/extras/Mesa/src/X86/xform_args.h	Fri Feb 22 14:31:41 2002
@@ -1,9 +1,9 @@
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.4
+ * Version:  3.5
  *
- * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -34,40 +34,18 @@
 #ifndef __XFORM_ARGS_H__
 #define __XFORM_ARGS_H__
 
-/* Offsets into GLvector4f
- */
-#define V4F_DATA	0
-#define V4F_START	4
-#define V4F_COUNT	8
-#define V4F_STRIDE	12
-#define V4F_SIZE	16
-#define V4F_FLAGS	20
-
-/* GLvector4f flags
- */
-#define VEC_SIZE_1	1
-#define VEC_SIZE_2	3
-#define VEC_SIZE_3	7
-#define VEC_SIZE_4	15
-
 /* Offsets for transform_func arguments
  *
  * typedef void (*transform_func)( GLvector4f *to_vec,
  *				   const GLfloat m[16],
- *				   const GLvector4f *from_vec,
- *				   const GLubyte *clipmask,
- *				   const GLubyte flag );
+ *				   const GLvector4f *from_vec );
  */
 #define OFFSET_DEST	4
 #define OFFSET_MATRIX	8
 #define OFFSET_SOURCE	12
-#define OFFSET_CLIP	16
-#define OFFSET_FLAG	20
 
 #define ARG_DEST	REGOFF(FRAME_OFFSET+OFFSET_DEST, ESP)
 #define ARG_MATRIX 	REGOFF(FRAME_OFFSET+OFFSET_MATRIX, ESP)
 #define ARG_SOURCE 	REGOFF(FRAME_OFFSET+OFFSET_SOURCE, ESP)
-#define ARG_CLIP 	REGOFF(FRAME_OFFSET+OFFSET_CLIP, ESP)
-#define ARG_FLAG 	REGOFF(FRAME_OFFSET+OFFSET_FLAG, ESP)
 
 #endif
Index: xc/extras/Mesa/src/array_cache/ac_context.c
diff -u /dev/null xc/extras/Mesa/src/array_cache/ac_context.c:1.2
--- /dev/null	Thu Feb 27 12:15:57 2003
+++ xc/extras/Mesa/src/array_cache/ac_context.c	Mon Dec 16 11:18:35 2002
@@ -0,0 +1,275 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+#include "array_cache/ac_context.h"
+
+static void _ac_fallbacks_init( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *cl;
+   GLuint i;
+
+   cl = &ac->Fallback.Normal;
+   cl->Size = 3;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) ctx->Current.Normal;
+   cl->Enabled = 1;
+   cl->Flags = CA_CLIENT_DATA;	/* hack */
+
+   cl = &ac->Fallback.Color;
+   cl->Size = 4;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) ctx->Current.Color;
+   cl->Enabled = 1;
+   cl->Flags = CA_CLIENT_DATA;	/* hack */
+
+   cl = &ac->Fallback.SecondaryColor;
+   cl->Size = 3;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) ctx->Current.SecondaryColor;
+   cl->Enabled = 1;
+   cl->Flags = CA_CLIENT_DATA;	/* hack */
+
+   cl = &ac->Fallback.FogCoord;
+   cl->Size = 1;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) &ctx->Current.FogCoord;
+   cl->Enabled = 1;
+   cl->Flags = CA_CLIENT_DATA;	/* hack */
+
+   cl = &ac->Fallback.Index;
+   cl->Size = 1;
+   cl->Type = GL_UNSIGNED_INT;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) &ctx->Current.Index;
+   cl->Enabled = 1;
+   cl->Flags = CA_CLIENT_DATA;	/* hack */
+
+   for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
+      cl = &ac->Fallback.TexCoord[i];
+      cl->Size = 4;
+      cl->Type = GL_FLOAT;
+      cl->Stride = 0;
+      cl->StrideB = 0;
+      cl->Ptr = (void *) ctx->Current.Texcoord[i];
+      cl->Enabled = 1;
+      cl->Flags = CA_CLIENT_DATA;	/* hack */
+   }
+
+   cl = &ac->Fallback.EdgeFlag;
+   cl->Size = 1;
+   cl->Type = GL_UNSIGNED_BYTE;
+   cl->Stride = 0;
+   cl->StrideB = 0;
+   cl->Ptr = (void *) &ctx->Current.EdgeFlag;
+   cl->Enabled = 1;
+   cl->Flags = CA_CLIENT_DATA;	/* hack */
+}
+
+
+static void _ac_cache_init( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *cl;
+   GLuint size = ctx->Const.MaxArrayLockSize + MAX_CLIPPED_VERTICES;
+   GLuint i;
+
+   cl = &ac->Cache.Vertex;
+   cl->Size = 4;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 4 * sizeof(GLfloat);
+   cl->Ptr = MALLOC( cl->StrideB * size );
+   cl->Enabled = 1;
+   cl->Flags = 0;
+
+   cl = &ac->Cache.Normal;
+   cl->Size = 3;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 3 * sizeof(GLfloat);
+   cl->Ptr = MALLOC( cl->StrideB * size );
+   cl->Enabled = 1;
+   cl->Flags = 0;
+
+   cl = &ac->Cache.Color;
+   cl->Size = 4;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 4 * sizeof(GLfloat);
+   cl->Ptr = MALLOC( cl->StrideB * size );
+   cl->Enabled = 1;
+   cl->Flags = 0;
+
+   cl = &ac->Cache.SecondaryColor;
+   cl->Size = 3;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = 4 * sizeof(GLfloat);
+   cl->Ptr = MALLOC( cl->StrideB * size );
+   cl->Enabled = 1;
+   cl->Flags = 0;
+
+   cl = &ac->Cache.FogCoord;
+   cl->Size = 1;
+   cl->Type = GL_FLOAT;
+   cl->Stride = 0;
+   cl->StrideB = sizeof(GLfloat);
+   cl->Ptr = MALLOC( cl->StrideB * size );
+   cl->Enabled = 1;
+   cl->Flags = 0;
+
+   cl = &ac->Cache.Index;
+   cl->Size = 1;
+   cl->Type = GL_UNSIGNED_INT;
+   cl->Stride = 0;
+   cl->StrideB = sizeof(GLuint);
+   cl->Ptr = MALLOC( cl->StrideB * size );
+   cl->Enabled = 1;
+   cl->Flags = 0;
+
+   for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
+      cl = &ac->Cache.TexCoord[i];
+      cl->Size = 4;
+      cl->Type = GL_FLOAT;
+      cl->Stride = 0;
+      cl->StrideB = 4 * sizeof(GLfloat);
+      cl->Ptr = MALLOC( cl->StrideB * size );
+      cl->Enabled = 1;
+      cl->Flags = 0;
+   }
+
+   cl = &ac->Cache.EdgeFlag;
+   cl->Size = 1;
+   cl->Type = GL_UNSIGNED_BYTE;
+   cl->Stride = 0;
+   cl->StrideB = sizeof(GLubyte);
+   cl->Ptr = MALLOC( cl->StrideB * size );
+   cl->Enabled = 1;
+   cl->Flags = 0;
+}
+
+
+/* This storage used to hold translated client data if type or stride
+ * need to be fixed.
+ */
+static void _ac_elts_init( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   GLuint size = 1000;
+
+   ac->Elts = (GLuint *)MALLOC( sizeof(GLuint) * size );
+   ac->elt_size = size;
+}
+
+static void _ac_raw_init( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   GLuint i;
+
+   ac->Raw.Color = ac->Fallback.Color;
+   ac->Raw.EdgeFlag = ac->Fallback.EdgeFlag;
+   ac->Raw.FogCoord = ac->Fallback.FogCoord;
+   ac->Raw.Index = ac->Fallback.Index;
+   ac->Raw.Normal = ac->Fallback.Normal;
+   ac->Raw.SecondaryColor = ac->Fallback.SecondaryColor;
+   ac->Raw.Vertex = ctx->Array.Vertex;
+
+   ac->IsCached.Color = GL_FALSE;
+   ac->IsCached.EdgeFlag = GL_FALSE;
+   ac->IsCached.FogCoord = GL_FALSE;
+   ac->IsCached.Index = GL_FALSE;
+   ac->IsCached.Normal = GL_FALSE;
+   ac->IsCached.SecondaryColor = GL_FALSE;
+   ac->IsCached.Vertex = GL_FALSE;
+
+   for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
+      ac->Raw.TexCoord[i] = ac->Fallback.TexCoord[i];
+      ac->IsCached.TexCoord[i] = GL_FALSE;
+   }
+
+}
+
+GLboolean _ac_CreateContext( GLcontext *ctx )
+{
+   ctx->acache_context = CALLOC(sizeof(ACcontext));
+   if (ctx->acache_context) {
+      _ac_cache_init( ctx );
+      _ac_fallbacks_init( ctx );
+      _ac_raw_init( ctx );
+      _ac_elts_init( ctx );
+      return GL_TRUE;
+   }
+   return GL_FALSE;
+}
+
+void _ac_DestroyContext( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   GLint i;
+
+   if (ac->Cache.Vertex.Ptr) FREE( ac->Cache.Vertex.Ptr );
+   if (ac->Cache.Normal.Ptr) FREE( ac->Cache.Normal.Ptr );
+   if (ac->Cache.Color.Ptr) FREE( ac->Cache.Color.Ptr );
+   if (ac->Cache.SecondaryColor.Ptr) FREE( ac->Cache.SecondaryColor.Ptr );
+   if (ac->Cache.EdgeFlag.Ptr) FREE( ac->Cache.EdgeFlag.Ptr );
+   if (ac->Cache.Index.Ptr) FREE( ac->Cache.Index.Ptr );
+   if (ac->Cache.FogCoord.Ptr) FREE( ac->Cache.FogCoord.Ptr );
+
+   for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
+      if (ac->Cache.TexCoord[i].Ptr)
+	 FREE( ac->Cache.TexCoord[i].Ptr );
+   }
+
+   if (ac->Elts) FREE( ac->Elts );
+
+   /* Free the context structure itself */
+   FREE(ac);
+   ctx->acache_context = NULL;
+}
+
+void _ac_InvalidateState( GLcontext *ctx, GLuint new_state )
+{
+   AC_CONTEXT(ctx)->NewState |= new_state;
+   AC_CONTEXT(ctx)->NewArrayState |= ctx->Array.NewState;
+}
Index: xc/extras/Mesa/src/array_cache/ac_context.h
diff -u /dev/null xc/extras/Mesa/src/array_cache/ac_context.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/array_cache/ac_context.h	Mon Dec 16 11:18:35 2002
@@ -0,0 +1,96 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef _AC_CONTEXT_H
+#define _AC_CONTEXT_H
+
+#include "glheader.h"
+#include "mtypes.h"
+
+#include "array_cache/acache.h"
+
+/* These are used to make the ctx->Current values look like
+ * arrays (with zero StrideB).
+ */
+struct ac_arrays {
+   struct gl_client_array Vertex;
+   struct gl_client_array Normal;
+   struct gl_client_array Color;
+   struct gl_client_array SecondaryColor;
+   struct gl_client_array FogCoord;
+   struct gl_client_array Index;
+   struct gl_client_array TexCoord[MAX_TEXTURE_UNITS];
+   struct gl_client_array EdgeFlag;
+};
+
+struct ac_array_pointers {
+   struct gl_client_array *Vertex;
+   struct gl_client_array *Normal;
+   struct gl_client_array *Color;
+   struct gl_client_array *SecondaryColor;
+   struct gl_client_array *FogCoord;
+   struct gl_client_array *Index;
+   struct gl_client_array *TexCoord[MAX_TEXTURE_UNITS];
+   struct gl_client_array *EdgeFlag;
+};
+
+struct ac_array_flags {
+   GLboolean Vertex;
+   GLboolean Normal;
+   GLboolean Color;
+   GLboolean SecondaryColor;
+   GLboolean FogCoord;
+   GLboolean Index;
+   GLboolean TexCoord[MAX_TEXTURE_UNITS];
+   GLboolean EdgeFlag;
+};
+
+
+typedef struct {
+   GLuint NewState;		/* not needed? */
+   GLuint NewArrayState;
+
+   /* Facility for importing and caching array data:
+    */
+   struct ac_arrays Fallback;
+   struct ac_arrays Cache;
+   struct ac_arrays Raw;
+   struct ac_array_flags IsCached;
+   GLuint start;
+   GLuint count;
+
+   /* Facility for importing element lists:
+    */
+   GLuint *Elts;
+   GLuint elt_size;
+
+} ACcontext;
+
+#define AC_CONTEXT(ctx) ((ACcontext *)ctx->acache_context)
+
+#endif
Index: xc/extras/Mesa/src/array_cache/ac_import.c
diff -u /dev/null xc/extras/Mesa/src/array_cache/ac_import.c:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/array_cache/ac_import.c	Mon Dec 16 11:18:35 2002
@@ -0,0 +1,783 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+#include "math/m_translate.h"
+#include "array_cache/ac_context.h"
+#include "math/m_translate.h"
+
+#define STRIDE_ARRAY( array, offset ) 		\
+do {						\
+   char *tmp = (char *) (array).Ptr;		\
+   tmp += (offset) * (array).StrideB;		\
+   (array).Ptr = tmp;				\
+} while (0)
+
+/* Set the array pointer back to its source when the cached data is
+ * invalidated:
+ */
+
+static void reset_texcoord( GLcontext *ctx, GLuint unit )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (ctx->Array._Enabled & _NEW_ARRAY_TEXCOORD(unit)) {
+      ac->Raw.TexCoord[unit] = ctx->Array.TexCoord[unit];
+      STRIDE_ARRAY(ac->Raw.TexCoord[unit], ac->start);
+   }
+   else {
+      ac->Raw.TexCoord[unit] = ac->Fallback.TexCoord[unit];
+
+      if (ctx->Current.Texcoord[unit][3] != 1.0)
+	 ac->Raw.TexCoord[unit].Size = 4;
+      else if (ctx->Current.Texcoord[unit][2] != 0.0)
+	 ac->Raw.TexCoord[unit].Size = 3;
+      else
+	 ac->Raw.TexCoord[unit].Size = 2;
+   }
+
+   ac->IsCached.TexCoord[unit] = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_TEXCOORD(unit);
+}
+
+static void reset_vertex( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   ASSERT(ctx->Array.Vertex.Enabled);
+   ac->Raw.Vertex = ctx->Array.Vertex;
+   STRIDE_ARRAY(ac->Raw.Vertex, ac->start);
+   ac->IsCached.Vertex = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_VERTEX;
+}
+
+
+static void reset_normal( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (ctx->Array._Enabled & _NEW_ARRAY_NORMAL) {
+      ac->Raw.Normal = ctx->Array.Normal;
+      STRIDE_ARRAY(ac->Raw.Normal, ac->start);
+   }
+   else {
+      ac->Raw.Normal = ac->Fallback.Normal;
+   }
+
+   ac->IsCached.Normal = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_NORMAL;
+}
+
+
+static void reset_color( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+
+   if (ctx->Array._Enabled & _NEW_ARRAY_COLOR) {
+      ac->Raw.Color = ctx->Array.Color;
+      STRIDE_ARRAY(ac->Raw.Color, ac->start);
+   }
+   else
+      ac->Raw.Color = ac->Fallback.Color;
+
+   ac->IsCached.Color = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_COLOR;
+}
+
+
+static void reset_secondarycolor( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (ctx->Array._Enabled & _NEW_ARRAY_SECONDARYCOLOR) {
+      ac->Raw.SecondaryColor = ctx->Array.SecondaryColor;
+      STRIDE_ARRAY(ac->Raw.SecondaryColor, ac->start);
+   }
+   else
+      ac->Raw.SecondaryColor = ac->Fallback.SecondaryColor;
+
+   ac->IsCached.SecondaryColor = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_SECONDARYCOLOR;
+}
+
+
+static void reset_index( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (ctx->Array._Enabled & _NEW_ARRAY_INDEX) {
+      ac->Raw.Index = ctx->Array.Index;
+      STRIDE_ARRAY(ac->Raw.Index, ac->start);
+   }
+   else
+      ac->Raw.Index = ac->Fallback.Index;
+
+   ac->IsCached.Index = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_INDEX;
+}
+
+static void reset_fogcoord( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (ctx->Array._Enabled & _NEW_ARRAY_FOGCOORD) {
+      ac->Raw.FogCoord = ctx->Array.FogCoord;
+      STRIDE_ARRAY(ac->Raw.FogCoord, ac->start);
+   }
+   else
+      ac->Raw.FogCoord = ac->Fallback.FogCoord;
+
+   ac->IsCached.FogCoord = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_FOGCOORD;
+}
+
+static void reset_edgeflag( GLcontext *ctx )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (ctx->Array._Enabled & _NEW_ARRAY_EDGEFLAG) {
+      ac->Raw.EdgeFlag = ctx->Array.EdgeFlag;
+      STRIDE_ARRAY(ac->Raw.EdgeFlag, ac->start);
+   }
+   else
+      ac->Raw.EdgeFlag = ac->Fallback.EdgeFlag;
+
+   ac->IsCached.EdgeFlag = GL_FALSE;
+   ac->NewArrayState &= ~_NEW_ARRAY_EDGEFLAG;
+}
+
+
+
+static void import( GLcontext *ctx,
+		    GLenum type,
+		    struct gl_client_array *to,
+		    struct gl_client_array *from )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (type == 0) 
+      type = from->Type;
+
+   switch (type) {
+   case GL_FLOAT:
+      _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
+		      from->Ptr,
+		      from->StrideB,
+		      from->Type,
+		      from->Size,
+		      0,
+		      ac->count - ac->start);
+
+      to->StrideB = 4 * sizeof(GLfloat);
+      to->Type = GL_FLOAT;
+      break;
+      
+   case GL_UNSIGNED_BYTE:
+      _math_trans_4ub( (GLubyte (*)[4]) to->Ptr,
+		       from->Ptr,
+		       from->StrideB,
+		       from->Type,
+		       from->Size,
+		       0,
+		       ac->count - ac->start);
+
+      to->StrideB = 4 * sizeof(GLubyte);
+      to->Type = GL_UNSIGNED_BYTE;
+      break;
+
+   case GL_UNSIGNED_SHORT:
+      _math_trans_4us( (GLushort (*)[4]) to->Ptr,
+		       from->Ptr,
+		       from->StrideB,
+		       from->Type,
+		       from->Size,
+		       0,
+		       ac->count - ac->start);
+
+      to->StrideB = 4 * sizeof(GLushort);
+      to->Type = GL_UNSIGNED_SHORT;
+      break;
+      
+   default:
+      ASSERT(0);
+      break;
+   }
+}
+
+
+
+/* Functions to import array ranges with specified types and strides.
+ */
+static void import_texcoord( GLcontext *ctx, GLuint unit,
+			     GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.TexCoord[unit];
+   struct gl_client_array *to = &ac->Cache.TexCoord[unit];
+
+   /* Limited choices at this stage:
+    */
+   ASSERT(type == GL_FLOAT);
+   ASSERT(stride == 4*sizeof(GLfloat) || stride == 0);
+   ASSERT(ac->count - ac->start < ctx->Const.MaxArrayLockSize);
+
+   _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
+		   from->Ptr,
+		   from->StrideB,
+		   from->Type,
+		   from->Size,
+		   0,
+		   ac->count - ac->start);
+
+   to->Size = from->Size;
+   to->StrideB = 4 * sizeof(GLfloat);
+   to->Type = GL_FLOAT;
+   ac->IsCached.TexCoord[unit] = GL_TRUE;
+}
+
+static void import_vertex( GLcontext *ctx,
+			   GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.Vertex;
+   struct gl_client_array *to = &ac->Cache.Vertex;
+
+   /* Limited choices at this stage:
+    */
+   ASSERT(type == GL_FLOAT);
+   ASSERT(stride == 4*sizeof(GLfloat) || stride == 0);
+
+   _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
+		   from->Ptr,
+		   from->StrideB,
+		   from->Type,
+		   from->Size,
+		   0,
+		   ac->count - ac->start);
+
+   to->Size = from->Size;
+   to->StrideB = 4 * sizeof(GLfloat);
+   to->Type = GL_FLOAT;
+   ac->IsCached.Vertex = GL_TRUE;
+}
+
+static void import_normal( GLcontext *ctx,
+			   GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.Normal;
+   struct gl_client_array *to = &ac->Cache.Normal;
+
+   /* Limited choices at this stage:
+    */
+   ASSERT(type == GL_FLOAT);
+   ASSERT(stride == 3*sizeof(GLfloat) || stride == 0);
+
+   _math_trans_3f( (GLfloat (*)[3]) to->Ptr,
+		   from->Ptr,
+		   from->StrideB,
+		   from->Type,
+		   0,
+		   ac->count - ac->start);
+
+   to->StrideB = 3 * sizeof(GLfloat);
+   to->Type = GL_FLOAT;
+   ac->IsCached.Normal = GL_TRUE;
+}
+
+		    
+
+
+static void import_color( GLcontext *ctx,
+			  GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.Color;
+   struct gl_client_array *to = &ac->Cache.Color;
+
+   import( ctx, type, to, from );
+   
+   ac->IsCached.Color = GL_TRUE;
+}
+
+static void import_index( GLcontext *ctx,
+			  GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.Index;
+   struct gl_client_array *to = &ac->Cache.Index;
+
+   /* Limited choices at this stage:
+    */
+   ASSERT(type == GL_UNSIGNED_INT);
+   ASSERT(stride == sizeof(GLuint) || stride == 0);
+
+   _math_trans_1ui( (GLuint *) to->Ptr,
+		    from->Ptr,
+		    from->StrideB,
+		    from->Type,
+		    0,
+		    ac->count - ac->start);
+
+   to->StrideB = sizeof(GLuint);
+   to->Type = GL_UNSIGNED_INT;
+   ac->IsCached.Index = GL_TRUE;
+}
+
+static void import_secondarycolor( GLcontext *ctx,
+				   GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.SecondaryColor;
+   struct gl_client_array *to = &ac->Cache.SecondaryColor;
+
+   import( ctx, type, to, from );
+
+   ac->IsCached.SecondaryColor = GL_TRUE;
+}
+
+static void import_fogcoord( GLcontext *ctx,
+			     GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.FogCoord;
+   struct gl_client_array *to = &ac->Cache.FogCoord;
+
+   /* Limited choices at this stage:
+    */
+   ASSERT(type == GL_FLOAT);
+   ASSERT(stride == sizeof(GLfloat) || stride == 0);
+
+   _math_trans_1f( (GLfloat *) to->Ptr,
+		   from->Ptr,
+		   from->StrideB,
+		   from->Type,
+		   0,
+		   ac->count - ac->start);
+
+   to->StrideB = sizeof(GLfloat);
+   to->Type = GL_FLOAT;
+   ac->IsCached.FogCoord = GL_TRUE;
+}
+
+static void import_edgeflag( GLcontext *ctx,
+			     GLenum type, GLuint stride )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+   struct gl_client_array *from = &ac->Raw.EdgeFlag;
+   struct gl_client_array *to = &ac->Cache.EdgeFlag;
+
+   /* Limited choices at this stage:
+    */
+   ASSERT(type == GL_UNSIGNED_BYTE);
+   ASSERT(stride == sizeof(GLubyte) || stride == 0);
+
+   _math_trans_1ub( (GLubyte *) to->Ptr,
+		    from->Ptr,
+		    from->StrideB,
+		    from->Type,
+		    0,
+		    ac->count - ac->start);
+
+   to->StrideB = sizeof(GLubyte);
+   to->Type = GL_UNSIGNED_BYTE;
+   ac->IsCached.EdgeFlag = GL_TRUE;
+}
+
+
+
+/* Externals to request arrays with specific properties:
+ */
+struct gl_client_array *_ac_import_texcoord( GLcontext *ctx,
+					     GLuint unit,
+					     GLenum type,
+					     GLuint reqstride,
+					     GLuint reqsize,
+					     GLboolean reqwriteable,
+					     GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_TEXCOORD(unit))
+      reset_texcoord( ctx, unit );
+
+   /* Is the request impossible?
+    */
+   if (reqsize != 0 && ac->Raw.TexCoord[unit].Size > (GLint) reqsize)
+      return 0;
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if (ac->Raw.TexCoord[unit].Type != type ||
+       (reqstride != 0 && ac->Raw.TexCoord[unit].StrideB != (GLint)reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.TexCoord[unit])
+	 import_texcoord(ctx, unit, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.TexCoord[unit];
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.TexCoord[unit];
+   }
+}
+
+struct gl_client_array *_ac_import_vertex( GLcontext *ctx,
+					   GLenum type,
+					   GLuint reqstride,
+					   GLuint reqsize,
+					   GLboolean reqwriteable,
+					   GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_VERTEX)
+      reset_vertex( ctx );
+
+   /* Is the request impossible?
+    */
+   if (reqsize != 0 && ac->Raw.Vertex.Size > (GLint) reqsize)
+      return 0;
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if (ac->Raw.Vertex.Type != type ||
+       (reqstride != 0 && ac->Raw.Vertex.StrideB != (GLint) reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.Vertex)
+	 import_vertex(ctx, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.Vertex;
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.Vertex;
+   }
+}
+
+struct gl_client_array *_ac_import_normal( GLcontext *ctx,
+					   GLenum type,
+					   GLuint reqstride,
+					   GLboolean reqwriteable,
+					   GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_NORMAL)
+      reset_normal( ctx );
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if (ac->Raw.Normal.Type != type ||
+       (reqstride != 0 && ac->Raw.Normal.StrideB != (GLint) reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.Normal)
+	 import_normal(ctx, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.Normal;
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.Normal;
+   }
+}
+
+struct gl_client_array *_ac_import_color( GLcontext *ctx,
+					  GLenum type,
+					  GLuint reqstride,
+					  GLuint reqsize,
+					  GLboolean reqwriteable,
+					  GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_COLOR)
+      reset_color( ctx );
+
+   /* Is the request impossible?
+    */
+   if (reqsize != 0 && ac->Raw.Color.Size > (GLint) reqsize) {
+      return 0;
+   }
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if ((type != 0 && ac->Raw.Color.Type != type) ||
+       (reqstride != 0 && ac->Raw.Color.StrideB != (GLint) reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.Color)
+	 import_color(ctx, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.Color;
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.Color;
+   }
+}
+
+struct gl_client_array *_ac_import_index( GLcontext *ctx,
+					  GLenum type,
+					  GLuint reqstride,
+					  GLboolean reqwriteable,
+					  GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_INDEX)
+      reset_index( ctx );
+
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if (ac->Raw.Index.Type != type ||
+       (reqstride != 0 && ac->Raw.Index.StrideB != (GLint) reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.Index)
+	 import_index(ctx, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.Index;
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.Index;
+   }
+}
+
+struct gl_client_array *_ac_import_secondarycolor( GLcontext *ctx,
+						   GLenum type,
+						   GLuint reqstride,
+						   GLuint reqsize,
+						   GLboolean reqwriteable,
+						   GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_SECONDARYCOLOR)
+      reset_secondarycolor( ctx );
+
+   /* Is the request impossible?
+    */
+   if (reqsize != 0 && ac->Raw.SecondaryColor.Size > (GLint) reqsize)
+      return 0;
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if ((type != 0 && ac->Raw.SecondaryColor.Type != type) ||
+       (reqstride != 0 && ac->Raw.SecondaryColor.StrideB != (GLint)reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.SecondaryColor)
+	 import_secondarycolor(ctx, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.SecondaryColor;
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.SecondaryColor;
+   }
+}
+
+struct gl_client_array *_ac_import_fogcoord( GLcontext *ctx,
+					     GLenum type,
+					     GLuint reqstride,
+					     GLboolean reqwriteable,
+					     GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_FOGCOORD)
+      reset_fogcoord( ctx );
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if (ac->Raw.FogCoord.Type != type ||
+       (reqstride != 0 && ac->Raw.FogCoord.StrideB != (GLint) reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.FogCoord)
+	 import_fogcoord(ctx, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.FogCoord;
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.FogCoord;
+   }
+}
+
+
+
+
+struct gl_client_array *_ac_import_edgeflag( GLcontext *ctx,
+					     GLenum type,
+					     GLuint reqstride,
+					     GLboolean reqwriteable,
+					     GLboolean *writeable )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   /* Can we keep the existing version?
+    */
+   if (ac->NewArrayState & _NEW_ARRAY_EDGEFLAG)
+      reset_edgeflag( ctx );
+
+   /* Do we need to pull in a copy of the client data:
+    */
+   if (ac->Raw.EdgeFlag.Type != type ||
+       (reqstride != 0 && ac->Raw.EdgeFlag.StrideB != (GLint) reqstride) ||
+       reqwriteable)
+   {
+      if (!ac->IsCached.EdgeFlag)
+	 import_edgeflag(ctx, type, reqstride );
+      *writeable = GL_TRUE;
+      return &ac->Cache.EdgeFlag;
+   }
+   else {
+      *writeable = GL_FALSE;
+      return &ac->Raw.EdgeFlag;
+   }
+}
+
+
+
+
+
+/* Clients must call this function to validate state and set bounds
+ * before importing any data:
+ */
+void _ac_import_range( GLcontext *ctx, GLuint start, GLuint count )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (!ctx->Array.LockCount) {
+      /* Not locked, discard cached data.  Changes to lock
+       * status are caught via. _ac_invalidate_state().
+       */
+      ac->NewArrayState = _NEW_ARRAY_ALL;
+      ac->start = start;
+      ac->count = count;
+   }
+   else {
+      /* Locked, discard data for any disabled arrays.  Require that
+       * the whole locked range always be dealt with, otherwise hard to
+       * maintain cached data in the face of clipping.
+       */
+      ac->NewArrayState |= ~ctx->Array._Enabled;
+      ac->start = ctx->Array.LockFirst;
+      ac->count = ctx->Array.LockCount;
+      ASSERT(ac->start == start); /* hmm? */
+      ASSERT(ac->count == count);
+   }
+}
+
+
+
+/* Additional convienence function for importing a the element list
+ * for drawelements, drawrangeelements:
+ */
+CONST void *
+_ac_import_elements( GLcontext *ctx,
+		     GLenum new_type,
+		     GLuint count,
+		     GLenum old_type,
+		     CONST void *indices )
+{
+   ACcontext *ac = AC_CONTEXT(ctx);
+
+   if (old_type == new_type)
+      return indices;
+
+   if (ac->elt_size < count * sizeof(GLuint)) {
+      if (ac->Elts) FREE(ac->Elts);
+      while (ac->elt_size < count * sizeof(GLuint))
+	 ac->elt_size *= 2;
+      ac->Elts = (GLuint *) MALLOC(ac->elt_size);
+   }
+
+   switch (new_type) {
+   case GL_UNSIGNED_BYTE:
+      ASSERT(0);
+      return 0;
+   case GL_UNSIGNED_SHORT:
+      ASSERT(0);
+      return 0;
+   case GL_UNSIGNED_INT: {
+      GLuint *out = (GLuint *)ac->Elts;
+      GLuint i;
+
+      switch (old_type) {
+      case GL_UNSIGNED_BYTE: {
+	 CONST GLubyte *in = (CONST GLubyte *)indices;
+	 for (i = 0 ; i < count ; i++)
+	    out[i] = in[i];
+	 break;
+      }
+      case GL_UNSIGNED_SHORT: {
+	 CONST GLushort *in = (CONST GLushort *)indices;
+	 for (i = 0 ; i < count ; i++)
+	       out[i] = in[i];
+	 break;
+      }
+      default:
+	 ASSERT(0);
+      }
+
+      return (CONST void *)out;
+   }
+   default:
+      ASSERT(0);
+      break;
+   }
+
+   return 0;
+}
Index: xc/extras/Mesa/src/array_cache/acache.h
diff -u /dev/null xc/extras/Mesa/src/array_cache/acache.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/array_cache/acache.h	Mon Dec 16 11:18:35 2002
@@ -0,0 +1,123 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef _ARRAYCACHE_H
+#define _ARRAYCACHE_H
+
+#include "mtypes.h"
+
+
+extern GLboolean
+_ac_CreateContext( GLcontext *ctx );
+
+extern void
+_ac_DestroyContext( GLcontext *ctx );
+
+extern void
+_ac_InvalidateState( GLcontext *ctx, GLuint new_state );
+
+extern struct gl_client_array *
+_ac_import_texcoord( GLcontext *ctx,
+		     GLuint unit,
+		     GLenum type,
+		     GLuint reqstride,
+		     GLuint reqsize,
+		     GLboolean reqwritable,
+		     GLboolean *writable );
+
+extern struct gl_client_array *
+_ac_import_vertex( GLcontext *ctx,
+		   GLenum type,
+		   GLuint reqstride,
+		   GLuint reqsize,
+		   GLboolean reqwritable,
+		   GLboolean *writable );
+
+extern struct gl_client_array *
+_ac_import_normal( GLcontext *ctx,
+		   GLenum type,
+		   GLuint reqstride,
+		   GLboolean reqwritable,
+		   GLboolean *writable );
+
+extern struct gl_client_array *
+_ac_import_color( GLcontext *ctx,
+		  GLenum type,
+		  GLuint reqstride,
+		  GLuint reqsize,
+		  GLboolean reqwritable,
+		  GLboolean *writable );
+
+extern struct gl_client_array *
+_ac_import_index( GLcontext *ctx,
+		  GLenum type,
+		  GLuint reqstride,
+		  GLboolean reqwritable,
+		  GLboolean *writable );
+
+extern struct gl_client_array *
+_ac_import_secondarycolor( GLcontext *ctx,
+			   GLenum type,
+			   GLuint reqstride,
+			   GLuint reqsize,
+			   GLboolean reqwritable,
+			   GLboolean *writable );
+
+extern struct gl_client_array *
+_ac_import_fogcoord( GLcontext *ctx,
+		     GLenum type,
+		     GLuint reqstride,
+		     GLboolean reqwritable,
+		     GLboolean *writable );
+
+extern struct gl_client_array *
+_ac_import_edgeflag( GLcontext *ctx,
+		     GLenum type,
+		     GLuint reqstride,
+		     GLboolean reqwritable,
+		     GLboolean *writable );
+
+
+/* Clients must call this function to validate state and set bounds
+ * before importing any data:
+ */
+extern void
+_ac_import_range( GLcontext *ctx, GLuint start, GLuint count );
+
+
+/* Additional convenience function:
+ */
+extern CONST void *
+_ac_import_elements( GLcontext *ctx,
+		     GLenum new_type,
+		     GLuint count,
+		     GLenum old_type,
+		     CONST void *indices );
+
+
+#endif
Index: xc/extras/Mesa/src/math/m_clip_tmp.h
diff -u /dev/null xc/extras/Mesa/src/math/m_clip_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_clip_tmp.h	Mon Dec 16 11:18:35 2002
@@ -0,0 +1,228 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+/* KW: a clever asm implementation would nestle integer versions
+ * of the outcode calculation underneath the division.  Gcc won't
+ * do this, strangely enough, so I only do the divide in
+ * the case where the cliptest passes.  This isn't essential,
+ * and an asm implementation needn't replicate that behaviour.
+ */
+static GLvector4f * _XFORMAPI TAG(cliptest_points4)( GLvector4f *clip_vec,
+                                                     GLvector4f *proj_vec,
+                                                     GLubyte clipMask[],
+                                                     GLubyte *orMask,
+                                                     GLubyte *andMask )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+   const GLuint count = clip_vec->count;
+   GLuint c = 0;
+   GLfloat (*vProj)[4] = (GLfloat (*)[4])proj_vec->start;
+   GLubyte tmpAndMask = *andMask;
+   GLubyte tmpOrMask = *orMask;
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat cx = from[0];
+      const GLfloat cy = from[1];
+      const GLfloat cz = from[2];
+      const GLfloat cw = from[3];
+#if defined(macintosh) || defined(__powerpc__)
+      /* on powerpc cliptest is 17% faster in this way. */
+      GLuint mask;
+      mask = (((cw < cx) << CLIP_RIGHT_SHIFT));
+      mask |= (((cw < -cx) << CLIP_LEFT_SHIFT));
+      mask |= (((cw < cy) << CLIP_TOP_SHIFT));
+      mask |= (((cw < -cy) << CLIP_BOTTOM_SHIFT));
+      mask |= (((cw < cz) << CLIP_FAR_SHIFT));
+      mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+#else /* !defined(macintosh)) */
+      GLubyte mask = 0;
+      if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT;
+      if ( cx + cw < 0) mask |= CLIP_LEFT_BIT;
+      if (-cy + cw < 0) mask |= CLIP_TOP_BIT;
+      if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT;
+      if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
+      if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+#endif /* defined(macintosh) */
+
+      clipMask[i] = mask;
+      if (mask) {
+	 c++;
+	 tmpAndMask &= mask;
+	 tmpOrMask |= mask;
+	 vProj[i][0] = 0;
+	 vProj[i][1] = 0;
+	 vProj[i][2] = 0;
+	 vProj[i][3] = 1;
+      } else {
+	 GLfloat oow = 1.0F / cw;
+	 vProj[i][0] = cx * oow;
+	 vProj[i][1] = cy * oow;
+	 vProj[i][2] = cz * oow;
+	 vProj[i][3] = oow;
+      }
+   }
+
+   *orMask = tmpOrMask;
+   *andMask = (GLubyte) (c < count ? 0 : tmpAndMask);
+
+   proj_vec->flags |= VEC_SIZE_4;
+   proj_vec->size = 4;
+   proj_vec->count = clip_vec->count;
+   return proj_vec;
+}
+
+
+
+static GLvector4f * _XFORMAPI TAG(cliptest_np_points4)( GLvector4f *clip_vec,
+							GLvector4f *proj_vec,
+							GLubyte clipMask[],
+							GLubyte *orMask,
+							GLubyte *andMask )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLuint count = clip_vec->count;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+   GLuint c = 0;
+   GLubyte tmpAndMask = *andMask;
+   GLubyte tmpOrMask = *orMask;
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat cx = from[0];
+      const GLfloat cy = from[1];
+      const GLfloat cz = from[2];
+      const GLfloat cw = from[3];
+#if defined(macintosh) || defined(__powerpc__)
+      /* on powerpc cliptest is 17% faster in this way. */
+      GLuint mask;
+      mask = (((cw < cx) << CLIP_RIGHT_SHIFT));
+      mask |= (((cw < -cx) << CLIP_LEFT_SHIFT));
+      mask |= (((cw < cy) << CLIP_TOP_SHIFT));
+      mask |= (((cw < -cy) << CLIP_BOTTOM_SHIFT));
+      mask |= (((cw < cz) << CLIP_FAR_SHIFT));
+      mask |= (((cw < -cz) << CLIP_NEAR_SHIFT));
+#else /* !defined(macintosh)) */
+      GLubyte mask = 0;
+      if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT;
+      if ( cx + cw < 0) mask |= CLIP_LEFT_BIT;
+      if (-cy + cw < 0) mask |= CLIP_TOP_BIT;
+      if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT;
+      if (-cz + cw < 0) mask |= CLIP_FAR_BIT;
+      if ( cz + cw < 0) mask |= CLIP_NEAR_BIT;
+#endif /* defined(macintosh) */
+
+      clipMask[i] = mask;
+      if (mask) {
+	 c++;
+	 tmpAndMask &= mask;
+	 tmpOrMask |= mask;
+      }
+   }
+
+   *orMask = tmpOrMask;
+   *andMask = (GLubyte) (c < count ? 0 : tmpAndMask);
+   return clip_vec;
+}
+
+
+static GLvector4f * _XFORMAPI TAG(cliptest_points3)( GLvector4f *clip_vec,
+                                                     GLvector4f *proj_vec,
+                                                     GLubyte clipMask[],
+                                                     GLubyte *orMask,
+                                                     GLubyte *andMask )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLuint count = clip_vec->count;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+
+   GLubyte tmpOrMask = *orMask;
+   GLubyte tmpAndMask = *andMask;
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat cx = from[0], cy = from[1], cz = from[2];
+      GLubyte mask = 0;
+      if (cx >  1.0)       mask |= CLIP_RIGHT_BIT;
+      else if (cx < -1.0)  mask |= CLIP_LEFT_BIT;
+      if (cy >  1.0)       mask |= CLIP_TOP_BIT;
+      else if (cy < -1.0)  mask |= CLIP_BOTTOM_BIT;
+      if (cz >  1.0)       mask |= CLIP_FAR_BIT;
+      else if (cz < -1.0)  mask |= CLIP_NEAR_BIT;
+      clipMask[i] = mask;
+      tmpOrMask |= mask;
+      tmpAndMask &= mask;
+   }
+
+   *orMask = tmpOrMask;
+   *andMask = tmpAndMask;
+   return clip_vec;
+}
+
+
+static GLvector4f * _XFORMAPI TAG(cliptest_points2)( GLvector4f *clip_vec,
+                                                     GLvector4f *proj_vec,
+                                                     GLubyte clipMask[],
+                                                     GLubyte *orMask,
+                                                     GLubyte *andMask )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLuint count = clip_vec->count;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+
+   GLubyte tmpOrMask = *orMask;
+   GLubyte tmpAndMask = *andMask;
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat cx = from[0], cy = from[1];
+      GLubyte mask = 0;
+      if (cx >  1.0)       mask |= CLIP_RIGHT_BIT;
+      else if (cx < -1.0)  mask |= CLIP_LEFT_BIT;
+      if (cy >  1.0)       mask |= CLIP_TOP_BIT;
+      else if (cy < -1.0)  mask |= CLIP_BOTTOM_BIT;
+      clipMask[i] = mask;
+      tmpOrMask |= mask;
+      tmpAndMask &= mask;
+   }
+
+   *orMask = tmpOrMask;
+   *andMask = tmpAndMask;
+   return clip_vec;
+}
+
+
+static void TAG(init_c_cliptest)( void )
+{
+   _mesa_clip_tab[4] = TAG(cliptest_points4);
+   _mesa_clip_tab[3] = TAG(cliptest_points3);
+   _mesa_clip_tab[2] = TAG(cliptest_points2);
+
+   _mesa_clip_np_tab[4] = TAG(cliptest_np_points4);
+   _mesa_clip_np_tab[3] = TAG(cliptest_points3);
+   _mesa_clip_np_tab[2] = TAG(cliptest_points2);
+}
Index: xc/extras/Mesa/src/math/m_copy_tmp.h
diff -u /dev/null xc/extras/Mesa/src/math/m_copy_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_copy_tmp.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,86 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+#define COPY_FUNC( BITS )						\
+static void TAG2(copy, BITS)( GLvector4f *to, const GLvector4f *f )	\
+{									\
+   GLfloat (*t)[4] = (GLfloat (*)[4])to->start;				\
+   GLfloat *from = f->start;						\
+   GLuint stride = f->stride;				        	\
+   GLuint count = f->count;						\
+   GLuint i;								\
+									\
+   if (BITS)								\
+      STRIDE_LOOP {							\
+	 if (BITS&1) t[i][0] = from[0];					\
+	 if (BITS&2) t[i][1] = from[1];					\
+	 if (BITS&4) t[i][2] = from[2];					\
+	 if (BITS&8) t[i][3] = from[3];					\
+      }									\
+}
+
+/* We got them all here:
+ */
+COPY_FUNC( 0x0 )		/* noop */
+COPY_FUNC( 0x1 )
+COPY_FUNC( 0x2 )
+COPY_FUNC( 0x3 )
+COPY_FUNC( 0x4 )
+COPY_FUNC( 0x5 )
+COPY_FUNC( 0x6 )
+COPY_FUNC( 0x7 )
+COPY_FUNC( 0x8 )
+COPY_FUNC( 0x9 )
+COPY_FUNC( 0xa )
+COPY_FUNC( 0xb )
+COPY_FUNC( 0xc )
+COPY_FUNC( 0xd )
+COPY_FUNC( 0xe )
+COPY_FUNC( 0xf )
+
+static void TAG2(init_copy, 0)( void )
+{
+   _mesa_copy_tab[0x0] = TAG2(copy, 0x0);
+   _mesa_copy_tab[0x1] = TAG2(copy, 0x1);
+   _mesa_copy_tab[0x2] = TAG2(copy, 0x2);
+   _mesa_copy_tab[0x3] = TAG2(copy, 0x3);
+   _mesa_copy_tab[0x4] = TAG2(copy, 0x4);
+   _mesa_copy_tab[0x5] = TAG2(copy, 0x5);
+   _mesa_copy_tab[0x6] = TAG2(copy, 0x6);
+   _mesa_copy_tab[0x7] = TAG2(copy, 0x7);
+   _mesa_copy_tab[0x8] = TAG2(copy, 0x8);
+   _mesa_copy_tab[0x9] = TAG2(copy, 0x9);
+   _mesa_copy_tab[0xa] = TAG2(copy, 0xa);
+   _mesa_copy_tab[0xb] = TAG2(copy, 0xb);
+   _mesa_copy_tab[0xc] = TAG2(copy, 0xc);
+   _mesa_copy_tab[0xd] = TAG2(copy, 0xd);
+   _mesa_copy_tab[0xe] = TAG2(copy, 0xe);
+   _mesa_copy_tab[0xf] = TAG2(copy, 0xf);
+}
Index: xc/extras/Mesa/src/math/m_debug.h
diff -u /dev/null xc/extras/Mesa/src/math/m_debug.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_debug.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,42 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __M_DEBUG_H__
+#define __M_DEBUG_H__
+
+extern void _math_test_all_transform_functions( char *description );
+extern void _math_test_all_normal_transform_functions( char *description );
+extern void _math_test_all_cliptest_functions( char *description );
+
+/* Deprecated?
+ */
+extern void _math_test_all_vertex_functions( char *description );
+
+extern char *mesa_profile;
+
+#endif
Index: xc/extras/Mesa/src/math/m_debug_clip.c
diff -u /dev/null xc/extras/Mesa/src/math/m_debug_clip.c:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_debug_clip.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,364 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "m_matrix.h"
+#include "m_xform.h"
+
+#include "m_debug.h"
+#include "m_debug_util.h"
+
+#ifdef DEBUG  /* This code only used for debugging */
+
+static clip_func *clip_tab[2] = {
+   _mesa_clip_tab,
+   _mesa_clip_np_tab
+};
+static char *cnames[2] = {
+   "_mesa_clip_tab",
+   "_mesa_clip_np_tab"
+};
+static char *cstrings[2] = {
+   "clip, perspective divide",
+   "clip, no divide"
+};
+
+
+/* =============================================================
+ * Reference cliptests
+ */
+
+static GLvector4f *ref_cliptest_points4( GLvector4f *clip_vec,
+					 GLvector4f *proj_vec,
+					 GLubyte clipMask[],
+					 GLubyte *orMask,
+					 GLubyte *andMask )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLuint count = clip_vec->count;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+   GLuint c = 0;
+   GLfloat (*vProj)[4] = (GLfloat (*)[4])proj_vec->start;
+   GLubyte tmpAndMask = *andMask;
+   GLubyte tmpOrMask = *orMask;
+   GLuint i;
+   for ( i = 0 ; i < count ; i++, STRIDE_F(from, stride) ) {
+      const GLfloat cx = from[0];
+      const GLfloat cy = from[1];
+      const GLfloat cz = from[2];
+      const GLfloat cw = from[3];
+      GLubyte mask = 0;
+      if ( -cx + cw < 0 ) mask |= CLIP_RIGHT_BIT;
+      if (  cx + cw < 0 ) mask |= CLIP_LEFT_BIT;
+      if ( -cy + cw < 0 ) mask |= CLIP_TOP_BIT;
+      if (  cy + cw < 0 ) mask |= CLIP_BOTTOM_BIT;
+      if ( -cz + cw < 0 ) mask |= CLIP_FAR_BIT;
+      if (  cz + cw < 0 ) mask |= CLIP_NEAR_BIT;
+      clipMask[i] = mask;
+      if ( mask ) {
+	 c++;
+	 tmpAndMask &= mask;
+	 tmpOrMask |= mask;
+	 vProj[i][0] = 0;
+	 vProj[i][1] = 0;
+	 vProj[i][2] = 0;
+	 vProj[i][3] = 1;
+      } else {
+	 GLfloat oow = 1.0F / cw;
+	 vProj[i][0] = cx * oow;
+	 vProj[i][1] = cy * oow;
+	 vProj[i][2] = cz * oow;
+	 vProj[i][3] = oow;
+      }
+   }
+
+   *orMask = tmpOrMask;
+   *andMask = (GLubyte) (c < count ? 0 : tmpAndMask);
+
+   proj_vec->flags |= VEC_SIZE_4;
+   proj_vec->size = 4;
+   proj_vec->count = clip_vec->count;
+   return proj_vec;
+}
+
+/* Keep these here for now, even though we don't use them...
+ */
+static GLvector4f *ref_cliptest_points3( GLvector4f *clip_vec,
+					 GLvector4f *proj_vec,
+					 GLubyte clipMask[],
+					 GLubyte *orMask,
+					 GLubyte *andMask )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLuint count = clip_vec->count;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+
+   GLubyte tmpOrMask = *orMask;
+   GLubyte tmpAndMask = *andMask;
+   GLuint i;
+   for ( i = 0 ; i < count ; i++, STRIDE_F(from, stride) ) {
+      const GLfloat cx = from[0], cy = from[1], cz = from[2];
+      GLubyte mask = 0;
+      if ( cx >  1.0 )		mask |= CLIP_RIGHT_BIT;
+      else if ( cx < -1.0 )	mask |= CLIP_LEFT_BIT;
+      if ( cy >  1.0 )		mask |= CLIP_TOP_BIT;
+      else if ( cy < -1.0 )	mask |= CLIP_BOTTOM_BIT;
+      if ( cz >  1.0 )		mask |= CLIP_FAR_BIT;
+      else if ( cz < -1.0 )	mask |= CLIP_NEAR_BIT;
+      clipMask[i] = mask;
+      tmpOrMask |= mask;
+      tmpAndMask &= mask;
+   }
+
+   *orMask = tmpOrMask;
+   *andMask = tmpAndMask;
+   return clip_vec;
+}
+
+static GLvector4f * ref_cliptest_points2( GLvector4f *clip_vec,
+					  GLvector4f *proj_vec,
+					  GLubyte clipMask[],
+					  GLubyte *orMask,
+					  GLubyte *andMask )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLuint count = clip_vec->count;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+
+   GLubyte tmpOrMask = *orMask;
+   GLubyte tmpAndMask = *andMask;
+   GLuint i;
+   for ( i = 0 ; i < count ; i++, STRIDE_F(from, stride) ) {
+      const GLfloat cx = from[0], cy = from[1];
+      GLubyte mask = 0;
+      if ( cx >  1.0 )		mask |= CLIP_RIGHT_BIT;
+      else if ( cx < -1.0 )	mask |= CLIP_LEFT_BIT;
+      if ( cy >  1.0 )		mask |= CLIP_TOP_BIT;
+      else if ( cy < -1.0 )	mask |= CLIP_BOTTOM_BIT;
+      clipMask[i] = mask;
+      tmpOrMask |= mask;
+      tmpAndMask &= mask;
+   }
+
+   *orMask = tmpOrMask;
+   *andMask = tmpAndMask;
+   return clip_vec;
+}
+
+static clip_func ref_cliptest[5] = {
+   0,
+   0,
+   ref_cliptest_points2,
+   ref_cliptest_points3,
+   ref_cliptest_points4
+};
+
+
+/* =============================================================
+ * Cliptest tests
+ */
+
+static GLfloat s[TEST_COUNT][4] ALIGN16;
+static GLfloat d[TEST_COUNT][4] ALIGN16;
+static GLfloat r[TEST_COUNT][4] ALIGN16;
+
+static int test_cliptest_function( clip_func func, int np,
+				   int psize, long *cycles )
+{
+   GLvector4f source[1], dest[1], ref[1];
+   GLubyte dm[TEST_COUNT], dco, dca;
+   GLubyte rm[TEST_COUNT], rco, rca;
+   int i, j;
+#ifdef  RUN_DEBUG_BENCHMARK
+   int cycle_i;                /* the counter for the benchmarks we run */
+#endif
+
+   (void) cycles;
+
+   if ( psize > 4 ) {
+      _mesa_problem( NULL, "test_cliptest_function called with psize > 4\n" );
+      return 0;
+   }
+
+   for ( i = 0 ; i < TEST_COUNT ; i++) {
+      ASSIGN_4V( d[i], 0.0, 0.0, 0.0, 1.0 );
+      ASSIGN_4V( s[i], 0.0, 0.0, 0.0, 1.0 );
+      for ( j = 0 ; j < psize ; j++ )
+         s[i][j] = rnd();
+   }
+
+   source->data = (GLfloat(*)[4])s;
+   source->start = (GLfloat *)s;
+   source->count = TEST_COUNT;
+   source->stride = sizeof(s[0]);
+   source->size = 4;
+   source->flags = 0;
+
+   dest->data = (GLfloat(*)[4])d;
+   dest->start = (GLfloat *)d;
+   dest->count = TEST_COUNT;
+   dest->stride = sizeof(float[4]);
+   dest->size = 0;
+   dest->flags = 0;
+
+   ref->data = (GLfloat(*)[4])r;
+   ref->start = (GLfloat *)r;
+   ref->count = TEST_COUNT;
+   ref->stride = sizeof(float[4]);
+   ref->size = 0;
+   ref->flags = 0;
+
+   dco = rco = 0;
+   dca = rca = CLIP_ALL_BITS;
+
+   ref_cliptest[psize]( source, ref, rm, &rco, &rca );
+
+   if ( mesa_profile ) {
+      BEGIN_RACE( *cycles );
+      func( source, dest, dm, &dco, &dca );
+      END_RACE( *cycles );
+   }
+   else {
+      func( source, dest, dm, &dco, &dca );
+   }
+
+   if ( dco != rco ) {
+      printf( "\n-----------------------------\n" );
+      printf( "dco = 0x%02x   rco = 0x%02x\n", dco, rco );
+      return 0;
+   }
+   if ( dca != rca ) {
+      printf( "\n-----------------------------\n" );
+      printf( "dca = 0x%02x   rca = 0x%02x\n", dca, rca );
+      return 0;
+   }
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      if ( dm[i] != rm[i] ) {
+	 printf( "\n-----------------------------\n" );
+	 printf( "(i = %i)\n", i );
+	 printf( "dm = 0x%02x   rm = 0x%02x\n", dm[i], rm[i] );
+	 return 0;
+      }
+   }
+
+   /* Only verify output on projected points4 case.  FIXME: Do we need
+    * to test other cases?
+    */
+   if ( np || psize < 4 )
+      return 1;
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      for ( j = 0 ; j < 4 ; j++ ) {
+         if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
+            printf( "\n-----------------------------\n" );
+            printf( "(i = %i, j = %i)  dm = 0x%02x   rm = 0x%02x\n",
+		    i, j, dm[i], rm[i] );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][0], r[i][0], r[i][0]-d[i][0],
+		    MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][1], r[i][1], r[i][1]-d[i][1],
+		    MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][2], r[i][2], r[i][2]-d[i][2],
+		    MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][3], r[i][3], r[i][3]-d[i][3],
+		    MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
+            return 0;
+         }
+      }
+   }
+
+   return 1;
+}
+
+void _math_test_all_cliptest_functions( char *description )
+{
+   int np, psize;
+   long benchmark_tab[2][4];
+   static int first_time = 1;
+
+   if ( first_time ) {
+      first_time = 0;
+      mesa_profile = getenv( "MESA_PROFILE" );
+   }
+
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      if ( !counter_overhead ) {
+	 INIT_COUNTER();
+	 printf( "counter overhead: %ld cycles\n\n", counter_overhead );
+      }
+      printf( "cliptest results after hooking in %s functions:\n", description );
+   }
+#endif
+
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      printf( "\n\t" );
+      for ( psize = 2 ; psize <= 4 ; psize++ ) {
+	 printf( " p%d\t", psize );
+      }
+      printf( "\n--------------------------------------------------------\n\t" );
+   }
+#endif
+
+   for ( np = 0 ; np < 2 ; np++ ) {
+      for ( psize = 2 ; psize <= 4 ; psize++ ) {
+	 clip_func func = clip_tab[np][psize];
+	 long *cycles = &(benchmark_tab[np][psize-1]);
+
+	 if ( test_cliptest_function( func, np, psize, cycles ) == 0 ) {
+	    char buf[100];
+	    sprintf( buf, "%s[%d] failed test (%s)",
+		     cnames[np], psize, description );
+	    _mesa_problem( NULL, buf );
+	 }
+#ifdef RUN_DEBUG_BENCHMARK
+	 if ( mesa_profile )
+	    printf( " %li\t", benchmark_tab[np][psize-1] );
+#endif
+      }
+#ifdef RUN_DEBUG_BENCHMARK
+      if ( mesa_profile )
+	 printf( " | [%s]\n\t", cstrings[np] );
+#endif
+   }
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile )
+      printf( "\n" );
+#endif
+}
+
+
+#endif /* DEBUG */
Index: xc/extras/Mesa/src/math/m_debug_norm.c
diff -u /dev/null xc/extras/Mesa/src/math/m_debug_norm.c:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_debug_norm.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,371 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+
+#include "m_matrix.h"
+#include "m_xform.h"
+
+#include "m_debug.h"
+#include "m_debug_util.h"
+
+
+#ifdef DEBUG  /* This code only used for debugging */
+
+
+static int m_norm_identity[16] = {
+   ONE, NIL, NIL, NIL,
+   NIL, ONE, NIL, NIL,
+   NIL, NIL, ONE, NIL,
+   NIL, NIL, NIL, NIL
+};
+static int m_norm_general[16] = {
+   VAR, VAR, VAR, NIL,
+   VAR, VAR, VAR, NIL,
+   VAR, VAR, VAR, NIL,
+   NIL, NIL, NIL, NIL
+};
+static int m_norm_no_rot[16] = {
+   VAR, NIL, NIL, NIL,
+   NIL, VAR, NIL, NIL,
+   NIL, NIL, VAR, NIL,
+   NIL, NIL, NIL, NIL
+};
+static int *norm_templates[8] = {
+   m_norm_no_rot,
+   m_norm_no_rot,
+   m_norm_no_rot,
+   m_norm_general,
+   m_norm_general,
+   m_norm_general,
+   m_norm_identity,
+   m_norm_identity
+};
+static int norm_types[8] = {
+   NORM_TRANSFORM_NO_ROT,
+   NORM_TRANSFORM_NO_ROT | NORM_RESCALE,
+   NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE,
+   NORM_TRANSFORM,
+   NORM_TRANSFORM | NORM_RESCALE,
+   NORM_TRANSFORM | NORM_NORMALIZE,
+   NORM_RESCALE,
+   NORM_NORMALIZE
+};
+static int norm_scale_types[8] = {               /*  rescale factor          */
+   NIL,                                          /*  NIL disables rescaling  */
+   VAR,
+   NIL,
+   NIL,
+   VAR,
+   NIL,
+   VAR,
+   NIL
+};
+static int norm_normalize_types[8] = {           /*  normalizing ?? (no = 0) */
+   0,
+   0,
+   1,
+   0,
+   0,
+   1,
+   0,
+   1
+};
+static char *norm_strings[8] = {
+   "NORM_TRANSFORM_NO_ROT",
+   "NORM_TRANSFORM_NO_ROT | NORM_RESCALE",
+   "NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE",
+   "NORM_TRANSFORM",
+   "NORM_TRANSFORM | NORM_RESCALE",
+   "NORM_TRANSFORM | NORM_NORMALIZE",
+   "NORM_RESCALE",
+   "NORM_NORMALIZE"
+};
+
+
+/* =============================================================
+ * Reference transformations
+ */
+
+static void ref_norm_transform_rescale( const GLmatrix *mat,
+					GLfloat scale,
+					const GLvector3f *in,
+					const GLfloat *lengths,
+					GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *s = in->start;
+   const GLfloat *m = mat->inv;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+
+   (void) lengths;
+
+   for ( i = 0 ; i < in->count ; i++ ) {
+      GLfloat t[3];
+
+      TRANSFORM_NORMAL( t, s, m );
+      SCALE_SCALAR_3V( out[i], scale, t );
+
+      s = (GLfloat *)((char *)s + in->stride);
+   }
+}
+
+static void ref_norm_transform_normalize( const GLmatrix *mat,
+					  GLfloat scale,
+					  const GLvector3f *in,
+					  const GLfloat *lengths,
+					  GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *s = in->start;
+   const GLfloat *m = mat->inv;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+
+   for ( i = 0 ; i < in->count ; i++ ) {
+      GLfloat t[3];
+
+      TRANSFORM_NORMAL( t, s, m );
+
+      if ( !lengths ) {
+         GLfloat len = LEN_SQUARED_3FV( t );
+         if ( len > 1e-20 ) {
+	    /* Hmmm, don't know how we could test the precalculated
+	     * length case...
+	     */
+            scale = 1.0 / sqrt( len );
+	    SCALE_SCALAR_3V( out[i], scale, t );
+         } else {
+            out[i][0] = out[i][1] = out[i][2] = 0;
+         }
+      } else {
+         scale = lengths[i];;
+	 SCALE_SCALAR_3V( out[i], scale, t );
+      }
+
+      s = (GLfloat *)((char *)s + in->stride);
+   }
+}
+
+
+/* =============================================================
+ * Normal transformation tests
+ */
+
+static int test_norm_function( normal_func func, int mtype, long *cycles )
+{
+   GLvector3f source[1], dest[1], dest2[1], ref[1], ref2[1];
+   GLmatrix mat[1];
+   GLfloat s[TEST_COUNT][5], d[TEST_COUNT][3], r[TEST_COUNT][3];
+   GLfloat d2[TEST_COUNT][3], r2[TEST_COUNT][3], length[TEST_COUNT];
+   GLfloat scale;
+   GLfloat *m;
+   int i, j;
+#ifdef  RUN_DEBUG_BENCHMARK
+   int cycle_i;		/* the counter for the benchmarks we run */
+#endif
+
+   (void) cycles;
+
+   mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+   mat->inv = m = mat->m;
+
+   init_matrix( m );
+
+   scale = 1.0F + rnd () * norm_scale_types[mtype];
+
+   for ( i = 0 ; i < 4 ; i++ ) {
+      for ( j = 0 ; j < 4 ; j++ ) {
+         switch ( norm_templates[mtype][i * 4 + j] ) {
+         case NIL:
+            m[j * 4 + i] = 0.0;
+            break;
+         case ONE:
+            m[j * 4 + i] = 1.0;
+            break;
+         case NEG:
+            m[j * 4 + i] = -1.0;
+            break;
+         case VAR:
+            break;
+         default:
+            abort();
+         }
+      }
+   }
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      ASSIGN_3V( d[i],  0.0, 0.0, 0.0 );
+      ASSIGN_3V( s[i],  0.0, 0.0, 0.0 );
+      ASSIGN_3V( d2[i], 0.0, 0.0, 0.0 );
+      for ( j = 0 ; j < 3 ; j++ )
+         s[i][j] = rnd();
+      length[i] = 1 / sqrt( LEN_SQUARED_3FV( s[i] ) );
+   }
+
+   source->data = (GLfloat(*)[3])s;
+   source->start = (GLfloat *)s;
+   source->count = TEST_COUNT;
+   source->stride = sizeof(s[0]);
+   source->flags = 0;
+
+   dest->data = (GLfloat(*)[3])d;
+   dest->start = (GLfloat *)d;
+   dest->count = TEST_COUNT;
+   dest->stride = sizeof(float[3]);
+   dest->flags = 0;
+
+   dest2->data = (GLfloat(*)[3])d2;
+   dest2->start = (GLfloat *)d2;
+   dest2->count = TEST_COUNT;
+   dest2->stride = sizeof(float[3]);
+   dest2->flags = 0;
+
+   ref->data = (GLfloat(*)[3])r;
+   ref->start = (GLfloat *)r;
+   ref->count = TEST_COUNT;
+   ref->stride = sizeof(float[3]);
+   ref->flags = 0;
+
+   ref2->data = (GLfloat(*)[3])r2;
+   ref2->start = (GLfloat *)r2;
+   ref2->count = TEST_COUNT;
+   ref2->stride = sizeof(float[3]);
+   ref2->flags = 0;
+
+   if ( norm_normalize_types[mtype] == 0 ) {
+      ref_norm_transform_rescale( mat, scale, source, NULL, ref );
+   } else {
+      ref_norm_transform_normalize( mat, scale, source, NULL, ref );
+      ref_norm_transform_normalize( mat, scale, source, length, ref2 );
+   }
+
+   if ( mesa_profile ) {
+      BEGIN_RACE( *cycles );
+      func( mat, scale, source, NULL, dest );
+      END_RACE( *cycles );
+      func( mat, scale, source, length, dest2 );
+   } else {
+      func( mat, scale, source, NULL, dest );
+      func( mat, scale, source, length, dest2 );
+   }
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      for ( j = 0 ; j < 3 ; j++ ) {
+         if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
+            printf( "-----------------------------\n" );
+            printf( "(i = %i, j = %i)\n", i, j );
+            printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
+		    d[i][0], r[i][0], r[i][0]/d[i][0],
+		    MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
+            printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
+		    d[i][1], r[i][1], r[i][1]/d[i][1],
+		    MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
+            printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
+		    d[i][2], r[i][2], r[i][2]/d[i][2],
+		    MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
+            return 0;
+         }
+
+         if ( norm_normalize_types[mtype] != 0 ) {
+            if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) {
+               printf( "------------------- precalculated length case ------\n" );
+               printf( "(i = %i, j = %i)\n", i, j );
+               printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
+		       d2[i][0], r2[i][0], r2[i][0]/d2[i][0],
+		       MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) );
+               printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
+		       d2[i][1], r2[i][1], r2[i][1]/d2[i][1],
+		       MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) );
+               printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
+		       d2[i][2], r2[i][2], r2[i][2]/d2[i][2],
+		       MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) );
+               return 0;
+            }
+         }
+      }
+   }
+
+   ALIGN_FREE( mat->m );
+   return 1;
+}
+
+void _math_test_all_normal_transform_functions( char *description )
+{
+   int mtype;
+   long benchmark_tab[0xf];
+   static int first_time = 1;
+
+   if ( first_time ) {
+      first_time = 0;
+      mesa_profile = getenv( "MESA_PROFILE" );
+   }
+
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      if ( !counter_overhead ) {
+	 INIT_COUNTER();
+	 printf( "counter overhead: %ld cycles\n\n", counter_overhead );
+      }
+      printf( "normal transform results after hooking in %s functions:\n",
+	      description );
+      printf( "\n-------------------------------------------------------\n" );
+   }
+#endif
+
+   for ( mtype = 0 ; mtype < 8 ; mtype++ ) {
+      normal_func func = _mesa_normal_tab[norm_types[mtype]];
+      long *cycles = &benchmark_tab[mtype];
+
+      if ( test_norm_function( func, mtype, cycles ) == 0 ) {
+	 char buf[100];
+	 sprintf( buf, "_mesa_normal_tab[0][%s] failed test (%s)",
+		  norm_strings[mtype], description );
+	 _mesa_problem( NULL, buf );
+      }
+
+#ifdef RUN_DEBUG_BENCHMARK
+      if ( mesa_profile ) {
+	 printf( " %li\t", benchmark_tab[mtype] );
+	 printf( " | [%s]\n", norm_strings[mtype] );
+      }
+#endif
+   }
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      printf( "\n" );
+      fflush( stdout );
+   }
+#endif
+}
+
+
+#endif /* DEBUG */
Index: xc/extras/Mesa/src/math/m_debug_util.h
diff -u /dev/null xc/extras/Mesa/src/math/m_debug_util.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_debug_util.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,288 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#ifndef __M_DEBUG_UTIL_H__
+#define __M_DEBUG_UTIL_H__
+
+
+#ifdef DEBUG  /* This code only used for debugging */
+
+
+/* Comment this out to deactivate the cycle counter.
+ * NOTE: it works only on CPUs which know the 'rdtsc' command (586 or higher)
+ * (hope, you don't try to debug Mesa on a 386 ;)
+ */
+#if defined(__GNUC__) && \
+    ((defined(__i386__) && defined(USE_X86_ASM)) || \
+     (defined(__sparc__) && defined(USE_SPARC_ASM)))
+#define  RUN_DEBUG_BENCHMARK
+#endif
+
+#define TEST_COUNT		128	/* size of the tested vector array   */
+
+#define REQUIRED_PRECISION	10	/* allow 4 bits to miss              */
+#define MAX_PRECISION		24	/* max. precision possible           */
+
+
+#ifdef  RUN_DEBUG_BENCHMARK
+/* Overhead of profiling counter in cycles.  Automatically adjusted to
+ * your machine at run time - counter initialization should give very
+ * consistent results.
+ */
+extern long counter_overhead;
+
+/* This is the value of the environment variable MESA_PROFILE, and is
+ * used to determine if we should benchmark the functions as well as
+ * verify their correctness.
+ */
+extern char *mesa_profile;
+
+/* Modify the the number of tests if you like.
+ * We take the minimum of all results, because every error should be
+ * positive (time used by other processes, task switches etc).
+ * It is assumed that all calculations are done in the cache.
+ */
+
+#if defined(__i386__)
+
+#if 1 /* PPro, PII, PIII version */
+
+/* Profiling on the P6 architecture requires a little more work, due to
+ * the internal out-of-order execution.  We must perform a serializing
+ * 'cpuid' instruction before and after the 'rdtsc' instructions to make
+ * sure no other uops are executed when we sample the timestamp counter.
+ */
+#define  INIT_COUNTER()							\
+   do {									\
+      int cycle_i;							\
+      counter_overhead = LONG_MAX;					\
+      for ( cycle_i = 0 ; cycle_i < 8 ; cycle_i++ ) {			\
+	 long cycle_tmp1 = 0, cycle_tmp2 = 0;				\
+	 __asm__ __volatile__ ( "push %%ebx       \n"			\
+				"xor %%eax, %%eax \n"			\
+				"cpuid            \n"			\
+				"rdtsc            \n"			\
+				"mov %%eax, %0    \n"			\
+				"xor %%eax, %%eax \n"			\
+				"cpuid            \n"			\
+				"pop %%ebx        \n"			\
+				"push %%ebx       \n"			\
+				"xor %%eax, %%eax \n"			\
+				"cpuid            \n"			\
+				"rdtsc            \n"			\
+				"mov %%eax, %1    \n"			\
+				"xor %%eax, %%eax \n"			\
+				"cpuid            \n"			\
+				"pop %%ebx        \n"			\
+				: "=m" (cycle_tmp1), "=m" (cycle_tmp2)	\
+				: : "eax", "ecx", "edx" );		\
+	 if ( counter_overhead > (cycle_tmp2 - cycle_tmp1) ) {		\
+	    counter_overhead = cycle_tmp2 - cycle_tmp1;			\
+	 }								\
+      }									\
+   } while (0)
+
+#define  BEGIN_RACE(x)							\
+   x = LONG_MAX;							\
+   for ( cycle_i = 0 ; cycle_i < 10 ; cycle_i++ ) {			\
+      long cycle_tmp1 = 0, cycle_tmp2 = 0;				\
+      __asm__ __volatile__ ( "push %%ebx       \n"			\
+			     "xor %%eax, %%eax \n"			\
+			     "cpuid            \n"			\
+			     "rdtsc            \n"			\
+			     "mov %%eax, %0    \n"			\
+			     "xor %%eax, %%eax \n"			\
+			     "cpuid            \n"			\
+			     "pop %%ebx        \n"			\
+			     : "=m" (cycle_tmp1)			\
+			     : : "eax", "ecx", "edx" );
+
+#define END_RACE(x)							\
+      __asm__ __volatile__ ( "push %%ebx       \n"			\
+			     "xor %%eax, %%eax \n"			\
+			     "cpuid            \n"			\
+			     "rdtsc            \n"			\
+			     "mov %%eax, %0    \n"			\
+			     "xor %%eax, %%eax \n"			\
+			     "cpuid            \n"			\
+			     "pop %%ebx        \n"			\
+			     : "=m" (cycle_tmp2)			\
+			     : : "eax", "ecx", "edx" );			\
+      if ( x > (cycle_tmp2 - cycle_tmp1) ) {				\
+	 x = cycle_tmp2 - cycle_tmp1;					\
+      }									\
+   }									\
+   x -= counter_overhead;
+
+#else /* PPlain, PMMX version */
+
+/* To ensure accurate results, we stall the pipelines with the
+ * non-pairable 'cdq' instruction.  This ensures all the code being
+ * profiled is complete when the 'rdtsc' instruction executes.
+ */
+#define  INIT_COUNTER(x)						\
+   do {									\
+      int cycle_i;							\
+      x = LONG_MAX;							\
+      for ( cycle_i = 0 ; cycle_i < 32 ; cycle_i++ ) {			\
+	 long cycle_tmp1, cycle_tmp2, dummy;				\
+	 __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp1) );		\
+	 __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp2) );		\
+	 __asm__ ( "cdq" );						\
+	 __asm__ ( "cdq" );						\
+	 __asm__ ( "rdtsc" : "=a" (cycle_tmp1), "=d" (dummy) );		\
+	 __asm__ ( "cdq" );						\
+	 __asm__ ( "cdq" );						\
+	 __asm__ ( "rdtsc" : "=a" (cycle_tmp2), "=d" (dummy) );		\
+	 if ( x > (cycle_tmp2 - cycle_tmp1) )				\
+	    x = cycle_tmp2 - cycle_tmp1;				\
+      }									\
+   } while (0)
+
+#define  BEGIN_RACE(x)							\
+   x = LONG_MAX;							\
+   for ( cycle_i = 0 ; cycle_i < 16 ; cycle_i++ ) {			\
+      long cycle_tmp1, cycle_tmp2, dummy;				\
+      __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp1) );			\
+      __asm__ ( "mov %%eax, %0" : "=a" (cycle_tmp2) );			\
+      __asm__ ( "cdq" );						\
+      __asm__ ( "cdq" );						\
+      __asm__ ( "rdtsc" : "=a" (cycle_tmp1), "=d" (dummy) );
+
+
+#define END_RACE(x)							\
+      __asm__ ( "cdq" );						\
+      __asm__ ( "cdq" );						\
+      __asm__ ( "rdtsc" : "=a" (cycle_tmp2), "=d" (dummy) );		\
+      if ( x > (cycle_tmp2 - cycle_tmp1) )				\
+	 x = cycle_tmp2 - cycle_tmp1;					\
+   }									\
+   x -= counter_overhead;
+
+#endif
+
+#elif defined(__sparc__)
+
+#define  INIT_COUNTER()	\
+	 do { counter_overhead = 5; } while(0)
+
+#define  BEGIN_RACE(x)                                                        \
+x = LONG_MAX;                                                                 \
+for (cycle_i = 0; cycle_i <10; cycle_i++) {                                   \
+   register long cycle_tmp1 asm("l0");					      \
+   register long cycle_tmp2 asm("l1");					      \
+   /* rd %tick, %l0 */							      \
+   __asm__ __volatile__ (".word 0xa1410000" : "=r" (cycle_tmp1));  /*  save timestamp   */
+
+#define END_RACE(x)                                                           \
+   /* rd %tick, %l1 */							      \
+   __asm__ __volatile__ (".word 0xa3410000" : "=r" (cycle_tmp2));	      \
+   if (x > (cycle_tmp2-cycle_tmp1)) x = cycle_tmp2 - cycle_tmp1;              \
+}                                                                             \
+x -= counter_overhead;
+
+#else
+#error Your processor is not supported for RUN_XFORM_BENCHMARK
+#endif
+
+#else
+
+#define BEGIN_RACE(x)
+#define END_RACE(x)
+
+#endif
+
+
+/* =============================================================
+ * Helper functions
+ */
+
+static GLfloat rnd( void )
+{
+   GLfloat f = (GLfloat)rand() / (GLfloat)RAND_MAX;
+   GLfloat gran = (GLfloat)(1 << 13);
+
+   f = (GLfloat)(GLint)(f * gran) / gran;
+
+   return f * 2.0 - 1.0;
+}
+
+static int significand_match( GLfloat a, GLfloat b )
+{
+   GLfloat d = a - b;
+   int a_ex, b_ex, d_ex;
+
+   if ( d == 0.0F ) {
+      return MAX_PRECISION;   /* Exact match */
+   }
+
+   if ( a == 0.0F || b == 0.0F ) {
+      /* It would probably be better to check if the
+       * non-zero number is denormalized and return
+       * the index of the highest set bit here.
+       */
+      return 0;
+   }
+
+   frexp( a, &a_ex );
+   frexp( b, &b_ex );
+   frexp( d, &d_ex );
+
+   if ( a_ex < b_ex ) {
+      return a_ex - d_ex;
+   } else {
+      return b_ex - d_ex;
+   }
+}
+
+enum { NIL = 0, ONE = 1, NEG = -1, VAR = 2 };
+
+static void init_matrix( GLfloat *m )
+{
+   m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0;
+   m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] =  7.0;
+   m[2] = 44.0; m[6] =  9.0; m[10] =  7.0; m[14] =  3.0;
+   m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] =  9.0;
+}
+
+
+/* Ensure our arrays are correctly aligned.
+ */
+#if defined(__GNUC__)
+#  define ALIGN16	__attribute__ ((aligned (16)))
+#elif defined(__MSC__)
+#  define ALIGN16	__declspec(align(16)) /* GH: Does this work? */
+#else
+#  warning "ALIGN16 will not 16-byte align!\n"
+#  define ALIGN16
+#endif
+
+
+#endif /* DEBUG */
+
+#endif /* __M_DEBUG_UTIL_H__ */
Index: xc/extras/Mesa/src/math/m_debug_vertex.c
diff -u /dev/null xc/extras/Mesa/src/math/m_debug_vertex.c:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_debug_vertex.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,537 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "m_matrix.h"
+#include "m_vertices.h"
+#include "m_xform.h"
+
+#include "m_debug.h"
+#include "m_debug_util.h"
+
+
+#ifdef DEBUG  /* This code only used for debugging */
+
+
+#define NUM_V16_FUNCS	4
+
+#ifdef RUN_DEBUG_BENCHMARK
+static char *v16_strings[NUM_V16_FUNCS] = {
+   "_mesa_xform_points3_v16_general",
+   "_mesa_cliptest_points4_v16",
+   "_mesa_project_v16",
+   "_mesa_project_clipped_v16"
+};
+#endif
+
+
+/* =============================================================
+ * Reference transformations
+ */
+
+static void ref_transform_v16( GLfloat *f,
+			       const GLfloat *m,
+			       const GLfloat *obj,
+			       GLuint obj_stride,
+			       GLuint count )
+{
+   GLuint i;
+
+   for ( i = 0 ; i < count ; i++, STRIDE_F(obj, obj_stride), f += 16 ) {
+      const GLfloat ox = obj[0], oy = obj[1], oz = obj[2];
+      f[0] = m[0] * ox + m[4] * oy + m[8]  * oz + m[12];
+      f[1] = m[1] * ox + m[5] * oy + m[9]  * oz + m[13];
+      f[2] = m[2] * ox + m[6] * oy + m[10] * oz + m[14];
+      f[3] = m[3] * ox + m[7] * oy + m[11] * oz + m[15];
+   }
+}
+
+static void ref_cliptest_v16( GLfloat *first,
+			      GLfloat *last,
+			      GLubyte *p_clipOr,
+			      GLubyte *p_clipAnd,
+			      GLubyte *clipmask )
+{
+   GLubyte clipAnd = (GLubyte) ~0;
+   GLubyte clipOr = 0;
+   GLfloat *f = first;
+   static int i;
+   i = 0;
+
+   for ( ; f != last ; f += 16, clipmask++, i++ ) {
+      const GLfloat cx = f[0];
+      const GLfloat cy = f[1];
+      const GLfloat cz = f[2];
+      const GLfloat cw = f[3];
+      GLubyte mask = 0;
+
+      if (cx >  cw) mask |= CLIP_RIGHT_BIT;
+      if (cx < -cw) mask |= CLIP_LEFT_BIT;
+      if (cy >  cw) mask |= CLIP_TOP_BIT;
+      if (cy < -cw) mask |= CLIP_BOTTOM_BIT;
+      if (cz >  cw) mask |= CLIP_FAR_BIT;
+      if (cz < -cw) mask |= CLIP_NEAR_BIT;
+
+      *clipmask = mask;
+      clipAnd &= mask;
+      clipOr |= mask;
+   }
+
+   (*p_clipOr) |= clipOr;
+   (*p_clipAnd) &= clipAnd;
+}
+
+static void ref_project_verts( GLfloat *first,
+			       GLfloat *last,
+			       const GLfloat *m,
+			       GLuint stride )
+{
+   const GLfloat sx = m[0], sy = m[5], sz = m[10];
+   const GLfloat tx = m[12], ty = m[13], tz = m[14];
+   GLfloat *f;
+
+   for (f = first; f != last; STRIDE_F(f, stride)) {
+      const GLfloat oow = 1.0F / f[3];
+      f[0] = sx * f[0] * oow + tx;
+      f[1] = sy * f[1] * oow + ty;
+      f[2] = sz * f[2] * oow + tz;
+      f[3] = oow;
+   }
+}
+
+static void ref_project_clipped_verts( GLfloat *first,
+				       GLfloat *last,
+				       const GLfloat *m,
+				       GLuint stride,
+				       const GLubyte *clipmask )
+{
+   const GLfloat sx = m[0], sy = m[5], sz = m[10];
+   const GLfloat tx = m[12], ty = m[13], tz = m[14];
+   GLfloat *f;
+
+   for ( f = first ; f != last ; STRIDE_F(f, stride), clipmask++ ) {
+      if (!(*clipmask)) {
+	 const GLfloat oow = 1.0F / f[3];
+	 f[0] = sx * f[0] * oow + tx;
+	 f[1] = sy * f[1] * oow + ty;
+	 f[2] = sz * f[2] * oow + tz;
+	 f[3] = oow;
+      }
+   }
+}
+
+
+
+/* =============================================================
+ * Vertex transformation, clipping etc tests
+ */
+
+static GLfloat ALIGN16(s[TEST_COUNT][4]);
+static GLfloat ALIGN16(d[TEST_COUNT][16]);
+static GLfloat ALIGN16(r[TEST_COUNT][16]);
+
+static int test_transform_function( long *cycles )
+{
+   GLvector4f source[1];
+   GLfloat *m;
+   int i, j;
+#ifdef  RUN_DEBUG_BENCHMARK
+   int cycle_i;                /* the counter for the benchmarks we run */
+#endif
+
+   m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+
+   m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0;
+   m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] =  7.0;
+   m[2] = 44.0; m[6] =  9.0; m[10] =  7.0; m[14] =  3.0;
+   m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] =  9.0;
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      d[i][0] = s[i][0] = 0.0;
+      d[i][1] = s[i][1] = 0.0;
+      d[i][2] = s[i][2] = 0.0;
+      d[i][3] = s[i][3] = 1.0;
+      for ( j = 0 ; j < 3 ; j++ )
+         s[i][j] = rnd();
+   }
+
+   source->data = (GLfloat(*)[4])s;
+   source->start = (GLfloat *)s;
+   source->count = TEST_COUNT;
+   source->stride = sizeof(s[0]);
+   source->size = 4;
+   source->flags = 0;
+
+   ref_transform_v16( (GLfloat *)r,
+		      m,
+		      source->start,
+		      source->stride,
+		      TEST_COUNT );
+
+   if ( mesa_profile ) {
+      BEGIN_RACE( *cycles );
+      _mesa_xform_points3_v16_general( (GLfloat *)d,
+                                       m,
+                                       source->start,
+                                       source->stride,
+                                       TEST_COUNT );
+      END_RACE( *cycles );
+   } else {
+      _mesa_xform_points3_v16_general( (GLfloat *)d,
+                                       m,
+                                       source->start,
+                                       source->stride,
+                                       TEST_COUNT );
+   }
+
+   ALIGN_FREE( m );
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      for ( j = 0 ; j < 4 ; j++ ) {
+         if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
+            printf( "-----------------------------\n" );
+            printf( "(i = %i, j = %i)\n", i, j );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][0], r[i][0], r[i][0]-d[i][0],
+		    MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][1], r[i][1], r[i][1]-d[i][1],
+		    MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][2], r[i][2], r[i][2]-d[i][2],
+		    MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][3], r[i][3], r[i][3]-d[i][3],
+		    MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
+	    return 0;
+         }
+      }
+   }
+
+   return 1;
+}
+
+static int test_cliptest_function( long *cycles )
+{
+   GLvector4f source[1];
+   GLubyte dco, dca, rco, rca;
+   GLubyte dm[TEST_COUNT], rm[TEST_COUNT];
+   GLfloat *m;
+   int i, j;
+#ifdef  RUN_DEBUG_BENCHMARK
+   int cycle_i;                /* the counter for the benchmarks we run */
+#endif
+
+   m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+
+   init_matrix( m );
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      d[i][0] = s[i][0] = 0.0;
+      d[i][1] = s[i][1] = 0.0;
+      d[i][2] = s[i][2] = 0.0;
+      d[i][3] = s[i][3] = 1.0;
+      for ( j = 0 ; j < 3 ; j++ )
+         s[i][j] = rnd();
+   }
+
+   source->data = (GLfloat(*)[4])s;
+   source->start = (GLfloat *)s;
+   source->count = TEST_COUNT;
+   source->stride = sizeof(s[0]);
+   source->size = 4;
+   source->flags = 0;
+
+   /* Build up a reference list of transformed points
+    */
+   ref_transform_v16( (GLfloat *)r,
+		      m,
+		      source->start,
+		      source->stride,
+		      TEST_COUNT );
+
+   dca = rca = ~0;
+   dco = rco = 0;
+
+   ref_cliptest_v16( (GLfloat *)r,
+		     (GLfloat *)&r[TEST_COUNT][0],
+		     &rco,
+		     &rca,
+		     &rm[0] );
+
+   if ( mesa_profile ) {
+      BEGIN_RACE( *cycles );
+      _mesa_cliptest_points4_v16( (GLfloat *)r,
+			       (GLfloat *)&r[TEST_COUNT][0],
+			       &dco,
+			       &dca,
+			       &dm[0] );
+      END_RACE( *cycles );
+   } else {
+      _mesa_cliptest_points4_v16( (GLfloat *)r,
+			       (GLfloat *)&r[TEST_COUNT][0],
+			       &dco,
+			       &dca,
+			       dm );
+   }
+
+   ALIGN_FREE( m );
+
+   if ( dco != rco ) {
+      printf( "-----------------------------\n" );
+      printf( "dco = 0x%02x   rco = 0x%02x\n", dco, rco );
+      return 0;
+   }
+   if ( dca != rca ) {
+      printf( "-----------------------------\n" );
+      printf( "dca = 0x%02x   rca = 0x%02x\n", dca, rca );
+      return 0;
+   }
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      if ( dm[i] != rm[i] ) {
+	 printf( "-----------------------------\n" );
+	 printf( "(i = %i)\n", i );
+	 printf( "dm = 0x%02x   rm = 0x%02x\n", dm[i], rm[i] );
+	 return 0;
+      }
+   }
+
+   return 1;
+}
+
+static int test_project_function( long *cycles, int clipped )
+{
+   GLvector4f source[1];
+   GLubyte co, ca;
+   GLubyte mask[TEST_COUNT];
+   GLfloat *m;
+   int i, j;
+#ifdef  RUN_DEBUG_BENCHMARK
+   int cycle_i;                /* the counter for the benchmarks we run */
+#endif
+
+   m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+
+   init_matrix( m );
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      d[i][0] = s[i][0] = 0.0;
+      d[i][1] = s[i][1] = 0.0;
+      d[i][2] = s[i][2] = 0.0;
+      d[i][3] = s[i][3] = 1.0;
+      for ( j = 0 ; j < 3 ; j++ )
+         s[i][j] = rnd();
+   }
+
+   source->data = (GLfloat(*)[4])s;
+   source->start = (GLfloat *)s;
+   source->count = TEST_COUNT;
+   source->stride = sizeof(s[0]);
+   source->size = 4;
+   source->flags = 0;
+
+   /* Build up a reference list of transformed points
+    */
+   ref_transform_v16( (GLfloat *)d,
+		      m,
+		      source->start,
+		      source->stride,
+		      TEST_COUNT );
+   ref_transform_v16( (GLfloat *)r,
+		      m,
+		      source->start,
+		      source->stride,
+		      TEST_COUNT );
+
+   if ( clipped ) {
+      ca = ~0;
+      co = 0;
+      ref_cliptest_v16( (GLfloat *)r,
+			(GLfloat *)&r[TEST_COUNT][0],
+			&co,
+			&ca,
+			mask );
+      ref_project_clipped_verts( (GLfloat *)r,
+				 (GLfloat *)&r[TEST_COUNT][0],
+				 m,
+				 16 * 4,
+				 mask );
+   } else {
+      ref_project_verts( (GLfloat *)r,
+			 (GLfloat *)&r[TEST_COUNT][0],
+			 m,
+			 16 * 4 );
+   }
+
+   if ( mesa_profile ) {
+      if ( clipped ) {
+	 /*BEGIN_RACE( *cycles );*/
+	 _mesa_project_clipped_v16( (GLfloat *)d,
+				 (GLfloat *)&d[TEST_COUNT][0],
+				 m,
+				 16 * 4,
+				 mask );
+	 /*END_RACE( *cycles );*/
+      } else {
+	 /*BEGIN_RACE( *cycles );*/
+	 _mesa_project_v16( (GLfloat *)d,
+			 (GLfloat *)&d[TEST_COUNT][0],
+			 m,
+			 16 * 4 );
+	 /*END_RACE( *cycles );*/
+      }
+   } else {
+      if ( clipped ) {
+	 _mesa_project_clipped_v16( (GLfloat *)d,
+				 (GLfloat *)&d[TEST_COUNT][0],
+				 m,
+				 16 * 4,
+				 mask );
+      } else {
+	 _mesa_project_v16( (GLfloat *)d,
+			 (GLfloat *)&d[TEST_COUNT][0],
+			 m,
+			 16 * 4 );
+      }
+   }
+
+   ALIGN_FREE( m );
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      for ( j = 0 ; j < 4 ; j++ ) {
+         if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
+            printf( "-----------------------------\n" );
+            printf( "(i = %i, j = %i)\n", i, j );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][0], r[i][0], r[i][0]-d[i][0],
+		    MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][1], r[i][1], r[i][1]-d[i][1],
+		    MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][2], r[i][2], r[i][2]-d[i][2],
+		    MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][3], r[i][3], r[i][3]-d[i][3],
+		    MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
+	    return 0;
+         }
+      }
+   }
+
+   return 1;
+}
+
+void _math_test_all_vertex_functions( char *description )
+{
+   long benchmark_tab[NUM_V16_FUNCS];
+   long *cycles;
+   static int first_time = 1;
+
+   if ( first_time ) {
+      first_time = 0;
+      mesa_profile = getenv( "MESA_PROFILE" );
+   }
+
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      int i;
+      if ( !counter_overhead ) {
+	 INIT_COUNTER();
+	 printf( "counter overhead: %ld cycles\n\n", counter_overhead );
+      }
+      printf( "fastpath vertex results after hooking in %s functions:\n",
+	      description );
+      printf( "\n--------------------------------------------------------\n" );
+
+      for ( i = 0 ; i < NUM_V16_FUNCS ; i++ ) {
+	 benchmark_tab[i] = 0;
+      }
+   }
+#endif
+
+   /* Test fastpath transformation
+    */
+   cycles = &benchmark_tab[0];
+
+   if ( test_transform_function( cycles ) == 0 ) {
+      char buf[100];
+      sprintf( buf, "_mesa_xform_points3_v16_general failed test (%s)",
+	       description );
+      _mesa_problem( NULL, buf );
+   }
+
+   /* Test fastpath clipping
+    */
+   cycles = &benchmark_tab[1];
+
+   if ( test_cliptest_function( cycles ) == 0 ) {
+      char buf[100];
+      sprintf( buf, "_mesa_cliptest_points4_v16 failed test (%s)",
+	       description );
+      _mesa_problem( NULL, buf );
+   }
+
+   /* Test fastpath projection
+    */
+   cycles = &benchmark_tab[2];
+
+   if ( test_project_function( cycles, 0 ) == 0 ) {
+      char buf[100];
+      sprintf( buf, "_mesa_project_v16 failed test (%s)",
+	       description );
+      _mesa_problem( NULL, buf );
+   }
+
+   cycles = &benchmark_tab[3];
+
+   if ( test_project_function( cycles, 1 ) == 0 ) {
+      char buf[100];
+      sprintf( buf, "_mesa_project_clipped_v16 failed test (%s)",
+	       description );
+      _mesa_problem( NULL, buf );
+   }
+
+
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      int i;
+      for ( i = 0 ; i < NUM_V16_FUNCS ; i++ ) {
+	 printf( " %li\t | [%s]\n", benchmark_tab[i], v16_strings[i] );
+      }
+      printf( "\n" );
+   }
+#endif
+}
+
+
+#endif /* DEBUG */
Index: xc/extras/Mesa/src/math/m_debug_xform.c
diff -u /dev/null xc/extras/Mesa/src/math/m_debug_xform.c:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_debug_xform.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,326 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Updated for P6 architecture by Gareth Hughes.
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "m_matrix.h"
+#include "m_xform.h"
+
+#include "m_debug.h"
+#include "m_debug_util.h"
+
+#ifdef DEBUG  /* This code only used for debugging */
+
+
+/* Overhead of profiling counter in cycles.  Automatically adjusted to
+ * your machine at run time - counter initialization should give very
+ * consistent results.
+ */
+long counter_overhead = 0;
+
+/* This is the value of the environment variable MESA_PROFILE, and is
+ * used to determine if we should benchmark the functions as well as
+ * verify their correctness.
+ */
+char *mesa_profile = NULL;
+
+
+static int m_general[16] = {
+   VAR, VAR, VAR, VAR,
+   VAR, VAR, VAR, VAR,
+   VAR, VAR, VAR, VAR,
+   VAR, VAR, VAR, VAR
+};
+static int m_identity[16] = {
+   ONE, NIL, NIL, NIL,
+   NIL, ONE, NIL, NIL,
+   NIL, NIL, ONE, NIL,
+   NIL, NIL, NIL, ONE
+};
+static int  m_2d[16]  = {
+   VAR, VAR, NIL, VAR,
+   VAR, VAR, NIL, VAR,
+   NIL, NIL, ONE, NIL,
+   NIL, NIL, NIL, ONE
+};
+static int m_2d_no_rot[16] = {
+   VAR, NIL, NIL, VAR,
+   NIL, VAR, NIL, VAR,
+   NIL, NIL, ONE, NIL,
+   NIL, NIL, NIL, ONE
+};
+static int m_3d[16] = {
+   VAR, VAR, VAR, VAR,
+   VAR, VAR, VAR, VAR,
+   VAR, VAR, VAR, VAR,
+   NIL, NIL, NIL, ONE
+};
+static int m_3d_no_rot[16] = {
+   VAR, NIL, NIL, VAR,
+   NIL, VAR, NIL, VAR,
+   NIL, NIL, VAR, VAR,
+   NIL, NIL, NIL, ONE
+};
+static int m_perspective[16] = {
+   VAR, NIL, VAR, NIL,
+   NIL, VAR, VAR, NIL,
+   NIL, NIL, VAR, VAR,
+   NIL, NIL, NEG, NIL
+};
+static int *templates[7] = {
+   m_general,
+   m_identity,
+   m_3d_no_rot,
+   m_perspective,
+   m_2d,
+   m_2d_no_rot,
+   m_3d
+};
+static int mtypes[7] = {
+   MATRIX_GENERAL,
+   MATRIX_IDENTITY,
+   MATRIX_3D_NO_ROT,
+   MATRIX_PERSPECTIVE,
+   MATRIX_2D,
+   MATRIX_2D_NO_ROT,
+   MATRIX_3D
+};
+static char *mstrings[7] = {
+   "MATRIX_GENERAL",
+   "MATRIX_IDENTITY",
+   "MATRIX_3D_NO_ROT",
+   "MATRIX_PERSPECTIVE",
+   "MATRIX_2D",
+   "MATRIX_2D_NO_ROT",
+   "MATRIX_3D"
+};
+
+
+/* =============================================================
+ * Reference transformations
+ */
+
+static void ref_transform( GLvector4f *dst,
+                           const GLmatrix *mat,
+                           const GLvector4f *src )
+{
+   GLuint i;
+   GLfloat *s = (GLfloat *)src->start;
+   GLfloat (*d)[4] = (GLfloat (*)[4])dst->start;
+   const GLfloat *m = mat->m;
+
+   for ( i = 0 ; i < src->count ; i++ ) {
+      TRANSFORM_POINT( d[i], m, s );
+      s = (GLfloat *)((char *)s + src->stride);
+   }
+}
+
+
+/* =============================================================
+ * Vertex transformation tests
+ */
+
+static GLfloat s[TEST_COUNT][4] ALIGN16;
+static GLfloat d[TEST_COUNT][4] ALIGN16;
+static GLfloat r[TEST_COUNT][4] ALIGN16;
+
+static int test_transform_function( transform_func func, int psize,
+				    int mtype, long *cycles )
+{
+   GLvector4f source[1], dest[1], ref[1];
+   GLmatrix mat[1];
+   GLfloat *m;
+   int i, j;
+#ifdef  RUN_DEBUG_BENCHMARK
+   int cycle_i;                /* the counter for the benchmarks we run */
+#endif
+
+   (void) cycles;
+
+   if ( psize > 4 ) {
+      _mesa_problem( NULL, "test_transform_function called with psize > 4\n" );
+      return 0;
+   }
+
+   mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+   mat->type = mtypes[mtype];
+
+   m = mat->m;
+   ASSERT( ((GLuint)m & 15) == 0 );
+
+   init_matrix( m );
+
+   for ( i = 0 ; i < 4 ; i++ ) {
+      for ( j = 0 ; j < 4 ; j++ ) {
+         switch ( templates[mtype][i * 4 + j] ) {
+         case NIL:
+            m[j * 4 + i] = 0.0;
+            break;
+         case ONE:
+            m[j * 4 + i] = 1.0;
+            break;
+         case NEG:
+            m[j * 4 + i] = -1.0;
+            break;
+         case VAR:
+            break;
+         default:
+            abort();
+         }
+      }
+   }
+
+   for ( i = 0 ; i < TEST_COUNT ; i++) {
+      ASSIGN_4V( d[i], 0.0, 0.0, 0.0, 1.0 );
+      ASSIGN_4V( s[i], 0.0, 0.0, 0.0, 1.0 );
+      for ( j = 0 ; j < psize ; j++ )
+         s[i][j] = rnd();
+   }
+
+   source->data = (GLfloat(*)[4])s;
+   source->start = (GLfloat *)s;
+   source->count = TEST_COUNT;
+   source->stride = sizeof(s[0]);
+   source->size = 4;
+   source->flags = 0;
+
+   dest->data = (GLfloat(*)[4])d;
+   dest->start = (GLfloat *)d;
+   dest->count = TEST_COUNT;
+   dest->stride = sizeof(float[4]);
+   dest->size = 0;
+   dest->flags = 0;
+
+   ref->data = (GLfloat(*)[4])r;
+   ref->start = (GLfloat *)r;
+   ref->count = TEST_COUNT;
+   ref->stride = sizeof(float[4]);
+   ref->size = 0;
+   ref->flags = 0;
+
+   ref_transform( ref, mat, source );
+
+   if ( mesa_profile ) {
+      BEGIN_RACE( *cycles );
+      func( dest, mat->m, source );
+      END_RACE( *cycles );
+   }
+   else {
+      func( dest, mat->m, source );
+   }
+
+   for ( i = 0 ; i < TEST_COUNT ; i++ ) {
+      for ( j = 0 ; j < 4 ; j++ ) {
+         if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
+            printf( "-----------------------------\n" );
+            printf( "(i = %i, j = %i)\n", i, j );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][0], r[i][0], r[i][0]-d[i][0],
+		    MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][1], r[i][1], r[i][1]-d[i][1],
+		    MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][2], r[i][2], r[i][2]-d[i][2],
+		    MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
+            printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
+		    d[i][3], r[i][3], r[i][3]-d[i][3],
+		    MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
+            return 0;
+         }
+      }
+   }
+
+   ALIGN_FREE( mat->m );
+   return 1;
+}
+
+void _math_test_all_transform_functions( char *description )
+{
+   int psize, mtype;
+   long benchmark_tab[4][7];
+   static int first_time = 1;
+
+   if ( first_time ) {
+      first_time = 0;
+      mesa_profile = getenv( "MESA_PROFILE" );
+   }
+
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      if ( !counter_overhead ) {
+	 INIT_COUNTER();
+	 printf( "counter overhead: %ld cycles\n\n", counter_overhead );
+      }
+      printf( "transform results after hooking in %s functions:\n", description );
+   }
+#endif
+
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile ) {
+      printf( "\n" );
+      for ( psize = 1 ; psize <= 4 ; psize++ ) {
+	 printf( " p%d\t", psize );
+      }
+      printf( "\n--------------------------------------------------------\n" );
+   }
+#endif
+
+   for ( mtype = 0 ; mtype < 7 ; mtype++ ) {
+      for ( psize = 1 ; psize <= 4 ; psize++ ) {
+	 transform_func func = _mesa_transform_tab[psize][mtypes[mtype]];
+	 long *cycles = &(benchmark_tab[psize-1][mtype]);
+
+	 if ( test_transform_function( func, psize, mtype, cycles ) == 0 ) {
+	    char buf[100];
+	    sprintf( buf, "_mesa_transform_tab[0][%d][%s] failed test (%s)",
+		     psize, mstrings[mtype], description );
+	    _mesa_problem( NULL, buf );
+	 }
+#ifdef RUN_DEBUG_BENCHMARK
+	 if ( mesa_profile )
+	    printf( " %li\t", benchmark_tab[psize-1][mtype] );
+#endif
+      }
+#ifdef RUN_DEBUG_BENCHMARK
+      if ( mesa_profile )
+	 printf( " | [%s]\n", mstrings[mtype] );
+#endif
+   }
+#ifdef RUN_DEBUG_BENCHMARK
+   if ( mesa_profile )
+      printf( "\n" );
+#endif
+}
+
+
+#endif /* DEBUG */
Index: xc/extras/Mesa/src/math/m_dotprod_tmp.h
diff -u /dev/null xc/extras/Mesa/src/math/m_dotprod_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_dotprod_tmp.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,102 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+/* Note - respects the stride of the output vector.
+ */
+static void TAG(dotprod_vec2)( GLfloat *out,
+			       GLuint outstride,
+			       const GLvector4f *coord_vec,
+			       const GLfloat plane[4] )
+{
+   GLuint stride = coord_vec->stride;
+   GLfloat *coord = coord_vec->start;
+   GLuint count = coord_vec->count;
+
+   GLuint i;
+
+   const GLfloat plane0 = plane[0], plane1 = plane[1], plane3 = plane[3];
+
+   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(out,outstride)) {
+      *out = (coord[0] * plane0 +
+	      coord[1] * plane1 +
+	      plane3);
+   }
+}
+
+static void TAG(dotprod_vec3)( GLfloat *out,
+			       GLuint outstride,
+			       const GLvector4f *coord_vec,
+			       const GLfloat plane[4] )
+{
+   GLuint stride = coord_vec->stride;
+   GLfloat *coord = coord_vec->start;
+   GLuint count = coord_vec->count;
+
+   GLuint i;
+
+   const GLfloat plane0 = plane[0], plane1 = plane[1], plane2 = plane[2];
+   const GLfloat plane3 = plane[3];
+
+   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(out,outstride)) {
+      *out = (coord[0] * plane0 +
+	      coord[1] * plane1 +
+	      coord[2] * plane2 +
+	      plane3);
+   }
+}
+
+static void TAG(dotprod_vec4)( GLfloat *out,
+			       GLuint outstride,
+			       const GLvector4f *coord_vec,
+			       const GLfloat plane[4] )
+{
+   GLuint stride = coord_vec->stride;
+   GLfloat *coord = coord_vec->start;
+   GLuint count = coord_vec->count;
+   GLuint i;
+
+   const GLfloat plane0 = plane[0], plane1 = plane[1], plane2 = plane[2];
+   const GLfloat plane3 = plane[3];
+
+   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(out,outstride)) {
+      *out = (coord[0] * plane0 +
+	      coord[1] * plane1 +
+	      coord[2] * plane2 +
+	      coord[3] * plane3);
+   }
+}
+
+
+static void TAG(init_dotprod)( void )
+{
+   _mesa_dotprod_tab[2] = TAG(dotprod_vec2);
+   _mesa_dotprod_tab[3] = TAG(dotprod_vec3);
+   _mesa_dotprod_tab[4] = TAG(dotprod_vec4);
+}
Index: xc/extras/Mesa/src/math/m_eval.c
diff -u /dev/null xc/extras/Mesa/src/math/m_eval.c:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_eval.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,461 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * eval.c was written by
+ * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
+ * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
+ *
+ * My original implementation of evaluators was simplistic and didn't
+ * compute surface normal vectors properly.  Bernd and Volker applied
+ * used more sophisticated methods to get better results.
+ *
+ * Thanks guys!
+ */
+
+
+#include "glheader.h"
+#include "config.h"
+#include "m_eval.h"
+
+static GLfloat inv_tab[MAX_EVAL_ORDER];
+
+
+
+/*
+ * Horner scheme for Bezier curves
+ *
+ * Bezier curves can be computed via a Horner scheme.
+ * Horner is numerically less stable than the de Casteljau
+ * algorithm, but it is faster. For curves of degree n
+ * the complexity of Horner is O(n) and de Casteljau is O(n^2).
+ * Since stability is not important for displaying curve
+ * points I decided to use the Horner scheme.
+ *
+ * A cubic Bezier curve with control points b0, b1, b2, b3 can be
+ * written as
+ *
+ *        (([3]        [3]     )     [3]       )     [3]
+ * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
+ *
+ *                                           [n]
+ * where s=1-t and the binomial coefficients [i]. These can
+ * be computed iteratively using the identity:
+ *
+ * [n]               [n  ]             [n]
+ * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
+ */
+
+
+void
+_math_horner_bezier_curve(const GLfloat * cp, GLfloat * out, GLfloat t,
+			  GLuint dim, GLuint order)
+{
+   GLfloat s, powert, bincoeff;
+   GLuint i, k;
+
+   if (order >= 2) {
+      bincoeff = (GLfloat) (order - 1);
+      s = 1.0F - t;
+
+      for (k = 0; k < dim; k++)
+	 out[k] = s * cp[k] + bincoeff * t * cp[dim + k];
+
+      for (i = 2, cp += 2 * dim, powert = t * t; i < order;
+	   i++, powert *= t, cp += dim) {
+	 bincoeff *= (GLfloat) (order - i);
+	 bincoeff *= inv_tab[i];
+
+	 for (k = 0; k < dim; k++)
+	    out[k] = s * out[k] + bincoeff * powert * cp[k];
+      }
+   }
+   else {			/* order=1 -> constant curve */
+
+      for (k = 0; k < dim; k++)
+	 out[k] = cp[k];
+   }
+}
+
+/*
+ * Tensor product Bezier surfaces
+ *
+ * Again the Horner scheme is used to compute a point on a
+ * TP Bezier surface. First a control polygon for a curve
+ * on the surface in one parameter direction is computed,
+ * then the point on the curve for the other parameter
+ * direction is evaluated.
+ *
+ * To store the curve control polygon additional storage
+ * for max(uorder,vorder) points is needed in the
+ * control net cn.
+ */
+
+void
+_math_horner_bezier_surf(GLfloat * cn, GLfloat * out, GLfloat u, GLfloat v,
+			 GLuint dim, GLuint uorder, GLuint vorder)
+{
+   GLfloat *cp = cn + uorder * vorder * dim;
+   GLuint i, uinc = vorder * dim;
+
+   if (vorder > uorder) {
+      if (uorder >= 2) {
+	 GLfloat s, poweru, bincoeff;
+	 GLuint j, k;
+
+	 /* Compute the control polygon for the surface-curve in u-direction */
+	 for (j = 0; j < vorder; j++) {
+	    GLfloat *ucp = &cn[j * dim];
+
+	    /* Each control point is the point for parameter u on a */
+	    /* curve defined by the control polygons in u-direction */
+	    bincoeff = (GLfloat) (uorder - 1);
+	    s = 1.0F - u;
+
+	    for (k = 0; k < dim; k++)
+	       cp[j * dim + k] = s * ucp[k] + bincoeff * u * ucp[uinc + k];
+
+	    for (i = 2, ucp += 2 * uinc, poweru = u * u; i < uorder;
+		 i++, poweru *= u, ucp += uinc) {
+	       bincoeff *= (GLfloat) (uorder - i);
+	       bincoeff *= inv_tab[i];
+
+	       for (k = 0; k < dim; k++)
+		  cp[j * dim + k] =
+		     s * cp[j * dim + k] + bincoeff * poweru * ucp[k];
+	    }
+	 }
+
+	 /* Evaluate curve point in v */
+	 _math_horner_bezier_curve(cp, out, v, dim, vorder);
+      }
+      else			/* uorder=1 -> cn defines a curve in v */
+	 _math_horner_bezier_curve(cn, out, v, dim, vorder);
+   }
+   else {			/* vorder <= uorder */
+
+      if (vorder > 1) {
+	 GLuint i;
+
+	 /* Compute the control polygon for the surface-curve in u-direction */
+	 for (i = 0; i < uorder; i++, cn += uinc) {
+	    /* For constant i all cn[i][j] (j=0..vorder) are located */
+	    /* on consecutive memory locations, so we can use        */
+	    /* horner_bezier_curve to compute the control points     */
+
+	    _math_horner_bezier_curve(cn, &cp[i * dim], v, dim, vorder);
+	 }
+
+	 /* Evaluate curve point in u */
+	 _math_horner_bezier_curve(cp, out, u, dim, uorder);
+      }
+      else			/* vorder=1 -> cn defines a curve in u */
+	 _math_horner_bezier_curve(cn, out, u, dim, uorder);
+   }
+}
+
+/*
+ * The direct de Casteljau algorithm is used when a point on the
+ * surface and the tangent directions spanning the tangent plane
+ * should be computed (this is needed to compute normals to the
+ * surface). In this case the de Casteljau algorithm approach is
+ * nicer because a point and the partial derivatives can be computed
+ * at the same time. To get the correct tangent length du and dv
+ * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1.
+ * Since only the directions are needed, this scaling step is omitted.
+ *
+ * De Casteljau needs additional storage for uorder*vorder
+ * values in the control net cn.
+ */
+
+void
+_math_de_casteljau_surf(GLfloat * cn, GLfloat * out, GLfloat * du,
+			GLfloat * dv, GLfloat u, GLfloat v, GLuint dim,
+			GLuint uorder, GLuint vorder)
+{
+   GLfloat *dcn = cn + uorder * vorder * dim;
+   GLfloat us = 1.0F - u, vs = 1.0F - v;
+   GLuint h, i, j, k;
+   GLuint minorder = uorder < vorder ? uorder : vorder;
+   GLuint uinc = vorder * dim;
+   GLuint dcuinc = vorder;
+
+   /* Each component is evaluated separately to save buffer space  */
+   /* This does not drasticaly decrease the performance of the     */
+   /* algorithm. If additional storage for (uorder-1)*(vorder-1)   */
+   /* points would be available, the components could be accessed  */
+   /* in the innermost loop which could lead to less cache misses. */
+
+#define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)]
+#define DCN(I, J) dcn[(I)*dcuinc+(J)]
+   if (minorder < 3) {
+      if (uorder == vorder) {
+	 for (k = 0; k < dim; k++) {
+	    /* Derivative direction in u */
+	    du[k] = vs * (CN(1, 0, k) - CN(0, 0, k)) +
+	       v * (CN(1, 1, k) - CN(0, 1, k));
+
+	    /* Derivative direction in v */
+	    dv[k] = us * (CN(0, 1, k) - CN(0, 0, k)) +
+	       u * (CN(1, 1, k) - CN(1, 0, k));
+
+	    /* bilinear de Casteljau step */
+	    out[k] = us * (vs * CN(0, 0, k) + v * CN(0, 1, k)) +
+	       u * (vs * CN(1, 0, k) + v * CN(1, 1, k));
+	 }
+      }
+      else if (minorder == uorder) {
+	 for (k = 0; k < dim; k++) {
+	    /* bilinear de Casteljau step */
+	    DCN(1, 0) = CN(1, 0, k) - CN(0, 0, k);
+	    DCN(0, 0) = us * CN(0, 0, k) + u * CN(1, 0, k);
+
+	    for (j = 0; j < vorder - 1; j++) {
+	       /* for the derivative in u */
+	       DCN(1, j + 1) = CN(1, j + 1, k) - CN(0, j + 1, k);
+	       DCN(1, j) = vs * DCN(1, j) + v * DCN(1, j + 1);
+
+	       /* for the `point' */
+	       DCN(0, j + 1) = us * CN(0, j + 1, k) + u * CN(1, j + 1, k);
+	       DCN(0, j) = vs * DCN(0, j) + v * DCN(0, j + 1);
+	    }
+
+	    /* remaining linear de Casteljau steps until the second last step */
+	    for (h = minorder; h < vorder - 1; h++)
+	       for (j = 0; j < vorder - h; j++) {
+		  /* for the derivative in u */
+		  DCN(1, j) = vs * DCN(1, j) + v * DCN(1, j + 1);
+
+		  /* for the `point' */
+		  DCN(0, j) = vs * DCN(0, j) + v * DCN(0, j + 1);
+	       }
+
+	    /* derivative direction in v */
+	    dv[k] = DCN(0, 1) - DCN(0, 0);
+
+	    /* derivative direction in u */
+	    du[k] = vs * DCN(1, 0) + v * DCN(1, 1);
+
+	    /* last linear de Casteljau step */
+	    out[k] = vs * DCN(0, 0) + v * DCN(0, 1);
+	 }
+      }
+      else {			/* minorder == vorder */
+
+	 for (k = 0; k < dim; k++) {
+	    /* bilinear de Casteljau step */
+	    DCN(0, 1) = CN(0, 1, k) - CN(0, 0, k);
+	    DCN(0, 0) = vs * CN(0, 0, k) + v * CN(0, 1, k);
+	    for (i = 0; i < uorder - 1; i++) {
+	       /* for the derivative in v */
+	       DCN(i + 1, 1) = CN(i + 1, 1, k) - CN(i + 1, 0, k);
+	       DCN(i, 1) = us * DCN(i, 1) + u * DCN(i + 1, 1);
+
+	       /* for the `point' */
+	       DCN(i + 1, 0) = vs * CN(i + 1, 0, k) + v * CN(i + 1, 1, k);
+	       DCN(i, 0) = us * DCN(i, 0) + u * DCN(i + 1, 0);
+	    }
+
+	    /* remaining linear de Casteljau steps until the second last step */
+	    for (h = minorder; h < uorder - 1; h++)
+	       for (i = 0; i < uorder - h; i++) {
+		  /* for the derivative in v */
+		  DCN(i, 1) = us * DCN(i, 1) + u * DCN(i + 1, 1);
+
+		  /* for the `point' */
+		  DCN(i, 0) = us * DCN(i, 0) + u * DCN(i + 1, 0);
+	       }
+
+	    /* derivative direction in u */
+	    du[k] = DCN(1, 0) - DCN(0, 0);
+
+	    /* derivative direction in v */
+	    dv[k] = us * DCN(0, 1) + u * DCN(1, 1);
+
+	    /* last linear de Casteljau step */
+	    out[k] = us * DCN(0, 0) + u * DCN(1, 0);
+	 }
+      }
+   }
+   else if (uorder == vorder) {
+      for (k = 0; k < dim; k++) {
+	 /* first bilinear de Casteljau step */
+	 for (i = 0; i < uorder - 1; i++) {
+	    DCN(i, 0) = us * CN(i, 0, k) + u * CN(i + 1, 0, k);
+	    for (j = 0; j < vorder - 1; j++) {
+	       DCN(i, j + 1) = us * CN(i, j + 1, k) + u * CN(i + 1, j + 1, k);
+	       DCN(i, j) = vs * DCN(i, j) + v * DCN(i, j + 1);
+	    }
+	 }
+
+	 /* remaining bilinear de Casteljau steps until the second last step */
+	 for (h = 2; h < minorder - 1; h++)
+	    for (i = 0; i < uorder - h; i++) {
+	       DCN(i, 0) = us * DCN(i, 0) + u * DCN(i + 1, 0);
+	       for (j = 0; j < vorder - h; j++) {
+		  DCN(i, j + 1) = us * DCN(i, j + 1) + u * DCN(i + 1, j + 1);
+		  DCN(i, j) = vs * DCN(i, j) + v * DCN(i, j + 1);
+	       }
+	    }
+
+	 /* derivative direction in u */
+	 du[k] = vs * (DCN(1, 0) - DCN(0, 0)) + v * (DCN(1, 1) - DCN(0, 1));
+
+	 /* derivative direction in v */
+	 dv[k] = us * (DCN(0, 1) - DCN(0, 0)) + u * (DCN(1, 1) - DCN(1, 0));
+
+	 /* last bilinear de Casteljau step */
+	 out[k] = us * (vs * DCN(0, 0) + v * DCN(0, 1)) +
+	    u * (vs * DCN(1, 0) + v * DCN(1, 1));
+      }
+   }
+   else if (minorder == uorder) {
+      for (k = 0; k < dim; k++) {
+	 /* first bilinear de Casteljau step */
+	 for (i = 0; i < uorder - 1; i++) {
+	    DCN(i, 0) = us * CN(i, 0, k) + u * CN(i + 1, 0, k);
+	    for (j = 0; j < vorder - 1; j++) {
+	       DCN(i, j + 1) = us * CN(i, j + 1, k) + u * CN(i + 1, j + 1, k);
+	       DCN(i, j) = vs * DCN(i, j) + v * DCN(i, j + 1);
+	    }
+	 }
+
+	 /* remaining bilinear de Casteljau steps until the second last step */
+	 for (h = 2; h < minorder - 1; h++)
+	    for (i = 0; i < uorder - h; i++) {
+	       DCN(i, 0) = us * DCN(i, 0) + u * DCN(i + 1, 0);
+	       for (j = 0; j < vorder - h; j++) {
+		  DCN(i, j + 1) = us * DCN(i, j + 1) + u * DCN(i + 1, j + 1);
+		  DCN(i, j) = vs * DCN(i, j) + v * DCN(i, j + 1);
+	       }
+	    }
+
+	 /* last bilinear de Casteljau step */
+	 DCN(2, 0) = DCN(1, 0) - DCN(0, 0);
+	 DCN(0, 0) = us * DCN(0, 0) + u * DCN(1, 0);
+	 for (j = 0; j < vorder - 1; j++) {
+	    /* for the derivative in u */
+	    DCN(2, j + 1) = DCN(1, j + 1) - DCN(0, j + 1);
+	    DCN(2, j) = vs * DCN(2, j) + v * DCN(2, j + 1);
+
+	    /* for the `point' */
+	    DCN(0, j + 1) = us * DCN(0, j + 1) + u * DCN(1, j + 1);
+	    DCN(0, j) = vs * DCN(0, j) + v * DCN(0, j + 1);
+	 }
+
+	 /* remaining linear de Casteljau steps until the second last step */
+	 for (h = minorder; h < vorder - 1; h++)
+	    for (j = 0; j < vorder - h; j++) {
+	       /* for the derivative in u */
+	       DCN(2, j) = vs * DCN(2, j) + v * DCN(2, j + 1);
+
+	       /* for the `point' */
+	       DCN(0, j) = vs * DCN(0, j) + v * DCN(0, j + 1);
+	    }
+
+	 /* derivative direction in v */
+	 dv[k] = DCN(0, 1) - DCN(0, 0);
+
+	 /* derivative direction in u */
+	 du[k] = vs * DCN(2, 0) + v * DCN(2, 1);
+
+	 /* last linear de Casteljau step */
+	 out[k] = vs * DCN(0, 0) + v * DCN(0, 1);
+      }
+   }
+   else {			/* minorder == vorder */
+
+      for (k = 0; k < dim; k++) {
+	 /* first bilinear de Casteljau step */
+	 for (i = 0; i < uorder - 1; i++) {
+	    DCN(i, 0) = us * CN(i, 0, k) + u * CN(i + 1, 0, k);
+	    for (j = 0; j < vorder - 1; j++) {
+	       DCN(i, j + 1) = us * CN(i, j + 1, k) + u * CN(i + 1, j + 1, k);
+	       DCN(i, j) = vs * DCN(i, j) + v * DCN(i, j + 1);
+	    }
+	 }
+
+	 /* remaining bilinear de Casteljau steps until the second last step */
+	 for (h = 2; h < minorder - 1; h++)
+	    for (i = 0; i < uorder - h; i++) {
+	       DCN(i, 0) = us * DCN(i, 0) + u * DCN(i + 1, 0);
+	       for (j = 0; j < vorder - h; j++) {
+		  DCN(i, j + 1) = us * DCN(i, j + 1) + u * DCN(i + 1, j + 1);
+		  DCN(i, j) = vs * DCN(i, j) + v * DCN(i, j + 1);
+	       }
+	    }
+
+	 /* last bilinear de Casteljau step */
+	 DCN(0, 2) = DCN(0, 1) - DCN(0, 0);
+	 DCN(0, 0) = vs * DCN(0, 0) + v * DCN(0, 1);
+	 for (i = 0; i < uorder - 1; i++) {
+	    /* for the derivative in v */
+	    DCN(i + 1, 2) = DCN(i + 1, 1) - DCN(i + 1, 0);
+	    DCN(i, 2) = us * DCN(i, 2) + u * DCN(i + 1, 2);
+
+	    /* for the `point' */
+	    DCN(i + 1, 0) = vs * DCN(i + 1, 0) + v * DCN(i + 1, 1);
+	    DCN(i, 0) = us * DCN(i, 0) + u * DCN(i + 1, 0);
+	 }
+
+	 /* remaining linear de Casteljau steps until the second last step */
+	 for (h = minorder; h < uorder - 1; h++)
+	    for (i = 0; i < uorder - h; i++) {
+	       /* for the derivative in v */
+	       DCN(i, 2) = us * DCN(i, 2) + u * DCN(i + 1, 2);
+
+	       /* for the `point' */
+	       DCN(i, 0) = us * DCN(i, 0) + u * DCN(i + 1, 0);
+	    }
+
+	 /* derivative direction in u */
+	 du[k] = DCN(1, 0) - DCN(0, 0);
+
+	 /* derivative direction in v */
+	 dv[k] = us * DCN(0, 2) + u * DCN(1, 2);
+
+	 /* last linear de Casteljau step */
+	 out[k] = us * DCN(0, 0) + u * DCN(1, 0);
+      }
+   }
+#undef DCN
+#undef CN
+}
+
+
+/*
+ * Do one-time initialization for evaluators.
+ */
+void
+_math_init_eval(void)
+{
+   GLuint i;
+
+   /* KW: precompute 1/x for useful x.
+    */
+   for (i = 1; i < MAX_EVAL_ORDER; i++)
+      inv_tab[i] = 1.0F / i;
+}
Index: xc/extras/Mesa/src/math/m_eval.h
diff -u /dev/null xc/extras/Mesa/src/math/m_eval.h:1.2
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_eval.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,103 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef _M_EVAL_H
+#define _M_EVAL_H
+
+#include "glheader.h"
+
+void _math_init_eval( void );
+
+
+/*
+ * Horner scheme for Bezier curves
+ *
+ * Bezier curves can be computed via a Horner scheme.
+ * Horner is numerically less stable than the de Casteljau
+ * algorithm, but it is faster. For curves of degree n
+ * the complexity of Horner is O(n) and de Casteljau is O(n^2).
+ * Since stability is not important for displaying curve
+ * points I decided to use the Horner scheme.
+ *
+ * A cubic Bezier curve with control points b0, b1, b2, b3 can be
+ * written as
+ *
+ *        (([3]        [3]     )     [3]       )     [3]
+ * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
+ *
+ *                                           [n]
+ * where s=1-t and the binomial coefficients [i]. These can
+ * be computed iteratively using the identity:
+ *
+ * [n]               [n  ]             [n]
+ * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
+ */
+
+
+void
+_math_horner_bezier_curve(const GLfloat *cp, GLfloat *out, GLfloat t,
+			  GLuint dim, GLuint order);
+
+
+/*
+ * Tensor product Bezier surfaces
+ *
+ * Again the Horner scheme is used to compute a point on a
+ * TP Bezier surface. First a control polygon for a curve
+ * on the surface in one parameter direction is computed,
+ * then the point on the curve for the other parameter
+ * direction is evaluated.
+ *
+ * To store the curve control polygon additional storage
+ * for max(uorder,vorder) points is needed in the
+ * control net cn.
+ */
+
+void
+_math_horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
+			 GLuint dim, GLuint uorder, GLuint vorder);
+
+
+/*
+ * The direct de Casteljau algorithm is used when a point on the
+ * surface and the tangent directions spanning the tangent plane
+ * should be computed (this is needed to compute normals to the
+ * surface). In this case the de Casteljau algorithm approach is
+ * nicer because a point and the partial derivatives can be computed
+ * at the same time. To get the correct tangent length du and dv
+ * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1.
+ * Since only the directions are needed, this scaling step is omitted.
+ *
+ * De Casteljau needs additional storage for uorder*vorder
+ * values in the control net cn.
+ */
+
+void
+_math_de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
+			GLfloat u, GLfloat v, GLuint dim,
+			GLuint uorder, GLuint vorder);
+
+
+#endif
Index: xc/extras/Mesa/src/math/m_matrix.c
diff -u /dev/null xc/extras/Mesa/src/math/m_matrix.c:1.3
--- /dev/null	Thu Feb 27 12:15:58 2003
+++ xc/extras/Mesa/src/math/m_matrix.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,1123 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/math/m_matrix.c,v 1.3 2002/12/16 16:18:36 dawes Exp $ */
+
+
+/*
+ * Matrix operations
+ *
+ * NOTES:
+ * 1. 4x4 transformation matrices are stored in memory in column major order.
+ * 2. Points/vertices are to be thought of as column vectors.
+ * 3. Transformation of a point p by a matrix M is: p' = M * p
+ */
+
+#include <math.h>
+
+#include "glheader.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+
+#include "m_matrix.h"
+
+
+static const char *types[] = {
+   "MATRIX_GENERAL",
+   "MATRIX_IDENTITY",
+   "MATRIX_3D_NO_ROT",
+   "MATRIX_PERSPECTIVE",
+   "MATRIX_2D",
+   "MATRIX_2D_NO_ROT",
+   "MATRIX_3D"
+};
+
+
+static GLfloat Identity[16] = {
+   1.0, 0.0, 0.0, 0.0,
+   0.0, 1.0, 0.0, 0.0,
+   0.0, 0.0, 1.0, 0.0,
+   0.0, 0.0, 0.0, 1.0
+};
+
+
+
+
+/*
+ * This matmul was contributed by Thomas Malik
+ *
+ * Perform a 4x4 matrix multiplication  (product = a x b).
+ * Input:  a, b - matrices to multiply
+ * Output:  product - product of a and b
+ * WARNING: (product != b) assumed
+ * NOTE:    (product == a) allowed
+ *
+ * KW: 4*16 = 64 muls
+ */
+#define A(row,col)  a[(col<<2)+row]
+#define B(row,col)  b[(col<<2)+row]
+#define P(row,col)  product[(col<<2)+row]
+
+static void matmul4( GLfloat *product, const GLfloat *a, const GLfloat *b )
+{
+   GLint i;
+   for (i = 0; i < 4; i++) {
+      const GLfloat ai0=A(i,0),  ai1=A(i,1),  ai2=A(i,2),  ai3=A(i,3);
+      P(i,0) = ai0 * B(0,0) + ai1 * B(1,0) + ai2 * B(2,0) + ai3 * B(3,0);
+      P(i,1) = ai0 * B(0,1) + ai1 * B(1,1) + ai2 * B(2,1) + ai3 * B(3,1);
+      P(i,2) = ai0 * B(0,2) + ai1 * B(1,2) + ai2 * B(2,2) + ai3 * B(3,2);
+      P(i,3) = ai0 * B(0,3) + ai1 * B(1,3) + ai2 * B(2,3) + ai3 * B(3,3);
+   }
+}
+
+
+/* Multiply two matrices known to occupy only the top three rows, such
+ * as typical model matrices, and ortho matrices.
+ */
+static void matmul34( GLfloat *product, const GLfloat *a, const GLfloat *b )
+{
+   GLint i;
+   for (i = 0; i < 3; i++) {
+      const GLfloat ai0=A(i,0),  ai1=A(i,1),  ai2=A(i,2),  ai3=A(i,3);
+      P(i,0) = ai0 * B(0,0) + ai1 * B(1,0) + ai2 * B(2,0);
+      P(i,1) = ai0 * B(0,1) + ai1 * B(1,1) + ai2 * B(2,1);
+      P(i,2) = ai0 * B(0,2) + ai1 * B(1,2) + ai2 * B(2,2);
+      P(i,3) = ai0 * B(0,3) + ai1 * B(1,3) + ai2 * B(2,3) + ai3;
+   }
+   P(3,0) = 0;
+   P(3,1) = 0;
+   P(3,2) = 0;
+   P(3,3) = 1;
+}
+
+
+#undef A
+#undef B
+#undef P
+
+
+/*
+ * Multiply a matrix by an array of floats with known properties.
+ */
+static void matrix_multf( GLmatrix *mat, const GLfloat *m, GLuint flags )
+{
+   mat->flags |= (flags | MAT_DIRTY_TYPE | MAT_DIRTY_INVERSE);
+
+   if (TEST_MAT_FLAGS(mat, MAT_FLAGS_3D))
+      matmul34( mat->m, mat->m, m );
+   else
+      matmul4( mat->m, mat->m, m );
+}
+
+
+static void print_matrix_floats( const GLfloat m[16] )
+{
+   int i;
+   for (i=0;i<4;i++) {
+      fprintf(stderr,"\t%f %f %f %f\n", m[i], m[4+i], m[8+i], m[12+i] );
+   }
+}
+
+void
+_math_matrix_print( const GLmatrix *m )
+{
+   fprintf(stderr, "Matrix type: %s, flags: %x\n", types[m->type], m->flags);
+   print_matrix_floats(m->m);
+   fprintf(stderr, "Inverse: \n");
+   if (m->inv) {
+      GLfloat prod[16];
+      print_matrix_floats(m->inv);
+      matmul4(prod, m->m, m->inv);
+      fprintf(stderr, "Mat * Inverse:\n");
+      print_matrix_floats(prod);
+   }
+   else {
+      fprintf(stderr, "  - not available\n");
+   }
+}
+
+
+
+
+#define SWAP_ROWS(a, b) { GLfloat *_tmp = a; (a)=(b); (b)=_tmp; }
+#define MAT(m,r,c) (m)[(c)*4+(r)]
+
+/*
+ * Compute inverse of 4x4 transformation matrix.
+ * Code contributed by Jacques Leroy jle@star.be
+ * Return GL_TRUE for success, GL_FALSE for failure (singular matrix)
+ */
+static GLboolean invert_matrix_general( GLmatrix *mat )
+{
+   const GLfloat *m = mat->m;
+   GLfloat *out = mat->inv;
+   GLfloat wtmp[4][8];
+   GLfloat m0, m1, m2, m3, s;
+   GLfloat *r0, *r1, *r2, *r3;
+
+   r0 = wtmp[0], r1 = wtmp[1], r2 = wtmp[2], r3 = wtmp[3];
+
+   r0[0] = MAT(m,0,0), r0[1] = MAT(m,0,1),
+   r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
+   r0[4] = 1.0, r0[5] = r0[6] = r0[7] = 0.0,
+
+   r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
+   r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
+   r1[5] = 1.0, r1[4] = r1[6] = r1[7] = 0.0,
+
+   r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
+   r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
+   r2[6] = 1.0, r2[4] = r2[5] = r2[7] = 0.0,
+
+   r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
+   r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
+   r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
+
+   /* choose pivot - or die */
+   if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
+   if (fabs(r2[0])>fabs(r1[0])) SWAP_ROWS(r2, r1);
+   if (fabs(r1[0])>fabs(r0[0])) SWAP_ROWS(r1, r0);
+   if (0.0 == r0[0])  return GL_FALSE;
+
+   /* eliminate first variable     */
+   m1 = r1[0]/r0[0]; m2 = r2[0]/r0[0]; m3 = r3[0]/r0[0];
+   s = r0[1]; r1[1] -= m1 * s; r2[1] -= m2 * s; r3[1] -= m3 * s;
+   s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
+   s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
+   s = r0[4];
+   if (s != 0.0) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
+   s = r0[5];
+   if (s != 0.0) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
+   s = r0[6];
+   if (s != 0.0) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
+   s = r0[7];
+   if (s != 0.0) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
+
+   /* choose pivot - or die */
+   if (fabs(r3[1])>fabs(r2[1])) SWAP_ROWS(r3, r2);
+   if (fabs(r2[1])>fabs(r1[1])) SWAP_ROWS(r2, r1);
+   if (0.0 == r1[1])  return GL_FALSE;
+
+   /* eliminate second variable */
+   m2 = r2[1]/r1[1]; m3 = r3[1]/r1[1];
+   r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
+   r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
+   s = r1[4]; if (0.0 != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
+   s = r1[5]; if (0.0 != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
+   s = r1[6]; if (0.0 != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
+   s = r1[7]; if (0.0 != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
+
+   /* choose pivot - or die */
+   if (fabs(r3[2])>fabs(r2[2])) SWAP_ROWS(r3, r2);
+   if (0.0 == r2[2])  return GL_FALSE;
+
+   /* eliminate third variable */
+   m3 = r3[2]/r2[2];
+   r3[3] -= m3 * r2[3], r3[4] -= m3 * r2[4],
+   r3[5] -= m3 * r2[5], r3[6] -= m3 * r2[6],
+   r3[7] -= m3 * r2[7];
+
+   /* last check */
+   if (0.0 == r3[3]) return GL_FALSE;
+
+   s = 1.0F/r3[3];             /* now back substitute row 3 */
+   r3[4] *= s; r3[5] *= s; r3[6] *= s; r3[7] *= s;
+
+   m2 = r2[3];                 /* now back substitute row 2 */
+   s  = 1.0F/r2[2];
+   r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
+   r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
+   m1 = r1[3];
+   r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1,
+   r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
+   m0 = r0[3];
+   r0[4] -= r3[4] * m0, r0[5] -= r3[5] * m0,
+   r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
+
+   m1 = r1[2];                 /* now back substitute row 1 */
+   s  = 1.0F/r1[1];
+   r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
+   r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
+   m0 = r0[2];
+   r0[4] -= r2[4] * m0, r0[5] -= r2[5] * m0,
+   r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
+
+   m0 = r0[1];                 /* now back substitute row 0 */
+   s  = 1.0F/r0[0];
+   r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
+   r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
+
+   MAT(out,0,0) = r0[4]; MAT(out,0,1) = r0[5],
+   MAT(out,0,2) = r0[6]; MAT(out,0,3) = r0[7],
+   MAT(out,1,0) = r1[4]; MAT(out,1,1) = r1[5],
+   MAT(out,1,2) = r1[6]; MAT(out,1,3) = r1[7],
+   MAT(out,2,0) = r2[4]; MAT(out,2,1) = r2[5],
+   MAT(out,2,2) = r2[6]; MAT(out,2,3) = r2[7],
+   MAT(out,3,0) = r3[4]; MAT(out,3,1) = r3[5],
+   MAT(out,3,2) = r3[6]; MAT(out,3,3) = r3[7];
+
+   return GL_TRUE;
+}
+#undef SWAP_ROWS
+
+
+/* Adapted from graphics gems II.
+ */
+static GLboolean invert_matrix_3d_general( GLmatrix *mat )
+{
+   const GLfloat *in = mat->m;
+   GLfloat *out = mat->inv;
+   GLfloat pos, neg, t;
+   GLfloat det;
+
+   /* Calculate the determinant of upper left 3x3 submatrix and
+    * determine if the matrix is singular.
+    */
+   pos = neg = 0.0;
+   t =  MAT(in,0,0) * MAT(in,1,1) * MAT(in,2,2);
+   if (t >= 0.0) pos += t; else neg += t;
+
+   t =  MAT(in,1,0) * MAT(in,2,1) * MAT(in,0,2);
+   if (t >= 0.0) pos += t; else neg += t;
+
+   t =  MAT(in,2,0) * MAT(in,0,1) * MAT(in,1,2);
+   if (t >= 0.0) pos += t; else neg += t;
+
+   t = -MAT(in,2,0) * MAT(in,1,1) * MAT(in,0,2);
+   if (t >= 0.0) pos += t; else neg += t;
+
+   t = -MAT(in,1,0) * MAT(in,0,1) * MAT(in,2,2);
+   if (t >= 0.0) pos += t; else neg += t;
+
+   t = -MAT(in,0,0) * MAT(in,2,1) * MAT(in,1,2);
+   if (t >= 0.0) pos += t; else neg += t;
+
+   det = pos + neg;
+
+   if (det*det < 1e-25)
+      return GL_FALSE;
+
+   det = 1.0F / det;
+   MAT(out,0,0) = (  (MAT(in,1,1)*MAT(in,2,2) - MAT(in,2,1)*MAT(in,1,2) )*det);
+   MAT(out,0,1) = (- (MAT(in,0,1)*MAT(in,2,2) - MAT(in,2,1)*MAT(in,0,2) )*det);
+   MAT(out,0,2) = (  (MAT(in,0,1)*MAT(in,1,2) - MAT(in,1,1)*MAT(in,0,2) )*det);
+   MAT(out,1,0) = (- (MAT(in,1,0)*MAT(in,2,2) - MAT(in,2,0)*MAT(in,1,2) )*det);
+   MAT(out,1,1) = (  (MAT(in,0,0)*MAT(in,2,2) - MAT(in,2,0)*MAT(in,0,2) )*det);
+   MAT(out,1,2) = (- (MAT(in,0,0)*MAT(in,1,2) - MAT(in,1,0)*MAT(in,0,2) )*det);
+   MAT(out,2,0) = (  (MAT(in,1,0)*MAT(in,2,1) - MAT(in,2,0)*MAT(in,1,1) )*det);
+   MAT(out,2,1) = (- (MAT(in,0,0)*MAT(in,2,1) - MAT(in,2,0)*MAT(in,0,1) )*det);
+   MAT(out,2,2) = (  (MAT(in,0,0)*MAT(in,1,1) - MAT(in,1,0)*MAT(in,0,1) )*det);
+
+   /* Do the translation part */
+   MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0) +
+		     MAT(in,1,3) * MAT(out,0,1) +
+		     MAT(in,2,3) * MAT(out,0,2) );
+   MAT(out,1,3) = - (MAT(in,0,3) * MAT(out,1,0) +
+		     MAT(in,1,3) * MAT(out,1,1) +
+		     MAT(in,2,3) * MAT(out,1,2) );
+   MAT(out,2,3) = - (MAT(in,0,3) * MAT(out,2,0) +
+		     MAT(in,1,3) * MAT(out,2,1) +
+		     MAT(in,2,3) * MAT(out,2,2) );
+
+   return GL_TRUE;
+}
+
+
+static GLboolean invert_matrix_3d( GLmatrix *mat )
+{
+   const GLfloat *in = mat->m;
+   GLfloat *out = mat->inv;
+
+   if (!TEST_MAT_FLAGS(mat, MAT_FLAGS_ANGLE_PRESERVING)) {
+      return invert_matrix_3d_general( mat );
+   }
+
+   if (mat->flags & MAT_FLAG_UNIFORM_SCALE) {
+      GLfloat scale = (MAT(in,0,0) * MAT(in,0,0) +
+                       MAT(in,0,1) * MAT(in,0,1) +
+                       MAT(in,0,2) * MAT(in,0,2));
+
+      if (scale == 0.0)
+         return GL_FALSE;
+
+      scale = 1.0F / scale;
+
+      /* Transpose and scale the 3 by 3 upper-left submatrix. */
+      MAT(out,0,0) = scale * MAT(in,0,0);
+      MAT(out,1,0) = scale * MAT(in,0,1);
+      MAT(out,2,0) = scale * MAT(in,0,2);
+      MAT(out,0,1) = scale * MAT(in,1,0);
+      MAT(out,1,1) = scale * MAT(in,1,1);
+      MAT(out,2,1) = scale * MAT(in,1,2);
+      MAT(out,0,2) = scale * MAT(in,2,0);
+      MAT(out,1,2) = scale * MAT(in,2,1);
+      MAT(out,2,2) = scale * MAT(in,2,2);
+   }
+   else if (mat->flags & MAT_FLAG_ROTATION) {
+      /* Transpose the 3 by 3 upper-left submatrix. */
+      MAT(out,0,0) = MAT(in,0,0);
+      MAT(out,1,0) = MAT(in,0,1);
+      MAT(out,2,0) = MAT(in,0,2);
+      MAT(out,0,1) = MAT(in,1,0);
+      MAT(out,1,1) = MAT(in,1,1);
+      MAT(out,2,1) = MAT(in,1,2);
+      MAT(out,0,2) = MAT(in,2,0);
+      MAT(out,1,2) = MAT(in,2,1);
+      MAT(out,2,2) = MAT(in,2,2);
+   }
+   else {
+      /* pure translation */
+      MEMCPY( out, Identity, sizeof(Identity) );
+      MAT(out,0,3) = - MAT(in,0,3);
+      MAT(out,1,3) = - MAT(in,1,3);
+      MAT(out,2,3) = - MAT(in,2,3);
+      return GL_TRUE;
+   }
+
+   if (mat->flags & MAT_FLAG_TRANSLATION) {
+      /* Do the translation part */
+      MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0) +
+			MAT(in,1,3) * MAT(out,0,1) +
+			MAT(in,2,3) * MAT(out,0,2) );
+      MAT(out,1,3) = - (MAT(in,0,3) * MAT(out,1,0) +
+			MAT(in,1,3) * MAT(out,1,1) +
+			MAT(in,2,3) * MAT(out,1,2) );
+      MAT(out,2,3) = - (MAT(in,0,3) * MAT(out,2,0) +
+			MAT(in,1,3) * MAT(out,2,1) +
+			MAT(in,2,3) * MAT(out,2,2) );
+   }
+   else {
+      MAT(out,0,3) = MAT(out,1,3) = MAT(out,2,3) = 0.0;
+   }
+
+   return GL_TRUE;
+}
+
+
+
+static GLboolean invert_matrix_identity( GLmatrix *mat )
+{
+   MEMCPY( mat->inv, Identity, sizeof(Identity) );
+   return GL_TRUE;
+}
+
+
+static GLboolean invert_matrix_3d_no_rot( GLmatrix *mat )
+{
+   const GLfloat *in = mat->m;
+   GLfloat *out = mat->inv;
+
+   if (MAT(in,0,0) == 0 || MAT(in,1,1) == 0 || MAT(in,2,2) == 0 )
+      return GL_FALSE;
+
+   MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
+   MAT(out,0,0) = 1.0F / MAT(in,0,0);
+   MAT(out,1,1) = 1.0F / MAT(in,1,1);
+   MAT(out,2,2) = 1.0F / MAT(in,2,2);
+
+   if (mat->flags & MAT_FLAG_TRANSLATION) {
+      MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0));
+      MAT(out,1,3) = - (MAT(in,1,3) * MAT(out,1,1));
+      MAT(out,2,3) = - (MAT(in,2,3) * MAT(out,2,2));
+   }
+
+   return GL_TRUE;
+}
+
+
+static GLboolean invert_matrix_2d_no_rot( GLmatrix *mat )
+{
+   const GLfloat *in = mat->m;
+   GLfloat *out = mat->inv;
+
+   if (MAT(in,0,0) == 0 || MAT(in,1,1) == 0)
+      return GL_FALSE;
+
+   MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
+   MAT(out,0,0) = 1.0F / MAT(in,0,0);
+   MAT(out,1,1) = 1.0F / MAT(in,1,1);
+
+   if (mat->flags & MAT_FLAG_TRANSLATION) {
+      MAT(out,0,3) = - (MAT(in,0,3) * MAT(out,0,0));
+      MAT(out,1,3) = - (MAT(in,1,3) * MAT(out,1,1));
+   }
+
+   return GL_TRUE;
+}
+
+
+#if 0
+static GLboolean invert_matrix_perspective( GLmatrix *mat )
+{
+   const GLfloat *in = mat->m;
+   GLfloat *out = mat->inv;
+
+   if (MAT(in,2,3) == 0)
+      return GL_FALSE;
+
+   MEMCPY( out, Identity, 16 * sizeof(GLfloat) );
+
+   MAT(out,0,0) = 1.0F / MAT(in,0,0);
+   MAT(out,1,1) = 1.0F / MAT(in,1,1);
+
+   MAT(out,0,3) = MAT(in,0,2);
+   MAT(out,1,3) = MAT(in,1,2);
+
+   MAT(out,2,2) = 0;
+   MAT(out,2,3) = -1;
+
+   MAT(out,3,2) = 1.0F / MAT(in,2,3);
+   MAT(out,3,3) = MAT(in,2,2) * MAT(out,3,2);
+
+   return GL_TRUE;
+}
+#endif
+
+
+typedef GLboolean (*inv_mat_func)( GLmatrix *mat );
+
+
+static inv_mat_func inv_mat_tab[7] = {
+   invert_matrix_general,
+   invert_matrix_identity,
+   invert_matrix_3d_no_rot,
+#if 0
+   /* Don't use this function for now - it fails when the projection matrix
+    * is premultiplied by a translation (ala Chromium's tilesort SPU).
+    */
+   invert_matrix_perspective,
+#else
+   invert_matrix_general,
+#endif
+   invert_matrix_3d,		/* lazy! */
+   invert_matrix_2d_no_rot,
+   invert_matrix_3d
+};
+
+
+static GLboolean matrix_invert( GLmatrix *mat )
+{
+   if (inv_mat_tab[mat->type](mat)) {
+      mat->flags &= ~MAT_FLAG_SINGULAR;
+      return GL_TRUE;
+   } else {
+      mat->flags |= MAT_FLAG_SINGULAR;
+      MEMCPY( mat->inv, Identity, sizeof(Identity) );
+      return GL_FALSE;
+   }
+}
+
+
+
+
+
+
+/*
+ * Generate a 4x4 transformation matrix from glRotate parameters, and
+ * postmultiply the input matrix by it.
+ */
+void
+_math_matrix_rotate( GLmatrix *mat,
+		     GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
+{
+   /* This function contributed by Erich Boleyn (erich@uruk.org) */
+   GLfloat mag, s, c;
+   GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
+   GLfloat m[16];
+
+   s = (GLfloat) sin( angle * DEG2RAD );
+   c = (GLfloat) cos( angle * DEG2RAD );
+
+   mag = (GLfloat) GL_SQRT( x*x + y*y + z*z );
+
+   if (mag <= 1.0e-4) {
+      /* generate an identity matrix and return */
+      MEMCPY(m, Identity, sizeof(GLfloat)*16);
+      return;
+   }
+
+   x /= mag;
+   y /= mag;
+   z /= mag;
+
+#define M(row,col)  m[col*4+row]
+
+   /*
+    *     Arbitrary axis rotation matrix.
+    *
+    *  This is composed of 5 matrices, Rz, Ry, T, Ry', Rz', multiplied
+    *  like so:  Rz * Ry * T * Ry' * Rz'.  T is the final rotation
+    *  (which is about the X-axis), and the two composite transforms
+    *  Ry' * Rz' and Rz * Ry are (respectively) the rotations necessary
+    *  from the arbitrary axis to the X-axis then back.  They are
+    *  all elementary rotations.
+    *
+    *  Rz' is a rotation about the Z-axis, to bring the axis vector
+    *  into the x-z plane.  Then Ry' is applied, rotating about the
+    *  Y-axis to bring the axis vector parallel with the X-axis.  The
+    *  rotation about the X-axis is then performed.  Ry and Rz are
+    *  simply the respective inverse transforms to bring the arbitrary
+    *  axis back to it's original orientation.  The first transforms
+    *  Rz' and Ry' are considered inverses, since the data from the
+    *  arbitrary axis gives you info on how to get to it, not how
+    *  to get away from it, and an inverse must be applied.
+    *
+    *  The basic calculation used is to recognize that the arbitrary
+    *  axis vector (x, y, z), since it is of unit length, actually
+    *  represents the sines and cosines of the angles to rotate the
+    *  X-axis to the same orientation, with theta being the angle about
+    *  Z and phi the angle about Y (in the order described above)
+    *  as follows:
+    *
+    *  cos ( theta ) = x / sqrt ( 1 - z^2 )
+    *  sin ( theta ) = y / sqrt ( 1 - z^2 )
+    *
+    *  cos ( phi ) = sqrt ( 1 - z^2 )
+    *  sin ( phi ) = z
+    *
+    *  Note that cos ( phi ) can further be inserted to the above
+    *  formulas:
+    *
+    *  cos ( theta ) = x / cos ( phi )
+    *  sin ( theta ) = y / sin ( phi )
+    *
+    *  ...etc.  Because of those relations and the standard trigonometric
+    *  relations, it is pssible to reduce the transforms down to what
+    *  is used below.  It may be that any primary axis chosen will give the
+    *  same results (modulo a sign convention) using thie method.
+    *
+    *  Particularly nice is to notice that all divisions that might
+    *  have caused trouble when parallel to certain planes or
+    *  axis go away with care paid to reducing the expressions.
+    *  After checking, it does perform correctly under all cases, since
+    *  in all the cases of division where the denominator would have
+    *  been zero, the numerator would have been zero as well, giving
+    *  the expected result.
+    */
+
+   xx = x * x;
+   yy = y * y;
+   zz = z * z;
+   xy = x * y;
+   yz = y * z;
+   zx = z * x;
+   xs = x * s;
+   ys = y * s;
+   zs = z * s;
+   one_c = 1.0F - c;
+
+   M(0,0) = (one_c * xx) + c;
+   M(0,1) = (one_c * xy) - zs;
+   M(0,2) = (one_c * zx) + ys;
+   M(0,3) = 0.0F;
+
+   M(1,0) = (one_c * xy) + zs;
+   M(1,1) = (one_c * yy) + c;
+   M(1,2) = (one_c * yz) - xs;
+   M(1,3) = 0.0F;
+
+   M(2,0) = (one_c * zx) - ys;
+   M(2,1) = (one_c * yz) + xs;
+   M(2,2) = (one_c * zz) + c;
+   M(2,3) = 0.0F;
+
+   M(3,0) = 0.0F;
+   M(3,1) = 0.0F;
+   M(3,2) = 0.0F;
+   M(3,3) = 1.0F;
+
+#undef M
+
+   matrix_multf( mat, m, MAT_FLAG_ROTATION );
+}
+
+
+void
+_math_matrix_frustum( GLmatrix *mat,
+		      GLfloat left, GLfloat right,
+		      GLfloat bottom, GLfloat top,
+		      GLfloat nearval, GLfloat farval )
+{
+   GLfloat x, y, a, b, c, d;
+   GLfloat m[16];
+
+   x = (2.0F*nearval) / (right-left);
+   y = (2.0F*nearval) / (top-bottom);
+   a = (right+left) / (right-left);
+   b = (top+bottom) / (top-bottom);
+   c = -(farval+nearval) / ( farval-nearval);
+   d = -(2.0F*farval*nearval) / (farval-nearval);  /* error? */
+
+#define M(row,col)  m[col*4+row]
+   M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = a;      M(0,3) = 0.0F;
+   M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = b;      M(1,3) = 0.0F;
+   M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = c;      M(2,3) = d;
+   M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = -1.0F;  M(3,3) = 0.0F;
+#undef M
+
+   matrix_multf( mat, m, MAT_FLAG_PERSPECTIVE );
+}
+
+void
+_math_matrix_ortho( GLmatrix *mat,
+		    GLfloat left, GLfloat right,
+		    GLfloat bottom, GLfloat top,
+		    GLfloat nearval, GLfloat farval )
+{
+   GLfloat x, y, z;
+   GLfloat tx, ty, tz;
+   GLfloat m[16];
+
+   x = 2.0F / (right-left);
+   y = 2.0F / (top-bottom);
+   z = -2.0F / (farval-nearval);
+   tx = -(right+left) / (right-left);
+   ty = -(top+bottom) / (top-bottom);
+   tz = -(farval+nearval) / (farval-nearval);
+
+#define M(row,col)  m[col*4+row]
+   M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = 0.0F;  M(0,3) = tx;
+   M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = 0.0F;  M(1,3) = ty;
+   M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = z;     M(2,3) = tz;
+   M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = 0.0F;  M(3,3) = 1.0F;
+#undef M
+
+   matrix_multf( mat, m, (MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION));
+}
+
+
+#define ZERO(x) (1<<x)
+#define ONE(x)  (1<<(x+16))
+
+#define MASK_NO_TRX      (ZERO(12) | ZERO(13) | ZERO(14))
+#define MASK_NO_2D_SCALE ( ONE(0)  | ONE(5))
+
+#define MASK_IDENTITY    ( ONE(0)  | ZERO(4)  | ZERO(8)  | ZERO(12) |\
+			  ZERO(1)  |  ONE(5)  | ZERO(9)  | ZERO(13) |\
+			  ZERO(2)  | ZERO(6)  |  ONE(10) | ZERO(14) |\
+			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
+
+#define MASK_2D_NO_ROT   (           ZERO(4)  | ZERO(8)  |           \
+			  ZERO(1)  |            ZERO(9)  |           \
+			  ZERO(2)  | ZERO(6)  |  ONE(10) | ZERO(14) |\
+			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
+
+#define MASK_2D          (                      ZERO(8)  |           \
+			                        ZERO(9)  |           \
+			  ZERO(2)  | ZERO(6)  |  ONE(10) | ZERO(14) |\
+			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
+
+
+#define MASK_3D_NO_ROT   (           ZERO(4)  | ZERO(8)  |           \
+			  ZERO(1)  |            ZERO(9)  |           \
+			  ZERO(2)  | ZERO(6)  |                      \
+			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
+
+#define MASK_3D          (                                           \
+			                                             \
+			                                             \
+			  ZERO(3)  | ZERO(7)  | ZERO(11) |  ONE(15) )
+
+
+#define MASK_PERSPECTIVE (           ZERO(4)  |            ZERO(12) |\
+			  ZERO(1)  |                       ZERO(13) |\
+			  ZERO(2)  | ZERO(6)  |                      \
+			  ZERO(3)  | ZERO(7)  |            ZERO(15) )
+
+#define SQ(x) ((x)*(x))
+
+/* Determine type and flags from scratch.  This is expensive enough to
+ * only want to do it once.
+ */
+static void analyse_from_scratch( GLmatrix *mat )
+{
+   const GLfloat *m = mat->m;
+   GLuint mask = 0;
+   GLuint i;
+
+   for (i = 0 ; i < 16 ; i++) {
+      if (m[i] == 0.0) mask |= (1<<i);
+   }
+
+   if (m[0] == 1.0F) mask |= (1<<16);
+   if (m[5] == 1.0F) mask |= (1<<21);
+   if (m[10] == 1.0F) mask |= (1<<26);
+   if (m[15] == 1.0F) mask |= (1<<31);
+
+   mat->flags &= ~MAT_FLAGS_GEOMETRY;
+
+   /* Check for translation - no-one really cares
+    */
+   if ((mask & MASK_NO_TRX) != MASK_NO_TRX)
+      mat->flags |= MAT_FLAG_TRANSLATION;
+
+   /* Do the real work
+    */
+   if (mask == (GLuint) MASK_IDENTITY) {
+      mat->type = MATRIX_IDENTITY;
+   }
+   else if ((mask & MASK_2D_NO_ROT) == (GLuint) MASK_2D_NO_ROT) {
+      mat->type = MATRIX_2D_NO_ROT;
+
+      if ((mask & MASK_NO_2D_SCALE) != MASK_NO_2D_SCALE)
+	 mat->flags = MAT_FLAG_GENERAL_SCALE;
+   }
+   else if ((mask & MASK_2D) == (GLuint) MASK_2D) {
+      GLfloat mm = DOT2(m, m);
+      GLfloat m4m4 = DOT2(m+4,m+4);
+      GLfloat mm4 = DOT2(m,m+4);
+
+      mat->type = MATRIX_2D;
+
+      /* Check for scale */
+      if (SQ(mm-1) > SQ(1e-6) ||
+	  SQ(m4m4-1) > SQ(1e-6))
+	 mat->flags |= MAT_FLAG_GENERAL_SCALE;
+
+      /* Check for rotation */
+      if (SQ(mm4) > SQ(1e-6))
+	 mat->flags |= MAT_FLAG_GENERAL_3D;
+      else
+	 mat->flags |= MAT_FLAG_ROTATION;
+
+   }
+   else if ((mask & MASK_3D_NO_ROT) == (GLuint) MASK_3D_NO_ROT) {
+      mat->type = MATRIX_3D_NO_ROT;
+
+      /* Check for scale */
+      if (SQ(m[0]-m[5]) < SQ(1e-6) &&
+	  SQ(m[0]-m[10]) < SQ(1e-6)) {
+	 if (SQ(m[0]-1.0) > SQ(1e-6)) {
+	    mat->flags |= MAT_FLAG_UNIFORM_SCALE;
+         }
+      }
+      else {
+	 mat->flags |= MAT_FLAG_GENERAL_SCALE;
+      }
+   }
+   else if ((mask & MASK_3D) == (GLuint) MASK_3D) {
+      GLfloat c1 = DOT3(m,m);
+      GLfloat c2 = DOT3(m+4,m+4);
+      GLfloat c3 = DOT3(m+8,m+8);
+      GLfloat d1 = DOT3(m, m+4);
+      GLfloat cp[3];
+
+      mat->type = MATRIX_3D;
+
+      /* Check for scale */
+      if (SQ(c1-c2) < SQ(1e-6) && SQ(c1-c3) < SQ(1e-6)) {
+	 if (SQ(c1-1.0) > SQ(1e-6))
+	    mat->flags |= MAT_FLAG_UNIFORM_SCALE;
+	 /* else no scale at all */
+      }
+      else {
+	 mat->flags |= MAT_FLAG_GENERAL_SCALE;
+      }
+
+      /* Check for rotation */
+      if (SQ(d1) < SQ(1e-6)) {
+	 CROSS3( cp, m, m+4 );
+	 SUB_3V( cp, cp, (m+8) );
+	 if (LEN_SQUARED_3FV(cp) < SQ(1e-6))
+	    mat->flags |= MAT_FLAG_ROTATION;
+	 else
+	    mat->flags |= MAT_FLAG_GENERAL_3D;
+      }
+      else {
+	 mat->flags |= MAT_FLAG_GENERAL_3D; /* shear, etc */
+      }
+   }
+   else if ((mask & MASK_PERSPECTIVE) == MASK_PERSPECTIVE && m[11]==-1.0F) {
+      mat->type = MATRIX_PERSPECTIVE;
+      mat->flags |= MAT_FLAG_GENERAL;
+   }
+   else {
+      mat->type = MATRIX_GENERAL;
+      mat->flags |= MAT_FLAG_GENERAL;
+   }
+}
+
+
+/* Analyse a matrix given that its flags are accurate - this is the
+ * more common operation, hopefully.
+ */
+static void analyse_from_flags( GLmatrix *mat )
+{
+   const GLfloat *m = mat->m;
+
+   if (TEST_MAT_FLAGS(mat, 0)) {
+      mat->type = MATRIX_IDENTITY;
+   }
+   else if (TEST_MAT_FLAGS(mat, (MAT_FLAG_TRANSLATION |
+				 MAT_FLAG_UNIFORM_SCALE |
+				 MAT_FLAG_GENERAL_SCALE))) {
+      if ( m[10]==1.0F && m[14]==0.0F ) {
+	 mat->type = MATRIX_2D_NO_ROT;
+      }
+      else {
+	 mat->type = MATRIX_3D_NO_ROT;
+      }
+   }
+   else if (TEST_MAT_FLAGS(mat, MAT_FLAGS_3D)) {
+      if (                                 m[ 8]==0.0F
+            &&                             m[ 9]==0.0F
+            && m[2]==0.0F && m[6]==0.0F && m[10]==1.0F && m[14]==0.0F) {
+	 mat->type = MATRIX_2D;
+      }
+      else {
+	 mat->type = MATRIX_3D;
+      }
+   }
+   else if (                 m[4]==0.0F                 && m[12]==0.0F
+            && m[1]==0.0F                               && m[13]==0.0F
+            && m[2]==0.0F && m[6]==0.0F
+            && m[3]==0.0F && m[7]==0.0F && m[11]==-1.0F && m[15]==0.0F) {
+      mat->type = MATRIX_PERSPECTIVE;
+   }
+   else {
+      mat->type = MATRIX_GENERAL;
+   }
+}
+
+
+void
+_math_matrix_analyse( GLmatrix *mat )
+{
+   if (mat->flags & MAT_DIRTY_TYPE) {
+      if (mat->flags & MAT_DIRTY_FLAGS)
+	 analyse_from_scratch( mat );
+      else
+	 analyse_from_flags( mat );
+   }
+
+   if (mat->inv && (mat->flags & MAT_DIRTY_INVERSE)) {
+      matrix_invert( mat );
+   }
+
+   mat->flags &= ~(MAT_DIRTY_FLAGS|
+		   MAT_DIRTY_TYPE|
+		   MAT_DIRTY_INVERSE);
+}
+
+
+void
+_math_matrix_copy( GLmatrix *to, const GLmatrix *from )
+{
+   MEMCPY( to->m, from->m, sizeof(Identity) );
+   to->flags = from->flags;
+   to->type = from->type;
+
+   if (to->inv != 0) {
+      if (from->inv == 0) {
+	 matrix_invert( to );
+      }
+      else {
+	 MEMCPY(to->inv, from->inv, sizeof(GLfloat)*16);
+      }
+   }
+}
+
+
+void
+_math_matrix_scale( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z )
+{
+   GLfloat *m = mat->m;
+   m[0] *= x;   m[4] *= y;   m[8]  *= z;
+   m[1] *= x;   m[5] *= y;   m[9]  *= z;
+   m[2] *= x;   m[6] *= y;   m[10] *= z;
+   m[3] *= x;   m[7] *= y;   m[11] *= z;
+
+   if (fabs(x - y) < 1e-8 && fabs(x - z) < 1e-8)
+      mat->flags |= MAT_FLAG_UNIFORM_SCALE;
+   else
+      mat->flags |= MAT_FLAG_GENERAL_SCALE;
+
+   mat->flags |= (MAT_DIRTY_TYPE |
+		  MAT_DIRTY_INVERSE);
+}
+
+
+void
+_math_matrix_translate( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z )
+{
+   GLfloat *m = mat->m;
+   m[12] = m[0] * x + m[4] * y + m[8]  * z + m[12];
+   m[13] = m[1] * x + m[5] * y + m[9]  * z + m[13];
+   m[14] = m[2] * x + m[6] * y + m[10] * z + m[14];
+   m[15] = m[3] * x + m[7] * y + m[11] * z + m[15];
+
+   mat->flags |= (MAT_FLAG_TRANSLATION |
+		  MAT_DIRTY_TYPE |
+		  MAT_DIRTY_INVERSE);
+}
+
+
+void
+_math_matrix_loadf( GLmatrix *mat, const GLfloat *m )
+{
+   MEMCPY( mat->m, m, 16*sizeof(GLfloat) );
+   mat->flags = (MAT_FLAG_GENERAL | MAT_DIRTY);
+}
+
+void
+_math_matrix_ctr( GLmatrix *m )
+{
+   if ( m->m == 0 ) {
+      m->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+   }
+   MEMCPY( m->m, Identity, sizeof(Identity) );
+   m->inv = 0;
+   m->type = MATRIX_IDENTITY;
+   m->flags = 0;
+}
+
+void
+_math_matrix_dtr( GLmatrix *m )
+{
+   if ( m->m != 0 ) {
+      ALIGN_FREE( m->m );
+      m->m = 0;
+   }
+   if ( m->inv != 0 ) {
+      ALIGN_FREE( m->inv );
+      m->inv = 0;
+   }
+}
+
+
+void
+_math_matrix_alloc_inv( GLmatrix *m )
+{
+   if ( m->inv == 0 ) {
+      m->inv = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
+      MEMCPY( m->inv, Identity, 16 * sizeof(GLfloat) );
+   }
+}
+
+
+void
+_math_matrix_mul_matrix( GLmatrix *dest, const GLmatrix *a, const GLmatrix *b )
+{
+   dest->flags = (a->flags |
+		  b->flags |
+		  MAT_DIRTY_TYPE |
+		  MAT_DIRTY_INVERSE);
+
+   if (TEST_MAT_FLAGS(dest, MAT_FLAGS_3D))
+      matmul34( dest->m, a->m, b->m );
+   else
+      matmul4( dest->m, a->m, b->m );
+}
+
+
+void
+_math_matrix_mul_floats( GLmatrix *dest, const GLfloat *m )
+{
+   dest->flags |= (MAT_FLAG_GENERAL |
+		   MAT_DIRTY_TYPE |
+		   MAT_DIRTY_INVERSE);
+
+   matmul4( dest->m, dest->m, m );
+}
+
+void
+_math_matrix_set_identity( GLmatrix *mat )
+{
+   MEMCPY( mat->m, Identity, 16*sizeof(GLfloat) );
+
+   if (mat->inv)
+      MEMCPY( mat->inv, Identity, 16*sizeof(GLfloat) );
+
+   mat->type = MATRIX_IDENTITY;
+   mat->flags &= ~(MAT_DIRTY_FLAGS|
+		   MAT_DIRTY_TYPE|
+		   MAT_DIRTY_INVERSE);
+}
+
+
+
+void
+_math_transposef( GLfloat to[16], const GLfloat from[16] )
+{
+   to[0] = from[0];
+   to[1] = from[4];
+   to[2] = from[8];
+   to[3] = from[12];
+   to[4] = from[1];
+   to[5] = from[5];
+   to[6] = from[9];
+   to[7] = from[13];
+   to[8] = from[2];
+   to[9] = from[6];
+   to[10] = from[10];
+   to[11] = from[14];
+   to[12] = from[3];
+   to[13] = from[7];
+   to[14] = from[11];
+   to[15] = from[15];
+}
+
+
+void
+_math_transposed( GLdouble to[16], const GLdouble from[16] )
+{
+   to[0] = from[0];
+   to[1] = from[4];
+   to[2] = from[8];
+   to[3] = from[12];
+   to[4] = from[1];
+   to[5] = from[5];
+   to[6] = from[9];
+   to[7] = from[13];
+   to[8] = from[2];
+   to[9] = from[6];
+   to[10] = from[10];
+   to[11] = from[14];
+   to[12] = from[3];
+   to[13] = from[7];
+   to[14] = from[11];
+   to[15] = from[15];
+}
+
+void
+_math_transposefd( GLfloat to[16], const GLdouble from[16] )
+{
+   to[0] = (GLfloat) from[0];
+   to[1] = (GLfloat) from[4];
+   to[2] = (GLfloat) from[8];
+   to[3] = (GLfloat) from[12];
+   to[4] = (GLfloat) from[1];
+   to[5] = (GLfloat) from[5];
+   to[6] = (GLfloat) from[9];
+   to[7] = (GLfloat) from[13];
+   to[8] = (GLfloat) from[2];
+   to[9] = (GLfloat) from[6];
+   to[10] = (GLfloat) from[10];
+   to[11] = (GLfloat) from[14];
+   to[12] = (GLfloat) from[3];
+   to[13] = (GLfloat) from[7];
+   to[14] = (GLfloat) from[11];
+   to[15] = (GLfloat) from[15];
+}
Index: xc/extras/Mesa/src/math/m_matrix.h
diff -u /dev/null xc/extras/Mesa/src/math/m_matrix.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_matrix.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,175 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _M_MATRIX_H
+#define _M_MATRIX_H
+
+
+
+/* Give symbolic names to some of the entries in the matrix to help
+ * out with the rework of the viewport_map as a matrix transform.
+ */
+#define MAT_SX 0
+#define MAT_SY 5
+#define MAT_SZ 10
+#define MAT_TX 12
+#define MAT_TY 13
+#define MAT_TZ 14
+
+/*
+ * Different kinds of 4x4 transformation matrices:
+ */
+#define MATRIX_GENERAL		0	/* general 4x4 matrix */
+#define MATRIX_IDENTITY		1	/* identity matrix */
+#define MATRIX_3D_NO_ROT	2	/* ortho projection and others... */
+#define MATRIX_PERSPECTIVE	3	/* perspective projection matrix */
+#define MATRIX_2D		4	/* 2-D transformation */
+#define MATRIX_2D_NO_ROT	5	/* 2-D scale & translate only */
+#define MATRIX_3D		6	/* 3-D transformation */
+
+#define MAT_FLAG_IDENTITY       0
+#define MAT_FLAG_GENERAL        0x1
+#define MAT_FLAG_ROTATION       0x2
+#define MAT_FLAG_TRANSLATION    0x4
+#define MAT_FLAG_UNIFORM_SCALE  0x8
+#define MAT_FLAG_GENERAL_SCALE  0x10
+#define MAT_FLAG_GENERAL_3D     0x20
+#define MAT_FLAG_PERSPECTIVE    0x40
+#define MAT_FLAG_SINGULAR       0x80
+#define MAT_DIRTY_TYPE          0x100
+#define MAT_DIRTY_FLAGS         0x200
+#define MAT_DIRTY_INVERSE       0x400
+
+#define MAT_FLAGS_ANGLE_PRESERVING (MAT_FLAG_ROTATION | \
+				    MAT_FLAG_TRANSLATION | \
+				    MAT_FLAG_UNIFORM_SCALE)
+
+#define MAT_FLAGS_LENGTH_PRESERVING (MAT_FLAG_ROTATION | \
+				     MAT_FLAG_TRANSLATION)
+
+#define MAT_FLAGS_3D (MAT_FLAG_ROTATION | \
+		      MAT_FLAG_TRANSLATION | \
+		      MAT_FLAG_UNIFORM_SCALE | \
+		      MAT_FLAG_GENERAL_SCALE | \
+		      MAT_FLAG_GENERAL_3D)
+
+#define MAT_FLAGS_GEOMETRY (MAT_FLAG_GENERAL | \
+			    MAT_FLAG_ROTATION | \
+			    MAT_FLAG_TRANSLATION | \
+			    MAT_FLAG_UNIFORM_SCALE | \
+			    MAT_FLAG_GENERAL_SCALE | \
+			    MAT_FLAG_GENERAL_3D | \
+			    MAT_FLAG_PERSPECTIVE | \
+	                    MAT_FLAG_SINGULAR)
+
+#define MAT_DIRTY          (MAT_DIRTY_TYPE | \
+			    MAT_DIRTY_FLAGS | \
+			    MAT_DIRTY_INVERSE)
+
+#define TEST_MAT_FLAGS(mat, a)  \
+    ((MAT_FLAGS_GEOMETRY & (~(a)) & ((mat)->flags) ) == 0)
+
+
+typedef struct {
+   GLfloat *m;		/* 16-byte aligned */
+   GLfloat *inv;	/* optional, 16-byte aligned */
+   GLuint flags;
+   GLuint type;		/* one of the MATRIX_* values */
+} GLmatrix;
+
+
+
+
+extern void
+_math_matrix_ctr( GLmatrix *m );
+
+extern void
+_math_matrix_dtr( GLmatrix *m );
+
+extern void
+_math_matrix_alloc_inv( GLmatrix *m );
+
+extern void
+_math_matrix_mul_matrix( GLmatrix *dest, const GLmatrix *a, const GLmatrix *b );
+
+extern void
+_math_matrix_mul_floats( GLmatrix *dest, const GLfloat *b );
+
+extern void
+_math_matrix_loadf( GLmatrix *mat, const GLfloat *m );
+
+extern void
+_math_matrix_translate( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z );
+
+extern void
+_math_matrix_rotate( GLmatrix *m, GLfloat angle,
+		     GLfloat x, GLfloat y, GLfloat z );
+
+extern void
+_math_matrix_scale( GLmatrix *mat, GLfloat x, GLfloat y, GLfloat z );
+
+extern void
+_math_matrix_ortho( GLmatrix *mat,
+		    GLfloat left, GLfloat right,
+		    GLfloat bottom, GLfloat top,
+		    GLfloat nearval, GLfloat farval );
+
+extern void
+_math_matrix_frustum( GLmatrix *mat,
+		      GLfloat left, GLfloat right,
+		      GLfloat bottom, GLfloat top,
+		      GLfloat nearval, GLfloat farval );
+
+extern void
+_math_matrix_set_identity( GLmatrix *dest );
+
+extern void
+_math_matrix_copy( GLmatrix *to, const GLmatrix *from );
+
+extern void
+_math_matrix_analyse( GLmatrix *mat );
+
+extern void
+_math_matrix_print( const GLmatrix *m );
+
+
+
+
+/* Related functions that don't actually operate on GLmatrix structs:
+ */
+extern void
+_math_transposef( GLfloat to[16], const GLfloat from[16] );
+
+extern void
+_math_transposed( GLdouble to[16], const GLdouble from[16] );
+
+extern void
+_math_transposefd( GLfloat to[16], const GLdouble from[16] );
+
+
+
+
+#endif
Index: xc/extras/Mesa/src/math/m_norm_tmp.h
diff -u /dev/null xc/extras/Mesa/src/math/m_norm_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_norm_tmp.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,369 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+#include <math.h>
+#include "m_vertices.h"
+
+static void _XFORMAPI
+TAG(transform_normalize_normals)( const GLmatrix *mat,
+                                  GLfloat scale,
+                                  const GLvector3f *in,
+                                  const GLfloat *lengths,
+                                  GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   GLfloat *m = mat->inv;
+   GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8];
+   GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9];
+   GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10];
+
+   if (!lengths) {
+      STRIDE_LOOP {
+	 GLfloat tx, ty, tz;
+	 {
+	    const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+	    tx = ux * m0 + uy * m1 + uz * m2;
+	    ty = ux * m4 + uy * m5 + uz * m6;
+	    tz = ux * m8 + uy * m9 + uz * m10;
+	 }
+	 {
+	    GLdouble len = tx*tx + ty*ty + tz*tz;
+	    if (len > 1e-20) {
+	       GLdouble scale = 1.0 / GL_SQRT(len);
+	       out[i][0] = (GLfloat) (tx * scale);
+	       out[i][1] = (GLfloat) (ty * scale);
+	       out[i][2] = (GLfloat) (tz * scale);
+	    }
+	    else
+	    {
+	       out[i][0] = out[i][1] = out[i][2] = 0;
+	    }
+	 }
+      }
+   }
+   else {
+      if (scale != 1.0) {
+	 m0 *= scale,  m4 *= scale,  m8 *= scale;
+	 m1 *= scale,  m5 *= scale,  m9 *= scale;
+	 m2 *= scale,  m6 *= scale,  m10 *= scale;
+      }
+
+      STRIDE_LOOP {
+	 GLfloat tx, ty, tz;
+	 {
+	    const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+	    tx = ux * m0 + uy * m1 + uz * m2;
+	    ty = ux * m4 + uy * m5 + uz * m6;
+	    tz = ux * m8 + uy * m9 + uz * m10;
+	 }
+	 {
+	    GLfloat len = lengths[i];
+	    out[i][0] = tx * len;
+	    out[i][1] = ty * len;
+	    out[i][2] = tz * len;
+	 }
+      }
+   }
+   dest->count = in->count;
+}
+
+
+static void _XFORMAPI
+TAG(transform_normalize_normals_no_rot)( const GLmatrix *mat,
+                                         GLfloat scale,
+                                         const GLvector3f *in,
+                                         const GLfloat *lengths,
+                                         GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   GLfloat *m = mat->inv;
+   GLfloat m0 = m[0];
+   GLfloat m5 = m[5];
+   GLfloat m10 = m[10];
+   if (!lengths) {
+      STRIDE_LOOP {
+	 GLfloat tx, ty, tz;
+	 {
+	    const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+	    tx = ux * m0                    ;
+	    ty =           uy * m5          ;
+	    tz =                     uz * m10;
+	 }
+	 {
+	    GLdouble len = tx*tx + ty*ty + tz*tz;
+	    if (len > 1e-20) {
+	       GLdouble scale = 1.0 / GL_SQRT(len);
+	       out[i][0] = (GLfloat) (tx * scale);
+	       out[i][1] = (GLfloat) (ty * scale);
+	       out[i][2] = (GLfloat) (tz * scale);
+	    }
+	    else
+	    {
+	       out[i][0] = out[i][1] = out[i][2] = 0;
+	    }
+	 }
+      }
+   }
+   else {
+      m0 *= scale;
+      m5 *= scale;
+      m10 *= scale;
+
+      STRIDE_LOOP {
+	 GLfloat tx, ty, tz;
+	 {
+	    const GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+	    tx = ux * m0                    ;
+	    ty =           uy * m5          ;
+	    tz =                     uz * m10;
+	 }
+	 {
+	    GLfloat len = lengths[i];
+	    out[i][0] = tx * len;
+	    out[i][1] = ty * len;
+	    out[i][2] = tz * len;
+	 }
+      }
+   }
+   dest->count = in->count;
+}
+
+
+static void _XFORMAPI
+TAG(transform_rescale_normals_no_rot)( const GLmatrix *mat,
+                                       GLfloat scale,
+                                       const GLvector3f *in,
+                                       const GLfloat *lengths,
+                                       GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   const GLfloat *m = mat->inv;
+   GLfloat m0 = scale*m[0];
+   GLfloat m5 = scale*m[5];
+   GLfloat m10 = scale*m[10];
+   (void) lengths;
+   STRIDE_LOOP {
+      GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+      out[i][0] = ux * m0;
+      out[i][1] =           uy * m5;
+      out[i][2] =                     uz * m10;
+   }
+   dest->count = in->count;
+}
+
+static void _XFORMAPI
+TAG(transform_rescale_normals)( const GLmatrix *mat,
+                                GLfloat scale,
+                                const GLvector3f *in,
+                                const GLfloat *lengths,
+                                GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   /* Since we are unlikely to have < 3 vertices in the buffer,
+    * it makes sense to pre-multiply by scale.
+    */
+   const GLfloat *m = mat->inv;
+   GLfloat m0 = scale*m[0],  m4 = scale*m[4],  m8 = scale*m[8];
+   GLfloat m1 = scale*m[1],  m5 = scale*m[5],  m9 = scale*m[9];
+   GLfloat m2 = scale*m[2],  m6 = scale*m[6],  m10 = scale*m[10];
+   (void) lengths;
+   STRIDE_LOOP {
+      GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+      out[i][0] = ux * m0 + uy * m1 + uz * m2;
+      out[i][1] = ux * m4 + uy * m5 + uz * m6;
+      out[i][2] = ux * m8 + uy * m9 + uz * m10;
+   }
+   dest->count = in->count;
+}
+
+
+static void _XFORMAPI
+TAG(transform_normals_no_rot)( const GLmatrix *mat,
+			       GLfloat scale,
+			       const GLvector3f *in,
+			       const GLfloat *lengths,
+			       GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   const GLfloat *m = mat->inv;
+   GLfloat m0 = m[0];
+   GLfloat m5 = m[5];
+   GLfloat m10 = m[10];
+   (void) scale;
+   (void) lengths;
+   STRIDE_LOOP {
+      GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+      out[i][0] = ux * m0;
+      out[i][1] =           uy * m5;
+      out[i][2] =                     uz * m10;
+   }
+   dest->count = in->count;
+}
+
+
+static void _XFORMAPI
+TAG(transform_normals)( const GLmatrix *mat,
+                        GLfloat scale,
+                        const GLvector3f *in,
+                        const GLfloat *lengths,
+                        GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   const GLfloat *m = mat->inv;
+   GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8];
+   GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9];
+   GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10];
+   (void) scale;
+   (void) lengths;
+   STRIDE_LOOP {
+      GLfloat ux = from[0],  uy = from[1],  uz = from[2];
+      out[i][0] = ux * m0 + uy * m1 + uz * m2;
+      out[i][1] = ux * m4 + uy * m5 + uz * m6;
+      out[i][2] = ux * m8 + uy * m9 + uz * m10;
+   }
+   dest->count = in->count;
+}
+
+
+static void _XFORMAPI
+TAG(normalize_normals)( const GLmatrix *mat,
+                        GLfloat scale,
+                        const GLvector3f *in,
+                        const GLfloat *lengths,
+                        GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   (void) mat;
+   (void) scale;
+   if (lengths) {
+      STRIDE_LOOP {
+	 const GLfloat x = from[0], y = from[1], z = from[2];
+	 GLfloat invlen = lengths[i];
+	 out[i][0] = x * invlen;
+	 out[i][1] = y * invlen;
+	 out[i][2] = z * invlen;
+      }
+   }
+   else {
+      STRIDE_LOOP {
+	 const GLfloat x = from[0], y = from[1], z = from[2];
+	 GLdouble len = x * x + y * y + z * z;
+	 if (len > 1e-50) {
+	    len = 1.0 / GL_SQRT(len);
+	    out[i][0] = (GLfloat) (x * len);
+	    out[i][1] = (GLfloat) (y * len);
+	    out[i][2] = (GLfloat) (z * len);
+	 }
+	 else {
+	    out[i][0] = x;
+	    out[i][1] = y;
+	    out[i][2] = z;
+	 }
+      }
+   }
+   dest->count = in->count;
+}
+
+
+static void _XFORMAPI
+TAG(rescale_normals)( const GLmatrix *mat,
+                      GLfloat scale,
+                      const GLvector3f *in,
+                      const GLfloat *lengths,
+                      GLvector3f *dest )
+{
+   GLuint i;
+   const GLfloat *from = in->start;
+   GLuint stride = in->stride;
+   GLuint count = in->count;
+   GLfloat (*out)[3] = (GLfloat (*)[3])dest->start;
+   (void) mat;
+   (void) lengths;
+   STRIDE_LOOP {
+      SCALE_SCALAR_3V( out[i], scale, from );
+   }
+   dest->count = in->count;
+}
+
+
+static void _XFORMAPI
+TAG(init_c_norm_transform)( void )
+{
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT] =
+      TAG(transform_normals_no_rot);
+
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_RESCALE] =
+      TAG(transform_rescale_normals_no_rot);
+
+   _mesa_normal_tab[NORM_TRANSFORM_NO_ROT | NORM_NORMALIZE] =
+      TAG(transform_normalize_normals_no_rot);
+
+   _mesa_normal_tab[NORM_TRANSFORM] =
+      TAG(transform_normals);
+
+   _mesa_normal_tab[NORM_TRANSFORM | NORM_RESCALE] =
+      TAG(transform_rescale_normals);
+
+   _mesa_normal_tab[NORM_TRANSFORM | NORM_NORMALIZE] =
+      TAG(transform_normalize_normals);
+
+   _mesa_normal_tab[NORM_RESCALE] =
+      TAG(rescale_normals);
+
+   _mesa_normal_tab[NORM_NORMALIZE] =
+      TAG(normalize_normals);
+}
Index: xc/extras/Mesa/src/math/m_trans_tmp.h
diff -u /dev/null xc/extras/Mesa/src/math/m_trans_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_trans_tmp.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,235 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+/* KW: This file also included by tnl/trans_elt.c to build code
+ *     specific to the implementation of array-elements in the
+ *     tnl module.
+ */
+
+
+#ifdef DEST_4F
+static void DEST_4F( GLfloat (*t)[4],
+		     CONST void *ptr,
+		     GLuint stride,
+		     ARGS )
+{
+   const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
+   const GLubyte *first = f;
+   GLuint i;
+
+   (void) first;
+   (void) start;
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	 if (SZ >= 1) t[i][0] = TRX_4F(f, 0);
+	 if (SZ >= 2) t[i][1] = TRX_4F(f, 1);
+	 if (SZ >= 3) t[i][2] = TRX_4F(f, 2);
+	 if (SZ == 4) t[i][3] = TRX_4F(f, 3); else t[i][3] = 1.0;
+      }
+   }
+}
+#endif
+
+
+#ifdef DEST_3F
+static void DEST_3F( GLfloat (*t)[3],
+		     CONST void *ptr,
+		     GLuint stride,
+		     ARGS )
+{
+   const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
+   const GLubyte *first = f;
+   GLuint i;
+   (void) first;
+   (void) start;
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	 t[i][0] = TRX_3F(f, 0);
+	 t[i][1] = TRX_3F(f, 1);
+	 t[i][2] = TRX_3F(f, 2);
+      }
+   }
+}
+#endif
+
+#ifdef DEST_1F
+static void DEST_1F( GLfloat *t,
+		     CONST void *ptr,
+		     GLuint stride,
+		     ARGS )
+{
+   const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
+   const GLubyte *first = f;
+   GLuint i;
+   (void) first;
+   (void) start;
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	 t[i] = TRX_1F(f, 0);
+      }
+   }
+}
+#endif
+
+#ifdef DEST_4UB
+static void DEST_4UB( GLubyte (*t)[4],
+                      CONST void *ptr,
+                      GLuint stride,
+                      ARGS )
+{
+   const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
+   const GLubyte *first = f;
+   GLuint i;
+   (void) start;
+   (void) first;
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	 if (SZ >= 1) TRX_UB(t[i][0], f, 0);
+	 if (SZ >= 2) TRX_UB(t[i][1], f, 1);
+	 if (SZ >= 3) TRX_UB(t[i][2], f, 2);
+	 if (SZ == 4) TRX_UB(t[i][3], f, 3); else t[i][3] = 255;
+      }
+   }
+}
+#endif
+
+
+#ifdef DEST_4US
+static void DEST_4US( GLushort (*t)[4],
+                      CONST void *ptr,
+                      GLuint stride,
+                      ARGS )
+{
+   const GLubyte *f = (GLubyte *) ((GLubyte *) ptr + SRC_START * stride);
+   const GLubyte *first = f;
+   GLuint i;
+   (void) start;
+   (void) first;
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	 if (SZ >= 1) TRX_US(t[i][0], f, 0);
+	 if (SZ >= 2) TRX_US(t[i][1], f, 1);
+	 if (SZ >= 3) TRX_US(t[i][2], f, 2);
+	 if (SZ == 4) TRX_US(t[i][3], f, 3); else t[i][3] = 65535;
+      }
+   }
+}
+#endif
+
+
+#ifdef DEST_1UB
+static void DEST_1UB( GLubyte *t,
+		      CONST void *ptr,
+		      GLuint stride,
+		      ARGS )
+{
+   const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
+   const GLubyte *first = f;
+   GLuint i;
+   (void) start;
+   (void) first;
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	  TRX_UB(t[i], f, 0);
+      }
+   }
+}
+#endif
+
+
+#ifdef DEST_1UI
+static void DEST_1UI( GLuint *t,
+		      CONST void *ptr,
+		      GLuint stride,
+		      ARGS )
+{
+   const GLubyte *f = (GLubyte *) ptr + SRC_START * stride;
+   const GLubyte *first = f;
+   GLuint i;
+   (void) start;
+   (void) first;
+
+   for (i = DST_START ; i < n ; i++, NEXT_F) {
+      CHECK {
+         NEXT_F2;
+	 t[i] = TRX_UI(f, 0);
+      }
+   }
+}
+#endif
+
+
+static void INIT(void)
+{
+#ifdef DEST_1UI
+   ASSERT(SZ == 1);
+   TAB(_1ui)[SRC_IDX] = DEST_1UI;
+#endif
+#ifdef DEST_1UB
+   ASSERT(SZ == 1);
+   TAB(_1ub)[SRC_IDX] = DEST_1UB;
+#endif
+#ifdef DEST_1F
+   ASSERT(SZ == 1);
+   TAB(_1f)[SRC_IDX] = DEST_1F;
+#endif
+#ifdef DEST_3F
+   ASSERT(SZ == 3);
+   TAB(_3f)[SRC_IDX] = DEST_3F;
+#endif
+#ifdef DEST_4UB
+   TAB(_4ub)[SZ][SRC_IDX] = DEST_4UB;
+#endif
+#ifdef DEST_4US
+   TAB(_4us)[SZ][SRC_IDX] = DEST_4US;
+#endif
+#ifdef DEST_4F
+   TAB(_4f)[SZ][SRC_IDX] = DEST_4F;
+#endif
+
+}
+
+
+#undef INIT
+#undef DEST_1UI
+#undef DEST_1UB
+#undef DEST_4UB
+#undef DEST_4US
+#undef DEST_3F
+#undef DEST_4F
+#undef DEST_1F
+#undef SZ
+#undef TAG
Index: xc/extras/Mesa/src/math/m_translate.c
diff -u /dev/null xc/extras/Mesa/src/math/m_translate.c:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_translate.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,662 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+#include "glheader.h"
+#include "mtypes.h"		/* GLchan hack */
+#include "colormac.h"
+#include "mem.h"
+#include "mmath.h"
+
+#include "m_translate.h"
+
+
+
+typedef void (*trans_1f_func)(GLfloat *to,
+			      CONST void *ptr,
+			      GLuint stride,
+			      GLuint start,
+			      GLuint n );
+
+typedef void (*trans_1ui_func)(GLuint *to,
+			       CONST void *ptr,
+			       GLuint stride,
+			       GLuint start,
+			       GLuint n );
+
+typedef void (*trans_1ub_func)(GLubyte *to,
+			       CONST void *ptr,
+			       GLuint stride,
+			       GLuint start,
+			       GLuint n );
+
+typedef void (*trans_4ub_func)(GLubyte (*to)[4],
+                               CONST void *ptr,
+                               GLuint stride,
+                               GLuint start,
+                               GLuint n );
+
+typedef void (*trans_4us_func)(GLushort (*to)[4],
+                               CONST void *ptr,
+                               GLuint stride,
+                               GLuint start,
+                               GLuint n );
+
+typedef void (*trans_4f_func)(GLfloat (*to)[4],
+			      CONST void *ptr,
+			      GLuint stride,
+			      GLuint start,
+			      GLuint n );
+
+typedef void (*trans_3f_func)(GLfloat (*to)[3],
+			      CONST void *ptr,
+			      GLuint stride,
+			      GLuint start,
+			      GLuint n );
+
+
+
+
+#define TYPE_IDX(t) ((t) & 0xf)
+#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1      /* 0xa + 1 */
+
+
+/* This macro is used on other systems, so undefine it for this module */
+
+#undef	CHECK
+
+static trans_1f_func  _math_trans_1f_tab[MAX_TYPES];
+static trans_1ui_func _math_trans_1ui_tab[MAX_TYPES];
+static trans_1ub_func _math_trans_1ub_tab[MAX_TYPES];
+static trans_3f_func  _math_trans_3f_tab[MAX_TYPES];
+static trans_4ub_func _math_trans_4ub_tab[5][MAX_TYPES];
+static trans_4us_func _math_trans_4us_tab[5][MAX_TYPES];
+static trans_4f_func  _math_trans_4f_tab[5][MAX_TYPES];
+
+
+#define PTR_ELT(ptr, elt) (((SRC *)ptr)[elt])
+
+
+#define TAB(x) _math_trans##x##_tab
+#define ARGS   GLuint start, GLuint n
+#define SRC_START  start
+#define DST_START  0
+#define STRIDE stride
+#define NEXT_F f += stride
+#define NEXT_F2
+#define CHECK
+
+
+
+
+/* GL_BYTE
+ */
+#define SRC GLbyte
+#define SRC_IDX TYPE_IDX(GL_BYTE)
+#define TRX_3F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
+#define TRX_US(ch, f,n)  ch = BYTE_TO_USHORT( PTR_ELT(f,n) )
+#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
+
+
+#define SZ 4
+#define INIT init_trans_4_GLbyte_raw
+#define DEST_4F trans_4_GLbyte_4f_raw
+#define DEST_4UB trans_4_GLbyte_4ub_raw
+#define DEST_4US trans_4_GLbyte_4us_raw
+#include "m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLbyte_raw
+#define DEST_4F trans_3_GLbyte_4f_raw
+#define DEST_4UB trans_3_GLbyte_4ub_raw
+#define DEST_4US trans_3_GLbyte_4us_raw
+#define DEST_3F trans_3_GLbyte_3f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLbyte_raw
+#define DEST_4F trans_2_GLbyte_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLbyte_raw
+#define DEST_4F trans_1_GLbyte_4f_raw
+#define DEST_1UB trans_1_GLbyte_1ub_raw
+#define DEST_1UI trans_1_GLbyte_1ui_raw
+#include "m_trans_tmp.h"
+
+#undef SRC
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+#undef SRC_IDX
+
+
+/* GL_UNSIGNED_BYTE
+ */
+#define SRC GLubyte
+#define SRC_IDX TYPE_IDX(GL_UNSIGNED_BYTE)
+#define TRX_3F(f,n)	     UBYTE_TO_FLOAT(PTR_ELT(f,n))
+#define TRX_4F(f,n)	     UBYTE_TO_FLOAT(PTR_ELT(f,n))
+#define TRX_UB(ub, f,n)	     ub = PTR_ELT(f,n)
+#define TRX_US(us, f,n)      us = UBYTE_TO_USHORT(PTR_ELT(f,n))
+#define TRX_UI(f,n)          (GLuint)PTR_ELT(f,n)
+
+/* 4ub->4ub handled in special case below.
+ */
+#define SZ 4
+#define INIT init_trans_4_GLubyte_raw
+#define DEST_4F trans_4_GLubyte_4f_raw
+#define DEST_4US trans_4_GLubyte_4us_raw
+#include "m_trans_tmp.h"
+
+
+#define SZ 3
+#define INIT init_trans_3_GLubyte_raw
+#define DEST_4UB trans_3_GLubyte_4ub_raw
+#define DEST_4US trans_3_GLubyte_4us_raw
+#define DEST_3F trans_3_GLubyte_3f_raw
+#define DEST_4F trans_3_GLubyte_4f_raw
+#include "m_trans_tmp.h"
+
+
+#define SZ 1
+#define INIT init_trans_1_GLubyte_raw
+#define DEST_1UI trans_1_GLubyte_1ui_raw
+#define DEST_1UB trans_1_GLubyte_1ub_raw
+#include "m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_SHORT
+ */
+#define SRC GLshort
+#define SRC_IDX TYPE_IDX(GL_SHORT)
+#define TRX_3F(f,n)   SHORT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = SHORT_TO_USHORT(PTR_ELT(f,n))
+#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
+
+
+#define SZ  4
+#define INIT init_trans_4_GLshort_raw
+#define DEST_4F trans_4_GLshort_4f_raw
+#define DEST_4UB trans_4_GLshort_4ub_raw
+#define DEST_4US trans_4_GLshort_4us_raw
+#include "m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLshort_raw
+#define DEST_4F trans_3_GLshort_4f_raw
+#define DEST_4UB trans_3_GLshort_4ub_raw
+#define DEST_4US trans_3_GLshort_4us_raw
+#define DEST_3F trans_3_GLshort_3f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLshort_raw
+#define DEST_4F trans_2_GLshort_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLshort_raw
+#define DEST_4F trans_1_GLshort_4f_raw
+#define DEST_1UB trans_1_GLshort_1ub_raw
+#define DEST_1UI trans_1_GLshort_1ui_raw
+#include "m_trans_tmp.h"
+
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_UNSIGNED_SHORT
+ */
+#define SRC GLushort
+#define SRC_IDX TYPE_IDX(GL_UNSIGNED_SHORT)
+#define TRX_3F(f,n)   USHORT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub,f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 8)
+#define TRX_US(us,f,n)  us = (GLushort) (PTR_ELT(f,n) >> 8)
+#define TRX_UI(f,n)  (GLuint)   PTR_ELT(f,n)
+
+
+#define SZ 4
+#define INIT init_trans_4_GLushort_raw
+#define DEST_4F trans_4_GLushort_4f_raw
+#define DEST_4UB trans_4_GLushort_4ub_raw
+#define DEST_4US trans_4_GLushort_4us_raw
+#include "m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLushort_raw
+#define DEST_4F trans_3_GLushort_4f_raw
+#define DEST_4UB trans_3_GLushort_4ub_raw
+#define DEST_4US trans_3_GLushort_4us_raw
+#define DEST_3F trans_3_GLushort_3f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLushort_raw
+#define DEST_4F trans_2_GLushort_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLushort_raw
+#define DEST_4F trans_1_GLushort_4f_raw
+#define DEST_1UB trans_1_GLushort_1ub_raw
+#define DEST_1UI trans_1_GLushort_1ui_raw
+#include "m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_INT
+ */
+#define SRC GLint
+#define SRC_IDX TYPE_IDX(GL_INT)
+#define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = INT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = INT_TO_USHORT(PTR_ELT(f,n))
+#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
+
+
+#define SZ 4
+#define INIT init_trans_4_GLint_raw
+#define DEST_4F trans_4_GLint_4f_raw
+#define DEST_4UB trans_4_GLint_4ub_raw
+#define DEST_4US trans_4_GLint_4us_raw
+#include "m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLint_raw
+#define DEST_4F trans_3_GLint_4f_raw
+#define DEST_4UB trans_3_GLint_4ub_raw
+#define DEST_4US trans_3_GLint_4us_raw
+#define DEST_3F trans_3_GLint_3f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLint_raw
+#define DEST_4F trans_2_GLint_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLint_raw
+#define DEST_4F trans_1_GLint_4f_raw
+#define DEST_1UB trans_1_GLint_1ub_raw
+#define DEST_1UI trans_1_GLint_1ui_raw
+#include "m_trans_tmp.h"
+
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_UNSIGNED_INT
+ */
+#define SRC GLuint
+#define SRC_IDX TYPE_IDX(GL_UNSIGNED_INT)
+#define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 24)
+#define TRX_US(us, f,n)  us = (GLshort) (PTR_ELT(f,n) >> 16)
+#define TRX_UI(f,n)		PTR_ELT(f,n)
+
+
+#define SZ 4
+#define INIT init_trans_4_GLuint_raw
+#define DEST_4F trans_4_GLuint_4f_raw
+#define DEST_4UB trans_4_GLuint_4ub_raw
+#define DEST_4US trans_4_GLuint_4us_raw
+#include "m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLuint_raw
+#define DEST_4F trans_3_GLuint_4f_raw
+#define DEST_4UB trans_3_GLuint_4ub_raw
+#define DEST_4US trans_3_GLuint_4us_raw
+#define DEST_3F trans_3_GLuint_3f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLuint_raw
+#define DEST_4F trans_2_GLuint_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLuint_raw
+#define DEST_4F trans_1_GLuint_4f_raw
+#define DEST_1UB trans_1_GLuint_1ub_raw
+#define DEST_1UI trans_1_GLuint_1ui_raw
+#include "m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_DOUBLE
+ */
+#define SRC GLdouble
+#define SRC_IDX TYPE_IDX(GL_DOUBLE)
+#define TRX_3F(f,n)   (GLfloat) PTR_ELT(f,n)
+#define TRX_4F(f,n)   (GLfloat) PTR_ELT(f,n)
+#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_UBYTE(ub, PTR_ELT(f,n))
+#define TRX_US(us,f,n) UNCLAMPED_FLOAT_TO_USHORT(us, PTR_ELT(f,n))
+#define TRX_UI(f,n)  (GLuint) (GLint) PTR_ELT(f,n)
+#define TRX_1F(f,n)   (GLfloat) PTR_ELT(f,n)
+
+
+#define SZ 4
+#define INIT init_trans_4_GLdouble_raw
+#define DEST_4F trans_4_GLdouble_4f_raw
+#define DEST_4UB trans_4_GLdouble_4ub_raw
+#define DEST_4US trans_4_GLdouble_4us_raw
+#include "m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLdouble_raw
+#define DEST_4F trans_3_GLdouble_4f_raw
+#define DEST_4UB trans_3_GLdouble_4ub_raw
+#define DEST_4US trans_3_GLdouble_4us_raw
+#define DEST_3F trans_3_GLdouble_3f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLdouble_raw
+#define DEST_4F trans_2_GLdouble_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLdouble_raw
+#define DEST_4F trans_1_GLdouble_4f_raw
+#define DEST_1UB trans_1_GLdouble_1ub_raw
+#define DEST_1UI trans_1_GLdouble_1ui_raw
+#define DEST_1F trans_1_GLdouble_1f_raw
+#include "m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+
+/* GL_FLOAT
+ */
+#define SRC GLfloat
+#define SRC_IDX TYPE_IDX(GL_FLOAT)
+#define SZ 4
+#define INIT init_trans_4_GLfloat_raw
+#define DEST_4UB trans_4_GLfloat_4ub_raw
+#define DEST_4US trans_4_GLfloat_4us_raw
+#define DEST_4F  trans_4_GLfloat_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLfloat_raw
+#define DEST_4F  trans_3_GLfloat_4f_raw
+#define DEST_4UB trans_3_GLfloat_4ub_raw
+#define DEST_4US trans_3_GLfloat_4us_raw
+#define DEST_3F trans_3_GLfloat_3f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLfloat_raw
+#define DEST_4F trans_2_GLfloat_4f_raw
+#include "m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLfloat_raw
+#define DEST_4F  trans_1_GLfloat_4f_raw
+#define DEST_1UB trans_1_GLfloat_1ub_raw
+#define DEST_1UI trans_1_GLfloat_1ui_raw
+#define DEST_1F trans_1_GLfloat_1f_raw
+
+#include "m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+static void trans_4_GLubyte_4ub_raw(GLubyte (*t)[4],
+				    CONST void *Ptr,
+				    GLuint stride,
+				    ARGS )
+{
+   const GLubyte *f = (GLubyte *) Ptr + SRC_START * stride;
+   GLuint i;
+
+   if (((((long) f | (long) stride)) & 3L) == 0L) {
+      /* Aligned.
+       */
+      for (i = DST_START ; i < n ; i++, f += stride) {
+	 COPY_4UBV( t[i], f );
+      }
+   } else {
+      for (i = DST_START ; i < n ; i++, f += stride) {
+	 t[i][0] = f[0];
+	 t[i][1] = f[1];
+	 t[i][2] = f[2];
+	 t[i][3] = f[3];
+      }
+   }
+}
+
+
+static void init_translate_raw(void)
+{
+   MEMSET( TAB(_1ui), 0, sizeof(TAB(_1ui)) );
+   MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
+   MEMSET( TAB(_3f),  0, sizeof(TAB(_3f)) );
+   MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
+   MEMSET( TAB(_4us), 0, sizeof(TAB(_4us)) );
+   MEMSET( TAB(_4f),  0, sizeof(TAB(_4f)) );
+
+   init_trans_4_GLbyte_raw();
+   init_trans_3_GLbyte_raw();
+   init_trans_2_GLbyte_raw();
+   init_trans_1_GLbyte_raw();
+   init_trans_1_GLubyte_raw();
+   init_trans_3_GLubyte_raw();
+   init_trans_4_GLubyte_raw();
+   init_trans_4_GLshort_raw();
+   init_trans_3_GLshort_raw();
+   init_trans_2_GLshort_raw();
+   init_trans_1_GLshort_raw();
+   init_trans_4_GLushort_raw();
+   init_trans_3_GLushort_raw();
+   init_trans_2_GLushort_raw();
+   init_trans_1_GLushort_raw();
+   init_trans_4_GLint_raw();
+   init_trans_3_GLint_raw();
+   init_trans_2_GLint_raw();
+   init_trans_1_GLint_raw();
+   init_trans_4_GLuint_raw();
+   init_trans_3_GLuint_raw();
+   init_trans_2_GLuint_raw();
+   init_trans_1_GLuint_raw();
+   init_trans_4_GLdouble_raw();
+   init_trans_3_GLdouble_raw();
+   init_trans_2_GLdouble_raw();
+   init_trans_1_GLdouble_raw();
+   init_trans_4_GLfloat_raw();
+   init_trans_3_GLfloat_raw();
+   init_trans_2_GLfloat_raw();
+   init_trans_1_GLfloat_raw();
+
+   TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub_raw;
+}
+
+
+#undef TAB
+#undef CLASS
+#undef ARGS
+#undef CHECK
+#undef SRC_START
+#undef DST_START
+#undef NEXT_F
+#undef NEXT_F2
+
+
+
+
+
+void _math_init_translate( void )
+{
+   init_translate_raw();
+}
+
+
+
+void _math_trans_1f(GLfloat *to,
+		    CONST void *ptr,
+		    GLuint stride,
+		    GLenum type,
+		    GLuint start,
+		    GLuint n )
+{
+   _math_trans_1f_tab[TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
+
+void _math_trans_1ui(GLuint *to,
+		     CONST void *ptr,
+		     GLuint stride,
+		     GLenum type,
+		     GLuint start,
+		     GLuint n )
+{
+   _math_trans_1ui_tab[TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
+
+void _math_trans_1ub(GLubyte *to,
+		     CONST void *ptr,
+		     GLuint stride,
+		     GLenum type,
+		     GLuint start,
+		     GLuint n )
+{
+   _math_trans_1ub_tab[TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
+
+
+void _math_trans_4ub(GLubyte (*to)[4],
+		     CONST void *ptr,
+		     GLuint stride,
+		     GLenum type,
+		     GLuint size,
+		     GLuint start,
+		     GLuint n )
+{
+   _math_trans_4ub_tab[size][TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
+
+void _math_trans_4chan( GLchan (*to)[4],
+			CONST void *ptr,
+			GLuint stride,
+			GLenum type,
+			GLuint size,
+			GLuint start,
+			GLuint n )
+{
+#if CHAN_TYPE == GL_UNSIGNED_BYTE
+   _math_trans_4ub( to, ptr, stride, type, size, start, n );
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+   _math_trans_4us( to, ptr, stride, type, size, start, n );
+#elif CHAN_TYPE == GL_FLOAT
+   _math_trans_4f( to, ptr, stride, type, size, start, n );
+#endif
+}
+
+void _math_trans_4us(GLushort (*to)[4],
+		     CONST void *ptr,
+		     GLuint stride,
+		     GLenum type,
+		     GLuint size,
+		     GLuint start,
+		     GLuint n )
+{
+   _math_trans_4us_tab[size][TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
+
+void _math_trans_4f(GLfloat (*to)[4],
+		    CONST void *ptr,
+		    GLuint stride,
+		    GLenum type,
+		    GLuint size,
+		    GLuint start,
+		    GLuint n )
+{
+   _math_trans_4f_tab[size][TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
+
+void _math_trans_3f(GLfloat (*to)[3],
+		    CONST void *ptr,
+		    GLuint stride,
+		    GLenum type,
+		    GLuint start,
+		    GLuint n )
+{
+   _math_trans_3f_tab[TYPE_IDX(type)]( to, ptr, stride, start, n );
+}
Index: xc/extras/Mesa/src/math/m_translate.h
diff -u /dev/null xc/extras/Mesa/src/math/m_translate.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_translate.h	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,98 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _M_TRANSLATE_H_
+#define _M_TRANSLATE_H_
+
+#include "config.h"
+#include "mtypes.h"		/* hack for GLchan */
+
+
+
+extern void _math_trans_1f(GLfloat *to,
+			   CONST void *ptr,
+			   GLuint stride,
+			   GLenum type,
+			   GLuint start,
+			   GLuint n );
+
+extern void _math_trans_1ui(GLuint *to,
+			    CONST void *ptr,
+			    GLuint stride,
+			    GLenum type,
+			    GLuint start,
+			    GLuint n );
+
+extern void _math_trans_1ub(GLubyte *to,
+			    CONST void *ptr,
+			    GLuint stride,
+			    GLenum type,
+			    GLuint start,
+			    GLuint n );
+
+extern void _math_trans_4ub(GLubyte (*to)[4],
+			    CONST void *ptr,
+			    GLuint stride,
+			    GLenum type,
+			    GLuint size,
+			    GLuint start,
+			    GLuint n );
+
+extern void _math_trans_4chan( GLchan (*to)[4],
+			       CONST void *ptr,
+			       GLuint stride,
+			       GLenum type,
+			       GLuint size,
+			       GLuint start,
+			       GLuint n );
+
+extern void _math_trans_4us(GLushort (*to)[4],
+			    CONST void *ptr,
+			    GLuint stride,
+			    GLenum type,
+			    GLuint size,
+			    GLuint start,
+			    GLuint n );
+
+extern void _math_trans_4f(GLfloat (*to)[4],
+			   CONST void *ptr,
+			   GLuint stride,
+			   GLenum type,
+			   GLuint size,
+			   GLuint start,
+			   GLuint n );
+
+extern void _math_trans_3f(GLfloat (*to)[3],
+			   CONST void *ptr,
+			   GLuint stride,
+			   GLenum type,
+			   GLuint start,
+			   GLuint n );
+
+extern void _math_init_translate( void );
+
+
+#endif
Index: xc/extras/Mesa/src/math/m_vector.c
diff -u /dev/null xc/extras/Mesa/src/math/m_vector.c:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_vector.c	Mon Dec 16 11:18:36 2002
@@ -0,0 +1,428 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+#include "glheader.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "m_vector.h"
+
+
+
+/*
+ * Given a vector [count][4] of floats, set all the [][elt] values
+ * to 0 (if elt = 0, 1, 2) or 1.0 (if elt = 3).
+ */
+void _mesa_vector4f_clean_elem( GLvector4f *vec, GLuint count, GLuint elt )
+{
+   static const GLubyte elem_bits[4] = {
+      VEC_DIRTY_0,
+      VEC_DIRTY_1,
+      VEC_DIRTY_2,
+      VEC_DIRTY_3
+   };
+   static const GLfloat clean[4] = { 0, 0, 0, 1 };
+   const GLfloat v = clean[elt];
+   GLfloat (*data)[4] = (GLfloat (*)[4])vec->start;
+   GLuint i;
+
+   for (i = 0 ; i < count ; i++)
+      data[i][elt] = v;
+
+   vec->flags &= ~elem_bits[elt];
+}
+
+static const GLubyte size_bits[5] = {
+   0,
+   VEC_SIZE_1,
+   VEC_SIZE_2,
+   VEC_SIZE_3,
+   VEC_SIZE_4,
+};
+
+
+
+/*
+ * Initialize GLvector objects.
+ * Input: v - the vector object to initialize.
+ *        flags - bitwise-OR of VEC_* flags
+ *        storage - pointer to storage for the vector's data
+ */
+
+
+void _mesa_vector4f_init( GLvector4f *v, GLuint flags, GLfloat (*storage)[4] )
+{
+   v->stride = 4 * sizeof(GLfloat);
+   v->size = 2;   /* may change: 2-4 for vertices and 1-4 for texcoords */
+   v->data = storage;
+   v->start = (GLfloat *) storage;
+   v->count = 0;
+   v->flags = size_bits[4] | flags ;
+}
+
+void _mesa_vector3f_init( GLvector3f *v, GLuint flags, GLfloat (*storage)[3] )
+{
+   v->stride = 3 * sizeof(GLfloat);
+   v->data = storage;
+   v->start = (GLfloat *) storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
+void _mesa_vector1f_init( GLvector1f *v, GLuint flags, GLfloat *storage )
+{
+   v->stride = 1*sizeof(GLfloat);
+   v->data = storage;
+   v->start = (GLfloat *)storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
+void _mesa_vector4ub_init( GLvector4ub *v, GLuint flags, GLubyte (*storage)[4] )
+{
+   v->stride = 4 * sizeof(GLubyte);
+   v->data = storage;
+   v->start = (GLubyte *) storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
+void _mesa_vector4chan_init( GLvector4chan *v, GLuint flags, GLchan (*storage)[4] )
+{
+   v->stride = 4 * sizeof(GLchan);
+   v->data = storage;
+   v->start = (GLchan *) storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
+void _mesa_vector4us_init( GLvector4us *v, GLuint flags, GLushort (*storage)[4] )
+{
+   v->stride = 4 * sizeof(GLushort);
+   v->data = storage;
+   v->start = (GLushort *) storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
+void _mesa_vector1ub_init( GLvector1ub *v, GLuint flags, GLubyte *storage )
+{
+   v->stride = 1 * sizeof(GLubyte);
+   v->data = storage;
+   v->start = (GLubyte *) storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
+void _mesa_vector1ui_init( GLvector1ui *v, GLuint flags, GLuint *storage )
+{
+   v->stride = 1 * sizeof(GLuint);
+   v->data = storage;
+   v->start = (GLuint *) storage;
+   v->count = 0;
+   v->flags = flags ;
+}
+
+
+/*
+ * Initialize GLvector objects and allocate storage.
+ * Input: v - the vector object
+ *        sz - unused????
+ *        flags - bitwise-OR of VEC_* flags
+ *        count - number of elements to allocate in vector
+ *        alignment - desired memory alignment for the data (in bytes)
+ */
+
+
+void _mesa_vector4f_alloc( GLvector4f *v, GLuint flags, GLuint count,
+			GLuint alignment )
+{
+   v->stride = 4 * sizeof(GLfloat);
+   v->size = 2;
+   v->storage = ALIGN_MALLOC( count * 4 * sizeof(GLfloat), alignment );
+   v->start = (GLfloat *) v->storage;
+   v->data = (GLfloat (*)[4]) v->storage;
+   v->count = 0;
+   v->flags = size_bits[4] | flags | VEC_MALLOC ;
+}
+
+void _mesa_vector3f_alloc( GLvector3f *v, GLuint flags, GLuint count,
+			GLuint alignment )
+{
+   v->stride = 3 * sizeof(GLfloat);
+   v->storage = ALIGN_MALLOC( count * 3 * sizeof(GLfloat), alignment );
+   v->start = (GLfloat *) v->storage;
+   v->data = (GLfloat (*)[3]) v->storage;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
+void _mesa_vector1f_alloc( GLvector1f *v, GLuint flags, GLuint count,
+			GLuint alignment )
+{
+   v->stride = sizeof(GLfloat);
+   v->storage = v->start = (GLfloat *)
+      ALIGN_MALLOC( count * sizeof(GLfloat), alignment );
+   v->data = v->start;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
+void _mesa_vector4ub_alloc( GLvector4ub *v, GLuint flags, GLuint count,
+			 GLuint alignment )
+{
+   v->stride = 4 * sizeof(GLubyte);
+   v->storage = ALIGN_MALLOC( count * 4 * sizeof(GLubyte), alignment );
+   v->start = (GLubyte *) v->storage;
+   v->data = (GLubyte (*)[4]) v->storage;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
+void _mesa_vector4chan_alloc( GLvector4chan *v, GLuint flags, GLuint count,
+			   GLuint alignment )
+{
+   v->stride = 4 * sizeof(GLchan);
+   v->storage = ALIGN_MALLOC( count * 4 * sizeof(GLchan), alignment );
+   v->start = (GLchan *) v->storage;
+   v->data = (GLchan (*)[4]) v->storage;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
+void _mesa_vector4us_alloc( GLvector4us *v, GLuint flags, GLuint count,
+                         GLuint alignment )
+{
+   v->stride = 4 * sizeof(GLushort);
+   v->storage = ALIGN_MALLOC( count * 4 * sizeof(GLushort), alignment );
+   v->start = (GLushort *) v->storage;
+   v->data = (GLushort (*)[4]) v->storage;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
+void _mesa_vector1ub_alloc( GLvector1ub *v, GLuint flags, GLuint count,
+			 GLuint alignment )
+{
+   v->stride = 1 * sizeof(GLubyte);
+   v->storage = ALIGN_MALLOC( count * sizeof(GLubyte), alignment );
+   v->start = (GLubyte *) v->storage;
+   v->data = (GLubyte *) v->storage;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
+void _mesa_vector1ui_alloc( GLvector1ui *v, GLuint flags, GLuint count,
+			 GLuint alignment )
+{
+   v->stride = 1 * sizeof(GLuint);
+   v->storage = ALIGN_MALLOC( count * sizeof(GLuint), alignment );
+   v->start = (GLuint *) v->storage;
+   v->data = (GLuint *) v->storage;
+   v->count = 0;
+   v->flags = flags | VEC_MALLOC ;
+}
+
+
+
+/*
+ * Vector deallocation.  Free whatever memory is pointed to by the
+ * vector's storage field if the VEC_MALLOC flag is set.
+ * DO NOT free the GLvector object itself, though.
+ */
+
+
+void _mesa_vector4f_free( GLvector4f *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+void _mesa_vector3f_free( GLvector3f *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = 0;
+      v->start = 0;
+      v->storage = 0;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+void _mesa_vector1f_free( GLvector1f *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+void _mesa_vector4ub_free( GLvector4ub *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+void _mesa_vector4chan_free( GLvector4chan *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+void _mesa_vector4us_free( GLvector4us *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+void _mesa_vector1ub_free( GLvector1ub *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+void _mesa_vector1ui_free( GLvector1ui *v )
+{
+   if (v->flags & VEC_MALLOC) {
+      ALIGN_FREE( v->storage );
+      v->data = NULL;
+      v->start = NULL;
+      v->storage = NULL;
+      v->flags &= ~VEC_MALLOC;
+   }
+}
+
+
+/*
+ * For debugging
+ */
+void _mesa_vector4f_print( GLvector4f *v, GLubyte *cullmask, GLboolean culling )
+{
+   GLfloat c[4] = { 0, 0, 0, 1 };
+   const char *templates[5] = {
+      "%d:\t0, 0, 0, 1\n",
+      "%d:\t%f, 0, 0, 1\n",
+      "%d:\t%f, %f, 0, 1\n",
+      "%d:\t%f, %f, %f, 1\n",
+      "%d:\t%f, %f, %f, %f\n"
+   };
+
+   const char *t = templates[v->size];
+   GLfloat *d = (GLfloat *)v->data;
+   GLuint j, i = 0, count;
+
+   printf("data-start\n");
+   for ( ; d != v->start ; STRIDE_F(d, v->stride), i++)
+      printf( t, i, d[0], d[1], d[2], d[3]);
+
+   printf("start-count(%u)\n", v->count);
+   count = i + v->count;
+
+   if (culling) {
+      for ( ; i < count ; STRIDE_F(d, v->stride), i++)
+	 if (cullmask[i])
+	    printf( t, i, d[0], d[1], d[2], d[3]);
+   }
+   else {
+      for ( ; i < count ; STRIDE_F(d, v->stride), i++)
+	 printf( t, i, d[0], d[1], d[2], d[3]);
+   }
+
+   for (j = v->size ; j < 4; j++) {
+      if ((v->flags & (1<<j)) == 0) {
+
+	 printf("checking col %u is clean as advertised ", j);
+
+	 for (i = 0, d = (GLfloat *) v->data ;
+	      i < count && d[j] == c[j] ;
+	      i++, STRIDE_F(d, v->stride)) {};
+
+	 if (i == count)
+	    printf(" --> ok\n");
+	 else
+	    printf(" --> Failed at %u ******\n", i);
+      }
+   }
+}
+
+
+/*
+ * For debugging
+ */
+void _mesa_vector3f_print( GLvector3f *v, GLubyte *cullmask, GLboolean culling )
+{
+   GLfloat *d = (GLfloat *)v->data;
+   GLuint i = 0, count;
+
+   printf("data-start\n");
+   for ( ; d != v->start ; STRIDE_F(d,v->stride), i++)
+      printf( "%u:\t%f, %f, %f\n", i, d[0], d[1], d[2]);
+
+   printf("start-count(%u)\n", v->count);
+   count = i + v->count;
+
+   if (culling) {
+      for ( ; i < count ; STRIDE_F(d,v->stride), i++)
+	 if (cullmask[i])
+	    printf( "%u:\t%f, %f, %f\n", i, d[0], d[1], d[2]);
+   }
+   else {
+      for ( ; i < count ; STRIDE_F(d,v->stride), i++)
+	 printf( "%u:\t%f, %f, %f\n", i, d[0], d[1], d[2]);
+   }
+}
Index: xc/extras/Mesa/src/math/m_vector.h
diff -u /dev/null xc/extras/Mesa/src/math/m_vector.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_vector.h	Mon Dec 16 11:18:37 2002
@@ -0,0 +1,221 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+#ifndef _M_VECTOR_H_
+#define _M_VECTOR_H_
+
+#include "glheader.h"
+#include "mtypes.h"		/* hack for GLchan */
+
+
+#define VEC_DIRTY_0        0x1
+#define VEC_DIRTY_1        0x2
+#define VEC_DIRTY_2        0x4
+#define VEC_DIRTY_3        0x8
+#define VEC_MALLOC         0x10 /* storage field points to self-allocated mem*/
+#define VEC_NOT_WRITEABLE  0x40	/* writable elements to hold clipped data */
+#define VEC_BAD_STRIDE     0x100 /* matches tnl's prefered stride */
+
+
+#define VEC_SIZE_1   VEC_DIRTY_0
+#define VEC_SIZE_2   (VEC_DIRTY_0|VEC_DIRTY_1)
+#define VEC_SIZE_3   (VEC_DIRTY_0|VEC_DIRTY_1|VEC_DIRTY_2)
+#define VEC_SIZE_4   (VEC_DIRTY_0|VEC_DIRTY_1|VEC_DIRTY_2|VEC_DIRTY_3)
+
+
+
+/* Wrap all the information about vectors up in a struct.  Has
+ * additional fields compared to the other vectors to help us track of
+ * different vertex sizes, and whether we need to clean columns out
+ * because they contain non-(0,0,0,1) values.
+ *
+ * The start field is used to reserve data for copied vertices at the
+ * end of _mesa_transform_vb, and avoids the need for a multiplication in
+ * the transformation routines.
+ */
+typedef struct {
+   GLfloat (*data)[4];	/* may be malloc'd or point to client data */
+   GLfloat *start;	/* points somewhere inside of <data> */
+   GLuint count;	/* size of the vector (in elements) */
+   GLuint stride;	/* stride from one element to the next (in bytes) */
+   GLuint size;		/* 2-4 for vertices and 1-4 for texcoords */
+   GLuint flags;	/* which columns are dirty */
+   void *storage;	/* self-allocated storage */
+} GLvector4f;
+
+
+extern void _mesa_vector4f_init( GLvector4f *v, GLuint flags,
+			      GLfloat (*storage)[4] );
+extern void _mesa_vector4f_alloc( GLvector4f *v, GLuint flags,
+			       GLuint count, GLuint alignment );
+extern void _mesa_vector4f_free( GLvector4f *v );
+extern void _mesa_vector4f_print( GLvector4f *v, GLubyte *, GLboolean );
+extern void _mesa_vector4f_clean_elem( GLvector4f *vec, GLuint nr, GLuint elt );
+
+
+/* Could use a single vector type for normals and vertices, but
+ * this way avoids some casts.
+ */
+typedef struct {
+   GLfloat (*data)[3];
+   GLfloat *start;
+   GLuint count;
+   GLuint stride;
+   GLuint flags;
+   void *storage;
+} GLvector3f;
+
+extern void _mesa_vector3f_init( GLvector3f *v, GLuint flags, GLfloat (*)[3] );
+extern void _mesa_vector3f_alloc( GLvector3f *v, GLuint flags, GLuint count,
+			       GLuint alignment );
+extern void _mesa_vector3f_free( GLvector3f *v );
+extern void _mesa_vector3f_print( GLvector3f *v, GLubyte *, GLboolean );
+
+
+typedef struct {
+   GLfloat *data;
+   GLfloat *start;
+   GLuint count;
+   GLuint stride;
+   GLuint flags;
+   void *storage;
+} GLvector1f;
+
+extern void _mesa_vector1f_free( GLvector1f *v );
+extern void _mesa_vector1f_init( GLvector1f *v, GLuint flags, GLfloat * );
+extern void _mesa_vector1f_alloc( GLvector1f *v, GLuint flags, GLuint count,
+			       GLuint alignment );
+
+
+/* For 4ub rgba values.
+ */
+typedef struct {
+   GLubyte (*data)[4];
+   GLubyte *start;
+   GLuint count;
+   GLuint stride;
+   GLuint flags;
+   void *storage;
+} GLvector4ub;
+
+extern void _mesa_vector4ub_init( GLvector4ub *v, GLuint flags,
+			       GLubyte (*storage)[4] );
+extern void _mesa_vector4ub_alloc( GLvector4ub *v, GLuint flags, GLuint count,
+				GLuint alignment );
+extern void _mesa_vector4ub_free( GLvector4ub * );
+
+
+/* For 4 * GLchan values.
+ */
+typedef struct {
+   GLchan (*data)[4];
+   GLchan *start;
+   GLuint count;
+   GLuint stride;
+   GLuint flags;
+   void *storage;
+} GLvector4chan;
+
+extern void _mesa_vector4chan_init( GLvector4chan *v, GLuint flags,
+				 GLchan (*storage)[4] );
+extern void _mesa_vector4chan_alloc( GLvector4chan *v, GLuint flags, GLuint count,
+				  GLuint alignment );
+extern void _mesa_vector4chan_free( GLvector4chan * );
+
+
+
+
+/* For 4 * GLushort rgba values.
+ */
+typedef struct {
+   GLushort (*data)[4];
+   GLushort *start;
+   GLuint count;
+   GLuint stride;
+   GLuint flags;
+   void *storage;
+} GLvector4us;
+
+extern void _mesa_vector4us_init( GLvector4us *v, GLuint flags,
+                               GLushort (*storage)[4] );
+extern void _mesa_vector4us_alloc( GLvector4us *v, GLuint flags, GLuint count,
+                                GLuint alignment );
+extern void _mesa_vector4us_free( GLvector4us * );
+
+
+
+
+/* For 1ub values, eg edgeflag.
+ */
+typedef struct {
+   GLubyte *data;
+   GLubyte *start;
+   GLuint count;
+   GLuint stride;
+   GLuint flags;
+   void *storage;
+} GLvector1ub;
+
+extern void _mesa_vector1ub_init( GLvector1ub *v, GLuint flags, GLubyte *storage);
+extern void _mesa_vector1ub_alloc( GLvector1ub *v, GLuint flags, GLuint count,
+				GLuint alignment );
+extern void _mesa_vector1ub_free( GLvector1ub * );
+
+
+
+
+/* For, eg Index, Array element.
+ */
+typedef struct {
+   GLuint *data;
+   GLuint *start;
+   GLuint count;
+   GLuint stride;
+   GLuint flags;
+   void *storage;
+} GLvector1ui;
+
+extern void _mesa_vector1ui_init( GLvector1ui *v, GLuint flags, GLuint *storage );
+extern void _mesa_vector1ui_alloc( GLvector1ui *v, GLuint flags, GLuint count,
+				GLuint alignment );
+extern void _mesa_vector1ui_free( GLvector1ui * );
+
+
+
+/*
+ * Given vector <v>, return a pointer (cast to <type *> to the <i>-th element.
+ *
+ * End up doing a lot of slow imuls if not careful.
+ */
+#define VEC_ELT( v, type, i ) \
+       ( (type *)  ( ((GLbyte *) ((v)->data)) + (i) * (v)->stride) )
+
+
+#endif
Index: xc/extras/Mesa/src/math/m_vertices.c
diff -u /dev/null xc/extras/Mesa/src/math/m_vertices.c:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_vertices.c	Mon Dec 16 11:18:37 2002
@@ -0,0 +1,214 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "macros.h"
+
+#include "m_vertices.h"
+#include "m_xform.h"
+
+#if defined(USE_X86_ASM)
+#include "X86/common_x86_asm.h"
+#endif
+
+
+/* The start of a bunch of vertex oriented geometry routines.  These
+ * are expected to support the production of driver-specific fast paths
+ * for CVA and eventually normal processing.
+ *
+ * These have been taken from fxfastpath.c, and are now also used in
+ * the mga driver.
+ *
+ * These should grow to include:
+ *     - choice of 8/16 dword vertices
+ *     - ??
+ *     - use of portable assembly layouts.
+ *
+ * More tentatively:
+ *     - more (all?) matrix types
+ *     - more (?) vertex sizes
+ *
+ * -- Keith Whitwell.
+ */
+
+/* The inline 3dnow code seems to give problems with some peoples
+ * compiler/binutils.
+ */
+/*  #undef USE_3DNOW_ASM */
+
+
+#if defined(USE_X86_ASM) && defined(__GNUC__)
+
+
+#endif
+
+
+/*
+ * Transform an array of coordinates by an arbitrary 4x4 matrix.
+ * Output:  f - the results vector [][16]
+ * Input:   m - the 4x4 matrix
+ *          obj - pointer to first 4-component coordinate
+ *          obj_stride - stride in bytes between input coordinates
+ *          count - number of coordinates to transform
+ */
+static void _PROJAPI transform_v16( GLfloat *f,
+				    const GLfloat *m,
+				    const GLfloat *obj,
+				    GLuint obj_stride,
+				    GLuint count )
+{
+   GLuint i;
+
+   for (i = 0; i < count; i++, STRIDE_F(obj, obj_stride), f += 16) {
+      const GLfloat ox = obj[0], oy = obj[1], oz = obj[2];
+      f[0] = m[0] * ox + m[4] * oy + m[8]  * oz + m[12];
+      f[1] = m[1] * ox + m[5] * oy + m[9]  * oz + m[13];
+      f[2] = m[2] * ox + m[6] * oy + m[10] * oz + m[14];
+      f[3] = m[3] * ox + m[7] * oy + m[11] * oz + m[15];
+   }
+}
+
+
+/*
+ * Compute the view frustum clipmask for an array of vertices.
+ * Input:  first - pointer to first vertex to process
+ *                 (the stride must be 16 floats between coordinates)
+ *         last - pointer to vertex just after the last vertex to process
+ * Input/output:  p_clipOr - the bitwise-OR of all vertex clipmasks
+ *                p_clipAnd - the bitwise-AND of all vertex clipmasks
+ * Output:  clipmask - the clipmask for each vertex
+ */
+static void _PROJAPI cliptest_v16( GLfloat *firstVertex,
+				   GLfloat *lastVertex,
+				   GLubyte *p_clipOr,
+				   GLubyte *p_clipAnd,
+				   GLubyte *clipmask )
+{
+   GLubyte clipAnd = (GLubyte) ~0;
+   GLubyte clipOr = 0;
+   GLfloat *v = firstVertex;
+   static int i;
+   i = 0;
+
+   for ( ; v != lastVertex; v += 16, clipmask++, i++) {
+      const GLfloat cx = v[0];
+      const GLfloat cy = v[1];
+      const GLfloat cz = v[2];
+      const GLfloat cw = v[3];
+      GLubyte mask = 0;
+
+      if (cx >  cw) mask |= CLIP_RIGHT_BIT;
+      if (cx < -cw) mask |= CLIP_LEFT_BIT;
+      if (cy >  cw) mask |= CLIP_TOP_BIT;
+      if (cy < -cw) mask |= CLIP_BOTTOM_BIT;
+      if (cz >  cw) mask |= CLIP_FAR_BIT;
+      if (cz < -cw) mask |= CLIP_NEAR_BIT;
+
+      *clipmask = mask;
+      clipAnd &= mask;
+      clipOr |= mask;
+   }
+
+   (*p_clipOr) |= clipOr;
+   (*p_clipAnd) &= clipAnd;
+}
+
+
+/*
+ * Project all vertices upto but not including last.  Guarenteed to be at
+ * least one such vertex.
+ * Input:  firstVertex - pointer to first vertex
+ *         lastVertex - pointer to vertex just afte the last to transform
+ *         m - 4x4 matrix, we only look at the scale and translate terms
+ *         stride - stride in bytes between coordinates
+ */
+static void _PROJAPI project_verts( GLfloat *firstVertex,
+				    GLfloat *lastVertex,
+				    const GLfloat *m,
+				    GLuint stride )
+{
+   const GLfloat sx = m[0], sy = m[5], sz = m[10];
+   const GLfloat tx = m[12], ty = m[13], tz = m[14];
+   GLfloat *v;
+
+   for (v = firstVertex; v != lastVertex; STRIDE_F(v, stride)) {
+      const GLfloat oow = 1.0F / v[3];
+      v[0] = sx * v[0] * oow + tx;
+      v[1] = sy * v[1] * oow + ty;
+      v[2] = sz * v[2] * oow + tz;
+      v[3] = oow;
+   }
+}
+
+/*
+ * Same as the above function, except only process coordinate [i] if
+ * clipmask[i] is zero.
+ */
+static void _PROJAPI project_clipped_verts( GLfloat *firstVertex,
+					    GLfloat *lastVertex,
+					    const GLfloat *m,
+					    GLuint stride,
+					    const GLubyte clipmask[] )
+{
+   const GLfloat sx = m[0], sy = m[5], sz = m[10];
+   const GLfloat tx = m[12], ty = m[13], tz = m[14];
+   GLfloat *v;
+
+   for (v = firstVertex; v != lastVertex; STRIDE_F(v, stride), clipmask++) {
+      if (!(*clipmask)) {
+	 const GLfloat oow = 1.0F / v[3];
+	 v[0] = sx * v[0] * oow + tx;
+	 v[1] = sy * v[1] * oow + ty;
+	 v[2] = sz * v[2] * oow + tz;
+	 v[3] = oow;
+      }
+   }
+}
+
+
+_mesa_transform_func		_mesa_xform_points3_v16_general = 0;
+_mesa_cliptest_func		_mesa_cliptest_points4_v16 = 0;
+_mesa_project_func		_mesa_project_v16 = 0;
+_mesa_project_clipped_func	_mesa_project_clipped_v16 = 0;
+
+
+void
+_math_init_vertices( void )
+{
+   _mesa_xform_points3_v16_general	= transform_v16;
+   _mesa_cliptest_points4_v16	= cliptest_v16;
+   _mesa_project_v16		= project_verts;
+   _mesa_project_clipped_v16	= project_clipped_verts;
+
+#if 0
+   /* GH: Add tests/benchmarks for the vertex asm */
+   gl_test_all_vertex_functions( "default" );
+#endif
+
+#ifdef USE_X86_ASM
+   _mesa_init_all_x86_vertex_asm();
+#endif
+}
Index: xc/extras/Mesa/src/math/m_vertices.h
diff -u /dev/null xc/extras/Mesa/src/math/m_vertices.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_vertices.h	Mon Dec 16 11:18:37 2002
@@ -0,0 +1,84 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _M_VERTICES_H_
+#define _M_VERTICES_H_
+
+#ifdef USE_X86_ASM
+#define _PROJAPI _ASMAPI
+#define _PROJAPIP _ASMAPIP
+#else
+#define _PROJAPI
+#define _PROJAPIP *
+#endif
+
+
+/*
+ * Some handy functions for "fastpath" vertex processing in DRI drivers.
+ */
+
+
+typedef void (_PROJAPIP _mesa_transform_func)( GLfloat *first_vert,
+                                               const GLfloat *m,
+                                               const GLfloat *src,
+                                               GLuint src_stride,
+                                               GLuint count );
+
+/* use count instead of last vert? */
+typedef void (_PROJAPIP _mesa_cliptest_func)( GLfloat *first_vert,
+                                              GLfloat *last_vert,
+                                              GLubyte *or_mask,
+                                              GLubyte *and_mask,
+                                              GLubyte *clip_mask );
+
+typedef void (_PROJAPIP _mesa_project_func)( GLfloat *first,
+                                             GLfloat *last,
+                                             const GLfloat *m,
+                                             GLuint stride );
+
+typedef void (_PROJAPIP _mesa_project_clipped_func)( GLfloat *first,
+                                                     GLfloat *last,
+                                                     const GLfloat *m,
+                                                     GLuint stride,
+                                                     const GLubyte *clipmask );
+
+typedef void (_PROJAPIP gl_vertex_interp_func)( GLfloat t,
+						GLfloat *result,
+						const GLfloat *in,
+						const GLfloat *out );
+
+
+extern _mesa_transform_func       _mesa_xform_points3_v16_general;
+extern _mesa_cliptest_func        _mesa_cliptest_points4_v16;
+extern _mesa_project_func         _mesa_project_v16;
+extern _mesa_project_clipped_func _mesa_project_clipped_v16;
+
+
+extern void
+_math_init_vertices( void );
+
+
+#endif
Index: xc/extras/Mesa/src/math/m_xform.c
diff -u /dev/null xc/extras/Mesa/src/math/m_xform.c:1.3
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_xform.c	Mon Dec 16 11:18:37 2002
@@ -0,0 +1,224 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Matrix/vertex/vector transformation stuff
+ *
+ *
+ * NOTES:
+ * 1. 4x4 transformation matrices are stored in memory in column major order.
+ * 2. Points/vertices are to be thought of as column vectors.
+ * 3. Transformation of a point p by a matrix M is: p' = M * p
+ */
+
+#include <math.h>
+
+#include "glheader.h"
+#include "macros.h"
+#include "mmath.h"
+
+#include "m_eval.h"
+#include "m_matrix.h"
+#include "m_translate.h"
+#include "m_xform.h"
+#include "mathmod.h"
+
+
+#ifdef DEBUG
+#include "m_debug.h"
+#endif
+
+#ifdef USE_X86_ASM
+#include "X86/common_x86_asm.h"
+#endif
+
+#ifdef USE_SPARC_ASM
+#include "SPARC/sparc.h"
+#endif
+
+clip_func _mesa_clip_tab[5];
+clip_func _mesa_clip_np_tab[5];
+dotprod_func _mesa_dotprod_tab[5];
+vec_copy_func _mesa_copy_tab[0x10];
+normal_func _mesa_normal_tab[0xf];
+transform_func *_mesa_transform_tab[5];
+
+
+/* Raw data format used for:
+ *    - Object-to-eye transform prior to culling, although this too
+ *      could be culled under some circumstances.
+ *    - Eye-to-clip transform (via the function above).
+ *    - Cliptesting
+ *    - And everything else too, if culling happens to be disabled.
+ *
+ * GH: It's used for everything now, as clipping/culling is done
+ *     elsewhere (most often by the driver itself).
+ */
+#define TAG(x) x
+#define TAG2(x,y) x##y
+#define STRIDE_LOOP for ( i = 0 ; i < count ; i++, STRIDE_F(from, stride) )
+#define LOOP for ( i = 0 ; i < n ; i++ )
+#define ARGS
+#include "m_xform_tmp.h"
+#include "m_clip_tmp.h"
+#include "m_norm_tmp.h"
+#include "m_dotprod_tmp.h"
+#include "m_copy_tmp.h"
+#undef TAG
+#undef TAG2
+#undef LOOP
+#undef ARGS
+
+
+
+
+GLvector4f *_mesa_project_points( GLvector4f *proj_vec,
+				  const GLvector4f *clip_vec )
+{
+   const GLuint stride = clip_vec->stride;
+   const GLfloat *from = (GLfloat *)clip_vec->start;
+   const GLuint count = clip_vec->count;
+   GLfloat (*vProj)[4] = (GLfloat (*)[4])proj_vec->start;
+   GLuint i;
+
+   for (i = 0 ; i < count ; i++, STRIDE_F(from, stride))
+   {
+	 GLfloat oow = 1.0F / from[3];
+	 vProj[i][3] = oow;
+	 vProj[i][0] = from[0] * oow;
+	 vProj[i][1] = from[1] * oow;
+	 vProj[i][2] = from[2] * oow;
+   }
+
+   proj_vec->flags |= VEC_SIZE_4;
+   proj_vec->size = 3;
+   proj_vec->count = clip_vec->count;
+   return proj_vec;
+}
+
+
+
+
+
+
+/*
+ * Transform a 4-element row vector (1x4 matrix) by a 4x4 matrix.  This
+ * function is used for transforming clipping plane equations and spotlight
+ * directions.
+ * Mathematically,  u = v * m.
+ * Input:  v - input vector
+ *         m - transformation matrix
+ * Output:  u - transformed vector
+ */
+void _mesa_transform_vector( GLfloat u[4], const GLfloat v[4], const GLfloat m[16] )
+{
+   GLfloat v0=v[0], v1=v[1], v2=v[2], v3=v[3];
+#define M(row,col)  m[row + col*4]
+   u[0] = v0 * M(0,0) + v1 * M(1,0) + v2 * M(2,0) + v3 * M(3,0);
+   u[1] = v0 * M(0,1) + v1 * M(1,1) + v2 * M(2,1) + v3 * M(3,1);
+   u[2] = v0 * M(0,2) + v1 * M(1,2) + v2 * M(2,2) + v3 * M(3,2);
+   u[3] = v0 * M(0,3) + v1 * M(1,3) + v2 * M(2,3) + v3 * M(3,3);
+#undef M
+}
+
+
+/* Useful for one-off point transformations, as in clipping.
+ * Note that because the matrix isn't analysed we do too many
+ * multiplies, and that the result is always 4-clean.
+ */
+void _mesa_transform_point_sz( GLfloat Q[4], const GLfloat M[16],
+			    const GLfloat P[4], GLuint sz )
+{
+   if (Q == P)
+      return;
+
+   if (sz == 4)
+   {
+      Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12] * P[3];
+      Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13] * P[3];
+      Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3];
+      Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3];
+   }
+   else if (sz == 3)
+   {
+      Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12];
+      Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13];
+      Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14];
+      Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15];
+   }
+   else if (sz == 2)
+   {
+      Q[0] = M[0] * P[0] + M[4] * P[1] +                M[12];
+      Q[1] = M[1] * P[0] + M[5] * P[1] +                M[13];
+      Q[2] = M[2] * P[0] + M[6] * P[1] +                M[14];
+      Q[3] = M[3] * P[0] + M[7] * P[1] +                M[15];
+   }
+   else if (sz == 1)
+   {
+      Q[0] = M[0] * P[0] +                              M[12];
+      Q[1] = M[1] * P[0] +                              M[13];
+      Q[2] = M[2] * P[0] +                              M[14];
+      Q[3] = M[3] * P[0] +                              M[15];
+   }
+}
+
+
+/*
+ * This is called only once.  It initializes several tables with pointers
+ * to optimized transformation functions.  This is where we can test for
+ * AMD 3Dnow! capability, Intel SSE, etc. and hook in the right code.
+ */
+void
+_math_init_transformation( void )
+{
+   init_c_transformations();
+   init_c_norm_transform();
+   init_c_cliptest();
+   init_copy0();
+   init_dotprod();
+
+#ifdef DEBUG
+   _math_test_all_transform_functions( "default" );
+   _math_test_all_normal_transform_functions( "default" );
+   _math_test_all_cliptest_functions( "default" );
+#endif
+
+#ifdef USE_X86_ASM
+   _mesa_init_all_x86_transform_asm();
+#endif
+#ifdef USE_SPARC_ASM
+   _mesa_init_all_sparc_transform_asm();
+#endif
+}
+
+void
+_math_init( void )
+{
+   _math_init_transformation();
+   _math_init_translate();
+   _math_init_vertices();
+   _math_init_eval();
+}
Index: xc/extras/Mesa/src/math/m_xform.h
diff -u /dev/null xc/extras/Mesa/src/math/m_xform.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_xform.h	Mon Dec 16 11:18:37 2002
@@ -0,0 +1,216 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+
+
+
+#ifndef _M_XFORM_H
+#define _M_XFORM_H
+
+
+#include "glheader.h"
+#include "config.h"
+#include "math/m_vector.h"
+#include "math/m_matrix.h"
+
+#ifdef USE_X86_ASM
+#define _XFORMAPI _ASMAPI
+#define _XFORMAPIP _ASMAPIP
+#else
+#define _XFORMAPI
+#define _XFORMAPIP *
+#endif
+
+/*
+ * Transform a point (column vector) by a matrix:   Q = M * P
+ */
+#define TRANSFORM_POINT( Q, M, P )					\
+   Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12] * P[3];	\
+   Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13] * P[3];	\
+   Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14] * P[3];	\
+   Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15] * P[3];
+
+
+#define TRANSFORM_POINT3( Q, M, P )				\
+   Q[0] = M[0] * P[0] + M[4] * P[1] + M[8] *  P[2] + M[12];	\
+   Q[1] = M[1] * P[0] + M[5] * P[1] + M[9] *  P[2] + M[13];	\
+   Q[2] = M[2] * P[0] + M[6] * P[1] + M[10] * P[2] + M[14];	\
+   Q[3] = M[3] * P[0] + M[7] * P[1] + M[11] * P[2] + M[15];
+
+
+/*
+ * Transform a normal (row vector) by a matrix:  [NX NY NZ] = N * MAT
+ */
+#define TRANSFORM_NORMAL( TO, N, MAT )				\
+do {								\
+   TO[0] = N[0] * MAT[0] + N[1] * MAT[1] + N[2] * MAT[2];	\
+   TO[1] = N[0] * MAT[4] + N[1] * MAT[5] + N[2] * MAT[6];	\
+   TO[2] = N[0] * MAT[8] + N[1] * MAT[9] + N[2] * MAT[10];	\
+} while (0)
+
+
+extern void _mesa_transform_vector( GLfloat u[4],
+				 CONST GLfloat v[4],
+                                 CONST GLfloat m[16] );
+
+
+extern void
+_math_init_transformation( void );
+
+
+/* KW: Clip functions now do projective divide as well.  The projected
+ * coordinates are very useful to us because they let us cull
+ * backfaces and eliminate vertices from lighting, fogging, etc
+ * calculations.  Despite the fact that this divide could be done one
+ * day in hardware, we would still have a reason to want to do it here
+ * as long as those other calculations remain in software.
+ *
+ * Clipping is a convenient place to do the divide on x86 as it should be
+ * possible to overlap with integer outcode calculations.
+ *
+ * There are two cases where we wouldn't want to do the divide in cliptest:
+ *    - When we aren't clipping.  We still might want to cull backfaces
+ *      so the divide should be done elsewhere.  This currently never
+ *      happens.
+ *
+ *    - When culling isn't likely to help us, such as when the GL culling
+ *      is disabled and we not lighting or are only lighting
+ *      one-sided.  In this situation, backface determination provides
+ *      us with no useful information.  A tricky case to detect is when
+ *      all input data is already culled, although hopefully the
+ *      application wouldn't turn on culling in such cases.
+ *
+ * We supply a buffer to hold the [x/w,y/w,z/w,1/w] values which
+ * are the result of the projection.  This is only used in the
+ * 4-vector case - in other cases, we just use the clip coordinates
+ * as the projected coordinates - they are identical.
+ *
+ * This is doubly convenient because it means the Win[] array is now
+ * of the same stride as all the others, so I can now turn map_vertices
+ * into a straight-forward matrix transformation, with asm acceleration
+ * automatically available.
+ */
+
+/* Vertex buffer clipping flags
+ */
+#define CLIP_RIGHT_SHIFT 	0
+#define CLIP_LEFT_SHIFT 	1
+#define CLIP_TOP_SHIFT  	2
+#define CLIP_BOTTOM_SHIFT       3
+#define CLIP_NEAR_SHIFT  	4
+#define CLIP_FAR_SHIFT  	5
+
+#define CLIP_RIGHT_BIT   0x01
+#define CLIP_LEFT_BIT    0x02
+#define CLIP_TOP_BIT     0x04
+#define CLIP_BOTTOM_BIT  0x08
+#define CLIP_NEAR_BIT    0x10
+#define CLIP_FAR_BIT     0x20
+#define CLIP_USER_BIT    0x40
+#define CLIP_ALL_BITS    0x3f
+
+
+typedef GLvector4f * (_XFORMAPIP clip_func)( GLvector4f *vClip,
+					     GLvector4f *vProj,
+					     GLubyte clipMask[],
+					     GLubyte *orMask,
+					     GLubyte *andMask );
+
+typedef void (*dotprod_func)( GLfloat *out,
+			      GLuint out_stride,
+			      CONST GLvector4f *coord_vec,
+			      CONST GLfloat plane[4] );
+
+typedef void (*vec_copy_func)( GLvector4f *to,
+			       CONST GLvector4f *from );
+
+
+
+/*
+ * Functions for transformation of normals in the VB.
+ */
+typedef void (_NORMAPIP normal_func)( CONST GLmatrix *mat,
+				      GLfloat scale,
+				      CONST GLvector3f *in,
+				      CONST GLfloat lengths[],
+				      GLvector3f *dest );
+
+
+/* Flags for selecting a normal transformation function.
+ */
+#define NORM_RESCALE   0x1		/* apply the scale factor */
+#define NORM_NORMALIZE 0x2		/* normalize */
+#define NORM_TRANSFORM 0x4		/* apply the transformation matrix */
+#define NORM_TRANSFORM_NO_ROT 0x8	/* apply the transformation matrix */
+
+
+
+
+/* KW: New versions of the transform function allow a mask array
+ *     specifying that individual vector transform should be skipped
+ *     when the mask byte is zero.  This is always present as a
+ *     parameter, to allow a unified interface.
+ */
+typedef void (_XFORMAPIP transform_func)( GLvector4f *to_vec,
+					  CONST GLfloat m[16],
+					  CONST GLvector4f *from_vec );
+
+
+extern GLvector4f *_mesa_project_points( GLvector4f *to,
+					 CONST GLvector4f *from );
+
+extern void _mesa_transform_bounds3( GLubyte *orMask, GLubyte *andMask,
+				     CONST GLfloat m[16],
+				     CONST GLfloat src[][3] );
+
+extern void _mesa_transform_bounds2( GLubyte *orMask, GLubyte *andMask,
+				     CONST GLfloat m[16],
+				     CONST GLfloat src[][3] );
+
+
+extern dotprod_func  _mesa_dotprod_tab[5];
+extern vec_copy_func _mesa_copy_tab[0x10];
+extern vec_copy_func _mesa_copy_clean_tab[5];
+extern clip_func     _mesa_clip_tab[5];
+extern clip_func     _mesa_clip_np_tab[5];
+extern normal_func   _mesa_normal_tab[0xf];
+
+/* Use of 2 layers of linked 1-dimensional arrays to reduce
+ * cost of lookup.
+ */
+extern transform_func *_mesa_transform_tab[5];
+
+
+extern void _mesa_transform_point_sz( GLfloat Q[4], CONST GLfloat M[16],
+				      CONST GLfloat P[4], GLuint sz );
+
+
+#define TransformRaw( to, mat, from ) \
+   ( _mesa_transform_tab[(from)->size][(mat)->type]( to, (mat)->m, from ), \
+     (to) )
+
+
+#endif
Index: xc/extras/Mesa/src/math/m_xform_tmp.h
diff -u /dev/null xc/extras/Mesa/src/math/m_xform_tmp.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/m_xform_tmp.h	Mon Dec 16 11:18:37 2002
@@ -0,0 +1,806 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * New (3.1) transformation code written by Keith Whitwell.
+ */
+
+
+/*----------------------------------------------------------------------
+ * Begin Keith's new code
+ *
+ *----------------------------------------------------------------------
+ */
+
+/* KW: Fixed stride, now measured in bytes as is the OpenGL array stride.
+ */
+
+/* KW: These are now parameterized to produce two versions, one
+ *     which transforms all incoming points, and a second which
+ *     takes notice of a cullmask array, and only transforms
+ *     unculled vertices.
+ */
+
+/* KW: 1-vectors can sneak into the texture pipeline via the array
+ *     interface.  These functions are here because I want consistant
+ *     treatment of the vertex sizes and a lazy strategy for
+ *     cleaning unused parts of the vector, and so as not to exclude
+ *     them from the vertex array interface.
+ *
+ *     Under our current analysis of matrices, there is no way that
+ *     the product of a matrix and a 1-vector can remain a 1-vector,
+ *     with the exception of the identity transform.
+ */
+
+/* KW: No longer zero-pad outgoing vectors.  Now that external
+ *     vectors can get into the pipeline we cannot ever assume
+ *     that there is more to a vector than indicated by its
+ *     size.
+ */
+
+/* KW: Now uses clipmask and a flag to allow us to skip both/either
+ *     cliped and/or culled vertices.
+ */
+
+/* GH: Not any more -- it's easier (and faster) to just process the
+ *     entire vector.  Clipping and culling are handled further down
+ *     the pipe, most often during or after the conversion to some
+ *     driver-specific vertex format.
+ */
+
+static void _XFORMAPI
+TAG(transform_points1_general)( GLvector4f *to_vec,
+				const GLfloat m[16],
+				const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0],  m12 = m[12];
+   const GLfloat m1 = m[1],  m13 = m[13];
+   const GLfloat m2 = m[2],  m14 = m[14];
+   const GLfloat m3 = m[3],  m15 = m[15];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] = m1 * ox + m13;
+      to[i][2] = m2 * ox + m14;
+      to[i][3] = m3 * ox + m15;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points1_identity)( GLvector4f *to_vec,
+				 const GLfloat m[16],
+				 const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLuint count = from_vec->count;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint i;
+   if (to_vec == from_vec) return;
+   STRIDE_LOOP {
+      to[i][0] = from[0];
+   }
+   to_vec->size = 1;
+   to_vec->flags |= VEC_SIZE_1;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points1_2d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1];
+   const GLfloat m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] = m1 * ox + m13;
+   }
+   to_vec->size = 2;
+   to_vec->flags |= VEC_SIZE_2;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points1_2d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] =           m13;
+   }
+   to_vec->size = 2;
+   to_vec->flags |= VEC_SIZE_2;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points1_3d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2];
+   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox + m12;
+      to[i][1] = m1 * ox + m13;
+      to[i][2] = m2 * ox + m14;
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+
+static void _XFORMAPI
+TAG(transform_points1_3d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0];
+   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox           + m12;
+      to[i][1] =                     m13;
+      to[i][2] =                     m14;
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points1_perspective)( GLvector4f *to_vec,
+				    const GLfloat m[16],
+				    const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0];
+      to[i][0] = m0 * ox                ;
+      to[i][1] =           0            ;
+      to[i][2] =                     m14;
+      to[i][3] = 0;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+
+
+
+/* 2-vectors, which are a lot more relevant than 1-vectors, are
+ * present early in the geometry pipeline and throughout the
+ * texture pipeline.
+ */
+static void _XFORMAPI
+TAG(transform_points2_general)( GLvector4f *to_vec,
+				const GLfloat m[16],
+				const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0],  m4 = m[4],  m12 = m[12];
+   const GLfloat m1 = m[1],  m5 = m[5],  m13 = m[13];
+   const GLfloat m2 = m[2],  m6 = m[6],  m14 = m[14];
+   const GLfloat m3 = m[3],  m7 = m[7],  m15 = m[15];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox + m4 * oy + m12;
+      to[i][1] = m1 * ox + m5 * oy + m13;
+      to[i][2] = m2 * ox + m6 * oy + m14;
+      to[i][3] = m3 * ox + m7 * oy + m15;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points2_identity)( GLvector4f *to_vec,
+				 const GLfloat m[16],
+				 const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   GLuint i;
+   if (to_vec == from_vec) return;
+   STRIDE_LOOP {
+      to[i][0] = from[0];
+      to[i][1] = from[1];
+   }
+   to_vec->size = 2;
+   to_vec->flags |= VEC_SIZE_2;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points2_2d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
+   const GLfloat m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox + m4 * oy + m12;
+      to[i][1] = m1 * ox + m5 * oy + m13;
+   }
+   to_vec->size = 2;
+   to_vec->flags |= VEC_SIZE_2;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points2_2d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox           + m12;
+      to[i][1] =           m5 * oy + m13;
+   }
+   to_vec->size = 2;
+   to_vec->flags |= VEC_SIZE_2;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points2_3d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
+   const GLfloat m6 = m[6], m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox + m4 * oy + m12;
+      to[i][1] = m1 * ox + m5 * oy + m13;
+      to[i][2] = m2 * ox + m6 * oy + m14;
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+
+/* I would actually say this was a fairly important function, from
+ * a texture transformation point of view.
+ */
+static void _XFORMAPI
+TAG(transform_points2_3d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5];
+   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox           + m12;
+      to[i][1] =           m5 * oy + m13;
+      to[i][2] =                     m14;
+   }
+   if (m14 == 0) {
+      to_vec->size = 2;
+      to_vec->flags |= VEC_SIZE_2;
+   } else {
+      to_vec->size = 3;
+      to_vec->flags |= VEC_SIZE_3;
+   }
+   to_vec->count = from_vec->count;
+}
+
+
+static void _XFORMAPI
+TAG(transform_points2_perspective)( GLvector4f *to_vec,
+				    const GLfloat m[16],
+				    const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1];
+      to[i][0] = m0 * ox                ;
+      to[i][1] =           m5 * oy      ;
+      to[i][2] =                     m14;
+      to[i][3] = 0;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+
+
+static void _XFORMAPI
+TAG(transform_points3_general)( GLvector4f *to_vec,
+				const GLfloat m[16],
+				const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8],  m12 = m[12];
+   const GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9],  m13 = m[13];
+   const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
+   const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12;
+      to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14;
+      to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points3_identity)( GLvector4f *to_vec,
+				 const GLfloat m[16],
+				 const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   GLuint i;
+   if (to_vec == from_vec) return;
+   STRIDE_LOOP {
+      to[i][0] = from[0];
+      to[i][1] = from[1];
+      to[i][2] = from[2];
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points3_2d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
+   const GLfloat m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox + m4 * oy            + m12       ;
+      to[i][1] = m1 * ox + m5 * oy            + m13       ;
+      to[i][2] =                   +       oz             ;
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points3_2d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox                      + m12       ;
+      to[i][1] =           m5 * oy            + m13       ;
+      to[i][2] =                   +       oz             ;
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points3_3d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
+   const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
+   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12       ;
+      to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13       ;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14       ;
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+/* previously known as ortho...
+ */
+static void _XFORMAPI
+TAG(transform_points3_3d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5];
+   const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox                      + m12       ;
+      to[i][1] =           m5 * oy            + m13       ;
+      to[i][2] =                     m10 * oz + m14       ;
+   }
+   to_vec->size = 3;
+   to_vec->flags |= VEC_SIZE_3;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points3_perspective)( GLvector4f *to_vec,
+				    const GLfloat m[16],
+				    const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
+   const GLfloat m10 = m[10], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2];
+      to[i][0] = m0 * ox           + m8  * oz       ;
+      to[i][1] =           m5 * oy + m9  * oz       ;
+      to[i][2] =                     m10 * oz + m14 ;
+      to[i][3] =                          -oz       ;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+
+
+static void _XFORMAPI
+TAG(transform_points4_general)( GLvector4f *to_vec,
+				const GLfloat m[16],
+				const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0],  m4 = m[4],  m8 = m[8],  m12 = m[12];
+   const GLfloat m1 = m[1],  m5 = m[5],  m9 = m[9],  m13 = m[13];
+   const GLfloat m2 = m[2],  m6 = m[6],  m10 = m[10],  m14 = m[14];
+   const GLfloat m3 = m[3],  m7 = m[7],  m11 = m[11],  m15 = m[15];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox + m4 * oy + m8  * oz + m12 * ow;
+      to[i][1] = m1 * ox + m5 * oy + m9  * oz + m13 * ow;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
+      to[i][3] = m3 * ox + m7 * oy + m11 * oz + m15 * ow;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points4_identity)( GLvector4f *to_vec,
+				 const GLfloat m[16],
+				 const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   GLuint i;
+   if (to_vec == from_vec) return;
+   STRIDE_LOOP {
+      to[i][0] = from[0];
+      to[i][1] = from[1];
+      to[i][2] = from[2];
+      to[i][3] = from[3];
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points4_2d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1], m4 = m[4], m5 = m[5];
+   const GLfloat m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox + m4 * oy            + m12 * ow;
+      to[i][1] = m1 * ox + m5 * oy            + m13 * ow;
+      to[i][2] =                   +       oz           ;
+      to[i][3] =                                      ow;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points4_2d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5], m12 = m[12], m13 = m[13];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox                      + m12 * ow;
+      to[i][1] =           m5 * oy            + m13 * ow;
+      to[i][2] =                   +       oz           ;
+      to[i][3] =                                      ow;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points4_3d)( GLvector4f *to_vec,
+			   const GLfloat m[16],
+			   const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m1 = m[1], m2 = m[2], m4 = m[4], m5 = m[5];
+   const GLfloat m6 = m[6], m8 = m[8], m9 = m[9], m10 = m[10];
+   const GLfloat m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox + m4 * oy +  m8 * oz + m12 * ow;
+      to[i][1] = m1 * ox + m5 * oy +  m9 * oz + m13 * ow;
+      to[i][2] = m2 * ox + m6 * oy + m10 * oz + m14 * ow;
+      to[i][3] =                                      ow;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points4_3d_no_rot)( GLvector4f *to_vec,
+				  const GLfloat m[16],
+				  const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5];
+   const GLfloat m10 = m[10], m12 = m[12], m13 = m[13], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox                      + m12 * ow;
+      to[i][1] =           m5 * oy            + m13 * ow;
+      to[i][2] =                     m10 * oz + m14 * ow;
+      to[i][3] =                                      ow;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static void _XFORMAPI
+TAG(transform_points4_perspective)( GLvector4f *to_vec,
+				    const GLfloat m[16],
+				    const GLvector4f *from_vec )
+{
+   const GLuint stride = from_vec->stride;
+   GLfloat *from = from_vec->start;
+   GLfloat (*to)[4] = (GLfloat (*)[4])to_vec->start;
+   GLuint count = from_vec->count;
+   const GLfloat m0 = m[0], m5 = m[5], m8 = m[8], m9 = m[9];
+   const GLfloat m10 = m[10], m14 = m[14];
+   GLuint i;
+   STRIDE_LOOP {
+      const GLfloat ox = from[0], oy = from[1], oz = from[2], ow = from[3];
+      to[i][0] = m0 * ox           + m8  * oz            ;
+      to[i][1] =           m5 * oy + m9  * oz            ;
+      to[i][2] =                     m10 * oz + m14 * ow ;
+      to[i][3] =                          -oz            ;
+   }
+   to_vec->size = 4;
+   to_vec->flags |= VEC_SIZE_4;
+   to_vec->count = from_vec->count;
+}
+
+static transform_func _XFORMAPI TAG(transform_tab_1)[7];
+static transform_func _XFORMAPI TAG(transform_tab_2)[7];
+static transform_func _XFORMAPI TAG(transform_tab_3)[7];
+static transform_func _XFORMAPI TAG(transform_tab_4)[7];
+
+/* Similar functions could be called several times, with more highly
+ * optimized routines overwriting the arrays.  This only occurs during
+ * startup.
+ */
+static void _XFORMAPI TAG(init_c_transformations)( void )
+{
+#define TAG_TAB   _mesa_transform_tab
+#define TAG_TAB_1 TAG(transform_tab_1)
+#define TAG_TAB_2 TAG(transform_tab_2)
+#define TAG_TAB_3 TAG(transform_tab_3)
+#define TAG_TAB_4 TAG(transform_tab_4)
+
+   TAG_TAB[1] = TAG_TAB_1;
+   TAG_TAB[2] = TAG_TAB_2;
+   TAG_TAB[3] = TAG_TAB_3;
+   TAG_TAB[4] = TAG_TAB_4;
+
+   /* 1-D points (ie texcoords) */
+   TAG_TAB_1[MATRIX_GENERAL]     = TAG(transform_points1_general);
+   TAG_TAB_1[MATRIX_IDENTITY]    = TAG(transform_points1_identity);
+   TAG_TAB_1[MATRIX_3D_NO_ROT]   = TAG(transform_points1_3d_no_rot);
+   TAG_TAB_1[MATRIX_PERSPECTIVE] = TAG(transform_points1_perspective);
+   TAG_TAB_1[MATRIX_2D]          = TAG(transform_points1_2d);
+   TAG_TAB_1[MATRIX_2D_NO_ROT]   = TAG(transform_points1_2d_no_rot);
+   TAG_TAB_1[MATRIX_3D]          = TAG(transform_points1_3d);
+
+   /* 2-D points */
+   TAG_TAB_2[MATRIX_GENERAL]     = TAG(transform_points2_general);
+   TAG_TAB_2[MATRIX_IDENTITY]    = TAG(transform_points2_identity);
+   TAG_TAB_2[MATRIX_3D_NO_ROT]   = TAG(transform_points2_3d_no_rot);
+   TAG_TAB_2[MATRIX_PERSPECTIVE] = TAG(transform_points2_perspective);
+   TAG_TAB_2[MATRIX_2D]          = TAG(transform_points2_2d);
+   TAG_TAB_2[MATRIX_2D_NO_ROT]   = TAG(transform_points2_2d_no_rot);
+   TAG_TAB_2[MATRIX_3D]          = TAG(transform_points2_3d);
+
+   /* 3-D points */
+   TAG_TAB_3[MATRIX_GENERAL]     = TAG(transform_points3_general);
+   TAG_TAB_3[MATRIX_IDENTITY]    = TAG(transform_points3_identity);
+   TAG_TAB_3[MATRIX_3D_NO_ROT]   = TAG(transform_points3_3d_no_rot);
+   TAG_TAB_3[MATRIX_PERSPECTIVE] = TAG(transform_points3_perspective);
+   TAG_TAB_3[MATRIX_2D]          = TAG(transform_points3_2d);
+   TAG_TAB_3[MATRIX_2D_NO_ROT]   = TAG(transform_points3_2d_no_rot);
+   TAG_TAB_3[MATRIX_3D]          = TAG(transform_points3_3d);
+
+   /* 4-D points */
+   TAG_TAB_4[MATRIX_GENERAL]     = TAG(transform_points4_general);
+   TAG_TAB_4[MATRIX_IDENTITY]    = TAG(transform_points4_identity);
+   TAG_TAB_4[MATRIX_3D_NO_ROT]   = TAG(transform_points4_3d_no_rot);
+   TAG_TAB_4[MATRIX_PERSPECTIVE] = TAG(transform_points4_perspective);
+   TAG_TAB_4[MATRIX_2D]          = TAG(transform_points4_2d);
+   TAG_TAB_4[MATRIX_2D_NO_ROT]   = TAG(transform_points4_2d_no_rot);
+   TAG_TAB_4[MATRIX_3D]          = TAG(transform_points4_3d);
+
+#undef TAG_TAB
+#undef TAG_TAB_1
+#undef TAG_TAB_2
+#undef TAG_TAB_3
+#undef TAG_TAB_4
+}
Index: xc/extras/Mesa/src/math/mathmod.h
diff -u /dev/null xc/extras/Mesa/src/math/mathmod.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/math/mathmod.h	Mon Dec 16 11:18:37 2002
@@ -0,0 +1,31 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef _MESA_MATH_H_
+#define _MESA_MATH_H_
+
+extern void _math_init( void );
+
+#endif
Index: xc/extras/Mesa/src/swrast/NOTES
diff -u /dev/null xc/extras/Mesa/src/swrast/NOTES:1.1.1.1
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/swrast/NOTES	Fri Feb 22 12:14:12 2002
@@ -0,0 +1,55 @@
+INTRODUCTION
+
+Mesa's native software rasterizer.  This module provides the fallback
+paths for rasterization operations and states that aren't accelerated
+in hardware drivers, and as the full rasterization engine in software
+drivers.
+
+The swrast module 'stands alone', relying only on interfaces to core
+mesa and it's own driver interface.  It knows nothing about the tnl or
+other modules, allowing it to be used for fallback paths in future tnl
+schemes without modification.
+
+As well as providing triangle/line/point rasterization functionality,
+the module provides implementations of the pixel operations
+(ReadPixels, etc), and texture operations (CopyTexSubImage) which may
+be plugged in to the core Mesa driver interface where accelerated
+versions of these operations are unavailable.
+
+
+STATE
+
+To create and destroy the module:
+
+	GLboolean _swrast_CreateContext( GLcontext *ctx );
+	void _swrast_DestroyContext( GLcontext *ctx );
+   
+This module tracks state changes internally and maintains derived
+values based on the current state.  For this to work, the driver
+ensure the following funciton is called whenever the state changes and
+the swsetup module is 'awake':
+
+	void _swrast_InvalidateState( GLcontext *ctx, GLuint new_state );
+
+There is no explicit call to put the swrast module to sleep.  
+
+
+CUSTOMIZATION
+
+   void (*choose_point)( GLcontext * );
+   void (*choose_line)( GLcontext * );
+   void (*choose_triangle)( GLcontext * );
+
+Drivers may add additional triangle/line/point functions to swrast by
+overriding these functions.  It is necessary for the driver to be very
+careful that it doesn't return an inappropriate function, eg a
+rasterization function in feedback mode.  See the X11 driver for
+examples.
+
+DRIVER INTERFACE
+
+The swrast device driver provides swrast primarily with span- and
+pixel- level interfaces to a framebuffer, with a few additional hooks
+for locking and setting the read buffer.
+
+See the definition of struct swrast_device_driver in swrast.h.
\ No newline at end of file
Index: xc/extras/Mesa/src/swrast/s_aaline.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_aaline.c:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/swrast/s_aaline.c	Mon Dec 16 11:18:38 2002
@@ -0,0 +1,532 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "swrast/s_aaline.h"
+#include "swrast/s_pb.h"
+#include "swrast/s_context.h"
+#include "swrast/swrast.h"
+#include "mtypes.h"
+#include "mmath.h"
+
+
+#define SUB_PIXEL 4
+
+
+/*
+ * Info about the AA line we're rendering
+ */
+struct LineInfo
+{
+   GLfloat x0, y0;        /* start */
+   GLfloat x1, y1;        /* end */
+   GLfloat dx, dy;        /* direction vector */
+   GLfloat len;           /* length */
+   GLfloat halfWidth;     /* half of line width */
+   GLfloat xAdj, yAdj;    /* X and Y adjustment for quad corners around line */
+   /* for coverage computation */
+   GLfloat qx0, qy0;      /* quad vertices */
+   GLfloat qx1, qy1;
+   GLfloat qx2, qy2;
+   GLfloat qx3, qy3;
+   GLfloat ex0, ey0;      /* quad edge vectors */
+   GLfloat ex1, ey1;
+   GLfloat ex2, ey2;
+   GLfloat ex3, ey3;
+
+   /* DO_Z */
+   GLfloat zPlane[4];
+   /* DO_FOG */
+   GLfloat fPlane[4];
+   /* DO_RGBA */
+   GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
+   /* DO_INDEX */
+   GLfloat iPlane[4];
+   /* DO_SPEC */
+   GLfloat srPlane[4], sgPlane[4], sbPlane[4];
+   /* DO_TEX or DO_MULTITEX */
+   GLfloat sPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat tPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat uPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat vPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat lambda[MAX_TEXTURE_UNITS];
+   GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
+};
+
+
+
+/*
+ * Compute the equation of a plane used to interpolate line fragment data
+ * such as color, Z, texture coords, etc.
+ * Input: (x0, y0) and (x1,y1) are the endpoints of the line.
+ *        z0, and z1 are the end point values to interpolate.
+ * Output:  plane - the plane equation.
+ *
+ * Note: we don't really have enough parameters to specify a plane.
+ * We take the endpoints of the line and compute a plane such that
+ * the cross product of the line vector and the plane normal is
+ * parallel to the projection plane.
+ */
+static void
+compute_plane(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1,
+              GLfloat z0, GLfloat z1, GLfloat plane[4])
+{
+#if 0
+   /* original */
+   const GLfloat px = x1 - x0;
+   const GLfloat py = y1 - y0;
+   const GLfloat pz = z1 - z0;
+   const GLfloat qx = -py;
+   const GLfloat qy = px;
+   const GLfloat qz = 0;
+   const GLfloat a = py * qz - pz * qy;
+   const GLfloat b = pz * qx - px * qz;
+   const GLfloat c = px * qy - py * qx;
+   const GLfloat d = -(a * x0 + b * y0 + c * z0);
+   plane[0] = a;
+   plane[1] = b;
+   plane[2] = c;
+   plane[3] = d;
+#else
+   /* simplified */
+   const GLfloat px = x1 - x0;
+   const GLfloat py = y1 - y0;
+   const GLfloat pz = z0 - z1;
+   const GLfloat a = pz * px;
+   const GLfloat b = pz * py;
+   const GLfloat c = px * px + py * py;
+   const GLfloat d = -(a * x0 + b * y0 + c * z0);
+   if (a == 0.0 && b == 0.0 && c == 0.0 && d == 0.0) {
+      plane[0] = 0.0;
+      plane[1] = 0.0;
+      plane[2] = 1.0;
+      plane[3] = 0.0;
+   }
+   else {
+      plane[0] = a;
+      plane[1] = b;
+      plane[2] = c;
+      plane[3] = d;
+   }
+#endif
+}
+
+
+static INLINE void
+constant_plane(GLfloat value, GLfloat plane[4])
+{
+   plane[0] = 0.0;
+   plane[1] = 0.0;
+   plane[2] = -1.0;
+   plane[3] = value;
+}
+
+
+static INLINE GLfloat
+solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
+   return z;
+}
+
+#define SOLVE_PLANE(X, Y, PLANE) \
+   ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])
+
+
+/*
+ * Return 1 / solve_plane().
+ */
+static INLINE GLfloat
+solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+   const GLfloat denom = plane[3] + plane[0] * x + plane[1] * y;
+   if (denom == 0.0)
+      return 0.0;
+   else
+      return -plane[2] / denom;
+}
+
+
+/*
+ * Solve plane and return clamped GLchan value.
+ */
+static INLINE GLchan
+solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+   GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2] + 0.5F;
+   if (z < 0.0F)
+      return 0;
+   else if (z > CHAN_MAXF)
+      return (GLchan) CHAN_MAXF;
+   return (GLchan) (GLint) z;
+}
+
+
+/*
+ * Compute mipmap level of detail.
+ */
+static INLINE GLfloat
+compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4],
+               GLfloat invQ, GLfloat width, GLfloat height)
+{
+   GLfloat dudx = sPlane[0] / sPlane[2] * invQ * width;
+   GLfloat dudy = sPlane[1] / sPlane[2] * invQ * width;
+   GLfloat dvdx = tPlane[0] / tPlane[2] * invQ * height;
+   GLfloat dvdy = tPlane[1] / tPlane[2] * invQ * height;
+   GLfloat r1 = dudx * dudx + dudy * dudy;
+   GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
+   GLfloat rho2 = r1 + r2;
+   /* return log base 2 of rho */
+   if (rho2 == 0.0F)
+      return 0.0;
+   else
+      return (GLfloat) (log(rho2) * 1.442695 * 0.5);/* 1.442695 = 1/log(2) */
+}
+
+
+
+
+/*
+ * Fill in the samples[] array with the (x,y) subpixel positions of
+ * xSamples * ySamples sample positions.
+ * Note that the four corner samples are put into the first four
+ * positions of the array.  This allows us to optimize for the common
+ * case of all samples being inside the polygon.
+ */
+static void
+make_sample_table(GLint xSamples, GLint ySamples, GLfloat samples[][2])
+{
+   const GLfloat dx = 1.0F / (GLfloat) xSamples;
+   const GLfloat dy = 1.0F / (GLfloat) ySamples;
+   GLint x, y;
+   GLint i;
+
+   i = 4;
+   for (x = 0; x < xSamples; x++) {
+      for (y = 0; y < ySamples; y++) {
+         GLint j;
+         if (x == 0 && y == 0) {
+            /* lower left */
+            j = 0;
+         }
+         else if (x == xSamples - 1 && y == 0) {
+            /* lower right */
+            j = 1;
+         }
+         else if (x == 0 && y == ySamples - 1) {
+            /* upper left */
+            j = 2;
+         }
+         else if (x == xSamples - 1 && y == ySamples - 1) {
+            /* upper right */
+            j = 3;
+         }
+         else {
+            j = i++;
+         }
+         samples[j][0] = x * dx + 0.5F * dx;
+         samples[j][1] = y * dy + 0.5F * dy;
+      }
+   }
+}
+
+
+
+/*
+ * Compute how much of the given pixel's area is inside the rectangle
+ * defined by vertices v0, v1, v2, v3.
+ * Vertices MUST be specified in counter-clockwise order.
+ * Return:  coverage in [0, 1].
+ */
+static GLfloat
+compute_coveragef(const struct LineInfo *info,
+                  GLint winx, GLint winy)
+{
+   static GLfloat samples[SUB_PIXEL * SUB_PIXEL][2];
+   static GLboolean haveSamples = GL_FALSE;
+   const GLfloat x = (GLfloat) winx;
+   const GLfloat y = (GLfloat) winy;
+   GLint stop = 4, i;
+   GLfloat insideCount = SUB_PIXEL * SUB_PIXEL;
+
+   if (!haveSamples) {
+      make_sample_table(SUB_PIXEL, SUB_PIXEL, samples);
+      haveSamples = GL_TRUE;
+   }
+
+#if 0 /*DEBUG*/
+   {
+      const GLfloat area = dx0 * dy1 - dx1 * dy0;
+      assert(area >= 0.0);
+   }
+#endif
+
+   for (i = 0; i < stop; i++) {
+      const GLfloat sx = x + samples[i][0];
+      const GLfloat sy = y + samples[i][1];
+      const GLfloat fx0 = sx - info->qx0;
+      const GLfloat fy0 = sy - info->qy0;
+      const GLfloat fx1 = sx - info->qx1;
+      const GLfloat fy1 = sy - info->qy1;
+      const GLfloat fx2 = sx - info->qx2;
+      const GLfloat fy2 = sy - info->qy2;
+      const GLfloat fx3 = sx - info->qx3;
+      const GLfloat fy3 = sy - info->qy3;
+      /* cross product determines if sample is inside or outside each edge */
+      GLfloat cross0 = (info->ex0 * fy0 - info->ey0 * fx0);
+      GLfloat cross1 = (info->ex1 * fy1 - info->ey1 * fx1);
+      GLfloat cross2 = (info->ex2 * fy2 - info->ey2 * fx2);
+      GLfloat cross3 = (info->ex3 * fy3 - info->ey3 * fx3);
+      /* Check if the sample is exactly on an edge.  If so, let cross be a
+       * positive or negative value depending on the direction of the edge.
+       */
+      if (cross0 == 0.0F)
+         cross0 = info->ex0 + info->ey0;
+      if (cross1 == 0.0F)
+         cross1 = info->ex1 + info->ey1;
+      if (cross2 == 0.0F)
+         cross2 = info->ex2 + info->ey2;
+      if (cross3 == 0.0F)
+         cross3 = info->ex3 + info->ey3;
+      if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F || cross3 < 0.0F) {
+         /* point is outside quadrilateral */
+         insideCount -= 1.0F;
+         stop = SUB_PIXEL * SUB_PIXEL;
+      }
+   }
+   if (stop == 4)
+      return 1.0F;
+   else
+      return insideCount * (1.0F / (SUB_PIXEL * SUB_PIXEL));
+}
+
+
+
+typedef void (*plot_func)(GLcontext *ctx, const struct LineInfo *line,
+                          struct pixel_buffer *pb, int ix, int iy);
+
+
+/*
+ * Draw an AA line segment (called many times per line when stippling)
+ */
+static void
+segment(GLcontext *ctx,
+        struct LineInfo *line,
+        plot_func plot,
+        struct pixel_buffer *pb,
+        GLfloat t0, GLfloat t1)
+{
+   const GLfloat absDx = (line->dx < 0.0F) ? -line->dx : line->dx;
+   const GLfloat absDy = (line->dy < 0.0F) ? -line->dy : line->dy;
+   /* compute the actual segment's endpoints */
+   const GLfloat x0 = line->x0 + t0 * line->dx;
+   const GLfloat y0 = line->y0 + t0 * line->dy;
+   const GLfloat x1 = line->x0 + t1 * line->dx;
+   const GLfloat y1 = line->y0 + t1 * line->dy;
+
+   /* compute vertices of the line-aligned quadrilateral */
+   line->qx0 = x0 - line->yAdj;
+   line->qy0 = y0 + line->xAdj;
+   line->qx1 = x0 + line->yAdj;
+   line->qy1 = y0 - line->xAdj;
+   line->qx2 = x1 + line->yAdj;
+   line->qy2 = y1 - line->xAdj;
+   line->qx3 = x1 - line->yAdj;
+   line->qy3 = y1 + line->xAdj;
+   /* compute the quad's edge vectors (for coverage calc) */
+   line->ex0 = line->qx1 - line->qx0;
+   line->ey0 = line->qy1 - line->qy0;
+   line->ex1 = line->qx2 - line->qx1;
+   line->ey1 = line->qy2 - line->qy1;
+   line->ex2 = line->qx3 - line->qx2;
+   line->ey2 = line->qy3 - line->qy2;
+   line->ex3 = line->qx0 - line->qx3;
+   line->ey3 = line->qy0 - line->qy3;
+
+   if (absDx > absDy) {
+      /* X-major line */
+      GLfloat dydx = line->dy / line->dx;
+      GLfloat xLeft, xRight, yBot, yTop;
+      GLint ix, ixRight;
+      if (x0 < x1) {
+         xLeft = x0 - line->halfWidth;
+         xRight = x1 + line->halfWidth;
+         if (line->dy >= 0.0) {
+            yBot = y0 - 3.0F * line->halfWidth;
+            yTop = y0 + line->halfWidth;
+         }
+         else {
+            yBot = y0 - line->halfWidth;
+            yTop = y0 + 3.0F * line->halfWidth;
+         }
+      }
+      else {
+         xLeft = x1 - line->halfWidth;
+         xRight = x0 + line->halfWidth;
+         if (line->dy <= 0.0) {
+            yBot = y1 - 3.0F * line->halfWidth;
+            yTop = y1 + line->halfWidth;
+         }
+         else {
+            yBot = y1 - line->halfWidth;
+            yTop = y1 + 3.0F * line->halfWidth;
+         }
+      }
+
+      /* scan along the line, left-to-right */
+      ixRight = (GLint) (xRight + 1.0F);
+
+      /*printf("avg span height: %g\n", yTop - yBot);*/
+      for (ix = (GLint) xLeft; ix < ixRight; ix++) {
+         const GLint iyBot = (GLint) yBot;
+         const GLint iyTop = (GLint) (yTop + 1.0F);
+         GLint iy;
+         /* scan across the line, bottom-to-top */
+         for (iy = iyBot; iy < iyTop; iy++) {
+            (*plot)(ctx, line, pb, ix, iy);
+         }
+         yBot += dydx;
+         yTop += dydx;
+      }
+   }
+   else {
+      /* Y-major line */
+      GLfloat dxdy = line->dx / line->dy;
+      GLfloat yBot, yTop, xLeft, xRight;
+      GLint iy, iyTop;
+      if (y0 < y1) {
+         yBot = y0 - line->halfWidth;
+         yTop = y1 + line->halfWidth;
+         if (line->dx >= 0.0) {
+            xLeft = x0 - 3.0F * line->halfWidth;
+            xRight = x0 + line->halfWidth;
+         }
+         else {
+            xLeft = x0 - line->halfWidth;
+            xRight = x0 + 3.0F * line->halfWidth;
+         }
+      }
+      else {
+         yBot = y1 - line->halfWidth;
+         yTop = y0 + line->halfWidth;
+         if (line->dx <= 0.0) {
+            xLeft = x1 - 3.0F * line->halfWidth;
+            xRight = x1 + line->halfWidth;
+         }
+         else {
+            xLeft = x1 - line->halfWidth;
+            xRight = x1 + 3.0F * line->halfWidth;
+         }
+      }
+
+      /* scan along the line, bottom-to-top */
+      iyTop = (GLint) (yTop + 1.0F);
+
+      /*printf("avg span width: %g\n", xRight - xLeft);*/
+      for (iy = (GLint) yBot; iy < iyTop; iy++) {
+         const GLint ixLeft = (GLint) xLeft;
+         const GLint ixRight = (GLint) (xRight + 1.0F);
+         GLint ix;
+         /* scan across the line, left-to-right */
+         for (ix = ixLeft; ix < ixRight; ix++) {
+            (*plot)(ctx, line, pb, ix, iy);
+         }
+         xLeft += dxdy;
+         xRight += dxdy;
+      }
+   }
+}
+
+
+#define NAME(x) aa_ci_##x
+#define DO_Z
+#define DO_FOG
+#define DO_INDEX
+#include "s_aalinetemp.h"
+
+
+#define NAME(x) aa_rgba_##x
+#define DO_Z
+#define DO_FOG
+#define DO_RGBA
+#include "s_aalinetemp.h"
+
+
+#define NAME(x)  aa_tex_rgba_##x
+#define DO_Z
+#define DO_FOG
+#define DO_RGBA
+#define DO_TEX
+#include "s_aalinetemp.h"
+
+
+#define NAME(x)  aa_multitex_rgba_##x
+#define DO_Z
+#define DO_RGBA
+#define DO_MULTITEX
+#include "s_aalinetemp.h"
+
+
+#define NAME(x)  aa_multitex_spec_##x
+#define DO_Z
+#define DO_RGBA
+#define DO_MULTITEX
+#define DO_SPEC
+#include "s_aalinetemp.h"
+
+
+
+void
+_swrast_choose_aa_line_function(GLcontext *ctx)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   ASSERT(ctx->Line.SmoothFlag);
+
+   if (ctx->Visual.rgbMode) {
+      /* RGBA */
+      if (ctx->Texture._ReallyEnabled) {
+         if (ctx->Texture._ReallyEnabled > TEXTURE0_ANY) {
+            /* Multitextured! */
+            if (ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR || 
+                ctx->Fog.ColorSumEnabled)
+               swrast->Line = aa_multitex_spec_line;
+            else
+               swrast->Line = aa_multitex_rgba_line;
+         }
+         else {
+            swrast->Line = aa_tex_rgba_line;
+         }
+      }
+      else {
+         swrast->Line = aa_rgba_line;
+      }
+   }
+   else {
+      /* Color Index */
+      swrast->Line = aa_ci_line;
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_aaline.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_aaline.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/swrast/s_aaline.h	Mon Dec 16 11:18:38 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_AALINE_H
+#define S_AALINE_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void
+_swrast_choose_aa_line_function(GLcontext *ctx);
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_aalinetemp.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_aalinetemp.h:1.2
--- /dev/null	Thu Feb 27 12:15:59 2003
+++ xc/extras/Mesa/src/swrast/s_aalinetemp.h	Mon Dec 16 11:18:38 2002
@@ -0,0 +1,324 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Antialiased line template.
+ */
+
+
+/*
+ * Function to render each fragment in the AA line.
+ */
+static void
+NAME(plot)(GLcontext *ctx, const struct LineInfo *line,
+           struct pixel_buffer *pb, int ix, int iy)
+{
+   const GLfloat fx = (GLfloat) ix;
+   const GLfloat fy = (GLfloat) iy;
+   const GLfloat coverage = compute_coveragef(line, ix, iy);
+   GLdepth z;
+   GLfloat fog;
+#ifdef DO_RGBA
+   GLchan red, green, blue, alpha;
+#else
+   GLint index;
+#endif
+   GLchan specRed, specGreen, specBlue;
+   GLfloat tex[MAX_TEXTURE_UNITS][4], lambda[MAX_TEXTURE_UNITS];
+
+   if (coverage == 0.0)
+      return;
+
+   /*
+    * Compute Z, color, texture coords, fog for the fragment by
+    * solving the plane equations at (ix,iy).
+    */
+#ifdef DO_Z
+   z = (GLdepth) solve_plane(fx, fy, line->zPlane);
+#else
+   z = 0.0;
+#endif
+#ifdef DO_FOG
+   fog = solve_plane(fx, fy, line->fPlane);
+#else
+   fog = 0.0;
+#endif
+#ifdef DO_RGBA
+   red   = solve_plane_chan(fx, fy, line->rPlane);
+   green = solve_plane_chan(fx, fy, line->gPlane);
+   blue  = solve_plane_chan(fx, fy, line->bPlane);
+   alpha = solve_plane_chan(fx, fy, line->aPlane);
+#endif
+#ifdef DO_INDEX
+   index = (GLint) solve_plane(fx, fy, line->iPlane);
+#endif
+#ifdef DO_SPEC
+   specRed   = solve_plane_chan(fx, fy, line->srPlane);
+   specGreen = solve_plane_chan(fx, fy, line->sgPlane);
+   specBlue  = solve_plane_chan(fx, fy, line->sbPlane);
+#else
+   (void) specRed;
+   (void) specGreen;
+   (void) specBlue;
+#endif
+#ifdef DO_TEX
+   {
+      GLfloat invQ = solve_plane_recip(fx, fy, line->vPlane[0]);
+      tex[0][0] = solve_plane(fx, fy, line->sPlane[0]) * invQ;
+      tex[0][1] = solve_plane(fx, fy, line->tPlane[0]) * invQ;
+      tex[0][2] = solve_plane(fx, fy, line->uPlane[0]) * invQ;
+      lambda[0] = compute_lambda(line->sPlane[0], line->tPlane[0], invQ,
+                                 line->texWidth[0], line->texHeight[0]);
+   }
+#elif defined(DO_MULTITEX)
+   {
+      GLuint unit;
+      for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+         if (ctx->Texture.Unit[unit]._ReallyEnabled) {
+            GLfloat invQ = solve_plane_recip(fx, fy, line->vPlane[unit]);
+            tex[unit][0] = solve_plane(fx, fy, line->sPlane[unit]) * invQ;
+            tex[unit][1] = solve_plane(fx, fy, line->tPlane[unit]) * invQ;
+            tex[unit][2] = solve_plane(fx, fy, line->uPlane[unit]) * invQ;
+            lambda[unit] = compute_lambda(line->sPlane[unit],
+                                          line->tPlane[unit], invQ,
+                                          line->texWidth[unit], line->texHeight[unit]);
+         }
+      }
+   }
+#else
+   (void) tex[0][0];
+   (void) lambda[0];
+#endif
+
+
+   PB_COVERAGE(pb, coverage);
+
+#if defined(DO_MULTITEX)
+#if defined(DO_SPEC)
+   PB_WRITE_MULTITEX_SPEC_PIXEL(pb, ix, iy, z, fog, red, green, blue, alpha,
+                                specRed, specGreen, specBlue, tex);
+#else
+   PB_WRITE_MULTITEX_PIXEL(pb, ix, iy, z, fog, red, green, blue, alpha, tex);
+#endif
+#elif defined(DO_TEX)
+   PB_WRITE_TEX_PIXEL(pb, ix, iy, z, fog, red, green, blue, alpha,
+                      tex[0][0], tex[0][1], tex[0][2]);
+#elif defined(DO_RGBA)
+   PB_WRITE_RGBA_PIXEL(pb, ix, iy, z, fog, red, green, blue, alpha);
+#elif defined(DO_INDEX)
+   PB_WRITE_CI_PIXEL(pb, ix, iy, z, fog, index);
+#endif
+
+   pb->haveCoverage = GL_TRUE;
+   PB_CHECK_FLUSH(ctx, pb);
+}
+
+
+
+/*
+ * Line setup
+ */
+static void
+NAME(line)(GLcontext *ctx, const SWvertex *v0, const SWvertex *v1)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   struct pixel_buffer *pb = SWRAST_CONTEXT(ctx)->PB;
+   GLfloat tStart, tEnd;   /* segment start, end along line length */
+   GLboolean inSegment;
+   GLint iLen, i;
+
+   /* Init the LineInfo struct */
+   struct LineInfo line;
+   line.x0 = v0->win[0];
+   line.y0 = v0->win[1];
+   line.x1 = v1->win[0];
+   line.y1 = v1->win[1];
+   line.dx = line.x1 - line.x0;
+   line.dy = line.y1 - line.y0;
+   line.len = (GLfloat) sqrt(line.dx * line.dx + line.dy * line.dy);
+   line.halfWidth = 0.5F * ctx->Line.Width;
+
+   if (line.len == 0.0 || IS_INF_OR_NAN(line.len))
+      return;
+
+   line.xAdj = line.dx / line.len * line.halfWidth;
+   line.yAdj = line.dy / line.len * line.halfWidth;
+
+#ifdef DO_Z
+   compute_plane(line.x0, line.y0, line.x1, line.y1,
+                 v0->win[2], v1->win[2], line.zPlane);
+#endif
+#ifdef DO_FOG
+   compute_plane(line.x0, line.y0, line.x1, line.y1,
+                 v0->fog, v1->fog, line.fPlane);
+#endif
+#ifdef DO_RGBA
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    v0->color[RCOMP], v1->color[RCOMP], line.rPlane);
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    v0->color[GCOMP], v1->color[GCOMP], line.gPlane);
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    v0->color[BCOMP], v1->color[BCOMP], line.bPlane);
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    v0->color[ACOMP], v1->color[ACOMP], line.aPlane);
+   }
+   else {
+      constant_plane(v1->color[RCOMP], line.rPlane);
+      constant_plane(v1->color[GCOMP], line.gPlane);
+      constant_plane(v1->color[BCOMP], line.bPlane);
+      constant_plane(v1->color[ACOMP], line.aPlane);
+   }
+#endif
+#ifdef DO_SPEC
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    v0->specular[RCOMP], v1->specular[RCOMP], line.srPlane);
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    v0->specular[GCOMP], v1->specular[GCOMP], line.sgPlane);
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    v0->specular[BCOMP], v1->specular[BCOMP], line.sbPlane);
+   }
+   else {
+      constant_plane(v1->specular[RCOMP], line.srPlane);
+      constant_plane(v1->specular[GCOMP], line.sgPlane);
+      constant_plane(v1->specular[BCOMP], line.sbPlane);
+   }
+#endif
+#ifdef DO_INDEX
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      compute_plane(line.x0, line.y0, line.x1, line.y1,
+                    (GLfloat) v0->index, (GLfloat) v1->index, line.iPlane);
+   }
+   else {
+      constant_plane((GLfloat) v1->index, line.iPlane);
+   }
+#endif
+#ifdef DO_TEX
+   {
+      const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;
+      const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
+      const GLfloat invW0 = v0->win[3];
+      const GLfloat invW1 = v1->win[3];
+      const GLfloat s0 = v0->texcoord[0][0] * invW0;
+      const GLfloat s1 = v1->texcoord[0][0] * invW1;
+      const GLfloat t0 = v0->texcoord[0][1] * invW0;
+      const GLfloat t1 = v1->texcoord[0][1] * invW0;
+      const GLfloat r0 = v0->texcoord[0][2] * invW0;
+      const GLfloat r1 = v1->texcoord[0][2] * invW0;
+      const GLfloat q0 = v0->texcoord[0][3] * invW0;
+      const GLfloat q1 = v1->texcoord[0][3] * invW0;
+      compute_plane(line.x0, line.y0, line.x1, line.y1, s0, s1, line.sPlane[0]);
+      compute_plane(line.x0, line.y0, line.x1, line.y1, t0, t1, line.tPlane[0]);
+      compute_plane(line.x0, line.y0, line.x1, line.y1, r0, r1, line.uPlane[0]);
+      compute_plane(line.x0, line.y0, line.x1, line.y1, q0, q1, line.vPlane[0]);
+      line.texWidth[0] = (GLfloat) texImage->Width;
+      line.texHeight[0] = (GLfloat) texImage->Height;
+   }
+#elif defined(DO_MULTITEX)
+   {
+      GLuint u;
+      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+         if (ctx->Texture.Unit[u]._ReallyEnabled) {
+            const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
+            const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
+            const GLfloat invW0 = v0->win[3];
+            const GLfloat invW1 = v1->win[3];
+            const GLfloat s0 = v0->texcoord[u][0] * invW0;
+            const GLfloat s1 = v1->texcoord[u][0] * invW1;
+            const GLfloat t0 = v0->texcoord[u][1] * invW0;
+            const GLfloat t1 = v1->texcoord[u][1] * invW0;
+            const GLfloat r0 = v0->texcoord[u][2] * invW0;
+            const GLfloat r1 = v1->texcoord[u][2] * invW0;
+            const GLfloat q0 = v0->texcoord[u][3] * invW0;
+            const GLfloat q1 = v1->texcoord[u][3] * invW0;
+            compute_plane(line.x0, line.y0, line.x1, line.y1, s0, s1, line.sPlane[u]);
+            compute_plane(line.x0, line.y0, line.x1, line.y1, t0, t1, line.tPlane[u]);
+            compute_plane(line.x0, line.y0, line.x1, line.y1, r0, r1, line.uPlane[u]);
+            compute_plane(line.x0, line.y0, line.x1, line.y1, q0, q1, line.vPlane[u]);
+            line.texWidth[u]  = (GLfloat) texImage->Width;
+            line.texHeight[u] = (GLfloat) texImage->Height;
+         }
+      }
+   }
+#endif
+
+   tStart = tEnd = 0.0;
+   inSegment = GL_FALSE;
+   iLen = (GLint) line.len;
+
+   if (ctx->Line.StippleFlag) {
+      for (i = 0; i < iLen; i++) {
+         const GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;
+         if ((1 << bit) & ctx->Line.StipplePattern) {
+            /* stipple bit is on */
+            const GLfloat t = (GLfloat) i / (GLfloat) line.len;
+            if (!inSegment) {
+               /* start new segment */
+               inSegment = GL_TRUE;
+               tStart = t;
+            }
+            else {
+               /* still in the segment, extend it */
+               tEnd = t;
+            }
+         }
+         else {
+            /* stipple bit is off */
+            if (inSegment && (tEnd > tStart)) {
+               /* draw the segment */
+               segment(ctx, &line, NAME(plot), pb, tStart, tEnd);
+               inSegment = GL_FALSE;
+            }
+            else {
+               /* still between segments, do nothing */
+            }
+         }
+         swrast->StippleCounter++;
+      }
+
+      if (inSegment) {
+         /* draw the final segment of the line */
+         segment(ctx, &line, NAME(plot), pb, tStart, 1.0F);
+      }
+   }
+   else {
+      /* non-stippled */
+      segment(ctx, &line, NAME(plot), pb, 0.0, 1.0);
+   }
+}
+
+
+
+
+#undef DO_Z
+#undef DO_FOG
+#undef DO_RGBA
+#undef DO_INDEX
+#undef DO_SPEC
+#undef DO_TEX
+#undef DO_MULTITEX
+#undef NAME
Index: xc/extras/Mesa/src/swrast/s_aatriangle.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_aatriangle.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_aatriangle.c	Mon Dec 16 11:18:38 2002
@@ -0,0 +1,458 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.1
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Antialiased Triangle rasterizers
+ */
+
+
+#include "mem.h"
+#include "mmath.h"
+#include "s_aatriangle.h"
+#include "s_context.h"
+#include "s_span.h"
+
+
+/*
+ * Compute coefficients of a plane using the X,Y coords of the v0, v1, v2
+ * vertices and the given Z values.
+ */
+static INLINE void
+compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
+              GLfloat z0, GLfloat z1, GLfloat z2, GLfloat plane[4])
+{
+   const GLfloat px = v1[0] - v0[0];
+   const GLfloat py = v1[1] - v0[1];
+   const GLfloat pz = z1 - z0;
+
+   const GLfloat qx = v2[0] - v0[0];
+   const GLfloat qy = v2[1] - v0[1];
+   const GLfloat qz = z2 - z0;
+
+   const GLfloat a = py * qz - pz * qy;
+   const GLfloat b = pz * qx - px * qz;
+   const GLfloat c = px * qy - py * qx;
+   const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);
+
+   plane[0] = a;
+   plane[1] = b;
+   plane[2] = c;
+   plane[3] = d;
+}
+
+
+/*
+ * Compute coefficients of a plane with a constant Z value.
+ */
+static INLINE void
+constant_plane(GLfloat value, GLfloat plane[4])
+{
+   plane[0] = 0.0;
+   plane[1] = 0.0;
+   plane[2] = -1.0;
+   plane[3] = value;
+}
+
+#define CONSTANT_PLANE(VALUE, PLANE)	\
+do {					\
+   PLANE[0] = 0.0F;			\
+   PLANE[1] = 0.0F;			\
+   PLANE[2] = -1.0F;			\
+   PLANE[3] = VALUE;			\
+} while (0)
+
+
+
+/*
+ * Solve plane equation for Z at (X,Y).
+ */
+static INLINE GLfloat
+solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+   const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
+   return z;
+}
+
+
+#define SOLVE_PLANE(X, Y, PLANE) \
+   ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])
+
+
+/*
+ * Return 1 / solve_plane().
+ */
+static INLINE GLfloat
+solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+   const GLfloat denom = plane[3] + plane[0] * x + plane[1] * y;
+   if (denom == 0.0F)
+      return 0.0F;
+   else
+      return -plane[2] / denom;
+}
+
+
+
+/*
+ * Solve plane and return clamped GLchan value.
+ */
+static INLINE GLchan
+solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])
+{
+   GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2] + 0.5F;
+   if (z < 0.0F)
+      return 0;
+   else if (z > CHAN_MAXF)
+      return (GLchan) CHAN_MAXF;
+   return (GLchan) (GLint) z;
+}
+
+
+
+/*
+ * Compute how much (area) of the given pixel is inside the triangle.
+ * Vertices MUST be specified in counter-clockwise order.
+ * Return:  coverage in [0, 1].
+ */
+static GLfloat
+compute_coveragef(const GLfloat v0[3], const GLfloat v1[3],
+                  const GLfloat v2[3], GLint winx, GLint winy)
+{
+   /* Given a position [0,3]x[0,3] return the sub-pixel sample position.
+    * Contributed by Ray Tice.
+    *
+    * Jitter sample positions -
+    * - average should be .5 in x & y for each column
+    * - each of the 16 rows and columns should be used once
+    * - the rectangle formed by the first four points
+    *   should contain the other points
+    * - the distrubition should be fairly even in any given direction
+    *
+    * The pattern drawn below isn't optimal, but it's better than a regular
+    * grid.  In the drawing, the center of each subpixel is surrounded by
+    * four dots.  The "x" marks the jittered position relative to the
+    * subpixel center.
+    */
+#define POS(a, b) (0.5+a*4+b)/16
+   static const GLfloat samples[16][2] = {
+      /* start with the four corners */
+      { POS(0, 2), POS(0, 0) },
+      { POS(3, 3), POS(0, 2) },
+      { POS(0, 0), POS(3, 1) },
+      { POS(3, 1), POS(3, 3) },
+      /* continue with interior samples */
+      { POS(1, 1), POS(0, 1) },
+      { POS(2, 0), POS(0, 3) },
+      { POS(0, 3), POS(1, 3) },
+      { POS(1, 2), POS(1, 0) },
+      { POS(2, 3), POS(1, 2) },
+      { POS(3, 2), POS(1, 1) },
+      { POS(0, 1), POS(2, 2) },
+      { POS(1, 0), POS(2, 1) },
+      { POS(2, 1), POS(2, 3) },
+      { POS(3, 0), POS(2, 0) },
+      { POS(1, 3), POS(3, 0) },
+      { POS(2, 2), POS(3, 2) }
+   };
+
+   const GLfloat x = (GLfloat) winx;
+   const GLfloat y = (GLfloat) winy;
+   const GLfloat dx0 = v1[0] - v0[0];
+   const GLfloat dy0 = v1[1] - v0[1];
+   const GLfloat dx1 = v2[0] - v1[0];
+   const GLfloat dy1 = v2[1] - v1[1];
+   const GLfloat dx2 = v0[0] - v2[0];
+   const GLfloat dy2 = v0[1] - v2[1];
+   GLint stop = 4, i;
+   GLfloat insideCount = 16.0F;
+
+#ifdef DEBUG
+   {
+      const GLfloat area = dx0 * dy1 - dx1 * dy0;
+      assert(area >= 0.0);
+   }
+#endif
+
+   for (i = 0; i < stop; i++) {
+      const GLfloat sx = x + samples[i][0];
+      const GLfloat sy = y + samples[i][1];
+      const GLfloat fx0 = sx - v0[0];
+      const GLfloat fy0 = sy - v0[1];
+      const GLfloat fx1 = sx - v1[0];
+      const GLfloat fy1 = sy - v1[1];
+      const GLfloat fx2 = sx - v2[0];
+      const GLfloat fy2 = sy - v2[1];
+      /* cross product determines if sample is inside or outside each edge */
+      GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
+      GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
+      GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
+      /* Check if the sample is exactly on an edge.  If so, let cross be a
+       * positive or negative value depending on the direction of the edge.
+       */
+      if (cross0 == 0.0F)
+         cross0 = dx0 + dy0;
+      if (cross1 == 0.0F)
+         cross1 = dx1 + dy1;
+      if (cross2 == 0.0F)
+         cross2 = dx2 + dy2;
+      if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
+         /* point is outside triangle */
+         insideCount -= 1.0F;
+         stop = 16;
+      }
+   }
+   if (stop == 4)
+      return 1.0F;
+   else
+      return insideCount * (1.0F / 16.0F);
+}
+
+
+
+/*
+ * Compute how much (area) of the given pixel is inside the triangle.
+ * Vertices MUST be specified in counter-clockwise order.
+ * Return:  coverage in [0, 15].
+ */
+static GLint
+compute_coveragei(const GLfloat v0[3], const GLfloat v1[3],
+                  const GLfloat v2[3], GLint winx, GLint winy)
+{
+   /* NOTE: 15 samples instead of 16. */
+   static const GLfloat samples[15][2] = {
+      /* start with the four corners */
+      { POS(0, 2), POS(0, 0) },
+      { POS(3, 3), POS(0, 2) },
+      { POS(0, 0), POS(3, 1) },
+      { POS(3, 1), POS(3, 3) },
+      /* continue with interior samples */
+      { POS(1, 1), POS(0, 1) },
+      { POS(2, 0), POS(0, 3) },
+      { POS(0, 3), POS(1, 3) },
+      { POS(1, 2), POS(1, 0) },
+      { POS(2, 3), POS(1, 2) },
+      { POS(3, 2), POS(1, 1) },
+      { POS(0, 1), POS(2, 2) },
+      { POS(1, 0), POS(2, 1) },
+      { POS(2, 1), POS(2, 3) },
+      { POS(3, 0), POS(2, 0) },
+      { POS(1, 3), POS(3, 0) }
+   };
+   const GLfloat x = (GLfloat) winx;
+   const GLfloat y = (GLfloat) winy;
+   const GLfloat dx0 = v1[0] - v0[0];
+   const GLfloat dy0 = v1[1] - v0[1];
+   const GLfloat dx1 = v2[0] - v1[0];
+   const GLfloat dy1 = v2[1] - v1[1];
+   const GLfloat dx2 = v0[0] - v2[0];
+   const GLfloat dy2 = v0[1] - v2[1];
+   GLint stop = 4, i;
+   GLint insideCount = 15;
+
+#ifdef DEBUG
+   {
+      const GLfloat area = dx0 * dy1 - dx1 * dy0;
+      assert(area >= 0.0);
+   }
+#endif
+
+   for (i = 0; i < stop; i++) {
+      const GLfloat sx = x + samples[i][0];
+      const GLfloat sy = y + samples[i][1];
+      const GLfloat fx0 = sx - v0[0];
+      const GLfloat fy0 = sy - v0[1];
+      const GLfloat fx1 = sx - v1[0];
+      const GLfloat fy1 = sy - v1[1];
+      const GLfloat fx2 = sx - v2[0];
+      const GLfloat fy2 = sy - v2[1];
+      /* cross product determines if sample is inside or outside each edge */
+      GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
+      GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
+      GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
+      /* Check if the sample is exactly on an edge.  If so, let cross be a
+       * positive or negative value depending on the direction of the edge.
+       */
+      if (cross0 == 0.0F)
+         cross0 = dx0 + dy0;
+      if (cross1 == 0.0F)
+         cross1 = dx1 + dy1;
+      if (cross2 == 0.0F)
+         cross2 = dx2 + dy2;
+      if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
+         /* point is outside triangle */
+         insideCount--;
+         stop = 15;
+      }
+   }
+   if (stop == 4)
+      return 15;
+   else
+      return insideCount;
+}
+
+
+
+static void
+rgba_aa_tri(GLcontext *ctx,
+	    const SWvertex *v0,
+	    const SWvertex *v1,
+	    const SWvertex *v2)
+{
+#define DO_Z
+#define DO_FOG
+#define DO_RGBA
+#include "s_aatritemp.h"
+}
+
+
+static void
+index_aa_tri(GLcontext *ctx,
+	     const SWvertex *v0,
+	     const SWvertex *v1,
+	     const SWvertex *v2)
+{
+#define DO_Z
+#define DO_FOG
+#define DO_INDEX
+#include "s_aatritemp.h"
+}
+
+
+/*
+ * Compute mipmap level of detail.
+ */
+static INLINE GLfloat
+compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4],
+               GLfloat invQ, GLfloat width, GLfloat height)
+{
+   GLfloat dudx = sPlane[0] / sPlane[2] * invQ * width;
+   GLfloat dudy = sPlane[1] / sPlane[2] * invQ * width;
+   GLfloat dvdx = tPlane[0] / tPlane[2] * invQ * height;
+   GLfloat dvdy = tPlane[1] / tPlane[2] * invQ * height;
+   GLfloat r1 = dudx * dudx + dudy * dudy;
+   GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
+   GLfloat rho2 = r1 + r2;
+   /* return log base 2 of rho */
+   if (rho2 == 0.0F)
+      return 0.0;
+   else
+      return (GLfloat) (log(rho2) * 1.442695 * 0.5); /* 1.442695 = 1/log(2) */
+}
+
+
+static void
+tex_aa_tri(GLcontext *ctx,
+	   const SWvertex *v0,
+	   const SWvertex *v1,
+	   const SWvertex *v2)
+{
+#define DO_Z
+#define DO_FOG
+#define DO_RGBA
+#define DO_TEX
+#include "s_aatritemp.h"
+}
+
+
+static void
+spec_tex_aa_tri(GLcontext *ctx,
+		const SWvertex *v0,
+		const SWvertex *v1,
+		const SWvertex *v2)
+{
+#define DO_Z
+#define DO_FOG
+#define DO_RGBA
+#define DO_TEX
+#define DO_SPEC
+#include "s_aatritemp.h"
+}
+
+
+static void
+multitex_aa_tri(GLcontext *ctx,
+		const SWvertex *v0,
+		const SWvertex *v1,
+		const SWvertex *v2)
+{
+#define DO_Z
+#define DO_FOG
+#define DO_RGBA
+#define DO_MULTITEX
+#include "s_aatritemp.h"
+}
+
+static void
+spec_multitex_aa_tri(GLcontext *ctx,
+		     const SWvertex *v0,
+		     const SWvertex *v1,
+		     const SWvertex *v2)
+{
+#define DO_Z
+#define DO_FOG
+#define DO_RGBA
+#define DO_MULTITEX
+#define DO_SPEC
+#include "s_aatritemp.h"
+}
+
+
+/*
+ * Examine GL state and set swrast->Triangle to an
+ * appropriate antialiased triangle rasterizer function.
+ */
+void
+_mesa_set_aa_triangle_function(GLcontext *ctx)
+{
+   ASSERT(ctx->Polygon.SmoothFlag);
+
+   if (ctx->Texture._ReallyEnabled) {
+      if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
+         if (ctx->Texture._ReallyEnabled > TEXTURE0_ANY) {
+            SWRAST_CONTEXT(ctx)->Triangle = spec_multitex_aa_tri;
+         }
+         else {
+            SWRAST_CONTEXT(ctx)->Triangle = spec_tex_aa_tri;
+         }
+      }
+      else {
+         if (ctx->Texture._ReallyEnabled > TEXTURE0_ANY) {
+            SWRAST_CONTEXT(ctx)->Triangle = multitex_aa_tri;
+         }
+         else {
+            SWRAST_CONTEXT(ctx)->Triangle = tex_aa_tri;
+         }
+      }
+   }
+   else if (ctx->Visual.rgbMode) {
+      SWRAST_CONTEXT(ctx)->Triangle = rgba_aa_tri;
+   }
+   else {
+      SWRAST_CONTEXT(ctx)->Triangle = index_aa_tri;
+   }
+
+   ASSERT(SWRAST_CONTEXT(ctx)->Triangle);
+}
Index: xc/extras/Mesa/src/swrast/s_aatriangle.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_aatriangle.h:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_aatriangle.h	Mon Dec 16 11:18:38 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_AATRIANGLE_H
+#define S_AATRIANGLE_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_set_aa_triangle_function(GLcontext *ctx);
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_aatritemp.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_aatritemp.h:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_aatritemp.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,594 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Antialiased Triangle Rasterizer Template
+ *
+ * This file is #include'd to generate custom AA triangle rasterizers.
+ * NOTE: this code hasn't been optimized yet.  That'll come after it
+ * works correctly.
+ *
+ * The following macros may be defined to indicate what auxillary information
+ * must be copmuted across the triangle:
+ *    DO_Z         - if defined, compute Z values
+ *    DO_RGBA      - if defined, compute RGBA values
+ *    DO_INDEX     - if defined, compute color index values
+ *    DO_SPEC      - if defined, compute specular RGB values
+ *    DO_TEX       - if defined, compute unit 0 STRQ texcoords
+ *    DO_MULTITEX  - if defined, compute all unit's STRQ texcoords
+ */
+
+/*void triangle( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint pv )*/
+{
+   const GLfloat *p0 = v0->win;
+   const GLfloat *p1 = v1->win;
+   const GLfloat *p2 = v2->win;
+   const SWvertex *vMin, *vMid, *vMax;
+   GLint iyMin, iyMax;
+   GLfloat yMin, yMax;
+   GLboolean ltor;
+   GLfloat majDx, majDy;  /* major (i.e. long) edge dx and dy */
+
+#ifdef DO_Z
+   GLfloat zPlane[4];
+   GLdepth z[MAX_WIDTH];
+#endif
+#ifdef DO_FOG
+   GLfloat fogPlane[4];
+   GLfloat fog[MAX_WIDTH];
+#else
+   GLfloat *fog = NULL;
+#endif
+#ifdef DO_RGBA
+   GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
+   DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
+#endif
+#ifdef DO_INDEX
+   GLfloat iPlane[4];
+   GLuint index[MAX_WIDTH];
+   GLint icoverageSpan[MAX_WIDTH];
+#else
+   GLfloat coverageSpan[MAX_WIDTH];
+#endif
+#ifdef DO_SPEC
+   GLfloat srPlane[4], sgPlane[4], sbPlane[4];
+   DEFMARRAY(GLchan, spec, MAX_WIDTH, 4);
+#endif
+#ifdef DO_TEX
+   GLfloat sPlane[4], tPlane[4], uPlane[4], vPlane[4];
+   GLfloat texWidth, texHeight;
+   DEFARRAY(GLfloat, s, MAX_WIDTH);  /* mac 32k limitation */
+   DEFARRAY(GLfloat, t, MAX_WIDTH);
+   DEFARRAY(GLfloat, u, MAX_WIDTH);
+   DEFARRAY(GLfloat, lambda, MAX_WIDTH);
+#elif defined(DO_MULTITEX)
+   GLfloat sPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat tPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat uPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat vPlane[MAX_TEXTURE_UNITS][4];
+   GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
+   DEFMARRAY(GLfloat, s, MAX_TEXTURE_UNITS, MAX_WIDTH);  /* mac 32k limit */
+   DEFMARRAY(GLfloat, t, MAX_TEXTURE_UNITS, MAX_WIDTH);
+   DEFMARRAY(GLfloat, u, MAX_TEXTURE_UNITS, MAX_WIDTH);
+   DEFMARRAY(GLfloat, lambda, MAX_TEXTURE_UNITS, MAX_WIDTH);
+#endif
+   GLfloat bf = SWRAST_CONTEXT(ctx)->_backface_sign;
+
+#ifdef DO_RGBA
+   CHECKARRAY(rgba, return);  /* mac 32k limitation */
+#endif
+#ifdef DO_SPEC
+   CHECKARRAY(spec, return);
+#endif
+#if defined(DO_TEX) || defined(DO_MULTITEX)
+   CHECKARRAY(s, return);
+   CHECKARRAY(t, return);
+   CHECKARRAY(u, return);
+   CHECKARRAY(lambda, return);
+#endif
+
+   /* determine bottom to top order of vertices */
+   {
+      GLfloat y0 = v0->win[1];
+      GLfloat y1 = v1->win[1];
+      GLfloat y2 = v2->win[1];
+      if (y0 <= y1) {
+	 if (y1 <= y2) {
+	    vMin = v0;   vMid = v1;   vMax = v2;   /* y0<=y1<=y2 */
+	 }
+	 else if (y2 <= y0) {
+	    vMin = v2;   vMid = v0;   vMax = v1;   /* y2<=y0<=y1 */
+	 }
+	 else {
+	    vMin = v0;   vMid = v2;   vMax = v1;  bf = -bf; /* y0<=y2<=y1 */
+	 }
+      }
+      else {
+	 if (y0 <= y2) {
+	    vMin = v1;   vMid = v0;   vMax = v2;  bf = -bf; /* y1<=y0<=y2 */
+	 }
+	 else if (y2 <= y1) {
+	    vMin = v2;   vMid = v1;   vMax = v0;  bf = -bf; /* y2<=y1<=y0 */
+	 }
+	 else {
+	    vMin = v1;   vMid = v2;   vMax = v0;   /* y1<=y2<=y0 */
+	 }
+      }
+   }
+
+   majDx = vMax->win[0] - vMin->win[0];
+   majDy = vMax->win[1] - vMin->win[1];
+
+   {
+      const GLfloat botDx = vMid->win[0] - vMin->win[0];
+      const GLfloat botDy = vMid->win[1] - vMin->win[1];
+      const GLfloat area = majDx * botDy - botDx * majDy;
+      ltor = (GLboolean) (area < 0.0F);
+      /* Do backface culling */
+      if (area * bf < 0 || area == 0 || IS_INF_OR_NAN(area))
+	 return;
+   }
+
+#ifndef DO_OCCLUSION_TEST
+   ctx->OcclusionResult = GL_TRUE;
+#endif
+
+   /* Plane equation setup:
+    * We evaluate plane equations at window (x,y) coordinates in order
+    * to compute color, Z, fog, texcoords, etc.  This isn't terribly
+    * efficient but it's easy and reliable.
+    */
+#ifdef DO_Z
+   compute_plane(p0, p1, p2, p0[2], p1[2], p2[2], zPlane);
+#endif
+#ifdef DO_FOG
+   compute_plane(p0, p1, p2, v0->fog, v1->fog, v2->fog, fogPlane);
+#endif
+#ifdef DO_RGBA
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      compute_plane(p0, p1, p2, v0->color[0], v1->color[0], v2->color[0], rPlane);
+      compute_plane(p0, p1, p2, v0->color[1], v1->color[1], v2->color[1], gPlane);
+      compute_plane(p0, p1, p2, v0->color[2], v1->color[2], v2->color[2], bPlane);
+      compute_plane(p0, p1, p2, v0->color[3], v1->color[3], v2->color[3], aPlane);
+   }
+   else {
+      constant_plane(v2->color[RCOMP], rPlane);
+      constant_plane(v2->color[GCOMP], gPlane);
+      constant_plane(v2->color[BCOMP], bPlane);
+      constant_plane(v2->color[ACOMP], aPlane);
+   }
+#endif
+#ifdef DO_INDEX
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      compute_plane(p0, p1, p2, (GLfloat) v0->index,
+                    (GLfloat) v1->index, (GLfloat) v2->index, iPlane);
+   }
+   else {
+      constant_plane((GLfloat) v2->index, iPlane);
+   }
+#endif
+#ifdef DO_SPEC
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      compute_plane(p0, p1, p2, v0->specular[0], v1->specular[0], v2->specular[0],srPlane);
+      compute_plane(p0, p1, p2, v0->specular[1], v1->specular[1], v2->specular[1],sgPlane);
+      compute_plane(p0, p1, p2, v0->specular[2], v1->specular[2], v2->specular[2],sbPlane);
+   }
+   else {
+      constant_plane(v2->specular[RCOMP], srPlane);
+      constant_plane(v2->specular[GCOMP], sgPlane);
+      constant_plane(v2->specular[BCOMP], sbPlane);
+   }
+#endif
+#ifdef DO_TEX
+   {
+      const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;
+      const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
+      const GLfloat invW0 = v0->win[3];
+      const GLfloat invW1 = v1->win[3];
+      const GLfloat invW2 = v2->win[3];
+      const GLfloat s0 = v0->texcoord[0][0] * invW0;
+      const GLfloat s1 = v1->texcoord[0][0] * invW1;
+      const GLfloat s2 = v2->texcoord[0][0] * invW2;
+      const GLfloat t0 = v0->texcoord[0][1] * invW0;
+      const GLfloat t1 = v1->texcoord[0][1] * invW1;
+      const GLfloat t2 = v2->texcoord[0][1] * invW2;
+      const GLfloat r0 = v0->texcoord[0][2] * invW0;
+      const GLfloat r1 = v1->texcoord[0][2] * invW1;
+      const GLfloat r2 = v2->texcoord[0][2] * invW2;
+      const GLfloat q0 = v0->texcoord[0][3] * invW0;
+      const GLfloat q1 = v1->texcoord[0][3] * invW1;
+      const GLfloat q2 = v2->texcoord[0][3] * invW2;
+      compute_plane(p0, p1, p2, s0, s1, s2, sPlane);
+      compute_plane(p0, p1, p2, t0, t1, t2, tPlane);
+      compute_plane(p0, p1, p2, r0, r1, r2, uPlane);
+      compute_plane(p0, p1, p2, q0, q1, q2, vPlane);
+      texWidth = (GLfloat) texImage->Width;
+      texHeight = (GLfloat) texImage->Height;
+   }
+#elif defined(DO_MULTITEX)
+   {
+      GLuint u;
+      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+         if (ctx->Texture.Unit[u]._ReallyEnabled) {
+            const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
+            const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];
+            const GLfloat invW0 = v0->win[3];
+            const GLfloat invW1 = v1->win[3];
+            const GLfloat invW2 = v2->win[3];
+            const GLfloat s0 = v0->texcoord[u][0] * invW0;
+            const GLfloat s1 = v1->texcoord[u][0] * invW1;
+            const GLfloat s2 = v2->texcoord[u][0] * invW2;
+            const GLfloat t0 = v0->texcoord[u][1] * invW0;
+            const GLfloat t1 = v1->texcoord[u][1] * invW1;
+            const GLfloat t2 = v2->texcoord[u][1] * invW2;
+            const GLfloat r0 = v0->texcoord[u][2] * invW0;
+            const GLfloat r1 = v1->texcoord[u][2] * invW1;
+            const GLfloat r2 = v2->texcoord[u][2] * invW2;
+            const GLfloat q0 = v0->texcoord[u][3] * invW0;
+            const GLfloat q1 = v1->texcoord[u][3] * invW1;
+            const GLfloat q2 = v2->texcoord[u][3] * invW2;
+            compute_plane(p0, p1, p2, s0, s1, s2, sPlane[u]);
+            compute_plane(p0, p1, p2, t0, t1, t2, tPlane[u]);
+            compute_plane(p0, p1, p2, r0, r1, r2, uPlane[u]);
+            compute_plane(p0, p1, p2, q0, q1, q2, vPlane[u]);
+            texWidth[u]  = (GLfloat) texImage->Width;
+            texHeight[u] = (GLfloat) texImage->Height;
+         }
+      }
+   }
+#endif
+
+   /* Begin bottom-to-top scan over the triangle.
+    * The long edge will either be on the left or right side of the
+    * triangle.  We always scan from the long edge toward the shorter
+    * edges, stopping when we find that coverage = 0.  If the long edge
+    * is on the left we scan left-to-right.  Else, we scan right-to-left.
+    */
+   yMin = vMin->win[1];
+   yMax = vMax->win[1];
+   iyMin = (GLint) yMin;
+   iyMax = (GLint) yMax + 1;
+
+   if (ltor) {
+      /* scan left to right */
+      const GLfloat *pMin = vMin->win;
+      const GLfloat *pMid = vMid->win;
+      const GLfloat *pMax = vMax->win;
+      const GLfloat dxdy = majDx / majDy;
+      const GLfloat xAdj = dxdy < 0.0F ? -dxdy : 0.0F;
+      GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
+      GLint iy;
+      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
+         GLint ix, startX = (GLint) (x - xAdj);
+         GLuint count, n;
+         GLfloat coverage = 0.0F;
+         /* skip over fragments with zero coverage */
+         while (startX < MAX_WIDTH) {
+            coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
+            if (coverage > 0.0F)
+               break;
+            startX++;
+         }
+
+         /* enter interior of triangle */
+         ix = startX;
+         count = 0;
+         while (coverage > 0.0F) {
+            /* (cx,cy) = center of fragment */
+            const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
+#ifdef DO_INDEX
+            icoverageSpan[count] = compute_coveragei(pMin, pMid, pMax, ix, iy);
+#else
+            coverageSpan[count] = coverage;
+#endif
+#ifdef DO_Z
+            z[count] = (GLdepth) solve_plane(cx, cy, zPlane);
+#endif
+#ifdef DO_FOG
+	    fog[count] = solve_plane(cx, cy, fogPlane);
+#endif
+#ifdef DO_RGBA
+            rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
+            rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
+            rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
+            rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
+#endif
+#ifdef DO_INDEX
+            index[count] = (GLint) solve_plane(cx, cy, iPlane);
+#endif
+#ifdef DO_SPEC
+            spec[count][RCOMP] = solve_plane_chan(cx, cy, srPlane);
+            spec[count][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
+            spec[count][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
+#endif
+#ifdef DO_TEX
+            {
+               const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
+               s[count] = solve_plane(cx, cy, sPlane) * invQ;
+               t[count] = solve_plane(cx, cy, tPlane) * invQ;
+               u[count] = solve_plane(cx, cy, uPlane) * invQ;
+               lambda[count] = compute_lambda(sPlane, tPlane, invQ,
+                                                 texWidth, texHeight);
+            }
+#elif defined(DO_MULTITEX)
+            {
+               GLuint unit;
+               for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+                  if (ctx->Texture.Unit[unit]._ReallyEnabled) {
+                     GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
+                     s[unit][count] = solve_plane(cx, cy, sPlane[unit]) * invQ;
+                     t[unit][count] = solve_plane(cx, cy, tPlane[unit]) * invQ;
+                     u[unit][count] = solve_plane(cx, cy, uPlane[unit]) * invQ;
+                     lambda[unit][count] = compute_lambda(sPlane[unit],
+                          tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
+                  }
+               }
+            }
+#endif
+            ix++;
+            count++;
+            coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
+         }
+
+         if (ix <= startX)
+            continue;
+
+         n = (GLuint) ix - (GLuint) startX;
+
+#ifdef DO_MULTITEX
+#  ifdef DO_SPEC
+         _mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
+                                       (const GLfloat (*)[MAX_WIDTH]) s,
+                                       (const GLfloat (*)[MAX_WIDTH]) t,
+                                       (const GLfloat (*)[MAX_WIDTH]) u,
+                                       (GLfloat (*)[MAX_WIDTH]) lambda,
+                                       rgba, (const GLchan (*)[4]) spec,
+                                       coverageSpan,  GL_POLYGON);
+#  else
+         _mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
+                                       (const GLfloat (*)[MAX_WIDTH]) s,
+                                       (const GLfloat (*)[MAX_WIDTH]) t,
+                                       (const GLfloat (*)[MAX_WIDTH]) u,
+                                       lambda, rgba, NULL, coverageSpan,
+                                       GL_POLYGON);
+#  endif
+#elif defined(DO_TEX)
+#  ifdef DO_SPEC
+         _mesa_write_texture_span(ctx, n, startX, iy, z, fog,
+                                  s, t, u, lambda, rgba,
+                                  (const GLchan (*)[4]) spec,
+                                  coverageSpan, GL_POLYGON);
+#  else
+         _mesa_write_texture_span(ctx, n, startX, iy, z, fog,
+                                  s, t, u, lambda,
+                                  rgba, NULL, coverageSpan, GL_POLYGON);
+#  endif
+#elif defined(DO_RGBA)
+         _mesa_write_rgba_span(ctx, n, startX, iy, z, fog, rgba,
+                               coverageSpan, GL_POLYGON);
+#elif defined(DO_INDEX)
+         _mesa_write_index_span(ctx, n, startX, iy, z, fog, index,
+                                icoverageSpan, GL_POLYGON);
+#endif
+      }
+   }
+   else {
+      /* scan right to left */
+      const GLfloat *pMin = vMin->win;
+      const GLfloat *pMid = vMid->win;
+      const GLfloat *pMax = vMax->win;
+      const GLfloat dxdy = majDx / majDy;
+      const GLfloat xAdj = dxdy > 0 ? dxdy : 0.0F;
+      GLfloat x = pMin[0] - (yMin - iyMin) * dxdy;
+      GLint iy;
+      for (iy = iyMin; iy < iyMax; iy++, x += dxdy) {
+         GLint ix, left, startX = (GLint) (x + xAdj);
+         GLuint count, n;
+         GLfloat coverage = 0.0F;
+
+         /* make sure we're not past the window edge */
+         if (startX >= ctx->DrawBuffer->_Xmax) {
+            startX = ctx->DrawBuffer->_Xmax - 1;
+         }
+
+         /* skip fragments with zero coverage */
+         while (startX >= 0) {
+            coverage = compute_coveragef(pMin, pMax, pMid, startX, iy);
+            if (coverage > 0.0F)
+               break;
+            startX--;
+         }
+
+         /* enter interior of triangle */
+         ix = startX;
+         count = 0;
+         while (coverage > 0.0F) {
+            /* (cx,cy) = center of fragment */
+            const GLfloat cx = ix + 0.5F, cy = iy + 0.5F;
+#ifdef DO_INDEX
+            icoverageSpan[ix] = compute_coveragei(pMin, pMid, pMax, ix, iy);
+#else
+            coverageSpan[ix] = coverage;
+#endif
+#ifdef DO_Z
+            z[ix] = (GLdepth) solve_plane(cx, cy, zPlane);
+#endif
+#ifdef DO_FOG
+            fog[ix] = solve_plane(cx, cy, fogPlane);
+#endif
+#ifdef DO_RGBA
+            rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
+            rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
+            rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
+            rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
+#endif
+#ifdef DO_INDEX
+            index[ix] = (GLint) solve_plane(cx, cy, iPlane);
+#endif
+#ifdef DO_SPEC
+            spec[ix][RCOMP] = solve_plane_chan(cx, cy, srPlane);
+            spec[ix][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
+            spec[ix][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
+#endif
+#ifdef DO_TEX
+            {
+               const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
+               s[ix] = solve_plane(cx, cy, sPlane) * invQ;
+               t[ix] = solve_plane(cx, cy, tPlane) * invQ;
+               u[ix] = solve_plane(cx, cy, uPlane) * invQ;
+               lambda[ix] = compute_lambda(sPlane, tPlane, invQ,
+                                              texWidth, texHeight);
+            }
+#elif defined(DO_MULTITEX)
+            {
+               GLuint unit;
+               for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+                  if (ctx->Texture.Unit[unit]._ReallyEnabled) {
+                     GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
+                     s[unit][ix] = solve_plane(cx, cy, sPlane[unit]) * invQ;
+                     t[unit][ix] = solve_plane(cx, cy, tPlane[unit]) * invQ;
+                     u[unit][ix] = solve_plane(cx, cy, uPlane[unit]) * invQ;
+                     lambda[unit][ix] = compute_lambda(sPlane[unit],
+                         tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
+                  }
+               }
+            }
+#endif
+            ix--;
+            count++;
+            coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
+         }
+
+         if (startX <= ix)
+            continue;
+
+         n = (GLuint) startX - (GLuint) ix;
+
+         left = ix + 1;
+#ifdef DO_MULTITEX
+         {
+            GLuint unit;
+            for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+               if (ctx->Texture.Unit[unit]._ReallyEnabled) {
+                  GLint j;
+                  for (j = 0; j < (GLint) n; j++) {
+                     s[unit][j] = s[unit][j + left];
+                     t[unit][j] = t[unit][j + left];
+                     u[unit][j] = u[unit][j + left];
+                     lambda[unit][j] = lambda[unit][j + left];
+                  }
+               }
+            }
+         }
+#  ifdef DO_SPEC
+         _mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
+                                       (const GLfloat (*)[MAX_WIDTH]) s,
+                                       (const GLfloat (*)[MAX_WIDTH]) t,
+                                       (const GLfloat (*)[MAX_WIDTH]) u,
+                                       lambda, rgba + left,
+                                       (const GLchan (*)[4]) (spec + left),
+                                       coverageSpan + left,
+                                       GL_POLYGON);
+#  else
+         _mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
+                                       (const GLfloat (*)[MAX_WIDTH]) s,
+                                       (const GLfloat (*)[MAX_WIDTH]) t,
+                                       (const GLfloat (*)[MAX_WIDTH]) u,
+                                       lambda,
+                                       rgba + left, NULL, coverageSpan + left,
+                                       GL_POLYGON);
+#  endif
+#elif defined(DO_TEX)
+#  ifdef DO_SPEC
+         _mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
+                                  s + left, t + left, u + left,
+                                  lambda + left, rgba + left,
+                                  (const GLchan (*)[4]) (spec + left),
+                                  coverageSpan + left,
+                                  GL_POLYGON);
+#  else
+         _mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
+                                  s + left, t + left,
+                                  u + left, lambda + left,
+                                  rgba + left, NULL,
+                                  coverageSpan + left, GL_POLYGON);
+#  endif
+#elif defined(DO_RGBA)
+         _mesa_write_rgba_span(ctx, n, left, iy, z + left, fog + left,
+                               rgba + left, coverageSpan + left, GL_POLYGON);
+#elif defined(DO_INDEX)
+         _mesa_write_index_span(ctx, n, left, iy, z + left, fog + left,
+                               index + left, icoverageSpan + left, GL_POLYGON);
+#endif
+      }
+   }
+
+#ifdef DO_RGBA
+   UNDEFARRAY(rgba);  /* mac 32k limitation */
+#endif
+#ifdef DO_SPEC
+   UNDEFARRAY(spec);
+#endif
+#if defined(DO_TEX) || defined(DO_MULTITEX)
+   UNDEFARRAY(s);
+   UNDEFARRAY(t);
+   UNDEFARRAY(u);
+   UNDEFARRAY(lambda);
+#endif
+}
+
+
+#ifdef DO_Z
+#undef DO_Z
+#endif
+
+#ifdef DO_FOG
+#undef DO_FOG
+#endif
+
+#ifdef DO_RGBA
+#undef DO_RGBA
+#endif
+
+#ifdef DO_INDEX
+#undef DO_INDEX
+#endif
+
+#ifdef DO_SPEC
+#undef DO_SPEC
+#endif
+
+#ifdef DO_TEX
+#undef DO_TEX
+#endif
+
+#ifdef DO_MULTITEX
+#undef DO_MULTITEX
+#endif
+
+#ifdef DO_OCCLUSION_TEST
+#undef DO_OCCLUSION_TEST
+#endif
Index: xc/extras/Mesa/src/swrast/s_accum.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_accum.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_accum.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,527 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mem.h"
+
+#include "s_accum.h"
+#include "s_alphabuf.h"
+#include "s_context.h"
+#include "s_masking.h"
+#include "s_span.h"
+
+
+/*
+ * Accumulation buffer notes
+ *
+ * Normally, accumulation buffer values are GLshorts with values in
+ * [-32767, 32767] which represent floating point colors in [-1, 1],
+ * as suggested by the OpenGL specification.
+ *
+ * We optimize for the common case used for full-scene antialiasing:
+ *    // start with accum buffer cleared to zero
+ *    glAccum(GL_LOAD, w);   // or GL_ACCUM the first image
+ *    glAccum(GL_ACCUM, w);
+ *    ...
+ *    glAccum(GL_ACCUM, w);
+ *    glAccum(GL_RETURN, 1.0);
+ * That is, we start with an empty accumulation buffer and accumulate
+ * n images, each with weight w = 1/n.
+ * In this scenario, we can simply store unscaled integer values in
+ * the accum buffer instead of scaled integers.  We'll also keep track
+ * of the w value so when we do GL_RETURN we simply divide the accumulated
+ * values by n (=1/w).
+ * This lets us avoid _many_ int->float->int conversions.
+ */
+
+
+#if CHAN_BITS == 8
+#define USE_OPTIMIZED_ACCUM   /* enable the optimization */
+#endif
+
+void
+_mesa_alloc_accum_buffer( GLframebuffer *buffer )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint n;
+
+   if (buffer->Accum) {
+      MESA_PBUFFER_FREE( buffer->Accum );
+      buffer->Accum = NULL;
+   }
+
+   /* allocate accumulation buffer if not already present */
+   n = buffer->Width * buffer->Height * 4 * sizeof(GLaccum);
+   buffer->Accum = (GLaccum *) MESA_PBUFFER_ALLOC( n );
+   if (!buffer->Accum) {
+      /* unable to setup accumulation buffer */
+      _mesa_error( NULL, GL_OUT_OF_MEMORY, "glAccum" );
+   }
+
+   if (ctx) {
+      SWcontext *swrast = SWRAST_CONTEXT(ctx);
+      /* XXX these fields should probably be in the GLframebuffer */
+#ifdef USE_OPTIMIZED_ACCUM
+      swrast->_IntegerAccumMode = GL_TRUE;
+#else
+      swrast->_IntegerAccumMode = GL_FALSE;
+#endif
+      swrast->_IntegerAccumScaler = 0.0;
+   }
+}
+
+
+/*
+ * This is called when we fall out of optimized/unscaled accum buffer mode.
+ * That is, we convert each unscaled accum buffer value into a scaled value
+ * representing the range[-1, 1].
+ */
+static void rescale_accum( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height * 4;
+   const GLfloat s = swrast->_IntegerAccumScaler * (32767.0F / CHAN_MAXF);
+   GLaccum *accum = ctx->DrawBuffer->Accum;
+   GLuint i;
+
+   assert(swrast->_IntegerAccumMode);
+   assert(accum);
+
+   for (i = 0; i < n; i++) {
+      accum[i] = (GLaccum) (accum[i] * s);
+   }
+
+   swrast->_IntegerAccumMode = GL_FALSE;
+}
+
+
+
+
+
+
+/*
+ * Clear the accumulation Buffer.
+ */
+void
+_mesa_clear_accum_buffer( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint buffersize;
+   GLfloat acc_scale;
+
+   if (ctx->Visual.accumRedBits==0) {
+      /* No accumulation buffer! */
+      return;
+   }
+
+   if (sizeof(GLaccum)==1) {
+      acc_scale = 127.0;
+   }
+   else if (sizeof(GLaccum)==2) {
+      acc_scale = 32767.0;
+   }
+   else {
+      acc_scale = 1.0F;
+   }
+
+   /* number of pixels */
+   buffersize = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+
+   if (!ctx->DrawBuffer->Accum) {
+      /* try to alloc accumulation buffer */
+      ctx->DrawBuffer->Accum = (GLaccum *)
+	                   MALLOC( buffersize * 4 * sizeof(GLaccum) );
+   }
+
+   if (ctx->DrawBuffer->Accum) {
+      if (ctx->Scissor.Enabled) {
+	 /* Limit clear to scissor box */
+	 const GLaccum r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale);
+	 const GLaccum g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale);
+	 const GLaccum b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale);
+	 const GLaccum a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale);
+	 GLint i, j;
+         GLint width, height;
+         GLaccum *row;
+         /* size of region to clear */
+         width = 4 * (ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin);
+         height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+         /* ptr to first element to clear */
+         row = ctx->DrawBuffer->Accum
+               + 4 * (ctx->DrawBuffer->_Ymin * ctx->DrawBuffer->Width
+                      + ctx->DrawBuffer->_Xmin);
+         for (j=0;j<height;j++) {
+            for (i=0;i<width;i+=4) {
+               row[i+0] = r;
+               row[i+1] = g;
+               row[i+2] = b;
+               row[i+3] = a;
+	    }
+            row += 4 * ctx->DrawBuffer->Width;
+	 }
+      }
+      else {
+	 /* clear whole buffer */
+	 if (ctx->Accum.ClearColor[0]==0.0 &&
+	     ctx->Accum.ClearColor[1]==0.0 &&
+	     ctx->Accum.ClearColor[2]==0.0 &&
+	     ctx->Accum.ClearColor[3]==0.0) {
+	    /* Black */
+	    BZERO( ctx->DrawBuffer->Accum, buffersize * 4 * sizeof(GLaccum) );
+	 }
+	 else {
+	    /* Not black */
+	    const GLaccum r = (GLaccum) (ctx->Accum.ClearColor[0] * acc_scale);
+	    const GLaccum g = (GLaccum) (ctx->Accum.ClearColor[1] * acc_scale);
+	    const GLaccum b = (GLaccum) (ctx->Accum.ClearColor[2] * acc_scale);
+	    const GLaccum a = (GLaccum) (ctx->Accum.ClearColor[3] * acc_scale);
+	    GLaccum *acc = ctx->DrawBuffer->Accum;
+	    GLuint i;
+	    for (i=0;i<buffersize;i++) {
+	       *acc++ = r;
+	       *acc++ = g;
+	       *acc++ = b;
+	       *acc++ = a;
+	    }
+	 }
+      }
+
+      /* update optimized accum state vars */
+      if (ctx->Accum.ClearColor[0] == 0.0 && ctx->Accum.ClearColor[1] == 0.0 &&
+          ctx->Accum.ClearColor[2] == 0.0 && ctx->Accum.ClearColor[3] == 0.0) {
+#ifdef USE_OPTIMIZED_ACCUM
+         swrast->_IntegerAccumMode = GL_TRUE;
+#else
+         swrast->_IntegerAccumMode = GL_FALSE;
+#endif
+         swrast->_IntegerAccumScaler = 0.0;  /* denotes empty accum buffer */
+      }
+      else {
+         swrast->_IntegerAccumMode = GL_FALSE;
+      }
+   }
+}
+
+
+void
+_swrast_Accum( GLcontext *ctx, GLenum op, GLfloat value,
+	       GLint xpos, GLint ypos,
+	       GLint width, GLint height )
+
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint width4;
+   GLfloat acc_scale;
+   GLchan rgba[MAX_WIDTH][4];
+   const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
+
+   if (SWRAST_CONTEXT(ctx)->NewState)
+      _swrast_validate_derived( ctx );
+
+   if (!ctx->DrawBuffer->Accum) {
+      _mesa_warning(ctx,
+		    "Calling glAccum() without an accumulation "
+		    "buffer (low memory?)");
+      return;
+   }
+
+   if (sizeof(GLaccum)==1) {
+      acc_scale = 127.0;
+   }
+   else if (sizeof(GLaccum)==2) {
+      acc_scale = 32767.0;
+   }
+   else {
+      acc_scale = 1.0F;
+   }
+
+   width4 = 4 * width;
+
+   switch (op) {
+      case GL_ADD:
+         if (value != 0.0F) {
+	    const GLaccum val = (GLaccum) (value * acc_scale);
+	    GLint j;
+            /* Leave optimized accum buffer mode */
+            if (swrast->_IntegerAccumMode)
+               rescale_accum(ctx);
+	    for (j = 0; j < height; j++) {
+	       GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + 4*xpos;
+               GLuint i;
+	       for (i = 0; i < width4; i++) {
+                  acc[i] += val;
+	       }
+	       ypos++;
+	    }
+	 }
+	 break;
+
+      case GL_MULT:
+         if (value != 1.0F) {
+	    GLint j;
+            /* Leave optimized accum buffer mode */
+            if (swrast->_IntegerAccumMode)
+               rescale_accum(ctx);
+	    for (j = 0; j < height; j++) {
+	       GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + 4 * xpos;
+               GLuint i;
+	       for (i = 0; i < width4; i++) {
+                  acc[i] = (GLaccum) ( (GLfloat) acc[i] * value );
+	       }
+	       ypos++;
+	    }
+	 }
+	 break;
+
+      case GL_ACCUM:
+         if (value == 0.0F)
+            return;
+
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+					  ctx->Pixel.DriverReadBuffer );
+
+         /* May have to leave optimized accum buffer mode */
+         if (swrast->_IntegerAccumScaler == 0.0 && value > 0.0 && value <= 1.0)
+            swrast->_IntegerAccumScaler = value;
+         if (swrast->_IntegerAccumMode && value != swrast->_IntegerAccumScaler)
+            rescale_accum(ctx);
+
+         RENDER_START(swrast,ctx);
+
+         if (swrast->_IntegerAccumMode) {
+            /* simply add integer color values into accum buffer */
+            GLint j;
+            GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+            assert(swrast->_IntegerAccumScaler > 0.0);
+            assert(swrast->_IntegerAccumScaler <= 1.0);
+            for (j = 0; j < height; j++) {
+
+               GLint i, i4;
+               _mesa_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+               for (i = i4 = 0; i < width; i++, i4+=4) {
+                  acc[i4+0] += rgba[i][RCOMP];
+                  acc[i4+1] += rgba[i][GCOMP];
+                  acc[i4+2] += rgba[i][BCOMP];
+                  acc[i4+3] += rgba[i][ACOMP];
+               }
+               acc += width4;
+               ypos++;
+            }
+         }
+         else {
+            /* scaled integer (or float) accum buffer */
+            const GLfloat rscale = value * acc_scale / CHAN_MAXF;
+            const GLfloat gscale = value * acc_scale / CHAN_MAXF;
+            const GLfloat bscale = value * acc_scale / CHAN_MAXF;
+            const GLfloat ascale = value * acc_scale / CHAN_MAXF;
+            GLint j;
+            for (j=0;j<height;j++) {
+               GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+               GLint i;
+               _mesa_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+               for (i=0;i<width;i++) {
+                  acc[0] += (GLaccum) ( (GLfloat) rgba[i][RCOMP] * rscale );
+                  acc[1] += (GLaccum) ( (GLfloat) rgba[i][GCOMP] * gscale );
+                  acc[2] += (GLaccum) ( (GLfloat) rgba[i][BCOMP] * bscale );
+                  acc[3] += (GLaccum) ( (GLfloat) rgba[i][ACOMP] * ascale );
+                  acc += 4;
+               }
+               ypos++;
+            }
+         }
+         /* restore read buffer = draw buffer (the default) */
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+					  ctx->Color.DriverDrawBuffer );
+         RENDER_FINISH(swrast,ctx);
+	 break;
+
+      case GL_LOAD:
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+					  ctx->Pixel.DriverReadBuffer );
+
+         /* This is a change to go into optimized accum buffer mode */
+         if (value > 0.0 && value <= 1.0) {
+#ifdef USE_OPTIMIZED_ACCUM
+            swrast->_IntegerAccumMode = GL_TRUE;
+#else
+            swrast->_IntegerAccumMode = GL_FALSE;
+#endif
+            swrast->_IntegerAccumScaler = value;
+         }
+         else {
+            swrast->_IntegerAccumMode = GL_FALSE;
+            swrast->_IntegerAccumScaler = 0.0;
+         }
+
+         RENDER_START(swrast,ctx);
+         if (swrast->_IntegerAccumMode) {
+            /* just copy values into accum buffer */
+            GLint j;
+            GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+            assert(swrast->_IntegerAccumScaler > 0.0);
+            assert(swrast->_IntegerAccumScaler <= 1.0);
+            for (j = 0; j < height; j++) {
+               GLint i, i4;
+               _mesa_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+               for (i = i4 = 0; i < width; i++, i4 += 4) {
+                  acc[i4+0] = rgba[i][RCOMP];
+                  acc[i4+1] = rgba[i][GCOMP];
+                  acc[i4+2] = rgba[i][BCOMP];
+                  acc[i4+3] = rgba[i][ACOMP];
+               }
+               acc += width4;
+               ypos++;
+            }
+         }
+         else {
+            /* scaled integer (or float) accum buffer */
+            const GLfloat rscale = value * acc_scale / CHAN_MAXF;
+            const GLfloat gscale = value * acc_scale / CHAN_MAXF;
+            const GLfloat bscale = value * acc_scale / CHAN_MAXF;
+            const GLfloat ascale = value * acc_scale / CHAN_MAXF;
+#if 0
+            const GLfloat d = 3.0 / acc_scale;  /* XXX what's this? */
+#endif
+            GLint i, j;
+            for (j = 0; j < height; j++) {
+               GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos * 4;
+               _mesa_read_rgba_span(ctx, ctx->DrawBuffer, width, xpos, ypos, rgba);
+               for (i=0;i<width;i++) {
+#if 0
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][RCOMP] * rscale + d);
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][GCOMP] * gscale + d);
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][BCOMP] * bscale + d);
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][ACOMP] * ascale + d);
+#else
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][RCOMP] * rscale);
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][GCOMP] * gscale);
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][BCOMP] * bscale);
+                  *acc++ = (GLaccum) ((GLfloat) rgba[i][ACOMP] * ascale);
+#endif
+               }
+               ypos++;
+            }
+         }
+
+         /* restore read buffer = draw buffer (the default) */
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                       ctx->Color.DriverDrawBuffer );
+         RENDER_FINISH(swrast,ctx);
+	 break;
+
+      case GL_RETURN:
+         /* May have to leave optimized accum buffer mode */
+         if (swrast->_IntegerAccumMode && value != 1.0)
+            rescale_accum(ctx);
+
+         RENDER_START(swrast,ctx);
+#ifdef USE_OPTIMIZED_ACCUM
+         if (swrast->_IntegerAccumMode && swrast->_IntegerAccumScaler > 0) {
+            /* build lookup table to avoid many floating point multiplies */
+            static GLchan multTable[32768];
+            static GLfloat prevMult = 0.0;
+            const GLfloat mult = swrast->_IntegerAccumScaler;
+            const GLint max = MIN2((GLint) (256 / mult), 32767);
+            GLint j;
+            if (mult != prevMult) {
+               for (j = 0; j < max; j++)
+                  multTable[j] = IROUND((GLfloat) j * mult);
+               prevMult = mult;
+            }
+
+            assert(swrast->_IntegerAccumScaler > 0.0);
+            assert(swrast->_IntegerAccumScaler <= 1.0);
+            for (j = 0; j < height; j++) {
+               const GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos*4;
+               GLint i, i4;
+               for (i = i4 = 0; i < width; i++, i4 += 4) {
+                  ASSERT(acc[i4+0] < max);
+                  ASSERT(acc[i4+1] < max);
+                  ASSERT(acc[i4+2] < max);
+                  ASSERT(acc[i4+3] < max);
+                  rgba[i][RCOMP] = multTable[acc[i4+0]];
+                  rgba[i][GCOMP] = multTable[acc[i4+1]];
+                  rgba[i][BCOMP] = multTable[acc[i4+2]];
+                  rgba[i][ACOMP] = multTable[acc[i4+3]];
+               }
+               if (colorMask != 0xffffffff) {
+                  _mesa_mask_rgba_span( ctx, width, xpos, ypos, rgba );
+               }
+               (*swrast->Driver.WriteRGBASpan)( ctx, width, xpos, ypos,
+                                             (const GLchan (*)[4])rgba, NULL );
+               if (ctx->DrawBuffer->UseSoftwareAlphaBuffers
+                   && ctx->Color.ColorMask[ACOMP]) {
+                  _mesa_write_alpha_span(ctx, width, xpos, ypos,
+                                         (CONST GLchan (*)[4]) rgba, NULL);
+               }
+               ypos++;
+            }
+         }
+         else
+#endif /* USE_OPTIMIZED_ACCUM */
+         {
+            /* scaled integer (or float) accum buffer */
+            const GLfloat rscale = value / acc_scale * CHAN_MAXF;
+            const GLfloat gscale = value / acc_scale * CHAN_MAXF;
+            const GLfloat bscale = value / acc_scale * CHAN_MAXF;
+            const GLfloat ascale = value / acc_scale * CHAN_MAXF;
+            GLint i, j;
+            for (j=0;j<height;j++) {
+               const GLaccum *acc = ctx->DrawBuffer->Accum + ypos * width4 + xpos*4;
+               for (i=0;i<width;i++) {
+                  GLint r = IROUND( (GLfloat) (acc[0]) * rscale );
+                  GLint g = IROUND( (GLfloat) (acc[1]) * gscale );
+                  GLint b = IROUND( (GLfloat) (acc[2]) * bscale );
+                  GLint a = IROUND( (GLfloat) (acc[3]) * ascale );
+                  acc += 4;
+                  rgba[i][RCOMP] = CLAMP( r, 0, CHAN_MAX );
+                  rgba[i][GCOMP] = CLAMP( g, 0, CHAN_MAX );
+                  rgba[i][BCOMP] = CLAMP( b, 0, CHAN_MAX );
+                  rgba[i][ACOMP] = CLAMP( a, 0, CHAN_MAX );
+               }
+               if (colorMask != 0xffffffff) {
+                  _mesa_mask_rgba_span( ctx, width, xpos, ypos, rgba );
+               }
+               (*swrast->Driver.WriteRGBASpan)( ctx, width, xpos, ypos,
+                                             (const GLchan (*)[4])rgba, NULL );
+               if (ctx->DrawBuffer->UseSoftwareAlphaBuffers
+                   && ctx->Color.ColorMask[ACOMP]) {
+                  _mesa_write_alpha_span(ctx, width, xpos, ypos,
+                                         (CONST GLchan (*)[4]) rgba, NULL);
+               }
+               ypos++;
+            }
+	 }
+         RENDER_FINISH(swrast,ctx);
+	 break;
+
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glAccum" );
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_accum.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_accum.h:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_accum.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,43 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_ACCUM_H
+#define S_ACCUM_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_alloc_accum_buffer( GLframebuffer *buffer );
+
+
+extern void
+_mesa_clear_accum_buffer( GLcontext *ctx );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_alpha.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_alpha.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_alpha.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,97 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mmath.h"
+
+#include "s_alpha.h"
+
+
+
+
+
+/*
+ * Apply the alpha test to a span of pixels.
+ * In:  rgba - array of pixels
+ * In/Out:  mask - current pixel mask.  Pixels which fail the alpha test
+ *                 will set the corresponding mask flag to 0.
+ * Return:  0 = all pixels in the span failed the alpha test.
+ *          1 = one or more pixels passed the alpha test.
+ */
+GLint
+_mesa_alpha_test( const GLcontext *ctx,
+                  GLuint n, CONST GLchan rgba[][4], GLubyte mask[] )
+{
+   GLuint i;
+   GLchan ref = ctx->Color.AlphaRef;
+
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Color.AlphaFunc) {
+      case GL_LESS:
+         for (i=0;i<n;i++) {
+	    mask[i] &= (rgba[i][ACOMP] < ref);
+	 }
+	 return 1;
+      case GL_LEQUAL:
+         for (i=0;i<n;i++)
+	    mask[i] &= (rgba[i][ACOMP] <= ref);
+	 return 1;
+      case GL_GEQUAL:
+         for (i=0;i<n;i++) {
+	    mask[i] &= (rgba[i][ACOMP] >= ref);
+	 }
+	 return 1;
+      case GL_GREATER:
+         for (i=0;i<n;i++) {
+	    mask[i] &= (rgba[i][ACOMP] > ref);
+	 }
+	 return 1;
+      case GL_NOTEQUAL:
+         for (i=0;i<n;i++) {
+	    mask[i] &= (rgba[i][ACOMP] != ref);
+	 }
+	 return 1;
+      case GL_EQUAL:
+         for (i=0;i<n;i++) {
+	    mask[i] &= (rgba[i][ACOMP] == ref);
+	 }
+	 return 1;
+      case GL_ALWAYS:
+	 /* do nothing */
+	 return 1;
+      case GL_NEVER:
+         /* caller should check for zero! */
+	 return 0;
+      default:
+	 _mesa_problem( ctx, "Invalid alpha test in gl_alpha_test" );
+         return 0;
+   }
+   /* Never get here */
+   /*return 1;*/
+}
Index: xc/extras/Mesa/src/swrast/s_alpha.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_alpha.h:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_alpha.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,41 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_ALPHA_H
+#define S_ALPHA_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern GLint
+_mesa_alpha_test( const GLcontext *ctx, GLuint n,
+                  CONST GLchan rgba[][4], GLubyte mask[] );
+
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_alphabuf.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_alphabuf.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_alphabuf.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,308 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Software alpha planes.  Many frame buffers don't have alpha bits so
+ * we simulate them in software.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "mem.h"
+
+#include "s_alphabuf.h"
+
+
+#define ALPHA_DRAW_ADDR(X,Y) \
+   (ctx->DrawBuffer->Alpha + (Y) * ctx->DrawBuffer->Width + (X))
+
+#define ALPHA_READ_ADDR(X,Y) \
+   (ctx->ReadBuffer->Alpha + (Y) * ctx->ReadBuffer->Width + (X))
+
+
+/*
+ * Allocate a new front and back alpha buffer.
+ */
+void
+_mesa_alloc_alpha_buffers( GLframebuffer *buffer )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const GLint bytes = buffer->Width * buffer->Height * sizeof(GLchan);
+
+   ASSERT(buffer->UseSoftwareAlphaBuffers);
+
+   if (buffer->FrontLeftAlpha) {
+      MESA_PBUFFER_FREE( buffer->FrontLeftAlpha );
+   }
+   buffer->FrontLeftAlpha = (GLchan *) MESA_PBUFFER_ALLOC( bytes );
+   if (!buffer->FrontLeftAlpha) {
+      /* out of memory */
+      _mesa_error( NULL, GL_OUT_OF_MEMORY,
+                   "Couldn't allocate front-left alpha buffer" );
+   }
+
+   if (buffer->Visual.doubleBufferMode) {
+      if (buffer->BackLeftAlpha) {
+         MESA_PBUFFER_FREE( buffer->BackLeftAlpha );
+      }
+      buffer->BackLeftAlpha = (GLchan *) MESA_PBUFFER_ALLOC( bytes );
+      if (!buffer->BackLeftAlpha) {
+         /* out of memory */
+         _mesa_error( NULL, GL_OUT_OF_MEMORY,
+                      "Couldn't allocate back-left alpha buffer" );
+      }
+   }
+
+   if (buffer->Visual.stereoMode) {
+      if (buffer->FrontRightAlpha) {
+         MESA_PBUFFER_FREE( buffer->FrontRightAlpha );
+      }
+      buffer->FrontRightAlpha = (GLchan *) MESA_PBUFFER_ALLOC( bytes );
+      if (!buffer->FrontRightAlpha) {
+         /* out of memory */
+         _mesa_error( NULL, GL_OUT_OF_MEMORY,
+                      "Couldn't allocate front-right alpha buffer" );
+      }
+
+      if (buffer->Visual.doubleBufferMode) {
+         if (buffer->BackRightAlpha) {
+            MESA_PBUFFER_FREE( buffer->BackRightAlpha );
+         }
+         buffer->BackRightAlpha = (GLchan *) MESA_PBUFFER_ALLOC( bytes );
+         if (!buffer->BackRightAlpha) {
+            /* out of memory */
+            _mesa_error( NULL, GL_OUT_OF_MEMORY,
+                         "Couldn't allocate back-right alpha buffer" );
+         }
+      }
+   }
+
+   if (ctx) {
+      if (ctx->Color.DriverDrawBuffer == GL_FRONT_LEFT)
+         buffer->Alpha = buffer->FrontLeftAlpha;
+      else if (ctx->Color.DriverDrawBuffer == GL_BACK_LEFT)
+         buffer->Alpha = buffer->BackLeftAlpha;
+      else if (ctx->Color.DriverDrawBuffer == GL_FRONT_RIGHT)
+         buffer->Alpha = buffer->FrontRightAlpha;
+      else if (ctx->Color.DriverDrawBuffer == GL_BACK_RIGHT)
+         buffer->Alpha = buffer->BackRightAlpha;
+   }
+}
+
+
+/*
+ * Clear all the alpha buffers
+ */
+void
+_mesa_clear_alpha_buffers( GLcontext *ctx )
+{
+   const GLchan aclear = ctx->Color.ClearColor[3];
+   GLuint bufferBit;
+
+   ASSERT(ctx->DrawBuffer->UseSoftwareAlphaBuffers);
+   ASSERT(ctx->Color.ColorMask[ACOMP]);
+
+   /* loop over four possible alpha buffers */
+   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+      if (bufferBit & ctx->Color.DrawDestMask) {
+         GLchan *buffer;
+         if (bufferBit == FRONT_LEFT_BIT) {
+            buffer = ctx->DrawBuffer->FrontLeftAlpha;
+         }
+         else if (bufferBit == FRONT_RIGHT_BIT) {
+            buffer = ctx->DrawBuffer->FrontRightAlpha;
+         }
+         else if (bufferBit == BACK_LEFT_BIT) {
+            buffer = ctx->DrawBuffer->BackLeftAlpha;
+         }
+         else {
+            buffer = ctx->DrawBuffer->BackRightAlpha;
+         }
+
+         if (ctx->Scissor.Enabled) {
+            /* clear scissor region */
+            GLint j;
+            GLint rowLen = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+            GLint rows = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+            GLint width = ctx->DrawBuffer->Width;
+            GLchan *aptr = buffer
+                          + ctx->DrawBuffer->_Ymin * ctx->DrawBuffer->Width
+                          + ctx->DrawBuffer->_Xmin;
+            for (j = 0; j < rows; j++) {
+#if CHAN_BITS == 8
+               MEMSET( aptr, aclear, rowLen );
+#elif CHAN_BITS == 16
+               MEMSET16( aptr, aclear, rowLen );
+#else
+               GLint i;
+               for (i = 0; i < rowLen; i++) {
+                  aptr[i] = aclear;
+               }
+#endif
+               aptr += width;
+            }
+         }
+         else {
+            /* clear whole buffer */
+            GLuint pixels = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+#if CHAN_BITS == 8
+            MEMSET(buffer, aclear, pixels);
+#elif CHAN_BITS == 16
+            MEMSET16(buffer, aclear, pixels);
+#else
+            GLuint i;
+            for (i = 0; i < pixels; i++) {
+               buffer[i] = aclear;
+            }
+#endif
+         }
+      }
+   }
+}
+
+
+
+void
+_mesa_write_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                        CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   GLchan *aptr = ALPHA_DRAW_ADDR( x, y );
+   GLuint i;
+
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            *aptr = rgba[i][ACOMP];
+         }
+         aptr++;
+      }
+   }
+   else {
+      for (i=0;i<n;i++) {
+         *aptr++ = rgba[i][ACOMP];
+      }
+   }
+}
+
+
+void
+_mesa_write_mono_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                             GLchan alpha, const GLubyte mask[] )
+{
+   GLchan *aptr = ALPHA_DRAW_ADDR( x, y );
+   GLuint i;
+
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            *aptr = alpha;
+         }
+         aptr++;
+      }
+   }
+   else {
+      for (i=0;i<n;i++) {
+         *aptr++ = alpha;
+      }
+   }
+}
+
+
+void
+_mesa_write_alpha_pixels( GLcontext *ctx,
+                          GLuint n, const GLint x[], const GLint y[],
+                          CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   GLuint i;
+
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+            *aptr = rgba[i][ACOMP];
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++) {
+         GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+         *aptr = rgba[i][ACOMP];
+      }
+   }
+}
+
+
+void
+_mesa_write_mono_alpha_pixels( GLcontext *ctx,
+                               GLuint n, const GLint x[], const GLint y[],
+                               GLchan alpha, const GLubyte mask[] )
+{
+   GLuint i;
+
+   if (mask) {
+      for (i=0;i<n;i++) {
+         if (mask[i]) {
+            GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+            *aptr = alpha;
+         }
+      }
+   }
+   else {
+      for (i=0;i<n;i++) {
+         GLchan *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
+         *aptr = alpha;
+      }
+   }
+}
+
+
+
+void
+_mesa_read_alpha_span( GLcontext *ctx,
+                       GLuint n, GLint x, GLint y, GLchan rgba[][4] )
+{
+   GLchan *aptr = ALPHA_READ_ADDR( x, y );
+   GLuint i;
+   for (i=0;i<n;i++) {
+      rgba[i][ACOMP] = *aptr++;
+   }
+}
+
+
+void
+_mesa_read_alpha_pixels( GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         GLchan rgba[][4], const GLubyte mask[] )
+{
+   GLuint i;
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         GLchan *aptr = ALPHA_READ_ADDR( x[i], y[i] );
+         rgba[i][ACOMP] = *aptr;
+      }
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_alphabuf.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_alphabuf.h:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_alphabuf.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,80 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_ALPHABUF_H
+#define S_ALPHABUF_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_alloc_alpha_buffers( GLframebuffer *buffer );
+
+
+extern void
+_mesa_clear_alpha_buffers( GLcontext *ctx );
+
+
+extern void
+_mesa_write_alpha_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                        CONST GLchan rgba[][4], const GLubyte mask[] );
+
+
+extern void
+_mesa_write_mono_alpha_span( GLcontext *ctx,
+                             GLuint n, GLint x, GLint y,
+                             GLchan alpha, const GLubyte mask[] );
+
+
+
+extern void
+_mesa_write_alpha_pixels( GLcontext* ctx,
+                          GLuint n, const GLint x[], const GLint y[],
+                          CONST GLchan rgba[][4],
+                          const GLubyte mask[] );
+
+
+extern void
+_mesa_write_mono_alpha_pixels( GLcontext* ctx,
+                               GLuint n, const GLint x[],
+                               const GLint y[], GLchan alpha,
+                               const GLubyte mask[] );
+
+
+extern void
+_mesa_read_alpha_span( GLcontext* ctx,
+                       GLuint n, GLint x, GLint y, GLchan rgba[][4] );
+
+
+extern void
+_mesa_read_alpha_pixels( GLcontext* ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         GLchan rgba[][4], const GLubyte mask[] );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_bitmap.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_bitmap.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_bitmap.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,139 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "image.h"
+#include "macros.h"
+#include "pixel.h"
+
+#include "s_context.h"
+#include "s_fog.h"
+#include "s_pb.h"
+
+
+
+/*
+ * Render a bitmap.
+ */
+void
+_swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
+		GLsizei width, GLsizei height,
+		const struct gl_pixelstore_attrib *unpack,
+		const GLubyte *bitmap )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   struct pixel_buffer *PB = swrast->PB;
+   GLint row, col;
+   GLdepth fragZ;
+   GLfloat fog;
+
+   ASSERT(ctx->RenderMode == GL_RENDER);
+   ASSERT(bitmap);
+
+   RENDER_START(swrast,ctx);
+
+   if (SWRAST_CONTEXT(ctx)->NewState)
+      _swrast_validate_derived( ctx );
+
+   /* Set bitmap drawing color */
+   if (ctx->Visual.rgbMode) {
+      GLint r, g, b, a;
+      r = (GLint) (ctx->Current.RasterColor[0] * CHAN_MAXF);
+      g = (GLint) (ctx->Current.RasterColor[1] * CHAN_MAXF);
+      b = (GLint) (ctx->Current.RasterColor[2] * CHAN_MAXF);
+      a = (GLint) (ctx->Current.RasterColor[3] * CHAN_MAXF);
+      PB_SET_COLOR( PB, r, g, b, a );
+   }
+   else {
+      PB_SET_INDEX( PB, ctx->Current.RasterIndex );
+   }
+
+   fragZ = (GLdepth) ( ctx->Current.RasterPos[2] * ctx->DepthMaxF);
+
+   if (ctx->Fog.Enabled) {
+      if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.FogCoord);
+      else
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+   }
+   else {
+      fog = 0.0;
+   }
+
+   for (row=0; row<height; row++) {
+      const GLubyte *src = (const GLubyte *) _mesa_image_address( unpack,
+                 bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
+
+      if (unpack->LsbFirst) {
+         /* Lsb first */
+         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
+         for (col=0; col<width; col++) {
+            if (*src & mask) {
+               PB_WRITE_PIXEL( PB, px+col, py+row, fragZ, fog );
+            }
+            if (mask == 128U) {
+               src++;
+               mask = 1U;
+            }
+            else {
+               mask = mask << 1;
+            }
+         }
+
+         PB_CHECK_FLUSH( ctx, PB );
+
+         /* get ready for next row */
+         if (mask != 1)
+            src++;
+      }
+      else {
+         /* Msb first */
+         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
+         for (col=0; col<width; col++) {
+            if (*src & mask) {
+               PB_WRITE_PIXEL( PB, px+col, py+row, fragZ, fog );
+            }
+            if (mask == 1U) {
+               src++;
+               mask = 128U;
+            }
+            else {
+               mask = mask >> 1;
+            }
+         }
+
+         PB_CHECK_FLUSH( ctx, PB );
+
+         /* get ready for next row */
+         if (mask != 128)
+            src++;
+      }
+   }
+
+   _mesa_flush_pb(ctx);
+
+   RENDER_FINISH(swrast,ctx);
+}
Index: xc/extras/Mesa/src/swrast/s_blend.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_blend.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_blend.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,765 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+
+#include "s_alphabuf.h"
+#include "s_blend.h"
+#include "s_context.h"
+#include "s_pb.h"
+#include "s_span.h"
+
+
+#if defined(USE_MMX_ASM)
+#include "X86/mmx.h"
+#include "X86/common_x86_asm.h"
+#define _BLENDAPI _ASMAPI
+#else
+#define _BLENDAPI
+#endif
+
+
+/*
+ * Special case for glBlendFunc(GL_ZERO, GL_ONE)
+ */
+static void _BLENDAPI
+blend_noop( GLcontext *ctx, GLuint n, const GLubyte mask[],
+            GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   GLuint i;
+   ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
+   ASSERT(ctx->Color.BlendSrcRGB==GL_ZERO);
+   ASSERT(ctx->Color.BlendDstRGB==GL_ONE);
+   (void) ctx;
+
+   for (i = 0; i < n; i++) {
+      if (mask[i]) {
+         rgba[i][RCOMP] = dest[i][RCOMP];
+         rgba[i][GCOMP] = dest[i][GCOMP];
+         rgba[i][BCOMP] = dest[i][BCOMP];
+         rgba[i][ACOMP] = dest[i][ACOMP];
+      }
+   }
+}
+
+
+/*
+ * Special case for glBlendFunc(GL_ONE, GL_ZERO)
+ */
+static void _BLENDAPI
+blend_replace( GLcontext *ctx, GLuint n, const GLubyte mask[],
+               GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
+   ASSERT(ctx->Color.BlendSrcRGB==GL_ONE);
+   ASSERT(ctx->Color.BlendDstRGB==GL_ZERO);
+   (void) ctx;
+   (void) n;
+   (void) mask;
+   (void) rgba;
+   (void) dest;
+}
+
+
+/*
+ * Common transparency blending mode.
+ */
+static void _BLENDAPI
+blend_transparency( GLcontext *ctx, GLuint n, const GLubyte mask[],
+                    GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   GLuint i;
+   ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
+   ASSERT(ctx->Color.BlendSrcRGB==GL_SRC_ALPHA);
+   ASSERT(ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA);
+   (void) ctx;
+
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         const GLint t = rgba[i][ACOMP];  /* t in [0, CHAN_MAX] */
+         if (t == 0) {
+            /* 0% alpha */
+            rgba[i][RCOMP] = dest[i][RCOMP];
+            rgba[i][GCOMP] = dest[i][GCOMP];
+            rgba[i][BCOMP] = dest[i][BCOMP];
+            rgba[i][ACOMP] = dest[i][ACOMP];
+         }
+         else if (t == CHAN_MAX) {
+            /* 100% alpha, no-op */
+         }
+         else {
+#if 0
+            /* This is pretty close, but Glean complains */
+            const GLint s = CHAN_MAX - t;
+            const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s + 1) >> 8;
+            const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s + 1) >> 8;
+            const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s + 1) >> 8;
+            const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s + 1) >> 8;
+#elif 0
+            /* This is slower but satisfies Glean */
+            const GLint s = CHAN_MAX - t;
+            const GLint r = (rgba[i][RCOMP] * t + dest[i][RCOMP] * s) / 255;
+            const GLint g = (rgba[i][GCOMP] * t + dest[i][GCOMP] * s) / 255;
+            const GLint b = (rgba[i][BCOMP] * t + dest[i][BCOMP] * s) / 255;
+            const GLint a = (rgba[i][ACOMP] * t + dest[i][ACOMP] * s) / 255;
+#else
+#if CHAN_BITS == 8
+            /* This satisfies Glean and should be reasonably fast */
+            /* Contributed by Nathan Hand */
+#define DIV255(X)  (((X) << 8) + (X) + 256) >> 16
+            const GLint s = CHAN_MAX - t;
+            const GLint r = DIV255(rgba[i][RCOMP] * t + dest[i][RCOMP] * s);
+            const GLint g = DIV255(rgba[i][GCOMP] * t + dest[i][GCOMP] * s);
+            const GLint b = DIV255(rgba[i][BCOMP] * t + dest[i][BCOMP] * s);
+            const GLint a = DIV255(rgba[i][ACOMP] * t + dest[i][ACOMP] * s);
+#undef DIV255
+#elif CHAN_BITS == 16
+            const GLfloat tt = (GLfloat) t / CHAN_MAXF;
+            const GLfloat s = 1.0 - tt;
+            const GLint r = (GLint) (rgba[i][RCOMP] * tt + dest[i][RCOMP] * s);
+            const GLint g = (GLint) (rgba[i][GCOMP] * tt + dest[i][GCOMP] * s);
+            const GLint b = (GLint) (rgba[i][BCOMP] * tt + dest[i][BCOMP] * s);
+            const GLint a = (GLint) (rgba[i][ACOMP] * tt + dest[i][ACOMP] * s);
+#else /* CHAN_BITS == 32 */
+            const GLfloat tt = (GLfloat) t / CHAN_MAXF;
+            const GLfloat s = 1.0 - tt;
+            const GLfloat r = rgba[i][RCOMP] * tt + dest[i][RCOMP] * s;
+            const GLfloat g = rgba[i][GCOMP] * tt + dest[i][GCOMP] * s;
+            const GLfloat b = rgba[i][BCOMP] * tt + dest[i][BCOMP] * s;
+            const GLfloat a = rgba[i][ACOMP] * tt + dest[i][ACOMP] * s;
+#endif
+#endif
+            ASSERT(r <= CHAN_MAX);
+            ASSERT(g <= CHAN_MAX);
+            ASSERT(b <= CHAN_MAX);
+            ASSERT(a <= CHAN_MAX);
+            rgba[i][RCOMP] = (GLchan) r;
+            rgba[i][GCOMP] = (GLchan) g;
+            rgba[i][BCOMP] = (GLchan) b;
+            rgba[i][ACOMP] = (GLchan) a;
+         }
+      }
+   }
+}
+
+
+
+/*
+ * Add src and dest.
+ */
+static void _BLENDAPI
+blend_add( GLcontext *ctx, GLuint n, const GLubyte mask[],
+           GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   GLuint i;
+   ASSERT(ctx->Color.BlendEquation==GL_FUNC_ADD_EXT);
+   ASSERT(ctx->Color.BlendSrcRGB==GL_ONE);
+   ASSERT(ctx->Color.BlendDstRGB==GL_ONE);
+   (void) ctx;
+
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+#if CHAN_TYPE == GL_FLOAT
+         GLfloat r = rgba[i][RCOMP] + dest[i][RCOMP];
+         GLfloat g = rgba[i][GCOMP] + dest[i][GCOMP];
+         GLfloat b = rgba[i][BCOMP] + dest[i][BCOMP];
+         GLfloat a = rgba[i][ACOMP] + dest[i][ACOMP];
+#else
+         GLint r = rgba[i][RCOMP] + dest[i][RCOMP];
+         GLint g = rgba[i][GCOMP] + dest[i][GCOMP];
+         GLint b = rgba[i][BCOMP] + dest[i][BCOMP];
+         GLint a = rgba[i][ACOMP] + dest[i][ACOMP];
+#endif
+         rgba[i][RCOMP] = (GLchan) MIN2( r, CHAN_MAX );
+         rgba[i][GCOMP] = (GLchan) MIN2( g, CHAN_MAX );
+         rgba[i][BCOMP] = (GLchan) MIN2( b, CHAN_MAX );
+         rgba[i][ACOMP] = (GLchan) MIN2( a, CHAN_MAX );
+      }
+   }
+}
+
+
+
+/*
+ * Blend min function  (for GL_EXT_blend_minmax)
+ */
+static void _BLENDAPI
+blend_min( GLcontext *ctx, GLuint n, const GLubyte mask[],
+           GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   GLuint i;
+   ASSERT(ctx->Color.BlendEquation==GL_MIN_EXT);
+   (void) ctx;
+
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         rgba[i][RCOMP] = (GLchan) MIN2( rgba[i][RCOMP], dest[i][RCOMP] );
+         rgba[i][GCOMP] = (GLchan) MIN2( rgba[i][GCOMP], dest[i][GCOMP] );
+         rgba[i][BCOMP] = (GLchan) MIN2( rgba[i][BCOMP], dest[i][BCOMP] );
+         rgba[i][ACOMP] = (GLchan) MIN2( rgba[i][ACOMP], dest[i][ACOMP] );
+      }
+   }
+}
+
+
+
+/*
+ * Blend max function  (for GL_EXT_blend_minmax)
+ */
+static void _BLENDAPI
+blend_max( GLcontext *ctx, GLuint n, const GLubyte mask[],
+           GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   GLuint i;
+   ASSERT(ctx->Color.BlendEquation==GL_MAX_EXT);
+   (void) ctx;
+
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+         rgba[i][RCOMP] = (GLchan) MAX2( rgba[i][RCOMP], dest[i][RCOMP] );
+         rgba[i][GCOMP] = (GLchan) MAX2( rgba[i][GCOMP], dest[i][GCOMP] );
+         rgba[i][BCOMP] = (GLchan) MAX2( rgba[i][BCOMP], dest[i][BCOMP] );
+         rgba[i][ACOMP] = (GLchan) MAX2( rgba[i][ACOMP], dest[i][ACOMP] );
+      }
+   }
+}
+
+
+
+/*
+ * Modulate:  result = src * dest
+ */
+static void _BLENDAPI
+blend_modulate( GLcontext *ctx, GLuint n, const GLubyte mask[],
+                GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   GLuint i;
+   (void) ctx;
+
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+#if CHAN_TYPE == GL_FLOAT
+         rgba[i][RCOMP] = rgba[i][RCOMP] * dest[i][RCOMP];
+         rgba[i][GCOMP] = rgba[i][GCOMP] * dest[i][GCOMP];
+         rgba[i][BCOMP] = rgba[i][BCOMP] * dest[i][BCOMP];
+         rgba[i][ACOMP] = rgba[i][ACOMP] * dest[i][ACOMP];
+#else
+         GLint r = (rgba[i][RCOMP] * dest[i][RCOMP]) >> 8;
+         GLint g = (rgba[i][GCOMP] * dest[i][GCOMP]) >> 8;
+         GLint b = (rgba[i][BCOMP] * dest[i][BCOMP]) >> 8;
+         GLint a = (rgba[i][ACOMP] * dest[i][ACOMP]) >> 8;
+         rgba[i][RCOMP] = (GLchan) r;
+         rgba[i][GCOMP] = (GLchan) g;
+         rgba[i][BCOMP] = (GLchan) b;
+         rgba[i][ACOMP] = (GLchan) a;
+#endif
+      }
+   }
+}
+
+
+
+/*
+ * General case blend pixels.
+ * Input:  n - number of pixels
+ *         mask - the usual write mask
+ * In/Out:  rgba - the incoming and modified pixels
+ * Input:  dest - the pixels from the dest color buffer
+ */
+static void _BLENDAPI
+blend_general( GLcontext *ctx, GLuint n, const GLubyte mask[],
+               GLchan rgba[][4], CONST GLchan dest[][4] )
+{
+   GLfloat rscale = 1.0F / CHAN_MAXF;
+   GLfloat gscale = 1.0F / CHAN_MAXF;
+   GLfloat bscale = 1.0F / CHAN_MAXF;
+   GLfloat ascale = 1.0F / CHAN_MAXF;
+   GLuint i;
+
+   for (i=0;i<n;i++) {
+      if (mask[i]) {
+#if CHAN_TYPE == GL_FLOAT
+         GLfloat Rs, Gs, Bs, As;  /* Source colors */
+         GLfloat Rd, Gd, Bd, Ad;  /* Dest colors */
+#else
+         GLint Rs, Gs, Bs, As;  /* Source colors */
+         GLint Rd, Gd, Bd, Ad;  /* Dest colors */
+#endif
+         GLfloat sR, sG, sB, sA;  /* Source scaling */
+         GLfloat dR, dG, dB, dA;  /* Dest scaling */
+         GLfloat r, g, b, a;
+
+         /* Source Color */
+         Rs = rgba[i][RCOMP];
+         Gs = rgba[i][GCOMP];
+         Bs = rgba[i][BCOMP];
+         As = rgba[i][ACOMP];
+
+         /* Frame buffer color */
+         Rd = dest[i][RCOMP];
+         Gd = dest[i][GCOMP];
+         Bd = dest[i][BCOMP];
+         Ad = dest[i][ACOMP];
+
+         /* Source RGB factor */
+         switch (ctx->Color.BlendSrcRGB) {
+            case GL_ZERO:
+               sR = sG = sB = 0.0F;
+               break;
+            case GL_ONE:
+               sR = sG = sB = 1.0F;
+               break;
+            case GL_DST_COLOR:
+               sR = (GLfloat) Rd * rscale;
+               sG = (GLfloat) Gd * gscale;
+               sB = (GLfloat) Bd * bscale;
+               break;
+            case GL_ONE_MINUS_DST_COLOR:
+               sR = 1.0F - (GLfloat) Rd * rscale;
+               sG = 1.0F - (GLfloat) Gd * gscale;
+               sB = 1.0F - (GLfloat) Bd * bscale;
+               break;
+            case GL_SRC_ALPHA:
+               sR = sG = sB = (GLfloat) As * ascale;
+               break;
+            case GL_ONE_MINUS_SRC_ALPHA:
+               sR = sG = sB = (GLfloat) 1.0F - (GLfloat) As * ascale;
+               break;
+            case GL_DST_ALPHA:
+               sR = sG = sB = (GLfloat) Ad * ascale;
+               break;
+            case GL_ONE_MINUS_DST_ALPHA:
+               sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
+               break;
+            case GL_SRC_ALPHA_SATURATE:
+               if (As < CHAN_MAX - Ad) {
+                  sR = sG = sB = (GLfloat) As * ascale;
+               }
+               else {
+                  sR = sG = sB = 1.0F - (GLfloat) Ad * ascale;
+               }
+               break;
+            case GL_CONSTANT_COLOR:
+               sR = ctx->Color.BlendColor[0];
+               sG = ctx->Color.BlendColor[1];
+               sB = ctx->Color.BlendColor[2];
+               break;
+            case GL_ONE_MINUS_CONSTANT_COLOR:
+               sR = 1.0F - ctx->Color.BlendColor[0];
+               sG = 1.0F - ctx->Color.BlendColor[1];
+               sB = 1.0F - ctx->Color.BlendColor[2];
+               break;
+            case GL_CONSTANT_ALPHA:
+               sR = sG = sB = ctx->Color.BlendColor[3];
+               break;
+            case GL_ONE_MINUS_CONSTANT_ALPHA:
+               sR = sG = sB = 1.0F - ctx->Color.BlendColor[3];
+               break;
+            case GL_SRC_COLOR: /* GL_NV_blend_square */
+               sR = (GLfloat) Rs * rscale;
+               sG = (GLfloat) Gs * gscale;
+               sB = (GLfloat) Bs * bscale;
+               break;
+            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
+               sR = 1.0F - (GLfloat) Rs * rscale;
+               sG = 1.0F - (GLfloat) Gs * gscale;
+               sB = 1.0F - (GLfloat) Bs * bscale;
+               break;
+            default:
+               /* this should never happen */
+               _mesa_problem(ctx, "Bad blend source RGB factor in do_blend");
+               return;
+         }
+
+         /* Source Alpha factor */
+         switch (ctx->Color.BlendSrcA) {
+            case GL_ZERO:
+               sA = 0.0F;
+               break;
+            case GL_ONE:
+               sA = 1.0F;
+               break;
+            case GL_DST_COLOR:
+               sA = (GLfloat) Ad * ascale;
+               break;
+            case GL_ONE_MINUS_DST_COLOR:
+               sA = 1.0F - (GLfloat) Ad * ascale;
+               break;
+            case GL_SRC_ALPHA:
+               sA = (GLfloat) As * ascale;
+               break;
+            case GL_ONE_MINUS_SRC_ALPHA:
+               sA = (GLfloat) 1.0F - (GLfloat) As * ascale;
+               break;
+            case GL_DST_ALPHA:
+               sA =(GLfloat) Ad * ascale;
+               break;
+            case GL_ONE_MINUS_DST_ALPHA:
+               sA = 1.0F - (GLfloat) Ad * ascale;
+               break;
+            case GL_SRC_ALPHA_SATURATE:
+               sA = 1.0;
+               break;
+            case GL_CONSTANT_COLOR:
+               sA = ctx->Color.BlendColor[3];
+               break;
+            case GL_ONE_MINUS_CONSTANT_COLOR:
+               sA = 1.0F - ctx->Color.BlendColor[3];
+               break;
+            case GL_CONSTANT_ALPHA:
+               sA = ctx->Color.BlendColor[3];
+               break;
+            case GL_ONE_MINUS_CONSTANT_ALPHA:
+               sA = 1.0F - ctx->Color.BlendColor[3];
+               break;
+            case GL_SRC_COLOR: /* GL_NV_blend_square */
+               sA = (GLfloat) As * ascale;
+               break;
+            case GL_ONE_MINUS_SRC_COLOR: /* GL_NV_blend_square */
+               sA = 1.0F - (GLfloat) As * ascale;
+               break;
+            default:
+               /* this should never happen */
+               sA = 0.0F;
+               _mesa_problem(ctx, "Bad blend source A factor in do_blend");
+         }
+
+         /* Dest RGB factor */
+         switch (ctx->Color.BlendDstRGB) {
+            case GL_ZERO:
+               dR = dG = dB = 0.0F;
+               break;
+            case GL_ONE:
+               dR = dG = dB = 1.0F;
+               break;
+            case GL_SRC_COLOR:
+               dR = (GLfloat) Rs * rscale;
+               dG = (GLfloat) Gs * gscale;
+               dB = (GLfloat) Bs * bscale;
+               break;
+            case GL_ONE_MINUS_SRC_COLOR:
+               dR = 1.0F - (GLfloat) Rs * rscale;
+               dG = 1.0F - (GLfloat) Gs * gscale;
+               dB = 1.0F - (GLfloat) Bs * bscale;
+               break;
+            case GL_SRC_ALPHA:
+               dR = dG = dB = (GLfloat) As * ascale;
+               break;
+            case GL_ONE_MINUS_SRC_ALPHA:
+               dR = dG = dB = (GLfloat) 1.0F - (GLfloat) As * ascale;
+               break;
+            case GL_DST_ALPHA:
+               dR = dG = dB = (GLfloat) Ad * ascale;
+               break;
+            case GL_ONE_MINUS_DST_ALPHA:
+               dR = dG = dB = 1.0F - (GLfloat) Ad * ascale;
+               break;
+            case GL_CONSTANT_COLOR:
+               dR = ctx->Color.BlendColor[0];
+               dG = ctx->Color.BlendColor[1];
+               dB = ctx->Color.BlendColor[2];
+               break;
+            case GL_ONE_MINUS_CONSTANT_COLOR:
+               dR = 1.0F - ctx->Color.BlendColor[0];
+               dG = 1.0F - ctx->Color.BlendColor[1];
+               dB = 1.0F - ctx->Color.BlendColor[2];
+               break;
+            case GL_CONSTANT_ALPHA:
+               dR = dG = dB = ctx->Color.BlendColor[3];
+               break;
+            case GL_ONE_MINUS_CONSTANT_ALPHA:
+               dR = dG = dB = 1.0F - ctx->Color.BlendColor[3];
+               break;
+            case GL_DST_COLOR: /* GL_NV_blend_square */
+               dR = (GLfloat) Rd * rscale;
+               dG = (GLfloat) Gd * gscale;
+               dB = (GLfloat) Bd * bscale;
+               break;
+            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
+               dR = 1.0F - (GLfloat) Rd * rscale;
+               dG = 1.0F - (GLfloat) Gd * gscale;
+               dB = 1.0F - (GLfloat) Bd * bscale;
+               break;
+            default:
+               /* this should never happen */
+               dR = dG = dB = 0.0F;
+               _mesa_problem(ctx, "Bad blend dest RGB factor in do_blend");
+         }
+
+         /* Dest Alpha factor */
+         switch (ctx->Color.BlendDstA) {
+            case GL_ZERO:
+               dA = 0.0F;
+               break;
+            case GL_ONE:
+               dA = 1.0F;
+               break;
+            case GL_SRC_COLOR:
+               dA = (GLfloat) As * ascale;
+               break;
+            case GL_ONE_MINUS_SRC_COLOR:
+               dA = 1.0F - (GLfloat) As * ascale;
+               break;
+            case GL_SRC_ALPHA:
+               dA = (GLfloat) As * ascale;
+               break;
+            case GL_ONE_MINUS_SRC_ALPHA:
+               dA = (GLfloat) 1.0F - (GLfloat) As * ascale;
+               break;
+            case GL_DST_ALPHA:
+               dA = (GLfloat) Ad * ascale;
+               break;
+            case GL_ONE_MINUS_DST_ALPHA:
+               dA = 1.0F - (GLfloat) Ad * ascale;
+               break;
+            case GL_CONSTANT_COLOR:
+               dA = ctx->Color.BlendColor[3];
+               break;
+            case GL_ONE_MINUS_CONSTANT_COLOR:
+               dA = 1.0F - ctx->Color.BlendColor[3];
+               break;
+            case GL_CONSTANT_ALPHA:
+               dA = ctx->Color.BlendColor[3];
+               break;
+            case GL_ONE_MINUS_CONSTANT_ALPHA:
+               dA = 1.0F - ctx->Color.BlendColor[3];
+               break;
+            case GL_DST_COLOR: /* GL_NV_blend_square */
+               dA = (GLfloat) Ad * ascale;
+               break;
+            case GL_ONE_MINUS_DST_COLOR: /* GL_NV_blend_square */
+               dA = 1.0F - (GLfloat) Ad * ascale;
+               break;
+            default:
+               /* this should never happen */
+               dA = 0.0F;
+               _mesa_problem(ctx, "Bad blend dest A factor in do_blend");
+	       return;
+         }
+
+         /* Due to round-off problems we have to clamp against zero. */
+         /* Optimization: we don't have to do this for all src & dst factors */
+         if (dA < 0.0F)  dA = 0.0F;
+         if (dR < 0.0F)  dR = 0.0F;
+         if (dG < 0.0F)  dG = 0.0F;
+         if (dB < 0.0F)  dB = 0.0F;
+         if (sA < 0.0F)  sA = 0.0F;
+         if (sR < 0.0F)  sR = 0.0F;
+         if (sG < 0.0F)  sG = 0.0F;
+         if (sB < 0.0F)  sB = 0.0F;
+
+         ASSERT( sR <= 1.0 );
+         ASSERT( sG <= 1.0 );
+         ASSERT( sB <= 1.0 );
+         ASSERT( sA <= 1.0 );
+         ASSERT( dR <= 1.0 );
+         ASSERT( dG <= 1.0 );
+         ASSERT( dB <= 1.0 );
+         ASSERT( dA <= 1.0 );
+
+         /* compute blended color */
+#if CHAN_TYPE == GL_FLOAT
+         if (ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+            r = Rs * sR + Rd * dR;
+            g = Gs * sG + Gd * dG;
+            b = Bs * sB + Bd * dB;
+            a = As * sA + Ad * dA;
+         }
+         else if (ctx->Color.BlendEquation==GL_FUNC_SUBTRACT_EXT) {
+            r = Rs * sR - Rd * dR;
+            g = Gs * sG - Gd * dG;
+            b = Bs * sB - Bd * dB;
+            a = As * sA - Ad * dA;
+         }
+         else if (ctx->Color.BlendEquation==GL_FUNC_REVERSE_SUBTRACT_EXT) {
+            r = Rd * dR - Rs * sR;
+            g = Gd * dG - Gs * sG;
+            b = Bd * dB - Bs * sB;
+            a = Ad * dA - As * sA;
+         }
+         else {
+            /* should never get here */
+            r = g = b = a = 0.0F;  /* silence uninitialized var warning */
+            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
+         }
+
+         /* final clamping */
+         rgba[i][RCOMP] = CLAMP( r, 0.0F, CHAN_MAXF );
+         rgba[i][GCOMP] = CLAMP( g, 0.0F, CHAN_MAXF );
+         rgba[i][BCOMP] = CLAMP( b, 0.0F, CHAN_MAXF );
+         rgba[i][ACOMP] = CLAMP( a, 0.0F, CHAN_MAXF );
+#else
+         if (ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
+            r = Rs * sR + Rd * dR + 0.5F;
+            g = Gs * sG + Gd * dG + 0.5F;
+            b = Bs * sB + Bd * dB + 0.5F;
+            a = As * sA + Ad * dA + 0.5F;
+         }
+         else if (ctx->Color.BlendEquation==GL_FUNC_SUBTRACT_EXT) {
+            r = Rs * sR - Rd * dR + 0.5F;
+            g = Gs * sG - Gd * dG + 0.5F;
+            b = Bs * sB - Bd * dB + 0.5F;
+            a = As * sA - Ad * dA + 0.5F;
+         }
+         else if (ctx->Color.BlendEquation==GL_FUNC_REVERSE_SUBTRACT_EXT) {
+            r = Rd * dR - Rs * sR + 0.5F;
+            g = Gd * dG - Gs * sG + 0.5F;
+            b = Bd * dB - Bs * sB + 0.5F;
+            a = Ad * dA - As * sA + 0.5F;
+         }
+         else {
+            /* should never get here */
+            r = g = b = a = 0.0F;  /* silence uninitialized var warning */
+            _mesa_problem(ctx, "unexpected BlendEquation in blend_general()");
+         }
+
+         /* final clamping */
+         rgba[i][RCOMP] = (GLchan) (GLint) CLAMP( r, 0.0F, CHAN_MAXF );
+         rgba[i][GCOMP] = (GLchan) (GLint) CLAMP( g, 0.0F, CHAN_MAXF );
+         rgba[i][BCOMP] = (GLchan) (GLint) CLAMP( b, 0.0F, CHAN_MAXF );
+         rgba[i][ACOMP] = (GLchan) (GLint) CLAMP( a, 0.0F, CHAN_MAXF );
+#endif
+      }
+   }
+}
+
+
+
+
+
+/*
+ * Analyze current blending parameters to pick fastest blending function.
+ * Result: the ctx->Color.BlendFunc pointer is updated.
+ */
+void _swrast_choose_blend_func( GLcontext *ctx )
+{
+   const GLenum eq = ctx->Color.BlendEquation;
+   const GLenum srcRGB = ctx->Color.BlendSrcRGB;
+   const GLenum dstRGB = ctx->Color.BlendDstRGB;
+   const GLenum srcA = ctx->Color.BlendSrcA;
+   const GLenum dstA = ctx->Color.BlendDstA;
+
+   if (srcRGB != srcA || dstRGB != dstA) {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_general;
+   }
+   else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_SRC_ALPHA
+	    && dstRGB==GL_ONE_MINUS_SRC_ALPHA) {
+#if defined(USE_MMX_ASM)
+      if ( cpu_has_mmx ) {
+	 SWRAST_CONTEXT(ctx)->BlendFunc = _mesa_mmx_blend_transparency;
+      }
+      else
+#endif
+	 SWRAST_CONTEXT(ctx)->BlendFunc = blend_transparency;
+   }
+   else if (eq==GL_FUNC_ADD_EXT && srcRGB==GL_ONE && dstRGB==GL_ONE) {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_add;
+   }
+   else if (((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_REVERSE_SUBTRACT_EXT)
+	     && (srcRGB==GL_ZERO && dstRGB==GL_SRC_COLOR))
+	    ||
+	    ((eq==GL_FUNC_ADD_EXT || eq==GL_FUNC_SUBTRACT_EXT)
+	     && (srcRGB==GL_DST_COLOR && dstRGB==GL_ZERO))) {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_modulate;
+   }
+   else if (eq==GL_MIN_EXT) {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_min;
+   }
+   else if (eq==GL_MAX_EXT) {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_max;
+   }
+   else if (eq==GL_FUNC_ADD_EXT && srcRGB == GL_ZERO && dstRGB == GL_ONE) {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_noop;
+   }
+   else if (eq==GL_FUNC_ADD_EXT && srcRGB == GL_ONE && dstRGB == GL_ZERO) {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_replace;
+   }
+   else {
+      SWRAST_CONTEXT(ctx)->BlendFunc = blend_general;
+   }
+}
+
+
+
+/*
+ * Apply the blending operator to a span of pixels.
+ * Input:  n - number of pixels in span
+ *         x, y - location of leftmost pixel in span in window coords.
+ *         mask - boolean mask indicating which pixels to blend.
+ * In/Out:  rgba - pixel values
+ */
+void
+_mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                  GLchan rgba[][4], const GLubyte mask[] )
+{
+   GLchan dest[MAX_WIDTH][4];
+
+   /* Check if device driver can do the work */
+   if (ctx->Color.BlendEquation==GL_LOGIC_OP &&
+       !ctx->Color.ColorLogicOpEnabled) {
+      return;
+   }
+
+   /* Read span of current frame buffer pixels */
+   _mesa_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
+
+   SWRAST_CONTEXT(ctx)->BlendFunc( ctx, n, mask, rgba,
+				   (const GLchan (*)[4]) dest );
+}
+
+
+
+/*
+ * Apply the blending operator to an array of pixels.
+ * Input:  n - number of pixels in span
+ *         x, y - array of pixel locations
+ *         mask - boolean mask indicating which pixels to blend.
+ * In/Out:  rgba - pixel values
+ */
+void
+_mesa_blend_pixels( GLcontext *ctx,
+                    GLuint n, const GLint x[], const GLint y[],
+                    GLchan rgba[][4], const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLchan dest[PB_SIZE][4];
+
+   /* Check if device driver can do the work */
+   if (ctx->Color.BlendEquation==GL_LOGIC_OP &&
+       !ctx->Color.ColorLogicOpEnabled) {
+      return;
+   }
+
+   /* Read pixels from current color buffer */
+   (*swrast->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+   if (swrast->_RasterMask & ALPHABUF_BIT) {
+      _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
+   }
+
+   swrast->BlendFunc( ctx, n, mask, rgba, (const GLchan (*)[4])dest );
+}
Index: xc/extras/Mesa/src/swrast/s_blend.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_blend.h:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_blend.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,50 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_BLEND_H
+#define S_BLEND_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+
+extern void
+_mesa_blend_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                  GLchan rgba[][4], const GLubyte mask[] );
+
+
+extern void
+_mesa_blend_pixels( GLcontext *ctx,
+                    GLuint n, const GLint x[], const GLint y[],
+                    GLchan rgba[][4], const GLubyte mask[] );
+
+extern void
+_swrast_choose_blend_func( GLcontext *ctx );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_buffers.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_buffers.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_buffers.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,259 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_accum.h"
+#include "s_alphabuf.h"
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_masking.h"
+#include "s_stencil.h"
+
+
+
+
+/*
+ * Clear the color buffer when glColorMask or glIndexMask is in effect.
+ */
+static void
+clear_color_buffer_with_masking( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLint x = ctx->DrawBuffer->_Xmin;
+   const GLint y = ctx->DrawBuffer->_Ymin;
+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+
+   if (ctx->Visual.rgbMode) {
+      /* RGBA mode */
+      const GLchan r = ctx->Color.ClearColor[0];
+      const GLchan g = ctx->Color.ClearColor[1];
+      const GLchan b = ctx->Color.ClearColor[2];
+      const GLchan a = ctx->Color.ClearColor[3];
+      GLint i;
+      for (i = 0; i < height; i++) {
+         GLchan rgba[MAX_WIDTH][4];
+         GLint j;
+         for (j = 0; j < width; j++) {
+            rgba[j][RCOMP] = r;
+            rgba[j][GCOMP] = g;
+            rgba[j][BCOMP] = b;
+            rgba[j][ACOMP] = a;
+         }
+         _mesa_mask_rgba_span( ctx, width, x, y + i, rgba );
+         (*swrast->Driver.WriteRGBASpan)( ctx, width, x, y + i,
+				       (CONST GLchan (*)[4]) rgba, NULL );
+      }
+   }
+   else {
+      /* Color index mode */
+      GLuint span[MAX_WIDTH];
+      GLubyte mask[MAX_WIDTH];
+      GLint i, j;
+      MEMSET( mask, 1, width );
+      for (i=0;i<height;i++) {
+         for (j=0;j<width;j++) {
+            span[j] = ctx->Color.ClearIndex;
+         }
+         _mesa_mask_index_span( ctx, width, x, y + i, span );
+         (*swrast->Driver.WriteCI32Span)( ctx, width, x, y + i, span, mask );
+      }
+   }
+}
+
+
+
+/*
+ * Clear a color buffer without index/channel masking.
+ */
+static void
+clear_color_buffer(GLcontext *ctx)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLint x = ctx->DrawBuffer->_Xmin;
+   const GLint y = ctx->DrawBuffer->_Ymin;
+   const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+   const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+
+   if (ctx->Visual.rgbMode) {
+      /* RGBA mode */
+      const GLchan r = ctx->Color.ClearColor[0];
+      const GLchan g = ctx->Color.ClearColor[1];
+      const GLchan b = ctx->Color.ClearColor[2];
+      const GLchan a = ctx->Color.ClearColor[3];
+      GLchan span[MAX_WIDTH][4];
+      GLint i;
+
+      ASSERT(*((GLuint *) &ctx->Color.ColorMask) == 0xffffffff);
+
+      for (i = 0; i < width; i++) {
+         span[i][RCOMP] = r;
+         span[i][GCOMP] = g;
+         span[i][BCOMP] = b;
+         span[i][ACOMP] = a;
+      }
+      for (i = 0; i < height; i++) {
+         (*swrast->Driver.WriteRGBASpan)( ctx, width, x, y + i,
+                                       (CONST GLchan (*)[4]) span, NULL );
+      }
+   }
+   else {
+      /* Color index mode */
+      ASSERT((ctx->Color.IndexMask & ((1 << ctx->Visual.indexBits) - 1))
+             == (GLuint) ((1 << ctx->Visual.indexBits) - 1));
+      if (ctx->Visual.indexBits == 8) {
+         /* 8-bit clear */
+         GLubyte span[MAX_WIDTH];
+         GLint i;
+         MEMSET(span, ctx->Color.ClearIndex, width);
+         for (i = 0; i < height; i++) {
+            (*swrast->Driver.WriteCI8Span)( ctx, width, x, y + i, span, NULL );
+         }
+      }
+      else {
+         /* non 8-bit clear */
+         GLuint span[MAX_WIDTH];
+         GLint i;
+         for (i = 0; i < width; i++) {
+            span[i] = ctx->Color.ClearIndex;
+         }
+         for (i = 0; i < height; i++) {
+            (*swrast->Driver.WriteCI32Span)( ctx, width, x, y + i, span, NULL );
+         }
+      }
+   }
+}
+
+
+
+/*
+ * Clear the front/back/left/right color buffers.
+ * This function is usually only called if we need to clear the
+ * buffers with masking.
+ */
+static void
+clear_color_buffers(GLcontext *ctx)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
+   GLuint bufferBit;
+
+   /* loop over four possible dest color buffers */
+   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+      if (bufferBit & ctx->Color.DrawDestMask) {
+         if (bufferBit == FRONT_LEFT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+            (void) (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_LEFT);
+         }
+         else if (bufferBit == FRONT_RIGHT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+            (void) (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_FRONT_RIGHT);
+         }
+         else if (bufferBit == BACK_LEFT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+            (void) (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_LEFT);
+         }
+         else {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+            (void) (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer, GL_BACK_RIGHT);
+         }
+
+         if (colorMask != 0xffffffff) {
+            clear_color_buffer_with_masking(ctx);
+         }
+         else {
+            clear_color_buffer(ctx);
+         }
+      }
+   }
+
+   /* restore default read/draw buffers */
+   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
+   (void) (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer );
+}
+
+
+
+void
+_swrast_Clear( GLcontext *ctx, GLbitfield mask,
+	       GLboolean all,
+	       GLint x, GLint y, GLint width, GLint height )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+#ifdef DEBUG
+   {
+      GLbitfield legalBits = DD_FRONT_LEFT_BIT |
+	 DD_FRONT_RIGHT_BIT |
+	 DD_BACK_LEFT_BIT |
+	 DD_BACK_RIGHT_BIT |
+	 DD_DEPTH_BIT |
+	 DD_STENCIL_BIT |
+	 DD_ACCUM_BIT;
+      assert((mask & (~legalBits)) == 0);
+   }
+#endif
+
+   RENDER_START(swrast,ctx);
+
+   /* do software clearing here */
+   if (mask) {
+      if (mask & ctx->Color.DrawDestMask)   clear_color_buffers(ctx);
+      if (mask & GL_DEPTH_BUFFER_BIT)    _mesa_clear_depth_buffer(ctx);
+      if (mask & GL_ACCUM_BUFFER_BIT)    _mesa_clear_accum_buffer(ctx);
+      if (mask & GL_STENCIL_BUFFER_BIT)  _mesa_clear_stencil_buffer(ctx);
+   }
+
+   /* clear software-based alpha buffer(s) */
+   if ( (mask & GL_COLOR_BUFFER_BIT)
+	&& ctx->DrawBuffer->UseSoftwareAlphaBuffers
+	&& ctx->Color.ColorMask[ACOMP]) {
+      _mesa_clear_alpha_buffers( ctx );
+   }
+
+   RENDER_FINISH(swrast,ctx);
+}
+
+
+void
+_swrast_alloc_buffers( GLframebuffer *buffer )
+{
+   /* Reallocate other buffers if needed. */
+   if (buffer->UseSoftwareDepthBuffer) {
+      _mesa_alloc_depth_buffer( buffer );
+   }
+   if (buffer->UseSoftwareStencilBuffer) {
+      _mesa_alloc_stencil_buffer( buffer );
+   }
+   if (buffer->UseSoftwareAccumBuffer) {
+      _mesa_alloc_accum_buffer( buffer );
+   }
+   if (buffer->UseSoftwareAlphaBuffers) {
+      _mesa_alloc_alpha_buffers( buffer );
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_context.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_context.c:1.4
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_context.c	Fri Dec 20 08:20:32 2002
@@ -0,0 +1,583 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "mtypes.h"
+#include "mem.h"
+
+#include "s_pb.h"
+#include "s_points.h"
+#include "s_lines.h"
+#include "s_triangle.h"
+#include "s_blend.h"
+#include "s_context.h"
+#include "s_texture.h"
+
+
+
+
+
+/*
+ * Recompute the value of swrast->_RasterMask, etc. according to
+ * the current context.
+ */
+static void
+_swrast_update_rasterflags( GLcontext *ctx )
+{
+   GLuint RasterMask = 0;
+
+   if (ctx->Color.AlphaEnabled)           RasterMask |= ALPHATEST_BIT;
+   if (ctx->Color.BlendEnabled)           RasterMask |= BLEND_BIT;
+   if (ctx->Depth.Test)                   RasterMask |= DEPTH_BIT;
+   if (ctx->Fog.Enabled)                  RasterMask |= FOG_BIT;
+   if (ctx->Scissor.Enabled)              RasterMask |= SCISSOR_BIT;
+   if (ctx->Stencil.Enabled)              RasterMask |= STENCIL_BIT;
+   if (ctx->Visual.rgbMode) {
+      const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask);
+      if (colorMask != 0xffffffff)        RasterMask |= MASKING_BIT;
+      if (ctx->Color.ColorLogicOpEnabled) RasterMask |= LOGIC_OP_BIT;
+      if (ctx->Texture._ReallyEnabled)     RasterMask |= TEXTURE_BIT;
+   }
+   else {
+      if (ctx->Color.IndexMask != 0xffffffff) RasterMask |= MASKING_BIT;
+      if (ctx->Color.IndexLogicOpEnabled)     RasterMask |= LOGIC_OP_BIT;
+   }
+
+   if (ctx->DrawBuffer->UseSoftwareAlphaBuffers
+       && ctx->Color.ColorMask[ACOMP]
+       && ctx->Color.DrawBuffer != GL_NONE)
+      RasterMask |= ALPHABUF_BIT;
+
+   if (   ctx->Viewport.X < 0
+       || ctx->Viewport.X + ctx->Viewport.Width > (GLint) ctx->DrawBuffer->Width
+       || ctx->Viewport.Y < 0
+       || ctx->Viewport.Y + ctx->Viewport.Height > (GLint) ctx->DrawBuffer->Height) {
+      RasterMask |= WINCLIP_BIT;
+   }
+
+   if (ctx->Depth.OcclusionTest)
+      RasterMask |= OCCLUSION_BIT;
+
+
+   /* If we're not drawing to exactly one color buffer set the
+    * MULTI_DRAW_BIT flag.  Also set it if we're drawing to no
+    * buffers or the RGBA or CI mask disables all writes.
+    */
+   if (ctx->Color.DrawBuffer == GL_FRONT_AND_BACK ||
+       ctx->Color.DrawBuffer == GL_NONE) {
+      RasterMask |= MULTI_DRAW_BIT;
+   }
+   else if (ctx->Visual.rgbMode && *((GLuint *) ctx->Color.ColorMask) == 0) {
+      RasterMask |= MULTI_DRAW_BIT; /* all RGBA channels disabled */
+   }
+   else if (!ctx->Visual.rgbMode && ctx->Color.IndexMask==0) {
+      RasterMask |= MULTI_DRAW_BIT; /* all color index bits disabled */
+   }
+
+   SWRAST_CONTEXT(ctx)->_RasterMask = RasterMask;
+}
+
+
+static void
+_swrast_update_polygon( GLcontext *ctx )
+{
+   GLfloat backface_sign = 1;
+
+   if (ctx->Polygon.CullFlag) {
+      backface_sign = 1;
+      switch(ctx->Polygon.CullFaceMode) {
+      case GL_BACK:
+	 if(ctx->Polygon.FrontFace==GL_CCW)
+	    backface_sign = -1;
+	 break;
+      case GL_FRONT:
+	 if(ctx->Polygon.FrontFace!=GL_CCW)
+	    backface_sign = -1;
+	 break;
+      default:
+      case GL_FRONT_AND_BACK:
+	 backface_sign = 0;
+	 break;
+      }
+   }
+   else {
+      backface_sign = 0;
+   }
+
+   SWRAST_CONTEXT(ctx)->_backface_sign = backface_sign;
+}
+
+
+static void
+_swrast_update_hint( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   swrast->_PreferPixelFog = (!swrast->AllowVertexFog ||
+			      (ctx->Hint.Fog == GL_NICEST &&
+			       swrast->AllowPixelFog));
+}
+
+#define _SWRAST_NEW_DERIVED (_SWRAST_NEW_RASTERMASK |	\
+			     _NEW_TEXTURE |		\
+			     _NEW_HINT |		\
+			     _NEW_POLYGON )
+
+/* State referenced by _swrast_choose_triangle, _swrast_choose_line.
+ */
+#define _SWRAST_NEW_TRIANGLE (_SWRAST_NEW_DERIVED |		\
+			      _NEW_RENDERMODE|			\
+                              _NEW_POLYGON|			\
+                              _NEW_DEPTH|			\
+                              _NEW_STENCIL|			\
+                              _NEW_COLOR|			\
+                              _NEW_TEXTURE|			\
+                              _SWRAST_NEW_RASTERMASK|		\
+                              _NEW_LIGHT|			\
+                              _NEW_FOG |			\
+			      _DD_NEW_SEPARATE_SPECULAR)
+
+#define _SWRAST_NEW_LINE (_SWRAST_NEW_DERIVED |		\
+			  _NEW_RENDERMODE|		\
+                          _NEW_LINE|			\
+                          _NEW_TEXTURE|			\
+                          _NEW_LIGHT|			\
+                          _NEW_FOG|			\
+                          _NEW_DEPTH |			\
+                          _DD_NEW_SEPARATE_SPECULAR)
+
+#define _SWRAST_NEW_POINT (_SWRAST_NEW_DERIVED |	\
+			   _NEW_RENDERMODE |		\
+			   _NEW_POINT |			\
+			   _NEW_TEXTURE |		\
+			   _NEW_LIGHT |			\
+			   _NEW_FOG |			\
+                           _DD_NEW_SEPARATE_SPECULAR)
+
+#define _SWRAST_NEW_TEXTURE_SAMPLE_FUNC _NEW_TEXTURE
+
+#define _SWRAST_NEW_BLEND_FUNC _NEW_COLOR
+
+
+
+/* Stub for swrast->Triangle to select a true triangle function
+ * after a state change.
+ */
+static void
+_swrast_validate_triangle( GLcontext *ctx,
+			   const SWvertex *v0,
+                           const SWvertex *v1,
+                           const SWvertex *v2 )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   _swrast_validate_derived( ctx );
+   swrast->choose_triangle( ctx );
+
+   if ((ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) &&
+       !ctx->Texture._ReallyEnabled) {
+      swrast->SpecTriangle = swrast->Triangle;
+      swrast->Triangle = _swrast_add_spec_terms_triangle;
+   }
+
+   swrast->Triangle( ctx, v0, v1, v2 );
+}
+
+static void
+_swrast_validate_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   _swrast_validate_derived( ctx );
+   swrast->choose_line( ctx );
+
+   if ((ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) &&
+       !ctx->Texture._ReallyEnabled) {
+      swrast->SpecLine = swrast->Line;
+      swrast->Line = _swrast_add_spec_terms_line;
+   }
+
+
+   swrast->Line( ctx, v0, v1 );
+}
+
+static void
+_swrast_validate_point( GLcontext *ctx, const SWvertex *v0 )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   _swrast_validate_derived( ctx );
+   swrast->choose_point( ctx );
+
+   if ((ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) &&
+       !ctx->Texture._ReallyEnabled) {
+      swrast->SpecPoint = swrast->Point;
+      swrast->Point = _swrast_add_spec_terms_point;
+   }
+
+   swrast->Point( ctx, v0 );
+}
+
+static void
+_swrast_validate_blend_func( GLcontext *ctx, GLuint n,
+			     const GLubyte mask[],
+			     GLchan src[][4],
+			     CONST GLchan dst[][4] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   _swrast_validate_derived( ctx );
+   _swrast_choose_blend_func( ctx );
+
+   swrast->BlendFunc( ctx, n, mask, src, dst );
+}
+
+
+static void
+_swrast_validate_texture_sample( GLcontext *ctx, GLuint texUnit,
+				 const struct gl_texture_object *tObj,
+				 GLuint n,
+				 const GLfloat s[], const GLfloat t[],
+				 const GLfloat u[], const GLfloat lambda[],
+				 GLchan rgba[][4] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   _swrast_validate_derived( ctx );
+   _swrast_choose_texture_sample_func( ctx, texUnit, tObj );
+
+   swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, s, t, u,
+				   lambda, rgba );
+}
+
+
+static void
+_swrast_sleep( GLcontext *ctx, GLuint new_state )
+{
+}
+
+
+static void
+_swrast_invalidate_state( GLcontext *ctx, GLuint new_state )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint i;
+
+   swrast->NewState |= new_state;
+
+   /* After 10 statechanges without any swrast functions being called,
+    * put the module to sleep.
+    */
+   if (++swrast->StateChanges > 10) {
+      swrast->InvalidateState = _swrast_sleep;
+      swrast->NewState = ~0;
+      new_state = ~0;
+   }
+
+   if (new_state & swrast->invalidate_triangle)
+      swrast->Triangle = _swrast_validate_triangle;
+
+   if (new_state & swrast->invalidate_line)
+      swrast->Line = _swrast_validate_line;
+
+   if (new_state & swrast->invalidate_point)
+      swrast->Point = _swrast_validate_point;
+
+   if (new_state & _SWRAST_NEW_BLEND_FUNC)
+      swrast->BlendFunc = _swrast_validate_blend_func;
+
+   if (new_state & _SWRAST_NEW_TEXTURE_SAMPLE_FUNC)
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+	 swrast->TextureSample[i] = _swrast_validate_texture_sample;
+
+
+   if (ctx->Visual.rgbMode) {
+      ASSERT(swrast->Driver.WriteRGBASpan);
+      ASSERT(swrast->Driver.WriteRGBSpan);
+      ASSERT(swrast->Driver.WriteMonoRGBASpan);
+      ASSERT(swrast->Driver.WriteRGBAPixels);
+      ASSERT(swrast->Driver.WriteMonoRGBAPixels);
+      ASSERT(swrast->Driver.ReadRGBASpan);
+      ASSERT(swrast->Driver.ReadRGBAPixels);
+   }
+   else {
+      ASSERT(swrast->Driver.WriteCI32Span);
+      ASSERT(swrast->Driver.WriteCI8Span);
+      ASSERT(swrast->Driver.WriteMonoCISpan);
+      ASSERT(swrast->Driver.WriteCI32Pixels);
+      ASSERT(swrast->Driver.WriteMonoCIPixels);
+      ASSERT(swrast->Driver.ReadCI32Span);
+      ASSERT(swrast->Driver.ReadCI32Pixels);
+   }
+
+}
+
+
+
+void
+_swrast_validate_derived( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (swrast->NewState)
+   {
+      if (swrast->NewState & _SWRAST_NEW_RASTERMASK)
+ 	 _swrast_update_rasterflags( ctx );
+
+      if (swrast->NewState & _NEW_POLYGON)
+	 _swrast_update_polygon( ctx );
+
+      if (swrast->NewState & _NEW_HINT)
+	 _swrast_update_hint( ctx );
+
+      swrast->NewState = 0;
+      swrast->StateChanges = 0;
+      swrast->InvalidateState = _swrast_invalidate_state;
+   }
+}
+
+#define SWRAST_DEBUG 0
+
+/* Public entrypoints:  See also s_accum.c, s_bitmap.c, etc.
+ */
+void
+_swrast_Quad( GLcontext *ctx,
+	      const SWvertex *v0, const SWvertex *v1,
+              const SWvertex *v2, const SWvertex *v3 )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_Quad\n");
+      _swrast_print_vertex( ctx, v0 );
+      _swrast_print_vertex( ctx, v1 );
+      _swrast_print_vertex( ctx, v2 );
+      _swrast_print_vertex( ctx, v3 );
+   }
+   SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v3 );
+   SWRAST_CONTEXT(ctx)->Triangle( ctx, v1, v2, v3 );
+}
+
+void
+_swrast_Triangle( GLcontext *ctx, const SWvertex *v0,
+                  const SWvertex *v1, const SWvertex *v2 )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_Triangle\n");
+      _swrast_print_vertex( ctx, v0 );
+      _swrast_print_vertex( ctx, v1 );
+      _swrast_print_vertex( ctx, v2 );
+   }
+   SWRAST_CONTEXT(ctx)->Triangle( ctx, v0, v1, v2 );
+}
+
+void
+_swrast_Line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_Line\n");
+      _swrast_print_vertex( ctx, v0 );
+      _swrast_print_vertex( ctx, v1 );
+   }
+   SWRAST_CONTEXT(ctx)->Line( ctx, v0, v1 );
+}
+
+void
+_swrast_Point( GLcontext *ctx, const SWvertex *v0 )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_Point\n");
+      _swrast_print_vertex( ctx, v0 );
+   }
+   SWRAST_CONTEXT(ctx)->Point( ctx, v0 );
+}
+
+void
+_swrast_InvalidateState( GLcontext *ctx, GLuint new_state )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_InvalidateState\n");
+   }
+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, new_state );
+}
+
+void
+_swrast_ResetLineStipple( GLcontext *ctx )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_ResetLineStipple\n");
+   }
+   SWRAST_CONTEXT(ctx)->StippleCounter = 0;
+}
+
+void
+_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_allow_vertex_fog %d\n", value);
+   }
+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
+   SWRAST_CONTEXT(ctx)->AllowVertexFog = value;
+}
+
+void
+_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value )
+{
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_allow_pixel_fog %d\n", value);
+   }
+   SWRAST_CONTEXT(ctx)->InvalidateState( ctx, _NEW_HINT );
+   SWRAST_CONTEXT(ctx)->AllowPixelFog = value;
+}
+
+
+GLboolean
+_swrast_CreateContext( GLcontext *ctx )
+{
+   GLuint i;
+   SWcontext *swrast = (SWcontext *)CALLOC(sizeof(SWcontext));
+
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_CreateContext\n");
+   }
+
+   if (!swrast)
+      return GL_FALSE;
+
+   swrast->PB = _mesa_alloc_pb();
+   if (!swrast->PB) {
+      FREE(swrast);
+      return GL_FALSE;
+   }
+
+   swrast->NewState = ~0;
+
+   swrast->choose_point = _swrast_choose_point;
+   swrast->choose_line = _swrast_choose_line;
+   swrast->choose_triangle = _swrast_choose_triangle;
+
+   swrast->invalidate_point = _SWRAST_NEW_POINT;
+   swrast->invalidate_line = _SWRAST_NEW_LINE;
+   swrast->invalidate_triangle = _SWRAST_NEW_TRIANGLE;
+
+   swrast->Point = _swrast_validate_point;
+   swrast->Line = _swrast_validate_line;
+   swrast->Triangle = _swrast_validate_triangle;
+   swrast->InvalidateState = _swrast_sleep;
+   swrast->BlendFunc = _swrast_validate_blend_func;
+
+   swrast->AllowVertexFog = GL_TRUE;
+   swrast->AllowPixelFog = GL_TRUE;
+
+   /* Optimized Accum buffer */
+   swrast->_IntegerAccumMode = GL_TRUE;
+   swrast->_IntegerAccumScaler = 0.0;
+
+
+   for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++)
+      swrast->TextureSample[i] = _swrast_validate_texture_sample;
+
+   ctx->swrast_context = swrast;
+   return GL_TRUE;
+}
+
+void
+_swrast_DestroyContext( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (SWRAST_DEBUG) {
+      fprintf(stderr, "_swrast_DestroyContext\n");
+   }
+
+   FREE( swrast->PB );
+   FREE( swrast );
+
+   ctx->swrast_context = 0;
+}
+
+
+struct swrast_device_driver *
+_swrast_GetDeviceDriverReference( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   return &swrast->Driver;
+}
+
+
+void
+_swrast_render_start( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   if (swrast->Driver.SpanRenderStart)
+      swrast->Driver.SpanRenderStart( ctx );
+}
+
+void
+_swrast_render_finish( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   _swrast_flush(ctx);
+   if (swrast->Driver.SpanRenderFinish)
+      swrast->Driver.SpanRenderFinish( ctx );
+}
+
+
+#define SWRAST_DEBUG_VERTICES 0
+
+void
+_swrast_print_vertex( GLcontext *ctx, const SWvertex *v )
+{
+   GLuint i;
+
+   if (SWRAST_DEBUG_VERTICES) {
+      fprintf(stderr, "win %f %f %f %f\n",
+	      v->win[0], v->win[1], v->win[2], v->win[3]);
+
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+	 if (ctx->Texture.Unit[i]._ReallyEnabled)
+	    fprintf(stderr, "texcoord[%d] %f %f %f %f\n", i,
+		    v->texcoord[i][0], v->texcoord[i][1],
+		    v->texcoord[i][2], v->texcoord[i][3]);
+
+#if CHAN_TYPE == GL_FLOAT
+      fprintf(stderr, "color %f %f %f %f\n",
+	      v->color[0], v->color[1], v->color[2], v->color[3]);
+      fprintf(stderr, "spec %f %f %f %f\n",
+	      v->specular[0], v->specular[1], v->specular[2], v->specular[3]);
+#else
+      fprintf(stderr, "color %d %d %d %d\n",
+	      v->color[0], v->color[1], v->color[2], v->color[3]);
+      fprintf(stderr, "spec %d %d %d %d\n",
+	      v->specular[0], v->specular[1], v->specular[2], v->specular[3]);
+#endif
+      fprintf(stderr, "fog %f\n", v->fog);
+      fprintf(stderr, "index %d\n", v->index);
+      fprintf(stderr, "pointsize %f\n", v->pointSize);
+      fprintf(stderr, "\n");
+   }
+}
+
+
Index: xc/extras/Mesa/src/swrast/s_context.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_context.h:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_context.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,204 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef S_CONTEXT_H
+#define S_CONTEXT_H
+
+#include "mtypes.h"
+#include "swrast.h"
+
+/*
+ * For texture sampling:
+ */
+typedef void (*TextureSampleFunc)( GLcontext *ctx, GLuint texUnit,
+				   const struct gl_texture_object *tObj,
+                                   GLuint n,
+                                   const GLfloat s[], const GLfloat t[],
+                                   const GLfloat u[], const GLfloat lambda[],
+                                   GLchan rgba[][4] );
+
+
+
+/*
+ * Blending function
+ */
+#ifdef USE_MMX_ASM
+typedef void (_ASMAPIP blend_func)( GLcontext *ctx, GLuint n,
+                                    const GLubyte mask[],
+                                    GLchan src[][4], CONST GLchan dst[][4] );
+#else
+typedef void (*blend_func)( GLcontext *ctx, GLuint n, const GLubyte mask[],
+                            GLchan src[][4], CONST GLchan dst[][4] );
+#endif
+
+typedef void (*swrast_point_func)( GLcontext *ctx, const SWvertex *);
+
+typedef void (*swrast_line_func)( GLcontext *ctx,
+                                  const SWvertex *, const SWvertex *);
+
+typedef void (*swrast_tri_func)( GLcontext *ctx, const SWvertex *,
+                                 const SWvertex *, const SWvertex *);
+
+
+
+/*
+ * Bitmasks to indicate which rasterization options are enabled (RasterMask)
+ */
+#define ALPHATEST_BIT		0x001	/* Alpha-test pixels */
+#define BLEND_BIT		0x002	/* Blend pixels */
+#define DEPTH_BIT		0x004	/* Depth-test pixels */
+#define FOG_BIT			0x008	/* Fog pixels */
+#define LOGIC_OP_BIT		0x010	/* Apply logic op in software */
+#define SCISSOR_BIT		0x020	/* Scissor pixels */
+#define STENCIL_BIT		0x040	/* Stencil pixels */
+#define MASKING_BIT		0x080	/* Do glColorMask or glIndexMask */
+#define ALPHABUF_BIT		0x100	/* Using software alpha buffer */
+#define WINCLIP_BIT		0x200	/* Clip pixels/primitives to window */
+#define MULTI_DRAW_BIT		0x400	/* Write to more than one color- */
+                                        /* buffer or no buffers. */
+#define OCCLUSION_BIT           0x800   /* GL_HP_occlusion_test enabled */
+#define TEXTURE_BIT		0x1000	/* Texturing really enabled */
+
+
+#define _SWRAST_NEW_RASTERMASK (_NEW_BUFFERS|	\
+			        _NEW_SCISSOR|	\
+			        _NEW_COLOR|	\
+			        _NEW_DEPTH|	\
+			        _NEW_FOG|	\
+			        _NEW_STENCIL|	\
+			        _NEW_TEXTURE|	\
+			        _NEW_VIEWPORT|	\
+			        _NEW_DEPTH)
+
+
+
+typedef struct
+{
+   /* Driver interface:
+    */
+   struct swrast_device_driver Driver;
+
+   /* Configuration mechanisms to make software rasterizer match
+    * characteristics of the hardware rasterizer (if present):
+    */
+   GLboolean AllowVertexFog;
+   GLboolean AllowPixelFog;
+
+   /* Derived values, invalidated on statechanges, updated from
+    * _swrast_validate_derived():
+    */
+   GLuint _RasterMask;
+   GLfloat _MinMagThresh[MAX_TEXTURE_UNITS];
+   GLfloat _backface_sign;
+   GLboolean _PreferPixelFog;
+
+   /* Accum buffer temporaries.
+    */
+   GLboolean _IntegerAccumMode;	/* Storing unscaled integers? */
+   GLfloat _IntegerAccumScaler;	/* Implicit scale factor */
+
+
+   /* Working values:
+    */
+   struct pixel_buffer* PB;
+   GLuint StippleCounter;    /* Line stipple counter */
+   GLuint NewState;
+   GLuint StateChanges;
+
+   /* Mechanism to allow driver (like X11) to register further
+    * software rasterization routines.
+    */
+   void (*choose_point)( GLcontext * );
+   void (*choose_line)( GLcontext * );
+   void (*choose_triangle)( GLcontext * );
+
+   GLuint invalidate_point;
+   GLuint invalidate_line;
+   GLuint invalidate_triangle;
+
+
+   /* Function pointers for dispatch behind public entrypoints.
+    */
+   void (*InvalidateState)( GLcontext *ctx, GLuint new_state );
+
+   swrast_point_func Point;
+   swrast_line_func Line;
+   swrast_tri_func Triangle;
+
+   /* Placeholders for when separate specular (or secondary color) is
+    * enabled but texturing is not.
+    */
+   swrast_point_func SpecPoint;
+   swrast_line_func SpecLine;
+   swrast_tri_func SpecTriangle;
+
+
+   /* Internal hooks, kept uptodate by the same mechanism as above.
+    */
+   blend_func BlendFunc;
+   TextureSampleFunc TextureSample[MAX_TEXTURE_UNITS];
+
+} SWcontext;
+
+
+extern void
+_swrast_validate_derived( GLcontext *ctx );
+
+
+#define SWRAST_CONTEXT(ctx) ((SWcontext *)ctx->swrast_context)
+
+#define RENDER_START(SWctx, GLctx)			\
+   do {							\
+      if ((SWctx)->Driver.SpanRenderStart) {		\
+         (*(SWctx)->Driver.SpanRenderStart)(GLctx);	\
+      }							\
+   } while (0)
+
+#define RENDER_FINISH(SWctx, GLctx)			\
+   do {							\
+      if ((SWctx)->Driver.SpanRenderFinish) {		\
+         (*(SWctx)->Driver.SpanRenderFinish)(GLctx);	\
+      }							\
+   } while (0)
+
+
+
+/*
+ * XXX these macros are just bandages for now in order to make
+ * CHAN_BITS==32 compile cleanly.
+ * These should probably go elsewhere at some point.
+ */
+#if CHAN_TYPE == GL_FLOAT
+#define ChanToFixed(X)  (X)
+#define FixedToChan(X)  (X)
+#else
+#define ChanToFixed(X)  IntToFixed(X)
+#define FixedToChan(X)  FixedToInt(X)
+#endif
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_copypix.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_copypix.c:1.2
--- /dev/null	Thu Feb 27 12:16:00 2003
+++ xc/extras/Mesa/src/swrast/s_copypix.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,953 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "convolve.h"
+#include "feedback.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "pixel.h"
+
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_fog.h"
+#include "s_histogram.h"
+#include "s_pixeltex.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_texture.h"
+#include "s_zoom.h"
+
+
+
+/*
+ * Determine if there's overlap in an image copy.
+ * This test also compensates for the fact that copies are done from
+ * bottom to top and overlaps can sometimes be handled correctly
+ * without making a temporary image copy.
+ */
+static GLboolean
+regions_overlap(GLint srcx, GLint srcy,
+                GLint dstx, GLint dsty,
+                GLint width, GLint height,
+                GLfloat zoomX, GLfloat zoomY)
+{
+   if (zoomX == 1.0 && zoomY == 1.0) {
+      /* no zoom */
+      if (srcx >= dstx + width || (srcx + width <= dstx)) {
+         return GL_FALSE;
+      }
+      else if (srcy < dsty) { /* this is OK */
+         return GL_FALSE;
+      }
+      else {
+         return GL_TRUE;
+      }
+   }
+   else {
+      /* add one pixel of slop when zooming, just to be safe */
+      if ((srcx > dstx + (width * zoomX) + 1) || (srcx + width + 1 < dstx)) {
+         return GL_FALSE;
+      }
+      else if ((srcy < dsty) && (srcy + height < dsty + (height * zoomY))) {
+         return GL_FALSE;
+      }
+      else if ((srcy > dsty) && (srcy + height > dsty + (height * zoomY))) {
+         return GL_FALSE;
+      }
+      else {
+         return GL_TRUE;
+      }
+   }
+}
+
+
+
+/*
+ * RGBA copypixels with convolution.
+ */
+static void
+copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
+                      GLint width, GLint height, GLint destx, GLint desty)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat fogSpan[MAX_WIDTH];
+   GLboolean quick_draw;
+   GLint row;
+   GLboolean changeBuffer;
+   GLchan *saveReadAlpha;
+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+   const GLuint transferOps = ctx->_ImageTransferState;
+   GLfloat *dest, *tmpImage, *convImage;
+
+   if (ctx->Depth.Test || ctx->Fog.Enabled) {
+      /* fill in array of z values */
+      GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMax);
+      GLfloat fog;
+      GLint i;
+
+      if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterFogCoord);
+      else
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+
+      for (i = 0; i < width; i++) {
+         zspan[i] = z;
+         fogSpan[i] = fog;
+      }
+   }
+
+   if (SWRAST_CONTEXT(ctx)->_RasterMask == 0
+       && !zoom
+       && destx >= 0
+       && destx + width <= (GLint) ctx->DrawBuffer->Width) {
+      quick_draw = GL_TRUE;
+   }
+   else {
+      quick_draw = GL_FALSE;
+   }
+
+   /* If read and draw buffer are different we must do buffer switching */
+   saveReadAlpha = ctx->ReadBuffer->Alpha;
+   changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
+               || ctx->DrawBuffer != ctx->ReadBuffer;
+
+
+   /* allocate space for GLfloat image */
+   tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+   if (!tmpImage) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
+      return;
+   }
+   convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+   if (!convImage) {
+      FREE(tmpImage);
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels");
+      return;
+   }
+
+   dest = tmpImage;
+
+   if (changeBuffer) {
+      (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                    ctx->Pixel.DriverReadBuffer );
+      if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT)
+         ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
+      else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT)
+         ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
+      else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT)
+         ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
+      else
+         ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
+   }
+
+   /* read source image */
+   dest = tmpImage;
+   for (row = 0; row < height; row++) {
+      GLchan rgba[MAX_WIDTH][4];
+      GLint i;
+      _mesa_read_rgba_span(ctx, ctx->ReadBuffer, width, srcx, srcy + row, rgba);
+      /* convert GLchan to GLfloat */
+      for (i = 0; i < width; i++) {
+         *dest++ = (GLfloat) rgba[i][RCOMP] * (1.0F / CHAN_MAXF);
+         *dest++ = (GLfloat) rgba[i][GCOMP] * (1.0F / CHAN_MAXF);
+         *dest++ = (GLfloat) rgba[i][BCOMP] * (1.0F / CHAN_MAXF);
+         *dest++ = (GLfloat) rgba[i][ACOMP] * (1.0F / CHAN_MAXF);
+      }
+   }
+
+   /* read from the draw buffer again (in case of blending) */
+   if (changeBuffer) {
+      (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                    ctx->Color.DriverDrawBuffer );
+      ctx->ReadBuffer->Alpha = saveReadAlpha;
+   }
+
+   /* do image transfer ops up until convolution */
+   for (row = 0; row < height; row++) {
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (tmpImage + row * width * 4);
+
+      /* scale & bias */
+      if (transferOps & IMAGE_SCALE_BIAS_BIT) {
+         _mesa_scale_and_bias_rgba(ctx, width, rgba,
+                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
+                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
+                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
+                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
+      }
+      /* color map lookup */
+      if (transferOps & IMAGE_MAP_COLOR_BIT) {
+         _mesa_map_rgba(ctx, width, rgba);
+      }
+      /* GL_COLOR_TABLE lookup */
+      if (transferOps & IMAGE_COLOR_TABLE_BIT) {
+         _mesa_lookup_rgba(&ctx->ColorTable, width, rgba);
+      }
+   }
+
+   /* do convolution */
+   if (ctx->Pixel.Convolution2DEnabled) {
+      _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
+   }
+   else {
+      ASSERT(ctx->Pixel.Separable2DEnabled);
+      _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
+   }
+   FREE(tmpImage);
+
+   /* do remaining image transfer ops */
+   for (row = 0; row < height; row++) {
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) (convImage + row * width * 4);
+
+      /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
+      if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
+         _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgba);
+      }
+      /* color matrix */
+      if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
+         _mesa_transform_rgba(ctx, width, rgba);
+      }
+      /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
+      if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
+         _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgba);
+      }
+      /* update histogram count */
+      if (transferOps & IMAGE_HISTOGRAM_BIT) {
+         _mesa_update_histogram(ctx, width, (CONST GLfloat (*)[4]) rgba);
+      }
+      /* update min/max */
+      if (transferOps & IMAGE_MIN_MAX_BIT) {
+         _mesa_update_minmax(ctx, width, (CONST GLfloat (*)[4]) rgba);
+      }
+   }
+
+   for (row = 0; row < height; row++) {
+      const GLfloat *src = convImage + row * width * 4;
+      GLchan rgba[MAX_WIDTH][4];
+      GLint i, dy;
+
+      /* clamp to [0,1] and convert float back to chan */
+      for (i = 0; i < width; i++) {
+         GLint r = (GLint) (src[i * 4 + RCOMP] * CHAN_MAXF);
+         GLint g = (GLint) (src[i * 4 + GCOMP] * CHAN_MAXF);
+         GLint b = (GLint) (src[i * 4 + BCOMP] * CHAN_MAXF);
+         GLint a = (GLint) (src[i * 4 + ACOMP] * CHAN_MAXF);
+         rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
+         rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
+         rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
+         rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
+      }
+
+      if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
+         GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH];
+         GLchan primary_rgba[MAX_WIDTH][4];
+         GLuint unit;
+         /* XXX not sure how multitexture is supposed to work here */
+
+         MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
+
+         for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+            _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
+                              s, t, r, q);
+            _swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
+                                      (CONST GLchan (*)[4]) primary_rgba,
+                                      rgba);
+         }
+      }
+
+      /* write row to framebuffer */
+
+      dy = desty + row;
+      if (quick_draw && dy >= 0 && dy < (GLint) ctx->DrawBuffer->Height) {
+         (*swrast->Driver.WriteRGBASpan)( ctx, width, destx, dy,
+				       (const GLchan (*)[4])rgba, NULL );
+      }
+      else if (zoom) {
+         _mesa_write_zoomed_rgba_span( ctx, width, destx, dy, zspan, fogSpan,
+				    (const GLchan (*)[4])rgba, desty);
+      }
+      else {
+         _mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
+                                NULL, GL_BITMAP );
+      }
+   }
+
+   FREE(convImage);
+}
+
+
+/*
+ * RGBA copypixels
+ */
+static void
+copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
+                 GLint width, GLint height, GLint destx, GLint desty)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat fogSpan[MAX_WIDTH];
+   GLchan rgba[MAX_WIDTH][4];
+   GLchan *tmpImage,*p;
+   GLboolean quick_draw;
+   GLint sy, dy, stepy;
+   GLint i, j;
+   GLboolean changeBuffer;
+   GLchan *saveReadAlpha;
+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+   GLint overlapping;
+   const GLuint transferOps = ctx->_ImageTransferState;
+
+   if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
+      copy_conv_rgba_pixels(ctx, srcx, srcy, width, height, destx, desty);
+      return;
+   }
+
+   /* Determine if copy should be done bottom-to-top or top-to-bottom */
+   if (srcy < desty) {
+      /* top-down  max-to-min */
+      sy = srcy + height - 1;
+      dy = desty + height - 1;
+      stepy = -1;
+   }
+   else {
+      /* bottom-up  min-to-max */
+      sy = srcy;
+      dy = desty;
+      stepy = 1;
+   }
+
+   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+   if (ctx->Depth.Test || ctx->Fog.Enabled) {
+      /* fill in array of z values */
+      GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMax);
+      GLfloat fog;
+
+      if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterFogCoord);
+      else
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+
+      for (i=0;i<width;i++) {
+         zspan[i] = z;
+         fogSpan[i] = fog;
+      }
+   }
+
+   if (SWRAST_CONTEXT(ctx)->_RasterMask == 0
+       && !zoom
+       && destx >= 0
+       && destx + width <= (GLint) ctx->DrawBuffer->Width) {
+      quick_draw = GL_TRUE;
+   }
+   else {
+      quick_draw = GL_FALSE;
+   }
+
+   /* If read and draw buffer are different we must do buffer switching */
+   saveReadAlpha = ctx->ReadBuffer->Alpha;
+   changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
+                  || ctx->DrawBuffer != ctx->ReadBuffer;
+
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                 ctx->Pixel.DriverReadBuffer );
+
+   if (overlapping) {
+      GLint ssy = sy;
+      tmpImage = (GLchan *) MALLOC(width * height * sizeof(GLchan) * 4);
+      if (!tmpImage) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+         return;
+      }
+      p = tmpImage;
+      if (changeBuffer) {
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                       ctx->Pixel.DriverReadBuffer );
+         if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT)
+            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
+         else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT)
+            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
+         else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT)
+            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
+         else
+            ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
+      }
+      for (j = 0; j < height; j++, ssy += stepy) {
+         _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, ssy,
+                            (GLchan (*)[4]) p );
+         p += width * 4;
+      }
+      p = tmpImage;
+   }
+   else {
+      tmpImage = NULL;  /* silence compiler warnings */
+      p = NULL;
+   }
+
+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+      /* Get source pixels */
+      if (overlapping) {
+         /* get from buffered image */
+         MEMCPY(rgba, p, width * sizeof(GLchan) * 4);
+         p += width * 4;
+      }
+      else {
+         /* get from framebuffer */
+         if (changeBuffer) {
+            (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                          ctx->Pixel.DriverReadBuffer );
+            if (ctx->Pixel.DriverReadBuffer == GL_FRONT_LEFT) {
+               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontLeftAlpha;
+            }
+            else if (ctx->Pixel.DriverReadBuffer == GL_BACK_LEFT) {
+               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackLeftAlpha;
+            }
+            else if (ctx->Pixel.DriverReadBuffer == GL_FRONT_RIGHT) {
+               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->FrontRightAlpha;
+            }
+            else {
+               ctx->ReadBuffer->Alpha = ctx->ReadBuffer->BackRightAlpha;
+            }
+         }
+         _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, srcx, sy, rgba );
+      }
+
+      if (changeBuffer) {
+         /* read from the draw buffer again (in case of blending) */
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                       ctx->Color.DriverDrawBuffer );
+         ctx->ReadBuffer->Alpha = saveReadAlpha;
+      }
+
+      if (transferOps) {
+         const GLfloat scale = (1.0F / CHAN_MAXF);
+         GLint k;
+         DEFMARRAY(GLfloat, rgbaFloat, MAX_WIDTH, 4);  /* mac 32k limitation */
+         CHECKARRAY(rgbaFloat, return);
+
+         /* convert chan to float */
+         for (k = 0; k < width; k++) {
+            rgbaFloat[k][RCOMP] = (GLfloat) rgba[k][RCOMP] * scale;
+            rgbaFloat[k][GCOMP] = (GLfloat) rgba[k][GCOMP] * scale;
+            rgbaFloat[k][BCOMP] = (GLfloat) rgba[k][BCOMP] * scale;
+            rgbaFloat[k][ACOMP] = (GLfloat) rgba[k][ACOMP] * scale;
+         }
+         /* scale & bias */
+         if (transferOps & IMAGE_SCALE_BIAS_BIT) {
+            _mesa_scale_and_bias_rgba(ctx, width, rgbaFloat,
+                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
+                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
+                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
+                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
+         }
+         /* color map lookup */
+         if (transferOps & IMAGE_MAP_COLOR_BIT) {
+            _mesa_map_rgba(ctx, width, rgbaFloat);
+         }
+         /* GL_COLOR_TABLE lookup */
+         if (transferOps & IMAGE_COLOR_TABLE_BIT) {
+            _mesa_lookup_rgba(&ctx->ColorTable, width, rgbaFloat);
+         }
+         /* convolution */
+         if (transferOps & IMAGE_CONVOLUTION_BIT) {
+            /* XXX to do */
+         }
+         /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
+         if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
+            _mesa_scale_and_bias_rgba(ctx, width, rgbaFloat,
+                                      ctx->Pixel.PostConvolutionScale[RCOMP],
+                                      ctx->Pixel.PostConvolutionScale[GCOMP],
+                                      ctx->Pixel.PostConvolutionScale[BCOMP],
+                                      ctx->Pixel.PostConvolutionScale[ACOMP],
+                                      ctx->Pixel.PostConvolutionBias[RCOMP],
+                                      ctx->Pixel.PostConvolutionBias[GCOMP],
+                                      ctx->Pixel.PostConvolutionBias[BCOMP],
+                                      ctx->Pixel.PostConvolutionBias[ACOMP]);
+         }
+         /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
+         if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
+            _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, width, rgbaFloat);
+         }
+         /* color matrix */
+         if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
+            _mesa_transform_rgba(ctx, width, rgbaFloat);
+         }
+         /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
+         if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
+            _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, width, rgbaFloat);
+         }
+         /* update histogram count */
+         if (transferOps & IMAGE_HISTOGRAM_BIT) {
+            _mesa_update_histogram(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
+         }
+         /* update min/max */
+         if (transferOps & IMAGE_MIN_MAX_BIT) {
+            _mesa_update_minmax(ctx, width, (CONST GLfloat (*)[4]) rgbaFloat);
+         }
+         /* clamp to [0,1] and convert float back to chan */
+         for (k = 0; k < width; k++) {
+            GLint r = (GLint) (rgbaFloat[k][RCOMP] * CHAN_MAXF);
+            GLint g = (GLint) (rgbaFloat[k][GCOMP] * CHAN_MAXF);
+            GLint b = (GLint) (rgbaFloat[k][BCOMP] * CHAN_MAXF);
+            GLint a = (GLint) (rgbaFloat[k][ACOMP] * CHAN_MAXF);
+            rgba[k][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
+            rgba[k][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
+            rgba[k][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
+            rgba[k][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
+         }
+         UNDEFARRAY(rgbaFloat);  /* mac 32k limitation */
+      }
+
+      if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
+         GLuint unit;
+         GLchan primary_rgba[MAX_WIDTH][4];
+         DEFARRAY(GLfloat, s, MAX_WIDTH);  /* mac 32k limitation */
+         DEFARRAY(GLfloat, t, MAX_WIDTH);  /* mac 32k limitation */
+         DEFARRAY(GLfloat, r, MAX_WIDTH);  /* mac 32k limitation */
+         DEFARRAY(GLfloat, q, MAX_WIDTH);  /* mac 32k limitation */
+         CHECKARRAY(s, return); /* mac 32k limitation */
+         CHECKARRAY(t, return);
+         CHECKARRAY(r, return);
+         CHECKARRAY(q, return);
+
+         /* XXX not sure how multitexture is supposed to work here */
+         MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
+
+         for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+            _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
+                              s, t, r, q);
+            _swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
+                                      (CONST GLchan (*)[4]) primary_rgba,
+                                      rgba);
+         }
+
+         UNDEFARRAY(s);  /* mac 32k limitation */
+         UNDEFARRAY(t);
+         UNDEFARRAY(r);
+         UNDEFARRAY(q);
+      }
+
+      if (quick_draw && dy >= 0 && dy < (GLint) ctx->DrawBuffer->Height) {
+         (*swrast->Driver.WriteRGBASpan)( ctx, width, destx, dy,
+				       (const GLchan (*)[4])rgba, NULL );
+      }
+      else if (zoom) {
+         _mesa_write_zoomed_rgba_span( ctx, width, destx, dy, zspan, fogSpan,
+				    (const GLchan (*)[4])rgba, desty);
+      }
+      else {
+         _mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
+                                NULL, GL_BITMAP );
+      }
+   }
+
+   /* Restore pixel source to be the draw buffer (for blending, etc) */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                 ctx->Color.DriverDrawBuffer );
+
+   if (overlapping)
+      FREE(tmpImage);
+}
+
+
+static void copy_ci_pixels( GLcontext *ctx,
+                            GLint srcx, GLint srcy, GLint width, GLint height,
+                            GLint destx, GLint desty )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat fogSpan[MAX_WIDTH];
+   GLuint *tmpImage,*p;
+   GLint sy, dy, stepy;
+   GLint i, j;
+   GLboolean changeBuffer;
+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+   const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
+   GLint overlapping;
+
+   /* Determine if copy should be bottom-to-top or top-to-bottom */
+   if (srcy<desty) {
+      /* top-down  max-to-min */
+      sy = srcy + height - 1;
+      dy = desty + height - 1;
+      stepy = -1;
+   }
+   else {
+      /* bottom-up  min-to-max */
+      sy = srcy;
+      dy = desty;
+      stepy = 1;
+   }
+
+   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+   if (ctx->Depth.Test || ctx->Fog.Enabled) {
+      /* fill in array of z values */
+      GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMax);
+      GLfloat fog;
+
+      if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterFogCoord);
+      else
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+
+      for (i=0;i<width;i++) {
+         zspan[i] = z;
+         fogSpan[i] = fog;
+      }
+   }
+
+   /* If read and draw buffer are different we must do buffer switching */
+   changeBuffer = ctx->Pixel.ReadBuffer != ctx->Color.DrawBuffer
+               || ctx->DrawBuffer != ctx->ReadBuffer;
+
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                 ctx->Pixel.DriverReadBuffer );
+
+   if (overlapping) {
+      GLint ssy = sy;
+      tmpImage = (GLuint *) MALLOC(width * height * sizeof(GLuint));
+      if (!tmpImage) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+         return;
+      }
+      p = tmpImage;
+      if (changeBuffer) {
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                       ctx->Pixel.DriverReadBuffer );
+      }
+      for (j = 0; j < height; j++, ssy += stepy) {
+         _mesa_read_index_span( ctx, ctx->ReadBuffer, width, srcx, ssy, p );
+         p += width;
+      }
+      p = tmpImage;
+   }
+   else {
+      tmpImage = NULL;  /* silence compiler warning */
+      p = NULL;
+   }
+
+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+      GLuint indexes[MAX_WIDTH];
+      if (overlapping) {
+         MEMCPY(indexes, p, width * sizeof(GLuint));
+         p += width;
+      }
+      else {
+         if (changeBuffer) {
+            (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                          ctx->Pixel.DriverReadBuffer );
+         }
+         _mesa_read_index_span( ctx, ctx->ReadBuffer, width, srcx, sy, indexes );
+      }
+
+      if (changeBuffer) {
+         /* set read buffer back to draw buffer (in case of logicops) */
+         (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                       ctx->Color.DriverDrawBuffer );
+      }
+
+      if (shift_or_offset) {
+         _mesa_shift_and_offset_ci( ctx, width, indexes );
+      }
+      if (ctx->Pixel.MapColorFlag) {
+         _mesa_map_ci( ctx, width, indexes );
+      }
+
+      if (zoom) {
+         _mesa_write_zoomed_index_span(ctx, width, destx, dy, zspan, fogSpan,
+                                       indexes, desty );
+      }
+      else {
+         _mesa_write_index_span(ctx, width, destx, dy, zspan, fogSpan, indexes,
+                                NULL, GL_BITMAP);
+      }
+   }
+
+   /* Restore pixel source to be the draw buffer (for blending, etc) */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                 ctx->Color.DriverDrawBuffer );
+
+   if (overlapping)
+      FREE(tmpImage);
+}
+
+
+
+/*
+ * TODO: Optimize!!!!
+ */
+static void copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
+                               GLint width, GLint height,
+                               GLint destx, GLint desty )
+{
+   GLfloat depth[MAX_WIDTH];
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat fogSpan[MAX_WIDTH];
+   GLfloat *p, *tmpImage;
+   GLuint indexes[MAX_WIDTH];
+   GLint sy, dy, stepy;
+   GLint i, j;
+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+   GLint overlapping;
+   DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
+   CHECKARRAY(rgba, return);  /* mac 32k limitation */
+
+   if (!ctx->Visual.depthBits) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
+      UNDEFARRAY(rgba);  /* mac 32k limitation */
+      return;
+   }
+
+   /* Determine if copy should be bottom-to-top or top-to-bottom */
+   if (srcy<desty) {
+      /* top-down  max-to-min */
+      sy = srcy + height - 1;
+      dy = desty + height - 1;
+      stepy = -1;
+   }
+   else {
+      /* bottom-up  min-to-max */
+      sy = srcy;
+      dy = desty;
+      stepy = 1;
+   }
+
+   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+   /* setup colors or indexes */
+   if (ctx->Visual.rgbMode) {
+      GLuint *rgba32 = (GLuint *) rgba;
+      GLuint color = *(GLuint*)( ctx->Current.Color );
+      for (i = 0; i < width; i++) {
+         rgba32[i] = color;
+      }
+   }
+   else {
+      for (i = 0; i < width; i++) {
+         indexes[i] = ctx->Current.Index;
+      }
+   }
+
+   if (ctx->Fog.Enabled) {
+      GLfloat fog;
+
+      if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterFogCoord);
+      else
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+
+      for (i = 0; i < width; i++) {
+         fogSpan[i] = fog;
+      }
+   }
+
+   if (overlapping) {
+      GLint ssy = sy;
+      tmpImage = (GLfloat *) MALLOC(width * height * sizeof(GLfloat));
+      if (!tmpImage) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+         UNDEFARRAY(rgba);  /* mac 32k limitation */
+         return;
+      }
+      p = tmpImage;
+      for (j = 0; j < height; j++, ssy += stepy) {
+         _mesa_read_depth_span_float(ctx, width, srcx, ssy, p);
+         p += width;
+      }
+      p = tmpImage;
+   }
+   else {
+      tmpImage = NULL;  /* silence compiler warning */
+      p = NULL;
+   }
+
+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+      if (overlapping) {
+         MEMCPY(depth, p, width * sizeof(GLfloat));
+         p += width;
+      }
+      else {
+         _mesa_read_depth_span_float(ctx, width, srcx, sy, depth);
+      }
+
+      for (i = 0; i < width; i++) {
+         GLfloat d = depth[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
+         zspan[i] = (GLdepth) (CLAMP(d, 0.0F, 1.0F) * ctx->DepthMax);
+      }
+
+      if (ctx->Visual.rgbMode) {
+         if (zoom) {
+            _mesa_write_zoomed_rgba_span( ctx, width, destx, dy, zspan,
+                                   fogSpan, (const GLchan (*)[4])rgba, desty );
+         }
+         else {
+            _mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan,
+                                   (GLchan (*)[4])rgba, NULL, GL_BITMAP);
+         }
+      }
+      else {
+         if (zoom) {
+            _mesa_write_zoomed_index_span( ctx, width, destx, dy,
+                                           zspan, fogSpan, indexes, desty );
+         }
+         else {
+            _mesa_write_index_span( ctx, width, destx, dy,
+                                    zspan, fogSpan, indexes, NULL, GL_BITMAP );
+         }
+      }
+   }
+
+   UNDEFARRAY(rgba);  /* mac 32k limitation */
+
+   if (overlapping)
+      FREE(tmpImage);
+}
+
+
+
+static void copy_stencil_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
+                                 GLint width, GLint height,
+                                 GLint destx, GLint desty )
+{
+   GLint sy, dy, stepy;
+   GLint j;
+   GLstencil *p, *tmpImage;
+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F;
+   const GLboolean shift_or_offset = ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset;
+   GLint overlapping;
+
+   if (!ctx->Visual.stencilBits) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glCopyPixels" );
+      return;
+   }
+
+   /* Determine if copy should be bottom-to-top or top-to-bottom */
+   if (srcy < desty) {
+      /* top-down  max-to-min */
+      sy = srcy + height - 1;
+      dy = desty + height - 1;
+      stepy = -1;
+   }
+   else {
+      /* bottom-up  min-to-max */
+      sy = srcy;
+      dy = desty;
+      stepy = 1;
+   }
+
+   overlapping = regions_overlap(srcx, srcy, destx, desty, width, height,
+                                 ctx->Pixel.ZoomX, ctx->Pixel.ZoomY);
+
+   if (overlapping) {
+      GLint ssy = sy;
+      tmpImage = (GLstencil *) MALLOC(width * height * sizeof(GLstencil));
+      if (!tmpImage) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
+         return;
+      }
+      p = tmpImage;
+      for (j = 0; j < height; j++, ssy += stepy) {
+         _mesa_read_stencil_span( ctx, width, srcx, ssy, p );
+         p += width;
+      }
+      p = tmpImage;
+   }
+   else {
+      tmpImage = NULL;  /* silence compiler warning */
+      p = NULL;
+   }
+
+   for (j = 0; j < height; j++, sy += stepy, dy += stepy) {
+      GLstencil stencil[MAX_WIDTH];
+
+      if (overlapping) {
+         MEMCPY(stencil, p, width * sizeof(GLstencil));
+         p += width;
+      }
+      else {
+         _mesa_read_stencil_span( ctx, width, srcx, sy, stencil );
+      }
+
+      if (shift_or_offset) {
+         _mesa_shift_and_offset_stencil( ctx, width, stencil );
+      }
+      if (ctx->Pixel.MapStencilFlag) {
+         _mesa_map_stencil( ctx, width, stencil );
+      }
+
+      if (zoom) {
+         _mesa_write_zoomed_stencil_span( ctx, width, destx, dy, stencil, desty );
+      }
+      else {
+         _mesa_write_stencil_span( ctx, width, destx, dy, stencil );
+      }
+   }
+
+   if (overlapping)
+      FREE(tmpImage);
+}
+
+
+
+
+void
+_swrast_CopyPixels( GLcontext *ctx,
+		    GLint srcx, GLint srcy, GLsizei width, GLsizei height,
+		    GLint destx, GLint desty,
+		    GLenum type )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   RENDER_START(swrast,ctx);
+      
+   if (swrast->NewState)
+      _swrast_validate_derived( ctx );
+
+   if (type == GL_COLOR && ctx->Visual.rgbMode) {
+      copy_rgba_pixels( ctx, srcx, srcy, width, height, destx, desty );
+   }
+   else if (type == GL_COLOR && !ctx->Visual.rgbMode) {
+      copy_ci_pixels( ctx, srcx, srcy, width, height, destx, desty );
+   }
+   else if (type == GL_DEPTH) {
+      copy_depth_pixels( ctx, srcx, srcy, width, height, destx, desty );
+   }
+   else if (type == GL_STENCIL) {
+      copy_stencil_pixels( ctx, srcx, srcy, width, height, destx, desty );
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glCopyPixels" );
+   }
+
+   RENDER_FINISH(swrast,ctx);
+}
Index: xc/extras/Mesa/src/swrast/s_depth.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_depth.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_depth.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,1639 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_depth.h"
+#include "s_context.h"
+#include "s_pb.h"
+
+
+
+
+/*
+ * Return address of depth buffer value for given window coord.
+ */
+GLvoid *
+_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y)
+{
+   if (ctx->Visual.depthBits <= 16)
+      return (GLushort *) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width * y + x;
+   else
+      return (GLuint *) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width * y + x;
+}
+
+
+#define Z_ADDRESS16( CTX, X, Y )				\
+            ( ((GLushort *) (CTX)->DrawBuffer->DepthBuffer)	\
+              + (CTX)->DrawBuffer->Width * (Y) + (X) )
+
+#define Z_ADDRESS32( CTX, X, Y )				\
+            ( ((GLuint *) (CTX)->DrawBuffer->DepthBuffer)	\
+              + (CTX)->DrawBuffer->Width * (Y) + (X) )
+
+
+
+/**********************************************************************/
+/*****                   Depth Testing Functions                  *****/
+/**********************************************************************/
+
+
+/*
+ * Do depth test for an array of fragments.  This is used both for
+ * software and hardware Z buffers.
+ * Input:  zbuffer - array of z values in the zbuffer
+ *         z - array of fragment z values
+ * Return:  number of fragments which pass the test.
+ */
+static GLuint
+depth_test_span16( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                   GLushort zbuffer[], const GLdepth z[], GLubyte mask[] )
+{
+   GLuint passed = 0;
+
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] < zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] < zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] <= zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] <= zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] >= zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] >= zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] > zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] > zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] != zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] != zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] == zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] == zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  zbuffer[i] = z[i];
+		  passed++;
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	    passed = n;
+	 }
+	 break;
+      case GL_NEVER:
+         BZERO(mask, n * sizeof(GLubyte));
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad depth func in depth_test_span16");
+   }
+
+   return passed;
+}
+
+
+static GLuint
+depth_test_span32( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                   GLuint zbuffer[], const GLdepth z[], GLubyte mask[] )
+{
+   GLuint passed = 0;
+
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] < zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] < zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] <= zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] <= zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] >= zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] >= zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] > zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] > zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] != zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] != zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] == zbuffer[i]) {
+		     zbuffer[i] = z[i];
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  if (z[i] == zbuffer[i]) {
+		     /* pass */
+		     passed++;
+		  }
+		  else {
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  zbuffer[i] = z[i];
+		  passed++;
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	    passed = n;
+	 }
+	 break;
+      case GL_NEVER:
+         BZERO(mask, n * sizeof(GLubyte));
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad depth func in depth_test_span32");
+   }
+
+   return passed;
+}
+
+
+
+/*
+ * Apply depth test to span of fragments.  Hardware or software z buffer.
+ */
+GLuint
+_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                       const GLdepth z[], GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   if (swrast->Driver.ReadDepthSpan) {
+      /* hardware-based depth buffer */
+      GLdepth zbuffer[MAX_WIDTH];
+      GLuint passed;
+      (*swrast->Driver.ReadDepthSpan)(ctx, n, x, y, zbuffer);
+      passed = depth_test_span32(ctx, n, x, y, zbuffer, z, mask);
+      assert(swrast->Driver.WriteDepthSpan);
+      (*swrast->Driver.WriteDepthSpan)(ctx, n, x, y, zbuffer, mask);
+      return passed;
+   }
+   else {
+      /* software depth buffer */
+      if (ctx->Visual.depthBits <= 16) {
+         GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, x, y);
+         GLuint passed = depth_test_span16(ctx, n, x, y, zptr, z, mask);
+         return passed;
+      }
+      else {
+         GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, x, y);
+         GLuint passed = depth_test_span32(ctx, n, x, y, zptr, z, mask);
+         return passed;
+      }
+   }
+}
+
+
+
+
+/*
+ * Do depth testing for an array of fragments using software Z buffer.
+ */
+static void
+software_depth_test_pixels16( GLcontext *ctx, GLuint n,
+                              const GLint x[], const GLint y[],
+                              const GLdepth z[], GLubyte mask[] )
+{
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
+		  *zptr = z[i];
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	 }
+	 break;
+      case GL_NEVER:
+	 /* depth test never passes */
+         BZERO(mask, n * sizeof(GLubyte));
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad depth func in software_depth_test_pixels");
+   }
+}
+
+
+
+/*
+ * Do depth testing for an array of fragments using software Z buffer.
+ */
+static void
+software_depth_test_pixels32( GLcontext *ctx, GLuint n,
+                              const GLint x[], const GLint y[],
+                              const GLdepth z[], GLubyte mask[] )
+{
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] < *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] <= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] >= *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] > *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] != *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		     *zptr = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  if (z[i] == *zptr) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
+		  *zptr = z[i];
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	 }
+	 break;
+      case GL_NEVER:
+	 /* depth test never passes */
+         BZERO(mask, n * sizeof(GLubyte));
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad depth func in software_depth_test_pixels");
+   }
+}
+
+
+
+/*
+ * Do depth testing for an array of pixels using hardware Z buffer.
+ * Input/output:  zbuffer - array of depth values from Z buffer
+ * Input:  z - array of fragment z values.
+ */
+static void
+hardware_depth_test_pixels( GLcontext *ctx, GLuint n, GLdepth zbuffer[],
+                            const GLdepth z[], GLubyte mask[] )
+{
+   /* switch cases ordered from most frequent to less frequent */
+   switch (ctx->Depth.Func) {
+      case GL_LESS:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] < zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] < zbuffer[i]) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] <= zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] <= zbuffer[i]) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] >= zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] >= zbuffer[i]) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] > zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] > zbuffer[i]) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] != zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] != zbuffer[i]) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+         if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] == zbuffer[i]) {
+		     /* pass */
+		     zbuffer[i] = z[i];
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  if (z[i] == zbuffer[i]) {
+		     /* pass */
+		  }
+		  else {
+		     /* fail */
+		     mask[i] = 0;
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 if (ctx->Depth.Mask) {
+	    /* Update Z buffer */
+            GLuint i;
+	    for (i=0; i<n; i++) {
+	       if (mask[i]) {
+		  zbuffer[i] = z[i];
+	       }
+	    }
+	 }
+	 else {
+	    /* Don't update Z buffer or mask */
+	 }
+	 break;
+      case GL_NEVER:
+	 /* depth test never passes */
+         BZERO(mask, n * sizeof(GLubyte));
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad depth func in hardware_depth_test_pixels");
+   }
+}
+
+
+
+void
+_mesa_depth_test_pixels( GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         const GLdepth z[], GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   if (swrast->Driver.ReadDepthPixels) {
+      /* read depth values from hardware Z buffer */
+      GLdepth zbuffer[PB_SIZE];
+      (*swrast->Driver.ReadDepthPixels)(ctx, n, x, y, zbuffer);
+
+      hardware_depth_test_pixels( ctx, n, zbuffer, z, mask );
+
+      /* update hardware Z buffer with new values */
+      assert(swrast->Driver.WriteDepthPixels);
+      (*swrast->Driver.WriteDepthPixels)(ctx, n, x, y, zbuffer, mask );
+   }
+   else {
+      /* software depth testing */
+      if (ctx->Visual.depthBits <= 16)
+         software_depth_test_pixels16(ctx, n, x, y, z, mask);
+      else
+         software_depth_test_pixels32(ctx, n, x, y, z, mask);
+   }
+}
+
+
+
+
+
+/**********************************************************************/
+/*****                      Read Depth Buffer                     *****/
+/**********************************************************************/
+
+
+/*
+ * Read a span of depth values from the depth buffer.
+ * This function does clipping before calling the device driver function.
+ */
+void
+_mesa_read_depth_span( GLcontext *ctx,
+                       GLint n, GLint x, GLint y, GLdepth depth[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (y < 0 || y >= (GLint) ctx->DrawBuffer->Height ||
+       x + n <= 0 || x >= (GLint) ctx->DrawBuffer->Width) {
+      /* span is completely outside framebuffer */
+      GLint i;
+      for (i = 0; i < n; i++)
+         depth[i] = 0;
+      return;
+   }
+
+   if (x < 0) {
+      GLint dx = -x;
+      GLint i;
+      for (i = 0; i < dx; i++)
+         depth[i] = 0;
+      x = 0;
+      n -= dx;
+      depth += dx;
+   }
+   if (x + n > (GLint) ctx->DrawBuffer->Width) {
+      GLint dx = x + n - (GLint) ctx->DrawBuffer->Width;
+      GLint i;
+      for (i = 0; i < dx; i++)
+         depth[n - i - 1] = 0;
+      n -= dx;
+   }
+   if (n <= 0) {
+      return;
+   }
+
+   if (ctx->DrawBuffer->DepthBuffer) {
+      /* read from software depth buffer */
+      if (ctx->Visual.depthBits <= 16) {
+         const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
+         GLint i;
+         for (i = 0; i < n; i++) {
+            depth[i] = zptr[i];
+         }
+      }
+      else {
+         const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
+         GLint i;
+         for (i = 0; i < n; i++) {
+            depth[i] = zptr[i];
+         }
+      }
+   }
+   else if (swrast->Driver.ReadDepthSpan) {
+      /* read from hardware depth buffer */
+      (*swrast->Driver.ReadDepthSpan)( ctx, n, x, y, depth );
+   }
+   else {
+      /* no depth buffer */
+      BZERO(depth, n * sizeof(GLfloat));
+   }
+
+}
+
+
+
+
+/*
+ * Return a span of depth values from the depth buffer as floats in [0,1].
+ * This is used for both hardware and software depth buffers.
+ * Input:  n - how many pixels
+ *         x,y - location of first pixel
+ * Output:  depth - the array of depth values
+ */
+void
+_mesa_read_depth_span_float( GLcontext *ctx,
+                             GLint n, GLint x, GLint y, GLfloat depth[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLfloat scale = 1.0F / ctx->DepthMaxF;
+
+   if (y < 0 || y >= (GLint) ctx->DrawBuffer->Height ||
+       x + n <= 0 || x >= (GLint) ctx->DrawBuffer->Width) {
+      /* span is completely outside framebuffer */
+      GLint i;
+      for (i = 0; i < n; i++)
+         depth[i] = 0.0F;
+      return;
+   }
+
+   if (x < 0) {
+      GLint dx = -x;
+      GLint i;
+      for (i = 0; i < dx; i++)
+         depth[i] = 0.0F;
+      n -= dx;
+      x = 0;
+   }
+   if (x + n > (GLint) ctx->DrawBuffer->Width) {
+      GLint dx = x + n - (GLint) ctx->DrawBuffer->Width;
+      GLint i;
+      for (i = 0; i < dx; i++)
+         depth[n - i - 1] = 0.0F;
+      n -= dx;
+   }
+   if (n <= 0) {
+      return;
+   }
+
+   if (ctx->DrawBuffer->DepthBuffer) {
+      /* read from software depth buffer */
+      if (ctx->Visual.depthBits <= 16) {
+         const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
+         GLint i;
+         for (i = 0; i < n; i++) {
+            depth[i] = (GLfloat) zptr[i] * scale;
+         }
+      }
+      else {
+         const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
+         GLint i;
+         for (i = 0; i < n; i++) {
+            depth[i] = (GLfloat) zptr[i] * scale;
+         }
+      }
+   }
+   else if (swrast->Driver.ReadDepthSpan) {
+      /* read from hardware depth buffer */
+      GLdepth d[MAX_WIDTH];
+      GLint i;
+      assert(n <= MAX_WIDTH);
+      (*swrast->Driver.ReadDepthSpan)( ctx, n, x, y, d );
+      for (i = 0; i < n; i++) {
+	 depth[i] = d[i] * scale;
+      }
+   }
+   else {
+      /* no depth buffer */
+      BZERO(depth, n * sizeof(GLfloat));
+   }
+}
+
+
+
+/**********************************************************************/
+/*****                Allocate and Clear Depth Buffer             *****/
+/**********************************************************************/
+
+
+
+/*
+ * Allocate a new depth buffer.  If there's already a depth buffer allocated
+ * it will be free()'d.  The new depth buffer will be uniniitalized.
+ */
+void
+_mesa_alloc_depth_buffer( GLframebuffer *buffer )
+{
+   GLint bytesPerValue;
+
+   ASSERT(buffer->UseSoftwareDepthBuffer);
+
+   /* deallocate current depth buffer if present */
+   if (buffer->DepthBuffer) {
+      MESA_PBUFFER_FREE(buffer->DepthBuffer);
+      buffer->DepthBuffer = NULL;
+   }
+
+   /* allocate new depth buffer, but don't initialize it */
+   if (buffer->Visual.depthBits <= 16)
+      bytesPerValue = sizeof(GLushort);
+   else
+      bytesPerValue = sizeof(GLuint);
+
+   buffer->DepthBuffer = MESA_PBUFFER_ALLOC(buffer->Width * buffer->Height * bytesPerValue);
+
+   if (!buffer->DepthBuffer) {
+      /* out of memory */
+      GET_CURRENT_CONTEXT(ctx);
+      if (ctx) {
+         ctx->Depth.Test = GL_FALSE;
+         ctx->NewState |= _NEW_DEPTH;
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "Couldn't allocate depth buffer");
+      }
+   }
+}
+
+
+
+
+/*
+ * Clear the depth buffer.  If the depth buffer doesn't exist yet we'll
+ * allocate it now.
+ * This function is only called through Driver.clear_depth_buffer.
+ */
+void
+_mesa_clear_depth_buffer( GLcontext *ctx )
+{
+   if (ctx->Visual.depthBits == 0
+       || !ctx->DrawBuffer->DepthBuffer
+       || !ctx->Depth.Mask) {
+      /* no depth buffer, or writing to it is disabled */
+      return;
+   }
+
+   /* The loops in this function have been written so the IRIX 5.3
+    * C compiler can unroll them.  Hopefully other compilers can too!
+    */
+
+   if (ctx->Scissor.Enabled) {
+      /* only clear scissor region */
+      if (ctx->Visual.depthBits <= 16) {
+         const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->DepthMax);
+         const GLint rows = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+         const GLint cols = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+         const GLint rowStride = ctx->DrawBuffer->Width;
+         GLushort *dRow = (GLushort *) ctx->DrawBuffer->DepthBuffer
+            + ctx->DrawBuffer->_Ymin * rowStride + ctx->DrawBuffer->_Xmin;
+         GLint i, j;
+         for (i = 0; i < rows; i++) {
+            for (j = 0; j < cols; j++) {
+               dRow[j] = clearValue;
+            }
+            dRow += rowStride;
+         }
+      }
+      else {
+         const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->DepthMax);
+         const GLint rows = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+         const GLint cols = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+         const GLint rowStride = ctx->DrawBuffer->Width;
+         GLuint *dRow = (GLuint *) ctx->DrawBuffer->DepthBuffer
+            + ctx->DrawBuffer->_Ymin * rowStride + ctx->DrawBuffer->_Xmin;
+         GLint i, j;
+         for (i = 0; i < rows; i++) {
+            for (j = 0; j < cols; j++) {
+               dRow[j] = clearValue;
+            }
+            dRow += rowStride;
+         }
+      }
+   }
+   else {
+      /* clear whole buffer */
+      if (ctx->Visual.depthBits <= 16) {
+         const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->DepthMax);
+         if ((clearValue & 0xff) == (clearValue >> 8)) {
+            if (clearValue == 0) {
+               BZERO(ctx->DrawBuffer->DepthBuffer,
+                     2*ctx->DrawBuffer->Width*ctx->DrawBuffer->Height);
+            }
+            else {
+               /* lower and upper bytes of clear_value are same, use MEMSET */
+               MEMSET( ctx->DrawBuffer->DepthBuffer, clearValue & 0xff,
+                       2 * ctx->DrawBuffer->Width * ctx->DrawBuffer->Height);
+            }
+         }
+         else {
+            GLushort *d = (GLushort *) ctx->DrawBuffer->DepthBuffer;
+            GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+            while (n >= 16) {
+               d[0] = clearValue;    d[1] = clearValue;
+               d[2] = clearValue;    d[3] = clearValue;
+               d[4] = clearValue;    d[5] = clearValue;
+               d[6] = clearValue;    d[7] = clearValue;
+               d[8] = clearValue;    d[9] = clearValue;
+               d[10] = clearValue;   d[11] = clearValue;
+               d[12] = clearValue;   d[13] = clearValue;
+               d[14] = clearValue;   d[15] = clearValue;
+               d += 16;
+               n -= 16;
+            }
+            while (n > 0) {
+               *d++ = clearValue;
+               n--;
+            }
+         }
+      }
+      else {
+         /* >16 bit depth buffer */
+         const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->DepthMax);
+         if (clearValue == 0) {
+            BZERO(ctx->DrawBuffer->DepthBuffer,
+                ctx->DrawBuffer->Width*ctx->DrawBuffer->Height*sizeof(GLuint));
+         }
+         else {
+            GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+            GLuint *d = (GLuint *) ctx->DrawBuffer->DepthBuffer;
+            while (n >= 16) {
+               d[0] = clearValue;    d[1] = clearValue;
+               d[2] = clearValue;    d[3] = clearValue;
+               d[4] = clearValue;    d[5] = clearValue;
+               d[6] = clearValue;    d[7] = clearValue;
+               d[8] = clearValue;    d[9] = clearValue;
+               d[10] = clearValue;   d[11] = clearValue;
+               d[12] = clearValue;   d[13] = clearValue;
+               d[14] = clearValue;   d[15] = clearValue;
+               d += 16;
+               n -= 16;
+            }
+            while (n > 0) {
+               *d++ = clearValue;
+               n--;
+            }
+         }
+      }
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_depth.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_depth.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_depth.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,67 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_DEPTH_H
+#define S_DEPTH_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern GLvoid *
+_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y);
+
+
+extern GLuint
+_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                       const GLdepth z[], GLubyte mask[] );
+
+extern void
+_mesa_depth_test_pixels( GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         const GLdepth z[], GLubyte mask[] );
+
+
+extern void
+_mesa_read_depth_span( GLcontext *ctx,
+                       GLint n, GLint x, GLint y, GLdepth depth[] );
+
+
+extern void
+_mesa_read_depth_span_float( GLcontext *ctx, GLint n, GLint x, GLint y,
+                             GLfloat depth[] );
+
+
+extern void
+_mesa_alloc_depth_buffer( GLframebuffer *buffer );
+
+
+extern void
+_mesa_clear_depth_buffer( GLcontext *ctx );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_drawpix.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_drawpix.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_drawpix.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,946 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "convolve.h"
+#include "image.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "pixel.h"
+
+#include "s_context.h"
+#include "s_drawpix.h"
+#include "s_fog.h"
+#include "s_pixeltex.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_texture.h"
+#include "s_zoom.h"
+
+
+
+/*
+ * Given the dest position, size and skipPixels and skipRows values
+ * for a glDrawPixels command, perform clipping of the image bounds
+ * so the result lies withing the context's buffer bounds.
+ * Return:  GL_TRUE if image is ready for drawing
+ *          GL_FALSE if image was completely clipped away (draw nothing)
+ */
+GLboolean
+_mesa_clip_pixelrect(const GLcontext *ctx,
+                     GLint *destX, GLint *destY,
+                     GLsizei *width, GLsizei *height,
+                     GLint *skipPixels, GLint *skipRows)
+{
+   const GLframebuffer *buffer = ctx->DrawBuffer;
+
+   /* left clipping */
+   if (*destX < buffer->_Xmin) {
+      *skipPixels += (buffer->_Xmin - *destX);
+      *width -= (buffer->_Xmin - *destX);
+      *destX = buffer->_Xmin;
+   }
+   /* right clipping */
+   if (*destX + *width > buffer->_Xmax)
+      *width -= (*destX + *width - buffer->_Xmax);
+
+   if (*width <= 0)
+      return GL_FALSE;
+
+   /* bottom clipping */
+   if (*destY < buffer->_Ymin) {
+      *skipRows += (buffer->_Ymin - *destY);
+      *height -= (buffer->_Ymin - *destY);
+      *destY = buffer->_Ymin;
+   }
+   /* top clipping */
+   if (*destY + *height > buffer->_Ymax)
+      *height -= (*destY + *height - buffer->_Ymax);
+
+   if (*height <= 0)
+      return GL_TRUE;
+
+   return GL_TRUE;
+}
+
+
+
+/*
+ * Try to do a fast and simple RGB(a) glDrawPixels.
+ * Return:  GL_TRUE if success, GL_FALSE if slow path must be used instead
+ */
+static GLboolean
+fast_draw_pixels(GLcontext *ctx, GLint x, GLint y,
+                 GLsizei width, GLsizei height,
+                 GLenum format, GLenum type, const GLvoid *pixels)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const struct gl_pixelstore_attrib *unpack = &ctx->Unpack;
+   GLchan rgb[MAX_WIDTH][3];
+   GLchan rgba[MAX_WIDTH][4];
+
+   if (!ctx->Current.RasterPosValid) {
+      return GL_TRUE;      /* no-op */
+   }
+
+   if ((SWRAST_CONTEXT(ctx)->_RasterMask&(~(SCISSOR_BIT|WINCLIP_BIT)))==0
+       && ctx->Texture._ReallyEnabled == 0
+       && unpack->Alignment == 1
+       && !unpack->SwapBytes
+       && !unpack->LsbFirst) {
+
+      GLint destX = x;
+      GLint destY = y;
+      GLint drawWidth = width;           /* actual width drawn */
+      GLint drawHeight = height;         /* actual height drawn */
+      GLint skipPixels = unpack->SkipPixels;
+      GLint skipRows = unpack->SkipRows;
+      GLint rowLength;
+      GLdepth zSpan[MAX_WIDTH];  /* only used when zooming */
+      GLint zoomY0 = 0;
+
+      if (unpack->RowLength > 0)
+         rowLength = unpack->RowLength;
+      else
+         rowLength = width;
+
+      /* If we're not using pixel zoom then do all clipping calculations
+       * now.  Otherwise, we'll let the _mesa_write_zoomed_*_span() functions
+       * handle the clipping.
+       */
+      if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+         /* horizontal clipping */
+         if (destX < ctx->DrawBuffer->_Xmin) {
+            skipPixels += (ctx->DrawBuffer->_Xmin - destX);
+            drawWidth  -= (ctx->DrawBuffer->_Xmin - destX);
+            destX = ctx->DrawBuffer->_Xmin;
+         }
+         if (destX + drawWidth > ctx->DrawBuffer->_Xmax)
+            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->_Xmax);
+         if (drawWidth <= 0)
+            return GL_TRUE;
+
+         /* vertical clipping */
+         if (destY < ctx->DrawBuffer->_Ymin) {
+            skipRows   += (ctx->DrawBuffer->_Ymin - destY);
+            drawHeight -= (ctx->DrawBuffer->_Ymin - destY);
+            destY = ctx->DrawBuffer->_Ymin;
+         }
+         if (destY + drawHeight > ctx->DrawBuffer->_Ymax)
+            drawHeight -= (destY + drawHeight - ctx->DrawBuffer->_Ymax);
+         if (drawHeight <= 0)
+            return GL_TRUE;
+      }
+      else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+         /* upside-down image */
+         /* horizontal clipping */
+         if (destX < ctx->DrawBuffer->_Xmin) {
+            skipPixels += (ctx->DrawBuffer->_Xmin - destX);
+            drawWidth  -= (ctx->DrawBuffer->_Xmin - destX);
+            destX = ctx->DrawBuffer->_Xmin;
+         }
+         if (destX + drawWidth > ctx->DrawBuffer->_Xmax)
+            drawWidth -= (destX + drawWidth - ctx->DrawBuffer->_Xmax);
+         if (drawWidth <= 0)
+            return GL_TRUE;
+
+         /* vertical clipping */
+         if (destY > ctx->DrawBuffer->_Ymax) {
+            skipRows   += (destY - ctx->DrawBuffer->_Ymax);
+            drawHeight -= (destY - ctx->DrawBuffer->_Ymax);
+            destY = ctx->DrawBuffer->_Ymax;
+         }
+         if (destY - drawHeight < ctx->DrawBuffer->_Ymin)
+            drawHeight -= (ctx->DrawBuffer->_Ymin - (destY - drawHeight));
+         if (drawHeight <= 0)
+            return GL_TRUE;
+      }
+      else {
+         /* setup array of fragment Z value to pass to zoom function */
+         GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMaxF);
+         GLint i;
+         ASSERT(drawWidth < MAX_WIDTH);
+         for (i=0; i<drawWidth; i++)
+            zSpan[i] = z;
+
+         /* save Y value of first row */
+         zoomY0 = IROUND(ctx->Current.RasterPos[1]);
+      }
+
+
+      /*
+       * Ready to draw!
+       * The window region at (destX, destY) of size (drawWidth, drawHeight)
+       * will be written to.
+       * We'll take pixel data from buffer pointed to by "pixels" but we'll
+       * skip "skipRows" rows and skip "skipPixels" pixels/row.
+       */
+
+      if (format == GL_RGBA && type == CHAN_TYPE
+          && ctx->_ImageTransferState==0) {
+         if (ctx->Visual.rgbMode) {
+            GLchan *src = (GLchan *) pixels
+               + (skipRows * rowLength + skipPixels) * 4;
+            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+               /* no zooming */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+                                              (CONST GLchan (*)[4]) src, NULL);
+                  src += rowLength * 4;
+                  destY++;
+               }
+            }
+            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+               /* upside-down */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  destY--;
+                  (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+                                              (CONST GLchan (*)[4]) src, NULL);
+                  src += rowLength * 4;
+               }
+            }
+            else {
+               /* with zooming */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  _mesa_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
+                                  zSpan, 0, (CONST GLchan (*)[4]) src, zoomY0);
+                  src += rowLength * 4;
+                  destY++;
+               }
+            }
+         }
+         return GL_TRUE;
+      }
+      else if (format == GL_RGB && type == CHAN_TYPE
+               && ctx->_ImageTransferState == 0) {
+         if (ctx->Visual.rgbMode) {
+            GLchan *src = (GLchan *) pixels
+               + (skipRows * rowLength + skipPixels) * 3;
+            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+                                              (CONST GLchan (*)[3]) src, NULL);
+                  src += rowLength * 3;
+                  destY++;
+               }
+            }
+            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+               /* upside-down */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  destY--;
+                  (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+                                              (CONST GLchan (*)[3]) src, NULL);
+                  src += rowLength * 3;
+               }
+            }
+            else {
+               /* with zooming */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  _mesa_write_zoomed_rgb_span(ctx, drawWidth, destX, destY,
+                                  zSpan, 0, (CONST GLchan (*)[3]) src, zoomY0);
+                  src += rowLength * 3;
+                  destY++;
+               }
+            }
+         }
+         return GL_TRUE;
+      }
+      else if (format == GL_LUMINANCE && type == CHAN_TYPE
+               && ctx->_ImageTransferState==0) {
+         if (ctx->Visual.rgbMode) {
+            GLchan *src = (GLchan *) pixels
+               + (skipRows * rowLength + skipPixels);
+            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+               /* no zooming */
+               GLint row;
+               ASSERT(drawWidth < MAX_WIDTH);
+               for (row=0; row<drawHeight; row++) {
+                  GLint i;
+		  for (i=0;i<drawWidth;i++) {
+                     rgb[i][0] = src[i];
+                     rgb[i][1] = src[i];
+                     rgb[i][2] = src[i];
+		  }
+                  (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+                                              (CONST GLchan (*)[3]) rgb, NULL);
+                  src += rowLength;
+                  destY++;
+               }
+            }
+            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+               /* upside-down */
+               GLint row;
+               ASSERT(drawWidth < MAX_WIDTH);
+               for (row=0; row<drawHeight; row++) {
+                  GLint i;
+                  for (i=0;i<drawWidth;i++) {
+                     rgb[i][0] = src[i];
+                     rgb[i][1] = src[i];
+                     rgb[i][2] = src[i];
+                  }
+                  destY--;
+                  (*swrast->Driver.WriteRGBSpan)(ctx, drawWidth, destX, destY,
+                                              (CONST GLchan (*)[3]) rgb, NULL);
+                  src += rowLength;
+               }
+            }
+            else {
+               /* with zooming */
+               GLint row;
+               ASSERT(drawWidth < MAX_WIDTH);
+               for (row=0; row<drawHeight; row++) {
+                  GLint i;
+		  for (i=0;i<drawWidth;i++) {
+                     rgb[i][0] = src[i];
+                     rgb[i][1] = src[i];
+                     rgb[i][2] = src[i];
+		  }
+                  _mesa_write_zoomed_rgb_span(ctx, drawWidth, destX, destY,
+                                  zSpan, 0, (CONST GLchan (*)[3]) rgb, zoomY0);
+                  src += rowLength;
+                  destY++;
+               }
+            }
+         }
+         return GL_TRUE;
+      }
+      else if (format == GL_LUMINANCE_ALPHA && type == CHAN_TYPE
+               && ctx->_ImageTransferState == 0) {
+         if (ctx->Visual.rgbMode) {
+            GLchan *src = (GLchan *) pixels
+               + (skipRows * rowLength + skipPixels)*2;
+            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+               /* no zooming */
+               GLint row;
+               ASSERT(drawWidth < MAX_WIDTH);
+               for (row=0; row<drawHeight; row++) {
+                  GLint i;
+                  GLchan *ptr = src;
+		  for (i=0;i<drawWidth;i++) {
+                     rgba[i][0] = *ptr;
+                     rgba[i][1] = *ptr;
+                     rgba[i][2] = *ptr++;
+                     rgba[i][3] = *ptr++;
+		  }
+                  (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+                                             (CONST GLchan (*)[4]) rgba, NULL);
+                  src += rowLength*2;
+                  destY++;
+               }
+            }
+            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+               /* upside-down */
+               GLint row;
+               ASSERT(drawWidth < MAX_WIDTH);
+               for (row=0; row<drawHeight; row++) {
+                  GLint i;
+                  GLchan *ptr = src;
+                  for (i=0;i<drawWidth;i++) {
+                     rgba[i][0] = *ptr;
+                     rgba[i][1] = *ptr;
+                     rgba[i][2] = *ptr++;
+                     rgba[i][3] = *ptr++;
+                  }
+                  destY--;
+                  (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+                                             (CONST GLchan (*)[4]) rgba, NULL);
+                  src += rowLength*2;
+               }
+            }
+            else {
+               /* with zooming */
+               GLint row;
+               ASSERT(drawWidth < MAX_WIDTH);
+               for (row=0; row<drawHeight; row++) {
+                  GLchan *ptr = src;
+                  GLint i;
+		  for (i=0;i<drawWidth;i++) {
+                     rgba[i][0] = *ptr;
+                     rgba[i][1] = *ptr;
+                     rgba[i][2] = *ptr++;
+                     rgba[i][3] = *ptr++;
+		  }
+                  _mesa_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
+                                 zSpan, 0, (CONST GLchan (*)[4]) rgba, zoomY0);
+                  src += rowLength*2;
+                  destY++;
+               }
+            }
+         }
+         return GL_TRUE;
+      }
+      else if (format==GL_COLOR_INDEX && type==GL_UNSIGNED_BYTE) {
+         GLubyte *src = (GLubyte *) pixels + skipRows * rowLength + skipPixels;
+         if (ctx->Visual.rgbMode) {
+            /* convert CI data to RGBA */
+            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+               /* no zooming */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  ASSERT(drawWidth < MAX_WIDTH);
+                  _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
+                  (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+                                               (const GLchan (*)[4]) rgba,
+					       NULL);
+                  src += rowLength;
+                  destY++;
+               }
+               return GL_TRUE;
+            }
+            else if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==-1.0F) {
+               /* upside-down */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  ASSERT(drawWidth < MAX_WIDTH);
+                  _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
+                  destY--;
+                  (*swrast->Driver.WriteRGBASpan)(ctx, drawWidth, destX, destY,
+                                               (CONST GLchan (*)[4]) rgba,
+                                               NULL);
+                  src += rowLength;
+               }
+               return GL_TRUE;
+            }
+            else {
+               /* with zooming */
+               GLint row;
+               for (row=0; row<drawHeight; row++) {
+                  ASSERT(drawWidth < MAX_WIDTH);
+                  _mesa_map_ci8_to_rgba(ctx, drawWidth, src, rgba);
+                  _mesa_write_zoomed_rgba_span(ctx, drawWidth, destX, destY,
+                                 zSpan, 0, (CONST GLchan (*)[4]) rgba, zoomY0);
+                  src += rowLength;
+                  destY++;
+               }
+               return GL_TRUE;
+            }
+         }
+         else if (ctx->_ImageTransferState==0) {
+            /* write CI data to CI frame buffer */
+            GLint row;
+            if (ctx->Pixel.ZoomX==1.0F && ctx->Pixel.ZoomY==1.0F) {
+               /* no zooming */
+               for (row=0; row<drawHeight; row++) {
+                  (*swrast->Driver.WriteCI8Span)(ctx, drawWidth, destX, destY,
+                                              src, NULL);
+                  src += rowLength;
+                  destY++;
+               }
+               return GL_TRUE;
+            }
+            else {
+               /* with zooming */
+               return GL_FALSE;
+            }
+         }
+      }
+      else {
+         /* can't handle this pixel format and/or data type here */
+         return GL_FALSE;
+      }
+   }
+
+   /* can't do a simple draw, have to use slow path */
+   return GL_FALSE;
+}
+
+
+
+/*
+ * Do glDrawPixels of index pixels.
+ */
+static void
+draw_index_pixels( GLcontext *ctx, GLint x, GLint y,
+                   GLsizei width, GLsizei height,
+                   GLenum type, const GLvoid *pixels )
+{
+   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+   const GLint desty = y;
+   GLint row, drawWidth;
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat fogSpan[MAX_WIDTH];
+
+   drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+   /* Fragment depth values */
+   if (ctx->Depth.Test || ctx->Fog.Enabled) {
+      GLdepth zval = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMaxF);
+      GLfloat fog;
+      GLint i;
+
+      if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterFogCoord);
+      else
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+
+      for (i = 0; i < drawWidth; i++) {
+	 zspan[i] = zval;
+         fogSpan[i] = fog;
+      }
+   }
+
+   /*
+    * General solution
+    */
+   for (row = 0; row < height; row++, y++) {
+      GLuint indexes[MAX_WIDTH];
+      const GLvoid *source = _mesa_image_address(&ctx->Unpack,
+                    pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0);
+      _mesa_unpack_index_span(ctx, drawWidth, GL_UNSIGNED_INT, indexes,
+                              type, source, &ctx->Unpack,
+                              ctx->_ImageTransferState);
+      if (zoom) {
+         _mesa_write_zoomed_index_span(ctx, drawWidth, x, y, zspan, fogSpan,
+                                       indexes, desty);
+      }
+      else {
+         _mesa_write_index_span(ctx, drawWidth, x, y, zspan, fogSpan, indexes,
+                                NULL, GL_BITMAP);
+      }
+   }
+}
+
+
+
+/*
+ * Do glDrawPixels of stencil image.  The image datatype may either
+ * be GLubyte or GLbitmap.
+ */
+static void
+draw_stencil_pixels( GLcontext *ctx, GLint x, GLint y,
+                     GLsizei width, GLsizei height,
+                     GLenum type, const GLvoid *pixels )
+{
+   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+   const GLint desty = y;
+   GLint row, drawWidth;
+
+   if (type != GL_BYTE &&
+       type != GL_UNSIGNED_BYTE &&
+       type != GL_SHORT &&
+       type != GL_UNSIGNED_SHORT &&
+       type != GL_INT &&
+       type != GL_UNSIGNED_INT &&
+       type != GL_FLOAT &&
+       type != GL_BITMAP) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawPixels(stencil type)");
+      return;
+   }
+
+   if (ctx->Visual.stencilBits == 0) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glDrawPixels(no stencil buffer)");
+      return;
+   }
+
+   drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+   for (row = 0; row < height; row++, y++) {
+      GLstencil values[MAX_WIDTH];
+      GLenum destType = (sizeof(GLstencil) == sizeof(GLubyte))
+                      ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;
+      const GLvoid *source = _mesa_image_address(&ctx->Unpack,
+                    pixels, width, height, GL_COLOR_INDEX, type, 0, row, 0);
+      _mesa_unpack_index_span(ctx, drawWidth, destType, values,
+                              type, source, &ctx->Unpack,
+                              ctx->_ImageTransferState);
+      if (ctx->_ImageTransferState & IMAGE_SHIFT_OFFSET_BIT) {
+         _mesa_shift_and_offset_stencil( ctx, drawWidth, values );
+      }
+      if (ctx->Pixel.MapStencilFlag) {
+         _mesa_map_stencil( ctx, drawWidth, values );
+      }
+
+      if (zoom) {
+         _mesa_write_zoomed_stencil_span( ctx, (GLuint) drawWidth, x, y,
+                                       values, desty );
+      }
+      else {
+         _mesa_write_stencil_span( ctx, (GLuint) drawWidth, x, y, values );
+      }
+   }
+}
+
+
+
+/*
+ * Do a glDrawPixels of depth values.
+ */
+static void
+draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
+                   GLsizei width, GLsizei height,
+                   GLenum type, const GLvoid *pixels )
+{
+   const GLboolean bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0;
+   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+   const GLint desty = y;
+   GLchan rgba[MAX_WIDTH][4];
+   GLuint ispan[MAX_WIDTH];
+   GLint drawWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+   if (type != GL_BYTE
+       && type != GL_UNSIGNED_BYTE
+       && type != GL_SHORT
+       && type != GL_UNSIGNED_SHORT
+       && type != GL_INT
+       && type != GL_UNSIGNED_INT
+       && type != GL_FLOAT) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawPixels(type)");
+      return;
+   }
+
+   /* Colors or indexes */
+   if (ctx->Visual.rgbMode) {
+      GLint i;
+      GLint r, g, b, a;
+      UNCLAMPED_FLOAT_TO_CHAN(r, ctx->Current.RasterColor[0]);
+      UNCLAMPED_FLOAT_TO_CHAN(g, ctx->Current.RasterColor[1]);
+      UNCLAMPED_FLOAT_TO_CHAN(b, ctx->Current.RasterColor[2]);
+      UNCLAMPED_FLOAT_TO_CHAN(a, ctx->Current.RasterColor[3]);
+      for (i = 0; i < drawWidth; i++) {
+         rgba[i][RCOMP] = r;
+         rgba[i][GCOMP] = g;
+         rgba[i][BCOMP] = b;
+         rgba[i][ACOMP] = a;
+      }
+   }
+   else {
+      GLint i;
+      for (i = 0; i < drawWidth; i++) {
+	 ispan[i] = ctx->Current.RasterIndex;
+      }
+   }
+
+   if (type==GL_UNSIGNED_SHORT && ctx->Visual.depthBits == 16
+       && !bias_or_scale && !zoom && ctx->Visual.rgbMode) {
+      /* Special case: directly write 16-bit depth values */
+      GLint row;
+      for (row = 0; row < height; row++, y++) {
+         GLdepth zspan[MAX_WIDTH];
+         const GLushort *zptr = (const GLushort *)
+            _mesa_image_address(&ctx->Unpack, pixels, width, height,
+                                GL_DEPTH_COMPONENT, type, 0, row, 0);
+         GLint i;
+         for (i = 0; i < width; i++)
+            zspan[i] = zptr[i];
+         _mesa_write_rgba_span(ctx, width, x, y, zspan, 0, rgba,
+                               NULL, GL_BITMAP);
+      }
+   }
+   else if (type==GL_UNSIGNED_INT && ctx->Visual.depthBits == 32
+       && !bias_or_scale && !zoom && ctx->Visual.rgbMode) {
+      /* Special case: directly write 32-bit depth values */
+      GLint row;
+      for (row = 0; row < height; row++, y++) {
+         const GLuint *zptr = (const GLuint *)
+            _mesa_image_address(&ctx->Unpack, pixels, width, height,
+                                GL_DEPTH_COMPONENT, type, 0, row, 0);
+         _mesa_write_rgba_span(ctx, width, x, y, zptr, 0, rgba,
+                               NULL, GL_BITMAP);
+      }
+   }
+   else {
+      /* General case */
+      GLint row;
+      for (row = 0; row < height; row++, y++) {
+         GLfloat fspan[MAX_WIDTH];
+         GLdepth zspan[MAX_WIDTH];
+         const GLvoid *src = _mesa_image_address(&ctx->Unpack,
+                pixels, width, height, GL_DEPTH_COMPONENT, type, 0, row, 0);
+         _mesa_unpack_depth_span( ctx, drawWidth, fspan, type, src,
+                                  &ctx->Unpack );
+         /* clamp depth values to [0,1] and convert from floats to integers */
+         {
+            const GLfloat zs = ctx->DepthMaxF;
+            GLint i;
+            for (i = 0; i < drawWidth; i++) {
+               zspan[i] = (GLdepth) (fspan[i] * zs + 0.5F);
+            }
+         }
+
+         if (ctx->Visual.rgbMode) {
+            if (zoom) {
+               _mesa_write_zoomed_rgba_span(ctx, width, x, y, zspan, 0,
+                                            (const GLchan (*)[4]) rgba, desty);
+            }
+            else {
+               _mesa_write_rgba_span(ctx, width, x, y, zspan, 0,
+                                     rgba, NULL, GL_BITMAP);
+            }
+         }
+         else {
+            if (zoom) {
+               _mesa_write_zoomed_index_span(ctx, width, x, y, zspan, 0,
+                                             ispan, GL_BITMAP);
+            }
+            else {
+               _mesa_write_index_span(ctx, width, x, y, zspan, 0,
+                                      ispan, NULL, GL_BITMAP);
+            }
+         }
+
+      }
+   }
+}
+
+
+/*
+ * Do glDrawPixels of RGBA pixels.
+ */
+static void
+draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
+                  GLsizei width, GLsizei height,
+                  GLenum format, GLenum type, const GLvoid *pixels )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const struct gl_pixelstore_attrib *unpack = &ctx->Unpack;
+   const GLboolean zoom = ctx->Pixel.ZoomX!=1.0 || ctx->Pixel.ZoomY!=1.0;
+   const GLint desty = y;
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat fogSpan[MAX_WIDTH];
+   GLboolean quickDraw;
+   GLfloat *convImage = NULL;
+   GLuint transferOps = ctx->_ImageTransferState;
+
+   if (!_mesa_is_legal_format_and_type(format, type)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawPixels(format or type)");
+      return;
+   }
+
+   /* Try an optimized glDrawPixels first */
+   if (fast_draw_pixels(ctx, x, y, width, height, format, type, pixels))
+      return;
+
+   /* Fragment depth values */
+   if (ctx->Depth.Test || ctx->Fog.Enabled) {
+      /* fill in array of z values */
+      GLdepth z = (GLdepth) (ctx->Current.RasterPos[2] * ctx->DepthMaxF);
+      GLfloat fog;
+      GLint i;
+
+      if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterFogCoord);
+      else
+         fog = _mesa_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
+
+      for (i=0;i<width;i++) {
+	 zspan[i] = z;
+         fogSpan[i] = fog;
+      }
+   }
+
+
+   if (SWRAST_CONTEXT(ctx)->_RasterMask == 0 && !zoom && x >= 0 && y >= 0
+       && x + width <= (GLint) ctx->DrawBuffer->Width
+       && y + height <= (GLint) ctx->DrawBuffer->Height) {
+      quickDraw = GL_TRUE;
+   }
+   else {
+      quickDraw = GL_FALSE;
+   }
+
+   if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
+      /* Convolution has to be handled specially.  We'll create an
+       * intermediate image, applying all pixel transfer operations
+       * up to convolution.  Then we'll convolve the image.  Then
+       * we'll proceed with the rest of the transfer operations and
+       * rasterize the image.
+       */
+      GLint row;
+      GLfloat *dest, *tmpImage;
+
+      tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+      if (!tmpImage) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
+         return;
+      }
+      convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+      if (!convImage) {
+         FREE(tmpImage);
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
+         return;
+      }
+
+      /* Unpack the image and apply transfer ops up to convolution */
+      dest = tmpImage;
+      for (row = 0; row < height; row++) {
+         const GLvoid *source = _mesa_image_address(unpack,
+                  pixels, width, height, format, type, 0, row, 0);
+         _mesa_unpack_float_color_span(ctx, width, GL_RGBA, (GLfloat *) dest,
+                                      format, type, source, unpack,
+                                      transferOps & IMAGE_PRE_CONVOLUTION_BITS,
+                                      GL_FALSE);
+         dest += width * 4;
+      }
+
+      /* do convolution */
+      if (ctx->Pixel.Convolution2DEnabled) {
+         _mesa_convolve_2d_image(ctx, &width, &height, tmpImage, convImage);
+      }
+      else {
+         ASSERT(ctx->Pixel.Separable2DEnabled);
+         _mesa_convolve_sep_image(ctx, &width, &height, tmpImage, convImage);
+      }
+      FREE(tmpImage);
+
+      /* continue transfer ops and draw the convolved image */
+      unpack = &_mesa_native_packing;
+      pixels = convImage;
+      format = GL_RGBA;
+      type = GL_FLOAT;
+      transferOps &= IMAGE_POST_CONVOLUTION_BITS;
+   }
+
+   /*
+    * General solution
+    */
+   {
+      GLchan rgba[MAX_WIDTH][4];
+      GLint row;
+      if (width > MAX_WIDTH)
+         width = MAX_WIDTH;
+      for (row = 0; row < height; row++, y++) {
+         const GLvoid *source = _mesa_image_address(unpack,
+                  pixels, width, height, format, type, 0, row, 0);
+         _mesa_unpack_chan_color_span(ctx, width, GL_RGBA, (GLchan *) rgba,
+                                      format, type, source, unpack,
+                                      transferOps);
+         if ((ctx->Pixel.MinMaxEnabled && ctx->MinMax.Sink) ||
+             (ctx->Pixel.HistogramEnabled && ctx->Histogram.Sink))
+            continue;
+
+         if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
+            GLchan primary_rgba[MAX_WIDTH][4];
+            GLuint unit;
+            DEFARRAY(GLfloat, s, MAX_WIDTH);  /* mac 32k limitation */
+            DEFARRAY(GLfloat, t, MAX_WIDTH);
+            DEFARRAY(GLfloat, r, MAX_WIDTH);
+            DEFARRAY(GLfloat, q, MAX_WIDTH);
+            CHECKARRAY(s, return);  /* mac 32k limitation */
+            CHECKARRAY(t, return);
+            CHECKARRAY(r, return);
+            CHECKARRAY(q, return);
+
+            /* XXX not sure how multitexture is supposed to work here */
+            MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
+
+            for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+               if (ctx->Texture.Unit[unit]._ReallyEnabled) {
+                  _mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
+                                    s, t, r, q);
+                  _swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
+                                            (CONST GLchan (*)[4]) primary_rgba,
+                                            rgba);
+               }
+            }
+            UNDEFARRAY(s);  /* mac 32k limitation */
+            UNDEFARRAY(t);
+            UNDEFARRAY(r);
+            UNDEFARRAY(q);
+         }
+
+         if (quickDraw) {
+            (*swrast->Driver.WriteRGBASpan)(ctx, width, x, y,
+                                            (CONST GLchan (*)[4]) rgba, NULL);
+         }
+         else if (zoom) {
+            _mesa_write_zoomed_rgba_span(ctx, width, x, y, zspan, fogSpan,
+                                         (CONST GLchan (*)[4]) rgba, desty);
+         }
+         else {
+            _mesa_write_rgba_span(ctx, (GLuint) width, x, y, zspan, fogSpan,
+                                  rgba, NULL, GL_BITMAP);
+         }
+      }
+   }
+
+   if (convImage) {
+      FREE(convImage);
+   }
+}
+
+
+
+/*
+ * Execute glDrawPixels
+ */
+void
+_swrast_DrawPixels( GLcontext *ctx,
+		    GLint x, GLint y,
+		    GLsizei width, GLsizei height,
+		    GLenum format, GLenum type,
+		    const struct gl_pixelstore_attrib *unpack,
+		    const GLvoid *pixels )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   (void) unpack;
+
+
+   if (swrast->NewState)
+      _swrast_validate_derived( ctx );
+
+   RENDER_START(swrast,ctx);
+
+   switch (format) {
+   case GL_STENCIL_INDEX:
+      draw_stencil_pixels( ctx, x, y, width, height, type, pixels );
+      break;
+   case GL_DEPTH_COMPONENT:
+      draw_depth_pixels( ctx, x, y, width, height, type, pixels );
+      break;
+   case GL_COLOR_INDEX:
+      if (ctx->Visual.rgbMode)
+	 draw_rgba_pixels(ctx, x,y, width, height, format, type, pixels);
+      else
+	 draw_index_pixels(ctx, x, y, width, height, type, pixels);
+      break;
+   case GL_RED:
+   case GL_GREEN:
+   case GL_BLUE:
+   case GL_ALPHA:
+   case GL_LUMINANCE:
+   case GL_LUMINANCE_ALPHA:
+   case GL_RGB:
+   case GL_BGR:
+   case GL_RGBA:
+   case GL_BGRA:
+   case GL_ABGR_EXT:
+      draw_rgba_pixels(ctx, x, y, width, height, format, type, pixels);
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawPixels(format)" );
+   }
+
+   RENDER_FINISH(swrast,ctx);
+}
Index: xc/extras/Mesa/src/swrast/s_drawpix.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_drawpix.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_drawpix.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,41 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_DRAWPIXELS_H
+#define S_DRAWPIXELS_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern GLboolean
+_mesa_clip_pixelrect(const GLcontext *ctx,
+                     GLint *destX, GLint *destY,
+                     GLsizei *width, GLsizei *height,
+                     GLint *skipPixels, GLint *skipRows);
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_feedback.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_feedback.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_feedback.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,166 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "enums.h"
+#include "feedback.h"
+#include "macros.h"
+#include "mmath.h"
+
+#include "s_context.h"
+#include "s_feedback.h"
+#include "s_triangle.h"
+
+
+#define FB_3D		0x01
+#define FB_4D		0x02
+#define FB_INDEX	0x04
+#define FB_COLOR	0x08
+#define FB_TEXTURE	0X10
+
+
+
+
+static void feedback_vertex( GLcontext *ctx,
+                             const SWvertex *v, const SWvertex *pv )
+{
+   const GLuint texUnit = 0;  /* See section 5.3 of 1.2.1 spec */
+   GLfloat win[4];
+   GLfloat color[4];
+   GLfloat tc[4];
+   GLuint index;
+
+   win[0] = v->win[0];
+   win[1] = v->win[1];
+   win[2] = v->win[2] / ctx->DepthMaxF;
+   win[3] = 1.0F / v->win[3];
+
+   color[0] = CHAN_TO_FLOAT(pv->color[0]);
+   color[1] = CHAN_TO_FLOAT(pv->color[1]);
+   color[2] = CHAN_TO_FLOAT(pv->color[2]);
+   color[3] = CHAN_TO_FLOAT(pv->color[3]);
+
+   if (v->texcoord[texUnit][3] != 1.0 &&
+       v->texcoord[texUnit][3] != 0.0) {
+      GLfloat invq = 1.0F / v->texcoord[texUnit][3];
+      tc[0] = v->texcoord[texUnit][0] * invq;
+      tc[1] = v->texcoord[texUnit][1] * invq;
+      tc[2] = v->texcoord[texUnit][2] * invq;
+      tc[3] = v->texcoord[texUnit][3];
+   }
+   else {
+      COPY_4V(tc, v->texcoord[texUnit]);
+   }
+
+   index = v->index;
+
+   _mesa_feedback_vertex( ctx, win, color, index, tc );
+}
+
+
+/*
+ * Put triangle in feedback buffer.
+ */
+void _mesa_feedback_triangle( GLcontext *ctx,
+                           const SWvertex *v0,
+                           const SWvertex *v1,
+			   const SWvertex *v2)
+{
+   if (_mesa_cull_triangle( ctx, v0, v1, v2 )) {
+      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN );
+      FEEDBACK_TOKEN( ctx, (GLfloat) 3 );        /* three vertices */
+
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+	 feedback_vertex( ctx, v0, v0 );
+	 feedback_vertex( ctx, v1, v1 );
+	 feedback_vertex( ctx, v2, v2 );
+      } else {
+	 feedback_vertex( ctx, v0, v2 );
+	 feedback_vertex( ctx, v1, v2 );
+	 feedback_vertex( ctx, v2, v2 );
+      }
+   }
+}
+
+
+void _mesa_feedback_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
+{
+   GLenum token = GL_LINE_TOKEN;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (swrast->StippleCounter==0)
+      token = GL_LINE_RESET_TOKEN;
+
+   FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) token );
+
+   if (ctx->Light.ShadeModel == GL_SMOOTH) {
+      feedback_vertex( ctx, v0, v0 );
+      feedback_vertex( ctx, v1, v1 );
+   } else {
+      feedback_vertex( ctx, v0, v1 );
+      feedback_vertex( ctx, v1, v1 );
+   }
+
+   swrast->StippleCounter++;
+}
+
+
+void _mesa_feedback_point( GLcontext *ctx, const SWvertex *v )
+{
+   FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POINT_TOKEN );
+   feedback_vertex( ctx, v, v );
+}
+
+
+void _mesa_select_triangle( GLcontext *ctx,
+                         const SWvertex *v0,
+                         const SWvertex *v1,
+			 const SWvertex *v2)
+{
+   if (_mesa_cull_triangle( ctx, v0, v1, v2 )) {
+      const GLfloat zs = 1.0F / ctx->DepthMaxF;
+
+      _mesa_update_hitflag( ctx, v0->win[2] * zs );
+      _mesa_update_hitflag( ctx, v1->win[2] * zs );
+      _mesa_update_hitflag( ctx, v2->win[2] * zs );
+   }
+}
+
+
+void _mesa_select_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
+{
+   const GLfloat zs = 1.0F / ctx->DepthMaxF;
+   _mesa_update_hitflag( ctx, v0->win[2] * zs );
+   _mesa_update_hitflag( ctx, v1->win[2] * zs );
+}
+
+
+void _mesa_select_point( GLcontext *ctx, const SWvertex *v )
+{
+   const GLfloat zs = 1.0F / ctx->DepthMaxF;
+   _mesa_update_hitflag( ctx, v->win[2] * zs );
+}
Index: xc/extras/Mesa/src/swrast/s_feedback.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_feedback.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_feedback.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,51 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_FEEDBACK_H
+#define S_FEEDBACK_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void _mesa_feedback_point( GLcontext *ctx, const SWvertex *v );
+
+extern void _mesa_feedback_line( GLcontext *ctx,
+                              const SWvertex *v1, const SWvertex *v2 );
+
+extern void _mesa_feedback_triangle( GLcontext *ctx, const SWvertex *v0,
+                                  const SWvertex *v1, const SWvertex *v2 );
+
+extern void _mesa_select_point( GLcontext *ctx, const SWvertex *v );
+
+extern void _mesa_select_line( GLcontext *ctx,
+                            const SWvertex *v1, const SWvertex *v2 );
+
+extern void _mesa_select_triangle( GLcontext *ctx, const SWvertex *v0,
+                                const SWvertex *v1, const SWvertex *v2 );
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_fog.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_fog.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_fog.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,302 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mmath.h"
+
+#include "s_context.h"
+#include "s_fog.h"
+#include "s_pb.h"
+
+
+
+
+/*
+ * Used to convert current raster distance to a fog factor in [0,1].
+ */
+GLfloat
+_mesa_z_to_fogfactor(GLcontext *ctx, GLfloat z)
+{
+   GLfloat d, f;
+
+   switch (ctx->Fog.Mode) {
+   case GL_LINEAR:
+      if (ctx->Fog.Start == ctx->Fog.End)
+         d = 1.0F;
+      else
+         d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
+      f = (ctx->Fog.End - z) * d;
+      return CLAMP(f, 0.0F, 1.0F);
+   case GL_EXP:
+      d = ctx->Fog.Density;
+      f = (GLfloat) exp(-d * z);
+      return f;
+   case GL_EXP2:
+      d = ctx->Fog.Density;
+      f = (GLfloat) exp(-(d * d * z * z));
+      return f;
+   default:
+      _mesa_problem(ctx, "Bad fog mode in make_fog_coord");
+      return 0.0; 
+   }
+}
+
+
+
+/*
+ * Apply fog to an array of RGBA pixels.
+ * Input:  n - number of pixels
+ *         fog - array of fog factors in [0,1]
+ *         red, green, blue, alpha - pixel colors
+ * Output:  red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_fog_rgba_pixels( const GLcontext *ctx,
+                       GLuint n,
+		       const GLfloat fog[],
+		       GLchan rgba[][4] )
+{
+   GLuint i;
+   GLchan rFog, gFog, bFog;
+
+   UNCLAMPED_FLOAT_TO_CHAN(rFog, ctx->Fog.Color[RCOMP]);
+   UNCLAMPED_FLOAT_TO_CHAN(gFog, ctx->Fog.Color[GCOMP]);
+   UNCLAMPED_FLOAT_TO_CHAN(bFog, ctx->Fog.Color[BCOMP]);
+
+   for (i = 0; i < n; i++) {
+      const GLfloat f = fog[i];
+      const GLfloat g = 1.0F - f;
+      rgba[i][RCOMP] = (GLchan) (f * rgba[i][RCOMP] + g * rFog);
+      rgba[i][GCOMP] = (GLchan) (f * rgba[i][GCOMP] + g * gFog);
+      rgba[i][BCOMP] = (GLchan) (f * rgba[i][BCOMP] + g * bFog);
+   }
+}
+
+
+
+/*
+ * Apply fog to an array of color index pixels.
+ * Input:  n - number of pixels
+ *         fog - array of fog factors in [0,1]
+ *         index - pixel color indexes
+ * Output:  index - fogged pixel color indexes
+ */
+void
+_mesa_fog_ci_pixels( const GLcontext *ctx,
+                     GLuint n, const GLfloat fog[], GLuint index[] )
+{
+   GLuint idx = (GLuint) ctx->Fog.Index;
+   GLuint i;
+
+   for (i = 0; i < n; i++) {
+      const GLfloat f = CLAMP(fog[i], 0.0F, 1.0F);
+      index[i] = (GLuint) ((GLfloat) index[i] + (1.0F - f) * idx);
+   }
+}
+
+
+
+/*
+ * Calculate fog factors (in [0,1]) from window z values
+ * Input:  n - number of pixels
+ *         z - array of integer depth values
+ *         red, green, blue, alpha - pixel colors
+ * Output:  red, green, blue, alpha - fogged pixel colors
+ *
+ * Use lookup table & interpolation?
+ */
+static void
+compute_fog_factors_from_z( const GLcontext *ctx,
+                            GLuint n,
+                            const GLdepth z[],
+                            GLfloat fogFact[] )
+{
+   const GLboolean ortho = (ctx->ProjectionMatrix.m[15] != 0.0F);
+   const GLfloat p10 = ctx->ProjectionMatrix.m[10];
+   const GLfloat p14 = ctx->ProjectionMatrix.m[14];
+   const GLfloat tz = ctx->Viewport._WindowMap.m[MAT_TZ];
+   GLfloat szInv;
+   GLuint i;
+
+   if (ctx->Viewport._WindowMap.m[MAT_SZ] == 0.0)
+      szInv = 1.0F;
+   else
+      szInv = 1.0F / ctx->Viewport._WindowMap.m[MAT_SZ];
+
+   /*
+    * Note: to compute eyeZ from the ndcZ we have to solve the following:
+    *
+    *        p[10] * eyeZ + p[14] * eyeW
+    * ndcZ = ---------------------------
+    *        p[11] * eyeZ + p[15] * eyeW
+    *
+    * Thus:
+    *
+    *        p[14] * eyeW - p[15] * eyeW * ndcZ
+    * eyeZ = ----------------------------------
+    *             p[11] * ndcZ - p[10]
+    *
+    * If we note:
+    *    a) if using an orthographic projection, p[11] = 0 and p[15] = 1.
+    *    b) if using a perspective projection, p[11] = -1 and p[15] = 0.
+    *    c) we assume eyeW = 1 (not always true- glVertex4)
+    *
+    * Then we can simplify the calculation of eyeZ quite a bit.  We do
+    * separate calculations for the orthographic and perspective cases below.
+    * Note that we drop a negative sign or two since they don't matter.
+    */
+
+   switch (ctx->Fog.Mode) {
+      case GL_LINEAR:
+         {
+            GLfloat fogEnd = ctx->Fog.End;
+            GLfloat fogScale;
+            if (ctx->Fog.Start == ctx->Fog.End)
+               fogScale = 1.0;
+            else
+               fogScale = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
+            if (ortho) {
+               for (i=0;i<n;i++) {
+                  GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+                  GLfloat eyez = (ndcz - p14) / p10;
+                  GLfloat f;
+                  if (eyez < 0.0)
+                     eyez = -eyez;
+                  f = (fogEnd - eyez) * fogScale;
+                  fogFact[i] = CLAMP(f, 0.0F, 1.0F);
+               }
+            }
+            else {
+               /* perspective */
+               for (i=0;i<n;i++) {
+                  GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+                  GLfloat eyez = p14 / (ndcz + p10);
+                  GLfloat f;
+                  if (eyez < 0.0)
+                     eyez = -eyez;
+                  f = (fogEnd - eyez) * fogScale;
+                  fogFact[i] = CLAMP(f, 0.0F, 1.0F);
+               }
+            }
+         }
+	 break;
+      case GL_EXP:
+         if (ortho) {
+            for (i=0;i<n;i++) {
+               GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+               GLfloat eyez = (ndcz - p14) / p10;
+               if (eyez < 0.0)
+                  eyez = -eyez;
+               fogFact[i] = (GLfloat) exp( -ctx->Fog.Density * eyez );
+            }
+         }
+         else {
+            /* perspective */
+            for (i=0;i<n;i++) {
+               GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+               GLfloat eyez = p14 / (ndcz + p10);
+               if (eyez < 0.0)
+                  eyez = -eyez;
+               fogFact[i] = (GLfloat) exp( -ctx->Fog.Density * eyez );
+            }
+         }
+	 break;
+      case GL_EXP2:
+         {
+            GLfloat negDensitySquared = -ctx->Fog.Density * ctx->Fog.Density;
+            if (ortho) {
+               for (i=0;i<n;i++) {
+                  GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+                  GLfloat eyez = (ndcz - p14) / p10;
+                  GLfloat tmp = negDensitySquared * eyez * eyez;
+#if defined(__alpha__) || defined(__alpha)
+                  /* XXX this underflow check may be needed for other systems*/
+                  if (tmp < FLT_MIN_10_EXP)
+                     tmp = FLT_MIN_10_EXP;
+#endif
+                  fogFact[i] = (GLfloat) exp( tmp );
+               }
+            }
+            else {
+               /* perspective */
+               for (i=0;i<n;i++) {
+                  GLfloat ndcz = ((GLfloat) z[i] - tz) * szInv;
+                  GLfloat eyez = p14 / (ndcz + p10);
+                  GLfloat tmp = negDensitySquared * eyez * eyez;
+#if defined(__alpha__) || defined(__alpha)
+                  /* XXX this underflow check may be needed for other systems*/
+                  if (tmp < FLT_MIN_10_EXP)
+                     tmp = FLT_MIN_10_EXP;
+#endif
+                  fogFact[i] = (GLfloat) exp( tmp );
+               }
+            }
+         }
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad fog mode in compute_fog_factors_from_z");
+         return;
+   }
+}
+
+
+/*
+ * Apply fog to an array of RGBA pixels.
+ * Input:  n - number of pixels
+ *         z - array of integer depth values
+ *         red, green, blue, alpha - pixel colors
+ * Output:  red, green, blue, alpha - fogged pixel colors
+ */
+void
+_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
+			     GLuint n, const GLdepth z[], GLchan rgba[][4] )
+{
+   GLfloat fogFact[PB_SIZE];
+   ASSERT(n <= PB_SIZE);
+   compute_fog_factors_from_z( ctx, n, z, fogFact );
+   _mesa_fog_rgba_pixels( ctx, n, fogFact, rgba );
+}
+
+
+/*
+ * Apply fog to an array of color index pixels.
+ * Input:  n - number of pixels
+ *         z - array of integer depth values
+ *         index - pixel color indexes
+ * Output:  index - fogged pixel color indexes
+ */
+void
+_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
+                     GLuint n, const GLdepth z[], GLuint index[] )
+{
+   GLfloat fogFact[PB_SIZE];
+   ASSERT(n <= PB_SIZE);
+   compute_fog_factors_from_z( ctx, n, z, fogFact );
+   _mesa_fog_ci_pixels( ctx, n, fogFact, index );
+}
Index: xc/extras/Mesa/src/swrast/s_fog.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_fog.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_fog.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,63 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_FOG_H
+#define S_FOG_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern GLfloat
+_mesa_z_to_fogfactor(GLcontext *ctx, GLfloat z);
+
+
+extern void
+_mesa_fog_rgba_pixels( const GLcontext *ctx,
+                       GLuint n, const GLfloat fog[],
+                       GLchan rgba[][4] );
+
+extern void
+_mesa_fog_ci_pixels( const GLcontext *ctx,
+                     GLuint n, const GLfloat fog[], GLuint indx[] );
+
+extern void
+_mesa_win_fog_coords_from_z( const GLcontext *ctx,
+			     GLuint n,
+			     const GLdepth z[],
+			     GLfloat fogcoord[] );
+
+extern void
+_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
+			     GLuint n, const GLdepth z[], GLchan rgba[][4] );
+
+extern void
+_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
+			   GLuint n, const GLdepth z[], GLuint index[] );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_histogram.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_histogram.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_histogram.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,96 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "image.h"
+#include "mmath.h"
+
+#include "s_context.h"
+#include "s_histogram.h"
+#include "s_span.h"
+
+
+
+/*
+ * Update the min/max values from an array of fragment colors.
+ */
+void
+_mesa_update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
+{
+   GLuint i;
+   for (i = 0; i < n; i++) {
+      /* update mins */
+      if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP])
+         ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP];
+      if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP])
+         ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP];
+      if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP])
+         ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP];
+      if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP])
+         ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP];
+
+      /* update maxs */
+      if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP])
+         ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP];
+      if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP])
+         ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP];
+      if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP])
+         ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP];
+      if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP])
+         ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP];
+   }
+}
+
+
+/*
+ * Update the histogram values from an array of fragment colors.
+ */
+void
+_mesa_update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4])
+{
+   const GLint max = ctx->Histogram.Width - 1;
+   GLfloat w = (GLfloat) max;
+   GLuint i;
+
+   if (ctx->Histogram.Width == 0)
+      return;
+
+   for (i = 0; i < n; i++) {
+      GLint ri = IROUND(rgba[i][RCOMP] * w);
+      GLint gi = IROUND(rgba[i][GCOMP] * w);
+      GLint bi = IROUND(rgba[i][BCOMP] * w);
+      GLint ai = IROUND(rgba[i][ACOMP] * w);
+      ri = CLAMP(ri, 0, max);
+      gi = CLAMP(gi, 0, max);
+      bi = CLAMP(bi, 0, max);
+      ai = CLAMP(ai, 0, max);
+      ctx->Histogram.Count[ri][RCOMP]++;
+      ctx->Histogram.Count[gi][GCOMP]++;
+      ctx->Histogram.Count[bi][BCOMP]++;
+      ctx->Histogram.Count[ai][ACOMP]++;
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_histogram.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_histogram.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_histogram.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,40 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_HISTOGRAM_H
+#define S_HISTOGRAM_H
+
+#include "mtypes.h"
+#include "swrast.h"
+
+extern void
+_mesa_update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]);
+
+extern void
+_mesa_update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]);
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_imaging.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_imaging.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_imaging.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,149 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/* KW:  Moved these here to remove knowledge of swrast from core mesa.
+ * Should probably pull the entire software implementation of these
+ * extensions into either swrast or a sister module.  
+ */
+
+#include "s_context.h"
+#include "s_span.h"
+
+void
+_swrast_CopyColorTable( GLcontext *ctx, 
+			GLenum target, GLenum internalformat,
+			GLint x, GLint y, GLsizei width)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLchan data[MAX_WIDTH][4];
+
+   /* Select buffer to read from */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                 ctx->Pixel.DriverReadBuffer );
+
+   if (width > MAX_WIDTH)
+      width = MAX_WIDTH;
+
+   /* read the data from framebuffer */
+   _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
+
+   /* Restore reading from draw buffer (the default) */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                 ctx->Color.DriverDrawBuffer );
+
+   glColorTable(target, internalformat, width, GL_RGBA, CHAN_TYPE, data);
+}
+
+void
+_swrast_CopyColorSubTable( GLcontext *ctx,GLenum target, GLsizei start,
+			   GLint x, GLint y, GLsizei width)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLchan data[MAX_WIDTH][4];
+
+   /* Select buffer to read from */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                 ctx->Pixel.DriverReadBuffer );
+
+   if (width > MAX_WIDTH)
+      width = MAX_WIDTH;
+
+   /* read the data from framebuffer */
+   _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y, data );
+
+   /* Restore reading from draw buffer (the default) */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                 ctx->Color.DriverDrawBuffer );
+
+   glColorSubTable(target, start, width, GL_RGBA, CHAN_TYPE, data);
+}
+
+
+void
+_swrast_CopyConvolutionFilter1D(GLcontext *ctx, GLenum target, 
+				GLenum internalFormat, 
+				GLint x, GLint y, GLsizei width)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLchan rgba[MAX_CONVOLUTION_WIDTH][4];
+
+   RENDER_START( swrast, ctx );
+
+   /* read the data from framebuffer */
+   _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y,
+				(GLchan (*)[4]) rgba );
+   
+   RENDER_FINISH( swrast, ctx );
+
+   /* store as convolution filter */
+   glConvolutionFilter1D(target, internalFormat, width,
+			 GL_RGBA, CHAN_TYPE, rgba);
+}
+
+
+void
+_swrast_CopyConvolutionFilter2D(GLcontext *ctx, GLenum target, 
+				GLenum internalFormat, 
+				GLint x, GLint y, GLsizei width, GLsizei height)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   struct gl_pixelstore_attrib packSave;
+   GLchan rgba[MAX_CONVOLUTION_HEIGHT][MAX_CONVOLUTION_WIDTH][4];
+   GLint i;
+
+   RENDER_START(swrast,ctx);
+   
+   /* read pixels from framebuffer */
+   for (i = 0; i < height; i++) {
+      _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y + i,
+				(GLchan (*)[4]) rgba[i] );
+   }
+
+   RENDER_FINISH(swrast,ctx);
+
+   /*
+    * HACK: save & restore context state so we can store this as a
+    * convolution filter via the GL api.  Doesn't call any callbacks
+    * hanging off ctx->Unpack statechanges.
+    */
+
+   packSave = ctx->Unpack;  /* save pixel packing params */
+
+   ctx->Unpack.Alignment = 1;
+   ctx->Unpack.RowLength = MAX_CONVOLUTION_WIDTH;
+   ctx->Unpack.SkipPixels = 0;
+   ctx->Unpack.SkipRows = 0;
+   ctx->Unpack.ImageHeight = 0;
+   ctx->Unpack.SkipImages = 0;
+   ctx->Unpack.SwapBytes = GL_FALSE;
+   ctx->Unpack.LsbFirst = GL_FALSE;
+   ctx->NewState |= _NEW_PACKUNPACK;
+
+   glConvolutionFilter2D(target, internalFormat, width, height,
+			 GL_RGBA, CHAN_TYPE, rgba);
+
+   ctx->Unpack = packSave;  /* restore pixel packing params */
+   ctx->NewState |= _NEW_PACKUNPACK; 
+}
Index: xc/extras/Mesa/src/swrast/s_lines.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_lines.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_lines.c	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,1118 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mmath.h"
+#include "s_aaline.h"
+#include "s_pb.h"
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_lines.h"
+#include "s_feedback.h"
+
+
+
+/**********************************************************************/
+/*****                    Rasterization                           *****/
+/**********************************************************************/
+
+
+/*
+ * There are 4 pairs (RGBA, CI) of line drawing functions:
+ *   1. simple:  width=1 and no special rasterization functions (fastest)
+ *   2. flat:  width=1, non-stippled, flat-shaded, any raster operations
+ *   3. smooth:  width=1, non-stippled, smooth-shaded, any raster operations
+ *   4. general:  any other kind of line (slowest)
+ */
+
+
+/* Flat, color index line */
+static void flat_ci_line( GLcontext *ctx,
+                          const SWvertex *vert0,
+			  const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+
+   PB_SET_INDEX( PB, vert0->index );
+
+#define INTERP_XY 1
+#define PLOT(X,Y)  PB_WRITE_PIXEL(PB, X, Y, 0, 0);
+
+#include "s_linetemp.h"
+
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Flat, color index line with Z interpolation/testing */
+static void flat_ci_z_line( GLcontext *ctx,
+                            const SWvertex *vert0,
+			    const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   PB_SET_INDEX( PB, vert0->index );
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define PLOT(X,Y)  PB_WRITE_PIXEL(PB, X, Y, Z, fog0);
+
+#include "s_linetemp.h"
+
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Flat-shaded, RGBA line */
+static void flat_rgba_line( GLcontext *ctx,
+                            const SWvertex *vert0,
+			    const SWvertex *vert1 )
+{
+   const GLchan *color = vert1->color;
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] );
+
+#define INTERP_XY 1
+#define PLOT(X,Y)   PB_WRITE_PIXEL(PB, X, Y, 0, 0);
+
+#include "s_linetemp.h"
+
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Flat-shaded, RGBA line with Z interpolation/testing */
+static void flat_rgba_z_line( GLcontext *ctx,
+                              const SWvertex *vert0,
+			      const SWvertex *vert1 )
+{
+   const GLchan *color = vert1->color;
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] );
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define PLOT(X,Y)   PB_WRITE_PIXEL(PB, X, Y, Z, fog0);
+
+#include "s_linetemp.h"
+
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Smooth shaded, color index line */
+static void smooth_ci_line( GLcontext *ctx,
+                            const SWvertex *vert0,
+			    const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLuint *pbi = PB->index;
+
+   PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_INDEX 1
+
+#define PLOT(X,Y)		\
+	pbx[count] = X;		\
+	pby[count] = Y;		\
+	pbi[count] = I;		\
+	count++;
+
+#include "s_linetemp.h"
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Smooth shaded, color index line with Z interpolation/testing */
+static void smooth_ci_z_line( GLcontext *ctx,
+                              const SWvertex *vert0,
+			      const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLuint *pbi = PB->index;
+
+   PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_INDEX 1
+
+#define PLOT(X,Y)		\
+	pbx[count] = X;		\
+	pby[count] = Y;		\
+	pbz[count] = Z;		\
+	pbi[count] = I;		\
+	count++;
+
+#include "s_linetemp.h"
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Smooth-shaded, RGBA line */
+static void smooth_rgba_line( GLcontext *ctx,
+                       	      const SWvertex *vert0,
+			      const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLchan (*pbrgba)[4] = PB->rgba;
+
+   PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+
+#define PLOT(X,Y)			\
+	pbx[count] = X;			\
+	pby[count] = Y;			\
+	pbrgba[count][RCOMP] = FixedToInt(r0);	\
+	pbrgba[count][GCOMP] = FixedToInt(g0);	\
+	pbrgba[count][BCOMP] = FixedToInt(b0);	\
+	pbrgba[count][ACOMP] = FixedToInt(a0);	\
+	count++;
+
+#include "s_linetemp.h"
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Smooth-shaded, RGBA line with Z interpolation/testing */
+static void smooth_rgba_z_line( GLcontext *ctx,
+                       	        const SWvertex *vert0,
+				const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   GLchan (*pbrgba)[4] = PB->rgba;
+
+
+   PB->mono = GL_FALSE;
+
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+
+#define PLOT(X,Y)				\
+	pbx[count] = X;				\
+	pby[count] = Y;				\
+	pbz[count] = Z;				\
+	pbfog[count] = fog0;			\
+	pbrgba[count][RCOMP] = FixedToInt(r0);	\
+	pbrgba[count][GCOMP] = FixedToInt(g0);	\
+	pbrgba[count][BCOMP] = FixedToInt(b0);	\
+	pbrgba[count][ACOMP] = FixedToInt(a0);	\
+	count++;
+
+#include "s_linetemp.h"
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+#define CHECK_FULL(count)		\
+   if (count >= PB_SIZE-MAX_WIDTH) {	\
+      PB->count = count;		\
+      _mesa_flush_pb(ctx);			\
+      count = PB->count;		\
+   }
+
+
+
+/* Smooth shaded, color index, any width, maybe stippled */
+static void general_smooth_ci_line( GLcontext *ctx,
+                           	    const SWvertex *vert0,
+				    const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   GLuint *pbi = PB->index;
+
+   PB->mono = GL_FALSE;
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_INDEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)		\
+	pbx[count] = X;		\
+	pby[count] = Y;		\
+	pbz[count] = Z;		\
+	pbfog[count] = fog0;	\
+	pbi[count] = I;		\
+	count++;		\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+      if (ctx->Line.Width==2.0F) {
+         /* special case: unstippled and width=2 */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_INDEX 1
+#define XMAJOR_PLOT(X,Y)				\
+	pbx[count] = X;  pbx[count+1] = X;		\
+	pby[count] = Y;  pby[count+1] = Y+1;		\
+	pbz[count] = Z;  pbz[count+1] = Z;		\
+	pbfog[count] = fog0;  pbfog[count+1] = fog0;	\
+	pbi[count] = I;  pbi[count+1] = I;		\
+	count += 2;					\
+	CHECK_FULL(count);
+#define YMAJOR_PLOT(X,Y)				\
+	pbx[count] = X;  pbx[count+1] = X+1;		\
+	pby[count] = Y;  pby[count+1] = Y;		\
+	pbz[count] = Z;  pbz[count+1] = Z;		\
+	pbfog[count] = fog0;  pbfog[count+1] = fog0;	\
+	pbi[count] = I;  pbi[count+1] = I;		\
+	count += 2;					\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+      }
+      else {
+         /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_INDEX 1
+#define WIDE 1
+#define PLOT(X,Y)		\
+	pbx[count] = X;		\
+	pby[count] = Y;		\
+	pbz[count] = Z;		\
+	pbi[count] = I;		\
+	pbfog[count] = fog0;	\
+	count++;		\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+      }
+   }
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+/* Flat shaded, color index, any width, maybe stippled */
+static void general_flat_ci_line( GLcontext *ctx,
+                                  const SWvertex *vert0,
+				  const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   PB_SET_INDEX( PB, vert0->index );
+   count = PB->count;
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)		\
+	pbx[count] = X;		\
+	pby[count] = Y;		\
+	pbz[count] = Z;		\
+	pbfog[count] = fog0;	\
+	count++;		\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+      if (ctx->Line.Width==2.0F) {
+         /* special case: unstippled and width=2 */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define XMAJOR_PLOT(X,Y)				\
+	pbx[count] = X;  pbx[count+1] = X;		\
+	pby[count] = Y;  pby[count+1] = Y+1;		\
+	pbz[count] = Z;  pbz[count+1] = Z;		\
+	pbfog[count] = fog0;  pbfog[count+1] = fog0;	\
+	count += 2;					\
+	CHECK_FULL(count);
+#define YMAJOR_PLOT(X,Y)				\
+	pbx[count] = X;  pbx[count+1] = X+1;		\
+	pby[count] = Y;  pby[count+1] = Y;		\
+	pbz[count] = Z;  pbz[count+1] = Z;		\
+	pbfog[count] = fog0;  pbfog[count+1] = fog0;	\
+	count += 2;					\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+      }
+      else {
+         /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define WIDE 1
+#define PLOT(X,Y)		\
+	pbx[count] = X;		\
+	pby[count] = Y;		\
+	pbz[count] = Z;		\
+	pbfog[count] = fog0;	\
+	count++;		\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+      }
+   }
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+
+static void general_smooth_rgba_line( GLcontext *ctx,
+                                      const SWvertex *vert0,
+				      const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   GLchan (*pbrgba)[4] = PB->rgba;
+
+   PB->mono = GL_FALSE;
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)				\
+	pbx[count] = X;				\
+	pby[count] = Y;				\
+	pbz[count] = Z;				\
+	pbfog[count] = fog0;			\
+	pbrgba[count][RCOMP] = FixedToInt(r0);	\
+	pbrgba[count][GCOMP] = FixedToInt(g0);	\
+	pbrgba[count][BCOMP] = FixedToInt(b0);	\
+	pbrgba[count][ACOMP] = FixedToInt(a0);	\
+	count++;				\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+      if (ctx->Line.Width==2.0F) {
+         /* special case: unstippled and width=2 */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define XMAJOR_PLOT(X,Y)				\
+	pbx[count] = X;  pbx[count+1] = X;		\
+	pby[count] = Y;  pby[count+1] = Y+1;		\
+	pbz[count] = Z;  pbz[count+1] = Z;		\
+	pbfog[count] = fog0;  pbfog[count+1] = fog0;	\
+	pbrgba[count][RCOMP] = FixedToInt(r0);		\
+	pbrgba[count][GCOMP] = FixedToInt(g0);		\
+	pbrgba[count][BCOMP] = FixedToInt(b0);		\
+	pbrgba[count][ACOMP] = FixedToInt(a0);		\
+	pbrgba[count+1][RCOMP] = FixedToInt(r0);	\
+	pbrgba[count+1][GCOMP] = FixedToInt(g0);	\
+	pbrgba[count+1][BCOMP] = FixedToInt(b0);	\
+	pbrgba[count+1][ACOMP] = FixedToInt(a0);	\
+	count += 2;					\
+	CHECK_FULL(count);
+#define YMAJOR_PLOT(X,Y)				\
+	pbx[count] = X;  pbx[count+1] = X+1;		\
+	pby[count] = Y;  pby[count+1] = Y;		\
+	pbz[count] = Z;  pbz[count+1] = Z;		\
+	pbfog[count] = fog0;  pbfog[count+1] = fog0;	\
+	pbrgba[count][RCOMP] = FixedToInt(r0);		\
+	pbrgba[count][GCOMP] = FixedToInt(g0);		\
+	pbrgba[count][BCOMP] = FixedToInt(b0);		\
+	pbrgba[count][ACOMP] = FixedToInt(a0);		\
+	pbrgba[count+1][RCOMP] = FixedToInt(r0);	\
+	pbrgba[count+1][GCOMP] = FixedToInt(g0);	\
+	pbrgba[count+1][BCOMP] = FixedToInt(b0);	\
+	pbrgba[count+1][ACOMP] = FixedToInt(a0);	\
+	count += 2;					\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+      }
+      else {
+         /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define WIDE 1
+#define PLOT(X,Y)				\
+	pbx[count] = X;				\
+	pby[count] = Y;				\
+	pbz[count] = Z;				\
+	pbfog[count] = fog0;  			\
+	pbrgba[count][RCOMP] = FixedToInt(r0);	\
+	pbrgba[count][GCOMP] = FixedToInt(g0);	\
+	pbrgba[count][BCOMP] = FixedToInt(b0);	\
+	pbrgba[count][ACOMP] = FixedToInt(a0);	\
+	count++;				\
+	CHECK_FULL(count);
+#include "s_linetemp.h"
+      }
+   }
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+static void general_flat_rgba_line( GLcontext *ctx,
+                                    const SWvertex *vert0,
+				    const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   const GLchan *color = vert1->color;
+   GLuint count;
+   PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] );
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)                       \
+    PB_WRITE_PIXEL(PB, X, Y, Z, fog0);  \
+    count = PB->count;                  \
+    CHECK_FULL(count);
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+      if (ctx->Line.Width==2.0F) {
+         /* special case: unstippled and width=2 */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define XMAJOR_PLOT(X,Y) PB_WRITE_PIXEL(PB, X, Y, Z, fog0); \
+                         PB_WRITE_PIXEL(PB, X, Y+1, Z, fog0);
+#define YMAJOR_PLOT(X,Y)  PB_WRITE_PIXEL(PB, X, Y, Z, fog0); \
+                          PB_WRITE_PIXEL(PB, X+1, Y, Z, fog0);
+#include "s_linetemp.h"
+      }
+      else {
+         /* unstippled, any width */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define WIDE 1
+#define PLOT(X,Y)                       \
+    PB_WRITE_PIXEL(PB, X, Y, Z, fog0);  \
+    count = PB->count;                  \
+    CHECK_FULL(count);
+#include "s_linetemp.h"
+      }
+   }
+
+   _mesa_flush_pb(ctx);
+}
+
+
+/* Flat-shaded, textured, any width, maybe stippled */
+static void flat_textured_line( GLcontext *ctx,
+                                const SWvertex *vert0,
+				const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   GLfloat *pbs = PB->s[0];
+   GLfloat *pbt = PB->t[0];
+   GLfloat *pbu = PB->u[0];
+   GLchan *color = (GLchan*) vert1->color;
+   PB_SET_COLOR( PB, color[0], color[1], color[2], color[3] );
+   count = PB->count;
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)			\
+	{				\
+	   pbx[count] = X;		\
+	   pby[count] = Y;		\
+	   pbz[count] = Z;		\
+ 	   pbfog[count] = fog0;		\
+	   pbs[count] = fragTexcoord[0];\
+	   pbt[count] = fragTexcoord[1];\
+	   pbu[count] = fragTexcoord[2];\
+	   count++;			\
+	   CHECK_FULL(count);		\
+	}
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define PLOT(X,Y)			\
+	{				\
+	   pbx[count] = X;		\
+	   pby[count] = Y;		\
+	   pbz[count] = Z;		\
+ 	   pbfog[count] = fog0;		\
+	   pbs[count] = fragTexcoord[0];\
+	   pbt[count] = fragTexcoord[1];\
+	   pbu[count] = fragTexcoord[2];\
+	   count++;			\
+	   CHECK_FULL(count);		\
+	}
+#include "s_linetemp.h"
+   }
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+
+/* Smooth-shaded, textured, any width, maybe stippled */
+static void smooth_textured_line( GLcontext *ctx,
+                                  const SWvertex *vert0,
+				  const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   GLfloat *pbs = PB->s[0];
+   GLfloat *pbt = PB->t[0];
+   GLfloat *pbu = PB->u[0];
+   GLchan (*pbrgba)[4] = PB->rgba;
+
+   PB->mono = GL_FALSE;
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)					\
+	{						\
+	   pbx[count] = X;				\
+	   pby[count] = Y;				\
+	   pbz[count] = Z;				\
+ 	   pbfog[count] = fog0;				\
+	   pbs[count] = fragTexcoord[0];		\
+	   pbt[count] = fragTexcoord[1];		\
+	   pbu[count] = fragTexcoord[2];		\
+	   pbrgba[count][RCOMP] = FixedToInt(r0);	\
+	   pbrgba[count][GCOMP] = FixedToInt(g0);	\
+	   pbrgba[count][BCOMP] = FixedToInt(b0);	\
+	   pbrgba[count][ACOMP] = FixedToInt(a0);	\
+	   count++;					\
+	   CHECK_FULL(count);				\
+	}
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define WIDE 1
+#define PLOT(X,Y)					\
+	{						\
+	   pbx[count] = X;				\
+	   pby[count] = Y;				\
+	   pbz[count] = Z;				\
+ 	   pbfog[count] = fog0;				\
+	   pbs[count] = fragTexcoord[0];		\
+	   pbt[count] = fragTexcoord[1];		\
+	   pbu[count] = fragTexcoord[2];		\
+	   pbrgba[count][RCOMP] = FixedToInt(r0);	\
+	   pbrgba[count][GCOMP] = FixedToInt(g0);	\
+	   pbrgba[count][BCOMP] = FixedToInt(b0);	\
+	   pbrgba[count][ACOMP] = FixedToInt(a0);	\
+	   count++;					\
+	   CHECK_FULL(count);				\
+	}
+#include "s_linetemp.h"
+   }
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+/* Smooth-shaded, multitextured, any width, maybe stippled, separate specular
+ * color interpolation.
+ */
+static void smooth_multitextured_line( GLcontext *ctx,
+				       const SWvertex *vert0,
+				       const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   GLchan (*pbrgba)[4] = PB->rgba;
+   GLchan (*pbspec)[3] = PB->spec;
+
+   PB->mono = GL_FALSE;
+   PB->haveSpec = GL_TRUE;
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)						\
+	{							\
+	   GLuint u;						\
+	   pbx[count] = X;					\
+	   pby[count] = Y;					\
+	   pbz[count] = Z;					\
+ 	   pbfog[count] = fog0;					\
+	   pbrgba[count][RCOMP] = FixedToInt(r0);		\
+	   pbrgba[count][GCOMP] = FixedToInt(g0);		\
+	   pbrgba[count][BCOMP] = FixedToInt(b0);		\
+	   pbrgba[count][ACOMP] = FixedToInt(a0);		\
+	   pbspec[count][RCOMP] = FixedToInt(sr0);		\
+	   pbspec[count][GCOMP] = FixedToInt(sg0);		\
+	   pbspec[count][BCOMP] = FixedToInt(sb0);		\
+	   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {	\
+	      if (ctx->Texture.Unit[u]._ReallyEnabled) {	\
+	         PB->s[u][count] = fragTexcoord[u][0];		\
+	         PB->t[u][count] = fragTexcoord[u][1];		\
+	         PB->u[u][count] = fragTexcoord[u][2];		\
+	      }							\
+	   }							\
+	   count++;						\
+	   CHECK_FULL(count);					\
+	}
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define PLOT(X,Y)						\
+	{							\
+	   GLuint u;						\
+	   pbx[count] = X;					\
+	   pby[count] = Y;					\
+	   pbz[count] = Z;					\
+ 	   pbfog[count] = fog0;					\
+	   pbrgba[count][RCOMP] = FixedToInt(r0);		\
+	   pbrgba[count][GCOMP] = FixedToInt(g0);		\
+	   pbrgba[count][BCOMP] = FixedToInt(b0);		\
+	   pbrgba[count][ACOMP] = FixedToInt(a0);		\
+	   pbspec[count][RCOMP] = FixedToInt(sr0);		\
+	   pbspec[count][GCOMP] = FixedToInt(sg0);		\
+	   pbspec[count][BCOMP] = FixedToInt(sb0);		\
+	   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {	\
+	      if (ctx->Texture.Unit[u]._ReallyEnabled) {	\
+	         PB->s[u][count] = fragTexcoord[u][0];		\
+	         PB->t[u][count] = fragTexcoord[u][1];		\
+	         PB->u[u][count] = fragTexcoord[u][2];		\
+	      }							\
+	   }							\
+	   count++;						\
+	   CHECK_FULL(count);					\
+	}
+#include "s_linetemp.h"
+   }
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+/* Flat-shaded, multitextured, any width, maybe stippled, separate specular
+ * color interpolation.
+ */
+static void flat_multitextured_line( GLcontext *ctx,
+                                     const SWvertex *vert0,
+				     const SWvertex *vert1 )
+{
+   struct pixel_buffer *PB = SWRAST_CONTEXT(ctx)->PB;
+   GLint count = PB->count;
+   GLint *pbx = PB->x;
+   GLint *pby = PB->y;
+   GLdepth *pbz = PB->z;
+   GLfloat *pbfog = PB->fog;
+   GLchan (*pbrgba)[4] = PB->rgba;
+   GLchan (*pbspec)[3] = PB->spec;
+   GLchan *color = (GLchan*) vert1->color;
+   GLchan sRed   = vert1->specular[0];
+   GLchan sGreen = vert1->specular[1];
+   GLchan sBlue  = vert1->specular[2];
+
+   PB->mono = GL_FALSE;
+   PB->haveSpec = GL_TRUE;
+
+   if (ctx->Line.StippleFlag) {
+      /* stippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define STIPPLE 1
+#define PLOT(X,Y)						\
+	{							\
+	   GLuint u;						\
+	   pbx[count] = X;					\
+	   pby[count] = Y;					\
+	   pbz[count] = Z;					\
+ 	   pbfog[count] = fog0;					\
+	   pbrgba[count][RCOMP] = color[0];			\
+	   pbrgba[count][GCOMP] = color[1];			\
+	   pbrgba[count][BCOMP] = color[2];			\
+	   pbrgba[count][ACOMP] = color[3];			\
+	   pbspec[count][RCOMP] = sRed;				\
+	   pbspec[count][GCOMP] = sGreen;			\
+	   pbspec[count][BCOMP] = sBlue;			\
+	   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {	\
+	      if (ctx->Texture.Unit[u]._ReallyEnabled) {	\
+	         PB->s[u][count] = fragTexcoord[u][0];		\
+	         PB->t[u][count] = fragTexcoord[u][1];		\
+	         PB->u[u][count] = fragTexcoord[u][2];		\
+	      }							\
+	   }							\
+	   count++;						\
+	   CHECK_FULL(count);					\
+	}
+#include "s_linetemp.h"
+   }
+   else {
+      /* unstippled */
+#define INTERP_XY 1
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_ALPHA 1
+#define INTERP_MULTITEX 1
+#define WIDE 1
+#define PLOT(X,Y)						\
+	{							\
+	   GLuint u;						\
+	   pbx[count] = X;					\
+	   pby[count] = Y;					\
+	   pbz[count] = Z;					\
+ 	   pbfog[count] = fog0;					\
+	   pbrgba[count][RCOMP] = color[0];			\
+	   pbrgba[count][GCOMP] = color[1];			\
+	   pbrgba[count][BCOMP] = color[2];			\
+	   pbrgba[count][ACOMP] = color[3];			\
+	   pbspec[count][RCOMP] = sRed;				\
+	   pbspec[count][GCOMP] = sGreen;			\
+	   pbspec[count][BCOMP] = sBlue;			\
+	   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {	\
+	      if (ctx->Texture.Unit[u]._ReallyEnabled) {	\
+	         PB->s[u][count] = fragTexcoord[u][0];		\
+	         PB->t[u][count] = fragTexcoord[u][1];		\
+	         PB->u[u][count] = fragTexcoord[u][2];		\
+	      }							\
+	   }							\
+	   count++;						\
+	   CHECK_FULL(count);					\
+	}
+#include "s_linetemp.h"
+   }
+
+   PB->count = count;
+   _mesa_flush_pb(ctx);
+}
+
+
+void _swrast_add_spec_terms_line( GLcontext *ctx,
+				  const SWvertex *v0,
+				  const SWvertex *v1 )
+{
+   SWvertex *ncv0 = (SWvertex *)v0;
+   SWvertex *ncv1 = (SWvertex *)v1;
+   GLchan c[2][4];
+   COPY_CHAN4( c[0], ncv0->color );
+   COPY_CHAN4( c[1], ncv1->color );
+   ACC_3V( ncv0->color, ncv0->specular );
+   ACC_3V( ncv1->color, ncv1->specular );
+   SWRAST_CONTEXT(ctx)->SpecLine( ctx, ncv0, ncv1 );
+   COPY_CHAN4( ncv0->color, c[0] );
+   COPY_CHAN4( ncv1->color, c[1] );
+}
+
+
+#ifdef DEBUG
+extern void
+_mesa_print_line_function(GLcontext *ctx);  /* silence compiler warning */
+void
+_mesa_print_line_function(GLcontext *ctx)
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   printf("Line Func == ");
+   if (swrast->Line == flat_ci_line)
+      printf("flat_ci_line\n");
+   else if (swrast->Line == flat_ci_z_line)
+      printf("flat_ci_z_line\n");
+   else if (swrast->Line == flat_rgba_line)
+      printf("flat_rgba_line\n");
+   else if (swrast->Line == flat_rgba_z_line)
+      printf("flat_rgba_z_line\n");
+   else if (swrast->Line == smooth_ci_line)
+      printf("smooth_ci_line\n");
+   else if (swrast->Line == smooth_ci_z_line)
+      printf("smooth_ci_z_line\n");
+   else if (swrast->Line == smooth_rgba_line)
+      printf("smooth_rgba_line\n");
+   else if (swrast->Line == smooth_rgba_z_line)
+      printf("smooth_rgba_z_line\n");
+   else if (swrast->Line == general_smooth_ci_line)
+      printf("general_smooth_ci_line\n");
+   else if (swrast->Line == general_flat_ci_line)
+      printf("general_flat_ci_line\n");
+   else if (swrast->Line == general_smooth_rgba_line)
+      printf("general_smooth_rgba_line\n");
+   else if (swrast->Line == general_flat_rgba_line)
+      printf("general_flat_rgba_line\n");
+   else if (swrast->Line == flat_textured_line)
+      printf("flat_textured_line\n");
+   else if (swrast->Line == smooth_textured_line)
+      printf("smooth_textured_line\n");
+   else if (swrast->Line == smooth_multitextured_line)
+      printf("smooth_multitextured_line\n");
+   else if (swrast->Line == flat_multitextured_line)
+      printf("flat_multitextured_line\n");
+   else
+      printf("Driver func %p\n", (void *) swrast->Line);
+}
+#endif
+
+
+
+#ifdef DEBUG
+
+/* record the current line function name */
+static const char *lineFuncName = NULL;
+
+#define USE(lineFunc)                   \
+do {                                    \
+    lineFuncName = #lineFunc;           \
+    /*printf("%s\n", lineFuncName);*/   \
+    swrast->Line = lineFunc;            \
+} while (0)
+
+#else
+
+#define USE(lineFunc)  swrast->Line = lineFunc
+
+#endif
+
+
+
+/*
+ * Determine which line drawing function to use given the current
+ * rendering context.
+ *
+ * Please update the summary flag _SWRAST_NEW_LINE if you add or remove
+ * tests to this code.
+ */
+void
+_swrast_choose_line( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLboolean rgbmode = ctx->Visual.rgbMode;
+
+   if (ctx->RenderMode==GL_RENDER) {
+      if (ctx->Line.SmoothFlag) {
+         /* antialiased lines */
+         _swrast_choose_aa_line_function(ctx);
+         ASSERT(swrast->Triangle);
+      }
+      else if (ctx->Texture._ReallyEnabled) {
+         if (ctx->Texture._ReallyEnabled > TEXTURE0_ANY ||	     
+	     (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)) {
+            /* multi-texture and/or separate specular color */
+            if (ctx->Light.ShadeModel==GL_SMOOTH)
+               USE(smooth_multitextured_line);
+            else
+               USE(flat_multitextured_line);
+         }
+         else {
+            if (ctx->Light.ShadeModel==GL_SMOOTH) {
+                USE(smooth_textured_line);
+            }
+            else {
+                USE(flat_textured_line);
+            }
+         }
+      }
+      else if (ctx->Line.Width!=1.0 || ctx->Line.StippleFlag) {
+         if (ctx->Light.ShadeModel==GL_SMOOTH) {
+            if (rgbmode)
+               USE(general_smooth_rgba_line);
+            else
+               USE(general_smooth_ci_line);
+         }
+         else {
+            if (rgbmode)
+               USE(general_flat_rgba_line);
+            else
+               USE(general_flat_ci_line);
+         }
+      }
+      else {
+	 if (ctx->Light.ShadeModel==GL_SMOOTH) {
+	    /* Width==1, non-stippled, smooth-shaded */
+            if (ctx->Depth.Test || ctx->Fog.Enabled) {
+               if (rgbmode)
+                  USE(smooth_rgba_z_line);
+               else
+                  USE(smooth_ci_z_line);
+            }
+            else {
+               if (rgbmode)
+                  USE(smooth_rgba_line);
+               else
+                  USE(smooth_ci_line);
+            }
+	 }
+         else {
+	    /* Width==1, non-stippled, flat-shaded */
+            if (ctx->Depth.Test || ctx->Fog.Enabled) {
+               if (rgbmode)
+                  USE(flat_rgba_z_line);
+               else
+                  USE(flat_ci_z_line);
+            }
+            else {
+               if (rgbmode)
+                  USE(flat_rgba_line);
+               else
+                  USE(flat_ci_line);
+            }
+         }
+      }
+   }
+   else if (ctx->RenderMode==GL_FEEDBACK) {
+      USE(_mesa_feedback_line);
+   }
+   else {
+      /* GL_SELECT mode */
+      USE(_mesa_select_line);
+   }
+
+   /*_mesa_print_line_function(ctx);*/
+}
Index: xc/extras/Mesa/src/swrast/s_lines.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_lines.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_lines.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,41 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_LINES_H
+#define S_LINES_H
+
+#include "mtypes.h"
+
+void
+_swrast_choose_line( GLcontext *ctx );
+
+void
+_swrast_add_spec_terms_line( GLcontext *ctx,
+			     const SWvertex *v0,
+			     const SWvertex *v1 );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_linetemp.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_linetemp.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_linetemp.h	Mon Dec 16 11:18:39 2002
@@ -0,0 +1,670 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.5
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Line Rasterizer Template
+ *
+ * This file is #include'd to generate custom line rasterizers.
+ *
+ * The following macros may be defined to indicate what auxillary information
+ * must be interplated along the line:
+ *    INTERP_Z        - if defined, interpolate Z values
+ *    INTERP_FOG      - if defined, interpolate FOG values
+ *    INTERP_RGB      - if defined, interpolate RGB values
+ *    INTERP_SPEC     - if defined, interpolate specular RGB values
+ *    INTERP_ALPHA    - if defined, interpolate Alpha values
+ *    INTERP_INDEX    - if defined, interpolate color index values
+ *    INTERP_TEX      - if defined, interpolate unit 0 texcoords
+ *    INTERP_MULTITEX - if defined, interpolate multi-texcoords
+ *
+ * When one can directly address pixels in the color buffer the following
+ * macros can be defined and used to directly compute pixel addresses during
+ * rasterization (see pixelPtr):
+ *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)
+ *    BYTES_PER_ROW       - number of bytes per row in the color buffer
+ *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
+ *                          Y==0 at bottom of screen and increases upward.
+ *
+ * Similarly, for direct depth buffer access, this type is used for depth
+ * buffer addressing:
+ *    DEPTH_TYPE          - either GLushort or GLuint
+ *
+ * Optionally, one may provide one-time setup code
+ *    SETUP_CODE    - code which is to be executed once per line
+ *
+ * To enable line stippling define STIPPLE = 1
+ * To enable wide lines define WIDE = 1
+ *
+ * To actually "plot" each pixel either the PLOT macro or
+ * (XMAJOR_PLOT and YMAJOR_PLOT macros) must be defined...
+ *    PLOT(X,Y) - code to plot a pixel.  Example:
+ *                if (Z < *zPtr) {
+ *                   *zPtr = Z;
+ *                   color = pack_rgb( FixedToInt(r0), FixedToInt(g0),
+ *                                     FixedToInt(b0) );
+ *                   put_pixel( X, Y, color );
+ *                }
+ *
+ * This code was designed for the origin to be in the lower-left corner.
+ *
+ */
+
+
+/*void line( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )*/
+{
+   GLint x0 = (GLint) vert0->win[0];
+   GLint x1 = (GLint) vert1->win[0];
+   GLint y0 = (GLint) vert0->win[1];
+   GLint y1 = (GLint) vert1->win[1];
+   GLint dx, dy;
+#ifdef INTERP_XY
+   GLint xstep, ystep;
+#endif
+#ifdef INTERP_Z
+   GLint z0, z1, dz;
+   const GLint depthBits = ctx->Visual.depthBits;
+   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
+#  define FixedToDepth(F)  ((F) >> fixedToDepthShift)
+#  ifdef DEPTH_TYPE
+   GLint zPtrXstep, zPtrYstep;
+   DEPTH_TYPE *zPtr;
+#  endif
+#endif
+#ifdef INTERP_FOG
+   GLfloat fog0 = vert0->fog;
+   GLfloat dfog = vert1->fog - fog0;
+#endif
+#ifdef INTERP_RGB
+   GLfixed r0 = ChanToFixed(vert0->color[0]);
+   GLfixed dr = ChanToFixed(vert1->color[0]) - r0;
+   GLfixed g0 = ChanToFixed(vert0->color[1]);
+   GLfixed dg = ChanToFixed(vert1->color[1]) - g0;
+   GLfixed b0 = ChanToFixed(vert0->color[2]);
+   GLfixed db = ChanToFixed(vert1->color[2]) - b0;
+#endif
+#ifdef INTERP_SPEC
+   GLfixed sr0 = ChanToFixed(vert0->specular[0]);
+   GLfixed dsr = ChanToFixed(vert1->specular[0]) - sr0;
+   GLfixed sg0 = ChanToFixed(vert0->specular[1]);
+   GLfixed dsg = ChanToFixed(vert1->specular[1]) - sg0;
+   GLfixed sb0 = ChanToFixed(vert0->specular[2]);
+   GLfixed dsb = ChanToFixed(vert1->specular[2]) - sb0;
+#endif
+#ifdef INTERP_ALPHA
+   GLfixed a0 = ChanToFixed(vert0->color[3]);
+   GLfixed da = ChanToFixed(vert1->color[3]) - a0;
+#endif
+#ifdef INTERP_INDEX
+   GLint i0 = vert0->index << 8;
+   GLint di = (GLint) (vert1->index << 8) - i0;
+#endif
+#ifdef INTERP_TEX
+   const GLfloat invw0 = vert0->win[3];
+   const GLfloat invw1 = vert1->win[3];
+   GLfloat tex[4];
+   GLfloat dtex[4];
+   GLfloat fragTexcoord[4];
+#endif
+#ifdef INTERP_MULTITEX
+   const GLfloat invw0 = vert0->win[3];
+   const GLfloat invw1 = vert1->win[3];
+   GLfloat tex[MAX_TEXTURE_UNITS][4];
+   GLfloat dtex[MAX_TEXTURE_UNITS][4];
+   GLfloat fragTexcoord[MAX_TEXTURE_UNITS][4];
+#endif
+#ifdef PIXEL_ADDRESS
+   PIXEL_TYPE *pixelPtr;
+   GLint pixelXstep, pixelYstep;
+#endif
+#ifdef STIPPLE
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+#endif
+#ifdef WIDE
+   /* for wide lines, draw all X in [x+min, x+max] or Y in [y+min, y+max] */
+   GLint width, min, max;
+   width = (GLint) CLAMP( ctx->Line.Width, MIN_LINE_WIDTH, MAX_LINE_WIDTH );
+   min = (width-1) / -2;
+   max = min + width - 1;
+#endif
+#ifdef INTERP_TEX
+   {
+      tex[0]  = invw0 * vert0->texcoord[0][0];
+      dtex[0] = invw1 * vert1->texcoord[0][0] - tex[0];
+      tex[1]  = invw0 * vert0->texcoord[0][1];
+      dtex[1] = invw1 * vert1->texcoord[0][1] - tex[1];
+      tex[2]  = invw0 * vert0->texcoord[0][2];
+      dtex[2] = invw1 * vert1->texcoord[0][2] - tex[2];
+      tex[3]  = invw0 * vert0->texcoord[0][3];
+      dtex[3] = invw1 * vert1->texcoord[0][3] - tex[3];
+   }
+#endif
+#ifdef INTERP_MULTITEX
+   {
+      GLuint u;
+      for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+         if (ctx->Texture.Unit[u]._ReallyEnabled) {
+            tex[u][0]  = invw0 * vert0->texcoord[u][0];
+            dtex[u][0] = invw1 * vert1->texcoord[u][0] - tex[u][0];
+	    tex[u][1]  = invw0 * vert0->texcoord[u][1];
+	    dtex[u][1] = invw1 * vert1->texcoord[u][1] - tex[u][1];
+	    tex[u][2]  = invw0 * vert0->texcoord[u][2];
+	    dtex[u][2] = invw1 * vert1->texcoord[u][2] - tex[u][2];
+	    tex[u][3]  = invw0 * vert0->texcoord[u][3];
+	    dtex[u][3] = invw1 * vert1->texcoord[u][3] - tex[u][3];
+	 }
+      }
+   }
+#endif
+
+   /* Cull primitives with malformed coordinates.
+    */
+   {
+      float tmp = vert0->win[0] + vert0->win[1] + vert1->win[0] + vert1->win[1];
+      if (IS_INF_OR_NAN(tmp))
+	 return;
+   }
+
+/*
+ * Despite being clipped to the view volume, the line's window coordinates
+ * may just lie outside the window bounds.  That is, if the legal window
+ * coordinates are [0,W-1][0,H-1], it's possible for x==W and/or y==H.
+ * This quick and dirty code nudges the endpoints inside the window if
+ * necessary.
+ */
+#ifdef CLIP_HACK
+   {
+      GLint w = ctx->DrawBuffer->Width;
+      GLint h = ctx->DrawBuffer->Height;
+      if ((x0==w) | (x1==w)) {
+         if ((x0==w) & (x1==w))
+           return;
+         x0 -= x0==w;
+         x1 -= x1==w;
+      }
+      if ((y0==h) | (y1==h)) {
+         if ((y0==h) & (y1==h))
+           return;
+         y0 -= y0==h;
+         y1 -= y1==h;
+      }
+   }
+#endif
+   dx = x1 - x0;
+   dy = y1 - y0;
+   if (dx==0 && dy==0) {
+      return;
+   }
+
+   /*
+    * Setup
+    */
+#ifdef SETUP_CODE
+   SETUP_CODE
+#endif
+
+#ifdef INTERP_Z
+#  ifdef DEPTH_TYPE
+     zPtr = (DEPTH_TYPE *) _mesa_zbuffer_address(ctx, x0, y0);
+#  endif
+   if (depthBits <= 16) {
+      z0 = FloatToFixed(vert0->win[2]) + FIXED_HALF;
+      z1 = FloatToFixed(vert1->win[2]) + FIXED_HALF;
+   }
+   else {
+      z0 = (int) vert0->win[2];
+      z1 = (int) vert1->win[2];
+   }
+#endif
+#ifdef PIXEL_ADDRESS
+   pixelPtr = (PIXEL_TYPE *) PIXEL_ADDRESS(x0,y0);
+#endif
+
+   if (dx<0) {
+      dx = -dx;   /* make positive */
+#ifdef INTERP_XY
+      xstep = -1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+      zPtrXstep = -((GLint)sizeof(DEPTH_TYPE));
+#endif
+#ifdef PIXEL_ADDRESS
+      pixelXstep = -((GLint)sizeof(PIXEL_TYPE));
+#endif
+   }
+   else {
+#ifdef INTERP_XY
+      xstep = 1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+      zPtrXstep = ((GLint)sizeof(DEPTH_TYPE));
+#endif
+#ifdef PIXEL_ADDRESS
+      pixelXstep = ((GLint)sizeof(PIXEL_TYPE));
+#endif
+   }
+
+   if (dy<0) {
+      dy = -dy;   /* make positive */
+#ifdef INTERP_XY
+      ystep = -1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+      zPtrYstep = -((GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE)));
+#endif
+#ifdef PIXEL_ADDRESS
+      pixelYstep = BYTES_PER_ROW;
+#endif
+   }
+   else {
+#ifdef INTERP_XY
+      ystep = 1;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+      zPtrYstep = (GLint) (ctx->DrawBuffer->Width * sizeof(DEPTH_TYPE));
+#endif
+#ifdef PIXEL_ADDRESS
+      pixelYstep = -(BYTES_PER_ROW);
+#endif
+   }
+
+   /*
+    * Draw
+    */
+
+   if (dx>dy) {
+      /*** X-major line ***/
+      GLint i;
+      GLint errorInc = dy+dy;
+      GLint error = errorInc-dx;
+      GLint errorDec = error-dx;
+#ifdef INTERP_Z
+      dz = (z1-z0) / dx;
+#endif
+#ifdef INTERP_FOG
+      dfog /= dx;
+#endif
+#ifdef INTERP_RGB
+      dr /= dx;   /* convert from whole line delta to per-pixel delta */
+      dg /= dx;
+      db /= dx;
+#endif
+#ifdef INTERP_SPEC
+      dsr /= dx;   /* convert from whole line delta to per-pixel delta */
+      dsg /= dx;
+      dsb /= dx;
+#endif
+#ifdef INTERP_ALPHA
+      da /= dx;
+#endif
+#ifdef INTERP_INDEX
+      di /= dx;
+#endif
+#ifdef INTERP_TEX
+      {
+         const GLfloat invDx = 1.0F / (GLfloat) dx;
+         dtex[0] *= invDx;
+         dtex[1] *= invDx;
+         dtex[2] *= invDx;
+         dtex[3] *= invDx;
+      }
+#endif
+#ifdef INTERP_MULTITEX
+      {
+         const GLfloat invDx = 1.0F / (GLfloat) dx;
+         GLuint u;
+         for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+            if (ctx->Texture.Unit[u]._ReallyEnabled) {
+               dtex[u][0] *= invDx;
+               dtex[u][1] *= invDx;
+               dtex[u][2] *= invDx;
+               dtex[u][3] *= invDx;
+            }
+         }
+      }
+#endif
+
+      for (i=0;i<dx;i++) {
+#ifdef STIPPLE
+         GLushort m;
+         m = 1 << ((swrast->StippleCounter/ctx->Line.StippleFactor) & 0xf);
+         if (ctx->Line.StipplePattern & m) {
+#endif
+#ifdef INTERP_Z
+            GLdepth Z = FixedToDepth(z0);
+#endif
+#ifdef INTERP_INDEX
+            GLint I = i0 >> 8;
+#endif
+#ifdef INTERP_TEX
+            {
+               const GLfloat invQ = tex[3] ? (1.0F / tex[3]) : 1.0F;
+               fragTexcoord[0] = tex[0] * invQ;
+               fragTexcoord[1] = tex[1] * invQ;
+               fragTexcoord[2] = tex[2] * invQ;
+               fragTexcoord[3] = tex[3];
+            }
+#endif
+#ifdef INTERP_MULTITEX
+            {
+               GLuint u;
+               for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+                  if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                     const GLfloat invQ = 1.0F / tex[u][3];
+                     fragTexcoord[u][0] = tex[u][0] * invQ;
+                     fragTexcoord[u][1] = tex[u][1] * invQ;
+                     fragTexcoord[u][2] = tex[u][2] * invQ;
+                     fragTexcoord[u][3] = tex[u][3];
+                  }
+               }
+            }
+#endif
+#ifdef WIDE
+            {
+               GLint yy;
+               GLint ymin = y0 + min;
+               GLint ymax = y0 + max;
+               for (yy=ymin;yy<=ymax;yy++) {
+                  PLOT( x0, yy );
+               }
+            }
+#else
+#  ifdef XMAJOR_PLOT
+            XMAJOR_PLOT( x0, y0 );
+#  else
+            PLOT( x0, y0 );
+#  endif
+#endif /*WIDE*/
+#ifdef STIPPLE
+        }
+	swrast->StippleCounter++;
+#endif
+#ifdef INTERP_XY
+         x0 += xstep;
+#endif
+#ifdef INTERP_Z
+#  ifdef DEPTH_TYPE
+         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
+#  endif
+         z0 += dz;
+#endif
+#ifdef INTERP_FOG
+	 fog0 += dfog;
+#endif
+#ifdef INTERP_RGB
+         r0 += dr;
+         g0 += dg;
+         b0 += db;
+#endif
+#ifdef INTERP_SPEC
+         sr0 += dsr;
+         sg0 += dsg;
+         sb0 += dsb;
+#endif
+#ifdef INTERP_ALPHA
+         a0 += da;
+#endif
+#ifdef INTERP_INDEX
+         i0 += di;
+#endif
+#ifdef INTERP_TEX
+         tex[0] += dtex[0];
+         tex[1] += dtex[1];
+         tex[2] += dtex[2];
+         tex[3] += dtex[3];
+#endif
+#ifdef INTERP_MULTITEX
+         {
+            GLuint u;
+            for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+               if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                  tex[u][0] += dtex[u][0];
+                  tex[u][1] += dtex[u][1];
+                  tex[u][2] += dtex[u][2];
+                  tex[u][3] += dtex[u][3];
+               }
+            }
+         }
+#endif
+
+#ifdef PIXEL_ADDRESS
+         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
+#endif
+         if (error<0) {
+            error += errorInc;
+         }
+         else {
+            error += errorDec;
+#ifdef INTERP_XY
+            y0 += ystep;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
+#endif
+#ifdef PIXEL_ADDRESS
+            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
+#endif
+         }
+      }
+   }
+   else {
+      /*** Y-major line ***/
+      GLint i;
+      GLint errorInc = dx+dx;
+      GLint error = errorInc-dy;
+      GLint errorDec = error-dy;
+#ifdef INTERP_Z
+      dz = (z1-z0) / dy;
+#endif
+#ifdef INTERP_FOG
+      dfog /= dy;
+#endif
+#ifdef INTERP_RGB
+      dr /= dy;   /* convert from whole line delta to per-pixel delta */
+      dg /= dy;
+      db /= dy;
+#endif
+#ifdef INTERP_SPEC
+      dsr /= dy;   /* convert from whole line delta to per-pixel delta */
+      dsg /= dy;
+      dsb /= dy;
+#endif
+#ifdef INTERP_ALPHA
+      da /= dy;
+#endif
+#ifdef INTERP_INDEX
+      di /= dy;
+#endif
+#ifdef INTERP_TEX
+      {
+         const GLfloat invDy = 1.0F / (GLfloat) dy;
+         dtex[0] *= invDy;
+         dtex[1] *= invDy;
+         dtex[2] *= invDy;
+         dtex[3] *= invDy;
+      }
+#endif
+#ifdef INTERP_MULTITEX
+      {
+         const GLfloat invDy = 1.0F / (GLfloat) dy;
+         GLuint u;
+         for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+            if (ctx->Texture.Unit[u]._ReallyEnabled) {
+               dtex[u][0] *= invDy;
+               dtex[u][1] *= invDy;
+               dtex[u][2] *= invDy;
+               dtex[u][3] *= invDy;
+            }
+         }
+      }
+#endif
+
+      for (i=0;i<dy;i++) {
+#ifdef STIPPLE
+         GLushort m;
+         m = 1 << ((swrast->StippleCounter/ctx->Line.StippleFactor) & 0xf);
+         if (ctx->Line.StipplePattern & m) {
+#endif
+#ifdef INTERP_Z
+            GLdepth Z = FixedToDepth(z0);
+#endif
+#ifdef INTERP_INDEX
+            GLint I = i0 >> 8;
+#endif
+#ifdef INTERP_TEX
+            {
+               const GLfloat invQ = tex[3] ? (1.0F / tex[3]) : 1.0F;
+               fragTexcoord[0] = tex[0] * invQ;
+               fragTexcoord[1] = tex[1] * invQ;
+               fragTexcoord[2] = tex[2] * invQ;
+               fragTexcoord[3] = tex[3];
+            }
+#endif
+#ifdef INTERP_MULTITEX
+            {
+               GLuint u;
+               for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+                  if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                     const GLfloat invQ = 1.0F / tex[u][3];
+                     fragTexcoord[u][0] = tex[u][0] * invQ;
+                     fragTexcoord[u][1] = tex[u][1] * invQ;
+                     fragTexcoord[u][2] = tex[u][2] * invQ;
+                     fragTexcoord[u][3] = tex[u][3];
+                  }
+               }
+            }
+#endif
+#ifdef WIDE
+            {
+               GLint xx;
+               GLint xmin = x0 + min;
+               GLint xmax = x0 + max;
+               for (xx=xmin;xx<=xmax;xx++) {
+                  PLOT( xx, y0 );
+               }
+            }
+#else
+#  ifdef YMAJOR_PLOT
+            YMAJOR_PLOT( x0, y0 );
+#  else
+            PLOT( x0, y0 );
+#  endif
+#endif /*WIDE*/
+#ifdef STIPPLE
+        }
+	swrast->StippleCounter++;
+#endif
+#ifdef INTERP_XY
+         y0 += ystep;
+#endif
+#ifdef INTERP_Z
+#  ifdef DEPTH_TYPE
+         zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrYstep);
+#  endif
+         z0 += dz;
+#endif
+#ifdef INTERP_FOG
+	 fog0 += dfog;
+#endif
+#ifdef INTERP_RGB
+         r0 += dr;
+         g0 += dg;
+         b0 += db;
+#endif
+#ifdef INTERP_SPEC
+         sr0 += dsr;
+         sg0 += dsg;
+         sb0 += dsb;
+#endif
+#ifdef INTERP_ALPHA
+         a0 += da;
+#endif
+#ifdef INTERP_INDEX
+         i0 += di;
+#endif
+#ifdef INTERP_TEX
+         tex[0] += dtex[0];
+         tex[1] += dtex[1];
+         tex[2] += dtex[2];
+         tex[3] += dtex[3];
+#endif
+#ifdef INTERP_MULTITEX
+         {
+            GLuint u;
+            for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+               if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                  tex[u][0] += dtex[u][0];
+                  tex[u][1] += dtex[u][1];
+                  tex[u][2] += dtex[u][2];
+                  tex[u][3] += dtex[u][3];
+               }
+            }
+         }
+#endif
+#ifdef PIXEL_ADDRESS
+         pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelYstep);
+#endif
+         if (error<0) {
+            error += errorInc;
+         }
+         else {
+            error += errorDec;
+#ifdef INTERP_XY
+            x0 += xstep;
+#endif
+#if defined(INTERP_Z) && defined(DEPTH_TYPE)
+            zPtr = (DEPTH_TYPE *) ((GLubyte*) zPtr + zPtrXstep);
+#endif
+#ifdef PIXEL_ADDRESS
+            pixelPtr = (PIXEL_TYPE*) ((GLubyte*) pixelPtr + pixelXstep);
+#endif
+         }
+      }
+   }
+
+}
+
+
+#undef INTERP_XY
+#undef INTERP_Z
+#undef INTERP_FOG
+#undef INTERP_RGB
+#undef INTERP_SPEC
+#undef INTERP_ALPHA
+#undef INTERP_TEX
+#undef INTERP_MULTITEX
+#undef INTERP_INDEX
+#undef PIXEL_ADDRESS
+#undef PIXEL_TYPE
+#undef DEPTH_TYPE
+#undef BYTES_PER_ROW
+#undef SETUP_CODE
+#undef PLOT
+#undef XMAJOR_PLOT
+#undef YMAJOR_PLOT
+#undef CLIP_HACK
+#undef STIPPLE
+#undef WIDE
+#undef FixedToDepth
Index: xc/extras/Mesa/src/swrast/s_logic.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_logic.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_logic.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,510 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+
+#include "s_alphabuf.h"
+#include "s_context.h"
+#include "s_logic.h"
+#include "s_pb.h"
+#include "s_span.h"
+
+
+
+/*
+ * Apply logic op to array of CI pixels.
+ */
+static void index_logicop( GLcontext *ctx, GLuint n,
+                           GLuint index[], const GLuint dest[],
+                           const GLubyte mask[] )
+{
+   GLuint i;
+   switch (ctx->Color.LogicOp) {
+      case GL_CLEAR:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_SET:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~0;
+	    }
+	 }
+	 break;
+      case GL_COPY:
+	 /* do nothing */
+	 break;
+      case GL_COPY_INVERTED:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~index[i];
+	    }
+	 }
+	 break;
+      case GL_NOOP:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = dest[i];
+	    }
+	 }
+	 break;
+      case GL_INVERT:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~dest[i];
+	    }
+	 }
+	 break;
+      case GL_AND:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] &= dest[i];
+	    }
+	 }
+	 break;
+      case GL_NAND:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~(index[i] & dest[i]);
+	    }
+	 }
+	 break;
+      case GL_OR:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] |= dest[i];
+	    }
+	 }
+	 break;
+      case GL_NOR:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~(index[i] | dest[i]);
+	    }
+	 }
+	 break;
+      case GL_XOR:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] ^= dest[i];
+	    }
+	 }
+	 break;
+      case GL_EQUIV:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~(index[i] ^ dest[i]);
+	    }
+	 }
+	 break;
+      case GL_AND_REVERSE:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = index[i] & ~dest[i];
+	    }
+	 }
+	 break;
+      case GL_AND_INVERTED:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~index[i] & dest[i];
+	    }
+	 }
+	 break;
+      case GL_OR_REVERSE:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = index[i] | ~dest[i];
+	    }
+	 }
+	 break;
+      case GL_OR_INVERTED:
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       index[i] = ~index[i] | dest[i];
+	    }
+	 }
+	 break;
+      default:
+	 _mesa_problem(ctx, "bad mode in index_logic()");
+   }
+}
+
+
+
+/*
+ * Apply the current logic operator to a span of CI pixels.  This is only
+ * used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_ci_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                       GLuint index[], const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint dest[MAX_WIDTH];
+   /* Read dest values from frame buffer */
+   (*swrast->Driver.ReadCI32Span)( ctx, n, x, y, dest );
+   index_logicop( ctx, n, index, dest, mask );
+}
+
+
+
+/*
+ * Apply the current logic operator to an array of CI pixels.  This is only
+ * used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_ci_pixels( GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         GLuint index[], const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint dest[PB_SIZE];
+   /* Read dest values from frame buffer */
+   (*swrast->Driver.ReadCI32Pixels)( ctx, n, x, y, dest, mask );
+   index_logicop( ctx, n, index, dest, mask );
+}
+
+
+
+/*
+ * Apply logic operator to rgba pixels.
+ * Input:  ctx - the context
+ *         n - number of pixels
+ *         mask - pixel mask array
+ * In/Out:  src - incoming pixels which will be modified
+ * Input:  dest - frame buffer values
+ *
+ * Note:  Since the R, G, B, and A channels are all treated the same we
+ * process them as 4-byte GLuints instead of four GLubytes.
+ */
+static void rgba_logicop_ui( const GLcontext *ctx, GLuint n,
+                             const GLubyte mask[],
+                             GLuint src[], const GLuint dest[] )
+{
+   GLuint i;
+   switch (ctx->Color.LogicOp) {
+      case GL_CLEAR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = 0;
+            }
+         }
+         break;
+      case GL_SET:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~0;
+            }
+         }
+         break;
+      case GL_COPY:
+         /* do nothing */
+         break;
+      case GL_COPY_INVERTED:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~src[i];
+            }
+         }
+         break;
+      case GL_NOOP:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = dest[i];
+            }
+         }
+         break;
+      case GL_INVERT:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~dest[i];
+            }
+         }
+         break;
+      case GL_AND:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] &= dest[i];
+            }
+         }
+         break;
+      case GL_NAND:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~(src[i] & dest[i]);
+            }
+         }
+         break;
+      case GL_OR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i]|= dest[i];
+            }
+         }
+         break;
+      case GL_NOR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~(src[i] | dest[i]);
+            }
+         }
+         break;
+      case GL_XOR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] ^= dest[i];
+            }
+         }
+         break;
+      case GL_EQUIV:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~(src[i] ^ dest[i]);
+            }
+         }
+         break;
+      case GL_AND_REVERSE:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = src[i] & ~dest[i];
+            }
+         }
+         break;
+      case GL_AND_INVERTED:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~src[i] & dest[i];
+            }
+         }
+         break;
+      case GL_OR_REVERSE:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = src[i] | ~dest[i];
+            }
+         }
+         break;
+      case GL_OR_INVERTED:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~src[i] | dest[i];
+            }
+         }
+         break;
+      default:
+         /* should never happen */
+         _mesa_problem(ctx, "Bad function in rgba_logicop");
+   }
+}
+
+
+/*
+ * As above, but operate on GLchan values
+ * Note: need to pass n = numPixels * 4.
+ */
+static void rgba_logicop_chan( const GLcontext *ctx, GLuint n,
+                               const GLubyte mask[],
+                               GLchan srcPtr[], const GLchan destPtr[] )
+{
+#if CHAN_TYPE == GL_FLOAT
+   GLuint *src = (GLuint *) srcPtr;
+   const GLuint *dest = (const GLuint *) destPtr;
+   GLuint i;
+   ASSERT(sizeof(GLfloat) == sizeof(GLuint));
+#else
+   GLchan *src = srcPtr;
+   const GLchan *dest = destPtr;
+   GLuint i;
+#endif
+
+   switch (ctx->Color.LogicOp) {
+      case GL_CLEAR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = 0;
+            }
+         }
+         break;
+      case GL_SET:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~0;
+            }
+         }
+         break;
+      case GL_COPY:
+         /* do nothing */
+         break;
+      case GL_COPY_INVERTED:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~src[i];
+            }
+         }
+         break;
+      case GL_NOOP:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = dest[i];
+            }
+         }
+         break;
+      case GL_INVERT:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~dest[i];
+            }
+         }
+         break;
+      case GL_AND:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] &= dest[i];
+            }
+         }
+         break;
+      case GL_NAND:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~(src[i] & dest[i]);
+            }
+         }
+         break;
+      case GL_OR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i]|= dest[i];
+            }
+         }
+         break;
+      case GL_NOR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~(src[i] | dest[i]);
+            }
+         }
+         break;
+      case GL_XOR:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] ^= dest[i];
+            }
+         }
+         break;
+      case GL_EQUIV:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~(src[i] ^ dest[i]);
+            }
+         }
+         break;
+      case GL_AND_REVERSE:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = src[i] & ~dest[i];
+            }
+         }
+         break;
+      case GL_AND_INVERTED:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~src[i] & dest[i];
+            }
+         }
+         break;
+      case GL_OR_REVERSE:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = src[i] | ~dest[i];
+            }
+         }
+         break;
+      case GL_OR_INVERTED:
+         for (i=0;i<n;i++) {
+            if (mask[i]) {
+               src[i] = ~src[i] | dest[i];
+            }
+         }
+         break;
+      default:
+         /* should never happen */
+         _mesa_problem(ctx, "Bad function in rgba_logicop");
+   }
+}
+
+
+
+/*
+ * Apply the current logic operator to a span of RGBA pixels.
+ * This is only used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_rgba_span( GLcontext *ctx,
+                         GLuint n, GLint x, GLint y,
+                         GLchan rgba[][4], const GLubyte mask[] )
+{
+   GLchan dest[MAX_WIDTH][4];
+   _mesa_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
+   if (sizeof(GLchan) * 4 == sizeof(GLuint)) {
+      rgba_logicop_ui(ctx, n, mask, (GLuint *) rgba, (const GLuint *) dest);
+   }
+   else {
+      rgba_logicop_chan(ctx, 4 * n, mask,
+                        (GLchan *) rgba, (const GLchan *) dest);
+   }
+}
+
+
+
+/*
+ * Apply the current logic operator to an array of RGBA pixels.
+ * This is only used if the device driver can't do logic ops.
+ */
+void
+_mesa_logicop_rgba_pixels( GLcontext *ctx,
+                           GLuint n, const GLint x[], const GLint y[],
+                           GLchan rgba[][4], const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLchan dest[PB_SIZE][4];
+   (*swrast->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+   if (SWRAST_CONTEXT(ctx)->_RasterMask & ALPHABUF_BIT) {
+      _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
+   }
+   if (sizeof(GLchan) * 4 == sizeof(GLuint)) {
+      rgba_logicop_ui(ctx, n, mask, (GLuint *) rgba, (const GLuint *) dest);
+   }
+   else {
+      rgba_logicop_chan(ctx, 4 * n, mask,
+                        (GLchan *) rgba, (const GLchan *) dest);
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_logic.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_logic.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_logic.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,58 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_LOGIC_H
+#define S_LOGIC_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_logicop_ci_span( GLcontext *ctx,
+                       GLuint n, GLint x, GLint y, GLuint index[],
+                       const GLubyte mask[] );
+
+
+extern void
+_mesa_logicop_ci_pixels( GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         GLuint index[], const GLubyte mask[] );
+
+
+extern void
+_mesa_logicop_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                         GLchan rgba[][4], const GLubyte mask[] );
+
+
+extern void
+_mesa_logicop_rgba_pixels( GLcontext *ctx,
+                           GLuint n, const GLint x[], const GLint y[],
+                           GLchan rgba[][4], const GLubyte mask[] );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_masking.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_masking.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_masking.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,181 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Implement the effect of glColorMask and glIndexMask in software.
+ */
+
+
+#include "glheader.h"
+#include "enums.h"
+#include "macros.h"
+
+#include "s_alphabuf.h"
+#include "s_context.h"
+#include "s_masking.h"
+#include "s_pb.h"
+#include "s_span.h"
+
+
+/*
+ * Apply glColorMask to a span of RGBA pixels.
+ */
+void
+_mesa_mask_rgba_span( GLcontext *ctx,
+                      GLuint n, GLint x, GLint y, GLchan rgba[][4] )
+{
+   GLchan dest[MAX_WIDTH][4];
+   GLuint i;
+
+#if CHAN_BITS == 8
+
+   GLuint srcMask = *((GLuint*)ctx->Color.ColorMask);
+   GLuint dstMask = ~srcMask;
+   GLuint *rgba32 = (GLuint *) rgba;
+   GLuint *dest32 = (GLuint *) dest;
+
+   _mesa_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
+   for (i = 0; i < n; i++) {
+      rgba32[i] = (rgba32[i] & srcMask) | (dest32[i] & dstMask);
+   }
+
+#else
+
+   const GLint rMask = ctx->Color.ColorMask[RCOMP];
+   const GLint gMask = ctx->Color.ColorMask[GCOMP];
+   const GLint bMask = ctx->Color.ColorMask[BCOMP];
+   const GLint aMask = ctx->Color.ColorMask[ACOMP];
+
+   _mesa_read_rgba_span( ctx, ctx->DrawBuffer, n, x, y, dest );
+   for (i = 0; i < n; i++) {
+      if (!rMask)  rgba[i][RCOMP] = dest[i][RCOMP];
+      if (!gMask)  rgba[i][GCOMP] = dest[i][GCOMP];
+      if (!bMask)  rgba[i][BCOMP] = dest[i][BCOMP];
+      if (!aMask)  rgba[i][ACOMP] = dest[i][ACOMP];
+   }
+
+#endif
+}
+
+
+
+/*
+ * Apply glColorMask to an array of RGBA pixels.
+ */
+void
+_mesa_mask_rgba_pixels( GLcontext *ctx,
+                        GLuint n, const GLint x[], const GLint y[],
+                        GLchan rgba[][4], const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLchan dest[PB_SIZE][4];
+   GLuint i;
+
+#if CHAN_BITS == 8
+
+   GLuint srcMask = *((GLuint*)ctx->Color.ColorMask);
+   GLuint dstMask = ~srcMask;
+   GLuint *rgba32 = (GLuint *) rgba;
+   GLuint *dest32 = (GLuint *) dest;
+
+   (*swrast->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+   if (SWRAST_CONTEXT(ctx)->_RasterMask & ALPHABUF_BIT) {
+      _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
+   }
+
+   for (i=0; i<n; i++) {
+      rgba32[i] = (rgba32[i] & srcMask) | (dest32[i] & dstMask);
+   }
+
+#else
+
+   const GLint rMask = ctx->Color.ColorMask[RCOMP];
+   const GLint gMask = ctx->Color.ColorMask[GCOMP];
+   const GLint bMask = ctx->Color.ColorMask[BCOMP];
+   const GLint aMask = ctx->Color.ColorMask[ACOMP];
+
+   (*swrast->Driver.ReadRGBAPixels)( ctx, n, x, y, dest, mask );
+   if (SWRAST_CONTEXT(ctx)->_RasterMask & ALPHABUF_BIT) {
+      _mesa_read_alpha_pixels( ctx, n, x, y, dest, mask );
+   }
+
+   for (i = 0; i < n; i++) {
+      if (!rMask)  rgba[i][RCOMP] = dest[i][RCOMP];
+      if (!gMask)  rgba[i][GCOMP] = dest[i][GCOMP];
+      if (!bMask)  rgba[i][BCOMP] = dest[i][BCOMP];
+      if (!aMask)  rgba[i][ACOMP] = dest[i][ACOMP];
+   }
+
+#endif
+}
+
+
+
+/*
+ * Apply glIndexMask to a span of CI pixels.
+ */
+void
+_mesa_mask_index_span( GLcontext *ctx,
+                       GLuint n, GLint x, GLint y, GLuint index[] )
+{
+   GLuint i;
+   GLuint fbindexes[MAX_WIDTH];
+   GLuint msrc, mdest;
+
+   _mesa_read_index_span( ctx, ctx->DrawBuffer, n, x, y, fbindexes );
+
+   msrc = ctx->Color.IndexMask;
+   mdest = ~msrc;
+
+   for (i=0;i<n;i++) {
+      index[i] = (index[i] & msrc) | (fbindexes[i] & mdest);
+   }
+}
+
+
+
+/*
+ * Apply glIndexMask to an array of CI pixels.
+ */
+void
+_mesa_mask_index_pixels( GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         GLuint index[], const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint i;
+   GLuint fbindexes[PB_SIZE];
+   GLuint msrc, mdest;
+
+   (*swrast->Driver.ReadCI32Pixels)( ctx, n, x, y, fbindexes, mask );
+
+   msrc = ctx->Color.IndexMask;
+   mdest = ~msrc;
+
+   for (i=0;i<n;i++) {
+      index[i] = (index[i] & msrc) | (fbindexes[i] & mdest);
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_masking.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_masking.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_masking.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,74 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_MASKING_H
+#define S_MASKING_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+/*
+ * Implement glColorMask for a span of RGBA pixels.
+ */
+extern void
+_mesa_mask_rgba_span( GLcontext *ctx,
+                      GLuint n, GLint x, GLint y,
+                      GLchan rgba[][4] );
+
+
+
+/*
+ * Implement glColorMask for an array of RGBA pixels.
+ */
+extern void
+_mesa_mask_rgba_pixels( GLcontext *ctx,
+                        GLuint n, const GLint x[], const GLint y[],
+                        GLchan rgba[][4], const GLubyte mask[] );
+
+
+
+/*
+ * Implement glIndexMask for a span of CI pixels.
+ */
+extern void
+_mesa_mask_index_span( GLcontext *ctx,
+                       GLuint n, GLint x, GLint y, GLuint index[] );
+
+
+
+/*
+ * Implement glIndexMask for an array of CI pixels.
+ */
+extern void
+_mesa_mask_index_pixels( GLcontext *ctx,
+                         GLuint n, const GLint x[], const GLint y[],
+                         GLuint index[], const GLubyte mask[] );
+
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_pb.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_pb.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_pb.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,516 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+
+/*
+ * Pixel buffer:
+ *
+ * As fragments are produced (by point, line, and bitmap drawing) they
+ * are accumlated in a buffer.  When the buffer is full or has to be
+ * flushed (glEnd), we apply all enabled rasterization functions to the
+ * pixels and write the results to the display buffer.  The goal is to
+ * maximize the number of pixels processed inside loops and to minimize
+ * the number of function calls.
+ */
+
+
+#include "glheader.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_alpha.h"
+#include "s_alphabuf.h"
+#include "s_blend.h"
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_fog.h"
+#include "s_logic.h"
+#include "s_masking.h"
+#include "s_pb.h"
+#include "s_scissor.h"
+#include "s_stencil.h"
+#include "s_texture.h"
+
+
+
+/*
+ * Allocate and initialize a new pixel buffer structure.
+ */
+struct pixel_buffer *_mesa_alloc_pb(void)
+{
+   struct pixel_buffer *pb;
+   pb = CALLOC_STRUCT(pixel_buffer);
+   if (pb) {
+      int i, j;
+      /* set non-zero fields */
+      pb->mono = GL_TRUE;
+
+      /* Set all lambda values to 0.0 since we don't do mipmapping for
+       * points or lines and want to use the level 0 texture image.
+       */
+      for (j=0;j<MAX_TEXTURE_UNITS;j++) {
+         for (i=0; i<PB_SIZE; i++) {
+            pb->lambda[j][i] = 0.0;
+         }
+      }
+   }
+   return pb;
+}
+
+
+
+/*
+ * Draw to more than one color buffer (or none).
+ */
+static void multi_write_index_pixels( GLcontext *ctx, GLuint n,
+                                      const GLint x[], const GLint y[],
+                                      const GLuint indexes[],
+                                      const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint bufferBit;
+
+   if (ctx->Color.DrawBuffer == GL_NONE)
+      return;
+
+   /* loop over four possible dest color buffers */
+   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+      if (bufferBit & ctx->Color.DrawDestMask) {
+         GLuint indexTmp[PB_SIZE];
+         ASSERT(n < PB_SIZE);
+
+         if (bufferBit == FRONT_LEFT_BIT)
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+         else if (bufferBit == FRONT_RIGHT_BIT)
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+         else if (bufferBit == BACK_LEFT_BIT)
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+         else
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+
+         /* make copy of incoming indexes */
+         MEMCPY( indexTmp, indexes, n * sizeof(GLuint) );
+         if (ctx->Color.IndexLogicOpEnabled) {
+            _mesa_logicop_ci_pixels( ctx, n, x, y, indexTmp, mask );
+         }
+         if (ctx->Color.IndexMask != 0xffffffff) {
+            _mesa_mask_index_pixels( ctx, n, x, y, indexTmp, mask );
+         }
+         (*swrast->Driver.WriteCI32Pixels)( ctx, n, x, y, indexTmp, mask );
+      }
+   }
+
+   /* restore default dest buffer */
+   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer);
+}
+
+
+
+/*
+ * Draw to more than one RGBA color buffer (or none).
+ */
+static void multi_write_rgba_pixels( GLcontext *ctx, GLuint n,
+                                     const GLint x[], const GLint y[],
+                                     CONST GLchan rgba[][4],
+                                     const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint bufferBit;
+
+   if (ctx->Color.DrawBuffer == GL_NONE)
+      return;
+
+   /* loop over four possible dest color buffers */
+   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+      if (bufferBit & ctx->Color.DrawDestMask) {
+         GLchan rgbaTmp[PB_SIZE][4];
+         ASSERT(n < PB_SIZE);
+
+         if (bufferBit == FRONT_LEFT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontLeftAlpha;
+         }
+         else if (bufferBit == FRONT_RIGHT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontRightAlpha;
+         }
+         else if (bufferBit == BACK_LEFT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackLeftAlpha;
+         }
+         else {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackRightAlpha;
+         }
+
+         /* make copy of incoming colors */
+         MEMCPY( rgbaTmp, rgba, 4 * n * sizeof(GLchan) );
+
+         if (ctx->Color.ColorLogicOpEnabled) {
+            _mesa_logicop_rgba_pixels( ctx, n, x, y, rgbaTmp, mask );
+         }
+         else if (ctx->Color.BlendEnabled) {
+            _mesa_blend_pixels( ctx, n, x, y, rgbaTmp, mask );
+         }
+         if (*((GLuint *) &ctx->Color.ColorMask) != 0xffffffff) {
+            _mesa_mask_rgba_pixels( ctx, n, x, y, rgbaTmp, mask );
+         }
+
+         (*swrast->Driver.WriteRGBAPixels)( ctx, n, x, y,
+					 (const GLchan (*)[4])rgbaTmp, mask );
+         if (SWRAST_CONTEXT(ctx)->_RasterMask & ALPHABUF_BIT) {
+            _mesa_write_alpha_pixels( ctx, n, x, y,
+                                      (const GLchan (*)[4])rgbaTmp, mask );
+         }
+      }
+   }
+
+   /* restore default dest buffer */
+   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer);
+}
+
+
+
+/*
+ * Add specular color to primary color.  This is used only when
+ * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
+ */
+static void add_colors( GLuint n, GLchan rgba[][4], CONST GLchan spec[][3] )
+{
+   GLuint i;
+   for (i=0; i<n; i++) {
+      GLint r = rgba[i][RCOMP] + spec[i][RCOMP];
+      GLint g = rgba[i][GCOMP] + spec[i][GCOMP];
+      GLint b = rgba[i][BCOMP] + spec[i][BCOMP];
+      rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+      rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+      rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+   }
+}
+
+
+
+/*
+ * When the pixel buffer is full, or needs to be flushed, call this
+ * function.  All the pixels in the pixel buffer will be subjected
+ * to texturing, scissoring, stippling, alpha testing, stenciling,
+ * depth testing, blending, and finally written to the frame buffer.
+ */
+void _mesa_flush_pb( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint RasterMask = swrast->_RasterMask;
+
+   /* Pixel colors may be changed if any of these raster ops enabled */
+   const GLuint modBits = FOG_BIT | TEXTURE_BIT | BLEND_BIT |
+                          MASKING_BIT | LOGIC_OP_BIT;
+   struct pixel_buffer *PB = swrast->PB;
+   GLubyte mask[PB_SIZE];
+
+   if (PB->count == 0)
+      goto CleanUp;
+
+   /* initialize mask array and clip pixels simultaneously */
+   {
+      const GLint xmin = ctx->DrawBuffer->_Xmin;
+      const GLint xmax = ctx->DrawBuffer->_Xmax;
+      const GLint ymin = ctx->DrawBuffer->_Ymin;
+      const GLint ymax = ctx->DrawBuffer->_Ymax;
+      const GLuint n = PB->count;
+      GLint *x = PB->x;
+      GLint *y = PB->y;
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         mask[i] = (x[i] >= xmin) & (x[i] < xmax) & (y[i] >= ymin) & (y[i] < ymax);
+      }
+   }
+
+   if (ctx->Visual.rgbMode) {
+      /*
+       * RGBA COLOR PIXELS
+       */
+
+      /* If each pixel can be of a different color... */
+      if ((RasterMask & modBits) || !PB->mono) {
+
+         if (PB->mono) {
+            /* copy mono color into rgba array */
+            GLuint i;
+            for (i = 0; i < PB->count; i++) {
+               COPY_CHAN4(PB->rgba[i], PB->currentColor);
+            }
+         }
+
+	 if (ctx->Texture._ReallyEnabled) {
+            GLchan primary_rgba[PB_SIZE][4];
+            GLuint texUnit;
+
+            /* must make a copy of primary colors since they may be modified */
+            MEMCPY(primary_rgba, PB->rgba, 4 * PB->count * sizeof(GLchan));
+
+            for (texUnit = 0; texUnit < ctx->Const.MaxTextureUnits; texUnit++){
+               _swrast_texture_fragments( ctx, texUnit, PB->count,
+                                          PB->s[texUnit], PB->t[texUnit],
+                                          PB->u[texUnit], PB->lambda[texUnit],
+                                          (CONST GLchan (*)[4]) primary_rgba,
+                                          PB->rgba );
+            }
+	 }
+
+         if ((ctx->Fog.ColorSumEnabled ||
+              (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR
+               && ctx->Light.Enabled)) && PB->haveSpec) {
+            /* add specular color to primary color */
+            add_colors( PB->count, PB->rgba, (const GLchan (*)[3]) PB->spec );
+         }
+
+	 if (ctx->Fog.Enabled) {
+	    if (swrast->_PreferPixelFog)
+	       _mesa_depth_fog_rgba_pixels( ctx, PB->count, PB->z, PB->rgba );
+	    else
+	       _mesa_fog_rgba_pixels( ctx, PB->count, PB->fog, PB->rgba );
+	 }
+
+         /* Antialias coverage application */
+         if (PB->haveCoverage) {
+            const GLuint n = PB->count;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               PB->rgba[i][ACOMP] = (GLchan) (PB->rgba[i][ACOMP] * PB->coverage[i]);
+            }
+         }
+
+         /* Scissoring already done above */
+
+	 if (ctx->Color.AlphaEnabled) {
+	    if (_mesa_alpha_test( ctx, PB->count,
+                                  (const GLchan (*)[4]) PB->rgba, mask )==0) {
+	       goto CleanUp;
+	    }
+	 }
+
+	 if (ctx->Stencil.Enabled) {
+	    /* first stencil test */
+	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
+                                       PB->x, PB->y, PB->z, mask) == 0) {
+	       goto CleanUp;
+	    }
+	 }
+	 else if (ctx->Depth.Test) {
+	    /* regular depth testing */
+	    _mesa_depth_test_pixels( ctx, PB->count, PB->x, PB->y, PB->z, mask );
+	 }
+
+
+         if (RasterMask & MULTI_DRAW_BIT) {
+            multi_write_rgba_pixels( ctx, PB->count, PB->x, PB->y,
+                                     (const GLchan (*)[4])PB->rgba, mask );
+         }
+         else {
+            /* normal case: write to exactly one buffer */
+            const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+
+            if (ctx->Color.ColorLogicOpEnabled) {
+               _mesa_logicop_rgba_pixels( ctx, PB->count, PB->x, PB->y,
+                                          PB->rgba, mask);
+            }
+            else if (ctx->Color.BlendEnabled) {
+               _mesa_blend_pixels( ctx, PB->count, PB->x, PB->y, PB->rgba, mask);
+            }
+            if (colorMask == 0x0) {
+               goto CleanUp;
+            }
+            else if (colorMask != 0xffffffff) {
+               _mesa_mask_rgba_pixels(ctx, PB->count, PB->x, PB->y, PB->rgba, mask);
+            }
+
+            (*swrast->Driver.WriteRGBAPixels)( ctx, PB->count, PB->x, PB->y,
+                                            (const GLchan (*)[4]) PB->rgba,
+					    mask );
+            if (RasterMask & ALPHABUF_BIT) {
+               _mesa_write_alpha_pixels( ctx, PB->count, PB->x, PB->y,
+				      (const GLchan (*)[4]) PB->rgba, mask );
+            }
+         }
+      }
+      else {
+	 /* Same color for all pixels */
+
+         /* Scissoring already done above */
+
+	 if (ctx->Color.AlphaEnabled) {
+	    if (_mesa_alpha_test( ctx, PB->count,
+                                  (const GLchan (*)[4]) PB->rgba, mask )==0) {
+	       goto CleanUp;
+	    }
+	 }
+
+	 if (ctx->Stencil.Enabled) {
+	    /* first stencil test */
+	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
+                                       PB->x, PB->y, PB->z, mask) == 0) {
+	       goto CleanUp;
+	    }
+	 }
+	 else if (ctx->Depth.Test) {
+	    /* regular depth testing */
+	    _mesa_depth_test_pixels( ctx, PB->count, PB->x, PB->y, PB->z, mask );
+	 }
+
+         if (ctx->Color.DrawBuffer == GL_NONE) {
+            goto CleanUp;
+         }
+
+         if (RasterMask & MULTI_DRAW_BIT) {
+            if (PB->mono) {
+               /* copy mono color into rgba array */
+               GLuint i;
+               for (i = 0; i < PB->count; i++) {
+                  COPY_CHAN4(PB->rgba[i], PB->currentColor);
+               }
+            }
+            multi_write_rgba_pixels( ctx, PB->count, PB->x, PB->y,
+                                     (const GLchan (*)[4]) PB->rgba, mask );
+         }
+         else {
+            /* normal case: write to exactly one buffer */
+            (*swrast->Driver.WriteMonoRGBAPixels)( ctx, PB->count, PB->x, PB->y,
+                                                PB->currentColor, mask );
+            if (RasterMask & ALPHABUF_BIT) {
+               _mesa_write_mono_alpha_pixels( ctx, PB->count, PB->x, PB->y,
+                                              PB->currentColor[ACOMP], mask );
+            }
+         }
+         /*** ALL DONE ***/
+      }
+   }
+   else {
+      /*
+       * COLOR INDEX PIXELS
+       */
+
+      /* If we may be writting pixels with different indexes... */
+      if ((RasterMask & modBits) || !PB->mono) {
+
+         if (PB->mono) {
+            GLuint i;
+            for (i = 0; i < PB->count; i++) {
+               PB->index[i] = PB->currentIndex;
+            }
+         }
+	 if (ctx->Fog.Enabled) {
+	    if (swrast->_PreferPixelFog)
+	       _mesa_depth_fog_ci_pixels( ctx, PB->count, PB->z, PB->index );
+	    else
+	       _mesa_fog_ci_pixels( ctx, PB->count, PB->fog, PB->index );
+	 }
+
+         /* Antialias coverage application */
+         if (PB->haveCoverage) {
+            const GLuint n = PB->count;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               GLint frac = (GLint) (15.0 * PB->coverage[i]);
+               PB->index[i] = (PB->index[i] & ~0xf) | frac;
+            }
+         }
+
+         /* Scissoring already done above */
+
+	 if (ctx->Stencil.Enabled) {
+	    /* first stencil test */
+	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
+                                       PB->x, PB->y, PB->z, mask) == 0) {
+	       goto CleanUp;
+	    }
+	 }
+	 else if (ctx->Depth.Test) {
+	    /* regular depth testing */
+	    _mesa_depth_test_pixels( ctx, PB->count, PB->x, PB->y, PB->z, mask );
+	 }
+         if (RasterMask & MULTI_DRAW_BIT) {
+            multi_write_index_pixels( ctx, PB->count, PB->x, PB->y, PB->index, mask );
+         }
+         else {
+            /* normal case: write to exactly one buffer */
+
+            if (ctx->Color.IndexLogicOpEnabled) {
+               _mesa_logicop_ci_pixels(ctx, PB->count, PB->x, PB->y,
+                                       PB->index, mask);
+            }
+            if (ctx->Color.IndexMask != 0xffffffff) {
+               _mesa_mask_index_pixels(ctx, PB->count, PB->x, PB->y,
+                                       PB->index, mask);
+            }
+            (*swrast->Driver.WriteCI32Pixels)( ctx, PB->count, PB->x, PB->y,
+                                            PB->index, mask );
+         }
+
+         /*** ALL DONE ***/
+      }
+      else {
+	 /* Same color index for all pixels */
+
+         /* Scissoring already done above */
+
+	 if (ctx->Stencil.Enabled) {
+	    /* first stencil test */
+	    if (_mesa_stencil_and_ztest_pixels(ctx, PB->count,
+                                       PB->x, PB->y, PB->z, mask) == 0) {
+	       goto CleanUp;
+	    }
+	 }
+	 else if (ctx->Depth.Test) {
+	    /* regular depth testing */
+	    _mesa_depth_test_pixels(ctx, PB->count, PB->x, PB->y, PB->z, mask);
+	 }
+
+         if (RasterMask & MULTI_DRAW_BIT) {
+            multi_write_index_pixels(ctx, PB->count, PB->x, PB->y,
+                                     PB->index, mask);
+         }
+         else {
+            /* normal case: write to exactly one buffer */
+            (*swrast->Driver.WriteMonoCIPixels)(ctx, PB->count, PB->x, PB->y,
+                                             PB->currentIndex, mask);
+         }
+      }
+   }
+
+CleanUp:
+   PB->count = 0;
+   PB->mono = GL_TRUE;
+   PB->haveSpec = GL_FALSE;
+   PB->haveCoverage = GL_FALSE;
+}
+
+
+void
+_swrast_flush( GLcontext *ctx )
+{
+   if (SWRAST_CONTEXT(ctx)->PB->count > 0)
+      _mesa_flush_pb(ctx);
+}
Index: xc/extras/Mesa/src/swrast/s_pb.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_pb.h:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_pb.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,243 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef PB_H
+#define PB_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+#include "colormac.h"
+
+
+/*
+ * Pixel buffer size, must be larger than MAX_WIDTH.
+ */
+#define PB_SIZE (3*MAX_WIDTH)
+
+
+struct pixel_buffer {
+   GLchan currentColor[4];     /* Current color, for subsequent pixels */
+   GLuint currentIndex;        /* Current index, for subsequent pixels */
+   GLuint count;               /* Number of pixels in buffer */
+   GLboolean mono;             /* Same color or index for all pixels? */
+   GLboolean haveSpec;         /* any specular colors? */
+   GLboolean haveCoverage;     /* apply AA coverage? */
+
+   GLint x[PB_SIZE];           /* X window coord in [0,MAX_WIDTH) */
+   GLint y[PB_SIZE];           /* Y window coord in [0,MAX_HEIGHT) */
+   GLdepth z[PB_SIZE];         /* Z window coord in [0,Visual.MaxDepth] */
+   GLfloat fog[PB_SIZE];       /* Fog window coord in [0,1] */
+   GLchan rgba[PB_SIZE][4];    /* Colors */
+   GLchan spec[PB_SIZE][3];    /* Separate specular colors */
+   GLuint index[PB_SIZE];      /* Color indexes */
+   GLfloat coverage[PB_SIZE];  /* Antialiasing coverage in [0,1] */
+   GLfloat s[MAX_TEXTURE_UNITS][PB_SIZE];	/* Texture S coordinates */
+   GLfloat t[MAX_TEXTURE_UNITS][PB_SIZE];	/* Texture T coordinates */
+   GLfloat u[MAX_TEXTURE_UNITS][PB_SIZE];	/* Texture R coordinates */
+   GLfloat lambda[MAX_TEXTURE_UNITS][PB_SIZE];  /* Texture lambda values */
+};
+
+
+
+/*
+ * Set the color used for all subsequent pixels in the buffer.
+ */
+#define PB_SET_COLOR( PB, R, G, B, A )		\
+do {						\
+   if ((PB)->count > 0)				\
+      (PB)->mono = GL_FALSE;			\
+   (PB)->currentColor[RCOMP] = (R);		\
+   (PB)->currentColor[GCOMP] = (G);		\
+   (PB)->currentColor[BCOMP] = (B);		\
+   (PB)->currentColor[ACOMP] = (A);		\
+} while (0)
+
+
+/*
+ * Set the color index used for all subsequent pixels in the buffer.
+ */
+#define PB_SET_INDEX( PB, I )			\
+do {						\
+   if ((PB)->count > 0)				\
+      (PB)->mono = GL_FALSE;			\
+   (PB)->currentIndex = (I);			\
+} while (0)
+
+
+/*
+ * "write" a pixel using current color or index
+ */
+#define PB_WRITE_PIXEL( PB, X, Y, Z, FOG )		\
+do {							\
+   GLuint count = (PB)->count;				\
+   (PB)->x[count] = X;					\
+   (PB)->y[count] = Y;					\
+   (PB)->z[count] = Z;					\
+   (PB)->fog[count] = FOG;				\
+   COPY_CHAN4((PB)->rgba[count], (PB)->currentColor);	\
+   (PB)->index[count] = (PB)->currentIndex;		\
+   (PB)->count++;					\
+} while (0)
+
+
+/*
+ * "write" an RGBA pixel
+ */
+#define PB_WRITE_RGBA_PIXEL( PB, X, Y, Z, FOG, R, G, B, A )	\
+do {								\
+   GLuint count = (PB)->count;					\
+   (PB)->x[count] = X;						\
+   (PB)->y[count] = Y;						\
+   (PB)->z[count] = Z;						\
+   (PB)->fog[count] = FOG;					\
+   (PB)->rgba[count][RCOMP] = R;				\
+   (PB)->rgba[count][GCOMP] = G;				\
+   (PB)->rgba[count][BCOMP] = B;				\
+   (PB)->rgba[count][ACOMP] = A;				\
+   (PB)->mono = GL_FALSE;					\
+   (PB)->count++;						\
+} while (0)
+
+
+/*
+ * "write" a color-index pixel
+ */
+#define PB_WRITE_CI_PIXEL( PB, X, Y, Z, FOG, I ) \
+do {						\
+   GLuint count = (PB)->count;			\
+   (PB)->x[count] = X;				\
+   (PB)->y[count] = Y;				\
+   (PB)->z[count] = Z;				\
+   (PB)->fog[count] = FOG;			\
+   (PB)->index[count] = I;			\
+   (PB)->mono = GL_FALSE;			\
+   (PB)->count++;				\
+} while (0)
+
+
+
+/*
+ * "write" an RGBA pixel with texture coordinates
+ */
+#define PB_WRITE_TEX_PIXEL( PB, X, Y, Z, FOG, R, G, B, A, S, T, U )	\
+do {							\
+   GLuint count = (PB)->count;				\
+   (PB)->x[count] = X;					\
+   (PB)->y[count] = Y;					\
+   (PB)->z[count] = Z;					\
+   (PB)->fog[count] = FOG;				\
+   (PB)->rgba[count][RCOMP] = R;			\
+   (PB)->rgba[count][GCOMP] = G;			\
+   (PB)->rgba[count][BCOMP] = B;			\
+   (PB)->rgba[count][ACOMP] = A;			\
+   (PB)->s[0][count] = S;				\
+   (PB)->t[0][count] = T;				\
+   (PB)->u[0][count] = U;				\
+   (PB)->mono = GL_FALSE;				\
+   (PB)->count++;					\
+} while (0)
+
+
+/*
+ * "write" an RGBA pixel with multiple texture coordinates
+ */
+#define PB_WRITE_MULTITEX_PIXEL( PB, X, Y, Z, FOG, R, G, B, A, TEXCOORDS ) \
+do {									\
+   GLuint count = (PB)->count;						\
+   GLuint unit;								\
+   (PB)->x[count] = X;							\
+   (PB)->y[count] = Y;							\
+   (PB)->z[count] = Z;							\
+   (PB)->fog[count] = FOG;						\
+   (PB)->rgba[count][RCOMP] = R;					\
+   (PB)->rgba[count][GCOMP] = G;					\
+   (PB)->rgba[count][BCOMP] = B;					\
+   (PB)->rgba[count][ACOMP] = A;					\
+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {		\
+      if (ctx->Texture.Unit[unit]._ReallyEnabled) {			\
+         (PB)->s[unit][count] = TEXCOORDS[unit][0];			\
+         (PB)->t[unit][count] = TEXCOORDS[unit][1];			\
+         (PB)->u[unit][count] = TEXCOORDS[unit][2];			\
+      }									\
+   }									\
+   (PB)->mono = GL_FALSE;						\
+   (PB)->count++;							\
+} while (0)
+
+
+/*
+ * "write" an RGBA pixel with multiple texture coordinates and specular color
+ */
+#define PB_WRITE_MULTITEX_SPEC_PIXEL( PB, X, Y, Z, FOG, R, G, B, A, SR, SG, SB, TEXCOORDS )\
+do {									\
+   GLuint count = (PB)->count;						\
+   GLuint unit;								\
+   (PB)->haveSpec = GL_TRUE;						\
+   (PB)->x[count] = X;							\
+   (PB)->y[count] = Y;							\
+   (PB)->z[count] = Z;							\
+   (PB)->fog[count] = FOG;						\
+   (PB)->rgba[count][RCOMP] = R;					\
+   (PB)->rgba[count][GCOMP] = G;					\
+   (PB)->rgba[count][BCOMP] = B;					\
+   (PB)->rgba[count][ACOMP] = A;					\
+   (PB)->spec[count][RCOMP] = SR;					\
+   (PB)->spec[count][GCOMP] = SG;					\
+   (PB)->spec[count][BCOMP] = SB;					\
+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {		\
+      if (ctx->Texture.Unit[unit]._ReallyEnabled) {			\
+         (PB)->s[unit][count] = TEXCOORDS[unit][0];			\
+         (PB)->t[unit][count] = TEXCOORDS[unit][1];			\
+         (PB)->u[unit][count] = TEXCOORDS[unit][2];			\
+      }									\
+   }									\
+   (PB)->mono = GL_FALSE;						\
+   (PB)->count++;							\
+} while (0)
+
+
+#define PB_COVERAGE(PB, COVERAGE)				\
+   (PB)->coverage[(PB)->count] = COVERAGE;
+
+
+/*
+ * Call this function at least every MAX_WIDTH pixels:
+ */
+#define PB_CHECK_FLUSH( CTX, PB )			\
+do {							\
+   if ((PB)->count >= PB_SIZE - MAX_WIDTH) {		\
+      _mesa_flush_pb( CTX );				\
+   }							\
+} while(0)
+
+
+extern struct pixel_buffer *_mesa_alloc_pb(void);
+
+extern void _mesa_flush_pb( GLcontext *ctx );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_pixeltex.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_pixeltex.c:1.2
--- /dev/null	Thu Feb 27 12:16:01 2003
+++ xc/extras/Mesa/src/swrast/s_pixeltex.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,80 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * This file implements both the GL_SGIX_pixel_texture and
+ * GL_SIGS_pixel_texture extensions. Luckily, they pretty much
+ * overlap in functionality so we use the same state variables
+ * and execution code for both.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+
+#include "s_context.h"
+#include "s_pixeltex.h"
+
+
+/*
+ * Convert RGBA values into strq texture coordinates.
+ */
+void
+_mesa_pixeltexgen(GLcontext *ctx, GLuint n, const GLchan rgba[][4],
+                  GLfloat s[], GLfloat t[], GLfloat r[], GLfloat q[])
+{
+   if (ctx->Pixel.FragmentRgbSource == GL_CURRENT_RASTER_COLOR) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         s[i] = ctx->Current.RasterColor[RCOMP];
+         t[i] = ctx->Current.RasterColor[GCOMP];
+         r[i] = ctx->Current.RasterColor[BCOMP];
+      }
+   }
+   else {
+      GLuint i;
+      ASSERT(ctx->Pixel.FragmentRgbSource == GL_PIXEL_GROUP_COLOR_SGIS);
+      for (i = 0; i < n; i++) {
+         s[i] = CHAN_TO_FLOAT(rgba[i][RCOMP]);
+         t[i] = CHAN_TO_FLOAT(rgba[i][GCOMP]);
+         r[i] = CHAN_TO_FLOAT(rgba[i][BCOMP]);
+      }
+   }
+
+   if (ctx->Pixel.FragmentAlphaSource == GL_CURRENT_RASTER_COLOR) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         q[i] = ctx->Current.RasterColor[ACOMP];
+      }
+   }
+   else {
+      GLuint i;
+      ASSERT(ctx->Pixel.FragmentAlphaSource == GL_PIXEL_GROUP_COLOR_SGIS);
+      for (i = 0; i < n; i++) {
+         q[i] = CHAN_TO_FLOAT(rgba[i][ACOMP]);
+      }
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_pixeltex.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_pixeltex.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_pixeltex.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,38 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_PIXELTEX_H
+#define S_PIXELTEX_H
+
+#include "mtypes.h"
+#include "swrast.h"
+
+extern void
+_mesa_pixeltexgen(GLcontext *ctx, GLuint n, const GLchan rgba[][4],
+                  GLfloat s[], GLfloat t[], GLfloat r[], GLfloat q[]);
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_points.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_points.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_points.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,256 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mmath.h"
+#include "texstate.h"
+#include "s_context.h"
+#include "s_feedback.h"
+#include "s_pb.h"
+#include "s_points.h"
+#include "s_span.h"
+
+
+
+#define INDEX      0x0
+#define RGBA       0x1
+#define SMOOTH     0x2
+#define TEXTURE    0x4
+#define SPECULAR   0x8
+#define LARGE     0x10
+#define ATTENUATE 0x20
+
+
+/*
+ * CI points with size == 1.0
+ */
+#define FLAGS (INDEX)
+#define NAME size1_ci_point
+#include "s_pointtemp.h"
+
+
+/*
+ * General CI points.
+ */
+#define FLAGS (INDEX | LARGE)
+#define NAME general_ci_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Antialiased CI points.
+ */
+#define FLAGS (INDEX | SMOOTH)
+#define NAME antialiased_ci_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Distance attenuated, general CI points.
+ */
+#define FLAGS (INDEX | ATTENUATE)
+#define NAME atten_general_ci_point
+#include "s_pointtemp.h"
+
+
+/*
+ * RGBA points with size == 1.0
+ */
+#define FLAGS (RGBA)
+#define NAME size1_rgba_point
+#include "s_pointtemp.h"
+
+
+/*
+ * General RGBA points.
+ */
+#define FLAGS (RGBA | LARGE)
+#define NAME general_rgba_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Antialiased RGBA points.
+ */
+#define FLAGS (RGBA | SMOOTH)
+#define NAME antialiased_rgba_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Textured RGBA points.
+ */
+#define FLAGS (RGBA | LARGE | TEXTURE | SPECULAR)
+#define NAME textured_rgba_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Antialiased points with texture mapping.
+ */
+#define FLAGS (RGBA | SMOOTH | TEXTURE | SPECULAR)
+#define NAME antialiased_tex_rgba_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Distance attenuated, general RGBA points.
+ */
+#define FLAGS (RGBA | ATTENUATE)
+#define NAME atten_general_rgba_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Distance attenuated, textured RGBA points.
+ */
+#define FLAGS (RGBA | ATTENUATE | TEXTURE | SPECULAR)
+#define NAME atten_textured_rgba_point
+#include "s_pointtemp.h"
+
+
+/*
+ * Distance attenuated, antialiased points with or without texture mapping.
+ */
+#define FLAGS (RGBA | ATTENUATE | TEXTURE | SMOOTH)
+#define NAME atten_antialiased_rgba_point
+#include "s_pointtemp.h"
+
+
+
+void _swrast_add_spec_terms_point( GLcontext *ctx,
+				   const SWvertex *v0 )
+{
+   SWvertex *ncv0 = (SWvertex *)v0;
+   GLchan c[1][4];
+   COPY_CHAN4( c[0], ncv0->color );
+   ACC_3V( ncv0->color, ncv0->specular );
+   SWRAST_CONTEXT(ctx)->SpecPoint( ctx, ncv0 );
+   COPY_CHAN4( ncv0->color, c[0] );
+}
+
+
+
+/* record the current point function name */
+#ifdef DEBUG
+
+static const char *pntFuncName = NULL;
+
+#define USE(pntFunc)                   \
+do {                                   \
+    pntFuncName = #pntFunc;            \
+    /*printf("%s\n", pntFuncName);*/   \
+    swrast->Point = pntFunc;           \
+} while (0)
+
+#else
+
+#define USE(pntFunc)  swrast->Point = pntFunc
+
+#endif
+
+
+/*
+ * Examine the current context to determine which point drawing function
+ * should be used.
+ */
+void
+_swrast_choose_point( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLboolean rgbMode = ctx->Visual.rgbMode;
+
+   if (ctx->RenderMode==GL_RENDER) {
+      if (ctx->Point.SmoothFlag) {
+         /* Smooth points */
+         if (rgbMode) {
+            if (ctx->Point._Attenuated) {
+               USE(atten_antialiased_rgba_point);
+            }
+            else if (ctx->Texture._ReallyEnabled) {
+               USE(antialiased_tex_rgba_point);
+            }
+            else {
+               USE(antialiased_rgba_point);
+            }
+         }
+         else {
+            USE(antialiased_ci_point);
+         }
+      }
+      else if (ctx->Point._Attenuated) {
+         if (rgbMode) {
+            if (ctx->Texture._ReallyEnabled) {
+               if (ctx->Point.SmoothFlag) {
+                  USE(atten_antialiased_rgba_point);
+               }
+               else {
+                  USE(atten_textured_rgba_point);
+               }
+            }
+            else {
+               USE(atten_general_rgba_point);
+            }
+         }
+         else {
+            /* ci, atten */
+            USE(atten_general_ci_point);
+         }
+      }
+      else if (ctx->Texture._ReallyEnabled && rgbMode) {
+         /* textured */
+         USE(textured_rgba_point);
+      }
+      else if (ctx->Point.Size != 1.0) {
+         /* large points */
+         if (rgbMode) {
+            USE(general_rgba_point);
+         }
+         else {
+            USE(general_ci_point);
+         }
+      }
+      else {
+         /* single pixel points */
+         if (rgbMode) {
+            USE(size1_rgba_point);
+         }
+         else {
+            USE(size1_ci_point);
+         }
+      }
+   }
+   else if (ctx->RenderMode==GL_FEEDBACK) {
+      USE(_mesa_feedback_point);
+   }
+   else {
+      /* GL_SELECT mode */
+      USE(_mesa_select_point);
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_points.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_points.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_points.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_POINTS_H
+#define S_POINTS_H
+
+#include "mtypes.h"
+
+void
+_swrast_choose_point( GLcontext *ctx );
+
+void
+_swrast_add_spec_terms_point( GLcontext *ctx,
+			      const SWvertex *v0 );
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_pointtemp.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_pointtemp.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_pointtemp.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,271 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.5
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * Point rendering template code.
+ *
+ * Set FLAGS = bitwise-OR of the following tokens:
+ *
+ *   RGBA = do rgba instead of color index
+ *   SMOOTH = do antialiasing
+ *   TEXTURE = do texture coords
+ *   SPECULAR = do separate specular color
+ *   LARGE = do points with diameter > 1 pixel
+ *   ATTENUATE = compute point size attenuation
+ *
+ * Notes: LARGE and ATTENUATE are exclusive of each other.
+ *        TEXTURE requires RGBA
+ *        SPECULAR requires TEXTURE
+ */
+
+
+/*
+ * NOTES on antialiased point rasterization:
+ *
+ * Let d = distance of fragment center from vertex.
+ * if d < rmin2 then
+ *    fragment has 100% coverage
+ * else if d > rmax2 then
+ *    fragment has 0% coverage
+ * else
+ *    fragement has % coverage = (d - rmin2) / (rmax2 - rmin2)
+ */
+
+
+
+static void
+NAME ( GLcontext *ctx, const SWvertex *vert )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   struct pixel_buffer *PB = swrast->PB;
+
+   const GLint z = (GLint) (vert->win[2] + 0.5F);
+
+#if FLAGS & RGBA
+   const GLchan red   = vert->color[0];
+   const GLchan green = vert->color[1];
+   const GLchan blue  = vert->color[2];
+   GLchan alpha = vert->color[3];
+#if FLAGS & SPECULAR
+   const GLchan sRed   = vert->specular[0];
+   const GLchan sGreen = vert->specular[1];
+   const GLchan sBlue  = vert->specular[2];
+#endif
+#else
+   GLint index = vert->index;
+#endif
+#if FLAGS & (ATTENUATE | LARGE | SMOOTH)
+   GLfloat size;
+#endif
+#if FLAGS & ATTENUATE
+   GLfloat alphaAtten;
+#endif
+
+#if FLAGS & TEXTURE
+   GLfloat texcoord[MAX_TEXTURE_UNITS][4];
+   GLuint u;
+   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+      if (ctx->Texture.Unit[u]._ReallyEnabled) {
+         if (vert->texcoord[u][3] != 1.0 && vert->texcoord[u][3] != 0.0) {
+            texcoord[u][0] = vert->texcoord[u][0] / vert->texcoord[u][3];
+            texcoord[u][1] = vert->texcoord[u][1] / vert->texcoord[u][3];
+            texcoord[u][2] = vert->texcoord[u][2] / vert->texcoord[u][3];
+         }
+         else {
+            texcoord[u][0] = vert->texcoord[u][0];
+            texcoord[u][1] = vert->texcoord[u][1];
+            texcoord[u][2] = vert->texcoord[u][2];
+         }
+      }
+   }
+#endif
+
+#if FLAGS & ATTENUATE
+   if (vert->pointSize >= ctx->Point.Threshold) {
+      size = MIN2(vert->pointSize, ctx->Point.MaxSize);
+      alphaAtten = 1.0F;
+   }
+   else {
+      GLfloat dsize = vert->pointSize / ctx->Point.Threshold;
+      size = MAX2(ctx->Point.Threshold, ctx->Point.MinSize);
+      alphaAtten = dsize * dsize;
+   }
+#elif FLAGS & (LARGE | SMOOTH)
+   size = ctx->Point._Size;
+#endif
+
+   /* Cull primitives with malformed coordinates.
+    */
+   {
+      float tmp = vert->win[0] + vert->win[1];
+      if (IS_INF_OR_NAN(tmp))
+	 return;
+   }
+
+#if FLAGS & (LARGE | ATTENUATE | SMOOTH)
+
+   {
+      GLint x, y;
+      const GLfloat radius = 0.5F * size;
+#if FLAGS & SMOOTH
+      const GLfloat rmin = radius - 0.7071F;  /* 0.7071 = sqrt(2)/2 */
+      const GLfloat rmax = radius + 0.7071F;
+      const GLfloat rmin2 = MAX2(0.0F, rmin * rmin);
+      const GLfloat rmax2 = rmax * rmax;
+      const GLfloat cscale = 1.0F / (rmax2 - rmin2);
+      const GLint xmin = (GLint) (vert->win[0] - radius);
+      const GLint xmax = (GLint) (vert->win[0] + radius);
+      const GLint ymin = (GLint) (vert->win[1] - radius);
+      const GLint ymax = (GLint) (vert->win[1] + radius);
+#else
+      /* non-smooth */
+      GLint xmin, xmax, ymin, ymax;
+      GLint iSize = (GLint) (size + 0.5F);
+      GLint iRadius;
+      iSize = MAX2(1, iSize);
+      iRadius = iSize / 2;
+      if (iSize & 1) {
+         /* odd size */
+         xmin = (GLint) (vert->win[0] - iRadius);
+         xmax = (GLint) (vert->win[0] + iRadius);
+         ymin = (GLint) (vert->win[1] - iRadius);
+         ymax = (GLint) (vert->win[1] + iRadius);
+      }
+      else {
+         /* even size */
+         xmin = (GLint) vert->win[0] - iRadius + 1;
+         xmax = xmin + iSize - 1;
+         ymin = (GLint) vert->win[1] - iRadius + 1;
+         ymax = ymin + iSize - 1;
+      }
+#endif
+      (void) radius;
+
+      for (y = ymin; y <= ymax; y++) {
+         for (x = xmin; x <= xmax; x++) {
+#if FLAGS & SMOOTH
+            /* compute coverage */
+            const GLfloat dx = x - vert->win[0] + 0.5F;
+            const GLfloat dy = y - vert->win[1] + 0.5F;
+            const GLfloat dist2 = dx * dx + dy * dy;
+            if (dist2 < rmax2) {
+#if FLAGS & RGBA
+               alpha = vert->color[3];
+#endif
+               if (dist2 >= rmin2) {
+                  /* compute partial coverage */
+                  PB_COVERAGE(PB, 1.0F - (dist2 - rmin2) * cscale);
+	       }
+               else {
+                  /* full coverage */
+                  PB_COVERAGE(PB, 1.0F);
+               }
+
+#endif /* SMOOTH */
+
+#if ((FLAGS & (ATTENUATE | RGBA)) == (ATTENUATE | RGBA))
+	       alpha = (GLchan) (alpha * alphaAtten);
+#endif
+
+#if FLAGS & SPECULAR
+               PB_WRITE_MULTITEX_SPEC_PIXEL(PB, x, y, z, vert->fog,
+                                            red, green, blue, alpha,
+                                            sRed, sGreen, sBlue,
+                                            texcoord);
+#elif FLAGS & TEXTURE
+	       if (ctx->Texture._ReallyEnabled > TEXTURE0_ANY) {
+		  PB_WRITE_MULTITEX_PIXEL(PB, x, y, z, vert->fog,
+					  red, green, blue, alpha,
+					  texcoord);
+	       }
+	       else if (ctx->Texture._ReallyEnabled) {
+		  PB_WRITE_TEX_PIXEL(PB, x,y,z, vert->fog,
+				     red, green, blue, alpha,
+				     texcoord[0][0],
+				     texcoord[0][1],
+				     texcoord[0][2]);
+	       }
+               else {
+                  PB_WRITE_RGBA_PIXEL(PB, x, y, z, vert->fog,
+                                      red, green, blue, alpha);
+               }
+#elif FLAGS & RGBA
+	       PB_WRITE_RGBA_PIXEL(PB, x, y, z, vert->fog,
+                                   red, green, blue, alpha);
+#else /* color index */
+               PB_WRITE_CI_PIXEL(PB, x, y, z, vert->fog, index);
+#endif
+#if FLAGS & SMOOTH
+	    }
+#endif
+	 }
+      }
+
+#if FLAGS & SMOOTH
+      PB->haveCoverage = GL_TRUE;
+#endif
+
+      PB_CHECK_FLUSH(ctx,PB);
+   }
+
+#else /* LARGE || ATTENUATE || SMOOTH*/
+
+   {
+      /* size == 1 */
+      GLint x = (GLint) vert->win[0];
+      GLint y = (GLint) vert->win[1];
+#if ((FLAGS & (SPECULAR | TEXTURE)) == (SPECULAR | TEXTURE))
+      PB_WRITE_MULTITEX_SPEC_PIXEL(PB, x, y, z, vert->fog,
+                                   red, green, blue, alpha,
+                                   sRed, sGreen, sBlue,
+                                   texcoord);
+#elif FLAGS & TEXTURE
+      if (ctx->Texture._ReallyEnabled > TEXTURE0_ANY) {
+         PB_WRITE_MULTITEX_PIXEL(PB, x, y, z, vert->fog,
+                                 red, green, blue, alpha, texcoord );
+      }
+      else {
+         PB_WRITE_TEX_PIXEL(PB, x, y, z, vert->fog,
+                            red, green, blue, alpha,
+                            texcoord[0][0], texcoord[0][1], texcoord[0][2]);
+      }
+#elif FLAGS & RGBA
+      /* rgba size 1 point */
+      alpha = vert->color[3];
+      PB_WRITE_RGBA_PIXEL(PB, x, y, z, vert->fog, red, green, blue, alpha);
+#else
+      /* color index size 1 point */
+      PB_WRITE_CI_PIXEL(PB, x, y, z, vert->fog, index);
+#endif
+   }
+#endif /* LARGE || ATTENUATE || SMOOTH */
+
+   PB_CHECK_FLUSH(ctx, PB);
+}
+
+
+#undef FLAGS
+#undef NAME
Index: xc/extras/Mesa/src/swrast/s_readpix.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_readpix.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_readpix.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,528 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "convolve.h"
+#include "context.h"
+#include "feedback.h"
+#include "image.h"
+#include "macros.h"
+#include "mem.h"
+#include "pixel.h"
+
+#include "s_alphabuf.h"
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_span.h"
+#include "s_stencil.h"
+
+
+
+/*
+ * Read a block of color index pixels.
+ */
+static void
+read_index_pixels( GLcontext *ctx,
+                   GLint x, GLint y,
+                   GLsizei width, GLsizei height,
+                   GLenum type, GLvoid *pixels,
+                   const struct gl_pixelstore_attrib *packing )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLint i, readWidth;
+
+   /* error checking */
+   if (ctx->Visual.rgbMode) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
+      return;
+   }
+
+   ASSERT(swrast->Driver.SetReadBuffer);
+   (*swrast->Driver.SetReadBuffer)(ctx, ctx->ReadBuffer,
+                                ctx->Pixel.DriverReadBuffer);
+
+   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+   /* process image row by row */
+   for (i = 0; i < height; i++) {
+      GLuint index[MAX_WIDTH];
+      GLvoid *dest;
+
+      (*swrast->Driver.ReadCI32Span)(ctx, readWidth, x, y + i, index);
+
+      dest = _mesa_image_address(packing, pixels, width, height,
+                                 GL_COLOR_INDEX, type, 0, i, 0);
+
+      _mesa_pack_index_span(ctx, readWidth, type, dest, index,
+                            &ctx->Pack, ctx->_ImageTransferState);
+   }
+
+   (*swrast->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer,
+                                ctx->Color.DriverDrawBuffer);
+}
+
+
+
+static void
+read_depth_pixels( GLcontext *ctx,
+                   GLint x, GLint y,
+                   GLsizei width, GLsizei height,
+                   GLenum type, GLvoid *pixels,
+                   const struct gl_pixelstore_attrib *packing )
+{
+   GLint readWidth;
+   GLboolean bias_or_scale;
+
+   /* Error checking */
+   if (ctx->Visual.depthBits <= 0) {
+      /* No depth buffer */
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
+      return;
+   }
+
+   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+   if (type != GL_BYTE &&
+       type != GL_UNSIGNED_BYTE &&
+       type != GL_SHORT &&
+       type != GL_UNSIGNED_SHORT &&
+       type != GL_INT &&
+       type != GL_UNSIGNED_INT &&
+       type != GL_FLOAT) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glReadPixels(depth type)");
+      return;
+   }
+
+   bias_or_scale = ctx->Pixel.DepthBias!=0.0 || ctx->Pixel.DepthScale!=1.0;
+
+   if (type==GL_UNSIGNED_SHORT && ctx->Visual.depthBits == 16
+       && !bias_or_scale && !packing->SwapBytes) {
+      /* Special case: directly read 16-bit unsigned depth values. */
+      GLint j;
+      for (j=0;j<height;j++,y++) {
+         GLdepth depth[MAX_WIDTH];
+         GLushort *dst = (GLushort*) _mesa_image_address( packing, pixels,
+                         width, height, GL_DEPTH_COMPONENT, type, 0, j, 0 );
+         GLint i;
+         _mesa_read_depth_span(ctx, width, x, y, depth);
+         for (i = 0; i < width; i++)
+            dst[i] = depth[i];
+      }
+   }
+   else if (type==GL_UNSIGNED_INT && ctx->Visual.depthBits == 32
+            && !bias_or_scale && !packing->SwapBytes) {
+      /* Special case: directly read 32-bit unsigned depth values. */
+      GLint j;
+      for (j=0;j<height;j++,y++) {
+         GLdepth *dst = (GLdepth *) _mesa_image_address( packing, pixels,
+                         width, height, GL_DEPTH_COMPONENT, type, 0, j, 0 );
+         _mesa_read_depth_span(ctx, width, x, y, dst);
+      }
+   }
+   else {
+      /* General case (slower) */
+      GLint j;
+      for (j=0;j<height;j++,y++) {
+         GLfloat depth[MAX_WIDTH];
+         GLvoid *dest;
+
+         _mesa_read_depth_span_float(ctx, readWidth, x, y, depth);
+
+         dest = _mesa_image_address(packing, pixels, width, height,
+                                    GL_DEPTH_COMPONENT, type, 0, j, 0);
+
+         _mesa_pack_depth_span(ctx, readWidth, (GLdepth *) dest, type,
+                               depth, &ctx->Pack);
+      }
+   }
+}
+
+
+
+static void
+read_stencil_pixels( GLcontext *ctx,
+                     GLint x, GLint y,
+                     GLsizei width, GLsizei height,
+                     GLenum type, GLvoid *pixels,
+                     const struct gl_pixelstore_attrib *packing )
+{
+   GLint j, readWidth;
+
+   if (type != GL_BYTE &&
+       type != GL_UNSIGNED_BYTE &&
+       type != GL_SHORT &&
+       type != GL_UNSIGNED_SHORT &&
+       type != GL_INT &&
+       type != GL_UNSIGNED_INT &&
+       type != GL_FLOAT &&
+       type != GL_BITMAP) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glReadPixels(stencil type)");
+      return;
+   }
+
+   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+   if (ctx->Visual.stencilBits <= 0) {
+      /* No stencil buffer */
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glReadPixels" );
+      return;
+   }
+
+   /* process image row by row */
+   for (j=0;j<height;j++,y++) {
+      GLvoid *dest;
+      GLstencil stencil[MAX_WIDTH];
+
+      _mesa_read_stencil_span(ctx, readWidth, x, y, stencil);
+
+      dest = _mesa_image_address(packing, pixels, width, height,
+                                 GL_STENCIL_INDEX, type, 0, j, 0);
+
+      _mesa_pack_stencil_span(ctx, readWidth, type, dest, stencil, &ctx->Pack);
+   }
+}
+
+
+
+/*
+ * Optimized glReadPixels for particular pixel formats:
+ *   GL_UNSIGNED_BYTE, GL_RGBA
+ * when pixel scaling, biasing and mapping are disabled.
+ */
+static GLboolean
+read_fast_rgba_pixels( GLcontext *ctx,
+                       GLint x, GLint y,
+                       GLsizei width, GLsizei height,
+                       GLenum format, GLenum type,
+                       GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   /* can't do scale, bias, mapping, etc */
+   if (ctx->_ImageTransferState)
+       return GL_FALSE;
+
+   /* can't do fancy pixel packing */
+   if (packing->Alignment != 1 || packing->SwapBytes || packing->LsbFirst)
+      return GL_FALSE;
+
+   {
+      GLint srcX = x;
+      GLint srcY = y;
+      GLint readWidth = width;           /* actual width read */
+      GLint readHeight = height;         /* actual height read */
+      GLint skipPixels = packing->SkipPixels;
+      GLint skipRows = packing->SkipRows;
+      GLint rowLength;
+
+      if (packing->RowLength > 0)
+         rowLength = packing->RowLength;
+      else
+         rowLength = width;
+
+      /* horizontal clipping */
+      if (srcX < 0) {
+         skipPixels -= srcX;
+         readWidth += srcX;
+         srcX = 0;
+      }
+      if (srcX + readWidth > (GLint) ctx->ReadBuffer->Width)
+         readWidth -= (srcX + readWidth - (GLint) ctx->ReadBuffer->Width);
+      if (readWidth <= 0)
+         return GL_TRUE;
+
+      /* vertical clipping */
+      if (srcY < 0) {
+         skipRows -= srcY;
+         readHeight += srcY;
+         srcY = 0;
+      }
+      if (srcY + readHeight > (GLint) ctx->ReadBuffer->Height)
+         readHeight -= (srcY + readHeight - (GLint) ctx->ReadBuffer->Height);
+      if (readHeight <= 0)
+         return GL_TRUE;
+
+      /*
+       * Ready to read!
+       * The window region at (destX, destY) of size (readWidth, readHeight)
+       * will be read back.
+       * We'll write pixel data to buffer pointed to by "pixels" but we'll
+       * skip "skipRows" rows and skip "skipPixels" pixels/row.
+       */
+#if CHAN_BITS == 8
+      if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
+#elif CHAN_BITS == 16
+      if (format == GL_RGBA && type == GL_UNSIGNED_SHORT) {
+#else
+      if (0) {
+#endif
+         GLchan *dest = (GLchan *) pixels
+                      + (skipRows * rowLength + skipPixels) * 4;
+         GLint row;
+
+         if (packing->Invert) {
+            /* start at top and go down */
+            dest += (readHeight - 1) * rowLength * 4;
+            rowLength = -rowLength;
+         }
+
+         for (row=0; row<readHeight; row++) {
+            (*swrast->Driver.ReadRGBASpan)(ctx, readWidth, srcX, srcY,
+                                        (GLchan (*)[4]) dest);
+            if (ctx->DrawBuffer->UseSoftwareAlphaBuffers) {
+               _mesa_read_alpha_span(ctx, readWidth, srcX, srcY,
+                                     (GLchan (*)[4]) dest);
+            }
+            dest += rowLength * 4;
+            srcY++;
+         }
+         return GL_TRUE;
+      }
+      else {
+         /* can't do this format/type combination */
+         return GL_FALSE;
+      }
+   }
+}
+
+
+
+/*
+ * Read R, G, B, A, RGB, L, or LA pixels.
+ */
+static void
+read_rgba_pixels( GLcontext *ctx,
+                  GLint x, GLint y,
+                  GLsizei width, GLsizei height,
+                  GLenum format, GLenum type, GLvoid *pixels,
+                  const struct gl_pixelstore_attrib *packing )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLint readWidth;
+
+   (*swrast->Driver.SetReadBuffer)(ctx, ctx->ReadBuffer, ctx->Pixel.DriverReadBuffer);
+
+   /* Try optimized path first */
+   if (read_fast_rgba_pixels( ctx, x, y, width, height,
+                              format, type, pixels, packing )) {
+
+      (*swrast->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer);
+      return; /* done! */
+   }
+
+   readWidth = (width > MAX_WIDTH) ? MAX_WIDTH : width;
+
+   /* do error checking on pixel type, format was already checked by caller */
+   switch (type) {
+      case GL_UNSIGNED_BYTE:
+      case GL_BYTE:
+      case GL_UNSIGNED_SHORT:
+      case GL_SHORT:
+      case GL_UNSIGNED_INT:
+      case GL_INT:
+      case GL_FLOAT:
+      case GL_UNSIGNED_BYTE_3_3_2:
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+      case GL_UNSIGNED_SHORT_5_6_5:
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+      case GL_UNSIGNED_INT_8_8_8_8:
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+      case GL_UNSIGNED_INT_10_10_10_2:
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+         /* valid pixel type */
+         break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glReadPixels(type)" );
+         return;
+   }
+
+   if (!_mesa_is_legal_format_and_type(format, type) ||
+       format == GL_INTENSITY) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(format or type)");
+      return;
+   }
+
+   if (ctx->Pixel.Convolution2DEnabled || ctx->Pixel.Separable2DEnabled) {
+      const GLuint transferOps = ctx->_ImageTransferState;
+      GLfloat *dest, *src, *tmpImage, *convImage;
+      GLint row;
+
+      tmpImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+      if (!tmpImage) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+         return;
+      }
+      convImage = (GLfloat *) MALLOC(width * height * 4 * sizeof(GLfloat));
+      if (!convImage) {
+         FREE(tmpImage);
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glReadPixels");
+         return;
+      }
+
+      /* read full RGBA, FLOAT image */
+      dest = tmpImage;
+      for (row = 0; row < height; row++, y++) {
+         GLchan rgba[MAX_WIDTH][4];
+         if (ctx->Visual.rgbMode) {
+            _mesa_read_rgba_span(ctx, ctx->ReadBuffer, readWidth, x, y, rgba);
+         }
+         else {
+            GLuint index[MAX_WIDTH];
+            (*swrast->Driver.ReadCI32Span)(ctx, readWidth, x, y, index);
+            if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset !=0 ) {
+               _mesa_map_ci(ctx, readWidth, index);
+            }
+            _mesa_map_ci_to_rgba_chan(ctx, readWidth, index, rgba);
+         }
+         _mesa_pack_rgba_span(ctx, readWidth, (const GLchan (*)[4]) rgba,
+                              GL_RGBA, GL_FLOAT, dest, &_mesa_native_packing,
+                              transferOps & IMAGE_PRE_CONVOLUTION_BITS);
+         dest += width * 4;
+      }
+
+      /* do convolution */
+      if (ctx->Pixel.Convolution2DEnabled) {
+         _mesa_convolve_2d_image(ctx, &readWidth, &height, tmpImage, convImage);
+      }
+      else {
+         ASSERT(ctx->Pixel.Separable2DEnabled);
+         _mesa_convolve_sep_image(ctx, &readWidth, &height, tmpImage, convImage);
+      }
+      FREE(tmpImage);
+
+      /* finish transfer ops and pack the resulting image */
+      src = convImage;
+      for (row = 0; row < height; row++) {
+         GLvoid *dest;
+         dest = _mesa_image_address(packing, pixels, readWidth, height,
+                                    format, type, 0, row, 0);
+         _mesa_pack_float_rgba_span(ctx, readWidth,
+                                    (const GLfloat (*)[4]) src,
+                                    format, type, dest, packing,
+                                    transferOps & IMAGE_POST_CONVOLUTION_BITS);
+         src += readWidth * 4;
+      }
+   }
+   else {
+      /* no convolution */
+      GLint row;
+      for (row = 0; row < height; row++, y++) {
+         GLchan rgba[MAX_WIDTH][4];
+         GLvoid *dst;
+         if (ctx->Visual.rgbMode) {
+            _mesa_read_rgba_span(ctx, ctx->ReadBuffer, readWidth, x, y, rgba);
+         }
+         else {
+            GLuint index[MAX_WIDTH];
+            (*swrast->Driver.ReadCI32Span)(ctx, readWidth, x, y, index);
+            if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) {
+               _mesa_map_ci(ctx, readWidth, index);
+            }
+            _mesa_map_ci_to_rgba_chan(ctx, readWidth, index, rgba);
+         }
+         dst = _mesa_image_address(packing, pixels, width, height,
+                                   format, type, 0, row, 0);
+         if (ctx->Visual.redBits < CHAN_BITS ||
+             ctx->Visual.greenBits < CHAN_BITS ||
+             ctx->Visual.blueBits < CHAN_BITS) {
+            /* Requantize the color values into floating point and go from
+             * there.  This fixes conformance failures with 16-bit color
+             * buffers, for example.
+             */
+            DEFMARRAY(GLfloat, rgbaf, MAX_WIDTH, 4);  /* mac 32k limitation */
+            CHECKARRAY(rgbaf, return);  /* mac 32k limitation */
+            _mesa_chan_to_float_span(ctx, readWidth,
+                                     (CONST GLchan (*)[4]) rgba, rgbaf);
+            _mesa_pack_float_rgba_span(ctx, readWidth,
+                                       (CONST GLfloat (*)[4]) rgbaf,
+                                       format, type, dst, packing,
+                                       ctx->_ImageTransferState);
+            UNDEFARRAY(rgbaf);  /* mac 32k limitation */
+         }
+         else {
+            /* GLubytes are fine */
+            _mesa_pack_rgba_span(ctx, readWidth, (CONST GLchan (*)[4]) rgba,
+                                 format, type, dst, packing,
+                                 ctx->_ImageTransferState);
+         }
+      }
+   }
+
+   (*swrast->Driver.SetReadBuffer)(ctx, ctx->DrawBuffer, ctx->Color.DriverDrawBuffer);
+}
+
+
+
+void
+_swrast_ReadPixels( GLcontext *ctx,
+		    GLint x, GLint y, GLsizei width, GLsizei height,
+		    GLenum format, GLenum type,
+		    const struct gl_pixelstore_attrib *pack,
+		    GLvoid *pixels )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   (void) pack;
+
+   if (swrast->NewState)
+      _swrast_validate_derived( ctx );
+
+   RENDER_START(swrast,ctx);
+
+   switch (format) {
+      case GL_COLOR_INDEX:
+         read_index_pixels(ctx, x, y, width, height, type, pixels, &ctx->Pack);
+	 break;
+      case GL_STENCIL_INDEX:
+	 read_stencil_pixels(ctx, x,y, width,height, type, pixels, &ctx->Pack);
+         break;
+      case GL_DEPTH_COMPONENT:
+	 read_depth_pixels(ctx, x, y, width, height, type, pixels, &ctx->Pack);
+	 break;
+      case GL_RED:
+      case GL_GREEN:
+      case GL_BLUE:
+      case GL_ALPHA:
+      case GL_RGB:
+      case GL_LUMINANCE:
+      case GL_LUMINANCE_ALPHA:
+      case GL_RGBA:
+      case GL_BGR:
+      case GL_BGRA:
+      case GL_ABGR_EXT:
+         read_rgba_pixels(ctx, x, y, width, height,
+                          format, type, pixels, &ctx->Pack);
+	 break;
+      default:
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glReadPixels(format)" );
+   }
+
+   RENDER_FINISH(swrast,ctx);
+}
Index: xc/extras/Mesa/src/swrast/s_scissor.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_scissor.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_scissor.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,63 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "macros.h"
+#include "mem.h"
+#include "s_context.h"
+#include "s_scissor.h"
+
+
+/*
+ * Apply the scissor test to a span of pixels.
+ * Return:  0 = all pixels in the span are outside the scissor box.
+ *          n = mask[n-1] is the last one to be visible
+ */
+GLuint
+_mesa_scissor_span(GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte mask[])
+{
+   /* first check if whole span is outside the scissor box */
+   if (y < ctx->DrawBuffer->_Ymin
+       || y >= ctx->DrawBuffer->_Ymax
+       || x > ctx->DrawBuffer->_Xmax
+       || x + (GLint) n - 1 < ctx->DrawBuffer->_Xmin) {
+      return 0;
+   }
+   else {
+      const GLint xMin = ctx->DrawBuffer->_Xmin;
+      const GLint xMax = ctx->DrawBuffer->_Xmax;
+
+      if (x < xMin)
+         BZERO(mask, (xMin-x) * sizeof(GLubyte));
+
+      if (x + (GLint) n > xMax) {
+         BZERO(mask + xMax - x, (n - (xMax - x)) * sizeof(GLubyte));
+         return (GLuint) (xMax - x);
+      }
+
+      return n;
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_scissor.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_scissor.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_scissor.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_SCISSOR_H
+#define S_SCISSOR_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern GLuint
+_mesa_scissor_span(GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte mask[]);
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_span.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_span.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_span.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,1229 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * pixel span rasterization:
+ * These functions implement the rasterization pipeline.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_alpha.h"
+#include "s_alphabuf.h"
+#include "s_blend.h"
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_fog.h"
+#include "s_logic.h"
+#include "s_masking.h"
+#include "s_scissor.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_texture.h"
+
+
+
+/*
+ * Apply the current polygon stipple pattern to a span of pixels.
+ */
+static void
+stipple_polygon_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                      GLubyte mask[] )
+{
+   const GLuint highbit = 0x80000000;
+   GLuint i, m, stipple;
+
+   stipple = ctx->PolygonStipple[y % 32];
+   m = highbit >> (GLuint) (x % 32);
+
+   for (i = 0; i < n; i++) {
+      if ((m & stipple) == 0) {
+         mask[i] = 0;
+      }
+      m = m >> 1;
+      if (m == 0) {
+         m = highbit;
+      }
+   }
+}
+
+
+
+/*
+ * Clip a pixel span to the current buffer/window boundaries.
+ * Return:  'n' such that pixel 'n', 'n+1' etc. are clipped,
+ *           as a special case:
+ *           0 = all pixels clipped
+ */
+static GLuint
+clip_span( GLcontext *ctx, GLint n, GLint x, GLint y, GLubyte mask[] )
+{
+   /* Clip to top and bottom */
+   if (y < 0 || y >= (GLint) ctx->DrawBuffer->Height) {
+      return 0;
+   }
+
+   /* Clip to the left */
+   if (x < 0) {
+      if (x + n <= 0) {
+         /* completely off left side */
+         return 0;
+      }
+      else {
+         /* partially off left side */
+         BZERO(mask, -x * sizeof(GLubyte));
+      }
+   }
+
+   /* Clip to right */
+   if (x + n > (GLint) ctx->DrawBuffer->Width) {
+      if (x >= (GLint) ctx->DrawBuffer->Width) {
+         /* completely off right side */
+         return 0;
+      }
+      else {
+         /* partially off right side */
+         return ctx->DrawBuffer->Width - x;
+      }
+   }
+
+   return n;
+}
+
+
+
+/*
+ * Draw to more than one color buffer (or none).
+ */
+static void
+multi_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                        const GLuint indexes[], const GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLuint bufferBit;
+
+   if (ctx->Color.DrawBuffer == GL_NONE)
+      return;
+
+   /* loop over four possible dest color buffers */
+   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+      if (bufferBit & ctx->Color.DrawDestMask) {
+         GLuint indexTmp[MAX_WIDTH];
+         ASSERT(n < MAX_WIDTH);
+
+         if (bufferBit == FRONT_LEFT_BIT)
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+         else if (bufferBit == FRONT_RIGHT_BIT)
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+         else if (bufferBit == BACK_LEFT_BIT)
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+         else
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+
+         /* make copy of incoming indexes */
+         MEMCPY( indexTmp, indexes, n * sizeof(GLuint) );
+         if (ctx->Color.IndexLogicOpEnabled) {
+            _mesa_logicop_ci_span( ctx, n, x, y, indexTmp, mask );
+         }
+         if (ctx->Color.IndexMask == 0) {
+            break;
+         }
+         else if (ctx->Color.IndexMask != 0xffffffff) {
+            _mesa_mask_index_span( ctx, n, x, y, indexTmp );
+         }
+         (*swrast->Driver.WriteCI32Span)( ctx, n, x, y, indexTmp, mask );
+      }
+   }
+
+   /* restore default dest buffer */
+   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer);
+}
+
+
+
+/*
+ * Write a horizontal span of color index pixels to the frame buffer.
+ * Stenciling, Depth-testing, etc. are done as needed.
+ * Input:  n - number of pixels in the span
+ *         x, y - location of leftmost pixel in the span
+ *         z - array of [n] z-values
+ *         fog - array of fog factor values in [0,1]
+ *         index - array of [n] color indexes
+ *         primitive - either GL_POINT, GL_LINE, GL_POLYGON, or GL_BITMAP
+ */
+void
+_mesa_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                        const GLdepth z[], const GLfloat fog[],
+                        GLuint indexIn[], const GLint coverage[],
+                        GLenum primitive )
+{
+   const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT | LOGIC_OP_BIT;
+   GLubyte mask[MAX_WIDTH];
+   GLuint indexBackup[MAX_WIDTH];
+   GLuint *index;  /* points to indexIn or indexBackup */
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   /* init mask to 1's (all pixels are to be written) */
+   MEMSET(mask, 1, n);
+
+   if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+      if ((n = clip_span(ctx,n,x,y,mask)) == 0) {
+         return;
+      }
+   }
+
+   if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
+       || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
+      /* Make copy of color indexes */
+      MEMCPY( indexBackup, indexIn, n * sizeof(GLuint) );
+      index = indexBackup;
+   }
+   else {
+      index = indexIn;
+   }
+
+
+   /* Do the scissor test */
+   if (ctx->Scissor.Enabled) {
+      if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+         return;
+      }
+   }
+
+   /* Polygon Stippling */
+   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+      stipple_polygon_span( ctx, n, x, y, mask );
+   }
+
+   if (ctx->Stencil.Enabled) {
+      /* first stencil test */
+      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+         return;
+      }
+   }
+   else if (ctx->Depth.Test) {
+      /* regular depth testing */
+      if (_mesa_depth_test_span( ctx, n, x, y, z, mask ) == 0)
+         return;
+   }
+
+   /* if we get here, something passed the depth test */
+   ctx->OcclusionResult = GL_TRUE;
+
+   /* Per-pixel fog */
+   if (ctx->Fog.Enabled) {
+      if (fog && !swrast->_PreferPixelFog)
+         _mesa_fog_ci_pixels( ctx, n, fog, index );
+      else
+         _mesa_depth_fog_ci_pixels( ctx, n, z, index );
+   }
+
+   /* Antialias coverage application */
+   if (coverage) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         ASSERT(coverage[i] < 16);
+         index[i] = (index[i] & ~0xf) | coverage[i];
+      }
+   }
+
+   if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+      /* draw to zero or two or more buffers */
+      multi_write_index_span( ctx, n, x, y, index, mask );
+   }
+   else {
+      /* normal situation: draw to exactly one buffer */
+      if (ctx->Color.IndexLogicOpEnabled) {
+         _mesa_logicop_ci_span( ctx, n, x, y, index, mask );
+      }
+
+      if (ctx->Color.IndexMask == 0) {
+         return;
+      }
+      else if (ctx->Color.IndexMask != 0xffffffff) {
+         _mesa_mask_index_span( ctx, n, x, y, index );
+      }
+
+      /* write pixels */
+      (*swrast->Driver.WriteCI32Span)( ctx, n, x, y, index, mask );
+   }
+}
+
+
+
+
+void
+_mesa_write_monoindex_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            const GLdepth z[], const GLfloat fog[],
+                            GLuint index, const GLint coverage[],
+                            GLenum primitive )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLubyte mask[MAX_WIDTH];
+   GLuint i;
+
+   /* init mask to 1's (all pixels are to be written) */
+   MEMSET(mask, 1, n);
+
+   if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+      if ((n = clip_span( ctx, n, x, y, mask)) == 0) {
+	 return;
+      }
+   }
+
+   /* Do the scissor test */
+   if (ctx->Scissor.Enabled) {
+      if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+         return;
+      }
+   }
+
+   /* Polygon Stippling */
+   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+      stipple_polygon_span( ctx, n, x, y, mask );
+   }
+
+   if (ctx->Stencil.Enabled) {
+      /* first stencil test */
+      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+	 return;
+      }
+   }
+   else if (ctx->Depth.Test) {
+      /* regular depth testing */
+      if (_mesa_depth_test_span( ctx, n, x, y, z, mask ) == 0)
+         return;
+   }
+
+   /* if we get here, something passed the depth test */
+   ctx->OcclusionResult = GL_TRUE;
+
+   if (ctx->Color.DrawBuffer == GL_NONE) {
+      /* write no pixels */
+      return;
+   }
+
+   if (ctx->Fog.Enabled
+       || ctx->Color.IndexLogicOpEnabled
+       || ctx->Color.IndexMask != 0xffffffff
+       || coverage) {
+      /* different index per pixel */
+      GLuint indexes[MAX_WIDTH];
+      for (i = 0; i < n; i++) {
+	 indexes[i] = index;
+      }
+
+      if (ctx->Fog.Enabled) {
+ 	 if (fog && !swrast->_PreferPixelFog)
+ 	    _mesa_fog_ci_pixels( ctx, n, fog, indexes );
+ 	 else
+ 	    _mesa_depth_fog_ci_pixels( ctx, n, z, indexes );
+      }
+
+      /* Antialias coverage application */
+      if (coverage) {
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            ASSERT(coverage[i] < 16);
+            indexes[i] = (indexes[i] & ~0xf) | coverage[i];
+         }
+      }
+
+      if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+         /* draw to zero or two or more buffers */
+         multi_write_index_span( ctx, n, x, y, indexes, mask );
+      }
+      else {
+         /* normal situation: draw to exactly one buffer */
+         if (ctx->Color.IndexLogicOpEnabled) {
+            _mesa_logicop_ci_span( ctx, n, x, y, indexes, mask );
+         }
+         if (ctx->Color.IndexMask == 0) {
+            return;
+         }
+         else if (ctx->Color.IndexMask != 0xffffffff) {
+            _mesa_mask_index_span( ctx, n, x, y, indexes );
+         }
+         (*swrast->Driver.WriteCI32Span)( ctx, n, x, y, indexes, mask );
+      }
+   }
+   else {
+      /* same color index for all pixels */
+      ASSERT(!ctx->Color.IndexLogicOpEnabled);
+      ASSERT(ctx->Color.IndexMask == 0xffffffff);
+      if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+         /* draw to zero or two or more buffers */
+         GLuint indexes[MAX_WIDTH];
+         for (i = 0; i < n; i++)
+            indexes[i] = index;
+         multi_write_index_span( ctx, n, x, y, indexes, mask );
+      }
+      else {
+         /* normal situation: draw to exactly one buffer */
+         (*swrast->Driver.WriteMonoCISpan)( ctx, n, x, y, index, mask );
+      }
+   }
+}
+
+
+
+/*
+ * Draw to more than one RGBA color buffer (or none).
+ */
+static void
+multi_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                       CONST GLchan rgba[][4], const GLubyte mask[] )
+{
+   const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+   GLuint bufferBit;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   if (ctx->Color.DrawBuffer == GL_NONE)
+      return;
+
+   /* loop over four possible dest color buffers */
+   for (bufferBit = 1; bufferBit <= 8; bufferBit = bufferBit << 1) {
+      if (bufferBit & ctx->Color.DrawDestMask) {
+         GLchan rgbaTmp[MAX_WIDTH][4];
+         ASSERT(n < MAX_WIDTH);
+
+         if (bufferBit == FRONT_LEFT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_LEFT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontLeftAlpha;
+         }
+         else if (bufferBit == FRONT_RIGHT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_FRONT_RIGHT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->FrontRightAlpha;
+         }
+         else if (bufferBit == BACK_LEFT_BIT) {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_LEFT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackLeftAlpha;
+         }
+         else {
+            (void) (*ctx->Driver.SetDrawBuffer)( ctx, GL_BACK_RIGHT);
+            ctx->DrawBuffer->Alpha = ctx->DrawBuffer->BackRightAlpha;
+         }
+
+         /* make copy of incoming colors */
+         MEMCPY( rgbaTmp, rgba, 4 * n * sizeof(GLchan) );
+
+         if (ctx->Color.ColorLogicOpEnabled) {
+            _mesa_logicop_rgba_span( ctx, n, x, y, rgbaTmp, mask );
+         }
+         else if (ctx->Color.BlendEnabled) {
+            _mesa_blend_span( ctx, n, x, y, rgbaTmp, mask );
+         }
+         if (colorMask == 0x0) {
+            break;
+         }
+         else if (colorMask != 0xffffffff) {
+            _mesa_mask_rgba_span( ctx, n, x, y, rgbaTmp );
+         }
+
+         (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
+				       (const GLchan (*)[4]) rgbaTmp, mask );
+         if (swrast->_RasterMask & ALPHABUF_BIT) {
+            _mesa_write_alpha_span( ctx, n, x, y,
+                                    (const GLchan (*)[4])rgbaTmp, mask );
+         }
+      }
+   }
+
+   /* restore default dest buffer */
+   (void) (*ctx->Driver.SetDrawBuffer)( ctx, ctx->Color.DriverDrawBuffer );
+}
+
+
+
+/*
+ * Apply fragment processing to a span of RGBA fragments.
+ * Input:
+ *         n - number of fragments in the span
+ *         x,y - location of first (left) fragment
+ *         fog - array of fog factor values in [0,1]
+ */
+void
+_mesa_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                       const GLdepth z[], const GLfloat fog[],
+                       GLchan rgbaIn[][4], const GLfloat coverage[],
+                       GLenum primitive )
+{
+   const GLuint modBits = FOG_BIT | BLEND_BIT | MASKING_BIT |
+                          LOGIC_OP_BIT | TEXTURE_BIT;
+   GLubyte mask[MAX_WIDTH];
+   GLboolean write_all = GL_TRUE;
+   GLchan rgbaBackup[MAX_WIDTH][4];
+   GLchan (*rgba)[4];
+   const GLubyte *Null = 0;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   /* init mask to 1's (all pixels are to be written) */
+   MEMSET(mask, 1, n);
+
+   if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+      if ((n = clip_span( ctx,n,x,y,mask)) == 0) {
+         return;
+      }
+      if (mask[0] == 0)
+         write_all = GL_FALSE;
+   }
+
+   if ((primitive==GL_BITMAP && (swrast->_RasterMask & modBits))
+       || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
+      /* must make a copy of the colors since they may be modified */
+      MEMCPY( rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan) );
+      rgba = rgbaBackup;
+   }
+   else {
+      rgba = rgbaIn;
+   }
+
+   /* Do the scissor test */
+   if (ctx->Scissor.Enabled) {
+      if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+         return;
+      }
+      if (mask[0] == 0)
+	write_all = GL_FALSE;
+   }
+
+   /* Polygon Stippling */
+   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+      stipple_polygon_span( ctx, n, x, y, mask );
+      write_all = GL_FALSE;
+   }
+
+   /* Do the alpha test */
+   if (ctx->Color.AlphaEnabled) {
+      if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask ) == 0) {
+	 return;
+      }
+      write_all = GL_FALSE;
+   }
+
+   if (ctx->Stencil.Enabled) {
+      /* first stencil test */
+      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+	 return;
+      }
+      write_all = GL_FALSE;
+   }
+   else if (ctx->Depth.Test) {
+      /* regular depth testing */
+      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+      if (m == 0) {
+         return;
+      }
+      if (m < n) {
+         write_all = GL_FALSE;
+      }
+   }
+
+   /* if we get here, something passed the depth test */
+   ctx->OcclusionResult = GL_TRUE;
+
+   /* Per-pixel fog */
+   if (ctx->Fog.Enabled) {
+      if (fog && !swrast->_PreferPixelFog)
+	 _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+      else
+	 _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+   }
+
+   /* Antialias coverage application */
+   if (coverage) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+      }
+   }
+
+   if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+      multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+   }
+   else {
+      /* normal: write to exactly one buffer */
+      /* logic op or blending */
+      const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+
+      if (ctx->Color.ColorLogicOpEnabled) {
+         _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+      }
+      else if (ctx->Color.BlendEnabled) {
+         _mesa_blend_span( ctx, n, x, y, rgba, mask );
+      }
+
+      /* Color component masking */
+      if (colorMask == 0x0) {
+         return;
+      }
+      else if (colorMask != 0xffffffff) {
+         _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+      }
+
+      /* write pixels */
+      (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
+				    (const GLchan (*)[4]) rgba,
+				    write_all ? Null : mask );
+
+      if (swrast->_RasterMask & ALPHABUF_BIT) {
+         _mesa_write_alpha_span( ctx, n, x, y,
+                                 (const GLchan (*)[4]) rgba,
+                                 write_all ? Null : mask );
+      }
+   }
+}
+
+
+
+/*
+ * Write a horizontal span of color pixels to the frame buffer.
+ * The color is initially constant for the whole span.
+ * Alpha-testing, stenciling, depth-testing, and blending are done as needed.
+ * Input:  n - number of pixels in the span
+ *         x, y - location of leftmost pixel in the span
+ *         z - array of [n] z-values
+ *         fog - array of fog factor values in [0,1]
+ *         r, g, b, a - the color of the pixels
+ *         primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
+ */
+void
+_mesa_write_monocolor_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            const GLdepth z[], const GLfloat fog[],
+                            const GLchan color[4], const GLfloat coverage[],
+                            GLenum primitive )
+{
+   const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+   GLuint i;
+   GLubyte mask[MAX_WIDTH];
+   GLboolean write_all = GL_TRUE;
+   GLchan rgba[MAX_WIDTH][4];
+   const GLubyte *Null = 0;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   /* init mask to 1's (all pixels are to be written) */
+   MEMSET(mask, 1, n);
+
+   if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+      if ((n = clip_span( ctx,n,x,y,mask)) == 0) {
+	 return;
+      }
+      if (mask[0] == 0)
+         write_all = GL_FALSE;
+   }
+
+   /* Do the scissor test */
+   if (ctx->Scissor.Enabled) {
+      if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+         return;
+      }
+      if (mask[0] == 0)
+         write_all = GL_FALSE;
+   }
+
+   /* Polygon Stippling */
+   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+      stipple_polygon_span( ctx, n, x, y, mask );
+      write_all = GL_FALSE;
+   }
+
+   /* Do the alpha test */
+   if (ctx->Color.AlphaEnabled) {
+      for (i = 0; i < n; i++) {
+         rgba[i][ACOMP] = color[ACOMP];
+      }
+      if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask ) == 0) {
+	 return;
+      }
+      write_all = GL_FALSE;
+   }
+
+   if (ctx->Stencil.Enabled) {
+      /* first stencil test */
+      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+	 return;
+      }
+      write_all = GL_FALSE;
+   }
+   else if (ctx->Depth.Test) {
+      /* regular depth testing */
+      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+      if (m == 0) {
+         return;
+      }
+      if (m < n) {
+         write_all = GL_FALSE;
+      }
+   }
+
+   /* if we get here, something passed the depth test */
+   ctx->OcclusionResult = GL_TRUE;
+
+   if (ctx->Color.DrawBuffer == GL_NONE) {
+      /* write no pixels */
+      return;
+   }
+
+   if (ctx->Color.ColorLogicOpEnabled || colorMask != 0xffffffff ||
+       (swrast->_RasterMask & (BLEND_BIT | FOG_BIT)) || coverage) {
+      /* assign same color to each pixel */
+      for (i = 0; i < n; i++) {
+	 if (mask[i]) {
+            COPY_CHAN4(rgba[i], color);
+	 }
+      }
+
+      /* Per-pixel fog */
+      if (ctx->Fog.Enabled) {
+	 if (fog && !swrast->_PreferPixelFog)
+	    _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+	 else
+	    _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+      }
+
+      /* Antialias coverage application */
+      if (coverage) {
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+         }
+      }
+
+      if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+         multi_write_rgba_span( ctx, n, x, y,
+                                (const GLchan (*)[4]) rgba, mask );
+      }
+      else {
+         /* normal: write to exactly one buffer */
+         if (ctx->Color.ColorLogicOpEnabled) {
+            _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+         }
+         else if (ctx->Color.BlendEnabled) {
+            _mesa_blend_span( ctx, n, x, y, rgba, mask );
+         }
+
+         /* Color component masking */
+         if (colorMask == 0x0) {
+            return;
+         }
+         else if (colorMask != 0xffffffff) {
+            _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+         }
+
+         /* write pixels */
+         (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y,
+				       (const GLchan (*)[4]) rgba,
+				       write_all ? Null : mask );
+         if (swrast->_RasterMask & ALPHABUF_BIT) {
+            _mesa_write_alpha_span( ctx, n, x, y,
+                                    (const GLchan (*)[4]) rgba,
+                                    write_all ? Null : mask );
+         }
+      }
+   }
+   else {
+      /* same color for all pixels */
+      ASSERT(!ctx->Color.BlendEnabled);
+      ASSERT(!ctx->Color.ColorLogicOpEnabled);
+
+      if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+         for (i = 0; i < n; i++) {
+            if (mask[i]) {
+               COPY_CHAN4(rgba[i], color);
+            }
+         }
+         multi_write_rgba_span( ctx, n, x, y,
+				(const GLchan (*)[4]) rgba, mask );
+      }
+      else {
+         (*swrast->Driver.WriteMonoRGBASpan)( ctx, n, x, y, color, mask );
+         if (swrast->_RasterMask & ALPHABUF_BIT) {
+            _mesa_write_mono_alpha_span( ctx, n, x, y, (GLchan) color[ACOMP],
+                                         write_all ? Null : mask );
+         }
+      }
+   }
+}
+
+
+
+/*
+ * Add specular color to base color.  This is used only when
+ * GL_LIGHT_MODEL_COLOR_CONTROL = GL_SEPARATE_SPECULAR_COLOR.
+ */
+static void
+add_colors(GLuint n, GLchan rgba[][4], CONST GLchan specular[][4] )
+{
+   GLuint i;
+   for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+      /* no clamping */
+      rgba[i][RCOMP] += specular[i][RCOMP];
+      rgba[i][GCOMP] += specular[i][GCOMP];
+      rgba[i][BCOMP] += specular[i][BCOMP];
+#else
+      GLint r = rgba[i][RCOMP] + specular[i][RCOMP];
+      GLint g = rgba[i][GCOMP] + specular[i][GCOMP];
+      GLint b = rgba[i][BCOMP] + specular[i][BCOMP];
+      rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+      rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+      rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+#endif
+   }
+}
+
+
+/*
+ * Write a horizontal span of textured pixels to the frame buffer.
+ * The color of each pixel is different.
+ * Alpha-testing, stenciling, depth-testing, and blending are done
+ * as needed.
+ * Input:  n - number of pixels in the span
+ *         x, y - location of leftmost pixel in the span
+ *         z - array of [n] z-values
+ *         fog - array of fog factor values in [0,1]
+ *         s, t - array of (s,t) texture coordinates for each pixel
+ *         lambda - array of texture lambda values
+ *         rgba - array of [n] color components
+ *         primitive - either GL_POINT, GL_LINE, GL_POLYGON or GL_BITMAP.
+ */
+void
+_mesa_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLdepth z[], const GLfloat fog[],
+                          const GLfloat s[], const GLfloat t[],
+                          const GLfloat u[], GLfloat lambda[],
+                          GLchan rgbaIn[][4], CONST GLchan spec[][4],
+                          const GLfloat coverage[], GLenum primitive )
+{
+   const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+   GLubyte mask[MAX_WIDTH];
+   GLboolean write_all = GL_TRUE;
+   GLchan rgbaBackup[MAX_WIDTH][4];
+   GLchan (*rgba)[4];   /* points to either rgbaIn or rgbaBackup */
+   const GLubyte *Null = 0;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   /* init mask to 1's (all pixels are to be written) */
+   MEMSET(mask, 1, n);
+
+   if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+      if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
+	 return;
+      }
+      if (mask[0] == 0)
+	write_all = GL_FALSE;
+   }
+
+
+   if (primitive==GL_BITMAP || (swrast->_RasterMask & MULTI_DRAW_BIT)) {
+      /* must make a copy of the colors since they may be modified */
+      MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan));
+      rgba = rgbaBackup;
+   }
+   else {
+      rgba = rgbaIn;
+   }
+
+   /* Do the scissor test */
+   if (ctx->Scissor.Enabled) {
+      if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+         return;
+      }
+      if (mask[0] == 0)
+         write_all = GL_FALSE;
+   }
+
+   /* Polygon Stippling */
+   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+      stipple_polygon_span( ctx, n, x, y, mask );
+      write_all = GL_FALSE;
+   }
+
+   /* Texture with alpha test */
+   if (ctx->Color.AlphaEnabled) {
+      /* Texturing without alpha is done after depth-testing which
+         gives a potential speed-up. */
+      ASSERT(ctx->Texture._ReallyEnabled);
+      _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda,
+                                 (CONST GLchan (*)[4]) rgba, rgba );
+
+      /* Do the alpha test */
+      if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4]) rgba, mask ) == 0) {
+         return;
+      }
+      write_all = GL_FALSE;
+   }
+
+   if (ctx->Stencil.Enabled) {
+      /* first stencil test */
+      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+	 return;
+      }
+      write_all = GL_FALSE;
+   }
+   else if (ctx->Depth.Test) {
+      /* regular depth testing */
+      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+      if (m == 0) {
+         return;
+      }
+      if (m < n) {
+         write_all = GL_FALSE;
+      }
+   }
+
+   /* if we get here, something passed the depth test */
+   ctx->OcclusionResult = GL_TRUE;
+
+   /* Texture without alpha test */
+   if (! ctx->Color.AlphaEnabled) {
+      ASSERT(ctx->Texture._ReallyEnabled);
+      _swrast_texture_fragments( ctx, 0, n, s, t, u, lambda,
+                                 (CONST GLchan (*)[4]) rgba, rgba );
+   }
+
+   /* Add base and specular colors */
+   if (spec &&
+       (ctx->Fog.ColorSumEnabled ||
+	(ctx->Light.Enabled &&
+         ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
+      add_colors( n, rgba, spec );   /* rgba = rgba + spec */
+
+   /* Per-pixel fog */
+   if (ctx->Fog.Enabled) {
+      if (fog && !swrast->_PreferPixelFog)
+	 _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+      else
+	 _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+   }
+
+   /* Antialias coverage application */
+   if (coverage) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+      }
+   }
+
+   if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+      multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+   }
+   else {
+      /* normal: write to exactly one buffer */
+      if (ctx->Color.ColorLogicOpEnabled) {
+         _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+      }
+      else  if (ctx->Color.BlendEnabled) {
+         _mesa_blend_span( ctx, n, x, y, rgba, mask );
+      }
+      if (colorMask == 0x0) {
+         return;
+      }
+      else if (colorMask != 0xffffffff) {
+         _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+      }
+
+      (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba,
+				    write_all ? Null : mask );
+      if (swrast->_RasterMask & ALPHABUF_BIT) {
+         _mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4]) rgba,
+                                 write_all ? Null : mask );
+      }
+   }
+}
+
+
+
+/*
+ * As above but perform multiple stages of texture application.
+ */
+void
+_mesa_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                               const GLdepth z[], const GLfloat fog[],
+                               CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
+                               CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
+                               CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
+                               GLfloat lambda[][MAX_WIDTH],
+                               GLchan rgbaIn[MAX_TEXTURE_UNITS][4],
+                               CONST GLchan spec[MAX_TEXTURE_UNITS][4],
+                               const GLfloat coverage[],
+                               GLenum primitive )
+{
+   GLubyte mask[MAX_WIDTH];
+   GLboolean write_all = GL_TRUE;
+   GLchan rgbaBackup[MAX_WIDTH][4];
+   GLchan (*rgba)[4];   /* points to either rgbaIn or rgbaBackup */
+   GLuint i;
+   const GLubyte *Null = 0;
+   const GLuint texUnits = ctx->Const.MaxTextureUnits;
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+   /* init mask to 1's (all pixels are to be written) */
+   MEMSET(mask, 1, n);
+
+   if ((swrast->_RasterMask & WINCLIP_BIT) || primitive==GL_BITMAP) {
+      if ((n=clip_span(ctx, n, x, y, mask)) == 0) {
+	 return;
+      }
+      if (mask[0] == 0)
+	write_all = GL_FALSE;
+   }
+
+
+   if (primitive==GL_BITMAP || (swrast->_RasterMask & MULTI_DRAW_BIT)
+                            || texUnits > 1) {
+      /* must make a copy of the colors since they may be modified */
+      MEMCPY(rgbaBackup, rgbaIn, 4 * n * sizeof(GLchan));
+      rgba = rgbaBackup;
+   }
+   else {
+      rgba = rgbaIn;
+   }
+
+   /* Do the scissor test */
+   if (ctx->Scissor.Enabled) {
+      if ((n = _mesa_scissor_span( ctx, n, x, y, mask )) == 0) {
+         return;
+      }
+      if (mask[0] == 0)
+         write_all = GL_FALSE;
+   }
+
+   /* Polygon Stippling */
+   if (ctx->Polygon.StippleFlag && primitive==GL_POLYGON) {
+      stipple_polygon_span( ctx, n, x, y, mask );
+      write_all = GL_FALSE;
+   }
+
+   /* Texture with alpha test */
+   if (ctx->Color.AlphaEnabled) {
+      /* Texturing without alpha is done after depth-testing which
+       * gives a potential speed-up.
+       */
+      ASSERT(ctx->Texture._ReallyEnabled);
+      for (i = 0; i < texUnits; i++)
+         _swrast_texture_fragments( ctx, i, n, s[i], t[i], u[i], lambda[i],
+                                    (CONST GLchan (*)[4]) rgbaIn, rgba );
+
+      /* Do the alpha test */
+      if (_mesa_alpha_test( ctx, n, (const GLchan (*)[4])rgba, mask ) == 0) {
+         return;
+      }
+      write_all = GL_FALSE;
+   }
+
+   if (ctx->Stencil.Enabled) {
+      /* first stencil test */
+      if (_mesa_stencil_and_ztest_span(ctx, n, x, y, z, mask) == GL_FALSE) {
+	 return;
+      }
+      write_all = GL_FALSE;
+   }
+   else if (ctx->Depth.Test) {
+      /* regular depth testing */
+      GLuint m = _mesa_depth_test_span( ctx, n, x, y, z, mask );
+      if (m == 0) {
+         return;
+      }
+      if (m < n) {
+         write_all = GL_FALSE;
+      }
+   }
+
+   /* if we get here, something passed the depth test */
+   ctx->OcclusionResult = GL_TRUE;
+
+   /* Texture without alpha test */
+   if (! ctx->Color.AlphaEnabled) {
+      ASSERT(ctx->Texture._ReallyEnabled);
+      for (i = 0; i < texUnits; i++)
+         _swrast_texture_fragments( ctx, i, n, s[i], t[i], u[i], lambda[i],
+                                    (CONST GLchan (*)[4]) rgbaIn, rgba );
+   }
+
+   /* Add base and specular colors */
+   if (spec &&
+       (ctx->Fog.ColorSumEnabled ||
+	(ctx->Light.Enabled &&
+	 ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)))
+      add_colors( n, rgba, spec );   /* rgba = rgba + spec */
+
+   /* Per-pixel fog */
+   if (ctx->Fog.Enabled) {
+      if (fog && !swrast->_PreferPixelFog)
+	 _mesa_fog_rgba_pixels( ctx, n, fog, rgba );
+      else
+	 _mesa_depth_fog_rgba_pixels( ctx, n, z, rgba );
+   }
+
+   /* Antialias coverage application */
+   if (coverage) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         rgba[i][ACOMP] = (GLchan) (rgba[i][ACOMP] * coverage[i]);
+      }
+   }
+
+   if (swrast->_RasterMask & MULTI_DRAW_BIT) {
+      multi_write_rgba_span( ctx, n, x, y, (const GLchan (*)[4]) rgba, mask );
+   }
+   else {
+      /* normal: write to exactly one buffer */
+      const GLuint colorMask = *((GLuint *) ctx->Color.ColorMask);
+
+      if (ctx->Color.ColorLogicOpEnabled) {
+         _mesa_logicop_rgba_span( ctx, n, x, y, rgba, mask );
+      }
+      else  if (ctx->Color.BlendEnabled) {
+         _mesa_blend_span( ctx, n, x, y, rgba, mask );
+      }
+
+      if (colorMask == 0x0) {
+         return;
+      }
+      else if (colorMask != 0xffffffff) {
+         _mesa_mask_rgba_span( ctx, n, x, y, rgba );
+      }
+
+      (*swrast->Driver.WriteRGBASpan)( ctx, n, x, y, (const GLchan (*)[4])rgba,
+                                    write_all ? Null : mask );
+      if (swrast->_RasterMask & ALPHABUF_BIT) {
+         _mesa_write_alpha_span( ctx, n, x, y, (const GLchan (*)[4])rgba,
+                                 write_all ? Null : mask );
+      }
+   }
+}
+
+
+
+/*
+ * Read RGBA pixels from frame buffer.  Clipping will be done to prevent
+ * reading ouside the buffer's boundaries.
+ */
+void
+_mesa_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
+                      GLuint n, GLint x, GLint y, GLchan rgba[][4] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLint bufWidth = (GLint) buffer->Width;
+   const GLint bufHeight = (GLint) buffer->Height;
+
+   if (y < 0 || y >= bufHeight || x + (GLint) n < 0 || x >= bufWidth) {
+      /* completely above, below, or right */
+      /* XXX maybe leave undefined? */
+      BZERO(rgba, 4 * n * sizeof(GLchan));
+   }
+   else {
+      GLint skip, length;
+      if (x < 0) {
+         /* left edge clippping */
+         skip = -x;
+         length = (GLint) n - skip;
+         if (length < 0) {
+            /* completely left of window */
+            return;
+         }
+         if (length > bufWidth) {
+            length = buffer->Width;
+         }
+      }
+      else if ((GLint) (x + n) > bufWidth) {
+         /* right edge clipping */
+         skip = 0;
+         length = bufWidth - x;
+         if (length < 0) {
+            /* completely to right of window */
+            return;
+         }
+      }
+      else {
+         /* no clipping */
+         skip = 0;
+         length = (GLint) n;
+      }
+
+      (*swrast->Driver.ReadRGBASpan)( ctx, length, x + skip, y, rgba + skip );
+      if (buffer->UseSoftwareAlphaBuffers) {
+         _mesa_read_alpha_span( ctx, length, x + skip, y, rgba + skip );
+      }
+   }
+}
+
+
+
+
+/*
+ * Read CI pixels from frame buffer.  Clipping will be done to prevent
+ * reading ouside the buffer's boundaries.
+ */
+void
+_mesa_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
+                       GLuint n, GLint x, GLint y, GLuint indx[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLint bufWidth = (GLint) buffer->Width;
+   const GLint bufHeight = (GLint) buffer->Height;
+
+   if (y < 0 || y >= bufHeight || x + (GLint) n < 0 || x >= bufWidth) {
+      /* completely above, below, or right */
+      BZERO(indx, n * sizeof(GLuint));
+   }
+   else {
+      GLint skip, length;
+      if (x < 0) {
+         /* left edge clippping */
+         skip = -x;
+         length = (GLint) n - skip;
+         if (length < 0) {
+            /* completely left of window */
+            return;
+         }
+         if (length > bufWidth) {
+            length = bufWidth;
+         }
+      }
+      else if ((GLint) (x + n) > bufWidth) {
+         /* right edge clipping */
+         skip = 0;
+         length = bufWidth - x;
+         if (length < 0) {
+            /* completely to right of window */
+            return;
+         }
+      }
+      else {
+         /* no clipping */
+         skip = 0;
+         length = (GLint) n;
+      }
+
+      (*swrast->Driver.ReadCI32Span)( ctx, length, skip + x, y, indx + skip );
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_span.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_span.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_span.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,93 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_SPAN_H
+#define S_SPAN_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void
+_mesa_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                        const GLdepth z[], const GLfloat fog[],
+                        GLuint index[], const GLint coverage[],
+                        GLenum primitive );
+
+
+extern void
+_mesa_write_monoindex_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            const GLdepth z[], const GLfloat fog[],
+                            GLuint index, const GLint coverage[],
+                            GLenum primitive );
+
+
+extern void
+_mesa_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                       const GLdepth z[], const GLfloat fog[],
+                       GLchan rgba[][4], const GLfloat coverage[],
+                       GLenum primitive );
+
+
+extern void
+_mesa_write_monocolor_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            const GLdepth z[], const GLfloat fog[],
+                            const GLchan color[4], const GLfloat coverage[],
+                            GLenum primitive );
+
+
+extern void
+_mesa_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLdepth z[], const GLfloat fog[],
+                          const GLfloat s[], const GLfloat t[],
+                          const GLfloat u[], GLfloat lambda[],
+                          GLchan rgba[][4], CONST GLchan spec[][4],
+                          const GLfloat coverage[], GLenum primitive );
+
+
+extern void
+_mesa_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                               const GLdepth z[], const GLfloat fog[],
+                               CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
+                               CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
+                               CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
+                               GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH],
+                               GLchan rgba[][4], CONST GLchan spec[][4],
+                               const GLfloat coverage[],  GLenum primitive );
+
+
+extern void
+_mesa_read_rgba_span( GLcontext *ctx, GLframebuffer *buffer,
+                      GLuint n, GLint x, GLint y, GLchan rgba[][4] );
+
+
+extern void
+_mesa_read_index_span( GLcontext *ctx, GLframebuffer *buffer,
+                       GLuint n, GLint x, GLint y, GLuint indx[] );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_stencil.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_stencil.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_stencil.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,1308 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_pb.h"
+#include "s_stencil.h"
+
+
+
+
+
+/* Stencil Logic:
+
+IF stencil test fails THEN
+   Apply fail-op to stencil value
+   Don't write the pixel (RGBA,Z)
+ELSE
+   IF doing depth test && depth test fails THEN
+      Apply zfail-op to stencil value
+      Write RGBA and Z to appropriate buffers
+   ELSE
+      Apply zpass-op to stencil value
+ENDIF
+
+*/
+
+
+
+
+/*
+ * Return the address of a stencil buffer value given the window coords:
+ */
+#define STENCIL_ADDRESS(X,Y)  \
+       (ctx->DrawBuffer->Stencil + ctx->DrawBuffer->Width * (Y) + (X))
+
+
+
+/*
+ * Apply the given stencil operator to the array of stencil values.
+ * Don't touch stencil[i] if mask[i] is zero.
+ * Input:  n - size of stencil array
+ *         oper - the stencil buffer operator
+ *         stencil - array of stencil values
+ *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator
+ * Output:  stencil - modified values
+ */
+static void apply_stencil_op( const GLcontext *ctx, GLenum oper,
+                              GLuint n, GLstencil stencil[],
+                              const GLubyte mask[] )
+{
+   const GLstencil ref = ctx->Stencil.Ref;
+   const GLstencil wrtmask = ctx->Stencil.WriteMask;
+   const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
+   GLuint i;
+
+   switch (oper) {
+      case GL_KEEP:
+         /* do nothing */
+         break;
+      case GL_ZERO:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  stencil[i] = 0;
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  stencil[i] = (GLstencil) (stencil[i] & invmask);
+	       }
+	    }
+	 }
+	 break;
+      case GL_REPLACE:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  stencil[i] = ref;
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  GLstencil s = stencil[i];
+		  stencil[i] = (GLstencil) ((invmask & s ) | (wrtmask & ref));
+	       }
+	    }
+	 }
+	 break;
+      case GL_INCR:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  GLstencil s = stencil[i];
+		  if (s < STENCIL_MAX) {
+		     stencil[i] = (GLstencil) (s+1);
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  /* VERIFY logic of adding 1 to a write-masked value */
+		  GLstencil s = stencil[i];
+		  if (s < STENCIL_MAX) {
+		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_DECR:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  GLstencil s = stencil[i];
+		  if (s>0) {
+		     stencil[i] = (GLstencil) (s-1);
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  /* VERIFY logic of subtracting 1 to a write-masked value */
+		  GLstencil s = stencil[i];
+		  if (s>0) {
+		     stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_INCR_WRAP_EXT:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  stencil[i]++;
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil s = stencil[i];
+                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s+1)));
+	       }
+	    }
+	 }
+	 break;
+      case GL_DECR_WRAP_EXT:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  stencil[i]--;
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil s = stencil[i];
+                  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & (s-1)));
+	       }
+	    }
+	 }
+	 break;
+      case GL_INVERT:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  GLstencil s = stencil[i];
+		  stencil[i] = (GLstencil) ~s;
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+		  GLstencil s = stencil[i];
+		  stencil[i] = (GLstencil) ((invmask & s) | (wrtmask & ~s));
+	       }
+	    }
+	 }
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad stencil op in apply_stencil_op");
+   }
+}
+
+
+
+
+/*
+ * Apply stencil test to an array of stencil values (before depth buffering).
+ * Input:  n - number of pixels in the array
+ *         stencil - array of [n] stencil values
+ *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel
+ * Output:  mask - pixels which fail the stencil test will have their
+ *                 mask flag set to 0.
+ *          stencil - updated stencil values (where the test passed)
+ * Return:  GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed.
+ */
+static GLboolean
+do_stencil_test( GLcontext *ctx, GLuint n, GLstencil stencil[],
+                 GLubyte mask[] )
+{
+   GLubyte fail[PB_SIZE];
+   GLboolean allfail = GL_FALSE;
+   GLuint i;
+   GLstencil r, s;
+
+   ASSERT(n <= PB_SIZE);
+
+   /*
+    * Perform stencil test.  The results of this operation are stored
+    * in the fail[] array:
+    *   IF fail[i] is non-zero THEN
+    *       the stencil fail operator is to be applied
+    *   ELSE
+    *       the stencil fail operator is not to be applied
+    *   ENDIF
+    */
+   switch (ctx->Stencil.Function) {
+      case GL_NEVER:
+         /* always fail */
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       mask[i] = 0;
+	       fail[i] = 1;
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 allfail = GL_TRUE;
+	 break;
+      case GL_LESS:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       if (r < s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       if (r <= s) {
+		  /* pass */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       if (r > s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       if (r >= s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       if (r == s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       s = (GLstencil) (stencil[i] & ctx->Stencil.ValueMask);
+	       if (r != s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 /* always pass */
+	 for (i=0;i<n;i++) {
+	    fail[i] = 0;
+	 }
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad stencil func in gl_stencil_span");
+         return 0;
+   }
+
+   if (ctx->Stencil.FailFunc != GL_KEEP) {
+      apply_stencil_op( ctx, ctx->Stencil.FailFunc, n, stencil, fail );
+   }
+
+   return !allfail;
+}
+
+
+
+
+/*
+ * Apply stencil and depth testing to an array of pixels.
+ * Hardware or software stencil buffer acceptable.
+ * Input:  n - number of pixels in the span
+ *         z - array [n] of z values
+ *         stencil - array [n] of stencil values
+ *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
+ * Output:  stencil - modified stencil values
+ *          mask - array [n] of flags (1=stencil and depth test passed)
+ * Return: GL_TRUE - all fragments failed the testing
+ *         GL_FALSE - one or more fragments passed the testing
+ *
+ */
+static GLboolean
+stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                        const GLdepth z[], GLstencil stencil[],
+                        GLubyte mask[] )
+{
+   ASSERT(ctx->Stencil.Enabled);
+   ASSERT(n <= PB_SIZE);
+
+   /*
+    * Apply the stencil test to the fragments.
+    * failMask[i] is 1 if the stencil test failed.
+    */
+   if (do_stencil_test( ctx, n, stencil, mask ) == GL_FALSE) {
+      /* all fragments failed the stencil test, we're done. */
+      return GL_FALSE;
+   }
+
+
+   /*
+    * Some fragments passed the stencil test, apply depth test to them
+    * and apply Zpass and Zfail stencil ops.
+    */
+   if (ctx->Depth.Test==GL_FALSE) {
+      /*
+       * No depth buffer, just apply zpass stencil function to active pixels.
+       */
+      apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, mask );
+   }
+   else {
+      /*
+       * Perform depth buffering, then apply zpass or zfail stencil function.
+       */
+      GLubyte passmask[MAX_WIDTH], failmask[MAX_WIDTH], oldmask[MAX_WIDTH];
+      GLuint i;
+
+      /* save the current mask bits */
+      MEMCPY(oldmask, mask, n * sizeof(GLubyte));
+
+      /* apply the depth test */
+      _mesa_depth_test_span(ctx, n, x, y, z, mask);
+
+      /* Set the stencil pass/fail flags according to result of depth testing.
+       * if oldmask[i] == 0 then
+       *    Don't touch the stencil value
+       * else if oldmask[i] and newmask[i] then
+       *    Depth test passed
+       * else
+       *    assert(oldmask[i] && !newmask[i])
+       *    Depth test failed
+       * endif
+       */
+      for (i=0;i<n;i++) {
+         ASSERT(mask[i] == 0 || mask[i] == 1);
+         passmask[i] = oldmask[i] & mask[i];
+         failmask[i] = oldmask[i] & (mask[i] ^ 1);
+      }
+
+      /* apply the pass and fail operations */
+      if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+         apply_stencil_op( ctx, ctx->Stencil.ZFailFunc, n, stencil, failmask );
+      }
+      if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+         apply_stencil_op( ctx, ctx->Stencil.ZPassFunc, n, stencil, passmask );
+      }
+   }
+
+   return GL_TRUE;  /* one or more fragments passed both tests */
+}
+
+
+
+/*
+ * Apply stencil and depth testing to the span of pixels.
+ * Both software and hardware stencil buffers are acceptable.
+ * Input:  n - number of pixels in the span
+ *         x, y - location of leftmost pixel in span
+ *         z - array [n] of z values
+ *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
+ * Output:  mask - array [n] of flags (1=stencil and depth test passed)
+ * Return: GL_TRUE - all fragments failed the testing
+ *         GL_FALSE - one or more fragments passed the testing
+ *
+ */
+GLboolean
+_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                              const GLdepth z[], GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLstencil stencilRow[MAX_WIDTH];
+   GLstencil *stencil;
+   GLboolean result;
+
+   ASSERT(ctx->Stencil.Enabled);
+   ASSERT(n <= MAX_WIDTH);
+
+   /* Get initial stencil values */
+   if (swrast->Driver.WriteStencilSpan) {
+      ASSERT(swrast->Driver.ReadStencilSpan);
+      /* Get stencil values from the hardware stencil buffer */
+      (*swrast->Driver.ReadStencilSpan)(ctx, n, x, y, stencilRow);
+      stencil = stencilRow;
+   }
+   else {
+      /* software stencil buffer */
+      stencil = STENCIL_ADDRESS(x, y);
+   }
+
+   /* do all the stencil/depth testing/updating */
+   result = stencil_and_ztest_span( ctx, n, x, y, z, stencil, mask );
+
+   if (swrast->Driver.WriteStencilSpan) {
+      /* Write updated stencil values into hardware stencil buffer */
+      (swrast->Driver.WriteStencilSpan)(ctx, n, x, y, stencil, mask );
+   }
+
+   return result;
+}
+
+
+
+
+/*
+ * Apply the given stencil operator for each pixel in the array whose
+ * mask flag is set.  This is for software stencil buffers only.
+ * Input:  n - number of pixels in the span
+ *         x, y - array of [n] pixels
+ *         operator - the stencil buffer operator
+ *         mask - array [n] of flag:  1=apply operator, 0=don't apply operator
+ */
+static void
+apply_stencil_op_to_pixels( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            GLenum oper, const GLubyte mask[] )
+{
+   const GLstencil ref = ctx->Stencil.Ref;
+   const GLstencil wrtmask = ctx->Stencil.WriteMask;
+   const GLstencil invmask = (GLstencil) (~ctx->Stencil.WriteMask);
+   GLuint i;
+
+   ASSERT(!SWRAST_CONTEXT(ctx)->Driver.WriteStencilSpan);  /* software stencil buffer only! */
+
+   switch (oper) {
+      case GL_KEEP:
+         /* do nothing */
+         break;
+      case GL_ZERO:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = 0;
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+		  *sptr = (GLstencil) (invmask & *sptr);
+	       }
+	    }
+	 }
+	 break;
+      case GL_REPLACE:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = ref;
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+		  *sptr = (GLstencil) ((invmask & *sptr ) | (wrtmask & ref));
+	       }
+	    }
+	 }
+	 break;
+      case GL_INCR:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+		  if (*sptr < STENCIL_MAX) {
+		     *sptr = (GLstencil) (*sptr + 1);
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+		  if (*sptr < STENCIL_MAX) {
+		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_DECR:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+		  if (*sptr>0) {
+		     *sptr = (GLstencil) (*sptr - 1);
+		  }
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+		  if (*sptr>0) {
+		     *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
+		  }
+	       }
+	    }
+	 }
+	 break;
+      case GL_INCR_WRAP_EXT:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = (GLstencil) (*sptr + 1);
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr+1)));
+	       }
+	    }
+	 }
+	 break;
+      case GL_DECR_WRAP_EXT:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = (GLstencil) (*sptr - 1);
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & (*sptr-1)));
+	       }
+	    }
+	 }
+	 break;
+      case GL_INVERT:
+	 if (invmask==0) {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = (GLstencil) (~*sptr);
+	       }
+	    }
+	 }
+	 else {
+	    for (i=0;i<n;i++) {
+	       if (mask[i]) {
+                  GLstencil *sptr = STENCIL_ADDRESS( x[i], y[i] );
+                  *sptr = (GLstencil) ((invmask & *sptr) | (wrtmask & ~*sptr));
+	       }
+	    }
+	 }
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad stencilop in apply_stencil_op_to_pixels");
+   }
+}
+
+
+
+/*
+ * Apply stencil test to an array of pixels before depth buffering.
+ * Used for software stencil buffer only.
+ * Input:  n - number of pixels in the span
+ *         x, y - array of [n] pixels to stencil
+ *         mask - array [n] of flag:  0=skip the pixel, 1=stencil the pixel
+ * Output:  mask - pixels which fail the stencil test will have their
+ *                 mask flag set to 0.
+ * Return:  0 = all pixels failed, 1 = zero or more pixels passed.
+ */
+static GLboolean
+stencil_test_pixels( GLcontext *ctx, GLuint n,
+                     const GLint x[], const GLint y[], GLubyte mask[] )
+{
+   GLubyte fail[PB_SIZE];
+   GLstencil r, s;
+   GLuint i;
+   GLboolean allfail = GL_FALSE;
+
+   ASSERT(!SWRAST_CONTEXT(ctx)->Driver.WriteStencilSpan);  /* software stencil buffer only! */
+
+   /*
+    * Perform stencil test.  The results of this operation are stored
+    * in the fail[] array:
+    *   IF fail[i] is non-zero THEN
+    *       the stencil fail operator is to be applied
+    *   ELSE
+    *       the stencil fail operator is not to be applied
+    *   ENDIF
+    */
+
+   switch (ctx->Stencil.Function) {
+      case GL_NEVER:
+         /* always fail */
+         for (i=0;i<n;i++) {
+	    if (mask[i]) {
+	       mask[i] = 0;
+	       fail[i] = 1;
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 allfail = GL_TRUE;
+	 break;
+      case GL_LESS:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       if (r < s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_LEQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       if (r <= s) {
+		  /* pass */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_GREATER:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       if (r > s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_GEQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       if (r >= s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_EQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       if (r == s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_NOTEQUAL:
+	 r = (GLstencil) (ctx->Stencil.Ref & ctx->Stencil.ValueMask);
+	 for (i=0;i<n;i++) {
+	    if (mask[i]) {
+               GLstencil *sptr = STENCIL_ADDRESS(x[i],y[i]);
+	       s = (GLstencil) (*sptr & ctx->Stencil.ValueMask);
+	       if (r != s) {
+		  /* passed */
+		  fail[i] = 0;
+	       }
+	       else {
+		  fail[i] = 1;
+		  mask[i] = 0;
+	       }
+	    }
+	    else {
+	       fail[i] = 0;
+	    }
+	 }
+	 break;
+      case GL_ALWAYS:
+	 /* always pass */
+	 for (i=0;i<n;i++) {
+	    fail[i] = 0;
+	 }
+	 break;
+      default:
+         _mesa_problem(ctx, "Bad stencil func in gl_stencil_pixels");
+         return 0;
+   }
+
+   if (ctx->Stencil.FailFunc != GL_KEEP) {
+      apply_stencil_op_to_pixels( ctx, n, x, y, ctx->Stencil.FailFunc, fail );
+   }
+
+   return !allfail;
+}
+
+
+
+
+/*
+ * Apply stencil and depth testing to an array of pixels.
+ * This is used both for software and hardware stencil buffers.
+ *
+ * The comments in this function are a bit sparse but the code is
+ * almost identical to stencil_and_ztest_span(), which is well
+ * commented.
+ *
+ * Input:  n - number of pixels in the array
+ *         x, y - array of [n] pixel positions
+ *         z - array [n] of z values
+ *         mask - array [n] of flags  (1=test this pixel, 0=skip the pixel)
+ * Output: mask - array [n] of flags (1=stencil and depth test passed)
+ * Return: GL_TRUE - all fragments failed the testing
+ *         GL_FALSE - one or more fragments passed the testing
+ */
+GLboolean
+_mesa_stencil_and_ztest_pixels( GLcontext *ctx,
+                                GLuint n, const GLint x[], const GLint y[],
+                                const GLdepth z[], GLubyte mask[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   ASSERT(ctx->Stencil.Enabled);
+   ASSERT(n <= PB_SIZE);
+
+   if (swrast->Driver.WriteStencilPixels) {
+      /*** Hardware stencil buffer ***/
+      GLstencil stencil[PB_SIZE];
+      GLubyte origMask[PB_SIZE];
+
+      ASSERT(swrast->Driver.ReadStencilPixels);
+      (*swrast->Driver.ReadStencilPixels)(ctx, n, x, y, stencil);
+
+      MEMCPY(origMask, mask, n * sizeof(GLubyte));
+
+      (void) do_stencil_test(ctx, n, stencil, mask);
+
+      if (ctx->Depth.Test == GL_FALSE) {
+         apply_stencil_op(ctx, ctx->Stencil.ZPassFunc, n, stencil, mask);
+      }
+      else {
+         _mesa_depth_test_pixels(ctx, n, x, y, z, mask);
+
+         if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+            GLubyte failmask[PB_SIZE];
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               ASSERT(mask[i] == 0 || mask[i] == 1);
+               failmask[i] = origMask[i] & (mask[i] ^ 1);
+            }
+            apply_stencil_op(ctx, ctx->Stencil.ZFailFunc,
+                             n, stencil, failmask);
+         }
+         if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+            GLubyte passmask[PB_SIZE];
+            GLuint i;
+            for (i = 0; i < n; i++) {
+               ASSERT(mask[i] == 0 || mask[i] == 1);
+               passmask[i] = origMask[i] & mask[i];
+            }
+            apply_stencil_op(ctx, ctx->Stencil.ZPassFunc,
+                             n, stencil, passmask);
+         }
+      }
+
+      /* Write updated stencil values into hardware stencil buffer */
+      (swrast->Driver.WriteStencilPixels)(ctx, n, x, y, stencil, origMask);
+
+      return GL_TRUE;
+   }
+   else {
+      /*** Software stencil buffer ***/
+
+      if (stencil_test_pixels(ctx, n, x, y, mask) == GL_FALSE) {
+         /* all fragments failed the stencil test, we're done. */
+         return GL_FALSE;
+      }
+
+      if (ctx->Depth.Test==GL_FALSE) {
+         apply_stencil_op_to_pixels(ctx, n, x, y,
+                                    ctx->Stencil.ZPassFunc, mask);
+      }
+      else {
+         GLubyte passmask[PB_SIZE], failmask[PB_SIZE], oldmask[PB_SIZE];
+         GLuint i;
+
+         MEMCPY(oldmask, mask, n * sizeof(GLubyte));
+
+         _mesa_depth_test_pixels(ctx, n, x, y, z, mask);
+
+         for (i=0;i<n;i++) {
+            ASSERT(mask[i] == 0 || mask[i] == 1);
+            passmask[i] = oldmask[i] & mask[i];
+            failmask[i] = oldmask[i] & (mask[i] ^ 1);
+         }
+
+         if (ctx->Stencil.ZFailFunc != GL_KEEP) {
+            apply_stencil_op_to_pixels(ctx, n, x, y,
+                                       ctx->Stencil.ZFailFunc, failmask);
+         }
+         if (ctx->Stencil.ZPassFunc != GL_KEEP) {
+            apply_stencil_op_to_pixels(ctx, n, x, y,
+                                       ctx->Stencil.ZPassFunc, passmask);
+         }
+      }
+
+      return GL_TRUE;  /* one or more fragments passed both tests */
+   }
+}
+
+
+
+/*
+ * Return a span of stencil values from the stencil buffer.
+ * Used for glRead/CopyPixels
+ * Input:  n - how many pixels
+ *         x,y - location of first pixel
+ * Output:  stencil - the array of stencil values
+ */
+void
+_mesa_read_stencil_span( GLcontext *ctx,
+                         GLint n, GLint x, GLint y, GLstencil stencil[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   if (y < 0 || y >= (GLint) ctx->DrawBuffer->Height ||
+       x + n <= 0 || x >= (GLint) ctx->DrawBuffer->Width) {
+      /* span is completely outside framebuffer */
+      return; /* undefined values OK */
+   }
+
+   if (x < 0) {
+      GLint dx = -x;
+      x = 0;
+      n -= dx;
+      stencil += dx;
+   }
+   if (x + n > (GLint) ctx->DrawBuffer->Width) {
+      GLint dx = x + n - (GLint) ctx->DrawBuffer->Width;
+      n -= dx;
+   }
+   if (n <= 0) {
+      return;
+   }
+
+
+   ASSERT(n >= 0);
+   if (swrast->Driver.ReadStencilSpan) {
+      (*swrast->Driver.ReadStencilSpan)( ctx, (GLuint) n, x, y, stencil );
+   }
+   else if (ctx->DrawBuffer->Stencil) {
+      const GLstencil *s = STENCIL_ADDRESS( x, y );
+#if STENCIL_BITS == 8
+      MEMCPY( stencil, s, n * sizeof(GLstencil) );
+#else
+      GLuint i;
+      for (i=0;i<n;i++)
+         stencil[i] = s[i];
+#endif
+   }
+}
+
+
+
+/*
+ * Write a span of stencil values to the stencil buffer.
+ * Used for glDraw/CopyPixels
+ * Input:  n - how many pixels
+ *         x, y - location of first pixel
+ *         stencil - the array of stencil values
+ */
+void
+_mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
+                          const GLstencil stencil[] )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLstencil *ssrc = stencil;
+
+   if (y < 0 || y >= (GLint) ctx->DrawBuffer->Height ||
+       x + n <= 0 || x >= (GLint) ctx->DrawBuffer->Width) {
+      /* span is completely outside framebuffer */
+      return; /* undefined values OK */
+   }
+
+   if (x < 0) {
+      GLint dx = -x;
+      x = 0;
+      n -= dx;
+      ssrc += dx;
+   }
+   if (x + n > (GLint) ctx->DrawBuffer->Width) {
+      GLint dx = x + n - (GLint) ctx->DrawBuffer->Width;
+      n -= dx;
+   }
+   if (n <= 0) {
+      return;
+   }
+
+   if (swrast->Driver.WriteStencilSpan) {
+      (*swrast->Driver.WriteStencilSpan)( ctx, n, x, y, ssrc, NULL );
+   }
+   else if (ctx->DrawBuffer->Stencil) {
+      GLstencil *s = STENCIL_ADDRESS( x, y );
+#if STENCIL_BITS == 8
+      MEMCPY( s, ssrc, n * sizeof(GLstencil) );
+#else
+      GLuint i;
+      for (i=0;i<n;i++)
+         s[i] = ssrc[i];
+#endif
+   }
+}
+
+
+
+/*
+ * Allocate a new stencil buffer.  If there's an old one it will be
+ * deallocated first.  The new stencil buffer will be uninitialized.
+ */
+void
+_mesa_alloc_stencil_buffer( GLframebuffer *buffer )
+{
+   /* deallocate current stencil buffer if present */
+   if (buffer->Stencil) {
+      MESA_PBUFFER_FREE(buffer->Stencil);
+      buffer->Stencil = NULL;
+   }
+
+   /* allocate new stencil buffer */
+   buffer->Stencil = (GLstencil *) MESA_PBUFFER_ALLOC(buffer->Width * buffer->Height
+                                          * sizeof(GLstencil));
+   if (!buffer->Stencil) {
+      /* out of memory */
+      _mesa_error( NULL, GL_OUT_OF_MEMORY, "_mesa_alloc_stencil_buffer" );
+   }
+}
+
+
+
+/*
+ * Clear the software (malloc'd) stencil buffer.
+ */
+static void
+clear_software_stencil_buffer( GLcontext *ctx )
+{
+   if (ctx->Visual.stencilBits==0 || !ctx->DrawBuffer->Stencil) {
+      /* no stencil buffer */
+      return;
+   }
+
+   if (ctx->Scissor.Enabled) {
+      /* clear scissor region only */
+      const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+         /* must apply mask to the clear */
+         GLint y;
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
+            const GLstencil mask = ctx->Stencil.WriteMask;
+            const GLstencil invMask = ~mask;
+            const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->_Xmin, y );
+            GLint i;
+            for (i = 0; i < width; i++) {
+               stencil[i] = (stencil[i] & invMask) | clearVal;
+            }
+         }
+      }
+      else {
+         /* no masking */
+         GLint y;
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
+            GLstencil *stencil = STENCIL_ADDRESS( ctx->DrawBuffer->_Xmin, y );
+#if STENCIL_BITS==8
+            MEMSET( stencil, ctx->Stencil.Clear, width * sizeof(GLstencil) );
+#else
+            GLint i;
+            for (i = 0; i < width; i++)
+               stencil[x] = ctx->Stencil.Clear;
+#endif
+         }
+      }
+   }
+   else {
+      /* clear whole stencil buffer */
+      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+         /* must apply mask to the clear */
+         const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+         GLstencil *stencil = ctx->DrawBuffer->Stencil;
+         const GLstencil mask = ctx->Stencil.WriteMask;
+         const GLstencil invMask = ~mask;
+         const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            stencil[i] = (stencil[i] & invMask) | clearVal;
+         }
+      }
+      else {
+         /* clear whole buffer without masking */
+         const GLuint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+         GLstencil *stencil = ctx->DrawBuffer->Stencil;
+
+#if STENCIL_BITS==8
+         MEMSET(stencil, ctx->Stencil.Clear, n * sizeof(GLstencil) );
+#else
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            stencil[i] = ctx->Stencil.Clear;
+         }
+#endif
+      }
+   }
+}
+
+
+
+/*
+ * Clear the hardware (in graphics card) stencil buffer.
+ * This is done with the Driver.WriteStencilSpan() and Driver.ReadStencilSpan()
+ * functions.
+ * Actually, if there is a hardware stencil buffer it really should have
+ * been cleared in Driver.Clear()!  However, if the hardware does not
+ * support scissored clears or masked clears (i.e. glStencilMask) then
+ * we have to use the span-based functions.
+ */
+static void
+clear_hardware_stencil_buffer( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   ASSERT(swrast->Driver.WriteStencilSpan);
+   ASSERT(swrast->Driver.ReadStencilSpan);
+
+   if (ctx->Scissor.Enabled) {
+      /* clear scissor region only */
+      const GLint x = ctx->DrawBuffer->_Xmin;
+      const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+         /* must apply mask to the clear */
+         GLint y;
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
+            const GLstencil mask = ctx->Stencil.WriteMask;
+            const GLstencil invMask = ~mask;
+            const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+            GLstencil stencil[MAX_WIDTH];
+            GLint i;
+            (*swrast->Driver.ReadStencilSpan)(ctx, width, x, y, stencil);
+            for (i = 0; i < width; i++) {
+               stencil[i] = (stencil[i] & invMask) | clearVal;
+            }
+            (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
+         }
+      }
+      else {
+         /* no masking */
+         GLstencil stencil[MAX_WIDTH];
+         GLint y, i;
+         for (i = 0; i < width; i++) {
+            stencil[i] = ctx->Stencil.Clear;
+         }
+         for (y = ctx->DrawBuffer->_Ymin; y < ctx->DrawBuffer->_Ymax; y++) {
+            (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
+         }
+      }
+   }
+   else {
+      /* clear whole stencil buffer */
+      if (ctx->Stencil.WriteMask != STENCIL_MAX) {
+         /* must apply mask to the clear */
+         const GLstencil mask = ctx->Stencil.WriteMask;
+         const GLstencil invMask = ~mask;
+         const GLstencil clearVal = (ctx->Stencil.Clear & mask);
+         const GLint width = ctx->DrawBuffer->Width;
+         const GLint height = ctx->DrawBuffer->Height;
+         const GLint x = ctx->DrawBuffer->_Xmin;
+         GLint y;
+         for (y = 0; y < height; y++) {
+            GLstencil stencil[MAX_WIDTH];
+            GLint i;
+            (*swrast->Driver.ReadStencilSpan)(ctx, width, x, y, stencil);
+            for (i = 0; i < width; i++) {
+               stencil[i] = (stencil[i] & invMask) | clearVal;
+            }
+            (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
+         }
+      }
+      else {
+         /* clear whole buffer without masking */
+         const GLint width = ctx->DrawBuffer->Width;
+         const GLint height = ctx->DrawBuffer->Height;
+         const GLint x = ctx->DrawBuffer->_Xmin;
+         GLstencil stencil[MAX_WIDTH];
+         GLint y, i;
+         for (i = 0; i < width; i++) {
+            stencil[i] = ctx->Stencil.Clear;
+         }
+         for (y = 0; y < height; y++) {
+            (*swrast->Driver.WriteStencilSpan)(ctx, width, x, y, stencil, NULL);
+         }
+      }
+   }
+}
+
+
+
+/*
+ * Clear the stencil buffer.
+ */
+void
+_mesa_clear_stencil_buffer( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   if (swrast->Driver.WriteStencilSpan) {
+      ASSERT(swrast->Driver.ReadStencilSpan);
+      clear_hardware_stencil_buffer(ctx);
+   }
+   else {
+      clear_software_stencil_buffer(ctx);
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_stencil.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_stencil.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_stencil.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,63 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_STENCIL_H
+#define S_STENCIL_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern GLboolean
+_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                              const GLdepth z[], GLubyte mask[] );
+
+extern GLboolean
+_mesa_stencil_and_ztest_pixels( GLcontext *ctx, GLuint n,
+                                const GLint x[], const GLint y[],
+                                const GLdepth z[], GLubyte mask[] );
+
+
+extern void
+_mesa_read_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
+                         GLstencil stencil[] );
+
+
+extern void
+_mesa_write_stencil_span( GLcontext *ctx, GLint n, GLint x, GLint y,
+                          const GLstencil stencil[] );
+
+
+extern void
+_mesa_alloc_stencil_buffer( GLframebuffer *buffer );
+
+
+extern void
+_mesa_clear_stencil_buffer( GLcontext *ctx );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_texstore.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_texstore.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_texstore.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,480 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.4
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Authors:
+ *   Brian Paul
+ */
+
+
+/*
+ * The functions in this file are mostly related to software texture fallbacks.
+ * This includes texture image transfer/packing and texel fetching.
+ * Hardware drivers will likely override most of this.
+ */
+
+
+
+#include "colormac.h"
+#include "context.h"
+#include "convolve.h"
+#include "image.h"
+#include "macros.h"
+#include "mem.h"
+#include "texformat.h"
+#include "teximage.h"
+#include "texstore.h"
+
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_span.h"
+
+/*
+ * Read an RGBA image from the frame buffer.
+ * This is used by glCopyTex[Sub]Image[12]D().
+ * Input:  ctx - the context
+ *         x, y - lower left corner
+ *         width, height - size of region to read
+ * Return: pointer to block of GL_RGBA, GLchan data.
+ */
+static GLchan *
+read_color_image( GLcontext *ctx, GLint x, GLint y,
+                  GLsizei width, GLsizei height )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLint stride, i;
+   GLchan *image, *dst;
+
+   image = (GLchan *) MALLOC(width * height * 4 * sizeof(GLchan));
+   if (!image)
+      return NULL;
+
+   /* Select buffer to read from */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->ReadBuffer,
+                                 ctx->Pixel.DriverReadBuffer );
+
+   RENDER_START(swrast,ctx);
+
+   dst = image;
+   stride = width * 4;
+   for (i = 0; i < height; i++) {
+      _mesa_read_rgba_span( ctx, ctx->ReadBuffer, width, x, y + i,
+                         (GLchan (*)[4]) dst );
+      dst += stride;
+   }
+
+   RENDER_FINISH(swrast,ctx);
+
+   /* Read from draw buffer (the default) */
+   (*swrast->Driver.SetReadBuffer)( ctx, ctx->DrawBuffer,
+                                 ctx->Color.DriverDrawBuffer );
+
+   return image;
+}
+
+
+/*
+ * As above, but read data from depth buffer.
+ */
+static GLfloat *
+read_depth_image( GLcontext *ctx, GLint x, GLint y,
+                  GLsizei width, GLsizei height )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   GLfloat *image, *dst;
+   GLint i;
+
+   image = (GLfloat *) MALLOC(width * height * sizeof(GLfloat));
+   if (!image)
+      return NULL;
+
+   RENDER_START(swrast,ctx);
+
+   dst = image;
+   for (i = 0; i < height; i++) {
+      _mesa_read_depth_span_float(ctx, width, x, y + i, dst);
+      dst += width;
+   }
+
+   RENDER_FINISH(swrast,ctx);
+
+   return image;
+}
+
+
+
+static GLboolean
+is_depth_format(GLenum format)
+{
+   switch (format) {
+      case GL_DEPTH_COMPONENT:
+      case GL_DEPTH_COMPONENT16_SGIX:
+      case GL_DEPTH_COMPONENT24_SGIX:
+      case GL_DEPTH_COMPONENT32_SGIX:
+         return GL_TRUE;
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+/*
+ * Fallback for Driver.CopyTexImage1D().
+ */
+void
+_swrast_copy_teximage1d( GLcontext *ctx, GLenum target, GLint level,
+                       GLenum internalFormat,
+                       GLint x, GLint y, GLsizei width, GLint border )
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   ASSERT(texObj);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   ASSERT(texImage);
+
+   ASSERT(ctx->Driver.TexImage1D);
+
+   if (is_depth_format(internalFormat)) {
+      /* read depth image from framebuffer */
+      GLfloat *image = read_depth_image(ctx, x, y, width, 1);
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
+         return;
+      }
+
+      /* call glTexImage1D to redefine the texture */
+      (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
+                                width, border,
+                                GL_DEPTH_COMPONENT, GL_FLOAT, image,
+                                &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+   else {
+      /* read RGBA image from framebuffer */
+      GLchan *image = read_color_image(ctx, x, y, width, 1);
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage1D");
+         return;
+      }
+
+      /* call glTexImage1D to redefine the texture */
+      (*ctx->Driver.TexImage1D)(ctx, target, level, internalFormat,
+                                width, border,
+                                GL_RGBA, CHAN_TYPE, image,
+                                &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target, texUnit, texObj);
+   }
+}
+
+
+/*
+ * Fallback for Driver.CopyTexImage2D().
+ */
+void
+_swrast_copy_teximage2d( GLcontext *ctx, GLenum target, GLint level,
+                       GLenum internalFormat,
+                       GLint x, GLint y, GLsizei width, GLsizei height,
+                       GLint border )
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   ASSERT(texObj);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   ASSERT(texImage);
+
+   ASSERT(ctx->Driver.TexImage2D);
+
+   if (is_depth_format(internalFormat)) {
+      /* read depth image from framebuffer */
+      GLfloat *image = read_depth_image(ctx, x, y, width, height);
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
+         return;
+      }
+
+      /* call glTexImage2D to redefine the texture */
+      (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
+                                width, height, border,
+                                GL_DEPTH_COMPONENT, GL_FLOAT, image,
+                                &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+   else {
+      /* read RGBA image from framebuffer */
+      GLchan *image = read_color_image(ctx, x, y, width, height);
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexImage2D");
+         return;
+      }
+
+      /* call glTexImage2D to redefine the texture */
+      (*ctx->Driver.TexImage2D)(ctx, target, level, internalFormat,
+                                width, height, border,
+                                GL_RGBA, CHAN_TYPE, image,
+                                &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target, texUnit, texObj);
+   }
+}
+
+
+/*
+ * Fallback for Driver.CopyTexSubImage1D().
+ */
+void
+_swrast_copy_texsubimage1d(GLcontext *ctx, GLenum target, GLint level,
+                         GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   ASSERT(texObj);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   ASSERT(texImage);
+
+   ASSERT(ctx->Driver.TexImage1D);
+
+   if (texImage->Format != GL_DEPTH_COMPONENT) {
+      /* read RGBA image from framebuffer */
+      GLchan *image = read_color_image(ctx, x, y, width, 1);
+      if (!image) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage1D" );
+         return;
+      }
+
+#if 0
+      /*
+       * XXX this is a bit of a hack.  We need to be sure that the alpha
+       * channel is 1.0 if the internal texture format is not supposed to
+       * have an alpha channel.  This is because some drivers may store
+       * RGB textures as RGBA and the texutil.c code isn't smart enough
+       * to set the alpha channel to 1.0 in this situation.
+       */
+      if (texImage->Format == GL_LUMINANCE ||
+          texImage->Format == GL_RGB) {
+         const GLuint n = width * 4;
+         GLuint i;
+         for (i = 0; i < n; i += 4) {
+            image[i + 3] = CHAN_MAX;
+         }
+      }
+#endif
+      /* now call glTexSubImage1D to do the real work */
+      (*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
+                                   GL_RGBA, CHAN_TYPE, image,
+                                   &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+   else {
+      /* read depth image from framebuffer */
+      GLfloat *image = read_depth_image(ctx, x, y, width, 1);
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage1D");
+         return;
+      }
+
+      /* call glTexSubImage1D to redefine the texture */
+      (*ctx->Driver.TexSubImage1D)(ctx, target, level, xoffset, width,
+                                   GL_DEPTH_COMPONENT, GL_FLOAT, image,
+                                   &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target, texUnit, texObj);
+   }
+}
+
+
+/*
+ * Fallback for Driver.CopyTexSubImage2D().
+ */
+void
+_swrast_copy_texsubimage2d( GLcontext *ctx,
+                          GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset,
+                          GLint x, GLint y, GLsizei width, GLsizei height )
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   ASSERT(texObj);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   ASSERT(texImage);
+
+   ASSERT(ctx->Driver.TexImage2D);
+
+   if (texImage->Format != GL_DEPTH_COMPONENT) {
+      /* read RGBA image from framebuffer */
+      GLchan *image = read_color_image(ctx, x, y, width, height);
+      if (!image) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D" );
+         return;
+      }
+
+#if  0
+      /*
+       * XXX this is a bit of a hack.  We need to be sure that the alpha
+       * channel is 1.0 if the internal texture format is not supposed to
+       * have an alpha channel.  This is because some drivers may store
+       * RGB textures as RGBA and the texutil.c code isn't smart enough
+       * to set the alpha channel to 1.0 in this situation.
+       */
+      if (texImage->Format == GL_LUMINANCE ||
+          texImage->Format == GL_RGB) {
+         const GLuint n = width * height * 4;
+         GLuint i;
+         for (i = 0; i < n; i += 4) {
+            image[i + 3] = CHAN_MAX;
+         }
+      }
+#endif
+      /* now call glTexSubImage2D to do the real work */
+      (*ctx->Driver.TexSubImage2D)(ctx, target, level,
+                                   xoffset, yoffset, width, height,
+                                   GL_RGBA, CHAN_TYPE, image,
+                                   &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+   else {
+      /* read depth image from framebuffer */
+      GLfloat *image = read_depth_image(ctx, x, y, width, height);
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage2D");
+         return;
+      }
+
+      /* call glTexImage1D to redefine the texture */
+      (*ctx->Driver.TexSubImage2D)(ctx, target, level,
+                                   xoffset, yoffset, width, height,
+                                   GL_DEPTH_COMPONENT, GL_FLOAT, image,
+                                   &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target, texUnit, texObj);
+   }
+}
+
+
+/*
+ * Fallback for Driver.CopyTexSubImage3D().
+ */
+void
+_swrast_copy_texsubimage3d( GLcontext *ctx,
+                          GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset, GLint zoffset,
+                          GLint x, GLint y, GLsizei width, GLsizei height )
+{
+   struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+
+   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   ASSERT(texObj);
+   texImage = _mesa_select_tex_image(ctx, texUnit, target, level);
+   ASSERT(texImage);
+
+   ASSERT(ctx->Driver.TexImage3D);
+
+   if (texImage->Format != GL_DEPTH_COMPONENT) {
+      /* read RGBA image from framebuffer */
+      GLchan *image = read_color_image(ctx, x, y, width, height);
+      if (!image) {
+         _mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage3D" );
+         return;
+      }
+#if 0
+      /*
+       * XXX this is a bit of a hack.  We need to be sure that the alpha
+       * channel is 1.0 if the internal texture format is not supposed to
+       * have an alpha channel.  This is because some drivers may store
+       * RGB textures as RGBA and the texutil.c code isn't smart enough
+       * to set the alpha channel to 1.0 in this situation.
+       */
+      if (texImage->Format == GL_LUMINANCE ||
+          texImage->Format == GL_RGB) {
+         const GLuint n = width * height * 4;
+         GLuint i;
+         for (i = 0; i < n; i += 4) {
+            image[i + 3] = CHAN_MAX;
+         }
+      }
+#endif
+      /* now call glTexSubImage3D to do the real work */
+      (*ctx->Driver.TexSubImage3D)(ctx, target, level,
+                                   xoffset, yoffset, zoffset, width, height, 1,
+                                   GL_RGBA, CHAN_TYPE, image,
+                                   &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+   else {
+      /* read depth image from framebuffer */
+      GLfloat *image = read_depth_image(ctx, x, y, width, height);
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage3D");
+         return;
+      }
+
+      /* call glTexImage1D to redefine the texture */
+      (*ctx->Driver.TexSubImage3D)(ctx, target, level,
+                                   xoffset, yoffset, zoffset, width, height, 1,
+                                   GL_DEPTH_COMPONENT, GL_FLOAT, image,
+                                   &_mesa_native_packing, texObj, texImage);
+      FREE(image);
+   }
+
+   /* GL_SGIS_generate_mipmap */
+   if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
+      _mesa_generate_mipmap(ctx, target, texUnit, texObj);
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_texture.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_texture.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_texture.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,3262 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.5
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mem.h"
+#include "texformat.h"
+#include "teximage.h"
+
+#include "s_context.h"
+#include "s_pb.h"
+#include "s_texture.h"
+
+
+/*
+ * These values are used in the fixed-point arithmetic used
+ * for linear filtering.
+ */
+#define WEIGHT_SCALE 65536.0F
+#define WEIGHT_SHIFT 16
+
+
+/*
+ * Used to compute texel locations for linear sampling.
+ * Input:
+ *    wrapMode = GL_REPEAT, GL_CLAMP, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER_ARB
+ *    S = texcoord in [0,1]
+ *    SIZE = width (or height or depth) of texture
+ * Output:
+ *    U = texcoord in [0, width]
+ *    I0, I1 = two nearest texel indexes
+ */
+#define COMPUTE_LINEAR_TEXEL_LOCATIONS(wrapMode, S, U, SIZE, I0, I1)	\
+{									\
+   if (wrapMode == GL_REPEAT) {						\
+      U = S * SIZE - 0.5F;						\
+      I0 = IFLOOR(U) & (SIZE - 1);					\
+      I1 = (I0 + 1) & (SIZE - 1);					\
+   }									\
+   else if (wrapMode == GL_CLAMP_TO_EDGE) {				\
+      if (S <= 0.0F)							\
+         U = 0.0F;							\
+      else if (S >= 1.0F)						\
+         U = (GLfloat) SIZE;						\
+      else								\
+         U = S * SIZE;							\
+      U -= 0.5F;							\
+      I0 = IFLOOR(U);							\
+      I1 = I0 + 1;							\
+      if (I0 < 0)							\
+         I0 = 0;							\
+      if (I1 >= (GLint) SIZE)						\
+         I1 = SIZE - 1;							\
+   }									\
+   else  if (wrapMode == GL_CLAMP_TO_BORDER_ARB) {			\
+      const GLfloat min = -1.0F / (2.0F * SIZE);			\
+      const GLfloat max = 1.0F - min;					\
+      if (S <= min)							\
+         U = min * SIZE;						\
+      else if (S >= max)						\
+         U = max * SIZE;						\
+      else								\
+         U = S * SIZE;							\
+      U -= 0.5F;							\
+      I0 = IFLOOR(U);							\
+      I1 = I0 + 1;							\
+   }									\
+   else if (wrapMode == GL_MIRRORED_REPEAT_ARB) {			\
+      const GLint flr = IFLOOR(S);					\
+      if (flr & 1)							\
+         U = 1.0F - (S - (GLfloat) flr);	/* flr is odd */	\
+      else								\
+         U = S - (GLfloat) flr;		/* flr is even */		\
+      U = (U * SIZE) - 0.5;						\
+      I0 = IFLOOR(U);							\
+      I1 = I0 + 1;							\
+      if (I0 < 0)							\
+         I0 = 0;							\
+      if (I1 >= (GLint) SIZE)						\
+         I1 = SIZE - 1;							\
+   }									\
+   else {								\
+      ASSERT(wrapMode == GL_CLAMP);					\
+      if (S <= 0.0F)							\
+         U = 0.0F;							\
+      else if (S >= 1.0F)						\
+         U = (GLfloat) SIZE;						\
+      else								\
+         U = S * SIZE;							\
+      U -= 0.5F;							\
+      I0 = IFLOOR(U);							\
+      I1 = I0 + 1;							\
+   }									\
+}
+
+
+/*
+ * Used to compute texel location for nearest sampling.
+ */
+#define COMPUTE_NEAREST_TEXEL_LOCATION(wrapMode, S, SIZE, I)		\
+{									\
+   if (wrapMode == GL_REPEAT) {						\
+      /* s limited to [0,1) */						\
+      /* i limited to [0,size-1] */					\
+      I = IFLOOR(S * SIZE);						\
+      I &= (SIZE - 1);							\
+   }									\
+   else if (wrapMode == GL_CLAMP_TO_EDGE) {				\
+      /* s limited to [min,max] */					\
+      /* i limited to [0, size-1] */					\
+      const GLfloat min = 1.0F / (2.0F * SIZE);				\
+      const GLfloat max = 1.0F - min;					\
+      if (S < min)							\
+         I = 0;								\
+      else if (S > max)							\
+         I = SIZE - 1;							\
+      else								\
+         I = IFLOOR(S * SIZE);						\
+   }									\
+   else if (wrapMode == GL_CLAMP_TO_BORDER_ARB) {			\
+      /* s limited to [min,max] */					\
+      /* i limited to [-1, size] */					\
+      const GLfloat min = -1.0F / (2.0F * SIZE);			\
+      const GLfloat max = 1.0F - min;					\
+      if (S <= min)							\
+         I = -1;							\
+      else if (S >= max)						\
+         I = SIZE;							\
+      else								\
+         I = IFLOOR(S * SIZE);						\
+   }									\
+   else if (wrapMode == GL_MIRRORED_REPEAT_ARB) {			\
+      const GLfloat min = 1.0F / (2.0F * SIZE);				\
+      const GLfloat max = 1.0F - min;					\
+      const GLint flr = IFLOOR(S);					\
+      GLfloat u;							\
+      if (flr & 1)							\
+         u = 1.0F - (S - (GLfloat) flr);	/* flr is odd */	\
+      else								\
+         u = S - (GLfloat) flr;		/* flr is even */		\
+      if (u < min)							\
+         I = 0;								\
+      else if (u > max)							\
+         I = SIZE - 1;							\
+      else								\
+         I = IFLOOR(u * SIZE);						\
+   }									\
+   else {								\
+      ASSERT(wrapMode == GL_CLAMP);					\
+      /* s limited to [0,1] */						\
+      /* i limited to [0,size-1] */					\
+      if (S <= 0.0F)							\
+         I = 0;								\
+      else if (S >= 1.0F)						\
+         I = SIZE - 1;							\
+      else								\
+         I = IFLOOR(S * SIZE);						\
+   }									\
+}
+
+
+/*
+ * Compute linear mipmap levels for given lambda.
+ */
+#define COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level)	\
+{								\
+   if (lambda < 0.0F)						\
+      lambda = 0.0F;						\
+   else if (lambda > tObj->_MaxLambda)				\
+      lambda = tObj->_MaxLambda;				\
+   level = (GLint) (tObj->BaseLevel + lambda);			\
+}
+
+
+/*
+ * Compute nearest mipmap level for given lambda.
+ */
+#define COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level)	\
+{								\
+   if (lambda <= 0.5F)						\
+      lambda = 0.0F;						\
+   else if (lambda > tObj->_MaxLambda + 0.4999F)		\
+      lambda = tObj->_MaxLambda + 0.4999F;			\
+   level = (GLint) (tObj->BaseLevel + lambda + 0.5F);		\
+   if (level > tObj->_MaxLevel)					\
+      level = tObj->_MaxLevel;					\
+}
+
+
+
+/*
+ * Note, the FRAC macro has to work perfectly.  Otherwise you'll sometimes
+ * see 1-pixel bands of improperly weighted linear-sampled texels.  The
+ * tests/texwrap.c demo is a good test.
+ * Also note, FRAC(x) doesn't truly return the fractional part of x for x < 0.
+ * Instead, if x < 0 then FRAC(x) = 1 - true_frac(x).
+ */
+#define FRAC(f)  ((f) - IFLOOR(f))
+
+
+
+/*
+ * Bitflags for texture border color sampling.
+ */
+#define I0BIT   1
+#define I1BIT   2
+#define J0BIT   4
+#define J1BIT   8
+#define K0BIT  16
+#define K1BIT  32
+
+
+
+/*
+ * Get texture palette entry.
+ */
+static void
+palette_sample(const GLcontext *ctx,
+               const struct gl_texture_object *tObj,
+               GLint index, GLchan rgba[4] )
+{
+   const GLchan *palette;
+   GLenum format;
+
+   if (ctx->Texture.SharedPalette) {
+      ASSERT(!ctx->Texture.Palette.FloatTable);
+      palette = (const GLchan *) ctx->Texture.Palette.Table;
+      format = ctx->Texture.Palette.Format;
+   }
+   else {
+      ASSERT(!tObj->Palette.FloatTable);
+      palette = (const GLchan *) tObj->Palette.Table;
+      format = tObj->Palette.Format;
+   }
+
+   switch (format) {
+      case GL_ALPHA:
+         rgba[ACOMP] = palette[index];
+         return;
+      case GL_LUMINANCE:
+      case GL_INTENSITY:
+         rgba[RCOMP] = palette[index];
+         return;
+      case GL_LUMINANCE_ALPHA:
+         rgba[RCOMP] = palette[(index << 1) + 0];
+         rgba[ACOMP] = palette[(index << 1) + 1];
+         return;
+      case GL_RGB:
+         rgba[RCOMP] = palette[index * 3 + 0];
+         rgba[GCOMP] = palette[index * 3 + 1];
+         rgba[BCOMP] = palette[index * 3 + 2];
+         return;
+      case GL_RGBA:
+         rgba[RCOMP] = palette[(index << 2) + 0];
+         rgba[GCOMP] = palette[(index << 2) + 1];
+         rgba[BCOMP] = palette[(index << 2) + 2];
+         rgba[ACOMP] = palette[(index << 2) + 3];
+         return;
+      default:
+         _mesa_problem(ctx, "Bad palette format in palette_sample");
+   }
+}
+
+
+
+/**********************************************************************/
+/*                    1-D Texture Sampling Functions                  */
+/**********************************************************************/
+
+/*
+ * Return the texture sample for coordinate (s) using GL_NEAREST filter.
+ */
+static void
+sample_1d_nearest(GLcontext *ctx,
+                  const struct gl_texture_object *tObj,
+                  const struct gl_texture_image *img,
+                  GLfloat s, GLchan rgba[4])
+{
+   const GLint width = img->Width2;  /* without border, power of two */
+   GLint i;
+
+   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width, i);
+
+   /* skip over the border, if any */
+   i += img->Border;
+
+   if (i < 0 || i >= (GLint) img->Width) {
+      /* Need this test for GL_CLAMP_TO_BORDER_ARB mode */
+      COPY_CHAN4(rgba, tObj->BorderColor);
+   }
+   else {
+      (*img->FetchTexel)(img, i, 0, 0, (GLvoid *) rgba);
+      if (img->Format == GL_COLOR_INDEX) {
+         palette_sample(ctx, tObj, rgba[0], rgba);
+      }
+   }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s) using GL_LINEAR filter.
+ */
+static void
+sample_1d_linear(GLcontext *ctx,
+                 const struct gl_texture_object *tObj,
+                 const struct gl_texture_image *img,
+                 GLfloat s, GLchan rgba[4])
+{
+   const GLint width = img->Width2;
+   GLint i0, i1;
+   GLfloat u;
+   GLuint useBorderColor;
+
+   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width, i0, i1);
+
+   useBorderColor = 0;
+   if (img->Border) {
+      i0 += img->Border;
+      i1 += img->Border;
+   }
+   else {
+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
+   }
+
+   {
+      const GLfloat a = FRAC(u);
+
+#if CHAN_TYPE == GL_FLOAT || CHAN_TYPE == GL_UNSIGNED_SHORT
+      const GLfloat w0 = (1.0F-a);
+      const GLfloat w1 =       a ;
+#else /* CHAN_BITS == 8 */
+      /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
+      const GLint w0 = IROUND_POS((1.0F - a) * WEIGHT_SCALE);
+      const GLint w1 = IROUND_POS(        a  * WEIGHT_SCALE);
+#endif
+      GLchan t0[4], t1[4];  /* texels */
+
+      if (useBorderColor & I0BIT) {
+         COPY_CHAN4(t0, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i0, 0, 0, (GLvoid *) t0);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t0[0], t0);
+         }
+      }
+      if (useBorderColor & I1BIT) {
+         COPY_CHAN4(t1, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i1, 0, 0, (GLvoid *) t1);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t1[0], t1);
+         }
+      }
+
+#if CHAN_TYPE == GL_FLOAT
+      rgba[0] = w0 * t0[0] + w1 * t1[0];
+      rgba[1] = w0 * t0[1] + w1 * t1[1];
+      rgba[2] = w0 * t0[2] + w1 * t1[2];
+      rgba[3] = w0 * t0[3] + w1 * t1[3];
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      rgba[0] = (GLchan) (w0 * t0[0] + w1 * t1[0] + 0.5);
+      rgba[1] = (GLchan) (w0 * t0[1] + w1 * t1[1] + 0.5);
+      rgba[2] = (GLchan) (w0 * t0[2] + w1 * t1[2] + 0.5);
+      rgba[3] = (GLchan) (w0 * t0[3] + w1 * t1[3] + 0.5);
+#else /* CHAN_BITS == 8 */
+      rgba[0] = (GLchan) ((w0 * t0[0] + w1 * t1[0]) >> WEIGHT_SHIFT);
+      rgba[1] = (GLchan) ((w0 * t0[1] + w1 * t1[1]) >> WEIGHT_SHIFT);
+      rgba[2] = (GLchan) ((w0 * t0[2] + w1 * t1[2]) >> WEIGHT_SHIFT);
+      rgba[3] = (GLchan) ((w0 * t0[3] + w1 * t1[3]) >> WEIGHT_SHIFT);
+#endif
+
+   }
+}
+
+
+static void
+sample_1d_nearest_mipmap_nearest(GLcontext *ctx,
+                                 const struct gl_texture_object *tObj,
+                                 GLfloat s, GLfloat lambda,
+                                 GLchan rgba[4])
+{
+   GLint level;
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+   sample_1d_nearest(ctx, tObj, tObj->Image[level], s, rgba);
+}
+
+
+static void
+sample_1d_linear_mipmap_nearest(GLcontext *ctx,
+                                const struct gl_texture_object *tObj,
+                                GLfloat s, GLfloat lambda,
+                                GLchan rgba[4])
+{
+   GLint level;
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+   sample_1d_linear(ctx, tObj, tObj->Image[level], s, rgba);
+}
+
+
+
+/*
+ * This is really just needed in order to prevent warnings with some compilers.
+ */
+#if CHAN_TYPE == GL_FLOAT
+#define INTCAST
+#else
+#define INTCAST (GLint)
+#endif
+
+
+static void
+sample_1d_nearest_mipmap_linear(GLcontext *ctx,
+                                const struct gl_texture_object *tObj,
+                                GLfloat s, GLfloat lambda,
+                                GLchan rgba[4])
+{
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_1d_nearest(ctx, tObj, tObj->Image[tObj->_MaxLevel], s, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];
+      const GLfloat f = FRAC(lambda);
+      sample_1d_nearest(ctx, tObj, tObj->Image[level  ], s, t0);
+      sample_1d_nearest(ctx, tObj, tObj->Image[level+1], s, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+
+static void
+sample_1d_linear_mipmap_linear(GLcontext *ctx,
+                               const struct gl_texture_object *tObj,
+                               GLfloat s, GLfloat lambda,
+                               GLchan rgba[4])
+{
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_1d_linear(ctx, tObj, tObj->Image[tObj->_MaxLevel], s, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];
+      const GLfloat f = FRAC(lambda);
+      sample_1d_linear(ctx, tObj, tObj->Image[level  ], s, t0);
+      sample_1d_linear(ctx, tObj, tObj->Image[level+1], s, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+
+static void
+sample_nearest_1d( GLcontext *ctx, GLuint texUnit,
+                   const struct gl_texture_object *tObj, GLuint n,
+                   const GLfloat s[], const GLfloat t[],
+                   const GLfloat u[], const GLfloat lambda[],
+                   GLchan rgba[][4] )
+{
+   GLuint i;
+   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+   (void) t;
+   (void) u;
+   (void) lambda;
+   for (i=0;i<n;i++) {
+      sample_1d_nearest(ctx, tObj, image, s[i], rgba[i]);
+   }
+}
+
+
+
+static void
+sample_linear_1d( GLcontext *ctx, GLuint texUnit,
+                  const struct gl_texture_object *tObj, GLuint n,
+                  const GLfloat s[], const GLfloat t[],
+                  const GLfloat u[], const GLfloat lambda[],
+                  GLchan rgba[][4] )
+{
+   GLuint i;
+   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+   (void) t;
+   (void) u;
+   (void) lambda;
+   for (i=0;i<n;i++) {
+      sample_1d_linear(ctx, tObj, image, s[i], rgba[i]);
+   }
+}
+
+
+/*
+ * Given an (s) texture coordinate and lambda (level of detail) value,
+ * return a texture sample.
+ *
+ */
+static void
+sample_lambda_1d( GLcontext *ctx, GLuint texUnit,
+                  const struct gl_texture_object *tObj, GLuint n,
+                  const GLfloat s[], const GLfloat t[],
+                  const GLfloat u[], const GLfloat lambda[],
+                  GLchan rgba[][4] )
+{
+   GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
+   GLuint i;
+
+   (void) t;
+   (void) u;
+
+   for (i=0;i<n;i++) {
+      if (lambda[i] > MinMagThresh) {
+         /* minification */
+         switch (tObj->MinFilter) {
+            case GL_NEAREST:
+               sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                 s[i], rgba[i]);
+               break;
+            case GL_LINEAR:
+               sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                s[i], rgba[i]);
+               break;
+            case GL_NEAREST_MIPMAP_NEAREST:
+               sample_1d_nearest_mipmap_nearest(ctx, tObj, lambda[i], s[i],
+                                                rgba[i]);
+               break;
+            case GL_LINEAR_MIPMAP_NEAREST:
+               sample_1d_linear_mipmap_nearest(ctx, tObj, s[i], lambda[i],
+                                               rgba[i]);
+               break;
+            case GL_NEAREST_MIPMAP_LINEAR:
+               sample_1d_nearest_mipmap_linear(ctx, tObj, s[i], lambda[i],
+                                               rgba[i]);
+               break;
+            case GL_LINEAR_MIPMAP_LINEAR:
+               sample_1d_linear_mipmap_linear(ctx, tObj, s[i], lambda[i],
+                                              rgba[i]);
+               break;
+            default:
+               _mesa_problem(NULL, "Bad min filter in sample_1d_texture");
+               return;
+         }
+      }
+      else {
+         /* magnification */
+         switch (tObj->MagFilter) {
+            case GL_NEAREST:
+               sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                 s[i], rgba[i]);
+               break;
+            case GL_LINEAR:
+               sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                s[i], rgba[i]);
+               break;
+            default:
+               _mesa_problem(NULL, "Bad mag filter in sample_1d_texture");
+               return;
+         }
+      }
+   }
+}
+
+
+
+
+/**********************************************************************/
+/*                    2-D Texture Sampling Functions                  */
+/**********************************************************************/
+
+
+/*
+ * Return the texture sample for coordinate (s,t) using GL_NEAREST filter.
+ */
+static void
+sample_2d_nearest(GLcontext *ctx,
+                  const struct gl_texture_object *tObj,
+                  const struct gl_texture_image *img,
+                  GLfloat s, GLfloat t,
+                  GLchan rgba[])
+{
+   const GLint width = img->Width2;    /* without border, power of two */
+   const GLint height = img->Height2;  /* without border, power of two */
+   GLint i, j;
+
+   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width,  i);
+   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, t, height, j);
+
+   /* skip over the border, if any */
+   i += img->Border;
+   j += img->Border;
+
+   if (i < 0 || i >= (GLint) img->Width || j < 0 || j >= (GLint) img->Height) {
+      /* Need this test for GL_CLAMP_TO_BORDER_ARB mode */
+      COPY_CHAN4(rgba, tObj->BorderColor);
+   }
+   else {
+      (*img->FetchTexel)(img, i, j, 0, (GLvoid *) rgba);
+      if (img->Format == GL_COLOR_INDEX) {
+         palette_sample(ctx, tObj, rgba[0], rgba);
+      }
+   }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s,t) using GL_LINEAR filter.
+ * New sampling code contributed by Lynn Quam <quam@ai.sri.com>.
+ */
+static void
+sample_2d_linear(GLcontext *ctx,
+                 const struct gl_texture_object *tObj,
+                 const struct gl_texture_image *img,
+                 GLfloat s, GLfloat t,
+                 GLchan rgba[])
+{
+   const GLint width = img->Width2;
+   const GLint height = img->Height2;
+   GLint i0, j0, i1, j1;
+   GLuint useBorderColor;
+   GLfloat u, v;
+
+   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width,  i0, i1);
+   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, t, v, height, j0, j1);
+
+   useBorderColor = 0;
+   if (img->Border) {
+      i0 += img->Border;
+      i1 += img->Border;
+      j0 += img->Border;
+      j1 += img->Border;
+   }
+   else {
+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
+   }
+
+   {
+      const GLfloat a = FRAC(u);
+      const GLfloat b = FRAC(v);
+
+#if CHAN_TYPE == GL_FLOAT || CHAN_TYPE == GL_UNSIGNED_SHORT
+      const GLfloat w00 = (1.0F-a) * (1.0F-b);
+      const GLfloat w10 =       a  * (1.0F-b);
+      const GLfloat w01 = (1.0F-a) *       b ;
+      const GLfloat w11 =       a  *       b ;
+#else /* CHAN_BITS == 8 */
+      /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
+      const GLint w00 = IROUND_POS((1.0F-a) * (1.0F-b) * WEIGHT_SCALE);
+      const GLint w10 = IROUND_POS(      a  * (1.0F-b) * WEIGHT_SCALE);
+      const GLint w01 = IROUND_POS((1.0F-a) *       b  * WEIGHT_SCALE);
+      const GLint w11 = IROUND_POS(      a  *       b  * WEIGHT_SCALE);
+#endif
+      GLchan t00[4];
+      GLchan t10[4];
+      GLchan t01[4];
+      GLchan t11[4];
+
+      if (useBorderColor & (I0BIT | J0BIT)) {
+         COPY_CHAN4(t00, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i0, j0, 0, (GLvoid *) t00);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t00[0], t00);
+         }
+      }
+      if (useBorderColor & (I1BIT | J0BIT)) {
+         COPY_CHAN4(t10, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i1, j0, 0, (GLvoid *) t10);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t10[0], t10);
+         }
+      }
+      if (useBorderColor & (I0BIT | J1BIT)) {
+         COPY_CHAN4(t01, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i0, j1, 0, (GLvoid *) t01);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t01[0], t01);
+         }
+      }
+      if (useBorderColor & (I1BIT | J1BIT)) {
+         COPY_CHAN4(t11, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i1, j1, 0, (GLvoid *) t11);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t11[0], t11);
+         }
+      }
+#if CHAN_TYPE == GL_FLOAT
+      rgba[0] = w00 * t00[0] + w10 * t10[0] + w01 * t01[0] + w11 * t11[0];
+      rgba[1] = w00 * t00[1] + w10 * t10[1] + w01 * t01[1] + w11 * t11[1];
+      rgba[2] = w00 * t00[2] + w10 * t10[2] + w01 * t01[2] + w11 * t11[2];
+      rgba[3] = w00 * t00[3] + w10 * t10[3] + w01 * t01[3] + w11 * t11[3];
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      rgba[0] = (GLchan) (w00 * t00[0] + w10 * t10[0] +
+                          w01 * t01[0] + w11 * t11[0] + 0.5);
+      rgba[1] = (GLchan) (w00 * t00[1] + w10 * t10[1] +
+                          w01 * t01[1] + w11 * t11[1] + 0.5);
+      rgba[2] = (GLchan) (w00 * t00[2] + w10 * t10[2] +
+                          w01 * t01[2] + w11 * t11[2] + 0.5);
+      rgba[3] = (GLchan) (w00 * t00[3] + w10 * t10[3] +
+                          w01 * t01[3] + w11 * t11[3] + 0.5);
+#else /* CHAN_BITS == 8 */
+      rgba[0] = (GLchan) ((w00 * t00[0] + w10 * t10[0] +
+                           w01 * t01[0] + w11 * t11[0]) >> WEIGHT_SHIFT);
+      rgba[1] = (GLchan) ((w00 * t00[1] + w10 * t10[1] +
+                           w01 * t01[1] + w11 * t11[1]) >> WEIGHT_SHIFT);
+      rgba[2] = (GLchan) ((w00 * t00[2] + w10 * t10[2] +
+                           w01 * t01[2] + w11 * t11[2]) >> WEIGHT_SHIFT);
+      rgba[3] = (GLchan) ((w00 * t00[3] + w10 * t10[3] +
+                           w01 * t01[3] + w11 * t11[3]) >> WEIGHT_SHIFT);
+#endif
+
+   }
+
+}
+
+
+
+static void
+sample_2d_nearest_mipmap_nearest(GLcontext *ctx,
+                                 const struct gl_texture_object *tObj,
+                                 GLfloat s, GLfloat t, GLfloat lambda,
+                                 GLchan rgba[4])
+{
+   GLint level;
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+   sample_2d_nearest(ctx, tObj, tObj->Image[level], s, t, rgba);
+}
+
+
+
+static void
+sample_2d_linear_mipmap_nearest(GLcontext *ctx,
+                                const struct gl_texture_object *tObj,
+                                GLfloat s, GLfloat t, GLfloat lambda,
+                                GLchan rgba[4])
+{
+   GLint level;
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+   sample_2d_linear(ctx, tObj, tObj->Image[level], s, t, rgba);
+}
+
+
+
+static void
+sample_2d_nearest_mipmap_linear(GLcontext *ctx,
+                                const struct gl_texture_object *tObj,
+                                GLfloat s, GLfloat t, GLfloat lambda,
+                                GLchan rgba[4])
+{
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_2d_nearest(ctx, tObj, tObj->Image[tObj->_MaxLevel], s, t, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];  /* texels */
+      const GLfloat f = FRAC(lambda);
+      sample_2d_nearest(ctx, tObj, tObj->Image[level  ], s, t, t0);
+      sample_2d_nearest(ctx, tObj, tObj->Image[level+1], s, t, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+
+static void
+sample_2d_linear_mipmap_linear(GLcontext *ctx,
+                               const struct gl_texture_object *tObj,
+                               GLfloat s, GLfloat t, GLfloat lambda,
+                               GLchan rgba[4])
+{
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_2d_linear(ctx, tObj, tObj->Image[tObj->_MaxLevel], s, t, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];  /* texels */
+      const GLfloat f = FRAC(lambda);
+      sample_2d_linear(ctx, tObj, tObj->Image[level  ], s, t, t0);
+      sample_2d_linear(ctx, tObj, tObj->Image[level+1], s, t, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+
+static void
+sample_nearest_2d( GLcontext *ctx, GLuint texUnit,
+                   const struct gl_texture_object *tObj, GLuint n,
+                   const GLfloat s[], const GLfloat t[],
+                   const GLfloat u[], const GLfloat lambda[],
+                   GLchan rgba[][4] )
+{
+   GLuint i;
+   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+   (void) u;
+   (void) lambda;
+   for (i=0;i<n;i++) {
+      sample_2d_nearest(ctx, tObj, image, s[i], t[i], rgba[i]);
+   }
+}
+
+
+
+static void
+sample_linear_2d( GLcontext *ctx, GLuint texUnit,
+                  const struct gl_texture_object *tObj, GLuint n,
+                  const GLfloat s[], const GLfloat t[],
+                  const GLfloat u[], const GLfloat lambda[],
+                  GLchan rgba[][4] )
+{
+   GLuint i;
+   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+   (void) u;
+   (void) lambda;
+   for (i=0;i<n;i++) {
+      sample_2d_linear(ctx, tObj, image, s[i], t[i], rgba[i]);
+   }
+}
+
+
+/*
+ * Optimized 2-D texture sampling:
+ *    S and T wrap mode == GL_REPEAT
+ *    GL_NEAREST min/mag filter
+ *    No border, 
+ *    RowStride == Width,
+ *    Format = GL_RGB
+ */
+static void
+opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit,
+                   const struct gl_texture_object *tObj,
+                   GLuint n, const GLfloat s[], const GLfloat t[],
+                   const GLfloat u[], const GLfloat lambda[],
+                   GLchan rgba[][4] )
+{
+   const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
+   const GLfloat width = (GLfloat) img->Width;
+   const GLfloat height = (GLfloat) img->Height;
+   const GLint colMask = img->Width - 1;
+   const GLint rowMask = img->Height - 1;
+   const GLint shift = img->WidthLog2;
+   GLuint k;
+   (void) u;
+   (void) lambda;
+   ASSERT(tObj->WrapS==GL_REPEAT);
+   ASSERT(tObj->WrapT==GL_REPEAT);
+   ASSERT(img->Border==0);
+   ASSERT(img->Format==GL_RGB);
+
+   for (k=0; k<n; k++) {
+      GLint i = IFLOOR(s[k] * width) & colMask;
+      GLint j = IFLOOR(t[k] * height) & rowMask;
+      GLint pos = (j << shift) | i;
+      GLchan *texel = ((GLchan *) img->Data) + 3*pos;
+      rgba[k][RCOMP] = texel[0];
+      rgba[k][GCOMP] = texel[1];
+      rgba[k][BCOMP] = texel[2];
+   }
+}
+
+
+/*
+ * Optimized 2-D texture sampling:
+ *    S and T wrap mode == GL_REPEAT
+ *    GL_NEAREST min/mag filter
+ *    No border
+ *    RowStride == Width,
+ *    Format = GL_RGBA
+ */
+static void
+opt_sample_rgba_2d( GLcontext *ctx, GLuint texUnit,
+                    const struct gl_texture_object *tObj,
+                    GLuint n, const GLfloat s[], const GLfloat t[],
+                    const GLfloat u[], const GLfloat lambda[],
+                    GLchan rgba[][4] )
+{
+   const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
+   const GLfloat width = (GLfloat) img->Width;
+   const GLfloat height = (GLfloat) img->Height;
+   const GLint colMask = img->Width - 1;
+   const GLint rowMask = img->Height - 1;
+   const GLint shift = img->WidthLog2;
+   GLuint i;
+   (void) u;
+   (void) lambda;
+   ASSERT(tObj->WrapS==GL_REPEAT);
+   ASSERT(tObj->WrapT==GL_REPEAT);
+   ASSERT(img->Border==0);
+   ASSERT(img->Format==GL_RGBA);
+
+   for (i = 0; i < n; i++) {
+      const GLint col = IFLOOR(s[i] * width) & colMask;
+      const GLint row = IFLOOR(t[i] * height) & rowMask;
+      const GLint pos = (row << shift) | col;
+      const GLchan *texel = ((GLchan *) img->Data) + (pos << 2);    /* pos*4 */
+      COPY_CHAN4(rgba[i], texel);
+   }
+}
+
+
+/*
+ * Given an array of (s,t) texture coordinate and lambda (level of detail)
+ * values, return an array of texture sample.
+ */
+static void
+sample_lambda_2d( GLcontext *ctx, GLuint texUnit,
+                  const struct gl_texture_object *tObj,
+                  GLuint n,
+                  const GLfloat s[], const GLfloat t[],
+                  const GLfloat u[], const GLfloat lambda[],
+                  GLchan rgba[][4] )
+{
+   const GLfloat minMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
+   GLuint i;
+   (void) u;
+
+   /* since lambda is monotonous-array use this check first */
+   if (lambda[0] <= minMagThresh && lambda[n-1] <= minMagThresh) {
+      /* magnification for whole span */
+      const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
+      switch (tObj->MagFilter) {
+      case GL_NEAREST:
+         if (tObj->WrapS == GL_REPEAT && tObj->WrapT == GL_REPEAT &&
+             img->Border == 0 && img->Width == img->RowStride) {
+            switch (img->Format) {
+            case GL_RGB:
+               opt_sample_rgb_2d(ctx, texUnit, tObj, n, s, t, NULL,
+                                 NULL, rgba);
+               break;
+            case GL_RGBA:
+               opt_sample_rgba_2d(ctx, texUnit, tObj, n, s, t, NULL,
+                                  NULL, rgba);
+               break;
+            default:
+               sample_nearest_2d(ctx, texUnit, tObj, n, s, t, NULL,
+                                 NULL, rgba);
+            }
+         }
+         else {
+            sample_nearest_2d(ctx, texUnit, tObj, n, s, t, NULL,
+                              NULL, rgba);
+         }
+         break;
+      case GL_LINEAR:
+	 sample_linear_2d(ctx, texUnit, tObj, n, s, t, NULL,
+			  NULL, rgba);
+         break;
+      default:
+         _mesa_problem(NULL, "Bad mag filter in sample_lambda_2d");
+      }
+   }
+   else {
+      for (i = 0; i < n; i++) {
+         if (lambda[i] > minMagThresh) {
+            /* minification */
+            switch (tObj->MinFilter) {
+               case GL_NEAREST:
+                  sample_2d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                    s[i], t[i], rgba[i]);
+                  break;
+               case GL_LINEAR:
+                  sample_2d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                   s[i], t[i], rgba[i]);
+                  break;
+               case GL_NEAREST_MIPMAP_NEAREST:
+                  sample_2d_nearest_mipmap_nearest(ctx, tObj, s[i], t[i],
+                                                   lambda[i], rgba[i]);
+                  break;
+               case GL_LINEAR_MIPMAP_NEAREST:
+                  sample_2d_linear_mipmap_nearest(ctx,tObj, s[i], t[i],
+                                                  lambda[i], rgba[i]);
+                  break;
+               case GL_NEAREST_MIPMAP_LINEAR:
+                  sample_2d_nearest_mipmap_linear(ctx,tObj, s[i], t[i],
+                                                  lambda[i], rgba[i]);
+                  break;
+               case GL_LINEAR_MIPMAP_LINEAR:
+                  sample_2d_linear_mipmap_linear(ctx,tObj, s[i], t[i],
+                                                 lambda[i], rgba[i] );
+                  break;
+               default:
+                  _mesa_problem(NULL, "Bad min filter in sample_2d_texture");
+                  return;
+            }
+         }
+         else {
+            /* magnification */
+            switch (tObj->MagFilter) {
+               case GL_NEAREST:
+                  sample_2d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                    s[i], t[i], rgba[i]);
+                  break;
+               case GL_LINEAR:
+                  sample_2d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                   s[i], t[i], rgba[i] );
+                  break;
+               default:
+                  _mesa_problem(NULL, "Bad mag filter in sample_2d_texture");
+            }
+         }
+      }
+   }
+}
+
+
+
+/**********************************************************************/
+/*                    3-D Texture Sampling Functions                  */
+/**********************************************************************/
+
+/*
+ * Return the texture sample for coordinate (s,t,r) using GL_NEAREST filter.
+ */
+static void
+sample_3d_nearest(GLcontext *ctx,
+                  const struct gl_texture_object *tObj,
+                  const struct gl_texture_image *img,
+                  GLfloat s, GLfloat t, GLfloat r,
+                  GLchan rgba[4])
+{
+   const GLint width = img->Width2;     /* without border, power of two */
+   const GLint height = img->Height2;   /* without border, power of two */
+   const GLint depth = img->Depth2;     /* without border, power of two */
+   GLint i, j, k;
+
+   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapS, s, width,  i);
+   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapT, t, height, j);
+   COMPUTE_NEAREST_TEXEL_LOCATION(tObj->WrapR, r, depth,  k);
+
+   if (i < 0 || i >= (GLint) img->Width ||
+       j < 0 || j >= (GLint) img->Height ||
+       k < 0 || k >= (GLint) img->Depth) {
+      /* Need this test for GL_CLAMP_TO_BORDER_ARB mode */
+      COPY_CHAN4(rgba, tObj->BorderColor);
+   }
+   else {
+      (*img->FetchTexel)(img, i, j, k, (GLvoid *) rgba);
+      if (img->Format == GL_COLOR_INDEX) {
+         palette_sample(ctx, tObj, rgba[0], rgba);
+      }
+   }
+}
+
+
+
+/*
+ * Return the texture sample for coordinate (s,t,r) using GL_LINEAR filter.
+ */
+static void
+sample_3d_linear(GLcontext *ctx,
+                 const struct gl_texture_object *tObj,
+                 const struct gl_texture_image *img,
+                 GLfloat s, GLfloat t, GLfloat r,
+                 GLchan rgba[4])
+{
+   const GLint width = img->Width2;
+   const GLint height = img->Height2;
+   const GLint depth = img->Depth2;
+   GLint i0, j0, k0, i1, j1, k1;
+   GLuint useBorderColor;
+   GLfloat u, v, w;
+
+   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapS, s, u, width,  i0, i1);
+   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapT, t, v, height, j0, j1);
+   COMPUTE_LINEAR_TEXEL_LOCATIONS(tObj->WrapR, r, w, depth,  k0, k1);
+
+   useBorderColor = 0;
+   if (img->Border) {
+      i0 += img->Border;
+      i1 += img->Border;
+      j0 += img->Border;
+      j1 += img->Border;
+      k0 += img->Border;
+      k1 += img->Border;
+   }
+   else {
+      /* check if sampling texture border color */
+      if (i0 < 0 || i0 >= width)   useBorderColor |= I0BIT;
+      if (i1 < 0 || i1 >= width)   useBorderColor |= I1BIT;
+      if (j0 < 0 || j0 >= height)  useBorderColor |= J0BIT;
+      if (j1 < 0 || j1 >= height)  useBorderColor |= J1BIT;
+      if (k0 < 0 || k0 >= depth)   useBorderColor |= K0BIT;
+      if (k1 < 0 || k1 >= depth)   useBorderColor |= K1BIT;
+   }
+
+   {
+      const GLfloat a = FRAC(u);
+      const GLfloat b = FRAC(v);
+      const GLfloat c = FRAC(w);
+
+#if CHAN_TYPE == GL_FLOAT || CHAN_TYPE == GL_UNSIGNED_SHORT
+      /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
+      GLfloat w000 = (1.0F-a) * (1.0F-b) * (1.0F-c);
+      GLfloat w100 =       a  * (1.0F-b) * (1.0F-c);
+      GLfloat w010 = (1.0F-a) *       b  * (1.0F-c);
+      GLfloat w110 =       a  *       b  * (1.0F-c);
+      GLfloat w001 = (1.0F-a) * (1.0F-b) *       c ;
+      GLfloat w101 =       a  * (1.0F-b) *       c ;
+      GLfloat w011 = (1.0F-a) *       b  *       c ;
+      GLfloat w111 =       a  *       b  *       c ;
+#else /* CHAN_BITS == 8 */
+      /* compute sample weights in fixed point in [0,WEIGHT_SCALE] */
+      GLint w000 = IROUND_POS((1.0F-a) * (1.0F-b) * (1.0F-c) * WEIGHT_SCALE);
+      GLint w100 = IROUND_POS(      a  * (1.0F-b) * (1.0F-c) * WEIGHT_SCALE);
+      GLint w010 = IROUND_POS((1.0F-a) *       b  * (1.0F-c) * WEIGHT_SCALE);
+      GLint w110 = IROUND_POS(      a  *       b  * (1.0F-c) * WEIGHT_SCALE);
+      GLint w001 = IROUND_POS((1.0F-a) * (1.0F-b) *       c  * WEIGHT_SCALE);
+      GLint w101 = IROUND_POS(      a  * (1.0F-b) *       c  * WEIGHT_SCALE);
+      GLint w011 = IROUND_POS((1.0F-a) *       b  *       c  * WEIGHT_SCALE);
+      GLint w111 = IROUND_POS(      a  *       b  *       c  * WEIGHT_SCALE);
+#endif
+
+      GLchan t000[4], t010[4], t001[4], t011[4];
+      GLchan t100[4], t110[4], t101[4], t111[4];
+
+      if (useBorderColor & (I0BIT | J0BIT | K0BIT)) {
+         COPY_CHAN4(t000, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i0, j0, k0, (GLvoid *) t000);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t000[0], t000);
+         }
+      }
+      if (useBorderColor & (I1BIT | J0BIT | K0BIT)) {
+         COPY_CHAN4(t100, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i1, j0, k0, (GLvoid *) t100);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t100[0], t100);
+         }
+      }
+      if (useBorderColor & (I0BIT | J1BIT | K0BIT)) {
+         COPY_CHAN4(t010, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i0, j1, k0, (GLvoid *) t010);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t010[0], t010);
+         }
+      }
+      if (useBorderColor & (I1BIT | J1BIT | K0BIT)) {
+         COPY_CHAN4(t110, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i1, j1, k0, (GLvoid *) t110);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t110[0], t110);
+         }
+      }
+
+      if (useBorderColor & (I0BIT | J0BIT | K1BIT)) {
+         COPY_CHAN4(t001, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i0, j0, k1, (GLvoid *) t001);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t001[0], t001);
+         }
+      }
+      if (useBorderColor & (I1BIT | J0BIT | K1BIT)) {
+         COPY_CHAN4(t101, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i1, j0, k1, (GLvoid *) t101);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t101[0], t101);
+         }
+      }
+      if (useBorderColor & (I0BIT | J1BIT | K1BIT)) {
+         COPY_CHAN4(t011, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i0, j1, k1, (GLvoid *) t011);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t011[0], t011);
+         }
+      }
+      if (useBorderColor & (I1BIT | J1BIT | K1BIT)) {
+         COPY_CHAN4(t111, tObj->BorderColor);
+      }
+      else {
+         (*img->FetchTexel)(img, i1, j1, k1, (GLvoid *) t111);
+         if (img->Format == GL_COLOR_INDEX) {
+            palette_sample(ctx, tObj, t111[0], t111);
+         }
+      }
+
+#if CHAN_TYPE == GL_FLOAT
+      rgba[0] = w000*t000[0] + w010*t010[0] + w001*t001[0] + w011*t011[0] +
+                w100*t100[0] + w110*t110[0] + w101*t101[0] + w111*t111[0];
+      rgba[1] = w000*t000[1] + w010*t010[1] + w001*t001[1] + w011*t011[1] +
+                w100*t100[1] + w110*t110[1] + w101*t101[1] + w111*t111[1];
+      rgba[2] = w000*t000[2] + w010*t010[2] + w001*t001[2] + w011*t011[2] +
+                w100*t100[2] + w110*t110[2] + w101*t101[2] + w111*t111[2];
+      rgba[3] = w000*t000[3] + w010*t010[3] + w001*t001[3] + w011*t011[3] +
+                w100*t100[3] + w110*t110[3] + w101*t101[3] + w111*t111[3];
+#elif CHAN_TYPE == GL_UNSIGNED_SHORT
+      rgba[0] = (GLchan) (w000*t000[0] + w010*t010[0] +
+                          w001*t001[0] + w011*t011[0] +
+                          w100*t100[0] + w110*t110[0] +
+                          w101*t101[0] + w111*t111[0] + 0.5);
+      rgba[1] = (GLchan) (w000*t000[1] + w010*t010[1] +
+                          w001*t001[1] + w011*t011[1] +
+                          w100*t100[1] + w110*t110[1] +
+                          w101*t101[1] + w111*t111[1] + 0.5);
+      rgba[2] = (GLchan) (w000*t000[2] + w010*t010[2] +
+                          w001*t001[2] + w011*t011[2] +
+                          w100*t100[2] + w110*t110[2] +
+                          w101*t101[2] + w111*t111[2] + 0.5);
+      rgba[3] = (GLchan) (w000*t000[3] + w010*t010[3] +
+                          w001*t001[3] + w011*t011[3] +
+                          w100*t100[3] + w110*t110[3] +
+                          w101*t101[3] + w111*t111[3] + 0.5);
+#else /* CHAN_BITS == 8 */
+      rgba[0] = (GLchan) (
+                 (w000*t000[0] + w010*t010[0] + w001*t001[0] + w011*t011[0] +
+                  w100*t100[0] + w110*t110[0] + w101*t101[0] + w111*t111[0] )
+                 >> WEIGHT_SHIFT);
+      rgba[1] = (GLchan) (
+                 (w000*t000[1] + w010*t010[1] + w001*t001[1] + w011*t011[1] +
+                  w100*t100[1] + w110*t110[1] + w101*t101[1] + w111*t111[1] )
+                 >> WEIGHT_SHIFT);
+      rgba[2] = (GLchan) (
+                 (w000*t000[2] + w010*t010[2] + w001*t001[2] + w011*t011[2] +
+                  w100*t100[2] + w110*t110[2] + w101*t101[2] + w111*t111[2] )
+                 >> WEIGHT_SHIFT);
+      rgba[3] = (GLchan) (
+                 (w000*t000[3] + w010*t010[3] + w001*t001[3] + w011*t011[3] +
+                  w100*t100[3] + w110*t110[3] + w101*t101[3] + w111*t111[3] )
+                 >> WEIGHT_SHIFT);
+#endif
+
+   }
+}
+
+
+
+static void
+sample_3d_nearest_mipmap_nearest(GLcontext *ctx,
+                                 const struct gl_texture_object *tObj,
+                                 GLfloat s, GLfloat t, GLfloat r,
+                                 GLfloat lambda, GLchan rgba[4] )
+{
+   GLint level;
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+   sample_3d_nearest(ctx, tObj, tObj->Image[level], s, t, r, rgba);
+}
+
+
+static void
+sample_3d_linear_mipmap_nearest(GLcontext *ctx,
+                                const struct gl_texture_object *tObj,
+                                GLfloat s, GLfloat t, GLfloat r,
+                                GLfloat lambda, GLchan rgba[4])
+{
+   GLint level;
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+   sample_3d_linear(ctx, tObj, tObj->Image[level], s, t, r, rgba);
+}
+
+
+static void
+sample_3d_nearest_mipmap_linear(GLcontext *ctx,
+                                const struct gl_texture_object *tObj,
+                                GLfloat s, GLfloat t, GLfloat r,
+                                GLfloat lambda, GLchan rgba[4])
+{
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_3d_nearest(ctx, tObj, tObj->Image[tObj->_MaxLevel],
+                        s, t, r, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];  /* texels */
+      const GLfloat f = FRAC(lambda);
+      sample_3d_nearest(ctx, tObj, tObj->Image[level  ], s, t, r, t0);
+      sample_3d_nearest(ctx, tObj, tObj->Image[level+1], s, t, r, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+static void
+sample_3d_linear_mipmap_linear(GLcontext *ctx,
+                               const struct gl_texture_object *tObj,
+                               GLfloat s, GLfloat t, GLfloat r,
+                               GLfloat lambda, GLchan rgba[4] )
+{
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_3d_linear(ctx, tObj, tObj->Image[tObj->_MaxLevel], s, t, r, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];  /* texels */
+      const GLfloat f = FRAC(lambda);
+      sample_3d_linear(ctx, tObj, tObj->Image[level  ], s, t, r, t0);
+      sample_3d_linear(ctx, tObj, tObj->Image[level+1], s, t, r, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+static void
+sample_nearest_3d(GLcontext *ctx, GLuint texUnit,
+                  const struct gl_texture_object *tObj, GLuint n,
+                  const GLfloat s[], const GLfloat t[],
+                  const GLfloat u[], const GLfloat lambda[],
+                  GLchan rgba[][4])
+{
+   GLuint i;
+   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+   (void) lambda;
+   for (i=0;i<n;i++) {
+      sample_3d_nearest(ctx, tObj, image, s[i], t[i], u[i], rgba[i]);
+   }
+}
+
+
+
+static void
+sample_linear_3d( GLcontext *ctx, GLuint texUnit,
+                  const struct gl_texture_object *tObj, GLuint n,
+                  const GLfloat s[], const GLfloat t[],
+                  const GLfloat u[], const GLfloat lambda[],
+                  GLchan rgba[][4] )
+{
+   GLuint i;
+   struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
+   (void) lambda;
+   for (i=0;i<n;i++) {
+      sample_3d_linear(ctx, tObj, image, s[i], t[i], u[i], rgba[i]);
+   }
+}
+
+
+/*
+ * Given an (s,t,r) texture coordinate and lambda (level of detail) value,
+ * return a texture sample.
+ */
+static void
+sample_lambda_3d( GLcontext *ctx, GLuint texUnit,
+                  const struct gl_texture_object *tObj, GLuint n,
+                  const GLfloat s[], const GLfloat t[],
+                  const GLfloat u[], const GLfloat lambda[],
+                  GLchan rgba[][4] )
+{
+   GLuint i;
+   GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
+
+   for (i=0;i<n;i++) {
+
+      if (lambda[i] > MinMagThresh) {
+         /* minification */
+         switch (tObj->MinFilter) {
+            case GL_NEAREST:
+               sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                 s[i], t[i], u[i], rgba[i]);
+               break;
+            case GL_LINEAR:
+               sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                s[i], t[i], u[i], rgba[i]);
+               break;
+            case GL_NEAREST_MIPMAP_NEAREST:
+               sample_3d_nearest_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+                                                lambda[i], rgba[i]);
+               break;
+            case GL_LINEAR_MIPMAP_NEAREST:
+               sample_3d_linear_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+                                               lambda[i], rgba[i]);
+               break;
+            case GL_NEAREST_MIPMAP_LINEAR:
+               sample_3d_nearest_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+                                               lambda[i], rgba[i]);
+               break;
+            case GL_LINEAR_MIPMAP_LINEAR:
+               sample_3d_linear_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+                                              lambda[i], rgba[i]);
+               break;
+            default:
+               _mesa_problem(NULL, "Bad min filterin sample_3d_texture");
+         }
+      }
+      else {
+         /* magnification */
+         switch (tObj->MagFilter) {
+            case GL_NEAREST:
+               sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                 s[i], t[i], u[i], rgba[i]);
+               break;
+            case GL_LINEAR:
+               sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
+                                s[i], t[i], u[i], rgba[i]);
+               break;
+            default:
+               _mesa_problem(NULL, "Bad mag filter in sample_3d_texture");
+         }
+      }
+   }
+}
+
+
+/**********************************************************************/
+/*                Texture Cube Map Sampling Functions                 */
+/**********************************************************************/
+
+/*
+ * Choose one of six sides of a texture cube map given the texture
+ * coord (rx,ry,rz).  Return pointer to corresponding array of texture
+ * images.
+ */
+static const struct gl_texture_image **
+choose_cube_face(const struct gl_texture_object *texObj,
+                 GLfloat rx, GLfloat ry, GLfloat rz,
+                 GLfloat *newS, GLfloat *newT)
+{
+/*
+      major axis
+      direction     target                             sc     tc    ma
+      ----------    -------------------------------    ---    ---   ---
+       +rx          TEXTURE_CUBE_MAP_POSITIVE_X_EXT    -rz    -ry   rx
+       -rx          TEXTURE_CUBE_MAP_NEGATIVE_X_EXT    +rz    -ry   rx
+       +ry          TEXTURE_CUBE_MAP_POSITIVE_Y_EXT    +rx    +rz   ry
+       -ry          TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT    +rx    -rz   ry
+       +rz          TEXTURE_CUBE_MAP_POSITIVE_Z_EXT    +rx    -ry   rz
+       -rz          TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT    -rx    -ry   rz
+*/
+   const struct gl_texture_image **imgArray;
+   const GLfloat arx = ABSF(rx),   ary = ABSF(ry),   arz = ABSF(rz);
+   GLfloat sc, tc, ma;
+
+   if (arx > ary && arx > arz) {
+      if (rx >= 0.0F) {
+         imgArray = (const struct gl_texture_image **) texObj->Image;
+         sc = -rz;
+         tc = -ry;
+         ma = arx;
+      }
+      else {
+         imgArray = (const struct gl_texture_image **) texObj->NegX;
+         sc = rz;
+         tc = -ry;
+         ma = arx;
+      }
+   }
+   else if (ary > arx && ary > arz) {
+      if (ry >= 0.0F) {
+         imgArray = (const struct gl_texture_image **) texObj->PosY;
+         sc = rx;
+         tc = rz;
+         ma = ary;
+      }
+      else {
+         imgArray = (const struct gl_texture_image **) texObj->NegY;
+         sc = rx;
+         tc = -rz;
+         ma = ary;
+      }
+   }
+   else {
+      if (rz > 0.0F) {
+         imgArray = (const struct gl_texture_image **) texObj->PosZ;
+         sc = rx;
+         tc = -ry;
+         ma = arz;
+      }
+      else {
+         imgArray = (const struct gl_texture_image **) texObj->NegZ;
+         sc = -rx;
+         tc = -ry;
+         ma = arz;
+      }
+   }
+
+   *newS = ( sc / ma + 1.0F ) * 0.5F;
+   *newT = ( tc / ma + 1.0F ) * 0.5F;
+   return imgArray;
+}
+
+
+static void
+sample_nearest_cube(GLcontext *ctx, GLuint texUnit,
+		    const struct gl_texture_object *tObj, GLuint n,
+                    const GLfloat s[], const GLfloat t[],
+                    const GLfloat u[], const GLfloat lambda[],
+                    GLchan rgba[][4])
+{
+   GLuint i;
+   (void) lambda;
+   for (i = 0; i < n; i++) {
+      const struct gl_texture_image **images;
+      GLfloat newS, newT;
+      images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
+      sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
+                        newS, newT, rgba[i]);
+   }
+}
+
+
+static void
+sample_linear_cube(GLcontext *ctx, GLuint texUnit,
+		   const struct gl_texture_object *tObj, GLuint n,
+                   const GLfloat s[], const GLfloat t[],
+                   const GLfloat u[], const GLfloat lambda[],
+                   GLchan rgba[][4])
+{
+   GLuint i;
+   (void) lambda;
+   for (i = 0; i < n; i++) {
+      const struct gl_texture_image **images;
+      GLfloat newS, newT;
+      images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
+      sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
+                       newS, newT, rgba[i]);
+   }
+}
+
+
+static void
+sample_cube_nearest_mipmap_nearest(GLcontext *ctx,
+                                   const struct gl_texture_object *tObj,
+                                   GLfloat s, GLfloat t, GLfloat u,
+                                   GLfloat lambda, GLchan rgba[4])
+{
+   const struct gl_texture_image **images;
+   GLfloat newS, newT;
+   GLint level;
+
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+
+   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+   sample_2d_nearest(ctx, tObj, images[level], newS, newT, rgba);
+}
+
+
+static void
+sample_cube_linear_mipmap_nearest(GLcontext *ctx,
+                                  const struct gl_texture_object *tObj,
+                                  GLfloat s, GLfloat t, GLfloat u,
+                                  GLfloat lambda, GLchan rgba[4])
+{
+   const struct gl_texture_image **images;
+   GLfloat newS, newT;
+   GLint level;
+
+   COMPUTE_NEAREST_MIPMAP_LEVEL(tObj, lambda, level);
+
+   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+   sample_2d_linear(ctx, tObj, images[level], newS, newT, rgba);
+}
+
+
+static void
+sample_cube_nearest_mipmap_linear(GLcontext *ctx,
+                                  const struct gl_texture_object *tObj,
+                                  GLfloat s, GLfloat t, GLfloat u,
+                                  GLfloat lambda, GLchan rgba[4])
+{
+   const struct gl_texture_image **images;
+   GLfloat newS, newT;
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_2d_nearest(ctx, tObj, images[tObj->_MaxLevel], newS, newT, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];  /* texels */
+      const GLfloat f = FRAC(lambda);
+      sample_2d_nearest(ctx, tObj, images[level  ], newS, newT, t0);
+      sample_2d_nearest(ctx, tObj, images[level+1], newS, newT, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+static void
+sample_cube_linear_mipmap_linear(GLcontext *ctx,
+                                 const struct gl_texture_object *tObj,
+                                 GLfloat s, GLfloat t, GLfloat u,
+                                 GLfloat lambda, GLchan rgba[4])
+{
+   const struct gl_texture_image **images;
+   GLfloat newS, newT;
+   GLint level;
+
+   COMPUTE_LINEAR_MIPMAP_LEVEL(tObj, lambda, level);
+
+   images = choose_cube_face(tObj, s, t, u, &newS, &newT);
+
+   if (level >= tObj->_MaxLevel) {
+      sample_2d_linear(ctx, tObj, images[tObj->_MaxLevel], newS, newT, rgba);
+   }
+   else {
+      GLchan t0[4], t1[4];
+      const GLfloat f = FRAC(lambda);
+      sample_2d_linear(ctx, tObj, images[level  ], newS, newT, t0);
+      sample_2d_linear(ctx, tObj, images[level+1], newS, newT, t1);
+      rgba[RCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[RCOMP] + f * t1[RCOMP]);
+      rgba[GCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[GCOMP] + f * t1[GCOMP]);
+      rgba[BCOMP] = (GLchan) INTCAST ((1.0F-f) * t0[BCOMP] + f * t1[BCOMP]);
+      rgba[ACOMP] = (GLchan) INTCAST ((1.0F-f) * t0[ACOMP] + f * t1[ACOMP]);
+   }
+}
+
+
+static void
+sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
+		    const struct gl_texture_object *tObj, GLuint n,
+		    const GLfloat s[], const GLfloat t[],
+		    const GLfloat u[], const GLfloat lambda[],
+		    GLchan rgba[][4])
+{
+   GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
+   GLuint i;
+
+   for (i = 0; i < n; i++) {
+      if (lambda[i] > MinMagThresh) {
+         /* minification */
+         switch (tObj->MinFilter) {
+            case GL_NEAREST:
+               {
+                  const struct gl_texture_image **images;
+                  GLfloat newS, newT;
+                  images = choose_cube_face(tObj, s[i], t[i], u[i],
+                                            &newS, &newT);
+                  sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
+                                    newS, newT, rgba[i]);
+               }
+               break;
+            case GL_LINEAR:
+               {
+                  const struct gl_texture_image **images;
+                  GLfloat newS, newT;
+                  images = choose_cube_face(tObj, s[i], t[i], u[i],
+                                            &newS, &newT);
+                  sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
+                                   newS, newT, rgba[i]);
+               }
+               break;
+            case GL_NEAREST_MIPMAP_NEAREST:
+               sample_cube_nearest_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+                                                  lambda[i], rgba[i]);
+               break;
+            case GL_LINEAR_MIPMAP_NEAREST:
+               sample_cube_linear_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
+                                                 lambda[i], rgba[i]);
+               break;
+            case GL_NEAREST_MIPMAP_LINEAR:
+               sample_cube_nearest_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+                                                 lambda[i], rgba[i]);
+               break;
+            case GL_LINEAR_MIPMAP_LINEAR:
+               sample_cube_linear_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
+                                                lambda[i], rgba[i]);
+               break;
+            default:
+               _mesa_problem(NULL, "Bad min filter in sample_lambda_cube");
+         }
+      }
+      else {
+         /* magnification */
+         const struct gl_texture_image **images;
+         GLfloat newS, newT;
+         images = choose_cube_face(tObj, s[i], t[i], u[i],
+                                   &newS, &newT);
+         switch (tObj->MagFilter) {
+            case GL_NEAREST:
+               sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
+                                 newS, newT, rgba[i]);
+               break;
+            case GL_LINEAR:
+               sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
+                                newS, newT, rgba[i]);
+               break;
+            default:
+               _mesa_problem(NULL, "Bad mag filter in sample_lambda_cube");
+         }
+      }
+   }
+}
+
+
+
+/**********************************************************************/
+/*               Texture Rectangle Sampling Functions                 */
+/**********************************************************************/
+
+static void
+sample_nearest_rect(GLcontext *ctx, GLuint texUnit,
+		    const struct gl_texture_object *tObj, GLuint n,
+                    const GLfloat s[], const GLfloat t[],
+                    const GLfloat u[], const GLfloat lambda[],
+                    GLchan rgba[][4])
+{
+   const struct gl_texture_image *img = tObj->Image[0];
+   const GLfloat width = (GLfloat) img->Width;
+   const GLfloat height = (GLfloat) img->Height;
+   const GLint width_minus_1 = img->Width - 1;
+   const GLint height_minus_1 = img->Height - 1;
+   GLuint i;
+
+   (void) texUnit;
+   (void) lambda;
+
+   ASSERT(tObj->WrapS == GL_CLAMP ||
+          tObj->WrapS == GL_CLAMP_TO_EDGE ||
+          tObj->WrapS == GL_CLAMP_TO_BORDER_ARB);
+   ASSERT(tObj->WrapT == GL_CLAMP ||
+          tObj->WrapT == GL_CLAMP_TO_EDGE ||
+          tObj->WrapT == GL_CLAMP_TO_BORDER_ARB);
+   ASSERT(img->Format != GL_COLOR_INDEX);
+
+   /* XXX move Wrap mode tests outside of loops for common cases */
+   for (i = 0; i < n; i++) {
+      GLint row, col;
+      /* NOTE: we DO NOT use [0, 1] texture coordinates! */
+      if (tObj->WrapS == GL_CLAMP) {
+         col = IFLOOR( CLAMP(s[i], 0.0F, width) );
+      }
+      else if (tObj->WrapS == GL_CLAMP_TO_EDGE) {
+         col = IFLOOR( CLAMP(s[i], 0.5F, width - 0.5F) );
+      }
+      else {
+         col = IFLOOR( CLAMP(s[i], -0.5F, width + 0.5F) );
+      }
+      if (tObj->WrapT == GL_CLAMP) {
+         row = IFLOOR( CLAMP(t[i], 0.0F, height) );
+      }
+      else if (tObj->WrapT == GL_CLAMP_TO_EDGE) {
+         row = IFLOOR( CLAMP(t[i], 0.5F, height - 0.5F) );
+      }
+      else {
+         row = IFLOOR( CLAMP(t[i], -0.5F, height + 0.5F) );
+      }
+
+      col = CLAMP(col, 0, width_minus_1);
+      row = CLAMP(row, 0, height_minus_1);
+
+      (*img->FetchTexel)(img, col, row, 0, (GLvoid *) rgba[i]);
+   }
+}
+
+
+static void
+sample_linear_rect(GLcontext *ctx, GLuint texUnit,
+		   const struct gl_texture_object *tObj, GLuint n,
+                   const GLfloat s[], const GLfloat t[],
+                   const GLfloat u[], const GLfloat lambda[],
+		   GLchan rgba[][4])
+{
+   const struct gl_texture_image *img = tObj->Image[0];
+   const GLfloat width = (GLfloat) img->Width;
+   const GLfloat height = (GLfloat) img->Height;
+   const GLint width_minus_1 = img->Width - 1;
+   const GLint height_minus_1 = img->Height - 1;
+   GLuint i;
+
+   (void) texUnit;
+   (void) lambda;
+
+   ASSERT(tObj->WrapS == GL_CLAMP ||
+          tObj->WrapS == GL_CLAMP_TO_EDGE ||
+          tObj->WrapS == GL_CLAMP_TO_BORDER_ARB);
+   ASSERT(tObj->WrapT == GL_CLAMP ||
+          tObj->WrapT == GL_CLAMP_TO_EDGE ||
+          tObj->WrapT == GL_CLAMP_TO_BORDER_ARB);
+   ASSERT(img->Format != GL_COLOR_INDEX);
+
+   /* XXX lots of opportunity for optimization in this loop */
+   for (i = 0; i < n; i++) {
+      GLfloat frow, fcol;
+      GLint row0, col0, row1, col1;
+      GLchan t00[4], t01[4], t10[4], t11[4];
+      GLfloat a, b, w00, w01, w10, w11;
+
+      /* NOTE: we DO NOT use [0, 1] texture coordinates! */
+      if (tObj->WrapS == GL_CLAMP) {
+         fcol = CLAMP(s[i], 0.0F, width);
+      }
+      else if (tObj->WrapS == GL_CLAMP_TO_EDGE) {
+         fcol = CLAMP(s[i], 0.5F, width - 0.5F);
+      }
+      else {
+         fcol = CLAMP(s[i], -0.5F, width + 0.5F);
+      }
+      if (tObj->WrapT == GL_CLAMP) {
+         frow = CLAMP(t[i], 0.0F, height);
+      }
+      else if (tObj->WrapT == GL_CLAMP_TO_EDGE) {
+         frow = CLAMP(t[i], 0.5F, height - 0.5F);
+      }
+      else {
+         frow = CLAMP(t[i], -0.5F, height + 0.5F);
+      }
+
+      /* compute integer rows/columns */
+      col0 = IFLOOR(fcol);
+      col1 = col0 + 1;
+      col0 = CLAMP(col0, 0, width_minus_1);
+      col1 = CLAMP(col1, 0, width_minus_1);
+      row0 = IFLOOR(frow);
+      row1 = row0 + 1;
+      row0 = CLAMP(row0, 0, height_minus_1);
+      row1 = CLAMP(row1, 0, height_minus_1);
+
+      /* get four texel samples */
+      (*img->FetchTexel)(img, col0, row0, 0, (GLvoid *) t00);
+      (*img->FetchTexel)(img, col1, row0, 0, (GLvoid *) t10);
+      (*img->FetchTexel)(img, col0, row1, 0, (GLvoid *) t01);
+      (*img->FetchTexel)(img, col1, row1, 0, (GLvoid *) t11);
+
+      /* compute sample weights */
+      a = FRAC(fcol);
+      b = FRAC(frow);
+      w00 = (1.0F-a) * (1.0F-b);
+      w10 =       a  * (1.0F-b);
+      w01 = (1.0F-a) *       b ;
+      w11 =       a  *       b ;
+
+      /* compute weighted average of samples */
+      rgba[i][0] = (GLchan)
+	  (w00 * t00[0] + w10 * t10[0] + w01 * t01[0] + w11 * t11[0]);
+      rgba[i][1] = (GLchan)
+	  (w00 * t00[1] + w10 * t10[1] + w01 * t01[1] + w11 * t11[1]);
+      rgba[i][2] = (GLchan)
+	  (w00 * t00[2] + w10 * t10[2] + w01 * t01[2] + w11 * t11[2]);
+      rgba[i][3] = (GLchan)
+	  (w00 * t00[3] + w10 * t10[3] + w01 * t01[3] + w11 * t11[3]);
+   }
+}
+
+
+
+static void
+sample_lambda_rect( GLcontext *ctx, GLuint texUnit,
+		    const struct gl_texture_object *tObj, GLuint n,
+		    const GLfloat s[], const GLfloat t[],
+		    const GLfloat u[], const GLfloat lambda[],
+		    GLchan rgba[][4])
+{
+   const GLfloat minMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
+   GLuint i;
+
+   {
+      for (i = 0; i < n; i++) {
+         GLfloat coord[4];
+         coord[0] = s[i];
+         coord[1] = t[i];
+         coord[2] = u[i];
+         coord[3] = 1.0;
+         if (lambda[i] > minMagThresh) {
+            /* minification */
+            switch (tObj->MinFilter) {
+               case GL_NEAREST:
+                  sample_nearest_rect(ctx, texUnit, tObj, 1,
+                                      s + i, t + i, u + i, lambda + i,
+                                      rgba + i );
+                  break;
+               case GL_LINEAR:
+                  sample_linear_rect(ctx, texUnit, tObj, 1,
+                                      s + i, t + i, u + i, lambda + i,
+                                      rgba + i );
+                  break;
+               default:
+                  _mesa_problem(NULL, "Bad min filter in sample_lambda_rect");
+                  return;
+            }
+         }
+         else {
+            /* magnification */
+            switch (tObj->MagFilter) {
+               case GL_NEAREST:
+                  sample_nearest_rect(ctx, texUnit, tObj, 1,
+                                      s + i, t + i, u + i, lambda + i,
+                                      rgba + i );
+                  break;
+               case GL_LINEAR:
+                  sample_linear_rect(ctx, texUnit, tObj, 1,
+                                      s + i, t + i, u + i, lambda + i,
+                                      rgba + i );
+                  break;
+               default:
+                  _mesa_problem(NULL, "Bad mag filter in sample_lambda_rect");
+                  return;
+            }
+         }
+      }
+   }
+
+}
+
+
+
+static void
+null_sample_func( GLcontext *ctx, GLuint texUnit,
+		  const struct gl_texture_object *tObj, GLuint n,
+		  const GLfloat s[], const GLfloat t[],
+		  const GLfloat u[], const GLfloat lambda[],
+		  GLchan rgba[][4])
+{
+}
+
+
+
+/**********************************************************************/
+/*                       Texture Sampling Setup                       */
+/**********************************************************************/
+
+
+/*
+ * Setup the texture sampling function for this texture object.
+ */
+void
+_swrast_choose_texture_sample_func( GLcontext *ctx, GLuint texUnit,
+				    const struct gl_texture_object *t )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+
+  if (!t->Complete) {
+     swrast->TextureSample[texUnit] = null_sample_func;
+   }
+   else {
+      GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);
+
+      if (needLambda) {
+         /* Compute min/mag filter threshold */
+         if (t->MagFilter == GL_LINEAR
+             && (t->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||
+                 t->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {
+            swrast->_MinMagThresh[texUnit] = 0.5F;
+         }
+         else {
+            swrast->_MinMagThresh[texUnit] = 0.0F;
+         }
+      }
+
+      switch (t->Target) {
+         case GL_TEXTURE_1D:
+            if (needLambda) {
+               swrast->TextureSample[texUnit] = sample_lambda_1d;
+            }
+            else if (t->MinFilter==GL_LINEAR) {
+               swrast->TextureSample[texUnit] = sample_linear_1d;
+            }
+            else {
+               ASSERT(t->MinFilter==GL_NEAREST);
+               swrast->TextureSample[texUnit] = sample_nearest_1d;
+            }
+            break;
+         case GL_TEXTURE_2D:
+            if (needLambda) {
+               swrast->TextureSample[texUnit] = sample_lambda_2d;
+            }
+            else if (t->MinFilter==GL_LINEAR) {
+               swrast->TextureSample[texUnit] = sample_linear_2d;
+            }
+            else {
+               GLint baseLevel = t->BaseLevel;
+               ASSERT(t->MinFilter==GL_NEAREST);
+               if (t->WrapS == GL_REPEAT &&
+                   t->WrapT == GL_REPEAT &&
+                   t->Image[baseLevel]->Border == 0 &&
+                   t->Image[baseLevel]->Width == t->Image[baseLevel]->RowStride &&
+                   t->Image[baseLevel]->TexFormat->MesaFormat == MESA_FORMAT_RGB) {
+                  swrast->TextureSample[texUnit] = opt_sample_rgb_2d;
+               }
+               else if (t->WrapS == GL_REPEAT &&
+                        t->WrapT == GL_REPEAT &&
+                        t->Image[baseLevel]->Border == 0 &&
+			t->Image[baseLevel]->Width == t->Image[baseLevel]->RowStride &&
+                        t->Image[baseLevel]->TexFormat->MesaFormat == MESA_FORMAT_RGBA) {
+                  swrast->TextureSample[texUnit] = opt_sample_rgba_2d;
+               }
+               else
+                  swrast->TextureSample[texUnit] = sample_nearest_2d;
+            }
+            break;
+         case GL_TEXTURE_3D:
+            if (needLambda) {
+               swrast->TextureSample[texUnit] = sample_lambda_3d;
+            }
+            else if (t->MinFilter==GL_LINEAR) {
+               swrast->TextureSample[texUnit] = sample_linear_3d;
+            }
+            else {
+               ASSERT(t->MinFilter==GL_NEAREST);
+               swrast->TextureSample[texUnit] = sample_nearest_3d;
+            }
+            break;
+         case GL_TEXTURE_CUBE_MAP_ARB:
+            if (needLambda) {
+               swrast->TextureSample[texUnit] = sample_lambda_cube;
+            }
+            else if (t->MinFilter==GL_LINEAR) {
+               swrast->TextureSample[texUnit] = sample_linear_cube;
+            }
+            else {
+               ASSERT(t->MinFilter==GL_NEAREST);
+               swrast->TextureSample[texUnit] = sample_nearest_cube;
+            }
+            break;
+         case GL_TEXTURE_RECTANGLE_NV:
+            if (needLambda) {
+               swrast->TextureSample[texUnit] = sample_lambda_rect;
+            }
+            else if (t->MinFilter == GL_LINEAR) {
+               swrast->TextureSample[texUnit] = sample_linear_rect;
+            }
+            else {
+               ASSERT(t->MinFilter == GL_NEAREST);
+               swrast->TextureSample[texUnit] = sample_nearest_rect;
+            }
+            break;
+         default:
+            _mesa_problem(NULL, "invalid dimensions in _mesa_set_texture_sampler");
+      }
+   }
+}
+
+
+#define PROD(A,B)   ( (GLuint)(A) * ((GLuint)(B)+1) )
+#define S_PROD(A,B) ( (GLint)(A) * ((GLint)(B)+1) )
+
+static INLINE void
+texture_combine(const GLcontext *ctx,
+                const struct gl_texture_unit *textureUnit,
+                GLuint n,
+                CONST GLchan (*primary_rgba)[4],
+                CONST GLchan (*texel)[4],
+                GLchan (*rgba)[4])
+{
+   const GLchan (*argRGB [3])[4];
+   const GLchan (*argA [3])[4];
+   GLuint i, j;
+   const GLuint RGBshift = textureUnit->CombineScaleShiftRGB;
+   const GLuint Ashift   = textureUnit->CombineScaleShiftA;
+#if CHAN_TYPE == GL_FLOAT
+   const GLchan RGBmult = (GLfloat) (1 << RGBshift);
+   const GLchan Amult = (GLfloat) (1 << Ashift);
+#else
+   const GLint half = (CHAN_MAX + 1) / 2;
+#endif
+
+   DEFMNARRAY(GLchan, ccolor, 3, 3 * MAX_WIDTH, 4);  /* mac 32k limitation */
+   CHECKARRAY(ccolor, return);  /* mac 32k limitation */
+
+   ASSERT(ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine);
+
+   /*
+    * Do operand setup for up to 3 operands.  Loop over the terms.
+    */
+   for (j = 0; j < 3; j++) {
+      switch (textureUnit->CombineSourceA[j]) {
+         case GL_TEXTURE:
+            argA[j] = texel;
+            break;
+         case GL_PRIMARY_COLOR_EXT:
+            argA[j] = primary_rgba;
+            break;
+         case GL_PREVIOUS_EXT:
+            argA[j] = (const GLchan (*)[4]) rgba;
+            break;
+         case GL_CONSTANT_EXT:
+            {
+               GLchan alpha, (*c)[4] = ccolor[j];
+               UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
+               for (i = 0; i < n; i++)
+                  c[i][ACOMP] = alpha;
+               argA[j] = (const GLchan (*)[4]) ccolor[j];
+            }
+            break;
+         default:
+            _mesa_problem(ctx, "invalid combine source");
+      }
+
+      switch (textureUnit->CombineSourceRGB[j]) {
+         case GL_TEXTURE:
+            argRGB[j] = texel;
+            break;
+         case GL_PRIMARY_COLOR_EXT:
+            argRGB[j] = primary_rgba;
+            break;
+         case GL_PREVIOUS_EXT:
+            argRGB[j] = (const GLchan (*)[4]) rgba;
+            break;
+         case GL_CONSTANT_EXT:
+            {
+               GLchan (*c)[4] = ccolor[j];
+               GLchan red, green, blue, alpha;
+               UNCLAMPED_FLOAT_TO_CHAN(red,   textureUnit->EnvColor[0]);
+               UNCLAMPED_FLOAT_TO_CHAN(green, textureUnit->EnvColor[1]);
+               UNCLAMPED_FLOAT_TO_CHAN(blue,  textureUnit->EnvColor[2]);
+               UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
+               for (i = 0; i < n; i++) {
+                  c[i][RCOMP] = red;
+                  c[i][GCOMP] = green;
+                  c[i][BCOMP] = blue;
+                  c[i][ACOMP] = alpha;
+               }
+               argRGB[j] = (const GLchan (*)[4]) ccolor[j];
+            }
+            break;
+         default:
+            _mesa_problem(ctx, "invalid combine source");
+      }
+
+      if (textureUnit->CombineOperandRGB[j] != GL_SRC_COLOR) {
+         const GLchan (*src)[4] = argRGB[j];
+         GLchan (*dst)[4] = ccolor[j];
+
+         /* point to new arg[j] storage */
+         argRGB[j] = (const GLchan (*)[4]) ccolor[j];
+
+         if (textureUnit->CombineOperandRGB[j] == GL_ONE_MINUS_SRC_COLOR) {
+            for (i = 0; i < n; i++) {
+               dst[i][RCOMP] = CHAN_MAX - src[i][RCOMP];
+               dst[i][GCOMP] = CHAN_MAX - src[i][GCOMP];
+               dst[i][BCOMP] = CHAN_MAX - src[i][BCOMP];
+            }
+         }
+         else if (textureUnit->CombineOperandRGB[j] == GL_SRC_ALPHA) {
+            for (i = 0; i < n; i++) {
+               dst[i][RCOMP] = src[i][ACOMP];
+               dst[i][GCOMP] = src[i][ACOMP];
+               dst[i][BCOMP] = src[i][ACOMP];
+            }
+         }
+         else {
+            ASSERT(textureUnit->CombineOperandRGB[j] ==GL_ONE_MINUS_SRC_ALPHA);
+            for (i = 0; i < n; i++) {
+               dst[i][RCOMP] = CHAN_MAX - src[i][ACOMP];
+               dst[i][GCOMP] = CHAN_MAX - src[i][ACOMP];
+               dst[i][BCOMP] = CHAN_MAX - src[i][ACOMP];
+            }
+         }
+      }
+
+      if (textureUnit->CombineOperandA[j] == GL_ONE_MINUS_SRC_ALPHA) {
+         const GLchan (*src)[4] = argA[j];
+         GLchan (*dst)[4] = ccolor[j];
+         argA[j] = (const GLchan (*)[4]) ccolor[j];
+         for (i = 0; i < n; i++) {
+            dst[i][ACOMP] = CHAN_MAX - src[i][ACOMP];
+         }
+      }
+
+      if (textureUnit->CombineModeRGB == GL_REPLACE &&
+          textureUnit->CombineModeA == GL_REPLACE) {
+         break;      /*  done, we need only arg0  */
+      }
+
+      if (j == 1 &&
+          textureUnit->CombineModeRGB != GL_INTERPOLATE_EXT &&
+          textureUnit->CombineModeA != GL_INTERPOLATE_EXT) {
+         break;      /*  arg0 and arg1 are done. we don't need arg2. */
+      }
+   }
+
+   /*
+    * Do the texture combine.
+    */
+   switch (textureUnit->CombineModeRGB) {
+      case GL_REPLACE:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            if (RGBshift) {
+               for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+                  rgba[i][RCOMP] = arg0[i][RCOMP] * RGBmult;
+                  rgba[i][GCOMP] = arg0[i][GCOMP] * RGBmult;
+                  rgba[i][BCOMP] = arg0[i][BCOMP] * RGBmult;
+#else
+                  GLuint r = (GLuint) arg0[i][RCOMP] << RGBshift;
+                  GLuint g = (GLuint) arg0[i][GCOMP] << RGBshift;
+                  GLuint b = (GLuint) arg0[i][BCOMP] << RGBshift;
+                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+#endif
+               }
+            }
+            else {
+               for (i = 0; i < n; i++) {
+                  rgba[i][RCOMP] = arg0[i][RCOMP];
+                  rgba[i][GCOMP] = arg0[i][GCOMP];
+                  rgba[i][BCOMP] = arg0[i][BCOMP];
+               }
+            }
+         }
+         break;
+      case GL_MODULATE:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+#if CHAN_TYPE != GL_FLOAT
+            const GLint shift = CHAN_BITS - RGBshift;
+#endif
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * RGBmult;
+               rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * RGBmult;
+               rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * RGBmult;
+#else
+               GLuint r = PROD(arg0[i][RCOMP], arg1[i][RCOMP]) >> shift;
+               GLuint g = PROD(arg0[i][GCOMP], arg1[i][GCOMP]) >> shift;
+               GLuint b = PROD(arg0[i][BCOMP], arg1[i][BCOMP]) >> shift;
+               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_ADD:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * RGBmult;
+               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * RGBmult;
+               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * RGBmult;
+#else
+               GLint r = ((GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP]) << RGBshift;
+               GLint g = ((GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP]) << RGBshift;
+               GLint b = ((GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP]) << RGBshift;
+               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_ADD_SIGNED_EXT:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5) * RGBmult;
+               rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5) * RGBmult;
+               rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5) * RGBmult;
+#else
+               GLint r = (GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP] -half;
+               GLint g = (GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP] -half;
+               GLint b = (GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP] -half;
+               r = (r < 0) ? 0 : r << RGBshift;
+               g = (g < 0) ? 0 : g << RGBshift;
+               b = (b < 0) ? 0 : b << RGBshift;
+               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_INTERPOLATE_EXT:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
+#if CHAN_TYPE != GL_FLOAT
+            const GLint shift = CHAN_BITS - RGBshift;
+#endif
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +
+                      arg1[i][RCOMP] * (CHAN_MAXF - arg2[i][RCOMP])) * RGBmult;
+               rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +
+                      arg1[i][GCOMP] * (CHAN_MAXF - arg2[i][GCOMP])) * RGBmult;
+               rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +
+                      arg1[i][BCOMP] * (CHAN_MAXF - arg2[i][BCOMP])) * RGBmult;
+#else
+               GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
+                           + PROD(arg1[i][RCOMP], CHAN_MAX - arg2[i][RCOMP]))
+                              >> shift;
+               GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
+                           + PROD(arg1[i][GCOMP], CHAN_MAX - arg2[i][GCOMP]))
+                              >> shift;
+               GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
+                           + PROD(arg1[i][BCOMP], CHAN_MAX - arg2[i][BCOMP]))
+                              >> shift;
+               rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
+               rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
+               rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_SUBTRACT_ARB:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * RGBmult;
+               rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * RGBmult;
+               rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * RGBmult;
+#else
+               GLint r = ((GLint) arg0[i][RCOMP] - (GLint) arg1[i][RCOMP]) << RGBshift;
+               GLint g = ((GLint) arg0[i][GCOMP] - (GLint) arg1[i][GCOMP]) << RGBshift;
+               GLint b = ((GLint) arg0[i][BCOMP] - (GLint) arg1[i][BCOMP]) << RGBshift;
+               rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
+               rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
+               rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_DOT3_RGB_EXT:
+      case GL_DOT3_RGBA_EXT:
+         {
+            /* Do not scale the result by 1 2 or 4 */
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
+                             (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
+                             (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
+                            * 4.0F;
+               dot = CLAMP(dot, 0.0F, CHAN_MAXF);
+#else
+               GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
+				   (GLint)arg1[i][RCOMP] - half) +
+			    S_PROD((GLint)arg0[i][GCOMP] - half,
+				   (GLint)arg1[i][GCOMP] - half) +
+			    S_PROD((GLint)arg0[i][BCOMP] - half,
+				   (GLint)arg1[i][BCOMP] - half)) >> 6;
+               dot = CLAMP(dot, 0, CHAN_MAX);
+#endif
+               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
+            }
+         }
+         break;
+      case GL_DOT3_RGB_ARB:
+      case GL_DOT3_RGBA_ARB:
+         {
+            /* DO scale the result by 1 2 or 4 */
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
+                             (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
+                             (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
+                            * 4.0F * RGBmult;
+               dot = CLAMP(dot, 0.0, CHAN_MAXF);
+#else
+               GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
+				   (GLint)arg1[i][RCOMP] - half) +
+			    S_PROD((GLint)arg0[i][GCOMP] - half,
+				   (GLint)arg1[i][GCOMP] - half) +
+			    S_PROD((GLint)arg0[i][BCOMP] - half,
+				   (GLint)arg1[i][BCOMP] - half)) >> 6;
+               dot <<= RGBshift;
+               dot = CLAMP(dot, 0, CHAN_MAX);
+#endif
+               rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
+            }
+         }
+         break;
+      default:
+         _mesa_problem(ctx, "invalid combine mode");
+   }
+
+   switch (textureUnit->CombineModeA) {
+      case GL_REPLACE:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+            if (Ashift) {
+               for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+                  GLchan a = arg0[i][ACOMP] * Amult;
+#else
+                  GLuint a = (GLuint) arg0[i][ACOMP] << Ashift;
+#endif
+                  rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+               }
+            }
+            else {
+               for (i = 0; i < n; i++) {
+                  rgba[i][ACOMP] = arg0[i][ACOMP];
+               }
+            }
+         }
+         break;
+      case GL_MODULATE:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+#if CHAN_TYPE != GL_FLOAT
+            const GLint shift = CHAN_BITS - Ashift;
+#endif
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * Amult;
+#else
+               GLuint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> shift);
+               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_ADD:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+            const GLchan  (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * Amult;
+#else
+               GLint a = ((GLint) arg0[i][ACOMP] + arg1[i][ACOMP]) << Ashift;
+               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_ADD_SIGNED_EXT:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * Amult;
+#else
+               GLint a = (GLint) arg0[i][ACOMP] + (GLint) arg1[i][ACOMP] -half;
+               a = (a < 0) ? 0 : a << Ashift;
+               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_INTERPOLATE_EXT:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+            const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
+#if CHAN_TYPE != GL_FLOAT
+            const GLint shift = CHAN_BITS - Ashift;
+#endif
+            for (i=0; i<n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +
+                                 arg1[i][ACOMP] * (CHAN_MAXF - arg2[i][ACOMP]))
+                                * Amult;
+#else
+               GLuint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
+                           + PROD(arg1[i][ACOMP], CHAN_MAX - arg2[i][ACOMP]))
+                              >> shift;
+               rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+      case GL_SUBTRACT_ARB:
+         {
+            const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
+            const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
+            for (i = 0; i < n; i++) {
+#if CHAN_TYPE == GL_FLOAT
+               rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * Amult;
+#else
+               GLint a = ((GLint) arg0[i][ACOMP] - (GLint) arg1[i][ACOMP]) << Ashift;
+               rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
+#endif
+            }
+         }
+         break;
+
+      default:
+         _mesa_problem(ctx, "invalid combine mode");
+   }
+
+   /* Fix the alpha component for GL_DOT3_RGBA_EXT/ARB combining.
+    * This is kind of a kludge.  It would have been better if the spec
+    * were written such that the GL_COMBINE_ALPHA value could be set to
+    * GL_DOT3.
+    */
+   if (textureUnit->CombineModeRGB == GL_DOT3_RGBA_EXT ||
+       textureUnit->CombineModeRGB == GL_DOT3_RGBA_ARB) {
+      for (i = 0; i < n; i++) {
+	 rgba[i][ACOMP] = rgba[i][RCOMP];
+      }
+   }
+   UNDEFARRAY(ccolor);  /* mac 32k limitation */
+}
+#undef PROD
+
+
+
+/**********************************************************************/
+/*                      Texture Application                           */
+/**********************************************************************/
+
+
+/*
+ * Combine incoming fragment color with texel color to produce output color.
+ * Input:  textureUnit - pointer to texture unit to apply
+ *         format - base internal texture format
+ *         n - number of fragments
+ *         primary_rgba - primary colors (may alias rgba for single texture)
+ *         texels - array of texel colors
+ * InOut:  rgba - incoming fragment colors modified by texel colors
+ *                according to the texture environment mode.
+ */
+static void
+apply_texture( const GLcontext *ctx,
+               const struct gl_texture_unit *texUnit,
+               GLuint n,
+               CONST GLchan primary_rgba[][4], CONST GLchan texel[][4],
+               GLchan rgba[][4] )
+{
+   GLint baseLevel;
+   GLuint i;
+   GLint Rc, Gc, Bc, Ac;
+   GLenum format;
+
+   ASSERT(texUnit);
+   ASSERT(texUnit->_Current);
+
+   baseLevel = texUnit->_Current->BaseLevel;
+   ASSERT(texUnit->_Current->Image[baseLevel]);
+
+   format = texUnit->_Current->Image[baseLevel]->Format;
+
+   if (format==GL_COLOR_INDEX || format==GL_DEPTH_COMPONENT || format==GL_YCBCR_MESA) {
+      format = GL_RGBA;  /* XXXX a hack! */
+   }
+
+   switch (texUnit->EnvMode) {
+      case GL_REPLACE:
+	 switch (format) {
+	    case GL_ALPHA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf */
+                  /* Av = At */
+                  rgba[i][ACOMP] = texel[i][ACOMP];
+	       }
+	       break;
+	    case GL_LUMINANCE:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Lt */
+                  GLchan Lt = texel[i][RCOMP];
+                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
+                  /* Av = Af */
+	       }
+	       break;
+	    case GL_LUMINANCE_ALPHA:
+	       for (i=0;i<n;i++) {
+                  GLchan Lt = texel[i][RCOMP];
+		  /* Cv = Lt */
+		  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
+		  /* Av = At */
+		  rgba[i][ACOMP] = texel[i][ACOMP];
+	       }
+	       break;
+	    case GL_INTENSITY:
+	       for (i=0;i<n;i++) {
+		  /* Cv = It */
+                  GLchan It = texel[i][RCOMP];
+                  rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = It;
+                  /* Av = It */
+                  rgba[i][ACOMP] = It;
+	       }
+	       break;
+	    case GL_RGB:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Ct */
+		  rgba[i][RCOMP] = texel[i][RCOMP];
+		  rgba[i][GCOMP] = texel[i][GCOMP];
+		  rgba[i][BCOMP] = texel[i][BCOMP];
+		  /* Av = Af */
+	       }
+	       break;
+	    case GL_RGBA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Ct */
+		  rgba[i][RCOMP] = texel[i][RCOMP];
+		  rgba[i][GCOMP] = texel[i][GCOMP];
+		  rgba[i][BCOMP] = texel[i][BCOMP];
+		  /* Av = At */
+		  rgba[i][ACOMP] = texel[i][ACOMP];
+	       }
+	       break;
+            default:
+               _mesa_problem(ctx, "Bad format (GL_REPLACE) in apply_texture");
+               return;
+	 }
+	 break;
+
+      case GL_MODULATE:
+         switch (format) {
+	    case GL_ALPHA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf */
+		  /* Av = AfAt */
+		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+	       }
+	       break;
+	    case GL_LUMINANCE:
+	       for (i=0;i<n;i++) {
+		  /* Cv = LtCf */
+                  GLchan Lt = texel[i][RCOMP];
+		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
+		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
+		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
+		  /* Av = Af */
+	       }
+	       break;
+	    case GL_LUMINANCE_ALPHA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = CfLt */
+                  GLchan Lt = texel[i][RCOMP];
+		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
+		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
+		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
+		  /* Av = AfAt */
+		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+	       }
+	       break;
+	    case GL_INTENSITY:
+	       for (i=0;i<n;i++) {
+		  /* Cv = CfIt */
+                  GLchan It = texel[i][RCOMP];
+		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], It );
+		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], It );
+		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], It );
+		  /* Av = AfIt */
+		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], It );
+	       }
+	       break;
+	    case GL_RGB:
+	       for (i=0;i<n;i++) {
+		  /* Cv = CfCt */
+		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
+		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
+		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
+		  /* Av = Af */
+	       }
+	       break;
+	    case GL_RGBA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = CfCt */
+		  rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
+		  rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
+		  rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
+		  /* Av = AfAt */
+		  rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
+	       }
+	       break;
+            default:
+               _mesa_problem(ctx, "Bad format (GL_MODULATE) in apply_texture");
+               return;
+	 }
+	 break;
+
+      case GL_DECAL:
+         switch (format) {
+            case GL_ALPHA:
+            case GL_LUMINANCE:
+            case GL_LUMINANCE_ALPHA:
+            case GL_INTENSITY:
+               /* undefined */
+               break;
+	    case GL_RGB:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Ct */
+		  rgba[i][RCOMP] = texel[i][RCOMP];
+		  rgba[i][GCOMP] = texel[i][GCOMP];
+		  rgba[i][BCOMP] = texel[i][BCOMP];
+		  /* Av = Af */
+	       }
+	       break;
+	    case GL_RGBA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf(1-At) + CtAt */
+		  GLint t = texel[i][ACOMP], s = CHAN_MAX - t;
+		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(texel[i][RCOMP],t);
+		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(texel[i][GCOMP],t);
+		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(texel[i][BCOMP],t);
+		  /* Av = Af */
+	       }
+	       break;
+            default:
+               _mesa_problem(ctx, "Bad format (GL_DECAL) in apply_texture");
+               return;
+	 }
+	 break;
+
+      case GL_BLEND:
+         Rc = (GLint) (texUnit->EnvColor[0] * CHAN_MAXF);
+         Gc = (GLint) (texUnit->EnvColor[1] * CHAN_MAXF);
+         Bc = (GLint) (texUnit->EnvColor[2] * CHAN_MAXF);
+         Ac = (GLint) (texUnit->EnvColor[3] * CHAN_MAXF);
+	 switch (format) {
+	    case GL_ALPHA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf */
+		  /* Av = AfAt */
+                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+	       }
+	       break;
+            case GL_LUMINANCE:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf(1-Lt) + CcLt */
+		  GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
+		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
+		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
+		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
+		  /* Av = Af */
+	       }
+	       break;
+	    case GL_LUMINANCE_ALPHA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf(1-Lt) + CcLt */
+		  GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
+		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
+		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
+		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
+		  /* Av = AfAt */
+		  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
+	       }
+	       break;
+            case GL_INTENSITY:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf(1-It) + CcLt */
+		  GLchan It = texel[i][RCOMP], s = CHAN_MAX - It;
+		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, It);
+		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, It);
+		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, It);
+                  /* Av = Af(1-It) + Ac*It */
+                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], s) + CHAN_PRODUCT(Ac, It);
+               }
+               break;
+	    case GL_RGB:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf(1-Ct) + CcCt */
+		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
+		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
+		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
+		  /* Av = Af */
+	       }
+	       break;
+	    case GL_RGBA:
+	       for (i=0;i<n;i++) {
+		  /* Cv = Cf(1-Ct) + CcCt */
+		  rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
+		  rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
+		  rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
+		  /* Av = AfAt */
+		  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
+	       }
+	       break;
+            default:
+               _mesa_problem(ctx, "Bad format (GL_BLEND) in apply_texture");
+               return;
+	 }
+	 break;
+
+     /* XXX don't clamp results if GLchan is float??? */
+
+      case GL_ADD:  /* GL_EXT_texture_add_env */
+         switch (format) {
+            case GL_ALPHA:
+               for (i=0;i<n;i++) {
+                  /* Rv = Rf */
+                  /* Gv = Gf */
+                  /* Bv = Bf */
+                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+               }
+               break;
+            case GL_LUMINANCE:
+               for (i=0;i<n;i++) {
+                  GLuint Lt = texel[i][RCOMP];
+                  GLuint r = rgba[i][RCOMP] + Lt;
+                  GLuint g = rgba[i][GCOMP] + Lt;
+                  GLuint b = rgba[i][BCOMP] + Lt;
+                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+                  /* Av = Af */
+               }
+               break;
+            case GL_LUMINANCE_ALPHA:
+               for (i=0;i<n;i++) {
+                  GLuint Lt = texel[i][RCOMP];
+                  GLuint r = rgba[i][RCOMP] + Lt;
+                  GLuint g = rgba[i][GCOMP] + Lt;
+                  GLuint b = rgba[i][BCOMP] + Lt;
+                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+               }
+               break;
+            case GL_INTENSITY:
+               for (i=0;i<n;i++) {
+                  GLchan It = texel[i][RCOMP];
+                  GLuint r = rgba[i][RCOMP] + It;
+                  GLuint g = rgba[i][GCOMP] + It;
+                  GLuint b = rgba[i][BCOMP] + It;
+                  GLuint a = rgba[i][ACOMP] + It;
+                  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+                  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+                  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+                  rgba[i][ACOMP] = MIN2(a, CHAN_MAX);
+               }
+               break;
+	    case GL_RGB:
+	       for (i=0;i<n;i++) {
+                  GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
+                  GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
+                  GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
+		  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+		  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+		  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+		  /* Av = Af */
+	       }
+	       break;
+	    case GL_RGBA:
+	       for (i=0;i<n;i++) {
+                  GLuint r = rgba[i][RCOMP] + texel[i][RCOMP];
+                  GLuint g = rgba[i][GCOMP] + texel[i][GCOMP];
+                  GLuint b = rgba[i][BCOMP] + texel[i][BCOMP];
+		  rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
+		  rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
+		  rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
+                  rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
+               }
+               break;
+            default:
+               _mesa_problem(ctx, "Bad format (GL_ADD) in apply_texture");
+               return;
+	 }
+	 break;
+
+      case GL_COMBINE_EXT:
+         texture_combine(ctx, texUnit, n, primary_rgba, texel, rgba);
+         break;
+
+      default:
+         _mesa_problem(ctx, "Bad env mode in apply_texture");
+         return;
+   }
+}
+
+
+
+/*
+ * Sample a shadow/depth texture.
+ * Input:  ctx - context
+ *         texUnit - the texture unit
+ *         n - number of samples
+ *         s,t,r - array [n] of texture coordinates
+ * In/Out:  rgba - array [n] of texel colors.
+ */
+static void
+sample_depth_texture(const GLcontext *ctx,
+                     const struct gl_texture_unit *texUnit,
+                     GLuint n,
+                     const GLfloat s[], const GLfloat t[], const GLfloat r[],
+                     GLchan texel[][4])
+{
+   const struct gl_texture_object *texObj = texUnit->_Current;
+   const GLint baseLevel = texObj->BaseLevel;
+   const struct gl_texture_image *texImage = texObj->Image[baseLevel];
+   const GLuint width = texImage->Width;
+   const GLuint height = texImage->Height;
+   const GLchan ambient = texObj->ShadowAmbient;
+   GLboolean lequal, gequal;
+
+   if (texObj->Target != GL_TEXTURE_2D) {
+      _mesa_problem(ctx, "only 2-D depth textures supported at this time");
+      return;
+   }
+
+   if (texObj->MinFilter != texObj->MagFilter) {
+      _mesa_problem(ctx, "mipmapped depth textures not supported at this time");
+      return;
+   }
+
+   /* XXX the GL_SGIX_shadow extension spec doesn't say what to do if
+    * GL_TEXTURE_COMPARE_SGIX == GL_TRUE but the current texture object
+    * isn't a depth texture.
+    */
+   if (texImage->Format != GL_DEPTH_COMPONENT) {
+      _mesa_problem(ctx,"GL_TEXTURE_COMPARE_SGIX enabled with non-depth texture");
+      return;
+   }
+
+   if (texObj->CompareOperator == GL_TEXTURE_LEQUAL_R_SGIX) {
+      lequal = GL_TRUE;
+      gequal = GL_FALSE;
+   }
+   else {
+      lequal = GL_FALSE;
+      gequal = GL_TRUE;
+   }
+
+   if (texObj->MagFilter == GL_NEAREST) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         GLfloat depthSample;
+         GLint col, row;
+         COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, s[i], width, col);
+         COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, t[i], height, row);
+         depthSample = *((const GLfloat *) texImage->Data + row * width + col);
+         if ((r[i] <= depthSample && lequal) ||
+             (r[i] >= depthSample && gequal)) {
+            texel[i][RCOMP] = CHAN_MAX;
+            texel[i][GCOMP] = CHAN_MAX;
+            texel[i][BCOMP] = CHAN_MAX;
+            texel[i][ACOMP] = CHAN_MAX;
+         }
+         else {
+            texel[i][RCOMP] = ambient;
+            texel[i][GCOMP] = ambient;
+            texel[i][BCOMP] = ambient;
+            texel[i][ACOMP] = CHAN_MAX;
+         }
+      }
+   }
+   else {
+      GLuint i;
+      ASSERT(texObj->MagFilter == GL_LINEAR);
+      for (i = 0; i < n; i++) {
+         GLfloat depth00, depth01, depth10, depth11;
+         GLint i0, i1, j0, j1;
+         GLfloat u, v;
+         GLuint useBorderTexel;
+
+         COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapS, s[i], u, width, i0, i1);
+         COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapT, t[i], v, height,j0, j1);
+
+         useBorderTexel = 0;
+         if (texImage->Border) {
+            i0 += texImage->Border;
+            i1 += texImage->Border;
+            j0 += texImage->Border;
+            j1 += texImage->Border;
+         }
+         else {
+            if (i0 < 0 || i0 >= (GLint) width)   useBorderTexel |= I0BIT;
+            if (i1 < 0 || i1 >= (GLint) width)   useBorderTexel |= I1BIT;
+            if (j0 < 0 || j0 >= (GLint) height)  useBorderTexel |= J0BIT;
+            if (j1 < 0 || j1 >= (GLint) height)  useBorderTexel |= J1BIT;
+         }
+
+         /* get four depth samples from the texture */
+         if (useBorderTexel & (I0BIT | J0BIT)) {
+            depth00 = 1.0;
+         }
+         else {
+            depth00 = *((const GLfloat *) texImage->Data + j0 * width + i0);
+         }
+         if (useBorderTexel & (I1BIT | J0BIT)) {
+            depth10 = 1.0;
+         }
+         else {
+            depth10 = *((const GLfloat *) texImage->Data + j0 * width + i1);
+         }
+         if (useBorderTexel & (I0BIT | J1BIT)) {
+            depth01 = 1.0;
+         }
+         else {
+            depth01 = *((const GLfloat *) texImage->Data + j1 * width + i0);
+         }
+         if (useBorderTexel & (I1BIT | J1BIT)) {
+            depth11 = 1.0;
+         }
+         else {
+            depth11 = *((const GLfloat *) texImage->Data + j1 * width + i1);
+         }
+
+         if (0) {
+            /* compute a single weighted depth sample and do one comparison */
+            const GLfloat a = FRAC(u + 1.0F);
+            const GLfloat b = FRAC(v + 1.0F);
+            const GLfloat w00 = (1.0F - a) * (1.0F - b);
+            const GLfloat w10 = (       a) * (1.0F - b);
+            const GLfloat w01 = (1.0F - a) * (       b);
+            const GLfloat w11 = (       a) * (       b);
+            const GLfloat depthSample = w00 * depth00 + w10 * depth10
+                                      + w01 * depth01 + w11 * depth11;
+            if ((depthSample <= r[i] && lequal) ||
+                (depthSample >= r[i] && gequal)) {
+               texel[i][RCOMP] = ambient;
+               texel[i][GCOMP] = ambient;
+               texel[i][BCOMP] = ambient;
+               texel[i][ACOMP] = CHAN_MAX;
+            }
+            else {
+               texel[i][RCOMP] = CHAN_MAX;
+               texel[i][GCOMP] = CHAN_MAX;
+               texel[i][BCOMP] = CHAN_MAX;
+               texel[i][ACOMP] = CHAN_MAX;
+            }
+         }
+         else {
+            /* Do four depth/R comparisons and compute a weighted result.
+             * If this touches on somebody's I.P., I'll remove this code
+             * upon request.
+             */
+            const GLfloat d = (CHAN_MAXF - (GLfloat) ambient) * 0.25F;
+            GLfloat luminance = CHAN_MAXF;
+            GLchan lum;
+            if (lequal) {
+               if (depth00 <= r[i])   luminance -= d;
+               if (depth01 <= r[i])   luminance -= d;
+               if (depth10 <= r[i])   luminance -= d;
+               if (depth11 <= r[i])   luminance -= d;
+            }
+            else {
+               if (depth00 >= r[i])   luminance -= d;
+               if (depth01 >= r[i])   luminance -= d;
+               if (depth10 >= r[i])   luminance -= d;
+               if (depth11 >= r[i])   luminance -= d;
+            }
+            lum = (GLchan) luminance;
+            texel[i][RCOMP] = lum;
+            texel[i][GCOMP] = lum;
+            texel[i][BCOMP] = lum;
+            texel[i][ACOMP] = CHAN_MAX;
+         }
+      }
+   }
+}
+
+
+#if 0
+/*
+ * Experimental depth texture sampling function.
+ */
+static void
+sample_depth_texture2(const GLcontext *ctx,
+                     const struct gl_texture_unit *texUnit,
+                     GLuint n,
+                     const GLfloat s[], const GLfloat t[], const GLfloat r[],
+                     GLchan texel[][4])
+{
+   const struct gl_texture_object *texObj = texUnit->_Current;
+   const GLint baseLevel = texObj->BaseLevel;
+   const struct gl_texture_image *texImage = texObj->Image[baseLevel];
+   const GLuint width = texImage->Width;
+   const GLuint height = texImage->Height;
+   const GLchan ambient = texObj->ShadowAmbient;
+   GLboolean lequal, gequal;
+
+   if (texObj->Dimensions != 2) {
+      _mesa_problem(ctx, "only 2-D depth textures supported at this time");
+      return;
+   }
+
+   if (texObj->MinFilter != texObj->MagFilter) {
+      _mesa_problem(ctx, "mipmapped depth textures not supported at this time");
+      return;
+   }
+
+   /* XXX the GL_SGIX_shadow extension spec doesn't say what to do if
+    * GL_TEXTURE_COMPARE_SGIX == GL_TRUE but the current texture object
+    * isn't a depth texture.
+    */
+   if (texImage->Format != GL_DEPTH_COMPONENT) {
+      _mesa_problem(ctx,"GL_TEXTURE_COMPARE_SGIX enabled with non-depth texture");
+      return;
+   }
+
+   if (texObj->CompareOperator == GL_TEXTURE_LEQUAL_R_SGIX) {
+      lequal = GL_TRUE;
+      gequal = GL_FALSE;
+   }
+   else {
+      lequal = GL_FALSE;
+      gequal = GL_TRUE;
+   }
+
+   {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         const GLint K = 3;
+         GLint col, row, ii, jj, imin, imax, jmin, jmax, samples, count;
+         GLfloat w;
+         GLchan lum;
+         COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, s[i], width, col);
+         COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, t[i], height, row);
+
+         imin = col - K;
+         imax = col + K;
+         jmin = row - K;
+         jmax = row + K;
+
+         if (imin < 0)  imin = 0;
+         if (imax >= width)  imax = width - 1;
+         if (jmin < 0)  jmin = 0;
+         if (jmax >= height) jmax = height - 1;
+
+         samples = (imax - imin + 1) * (jmax - jmin + 1);
+         count = 0;
+         for (jj = jmin; jj <= jmax; jj++) {
+            for (ii = imin; ii <= imax; ii++) {
+               GLfloat depthSample = *((const GLfloat *) texImage->Data
+                                       + jj * width + ii);
+               if ((depthSample <= r[i] && lequal) ||
+                   (depthSample >= r[i] && gequal)) {
+                  count++;
+               }
+            }
+         }
+
+         w = (GLfloat) count / (GLfloat) samples;
+         w = CHAN_MAXF - w * (CHAN_MAXF - (GLfloat) ambient);
+         lum = (GLint) w;
+
+         texel[i][RCOMP] = lum;
+         texel[i][GCOMP] = lum;
+         texel[i][BCOMP] = lum;
+         texel[i][ACOMP] = CHAN_MAX;
+      }
+   }
+}
+#endif
+
+
+/*
+ * Apply a unit of texture mapping to the incoming fragments.
+ */
+void
+_swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
+                           const GLfloat s[], const GLfloat t[],
+                           const GLfloat r[], GLfloat lambda[],
+                           CONST GLchan primary_rgba[][4], GLchan rgba[][4] )
+{
+   const GLuint mask = TEXTURE0_ANY << (texUnit * NUM_TEXTURE_TARGETS);
+
+   if (ctx->Texture._ReallyEnabled & mask) {
+      const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
+
+      if (textureUnit->_Current) {   /* XXX need this? */
+         GLchan texel[PB_SIZE][4];
+
+         if (lambda) {
+            if (textureUnit->LodBias != 0.0F) {
+               /* apply LOD bias, but don't clamp yet */
+               GLuint i;
+               for (i=0;i<n;i++) {
+                  lambda[i] += textureUnit->LodBias;
+               }
+            }
+
+            if (textureUnit->_Current->MinLod != -1000.0 ||
+                textureUnit->_Current->MaxLod != 1000.0) {
+               /* apply LOD clamping to lambda */
+               const GLfloat min = textureUnit->_Current->MinLod;
+               const GLfloat max = textureUnit->_Current->MaxLod;
+               GLuint i;
+               for (i=0;i<n;i++) {
+                  GLfloat l = lambda[i];
+                  lambda[i] = CLAMP(l, min, max);
+               }
+            }
+         }
+
+         /* Sample the texture. */
+         if (textureUnit->_Current->CompareFlag) {
+            /* depth texture */
+            sample_depth_texture(ctx, textureUnit, n, s, t, r, texel);
+         }
+         else {
+            /* color texture */
+            SWRAST_CONTEXT(ctx)->TextureSample[texUnit]( ctx, texUnit,
+                                                         textureUnit->_Current,
+                                                         n, s, t, r,
+                                                         lambda, texel );
+         }
+         apply_texture( ctx, textureUnit, n, primary_rgba,
+                        (const GLchan (*)[4]) texel, rgba );
+      }
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_texture.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_texture.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_texture.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,48 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_TEXTURE_H
+#define S_TEXTURE_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+extern void
+_swrast_choose_texture_sample_func( GLcontext *ctx,
+				    GLuint texUnit,
+				    const struct gl_texture_object *tObj );
+
+
+extern void
+_swrast_texture_fragments( GLcontext *ctx, GLuint texSet, GLuint n,
+                           const GLfloat s[], const GLfloat t[],
+                           const GLfloat r[], GLfloat lambda[],
+                           CONST GLchan primary_rgba[][4], GLchan rgba[][4] );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_triangle.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_triangle.c:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_triangle.c	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,1795 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.2
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/*
+ * When the device driver doesn't implement triangle rasterization it
+ * can hook in _swrast_Triangle, which eventually calls one of these
+ * functions to draw triangles.
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "texformat.h"
+#include "teximage.h"
+#include "texstate.h"
+
+#include "s_aatriangle.h"
+#include "s_context.h"
+#include "s_depth.h"
+#include "s_feedback.h"
+#include "s_span.h"
+#include "s_triangle.h"
+#include "s_trispan.h"
+
+
+
+GLboolean _mesa_cull_triangle( GLcontext *ctx,
+			    const SWvertex *v0,
+			    const SWvertex *v1,
+			    const SWvertex *v2 )
+{
+   GLfloat ex = v1->win[0] - v0->win[0];
+   GLfloat ey = v1->win[1] - v0->win[1];
+   GLfloat fx = v2->win[0] - v0->win[0];
+   GLfloat fy = v2->win[1] - v0->win[1];
+   GLfloat c = ex*fy-ey*fx;
+
+   if (c * SWRAST_CONTEXT(ctx)->_backface_sign > 0)
+      return 0;
+
+   return 1;
+}
+
+
+
+/*
+ * Render a flat-shaded color index triangle.
+ */
+static void flat_ci_triangle( GLcontext *ctx,
+			      const SWvertex *v0,
+			      const SWvertex *v1,
+			      const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+
+#define RENDER_SPAN( span )						\
+   GLdepth zSpan[MAX_WIDTH];						\
+   GLfloat fogSpan[MAX_WIDTH];						\
+   GLuint i;								\
+   for (i = 0; i < span.count; i++) {					\
+      zSpan[i] = FixedToDepth(span.z);					\
+      span.z += span.zStep;						\
+      fogSpan[i] = span.fog;						\
+      span.fog += span.fogStep;						\
+   }									\
+   _mesa_write_monoindex_span(ctx, span.count, span.x, span.y,		\
+	                      zSpan, fogSpan, v2->index, NULL, GL_POLYGON );
+
+#include "s_tritemp.h"
+}
+
+
+
+/*
+ * Render a smooth-shaded color index triangle.
+ */
+static void smooth_ci_triangle( GLcontext *ctx,
+				const SWvertex *v0,
+				const SWvertex *v1,
+				const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define INTERP_INDEX 1
+
+#define RENDER_SPAN( span )						\
+   GLdepth zSpan[MAX_WIDTH];						\
+   GLfloat fogSpan[MAX_WIDTH];						\
+   GLuint indexSpan[MAX_WIDTH];						\
+   GLuint i;						                \
+   for (i = 0; i < span.count; i++) {					\
+      zSpan[i] = FixedToDepth(span.z);					\
+      span.z += span.zStep;						\
+      indexSpan[i] = FixedToInt(span.index);				\
+      span.index += span.indexStep;					\
+      fogSpan[i] = span.fog;						\
+      span.fog += span.fogStep;						\
+   }									\
+   _mesa_write_index_span(ctx, span.count, span.x, span.y,		\
+                          zSpan, fogSpan, indexSpan, NULL, GL_POLYGON);
+
+#include "s_tritemp.h"
+}
+
+
+
+/*
+ * Render a flat-shaded RGBA triangle.
+ */
+static void flat_rgba_triangle( GLcontext *ctx,
+				const SWvertex *v0,
+				const SWvertex *v1,
+				const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+
+#define RENDER_SPAN( span )						\
+   GLdepth zSpan[MAX_WIDTH];						\
+   GLfloat fogSpan[MAX_WIDTH];						\
+   GLuint i;								\
+   for (i = 0; i < span.count; i++) {					\
+      zSpan[i] = FixedToDepth(span.z);					\
+      span.z += span.zStep;						\
+      fogSpan[i] = span.fog;						\
+      span.fog += span.fogStep;						\
+   }									\
+   _mesa_write_monocolor_span(ctx, span.count, span.x, span.y, zSpan,	\
+                              fogSpan, v2->color, NULL, GL_POLYGON );
+
+#include "s_tritemp.h"
+
+   ASSERT(!ctx->Texture._ReallyEnabled);  /* texturing must be off */
+   ASSERT(ctx->Light.ShadeModel==GL_FLAT);
+}
+
+
+
+/*
+ * Render a smooth-shaded RGBA triangle.
+ */
+static void smooth_rgba_triangle( GLcontext *ctx,
+				  const SWvertex *v0,
+				  const SWvertex *v1,
+				  const SWvertex *v2 )
+{
+
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+
+#define RENDER_SPAN( span )					\
+   GLdepth zSpan[MAX_WIDTH];					\
+   GLchan rgbaSpan[MAX_WIDTH][4];				\
+   GLfloat fogSpan[MAX_WIDTH];					\
+   GLuint i;				        	        \
+   for (i = 0; i < span.count; i++) {				\
+      rgbaSpan[i][RCOMP] = FixedToChan(span.red);		\
+      rgbaSpan[i][GCOMP] = FixedToChan(span.green);		\
+      rgbaSpan[i][BCOMP] = FixedToChan(span.blue);		\
+      rgbaSpan[i][ACOMP] = FixedToChan(span.alpha);		\
+      span.red += span.redStep;					\
+      span.green += span.greenStep;				\
+      span.blue += span.blueStep;				\
+      span.alpha += span.alphaStep;				\
+      zSpan[i] = FixedToDepth(span.z);				\
+      span.z += span.zStep;					\
+      fogSpan[i] = span.fog;					\
+      span.fog += span.fogStep;					\
+   }								\
+   _mesa_write_rgba_span(ctx, span.count, span.x, span.y,	\
+                         (CONST GLdepth *) zSpan,		\
+                         fogSpan, rgbaSpan, NULL, GL_POLYGON);
+
+#include "s_tritemp.h"
+
+   ASSERT(!ctx->Texture._ReallyEnabled);  /* texturing must be off */
+   ASSERT(ctx->Light.ShadeModel==GL_SMOOTH);
+}
+
+
+/*
+ * Render an RGB, GL_DECAL, textured triangle.
+ * Interpolate S,T only w/out mipmapping or perspective correction.
+ *
+ * No fog.
+ */
+static void simple_textured_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+#define INTERP_INT_TEX 1
+#define S_SCALE twidth
+#define T_SCALE theight
+
+#define SETUP_CODE							\
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);                             \
+   struct gl_texture_object *obj = ctx->Texture.Unit[0].Current2D;	\
+   GLint b = obj->BaseLevel;						\
+   const GLfloat twidth = (GLfloat) obj->Image[b]->Width;		\
+   const GLfloat theight = (GLfloat) obj->Image[b]->Height;		\
+   const GLint twidth_log2 = obj->Image[b]->WidthLog2;			\
+   const GLchan *texture = (const GLchan *) obj->Image[b]->Data;	\
+   const GLint smask = obj->Image[b]->Width - 1;			\
+   const GLint tmask = obj->Image[b]->Height - 1;			\
+   if (!texture) {							\
+      /* this shouldn't happen */					\
+      return;								\
+   }
+
+#define RENDER_SPAN( span  )						\
+   GLchan rgbSpan[MAX_WIDTH][3];					\
+   GLuint i;								\
+   span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\
+   span.intTex[1] -= FIXED_HALF;					\
+   for (i = 0; i < span.count; i++) {					\
+      GLint s = FixedToInt(span.intTex[0]) & smask;			\
+      GLint t = FixedToInt(span.intTex[1]) & tmask;			\
+      GLint pos = (t << twidth_log2) + s;				\
+      pos = pos + pos + pos;  /* multiply by 3 */			\
+      rgbSpan[i][RCOMP] = texture[pos];					\
+      rgbSpan[i][GCOMP] = texture[pos+1];				\
+      rgbSpan[i][BCOMP] = texture[pos+2];				\
+      span.intTex[0] += span.intTexStep[0];				\
+      span.intTex[1] += span.intTexStep[1];				\
+   }									\
+   (*swrast->Driver.WriteRGBSpan)(ctx, span.count, span.x, span.y,	\
+                                  (CONST GLchan (*)[3]) rgbSpan, NULL );
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * Render an RGB, GL_DECAL, textured triangle.
+ * Interpolate S,T, GL_LESS depth test, w/out mipmapping or
+ * perspective correction.
+ *
+ * No fog.
+ */
+static void simple_z_textured_triangle( GLcontext *ctx,
+					const SWvertex *v0,
+					const SWvertex *v1,
+					const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_INT_TEX 1
+#define S_SCALE twidth
+#define T_SCALE theight
+
+#define SETUP_CODE							\
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);                             \
+   struct gl_texture_object *obj = ctx->Texture.Unit[0].Current2D;	\
+   GLint b = obj->BaseLevel;						\
+   GLfloat twidth = (GLfloat) obj->Image[b]->Width;			\
+   GLfloat theight = (GLfloat) obj->Image[b]->Height;			\
+   GLint twidth_log2 = obj->Image[b]->WidthLog2;			\
+   const GLchan *texture = (const GLchan *) obj->Image[b]->Data;	\
+   GLint smask = obj->Image[b]->Width - 1;				\
+   GLint tmask = obj->Image[b]->Height - 1;				\
+   if (!texture) {							\
+      /* this shouldn't happen */					\
+      return;								\
+   }
+
+#define RENDER_SPAN( span )						\
+   GLchan rgbSpan[MAX_WIDTH][3];					\
+   GLubyte mask[MAX_WIDTH];						\
+   GLuint i;				    				\
+   span.intTex[0] -= FIXED_HALF; /* off-by-one error? */		\
+   span.intTex[1] -= FIXED_HALF;					\
+   for (i = 0; i < span.count; i++) {					\
+      const GLdepth z = FixedToDepth(span.z);				\
+      if (z < zRow[i]) {						\
+         GLint s = FixedToInt(span.intTex[0]) & smask;			\
+         GLint t = FixedToInt(span.intTex[1]) & tmask;			\
+         GLint pos = (t << twidth_log2) + s;				\
+         pos = pos + pos + pos;  /* multiply by 3 */			\
+         rgbSpan[i][RCOMP] = texture[pos];				\
+         rgbSpan[i][GCOMP] = texture[pos+1];				\
+         rgbSpan[i][BCOMP] = texture[pos+2];				\
+         zRow[i] = z;							\
+         mask[i] = 1;							\
+      }									\
+      else {								\
+         mask[i] = 0;							\
+      }									\
+      span.intTex[0] += span.intTexStep[0];				\
+      span.intTex[1] += span.intTexStep[1];				\
+      span.z += span.zStep;						\
+   }									\
+   (*swrast->Driver.WriteRGBSpan)(ctx, span.count, span.x, span.y,	\
+                                  (CONST GLchan (*)[3]) rgbSpan, mask );
+
+#include "s_tritemp.h"
+}
+
+
+#if CHAN_TYPE != GL_FLOAT
+
+struct affine_info
+{
+   GLenum filter;
+   GLenum format;
+   GLenum envmode;
+   GLint smask, tmask;
+   GLint twidth_log2;
+   const GLchan *texture;
+   GLfixed er, eg, eb, ea;
+   GLint tbytesline, tsize;
+   GLint fixedToDepthShift;
+};
+
+
+/* This function can handle GL_NEAREST or GL_LINEAR sampling of 2D RGB or RGBA
+ * textures with GL_REPLACE, GL_MODULATE, GL_BLEND, GL_DECAL or GL_ADD
+ * texture env modes.
+ */
+static void
+affine_span(GLcontext *ctx, struct triangle_span *span,
+            struct affine_info *info)
+{
+   GLchan sample[4];  /* the filtered texture sample */
+
+   /* Instead of defining a function for each mode, a test is done
+    * between the outer and inner loops. This is to reduce code size
+    * and complexity. Observe that an optimizing compiler kills
+    * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
+    */
+
+#define NEAREST_RGB			\
+   sample[RCOMP] = tex00[RCOMP];	\
+   sample[GCOMP] = tex00[GCOMP];	\
+   sample[BCOMP] = tex00[BCOMP];	\
+   sample[ACOMP] = CHAN_MAX
+
+#define LINEAR_RGB							\
+   sample[RCOMP] = (ti * (si * tex00[0] + sf * tex01[0]) +		\
+             tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT;	\
+   sample[GCOMP] = (ti * (si * tex00[1] + sf * tex01[1]) +		\
+             tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT;	\
+   sample[BCOMP] = (ti * (si * tex00[2] + sf * tex01[2]) +		\
+             tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT;	\
+   sample[ACOMP] = CHAN_MAX
+
+#define NEAREST_RGBA  COPY_CHAN4(sample, tex00)
+
+#define LINEAR_RGBA							\
+   sample[RCOMP] = (ti * (si * tex00[0] + sf * tex01[0]) +		\
+               tf * (si * tex10[0] + sf * tex11[0])) >> 2 * FIXED_SHIFT;\
+   sample[GCOMP] = (ti * (si * tex00[1] + sf * tex01[1]) +		\
+               tf * (si * tex10[1] + sf * tex11[1])) >> 2 * FIXED_SHIFT;\
+   sample[BCOMP] = (ti * (si * tex00[2] + sf * tex01[2]) +		\
+               tf * (si * tex10[2] + sf * tex11[2])) >> 2 * FIXED_SHIFT;\
+   sample[ACOMP] = (ti * (si * tex00[3] + sf * tex01[3]) +		\
+               tf * (si * tex10[3] + sf * tex11[3])) >> 2 * FIXED_SHIFT
+
+#define MODULATE							   \
+   dest[RCOMP] = span->red   * (sample[RCOMP] + 1u) >> (FIXED_SHIFT + 8); \
+   dest[GCOMP] = span->green * (sample[GCOMP] + 1u) >> (FIXED_SHIFT + 8); \
+   dest[BCOMP] = span->blue  * (sample[BCOMP] + 1u) >> (FIXED_SHIFT + 8); \
+   dest[ACOMP] = span->alpha * (sample[ACOMP] + 1u) >> (FIXED_SHIFT + 8)
+
+#define DECAL								\
+   dest[RCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->red +		\
+               ((sample[ACOMP] + 1) * sample[RCOMP] << FIXED_SHIFT))	\
+               >> (FIXED_SHIFT + 8);					\
+   dest[GCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->green +		\
+               ((sample[ACOMP] + 1) * sample[GCOMP] << FIXED_SHIFT))	\
+               >> (FIXED_SHIFT + 8);					\
+   dest[BCOMP] = ((CHAN_MAX - sample[ACOMP]) * span->blue +		\
+               ((sample[ACOMP] + 1) * sample[BCOMP] << FIXED_SHIFT))	\
+               >> (FIXED_SHIFT + 8);					\
+   dest[ACOMP] = FixedToInt(span->alpha)
+
+#define BLEND								\
+   dest[RCOMP] = ((CHAN_MAX - sample[RCOMP]) * span->red		\
+               + (sample[RCOMP] + 1) * info->er) >> (FIXED_SHIFT + 8);	\
+   dest[GCOMP] = ((CHAN_MAX - sample[GCOMP]) * span->green		\
+               + (sample[GCOMP] + 1) * info->eg) >> (FIXED_SHIFT + 8);	\
+   dest[BCOMP] = ((CHAN_MAX - sample[BCOMP]) * span->blue		\
+               + (sample[BCOMP] + 1) * info->eb) >> (FIXED_SHIFT + 8);	\
+   dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8)
+
+#define REPLACE  COPY_CHAN4(dest, sample)
+
+#define ADD								\
+   {									\
+      GLint rSum = FixedToInt(span->red)   + (GLint) sample[RCOMP];	\
+      GLint gSum = FixedToInt(span->green) + (GLint) sample[GCOMP];	\
+      GLint bSum = FixedToInt(span->blue)  + (GLint) sample[BCOMP];	\
+      dest[RCOMP] = MIN2(rSum, CHAN_MAX);				\
+      dest[GCOMP] = MIN2(gSum, CHAN_MAX);				\
+      dest[BCOMP] = MIN2(bSum, CHAN_MAX);				\
+      dest[ACOMP] = span->alpha * (sample[ACOMP] + 1) >> (FIXED_SHIFT + 8); \
+  }
+
+/* shortcuts */
+
+#define NEAREST_RGB_REPLACE		\
+   NEAREST_RGB;				\
+   dest[0] = sample[0];			\
+   dest[1] = sample[1];			\
+   dest[2] = sample[2];			\
+   dest[3] = FixedToInt(span->alpha);
+
+#define NEAREST_RGBA_REPLACE  COPY_CHAN4(dest, tex00)
+
+#define SPAN_NEAREST(DO_TEX,COMP)					\
+	for (i = 0; i < span->count; i++) {				\
+           /* Isn't it necessary to use FixedFloor below?? */		\
+           GLint s = FixedToInt(span->intTex[0]) & info->smask;		\
+           GLint t = FixedToInt(span->intTex[1]) & info->tmask;		\
+           GLint pos = (t << info->twidth_log2) + s;			\
+           const GLchan *tex00 = info->texture + COMP * pos;		\
+	   zspan[i] = FixedToDepth(span->z);				\
+	   fogspan[i] = span->fog;					\
+           DO_TEX;							\
+	   span->fog += span->fogStep;					\
+	   span->z += span->zStep;					\
+           span->red += span->redStep;					\
+	   span->green += span->greenStep;				\
+           span->blue += span->blueStep;				\
+	   span->alpha += span->alphaStep;				\
+	   span->intTex[0] += span->intTexStep[0];			\
+	   span->intTex[1] += span->intTexStep[1];			\
+           dest += 4;							\
+	}
+
+#define SPAN_LINEAR(DO_TEX,COMP)					\
+	for (i = 0; i < span->count; i++) {				\
+           /* Isn't it necessary to use FixedFloor below?? */		\
+           GLint s = FixedToInt(span->intTex[0]) & info->smask;		\
+           GLint t = FixedToInt(span->intTex[1]) & info->tmask;		\
+           GLfixed sf = span->intTex[0] & FIXED_FRAC_MASK;		\
+           GLfixed tf = span->intTex[1] & FIXED_FRAC_MASK;		\
+           GLfixed si = FIXED_FRAC_MASK - sf;				\
+           GLfixed ti = FIXED_FRAC_MASK - tf;				\
+           GLint pos = (t << info->twidth_log2) + s;			\
+           const GLchan *tex00 = info->texture + COMP * pos;		\
+           const GLchan *tex10 = tex00 + info->tbytesline;		\
+           const GLchan *tex01 = tex00 + COMP;				\
+           const GLchan *tex11 = tex10 + COMP;				\
+           (void) ti;							\
+           (void) si;							\
+           if (t == info->tmask) {					\
+              tex10 -= info->tsize;					\
+              tex11 -= info->tsize;					\
+           }								\
+           if (s == info->smask) {					\
+              tex01 -= info->tbytesline;				\
+              tex11 -= info->tbytesline;				\
+           }								\
+	   zspan[i] = FixedToDepth(span->z);				\
+	   fogspan[i] = span->fog;					\
+           DO_TEX;							\
+	   span->fog += span->fogStep;					\
+	   span->z += span->zStep;					\
+           span->red += span->redStep;					\
+	   span->green += span->greenStep;				\
+           span->blue += span->blueStep;				\
+	   span->alpha += span->alphaStep;				\
+	   span->intTex[0] += span->intTexStep[0];			\
+	   span->intTex[1] += span->intTexStep[1];			\
+           dest += 4;							\
+	}
+
+#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
+
+   GLuint i;
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat fogspan[MAX_WIDTH];
+   GLchan rgba[MAX_WIDTH][4];
+   GLchan *dest = rgba[0];
+   const GLint fixedToDepthShift = info->fixedToDepthShift;
+
+   span->intTex[0] -= FIXED_HALF;
+   span->intTex[1] -= FIXED_HALF;
+   switch (info->filter) {
+   case GL_NEAREST:
+      switch (info->format) {
+      case GL_RGB:
+         switch (info->envmode) {
+         case GL_MODULATE:
+            SPAN_NEAREST(NEAREST_RGB;MODULATE,3);
+            break;
+         case GL_DECAL:
+         case GL_REPLACE:
+            SPAN_NEAREST(NEAREST_RGB_REPLACE,3);
+            break;
+         case GL_BLEND:
+            SPAN_NEAREST(NEAREST_RGB;BLEND,3);
+            break;
+         case GL_ADD:
+            SPAN_NEAREST(NEAREST_RGB;ADD,3);
+            break;
+         default:
+            abort();
+         }
+         break;
+      case GL_RGBA:
+         switch(info->envmode) {
+         case GL_MODULATE:
+            SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);
+            break;
+         case GL_DECAL:
+            SPAN_NEAREST(NEAREST_RGBA;DECAL,4);
+            break;
+         case GL_BLEND:
+            SPAN_NEAREST(NEAREST_RGBA;BLEND,4);
+            break;
+         case GL_ADD:
+            SPAN_NEAREST(NEAREST_RGBA;ADD,4);
+            break;
+         case GL_REPLACE:
+            SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);
+            break;
+         default:
+            abort();
+         }
+         break;
+      }
+      break;
+
+   case GL_LINEAR:
+      span->intTex[0] -= FIXED_HALF;
+      span->intTex[1] -= FIXED_HALF;
+      switch (info->format) {
+      case GL_RGB:
+         switch (info->envmode) {
+         case GL_MODULATE:
+            SPAN_LINEAR(LINEAR_RGB;MODULATE,3);
+            break;
+         case GL_DECAL:
+         case GL_REPLACE:
+            SPAN_LINEAR(LINEAR_RGB;REPLACE,3);
+            break;
+         case GL_BLEND:
+            SPAN_LINEAR(LINEAR_RGB;BLEND,3);
+            break;
+         case GL_ADD:
+            SPAN_LINEAR(LINEAR_RGB;ADD,3);
+            break;
+         default:
+            abort();
+         }
+         break;
+      case GL_RGBA:
+         switch (info->envmode) {
+         case GL_MODULATE:
+            SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);
+            break;
+         case GL_DECAL:
+            SPAN_LINEAR(LINEAR_RGBA;DECAL,4);
+            break;
+         case GL_BLEND:
+            SPAN_LINEAR(LINEAR_RGBA;BLEND,4);
+            break;
+         case GL_ADD:
+            SPAN_LINEAR(LINEAR_RGBA;ADD,4);
+            break;
+         case GL_REPLACE:
+            SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);
+            break;
+         default:
+            abort();
+         }		    break;
+      }
+      break;
+   }
+   _mesa_write_rgba_span(ctx, span->count, span->x, span->y,
+                         zspan, fogspan, rgba, NULL, GL_POLYGON);
+
+#undef SPAN_NEAREST
+#undef SPAN_LINEAR
+#undef FixedToDepth
+}
+
+
+
+/*
+ * Render an RGB/RGBA textured triangle without perspective correction.
+ */
+static void affine_textured_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_INT_TEX 1
+#define S_SCALE twidth
+#define T_SCALE theight
+
+#define SETUP_CODE							\
+   struct affine_info info;						\
+   struct gl_texture_unit *unit = ctx->Texture.Unit+0;			\
+   struct gl_texture_object *obj = unit->Current2D;			\
+   GLint b = obj->BaseLevel;						\
+   GLfloat twidth = (GLfloat) obj->Image[b]->Width;			\
+   GLfloat theight = (GLfloat) obj->Image[b]->Height;			\
+   info.fixedToDepthShift = ctx->Visual.depthBits <= 16 ? FIXED_SHIFT : 0;\
+   info.texture = (const GLchan *) obj->Image[b]->Data;			\
+   info.twidth_log2 = obj->Image[b]->WidthLog2;				\
+   info.smask = obj->Image[b]->Width - 1;				\
+   info.tmask = obj->Image[b]->Height - 1;				\
+   info.format = obj->Image[b]->Format;					\
+   info.filter = obj->MinFilter;					\
+   info.envmode = unit->EnvMode;					\
+									\
+   if (info.envmode == GL_BLEND) {					\
+      /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\
+      info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\
+      info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\
+      info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\
+      info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\
+   }									\
+   if (!info.texture) {							\
+      /* this shouldn't happen */					\
+      return;								\
+   }									\
+									\
+   switch (info.format) {						\
+   case GL_ALPHA:							\
+   case GL_LUMINANCE:							\
+   case GL_INTENSITY:							\
+      info.tbytesline = obj->Image[b]->Width;				\
+      break;								\
+   case GL_LUMINANCE_ALPHA:						\
+      info.tbytesline = obj->Image[b]->Width * 2;			\
+      break;								\
+   case GL_RGB:								\
+      info.tbytesline = obj->Image[b]->Width * 3;			\
+      break;								\
+   case GL_RGBA:							\
+      info.tbytesline = obj->Image[b]->Width * 4;			\
+      break;								\
+   default:								\
+      _mesa_problem(NULL, "Bad texture format in affine_texture_triangle");\
+      return;								\
+   }									\
+   info.tsize = obj->Image[b]->Height * info.tbytesline;
+
+#define RENDER_SPAN( span )   affine_span(ctx, &span, &info);
+
+#include "s_tritemp.h"
+
+}
+
+
+
+struct persp_info
+{
+   GLenum filter;
+   GLenum format;
+   GLenum envmode;
+   GLint smask, tmask;
+   GLint twidth_log2;
+   const GLchan *texture;
+   GLfixed er, eg, eb, ea;   /* texture env color */
+   GLint tbytesline, tsize;
+   GLint fixedToDepthShift;
+};
+
+
+static void
+fast_persp_span(GLcontext *ctx, struct triangle_span *span,
+		struct persp_info *info)
+{
+   GLchan sample[4];  /* the filtered texture sample */
+
+  /* Instead of defining a function for each mode, a test is done
+   * between the outer and inner loops. This is to reduce code size
+   * and complexity. Observe that an optimizing compiler kills
+   * unused variables (for instance tf,sf,ti,si in case of GL_NEAREST).
+   */
+#define SPAN_NEAREST(DO_TEX,COMP)					\
+	for (i = 0; i < span->count; i++) {				\
+           GLdouble invQ = tex_coord[2] ?				\
+                                 (1.0 / tex_coord[2]) : 1.0;            \
+           GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);		\
+           GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);		\
+           GLint s = IFLOOR(s_tmp) & info->smask;	        	\
+           GLint t = IFLOOR(t_tmp) & info->tmask;	        	\
+           GLint pos = (t << info->twidth_log2) + s;			\
+           const GLchan *tex00 = info->texture + COMP * pos;		\
+	   zspan[i] = FixedToDepth(span->z);				\
+	   fogspan[i] = span->fog;					\
+           DO_TEX;							\
+	   span->fog += span->fogStep;					\
+	   span->z += span->zStep;					\
+           span->red += span->redStep;					\
+	   span->green += span->greenStep;				\
+           span->blue += span->blueStep;				\
+	   span->alpha += span->alphaStep;				\
+	   tex_coord[0] += tex_step[0];					\
+	   tex_coord[1] += tex_step[1];					\
+	   tex_coord[2] += tex_step[2];					\
+           dest += 4;							\
+	}
+
+#define SPAN_LINEAR(DO_TEX,COMP)					\
+	for (i = 0; i < span->count; i++) {				\
+           GLdouble invQ = tex_coord[2] ?				\
+                                 (1.0 / tex_coord[2]) : 1.0;            \
+           GLfloat s_tmp = (GLfloat) (tex_coord[0] * invQ);		\
+           GLfloat t_tmp = (GLfloat) (tex_coord[1] * invQ);		\
+           GLfixed s_fix = FloatToFixed(s_tmp) - FIXED_HALF;		\
+           GLfixed t_fix = FloatToFixed(t_tmp) - FIXED_HALF;        	\
+           GLint s = FixedToInt(FixedFloor(s_fix)) & info->smask;	\
+           GLint t = FixedToInt(FixedFloor(t_fix)) & info->tmask;	\
+           GLfixed sf = s_fix & FIXED_FRAC_MASK;			\
+           GLfixed tf = t_fix & FIXED_FRAC_MASK;			\
+           GLfixed si = FIXED_FRAC_MASK - sf;				\
+           GLfixed ti = FIXED_FRAC_MASK - tf;				\
+           GLint pos = (t << info->twidth_log2) + s;			\
+           const GLchan *tex00 = info->texture + COMP * pos;		\
+           const GLchan *tex10 = tex00 + info->tbytesline;		\
+           const GLchan *tex01 = tex00 + COMP;				\
+           const GLchan *tex11 = tex10 + COMP;				\
+           (void) ti;							\
+           (void) si;							\
+           if (t == info->tmask) {					\
+              tex10 -= info->tsize;					\
+              tex11 -= info->tsize;					\
+           }								\
+           if (s == info->smask) {					\
+              tex01 -= info->tbytesline;				\
+              tex11 -= info->tbytesline;				\
+           }								\
+	   zspan[i] = FixedToDepth(span->z);				\
+	   fogspan[i] = span->fog;					\
+           DO_TEX;							\
+	   span->fog += span->fogStep;					\
+	   span->z += span->zStep;					\
+           span->red   += span->redStep;				\
+	   span->green += span->greenStep;				\
+           span->blue  += span->blueStep;				\
+	   span->alpha += span->alphaStep;				\
+	   tex_coord[0] += tex_step[0];					\
+	   tex_coord[1] += tex_step[1];					\
+	   tex_coord[2] += tex_step[2];					\
+           dest += 4;							\
+	}
+
+#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
+
+   GLuint i;
+   GLdepth zspan[MAX_WIDTH];
+   GLfloat tex_coord[3], tex_step[3];
+   GLfloat fogspan[MAX_WIDTH];
+   GLchan rgba[MAX_WIDTH][4];
+   GLchan *dest = rgba[0];
+   const GLint fixedToDepthShift = info->fixedToDepthShift;
+
+   tex_coord[0] = span->tex[0][0]  * (info->smask + 1),
+     tex_step[0] = span->texStep[0][0] * (info->smask + 1);
+   tex_coord[1] = span->tex[0][1] * (info->tmask + 1),
+     tex_step[1] = span->texStep[0][1] * (info->tmask + 1);
+   /* span->tex[0][2] only if 3D-texturing, here only 2D */
+   tex_coord[2] = span->tex[0][3],
+     tex_step[2] = span->texStep[0][3];
+
+   switch (info->filter) {
+   case GL_NEAREST:
+      switch (info->format) {
+      case GL_RGB:
+         switch (info->envmode) {
+         case GL_MODULATE:
+            SPAN_NEAREST(NEAREST_RGB;MODULATE,3);
+            break;
+         case GL_DECAL:
+         case GL_REPLACE:
+            SPAN_NEAREST(NEAREST_RGB_REPLACE,3);
+            break;
+         case GL_BLEND:
+            SPAN_NEAREST(NEAREST_RGB;BLEND,3);
+            break;
+         case GL_ADD:
+            SPAN_NEAREST(NEAREST_RGB;ADD,3);
+            break;
+         default:
+            abort();
+         }
+         break;
+      case GL_RGBA:
+         switch(info->envmode) {
+         case GL_MODULATE:
+            SPAN_NEAREST(NEAREST_RGBA;MODULATE,4);
+            break;
+         case GL_DECAL:
+            SPAN_NEAREST(NEAREST_RGBA;DECAL,4);
+            break;
+         case GL_BLEND:
+            SPAN_NEAREST(NEAREST_RGBA;BLEND,4);
+            break;
+         case GL_ADD:
+            SPAN_NEAREST(NEAREST_RGBA;ADD,4);
+            break;
+         case GL_REPLACE:
+            SPAN_NEAREST(NEAREST_RGBA_REPLACE,4);
+            break;
+         default:
+            abort();
+         }
+         break;
+      }
+      break;
+
+   case GL_LINEAR:
+      switch (info->format) {
+      case GL_RGB:
+         switch (info->envmode) {
+         case GL_MODULATE:
+            SPAN_LINEAR(LINEAR_RGB;MODULATE,3);
+            break;
+         case GL_DECAL:
+         case GL_REPLACE:
+            SPAN_LINEAR(LINEAR_RGB;REPLACE,3);
+            break;
+         case GL_BLEND:
+            SPAN_LINEAR(LINEAR_RGB;BLEND,3);
+            break;
+         case GL_ADD:
+            SPAN_LINEAR(LINEAR_RGB;ADD,3);
+            break;
+         default:
+            abort();
+         }
+         break;
+      case GL_RGBA:
+         switch (info->envmode) {
+         case GL_MODULATE:
+            SPAN_LINEAR(LINEAR_RGBA;MODULATE,4);
+            break;
+         case GL_DECAL:
+            SPAN_LINEAR(LINEAR_RGBA;DECAL,4);
+            break;
+         case GL_BLEND:
+            SPAN_LINEAR(LINEAR_RGBA;BLEND,4);
+            break;
+         case GL_ADD:
+            SPAN_LINEAR(LINEAR_RGBA;ADD,4);
+            break;
+         case GL_REPLACE:
+            SPAN_LINEAR(LINEAR_RGBA;REPLACE,4);
+            break;
+         default:
+            abort();
+         }
+         break;
+      }
+      break;
+   }
+   /* This does not seem to be necessary, but I don't know !! */
+   /* span->tex[0][0] = tex_coord[0] / (info->smask + 1),
+      span->tex[0][1] = tex_coord[1] / (info->tmask + 1),*/
+   /* span->tex[0][2] only if 3D-texturing, here only 2D */
+   /* span->tex[0][3] = tex_coord[2]; */
+   
+   _mesa_write_rgba_span(ctx, span->count, span->x, span->y,
+                         zspan, fogspan, rgba, NULL, GL_POLYGON);
+
+
+#undef SPAN_NEAREST
+#undef SPAN_LINEAR
+#undef FixedToDepth
+}
+
+
+/*
+ * Render an perspective corrected RGB/RGBA textured triangle.
+ * The Q (aka V in Mesa) coordinate must be zero such that the divide
+ * by interpolated Q/W comes out right.
+ *
+ */
+static void persp_textured_triangle( GLcontext *ctx,
+				     const SWvertex *v0,
+				     const SWvertex *v1,
+				     const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+
+#define SETUP_CODE							\
+   struct persp_info info;						\
+   struct gl_texture_unit *unit = ctx->Texture.Unit+0;			\
+   struct gl_texture_object *obj = unit->Current2D;			\
+   GLint b = obj->BaseLevel;						\
+   info.fixedToDepthShift = ctx->Visual.depthBits <= 16 ? FIXED_SHIFT : 0;\
+   info.texture = (const GLchan *) obj->Image[b]->Data;			\
+   info.twidth_log2 = obj->Image[b]->WidthLog2;				\
+   info.smask = obj->Image[b]->Width - 1;				\
+   info.tmask = obj->Image[b]->Height - 1;				\
+   info.format = obj->Image[b]->Format;					\
+   info.filter = obj->MinFilter;					\
+   info.envmode = unit->EnvMode;					\
+									\
+   if (info.envmode == GL_BLEND) {					\
+      /* potential off-by-one error here? (1.0f -> 2048 -> 0) */	\
+      info.er = FloatToFixed(unit->EnvColor[RCOMP] * CHAN_MAXF);	\
+      info.eg = FloatToFixed(unit->EnvColor[GCOMP] * CHAN_MAXF);	\
+      info.eb = FloatToFixed(unit->EnvColor[BCOMP] * CHAN_MAXF);	\
+      info.ea = FloatToFixed(unit->EnvColor[ACOMP] * CHAN_MAXF);	\
+   }									\
+   if (!info.texture) {							\
+      /* this shouldn't happen */					\
+      return;								\
+   }									\
+									\
+   switch (info.format) {						\
+   case GL_ALPHA:							\
+   case GL_LUMINANCE:							\
+   case GL_INTENSITY:							\
+      info.tbytesline = obj->Image[b]->Width;				\
+      break;								\
+   case GL_LUMINANCE_ALPHA:						\
+      info.tbytesline = obj->Image[b]->Width * 2;			\
+      break;								\
+   case GL_RGB:								\
+      info.tbytesline = obj->Image[b]->Width * 3;			\
+      break;								\
+   case GL_RGBA:							\
+      info.tbytesline = obj->Image[b]->Width * 4;			\
+      break;								\
+   default:								\
+      _mesa_problem(NULL, "Bad texture format in persp_textured_triangle");\
+      return;								\
+   }									\
+   info.tsize = obj->Image[b]->Height * info.tbytesline;
+
+#define RENDER_SPAN( span )   fast_persp_span(ctx, &span, &info);
+
+#include "s_tritemp.h"
+
+}
+
+
+#endif /* CHAN_BITS != GL_FLOAT */
+
+
+/*
+ * Generate arrays of fragment colors, z, fog, texcoords, etc from a
+ * triangle span object.  Then call the span/fragment processsing
+ * functions in s_span.[ch].  This is used by a bunch of the textured
+ * triangle functions.
+ */
+static void
+rasterize_span(GLcontext *ctx, const struct triangle_span *span)
+{
+   DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4);
+   DEFMARRAY(GLchan, spec, MAX_WIDTH, 4);
+   DEFARRAY(GLuint, index, MAX_WIDTH);
+   DEFARRAY(GLuint, z, MAX_WIDTH);
+   DEFARRAY(GLfloat, fog, MAX_WIDTH);
+   DEFARRAY(GLfloat, sTex, MAX_WIDTH);
+   DEFARRAY(GLfloat, tTex, MAX_WIDTH);
+   DEFARRAY(GLfloat, rTex, MAX_WIDTH);
+   DEFARRAY(GLfloat, lambda, MAX_WIDTH);
+   DEFMARRAY(GLfloat, msTex, MAX_TEXTURE_UNITS, MAX_WIDTH);
+   DEFMARRAY(GLfloat, mtTex, MAX_TEXTURE_UNITS, MAX_WIDTH);
+   DEFMARRAY(GLfloat, mrTex, MAX_TEXTURE_UNITS, MAX_WIDTH);
+   DEFMARRAY(GLfloat, mLambda, MAX_TEXTURE_UNITS, MAX_WIDTH);
+
+   CHECKARRAY(rgba, return);
+   CHECKARRAY(spec, return);
+   CHECKARRAY(index, return);
+   CHECKARRAY(z, return);
+   CHECKARRAY(fog, return);
+   CHECKARRAY(sTex, return);
+   CHECKARRAY(tTex, return);
+   CHECKARRAY(rTex, return);
+   CHECKARRAY(lambda, return);
+   CHECKARRAY(msTex, return);
+   CHECKARRAY(mtTex, return);
+   CHECKARRAY(mrTex, return);
+   CHECKARRAY(mLambda, return);
+
+   if (span->activeMask & SPAN_RGBA) {
+      if (span->activeMask & SPAN_FLAT) {
+         GLuint i;
+         GLchan color[4];
+         color[RCOMP] = FixedToChan(span->red);
+         color[GCOMP] = FixedToChan(span->green);
+         color[BCOMP] = FixedToChan(span->blue);
+         color[ACOMP] = FixedToChan(span->alpha);
+         for (i = 0; i < span->count; i++) {
+            COPY_CHAN4(rgba[i], color);
+         }
+      }
+      else {
+         /* smooth interpolation */
+#if CHAN_TYPE == GL_FLOAT
+         GLfloat r = span->red;
+         GLfloat g = span->green;
+         GLfloat b = span->blue;
+         GLfloat a = span->alpha;
+#else
+         GLfixed r = span->red;
+         GLfixed g = span->green;
+         GLfixed b = span->blue;
+         GLfixed a = span->alpha;
+#endif
+         GLuint i;
+         for (i = 0; i < span->count; i++) {
+            rgba[i][RCOMP] = FixedToChan(r);
+            rgba[i][GCOMP] = FixedToChan(g);
+            rgba[i][BCOMP] = FixedToChan(b);
+            rgba[i][ACOMP] = FixedToChan(a);
+            r += span->redStep;
+            g += span->greenStep;
+            b += span->blueStep;
+            a += span->alphaStep;
+         }
+      }
+   }
+
+   if (span->activeMask & SPAN_SPEC) {
+      if (span->activeMask & SPAN_FLAT) {
+         const GLchan r = FixedToChan(span->specRed);
+         const GLchan g = FixedToChan(span->specGreen);
+         const GLchan b = FixedToChan(span->specBlue);
+         GLuint i;
+         for (i = 0; i < span->count; i++) {
+            spec[i][RCOMP] = r;
+            spec[i][GCOMP] = g;
+            spec[i][BCOMP] = b;
+         }
+      }
+      else {
+         /* smooth interpolation */
+#if CHAN_TYPE == GL_FLOAT
+         GLfloat r = span->specRed;
+         GLfloat g = span->specGreen;
+         GLfloat b = span->specBlue;
+#else
+         GLfixed r = span->specRed;
+         GLfixed g = span->specGreen;
+         GLfixed b = span->specBlue;
+#endif
+         GLuint i;
+         for (i = 0; i < span->count; i++) {
+            spec[i][RCOMP] = FixedToChan(r);
+            spec[i][GCOMP] = FixedToChan(g);
+            spec[i][BCOMP] = FixedToChan(b);
+            r += span->specRedStep;
+            g += span->specGreenStep;
+            b += span->specBlueStep;
+         }
+      }
+   }
+
+   if (span->activeMask & SPAN_INDEX) {
+      if (span->activeMask & SPAN_FLAT) {
+         GLuint i;
+         const GLint indx = FixedToInt(span->index);
+         for (i = 0; i < span->count; i++) {
+            index[i] = indx;
+         }
+      }
+      else {
+         /* smooth interpolation */
+         GLuint i;
+         GLfixed ind = span->index;
+         for (i = 0; i < span->count; i++) {
+            index[i] = FixedToInt(ind);
+            ind += span->indexStep;
+         }
+      }
+   }
+
+   if (span->activeMask & SPAN_Z) {
+      if (ctx->Visual.depthBits <= 16) {
+         GLuint i;
+         GLfixed zval = span->z;
+         for (i = 0; i < span->count; i++) {
+            z[i] = FixedToInt(zval);
+            zval += span->zStep;
+         }
+      }
+      else {
+         /* Deep Z buffer, no fixed->int shift */
+         GLuint i;
+         GLfixed zval = span->z;
+         for (i = 0; i < span->count; i++) {
+            z[i] = zval;
+            zval += span->zStep;
+         }
+      }
+   }
+   if (span->activeMask & SPAN_FOG) {
+      GLuint i;
+      GLfloat f = span->fog;
+      for (i = 0; i < span->count; i++) {
+         fog[i] = f;
+         f += span->fogStep;
+      }
+   }
+   if (span->activeMask & SPAN_TEXTURE) {
+      if (ctx->Texture._ReallyEnabled & ~TEXTURE0_ANY) {
+         /* multitexture */
+         if (span->activeMask & SPAN_LAMBDA) {
+            /* with lambda */
+            GLuint u;
+            for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
+               if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                  GLfloat s = span->tex[u][0];
+                  GLfloat t = span->tex[u][1];
+                  GLfloat r = span->tex[u][2];
+                  GLfloat q = span->tex[u][3];
+                  GLuint i;
+                  for (i = 0; i < span->count; i++) {
+                     const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+                     msTex[u][i] = s * invQ;
+                     mtTex[u][i] = t * invQ;
+                     mrTex[u][i] = r * invQ;
+                     mLambda[u][i] = (GLfloat) 
+			 (log(span->rho[u] * invQ * invQ) * 1.442695F * 0.5F);
+                     s += span->texStep[u][0];
+                     t += span->texStep[u][1];
+                     r += span->texStep[u][2];
+                     q += span->texStep[u][3];
+                  }
+               }
+            }
+         }
+         else {
+            /* without lambda */
+            GLuint u;
+            for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
+               if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                  GLfloat s = span->tex[u][0];
+                  GLfloat t = span->tex[u][1];
+                  GLfloat r = span->tex[u][2];
+                  GLfloat q = span->tex[u][3];
+                  GLuint i;
+                  for (i = 0; i < span->count; i++) {
+                     const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+                     msTex[u][i] = s * invQ;
+                     mtTex[u][i] = t * invQ;
+                     mrTex[u][i] = r * invQ;
+                     s += span->texStep[u][0];
+                     t += span->texStep[u][1];
+                     r += span->texStep[u][2];
+                     q += span->texStep[u][3];
+                  }
+               }
+            }
+         }
+      }
+      else {
+         /* just texture unit 0 */
+         if (span->activeMask & SPAN_LAMBDA) {
+            /* with lambda */
+            GLfloat s = span->tex[0][0];
+            GLfloat t = span->tex[0][1];
+            GLfloat r = span->tex[0][2];
+            GLfloat q = span->tex[0][3];
+            GLuint i;
+            for (i = 0; i < span->count; i++) {
+               const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+               sTex[i] = s * invQ;
+               tTex[i] = t * invQ;
+               rTex[i] = r * invQ;
+               lambda[i] = (GLfloat)
+		   (log(span->rho[0] * invQ * invQ) * 1.442695F * 0.5F);
+               s += span->texStep[0][0];
+               t += span->texStep[0][1];
+               r += span->texStep[0][2];
+               q += span->texStep[0][3];
+            }
+         }
+         else {
+            /* without lambda */
+            GLfloat s = span->tex[0][0];
+            GLfloat t = span->tex[0][1];
+            GLfloat r = span->tex[0][2];
+            GLfloat q = span->tex[0][3];
+            GLuint i;
+            for (i = 0; i < span->count; i++) {
+               const GLfloat invQ = (q == 0.0F) ? 1.0F : (1.0F / q);
+               sTex[i] = s * invQ;
+               tTex[i] = t * invQ;
+               rTex[i] = r * invQ;
+               s += span->texStep[0][0];
+               t += span->texStep[0][1];
+               r += span->texStep[0][2];
+               q += span->texStep[0][3];
+            }
+         }
+      }
+   }
+   /* XXX keep this? */
+   if (span->activeMask & SPAN_INT_TEXTURE) {
+      GLint intTexcoord[MAX_WIDTH][2];
+      GLfixed s = span->intTex[0];
+      GLfixed t = span->intTex[1];
+      GLuint i;
+      for (i = 0; i < span->count; i++) {
+         intTexcoord[i][0] = FixedToInt(s);
+         intTexcoord[i][1] = FixedToInt(t);
+         s += span->intTexStep[0];
+         t += span->intTexStep[1];
+      }
+   }
+
+   /* examine activeMask and call a s_span.c function */
+   if (span->activeMask & SPAN_TEXTURE) {
+      const GLfloat *fogPtr;
+      if (span->activeMask & SPAN_FOG)
+         fogPtr = fog;
+      else
+         fogPtr = NULL;
+
+      if (ctx->Texture._ReallyEnabled & ~TEXTURE0_ANY) {
+         if (span->activeMask & SPAN_SPEC) {
+            _mesa_write_multitexture_span(ctx, span->count, span->x, span->y,
+                                          z, fogPtr,
+                                          (const GLfloat (*)[MAX_WIDTH]) msTex,
+                                          (const GLfloat (*)[MAX_WIDTH]) mtTex,
+                                          (const GLfloat (*)[MAX_WIDTH]) mrTex,
+                                          (GLfloat (*)[MAX_WIDTH]) mLambda,
+                                          rgba, (CONST GLchan (*)[4]) spec,
+                                          NULL, GL_POLYGON );
+         }
+         else {
+            _mesa_write_multitexture_span(ctx, span->count, span->x, span->y,
+                                          z, fogPtr,
+                                          (const GLfloat (*)[MAX_WIDTH]) msTex,
+                                          (const GLfloat (*)[MAX_WIDTH]) mtTex,
+                                          (const GLfloat (*)[MAX_WIDTH]) mrTex,
+                                          (GLfloat (*)[MAX_WIDTH]) mLambda,
+                                          rgba, NULL, NULL, GL_POLYGON);
+         }
+      }
+      else {
+         /* single texture */
+         if (span->activeMask & SPAN_SPEC) {
+            _mesa_write_texture_span(ctx, span->count, span->x, span->y,
+                                     z, fogPtr, sTex, tTex, rTex, lambda,
+                                     rgba, (CONST GLchan (*)[4]) spec,
+                                     NULL, GL_POLYGON);
+         }
+         else {
+            _mesa_write_texture_span(ctx, span->count, span->x, span->y,
+                                     z, fogPtr, sTex, tTex, rTex, lambda,
+                                     rgba, NULL, NULL, GL_POLYGON);
+         }
+      }
+   }
+   else {
+      _mesa_problem(ctx, "rasterize_span() should only be used for texturing");
+   }
+
+   UNDEFARRAY(rgba);
+   UNDEFARRAY(spec);
+   UNDEFARRAY(index);
+   UNDEFARRAY(z);
+   UNDEFARRAY(fog);
+   UNDEFARRAY(sTex);
+   UNDEFARRAY(tTex);
+   UNDEFARRAY(rTex);
+   UNDEFARRAY(lambda);
+   UNDEFARRAY(msTex);
+   UNDEFARRAY(mtTex);
+   UNDEFARRAY(mrTex);
+   UNDEFARRAY(mLambda);
+}
+
+                
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle.
+ * Interpolate S,T,R with perspective correction, w/out mipmapping.
+ */
+static void general_textured_triangle( GLcontext *ctx,
+				       const SWvertex *v0,
+				       const SWvertex *v1,
+				       const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+
+#define SETUP_CODE							\
+   const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;	\
+   const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];\
+   DEFARRAY(GLfloat, sSpan, MAX_WIDTH);  /* mac 32k limitation */	\
+   DEFARRAY(GLfloat, tSpan, MAX_WIDTH);  /* mac 32k limitation */	\
+   DEFARRAY(GLfloat, uSpan, MAX_WIDTH);  /* mac 32k limitation */	\
+   CHECKARRAY(sSpan, return);  /* mac 32k limitation */			\
+   CHECKARRAY(tSpan, return);  /* mac 32k limitation */			\
+   CHECKARRAY(uSpan, return);  /* mac 32k limitation */			\
+   span.texWidth[0] = (GLfloat) texImage->Width;			\
+   span.texHeight[0] = (GLfloat) texImage->Height;			\
+   (void) fixedToDepthShift;
+
+#define RENDER_SPAN( span )						\
+   GLdepth zSpan[MAX_WIDTH];						\
+   GLfloat fogSpan[MAX_WIDTH];						\
+   GLchan rgbaSpan[MAX_WIDTH][4];					\
+   GLuint i;								\
+   /* NOTE: we could just call rasterize_span() here instead */		\
+   for (i = 0; i < span.count; i++) {					\
+      GLdouble invQ = span.tex[0][3] ? (1.0 / span.tex[0][3]) : 1.0;	\
+      zSpan[i] = FixedToDepth(span.z);					\
+      span.z += span.zStep;						\
+      fogSpan[i] = span.fog;			          		\
+      span.fog += span.fogStep;						\
+      rgbaSpan[i][RCOMP] = FixedToChan(span.red);			\
+      rgbaSpan[i][GCOMP] = FixedToChan(span.green);			\
+      rgbaSpan[i][BCOMP] = FixedToChan(span.blue);			\
+      rgbaSpan[i][ACOMP] = FixedToChan(span.alpha);			\
+      span.red += span.redStep;						\
+      span.green += span.greenStep;					\
+      span.blue += span.blueStep;					\
+      span.alpha += span.alphaStep;					\
+      sSpan[i] = (GLfloat) (span.tex[0][0] * invQ);			\
+      tSpan[i] = (GLfloat) (span.tex[0][1] * invQ);			\
+      uSpan[i] = (GLfloat) (span.tex[0][2] * invQ);			\
+      span.tex[0][0] += span.texStep[0][0];				\
+      span.tex[0][1] += span.texStep[0][1];				\
+      span.tex[0][2] += span.texStep[0][2];				\
+      span.tex[0][3] += span.texStep[0][3];				\
+   }									\
+   _mesa_write_texture_span(ctx, span.count, span.x, span.y,		\
+                            zSpan, fogSpan, sSpan, tSpan, uSpan,	\
+                            NULL, rgbaSpan, NULL, NULL, GL_POLYGON );
+
+#define CLEANUP_CODE				\
+   UNDEFARRAY(sSpan);  /* mac 32k limitation */	\
+   UNDEFARRAY(tSpan);				\
+   UNDEFARRAY(uSpan);
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle with separate specular
+ * color interpolation.
+ * Interpolate texcoords with perspective correction, w/out mipmapping.
+ */
+static void general_textured_spec_triangle( GLcontext *ctx,
+					    const SWvertex *v0,
+					    const SWvertex *v1,
+					    const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+
+#define SETUP_CODE							\
+   const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;	\
+   const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];\
+   span.texWidth[0] = (GLfloat) texImage->Width;			\
+   span.texHeight[0] = (GLfloat) texImage->Height;			\
+   (void) fixedToDepthShift;
+
+#define RENDER_SPAN( span )   rasterize_span(ctx, &span);
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle.
+ * Interpolate S,T,R with perspective correction and compute lambda for
+ * each fragment.  Lambda is used to determine whether to use the
+ * minification or magnification filter.  If minification and using
+ * mipmaps, lambda is also used to select the texture level of detail.
+ */
+static void lambda_textured_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define INTERP_LAMBDA 1
+
+#define SETUP_CODE							\
+   const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;	\
+   const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];\
+   span.texWidth[0] = (GLfloat) texImage->Width;			\
+   span.texHeight[0] = (GLfloat) texImage->Height;			\
+   (void) fixedToDepthShift;
+
+#define RENDER_SPAN( span )   rasterize_span(ctx, &span);
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * Render a smooth-shaded, textured, RGBA triangle with separate specular
+ * interpolation.
+ * Interpolate S,T,R with perspective correction and compute lambda for
+ * each fragment.  Lambda is used to determine whether to use the
+ * minification or magnification filter.  If minification and using
+ * mipmaps, lambda is also used to select the texture level of detail.
+ */
+static void lambda_textured_spec_triangle( GLcontext *ctx,
+					   const SWvertex *v0,
+					   const SWvertex *v1,
+					   const SWvertex *v2 )
+{
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_SPEC 1
+#define INTERP_ALPHA 1
+#define INTERP_TEX 1
+#define INTERP_LAMBDA 1
+
+#define SETUP_CODE							\
+   const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;	\
+   const struct gl_texture_image *texImage = obj->Image[obj->BaseLevel];\
+   span.texWidth[0] = (GLfloat) texImage->Width;			\
+   span.texHeight[0] = (GLfloat) texImage->Height;			\
+   (void) fixedToDepthShift;
+
+#define RENDER_SPAN( span )   rasterize_span(ctx, &span);
+
+#include "s_tritemp.h"
+}
+
+
+/*
+ * This is the big one!
+ * Interpolate Z, RGB, Alpha, specular, fog, and N sets of texture coordinates
+ * with lambda (LOD).
+ * Yup, it's slow.
+ */
+static void
+lambda_multitextured_triangle( GLcontext *ctx,
+                               const SWvertex *v0,
+                               const SWvertex *v1,
+                               const SWvertex *v2 )
+{
+
+#define INTERP_Z 1
+#define INTERP_FOG 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+#define INTERP_RGB 1
+#define INTERP_ALPHA 1
+#define INTERP_SPEC 1
+#define INTERP_MULTITEX 1
+#define INTERP_LAMBDA 1
+
+#define SETUP_CODE							\
+   GLuint u;								\
+   for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {			\
+      if (ctx->Texture.Unit[u]._ReallyEnabled) {			\
+         const struct gl_texture_object *texObj;			\
+         const struct gl_texture_image *texImage;			\
+         texObj = ctx->Texture.Unit[u]._Current;			\
+         texImage = texObj->Image[texObj->BaseLevel];			\
+         span.texWidth[u] = (GLfloat) texImage->Width;			\
+         span.texHeight[u] = (GLfloat) texImage->Height;		\
+      }									\
+   }									\
+   (void) fixedToDepthShift;
+
+#define RENDER_SPAN( span )   rasterize_span(ctx, &span);
+
+#include "s_tritemp.h"
+
+}
+
+
+static void occlusion_zless_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   if (ctx->OcclusionResult) {
+      return;
+   }
+
+#define DO_OCCLUSION_TEST
+#define INTERP_Z 1
+#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
+
+#define RENDER_SPAN( span )				\
+   GLuint i;						\
+   for (i = 0; i < span.count; i++) {			\
+      GLdepth z = FixedToDepth(span.z);			\
+      if (z < zRow[i]) {				\
+         ctx->OcclusionResult = GL_TRUE;		\
+         return;					\
+      }							\
+      span.z += span.zStep;				\
+   }
+
+#include "s_tritemp.h"
+}
+
+static void nodraw_triangle( GLcontext *ctx,
+			     const SWvertex *v0,
+			     const SWvertex *v1,
+			     const SWvertex *v2 )
+{
+   (void) (ctx && v0 && v1 && v2);
+}
+
+
+/*
+ * This is used when separate specular color is enabled, but not
+ * texturing.  We add the specular color to the primary color,
+ * draw the triangle, then restore the original primary color.
+ * Inefficient, but seldom needed.
+ */
+void _swrast_add_spec_terms_triangle( GLcontext *ctx,
+				      const SWvertex *v0,
+				      const SWvertex *v1,
+				      const SWvertex *v2 )
+{
+   SWvertex *ncv0 = (SWvertex *)v0; /* drop const qualifier */
+   SWvertex *ncv1 = (SWvertex *)v1;
+   SWvertex *ncv2 = (SWvertex *)v2;
+#if CHAN_TYPE == GL_FLOAT
+   GLfloat rSum, gSum, bSum;
+#else
+   GLint rSum, gSum, bSum;
+#endif
+   GLchan c[3][4];
+   /* save original colors */
+   COPY_CHAN4( c[0], ncv0->color );
+   COPY_CHAN4( c[1], ncv1->color );
+   COPY_CHAN4( c[2], ncv2->color );
+   /* sum v0 */
+   rSum = ncv0->color[0] + ncv0->specular[0];
+   gSum = ncv0->color[1] + ncv0->specular[1];
+   bSum = ncv0->color[2] + ncv0->specular[2];
+   ncv0->color[0] = MIN2(rSum, CHAN_MAX);
+   ncv0->color[1] = MIN2(gSum, CHAN_MAX);
+   ncv0->color[2] = MIN2(bSum, CHAN_MAX);
+   /* sum v1 */
+   rSum = ncv1->color[0] + ncv1->specular[0];
+   gSum = ncv1->color[1] + ncv1->specular[1];
+   bSum = ncv1->color[2] + ncv1->specular[2];
+   ncv1->color[0] = MIN2(rSum, CHAN_MAX);
+   ncv1->color[1] = MIN2(gSum, CHAN_MAX);
+   ncv1->color[2] = MIN2(bSum, CHAN_MAX);
+   /* sum v2 */
+   rSum = ncv2->color[0] + ncv2->specular[0];
+   gSum = ncv2->color[1] + ncv2->specular[1];
+   bSum = ncv2->color[2] + ncv2->specular[2];
+   ncv2->color[0] = MIN2(rSum, CHAN_MAX);
+   ncv2->color[1] = MIN2(gSum, CHAN_MAX);
+   ncv2->color[2] = MIN2(bSum, CHAN_MAX);
+   /* draw */
+   SWRAST_CONTEXT(ctx)->SpecTriangle( ctx, ncv0, ncv1, ncv2 );
+   /* restore original colors */
+   COPY_CHAN4( ncv0->color, c[0] );
+   COPY_CHAN4( ncv1->color, c[1] );
+   COPY_CHAN4( ncv2->color, c[2] );
+}
+
+
+
+#ifdef DEBUG
+
+/* record the current triangle function name */
+static const char *triFuncName = NULL;
+
+#define USE(triFunc)                   \
+do {                                   \
+    triFuncName = #triFunc;            \
+    /*printf("%s\n", triFuncName);*/   \
+    swrast->Triangle = triFunc;        \
+} while (0)
+
+#else
+
+#define USE(triFunc)  swrast->Triangle = triFunc;
+
+#endif
+
+
+
+
+/*
+ * Determine which triangle rendering function to use given the current
+ * rendering context.
+ *
+ * Please update the summary flag _SWRAST_NEW_TRIANGLE if you add or
+ * remove tests to this code.
+ */
+void
+_swrast_choose_triangle( GLcontext *ctx )
+{
+   SWcontext *swrast = SWRAST_CONTEXT(ctx);
+   const GLboolean rgbmode = ctx->Visual.rgbMode;
+
+   if (ctx->Polygon.CullFlag &&
+       ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK) {
+      USE(nodraw_triangle);
+      return;
+   }
+
+   if (ctx->RenderMode==GL_RENDER) {
+
+      if (ctx->Polygon.SmoothFlag) {
+         _mesa_set_aa_triangle_function(ctx);
+         ASSERT(swrast->Triangle);
+         return;
+      }
+
+      if (ctx->Depth.OcclusionTest &&
+          ctx->Depth.Test &&
+          ctx->Depth.Mask == GL_FALSE &&
+          ctx->Depth.Func == GL_LESS &&
+          !ctx->Stencil.Enabled) {
+         if ((rgbmode &&
+              ctx->Color.ColorMask[0] == 0 &&
+              ctx->Color.ColorMask[1] == 0 &&
+              ctx->Color.ColorMask[2] == 0 &&
+              ctx->Color.ColorMask[3] == 0)
+             ||
+             (!rgbmode && ctx->Color.IndexMask == 0)) {
+            USE(occlusion_zless_triangle);
+            return;
+         }
+      }
+
+      if (ctx->Texture._ReallyEnabled) {
+         /* Ugh, we do a _lot_ of tests to pick the best textured tri func */
+	 const struct gl_texture_object *texObj2D;
+         const struct gl_texture_image *texImg;
+         GLenum minFilter, magFilter, envMode;
+         GLint format;
+         texObj2D = ctx->Texture.Unit[0].Current2D;
+         texImg = texObj2D ? texObj2D->Image[texObj2D->BaseLevel] : NULL;
+         format = texImg ? texImg->TexFormat->MesaFormat : -1;
+         minFilter = texObj2D ? texObj2D->MinFilter : (GLenum) 0;
+         magFilter = texObj2D ? texObj2D->MagFilter : (GLenum) 0;
+         envMode = ctx->Texture.Unit[0].EnvMode;
+
+         /* First see if we can used an optimized 2-D texture function */
+         if (ctx->Texture._ReallyEnabled==TEXTURE0_2D
+             && texObj2D->WrapS==GL_REPEAT
+	     && texObj2D->WrapT==GL_REPEAT
+             && texImg->Border==0
+             && texImg->Width==texImg->RowStride
+             && (format == MESA_FORMAT_RGB || format == MESA_FORMAT_RGBA)
+	     && minFilter == magFilter
+	     && ctx->Light.Model.ColorControl == GL_SINGLE_COLOR
+	     && ctx->Texture.Unit[0].EnvMode != GL_COMBINE_EXT) {
+	    if (ctx->Hint.PerspectiveCorrection==GL_FASTEST) {
+	       if (minFilter == GL_NEAREST
+		   && format == MESA_FORMAT_RGB
+		   && (envMode == GL_REPLACE || envMode == GL_DECAL)
+		   && ((swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)
+			&& ctx->Depth.Func == GL_LESS
+			&& ctx->Depth.Mask == GL_TRUE)
+		       || swrast->_RasterMask == TEXTURE_BIT)
+		   && ctx->Polygon.StippleFlag == GL_FALSE) {
+		  if (swrast->_RasterMask == (DEPTH_BIT | TEXTURE_BIT)) {
+		     USE(simple_z_textured_triangle);
+		  }
+		  else {
+		     USE(simple_textured_triangle);
+		  }
+	       }
+	       else {
+#if (CHAN_BITS == 16 || CHAN_BITS == 32)
+                  USE(general_textured_triangle);
+#else
+                  USE(affine_textured_triangle);
+#endif
+	       }
+	    }
+	    else {
+#if (CHAN_BITS == 16 || CHAN_BITS == 32)
+               USE(general_textured_triangle);
+#else
+               USE(persp_textured_triangle);
+#endif
+	    }
+	 }
+         else {
+            /* More complicated textures (mipmap, multi-tex, sep specular) */
+            GLboolean needLambda;
+            /* if mag filter != min filter we need to compute lambda */
+            const struct gl_texture_object *obj = ctx->Texture.Unit[0]._Current;
+            if (obj && obj->MinFilter != obj->MagFilter)
+               needLambda = GL_TRUE;
+            else
+               needLambda = GL_FALSE;
+            if (ctx->Texture._ReallyEnabled > TEXTURE0_ANY) {
+               USE(lambda_multitextured_triangle);
+            }
+            else if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
+               /* separate specular color interpolation */
+               if (needLambda) {
+                  USE(lambda_textured_spec_triangle);
+	       }
+               else {
+                  USE(general_textured_spec_triangle);
+	       }
+            }
+            else {
+               if (needLambda) {
+		  USE(lambda_textured_triangle);
+	       }
+               else {
+                  USE(general_textured_triangle);
+	       }
+            }
+         }
+      }
+      else {
+         ASSERT(!ctx->Texture._ReallyEnabled);
+	 if (ctx->Light.ShadeModel==GL_SMOOTH) {
+	    /* smooth shaded, no texturing, stippled or some raster ops */
+            if (rgbmode) {
+	       USE(smooth_rgba_triangle);
+            }
+            else {
+               USE(smooth_ci_triangle);
+            }
+	 }
+	 else {
+	    /* flat shaded, no texturing, stippled or some raster ops */
+            if (rgbmode) {
+	       USE(flat_rgba_triangle);
+            }
+            else {
+               USE(flat_ci_triangle);
+            }
+	 }
+      }
+   }
+   else if (ctx->RenderMode==GL_FEEDBACK) {
+      USE(_mesa_feedback_triangle);
+   }
+   else {
+      /* GL_SELECT mode */
+      USE(_mesa_select_triangle);
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_triangle.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_triangle.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_triangle.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,54 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+
+
+
+#ifndef S_TRIANGLES_H
+#define S_TRIANGLES_H
+
+
+#include "mtypes.h"
+#include "swrast.h"
+
+
+GLboolean _mesa_cull_triangle( GLcontext *ctx,
+			    const SWvertex *v0,
+			    const SWvertex *v1,
+			    const SWvertex *v2);
+
+
+void
+_swrast_choose_triangle( GLcontext *ctx );
+
+void
+_swrast_add_spec_terms_triangle( GLcontext *ctx,
+				 const SWvertex *v0,
+				 const SWvertex *v1,
+				 const SWvertex *v2 );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/s_trispan.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_trispan.h:1.2
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_trispan.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,92 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_TRISPAN_H
+#define S_TRISPAN_H
+
+
+/*
+ * The triangle_span structure is used by the triangle template code in
+ * s_tritemp.h.  It describes how colors, Z, texcoords, etc are to be
+ * interpolated across each scanline of triangle.
+ * With this structure it's easy to hand-off span rasterization to a
+ * subroutine instead of doing it all inline like we used to do.
+ * It also cleans up the local variable namespace a great deal.
+ *
+ * It would be interesting to experiment with multiprocessor rasterization
+ * with this structure.  The triangle rasterizer could simply emit a
+ * stream of these structures which would be consumed by one or more
+ * span-processing threads which could run in parallel.
+ */
+
+
+/* When the triangle_span struct is initialized, these flags indicates
+ * which values are needed for rendering the triangle.
+ */
+#define SPAN_RGBA         0x001
+#define SPAN_SPEC         0x002
+#define SPAN_INDEX        0x004
+#define SPAN_Z            0x008
+#define SPAN_FOG          0x010
+#define SPAN_TEXTURE      0x020
+#define SPAN_INT_TEXTURE  0x040
+#define SPAN_LAMBDA       0x080
+#define SPAN_FLAT         0x100  /* flat shading? */
+
+
+struct triangle_span {
+   GLint x, y;
+   GLuint count;
+   GLuint activeMask;  /* OR of the SPAN_* flags */
+#if CHAN_TYPE == GL_FLOAT
+   GLfloat red, redStep;
+   GLfloat green, greenStep;
+   GLfloat blue, blueStep;
+   GLfloat alpha, alphaStep;
+   GLfloat specRed, specRedStep;
+   GLfloat specGreen, specGreenStep;
+   GLfloat specBlue, specBlueStep;
+#else
+   GLfixed red, redStep;
+   GLfixed green, greenStep;
+   GLfixed blue, blueStep;
+   GLfixed alpha, alphaStep;
+   GLfixed specRed, specRedStep;
+   GLfixed specGreen, specGreenStep;
+   GLfixed specBlue, specBlueStep;
+#endif
+   GLfixed index, indexStep;
+   GLfixed z, zStep;
+   GLfloat fog, fogStep;
+   GLfloat tex[MAX_TEXTURE_UNITS][4], texStep[MAX_TEXTURE_UNITS][4];
+   GLfixed intTex[2], intTexStep[2];
+   /* Needed for texture lambda (LOD) computation */
+   GLfloat rho[MAX_TEXTURE_UNITS];
+   GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
+};
+
+
+#endif /* S_TRISPAN_H */
Index: xc/extras/Mesa/src/swrast/s_tritemp.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_tritemp.h:1.5
--- /dev/null	Thu Feb 27 12:16:02 2003
+++ xc/extras/Mesa/src/swrast/s_tritemp.h	Mon Dec 16 11:18:40 2002
@@ -0,0 +1,1432 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+/* $XFree86: xc/extras/Mesa/src/swrast/s_tritemp.h,v 1.5 2002/12/16 16:18:40 dawes Exp $ */
+
+/*
+ * Triangle Rasterizer Template
+ *
+ * This file is #include'd to generate custom triangle rasterizers.
+ *
+ * The following macros may be defined to indicate what auxillary information
+ * must be interplated across the triangle:
+ *    INTERP_Z        - if defined, interpolate Z values
+ *    INTERP_FOG      - if defined, interpolate fog values
+ *    INTERP_RGB      - if defined, interpolate RGB values
+ *    INTERP_ALPHA    - if defined, interpolate Alpha values (req's INTERP_RGB)
+ *    INTERP_SPEC     - if defined, interpolate specular RGB values
+ *    INTERP_INDEX    - if defined, interpolate color index values
+ *    INTERP_INT_TEX  - if defined, interpolate integer ST texcoords
+ *                         (fast, simple 2-D texture mapping)
+ *    INTERP_TEX      - if defined, interpolate set 0 float STRQ texcoords
+ *                         NOTE:  OpenGL STRQ = Mesa STUV (R was taken for red)
+ *    INTERP_MULTITEX - if defined, interpolate N units of STRQ texcoords
+ *    INTERP_LAMBDA   - if defined, compute lambda value (for mipmapping)
+ *                         a lambda value for every texture unit
+ *    INTERP_FLOAT_RGBA - if defined, interpolate RGBA with floating point
+ *    INTERP_FLOAT_SPEC - if defined, interpolate specular with floating point
+ *
+ * When one can directly address pixels in the color buffer the following
+ * macros can be defined and used to compute pixel addresses during
+ * rasterization (see pRow):
+ *    PIXEL_TYPE          - the datatype of a pixel (GLubyte, GLushort, GLuint)
+ *    BYTES_PER_ROW       - number of bytes per row in the color buffer
+ *    PIXEL_ADDRESS(X,Y)  - returns the address of pixel at (X,Y) where
+ *                          Y==0 at bottom of screen and increases upward.
+ *
+ * Similarly, for direct depth buffer access, this type is used for depth
+ * buffer addressing:
+ *    DEPTH_TYPE          - either GLushort or GLuint
+ *
+ * Optionally, one may provide one-time setup code per triangle:
+ *    SETUP_CODE    - code which is to be executed once per triangle
+ *    CLEANUP_CODE    - code to execute at end of triangle
+ *
+ * The following macro MUST be defined:
+ *    RENDER_SPAN(span) - code to write a span of pixels.
+ *
+ * This code was designed for the origin to be in the lower-left corner.
+ *
+ * Inspired by triangle rasterizer code written by Allen Akin.  Thanks Allen!
+ */
+
+
+/*
+ * This is a bit of a hack, but it's a centralized place to enable floating-
+ * point color interpolation when GLchan is actually floating point.
+ */
+#if CHAN_TYPE == GL_FLOAT
+
+#if defined(INTERP_RGB)
+#undef INTERP_RGB
+#undef INTERP_ALPHA
+#define INTERP_FLOAT_RGBA
+#endif
+
+#if defined(INTERP_SPEC)
+#undef INTERP_SPEC
+#define INTERP_FLOAT_SPEC
+#endif
+
+#endif
+
+
+/*void triangle( GLcontext *ctx, SWvertex *v0, SWvertex *v1, SWvertex *v2 )*/
+{
+   typedef struct {
+        const SWvertex *v0, *v1;   /* Y(v0) < Y(v1) */
+        GLfloat dx;	/* X(v1) - X(v0) */
+        GLfloat dy;	/* Y(v1) - Y(v0) */
+        GLfixed fdxdy;	/* dx/dy in fixed-point */
+        GLfixed fsx;	/* first sample point x coord */
+        GLfixed fsy;
+        GLfloat adjy;	/* adjust from v[0]->fy to fsy, scaled */
+        GLint lines;	/* number of lines to be sampled on this edge */
+        GLfixed fx0;	/* fixed pt X of lower endpoint */
+   } EdgeT;
+
+#ifdef INTERP_Z
+   const GLint depthBits = ctx->Visual.depthBits;
+   const GLint fixedToDepthShift = depthBits <= 16 ? FIXED_SHIFT : 0;
+   const GLfloat maxDepth = ctx->DepthMaxF;
+#define FixedToDepth(F)  ((F) >> fixedToDepthShift)
+#endif
+   EdgeT eMaj, eTop, eBot;
+   GLfloat oneOverArea;
+   const SWvertex *vMin, *vMid, *vMax;  /* Y(vMin)<=Y(vMid)<=Y(vMax) */
+   float bf = SWRAST_CONTEXT(ctx)->_backface_sign;
+   const GLint snapMask = ~((FIXED_ONE / 16) - 1); /* for x/y coord snapping */
+   GLfixed vMin_fx, vMin_fy, vMid_fx, vMid_fy, vMax_fx, vMax_fy;
+
+   struct triangle_span span;
+
+#ifdef INTERP_Z
+   (void) fixedToDepthShift;
+#endif
+
+   /*
+   printf("%s()\n", __FUNCTION__);
+   printf("  %g, %g, %g\n", v0->win[0], v0->win[1], v0->win[2]);
+   printf("    %d, %d, %d, %d\n",
+          v0->color[0], v0->color[1], v0->color[2], v0->color[3]);
+   printf("  %g, %g, %g\n", v1->win[0], v1->win[1], v1->win[2]);
+   printf("    %d, %d, %d, %d\n",
+          v1->color[0], v1->color[1], v1->color[2], v1->color[3]);
+   printf("  %g, %g, %g\n", v2->win[0], v2->win[1], v2->win[2]);
+   printf("    %d, %d, %d, %d\n",
+          v2->color[0], v2->color[1], v2->color[2], v2->color[3]);
+   */
+
+   /* Compute fixed point x,y coords w/ half-pixel offsets and snapping.
+    * And find the order of the 3 vertices along the Y axis.
+    */
+   {
+      const GLfixed fy0 = FloatToFixed(v0->win[1] - 0.5F) & snapMask;
+      const GLfixed fy1 = FloatToFixed(v1->win[1] - 0.5F) & snapMask;
+      const GLfixed fy2 = FloatToFixed(v2->win[1] - 0.5F) & snapMask;
+
+      if (fy0 <= fy1) {
+         if (fy1 <= fy2) {
+            /* y0 <= y1 <= y2 */
+            vMin = v0;   vMid = v1;   vMax = v2;
+            vMin_fy = fy0;  vMid_fy = fy1;  vMax_fy = fy2;
+         }
+         else if (fy2 <= fy0) {
+            /* y2 <= y0 <= y1 */
+            vMin = v2;   vMid = v0;   vMax = v1;
+            vMin_fy = fy2;  vMid_fy = fy0;  vMax_fy = fy1;
+         }
+         else {
+            /* y0 <= y2 <= y1 */
+            vMin = v0;   vMid = v2;   vMax = v1;
+            vMin_fy = fy0;  vMid_fy = fy2;  vMax_fy = fy1;
+            bf = -bf;
+         }
+      }
+      else {
+         if (fy0 <= fy2) {
+            /* y1 <= y0 <= y2 */
+            vMin = v1;   vMid = v0;   vMax = v2;
+            vMin_fy = fy1;  vMid_fy = fy0;  vMax_fy = fy2;
+            bf = -bf;
+         }
+         else if (fy2 <= fy1) {
+            /* y2 <= y1 <= y0 */
+            vMin = v2;   vMid = v1;   vMax = v0;
+            vMin_fy = fy2;  vMid_fy = fy1;  vMax_fy = fy0;
+            bf = -bf;
+         }
+         else {
+            /* y1 <= y2 <= y0 */
+            vMin = v1;   vMid = v2;   vMax = v0;
+            vMin_fy = fy1;  vMid_fy = fy2;  vMax_fy = fy0;
+         }
+      }
+
+      /* fixed point X coords */
+      vMin_fx = FloatToFixed(vMin->win[0] + 0.5F) & snapMask;
+      vMid_fx = FloatToFixed(vMid->win[0] + 0.5F) & snapMask;
+      vMax_fx = FloatToFixed(vMax->win[0] + 0.5F) & snapMask;
+   }
+
+   /* vertex/edge relationship */
+   eMaj.v0 = vMin;   eMaj.v1 = vMax;   /*TODO: .v1's not needed */
+   eTop.v0 = vMid;   eTop.v1 = vMax;
+   eBot.v0 = vMin;   eBot.v1 = vMid;
+
+   /* compute deltas for each edge:  vertex[upper] - vertex[lower] */
+   eMaj.dx = FixedToFloat(vMax_fx - vMin_fx);
+   eMaj.dy = FixedToFloat(vMax_fy - vMin_fy);
+   eTop.dx = FixedToFloat(vMax_fx - vMid_fx);
+   eTop.dy = FixedToFloat(vMax_fy - vMid_fy);
+   eBot.dx = FixedToFloat(vMid_fx - vMin_fx);
+   eBot.dy = FixedToFloat(vMid_fy - vMin_fy);
+
+   /* compute area, oneOverArea and perform backface culling */
+   {
+      const GLfloat area = eMaj.dx * eBot.dy - eBot.dx * eMaj.dy;
+
+      /* Do backface culling */
+      if (area * bf < 0.0)
+         return;
+
+      if (IS_INF_OR_NAN(area) || area == 0.0F)
+         return;
+
+      oneOverArea = 1.0F / area;
+   }
+
+#ifndef DO_OCCLUSION_TEST
+   ctx->OcclusionResult = GL_TRUE;
+#endif
+
+   /* Edge setup.  For a triangle strip these could be reused... */
+   {
+      eMaj.fsy = FixedCeil(vMin_fy);
+      eMaj.lines = FixedToInt(FixedCeil(vMax_fy - eMaj.fsy));
+      if (eMaj.lines > 0) {
+         GLfloat dxdy = eMaj.dx / eMaj.dy;
+         eMaj.fdxdy = SignedFloatToFixed(dxdy);
+         eMaj.adjy = (GLfloat) (eMaj.fsy - vMin_fy);  /* SCALED! */
+         eMaj.fx0 = vMin_fx;
+         eMaj.fsx = eMaj.fx0 + (GLfixed) (eMaj.adjy * dxdy);
+      }
+      else {
+         return;  /*CULLED*/
+      }
+
+      eTop.fsy = FixedCeil(vMid_fy);
+      eTop.lines = FixedToInt(FixedCeil(vMax_fy - eTop.fsy));
+      if (eTop.lines > 0) {
+         GLfloat dxdy = eTop.dx / eTop.dy;
+         eTop.fdxdy = SignedFloatToFixed(dxdy);
+         eTop.adjy = (GLfloat) (eTop.fsy - vMid_fy); /* SCALED! */
+         eTop.fx0 = vMid_fx;
+         eTop.fsx = eTop.fx0 + (GLfixed) (eTop.adjy * dxdy);
+      }
+
+      eBot.fsy = FixedCeil(vMin_fy);
+      eBot.lines = FixedToInt(FixedCeil(vMid_fy - eBot.fsy));
+      if (eBot.lines > 0) {
+         GLfloat dxdy = eBot.dx / eBot.dy;
+         eBot.fdxdy = SignedFloatToFixed(dxdy);
+         eBot.adjy = (GLfloat) (eBot.fsy - vMin_fy);  /* SCALED! */
+         eBot.fx0 = vMin_fx;
+         eBot.fsx = eBot.fx0 + (GLfixed) (eBot.adjy * dxdy);
+      }
+   }
+
+   /*
+    * Conceptually, we view a triangle as two subtriangles
+    * separated by a perfectly horizontal line.  The edge that is
+    * intersected by this line is one with maximal absolute dy; we
+    * call it a ``major'' edge.  The other two edges are the
+    * ``top'' edge (for the upper subtriangle) and the ``bottom''
+    * edge (for the lower subtriangle).  If either of these two
+    * edges is horizontal or very close to horizontal, the
+    * corresponding subtriangle might cover zero sample points;
+    * we take care to handle such cases, for performance as well
+    * as correctness.
+    *
+    * By stepping rasterization parameters along the major edge,
+    * we can avoid recomputing them at the discontinuity where
+    * the top and bottom edges meet.  However, this forces us to
+    * be able to scan both left-to-right and right-to-left.
+    * Also, we must determine whether the major edge is at the
+    * left or right side of the triangle.  We do this by
+    * computing the magnitude of the cross-product of the major
+    * and top edges.  Since this magnitude depends on the sine of
+    * the angle between the two edges, its sign tells us whether
+    * we turn to the left or to the right when travelling along
+    * the major edge to the top edge, and from this we infer
+    * whether the major edge is on the left or the right.
+    *
+    * Serendipitously, this cross-product magnitude is also a
+    * value we need to compute the iteration parameter
+    * derivatives for the triangle, and it can be used to perform
+    * backface culling because its sign tells us whether the
+    * triangle is clockwise or counterclockwise.  In this code we
+    * refer to it as ``area'' because it's also proportional to
+    * the pixel area of the triangle.
+    */
+
+   {
+      GLint scan_from_left_to_right;  /* true if scanning left-to-right */
+#ifdef INTERP_Z
+      GLfloat dzdx, dzdy;
+#endif
+#ifdef INTERP_FOG
+      GLfloat dfogdy;
+#endif
+#if defined(INTERP_RGB) || defined(INTERP_FLOAT_RGBA)
+      GLfloat drdx, drdy;
+      GLfloat dgdx, dgdy;
+      GLfloat dbdx, dbdy;
+#endif
+#if defined(INTERP_ALPHA) || defined(INTERP_FLOAT_RGBA)
+      GLfloat dadx, dady;
+#endif
+#if defined(INTERP_SPEC) || defined(INTERP_FLOAT_SPEC)
+      GLfloat dsrdx, dsrdy;
+      GLfloat dsgdx, dsgdy;
+      GLfloat dsbdx, dsbdy;
+#endif
+#ifdef INTERP_INDEX
+      GLfloat didx, didy;
+#endif
+#ifdef INTERP_INT_TEX
+      GLfloat dsdx, dsdy;
+      GLfloat dtdx, dtdy;
+#endif
+#ifdef INTERP_TEX
+      GLfloat dsdy;
+      GLfloat dtdy;
+      GLfloat dudy;
+      GLfloat dvdy;
+#endif
+#ifdef INTERP_MULTITEX
+      GLfloat dsdy[MAX_TEXTURE_UNITS];
+      GLfloat dtdy[MAX_TEXTURE_UNITS];
+      GLfloat dudy[MAX_TEXTURE_UNITS];
+      GLfloat dvdy[MAX_TEXTURE_UNITS];
+#endif
+
+#if defined(INTERP_LAMBDA) && !defined(INTERP_TEX) && !defined(INTERP_MULTITEX)
+#error "Mipmapping without texturing doesn't make sense."
+#endif
+
+      /*
+       * Execute user-supplied setup code
+       */
+#ifdef SETUP_CODE
+      SETUP_CODE
+#endif
+
+      scan_from_left_to_right = (oneOverArea < 0.0F);
+
+      span.activeMask = 0;
+
+      /* compute d?/dx and d?/dy derivatives */
+#ifdef INTERP_Z
+      span.activeMask |= SPAN_Z;
+      {
+         GLfloat eMaj_dz, eBot_dz;
+         eMaj_dz = vMax->win[2] - vMin->win[2];
+         eBot_dz = vMid->win[2] - vMin->win[2];
+         dzdx = oneOverArea * (eMaj_dz * eBot.dy - eMaj.dy * eBot_dz);
+         if (dzdx > maxDepth || dzdx < -maxDepth) {
+            /* probably a sliver triangle */
+            dzdx = 0.0;
+            dzdy = 0.0;
+         }
+         else {
+            dzdy = oneOverArea * (eMaj.dx * eBot_dz - eMaj_dz * eBot.dx);
+         }
+         if (depthBits <= 16)
+            span.zStep = SignedFloatToFixed(dzdx);
+         else
+            span.zStep = (GLint) dzdx;
+      }
+#endif
+#ifdef INTERP_FOG
+      span.activeMask |= SPAN_FOG;
+      {
+         const GLfloat eMaj_dfog = vMax->fog - vMin->fog;
+         const GLfloat eBot_dfog = vMid->fog - vMin->fog;
+         span.fogStep = oneOverArea * (eMaj_dfog * eBot.dy - eMaj.dy * eBot_dfog);
+         dfogdy = oneOverArea * (eMaj.dx * eBot_dfog - eMaj_dfog * eBot.dx);
+      }
+#endif
+#ifdef INTERP_RGB
+      span.activeMask |= SPAN_RGBA;
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+         GLfloat eMaj_dr, eBot_dr;
+         GLfloat eMaj_dg, eBot_dg;
+         GLfloat eMaj_db, eBot_db;
+#  ifdef INTERP_ALPHA
+         GLfloat eMaj_da, eBot_da;
+#  endif
+         eMaj_dr = (GLfloat) ((GLint) vMax->color[RCOMP] - 
+			      (GLint) vMin->color[RCOMP]);
+         eBot_dr = (GLfloat) ((GLint) vMid->color[RCOMP] - 
+			      (GLint) vMin->color[RCOMP]);
+         drdx = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr);
+         span.redStep = SignedFloatToFixed(drdx);
+         drdy = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx);
+         eMaj_dg = (GLfloat) ((GLint) vMax->color[GCOMP] - 
+			      (GLint) vMin->color[GCOMP]);
+         eBot_dg = (GLfloat) ((GLint) vMid->color[GCOMP] - 
+			      (GLint) vMin->color[GCOMP]);
+         dgdx = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg);
+         span.greenStep = SignedFloatToFixed(dgdx);
+         dgdy = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx);
+         eMaj_db = (GLfloat) ((GLint) vMax->color[BCOMP] - 
+			      (GLint) vMin->color[BCOMP]);
+         eBot_db = (GLfloat) ((GLint) vMid->color[BCOMP] - 
+			      (GLint) vMin->color[BCOMP]);
+         dbdx = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db);
+         span.blueStep = SignedFloatToFixed(dbdx);
+         dbdy = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx);
+#  ifdef INTERP_ALPHA
+         eMaj_da = (GLfloat) ((GLint) vMax->color[ACOMP] - 
+			      (GLint) vMin->color[ACOMP]);
+         eBot_da = (GLfloat) ((GLint) vMid->color[ACOMP] - 
+			      (GLint) vMin->color[ACOMP]);
+         dadx = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
+         span.alphaStep = SignedFloatToFixed(dadx);
+         dady = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
+#  endif
+      }
+      else {
+         ASSERT (ctx->Light.ShadeModel == GL_FLAT);
+         span.activeMask |= SPAN_FLAT;
+         drdx = drdy = 0.0F;
+         dgdx = dgdy = 0.0F;
+         dbdx = dbdy = 0.0F;
+         span.redStep = 0;
+         span.greenStep = 0;
+         span.blueStep = 0;
+#  ifdef INTERP_ALPHA
+         dadx = dady = 0.0F;
+         span.alphaStep = 0;
+#  endif
+      }
+#endif
+#ifdef INTERP_FLOAT_RGBA
+      span.activeMask |= SPAN_RGBA;
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+         GLfloat eMaj_dr, eBot_dr;
+         GLfloat eMaj_dg, eBot_dg;
+         GLfloat eMaj_db, eBot_db;
+         GLfloat eMaj_da, eBot_da;
+         eMaj_dr = vMax->color[RCOMP] - vMin->color[RCOMP];
+         eBot_dr = vMid->color[RCOMP] - vMin->color[RCOMP];
+         drdx = oneOverArea * (eMaj_dr * eBot.dy - eMaj.dy * eBot_dr);
+         span.redStep = drdx;
+         drdy = oneOverArea * (eMaj.dx * eBot_dr - eMaj_dr * eBot.dx);
+         eMaj_dg = vMax->color[GCOMP] - vMin->color[GCOMP];
+         eBot_dg = vMid->color[GCOMP] - vMin->color[GCOMP];
+         dgdx = oneOverArea * (eMaj_dg * eBot.dy - eMaj.dy * eBot_dg);
+         span.greenStep = dgdx;
+         dgdy = oneOverArea * (eMaj.dx * eBot_dg - eMaj_dg * eBot.dx);
+         eMaj_db = vMax->color[BCOMP] - vMin->color[BCOMP];
+         eBot_db = vMid->color[BCOMP] - vMin->color[BCOMP];
+         dbdx = oneOverArea * (eMaj_db * eBot.dy - eMaj.dy * eBot_db);
+         span.blueStep = dbdx;
+         dbdy = oneOverArea * (eMaj.dx * eBot_db - eMaj_db * eBot.dx);
+         eMaj_da = vMax->color[ACOMP] - vMin->color[ACOMP];
+         eBot_da = vMid->color[ACOMP] - vMin->color[ACOMP];
+         dadx = oneOverArea * (eMaj_da * eBot.dy - eMaj.dy * eBot_da);
+         span.alphaStep = dadx;
+         dady = oneOverArea * (eMaj.dx * eBot_da - eMaj_da * eBot.dx);
+      }
+      else {
+         drdx = drdy = span.redStep = 0.0F;
+         dgdx = dgdy = span.greenStep = 0.0F;
+         dbdx = dbdy = span.blueStep = 0.0F;
+         dadx = dady = span.alphaStep = 0.0F;
+      }
+#endif
+#ifdef INTERP_SPEC
+      span.activeMask |= SPAN_SPEC;
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+         GLfloat eMaj_dsr, eBot_dsr;
+         GLfloat eMaj_dsg, eBot_dsg;
+         GLfloat eMaj_dsb, eBot_dsb;
+         eMaj_dsr = (GLfloat) ((GLint) vMax->specular[RCOMP] - 
+			       (GLint) vMin->specular[RCOMP]);
+         eBot_dsr = (GLfloat) ((GLint) vMid->specular[RCOMP] - 
+			       (GLint) vMin->specular[RCOMP]);
+         dsrdx = oneOverArea * (eMaj_dsr * eBot.dy - eMaj.dy * eBot_dsr);
+         span.specRedStep = SignedFloatToFixed(dsrdx);
+         dsrdy = oneOverArea * (eMaj.dx * eBot_dsr - eMaj_dsr * eBot.dx);
+         eMaj_dsg = (GLfloat) ((GLint) vMax->specular[GCOMP] - 
+			       (GLint) vMin->specular[GCOMP]);
+         eBot_dsg = (GLfloat) ((GLint) vMid->specular[GCOMP] - 
+			       (GLint) vMin->specular[GCOMP]);
+         dsgdx = oneOverArea * (eMaj_dsg * eBot.dy - eMaj.dy * eBot_dsg);
+         span.specGreenStep = SignedFloatToFixed(dsgdx);
+         dsgdy = oneOverArea * (eMaj.dx * eBot_dsg - eMaj_dsg * eBot.dx);
+         eMaj_dsb = (GLfloat) ((GLint) vMax->specular[BCOMP] - 
+			       (GLint) vMin->specular[BCOMP]);
+         eBot_dsb = (GLfloat) ((GLint) vMid->specular[BCOMP] - 
+			       (GLint) vMin->specular[BCOMP]);
+         dsbdx = oneOverArea * (eMaj_dsb * eBot.dy - eMaj.dy * eBot_dsb);
+         span.specBlueStep = SignedFloatToFixed(dsbdx);
+         dsbdy = oneOverArea * (eMaj.dx * eBot_dsb - eMaj_dsb * eBot.dx);
+      }
+      else {
+         dsrdx = dsrdy = 0.0F;
+         dsgdx = dsgdy = 0.0F;
+         dsbdx = dsbdy = 0.0F;
+         span.specRedStep = 0;
+         span.specGreenStep = 0;
+         span.specBlueStep = 0;
+      }
+#endif
+#ifdef INTERP_FLOAT_SPEC
+      span.activeMask |= SPAN_SPEC;
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+         GLfloat eMaj_dsr, eBot_dsr;
+         GLfloat eMaj_dsg, eBot_dsg;
+         GLfloat eMaj_dsb, eBot_dsb;
+         eMaj_dsr = vMax->specular[RCOMP] - vMin->specular[RCOMP];
+         eBot_dsr = vMid->specular[RCOMP] - vMin->specular[RCOMP];
+         dsrdx = oneOverArea * (eMaj_dsr * eBot.dy - eMaj.dy * eBot_dsr);
+         span.specRedStep = dsrdx;
+         dsrdy = oneOverArea * (eMaj.dx * eBot_dsr - eMaj_dsr * eBot.dx);
+         eMaj_dsg = vMax->specular[GCOMP] - vMin->specular[GCOMP];
+         eBot_dsg = vMid->specular[GCOMP] - vMin->specular[GCOMP];
+         dsgdx = oneOverArea * (eMaj_dsg * eBot.dy - eMaj.dy * eBot_dsg);
+         span.specGreenStep = dsgdx;
+         dsgdy = oneOverArea * (eMaj.dx * eBot_dsg - eMaj_dsg * eBot.dx);
+         eMaj_dsb = vMax->specular[BCOMP] - vMin->specular[BCOMP];
+         eBot_dsb = vMid->specular[BCOMP] - vMin->specular[BCOMP];
+         dsbdx = oneOverArea * (eMaj_dsb * eBot.dy - eMaj.dy * eBot_dsb);
+         span.specBlueStep = dsbdx;
+         dsbdy = oneOverArea * (eMaj.dx * eBot_dsb - eMaj_dsb * eBot.dx);
+      }
+      else {
+         dsrdx = dsrdy = span.specRedStep = 0;
+         dsgdx = dsgdy = span.specGreenStep = 0;
+         dsbdx = dsbdy = span.specBlueStep = 0;
+      }
+#endif
+#ifdef INTERP_INDEX
+      span.activeMask |= SPAN_INDEX;
+      if (ctx->Light.ShadeModel == GL_SMOOTH) {
+         GLfloat eMaj_di, eBot_di;
+         eMaj_di = (GLfloat) ((GLint) vMax->index - (GLint) vMin->index);
+         eBot_di = (GLfloat) ((GLint) vMid->index - (GLint) vMin->index);
+         didx = oneOverArea * (eMaj_di * eBot.dy - eMaj.dy * eBot_di);
+         span.indexStep = SignedFloatToFixed(didx);
+         didy = oneOverArea * (eMaj.dx * eBot_di - eMaj_di * eBot.dx);
+      }
+      else {
+         span.activeMask |= SPAN_FLAT;
+         didx = didy = 0.0F;
+         span.indexStep = 0;
+      }
+#endif
+#ifdef INTERP_INT_TEX
+      span.activeMask |= SPAN_INT_TEXTURE;
+      {
+         GLfloat eMaj_ds, eBot_ds;
+         eMaj_ds = (vMax->texcoord[0][0] - vMin->texcoord[0][0]) * S_SCALE;
+         eBot_ds = (vMid->texcoord[0][0] - vMin->texcoord[0][0]) * S_SCALE;
+         dsdx = oneOverArea * (eMaj_ds * eBot.dy - eMaj.dy * eBot_ds);
+         span.intTexStep[0] = SignedFloatToFixed(dsdx);
+         dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
+      }
+      {
+         GLfloat eMaj_dt, eBot_dt;
+         eMaj_dt = (vMax->texcoord[0][1] - vMin->texcoord[0][1]) * T_SCALE;
+         eBot_dt = (vMid->texcoord[0][1] - vMin->texcoord[0][1]) * T_SCALE;
+         dtdx = oneOverArea * (eMaj_dt * eBot.dy - eMaj.dy * eBot_dt);
+         span.intTexStep[1] = SignedFloatToFixed(dtdx);
+         dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
+      }
+
+#endif
+#ifdef INTERP_TEX
+      span.activeMask |= SPAN_TEXTURE;
+      {
+         GLfloat wMax = vMax->win[3];
+         GLfloat wMin = vMin->win[3];
+         GLfloat wMid = vMid->win[3];
+         GLfloat eMaj_ds, eBot_ds;
+         GLfloat eMaj_dt, eBot_dt;
+         GLfloat eMaj_du, eBot_du;
+         GLfloat eMaj_dv, eBot_dv;
+
+         eMaj_ds = vMax->texcoord[0][0] * wMax - vMin->texcoord[0][0] * wMin;
+         eBot_ds = vMid->texcoord[0][0] * wMid - vMin->texcoord[0][0] * wMin;
+         span.texStep[0][0] = oneOverArea * (eMaj_ds * eBot.dy
+                                             - eMaj.dy * eBot_ds);
+         dsdy = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
+
+         eMaj_dt = vMax->texcoord[0][1] * wMax - vMin->texcoord[0][1] * wMin;
+         eBot_dt = vMid->texcoord[0][1] * wMid - vMin->texcoord[0][1] * wMin;
+         span.texStep[0][1] = oneOverArea * (eMaj_dt * eBot.dy
+                                             - eMaj.dy * eBot_dt);
+         dtdy = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
+
+         eMaj_du = vMax->texcoord[0][2] * wMax - vMin->texcoord[0][2] * wMin;
+         eBot_du = vMid->texcoord[0][2] * wMid - vMin->texcoord[0][2] * wMin;
+         span.texStep[0][2] = oneOverArea * (eMaj_du * eBot.dy
+                                             - eMaj.dy * eBot_du);
+         dudy = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx);
+
+         eMaj_dv = vMax->texcoord[0][3] * wMax - vMin->texcoord[0][3] * wMin;
+         eBot_dv = vMid->texcoord[0][3] * wMid - vMin->texcoord[0][3] * wMin;
+         span.texStep[0][3] = oneOverArea * (eMaj_dv * eBot.dy
+                                             - eMaj.dy * eBot_dv);
+         dvdy = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
+      }
+#  ifdef INTERP_LAMBDA
+      {
+         GLfloat dudx = span.texStep[0][0] * span.texWidth[0];
+         GLfloat dudy = dsdy * span.texWidth[0];
+         GLfloat dvdx = span.texStep[0][1] * span.texHeight[0];
+         GLfloat dvdy = dtdy * span.texHeight[0];
+         GLfloat r1 = dudx * dudx + dudy * dudy;
+         GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
+         span.rho[0] = r1 + r2; /* was rho2 = MAX2(r1,r2) */
+         span.activeMask |= SPAN_LAMBDA;
+      }
+#  endif
+#endif
+#ifdef INTERP_MULTITEX
+      span.activeMask |= SPAN_TEXTURE;
+#  ifdef INTERP_LAMBDA
+      span.activeMask |= SPAN_LAMBDA;
+#  endif
+      {
+         GLfloat wMax = vMax->win[3];
+         GLfloat wMin = vMin->win[3];
+         GLfloat wMid = vMid->win[3];
+         GLuint u;
+         for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+            if (ctx->Texture.Unit[u]._ReallyEnabled) {
+               GLfloat eMaj_ds, eBot_ds;
+               GLfloat eMaj_dt, eBot_dt;
+               GLfloat eMaj_du, eBot_du;
+               GLfloat eMaj_dv, eBot_dv;
+               eMaj_ds = vMax->texcoord[u][0] * wMax
+                       - vMin->texcoord[u][0] * wMin;
+               eBot_ds = vMid->texcoord[u][0] * wMid
+                       - vMin->texcoord[u][0] * wMin;
+               span.texStep[u][0] = oneOverArea * (eMaj_ds * eBot.dy
+                                                   - eMaj.dy * eBot_ds);
+               dsdy[u] = oneOverArea * (eMaj.dx * eBot_ds - eMaj_ds * eBot.dx);
+
+               eMaj_dt = vMax->texcoord[u][1] * wMax
+                       - vMin->texcoord[u][1] * wMin;
+               eBot_dt = vMid->texcoord[u][1] * wMid
+                       - vMin->texcoord[u][1] * wMin;
+               span.texStep[u][1] = oneOverArea * (eMaj_dt * eBot.dy
+                                                   - eMaj.dy * eBot_dt);
+               dtdy[u] = oneOverArea * (eMaj.dx * eBot_dt - eMaj_dt * eBot.dx);
+
+               eMaj_du = vMax->texcoord[u][2] * wMax
+                       - vMin->texcoord[u][2] * wMin;
+               eBot_du = vMid->texcoord[u][2] * wMid
+                       - vMin->texcoord[u][2] * wMin;
+               span.texStep[u][2] = oneOverArea * (eMaj_du * eBot.dy
+                                                   - eMaj.dy * eBot_du);
+               dudy[u] = oneOverArea * (eMaj.dx * eBot_du - eMaj_du * eBot.dx);
+
+               eMaj_dv = vMax->texcoord[u][3] * wMax
+                       - vMin->texcoord[u][3] * wMin;
+               eBot_dv = vMid->texcoord[u][3] * wMid
+                       - vMin->texcoord[u][3] * wMin;
+               span.texStep[u][3] = oneOverArea * (eMaj_dv * eBot.dy
+                                                   - eMaj.dy * eBot_dv);
+               dvdy[u] = oneOverArea * (eMaj.dx * eBot_dv - eMaj_dv * eBot.dx);
+#  ifdef INTERP_LAMBDA
+               {
+                  GLfloat dudx = span.texStep[u][0] * span.texWidth[u];
+                  GLfloat dudy = dsdy[u] * span.texWidth[u];
+                  GLfloat dvdx = span.texStep[u][1] * span.texHeight[u];
+                  GLfloat dvdy = dtdy[u] * span.texHeight[u];
+                  GLfloat r1 = dudx * dudx + dudy * dudy;
+                  GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
+                  span.rho[u] = r1 + r2; /* was rho2 = MAX2(r1,r2) */
+               }
+#  endif
+            }
+         }
+      }
+#endif
+
+      /*
+       * We always sample at pixel centers.  However, we avoid
+       * explicit half-pixel offsets in this code by incorporating
+       * the proper offset in each of x and y during the
+       * transformation to window coordinates.
+       *
+       * We also apply the usual rasterization rules to prevent
+       * cracks and overlaps.  A pixel is considered inside a
+       * subtriangle if it meets all of four conditions: it is on or
+       * to the right of the left edge, strictly to the left of the
+       * right edge, on or below the top edge, and strictly above
+       * the bottom edge.  (Some edges may be degenerate.)
+       *
+       * The following discussion assumes left-to-right scanning
+       * (that is, the major edge is on the left); the right-to-left
+       * case is a straightforward variation.
+       *
+       * We start by finding the half-integral y coordinate that is
+       * at or below the top of the triangle.  This gives us the
+       * first scan line that could possibly contain pixels that are
+       * inside the triangle.
+       *
+       * Next we creep down the major edge until we reach that y,
+       * and compute the corresponding x coordinate on the edge.
+       * Then we find the half-integral x that lies on or just
+       * inside the edge.  This is the first pixel that might lie in
+       * the interior of the triangle.  (We won't know for sure
+       * until we check the other edges.)
+       *
+       * As we rasterize the triangle, we'll step down the major
+       * edge.  For each step in y, we'll move an integer number
+       * of steps in x.  There are two possible x step sizes, which
+       * we'll call the ``inner'' step (guaranteed to land on the
+       * edge or inside it) and the ``outer'' step (guaranteed to
+       * land on the edge or outside it).  The inner and outer steps
+       * differ by one.  During rasterization we maintain an error
+       * term that indicates our distance from the true edge, and
+       * select either the inner step or the outer step, whichever
+       * gets us to the first pixel that falls inside the triangle.
+       *
+       * All parameters (z, red, etc.) as well as the buffer
+       * addresses for color and z have inner and outer step values,
+       * so that we can increment them appropriately.  This method
+       * eliminates the need to adjust parameters by creeping a
+       * sub-pixel amount into the triangle at each scanline.
+       */
+
+      {
+         int subTriangle;
+         GLfixed fx;
+         GLfixed fxLeftEdge = 0, fxRightEdge = 0;
+         GLfixed fdxLeftEdge = 0, fdxRightEdge = 0;
+         GLfixed fdxOuter;
+         int idxOuter;
+         float dxOuter;
+         GLfixed fError = 0, fdError = 0;
+         float adjx, adjy;
+         GLfixed fy;
+#ifdef PIXEL_ADDRESS
+         PIXEL_TYPE *pRow = NULL;
+         int dPRowOuter = 0, dPRowInner;  /* offset in bytes */
+#endif
+#ifdef INTERP_Z
+#  ifdef DEPTH_TYPE
+         DEPTH_TYPE *zRow = NULL;
+         int dZRowOuter = 0, dZRowInner;  /* offset in bytes */
+#  endif
+         GLfixed fz = 0, fdzOuter = 0, fdzInner;
+#endif
+#ifdef INTERP_FOG
+         GLfloat fogLeft = 0, dfogOuter = 0, dfogInner;
+#endif
+#ifdef INTERP_RGB
+         GLfixed fr = 0, fdrOuter = 0, fdrInner;
+         GLfixed fg = 0, fdgOuter = 0, fdgInner;
+         GLfixed fb = 0, fdbOuter = 0, fdbInner;
+#endif
+#ifdef INTERP_ALPHA
+         GLfixed fa = 0, fdaOuter = 0, fdaInner;
+#endif
+#ifdef INTERP_FLOAT_RGBA
+         GLfloat fr, fdrOuter, fdrInner;
+         GLfloat fg, fdgOuter, fdgInner;
+         GLfloat fb, fdbOuter, fdbInner;
+         GLfloat fa, fdaOuter, fdaInner;
+#endif
+#ifdef INTERP_SPEC
+         GLfixed fsr=0, fdsrOuter=0, fdsrInner;
+         GLfixed fsg=0, fdsgOuter=0, fdsgInner;
+         GLfixed fsb=0, fdsbOuter=0, fdsbInner;
+#endif
+#ifdef INTERP_FLOAT_SPEC
+         GLfloat fsr=0, fdsrOuter=0, fdsrInner;
+         GLfloat fsg=0, fdsgOuter=0, fdsgInner;
+         GLfloat fsb=0, fdsbOuter=0, fdsbInner;
+#endif
+#ifdef INTERP_INDEX
+         GLfixed fi=0, fdiOuter=0, fdiInner;
+#endif
+#ifdef INTERP_INT_TEX
+         GLfixed fs=0, fdsOuter=0, fdsInner;
+         GLfixed ft=0, fdtOuter=0, fdtInner;
+#endif
+#ifdef INTERP_TEX
+         GLfloat sLeft=0, dsOuter=0, dsInner;
+         GLfloat tLeft=0, dtOuter=0, dtInner;
+         GLfloat uLeft=0, duOuter=0, duInner;
+         GLfloat vLeft=0, dvOuter=0, dvInner;
+#endif
+#ifdef INTERP_MULTITEX
+         GLfloat sLeft[MAX_TEXTURE_UNITS];
+         GLfloat tLeft[MAX_TEXTURE_UNITS];
+         GLfloat uLeft[MAX_TEXTURE_UNITS];
+         GLfloat vLeft[MAX_TEXTURE_UNITS];
+         GLfloat dsOuter[MAX_TEXTURE_UNITS], dsInner[MAX_TEXTURE_UNITS];
+         GLfloat dtOuter[MAX_TEXTURE_UNITS], dtInner[MAX_TEXTURE_UNITS];
+         GLfloat duOuter[MAX_TEXTURE_UNITS], duInner[MAX_TEXTURE_UNITS];
+         GLfloat dvOuter[MAX_TEXTURE_UNITS], dvInner[MAX_TEXTURE_UNITS];
+#endif
+
+         for (subTriangle=0; subTriangle<=1; subTriangle++) {
+            EdgeT *eLeft, *eRight;
+            int setupLeft, setupRight;
+            int lines;
+
+            if (subTriangle==0) {
+               /* bottom half */
+               if (scan_from_left_to_right) {
+                  eLeft = &eMaj;
+                  eRight = &eBot;
+                  lines = eRight->lines;
+                  setupLeft = 1;
+                  setupRight = 1;
+               }
+               else {
+                  eLeft = &eBot;
+                  eRight = &eMaj;
+                  lines = eLeft->lines;
+                  setupLeft = 1;
+                  setupRight = 1;
+               }
+            }
+            else {
+               /* top half */
+               if (scan_from_left_to_right) {
+                  eLeft = &eMaj;
+                  eRight = &eTop;
+                  lines = eRight->lines;
+                  setupLeft = 0;
+                  setupRight = 1;
+               }
+               else {
+                  eLeft = &eTop;
+                  eRight = &eMaj;
+                  lines = eLeft->lines;
+                  setupLeft = 1;
+                  setupRight = 0;
+               }
+               if (lines == 0)
+                  return;
+            }
+
+            if (setupLeft && eLeft->lines > 0) {
+               const SWvertex *vLower;
+               GLfixed fsx = eLeft->fsx;
+               fx = FixedCeil(fsx);
+               fError = fx - fsx - FIXED_ONE;
+               fxLeftEdge = fsx - FIXED_EPSILON;
+               fdxLeftEdge = eLeft->fdxdy;
+               fdxOuter = FixedFloor(fdxLeftEdge - FIXED_EPSILON);
+               fdError = fdxOuter - fdxLeftEdge + FIXED_ONE;
+               idxOuter = FixedToInt(fdxOuter);
+               dxOuter = (float) idxOuter;
+               (void) dxOuter;
+
+               fy = eLeft->fsy;
+               span.y = FixedToInt(fy);
+
+               adjx = (float)(fx - eLeft->fx0);  /* SCALED! */
+               adjy = eLeft->adjy;		 /* SCALED! */
+               (void) adjx;  /* silence compiler warnings */
+               (void) adjy;  /* silence compiler warnings */
+
+               vLower = eLeft->v0;
+               (void) vLower;  /* silence compiler warnings */
+
+#ifdef PIXEL_ADDRESS
+               {
+                  pRow = (PIXEL_TYPE *) PIXEL_ADDRESS(FixedToInt(fxLeftEdge), span.y);
+                  dPRowOuter = -((int)BYTES_PER_ROW) + idxOuter * sizeof(PIXEL_TYPE);
+                  /* negative because Y=0 at bottom and increases upward */
+               }
+#endif
+               /*
+                * Now we need the set of parameter (z, color, etc.) values at
+                * the point (fx, fy).  This gives us properly-sampled parameter
+                * values that we can step from pixel to pixel.  Furthermore,
+                * although we might have intermediate results that overflow
+                * the normal parameter range when we step temporarily outside
+                * the triangle, we shouldn't overflow or underflow for any
+                * pixel that's actually inside the triangle.
+                */
+
+#ifdef INTERP_Z
+               {
+                  GLfloat z0 = vLower->win[2];
+                  if (depthBits <= 16) {
+                     /* interpolate fixed-pt values */
+                     GLfloat tmp = (z0 * FIXED_SCALE +
+                                    dzdx * adjx + dzdy * adjy) + FIXED_HALF;
+                     if (tmp < MAX_GLUINT / 2)
+                        fz = (GLfixed) tmp;
+                     else
+                        fz = MAX_GLUINT / 2;
+                     fdzOuter = SignedFloatToFixed(dzdy + dxOuter * dzdx);
+                  }
+                  else {
+                     /* interpolate depth values exactly */
+                     fz = (GLint) (z0 + dzdx * FixedToFloat(adjx)
+                                   + dzdy * FixedToFloat(adjy));
+                     fdzOuter = (GLint) (dzdy + dxOuter * dzdx);
+                  }
+#  ifdef DEPTH_TYPE
+                  zRow = (DEPTH_TYPE *)
+                    _mesa_zbuffer_address(ctx, FixedToInt(fxLeftEdge), span.y);
+                  dZRowOuter = (ctx->DrawBuffer->Width + idxOuter) * sizeof(DEPTH_TYPE);
+#  endif
+               }
+#endif
+#ifdef INTERP_FOG
+               fogLeft = vLower->fog + (span.fogStep * adjx + dfogdy * adjy)
+                                       * (1.0F/FIXED_SCALE);
+               dfogOuter = dfogdy + dxOuter * span.fogStep;
+#endif
+#ifdef INTERP_RGB
+               if (ctx->Light.ShadeModel == GL_SMOOTH) {
+                  fr = (GLfixed) (ChanToFixed(vLower->color[RCOMP])
+                                   + drdx * adjx + drdy * adjy) + FIXED_HALF;
+                  fdrOuter = SignedFloatToFixed(drdy + dxOuter * drdx);
+                  fg = (GLfixed) (ChanToFixed(vLower->color[GCOMP])
+                                   + dgdx * adjx + dgdy * adjy) + FIXED_HALF;
+                  fdgOuter = SignedFloatToFixed(dgdy + dxOuter * dgdx);
+                  fb = (GLfixed) (ChanToFixed(vLower->color[BCOMP])
+                                    + dbdx * adjx + dbdy * adjy) + FIXED_HALF;
+                  fdbOuter = SignedFloatToFixed(dbdy + dxOuter * dbdx);
+#  ifdef INTERP_ALPHA
+                  fa = (GLfixed) (ChanToFixed(vLower->color[ACOMP])
+                                   + dadx * adjx + dady * adjy) + FIXED_HALF;
+                  fdaOuter = SignedFloatToFixed(dady + dxOuter * dadx);
+#  endif
+               }
+               else {
+                  ASSERT (ctx->Light.ShadeModel == GL_FLAT);
+                  fr = ChanToFixed(v2->color[RCOMP]);
+                  fg = ChanToFixed(v2->color[GCOMP]);
+                  fb = ChanToFixed(v2->color[BCOMP]);
+                  fdrOuter = fdgOuter = fdbOuter = 0;
+#  ifdef INTERP_ALPHA
+                  fa =  ChanToFixed(v2->color[ACOMP]);
+                  fdaOuter = 0;
+#  endif
+               }
+#endif
+#ifdef INTERP_FLOAT_RGBA
+               if (ctx->Light.ShadeModel == GL_SMOOTH) {
+                  fr = vLower->color[RCOMP]
+                     + (drdx * adjx + drdy * adjy) * (1.0F / FIXED_SCALE);
+                  fdrOuter = drdy + dxOuter * drdx;
+                  fg = vLower->color[GCOMP]
+                     + (dgdx * adjx + dgdy * adjy) * (1.0F / FIXED_SCALE);
+                  fdgOuter = dgdy + dxOuter * dgdx;
+                  fb = vLower->color[BCOMP]
+                     + (dbdx * adjx + dbdy * adjy) * (1.0F / FIXED_SCALE);
+                  fdbOuter = dbdy + dxOuter * dbdx;
+                  fa = vLower->color[ACOMP]
+                     + (dadx * adjx + dady * adjy) * (1.0F / FIXED_SCALE);
+                  fdaOuter = dady + dxOuter * dadx;
+               }
+               else {
+                  fr = v2->color[RCOMP];
+                  fg = v2->color[GCOMP];
+                  fb = v2->color[BCOMP];
+                  fa = v2->color[ACOMP];
+                  fdrOuter = fdgOuter = fdbOuter = fdaOuter = 0.0F;
+               }
+#endif
+#ifdef INTERP_SPEC
+               if (ctx->Light.ShadeModel == GL_SMOOTH) {
+                  fsr = (GLfixed) (ChanToFixed(vLower->specular[RCOMP])
+                                   + dsrdx * adjx + dsrdy * adjy) + FIXED_HALF;
+                  fdsrOuter = SignedFloatToFixed(dsrdy + dxOuter * dsrdx);
+                  fsg = (GLfixed) (ChanToFixed(vLower->specular[GCOMP])
+                                   + dsgdx * adjx + dsgdy * adjy) + FIXED_HALF;
+                  fdsgOuter = SignedFloatToFixed(dsgdy + dxOuter * dsgdx);
+                  fsb = (GLfixed) (ChanToFixed(vLower->specular[BCOMP])
+                                   + dsbdx * adjx + dsbdy * adjy) + FIXED_HALF;
+                  fdsbOuter = SignedFloatToFixed(dsbdy + dxOuter * dsbdx);
+               }
+               else {
+                  fsr = ChanToFixed(v2->specular[RCOMP]);
+                  fsg = ChanToFixed(v2->specular[GCOMP]);
+                  fsb = ChanToFixed(v2->specular[BCOMP]);
+                  fdsrOuter = fdsgOuter = fdsbOuter = 0;
+               }
+#endif
+#ifdef INTERP_FLOAT_SPEC
+               if (ctx->Light.ShadeModel == GL_SMOOTH) {
+                  fsr = vLower->specular[RCOMP]
+                     + (dsrdx * adjx + dsrdy * adjy) * (1.0F / FIXED_SCALE);
+                  fdsrOuter = dsrdy + dxOuter * dsrdx;
+                  fsg = vLower->specular[GCOMP]
+                     + (dsgdx * adjx + dsgdy * adjy) * (1.0F / FIXED_SCALE);
+                  fdsgOuter = dsgdy + dxOuter * dsgdx;
+                  fsb = vLower->specular[BCOMP]
+                     + (dsbdx * adjx + dsbdy * adjy) * (1.0F / FIXED_SCALE);
+                  fdsbOuter = dsbdy + dxOuter * dsbdx;
+               }
+               else {
+                  fsr = v2->specular[RCOMP];
+                  fsg = v2->specular[GCOMP];
+                  fsb = v2->specular[BCOMP];
+                  fdsrOuter = fdsgOuter = fdsbOuter = 0.0F;
+               }
+#endif
+#ifdef INTERP_INDEX
+               if (ctx->Light.ShadeModel == GL_SMOOTH) {
+                  fi = (GLfixed)(vLower->index * FIXED_SCALE
+                                 + didx * adjx + didy * adjy) + FIXED_HALF;
+                  fdiOuter = SignedFloatToFixed(didy + dxOuter * didx);
+               }
+               else {
+                  fi = (GLfixed) (v2->index * FIXED_SCALE);
+                  fdiOuter = 0;
+               }
+#endif
+#ifdef INTERP_INT_TEX
+               {
+                  GLfloat s0, t0;
+                  s0 = vLower->texcoord[0][0] * S_SCALE;
+                  fs = (GLfixed)(s0 * FIXED_SCALE + dsdx * adjx
+                                 + dsdy * adjy) + FIXED_HALF;
+                  fdsOuter = SignedFloatToFixed(dsdy + dxOuter * dsdx);
+
+                  t0 = vLower->texcoord[0][1] * T_SCALE;
+                  ft = (GLfixed)(t0 * FIXED_SCALE + dtdx * adjx
+                                 + dtdy * adjy) + FIXED_HALF;
+                  fdtOuter = SignedFloatToFixed(dtdy + dxOuter * dtdx);
+               }
+#endif
+#ifdef INTERP_TEX
+               {
+                  GLfloat invW = vLower->win[3];
+                  GLfloat s0, t0, u0, v0;
+                  s0 = vLower->texcoord[0][0] * invW;
+                  sLeft = s0 + (span.texStep[0][0] * adjx + dsdy * adjy)
+                     * (1.0F/FIXED_SCALE);
+                  dsOuter = dsdy + dxOuter * span.texStep[0][0];
+                  t0 = vLower->texcoord[0][1] * invW;
+                  tLeft = t0 + (span.texStep[0][1] * adjx + dtdy * adjy)
+                     * (1.0F/FIXED_SCALE);
+                  dtOuter = dtdy + dxOuter * span.texStep[0][1];
+                  u0 = vLower->texcoord[0][2] * invW;
+                  uLeft = u0 + (span.texStep[0][2] * adjx + dudy * adjy)
+                     * (1.0F/FIXED_SCALE);
+                  duOuter = dudy + dxOuter * span.texStep[0][2];
+                  v0 = vLower->texcoord[0][3] * invW;
+                  vLeft = v0 + (span.texStep[0][3] * adjx + dvdy * adjy)
+                     * (1.0F/FIXED_SCALE);
+                  dvOuter = dvdy + dxOuter * span.texStep[0][3];
+               }
+#endif
+#ifdef INTERP_MULTITEX
+               {
+                  GLuint u;
+                  for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+                     if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                        GLfloat invW = vLower->win[3];
+                        GLfloat s0, t0, u0, v0;
+                        s0 = vLower->texcoord[u][0] * invW;
+                        sLeft[u] = s0 + (span.texStep[u][0] * adjx + dsdy[u]
+                                         * adjy) * (1.0F/FIXED_SCALE);
+                        dsOuter[u] = dsdy[u] + dxOuter * span.texStep[u][0];
+                        t0 = vLower->texcoord[u][1] * invW;
+                        tLeft[u] = t0 + (span.texStep[u][1] * adjx + dtdy[u]
+                                         * adjy) * (1.0F/FIXED_SCALE);
+                        dtOuter[u] = dtdy[u] + dxOuter * span.texStep[u][1];
+                        u0 = vLower->texcoord[u][2] * invW;
+                        uLeft[u] = u0 + (span.texStep[u][2] * adjx + dudy[u]
+                                         * adjy) * (1.0F/FIXED_SCALE);
+                        duOuter[u] = dudy[u] + dxOuter * span.texStep[u][2];
+                        v0 = vLower->texcoord[u][3] * invW;
+                        vLeft[u] = v0 + (span.texStep[u][3] * adjx + dvdy[u]
+                                         * adjy) * (1.0F/FIXED_SCALE);
+                        dvOuter[u] = dvdy[u] + dxOuter * span.texStep[u][3];
+                     }
+                  }
+               }
+#endif
+
+            } /*if setupLeft*/
+
+
+            if (setupRight && eRight->lines>0) {
+               fxRightEdge = eRight->fsx - FIXED_EPSILON;
+               fdxRightEdge = eRight->fdxdy;
+            }
+
+            if (lines==0) {
+               continue;
+            }
+
+
+            /* Rasterize setup */
+#ifdef PIXEL_ADDRESS
+            dPRowInner = dPRowOuter + sizeof(PIXEL_TYPE);
+#endif
+#ifdef INTERP_Z
+#  ifdef DEPTH_TYPE
+            dZRowInner = dZRowOuter + sizeof(DEPTH_TYPE);
+#  endif
+            fdzInner = fdzOuter + span.zStep;
+#endif
+#ifdef INTERP_FOG
+            dfogInner = dfogOuter + span.fogStep;
+#endif
+#if defined(INTERP_RGB) || defined(INTERP_FLOAT_RGBA)
+            fdrInner = fdrOuter + span.redStep;
+            fdgInner = fdgOuter + span.greenStep;
+            fdbInner = fdbOuter + span.blueStep;
+#endif
+#if defined(INTERP_ALPHA) || defined(INTERP_FLOAT_RGBA)
+            fdaInner = fdaOuter + span.alphaStep;
+#endif
+#if defined(INTERP_SPEC) || defined(INTERP_FLOAT_SPEC)
+            fdsrInner = fdsrOuter + span.specRedStep;
+            fdsgInner = fdsgOuter + span.specGreenStep;
+            fdsbInner = fdsbOuter + span.specBlueStep;
+#endif
+#ifdef INTERP_INDEX
+            fdiInner = fdiOuter + span.indexStep;
+#endif
+#ifdef INTERP_INT_TEX
+            fdsInner = fdsOuter + span.intTexStep[0];
+            fdtInner = fdtOuter + span.intTexStep[1];
+#endif
+#ifdef INTERP_TEX
+            dsInner = dsOuter + span.texStep[0][0];
+            dtInner = dtOuter + span.texStep[0][1];
+            duInner = duOuter + span.texStep[0][2];
+            dvInner = dvOuter + span.texStep[0][3];
+#endif
+#ifdef INTERP_MULTITEX
+            {
+               GLuint u;
+               for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+                  if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                     dsInner[u] = dsOuter[u] + span.texStep[u][0];
+                     dtInner[u] = dtOuter[u] + span.texStep[u][1];
+                     duInner[u] = duOuter[u] + span.texStep[u][2];
+                     dvInner[u] = dvOuter[u] + span.texStep[u][3];
+                  }
+               }
+            }
+#endif
+
+            while (lines > 0) {
+               /* initialize the span interpolants to the leftmost value */
+               /* ff = fixed-pt fragment */
+               const GLint right = FixedToInt(fxRightEdge);
+               span.x = FixedToInt(fxLeftEdge);
+               if (right <= span.x)
+                  span.count = 0;
+               else
+                  span.count = right - span.x;
+
+#ifdef INTERP_Z
+               span.z = fz;
+#endif
+#ifdef INTERP_FOG
+               span.fog = fogLeft;
+#endif
+#if defined(INTERP_RGB) || defined(INTERP_FLOAT_RGBA)
+               span.red = fr;
+               span.green = fg;
+               span.blue = fb;
+#endif
+#if defined(INTERP_ALPHA) || defined(INTERP_FLOAT_RGBA)
+               span.alpha = fa;
+#endif
+#if defined(INTERP_SPEC) || defined(INTERP_FLOAT_SPEC)
+               span.specRed = fsr;
+               span.specGreen = fsg;
+               span.specBlue = fsb;
+#endif
+#ifdef INTERP_INDEX
+               span.index = fi;
+#endif
+#ifdef INTERP_INT_TEX
+               span.intTex[0] = fs;
+               span.intTex[1] = ft;
+#endif
+
+#ifdef INTERP_TEX
+               span.tex[0][0] = sLeft;
+               span.tex[0][1] = tLeft;
+               span.tex[0][2] = uLeft;
+               span.tex[0][3] = vLeft;
+#endif
+
+#ifdef INTERP_MULTITEX
+               {
+                  GLuint u;
+                  for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+                     if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                        span.tex[u][0] = sLeft[u];
+                        span.tex[u][1] = tLeft[u];
+                        span.tex[u][2] = uLeft[u];
+                        span.tex[u][3] = vLeft[u];
+                     }
+                  }
+               }
+#endif
+
+#ifdef INTERP_RGB
+               {
+                  /* need this to accomodate round-off errors */
+                  const GLint len = right - span.x - 1;
+                  GLfixed ffrend = span.red + len * span.redStep;
+                  GLfixed ffgend = span.green + len * span.greenStep;
+                  GLfixed ffbend = span.blue + len * span.blueStep;
+                  if (ffrend < 0) {
+                     span.red -= ffrend;
+                     if (span.red < 0)
+                        span.red = 0;
+                  }
+                  if (ffgend < 0) {
+                     span.green -= ffgend;
+                     if (span.green < 0)
+                        span.green = 0;
+                  }
+                  if (ffbend < 0) {
+                     span.blue -= ffbend;
+                     if (span.blue < 0)
+                        span.blue = 0;
+                  }
+               }
+#endif
+#ifdef INTERP_ALPHA
+               {
+                  const GLint len = right - span.x - 1;
+                  GLfixed ffaend = span.alpha + len * span.alphaStep;
+                  if (ffaend < 0) {
+                     span.alpha -= ffaend;
+                     if (span.alpha < 0)
+                        span.alpha = 0;
+                  }
+               }
+#endif
+#ifdef INTERP_SPEC
+               {
+                  /* need this to accomodate round-off errors */
+                  const GLint len = right - span.x - 1;
+                  GLfixed ffsrend = span.specRed + len * span.specRedStep;
+                  GLfixed ffsgend = span.specGreen + len * span.specGreenStep;
+                  GLfixed ffsbend = span.specBlue + len * span.specBlueStep;
+                  if (ffsrend < 0) {
+                     span.specRed -= ffsrend;
+                     if (span.specRed < 0)
+                        span.specRed = 0;
+                  }
+                  if (ffsgend < 0) {
+                     span.specGreen -= ffsgend;
+                     if (span.specGreen < 0)
+                        span.specGreen = 0;
+                  }
+                  if (ffsbend < 0) {
+                     span.specBlue -= ffsbend;
+                     if (span.specBlue < 0)
+                        span.specBlue = 0;
+                  }
+               }
+#endif
+#ifdef INTERP_INDEX
+               if (span.index < 0)  span.index = 0;
+#endif
+
+               /* This is where we actually generate fragments */
+               if (span.count > 0) {
+                  RENDER_SPAN( span );
+               }
+
+               /*
+                * Advance to the next scan line.  Compute the
+                * new edge coordinates, and adjust the
+                * pixel-center x coordinate so that it stays
+                * on or inside the major edge.
+                */
+               span.y++;
+               lines--;
+
+               fxLeftEdge += fdxLeftEdge;
+               fxRightEdge += fdxRightEdge;
+
+
+               fError += fdError;
+               if (fError >= 0) {
+                  fError -= FIXED_ONE;
+#ifdef PIXEL_ADDRESS
+                  pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowOuter);
+#endif
+#ifdef INTERP_Z
+#  ifdef DEPTH_TYPE
+                  zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowOuter);
+#  endif
+                  fz += fdzOuter;
+#endif
+#ifdef INTERP_FOG
+                  fogLeft += dfogOuter;
+#endif
+#if defined(INTERP_RGB) || defined(INTERP_FLOAT_RGBA)
+                  fr += fdrOuter;
+                  fg += fdgOuter;
+                  fb += fdbOuter;
+#endif
+#if defined(INTERP_ALPHA) || defined(INTERP_FLOAT_RGBA)
+                  fa += fdaOuter;
+#endif
+#if defined(INTERP_SPEC) || defined(INTERP_FLOAT_SPEC)
+                  fsr += fdsrOuter;
+                  fsg += fdsgOuter;
+                  fsb += fdsbOuter;
+#endif
+#ifdef INTERP_INDEX
+                  fi += fdiOuter;
+#endif
+#ifdef INTERP_INT_TEX
+                  fs += fdsOuter;
+                  ft += fdtOuter;
+#endif
+#ifdef INTERP_TEX
+                  sLeft += dsOuter;
+                  tLeft += dtOuter;
+                  uLeft += duOuter;
+                  vLeft += dvOuter;
+#endif
+#ifdef INTERP_MULTITEX
+                  {
+                     GLuint u;
+                     for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+                        if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                           sLeft[u] += dsOuter[u];
+                           tLeft[u] += dtOuter[u];
+                           uLeft[u] += duOuter[u];
+                           vLeft[u] += dvOuter[u];
+                        }
+                     }
+                  }
+#endif
+               }
+               else {
+#ifdef PIXEL_ADDRESS
+                  pRow = (PIXEL_TYPE *) ((GLubyte *) pRow + dPRowInner);
+#endif
+#ifdef INTERP_Z
+#  ifdef DEPTH_TYPE
+                  zRow = (DEPTH_TYPE *) ((GLubyte *) zRow + dZRowInner);
+#  endif
+                  fz += fdzInner;
+#endif
+#ifdef INTERP_FOG
+                  fogLeft += dfogInner;
+#endif
+#if defined(INTERP_RGB) || defined(INTERP_FLOAT_RGBA)
+                  fr += fdrInner;
+                  fg += fdgInner;
+                  fb += fdbInner;
+#endif
+#if defined(INTERP_ALPHA) || defined(INTERP_FLOAT_RGBA)
+                  fa += fdaInner;
+#endif
+#if defined(INTERP_SPEC) || defined(INTERP_FLOAT_SPEC)
+                  fsr += fdsrInner;
+                  fsg += fdsgInner;
+                  fsb += fdsbInner;
+#endif
+#ifdef INTERP_INDEX
+                  fi += fdiInner;
+#endif
+#ifdef INTERP_INT_TEX
+                  fs += fdsInner;
+                  ft += fdtInner;
+#endif
+#ifdef INTERP_TEX
+                  sLeft += dsInner;
+                  tLeft += dtInner;
+                  uLeft += duInner;
+                  vLeft += dvInner;
+#endif
+#ifdef INTERP_MULTITEX
+                  {
+                     GLuint u;
+                     for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
+                        if (ctx->Texture.Unit[u]._ReallyEnabled) {
+                           sLeft[u] += dsInner[u];
+                           tLeft[u] += dtInner[u];
+                           uLeft[u] += duInner[u];
+                           vLeft[u] += dvInner[u];
+                        }
+                     }
+                  }
+#endif
+               }
+            } /*while lines>0*/
+
+         } /* for subTriangle */
+
+      }
+#ifdef CLEANUP_CODE
+      CLEANUP_CODE
+#endif
+   }
+}
+
+#undef SETUP_CODE
+#undef CLEANUP_CODE
+#undef RENDER_SPAN
+
+#undef PIXEL_TYPE
+#undef BYTES_PER_ROW
+#undef PIXEL_ADDRESS
+
+#undef INTERP_Z
+#undef INTERP_FOG
+#undef INTERP_RGB
+#undef INTERP_ALPHA
+#undef INTERP_SPEC
+#undef INTERP_INDEX
+#undef INTERP_INT_TEX
+#undef INTERP_TEX
+#undef INTERP_MULTITEX
+#undef INTERP_LAMBDA
+#undef INTERP_FLOAT_RGBA
+#undef INTERP_FLOAT_SPEC
+
+#undef S_SCALE
+#undef T_SCALE
+
+#undef FixedToDepth
+
+#undef DO_OCCLUSION_TEST
Index: xc/extras/Mesa/src/swrast/s_zoom.c
diff -u /dev/null xc/extras/Mesa/src/swrast/s_zoom.c:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast/s_zoom.c	Mon Dec 16 11:18:41 2002
@@ -0,0 +1,456 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "glheader.h"
+#include "macros.h"
+
+#include "s_context.h"
+#include "s_span.h"
+#include "s_stencil.h"
+#include "s_zoom.h"
+
+
+
+/*
+ * Write a span of pixels to the frame buffer while applying a pixel zoom.
+ * This is only used by glDrawPixels and glCopyPixels.
+ * Input:  n - number of pixels in input row
+ *         x, y - destination of the span
+ *         z - depth values for the span
+ *         red, green, blue, alpha - array of colors
+ *         y0 - location of first row in the image we're drawing.
+ */
+void
+_mesa_write_zoomed_rgba_span( GLcontext *ctx,
+                              GLuint n, GLint x, GLint y, const GLdepth z[],
+                              const GLfloat *fog,
+                              CONST GLchan rgba[][4], GLint y0 )
+{
+   GLint m;
+   GLint r0, r1, row, r;
+   GLint i, j, skipcol;
+   GLchan zrgba[MAX_WIDTH][4];  /* zoomed pixel colors */
+   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
+   GLfloat zfog[MAX_WIDTH];  /* zoomed fog values */
+   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+   const GLuint *srcRGBA32 = (const GLuint *) rgba;
+   GLuint *dstRGBA32 = (GLuint *) zrgba;
+
+   /* compute width of output row */
+   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+   if (m==0) {
+      return;
+   }
+   if (ctx->Pixel.ZoomX<0.0) {
+      /* adjust x coordinate for left/right mirroring */
+      x = x - m;
+   }
+
+   /* compute which rows to draw */
+   row = y-y0;
+   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+   if (r0==r1) {
+      return;
+   }
+   else if (r1<r0) {
+      GLint rtmp = r1;
+      r1 = r0;
+      r0 = rtmp;
+   }
+
+   /* return early if r0...r1 is above or below window */
+   if (r0<0 && r1<0) {
+      /* below window */
+      return;
+   }
+   if (r0 >= (GLint) ctx->DrawBuffer->Height &&
+       r1 >= (GLint) ctx->DrawBuffer->Height) {
+      /* above window */
+      return;
+   }
+
+   /* check if left edge is outside window */
+   skipcol = 0;
+   if (x<0) {
+      skipcol = -x;
+      m += x;
+   }
+   /* make sure span isn't too long or short */
+   if (m>maxwidth) {
+      m = maxwidth;
+   }
+   else if (m<=0) {
+      return;
+   }
+
+   assert( m <= MAX_WIDTH );
+
+   /* zoom the span horizontally */
+   if (ctx->Pixel.ZoomX==-1.0F) {
+      /* n==m */
+      for (j=0;j<m;j++) {
+         i = n - (j+skipcol) - 1;
+         dstRGBA32[j] = srcRGBA32[i];
+         zdepth[j] = z[i];
+      }
+      if (fog && ctx->Fog.Enabled) {
+	 for (j=0;j<m;j++) {
+	    i = n - (j+skipcol) - 1;
+	    zfog[j] = fog[i];
+	 }
+      }
+   }
+   else {
+      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+      for (j=0;j<m;j++) {
+         i = (GLint) ((j+skipcol) * xscale);
+         if (i<0)  i = n + i - 1;
+         dstRGBA32[j] = srcRGBA32[i];
+         zdepth[j] = z[i];
+      }
+      if (fog && ctx->Fog.Enabled) {
+	 for (j=0;j<m;j++) {
+	    i = (GLint) ((j+skipcol) * xscale);
+	    if (i<0)  i = n + i - 1;
+	    zfog[j] = fog[i];
+	 }
+      }
+   }
+
+   /* write the span */
+   for (r=r0; r<r1; r++) {
+      _mesa_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
+			  (fog ? zfog : 0), zrgba, NULL, GL_BITMAP );
+   }
+}
+
+
+
+void
+_mesa_write_zoomed_rgb_span( GLcontext *ctx,
+                             GLuint n, GLint x, GLint y, const GLdepth z[],
+                             const GLfloat *fog,
+                             CONST GLchan rgb[][3], GLint y0 )
+{
+   GLint m;
+   GLint r0, r1, row, r;
+   GLint i, j, skipcol;
+   GLchan zrgba[MAX_WIDTH][4];  /* zoomed pixel colors */
+   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
+   GLfloat zfog[MAX_WIDTH];  /* zoomed fog values */
+   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+
+   /* compute width of output row */
+   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+   if (m==0) {
+      return;
+   }
+   if (ctx->Pixel.ZoomX<0.0) {
+      /* adjust x coordinate for left/right mirroring */
+      x = x - m;
+   }
+
+   /* compute which rows to draw */
+   row = y-y0;
+   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+   if (r0==r1) {
+      return;
+   }
+   else if (r1<r0) {
+      GLint rtmp = r1;
+      r1 = r0;
+      r0 = rtmp;
+   }
+
+   /* return early if r0...r1 is above or below window */
+   if (r0<0 && r1<0) {
+      /* below window */
+      return;
+   }
+   if (r0 >= (GLint) ctx->DrawBuffer->Height &&
+       r1 >= (GLint) ctx->DrawBuffer->Height) {
+      /* above window */
+      return;
+   }
+
+   /* check if left edge is outside window */
+   skipcol = 0;
+   if (x<0) {
+      skipcol = -x;
+      m += x;
+   }
+   /* make sure span isn't too long or short */
+   if (m>maxwidth) {
+      m = maxwidth;
+   }
+   else if (m<=0) {
+      return;
+   }
+
+   assert( m <= MAX_WIDTH );
+
+   /* zoom the span horizontally */
+   if (ctx->Pixel.ZoomX==-1.0F) {
+      /* n==m */
+      for (j=0;j<m;j++) {
+         i = n - (j+skipcol) - 1;
+         zrgba[j][0] = rgb[i][0];
+         zrgba[j][1] = rgb[i][1];
+         zrgba[j][2] = rgb[i][2];
+         zrgba[j][3] = CHAN_MAX;
+         zdepth[j] = z[i];
+      }
+      if (fog && ctx->Fog.Enabled) {
+	 for (j=0;j<m;j++) {
+	    i = n - (j+skipcol) - 1;
+	    zfog[j] = fog[i];
+	 }
+      }
+   }
+   else {
+      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+      for (j=0;j<m;j++) {
+         i = (GLint) ((j+skipcol) * xscale);
+         if (i<0)  i = n + i - 1;
+         zrgba[j][0] = rgb[i][0];
+         zrgba[j][1] = rgb[i][1];
+         zrgba[j][2] = rgb[i][2];
+         zrgba[j][3] = CHAN_MAX;
+         zdepth[j] = z[i];
+      }
+      if (fog && ctx->Fog.Enabled) {
+	 for (j=0;j<m;j++) {
+	    i = (GLint) ((j+skipcol) * xscale);
+	    if (i<0)  i = n + i - 1;
+	    zfog[j] = fog[i];
+	 }
+      }
+   }
+
+   /* write the span */
+   for (r=r0; r<r1; r++) {
+      _mesa_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
+			  (fog ? zfog : 0), zrgba, NULL, GL_BITMAP );
+   }
+}
+
+
+
+/*
+ * As above, but write CI pixels.
+ */
+void
+_mesa_write_zoomed_index_span( GLcontext *ctx,
+                               GLuint n, GLint x, GLint y, const GLdepth z[],
+                               const GLfloat *fog,
+                               const GLuint indexes[], GLint y0 )
+{
+   GLint m;
+   GLint r0, r1, row, r;
+   GLint i, j, skipcol;
+   GLuint zindexes[MAX_WIDTH];  /* zoomed color indexes */
+   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
+   GLfloat zfog[MAX_WIDTH];  /* zoomed fog values */
+   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+
+   /* compute width of output row */
+   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+   if (m==0) {
+      return;
+   }
+   if (ctx->Pixel.ZoomX<0.0) {
+      /* adjust x coordinate for left/right mirroring */
+      x = x - m;
+   }
+
+   /* compute which rows to draw */
+   row = y-y0;
+   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+   if (r0==r1) {
+      return;
+   }
+   else if (r1<r0) {
+      GLint rtmp = r1;
+      r1 = r0;
+      r0 = rtmp;
+   }
+
+   /* return early if r0...r1 is above or below window */
+   if (r0<0 && r1<0) {
+      /* below window */
+      return;
+   }
+   if (r0 >= (GLint) ctx->DrawBuffer->Height &&
+       r1 >= (GLint) ctx->DrawBuffer->Height) {
+      /* above window */
+      return;
+   }
+
+   /* check if left edge is outside window */
+   skipcol = 0;
+   if (x<0) {
+      skipcol = -x;
+      m += x;
+   }
+   /* make sure span isn't too long or short */
+   if (m>maxwidth) {
+      m = maxwidth;
+   }
+   else if (m<=0) {
+      return;
+   }
+
+   assert( m <= MAX_WIDTH );
+
+   /* zoom the span horizontally */
+   if (ctx->Pixel.ZoomX==-1.0F) {
+      /* n==m */
+      for (j=0;j<m;j++) {
+         i = n - (j+skipcol) - 1;
+         zindexes[j] = indexes[i];
+         zdepth[j]   = z[i];
+      }
+      if (fog && ctx->Fog.Enabled) {
+	 for (j=0;j<m;j++) {
+	    i = n - (j+skipcol) - 1;
+	    zfog[j] = fog[i];
+	 }
+      }
+   }
+   else {
+      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+      for (j=0;j<m;j++) {
+         i = (GLint) ((j+skipcol) * xscale);
+         if (i<0)  i = n + i - 1;
+         zindexes[j] = indexes[i];
+         zdepth[j] = z[i];
+      }
+      if (fog && ctx->Fog.Enabled) {
+	 for (j=0;j<m;j++) {
+	    i = (GLint) ((j+skipcol) * xscale);
+	    if (i<0)  i = n + i - 1;
+	    zfog[j] = fog[i];
+	 }
+      }
+   }
+
+   /* write the span */
+   for (r=r0; r<r1; r++) {
+      _mesa_write_index_span( ctx, m, x+skipcol, r, zdepth,
+                              (fog ? zfog : 0), zindexes, NULL, GL_BITMAP );
+   }
+}
+
+
+
+/*
+ * As above, but write stencil values.
+ */
+void
+_mesa_write_zoomed_stencil_span( GLcontext *ctx,
+                                 GLuint n, GLint x, GLint y,
+                                 const GLstencil stencil[], GLint y0 )
+{
+   GLint m;
+   GLint r0, r1, row, r;
+   GLint i, j, skipcol;
+   GLstencil zstencil[MAX_WIDTH];  /* zoomed stencil values */
+   GLint maxwidth = MIN2( ctx->DrawBuffer->Width, MAX_WIDTH );
+
+   /* compute width of output row */
+   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
+   if (m==0) {
+      return;
+   }
+   if (ctx->Pixel.ZoomX<0.0) {
+      /* adjust x coordinate for left/right mirroring */
+      x = x - m;
+   }
+
+   /* compute which rows to draw */
+   row = y-y0;
+   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
+   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
+   if (r0==r1) {
+      return;
+   }
+   else if (r1<r0) {
+      GLint rtmp = r1;
+      r1 = r0;
+      r0 = rtmp;
+   }
+
+   /* return early if r0...r1 is above or below window */
+   if (r0<0 && r1<0) {
+      /* below window */
+      return;
+   }
+   if (r0 >= (GLint) ctx->DrawBuffer->Height &&
+       r1 >= (GLint) ctx->DrawBuffer->Height) {
+      /* above window */
+      return;
+   }
+
+   /* check if left edge is outside window */
+   skipcol = 0;
+   if (x<0) {
+      skipcol = -x;
+      m += x;
+   }
+   /* make sure span isn't too long or short */
+   if (m>maxwidth) {
+      m = maxwidth;
+   }
+   else if (m<=0) {
+      return;
+   }
+
+   assert( m <= MAX_WIDTH );
+
+   /* zoom the span horizontally */
+   if (ctx->Pixel.ZoomX==-1.0F) {
+      /* n==m */
+      for (j=0;j<m;j++) {
+         i = n - (j+skipcol) - 1;
+         zstencil[j] = stencil[i];
+      }
+   }
+   else {
+      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
+      for (j=0;j<m;j++) {
+         i = (GLint) ((j+skipcol) * xscale);
+         if (i<0)  i = n + i - 1;
+         zstencil[j] = stencil[i];
+      }
+   }
+
+   /* write the span */
+   for (r=r0; r<r1; r++) {
+      _mesa_write_stencil_span( ctx, m, x+skipcol, r, zstencil );
+   }
+}
Index: xc/extras/Mesa/src/swrast/s_zoom.h
diff -u /dev/null xc/extras/Mesa/src/swrast/s_zoom.h:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast/s_zoom.h	Mon Dec 16 11:18:41 2002
@@ -0,0 +1,61 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef S_ZOOM_H
+#define S_ZOOM_H
+
+
+#include "mtypes.h"
+
+
+extern void
+_mesa_write_zoomed_rgba_span( GLcontext *ctx,
+                              GLuint n, GLint x, GLint y, const GLdepth z[],
+                              const GLfloat *fog,
+                              CONST GLchan rgba[][4], GLint y0 );
+
+
+extern void
+_mesa_write_zoomed_rgb_span( GLcontext *ctx,
+                             GLuint n, GLint x, GLint y, const GLdepth z[],
+                             const GLfloat *fog,
+                             CONST GLchan rgb[][3], GLint y0 );
+
+
+extern void
+_mesa_write_zoomed_index_span( GLcontext *ctx,
+                               GLuint n, GLint x, GLint y, const GLdepth z[],
+                               const GLfloat *fog,
+                               const GLuint indexes[], GLint y0 );
+
+
+extern void
+_mesa_write_zoomed_stencil_span( GLcontext *ctx,
+                                 GLuint n, GLint x, GLint y,
+                                 const GLstencil stencil[], GLint y0 );
+
+
+#endif
Index: xc/extras/Mesa/src/swrast/swrast.h
diff -u /dev/null xc/extras/Mesa/src/swrast/swrast.h:1.1.1.3
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast/swrast.h	Tue Oct 29 12:32:21 2002
@@ -0,0 +1,429 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef SWRAST_H
+#define SWRAST_H
+
+#include "mtypes.h"
+
+
+
+/* The software rasterizer now uses this format for vertices.  Thus a
+ * 'RasterSetup' stage or other translation is required between the
+ * tnl module and the swrast rasterization functions.  This serves to
+ * isolate the swrast module from the internals of the tnl module, and
+ * improve its usefulness as a fallback mechanism for hardware
+ * drivers.
+ *
+ * Full software drivers:
+ *   - Register the rastersetup and triangle functions from
+ *     utils/software_helper.
+ *   - On statechange, update the rasterization pointers in that module.
+ *
+ * Rasterization hardware drivers:
+ *   - Keep native rastersetup.
+ *   - Implement native twoside,offset and unfilled triangle setup.
+ *   - Implement a translator from native vertices to swrast vertices.
+ *   - On partial fallback (mix of accelerated and unaccelerated
+ *   prims), call a pass-through function which translates native
+ *   vertices to SWvertices and calls the appropriate swrast function.
+ *   - On total fallback (vertex format insufficient for state or all
+ *     primitives unaccelerated), hook in swrast_setup instead.
+ */
+typedef struct {
+   GLfloat win[4];
+   GLfloat texcoord[MAX_TEXTURE_UNITS][4];
+   GLchan color[4];
+   GLchan specular[4];
+   GLfloat fog;
+   GLuint index;
+   GLfloat pointSize;
+} SWvertex;
+
+
+struct swrast_device_driver;
+
+
+/* These are the public-access functions exported from swrast.
+ */
+extern void
+_swrast_alloc_buffers( GLframebuffer *buffer );
+
+extern GLboolean
+_swrast_CreateContext( GLcontext *ctx );
+
+extern void
+_swrast_DestroyContext( GLcontext *ctx );
+
+/* Get a (non-const) reference to the device driver struct for swrast.
+ */
+extern struct swrast_device_driver *
+_swrast_GetDeviceDriverReference( GLcontext *ctx );
+
+extern void
+_swrast_Bitmap( GLcontext *ctx,
+		GLint px, GLint py,
+		GLsizei width, GLsizei height,
+		const struct gl_pixelstore_attrib *unpack,
+		const GLubyte *bitmap );
+
+extern void
+_swrast_CopyPixels( GLcontext *ctx,
+		    GLint srcx, GLint srcy,
+		    GLint destx, GLint desty,
+		    GLsizei width, GLsizei height,
+		    GLenum type );
+
+extern void
+_swrast_DrawPixels( GLcontext *ctx,
+		    GLint x, GLint y,
+		    GLsizei width, GLsizei height,
+		    GLenum format, GLenum type,
+		    const struct gl_pixelstore_attrib *unpack,
+		    const GLvoid *pixels );
+
+extern void
+_swrast_ReadPixels( GLcontext *ctx,
+		    GLint x, GLint y, GLsizei width, GLsizei height,
+		    GLenum format, GLenum type,
+		    const struct gl_pixelstore_attrib *unpack,
+		    GLvoid *pixels );
+
+extern void
+_swrast_Clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
+	       GLint x, GLint y, GLint width, GLint height );
+
+extern void
+_swrast_Accum( GLcontext *ctx, GLenum op,
+	       GLfloat value, GLint xpos, GLint ypos,
+	       GLint width, GLint height );
+
+
+/* Reset the stipple counter
+ */
+extern void
+_swrast_ResetLineStipple( GLcontext *ctx );
+
+/* These will always render the correct point/line/triangle for the
+ * current state.
+ *
+ * For flatshaded primitives, the provoking vertex is the final one.
+ */
+extern void
+_swrast_Point( GLcontext *ctx, const SWvertex *v );
+
+extern void
+_swrast_Line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 );
+
+extern void
+_swrast_Triangle( GLcontext *ctx, const SWvertex *v0,
+                  const SWvertex *v1, const SWvertex *v2 );
+
+extern void
+_swrast_Quad( GLcontext *ctx,
+              const SWvertex *v0, const SWvertex *v1,
+	      const SWvertex *v2,  const SWvertex *v3);
+
+extern void
+_swrast_flush( GLcontext *ctx );
+
+extern void
+_swrast_render_start( GLcontext *ctx );
+
+extern void
+_swrast_render_finish( GLcontext *ctx );
+
+/* Tell the software rasterizer about core state changes.
+ */
+extern void
+_swrast_InvalidateState( GLcontext *ctx, GLuint new_state );
+
+/* Configure software rasterizer to match hardware rasterizer characteristics:
+ */
+extern void
+_swrast_allow_vertex_fog( GLcontext *ctx, GLboolean value );
+
+extern void
+_swrast_allow_pixel_fog( GLcontext *ctx, GLboolean value );
+
+/* Debug:
+ */
+extern void
+_swrast_print_vertex( GLcontext *ctx, const SWvertex *v );
+
+
+/*
+ * Imaging fallbacks (a better solution should be found, perhaps
+ * moving all the imaging fallback code to a new module) 
+ */
+void
+_swrast_CopyConvolutionFilter2D(GLcontext *ctx, GLenum target, 
+				GLenum internalFormat, 
+				GLint x, GLint y, GLsizei width, 
+				GLsizei height);
+void
+_swrast_CopyConvolutionFilter1D(GLcontext *ctx, GLenum target, 
+				GLenum internalFormat, 
+				GLint x, GLint y, GLsizei width);
+void
+_swrast_CopyColorSubTable( GLcontext *ctx,GLenum target, GLsizei start,
+			   GLint x, GLint y, GLsizei width);
+void
+_swrast_CopyColorTable( GLcontext *ctx, 
+			GLenum target, GLenum internalformat,
+			GLint x, GLint y, GLsizei width);
+
+
+/*
+ * Texture fallbacks, Brian Paul.  Could also live in a new module
+ * with the rest of the texture store fallbacks?
+ */
+extern void
+_swrast_copy_teximage1d(GLcontext *ctx, GLenum target, GLint level,
+                      GLenum internalFormat,
+                      GLint x, GLint y, GLsizei width, GLint border);
+
+extern void
+_swrast_copy_teximage2d(GLcontext *ctx, GLenum target, GLint level,
+                      GLenum internalFormat,
+                      GLint x, GLint y, GLsizei width, GLsizei height,
+                      GLint border);
+
+
+extern void
+_swrast_copy_texsubimage1d(GLcontext *ctx, GLenum target, GLint level,
+                         GLint xoffset, GLint x, GLint y, GLsizei width);
+
+extern void
+_swrast_copy_texsubimage2d(GLcontext *ctx,
+                         GLenum target, GLint level,
+                         GLint xoffset, GLint yoffset,
+                         GLint x, GLint y, GLsizei width, GLsizei height);
+
+extern void
+_swrast_copy_texsubimage3d(GLcontext *ctx,
+                         GLenum target, GLint level,
+                         GLint xoffset, GLint yoffset, GLint zoffset,
+                         GLint x, GLint y, GLsizei width, GLsizei height);
+
+
+
+/* The driver interface for the software rasterizer.  Unless otherwise
+ * noted, all functions are mandatory.  
+ */
+struct swrast_device_driver {
+
+   void (*SetReadBuffer)( GLcontext *ctx, GLframebuffer *colorBuffer,
+                          GLenum buffer );
+   /*
+    * Specifies the current buffer for span/pixel reading.
+    * colorBuffer will be one of:
+    *    GL_FRONT_LEFT - this buffer always exists
+    *    GL_BACK_LEFT - when double buffering
+    *    GL_FRONT_RIGHT - when using stereo
+    *    GL_BACK_RIGHT - when using stereo and double buffering
+    */
+
+
+   /***
+    *** Functions for synchronizing access to the framebuffer:
+    ***/
+
+   void (*SpanRenderStart)(GLcontext *ctx);
+   void (*SpanRenderFinish)(GLcontext *ctx);
+   /* OPTIONAL.
+    *
+    * Called before and after all rendering operations, including DrawPixels,
+    * ReadPixels, Bitmap, span functions, and CopyTexImage, etc commands.
+    * These are a suitable place for grabbing/releasing hardware locks.
+    *
+    * NOTE: The swrast triangle/line/point routines *DO NOT* call
+    * these functions.  Locking in that case must be organized by the
+    * driver by other mechanisms.
+    */
+
+   /***
+    *** Functions for writing pixels to the frame buffer:
+    ***/
+
+   void (*WriteRGBASpan)( const GLcontext *ctx,
+                          GLuint n, GLint x, GLint y,
+                          CONST GLchan rgba[][4], const GLubyte mask[] );
+   void (*WriteRGBSpan)( const GLcontext *ctx,
+                         GLuint n, GLint x, GLint y,
+                         CONST GLchan rgb[][3], const GLubyte mask[] );
+   /* Write a horizontal run of RGBA or RGB pixels.
+    * If mask is NULL, draw all pixels.
+    * If mask is not null, only draw pixel [i] when mask [i] is true.
+    */
+
+   void (*WriteMonoRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                              const GLchan color[4], const GLubyte mask[] );
+   /* Write a horizontal run of RGBA pixels all with the same color.
+    */
+
+   void (*WriteRGBAPixels)( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            CONST GLchan rgba[][4], const GLubyte mask[] );
+   /* Write array of RGBA pixels at random locations.
+    */
+
+   void (*WriteMonoRGBAPixels)( const GLcontext *ctx,
+                                GLuint n, const GLint x[], const GLint y[],
+                                const GLchan color[4], const GLubyte mask[] );
+   /* Write an array of mono-RGBA pixels at random locations.
+    */
+
+   void (*WriteCI32Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLuint index[], const GLubyte mask[] );
+   void (*WriteCI8Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                         const GLubyte index[], const GLubyte mask[] );
+   /* Write a horizontal run of CI pixels.  One function is for 32bpp
+    * indexes and the other for 8bpp pixels (the common case).  You mus
+    * implement both for color index mode.
+    */
+
+   void (*WriteMonoCISpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            GLuint colorIndex, const GLubyte mask[] );
+   /* Write a horizontal run of color index pixels using the color index
+    * last specified by the Index() function.
+    */
+
+   void (*WriteCI32Pixels)( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLuint index[], const GLubyte mask[] );
+   /*
+    * Write a random array of CI pixels.
+    */
+
+   void (*WriteMonoCIPixels)( const GLcontext *ctx,
+                              GLuint n, const GLint x[], const GLint y[],
+                              GLuint colorIndex, const GLubyte mask[] );
+   /* Write a random array of color index pixels using the color index
+    * last specified by the Index() function.
+    */
+
+
+   /***
+    *** Functions to read pixels from frame buffer:
+    ***/
+
+   void (*ReadCI32Span)( const GLcontext *ctx,
+                         GLuint n, GLint x, GLint y, GLuint index[] );
+   /* Read a horizontal run of color index pixels.
+    */
+
+   void (*ReadRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                         GLchan rgba[][4] );
+   /* Read a horizontal run of RGBA pixels.
+    */
+
+   void (*ReadCI32Pixels)( const GLcontext *ctx,
+                           GLuint n, const GLint x[], const GLint y[],
+                           GLuint indx[], const GLubyte mask[] );
+   /* Read a random array of CI pixels.
+    */
+
+   void (*ReadRGBAPixels)( const GLcontext *ctx,
+                           GLuint n, const GLint x[], const GLint y[],
+                           GLchan rgba[][4], const GLubyte mask[] );
+   /* Read a random array of RGBA pixels.
+    */
+
+
+
+   /***
+    *** For supporting hardware Z buffers:
+    *** Either ALL or NONE of these functions must be implemented!
+    *** NOTE that Each depth value is a 32-bit GLuint.  If the depth
+    *** buffer is less than 32 bits deep then the extra upperbits are zero.
+    ***/
+
+   void (*WriteDepthSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                           const GLdepth depth[], const GLubyte mask[] );
+   /* Write a horizontal span of values into the depth buffer.  Only write
+    * depth[i] value if mask[i] is nonzero.
+    */
+
+   void (*ReadDepthSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          GLdepth depth[] );
+   /* Read a horizontal span of values from the depth buffer.
+    */
+
+
+   void (*WriteDepthPixels)( GLcontext *ctx, GLuint n,
+                             const GLint x[], const GLint y[],
+                             const GLdepth depth[], const GLubyte mask[] );
+   /* Write an array of randomly positioned depth values into the
+    * depth buffer.  Only write depth[i] value if mask[i] is nonzero.
+    */
+
+   void (*ReadDepthPixels)( GLcontext *ctx, GLuint n,
+                            const GLint x[], const GLint y[],
+                            GLdepth depth[] );
+   /* Read an array of randomly positioned depth values from the depth buffer.
+    */
+
+
+
+   /***
+    *** For supporting hardware stencil buffers:
+    *** Either ALL or NONE of these functions must be implemented!
+    ***/
+
+   void (*WriteStencilSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                             const GLstencil stencil[], const GLubyte mask[] );
+   /* Write a horizontal span of stencil values into the stencil buffer.
+    * If mask is NULL, write all stencil values.
+    * Else, only write stencil[i] if mask[i] is non-zero.
+    */
+
+   void (*ReadStencilSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            GLstencil stencil[] );
+   /* Read a horizontal span of stencil values from the stencil buffer.
+    */
+
+   void (*WriteStencilPixels)( GLcontext *ctx, GLuint n,
+                               const GLint x[], const GLint y[],
+                               const GLstencil stencil[],
+                               const GLubyte mask[] );
+   /* Write an array of stencil values into the stencil buffer.
+    * If mask is NULL, write all stencil values.
+    * Else, only write stencil[i] if mask[i] is non-zero.
+    */
+
+   void (*ReadStencilPixels)( GLcontext *ctx, GLuint n,
+                              const GLint x[], const GLint y[],
+                              GLstencil stencil[] );
+   /* Read an array of stencil values from the stencil buffer.
+    */
+};
+
+
+
+#endif
Index: xc/extras/Mesa/src/swrast_setup/NOTES
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/NOTES:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/NOTES	Fri Feb 22 12:14:13 2002
@@ -0,0 +1,65 @@
+INTRODUCTION
+
+A helper module which provides glue to bind the software rasterizer to
+the software t&l module.  The main task of this module is to build
+swrast vertices from the t&l vertex_buffer structs, and to use them to
+perform triangle setup functions not implemented in the software
+rasterizer.
+
+The module implements a full set of functions to plug into the
+t_vb_render.c driver interface (tnl->Driver.Render.*).  
+
+There are strong advantages to decoupling the software rasterizer from
+the t&l module, primarily allowing hardware drivers better control
+over fallbacks, the removal of implicit knowledge about the software
+rasterizer in the t&l module, allowing the two modules to evolve
+independently and allowing either to be substituted with equivalent
+functionality from another codebase.
+
+This module implements triangle/quad setup for offset, unfilled and
+twoside-lit triangles.  The software rasterizer doesn't handle these
+primitives directly.
+
+Hardware rasterization drivers typically use this module in situations
+where no hardware rasterization is possible, ie during total
+fallbacks. 
+
+STATE
+
+To create and destroy the module:
+
+	GLboolean _swsetup_CreateContext( GLcontext *ctx );
+	void _swsetup_DestroyContext( GLcontext *ctx );
+
+The module is not active by default, and must be installed by calling
+_swrast_Wakeup().  This function installs internal swrast_setup
+functions into all the tnl->Driver.Render driver hooks, thus taking
+over the task of rasterization entirely:
+
+        void _swrast_Wakeup( GLcontext *ctx );
+
+   
+This module tracks state changes internally and maintains derived
+values based on the current state.  For this to work, the driver
+ensure the following funciton is called whenever the state changes and
+the swsetup module is 'awake':
+
+	void _swsetup_InvalidateState( GLcontext *ctx, GLuint new_state );
+
+There is no explicit call to put the swsetup module to sleep.  Simply
+install other function pointers into all the tnl->Driver.Render.*
+hooks, and (optionally) cease calling _swsetup_InvalidateState().
+
+DRIVER INTERFACE
+
+The module offers a minimal driver interface:
+
+	 void (*Start)( GLcontext *ctx );
+	 void (*Finish)( GLcontext *ctx );
+	 
+These are called before and after the completion of all swrast drawing
+activity.  As swrast doesn't call callbacks during triangle, line or
+point rasterization, these are necessary to provide locking hooks for
+some drivers.  They may otherwise be left null.
+
+
Index: xc/extras/Mesa/src/swrast_setup/ss_context.c
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_context.c:1.1.1.3
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_context.c	Tue Oct 29 12:32:13 2002
@@ -0,0 +1,157 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "mem.h"
+#include "ss_context.h"
+#include "ss_triangle.h"
+#include "ss_vb.h"
+#include "swrast_setup.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
+
+
+#define _SWSETUP_NEW_VERTS (_NEW_RENDERMODE|	\
+                            _NEW_POLYGON|       \
+                            _NEW_LIGHT|         \
+			    _NEW_TEXTURE|	\
+			    _NEW_COLOR|		\
+			    _NEW_FOG|		\
+			    _NEW_POINT)
+
+#define _SWSETUP_NEW_RENDERINDEX (_NEW_POLYGON|_NEW_LIGHT)
+
+
+GLboolean
+_swsetup_CreateContext( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   SScontext *swsetup = (SScontext *)CALLOC(sizeof(SScontext));
+
+   if (!swsetup)
+      return GL_FALSE;
+
+   swsetup->verts = (SWvertex *) ALIGN_CALLOC( sizeof(SWvertex) * tnl->vb.Size,
+					       32);
+   if (!swsetup->verts) {
+      FREE(swsetup);
+      return GL_FALSE;
+   }
+
+   ctx->swsetup_context = swsetup;
+
+   swsetup->NewState = ~0;
+   _swsetup_vb_init( ctx );
+   _swsetup_trifuncs_init( ctx );
+
+   return GL_TRUE;
+}
+
+void
+_swsetup_DestroyContext( GLcontext *ctx )
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+
+   if (swsetup) {
+      if (swsetup->verts)
+	 ALIGN_FREE(swsetup->verts);
+
+      if (swsetup->ChanSecondaryColor.Ptr) 
+	 ALIGN_FREE(swsetup->ChanSecondaryColor.Ptr);
+
+      if (swsetup->ChanColor.Ptr) 
+	 ALIGN_FREE(swsetup->ChanColor.Ptr);
+
+      FREE(swsetup);
+      ctx->swsetup_context = 0;
+   }
+}
+
+static void
+_swsetup_RenderPrimitive( GLcontext *ctx, GLenum mode )
+{
+   SWSETUP_CONTEXT(ctx)->render_prim = mode;
+}
+
+static void
+_swsetup_RenderStart( GLcontext *ctx )
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+   GLuint new_state = swsetup->NewState;
+
+   if (new_state & _SWSETUP_NEW_RENDERINDEX) {
+      _swsetup_choose_trifuncs( ctx );
+   }
+
+   if (new_state & _SWSETUP_NEW_VERTS) {
+      _swsetup_choose_rastersetup_func( ctx );
+   }
+
+   swsetup->NewState = 0;
+
+   _swrast_render_start( ctx );
+}
+
+static void
+_swsetup_RenderFinish( GLcontext *ctx )
+{
+   _swrast_render_finish( ctx );
+}
+
+void
+_swsetup_InvalidateState( GLcontext *ctx, GLuint new_state )
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+   swsetup->NewState |= new_state;
+}
+
+
+void
+_swsetup_Wakeup( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->Driver.Render.Start = _swsetup_RenderStart;
+   tnl->Driver.Render.Finish = _swsetup_RenderFinish;
+   tnl->Driver.Render.PrimitiveNotify = _swsetup_RenderPrimitive;
+   /* interp */
+   /* copypv */
+   tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon; /* new */
+   tnl->Driver.Render.ClippedLine = _tnl_RenderClippedLine; /* new */
+   /* points */
+   /* line */
+   /* triangle */
+   /* quad */
+   tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
+   tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
+   tnl->Driver.Render.ResetLineStipple = _swrast_ResetLineStipple;
+   /* buildvertices */
+   tnl->Driver.Render.Multipass = 0;
+   _tnl_need_projected_coords( ctx, GL_TRUE );
+   _swsetup_InvalidateState( ctx, ~0 );
+}
Index: xc/extras/Mesa/src/swrast_setup/ss_context.h
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_context.h:1.1.1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_context.h	Tue Oct 29 12:32:13 2002
@@ -0,0 +1,50 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef SS_CONTEXT_H
+#define SS_CONTEXT_H
+
+#include "mtypes.h"
+#include "swrast/swrast.h"
+#include "swrast_setup.h"
+
+typedef struct {
+   GLuint NewState;
+   SWvertex *verts;
+   GLenum render_prim;
+   GLuint SetupIndex;
+
+   /* Temporaries for translating away float colors:
+    */
+   struct gl_client_array ChanColor;
+   struct gl_client_array ChanSecondaryColor;
+} SScontext;
+
+#define SWSETUP_CONTEXT(ctx) ((SScontext *)ctx->swsetup_context)
+
+#endif
Index: xc/extras/Mesa/src/swrast_setup/ss_triangle.c
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_triangle.c:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_triangle.c	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,283 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mtypes.h"
+
+#include "tnl/t_context.h"
+
+#include "ss_triangle.h"
+#include "ss_context.h"
+
+#define SS_RGBA_BIT         0x1
+#define SS_OFFSET_BIT	    0x2
+#define SS_TWOSIDE_BIT	    0x4
+#define SS_UNFILLED_BIT	    0x8
+#define SS_MAX_TRIFUNC      0x10
+
+static triangle_func tri_tab[SS_MAX_TRIFUNC];
+static quad_func     quad_tab[SS_MAX_TRIFUNC];
+
+
+static void _swsetup_render_line_tri( GLcontext *ctx,
+				      GLuint e0, GLuint e1, GLuint e2 )
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLubyte *ef = VB->EdgeFlag;
+   SWvertex *verts = swsetup->verts;
+   SWvertex *v0 = &verts[e0];
+   SWvertex *v1 = &verts[e1];
+   SWvertex *v2 = &verts[e2];
+   GLchan c[2][4];
+   GLchan s[2][4];
+   GLuint i[2];
+
+   if (ctx->_TriangleCaps & DD_FLATSHADE) {
+      COPY_CHAN4(c[0], v0->color);
+      COPY_CHAN4(c[1], v1->color);
+      COPY_CHAN4(s[0], v0->specular);
+      COPY_CHAN4(s[1], v1->specular);
+      i[0] = v0->index;
+      i[1] = v1->index;
+
+      COPY_CHAN4(v0->color, v2->color);
+      COPY_CHAN4(v1->color, v2->color);
+      COPY_CHAN4(v0->specular, v2->specular);
+      COPY_CHAN4(v1->specular, v2->specular);
+      v0->index = v2->index;
+      v1->index = v2->index;
+   }
+
+   if (swsetup->render_prim == GL_POLYGON) {
+      if (ef[e2]) _swrast_Line( ctx, v2, v0 );
+      if (ef[e0]) _swrast_Line( ctx, v0, v1 );
+      if (ef[e1]) _swrast_Line( ctx, v1, v2 );
+   } else {
+      if (ef[e0]) _swrast_Line( ctx, v0, v1 );
+      if (ef[e1]) _swrast_Line( ctx, v1, v2 );
+      if (ef[e2]) _swrast_Line( ctx, v2, v0 );
+   }
+
+   if (ctx->_TriangleCaps & DD_FLATSHADE) {
+      COPY_CHAN4(v0->color, c[0]);
+      COPY_CHAN4(v1->color, c[1]);
+      COPY_CHAN4(v0->specular, s[0]);
+      COPY_CHAN4(v1->specular, s[1]);
+      v0->index = i[0];
+      v1->index = i[1];
+   }
+}
+
+static void _swsetup_render_point_tri( GLcontext *ctx,
+				       GLuint e0, GLuint e1, GLuint e2 )
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLubyte *ef = VB->EdgeFlag;
+   SWvertex *verts = swsetup->verts;
+   SWvertex *v0 = &verts[e0];
+   SWvertex *v1 = &verts[e1];
+   SWvertex *v2 = &verts[e2];
+   GLchan c[2][4];
+   GLchan s[2][4];
+   GLuint i[2];
+
+   if (ctx->_TriangleCaps & DD_FLATSHADE) {
+      COPY_CHAN4(c[0], v0->color);
+      COPY_CHAN4(c[1], v1->color);
+      COPY_CHAN4(s[0], v0->specular);
+      COPY_CHAN4(s[1], v1->specular);
+      i[0] = v0->index;
+      i[1] = v1->index;
+
+      COPY_CHAN4(v0->color, v2->color);
+      COPY_CHAN4(v1->color, v2->color);
+      COPY_CHAN4(v0->specular, v2->specular);
+      COPY_CHAN4(v1->specular, v2->specular);
+      v0->index = v2->index;
+      v1->index = v2->index;
+   }
+
+   if (ef[e0]) _swrast_Point( ctx, v0 );
+   if (ef[e1]) _swrast_Point( ctx, v1 );
+   if (ef[e2]) _swrast_Point( ctx, v2 );
+
+   if (ctx->_TriangleCaps & DD_FLATSHADE) {
+      COPY_CHAN4(v0->color, c[0]);
+      COPY_CHAN4(v1->color, c[1]);
+      COPY_CHAN4(v0->specular, s[0]);
+      COPY_CHAN4(v1->specular, s[1]);
+      v0->index = i[0];
+      v1->index = i[1];
+   }
+}
+
+#define SS_COLOR(a,b) COPY_CHAN4(a,b)
+#define SS_SPEC(a,b) COPY_3V(a,b)
+#define SS_IND(a,b) (a = b)
+
+#define IND (0)
+#define TAG(x) x
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT)
+#define TAG(x) x##_offset
+#include "ss_tritmp.h"
+
+#define IND (SS_TWOSIDE_BIT)
+#define TAG(x) x##_twoside
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_TWOSIDE_BIT)
+#define TAG(x) x##_offset_twoside
+#include "ss_tritmp.h"
+
+#define IND (SS_UNFILLED_BIT)
+#define TAG(x) x##_unfilled
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_UNFILLED_BIT)
+#define TAG(x) x##_offset_unfilled
+#include "ss_tritmp.h"
+
+#define IND (SS_TWOSIDE_BIT|SS_UNFILLED_BIT)
+#define TAG(x) x##_twoside_unfilled
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_TWOSIDE_BIT|SS_UNFILLED_BIT)
+#define TAG(x) x##_offset_twoside_unfilled
+#include "ss_tritmp.h"
+
+#define IND (0|SS_RGBA_BIT)
+#define TAG(x) x##_rgba
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_RGBA_BIT)
+#define TAG(x) x##_offset_rgba
+#include "ss_tritmp.h"
+
+#define IND (SS_TWOSIDE_BIT|SS_RGBA_BIT)
+#define TAG(x) x##_twoside_rgba
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_TWOSIDE_BIT|SS_RGBA_BIT)
+#define TAG(x) x##_offset_twoside_rgba
+#include "ss_tritmp.h"
+
+#define IND (SS_UNFILLED_BIT|SS_RGBA_BIT)
+#define TAG(x) x##_unfilled_rgba
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_UNFILLED_BIT|SS_RGBA_BIT)
+#define TAG(x) x##_offset_unfilled_rgba
+#include "ss_tritmp.h"
+
+#define IND (SS_TWOSIDE_BIT|SS_UNFILLED_BIT|SS_RGBA_BIT)
+#define TAG(x) x##_twoside_unfilled_rgba
+#include "ss_tritmp.h"
+
+#define IND (SS_OFFSET_BIT|SS_TWOSIDE_BIT|SS_UNFILLED_BIT|SS_RGBA_BIT)
+#define TAG(x) x##_offset_twoside_unfilled_rgba
+#include "ss_tritmp.h"
+
+
+void _swsetup_trifuncs_init( GLcontext *ctx )
+{
+   (void) ctx;
+
+   init();
+   init_offset();
+   init_twoside();
+   init_offset_twoside();
+   init_unfilled();
+   init_offset_unfilled();
+   init_twoside_unfilled();
+   init_offset_twoside_unfilled();
+
+   init_rgba();
+   init_offset_rgba();
+   init_twoside_rgba();
+   init_offset_twoside_rgba();
+   init_unfilled_rgba();
+   init_offset_unfilled_rgba();
+   init_twoside_unfilled_rgba();
+   init_offset_twoside_unfilled_rgba();
+}
+
+
+static void swsetup_points( GLcontext *ctx, GLuint first, GLuint last )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+   GLuint i;
+
+   if (VB->Elts) {
+      for (i = first; i < last; i++)
+	 if (VB->ClipMask[VB->Elts[i]] == 0)
+	    _swrast_Point( ctx, &verts[VB->Elts[i]] );
+   }
+   else {
+      for (i = first; i < last; i++)
+	 if (VB->ClipMask[i] == 0)
+	    _swrast_Point( ctx, &verts[i] );
+   }
+}
+
+static void swsetup_line( GLcontext *ctx, GLuint v0, GLuint v1 )
+{
+   SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+   _swrast_Line( ctx, &verts[v0], &verts[v1] );
+}
+
+
+
+void _swsetup_choose_trifuncs( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint ind = 0;
+
+   if (ctx->Polygon._OffsetAny)
+      ind |= SS_OFFSET_BIT;
+
+   if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
+      ind |= SS_TWOSIDE_BIT;
+
+   if (ctx->_TriangleCaps & DD_TRI_UNFILLED)
+      ind |= SS_UNFILLED_BIT;
+
+   if (ctx->Visual.rgbMode)
+      ind |= SS_RGBA_BIT;
+
+   tnl->Driver.Render.Triangle = tri_tab[ind];
+   tnl->Driver.Render.Quad = quad_tab[ind];
+   tnl->Driver.Render.Line = swsetup_line;
+   tnl->Driver.Render.Points = swsetup_points;
+}
Index: xc/extras/Mesa/src/swrast_setup/ss_triangle.h
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_triangle.h:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_triangle.h	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef SS_TRIANGLE_H
+#define SS_TRIANGLE_H
+
+#include "mtypes.h"
+#include "ss_context.h"
+
+
+void _swsetup_trifuncs_init( GLcontext *ctx );
+void _swsetup_choose_trifuncs( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/swrast_setup/ss_tritmp.h
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_tritmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_tritmp.h	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,192 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+static void TAG(triangle)(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2 )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+   SWvertex *v[3];
+   GLfloat z[3];
+   GLfloat offset;
+   GLenum mode = GL_FILL;
+   GLuint facing;
+
+   v[0] = &verts[e0];
+   v[1] = &verts[e1];
+   v[2] = &verts[e2];
+
+
+   if (IND & (SS_TWOSIDE_BIT | SS_OFFSET_BIT | SS_UNFILLED_BIT))
+   {
+      GLfloat ex = v[0]->win[0] - v[2]->win[0];
+      GLfloat ey = v[0]->win[1] - v[2]->win[1];
+      GLfloat fx = v[1]->win[0] - v[2]->win[0];
+      GLfloat fy = v[1]->win[1] - v[2]->win[1];
+      GLfloat cc  = ex*fy - ey*fx;
+
+      if (IND & (SS_TWOSIDE_BIT | SS_UNFILLED_BIT))
+      {
+	 facing = (cc < 0.0) ^ ctx->Polygon._FrontBit;
+
+	 if (IND & SS_UNFILLED_BIT)
+	    mode = facing ? ctx->Polygon.BackMode : ctx->Polygon.FrontMode;
+
+	 if (facing == 1) {
+	    if (IND & SS_TWOSIDE_BIT) {
+	       if (IND & SS_RGBA_BIT) {
+		  GLchan (*vbcolor)[4] = (GLchan (*)[4])VB->ColorPtr[1]->Ptr;
+		  SS_COLOR(v[0]->color, vbcolor[e0]);
+		  SS_COLOR(v[1]->color, vbcolor[e1]);
+		  SS_COLOR(v[2]->color, vbcolor[e2]);
+		  if (VB->SecondaryColorPtr[1]) {
+		     GLchan (*vbspec)[4] = (GLchan (*)[4])VB->SecondaryColorPtr[1]->Ptr;
+		     SS_SPEC(v[0]->specular, vbspec[e0]);
+		     SS_SPEC(v[1]->specular, vbspec[e1]);
+		     SS_SPEC(v[2]->specular, vbspec[e2]);
+		  }
+	       } else {
+		  GLuint *vbindex = VB->IndexPtr[1]->data;
+		  SS_IND(v[0]->index, vbindex[e0]);
+		  SS_IND(v[1]->index, vbindex[e1]);
+		  SS_IND(v[2]->index, vbindex[e2]);
+	       }
+	    }
+	 }
+      }
+
+      if (IND & SS_OFFSET_BIT)
+      {
+	 offset = ctx->Polygon.OffsetUnits;
+	 z[0] = v[0]->win[2];
+	 z[1] = v[1]->win[2];
+	 z[2] = v[2]->win[2];
+	 if (cc * cc > 1e-16) {
+	    GLfloat ez = z[0] - z[2];
+	    GLfloat fz = z[1] - z[2];
+	    GLfloat a = ey*fz - ez*fy;
+	    GLfloat b = ez*fx - ex*fz;
+	    GLfloat ic = 1.0F / cc;
+	    GLfloat ac = a * ic;
+	    GLfloat bc = b * ic;
+	    if (ac < 0.0F) ac = -ac;
+	    if (bc < 0.0F) bc = -bc;
+	    offset += MAX2(ac, bc) * ctx->Polygon.OffsetFactor;
+	 }
+         offset *= ctx->MRD;
+         /*printf("offset %g\n", offset);*/
+      }
+   }
+
+   if (mode == GL_POINT) {
+      if ((IND & SS_OFFSET_BIT) && ctx->Polygon.OffsetPoint) {
+	 v[0]->win[2] += offset;
+	 v[1]->win[2] += offset;
+	 v[2]->win[2] += offset;
+      }
+      _swsetup_render_point_tri( ctx, e0, e1, e2 );
+   } else if (mode == GL_LINE) {
+      if ((IND & SS_OFFSET_BIT) && ctx->Polygon.OffsetLine) {
+	 v[0]->win[2] += offset;
+	 v[1]->win[2] += offset;
+	 v[2]->win[2] += offset;
+      }
+      _swsetup_render_line_tri( ctx, e0, e1, e2 );
+   } else {
+      if ((IND & SS_OFFSET_BIT) && ctx->Polygon.OffsetFill) {
+	 v[0]->win[2] += offset;
+	 v[1]->win[2] += offset;
+	 v[2]->win[2] += offset;
+      }
+      _swrast_Triangle( ctx, v[0], v[1], v[2] );
+   }
+
+   if (IND & SS_OFFSET_BIT) {
+      v[0]->win[2] = z[0];
+      v[1]->win[2] = z[1];
+      v[2]->win[2] = z[2];
+   }
+
+   if (IND & SS_TWOSIDE_BIT) {
+      if (facing == 1) {
+	 if (IND & SS_RGBA_BIT) {
+	    GLchan (*vbcolor)[4] = (GLchan (*)[4])VB->ColorPtr[0]->Ptr;
+	    SS_COLOR(v[0]->color, vbcolor[e0]);
+	    SS_COLOR(v[1]->color, vbcolor[e1]);
+	    SS_COLOR(v[2]->color, vbcolor[e2]);
+	    if (VB->SecondaryColorPtr[0]) {
+	       GLchan (*vbspec)[4] = (GLchan (*)[4])VB->SecondaryColorPtr[0]->Ptr;
+	       SS_SPEC(v[0]->specular, vbspec[e0]);
+	       SS_SPEC(v[1]->specular, vbspec[e1]);
+	       SS_SPEC(v[2]->specular, vbspec[e2]);
+	    }
+	 } else {
+	    GLuint *vbindex = VB->IndexPtr[0]->data;
+	    SS_IND(v[0]->index, vbindex[e0]);
+	    SS_IND(v[1]->index, vbindex[e1]);
+	    SS_IND(v[2]->index, vbindex[e2]);
+	 }
+      }
+   }
+}
+
+
+
+/* Need to fixup edgeflags when decomposing to triangles:
+ */
+static void TAG(quadfunc)( GLcontext *ctx, GLuint v0,
+		       GLuint v1, GLuint v2, GLuint v3 )
+{
+   if (IND & SS_UNFILLED_BIT) {
+      struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+      GLubyte ef1 = VB->EdgeFlag[v1];
+      GLubyte ef3 = VB->EdgeFlag[v3];
+      VB->EdgeFlag[v1] = 0;
+      TAG(triangle)( ctx, v0, v1, v3 );
+      VB->EdgeFlag[v1] = ef1;
+      VB->EdgeFlag[v3] = 0;
+      TAG(triangle)( ctx, v1, v2, v3 );
+      VB->EdgeFlag[v3] = ef3;
+   } else {
+      TAG(triangle)( ctx, v0, v1, v3 );
+      TAG(triangle)( ctx, v1, v2, v3 );
+   }
+}
+
+
+
+
+static void TAG(init)( void )
+{
+   tri_tab[IND] = TAG(triangle);
+   quad_tab[IND] = TAG(quadfunc);
+}
+
+
+#undef IND
+#undef TAG
Index: xc/extras/Mesa/src/swrast_setup/ss_vb.c
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_vb.c:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_vb.c	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,439 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "colormac.h"
+#include "macros.h"
+#include "mem.h"
+
+#include "swrast/swrast.h"
+#include "tnl/t_context.h"
+#include "math/m_vector.h"
+#include "math/m_translate.h"
+
+#include "ss_context.h"
+#include "ss_vb.h"
+
+static void do_import( struct vertex_buffer *VB,
+		       struct gl_client_array *to,
+		       struct gl_client_array *from )
+{
+   GLuint count = VB->Count;
+
+   if (!to->Ptr) {
+      to->Ptr = ALIGN_MALLOC( VB->Size * 4 * sizeof(GLchan), 32 );
+      to->Type = CHAN_TYPE;
+   }
+
+   /* No need to transform the same value 3000 times.
+    */
+   if (!from->StrideB) {
+      to->StrideB = 0;
+      count = 1;
+   }
+   else
+      to->StrideB = 4 * sizeof(GLchan);
+   
+   _math_trans_4chan( (GLchan (*)[4]) to->Ptr,
+		      from->Ptr,
+		      from->StrideB,
+		      from->Type,
+		      from->Size,
+		      0,
+		      count);
+}
+
+static void import_float_colors( GLcontext *ctx )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct gl_client_array *to = &SWSETUP_CONTEXT(ctx)->ChanColor;
+   do_import( VB, to, VB->ColorPtr[0] );
+   VB->ColorPtr[0] = to;
+}
+
+static void import_float_spec_colors( GLcontext *ctx )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct gl_client_array *to = &SWSETUP_CONTEXT(ctx)->ChanSecondaryColor;
+   do_import( VB, to, VB->SecondaryColorPtr[0] );
+   VB->SecondaryColorPtr[0] = to;
+}
+
+
+/* Provides a RasterSetup function which prebuilds vertices for the
+ * software rasterizer.  This is required for the triangle functions
+ * in this module, but not the rest of the swrast module.
+ */
+
+
+#define COLOR         0x1
+#define INDEX         0x2
+#define TEX0          0x4
+#define MULTITEX      0x8
+#define SPEC          0x10
+#define FOG           0x20
+#define POINT         0x40
+#define MAX_SETUPFUNC 0x80
+
+static setup_func setup_tab[MAX_SETUPFUNC];
+static interp_func interp_tab[MAX_SETUPFUNC];
+static copy_pv_func copy_pv_tab[MAX_SETUPFUNC];
+
+
+#define IND (0)
+#define TAG(x) x##_none
+#include "ss_vbtmp.h"
+
+#define IND (COLOR)
+#define TAG(x) x##_color
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|SPEC)
+#define TAG(x) x##_color_spec
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|FOG)
+#define TAG(x) x##_color_fog
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|SPEC|FOG)
+#define TAG(x) x##_color_spec_fog
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0)
+#define TAG(x) x##_color_tex0
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0|SPEC)
+#define TAG(x) x##_color_tex0_spec
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0|FOG)
+#define TAG(x) x##_color_tex0_fog
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0|SPEC|FOG)
+#define TAG(x) x##_color_tex0_spec_fog
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX)
+#define TAG(x) x##_color_multitex
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX|SPEC)
+#define TAG(x) x##_color_multitex_spec
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX|FOG)
+#define TAG(x) x##_color_multitex_fog
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX|SPEC|FOG)
+#define TAG(x) x##_color_multitex_spec_fog
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|POINT)
+#define TAG(x) x##_color_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|SPEC|POINT)
+#define TAG(x) x##_color_spec_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|FOG|POINT)
+#define TAG(x) x##_color_fog_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|SPEC|FOG|POINT)
+#define TAG(x) x##_color_spec_fog_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0|POINT)
+#define TAG(x) x##_color_tex0_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0|SPEC|POINT)
+#define TAG(x) x##_color_tex0_spec_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0|FOG|POINT)
+#define TAG(x) x##_color_tex0_fog_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|TEX0|SPEC|FOG|POINT)
+#define TAG(x) x##_color_tex0_spec_fog_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX|POINT)
+#define TAG(x) x##_color_multitex_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX|SPEC|POINT)
+#define TAG(x) x##_color_multitex_spec_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX|FOG|POINT)
+#define TAG(x) x##_color_multitex_fog_point
+#include "ss_vbtmp.h"
+
+#define IND (COLOR|MULTITEX|SPEC|FOG|POINT)
+#define TAG(x) x##_color_multitex_spec_fog_point
+#include "ss_vbtmp.h"
+
+#define IND (INDEX)
+#define TAG(x) x##_index
+#include "ss_vbtmp.h"
+
+#define IND (INDEX|FOG)
+#define TAG(x) x##_index_fog
+#include "ss_vbtmp.h"
+
+#define IND (INDEX|POINT)
+#define TAG(x) x##_index_point
+#include "ss_vbtmp.h"
+
+#define IND (INDEX|FOG|POINT)
+#define TAG(x) x##_index_fog_point
+#include "ss_vbtmp.h"
+
+
+/***********************************************************************
+ *      Additional setup and interp for back color and edgeflag. 
+ ***********************************************************************/
+
+#define GET_COLOR(ptr, idx) (((GLchan (*)[4])((ptr)->Ptr))[idx])
+
+static void interp_extras( GLcontext *ctx,
+			   GLfloat t,
+			   GLuint dst, GLuint out, GLuint in,
+			   GLboolean force_boundary )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+
+   if (VB->ColorPtr[1]) {
+      INTERP_4CHAN( t,
+		 GET_COLOR(VB->ColorPtr[1], dst),
+		 GET_COLOR(VB->ColorPtr[1], out),
+		 GET_COLOR(VB->ColorPtr[1], in) );
+
+      if (VB->SecondaryColorPtr[1]) {
+	 INTERP_3CHAN( t,
+		    GET_COLOR(VB->SecondaryColorPtr[1], dst),
+		    GET_COLOR(VB->SecondaryColorPtr[1], out),
+		    GET_COLOR(VB->SecondaryColorPtr[1], in) );
+      }
+   }
+   else if (VB->IndexPtr[1]) {
+      VB->IndexPtr[1]->data[dst] = (GLuint) (GLint)
+	 LINTERP( t,
+		  (GLfloat) VB->IndexPtr[1]->data[out],
+		  (GLfloat) VB->IndexPtr[1]->data[in] );
+   }
+
+   if (VB->EdgeFlag) {
+      VB->EdgeFlag[dst] = VB->EdgeFlag[out] || force_boundary;
+   }
+
+   interp_tab[SWSETUP_CONTEXT(ctx)->SetupIndex](ctx, t, dst, out, in,
+						force_boundary);
+}
+
+static void copy_pv_extras( GLcontext *ctx, GLuint dst, GLuint src )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+
+   if (VB->ColorPtr[1]) {
+	 COPY_CHAN4( GET_COLOR(VB->ColorPtr[1], dst), 
+		     GET_COLOR(VB->ColorPtr[1], src) );
+	 
+	 if (VB->SecondaryColorPtr[1]) {
+	    COPY_3V( GET_COLOR(VB->SecondaryColorPtr[1], dst), 
+		     GET_COLOR(VB->SecondaryColorPtr[1], src) );
+	 }
+   }
+   else if (VB->IndexPtr[1]) {
+      VB->IndexPtr[1]->data[dst] = VB->IndexPtr[1]->data[src];
+   }
+
+   copy_pv_tab[SWSETUP_CONTEXT(ctx)->SetupIndex](ctx, dst, src);
+}
+
+
+
+
+/***********************************************************************
+ *                         Initialization 
+ ***********************************************************************/
+
+
+
+
+
+static void
+emit_invalid( GLcontext *ctx, GLuint start, GLuint end, GLuint newinputs )
+{
+   fprintf(stderr, "swrast_setup: invalid setup function\n");
+   (void) (ctx && start && end && newinputs);
+}
+
+static void 
+interp_invalid( GLcontext *ctx, GLfloat t,
+		GLuint edst, GLuint eout, GLuint ein,
+		GLboolean force_boundary )
+{
+   fprintf(stderr, "swrast_setup: invalid interp function\n");
+   (void) (ctx && t && edst && eout && ein && force_boundary);
+}
+
+static void 
+copy_pv_invalid( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   fprintf(stderr, "swrast_setup: invalid copy_pv function\n");
+   (void) (ctx && edst && esrc );
+}
+
+static void init_standard( void )
+{
+   GLuint i;
+
+   for (i = 0 ; i < Elements(setup_tab) ; i++) {
+      setup_tab[i] = emit_invalid;
+      interp_tab[i] = interp_invalid;
+      copy_pv_tab[i] = copy_pv_invalid;
+   }
+
+   init_none();
+   init_color();
+   init_color_spec();
+   init_color_fog();
+   init_color_spec_fog();
+   init_color_tex0();
+   init_color_tex0_spec();
+   init_color_tex0_fog();
+   init_color_tex0_spec_fog();
+   init_color_multitex();
+   init_color_multitex_spec();
+   init_color_multitex_fog();
+   init_color_multitex_spec_fog();
+   init_color_point();
+   init_color_spec_point();
+   init_color_fog_point();
+   init_color_spec_fog_point();
+   init_color_tex0_point();
+   init_color_tex0_spec_point();
+   init_color_tex0_fog_point();
+   init_color_tex0_spec_fog_point();
+   init_color_multitex_point();
+   init_color_multitex_spec_point();
+   init_color_multitex_fog_point();
+   init_color_multitex_spec_fog_point();
+   init_index();
+   init_index_fog();
+   init_index_point();
+   init_index_fog_point();
+}
+
+static void printSetupFlags(char *msg, GLuint flags )
+{
+   fprintf(stderr, "%s(%x): %s%s%s%s%s%s%s\n",
+	   msg,
+	   (int)flags,
+	   (flags & COLOR) ? "color, " : "",
+	   (flags & INDEX) ? "index, " : "",
+	   (flags & TEX0) ? "tex0, " : "",
+	   (flags & MULTITEX) ? "multitex, " : "",
+	   (flags & SPEC) ? "spec, " : "",
+	   (flags & FOG) ? "fog, " : "",
+	   (flags & POINT) ? "point, " : "");
+}
+
+
+
+void
+_swsetup_choose_rastersetup_func(GLcontext *ctx)
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   int funcindex = 0;
+
+   if (ctx->RenderMode == GL_RENDER) {
+      if (ctx->Visual.rgbMode) {
+         funcindex = COLOR;
+
+         if (ctx->Texture._ReallyEnabled & ~TEXTURE0_ANY)
+            funcindex |= MULTITEX;
+         else if (ctx->Texture._ReallyEnabled & TEXTURE0_ANY)
+            funcindex |= TEX0;
+
+         if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
+            funcindex |= SPEC;
+      }
+      else {
+         funcindex = INDEX;
+      }
+
+      if (ctx->Point._Attenuated)
+         funcindex |= POINT;
+
+      if (ctx->Fog.Enabled)
+	 funcindex |= FOG;
+   }
+   else if (ctx->RenderMode == GL_FEEDBACK) {
+      if (ctx->Visual.rgbMode)
+	 funcindex = (COLOR | TEX0); /* is feedback color subject to fogging? */
+      else
+	 funcindex = INDEX;
+   }
+   else
+      funcindex = 0;
+   
+   swsetup->SetupIndex = funcindex;
+   tnl->Driver.Render.BuildVertices = setup_tab[funcindex];
+
+   if (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED)) {
+      tnl->Driver.Render.Interp = interp_extras;
+      tnl->Driver.Render.CopyPV = copy_pv_extras;
+   }
+   else {
+      tnl->Driver.Render.Interp = interp_tab[funcindex];
+      tnl->Driver.Render.CopyPV = copy_pv_tab[funcindex];
+   }
+
+   ASSERT(tnl->Driver.Render.BuildVertices);
+   ASSERT(tnl->Driver.Render.BuildVertices != emit_invalid);
+}
+
+
+void
+_swsetup_vb_init( GLcontext *ctx )
+{
+   (void) ctx;
+   init_standard();
+   (void) printSetupFlags;
+}
+   
Index: xc/extras/Mesa/src/swrast_setup/ss_vb.h
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_vb.h:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_vb.h	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,38 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef SS_VB_H
+#define SS_VB_H
+
+#include "mtypes.h"
+#include "swrast_setup.h"
+
+void _swsetup_vb_init( GLcontext *ctx );
+void _swsetup_choose_rastersetup_func( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/swrast_setup/ss_vbtmp.h
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/ss_vbtmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/ss_vbtmp.h	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,252 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+static void TAG(emit)(GLcontext *ctx, GLuint start, GLuint end, 
+		      GLuint newinputs )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   SWvertex *v;
+   GLfloat *proj;		/* projected clip coordinates */
+   GLfloat *tc[MAX_TEXTURE_UNITS];
+   GLchan *color;
+   GLchan *spec;
+   GLuint *index;
+   GLfloat *fog;
+   GLfloat *pointSize;
+   GLuint tsz[MAX_TEXTURE_UNITS];
+   GLuint tstride[MAX_TEXTURE_UNITS];
+   GLuint proj_stride, color_stride, spec_stride, index_stride;
+   GLuint fog_stride, pointSize_stride;
+   GLuint i;
+   GLfloat *m = ctx->Viewport._WindowMap.m;
+   const GLfloat sx = m[0];
+   const GLfloat sy = m[5];
+   const GLfloat sz = m[10];
+   const GLfloat tx = m[12];
+   const GLfloat ty = m[13];
+   const GLfloat tz = m[14];
+   GLuint maxtex = 0;
+
+   if (IND & TEX0) {
+      tc[0] = (GLfloat *)VB->TexCoordPtr[0]->data;
+      tsz[0] = VB->TexCoordPtr[0]->size;
+      tstride[0] = VB->TexCoordPtr[0]->stride;
+   }
+
+   if (IND & MULTITEX) {
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
+	 if (VB->TexCoordPtr[i]) {
+	    maxtex = i+1;
+	    tc[i] = (GLfloat *)VB->TexCoordPtr[i]->data;
+	    tsz[i] = VB->TexCoordPtr[i]->size;
+	    tstride[i] = VB->TexCoordPtr[i]->stride;
+	 }
+	 else tc[i] = 0;
+      }
+   }
+
+   proj = VB->ProjectedClipPtr->data[0];
+   proj_stride = VB->ProjectedClipPtr->stride;
+
+   if (IND & FOG) {
+      fog = VB->FogCoordPtr->data;
+      fog_stride = VB->FogCoordPtr->stride;
+   }
+   if (IND & COLOR) {
+      if (VB->ColorPtr[0]->Type != CHAN_TYPE)
+	 import_float_colors( ctx );
+
+      color = (GLchan *) VB->ColorPtr[0]->Ptr;
+      color_stride = VB->ColorPtr[0]->StrideB;
+   }
+   if (IND & SPEC) {
+      if (VB->SecondaryColorPtr[0]->Type != CHAN_TYPE)
+	 import_float_spec_colors( ctx );
+
+      spec = (GLchan *) VB->SecondaryColorPtr[0]->Ptr;
+      spec_stride = VB->SecondaryColorPtr[0]->StrideB;
+   }
+   if (IND & INDEX) {
+      index = VB->IndexPtr[0]->data;
+      index_stride = VB->IndexPtr[0]->stride;
+   }
+   if (IND & POINT) {
+      pointSize = VB->PointSizePtr->data;
+      pointSize_stride = VB->PointSizePtr->stride;
+   }
+
+   v = &(SWSETUP_CONTEXT(ctx)->verts[start]);
+
+   for (i=start; i < end; i++, v++) {
+      if (VB->ClipMask[i] == 0) {
+	 v->win[0] = sx * proj[0] + tx;
+	 v->win[1] = sy * proj[1] + ty;
+	 v->win[2] = sz * proj[2] + tz;
+	 v->win[3] =      proj[3];
+      }
+      STRIDE_F(proj, proj_stride);
+
+      if (IND & TEX0) {
+	 COPY_CLEAN_4V( v->texcoord[0], tsz[0], tc[0] );
+	 STRIDE_F(tc[0], tstride[0]);
+      }
+
+      if (IND & MULTITEX) {
+	 GLuint u;
+	 for (u = 0 ; u < maxtex ; u++)
+	    if (tc[u]) {
+	       COPY_CLEAN_4V( v->texcoord[u], tsz[u], tc[u] );
+	       STRIDE_F(tc[u], tstride[u]);
+	    }
+      }
+
+      if (IND & COLOR) {
+	 COPY_CHAN4(v->color, color);
+	 STRIDE_CHAN(color, color_stride);
+      }
+
+      if (IND & SPEC) {
+	 COPY_CHAN4(v->specular, spec);
+	 STRIDE_CHAN(spec, spec_stride);
+      }
+
+      if (IND & FOG) {
+	 v->fog = fog[0];
+	 STRIDE_F(fog, fog_stride);
+      }
+
+      if (IND & INDEX) {
+	 v->index = index[0];
+	 STRIDE_UI(index, index_stride);
+      }
+
+      if (IND & POINT) {
+	 v->pointSize = pointSize[0];
+	 STRIDE_F(pointSize, pointSize_stride);
+      }
+   }
+}
+
+
+
+static void TAG(interp)( GLcontext *ctx,
+			 GLfloat t,
+			 GLuint edst, GLuint eout, GLuint ein,
+			 GLboolean force_boundary )
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLfloat *m = ctx->Viewport._WindowMap.m;
+   GLfloat *clip = VB->ClipPtr->data[edst];
+
+   SWvertex *dst = &swsetup->verts[edst];
+   SWvertex *in  = &swsetup->verts[ein];
+   SWvertex *out = &swsetup->verts[eout];
+
+   /* Avoid division by zero by rearranging order of clip planes?
+    */
+   if (clip[3] != 0.0) {
+      GLfloat oow = 1.0F / clip[3];
+      dst->win[0] = m[0]  * clip[0] * oow + m[12];
+      dst->win[1] = m[5]  * clip[1] * oow + m[13];
+      dst->win[2] = m[10] * clip[2] * oow + m[14];
+      dst->win[3] =                   oow;
+   }
+   
+   if (IND & TEX0) {
+      INTERP_4F( t, dst->texcoord[0], out->texcoord[0], in->texcoord[0] );
+   }
+
+   if (IND & MULTITEX) {
+      GLuint u;
+      GLuint maxtex = ctx->Const.MaxTextureUnits;
+      for (u = 0 ; u < maxtex ; u++)
+	 if (VB->TexCoordPtr[u]) {
+	    INTERP_4F( t, dst->texcoord[u], out->texcoord[u], in->texcoord[u] );
+	 }
+   }
+
+   if (IND & COLOR) {
+      INTERP_CHAN( t, dst->color[0], out->color[0], in->color[0] );
+      INTERP_CHAN( t, dst->color[1], out->color[1], in->color[1] );
+      INTERP_CHAN( t, dst->color[2], out->color[2], in->color[2] );
+      INTERP_CHAN( t, dst->color[3], out->color[3], in->color[3] );
+   }
+
+   if (IND & SPEC) {
+      INTERP_CHAN( t, dst->specular[0], out->specular[0], in->specular[0] );
+      INTERP_CHAN( t, dst->specular[1], out->specular[1], in->specular[1] );
+      INTERP_CHAN( t, dst->specular[2], out->specular[2], in->specular[2] );
+   }
+
+   if (IND & FOG) {
+      INTERP_F( t, dst->fog, out->fog, in->fog );
+   }
+
+   if (IND & INDEX) {
+      INTERP_UI( t, dst->index, out->index, in->index );
+   }
+
+   if (IND & POINT) {
+      INTERP_F( t, dst->pointSize, out->pointSize, in->pointSize );
+   }
+}
+
+
+static void TAG(copy_pv)( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   SScontext *swsetup = SWSETUP_CONTEXT(ctx);
+   SWvertex *dst = &swsetup->verts[edst];
+   SWvertex *src = &swsetup->verts[esrc];
+
+   if (IND & COLOR) {
+      COPY_CHAN4( dst->color, src->color );
+   }
+
+   if (IND & SPEC) {
+      COPY_3V( dst->specular, src->specular );
+   }
+
+   if (IND & INDEX) {
+      dst->index = src->index;
+   }
+}
+
+
+static void TAG(init)( void )
+{
+   setup_tab[IND] = TAG(emit);
+   interp_tab[IND] = TAG(interp);
+   copy_pv_tab[IND] = TAG(copy_pv);
+}
+
+#undef TAG
+#undef IND
+#undef SETUP_FLAGS
Index: xc/extras/Mesa/src/swrast_setup/swrast_setup.h
diff -u /dev/null xc/extras/Mesa/src/swrast_setup/swrast_setup.h:1.2
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/swrast_setup/swrast_setup.h	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,53 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+/* Public interface to the swrast_setup module.  This module provides
+ * an implementation of the driver interface to t_vb_render.c, and uses
+ * the software rasterizer (swrast) to perform actual rasterization.
+ *
+ * The internals of the implementation are private, but can be hooked
+ * into tnl at any time (except between RenderStart/RenderEnd) by
+ * calling _swsetup_Wakeup(). 
+ */
+
+#ifndef SWRAST_SETUP_H
+#define SWRAST_SETUP_H
+
+extern GLboolean
+_swsetup_CreateContext( GLcontext *ctx );
+
+extern void
+_swsetup_DestroyContext( GLcontext *ctx );
+
+extern void
+_swsetup_InvalidateState( GLcontext *ctx, GLuint new_state );
+
+extern void
+_swsetup_Wakeup( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/tnl/NOTES
diff -u /dev/null xc/extras/Mesa/src/tnl/NOTES:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:03 2003
+++ xc/extras/Mesa/src/tnl/NOTES	Fri Feb 22 12:14:14 2002
@@ -0,0 +1,102 @@
+INTRODUCTION
+
+A generic, configurable software implementation of GL transformation &
+lighting.
+
+This module provides an implementation of the routines required by the
+'vtxfmt' mechanism of core mesa for tnl functionality in all
+combinations of compile and execute modes.
+
+Most current drivers use the tnl module exclusively to provide this
+functionality, though there is an experimental alternate
+implementation provided by the tnl_dd/t_dd_imm_* files which can
+handle a small subset of GL states in execute mode only.
+
+
+STATE
+
+To create and destroy the module:
+
+	GLboolean _tnl_CreateContext( GLcontext *ctx );
+	void _tnl_DestroyContext( GLcontext *ctx );
+
+The module is not active by default, and must be installed by calling
+_tnl_Wakeup().  This function installs internal tnl functions into all
+the vtxfmt dispatch hooks, thus taking over the task of transformation
+and lighting entirely:
+
+        void _tnl_wakeup_exec( GLcontext *ctx );
+	void _tnl_wakeup_save_exec( GLcontext *ctx );
+
+   
+This module tracks state changes internally and maintains derived
+values based on the current state.  For this to work, the driver
+ensure the following funciton is called whenever the state changes and
+the swsetup module is 'awake':
+
+	void _tnl_InvalidateState( GLcontext *ctx, GLuint new_state );
+
+There is no explicit call to put the tnl module to sleep.  Simply
+install other function pointers into all the vtxfmt dispatch slots,
+and (optionally) cease calling _tnl_InvalidateState().
+
+CUSTOMIZATION
+
+The module provides customizability through several mechanisms.  The
+most important is by allowing drivers to specify the pipeline through
+which vertex data is passed, including its eventual transfer to
+rasterization hardware (or software).
+
+The default pipeline is specified in t_pipeline.c, and is usually a
+starting point for driver pipelines.  Some drivers will remove a stage
+where hardware provides support for the implemented operation (for
+instance fog where per-pixel hardware fog is available, as in the dri
+tdfx driver), or add stages to shortcircuit latter operations (for
+example taking advantage of hardware support for strips and other
+higher-level primitives (for example the radeon driver).
+
+In addition, the following functions provide further tweaks:
+
+extern void
+_tnl_need_projected_coords( GLcontext *ctx, GLboolean flag );
+
+	- Direct the default vertex transformation stage to
+          produce/not produce projected clip coordinates.
+	  
+extern void
+_tnl_need_dlist_loopback( GLcontext *ctx, GLboolean flag );
+      
+        - Direct the display list component of the tnl module to
+          replay display lists as 'glVertex' type calls, rather than
+          passing the display list data directly into the tnl pipeline
+          mechanism.  
+
+	  This allows display lists to be replayed by the tnl module
+	  even when the module is not strictly active.
+
+
+extern void
+_tnl_need_dlist_norm_lengths( GLcontext *ctx, GLboolean flag );
+
+	- Direct the display list component to enable/disable caching
+          1/length values for display list normals.  Doing so is
+          ususally helpful when lighting is performed in software, but
+          wasteful otherwise.
+
+
+DRIVER INTERFACE
+
+The module itself offers a minimal driver interface:
+
+	 void (*RunPipeline)( GLcontext *ctx );
+
+Normally this is set to _tnl_RunPipeline(), however the driver can use
+this hook to wrap checks or other code around this call. 
+
+In addition, the driver interface for the default render pipeline
+stage is housed in the tnl context struct (this could be cleaner).  
+
+
+RENDER DRIVER INTERFACE
+
+See t_context.h for the definition and explanation of this.
\ No newline at end of file
Index: xc/extras/Mesa/src/tnl/t_array_api.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_array_api.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_array_api.c	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,390 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.5
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "api_validate.h"
+#include "context.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mem.h"
+#include "state.h"
+#include "mtypes.h"
+
+#include "array_cache/acache.h"
+
+#include "t_array_api.h"
+#include "t_array_import.h"
+#include "t_imm_api.h"
+#include "t_imm_exec.h"
+#include "t_context.h"
+#include "t_pipeline.h"
+
+static void fallback_drawarrays( GLcontext *ctx, GLenum mode, GLint start,
+				 GLsizei count )
+{
+   if (_tnl_hard_begin( ctx, mode )) {
+      GLint i;
+      for (i = start; i < count; i++) 
+	 glArrayElement( i );
+      glEnd();
+   }
+}
+
+
+static void fallback_drawelements( GLcontext *ctx, GLenum mode, GLsizei count,
+				   const GLuint *indices)
+{
+   if (_tnl_hard_begin(ctx, mode)) {
+      GLint i;
+      for (i = 0 ; i < count ; i++)
+	 glArrayElement( indices[i] );
+      glEnd();
+   }
+}
+
+
+static void _tnl_draw_range_elements( GLcontext *ctx, GLenum mode,
+				      GLuint start, GLuint end,
+				      GLsizei count, const GLuint *indices )
+
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   FLUSH_CURRENT( ctx, 0 );
+   
+   /*  fprintf(stderr, "%s\n", __FUNCTION__); */
+   if (tnl->pipeline.build_state_changes)
+      _tnl_validate_pipeline( ctx );
+
+   _tnl_vb_bind_arrays( ctx, start, end );
+
+   tnl->vb.FirstPrimitive = 0;
+   tnl->vb.Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
+   tnl->vb.PrimitiveLength[0] = count;
+   tnl->vb.Elts = (GLuint *)indices;
+
+   if (ctx->Array.LockCount)
+      tnl->Driver.RunPipeline( ctx );
+   else {
+      /* Note that arrays may have changed before/after execution.
+       */
+      tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
+      tnl->Driver.RunPipeline( ctx );
+      tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
+   }
+}
+
+
+
+
+void
+_tnl_DrawArrays(GLenum mode, GLint start, GLsizei count)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint thresh = (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES) ? 30 : 10;
+   
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "_tnl_DrawArrays %d %d\n", start, count); 
+   
+   /* Check arguments, etc.
+    */
+   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
+      return;
+
+   if (tnl->pipeline.build_state_changes)
+      _tnl_validate_pipeline( ctx );
+
+   if (ctx->CompileFlag) {
+      fallback_drawarrays( ctx, mode, start, start + count );
+   }    
+   else if (!ctx->Array.LockCount && (GLuint) count < thresh) {
+      /* Small primitives: attempt to share a vb (at the expense of
+       * using the immediate interface).
+      */
+      fallback_drawarrays( ctx, mode, start, start + count );
+   } 
+   else if (count < (GLint) ctx->Const.MaxArrayLockSize) {
+      /* Moderate primitives which can fit in a single vertex buffer:
+       */
+      FLUSH_CURRENT( ctx, 0 );
+
+      if (ctx->Array.LockCount)
+      {
+	 if (start < (GLint) ctx->Array.LockFirst)
+            start = ctx->Array.LockFirst;
+	 if (start + count > (GLint) ctx->Array.LockCount)
+            count = ctx->Array.LockCount - start;
+
+	 /* Locked drawarrays.  Reuse any previously transformed data.
+	  */
+	 _tnl_vb_bind_arrays( ctx, ctx->Array.LockFirst, ctx->Array.LockCount );
+	 VB->FirstPrimitive = start;
+	 VB->Primitive[start] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
+	 VB->PrimitiveLength[start] = count;
+	 tnl->Driver.RunPipeline( ctx );
+      } else {
+	 /* The arrays are small enough to fit in a single VB; just bind
+	  * them and go.  Any untransformed data will be copied on
+	  * clipping.
+	  *
+	  * Invalidate any cached data dependent on these arrays.
+	  */
+	 _tnl_vb_bind_arrays( ctx, start, start + count );
+	 VB->FirstPrimitive = 0;
+	 VB->Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
+	 VB->PrimitiveLength[0] = count;
+	 tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
+	 tnl->Driver.RunPipeline( ctx );
+	 tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
+      }
+   }
+   else {
+      int bufsz = 256;		/* use a small buffer for cache goodness */
+      int j, nr;
+      int minimum, modulo, skip;
+
+      /* Large primitives requiring decomposition to multiple vertex
+       * buffers:
+       */
+      switch (mode) {
+      case GL_POINTS:
+	 minimum = 0;
+	 modulo = 1;
+	 skip = 0;
+	 break;
+      case GL_LINES:
+	 minimum = 1;
+	 modulo = 2;
+	 skip = 1;
+	 break;
+      case GL_LINE_STRIP:
+	 minimum = 1;
+	 modulo = 1;
+	 skip = 0;
+	 break;
+      case GL_TRIANGLES:
+	 minimum = 2;
+	 modulo = 3;
+	 skip = 2;
+	 break;
+      case GL_TRIANGLE_STRIP:
+	 minimum = 2;
+	 modulo = 1;
+	 skip = 0;
+	 break;
+      case GL_QUADS:
+	 minimum = 3;
+	 modulo = 4;
+	 skip = 3;
+	 break;
+      case GL_QUAD_STRIP:
+	 minimum = 3;
+	 modulo = 2;
+	 skip = 0;
+	 break;
+      case GL_LINE_LOOP:
+      case GL_TRIANGLE_FAN:
+      case GL_POLYGON:
+      default:
+	 /* Primitives requiring a copied vertex (fan-like primitives)
+	  * must use the slow path:
+	  */
+	 fallback_drawarrays( ctx, mode, start, start + count );
+	 return;
+      }
+
+      FLUSH_CURRENT( ctx, 0 );
+
+      bufsz -= bufsz % modulo;
+      bufsz -= minimum;
+      count += start;
+
+      for (j = start + minimum ; j < count ; j += nr + skip ) {
+
+	 nr = MIN2( bufsz, count - j );
+
+	 _tnl_vb_bind_arrays( ctx, j - minimum, j + nr );
+
+	 VB->FirstPrimitive = 0;
+	 VB->Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
+	 VB->PrimitiveLength[0] = nr + minimum;
+	 tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
+	 tnl->Driver.RunPipeline( ctx );
+	 tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
+      }
+   }
+}
+
+
+void
+_tnl_DrawRangeElements(GLenum mode,
+		       GLuint start, GLuint end,
+		       GLsizei count, GLenum type, const GLvoid *indices)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint *ui_indices;
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "_tnl_DrawRangeElements %d %d %d\n", start, end, count); 
+
+   /* Check arguments, etc.
+    */
+   if (!_mesa_validate_DrawRangeElements( ctx, mode, start, end, count,
+                                          type, indices ))
+      return;
+
+   ui_indices = (GLuint *)_ac_import_elements( ctx, GL_UNSIGNED_INT,
+					       count, type, indices );
+
+
+   if (ctx->CompileFlag) {
+      /* Can't do anything when compiling:
+       */
+      fallback_drawelements( ctx, mode, count, ui_indices );
+   }
+   else if (ctx->Array.LockCount) {
+      /* Are the arrays already locked?  If so we currently have to look
+       * at the whole locked range.
+       */
+      if (start >= ctx->Array.LockFirst && end <= ctx->Array.LockCount)
+	 _tnl_draw_range_elements( ctx, mode,
+				   ctx->Array.LockFirst,
+				   ctx->Array.LockCount,
+				   count, ui_indices );
+      else {
+	 /* The spec says referencing elements outside the locked
+	  * range is undefined.  I'm going to make it a noop this time
+	  * round, maybe come up with something beter before 3.6.
+	  *
+	  * May be able to get away with just setting LockCount==0,
+	  * though this raises the problems of dependent state.  May
+	  * have to call glUnlockArrays() directly?
+	  *
+	  * Or scan the list and replace bad indices?
+	  */
+	 _mesa_problem( ctx,
+		     "DrawRangeElements references "
+		     "elements outside locked range.");
+      }
+   }
+   else if (end + 1 - start < ctx->Const.MaxArrayLockSize) {
+      /* The arrays aren't locked but we can still fit them inside a
+       * single vertexbuffer.
+       */
+      _tnl_draw_range_elements( ctx, mode, start, end + 1, count, ui_indices );
+   } else {
+      /* Range is too big to optimize:
+       */
+      fallback_drawelements( ctx, mode, count, ui_indices );
+   }
+}
+
+
+
+void
+_tnl_DrawElements(GLenum mode, GLsizei count, GLenum type,
+		  const GLvoid *indices)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint *ui_indices;
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "_tnl_DrawElements %d\n", count); 
+
+   /* Check arguments, etc.
+    */
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+      return;
+
+   ui_indices = (GLuint *)_ac_import_elements( ctx, GL_UNSIGNED_INT,
+					       count, type, indices );
+
+   if (ctx->CompileFlag) {
+      /* Can't do anything when compiling:
+       */
+      fallback_drawelements( ctx, mode, count, ui_indices );
+   }
+   else if (ctx->Array.LockCount) {
+      _tnl_draw_range_elements( ctx, mode,
+				ctx->Array.LockFirst,
+				ctx->Array.LockCount,
+				count, ui_indices );
+   }
+   else {
+      /* Scan the index list and see if we can use the locked path anyway.
+       */
+      GLuint max_elt = 0;
+      GLint i;
+
+      for (i = 0 ; i < count ; i++)
+	 if (ui_indices[i] > max_elt)
+            max_elt = ui_indices[i];
+
+      if (max_elt < ctx->Const.MaxArrayLockSize && /* can we use it? */
+	  max_elt < (GLuint) count) 	           /* do we want to use it? */
+	 _tnl_draw_range_elements( ctx, mode, 0, max_elt+1, count, ui_indices );
+      else
+	 fallback_drawelements( ctx, mode, count, ui_indices );
+   }
+}
+
+
+void _tnl_array_init( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_arrays *tmp = &tnl->array_inputs;
+   GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt);
+   GLuint i;
+
+   vfmt->DrawArrays = _tnl_DrawArrays;
+   vfmt->DrawElements = _tnl_DrawElements;
+   vfmt->DrawRangeElements = _tnl_DrawRangeElements;
+
+   /* Setup vector pointers that will be used to bind arrays to VB's.
+    */
+   _mesa_vector4f_init( &tmp->Obj, 0, 0 );
+   _mesa_vector3f_init( &tmp->Normal, 0, 0 );   
+   _mesa_vector1f_init( &tmp->FogCoord, 0, 0 );
+   _mesa_vector1ui_init( &tmp->Index, 0, 0 );
+   _mesa_vector1ub_init( &tmp->EdgeFlag, 0, 0 );
+
+   for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
+      _mesa_vector4f_init( &tmp->TexCoord[i], 0, 0);
+
+   tnl->tmp_primitive = (GLuint *)MALLOC(sizeof(GLuint)*tnl->vb.Size);
+   tnl->tmp_primitive_length = (GLuint *)MALLOC(sizeof(GLuint)*tnl->vb.Size);
+}
+
+
+void _tnl_array_destroy( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   if (tnl->tmp_primitive_length) FREE(tnl->tmp_primitive_length);
+   if (tnl->tmp_primitive) FREE(tnl->tmp_primitive);
+}
Index: xc/extras/Mesa/src/tnl/t_array_api.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_array_api.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_array_api.h	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,46 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef _T_VARRAY_H
+#define _T_VARRAY_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+
+extern void _tnl_DrawArrays(GLenum mode, GLint first, GLsizei count);
+
+extern void _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type,
+			      const GLvoid *indices);
+
+extern void _tnl_DrawRangeElements(GLenum mode, GLuint start,
+				   GLuint end, GLsizei count, GLenum type,
+				   const GLvoid *indices);
+
+
+extern void _tnl_array_init( GLcontext *ctx );
+extern void _tnl_array_destroy( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_array_import.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_array_import.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_array_import.c	Mon Dec 16 11:18:44 2002
@@ -0,0 +1,389 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "state.h"
+#include "mtypes.h"
+
+#include "array_cache/acache.h"
+#include "math/m_translate.h"
+
+#include "t_array_import.h"
+#include "t_context.h"
+#include "t_imm_debug.h"
+
+
+static void _tnl_import_vertex( GLcontext *ctx,
+				GLboolean writeable,
+				GLboolean stride )
+{
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+
+   tmp = _ac_import_vertex(ctx,
+			   GL_FLOAT,
+			   stride ? 4*sizeof(GLfloat) : 0,
+			   0,
+			   writeable,
+			   &is_writeable);
+
+   inputs->Obj.data = (GLfloat (*)[4]) tmp->Ptr;
+   inputs->Obj.start = (GLfloat *) tmp->Ptr;
+   inputs->Obj.stride = tmp->StrideB;
+   inputs->Obj.size = tmp->Size;
+   inputs->Obj.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
+   if (inputs->Obj.stride != 4*sizeof(GLfloat))
+      inputs->Obj.flags |= VEC_BAD_STRIDE;
+   if (!is_writeable)
+      inputs->Obj.flags |= VEC_NOT_WRITEABLE;
+}
+
+static void _tnl_import_normal( GLcontext *ctx,
+				GLboolean writeable,
+				GLboolean stride )
+{
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+
+   tmp = _ac_import_normal(ctx, GL_FLOAT,
+			   stride ? 3*sizeof(GLfloat) : 0, writeable,
+			   &is_writeable);
+
+   inputs->Normal.data = (GLfloat (*)[3]) tmp->Ptr;
+   inputs->Normal.start = (GLfloat *) tmp->Ptr;
+   inputs->Normal.stride = tmp->StrideB;
+   inputs->Normal.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
+   if (inputs->Normal.stride != 3*sizeof(GLfloat))
+      inputs->Normal.flags |= VEC_BAD_STRIDE;
+   if (!is_writeable)
+      inputs->Normal.flags |= VEC_NOT_WRITEABLE;
+}
+
+
+static void _tnl_import_color( GLcontext *ctx,
+			       GLenum type,
+			       GLboolean writeable,
+			       GLboolean stride )
+{
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+
+   tmp = _ac_import_color(ctx,
+			  type,
+			  stride ? 4*sizeof(GLfloat) : 0,
+			  4,
+			  writeable,
+			  &is_writeable);
+
+   inputs->Color = *tmp;
+}
+
+
+static void _tnl_import_secondarycolor( GLcontext *ctx,
+					GLenum type,
+					GLboolean writeable,
+					GLboolean stride )
+{
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+
+   tmp = _ac_import_secondarycolor(ctx, 
+				   type,
+				   stride ? 4*sizeof(GLfloat) : 0,
+				   4,
+				   writeable,
+				   &is_writeable);
+
+   inputs->SecondaryColor = *tmp;
+}
+
+static void _tnl_import_fogcoord( GLcontext *ctx,
+				  GLboolean writeable,
+				  GLboolean stride )
+{
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+    struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+
+   tmp = _ac_import_fogcoord(ctx, GL_FLOAT,
+			     stride ? sizeof(GLfloat) : 0, writeable,
+			     &is_writeable);
+
+   inputs->FogCoord.data = (GLfloat *) tmp->Ptr;
+   inputs->FogCoord.start = (GLfloat *) tmp->Ptr;
+   inputs->FogCoord.stride = tmp->StrideB;
+   inputs->FogCoord.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
+   if (inputs->FogCoord.stride != sizeof(GLfloat))
+      inputs->FogCoord.flags |= VEC_BAD_STRIDE;
+   if (!is_writeable)
+      inputs->FogCoord.flags |= VEC_NOT_WRITEABLE;
+}
+
+static void _tnl_import_index( GLcontext *ctx,
+			       GLboolean writeable,
+			       GLboolean stride )
+{
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+
+   tmp = _ac_import_index(ctx, GL_UNSIGNED_INT,
+			  stride ? sizeof(GLuint) : 0, writeable,
+			  &is_writeable);
+
+   inputs->Index.data = (GLuint *) tmp->Ptr;
+   inputs->Index.start = (GLuint *) tmp->Ptr;
+   inputs->Index.stride = tmp->StrideB;
+   inputs->Index.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
+   if (inputs->Index.stride != sizeof(GLuint))
+      inputs->Index.flags |= VEC_BAD_STRIDE;
+   if (!is_writeable)
+      inputs->Index.flags |= VEC_NOT_WRITEABLE;
+}
+
+
+static void _tnl_import_texcoord( GLcontext *ctx,
+				  GLuint i,
+				  GLboolean writeable,
+				  GLboolean stride )
+{
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+
+   tmp = _ac_import_texcoord(ctx, i, GL_FLOAT,
+			     stride ? 4*sizeof(GLfloat) : 0,
+			     0,
+			     writeable,
+			     &is_writeable);
+
+   inputs->TexCoord[i].data = (GLfloat (*)[4]) tmp->Ptr;
+   inputs->TexCoord[i].start = (GLfloat *) tmp->Ptr;
+   inputs->TexCoord[i].stride = tmp->StrideB;
+   inputs->TexCoord[i].size = tmp->Size;
+   inputs->TexCoord[i].flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
+   if (inputs->TexCoord[i].stride != 4*sizeof(GLfloat))
+      inputs->TexCoord[i].flags |= VEC_BAD_STRIDE;
+   if (!is_writeable)
+      inputs->TexCoord[i].flags |= VEC_NOT_WRITEABLE;
+}
+
+
+static void _tnl_import_edgeflag( GLcontext *ctx,
+				  GLboolean writeable,
+				  GLboolean stride )
+{
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   struct gl_client_array *tmp;
+   GLboolean is_writeable = 0;
+
+   tmp = _ac_import_edgeflag(ctx, GL_UNSIGNED_BYTE,
+			     stride ? sizeof(GLubyte) : 0,
+			     0,
+			     &is_writeable);
+
+   inputs->EdgeFlag.data = (GLubyte *) tmp->Ptr;
+   inputs->EdgeFlag.start = (GLubyte *) tmp->Ptr;
+   inputs->EdgeFlag.stride = tmp->StrideB;
+   inputs->EdgeFlag.flags &= ~(VEC_BAD_STRIDE|VEC_NOT_WRITEABLE);
+   if (inputs->EdgeFlag.stride != sizeof(GLubyte))
+      inputs->EdgeFlag.flags |= VEC_BAD_STRIDE;
+   if (!is_writeable)
+      inputs->EdgeFlag.flags |= VEC_NOT_WRITEABLE;
+}
+
+
+
+/* Callback for VB stages that need to improve the quality of arrays
+ * bound to the VB.  This is only necessary for client arrays which
+ * have not been transformed at any point in the pipeline.
+ */
+static void _tnl_upgrade_client_data( GLcontext *ctx,
+				      GLuint required,
+				      GLuint flags )
+{
+   GLuint i;
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLboolean writeable = (flags & VEC_NOT_WRITEABLE) != 0;
+   GLboolean stride = (flags & VEC_BAD_STRIDE) != 0;
+   struct vertex_arrays *inputs = &TNL_CONTEXT(ctx)->array_inputs;
+   GLuint ca_flags = 0;
+   (void) inputs;
+
+   if (writeable || stride) ca_flags |= CA_CLIENT_DATA;
+
+   if ((required & VERT_CLIP) && VB->ClipPtr == VB->ObjPtr)
+      required |= VERT_OBJ;
+
+/*     _tnl_print_vert_flags("_tnl_upgrade_client_data", required); */
+
+   if ((required & VERT_OBJ) && (VB->ObjPtr->flags & flags)) {
+      ASSERT(VB->ObjPtr == &inputs->Obj);
+      _tnl_import_vertex( ctx, writeable, stride );
+      VB->importable_data &= ~(VERT_OBJ|VERT_CLIP);
+   }
+
+   if ((required & VERT_NORM) && (VB->NormalPtr->flags & flags)) {
+      ASSERT(VB->NormalPtr == &inputs->Normal);
+      _tnl_import_normal( ctx, writeable, stride );
+      VB->importable_data &= ~VERT_NORM;
+   }
+
+   if ((required & VERT_RGBA) && (VB->ColorPtr[0]->Flags & ca_flags)) {
+      ASSERT(VB->ColorPtr[0] == &inputs->Color);
+      _tnl_import_color( ctx, GL_FLOAT, writeable, stride );
+      VB->importable_data &= ~VERT_RGBA;
+   }
+
+   if ((required & VERT_SPEC_RGB) && 
+       (VB->SecondaryColorPtr[0]->Flags & ca_flags)) {
+      ASSERT(VB->SecondaryColorPtr[0] == &inputs->SecondaryColor);
+      _tnl_import_secondarycolor( ctx, GL_FLOAT, writeable, stride );
+      VB->importable_data &= ~VERT_SPEC_RGB;
+   }
+
+   if ((required & VERT_FOG_COORD) && (VB->FogCoordPtr->flags & flags)) {
+      ASSERT(VB->FogCoordPtr == &inputs->FogCoord);
+      _tnl_import_fogcoord( ctx, writeable, stride );
+      VB->importable_data &= ~VERT_FOG_COORD;
+   }
+
+   if ((required & VERT_INDEX) && (VB->IndexPtr[0]->flags & flags)) {
+      ASSERT(VB->IndexPtr[0] == &inputs->Index);
+      _tnl_import_index( ctx, writeable, stride );
+      VB->importable_data &= ~VERT_INDEX;
+   }
+
+   if (required & VERT_TEX_ANY)
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+	 if ((required & VERT_TEX(i)) && (VB->TexCoordPtr[i]->flags & flags)) {
+	    ASSERT(VB->TexCoordPtr[i] == &inputs->TexCoord[i]);
+	    _tnl_import_texcoord( ctx, i, writeable, stride );
+	    VB->importable_data &= ~VERT_TEX(i);
+	 }
+
+}
+
+
+
+void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLsizei count )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint inputs = tnl->pipeline.inputs;
+   struct vertex_arrays *tmp = &tnl->array_inputs;
+   GLuint i;
+
+/*        fprintf(stderr, "%s %d..%d // %d..%d\n", __FUNCTION__, */
+/*  	      start, count, ctx->Array.LockFirst, ctx->Array.LockCount);  */
+/*        _tnl_print_vert_flags("    inputs", inputs);  */
+/*        _tnl_print_vert_flags("    _Enabled", ctx->Array._Enabled); */
+/*        _tnl_print_vert_flags("    importable", inputs & VERT_FIXUP); */
+
+   VB->Count = count - start;
+   VB->FirstClipped = VB->Count;
+   VB->Elts = 0;
+   VB->MaterialMask = 0;
+   VB->Material = 0;
+   VB->Flag = 0;
+   VB->Primitive = tnl->tmp_primitive;
+   VB->PrimitiveLength = tnl->tmp_primitive_length;
+   VB->import_data = _tnl_upgrade_client_data;
+   VB->importable_data = inputs & VERT_FIXUP;
+
+   if (ctx->Array.LockCount) {
+      ASSERT(start == (GLint) ctx->Array.LockFirst);
+      ASSERT(count == (GLint) ctx->Array.LockCount);
+   }
+
+   _ac_import_range( ctx, start, count );
+
+   if (inputs & VERT_OBJ) {
+      _tnl_import_vertex( ctx, 0, 0 );
+      tmp->Obj.count = VB->Count;
+      VB->ObjPtr = &tmp->Obj;
+   }
+
+   if (inputs & VERT_NORM) {
+      _tnl_import_normal( ctx, 0, 0 );
+      tmp->Normal.count = VB->Count;
+      VB->NormalPtr = &tmp->Normal;
+   }
+
+   if (inputs & VERT_RGBA) {
+      _tnl_import_color( ctx, 0, 0, 0 );
+      VB->ColorPtr[0] = &tmp->Color;
+      VB->ColorPtr[1] = 0;
+   }
+
+   if (inputs & VERT_TEX_ANY) {
+      for (i = 0; i < ctx->Const.MaxTextureUnits ; i++) {
+	 if (inputs & VERT_TEX(i)) {
+	    _tnl_import_texcoord( ctx, i, 0, 0 );
+	    tmp->TexCoord[i].count = VB->Count;
+	    VB->TexCoordPtr[i] = &tmp->TexCoord[i];
+	 }
+      }
+   }
+
+   if (inputs & (VERT_INDEX|VERT_FOG_COORD|VERT_EDGE|VERT_SPEC_RGB)) {
+      if (inputs & VERT_INDEX) {
+	 _tnl_import_index( ctx, 0, 0 );
+	 tmp->Index.count = VB->Count;
+	 VB->IndexPtr[0] = &tmp->Index;
+	 VB->IndexPtr[1] = 0;
+      }
+
+      if (inputs & VERT_FOG_COORD) {
+	 _tnl_import_fogcoord( ctx, 0, 0 );
+	 tmp->FogCoord.count = VB->Count;
+	 VB->FogCoordPtr = &tmp->FogCoord;
+      }
+
+      if (inputs & VERT_EDGE) {
+	 _tnl_import_edgeflag( ctx, GL_TRUE, sizeof(GLboolean) );
+	 VB->EdgeFlag = (GLboolean *) tmp->EdgeFlag.data;
+      }
+
+      if (inputs & VERT_SPEC_RGB) {
+	 _tnl_import_secondarycolor( ctx, 0, 0, 0 );
+	 VB->SecondaryColorPtr[0] = &tmp->SecondaryColor;
+	 VB->SecondaryColorPtr[1] = 0;
+      }
+   }
+}
+
+
Index: xc/extras/Mesa/src/tnl/t_array_import.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_array_import.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_array_import.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,36 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#ifndef _T_ARRAY_IMPORT_H
+#define _T_ARRAY_IMPORT_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+extern void _tnl_vb_bind_arrays( GLcontext *ctx, GLint start, GLsizei count );
+
+extern void _tnl_array_import_init( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_context.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_context.c:1.3
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_context.c	Wed Jan 29 17:27:41 2003
@@ -0,0 +1,244 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "macros.h"
+#include "mtypes.h"
+#include "mem.h"
+#include "dlist.h"
+#include "light.h"
+#include "vtxfmt.h"
+
+#include "t_context.h"
+#include "t_array_api.h"
+#include "t_eval_api.h"
+#include "t_imm_alloc.h"
+#include "t_imm_api.h"
+#include "t_imm_exec.h"
+#include "t_imm_dlist.h"
+#include "t_pipeline.h"
+#include "tnl.h"
+
+#ifndef THREADS
+struct immediate *_tnl_CurrentInput = NULL;
+#endif
+
+
+void
+_tnl_MakeCurrent( GLcontext *ctx,
+		  GLframebuffer *drawBuffer,
+		  GLframebuffer *readBuffer )
+{
+#ifndef THREADS
+   SET_IMMEDIATE( ctx, TNL_CURRENT_IM(ctx) );
+#endif
+}
+
+
+static void
+install_driver_callbacks( GLcontext *ctx )
+{
+   ctx->Driver.NewList = _tnl_NewList;
+   ctx->Driver.EndList = _tnl_EndList;
+   ctx->Driver.FlushVertices = _tnl_flush_vertices;
+   ctx->Driver.MakeCurrent = _tnl_MakeCurrent;
+   ctx->Driver.BeginCallList = _tnl_BeginCallList;
+   ctx->Driver.EndCallList = _tnl_EndCallList;
+}
+
+
+
+GLboolean
+_tnl_CreateContext( GLcontext *ctx )
+{
+   TNLcontext *tnl;
+
+   /* Create the TNLcontext structure
+    */
+   ctx->swtnl_context = tnl = (TNLcontext *) CALLOC( sizeof(TNLcontext) );
+
+   if (!tnl) {
+      return GL_FALSE;
+   }
+
+   /* Initialize the VB.
+    */
+   tnl->vb.Size = MAX2( IMM_SIZE,
+			ctx->Const.MaxArrayLockSize + MAX_CLIPPED_VERTICES);
+
+
+   /* Initialize tnl state and tnl->vtxfmt.
+    */
+   _tnl_dlist_init( ctx );
+   _tnl_array_init( ctx );
+   _tnl_imm_init( ctx );
+   _tnl_eval_init( ctx );
+   _tnl_install_pipeline( ctx, _tnl_default_pipeline );
+
+
+   tnl->NeedProjCoords = GL_TRUE;
+   tnl->LoopbackDListCassettes = GL_FALSE;
+   tnl->CalcDListNormalLengths = GL_TRUE;
+
+   /* Hook our functions into exec and compile dispatch tables.
+    */
+   _mesa_install_exec_vtxfmt( ctx, &tnl->vtxfmt );
+
+   tnl->save_vtxfmt = tnl->vtxfmt;
+   tnl->save_vtxfmt.CallList = _mesa_save_CallList;	
+   tnl->save_vtxfmt.EvalMesh1 = _mesa_save_EvalMesh1;	
+   tnl->save_vtxfmt.EvalMesh2 = _mesa_save_EvalMesh2;
+   tnl->save_vtxfmt.Begin = _tnl_save_Begin;
+
+   _mesa_install_save_vtxfmt( ctx, &tnl->save_vtxfmt );
+
+
+   /* Set a few default values in the driver struct.
+    */
+   install_driver_callbacks(ctx);
+   ctx->Driver.NeedFlush = FLUSH_UPDATE_CURRENT;
+   ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
+   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
+
+   tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
+   tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
+   tnl->Driver.NotifyMaterialChange = _mesa_validate_all_lighting_tables;
+
+
+   
+   return GL_TRUE;
+}
+
+
+void
+_tnl_DestroyContext( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   _tnl_array_destroy( ctx );
+   _tnl_imm_destroy( ctx );
+   _tnl_destroy_pipeline( ctx );
+   if (tnl->freed_immediate) 
+     _tnl_free_immediate( ctx, tnl->freed_immediate );
+
+   FREE(tnl);
+   ctx->swtnl_context = 0;
+}
+
+
+void
+_tnl_InvalidateState( GLcontext *ctx, GLuint new_state )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   if (new_state & _NEW_ARRAY) {
+      struct immediate *IM = TNL_CURRENT_IM(ctx);
+      IM->ArrayEltFlags = ~ctx->Array._Enabled;
+      IM->ArrayEltFlush = (ctx->Array.LockCount 
+			   ? FLUSH_ELT_LAZY : FLUSH_ELT_EAGER);
+      IM->ArrayEltIncr = ctx->Array.Vertex.Enabled ? 1 : 0;
+      tnl->pipeline.run_input_changes |= ctx->Array.NewState; /* overkill */
+   }
+
+   tnl->pipeline.run_state_changes |= new_state;
+   tnl->pipeline.build_state_changes |= (new_state &
+					 tnl->pipeline.build_state_trigger);
+
+   tnl->eval.EvalNewState |= new_state;
+}
+
+
+void
+_tnl_wakeup_exec( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   install_driver_callbacks(ctx);
+   ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT;
+
+   /* Hook our functions into exec and compile dispatch tables.
+    */
+   _mesa_install_exec_vtxfmt( ctx, &tnl->vtxfmt );
+
+   /* Call all appropriate driver callbacks to revive state.
+    */
+   _tnl_MakeCurrent( ctx, ctx->DrawBuffer, ctx->ReadBuffer );
+
+   /* Assume we haven't been getting state updates either:
+    */
+   _tnl_InvalidateState( ctx, ~0 );
+   tnl->pipeline.run_input_changes = ~0;
+
+   if (ctx->Light.ColorMaterialEnabled) {
+      _mesa_update_color_material( ctx, ctx->Current.Color );
+   }
+
+}
+
+
+void
+_tnl_wakeup_save_exec( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   _tnl_wakeup_exec( ctx );
+   _mesa_install_save_vtxfmt( ctx, &tnl->save_vtxfmt );
+}
+
+
+void
+_tnl_need_projected_coords( GLcontext *ctx, GLboolean mode )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   if (tnl->NeedProjCoords != mode) {
+      tnl->NeedProjCoords = mode;
+      _tnl_InvalidateState( ctx, _NEW_PROJECTION );
+   }
+}
+
+void
+_tnl_need_dlist_loopback( GLcontext *ctx, GLboolean mode )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->LoopbackDListCassettes = mode;
+}
+
+void
+_tnl_need_dlist_norm_lengths( GLcontext *ctx, GLboolean mode )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->CalcDListNormalLengths = mode;
+}
+
+void
+_tnl_isolate_materials( GLcontext *ctx, GLboolean mode )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->IsolateMaterials = mode;
+}
Index: xc/extras/Mesa/src/tnl/t_context.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_context.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_context.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,587 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Author:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef _T_CONTEXT_H
+#define _T_CONTEXT_H
+
+#include "glheader.h"
+#include "mtypes.h"
+
+#include "math/m_matrix.h"
+#include "math/m_vector.h"
+#include "math/m_xform.h"
+
+
+#define MAX_PIPELINE_STAGES     30
+
+
+/* Numbers for sizing immediate structs.
+ */
+#define IMM_MAX_COPIED_VERTS  3
+#define IMM_MAXDATA          (216 + IMM_MAX_COPIED_VERTS)
+#define IMM_SIZE             (IMM_MAXDATA + MAX_CLIPPED_VERTICES)
+
+
+/* Values for IM->BeginState
+ */
+#define VERT_BEGIN_0    0x1	   /* glBegin (if initially inside beg/end) */
+#define VERT_BEGIN_1    0x2	   /* glBegin (if initially outside beg/end) */
+#define VERT_ERROR_0    0x4	   /* invalid_operation in initial state 0 */
+#define VERT_ERROR_1    0x8        /* invalid_operation in initial state 1 */
+
+
+/* Flags to be added to the primitive enum in VB->Primitive.
+ */
+#define PRIM_MODE_MASK  0xff    /* Extract the actual primitive */
+#define PRIM_BEGIN      0x100	/* The prim starts here (not wrapped) */
+#define PRIM_END        0x200	/* The prim ends in this VB (does not wrap) */
+#define PRIM_PARITY     0x400	/* The prim wrapped on an odd number of verts */
+#define PRIM_LAST       0x800   /* No more prims in the VB */
+
+
+/* Flags that describe the inputs and outputs of pipeline stages, and
+ * the contents of a vertex-cassette.
+ *
+ * 5 spare flags, rearrangement of eval flags can secure at least 3
+ * more.
+ */
+#define VERT_OBJ             _NEW_ARRAY_VERTEX
+#define VERT_RGBA            _NEW_ARRAY_COLOR
+#define VERT_NORM            _NEW_ARRAY_NORMAL
+#define VERT_INDEX           _NEW_ARRAY_INDEX
+#define VERT_EDGE            _NEW_ARRAY_EDGEFLAG
+#define VERT_SPEC_RGB        _NEW_ARRAY_SECONDARYCOLOR
+#define VERT_FOG_COORD       _NEW_ARRAY_FOGCOORD
+#define VERT_TEX0            _NEW_ARRAY_TEXCOORD_0
+#define VERT_TEX1            _NEW_ARRAY_TEXCOORD_1
+#define VERT_TEX2            _NEW_ARRAY_TEXCOORD_2
+#define VERT_TEX3            _NEW_ARRAY_TEXCOORD_3
+#define VERT_TEX4            _NEW_ARRAY_TEXCOORD_4
+#define VERT_TEX5            _NEW_ARRAY_TEXCOORD_5
+#define VERT_TEX6            _NEW_ARRAY_TEXCOORD_6
+#define VERT_TEX7            _NEW_ARRAY_TEXCOORD_7
+#define VERT_EVAL_C1         0x8000     /* imm only */
+#define VERT_EVAL_C2         0x10000    /* imm only */
+#define VERT_EVAL_P1         0x20000    /* imm only */
+#define VERT_EVAL_P2         0x40000    /* imm only */
+#define VERT_OBJ_3           0x80000    /* imm only */
+#define VERT_OBJ_4           0x100000   /* imm only */
+#define VERT_MATERIAL        0x200000   /* imm only, but tested in vb code */
+#define VERT_ELT             0x400000   /* imm only */
+#define VERT_BEGIN           0x800000   /* imm only, but tested in vb code */
+#define VERT_END             0x1000000  /* imm only, but tested in vb code */
+#define VERT_END_VB          0x2000000  /* imm only, but tested in vb code */
+#define VERT_POINT_SIZE      0x4000000  /* vb only, could reuse a bit */
+#define VERT_EYE             VERT_BEGIN /* vb only, reuse imm bit */
+#define VERT_CLIP            VERT_END   /* vb only, reuse imm bit*/
+
+
+/* Flags for IM->TexCoordSize.  Enough flags for 16 units.
+ */
+#define TEX_0_SIZE_3          (GLuint) 0x1
+#define TEX_0_SIZE_4          (GLuint) 0x1001
+#define TEX_SIZE_3(unit)      (TEX_0_SIZE_3<<unit)
+#define TEX_SIZE_4(unit)      (TEX_0_SIZE_4<<unit)
+
+
+/* Shorthands.
+ */
+#define VERT_EVAL_ANY      (VERT_EVAL_C1|VERT_EVAL_P1|	\
+                            VERT_EVAL_C2|VERT_EVAL_P2)
+
+#define VERT_OBJ_23       (VERT_OBJ_3|VERT_OBJ)
+#define VERT_OBJ_234      (VERT_OBJ_4|VERT_OBJ_23)
+
+#define VERT_TEX0_SHIFT 11
+
+#define VERT_TEX(i)        (VERT_TEX0 << i)
+
+#define VERT_TEX_ANY       (VERT_TEX0 |		\
+                            VERT_TEX1 |		\
+                            VERT_TEX2 |		\
+                            VERT_TEX3 |		\
+                            VERT_TEX4 |		\
+                            VERT_TEX5 |		\
+                            VERT_TEX6 |		\
+                            VERT_TEX7)
+
+#define VERT_FIXUP        (VERT_TEX_ANY |	\
+                           VERT_RGBA |		\
+                           VERT_SPEC_RGB |	\
+                           VERT_FOG_COORD |	\
+			   VERT_INDEX |		\
+                           VERT_EDGE |		\
+                           VERT_NORM)
+
+#define VERT_CURRENT_DATA  (VERT_FIXUP |	\
+			    VERT_MATERIAL)
+
+#define VERT_DATA          (VERT_TEX_ANY |	\
+			    VERT_RGBA |		\
+			    VERT_SPEC_RGB |	\
+			    VERT_FOG_COORD |	\
+                            VERT_INDEX |	\
+                            VERT_EDGE |		\
+                            VERT_NORM |		\
+	                    VERT_OBJ |	\
+                            VERT_MATERIAL |	\
+                            VERT_ELT |		\
+	                    VERT_EVAL_ANY)
+
+
+/* KW: Represents everything that can take place between a begin and
+ * end, and can represent multiple begin/end pairs.  Can be used to
+ * losslessly encode this information in display lists.
+ */
+struct immediate
+{
+   struct __GLcontextRec *backref;
+   GLuint id, ref_count;
+
+   /* This must be saved when immediates are shared in display lists.
+    */
+   GLuint CopyStart, Start, Count;
+   GLuint LastData;		/* count or count+1 */
+   GLuint AndFlag, OrFlag;
+   GLuint TexSize;		/* keep track of texcoord sizes */
+   GLuint BeginState, SavedBeginState;
+   GLuint LastPrimitive;
+
+   GLuint ArrayEltFlags;	/* precalc'ed for glArrayElt */
+   GLuint ArrayEltIncr;
+   GLuint ArrayEltFlush;
+
+#define FLUSH_ELT_EAGER 0x1
+#define FLUSH_ELT_LAZY 0x2
+   GLuint FlushElt;
+
+   GLuint MaxTextureUnits;	/* precalc'ed for glMultiTexCoordARB */
+
+   /* Temporary values created when vertices are copied into the
+    * first 3 slots of the struct:
+    */
+   GLuint CopyOrFlag;
+   GLuint CopyAndFlag;
+   GLuint CopyTexSize;
+   GLuint Evaluated;
+
+
+   /* allocate storage for these on demand:
+    */
+   struct gl_material (*Material)[2];
+   GLuint *MaterialMask;
+   GLuint LastMaterial;
+   GLuint MaterialOrMask;
+   GLuint MaterialAndMask;
+
+   GLfloat (*TexCoord[MAX_TEXTURE_UNITS])[4];
+
+   GLuint  Primitive[IMM_SIZE];	    /* BEGIN/END */
+   GLuint  PrimitiveLength[IMM_SIZE]; /* BEGIN/END */
+   GLuint  Flag[IMM_SIZE];	    /* VERT_* flags */
+   GLfloat Color[IMM_SIZE][4];
+   GLfloat Obj[IMM_SIZE][4];
+   GLfloat Normal[IMM_SIZE][3];
+   GLfloat *NormalLengthPtr;
+   GLfloat TexCoord0[IMM_SIZE][4];  /* just VERT_TEX0 */
+   GLuint  Elt[IMM_SIZE];
+   GLubyte EdgeFlag[IMM_SIZE];
+   GLuint  Index[IMM_SIZE];
+   GLfloat SecondaryColor[IMM_SIZE][4];
+   GLfloat FogCoord[IMM_SIZE];
+};
+
+
+struct vertex_arrays
+{
+   GLvector4f  Obj;
+   GLvector3f  Normal;
+   struct gl_client_array Color;
+   struct gl_client_array SecondaryColor;
+   GLvector1ui Index;
+   GLvector1ub EdgeFlag;
+   GLvector4f  TexCoord[MAX_TEXTURE_UNITS];
+   GLvector1ui Elt;
+   GLvector1f  FogCoord;
+};
+
+
+typedef struct gl_material GLmaterial;
+
+/* Contains the current state of a running pipeline.
+ */
+typedef struct vertex_buffer
+{
+   /* Constant over life of the vertex_buffer.
+    */
+   GLuint Size;
+
+   /* Constant over the pipeline.
+    */
+   GLuint     Count;		                /* for everything except Elts */
+   GLuint     FirstClipped;	                /* temp verts for clipping */
+   GLuint     FirstPrimitive;	                /* usually zero */
+
+   /* Pointers to current data.
+    */
+   GLuint      *Elts;		                /* VERT_ELT */
+   GLvector4f  *ObjPtr;		                /* VERT_OBJ */
+   GLvector4f  *EyePtr;		                /* VERT_EYE */
+   GLvector4f  *ClipPtr;	                /* VERT_CLIP */
+   GLvector4f  *ProjectedClipPtr;               /* VERT_CLIP (2) */
+   GLubyte     ClipOrMask;	                /* VERT_CLIP (3) */
+   GLubyte     *ClipMask;		        /* VERT_CLIP (4) */
+   GLvector3f  *NormalPtr;	                /* VERT_NORM */
+   GLfloat     *NormalLengthPtr;	        /* VERT_NORM */
+   GLboolean   *EdgeFlag;	                /* VERT_EDGE */
+   GLvector4f  *TexCoordPtr[MAX_TEXTURE_UNITS];	/* VERT_TEX_0..n */
+   GLvector1ui *IndexPtr[2];	                /* VERT_INDEX */
+   struct gl_client_array *ColorPtr[2];	                /* VERT_RGBA */
+   struct gl_client_array *SecondaryColorPtr[2];         /* VERT_SPEC_RGB */
+   GLvector1f  *FogCoordPtr;	                /* VERT_FOG_COORD */
+   GLvector1f  *PointSizePtr;	                /* VERT_POINT_SIZE */
+   GLmaterial (*Material)[2];                   /* VERT_MATERIAL, optional */
+   GLuint      *MaterialMask;	                /* VERT_MATERIAL, optional */
+   GLuint      *Flag;		                /* VERT_* flags, optional */
+   GLuint      *Primitive;	                /* GL_(mode)|PRIM_* flags */
+   GLuint      *PrimitiveLength;	        /* integers */
+
+
+   GLuint importable_data;
+   void *import_source;
+   void (*import_data)( GLcontext *ctx, GLuint flags, GLuint vecflags );
+   /* Callback to the provider of the untransformed input for the
+    * render stage (or other stages) to call if they need to write into
+    * write-protected arrays, or fixup the stride on input arrays.
+    *
+    * This is currently only necessary for client arrays that make it
+    * as far down the pipeline as the render stage.
+    */
+
+   GLuint LastClipped;
+   /* Private data from _tnl_render_stage that has no business being
+    * in this struct.
+    */
+
+} TNLvertexbuffer;
+
+
+
+/* Describes an individual operation on the pipeline.
+ */
+struct gl_pipeline_stage {
+   const char *name;
+   GLuint check_state;		/* All state referenced in check() --
+				 * When is the pipeline_stage struct
+				 * itself invalidated?  Must be
+				 * constant.
+				 */
+
+   /* Usually constant or set by the 'check' callback:
+    */
+   GLuint run_state;		/* All state referenced in run() --
+				 * When is the cached output of the
+				 * stage invalidated?
+				 */
+
+   GLboolean active;		/* True if runnable in current state */
+   GLuint inputs;		/* VERT_* inputs to the stage */
+   GLuint outputs;		/* VERT_* outputs of the stage */
+
+   /* Set in _tnl_run_pipeline():
+    */
+   GLuint changed_inputs;	/* Generated value -- inputs to the
+				 * stage that have changed since last
+				 * call to 'run'.
+				 */
+
+   /* Private data for the pipeline stage:
+    */
+   void *privatePtr;
+
+   /* Free private data.  May not be null.
+    */
+   void (*destroy)( struct gl_pipeline_stage * );
+
+   /* Called from _tnl_validate_pipeline().  Must update all fields in
+    * the pipeline_stage struct for the current state.
+    */
+   void (*check)( GLcontext *ctx, struct gl_pipeline_stage * );
+
+   /* Called from _tnl_run_pipeline().  The stage.changed_inputs value
+    * encodes all inputs to thee struct which have changed.  If
+    * non-zero, recompute all affected outputs of the stage, otherwise
+    * execute any 'sideeffects' of the stage.
+    *
+    * Return value: GL_TRUE - keep going
+    *               GL_FALSE - finished pipeline
+    */
+   GLboolean (*run)( GLcontext *ctx, struct gl_pipeline_stage * );
+};
+
+
+struct gl_pipeline {
+   GLuint build_state_trigger;	  /* state changes which require build */
+   GLuint build_state_changes;    /* state changes since last build */
+   GLuint run_state_changes;	  /* state changes since last run */
+   GLuint run_input_changes;	  /* VERT_* changes since last run */
+   GLuint inputs;		  /* VERT_* inputs to pipeline */
+   struct gl_pipeline_stage stages[MAX_PIPELINE_STAGES+1];
+   GLuint nr_stages;
+};
+
+
+struct tnl_eval_store {
+   GLuint EvalMap1Flags;
+   GLuint EvalMap2Flags;
+   GLuint EvalNewState;
+   struct immediate *im;	/* used for temporary data */
+};
+
+
+typedef void (*points_func)( GLcontext *ctx, GLuint first, GLuint last );
+typedef void (*line_func)( GLcontext *ctx, GLuint v1, GLuint v2 );
+typedef void (*triangle_func)( GLcontext *ctx,
+                               GLuint v1, GLuint v2, GLuint v3 );
+typedef void (*quad_func)( GLcontext *ctx, GLuint v1, GLuint v2,
+                           GLuint v3, GLuint v4 );
+typedef void (*render_func)( GLcontext *ctx, GLuint start, GLuint count,
+			     GLuint flags );
+typedef void (*interp_func)( GLcontext *ctx,
+			     GLfloat t, GLuint dst, GLuint out, GLuint in,
+			     GLboolean force_boundary );
+typedef void (*copy_pv_func)( GLcontext *ctx, GLuint dst, GLuint src );
+typedef void (*setup_func)( GLcontext *ctx,
+			    GLuint start, GLuint end,
+			    GLuint new_inputs);
+
+
+struct tnl_device_driver {
+   /***
+    *** TNL Pipeline
+    ***/
+
+   void (*RunPipeline)(GLcontext *ctx);
+   /* Replaces PipelineStart/PipelineFinish -- intended to allow
+    * drivers to wrap _tnl_run_pipeline() with code to validate state
+    * and grab/release hardware locks.  
+    */
+
+   void (*NotifyMaterialChange)(GLcontext *ctx);
+   /* Alert tnl-aware drivers of changes to material.
+    */
+
+   GLboolean (*NotifyBegin)(GLcontext *ctx, GLenum p);
+   /* Allow drivers to hook in optimized begin/end engines.
+    * Return value:  GL_TRUE - driver handled the begin
+    *                GL_FALSE - driver didn't handle the begin
+    */
+
+   /***
+    *** Rendering -- These functions called only from t_vb_render.c
+    ***/
+   struct {
+      void (*Start)(GLcontext *ctx);
+      void (*Finish)(GLcontext *ctx);
+      /* Called before and after all rendering operations, including DrawPixels,
+       * ReadPixels, Bitmap, span functions, and CopyTexImage, etc commands.
+       * These are a suitable place for grabbing/releasing hardware locks.
+       */
+
+      void (*PrimitiveNotify)(GLcontext *ctx, GLenum mode);
+      /* Called between RenderStart() and RenderFinish() to indicate the
+       * type of primitive we're about to draw.  Mode will be one of the
+       * modes accepted by glBegin().
+       */
+
+      interp_func Interp;
+      /* The interp function is called by the clipping routines when we need
+       * to generate an interpolated vertex.  All pertinant vertex ancilliary
+       * data should be computed by interpolating between the 'in' and 'out'
+       * vertices.
+       */
+
+      copy_pv_func CopyPV;
+      /* The copy function is used to make a copy of a vertex.  All pertinant
+       * vertex attributes should be copied.
+       */
+
+      void (*ClippedPolygon)( GLcontext *ctx, const GLuint *elts, GLuint n );
+      /* Render a polygon with <n> vertices whose indexes are in the <elts>
+       * array.
+       */
+
+      void (*ClippedLine)( GLcontext *ctx, GLuint v0, GLuint v1 );
+      /* Render a line between the two vertices given by indexes v0 and v1. */
+
+      points_func           Points; /* must now respect vb->elts */
+      line_func             Line;
+      triangle_func         Triangle;
+      quad_func             Quad;
+      /* These functions are called in order to render points, lines,
+       * triangles and quads.  These are only called via the T&L module.
+       */
+
+      render_func          *PrimTabVerts;
+      render_func          *PrimTabElts;
+      /* Render whole unclipped primitives (points, lines, linestrips,
+       * lineloops, etc).  The tables are indexed by the GL enum of the
+       * primitive to be rendered.  RenderTabVerts is used for non-indexed
+       * arrays of vertices.  RenderTabElts is used for indexed arrays of
+       * vertices.
+       */
+
+      void (*ResetLineStipple)( GLcontext *ctx );
+      /* Reset the hardware's line stipple counter.
+       */
+
+      setup_func BuildVertices;
+      /* This function is called whenever new vertices are required for
+       * rendering.  The vertices in question are those n such that start
+       * <= n < end.  The new_inputs parameter indicates those fields of
+       * the vertex which need to be updated, if only a partial repair of
+       * the vertex is required.
+       *
+       * This function is called only from _tnl_render_stage in tnl/t_render.c.
+       */
+      
+
+      GLboolean (*Multipass)( GLcontext *ctx, GLuint passno );
+      /* Driver may request additional render passes by returning GL_TRUE
+       * when this function is called.  This function will be called
+       * after the first pass, and passes will be made until the function
+       * returns GL_FALSE.  If no function is registered, only one pass
+       * is made.
+       *
+       * This function will be first invoked with passno == 1.
+       */
+   } Render;
+};
+   
+
+typedef struct {
+
+   /* Driver interface.
+    */
+   struct tnl_device_driver Driver;
+
+   /* Track whether the module is active.
+    */
+   GLboolean bound_exec;
+
+   /* Display list extensions
+    */
+   GLuint opcode_vertex_cassette;
+
+   /* Pipeline
+    */
+   struct gl_pipeline pipeline;
+   struct vertex_buffer vb;
+
+   /* GLvectors for binding to vb:
+    */
+   struct vertex_arrays imm_inputs;
+   struct vertex_arrays array_inputs;
+   GLuint *tmp_primitive;
+   GLuint *tmp_primitive_length;
+
+   /* Set when executing an internally generated begin/end object.  If
+    * such an object is encountered in a display list, it will be
+    * replayed only if the list is outside any existing begin/end
+    * objects.  
+    */
+   GLboolean ReplayHardBeginEnd;
+
+   /* Note which vertices need copying over succesive immediates.
+    * Will add save versions to precompute vertex copying where
+    * possible.
+    */
+   struct immediate *ExecCopySource;
+   GLuint ExecCopyCount;
+   GLuint ExecCopyElts[IMM_MAX_COPIED_VERTS];
+   GLuint ExecCopyTexSize;
+   GLuint ExecParity;
+
+   GLuint DlistPrimitive;
+   GLuint DlistPrimitiveLength;
+   GLuint DlistLastPrimitive;
+
+   /* Cache a single free immediate (refcount == 0)
+    */
+   struct immediate *freed_immediate;   
+
+   /* Probably need a better configuration mechanism:
+    */
+   GLboolean NeedProjCoords;
+   GLboolean LoopbackDListCassettes;
+   GLboolean CalcDListNormalLengths;
+   GLboolean IsolateMaterials;
+
+   /* Derived state and storage for _tnl_eval_vb:
+    */
+   struct tnl_eval_store eval;
+
+   /* Functions to be plugged into dispatch when tnl is active.
+    */
+   GLvertexformat vtxfmt;
+   GLvertexformat save_vtxfmt;
+
+} TNLcontext;
+
+
+
+#define TNL_CONTEXT(ctx) ((TNLcontext *)(ctx->swtnl_context))
+#define TNL_CURRENT_IM(ctx) ((struct immediate *)(ctx->swtnl_im))
+
+
+#define TYPE_IDX(t) ((t) & 0xf)
+#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1      /* 0xa + 1 */
+
+extern void _tnl_MakeCurrent( GLcontext *ctx,
+			      GLframebuffer *drawBuffer,
+			      GLframebuffer *readBuffer );
+
+
+/*
+ * Macros for fetching current input buffer.
+ */
+#ifdef THREADS
+#define GET_IMMEDIATE  struct immediate *IM = TNL_CURRENT_IM(((GLcontext *) (_glapi_Context ? _glapi_Context : _glapi_get_context())))
+#define SET_IMMEDIATE(ctx, im)  ctx->swtnl_im = (void *)im
+#else
+extern struct immediate *_tnl_CurrentInput;
+#define GET_IMMEDIATE struct immediate *IM = _tnl_CurrentInput
+#define SET_IMMEDIATE(ctx, im)			\
+do {						\
+   ctx->swtnl_im = (void *)im;			\
+   _tnl_CurrentInput = im;			\
+} while (0)
+#endif
+
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_eval_api.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_eval_api.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_eval_api.c	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,244 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+#include "math/m_eval.h"
+
+#include "t_eval_api.h"
+#include "t_imm_api.h"
+#include "t_imm_alloc.h"
+#include "t_imm_exec.h"
+
+
+
+
+
+/* KW: If are compiling, we don't know whether eval will produce a
+ *     vertex when it is run in the future.  If this is pure immediate
+ *     mode, eval is a noop if neither vertex map is enabled.
+ *
+ *     Thus we need to have a check in the display list code or
+ *     elsewhere for eval(1,2) vertices in the case where
+ *     map(1,2)_vertex is disabled, and to purge those vertices from
+ *     the vb.
+ */
+void
+_tnl_exec_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint i;
+   GLfloat u, du;
+   GLenum prim;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   switch (mode) {
+      case GL_POINT:
+         prim = GL_POINTS;
+         break;
+      case GL_LINE:
+         prim = GL_LINE_STRIP;
+         break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
+         return;
+   }
+
+   /* No effect if vertex maps disabled.
+    */
+   if (!ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3)
+      return;
+
+   du = ctx->Eval.MapGrid1du;
+   u = ctx->Eval.MapGrid1u1 + i1 * du;
+
+   /* Need to turn off compilation -- this is already saved, and the
+    * coordinates generated and the test above depend on state that
+    * may change before the list is executed.
+    *
+    * TODO: Anaylse display lists to determine if this state is
+    * constant.
+    *
+    * State to watch:
+    *       - enabled maps
+    *       - map state for each enabled map, including control points
+    *       - grid state
+    *
+    * Could alternatively cache individual maps in arrays, rather than
+    * building immediates.  
+    */
+   {
+      GLboolean compiling = ctx->CompileFlag;
+      TNLcontext *tnl = TNL_CONTEXT(ctx);
+      struct immediate *im = TNL_CURRENT_IM(ctx);
+      GLboolean (*NotifyBegin)(GLcontext *ctx, GLenum p);
+
+      NotifyBegin = tnl->Driver.NotifyBegin;
+      tnl->Driver.NotifyBegin = 0;
+
+      if (compiling) {
+	 struct immediate *IM = _tnl_alloc_immediate( ctx );
+	 FLUSH_VERTICES( ctx, 0 );
+	 SET_IMMEDIATE( ctx, IM );
+	 IM->ref_count++;	 
+	 ctx->CompileFlag = GL_FALSE;
+      }
+
+      _tnl_Begin( prim );
+      for (i=i1;i<=i2;i++,u+=du) {
+	 _tnl_eval_coord1f( ctx, u );
+      }
+      _tnl_end(ctx);
+
+      /* Need this for replay *and* compile:
+       */
+      FLUSH_VERTICES( ctx, 0 );
+      tnl->Driver.NotifyBegin = NotifyBegin;
+
+      if (compiling) {
+	 TNL_CURRENT_IM(ctx)->ref_count--;
+	 ASSERT( TNL_CURRENT_IM(ctx)->ref_count == 0 );
+	 _tnl_free_immediate( ctx, TNL_CURRENT_IM(ctx) );
+	 SET_IMMEDIATE( ctx, im );
+	 ctx->CompileFlag = GL_TRUE;
+      }
+   }
+}
+
+
+
+void
+_tnl_exec_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint i, j;
+   GLfloat u, du, v, dv, v1, u1;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   /* No effect if vertex maps disabled.
+    */
+   if (!ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3)
+      return;
+
+
+   du = ctx->Eval.MapGrid2du;
+   dv = ctx->Eval.MapGrid2dv;
+   v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
+   u1 = ctx->Eval.MapGrid2u1 + i1 * du;
+
+   /* Need to turn off compilation -- this is already saved, and the
+    * coordinates generated and the test above depend on state that
+    * may change before the list is executed.
+    */
+   {
+      GLboolean compiling = ctx->CompileFlag;
+      struct immediate *im = TNL_CURRENT_IM(ctx);
+      TNLcontext *tnl = TNL_CONTEXT(ctx);
+      GLboolean (*NotifyBegin)(GLcontext *ctx, GLenum p);
+
+      NotifyBegin = tnl->Driver.NotifyBegin;
+      tnl->Driver.NotifyBegin = 0;
+
+      if (compiling) {
+	 struct immediate *IM =  _tnl_alloc_immediate( ctx );
+	 FLUSH_VERTICES( ctx, 0 );
+	 SET_IMMEDIATE( ctx, IM );
+	 IM->ref_count++;	 
+	 ctx->CompileFlag = GL_FALSE;
+      }
+
+      switch (mode) {
+      case GL_POINT:
+	 _tnl_Begin( GL_POINTS );
+	 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
+	    for (u=u1,i=i1;i<=i2;i++,u+=du) {
+	       _tnl_eval_coord2f( ctx, u, v );
+	    }
+	 }
+	 _tnl_end(ctx);
+	 break;
+      case GL_LINE:
+	 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
+	    _tnl_Begin( GL_LINE_STRIP );
+	    for (u=u1,i=i1;i<=i2;i++,u+=du) {
+	       _tnl_eval_coord2f( ctx, u, v );
+	    }
+	    _tnl_end(ctx);
+	 }
+	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
+	    _tnl_Begin( GL_LINE_STRIP );
+	    for (v=v1,j=j1;j<=j2;j++,v+=dv) {
+	       _tnl_eval_coord2f( ctx, u, v );
+	    }
+	    _tnl_end(ctx);
+	 }
+	 break;
+      case GL_FILL:
+	 for (v=v1,j=j1;j<j2;j++,v+=dv) {
+	    _tnl_Begin( GL_TRIANGLE_STRIP );
+	    for (u=u1,i=i1;i<=i2;i++,u+=du) {
+	       _tnl_eval_coord2f( ctx, u, v );
+	       _tnl_eval_coord2f( ctx, u, v+dv );
+	    }
+	    _tnl_end(ctx);
+	 }
+	 break;
+      default:
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
+	 return;
+      }
+
+      /* Need this for replay *and* compile:
+       */
+      FLUSH_VERTICES( ctx, 0 );
+      tnl->Driver.NotifyBegin = NotifyBegin;
+	 
+      if (compiling) {
+	 TNL_CURRENT_IM(ctx)->ref_count--;
+	 _tnl_free_immediate( ctx, TNL_CURRENT_IM( ctx ) );
+	 SET_IMMEDIATE( ctx, im );
+	 ctx->CompileFlag = GL_TRUE;
+      }
+   }
+}
+
+
+
+void _tnl_eval_init( GLcontext *ctx )
+{
+   GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt);
+   vfmt->EvalMesh1 = _tnl_exec_EvalMesh1;
+   vfmt->EvalMesh2 = _tnl_exec_EvalMesh2;
+}
Index: xc/extras/Mesa/src/tnl/t_eval_api.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_eval_api.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_eval_api.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,43 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _T_EVAL_H
+#define _T_EVAL_H
+
+
+#include "mtypes.h"
+#include "t_context.h"
+
+/* Use _mesa_save_EvalMesh{1,2} to save these to display lists.
+ */
+extern void _tnl_exec_EvalMesh1( GLenum mode, GLint i1, GLint i2 );
+
+extern void _tnl_exec_EvalMesh2( GLenum mode, GLint i1, GLint i2,
+				 GLint j1, GLint j2 );
+
+void _tnl_eval_init( GLcontext *ctx );
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_alloc.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_alloc.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_alloc.c	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,146 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "mem.h"
+#include "mtypes.h"
+
+#include "t_imm_alloc.h"
+
+
+static int id = 0;  /* give each struct immediate a unique ID number */
+
+static struct immediate *real_alloc_immediate( GLcontext *ctx )
+{
+   struct immediate *IM = ALIGN_MALLOC_STRUCT( immediate, 32 );
+   GLuint j;
+
+   if (!IM)
+      return 0;
+
+/*     memset(IM, 0, sizeof(*IM)); */
+
+   IM->id = id++;
+   IM->ref_count = 0;
+   IM->backref = ctx;
+   IM->FlushElt = 0;
+   IM->LastPrimitive = IMM_MAX_COPIED_VERTS;
+   IM->Count = IMM_MAX_COPIED_VERTS;
+   IM->Start = IMM_MAX_COPIED_VERTS;
+   IM->Material = 0;
+   IM->MaterialMask = 0;
+   IM->MaxTextureUnits = ctx->Const.MaxTextureUnits;
+   IM->TexSize = 0;
+   IM->NormalLengthPtr = 0;
+
+   IM->CopyTexSize = 0;
+   IM->CopyStart = IM->Start;
+
+
+   /* TexCoord0 is special.
+    */
+   IM->TexCoord[0] = IM->TexCoord0;
+
+   for (j = 1; j < ctx->Const.MaxTextureUnits; j++) {
+      IM->TexCoord[j] = (GLfloat (*)[4])
+         ALIGN_MALLOC( IMM_SIZE * sizeof(GLfloat) * 4, 32 );
+   }
+
+   /* KW: Removed initialization of normals as these are now treated
+    * identically to all other data types.
+    */
+
+   MEMSET(IM->Flag, 0, sizeof(IM->Flag));
+   MEMSET(IM->Normal, 0.0 , sizeof(IM->Normal));
+
+   return IM;
+}
+
+
+static void real_free_immediate( struct immediate *IM )
+{
+   static int freed = 0;
+   GLuint j;
+
+   if (IM->Material) {
+      FREE( IM->Material );
+      FREE( IM->MaterialMask );
+      IM->Material = 0;
+      IM->MaterialMask = 0;
+   }
+
+   for (j = 1; j < IM->MaxTextureUnits; j++)
+      ALIGN_FREE( IM->TexCoord[j] );
+
+   if (IM->NormalLengthPtr)
+      ALIGN_FREE( IM->NormalLengthPtr );
+
+   ALIGN_FREE( IM );
+   freed++;
+/*     printf("outstanding %d\n", id - freed);    */
+}
+
+
+/* Cache a single allocated immediate struct.
+ */
+struct immediate *_tnl_alloc_immediate( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct immediate *tmp = tnl->freed_immediate;
+   
+   if (tmp) {
+      tnl->freed_immediate = 0;
+      return tmp;
+   }
+   else
+      return real_alloc_immediate( ctx );
+}
+
+/* May be called after tnl is destroyed.
+ */
+void _tnl_free_immediate( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   ASSERT(IM->ref_count == 0);
+
+   if (IM->NormalLengthPtr) {
+      ALIGN_FREE(IM->NormalLengthPtr);
+      IM->NormalLengthPtr = NULL;
+   }
+
+   if (!tnl) {
+      real_free_immediate( IM );
+   } 
+   else {
+      if (tnl->freed_immediate)
+	 real_free_immediate( tnl->freed_immediate );
+      
+      tnl->freed_immediate = IM;
+   }
+}
Index: xc/extras/Mesa/src/tnl/t_imm_alloc.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_alloc.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_alloc.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,39 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _T_IMM_ALLOC_H
+#define _T_IMM_ALLOC_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+
+extern struct immediate *_tnl_alloc_immediate( GLcontext *ctx );
+
+extern void _tnl_free_immediate( GLcontext *ctx, struct immediate *im );
+
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_api.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_api.c:1.4
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_api.c	Sat Feb 15 17:18:46 2003
@@ -0,0 +1,1334 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+
+#include "glheader.h"
+#include "context.h"
+#include "dlist.h"
+#include "enums.h"
+#include "light.h"
+#include "mem.h"
+#include "state.h"
+#include "colormac.h"
+#include "macros.h"
+
+#include "t_context.h"
+#include "t_imm_api.h"
+#include "t_imm_elt.h"
+#include "t_imm_exec.h"
+#include "t_imm_dlist.h"
+
+
+/* A cassette is full or flushed on a statechange.
+ */
+void _tnl_flush_immediate( struct immediate *IM )
+{
+   GLcontext *ctx = IM->backref;
+
+   if (MESA_VERBOSE & VERBOSE_IMMEDIATE)
+      fprintf(stderr, "_tnl_flush_immediate IM: %d compiling: %d\n",
+	      IM->id, ctx->CompileFlag);
+
+   if (IM->FlushElt == FLUSH_ELT_EAGER) {
+      _tnl_translate_array_elts( ctx, IM, IM->LastPrimitive, IM->Count );
+   }
+
+   /* Mark the last primitive:
+    */
+   IM->PrimitiveLength[IM->LastPrimitive] = IM->Count - IM->LastPrimitive;
+   IM->Primitive[IM->LastPrimitive] |= PRIM_LAST;
+
+   if (ctx->CompileFlag)
+      _tnl_compile_cassette( ctx, IM );
+   else
+      _tnl_execute_cassette( ctx, IM );
+}
+
+
+/* Hook for ctx->Driver.FlushVertices:
+ */
+void _tnl_flush_vertices( GLcontext *ctx, GLuint flags )
+{
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_IMMEDIATE)
+      fprintf( stderr, 
+	       "_tnl_flush_vertices flags %x IM(%d) %d..%d Flag[%d]: %x\n", 
+	       flags, IM->id, IM->Start, IM->Count, IM->Start,
+	       IM->Flag[IM->Start]);
+
+   if (IM->Flag[IM->Start])
+      if ((flags & FLUSH_UPDATE_CURRENT) || 
+	  IM->Count > IM->Start ||
+	  (IM->Flag[IM->Start] & (VERT_BEGIN|VERT_END)))
+	 _tnl_flush_immediate( IM );
+}
+
+
+
+
+void
+_tnl_save_Begin( GLenum mode )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+   GLuint inflags, state;
+
+/*     fprintf(stderr, "%s: before: %x\n", __FUNCTION__, IM->BeginState); */
+
+   if (mode > GL_POLYGON) {
+      _mesa_compile_error( ctx, GL_INVALID_ENUM, "_tnl_Begin" );
+      return;
+   }
+
+   if (ctx->NewState)
+      _mesa_update_state(ctx);
+
+   if (IM->Count > IMM_MAXDATA-8) {
+      _tnl_flush_immediate( IM );
+      IM = TNL_CURRENT_IM(ctx);
+   }
+
+   /* Check for and flush buffered vertices from internal operations.
+    */
+   if (IM->SavedBeginState) {
+      _tnl_flush_immediate( IM );
+      IM = TNL_CURRENT_IM(ctx);
+      IM->BeginState = IM->SavedBeginState;
+      IM->SavedBeginState = 0;
+   }
+
+   state = IM->BeginState;
+   inflags = state & (VERT_BEGIN_0|VERT_BEGIN_1);
+   state |= inflags << 2;	/* set error conditions */
+
+   if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
+   {
+      GLuint count = IM->Count;
+      GLuint last = IM->LastPrimitive;
+
+      state |= (VERT_BEGIN_0|VERT_BEGIN_1);
+      IM->Flag[count] |= VERT_BEGIN;
+      IM->Primitive[count] = mode | PRIM_BEGIN;
+      IM->PrimitiveLength[IM->LastPrimitive] = count - IM->LastPrimitive;
+      IM->LastPrimitive = count;
+
+      /* Not quite right.  Need to use the fallback '_aa_ArrayElement'
+       * when not known to be inside begin/end and arrays are
+       * unlocked.  
+       */
+      if (IM->FlushElt == FLUSH_ELT_EAGER) {
+	 _tnl_translate_array_elts( ctx, IM, last, count );
+      }
+   }
+
+   ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
+   IM->BeginState = state;
+
+   /* Update save_primitive now.  Don't touch ExecPrimitive as this is
+    * updated in the replay of this cassette if we are in
+    * COMPILE_AND_EXECUTE mode.
+    */
+   if (ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN)
+      ctx->Driver.CurrentSavePrimitive = PRIM_INSIDE_UNKNOWN_PRIM;
+   else if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END)
+      ctx->Driver.CurrentSavePrimitive = mode;
+}
+
+
+void
+_tnl_Begin( GLenum mode )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   ASSERT (!ctx->CompileFlag);
+
+   if (mode > GL_POLYGON) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "_tnl_Begin" );
+      return;
+   }
+
+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "_tnl_Begin" );
+      return;
+   }
+
+   if (ctx->NewState)
+      _mesa_update_state(ctx);
+
+   {
+      struct immediate *IM = TNL_CURRENT_IM(ctx);
+      if (IM->Count > IMM_MAXDATA-8) {
+	 _tnl_flush_immediate( IM );
+	 IM = TNL_CURRENT_IM(ctx);
+      }
+   }
+
+
+   {
+      struct immediate *IM = TNL_CURRENT_IM(ctx);
+      GLuint count = IM->Count;
+      GLuint last = IM->LastPrimitive;
+
+      if (IM->Start == IM->Count &&
+	  tnl->Driver.NotifyBegin &&
+	  tnl->Driver.NotifyBegin( ctx, mode )) {
+	 return;
+      }
+
+      assert( (IM->SavedBeginState & (VERT_BEGIN_0|VERT_BEGIN_1)) == 0 );
+      assert( (IM->BeginState & (VERT_BEGIN_0|VERT_BEGIN_1)) == 0 );
+
+      /* Not quite right.  Need to use the fallback '_aa_ArrayElement'
+       * when not known to be inside begin/end and arrays are
+       * unlocked.  
+       */
+      if (IM->FlushElt == FLUSH_ELT_EAGER) {
+	 _tnl_translate_array_elts( ctx, IM, last, count );
+      }
+
+      IM->Flag[count] |= VERT_BEGIN;
+      IM->Primitive[count] = mode | PRIM_BEGIN;
+      IM->PrimitiveLength[last] = count - last;
+      IM->LastPrimitive = count;
+      IM->BeginState = (VERT_BEGIN_0|VERT_BEGIN_1);
+
+      ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
+      ctx->Driver.CurrentExecPrimitive = mode;
+   }
+}
+
+
+/* Function which allows operations like 'glRectf' to decompose to a
+ * begin/end object and vertices without worrying about what happens
+ * with display lists.
+ */
+GLboolean
+_tnl_hard_begin( GLcontext *ctx, GLenum p )
+{
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   if (!ctx->CompileFlag) {
+      /* If not compiling, treat as a normal begin().
+       */
+/*        fprintf(stderr, "%s: treating as glBegin\n", __FUNCTION__); */
+      glBegin( p );
+      return GL_TRUE;
+   }
+   else {
+      /* Otherwise, need to do special processing to preserve the
+       * condition that these vertices will only be replayed outside
+       * future begin/end objects.
+       */
+      struct immediate *IM = TNL_CURRENT_IM(ctx);
+
+      if (ctx->NewState)
+	 _mesa_update_state(ctx);
+
+      if (IM->Count > IMM_MAXDATA-8) {
+	 _tnl_flush_immediate( IM );
+	 IM = TNL_CURRENT_IM(ctx);
+      }
+
+      /* A lot depends on the degree to which the display list has
+       * constrained the possible begin/end states at this point:
+       */
+      switch (IM->BeginState & (VERT_BEGIN_0|VERT_BEGIN_1)) {
+      case VERT_BEGIN_0|VERT_BEGIN_1:
+	 /* This is an immediate known to be inside a begin/end object.
+	  */
+	 ASSERT(ctx->Driver.CurrentSavePrimitive <= GL_POLYGON);
+	 IM->BeginState |= (VERT_ERROR_1|VERT_ERROR_0);
+	 return GL_FALSE;
+
+      case VERT_BEGIN_0:
+      case VERT_BEGIN_1:
+	 /* This is a display-list immediate in an unknown begin/end
+	  * state.  Assert it is empty and convert it to a 'hard' one.
+	  */
+	 ASSERT(IM->SavedBeginState == 0);
+	 ASSERT(ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN);
+
+	 /* Push current beginstate, to be restored later.  Don't worry
+	  * about raising errors.
+	  */
+	 IM->SavedBeginState = IM->BeginState;
+
+	 /* FALLTHROUGH */
+
+      case 0:
+	 /* Unless we have fallen through, this is an immediate known to
+	  * be outside begin/end objects.
+	  */
+	 ASSERT(ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN ||
+		ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END);
+	 ASSERT (IM->FlushElt != FLUSH_ELT_EAGER);
+
+	 IM->BeginState |= VERT_BEGIN_0|VERT_BEGIN_1;
+	 IM->Flag[IM->Count] |= VERT_BEGIN;
+	 IM->Primitive[IM->Count] = p | PRIM_BEGIN;
+	 IM->PrimitiveLength[IM->LastPrimitive] = IM->Count - IM->LastPrimitive;
+	 IM->LastPrimitive = IM->Count;
+
+	 /* This is necessary as this immediate will not be flushed in
+	  * _tnl_end() -- we leave it active, hoping to pick up more
+	  * vertices before the next state change.
+	  */
+	 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
+	 return GL_TRUE;
+
+      default:
+	 assert (0);
+	 return GL_TRUE;
+      }
+   }
+}
+
+
+
+
+
+
+/* Both streams now outside begin/end.
+ *
+ * Leave SavedBeginState untouched -- attempt to gather several
+ * rects/arrays together in a single immediate struct.
+ */
+void
+_tnl_end( GLcontext *ctx )
+{
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+   GLuint state = IM->BeginState;
+   GLuint inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
+
+   /* Not the case if vertices emitted without calling glBegin first:
+    */
+/*   assert( ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES ); */
+
+
+   state |= inflags << 2;	/* errors */
+
+   if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
+   {
+      GLuint count = IM->Count;
+      GLuint last = IM->LastPrimitive;
+
+      state &= ~(VERT_BEGIN_0|VERT_BEGIN_1); /* update state */
+      IM->Flag[count] |= VERT_END;
+      IM->Primitive[last] |= PRIM_END;
+      IM->PrimitiveLength[last] = count - last;
+      IM->Primitive[count] = PRIM_OUTSIDE_BEGIN_END; /* removes PRIM_BEGIN 
+						      * flag if length == 0
+						      */
+      IM->LastPrimitive = count;
+
+      if (IM->FlushElt == FLUSH_ELT_EAGER) {
+	 _tnl_translate_array_elts( ctx, IM, last, count );
+      }
+   }
+
+   IM->BeginState = state;
+
+   /* Only update CurrentExecPrimitive if not compiling.  If we are in
+    * COMPILE_AND_EXECUTE mode, it will be done on replay of this
+    * cassette.
+    */
+   if (!ctx->CompileFlag) {
+      if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END) 
+	 _mesa_error( ctx, GL_INVALID_OPERATION, "_tnl_End" );
+      else
+	 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
+   }
+
+   /* You can set this flag to get the old 'flush_vb on glEnd()'
+    * behaviour.
+    */
+   if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
+      _tnl_flush_immediate( IM );
+}
+
+static void
+_tnl_End(void)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _tnl_end( ctx );
+
+   /* Need to keep save primitive uptodate in COMPILE and
+    * COMPILE_AND_EXEC modes, need to keep exec primitive uptodate
+    * otherwise.
+    */
+   if (ctx->CompileFlag)
+      ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
+}
+
+
+#define COLOR( IM, r, g, b, a )			\
+{						\
+   GLuint count = IM->Count;			\
+   IM->Flag[count] |= VERT_RGBA;		\
+   IM->Color[count][0] = r;			\
+   IM->Color[count][1] = g;			\
+   IM->Color[count][2] = b;			\
+   IM->Color[count][3] = a;			\
+}
+
+static void
+_tnl_Color3f( GLfloat red, GLfloat green, GLfloat blue )
+{
+   GET_IMMEDIATE;
+   COLOR( IM, red, green, blue, 1.0 );
+}
+
+static void
+_tnl_Color3ub( GLubyte red, GLubyte green, GLubyte blue )
+{
+   GET_IMMEDIATE;
+   COLOR(IM,
+         UBYTE_TO_FLOAT(red),
+         UBYTE_TO_FLOAT(green),
+         UBYTE_TO_FLOAT(blue),
+         1.0);
+}
+
+static void
+_tnl_Color4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
+   GET_IMMEDIATE;
+   COLOR( IM, red, green, blue, alpha );
+}
+
+static void
+_tnl_Color4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
+{
+   GET_IMMEDIATE;
+   COLOR(IM,
+         UBYTE_TO_FLOAT(red),
+         UBYTE_TO_FLOAT(green),
+         UBYTE_TO_FLOAT(blue),
+         UBYTE_TO_FLOAT(alpha));
+}
+
+static void
+_tnl_Color3fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   COLOR( IM, v[0], v[1], v[2], 1.0 );
+}
+
+static void
+_tnl_Color3ubv( const GLubyte *v )
+{
+   GET_IMMEDIATE;
+   COLOR(IM,
+         UBYTE_TO_FLOAT(v[0]),
+         UBYTE_TO_FLOAT(v[1]),
+         UBYTE_TO_FLOAT(v[2]),
+         1.0 );
+}
+
+static void
+_tnl_Color4fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   COLOR( IM, v[0], v[1], v[2], v[3] );
+}
+
+static void
+_tnl_Color4ubv( const GLubyte *v)
+{
+   GET_IMMEDIATE;
+   COLOR(IM,
+         UBYTE_TO_FLOAT(v[0]),
+         UBYTE_TO_FLOAT(v[1]),
+         UBYTE_TO_FLOAT(v[2]),
+         UBYTE_TO_FLOAT(v[3]));
+}
+
+
+
+
+#define SECONDARY_COLOR( IM, r, g, b )		\
+{						\
+   GLuint count = IM->Count;			\
+   IM->Flag[count] |= VERT_SPEC_RGB;		\
+   IM->SecondaryColor[count][0] = r;		\
+   IM->SecondaryColor[count][1] = g;		\
+   IM->SecondaryColor[count][2] = b;		\
+}
+
+static void
+_tnl_SecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue )
+{
+   GET_IMMEDIATE;
+   SECONDARY_COLOR( IM, red, green, blue );
+}
+
+static void
+_tnl_SecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue )
+{
+   GET_IMMEDIATE;
+   SECONDARY_COLOR(IM,
+                   UBYTE_TO_FLOAT(red),
+                   UBYTE_TO_FLOAT(green),
+                   UBYTE_TO_FLOAT(blue));
+}
+
+static void
+_tnl_SecondaryColor3fvEXT( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   SECONDARY_COLOR( IM, v[0], v[1], v[2] );
+}
+
+static void
+_tnl_SecondaryColor3ubvEXT( const GLubyte *v )
+{
+   GET_IMMEDIATE;
+   SECONDARY_COLOR(IM,
+                   UBYTE_TO_FLOAT(v[0]),
+                   UBYTE_TO_FLOAT(v[1]),
+                   UBYTE_TO_FLOAT(v[2]));
+}
+
+
+
+
+static void
+_tnl_EdgeFlag( GLboolean flag )
+{
+   GLuint count;
+   GET_IMMEDIATE;
+   count = IM->Count;
+   IM->EdgeFlag[count] = flag;
+   IM->Flag[count] |= VERT_EDGE;
+}
+
+
+static void
+_tnl_EdgeFlagv( const GLboolean *flag )
+{
+   GLuint count;
+   GET_IMMEDIATE;
+   count = IM->Count;
+   IM->EdgeFlag[count] = *flag;
+   IM->Flag[count] |= VERT_EDGE;
+}
+
+
+static void
+_tnl_FogCoordfEXT( GLfloat f )
+{
+   GLuint count;
+   GET_IMMEDIATE;
+   count = IM->Count;
+   IM->FogCoord[count] = f;
+   IM->Flag[count] |= VERT_FOG_COORD;
+}
+
+static void
+_tnl_FogCoordfvEXT( const GLfloat *v )
+{
+   GLuint count;
+   GET_IMMEDIATE;
+   count = IM->Count;
+   IM->FogCoord[count] = v[0];
+   IM->Flag[count] |= VERT_FOG_COORD;
+}
+
+
+static void
+_tnl_Indexi( GLint c )
+{
+   GLuint count;
+   GET_IMMEDIATE;
+   count = IM->Count;
+   IM->Index[count] = c;
+   IM->Flag[count] |= VERT_INDEX;
+}
+
+
+static void
+_tnl_Indexiv( const GLint *c )
+{
+   GLuint count;
+   GET_IMMEDIATE;
+   count = IM->Count;
+   IM->Index[count] = *c;
+   IM->Flag[count] |= VERT_INDEX;
+}
+
+
+#define NORMAL( x, y, z )			\
+{						\
+   GLuint count;				\
+   GLfloat *normal;				\
+   GET_IMMEDIATE;				\
+   count = IM->Count;				\
+   IM->Flag[count] |= VERT_NORM;		\
+   normal = IM->Normal[count];			\
+   ASSIGN_3V(normal, x,y,z);			\
+}
+
+#if defined(USE_IEEE)
+#define NORMALF( x, y, z )					\
+{								\
+   GLuint count;						\
+   fi_type *normal;						\
+   GET_IMMEDIATE;						\
+   count = IM->Count;						\
+   IM->Flag[count] |= VERT_NORM;				\
+   normal = (fi_type *)IM->Normal[count];			\
+   normal[0].i = ((fi_type *)&(x))->i;				\
+   normal[1].i = ((fi_type *)&(y))->i;				\
+   normal[2].i = ((fi_type *)&(z))->i;				\
+}
+#else
+#define NORMALF NORMAL
+#endif
+
+static void
+_tnl_Normal3f( GLfloat nx, GLfloat ny, GLfloat nz )
+{
+   NORMALF(nx, ny, nz);
+}
+
+
+static void
+_tnl_Normal3fv( const GLfloat *v )
+{
+   NORMALF( v[0], v[1], v[2] );
+/*     struct immediate *IM = (struct immediate *)(((GLcontext *) _glapi_Context)->swtnl_im); */
+/*     IM->Flag[IM->Count] = VERT_NORM; */
+}
+
+
+
+#define TEXCOORD1(s)				\
+{						\
+   GLuint count;				\
+   GLfloat *tc;					\
+   GET_IMMEDIATE;				\
+   count = IM->Count;				\
+   IM->Flag[count] |= VERT_TEX0;		\
+   tc = IM->TexCoord0[count];			\
+   ASSIGN_4V(tc,s,0,0,1);			\
+}
+
+#define TEXCOORD2(s,t)				\
+{						\
+   GLuint count;				\
+   GLfloat *tc;					\
+   GET_IMMEDIATE;				\
+   count = IM->Count;				\
+   IM->Flag[count] |= VERT_TEX0;		\
+   tc = IM->TexCoord0[count];			\
+   ASSIGN_4V(tc, s,t,0,1);		        \
+}
+
+#define TEXCOORD3(s,t,u)			\
+{						\
+   GLuint count;				\
+   GLfloat *tc;					\
+   GET_IMMEDIATE;				\
+   count = IM->Count;				\
+   IM->Flag[count] |= VERT_TEX0;		\
+   IM->TexSize |= TEX_0_SIZE_3;		\
+   tc = IM->TexCoord0[count];			\
+   ASSIGN_4V(tc, s,t,u,1);			\
+}
+
+#define TEXCOORD4(s,t,u,v)			\
+{						\
+   GLuint count;				\
+   GLfloat *tc;					\
+   GET_IMMEDIATE;				\
+   count = IM->Count;				\
+   IM->Flag[count] |= VERT_TEX0;		\
+   IM->TexSize |= TEX_0_SIZE_4;		\
+   tc = IM->TexCoord0[count];			\
+   ASSIGN_4V(tc, s,t,u,v);			\
+}
+
+#if defined(USE_IEEE)
+#define TEXCOORD2F(s,t)					\
+{							\
+   GLuint count;					\
+   fi_type *tc;						\
+   GET_IMMEDIATE;					\
+   count = IM->Count;					\
+   IM->Flag[count] |= VERT_TEX0;			\
+   tc = (fi_type *)IM->TexCoord0[count];		\
+   tc[0].i = ((fi_type *)&(s))->i;			\
+   tc[1].i = ((fi_type *)&(t))->i;			\
+   tc[2].i = 0;						\
+   tc[3].i = IEEE_ONE;					\
+}
+#else
+#define TEXCOORD2F TEXCOORD2
+#endif
+
+static void
+_tnl_TexCoord1f( GLfloat s )
+{
+   TEXCOORD1(s);
+}
+
+
+static void
+_tnl_TexCoord2f( GLfloat s, GLfloat t )
+{
+   TEXCOORD2F(s,t);
+}
+
+
+static void
+_tnl_TexCoord3f( GLfloat s, GLfloat t, GLfloat r )
+{
+   TEXCOORD3(s,t,r);
+}
+
+static void
+_tnl_TexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
+   TEXCOORD4(s,t,r,q)
+}
+
+static void
+_tnl_TexCoord1fv( const GLfloat *v )
+{
+   TEXCOORD1(v[0]);
+}
+
+static void
+_tnl_TexCoord2fv( const GLfloat *v )
+{
+   TEXCOORD2F(v[0],v[1]);
+}
+
+static void
+_tnl_TexCoord3fv( const GLfloat *v )
+{
+   TEXCOORD3(v[0],v[1],v[2]);
+}
+
+static void
+_tnl_TexCoord4fv( const GLfloat *v )
+{
+   TEXCOORD4(v[0],v[1],v[2],v[3]);
+}
+
+
+
+/* KW: Run into bad problems in vertex copying if we don't fully pad
+ *     the incoming vertices.
+ */
+#define VERTEX2(IM, x,y)			\
+{						\
+   GLuint count = IM->Count++;			\
+   GLfloat *dest = IM->Obj[count];		\
+   IM->Flag[count] |= VERT_OBJ;			\
+   ASSIGN_4V(dest, x, y, 0, 1);			\
+/*     ASSERT(IM->Flag[IM->Count]==0);		 */\
+   if (count == IMM_MAXDATA - 1)		\
+      _tnl_flush_immediate( IM );		\
+}
+
+#define VERTEX3(IM,x,y,z)			\
+{						\
+   GLuint count = IM->Count++;			\
+   GLfloat *dest = IM->Obj[count];		\
+   IM->Flag[count] |= VERT_OBJ_23;		\
+   ASSIGN_4V(dest, x, y, z, 1);			\
+/*     ASSERT(IM->Flag[IM->Count]==0); */		\
+   if (count == IMM_MAXDATA - 1)		\
+      _tnl_flush_immediate( IM );		\
+}
+
+#define VERTEX4(IM, x,y,z,w)			\
+{						\
+   GLuint count = IM->Count++;			\
+   GLfloat *dest = IM->Obj[count];		\
+   IM->Flag[count] |= VERT_OBJ_234;		\
+   ASSIGN_4V(dest, x, y, z, w);			\
+   if (count == IMM_MAXDATA - 1)			\
+      _tnl_flush_immediate( IM );		\
+}
+
+#if defined(USE_IEEE)
+#define VERTEX2F(IM, x, y)				\
+{							\
+   GLuint count = IM->Count++;				\
+   fi_type *dest = (fi_type *)IM->Obj[count];		\
+   IM->Flag[count] |= VERT_OBJ; 			\
+   dest[0].i = ((fi_type *)&(x))->i;			\
+   dest[1].i = ((fi_type *)&(y))->i;			\
+   dest[2].i = 0;					\
+   dest[3].i = IEEE_ONE;				\
+/*     ASSERT(IM->Flag[IM->Count]==0); */		\
+   if (count == IMM_MAXDATA - 1)			\
+      _tnl_flush_immediate( IM );			\
+}
+#else
+#define VERTEX2F VERTEX2
+#endif
+
+#if defined(USE_IEEE)
+#define VERTEX3F(IM, x, y, z)				\
+{							\
+   GLuint count = IM->Count++;				\
+   fi_type *dest = (fi_type *)IM->Obj[count];		\
+   IM->Flag[count] |= VERT_OBJ_23;			\
+   dest[0].i = ((fi_type *)&(x))->i;			\
+   dest[1].i = ((fi_type *)&(y))->i;			\
+   dest[2].i = ((fi_type *)&(z))->i;			\
+   dest[3].i = IEEE_ONE;				\
+/*     ASSERT(IM->Flag[IM->Count]==0);	 */		\
+   if (count == IMM_MAXDATA - 1)			\
+      _tnl_flush_immediate( IM );			\
+}
+#else
+#define VERTEX3F VERTEX3
+#endif
+
+#if defined(USE_IEEE)
+#define VERTEX4F(IM, x, y, z, w)			\
+{							\
+   GLuint count = IM->Count++;				\
+   fi_type *dest = (fi_type *)IM->Obj[count];		\
+   IM->Flag[count] |= VERT_OBJ_234;			\
+   dest[0].i = ((fi_type *)&(x))->i;			\
+   dest[1].i = ((fi_type *)&(y))->i;			\
+   dest[2].i = ((fi_type *)&(z))->i;			\
+   dest[3].i = ((fi_type *)&(w))->i;			\
+   if (count == IMM_MAXDATA - 1)			\
+      _tnl_flush_immediate( IM );			\
+}
+#else
+#define VERTEX4F VERTEX4
+#endif
+
+
+
+static void
+_tnl_Vertex2f( GLfloat x, GLfloat y )
+{
+   GET_IMMEDIATE;
+   VERTEX2F( IM, x, y );
+}
+
+static void
+_tnl_Vertex3f( GLfloat x, GLfloat y, GLfloat z )
+{
+   GET_IMMEDIATE;
+   VERTEX3F( IM, x, y, z );
+}
+static void
+_tnl_Vertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+   GET_IMMEDIATE;
+   VERTEX4F( IM, x, y, z, w );
+}
+
+static void
+_tnl_Vertex2fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   VERTEX2F( IM, v[0], v[1] );
+}
+
+static void
+_tnl_Vertex3fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   VERTEX3F( IM, v[0], v[1], v[2] );
+}
+
+static void
+_tnl_Vertex4fv( const GLfloat *v )
+{
+   GET_IMMEDIATE;
+   VERTEX4F( IM, v[0], v[1], v[2], v[3] );
+}
+
+
+
+
+/*
+ * GL_ARB_multitexture
+ *
+ * Note: the multitexture spec says that specifying an invalid target
+ * has undefined results and does not have to generate an error.  Just
+ * don't crash.  We no-op on invalid targets.
+ */
+
+#define MAX_TARGET (GL_TEXTURE0_ARB + MAX_TEXTURE_UNITS)
+
+#define MULTI_TEXCOORD1(target, s)			\
+{							\
+   GET_IMMEDIATE;					\
+   GLuint texunit = target - GL_TEXTURE0_ARB;		\
+   if (texunit < IM->MaxTextureUnits) {			\
+      GLuint count = IM->Count;				\
+      GLfloat *tc = IM->TexCoord[texunit][count];	\
+      ASSIGN_4V(tc, s, 0.0F, 0.0F, 1.0F);		\
+      IM->Flag[count] |= VERT_TEX(texunit);		\
+   }							\
+}
+
+#define MULTI_TEXCOORD2(target, s, t)			\
+{							\
+   GET_IMMEDIATE;					\
+   GLuint texunit = target - GL_TEXTURE0_ARB;		\
+   if (texunit < IM->MaxTextureUnits) {			\
+      GLuint count = IM->Count;				\
+      GLfloat *tc = IM->TexCoord[texunit][count];	\
+      ASSIGN_4V(tc, s, t, 0.0F, 1.0F);			\
+      IM->Flag[count] |= VERT_TEX(texunit);		\
+   }							\
+}
+
+#define MULTI_TEXCOORD3(target, s, t, u)		\
+{							\
+   GET_IMMEDIATE;					\
+   GLuint texunit = target - GL_TEXTURE0_ARB;		\
+   if (texunit < IM->MaxTextureUnits) {			\
+      GLuint count = IM->Count;				\
+      GLfloat *tc = IM->TexCoord[texunit][count];	\
+      ASSIGN_4V(tc, s, t, u, 1.0F);			\
+      IM->Flag[count] |= VERT_TEX(texunit);		\
+      IM->TexSize |= TEX_SIZE_3(texunit);		\
+   }							\
+}
+
+#define MULTI_TEXCOORD4(target, s, t, u, v)		\
+{							\
+   GET_IMMEDIATE;					\
+   GLuint texunit = target - GL_TEXTURE0_ARB;		\
+   if (texunit < IM->MaxTextureUnits) {			\
+      GLuint count = IM->Count;				\
+      GLfloat *tc = IM->TexCoord[texunit][count];	\
+      ASSIGN_4V(tc, s, t, u, v);			\
+      IM->Flag[count] |= VERT_TEX(texunit);		\
+      IM->TexSize |= TEX_SIZE_4(texunit);		\
+   }							\
+}
+
+#if defined(USE_IEEE)
+#define MULTI_TEXCOORD2F(target, s, t)				\
+{								\
+   GET_IMMEDIATE;						\
+   GLuint texunit = target - GL_TEXTURE0_ARB;			\
+   if (texunit < IM->MaxTextureUnits) {				\
+      GLuint count = IM->Count;					\
+      fi_type *tc = (fi_type *)IM->TexCoord[texunit][count];	\
+      IM->Flag[count] |= VERT_TEX(texunit);			\
+      tc[0].i = ((fi_type *)&(s))->i;				\
+      tc[1].i = ((fi_type *)&(t))->i;				\
+      tc[2].i = 0;						\
+      tc[3].i = IEEE_ONE;					\
+   }								\
+}
+#else
+#define MULTI_TEXCOORD2F MULTI_TEXCOORD2
+#endif
+
+static void
+_tnl_MultiTexCoord1fARB(GLenum target, GLfloat s)
+{
+   MULTI_TEXCOORD1( target, s );
+}
+
+static void
+_tnl_MultiTexCoord1fvARB(GLenum target, const GLfloat *v)
+{
+   MULTI_TEXCOORD1( target, v[0] );
+}
+
+static void
+_tnl_MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
+{
+   MULTI_TEXCOORD2F( target, s, t );
+}
+
+static void
+_tnl_MultiTexCoord2fvARB(GLenum target, const GLfloat *v)
+{
+   MULTI_TEXCOORD2F( target, v[0], v[1] );
+}
+
+static void
+_tnl_MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
+{
+   MULTI_TEXCOORD3( target, s, t, r );
+}
+
+static void
+_tnl_MultiTexCoord3fvARB(GLenum target, const GLfloat *v)
+{
+   MULTI_TEXCOORD3( target, v[0], v[1], v[2] );
+}
+
+static void
+_tnl_MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+   MULTI_TEXCOORD4( target, s, t, r, q );
+}
+
+static void
+_tnl_MultiTexCoord4fvARB(GLenum target, const GLfloat *v)
+{
+   MULTI_TEXCOORD4( target, v[0], v[1], v[2], v[3] );
+}
+
+
+
+/* KW: Because the eval values don't become 'current', fixup will flow
+ *     through these vertices, and then evaluation will write on top
+ *     of the fixup results.
+ *
+ *     Note: using Obj to hold eval coord data.
+ */
+#define EVALCOORD1(IM, x)				\
+{							\
+   GLuint count = IM->Count++;				\
+   IM->Flag[count] |= VERT_EVAL_C1;			\
+   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);		\
+   if (count == IMM_MAXDATA-1)				\
+      _tnl_flush_immediate( IM );			\
+}
+
+#define EVALCOORD2(IM, x, y)				\
+{							\
+   GLuint count = IM->Count++;				\
+   IM->Flag[count] |= VERT_EVAL_C2;			\
+   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);		\
+   if (count == IMM_MAXDATA-1)				\
+      _tnl_flush_immediate( IM );			\
+}
+
+#define EVALPOINT1(IM, x)				\
+{							\
+   GLuint count = IM->Count++;				\
+   IM->Flag[count] |= VERT_EVAL_P1;			\
+   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);		\
+   if (count == IMM_MAXDATA-1)				\
+      _tnl_flush_immediate( IM );			\
+}
+
+#define EVALPOINT2(IM, x, y)				\
+{							\
+   GLuint count = IM->Count++;				\
+   IM->Flag[count] |= VERT_EVAL_P2;			\
+   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);		\
+   if (count == IMM_MAXDATA-1)				\
+      _tnl_flush_immediate( IM );			\
+}
+
+static void
+_tnl_EvalCoord1f( GLfloat u )
+{
+   GET_IMMEDIATE;
+   EVALCOORD1( IM, u );
+}
+
+static void
+_tnl_EvalCoord1fv( const GLfloat *u )
+{
+   GET_IMMEDIATE;
+   EVALCOORD1( IM, (GLfloat) *u );
+}
+
+static void
+_tnl_EvalCoord2f( GLfloat u, GLfloat v )
+{
+   GET_IMMEDIATE;
+   EVALCOORD2( IM, u, v );
+}
+
+static void
+_tnl_EvalCoord2fv( const GLfloat *u )
+{
+   GET_IMMEDIATE;
+   EVALCOORD2( IM, u[0], u[1] );
+}
+
+
+static void
+_tnl_EvalPoint1( GLint i )
+{
+   GET_IMMEDIATE;
+   EVALPOINT1( IM, (GLfloat) i );
+}
+
+
+static void
+_tnl_EvalPoint2( GLint i, GLint j )
+{
+   GET_IMMEDIATE;
+   EVALPOINT2( IM, (GLfloat) i, (GLfloat) j );
+}
+
+
+/* Need to use the default array-elt outside begin/end for strict
+ * conformance.
+ */
+#define ARRAY_ELT( IM, i )			\
+{						\
+   GLuint count = IM->Count;			\
+   IM->Elt[count] = i;				\
+   IM->Flag[count] &= IM->ArrayEltFlags;	\
+   IM->Flag[count] |= VERT_ELT;			\
+   IM->FlushElt = IM->ArrayEltFlush;		\
+   IM->Count += IM->ArrayEltIncr;		\
+   if (IM->Count == IMM_MAXDATA)			\
+      _tnl_flush_immediate( IM );		\
+}
+
+
+static void
+_tnl_ArrayElement( GLint i )
+{
+   GET_IMMEDIATE;
+   ARRAY_ELT( IM, i );
+}
+
+
+/* Internal functions.  These are safe to use providing either:
+ *
+ *    - It is determined that a display list is not being compiled, or
+ *    if so that these commands won't be compiled into the list (see
+ *    t_eval.c for an example).
+ *
+ *    - _tnl_hard_begin() is used instead of _tnl_[bB]egin, and tested
+ *    for a GL_TRUE return value.  See _tnl_Rectf, below.
+ */
+void
+_tnl_eval_coord1f( GLcontext *CC, GLfloat u )
+{
+   struct immediate *i = TNL_CURRENT_IM(CC);
+   EVALCOORD1( i, u );
+}
+
+void
+_tnl_eval_coord2f( GLcontext *CC, GLfloat u, GLfloat v )
+{
+   struct immediate *i = TNL_CURRENT_IM(CC);
+   EVALCOORD2( i, u, v );
+}
+
+
+
+
+
+
+/* Execute a glRectf() function.  _tnl_hard_begin() ensures the check
+ * on outside_begin_end is executed even in compiled lists.  These
+ * vertices can now participate in the same immediate as regular ones,
+ * even in most display lists.  
+ */
+static void
+_tnl_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (_tnl_hard_begin( ctx, GL_QUADS )) {
+      glVertex2f( x1, y1 );
+      glVertex2f( x2, y1 );
+      glVertex2f( x2, y2 );
+      glVertex2f( x1, y2 );
+      glEnd();
+   }
+}
+
+static void
+_tnl_Materialfv( GLenum face, GLenum pname, const GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+   GLuint count = IM->Count;
+   struct gl_material *mat;
+   GLuint bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, "Materialfv");
+
+   if (bitmask == 0)
+      return;
+   
+   if (MESA_VERBOSE & VERBOSE_API)
+      fprintf(stderr, "_tnl_Materialfv\n");
+
+   if (tnl->IsolateMaterials &&
+       !(IM->BeginState & VERT_BEGIN_1)) /* heuristic */
+   {
+      _tnl_flush_immediate( IM );      
+      IM = TNL_CURRENT_IM(ctx);
+      count = IM->Count;
+   }
+
+   if (!(IM->Flag[count] & VERT_MATERIAL)) {
+      if (!IM->Material) {
+	 IM->Material = (GLmaterial (*)[2]) MALLOC( sizeof(GLmaterial) *
+						    IMM_SIZE * 2 );
+	 IM->MaterialMask = (GLuint *) MALLOC( sizeof(GLuint) * IMM_SIZE );
+	 IM->MaterialMask[IM->LastMaterial] = 0;
+      }
+      else if (IM->MaterialOrMask & ~bitmask) {
+	 _mesa_copy_material_pairs( IM->Material[count],
+				    IM->Material[IM->LastMaterial],
+				    IM->MaterialOrMask & ~bitmask );
+      }
+
+      IM->Flag[count] |= VERT_MATERIAL;
+      IM->MaterialMask[count] = 0;
+      IM->MaterialAndMask &= IM->MaterialMask[IM->LastMaterial];
+      IM->LastMaterial = count;
+   }
+
+   IM->MaterialOrMask |= bitmask;
+   IM->MaterialMask[count] |= bitmask;
+   mat = IM->Material[count];
+
+   if (bitmask & FRONT_AMBIENT_BIT) {
+      COPY_4FV( mat[0].Ambient, params );
+   }
+   if (bitmask & BACK_AMBIENT_BIT) {
+      COPY_4FV( mat[1].Ambient, params );
+   }
+   if (bitmask & FRONT_DIFFUSE_BIT) {
+      COPY_4FV( mat[0].Diffuse, params );
+   }
+   if (bitmask & BACK_DIFFUSE_BIT) {
+      COPY_4FV( mat[1].Diffuse, params );
+   }
+   if (bitmask & FRONT_SPECULAR_BIT) {
+      COPY_4FV( mat[0].Specular, params );
+   }
+   if (bitmask & BACK_SPECULAR_BIT) {
+      COPY_4FV( mat[1].Specular, params );
+   }
+   if (bitmask & FRONT_EMISSION_BIT) {
+      COPY_4FV( mat[0].Emission, params );
+   }
+   if (bitmask & BACK_EMISSION_BIT) {
+      COPY_4FV( mat[1].Emission, params );
+   }
+   if (bitmask & FRONT_SHININESS_BIT) {
+      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
+      mat[0].Shininess = shininess;
+   }
+   if (bitmask & BACK_SHININESS_BIT) {
+      GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
+      mat[1].Shininess = shininess;
+   }
+   if (bitmask & FRONT_INDEXES_BIT) {
+      mat[0].AmbientIndex = params[0];
+      mat[0].DiffuseIndex = params[1];
+      mat[0].SpecularIndex = params[2];
+   }
+   if (bitmask & BACK_INDEXES_BIT) {
+      mat[1].AmbientIndex = params[0];
+      mat[1].DiffuseIndex = params[1];
+      mat[1].SpecularIndex = params[2];
+   }
+
+   if (tnl->IsolateMaterials && 
+       !(IM->BeginState & VERT_BEGIN_1)) /* heuristic */
+   {
+      _tnl_flush_immediate( IM );
+   }
+}
+
+void _tnl_imm_vtxfmt_init( GLcontext *ctx )
+{
+   GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt);
+
+   /* All begin/end operations are handled by this vertex format:
+    */
+   vfmt->ArrayElement = _tnl_ArrayElement;
+   vfmt->Begin = _tnl_Begin;
+   vfmt->Color3f = _tnl_Color3f;
+   vfmt->Color3fv = _tnl_Color3fv;
+   vfmt->Color3ub = _tnl_Color3ub;
+   vfmt->Color3ubv = _tnl_Color3ubv;
+   vfmt->Color4f = _tnl_Color4f;
+   vfmt->Color4fv = _tnl_Color4fv;
+   vfmt->Color4ub = _tnl_Color4ub;
+   vfmt->Color4ubv = _tnl_Color4ubv;
+   vfmt->EdgeFlag = _tnl_EdgeFlag;
+   vfmt->EdgeFlagv = _tnl_EdgeFlagv;
+   vfmt->End = _tnl_End;
+   vfmt->EvalCoord1f = _tnl_EvalCoord1f;
+   vfmt->EvalCoord1fv = _tnl_EvalCoord1fv;
+   vfmt->EvalCoord2f = _tnl_EvalCoord2f;
+   vfmt->EvalCoord2fv = _tnl_EvalCoord2fv;
+   vfmt->EvalPoint1 = _tnl_EvalPoint1;
+   vfmt->EvalPoint2 = _tnl_EvalPoint2;
+   vfmt->FogCoordfEXT = _tnl_FogCoordfEXT;
+   vfmt->FogCoordfvEXT = _tnl_FogCoordfvEXT;
+   vfmt->Indexi = _tnl_Indexi;
+   vfmt->Indexiv = _tnl_Indexiv;
+   vfmt->Materialfv = _tnl_Materialfv;
+   vfmt->MultiTexCoord1fARB = _tnl_MultiTexCoord1fARB;
+   vfmt->MultiTexCoord1fvARB = _tnl_MultiTexCoord1fvARB;
+   vfmt->MultiTexCoord2fARB = _tnl_MultiTexCoord2fARB;
+   vfmt->MultiTexCoord2fvARB = _tnl_MultiTexCoord2fvARB;
+   vfmt->MultiTexCoord3fARB = _tnl_MultiTexCoord3fARB;
+   vfmt->MultiTexCoord3fvARB = _tnl_MultiTexCoord3fvARB;
+   vfmt->MultiTexCoord4fARB = _tnl_MultiTexCoord4fARB;
+   vfmt->MultiTexCoord4fvARB = _tnl_MultiTexCoord4fvARB;
+   vfmt->Normal3f = _tnl_Normal3f;
+   vfmt->Normal3fv = _tnl_Normal3fv;
+   vfmt->SecondaryColor3fEXT = _tnl_SecondaryColor3fEXT;
+   vfmt->SecondaryColor3fvEXT = _tnl_SecondaryColor3fvEXT;
+   vfmt->SecondaryColor3ubEXT = _tnl_SecondaryColor3ubEXT;
+   vfmt->SecondaryColor3ubvEXT = _tnl_SecondaryColor3ubvEXT;
+   vfmt->TexCoord1f = _tnl_TexCoord1f;
+   vfmt->TexCoord1fv = _tnl_TexCoord1fv;
+   vfmt->TexCoord2f = _tnl_TexCoord2f;
+   vfmt->TexCoord2fv = _tnl_TexCoord2fv;
+   vfmt->TexCoord3f = _tnl_TexCoord3f;
+   vfmt->TexCoord3fv = _tnl_TexCoord3fv;
+   vfmt->TexCoord4f = _tnl_TexCoord4f;
+   vfmt->TexCoord4fv = _tnl_TexCoord4fv;
+   vfmt->Vertex2f = _tnl_Vertex2f;
+   vfmt->Vertex2fv = _tnl_Vertex2fv;
+   vfmt->Vertex3f = _tnl_Vertex3f;
+   vfmt->Vertex3fv = _tnl_Vertex3fv;
+   vfmt->Vertex4f = _tnl_Vertex4f;
+   vfmt->Vertex4fv = _tnl_Vertex4fv;
+
+   /* Outside begin/end functions (from t_varray.c, t_eval.c, ...):
+    */
+   vfmt->Rectf = _tnl_Rectf;
+
+   /* Just use the core function:
+    */
+   vfmt->CallList = _mesa_CallList;
+
+   vfmt->prefer_float_colors = GL_FALSE;
+}
Index: xc/extras/Mesa/src/tnl/t_imm_api.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_api.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_api.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,51 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _T_VTXFMT_H
+#define _T_VTXFMT_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+
+extern void _tnl_save_Begin( GLenum mode );
+extern void _tnl_Begin( GLenum mode );
+
+/* TNL-private internal functions for building higher-level operations:
+ */
+extern GLboolean _tnl_hard_begin( GLcontext *ctx, GLenum p );
+extern void _tnl_end( GLcontext *ctx );
+extern void _tnl_vertex2f( GLcontext *ctx, GLfloat x, GLfloat y );
+extern void _tnl_eval_coord1f( GLcontext *CC, GLfloat u );
+extern void _tnl_eval_coord2f( GLcontext *CC, GLfloat u, GLfloat v );
+extern void _tnl_array_element( GLcontext *CC, GLint i );
+
+/* Initialize our part of the vtxfmt struct:
+ */
+extern void _tnl_imm_vtxfmt_init( GLcontext *ctx );
+
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_debug.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_debug.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_debug.c	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,168 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+#include "mtypes.h"
+#include "t_context.h"
+#include "t_imm_debug.h"
+
+void _tnl_print_vert_flags( const char *name, GLuint flags )
+{
+   fprintf(stderr,
+	   "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
+	   name,
+	   flags,
+	   (flags & VERT_CLIP)       ? "clip/proj-clip/glend, " : "",
+	   (flags & VERT_EDGE)       ? "edgeflag, " : "",
+	   (flags & VERT_ELT)        ? "array-elt, " : "",
+	   (flags & VERT_END_VB)     ? "end-vb, " : "",
+	   (flags & VERT_EVAL_ANY)   ? "eval-coord, " : "",
+	   (flags & VERT_EYE)        ? "eye/glbegin, " : "",
+	   (flags & VERT_FOG_COORD)  ? "fog-coord, " : "",
+	   (flags & VERT_INDEX)      ? "index, " : "",
+	   (flags & VERT_MATERIAL)   ? "material, " : "",
+	   (flags & VERT_NORM)       ? "normals, " : "",
+	   (flags & VERT_OBJ)        ? "obj, " : "",
+	   (flags & VERT_OBJ_3)      ? "obj-3, " : "",
+	   (flags & VERT_OBJ_4)      ? "obj-4, " : "",
+	   (flags & VERT_POINT_SIZE) ? "point-size, " : "",
+	   (flags & VERT_RGBA)       ? "colors, " : "",
+	   (flags & VERT_SPEC_RGB)   ? "specular, " : "",
+	   (flags & VERT_TEX0)       ? "texcoord0, " : "",
+	   (flags & VERT_TEX1)       ? "texcoord1, " : "",
+	   (flags & VERT_TEX2)       ? "texcoord2, " : "",
+	   (flags & VERT_TEX3)       ? "texcoord3, " : "",
+	   (flags & VERT_TEX4)       ? "texcoord4, " : "",
+	   (flags & VERT_TEX5)       ? "texcoord5, " : "",
+	   (flags & VERT_TEX6)       ? "texcoord6, " : "",
+	   (flags & VERT_TEX7)       ? "texcoord7, " : ""
+      );
+}
+
+void _tnl_print_cassette( struct immediate *IM )
+{
+   GLuint i;
+   GLuint *flags = IM->Flag;
+   GLuint andflag = IM->CopyAndFlag;
+   GLuint orflag = (IM->CopyOrFlag|IM->Evaluated);
+   GLuint state = IM->BeginState;
+   GLuint req = ~0;
+
+   fprintf(stderr, "Cassette id %d, %u rows.\n", IM->id,
+	   IM->Count - IM->CopyStart);
+
+   _tnl_print_vert_flags("Contains at least one", orflag);
+
+   if (IM->Count != IM->CopyStart)
+   {
+      _tnl_print_vert_flags("Contains a full complement of", andflag);
+
+      fprintf(stderr, "Final begin/end state %s/%s, errors %s/%s\n",
+	      (state & VERT_BEGIN_0) ? "in" : "out",
+	      (state & VERT_BEGIN_1) ? "in" : "out",
+	      (state & VERT_ERROR_0) ? "y" : "n",
+	      (state & VERT_ERROR_1) ? "y" : "n");
+
+   }
+
+   if ((MESA_VERBOSE & VERBOSE_IMMEDIATE) &&
+       (MESA_VERBOSE & VERBOSE_VERTS)) {
+      for (i = IM->CopyStart ; i <= IM->Count ; i++) {
+	 fprintf(stderr, "%u: ", i);
+	 if (req & VERT_OBJ_234) {
+	    if (flags[i] & VERT_EVAL_C1)
+	       fprintf(stderr, "EvalCoord %f ", IM->Obj[i][0]);
+	    else if (flags[i] & VERT_EVAL_P1)
+	       fprintf(stderr, "EvalPoint %.0f ", IM->Obj[i][0]);
+	    else if (flags[i] & VERT_EVAL_C2)
+	       fprintf(stderr, "EvalCoord %f %f ", IM->Obj[i][0], IM->Obj[i][1]);
+	    else if (flags[i] & VERT_EVAL_P2)
+	       fprintf(stderr, "EvalPoint %.0f %.0f ", IM->Obj[i][0], IM->Obj[i][1]);
+	    else if (i < IM->Count && (flags[i]&VERT_OBJ_234)) {
+	       fprintf(stderr, "Obj %f %f %f %f",
+		       IM->Obj[i][0], IM->Obj[i][1], IM->Obj[i][2], IM->Obj[i][3]);
+	    }
+	 }
+
+	 if (req & flags[i] & VERT_ELT)
+	    fprintf(stderr, " Elt %u\t", IM->Elt[i]);
+
+	 if (req & flags[i] & VERT_NORM)
+	    fprintf(stderr, " Norm %f %f %f ",
+		    IM->Normal[i][0], IM->Normal[i][1], IM->Normal[i][2]);
+
+	 if (req & flags[i] & VERT_TEX_ANY) {
+	    GLuint j;
+	    for (j = 0 ; j < MAX_TEXTURE_UNITS ; j++) {
+	       if (req & flags[i] & VERT_TEX(j)) {
+		  fprintf(stderr,
+			  "TC%d %f %f %f %f",
+			  j,
+			  IM->TexCoord[j][i][0], IM->TexCoord[j][i][1],
+			  IM->TexCoord[j][i][2], IM->TexCoord[j][i][2]);
+	       }
+	    }
+	 }
+
+	 if (req & flags[i] & VERT_RGBA)
+	    fprintf(stderr, " Rgba %f %f %f %f ",
+		    IM->Color[i][0], IM->Color[i][1],
+		    IM->Color[i][2], IM->Color[i][3]);
+
+	 if (req & flags[i] & VERT_SPEC_RGB)
+	    fprintf(stderr, " Spec %f %f %f ",
+		    IM->SecondaryColor[i][0], IM->SecondaryColor[i][1],
+		    IM->SecondaryColor[i][2]);
+
+	 if (req & flags[i] & VERT_FOG_COORD)
+	    fprintf(stderr, " Fog %f ", IM->FogCoord[i]);
+
+	 if (req & flags[i] & VERT_INDEX)
+	    fprintf(stderr, " Index %u ", IM->Index[i]);
+
+	 if (req & flags[i] & VERT_EDGE)
+	    fprintf(stderr, " Edgeflag %d ", IM->EdgeFlag[i]);
+
+	 if (req & flags[i] & VERT_MATERIAL)
+	    fprintf(stderr, " Material ");
+
+
+	 /* The order of these two is not easily knowable, but this is
+	  * the usually correct way to look at them.
+	  */
+	 if (req & flags[i] & VERT_END)
+	    fprintf(stderr, " END ");
+
+	 if (req & flags[i] & VERT_BEGIN)
+	    fprintf(stderr, " BEGIN(%s) (%s%s%s%s)",
+		    _mesa_prim_name[IM->Primitive[i] & PRIM_MODE_MASK],
+		    (IM->Primitive[i] & PRIM_LAST) ? "LAST," : "",
+		    (IM->Primitive[i] & PRIM_BEGIN) ? "BEGIN," : "",
+		    (IM->Primitive[i] & PRIM_END) ? "END," : "",
+		    (IM->Primitive[i] & PRIM_PARITY) ? "PARITY," : "");
+
+	 fprintf(stderr, "\n");
+      }
+   }
+}
Index: xc/extras/Mesa/src/tnl/t_imm_debug.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_debug.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_debug.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,38 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef _T_DEBUG_H
+#define _T_DEBUG_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+void _tnl_print_cassette( struct immediate *IM );
+void _tnl_print_vert_flags( const char *name, GLuint flags );
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_dlist.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_dlist.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_dlist.c	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,666 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "dlist.h"
+#include "debug.h"
+#include "mmath.h"
+#include "mem.h"
+#include "state.h"
+
+#include "t_context.h"
+#include "t_imm_api.h"
+#include "t_imm_elt.h"
+#include "t_imm_alloc.h"
+#include "t_imm_dlist.h"
+#include "t_imm_debug.h"
+#include "t_imm_exec.h"
+#include "t_imm_fixup.h"
+#include "t_pipeline.h"
+
+typedef struct {
+   struct immediate *IM;
+   GLuint Start;
+   GLuint Count;
+   GLuint BeginState;
+   GLuint SavedBeginState;
+   GLuint OrFlag;
+   GLuint AndFlag;
+   GLuint TexSize;
+   GLuint LastData;
+   GLuint LastPrimitive;
+   GLuint LastMaterial;
+   GLuint MaterialOrMask;
+   GLuint MaterialAndMask;
+} TNLvertexcassette;
+
+static void execute_compiled_cassette( GLcontext *ctx, void *data );
+static void loopback_compiled_cassette( GLcontext *ctx, struct immediate *IM );
+
+
+static void build_normal_lengths( struct immediate *IM )
+{
+   GLuint i;
+   GLfloat len;
+   GLfloat (*data)[3] = IM->Normal + IM->Start;
+   GLfloat *dest = IM->NormalLengthPtr;
+   GLuint *flags = IM->Flag + IM->Start;
+   GLuint count = IM->Count - IM->Start;
+
+   if (!dest) {
+      dest = IM->NormalLengthPtr = (GLfloat *) ALIGN_MALLOC( IMM_SIZE*sizeof(GLfloat), 32 );
+      if (!dest) return;
+   }
+   dest += IM->Start;
+
+   len = (GLfloat) LEN_3FV( data[0] );
+   if (len > 0.0F) len = 1.0F / len;
+   
+   for (i = 0 ; i < count ; ) {
+      dest[i] = len;
+      if (flags[++i] & VERT_NORM) {
+	 len = (GLfloat) LEN_3FV( data[i] );
+	 if (len > 0.0F) len = 1.0F / len;
+      }
+   } 
+}
+
+static void fixup_normal_lengths( struct immediate *IM ) 
+{
+   GLuint i;
+   GLfloat len = 1.0F;  /* just to silence warnings */
+   GLfloat (*data)[3] = IM->Normal;
+   GLfloat *dest = IM->NormalLengthPtr;
+   GLuint *flags = IM->Flag;
+
+   for (i = IM->CopyStart ; i <= IM->Start ; i++) {
+      len = (GLfloat) LEN_3FV( data[i] );
+      if (len > 0.0F) len = 1.0F / len;
+      dest[i] = len;
+   } 
+
+   if (i < IM->Count) {
+      while (!(flags[i] & (VERT_NORM|VERT_END_VB))) {
+	 dest[i] = len;
+	 i++;
+      }
+   }
+}
+
+
+
+/* Insert the active immediate struct onto the display list currently
+ * being built.
+ */
+void
+_tnl_compile_cassette( GLcontext *ctx, struct immediate *IM )
+{
+   struct immediate *im = TNL_CURRENT_IM(ctx);
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   TNLvertexcassette *node;
+   GLuint new_beginstate;
+
+   if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
+      fprintf(stderr, "_tnl_compiled_cassette IM: %d\n", IM->id); 
+
+   if (IM->FlushElt) {
+      ASSERT (IM->FlushElt == FLUSH_ELT_LAZY); 
+      _tnl_translate_array_elts( ctx, IM, IM->Start, IM->Count );
+   }
+
+   _tnl_compute_orflag( IM, IM->Start );
+
+   /* Need to clear this flag, or fixup gets confused.  (The
+    * array-elements have been translated away by now, so it's ok to
+    * remove it.)
+    */
+   IM->OrFlag &= ~VERT_ELT;	
+   IM->AndFlag &= ~VERT_ELT;	
+
+   _tnl_fixup_input( ctx, IM );
+
+   node = (TNLvertexcassette *)
+      _mesa_alloc_instruction(ctx,
+			      tnl->opcode_vertex_cassette,
+			      sizeof(TNLvertexcassette));
+   if (!node)
+      return;
+
+   node->IM = im; im->ref_count++;
+   node->Start = im->Start;
+   node->Count = im->Count;
+   node->BeginState = im->BeginState;
+   node->SavedBeginState = im->SavedBeginState;
+   node->OrFlag = im->OrFlag;
+   node->TexSize = im->TexSize;
+   node->AndFlag = im->AndFlag;
+   node->LastData = im->LastData;
+   node->LastPrimitive = im->LastPrimitive;
+   node->LastMaterial = im->LastMaterial;
+   node->MaterialOrMask = im->MaterialOrMask;
+   node->MaterialAndMask = im->MaterialAndMask;
+   
+   if (tnl->CalcDListNormalLengths) {
+      build_normal_lengths( im );
+   }
+
+   if (ctx->ExecuteFlag) {
+      execute_compiled_cassette( ctx, (void *)node );
+   }
+
+   /* Discard any errors raised in the last cassette.
+    */
+   new_beginstate = node->BeginState & (VERT_BEGIN_0|VERT_BEGIN_1);
+
+   /* Decide whether this immediate struct is full, or can be used for
+    * the next batch of vertices as well.
+    */
+   if (im->Count > IMM_MAXDATA - 16) {
+      /* Call it full...
+       */
+      struct immediate *new_im = _tnl_alloc_immediate(ctx);
+      new_im->ref_count++;
+      im->ref_count--;		 /* remove CURRENT_IM reference */
+      ASSERT(im->ref_count > 0); /* it is compiled into a display list */
+      SET_IMMEDIATE( ctx, new_im );
+      _tnl_reset_compile_input( ctx, IMM_MAX_COPIED_VERTS,
+				new_beginstate, node->SavedBeginState );
+   } else {
+      /* Still some room in the current immediate.
+       */
+      _tnl_reset_compile_input( ctx, im->Count+1+IMM_MAX_COPIED_VERTS,
+			new_beginstate, node->SavedBeginState);
+   }
+}
+
+
+static void fixup_compiled_primitives( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   /* Can potentially overwrite primitive details - need to save the
+    * first slot:
+    */
+   tnl->DlistPrimitive = IM->Primitive[IM->Start];
+   tnl->DlistPrimitiveLength = IM->PrimitiveLength[IM->Start];
+   tnl->DlistLastPrimitive = IM->LastPrimitive;
+
+   /* The first primitive may be different from what was recorded in
+    * the immediate struct.  Consider an immediate that starts with a
+    * glBegin, compiled in a display list, which is called from within
+    * an existing Begin/End object.
+    */
+   if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1) {
+      GLuint i;
+
+      if (IM->BeginState & VERT_ERROR_1)
+	 _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin/glEnd");
+
+      for (i = IM->Start ; i <= IM->Count ; i += IM->PrimitiveLength[i])
+	 if (IM->Flag[i] & (VERT_BEGIN|VERT_END_VB))
+	    break;
+
+      /* Would like to just ignore vertices upto this point.  Can't
+       * set copystart because it might skip materials?
+       */
+      ASSERT(IM->Start == IM->CopyStart);
+      if (i > IM->CopyStart || !(IM->Flag[IM->Start] & VERT_BEGIN)) {
+	 IM->Primitive[IM->CopyStart] = GL_POLYGON+1;
+	 IM->PrimitiveLength[IM->CopyStart] = i - IM->CopyStart;
+	 if (IM->Flag[i] & VERT_END_VB) {
+	    IM->Primitive[IM->CopyStart] |= PRIM_LAST;
+	    IM->LastPrimitive = IM->CopyStart;
+	 }
+      }
+   } else {
+      GLuint i;
+
+      if (IM->BeginState & VERT_ERROR_0)
+	 _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin/glEnd");
+
+      if (IM->CopyStart == IM->Start &&
+	  IM->Flag[IM->Start] & (VERT_END|VERT_END_VB))
+      {
+      }
+      else
+      {
+	 IM->Primitive[IM->CopyStart] = ctx->Driver.CurrentExecPrimitive;
+	 if (tnl->ExecParity)
+	    IM->Primitive[IM->CopyStart] |= PRIM_PARITY;
+
+         /* one of these should be true, else we'll be in an infinite loop 
+	  */
+         ASSERT(IM->PrimitiveLength[IM->Start] > 0 ||
+                IM->Flag[IM->Start] & (VERT_END|VERT_END_VB));
+
+	 for (i = IM->Start ; i <= IM->Count ; i += IM->PrimitiveLength[i])
+	    if (IM->Flag[i] & (VERT_END|VERT_END_VB)) {
+	       IM->PrimitiveLength[IM->CopyStart] = i - IM->CopyStart;
+	       if (IM->Flag[i] & VERT_END_VB) {
+		  IM->Primitive[IM->CopyStart] |= PRIM_LAST;
+		  IM->LastPrimitive = IM->CopyStart;
+	       }
+	       if (IM->Flag[i] & VERT_END) {
+		  IM->Primitive[IM->CopyStart] |= PRIM_END;
+	       }
+	       break;
+	    }
+      }
+   }
+}
+
+/* Undo any changes potentially made to the immediate in the range
+ * IM->Start..IM->Count above.
+ */
+static void restore_compiled_primitives( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   IM->Primitive[IM->Start] = tnl->DlistPrimitive;
+   IM->PrimitiveLength[IM->Start] = tnl->DlistPrimitiveLength;
+}
+
+
+
+static void
+execute_compiled_cassette( GLcontext *ctx, void *data )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   TNLvertexcassette *node = (TNLvertexcassette *)data;
+   struct immediate *IM = node->IM;
+
+   if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
+      fprintf(stderr, "execute_compiled_cassette IM: %d\n", IM->id); 
+
+   IM->Start = node->Start;
+   IM->CopyStart = node->Start;
+   IM->Count = node->Count;
+   IM->BeginState = node->BeginState;
+   IM->SavedBeginState = node->SavedBeginState;
+   IM->OrFlag = node->OrFlag;
+   IM->TexSize = node->TexSize;
+   IM->AndFlag = node->AndFlag;
+   IM->LastData = node->LastData;
+   IM->LastPrimitive = node->LastPrimitive;
+   IM->LastMaterial = node->LastMaterial;
+   IM->MaterialOrMask = node->MaterialOrMask;
+   IM->MaterialAndMask = node->MaterialAndMask;
+
+
+   if ((MESA_VERBOSE & VERBOSE_DISPLAY_LIST) &&
+       (MESA_VERBOSE & VERBOSE_IMMEDIATE))
+      _tnl_print_cassette( IM );
+
+   if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST) {
+      fprintf(stderr, "Run cassette %d, rows %d..%d, beginstate %x ",
+	      IM->id,
+	      IM->Start, IM->Count, IM->BeginState);
+      _tnl_print_vert_flags("orflag", IM->OrFlag);
+   }
+
+
+   /* Need to respect 'HardBeginEnd' even if the commands are looped
+    * back to a driver tnl module.
+    */
+   if (IM->SavedBeginState) {
+      if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1)
+	 tnl->ReplayHardBeginEnd = 1;
+      if (!tnl->ReplayHardBeginEnd) {
+	 /* This is a user error.  Whatever operation (like glRectf)
+	  * decomposed to this hard begin/end pair is now being run
+	  * inside a begin/end object -- illegally.  Reject it and
+	  * raise an error.
+	  */
+	 _mesa_error(ctx, GL_INVALID_OPERATION, "hard replay");
+	 return;
+      }
+   }
+
+   if (tnl->LoopbackDListCassettes) {
+/*        (tnl->IsolateMaterials && (IM->OrFlag & VERT_MATERIAL)) ) { */
+      fixup_compiled_primitives( ctx, IM );
+      loopback_compiled_cassette( ctx, IM );
+      restore_compiled_primitives( ctx, IM );
+   }
+   else {
+      if (ctx->NewState)
+	 _mesa_update_state(ctx);
+
+      if (tnl->pipeline.build_state_changes)
+	 _tnl_validate_pipeline( ctx );
+
+      _tnl_fixup_compiled_cassette( ctx, IM );
+      fixup_compiled_primitives( ctx, IM );
+
+      if (IM->Primitive[IM->LastPrimitive] & PRIM_END)
+	 ctx->Driver.CurrentExecPrimitive = GL_POLYGON+1;
+      else if ((IM->Primitive[IM->LastPrimitive] & PRIM_BEGIN) ||
+	       (IM->Primitive[IM->LastPrimitive] & PRIM_MODE_MASK) == 
+	       PRIM_OUTSIDE_BEGIN_END) {
+	 ctx->Driver.CurrentExecPrimitive =
+	    IM->Primitive[IM->LastPrimitive] & PRIM_MODE_MASK;
+      }
+
+/*        fprintf(stderr, "%s: IM->Primitive[%d]: %x, CurrExecPrim: %x\n", */
+/*  	      __FUNCTION__, */
+/*  	      IM->LastPrimitive, */
+/*  	      IM->Primitive[IM->LastPrimitive],  */
+/*  	      ctx->Driver.CurrentExecPrimitive); */
+
+      _tnl_get_exec_copy_verts( ctx, IM );
+
+      if (IM->NormalLengthPtr) 
+	 fixup_normal_lengths( IM );
+      
+      if (IM->Count == IM->Start) 
+	 _tnl_copy_to_current( ctx, IM, IM->OrFlag, IM->LastData );
+      else {
+/*  	 _tnl_print_cassette( IM ); */
+	 _tnl_run_cassette( ctx, IM );
+      }
+
+      restore_compiled_primitives( ctx, IM );
+   }
+
+   if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1)
+      tnl->ReplayHardBeginEnd = 0;
+}
+
+static void
+destroy_compiled_cassette( GLcontext *ctx, void *data )
+{
+   TNLvertexcassette *node = (TNLvertexcassette *)data;
+
+   if ( --node->IM->ref_count == 0 )
+      _tnl_free_immediate( ctx, node->IM );
+}
+
+
+static void
+print_compiled_cassette( GLcontext *ctx, void *data )
+{
+   TNLvertexcassette *node = (TNLvertexcassette *)data;
+   struct immediate *IM = node->IM;
+
+   fprintf(stderr, "TNL-VERTEX-CASSETTE, id %u, rows %u..%u\n",
+	   node->IM->id, node->Start, node->Count);
+
+   IM->Start = node->Start;
+   IM->CopyStart = node->Start;
+   IM->Count = node->Count;
+   IM->BeginState = node->BeginState;
+   IM->OrFlag = node->OrFlag;
+   IM->TexSize = node->TexSize;
+   IM->AndFlag = node->AndFlag;
+   IM->LastData = node->LastData;
+   IM->LastPrimitive = node->LastPrimitive;
+   IM->LastMaterial = node->LastMaterial;
+   IM->MaterialOrMask = node->MaterialOrMask;
+   IM->MaterialAndMask = node->MaterialAndMask;
+
+   _tnl_print_cassette( node->IM );
+}
+
+void
+_tnl_BeginCallList( GLcontext *ctx, GLuint list )
+{
+   (void) ctx;
+   (void) list;
+   FLUSH_CURRENT(ctx, 0);	/* Current immediate is emptied on CallList */
+}
+
+
+/* Called at the tail of a CallList.  Make current immediate aware of
+ * any new to-be-copied vertices.
+ */
+void
+_tnl_EndCallList( GLcontext *ctx )
+{
+   GLuint beginstate = 0;
+
+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END)
+      beginstate = VERT_BEGIN_0|VERT_BEGIN_1;
+
+   _tnl_reset_exec_input( ctx, TNL_CURRENT_IM(ctx)->Start, beginstate, 0 );
+}
+
+
+void
+_tnl_EndList( GLcontext *ctx )
+{
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+
+   ctx->swtnl_im = 0;
+   IM->ref_count--;
+
+   /* outside begin/end, even in COMPILE_AND_EXEC,
+    * so no vertices to copy, right?
+    */
+   ASSERT(TNL_CONTEXT(ctx)->ExecCopyCount == 0);
+
+   /* If this one isn't free, get a clean one.  (Otherwise we'll be
+    * using one that's already half full).
+    */
+   if (IM->ref_count != 0)
+      IM = _tnl_alloc_immediate( ctx );
+
+   ASSERT(IM->ref_count == 0);
+
+   SET_IMMEDIATE( ctx, IM );
+   IM->ref_count++;
+
+   _tnl_reset_exec_input( ctx, IMM_MAX_COPIED_VERTS, 0, 0 );
+}
+
+
+void
+_tnl_NewList( GLcontext *ctx, GLuint list, GLenum mode )
+{
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+
+   /* Use the installed immediate struct.  No vertices in the current
+    * immediate, no copied vertices in the system.
+    */
+   ASSERT(TNL_CURRENT_IM(ctx));
+   ASSERT(TNL_CURRENT_IM(ctx)->Start == IMM_MAX_COPIED_VERTS);
+   ASSERT(TNL_CURRENT_IM(ctx)->Start == TNL_CURRENT_IM(ctx)->Count);
+   ASSERT(TNL_CONTEXT(ctx)->ExecCopyCount == 0);
+
+   /* Set current Begin/End state to unknown:
+    */
+   IM->BeginState = VERT_BEGIN_0;
+   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
+}
+
+
+void
+_tnl_dlist_init( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   tnl->opcode_vertex_cassette =
+      _mesa_alloc_opcode( ctx,
+			  sizeof(TNLvertexcassette),
+			  execute_compiled_cassette,
+			  destroy_compiled_cassette,
+			  print_compiled_cassette );
+}
+
+
+static void emit_material( struct gl_material *src, GLuint bitmask )
+{
+   if (bitmask & FRONT_EMISSION_BIT) 
+      glMaterialfv( GL_FRONT, GL_EMISSION, src[0].Emission );
+
+   if (bitmask & BACK_EMISSION_BIT) 
+      glMaterialfv( GL_BACK, GL_EMISSION, src[1].Emission );
+
+   if (bitmask & FRONT_AMBIENT_BIT) 
+      glMaterialfv( GL_FRONT, GL_AMBIENT, src[0].Ambient );
+
+   if (bitmask & BACK_AMBIENT_BIT) 
+      glMaterialfv( GL_BACK, GL_AMBIENT, src[1].Ambient );
+
+   if (bitmask & FRONT_DIFFUSE_BIT) 
+      glMaterialfv( GL_FRONT, GL_DIFFUSE, src[0].Diffuse );
+
+   if (bitmask & BACK_DIFFUSE_BIT) 
+      glMaterialfv( GL_BACK, GL_DIFFUSE, src[1].Diffuse );
+
+   if (bitmask & FRONT_SPECULAR_BIT) 
+      glMaterialfv( GL_FRONT, GL_SPECULAR, src[0].Specular );
+
+   if (bitmask & BACK_SPECULAR_BIT) 
+      glMaterialfv( GL_BACK, GL_SPECULAR, src[1].Specular );
+
+   if (bitmask & FRONT_SHININESS_BIT) 
+      glMaterialfv( GL_FRONT, GL_SHININESS, &src[0].Shininess );
+
+   if (bitmask & BACK_SHININESS_BIT) 
+      glMaterialfv( GL_BACK, GL_SHININESS, &src[1].Shininess );
+
+   if (bitmask & FRONT_INDEXES_BIT) {
+      GLfloat ind[3];
+      ind[0] = src[0].AmbientIndex;
+      ind[1] = src[0].DiffuseIndex;
+      ind[2] = src[0].SpecularIndex;
+      glMaterialfv( GL_FRONT, GL_COLOR_INDEXES, ind );
+   }
+
+   if (bitmask & BACK_INDEXES_BIT) {
+      GLfloat ind[3];
+      ind[0] = src[1].AmbientIndex;
+      ind[1] = src[1].DiffuseIndex;
+      ind[2] = src[1].SpecularIndex;
+      glMaterialfv( GL_BACK, GL_COLOR_INDEXES, ind );
+   }
+}
+
+
+/* Low-performance helper function to allow driver-supplied tnl
+ * modules to process tnl display lists.  This is primarily supplied
+ * to avoid fallbacks if CallList is invoked inside a Begin/End pair.
+ * For higher performance, drivers should fallback to tnl (if outside
+ * begin/end), or (for tnl hardware) implement their own display list
+ * mechanism. 
+ */
+static void loopback_compiled_cassette( GLcontext *ctx, struct immediate *IM )
+{
+   GLuint i;
+   GLuint *flags = IM->Flag;
+   GLuint orflag = IM->OrFlag;
+   GLuint j;
+   void (GLAPIENTRY *vertex)( const GLfloat * );
+   void (GLAPIENTRY *texcoordfv[MAX_TEXTURE_UNITS])( GLenum, const GLfloat * );
+   GLuint maxtex = 0;
+   GLuint p, length, prim = 0;
+
+/*     _tnl_print_vert_flags(__FUNCTION__, orflag); */
+
+   if (orflag & VERT_OBJ_234)
+      vertex = (void (GLAPIENTRY *)(const GLfloat *)) glVertex4fv;
+   else
+      vertex = (void (GLAPIENTRY *)(const GLfloat *)) glVertex3fv;
+   
+   if (orflag & VERT_TEX_ANY) {
+      for (j = 0 ; j < ctx->Const.MaxTextureUnits ; j++) {
+	 if (orflag & VERT_TEX(j)) {
+	    maxtex = j+1;
+	    if ((IM->TexSize & TEX_SIZE_4(j)) == TEX_SIZE_4(j))
+	       texcoordfv[j] = glMultiTexCoord4fvARB;
+	    else if (IM->TexSize & TEX_SIZE_3(j))
+	       texcoordfv[j] = glMultiTexCoord3fvARB;
+	    else
+	       texcoordfv[j] = glMultiTexCoord2fvARB;
+	 }
+      }      
+   }
+
+   for (p = IM->Start ; !(prim & PRIM_LAST) ; p += length)
+   {
+      prim = IM->Primitive[p];
+      length= IM->PrimitiveLength[p];
+      ASSERT(length || (prim & PRIM_LAST));
+      ASSERT((prim & PRIM_MODE_MASK) <= GL_POLYGON+1);
+
+      if (prim & PRIM_BEGIN) {
+	 glBegin(prim & PRIM_MODE_MASK);
+      }
+
+      for ( i = p ; i <= p+length ; i++) {
+	 if (flags[i] & VERT_TEX_ANY) {
+	    GLuint k;
+	    for (k = 0 ; k < maxtex ; k++) {
+	       if (flags[i] & VERT_TEX(k)) {
+		  texcoordfv[k]( GL_TEXTURE0_ARB + k, IM->TexCoord[k][i] );
+	       }
+	    }
+	 }
+
+	 if (flags[i] & VERT_NORM) {
+	    glNormal3fv(IM->Normal[i]);
+	 }
+
+	 if (flags[i] & VERT_RGBA) {
+	    glColor4fv( IM->Color[i] );
+	 }
+
+	 if (flags[i] & VERT_SPEC_RGB)
+	    _glapi_Dispatch->SecondaryColor3fvEXT( IM->SecondaryColor[i] );
+
+	 if (flags[i] & VERT_FOG_COORD)
+	    _glapi_Dispatch->FogCoordfEXT( IM->FogCoord[i] );
+
+	 if (flags[i] & VERT_INDEX)
+	    glIndexi( IM->Index[i] );
+
+	 if (flags[i] & VERT_EDGE)
+	    glEdgeFlag( IM->EdgeFlag[i] );
+
+	 if (flags[i] & VERT_MATERIAL) 
+	    emit_material( IM->Material[i], IM->MaterialMask[i] );
+
+	 if (flags[i]&VERT_OBJ_234) {
+	    vertex( IM->Obj[i] );
+	 }
+	 else if (flags[i] & VERT_EVAL_C1)
+	    glEvalCoord1f( IM->Obj[i][0] );
+	 else if (flags[i] & VERT_EVAL_P1)
+	    glEvalPoint1( (GLint) IM->Obj[i][0] );
+	 else if (flags[i] & VERT_EVAL_C2)
+	    glEvalCoord2f( IM->Obj[i][0], IM->Obj[i][1] );
+	 else if (flags[i] & VERT_EVAL_P2)
+	    glEvalPoint2( (GLint) IM->Obj[i][0], (GLint) IM->Obj[i][1] );
+      }
+
+      if (prim & PRIM_END) {
+	 glEnd();
+      }
+   }
+}
Index: xc/extras/Mesa/src/tnl/t_imm_dlist.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_dlist.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_dlist.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,44 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef _T_DLIST_H
+#define _T_DLIST_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+extern void _tnl_dlist_init( GLcontext *ctx );
+
+extern void _tnl_compile_cassette( GLcontext *ctx, struct immediate *IM );
+extern void _tnl_EndList( GLcontext *ctx );
+extern void _tnl_NewList( GLcontext *ctx, GLuint list, GLenum mode );
+
+extern void _tnl_EndCallList( GLcontext *ctx );
+extern void _tnl_BeginCallList( GLcontext *ctx, GLuint list );
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_elt.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_elt.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_elt.c	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,829 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "colormac.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+#include "math/m_translate.h"
+
+#include "t_context.h"
+#include "t_imm_elt.h"
+
+
+
+typedef void (*trans_elt_1f_func)(GLfloat *to,
+				  CONST void *ptr,
+				  GLuint stride,
+				  GLuint *flags,
+				  GLuint *elts,
+				  GLuint match,
+				  GLuint start,
+				  GLuint n );
+
+typedef void (*trans_elt_1ui_func)(GLuint *to,
+				   CONST void *ptr,
+				   GLuint stride,
+				   GLuint *flags,
+				   GLuint *elts,
+				   GLuint match,
+				   GLuint start,
+				   GLuint n );
+
+typedef void (*trans_elt_1ub_func)(GLubyte *to,
+				   CONST void *ptr,
+				   GLuint stride,
+				   GLuint *flags,
+				   GLuint *elts,
+				   GLuint match,
+				   GLuint start,
+				   GLuint n );
+
+typedef void (*trans_elt_4ub_func)(GLubyte (*to)[4],
+                                   CONST void *ptr,
+                                   GLuint stride,
+                                   GLuint *flags,
+                                   GLuint *elts,
+                                   GLuint match,
+                                   GLuint start,
+                                   GLuint n );
+
+typedef void (*trans_elt_4us_func)(GLushort (*to)[4],
+                                   CONST void *ptr,
+                                   GLuint stride,
+                                   GLuint *flags,
+                                   GLuint *elts,
+                                   GLuint match,
+                                   GLuint start,
+                                   GLuint n );
+
+typedef void (*trans_elt_4f_func)(GLfloat (*to)[4],
+				  CONST void *ptr,
+				  GLuint stride,
+				  GLuint *flags,
+				  GLuint *elts,
+				  GLuint match,
+				  GLuint start,
+				  GLuint n );
+
+typedef void (*trans_elt_3f_func)(GLfloat (*to)[3],
+				  CONST void *ptr,
+				  GLuint stride,
+				  GLuint *flags,
+				  GLuint *elts,
+				  GLuint match,
+				  GLuint start,
+				  GLuint n );
+
+
+
+
+static trans_elt_1f_func _tnl_trans_elt_1f_tab[MAX_TYPES];
+static trans_elt_1ui_func _tnl_trans_elt_1ui_tab[MAX_TYPES];
+static trans_elt_1ub_func _tnl_trans_elt_1ub_tab[MAX_TYPES];
+static trans_elt_3f_func  _tnl_trans_elt_3f_tab[MAX_TYPES];
+static trans_elt_4ub_func _tnl_trans_elt_4ub_tab[5][MAX_TYPES];
+static trans_elt_4us_func _tnl_trans_elt_4us_tab[5][MAX_TYPES];
+static trans_elt_4f_func  _tnl_trans_elt_4f_tab[5][MAX_TYPES];
+
+
+#define PTR_ELT(ptr, elt) (((SRC *)ptr)[elt])
+
+
+
+
+
+/* Code specific to array element implementation.  There is a small
+ * subtlety in the bits CHECK() tests, and the way bits are set in
+ * glArrayElement which ensures that if, eg, in the case that the
+ * vertex array is disabled and normal array is enabled, and we get
+ * either sequence:
+ *
+ * ArrayElement()    OR   Normal()
+ * Normal()               ArrayElement()
+ * Vertex()               Vertex()
+ *
+ * That the correct value for normal is used.
+ */
+#define TAB(x) _tnl_trans_elt##x##_tab
+#define ARGS   GLuint *flags, GLuint *elts, GLuint match, \
+               GLuint start, GLuint n
+#define SRC_START  0
+#define DST_START  start
+#define CHECK  if ((flags[i]&match) == VERT_ELT)
+#define NEXT_F  (void)1
+#define NEXT_F2 f = first + elts[i] * stride;
+
+
+/* GL_BYTE
+ */
+#define SRC GLbyte
+#define SRC_IDX TYPE_IDX(GL_BYTE)
+#define TRX_3F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   BYTE_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = BYTE_TO_UBYTE( PTR_ELT(f,n) )
+#define TRX_US(us, f,n)  us = BYTE_TO_USHORT( PTR_ELT(f,n) )
+#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
+
+
+#define SZ 4
+#define INIT init_trans_4_GLbyte_elt
+#define DEST_4F trans_4_GLbyte_4f_elt
+#define DEST_4UB trans_4_GLbyte_4ub_elt
+#define DEST_4US trans_4_GLbyte_4us_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLbyte_elt
+#define DEST_4F trans_3_GLbyte_4f_elt
+#define DEST_4UB trans_3_GLbyte_4ub_elt
+#define DEST_4US trans_3_GLbyte_4us_elt
+#define DEST_3F trans_3_GLbyte_3f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLbyte_elt
+#define DEST_4F trans_2_GLbyte_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLbyte_elt
+#define DEST_4F trans_1_GLbyte_4f_elt
+#define DEST_1UB trans_1_GLbyte_1ub_elt
+#define DEST_1UI trans_1_GLbyte_1ui_elt
+#include "math/m_trans_tmp.h"
+
+#undef SRC
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+#undef SRC_IDX
+
+/* GL_UNSIGNED_BYTE
+ */
+#define SRC GLubyte
+#define SRC_IDX TYPE_IDX(GL_UNSIGNED_BYTE)
+#define TRX_3F(f,n)	     UBYTE_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)	     UBYTE_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)	     ub = PTR_ELT(f,n)
+#define TRX_US(us, f,n)	     us = PTR_ELT(f,n)
+#define TRX_UI(f,n)          (GLuint)PTR_ELT(f,n)
+
+/* 4ub->4ub handled in special case below.
+ */
+#define SZ 4
+#define INIT init_trans_4_GLubyte_elt
+#define DEST_4F trans_4_GLubyte_4f_elt
+#define DEST_4US trans_4_GLubyte_4us_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLubyte_elt
+#define DEST_4F trans_3_GLubyte_4f_elt
+#define DEST_3F trans_3_GLubyte_3f_elt
+#define DEST_4UB trans_3_GLubyte_4ub_elt
+#define DEST_4US trans_3_GLubyte_4us_elt
+#include "math/m_trans_tmp.h"
+
+
+#define SZ 1
+#define INIT init_trans_1_GLubyte_elt
+#define DEST_1UI trans_1_GLubyte_1ui_elt
+#define DEST_1UB trans_1_GLubyte_1ub_elt
+#include "math/m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_SHORT
+ */
+#define SRC GLshort
+#define SRC_IDX TYPE_IDX(GL_SHORT)
+#define TRX_3F(f,n)   SHORT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = SHORT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = SHORT_TO_USHORT(PTR_ELT(f,n))
+#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
+
+
+#define SZ  4
+#define INIT init_trans_4_GLshort_elt
+#define DEST_4F trans_4_GLshort_4f_elt
+#define DEST_4UB trans_4_GLshort_4ub_elt
+#define DEST_4US trans_4_GLshort_4us_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLshort_elt
+#define DEST_4F trans_3_GLshort_4f_elt
+#define DEST_4UB trans_3_GLshort_4ub_elt
+#define DEST_4US trans_3_GLshort_4us_elt
+#define DEST_3F trans_3_GLshort_3f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLshort_elt
+#define DEST_4F trans_2_GLshort_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLshort_elt
+#define DEST_4F trans_1_GLshort_4f_elt
+#define DEST_1UB trans_1_GLshort_1ub_elt
+#define DEST_1UI trans_1_GLshort_1ui_elt
+#include "math/m_trans_tmp.h"
+
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_UNSIGNED_SHORT
+ */
+#define SRC GLushort
+#define SRC_IDX TYPE_IDX(GL_UNSIGNED_SHORT)
+#define TRX_3F(f,n)   USHORT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub,f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 8)
+#define TRX_US(us,f,n)  us = PTR_ELT(f,n)
+#define TRX_UI(f,n)  (GLuint)   PTR_ELT(f,n)
+
+
+#define SZ 4
+#define INIT init_trans_4_GLushort_elt
+#define DEST_4F trans_4_GLushort_4f_elt
+#define DEST_4UB trans_4_GLushort_4ub_elt
+#define DEST_4US trans_4_GLushort_4us_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLushort_elt
+#define DEST_4F trans_3_GLushort_4f_elt
+#define DEST_4UB trans_3_GLushort_4ub_elt
+#define DEST_4US trans_3_GLushort_4us_elt
+#define DEST_3F trans_3_GLushort_3f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLushort_elt
+#define DEST_4F trans_2_GLushort_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLushort_elt
+#define DEST_4F trans_1_GLushort_4f_elt
+#define DEST_1UB trans_1_GLushort_1ub_elt
+#define DEST_1UI trans_1_GLushort_1ui_elt
+#include "math/m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_INT
+ */
+#define SRC GLint
+#define SRC_IDX TYPE_IDX(GL_INT)
+#define TRX_3F(f,n)   INT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = INT_TO_UBYTE(PTR_ELT(f,n))
+#define TRX_US(us, f,n)  us = INT_TO_USHORT(PTR_ELT(f,n))
+#define TRX_UI(f,n)  (PTR_ELT(f,n) < 0 ? 0 : (GLuint)  PTR_ELT(f,n))
+
+
+#define SZ 4
+#define INIT init_trans_4_GLint_elt
+#define DEST_4F trans_4_GLint_4f_elt
+#define DEST_4UB trans_4_GLint_4ub_elt
+#define DEST_4US trans_4_GLint_4us_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLint_elt
+#define DEST_4F trans_3_GLint_4f_elt
+#define DEST_4UB trans_3_GLint_4ub_elt
+#define DEST_4US trans_3_GLint_4us_elt
+#define DEST_3F trans_3_GLint_3f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLint_elt
+#define DEST_4F trans_2_GLint_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLint_elt
+#define DEST_4F trans_1_GLint_4f_elt
+#define DEST_1UB trans_1_GLint_1ub_elt
+#define DEST_1UI trans_1_GLint_1ui_elt
+#include "math/m_trans_tmp.h"
+
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_UNSIGNED_INT
+ */
+#define SRC GLuint
+#define SRC_IDX TYPE_IDX(GL_UNSIGNED_INT)
+#define TRX_3F(f,n)   UINT_TO_FLOAT( PTR_ELT(f,n) )
+#define TRX_4F(f,n)   (GLfloat)( PTR_ELT(f,n) )
+#define TRX_UB(ub, f,n)  ub = (GLubyte) (PTR_ELT(f,n) >> 24)
+#define TRX_US(us, f,n)  us = (GLushort) (PTR_ELT(f,n) >> 16)
+#define TRX_UI(f,n)		PTR_ELT(f,n)
+
+
+#define SZ 4
+#define INIT init_trans_4_GLuint_elt
+#define DEST_4F trans_4_GLuint_4f_elt
+#define DEST_4UB trans_4_GLuint_4ub_elt
+#define DEST_4US trans_4_GLuint_4us_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLuint_elt
+#define DEST_4F trans_3_GLuint_4f_elt
+#define DEST_4UB trans_3_GLuint_4ub_elt
+#define DEST_4US trans_3_GLuint_4us_elt
+#define DEST_3F trans_3_GLuint_3f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLuint_elt
+#define DEST_4F trans_2_GLuint_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLuint_elt
+#define DEST_4F trans_1_GLuint_4f_elt
+#define DEST_1UB trans_1_GLuint_1ub_elt
+#define DEST_1UI trans_1_GLuint_1ui_elt
+#include "math/m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+/* GL_DOUBLE
+ */
+#define SRC GLdouble
+#define SRC_IDX TYPE_IDX(GL_DOUBLE)
+#define TRX_3F(f,n)    (GLfloat) PTR_ELT(f,n)
+#define TRX_4F(f,n)    (GLfloat) PTR_ELT(f,n)
+#define TRX_UB(ub,f,n) UNCLAMPED_FLOAT_TO_UBYTE(ub, PTR_ELT(f,n))
+#define TRX_US(us,f,n) UNCLAMPED_FLOAT_TO_USHORT(us, PTR_ELT(f,n))
+#define TRX_UI(f,n)    (GLuint) (GLint) PTR_ELT(f,n)
+#define TRX_1F(f,n)    (GLfloat) PTR_ELT(f,n)
+
+
+#define SZ 4
+#define INIT init_trans_4_GLdouble_elt
+#define DEST_4F trans_4_GLdouble_4f_elt
+#define DEST_4UB trans_4_GLdouble_4ub_elt
+#define DEST_4US trans_4_GLdouble_4us_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLdouble_elt
+#define DEST_4F trans_3_GLdouble_4f_elt
+#define DEST_4UB trans_3_GLdouble_4ub_elt
+#define DEST_4US trans_3_GLdouble_4us_elt
+#define DEST_3F trans_3_GLdouble_3f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLdouble_elt
+#define DEST_4F trans_2_GLdouble_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLdouble_elt
+#define DEST_4F trans_1_GLdouble_4f_elt
+#define DEST_1UB trans_1_GLdouble_1ub_elt
+#define DEST_1UI trans_1_GLdouble_1ui_elt
+#define DEST_1F trans_1_GLdouble_1f_elt
+#include "math/m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+
+/* GL_FLOAT
+ */
+#define SRC GLfloat
+#define SRC_IDX TYPE_IDX(GL_FLOAT)
+#define SZ 4
+#define INIT init_trans_4_GLfloat_elt
+#define DEST_4UB trans_4_GLfloat_4ub_elt
+#define DEST_4US trans_4_GLfloat_4us_elt
+#define DEST_4F  trans_4_GLfloat_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 3
+#define INIT init_trans_3_GLfloat_elt
+#define DEST_4F  trans_3_GLfloat_4f_elt
+#define DEST_4UB trans_3_GLfloat_4ub_elt
+#define DEST_4US trans_3_GLfloat_4us_elt
+#define DEST_3F trans_3_GLfloat_3f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 2
+#define INIT init_trans_2_GLfloat_elt
+#define DEST_4F trans_2_GLfloat_4f_elt
+#include "math/m_trans_tmp.h"
+
+#define SZ 1
+#define INIT init_trans_1_GLfloat_elt
+#define DEST_4F  trans_1_GLfloat_3f_elt
+#define DEST_1UB trans_1_GLfloat_1ub_elt
+#define DEST_1UI trans_1_GLfloat_1ui_elt
+#define DEST_1F trans_1_GLfloat_1f_elt
+#include "math/m_trans_tmp.h"
+
+#undef SRC
+#undef SRC_IDX
+#undef TRX_3F
+#undef TRX_4F
+#undef TRX_UB
+#undef TRX_US
+#undef TRX_UI
+
+
+static void trans_4_GLubyte_4ub(GLubyte (*t)[4],
+                                CONST void *Ptr,
+                                GLuint stride,
+                                ARGS )
+{
+   const GLubyte *f = (GLubyte *) Ptr + SRC_START * stride;
+   const GLubyte *first = f;
+   GLuint i;
+   (void) start;
+   if (((((long) f | (long) stride)) & 3L) == 0L) {
+      /* Aligned.
+       */
+      for (i = DST_START ; i < n ; i++, NEXT_F) {
+	 CHECK {
+	    NEXT_F2;
+	    COPY_4UBV( t[i], f );
+	 }
+      }
+   } else {
+      for (i = DST_START ; i < n ; i++, NEXT_F) {
+	 CHECK {
+	    NEXT_F2;
+	    t[i][0] = f[0];
+	    t[i][1] = f[1];
+	    t[i][2] = f[2];
+	    t[i][3] = f[3];
+	 }
+      }
+   }
+}
+
+
+static void init_translate_elt(void)
+{
+   MEMSET( TAB(_1ui), 0, sizeof(TAB(_1ui)) );
+   MEMSET( TAB(_1ub), 0, sizeof(TAB(_1ub)) );
+   MEMSET( TAB(_3f),  0, sizeof(TAB(_3f)) );
+   MEMSET( TAB(_4ub), 0, sizeof(TAB(_4ub)) );
+   MEMSET( TAB(_4us), 0, sizeof(TAB(_4us)) );
+   MEMSET( TAB(_4f),  0, sizeof(TAB(_4f)) );
+
+   TAB(_4ub)[4][TYPE_IDX(GL_UNSIGNED_BYTE)] = trans_4_GLubyte_4ub;
+
+   init_trans_4_GLbyte_elt();
+   init_trans_3_GLbyte_elt();
+   init_trans_2_GLbyte_elt();
+   init_trans_1_GLbyte_elt();
+   init_trans_1_GLubyte_elt();
+   init_trans_3_GLubyte_elt();
+   init_trans_4_GLubyte_elt();
+   init_trans_4_GLshort_elt();
+   init_trans_3_GLshort_elt();
+   init_trans_2_GLshort_elt();
+   init_trans_1_GLshort_elt();
+   init_trans_4_GLushort_elt();
+   init_trans_3_GLushort_elt();
+   init_trans_2_GLushort_elt();
+   init_trans_1_GLushort_elt();
+   init_trans_4_GLint_elt();
+   init_trans_3_GLint_elt();
+   init_trans_2_GLint_elt();
+   init_trans_1_GLint_elt();
+   init_trans_4_GLuint_elt();
+   init_trans_3_GLuint_elt();
+   init_trans_2_GLuint_elt();
+   init_trans_1_GLuint_elt();
+   init_trans_4_GLdouble_elt();
+   init_trans_3_GLdouble_elt();
+   init_trans_2_GLdouble_elt();
+   init_trans_1_GLdouble_elt();
+   init_trans_4_GLfloat_elt();
+   init_trans_3_GLfloat_elt();
+   init_trans_2_GLfloat_elt();
+   init_trans_1_GLfloat_elt();
+}
+
+
+#undef TAB
+#undef CLASS
+#undef ARGS
+#undef CHECK
+#undef START
+
+
+
+
+void _tnl_imm_elt_init( void )
+{
+   init_translate_elt();
+}
+
+
+static void _tnl_trans_elt_1f(GLfloat *to,
+		       const struct gl_client_array *from,
+		       GLuint *flags,
+		       GLuint *elts,
+		       GLuint match,
+		       GLuint start,
+		       GLuint n )
+{
+   _tnl_trans_elt_1f_tab[TYPE_IDX(from->Type)]( to,
+					      from->Ptr,
+					      from->StrideB,
+					      flags,
+					      elts,
+					      match,
+					      start,
+					      n );
+
+}
+
+static void _tnl_trans_elt_1ui(GLuint *to,
+			const struct gl_client_array *from,
+			GLuint *flags,
+			GLuint *elts,
+			GLuint match,
+			GLuint start,
+			GLuint n )
+{
+   _tnl_trans_elt_1ui_tab[TYPE_IDX(from->Type)]( to,
+					       from->Ptr,
+					       from->StrideB,
+					       flags,
+					       elts,
+					       match,
+					       start,
+					       n );
+
+}
+
+
+static void _tnl_trans_elt_1ub(GLubyte *to,
+			const struct gl_client_array *from,
+			GLuint *flags,
+			GLuint *elts,
+			GLuint match,
+			GLuint start,
+			GLuint n )
+{
+   _tnl_trans_elt_1ub_tab[TYPE_IDX(from->Type)]( to,
+                                                 from->Ptr,
+                                                 from->StrideB,
+                                                 flags,
+                                                 elts,
+                                                 match,
+                                                 start,
+                                                 n );
+
+}
+
+
+#if 0
+static void _tnl_trans_elt_4ub(GLubyte (*to)[4],
+                               const struct gl_client_array *from,
+                               GLuint *flags,
+                               GLuint *elts,
+                               GLuint match,
+                               GLuint start,
+                               GLuint n )
+{
+   _tnl_trans_elt_4ub_tab[from->Size][TYPE_IDX(from->Type)]( to,
+                                                             from->Ptr,
+                                                             from->StrideB,
+                                                             flags,
+                                                             elts,
+                                                             match,
+                                                             start,
+                                                             n );
+
+}
+#endif
+
+#if 0
+static void _tnl_trans_elt_4us(GLushort (*to)[4],
+                               const struct gl_client_array *from,
+                               GLuint *flags,
+                               GLuint *elts,
+                               GLuint match,
+                               GLuint start,
+                               GLuint n )
+{
+   _tnl_trans_elt_4us_tab[from->Size][TYPE_IDX(from->Type)]( to,
+                                                             from->Ptr,
+                                                             from->StrideB,
+                                                             flags,
+                                                             elts,
+                                                             match,
+                                                             start,
+                                                             n );
+
+}
+#endif
+
+static void _tnl_trans_elt_4f(GLfloat (*to)[4],
+                              const struct gl_client_array *from,
+                              GLuint *flags,
+                              GLuint *elts,
+                              GLuint match,
+                              GLuint start,
+                              GLuint n )
+{
+   _tnl_trans_elt_4f_tab[from->Size][TYPE_IDX(from->Type)]( to,
+					      from->Ptr,
+					      from->StrideB,
+					      flags,
+					      elts,
+					      match,
+					      start,
+					      n );
+
+}
+
+
+
+static void _tnl_trans_elt_3f(GLfloat (*to)[3],
+		       const struct gl_client_array *from,
+		       GLuint *flags,
+		       GLuint *elts,
+		       GLuint match,
+		       GLuint start,
+		       GLuint n )
+{
+   _tnl_trans_elt_3f_tab[TYPE_IDX(from->Type)]( to,
+					      from->Ptr,
+					      from->StrideB,
+					      flags,
+					      elts,
+					      match,
+					      start,
+					      n );
+}
+
+
+
+
+/* Batch function to translate away all the array elements in the
+ * input buffer prior to transform.  Done only the first time a vertex
+ * buffer is executed or compiled.
+ *
+ * KW: Have to do this after each glEnd if arrays aren't locked.
+ */
+void _tnl_translate_array_elts( GLcontext *ctx, struct immediate *IM,
+				GLuint start, GLuint count )
+{
+   GLuint *flags = IM->Flag;
+   GLuint *elts = IM->Elt;
+   GLuint translate = ctx->Array._Enabled;
+   GLuint i;
+
+   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
+      fprintf(stderr, "exec_array_elements %d .. %d\n", start, count);
+
+   if (translate & VERT_OBJ) {
+      _tnl_trans_elt_4f( IM->Obj,
+			 &ctx->Array.Vertex,
+			 flags, elts, (VERT_ELT|VERT_OBJ),
+			 start, count);
+
+      if (ctx->Array.Vertex.Size == 4)
+	 translate |= VERT_OBJ_234;
+      else if (ctx->Array.Vertex.Size == 3)
+	 translate |= VERT_OBJ_23;
+   }
+
+
+   if (translate & VERT_NORM)
+      _tnl_trans_elt_3f( IM->Normal,
+			 &ctx->Array.Normal,
+			 flags, elts, (VERT_ELT|VERT_NORM),
+			 start, count);
+
+   if (translate & VERT_EDGE)
+      _tnl_trans_elt_1ub( IM->EdgeFlag,
+			  &ctx->Array.EdgeFlag,
+			  flags, elts, (VERT_ELT|VERT_EDGE),
+			  start, count);
+
+   if (translate & VERT_RGBA) {
+      _tnl_trans_elt_4f( IM->Color,
+			 &ctx->Array.Color,
+			 flags, elts, (VERT_ELT|VERT_RGBA),
+			 start, count);
+   }
+
+   if (translate & VERT_SPEC_RGB) {
+      _tnl_trans_elt_4f( IM->SecondaryColor,
+			 &ctx->Array.SecondaryColor,
+			 flags, elts, (VERT_ELT|VERT_SPEC_RGB),
+			 start, count);
+   }
+
+   if (translate & VERT_FOG_COORD)
+      _tnl_trans_elt_1f( IM->FogCoord,
+			 &ctx->Array.FogCoord,
+			 flags, elts, (VERT_ELT|VERT_FOG_COORD),
+			 start, count);
+
+   if (translate & VERT_INDEX)
+      _tnl_trans_elt_1ui( IM->Index,
+			  &ctx->Array.Index,
+			  flags, elts, (VERT_ELT|VERT_INDEX),
+			  start, count);
+
+   if (translate & VERT_TEX_ANY) {
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+	 if (translate & VERT_TEX(i)) {
+	    _tnl_trans_elt_4f( IM->TexCoord[i],
+			       &ctx->Array.TexCoord[i],
+			       flags, elts, (VERT_ELT|VERT_TEX(i)),
+			       start, count);
+
+	    if (ctx->Array.TexCoord[i].Size == 4)
+	       IM->TexSize |= TEX_SIZE_4(i);
+	    else if (ctx->Array.TexCoord[i].Size == 3)
+	       IM->TexSize |= TEX_SIZE_3(i);
+	 }
+   }
+
+   for (i = start ; i < count ; i++)
+      if (flags[i] & VERT_ELT) flags[i] |= translate;
+
+   IM->FlushElt = 0;
+}
Index: xc/extras/Mesa/src/tnl/t_imm_elt.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_elt.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_elt.h	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,45 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#ifndef _T_IMM_ELT_H_
+#define _T_IMM_ELT_H_
+
+#include "mtypes.h"
+#include "t_context.h"
+
+
+extern void _tnl_imm_elt_init( void );
+
+extern void _tnl_translate_array_elts( GLcontext *ctx,
+				       struct immediate *IM,
+				       GLuint start,
+				       GLuint end );
+
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_eval.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_eval.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_eval.c	Mon Dec 16 11:18:45 2002
@@ -0,0 +1,731 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ *
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+#include "math/m_eval.h"
+
+#include "t_context.h"
+#include "t_imm_debug.h"
+#include "t_imm_eval.h"
+#include "t_imm_exec.h"
+#include "t_imm_fixup.h"
+#include "t_imm_alloc.h"
+
+
+static void eval_points1( GLfloat outcoord[][4],
+			  GLfloat coord[][4],
+			  const GLuint *flags,
+			  GLfloat du, GLfloat u1 )
+{
+   GLuint i;
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & VERT_EVAL_ANY) {
+	 outcoord[i][0] = coord[i][0];
+	 outcoord[i][1] = coord[i][1];
+	 if (flags[i] & VERT_EVAL_P1)
+	    outcoord[i][0] = coord[i][0] * du + u1;
+      }
+}
+
+static void eval_points2( GLfloat outcoord[][4],
+			  GLfloat coord[][4],
+			  const GLuint *flags,
+			  GLfloat du, GLfloat u1,
+			  GLfloat dv, GLfloat v1 )
+{
+   GLuint i;
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++) {
+      if (flags[i] & VERT_EVAL_ANY) {
+	 outcoord[i][0] = coord[i][0];
+	 outcoord[i][1] = coord[i][1];
+	 if (flags[i] & VERT_EVAL_P2) {
+	    outcoord[i][0] = coord[i][0] * du + u1;
+	    outcoord[i][1] = coord[i][1] * dv + v1;
+	 }
+      }
+   }
+}
+
+static const GLubyte dirty_flags[5] = {
+   0,				/* not possible */
+   VEC_DIRTY_0,
+   VEC_DIRTY_1,
+   VEC_DIRTY_2,
+   VEC_DIRTY_3
+};
+
+
+static void eval1_4f( GLvector4f *dest,
+		      GLfloat coord[][4],
+		      const GLuint *flags,
+		      GLuint dimension,
+		      struct gl_1d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   GLfloat (*to)[4] = dest->data;
+   GLuint i;
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 ASSIGN_4V(to[i], 0,0,0,1);
+	 _math_horner_bezier_curve(map->Points, to[i], u,
+				   dimension, map->Order);
+      }
+
+   dest->size = MAX2(dest->size, dimension);
+   dest->flags |= dirty_flags[dimension];
+}
+
+static void eval1_4f_ca( struct gl_client_array *dest,
+			 GLfloat coord[][4],
+			 const GLuint *flags,
+			 GLuint dimension,
+			 struct gl_1d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   GLfloat (*to)[4] = (GLfloat (*)[4])dest->Ptr;
+   GLuint i;
+
+   ASSERT(dest->Type == GL_FLOAT);
+   ASSERT(dest->StrideB == 4 * sizeof(GLfloat));
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 ASSIGN_4V(to[i], 0,0,0,1);
+	 _math_horner_bezier_curve(map->Points, to[i], u,
+				   dimension, map->Order);
+      }
+
+   dest->Size = MAX2(dest->Size, (GLint) dimension);
+}
+
+
+static void eval1_1ui( GLvector1ui *dest,
+		       GLfloat coord[][4],
+		       const GLuint *flags,
+		       struct gl_1d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   GLuint *to = dest->data;
+   GLuint i;
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 GLfloat tmp;
+	 _math_horner_bezier_curve(map->Points, &tmp, u, 1, map->Order);
+	 to[i] = (GLuint) (GLint) tmp;
+      }
+
+}
+
+static void eval1_norm( GLvector3f *dest,
+			GLfloat coord[][4],
+			const GLuint *flags,
+			struct gl_1d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   GLfloat (*to)[3] = dest->data;
+   GLuint i;
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 _math_horner_bezier_curve(map->Points, to[i], u, 3, map->Order);
+      }
+}
+
+
+
+
+
+static void eval2_obj_norm( GLvector4f *obj_ptr,
+			    GLvector3f *norm_ptr,
+			    GLfloat coord[][4],
+			    GLuint *flags,
+			    GLuint dimension,
+			    struct gl_2d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   const GLfloat v1 = map->v1;
+   const GLfloat dv = map->dv;
+   GLfloat (*obj)[4] = obj_ptr->data;
+   GLfloat (*normal)[3] = norm_ptr->data;
+   GLuint i;
+
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 GLfloat v = (coord[i][1] - v1) * dv;
+	 GLfloat du[4], dv[4];
+
+	 ASSIGN_4V(obj[i], 0,0,0,1);
+	 _math_de_casteljau_surf(map->Points, obj[i], du, dv, u, v, dimension,
+				 map->Uorder, map->Vorder);
+
+	 if (dimension == 4) {
+	    du[0] = du[0]*obj[i][3] - du[3]*obj[i][0];
+	    du[1] = du[1]*obj[i][3] - du[3]*obj[i][1];
+	    du[2] = du[2]*obj[i][3] - du[3]*obj[i][2];
+	 
+	    dv[0] = dv[0]*obj[i][3] - dv[3]*obj[i][0];
+	    dv[1] = dv[1]*obj[i][3] - dv[3]*obj[i][1];
+	    dv[2] = dv[2]*obj[i][3] - dv[3]*obj[i][2];
+	 }
+
+	 CROSS3(normal[i], du, dv);
+	 NORMALIZE_3FV(normal[i]);
+      }
+
+   obj_ptr->size = MAX2(obj_ptr->size, dimension);
+   obj_ptr->flags |= dirty_flags[dimension];
+}
+
+
+static void eval2_4f( GLvector4f *dest,
+		      GLfloat coord[][4],
+		      const GLuint *flags,
+		      GLuint dimension,
+		      struct gl_2d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   const GLfloat v1 = map->v1;
+   const GLfloat dv = map->dv;
+   GLfloat (*to)[4] = dest->data;
+   GLuint i;
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 GLfloat v = (coord[i][1] - v1) * dv;
+
+	 _math_horner_bezier_surf(map->Points, to[i], u, v, dimension,
+				  map->Uorder, map->Vorder);
+      }
+
+   dest->size = MAX2(dest->size, dimension);
+   dest->flags |= dirty_flags[dimension];
+}
+
+static void eval2_4f_ca( struct gl_client_array *dest,
+			 GLfloat coord[][4],
+			 const GLuint *flags,
+			 GLuint dimension,
+			 struct gl_2d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   const GLfloat v1 = map->v1;
+   const GLfloat dv = map->dv;
+   GLfloat (*to)[4] = (GLfloat (*)[4])dest->Ptr;
+   GLuint i;
+
+   ASSERT(dest->Type == GL_FLOAT);
+   ASSERT(dest->StrideB == 4 * sizeof(GLfloat));
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 GLfloat v = (coord[i][1] - v1) * dv;
+	 _math_horner_bezier_surf(map->Points, to[i], u, v, dimension,
+				  map->Uorder, map->Vorder);
+      }
+
+   dest->Size = MAX2(dest->Size, (GLint) dimension);
+}
+
+
+static void eval2_norm( GLvector3f *dest,
+			GLfloat coord[][4],
+			GLuint *flags,
+			struct gl_2d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   const GLfloat v1 = map->v1;
+   const GLfloat dv = map->dv;
+   GLfloat (*to)[3] = dest->data;
+   GLuint i;
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 GLfloat v = (coord[i][1] - v1) * dv;
+	 _math_horner_bezier_surf(map->Points, to[i], u, v, 3,
+				  map->Uorder, map->Vorder);
+     }
+
+}
+
+
+static void eval2_1ui( GLvector1ui *dest,
+		       GLfloat coord[][4],
+		       const GLuint *flags,
+		       struct gl_2d_map *map )
+{
+   const GLfloat u1 = map->u1;
+   const GLfloat du = map->du;
+   const GLfloat v1 = map->v1;
+   const GLfloat dv = map->dv;
+   GLuint *to = dest->data;
+   GLuint i;
+
+   for (i = 0 ; !(flags[i] & VERT_END_VB) ; i++)
+      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
+	 GLfloat u = (coord[i][0] - u1) * du;
+	 GLfloat v = (coord[i][1] - v1) * dv;
+	 GLfloat tmp;
+	 _math_horner_bezier_surf(map->Points, &tmp, u, v, 1,
+				  map->Uorder, map->Vorder);
+
+	 to[i] = (GLuint) (GLint) tmp;
+      }
+}
+
+
+
+
+
+
+static void copy_4f( GLfloat to[][4], GLfloat from[][4], GLuint count )
+{
+   MEMCPY( to, from, count * sizeof(to[0]));
+}
+
+static void copy_4f_stride( GLfloat to[][4], GLfloat *from, 
+			    GLuint stride, GLuint count )
+{
+   if (stride == 4 * sizeof(GLfloat))
+      MEMCPY( to, from, count * sizeof(to[0]));
+   else {
+      GLuint i;
+      for (i = 0 ; i < count ; i++, STRIDE_F(from, stride))
+	 COPY_4FV( to[i], from );
+   }
+}
+
+static void copy_3f( GLfloat to[][3], GLfloat from[][3], GLuint count )
+{
+   GLuint i;
+   for (i = 0 ; i < count ; i++) {
+      COPY_3FV(to[i], from[i]);
+   }
+}
+
+
+static void copy_1ui( GLuint to[], GLuint from[], GLuint count )
+{
+   MEMCPY( to, from, (count) * sizeof(to[0]));
+}
+
+
+
+/* Translate eval enabled flags to VERT_* flags.
+ */
+static void update_eval( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint eval1 = 0, eval2 = 0;
+
+   if (ctx->Eval.Map1Index)
+      eval1 |= VERT_INDEX;
+
+   if (ctx->Eval.Map2Index)
+      eval2 |= VERT_INDEX;
+
+   if (ctx->Eval.Map1Color4)
+      eval1 |= VERT_RGBA;
+
+   if (ctx->Eval.Map2Color4)
+      eval2 |= VERT_RGBA;
+
+   if (ctx->Eval.Map1Normal)
+      eval1 |= VERT_NORM;
+
+   if (ctx->Eval.Map2Normal)
+      eval2 |= VERT_NORM;
+
+   if (ctx->Eval.Map1TextureCoord4 ||
+       ctx->Eval.Map1TextureCoord3 ||
+       ctx->Eval.Map1TextureCoord2 ||
+       ctx->Eval.Map1TextureCoord1)
+      eval1 |= VERT_TEX0;
+
+   if (ctx->Eval.Map2TextureCoord4 ||
+       ctx->Eval.Map2TextureCoord3 ||
+       ctx->Eval.Map2TextureCoord2 ||
+       ctx->Eval.Map2TextureCoord1)
+      eval2 |= VERT_TEX0;
+
+   if (ctx->Eval.Map1Vertex4)
+      eval1 |= VERT_OBJ_234;
+
+   if (ctx->Eval.Map1Vertex3)
+      eval1 |= VERT_OBJ_23;
+
+   if (ctx->Eval.Map2Vertex4) {
+      if (ctx->Eval.AutoNormal)
+	 eval2 |= VERT_OBJ_234 | VERT_NORM;
+      else
+	 eval2 |= VERT_OBJ_234;
+   }
+   else if (ctx->Eval.Map2Vertex3) {
+      if (ctx->Eval.AutoNormal)
+	 eval2 |= VERT_OBJ_23 | VERT_NORM;
+      else
+	 eval2 |= VERT_OBJ_23;
+   }
+
+   tnl->eval.EvalMap1Flags = eval1;
+   tnl->eval.EvalMap2Flags = eval2;
+   tnl->eval.EvalNewState = 0;
+}
+
+
+/* This looks a lot like a pipeline stage, but for various reasons is
+ * better handled outside the pipeline, and considered the final stage
+ * of fixing up an immediate struct for execution.
+ *
+ * Really want to cache the results of this function in display lists,
+ * at least for EvalMesh commands.
+ */
+void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_arrays *tmp = &tnl->imm_inputs;
+   struct immediate *store = tnl->eval.im;
+   GLuint *flags = IM->Flag + IM->CopyStart;
+   GLuint copycount;
+   GLuint orflag = IM->OrFlag;
+   GLuint any_eval1 = orflag & (VERT_EVAL_C1|VERT_EVAL_P1);
+   GLuint any_eval2 = orflag & (VERT_EVAL_C2|VERT_EVAL_P2);
+   GLuint req = 0;
+   GLuint purge_flags = 0;
+   GLfloat (*coord)[4] = IM->Obj + IM->CopyStart;
+
+   if (IM->AndFlag & VERT_EVAL_ANY)
+      copycount = IM->Start - IM->CopyStart; /* just copy copied vertices */
+   else
+      copycount = IM->Count - IM->CopyStart; /* copy all vertices */
+
+   if (!store)
+      store = tnl->eval.im = _tnl_alloc_immediate( ctx );
+
+   if (tnl->eval.EvalNewState & _NEW_EVAL)
+      update_eval( ctx );
+
+   if (any_eval1) {
+      req |= tnl->pipeline.inputs & tnl->eval.EvalMap1Flags;
+
+      if (!ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3)
+	 purge_flags = (VERT_EVAL_P1|VERT_EVAL_C1);
+
+      if (orflag & VERT_EVAL_P1) {
+	 eval_points1( store->Obj + IM->CopyStart, 
+		       coord, flags,
+		       ctx->Eval.MapGrid1du,
+		       ctx->Eval.MapGrid1u1);
+	 
+	 coord = store->Obj + IM->CopyStart;
+      }
+   }
+
+   if (any_eval2) {
+      req |= tnl->pipeline.inputs & tnl->eval.EvalMap2Flags;
+
+      if (!ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3)
+	 purge_flags |= (VERT_EVAL_P2|VERT_EVAL_C2);
+
+      if (orflag & VERT_EVAL_P2) {
+	 eval_points2( store->Obj + IM->CopyStart, 
+		       coord, flags,
+		       ctx->Eval.MapGrid2du,
+		       ctx->Eval.MapGrid2u1,
+		       ctx->Eval.MapGrid2dv,
+		       ctx->Eval.MapGrid2v1 );
+
+	 coord = store->Obj + IM->CopyStart;
+      }
+   }
+
+
+/*     _tnl_print_vert_flags(__FUNCTION__, req); */
+
+   /* Perform the evaluations on active data elements.
+    */
+   if (req & VERT_INDEX)
+   {
+      GLuint generated = 0;
+
+      if (copycount)
+	 copy_1ui( store->Index + IM->CopyStart, tmp->Index.data, copycount );
+
+      tmp->Index.data = store->Index + IM->CopyStart;
+      tmp->Index.start = store->Index + IM->CopyStart;
+
+      if (ctx->Eval.Map1Index && any_eval1) {
+	 eval1_1ui( &tmp->Index, coord, flags, &ctx->EvalMap.Map1Index );
+	 generated |= VERT_EVAL_C1|VERT_EVAL_P1;
+      }
+
+      if (ctx->Eval.Map2Index && any_eval2) {
+	 eval2_1ui( &tmp->Index, coord, flags, &ctx->EvalMap.Map2Index );
+	 generated |= VERT_EVAL_C2|VERT_EVAL_P2;
+      }
+   }
+
+   if (req & VERT_RGBA)
+   {
+      GLuint generated = 0;
+
+      if (copycount) 
+	 copy_4f_stride( store->Color + IM->CopyStart, 
+			 (GLfloat *)tmp->Color.Ptr, 
+			 tmp->Color.StrideB,
+			 copycount );
+
+      tmp->Color.Ptr = store->Color + IM->CopyStart;
+      tmp->Color.StrideB = 4 * sizeof(GLfloat);
+      tmp->Color.Flags = 0;
+      tnl->vb.importable_data &= ~VERT_RGBA;
+
+      if (ctx->Eval.Map1Color4 && any_eval1) {
+	 eval1_4f_ca( &tmp->Color, coord, flags, 4, &ctx->EvalMap.Map1Color4 );
+	 generated |= VERT_EVAL_C1|VERT_EVAL_P1;
+      }
+
+      if (ctx->Eval.Map2Color4 && any_eval2) {
+	 eval2_4f_ca( &tmp->Color, coord, flags, 4, &ctx->EvalMap.Map2Color4 );
+	 generated |= VERT_EVAL_C2|VERT_EVAL_P2;
+      }
+   }
+
+
+   if (req & VERT_TEX(0))
+   {
+      GLuint generated = 0;
+
+      if (copycount)
+	 copy_4f( store->TexCoord[0] + IM->CopyStart, 
+		  tmp->TexCoord[0].data, copycount );
+      else
+	 tmp->TexCoord[0].size = 0;
+
+      tmp->TexCoord[0].data = store->TexCoord[0] + IM->CopyStart;
+      tmp->TexCoord[0].start = (GLfloat *)tmp->TexCoord[0].data;
+
+      if (any_eval1) {
+	 if (ctx->Eval.Map1TextureCoord4) {
+	    eval1_4f( &tmp->TexCoord[0], coord, flags, 4,
+		      &ctx->EvalMap.Map1Texture4 );
+	    generated |= VERT_EVAL_C1|VERT_EVAL_P1;
+	 }
+	 else if (ctx->Eval.Map1TextureCoord3) {
+	    eval1_4f( &tmp->TexCoord[0], coord, flags, 3,
+		      &ctx->EvalMap.Map1Texture3 );
+	    generated |= VERT_EVAL_C1|VERT_EVAL_P1;
+	 }
+	 else if (ctx->Eval.Map1TextureCoord2) {
+	    eval1_4f( &tmp->TexCoord[0], coord, flags, 2,
+		      &ctx->EvalMap.Map1Texture2 );
+	    generated |= VERT_EVAL_C1|VERT_EVAL_P1;
+	 }
+	 else if (ctx->Eval.Map1TextureCoord1) {
+	    eval1_4f( &tmp->TexCoord[0], coord, flags, 1,
+		      &ctx->EvalMap.Map1Texture1 );
+	    generated |= VERT_EVAL_C1|VERT_EVAL_P1;
+	 }
+      }
+
+      if (any_eval2) {
+	 if (ctx->Eval.Map2TextureCoord4) {
+	    eval2_4f( &tmp->TexCoord[0], coord, flags, 4,
+		      &ctx->EvalMap.Map2Texture4 );
+	    generated |= VERT_EVAL_C2|VERT_EVAL_P2;
+	 }
+	 else if (ctx->Eval.Map2TextureCoord3) {
+	    eval2_4f( &tmp->TexCoord[0], coord, flags, 3,
+		      &ctx->EvalMap.Map2Texture3 );
+	    generated |= VERT_EVAL_C2|VERT_EVAL_P2;
+	 }
+	 else if (ctx->Eval.Map2TextureCoord2) {
+	    eval2_4f( &tmp->TexCoord[0], coord, flags, 2,
+		      &ctx->EvalMap.Map2Texture2 );
+	    generated |= VERT_EVAL_C2|VERT_EVAL_P2;
+	 }
+	 else if (ctx->Eval.Map2TextureCoord1) {
+	    eval2_4f( &tmp->TexCoord[0], coord, flags, 1,
+		      &ctx->EvalMap.Map2Texture1 );
+	    generated |= VERT_EVAL_C2|VERT_EVAL_P2;
+	 }
+      }
+   }
+
+
+   if (req & VERT_NORM)
+   {
+      GLuint generated = 0;
+
+      if (copycount) {
+	 copy_3f( store->Normal + IM->CopyStart, tmp->Normal.data, 
+		  copycount );
+      }
+
+      tmp->Normal.data = store->Normal + IM->CopyStart;
+      tmp->Normal.start = (GLfloat *)tmp->Normal.data;
+
+      if (ctx->Eval.Map1Normal && any_eval1) {
+	 eval1_norm( &tmp->Normal, coord, flags,
+		     &ctx->EvalMap.Map1Normal );
+	 generated |= VERT_EVAL_C1|VERT_EVAL_P1;
+      }
+
+      if (ctx->Eval.Map2Normal && any_eval2) {
+	 eval2_norm( &tmp->Normal, coord, flags,
+		     &ctx->EvalMap.Map2Normal );
+	 generated |= VERT_EVAL_C2|VERT_EVAL_P2;
+      }
+   }
+
+
+
+   /* In the AutoNormal case, the copy and assignment of tmp->NormalPtr
+    * are done above.
+    */
+   if (req & VERT_OBJ)
+   {
+      if (copycount) {
+	 /* This copy may already have occurred when eliminating
+	  * glEvalPoint calls:
+	  */
+	 if  (coord != store->Obj + IM->CopyStart)
+	    copy_4f( store->Obj + IM->CopyStart, tmp->Obj.data, copycount );
+      } else
+	 tmp->Obj.size = 0;
+
+      tmp->Obj.data = store->Obj + IM->CopyStart;
+      tmp->Obj.start = (GLfloat *)tmp->Obj.data;
+
+      /* Note: Normal data is already prepared above.
+       */
+
+      if (any_eval1) {
+	 if (ctx->Eval.Map1Vertex4) {
+	    eval1_4f( &tmp->Obj, coord, flags, 4,
+		      &ctx->EvalMap.Map1Vertex4 );
+	 }
+	 else if (ctx->Eval.Map1Vertex3) {
+	    eval1_4f( &tmp->Obj, coord, flags, 3,
+		      &ctx->EvalMap.Map1Vertex3 );
+	 }
+      }
+
+      if (any_eval2) {
+	 if (ctx->Eval.Map2Vertex4)
+	 {
+	    if (ctx->Eval.AutoNormal && (req & VERT_NORM))
+	       eval2_obj_norm( &tmp->Obj, &tmp->Normal, coord, flags, 4,
+			       &ctx->EvalMap.Map2Vertex4 );
+	    else
+	       eval2_4f( &tmp->Obj, coord, flags, 4,
+			 &ctx->EvalMap.Map2Vertex4 );
+	 }
+	 else if (ctx->Eval.Map2Vertex3)
+	 {
+	    if (ctx->Eval.AutoNormal && (req & VERT_NORM))
+	       eval2_obj_norm( &tmp->Obj, &tmp->Normal, coord, flags, 3,
+			       &ctx->EvalMap.Map2Vertex3 );
+	    else
+	       eval2_4f( &tmp->Obj, coord, flags, 3,
+			 &ctx->EvalMap.Map2Vertex3 );
+	 }
+      }
+   }
+
+
+   /* Calculate new IM->Elts, IM->Primitive, IM->PrimitiveLength for
+    * the case where vertex maps are not enabled for some received
+    * eval coordinates.  In this case those slots in the immediate
+    * must be ignored.
+    */
+   if (purge_flags) {
+      GLuint vertex = VERT_OBJ|(VERT_EVAL_ANY & ~purge_flags);
+      GLuint last_new_prim = 0;
+      GLuint new_prim_length = 0;
+      GLuint next_old_prim = 0;
+      struct vertex_buffer *VB = &tnl->vb;
+      GLuint i,j,count = VB->Count;
+
+      for (i = 0, j = 0 ; i < count ; i++) {
+	 if (flags[i] & vertex) {
+	    store->Elt[j++] = i;
+	    new_prim_length++;
+	 }
+	 if (i == next_old_prim) {
+	    next_old_prim += VB->PrimitiveLength[i];
+	    VB->PrimitiveLength[last_new_prim] = new_prim_length;
+	    VB->Primitive[j] = VB->Primitive[i];
+	    last_new_prim = j;
+	 }
+      }
+      
+      VB->Elts = store->Elt;
+      _tnl_get_purged_copy_verts( ctx, store );
+   }
+
+   /* Produce new flags array:
+    */
+   {
+      GLuint i;
+      GLuint count = tnl->vb.Count + 1;
+
+      copy_1ui( store->Flag, flags, count );
+      tnl->vb.Flag = store->Flag;
+      for (i = 0 ; i < count ; i++)
+	 store->Flag[i] |= req;
+      IM->Evaluated = req;	/* hack for copying. */
+   }
+}
Index: xc/extras/Mesa/src/tnl/t_imm_eval.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_eval.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_eval.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,38 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _T_IMM_EVAL_H
+#define _T_IMM_EVAL_H
+
+
+#include "mtypes.h"
+#include "t_context.h"
+
+extern void _tnl_eval_init( void );
+
+extern void _tnl_eval_immediate( GLcontext *ctx, struct immediate *IM );
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_exec.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_exec.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_exec.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,573 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "enums.h"
+#include "dlist.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "light.h"
+#include "state.h"
+#include "mtypes.h"
+
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_array_import.h"
+#include "t_imm_alloc.h"
+#include "t_imm_api.h"
+#include "t_imm_debug.h"
+#include "t_imm_dlist.h"
+#include "t_imm_eval.h"
+#include "t_imm_elt.h"
+#include "t_imm_exec.h"
+#include "t_imm_fixup.h"
+#include "t_pipeline.h"
+
+
+
+static void reset_input( GLcontext *ctx,
+			 GLuint start,
+			 GLuint beginstate,
+			 GLuint savedbeginstate )
+{
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+
+   /* Clear the dirty part of the flag array.
+    */
+   if (start < IM->Count+2)
+      MEMSET(IM->Flag + start, 0, sizeof(GLuint) * (IM->Count+2-start));
+
+   if (MESA_VERBOSE & VERBOSE_IMMEDIATE)
+      fprintf(stderr, "reset_input: IM(%d) new %x\n", 
+	      IM->id, beginstate);
+
+   IM->Start = start;
+   IM->Count = start;
+   IM->LastMaterial = start;
+   IM->BeginState = beginstate;
+   IM->SavedBeginState = savedbeginstate;
+   IM->TexSize = 0;
+   IM->MaterialOrMask = 0;
+
+   if (IM->MaterialMask) 
+      IM->MaterialMask[IM->Start] = 0;
+
+   IM->ArrayEltFlags = ~ctx->Array._Enabled;
+   IM->ArrayEltIncr = ctx->Array.Vertex.Enabled ? 1 : 0;
+   IM->ArrayEltFlush = ctx->Array.LockCount ? FLUSH_ELT_LAZY : FLUSH_ELT_EAGER;
+}
+  
+void _tnl_reset_exec_input( GLcontext *ctx,
+			    GLuint start,
+			    GLuint beginstate,
+			    GLuint savedbeginstate )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+
+   reset_input( ctx, start, beginstate, savedbeginstate );
+
+   IM->CopyStart = start - tnl->ExecCopyCount;
+   IM->Primitive[IM->CopyStart] = ctx->Driver.CurrentExecPrimitive;
+   if (tnl->ExecParity)
+      IM->Primitive[IM->CopyStart] |= PRIM_PARITY;
+
+   IM->LastPrimitive = IM->CopyStart;
+}
+
+
+void _tnl_reset_compile_input( GLcontext *ctx,
+			    GLuint start,
+			    GLuint beginstate,
+			    GLuint savedbeginstate )
+{
+   struct immediate *IM = TNL_CURRENT_IM(ctx);
+
+   reset_input( ctx, start, beginstate, savedbeginstate );
+   IM->CopyStart = start;
+   IM->LastPrimitive = IM->Start;
+}
+  
+
+void _tnl_copy_to_current( GLcontext *ctx, struct immediate *IM,
+			   GLuint flag, GLuint count )
+{
+   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
+      _tnl_print_vert_flags("copy to current", flag);
+
+   if (flag & VERT_NORM)
+      COPY_3FV( ctx->Current.Normal, IM->Normal[count]);
+
+   if (flag & VERT_INDEX)
+      ctx->Current.Index = IM->Index[count];
+
+   if (flag & VERT_EDGE)
+      ctx->Current.EdgeFlag = IM->EdgeFlag[count];
+
+   if (flag & VERT_RGBA) {
+      COPY_4FV(ctx->Current.Color, IM->Color[count]);
+      if (ctx->Light.ColorMaterialEnabled) {
+	 _mesa_update_color_material( ctx, ctx->Current.Color );
+	 TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+      }
+   }
+
+   if (flag & VERT_SPEC_RGB)
+      COPY_4FV(ctx->Current.SecondaryColor, IM->SecondaryColor[count]);
+
+   if (flag & VERT_FOG_COORD)
+      ctx->Current.FogCoord = IM->FogCoord[count];
+
+   if (flag & VERT_TEX_ANY) {
+      GLuint i;
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
+	 if (flag & VERT_TEX(i)) {
+	    COPY_4FV( ctx->Current.Texcoord[0], IM->TexCoord[0][count]);
+	 }
+      }
+   }
+
+   if (flag & VERT_MATERIAL) {
+      _mesa_update_material( ctx,
+			  IM->Material[IM->LastMaterial],
+			  IM->MaterialOrMask );
+
+      TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+   }
+}
+
+
+
+void _tnl_compute_orflag( struct immediate *IM, GLuint start )
+{
+   GLuint count = IM->Count;
+   GLuint orflag = 0;
+   GLuint andflag = ~0U;
+   GLuint i;
+
+   IM->LastData = count-1;
+
+
+   /* Compute the flags for the whole buffer.
+    */
+   for (i = start ; i < count ; i++) {
+      andflag &= IM->Flag[i];
+      orflag |= IM->Flag[i];
+   }
+
+   /* It is possible there will be data in the buffer arising from
+    * calls like 'glNormal', 'glMaterial' that occur after the final
+    * glVertex, glEval, etc.  Additionally, a buffer can consist of
+    * eg. a single glMaterial call, in which case IM->Start ==
+    * IM->Count, but the buffer is definitely not empty.
+    */
+   if (IM->Flag[i] & VERT_DATA) {
+      IM->LastData++;
+      orflag |= IM->Flag[i];
+   }
+
+   IM->Flag[IM->LastData+1] |= VERT_END_VB;
+   IM->CopyAndFlag = IM->AndFlag = andflag;
+   IM->OrFlag = orflag;
+   IM->CopyOrFlag = orflag;
+   IM->Evaluated = 0;
+}
+
+
+
+
+
+
+
+
+/* Note: The 'start' member of the GLvector structs is now redundant
+ * because we always re-transform copied vertices, and the vectors
+ * below are set up so that the first copied vertex (if any) appears
+ * at position zero.
+ */
+static void _tnl_vb_bind_immediate( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   struct vertex_arrays *tmp = &tnl->imm_inputs;
+   GLuint inputs = tnl->pipeline.inputs; /* for copy-to-current */
+   GLuint start = IM->CopyStart;
+   GLuint count = IM->Count - start;
+
+   /* TODO: optimize the case where nothing has changed.  (Just bind
+    * tmp to vb).
+    */
+
+   /* Setup constant data in the VB.
+    */
+   VB->Count = count;
+   VB->FirstClipped = IMM_MAXDATA - IM->CopyStart;
+   VB->import_data = 0;
+   VB->importable_data = 0;
+
+   /* Need an IM->FirstPrimitive?
+    */
+   VB->Primitive = IM->Primitive + IM->CopyStart;
+   VB->PrimitiveLength = IM->PrimitiveLength + IM->CopyStart;
+   VB->FirstPrimitive = 0;
+
+   VB->Flag = IM->Flag + start;
+
+   /* TexCoordPtr's are zeroed in loop below.
+    */
+   VB->NormalPtr = 0;
+   VB->NormalLengthPtr = 0;
+   VB->FogCoordPtr = 0;
+   VB->EdgeFlag = 0;
+   VB->IndexPtr[0] = 0;
+   VB->IndexPtr[1] = 0;
+   VB->ColorPtr[0] = 0;
+   VB->ColorPtr[1] = 0;
+   VB->SecondaryColorPtr[0] = 0;
+   VB->SecondaryColorPtr[1] = 0;
+   VB->Elts = 0;
+   VB->MaterialMask = 0;
+   VB->Material = 0;
+
+/*     _tnl_print_vert_flags("copy-orflag", IM->CopyOrFlag); */
+/*     _tnl_print_vert_flags("orflag", IM->OrFlag); */
+/*     _tnl_print_vert_flags("inputs", inputs); */
+
+   /* Setup the initial values of array pointers in the vb.
+    */
+   if (inputs & VERT_OBJ) {
+      tmp->Obj.data = IM->Obj + start;
+      tmp->Obj.start = (GLfloat *)(IM->Obj + start);
+      tmp->Obj.count = count;
+      VB->ObjPtr = &tmp->Obj;
+      if ((IM->CopyOrFlag & VERT_OBJ_234) == VERT_OBJ_234)
+	 tmp->Obj.size = 4;
+      else if ((IM->CopyOrFlag & VERT_OBJ_234) == VERT_OBJ_23)
+	 tmp->Obj.size = 3;
+      else
+	 tmp->Obj.size = 2;
+   }
+
+   if (inputs & VERT_NORM) {
+      tmp->Normal.data = IM->Normal + start;
+      tmp->Normal.start = (GLfloat *)(IM->Normal + start);
+      tmp->Normal.count = count;
+      VB->NormalPtr = &tmp->Normal;
+      if (IM->NormalLengthPtr)
+	 VB->NormalLengthPtr = IM->NormalLengthPtr + start;
+   }
+
+   if (inputs & VERT_INDEX) {
+      tmp->Index.count = count;
+      tmp->Index.data = IM->Index + start;
+      tmp->Index.start = IM->Index + start;
+      VB->IndexPtr[0] = &tmp->Index;
+   }
+
+   if (inputs & VERT_FOG_COORD) {
+      tmp->FogCoord.data = IM->FogCoord + start;
+      tmp->FogCoord.start = IM->FogCoord + start;
+      tmp->FogCoord.count = count;
+      VB->FogCoordPtr = &tmp->FogCoord;
+   }
+
+   if (inputs & VERT_SPEC_RGB) {
+      tmp->SecondaryColor.Ptr = IM->SecondaryColor + start;
+      VB->SecondaryColorPtr[0] = &tmp->SecondaryColor;
+   }
+
+   if (inputs & VERT_EDGE) {
+      VB->EdgeFlag = IM->EdgeFlag + start;
+   }
+
+   if (inputs & VERT_RGBA) {
+      if (IM->CopyOrFlag & VERT_RGBA) {
+	 tmp->Color.Ptr = IM->Color + start;
+	 tmp->Color.StrideB = 4 * sizeof(GLfloat);
+	 tmp->Color.Flags = 0;
+      } else {
+	 tmp->Color.Ptr = ctx->Current.Color;
+	 tmp->Color.StrideB = 0;
+	 tmp->Color.Flags = CA_CLIENT_DATA; /* hack */
+	 VB->import_source = IM;
+	 VB->importable_data |= VERT_RGBA;
+	 VB->import_data = _tnl_upgrade_current_data;
+      }
+      VB->ColorPtr[0] = &tmp->Color;
+   }
+
+   if (inputs & VERT_TEX_ANY) {
+      GLuint i;
+      for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
+	 VB->TexCoordPtr[i] = 0;
+	 if (inputs & VERT_TEX(i)) {
+	    tmp->TexCoord[i].count = count;
+	    tmp->TexCoord[i].data = IM->TexCoord[i] + start;
+	    tmp->TexCoord[i].start = (GLfloat *)(IM->TexCoord[i] + start);
+	    tmp->TexCoord[i].size = 2;
+	    if (IM->TexSize & TEX_SIZE_3(i)) {
+	       tmp->TexCoord[i].size = 3;
+	       if (IM->TexSize & TEX_SIZE_4(i))
+		  tmp->TexCoord[i].size = 4;
+	    }
+	    VB->TexCoordPtr[i] = &tmp->TexCoord[i];
+	 }
+      }
+   }
+
+   if ((inputs & IM->OrFlag & VERT_MATERIAL) && IM->Material) {
+      VB->MaterialMask = IM->MaterialMask + start;
+      VB->Material = IM->Material + start;
+   }
+}
+
+
+
+
+/* Called by exec_vert_cassette, execute_compiled_cassette, but not
+ * exec_elt_cassette.
+ */
+void _tnl_run_cassette( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+/*      fprintf(stderr, "%s\n", __FUNCTION__);  */
+
+   _tnl_vb_bind_immediate( ctx, IM );
+
+   if (IM->OrFlag & VERT_EVAL_ANY)
+      _tnl_eval_immediate( ctx, IM );
+
+   /* Invalidate all stored data before and after run:
+    */
+   tnl->pipeline.run_input_changes |= tnl->pipeline.inputs;
+   tnl->Driver.RunPipeline( ctx );
+   tnl->pipeline.run_input_changes |= tnl->pipeline.inputs;
+
+   _tnl_copy_to_current( ctx, IM, IM->OrFlag, IM->LastData );
+}
+
+
+/* Called for regular vertex cassettes.
+ */
+static void exec_vert_cassette( GLcontext *ctx, struct immediate *IM )
+{
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   if (IM->FlushElt) {
+      /* Orflag is computed twice, but only reach this code if app is
+       * using a mixture of glArrayElement() and glVertex() while
+       * arrays are locked (else would be in exec_elt_cassette now).
+       */
+      ASSERT(ctx->Array.LockCount);
+      ASSERT(IM->FlushElt == FLUSH_ELT_LAZY);
+      _tnl_translate_array_elts( ctx, IM, IM->CopyStart, IM->Count );
+      _tnl_compute_orflag( IM, IM->CopyStart ); 
+   }
+
+   _tnl_fixup_input( ctx, IM );
+/*     _tnl_print_cassette( IM ); */
+   _tnl_run_cassette( ctx, IM );
+}
+
+
+/* Called for pure, locked VERT_ELT cassettes instead of
+ * _tnl_run_cassette.
+ */
+static void exec_elt_cassette( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+
+/*     fprintf(stderr, "%s\n", __FUNCTION__);  */
+
+   _tnl_vb_bind_arrays( ctx, ctx->Array.LockFirst, ctx->Array.LockCount );
+
+   /* Take only elements and primitive information from the immediate:
+    */
+   VB->Elts = IM->Elt + IM->CopyStart;
+   VB->Primitive = IM->Primitive + IM->CopyStart;
+   VB->PrimitiveLength = IM->PrimitiveLength + IM->CopyStart;
+   VB->FirstPrimitive = 0;
+
+   /* Run the pipeline.  No input changes as a result of this action.
+    */
+   tnl->Driver.RunPipeline( ctx );
+
+   /* Still need to update current values:  
+    */
+   if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1) {
+      _tnl_translate_array_elts( ctx, IM, IM->LastData, IM->LastData );
+      _tnl_copy_to_current( ctx, IM, ctx->Array._Enabled, IM->LastData );
+   }
+}
+
+
+static void
+exec_empty_cassette( GLcontext *ctx, struct immediate *IM )
+{
+   if (IM->FlushElt)
+      _tnl_translate_array_elts( ctx, IM, IM->CopyStart, IM->CopyStart );
+
+   _tnl_copy_to_current( ctx, IM, IM->OrFlag, IM->LastData );
+}
+
+
+
+/* Called for all cassettes when not compiling or playing a display
+ * list.
+ */
+void _tnl_execute_cassette( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   _tnl_compute_orflag( IM, IM->Start );
+   _tnl_copy_immediate_vertices( ctx, IM ); 
+   _tnl_get_exec_copy_verts( ctx, IM );
+
+   if (tnl->pipeline.build_state_changes)
+      _tnl_validate_pipeline( ctx );
+
+   if (IM->CopyStart == IM->Count) {
+      exec_empty_cassette( ctx, IM );
+   }
+   else if ((IM->CopyOrFlag & VERT_DATA) == VERT_ELT &&
+	    ctx->Array.LockCount &&
+	    ctx->Array.Vertex.Enabled) {
+      exec_elt_cassette( ctx, IM );
+   }
+   else {
+      exec_vert_cassette( ctx, IM );
+   }
+
+   /* Only reuse the immediate if there are no copied vertices living
+    * inside it:
+    */
+   { 
+      GLuint begin_state = IM->BeginState & (VERT_BEGIN_0|VERT_BEGIN_1);
+      GLuint saved_begin_state = IM->SavedBeginState;
+
+      if (--IM->ref_count != 0) {
+	 IM = _tnl_alloc_immediate( ctx );
+	 SET_IMMEDIATE( ctx, IM );
+      }
+
+      IM->ref_count++;
+	 
+      _tnl_reset_exec_input( ctx, IMM_MAX_COPIED_VERTS, 
+			     begin_state, saved_begin_state );
+   }
+
+   if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1)
+      ctx->Driver.NeedFlush &= ~FLUSH_STORED_VERTICES;
+
+/*     fprintf(stderr, "%s: NeedFlush: %x\n", __FUNCTION__,  */
+/*  	   ctx->Driver.NeedFlush); */
+}
+
+
+
+
+/* Setup vector pointers that will be used to bind immediates to VB's.
+ */
+void _tnl_imm_init( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_arrays *tmp = &tnl->imm_inputs;
+   GLuint i;
+   static int firsttime = 1;
+
+   if (firsttime) {
+      firsttime = 0;
+      _tnl_imm_elt_init();
+   }
+
+   ctx->swtnl_im = _tnl_alloc_immediate( ctx );
+   TNL_CURRENT_IM(ctx)->ref_count++;
+
+   tnl->ExecCopyTexSize = 0;
+   tnl->ExecCopyCount = 0;
+   tnl->ExecCopySource = 0;
+
+   TNL_CURRENT_IM(ctx)->CopyStart = IMM_MAX_COPIED_VERTS;
+
+   _mesa_vector4f_init( &tmp->Obj, 0, 0 );
+   _mesa_vector3f_init( &tmp->Normal, 0, 0 );
+
+   tmp->Color.Ptr = 0;
+   tmp->Color.Type = GL_FLOAT;
+   tmp->Color.Size = 4;
+   tmp->Color.Stride = 0;
+   tmp->Color.StrideB = 4 * sizeof(GLfloat);
+   tmp->Color.Flags = 0;
+
+   tmp->SecondaryColor.Ptr = 0;
+   tmp->SecondaryColor.Type = GL_FLOAT;
+   tmp->SecondaryColor.Size = 4;
+   tmp->SecondaryColor.Stride = 0;
+   tmp->SecondaryColor.StrideB = 4 * sizeof(GLfloat);
+   tmp->SecondaryColor.Flags = 0;
+
+   _mesa_vector1f_init( &tmp->FogCoord, 0, 0 );
+   _mesa_vector1ui_init( &tmp->Index, 0, 0 );
+   _mesa_vector1ub_init( &tmp->EdgeFlag, 0, 0 );
+
+   for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
+      _mesa_vector4f_init( &tmp->TexCoord[i], 0, 0);
+
+   /* Install the first immediate.  Intially outside begin/end.
+    */
+   _tnl_reset_exec_input( ctx, IMM_MAX_COPIED_VERTS, 0, 0 );
+   tnl->ReplayHardBeginEnd = 0;
+
+   _tnl_imm_vtxfmt_init( ctx );
+}
+
+
+void _tnl_imm_destroy( GLcontext *ctx )
+{
+   if (TNL_CURRENT_IM(ctx)) {
+      TNL_CURRENT_IM(ctx)->ref_count--;
+      if (TNL_CURRENT_IM(ctx)->ref_count == 0)
+	 _tnl_free_immediate( ctx, TNL_CURRENT_IM(ctx) );
+      /* 
+       * Don't use SET_IMMEDIATE here, or else we'll whack the
+       * _tnl_CurrentInput pointer - not good when another 
+       * context has already been made current.
+       * So we just set the context's own tnl immediate pointer
+       * to 0.
+       */
+      ctx->swtnl_im = 0;
+   }
+}
Index: xc/extras/Mesa/src/tnl/t_imm_exec.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_exec.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_exec.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,69 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _T_VBXFORM_H
+#define _T_VBXFORM_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+
+/* Hook for ctx->Driver.FlushVertices:
+ */
+extern void _tnl_flush_vertices( GLcontext *ctx, GLuint flush_flags );
+
+/* Called from imm_api.c and _tnl_flush_vertices:
+ */
+extern void _tnl_flush_immediate( struct immediate *IM );
+
+/* Called from imm_dlist.c and _tnl_flush_immediate:
+ */
+extern void _tnl_run_cassette( GLcontext *ctx, struct immediate *IM );
+extern void _tnl_copy_to_current( GLcontext *ctx, struct immediate *IM,
+				  GLuint flag, GLuint row );
+
+/* Initialize some stuff:
+ */
+extern void _tnl_imm_init( GLcontext *ctx );
+
+extern void _tnl_imm_destroy( GLcontext *ctx );
+
+extern void _tnl_reset_exec_input( GLcontext *ctx,
+				   GLuint start,
+				   GLuint beginstate,
+				   GLuint savedbeginstate );
+
+extern void _tnl_reset_compile_input( GLcontext *ctx,
+				      GLuint start,
+				      GLuint beginstate,
+				      GLuint savedbeginstate );
+
+extern void _tnl_compute_orflag( struct immediate *IM, GLuint start );
+extern void _tnl_execute_cassette( GLcontext *ctx, struct immediate *IM );
+
+
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_imm_fixup.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_fixup.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_fixup.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,823 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+/*
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "enums.h"
+#include "dlist.h"
+#include "colormac.h"
+#include "light.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "state.h"
+#include "mtypes.h"
+
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_imm_alloc.h"
+#include "t_imm_debug.h"
+#include "t_imm_elt.h"
+#include "t_imm_fixup.h"
+#include "t_imm_exec.h"
+#include "t_pipeline.h"
+
+
+static const GLuint increment[GL_POLYGON+2] = { 1,2,1,1,3,1,1,4,2,1,1 };
+static const GLuint intro[GL_POLYGON+2]     = { 0,0,2,2,0,2,2,0,2,2,0 };
+
+void
+_tnl_fixup_4f( GLfloat data[][4], GLuint flag[], GLuint start, GLuint match )
+{
+   GLuint i = start;
+
+   for (;;) {
+      if ((flag[++i] & match) == 0) {
+	 COPY_4FV(data[i], data[i-1]);
+	 if (flag[i] & VERT_END_VB) break;
+      }
+   }
+}
+
+void
+_tnl_fixup_3f( float data[][3], GLuint flag[], GLuint start, GLuint match )
+{
+   GLuint i = start;
+
+
+   for (;;) {
+      if ((flag[++i] & match) == 0) {
+/*  	 fprintf(stderr, "_tnl_fixup_3f copy to %p values %f %f %f\n", */
+/*  		 data[i],  */
+/*  		 data[i-1][0], */
+/*  		 data[i-1][1], */
+/*  		 data[i-1][2]); */
+	 COPY_3V(data[i], data[i-1]);
+	 if (flag[i] & VERT_END_VB) break;
+      }
+   }
+}
+
+
+void
+_tnl_fixup_1ui( GLuint *data, GLuint flag[], GLuint start, GLuint match )
+{
+   GLuint i = start;
+
+   for (;;) {
+      if ((flag[++i] & match) == 0) {
+	 data[i] = data[i-1];
+	 if (flag[i] & VERT_END_VB) break;
+      }
+   }
+   flag[i] |= match;
+}
+
+
+void
+_tnl_fixup_1f( GLfloat *data, GLuint flag[], GLuint start, GLuint match )
+{
+   GLuint i = start;
+
+   for (;;) {
+      if ((flag[++i] & match) == 0) {
+	 data[i] = data[i-1];
+	 if (flag[i] & VERT_END_VB) break;
+      }
+   }
+   flag[i] |= match;
+}
+
+void
+_tnl_fixup_1ub( GLubyte *data, GLuint flag[], GLuint start, GLuint match )
+{
+   GLuint i = start;
+
+   for (;;) {
+      if ((flag[++i] & match) == 0) {
+	 data[i] = data[i-1];
+	 if (flag[i] & VERT_END_VB) break;
+      }
+   }
+   flag[i] |= match;
+}
+
+
+static void
+fixup_first_4f( GLfloat data[][4], GLuint flag[], GLuint match,
+		GLuint start, GLfloat *dflt )
+{
+   GLuint i = start-1;
+   match |= VERT_END_VB;
+
+   while ((flag[++i]&match) == 0)
+      COPY_4FV(data[i], dflt);
+}
+
+static void
+fixup_first_3f( GLfloat data[][3], GLuint flag[], GLuint match,
+		GLuint start, GLfloat *dflt )
+{
+   GLuint i = start-1;
+   match |= VERT_END_VB;
+
+/*     fprintf(stderr, "fixup_first_3f default: %f %f %f start: %d\n", */
+/*  	   dflt[0], dflt[1], dflt[2], start);  */
+
+   while ((flag[++i]&match) == 0)
+      COPY_3FV(data[i], dflt);
+}
+
+
+static void
+fixup_first_1ui( GLuint data[], GLuint flag[], GLuint match,
+		 GLuint start, GLuint dflt )
+{
+   GLuint i = start-1;
+   match |= VERT_END_VB;
+
+   while ((flag[++i]&match) == 0)
+      data[i] = dflt;
+}
+
+static void
+fixup_first_1f( GLfloat data[], GLuint flag[], GLuint match,
+		GLuint start, GLfloat dflt )
+{
+   GLuint i = start-1;
+   match |= VERT_END_VB;
+
+   while ((flag[++i]&match) == 0)
+      data[i] = dflt;
+}
+
+
+static void
+fixup_first_1ub( GLubyte data[], GLuint flag[], GLuint match,
+		 GLuint start, GLubyte dflt )
+{
+   GLuint i = start-1;
+   match |= VERT_END_VB;
+
+   while ((flag[++i]&match) == 0)
+      data[i] = dflt;
+}
+
+static void copy_from_current( GLcontext *ctx, struct immediate *IM, 
+			      GLuint start, GLuint copy )
+{
+   if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
+      _tnl_print_vert_flags("copy from current", copy); 
+
+   if (copy & VERT_NORM) {
+      COPY_3V( IM->Normal[start], ctx->Current.Normal );
+   }
+
+   if (copy & VERT_RGBA) {
+      COPY_4FV( IM->Color[start], ctx->Current.Color);
+   }
+
+   if (copy & VERT_SPEC_RGB)
+      COPY_4FV( IM->SecondaryColor[start], ctx->Current.SecondaryColor);
+
+   if (copy & VERT_FOG_COORD)
+      IM->FogCoord[start] = ctx->Current.FogCoord;
+
+   if (copy & VERT_INDEX)
+      IM->Index[start] = ctx->Current.Index;
+
+   if (copy & VERT_EDGE)
+      IM->EdgeFlag[start] = ctx->Current.EdgeFlag;
+
+   if (copy & VERT_TEX_ANY) {
+      GLuint i;
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
+	 if (copy & VERT_TEX(i))
+	    COPY_4FV( IM->TexCoord[i][start], ctx->Current.Texcoord[i] );
+      }
+   }
+}
+
+
+void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint start = IM->CopyStart;
+   GLuint andflag = IM->CopyAndFlag;
+   GLuint orflag = IM->CopyOrFlag | IM->Evaluated;
+   GLuint fixup;
+
+   IM->CopyTexSize = IM->TexSize;
+
+/*     fprintf(stderr, "Fixup input, Start: %u Count: %u LastData: %u\n", */
+/*  	   IM->Start, IM->Count, IM->LastData); */
+/*     _tnl_print_vert_flags("Orflag", orflag); */
+/*     _tnl_print_vert_flags("Andflag", andflag); */
+
+
+   fixup = ~andflag & VERT_FIXUP;
+
+   if (!ctx->CompileFlag)
+      fixup &= tnl->pipeline.inputs;
+
+   if (!ctx->ExecuteFlag)
+      fixup &= orflag;
+
+   if ((orflag & (VERT_OBJ|VERT_EVAL_ANY)) == 0)
+      fixup = 0;
+
+   if (fixup) {
+      GLuint copy = fixup & ~IM->Flag[start];
+
+
+      /* Equivalent to a lazy copy-from-current when setting up the
+       * immediate.
+       */
+      if (ctx->ExecuteFlag && copy) 
+	 copy_from_current( ctx, IM, start, copy );
+
+      if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
+  	 _tnl_print_vert_flags("fixup", fixup); 
+
+      if (fixup & VERT_TEX_ANY) {
+	 GLuint i;
+	 for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
+	    if (fixup & VERT_TEX(i)) {
+	       if (orflag & VERT_TEX(i))
+		  _tnl_fixup_4f( IM->TexCoord[i], IM->Flag, start,
+				 VERT_TEX(i) );
+	       else
+		  fixup_first_4f( IM->TexCoord[i], IM->Flag, VERT_END_VB, start,
+				  IM->TexCoord[i][start]);
+	    }
+	 }
+      }
+   
+
+      if (fixup & VERT_EDGE) {
+	 if (orflag & VERT_EDGE)
+	    _tnl_fixup_1ub( IM->EdgeFlag, IM->Flag, start, VERT_EDGE );
+	 else
+	    fixup_first_1ub( IM->EdgeFlag, IM->Flag, VERT_END_VB, start,
+			     IM->EdgeFlag[start] );
+      }
+
+      if (fixup & VERT_INDEX) {
+	 if (orflag & VERT_INDEX)
+	    _tnl_fixup_1ui( IM->Index, IM->Flag, start, VERT_INDEX );
+	 else
+	    fixup_first_1ui( IM->Index, IM->Flag, VERT_END_VB, start, 
+			     IM->Index[start] );
+      }
+
+      if (fixup & VERT_RGBA) {
+	 if (orflag & VERT_RGBA)
+	    _tnl_fixup_4f( IM->Color, IM->Flag, start, VERT_RGBA );
+	 /* No need for else case as the drivers understand stride
+	  * zero here.  (TODO - propogate this)
+	  */
+      }
+      
+      if (fixup & VERT_SPEC_RGB) {
+	 if (orflag & VERT_SPEC_RGB)
+	    _tnl_fixup_4f( IM->SecondaryColor, IM->Flag, start, 
+			   VERT_SPEC_RGB );
+	 else
+	    fixup_first_4f( IM->SecondaryColor, IM->Flag, VERT_END_VB, start,
+			    IM->SecondaryColor[start] );
+      }
+      
+      if (fixup & VERT_FOG_COORD) {
+	 if (orflag & VERT_FOG_COORD)
+	    _tnl_fixup_1f( IM->FogCoord, IM->Flag, start, VERT_FOG_COORD );
+	 else
+	    fixup_first_1f( IM->FogCoord, IM->Flag, VERT_END_VB, start,
+			    IM->FogCoord[start] );
+      }
+
+      if (fixup & VERT_NORM) {
+	 if (orflag & VERT_NORM)
+	    _tnl_fixup_3f( IM->Normal, IM->Flag, start, VERT_NORM );
+	 else
+	    fixup_first_3f( IM->Normal, IM->Flag, VERT_END_VB, start,
+			    IM->Normal[start] );
+      }
+   }
+      
+   /* Prune possible half-filled slot.
+    */
+   IM->Flag[IM->LastData+1] &= ~VERT_END_VB;
+   IM->Flag[IM->Count] |= VERT_END_VB;
+
+
+   /* Materials:
+    */
+   if (IM->MaterialOrMask & ~IM->MaterialAndMask) {
+      GLuint vulnerable = IM->MaterialOrMask;
+      GLuint i = IM->Start;
+
+      do {
+	 while (!(IM->Flag[i] & VERT_MATERIAL))
+	    i++;
+
+	 vulnerable &= ~IM->MaterialMask[i];
+	 _mesa_copy_material_pairs( IM->Material[i],
+				    ctx->Light.Material,
+				    vulnerable );
+
+
+	++i;
+      } while (vulnerable);
+   }
+}
+
+
+
+
+static void copy_material( struct immediate *next,
+			   struct immediate *prev,
+			   GLuint dst, GLuint src )
+{
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   if (next->Material == 0) {
+      next->Material = (GLmaterial (*)[2]) MALLOC( sizeof(GLmaterial) *
+						   IMM_SIZE * 2 );
+      next->MaterialMask = (GLuint *) MALLOC( sizeof(GLuint) * IMM_SIZE );
+   }
+
+   next->MaterialMask[dst] = prev->MaterialOrMask;
+   MEMCPY(next->Material[dst], prev->Material[src], 2*sizeof(GLmaterial));
+}
+
+static GLboolean is_fan_like[GL_POLYGON+1] = {
+   GL_FALSE,
+   GL_FALSE,
+   GL_TRUE,			/* line loop */
+   GL_FALSE,
+   GL_FALSE,
+   GL_FALSE,
+   GL_TRUE,			/* tri fan */
+   GL_FALSE,
+   GL_FALSE,
+   GL_TRUE			/* polygon */
+};
+
+
+/* Copy the untransformed data from the shared vertices of a primitive
+ * that wraps over two immediate structs.  This is done prior to
+ * set_immediate so that prev and next may point to the same
+ * structure.  In general it's difficult to avoid this copy on long
+ * primitives.
+ *
+ * Have to be careful with the transitions between display list
+ * replay, compile and normal execute modes.
+ */
+void _tnl_copy_immediate_vertices( GLcontext *ctx, struct immediate *next )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct immediate *prev = tnl->ExecCopySource;
+   struct vertex_arrays *inputs = &tnl->imm_inputs;
+   GLuint count = tnl->ExecCopyCount;
+   GLuint *elts = tnl->ExecCopyElts;
+   GLuint offset = IMM_MAX_COPIED_VERTS - count;
+   GLuint i;
+
+   if (!prev) {
+      ASSERT(tnl->ExecCopyCount == 0);
+      return;
+   }
+
+   next->CopyStart = next->Start - count;
+
+   if ((prev->CopyOrFlag & VERT_DATA) == VERT_ELT &&
+       ctx->Array.LockCount &&
+       ctx->Array.Vertex.Enabled)
+   {
+      /* Copy Elt values only
+       */
+      for (i = 0 ; i < count ; i++)
+      {
+	 GLuint src = elts[i+offset];
+	 GLuint dst = next->CopyStart+i;
+	 next->Elt[dst] = prev->Elt[src];
+	 next->Flag[dst] = VERT_ELT;
+	 elts[i+offset] = dst;
+      }
+/*        fprintf(stderr, "ADDING VERT_ELT!\n"); */
+      next->CopyOrFlag |= VERT_ELT;
+      next->CopyAndFlag &= VERT_ELT;
+   }
+   else {
+      GLuint copy = tnl->pipeline.inputs & (prev->CopyOrFlag|prev->Evaluated);
+      GLuint flag;
+
+      if (is_fan_like[ctx->Driver.CurrentExecPrimitive]) {
+	 flag = ((prev->CopyOrFlag|prev->Evaluated) & VERT_FIXUP);
+	 next->CopyOrFlag |= flag;
+      } 
+      else {
+	 /* Don't let an early 'glColor', etc. poison the elt path.
+	  */
+	 flag = ((prev->OrFlag|prev->Evaluated) & VERT_FIXUP);
+      }
+
+      next->TexSize |= tnl->ExecCopyTexSize;
+      next->CopyAndFlag &= flag;
+	 
+
+/*        _tnl_print_vert_flags("copy vertex components", copy); */
+/*        _tnl_print_vert_flags("prev copyorflag", prev->CopyOrFlag); */
+/*        _tnl_print_vert_flags("flag", flag); */
+
+      /* Copy whole vertices
+       */
+      for (i = 0 ; i < count ; i++)
+      {
+	 GLuint src = elts[i+offset];
+	 GLuint isrc = src - prev->CopyStart;
+	 GLuint dst = next->CopyStart+i;
+
+	 /* Values subject to eval must be copied out of the 'inputs'
+	  * struct.  (Copied rows should not be evaluated twice).
+	  *
+	  * Note these pointers are null when inactive.
+	  */
+	 COPY_4FV( next->Obj[dst], inputs->Obj.data[isrc] );
+
+	 if (copy & VERT_NORM) {
+/*  	    fprintf(stderr, "copy vert norm %d to %d (%p): %f %f %f\n", */
+/*  		    isrc, dst,  */
+/*  		    next->Normal[dst], */
+/*  		    inputs->Normal.data[isrc][0], */
+/*  		    inputs->Normal.data[isrc][1], */
+/*  		    inputs->Normal.data[isrc][2]); */
+	    COPY_3FV( next->Normal[dst], inputs->Normal.data[isrc] );
+	 }
+
+	 if (copy & VERT_RGBA)
+	    COPY_4FV( next->Color[dst], 
+		      ((GLfloat (*)[4])inputs->Color.Ptr)[isrc] );
+
+	 if (copy & VERT_INDEX)
+	    next->Index[dst] = inputs->Index.data[isrc];
+
+	 if (copy & VERT_TEX_ANY) {
+	    GLuint i;
+	    for (i = 0 ; i < prev->MaxTextureUnits ; i++) {
+	       if (copy & VERT_TEX(i))
+		  COPY_4FV( next->TexCoord[i][dst], 
+			    inputs->TexCoord[i].data[isrc] );
+	    }
+	 }
+
+	 /* Remaining values should be the same in the 'input' struct and the
+	  * original immediate.
+	  */
+	 if (copy & (VERT_ELT|VERT_EDGE|VERT_SPEC_RGB|VERT_FOG_COORD|
+		     VERT_MATERIAL)) {
+
+	    if (prev->Flag[src] & VERT_MATERIAL)
+	       copy_material(next, prev, dst, src);
+
+	    next->Elt[dst] = prev->Elt[src];
+	    next->EdgeFlag[dst] = prev->EdgeFlag[src];
+	    COPY_4FV( next->SecondaryColor[dst], prev->SecondaryColor[src] );
+	    next->FogCoord[dst] = prev->FogCoord[src];
+	 }
+
+	 next->Flag[dst] = flag;
+	 next->CopyOrFlag |= prev->Flag[src] & (VERT_FIXUP|
+						VERT_MATERIAL|
+						VERT_OBJ);
+	 elts[i+offset] = dst;
+      }
+   }
+
+   if (--tnl->ExecCopySource->ref_count == 0) 
+      _tnl_free_immediate( ctx, tnl->ExecCopySource );
+
+   tnl->ExecCopySource = next; next->ref_count++;
+}
+
+
+
+/* Revive a compiled immediate struct - propogate new 'Current'
+ * values.  Often this is redundant because the current values were
+ * known and fixed up at compile time (or in the first execution of
+ * the cassette).
+ */
+void _tnl_fixup_compiled_cassette( GLcontext *ctx, struct immediate *IM )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint fixup;
+   GLuint start = IM->Start;
+
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   IM->Evaluated = 0;
+   IM->CopyOrFlag = IM->OrFlag;	  
+   IM->CopyAndFlag = IM->AndFlag; 
+   IM->CopyTexSize = IM->TexSize | tnl->ExecCopyTexSize;
+
+   _tnl_copy_immediate_vertices( ctx, IM );
+
+   if (ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1) {
+      ASSERT(IM->CopyStart == IM->Start);
+   }
+
+   /* Naked array elements can be copied into the first cassette in a
+    * display list.  Need to translate them away:
+    */
+   if (IM->CopyOrFlag & VERT_ELT) {
+      GLuint copy = tnl->pipeline.inputs & ~ctx->Array._Enabled;
+      GLuint i;
+
+      ASSERT(IM->CopyStart < IM->Start);
+
+      _tnl_translate_array_elts( ctx, IM, IM->CopyStart, IM->Start );
+
+      for (i = IM->CopyStart ; i < IM->Start ; i++)
+	 copy_from_current( ctx, IM, i, copy ); 
+
+      _tnl_copy_to_current( ctx, IM, ctx->Array._Enabled, IM->Start );
+   }
+
+   fixup = tnl->pipeline.inputs & ~IM->Flag[start] & VERT_FIXUP;
+
+/*     _tnl_print_vert_flags("fixup compiled", fixup); */
+
+   if (fixup) {
+      if (fixup & VERT_TEX_ANY) {
+	 GLuint i;
+	 for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
+	    if (fixup & VERT_TEX(i))
+	       fixup_first_4f( IM->TexCoord[i], IM->Flag, VERT_TEX(i), start,
+			       ctx->Current.Texcoord[i] );
+	 }
+      }
+
+      if (fixup & VERT_EDGE)
+	 fixup_first_1ub(IM->EdgeFlag, IM->Flag, VERT_EDGE, start,
+			 ctx->Current.EdgeFlag );
+
+      if (fixup & VERT_INDEX)
+	 fixup_first_1ui(IM->Index, IM->Flag, VERT_INDEX, start,
+			 ctx->Current.Index );
+
+      if (fixup & VERT_RGBA) {
+	 if (IM->CopyOrFlag & VERT_RGBA)
+	    fixup_first_4f(IM->Color, IM->Flag, VERT_RGBA, start,
+			   ctx->Current.Color );
+	 else
+	    fixup &= ~VERT_RGBA;
+      }
+
+      if (fixup & VERT_SPEC_RGB)
+	 fixup_first_4f(IM->SecondaryColor, IM->Flag, VERT_SPEC_RGB, start,
+			ctx->Current.SecondaryColor );
+
+      if (fixup & VERT_FOG_COORD)
+	 fixup_first_1f(IM->FogCoord, IM->Flag, VERT_FOG_COORD, start,
+			 ctx->Current.FogCoord );
+
+      if (fixup & VERT_NORM) {
+	 fixup_first_3f(IM->Normal, IM->Flag, VERT_NORM, start,
+			ctx->Current.Normal );
+      }
+
+      IM->CopyOrFlag |= fixup;
+   }
+   
+
+   /* Materials:
+    */
+   if (IM->MaterialOrMask & ~IM->MaterialAndMask) {
+      GLuint vulnerable = IM->MaterialOrMask;
+      GLuint i = IM->Start;
+
+      do {
+	 while (!(IM->Flag[i] & VERT_MATERIAL))
+	    i++;
+
+	 vulnerable &= ~IM->MaterialMask[i];
+	 _mesa_copy_material_pairs( IM->Material[i],
+				    ctx->Light.Material,
+				    vulnerable );
+
+
+	 ++i;
+      } while (vulnerable);
+   }
+}
+
+
+
+
+
+
+static void copy_none( TNLcontext *tnl, GLuint start, GLuint count, GLuint ovf)
+{
+   (void) (start && ovf && tnl && count);
+}
+
+static void copy_last( TNLcontext *tnl, GLuint start, GLuint count, GLuint ovf)
+{
+   (void) start; (void) ovf;
+   tnl->ExecCopyCount = 1;
+   tnl->ExecCopyElts[2] = count-1;
+}
+
+static void copy_first_and_last( TNLcontext *tnl, GLuint start, GLuint count,
+				 GLuint ovf)
+{
+   (void) ovf;
+   tnl->ExecCopyCount = 2;
+   tnl->ExecCopyElts[1] = start;
+   tnl->ExecCopyElts[2] = count-1;
+}
+
+static void copy_last_two( TNLcontext *tnl, GLuint start, GLuint count,
+			   GLuint ovf )
+{
+   (void) start;
+   tnl->ExecCopyCount = 2+ovf;
+   tnl->ExecCopyElts[0] = count-3;
+   tnl->ExecCopyElts[1] = count-2;
+   tnl->ExecCopyElts[2] = count-1;
+}
+
+static void copy_overflow( TNLcontext *tnl, GLuint start, GLuint count,
+			   GLuint ovf )
+{
+   (void) start;
+   tnl->ExecCopyCount = ovf;
+   tnl->ExecCopyElts[0] = count-3;
+   tnl->ExecCopyElts[1] = count-2;
+   tnl->ExecCopyElts[2] = count-1;
+}
+
+
+typedef void (*copy_func)( TNLcontext *tnl, GLuint start, GLuint count,
+			   GLuint ovf );
+
+static copy_func copy_tab[GL_POLYGON+2] =
+{
+   copy_none,
+   copy_overflow,
+   copy_first_and_last,
+   copy_last,
+   copy_overflow,
+   copy_last_two,
+   copy_first_and_last,
+   copy_overflow,
+   copy_last_two,
+   copy_first_and_last,
+   copy_none
+};
+
+
+
+
+
+/* Figure out what vertices need to be copied next time.
+ */
+void
+_tnl_get_exec_copy_verts( GLcontext *ctx, struct immediate *IM )
+{
+
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint last = IM->LastPrimitive;
+   GLuint prim = ctx->Driver.CurrentExecPrimitive;
+   GLuint pincr = increment[prim];
+   GLuint pintro = intro[prim];
+   GLuint ovf = 0;
+
+/*     fprintf(stderr, "_tnl_get_exec_copy_verts %s\n",  */
+/*  	   _mesa_lookup_enum_by_nr(prim)); */
+
+   if (tnl->ExecCopySource)
+      if (--tnl->ExecCopySource->ref_count == 0) 
+	 _tnl_free_immediate( ctx, tnl->ExecCopySource );
+
+   if (prim == GL_POLYGON+1) {
+      tnl->ExecCopySource = 0;
+      tnl->ExecCopyCount = 0;
+      tnl->ExecCopyTexSize = 0;
+      tnl->ExecParity = 0;
+   } else {
+      /* Remember this immediate as the one to copy from.
+       */
+      tnl->ExecCopySource = IM; IM->ref_count++;
+      tnl->ExecCopyCount = 0;
+      tnl->ExecCopyTexSize = IM->CopyTexSize;
+
+      if (IM->LastPrimitive != IM->CopyStart)
+	 tnl->ExecParity = 0;
+	 
+      tnl->ExecParity ^= IM->PrimitiveLength[IM->LastPrimitive] & 1;
+
+      if (pincr != 1 && (IM->Count - last - pintro))
+	 ovf = (IM->Count - last - pintro) % pincr;
+
+      if (last < IM->Count)
+	 copy_tab[prim]( tnl, last, IM->Count, ovf );
+   }
+}
+
+
+/* Recalculate ExecCopyElts, ExecParity, etc.  
+ */
+void 
+_tnl_get_purged_copy_verts( GLcontext *ctx, struct immediate *IM ) 
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   if (ctx->Driver.CurrentExecPrimitive != GL_POLYGON+1) {
+      GLuint last = IM->LastPrimitive;
+      GLenum prim = IM->Primitive[last];
+      GLuint pincr = increment[prim];
+      GLuint pintro = intro[prim];
+      GLuint ovf = 0, i;
+
+      tnl->ExecCopyCount = 0;
+      if (IM->LastPrimitive != IM->CopyStart)
+	 tnl->ExecParity = 0;
+	 
+      tnl->ExecParity ^= IM->PrimitiveLength[IM->LastPrimitive] & 1;
+
+      if (pincr != 1 && (IM->Count - last - pintro))
+	 ovf = (IM->Count - last - pintro) % pincr;
+
+      if (last < IM->Count)
+	 copy_tab[prim]( tnl, last, IM->Count, ovf );
+
+      for (i = 0 ; i < tnl->ExecCopyCount ; i++)
+	 tnl->ExecCopyElts[i] = IM->Elt[tnl->ExecCopyElts[i]];
+   }
+}
+
+
+void _tnl_upgrade_current_data( GLcontext *ctx,
+				GLuint required,
+				GLuint flags )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   struct immediate *IM = (struct immediate *)VB->import_source;
+
+   ASSERT(IM);
+
+/*     _tnl_print_vert_flags("_tnl_upgrade_client_data", required); */
+
+   if ((required & VERT_RGBA) && (VB->ColorPtr[0]->Flags & CA_CLIENT_DATA)) {
+      struct gl_client_array *tmp = &tnl->imm_inputs.Color;
+      GLuint start = IM->CopyStart;
+
+      tmp->Ptr = IM->Color + start;
+      tmp->StrideB = 4 * sizeof(GLfloat);
+      tmp->Flags = 0;
+
+      COPY_4FV( IM->Color[start], ctx->Current.Color);   
+
+      /*
+      ASSERT(IM->Flag[IM->LastData+1] & VERT_END_VB);
+      */
+
+      fixup_first_4f( IM->Color, IM->Flag, VERT_END_VB, start, 
+		      IM->Color[start] );
+
+      VB->importable_data &= ~VERT_RGBA;
+   }
+}
+ 
Index: xc/extras/Mesa/src/tnl/t_imm_fixup.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_imm_fixup.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_imm_fixup.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,63 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+#ifndef _T_IMM_FIXUP_H
+#define _T_IMM_FIXUP_H
+
+#include "mtypes.h"
+#include "t_context.h"
+
+extern void _tnl_fixup_1ub( GLubyte *data, GLuint flag[],
+			    GLuint start, GLuint match );
+
+extern void _tnl_fixup_1f( GLfloat *data, GLuint flag[],
+			   GLuint start, GLuint match );
+
+extern void _tnl_fixup_1ui( GLuint *data, GLuint flag[],
+			    GLuint start, GLuint match );
+
+extern void _tnl_fixup_3f( float data[][3], GLuint flag[],
+			   GLuint start, GLuint match );
+
+extern void _tnl_fixup_4f( GLfloat data[][4], GLuint flag[],
+			   GLuint start, GLuint match );
+
+extern void _tnl_fixup_input( GLcontext *ctx, struct immediate *IM );
+
+extern void _tnl_fixup_compiled_cassette( GLcontext *ctx,
+					  struct immediate *IM );
+
+extern void _tnl_copy_immediate_vertices( GLcontext *ctx, 
+					  struct immediate *IM );
+
+extern void _tnl_get_purged_copy_verts( GLcontext *ctx, struct immediate *IM );
+
+extern void _tnl_get_exec_copy_verts( GLcontext *ctx, struct immediate *IM );
+
+extern void _tnl_upgrade_current_data( GLcontext *ctx, GLuint required,
+				       GLuint flags );
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_pipeline.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_pipeline.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_pipeline.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,207 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "mem.h"
+#include "mmath.h"
+#include "state.h"
+#include "mtypes.h"
+
+#include "math/m_translate.h"
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+void _tnl_install_pipeline( GLcontext *ctx,
+			    const struct gl_pipeline_stage **stages )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct gl_pipeline *pipe = &tnl->pipeline;
+   GLuint i;
+
+   ASSERT(pipe->nr_stages == 0);
+
+   pipe->run_state_changes = ~0;
+   pipe->run_input_changes = ~0;
+   pipe->build_state_changes = ~0;
+   pipe->build_state_trigger = 0;
+   pipe->inputs = 0;
+
+   /* Create a writeable copy of each stage.
+    */
+   for (i = 0 ; i < MAX_PIPELINE_STAGES && stages[i] ; i++) {
+      MEMCPY( &pipe->stages[i], stages[i], sizeof( **stages ));
+      pipe->build_state_trigger |= pipe->stages[i].check_state;
+   }
+
+   MEMSET( &pipe->stages[i], 0, sizeof( **stages ));
+
+   pipe->nr_stages = i;
+}
+
+void _tnl_destroy_pipeline( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint i;
+
+   for (i = 0 ; i < tnl->pipeline.nr_stages ; i++)
+      tnl->pipeline.stages[i].destroy( &tnl->pipeline.stages[i] );
+
+   tnl->pipeline.nr_stages = 0;
+}
+
+/* TODO: merge validate with run.
+ */
+void _tnl_validate_pipeline( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct gl_pipeline *pipe = &tnl->pipeline;
+   struct gl_pipeline_stage *s = pipe->stages;
+   GLuint newstate = pipe->build_state_changes;
+   GLuint generated = 0;
+   GLuint changed_inputs = 0;
+
+   pipe->inputs = 0;
+   pipe->build_state_changes = 0;
+
+   for ( ; s->check ; s++) {
+
+      s->changed_inputs |= s->inputs & changed_inputs;
+
+      if (s->check_state & newstate) {
+	 if (s->active) {
+	    GLuint old_outputs = s->outputs;
+	    s->check(ctx, s);
+	    if (!s->active)
+	       changed_inputs |= old_outputs;
+	 }
+	 else
+	    s->check(ctx, s);
+      }
+
+      if (s->active) {
+	 pipe->inputs |= s->inputs & ~generated;
+	 generated |= s->outputs;
+      }
+   }
+}
+
+
+
+void _tnl_run_pipeline( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   struct gl_pipeline *pipe = &tnl->pipeline;
+   struct gl_pipeline_stage *s = pipe->stages;
+   GLuint changed_state = pipe->run_state_changes;
+   GLuint changed_inputs = pipe->run_input_changes;
+   GLboolean running = GL_TRUE;
+   unsigned short __tmp;
+
+   pipe->run_state_changes = 0;
+   pipe->run_input_changes = 0;
+
+   /* Done elsewhere.
+    */
+   ASSERT(pipe->build_state_changes == 0);
+
+   START_FAST_MATH(__tmp);
+
+   /* If something changes in the pipeline, tag all subsequent stages
+    * using this value for recalculation.  Inactive stages have their
+    * state and inputs examined to try to keep cached data alive over
+    * state-changes.
+    */
+   for ( ; s->run ; s++) {
+      s->changed_inputs |= s->inputs & changed_inputs;
+
+      if (s->run_state & changed_state)
+	 s->changed_inputs = s->inputs;
+
+      if (s->active && running) {
+	 if (s->changed_inputs)
+	    changed_inputs |= s->outputs;
+
+	 running = s->run( ctx, s );
+
+	 s->changed_inputs = 0;
+	 VB->importable_data &= ~s->outputs;
+      }
+   }
+
+   END_FAST_MATH(__tmp);
+}
+
+
+
+/* The default pipeline.  This is useful for software rasterizers, and
+ * simple hardware rasterizers.  For customization, I don't recommend
+ * tampering with the internals of these stages in the way that
+ * drivers did in Mesa 3.4.  These stages are basically black boxes,
+ * and should be left intact.
+ *
+ * To customize the pipeline, consider:
+ *
+ * - removing redundant stages (making sure that the software rasterizer
+ *   can cope with this on fallback paths).  An example is fog
+ *   coordinate generation, which is not required in the FX driver.
+ *
+ * - replacing general-purpose machine-independent stages with
+ *   general-purpose machine-specific stages.  There is no example of
+ *   this to date, though it must be borne in mind that all subsequent
+ *   stages that reference the output of the new stage must cope with
+ *   any machine-specific data introduced.  This may not be easy
+ *   unless there are no such stages (ie the new stage is the last in
+ *   the pipe).
+ *
+ * - inserting optimized (but specialized) stages ahead of the
+ *   general-purpose fallback implementation.  For example, the old
+ *   fastpath mechanism, which only works when the VERT_ELT input is
+ *   available, can be duplicated by placing the fastpath stage at the
+ *   head of this pipeline.  Such specialized stages are currently
+ *   constrained to have no outputs (ie. they must either finish the *
+ *   pipeline by returning GL_FALSE from run(), or do nothing).
+ *
+ * Some work can be done to lift some of the restrictions in the final
+ * case, if it becomes necessary to do so.
+ */
+const struct gl_pipeline_stage *_tnl_default_pipeline[] = {
+   &_tnl_vertex_transform_stage,
+   &_tnl_normal_transform_stage,
+   &_tnl_lighting_stage,
+   &_tnl_fog_coordinate_stage,
+   &_tnl_texgen_stage,
+   &_tnl_texture_transform_stage,
+   &_tnl_point_attenuation_stage,
+   &_tnl_render_stage,
+   0
+};
Index: xc/extras/Mesa/src/tnl/t_pipeline.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_pipeline.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_pipeline.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,74 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+
+#ifndef _T_PIPELINE_H_
+#define _T_PIPELINE_H_
+
+#include "mtypes.h"
+#include "t_context.h"
+
+extern void _tnl_run_pipeline( GLcontext *ctx );
+
+extern void _tnl_validate_pipeline( GLcontext *ctx );
+
+extern void _tnl_destroy_pipeline( GLcontext *ctx );
+
+extern void _tnl_install_pipeline( GLcontext *ctx,
+				   const struct gl_pipeline_stage **stages );
+
+
+/* These are implemented in the t_vb_*.c files:
+ */
+extern const struct gl_pipeline_stage _tnl_vertex_transform_stage;
+extern const struct gl_pipeline_stage _tnl_normal_transform_stage;
+extern const struct gl_pipeline_stage _tnl_lighting_stage;
+extern const struct gl_pipeline_stage _tnl_fog_coordinate_stage;
+extern const struct gl_pipeline_stage _tnl_texgen_stage;
+extern const struct gl_pipeline_stage _tnl_texture_transform_stage;
+extern const struct gl_pipeline_stage _tnl_point_attenuation_stage;
+extern const struct gl_pipeline_stage _tnl_render_stage;
+
+/* Shorthand to plug in the default pipeline:
+ */
+extern const struct gl_pipeline_stage *_tnl_default_pipeline[];
+
+
+/* Convenience routines provided by t_vb_render.c:
+ */
+extern render_func _tnl_render_tab_elts[];
+extern render_func _tnl_render_tab_verts[];
+
+extern void _tnl_RenderClippedPolygon( GLcontext *ctx, 
+				       const GLuint *elts, GLuint n );
+
+extern void _tnl_RenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj );
+
+
+#endif
Index: xc/extras/Mesa/src/tnl/t_vb_cliptmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_cliptmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_cliptmp.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,270 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#define CLIP_DOTPROD(K, A, B, C, D) X(K)*A + Y(K)*B + Z(K)*C + W(K)*D
+
+#define POLY_CLIP( PLANE, A, B, C, D )					\
+do {									\
+   if (mask & PLANE) {							\
+      GLuint idxPrev = inlist[0];					\
+      GLfloat dpPrev = CLIP_DOTPROD(idxPrev, A, B, C, D );		\
+      GLuint outcount = 0;						\
+      GLuint i;								\
+									\
+      inlist[n] = inlist[0]; /* prevent rotation of vertices */		\
+      for (i = 1; i <= n; i++) {					\
+	 GLuint idx = inlist[i];					\
+	 GLfloat dp = CLIP_DOTPROD(idx, A, B, C, D );			\
+									\
+         clipmask[idxPrev] |= PLANE;					\
+	 if (!NEGATIVE(dpPrev)) {					\
+	    outlist[outcount++] = idxPrev;				\
+ 	    clipmask[idxPrev] &= ~PLANE;				\
+	 }								\
+									\
+	 if (DIFFERENT_SIGNS(dp, dpPrev)) {				\
+            GLuint newvert = VB->LastClipped++;				\
+            VB->ClipMask[newvert] = 0;					\
+            outlist[outcount++] = newvert;				\
+	    if (NEGATIVE(dp)) {						\
+	       /* Going out of bounds.  Avoid division by zero as we	\
+		* know dp != dpPrev from DIFFERENT_SIGNS, above.	\
+		*/							\
+	       GLfloat t = dp / (dp - dpPrev);				\
+               INTERP_4F( t, coord[newvert], coord[idx], coord[idxPrev]); \
+      	       interp( ctx, t, newvert, idx, idxPrev, GL_TRUE );	\
+	    } else {							\
+	       /* Coming back in.					\
+		*/							\
+	       GLfloat t = dpPrev / (dpPrev - dp);			\
+               INTERP_4F( t, coord[newvert], coord[idxPrev], coord[idx]); \
+	       interp( ctx, t, newvert, idxPrev, idx, GL_FALSE );	\
+	    }								\
+	 }								\
+									\
+	 idxPrev = idx;							\
+	 dpPrev = dp;							\
+      }									\
+									\
+      if (outcount < 3)							\
+	 return;							\
+									\
+      {									\
+	 GLuint *tmp = inlist;						\
+	 inlist = outlist;						\
+	 outlist = tmp;							\
+	 n = outcount;							\
+      }									\
+   }									\
+} while (0)
+
+
+#define LINE_CLIP(PLANE, A, B, C, D )					\
+do {									\
+   if (mask & PLANE) {							\
+      GLfloat dpI = CLIP_DOTPROD( ii, A, B, C, D );			\
+      GLfloat dpJ = CLIP_DOTPROD( jj, A, B, C, D );			\
+									\
+      if (DIFFERENT_SIGNS(dpI, dpJ)) {					\
+         GLuint newvert = VB->LastClipped++;				\
+         VB->ClipMask[newvert] = 0;					\
+	 if (NEGATIVE(dpJ)) {						\
+	    GLfloat t = dpI / (dpI - dpJ);				\
+            VB->ClipMask[jj] |= PLANE;					\
+            INTERP_4F( t, coord[newvert], coord[ii], coord[jj] );	\
+	    interp( ctx, t, newvert, ii, jj, GL_FALSE );		\
+            jj = newvert;						\
+	 } else {							\
+  	    GLfloat t = dpJ / (dpJ - dpI);				\
+            VB->ClipMask[ii] |= PLANE;					\
+            INTERP_4F( t, coord[newvert], coord[jj], coord[ii] );	\
+	    interp( ctx, t, newvert, jj, ii, GL_FALSE );		\
+            ii = newvert;						\
+	 }								\
+      }									\
+      else if (NEGATIVE(dpI))						\
+	 return;							\
+  }									\
+} while (0)
+
+
+
+/* Clip a line against the viewport and user clip planes.
+ */
+static INLINE void
+TAG(clip_line)( GLcontext *ctx, GLuint i, GLuint j, GLubyte mask )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   interp_func interp = tnl->Driver.Render.Interp;
+   GLfloat (*coord)[4] = VB->ClipPtr->data;
+   GLuint ii = i, jj = j, p;
+
+   VB->LastClipped = VB->FirstClipped;
+
+   if (mask & 0x3f) {
+      LINE_CLIP( CLIP_RIGHT_BIT,  -1,  0,  0, 1 );
+      LINE_CLIP( CLIP_LEFT_BIT,    1,  0,  0, 1 );
+      LINE_CLIP( CLIP_TOP_BIT,     0, -1,  0, 1 );
+      LINE_CLIP( CLIP_BOTTOM_BIT,  0,  1,  0, 1 );
+      LINE_CLIP( CLIP_FAR_BIT,     0,  0, -1, 1 );
+      LINE_CLIP( CLIP_NEAR_BIT,    0,  0,  1, 1 );
+   }
+
+   if (mask & CLIP_USER_BIT) {
+      for (p=0;p<MAX_CLIP_PLANES;p++) {
+	 if (ctx->Transform.ClipEnabled[p]) {
+	    GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+	    GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+	    GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+	    GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+	    LINE_CLIP( CLIP_USER_BIT, a, b, c, d );
+	 }
+      }
+   }
+
+   if ((ctx->_TriangleCaps & DD_FLATSHADE) && j != jj)
+      tnl->Driver.Render.CopyPV( ctx, jj, j );
+
+   tnl->Driver.Render.ClippedLine( ctx, ii, jj );
+}
+
+
+/* Clip a triangle against the viewport and user clip planes.
+ */
+static INLINE void
+TAG(clip_tri)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLubyte mask )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   interp_func interp = tnl->Driver.Render.Interp;
+   GLfloat (*coord)[4] = VB->ClipPtr->data;
+   GLuint pv = v2;
+   GLuint vlist[2][MAX_CLIPPED_VERTICES];
+   GLuint *inlist = vlist[0], *outlist = vlist[1];
+   GLuint p;
+   GLubyte *clipmask = VB->ClipMask;
+   GLuint n = 3;
+
+   ASSIGN_3V(inlist, v2, v0, v1 ); /* pv rotated to slot zero */
+
+   VB->LastClipped = VB->FirstClipped;
+
+   if (mask & 0x3f) {
+      POLY_CLIP( CLIP_RIGHT_BIT,  -1,  0,  0, 1 );
+      POLY_CLIP( CLIP_LEFT_BIT,    1,  0,  0, 1 );
+      POLY_CLIP( CLIP_TOP_BIT,     0, -1,  0, 1 );
+      POLY_CLIP( CLIP_BOTTOM_BIT,  0,  1,  0, 1 );
+      POLY_CLIP( CLIP_FAR_BIT,     0,  0, -1, 1 );
+      POLY_CLIP( CLIP_NEAR_BIT,    0,  0,  1, 1 );
+   }
+
+   if (mask & CLIP_USER_BIT) {
+      for (p=0;p<MAX_CLIP_PLANES;p++) {
+	 if (ctx->Transform.ClipEnabled[p]) {
+	    GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+	    GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+	    GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+	    GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+	    POLY_CLIP( CLIP_USER_BIT, a, b, c, d );
+	 }
+      }
+   }
+
+   if (ctx->_TriangleCaps & DD_FLATSHADE) {
+      if (pv != inlist[0]) {
+	 ASSERT( inlist[0] >= VB->FirstClipped );
+	 tnl->Driver.Render.CopyPV( ctx, inlist[0], pv );
+      }
+   }
+
+   tnl->Driver.Render.ClippedPolygon( ctx, inlist, n );
+}
+
+
+/* Clip a quad against the viewport and user clip planes.
+ */
+static INLINE void
+TAG(clip_quad)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint v3,
+                GLubyte mask )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   interp_func interp = tnl->Driver.Render.Interp;
+   GLfloat (*coord)[4] = VB->ClipPtr->data;
+   GLuint pv = v3;
+   GLuint vlist[2][MAX_CLIPPED_VERTICES];
+   GLuint *inlist = vlist[0], *outlist = vlist[1];
+   GLuint p;
+   GLubyte *clipmask = VB->ClipMask;
+   GLuint n = 4;
+
+   ASSIGN_4V(inlist, v3, v0, v1, v2 ); /* pv rotated to slot zero */
+
+   VB->LastClipped = VB->FirstClipped;
+
+   if (mask & 0x3f) {
+      POLY_CLIP( CLIP_RIGHT_BIT,  -1,  0,  0, 1 );
+      POLY_CLIP( CLIP_LEFT_BIT,    1,  0,  0, 1 );
+      POLY_CLIP( CLIP_TOP_BIT,     0, -1,  0, 1 );
+      POLY_CLIP( CLIP_BOTTOM_BIT,  0,  1,  0, 1 );
+      POLY_CLIP( CLIP_FAR_BIT,     0,  0, -1, 1 );
+      POLY_CLIP( CLIP_NEAR_BIT,    0,  0,  1, 1 );
+   }
+
+   if (mask & CLIP_USER_BIT) {
+      for (p=0;p<MAX_CLIP_PLANES;p++) {
+	 if (ctx->Transform.ClipEnabled[p]) {
+	    GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+	    GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+	    GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+	    GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+	    POLY_CLIP( CLIP_USER_BIT, a, b, c, d );
+	 }
+      }
+   }
+
+   if (ctx->_TriangleCaps & DD_FLATSHADE) {
+      if (pv != inlist[0]) {
+	 ASSERT( inlist[0] >= VB->FirstClipped );
+	 tnl->Driver.Render.CopyPV( ctx, inlist[0], pv );
+      }
+   }
+
+   tnl->Driver.Render.ClippedPolygon( ctx, inlist, n );
+}
+
+#undef W
+#undef Z
+#undef Y
+#undef X
+#undef SIZE
+#undef TAG
+#undef POLY_CLIP
+#undef LINE_CLIP
Index: xc/extras/Mesa/src/tnl/t_vb_fog.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_fog.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_fog.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,249 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+struct fog_stage_data {
+   GLvector1f fogcoord;		/* has actual storage allocated */
+   GLvector1f input;		/* points into VB->EyePtr Z values */
+};
+
+#define FOG_STAGE_DATA(stage) ((struct fog_stage_data *)stage->privatePtr)
+
+#define FOG_EXP_TABLE_SIZE 256
+#define FOG_MAX (10.0)
+#define EXP_FOG_MAX .0006595
+#define FOG_INCR (FOG_MAX/FOG_EXP_TABLE_SIZE)
+static GLfloat exp_table[FOG_EXP_TABLE_SIZE];
+static GLfloat inited = 0;
+
+#if 1
+#define NEG_EXP( result, narg )						\
+do {									\
+   GLfloat f = (GLfloat) (narg * (1.0/FOG_INCR));			\
+   GLint k = (GLint) f;							\
+   if (k > FOG_EXP_TABLE_SIZE-2) 					\
+      result = (GLfloat) EXP_FOG_MAX;					\
+   else									\
+      result = exp_table[k] + (f-k)*(exp_table[k+1]-exp_table[k]);	\
+} while (0)
+#else
+#define NEG_EXP( result, narg )					\
+do {								\
+   result = exp(-narg);						\
+} while (0)
+#endif
+
+
+static void init_static_data( void )
+{
+   GLfloat f = 0.0F;
+   GLint i = 0;
+   for ( ; i < FOG_EXP_TABLE_SIZE ; i++, f += FOG_INCR) {
+      exp_table[i] = (GLfloat) exp(-f);
+   }
+   inited = 1;
+}
+
+
+static void make_win_fog_coords( GLcontext *ctx, GLvector1f *out,
+				 const GLvector1f *in )
+{
+   GLfloat end  = ctx->Fog.End;
+   GLfloat *v = in->start;
+   GLuint stride = in->stride;
+   GLuint n = in->count;
+   GLfloat *data = out->data;
+   GLfloat d;
+   GLuint i;
+
+   out->count = in->count;
+
+   switch (ctx->Fog.Mode) {
+   case GL_LINEAR:
+      if (ctx->Fog.Start == ctx->Fog.End)
+         d = 1.0F;
+      else
+         d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
+         GLfloat f = (end - ABSF(*v)) * d;
+	 data[i] = CLAMP(f, 0.0F, 1.0F);
+      }
+      break;
+   case GL_EXP:
+      d = ctx->Fog.Density;
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride))
+         NEG_EXP( data[i], d * ABSF(*v) );
+      break;
+   case GL_EXP2:
+      d = ctx->Fog.Density*ctx->Fog.Density;
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
+         GLfloat z = *v;
+         NEG_EXP( data[i], d * z * z );
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "Bad fog mode in make_fog_coord");
+      return;
+   }
+}
+
+
+static GLboolean run_fog_stage( GLcontext *ctx,
+				struct gl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
+   GLvector1f *input;
+
+   if (stage->changed_inputs == 0)
+      return GL_TRUE;
+
+   if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT) {
+      /* fog computed from Z depth */
+      /* source = VB->ObjPtr or VB->EyePtr coords */
+      /* dest = VB->FogCoordPtr = fog stage private storage */
+      VB->FogCoordPtr = &store->fogcoord;
+
+      if (!ctx->_NeedEyeCoords) {
+	 GLfloat *m = ctx->ModelView.m;
+	 GLfloat plane[4];
+
+	 /* Use this to store calculated eye z values:
+	  */
+	 input = &store->fogcoord;
+
+	 plane[0] = m[2];
+	 plane[1] = m[6];
+	 plane[2] = m[10];
+	 plane[3] = m[14];
+
+	 /* Full eye coords weren't required, just calculate the
+	  * eye Z values.
+	  */
+	 _mesa_dotprod_tab[VB->ObjPtr->size]( input->data,
+					      sizeof(GLfloat),
+					      VB->ObjPtr, plane );
+
+	 input->count = VB->ObjPtr->count;
+      }
+      else
+      {
+	 input = &store->input;
+
+	 if (VB->EyePtr->size < 2)
+	    _mesa_vector4f_clean_elem( VB->EyePtr, VB->Count, 2 );
+
+	 input->data = &(VB->EyePtr->data[0][2]);
+	 input->start = VB->EyePtr->start+2;
+	 input->stride = VB->EyePtr->stride;
+	 input->count = VB->EyePtr->count;
+      }
+   } else {
+      /* use glFogCoord() coordinates */
+      /* source = VB->FogCoordPtr */
+      input = VB->FogCoordPtr;
+      /* dest = fog stage private storage */
+      VB->FogCoordPtr = &store->fogcoord;
+   }
+
+   make_win_fog_coords( ctx, VB->FogCoordPtr, input );
+   return GL_TRUE;
+}
+
+static void check_fog_stage( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   stage->active = ctx->Fog.Enabled;
+
+   if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT)
+      stage->inputs = VERT_EYE;
+   else
+      stage->inputs = VERT_FOG_COORD;
+}
+
+
+/* Called the first time stage->run() is invoked.
+ */
+static GLboolean alloc_fog_data( GLcontext *ctx,
+				 struct gl_pipeline_stage *stage )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct fog_stage_data *store;
+   stage->privatePtr = MALLOC(sizeof(*store));
+   store = FOG_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector1f_alloc( &store->fogcoord, 0, tnl->vb.Size, 32 );
+   _mesa_vector1f_init( &store->input, 0, 0 );
+
+   if (!inited)
+      init_static_data();
+
+   /* Now run the stage.
+    */
+   stage->run = run_fog_stage;
+   return stage->run( ctx, stage );
+}
+
+
+static void free_fog_data( struct gl_pipeline_stage *stage )
+{
+   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
+   if (store) {
+      _mesa_vector1f_free( &store->fogcoord );
+      FREE( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+const struct gl_pipeline_stage _tnl_fog_coordinate_stage =
+{
+   "build fog coordinates",
+   _NEW_FOG,
+   _NEW_FOG,
+   0, 0, VERT_FOG_COORD,	/* active, inputs, outputs */
+   0, 0,			/* changed_inputs, private_data */
+   free_fog_data,		/* dtr */
+   check_fog_stage,		/* check */
+   alloc_fog_data		/* run -- initially set to init. */
+};
Index: xc/extras/Mesa/src/tnl/t_vb_light.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_light.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_light.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,346 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "light.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "simple_list.h"
+#include "mtypes.h"
+
+#include "math/m_translate.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+#define LIGHT_FLAGS         0x1	/* must be first */
+#define LIGHT_TWOSIDE       0x2
+#define LIGHT_COLORMATERIAL 0x4
+#define MAX_LIGHT_FUNC      0x8
+
+typedef void (*light_func)( GLcontext *ctx,
+			    struct vertex_buffer *VB,
+			    struct gl_pipeline_stage *stage,
+			    GLvector4f *input );
+
+struct light_stage_data {
+   struct gl_client_array FloatColor; 
+   struct gl_client_array LitColor[2];
+   struct gl_client_array LitSecondary[2];
+   GLvector1ui LitIndex[2];
+   light_func *light_func_tab;
+};
+
+
+#define LIGHT_STAGE_DATA(stage) ((struct light_stage_data *)(stage->privatePtr))
+
+
+static void import_color_material( GLcontext *ctx,
+				   struct gl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct gl_client_array *to = &LIGHT_STAGE_DATA(stage)->FloatColor;
+   struct gl_client_array *from = VB->ColorPtr[0];
+   GLuint count = VB->Count;
+
+   if (!to->Ptr) {
+      to->Ptr = ALIGN_MALLOC( VB->Size * 4 * sizeof(GLfloat), 32 );
+      to->Type = GL_FLOAT;
+   }
+
+   /* No need to transform the same value 3000 times.
+    */
+   if (!from->StrideB) {
+      to->StrideB = 0;
+      count = 1;
+   }
+   else
+      to->StrideB = 4 * sizeof(GLfloat);
+   
+   _math_trans_4f( (GLfloat (*)[4]) to->Ptr,
+		   from->Ptr,
+		   from->StrideB,
+		   from->Type,
+		   from->Size,
+		   0,
+		   count);
+
+   VB->ColorPtr[0] = to;
+}
+
+
+/* Tables for all the shading functions.
+ */
+static light_func _tnl_light_tab[MAX_LIGHT_FUNC];
+static light_func _tnl_light_fast_tab[MAX_LIGHT_FUNC];
+static light_func _tnl_light_fast_single_tab[MAX_LIGHT_FUNC];
+static light_func _tnl_light_spec_tab[MAX_LIGHT_FUNC];
+static light_func _tnl_light_ci_tab[MAX_LIGHT_FUNC];
+
+#define TAG(x)           x
+#define IDX              (0)
+#include "t_vb_lighttmp.h"
+
+#define TAG(x)           x##_tw
+#define IDX              (LIGHT_TWOSIDE)
+#include "t_vb_lighttmp.h"
+
+#define TAG(x)           x##_fl
+#define IDX              (LIGHT_FLAGS)
+#include "t_vb_lighttmp.h"
+
+#define TAG(x)           x##_tw_fl
+#define IDX              (LIGHT_FLAGS|LIGHT_TWOSIDE)
+#include "t_vb_lighttmp.h"
+
+#define TAG(x)           x##_cm
+#define IDX              (LIGHT_COLORMATERIAL)
+#include "t_vb_lighttmp.h"
+
+#define TAG(x)           x##_tw_cm
+#define IDX              (LIGHT_TWOSIDE|LIGHT_COLORMATERIAL)
+#include "t_vb_lighttmp.h"
+
+#define TAG(x)           x##_fl_cm
+#define IDX              (LIGHT_FLAGS|LIGHT_COLORMATERIAL)
+#include "t_vb_lighttmp.h"
+
+#define TAG(x)           x##_tw_fl_cm
+#define IDX              (LIGHT_FLAGS|LIGHT_TWOSIDE|LIGHT_COLORMATERIAL)
+#include "t_vb_lighttmp.h"
+
+
+static void init_lighting( void )
+{
+   static int done;
+
+   if (!done) {
+      init_light_tab();
+      init_light_tab_tw();
+      init_light_tab_fl();
+      init_light_tab_tw_fl();
+      init_light_tab_cm();
+      init_light_tab_tw_cm();
+      init_light_tab_fl_cm();
+      init_light_tab_tw_fl_cm();
+      done = 1;
+   }
+}
+
+
+static GLboolean run_lighting( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLvector4f *input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
+   GLuint ind;
+
+/*     _tnl_print_vert_flags( __FUNCTION__, stage->changed_inputs ); */
+
+   /* Make sure we can talk about elements 0..2 in the vector we are
+    * lighting.
+    */
+   if (stage->changed_inputs & (VERT_EYE|VERT_OBJ)) {
+      if (input->size <= 2) {
+	 if (input->flags & VEC_NOT_WRITEABLE) {
+	    ASSERT(VB->importable_data & VERT_OBJ);
+
+	    VB->import_data( ctx, VERT_OBJ, VEC_NOT_WRITEABLE );
+	    input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
+
+	    ASSERT((input->flags & VEC_NOT_WRITEABLE) == 0);
+	 }
+
+	 _mesa_vector4f_clean_elem(input, VB->Count, 2);
+      }
+   }
+
+   if (VB->Flag)
+      ind = LIGHT_FLAGS;
+   else
+      ind = 0;
+
+   /* The individual functions know about replaying side-effects
+    * vs. full re-execution. 
+    */
+   store->light_func_tab[ind]( ctx, VB, stage, input );
+
+   return GL_TRUE;
+}
+
+
+/* Called in place of do_lighting when the light table may have changed.
+ */
+static GLboolean run_validate_lighting( GLcontext *ctx,
+					struct gl_pipeline_stage *stage )
+{
+   GLuint ind = 0;
+   light_func *tab;
+
+   if (ctx->Visual.rgbMode) {
+      if (ctx->Light._NeedVertices) {
+	 if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+	    tab = _tnl_light_spec_tab;
+	 else
+	    tab = _tnl_light_tab;
+      }
+      else {
+	 if (ctx->Light.EnabledList.next == ctx->Light.EnabledList.prev)
+	    tab = _tnl_light_fast_single_tab;
+	 else
+	    tab = _tnl_light_fast_tab;
+      }
+   }
+   else
+      tab = _tnl_light_ci_tab;
+
+   if (ctx->Light.ColorMaterialEnabled)
+      ind |= LIGHT_COLORMATERIAL;
+
+   if (ctx->Light.Model.TwoSide)
+      ind |= LIGHT_TWOSIDE;
+
+   LIGHT_STAGE_DATA(stage)->light_func_tab = &tab[ind];
+
+   /* This and the above should only be done on _NEW_LIGHT:
+    */
+   TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+
+   /* Now run the stage...
+    */
+   stage->run = run_lighting;
+   return stage->run( ctx, stage );
+}
+
+static void alloc_4chan( struct gl_client_array *a, GLuint sz )
+{
+   a->Ptr = ALIGN_MALLOC( sz * sizeof(GLchan) * 4, 32 );
+   a->Size = 4;
+   a->Type = CHAN_TYPE;
+   a->Stride = 0;
+   a->StrideB = sizeof(GLchan) * 4;
+   a->Enabled = 0;
+   a->Flags = 0;
+}
+
+
+/* Called the first time stage->run is called.  In effect, don't
+ * allocate data until the first time the stage is run.
+ */
+static GLboolean run_init_lighting( GLcontext *ctx,
+				    struct gl_pipeline_stage *stage )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct light_stage_data *store;
+   GLuint size = tnl->vb.Size;
+
+   stage->privatePtr = MALLOC(sizeof(*store));
+   store = LIGHT_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   /* Do onetime init.
+    */
+   init_lighting();
+
+   store->FloatColor.Ptr = 0;
+
+   alloc_4chan( &store->LitColor[0], size );
+   alloc_4chan( &store->LitColor[1], size );
+   alloc_4chan( &store->LitSecondary[0], size );
+   alloc_4chan( &store->LitSecondary[1], size );
+
+   _mesa_vector1ui_alloc( &store->LitIndex[0], 0, size, 32 );
+   _mesa_vector1ui_alloc( &store->LitIndex[1], 0, size, 32 );
+
+   /* Now validate the stage derived data...
+    */
+   stage->run = run_validate_lighting;
+   return stage->run( ctx, stage );
+}
+
+
+
+/*
+ * Check if lighting is enabled.  If so, configure the pipeline stage's
+ * type, inputs, and outputs.
+ */
+static void check_lighting( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   stage->active = ctx->Light.Enabled;
+   if (stage->active) {
+      if (stage->privatePtr)
+	 stage->run = run_validate_lighting;
+      stage->inputs = VERT_NORM|VERT_MATERIAL;
+      if (ctx->Light._NeedVertices)
+	 stage->inputs |= VERT_EYE; /* effectively, even when lighting in obj */
+      if (ctx->Light.ColorMaterialEnabled)
+	 stage->inputs |= VERT_RGBA;
+
+      stage->outputs = VERT_RGBA;
+      if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
+	 stage->outputs |= VERT_SPEC_RGB;
+   }
+}
+
+
+static void dtr( struct gl_pipeline_stage *stage )
+{
+   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
+
+   if (store) {
+      ALIGN_FREE( store->LitColor[0].Ptr );
+      ALIGN_FREE( store->LitColor[1].Ptr );
+      ALIGN_FREE( store->LitSecondary[0].Ptr );
+      ALIGN_FREE( store->LitSecondary[1].Ptr );
+
+      if (store->FloatColor.Ptr)
+	 ALIGN_FREE( store->FloatColor.Ptr );
+
+      _mesa_vector1ui_free( &store->LitIndex[0] );
+      _mesa_vector1ui_free( &store->LitIndex[1] );
+      FREE( store );
+      stage->privatePtr = 0;
+   }
+}
+
+const struct gl_pipeline_stage _tnl_lighting_stage =
+{
+   "lighting",
+   _NEW_LIGHT,			/* recheck */
+   _NEW_LIGHT|_NEW_MODELVIEW,	/* recalc -- modelview dependency
+				 * otherwise not captured by inputs
+				 * (which may be VERT_OBJ) */
+   0,0,0,			/* active, inputs, outputs */
+   0,0,				/* changed_inputs, private_data */
+   dtr,				/* destroy */
+   check_lighting,		/* check */
+   run_init_lighting		/* run -- initially set to ctr */
+};
Index: xc/extras/Mesa/src/tnl/t_vb_lighttmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_lighttmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_lighttmp.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,995 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ *
+ * Authors:
+ *    Brian Paul <brianp@valinux.com>
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#if (IDX & LIGHT_FLAGS)
+#  define VSTRIDE (4 * sizeof(GLfloat))
+#  define NSTRIDE (3 * sizeof(GLfloat))
+#  define CHECK_MATERIAL(x)  (flags[x] & VERT_MATERIAL)
+#  define CHECK_END_VB(x)    (flags[x] & VERT_END_VB)
+#  if (IDX & LIGHT_COLORMATERIAL)
+#    define CMSTRIDE STRIDE_F(CMcolor, CMstride)
+#    define CHECK_COLOR_MATERIAL(x) (flags[x] & VERT_RGBA)
+#    define CHECK_VALIDATE(x) (flags[x] & (VERT_RGBA|VERT_MATERIAL))
+#    define DO_ANOTHER_NORMAL(x) \
+     ((flags[x] & (VERT_RGBA|VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == VERT_NORM)
+#    define REUSE_LIGHT_RESULTS(x) \
+     ((flags[x] & (VERT_RGBA|VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == 0)
+#  else
+#    define CMSTRIDE (void)0
+#    define CHECK_COLOR_MATERIAL(x) 0
+#    define CHECK_VALIDATE(x) (flags[x] & (VERT_MATERIAL))
+#    define DO_ANOTHER_NORMAL(x) \
+      ((flags[x] & (VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == VERT_NORM)
+#    define REUSE_LIGHT_RESULTS(x) \
+      ((flags[x] & (VERT_NORM|VERT_END_VB|VERT_MATERIAL)) == 0)
+#  endif
+#else
+#  define VSTRIDE vstride
+#  define NSTRIDE nstride
+#  define CHECK_MATERIAL(x)   0	           /* no materials on array paths */
+#  define CHECK_END_VB(XX)     (XX >= nr)
+#  if (IDX & LIGHT_COLORMATERIAL)
+#     define CMSTRIDE STRIDE_F(CMcolor, CMstride)
+#     define CHECK_COLOR_MATERIAL(x) (x < nr) /* always have colormaterial */
+#     define CHECK_VALIDATE(x) (x < nr)
+#     define DO_ANOTHER_NORMAL(x) 0        /* always stop to recalc colormat */
+#  else
+#     define CMSTRIDE (void)0
+#     define CHECK_COLOR_MATERIAL(x) 0        /* no colormaterial */
+#     define CHECK_VALIDATE(x) (0)
+#     define DO_ANOTHER_NORMAL(XX) (XX < nr) /* keep going to end of vb */
+#  endif
+#  define REUSE_LIGHT_RESULTS(x) 0         /* always have a new normal */
+#endif
+
+
+
+#if (IDX & LIGHT_TWOSIDE)
+#  define NR_SIDES 2
+#else
+#  define NR_SIDES 1
+#endif
+
+
+
+static void TAG(light_rgba_spec)( GLcontext *ctx,
+				  struct vertex_buffer *VB,
+				  struct gl_pipeline_stage *stage,
+				  GLvector4f *input )
+{
+   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
+   GLfloat (*base)[3] = ctx->Light._BaseColor;
+   GLchan sumA[2];
+
+   GLuint j;
+
+   GLuint  vstride = input->stride;
+   const GLfloat *vertex = (GLfloat *)input->data;
+   GLuint  nstride = VB->NormalPtr->stride;
+   const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
+
+   GLfloat *CMcolor;
+   GLuint CMstride;
+
+   GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].Ptr;
+   GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].Ptr;
+   GLchan (*Fspec)[4] = (GLchan (*)[4]) store->LitSecondary[0].Ptr;
+   GLchan (*Bspec)[4] = (GLchan (*)[4]) store->LitSecondary[1].Ptr;
+   GLchan (*spec[2])[4];
+
+   GLuint nr = VB->Count;
+   GLuint *flags = VB->Flag;
+   struct gl_material (*new_material)[2] = VB->Material;
+   GLuint *new_material_mask = VB->MaterialMask;
+
+   (void) flags;
+   (void) nstride;
+   (void) vstride;
+
+
+   if (MESA_VERBOSE & VERBOSE_LIGHTING)
+      fprintf(stderr, "%s\n", __FUNCTION__ );   
+
+   spec[0] = Fspec;
+   spec[1] = Bspec;
+
+   if (IDX & LIGHT_COLORMATERIAL) {
+      if (VB->ColorPtr[0]->Type != GL_FLOAT || 
+	  VB->ColorPtr[0]->Size != 4)
+	 import_color_material( ctx, stage );
+
+      CMcolor = (GLfloat *) VB->ColorPtr[0]->Ptr;
+      CMstride = VB->ColorPtr[0]->StrideB;
+   }
+
+   VB->ColorPtr[0] = &store->LitColor[0];
+   VB->SecondaryColorPtr[0] = &store->LitSecondary[0];
+   UNCLAMPED_FLOAT_TO_CHAN(sumA[0], ctx->Light.Material[0].Diffuse[3]);
+
+   if (IDX & LIGHT_TWOSIDE) {
+      VB->ColorPtr[1] = &store->LitColor[1];
+      VB->SecondaryColorPtr[1] = &store->LitSecondary[1];
+      UNCLAMPED_FLOAT_TO_CHAN(sumA[1], ctx->Light.Material[1].Diffuse[3]);
+   }
+
+   /* Side-effects done, can we finish now?
+    */
+   if (stage->changed_inputs == 0)
+      return;
+
+   for ( j=0 ;
+	 j<nr ;
+	 j++,STRIDE_F(vertex,VSTRIDE),STRIDE_F(normal,NSTRIDE),CMSTRIDE)
+   {
+      GLfloat sum[2][3], spec[2][3];
+      struct gl_light *light;
+
+      if ( CHECK_COLOR_MATERIAL(j) )
+	 _mesa_update_color_material( ctx, CMcolor );
+
+      if ( CHECK_MATERIAL(j) )
+	 _mesa_update_material( ctx, new_material[j], new_material_mask[j] );
+
+      if ( CHECK_VALIDATE(j) ) {
+	 TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+	 UNCLAMPED_FLOAT_TO_CHAN(sumA[0], ctx->Light.Material[0].Diffuse[3]);
+	 if (IDX & LIGHT_TWOSIDE) 
+	    UNCLAMPED_FLOAT_TO_CHAN(sumA[1], ctx->Light.Material[1].Diffuse[3]);
+      }
+
+      COPY_3V(sum[0], base[0]);
+      ZERO_3V(spec[0]);
+
+      if (IDX & LIGHT_TWOSIDE) {
+	 COPY_3V(sum[1], base[1]);
+	 ZERO_3V(spec[1]);
+      }
+
+      /* Add contribution from each enabled light source */
+      foreach (light, &ctx->Light.EnabledList) {
+	 GLfloat n_dot_h;
+	 GLfloat correction;
+	 GLint side;
+	 GLfloat contrib[3];
+	 GLfloat attenuation;
+	 GLfloat VP[3];  /* unit vector from vertex to light */
+	 GLfloat n_dot_VP;       /* n dot VP */
+	 GLfloat *h;
+
+	 /* compute VP and attenuation */
+	 if (!(light->_Flags & LIGHT_POSITIONAL)) {
+	    /* directional light */
+	    COPY_3V(VP, light->_VP_inf_norm);
+	    attenuation = light->_VP_inf_spot_attenuation;
+	 }
+	 else {
+	    GLfloat d;     /* distance from vertex to light */
+
+	    SUB_3V(VP, light->_Position, vertex);
+
+	    d = (GLfloat) LEN_3FV( VP );
+
+	    if (d > 1e-6) {
+	       GLfloat invd = 1.0F / d;
+	       SELF_SCALE_SCALAR_3V(VP, invd);
+	    }
+
+	    attenuation = 1.0F / (light->ConstantAttenuation + d *
+				  (light->LinearAttenuation + d *
+				   light->QuadraticAttenuation));
+
+	    /* spotlight attenuation */
+	    if (light->_Flags & LIGHT_SPOT) {
+	       GLfloat PV_dot_dir = - DOT3(VP, light->_NormDirection);
+
+	       if (PV_dot_dir<light->_CosCutoff) {
+		  continue; /* this light makes no contribution */
+	       }
+	       else {
+		  GLdouble x = PV_dot_dir * (EXP_TABLE_SIZE-1);
+		  GLint k = (GLint) x;
+		  GLfloat spot = (GLfloat) (light->_SpotExpTable[k][0]
+				    + (x-k)*light->_SpotExpTable[k][1]);
+		  attenuation *= spot;
+	       }
+	    }
+	 }
+
+	 if (attenuation < 1e-3)
+	    continue;		/* this light makes no contribution */
+
+	 /* Compute dot product or normal and vector from V to light pos */
+	 n_dot_VP = DOT3( normal, VP );
+
+	 /* Which side gets the diffuse & specular terms? */
+	 if (n_dot_VP < 0.0F) {
+	    ACC_SCALE_SCALAR_3V(sum[0], attenuation, light->_MatAmbient[0]);
+	    if (!(IDX & LIGHT_TWOSIDE)) {
+	       continue;
+	    }
+	    side = 1;
+	    correction = -1;
+	    n_dot_VP = -n_dot_VP;
+	 }
+         else {
+	    if (IDX & LIGHT_TWOSIDE) {
+	       ACC_SCALE_SCALAR_3V( sum[1], attenuation, light->_MatAmbient[1]);
+	    }
+	    side = 0;
+	    correction = 1;
+	 }
+
+	 /* diffuse term */
+	 COPY_3V(contrib, light->_MatAmbient[side]);
+	 ACC_SCALE_SCALAR_3V(contrib, n_dot_VP, light->_MatDiffuse[side]);
+	 ACC_SCALE_SCALAR_3V(sum[side], attenuation, contrib );
+
+	 /* specular term - cannibalize VP... */
+	 if (ctx->Light.Model.LocalViewer) {
+	    GLfloat v[3];
+	    COPY_3V(v, vertex);
+	    NORMALIZE_3FV(v);
+	    SUB_3V(VP, VP, v);                /* h = VP + VPe */
+	    h = VP;
+	    NORMALIZE_3FV(h);
+	 }
+	 else if (light->_Flags & LIGHT_POSITIONAL) {
+	    h = VP;
+	    ACC_3V(h, ctx->_EyeZDir);
+	    NORMALIZE_3FV(h);
+	 }
+         else {
+	    h = light->_h_inf_norm;
+	 }
+
+	 n_dot_h = correction * DOT3(normal, h);
+
+	 if (n_dot_h > 0.0F) {
+	    GLfloat spec_coef;
+	    struct gl_shine_tab *tab = ctx->_ShineTable[side];
+	    GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec_coef );
+
+	    if (spec_coef > 1.0e-10) {
+	       spec_coef *= attenuation;
+	       ACC_SCALE_SCALAR_3V( spec[side], spec_coef,
+				    light->_MatSpecular[side]);
+	    }
+	 }
+      } /*loop over lights*/
+
+      UNCLAMPED_FLOAT_TO_RGB_CHAN( Fcolor[j], sum[0] );
+      UNCLAMPED_FLOAT_TO_RGB_CHAN( Fspec[j], spec[0] );
+      Fcolor[j][3] = sumA[0];
+
+      if (IDX & LIGHT_TWOSIDE) {
+	 UNCLAMPED_FLOAT_TO_RGB_CHAN( Bcolor[j], sum[1] );
+	 UNCLAMPED_FLOAT_TO_RGB_CHAN( Bspec[j], spec[1] );
+	 Bcolor[j][3] = sumA[1];
+      }
+   }
+}
+
+
+static void TAG(light_rgba)( GLcontext *ctx,
+			     struct vertex_buffer *VB,
+			     struct gl_pipeline_stage *stage,
+			     GLvector4f *input )
+{
+   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
+   GLuint j;
+
+   GLfloat (*base)[3] = ctx->Light._BaseColor;
+   GLchan sumA[2];
+
+   GLuint  vstride = input->stride;
+   const GLfloat *vertex = (GLfloat *) input->data;
+   GLuint  nstride = VB->NormalPtr->stride;
+   const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
+
+   GLfloat *CMcolor;
+   GLuint CMstride;
+
+   GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].Ptr;
+   GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].Ptr;
+   GLchan (*color[2])[4];
+   GLuint *flags = VB->Flag;
+
+   struct gl_material (*new_material)[2] = VB->Material;
+   GLuint *new_material_mask = VB->MaterialMask;
+   GLuint nr = VB->Count;
+
+   if (MESA_VERBOSE & VERBOSE_LIGHTING)
+      fprintf(stderr, "%s\n", __FUNCTION__ );   
+
+   (void) flags;
+   (void) nstride;
+   (void) vstride;
+
+   color[0] = Fcolor;
+   color[1] = Bcolor;
+
+   if (IDX & LIGHT_COLORMATERIAL) {
+      if (VB->ColorPtr[0]->Type != GL_FLOAT || 
+	  VB->ColorPtr[0]->Size != 4)
+	 import_color_material( ctx, stage );
+
+      CMcolor = (GLfloat *)VB->ColorPtr[0]->Ptr;
+      CMstride = VB->ColorPtr[0]->StrideB;
+   }
+
+   VB->ColorPtr[0] = &store->LitColor[0];
+   UNCLAMPED_FLOAT_TO_CHAN(sumA[0], ctx->Light.Material[0].Diffuse[3]);
+
+   if (IDX & LIGHT_TWOSIDE) {
+      VB->ColorPtr[1] = &store->LitColor[1];
+      UNCLAMPED_FLOAT_TO_CHAN(sumA[1], ctx->Light.Material[1].Diffuse[3]);
+   }
+
+   if (stage->changed_inputs == 0)
+      return;
+
+   for ( j=0 ;
+	 j<nr ;
+	 j++,STRIDE_F(vertex,VSTRIDE), STRIDE_F(normal,NSTRIDE),CMSTRIDE)
+   {
+      GLfloat sum[2][3];
+      struct gl_light *light;
+
+      if ( CHECK_COLOR_MATERIAL(j) )
+	 _mesa_update_color_material( ctx, CMcolor );
+
+      if ( CHECK_MATERIAL(j) )
+	 _mesa_update_material( ctx, new_material[j], new_material_mask[j] );
+
+      if ( CHECK_VALIDATE(j) ) {
+	 TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+	 UNCLAMPED_FLOAT_TO_CHAN(sumA[0], ctx->Light.Material[0].Diffuse[3]);
+	 if (IDX & LIGHT_TWOSIDE)
+	    UNCLAMPED_FLOAT_TO_CHAN(sumA[1], ctx->Light.Material[1].Diffuse[3]);
+      }
+
+      COPY_3V(sum[0], base[0]);
+
+      if ( IDX & LIGHT_TWOSIDE )
+	 COPY_3V(sum[1], base[1]);
+
+      /* Add contribution from each enabled light source */
+      foreach (light, &ctx->Light.EnabledList) {
+
+	 GLfloat n_dot_h;
+	 GLfloat correction;
+	 GLint side;
+	 GLfloat contrib[3];
+	 GLfloat attenuation = 1.0;
+	 GLfloat VP[3];          /* unit vector from vertex to light */
+	 GLfloat n_dot_VP;       /* n dot VP */
+	 GLfloat *h;
+
+	 /* compute VP and attenuation */
+	 if (!(light->_Flags & LIGHT_POSITIONAL)) {
+	    /* directional light */
+	    COPY_3V(VP, light->_VP_inf_norm);
+	    attenuation = light->_VP_inf_spot_attenuation;
+	 }
+	 else {
+	    GLfloat d;     /* distance from vertex to light */
+
+
+	    SUB_3V(VP, light->_Position, vertex);
+
+	    d = (GLfloat) LEN_3FV( VP );
+
+	    if ( d > 1e-6) {
+	       GLfloat invd = 1.0F / d;
+	       SELF_SCALE_SCALAR_3V(VP, invd);
+	    }
+
+            attenuation = 1.0F / (light->ConstantAttenuation + d *
+                                  (light->LinearAttenuation + d *
+                                   light->QuadraticAttenuation));
+
+	    /* spotlight attenuation */
+	    if (light->_Flags & LIGHT_SPOT) {
+	       GLfloat PV_dot_dir = - DOT3(VP, light->_NormDirection);
+
+	       if (PV_dot_dir<light->_CosCutoff) {
+		  continue; /* this light makes no contribution */
+	       }
+	       else {
+		  GLdouble x = PV_dot_dir * (EXP_TABLE_SIZE-1);
+		  GLint k = (GLint) x;
+		  GLfloat spot = (GLfloat) (light->_SpotExpTable[k][0]
+				  + (x-k)*light->_SpotExpTable[k][1]);
+		  attenuation *= spot;
+	       }
+	    }
+	 }
+
+	 if (attenuation < 1e-3)
+	    continue;		/* this light makes no contribution */
+
+	 /* Compute dot product or normal and vector from V to light pos */
+	 n_dot_VP = DOT3( normal, VP );
+
+	 /* which side are we lighting? */
+	 if (n_dot_VP < 0.0F) {
+	    ACC_SCALE_SCALAR_3V(sum[0], attenuation, light->_MatAmbient[0]);
+
+	    if (!(IDX & LIGHT_TWOSIDE))
+	       continue;
+
+	    side = 1;
+	    correction = -1;
+	    n_dot_VP = -n_dot_VP;
+	 }
+         else {
+	    if (IDX & LIGHT_TWOSIDE) {
+	       ACC_SCALE_SCALAR_3V( sum[1], attenuation, light->_MatAmbient[1]);
+	    }
+	    side = 0;
+	    correction = 1;
+	 }
+
+	 COPY_3V(contrib, light->_MatAmbient[side]);
+
+	 /* diffuse term */
+	 ACC_SCALE_SCALAR_3V(contrib, n_dot_VP, light->_MatDiffuse[side]);
+
+	 /* specular term - cannibalize VP... */
+	 {
+	    if (ctx->Light.Model.LocalViewer) {
+	       GLfloat v[3];
+	       COPY_3V(v, vertex);
+	       NORMALIZE_3FV(v);
+	       SUB_3V(VP, VP, v);                /* h = VP + VPe */
+	       h = VP;
+	       NORMALIZE_3FV(h);
+	    }
+	    else if (light->_Flags & LIGHT_POSITIONAL) {
+	       h = VP;
+	       ACC_3V(h, ctx->_EyeZDir);
+	       NORMALIZE_3FV(h);
+	    }
+            else {
+	       h = light->_h_inf_norm;
+	    }
+
+	    n_dot_h = correction * DOT3(normal, h);
+
+	    if (n_dot_h > 0.0F)
+	    {
+	       GLfloat spec_coef;
+	       struct gl_shine_tab *tab = ctx->_ShineTable[side];
+
+	       GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec_coef );
+
+	       ACC_SCALE_SCALAR_3V( contrib, spec_coef,
+				    light->_MatSpecular[side]);
+	    }
+	 }
+
+	 ACC_SCALE_SCALAR_3V( sum[side], attenuation, contrib );
+      }
+
+      UNCLAMPED_FLOAT_TO_RGB_CHAN( Fcolor[j], sum[0] );
+      Fcolor[j][3] = sumA[0];
+
+      if (IDX & LIGHT_TWOSIDE) {
+	 UNCLAMPED_FLOAT_TO_RGB_CHAN( Bcolor[j], sum[1] );
+	 Bcolor[j][3] = sumA[1];
+      }
+   }
+}
+
+
+
+
+/* As below, but with just a single light.
+ */
+static void TAG(light_fast_rgba_single)( GLcontext *ctx,
+					 struct vertex_buffer *VB,
+					 struct gl_pipeline_stage *stage,
+					 GLvector4f *input )
+
+{
+   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
+   GLuint  nstride = VB->NormalPtr->stride;
+   const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
+   GLfloat *CMcolor;
+   GLuint CMstride;
+   GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].Ptr;
+   GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].Ptr;
+   struct gl_light *light = ctx->Light.EnabledList.next;
+   GLuint *flags = VB->Flag;
+   GLchan basechan[2][4];
+   GLuint j = 0;
+   struct gl_material (*new_material)[2] = VB->Material;
+   GLuint *new_material_mask = VB->MaterialMask;
+   GLfloat base[2][3];
+   GLuint nr = VB->Count;
+
+   if (MESA_VERBOSE & VERBOSE_LIGHTING)
+      fprintf(stderr, "%s\n", __FUNCTION__ );   
+
+   (void) input;		/* doesn't refer to Eye or Obj */
+   (void) flags;
+   (void) nr;
+   (void) nstride;
+
+   if (IDX & LIGHT_COLORMATERIAL) {
+      if (VB->ColorPtr[0]->Type != GL_FLOAT || 
+	  VB->ColorPtr[0]->Size != 4)
+	 import_color_material( ctx, stage );
+
+      CMcolor = (GLfloat *)VB->ColorPtr[0]->Ptr;
+      CMstride = VB->ColorPtr[0]->StrideB;
+   }
+
+   VB->ColorPtr[0] = &store->LitColor[0];
+   if (IDX & LIGHT_TWOSIDE)
+      VB->ColorPtr[1] = &store->LitColor[1];
+
+   if (stage->changed_inputs == 0)
+      return;
+
+   do {
+      
+      if ( CHECK_COLOR_MATERIAL(j) ) {
+	 _mesa_update_color_material( ctx, CMcolor );
+      }
+
+      if ( CHECK_MATERIAL(j) )
+	 _mesa_update_material( ctx, new_material[j], new_material_mask[j] );
+
+      if ( CHECK_VALIDATE(j) )
+	 TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+
+
+      /* No attenuation, so incoporate _MatAmbient into base color.
+       */
+      COPY_3V(base[0], light->_MatAmbient[0]);
+      ACC_3V(base[0], ctx->Light._BaseColor[0] );
+      UNCLAMPED_FLOAT_TO_RGB_CHAN( basechan[0], base[0] );
+      UNCLAMPED_FLOAT_TO_CHAN(basechan[0][3], 
+			      ctx->Light.Material[0].Diffuse[3]);
+
+      if (IDX & LIGHT_TWOSIDE) {
+	 COPY_3V(base[1], light->_MatAmbient[1]);
+	 ACC_3V(base[1], ctx->Light._BaseColor[1]);
+	 UNCLAMPED_FLOAT_TO_RGB_CHAN( basechan[1], base[1]);
+	 UNCLAMPED_FLOAT_TO_CHAN(basechan[1][3], 
+				 ctx->Light.Material[1].Diffuse[3]);
+      }
+
+      do {
+	 GLfloat n_dot_VP = DOT3(normal, light->_VP_inf_norm);
+
+	 if (n_dot_VP < 0.0F) {
+	    if (IDX & LIGHT_TWOSIDE) {
+	       GLfloat n_dot_h = -DOT3(normal, light->_h_inf_norm);
+	       GLfloat sum[3];
+	       COPY_3V(sum, base[1]);
+	       ACC_SCALE_SCALAR_3V(sum, -n_dot_VP, light->_MatDiffuse[1]);
+	       if (n_dot_h > 0.0F) {
+		  GLfloat spec;
+		  GET_SHINE_TAB_ENTRY( ctx->_ShineTable[1], n_dot_h, spec );
+		  ACC_SCALE_SCALAR_3V(sum, spec, light->_MatSpecular[1]);
+	       }
+	       UNCLAMPED_FLOAT_TO_RGB_CHAN(Bcolor[j], sum );
+	       Bcolor[j][3] = basechan[1][3];
+	    }
+	    COPY_CHAN4(Fcolor[j], basechan[0]);
+	 } else {
+	    GLfloat n_dot_h = DOT3(normal, light->_h_inf_norm);
+	    GLfloat sum[3];
+	    COPY_3V(sum, base[0]);
+	    ACC_SCALE_SCALAR_3V(sum, n_dot_VP, light->_MatDiffuse[0]);
+	    if (n_dot_h > 0.0F) {
+	       GLfloat spec;
+	       GET_SHINE_TAB_ENTRY( ctx->_ShineTable[0], n_dot_h, spec );
+	       ACC_SCALE_SCALAR_3V(sum, spec, light->_MatSpecular[0]);
+
+	    }
+	    UNCLAMPED_FLOAT_TO_RGB_CHAN(Fcolor[j], sum );
+	    Fcolor[j][3] = basechan[0][3];
+	    if (IDX & LIGHT_TWOSIDE) COPY_CHAN4(Bcolor[j], basechan[1]);
+	 }
+
+	 j++;
+	 CMSTRIDE;
+	 STRIDE_F(normal, NSTRIDE);
+      } while (DO_ANOTHER_NORMAL(j));
+
+
+      for ( ; REUSE_LIGHT_RESULTS(j) ; j++, CMSTRIDE, STRIDE_F(normal,NSTRIDE))
+      {
+	 COPY_CHAN4(Fcolor[j], Fcolor[j-1]);
+	 if (IDX & LIGHT_TWOSIDE)
+	    COPY_CHAN4(Bcolor[j], Bcolor[j-1]);
+      }
+
+   } while (!CHECK_END_VB(j));
+}
+
+
+/* Light infinite lights
+ */
+static void TAG(light_fast_rgba)( GLcontext *ctx,
+				  struct vertex_buffer *VB,
+				  struct gl_pipeline_stage *stage,
+				  GLvector4f *input )
+{
+   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
+   GLchan sumA[2];
+   GLuint  nstride = VB->NormalPtr->stride;
+   const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
+   GLfloat *CMcolor;
+   GLuint CMstride;
+   GLchan (*Fcolor)[4] = (GLchan (*)[4]) store->LitColor[0].Ptr;
+   GLchan (*Bcolor)[4] = (GLchan (*)[4]) store->LitColor[1].Ptr;
+   GLuint *flags = VB->Flag;
+   GLuint j = 0;
+   struct gl_material (*new_material)[2] = VB->Material;
+   GLuint *new_material_mask = VB->MaterialMask;
+   GLuint nr = VB->Count;
+   struct gl_light *light;
+
+   if (MESA_VERBOSE & VERBOSE_LIGHTING)
+      fprintf(stderr, "%s\n", __FUNCTION__ );   
+
+
+   (void) flags;
+   (void) input;
+   (void) nr;
+   (void) nstride;
+
+   UNCLAMPED_FLOAT_TO_CHAN(sumA[0], ctx->Light.Material[0].Diffuse[3]);
+   UNCLAMPED_FLOAT_TO_CHAN(sumA[1], ctx->Light.Material[1].Diffuse[3]);
+
+   if (IDX & LIGHT_COLORMATERIAL) {
+      if (VB->ColorPtr[0]->Type != GL_FLOAT || 
+	  VB->ColorPtr[0]->Size != 4)
+	 import_color_material( ctx, stage );
+
+      CMcolor = (GLfloat *)VB->ColorPtr[0]->Ptr;
+      CMstride = VB->ColorPtr[0]->StrideB;
+   }
+
+   VB->ColorPtr[0] = &store->LitColor[0];
+   if (IDX & LIGHT_TWOSIDE)
+      VB->ColorPtr[1] = &store->LitColor[1];
+
+   if (stage->changed_inputs == 0)
+      return;
+
+   do {
+      do {
+	 GLfloat sum[2][3];
+
+	 if ( CHECK_COLOR_MATERIAL(j) )
+	    _mesa_update_color_material( ctx, CMcolor );
+
+	 if ( CHECK_MATERIAL(j) )
+	    _mesa_update_material( ctx, new_material[j], new_material_mask[j] );
+
+	 if ( CHECK_VALIDATE(j) ) {
+	    TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+	    UNCLAMPED_FLOAT_TO_CHAN(sumA[0], ctx->Light.Material[0].Diffuse[3]);
+	    if (IDX & LIGHT_TWOSIDE)
+	       UNCLAMPED_FLOAT_TO_CHAN(sumA[1], 
+				       ctx->Light.Material[1].Diffuse[3]);
+	 }
+
+
+	 COPY_3V(sum[0], ctx->Light._BaseColor[0]);
+	 if (IDX & LIGHT_TWOSIDE)
+	    COPY_3V(sum[1], ctx->Light._BaseColor[1]);
+
+	 foreach (light, &ctx->Light.EnabledList) {
+	    GLfloat n_dot_h, n_dot_VP, spec;
+
+	    ACC_3V(sum[0], light->_MatAmbient[0]);
+	    if (IDX & LIGHT_TWOSIDE)
+	       ACC_3V(sum[1], light->_MatAmbient[1]);
+
+	    n_dot_VP = DOT3(normal, light->_VP_inf_norm);
+
+	    if (n_dot_VP > 0.0F) {
+	       ACC_SCALE_SCALAR_3V(sum[0], n_dot_VP, light->_MatDiffuse[0]);
+	       n_dot_h = DOT3(normal, light->_h_inf_norm);
+	       if (n_dot_h > 0.0F) {
+		  struct gl_shine_tab *tab = ctx->_ShineTable[0];
+		  GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec );
+		  ACC_SCALE_SCALAR_3V( sum[0], spec,
+				       light->_MatSpecular[0]);
+	       }
+	    }
+	    else if (IDX & LIGHT_TWOSIDE) {
+	       ACC_SCALE_SCALAR_3V(sum[1], -n_dot_VP, light->_MatDiffuse[1]);
+	       n_dot_h = -DOT3(normal, light->_h_inf_norm);
+	       if (n_dot_h > 0.0F) {
+		  struct gl_shine_tab *tab = ctx->_ShineTable[1];
+		  GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec );
+		  ACC_SCALE_SCALAR_3V( sum[1], spec,
+				       light->_MatSpecular[1]);
+	       }
+	    }
+	 }
+
+	 UNCLAMPED_FLOAT_TO_RGB_CHAN( Fcolor[j], sum[0] );
+	 Fcolor[j][3] = sumA[0];
+
+	 if (IDX & LIGHT_TWOSIDE) {
+	    UNCLAMPED_FLOAT_TO_RGB_CHAN( Bcolor[j], sum[1] );
+	    Bcolor[j][3] = sumA[1];
+	 }
+
+	 j++;
+	 CMSTRIDE;
+	 STRIDE_F(normal, NSTRIDE);
+      } while (DO_ANOTHER_NORMAL(j));
+
+      /* Reuse the shading results while there is no change to
+       * normal or material values.
+       */
+      for ( ; REUSE_LIGHT_RESULTS(j) ; j++, CMSTRIDE, STRIDE_F(normal, NSTRIDE))
+      {
+	 COPY_CHAN4(Fcolor[j], Fcolor[j-1]);
+	 if (IDX & LIGHT_TWOSIDE)
+	    COPY_CHAN4(Bcolor[j], Bcolor[j-1]);
+      }
+
+   } while (!CHECK_END_VB(j));
+}
+
+
+
+
+
+/*
+ * Use current lighting/material settings to compute the color indexes
+ * for an array of vertices.
+ * Input:  n - number of vertices to light
+ *         side - 0=use front material, 1=use back material
+ *         vertex - array of [n] vertex position in eye coordinates
+ *         normal - array of [n] surface normal vector
+ * Output:  indexResult - resulting array of [n] color indexes
+ */
+static void TAG(light_ci)( GLcontext *ctx,
+			   struct vertex_buffer *VB,
+			   struct gl_pipeline_stage *stage,
+			   GLvector4f *input )
+{
+   struct light_stage_data *store = LIGHT_STAGE_DATA(stage);
+   GLuint j;
+   GLuint vstride = input->stride;
+   const GLfloat *vertex = (GLfloat *) input->data;
+   GLuint nstride = VB->NormalPtr->stride;
+   const GLfloat *normal = (GLfloat *)VB->NormalPtr->data;
+   GLfloat *CMcolor;
+   GLuint CMstride;
+   GLuint *flags = VB->Flag;
+   GLuint *indexResult[2];
+   struct gl_material (*new_material)[2] = VB->Material;
+   GLuint *new_material_mask = VB->MaterialMask;
+   GLuint nr = VB->Count;
+
+   if (MESA_VERBOSE & VERBOSE_LIGHTING)
+      fprintf(stderr, "%s\n", __FUNCTION__ );   
+
+   (void) flags;
+   (void) nstride;
+   (void) vstride;
+
+   VB->IndexPtr[0] = &store->LitIndex[0];
+   if (IDX & LIGHT_TWOSIDE)
+      VB->IndexPtr[1] = &store->LitIndex[1];
+
+   if (stage->changed_inputs == 0)
+      return;
+
+   indexResult[0] = VB->IndexPtr[0]->data;
+   if (IDX & LIGHT_TWOSIDE)
+      indexResult[1] = VB->IndexPtr[1]->data;
+
+   if (IDX & LIGHT_COLORMATERIAL) {
+      if (VB->ColorPtr[0]->Type != GL_FLOAT || 
+	  VB->ColorPtr[0]->Size != 4)
+	 import_color_material( ctx, stage );
+
+      CMcolor = (GLfloat *)VB->ColorPtr[0]->Ptr;
+      CMstride = VB->ColorPtr[0]->StrideB;
+   }
+
+   /* loop over vertices */
+   for ( j=0 ;
+	 j<nr ;
+	 j++,STRIDE_F(vertex,VSTRIDE),STRIDE_F(normal, NSTRIDE), CMSTRIDE)
+   {
+      GLfloat diffuse[2], specular[2];
+      GLuint side = 0;
+      struct gl_light *light;
+
+      if ( CHECK_COLOR_MATERIAL(j) )
+	 _mesa_update_color_material( ctx, CMcolor );
+
+      if ( CHECK_MATERIAL(j) )
+	 _mesa_update_material( ctx, new_material[j], new_material_mask[j] );
+
+      if ( CHECK_VALIDATE(j) )
+	 TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange( ctx );
+
+      diffuse[0] = specular[0] = 0.0F;
+
+      if ( IDX & LIGHT_TWOSIDE ) {
+	 diffuse[1] = specular[1] = 0.0F;
+      }
+
+      /* Accumulate diffuse and specular from each light source */
+      foreach (light, &ctx->Light.EnabledList) {
+
+	 GLfloat attenuation = 1.0F;
+	 GLfloat VP[3];  /* unit vector from vertex to light */
+	 GLfloat n_dot_VP;  /* dot product of l and n */
+	 GLfloat *h, n_dot_h, correction = 1.0;
+
+	 /* compute l and attenuation */
+	 if (!(light->_Flags & LIGHT_POSITIONAL)) {
+	    /* directional light */
+	    COPY_3V(VP, light->_VP_inf_norm);
+	 }
+	 else {
+	    GLfloat d;     /* distance from vertex to light */
+
+	    SUB_3V(VP, light->_Position, vertex);
+
+	    d = (GLfloat) LEN_3FV( VP );
+	    if ( d > 1e-6) {
+	       GLfloat invd = 1.0F / d;
+	       SELF_SCALE_SCALAR_3V(VP, invd);
+	    }
+
+	    attenuation = 1.0F / (light->ConstantAttenuation + d *
+				  (light->LinearAttenuation + d *
+				   light->QuadraticAttenuation));
+
+	    /* spotlight attenuation */
+	    if (light->_Flags & LIGHT_SPOT) {
+	       GLfloat PV_dot_dir = - DOT3(VP, light->_NormDirection);
+	       if (PV_dot_dir < light->_CosCutoff) {
+		  continue; /* this light makes no contribution */
+	       }
+	       else {
+		  GLdouble x = PV_dot_dir * (EXP_TABLE_SIZE-1);
+		  GLint k = (GLint) x;
+		  GLfloat spot = (GLfloat) (light->_SpotExpTable[k][0]
+				  + (x-k)*light->_SpotExpTable[k][1]);
+		  attenuation *= spot;
+	       }
+	    }
+	 }
+
+	 if (attenuation < 1e-3)
+	    continue;		/* this light makes no contribution */
+
+	 n_dot_VP = DOT3( normal, VP );
+
+	 /* which side are we lighting? */
+	 if (n_dot_VP < 0.0F) {
+	    if (!(IDX & LIGHT_TWOSIDE))
+	       continue;
+	    side = 1;
+	    correction = -1;
+	    n_dot_VP = -n_dot_VP;
+	 }
+
+	 /* accumulate diffuse term */
+	 diffuse[side] += n_dot_VP * light->_dli * attenuation;
+
+	 /* specular term */
+	 if (ctx->Light.Model.LocalViewer) {
+	    GLfloat v[3];
+	    COPY_3V(v, vertex);
+	    NORMALIZE_3FV(v);
+	    SUB_3V(VP, VP, v);                /* h = VP + VPe */
+	    h = VP;
+	    NORMALIZE_3FV(h);
+	 }
+	 else if (light->_Flags & LIGHT_POSITIONAL) {
+	    h = VP;
+            /* Strangely, disabling this addition fixes a conformance
+             * problem.  If this code is enabled, l_sed.c fails.
+             */
+	    /*ACC_3V(h, ctx->_EyeZDir);*/
+	    NORMALIZE_3FV(h);
+	 }
+         else {
+	    h = light->_h_inf_norm;
+	 }
+
+	 n_dot_h = correction * DOT3(normal, h);
+	 if (n_dot_h > 0.0F) {
+	    GLfloat spec_coef;
+	    struct gl_shine_tab *tab = ctx->_ShineTable[side];
+	    GET_SHINE_TAB_ENTRY( tab, n_dot_h, spec_coef);
+	    specular[side] += spec_coef * light->_sli * attenuation;
+	 }
+      } /*loop over lights*/
+
+      /* Now compute final color index */
+      for (side = 0 ; side < NR_SIDES ; side++) {
+	 struct gl_material *mat = &ctx->Light.Material[side];
+	 GLfloat index;
+
+	 if (specular[side] > 1.0F) {
+	    index = mat->SpecularIndex;
+	 }
+	 else {
+	    GLfloat d_a = mat->DiffuseIndex - mat->AmbientIndex;
+	    GLfloat s_a = mat->SpecularIndex - mat->AmbientIndex;
+
+	    index = mat->AmbientIndex
+	       + diffuse[side] * (1.0F-specular[side]) * d_a
+	       + specular[side] * s_a;
+
+	    if (index > mat->SpecularIndex) {
+	       index = mat->SpecularIndex;
+	    }
+	 }
+	 indexResult[side][j] = (GLuint) (GLint) index;
+      }
+   } /*for vertex*/
+}
+
+
+
+static void TAG(init_light_tab)( void )
+{
+   _tnl_light_tab[IDX] = TAG(light_rgba);
+   _tnl_light_fast_tab[IDX] = TAG(light_fast_rgba);
+   _tnl_light_fast_single_tab[IDX] = TAG(light_fast_rgba_single);
+   _tnl_light_spec_tab[IDX] = TAG(light_rgba_spec);
+   _tnl_light_ci_tab[IDX] = TAG(light_ci);
+}
+
+
+#undef TAG
+#undef IDX
+#undef NR_SIDES
+#undef NSTRIDE
+#undef VSTRIDE
+#undef CHECK_MATERIAL
+#undef CHECK_END_VB
+#undef DO_ANOTHER_NORMAL
+#undef REUSE_LIGHT_RESULTS
+#undef CMSTRIDE
+#undef CHECK_COLOR_MATERIAL
+#undef CHECK_VALIDATE
Index: xc/extras/Mesa/src/tnl/t_vb_normals.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_normals.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_normals.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,195 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+
+struct normal_stage_data {
+   normal_func NormalTransform;
+   GLvector3f normal;
+};
+
+#define NORMAL_STAGE_DATA(stage) ((struct normal_stage_data *)stage->privatePtr)
+
+
+
+
+static GLboolean run_normal_stage( GLcontext *ctx,
+				   struct gl_pipeline_stage *stage )
+{
+   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+
+   ASSERT(store->NormalTransform);
+
+   if (stage->changed_inputs) {
+      /* We can only use the display list's saved normal lengths if we've
+       * got a transformation matrix with uniform scaling.
+       */
+      const GLfloat *lengths;
+      if (ctx->ModelView.flags & MAT_FLAG_GENERAL_SCALE)
+         lengths = NULL;
+      else
+         lengths = VB->NormalLengthPtr;
+
+      store->NormalTransform( &ctx->ModelView,
+			      ctx->_ModelViewInvScale,
+			      VB->NormalPtr,
+			      lengths,
+			      &store->normal );
+   }
+
+   VB->NormalPtr = &store->normal;
+   VB->NormalLengthPtr = 0;	/* no longer valid */
+   return GL_TRUE;
+}
+
+
+static GLboolean run_validate_normal_stage( GLcontext *ctx,
+					    struct gl_pipeline_stage *stage )
+{
+   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
+
+   ASSERT(ctx->_NeedNormals);
+
+   if (ctx->_NeedEyeCoords) {
+      GLuint transform = NORM_TRANSFORM_NO_ROT;
+
+      if (ctx->ModelView.flags & (MAT_FLAG_GENERAL |
+				  MAT_FLAG_ROTATION |
+				  MAT_FLAG_GENERAL_3D |
+				  MAT_FLAG_PERSPECTIVE))
+	 transform = NORM_TRANSFORM;
+
+
+      if (ctx->Transform.Normalize) {
+	 store->NormalTransform = _mesa_normal_tab[transform | NORM_NORMALIZE];
+      }
+      else if (ctx->Transform.RescaleNormals &&
+	       ctx->_ModelViewInvScale != 1.0) {
+	 store->NormalTransform = _mesa_normal_tab[transform | NORM_RESCALE];
+      }
+      else {
+	 store->NormalTransform = _mesa_normal_tab[transform];
+      }
+   }
+   else {
+      if (ctx->Transform.Normalize) {
+	 store->NormalTransform = _mesa_normal_tab[NORM_NORMALIZE];
+      }
+      else if (!ctx->Transform.RescaleNormals &&
+	       ctx->_ModelViewInvScale != 1.0) {
+	 store->NormalTransform = _mesa_normal_tab[NORM_RESCALE];
+      }
+      else {
+	 store->NormalTransform = 0;
+      }
+   }
+
+   if (store->NormalTransform) {
+      stage->run = run_normal_stage;
+      return stage->run( ctx, stage );
+   } else {
+      stage->active = GL_FALSE;	/* !!! */
+      return GL_TRUE;
+   }
+}
+
+
+static void check_normal_transform( GLcontext *ctx,
+				    struct gl_pipeline_stage *stage )
+{
+   stage->active = ctx->_NeedNormals;
+   /* Don't clobber the initialize function:
+    */
+   if (stage->privatePtr)
+      stage->run = run_validate_normal_stage;
+}
+
+
+static GLboolean alloc_normal_data( GLcontext *ctx,
+				 struct gl_pipeline_stage *stage )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct normal_stage_data *store;
+   stage->privatePtr = MALLOC(sizeof(*store));
+   store = NORMAL_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector3f_alloc( &store->normal, 0, tnl->vb.Size, 32 );
+
+   /* Now run the stage.
+    */
+   stage->run = run_validate_normal_stage;
+   return stage->run( ctx, stage );
+}
+
+
+
+static void free_normal_data( struct gl_pipeline_stage *stage )
+{
+   struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
+   if (store) {
+      _mesa_vector3f_free( &store->normal );
+      FREE( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+#define _TNL_NEW_NORMAL_TRANSFORM        (_NEW_MODELVIEW| \
+					  _NEW_TRANSFORM| \
+                                          _MESA_NEW_NEED_NORMALS| \
+                                          _MESA_NEW_NEED_EYE_COORDS)
+
+
+
+const struct gl_pipeline_stage _tnl_normal_transform_stage =
+{
+   "normal transform",
+   _TNL_NEW_NORMAL_TRANSFORM,	/* re-check */
+   _TNL_NEW_NORMAL_TRANSFORM,	/* re-run */
+   0,VERT_NORM,VERT_NORM,	/* active, inputs, outputs */
+   0, 0,			/* changed_inputs, private */
+   free_normal_data,		/* destructor */
+   check_normal_transform,	/* check */
+   alloc_normal_data		/* run -- initially set to alloc */
+};
Index: xc/extras/Mesa/src/tnl/t_vb_points.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_points.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_points.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,123 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Brian Paul <brian@valinux.com>
+ */
+
+#include "mtypes.h"
+#include "mem.h"
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+struct point_stage_data {
+   GLvector1f PointSize;
+};
+
+#define POINT_STAGE_DATA(stage) ((struct point_stage_data *)stage->privatePtr)
+
+
+/*
+ * Compute attenuated point sizes
+ */
+static GLboolean run_point_stage( GLcontext *ctx,
+				  struct gl_pipeline_stage *stage )
+{
+   struct point_stage_data *store = POINT_STAGE_DATA(stage);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   const GLfloat (*eye)[4] = (const GLfloat (*)[4]) VB->EyePtr->data;
+   const GLfloat p0 = ctx->Point.Params[0];
+   const GLfloat p1 = ctx->Point.Params[1];
+   const GLfloat p2 = ctx->Point.Params[2];
+   const GLfloat pointSize = ctx->Point._Size;
+   GLfloat *size = store->PointSize.data;
+   GLuint i;
+
+   if (stage->changed_inputs) {
+      /* XXX do threshold and min/max clamping here? */
+      for (i = 0; i < VB->Count; i++) {
+	 const GLfloat dist = -eye[i][2];
+	 /* GLfloat dist = GL_SQRT(pos[0]*pos[0]+pos[1]*pos[1]+pos[2]*pos[2]);*/
+	 size[i] = pointSize / (p0 + dist * (p1 + dist * p2));
+      }
+   }
+
+   VB->PointSizePtr = &store->PointSize;
+
+   return GL_TRUE;
+}
+
+
+/* If point size attenuation is on we'll compute the point size for
+ * each vertex in a special pipeline stage.
+ */
+static void check_point_size( GLcontext *ctx, struct gl_pipeline_stage *d )
+{
+   d->active = ctx->Point._Attenuated;
+}
+
+static GLboolean alloc_point_data( GLcontext *ctx,
+				   struct gl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct point_stage_data *store;
+   stage->privatePtr = MALLOC(sizeof(*store));
+   store = POINT_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector1f_alloc( &store->PointSize, 0, VB->Size, 32 );
+
+   /* Now run the stage.
+    */
+   stage->run = run_point_stage;
+   return stage->run( ctx, stage );
+}
+
+
+static void free_point_data( struct gl_pipeline_stage *stage )
+{
+   struct point_stage_data *store = POINT_STAGE_DATA(stage);
+   if (store) {
+      _mesa_vector1f_free( &store->PointSize );
+      FREE( store );
+      stage->privatePtr = 0;
+   }
+}
+
+const struct gl_pipeline_stage _tnl_point_attenuation_stage =
+{
+   "point size attenuation",	/* name */
+   _NEW_POINT,			/* build_state_change */
+   _NEW_POINT,			/* run_state_change */
+   0,				/* active */
+   VERT_EYE,			/* inputs */
+   VERT_POINT_SIZE,		/* outputs */
+   0,				/* changed_inputs (temporary value) */
+   0,				/* stage private data */
+   free_point_data,		/* destructor */
+   check_point_size,		/* check */
+   alloc_point_data		/* run -- initially set to alloc data */
+};
Index: xc/extras/Mesa/src/tnl/t_vb_render.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_render.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_render.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,423 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.1
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+/*
+ * Render whole vertex buffers, including projection of vertices from
+ * clip space and clipping of primitives.
+ *
+ * This file makes calls to project vertices and to the point, line
+ * and triangle rasterizers via the function pointers:
+ *
+ *    context->Driver.Render.*
+ *
+ */
+
+
+#include "glheader.h"
+#include "context.h"
+#include "enums.h"
+#include "macros.h"
+#include "mem.h"
+#include "mtypes.h"
+#include "mmath.h"
+
+#include "math/m_matrix.h"
+#include "math/m_xform.h"
+
+#include "t_pipeline.h"
+
+
+
+/**********************************************************************/
+/*                        Clip single primitives                      */
+/**********************************************************************/
+
+
+#if defined(USE_IEEE)
+#define NEGATIVE(x) (GET_FLOAT_BITS(x) & (1<<31))
+#define DIFFERENT_SIGNS(x,y) ((GET_FLOAT_BITS(x) ^ GET_FLOAT_BITS(y)) & (1<<31))
+#else
+#define NEGATIVE(x) (x < 0)
+#define DIFFERENT_SIGNS(x,y) (x * y <= 0 && x - y != 0)
+/* Could just use (x*y<0) except for the flatshading requirements.
+ * Maybe there's a better way?
+ */
+#endif
+
+
+#define W(i) coord[i][3]
+#define Z(i) coord[i][2]
+#define Y(i) coord[i][1]
+#define X(i) coord[i][0]
+#define SIZE 4
+#define TAG(x) x##_4
+#include "t_vb_cliptmp.h"
+
+
+
+/**********************************************************************/
+/*              Clip and render whole begin/end objects               */
+/**********************************************************************/
+
+#define NEED_EDGEFLAG_SETUP (ctx->_TriangleCaps & DD_TRI_UNFILLED)
+#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx]
+#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val
+
+
+/* Vertices, with the possibility of clipping.
+ */
+#define RENDER_POINTS( start, count ) \
+   tnl->Driver.Render.Points( ctx, start, count )
+
+#define RENDER_LINE( v1, v2 )			\
+do {						\
+   GLubyte c1 = mask[v1], c2 = mask[v2];	\
+   GLubyte ormask = c1|c2;			\
+   if (!ormask)					\
+      LineFunc( ctx, v1, v2 );			\
+   else if (!(c1 & c2 & 0x3f))			\
+      clip_line_4( ctx, v1, v2, ormask );	\
+} while (0)
+
+#define RENDER_TRI( v1, v2, v3 )			\
+do {							\
+   GLubyte c1 = mask[v1], c2 = mask[v2], c3 = mask[v3];	\
+   GLubyte ormask = c1|c2|c3;				\
+   if (!ormask)						\
+      TriangleFunc( ctx, v1, v2, v3 );			\
+   else if (!(c1 & c2 & c3 & 0x3f)) 			\
+      clip_tri_4( ctx, v1, v2, v3, ormask );    	\
+} while (0)
+
+#define RENDER_QUAD( v1, v2, v3, v4 )			\
+do {							\
+   GLubyte c1 = mask[v1], c2 = mask[v2];		\
+   GLubyte c3 = mask[v3], c4 = mask[v4];		\
+   GLubyte ormask = c1|c2|c3|c4;			\
+   if (!ormask)						\
+      QuadFunc( ctx, v1, v2, v3, v4 );			\
+   else if (!(c1 & c2 & c3 & c4 & 0x3f)) 		\
+      clip_quad_4( ctx, v1, v2, v3, v4, ormask );	\
+} while (0)
+
+
+#define LOCAL_VARS						\
+   TNLcontext *tnl = TNL_CONTEXT(ctx);				\
+   struct vertex_buffer *VB = &tnl->vb;				\
+   const GLuint * const elt = VB->Elts;				\
+   const GLubyte *mask = VB->ClipMask;				\
+   const GLuint sz = VB->ClipPtr->size;				\
+   const line_func LineFunc = tnl->Driver.Render.Line;		\
+   const triangle_func TriangleFunc = tnl->Driver.Render.Triangle;	\
+   const quad_func QuadFunc = tnl->Driver.Render.Quad;		\
+   const GLboolean stipple = ctx->Line.StippleFlag;		\
+   (void) (LineFunc && TriangleFunc && QuadFunc);		\
+   (void) elt; (void) mask; (void) sz; (void) stipple;
+
+#define TAG(x) clip_##x##_verts
+#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x )
+#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx )
+#define RESET_OCCLUSION ctx->OcclusionResult = GL_TRUE
+#define PRESERVE_VB_DEFS
+#include "t_vb_rendertmp.h"
+
+
+
+/* Elts, with the possibility of clipping.
+ */
+#undef ELT
+#undef TAG
+#define ELT(x) elt[x]
+#define TAG(x) clip_##x##_elts
+#include "t_vb_rendertmp.h"
+
+/* TODO: do this for all primitives, verts and elts:
+ */
+static void clip_elt_triangles( GLcontext *ctx,
+				GLuint start,
+				GLuint count,
+				GLuint flags )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   render_func render_tris = tnl->Driver.Render.PrimTabElts[GL_TRIANGLES];
+   struct vertex_buffer *VB = &tnl->vb;
+   const GLuint * const elt = VB->Elts;
+   GLubyte *mask = VB->ClipMask;
+   GLuint last = count-2;
+   GLuint j;
+   (void) flags;
+
+   tnl->Driver.Render.PrimitiveNotify( ctx, GL_TRIANGLES );
+
+   for (j=start; j < last; j+=3 ) {
+      GLubyte c1 = mask[elt[j]];
+      GLubyte c2 = mask[elt[j+1]];
+      GLubyte c3 = mask[elt[j+2]];
+      GLubyte ormask = c1|c2|c3;
+      if (ormask) {
+	 if (start < j)
+	    render_tris( ctx, start, j, 0 );
+	 if (!(c1&c2&c3&0x3f))
+	    clip_tri_4( ctx, elt[j], elt[j+1], elt[j+2], ormask );
+	 start = j+3;
+      }
+   }
+
+   if (start < j)
+      render_tris( ctx, start, j, 0 );
+}
+
+/**********************************************************************/
+/*                  Render whole begin/end objects                    */
+/**********************************************************************/
+
+#define NEED_EDGEFLAG_SETUP (ctx->_TriangleCaps & DD_TRI_UNFILLED)
+#define EDGEFLAG_GET(idx) VB->EdgeFlag[idx]
+#define EDGEFLAG_SET(idx, val) VB->EdgeFlag[idx] = val
+
+
+/* Vertices, no clipping.
+ */
+#define RENDER_POINTS( start, count ) \
+   tnl->Driver.Render.Points( ctx, start, count )
+
+#define RENDER_LINE( v1, v2 ) \
+   LineFunc( ctx, v1, v2 )
+
+#define RENDER_TRI( v1, v2, v3 ) \
+   TriangleFunc( ctx, v1, v2, v3 )
+
+#define RENDER_QUAD( v1, v2, v3, v4 ) \
+   QuadFunc( ctx, v1, v2, v3, v4 )
+
+#define TAG(x) _tnl_##x##_verts
+
+#define LOCAL_VARS						\
+   TNLcontext *tnl = TNL_CONTEXT(ctx);				\
+   struct vertex_buffer *VB = &tnl->vb;				\
+   const GLuint * const elt = VB->Elts;				\
+   const line_func LineFunc = tnl->Driver.Render.Line;		\
+   const triangle_func TriangleFunc = tnl->Driver.Render.Triangle;	\
+   const quad_func QuadFunc = tnl->Driver.Render.Quad;		\
+   const GLboolean stipple = ctx->Line.StippleFlag;		\
+   (void) (LineFunc && TriangleFunc && QuadFunc);		\
+   (void) elt; (void) stipple;
+
+#define RESET_STIPPLE if (stipple) tnl->Driver.Render.ResetLineStipple( ctx )
+#define RESET_OCCLUSION ctx->OcclusionResult = GL_TRUE
+#define INIT(x) tnl->Driver.Render.PrimitiveNotify( ctx, x )
+#define RENDER_TAB_QUALIFIER
+#define PRESERVE_VB_DEFS
+#include "t_vb_rendertmp.h"
+
+
+/* Elts, no clipping.
+ */
+#undef ELT
+#define TAG(x) _tnl_##x##_elts
+#define ELT(x) elt[x]
+#include "t_vb_rendertmp.h"
+
+
+/**********************************************************************/
+/*              Helper functions for drivers                  */
+/**********************************************************************/
+
+void _tnl_RenderClippedPolygon( GLcontext *ctx, const GLuint *elts, GLuint n )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint *tmp = VB->Elts;
+
+   VB->Elts = (GLuint *)elts;
+   tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n, PRIM_BEGIN|PRIM_END );
+   VB->Elts = tmp;
+}
+
+void _tnl_RenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   tnl->Driver.Render.Line( ctx, ii, jj );
+}
+
+
+
+/**********************************************************************/
+/*              Clip and render whole vertex buffers                  */
+/**********************************************************************/
+
+
+static GLboolean run_render( GLcontext *ctx,
+			     struct gl_pipeline_stage *stage )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLuint new_inputs = stage->changed_inputs;
+   render_func *tab;
+   GLint pass = 0;
+
+
+   /* Allow the drivers to lock before projected verts are built so
+    * that window coordinates are guarenteed not to change before
+    * rendering.
+    */
+   ASSERT(tnl->Driver.Render.Start);
+
+   tnl->Driver.Render.Start( ctx );
+
+   ASSERT(tnl->Driver.Render.BuildVertices);
+   ASSERT(tnl->Driver.Render.PrimitiveNotify);
+   ASSERT(tnl->Driver.Render.Points);
+   ASSERT(tnl->Driver.Render.Line);
+   ASSERT(tnl->Driver.Render.Triangle);
+   ASSERT(tnl->Driver.Render.Quad);
+   ASSERT(tnl->Driver.Render.ResetLineStipple);
+   ASSERT(tnl->Driver.Render.Interp);
+   ASSERT(tnl->Driver.Render.CopyPV);
+   ASSERT(tnl->Driver.Render.ClippedLine);
+   ASSERT(tnl->Driver.Render.ClippedPolygon);
+   ASSERT(tnl->Driver.Render.Finish);
+
+   tnl->Driver.Render.BuildVertices( ctx, 0, VB->Count, new_inputs );
+
+   if (VB->ClipOrMask) {
+      tab = VB->Elts ? clip_render_tab_elts : clip_render_tab_verts;
+      clip_render_tab_elts[GL_TRIANGLES] = clip_elt_triangles;
+   }
+   else {
+      tab = (VB->Elts ? 
+	     tnl->Driver.Render.PrimTabElts : 
+	     tnl->Driver.Render.PrimTabVerts);
+   }
+
+   do
+   {
+      GLuint i, length, flags = 0;
+      for (i = VB->FirstPrimitive ; !(flags & PRIM_LAST) ; i += length)
+      {
+	 flags = VB->Primitive[i];
+	 length= VB->PrimitiveLength[i];
+	 ASSERT(length || (flags & PRIM_LAST));
+	 ASSERT((flags & PRIM_MODE_MASK) <= GL_POLYGON+1);
+
+	 if (MESA_VERBOSE & VERBOSE_PRIMS)
+	    fprintf(stderr, "MESA prim %s %d..%d\n", 
+		    _mesa_lookup_enum_by_nr(flags & PRIM_MODE_MASK), 
+		    i, i+length);
+
+	 if (length)
+	    tab[flags & PRIM_MODE_MASK]( ctx, i, i + length, flags );
+      }
+   } while (tnl->Driver.Render.Multipass &&
+	    tnl->Driver.Render.Multipass( ctx, ++pass ));
+
+
+   tnl->Driver.Render.Finish( ctx );
+/*     _swrast_flush(ctx); */
+/*     usleep(1000000); */
+   return GL_FALSE;		/* finished the pipe */
+}
+
+
+/**********************************************************************/
+/*                          Render pipeline stage                     */
+/**********************************************************************/
+
+
+
+/* Quite a bit of work involved in finding out the inputs for the
+ * render stage.
+ */
+static void check_render( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   GLuint inputs = VERT_CLIP;
+   GLuint i;
+
+   if (ctx->Visual.rgbMode) {
+      inputs |= VERT_RGBA;
+
+      if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
+	 inputs |= VERT_SPEC_RGB;
+
+      if (ctx->Texture._ReallyEnabled) {
+	 for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
+	    if (ctx->Texture.Unit[i]._ReallyEnabled)
+	       inputs |= VERT_TEX(i);
+	 }
+      }
+   }
+   else {
+      inputs |= VERT_INDEX;
+   }
+
+   if (ctx->Point._Attenuated)
+      inputs |= VERT_POINT_SIZE;
+
+   /* How do drivers turn this off?
+    */
+   if (ctx->Fog.Enabled)
+      inputs |= VERT_FOG_COORD;
+
+   if (ctx->_TriangleCaps & DD_TRI_UNFILLED)
+      inputs |= VERT_EDGE;
+
+   if (ctx->RenderMode==GL_FEEDBACK)
+      inputs |= VERT_TEX_ANY;
+
+   stage->inputs = inputs;
+}
+
+
+
+
+static void dtr( struct gl_pipeline_stage *stage )
+{
+}
+
+
+const struct gl_pipeline_stage _tnl_render_stage =
+{
+   "render",
+   (_NEW_BUFFERS |
+    _DD_NEW_SEPARATE_SPECULAR |
+    _DD_NEW_FLATSHADE |
+    _NEW_TEXTURE|
+    _NEW_LIGHT|
+    _NEW_POINT|
+    _NEW_FOG|
+    _DD_NEW_TRI_UNFILLED |
+    _NEW_RENDERMODE),		/* re-check (new inputs, interp function) */
+   0,				/* re-run (always runs) */
+   GL_TRUE,			/* active */
+   0, 0,			/* inputs (set in check_render), outputs */
+   0, 0,			/* changed_inputs, private */
+   dtr,				/* destructor */
+   check_render,		/* check */
+   run_render			/* run */
+};
Index: xc/extras/Mesa/src/tnl/t_vb_rendertmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_rendertmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_rendertmp.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,444 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#ifndef POSTFIX
+#define POSTFIX
+#endif
+
+#ifndef INIT
+#define INIT(x)
+#endif
+
+#ifndef NEED_EDGEFLAG_SETUP
+#define NEED_EDGEFLAG_SETUP 0
+#define EDGEFLAG_GET(a) 0
+#define EDGEFLAG_SET(a,b) (void)b
+#endif
+
+#ifndef RESET_STIPPLE
+#define RESET_STIPPLE
+#endif
+
+#ifndef RESET_OCCLUSION
+#define RESET_OCCLUSION
+#endif
+
+#ifndef TEST_PRIM_END
+#define TEST_PRIM_END(flags) (flags & PRIM_END)
+#define TEST_PRIM_BEGIN(flags) (flags & PRIM_BEGIN)
+#define TEST_PRIM_PARITY(flags) (flags & PRIM_PARITY)
+#endif
+
+#ifndef ELT
+#define ELT(x) x
+#endif
+
+#ifndef RENDER_TAB_QUALIFIER
+#define RENDER_TAB_QUALIFIER static
+#endif
+
+static void TAG(render_points)( GLcontext *ctx,
+				GLuint start,
+				GLuint count,
+				GLuint flags )
+{
+   LOCAL_VARS;
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_POINTS);
+   RENDER_POINTS( start, count );
+   POSTFIX;
+}
+
+static void TAG(render_lines)( GLcontext *ctx,
+			       GLuint start,
+			       GLuint count,
+			       GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_LINES);
+   for (j=start+1; j<count; j+=2 ) {
+      RESET_STIPPLE;
+      RENDER_LINE( ELT(j-1), ELT(j) );
+   }
+   POSTFIX;
+}
+
+
+static void TAG(render_line_strip)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_LINE_STRIP);
+
+   if (TEST_PRIM_BEGIN(flags)) {
+      RESET_STIPPLE;
+   }
+
+   for (j=start+1; j<count; j++ )
+      RENDER_LINE( ELT(j-1), ELT(j) );
+
+   POSTFIX;
+}
+
+
+static void TAG(render_line_loop)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint i;
+   LOCAL_VARS;
+
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_LINE_LOOP);
+
+   if (start+1 < count) {
+      if (TEST_PRIM_BEGIN(flags)) {
+	 RESET_STIPPLE;
+	 RENDER_LINE( ELT(start), ELT(start+1) );
+      }
+
+      for ( i = start+2 ; i < count ; i++) {
+	 RENDER_LINE( ELT(i-1), ELT(i) );
+      }
+
+      if ( TEST_PRIM_END(flags)) {
+	 RENDER_LINE( ELT(count-1), ELT(start) );
+      }
+   }
+
+   POSTFIX;
+}
+
+
+static void TAG(render_triangles)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_TRIANGLES);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2; j<count; j+=3) {
+	 /* Leave the edgeflags as supplied by the user.
+	  */
+	 RESET_STIPPLE;
+	 RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
+      }
+   } else {
+      for (j=start+2; j<count; j+=3) {
+	 RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+
+
+static void TAG(render_tri_strip)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint j;
+   GLuint parity = 0;
+   LOCAL_VARS;
+
+   if (TEST_PRIM_PARITY(flags))
+      parity = 1;
+
+   INIT(GL_TRIANGLE_STRIP);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2;j<count;j++,parity^=1) {
+	 GLuint ej2 = ELT(j-2+parity);
+	 GLuint ej1 = ELT(j-1-parity);
+	 GLuint ej = ELT(j);
+	 GLboolean ef2 = EDGEFLAG_GET( ej2 );
+	 GLboolean ef1 = EDGEFLAG_GET( ej1 );
+	 GLboolean ef = EDGEFLAG_GET( ej );
+	 if (TEST_PRIM_BEGIN(flags)) {
+	    RESET_STIPPLE;
+	 }
+	 EDGEFLAG_SET( ej2, GL_TRUE );
+	 EDGEFLAG_SET( ej1, GL_TRUE );
+	 EDGEFLAG_SET( ej, GL_TRUE );
+	 RENDER_TRI( ej2, ej1, ej );
+	 EDGEFLAG_SET( ej2, ef2 );
+	 EDGEFLAG_SET( ej1, ef1 );
+	 EDGEFLAG_SET( ej, ef );
+      }
+   } else {
+      for (j=start+2; j<count ; j++, parity^=1) {
+	 RENDER_TRI( ELT(j-2+parity), ELT(j-1-parity), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+
+static void TAG(render_tri_fan)( GLcontext *ctx,
+				 GLuint start,
+				 GLuint count,
+				 GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_TRIANGLE_FAN);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2;j<count;j++) {
+	 /* For trifans, all edges are boundary.
+	  */
+	 GLuint ejs = ELT(start);
+	 GLuint ej1 = ELT(j-1);
+	 GLuint ej = ELT(j);
+	 GLboolean efs = EDGEFLAG_GET( ejs );
+	 GLboolean ef1 = EDGEFLAG_GET( ej1 );
+	 GLboolean ef = EDGEFLAG_GET( ej );
+	 if (TEST_PRIM_BEGIN(flags)) {
+	    RESET_STIPPLE;
+	 }
+	 EDGEFLAG_SET( ejs, GL_TRUE );
+	 EDGEFLAG_SET( ej1, GL_TRUE );
+	 EDGEFLAG_SET( ej, GL_TRUE );
+	 RENDER_TRI( ejs, ej1, ej);
+	 EDGEFLAG_SET( ejs, efs );
+	 EDGEFLAG_SET( ej1, ef1 );
+	 EDGEFLAG_SET( ej, ef );
+      }
+   } else {
+      for (j=start+2;j<count;j++) {
+	 RENDER_TRI( ELT(start), ELT(j-1), ELT(j) );
+      }
+   }
+
+   POSTFIX;
+}
+
+
+static void TAG(render_poly)( GLcontext *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+   GLuint j = start+2;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_POLYGON);
+   if (NEED_EDGEFLAG_SETUP) {
+      GLboolean efstart = EDGEFLAG_GET( ELT(start) );
+      GLboolean efcount = EDGEFLAG_GET( ELT(count-1) );
+
+      /* If the primitive does not begin here, the first edge
+       * is non-boundary.
+       */
+      if (!TEST_PRIM_BEGIN(flags))
+	 EDGEFLAG_SET( ELT(start), GL_FALSE );
+      else {
+	 RESET_STIPPLE;
+      }
+
+      /* If the primitive does not end here, the final edge is
+       * non-boundary.
+       */
+      if (!TEST_PRIM_END(flags))
+	 EDGEFLAG_SET( ELT(count-1), GL_FALSE );
+
+      /* Draw the first triangles (possibly zero)
+       */
+      if (j+1<count) {
+	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
+	 EDGEFLAG_SET( ELT(j), GL_FALSE );
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+	 EDGEFLAG_SET( ELT(j), ef );
+	 j++;
+
+	 /* Don't render the first edge again:
+	  */
+	 EDGEFLAG_SET( ELT(start), GL_FALSE );
+
+	 for (;j+1<count;j++) {
+	    GLboolean efj = EDGEFLAG_GET( ELT(j) );
+	    EDGEFLAG_SET( ELT(j), GL_FALSE );
+	    RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+	    EDGEFLAG_SET( ELT(j), efj );
+	 }
+      }
+
+      /* Draw the last or only triangle
+       */
+      if (j < count)
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+
+      /* Restore the first and last edgeflags:
+       */
+      EDGEFLAG_SET( ELT(count-1), efcount );
+      EDGEFLAG_SET( ELT(start), efstart );
+
+   }
+   else {
+      for (j=start+2;j<count;j++) {
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_quads)( GLcontext *ctx,
+			       GLuint start,
+			       GLuint count,
+			       GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_QUADS);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+3; j<count; j+=4) {
+	 /* Use user-specified edgeflags for quads.
+	  */
+	 RESET_STIPPLE;
+	 RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
+      }
+   } else {
+      for (j=start+3; j<count; j+=4) {
+	 RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_quad_strip)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_QUAD_STRIP);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+3;j<count;j+=2) {
+	 /* All edges are boundary.  Set edgeflags to 1, draw the
+	  * quad, and restore them to the original values.
+	  */
+	 GLboolean ef3 = EDGEFLAG_GET( ELT(j-3) );
+	 GLboolean ef2 = EDGEFLAG_GET( ELT(j-2) );
+	 GLboolean ef1 = EDGEFLAG_GET( ELT(j-1) );
+	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
+	 if (TEST_PRIM_BEGIN(flags)) {
+	    RESET_STIPPLE;
+	 }
+	 EDGEFLAG_SET( ELT(j-3), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j-2), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j-1), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j), GL_TRUE );
+	 RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
+	 EDGEFLAG_SET( ELT(j-3), ef3 );
+	 EDGEFLAG_SET( ELT(j-2), ef2 );
+	 EDGEFLAG_SET( ELT(j-1), ef1 );
+	 EDGEFLAG_SET( ELT(j), ef );
+      }
+   } else {
+      for (j=start+3;j<count;j+=2) {
+	 RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_noop)( GLcontext *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+   (void)(ctx && start && count && flags);
+}
+
+RENDER_TAB_QUALIFIER void (*TAG(render_tab)[GL_POLYGON+2])(GLcontext *,
+							   GLuint,
+							   GLuint,
+							   GLuint) =
+{
+   TAG(render_points),
+   TAG(render_lines),
+   TAG(render_line_loop),
+   TAG(render_line_strip),
+   TAG(render_triangles),
+   TAG(render_tri_strip),
+   TAG(render_tri_fan),
+   TAG(render_quads),
+   TAG(render_quad_strip),
+   TAG(render_poly),
+   TAG(render_noop),
+};
+
+
+
+#ifndef PRESERVE_VB_DEFS
+#undef RENDER_TRI
+#undef RENDER_QUAD
+#undef RENDER_LINE
+#undef RENDER_POINTS
+#undef LOCAL_VARS
+#undef INIT
+#undef POSTFIX
+#undef RESET_STIPPLE
+#undef DBG
+#undef ELT
+#undef RENDER_TAB_QUALIFIER
+#endif
+
+#ifndef PRESERVE_TAG
+#undef TAG
+#endif
+
+#undef PRESERVE_VB_DEFS
+#undef PRESERVE_TAG
Index: xc/extras/Mesa/src/tnl/t_vb_texgen.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_texgen.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_texgen.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,688 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Brian Paul <brian@valinux.com>
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mmath.h"
+#include "mem.h"
+#include "mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+/***********************************************************************
+ * Automatic texture coordinate generation (texgen) code.
+ */
+
+
+struct texgen_stage_data;
+
+typedef void (*texgen_func)( GLcontext *ctx,
+			     struct texgen_stage_data *store,
+			     GLuint unit);
+
+
+struct texgen_stage_data {
+
+   /* Per-texunit derived state.
+    */
+   GLuint TexgenSize[MAX_TEXTURE_UNITS];
+   GLuint TexgenHoles[MAX_TEXTURE_UNITS];
+   texgen_func TexgenFunc[MAX_TEXTURE_UNITS];
+
+   /* Temporary values used in texgen.
+    */
+   GLfloat (*tmp_f)[3];
+   GLfloat *tmp_m;
+
+   /* Buffered outputs of the stage.
+    */
+   GLvector4f texcoord[MAX_TEXTURE_UNITS];
+};
+
+
+#define TEXGEN_STAGE_DATA(stage) ((struct texgen_stage_data *)stage->privatePtr)
+
+
+
+static GLuint all_bits[5] = {
+   0,
+   VEC_SIZE_1,
+   VEC_SIZE_2,
+   VEC_SIZE_3,
+   VEC_SIZE_4,
+};
+
+#define VEC_SIZE_FLAGS (VEC_SIZE_1|VEC_SIZE_2|VEC_SIZE_3|VEC_SIZE_4)
+
+#define TEXGEN_NEED_M            (TEXGEN_SPHERE_MAP)
+#define TEXGEN_NEED_F            (TEXGEN_SPHERE_MAP        | \
+				  TEXGEN_REFLECTION_MAP_NV)
+
+
+
+static void build_m3( GLfloat f[][3], GLfloat m[],
+		      const GLvector3f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = (GLfloat *)eye->start;
+   GLuint count = eye->count;
+   const GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) {
+      GLfloat u[3], two_nu, fx, fy, fz;
+      COPY_3V( u, coord );
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      fx = f[i][0] = u[0] - norm[0] * two_nu;
+      fy = f[i][1] = u[1] - norm[1] * two_nu;
+      fz = f[i][2] = u[2] - norm[2] * two_nu;
+      m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
+      if (m[i] != 0.0F) {
+	 m[i] = 0.5F / (GLfloat) GL_SQRT(m[i]);
+      }
+   }
+}
+
+
+
+static void build_m2( GLfloat f[][3], GLfloat m[],
+		      const GLvector3f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = eye->start;
+   GLuint count = eye->count;
+
+   GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++,STRIDE_F(coord,stride),STRIDE_F(norm,normal->stride)) {
+      GLfloat u[3], two_nu, fx, fy, fz;
+      COPY_2V( u, coord );
+      u[2] = 0;
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      fx = f[i][0] = u[0] - norm[0] * two_nu;
+      fy = f[i][1] = u[1] - norm[1] * two_nu;
+      fz = f[i][2] = u[2] - norm[2] * two_nu;
+      m[i] = fx * fx + fy * fy + (fz + 1.0F) * (fz + 1.0F);
+      if (m[i] != 0.0F) {
+	 m[i] = 0.5F / (GLfloat) GL_SQRT(m[i]);
+      }
+   }
+}
+
+
+
+typedef void (*build_m_func)( GLfloat f[][3],
+			      GLfloat m[],
+			      const GLvector3f *normal,
+			      const GLvector4f *eye );
+
+
+static build_m_func build_m_tab[5] = {
+   0,
+   0,
+   build_m2,
+   build_m3,
+   build_m3
+};
+
+
+/* This is unusual in that we respect the stride of the output vector
+ * (f).  This allows us to pass in either a texcoord vector4f, or a
+ * temporary vector3f.
+ */
+static void build_f3( GLfloat *f,
+		      GLuint fstride,
+		      const GLvector3f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = eye->start;
+   GLuint count = eye->count;
+
+   GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++) {
+      GLfloat u[3], two_nu;
+      COPY_3V( u, coord );
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      f[0] = u[0] - norm[0] * two_nu;
+      f[1] = u[1] - norm[1] * two_nu;
+      f[2] = u[2] - norm[2] * two_nu;
+      STRIDE_F(coord,stride);
+      STRIDE_F(f,fstride);
+      STRIDE_F(norm, normal->stride);
+   }
+}
+
+
+static void build_f2( GLfloat *f,
+		      GLuint fstride,
+		      const GLvector3f *normal,
+		      const GLvector4f *eye )
+{
+   GLuint stride = eye->stride;
+   GLfloat *coord = eye->start;
+   GLuint count = eye->count;
+   GLfloat *norm = normal->start;
+   GLuint i;
+
+   for (i=0;i<count;i++) {
+
+      GLfloat u[3], two_nu;
+      COPY_2V( u, coord );
+      u[2] = 0;
+      NORMALIZE_3FV( u );
+      two_nu = 2.0F * DOT3(norm,u);
+      f[0] = u[0] - norm[0] * two_nu;
+      f[1] = u[1] - norm[1] * two_nu;
+      f[2] = u[2] - norm[2] * two_nu;
+
+      STRIDE_F(coord,stride);
+      STRIDE_F(f,fstride);
+      STRIDE_F(norm, normal->stride);
+   }
+}
+
+typedef void (*build_f_func)( GLfloat *f,
+			      GLuint fstride,
+			      const GLvector3f *normal_vec,
+			      const GLvector4f *eye );
+
+
+
+/* Just treat 4-vectors as 3-vectors.
+ */
+static build_f_func build_f_tab[5] = {
+   0,
+   0,
+   build_f2,
+   build_f3,
+   build_f3
+};
+
+
+/* Special case texgen functions.
+ */
+static void texgen_reflection_map_nv( GLcontext *ctx,
+				      struct texgen_stage_data *store,
+				      GLuint unit )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLvector4f *in = VB->TexCoordPtr[unit];
+   GLvector4f *out = &store->texcoord[unit];
+
+   build_f_tab[VB->EyePtr->size]( out->start,
+				  out->stride,
+				  VB->NormalPtr,
+				  VB->EyePtr );
+
+   if (in) {
+      out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3;
+      out->count = in->count;
+      out->size = MAX2(in->size, 3);
+      if (in->size == 4)
+	 _mesa_copy_tab[0x8]( out, in );
+   }
+   else {
+      out->flags |= VEC_SIZE_3;
+      out->size = 3;
+      out->count = in->count;
+   }
+
+}
+
+
+
+static void texgen_normal_map_nv( GLcontext *ctx,
+				  struct texgen_stage_data *store,
+				  GLuint unit )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLvector4f *in = VB->TexCoordPtr[unit];
+   GLvector4f *out = &store->texcoord[unit];
+   GLvector3f *normal = VB->NormalPtr;
+   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start;
+   GLuint count = VB->Count;
+   GLuint i;
+   const GLfloat *norm = normal->start;
+
+   for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
+      texcoord[i][0] = norm[0];
+      texcoord[i][1] = norm[1];
+      texcoord[i][2] = norm[2];
+   }
+
+
+   if (in) {
+      out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_3;
+      out->count = in->count;
+      out->size = MAX2(in->size, 3);
+      if (in->size == 4)
+	 _mesa_copy_tab[0x8]( out, in );
+   }
+   else {
+      out->flags |= VEC_SIZE_3;
+      out->size = 3;
+      out->count = in->count;
+   }
+}
+
+
+static void texgen_sphere_map( GLcontext *ctx,
+			       struct texgen_stage_data *store,
+			       GLuint unit )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLvector4f *in = VB->TexCoordPtr[unit];
+   GLvector4f *out = &store->texcoord[unit];
+   GLfloat (*texcoord)[4] = (GLfloat (*)[4]) out->start;
+   GLuint count = VB->Count;
+   GLuint i;
+   GLfloat (*f)[3] = store->tmp_f;
+   GLfloat *m = store->tmp_m;
+
+/*     fprintf(stderr, "%s normstride %d eyestride %d\n",  */
+/*  	   __FUNCTION__, VB->NormalPtr->stride, */
+/*  	   VB->EyePtr->stride); */
+
+   (build_m_tab[VB->EyePtr->size])( store->tmp_f,
+				    store->tmp_m,
+				    VB->NormalPtr,
+				    VB->EyePtr );
+
+   for (i=0;i<count;i++) {
+      texcoord[i][0] = f[i][0] * m[i] + 0.5F;
+      texcoord[i][1] = f[i][1] * m[i] + 0.5F;
+   }
+
+   if (in) {
+      out->size = MAX2(in->size,2);
+      out->count = in->count;
+      out->flags |= (in->flags & VEC_SIZE_FLAGS) | VEC_SIZE_2;
+      if (in->size > 2)
+	 _mesa_copy_tab[all_bits[in->size] & ~0x3]( out, in );
+   } else {
+      out->size = 2;
+      out->flags |= VEC_SIZE_2;
+      out->count = in->count;
+   }
+}
+
+
+
+static void texgen( GLcontext *ctx,
+		    struct texgen_stage_data *store,
+		    GLuint unit )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   GLvector4f *in = VB->TexCoordPtr[unit];
+   GLvector4f *out = &store->texcoord[unit];
+   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+   const GLvector4f *obj = VB->ObjPtr;
+   const GLvector4f *eye = VB->EyePtr;
+   const GLvector3f *normal = VB->NormalPtr;
+   GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->data;
+   GLfloat *indata;
+   GLuint count = VB->Count;
+   GLfloat (*f)[3] = store->tmp_f;
+   GLfloat *m = store->tmp_m;
+	 GLuint holes = 0;
+
+
+   if (texUnit->_GenFlags & TEXGEN_NEED_M) {
+      build_m_tab[in->size]( store->tmp_f, store->tmp_m, normal, eye );
+   } else if (texUnit->_GenFlags & TEXGEN_NEED_F) {
+      build_f_tab[in->size]( (GLfloat *)store->tmp_f, 3, normal, eye );
+   }
+
+   if (!in) {
+      ASSERT(0);
+      in = out;
+      in->count = VB->Count;
+
+      out->size = store->TexgenSize[unit];
+      out->flags |= texUnit->TexGenEnabled;
+      out->count = VB->Count;
+      holes = store->TexgenHoles[unit];
+   }
+   else {
+      GLuint copy = (all_bits[in->size] & ~texUnit->TexGenEnabled);
+      if (copy)
+	 _mesa_copy_tab[copy]( out, in );
+
+      out->size = MAX2(in->size, store->TexgenSize[unit]);
+      out->flags |= (in->flags & VEC_SIZE_FLAGS) | texUnit->TexGenEnabled;
+      out->count = in->count;
+
+      holes = ~all_bits[in->size] & store->TexgenHoles[unit];
+   }
+
+   if (holes) {
+      if (holes & VEC_DIRTY_2) _mesa_vector4f_clean_elem(out, count, 2);
+      if (holes & VEC_DIRTY_1) _mesa_vector4f_clean_elem(out, count, 1);
+      if (holes & VEC_DIRTY_0) _mesa_vector4f_clean_elem(out, count, 0);
+   }
+
+   if (texUnit->TexGenEnabled & S_BIT) {
+      GLuint i;
+      switch (texUnit->GenModeS) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( (GLfloat *)out->data,
+				       sizeof(out->data[0]), obj,
+				       texUnit->ObjectPlaneS );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( (GLfloat *)out->data,
+				       sizeof(out->data[0]), eye,
+				       texUnit->EyePlaneS );
+	 break;
+      case GL_SPHERE_MAP:
+	 for (indata=in->start,i=0 ; i<count ;i++, STRIDE_F(indata,in->stride))
+	    texcoord[i][0] = indata[0] * m[i] + 0.5F;
+	 break;
+      case GL_REFLECTION_MAP_NV:
+	 for (i=0;i<count;i++)
+	     texcoord[i][0] = f[i][0];
+	 break;
+      case GL_NORMAL_MAP_NV: {
+	 const GLfloat *norm = normal->start;
+	 for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
+	     texcoord[i][0] = norm[0];
+	 }
+	 break;
+      }
+      default:
+	 _mesa_problem(ctx, "Bad S texgen");
+      }
+   }
+
+   if (texUnit->TexGenEnabled & T_BIT) {
+      GLuint i;
+      switch (texUnit->GenModeT) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( &(out->data[0][1]),
+				       sizeof(out->data[0]), obj,
+				       texUnit->ObjectPlaneT );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( &(out->data[0][1]),
+				       sizeof(out->data[0]), eye,
+				       texUnit->EyePlaneT );
+	 break;
+      case GL_SPHERE_MAP:
+	 for (indata=in->start,i=0; i<count ;i++,STRIDE_F(indata,in->stride))
+	     texcoord[i][1] = indata[1] * m[i] + 0.5F;
+	 break;
+      case GL_REFLECTION_MAP_NV:
+	 for (i=0;i<count;i++)
+	     texcoord[i][0] = f[i][0];
+	 break;
+      case GL_NORMAL_MAP_NV: {
+	 const GLfloat *norm = normal->start;
+	 for (i=0;i<count;i++, STRIDE_F(norm, normal->stride)) {
+	     texcoord[i][1] = norm[1];
+	 }
+	 break;
+      }
+      default:
+	 _mesa_problem(ctx, "Bad T texgen");
+      }
+   }
+
+   if (texUnit->TexGenEnabled & R_BIT) {
+      GLuint i;
+      switch (texUnit->GenModeR) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( &(out->data[0][2]),
+				       sizeof(out->data[0]), obj,
+				       texUnit->ObjectPlaneR );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( &(out->data[0][2]),
+				       sizeof(out->data[0]), eye,
+				       texUnit->EyePlaneR );
+	 break;
+      case GL_REFLECTION_MAP_NV:
+	 for (i=0;i<count;i++)
+	     texcoord[i][2] = f[i][2];
+	 break;
+      case GL_NORMAL_MAP_NV: {
+	 const GLfloat *norm = normal->start;
+	 for (i=0;i<count;i++,STRIDE_F(norm, normal->stride)) {
+	     texcoord[i][2] = norm[2];
+	 }
+	 break;
+      }
+      default:
+	 _mesa_problem(ctx, "Bad R texgen");
+      }
+   }
+
+   if (texUnit->TexGenEnabled & Q_BIT) {
+      switch (texUnit->GenModeQ) {
+      case GL_OBJECT_LINEAR:
+	 _mesa_dotprod_tab[obj->size]( &(out->data[0][3]),
+				       sizeof(out->data[0]), obj,
+				       texUnit->ObjectPlaneQ );
+	 break;
+      case GL_EYE_LINEAR:
+	 _mesa_dotprod_tab[eye->size]( &(out->data[0][3]),
+				       sizeof(out->data[0]), eye,
+				       texUnit->EyePlaneQ );
+	 break;
+      default:
+	 _mesa_problem(ctx, "Bad Q texgen");
+      }
+   }
+}
+
+
+
+static GLboolean run_texgen_stage( GLcontext *ctx,
+				   struct gl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct texgen_stage_data *store = TEXGEN_STAGE_DATA( stage );
+   GLuint i;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+      if (ctx->Texture._TexGenEnabled & ENABLE_TEXGEN(i)) {
+	 if (stage->changed_inputs & (VERT_EYE | VERT_NORM | VERT_TEX(i)))
+	    store->TexgenFunc[i]( ctx, store, i );
+
+	 VB->TexCoordPtr[i] = &store->texcoord[i];
+      }
+
+   return GL_TRUE;
+}
+
+
+
+
+static GLboolean run_validate_texgen_stage( GLcontext *ctx,
+					    struct gl_pipeline_stage *stage )
+{
+   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
+   GLuint i;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++) {
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
+
+      if (texUnit->TexGenEnabled) {
+	 GLuint sz;
+
+	 if (texUnit->TexGenEnabled & R_BIT)
+	    sz = 4;
+	 else if (texUnit->TexGenEnabled & Q_BIT)
+	    sz = 3;
+	 else if (texUnit->TexGenEnabled & T_BIT)
+	    sz = 2;
+	 else
+	    sz = 1;
+
+	 store->TexgenSize[i] = sz;
+	 store->TexgenHoles[i] = (all_bits[sz] & ~texUnit->TexGenEnabled);
+	 store->TexgenFunc[i] = texgen;
+
+	 if (texUnit->TexGenEnabled == (S_BIT|T_BIT|R_BIT)) {
+	    if (texUnit->_GenFlags == TEXGEN_REFLECTION_MAP_NV) {
+	       store->TexgenFunc[i] = texgen_reflection_map_nv;
+	    }
+	    else if (texUnit->_GenFlags == TEXGEN_NORMAL_MAP_NV) {
+	       store->TexgenFunc[i] = texgen_normal_map_nv;
+	    }
+	 }
+	 else if (texUnit->TexGenEnabled == (S_BIT|T_BIT) &&
+		  texUnit->_GenFlags == TEXGEN_SPHERE_MAP) {
+	    store->TexgenFunc[i] = texgen_sphere_map;
+	 }
+      }
+   }
+
+   stage->run = run_texgen_stage;
+   return stage->run( ctx, stage );
+}
+
+
+static void check_texgen( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   GLuint i;
+   stage->active = 0;
+
+   if (ctx->Texture._TexGenEnabled) {
+      GLuint inputs = 0;
+      GLuint outputs = 0;
+
+      if (ctx->Texture._GenFlags & TEXGEN_OBJ_LINEAR)
+	 inputs |= VERT_OBJ;
+
+      if (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)
+	 inputs |= VERT_EYE;
+
+      if (ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS)
+	 inputs |= VERT_NORM;
+
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+	 if (ctx->Texture._TexGenEnabled & ENABLE_TEXGEN(i))
+	 {
+	    outputs |= VERT_TEX(i);
+
+	    /* Need the original input in case it contains a Q coord:
+	     * (sigh)
+	     */
+	    inputs |= VERT_TEX(i);
+
+	    /* Something for Feedback? */
+	 }
+
+      if (stage->privatePtr)
+	 stage->run = run_validate_texgen_stage;
+      stage->active = 1;
+      stage->inputs = inputs;
+      stage->outputs = outputs;
+   }
+}
+
+
+
+
+/* Called the first time stage->run() is invoked.
+ */
+static GLboolean alloc_texgen_data( GLcontext *ctx,
+				    struct gl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct texgen_stage_data *store;
+   GLuint i;
+
+   stage->privatePtr = CALLOC(sizeof(*store));
+   store = TEXGEN_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+      _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 );
+
+   store->tmp_f = (GLfloat (*)[3]) MALLOC(VB->Size * sizeof(GLfloat) * 3);
+   store->tmp_m = (GLfloat *) MALLOC(VB->Size * sizeof(GLfloat));
+
+   /* Now validate and run the stage.
+    */
+   stage->run = run_validate_texgen_stage;
+   return stage->run( ctx, stage );
+}
+
+
+static void free_texgen_data( struct gl_pipeline_stage *stage )
+
+{
+   struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
+   GLuint i;
+
+   if (store) {
+      for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++)
+	 if (store->texcoord[i].data)
+	    _mesa_vector4f_free( &store->texcoord[i] );
+
+
+      if (store->tmp_f) FREE( store->tmp_f );
+      if (store->tmp_m) FREE( store->tmp_m );
+      FREE( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+
+const struct gl_pipeline_stage _tnl_texgen_stage =
+{
+   "texgen",
+   _NEW_TEXTURE,		/* when to call check() */
+   _NEW_TEXTURE,		/* when to invalidate stored data */
+   0,0,0,			/* active, inputs, outputs */
+   0,0,				/* changed_inputs, private */
+   free_texgen_data,		/* destructor */
+   check_texgen,		/* check */
+   alloc_texgen_data		/* run -- initially set to alloc data */
+};
Index: xc/extras/Mesa/src/tnl/t_vb_texmat.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_texmat.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_texmat.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,147 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+/* Is there any real benefit seperating texmat from texgen?  It means
+ * we need two lots of intermediate storage.  Any changes to
+ * _NEW_TEXTURE will invalidate both sets -- it's only on changes to
+ * *only* _NEW_TEXTURE_MATRIX that texgen survives but texmat doesn't.
+ *
+ * However, the seperation of this code from the complex texgen stuff
+ * is very appealing.
+ */
+struct texmat_stage_data {
+   GLvector4f texcoord[MAX_TEXTURE_UNITS];
+};
+
+#define TEXMAT_STAGE_DATA(stage) ((struct texmat_stage_data *)stage->privatePtr)
+
+static void check_texmat( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   GLuint i;
+   stage->active = 0;
+
+   if (ctx->Texture._TexMatEnabled) {
+      GLuint flags = 0;
+
+      for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+	 if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))
+	    flags |= VERT_TEX(i);
+
+      stage->active = 1;
+      stage->inputs = flags;
+      stage->outputs = flags;
+   }
+}
+
+static GLboolean run_texmat_stage( GLcontext *ctx,
+				   struct gl_pipeline_stage *stage )
+{
+   struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage);
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLuint i;
+
+   /* ENABLE_TEXMAT implies that the texture matrix is not the
+    * identity, so we don't have to check that here.
+    */
+   for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+      if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i)) {
+	 if (stage->changed_inputs & VERT_TEX(i))
+	    (void) TransformRaw( &store->texcoord[i], &ctx->TextureMatrix[i],
+				 VB->TexCoordPtr[i]);
+
+	 VB->TexCoordPtr[i] = &store->texcoord[i];
+      }
+   return GL_TRUE;
+}
+
+
+/* Called the first time stage->run() is invoked.
+ */
+static GLboolean alloc_texmat_data( GLcontext *ctx,
+				    struct gl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct texmat_stage_data *store;
+   GLuint i;
+
+   stage->privatePtr = CALLOC(sizeof(*store));
+   store = TEXMAT_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
+      _mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 );
+
+   /* Now run the stage.
+    */
+   stage->run = run_texmat_stage;
+   return stage->run( ctx, stage );
+}
+
+
+static void free_texmat_data( struct gl_pipeline_stage *stage )
+{
+   struct texmat_stage_data *store = TEXMAT_STAGE_DATA(stage);
+   GLuint i;
+
+   if (store) {
+      for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++)
+	 if (store->texcoord[i].data)
+	    _mesa_vector4f_free( &store->texcoord[i] );
+      FREE( store );
+      stage->privatePtr = 0;
+   }
+}
+
+
+
+const struct gl_pipeline_stage _tnl_texture_transform_stage =
+{
+   "texture transform",
+   _NEW_TEXTURE|_NEW_TEXTURE_MATRIX,
+   _NEW_TEXTURE|_NEW_TEXTURE_MATRIX,
+   0,0,0,			/* active, inputs, outputs */
+   0,0,				/* changed_inputs, private */
+   free_texmat_data,		/* destructor */
+   check_texmat,		/* check */
+   alloc_texmat_data,		/* run -- initially set to init */
+};
Index: xc/extras/Mesa/src/tnl/t_vb_vertex.c
diff -u /dev/null xc/extras/Mesa/src/tnl/t_vb_vertex.c:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/t_vb_vertex.c	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,317 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+
+struct vertex_stage_data {
+   GLvector4f eye;
+   GLvector4f clip;
+   GLvector4f proj;
+   GLubyte *clipmask;
+   GLubyte ormask;
+   GLubyte andmask;
+
+
+   /* Need these because it's difficult to replay the sideeffects
+    * analytically.
+    */
+   GLvector4f *save_eyeptr;
+   GLvector4f *save_clipptr;
+   GLvector4f *save_projptr;
+};
+
+#define VERTEX_STAGE_DATA(stage) ((struct vertex_stage_data *)stage->privatePtr)
+
+
+
+
+/* This function implements cliptesting for user-defined clip planes.
+ * The clipping of primitives to these planes is implemented in
+ * t_render_clip.h.
+ */
+#define USER_CLIPTEST(NAME, SZ)					\
+static void NAME( GLcontext *ctx,				\
+		  GLvector4f *clip,				\
+		  GLubyte *clipmask,				\
+		  GLubyte *clipormask,				\
+		  GLubyte *clipandmask )			\
+{								\
+   GLuint p;							\
+								\
+   for (p = 0; p < ctx->Const.MaxClipPlanes; p++)		\
+      if (ctx->Transform.ClipEnabled[p]) {			\
+	 GLuint nr, i;						\
+	 const GLfloat a = ctx->Transform._ClipUserPlane[p][0];	\
+	 const GLfloat b = ctx->Transform._ClipUserPlane[p][1];	\
+	 const GLfloat c = ctx->Transform._ClipUserPlane[p][2];	\
+	 const GLfloat d = ctx->Transform._ClipUserPlane[p][3];	\
+         GLfloat *coord = (GLfloat *)clip->data;		\
+         GLuint stride = clip->stride;				\
+         GLuint count = clip->count;				\
+								\
+	 for (nr = 0, i = 0 ; i < count ; i++) {		\
+	    GLfloat dp = coord[0] * a + coord[1] * b;		\
+	    if (SZ > 2) dp += coord[2] * c;			\
+	    if (SZ > 3) dp += coord[3] * d; else dp += d;	\
+								\
+	    if (dp < 0) {					\
+	       nr++;						\
+	       clipmask[i] |= CLIP_USER_BIT;			\
+	    }							\
+								\
+	    STRIDE_F(coord, stride);				\
+	 }							\
+								\
+	 if (nr > 0) {						\
+	    *clipormask |= CLIP_USER_BIT;			\
+	    if (nr == count) {					\
+	       *clipandmask |= CLIP_USER_BIT;			\
+	       return;						\
+	    }							\
+	 }							\
+      }								\
+}
+
+
+USER_CLIPTEST(userclip2, 2)
+USER_CLIPTEST(userclip3, 3)
+USER_CLIPTEST(userclip4, 4)
+
+static void (*(usercliptab[5]))( GLcontext *,
+				 GLvector4f *, GLubyte *,
+				 GLubyte *, GLubyte * ) =
+{
+   0,
+   0,
+   userclip2,
+   userclip3,
+   userclip4
+};
+
+
+
+static GLboolean run_vertex_stage( GLcontext *ctx,
+				   struct gl_pipeline_stage *stage )
+{
+   struct vertex_stage_data *store = (struct vertex_stage_data *)stage->privatePtr;
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+
+   if (stage->changed_inputs) {
+
+      if (ctx->_NeedEyeCoords) {
+	 /* Separate modelview transformation:
+	  * Use combined ModelProject to avoid some depth artifacts
+	  */
+	 if (ctx->ModelView.type == MATRIX_IDENTITY)
+	    VB->EyePtr = VB->ObjPtr;
+	 else
+	    VB->EyePtr = TransformRaw( &store->eye, &ctx->ModelView,
+				       VB->ObjPtr);
+
+	 if (ctx->ProjectionMatrix.type == MATRIX_IDENTITY)
+	    VB->ClipPtr = VB->EyePtr;
+	 else
+	    VB->ClipPtr = TransformRaw( &store->clip, &ctx->_ModelProjectMatrix,
+					VB->ObjPtr );
+      }
+      else {
+	 /* Combined modelviewproject transform:
+	  */
+	 if (ctx->_ModelProjectMatrix.type == MATRIX_IDENTITY)
+	    VB->ClipPtr = VB->ObjPtr;
+	 else
+	    VB->ClipPtr = TransformRaw( &store->clip,
+                                        &ctx->_ModelProjectMatrix,
+					VB->ObjPtr );
+      }
+
+      /* Drivers expect this to be clean to element 4...
+       */
+      if (VB->ClipPtr->size < 4) {
+	 if (VB->ClipPtr->flags & VEC_NOT_WRITEABLE) {
+	    ASSERT(VB->ClipPtr == VB->ObjPtr);
+	    VB->import_data( ctx, VERT_OBJ, VEC_NOT_WRITEABLE );
+	    VB->ClipPtr = VB->ObjPtr;
+	 }
+	 if (VB->ClipPtr->size == 2)
+	    _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
+	 _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
+      }
+
+      /* Cliptest and perspective divide.  Clip functions must clear
+       * the clipmask.
+       */
+      store->ormask = 0;
+      store->andmask = CLIP_ALL_BITS;
+
+      if (tnl->NeedProjCoords) {
+	 VB->ProjectedClipPtr =
+	    _mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
+                                               &store->proj,
+                                               store->clipmask,
+                                               &store->ormask,
+                                               &store->andmask );
+
+      } else {
+	 VB->ProjectedClipPtr = 0;
+	 _mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
+                                               0,
+                                               store->clipmask,
+                                               &store->ormask,
+                                               &store->andmask );
+      }
+
+      if (store->andmask)
+	 return GL_FALSE;
+
+
+      /* Test userclip planes.  This contributes to VB->ClipMask, so
+       * is essentially required to be in this stage.
+       */
+      if (ctx->Transform._AnyClip) {
+	 usercliptab[VB->ClipPtr->size]( ctx,
+					 VB->ClipPtr,
+					 store->clipmask,
+					 &store->ormask,
+					 &store->andmask );
+
+	 if (store->andmask)
+	    return GL_FALSE;
+      }
+
+      VB->ClipOrMask = store->ormask;
+      VB->ClipMask = store->clipmask;
+
+      if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_OBJ))
+	 VB->importable_data |= VERT_CLIP;
+
+      store->save_eyeptr = VB->EyePtr;
+      store->save_clipptr = VB->ClipPtr;
+      store->save_projptr = VB->ProjectedClipPtr;
+   }
+   else {
+      /* Replay the sideeffects.
+       */
+      VB->EyePtr = store->save_eyeptr;
+      VB->ClipPtr = store->save_clipptr;
+      VB->ProjectedClipPtr = store->save_projptr;
+      VB->ClipMask = store->clipmask;
+      VB->ClipOrMask = store->ormask;
+      if (VB->ClipPtr == VB->ObjPtr && (VB->importable_data & VERT_OBJ))
+	 VB->importable_data |= VERT_CLIP;
+      if (store->andmask)
+	 return GL_FALSE;
+   }
+
+   return GL_TRUE;
+}
+
+
+static void check_vertex( GLcontext *ctx, struct gl_pipeline_stage *stage )
+{
+   (void) ctx;
+   (void) stage;
+}
+
+static GLboolean init_vertex_stage( GLcontext *ctx,
+				    struct gl_pipeline_stage *stage )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct vertex_stage_data *store;
+   GLuint size = VB->Size;
+
+   stage->privatePtr = CALLOC(sizeof(*store));
+   store = VERTEX_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector4f_alloc( &store->eye, 0, size, 32 );
+   _mesa_vector4f_alloc( &store->clip, 0, size, 32 );
+   _mesa_vector4f_alloc( &store->proj, 0, size, 32 );
+
+   store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
+
+   if (!store->clipmask ||
+       !store->eye.data ||
+       !store->clip.data ||
+       !store->proj.data)
+      return GL_FALSE;
+
+   /* Now run the stage.
+    */
+   stage->run = run_vertex_stage;
+   return stage->run( ctx, stage );
+}
+
+static void dtr( struct gl_pipeline_stage *stage )
+{
+   struct vertex_stage_data *store = VERTEX_STAGE_DATA(stage);
+
+   if (store) {
+      _mesa_vector4f_free( &store->eye );
+      _mesa_vector4f_free( &store->clip );
+      _mesa_vector4f_free( &store->proj );
+      ALIGN_FREE( store->clipmask );
+      FREE(store);
+      stage->privatePtr = NULL;
+      stage->run = init_vertex_stage;
+   }
+}
+
+
+const struct gl_pipeline_stage _tnl_vertex_transform_stage =
+{
+   "modelview/project/cliptest/divide",
+   0,				/* re-check -- always on */
+   _MESA_NEW_NEED_EYE_COORDS |
+   _NEW_MODELVIEW|
+   _NEW_PROJECTION|
+   _NEW_TRANSFORM,		/* re-run */
+   GL_TRUE,			/* active */
+   VERT_OBJ,		/* inputs */
+   VERT_EYE|VERT_CLIP,		/* outputs */
+   0, 0,			/* changed_inputs, private */
+   dtr,				/* destructor */
+   check_vertex,		/* check */
+   init_vertex_stage		/* run -- initially set to init */
+};
Index: xc/extras/Mesa/src/tnl/tnl.h
diff -u /dev/null xc/extras/Mesa/src/tnl/tnl.h:1.2
--- /dev/null	Thu Feb 27 12:16:04 2003
+++ xc/extras/Mesa/src/tnl/tnl.h	Mon Dec 16 11:18:46 2002
@@ -0,0 +1,77 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#ifndef _TNL_H
+#define _TNL_H
+
+#include "mtypes.h"
+
+
+
+/* These are the public-access functions exported from tnl.  (A few
+ * more are currently hooked into dispatch directly by the module
+ * itself.)
+ */
+extern GLboolean
+_tnl_CreateContext( GLcontext *ctx );
+
+extern void
+_tnl_DestroyContext( GLcontext *ctx );
+
+extern void
+_tnl_InvalidateState( GLcontext *ctx, GLuint new_state );
+
+/* Functions to revive the tnl module after being unhooked from
+ * dispatch and/or driver callbacks.
+ */
+
+/* Restore just the ctx->Exec table:
+ */
+extern void
+_tnl_wakeup_exec( GLcontext *ctx );
+
+/* Restore both ctx->Exec and ctx->Save:
+ */
+extern void
+_tnl_wakeup_save_exec( GLcontext *ctx );
+
+/* Driver configuration options:
+ */
+extern void
+_tnl_need_projected_coords( GLcontext *ctx, GLboolean flag );
+
+extern void
+_tnl_need_dlist_loopback( GLcontext *ctx, GLboolean flag );
+
+extern void
+_tnl_need_dlist_norm_lengths( GLcontext *ctx, GLboolean flag );
+
+extern void
+_tnl_isolate_materials( GLcontext *ctx, GLboolean flag );
+
+#endif
Index: xc/extras/Mesa/src/tnl_dd/t_dd.c
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd.c:1.2
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd.c	Mon Dec 16 11:18:48 2002
@@ -0,0 +1,58 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+static void copy_pv_rgba4_spec5( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLubyte *i810verts = (GLubyte *)imesa->verts;
+   GLuint shift = imesa->vertex_stride_shift;
+   i810Vertex *dst = (i810Vertex *)(i810verts + (edst << shift));
+   i810Vertex *src = (i810Vertex *)(i810verts + (esrc << shift));
+   dst->ui[4] = src->ui[4];
+   dst->ui[5] = src->ui[5];
+}
+
+static void copy_pv_rgba4( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLubyte *i810verts = (GLubyte *)imesa->verts;
+   GLuint shift = imesa->vertex_stride_shift;
+   i810Vertex *dst = (i810Vertex *)(i810verts + (edst << shift));
+   i810Vertex *src = (i810Vertex *)(i810verts + (esrc << shift));
+   dst->ui[4] = src->ui[4];
+}
+
+static void copy_pv_rgba3( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   i810ContextPtr imesa = I810_CONTEXT( ctx );
+   GLubyte *i810verts = (GLubyte *)imesa->verts;
+   GLuint shift = imesa->vertex_stride_shift;
+   i810Vertex *dst = (i810Vertex *)(i810verts + (edst << shift));
+   i810Vertex *src = (i810Vertex *)(i810verts + (esrc << shift));
+   dst->ui[3] = src->ui[3];
+}
Index: xc/extras/Mesa/src/tnl_dd/t_dd_dmatmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_dmatmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_dmatmp.h	Mon Dec 16 11:18:48 2002
@@ -0,0 +1,1105 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+/* Template for render stages which build and emit vertices directly
+ * to fixed-size dma buffers.  Useful for rendering strips and other
+ * native primitives where clipping and per-vertex tweaks such as
+ * those in t_dd_tritmp.h are not required.
+ *
+ * Produces code for both inline triangles and indexed triangles.
+ * Where various primitive types are unaccelerated by hardware, the
+ * code attempts to fallback to other primitive types (quadstrips to
+ * tristrips, lineloops to linestrips), or to indexed vertices.
+ * Ultimately, a FALLBACK() macro is invoked if there is no way to
+ * render the primitive natively.
+ */
+
+#if !defined(HAVE_TRIANGLES)
+#error "must have at least triangles to use render template"
+#endif
+
+#if !HAVE_ELTS
+#define ELTS_VARS
+#define ALLOC_ELTS( nr )
+#define EMIT_ELT( offset, elt )
+#define EMIT_TWO_ELTS( offset, elt0, elt1 )
+#define INCR_ELTS( nr )
+#define ELT_INIT(prim)
+#define GET_CURRENT_VB_MAX_ELTS() 0
+#define GET_SUBSEQUENT_VB_MAX_ELTS() 0
+#define ALLOC_ELTS_NEW_PRIMITIVE(nr)
+#define RELEASE_ELT_VERTS()
+#define EMIT_INDEXED_VERTS( ctx, start, count )
+#endif
+
+#ifndef EMIT_TWO_ELTS
+#define EMIT_TWO_ELTS( offset, elt0, elt1 )	\
+do { 						\
+   EMIT_ELT( offset, elt0 ); 			\
+   EMIT_ELT( offset+1, elt1 ); 			\
+} while (0)
+#endif
+
+#ifndef FINISH
+#define FINISH
+#endif
+
+/**********************************************************************/
+/*                  Render whole begin/end objects                    */
+/**********************************************************************/
+
+
+
+static GLboolean TAG(emit_elt_verts)( GLcontext *ctx,
+				      GLuint start, GLuint count )
+{
+   if (HAVE_ELTS) {
+      LOCAL_VARS;
+      GLuint nr = count - start;
+
+      if ( nr >= GET_SUBSEQUENT_VB_MAX_VERTS() ) /* assumes same packing for
+						  * indexed and regualar verts
+						  */
+	 return GL_FALSE;
+
+      NEW_PRIMITIVE(); /* finish last prim */
+      EMIT_INDEXED_VERTS( ctx, start, count );
+      return GL_TRUE;
+   } else {
+      return GL_FALSE;
+   }
+}
+
+#if (HAVE_ELTS)
+static void TAG(emit_elts)( GLcontext *ctx, GLuint *elts, GLuint nr )
+{
+   GLint i;
+   LOCAL_VARS;
+   ELTS_VARS;
+
+   ALLOC_ELTS( nr );
+
+   for ( i = 0 ; i < nr ; i+=2, elts += 2 ) {
+      EMIT_TWO_ELTS( 0, elts[0], elts[1] );
+      INCR_ELTS( 2 );
+   }
+}
+#endif
+
+
+/***********************************************************************
+ *                    Render non-indexed primitives.
+ ***********************************************************************/
+
+
+
+static void TAG(render_points_verts)( GLcontext *ctx,
+				      GLuint start,
+				      GLuint count,
+				      GLuint flags )
+{
+   if (HAVE_POINTS) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz = GET_CURRENT_VB_MAX_VERTS();
+      GLuint j, nr;
+
+      INIT( GL_POINTS );
+
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j < count; j += nr ) {
+	 nr = MIN2( currentsz, count - j );
+	 EMIT_VERTS( ctx, j, nr );
+	 currentsz = dmasz;
+      }
+
+      FINISH;
+
+   } else {
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+static void TAG(render_lines_verts)( GLcontext *ctx,
+				     GLuint start,
+				     GLuint count,
+				     GLuint flags )
+{
+   if (HAVE_LINES) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz = GET_CURRENT_VB_MAX_VERTS();
+      GLuint j, nr;
+
+      INIT( GL_LINES );
+
+      /* Emit whole number of lines in total and in each buffer:
+       */
+      count -= (count-start) & 1;
+      currentsz -= currentsz & 1;
+      dmasz -= dmasz & 1;
+
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j < count; j += nr ) {
+	 nr = MIN2( currentsz, count - j );
+	 EMIT_VERTS( ctx, j, nr );
+	 currentsz = dmasz;
+      }
+
+      FINISH;
+
+   } else {
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_line_strip_verts)( GLcontext *ctx,
+					  GLuint start,
+					  GLuint count,
+					  GLuint flags )
+{
+   if (HAVE_LINE_STRIPS) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz = GET_CURRENT_VB_MAX_VERTS();
+      GLuint j, nr;
+
+      NEW_PRIMITIVE(); /* always a new primitive */
+      INIT( GL_LINE_STRIP );
+
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j + 1 < count; j += nr - 1 ) {
+	 nr = MIN2( currentsz, count - j );
+	 EMIT_VERTS( ctx, j, nr );
+	 currentsz = dmasz;
+      }
+ 
+      FINISH;
+
+   } else {
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_line_loop_verts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   if (HAVE_LINE_STRIPS) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz = GET_CURRENT_VB_MAX_VERTS();
+      GLuint j, nr;
+
+      NEW_PRIMITIVE();
+      INIT( GL_LINE_STRIP );
+
+      if (flags & PRIM_BEGIN)
+	 j = start;
+      else
+	 j = start + 1;
+
+      /* Ensure last vertex won't wrap buffers:
+       */
+      currentsz--;
+      dmasz--;
+
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      if (j + 1 < count) {
+	 for ( ; j + 1 < count; j += nr - 1 ) {
+	    nr = MIN2( currentsz, count - j );
+	    EMIT_VERTS( ctx, j, nr );
+	    currentsz = dmasz;
+	 }
+
+	 if (start < count - 1 && (flags & PRIM_END))
+	    EMIT_VERTS( ctx, start, 1 );
+      }
+      else if (start + 1 < count && (flags & PRIM_END)) {
+	 EMIT_VERTS( ctx, start+1, 1 );
+	 EMIT_VERTS( ctx, start, 1 );
+      }
+
+      FINISH;
+
+   } else {
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_triangles_verts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   LOCAL_VARS;
+   int dmasz = (GET_SUBSEQUENT_VB_MAX_VERTS()/3) * 3;
+   int currentsz = (GET_CURRENT_VB_MAX_VERTS()/3) * 3;
+   GLuint j, nr;
+
+   INIT(GL_TRIANGLES);
+
+   /* Emit whole number of tris in total.  dmasz is already a multiple
+    * of 3.
+    */
+   count -= (count-start)%3;
+
+   if (currentsz < 8)
+      currentsz = dmasz;
+
+   for (j = start; j < count; j += nr) {
+      nr = MIN2( currentsz, count - j );
+      EMIT_VERTS( ctx, j, nr );
+      currentsz = dmasz;
+   }
+   FINISH;
+}
+
+
+
+static void TAG(render_tri_strip_verts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   if (HAVE_TRI_STRIPS) {
+      LOCAL_VARS;
+      GLuint j, nr;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz;
+
+      INIT(GL_TRIANGLE_STRIP);
+      NEW_PRIMITIVE();
+
+      currentsz = GET_CURRENT_VB_MAX_VERTS();
+
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      if ((flags & PRIM_PARITY) && count - start > 2) {
+	 if (HAVE_TRI_STRIP_1 && 0) {
+	 } else {
+	    EMIT_VERTS( ctx, start, 1 );
+	    currentsz--;
+	 }
+      }
+
+      /* From here on emit even numbers of tris when wrapping over buffers:
+       */
+      dmasz -= (dmasz & 1);
+      currentsz -= (currentsz & 1);
+
+      for (j = start ; j + 2 < count; j += nr - 2 ) {
+	 nr = MIN2( currentsz, count - j );
+	 EMIT_VERTS( ctx, j, nr );
+	 currentsz = dmasz;
+      }
+
+      FINISH;
+
+   } else {
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+static void TAG(render_tri_fan_verts)( GLcontext *ctx,
+				       GLuint start,
+				       GLuint count,
+				       GLuint flags )
+{
+   if (HAVE_TRI_FANS) {
+      LOCAL_VARS;
+      GLuint j, nr;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz = GET_CURRENT_VB_MAX_VERTS();
+
+      NEW_PRIMITIVE();
+      INIT(GL_TRIANGLE_FAN);
+
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start + 1 ; j + 1 < count; j += nr - 1 ) {
+	 nr = MIN2( currentsz, count - j + 1 );
+	 EMIT_VERTS( ctx, start, 1 );
+	 EMIT_VERTS( ctx, j, nr - 1 );
+	 currentsz = dmasz;
+      }
+
+      FINISH;
+
+   }
+   else {
+      /* Could write code to emit these as indexed vertices (for the
+       * g400, for instance).
+       */
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_poly_verts)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   if (HAVE_POLYGONS) {
+      LOCAL_VARS;
+      GLuint j, nr;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz = GET_CURRENT_VB_MAX_VERTS();
+
+      NEW_PRIMITIVE();
+      INIT(GL_POLYGON);
+
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start + 1 ; j + 1 < count ; j += nr - 1 ) {
+	 nr = MIN2( currentsz, count - j + 1 );
+	 EMIT_VERTS( ctx, start, 1 );
+	 EMIT_VERTS( ctx, j, nr - 1 );
+	 currentsz = dmasz;
+      }
+
+      FINISH;
+
+   }
+   else if (HAVE_TRI_FANS && !(ctx->_TriangleCaps & DD_FLATSHADE)) {
+      TAG(render_tri_fan_verts)( ctx, start, count, flags );
+   } else {
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+static void TAG(render_quad_strip_verts)( GLcontext *ctx,
+					  GLuint start,
+					  GLuint count,
+					  GLuint flags )
+{
+   GLuint j, nr;
+
+   if (HAVE_QUAD_STRIPS) {
+      LOCAL_VARS;
+      GLuint j, nr;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz;
+
+      INIT(GL_QUAD_STRIP);
+      NEW_PRIMITIVE();
+
+      currentsz = GET_CURRENT_VB_MAX_VERTS();
+
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      dmasz -= (dmasz & 2);
+      currentsz -= (currentsz & 2);
+
+      for (j = start ; j + 3 < count; j += nr - 2 ) {
+	 nr = MIN2( currentsz, count - j );
+	 EMIT_VERTS( ctx, j, nr );
+	 currentsz = dmasz;
+      }
+
+      FINISH;
+
+   } else if (HAVE_TRI_STRIPS && (ctx->_TriangleCaps & DD_FLATSHADE)) {
+      if (TAG(emit_elt_verts)( ctx, start, count )) {
+	 LOCAL_VARS;
+	 int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+	 int currentsz;
+	 GLuint j, nr;
+
+	 /* Simulate flat-shaded quadstrips using indexed vertices:
+	  */
+	 NEW_PRIMITIVE();
+	 ELT_INIT( GL_TRIANGLES );
+
+	 currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+	 /* Emit whole number of quads in total, and in each buffer.
+	  */
+	 dmasz -= dmasz & 1;
+	 count -= (count-start) & 1;
+	 currentsz -= currentsz & 1;
+
+	 if (currentsz < 12)
+	    currentsz = dmasz;
+
+	 currentsz = currentsz/6*2;
+	 dmasz = dmasz/6*2;
+
+	 for (j = start; j + 3 < count; j += nr - 2 ) {
+	    nr = MIN2( currentsz, count - j );
+	    if (nr >= 4) {
+	       GLint quads = (nr/2)-1;
+	       GLint i;
+	       ELTS_VARS;
+
+	       NEW_PRIMITIVE();
+	       ALLOC_ELTS_NEW_PRIMITIVE( quads*6 );
+
+	       for ( i = j-start ; i < j-start+quads*2 ; i+=2 ) {
+		  EMIT_TWO_ELTS( 0, (i+0), (i+1) );
+		  EMIT_TWO_ELTS( 2, (i+2), (i+1) );
+		  EMIT_TWO_ELTS( 4, (i+3), (i+2) );
+		  INCR_ELTS( 6 );
+	       }
+
+	       NEW_PRIMITIVE();
+	    }
+	    currentsz = dmasz;
+	 }
+
+	 RELEASE_ELT_VERTS();
+      }
+      else {
+	 /* Vertices won't fit in a single buffer or elts not available,
+	  * VERT_FALLBACK.
+	  */
+	 VERT_FALLBACK( ctx, start, count, flags );
+      }
+   }
+   else if (HAVE_TRI_STRIPS) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_VERTS();
+      int currentsz = GET_CURRENT_VB_MAX_VERTS();
+
+      /* Emit smooth-shaded quadstrips as tristrips:
+       */
+      NEW_PRIMITIVE();
+      INIT( GL_TRIANGLE_STRIP );
+
+      /* Emit whole number of quads in total, and in each buffer.
+       */
+      dmasz -= dmasz & 1;
+      currentsz -= currentsz & 1;
+      count -= (count-start) & 1;
+
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start; j + 3 < count; j += nr - 2 ) {
+	 nr = MIN2( currentsz, count - j );
+	 EMIT_VERTS( ctx, j, nr );
+	 currentsz = dmasz;
+      }
+
+      FINISH;
+
+   } else {
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_quads_verts)( GLcontext *ctx,
+				     GLuint start,
+				     GLuint count,
+				     GLuint flags )
+{
+   if (HAVE_QUADS) {
+      LOCAL_VARS;
+      int dmasz = (GET_SUBSEQUENT_VB_MAX_VERTS()/4) * 4;
+      int currentsz = (GET_CURRENT_VB_MAX_VERTS()/4) * 4;
+      GLuint j, nr;
+
+      INIT(GL_QUADS);
+
+      /* Emit whole number of quads in total.  dmasz is already a multiple
+       * of 4.
+       */
+      count -= (count-start)%4;
+
+      if (currentsz < 8)
+         currentsz = dmasz;
+
+      for (j = start; j < count; j += nr) {
+         nr = MIN2( currentsz, count - j );
+         EMIT_VERTS( ctx, j, nr );
+         currentsz = dmasz;
+      }
+      FINISH;
+   } else if (TAG(emit_elt_verts)( ctx, start, count )) {
+      /* Hardware doesn't have a quad primitive type -- try to
+       * simulate it using indexed vertices and the triangle
+       * primitive:
+       */
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      NEW_PRIMITIVE();
+      ELT_INIT( GL_TRIANGLES );
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+      /* Emit whole number of quads in total, and in each buffer.
+       */
+      dmasz -= dmasz & 3;
+      count -= (count-start) & 3;
+      currentsz -= currentsz & 3;
+
+      /* Adjust for rendering as triangles:
+       */
+      currentsz = currentsz/6*4;
+      dmasz = dmasz/6*4;
+
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j < count; j += nr ) {
+	 nr = MIN2( currentsz, count - j );
+	 if (nr >= 4) {
+	    GLint quads = nr/4;
+	    GLint i;
+	    ELTS_VARS;
+
+	    NEW_PRIMITIVE();
+	    ALLOC_ELTS_NEW_PRIMITIVE( quads*6 );
+
+	    for ( i = j-start ; i < j-start+quads*4 ; i+=4 ) {
+	       EMIT_TWO_ELTS( 0, (i+0), (i+1) );
+	       EMIT_TWO_ELTS( 2, (i+3), (i+1) );
+	       EMIT_TWO_ELTS( 4, (i+2), (i+3) );
+	       INCR_ELTS( 6 );
+	    }
+
+	    NEW_PRIMITIVE();
+	 }
+	 currentsz = dmasz;
+      }
+
+      RELEASE_ELT_VERTS();
+   }
+   else {
+      /* Vertices won't fit in a single buffer, fallback.
+       */
+      VERT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+static void TAG(render_noop)( GLcontext *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+}
+
+
+
+
+static render_func TAG(render_tab_verts)[GL_POLYGON+2] =
+{
+   TAG(render_points_verts),
+   TAG(render_lines_verts),
+   TAG(render_line_loop_verts),
+   TAG(render_line_strip_verts),
+   TAG(render_triangles_verts),
+   TAG(render_tri_strip_verts),
+   TAG(render_tri_fan_verts),
+   TAG(render_quads_verts),
+   TAG(render_quad_strip_verts),
+   TAG(render_poly_verts),
+   TAG(render_noop),
+};
+
+
+/****************************************************************************
+ *                 Render elts using hardware indexed verts                 *
+ ****************************************************************************/
+
+#if (HAVE_ELTS)
+static void TAG(render_points_elts)( GLcontext *ctx,
+				     GLuint start,
+				     GLuint count,
+				     GLuint flags )
+{
+   if (HAVE_POINTS) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      GLuint j, nr;
+
+      ELT_INIT( GL_POINTS );
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j < count; j += nr ) {
+	 nr = MIN2( currentsz, count - j );
+	 TAG(emit_elts)( ctx, elts+j, nr );
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   } else {
+      ELT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+
+static void TAG(render_lines_elts)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   if (HAVE_LINES) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      GLuint j, nr;
+
+      ELT_INIT( GL_LINES );
+
+      /* Emit whole number of lines in total and in each buffer:
+       */
+      count -= (count-start) & 1;
+      currentsz -= currentsz & 1;
+      dmasz -= dmasz & 1;
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j < count; j += nr ) {
+	 nr = MIN2( currentsz, count - j );
+	 TAG(emit_elts)( ctx, elts+j, nr );
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   } else {
+      ELT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_line_strip_elts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   if (HAVE_LINE_STRIPS) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      GLuint j, nr;
+
+      NEW_PRIMITIVE(); /* always a new primitive */
+      ELT_INIT( GL_LINE_STRIP );
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j + 1 < count; j += nr - 1 ) {
+	 nr = MIN2( currentsz, count - j );
+	 TAG(emit_elts)( ctx, elts+j, nr );
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   } else {
+      /* TODO: Try to emit as indexed lines.
+       */
+      ELT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_line_loop_elts)( GLcontext *ctx,
+					GLuint start,
+					GLuint count,
+					GLuint flags )
+{
+   if (HAVE_LINE_STRIPS) {
+      LOCAL_VARS;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      GLuint j, nr;
+
+      NEW_PRIMITIVE();
+      ELT_INIT( GL_LINE_STRIP );
+
+      if (flags & PRIM_BEGIN)
+	 j = start;
+      else
+	 j = start + 1;
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      /* Ensure last vertex doesn't wrap:
+       */
+      currentsz--;
+      dmasz--;
+
+      for ( ; j + 1 < count; j += nr - 1 ) {
+	 nr = MIN2( currentsz, count - j );
+/*  	 NEW_PRIMITIVE(); */
+	 TAG(emit_elts)( ctx, elts+j, nr );
+	 currentsz = dmasz;
+      }
+
+      if (flags & PRIM_END)
+	 TAG(emit_elts)( ctx, elts+start, 1 );
+
+      NEW_PRIMITIVE();
+   } else {
+      /* TODO: Try to emit as indexed lines */
+      ELT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+/* For verts, we still eliminate the copy from main memory to dma
+ * buffers.  For elts, this is probably no better (worse?) than the
+ * standard path.
+ */
+static void TAG(render_triangles_elts)( GLcontext *ctx,
+					GLuint start,
+					GLuint count,
+					GLuint flags )
+{
+   LOCAL_VARS;
+   GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS()/3*3;
+   int currentsz;
+   GLuint j, nr;
+
+   NEW_PRIMITIVE();
+   ELT_INIT( GL_TRIANGLES );
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+   /* Emit whole number of tris in total.  dmasz is already a multiple
+    * of 3.
+    */
+   count -= (count-start)%3;
+   currentsz -= currentsz%3;
+   if (currentsz < 8)
+      currentsz = dmasz;
+
+   for (j = start; j < count; j += nr) {
+      nr = MIN2( currentsz, count - j );
+      TAG(emit_elts)( ctx, elts+j, nr );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+}
+
+
+
+static void TAG(render_tri_strip_elts)( GLcontext *ctx,
+					GLuint start,
+					GLuint count,
+					GLuint flags )
+{
+   if (HAVE_TRI_STRIPS) {
+      LOCAL_VARS;
+      GLuint j, nr;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+
+      NEW_PRIMITIVE();
+      ELT_INIT( GL_TRIANGLE_STRIP );
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      if ((flags & PRIM_PARITY) && count - start > 2) {
+	 TAG(emit_elts)( ctx, elts+start, 1 );
+      }
+
+      /* Keep the same winding over multiple buffers:
+       */
+      dmasz -= (dmasz & 1);
+      currentsz -= (currentsz & 1);
+
+      for (j = start ; j + 2 < count; j += nr - 2 ) {
+	 nr = MIN2( currentsz, count - j );
+	 TAG(emit_elts)( ctx, elts+j, nr );
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   } else {
+      /* TODO: try to emit as indexed triangles */
+      ELT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+static void TAG(render_tri_fan_elts)( GLcontext *ctx,
+				      GLuint start,
+				      GLuint count,
+				      GLuint flags )
+{
+   if (HAVE_TRI_FANS) {
+      LOCAL_VARS;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      GLuint j, nr;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+
+      NEW_PRIMITIVE();
+      ELT_INIT( GL_TRIANGLE_FAN );
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start + 1 ; j + 1 < count; j += nr - 1 ) {
+	 nr = MIN2( currentsz, count - j + 1 );
+	 TAG(emit_elts)( ctx, elts+start, 1 );
+	 TAG(emit_elts)( ctx, elts+j, nr - 1 );
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   } else {
+      /* TODO: try to emit as indexed triangles */
+      ELT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+
+static void TAG(render_poly_elts)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   if (HAVE_POLYGONS && 0) {
+   } else if (HAVE_TRI_FANS && !(ctx->_TriangleCaps & DD_FLATSHADE)) {
+      LOCAL_VARS;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      GLuint j, nr;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+
+      NEW_PRIMITIVE();
+      ELT_INIT( GL_TRIANGLE_FAN );
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start + 1 ; j + 1 < count ; j += nr - 1 ) {
+	 nr = MIN2( currentsz, count - j + 1 );
+	 TAG(emit_elts)( ctx, elts+start, 1 );
+	 TAG(emit_elts)( ctx, elts+j, nr - 1 );
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   } else {
+      ELT_FALLBACK( ctx, start, count, flags );
+   }
+}
+
+static void TAG(render_quad_strip_elts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   if (HAVE_QUAD_STRIPS && 0) {
+   }
+   else if (HAVE_TRI_STRIPS) {
+      LOCAL_VARS;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      NEW_PRIMITIVE();
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+      /* Emit whole number of quads in total, and in each buffer.
+       */
+      dmasz -= dmasz & 1;
+      count -= (count-start) & 1;
+      currentsz -= currentsz & 1;
+
+      if (currentsz < 12)
+	 currentsz = dmasz;
+
+      if (ctx->_TriangleCaps & DD_FLATSHADE) {
+	 ELT_INIT( GL_TRIANGLES );
+
+	 currentsz = currentsz/6*2;
+	 dmasz = dmasz/6*2;
+
+	 for (j = start; j + 3 < count; j += nr - 2 ) {
+	    nr = MIN2( currentsz, count - j );
+
+	    if (nr >= 4)
+	    {
+	       GLint i;
+	       GLint quads = (nr/2)-1;
+	       ELTS_VARS;
+
+
+	       NEW_PRIMITIVE();
+	       ALLOC_ELTS_NEW_PRIMITIVE( quads*6 );
+
+	       for ( i = j-start ; i < j-start+quads ; i++, elts += 2 ) {
+		  EMIT_TWO_ELTS( 0, elts[0], elts[1] );
+		  EMIT_TWO_ELTS( 2, elts[2], elts[1] );
+		  EMIT_TWO_ELTS( 4, elts[3], elts[2] );
+		  INCR_ELTS( 6 );
+	       }
+
+	       NEW_PRIMITIVE();
+	    }
+
+	    currentsz = dmasz;
+	 }
+      }
+      else {
+	 ELT_INIT( GL_TRIANGLE_STRIP );
+
+	 for (j = start; j + 3 < count; j += nr - 2 ) {
+	    nr = MIN2( currentsz, count - j );
+	    TAG(emit_elts)( ctx, elts+j, nr );
+	    NEW_PRIMITIVE();
+	    currentsz = dmasz;
+	 }
+      }
+   }
+}
+
+
+static void TAG(render_quads_elts)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   if (HAVE_QUADS && 0) {
+   } else {
+      LOCAL_VARS;
+      GLuint *elts = TNL_CONTEXT(ctx)->vb.Elts;
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      ELT_INIT( GL_TRIANGLES );
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+      /* Emit whole number of quads in total, and in each buffer.
+       */
+      dmasz -= dmasz & 3;
+      count -= (count-start) & 3;
+      currentsz -= currentsz & 3;
+
+      /* Adjust for rendering as triangles:
+       */
+      currentsz = currentsz/6*4;
+      dmasz = dmasz/6*4;
+
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j + 3 < count; j += nr - 2 ) {
+	 nr = MIN2( currentsz, count - j );
+
+	 if (nr >= 4)
+	 {
+	    GLint quads = nr/4;
+	    GLint i;
+	    ELTS_VARS;
+	    NEW_PRIMITIVE();
+	    ALLOC_ELTS_NEW_PRIMITIVE( quads * 6 );
+
+	    for ( i = j-start ; i < j-start+quads ; i++, elts += 4 ) {
+	       EMIT_TWO_ELTS( 0, elts[0], elts[1] );
+	       EMIT_TWO_ELTS( 2, elts[3], elts[1] );
+	       EMIT_TWO_ELTS( 4, elts[2], elts[3] );
+	       INCR_ELTS( 6 );
+	    }
+	 }
+
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   }
+}
+
+
+
+static render_func TAG(render_tab_elts)[GL_POLYGON+2] =
+{
+   TAG(render_points_elts),
+   TAG(render_lines_elts),
+   TAG(render_line_loop_elts),
+   TAG(render_line_strip_elts),
+   TAG(render_triangles_elts),
+   TAG(render_tri_strip_elts),
+   TAG(render_tri_fan_elts),
+   TAG(render_quads_elts),
+   TAG(render_quad_strip_elts),
+   TAG(render_poly_elts),
+   TAG(render_noop),
+};
+#endif
Index: xc/extras/Mesa/src/tnl_dd/t_dd_dmatmp2.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_dmatmp2.h:1.2
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_dmatmp2.h	Tue Nov  5 12:46:07 2002
@@ -0,0 +1,1094 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+/* $XFree86: xc/extras/Mesa/src/tnl_dd/t_dd_dmatmp2.h,v 1.2 2002/11/05 17:46:07 tsi Exp $ */
+
+
+/* Template for render stages which build and emit vertices directly
+ * to fixed-size dma buffers.  Useful for rendering strips and other
+ * native primitives where clipping and per-vertex tweaks such as
+ * those in t_dd_tritmp.h are not required.
+ *
+ */
+
+#if !HAVE_TRIANGLES || !HAVE_POINTS || !HAVE_LINES
+#error "must have points, lines & triangles to use render template"
+#endif
+
+#if !HAVE_TRI_STRIPS || !HAVE_TRI_FANS
+#error "must have tri strip and fans to use render template"
+#endif
+
+#if !HAVE_LINE_STRIPS
+#error "must have line strips to use render template"
+#endif
+
+#if !HAVE_POLYGONS
+#error "must have polygons to use render template"
+#endif
+
+#if !HAVE_ELTS
+#error "must have elts to use render template"
+#endif
+
+
+#ifndef EMIT_TWO_ELTS
+#define EMIT_TWO_ELTS( offset, elt0, elt1 )	\
+do { 						\
+   EMIT_ELT( offset, elt0 ); 			\
+   EMIT_ELT( offset+1, elt1 ); 			\
+} while (0)
+#endif
+
+
+/**********************************************************************/
+/*                  Render whole begin/end objects                    */
+/**********************************************************************/
+
+
+static void TAG(emit_elts)( GLcontext *ctx, GLuint *elts, GLuint nr )
+{
+   GLint i;
+   LOCAL_VARS;
+   ELTS_VARS;
+
+   ALLOC_ELTS( nr );
+
+   for ( i = 0 ; i < nr ; i+=2, elts += 2 ) {
+      EMIT_TWO_ELTS( 0, elts[0], elts[1] );
+      INCR_ELTS( 2 );
+   }
+}
+
+static void TAG(emit_consecutive_elts)( GLcontext *ctx, GLuint start, GLuint nr )
+{
+   GLint i;
+   LOCAL_VARS;
+   ELTS_VARS;
+
+   ALLOC_ELTS( nr );
+
+   for ( i = 0 ; i+1 < nr ; i+=2, start += 2 ) {
+      EMIT_TWO_ELTS( 0, start, start+1 );
+      INCR_ELTS( 2 );
+   }
+   if (i < nr) {
+      EMIT_ELT( 0, start );
+      INCR_ELTS( 1 );
+   }
+}
+
+/***********************************************************************
+ *                    Render non-indexed primitives.
+ ***********************************************************************/
+
+
+
+static void TAG(render_points_verts)( GLcontext *ctx,
+				      GLuint start,
+				      GLuint count,
+				      GLuint flags )
+{
+   if (start < count) {
+      LOCAL_VARS;
+      if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+      EMIT_PRIM( ctx, GL_POINTS, HW_POINTS, start, count );
+   }
+}
+
+static void TAG(render_lines_verts)( GLcontext *ctx,
+				     GLuint start,
+				     GLuint count,
+				     GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+   count -= (count-start) & 1;
+
+   if (start+1 >= count)
+      return;
+
+   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag) {
+      RESET_STIPPLE();
+      AUTO_STIPPLE( GL_TRUE );
+   }
+      
+   EMIT_PRIM( ctx, GL_LINES, HW_LINES, start, count );
+
+   if ((flags & PRIM_END) && ctx->Line.StippleFlag)
+      AUTO_STIPPLE( GL_FALSE );
+}
+
+
+static void TAG(render_line_strip_verts)( GLcontext *ctx,
+					  GLuint start,
+					  GLuint count,
+					  GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (start+1 >= count)
+      return;
+
+   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag)
+      RESET_STIPPLE();
+
+
+   if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_LINES ))
+   {   
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      ELT_INIT( GL_LINES, HW_LINES );
+
+      /* Emit whole number of lines in each full buffer.
+       */
+      dmasz = dmasz/2;
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      currentsz = currentsz/2;
+
+      if (currentsz < 4) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start; j + 1 < count; j += nr - 1 ) {
+	 GLint i;
+	 ELTS_VARS;
+	 nr = MIN2( currentsz, count - j );
+	    
+	 ALLOC_ELTS( (nr-1)*2 );
+	    
+	 for ( i = j ; i+1 < j+nr ; i+=1 ) {
+	    EMIT_TWO_ELTS( 0, (i+0), (i+1) );
+	    INCR_ELTS( 2 );
+	 }
+
+	 if (nr == currentsz) {
+	    NEW_BUFFER();
+	    currentsz = dmasz;
+	 }
+      }
+   }
+   else
+      EMIT_PRIM( ctx, GL_LINE_STRIP, HW_LINE_STRIP, start, count );
+}
+
+
+static void TAG(render_line_loop_verts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   LOCAL_VARS;
+   GLuint j, nr;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (flags & PRIM_BEGIN) {
+      j = start;
+      if (ctx->Line.StippleFlag)
+	 RESET_STIPPLE( );
+   }
+   else
+      j = start + 1;
+
+   if (flags & PRIM_END) {
+
+      if (start+1 >= count)
+	 return;
+
+      if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_LINES )) {
+	 int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+	 int currentsz;
+
+	 ELT_INIT( GL_LINES, HW_LINES );
+
+	 /* Emit whole number of lines in each full buffer.
+	  */
+	 dmasz = dmasz/2;
+	 currentsz = GET_CURRENT_VB_MAX_ELTS();
+	 currentsz = currentsz/2;
+
+	 if (currentsz < 4) {
+	    NEW_BUFFER();
+	    currentsz = dmasz;
+	 }
+
+	 /* Ensure last vertex doesn't wrap:
+	  */
+	 currentsz--;
+	 dmasz--;
+
+	 for (; j + 1 < count;  ) {
+	    GLint i;
+	    ELTS_VARS;
+	    nr = MIN2( currentsz, count - j );
+	    
+	    ALLOC_ELTS( (nr-1)*2 );	    
+	    for ( i = j ; i+1 < j+nr ; i+=1 ) {
+	       EMIT_TWO_ELTS( 0, (i+0), (i+1) );
+	       INCR_ELTS( 2 );
+	    }
+
+	    j += nr - 1;
+	    if (j + 1 < count) {
+	       NEW_BUFFER();
+	       currentsz = dmasz;
+	    }
+ 	    else { 
+ 	       ALLOC_ELTS( 2 ); 
+ 	       EMIT_TWO_ELTS( 0, (j), (start) ); 
+ 	       INCR_ELTS( 2 ); 
+ 	    } 
+	 }
+      }
+      else
+      {
+	 int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+	 int currentsz;
+
+	 ELT_INIT( GL_LINE_STRIP, HW_LINE_STRIP );
+
+	 currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+	 if (currentsz < 8) {
+	    NEW_BUFFER();
+	    currentsz = dmasz;
+	 }
+
+	 /* Ensure last vertex doesn't wrap:
+	  */
+	 currentsz--;
+	 dmasz--;
+
+	 for ( ; j + 1 < count;  ) {
+	    nr = MIN2( currentsz, count - j );
+	    if (j + nr < count) {
+	       TAG(emit_consecutive_elts)( ctx, j, nr );
+	       currentsz = dmasz;
+	       j += nr - 1;
+	       NEW_BUFFER();
+	    }
+	    else if (nr) {
+	       ELTS_VARS;
+	       int i;
+
+	       ALLOC_ELTS( nr + 1 );
+	       for ( i = 0 ; i+1 < nr ; i+=2, j += 2 ) {
+		  EMIT_TWO_ELTS( 0, j, j+1 );
+		  INCR_ELTS( 2 );
+	       }
+	       if (i < nr) {
+		  EMIT_ELT( 0, j ); j++;
+		  INCR_ELTS( 1 );
+	       }
+	       EMIT_ELT( 0, start );
+	       INCR_ELTS( 1 );
+	       NEW_BUFFER();
+	    }
+	    else {
+	       fprintf(stderr, "warining nr==0\n");
+	    }
+	 }   
+      }
+   } else {
+      TAG(render_line_strip_verts)( ctx, j, count, flags );
+   }
+}
+
+
+static void TAG(render_triangles_verts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   count -= (count-start)%3;
+
+   if (start+2 >= count) {
+      return;
+   }
+
+   /* need a PREFER_DISCRETE_ELT_PRIM here too..
+    */
+   EMIT_PRIM( ctx, GL_TRIANGLES, HW_TRIANGLES, start, count );
+}
+
+
+
+static void TAG(render_tri_strip_verts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (start + 2 >= count)
+      return;
+
+   if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_TRIANGLES ))
+   {   
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      int parity = 0;
+      GLuint j, nr;
+
+      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+
+      if (flags & PRIM_PARITY)
+	 parity = 1;
+
+      /* Emit even number of tris in each full buffer.
+       */
+      dmasz = dmasz/3;
+      dmasz -= dmasz & 1;
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      currentsz = currentsz/3;
+      currentsz -= currentsz & 1;
+
+      if (currentsz < 4) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start; j + 2 < count; j += nr - 2 ) {
+	 GLint i;
+	 ELTS_VARS;
+	 nr = MIN2( currentsz, count - j );
+	    
+	 ALLOC_ELTS( (nr-2)*3 );
+	    
+	 for ( i = j ; i+2 < j+nr ; i++, parity^=1 ) {
+	    EMIT_ELT( 0, (i+0+parity) );
+	    EMIT_ELT( 1, (i+1-parity) );
+	    EMIT_ELT( 2, (i+2) );
+	    INCR_ELTS( 3 );
+	 }
+
+	 if (nr == currentsz) {
+	    NEW_BUFFER();
+	    currentsz = dmasz;
+	 }
+      }
+   }
+   else if ((flags & PRIM_PARITY) == 0)  
+      EMIT_PRIM( ctx, GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0, start, count );
+   else if (HAVE_TRI_STRIP_1)
+      EMIT_PRIM( ctx, GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_1, start, count );
+   else {
+      /* Emit the first triangle with elts, then the rest as a regular strip.
+       * TODO:  Make this unlikely in t_imm_api.c
+       */
+      ELTS_VARS;
+      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+      ALLOC_ELTS( 3 );
+      EMIT_ELT( 0, (start+1) );
+      EMIT_ELT( 1, (start+0) );
+      EMIT_ELT( 2, (start+2) );
+      INCR_ELTS( 3 );
+      NEW_PRIMITIVE();
+
+      start++;
+      if (start + 2 >= count)
+	 return;
+
+      EMIT_PRIM( ctx, GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0, start, 
+		 count );
+   }
+}
+
+static void TAG(render_tri_fan_verts)( GLcontext *ctx,
+				       GLuint start,
+				       GLuint count,
+				       GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (start+2 >= count) 
+      return;
+
+   if (PREFER_DISCRETE_ELT_PRIM( count-start, HW_TRIANGLES ))
+   {   
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+
+      dmasz = dmasz/3;
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+      currentsz = currentsz/3;
+
+      if (currentsz < 4) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start + 1; j + 1 < count; j += nr - 1 ) {
+	 GLint i;
+	 ELTS_VARS;
+	 nr = MIN2( currentsz, count - j );
+	    
+	 ALLOC_ELTS( (nr-1)*3 );
+	    
+	 for ( i = j ; i+1 < j+nr ; i++ ) {
+	    EMIT_ELT( 0, (start) );
+	    EMIT_ELT( 1, (i) );
+	    EMIT_ELT( 2, (i+1) );
+	    INCR_ELTS( 3 );
+	 }
+
+	 if (nr == currentsz) {
+	    NEW_BUFFER();
+	    currentsz = dmasz;
+	 }
+      }
+   }
+   else {
+      EMIT_PRIM( ctx, GL_TRIANGLE_FAN, HW_TRIANGLE_FAN, start, count );
+   }
+}
+
+
+static void TAG(render_poly_verts)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (start+2 >= count) 
+      return;
+
+   EMIT_PRIM( ctx, GL_POLYGON, HW_POLYGON, start, count );
+}
+
+static void TAG(render_quad_strip_verts)( GLcontext *ctx,
+					  GLuint start,
+					  GLuint count,
+					  GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   count -= (count-start) & 1;
+
+   if (start+3 >= count) 
+      return;
+
+   if (HAVE_QUAD_STRIPS) {
+      EMIT_PRIM( ctx, GL_QUAD_STRIP, HW_QUAD_STRIP, start, count );
+   } 
+   else if (ctx->_TriangleCaps & DD_FLATSHADE) {
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+      /* Emit whole number of quads in total, and in each buffer.
+       */
+      currentsz = (currentsz/6)*2;
+      dmasz = (dmasz/6)*2;
+
+      if (currentsz < 4) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start; j + 3 < count; j += nr - 2 ) {
+	 ELTS_VARS;
+	 GLint quads, i;
+
+	 nr = MIN2( currentsz, count - j );
+	 quads = (nr/2)-1;
+	    
+	 ALLOC_ELTS( quads*6 );
+	    
+	 for ( i = j ; i < j+quads*2 ; i+=2 ) {
+	    EMIT_TWO_ELTS( 0, (i+0), (i+1) );
+	    EMIT_TWO_ELTS( 2, (i+2), (i+1) );
+	    EMIT_TWO_ELTS( 4, (i+3), (i+2) );
+	    INCR_ELTS( 6 );
+	 }
+
+	 if (nr == currentsz) {
+	    NEW_BUFFER();
+	    currentsz = dmasz;
+	 }
+      }
+   }
+   else {
+      EMIT_PRIM( ctx, GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0, start, count );
+   }
+}
+
+
+static void TAG(render_quads_verts)( GLcontext *ctx,
+				     GLuint start,
+				     GLuint count,
+				     GLuint flags )
+{
+   LOCAL_VARS;
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+   count -= (count-start)%4;
+
+   if (start+3 >= count) 
+      return;
+
+   if (HAVE_QUADS) {
+      EMIT_PRIM( ctx, HW_QUADS, GL_QUADS, start, count );
+   } 
+   else {
+      /* Hardware doesn't have a quad primitive type -- simulate it
+       * using indexed vertices and the triangle primitive: 
+       */
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+      /* Adjust for rendering as triangles:
+       */
+      currentsz = (currentsz/6)*4;
+      dmasz = (dmasz/6)*4;
+
+      if (currentsz < 8) {
+	 NEW_BUFFER();
+	 currentsz = dmasz;
+      }
+
+      for (j = start; j < count; j += nr ) {
+	 ELTS_VARS;
+	 GLint quads, i;
+	 nr = MIN2( currentsz, count - j );
+	 quads = nr/4;
+
+	 ALLOC_ELTS( quads*6 );
+
+	 for ( i = j ; i < j+quads*4 ; i+=4 ) {
+	    EMIT_TWO_ELTS( 0, (i+0), (i+1) );
+	    EMIT_TWO_ELTS( 2, (i+3), (i+1) );
+	    EMIT_TWO_ELTS( 4, (i+2), (i+3) );
+	    INCR_ELTS( 6 );
+	 }
+
+	 if (nr == currentsz) {
+	    NEW_BUFFER();
+	    currentsz = dmasz;
+	 }
+      }
+   }
+}
+
+static void TAG(render_noop)( GLcontext *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+}
+
+
+
+
+static render_func TAG(render_tab_verts)[GL_POLYGON+2] =
+{
+   TAG(render_points_verts),
+   TAG(render_lines_verts),
+   TAG(render_line_loop_verts),
+   TAG(render_line_strip_verts),
+   TAG(render_triangles_verts),
+   TAG(render_tri_strip_verts),
+   TAG(render_tri_fan_verts),
+   TAG(render_quads_verts),
+   TAG(render_quad_strip_verts),
+   TAG(render_poly_verts),
+   TAG(render_noop),
+};
+
+
+/****************************************************************************
+ *                 Render elts using hardware indexed verts                 *
+ ****************************************************************************/
+
+static void TAG(render_points_elts)( GLcontext *ctx,
+				     GLuint start,
+				     GLuint count,
+				     GLuint flags )
+{
+   LOCAL_VARS;
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+   int currentsz;
+   GLuint *elts = GET_ELTS();
+   GLuint j, nr;
+
+   ELT_INIT( GL_POINTS, HW_POINTS );
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+   if (currentsz < 8)
+      currentsz = dmasz;
+
+   for (j = start; j < count; j += nr ) {
+      nr = MIN2( currentsz, count - j );
+      TAG(emit_elts)( ctx, elts+j, nr );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+}
+
+
+
+static void TAG(render_lines_elts)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   LOCAL_VARS;
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+   int currentsz;
+   GLuint *elts = GET_ELTS();
+   GLuint j, nr;
+
+   if (start+1 >= count)
+      return;
+
+   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag) {
+      RESET_STIPPLE();
+      AUTO_STIPPLE( GL_TRUE );
+   }
+
+   ELT_INIT( GL_LINES, HW_LINES );
+
+   /* Emit whole number of lines in total and in each buffer:
+    */
+   count -= (count-start) & 1;
+   currentsz -= currentsz & 1;
+   dmasz -= dmasz & 1;
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+   if (currentsz < 8)
+      currentsz = dmasz;
+
+   for (j = start; j < count; j += nr ) {
+      nr = MIN2( currentsz, count - j );
+      TAG(emit_elts)( ctx, elts+j, nr );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+
+   if ((flags & PRIM_END) && ctx->Line.StippleFlag)
+      AUTO_STIPPLE( GL_FALSE );
+}
+
+
+static void TAG(render_line_strip_elts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   LOCAL_VARS;
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+   int currentsz;
+   GLuint *elts = GET_ELTS();
+   GLuint j, nr;
+
+   if (start+1 >= count)
+      return;
+
+   ELT_INIT( GL_LINE_STRIP, HW_LINE_STRIP );
+
+   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag)
+      RESET_STIPPLE();
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+   if (currentsz < 8)
+      currentsz = dmasz;
+
+   for (j = start; j + 1 < count; j += nr - 1 ) {
+      nr = MIN2( currentsz, count - j );
+      TAG(emit_elts)( ctx, elts+j, nr );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+}
+
+
+static void TAG(render_line_loop_elts)( GLcontext *ctx,
+					GLuint start,
+					GLuint count,
+					GLuint flags )
+{
+   LOCAL_VARS;
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+   int currentsz;
+   GLuint *elts = GET_ELTS();
+   GLuint j, nr;
+
+   if (0) fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (flags & PRIM_BEGIN)
+      j = start;
+   else
+      j = start + 1;
+
+   
+   if (flags & PRIM_END) {
+      if (start+1 >= count)
+	 return;
+   } 
+   else {
+      if (j+1 >= count)
+	 return;
+   }
+
+   ELT_INIT( GL_LINE_STRIP, HW_LINE_STRIP );
+
+   if ((flags & PRIM_BEGIN) && ctx->Line.StippleFlag)
+      RESET_STIPPLE();
+
+   
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+   if (currentsz < 8) {
+      NEW_BUFFER();
+      currentsz = dmasz;
+   }
+
+   /* Ensure last vertex doesn't wrap:
+    */
+   currentsz--;
+   dmasz--;
+
+   for ( ; j + 1 < count; j += nr - 1 ) {
+      nr = MIN2( currentsz, count - j );
+      TAG(emit_elts)( ctx, elts+j, nr );
+      currentsz = dmasz;
+   }
+
+   if (flags & PRIM_END)
+      TAG(emit_elts)( ctx, elts+start, 1 );
+
+   NEW_PRIMITIVE();
+}
+
+
+static void TAG(render_triangles_elts)( GLcontext *ctx,
+					GLuint start,
+					GLuint count,
+					GLuint flags )
+{
+   LOCAL_VARS;
+   GLuint *elts = GET_ELTS();
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS()/3*3;
+   int currentsz;
+   GLuint j, nr;
+
+   if (start+2 >= count)
+      return;
+
+/*     NEW_PRIMITIVE(); */
+   ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+   /* Emit whole number of tris in total.  dmasz is already a multiple
+    * of 3.
+    */
+   count -= (count-start)%3;
+   currentsz -= currentsz%3;
+   if (currentsz < 8)
+      currentsz = dmasz;
+
+   for (j = start; j < count; j += nr) {
+      nr = MIN2( currentsz, count - j );
+      TAG(emit_elts)( ctx, elts+j, nr );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+}
+
+
+
+static void TAG(render_tri_strip_elts)( GLcontext *ctx,
+					GLuint start,
+					GLuint count,
+					GLuint flags )
+{
+   LOCAL_VARS;
+   GLuint j, nr;
+   GLuint *elts = GET_ELTS();
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+   int currentsz;
+
+   if (start+2 >= count)
+      return;
+
+   ELT_INIT( GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0 );
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+   if (currentsz < 8) {
+      NEW_BUFFER();
+      currentsz = dmasz;
+   }
+
+   if ((flags & PRIM_PARITY) && count - start > 2) {
+      TAG(emit_elts)( ctx, elts+start, 1 );
+      currentsz--;
+   }
+
+   /* Keep the same winding over multiple buffers:
+    */
+   dmasz -= (dmasz & 1);
+   currentsz -= (currentsz & 1);
+
+   for (j = start ; j + 2 < count; j += nr - 2 ) {
+      nr = MIN2( currentsz, count - j );
+      TAG(emit_elts)( ctx, elts+j, nr );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+}
+
+static void TAG(render_tri_fan_elts)( GLcontext *ctx,
+				      GLuint start,
+				      GLuint count,
+				      GLuint flags )
+{
+   LOCAL_VARS;
+   GLuint *elts = GET_ELTS();
+   GLuint j, nr;
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+   int currentsz;
+
+   if (start+2 >= count)
+      return;
+
+   ELT_INIT( GL_TRIANGLE_FAN, HW_TRIANGLE_FAN );
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+   if (currentsz < 8) {
+      NEW_BUFFER();
+      currentsz = dmasz;
+   }
+
+   for (j = start + 1 ; j + 1 < count; j += nr - 1 ) {
+      nr = MIN2( currentsz, count - j + 1 );
+      TAG(emit_elts)( ctx, elts+start, 1 );
+      TAG(emit_elts)( ctx, elts+j, nr - 1 );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+}
+
+
+static void TAG(render_poly_elts)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   LOCAL_VARS;
+   GLuint *elts = GET_ELTS();
+   GLuint j, nr;
+   int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+   int currentsz;
+
+   if (start+2 >= count)
+      return;
+
+   ELT_INIT( GL_POLYGON, HW_POLYGON );
+
+   currentsz = GET_CURRENT_VB_MAX_ELTS();
+   if (currentsz < 8) {
+      NEW_BUFFER();
+      currentsz = dmasz;
+   }
+
+   for (j = start + 1 ; j + 1 < count ; j += nr - 1 ) {
+      nr = MIN2( currentsz, count - j + 1 );
+      TAG(emit_elts)( ctx, elts+start, 1 );
+      TAG(emit_elts)( ctx, elts+j, nr - 1 );
+      NEW_PRIMITIVE();
+      currentsz = dmasz;
+   }
+}
+
+static void TAG(render_quad_strip_elts)( GLcontext *ctx,
+					 GLuint start,
+					 GLuint count,
+					 GLuint flags )
+{
+   if (start+3 >= count)
+      return;
+
+   if (HAVE_QUAD_STRIPS && 0) {
+   }
+   else {
+      LOCAL_VARS;
+      GLuint *elts = GET_ELTS();
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      NEW_PRIMITIVE();
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+      /* Emit whole number of quads in total, and in each buffer.
+       */
+      dmasz -= dmasz & 1;
+      count -= (count-start) & 1;
+      currentsz -= currentsz & 1;
+
+      if (currentsz < 12)
+	 currentsz = dmasz;
+
+      if (ctx->_TriangleCaps & DD_FLATSHADE) {
+	 ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+
+	 currentsz = currentsz/6*2;
+	 dmasz = dmasz/6*2;
+
+	 for (j = start; j + 3 < count; j += nr - 2 ) {
+	    nr = MIN2( currentsz, count - j );
+
+	    if (nr >= 4)
+	    {
+	       GLint i;
+	       GLint quads = (nr/2)-1;
+	       ELTS_VARS;
+
+	       ALLOC_ELTS( quads*6 );
+
+	       for ( i = j-start ; i < j-start+quads ; i++, elts += 2 ) {
+		  EMIT_TWO_ELTS( 0, elts[0], elts[1] );
+		  EMIT_TWO_ELTS( 2, elts[2], elts[1] );
+		  EMIT_TWO_ELTS( 4, elts[3], elts[2] );
+		  INCR_ELTS( 6 );
+	       }
+
+	       NEW_PRIMITIVE();
+	    }
+
+	    currentsz = dmasz;
+	 }
+      }
+      else {
+	 ELT_INIT( GL_TRIANGLE_STRIP, HW_TRIANGLE_STRIP_0 );
+
+	 for (j = start; j + 3 < count; j += nr - 2 ) {
+	    nr = MIN2( currentsz, count - j );
+	    TAG(emit_elts)( ctx, elts+j, nr );
+	    NEW_PRIMITIVE();
+	    currentsz = dmasz;
+	 }
+      }
+   }
+}
+
+
+static void TAG(render_quads_elts)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   if (start+3 >= count)
+      return;
+
+   if (HAVE_QUADS && 0) {
+   } else {
+      LOCAL_VARS;
+      GLuint *elts = GET_ELTS();
+      int dmasz = GET_SUBSEQUENT_VB_MAX_ELTS();
+      int currentsz;
+      GLuint j, nr;
+
+      ELT_INIT( GL_TRIANGLES, HW_TRIANGLES );
+      currentsz = GET_CURRENT_VB_MAX_ELTS();
+
+      /* Emit whole number of quads in total, and in each buffer.
+       */
+      dmasz -= dmasz & 3;
+      count -= (count-start) & 3;
+      currentsz -= currentsz & 3;
+
+      /* Adjust for rendering as triangles:
+       */
+      currentsz = currentsz/6*4;
+      dmasz = dmasz/6*4;
+
+      if (currentsz < 8)
+	 currentsz = dmasz;
+
+      for (j = start; j + 3 < count; j += nr - 2 ) {
+	 nr = MIN2( currentsz, count - j );
+
+	 if (nr >= 4)
+	 {
+	    GLint quads = nr/4;
+	    GLint i;
+	    ELTS_VARS;
+	    ALLOC_ELTS( quads * 6 );
+
+	    for ( i = j-start ; i < j-start+quads ; i++, elts += 4 ) {
+	       EMIT_TWO_ELTS( 0, elts[0], elts[1] );
+	       EMIT_TWO_ELTS( 2, elts[3], elts[1] );
+	       EMIT_TWO_ELTS( 4, elts[2], elts[3] );
+	       INCR_ELTS( 6 );
+	    }
+	 }
+
+	 NEW_PRIMITIVE();
+	 currentsz = dmasz;
+      }
+   }
+}
+
+
+
+static render_func TAG(render_tab_elts)[GL_POLYGON+2] =
+{
+   TAG(render_points_elts),
+   TAG(render_lines_elts),
+   TAG(render_line_loop_elts),
+   TAG(render_line_strip_elts),
+   TAG(render_triangles_elts),
+   TAG(render_tri_strip_elts),
+   TAG(render_tri_fan_elts),
+   TAG(render_quads_elts),
+   TAG(render_quad_strip_elts),
+   TAG(render_poly_elts),
+   TAG(render_noop),
+};
Index: xc/extras/Mesa/src/tnl_dd/t_dd_rendertmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_rendertmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_rendertmp.h	Mon Dec 16 11:18:48 2002
@@ -0,0 +1,437 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+#ifndef POSTFIX
+#define POSTFIX
+#endif
+
+#ifndef INIT
+#define INIT(x)
+#endif
+
+#ifndef NEED_EDGEFLAG_SETUP
+#define NEED_EDGEFLAG_SETUP 0
+#define EDGEFLAG_GET(a) 0
+#define EDGEFLAG_SET(a,b) (void)b
+#endif
+
+#ifndef RESET_STIPPLE
+#define RESET_STIPPLE
+#endif
+
+#ifndef RESET_OCCLUSION
+#define RESET_OCCLUSION
+#endif
+
+#ifndef TEST_PRIM_END
+#define TEST_PRIM_END(flags) (flags & PRIM_END)
+#define TEST_PRIM_BEGIN(flags) (flags & PRIM_BEGIN)
+#define TEST_PRIM_PARITY(flags) (flags & PRIM_PARITY)
+#endif
+
+#ifndef ELT
+#define ELT(x) x
+#endif
+
+#ifndef RENDER_TAB_QUALIFIER
+#define RENDER_TAB_QUALIFIER static
+#endif
+
+static void TAG(render_points)( GLcontext *ctx,
+				GLuint start,
+				GLuint count,
+				GLuint flags )
+{
+   LOCAL_VARS;
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_POINTS);
+   RENDER_POINTS( start, count );
+   POSTFIX;
+}
+
+static void TAG(render_lines)( GLcontext *ctx,
+			       GLuint start,
+			       GLuint count,
+			       GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_LINES);
+   for (j=start+1; j<count; j+=2 ) {
+      RENDER_LINE( ELT(j-1), ELT(j) );
+      RESET_STIPPLE;
+   }
+   POSTFIX;
+}
+
+
+static void TAG(render_line_strip)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_LINE_STRIP);
+
+   for (j=start+1; j<count; j++ )
+      RENDER_LINE( ELT(j-1), ELT(j) );
+
+   if (TEST_PRIM_END(flags))
+      RESET_STIPPLE;
+
+   POSTFIX;
+}
+
+
+static void TAG(render_line_loop)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint i;
+   LOCAL_VARS;
+
+   (void) flags;
+
+   RESET_OCCLUSION;
+   INIT(GL_LINE_LOOP);
+
+   if (start+1 < count) {
+      if (TEST_PRIM_BEGIN(flags)) {
+	 RENDER_LINE( ELT(start), ELT(start+1) );
+      }
+
+      for ( i = start+2 ; i < count ; i++) {
+	 RENDER_LINE( ELT(i-1), ELT(i) );
+      }
+
+      if ( TEST_PRIM_END(flags)) {
+	 RENDER_LINE( ELT(count-1), ELT(start) );
+	 RESET_STIPPLE;
+      }
+   }
+
+   POSTFIX;
+}
+
+
+static void TAG(render_triangles)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_TRIANGLES);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2; j<count; j+=3) {
+	 /* Leave the edgeflags as supplied by the user.
+	  */
+	 RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
+	 RESET_STIPPLE;
+      }
+   } else {
+      for (j=start+2; j<count; j+=3) {
+	 RENDER_TRI( ELT(j-2), ELT(j-1), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+
+
+static void TAG(render_tri_strip)( GLcontext *ctx,
+				   GLuint start,
+				   GLuint count,
+				   GLuint flags )
+{
+   GLuint j;
+   GLuint parity = 0;
+   LOCAL_VARS;
+
+   if (TEST_PRIM_PARITY(flags))
+      parity = 1;
+
+   INIT(GL_TRIANGLE_STRIP);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2;j<count;j++,parity^=1) {
+	 GLuint ej2 = ELT(j-2+parity);
+	 GLuint ej1 = ELT(j-1-parity);
+	 GLuint ej = ELT(j);
+	 GLboolean ef2 = EDGEFLAG_GET( ej2 );
+	 GLboolean ef1 = EDGEFLAG_GET( ej1 );
+	 GLboolean ef = EDGEFLAG_GET( ej );
+	 EDGEFLAG_SET( ej2, GL_TRUE );
+	 EDGEFLAG_SET( ej1, GL_TRUE );
+	 EDGEFLAG_SET( ej, GL_TRUE );
+	 RENDER_TRI( ej2, ej1, ej );
+	 EDGEFLAG_SET( ej2, ef2 );
+	 EDGEFLAG_SET( ej1, ef1 );
+	 EDGEFLAG_SET( ej, ef );
+	 RESET_STIPPLE;
+      }
+   } else {
+      for (j=start+2; j<count ; j++, parity^=1) {
+	 RENDER_TRI( ELT(j-2+parity), ELT(j-1-parity), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+
+static void TAG(render_tri_fan)( GLcontext *ctx,
+				 GLuint start,
+				 GLuint count,
+				 GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_TRIANGLE_FAN);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+2;j<count;j++) {
+	 /* For trifans, all edges are boundary.
+	  */
+	 GLuint ejs = ELT(start);
+	 GLuint ej1 = ELT(j-1);
+	 GLuint ej = ELT(j);
+	 GLboolean efs = EDGEFLAG_GET( ejs );
+	 GLboolean ef1 = EDGEFLAG_GET( ej1 );
+	 GLboolean ef = EDGEFLAG_GET( ej );
+	 EDGEFLAG_SET( ejs, GL_TRUE );
+	 EDGEFLAG_SET( ej1, GL_TRUE );
+	 EDGEFLAG_SET( ej, GL_TRUE );
+	 RENDER_TRI( ejs, ej1, ej);
+	 EDGEFLAG_SET( ejs, efs );
+	 EDGEFLAG_SET( ej1, ef1 );
+	 EDGEFLAG_SET( ej, ef );
+	 RESET_STIPPLE;
+      }
+   } else {
+      for (j=start+2;j<count;j++) {
+	 RENDER_TRI( ELT(start), ELT(j-1), ELT(j) );
+      }
+   }
+
+   POSTFIX;
+}
+
+
+static void TAG(render_poly)( GLcontext *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+   GLuint j = start+2;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_POLYGON);
+   if (NEED_EDGEFLAG_SETUP) {
+      GLboolean efstart = EDGEFLAG_GET( ELT(start) );
+      GLboolean efcount = EDGEFLAG_GET( ELT(count-1) );
+
+      /* If the primitive does not begin here, the first edge
+       * is non-boundary.
+       */
+      if (!TEST_PRIM_BEGIN(flags))
+	 EDGEFLAG_SET( ELT(start), GL_FALSE );
+
+      /* If the primitive does not end here, the final edge is
+       * non-boundary.
+       */
+      if (!TEST_PRIM_END(flags))
+	 EDGEFLAG_SET( ELT(count-1), GL_FALSE );
+
+      /* Draw the first triangles (possibly zero)
+       */
+      if (j<count-1) {
+	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
+	 EDGEFLAG_SET( ELT(j), GL_FALSE );
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+	 EDGEFLAG_SET( ELT(j), ef );
+	 j++;
+
+	 /* Don't render the first edge again:
+	  */
+	 EDGEFLAG_SET( ELT(start), GL_FALSE );
+
+	 for (;j<count-1;j++) {
+	    GLboolean efj = EDGEFLAG_GET( ELT(j) );
+	    EDGEFLAG_SET( ELT(j), GL_FALSE );
+	    RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+	    EDGEFLAG_SET( ELT(j), efj );
+	 }
+      }
+
+      /* Draw the last or only triangle
+       */
+      if (j < count)
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+
+      /* Restore the first and last edgeflags:
+       */
+      EDGEFLAG_SET( ELT(count-1), efcount );
+      EDGEFLAG_SET( ELT(start), efstart );
+
+      if (TEST_PRIM_END(flags)) {
+	 RESET_STIPPLE;
+      }
+   }
+   else {
+      for (j=start+2;j<count;j++) {
+	 RENDER_TRI( ELT(j-1), ELT(j), ELT(start) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_quads)( GLcontext *ctx,
+			       GLuint start,
+			       GLuint count,
+			       GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_QUADS);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+3; j<count; j+=4) {
+	 /* Use user-specified edgeflags for quads.
+	  */
+	 RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
+	 RESET_STIPPLE;
+      }
+   } else {
+      for (j=start+3; j<count; j+=4) {
+	 RENDER_QUAD( ELT(j-3), ELT(j-2), ELT(j-1), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_quad_strip)( GLcontext *ctx,
+				    GLuint start,
+				    GLuint count,
+				    GLuint flags )
+{
+   GLuint j;
+   LOCAL_VARS;
+   (void) flags;
+
+   INIT(GL_QUAD_STRIP);
+   if (NEED_EDGEFLAG_SETUP) {
+      for (j=start+3;j<count;j+=2) {
+	 /* All edges are boundary.  Set edgeflags to 1, draw the
+	  * quad, and restore them to the original values.
+	  */
+	 GLboolean ef3 = EDGEFLAG_GET( ELT(j-3) );
+	 GLboolean ef2 = EDGEFLAG_GET( ELT(j-2) );
+	 GLboolean ef1 = EDGEFLAG_GET( ELT(j-1) );
+	 GLboolean ef = EDGEFLAG_GET( ELT(j) );
+	 EDGEFLAG_SET( ELT(j-3), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j-2), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j-1), GL_TRUE );
+	 EDGEFLAG_SET( ELT(j), GL_TRUE );
+	 RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
+	 EDGEFLAG_SET( ELT(j-3), ef3 );
+	 EDGEFLAG_SET( ELT(j-2), ef2 );
+	 EDGEFLAG_SET( ELT(j-1), ef1 );
+	 EDGEFLAG_SET( ELT(j), ef );
+	 RESET_STIPPLE;
+      }
+   } else {
+      for (j=start+3;j<count;j+=2) {
+	 RENDER_QUAD( ELT(j-1), ELT(j-3), ELT(j-2), ELT(j) );
+      }
+   }
+   POSTFIX;
+}
+
+static void TAG(render_noop)( GLcontext *ctx,
+			      GLuint start,
+			      GLuint count,
+			      GLuint flags )
+{
+   (void)(ctx && start && count && flags);
+}
+
+RENDER_TAB_QUALIFIER void (*TAG(render_tab)[GL_POLYGON+2])(GLcontext *,
+							   GLuint,
+							   GLuint,
+							   GLuint) =
+{
+   TAG(render_points),
+   TAG(render_lines),
+   TAG(render_line_loop),
+   TAG(render_line_strip),
+   TAG(render_triangles),
+   TAG(render_tri_strip),
+   TAG(render_tri_fan),
+   TAG(render_quads),
+   TAG(render_quad_strip),
+   TAG(render_poly),
+   TAG(render_noop),
+};
+
+
+
+#ifndef PRESERVE_VB_DEFS
+#undef RENDER_TRI
+#undef RENDER_QUAD
+#undef RENDER_LINE
+#undef RENDER_POINTS
+#undef LOCAL_VARS
+#undef INIT
+#undef POSTFIX
+#undef RESET_STIPPLE
+#undef DBG
+#undef ELT
+#undef RENDER_TAB_QUALIFIER
+#endif
+
+#ifndef PRESERVE_TAG
+#undef TAG
+#endif
+
+#undef PRESERVE_VB_DEFS
+#undef PRESERVE_TAG
Index: xc/extras/Mesa/src/tnl_dd/t_dd_triemit.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_triemit.h:1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_triemit.h	Wed Oct 30 07:51:24 2002
@@ -0,0 +1,158 @@
+/* $XFree86: xc/extras/Mesa/src/tnl_dd/t_dd_triemit.h,v 1.1 2002/10/30 12:51:24 alanh Exp $ */
+#ifndef DO_DEBUG_VERTS
+#define DO_DEBUG_VERTS 0
+#endif 
+
+#ifndef PRINT_VERTEX
+#define PRINT_VERTEX(x) 
+#endif
+
+#if defined(USE_X86_ASM)
+#define COPY_DWORDS( j, vb, vertsize, v )				\
+do {									\
+	int __tmp;							\
+	__asm__ __volatile__( "rep ; movsl"				\
+			      : "=%c" (j), "=D" (vb), "=S" (__tmp)	\
+			      : "0" (vertsize),				\
+			        "D" ((long)vb),				\
+			        "S" ((long)v) );			\
+} while (0)
+#else
+#define COPY_DWORDS( j, vb, vertsize, v )				\
+do {									\
+   for ( j = 0 ; j < vertsize ; j++ )					\
+      vb[j] = ((GLuint *)v)[j];						\
+   vb += vertsize;							\
+} while (0)
+#endif
+
+
+
+#if HAVE_QUADS
+static __inline void TAG(quad)( CTX_ARG,
+				VERTEX *v0,
+				VERTEX *v1,
+				VERTEX *v2,
+				VERTEX *v3 )
+{
+   GLuint vertsize = GET_VERTEX_DWORDS();
+   GLuint *vb = (GLuint *)ALLOC_VERTS( 4, vertsize);
+   GLuint j;
+
+   if (DO_DEBUG_VERTS) {
+      fprintf(stderr, "%s\n", __FUNCTION__);
+      PRINT_VERTEX(v0);
+      PRINT_VERTEX(v1);
+      PRINT_VERTEX(v2);
+      PRINT_VERTEX(v3);
+   }
+      
+   COPY_DWORDS( j, vb, vertsize, v0 );
+   COPY_DWORDS( j, vb, vertsize, v1 );
+   COPY_DWORDS( j, vb, vertsize, v2 );
+   COPY_DWORDS( j, vb, vertsize, v3 );
+}
+#else
+static __inline void TAG(quad)( CTX_ARG,
+				VERTEX *v0,
+				VERTEX *v1,
+				VERTEX *v2,
+				VERTEX *v3 )
+{
+   GLuint vertsize = GET_VERTEX_DWORDS();
+   GLuint *vb = (GLuint *)ALLOC_VERTS(  6, vertsize);
+   GLuint j;
+
+   if (DO_DEBUG_VERTS) {
+      fprintf(stderr, "%s\n", __FUNCTION__);
+      PRINT_VERTEX(v0);
+      PRINT_VERTEX(v1);
+      PRINT_VERTEX(v2);
+      PRINT_VERTEX(v3);
+   }
+ 
+   COPY_DWORDS( j, vb, vertsize, v0 );
+   COPY_DWORDS( j, vb, vertsize, v1 );
+   COPY_DWORDS( j, vb, vertsize, v3 );
+   COPY_DWORDS( j, vb, vertsize, v1 );
+   COPY_DWORDS( j, vb, vertsize, v2 );
+   COPY_DWORDS( j, vb, vertsize, v3 );
+}
+#endif
+
+
+static __inline void TAG(triangle)( CTX_ARG,
+				    VERTEX *v0,
+				    VERTEX *v1,
+				    VERTEX *v2 )
+{
+   GLuint vertsize = GET_VERTEX_DWORDS();
+   GLuint *vb = (GLuint *)ALLOC_VERTS( 3, vertsize);
+   GLuint j;
+
+   if (DO_DEBUG_VERTS) {
+      fprintf(stderr, "%s\n", __FUNCTION__);
+      PRINT_VERTEX(v0);
+      PRINT_VERTEX(v1);
+      PRINT_VERTEX(v2);
+   }
+
+   COPY_DWORDS( j, vb, vertsize, v0 );
+   COPY_DWORDS( j, vb, vertsize, v1 );
+   COPY_DWORDS( j, vb, vertsize, v2 );
+}
+
+
+#if HAVE_LINES
+static __inline void TAG(line)( CTX_ARG,
+				VERTEX *v0,
+				VERTEX *v1 )
+{
+   GLuint vertsize = GET_VERTEX_DWORDS();
+   GLuint *vb = (GLuint *)ALLOC_VERTS( 2, vertsize);
+   GLuint j;
+
+   COPY_DWORDS( j, vb, vertsize, v0 );
+   COPY_DWORDS( j, vb, vertsize, v1 );
+}
+#endif
+
+#if HAVE_POINTS
+static __inline void TAG(point)( CTX_ARG,
+				 VERTEX *v0 )
+{
+   GLuint vertsize = GET_VERTEX_DWORDS();
+   GLuint *vb = (GLuint *)ALLOC_VERTS( 1, vertsize);
+   int j;
+
+   COPY_DWORDS( j, vb, vertsize, v0 );
+}
+#endif
+
+
+static void TAG(fast_clipped_poly)( GLcontext *ctx, const GLuint *elts,
+				    GLuint n )
+{
+   LOCAL_VARS
+   GLuint vertsize = GET_VERTEX_DWORDS();
+   GLuint *vb = (GLuint *)ALLOC_VERTS( (n-2) * 3, vertsize );
+   const GLuint *start = (const GLuint *)VERT(elts[0]);
+   int i,j;
+
+   if (DO_DEBUG_VERTS) {
+      fprintf(stderr, "%s\n", __FUNCTION__);
+      PRINT_VERTEX(VERT(elts[0]));
+      PRINT_VERTEX(VERT(elts[1]));
+   }
+
+   for (i = 2 ; i < n ; i++) {
+      if (DO_DEBUG_VERTS) {
+	 PRINT_VERTEX(VERT(elts[i]));
+      }
+
+      COPY_DWORDS( j, vb, vertsize, VERT(elts[i-1]) );
+      COPY_DWORDS( j, vb, vertsize, VERT(elts[i]) );
+      COPY_DWORDS( j, vb, vertsize, start );
+   }
+}
+
Index: xc/extras/Mesa/src/tnl_dd/t_dd_tritmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_tritmp.h:1.2
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_tritmp.h	Mon Dec 16 11:18:48 2002
@@ -0,0 +1,739 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+/* Template for building functions to plug into the driver interface
+ * of t_vb_render.c:
+ *     ctx->Driver.QuadFunc
+ *     ctx->Driver.TriangleFunc
+ *     ctx->Driver.LineFunc
+ *     ctx->Driver.PointsFunc
+ *
+ * DO_TWOSIDE:   Plug back-color values from the VB into backfacing triangles,
+ *               and restore vertices afterwards.
+ * DO_OFFSET:    Calculate offset for triangles and adjust vertices.  Restore
+ *               vertices after rendering.
+ * DO_FLAT:      For hardware without native flatshading, copy provoking colors
+ *               into the other vertices.  Restore after rendering.
+ * DO_UNFILLED:  Decompose triangles to lines and points where appropriate.
+ *
+ * HAVE_RGBA: Vertices have rgba values (otherwise index values).
+ * HAVE_SPEC: Vertices have secondary rgba values.
+ *
+ * VERT_X(v): Alias for vertex x value.
+ * VERT_Y(v): Alias for vertex y value.
+ * VERT_Z(v): Alias for vertex z value.
+ * DEPTH_SCALE: Scale for offset.
+ *
+ * VERTEX: Hardware vertex type.
+ * GET_VERTEX(n): Retreive vertex with index n.
+ * AREA_IS_CCW(a): Return true if triangle with signed area a is ccw.
+ *
+ * VERT_SET_RGBA: Assign vertex rgba from VB color.
+ * VERT_COPY_RGBA: Copy vertex rgba another vertex.
+ * VERT_SAVE_RGBA: Save vertex rgba to a local variable.
+ * VERT_RESTORE_RGBA: Restore vertex rgba from a local variable.
+ *   --> Similar for IND and SPEC.
+ *
+ * LOCAL_VARS(n): (At least) define local vars for save/restore rgba.
+ *
+ */
+
+#if HAVE_RGBA
+#define VERT_SET_IND( v, c ) (void) c
+#define VERT_COPY_IND( v0, v1 )
+#define VERT_SAVE_IND( idx )
+#define VERT_RESTORE_IND( idx )
+#if HAVE_BACK_COLORS
+#define VERT_SET_RGBA( v, c )
+#endif
+#else
+#define VERT_SET_RGBA( v, c ) (void) c
+#define VERT_COPY_RGBA( v0, v1 )
+#define VERT_SAVE_RGBA( idx )
+#define VERT_RESTORE_RGBA( idx )
+#if HAVE_BACK_COLORS
+#define VERT_SET_IND( v, c )
+#endif
+#endif
+
+#if !HAVE_SPEC
+#define VERT_SET_SPEC( v, c ) (void) c
+#define VERT_COPY_SPEC( v0, v1 )
+#define VERT_SAVE_SPEC( idx )
+#define VERT_RESTORE_SPEC( idx )
+#if HAVE_BACK_COLORS
+#define VERT_COPY_SPEC1( v )
+#endif
+#else
+#if HAVE_BACK_COLORS
+#define VERT_SET_SPEC( v, c )
+#endif
+#endif
+
+#if !HAVE_BACK_COLORS
+#define VERT_COPY_SPEC1( v )
+#define VERT_COPY_IND1( v )
+#define VERT_COPY_RGBA1( v )
+#endif
+
+#ifndef INSANE_VERTICES
+#define VERT_SET_Z(v,val) VERT_Z(v) = val
+#define VERT_Z_ADD(v,val) VERT_Z(v) += val
+#endif
+
+#if DO_TRI
+static void TAG(triangle)( GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2 )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
+   VERTEX *v[3];
+   GLfloat offset;
+   GLfloat z[3];
+   GLenum mode = GL_FILL;
+   GLuint facing;
+   LOCAL_VARS(3);
+
+/*     fprintf(stderr, "%s\n", __FUNCTION__); */
+
+   v[0] = (VERTEX *)GET_VERTEX(e0);
+   v[1] = (VERTEX *)GET_VERTEX(e1);
+   v[2] = (VERTEX *)GET_VERTEX(e2);
+
+   if (DO_TWOSIDE || DO_OFFSET || DO_UNFILLED)
+   {
+      GLfloat ex = VERT_X(v[0]) - VERT_X(v[2]);
+      GLfloat ey = VERT_Y(v[0]) - VERT_Y(v[2]);
+      GLfloat fx = VERT_X(v[1]) - VERT_X(v[2]);
+      GLfloat fy = VERT_Y(v[1]) - VERT_Y(v[2]);
+      GLfloat cc = ex*fy - ey*fx;
+
+      if (DO_TWOSIDE || DO_UNFILLED)
+      {
+	 facing = AREA_IS_CCW( cc ) ^ ctx->Polygon._FrontBit;
+
+	 if (DO_UNFILLED) {
+	    if (facing) {
+	       mode = ctx->Polygon.BackMode;
+	       if (ctx->Polygon.CullFlag &&
+		   ctx->Polygon.CullFaceMode != GL_FRONT) {
+		  return;
+	       }
+	    } else {
+	       mode = ctx->Polygon.FrontMode;
+	       if (ctx->Polygon.CullFlag &&
+		   ctx->Polygon.CullFaceMode != GL_BACK) {
+		  return;
+	       }
+	    }
+	 }
+
+	 if (DO_TWOSIDE && facing == 1)
+	 {
+	    if (HAVE_RGBA) {
+	       if (HAVE_BACK_COLORS) {
+		  if (!DO_FLAT) {
+		     VERT_SAVE_RGBA( 0 );
+		     VERT_SAVE_RGBA( 1 );
+		     VERT_COPY_RGBA1( v[0] );
+		     VERT_COPY_RGBA1( v[1] );
+		  }
+		  VERT_SAVE_RGBA( 2 );
+		  VERT_COPY_RGBA1( v[2] );
+		  if (HAVE_SPEC) {
+		     if (!DO_FLAT) {
+			VERT_SAVE_SPEC( 0 );
+			VERT_SAVE_SPEC( 1 );
+			VERT_COPY_SPEC1( v[0] );
+			VERT_COPY_SPEC1( v[1] );
+		     }
+		     VERT_SAVE_SPEC( 2 );
+		     VERT_COPY_SPEC1( v[2] );
+		  }
+	       }
+	       else {
+		  GLchan (*vbcolor)[4] = VB->ColorPtr[1]->Ptr;
+		  ASSERT(VB->ColorPtr[1]->Type == CHAN_TYPE);
+		  ASSERT(VB->ColorPtr[1]->StrideB == 4*sizeof(GLchan));
+		  (void) vbcolor;
+
+		  if (!DO_FLAT) {
+		     VERT_SAVE_RGBA( 0 );
+		     VERT_SAVE_RGBA( 1 );
+		     VERT_SET_RGBA( v[0], vbcolor[e0] );
+		     VERT_SET_RGBA( v[1], vbcolor[e1] );
+		  }
+		  VERT_SAVE_RGBA( 2 );
+		  VERT_SET_RGBA( v[2], vbcolor[e2] );
+
+		  if (HAVE_SPEC && VB->SecondaryColorPtr[1]) {
+		     GLchan (*vbspec)[4] = VB->SecondaryColorPtr[1]->Ptr;
+
+		     if (!DO_FLAT) {
+			VERT_SAVE_SPEC( 0 );
+			VERT_SAVE_SPEC( 1 );
+			VERT_SET_SPEC( v[0], vbspec[e0] );
+			VERT_SET_SPEC( v[1], vbspec[e1] );
+		     }
+		     VERT_SAVE_SPEC( 2 );
+		     VERT_SET_SPEC( v[2], vbspec[e2] );
+		  }
+	       }
+	    }
+	    else {
+	       GLuint *vbindex = VB->IndexPtr[1]->data;
+	       if (!DO_FLAT) {
+		  VERT_SET_IND( v[0], vbindex[e0] );
+		  VERT_SET_IND( v[1], vbindex[e1] );
+	       }
+	       VERT_SET_IND( v[2], vbindex[e2] );
+	    }
+	 }
+      }
+
+
+      if (DO_OFFSET)
+      {
+	 offset = ctx->Polygon.OffsetUnits * DEPTH_SCALE;
+	 z[0] = VERT_Z(v[0]);
+	 z[1] = VERT_Z(v[1]);
+	 z[2] = VERT_Z(v[2]);
+	 if (cc * cc > 1e-16) {
+	    GLfloat ic	= 1.0 / cc;
+	    GLfloat ez	= z[0] - z[2];
+	    GLfloat fz	= z[1] - z[2];
+	    GLfloat a	= ey*fz - ez*fy;
+	    GLfloat b	= ez*fx - ex*fz;
+	    GLfloat ac	= a * ic;
+	    GLfloat bc	= b * ic;
+	    if ( ac < 0.0f ) ac = -ac;
+	    if ( bc < 0.0f ) bc = -bc;
+	    offset += MAX2( ac, bc ) * ctx->Polygon.OffsetFactor;
+	 }
+	 offset *= ctx->MRD;
+      }
+   }
+
+   if (DO_FLAT) {
+      if (HAVE_RGBA) {
+	 VERT_SAVE_RGBA( 0 );
+	 VERT_SAVE_RGBA( 1 );
+	 VERT_COPY_RGBA( v[0], v[2] );
+	 VERT_COPY_RGBA( v[1], v[2] );
+	 if (HAVE_SPEC && VB->SecondaryColorPtr[0]) {
+	    VERT_SAVE_SPEC( 0 );
+	    VERT_SAVE_SPEC( 1 );
+	    VERT_COPY_SPEC( v[0], v[2] );
+	    VERT_COPY_SPEC( v[1], v[2] );
+	 }
+      }
+      else {
+	 VERT_SAVE_IND( 0 );
+	 VERT_SAVE_IND( 1 );
+	 VERT_COPY_IND( v[0], v[2] );
+	 VERT_COPY_IND( v[1], v[2] );
+      }
+   }
+
+   if (mode == GL_POINT) {
+      if (DO_OFFSET && ctx->Polygon.OffsetPoint) {
+	 VERT_Z_ADD(v[0], offset);
+	 VERT_Z_ADD(v[1], offset);
+	 VERT_Z_ADD(v[2], offset);
+      }
+      UNFILLED_TRI( ctx, GL_POINT, e0, e1, e2 );
+   } else if (mode == GL_LINE) {
+      if (DO_OFFSET && ctx->Polygon.OffsetLine) {
+	 VERT_Z_ADD(v[0], offset);
+	 VERT_Z_ADD(v[1], offset);
+	 VERT_Z_ADD(v[2], offset);
+      }
+      UNFILLED_TRI( ctx, GL_LINE, e0, e1, e2 );
+   } else {
+      if (DO_OFFSET && ctx->Polygon.OffsetFill) {
+	 VERT_Z_ADD(v[0], offset);
+	 VERT_Z_ADD(v[1], offset);
+	 VERT_Z_ADD(v[2], offset);
+      }
+      if (DO_UNFILLED)
+	 RASTERIZE( GL_TRIANGLES );
+      TRI( v[0], v[1], v[2] );
+   }
+
+   if (DO_OFFSET)
+   {
+      VERT_SET_Z(v[0], z[0]);
+      VERT_SET_Z(v[1], z[1]);
+      VERT_SET_Z(v[2], z[2]);
+   }
+
+   if (DO_TWOSIDE && facing == 1)
+   {
+      if (HAVE_RGBA) {
+	 if (!DO_FLAT) {
+	    VERT_RESTORE_RGBA( 0 );
+	    VERT_RESTORE_RGBA( 1 );
+	 }
+	 VERT_RESTORE_RGBA( 2 );
+	 if (HAVE_SPEC) {
+	    if (!DO_FLAT) {
+	       VERT_RESTORE_SPEC( 0 );
+	       VERT_RESTORE_SPEC( 1 );
+	    }
+	    VERT_RESTORE_SPEC( 2 );
+	 }
+      }
+      else {
+	 GLuint *vbindex = VB->IndexPtr[0]->data;
+	 if (!DO_FLAT) {
+	    VERT_SET_IND( v[0], vbindex[e0] );
+	    VERT_SET_IND( v[1], vbindex[e1] );
+	 }
+	 VERT_SET_IND( v[2], vbindex[e2] );
+      }
+   }
+
+
+   if (DO_FLAT) {
+      if (HAVE_RGBA) {
+	 VERT_RESTORE_RGBA( 0 );
+	 VERT_RESTORE_RGBA( 1 );
+	 if (HAVE_SPEC && VB->SecondaryColorPtr[0]) {
+	    VERT_RESTORE_SPEC( 0 );
+	    VERT_RESTORE_SPEC( 1 );
+	 }
+      }
+      else {
+	 VERT_RESTORE_IND( 0 );
+	 VERT_RESTORE_IND( 1 );
+      }
+   }
+}
+#endif
+
+#if DO_QUAD
+#if DO_FULL_QUAD
+static void TAG(quad)( GLcontext *ctx,
+		       GLuint e0, GLuint e1, GLuint e2, GLuint e3 )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
+   VERTEX *v[4];
+   GLfloat offset;
+   GLfloat z[4];
+   GLenum mode = GL_FILL;
+   GLuint facing;
+   LOCAL_VARS(4);
+
+   v[0] = (VERTEX *)GET_VERTEX(e0);
+   v[1] = (VERTEX *)GET_VERTEX(e1);
+   v[2] = (VERTEX *)GET_VERTEX(e2);
+   v[3] = (VERTEX *)GET_VERTEX(e3);
+
+   if (DO_TWOSIDE || DO_OFFSET || DO_UNFILLED)
+   {
+      GLfloat ex = VERT_X(v[2]) - VERT_X(v[0]);
+      GLfloat ey = VERT_Y(v[2]) - VERT_Y(v[0]);
+      GLfloat fx = VERT_X(v[3]) - VERT_X(v[1]);
+      GLfloat fy = VERT_Y(v[3]) - VERT_Y(v[1]);
+      GLfloat cc = ex*fy - ey*fx;
+
+      if (DO_TWOSIDE || DO_UNFILLED)
+      {
+	 facing = AREA_IS_CCW( cc ) ^ ctx->Polygon._FrontBit;
+
+	 if (DO_UNFILLED) {
+	    if (facing) {
+	       mode = ctx->Polygon.BackMode;
+	       if (ctx->Polygon.CullFlag &&
+		   ctx->Polygon.CullFaceMode != GL_FRONT) {
+		  return;
+	       }
+	    } else {
+	       mode = ctx->Polygon.FrontMode;
+	       if (ctx->Polygon.CullFlag &&
+		   ctx->Polygon.CullFaceMode != GL_BACK) {
+		  return;
+	       }
+	    }
+	 }
+
+	 if (DO_TWOSIDE && facing == 1)
+	 {
+	    if (HAVE_RGBA) {
+	       GLchan (*vbcolor)[4] = VB->ColorPtr[1]->Ptr;
+	       (void)vbcolor;
+
+	       if (HAVE_BACK_COLORS) {
+                  if (!DO_FLAT) {
+                     VERT_SAVE_RGBA( 0 );
+                     VERT_SAVE_RGBA( 1 );
+                     VERT_SAVE_RGBA( 2 );
+		     VERT_COPY_RGBA1( v[0] );
+		     VERT_COPY_RGBA1( v[1] );
+		     VERT_COPY_RGBA1( v[2] );
+		  }
+		  VERT_SAVE_RGBA( 3 );
+		  VERT_COPY_RGBA1( v[3] );
+		  if (HAVE_SPEC) {
+                     if (!DO_FLAT) {
+                        VERT_SAVE_SPEC( 0 );
+                        VERT_SAVE_SPEC( 1 );
+                        VERT_SAVE_SPEC( 2 );
+			VERT_COPY_SPEC1( v[0] );
+			VERT_COPY_SPEC1( v[1] );
+			VERT_COPY_SPEC1( v[2] );
+		     }
+		     VERT_SAVE_SPEC( 3 );
+		     VERT_COPY_SPEC1( v[3] );
+		  }
+	       }
+	       else {
+	          if (!DO_FLAT) {
+		     VERT_SAVE_RGBA( 0 );
+		     VERT_SAVE_RGBA( 1 );
+		     VERT_SAVE_RGBA( 2 );
+		     VERT_SET_RGBA( v[0], vbcolor[e0] );
+		     VERT_SET_RGBA( v[1], vbcolor[e1] );
+		     VERT_SET_RGBA( v[2], vbcolor[e2] );
+	          }
+	          VERT_SAVE_RGBA( 3 );
+	          VERT_SET_RGBA( v[3], vbcolor[e3] );
+
+	          if (HAVE_SPEC && VB->SecondaryColorPtr[1]) {
+		     GLchan (*vbspec)[4] = VB->SecondaryColorPtr[1]->Ptr;
+		     ASSERT(VB->SecondaryColorPtr[1]->StrideB==4*sizeof(GLchan));
+
+		     if (!DO_FLAT) {
+		        VERT_SAVE_SPEC( 0 );
+		        VERT_SAVE_SPEC( 1 );
+		        VERT_SAVE_SPEC( 2 );
+		        VERT_SET_SPEC( v[0], vbspec[e0] );
+		        VERT_SET_SPEC( v[1], vbspec[e1] );
+		        VERT_SET_SPEC( v[2], vbspec[e2] );
+		     }
+		     VERT_SAVE_SPEC( 3 );
+		     VERT_SET_SPEC( v[3], vbspec[e3] );
+	          }
+	       }
+	    }
+	    else {
+	       GLuint *vbindex = VB->IndexPtr[1]->data;
+	       if (!DO_FLAT) {
+		  VERT_SET_IND( v[0], vbindex[e0] );
+		  VERT_SET_IND( v[1], vbindex[e1] );
+		  VERT_SET_IND( v[2], vbindex[e2] );
+	       }
+	       VERT_SET_IND( v[3], vbindex[e3] );
+	    }
+	 }
+      }
+
+
+      if (DO_OFFSET)
+      {
+	 offset = ctx->Polygon.OffsetUnits * DEPTH_SCALE;
+	 z[0] = VERT_Z(v[0]);
+	 z[1] = VERT_Z(v[1]);
+	 z[2] = VERT_Z(v[2]);
+	 z[3] = VERT_Z(v[3]);
+	 if (cc * cc > 1e-16) {
+	    GLfloat ez = z[2] - z[0];
+	    GLfloat fz = z[3] - z[1];
+	    GLfloat a	= ey*fz - ez*fy;
+	    GLfloat b	= ez*fx - ex*fz;
+	    GLfloat ic	= 1.0 / cc;
+	    GLfloat ac	= a * ic;
+	    GLfloat bc	= b * ic;
+	    if ( ac < 0.0f ) ac = -ac;
+	    if ( bc < 0.0f ) bc = -bc;
+	    offset += MAX2( ac, bc ) * ctx->Polygon.OffsetFactor;
+	 }
+	 offset *= ctx->MRD;
+      }
+   }
+
+   if (DO_FLAT) {
+      if (HAVE_RGBA) {
+	 VERT_SAVE_RGBA( 0 );
+	 VERT_SAVE_RGBA( 1 );
+	 VERT_SAVE_RGBA( 2 );
+	 VERT_COPY_RGBA( v[0], v[3] );
+	 VERT_COPY_RGBA( v[1], v[3] );
+	 VERT_COPY_RGBA( v[2], v[3] );
+	 if (HAVE_SPEC && VB->SecondaryColorPtr[0]) {
+	    VERT_SAVE_SPEC( 0 );
+	    VERT_SAVE_SPEC( 1 );
+	    VERT_SAVE_SPEC( 2 );
+	    VERT_COPY_SPEC( v[0], v[3] );
+	    VERT_COPY_SPEC( v[1], v[3] );
+	    VERT_COPY_SPEC( v[2], v[3] );
+	 }
+      }
+      else {
+	 VERT_SAVE_IND( 0 );
+	 VERT_SAVE_IND( 1 );
+	 VERT_SAVE_IND( 2 );
+	 VERT_COPY_IND( v[0], v[3] );
+	 VERT_COPY_IND( v[1], v[3] );
+	 VERT_COPY_IND( v[2], v[3] );
+      }
+   }
+
+   if (mode == GL_POINT) {
+      if (( DO_OFFSET) && ctx->Polygon.OffsetPoint) {
+	 VERT_Z_ADD(v[0], offset);
+	 VERT_Z_ADD(v[1], offset);
+	 VERT_Z_ADD(v[2], offset);
+	 VERT_Z_ADD(v[3], offset);
+      }
+      UNFILLED_QUAD( ctx, GL_POINT, e0, e1, e2, e3 );
+   } else if (mode == GL_LINE) {
+      if (DO_OFFSET && ctx->Polygon.OffsetLine) {
+	 VERT_Z_ADD(v[0], offset);
+	 VERT_Z_ADD(v[1], offset);
+	 VERT_Z_ADD(v[2], offset);
+	 VERT_Z_ADD(v[3], offset);
+      }
+      UNFILLED_QUAD( ctx, GL_LINE, e0, e1, e2, e3 );
+   } else {
+      if (DO_OFFSET && ctx->Polygon.OffsetFill) {
+	 VERT_Z_ADD(v[0], offset);
+	 VERT_Z_ADD(v[1], offset);
+	 VERT_Z_ADD(v[2], offset);
+	 VERT_Z_ADD(v[3], offset);
+      }
+      RASTERIZE( GL_TRIANGLES );
+      QUAD( (v[0]), (v[1]), (v[2]), (v[3]) );
+   }
+
+   if (DO_OFFSET)
+   {
+      VERT_SET_Z(v[0], z[0]);
+      VERT_SET_Z(v[1], z[1]);
+      VERT_SET_Z(v[2], z[2]);
+      VERT_SET_Z(v[3], z[3]);
+   }
+
+   if (DO_TWOSIDE && facing == 1)
+   {
+      if (HAVE_RGBA) {
+	 if (!DO_FLAT) {
+	    VERT_RESTORE_RGBA( 0 );
+	    VERT_RESTORE_RGBA( 1 );
+	    VERT_RESTORE_RGBA( 2 );
+	 }
+	 VERT_RESTORE_RGBA( 3 );
+	 if (HAVE_SPEC) {
+	    if (!DO_FLAT) {
+	       VERT_RESTORE_SPEC( 0 );
+	       VERT_RESTORE_SPEC( 1 );
+	       VERT_RESTORE_SPEC( 2 );
+	    }
+	    VERT_RESTORE_SPEC( 3 );
+	 }
+      }
+      else {
+	 GLuint *vbindex = VB->IndexPtr[0]->data;
+	 if (!DO_FLAT) {
+	    VERT_SET_IND( v[0], vbindex[e0] );
+	    VERT_SET_IND( v[1], vbindex[e1] );
+	    VERT_SET_IND( v[2], vbindex[e2] );
+	 }
+	 VERT_SET_IND( v[3], vbindex[e3] );
+      }
+   }
+
+
+   if (DO_FLAT) {
+      if (HAVE_RGBA) {
+	 VERT_RESTORE_RGBA( 0 );
+	 VERT_RESTORE_RGBA( 1 );
+	 VERT_RESTORE_RGBA( 2 );
+	 if (HAVE_SPEC && VB->SecondaryColorPtr[0]) {
+	    VERT_RESTORE_SPEC( 0 );
+	    VERT_RESTORE_SPEC( 1 );
+	    VERT_RESTORE_SPEC( 2 );
+	 }
+      }
+      else {
+	 VERT_RESTORE_IND( 0 );
+	 VERT_RESTORE_IND( 1 );
+	 VERT_RESTORE_IND( 2 );
+      }
+   }
+}
+#else
+static void TAG(quad)( GLcontext *ctx, GLuint e0,
+		       GLuint e1, GLuint e2, GLuint e3 )
+{
+   if (DO_UNFILLED) {
+      struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+      GLubyte ef1 = VB->EdgeFlag[e1];
+      GLubyte ef3 = VB->EdgeFlag[e3];
+      VB->EdgeFlag[e1] = 0;
+      TAG(triangle)( ctx, e0, e1, e3 );
+      VB->EdgeFlag[e1] = ef1;
+      VB->EdgeFlag[e3] = 0;
+      TAG(triangle)( ctx, e1, e2, e3 );
+      VB->EdgeFlag[e3] = ef3;
+   } else {
+      TAG(triangle)( ctx, e0, e1, e3 );
+      TAG(triangle)( ctx, e1, e2, e3 );
+   }
+}
+#endif
+#endif
+
+#if DO_LINE
+static void TAG(line)( GLcontext *ctx, GLuint e0, GLuint e1 )
+{
+   TNLvertexbuffer *VB = &TNL_CONTEXT(ctx)->vb;
+   VERTEX *v[2];
+   LOCAL_VARS(2);
+
+   v[0] = (VERTEX *)GET_VERTEX(e0);
+   v[1] = (VERTEX *)GET_VERTEX(e1);
+
+   if (DO_FLAT) {
+      if (HAVE_RGBA) {
+	 VERT_SAVE_RGBA( 0 );
+	 VERT_COPY_RGBA( v[0], v[1] );
+	 if (HAVE_SPEC && VB->SecondaryColorPtr[0]) {
+	    VERT_SAVE_SPEC( 0 );
+	    VERT_COPY_SPEC( v[0], v[1] );
+	 }
+      }
+      else {
+	 VERT_SAVE_IND( 0 );
+	 VERT_COPY_IND( v[0], v[1] );
+      }
+   }
+
+   LINE( v[0], v[1] );
+
+   if (DO_FLAT) {
+      if (HAVE_RGBA) {
+	 VERT_RESTORE_RGBA( 0 );
+
+	 if (HAVE_SPEC && VB->SecondaryColorPtr[0]) {
+	    VERT_RESTORE_SPEC( 0 );
+	 }
+      }
+      else {
+	 VERT_RESTORE_IND( 0 );
+      }
+   }
+}
+#endif
+
+#if DO_POINTS
+static void TAG(points)( GLcontext *ctx, GLuint first, GLuint last )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT( ctx )->vb;
+   int i;
+   LOCAL_VARS(1);
+
+   if (VB->Elts == 0) {
+      for ( i = first ; i < last ; i++ ) {
+	 if ( VB->ClipMask[i] == 0 ) {
+	    VERTEX *v = (VERTEX *)GET_VERTEX(i);
+	    POINT( v );
+	 }
+      }
+   } else {
+      for ( i = first ; i < last ; i++ ) {
+	 GLuint e = VB->Elts[i];
+	 if ( VB->ClipMask[e] == 0 ) {
+	    VERTEX *v = (VERTEX *)GET_VERTEX(e);
+	    POINT( v );
+	 }
+      }
+   }
+}
+#endif
+
+static void TAG(init)( void )
+{
+#if DO_QUAD
+   TAB[IND].quad = TAG(quad);
+#endif
+#if DO_TRI
+   TAB[IND].triangle = TAG(triangle);
+#endif
+#if DO_LINE
+   TAB[IND].line = TAG(line);
+#endif
+#if DO_POINTS
+   TAB[IND].points = TAG(points);
+#endif
+}
+
+#undef IND
+#undef TAG
+
+#if HAVE_RGBA
+#undef VERT_SET_IND
+#undef VERT_COPY_IND
+#undef VERT_SAVE_IND
+#undef VERT_RESTORE_IND
+#if HAVE_BACK_COLORS
+#undef VERT_SET_RGBA
+#endif
+#else
+#undef VERT_SET_RGBA
+#undef VERT_COPY_RGBA
+#undef VERT_SAVE_RGBA
+#undef VERT_RESTORE_RGBA
+#if HAVE_BACK_COLORS
+#undef VERT_SET_IND
+#endif
+#endif
+
+#if !HAVE_SPEC
+#undef VERT_SET_SPEC
+#undef VERT_COPY_SPEC
+#undef VERT_SAVE_SPEC
+#undef VERT_RESTORE_SPEC
+#if HAVE_BACK_COLORS
+#undef VERT_COPY_SPEC1
+#endif
+#else
+#if HAVE_BACK_COLORS
+#undef VERT_SET_SPEC
+#endif
+#endif
+
+#if !HAVE_BACK_COLORS
+#undef VERT_COPY_SPEC1
+#undef VERT_COPY_IND1
+#undef VERT_COPY_RGBA1
+#endif
+
+#ifndef INSANE_VERTICES
+#undef VERT_SET_Z
+#undef VERT_Z_ADD
+#endif
Index: xc/extras/Mesa/src/tnl_dd/t_dd_unfilled.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_unfilled.h:1.2
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_unfilled.h	Mon Dec 16 11:18:49 2002
@@ -0,0 +1,212 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+#if HAVE_RGBA
+#define VERT_SET_IND( v, c )
+#define VERT_COPY_IND( v0, v1 )
+#define VERT_SAVE_IND( idx )
+#define VERT_RESTORE_IND( idx )
+#endif
+
+#if !HAVE_SPEC
+#define VERT_SET_SPEC( v, c )
+#define VERT_COPY_SPEC( v0, v1 )
+#define VERT_SAVE_SPEC( idx )
+#define VERT_RESTORE_SPEC( idx )
+#endif
+
+static void TAG(unfilled_tri)( GLcontext *ctx,
+			       GLenum mode,
+			       GLuint e0, GLuint e1, GLuint e2 )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLubyte *ef = VB->EdgeFlag;
+   VERTEX *v[3];
+   LOCAL_VARS(3);
+
+   v[0] = (VERTEX *)GET_VERTEX(e0);
+   v[1] = (VERTEX *)GET_VERTEX(e1);
+   v[2] = (VERTEX *)GET_VERTEX(e2);
+
+   if ((ctx->_TriangleCaps & DD_FLATSHADE) && HAVE_HW_FLATSHADE) {
+      if (HAVE_RGBA) {
+	 VERT_SAVE_RGBA(0);
+	 VERT_SAVE_RGBA(1);
+	 VERT_COPY_RGBA(v[0], v[2]);
+	 VERT_COPY_RGBA(v[1], v[2]);
+
+	 if (HAVE_SPEC) {
+	    VERT_SAVE_SPEC(0);
+	    VERT_SAVE_SPEC(1);
+	    VERT_COPY_SPEC(v[0], v[2]);
+	    VERT_COPY_SPEC(v[1], v[2]);
+	 }
+      } else {
+	 VERT_SAVE_IND(0);
+	 VERT_SAVE_IND(1);
+	 VERT_COPY_IND(v[0], v[2]);
+	 VERT_COPY_IND(v[1], v[2]);
+      }
+   }
+
+/*     fprintf(stderr, "%s %s %d %d %d\n", __FUNCTION__, */
+/*  	   _mesa_lookup_enum_by_nr( mode ), */
+/*  	   ef[e0], ef[e1], ef[e2]); */
+
+   if (mode == GL_POINT) {
+      RASTERIZE(GL_POINTS);
+      if (ef[e0]) POINT( v[0] );
+      if (ef[e1]) POINT( v[1] );
+      if (ef[e2]) POINT( v[2] );
+   }
+   else {
+      RASTERIZE(GL_LINES);
+      if (RENDER_PRIMITIVE == GL_POLYGON) {
+	 if (ef[e2]) LINE( v[2], v[0] );
+	 if (ef[e0]) LINE( v[0], v[1] );
+	 if (ef[e1]) LINE( v[1], v[2] );
+      }
+      else {
+	 if (ef[e0]) LINE( v[0], v[1] );
+	 if (ef[e1]) LINE( v[1], v[2] );
+	 if (ef[e2]) LINE( v[2], v[0] );
+      }
+   }
+
+   if ((ctx->_TriangleCaps & DD_FLATSHADE) && HAVE_HW_FLATSHADE) {
+      if (HAVE_RGBA) {
+	 VERT_RESTORE_RGBA(0);
+	 VERT_RESTORE_RGBA(1);
+
+	 if (HAVE_SPEC) {
+	    VERT_RESTORE_SPEC(0);
+	    VERT_RESTORE_SPEC(1);
+	 }
+      } else {
+	 VERT_RESTORE_IND(0);
+	 VERT_RESTORE_IND(1);
+      }
+   }
+}
+
+
+static void TAG(unfilled_quad)( GLcontext *ctx,
+				GLenum mode,
+				GLuint e0, GLuint e1,
+				GLuint e2, GLuint e3 )
+{
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLubyte *ef = VB->EdgeFlag;
+   VERTEX *v[4];
+   LOCAL_VARS(4);
+
+   v[0] = (VERTEX *)GET_VERTEX(e0);
+   v[1] = (VERTEX *)GET_VERTEX(e1);
+   v[2] = (VERTEX *)GET_VERTEX(e2);
+   v[3] = (VERTEX *)GET_VERTEX(e3);
+
+   /* Hardware flatshading breaks down here.  If the hardware doesn't
+    * support flatshading, this will already have been done:
+    */
+   if ((ctx->_TriangleCaps & DD_FLATSHADE) && HAVE_HW_FLATSHADE) {
+      if (HAVE_RGBA) {
+	 VERT_SAVE_RGBA(0);
+	 VERT_SAVE_RGBA(1);
+	 VERT_SAVE_RGBA(2);
+	 VERT_COPY_RGBA(v[0], v[3]);
+	 VERT_COPY_RGBA(v[1], v[3]);
+	 VERT_COPY_RGBA(v[2], v[3]);
+
+	 if (HAVE_SPEC) {
+	    VERT_SAVE_SPEC(0);
+	    VERT_SAVE_SPEC(1);
+	    VERT_SAVE_SPEC(2);
+	    VERT_COPY_SPEC(v[0], v[3]);
+	    VERT_COPY_SPEC(v[1], v[3]);
+	    VERT_COPY_SPEC(v[2], v[3]);
+	 }
+      } else {
+	 VERT_SAVE_IND(0);
+	 VERT_SAVE_IND(1);
+	 VERT_SAVE_IND(2);
+	 VERT_COPY_IND(v[0], v[3]);
+	 VERT_COPY_IND(v[1], v[3]);
+	 VERT_COPY_IND(v[2], v[3]);
+      }
+   }
+
+   if (mode == GL_POINT) {
+      RASTERIZE(GL_POINTS);
+      if (ef[e0]) POINT( v[0] );
+      if (ef[e1]) POINT( v[1] );
+      if (ef[e2]) POINT( v[2] );
+      if (ef[e3]) POINT( v[3] );
+   }
+   else {
+      RASTERIZE(GL_LINES);
+      if (ef[e0]) LINE( v[0], v[1] );
+      if (ef[e1]) LINE( v[1], v[2] );
+      if (ef[e2]) LINE( v[2], v[3] );
+      if (ef[e3]) LINE( v[3], v[0] );
+   }
+
+   if ((ctx->_TriangleCaps & DD_FLATSHADE) && HAVE_HW_FLATSHADE) {
+      if (HAVE_RGBA) {
+	 VERT_RESTORE_RGBA(0);
+	 VERT_RESTORE_RGBA(1);
+	 VERT_RESTORE_RGBA(2);
+
+	 if (HAVE_SPEC) {
+	    VERT_RESTORE_SPEC(0);
+	    VERT_RESTORE_SPEC(1);
+	    VERT_RESTORE_SPEC(2);
+	 }
+      } else {
+	 VERT_RESTORE_IND(0);
+	 VERT_RESTORE_IND(1);
+	 VERT_RESTORE_IND(2);
+      }
+   }
+}
+
+
+#if HAVE_RGBA
+#undef VERT_SET_IND
+#undef VERT_COPY_IND
+#undef VERT_SAVE_IND
+#undef VERT_RESTORE_IND
+#endif
+
+#if !HAVE_SPEC
+#undef VERT_SET_SPEC
+#undef VERT_COPY_SPEC
+#undef VERT_SAVE_SPEC
+#undef VERT_RESTORE_SPEC
+#endif
+
+#undef TAG
Index: xc/extras/Mesa/src/tnl_dd/t_dd_vb.c
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_vb.c:1.1.1.3
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_vb.c	Tue Oct 29 12:32:35 2002
@@ -0,0 +1,392 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+#include "math/m_translate.h"
+
+#if (HAVE_HW_VIEWPORT)
+#define UNVIEWPORT_VARS
+#define UNVIEWPORT_X(x) x
+#define UNVIEWPORT_Y(x) x
+#define UNVIEWPORT_Z(x) x
+#endif
+
+#ifndef LOCALVARS
+#define LOCALVARS
+#endif
+
+#ifndef CHECK_HW_DIVIDE
+#define CHECK_HW_DIVIDE 1
+#endif
+
+/* These don't need to be duplicated, but there's currently nowhere
+ * really convenient to put them.  Need to build some actual .o files in
+ * this directory?
+ */
+static void copy_pv_rgba4_spec5( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   LOCALVARS   
+   GLubyte *verts = GET_VERTEX_STORE();
+   GLuint shift = GET_VERTEX_STRIDE_SHIFT();
+   GLuint *dst = (GLuint *)(verts + (edst << shift));
+   GLuint *src = (GLuint *)(verts + (esrc << shift));
+   dst[4] = src[4];
+   dst[5] = src[5];
+}
+
+static void copy_pv_rgba4( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   LOCALVARS
+   GLubyte *verts = GET_VERTEX_STORE();
+   GLuint shift = GET_VERTEX_STRIDE_SHIFT();
+   GLuint *dst = (GLuint *)(verts + (edst << shift));
+   GLuint *src = (GLuint *)(verts + (esrc << shift));
+   dst[4] = src[4];
+}
+
+static void copy_pv_rgba3( GLcontext *ctx, GLuint edst, GLuint esrc )
+{
+   LOCALVARS
+   GLubyte *verts = GET_VERTEX_STORE();
+   GLuint shift = GET_VERTEX_STRIDE_SHIFT();
+   GLuint *dst = (GLuint *)(verts + (edst << shift));
+   GLuint *src = (GLuint *)(verts + (esrc << shift));
+   dst[3] = src[3];
+}
+
+
+void TAG(translate_vertex)(GLcontext *ctx,
+			   const VERTEX *src,
+			   SWvertex *dst)
+{
+   LOCALVARS
+   GLuint format = GET_VERTEX_FORMAT();
+   GLfloat *s = ctx->Viewport._WindowMap.m;
+   UNVIEWPORT_VARS;
+
+   if (format == TINY_VERTEX_FORMAT) {
+      if (HAVE_HW_VIEWPORT) {
+	 dst->win[0] = s[0]  * src->v.x + s[12];
+	 dst->win[1] = s[5]  * src->v.y + s[13];
+	 dst->win[2] = s[10] * src->v.z + s[14];
+	 dst->win[3] = 1.0;
+      } else {
+	 dst->win[0] = UNVIEWPORT_X( src->v.x );
+	 dst->win[1] = UNVIEWPORT_Y( src->v.y );
+	 dst->win[2] = UNVIEWPORT_Z( src->v.z );
+	 dst->win[3] = 1.0;
+      }
+
+      dst->color[0] = src->tv.color.red;
+      dst->color[1] = src->tv.color.green;
+      dst->color[2] = src->tv.color.blue;
+      dst->color[3] = src->tv.color.alpha;
+   }
+   else {
+      if (HAVE_HW_VIEWPORT) {
+	 if (HAVE_HW_DIVIDE && CHECK_HW_DIVIDE) {
+	    GLfloat oow = 1.0 / src->v.w;
+	    dst->win[0] = s[0]  * src->v.x * oow + s[12];
+	    dst->win[1] = s[5]  * src->v.y * oow + s[13];
+	    dst->win[2] = s[10] * src->v.z * oow + s[14];
+	    dst->win[3] = oow;
+	 } else {
+	    dst->win[0] = s[0]  * src->v.x + s[12];
+	    dst->win[1] = s[5]  * src->v.y + s[13];
+	    dst->win[2] = s[10] * src->v.z + s[14];
+	    dst->win[3] = src->v.w;
+	 }
+      } else {
+	 dst->win[0] = UNVIEWPORT_X( src->v.x );
+	 dst->win[1] = UNVIEWPORT_Y( src->v.y );
+	 dst->win[2] = UNVIEWPORT_Z( src->v.z );
+	 dst->win[3] = src->v.w;
+      }
+
+      dst->color[0] = src->v.color.red;
+      dst->color[1] = src->v.color.green;
+      dst->color[2] = src->v.color.blue;
+      dst->color[3] = src->v.color.alpha;
+
+      dst->specular[0] = src->v.specular.red;
+      dst->specular[1] = src->v.specular.green;
+      dst->specular[2] = src->v.specular.blue;
+
+      dst->fog = src->v.specular.alpha/255.0;
+
+      if (HAVE_PTEX_VERTICES &&
+	  ((HAVE_TEX2_VERTICES && format == PROJ_TEX3_VERTEX_FORMAT) ||
+	   (format == PROJ_TEX1_VERTEX_FORMAT))) {
+
+	 dst->texcoord[0][0] = src->pv.u0;
+	 dst->texcoord[0][1] = src->pv.v0;
+	 dst->texcoord[0][3] = src->pv.q0;
+
+	 dst->texcoord[1][0] = src->pv.u1;
+	 dst->texcoord[1][1] = src->pv.v1;
+	 dst->texcoord[1][3] = src->pv.q1;
+
+	 if (HAVE_TEX2_VERTICES) {
+	    dst->texcoord[2][0] = src->pv.u2;
+	    dst->texcoord[2][1] = src->pv.v2;
+	    dst->texcoord[2][3] = src->pv.q2;
+	 }
+
+	 if (HAVE_TEX3_VERTICES) {
+	    dst->texcoord[3][0] = src->pv.u3;
+	    dst->texcoord[3][1] = src->pv.v3;
+	    dst->texcoord[3][3] = src->pv.q3;
+	 }
+      }
+      else {
+	 dst->texcoord[0][0] = src->v.u0;
+	 dst->texcoord[0][1] = src->v.v0;
+	 dst->texcoord[0][3] = 1.0;
+
+	 dst->texcoord[1][0] = src->v.u1;
+	 dst->texcoord[1][1] = src->v.v1;
+	 dst->texcoord[1][3] = 1.0;
+
+	 if (HAVE_TEX2_VERTICES) {
+	    dst->texcoord[2][0] = src->v.u2;
+	    dst->texcoord[2][1] = src->v.v2;
+	    dst->texcoord[2][3] = 1.0;
+	 }
+
+	 if (HAVE_TEX3_VERTICES) {
+	    dst->texcoord[3][0] = src->v.u3;
+	    dst->texcoord[3][1] = src->v.v3;
+	    dst->texcoord[3][3] = 1.0;
+	 }
+      }
+   }
+
+   dst->pointSize = ctx->Point._Size;
+}
+
+
+
+void TAG(print_vertex)( GLcontext *ctx, const VERTEX *v )
+{
+   LOCALVARS
+   GLuint format = GET_VERTEX_FORMAT();
+
+   fprintf(stderr, "(%x) ", format);
+
+   switch (format) {
+#if HAVE_TINY_VERTICES
+   case TINY_VERTEX_FORMAT:
+      fprintf(stderr, "xyz %.4f,%.4f,%.4f rgba %x:%x:%x:%x\n",
+	      v->v.x, v->v.y, v->v.z,
+	      v->tv.color.red,
+	      v->tv.color.green,
+	      v->tv.color.blue,
+	      v->tv.color.alpha);
+      break;
+#endif
+#if HAVE_NOTEX_VERTICES
+   case NOTEX_VERTEX_FORMAT:
+      fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x spec %x:%x:%x:%x\n",
+	      v->v.x, v->v.y, v->v.z, v->v.w,
+	      v->v.color.red,
+	      v->v.color.green,
+	      v->v.color.blue,
+	      v->v.color.alpha,
+	      v->v.specular.red,
+	      v->v.specular.green,
+	      v->v.specular.blue,
+	      v->v.specular.alpha);
+      break;
+#endif
+#if HAVE_TEX0_VERTICES
+   case TEX0_VERTEX_FORMAT:
+      fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x st %.4f,%.4f\n",
+	      v->v.x, v->v.y, v->v.z, v->v.w,
+	      v->v.color.red,
+	      v->v.color.green,
+	      v->v.color.blue,
+	      v->v.color.alpha,
+	      v->v.u0,
+	      v->v.v0);
+      break;
+#endif
+#if HAVE_TEX1_VERTICES
+   case TEX1_VERTEX_FORMAT:
+      fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x st %.4f,%.4f st %.4f,%.4f\n",
+	      v->v.x, v->v.y, v->v.z, v->v.w,
+	      v->v.color.red,
+	      v->v.color.green,
+	      v->v.color.blue,
+	      v->v.color.alpha,
+	      v->v.u0,
+	      v->v.v0,
+	      v->v.u1,
+	      v->v.u2);
+      break;
+#endif
+#if HAVE_PTEX_VERTICES
+   case PROJ_TEX1_VERTEX_FORMAT:
+      fprintf(stderr, "xyzw %.4f,%.4f,%.4f,%.4f rgba %x:%x:%x:%x stq %.4f,%.4f,%.4f stq %.4f,%.4f,%.4f\n",
+	      v->v.x, v->v.y, v->v.z, v->v.w,
+	      v->v.color.red,
+	      v->v.color.green,
+	      v->v.color.blue,
+	      v->v.color.alpha,
+	      v->pv.u0,
+	      v->pv.v0,
+	      v->pv.q0,
+	      v->pv.u1,
+	      v->pv.v1,
+	      v->pv.q1);
+      break;
+#endif      
+   default:
+      fprintf(stderr, "???\n");
+      break;
+   }
+
+   fprintf(stderr, "\n");
+}
+
+static void do_import( struct vertex_buffer *VB,
+		       struct gl_client_array *to,
+		       struct gl_client_array *from )
+{
+   GLuint count = VB->Count;
+
+   if (!to->Ptr) {
+      to->Ptr = ALIGN_MALLOC( VB->Size * 4 * sizeof(GLubyte), 32 );
+      to->Type = GL_UNSIGNED_BYTE;
+   }
+
+   /* No need to transform the same value 3000 times.
+    */
+   if (!from->StrideB) {
+      to->StrideB = 0;
+      count = 1;
+   }
+   else
+      to->StrideB = 4 * sizeof(GLubyte);
+   
+   _math_trans_4ub( (GLubyte (*)[4]) to->Ptr,
+		    from->Ptr,
+		    from->StrideB,
+		    from->Type,
+		    from->Size,
+		    0,
+		    count);
+}
+
+#ifndef IMPORT_QUALIFIER
+#define IMPORT_QUALIFIER static
+#endif
+
+IMPORT_QUALIFIER void TAG(import_float_colors)( GLcontext *ctx )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct gl_client_array *to = GET_UBYTE_COLOR_STORE();
+   do_import( VB, to, VB->ColorPtr[0] );
+   VB->ColorPtr[0] = to;
+}
+
+IMPORT_QUALIFIER void TAG(import_float_spec_colors)( GLcontext *ctx )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   struct gl_client_array *to = GET_UBYTE_SPEC_COLOR_STORE();
+   do_import( VB, to, VB->SecondaryColorPtr[0] );
+   VB->SecondaryColorPtr[0] = to;
+}
+
+/* Interpolate the elements of the VB not included in typical hardware
+ * vertices.  
+ *
+ * NOTE: All these arrays are guarenteed by tnl to be writeable and
+ * have good stride.
+ */
+#ifndef INTERP_QUALIFIER 
+#define INTERP_QUALIFIER static
+#endif
+
+#define GET_COLOR(ptr, idx) (((GLchan (*)[4])((ptr)->Ptr))[idx])
+
+
+INTERP_QUALIFIER void TAG(interp_extras)( GLcontext *ctx,
+					  GLfloat t,
+					  GLuint dst, GLuint out, GLuint in,
+					  GLboolean force_boundary )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+
+   if (VB->ColorPtr[1]) {
+      INTERP_4CHAN( t,
+		    GET_COLOR(VB->ColorPtr[1], dst),
+		    GET_COLOR(VB->ColorPtr[1], out),
+		    GET_COLOR(VB->ColorPtr[1], in) );
+
+      if (VB->SecondaryColorPtr[1]) {
+	 INTERP_3CHAN( t,
+		       GET_COLOR(VB->SecondaryColorPtr[1], dst),
+		       GET_COLOR(VB->SecondaryColorPtr[1], out),
+		       GET_COLOR(VB->SecondaryColorPtr[1], in) );
+      }
+   }
+
+   if (VB->EdgeFlag) {
+      VB->EdgeFlag[dst] = VB->EdgeFlag[out] || force_boundary;
+   }
+
+   INTERP_VERTEX(ctx, t, dst, out, in, force_boundary);
+}
+
+INTERP_QUALIFIER void TAG(copy_pv_extras)( GLcontext *ctx, 
+					   GLuint dst, GLuint src )
+{
+   LOCALVARS
+      struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+
+   if (VB->ColorPtr[1]) {
+      COPY_CHAN4( GET_COLOR(VB->ColorPtr[1], dst), 
+		  GET_COLOR(VB->ColorPtr[1], src) );
+
+      if (VB->SecondaryColorPtr[1]) {
+	 COPY_CHAN4( GET_COLOR(VB->SecondaryColorPtr[1], dst), 
+		     GET_COLOR(VB->SecondaryColorPtr[1], src) );
+      }
+   }
+
+   COPY_PV_VERTEX(ctx, dst, src);
+}
+
+
+#undef INTERP_QUALIFIER
+#undef IMPORT_QUALIFIER
+#undef GET_COLOR
+
+#undef IND
+#undef TAG
Index: xc/extras/Mesa/src/tnl_dd/t_dd_vbtmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_vbtmp.h:1.3
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_vbtmp.h	Tue Jan 14 23:44:35 2003
@@ -0,0 +1,832 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+
+/* Unlike the other templates here, this assumes quite a bit about the
+ * underlying hardware.  Specifically it assumes a d3d-like vertex
+ * format, with a layout more or less constrained to look like the
+ * following:
+ *
+ * union {
+ *    struct {
+ *        float x, y, z, w;
+ *        struct { char r, g, b, a; } color;
+ *        struct { char r, g, b, fog; } spec;
+ *        float u0, v0;
+ *        float u1, v1;
+ *        float u2, v2;
+ *        float u3, v3;
+ *    } v;
+ *    struct {
+ *        float x, y, z, w;
+ *        struct { char r, g, b, a; } color;
+ *        struct { char r, g, b, fog; } spec;
+ *        float u0, v0, q0;
+ *        float u1, v1, q1;
+ *        float u2, v2, q2;
+ *        float u3, v3, q3;
+ *    } pv;
+ *    struct {
+ *        float x, y, z;
+ *        struct { char r, g, b, a; } color;
+ *    } tv;
+ *    float f[16];
+ *    unsigned int ui[16];
+ *    unsigned char ub4[4][16];
+ * }
+ *
+ 
+ * VERTEX:   hw vertex type as above
+ * VERTEX_COLOR: hw color struct type in VERTEX
+ *
+ * DO_XYZW:  Emit xyz and maybe w coordinates.
+ * DO_RGBA:  Emit color.
+ * DO_SPEC:  Emit specular color.
+ * DO_FOG:   Emit fog coordinate in specular alpha.
+ * DO_TEX0:  Emit tex0 u,v coordinates.
+ * DO_TEX1:  Emit tex1 u,v coordinates.
+ * DO_TEX2:  Emit tex2 u,v coordinates.
+ * DO_TEX3:  Emit tex3 u,v coordinates.
+ * DO_PTEX:  Emit tex0,1,2,3 q coordinates where possible.
+ *
+ * HAVE_RGBA_COLOR: Hardware takes color in rgba order (else bgra).
+ *
+ * HAVE_HW_VIEWPORT:  Hardware performs viewport transform.
+ * HAVE_HW_DIVIDE:  Hardware performs perspective divide.
+ *
+ * HAVE_TINY_VERTICES:  Hardware understands v.tv format.
+ * HAVE_PTEX_VERTICES:  Hardware understands v.pv format.
+ * HAVE_NOTEX_VERTICES:  Hardware understands v.v format with texcount 0.
+ *
+ * Additionally, this template assumes it is emitting *transformed*
+ * vertices; the modifications to emit untransformed vertices (ie. to
+ * t&l hardware) are probably too great to cooexist with the code
+ * already in this file.
+ *
+ * NOTE: The PTEX vertex format always includes TEX0 and TEX1, even if
+ * only TEX0 is enabled, in order to maintain a vertex size which is
+ * an exact number of quadwords.
+ */
+
+#if (HAVE_HW_VIEWPORT)
+#define VIEWPORT_X(dst,x) dst = x
+#define VIEWPORT_Y(dst,y) dst = y
+#define VIEWPORT_Z(dst,z) dst = z
+#else
+#define VIEWPORT_X(dst,x) dst = s[0]  * x + s[12]
+#define VIEWPORT_Y(dst,y) dst = s[5]  * y + s[13]
+#define VIEWPORT_Z(dst,z) dst = s[10] * z + s[14]
+#endif
+
+#if (HAVE_HW_DIVIDE && !HAVE_PTEX_VERTICES)
+#error "can't cope with this combination" 
+#endif 
+
+#ifndef LOCALVARS
+#define LOCALVARS
+#endif
+
+#ifndef CHECK_HW_DIVIDE
+#define CHECK_HW_DIVIDE 1
+#endif
+
+#if (HAVE_HW_DIVIDE || DO_SPEC || DO_TEX0 || DO_FOG || !HAVE_TINY_VERTICES)
+
+static void TAG(emit)( GLcontext *ctx,
+		       GLuint start, GLuint end,
+		       void *dest,
+		       GLuint stride )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLfloat (*tc0)[4], (*tc1)[4], *fog;
+   GLfloat (*tc2)[4], (*tc3)[4];
+   GLubyte (*col)[4], (*spec)[4];
+   GLuint tc0_stride, tc1_stride, col_stride, spec_stride, fog_stride;
+   GLuint tc2_stride, tc3_stride;
+   GLuint tc0_size, tc1_size;
+   GLuint tc2_size, tc3_size;
+   GLfloat (*coord)[4];
+   GLuint coord_stride;
+   VERTEX *v = (VERTEX *)dest;
+   const GLfloat *s = GET_VIEWPORT_MAT();
+   const GLubyte *mask = VB->ClipMask;
+   int i;
+
+/*     fprintf(stderr, "%s(big) importable %d %d..%d\n",  */
+/*  	   __FUNCTION__, VB->importable_data, start, end); */
+
+   if (HAVE_HW_VIEWPORT && HAVE_HW_DIVIDE && CHECK_HW_DIVIDE) {
+      (void) s;
+      coord = VB->ClipPtr->data;
+      coord_stride = VB->ClipPtr->stride;
+   }
+   else {
+      coord = VB->ProjectedClipPtr->data;
+      coord_stride = VB->ProjectedClipPtr->stride;
+   }
+
+   if (DO_TEX3) {
+      const GLuint t3 = GET_TEXSOURCE(3);
+      tc3 = VB->TexCoordPtr[t3]->data;
+      tc3_stride = VB->TexCoordPtr[t3]->stride;
+      if (DO_PTEX)
+	 tc3_size = VB->TexCoordPtr[t3]->size;
+   }
+
+   if (DO_TEX2) {
+      const GLuint t2 = GET_TEXSOURCE(2);
+      tc2 = VB->TexCoordPtr[t2]->data;
+      tc2_stride = VB->TexCoordPtr[t2]->stride;
+      if (DO_PTEX)
+	 tc2_size = VB->TexCoordPtr[t2]->size;
+   }
+
+   if (DO_TEX1) {
+      const GLuint t1 = GET_TEXSOURCE(1);
+      tc1 = VB->TexCoordPtr[t1]->data;
+      tc1_stride = VB->TexCoordPtr[t1]->stride;
+      if (DO_PTEX)
+	 tc1_size = VB->TexCoordPtr[t1]->size;
+   }
+
+   if (DO_TEX0) {
+      const GLuint t0 = GET_TEXSOURCE(0);
+      tc0_stride = VB->TexCoordPtr[t0]->stride;
+      tc0 = VB->TexCoordPtr[t0]->data;
+      if (DO_PTEX) 
+	 tc0_size = VB->TexCoordPtr[t0]->size;
+   }
+
+   if (DO_RGBA) {
+      if (VB->ColorPtr[0]->Type != GL_UNSIGNED_BYTE)
+	 IMPORT_FLOAT_COLORS( ctx );
+      col = (GLubyte (*)[4])VB->ColorPtr[0]->Ptr;
+      col_stride = VB->ColorPtr[0]->StrideB;
+   }
+
+   if (DO_SPEC) {
+      if (VB->SecondaryColorPtr[0]) {
+	 if (VB->SecondaryColorPtr[0]->Type != GL_UNSIGNED_BYTE)
+	    IMPORT_FLOAT_SPEC_COLORS( ctx );
+	 spec = (GLubyte (*)[4])VB->SecondaryColorPtr[0]->Ptr;
+	 spec_stride = VB->SecondaryColorPtr[0]->StrideB;
+      } else {
+	 GLubyte tmp[4];
+	 spec = &tmp;
+	 spec_stride = 0;
+      }
+   }
+
+   if (DO_FOG) {
+      if (VB->FogCoordPtr) {
+	 fog = VB->FogCoordPtr->data;
+	 fog_stride = VB->FogCoordPtr->stride;
+      }
+      else {
+	 GLfloat tmp = 0;
+	 fog = &tmp;
+	 fog_stride = 0;
+      }
+   }
+
+   if (VB->importable_data || (DO_SPEC && !spec_stride) || (DO_FOG && !fog_stride)) {
+      /* May have nonstandard strides:
+       */
+      if (start) {
+	 coord =  (GLfloat (*)[4])((GLubyte *)coord + start * coord_stride);
+	 if (DO_TEX0)
+	    tc0 =  (GLfloat (*)[4])((GLubyte *)tc0 + start * tc0_stride);
+	 if (DO_TEX1) 
+	    tc1 =  (GLfloat (*)[4])((GLubyte *)tc1 + start * tc1_stride);
+	 if (DO_TEX2) 
+	    tc2 =  (GLfloat (*)[4])((GLubyte *)tc2 + start * tc2_stride);
+	 if (DO_TEX3) 
+	    tc3 =  (GLfloat (*)[4])((GLubyte *)tc3 + start * tc3_stride);
+	 if (DO_RGBA) 
+	    STRIDE_4UB(col, start * col_stride);
+	 if (DO_SPEC)
+	    STRIDE_4UB(spec, start * spec_stride);
+	 if (DO_FOG)
+	    STRIDE_F(fog, start * fog_stride);
+      }
+
+      for (i=start; i < end; i++, v = (VERTEX *)((GLubyte *)v + stride)) {
+	 if (DO_XYZW) {
+	    if (HAVE_HW_VIEWPORT || mask[i] == 0) {
+	       VIEWPORT_X(v->v.x, coord[0][0]);
+	       VIEWPORT_Y(v->v.y, coord[0][1]);
+	       VIEWPORT_Z(v->v.z, coord[0][2]);
+	       v->v.w = coord[0][3];
+	    }
+/*  	    fprintf(stderr, "vert %d: %.2f %.2f %.2f %.2f\n",  */
+/*  		    i, v->v.x, v->v.y, v->v.z, v->v.w); */
+	    coord =  (GLfloat (*)[4])((GLubyte *)coord +  coord_stride);
+	 }
+	 if (DO_RGBA) {
+	    if (HAVE_RGBA_COLOR) {
+	       *(GLuint *)&v->v.color = LE32_TO_CPU(*(GLuint *)&col[0]);
+	       STRIDE_4UB(col, col_stride);
+	    } else {
+	       v->v.color.blue  = col[0][2];
+	       v->v.color.green = col[0][1];
+	       v->v.color.red   = col[0][0];
+	       v->v.color.alpha = col[0][3];
+	       STRIDE_4UB(col, col_stride);
+	    }
+	 }
+	 if (DO_SPEC) {
+	    v->v.specular.red = spec[0][0];
+	    v->v.specular.green = spec[0][1];
+	    v->v.specular.blue = spec[0][2];
+	    STRIDE_4UB(spec, spec_stride);
+	 }
+	 if (DO_FOG) {
+	    v->v.specular.alpha = fog[0] * 255.0;
+	    STRIDE_F(fog, fog_stride);
+	 }
+	 if (DO_TEX0) {
+	    v->v.u0 = tc0[0][0];
+	    v->v.v0 = tc0[0][1];
+	    if (DO_PTEX) {
+	       if (HAVE_PTEX_VERTICES) {
+		  if (tc0_size == 4) 
+		     v->pv.q0 = tc0[0][3];
+		  else
+		     v->pv.q0 = 1.0;
+	       } 
+	       else if (tc0_size == 4) {
+		  float rhw = 1.0 / tc0[0][3];
+		  v->v.w *= tc0[0][3];
+		  v->v.u0 *= rhw;
+		  v->v.v0 *= rhw;
+	       } 
+	    } 
+	    tc0 =  (GLfloat (*)[4])((GLubyte *)tc0 +  tc0_stride);
+	 }
+	 if (DO_TEX1) {
+	    if (DO_PTEX) {
+	       v->pv.u1 = tc1[0][0];
+	       v->pv.v1 = tc1[0][1];
+	       if (tc1_size == 4) 
+		  v->pv.q1 = tc1[0][3];
+	       else
+		  v->pv.q1 = 1.0;
+	    } 
+	    else {
+	       v->v.u1 = tc1[0][0];
+	       v->v.v1 = tc1[0][1];
+	    }
+	    tc1 =  (GLfloat (*)[4])((GLubyte *)tc1 +  tc1_stride);
+	 } 
+	 else if (DO_PTEX) {
+	    *(GLuint *)&v->pv.q1 = 0;	/* avoid culling on radeon */
+	 }
+	 if (DO_TEX2) {
+	    if (DO_PTEX) {
+	       v->pv.u2 = tc2[0][0];
+	       v->pv.v2 = tc2[0][1];
+	       if (tc2_size == 4) 
+		  v->pv.q2 = tc2[0][3];
+	       else
+		  v->pv.q2 = 1.0;
+	    } 
+	    else {
+	       v->v.u2 = tc2[0][0];
+	       v->v.v2 = tc2[0][1];
+	    }
+	    tc2 =  (GLfloat (*)[4])((GLubyte *)tc2 +  tc2_stride);
+	 } 
+	 if (DO_TEX3) {
+	    if (DO_PTEX) {
+	       v->pv.u3 = tc3[0][0];
+	       v->pv.v3 = tc3[0][1];
+	       if (tc3_size == 4) 
+		  v->pv.q3 = tc3[0][3];
+	       else
+		  v->pv.q3 = 1.0;
+	    } 
+	    else {
+	       v->v.u3 = tc3[0][0];
+	       v->v.v3 = tc3[0][1];
+	    }
+	    tc3 =  (GLfloat (*)[4])((GLubyte *)tc3 +  tc3_stride);
+	 } 
+      }
+   }
+   else {
+      for (i=start; i < end; i++, v = (VERTEX *)((GLubyte *)v + stride)) {
+	 if (DO_XYZW) {
+	    if (HAVE_HW_VIEWPORT || mask[i] == 0) {
+	       VIEWPORT_X(v->v.x, coord[i][0]);
+	       VIEWPORT_Y(v->v.y, coord[i][1]);
+	       VIEWPORT_Z(v->v.z, coord[i][2]);
+	       v->v.w = coord[i][3];
+	    }
+	 }
+	 if (DO_RGBA) {
+	    if (HAVE_RGBA_COLOR) {
+	       *(GLuint *)&v->v.color = LE32_TO_CPU(*(GLuint *)&col[i]);
+	    }
+	    else {
+	       v->v.color.blue  = col[i][2];
+	       v->v.color.green = col[i][1];
+	       v->v.color.red   = col[i][0];
+	       v->v.color.alpha = col[i][3];
+	    }
+	 }
+	 if (DO_SPEC) {
+	    v->v.specular.red   = spec[i][0];
+	    v->v.specular.green = spec[i][1];
+	    v->v.specular.blue  = spec[i][2];
+	 }
+	 if (DO_FOG) {
+	    v->v.specular.alpha = fog[i] * 255.0;
+	 }
+	 if (DO_TEX0) {
+	    v->v.u0 = tc0[i][0];
+	    v->v.v0 = tc0[i][1];
+	    if (DO_PTEX) {
+	       if (HAVE_PTEX_VERTICES) {
+		  if (tc0_size == 4) 
+		     v->pv.q0 = tc0[i][3];
+		  else
+		     v->pv.q0 = 1.0;
+
+		  v->pv.q1 = 0;	/* radeon */
+	       } 
+	       else if (tc0_size == 4) {
+		  float rhw = 1.0 / tc0[i][3];
+		  v->v.w *= tc0[i][3];
+		  v->v.u0 *= rhw;
+		  v->v.v0 *= rhw;
+	       } 
+	    } 
+	 }
+	 if (DO_TEX1) {
+	    if (DO_PTEX) {
+	       v->pv.u1 = tc1[i][0];
+	       v->pv.v1 = tc1[i][1];
+	       if (tc1_size == 4) 
+		  v->pv.q1 = tc1[i][3];
+	       else
+		  v->pv.q1 = 1.0;
+	    } 
+	    else {
+	       v->v.u1 = tc1[i][0];
+	       v->v.v1 = tc1[i][1];
+	    }
+	 }
+      }
+   }
+}
+#else
+#if DO_XYZW
+
+#if HAVE_HW_DIVIDE
+#error "cannot use tiny vertices with hw perspective divide"
+#endif
+
+static void TAG(emit)( GLcontext *ctx, GLuint start, GLuint end,
+		       void *dest, GLuint stride )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLubyte (*col)[4];
+   GLuint col_stride;
+   GLfloat (*coord)[4] = VB->ProjectedClipPtr->data;
+   GLuint coord_stride = VB->ProjectedClipPtr->stride;
+   GLfloat *v = (GLfloat *)dest;
+   const GLubyte *mask = VB->ClipMask;
+   const GLfloat *s = GET_VIEWPORT_MAT();
+   int i;
+
+   (void) s;
+
+   ASSERT(stride == 4);
+
+   if (VB->ColorPtr[0]->Type != GL_UNSIGNED_BYTE)
+      IMPORT_FLOAT_COLORS( ctx );
+
+   col = (GLubyte (*)[4])VB->ColorPtr[0]->Ptr;
+   col_stride = VB->ColorPtr[0]->StrideB;
+   ASSERT(VB->ColorPtr[0]->Type == GL_UNSIGNED_BYTE);
+
+/*     fprintf(stderr, "%s(small) importable %x\n",  */
+/*  	   __FUNCTION__, VB->importable_data); */
+
+   /* Pack what's left into a 4-dword vertex.  Color is in a different
+    * place, and there is no 'w' coordinate.
+    */
+   if (VB->importable_data) {
+      if (start) {
+	 coord =  (GLfloat (*)[4])((GLubyte *)coord + start * coord_stride);
+	 STRIDE_4UB(col, start * col_stride);
+      }
+
+      for (i=start; i < end; i++, v+=4) {
+	 if (HAVE_HW_VIEWPORT || mask[i] == 0) {
+	    VIEWPORT_X(v[0], coord[0][0]);
+	    VIEWPORT_Y(v[1], coord[0][1]);
+	    VIEWPORT_Z(v[2], coord[0][2]);
+	 }
+	 coord =  (GLfloat (*)[4])((GLubyte *)coord +  coord_stride);
+	 if (DO_RGBA) {
+	    if (HAVE_RGBA_COLOR) {
+	       *(GLuint *)&v[3] = LE32_TO_CPU(*(GLuint *)col);
+	    }
+	    else {
+	       VERTEX_COLOR *c = (VERTEX_COLOR *)&v[3];
+	       c->blue  = col[0][2];
+	       c->green = col[0][1];
+	       c->red   = col[0][0];
+	       c->alpha = col[0][3];
+	    }
+	    STRIDE_4UB( col, col_stride );
+	 }
+/*  	 fprintf(stderr, "vert %d: %.2f %.2f %.2f %x\n",  */
+/*  		 i, v[0], v[1], v[2], *(int *)&v[3]); */
+      }
+   }
+   else {
+      for (i=start; i < end; i++, v+=4) {
+	 if (HAVE_HW_VIEWPORT || mask[i] == 0) {
+	    VIEWPORT_X(v[0], coord[i][0]);
+	    VIEWPORT_Y(v[1], coord[i][1]);
+	    VIEWPORT_Z(v[2], coord[i][2]);
+	 }
+	 if (DO_RGBA) {
+	    if (HAVE_RGBA_COLOR) {
+	       *(GLuint *)&v[3] = LE32_TO_CPU(*(GLuint *)&col[i]);
+	    }
+	    else {
+	       VERTEX_COLOR *c = (VERTEX_COLOR *)&v[3];
+	       c->blue  = col[i][2];
+	       c->green = col[i][1];
+	       c->red   = col[i][0];
+	       c->alpha = col[i][3];
+	    }
+	 }
+/*  	 fprintf(stderr, "vert %d: %.2f %.2f %.2f %x\n",  */
+/*  		 i, v[0], v[1], v[2], *(int *)&v[3]); */
+
+      }
+   }
+}
+#else
+static void TAG(emit)( GLcontext *ctx, GLuint start, GLuint end,
+		       void *dest, GLuint stride )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLubyte (*col)[4];
+   GLuint col_stride;
+   GLfloat *v = (GLfloat *)dest;
+   int i;
+
+   if (VB->ColorPtr[0]->Type != GL_UNSIGNED_BYTE)
+      IMPORT_FLOAT_COLORS( ctx );
+
+   col = VB->ColorPtr[0]->Ptr;
+   col_stride = VB->ColorPtr[0]->StrideB;
+
+   if (start)
+      STRIDE_4UB(col, col_stride * start);
+
+   /* Need to figure out where color is:
+    */
+   if (GET_VERTEX_FORMAT() == TINY_VERTEX_FORMAT)
+      v += 3;
+   else
+      v += 4;
+
+   for (i=start; i < end; i++, STRIDE_F(v, stride)) {
+      if (HAVE_RGBA_COLOR) {
+	 *(GLuint *)v = LE32_TO_CPU(*(GLuint *)col[0]);
+      }
+      else {
+	 VERTEX_COLOR *c = (VERTEX_COLOR *)v;
+	 c->blue  = col[0][2];
+	 c->green = col[0][1];
+	 c->red   = col[0][0];
+	 c->alpha = col[0][3];
+      }
+      STRIDE_4UB( col, col_stride );
+   }
+}
+#endif /* emit */
+#endif /* emit */
+
+#if (DO_XYZW) && (DO_RGBA)
+
+
+#if (HAVE_PTEX_VERTICES)
+static GLboolean TAG(check_tex_sizes)( GLcontext *ctx )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+
+   /* Force 'missing' texcoords to something valid.
+    */
+   if (DO_TEX3 && VB->TexCoordPtr[2] == 0)
+      VB->TexCoordPtr[2] = VB->TexCoordPtr[3];
+
+   if (DO_TEX2 && VB->TexCoordPtr[1] == 0)
+      VB->TexCoordPtr[1] = VB->TexCoordPtr[2];
+
+   if (DO_TEX1 && VB->TexCoordPtr[0] == 0)
+      VB->TexCoordPtr[0] = VB->TexCoordPtr[1];
+
+   if (DO_PTEX)
+      return GL_TRUE;
+   
+   if ((DO_TEX3 && VB->TexCoordPtr[GET_TEXSOURCE(3)]->size == 4) ||
+       (DO_TEX2 && VB->TexCoordPtr[GET_TEXSOURCE(2)]->size == 4) ||
+       (DO_TEX1 && VB->TexCoordPtr[GET_TEXSOURCE(1)]->size == 4) ||
+       (DO_TEX0 && VB->TexCoordPtr[GET_TEXSOURCE(0)]->size == 4))
+      return GL_FALSE;
+
+   return GL_TRUE;
+}
+#else
+static GLboolean TAG(check_tex_sizes)( GLcontext *ctx )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+
+   /* Force 'missing' texcoords to something valid.
+    */
+   if (DO_TEX3 && VB->TexCoordPtr[2] == 0)
+      VB->TexCoordPtr[2] = VB->TexCoordPtr[3];
+
+   if (DO_TEX2 && VB->TexCoordPtr[1] == 0)
+      VB->TexCoordPtr[1] = VB->TexCoordPtr[2];
+
+   if (DO_TEX1 && VB->TexCoordPtr[0] == 0)
+      VB->TexCoordPtr[0] = VB->TexCoordPtr[1];
+
+   if (DO_PTEX)
+      return GL_TRUE;
+
+   /* No hardware support for projective texture.  Can fake it for
+    * TEX0 only.
+    */
+   if ((DO_TEX3 && VB->TexCoordPtr[GET_TEXSOURCE(3)]->size == 4) ||
+       (DO_TEX2 && VB->TexCoordPtr[GET_TEXSOURCE(2)]->size == 4) ||
+       (DO_TEX1 && VB->TexCoordPtr[GET_TEXSOURCE(1)]->size == 4)) {
+      PTEX_FALLBACK();
+      return GL_FALSE;
+   }
+
+   if (DO_TEX0 && VB->TexCoordPtr[GET_TEXSOURCE(0)]->size == 4) {
+      if (DO_TEX1 || DO_TEX2 || DO_TEX3) {
+	 PTEX_FALLBACK();
+      }
+      return GL_FALSE;
+   }
+
+   return GL_TRUE;
+}
+#endif /* ptex */
+
+
+static void TAG(interp)( GLcontext *ctx,
+			 GLfloat t,
+			 GLuint edst, GLuint eout, GLuint ein,
+			 GLboolean force_boundary )
+{
+   LOCALVARS
+   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+   GLubyte *ddverts = GET_VERTEX_STORE();
+   GLuint shift = GET_VERTEX_STRIDE_SHIFT();
+   const GLfloat *dstclip = VB->ClipPtr->data[edst];
+   GLfloat w;
+   const GLfloat *s = GET_VIEWPORT_MAT();
+
+   VERTEX *dst = (VERTEX *)(ddverts + (edst << shift));
+   VERTEX *in  = (VERTEX *)(ddverts + (ein << shift));
+   VERTEX *out = (VERTEX *)(ddverts + (eout << shift));
+
+   (void)s;
+
+   if (HAVE_HW_DIVIDE && CHECK_HW_DIVIDE) {
+      VIEWPORT_X( dst->v.x, dstclip[0] );
+      VIEWPORT_Y( dst->v.y, dstclip[1] );
+      VIEWPORT_Z( dst->v.z, dstclip[2] );
+      w = dstclip[3];
+   }
+   else {
+      w = 1.0 / dstclip[3];
+      VIEWPORT_X( dst->v.x, dstclip[0] * w );
+      VIEWPORT_Y( dst->v.y, dstclip[1] * w );
+      VIEWPORT_Z( dst->v.z, dstclip[2] * w );
+   }
+
+   if ((HAVE_HW_DIVIDE && CHECK_HW_DIVIDE) || 
+       DO_FOG || DO_SPEC || DO_TEX0 || DO_TEX1 ||
+       DO_TEX2 || DO_TEX3 || !HAVE_TINY_VERTICES) {
+
+      dst->v.w = w;
+
+      INTERP_UB( t, dst->ub4[4][0], out->ub4[4][0], in->ub4[4][0] );
+      INTERP_UB( t, dst->ub4[4][1], out->ub4[4][1], in->ub4[4][1] );
+      INTERP_UB( t, dst->ub4[4][2], out->ub4[4][2], in->ub4[4][2] );
+      INTERP_UB( t, dst->ub4[4][3], out->ub4[4][3], in->ub4[4][3] );
+
+      if (DO_SPEC) {
+	 INTERP_UB( t, dst->v.specular.red,   out->v.specular.red,   in->v.specular.red );
+	 INTERP_UB( t, dst->v.specular.green, out->v.specular.green, in->v.specular.green );
+	 INTERP_UB( t, dst->v.specular.blue,  out->v.specular.blue,  in->v.specular.blue );
+      }
+      if (DO_FOG) {
+	 INTERP_UB( t, dst->v.specular.alpha, out->v.specular.alpha, in->v.specular.alpha );
+      }
+      if (DO_TEX0) {
+	 if (DO_PTEX) {
+	    if (HAVE_PTEX_VERTICES) {
+	       INTERP_F( t, dst->pv.u0, out->pv.u0, in->pv.u0 );
+	       INTERP_F( t, dst->pv.v0, out->pv.v0, in->pv.v0 );
+	       INTERP_F( t, dst->pv.q0, out->pv.q0, in->pv.q0 );
+	    } else {
+	       GLfloat wout = VB->ProjectedClipPtr->data[eout][3];
+	       GLfloat win = VB->ProjectedClipPtr->data[ein][3];
+	       GLfloat qout = out->pv.w / wout;
+	       GLfloat qin = in->pv.w / win;
+	       GLfloat qdst, rqdst;
+
+	       ASSERT( !HAVE_HW_DIVIDE );
+
+	       INTERP_F( t, dst->v.u0, out->v.u0 * qout, in->v.u0 * qin );
+	       INTERP_F( t, dst->v.v0, out->v.v0 * qout, in->v.v0 * qin );
+	       INTERP_F( t, qdst, qout, qin );
+
+	       rqdst = 1.0 / qdst;
+	       dst->v.u0 *= rqdst;
+	       dst->v.v0 *= rqdst;
+	       dst->v.w *= rqdst;
+	    }
+	 }
+	 else {
+	    INTERP_F( t, dst->v.u0, out->v.u0, in->v.u0 );
+	    INTERP_F( t, dst->v.v0, out->v.v0, in->v.v0 );
+	 }
+      }
+      if (DO_TEX1) {
+	 if (DO_PTEX) {
+	    INTERP_F( t, dst->pv.u1, out->pv.u1, in->pv.u1 );
+	    INTERP_F( t, dst->pv.v1, out->pv.v1, in->pv.v1 );
+	    INTERP_F( t, dst->pv.q1, out->pv.q1, in->pv.q1 );
+	 } else {
+	    INTERP_F( t, dst->v.u1, out->v.u1, in->v.u1 );
+	    INTERP_F( t, dst->v.v1, out->v.v1, in->v.v1 );
+	 }
+      }
+      else if (DO_PTEX) {
+	 dst->pv.q1 = 0.0;	/* must be a valid float on radeon */
+      }
+      if (DO_TEX2) {
+	 if (DO_PTEX) {
+	    INTERP_F( t, dst->pv.u2, out->pv.u2, in->pv.u2 );
+	    INTERP_F( t, dst->pv.v2, out->pv.v2, in->pv.v2 );
+	    INTERP_F( t, dst->pv.q2, out->pv.q2, in->pv.q2 );
+	 } else {
+	    INTERP_F( t, dst->v.u2, out->v.u2, in->v.u2 );
+	    INTERP_F( t, dst->v.v2, out->v.v2, in->v.v2 );
+	 }
+      }
+      if (DO_TEX3) {
+	 if (DO_PTEX) {
+	    INTERP_F( t, dst->pv.u3, out->pv.u3, in->pv.u3 );
+	    INTERP_F( t, dst->pv.v3, out->pv.v3, in->pv.v3 );
+	    INTERP_F( t, dst->pv.q3, out->pv.q3, in->pv.q3 );
+	 } else {
+	    INTERP_F( t, dst->v.u3, out->v.u3, in->v.u3 );
+	    INTERP_F( t, dst->v.v3, out->v.v3, in->v.v3 );
+	 }
+      }
+   } else {
+      /* 4-dword vertex.  Color is in v[3] and there is no oow coordinate.
+       */
+      INTERP_UB( t, dst->ub4[3][0], out->ub4[3][0], in->ub4[3][0] );
+      INTERP_UB( t, dst->ub4[3][1], out->ub4[3][1], in->ub4[3][1] );
+      INTERP_UB( t, dst->ub4[3][2], out->ub4[3][2], in->ub4[3][2] );
+      INTERP_UB( t, dst->ub4[3][3], out->ub4[3][3], in->ub4[3][3] );
+   }
+}
+
+#endif /* rgba && xyzw */
+
+
+static void TAG(init)( void )
+{
+   setup_tab[IND].emit = TAG(emit);
+
+#if (DO_XYZW && DO_RGBA)
+   setup_tab[IND].check_tex_sizes = TAG(check_tex_sizes);
+   setup_tab[IND].interp = TAG(interp);
+#endif
+
+   if (DO_SPEC)
+      setup_tab[IND].copy_pv = copy_pv_rgba4_spec5;
+   else if (HAVE_HW_DIVIDE || DO_SPEC || DO_FOG || DO_TEX0 || DO_TEX1 ||
+	    DO_TEX2 || DO_TEX3 || !HAVE_TINY_VERTICES)
+      setup_tab[IND].copy_pv = copy_pv_rgba4;
+   else
+      setup_tab[IND].copy_pv = copy_pv_rgba3;
+
+   if (DO_TEX3) {
+      if (DO_PTEX) {
+	 ASSERT(HAVE_PTEX_VERTICES);
+	 setup_tab[IND].vertex_format = PROJ_TEX3_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 18;
+	 setup_tab[IND].vertex_stride_shift = 7;
+      }
+      else {
+	 setup_tab[IND].vertex_format = TEX3_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 14;
+	 setup_tab[IND].vertex_stride_shift = 6;
+      }
+   }
+   else if (DO_TEX2) {
+      if (DO_PTEX) {
+	 ASSERT(HAVE_PTEX_VERTICES);
+	 setup_tab[IND].vertex_format = PROJ_TEX3_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 18;
+	 setup_tab[IND].vertex_stride_shift = 7;
+      }
+      else {
+	 setup_tab[IND].vertex_format = TEX2_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 12;
+	 setup_tab[IND].vertex_stride_shift = 6;
+      }
+   }
+   else if (DO_TEX1) {
+      if (DO_PTEX) {
+	 ASSERT(HAVE_PTEX_VERTICES);
+	 setup_tab[IND].vertex_format = PROJ_TEX1_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 12;
+	 setup_tab[IND].vertex_stride_shift = 6;
+      }
+      else {
+	 setup_tab[IND].vertex_format = TEX1_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 10;
+	 setup_tab[IND].vertex_stride_shift = 6;
+      }
+   }
+   else if (DO_TEX0) {
+      if (DO_PTEX && HAVE_PTEX_VERTICES) {
+	 setup_tab[IND].vertex_format = PROJ_TEX1_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 12;
+	 setup_tab[IND].vertex_stride_shift = 6;
+      } else {
+	 setup_tab[IND].vertex_format = TEX0_VERTEX_FORMAT;
+	 setup_tab[IND].vertex_size = 8;
+	 setup_tab[IND].vertex_stride_shift = 5;
+      }
+   }
+   else if (!HAVE_HW_DIVIDE && !DO_SPEC && !DO_FOG && HAVE_TINY_VERTICES) {
+      setup_tab[IND].vertex_format = TINY_VERTEX_FORMAT;
+      setup_tab[IND].vertex_size = 4;
+      setup_tab[IND].vertex_stride_shift = 4;
+   } else if (HAVE_NOTEX_VERTICES) {
+      setup_tab[IND].vertex_format = NOTEX_VERTEX_FORMAT;
+      setup_tab[IND].vertex_size = 6;
+      setup_tab[IND].vertex_stride_shift = 5;
+   } else {
+      setup_tab[IND].vertex_format = TEX0_VERTEX_FORMAT;
+      setup_tab[IND].vertex_size = 8;
+      setup_tab[IND].vertex_stride_shift = 5;
+   }
+
+   assert(setup_tab[IND].vertex_size * 4 <=
+          1 << setup_tab[IND].vertex_stride_shift);
+}
+
+
+#undef IND
+#undef TAG
Index: xc/extras/Mesa/src/tnl_dd/t_dd_vertex.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/t_dd_vertex.h:1.2
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/t_dd_vertex.h	Mon Dec 16 11:18:49 2002
@@ -0,0 +1,78 @@
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  4.0.3
+ *
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+typedef struct {
+   GLfloat x, y, z, w;
+} TAG(_coord_t);
+
+#ifdef COLOR_IS_RGBA
+typedef struct {
+#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+   GLubyte alpha, blue, green, red;
+#else
+   GLubyte red, green, blue, alpha;
+#endif
+} TAG(_color_t);
+#else
+typedef struct {
+#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+   GLubyte alpha, red, green, blue;
+#else
+   GLubyte blue, green, red, alpha;
+#endif
+} TAG(_color_t);
+#endif
+
+typedef union {
+   struct {
+      GLfloat x, y, z, w;
+      TAG(_color_t) color;
+      TAG(_color_t) specular;
+      GLfloat u0, v0;
+      GLfloat u1, v1;
+      GLfloat u2, v2;
+      GLfloat u3, v3;
+   } v;
+   struct {
+      GLfloat x, y, z, w;
+      TAG(_color_t) color;
+      TAG(_color_t) specular;
+      GLfloat u0, v0, q0;
+      GLfloat u1, v1, q1;
+      GLfloat u2, v2, q2;
+      GLfloat u3, v3, q3;
+   } pv;
+   struct {
+      GLfloat x, y, z;
+      TAG(_color_t) color;
+   } tv;
+   GLfloat f[24];
+   GLuint  ui[24];
+   GLubyte ub4[24][4];
+} TAG(Vertex), *TAG(VertexPtr);
+
Index: xc/extras/Mesa/src/tnl_dd/imm/NOTES.imm
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/NOTES.imm:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/NOTES.imm	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,112 @@
+
+NOTE:
+
+These files are incomplete.  They do not yet form a working
+implementation of hte concepts discused below.
+
+
+OVERVIEW
+
+The t_dd_imm_* files form a set of templates to produce driver -
+specific software tnl modules for a small subset of transformation and
+lighting states.
+
+The approach is quite different to the large vertex buffers of the
+src/tnl module, and is based around a cache of four recent vertices
+and a 'current' vertex which is updated directly from the Color,
+Normal, Texcoord, SecondaryColor and Fog entrypoints.
+
+The current vertex is actually a composite of the ctx->Current values
+and a partial hardware vertex maintained where the hardware values
+differ from those in ctx->Current.  For example, clamped color values
+are kept in the hardware vertex, while texcoords remain in
+ctx->Current.
+
+A crude diagram:
+
+       		+--------------+	+-------------------+
+		| ctx->Current |	| Current-HW-vertex |
+		+--------------+	+-------------------+
+		       \       	       	       	  /
+		       	\      			 /
+			 \     			/
+			  \    		       /
+			   ---------   --------
+			       	   |   |      
+			       	   v   v     
+	+--------+   +--------+  +--------+  +--------+ 
+	| vert-0 |   | vert-1 |  | vert-2 |  | vert-3 |		       	 
+	+--------+   +--------+  +--------+  +--------+		       	 
+				     |
+				     |
+				     v
+				     
+				    DMA
+
+
+Here values from ctx->Current and current-HW-vertex are merged to
+build vert-2, which is then dumped to hardware (DMA).  A state machine
+determines which vertex is built in turn, and how the vertices are
+used to present primitives to hardware.  These actions all occur
+during a call to Vertex{234}f{v}.
+
+Each vert-n includes clip coordinates and a clipmask in addition to
+the hardware (window) coordinates.  This information allows clipping
+to take place directly on these vertices, if need be.
+
+t_dd_imm_capi.h
+	
+	Color{34}{fub}{v}() implementations.  These update both
+	ctx->Current (unclamped float colors) and current-HW-vertex
+	with hardware-specific color values (typically unsigned
+	bytes).
+
+	When lighting is enabled, the functions from src/api_noop.c
+	should be used, which just update ctx->Current.  (The
+	current-hw-vertex colors are produced from lighting, which is
+	keyed to Normal3f).
+
+t_dd_imm_vb.c
+
+	Support functions for clipping and fallback.  See
+	t_dd_imm_primtmp.h.
+
+t_dd_imm_napi.c
+t_dd_imm_napi.h
+
+	Versions of Normal3f{v} to perform lighting with one or more
+	infinite lights.  Updates ctx->Current.Normal and the current
+	HW colors.
+
+	When lighting is disabled, use the functions from api_noop.c
+	instead.
+
+
+t_dd_imm_primtmp.h
+
+	State machine to control emission of vertices and primitives
+	to hardware.  Called indirectly from Vertex{234}f{v}.  Capable
+	of supporting hardware strip and fan primitives, and of
+	decomposing to discreet primitives for clipping or fallback,
+	or where the native primitive is unavailable.
+
+t_dd_imm_tapi.h
+
+	Implementations of TexCoord{v} and MultiTexCoord4f{v}ARB to
+	fire a callback when transitioning to projective texture.
+	Most drivers will need to change vertex format at this point,
+	some may need to enable a software rasterization fallback.
+
+t_dd_imm_vapi.h
+
+	Implementations of Vertex{234}f{v}.  These perform
+	transformation and cliptesting on their arguments, then jump
+	into the state machine implemented in primtmp.h.
+
+t_dd_imm_vertex.h
+
+	Support functions for building and clip-interpolating hardware
+	vertices.  Called from primtmp.h.
+
+
+Keith Whitwell, June 2001.
\ No newline at end of file
Index: xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_capi.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_capi.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_capi.h	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,420 @@
+/* $Id: t_dd_imm_capi.h,v 1.1 2001/09/23 15:44:23 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+/* Template for immediate mode color functions.
+ *
+ * FIXME: Floating-point color versions of these...
+ */
+
+
+static void TAG(Color3f)( GLfloat r, GLfloat g, GLfloat b )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = CLAMP(r, 0.0f, 1.0f);
+   CURRENT_COLOR( GCOMP ) = CLAMP(g, 0.0f, 1.0f);
+   CURRENT_COLOR( BCOMP ) = CLAMP(b, 0.0f, 1.0f);
+   CURRENT_COLOR( ACOMP ) = 1.0f;
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), r );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), g );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), b );
+   CURRENT_COLOR( ACOMP ) = 255;
+#endif
+}
+
+static void TAG(Color3fv)( const GLfloat *v )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = CLAMP(v[0], 0.0f, 1.0f);
+   CURRENT_COLOR( GCOMP ) = CLAMP(v[1], 0.0f, 1.0f);
+   CURRENT_COLOR( BCOMP ) = CLAMP(v[2], 0.0f, 1.0f);
+   CURRENT_COLOR( ACOMP ) = 1.0f;
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), v[0] );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), v[1] );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), v[2] );
+   CURRENT_COLOR( ACOMP ) = 255;
+#endif
+}
+
+static void TAG(Color3ub)( GLubyte r, GLubyte g, GLubyte b )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( r );
+   CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( g );
+   CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( b );
+   CURRENT_COLOR( ACOMP ) = 1.0f;
+#else
+   CURRENT_COLOR( RCOMP ) = r;
+   CURRENT_COLOR( GCOMP ) = g;
+   CURRENT_COLOR( BCOMP ) = b;
+   CURRENT_COLOR( ACOMP ) = 255;
+#endif
+}
+
+static void TAG(Color3ubv)( const GLubyte *v )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( v[0] );
+   CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( v[1] );
+   CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( v[2] );
+   CURRENT_COLOR( ACOMP ) = 1.0f;
+#else
+   CURRENT_COLOR( RCOMP ) = v[0];
+   CURRENT_COLOR( GCOMP ) = v[1];
+   CURRENT_COLOR( BCOMP ) = v[2];
+   CURRENT_COLOR( ACOMP ) = 255;
+#endif
+}
+
+static void TAG(Color4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = CLAMP(r, 0.0f, 1.0f);
+   CURRENT_COLOR( GCOMP ) = CLAMP(g, 0.0f, 1.0f);
+   CURRENT_COLOR( BCOMP ) = CLAMP(b, 0.0f, 1.0f);
+   CURRENT_COLOR( ACOMP ) = CLAMP(a, 0.0f, 1.0f);
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), r );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), g );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), b );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( ACOMP ), a );
+#endif
+}
+
+static void TAG(Color4fv)( const GLfloat *v )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = CLAMP(v[0], 0.0f, 1.0f);
+   CURRENT_COLOR( GCOMP ) = CLAMP(v[1], 0.0f, 1.0f);
+   CURRENT_COLOR( BCOMP ) = CLAMP(v[2], 0.0f, 1.0f);
+   CURRENT_COLOR( ACOMP ) = CLAMP(v[3], 0.0f, 1.0f);
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( RCOMP ), v[0] );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( GCOMP ), v[1] );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( BCOMP ), v[2] );
+   UNCLAMPED_FLOAT_TO_UBYTE( CURRENT_COLOR( ACOMP ), v[3] );
+#endif
+}
+
+static void TAG(Color4ub)( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( r );
+   CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( g );
+   CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( b );
+   CURRENT_COLOR( ACOMP ) = UBYTE_TO_FLOAT( a );
+#else
+   CURRENT_COLOR( RCOMP ) = r;
+   CURRENT_COLOR( GCOMP ) = g;
+   CURRENT_COLOR( BCOMP ) = b;
+   CURRENT_COLOR( ACOMP ) = a;
+#endif
+}
+
+static void TAG(Color4ubv)( const GLubyte *v )
+{
+   GET_CURRENT;
+#ifdef COLOR_IS_FLOAT
+   CURRENT_COLOR( RCOMP ) = UBYTE_TO_FLOAT( v[0] );
+   CURRENT_COLOR( GCOMP ) = UBYTE_TO_FLOAT( v[1] );
+   CURRENT_COLOR( BCOMP ) = UBYTE_TO_FLOAT( v[2] );
+   CURRENT_COLOR( ACOMP ) = UBYTE_TO_FLOAT( v[3] );
+#else
+   CURRENT_COLOR( RCOMP ) = v[0];
+   CURRENT_COLOR( GCOMP ) = v[1];
+   CURRENT_COLOR( BCOMP ) = v[2];
+   CURRENT_COLOR( ACOMP ) = v[3];
+#endif
+}
+
+
+static void TAG(ColorMaterial3f)( GLfloat r, GLfloat g, GLfloat b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = r;
+   color[1] = g;
+   color[2] = b;
+   color[3] = 1.0;
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+static void TAG(ColorMaterial3fv)( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = v[0];
+   color[1] = v[1];
+   color[2] = v[2];
+   color[3] = 1.0;
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+static void TAG(ColorMaterial3ub)( GLubyte r, GLubyte g, GLubyte b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = UBYTE_TO_FLOAT( r );
+   color[1] = UBYTE_TO_FLOAT( g );
+   color[2] = UBYTE_TO_FLOAT( b );
+   color[3] = 1.0;
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+static void TAG(ColorMaterial3ubv)( const GLubyte *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = UBYTE_TO_FLOAT( v[0] );
+   color[1] = UBYTE_TO_FLOAT( v[1] );
+   color[2] = UBYTE_TO_FLOAT( v[2] );
+   color[3] = 1.0;
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+static void TAG(ColorMaterial4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = r;
+   color[1] = g;
+   color[2] = b;
+   color[3] = a;
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+static void TAG(ColorMaterial4fv)( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = v[0];
+   color[1] = v[1];
+   color[2] = v[2];
+   color[3] = v[3];
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+static void TAG(ColorMaterial4ub)( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = UBYTE_TO_FLOAT( r );
+   color[1] = UBYTE_TO_FLOAT( g );
+   color[2] = UBYTE_TO_FLOAT( b );
+   color[3] = UBYTE_TO_FLOAT( a );
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+static void TAG(ColorMaterial4ubv)( const GLubyte *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat *color = ctx->Current.Color;
+
+   color[0] = UBYTE_TO_FLOAT( v[0] );
+   color[1] = UBYTE_TO_FLOAT( v[1] );
+   color[2] = UBYTE_TO_FLOAT( v[2] );
+   color[3] = UBYTE_TO_FLOAT( v[3] );
+
+   _mesa_update_color_material( ctx, color );
+   RECALC_BASE_COLOR( ctx );
+}
+
+
+
+
+
+/* =============================================================
+ * Color chooser functions:
+ */
+
+static void TAG(choose_Color3f)( GLfloat r, GLfloat g, GLfloat b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color3f = TAG(ColorMaterial3f);
+      } else {
+	 ctx->Exec->Color3f = _mesa_noop_Color3f;
+      }
+   } else {
+      ctx->Exec->Color3f = TAG(Color3f);
+   }
+   glColor3f( r, g, b );
+}
+
+static void TAG(choose_Color3fv)( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color3fv = TAG(ColorMaterial3fv);
+      } else {
+	 ctx->Exec->Color3fv = _mesa_noop_Color3fv;
+      }
+   } else {
+      ctx->Exec->Color3fv = TAG(Color3fv);
+   }
+   glColor3fv( v );
+}
+
+static void TAG(choose_Color3ub)( GLubyte r, GLubyte g, GLubyte b )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color3ub = TAG(ColorMaterial3ub);
+      } else {
+	 ctx->Exec->Color3ub = _mesa_noop_Color3ub;
+      }
+   } else {
+      ctx->Exec->Color3ub = TAG(Color3ub);
+   }
+   glColor3ub( r, g, b );
+}
+
+static void TAG(choose_Color3ubv)( const GLubyte *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color3ubv = TAG(ColorMaterial3ubv);
+      } else {
+	 ctx->Exec->Color3ubv = _mesa_noop_Color3ubv;
+      }
+   } else {
+      ctx->Exec->Color3ubv = TAG(Color3ubv);
+   }
+   glColor3ubv( v );
+}
+
+static void TAG(choose_Color4f)( GLfloat r, GLfloat g, GLfloat b, GLfloat a )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color4f = TAG(ColorMaterial4f);
+      } else {
+	 ctx->Exec->Color4f = _mesa_noop_Color4f;
+      }
+   } else {
+      ctx->Exec->Color4f = TAG(Color4f);
+   }
+   glColor4f( r, g, b, a );
+}
+
+static void TAG(choose_Color4fv)( const GLfloat *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color4fv = TAG(ColorMaterial4fv);
+      } else {
+	 ctx->Exec->Color4fv = _mesa_noop_Color4fv;
+      }
+   } else {
+      ctx->Exec->Color4fv = TAG(Color4fv);
+   }
+   glColor4fv( v );
+}
+
+static void TAG(choose_Color4ub)( GLubyte r, GLubyte g, GLubyte b, GLubyte a )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color4ub = TAG(ColorMaterial4ub);
+      } else {
+	 ctx->Exec->Color4ub = _mesa_noop_Color4ub;
+      }
+   } else {
+      ctx->Exec->Color4ub = TAG(Color4ub);
+   }
+   glColor4ub( r, g, b, a );
+}
+
+static void TAG(choose_Color4ubv)( const GLubyte *v )
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if ( ctx->Light.Enabled ) {
+      if ( ctx->Light.ColorMaterialEnabled ) {
+	 ctx->Exec->Color4ubv = TAG(ColorMaterial4ubv);
+      } else {
+	 ctx->Exec->Color4ubv = _mesa_noop_Color4ubv;
+      }
+   } else {
+      ctx->Exec->Color4ubv = TAG(Color4ubv);
+   }
+   glColor4ubv( v );
+}
+
+
+
+#undef GET_CURRENT
+#undef CURRENT_COLOR
+#undef CURRENT_SPECULAR
+#undef COLOR_IS_FLOAT
+#undef RECALC_BASE_COLOR
+#undef TAG
Index: xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_napi.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_napi.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_napi.h	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,229 @@
+/* $Id: t_dd_imm_napi.h,v 1.1 2001/09/23 15:44:23 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ *    Keith Whitwell <keith_whitwell@yahoo.com>
+ */
+
+/* Template for immediate mode normal functions.  Optimize for infinite
+ * lights when doing software lighting.
+ */
+
+static void TAG(Normal3f_single)( GLfloat x, GLfloat y, GLfloat z )
+{
+   GET_CURRENT_VERTEX;
+   const struct gl_light *light = ctx->Light.EnabledList.prev;
+   GLfloat n_dot_h, n_dot_VP, spec, sum[3];
+   GLfloat *normal = ctx->Current.Normal;
+   GLfloat scale = 1.0;
+
+   ASSIGN_3V( normal, x, y, z );
+   COPY_3V( sum, BASE_COLOR );
+
+   if ( IND & NORM_RESCALE ) {
+      scale = ctx->_ModelViewInvScale;
+   } else if ( IND & NORM_NORMALIZE ) {
+      scale = LEN_3FV( normal );
+      if ( scale != 0.0 ) scale = 1.0 / scale;
+   }
+
+   n_dot_VP = DOT3( normal, light->_VP_inf_norm ) * scale;
+   if ( n_dot_VP > 0.0F ) {
+      ACC_SCALE_SCALAR_3V( sum, n_dot_VP, light->_MatDiffuse[0] );
+      n_dot_h = DOT3( normal, light->_h_inf_norm ) * scale;
+      if ( n_dot_h > 0.0F ) {
+	 GET_SHINE_TAB_ENTRY( ctx->_ShineTable[0], n_dot_h, spec );
+	 ACC_SCALE_SCALAR_3V( sum, spec, light->_MatSpecular[0] );
+      }
+   }
+
+#ifdef LIT_COLOR_IS_FLOAT
+   LIT_COLOR ( RCOMP ) = CLAMP(sum[0], 0.0f, 0.1f);
+   LIT_COLOR ( GCOMP ) = CLAMP(sum[1], 0.0f, 0.1f);
+   LIT_COLOR ( BCOMP ) = CLAMP(sum[2], 0.0f, 0.1f);
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( RCOMP ), sum[0] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( GCOMP ), sum[1] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( BCOMP ), sum[2] );
+#endif
+   LIT_COLOR( ACOMP ) = LIT_ALPHA;
+}
+
+static void TAG(Normal3fv_single)( const GLfloat *normal )
+{
+   GET_CURRENT_VERTEX;
+   const struct gl_light *light = ctx->Light.EnabledList.prev;
+   GLfloat n_dot_h, n_dot_VP, spec, sum[3];
+   GLfloat scale = 1.0;
+
+   COPY_3V( ctx->Current.Normal, normal );
+   COPY_3V( sum, BASE_COLOR );
+
+   if ( IND & NORM_RESCALE ) {
+      scale = ctx->_ModelViewInvScale;
+   } else if ( IND & NORM_NORMALIZE ) {
+      scale = LEN_3FV( normal );
+      if ( scale != 0.0 ) scale = 1.0 / scale;
+   }
+
+   n_dot_VP = DOT3( normal, light->_VP_inf_norm ) * scale;
+   if ( n_dot_VP > 0.0F ) {
+      ACC_SCALE_SCALAR_3V( sum, n_dot_VP, light->_MatDiffuse[0] );
+      n_dot_h = DOT3( normal, light->_h_inf_norm ) * scale;
+      if ( n_dot_h > 0.0F ) {
+	 GET_SHINE_TAB_ENTRY( ctx->_ShineTable[0], n_dot_h, spec );
+	 ACC_SCALE_SCALAR_3V( sum, spec, light->_MatSpecular[0] );
+      }
+   }
+
+#ifdef LIT_COLOR_IS_FLOAT
+   LIT_COLOR ( RCOMP ) = CLAMP(sum[0], 0.0f, 0.1f);
+   LIT_COLOR ( GCOMP ) = CLAMP(sum[1], 0.0f, 0.1f);
+   LIT_COLOR ( BCOMP ) = CLAMP(sum[2], 0.0f, 0.1f);
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( RCOMP ), sum[0] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( GCOMP ), sum[1] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( BCOMP ), sum[2] );
+#endif
+   LIT_COLOR( ACOMP ) = LIT_ALPHA;
+}
+
+
+static void TAG(Normal3f_multi)( GLfloat x, GLfloat y, GLfloat z )
+{
+   GET_CURRENT_VERTEX;
+   struct gl_light *light;
+   GLfloat n_dot_h, n_dot_VP, spec, sum[3], tmp[3];
+   GLfloat *normal;
+
+   ASSIGN_3V( ctx->Current.Normal, x, y, z );
+   COPY_3V( sum, BASE_COLOR );
+
+   if ( IND & NORM_RESCALE ) {
+      normal = tmp;
+      ASSIGN_3V( normal, x, y, z );
+      SELF_SCALE_SCALAR_3V( normal, ctx->_ModelViewInvScale );
+   } else if ( IND & NORM_NORMALIZE ) {
+      normal = tmp;
+      ASSIGN_3V( normal, x, y, z );
+      NORMALIZE_3FV( normal );
+   } else {
+      normal = ctx->Current.Normal;
+   }
+
+   foreach ( light, &ctx->Light.EnabledList ) {
+      n_dot_VP = DOT3( normal, light->_VP_inf_norm );
+      if ( n_dot_VP > 0.0F ) {
+	 ACC_SCALE_SCALAR_3V( sum, n_dot_VP, light->_MatDiffuse[0] );
+	 n_dot_h = DOT3( normal, light->_h_inf_norm );
+	 if ( n_dot_h > 0.0F ) {
+	    GET_SHINE_TAB_ENTRY( ctx->_ShineTable[0], n_dot_h, spec );
+	    ACC_SCALE_SCALAR_3V( sum, spec, light->_MatSpecular[0] );
+	 }
+      }
+   }
+
+#ifdef LIT_COLOR_IS_FLOAT
+   LIT_COLOR ( RCOMP ) = CLAMP(sum[0], 0.0f, 0.1f);
+   LIT_COLOR ( GCOMP ) = CLAMP(sum[1], 0.0f, 0.1f);
+   LIT_COLOR ( BCOMP ) = CLAMP(sum[2], 0.0f, 0.1f);
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( RCOMP ), sum[0] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( GCOMP ), sum[1] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( BCOMP ), sum[2] );
+#endif
+   LIT_COLOR( ACOMP ) = LIT_ALPHA;
+}
+
+static void TAG(Normal3fv_multi)( const GLfloat *n )
+{
+   GET_CURRENT_VERTEX;
+   struct gl_light *light;
+   GLfloat n_dot_h, n_dot_VP, spec, sum[3], tmp[3];
+   GLfloat *normal;
+
+   COPY_3V( ctx->Current.Normal, n );
+   COPY_3V( sum, BASE_COLOR );
+
+   if ( IND & NORM_RESCALE ) {
+      normal = tmp;
+      COPY_3V( normal, n );
+      SELF_SCALE_SCALAR_3V( normal, ctx->_ModelViewInvScale );
+   } else if ( IND & NORM_NORMALIZE ) {
+      normal = tmp;
+      COPY_3V( normal, n );
+      NORMALIZE_3FV( normal );
+   } else {
+      normal = ctx->Current.Normal;
+   }
+
+   foreach ( light, &ctx->Light.EnabledList ) {
+      n_dot_VP = DOT3( normal, light->_VP_inf_norm );
+      if ( n_dot_VP > 0.0F ) {
+	 ACC_SCALE_SCALAR_3V( sum, n_dot_VP, light->_MatDiffuse[0] );
+	 n_dot_h = DOT3( normal, light->_h_inf_norm );
+	 if ( n_dot_h > 0.0F ) {
+	    GET_SHINE_TAB_ENTRY( ctx->_ShineTable[0], n_dot_h, spec );
+	    ACC_SCALE_SCALAR_3V( sum, spec, light->_MatSpecular[0] );
+	 }
+      }
+   }
+
+#ifdef LIT_COLOR_IS_FLOAT
+   LIT_COLOR ( RCOMP ) = CLAMP(sum[0], 0.0f, 0.1f);
+   LIT_COLOR ( GCOMP ) = CLAMP(sum[1], 0.0f, 0.1f);
+   LIT_COLOR ( BCOMP ) = CLAMP(sum[2], 0.0f, 0.1f);
+#else
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( RCOMP ), sum[0] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( GCOMP ), sum[1] );
+   UNCLAMPED_FLOAT_TO_UBYTE( LIT_COLOR( BCOMP ), sum[2] );
+#endif
+   LIT_COLOR( ACOMP ) = LIT_ALPHA;
+}
+
+
+
+static void TAG(init_norm)( void )
+{
+   norm_tab[IND].normal3f_single = TAG(Normal3f_single);
+   norm_tab[IND].normal3fv_single = TAG(Normal3fv_single);
+   norm_tab[IND].normal3f_multi = TAG(Normal3f_multi);
+   norm_tab[IND].normal3fv_multi = TAG(Normal3fv_multi);
+}
+
+#endif
+
+
+
+#ifndef PRESERVE_NORMAL_DEFS
+#undef GET_CURRENT
+#undef GET_CURRENT_VERTEX
+#undef LIT_COLOR
+#undef LIT_COLOR_IS_FLOAT
+#endif
+#undef PRESERVE_NORMAL_DEFS
+#undef IND
+#undef TAG
Index: xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_primtmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_primtmp.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_primtmp.h	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,571 @@
+/* $Id: t_dd_imm_primtmp.h,v 1.1 2001/09/23 15:44:23 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keithw@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
+ */
+
+/* Template for immediate mode vertices. 
+ *
+ * Probably instantiate once for each vertex format used:
+ *   - TINY_VERTICES
+ *   - TEX0_VERTICES
+ *   - TEX1_VERTICES
+ *   - PTEX_VERTICES
+ *
+ * Have to handle TEX->PTEX transition somehow.
+ */
+
+#define DBG 0
+
+
+
+/* =============================================================
+ * GL_POINTS
+ */
+
+static void TAG(flush_point_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   if ( !v0->mask ) {
+      LOCAL_VARS;
+      DRAW_POINT( v0 );
+   }
+}
+
+
+/* =============================================================
+ * GL_LINES
+ */
+
+static void TAG(flush_line_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_line_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   FLUSH_VERTEX = TAG(flush_line_1);
+   ACTIVE_VERTEX = IMM_VERTICES( 1 );
+}
+
+static void TAG(flush_line_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v1 = v0 - 1;
+   ACTIVE_VERTEX = IMM_VERTICES( 0 );
+   FLUSH_VERTEX = TAG(flush_line_0);
+   if (FALLBACK_OR_CLIPPING) 
+      CLIP_OR_DRAW_LINE( ctx, v1, v0 ); 
+   else
+      DRAW_LINE( ctx, v1, v0 ); 
+}
+
+
+/* =============================================================
+ * GL_LINE_LOOP
+ */
+
+static void TAG(flush_line_loop_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_line_loop_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_line_loop_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   ACTIVE_VERTEX = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_line_loop_1);
+}
+
+#define DRAW_LINELOOP_LINE( a, b )			\
+   if (!HAVE_LINE_STRIP || FALLBACK_OR_CLIPPING) {	\
+      CLIP_OR_DRAW_LINE( ctx, a, b );			\
+   } else if (EXTEND_PRIM( 1 )) {			\
+      EMIT_VERTEX( b );					\
+   } else {						\
+      BEGIN_PRIM( GL_LINE_STRIP, 2 ); 			\
+      EMIT_VERTEX( a );					\
+      EMIT_VERTEX( b );      				\
+   }
+
+static void TAG(flush_line_loop_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v1 = v0 - 1;
+   ACTIVE_VERTEX = v1;
+   FLUSH_VERTEX = TAG(flush_line_loop_2);
+   DRAW_LINELOOP_LINE( v1, v0 );
+}
+
+static void TAG(flush_line_loop_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v1 = v0 + 1;
+   ACTIVE_VERTEX = v1;
+   FLUSH_VERTEX = TAG(flush_line_loop_1);
+   DRAW_LINELOOP_LINE( v1, v0 );
+}
+
+static void TAG(end_line_loop)( GLcontext *ctx )
+{
+   LOCAL_VARS;
+
+   if ( FLUSH_VERTEX != TAG(flush_line_loop_0) ) {
+      TNL_VERTEX *v1 = ACTIVE_VERTEX;
+      TNL_VERTEX *v0 = IMM_VERTICES( 0 );
+      DRAW_LINELOOP_LINE( v1, v0 );
+   }
+}
+
+
+
+/* =============================================================
+ * GL_LINE_STRIP
+ */
+
+static void TAG(flush_line_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_line_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_line_strip_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   ACTIVE_VERTEX = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_line_strip_0b);
+}
+
+
+static void TAG(flush_line_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v1 = v0 - 1;
+
+   ACTIVE_VERTEX = v1;
+   FLUSH_VERTEX = TAG(flush_line_strip_2);
+
+   if (!HAVE_LINE_STRIP || FALLBACK_OR_CLIPPING)
+      CLIP_OR_DRAW_LINE( ctx, v1, v0 );
+   else if (EXTEND_PRIM( 1 )) {
+      EMIT_VERTEX( v0 );
+   } else {
+      BEGIN_PRIM( GL_LINE_STRIP, 2 ); 
+      EMIT_VERTEX( v1 );
+      EMIT_VERTEX( v0 );      
+   }      
+}
+
+static void TAG(flush_line_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v1 = v0 + 1;
+
+   ACTIVE_VERTEX = v1;
+   FLUSH_VERTEX = TAG(flush_line_strip_1);
+
+   if (!HAVE_LINE_STRIP || FALLBACK_OR_CLIPPING)
+      CLIP_OR_DRAW_LINE( ctx, v1, v0 );
+   else if (EXTEND_PRIM( 1 )) {
+      EMIT_VERTEX( v0 );
+   } else {
+      BEGIN_PRIM( GL_LINE_STRIP, 2 ); 
+      EMIT_VERTEX( v1 );
+      EMIT_VERTEX( v0 );      
+   }      
+}
+
+
+
+/* =============================================================
+ * GL_TRIANGLES
+ */
+
+static void TAG(flush_triangle_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_triangle_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_triangle_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   if ( DBG ) fprintf( stderr, __FUNCTION__ "\n" );
+
+   ACTIVE_VERTEX = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_triangle_1);
+   BEGIN_PRIM( GL_TRIANGLES, 0 );
+}
+
+static void TAG(flush_triangle_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   if ( DBG ) fprintf( stderr, __FUNCTION__ "\n" );
+
+   ACTIVE_VERTEX = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_triangle_2);
+}
+
+static void TAG(flush_triangle_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v2 = v0 - 2;
+   TNL_VERTEX *v1 = v0 - 1;
+
+   if ( DBG ) fprintf( stderr, __FUNCTION__ "\n" );
+
+   ACTIVE_VERTEX = v2;
+   FLUSH_VERTEX = TAG(flush_triangle_0);
+
+   /* nothing gained by trying to emit as hw primitives -- that
+    * happens normally in this case.  
+    */
+   if (FALLBACK_OR_CLIPPING)
+      CLIP_OR_DRAW_TRI( ctx, v2, v1, v0 );
+   else
+      DRAW_TRI( ctx, v2, v1, v0 );
+}
+
+
+
+
+/* =============================================================
+ * GL_TRIANGLE_STRIP
+ */
+
+static void TAG(flush_tri_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_tri_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_tri_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_tri_strip_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 1 );
+   FLUSH_VERTEX = TAG(flush_tri_strip_1);
+}
+
+static void TAG(flush_tri_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 2 );
+   FLUSH_VERTEX = TAG(flush_tri_strip_2);
+}
+
+#define DO_TRISTRIP_TRI( vert0, vert1 )				\
+   if (!HAVE_TRI_STRIP || FALLBACK_OR_CLIPPING) {	\
+      TNL_VERTEX *v2 = IMM_VERTICES( vert0 );			\
+      TNL_VERTEX *v1 = IMM_VERTICES( vert1 );			\
+      TAG(draw_tri)( ctx, v2, v1, v0 );				\
+   } else if (EXTEND_PRIM( 1 )) {				\
+      EMIT_VERTEX( v0 );					\
+   } else {							\
+      TNL_VERTEX *v2 = IMM_VERTICES( vert0 );			\
+      TNL_VERTEX *v1 = IMM_VERTICES( vert1 );			\
+      BEGIN_PRIM( GL_TRIANGLE_STRIP, 3 ); 			\
+      EMIT_VERTEX( v2 );					\
+      EMIT_VERTEX( v1 );      					\
+      EMIT_VERTEX( v0 );      					\
+   }      
+
+static void TAG(flush_tri_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   FLUSH_VERTEX = TAG(flush_tri_strip_3);
+   ACTIVE_VERTEX = IMM_VERTICES( 3 );
+   DO_TRISTRIP_TRI( 0, 1 );
+}
+
+static void TAG(flush_tri_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   FLUSH_VERTEX = TAG(flush_tri_strip_4);
+   ACTIVE_VERTEX = IMM_VERTICES( 0 );
+   DO_TRISTRIP_TRI( 1, 2 );
+}
+
+static void TAG(flush_tri_strip_4)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   FLUSH_VERTEX = TAG(flush_tri_strip_5);
+   ACTIVE_VERTEX = IMM_VERTICES( 1 );
+   DO_TRISTRIP_TRI( 2, 3 );
+}
+
+static void TAG(flush_tri_strip_5)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   FLUSH_VERTEX = TAG(flush_tri_strip_2);
+   ACTIVE_VERTEX = IMM_VERTICES( 2 );
+   DO_TRISTRIP_TRI( 0, 3 );
+}
+
+
+
+/* =============================================================
+ * GL_TRIANGLE_FAN
+ */
+
+static void TAG(flush_tri_fan_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_tri_fan_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_tri_fan_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   ACTIVE_VERTEX = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_tri_fan_1);
+}
+
+static void TAG(flush_tri_fan_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   ACTIVE_VERTEX = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_tri_fan_2);
+}
+
+#define DO_TRIFAN_TRI( vert0, vert1 )				\
+   if (!HAVE_TRI_FAN || FALLBACK_OR_CLIPPING) {	\
+      TNL_VERTEX *v2 = IMM_VERTICES( vert0 );			\
+      TNL_VERTEX *v1 = IMM_VERTICES( vert1 );			\
+      TAG(draw_tri)( ctx, v2, v1, v0 );				\
+   } else if (EXTEND_PRIM( 1 )) {				\
+      EMIT_VERTEX( v0 );					\
+   } else {							\
+      TNL_VERTEX *v2 = IMM_VERTICES( vert0 );			\
+      TNL_VERTEX *v1 = IMM_VERTICES( vert1 );			\
+      BEGIN_PRIM( GL_TRIANGLE_FAN, 3 ); 			\
+      EMIT_VERTEX( v2 );					\
+      EMIT_VERTEX( v1 );      					\
+      EMIT_VERTEX( v0 );      					\
+   }      
+
+static void TAG(flush_tri_fan_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 1 );
+   FLUSH_VERTEX = TAG(flush_tri_fan_3 );
+   DO_TRIFAN_TRI( 0, 1 );
+}
+
+static void TAG(flush_tri_fan_3)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 2 );
+   FLUSH_VERTEX = TAG(flush_tri_fan_2 );
+   DO_TRIFAN_TRI( 0, 2 );
+}
+
+
+
+/* =============================================================
+ * GL_QUADS
+ */
+
+static void TAG(flush_quad_3)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_quad_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_quad_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_quad_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   IMM_VERTEX( v0 ) = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_quad_1);
+}
+
+static void TAG(flush_quad_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   IMM_VERTEX( v0 ) = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_quad_2);
+}
+
+static void TAG(flush_quad_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   IMM_VERTEX( v0 ) = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_quad_3);
+}
+
+static void TAG(flush_quad_3)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v3 = v0 - 3;
+   TNL_VERTEX *v2 = v0 - 2;
+   TNL_VERTEX *v1 = v0 - 1;
+
+   IMM_VERTEX( v0 ) = v3;
+   FLUSH_VERTEX = TAG(flush_quad_0);
+
+   if (!HAVE_HW_QUADS || FALLBACK_OR_CLIPPING) {
+      CLIP_OR_DRAW_TRI( ctx, v3, v2, v0 );
+      CLIP_OR_DRAW_TRI( ctx, v2, v1, v0 );
+   } else {
+      EXTEND_PRIM_NF( GL_QUADS, 4 );
+      EMIT_VERTEX( v3 );
+      EMIT_VERTEX( v2 );
+      EMIT_VERTEX( v1 );      
+      EMIT_VERTEX( v0 );      
+   }
+}
+
+
+
+/* =============================================================
+ * GL_QUAD_STRIP
+ */
+
+static void TAG(flush_quad_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_quad_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_quad_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_quad_strip_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   IMM_VERTEX( v3 ) = v0;
+   IMM_VERTEX( v0 ) = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_quad_strip_1);
+}
+
+static void TAG(flush_quad_strip_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   IMM_VERTEX( v2 ) = v0;
+   IMM_VERTEX( v0 ) = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_quad_strip_2);
+}
+
+static void TAG(flush_quad_strip_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+
+   IMM_VERTEX( v1 ) = v0;
+   IMM_VERTEX( v0 ) = v0 + 1;
+   FLUSH_VERTEX = TAG(flush_quad_strip_3);
+}
+
+static void TAG(flush_quad_strip_3)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   TNL_VERTEX *v3 = IMM_VERTEX( v3 );
+   TNL_VERTEX *v2 = IMM_VERTEX( v2 );
+   TNL_VERTEX *v1 = IMM_VERTEX( v1 );
+
+   IMM_VERTEX( v0 ) = v3;
+   IMM_VERTEX( v2 ) = v0;
+   IMM_VERTEX( v3 ) = v1;
+   FLUSH_VERTEX = TAG(flush_quad_strip_2);
+
+   if (FALLBACK_OR_CLIPPING) {
+      CLIP_OR_DRAW_TRI( ctx, v3, v2, v0 );
+      CLIP_OR_DRAW_TRI( ctx, v2, v1, v0 );
+   } else {
+      DRAW_TRI( ctx, v3, v2, v0 );
+      DRAW_TRI( ctx, v2, v1, v0 );
+   }
+}
+
+
+
+/* =============================================================
+ * GL_POLYGON
+ */
+
+static void TAG(flush_poly_2)( GLcontext *ctx, TNL_VERTEX *v0 );
+static void TAG(flush_poly_1)( GLcontext *ctx, TNL_VERTEX *v0 );
+
+static void TAG(flush_poly_0)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 1 );
+   FLUSH_VERTEX = TAG(flush_poly_1);
+}
+
+static void TAG(flush_poly_1)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 2 );
+   FLUSH_VERTEX = TAG(flush_poly_2);
+}
+
+#define DO_POLY_TRI( vert0, vert1 )				\
+   if (!HAVE_POLYGONS || FALLBACK_OR_CLIPPING) {	\
+      TNL_VERTEX *v2 = IMM_VERTICES( vert0 );			\
+      TNL_VERTEX *v1 = IMM_VERTICES( vert1 );			\
+      TAG(draw_tri)( ctx, v1, v0, v2 );				\
+   } else if (EXTEND_PRIM( 1 )) {				\
+      EMIT_VERTEX( v0 );					\
+   } else {							\
+      TNL_VERTEX *v2 = IMM_VERTICES( vert0 );			\
+      TNL_VERTEX *v1 = IMM_VERTICES( vert1 );			\
+      BEGIN_PRIM( GL_POLYGON, 3 );				\
+      EMIT_VERTEX( v2 );					\
+      EMIT_VERTEX( v1 );					\
+      EMIT_VERTEX( v0 );					\
+   }      
+
+static void TAG(flush_poly_2)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 1 );
+   FLUSH_VERTEX = TAG(flush_poly_3);
+   DO_POLY_TRI( 0, 1 );
+}
+
+static void TAG(flush_poly_3)( GLcontext *ctx, TNL_VERTEX *v0 )
+{
+   LOCAL_VARS;
+   ACTIVE_VERTEX = IMM_VERTICES( 2 );
+   FLUSH_VERTEX = TAG(flush_poly_2);
+   DO_POLY_TRI( 0, 2 );
+}
+
+
+void (*TAG(flush_tab)[GL_POLYGON+1])( GLcontext *, TNL_VERTEX * ) =
+{
+   TAG(flush_point),
+   TAG(flush_line_0),
+   TAG(flush_line_loop_0),
+   TAG(flush_line_strip_0),
+   TAG(flush_triangle_0),
+   TAG(flush_tri_strip_0),
+   TAG(flush_tri_fan_0),
+   TAG(flush_quad_0),
+   TAG(flush_quad_strip_0),
+   TAG(flush_poly_0),
+};
+
+
+#ifndef PRESERVE_PRIM_DEFS
+#undef LOCAL_VARS
+#undef GET_INTERP_FUNC
+#undef IMM_VERTEX
+#undef IMM_VERTICES
+#undef FLUSH_VERTEX
+#endif
+#undef PRESERVE_PRIM_DEFS
+#undef EXTEND_PRIM
+#undef EMIT_VERTEX
+#undef EMIT_VERTEX_TRI
+#undef EMIT_VERTEX_LINE
+#undef EMIT_VERTEX_POINT
+#undef TAG
Index: xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_tapi.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_tapi.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_tapi.h	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,76 @@
+/* $Id: t_dd_imm_tapi.h,v 1.1 2001/09/23 15:44:23 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ *    Keith Whitwell <keith_whitwell@yahoo.com>
+ */
+
+/* Template for immediate mode texture coordinate functions.
+ */
+
+#ifndef DO_PROJ_TEX
+#error "Need to define DO_PROJ_TEX"
+#endif
+
+
+/* =============================================================
+ * Notify on calls to texture4f, to allow switch to projected texture
+ * vertex format:
+ */
+
+static void TAG(TexCoord4f)( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
+   GET_CURRENT;
+   DO_PROJ_TEX;
+   TEXCOORD4( s, t, r, q );
+}
+
+static void TAG(TexCoord4fv)( const GLfloat *v )
+{
+   GET_CURRENT;
+   DO_PROJ_TEX;
+   TEXCOORD4( v[0], v[1], v[2], v[3] );
+}
+
+static void TAG(MultiTexCoord4fARB)( GLenum target, GLfloat s,
+				     GLfloat t, GLfloat r, GLfloat q )
+{
+   GET_CURRENT;
+   DO_PROJ_TEX;
+   MULTI_TEXCOORD4( unit, s, t, r, q );
+}
+
+static void TAG(MultiTexCoord4fvARB)( GLenum target, const GLfloat *v )
+{
+   GET_CURRENT;
+   DO_PROJ_TEX;
+   MULTI_TEXCOORD4( unit, v[0], v[1], v[2], v[3] );
+}
+
+
+
+#undef DO_PROJ_TEX
+#undef TAG
Index: xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vapi.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vapi.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vapi.h	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,160 @@
+/* $Id: t_dd_imm_vapi.h,v 1.1 2001/09/23 15:44:23 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Gareth Hughes <gareth@valinux.com>
+ *    Keith Whitwell <keithw@valinux.com>
+ */
+
+/* Template for immediate mode vertex functions.
+ */
+
+#define DBG 0
+
+#define VERTEX( ox, oy, oz, ow )
+do {
+   GET_CURRENT_VERTEX;
+   GLfloat w;
+   GLuint mask;
+   const GLfloat * const m = ctx->_ModelProjectMatrix.m;
+
+   if (DO_FULL_MATRIX) {
+      VERTEX_CLIP(0) = m[0] * ox + m[4] * oy + m[8]  * oz + m[12] * ow;
+      VERTEX_CLIP(1) = m[1] * ox + m[5] * oy + m[9]  * oz + m[13] * ow;
+      VERTEX_CLIP(2) = m[2] * ox + m[6] * oy + m[10] * oz + m[14] * ow;
+      VERTEX_CLIP(3) = m[3] * ox + m[7] * oy + m[11] * oz + m[15] * ow;
+      w = VERTEX_CLIP(3);
+   }
+   else if (DO_NOROT_MATRIX) {
+      VERTEX_CLIP(0) = m[0] * ox                          + m[12] * ow;
+      VERTEX_CLIP(1) =             m[5] * oy              + m[13] * ow;
+      VERTEX_CLIP(2) =                         m[10] * oz + m[14] * ow;
+      VERTEX_CLIP(3) =                                              ow;
+      w = ow;
+   } 
+   else {
+      ASSERT (DO_IDENTITY_MATRIX);
+      VERTEX_CLIP(0) = ox;
+      VERTEX_CLIP(1) = oy;
+      VERTEX_CLIP(2) = oz;
+      VERTEX_CLIP(3) = ow;
+      w = ow;
+   }
+
+   mask = 0;
+   if (DO_CLIP_TEST) {
+      if ( VERTEX_CLIP(0) >  w ) mask |= CLIP_RIGHT_BIT;
+      if ( VERTEX_CLIP(0) < -w ) mask |= CLIP_LEFT_BIT;
+      if ( VERTEX_CLIP(1) >  w ) mask |= CLIP_TOP_BIT;
+      if ( VERTEX_CLIP(1) < -w ) mask |= CLIP_BOTTOM_BIT;
+      if ( VERTEX_CLIP(2) >  w ) mask |= CLIP_FAR_BIT;
+      if ( VERTEX_CLIP(2) < -w ) mask |= CLIP_NEAR_BIT;
+      VERTEX_MASK(v) = mask;
+   }
+
+   if (!mask) {
+      if (HAVE_VERTEX_WIN) {
+	 if (!HAVE_HW_VIEWPORT) {
+	    const GLfloat *s = GET_VIEWPORT_MATRIX();
+	    if (HAVE_W && HAVE_HW_DIVIDE) {
+	       VERTEX_WIN( 0 ) = s[0]  * VERTEX_CLIP( 0 ) + s[12];
+	       VERTEX_WIN( 1 ) = s[5]  * VERTEX_CLIP( 1 ) + s[13];
+	       VERTEX_WIN( 2 ) = s[10] * VERTEX_CLIP( 2 ) + s[14];
+	       VERTEX_WIN( 3 ) = w;
+	    }
+	    else {
+	       const GLfloat oow = 1.0/w; /* possibly opt away */
+	       VERTEX_WIN( 0 ) = s[0]  * VERTEX_CLIP( 0 ) * oow + s[12];
+	       VERTEX_WIN( 1 ) = s[5]  * VERTEX_CLIP( 1 ) * oow + s[13];
+	       VERTEX_WIN( 2 ) = s[10] * VERTEX_CLIP( 2 ) * oow + s[14];
+	       if (HAVE_W)
+		  VERTEX_WIN( 3 ) = oow;
+	    }
+	 }
+	 else if (HAVE_W && HAVE_HW_DIVIDE) {
+	    if (!VERTEX_WIN_IS_VERTEX_CLIP) {
+	       VERTEX_WIN( 0 ) = VERTEX_CLIP( 0 );
+	       VERTEX_WIN( 1 ) = VERTEX_CLIP( 1 );
+	       VERTEX_WIN( 2 ) = VERTEX_CLIP( 2 );
+	       VERTEX_WIN( 3 ) = w;
+	    }
+	 }
+	 else {
+	    const GLfloat oow = 1.0/w; /* possibly opt away */
+	    VERTEX_WIN( 0 ) = VERTEX_CLIP( 0 ) * oow;
+	    VERTEX_WIN( 1 ) = VERTEX_CLIP( 1 ) * oow;
+	    VERTEX_WIN( 2 ) = VERTEX_CLIP( 2 ) * oow;
+	    if (HAVE_W)
+	       VERTEX_WIN( 3 ) = oow;
+	 }
+      }
+   } else if (!FALLBACK_OR_CLIPPING) {
+      SET_CLIPPING();		/* transition to clipping */
+   }
+
+   COPY_VERTEX_FROM_CURRENT;
+   BUILD_PRIM_FROM_VERTEX;
+}
+
+/* Let the compiler optimize away the constant operations:
+ */
+static void VTAG(Vertex2f)( GLfloat ox, GLfloat oy )
+{
+   /* Cliptest on clip[2] could also be eliminated...
+    */
+   VERTEX( ox, oy, 0, 1 );
+}
+
+static void VTAG(Vertex2fv)( const GLfloat *obj )
+{
+   /* Cliptest on clip[2] could also be eliminated...
+    */
+   VERTEX( obj[0], obj[1], 0, 1 );
+}
+
+static void VTAG(Vertex3f)( GLfloat ox, GLfloat oy, GLfloat oz )
+{
+   VERTEX( ox, oy, oz, 1 );
+}
+
+static void VTAG(Vertex3fv)( const GLfloat *obj )
+{
+   VERTEX( obj[0], obj[1], obj[2], 1 );
+}
+
+static void VTAG(Vertex4f)( GLfloat ox, GLfloat oy, GLfloat oz, GLfloat ow )
+{
+   VERTEX( ox, oy, oz, ow );
+}
+
+static void VTAG(Vertex4fv)( const GLfloat *obj )
+{
+   VERTEX( obj[0], obj[1], obj[2], obj[3] );
+}
+
+
+#undef DO_FULL_MATRIX
+#undef VTAG
+#undef VERTEX
Index: xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vb.c
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vb.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vb.c	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,205 @@
+/* $Id: t_dd_imm_vb.c,v 1.1 2001/09/23 15:44:23 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keith_whitwell@yahoo.com>
+ */
+
+/* Template to build clipping routines to support t_dd_imm_primtmp.h.
+ *
+ * The TAG(draw_line) and TAG(draw_triangle) routines are called in
+ * clipping and fallback scenarios, and when the native hardware
+ * primitive (eg polygons) is unavailable.
+ */
+
+
+#define CLIP_DOTPROD(K, A, B, C, D)		\
+   (CLIP_X(K)*A + CLIP_Y(K)*B + 	\
+    CLIP_Z(K)*C + CLIP_W(K)*D)
+
+#define POLY_CLIP( PLANE, A, B, C, D )					\
+do {									\
+   if (mask & PLANE) {							\
+      TNL_VERTEX **indata = inlist[in];					\
+      TNL_VERTEX **outdata = inlist[in ^= 1];				\
+      TNL_VERTEX *J = indata[0];					\
+      GLfloat dpJ = CLIP_DOTPROD(J, A, B, C, D );			\
+      GLuint outcount = 0;						\
+      GLuint i;								\
+									\
+      indata[n] = indata[0]; /* prevent rotation of vertices */		\
+      for (i = 1; i <= n; i++) {					\
+	 TNL_VERTEX *I = indata[i];					\
+	 GLfloat dpI = CLIP_DOTPROD(idx, A, B, C, D );			\
+									\
+	 if (!NEGATIVE(dpPrev)) {					\
+	    outdata[outcount++] = J;					\
+	 }								\
+									\
+	 if (DIFFERENT_SIGNS(dpI, dpJ)) {				\
+            TNL_VERTEX *O = verts++;					\
+            outdata[outcount++] = O;					\
+	    if (NEGATIVE(dpI)) {					\
+	       /* Going out of bounds.  Avoid division by zero as we	\
+		* know dp != dpPrev from DIFFERENT_SIGNS, above.	\
+		*/							\
+	       GLfloat t = dpI / (dpI - dpJ);				\
+      	       INTERP( ctx, t, O, I, J );				\
+	    } else {							\
+	       /* Coming back in.					\
+		*/							\
+	       GLfloat t = dpJ / (dpJ - dpI);				\
+	       INTERP( ctx, t, O, J, I );				\
+	    }								\
+	 }								\
+									\
+	 J = I;								\
+	 dpJ = dpI;							\
+      }									\
+									\
+      if (outcount < 3)							\
+	 return;							\
+									\
+      nr = outcount;							\
+   }									\
+} while (0)
+
+
+#define LINE_CLIP(PLANE, A, B, C, D )			\
+do {							\
+   if (mask & PLANE) {					\
+      GLfloat dpI = CLIP_DOTPROD( I, A, B, C, D );	\
+      GLfloat dpJ = CLIP_DOTPROD( J, A, B, C, D );	\
+							\
+      if (DIFFERENT_SIGNS(dpI, dpJ)) {			\
+         TNL_VERTEX *O = verts++;			\
+	 if (NEGATIVE(dpJ)) {				\
+	    GLfloat t = dpI / (dpI - dpJ);		\
+	    INTERP( ctx, t, O, I, J );	\
+            J = O;					\
+	 } else {					\
+  	    GLfloat t = dpJ / (dpJ - dpI);		\
+	    INTERP( ctx, t, O, J, I );	\
+            I = O;					\
+	 }						\
+      }							\
+      else if (NEGATIVE(dpI))				\
+	 return;					\
+  }							\
+} while (0)
+
+
+
+/* Clip a line against the viewport and user clip planes.
+ */
+static void TAG(clip_draw_line)( GLcontext *ctx,
+				 TNL_VERTEX *I,
+				 TNL_VERTEX *J,
+				 GLuint mask )
+{
+   LOCAL_VARS;
+   GET_INTERP_FUNC;
+   TNL_VERTEX tmp[MAX_CLIPPED_VERTICES];
+   TNL_VERTEX *verts = tmp;
+   TNL_VERTEX *pv = J;
+
+   LINE_CLIP( CLIP_RIGHT_BIT,  -1,  0,  0, 1 );
+   LINE_CLIP( CLIP_LEFT_BIT,    1,  0,  0, 1 );
+   LINE_CLIP( CLIP_TOP_BIT,     0, -1,  0, 1 );
+   LINE_CLIP( CLIP_BOTTOM_BIT,  0,  1,  0, 1 );
+   LINE_CLIP( CLIP_FAR_BIT,     0,  0, -1, 1 );
+   LINE_CLIP( CLIP_NEAR_BIT,    0,  0,  1, 1 );
+
+   if ((ctx->_TriangleCaps & DD_FLATSHADE) && J != pv)
+      COPY_PV( ctx, J, pv );
+
+   DRAW_LINE( I, J );
+}
+
+
+/* Clip a triangle against the viewport and user clip planes.
+ */
+static void TAG(clip_draw_triangle)( GLcontext *ctx,
+				     TNL_VERTEX *v0,
+				     TNL_VERTEX *v1,
+				     TNL_VERTEX *v2,
+				     GLuint mask )
+{
+   LOCAL_VARS;
+   GET_INTERP_FUNC;
+   TNL_VERTEX tmp[MAX_CLIPPED_VERTICES];
+   TNL_VERTEX *verts = tmp;
+   TNL_VERTEX *(inlist[2][MAX_CLIPPED_VERTICES]);
+   TNL_VERTEX **out;
+   GLuint in = 0;
+   GLuint n = 3;
+   GLuint i;
+
+   ASSIGN_3V(inlist, v2, v0, v1 ); /* pv rotated to slot zero */
+
+   POLY_CLIP( CLIP_RIGHT_BIT,  -1,  0,  0, 1 );
+   POLY_CLIP( CLIP_LEFT_BIT,    1,  0,  0, 1 );
+   POLY_CLIP( CLIP_TOP_BIT,     0, -1,  0, 1 );
+   POLY_CLIP( CLIP_BOTTOM_BIT,  0,  1,  0, 1 );
+   POLY_CLIP( CLIP_FAR_BIT,     0,  0, -1, 1 );
+   POLY_CLIP( CLIP_NEAR_BIT,    0,  0,  1, 1 );
+
+   if ((ctx->_TriangleCaps & DD_FLATSHADE) && v2 != inlist[0]) 
+      COPY_PV( ctx, inlist[0], v2 );
+
+   out = inlist[in];
+   DRAW_POLYGON( out, n );
+}
+
+
+static __inline void TAG(draw_triangle)( GLcontext *ctx,
+					 TNL_VERTEX *v0,
+					 TNL_VERTEX *v1,
+					 TNL_VERTEX *v2 )
+{
+   LOCAL_VARS;
+   GLubyte ormask = (v0->mask | v1->mask | v2->mask);
+
+   if ( !ormask ) {
+      DRAW_TRI( v0, v1, v2 );
+   } else if ( !(v0->mask & v1->mask & v2->mask) ) {
+      TAG(clip_draw_triangle)( ctx, v0, v1, v2, ormask );
+   }
+}
+
+static __inline void TAG(draw_line)( GLcontext *ctx,
+				     TNL_VERTEX *v0,
+				     TNL_VERTEX *v1 )
+{
+   LOCAL_VARS;
+   GLubyte ormask = (v0->mask | v1->mask);
+
+   if ( !ormask ) {
+      DRAW_LINE( v0, v1 );
+   } else if ( !(v0->mask & v1->mask) ) {
+      TAG(clip_draw_line)( ctx, v0, v1, ormask );
+   }
+}
+
Index: xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vbtmp.h
diff -u /dev/null xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vbtmp.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:05 2003
+++ xc/extras/Mesa/src/tnl_dd/imm/t_dd_imm_vbtmp.h	Fri Feb 22 12:14:15 2002
@@ -0,0 +1,269 @@
+/* $Id: t_dd_imm_vbtmp.h,v 1.1 2001/09/23 15:44:23 keithw Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.5
+ *
+ * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Keith Whitwell <keith_whitwell@yahoo.com>
+ */
+
+/* Template to build support for t_dd_imm_* tnl module using vertices
+ * as defined in t_dd_vertex.h.
+ *
+ * See t_dd_vbtmp.h for definitions of arguments to this file.
+ * Unfortunately it seems necessary to duplicate a lot of that code.
+ */
+
+#ifndef LOCALVARS
+#define LOCALVARS
+#endif
+
+
+
+/* COPY_VERTEX_FROM_CURRENT in t_dd_imm_vapi.c
+ */
+static void TAG(emit_vfmt)( GLcontext *ctx, VERTEX *v )
+{
+   LOCALVARS
+      ;
+
+   /* This template assumes (like t_dd_vbtmp.h) that color is ubyte.
+    */
+   if (DO_TEX0 || DO_TEX1 || !HAVE_TINY_VERTICES)
+   {
+      const GLubyte *col = GET_HARDWARE_COLOR();
+      if (HAVE_RGBA_COLOR) {
+	 v->v.ui[4] = *(GLuint *)&col;
+      } else {
+	 v->v.color.blue  = col[2];
+	 v->v.color.green = col[1];
+	 v->v.color.red   = col[0];
+	 v->v.color.alpha = col[3];
+      }
+   }
+   else {
+      if (HAVE_RGBA_COLOR) {
+	 v->v.ui[3] = *(GLuint *)col;
+      }
+      else {
+	 v->tv.color.blue  = col[2];
+	 v->tv.color.green = col[1];
+	 v->tv.color.red   = col[0];
+	 v->tv.color.alpha = col[3];
+      }
+   }
+
+   if (DO_TEX0) {
+      GLfloat *tc = ctx->Current.Texture[0];
+      v->v.u0 = tc[0];
+      v->v.v0 = tc[1];
+      if (DO_PTEX) {
+	 if (HAVE_PTEX_VERTICES) {
+	    v->pv.q0 = tc[3];
+	 } 
+	 else {
+	    float rhw = 1.0 / tc[3];
+	    v->v.w *= tc[3];
+	    v->v.u0 *= rhw;
+	    v->v.v0 *= rhw;
+	 } 
+      } 
+   }
+   if (DO_TEX1) {
+      GLfloat *tc = ctx->Current.Texture[1];
+      if (DO_PTEX) {
+	 v->pv.u1 = tc[0];
+	 v->pv.v1 = tc[1];
+	 v->pv.q1 = tc[3];
+      } 
+      else {
+	 v->v.u1 = tc[0];
+	 v->v.v1 = tc[1];
+      }
+   } 
+   else if (DO_PTEX) {
+      *(GLuint *)&v->pv.q1 = 0;	/* avoid culling on radeon */
+   }
+   if (DO_TEX2) {
+      GLfloat *tc = ctx->Current.Texture[2];
+      if (DO_PTEX) {
+	 v->pv.u2 = tc[0];
+	 v->pv.v2 = tc[1];
+	 v->pv.q2 = tc[3];
+      } 
+      else {
+	 v->v.u2 = tc[0];
+	 v->v.v2 = tc[1];
+      }
+   } 
+   if (DO_TEX3) {
+      GLfloat *tc = ctx->Current.Texture[3];
+      if (DO_PTEX) {
+	 v->pv.u3 = tc[0];
+	 v->pv.v3 = tc[1];
+	 v->pv.q3 = tc[3];
+      } 
+      else {
+	 v->v.u3 = tc[0];
+	 v->v.v3 = tc[1];
+      }
+   } 
+}
+
+
+
+
+static void TAG(interp)( GLcontext *ctx,
+			 GLfloat t,
+			 TNL_VERTEX *dst,
+			 TNL_VERTEX *in,
+			 TNL_VERTEX *out )
+{
+   LOCALVARS
+   const GLfloat *s = GET_VIEWPORT_MAT();
+   GLfloat w;
+
+   (void)s;
+
+   if (HAVE_HW_DIVIDE) {
+      VIEWPORT_X( dst->v.v.x, dst->clip[0] );
+      VIEWPORT_Y( dst->v.v.y, dst->clip[1] );
+      VIEWPORT_Z( dst->v.v.z, dst->clip[2] );
+      w = dstclip[3];
+   }
+   else {
+      w = 1.0 / dst->clip[3];
+      VIEWPORT_X( dst->v.v.x, dst->clip[0] * w );
+      VIEWPORT_Y( dst->v.v.y, dst->clip[1] * w );
+      VIEWPORT_Z( dst->v.v.z, dst->clip[2] * w );
+   }
+
+   if (HAVE_HW_DIVIDE || DO_TEX0) {
+
+      dst->v.v.w = w;
+
+      INTERP_UB( t, dst->v.ub4[4][0], out->v.ub4[4][0], in->v.ub4[4][0] );
+      INTERP_UB( t, dst->v.ub4[4][1], out->v.ub4[4][1], in->v.ub4[4][1] );
+      INTERP_UB( t, dst->v.ub4[4][2], out->v.ub4[4][2], in->v.ub4[4][2] );
+      INTERP_UB( t, dst->v.ub4[4][3], out->v.ub4[4][3], in->v.ub4[4][3] );
+
+      if (DO_TEX0) {
+	 if (DO_PTEX) {
+	    if (HAVE_PTEX_VERTICES) {
+	       INTERP_F( t, dst->v.pv.u0, out->v.pv.u0, in->v.pv.u0 );
+	       INTERP_F( t, dst->v.pv.v0, out->v.pv.v0, in->v.pv.v0 );
+	       INTERP_F( t, dst->v.pv.q0, out->v.pv.q0, in->v.pv.q0 );
+	    } else {
+	       GLfloat wout = out->clip[3]; /* projected clip */
+	       GLfloat win = in->clip[3]; /* projected clip */
+	       GLfloat qout = out->v.pv.w / wout;
+	       GLfloat qin = in->v.pv.w / win;
+	       GLfloat qdst, rqdst;
+
+	       ASSERT( !HAVE_HW_DIVIDE ); /* assert win, wout projected clip */
+
+	       INTERP_F( t, dst->v.v.u0, out->v.v.u0 * qout, in->v.v.u0 * qin );
+	       INTERP_F( t, dst->v.v.v0, out->v.v.v0 * qout, in->v.v.v0 * qin );
+	       INTERP_F( t, qdst, qout, qin );
+
+	       rqdst = 1.0 / qdst;
+	       dst->v.v.u0 *= rqdst;
+	       dst->v.v.v0 *= rqdst;
+	       dst->v.v.w *= rqdst;
+	    }
+	 }
+	 else {
+	    INTERP_F( t, dst->v.v.u0, out->v.v.u0, in->v.v.u0 );
+	    INTERP_F( t, dst->v.v.v0, out->v.v.v0, in->v.v.v0 );
+	 }
+      }
+      if (DO_TEX1) {
+	 if (DO_PTEX) {
+	    INTERP_F( t, dst->v.pv.u1, out->v.pv.u1, in->v.pv.u1 );
+	    INTERP_F( t, dst->v.pv.v1, out->v.pv.v1, in->v.pv.v1 );
+	    INTERP_F( t, dst->v.pv.q1, out->v.pv.q1, in->v.pv.q1 );
+	 } else {
+	    INTERP_F( t, dst->v.v.u1, out->v.v.u1, in->v.v.u1 );
+	    INTERP_F( t, dst->v.v.v1, out->v.v.v1, in->v.v.v1 );
+	 }
+      }
+      else if (DO_PTEX) {
+	 dst->v.pv.q0 = 0.0;	/* must be a valid float on radeon */
+      }
+      if (DO_TEX2) {
+	 if (DO_PTEX) {
+	    INTERP_F( t, dst->v.pv.u2, out->v.pv.u2, in->v.pv.u2 );
+	    INTERP_F( t, dst->v.pv.v2, out->v.pv.v2, in->v.pv.v2 );
+	    INTERP_F( t, dst->v.pv.q2, out->v.pv.q2, in->v.pv.q2 );
+	 } else {
+	    INTERP_F( t, dst->v.v.u2, out->v.v.u2, in->v.v.u2 );
+	    INTERP_F( t, dst->v.v.v2, out->v.v.v2, in->v.v.v2 );
+	 }
+      }
+      if (DO_TEX3) {
+	 if (DO_PTEX) {
+	    INTERP_F( t, dst->v.pv.u3, out->v.pv.u3, in->v.pv.u3 );
+	    INTERP_F( t, dst->v.pv.v3, out->v.pv.v3, in->v.pv.v3 );
+	    INTERP_F( t, dst->v.pv.q3, out->v.pv.q3, in->v.pv.q3 );
+	 } else {
+	    INTERP_F( t, dst->v.v.u3, out->v.v.u3, in->v.v.u3 );
+	    INTERP_F( t, dst->v.v.v3, out->v.v.v3, in->v.v.v3 );
+	 }
+      }
+   } else {
+      /* 4-dword vertex.  Color is in v[3] and there is no oow coordinate.
+       */
+      INTERP_UB( t, dst->v.ub4[3][0], out->v.ub4[3][0], in->v.ub4[3][0] );
+      INTERP_UB( t, dst->v.ub4[3][1], out->v.ub4[3][1], in->v.ub4[3][1] );
+      INTERP_UB( t, dst->v.ub4[3][2], out->v.ub4[3][2], in->v.ub4[3][2] );
+      INTERP_UB( t, dst->v.ub4[3][3], out->v.ub4[3][3], in->v.ub4[3][3] );
+   }
+}
+
+
+static __inline void TAG(copy_pv)( GLcontext *ctx,
+				   TNL_VERTEX *dst, 
+				   TNL_VERTEX *src )
+{
+   if (DO_TEX0 || DO_TEX1 || !HAVE_TINY_VERTICES) {
+      dst->v.v.ui[4] = src->v.v.ui[4];
+   }
+   else {
+      dst->v.v.ui[3] = src->v.v.ui[3];
+   }
+}
+
+
+
+static void TAG(init)( void )
+{
+   setup_tab[IND].emit = TAG(emit_vfmt);
+   setup_tab[IND].interp = TAG(interp_vfmt);
+}
+
+
+#undef IND
+#undef TAG
+
+
+
Index: xc/extras/X-TrueType/xttcconv.c
diff -u xc/extras/X-TrueType/xttcconv.c:1.10 xc/extras/X-TrueType/xttcconv.c:1.11
--- xc/extras/X-TrueType/xttcconv.c:1.10	Tue Mar  6 13:54:39 2001
+++ xc/extras/X-TrueType/xttcconv.c	Tue Feb 25 17:10:15 2003
@@ -30,7 +30,7 @@
 
 Notice===
  */
-/* $XFree86: xc/extras/X-TrueType/xttcconv.c,v 1.10 2001/03/06 18:54:39 dawes Exp $ */
+/* $XFree86: xc/extras/X-TrueType/xttcconv.c,v 1.11 2003/02/25 22:10:15 dawes Exp $ */
 
 #include "xttversion.h"
 
@@ -510,14 +510,40 @@
             {
                 char **l;
 		char **tryItFirst = NULL;
+        char **fallback_try = NULL;
 
-                for (l=list; *l ; l++) {
-			if(!mystrcasecmp(*l,moduleArg.charSetHints->charsetStdName)) {
-				tryItFirst = l;
-				break;
-			}
-		}
-
+        for (l=list; *l ; l++) {
+            int breaking=0;
+            char *tmp_left=NULL;
+            char *mark_underscore=NULL;
+            tmp_left=xstrdup(*l);
+            mark_underscore=strrchr(tmp_left,'_');
+            if( mark_underscore != NULL ){
+                *mark_underscore = '\0';
+                if( !mystrcasecmp(tmp_left,moduleArg.charSetHints->charsetStdName) ){
+                    if( !mystrcasecmp( mark_underscore+1,moduleArg.charSetHints->charsetEncoding ) ){
+                        tryItFirst = l;
+                        breaking=1;
+                    }
+                }
+            }
+            else{
+                if(!mystrcasecmp(*l,moduleArg.charSetHints->charsetStdName)) {
+                    tryItFirst = l;
+                    breaking=1;
+                }
+            }
+            if( fallback_try == NULL ){
+                if( !mystrcasecmp(*l,"ISO8859_1") ){
+                    fallback_try = l;
+                }
+            }
+            if( tmp_left ) xfree(tmp_left);
+            if( breaking ) break;
+        }
+#if 1
+        if( tryItFirst == NULL ) tryItFirst=fallback_try;
+#endif
 		if(tryItFirst)
 			l = tryItFirst;
 		else
Index: xc/extras/X-TrueType/xttfuncs.c
diff -u xc/extras/X-TrueType/xttfuncs.c:1.11 xc/extras/X-TrueType/xttfuncs.c:1.17
--- xc/extras/X-TrueType/xttfuncs.c:1.11	Mon Dec 17 23:23:55 2001
+++ xc/extras/X-TrueType/xttfuncs.c	Sun Feb 16 22:59:22 2003
@@ -31,7 +31,7 @@
 
 Notice===
 */
-/* $XFree86: xc/extras/X-TrueType/xttfuncs.c,v 1.11 2001/12/18 04:23:55 dawes Exp $ */
+/* $XFree86: xc/extras/X-TrueType/xttfuncs.c,v 1.17 2003/02/17 03:59:22 dawes Exp $ */
 
 #include "xttversion.h"
 
@@ -566,7 +566,7 @@
     /*
      * Check invalid char index.
      */
-    if ( c <= 0 ) {
+    if ( c < 0 ) {
         charInfo = &nocharinfo;
         goto next;
     }
@@ -770,7 +770,7 @@
     /*
      * Check invalid char index.
      */
-    if ( c <= 0 ) {
+    if ( c < 0 ) {
         charInfo = &nocharinfo;
         goto next;
     }
@@ -850,7 +850,7 @@
 
         ft->map.rows  = height;
         bytes = (width + 7) / 8;
-        /* aligenment */
+        /* alignment */
         bytes = (bytes + (glyph) - 1) & -glyph;
         ft->map.cols  = bytes;
         ft->map.width = width;
@@ -862,6 +862,7 @@
             goto next;
         }
         ft->map.bitmap = charInfo->bits;
+        if ( ft->map.bitmap == NULL ) goto next;
 
         /*
          * draw a sbit or an outline glyph
@@ -898,6 +899,7 @@
     CharInfoPtr *glyphsBase = glyphs;
 
     int spacing = 0;
+    int i,nullbits,ncmark;
 
     dprintf((stderr, "FreeTypeGetGlyphs: %p %d\n", pFont, count));
 
@@ -913,40 +915,101 @@
         break;
     }
 
-    switch (encoding) {
-    case Linear8Bit:
-    case TwoD8Bit:
-        while (count--) {
-            unsigned c = *chars++;
-            c = ft->codeConverterInfo.ptrCodeConverter(c);
-            dprintf((stderr, "%04x\n", c));
-            *glyphs++ = get_glyph(ft, TT_Char_Index(ft->charmap, c), spacing);
-        }
-        break;
-    case Linear16Bit:
-    case TwoD16Bit:
-        while (count--) {
-            unsigned c1, c2;
+    while (count--) {
+        unsigned int c1=0, c2;
+
+        *glyphs = &nocharinfo;
+        switch (encoding) {
+        case Linear8Bit:
+        case TwoD8Bit:
             c1 = *chars++;
+            dprintf((stderr, "%04x\n", c1));
+            break;
+        case Linear16Bit:
+        case TwoD16Bit:
+            c1 = *chars++;
             c2 = *chars++;
-            dprintf((stderr, "code: %02x%02x ->", c1,c2));
-            if (!(c1 >= pFont->info.firstRow &&
-                  c1 <= pFont->info.lastRow  &&
-                  c2 >= pFont->info.firstCol &&
-                  c2 <= pFont->info.lastCol)) {
-                *glyphs++ = &nocharinfo;
-                dprintf((stderr, "invalid code\n"));
+            dprintf((stderr, "code: %02x%02x", c1,c2));
+            if (c1 >= pFont->info.firstRow &&
+                c1 <= pFont->info.lastRow  &&
+                c2 >= pFont->info.firstCol &&
+                c2 <= pFont->info.lastCol) {
+                c1 = (c1<<8|c2);
             } else {
-                c1 = ft->codeConverterInfo.ptrCodeConverter(c1<<8|c2);
-                dprintf((stderr, "%04x\n", c1));
-                *glyphs++ = get_glyph(ft, TT_Char_Index(ft->charmap, c1),
-                                      spacing);
+                dprintf((stderr, ", out of range.  We use nocharinfo.\n"));
+                *glyphs = &nocharinfo;
+                goto next;
             }
+            break;
+        default:
+            goto next;
         }
-        break;
+
+        c1 = ft->codeConverterInfo.ptrCodeConverter(c1);
+        dprintf((stderr, " ->%04x\n ->", c1));
+        c1 = TT_Char_Index(ft->charmap, c1);
+        dprintf((stderr, "%d\n", c1));
+        *glyphs = get_glyph(ft, c1, spacing);
+
+    next:
+#if 1
+        /* fallback for XAA */
+        if ( *glyphs == &nocharinfo ) {
+            dprintf((stderr, "nocharinfo causes a server crash. Instead We use .notdef glyph.\n"));
+            *glyphs = get_glyph(ft, 0, spacing);
+        }
+#endif
+        glyphs++;
     }
 
     *pCount = glyphs - glyphsBase;
+
+    /*
+      (pci)->bits == NULL crashes the Server when gHeight is not zero.
+      So we must check each value of (pci)->bits.  Since operation of
+      cash intervenes,  this "for () loop"  *MUST*  be independent of
+      the upper "while () loop".
+                                        Dec.26,2002  Chisato Yamauchi
+     */
+    dprintf((stderr, "AddressCheckBegin *pCount=%d\n",*pCount));
+    nullbits=0;
+    ncmark=-1;
+    for ( i=0 ; i<*pCount ; i++ ) {
+      /* Marking nocharinfo */
+      if ( glyphsBase[i] == &nocharinfo ) {
+        if ( ncmark == -1 ) ncmark=i;
+      }
+      else {
+        dprintf((stderr,"[%d]:%x\n",i,glyphsBase[i]->bits));
+        if ( glyphsBase[i]->bits == NULL ) {
+            glyphsBase[i]->metrics.ascent=0;
+            glyphsBase[i]->metrics.descent=0;
+            nullbits++;
+        }
+        /*
+          The XFree86 sometimes allocates memory with the value of maxbounds.ascent
+          and maxbounds.descent. 
+          So (*glyphs)->ascent must not become larger than maxbounds.ascent.
+          This is the same also about descent.
+         */
+        if ( pFont->info.maxbounds.ascent < glyphsBase[i]->metrics.ascent ) {
+            dprintf((stderr, " Invalid ascent : maxbounds.ascent=%d metrics.ascent=%d [corrected]\n",
+                     pFont->info.maxbounds.ascent,glyphsBase[i]->metrics.ascent));
+            glyphsBase[i]->metrics.ascent = pFont->info.maxbounds.ascent;
+        }
+        if ( pFont->info.maxbounds.descent < glyphsBase[i]->metrics.descent ) {
+            dprintf((stderr, " Invalid descent : maxbounds.descent=%d metrics.descent=%d [corrected]\n",
+                     pFont->info.maxbounds.descent,glyphsBase[i]->metrics.descent));
+            glyphsBase[i]->metrics.descent = pFont->info.maxbounds.descent;
+        }
+      }
+    }
+#if 1
+    /* Never return an address outside cache(for XAA). */
+    if ( ncmark != -1 ) *pCount = ncmark;
+#endif
+    dprintf((stderr, "AddressCheckEnd i=%d nullbits=%d\n",i,nullbits));
+
     return Successful;
 }
 
@@ -960,7 +1023,8 @@
 {
     FreeTypeFont *ft = (FreeTypeFont*) pFont->fontPrivate;
     xCharInfo **glyphsBase = glyphs;
-    unsigned int c;
+    unsigned int c=0,c2;
+    int i;
 
     /*dprintf((stderr, "FreeTypeGetMetrics: %d\n", count));*/
     if (ft->spacing == 'm' || ft->spacing == 'p') {
@@ -972,33 +1036,64 @@
         } else
             char_width.pixel = char_width.raw = 0;
 
-        switch (encoding) {
-        case Linear8Bit:
-        case TwoD8Bit:
-            while (count--) {
+        while (count--) {
+            *glyphs = &(&nocharinfo)->metrics;
+            switch (encoding) {
+            case Linear8Bit:
+            case TwoD8Bit:
                 c = *chars++;
-/*              dprintf((stderr, "code: %04x ->", c));*/
-                c = ft->codeConverterInfo.ptrCodeConverter(c);
-/*              dprintf((stderr, "%04x\n", c));*/
-                *glyphs++ =
-                    get_metrics(ft, TT_Char_Index(ft->charmap, c),
-                                char_width);
+                break;
+            case Linear16Bit:
+            case TwoD16Bit:
+                c  = *chars++;
+                c2 = *chars++;
+                if (c  >= pFont->info.firstRow &&
+                    c  <= pFont->info.lastRow  &&
+                    c2 >= pFont->info.firstCol &&
+                    c2 <= pFont->info.lastCol) {
+                    c  = (c<<8|c2);
+                } else {
+                    *glyphs = &(&nocharinfo)->metrics;
+                    goto next;
+                }
+                break;
+            default:
+                goto next;
             }
-            break;
-        case Linear16Bit:
-        case TwoD16Bit:
-            while (count--) {
-                c = *chars++ << 8; c |= *chars++;
-/*              dprintf((stderr, "code: %04x ->", c));*/
-                c = ft->codeConverterInfo.ptrCodeConverter(c);
-/*              dprintf((stderr, "%04x\n", c));*/
-                *glyphs++ =
-                    get_metrics(ft, TT_Char_Index(ft->charmap, c),
-                                char_width);
+            /* dprintf((stderr, "code: %04x ->", c));*/
+            c = ft->codeConverterInfo.ptrCodeConverter(c);
+            /* dprintf((stderr, "%04x\n", c));*/
+            *glyphs = get_metrics(ft, TT_Char_Index(ft->charmap, c),
+                                  char_width);
+    next:
+#if 1
+            /* fallback */
+            if ( *glyphs == &(&nocharinfo)->metrics ) {
+                dprintf((stderr, "nocharinfo -> Instead We use .notdef glyph.\n"));
+                *glyphs = get_metrics(ft, 0, char_width);
             }
-            break;
+#endif
+            glyphs++;
         }
         *pCount = glyphs - glyphsBase;
+        /*
+          The XFree86 sometimes allocates memory with the value of maxbounds.ascent
+          and maxbounds.descent. 
+          So (*glyphs)->ascent must not become larger than maxbounds.ascent.
+          This is the same also about descent.
+         */
+        for ( i=0 ; i<*pCount ; i++ ) {
+            if ( pFont->info.maxbounds.ascent < glyphsBase[i]->ascent ) {
+                dprintf((stderr, " Invalid ascent : maxbounds.ascent=%d metrics.ascent=%d [corrected]\n",
+                         pFont->info.maxbounds.ascent,glyphsBase[i]->ascent));
+                glyphsBase[i]->ascent = pFont->info.maxbounds.ascent;
+            }
+            if ( pFont->info.maxbounds.descent < glyphsBase[i]->descent ) {
+                dprintf((stderr, " Invalid descent : maxbounds.descent=%d metrics.descent=%d [corrected]\n",
+                         pFont->info.maxbounds.descent,glyphsBase[i]->descent));
+                glyphsBase[i]->descent = pFont->info.maxbounds.descent;
+            }
+        }
     } else {                                    /* -c- */
         switch (encoding) {
         case Linear8Bit:
@@ -1100,7 +1195,7 @@
                                 char_width);
                 }
 
-            if (!tmpchar->characterWidth)
+            if (!tmpchar || !tmpchar->characterWidth)
                 continue;
 
                 adjust_min_max(&minchar, &maxchar, tmpchar);
@@ -2079,8 +2174,12 @@
 
     /* reset */
     /* register */
-    for (i=0;i<sizeof(renderers)/sizeof(renderers[0]);i++)
-        FontFileRegisterRenderer(renderers + i);
+    for (i=0;i<sizeof(renderers)/sizeof(renderers[0]);i++) {
+        /* If the user has both the FreeType and the X-TT backends
+           linked in, he probably wants X-TT to be used for TrueType
+           fonts. */
+        FontFilePriorityRegisterRenderer(renderers + i, +10);
+    }
 
     return 0;
 }
Index: xc/extras/X-TrueType/xttversion.h
diff -u xc/extras/X-TrueType/xttversion.h:1.1.1.2 xc/extras/X-TrueType/xttversion.h:1.2
--- xc/extras/X-TrueType/xttversion.h:1.1.1.2	Sun Feb 13 00:14:17 2000
+++ xc/extras/X-TrueType/xttversion.h	Mon Dec  9 12:29:58 2002
@@ -7,7 +7,7 @@
 
 # define _XTT_V_MAJOR     1
 # define _XTT_V_MINOR     3
-# define _XTT_V_REVISION  0
+# define _XTT_V_REVISION  1
 # define _XTT_VENDOR_NAME "X-TrueType Server Project"
 # define _XTT_RELEASE_NAME \
     "===X-TT-ID: X-TrueType Server Version 1.3 [Aoi MATSUBARA Release 3] ==="
Index: xc/extras/X-TrueType/BIG5HKSCS/BIG5HKSCStoUCS2.c
diff -u xc/extras/X-TrueType/BIG5HKSCS/BIG5HKSCStoUCS2.c:1.1 xc/extras/X-TrueType/BIG5HKSCS/BIG5HKSCStoUCS2.c:1.2
--- xc/extras/X-TrueType/BIG5HKSCS/BIG5HKSCStoUCS2.c:1.1	Tue Mar  6 13:54:40 2001
+++ xc/extras/X-TrueType/BIG5HKSCS/BIG5HKSCStoUCS2.c	Mon Oct 14 21:54:37 2002
@@ -39,7 +39,7 @@
    (http://www.info.gov.hk/digital21/chi/hkscs/download/isov2cmp.txt)
  */
 
-/* $XFree86: xc/extras/X-TrueType/BIG5HKSCS/BIG5HKSCStoUCS2.c,v 1.1 2001/03/06 18:54:40 dawes Exp $ */
+/* $XFree86: xc/extras/X-TrueType/BIG5HKSCS/BIG5HKSCStoUCS2.c,v 1.2 2002/10/15 01:54:37 dawes Exp $ */
 
 #include "xttversion.h"
 
@@ -3091,12 +3091,12 @@
     0x9E17, 0x9F48, 0x6207, 0x6B1E, 0x7227, 0x864C, 0x8EA8, 0x9482, 
     0x9480, 0x9481, 0x9A69, 0x9A68, 0x9B2E, 0x9E19, 0x7229, 0x864B, 
     0x8B9F, 0x9483, 0x9C79, 0x9EB7, 0x7675, 0x9A6B, 0x9C7A, 0x9E1D, 
-    0x7069, 0x706A, 0x9EA4, 0x9F7E, 0x9F49, 0x9F98, ALTCHR, ALTCHR, 
-    ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, 
-    ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, 
-    ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, 
-    ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, 
-    ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, ALTCHR, 
+    0x7069, 0x706A, 0x9EA4, 0x9F7E, 0x9F49, 0x9F98, 0x7881, 0x92B9, 
+    0x88CF, 0x58BB, 0x6052, 0x7CA7, 0x5AFA, 0x2554, 0x2566, 0x2557, 
+    0x2560, 0x256C, 0x2563, 0x255A, 0x2569, 0x255D, 0x2552, 0x2564, 
+    0x2555, 0x255E, 0x256A, 0x2561, 0x2558, 0x2567, 0x255B, 0x2553, 
+    0x2565, 0x2556, 0x255F, 0x256B, 0x2562, 0x2559, 0x2568, 0x255C, 
+    0x2551, 0x2550, 0x256D, 0x256E, 0x2570, 0x256F, 0xFFED, ALTCHR, 
 /* start of HKSCS area */
 /* 0xFA40 - 0xFAFF */
     0xE000, 0x92DB, 0xE002, 0xE003, 0x854C, 0x42B5, 0x73EF, 0x51B5, 
Index: xc/extras/expat/COPYING
diff -u /dev/null xc/extras/expat/COPYING:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/COPYING	Mon Feb 18 16:44:16 2002
@@ -0,0 +1,21 @@
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+                               and Clark Cooper
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Index: xc/extras/expat/Changes
diff -u /dev/null xc/extras/expat/Changes:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/Changes	Mon Feb 18 16:44:16 2002
@@ -0,0 +1,46 @@
+Release 1.95.2 Fri Jul 27 2001
+	- Nore changes to make MSVC happy with the build; add a single
+	  workspace to support both the library and xmlwf applicatiion.
+	- Added a Windows installer for Windows users; includes
+	  xmlwf.exe.
+	- Added compile-time constants that can be used to determine the
+	  Expat version
+	- Removed a lot of GNU-specific dependencies to aide portability
+	  among the various Unix flavors.
+	- Fix the UTF-8 BOM bug.
+	- Cleaned up warning messages for several compilers.
+	- Added the -Wall, -Wstrict-prototypes options for GCC.
+Release 1.95.1 Sun Oct 22 15:11:36 EDT 2000
+	- Changes to get expat to build under Microsoft compiler
+	- Removed all aborts and instead return an UNEXPECTED_STATE error.
+	- Fixed a bug where a stray '%' in an entity value would cause an
+	  abort.
+	- Defined XML_SetEndNamespaceDeclHandler. Thanks to Darryl Miles for
+	  finding this oversight.
+	- Changed default patterns in lib/Makefile.in to fit non-GNU makes
+	  Thanks to robin@unrated.net for reporting and providing an
+	  account to test on.
+	- The reference had the wrong label for XML_SetStartNamespaceDecl.
+	  Reported by an anonymous user.
+Release 1.95.0 Fri Sep 29 2000
+	- XML_ParserCreate_MM
+		Allows you to set a memory management suite to replace the
+		standard malloc,realloc, and free.
+	- XML_SetReturnNSTriplet
+		If you turn this feature on when namespace processing is in
+		effect, then qualified, prefixed element and attribute names
+		are returned as "uri|name|prefix" where '|' is whatever
+		separator character is used in namespace processing.
+	- Merged in features from perl-expat
+		o XML_SetElementDeclHandler
+		o XML_SetAttlistDeclHandler
+		o XML_SetXmlDeclHandler
+		o XML_SetEntityDeclHandler
+		o StartDoctypeDeclHandler takes 3 additional parameters:
+			sysid, pubid, has_internal_subset
+		o Many paired handler setters (like XML_SetElementHandler)
+		  now have corresponding individual handler setters
+		o XML_GetInputContext for getting the input context of
+		  the current parse position.
+	- Added reference material
+	- Packaged into a distribution that builds a sharable library
Index: xc/extras/expat/MANIFEST
diff -u /dev/null xc/extras/expat/MANIFEST:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/MANIFEST	Mon Feb 18 16:44:16 2002
@@ -0,0 +1,58 @@
+Changes
+COPYING
+MANIFEST
+Makefile.in
+README
+config.h.in
+configure
+configure.in
+conftools/PrintPath
+conftools/ac_c_bigendian_cross.m4
+conftools/config.guess
+conftools/config.sub
+conftools/install-sh
+conftools/ltconfig
+conftools/ltmain.sh
+conftools/missing
+conftools/mkinstalldirs
+doc/reference.html
+doc/style.css
+examples/Makefile.in
+examples/elements.c
+examples/outline.c
+lib/Makefile.in
+lib/ascii.h
+lib/asciitab.h
+lib/expat.h.in
+lib/iasciitab.h
+lib/latin1tab.h
+lib/nametab.h
+lib/utf8tab.h
+lib/xmlparse.c
+lib/xmlrole.c
+lib/xmlrole.h
+lib/xmltok.c
+lib/xmltok.h
+lib/xmltok_impl.c
+lib/xmltok_impl.h
+lib/xmltok_ns.c
+lib/winconfig.h
+xmlwf/Makefile.in
+xmlwf/codepage.c
+xmlwf/codepage.h
+xmlwf/ct.c
+xmlwf/filemap.h
+xmlwf/readfilemap.c
+xmlwf/unixfilemap.c
+xmlwf/wfcheck.c
+xmlwf/wfcheck.h
+xmlwf/wfcheckmessage.c
+xmlwf/win32filemap.c
+xmlwf/xmlfile.c
+xmlwf/xmlfile.h
+xmlwf/xmlmime.c
+xmlwf/xmlmime.h
+xmlwf/xmltchar.h
+xmlwf/xmlurl.h
+xmlwf/xmlwf.c
+xmlwf/xmlwin32url.cxx
Index: xc/extras/expat/Makefile.in
diff -u /dev/null xc/extras/expat/Makefile.in:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/Makefile.in	Mon Feb 18 16:44:16 2002
@@ -0,0 +1,165 @@
+################################################################
+# Process this file with top-level configure script to produce Makefile
+#
+# Copyright 2000 Clark Cooper
+#
+#  This file is part of EXPAT.
+#
+#  EXPAT is free software; you can redistribute it and/or modify it
+#  under the terms of the License (based on the MIT/X license) contained
+#  in the file COPYING that comes with this distribution.
+#
+# EXPAT 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
+#
+#  ---
+#  I started using automake, but
+#		1) it seemed like overkill
+#		2) I don't want all the GNU policies
+#		3) I wanted more explicit control over what gets built
+#
+#  So I'm doing my Makefile.in files manually. But a fair part is based
+#  on what I learned from perusing the Makefile.in's generated by automake,
+#  and the automake authors still get my kudos.
+#
+
+SHELL = @SHELL@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+bindir = @bindir@
+sbindir = @sbindir@
+libexecdir = @libexecdir@
+datadir = @datadir@
+sysconfdir = @sysconfdir@
+sharedstatedir = @sharedstatedir@
+localstatedir = @localstatedir@
+libdir = @libdir@
+infodir = @infodir@
+mandir = @mandir@
+includedir = @includedir@
+oldincludedir = /usr/include
+
+top_builddir = .
+
+
+AUTOCONF = autoconf
+
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_alias = @host_alias@
+host_triplet = @host@
+
+CC = @CC@
+
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+PACKAGE = @PACKAGE@
+RANLIB = @RANLIB@
+VERSION = @VERSION@
+
+SUBDIRS = lib examples xmlwf
+INSTALLSUBDIRS = lib xmlwf
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+CONFIG_HEADERS = config.h
+
+DISTDIR = $(PACKAGE)-$(VERSION)
+DISTRIBUTION = $(DISTDIR).tar.gz
+
+default:  lib xmlwf
+
+buildlib: lib
+
+all: $(SUBDIRS)
+
+Makefile: Makefile.in config.status
+	CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) config.status
+
+config.status: configure
+	@if test -f $@; then \
+		$(SHELL) config.status --recheck ; \
+	else \
+		$(SHELL) configure ; \
+	fi
+
+configure: configure.in
+	$(AUTOCONF)
+
+config.h: config.h.in config.status
+	CONFIG_FILES= CONFIG_HEADERS=$(CONFIG_HEADERS) \
+	$(SHELL) ./config.status
+
+$(SUBDIRS):
+	cd $@ && $(MAKE)
+
+clean:
+	for dir in $(SUBDIRS); do \
+		(cd $$dir && $(MAKE) clean); \
+	done
+	rm -f core *~
+
+distclean:
+	for dir in $(SUBDIRS); do \
+		(cd $$dir && $(MAKE) distclean); \
+	done
+	rm -f config.h config.status config.log config.cache libtool
+	rm -f Makefile examples/Makefile xmlwf/Makefile
+
+extraclean: distclean
+	rm -f aclocal.m4 config.h.in configure
+	rm -f conftools/config.guess conftools/config.sub
+	rm -f conftools/ltconfig conftools/ltmain.sh
+
+maintainer-clean: distclean
+	rm -f $(DISTRIBUTION)
+	rm -rf $(DISTDIR)
+
+distdir: MANIFEST
+	test -d $(DISTDIR) && rm -rf $(DISTDIR); \
+	mkdir $(DISTDIR); \
+	flist=`sed -e "s/[ 	]:.*$$//" MANIFEST`; for file in $$flist; do \
+		cp -P $$file $(DISTDIR); \
+	done
+
+check:	$(SUBDIRS)
+	@echo
+	@echo This package does not yet have a regression test.
+	@echo
+
+$(DISTRIBUTION): distdir
+	tar cf - $(DISTDIR) | gzip -9 >$(DISTRIBUTION)
+
+dist: $(DISTRIBUTION)
+
+install:
+	for dir in $(INSTALLSUBDIRS); do \
+		(cd $$dir && $(MAKE) install); \
+	done
+
+uninstall:
+	for dir in $(INSTALLSUBDIRS); do \
+		(cd $$dir && $(MAKE) uninstall); \
+	done
+
+.PHONY: buildlib all $(SUBDIRS) \
+	clean distclean extraclean maintainer-clean \
+	dist distdir \
+	install uninstall
Index: xc/extras/expat/README
diff -u /dev/null xc/extras/expat/README:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/README	Mon Feb 18 16:44:17 2002
@@ -0,0 +1,72 @@
+
+			Expat, Release 1.95.2
+
+This is expat, a C library for parsing XML, written by James Clark.
+Expat is a stream-oriented XML parser.  This means that you register
+handlers with the parser before starting the parse.  These handlers
+are called when the parser discovers the associated structures in the
+document being parsed.  A start tag is an example of the kind of
+structures for which you may register handlers.
+
+Windows users should use the expat_win32bin package, which includes
+both precompiled libraries and executalbes, and source code for
+developers.
+
+Expat is free software.  You may copy, distribute, and modify it under
+the terms of the License contained in the file COPYING distributed
+with this package.  This license is the same as the MIT/X Consortium
+license.
+
+Versions of expat that have an odd minor version (the middle number in
+the release above), are development releases and should be considered
+as beta software.  Releases with even minor version numbers are
+intended to be production grade software.
+
+To build expat, you first run the configuration shell script in the
+top level distribution directory:
+
+	./configure
+
+There are many options which you may provide to configure (which you
+can discover by running configure with the --help option).  But the
+one of most interest is the one that sets the installation directory.
+By default, the configure script will set things up to install
+libexpat into /usr/local/lib, expat.h into /usr/local/include, and
+xmlwf into /usr/local/bin.  If, for example, you'd prefer to install
+into /home/me/mystuff/lib, /home/me/mystuff/include, and
+/home/me/mystuff/bin, you can tell configure about that with:
+
+	./configure --prefix=/home/me/mystuff
+
+After running the configure script, the "make" command will build
+things and "make install" will install things into their proper
+location.  Note that you need to have write permission into the
+directories into which things will be installed.
+
+When building for use with C++, you may need to add additional
+compiler flags to support proper interaction with exceptions.  This
+can be done by setting the CFLAGS environment variable.  For example,
+when using GCC, you can use:
+
+	CFLAGS=-fexceptions ./configure
+
+Note for Solaris users:  The "ar" command is usually located in
+"/usr/ccs/bin", which is not in the default PATH.  You will need to
+add this to your path for the "make" command, and probably also switch
+to GNU make (the "make" found in /usr/ccs/bin does not seem to work
+properly -- appearantly it does not understand .PHONY directives).  If
+you're using ksh or bash, use this command to build:
+
+	PATH=/usr/ccs/bin:$PATH make
+
+A reference manual is available in the file doc/reference.html in this
+distribution.
+
+The homepage for this project is http://expat.sourceforge.net/.  There
+are links there to connect you to the bug reports page.  If you need
+to report a bug when you don't have access to a browser, you may also
+send a bug report by email to expat-bugs@lists.sourceforge.net.
+
+Discussion related to the direction of future expat development takes
+place on expat-discuss@lists.sourceforge.net.  Archives of this list
+may be found at http://www.geocrawler.com/redir-sf.php3?list=expat-discuss.
Index: xc/extras/expat/config.h.in
diff -u /dev/null xc/extras/expat/config.h.in:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/config.h.in	Mon Feb 18 16:44:17 2002
@@ -0,0 +1,52 @@
+/* config.h.in.  Generated automatically from configure.in by autoheader.  */
+
+/* Define to empty if the keyword does not work.  */
+#undef const
+
+/* Define if you have a working `mmap' system call.  */
+#undef HAVE_MMAP
+
+/* Define to `long' if <sys/types.h> doesn't define.  */
+#undef off_t
+
+/* Define to `unsigned' if <sys/types.h> doesn't define.  */
+#undef size_t
+
+/* Define if you have the ANSI C header files.  */
+#undef STDC_HEADERS
+
+/* Define if you have the bcopy function.  */
+#undef HAVE_BCOPY
+
+/* Define if you have the getpagesize function.  */
+#undef HAVE_GETPAGESIZE
+
+/* Define if you have the memmove function.  */
+#undef HAVE_MEMMOVE
+
+/* Define if you have the <fcntl.h> header file.  */
+#undef HAVE_FCNTL_H
+
+/* Define if you have the <unistd.h> header file.  */
+#undef HAVE_UNISTD_H
+
+/* whether byteorder is bigendian */
+#undef WORDS_BIGENDIAN
+
+/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
+#undef BYTEORDER
+
+
+#define XML_NS
+#define XML_DTD
+
+#define XML_CONTEXT_BYTES 1024
+
+#ifndef HAVE_MEMMOVE
+#ifdef HAVE_BCOPY
+#define memmove(d,s,l) bcopy((s),(d),(l))
+#else
+#define memmove(d,s,l) ;punting on memmove;
+#endif
+
+#endif
Index: xc/extras/expat/configure
diff -u /dev/null xc/extras/expat/configure:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/configure	Mon Feb 18 16:44:17 2002
@@ -0,0 +1,3022 @@
+#! /bin/sh
+
+# Guess values for system-dependent variables and create Makefiles.
+# Generated automatically using autoconf version 2.13 
+# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+
+# Defaults:
+ac_help=
+ac_default_prefix=/usr/local
+# Any additions from configure.in:
+ac_help="$ac_help
+  --enable-shared[=PKGS]  build shared libraries [default=yes]"
+ac_help="$ac_help
+  --enable-static[=PKGS]  build static libraries [default=yes]"
+ac_help="$ac_help
+  --enable-fast-install[=PKGS]  optimize for fast installation [default=yes]"
+ac_help="$ac_help
+  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]"
+ac_help="$ac_help
+  --disable-libtool-lock  avoid locking (might break parallel builds)"
+
+# Initialize some variables set by options.
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+build=NONE
+cache_file=./config.cache
+exec_prefix=NONE
+host=NONE
+no_create=
+nonopt=NONE
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+target=NONE
+verbose=
+x_includes=NONE
+x_libraries=NONE
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datadir='${prefix}/share'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+libdir='${exec_prefix}/lib'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+infodir='${prefix}/info'
+mandir='${prefix}/man'
+
+# Initialize some other variables.
+subdirs=
+MFLAGS= MAKEFLAGS=
+SHELL=${CONFIG_SHELL-/bin/sh}
+# Maximum number of lines to put in a shell here document.
+ac_max_here_lines=12
+
+ac_prev=
+for ac_option
+do
+
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval "$ac_prev=\$ac_option"
+    ac_prev=
+    continue
+  fi
+
+  case "$ac_option" in
+  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) ac_optarg= ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case "$ac_option" in
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir="$ac_optarg" ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build="$ac_optarg" ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file="$ac_optarg" ;;
+
+  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+  | --da=*)
+    datadir="$ac_optarg" ;;
+
+  -disable-* | --disable-*)
+    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
+      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
+    fi
+    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
+    eval "enable_${ac_feature}=no" ;;
+
+  -enable-* | --enable-*)
+    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
+      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
+    fi
+    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
+    case "$ac_option" in
+      *=*) ;;
+      *) ac_optarg=yes ;;
+    esac
+    eval "enable_${ac_feature}='$ac_optarg'" ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix="$ac_optarg" ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he)
+    # Omit some internal or obsolete options to make the list less imposing.
+    # This message is too long to be a string in the A/UX 3.1 sh.
+    cat << EOF
+Usage: configure [options] [host]
+Options: [defaults in brackets after descriptions]
+Configuration:
+  --cache-file=FILE       cache test results in FILE
+  --help                  print this message
+  --no-create             do not create output files
+  --quiet, --silent       do not print \`checking...' messages
+  --version               print the version of autoconf that created configure
+Directory and file names:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          [same as prefix]
+  --bindir=DIR            user executables in DIR [EPREFIX/bin]
+  --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
+  --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
+  --datadir=DIR           read-only architecture-independent data in DIR
+                          [PREFIX/share]
+  --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
+  --sharedstatedir=DIR    modifiable architecture-independent data in DIR
+                          [PREFIX/com]
+  --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
+  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
+  --includedir=DIR        C header files in DIR [PREFIX/include]
+  --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
+  --infodir=DIR           info documentation in DIR [PREFIX/info]
+  --mandir=DIR            man documentation in DIR [PREFIX/man]
+  --srcdir=DIR            find the sources in DIR [configure dir or ..]
+  --program-prefix=PREFIX prepend PREFIX to installed program names
+  --program-suffix=SUFFIX append SUFFIX to installed program names
+  --program-transform-name=PROGRAM
+                          run sed PROGRAM on installed program names
+EOF
+    cat << EOF
+Host type:
+  --build=BUILD           configure for building on BUILD [BUILD=HOST]
+  --host=HOST             configure for HOST [guessed]
+  --target=TARGET         configure for TARGET [TARGET=HOST]
+Features and packages:
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --x-includes=DIR        X include files are in DIR
+  --x-libraries=DIR       X library files are in DIR
+EOF
+    if test -n "$ac_help"; then
+      echo "--enable and --with options recognized:$ac_help"
+    fi
+    exit 0 ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host="$ac_optarg" ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir="$ac_optarg" ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir="$ac_optarg" ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir="$ac_optarg" ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir="$ac_optarg" ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst \
+  | --locals | --local | --loca | --loc | --lo)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
+    localstatedir="$ac_optarg" ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir="$ac_optarg" ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir="$ac_optarg" ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix="$ac_optarg" ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix="$ac_optarg" ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix="$ac_optarg" ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name="$ac_optarg" ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir="$ac_optarg" ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir="$ac_optarg" ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site="$ac_optarg" ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir="$ac_optarg" ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir="$ac_optarg" ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target="$ac_optarg" ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers)
+    echo "configure generated by autoconf version 2.13"
+    exit 0 ;;
+
+  -with-* | --with-*)
+    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
+      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
+    fi
+    ac_package=`echo $ac_package| sed 's/-/_/g'`
+    case "$ac_option" in
+      *=*) ;;
+      *) ac_optarg=yes ;;
+    esac
+    eval "with_${ac_package}='$ac_optarg'" ;;
+
+  -without-* | --without-*)
+    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
+    # Reject names that are not valid shell variable names.
+    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
+      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
+    fi
+    ac_package=`echo $ac_package| sed 's/-/_/g'`
+    eval "with_${ac_package}=no" ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes="$ac_optarg" ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries="$ac_optarg" ;;
+
+  -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
+    ;;
+
+  *)
+    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
+      echo "configure: warning: $ac_option: invalid host type" 1>&2
+    fi
+    if test "x$nonopt" != xNONE; then
+      { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
+    fi
+    nonopt="$ac_option"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
+fi
+
+trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
+
+# File descriptor usage:
+# 0 standard input
+# 1 file creation
+# 2 errors and warnings
+# 3 some systems may open it to /dev/tty
+# 4 used on the Kubota Titan
+# 6 checking for... messages and results
+# 5 compiler messages saved in config.log
+if test "$silent" = yes; then
+  exec 6>/dev/null
+else
+  exec 6>&1
+fi
+exec 5>./config.log
+
+echo "\
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+" 1>&5
+
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Also quote any args containing shell metacharacters.
+ac_configure_args=
+for ac_arg
+do
+  case "$ac_arg" in
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c) ;;
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
+  *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
+  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
+  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
+  esac
+done
+
+# NLS nuisances.
+# Only set these to C if already set.  These must not be set unconditionally
+# because not all systems understand e.g. LANG=C (notably SCO).
+# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
+# Non-C LC_CTYPE values break the ctype check.
+if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
+if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
+if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
+if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -rf conftest* confdefs.h
+# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+echo > confdefs.h
+
+# A filename unique to this package, relative to the directory that
+# configure is in, which we can look for to find out if srcdir is correct.
+ac_unique_file=Makefile.in
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then its parent.
+  ac_prog=$0
+  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
+  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
+  srcdir=$ac_confdir
+  if test ! -r $srcdir/$ac_unique_file; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r $srcdir/$ac_unique_file; then
+  if test "$ac_srcdir_defaulted" = yes; then
+    { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
+  else
+    { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
+  fi
+fi
+srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
+
+# Prefer explicitly selected file to automatically selected ones.
+if test -z "$CONFIG_SITE"; then
+  if test "x$prefix" != xNONE; then
+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+  else
+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+  fi
+fi
+for ac_site_file in $CONFIG_SITE; do
+  if test -r "$ac_site_file"; then
+    echo "loading site script $ac_site_file"
+    . "$ac_site_file"
+  fi
+done
+
+if test -r "$cache_file"; then
+  echo "loading cache $cache_file"
+  . $cache_file
+else
+  echo "creating cache $cache_file"
+  > $cache_file
+fi
+
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+ac_exeext=
+ac_objext=o
+if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
+  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
+  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
+    ac_n= ac_c='
+' ac_t='	'
+  else
+    ac_n=-n ac_c= ac_t=
+  fi
+else
+  ac_n= ac_c='\c' ac_t=
+fi
+
+
+ac_aux_dir=
+for ac_dir in conftools $srcdir/conftools; do
+  if test -f $ac_dir/install-sh; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f $ac_dir/install.sh; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  { echo "configure: error: can not find install-sh or install.sh in conftools $srcdir/conftools" 1>&2; exit 1; }
+fi
+ac_config_guess=$ac_aux_dir/config.guess
+ac_config_sub=$ac_aux_dir/config.sub
+ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
+
+
+
+EXPAT_MAJOR_VERSION=1
+EXPAT_MINOR_VERSION=95
+EXPAT_EDIT=2
+
+EXPAT_VERSION=$EXPAT_MAJOR_VERSION.$EXPAT_MINOR_VERSION.$EXPAT_EDIT
+VERSION=$EXPAT_VERSION
+PACKAGE=expat
+
+
+LIBCURRENT=1
+LIBREVISION=0
+LIBAGE=1
+
+
+
+
+# Check whether --enable-shared or --disable-shared was given.
+if test "${enable_shared+set}" = set; then
+  enableval="$enable_shared"
+  p=${PACKAGE-default}
+case "$enableval" in
+yes) enable_shared=yes ;;
+no) enable_shared=no ;;
+*)
+  enable_shared=no
+  # Look at the argument we got.  We use all the common list separators.
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
+  for pkg in $enableval; do
+    if test "X$pkg" = "X$p"; then
+      enable_shared=yes
+    fi
+  done
+  IFS="$ac_save_ifs"
+  ;;
+esac
+else
+  enable_shared=yes
+fi
+
+# Check whether --enable-static or --disable-static was given.
+if test "${enable_static+set}" = set; then
+  enableval="$enable_static"
+  p=${PACKAGE-default}
+case "$enableval" in
+yes) enable_static=yes ;;
+no) enable_static=no ;;
+*)
+  enable_static=no
+  # Look at the argument we got.  We use all the common list separators.
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
+  for pkg in $enableval; do
+    if test "X$pkg" = "X$p"; then
+      enable_static=yes
+    fi
+  done
+  IFS="$ac_save_ifs"
+  ;;
+esac
+else
+  enable_static=yes
+fi
+
+# Check whether --enable-fast-install or --disable-fast-install was given.
+if test "${enable_fast_install+set}" = set; then
+  enableval="$enable_fast_install"
+  p=${PACKAGE-default}
+case "$enableval" in
+yes) enable_fast_install=yes ;;
+no) enable_fast_install=no ;;
+*)
+  enable_fast_install=no
+  # Look at the argument we got.  We use all the common list separators.
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
+  for pkg in $enableval; do
+    if test "X$pkg" = "X$p"; then
+      enable_fast_install=yes
+    fi
+  done
+  IFS="$ac_save_ifs"
+  ;;
+esac
+else
+  enable_fast_install=yes
+fi
+
+
+# Make sure we can run config.sub.
+if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
+else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
+fi
+
+echo $ac_n "checking host system type""... $ac_c" 1>&6
+echo "configure:648: checking host system type" >&5
+
+host_alias=$host
+case "$host_alias" in
+NONE)
+  case $nonopt in
+  NONE)
+    if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
+    else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
+    fi ;;
+  *) host_alias=$nonopt ;;
+  esac ;;
+esac
+
+host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
+host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+echo "$ac_t""$host" 1>&6
+
+echo $ac_n "checking build system type""... $ac_c" 1>&6
+echo "configure:669: checking build system type" >&5
+
+build_alias=$build
+case "$build_alias" in
+NONE)
+  case $nonopt in
+  NONE) build_alias=$host_alias ;;
+  *) build_alias=$nonopt ;;
+  esac ;;
+esac
+
+build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
+build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+echo "$ac_t""$build" 1>&6
+
+# Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:689: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_RANLIB="ranlib"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+  test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
+fi
+fi
+RANLIB="$ac_cv_prog_RANLIB"
+if test -n "$RANLIB"; then
+  echo "$ac_t""$RANLIB" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+# Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:719: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_CC="gcc"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:749: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_prog_rejected=no
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+	continue
+      fi
+      ac_cv_prog_CC="cc"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# -gt 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    set dummy "$ac_dir/$ac_word" "$@"
+    shift
+    ac_cv_prog_CC="$@"
+  fi
+fi
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+  if test -z "$CC"; then
+    case "`uname -s`" in
+    *win32* | *WIN32*)
+      # Extract the first word of "cl", so it can be a program name with args.
+set dummy cl; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:800: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_CC="cl"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+ ;;
+    esac
+  fi
+  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
+fi
+
+echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
+echo "configure:832: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+cat > conftest.$ac_ext << EOF
+
+#line 843 "configure"
+#include "confdefs.h"
+
+main(){return(0);}
+EOF
+if { (eval echo configure:848: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  ac_cv_prog_cc_works=yes
+  # If we can't run a trivial program, we are probably using a cross compiler.
+  if (./conftest; exit) 2>/dev/null; then
+    ac_cv_prog_cc_cross=no
+  else
+    ac_cv_prog_cc_cross=yes
+  fi
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  ac_cv_prog_cc_works=no
+fi
+rm -fr conftest*
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
+if test $ac_cv_prog_cc_works = no; then
+  { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
+fi
+echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
+echo "configure:874: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
+cross_compiling=$ac_cv_prog_cc_cross
+
+echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
+echo "configure:879: checking whether we are using GNU C" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.c <<EOF
+#ifdef __GNUC__
+  yes;
+#endif
+EOF
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:888: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+  ac_cv_prog_gcc=yes
+else
+  ac_cv_prog_gcc=no
+fi
+fi
+
+echo "$ac_t""$ac_cv_prog_gcc" 1>&6
+
+if test $ac_cv_prog_gcc = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+
+ac_test_CFLAGS="${CFLAGS+set}"
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS=
+echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
+echo "configure:907: checking whether ${CC-cc} accepts -g" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  echo 'void f(){}' > conftest.c
+if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
+  ac_cv_prog_cc_g=yes
+else
+  ac_cv_prog_cc_g=no
+fi
+rm -f conftest*
+
+fi
+
+echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS="$ac_save_CFLAGS"
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+
+# Check whether --with-gnu-ld or --without-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then
+  withval="$with_gnu_ld"
+  test "$withval" = no || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test "$ac_cv_prog_gcc" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
+echo "configure:950: checking for ld used by GCC" >&5
+  ac_prog=`($CC -print-prog-name=ld) 2>&5`
+  case "$ac_prog" in
+    # Accept absolute paths.
+    [\\/]* | [A-Za-z]:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the path of ld
+      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
+echo "configure:974: checking for GNU ld" >&5
+else
+  echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
+echo "configure:977: checking for non-GNU ld" >&5
+fi
+if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -z "$LD"; then
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  for ac_dir in $PATH; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      ac_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some GNU ld's only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
+	test "$with_gnu_ld" != no && break
+      else
+	test "$with_gnu_ld" != yes && break
+      fi
+    fi
+  done
+  IFS="$ac_save_ifs"
+else
+  ac_cv_path_LD="$LD" # Let the user override the test with a path.
+fi
+fi
+
+LD="$ac_cv_path_LD"
+if test -n "$LD"; then
+  echo "$ac_t""$LD" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
+echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
+echo "configure:1012: checking if the linker ($LD) is GNU ld" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
+if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
+  ac_cv_prog_gnu_ld=yes
+else
+  ac_cv_prog_gnu_ld=no
+fi
+fi
+
+echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
+
+
+echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
+echo "configure:1028: checking for BSD-compatible nm" >&5
+if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$NM"; then
+  # Let the user override the test.
+  ac_cv_path_NM="$NM"
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext ; then
+      # Check to see if the nm accepts a BSD-compat flag.
+      # Adding the `sed 1q' prevents false positives on HP-UX, which says:
+      #   nm: unknown option "B" ignored
+      if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
+	ac_cv_path_NM="$ac_dir/nm -B"
+	break
+      elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
+	ac_cv_path_NM="$ac_dir/nm -p"
+	break
+      else
+	ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/nm"} # keep the first match, but
+	continue # so that we can try to find one that supports BSD flags
+      fi
+    fi
+  done
+  IFS="$ac_save_ifs"
+  test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
+fi
+fi
+
+NM="$ac_cv_path_NM"
+echo "$ac_t""$NM" 1>&6
+
+echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
+echo "configure:1064: checking whether ln -s works" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  rm -f conftestdata
+if ln -s X conftestdata 2>/dev/null
+then
+  rm -f conftestdata
+  ac_cv_prog_LN_S="ln -s"
+else
+  ac_cv_prog_LN_S=ln
+fi
+fi
+LN_S="$ac_cv_prog_LN_S"
+if test "$ac_cv_prog_LN_S" = "ln -s"; then
+  echo "$ac_t""yes" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+if test $host != $build; then
+  ac_tool_prefix=${host_alias}-
+else
+  ac_tool_prefix=
+fi
+
+
+case "$target" in
+NONE) lt_target="$host" ;;
+*) lt_target="$target" ;;
+esac
+
+# Check for any special flags to pass to ltconfig.
+#
+# the following will cause an existing older ltconfig to fail, so
+# we ignore this at the expense of the cache file... Checking this 
+# will just take longer ... bummer!
+#libtool_flags="--cache-file=$cache_file"
+#
+test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
+test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
+test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
+test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
+test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
+
+libtool_flags="$libtool_flags --enable-win32-dll"
+# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then
+  enableval="$enable_libtool_lock"
+  :
+fi
+
+test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
+test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case "$lt_target" in
+*-*-irix6*)
+  # Find out which ABI we are using.
+  echo '#line 1124 "configure"' > conftest.$ac_ext
+  if { (eval echo configure:1125: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+    case "`/usr/bin/file conftest.o`" in
+    *32-bit*)
+      LD="${LD-ld} -32"
+      ;;
+    *N32*)
+      LD="${LD-ld} -n32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -64"
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -belf"
+  echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
+echo "configure:1146: checking whether the C compiler needs -belf" >&5
+if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 1151 "configure"
+#include "confdefs.h"
+
+int main() {
+
+; return 0; }
+EOF
+if { (eval echo configure:1158: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  lt_cv_cc_needs_belf=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  lt_cv_cc_needs_belf=no
+fi
+rm -f conftest*
+fi
+
+echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS="$SAVE_CFLAGS"
+  fi
+  ;;
+
+*-*-cygwin* | *-*-mingw*)
+  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1181: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+DLLTOOL="$ac_cv_prog_DLLTOOL"
+if test -n "$DLLTOOL"; then
+  echo "$ac_t""$DLLTOOL" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+
+if test -z "$ac_cv_prog_DLLTOOL"; then
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1213: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_DLLTOOL="dlltool"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+  test -z "$ac_cv_prog_DLLTOOL" && ac_cv_prog_DLLTOOL="false"
+fi
+fi
+DLLTOOL="$ac_cv_prog_DLLTOOL"
+if test -n "$DLLTOOL"; then
+  echo "$ac_t""$DLLTOOL" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+else
+  DLLTOOL="false"
+fi
+fi
+
+  # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
+set dummy ${ac_tool_prefix}as; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1248: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$AS"; then
+  ac_cv_prog_AS="$AS" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_AS="${ac_tool_prefix}as"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+AS="$ac_cv_prog_AS"
+if test -n "$AS"; then
+  echo "$ac_t""$AS" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+
+if test -z "$ac_cv_prog_AS"; then
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "as", so it can be a program name with args.
+set dummy as; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1280: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$AS"; then
+  ac_cv_prog_AS="$AS" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_AS="as"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+  test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="false"
+fi
+fi
+AS="$ac_cv_prog_AS"
+if test -n "$AS"; then
+  echo "$ac_t""$AS" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+else
+  AS="false"
+fi
+fi
+
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1315: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+OBJDUMP="$ac_cv_prog_OBJDUMP"
+if test -n "$OBJDUMP"; then
+  echo "$ac_t""$OBJDUMP" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+
+if test -z "$ac_cv_prog_OBJDUMP"; then
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1347: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_OBJDUMP="objdump"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+  test -z "$ac_cv_prog_OBJDUMP" && ac_cv_prog_OBJDUMP="false"
+fi
+fi
+OBJDUMP="$ac_cv_prog_OBJDUMP"
+if test -n "$OBJDUMP"; then
+  echo "$ac_t""$OBJDUMP" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+else
+  OBJDUMP="false"
+fi
+fi
+
+  ;;
+
+esac
+
+
+# Save cache, so that ltconfig can load it
+cat > confcache <<\EOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs.  It is not useful on other systems.
+# If it contains results you don't want to keep, you may remove or edit it.
+#
+# By default, configure uses ./config.cache as the cache file,
+# creating it if it does not exist already.  You can give configure
+# the --cache-file=FILE option to use a different cache file; that is
+# what configure does when it calls configure scripts in
+# subdirectories, so they share the cache.
+# Giving --cache-file=/dev/null disables caching, for debugging configure.
+# config.status only pays attention to the cache file if you give it the
+# --recheck option to rerun configure.
+#
+EOF
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(set) 2>&1 |
+  case `(ac_space=' '; set | grep ac_space) 2>&1` in
+  *ac_space=\ *)
+    # `set' does not quote correctly, so add quotes (double-quote substitution
+    # turns \\\\ into \\, and sed turns \\ into \).
+    sed -n \
+      -e "s/'/'\\\\''/g" \
+      -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
+    ;;
+  *)
+    # `set' quotes correctly as required by POSIX, so do not add quotes.
+    sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
+    ;;
+  esac >> confcache
+if cmp -s $cache_file confcache; then
+  :
+else
+  if test -w $cache_file; then
+    echo "updating cache $cache_file"
+    cat confcache > $cache_file
+  else
+    echo "not updating unwritable cache $cache_file"
+  fi
+fi
+rm -f confcache
+
+
+# Actually configure libtool.  ac_aux_dir is where install-sh is found.
+CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
+LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
+LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \
+DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \
+${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
+$libtool_flags --no-verify $ac_aux_dir/ltmain.sh $lt_target \
+|| { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
+
+# Reload cache, that may have been modified by ltconfig
+if test -r "$cache_file"; then
+  echo "loading cache $cache_file"
+  . $cache_file
+else
+  echo "creating cache $cache_file"
+  > $cache_file
+fi
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+# Redirect the config.log output again, so that the ltconfig log is not
+# clobbered by the next message.
+exec 5>>./config.log
+
+
+
+
+
+
+
+
+
+
+
+
+# Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1476: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_CC="gcc"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1506: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_prog_rejected=no
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
+        ac_prog_rejected=yes
+	continue
+      fi
+      ac_cv_prog_CC="cc"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# -gt 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    set dummy "$ac_dir/$ac_word" "$@"
+    shift
+    ac_cv_prog_CC="$@"
+  fi
+fi
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+  if test -z "$CC"; then
+    case "`uname -s`" in
+    *win32* | *WIN32*)
+      # Extract the first word of "cl", so it can be a program name with args.
+set dummy cl; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:1557: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_CC="cl"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+CC="$ac_cv_prog_CC"
+if test -n "$CC"; then
+  echo "$ac_t""$CC" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+ ;;
+    esac
+  fi
+  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
+fi
+
+echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
+echo "configure:1589: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+cat > conftest.$ac_ext << EOF
+
+#line 1600 "configure"
+#include "confdefs.h"
+
+main(){return(0);}
+EOF
+if { (eval echo configure:1605: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  ac_cv_prog_cc_works=yes
+  # If we can't run a trivial program, we are probably using a cross compiler.
+  if (./conftest; exit) 2>/dev/null; then
+    ac_cv_prog_cc_cross=no
+  else
+    ac_cv_prog_cc_cross=yes
+  fi
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  ac_cv_prog_cc_works=no
+fi
+rm -fr conftest*
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
+
+echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
+if test $ac_cv_prog_cc_works = no; then
+  { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
+fi
+echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
+echo "configure:1631: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
+cross_compiling=$ac_cv_prog_cc_cross
+
+echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
+echo "configure:1636: checking whether we are using GNU C" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.c <<EOF
+#ifdef __GNUC__
+  yes;
+#endif
+EOF
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1645: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+  ac_cv_prog_gcc=yes
+else
+  ac_cv_prog_gcc=no
+fi
+fi
+
+echo "$ac_t""$ac_cv_prog_gcc" 1>&6
+
+if test $ac_cv_prog_gcc = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+
+ac_test_CFLAGS="${CFLAGS+set}"
+ac_save_CFLAGS="$CFLAGS"
+CFLAGS=
+echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
+echo "configure:1664: checking whether ${CC-cc} accepts -g" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  echo 'void f(){}' > conftest.c
+if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
+  ac_cv_prog_cc_g=yes
+else
+  ac_cv_prog_cc_g=no
+fi
+rm -f conftest*
+
+fi
+
+echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS="$ac_save_CFLAGS"
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# ./install, which can be erroneously created by make from ./install.sh.
+echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
+echo "configure:1707: checking for a BSD compatible install" >&5
+if test -z "$INSTALL"; then
+if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+    IFS="${IFS= 	}"; ac_save_IFS="$IFS"; IFS=":"
+  for ac_dir in $PATH; do
+    # Account for people who put trailing slashes in PATH elements.
+    case "$ac_dir/" in
+    /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
+    *)
+      # OSF1 and SCO ODT 3.0 have their own names for install.
+      # Don't use installbsd from OSF since it installs stuff as root
+      # by default.
+      for ac_prog in ginstall scoinst install; do
+        if test -f $ac_dir/$ac_prog; then
+	  if test $ac_prog = install &&
+            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  else
+	    ac_cv_path_install="$ac_dir/$ac_prog -c"
+	    break 2
+	  fi
+	fi
+      done
+      ;;
+    esac
+  done
+  IFS="$ac_save_IFS"
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL="$ac_cv_path_install"
+  else
+    # As a last resort, use the slow shell script.  We don't cache a
+    # path for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the path is relative.
+    INSTALL="$ac_install_sh"
+  fi
+fi
+echo "$ac_t""$INSTALL" 1>&6
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+
+if test "$GCC" = yes ; then
+    CFLAGS="$CFLAGS -Wall -Wmissing-prototypes -Wstrict-prototypes -fexceptions"
+fi
+
+
+echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
+echo "configure:1766: checking how to run the C preprocessor" >&5
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+    # This must be in double quotes, not single quotes, because CPP may get
+  # substituted into the Makefile and "${CC-cc}" will confuse make.
+  CPP="${CC-cc} -E"
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp.
+  cat > conftest.$ac_ext <<EOF
+#line 1781 "configure"
+#include "confdefs.h"
+#include <assert.h>
+Syntax Error
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:1787: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  :
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  CPP="${CC-cc} -E -traditional-cpp"
+  cat > conftest.$ac_ext <<EOF
+#line 1798 "configure"
+#include "confdefs.h"
+#include <assert.h>
+Syntax Error
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:1804: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  :
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  CPP="${CC-cc} -nologo -E"
+  cat > conftest.$ac_ext <<EOF
+#line 1815 "configure"
+#include "confdefs.h"
+#include <assert.h>
+Syntax Error
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:1821: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  :
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  CPP=/lib/cpp
+fi
+rm -f conftest*
+fi
+rm -f conftest*
+fi
+rm -f conftest*
+  ac_cv_prog_CPP="$CPP"
+fi
+  CPP="$ac_cv_prog_CPP"
+else
+  ac_cv_prog_CPP="$CPP"
+fi
+echo "$ac_t""$CPP" 1>&6
+
+echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
+echo "configure:1846: checking for ANSI C header files" >&5
+if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 1851 "configure"
+#include "confdefs.h"
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:1859: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  ac_cv_header_stdc=yes
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+cat > conftest.$ac_ext <<EOF
+#line 1876 "configure"
+#include "confdefs.h"
+#include <string.h>
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "memchr" >/dev/null 2>&1; then
+  :
+else
+  rm -rf conftest*
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+cat > conftest.$ac_ext <<EOF
+#line 1894 "configure"
+#include "confdefs.h"
+#include <stdlib.h>
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "free" >/dev/null 2>&1; then
+  :
+else
+  rm -rf conftest*
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+if test "$cross_compiling" = yes; then
+  :
+else
+  cat > conftest.$ac_ext <<EOF
+#line 1915 "configure"
+#include "confdefs.h"
+#include <ctype.h>
+#define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+#define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int main () { int i; for (i = 0; i < 256; i++)
+if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
+exit (0); }
+
+EOF
+if { (eval echo configure:1926: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+then
+  :
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -fr conftest*
+  ac_cv_header_stdc=no
+fi
+rm -fr conftest*
+fi
+
+fi
+fi
+
+echo "$ac_t""$ac_cv_header_stdc" 1>&6
+if test $ac_cv_header_stdc = yes; then
+  cat >> confdefs.h <<\EOF
+#define STDC_HEADERS 1
+EOF
+
+fi
+
+for ac_hdr in fcntl.h unistd.h
+do
+ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
+echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
+echo "configure:1953: checking for $ac_hdr" >&5
+if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 1958 "configure"
+#include "confdefs.h"
+#include <$ac_hdr>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:1963: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=yes"
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=no"
+fi
+rm -f conftest*
+fi
+if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_hdr 1
+EOF
+ 
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+
+
+echo $ac_n "checking whether byte ordering is bigendian""... $ac_c" 1>&6
+echo "configure:1992: checking whether byte ordering is bigendian" >&5
+if eval "test \"`echo '$''{'ac_cv_c_bigendian'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  ac_cv_c_bigendian=unknown
+# See if sys/param.h defines the BYTE_ORDER macro.
+cat > conftest.$ac_ext <<EOF
+#line 1999 "configure"
+#include "confdefs.h"
+#include <sys/types.h>
+#include <sys/param.h>
+int main() {
+
+#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
+ bogus endian macros
+#endif
+; return 0; }
+EOF
+if { (eval echo configure:2010: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  # It does; now see whether it defined to BIG_ENDIAN or not.
+cat > conftest.$ac_ext <<EOF
+#line 2014 "configure"
+#include "confdefs.h"
+#include <sys/types.h>
+#include <sys/param.h>
+int main() {
+
+#if BYTE_ORDER != BIG_ENDIAN
+ not big endian
+#endif
+; return 0; }
+EOF
+if { (eval echo configure:2025: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  ac_cv_c_bigendian=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  ac_cv_c_bigendian=no
+fi
+rm -f conftest*
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+fi
+rm -f conftest*
+if test $ac_cv_c_bigendian = unknown; then
+if test "$cross_compiling" = yes; then
+   echo $ac_n "cross-compiling... " 2>&6 
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2045 "configure"
+#include "confdefs.h"
+main () {
+  /* Are we little or big endian?  From Harbison&Steele.  */
+  union
+  {
+    long l;
+    char c[sizeof (long)];
+  } u;
+  u.l = 1;
+  exit (u.c[sizeof (long) - 1] == 1);
+}
+EOF
+if { (eval echo configure:2058: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+then
+  ac_cv_c_bigendian=no
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -fr conftest*
+  ac_cv_c_bigendian=yes
+fi
+rm -fr conftest*
+fi
+
+fi
+fi
+
+echo "$ac_t""$ac_cv_c_bigendian" 1>&6
+if test $ac_cv_c_bigendian = unknown; then
+echo $ac_n "checking to probe for byte ordering""... $ac_c" 1>&6
+echo "configure:2076: checking to probe for byte ordering" >&5
+
+cat >conftest.c <<EOF
+short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
+short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
+void _ascii() { char* s = (char*) ascii_mm; s = (char*) ascii_ii; }
+short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
+short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
+void _ebcdic() { char* s = (char*) ebcdic_mm; s = (char*) ebcdic_ii; }
+int main() { _ascii (); _ebcdic (); return 0; }
+EOF
+ if test -f conftest.c ; then
+     if ${CC-cc} conftest.c -o conftest.o && test -f conftest.o ; then
+        if test `grep -l BIGenDianSyS conftest.o` ; then
+           echo $ac_n ' big endian probe OK, ' 1>&6
+           ac_cv_c_bigendian=yes
+        fi
+        if test `grep -l LiTTleEnDian conftest.o` ; then
+           echo $ac_n ' little endian probe OK, ' 1>&6
+           if test $ac_cv_c_bigendian = yes ; then
+            ac_cv_c_bigendian=unknown;
+           else
+            ac_cv_c_bigendian=no
+           fi
+        fi
+        echo $ac_n 'guessing bigendian ...  ' >&6
+     fi
+  fi
+echo "$ac_t""$ac_cv_c_bigendian" 1>&6
+fi
+if test $ac_cv_c_bigendian = yes; then
+  cat >> confdefs.h <<\EOF
+#define WORDS_BIGENDIAN 1
+EOF
+
+  BYTEORDER=4321
+else
+  BYTEORDER=1234
+fi
+cat >> confdefs.h <<EOF
+#define BYTEORDER $BYTEORDER
+EOF
+
+if test $ac_cv_c_bigendian = unknown; then
+  { echo "configure: error: unknown endianess - sorry" 1>&2; exit 1; }
+fi
+
+
+echo $ac_n "checking for working const""... $ac_c" 1>&6
+echo "configure:2125: checking for working const" >&5
+if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2130 "configure"
+#include "confdefs.h"
+
+int main() {
+
+/* Ultrix mips cc rejects this.  */
+typedef int charset[2]; const charset x;
+/* SunOS 4.1.1 cc rejects this.  */
+char const *const *ccp;
+char **p;
+/* NEC SVR4.0.2 mips cc rejects this.  */
+struct point {int x, y;};
+static struct point const zero = {0,0};
+/* AIX XL C 1.02.0.0 rejects this.
+   It does not let you subtract one const X* pointer from another in an arm
+   of an if-expression whose if-part is not a constant expression */
+const char *g = "string";
+ccp = &g + (g ? g-g : 0);
+/* HPUX 7.0 cc rejects these. */
+++ccp;
+p = (char**) ccp;
+ccp = (char const *const *) p;
+{ /* SCO 3.2v4 cc rejects this.  */
+  char *t;
+  char const *s = 0 ? (char *) 0 : (char const *) 0;
+
+  *t++ = 0;
+}
+{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
+  int x[] = {25, 17};
+  const int *foo = &x[0];
+  ++foo;
+}
+{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
+  typedef const int *iptr;
+  iptr p = 0;
+  ++p;
+}
+{ /* AIX XL C 1.02.0.0 rejects this saying
+     "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
+  struct s { int j; const int *ap[3]; };
+  struct s *b; b->j = 5;
+}
+{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
+  const int foo = 10;
+}
+
+; return 0; }
+EOF
+if { (eval echo configure:2179: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  rm -rf conftest*
+  ac_cv_c_const=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  ac_cv_c_const=no
+fi
+rm -f conftest*
+fi
+
+echo "$ac_t""$ac_cv_c_const" 1>&6
+if test $ac_cv_c_const = no; then
+  cat >> confdefs.h <<\EOF
+#define const 
+EOF
+
+fi
+
+echo $ac_n "checking for off_t""... $ac_c" 1>&6
+echo "configure:2200: checking for off_t" >&5
+if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2205 "configure"
+#include "confdefs.h"
+#include <sys/types.h>
+#if STDC_HEADERS
+#include <stdlib.h>
+#include <stddef.h>
+#endif
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "(^|[^a-zA-Z_0-9])off_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
+  rm -rf conftest*
+  ac_cv_type_off_t=yes
+else
+  rm -rf conftest*
+  ac_cv_type_off_t=no
+fi
+rm -f conftest*
+
+fi
+echo "$ac_t""$ac_cv_type_off_t" 1>&6
+if test $ac_cv_type_off_t = no; then
+  cat >> confdefs.h <<\EOF
+#define off_t long
+EOF
+
+fi
+
+echo $ac_n "checking for size_t""... $ac_c" 1>&6
+echo "configure:2233: checking for size_t" >&5
+if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2238 "configure"
+#include "confdefs.h"
+#include <sys/types.h>
+#if STDC_HEADERS
+#include <stdlib.h>
+#include <stddef.h>
+#endif
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "(^|[^a-zA-Z_0-9])size_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
+  rm -rf conftest*
+  ac_cv_type_size_t=yes
+else
+  rm -rf conftest*
+  ac_cv_type_size_t=no
+fi
+rm -f conftest*
+
+fi
+echo "$ac_t""$ac_cv_type_size_t" 1>&6
+if test $ac_cv_type_size_t = no; then
+  cat >> confdefs.h <<\EOF
+#define size_t unsigned
+EOF
+
+fi
+
+
+
+echo $ac_n "checking for 8-bit clean memcmp""... $ac_c" 1>&6
+echo "configure:2268: checking for 8-bit clean memcmp" >&5
+if eval "test \"`echo '$''{'ac_cv_func_memcmp_clean'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test "$cross_compiling" = yes; then
+  ac_cv_func_memcmp_clean=no
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2276 "configure"
+#include "confdefs.h"
+
+main()
+{
+  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
+  exit(memcmp(&c0, &c2, 1) < 0 && memcmp(&c1, &c2, 1) < 0 ? 0 : 1);
+}
+
+EOF
+if { (eval echo configure:2286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+then
+  ac_cv_func_memcmp_clean=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -fr conftest*
+  ac_cv_func_memcmp_clean=no
+fi
+rm -fr conftest*
+fi
+
+fi
+
+echo "$ac_t""$ac_cv_func_memcmp_clean" 1>&6
+test $ac_cv_func_memcmp_clean = no && LIBOBJS="$LIBOBJS memcmp.${ac_objext}"
+
+for ac_hdr in unistd.h
+do
+ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
+echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
+echo "configure:2307: checking for $ac_hdr" >&5
+if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2312 "configure"
+#include "confdefs.h"
+#include <$ac_hdr>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:2317: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=yes"
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=no"
+fi
+rm -f conftest*
+fi
+if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_hdr 1
+EOF
+ 
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+for ac_func in getpagesize
+do
+echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
+echo "configure:2346: checking for $ac_func" >&5
+if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2351 "configure"
+#include "confdefs.h"
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func(); below.  */
+#include <assert.h>
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+char $ac_func();
+
+int main() {
+
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+$ac_func();
+#endif
+
+; return 0; }
+EOF
+if { (eval echo configure:2374: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=yes"
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=no"
+fi
+rm -f conftest*
+fi
+
+if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_func 1
+EOF
+ 
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+echo $ac_n "checking for working mmap""... $ac_c" 1>&6
+echo "configure:2399: checking for working mmap" >&5
+if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test "$cross_compiling" = yes; then
+  ac_cv_func_mmap_fixed_mapped=no
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2407 "configure"
+#include "confdefs.h"
+
+/* Thanks to Mike Haertel and Jim Avera for this test.
+   Here is a matrix of mmap possibilities:
+	mmap private not fixed
+	mmap private fixed at somewhere currently unmapped
+	mmap private fixed at somewhere already mapped
+	mmap shared not fixed
+	mmap shared fixed at somewhere currently unmapped
+	mmap shared fixed at somewhere already mapped
+   For private mappings, we should verify that changes cannot be read()
+   back from the file, nor mmap's back from the file at a different
+   address.  (There have been systems where private was not correctly
+   implemented like the infamous i386 svr4.0, and systems where the
+   VM page cache was not coherent with the filesystem buffer cache
+   like early versions of FreeBSD and possibly contemporary NetBSD.)
+   For shared mappings, we should conversely verify that changes get
+   propogated back to all the places they're supposed to be.
+
+   Grep wants private fixed already mapped.
+   The main things grep needs to know about mmap are:
+   * does it exist and is it safe to write into the mmap'd area
+   * how to use it (BSD variants)  */
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+/* This mess was copied from the GNU getpagesize.h.  */
+#ifndef HAVE_GETPAGESIZE
+# ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+# endif
+
+/* Assume that all systems that can run configure have sys/param.h.  */
+# ifndef HAVE_SYS_PARAM_H
+#  define HAVE_SYS_PARAM_H 1
+# endif
+
+# ifdef _SC_PAGESIZE
+#  define getpagesize() sysconf(_SC_PAGESIZE)
+# else /* no _SC_PAGESIZE */
+#  ifdef HAVE_SYS_PARAM_H
+#   include <sys/param.h>
+#   ifdef EXEC_PAGESIZE
+#    define getpagesize() EXEC_PAGESIZE
+#   else /* no EXEC_PAGESIZE */
+#    ifdef NBPG
+#     define getpagesize() NBPG * CLSIZE
+#     ifndef CLSIZE
+#      define CLSIZE 1
+#     endif /* no CLSIZE */
+#    else /* no NBPG */
+#     ifdef NBPC
+#      define getpagesize() NBPC
+#     else /* no NBPC */
+#      ifdef PAGESIZE
+#       define getpagesize() PAGESIZE
+#      endif /* PAGESIZE */
+#     endif /* no NBPC */
+#    endif /* no NBPG */
+#   endif /* no EXEC_PAGESIZE */
+#  else /* no HAVE_SYS_PARAM_H */
+#   define getpagesize() 8192	/* punt totally */
+#  endif /* no HAVE_SYS_PARAM_H */
+# endif /* no _SC_PAGESIZE */
+
+#endif /* no HAVE_GETPAGESIZE */
+
+#ifdef __cplusplus
+extern "C" { void *malloc(unsigned); }
+#else
+char *malloc();
+#endif
+
+int
+main()
+{
+	char *data, *data2, *data3;
+	int i, pagesize;
+	int fd;
+
+	pagesize = getpagesize();
+
+	/*
+	 * First, make a file with some known garbage in it.
+	 */
+	data = malloc(pagesize);
+	if (!data)
+		exit(1);
+	for (i = 0; i < pagesize; ++i)
+		*(data + i) = rand();
+	umask(0);
+	fd = creat("conftestmmap", 0600);
+	if (fd < 0)
+		exit(1);
+	if (write(fd, data, pagesize) != pagesize)
+		exit(1);
+	close(fd);
+
+	/*
+	 * Next, try to mmap the file at a fixed address which
+	 * already has something else allocated at it.  If we can,
+	 * also make sure that we see the same garbage.
+	 */
+	fd = open("conftestmmap", O_RDWR);
+	if (fd < 0)
+		exit(1);
+	data2 = malloc(2 * pagesize);
+	if (!data2)
+		exit(1);
+	data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
+	if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
+	    MAP_PRIVATE | MAP_FIXED, fd, 0L))
+		exit(1);
+	for (i = 0; i < pagesize; ++i)
+		if (*(data + i) != *(data2 + i))
+			exit(1);
+
+	/*
+	 * Finally, make sure that changes to the mapped area
+	 * do not percolate back to the file as seen by read().
+	 * (This is a bug on some variants of i386 svr4.0.)
+	 */
+	for (i = 0; i < pagesize; ++i)
+		*(data2 + i) = *(data2 + i) + 1;
+	data3 = malloc(pagesize);
+	if (!data3)
+		exit(1);
+	if (read(fd, data3, pagesize) != pagesize)
+		exit(1);
+	for (i = 0; i < pagesize; ++i)
+		if (*(data + i) != *(data3 + i))
+			exit(1);
+	close(fd);
+	unlink("conftestmmap");
+	exit(0);
+}
+
+EOF
+if { (eval echo configure:2547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+then
+  ac_cv_func_mmap_fixed_mapped=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -fr conftest*
+  ac_cv_func_mmap_fixed_mapped=no
+fi
+rm -fr conftest*
+fi
+
+fi
+
+echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
+if test $ac_cv_func_mmap_fixed_mapped = yes; then
+  cat >> confdefs.h <<\EOF
+#define HAVE_MMAP 1
+EOF
+
+fi
+
+
+if test -z "$HAVE_MMAP"; then
+    FILEMAP_OBJ=unixfilemap.o
+else
+    FILEMAP_OBJ=readfilemap.o
+fi
+
+
+for ac_func in memmove bcopy
+do
+echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
+echo "configure:2580: checking for $ac_func" >&5
+if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2585 "configure"
+#include "confdefs.h"
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func(); below.  */
+#include <assert.h>
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+char $ac_func();
+
+int main() {
+
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+$ac_func();
+#endif
+
+; return 0; }
+EOF
+if { (eval echo configure:2608: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=yes"
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_func_$ac_func=no"
+fi
+rm -f conftest*
+fi
+
+if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_func 1
+EOF
+ 
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+
+
+OUTPUT="Makefile lib/Makefile lib/expat.h"
+if test -d ${srcdir}/xmlwf; then
+    OUTPUT="$OUTPUT xmlwf/Makefile"
+fi
+if test -d ${srcdir}/examples; then
+    OUTPUT="$OUTPUT examples/Makefile"
+fi
+trap '' 1 2 15
+cat > confcache <<\EOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs.  It is not useful on other systems.
+# If it contains results you don't want to keep, you may remove or edit it.
+#
+# By default, configure uses ./config.cache as the cache file,
+# creating it if it does not exist already.  You can give configure
+# the --cache-file=FILE option to use a different cache file; that is
+# what configure does when it calls configure scripts in
+# subdirectories, so they share the cache.
+# Giving --cache-file=/dev/null disables caching, for debugging configure.
+# config.status only pays attention to the cache file if you give it the
+# --recheck option to rerun configure.
+#
+EOF
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(set) 2>&1 |
+  case `(ac_space=' '; set | grep ac_space) 2>&1` in
+  *ac_space=\ *)
+    # `set' does not quote correctly, so add quotes (double-quote substitution
+    # turns \\\\ into \\, and sed turns \\ into \).
+    sed -n \
+      -e "s/'/'\\\\''/g" \
+      -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
+    ;;
+  *)
+    # `set' quotes correctly as required by POSIX, so do not add quotes.
+    sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
+    ;;
+  esac >> confcache
+if cmp -s $cache_file confcache; then
+  :
+else
+  if test -w $cache_file; then
+    echo "updating cache $cache_file"
+    cat confcache > $cache_file
+  else
+    echo "not updating unwritable cache $cache_file"
+  fi
+fi
+rm -f confcache
+
+trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# Any assignment to VPATH causes Sun make to only execute
+# the first set of double-colon rules, so remove it if not needed.
+# If there is a colon in the path, we need to keep it.
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[ 	]*VPATH[ 	]*=[^:]*$/d'
+fi
+
+trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
+
+DEFS=-DHAVE_CONFIG_H
+
+# Without the "./", some shells look in PATH for config.status.
+: ${CONFIG_STATUS=./config.status}
+
+echo creating $CONFIG_STATUS
+rm -f $CONFIG_STATUS
+cat > $CONFIG_STATUS <<EOF
+#! /bin/sh
+# Generated automatically by configure.
+# Run this file to recreate the current configuration.
+# This directory was configured as follows,
+# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+#
+# $0 $ac_configure_args
+#
+# Compiler output produced by configure, useful for debugging
+# configure, is in ./config.log if it exists.
+
+ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
+for ac_option
+do
+  case "\$ac_option" in
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
+    exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
+  -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
+    echo "$CONFIG_STATUS generated by autoconf version 2.13"
+    exit 0 ;;
+  -help | --help | --hel | --he | --h)
+    echo "\$ac_cs_usage"; exit 0 ;;
+  *) echo "\$ac_cs_usage"; exit 1 ;;
+  esac
+done
+
+ac_given_srcdir=$srcdir
+ac_given_INSTALL="$INSTALL"
+
+trap 'rm -fr `echo "$OUTPUT config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
+EOF
+cat >> $CONFIG_STATUS <<EOF
+
+# Protect against being on the right side of a sed subst in config.status.
+sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
+ s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
+$ac_vpsub
+$extrasub
+s%@SHELL@%$SHELL%g
+s%@CFLAGS@%$CFLAGS%g
+s%@CPPFLAGS@%$CPPFLAGS%g
+s%@CXXFLAGS@%$CXXFLAGS%g
+s%@FFLAGS@%$FFLAGS%g
+s%@DEFS@%$DEFS%g
+s%@LDFLAGS@%$LDFLAGS%g
+s%@LIBS@%$LIBS%g
+s%@exec_prefix@%$exec_prefix%g
+s%@prefix@%$prefix%g
+s%@program_transform_name@%$program_transform_name%g
+s%@bindir@%$bindir%g
+s%@sbindir@%$sbindir%g
+s%@libexecdir@%$libexecdir%g
+s%@datadir@%$datadir%g
+s%@sysconfdir@%$sysconfdir%g
+s%@sharedstatedir@%$sharedstatedir%g
+s%@localstatedir@%$localstatedir%g
+s%@libdir@%$libdir%g
+s%@includedir@%$includedir%g
+s%@oldincludedir@%$oldincludedir%g
+s%@infodir@%$infodir%g
+s%@mandir@%$mandir%g
+s%@host@%$host%g
+s%@host_alias@%$host_alias%g
+s%@host_cpu@%$host_cpu%g
+s%@host_vendor@%$host_vendor%g
+s%@host_os@%$host_os%g
+s%@build@%$build%g
+s%@build_alias@%$build_alias%g
+s%@build_cpu@%$build_cpu%g
+s%@build_vendor@%$build_vendor%g
+s%@build_os@%$build_os%g
+s%@RANLIB@%$RANLIB%g
+s%@CC@%$CC%g
+s%@LN_S@%$LN_S%g
+s%@DLLTOOL@%$DLLTOOL%g
+s%@AS@%$AS%g
+s%@OBJDUMP@%$OBJDUMP%g
+s%@LIBTOOL@%$LIBTOOL%g
+s%@PACKAGE@%$PACKAGE%g
+s%@VERSION@%$VERSION%g
+s%@EXPAT_MAJOR_VERSION@%$EXPAT_MAJOR_VERSION%g
+s%@EXPAT_MINOR_VERSION@%$EXPAT_MINOR_VERSION%g
+s%@EXPAT_EDIT@%$EXPAT_EDIT%g
+s%@LIBCURRENT@%$LIBCURRENT%g
+s%@LIBREVISION@%$LIBREVISION%g
+s%@LIBAGE@%$LIBAGE%g
+s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
+s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
+s%@INSTALL_DATA@%$INSTALL_DATA%g
+s%@CPP@%$CPP%g
+s%@LIBOBJS@%$LIBOBJS%g
+s%@FILEMAP_OBJ@%$FILEMAP_OBJ%g
+
+CEOF
+EOF
+
+cat >> $CONFIG_STATUS <<\EOF
+
+# Split the substitutions into bite-sized pieces for seds with
+# small command number limits, like on Digital OSF/1 and HP-UX.
+ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
+ac_file=1 # Number of current file.
+ac_beg=1 # First line for current file.
+ac_end=$ac_max_sed_cmds # Line after last line for current file.
+ac_more_lines=:
+ac_sed_cmds=""
+while $ac_more_lines; do
+  if test $ac_beg -gt 1; then
+    sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
+  else
+    sed "${ac_end}q" conftest.subs > conftest.s$ac_file
+  fi
+  if test ! -s conftest.s$ac_file; then
+    ac_more_lines=false
+    rm -f conftest.s$ac_file
+  else
+    if test -z "$ac_sed_cmds"; then
+      ac_sed_cmds="sed -f conftest.s$ac_file"
+    else
+      ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
+    fi
+    ac_file=`expr $ac_file + 1`
+    ac_beg=$ac_end
+    ac_end=`expr $ac_end + $ac_max_sed_cmds`
+  fi
+done
+if test -z "$ac_sed_cmds"; then
+  ac_sed_cmds=cat
+fi
+EOF
+
+cat >> $CONFIG_STATUS <<EOF
+
+CONFIG_FILES=\${CONFIG_FILES-"$OUTPUT"}
+EOF
+cat >> $CONFIG_STATUS <<\EOF
+for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case "$ac_file" in
+  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
+       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
+  *) ac_file_in="${ac_file}.in" ;;
+  esac
+
+  # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
+
+  # Remove last slash and all that follows it.  Not all systems have dirname.
+  ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
+  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
+    # The file is in a subdirectory.
+    test ! -d "$ac_dir" && mkdir "$ac_dir"
+    ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
+    # A "../" for each directory in $ac_dir_suffix.
+    ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
+  else
+    ac_dir_suffix= ac_dots=
+  fi
+
+  case "$ac_given_srcdir" in
+  .)  srcdir=.
+      if test -z "$ac_dots"; then top_srcdir=.
+      else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
+  /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
+  *) # Relative path.
+    srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
+    top_srcdir="$ac_dots$ac_given_srcdir" ;;
+  esac
+
+  case "$ac_given_INSTALL" in
+  [/$]*) INSTALL="$ac_given_INSTALL" ;;
+  *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
+  esac
+
+  echo creating "$ac_file"
+  rm -f "$ac_file"
+  configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
+  case "$ac_file" in
+  *Makefile*) ac_comsub="1i\\
+# $configure_input" ;;
+  *) ac_comsub= ;;
+  esac
+
+  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
+  sed -e "$ac_comsub
+s%@configure_input@%$configure_input%g
+s%@srcdir@%$srcdir%g
+s%@top_srcdir@%$top_srcdir%g
+s%@INSTALL@%$INSTALL%g
+" $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
+fi; done
+rm -f conftest.s*
+
+# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+# NAME is the cpp macro being defined and VALUE is the value it is being given.
+#
+# ac_d sets the value in "#define NAME VALUE" lines.
+ac_dA='s%^\([ 	]*\)#\([ 	]*define[ 	][ 	]*\)'
+ac_dB='\([ 	][ 	]*\)[^ 	]*%\1#\2'
+ac_dC='\3'
+ac_dD='%g'
+# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
+ac_uA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
+ac_uB='\([ 	]\)%\1#\2define\3'
+ac_uC=' '
+ac_uD='\4%g'
+# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+ac_eA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
+ac_eB='$%\1#\2define\3'
+ac_eC=' '
+ac_eD='%g'
+
+if test "${CONFIG_HEADERS+set}" != set; then
+EOF
+cat >> $CONFIG_STATUS <<EOF
+  CONFIG_HEADERS="config.h"
+EOF
+cat >> $CONFIG_STATUS <<\EOF
+fi
+for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case "$ac_file" in
+  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
+       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
+  *) ac_file_in="${ac_file}.in" ;;
+  esac
+
+  echo creating $ac_file
+
+  rm -f conftest.frag conftest.in conftest.out
+  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
+  cat $ac_file_inputs > conftest.in
+
+EOF
+
+# Transform confdefs.h into a sed script conftest.vals that substitutes
+# the proper values into config.h.in to produce config.h.  And first:
+# Protect against being on the right side of a sed subst in config.status.
+# Protect against being in an unquoted here document in config.status.
+rm -f conftest.vals
+cat > conftest.hdr <<\EOF
+s/[\\&%]/\\&/g
+s%[\\$`]%\\&%g
+s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
+s%ac_d%ac_u%gp
+s%ac_u%ac_e%gp
+EOF
+sed -n -f conftest.hdr confdefs.h > conftest.vals
+rm -f conftest.hdr
+
+# This sed command replaces #undef with comments.  This is necessary, for
+# example, in the case of _POSIX_SOURCE, which is predefined and required
+# on some systems where configure will not decide to define it.
+cat >> conftest.vals <<\EOF
+s%^[ 	]*#[ 	]*undef[ 	][ 	]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
+EOF
+
+# Break up conftest.vals because some shells have a limit on
+# the size of here documents, and old seds have small limits too.
+
+rm -f conftest.tail
+while :
+do
+  ac_lines=`grep -c . conftest.vals`
+  # grep -c gives empty output for an empty file on some AIX systems.
+  if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
+  # Write a limited-size here document to conftest.frag.
+  echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
+  sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
+  echo 'CEOF
+  sed -f conftest.frag conftest.in > conftest.out
+  rm -f conftest.in
+  mv conftest.out conftest.in
+' >> $CONFIG_STATUS
+  sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
+  rm -f conftest.vals
+  mv conftest.tail conftest.vals
+done
+rm -f conftest.vals
+
+cat >> $CONFIG_STATUS <<\EOF
+  rm -f conftest.frag conftest.h
+  echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
+  cat conftest.in >> conftest.h
+  rm -f conftest.in
+  if cmp -s $ac_file conftest.h 2>/dev/null; then
+    echo "$ac_file is unchanged"
+    rm -f conftest.h
+  else
+    # Remove last slash and all that follows it.  Not all systems have dirname.
+      ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
+      if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
+      # The file is in a subdirectory.
+      test ! -d "$ac_dir" && mkdir "$ac_dir"
+    fi
+    rm -f $ac_file
+    mv conftest.h $ac_file
+  fi
+fi; done
+
+EOF
+cat >> $CONFIG_STATUS <<EOF
+
+EOF
+cat >> $CONFIG_STATUS <<\EOF
+
+exit 0
+EOF
+chmod +x $CONFIG_STATUS
+rm -fr confdefs* $ac_clean_files
+test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
+
Index: xc/extras/expat/configure.in
diff -u /dev/null xc/extras/expat/configure.in:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/configure.in	Mon Feb 18 16:44:17 2002
@@ -0,0 +1,111 @@
+dnl   configuration script for expat
+dnl   Process this file with autoconf to produce a configure script.
+dnl
+dnl   Copyright 2000 Clark Cooper
+dnl
+dnl   This file is part of EXPAT.
+dnl
+dnl   EXPAT is free software; you can redistribute it and/or modify it
+dnl   under the terms of the License (based on the MIT/X license) contained
+dnl   in the file COPYING that comes with this distribution.
+dnl
+
+AC_INIT(Makefile.in)
+AC_CONFIG_AUX_DIR(conftools)
+
+dnl
+dnl Follow the GNU/Linux convention of odd number minor version for
+dnl beta/development releases and even number minor version for stable
+dnl releases. Edit is bumped with each release and set to 0 with
+dnl change to major or minor version.
+dnl
+
+EXPAT_MAJOR_VERSION=1
+EXPAT_MINOR_VERSION=95
+EXPAT_EDIT=2
+
+EXPAT_VERSION=$EXPAT_MAJOR_VERSION.$EXPAT_MINOR_VERSION.$EXPAT_EDIT
+VERSION=$EXPAT_VERSION
+PACKAGE=expat
+
+dnl
+dnl Increment LIBREVISION if source code has changed at all
+dnl
+dnl If the API has changed, increment LIBCURRENT and set LIBREVISION to 0
+dnl
+dnl If the API changes compatibly (i.e. simply adding a new function
+dnl without changing or removing earlier interfaces), then increment LIBAGE.
+dnl 
+dnl If the API changes incompatibly set LIBAGE back to 0
+dnl
+
+LIBCURRENT=1
+LIBREVISION=0
+LIBAGE=1
+
+AC_CONFIG_HEADER(config.h)
+
+AC_LIBTOOL_WIN32_DLL
+AC_PROG_LIBTOOL
+
+AC_SUBST(PACKAGE)
+AC_SUBST(VERSION)
+AC_SUBST(EXPAT_MAJOR_VERSION)
+AC_SUBST(EXPAT_MINOR_VERSION)
+AC_SUBST(EXPAT_EDIT)
+
+AC_SUBST(LIBCURRENT)
+AC_SUBST(LIBREVISION)
+AC_SUBST(LIBAGE)
+
+dnl Checks for programs.
+AC_PROG_CC
+AC_PROG_INSTALL
+
+if test "$GCC" = yes ; then
+    CFLAGS="$CFLAGS -Wall -Wmissing-prototypes -Wstrict-prototypes -fexceptions"
+fi
+
+dnl Checks for libraries.
+
+dnl Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS(fcntl.h unistd.h)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+
+dnl Note: Avoid using AC_C_BIGENDIAN because it does not
+dnl work in a cross compile.
+AC_C_BIGENDIAN_CROSS
+
+AC_C_CONST
+AC_TYPE_OFF_T
+AC_TYPE_SIZE_T
+
+dnl Checks for library functions.
+
+AC_FUNC_MEMCMP
+AC_FUNC_MMAP
+
+if test -z "$HAVE_MMAP"; then
+    FILEMAP_OBJ=unixfilemap.o
+else
+    FILEMAP_OBJ=readfilemap.o
+fi
+AC_SUBST(FILEMAP_OBJ)
+
+AC_CHECK_FUNCS(memmove bcopy)
+
+dnl Generate makefiles only for the directories that are present;
+dnl this allows this (and the generated configure script) to work
+dnl in "embedded distributions", where only part of the Expat sources
+dnl are included in the sources for another project.
+
+OUTPUT="Makefile lib/Makefile lib/expat.h"
+if test -d ${srcdir}/xmlwf; then
+    OUTPUT="$OUTPUT xmlwf/Makefile"
+fi
+if test -d ${srcdir}/examples; then
+    OUTPUT="$OUTPUT examples/Makefile"
+fi
+AC_OUTPUT($OUTPUT)
Index: xc/extras/expat/conftools/PrintPath
diff -u /dev/null xc/extras/expat/conftools/PrintPath:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/PrintPath	Mon Feb 18 16:44:17 2002
@@ -0,0 +1,116 @@
+#!/bin/sh
+# Look for program[s] somewhere in $PATH.
+#
+# Options:
+#  -s
+#    Do not print out full pathname. (silent)
+#  -pPATHNAME
+#    Look in PATHNAME instead of $PATH
+#
+# Usage:
+#  PrintPath [-s] [-pPATHNAME] program [program ...]
+#
+# Initially written by Jim Jagielski for the Apache configuration mechanism
+#  (with kudos to Kernighan/Pike)
+#
+# This script falls under the Apache License.
+# See http://www.apache.org/licenses/LICENSE
+
+##
+# Some "constants"
+##
+pathname=$PATH
+echo="yes"
+
+##
+# Find out what OS we are running for later on
+##
+os=`(uname) 2>/dev/null`
+
+##
+# Parse command line
+##
+for args in $*
+do
+    case $args in
+	-s  ) echo="no" ;;
+	-p* ) pathname="`echo $args | sed 's/^..//'`" ;;
+	*   ) programs="$programs $args" ;;
+    esac
+done
+
+##
+# Now we make the adjustments required for OS/2 and everyone
+# else :)
+#
+# First of all, all OS/2 programs have the '.exe' extension.
+# Next, we adjust PATH (or what was given to us as PATH) to
+# be whitespace seperated directories.
+# Finally, we try to determine the best flag to use for
+# test/[] to look for an executable file. OS/2 just has '-r'
+# but with other OSs, we do some funny stuff to check to see
+# if test/[] knows about -x, which is the prefered flag.
+##
+
+if [ "x$os" = "xOS/2" ]
+then
+    ext=".exe"
+    pathname=`echo -E $pathname |
+     sed 's/^;/.;/
+	  s/;;/;.;/g
+	  s/;$/;./
+	  s/;/ /g
+	  s/\\\\/\\//g' `
+    test_exec_flag="-r"
+else
+    ext=""	# No default extensions
+    pathname=`echo $pathname |
+     sed 's/^:/.:/
+	  s/::/:.:/g
+	  s/:$/:./
+	  s/:/ /g' `
+    # Here is how we test to see if test/[] can handle -x
+    testfile="pp.t.$$"
+
+    cat > $testfile <<ENDTEST
+#!/bin/sh
+if [ -x / ] || [ -x /bin ] || [ -x /bin/ls ]; then
+    exit 0
+fi
+exit 1
+ENDTEST
+
+    if `/bin/sh $testfile 2>/dev/null`; then
+	test_exec_flag="-x"
+    else
+	test_exec_flag="-r"
+    fi
+    rm -f $testfile
+fi
+
+for program in $programs
+do
+    for path in $pathname
+    do
+	if [ $test_exec_flag $path/${program}${ext} ] && \
+	   [ ! -d $path/${program}${ext} ]; then
+	    if [ "x$echo" = "xyes" ]; then
+		echo $path/${program}${ext}
+	    fi
+	    exit 0
+	fi
+
+# Next try without extension (if one was used above)
+	if [ "x$ext" != "x" ]; then
+            if [ $test_exec_flag $path/${program} ] && \
+               [ ! -d $path/${program} ]; then
+                if [ "x$echo" = "xyes" ]; then
+                    echo $path/${program}
+                fi
+                exit 0
+            fi
+        fi
+    done
+done
+exit 1
+
Index: xc/extras/expat/conftools/ac_c_bigendian_cross.m4
diff -u /dev/null xc/extras/expat/conftools/ac_c_bigendian_cross.m4:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/ac_c_bigendian_cross.m4	Mon Feb 18 16:44:17 2002
@@ -0,0 +1,81 @@
+dnl @synopsis AC_C_BIGENDIAN_CROSS
+dnl
+dnl Check endianess even when crosscompiling
+dnl (partially based on the original AC_C_BIGENDIAN).
+dnl
+dnl The implementation will create a binary, and instead of running
+dnl the binary it will be grep'ed for some symbols that will look
+dnl different for different endianess of the binary.
+dnl
+dnl @version $Id: ac_c_bigendian_cross.m4,v 1.1 2001/07/24 19:51:35 fdrake Exp $
+dnl @author Guido Draheim <guidod@gmx.de>
+dnl
+AC_DEFUN([AC_C_BIGENDIAN_CROSS],
+[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
+[ac_cv_c_bigendian=unknown
+# See if sys/param.h defines the BYTE_ORDER macro.
+AC_TRY_COMPILE([#include <sys/types.h>
+#include <sys/param.h>], [
+#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
+ bogus endian macros
+#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
+AC_TRY_COMPILE([#include <sys/types.h>
+#include <sys/param.h>], [
+#if BYTE_ORDER != BIG_ENDIAN
+ not big endian
+#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
+if test $ac_cv_c_bigendian = unknown; then
+AC_TRY_RUN([main () {
+  /* Are we little or big endian?  From Harbison&Steele.  */
+  union
+  {
+    long l;
+    char c[sizeof (long)];
+  } u;
+  u.l = 1;
+  exit (u.c[sizeof (long) - 1] == 1);
+}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes,
+[ echo $ac_n "cross-compiling... " 2>&AC_FD_MSG ])
+fi])
+if test $ac_cv_c_bigendian = unknown; then
+AC_MSG_CHECKING(to probe for byte ordering)
+[
+cat >conftest.c <<EOF
+short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
+short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
+void _ascii() { char* s = (char*) ascii_mm; s = (char*) ascii_ii; }
+short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
+short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
+void _ebcdic() { char* s = (char*) ebcdic_mm; s = (char*) ebcdic_ii; }
+int main() { _ascii (); _ebcdic (); return 0; }
+EOF
+] if test -f conftest.c ; then
+     if ${CC-cc} conftest.c -o conftest.o && test -f conftest.o ; then
+        if test `grep -l BIGenDianSyS conftest.o` ; then
+           echo $ac_n ' big endian probe OK, ' 1>&AC_FD_MSG
+           ac_cv_c_bigendian=yes
+        fi
+        if test `grep -l LiTTleEnDian conftest.o` ; then
+           echo $ac_n ' little endian probe OK, ' 1>&AC_FD_MSG
+           if test $ac_cv_c_bigendian = yes ; then
+            ac_cv_c_bigendian=unknown;
+           else
+            ac_cv_c_bigendian=no
+           fi
+        fi
+        echo $ac_n 'guessing bigendian ...  ' >&AC_FD_MSG
+     fi
+  fi
+AC_MSG_RESULT($ac_cv_c_bigendian)
+fi
+if test $ac_cv_c_bigendian = yes; then
+  AC_DEFINE(WORDS_BIGENDIAN, 1, [whether byteorder is bigendian])
+  BYTEORDER=4321
+else
+  BYTEORDER=1234
+fi
+AC_DEFINE_UNQUOTED(BYTEORDER, $BYTEORDER, [1234 = LIL_ENDIAN, 4321 = BIGENDIAN])
+if test $ac_cv_c_bigendian = unknown; then
+  AC_MSG_ERROR(unknown endianess - sorry, please pre-set ac_cv_c_bigendian)
+fi
+])
Index: xc/extras/expat/conftools/config.guess
diff -u /dev/null xc/extras/expat/conftools/config.guess:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/config.guess	Mon Feb 18 16:44:18 2002
@@ -0,0 +1,1183 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+#   Free Software Foundation, Inc.
+#
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Written by Per Bothner <bothner@cygnus.com>.
+# Please send patches to <config-patches@gnu.org>.
+#
+# This script attempts to guess a canonical system name similar to
+# config.sub.  If it succeeds, it prints the system name on stdout, and
+# exits with 0.  Otherwise, it exits with 1.
+#
+# The plan is that this can be called by configure scripts if you
+# don't specify an explicit system type (host/target name).
+#
+# Only a few systems have been added to this list; please add others
+# (but try to keep the structure clean).
+#
+
+# Use $HOST_CC if defined. $CC may point to a cross-compiler
+if test x"$CC_FOR_BUILD" = x; then
+  if test x"$HOST_CC" != x; then
+    CC_FOR_BUILD="$HOST_CC"
+  else
+    if test x"$CC" != x; then
+      CC_FOR_BUILD="$CC"
+    else
+      CC_FOR_BUILD=cc
+    fi
+  fi
+fi
+
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 8/24/94.)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+	PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+dummy=dummy-$$
+trap 'rm -f $dummy.c $dummy.o $dummy; exit 1' 1 2 15
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+    *:NetBSD:*:*)
+	# Netbsd (nbsd) targets should (where applicable) match one or
+	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+	# switched to ELF, *-*-netbsd* would select the old
+	# object file format.  This provides both forward
+	# compatibility and a consistent mechanism for selecting the
+	# object file format.
+	# Determine the machine/vendor (is the vendor relevant).
+	case "${UNAME_MACHINE}" in
+	    amiga) machine=m68k-cbm ;;
+	    arm32) machine=arm-unknown ;;
+	    atari*) machine=m68k-atari ;;
+	    sun3*) machine=m68k-sun ;;
+	    mac68k) machine=m68k-apple ;;
+	    macppc) machine=powerpc-apple ;;
+	    hp3[0-9][05]) machine=m68k-hp ;;
+	    ibmrt|romp-ibm) machine=romp-ibm ;;
+	    *) machine=${UNAME_MACHINE}-unknown ;;
+	esac
+	# The Operating System including object format.
+	if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+		| grep __ELF__ >/dev/null
+	then
+	    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+	    # Return netbsd for either.  FIX?
+	    os=netbsd
+	else
+	    os=netbsdelf
+	fi
+	# The OS release
+	release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+	# contains redundant information, the shorter form:
+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+	echo "${machine}-${os}${release}"
+	exit 0 ;;
+    alpha:OSF1:*:*)
+	if test $UNAME_RELEASE = "V4.0"; then
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+	fi
+	# A Vn.n version is a released version.
+	# A Tn.n version is a released field test version.
+	# A Xn.n version is an unreleased experimental baselevel.
+	# 1.2 uses "1.2" for uname -r.
+	cat <<EOF >$dummy.s
+	.data
+\$Lformat:
+	.byte 37,100,45,37,120,10,0	# "%d-%x\n"
+
+	.text
+	.globl main
+	.align 4
+	.ent main
+main:
+	.frame \$30,16,\$26,0
+	ldgp \$29,0(\$27)
+	.prologue 1
+	.long 0x47e03d80 # implver \$0
+	lda \$2,-1
+	.long 0x47e20c21 # amask \$2,\$1
+	lda \$16,\$Lformat
+	mov \$0,\$17
+	not \$1,\$18
+	jsr \$26,printf
+	ldgp \$29,0(\$26)
+	mov 0,\$16
+	jsr \$26,exit
+	.end main
+EOF
+	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
+	if test "$?" = 0 ; then
+		case `./$dummy` in
+			0-0)
+				UNAME_MACHINE="alpha"
+				;;
+			1-0)
+				UNAME_MACHINE="alphaev5"
+				;;
+			1-1)
+				UNAME_MACHINE="alphaev56"
+				;;
+			1-101)
+				UNAME_MACHINE="alphapca56"
+				;;
+			2-303)
+				UNAME_MACHINE="alphaev6"
+				;;
+			2-307)
+				UNAME_MACHINE="alphaev67"
+				;;
+		esac
+	fi
+	rm -f $dummy.s $dummy
+	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+	exit 0 ;;
+    Alpha\ *:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# Should we change UNAME_MACHINE based on the output of uname instead
+	# of the specific Alpha model?
+	echo alpha-pc-interix
+	exit 0 ;;
+    21064:Windows_NT:50:3)
+	echo alpha-dec-winnt3.5
+	exit 0 ;;
+    Amiga*:UNIX_System_V:4.0:*)
+	echo m68k-cbm-sysv4
+	exit 0;;
+    amiga:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    *:[Aa]miga[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-amigaos
+	exit 0 ;;
+    arc64:OpenBSD:*:*)
+	echo mips64el-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    arc:OpenBSD:*:*)
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    hkmips:OpenBSD:*:*)
+	echo mips-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    pmax:OpenBSD:*:*)
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    sgi:OpenBSD:*:*)
+	echo mips-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    wgrisc:OpenBSD:*:*)
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    *:OS/390:*:*)
+	echo i370-ibm-openedition
+	exit 0 ;;
+    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+	echo arm-acorn-riscix${UNAME_RELEASE}
+	exit 0;;
+    SR2?01:HI-UX/MPP:*:*)
+	echo hppa1.1-hitachi-hiuxmpp
+	exit 0;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+	if test "`(/bin/universe) 2>/dev/null`" = att ; then
+		echo pyramid-pyramid-sysv3
+	else
+		echo pyramid-pyramid-bsd
+	fi
+	exit 0 ;;
+    NILE*:*:*:dcosx)
+	echo pyramid-pyramid-svr4
+	exit 0 ;;
+    sun4H:SunOS:5.*:*)
+	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    i86pc:SunOS:5.*:*)
+	echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    sun4*:SunOS:6*:*)
+	# According to config.sub, this is the proper way to canonicalize
+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+	# it's likely to be more like Solaris than SunOS4.
+	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    sun4*:SunOS:*:*)
+	case "`/usr/bin/arch -k`" in
+	    Series*|S4*)
+		UNAME_RELEASE=`uname -v`
+		;;
+	esac
+	# Japanese Language versions have a version number like `4.1.3-JL'.
+	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+	exit 0 ;;
+    sun3*:SunOS:*:*)
+	echo m68k-sun-sunos${UNAME_RELEASE}
+	exit 0 ;;
+    sun*:*:4.2BSD:*)
+	UNAME_RELEASE=`(head -1 /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+	case "`/bin/arch`" in
+	    sun3)
+		echo m68k-sun-sunos${UNAME_RELEASE}
+		;;
+	    sun4)
+		echo sparc-sun-sunos${UNAME_RELEASE}
+		;;
+	esac
+	exit 0 ;;
+    aushp:SunOS:*:*)
+	echo sparc-auspex-sunos${UNAME_RELEASE}
+	exit 0 ;;
+    atari*:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+	exit 0 ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+	echo m68k-atari-mint${UNAME_RELEASE}
+        exit 0 ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+        echo m68k-atari-mint${UNAME_RELEASE}
+	exit 0 ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+        echo m68k-milan-mint${UNAME_RELEASE}
+        exit 0 ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+        echo m68k-hades-mint${UNAME_RELEASE}
+        exit 0 ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+        echo m68k-unknown-mint${UNAME_RELEASE}
+        exit 0 ;;
+    sun3*:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mac68k:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mvme68k:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mvme88k:OpenBSD:*:*)
+	echo m88k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    powerpc:machten:*:*)
+	echo powerpc-apple-machten${UNAME_RELEASE}
+	exit 0 ;;
+    RISC*:Mach:*:*)
+	echo mips-dec-mach_bsd4.3
+	exit 0 ;;
+    RISC*:ULTRIX:*:*)
+	echo mips-dec-ultrix${UNAME_RELEASE}
+	exit 0 ;;
+    VAX*:ULTRIX*:*:*)
+	echo vax-dec-ultrix${UNAME_RELEASE}
+	exit 0 ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+	echo clipper-intergraph-clix${UNAME_RELEASE}
+	exit 0 ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+	sed 's/^	//' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv[]) {
+#else
+	int main (argc, argv) int argc; char *argv[]; {
+#endif
+	#if defined (host_mips) && defined (MIPSEB)
+	#if defined (SYSTYPE_SYSV)
+	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_SVR4)
+	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+	#endif
+	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+	#endif
+	#endif
+	  exit (-1);
+	}
+EOF
+	$CC_FOR_BUILD $dummy.c -o $dummy \
+	  && ./$dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \
+	  && rm $dummy.c $dummy && exit 0
+	rm -f $dummy.c $dummy
+	echo mips-mips-riscos${UNAME_RELEASE}
+	exit 0 ;;
+    Night_Hawk:Power_UNIX:*:*)
+	echo powerpc-harris-powerunix
+	exit 0 ;;
+    m88k:CX/UX:7*:*)
+	echo m88k-harris-cxux7
+	exit 0 ;;
+    m88k:*:4*:R4*)
+	echo m88k-motorola-sysv4
+	exit 0 ;;
+    m88k:*:3*:R3*)
+	echo m88k-motorola-sysv3
+	exit 0 ;;
+    AViiON:dgux:*:*)
+        # DG/UX returns AViiON for all architectures
+        UNAME_PROCESSOR=`/usr/bin/uname -p`
+	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+	then
+	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+	       [ ${TARGET_BINARY_INTERFACE}x = x ]
+	    then
+		echo m88k-dg-dgux${UNAME_RELEASE}
+	    else
+		echo m88k-dg-dguxbcs${UNAME_RELEASE}
+	    fi
+	else
+	    echo i586-dg-dgux${UNAME_RELEASE}
+	fi
+ 	exit 0 ;;
+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
+	echo m88k-dolphin-sysv3
+	exit 0 ;;
+    M88*:*:R3*:*)
+	# Delta 88k system running SVR3
+	echo m88k-motorola-sysv3
+	exit 0 ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+	echo m88k-tektronix-sysv3
+	exit 0 ;;
+    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+	echo m68k-tektronix-bsd
+	exit 0 ;;
+    *:IRIX*:*:*)
+	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+	exit 0 ;;
+    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+	echo romp-ibm-aix      # uname -m gives an 8 hex-code CPU id
+	exit 0 ;;              # Note that: echo "'`uname -s`'" gives 'AIX '
+    i?86:AIX:*:*)
+	echo i386-ibm-aix
+	exit 0 ;;
+    *:AIX:2:3)
+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		sed 's/^		//' << EOF >$dummy.c
+		#include <sys/systemcfg.h>
+
+		main()
+			{
+			if (!__power_pc())
+				exit(1);
+			puts("powerpc-ibm-aix3.2.5");
+			exit(0);
+			}
+EOF
+		$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
+		rm -f $dummy.c $dummy
+		echo rs6000-ibm-aix3.2.5
+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+		echo rs6000-ibm-aix3.2.4
+	else
+		echo rs6000-ibm-aix3.2
+	fi
+	exit 0 ;;
+    *:AIX:*:4)
+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | head -1 | awk '{ print $1 }'`
+	if /usr/sbin/lsattr -EHl ${IBM_CPU_ID} | grep POWER >/dev/null 2>&1; then
+		IBM_ARCH=rs6000
+	else
+		IBM_ARCH=powerpc
+	fi
+	if [ -x /usr/bin/oslevel ] ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV=4.${UNAME_RELEASE}
+	fi
+	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+	exit 0 ;;
+    *:AIX:*:*)
+	echo rs6000-ibm-aix
+	exit 0 ;;
+    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+	echo romp-ibm-bsd4.4
+	exit 0 ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+	exit 0 ;;                           # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+	echo rs6000-bull-bosx
+	exit 0 ;;
+    DPX/2?00:B.O.S.:*:*)
+	echo m68k-bull-sysv3
+	exit 0 ;;
+    9000/[34]??:4.3bsd:1.*:*)
+	echo m68k-hp-bsd
+	exit 0 ;;
+    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+	echo m68k-hp-bsd4.4
+	exit 0 ;;
+    9000/[34678]??:HP-UX:*:*)
+	case "${UNAME_MACHINE}" in
+	    9000/31? )            HP_ARCH=m68000 ;;
+	    9000/[34]?? )         HP_ARCH=m68k ;;
+	    9000/[678][0-9][0-9])
+              sed 's/^              //' << EOF >$dummy.c
+
+              #define _HPUX_SOURCE
+              #include <stdlib.h>
+              #include <unistd.h>
+
+              int main ()
+              {
+              #if defined(_SC_KERNEL_BITS)
+                  long bits = sysconf(_SC_KERNEL_BITS);
+              #endif
+                  long cpu  = sysconf (_SC_CPU_VERSION);
+
+                  switch (cpu)
+              	{
+              	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+              	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+              	case CPU_PA_RISC2_0:
+              #if defined(_SC_KERNEL_BITS)
+              	    switch (bits)
+              		{
+              		case 64: puts ("hppa2.0w"); break;
+              		case 32: puts ("hppa2.0n"); break;
+              		default: puts ("hppa2.0"); break;
+              		} break;
+              #else  /* !defined(_SC_KERNEL_BITS) */
+              	    puts ("hppa2.0"); break;
+              #endif
+              	default: puts ("hppa1.0"); break;
+              	}
+                  exit (0);
+              }
+EOF
+	(CCOPTS= $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null ) && HP_ARCH=`./$dummy`
+	rm -f $dummy.c $dummy
+	esac
+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+	exit 0 ;;
+    3050*:HI-UX:*:*)
+	sed 's/^	//' << EOF >$dummy.c
+	#include <unistd.h>
+	int
+	main ()
+	{
+	  long cpu = sysconf (_SC_CPU_VERSION);
+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+	     results, however.  */
+	  if (CPU_IS_PA_RISC (cpu))
+	    {
+	      switch (cpu)
+		{
+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+		  default: puts ("hppa-hitachi-hiuxwe2"); break;
+		}
+	    }
+	  else if (CPU_IS_HP_MC68K (cpu))
+	    puts ("m68k-hitachi-hiuxwe2");
+	  else puts ("unknown-hitachi-hiuxwe2");
+	  exit (0);
+	}
+EOF
+	$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
+	rm -f $dummy.c $dummy
+	echo unknown-hitachi-hiuxwe2
+	exit 0 ;;
+    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+	echo hppa1.1-hp-bsd
+	exit 0 ;;
+    9000/8??:4.3bsd:*:*)
+	echo hppa1.0-hp-bsd
+	exit 0 ;;
+    *9??*:MPE/iX:*:*)
+	echo hppa1.0-hp-mpeix
+	exit 0 ;;
+    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+	echo hppa1.1-hp-osf
+	exit 0 ;;
+    hp8??:OSF1:*:*)
+	echo hppa1.0-hp-osf
+	exit 0 ;;
+    i?86:OSF1:*:*)
+	if [ -x /usr/sbin/sysversion ] ; then
+	    echo ${UNAME_MACHINE}-unknown-osf1mk
+	else
+	    echo ${UNAME_MACHINE}-unknown-osf1
+	fi
+	exit 0 ;;
+    parisc*:Lites*:*:*)
+	echo hppa1.1-hp-lites
+	exit 0 ;;
+    hppa*:OpenBSD:*:*)
+	echo hppa-unknown-openbsd
+	exit 0 ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+	echo c1-convex-bsd
+        exit 0 ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+        exit 0 ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+	echo c34-convex-bsd
+        exit 0 ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+	echo c38-convex-bsd
+        exit 0 ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+	echo c4-convex-bsd
+        exit 0 ;;
+    CRAY*X-MP:*:*:*)
+	echo xmp-cray-unicos
+        exit 0 ;;
+    CRAY*Y-MP:*:*:*)
+	echo ymp-cray-unicos${UNAME_RELEASE}
+	exit 0 ;;
+    CRAY*[A-Z]90:*:*:*)
+	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
+	exit 0 ;;
+    CRAY*TS:*:*:*)
+	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit 0 ;;
+    CRAY*T3E:*:*:*)
+	echo alpha-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit 0 ;;
+    CRAY*SV1:*:*:*)
+	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+	exit 0 ;;
+    CRAY-2:*:*:*)
+	echo cray2-cray-unicos
+        exit 0 ;;
+    F300:UNIX_System_V:*:*)
+        FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+        FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+        echo "f300-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+        exit 0 ;;
+    F301:UNIX_System_V:*:*)
+       echo f301-fujitsu-uxpv`echo $UNAME_RELEASE | sed 's/ .*//'`
+       exit 0 ;;
+    hp300:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    i?86:BSD/386:*:* | i?86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+	exit 0 ;;
+    sparc*:BSD/OS:*:*)
+	echo sparc-unknown-bsdi${UNAME_RELEASE}
+	exit 0 ;;
+    *:BSD/OS:*:*)
+	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+	exit 0 ;;
+    *:FreeBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+	exit 0 ;;
+    *:OpenBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-openbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+	exit 0 ;;
+    i*:CYGWIN*:*)
+	echo ${UNAME_MACHINE}-pc-cygwin
+	exit 0 ;;
+    i*:MINGW*:*)
+	echo ${UNAME_MACHINE}-pc-mingw32
+	exit 0 ;;
+    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+	# How do we know it's Interix rather than the generic POSIX subsystem?
+	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+	# UNAME_MACHINE based on the output of uname instead of i386?
+	echo i386-pc-interix
+	exit 0 ;;
+    i*:UWIN*:*)
+	echo ${UNAME_MACHINE}-pc-uwin
+	exit 0 ;;
+    p*:CYGWIN*:*)
+	echo powerpcle-unknown-cygwin
+	exit 0 ;;
+    prep*:SunOS:5.*:*)
+	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+	exit 0 ;;
+    *:GNU:*:*)
+	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+	exit 0 ;;
+    *:Linux:*:*)
+
+	# The BFD linker knows what the default object file format is, so
+	# first see if it will tell us. cd to the root directory to prevent
+	# problems with other programs or directories called `ld' in the path.
+	ld_help_string=`cd /; ld --help 2>&1`
+	ld_supported_emulations=`echo $ld_help_string \
+			 | sed -ne '/supported emulations:/!d
+				    s/[ 	][ 	]*/ /g
+				    s/.*supported emulations: *//
+				    s/ .*//
+				    p'`
+        case "$ld_supported_emulations" in
+	  *ia64)
+		echo "${UNAME_MACHINE}-unknown-linux"
+		exit 0
+		;;
+	  i?86linux)
+		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
+		exit 0
+		;;
+	  elf_i?86)
+		echo "${UNAME_MACHINE}-pc-linux"
+		exit 0
+		;;
+	  i?86coff)
+		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
+		exit 0
+		;;
+	  sparclinux)
+		echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
+		exit 0
+		;;
+	  armlinux)
+		echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
+		exit 0
+		;;
+	  elf32arm*)
+		echo "${UNAME_MACHINE}-unknown-linux-gnuoldld"
+		exit 0
+		;;
+	  armelf_linux*)
+		echo "${UNAME_MACHINE}-unknown-linux-gnu"
+		exit 0
+		;;
+	  m68klinux)
+		echo "${UNAME_MACHINE}-unknown-linux-gnuaout"
+		exit 0
+		;;
+	  elf32ppc | elf32ppclinux)
+		# Determine Lib Version
+		cat >$dummy.c <<EOF
+#include <features.h>
+#if defined(__GLIBC__)
+extern char __libc_version[];
+extern char __libc_release[];
+#endif
+main(argc, argv)
+     int argc;
+     char *argv[];
+{
+#if defined(__GLIBC__)
+  printf("%s %s\n", __libc_version, __libc_release);
+#else
+  printf("unkown\n");
+#endif
+  return 0;
+}
+EOF
+		LIBC=""
+		$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null
+		if test "$?" = 0 ; then
+			./$dummy | grep 1\.99 > /dev/null
+			if test "$?" = 0 ; then
+				LIBC="libc1"
+			fi
+		fi
+		rm -f $dummy.c $dummy
+		echo powerpc-unknown-linux-gnu${LIBC}
+		exit 0
+		;;
+	esac
+
+	if test "${UNAME_MACHINE}" = "alpha" ; then
+		cat <<EOF >$dummy.s
+			.data
+		\$Lformat:
+			.byte 37,100,45,37,120,10,0	# "%d-%x\n"
+
+			.text
+			.globl main
+			.align 4
+			.ent main
+		main:
+			.frame \$30,16,\$26,0
+			ldgp \$29,0(\$27)
+			.prologue 1
+			.long 0x47e03d80 # implver \$0
+			lda \$2,-1
+			.long 0x47e20c21 # amask \$2,\$1
+			lda \$16,\$Lformat
+			mov \$0,\$17
+			not \$1,\$18
+			jsr \$26,printf
+			ldgp \$29,0(\$26)
+			mov 0,\$16
+			jsr \$26,exit
+			.end main
+EOF
+		LIBC=""
+		$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
+		if test "$?" = 0 ; then
+			case `./$dummy` in
+			0-0)
+				UNAME_MACHINE="alpha"
+				;;
+			1-0)
+				UNAME_MACHINE="alphaev5"
+				;;
+			1-1)
+				UNAME_MACHINE="alphaev56"
+				;;
+			1-101)
+				UNAME_MACHINE="alphapca56"
+				;;
+			2-303)
+				UNAME_MACHINE="alphaev6"
+				;;
+			2-307)
+				UNAME_MACHINE="alphaev67"
+				;;
+			esac
+
+			objdump --private-headers $dummy | \
+			  grep ld.so.1 > /dev/null
+			if test "$?" = 0 ; then
+				LIBC="libc1"
+			fi
+		fi
+		rm -f $dummy.s $dummy
+		echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} ; exit 0
+	elif test "${UNAME_MACHINE}" = "mips" ; then
+	  cat >$dummy.c <<EOF
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv[]) {
+#else
+	int main (argc, argv) int argc; char *argv[]; {
+#endif
+#ifdef __MIPSEB__
+  printf ("%s-unknown-linux-gnu\n", argv[1]);
+#endif
+#ifdef __MIPSEL__
+  printf ("%sel-unknown-linux-gnu\n", argv[1]);
+#endif
+  return 0;
+}
+EOF
+	  $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
+	  rm -f $dummy.c $dummy
+	elif test "${UNAME_MACHINE}" = "s390"; then
+	  echo s390-ibm-linux && exit 0
+	else
+	  # Either a pre-BFD a.out linker (linux-gnuoldld)
+	  # or one that does not give us useful --help.
+	  # GCC wants to distinguish between linux-gnuoldld and linux-gnuaout.
+	  # If ld does not provide *any* "supported emulations:"
+	  # that means it is gnuoldld.
+	  echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations:"
+	  test $? != 0 && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0
+
+	  case "${UNAME_MACHINE}" in
+	  i?86)
+	    VENDOR=pc;
+	    ;;
+	  *)
+	    VENDOR=unknown;
+	    ;;
+	  esac
+	  # Determine whether the default compiler is a.out or elf
+	  cat >$dummy.c <<EOF
+#include <features.h>
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv[]) {
+#else
+	int main (argc, argv) int argc; char *argv[]; {
+#endif
+#ifdef __ELF__
+# ifdef __GLIBC__
+#  if __GLIBC__ >= 2
+    printf ("%s-${VENDOR}-linux-gnu\n", argv[1]);
+#  else
+    printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
+#  endif
+# else
+   printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
+# endif
+#else
+  printf ("%s-${VENDOR}-linux-gnuaout\n", argv[1]);
+#endif
+  return 0;
+}
+EOF
+	  $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
+	  rm -f $dummy.c $dummy
+	fi ;;
+# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
+# are messed up and put the nodename in both sysname and nodename.
+    i?86:DYNIX/ptx:4*:*)
+	echo i386-sequent-sysv4
+	exit 0 ;;
+    i?86:UNIX_SV:4.2MP:2.*)
+        # Unixware is an offshoot of SVR4, but it has its own version
+        # number series starting with 2...
+        # I am not positive that other SVR4 systems won't match this,
+	# I just have to hope.  -- rms.
+        # Use sysv4.2uw... so that sysv4* matches it.
+	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+	exit 0 ;;
+    i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*)
+	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+	else
+		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+	fi
+	exit 0 ;;
+    i?86:*:5:7*)
+        # Fixed at (any) Pentium or better
+        UNAME_MACHINE=i586
+        if [ ${UNAME_SYSTEM} = "UnixWare" ] ; then
+	    echo ${UNAME_MACHINE}-sco-sysv${UNAME_RELEASE}uw${UNAME_VERSION}
+	else
+	    echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
+	fi
+	exit 0 ;;
+    i?86:*:3.2:*)
+	if test -f /usr/options/cb.name; then
+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+	elif /bin/uname -X 2>/dev/null >/dev/null ; then
+		UNAME_REL=`(/bin/uname -X|egrep Release|sed -e 's/.*= //')`
+		(/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486
+		(/bin/uname -X|egrep '^Machine.*Pentium' >/dev/null) \
+			&& UNAME_MACHINE=i586
+		(/bin/uname -X|egrep '^Machine.*Pent ?II' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		(/bin/uname -X|egrep '^Machine.*Pentium Pro' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+	else
+		echo ${UNAME_MACHINE}-pc-sysv32
+	fi
+	exit 0 ;;
+    i?86:*DOS:*:*)
+	echo ${UNAME_MACHINE}-pc-msdosdjgpp
+	exit 0 ;;
+    pc:*:*:*)
+	# Left here for compatibility:
+        # uname -m prints for DJGPP always 'pc', but it prints nothing about
+        # the processor, so we play safe by assuming i386.
+	echo i386-pc-msdosdjgpp
+        exit 0 ;;
+    Intel:Mach:3*:*)
+	echo i386-pc-mach3
+	exit 0 ;;
+    paragon:*:*:*)
+	echo i860-intel-osf1
+	exit 0 ;;
+    i860:*:4.*:*) # i860-SVR4
+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+	else # Add other i860-SVR4 vendors below as they are discovered.
+	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+	fi
+	exit 0 ;;
+    mini*:CTIX:SYS*5:*)
+	# "miniframe"
+	echo m68010-convergent-sysv
+	exit 0 ;;
+    M68*:*:R3V[567]*:*)
+	test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
+    3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
+	OS_REL=''
+	test -r /etc/.relid \
+	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && echo i486-ncr-sysv4.3${OS_REL} && exit 0
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	  && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;;
+    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+        /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+          && echo i486-ncr-sysv4 && exit 0 ;;
+    m68*:LynxOS:2.*:*)
+	echo m68k-unknown-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    mc68030:UNIX_System_V:4.*:*)
+	echo m68k-atari-sysv4
+	exit 0 ;;
+    i?86:LynxOS:2.*:* | i?86:LynxOS:3.[01]*:*)
+	echo i386-unknown-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    TSUNAMI:LynxOS:2.*:*)
+	echo sparc-unknown-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*)
+	echo rs6000-unknown-lynxos${UNAME_RELEASE}
+	exit 0 ;;
+    SM[BE]S:UNIX_SV:*:*)
+	echo mips-dde-sysv${UNAME_RELEASE}
+	exit 0 ;;
+    RM*:ReliantUNIX-*:*:*)
+	echo mips-sni-sysv4
+	exit 0 ;;
+    RM*:SINIX-*:*:*)
+	echo mips-sni-sysv4
+	exit 0 ;;
+    *:SINIX-*:*:*)
+	if uname -p 2>/dev/null >/dev/null ; then
+		UNAME_MACHINE=`(uname -p) 2>/dev/null`
+		echo ${UNAME_MACHINE}-sni-sysv4
+	else
+		echo ns32k-sni-sysv
+	fi
+	exit 0 ;;
+    PENTIUM:CPunix:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+                           # says <Richard.M.Bartel@ccMail.Census.GOV>
+        echo i586-unisys-sysv4
+        exit 0 ;;
+    *:UNIX_System_V:4*:FTX*)
+	# From Gerald Hewes <hewes@openmarket.com>.
+	# How about differentiating between stratus architectures? -djm
+	echo hppa1.1-stratus-sysv4
+	exit 0 ;;
+    *:*:*:FTX*)
+	# From seanf@swdc.stratus.com.
+	echo i860-stratus-sysv4
+	exit 0 ;;
+    mc68*:A/UX:*:*)
+	echo m68k-apple-aux${UNAME_RELEASE}
+	exit 0 ;;
+    news*:NEWS-OS:*:6*)
+	echo mips-sony-newsos6
+	exit 0 ;;
+    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+	if [ -d /usr/nec ]; then
+	        echo mips-nec-sysv${UNAME_RELEASE}
+	else
+	        echo mips-unknown-sysv${UNAME_RELEASE}
+	fi
+        exit 0 ;;
+    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
+	echo powerpc-be-beos
+	exit 0 ;;
+    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
+	echo powerpc-apple-beos
+	exit 0 ;;
+    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
+	echo i586-pc-beos
+	exit 0 ;;
+    SX-4:SUPER-UX:*:*)
+	echo sx4-nec-superux${UNAME_RELEASE}
+	exit 0 ;;
+    SX-5:SUPER-UX:*:*)
+	echo sx5-nec-superux${UNAME_RELEASE}
+	exit 0 ;;
+    Power*:Rhapsody:*:*)
+	echo powerpc-apple-rhapsody${UNAME_RELEASE}
+	exit 0 ;;
+    *:Rhapsody:*:*)
+	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+	exit 0 ;;
+    *:Darwin:*:*)
+	echo `uname -p`-apple-darwin${UNAME_RELEASE}
+	exit 0 ;;
+    *:procnto*:*:* | *:QNX:[0123456789]*:*)
+	if test "${UNAME_MACHINE}" = "x86pc"; then
+		UNAME_MACHINE=pc
+	fi
+	echo `uname -p`-${UNAME_MACHINE}-nto-qnx
+	exit 0 ;;
+    *:QNX:*:4*)
+	echo i386-pc-qnx
+	exit 0 ;;
+    NSR-W:NONSTOP_KERNEL:*:*)
+	echo nsr-tandem-nsk${UNAME_RELEASE}
+	exit 0 ;;
+    BS2000:POSIX*:*:*)
+	echo bs2000-siemens-sysv
+	exit 0 ;;
+    DS/*:UNIX_System_V:*:*)
+	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+	exit 0 ;;
+esac
+
+#echo '(No uname command or uname output not recognized.)' 1>&2
+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
+
+cat >$dummy.c <<EOF
+#ifdef _SEQUENT_
+# include <sys/types.h>
+# include <sys/utsname.h>
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
+     I don't know....  */
+  printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+  printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+          "4"
+#else
+	  ""
+#endif
+         ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+  printf ("arm-acorn-riscix"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+  printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+  int version;
+  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+  if (version < 4)
+    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+  else
+    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+  exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+  printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+  printf ("ns32k-encore-mach\n"); exit (0);
+#else
+  printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+  printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+  printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+  printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+    struct utsname un;
+
+    uname(&un);
+
+    if (strncmp(un.version, "V2", 2) == 0) {
+	printf ("i386-sequent-ptx2\n"); exit (0);
+    }
+    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+	printf ("i386-sequent-ptx1\n"); exit (0);
+    }
+    printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+#if !defined (ultrix)
+  printf ("vax-dec-bsd\n"); exit (0);
+#else
+  printf ("vax-dec-ultrix\n"); exit (0);
+#endif
+#endif
+
+#if defined (alliant) && defined (i860)
+  printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+  exit (1);
+}
+EOF
+
+$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm $dummy.c $dummy && exit 0
+rm -f $dummy.c $dummy
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+    case `getsysinfo -f cpu_type` in
+    c1*)
+	echo c1-convex-bsd
+	exit 0 ;;
+    c2*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+	exit 0 ;;
+    c34*)
+	echo c34-convex-bsd
+	exit 0 ;;
+    c38*)
+	echo c38-convex-bsd
+	exit 0 ;;
+    c4*)
+	echo c4-convex-bsd
+	exit 0 ;;
+    esac
+fi
+
+#echo '(Unable to guess system type)' 1>&2
+
+exit 1
Index: xc/extras/expat/conftools/config.sub
diff -u /dev/null xc/extras/expat/conftools/config.sub:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/config.sub	Mon Feb 18 16:44:18 2002
@@ -0,0 +1,1268 @@
+#! /bin/sh
+# Configuration validation subroutine script, version 1.1.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+#   Free Software Foundation, Inc.
+#
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Written by Per Bothner <bothner@cygnus.com>.
+# Please send patches to <config-patches@gnu.org>.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support.  The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+if [ x$1 = x ]
+then
+	echo Configuration name missing. 1>&2
+	echo "Usage: $0 CPU-MFR-OPSYS" 1>&2
+	echo "or     $0 ALIAS" 1>&2
+	echo where ALIAS is a recognized configuration type. 1>&2
+	exit 1
+fi
+
+# First pass through any local machine types.
+case $1 in
+	*local*)
+		echo $1
+		exit 0
+		;;
+	*)
+	;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+  nto-qnx* | linux-gnu*)
+    os=-$maybe_os
+    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+    ;;
+  *)
+    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+    if [ $basic_machine != $1 ]
+    then os=`echo $1 | sed 's/.*-/-/'`
+    else os=; fi
+    ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work.  We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+	-sun*os*)
+		# Prevent following clause from handling this invalid input.
+		;;
+	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+	-apple)
+		os=
+		basic_machine=$1
+		;;
+	-sim | -cisco | -oki | -wec | -winbond)
+		os=
+		basic_machine=$1
+		;;
+	-scout)
+		;;
+	-wrs)
+		os=-vxworks
+		basic_machine=$1
+		;;
+	-hiux*)
+		os=-hiuxwe2
+		;;
+	-sco5)
+		os=-sco3.2v5
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco4)
+		os=-sco3.2v4
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2.[4-9]*)
+		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco3.2v[4-9]*)
+		# Don't forget version if it is 3.2v4 or newer.
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-sco*)
+		os=-sco3.2v2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-udk*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-isc)
+		os=-isc2.2
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-clix*)
+		basic_machine=clipper-intergraph
+		;;
+	-isc*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+		;;
+	-lynx*)
+		os=-lynxos
+		;;
+	-ptx*)
+		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+		;;
+	-windowsnt*)
+		os=`echo $os | sed -e 's/windowsnt/winnt/'`
+		;;
+	-psos*)
+		os=-psos
+		;;
+	-mint | -mint[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+	# Recognize the basic CPU types without company name.
+	# Some are omitted here because they have special meanings below.
+	tahoe | i860 | ia64 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \
+		| arme[lb] | pyramid | mn10200 | mn10300 | tron | a29k \
+		| 580 | i960 | h8300 \
+		| x86 | ppcbe | mipsbe | mipsle | shbe | shle | armbe | armle \
+		| hppa | hppa1.0 | hppa1.1 | hppa2.0 | hppa2.0w | hppa2.0n \
+		| hppa64 \
+		| alpha | alphaev[4-8] | alphaev56 | alphapca5[67] \
+		| alphaev6[78] \
+		| we32k | ns16k | clipper | i370 | sh | powerpc | powerpcle \
+		| 1750a | dsp16xx | pdp11 | mips16 | mips64 | mipsel | mips64el \
+		| mips64orion | mips64orionel | mipstx39 | mipstx39el \
+		| mips64vr4300 | mips64vr4300el | mips64vr4100 | mips64vr4100el \
+		| mips64vr5000 | miprs64vr5000el | mcore \
+		| sparc | sparclet | sparclite | sparc64 | sparcv9 | v850 | c4x \
+		| thumb | d10v | fr30 | avr)
+		basic_machine=$basic_machine-unknown
+		;;
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | h8500 | w65 | pj | pjl)
+		;;
+
+	# We use `pc' rather than `unknown'
+	# because (1) that's what they normally are, and
+	# (2) the word "unknown" tends to confuse beginning users.
+	i[34567]86)
+	  basic_machine=$basic_machine-pc
+	  ;;
+	# Object if more than one company name word.
+	*-*-*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+	# Recognize the basic CPU types with company name.
+	# FIXME: clean up the formatting here.
+	vax-* | tahoe-* | i[34567]86-* | i860-* | ia64-* | m32r-* | m68k-* | m68000-* \
+	      | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \
+	      | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
+	      | power-* | none-* | 580-* | cray2-* | h8300-* | h8500-* | i960-* \
+	      | xmp-* | ymp-* \
+	      | x86-* | ppcbe-* | mipsbe-* | mipsle-* | shbe-* | shle-* | armbe-* | armle-* \
+	      | hppa-* | hppa1.0-* | hppa1.1-* | hppa2.0-* | hppa2.0w-* \
+	      | hppa2.0n-* | hppa64-* \
+	      | alpha-* | alphaev[4-8]-* | alphaev56-* | alphapca5[67]-* \
+	      | alphaev6[78]-* \
+	      | we32k-* | cydra-* | ns16k-* | pn-* | np1-* | xps100-* \
+	      | clipper-* | orion-* \
+	      | sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
+	      | sparc64-* | sparcv9-* | sparc86x-* | mips16-* | mips64-* | mipsel-* \
+	      | mips64el-* | mips64orion-* | mips64orionel-* \
+	      | mips64vr4100-* | mips64vr4100el-* | mips64vr4300-* | mips64vr4300el-* \
+	      | mipstx39-* | mipstx39el-* | mcore-* \
+	      | f301-* | armv*-* | s390-* | sv1-* | t3e-* \
+	      | m88110-* | m680[01234]0-* | m683?2-* | m68360-* | z8k-* | d10v-* \
+	      | thumb-* | v850-* | d30v-* | tic30-* | c30-* | fr30-* \
+	      | bs2000-*)
+		;;
+	# Recognize the various machine names and aliases which stand
+	# for a CPU type and a company and sometimes even an OS.
+	386bsd)
+		basic_machine=i386-unknown
+		os=-bsd
+		;;
+	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+		basic_machine=m68000-att
+		;;
+	3b*)
+		basic_machine=we32k-att
+		;;
+	a29khif)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	adobe68k)
+		basic_machine=m68010-adobe
+		os=-scout
+		;;
+	alliant | fx80)
+		basic_machine=fx80-alliant
+		;;
+	altos | altos3068)
+		basic_machine=m68k-altos
+		;;
+	am29k)
+		basic_machine=a29k-none
+		os=-bsd
+		;;
+	amdahl)
+		basic_machine=580-amdahl
+		os=-sysv
+		;;
+	amiga | amiga-*)
+		basic_machine=m68k-cbm
+		;;
+	amigaos | amigados)
+		basic_machine=m68k-cbm
+		os=-amigaos
+		;;
+	amigaunix | amix)
+		basic_machine=m68k-cbm
+		os=-sysv4
+		;;
+	apollo68)
+		basic_machine=m68k-apollo
+		os=-sysv
+		;;
+	apollo68bsd)
+		basic_machine=m68k-apollo
+		os=-bsd
+		;;
+	aux)
+		basic_machine=m68k-apple
+		os=-aux
+		;;
+	balance)
+		basic_machine=ns32k-sequent
+		os=-dynix
+		;;
+	convex-c1)
+		basic_machine=c1-convex
+		os=-bsd
+		;;
+	convex-c2)
+		basic_machine=c2-convex
+		os=-bsd
+		;;
+	convex-c32)
+		basic_machine=c32-convex
+		os=-bsd
+		;;
+	convex-c34)
+		basic_machine=c34-convex
+		os=-bsd
+		;;
+	convex-c38)
+		basic_machine=c38-convex
+		os=-bsd
+		;;
+	cray | ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
+	cray2)
+		basic_machine=cray2-cray
+		os=-unicos
+		;;
+	[ctj]90-cray)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
+	crds | unos)
+		basic_machine=m68k-crds
+		;;
+	da30 | da30-*)
+		basic_machine=m68k-da30
+		;;
+	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+		basic_machine=mips-dec
+		;;
+	delta | 3300 | motorola-3300 | motorola-delta \
+	      | 3300-motorola | delta-motorola)
+		basic_machine=m68k-motorola
+		;;
+	delta88)
+		basic_machine=m88k-motorola
+		os=-sysv3
+		;;
+	dpx20 | dpx20-*)
+		basic_machine=rs6000-bull
+		os=-bosx
+		;;
+	dpx2* | dpx2*-bull)
+		basic_machine=m68k-bull
+		os=-sysv3
+		;;
+	ebmon29k)
+		basic_machine=a29k-amd
+		os=-ebmon
+		;;
+	elxsi)
+		basic_machine=elxsi-elxsi
+		os=-bsd
+		;;
+	encore | umax | mmax)
+		basic_machine=ns32k-encore
+		;;
+	es1800 | OSE68k | ose68k | ose | OSE)
+		basic_machine=m68k-ericsson
+		os=-ose
+		;;
+	fx2800)
+		basic_machine=i860-alliant
+		;;
+	genix)
+		basic_machine=ns32k-ns
+		;;
+	gmicro)
+		basic_machine=tron-gmicro
+		os=-sysv
+		;;
+	h3050r* | hiux*)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	h8300hms)
+		basic_machine=h8300-hitachi
+		os=-hms
+		;;
+	h8300xray)
+		basic_machine=h8300-hitachi
+		os=-xray
+		;;
+	h8500hms)
+		basic_machine=h8500-hitachi
+		os=-hms
+		;;
+	harris)
+		basic_machine=m88k-harris
+		os=-sysv3
+		;;
+	hp300-*)
+		basic_machine=m68k-hp
+		;;
+	hp300bsd)
+		basic_machine=m68k-hp
+		os=-bsd
+		;;
+	hp300hpux)
+		basic_machine=m68k-hp
+		os=-hpux
+		;;
+	hp3k9[0-9][0-9] | hp9[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k2[0-9][0-9] | hp9k31[0-9])
+		basic_machine=m68000-hp
+		;;
+	hp9k3[2-9][0-9])
+		basic_machine=m68k-hp
+		;;
+	hp9k6[0-9][0-9] | hp6[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hp9k7[0-79][0-9] | hp7[0-79][0-9])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k78[0-9] | hp78[0-9])
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+		# FIXME: really hppa2.0-hp
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][13679] | hp8[0-9][13679])
+		basic_machine=hppa1.1-hp
+		;;
+	hp9k8[0-9][0-9] | hp8[0-9][0-9])
+		basic_machine=hppa1.0-hp
+		;;
+	hppa-next)
+		os=-nextstep3
+		;;
+	hppaosf)
+		basic_machine=hppa1.1-hp
+		os=-osf
+		;;
+	hppro)
+		basic_machine=hppa1.1-hp
+		os=-proelf
+		;;
+	i370-ibm* | ibm*)
+		basic_machine=i370-ibm
+		;;
+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
+	i[34567]86v32)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv32
+		;;
+	i[34567]86v4*)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv4
+		;;
+	i[34567]86v)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-sysv
+		;;
+	i[34567]86sol2)
+		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+		os=-solaris2
+		;;
+	i386mach)
+		basic_machine=i386-mach
+		os=-mach
+		;;
+	i386-vsta | vsta)
+		basic_machine=i386-unknown
+		os=-vsta
+		;;
+	i386-go32 | go32)
+		basic_machine=i386-unknown
+		os=-go32
+		;;
+	i386-mingw32 | mingw32)
+		basic_machine=i386-unknown
+		os=-mingw32
+		;;
+	iris | iris4d)
+		basic_machine=mips-sgi
+		case $os in
+		    -irix*)
+			;;
+		    *)
+			os=-irix4
+			;;
+		esac
+		;;
+	isi68 | isi)
+		basic_machine=m68k-isi
+		os=-sysv
+		;;
+	m88k-omron*)
+		basic_machine=m88k-omron
+		;;
+	magnum | m3230)
+		basic_machine=mips-mips
+		os=-sysv
+		;;
+	merlin)
+		basic_machine=ns32k-utek
+		os=-sysv
+		;;
+	miniframe)
+		basic_machine=m68000-convergent
+		;;
+	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
+	mipsel*-linux*)
+		basic_machine=mipsel-unknown
+		os=-linux-gnu
+		;;
+	mips*-linux*)
+		basic_machine=mips-unknown
+		os=-linux-gnu
+		;;
+	mips3*-*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+		;;
+	mips3*)
+		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+		;;
+	mmix*)
+		basic_machine=mmix-knuth
+		os=-mmixware
+		;;
+	monitor)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	msdos)
+		basic_machine=i386-unknown
+		os=-msdos
+		;;
+	mvs)
+		basic_machine=i370-ibm
+		os=-mvs
+		;;
+	ncr3000)
+		basic_machine=i486-ncr
+		os=-sysv4
+		;;
+	netbsd386)
+		basic_machine=i386-unknown
+		os=-netbsd
+		;;
+	netwinder)
+		basic_machine=armv4l-rebel
+		os=-linux
+		;;
+	news | news700 | news800 | news900)
+		basic_machine=m68k-sony
+		os=-newsos
+		;;
+	news1000)
+		basic_machine=m68030-sony
+		os=-newsos
+		;;
+	news-3600 | risc-news)
+		basic_machine=mips-sony
+		os=-newsos
+		;;
+	necv70)
+		basic_machine=v70-nec
+		os=-sysv
+		;;
+	next | m*-next )
+		basic_machine=m68k-next
+		case $os in
+		    -nextstep* )
+			;;
+		    -ns2*)
+		      os=-nextstep2
+			;;
+		    *)
+		      os=-nextstep3
+			;;
+		esac
+		;;
+	nh3000)
+		basic_machine=m68k-harris
+		os=-cxux
+		;;
+	nh[45]000)
+		basic_machine=m88k-harris
+		os=-cxux
+		;;
+	nindy960)
+		basic_machine=i960-intel
+		os=-nindy
+		;;
+	mon960)
+		basic_machine=i960-intel
+		os=-mon960
+		;;
+	np1)
+		basic_machine=np1-gould
+		;;
+	nsr-tandem)
+		basic_machine=nsr-tandem
+		;;
+	op50n-* | op60c-*)
+		basic_machine=hppa1.1-oki
+		os=-proelf
+		;;
+	OSE68000 | ose68000)
+		basic_machine=m68000-ericsson
+		os=-ose
+		;;
+	os68k)
+		basic_machine=m68k-none
+		os=-os68k
+		;;
+	pa-hitachi)
+		basic_machine=hppa1.1-hitachi
+		os=-hiuxwe2
+		;;
+	paragon)
+		basic_machine=i860-intel
+		os=-osf
+		;;
+	pbd)
+		basic_machine=sparc-tti
+		;;
+	pbb)
+		basic_machine=m68k-tti
+		;;
+        pc532 | pc532-*)
+		basic_machine=ns32k-pc532
+		;;
+	pentium | p5 | k5 | k6 | nexen)
+		basic_machine=i586-pc
+		;;
+	pentiumpro | p6 | 6x86)
+		basic_machine=i686-pc
+		;;
+	pentiumii | pentium2)
+		basic_machine=i786-pc
+		;;
+	pentium-* | p5-* | k5-* | k6-* | nexen-*)
+		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumpro-* | p6-* | 6x86-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentiumii-* | pentium2-*)
+		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pn)
+		basic_machine=pn-gould
+		;;
+	power)	basic_machine=rs6000-ibm
+		;;
+	ppc)	basic_machine=powerpc-unknown
+	        ;;
+	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppcle | powerpclittle | ppc-le | powerpc-little)
+		basic_machine=powerpcle-unknown
+	        ;;
+	ppcle-* | powerpclittle-*)
+		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ps2)
+		basic_machine=i386-ibm
+		;;
+	rom68k)
+		basic_machine=m68k-rom68k
+		os=-coff
+		;;
+	rm[46]00)
+		basic_machine=mips-siemens
+		;;
+	rtpc | rtpc-*)
+		basic_machine=romp-ibm
+		;;
+	sa29200)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	sequent)
+		basic_machine=i386-sequent
+		;;
+	sh)
+		basic_machine=sh-hitachi
+		os=-hms
+		;;
+	sparclite-wrs)
+		basic_machine=sparclite-wrs
+		os=-vxworks
+		;;
+	sps7)
+		basic_machine=m68k-bull
+		os=-sysv2
+		;;
+	spur)
+		basic_machine=spur-unknown
+		;;
+	st2000)
+		basic_machine=m68k-tandem
+		;;
+	stratus)
+		basic_machine=i860-stratus
+		os=-sysv4
+		;;
+	sun2)
+		basic_machine=m68000-sun
+		;;
+	sun2os3)
+		basic_machine=m68000-sun
+		os=-sunos3
+		;;
+	sun2os4)
+		basic_machine=m68000-sun
+		os=-sunos4
+		;;
+	sun3os3)
+		basic_machine=m68k-sun
+		os=-sunos3
+		;;
+	sun3os4)
+		basic_machine=m68k-sun
+		os=-sunos4
+		;;
+	sun4os3)
+		basic_machine=sparc-sun
+		os=-sunos3
+		;;
+	sun4os4)
+		basic_machine=sparc-sun
+		os=-sunos4
+		;;
+	sun4sol2)
+		basic_machine=sparc-sun
+		os=-solaris2
+		;;
+	sun3 | sun3-*)
+		basic_machine=m68k-sun
+		;;
+	sun4)
+		basic_machine=sparc-sun
+		;;
+	sun386 | sun386i | roadrunner)
+		basic_machine=i386-sun
+		;;
+	sv1)
+		basic_machine=sv1-cray
+		os=-unicos
+		;;
+	symmetry)
+		basic_machine=i386-sequent
+		os=-dynix
+		;;
+	t3e)
+		basic_machine=t3e-cray
+		os=-unicos
+		;;
+	tx39)
+		basic_machine=mipstx39-unknown
+		;;
+	tx39el)
+		basic_machine=mipstx39el-unknown
+		;;
+	tower | tower-32)
+		basic_machine=m68k-ncr
+		;;
+	udi29k)
+		basic_machine=a29k-amd
+		os=-udi
+		;;
+	ultra3)
+		basic_machine=a29k-nyu
+		os=-sym1
+		;;
+	v810 | necv810)
+		basic_machine=v810-nec
+		os=-none
+		;;
+	vaxv)
+		basic_machine=vax-dec
+		os=-sysv
+		;;
+	vms)
+		basic_machine=vax-dec
+		os=-vms
+		;;
+	vpp*|vx|vx-*)
+               basic_machine=f301-fujitsu
+               ;;
+	vxworks960)
+		basic_machine=i960-wrs
+		os=-vxworks
+		;;
+	vxworks68)
+		basic_machine=m68k-wrs
+		os=-vxworks
+		;;
+	vxworks29k)
+		basic_machine=a29k-wrs
+		os=-vxworks
+		;;
+	w65*)
+		basic_machine=w65-wdc
+		os=-none
+		;;
+	w89k-*)
+		basic_machine=hppa1.1-winbond
+		os=-proelf
+		;;
+	xmp)
+		basic_machine=xmp-cray
+		os=-unicos
+		;;
+        xps | xps100)
+		basic_machine=xps100-honeywell
+		;;
+	z8k-*-coff)
+		basic_machine=z8k-unknown
+		os=-sim
+		;;
+	none)
+		basic_machine=none-none
+		os=-none
+		;;
+
+# Here we handle the default manufacturer of certain CPU types.  It is in
+# some cases the only manufacturer, in others, it is the most popular.
+	w89k)
+		basic_machine=hppa1.1-winbond
+		;;
+	op50n)
+		basic_machine=hppa1.1-oki
+		;;
+	op60c)
+		basic_machine=hppa1.1-oki
+		;;
+	mips)
+		if [ x$os = x-linux-gnu ]; then
+			basic_machine=mips-unknown
+		else
+			basic_machine=mips-mips
+		fi
+		;;
+	romp)
+		basic_machine=romp-ibm
+		;;
+	rs6000)
+		basic_machine=rs6000-ibm
+		;;
+	vax)
+		basic_machine=vax-dec
+		;;
+	pdp11)
+		basic_machine=pdp11-dec
+		;;
+	we32k)
+		basic_machine=we32k-att
+		;;
+	sparc | sparcv9)
+		basic_machine=sparc-sun
+		;;
+        cydra)
+		basic_machine=cydra-cydrome
+		;;
+	orion)
+		basic_machine=orion-highlevel
+		;;
+	orion105)
+		basic_machine=clipper-highlevel
+		;;
+	mac | mpw | mac-mpw)
+		basic_machine=m68k-apple
+		;;
+	pmac | pmac-mpw)
+		basic_machine=powerpc-apple
+		;;
+	c4x*)
+		basic_machine=c4x-none
+		os=-coff
+		;;
+	*)
+		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+		exit 1
+		;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+	*-digital*)
+		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+		;;
+	*-commodore*)
+		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+		;;
+	*)
+		;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+        # First match some system type aliases
+        # that might get confused with valid system types.
+	# -solaris* is a basic system type, with this one exception.
+	-solaris1 | -solaris1.*)
+		os=`echo $os | sed -e 's|solaris1|sunos4|'`
+		;;
+	-solaris)
+		os=-solaris2
+		;;
+	-svr4*)
+		os=-sysv4
+		;;
+	-unixware*)
+		os=-sysv4.2uw
+		;;
+	-gnu/linux*)
+		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+		;;
+	# First accept the basic system types.
+	# The portable systems comes first.
+	# Each alternative MUST END IN A *, to match a version number.
+	# -sysv* is not here because it comes later, after sysvr4.
+	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+	      | -aos* \
+	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+	      | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \
+	      | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
+	      | -interix* | -uwin* | -rhapsody* | -darwin* | -opened* \
+	      | -openstep* | -oskit*)
+	# Remember, each alternative MUST END IN *, to match a version number.
+		;;
+	-qnx*)
+		case $basic_machine in
+		    x86-* | i[34567]86-*)
+			;;
+		    *)
+			os=-nto$os
+			;;
+		esac
+		;;
+	-nto*)
+		os=-nto-qnx
+		;;
+	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* \
+	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+		;;
+	-mac*)
+		os=`echo $os | sed -e 's|mac|macos|'`
+		;;
+	-linux*)
+		os=`echo $os | sed -e 's|linux|linux-gnu|'`
+		;;
+	-sunos5*)
+		os=`echo $os | sed -e 's|sunos5|solaris2|'`
+		;;
+	-sunos6*)
+		os=`echo $os | sed -e 's|sunos6|solaris3|'`
+		;;
+	-opened*)
+		os=-openedition
+		;;
+	-wince*)
+		os=-wince
+		;;
+	-osfrose*)
+		os=-osfrose
+		;;
+	-osf*)
+		os=-osf
+		;;
+	-utek*)
+		os=-bsd
+		;;
+	-dynix*)
+		os=-bsd
+		;;
+	-acis*)
+		os=-aos
+		;;
+	-386bsd)
+		os=-bsd
+		;;
+	-ctix* | -uts*)
+		os=-sysv
+		;;
+	-ns2 )
+	        os=-nextstep2
+		;;
+	-nsk)
+		os=-nsk
+		;;
+	# Preserve the version number of sinix5.
+	-sinix5.*)
+		os=`echo $os | sed -e 's|sinix|sysv|'`
+		;;
+	-sinix*)
+		os=-sysv4
+		;;
+	-triton*)
+		os=-sysv3
+		;;
+	-oss*)
+		os=-sysv3
+		;;
+	-svr4)
+		os=-sysv4
+		;;
+	-svr3)
+		os=-sysv3
+		;;
+	-sysvr4)
+		os=-sysv4
+		;;
+	# This must come after -sysvr4.
+	-sysv*)
+		;;
+	-ose*)
+		os=-ose
+		;;
+	-es1800*)
+		os=-ose
+		;;
+	-xenix)
+		os=-xenix
+		;;
+        -*mint | -*MiNT)
+	        os=-mint
+		;;
+	-none)
+		;;
+	*)
+		# Get rid of the `-' at the beginning of $os.
+		os=`echo $os | sed 's/[^-]*-//'`
+		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+		exit 1
+		;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system.  Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+	*-acorn)
+		os=-riscix1.2
+		;;
+	arm*-rebel)
+		os=-linux
+		;;
+	arm*-semi)
+		os=-aout
+		;;
+        pdp11-*)
+		os=-none
+		;;
+	*-dec | vax-*)
+		os=-ultrix4.2
+		;;
+	m68*-apollo)
+		os=-domain
+		;;
+	i386-sun)
+		os=-sunos4.0.2
+		;;
+	m68000-sun)
+		os=-sunos3
+		# This also exists in the configure program, but was not the
+		# default.
+		# os=-sunos4
+		;;
+	m68*-cisco)
+		os=-aout
+		;;
+	mips*-cisco)
+		os=-elf
+		;;
+	mips*-*)
+		os=-elf
+		;;
+	*-tti)	# must be before sparc entry or we get the wrong os.
+		os=-sysv3
+		;;
+	sparc-* | *-sun)
+		os=-sunos4.1.1
+		;;
+	*-be)
+		os=-beos
+		;;
+	*-ibm)
+		os=-aix
+		;;
+	*-wec)
+		os=-proelf
+		;;
+	*-winbond)
+		os=-proelf
+		;;
+	*-oki)
+		os=-proelf
+		;;
+	*-hp)
+		os=-hpux
+		;;
+	*-hitachi)
+		os=-hiux
+		;;
+	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+		os=-sysv
+		;;
+	*-cbm)
+		os=-amigaos
+		;;
+	*-dg)
+		os=-dgux
+		;;
+	*-dolphin)
+		os=-sysv3
+		;;
+	m68k-ccur)
+		os=-rtu
+		;;
+	m88k-omron*)
+		os=-luna
+		;;
+	*-next )
+		os=-nextstep
+		;;
+	*-sequent)
+		os=-ptx
+		;;
+	*-crds)
+		os=-unos
+		;;
+	*-ns)
+		os=-genix
+		;;
+	i370-*)
+		os=-mvs
+		;;
+	*-next)
+		os=-nextstep3
+		;;
+        *-gould)
+		os=-sysv
+		;;
+        *-highlevel)
+		os=-bsd
+		;;
+	*-encore)
+		os=-bsd
+		;;
+        *-sgi)
+		os=-irix
+		;;
+        *-siemens)
+		os=-sysv4
+		;;
+	*-masscomp)
+		os=-rtu
+		;;
+	f301-fujitsu)
+		os=-uxpv
+		;;
+	*-rom68k)
+		os=-coff
+		;;
+	*-*bug)
+		os=-coff
+		;;
+	*-apple)
+		os=-macos
+		;;
+	*-atari*)
+		os=-mint
+		;;
+	*)
+		os=-none
+		;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer.  We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+	*-unknown)
+		case $os in
+			-riscix*)
+				vendor=acorn
+				;;
+			-sunos*)
+				vendor=sun
+				;;
+			-aix*)
+				vendor=ibm
+				;;
+			-beos*)
+				vendor=be
+				;;
+			-hpux*)
+				vendor=hp
+				;;
+			-mpeix*)
+				vendor=hp
+				;;
+			-hiux*)
+				vendor=hitachi
+				;;
+			-unos*)
+				vendor=crds
+				;;
+			-dgux*)
+				vendor=dg
+				;;
+			-luna*)
+				vendor=omron
+				;;
+			-genix*)
+				vendor=ns
+				;;
+			-mvs* | -opened*)
+				vendor=ibm
+				;;
+			-ptx*)
+				vendor=sequent
+				;;
+			-vxsim* | -vxworks*)
+				vendor=wrs
+				;;
+			-aux*)
+				vendor=apple
+				;;
+			-hms*)
+				vendor=hitachi
+				;;
+			-mpw* | -macos*)
+				vendor=apple
+				;;
+			-*mint | -*MiNT)
+				vendor=atari
+				;;
+		esac
+		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+		;;
+esac
+
+echo $basic_machine$os
Index: xc/extras/expat/conftools/install-sh
diff -u /dev/null xc/extras/expat/conftools/install-sh:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/install-sh	Mon Feb 18 16:44:18 2002
@@ -0,0 +1,251 @@
+#!/bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5 (mit/util/scripts/install.sh).
+#
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# 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, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.  It can only install one file at a time, a restriction
+# shared with many OS's install programs.
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+    case $1 in
+	-c) instcmd="$cpprog"
+	    shift
+	    continue;;
+
+	-d) dir_arg=true
+	    shift
+	    continue;;
+
+	-m) chmodcmd="$chmodprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-o) chowncmd="$chownprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-g) chgrpcmd="$chgrpprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-s) stripcmd="$stripprog"
+	    shift
+	    continue;;
+
+	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
+	    shift
+	    continue;;
+
+	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+	    shift
+	    continue;;
+
+	*)  if [ x"$src" = x ]
+	    then
+		src=$1
+	    else
+		# this colon is to work around a 386BSD /bin/sh bug
+		:
+		dst=$1
+	    fi
+	    shift
+	    continue;;
+    esac
+done
+
+if [ x"$src" = x ]
+then
+	echo "install:	no input file specified"
+	exit 1
+else
+	true
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst=$src
+	src=""
+	
+	if [ -d $dst ]; then
+		instcmd=:
+		chmodcmd=""
+	else
+		instcmd=mkdir
+	fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad 
+# if $src (and thus $dsttmp) contains '*'.
+
+	if [ -f $src -o -d $src ]
+	then
+		true
+	else
+		echo "install:  $src does not exist"
+		exit 1
+	fi
+	
+	if [ x"$dst" = x ]
+	then
+		echo "install:	no destination specified"
+		exit 1
+	else
+		true
+	fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+	if [ -d $dst ]
+	then
+		dst="$dst"/`basename $src`
+	else
+		true
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+#  this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='	
+'
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+	pathcomp="${pathcomp}${1}"
+	shift
+
+	if [ ! -d "${pathcomp}" ] ;
+        then
+		$mkdirprog "${pathcomp}"
+	else
+		true
+	fi
+
+	pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+	$doit $instcmd $dst &&
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+	if [ x"$transformarg" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		dstfile=`basename $dst $transformbasename | 
+			sed $transformarg`$transformbasename
+	fi
+
+# don't allow the sed command to completely eliminate the filename
+
+	if [ x"$dstfile" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		true
+	fi
+
+# Make a temp file name in the proper directory.
+
+	dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+	$doit $instcmd $src $dsttmp &&
+
+	trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing.  If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
+
+# Now rename the file to the real destination.
+
+	$doit $rmcmd -f $dstdir/$dstfile &&
+	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+
+fi &&
+
+
+exit 0
Index: xc/extras/expat/conftools/ltconfig
diff -u /dev/null xc/extras/expat/conftools/ltconfig:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/ltconfig	Mon Feb 18 16:44:19 2002
@@ -0,0 +1,3115 @@
+#! /bin/sh
+
+# ltconfig - Create a system-specific libtool.
+# Copyright (C) 1996-1999 Free Software Foundation, Inc.
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# A lot of this script is taken from autoconf-2.10.
+
+# Check that we are running under the correct shell.
+SHELL=${CONFIG_SHELL-/bin/sh}
+echo=echo
+if test "X$1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X$1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell.
+  exec "$SHELL" "$0" --no-reexec ${1+"$@"}
+fi
+
+if test "X$1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<EOF
+$*
+EOF
+  exit 0
+fi
+
+# Find the correct PATH separator.  Usually this is `:', but
+# DJGPP uses `;' like DOS.
+if test "X${PATH_SEPARATOR+set}" != Xset; then
+  UNAME=${UNAME-`uname 2>/dev/null`}
+  case X$UNAME in
+    *-DOS) PATH_SEPARATOR=';' ;;
+    *)     PATH_SEPARATOR=':' ;;
+  esac
+fi
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
+
+if test "X${echo_test_string+set}" != Xset; then
+  # find a string as large as possible, as long as the shell can cope with it
+  for cmd in 'sed 50q "$0"' 'sed 20q "$0"' 'sed 10q "$0"' 'sed 2q "$0"' 'echo test'; do
+    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
+    if (echo_test_string="`eval $cmd`") 2>/dev/null &&
+       echo_test_string="`eval $cmd`" &&
+       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null; then
+      break
+    fi
+  done
+fi
+
+if test "X`($echo '\t') 2>/dev/null`" != 'X\t' ||
+   test "X`($echo "$echo_test_string") 2>/dev/null`" != X"$echo_test_string"; then
+  # The Solaris, AIX, and Digital Unix default echo programs unquote
+  # backslashes.  This makes it impossible to quote backslashes using
+  #   echo "$something" | sed 's/\\/\\\\/g'
+  #
+  # So, first we look for a working echo in the user's PATH.
+
+  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+  for dir in $PATH /usr/ucb; do
+    if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
+       test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
+       test "X`($dir/echo "$echo_test_string") 2>/dev/null`" = X"$echo_test_string"; then
+      echo="$dir/echo"
+      break
+    fi
+  done
+  IFS="$save_ifs"
+
+  if test "X$echo" = Xecho; then
+    # We didn't find a better echo, so look for alternatives.
+    if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
+       test "X`(print -r "$echo_test_string") 2>/dev/null`" = X"$echo_test_string"; then
+      # This shell has a builtin print -r that does the trick.
+      echo='print -r'
+    elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
+	 test "X$CONFIG_SHELL" != X/bin/ksh; then
+      # If we have ksh, try running ltconfig again with it.
+      ORIGINAL_CONFIG_SHELL="${CONFIG_SHELL-/bin/sh}"
+      export ORIGINAL_CONFIG_SHELL
+      CONFIG_SHELL=/bin/ksh
+      export CONFIG_SHELL
+      exec "$CONFIG_SHELL" "$0" --no-reexec ${1+"$@"}
+    else
+      # Try using printf.
+      echo='printf "%s\n"'
+      if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+	 test "X`($echo "$echo_test_string") 2>/dev/null`" = X"$echo_test_string"; then
+	# Cool, printf works
+	:
+      elif test "X`("$ORIGINAL_CONFIG_SHELL" "$0" --fallback-echo '\t') 2>/dev/null`" = 'X\t' &&
+	   test "X`("$ORIGINAL_CONFIG_SHELL" "$0" --fallback-echo "$echo_test_string") 2>/dev/null`" = X"$echo_test_string"; then
+	CONFIG_SHELL="$ORIGINAL_CONFIG_SHELL"
+	export CONFIG_SHELL
+	SHELL="$CONFIG_SHELL"
+	export SHELL
+	echo="$CONFIG_SHELL $0 --fallback-echo"
+      elif test "X`("$CONFIG_SHELL" "$0" --fallback-echo '\t') 2>/dev/null`" = 'X\t' &&
+	   test "X`("$CONFIG_SHELL" "$0" --fallback-echo "$echo_test_string") 2>/dev/null`" = X"$echo_test_string"; then
+	echo="$CONFIG_SHELL $0 --fallback-echo"
+      else
+	# maybe with a smaller string...
+	prev=:
+
+	for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do
+	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null; then
+	    break
+	  fi
+	  prev="$cmd"
+	done
+
+	if test "$prev" != 'sed 50q "$0"'; then
+	  echo_test_string=`eval $prev`
+	  export echo_test_string
+	  exec "${ORIGINAL_CONFIG_SHELL}" "$0" ${1+"$@"}
+	else
+	  # Oops.  We lost completely, so just stick with echo.
+	  echo=echo
+	fi
+      fi
+    fi
+  fi
+fi
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='sed -e s/^X//'
+sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# The name of this program.
+progname=`$echo "X$0" | $Xsed -e 's%^.*/%%'`
+
+# Constants:
+PROGRAM=ltconfig
+PACKAGE=libtool
+VERSION=1.3.5
+TIMESTAMP=" (1.385.2.206 2000/05/27 11:12:27)"
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+rm="rm -f"
+
+help="Try \`$progname --help' for more information."
+
+# Global variables:
+default_ofile=libtool
+can_build_shared=yes
+enable_shared=yes
+# All known linkers require a `.a' archive for static linking (except M$VC,
+# which needs '.lib').
+enable_static=yes
+enable_fast_install=yes
+enable_dlopen=unknown
+enable_win32_dll=no
+ltmain=
+silent=
+srcdir=
+ac_config_guess=
+ac_config_sub=
+host=
+nonopt=
+ofile="$default_ofile"
+verify_host=yes
+with_gcc=no
+with_gnu_ld=no
+need_locks=yes
+ac_ext=c
+objext=o
+libext=a
+exeext=
+cache_file=
+
+old_AR="$AR"
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+old_CPPFLAGS="$CPPFLAGS"
+old_LDFLAGS="$LDFLAGS"
+old_LD="$LD"
+old_LN_S="$LN_S"
+old_LIBS="$LIBS"
+old_NM="$NM"
+old_RANLIB="$RANLIB"
+old_DLLTOOL="$DLLTOOL"
+old_OBJDUMP="$OBJDUMP"
+old_AS="$AS"
+
+# Parse the command line options.
+args=
+prev=
+for option
+do
+  case "$option" in
+  -*=*) optarg=`echo "$option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) optarg= ;;
+  esac
+
+  # If the previous option needs an argument, assign it.
+  if test -n "$prev"; then
+    eval "$prev=\$option"
+    prev=
+    continue
+  fi
+
+  case "$option" in
+  --help) cat <<EOM
+Usage: $progname [OPTION]... [HOST [LTMAIN]]
+
+Generate a system-specific libtool script.
+
+    --debug                enable verbose shell tracing
+    --disable-shared       do not build shared libraries
+    --disable-static       do not build static libraries
+    --disable-fast-install do not optimize for fast installation
+    --enable-dlopen        enable dlopen support
+    --enable-win32-dll     enable building dlls on win32 hosts
+    --help                 display this help and exit
+    --no-verify            do not verify that HOST is a valid host type
+-o, --output=FILE          specify the output file [default=$default_ofile]
+    --quiet                same as \`--silent'
+    --silent               do not print informational messages
+    --srcdir=DIR           find \`config.guess' in DIR
+    --version              output version information and exit
+    --with-gcc             assume that the GNU C compiler will be used
+    --with-gnu-ld          assume that the C compiler uses the GNU linker
+    --disable-lock         disable file locking
+    --cache-file=FILE      configure cache file
+
+LTMAIN is the \`ltmain.sh' shell script fragment or \`ltmain.c' program
+that provides basic libtool functionality.
+
+HOST is the canonical host system name [default=guessed].
+EOM
+  exit 0
+  ;;
+
+  --debug)
+    echo "$progname: enabling shell trace mode"
+    set -x
+    ;;
+
+  --disable-shared) enable_shared=no ;;
+
+  --disable-static) enable_static=no ;;
+
+  --disable-fast-install) enable_fast_install=no ;;
+
+  --enable-dlopen) enable_dlopen=yes ;;
+
+  --enable-win32-dll) enable_win32_dll=yes ;;
+
+  --quiet | --silent) silent=yes ;;
+
+  --srcdir) prev=srcdir ;;
+  --srcdir=*) srcdir="$optarg" ;;
+
+  --no-verify) verify_host=no ;;
+
+  --output | -o) prev=ofile ;;
+  --output=*) ofile="$optarg" ;;
+
+  --version) echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"; exit 0 ;;
+
+  --with-gcc) with_gcc=yes ;;
+  --with-gnu-ld) with_gnu_ld=yes ;;
+
+  --disable-lock) need_locks=no ;;
+
+  --cache-file=*) cache_file="$optarg" ;;
+  --build=*) ;;
+
+  -*)
+    echo "$progname: unrecognized option \`$option'" 1>&2
+    echo "$help" 1>&2
+    exit 1
+    ;;
+
+  *)
+    if test -z "$ltmain"; then
+      ltmain="$option"
+    elif test -z "$host"; then
+# This generates an unnecessary warning for sparc-sun-solaris4.1.3_U1
+#      if test -n "`echo $option| sed 's/[-a-z0-9.]//g'`"; then
+#        echo "$progname: warning \`$option' is not a valid host type" 1>&2
+#      fi
+      host="$option"
+    else
+      echo "$progname: too many arguments" 1>&2
+      echo "$help" 1>&2
+      exit 1
+    fi ;;
+  esac
+done
+
+if test -z "$ltmain"; then
+  echo "$progname: you must specify a LTMAIN file" 1>&2
+  echo "$help" 1>&2
+  exit 1
+fi
+
+if test ! -f "$ltmain"; then
+  echo "$progname: \`$ltmain' does not exist" 1>&2
+  echo "$help" 1>&2
+  exit 1
+fi
+
+# Quote any args containing shell metacharacters.
+ltconfig_args=
+for arg
+do
+  case "$arg" in
+  *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
+  ltconfig_args="$ltconfig_args '$arg'" ;;
+  *) ltconfig_args="$ltconfig_args $arg" ;;
+  esac
+done
+
+# A relevant subset of AC_INIT.
+
+# File descriptor usage:
+# 0 standard input
+# 1 file creation
+# 2 errors and warnings
+# 3 some systems may open it to /dev/tty
+# 4 used on the Kubota Titan
+# 5 compiler messages saved in config.log
+# 6 checking for... messages and results
+if test "$silent" = yes; then
+  exec 6>/dev/null
+else
+  exec 6>&1
+fi
+exec 5>>./config.log
+
+# NLS nuisances.
+# Only set LANG and LC_ALL to C if already set.
+# These must not be set unconditionally because not all systems understand
+# e.g. LANG=C (notably SCO).
+if test "X${LC_ALL+set}" = Xset; then LC_ALL=C; export LC_ALL; fi
+if test "X${LANG+set}"   = Xset; then LANG=C;   export LANG;   fi
+
+if test -n "$cache_file" && test -r "$cache_file"; then
+  echo "loading cache $cache_file within ltconfig"
+  . $cache_file
+fi
+
+if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
+  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
+  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
+    ac_n= ac_c='
+' ac_t='	'
+  else
+    ac_n=-n ac_c= ac_t=
+  fi
+else
+  ac_n= ac_c='\c' ac_t=
+fi
+
+if test -z "$srcdir"; then
+  # Assume the source directory is the same one as the path to LTMAIN.
+  srcdir=`$echo "X$ltmain" | $Xsed -e 's%/[^/]*$%%'`
+  test "$srcdir" = "$ltmain" && srcdir=.
+fi
+
+trap "$rm conftest*; exit 1" 1 2 15
+if test "$verify_host" = yes; then
+  # Check for config.guess and config.sub.
+  ac_aux_dir=
+  for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+    if test -f $ac_dir/config.guess; then
+      ac_aux_dir=$ac_dir
+      break
+    fi
+  done
+  if test -z "$ac_aux_dir"; then
+    echo "$progname: cannot find config.guess in $srcdir $srcdir/.. $srcdir/../.." 1>&2
+    echo "$help" 1>&2
+    exit 1
+  fi
+  ac_config_guess=$ac_aux_dir/config.guess
+  ac_config_sub=$ac_aux_dir/config.sub
+
+  # Make sure we can run config.sub.
+  if $SHELL $ac_config_sub sun4 >/dev/null 2>&1; then :
+  else
+    echo "$progname: cannot run $ac_config_sub" 1>&2
+    echo "$help" 1>&2
+    exit 1
+  fi
+
+  echo $ac_n "checking host system type""... $ac_c" 1>&6
+
+  host_alias=$host
+  case "$host_alias" in
+  "")
+    if host_alias=`$SHELL $ac_config_guess`; then :
+    else
+      echo "$progname: cannot guess host type; you must specify one" 1>&2
+      echo "$help" 1>&2
+      exit 1
+    fi ;;
+  esac
+  host=`$SHELL $ac_config_sub $host_alias`
+  echo "$ac_t$host" 1>&6
+
+  # Make sure the host verified.
+  test -z "$host" && exit 1
+
+elif test -z "$host"; then
+  echo "$progname: you must specify a host type if you use \`--no-verify'" 1>&2
+  echo "$help" 1>&2
+  exit 1
+else
+  host_alias=$host
+fi
+
+# Transform linux* to *-*-linux-gnu*, to support old configure scripts.
+case "$host_os" in
+linux-gnu*) ;;
+linux*) host=`echo $host | sed 's/^\(.*-.*-linux\)\(.*\)$/\1-gnu\2/'`
+esac
+
+host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+case "$host_os" in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test "X${COLLECT_NAMES+set}" != Xset; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR cru $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+# Set a sane default for `AR'.
+test -z "$AR" && AR=ar
+
+# Set a sane default for `OBJDUMP'.
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+# If RANLIB is not set, then run the test.
+if test "${RANLIB+set}" != "set"; then
+  result=no
+
+  echo $ac_n "checking for ranlib... $ac_c" 1>&6
+  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+  for dir in $PATH; do
+    test -z "$dir" && dir=.
+    if test -f $dir/ranlib || test -f $dir/ranlib$ac_exeext; then
+      RANLIB="ranlib"
+      result="ranlib"
+      break
+    fi
+  done
+  IFS="$save_ifs"
+
+  echo "$ac_t$result" 1>&6
+fi
+
+if test -n "$RANLIB"; then
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
+  old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
+fi
+
+# Set sane defaults for `DLLTOOL', `OBJDUMP', and `AS', used on cygwin.
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+test -z "$OBJDUMP" && OBJDUMP=objdump
+test -z "$AS" && AS=as
+
+# Check to see if we are using GCC.
+if test "$with_gcc" != yes || test -z "$CC"; then
+  # If CC is not set, then try to find GCC or a usable CC.
+  if test -z "$CC"; then
+    echo $ac_n "checking for gcc... $ac_c" 1>&6
+    IFS="${IFS= 	}"; save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+    for dir in $PATH; do
+      test -z "$dir" && dir=.
+      if test -f $dir/gcc || test -f $dir/gcc$ac_exeext; then
+	CC="gcc"
+	break
+      fi
+    done
+    IFS="$save_ifs"
+
+    if test -n "$CC"; then
+      echo "$ac_t$CC" 1>&6
+    else
+      echo "$ac_t"no 1>&6
+    fi
+  fi
+
+  # Not "gcc", so try "cc", rejecting "/usr/ucb/cc".
+  if test -z "$CC"; then
+    echo $ac_n "checking for cc... $ac_c" 1>&6
+    IFS="${IFS= 	}"; save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+    cc_rejected=no
+    for dir in $PATH; do
+      test -z "$dir" && dir=.
+      if test -f $dir/cc || test -f $dir/cc$ac_exeext; then
+	if test "$dir/cc" = "/usr/ucb/cc"; then
+	  cc_rejected=yes
+	  continue
+	fi
+	CC="cc"
+	break
+      fi
+    done
+    IFS="$save_ifs"
+    if test $cc_rejected = yes; then
+      # We found a bogon in the path, so make sure we never use it.
+      set dummy $CC
+      shift
+      if test $# -gt 0; then
+	# We chose a different compiler from the bogus one.
+	# However, it has the same name, so the bogon will be chosen
+	# first if we set CC to just the name; use the full file name.
+	shift
+	set dummy "$dir/cc" "$@"
+	shift
+	CC="$@"
+      fi
+    fi
+
+    if test -n "$CC"; then
+      echo "$ac_t$CC" 1>&6
+    else
+      echo "$ac_t"no 1>&6
+    fi
+
+    if test -z "$CC"; then
+      echo "$progname: error: no acceptable cc found in \$PATH" 1>&2
+      exit 1
+    fi
+  fi
+
+  # Now see if the compiler is really GCC.
+  with_gcc=no
+  echo $ac_n "checking whether we are using GNU C... $ac_c" 1>&6
+  echo "$progname:581: checking whether we are using GNU C" >&5
+
+  $rm conftest.c
+  cat > conftest.c <<EOF
+#ifdef __GNUC__
+  yes;
+#endif
+EOF
+  if { ac_try='${CC-cc} -E conftest.c'; { (eval echo $progname:589: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+    with_gcc=yes
+  fi
+  $rm conftest.c
+  echo "$ac_t$with_gcc" 1>&6
+fi
+
+# Allow CC to be a program name with arguments.
+set dummy $CC
+compiler="$2"
+
+echo $ac_n "checking for object suffix... $ac_c" 1>&6
+$rm conftest*
+echo 'int i = 1;' > conftest.c
+echo "$progname:603: checking for object suffix" >& 5
+if { (eval echo $progname:604: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>conftest.err; }; then
+  # Append any warnings to the config.log.
+  cat conftest.err 1>&5
+
+  for ac_file in conftest.*; do
+    case $ac_file in
+    *.c) ;;
+    *) objext=`echo $ac_file | sed -e s/conftest.//` ;;
+    esac
+  done
+else
+  cat conftest.err 1>&5
+  echo "$progname: failed program was:" >&5
+  cat conftest.c >&5
+fi
+$rm conftest*
+echo "$ac_t$objext" 1>&6
+
+echo $ac_n "checking for executable suffix... $ac_c" 1>&6
+if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  ac_cv_exeext="no"
+  $rm conftest*
+  echo 'main () { return 0; }' > conftest.c
+  echo "$progname:629: checking for executable suffix" >& 5
+  if { (eval echo $progname:630: \"$ac_link\") 1>&5; (eval $ac_link) 2>conftest.err; }; then
+    # Append any warnings to the config.log.
+    cat conftest.err 1>&5
+
+    for ac_file in conftest.*; do
+      case $ac_file in
+      *.c | *.err | *.$objext ) ;;
+      *) ac_cv_exeext=.`echo $ac_file | sed -e s/conftest.//` ;;
+      esac
+    done
+  else
+    cat conftest.err 1>&5
+    echo "$progname: failed program was:" >&5
+    cat conftest.c >&5
+  fi
+  $rm conftest*
+fi
+if test "X$ac_cv_exeext" = Xno; then
+  exeext=""
+else
+  exeext="$ac_cv_exeext"
+fi
+echo "$ac_t$ac_cv_exeext" 1>&6
+
+echo $ac_n "checking for $compiler option to produce PIC... $ac_c" 1>&6
+pic_flag=
+special_shlib_compile_flags=
+wl=
+link_static_flag=
+no_builtin_flag=
+
+if test "$with_gcc" = yes; then
+  wl='-Wl,'
+  link_static_flag='-static'
+
+  case "$host_os" in
+  beos* | irix5* | irix6* | osf3* | osf4* | osf5*)
+    # PIC is the default for these OSes.
+    ;;
+  aix*)
+    # Below there is a dirty hack to force normal static linking with -ldl
+    # The problem is because libdl dynamically linked with both libc and
+    # libC (AIX C++ library), which obviously doesn't included in libraries
+    # list by gcc. This cause undefined symbols with -static flags.
+    # This hack allows C programs to be linked with "-static -ldl", but
+    # we not sure about C++ programs.
+    link_static_flag="$link_static_flag ${wl}-lC"
+    ;;
+  cygwin* | mingw* | os2*)
+    # We can build DLLs from non-PIC.
+    ;;
+  amigaos*)
+    # FIXME: we need at least 68020 code to build shared libraries, but
+    # adding the `-m68020' flag to GCC prevents building anything better,
+    # like `-m68040'.
+    pic_flag='-m68020 -resident32 -malways-restore-a4'
+    ;;
+  sysv4*MP*)
+    if test -d /usr/nec; then
+       pic_flag=-Kconform_pic
+    fi
+    ;;
+  *)
+    pic_flag='-fPIC'
+    ;;
+  esac
+else
+  # PORTME Check for PIC flags for the system compiler.
+  case "$host_os" in
+  aix3* | aix4*)
+    # All AIX code is PIC.
+    link_static_flag='-bnso -bI:/lib/syscalls.exp'
+    ;;
+
+  hpux9* | hpux10* | hpux11*)
+    # Is there a better link_static_flag that works with the bundled CC?
+    wl='-Wl,'
+    link_static_flag="${wl}-a ${wl}archive"
+    pic_flag='+Z'
+    ;;
+
+  irix5* | irix6*)
+    wl='-Wl,'
+    link_static_flag='-non_shared'
+    # PIC (with -KPIC) is the default.
+    ;;
+
+  cygwin* | mingw* | os2*)
+    # We can build DLLs from non-PIC.
+    ;;
+
+  osf3* | osf4* | osf5*)
+    # All OSF/1 code is PIC.
+    wl='-Wl,'
+    link_static_flag='-non_shared'
+    ;;
+
+  sco3.2v5*)
+    pic_flag='-Kpic'
+    link_static_flag='-dn'
+    special_shlib_compile_flags='-belf'
+    ;;
+
+  solaris*)
+    pic_flag='-KPIC'
+    link_static_flag='-Bstatic'
+    wl='-Wl,'
+    ;;
+
+  sunos4*)
+    pic_flag='-PIC'
+    link_static_flag='-Bstatic'
+    wl='-Qoption ld '
+    ;;
+
+  sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+    pic_flag='-KPIC'
+    link_static_flag='-Bstatic'
+    wl='-Wl,'
+    ;;
+
+  uts4*)
+    pic_flag='-pic'
+    link_static_flag='-Bstatic'
+    ;;
+  sysv4*MP*)
+    if test -d /usr/nec ;then
+      pic_flag='-Kconform_pic'
+      link_static_flag='-Bstatic'
+    fi
+    ;;
+  *)
+    can_build_shared=no
+    ;;
+  esac
+fi
+
+if test -n "$pic_flag"; then
+  echo "$ac_t$pic_flag" 1>&6
+
+  # Check to make sure the pic_flag actually works.
+  echo $ac_n "checking if $compiler PIC flag $pic_flag works... $ac_c" 1>&6
+  $rm conftest*
+  echo "int some_variable = 0;" > conftest.c
+  save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS $pic_flag -DPIC"
+  echo "$progname:776: checking if $compiler PIC flag $pic_flag works" >&5
+  if { (eval echo $progname:777: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>conftest.err; } && test -s conftest.$objext; then
+    # Append any warnings to the config.log.
+    cat conftest.err 1>&5
+    
+    case "$host_os" in
+    hpux9* | hpux10* | hpux11*)
+      # On HP-UX, both CC and GCC only warn that PIC is supported... then they
+      # create non-PIC objects.  So, if there were any warnings, we assume that
+      # PIC is not supported.
+      if test -s conftest.err; then
+	echo "$ac_t"no 1>&6
+	can_build_shared=no
+	pic_flag=
+      else
+	echo "$ac_t"yes 1>&6
+	pic_flag=" $pic_flag"
+      fi
+      ;;
+    *)
+      echo "$ac_t"yes 1>&6
+      pic_flag=" $pic_flag"
+      ;;
+    esac
+  else
+    # Append any errors to the config.log.
+    cat conftest.err 1>&5
+    can_build_shared=no
+    pic_flag=
+    echo "$ac_t"no 1>&6
+  fi
+  CFLAGS="$save_CFLAGS"
+  $rm conftest*
+else
+  echo "$ac_t"none 1>&6
+fi
+
+# Check to see if options -o and -c are simultaneously supported by compiler
+echo $ac_n "checking if $compiler supports -c -o file.o... $ac_c" 1>&6
+$rm -r conftest 2>/dev/null
+mkdir conftest
+cd conftest
+$rm conftest*
+echo "int some_variable = 0;" > conftest.c
+mkdir out
+# According to Tom Tromey, Ian Lance Taylor reported there are C compilers
+# that will create temporary files in the current directory regardless of
+# the output directory.  Thus, making CWD read-only will cause this test
+# to fail, enabling locking or at least warning the user not to do parallel
+# builds.
+chmod -w .
+save_CFLAGS="$CFLAGS"
+CFLAGS="$CFLAGS -o out/conftest2.o"
+echo "$progname:829: checking if $compiler supports -c -o file.o" >&5
+if { (eval echo $progname:830: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.o; then
+
+  # The compiler can only warn and ignore the option if not recognized
+  # So say no if there are warnings
+    if test -s out/conftest.err; then
+      echo "$ac_t"no 1>&6
+      compiler_c_o=no
+    else
+      echo "$ac_t"yes 1>&6
+      compiler_c_o=yes
+    fi
+else
+  # Append any errors to the config.log.
+  cat out/conftest.err 1>&5
+  compiler_c_o=no
+  echo "$ac_t"no 1>&6
+fi
+CFLAGS="$save_CFLAGS"
+chmod u+w .
+$rm conftest* out/*
+rmdir out
+cd ..
+rmdir conftest
+$rm -r conftest 2>/dev/null
+
+if test x"$compiler_c_o" = x"yes"; then
+  # Check to see if we can write to a .lo
+  echo $ac_n "checking if $compiler supports -c -o file.lo... $ac_c" 1>&6
+  $rm conftest*
+  echo "int some_variable = 0;" > conftest.c
+  save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -c -o conftest.lo"
+  echo "$progname:862: checking if $compiler supports -c -o file.lo" >&5
+if { (eval echo $progname:863: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>conftest.err; } && test -s conftest.lo; then
+
+    # The compiler can only warn and ignore the option if not recognized
+    # So say no if there are warnings
+      if test -s conftest.err; then
+	echo "$ac_t"no 1>&6
+	compiler_o_lo=no
+      else
+	echo "$ac_t"yes 1>&6
+	compiler_o_lo=yes
+      fi
+  else
+    # Append any errors to the config.log.
+    cat conftest.err 1>&5
+    compiler_o_lo=no
+    echo "$ac_t"no 1>&6
+  fi
+  CFLAGS="$save_CFLAGS"
+  $rm conftest*
+else
+  compiler_o_lo=no
+fi
+
+# Check to see if we can do hard links to lock some files if needed
+hard_links="nottested"
+if test "$compiler_c_o" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  echo $ac_n "checking if we can lock with hard links... $ac_c" 1>&6
+  hard_links=yes
+  $rm conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  echo "$ac_t$hard_links" 1>&6
+  $rm conftest*
+  if test "$hard_links" = no; then
+    echo "*** WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+if test "$with_gcc" = yes; then
+  # Check to see if options -fno-rtti -fno-exceptions are supported by compiler
+  echo $ac_n "checking if $compiler supports -fno-rtti -fno-exceptions ... $ac_c" 1>&6
+  $rm conftest*
+  echo "int some_variable = 0;" > conftest.c
+  save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -c conftest.c"
+  echo "$progname:914: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+  if { (eval echo $progname:915: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>conftest.err; } && test -s conftest.o; then
+
+    # The compiler can only warn and ignore the option if not recognized
+    # So say no if there are warnings
+      if test -s conftest.err; then
+	echo "$ac_t"no 1>&6
+	compiler_rtti_exceptions=no
+      else
+	echo "$ac_t"yes 1>&6
+	compiler_rtti_exceptions=yes
+      fi
+  else
+    # Append any errors to the config.log.
+    cat conftest.err 1>&5
+    compiler_rtti_exceptions=no
+    echo "$ac_t"no 1>&6
+  fi
+  CFLAGS="$save_CFLAGS"
+  $rm conftest*
+
+  if test "$compiler_rtti_exceptions" = "yes"; then
+    no_builtin_flag=' -fno-builtin -fno-rtti -fno-exceptions'
+  else
+    no_builtin_flag=' -fno-builtin'
+  fi
+  
+fi
+
+# Check for any special shared library compilation flags.
+if test -n "$special_shlib_compile_flags"; then
+  echo "$progname: warning: \`$CC' requires \`$special_shlib_compile_flags' to build shared libraries" 1>&2
+  if echo "$old_CC $old_CFLAGS " | egrep -e "[ 	]$special_shlib_compile_flags[ 	]" >/dev/null; then :
+  else
+    echo "$progname: add \`$special_shlib_compile_flags' to the CC or CFLAGS env variable and reconfigure" 1>&2
+    can_build_shared=no
+  fi
+fi
+
+echo $ac_n "checking if $compiler static flag $link_static_flag works... $ac_c" 1>&6
+$rm conftest*
+echo 'main(){return(0);}' > conftest.c
+save_LDFLAGS="$LDFLAGS"
+LDFLAGS="$LDFLAGS $link_static_flag"
+echo "$progname:958: checking if $compiler static flag $link_static_flag works" >&5
+if { (eval echo $progname:959: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+  echo "$ac_t$link_static_flag" 1>&6
+else
+  echo "$ac_t"none 1>&6
+  link_static_flag=
+fi
+LDFLAGS="$save_LDFLAGS"
+$rm conftest*
+
+if test -z "$LN_S"; then
+  # Check to see if we can use ln -s, or we need hard links.
+  echo $ac_n "checking whether ln -s works... $ac_c" 1>&6
+  $rm conftest.dat
+  if ln -s X conftest.dat 2>/dev/null; then
+    $rm conftest.dat
+    LN_S="ln -s"
+  else
+    LN_S=ln
+  fi
+  if test "$LN_S" = "ln -s"; then
+    echo "$ac_t"yes 1>&6
+  else
+    echo "$ac_t"no 1>&6
+  fi
+fi
+
+# Make sure LD is an absolute path.
+if test -z "$LD"; then
+  ac_prog=ld
+  if test "$with_gcc" = yes; then
+    # Check if gcc -print-prog-name=ld gives a path.
+    echo $ac_n "checking for ld used by GCC... $ac_c" 1>&6
+    echo "$progname:991: checking for ld used by GCC" >&5
+    ac_prog=`($CC -print-prog-name=ld) 2>&5`
+    case "$ac_prog" in
+    # Accept absolute paths.
+    [\\/]* | [A-Za-z]:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the path of ld
+      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+    "")
+      # If it fails, then pretend we are not using GCC.
+      ac_prog=ld
+      ;;
+    *)
+      # If it is relative, then search for the first ld in PATH.
+      with_gnu_ld=unknown
+      ;;
+    esac
+  elif test "$with_gnu_ld" = yes; then
+    echo $ac_n "checking for GNU ld... $ac_c" 1>&6
+    echo "$progname:1015: checking for GNU ld" >&5
+  else
+    echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
+    echo "$progname:1018: checking for non-GNU ld" >&5
+  fi
+
+  if test -z "$LD"; then
+    IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+    for ac_dir in $PATH; do
+      test -z "$ac_dir" && ac_dir=.
+      if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+	LD="$ac_dir/$ac_prog"
+	# Check to see if the program is GNU ld.  I'd rather use --version,
+	# but apparently some GNU ld's only accept -v.
+	# Break only if it was the GNU/non-GNU ld that we prefer.
+	if "$LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
+	  test "$with_gnu_ld" != no && break
+	else
+	  test "$with_gnu_ld" != yes && break
+	fi
+      fi
+    done
+    IFS="$ac_save_ifs"
+  fi
+
+  if test -n "$LD"; then
+    echo "$ac_t$LD" 1>&6
+  else
+    echo "$ac_t"no 1>&6
+  fi
+
+  if test -z "$LD"; then
+    echo "$progname: error: no acceptable ld found in \$PATH" 1>&2
+    exit 1
+  fi
+fi
+
+# Check to see if it really is or is not GNU ld.
+echo $ac_n "checking if the linker ($LD) is GNU ld... $ac_c" 1>&6
+# I'd rather use --version here, but apparently some GNU ld's only accept -v.
+if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
+  with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi
+echo "$ac_t$with_gnu_ld" 1>&6
+
+# See if the linker supports building shared libraries.
+echo $ac_n "checking whether the linker ($LD) supports shared libraries... $ac_c" 1>&6
+
+allow_undefined_flag=
+no_undefined_flag=
+need_lib_prefix=unknown
+need_version=unknown
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+archive_cmds=
+archive_expsym_cmds=
+old_archive_from_new_cmds=
+export_dynamic_flag_spec=
+whole_archive_flag_spec=
+thread_safe_flag_spec=
+hardcode_libdir_flag_spec=
+hardcode_libdir_separator=
+hardcode_direct=no
+hardcode_minus_L=no
+hardcode_shlibpath_var=unsupported
+runpath_var=
+always_export_symbols=no
+export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | sed '\''s/.* //'\'' | sort | uniq > $export_symbols'
+# include_expsyms should be a list of space-separated symbols to be *always*
+# included in the symbol list
+include_expsyms=
+# exclude_expsyms can be an egrep regular expression of symbols to exclude
+# it will be wrapped by ` (' and `)$', so one must not match beginning or
+# end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+# as well as any symbol that contains `d'.
+exclude_expsyms="_GLOBAL_OFFSET_TABLE_"
+# Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+# platforms (ab)use it in PIC code, but their linkers get confused if
+# the symbol is explicitly referenced.  Since portable code cannot
+# rely on this symbol name, it's probably fine to never include it in
+# preloaded symbol tables.
+
+case "$host_os" in
+cygwin* | mingw*)
+  # FIXME: the MSVC++ port hasn't been tested in a loooong time
+  # When not using gcc, we currently assume that we are using
+  # Microsoft Visual C++.
+  if test "$with_gcc" != yes; then
+    with_gnu_ld=no
+  fi
+  ;;
+
+esac
+
+ld_shlibs=yes
+if test "$with_gnu_ld" = yes; then
+  # If archive_cmds runs LD, not CC, wlarc should be empty
+  wlarc='${wl}'
+
+  # See if GNU ld supports shared libraries.
+  case "$host_os" in
+  aix3* | aix4*)
+    # On AIX, the GNU linker is very broken
+    ld_shlibs=no
+    cat <<EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.9.1, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to modify your PATH
+*** so that a non-GNU linker is found, and then restart.
+
+EOF
+    ;;
+
+  amigaos*)
+    archive_cmds='$rm $objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $objdir/a2ixlibrary.data~$AR cru $lib $libobjs~$RANLIB $lib~(cd $objdir && a2ixlibrary -32)'
+    hardcode_libdir_flag_spec='-L$libdir'
+    hardcode_minus_L=yes
+
+    # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
+    # that the semantics of dynamic libraries on AmigaOS, at least up
+    # to version 4, is to share data among multiple programs linked
+    # with the same dynamic library.  Since this doesn't match the
+    # behavior of shared libraries on other platforms, we can use
+    # them.
+    ld_shlibs=no
+    ;;
+
+  beos*)
+    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      allow_undefined_flag=unsupported
+      # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+      # support --undefined.  This deserves some investigation.  FIXME
+      archive_cmds='$CC -nostart $libobjs $deplibs $linkopts ${wl}-soname $wl$soname -o $lib'
+    else
+      ld_shlibs=no
+    fi
+    ;;
+
+  cygwin* | mingw*)
+    # hardcode_libdir_flag_spec is actually meaningless, as there is
+    # no search path for DLLs.
+    hardcode_libdir_flag_spec='-L$libdir'
+    allow_undefined_flag=unsupported
+    always_export_symbols=yes
+
+    # Extract the symbol export list from an `--export-all' def file,
+    # then regenerate the def file from the symbol export list, so that
+    # the compiled dll only exports the symbol export list.
+    # Be careful not to strip the DATA tag left by newer dlltools.
+    export_symbols_cmds='test -f $objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < $0 > $objdir/$soname-ltdll.c~
+      test -f $objdir/$soname-ltdll.$objext || (cd $objdir && $CC -c $soname-ltdll.c)~
+      $DLLTOOL --export-all --exclude-symbols DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12 --output-def $objdir/$soname-def  $objdir/$soname-ltdll.$objext $libobjs $convenience~
+      sed -e "1,/EXPORTS/d" -e "s/ @ [0-9]*//" -e "s/ *;.*$//" < $objdir/$soname-def > $export_symbols'
+
+    # If DATA tags from a recent dlltool are present, honour them!
+    archive_expsym_cmds='echo EXPORTS > $objdir/$soname-def~
+      _lt_hint=1;
+      cat $export_symbols | while read symbol; do
+        set dummy \$symbol;
+        case \$# in
+          2) echo "	\$2 @ \$_lt_hint ; " >> $objdir/$soname-def;;
+          *) echo "     \$2 @ \$_lt_hint \$3 ; " >> $objdir/$soname-def;;
+        esac;
+	_lt_hint=`expr 1 + \$_lt_hint`;
+      done~
+      test -f $objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < $0 > $objdir/$soname-ltdll.c~
+      test -f $objdir/$soname-ltdll.$objext || (cd $objdir && $CC -c $soname-ltdll.c)~
+      $CC -Wl,--base-file,$objdir/$soname-base -Wl,--dll -nostartfiles -Wl,-e,__cygwin_dll_entry@12 -o $lib $objdir/$soname-ltdll.$objext $libobjs $deplibs $linkopts~
+      $DLLTOOL --as=$AS --dllname $soname --exclude-symbols DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12 --def $objdir/$soname-def --base-file $objdir/$soname-base --output-exp $objdir/$soname-exp~
+      $CC -Wl,--base-file,$objdir/$soname-base $objdir/$soname-exp -Wl,--dll -nostartfiles -Wl,-e,__cygwin_dll_entry@12 -o $lib $objdir/$soname-ltdll.$objext $libobjs $deplibs $linkopts~
+      $DLLTOOL --as=$AS --dllname $soname --exclude-symbols DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12 --def $objdir/$soname-def --base-file $objdir/$soname-base --output-exp $objdir/$soname-exp~
+      $CC $objdir/$soname-exp -Wl,--dll -nostartfiles -Wl,-e,__cygwin_dll_entry@12 -o $lib $objdir/$soname-ltdll.$objext $libobjs $deplibs $linkopts'
+
+      old_archive_from_new_cmds='$DLLTOOL --as=$AS --dllname $soname --def $objdir/$soname-def --output-lib $objdir/$libname.a' 
+    ;;
+
+  netbsd*)
+    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $linkopts ${wl}-soname $wl$soname -o $lib'
+      archive_expsym_cmds='$CC -shared $libobjs $deplibs $linkopts ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+    else
+      archive_cmds='$LD -Bshareable $libobjs $deplibs $linkopts -o $lib'
+      # can we support soname and/or expsyms with a.out? -oliva
+    fi
+    ;;
+
+  solaris* | sysv5*)
+    if $LD -v 2>&1 | egrep 'BFD 2\.8' > /dev/null; then
+      ld_shlibs=no
+      cat <<EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+EOF
+    elif $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $linkopts ${wl}-soname $wl$soname -o $lib'
+      archive_expsym_cmds='$CC -shared $libobjs $deplibs $linkopts ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+    else
+      ld_shlibs=no
+    fi
+    ;;      
+
+  sunos4*)
+    archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linkopts'
+    wlarc=
+    hardcode_direct=yes
+    hardcode_shlibpath_var=no
+    ;;
+
+  *)
+    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
+      archive_cmds='$CC -shared $libobjs $deplibs $linkopts ${wl}-soname $wl$soname -o $lib'
+      archive_expsym_cmds='$CC -shared $libobjs $deplibs $linkopts ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+    else
+      ld_shlibs=no
+    fi
+    ;;
+  esac
+
+  if test "$ld_shlibs" = yes; then
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir'
+    export_dynamic_flag_spec='${wl}--export-dynamic'
+    case $host_os in
+    cygwin* | mingw*)
+      # dlltool doesn't understand --whole-archive et. al.
+      whole_archive_flag_spec=
+      ;;
+    *)
+      # ancient GNU ld didn't support --whole-archive et. al.
+      if $LD --help 2>&1 | egrep 'no-whole-archive' > /dev/null; then
+        whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      else
+        whole_archive_flag_spec=
+      fi
+      ;;
+    esac
+  fi
+else
+  # PORTME fill in a description of your system's linker (not GNU ld)
+  case "$host_os" in
+  aix3*)
+    allow_undefined_flag=unsupported
+    always_export_symbols=yes
+    archive_expsym_cmds='$LD -o $objdir/$soname $libobjs $deplibs $linkopts -bE:$export_symbols -T512 -H512 -bM:SRE~$AR cru $lib $objdir/$soname'
+    # Note: this linker hardcodes the directories in LIBPATH if there
+    # are no directories specified by -L.
+    hardcode_minus_L=yes
+    if test "$with_gcc" = yes && test -z "$link_static_flag"; then
+      # Neither direct hardcoding nor static linking is supported with a
+      # broken collect2.
+      hardcode_direct=unsupported
+    fi
+    ;;
+
+  aix4*)
+    hardcode_libdir_flag_spec='${wl}-b ${wl}nolibpath ${wl}-b ${wl}libpath:$libdir:/usr/lib:/lib'
+    hardcode_libdir_separator=':'
+    if test "$with_gcc" = yes; then
+      collect2name=`${CC} -print-prog-name=collect2`
+      if test -f "$collect2name" && \
+	 strings "$collect2name" | grep resolve_lib_name >/dev/null
+      then
+	# We have reworked collect2
+	hardcode_direct=yes
+      else
+	# We have old collect2
+	hardcode_direct=unsupported
+	# It fails to find uninstalled libraries when the uninstalled
+	# path is not listed in the libpath.  Setting hardcode_minus_L
+	# to unsupported forces relinking
+	hardcode_minus_L=yes
+	hardcode_libdir_flag_spec='-L$libdir'
+	hardcode_libdir_separator=
+      fi
+      shared_flag='-shared'
+    else
+      shared_flag='${wl}-bM:SRE'
+      hardcode_direct=yes
+    fi
+    allow_undefined_flag=' ${wl}-berok'
+    archive_cmds="\$CC $shared_flag"' -o $objdir/$soname $libobjs $deplibs $linkopts ${wl}-bexpall ${wl}-bnoentry${allow_undefined_flag}'
+    archive_expsym_cmds="\$CC $shared_flag"' -o $objdir/$soname $libobjs $deplibs $linkopts ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}'
+    case "$host_os" in aix4.[01]|aix4.[01].*)
+      # According to Greg Wooledge, -bexpall is only supported from AIX 4.2 on
+      always_export_symbols=yes ;;
+    esac
+   ;;
+
+  amigaos*)
+    archive_cmds='$rm $objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $objdir/a2ixlibrary.data~$AR cru $lib $libobjs~$RANLIB $lib~(cd $objdir && a2ixlibrary -32)'
+    hardcode_libdir_flag_spec='-L$libdir'
+    hardcode_minus_L=yes
+    # see comment about different semantics on the GNU ld section
+    ld_shlibs=no
+    ;;
+
+  cygwin* | mingw*)
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    # hardcode_libdir_flag_spec is actually meaningless, as there is
+    # no search path for DLLs.
+    hardcode_libdir_flag_spec=' '
+    allow_undefined_flag=unsupported
+    # Tell ltmain to make .lib files, not .a files.
+    libext=lib
+    # FIXME: Setting linknames here is a bad hack.
+    archive_cmds='$CC -o $lib $libobjs $linkopts `echo "$deplibs" | sed -e '\''s/ -lc$//'\''` -link -dll~linknames='
+    # The linker will automatically build a .lib file if we build a DLL.
+    old_archive_from_new_cmds='true'
+    # FIXME: Should let the user specify the lib program.
+    old_archive_cmds='lib /OUT:$oldlib$oldobjs'
+    fix_srcfile_path='`cygpath -w $srcfile`'
+    ;;
+
+  freebsd1*)
+    ld_shlibs=no
+    ;;
+
+  # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+  # support.  Future versions do this automatically, but an explicit c++rt0.o
+  # does not break anything, and helps significantly (at the cost of a little
+  # extra space).
+  freebsd2.2*)
+    archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linkopts /usr/lib/c++rt0.o'
+    hardcode_libdir_flag_spec='-R$libdir'
+    hardcode_direct=yes
+    hardcode_shlibpath_var=no
+    ;;
+
+  # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+  freebsd2*)
+    archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linkopts'
+    hardcode_direct=yes
+    hardcode_minus_L=yes
+    hardcode_shlibpath_var=no
+    ;;
+
+  # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+  freebsd*)
+    archive_cmds='$CC -shared -o $lib $libobjs $deplibs $linkopts'
+    hardcode_libdir_flag_spec='-R$libdir'
+    hardcode_direct=yes
+    hardcode_shlibpath_var=no
+    ;;
+
+  hpux9* | hpux10* | hpux11*)
+    case "$host_os" in
+    hpux9*) archive_cmds='$rm $objdir/$soname~$LD -b +b $install_libdir -o $objdir/$soname $libobjs $deplibs $linkopts~test $objdir/$soname = $lib || mv $objdir/$soname $lib' ;;
+    *) archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linkopts' ;;
+    esac
+    hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+    hardcode_libdir_separator=:
+    hardcode_direct=yes
+    hardcode_minus_L=yes # Not in the search PATH, but as the default
+			 # location of the library.
+    export_dynamic_flag_spec='${wl}-E'
+    ;;
+
+  irix5* | irix6*)
+    if test "$with_gcc" = yes; then
+      archive_cmds='$CC -shared $libobjs $deplibs $linkopts ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
+    else
+      archive_cmds='$LD -shared $libobjs $deplibs $linkopts -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
+    fi
+    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+    hardcode_libdir_separator=:
+    ;;
+
+  netbsd*)
+    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linkopts'  # a.out
+    else
+      archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linkopts'      # ELF
+    fi
+    hardcode_libdir_flag_spec='${wl}-R$libdir'
+    hardcode_direct=yes
+    hardcode_shlibpath_var=no
+    ;;
+
+  openbsd*)
+    archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linkopts'
+    hardcode_libdir_flag_spec='-R$libdir'
+    hardcode_direct=yes
+    hardcode_shlibpath_var=no
+    ;;
+
+  os2*)
+    hardcode_libdir_flag_spec='-L$libdir'
+    hardcode_minus_L=yes
+    allow_undefined_flag=unsupported
+    archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $objdir/$libname.def~$echo DATA >> $objdir/$libname.def~$echo " SINGLE NONSHARED" >> $objdir/$libname.def~$echo EXPORTS >> $objdir/$libname.def~emxexp $libobjs >> $objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $linkopts $objdir/$libname.def'
+    old_archive_from_new_cmds='emximp -o $objdir/$libname.a $objdir/$libname.def'
+    ;;
+
+  osf3*)
+    if test "$with_gcc" = yes; then
+      allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+      archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $linkopts ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
+    else
+      allow_undefined_flag=' -expect_unresolved \*'
+      archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linkopts -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
+    fi
+    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+    hardcode_libdir_separator=:
+    ;;
+
+  osf4* | osf5*)  # As osf3* with the addition of the -msym flag
+    if test "$with_gcc" = yes; then
+      allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+      archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $linkopts ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
+    else
+      allow_undefined_flag=' -expect_unresolved \*'
+      archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linkopts -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
+    fi
+    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+    hardcode_libdir_separator=:
+    ;;
+  rhapsody*)
+    archive_cmds='$CC -bundle -undefined suppress -o $lib $libobjs $deplibs $linkopts'
+    hardcode_libdir_flags_spec='-L$libdir'
+    hardcode_direct=yes
+    hardcode_shlibpath_var=no
+    ;;
+                                       
+  sco3.2v5*)
+    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    hardcode_shlibpath_var=no
+    runpath_var=LD_RUN_PATH
+    hardcode_runpath_var=yes
+    ;;
+
+  solaris*)
+    no_undefined_flag=' -z text'
+    # $CC -shared without GNU ld will not create a library from C++
+    # object files and a static libstdc++, better avoid it by now
+    archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linkopts'
+    archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+		$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linkopts~$rm $lib.exp'
+    hardcode_libdir_flag_spec='-R$libdir'
+    hardcode_shlibpath_var=no
+    case "$host_os" in
+    solaris2.[0-5] | solaris2.[0-5].*) ;;
+    *) # Supported since Solaris 2.6 (maybe 2.5.1?)
+      whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;;
+    esac
+    ;;
+
+  sunos4*)
+    archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linkopts'
+    hardcode_libdir_flag_spec='-L$libdir'
+    hardcode_direct=yes
+    hardcode_minus_L=yes
+    hardcode_shlibpath_var=no
+    ;;
+
+  sysv4)
+    if test "x$host_vendor" = xsequent; then
+      # Use $CC to link under sequent, because it throws in some extra .o 
+      # files that make .init and .fini sections work.
+      archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $linkopts'
+    else
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    fi
+    runpath_var='LD_RUN_PATH'
+    hardcode_shlibpath_var=no
+    hardcode_direct=no #Motorola manual says yes, but my tests say they lie 
+    ;;  
+
+  sysv4.3*)
+    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    hardcode_shlibpath_var=no
+    export_dynamic_flag_spec='-Bexport'
+    ;;
+
+  sysv5*)
+    no_undefined_flag=' -z text'
+    # $CC -shared without GNU ld will not create a library from C++
+    # object files and a static libstdc++, better avoid it by now
+    archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linkopts'
+    archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+		$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linkopts~$rm $lib.exp'
+    hardcode_libdir_flag_spec=
+    hardcode_shlibpath_var=no
+    runpath_var='LD_RUN_PATH'
+    ;;
+
+  uts4*)
+    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    hardcode_libdir_flag_spec='-L$libdir'
+    hardcode_shlibpath_var=no
+    ;;
+
+  dgux*)
+    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    hardcode_libdir_flag_spec='-L$libdir'
+    hardcode_shlibpath_var=no
+    ;;
+
+  sysv4*MP*)
+    if test -d /usr/nec; then
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+      hardcode_shlibpath_var=no
+      runpath_var=LD_RUN_PATH
+      hardcode_runpath_var=yes
+      ld_shlibs=yes
+    fi
+    ;;
+
+  sysv4.2uw2*)
+    archive_cmds='$LD -G -o $lib $libobjs $deplibs $linkopts'
+    hardcode_direct=yes
+    hardcode_minus_L=no
+    hardcode_shlibpath_var=no
+    hardcode_runpath_var=yes
+    runpath_var=LD_RUN_PATH
+    ;;
+
+  unixware7*)
+    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    runpath_var='LD_RUN_PATH'
+    hardcode_shlibpath_var=no
+    ;;
+
+  *)
+    ld_shlibs=no
+    ;;
+  esac
+fi
+echo "$ac_t$ld_shlibs" 1>&6
+test "$ld_shlibs" = no && can_build_shared=no
+
+if test -z "$NM"; then
+  echo $ac_n "checking for BSD-compatible nm... $ac_c" 1>&6
+  case "$NM" in
+  [\\/]* | [A-Za-z]:[\\/]*) ;; # Let the user override the test with a path.
+  *)
+    IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+    for ac_dir in $PATH /usr/ucb /usr/ccs/bin /bin; do
+      test -z "$ac_dir" && ac_dir=.
+      if test -f $ac_dir/nm || test -f $ac_dir/nm$ac_exeext; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	if ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
+	  NM="$ac_dir/nm -B"
+	  break
+	elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
+	  NM="$ac_dir/nm -p"
+	  break
+	else
+	  NM=${NM="$ac_dir/nm"} # keep the first match, but
+	  continue # so that we can try to find one that supports BSD flags
+	fi
+      fi
+    done
+    IFS="$ac_save_ifs"
+    test -z "$NM" && NM=nm
+    ;;
+  esac
+  echo "$ac_t$NM" 1>&6
+fi
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+echo $ac_n "checking command to parse $NM output... $ac_c" 1>&6
+
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[BCDEGRST]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
+
+# Transform the above into a raw symbol and a C symbol.
+symxfrm='\1 \2\3 \3'
+
+# Transform an extracted symbol line into a proper C declaration
+global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern char \1;/p'"
+
+# Define system-specific variables.
+case "$host_os" in
+aix*)
+  symcode='[BCDT]'
+  ;;
+cygwin* | mingw*)
+  symcode='[ABCDGISTW]'
+  ;;
+hpux*) # Its linker distinguishes data from code symbols
+  global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern char \1();/p' -e 's/^. .* \(.*\)$/extern char \1;/p'"
+  ;;
+irix*)
+  symcode='[BCDEGRST]'
+  ;;
+solaris*)
+  symcode='[BDT]'
+  ;;
+sysv4)
+  symcode='[DFNSTU]'
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then
+  symcode='[ABCDGISTW]'
+fi
+
+# Try without a prefix undercore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Write the raw and C identifiers.
+  global_symbol_pipe="sed -n -e 's/^.*[ 	]\($symcode\)[ 	][ 	]*\($ac_symprfx\)$sympat$/$symxfrm/p'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+  $rm conftest*
+  cat > conftest.c <<EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(){}
+#ifdef __cplusplus
+}
+#endif
+main(){nm_test_var='a';nm_test_func();return(0);}
+EOF
+
+  echo "$progname:1653: checking if global_symbol_pipe works" >&5
+  if { (eval echo $progname:1654: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; } && test -s conftest.$objext; then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if { echo "$progname:1657: eval \"$NM conftest.$objext | $global_symbol_pipe > $nlist\"" >&5; eval "$NM conftest.$objext | $global_symbol_pipe > $nlist 2>&5"; } && test -s "$nlist"; then
+
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if egrep ' nm_test_var$' "$nlist" >/dev/null; then
+	if egrep ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<EOF > conftest.c
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EOF
+	  # Now generate the symbol file.
+	  eval "$global_symbol_to_cdecl"' < "$nlist" >> conftest.c'
+
+	  cat <<EOF >> conftest.c
+#if defined (__STDC__) && __STDC__
+# define lt_ptr_t void *
+#else
+# define lt_ptr_t char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+const struct {
+  const char *name;
+  lt_ptr_t address;
+}
+lt_preloaded_symbols[] =
+{
+EOF
+	  sed 's/^. \(.*\) \(.*\)$/  {"\2", (lt_ptr_t) \&\2},/' < "$nlist" >> conftest.c
+	  cat <<\EOF >> conftest.c
+  {0, (lt_ptr_t) 0}
+};
+
+#ifdef __cplusplus
+}
+#endif
+EOF
+	  # Now try linking the two files.
+	  mv conftest.$objext conftstm.$objext
+	  save_LIBS="$LIBS"
+	  save_CFLAGS="$CFLAGS"
+	  LIBS="conftstm.$objext"
+	  CFLAGS="$CFLAGS$no_builtin_flag"
+	  if { (eval echo $progname:1709: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest; then
+	    pipe_works=yes
+	  else
+	    echo "$progname: failed program was:" >&5
+	    cat conftest.c >&5
+	  fi
+	  LIBS="$save_LIBS"
+	else
+	  echo "cannot find nm_test_func in $nlist" >&5
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&5
+      fi
+    else
+      echo "cannot run $global_symbol_pipe" >&5
+    fi
+  else
+    echo "$progname: failed program was:" >&5
+    cat conftest.c >&5
+  fi
+  $rm conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test "$pipe_works" = yes; then
+    break
+  else
+    global_symbol_pipe=
+  fi
+done
+if test "$pipe_works" = yes; then
+  echo "${ac_t}ok" 1>&6
+else
+  echo "${ac_t}failed" 1>&6
+fi
+
+if test -z "$global_symbol_pipe"; then
+  global_symbol_to_cdecl=
+fi
+
+# Check hardcoding attributes.
+echo $ac_n "checking how to hardcode library paths into programs... $ac_c" 1>&6
+hardcode_action=
+if test -n "$hardcode_libdir_flag_spec" || \
+   test -n "$runpath_var"; then
+
+  # We can hardcode non-existant directories.
+  if test "$hardcode_direct" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$hardcode_shlibpath_var" != no &&
+     test "$hardcode_minus_L" != no; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action=unsupported
+fi
+echo "$ac_t$hardcode_action" 1>&6
+
+
+reload_flag=
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+echo $ac_n "checking for $LD option to reload object files... $ac_c" 1>&6
+# PORTME Some linkers may need a different reload flag.
+reload_flag='-r'
+echo "$ac_t$reload_flag" 1>&6
+test -n "$reload_flag" && reload_flag=" $reload_flag"
+
+# PORTME Fill in your ld.so characteristics
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+file_magic_cmd=
+file_magic_test_file=
+deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [regex]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given egrep regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+echo $ac_n "checking dynamic linker characteristics... $ac_c" 1>&6
+case "$host_os" in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}.so$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}.so$major'
+  ;;
+
+aix4*)
+  version_type=linux
+  # AIX has no versioning support, so currently we can not hardcode correct
+  # soname into executable. Probably we can add versioning support to
+  # collect2, so additional links can be useful in future.
+  # We preserve .a as extension for shared libraries though AIX4.2
+  # and later linker supports .so
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.a'
+  shlibpath_var=LIBPATH
+  deplibs_check_method=pass_all
+  ;;
+
+amigaos*)
+  library_names_spec='$libname.ixlibrary $libname.a'
+  # Create ${libname}_ixlibrary.a entries in /sys/libs.
+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "(cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a)"; (cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a) || exit 1; done'
+  ;;
+
+beos*)
+  library_names_spec='${libname}.so'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  deplibs_check_method=pass_all
+  lt_cv_dlopen="load_add_on"
+  lt_cv_dlopen_libs=
+  lt_cv_dlopen_self=yes
+  ;;
+
+bsdi4*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
+  soname_spec='${libname}${release}.so$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
+  file_magic_cmd=/usr/bin/file
+  file_magic_test_file=/shlib/libc.so
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  export_dynamic_flag_spec=-rdynamic
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw*)
+  version_type=windows
+  need_version=no
+  need_lib_prefix=no
+  if test "$with_gcc" = yes; then
+    library_names_spec='${libname}`echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll $libname.a'
+  else
+    library_names_spec='${libname}`echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll $libname.lib'
+  fi
+  dynamic_linker='Win32 ld.exe'
+  deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
+  file_magic_cmd='${OBJDUMP} -f'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  lt_cv_dlopen="LoadLibrary"
+  lt_cv_dlopen_libs=
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+  
+freebsd*)
+  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
+  version_type=freebsd-$objformat
+  case "$version_type" in
+    freebsd-elf*)
+      deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
+      file_magic_cmd=/usr/bin/file
+      file_magic_test_file=`echo /usr/lib/libc.so*`
+      library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so $libname.so'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      deplibs_check_method=unknown
+      library_names_spec='${libname}${release}.so$versuffix $libname.so$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case "$host_os" in
+  freebsd2* | freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  *) # from 3.2 on
+    shlibpath_overrides_runpath=no
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so${major} ${libname}.so'
+  soname_spec='${libname}${release}.so$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  dynamic_linker="$host_os dld.sl"
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  shlibpath_var=SHLIB_PATH
+  shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+  library_names_spec='${libname}${release}.sl$versuffix ${libname}${release}.sl$major $libname.sl'
+  soname_spec='${libname}${release}.sl$major'
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  case "$host_os" in
+  hpux10.20*)
+    # TODO:  Does this work for hpux-11 too?
+    deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
+    file_magic_cmd=/usr/bin/file
+    file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+irix5* | irix6*)
+  version_type=irix
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}.so.$major'
+  library_names_spec='${libname}${release}.so.$versuffix ${libname}${release}.so.$major ${libname}${release}.so $libname.so'
+  case "$host_os" in
+  irix5*)
+    libsuff= shlibsuff=
+    # this will be overridden with pass_all, but let us keep it just in case
+    deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
+    ;;
+  *)
+    case "$LD" in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 ") libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 ") libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 ") libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  file_magic_cmd=/usr/bin/file
+  file_magic_test_file=`echo /lib${libsuff}/libc.so*`
+  deplibs_check_method='pass_all'
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux-gnuoldld* | linux-gnuaout* | linux-gnucoff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux-gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
+  soname_spec='${libname}${release}.so$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  deplibs_check_method=pass_all
+
+  if test -f /lib/ld.so.1; then
+    dynamic_linker='GNU ld.so'
+  else
+    # Only the GNU ld.so supports shared libraries on MkLinux.
+    case "$host_cpu" in
+    powerpc*) dynamic_linker=no ;;
+    *) dynamic_linker='Linux ld.so' ;;
+    esac
+  fi
+  ;;
+
+netbsd*)
+  version_type=sunos
+  if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so ${libname}.so'
+    soname_spec='${libname}${release}.so$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+openbsd*)
+  version_type=sunos
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+    need_version=no
+  fi
+  library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+os2*)
+  libname_spec='$name'
+  need_lib_prefix=no
+  library_names_spec='$libname.dll $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_version=no
+  soname_spec='${libname}${release}.so'
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so $libname.so'
+  shlibpath_var=LD_LIBRARY_PATH
+  # this will be overridden with pass_all, but let us keep it just in case
+  deplibs_check_method='file_magic COFF format alpha shared library'
+  file_magic_cmd=/usr/bin/file
+  file_magic_test_file=/shlib/libc.so
+  deplibs_check_method='pass_all'
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+rhapsody*)
+  version_type=sunos
+  library_names_spec='${libname}.so'
+  soname_spec='${libname}.so'
+  shlibpath_var=DYLD_LIBRARY_PATH
+  deplibs_check_method=pass_all
+  ;;
+
+sco3.2v5*)
+  version_type=osf
+  soname_spec='${libname}${release}.so$major'
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
+  soname_spec='${libname}${release}.so$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  deplibs_check_method="file_magic ELF [0-9][0-9]-bit [LM]SB dynamic lib"
+  file_magic_cmd=/usr/bin/file
+  file_magic_test_file=/lib/libc.so
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+  version_type=linux
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
+  soname_spec='${libname}${release}.so$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case "$host_vendor" in
+    sequent)
+      file_magic_cmd='/bin/file'
+      deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
+      ;;
+    ncr)
+      deplibs_check_method='pass_all'
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
+      file_magic_cmd=/usr/bin/file
+      file_magic_test_file=`echo /usr/lib/libc.so*`
+      ;;
+  esac
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
+  soname_spec='${libname}${release}.so$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
+  soname_spec='${libname}${release}.so$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname.so.$versuffix $libname.so.$major $libname.so'
+    soname_spec='$libname.so.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+echo "$ac_t$dynamic_linker" 1>&6
+test "$dynamic_linker" = no && can_build_shared=no
+
+# Report the final consequences.
+echo "checking if libtool supports shared libraries... $can_build_shared" 1>&6
+
+# Only try to build win32 dlls if AC_LIBTOOL_WIN32_DLL was used in
+# configure.in, otherwise build static only libraries.
+case "$host_os" in
+cygwin* | mingw* | os2*)
+  if test x$can_build_shared = xyes; then
+    test x$enable_win32_dll = xno && can_build_shared=no
+    echo "checking if package supports dlls... $can_build_shared" 1>&6
+  fi
+;;
+esac
+
+if test -n "$file_magic_test_file" && test -n "$file_magic_cmd"; then
+  case "$deplibs_check_method" in
+  "file_magic "*)
+    file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
+    if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+       egrep "$file_magic_regex" > /dev/null; then
+      :
+    else
+      cat <<EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+EOF
+    fi ;;
+  esac
+fi
+
+echo $ac_n "checking whether to build shared libraries... $ac_c" 1>&6
+test "$can_build_shared" = "no" && enable_shared=no
+
+# On AIX, shared libraries and static libraries use the same namespace, and
+# are all built from PIC.
+case "$host_os" in
+aix3*)
+  test "$enable_shared" = yes && enable_static=no
+  if test -n "$RANLIB"; then
+    archive_cmds="$archive_cmds~\$RANLIB \$lib"
+    postinstall_cmds='$RANLIB $lib'
+  fi
+  ;;
+
+aix4*)
+  test "$enable_shared" = yes && enable_static=no
+  ;;
+esac
+
+echo "$ac_t$enable_shared" 1>&6
+
+# Make sure either enable_shared or enable_static is yes.
+test "$enable_shared" = yes || enable_static=yes
+
+echo "checking whether to build static libraries... $enable_static" 1>&6
+
+if test "$hardcode_action" = relink; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+echo $ac_n "checking for objdir... $ac_c" 1>&6
+rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  objdir=_libs
+fi
+rmdir .libs 2>/dev/null
+echo "$ac_t$objdir" 1>&6
+
+if test "x$enable_dlopen" != xyes; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+if eval "test \"`echo '$''{'lt_cv_dlopen'+set}'`\" != set"; then
+  lt_cv_dlopen=no lt_cv_dlopen_libs=
+echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6
+echo "$progname:2248: checking for dlopen in -ldl" >&5
+ac_lib_var=`echo dl'_'dlopen | sed 'y%./+-%__p_%'`
+if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  ac_save_LIBS="$LIBS"
+LIBS="-ldl  $LIBS"
+cat > conftest.$ac_ext <<EOF
+#line 2256 "ltconfig"
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen();
+
+int main() {
+dlopen()
+; return 0; }
+EOF
+if { (eval echo $progname:2269: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_lib_$ac_lib_var=yes"
+else
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_lib_$ac_lib_var=no"
+fi
+rm -f conftest*
+LIBS="$ac_save_LIBS"
+
+fi
+if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+else
+  echo "$ac_t""no" 1>&6
+echo $ac_n "checking for dlopen""... $ac_c" 1>&6
+echo "$progname:2288: checking for dlopen" >&5
+if eval "test \"`echo '$''{'ac_cv_func_dlopen'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2293 "ltconfig"
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char dlopen(); below.  */
+#include <assert.h>
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen();
+
+int main() {
+
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_dlopen) || defined (__stub___dlopen)
+choke me
+#else
+dlopen();
+#endif
+
+; return 0; }
+EOF
+if { (eval echo $progname:2318: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_func_dlopen=yes"
+else
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_func_dlopen=no"
+fi
+rm -f conftest*
+fi
+if eval "test \"`echo '$ac_cv_func_'dlopen`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+  lt_cv_dlopen="dlopen"
+else
+  echo "$ac_t""no" 1>&6
+echo $ac_n "checking for dld_link in -ldld""... $ac_c" 1>&6
+echo "$progname:2335: checking for dld_link in -ldld" >&5
+ac_lib_var=`echo dld'_'dld_link | sed 'y%./+-%__p_%'`
+if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  ac_save_LIBS="$LIBS"
+LIBS="-ldld  $LIBS"
+cat > conftest.$ac_ext <<EOF
+#line 2343 "ltconfig"
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dld_link();
+
+int main() {
+dld_link()
+; return 0; }
+EOF
+if { (eval echo $progname:2356: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_lib_$ac_lib_var=yes"
+else
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_lib_$ac_lib_var=no"
+fi
+rm -f conftest*
+LIBS="$ac_save_LIBS"
+
+fi
+if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+  lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"
+else
+  echo "$ac_t""no" 1>&6
+echo $ac_n "checking for shl_load""... $ac_c" 1>&6
+echo "$progname:2375: checking for shl_load" >&5
+if eval "test \"`echo '$''{'ac_cv_func_shl_load'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2380 "ltconfig"
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char shl_load(); below.  */
+#include <assert.h>
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shl_load();
+
+int main() {
+
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_shl_load) || defined (__stub___shl_load)
+choke me
+#else
+shl_load();
+#endif
+
+; return 0; }
+EOF
+if { (eval echo $progname:2405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_func_shl_load=yes"
+else
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_func_shl_load=no"
+fi
+rm -f conftest*
+fi
+
+if eval "test \"`echo '$ac_cv_func_'shl_load`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+  lt_cv_dlopen="shl_load"
+else
+  echo "$ac_t""no" 1>&6
+echo $ac_n "checking for shl_load in -ldld""... $ac_c" 1>&6
+echo "$progname:2423: checking for shl_load in -ldld" >&5
+ac_lib_var=`echo dld'_'shl_load | sed 'y%./+-%__p_%'`
+if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  ac_save_LIBS="$LIBS"
+LIBS="-ldld  $LIBS"
+cat > conftest.$ac_ext <<EOF
+#line 2431 "ltconfig"
+#include "confdefs.h"
+/* Override any gcc2 internal prototype to avoid an error.  */
+/* We use char because int might match the return type of a gcc2
+    builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shl_load();
+
+int main() {
+shl_load()
+; return 0; }
+EOF
+if { (eval echo $progname:2445: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  eval "ac_cv_lib_$ac_lib_var=yes"
+else
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_lib_$ac_lib_var=no"
+fi
+rm -f conftest*
+LIBS="$ac_save_LIBS"
+
+fi
+if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+
+fi
+
+    
+fi
+
+  
+fi
+
+
+fi
+
+fi
+
+  if test "x$lt_cv_dlopen" != xno; then
+    enable_dlopen=yes
+  fi
+
+  case "$lt_cv_dlopen" in
+  dlopen)
+for ac_hdr in dlfcn.h; do
+ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
+echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
+echo "$progname:2488: checking for $ac_hdr" >&5
+if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 2493 "ltconfig"
+#include <$ac_hdr>
+int fnord = 0;
+EOF
+ac_try="$ac_compile >/dev/null 2>conftest.out"
+{ (eval echo $progname:2498: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=yes"
+else
+  echo "$ac_err" >&5
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=no"
+fi
+rm -f conftest*
+fi
+if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+    if test "x$ac_cv_header_dlfcn_h" = xyes; then
+      CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+    fi
+    eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+  echo $ac_n "checking whether a program can dlopen itself""... $ac_c" 1>&6
+echo "$progname:2526: checking whether a program can dlopen itself" >&5
+if test "${lt_cv_dlopen_self+set}" = set; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test "$cross_compiling" = yes; then
+    lt_cv_dlopen_self=cross
+  else
+    cat > conftest.c <<EOF
+#line 2534 "ltconfig"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+# define LTDL_GLOBAL	RTLD_GLOBAL
+#else
+# ifdef DL_GLOBAL
+#  define LTDL_GLOBAL	DL_GLOBAL
+# else
+#  define LTDL_GLOBAL	0
+# endif
+#endif
+
+/* We may have to define LTDL_LAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LTDL_LAZY_OR_NOW
+# ifdef RTLD_LAZY
+#  define LTDL_LAZY_OR_NOW	RTLD_LAZY
+# else
+#  ifdef DL_LAZY
+#   define LTDL_LAZY_OR_NOW	DL_LAZY
+#  else
+#   ifdef RTLD_NOW
+#    define LTDL_LAZY_OR_NOW	RTLD_NOW
+#   else
+#    ifdef DL_NOW
+#     define LTDL_LAZY_OR_NOW	DL_NOW
+#    else
+#     define LTDL_LAZY_OR_NOW	0
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+fnord() { int i=42;}
+main() { void *self, *ptr1, *ptr2; self=dlopen(0,LTDL_GLOBAL|LTDL_LAZY_OR_NOW);
+    if(self) { ptr1=dlsym(self,"fnord"); ptr2=dlsym(self,"_fnord");
+	       if(ptr1 || ptr2) { dlclose(self); exit(0); } } exit(1); } 
+
+EOF
+if { (eval echo $progname:2580: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null
+then
+  lt_cv_dlopen_self=yes
+else
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -fr conftest*
+  lt_cv_dlopen_self=no
+fi
+rm -fr conftest*
+fi
+
+fi
+
+echo "$ac_t""$lt_cv_dlopen_self" 1>&6
+
+  if test "$lt_cv_dlopen_self" = yes; then
+    LDFLAGS="$LDFLAGS $link_static_flag"
+  echo $ac_n "checking whether a statically linked program can dlopen itself""... $ac_c" 1>&6
+echo "$progname:2599: checking whether a statically linked program can dlopen itself" >&5
+if test "${lt_cv_dlopen_self_static+set}" = set; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test "$cross_compiling" = yes; then
+    lt_cv_dlopen_self_static=cross
+  else
+    cat > conftest.c <<EOF
+#line 2607 "ltconfig"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+# define LTDL_GLOBAL	RTLD_GLOBAL
+#else
+# ifdef DL_GLOBAL
+#  define LTDL_GLOBAL	DL_GLOBAL
+# else
+#  define LTDL_GLOBAL	0
+# endif
+#endif
+
+/* We may have to define LTDL_LAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LTDL_LAZY_OR_NOW
+# ifdef RTLD_LAZY
+#  define LTDL_LAZY_OR_NOW	RTLD_LAZY
+# else
+#  ifdef DL_LAZY
+#   define LTDL_LAZY_OR_NOW	DL_LAZY
+#  else
+#   ifdef RTLD_NOW
+#    define LTDL_LAZY_OR_NOW	RTLD_NOW
+#   else
+#    ifdef DL_NOW
+#     define LTDL_LAZY_OR_NOW	DL_NOW
+#    else
+#     define LTDL_LAZY_OR_NOW	0
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+fnord() { int i=42;}
+main() { void *self, *ptr1, *ptr2; self=dlopen(0,LTDL_GLOBAL|LTDL_LAZY_OR_NOW);
+    if(self) { ptr1=dlsym(self,"fnord"); ptr2=dlsym(self,"_fnord");
+    if(ptr1 || ptr2) { dlclose(self); exit(0); } } exit(1); } 
+
+EOF
+if { (eval echo $progname:2653: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest && (./conftest; exit) 2>/dev/null
+then
+  lt_cv_dlopen_self_static=yes
+else
+  echo "$progname: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -fr conftest*
+  lt_cv_dlopen_self_static=no
+fi
+rm -fr conftest*
+fi
+
+fi
+
+echo "$ac_t""$lt_cv_dlopen_self_static" 1>&6
+fi
+    ;;
+  esac
+
+  case "$lt_cv_dlopen_self" in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case "$lt_cv_dlopen_self_static" in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+
+# Copy echo and quote the copy, instead of the original, because it is
+# used later.
+ltecho="$echo"
+if test "X$ltecho" = "X$CONFIG_SHELL $0 --fallback-echo"; then
+   ltecho="$CONFIG_SHELL \$0 --fallback-echo"
+fi
+LTSHELL="$SHELL"
+
+LTCONFIG_VERSION="$VERSION"
+
+# Only quote variables if we're using ltmain.sh.
+case "$ltmain" in
+*.sh)
+  # Now quote all the things that may contain metacharacters.
+  for var in ltecho old_CC old_CFLAGS old_CPPFLAGS \
+    old_LD old_LDFLAGS old_LIBS \
+    old_NM old_RANLIB old_LN_S old_DLLTOOL old_OBJDUMP old_AS \
+    AR CC LD LN_S NM LTSHELL LTCONFIG_VERSION \
+    reload_flag reload_cmds wl \
+    pic_flag link_static_flag no_builtin_flag export_dynamic_flag_spec \
+    thread_safe_flag_spec whole_archive_flag_spec libname_spec \
+    library_names_spec soname_spec \
+    RANLIB old_archive_cmds old_archive_from_new_cmds old_postinstall_cmds \
+    old_postuninstall_cmds archive_cmds archive_expsym_cmds postinstall_cmds postuninstall_cmds \
+    file_magic_cmd export_symbols_cmds deplibs_check_method allow_undefined_flag no_undefined_flag \
+    finish_cmds finish_eval global_symbol_pipe global_symbol_to_cdecl \
+    hardcode_libdir_flag_spec hardcode_libdir_separator  \
+    sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
+    compiler_c_o compiler_o_lo need_locks exclude_expsyms include_expsyms; do
+
+    case "$var" in
+    reload_cmds | old_archive_cmds | old_archive_from_new_cmds | \
+    old_postinstall_cmds | old_postuninstall_cmds | \
+    export_symbols_cmds | archive_cmds | archive_expsym_cmds | \
+    postinstall_cmds | postuninstall_cmds | \
+    finish_cmds | sys_lib_search_path_spec | sys_lib_dlsearch_path_spec)
+      # Double-quote double-evaled strings.
+      eval "$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\""
+      ;;
+    *)
+      eval "$var=\\\"\`\$echo \"X\$$var\" | \$Xsed -e \"\$sed_quote_subst\"\`\\\""
+      ;;
+    esac
+  done
+
+  case "$ltecho" in
+  *'\$0 --fallback-echo"')
+    ltecho=`$echo "X$ltecho" | $Xsed -e 's/\\\\\\\$0 --fallback-echo"$/$0 --fallback-echo"/'`
+    ;;
+  esac
+
+  trap "$rm \"$ofile\"; exit 1" 1 2 15
+  echo "creating $ofile"
+  $rm "$ofile"
+  cat <<EOF > "$ofile"
+#! $SHELL
+
+# `$echo "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)
+# NOTE: Changes made to this file will be lost: look at ltconfig or ltmain.sh.
+#
+# Copyright (C) 1996-1999 Free Software Foundation, Inc.
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="sed -e s/^X//"
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
+
+### BEGIN LIBTOOL CONFIG
+EOF
+  cfgfile="$ofile"
+  ;;
+
+*)
+  # Double-quote the variables that need it (for aesthetics).
+  for var in old_CC old_CFLAGS old_CPPFLAGS \
+    old_LD old_LDFLAGS old_LIBS \
+    old_NM old_RANLIB old_LN_S old_DLLTOOL old_OBJDUMP old_AS; do
+    eval "$var=\\\"\$var\\\""
+  done
+
+  # Just create a config file.
+  cfgfile="$ofile.cfg"
+  trap "$rm \"$cfgfile\"; exit 1" 1 2 15
+  echo "creating $cfgfile"
+  $rm "$cfgfile"
+  cat <<EOF > "$cfgfile"
+# `$echo "$cfgfile" | sed 's%^.*/%%'` - Libtool configuration file.
+# Generated automatically by $PROGRAM (GNU $PACKAGE $VERSION$TIMESTAMP)
+EOF
+  ;;
+esac
+
+cat <<EOF >> "$cfgfile"
+# Libtool was configured as follows, on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+#
+# CC=$old_CC CFLAGS=$old_CFLAGS CPPFLAGS=$old_CPPFLAGS \\
+# LD=$old_LD LDFLAGS=$old_LDFLAGS LIBS=$old_LIBS \\
+# NM=$old_NM RANLIB=$old_RANLIB LN_S=$old_LN_S \\
+# DLLTOOL=$old_DLLTOOL OBJDUMP=$old_OBJDUMP AS=$old_AS \\
+#   $0$ltconfig_args
+#
+# Compiler and other test output produced by $progname, useful for
+# debugging $progname, is in ./config.log if it exists.
+
+# The version of $progname that generated this script.
+LTCONFIG_VERSION=$LTCONFIG_VERSION
+
+# Shell to use when invoking shell scripts.
+SHELL=$LTSHELL
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# The host system.
+host_alias=$host_alias
+host=$host
+
+# An echo program that does not interpret backslashes.
+echo=$ltecho
+
+# The archiver.
+AR=$AR
+
+# The default C compiler.
+CC=$CC
+
+# The linker used to build libraries.
+LD=$LD
+
+# Whether we need hard or soft links.
+LN_S=$LN_S
+
+# A BSD-compatible nm program.
+NM=$NM
+
+# Used on cygwin: DLL creation program.
+DLLTOOL="$DLLTOOL"
+
+# Used on cygwin: object dumper.
+OBJDUMP="$OBJDUMP"
+
+# Used on cygwin: assembler.
+AS="$AS"
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# How to create reloadable object files.
+reload_flag=$reload_flag
+reload_cmds=$reload_cmds
+
+# How to pass a linker flag through the compiler.
+wl=$wl
+
+# Object file suffix (normally "o").
+objext="$objext"
+
+# Old archive suffix (normally "a").
+libext="$libext"
+
+# Executable file suffix (normally "").
+exeext="$exeext"
+
+# Additional compiler flags for building library objects.
+pic_flag=$pic_flag
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$compiler_c_o
+
+# Can we write directly to a .lo ?
+compiler_o_lo=$compiler_o_lo
+
+# Must we lock files when doing compilation ?
+need_locks=$need_locks
+
+# Do we need the lib prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Whether dlopen is supported.
+dlopen=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$link_static_flag
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$no_builtin_flag
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$export_dynamic_flag_spec
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$whole_archive_flag_spec
+
+# Compiler flag to generate thread-safe objects.
+thread_safe_flag_spec=$thread_safe_flag_spec
+
+# Library versioning type.
+version_type=$version_type
+
+# Format of library name prefix.
+libname_spec=$libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME.
+library_names_spec=$library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$soname_spec
+
+# Commands used to build and install an old-style archive.
+RANLIB=$RANLIB
+old_archive_cmds=$old_archive_cmds
+old_postinstall_cmds=$old_postinstall_cmds
+old_postuninstall_cmds=$old_postuninstall_cmds
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$old_archive_from_new_cmds
+
+# Commands used to build and install a shared archive.
+archive_cmds=$archive_cmds
+archive_expsym_cmds=$archive_expsym_cmds
+postinstall_cmds=$postinstall_cmds
+postuninstall_cmds=$postuninstall_cmds
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$deplibs_check_method
+
+# Command to use when deplibs_check_method == file_magic.
+file_magic_cmd=$file_magic_cmd
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$allow_undefined_flag
+
+# Flag that forces no undefined symbols.
+no_undefined_flag=$no_undefined_flag
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$finish_cmds
+
+# Same as above, but a single script fragment to be evaled but not shown.
+finish_eval=$finish_eval
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration
+global_symbol_to_cdecl=$global_symbol_to_cdecl
+
+# This is the shared library runtime path variable.
+runpath_var=$runpath_var
+
+# This is the shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec=$hardcode_libdir_flag_spec
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator=$hardcode_libdir_separator
+
+# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct=$hardcode_direct
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L=$hardcode_minus_L
+
+# Set to yes if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into
+# the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var
+
+# Compile-time system search path for libraries
+sys_lib_search_path_spec=$sys_lib_search_path_spec
+
+# Run-time system search path for libraries
+sys_lib_dlsearch_path_spec=$sys_lib_dlsearch_path_spec
+
+# Fix the shell variable \$srcfile for the compiler.
+fix_srcfile_path="$fix_srcfile_path"
+
+# Set to yes if exported symbols are required.
+always_export_symbols=$always_export_symbols
+
+# The commands to list exported symbols.
+export_symbols_cmds=$export_symbols_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$exclude_expsyms
+
+# Symbols that must always be exported.
+include_expsyms=$include_expsyms
+
+EOF
+
+case "$ltmain" in
+*.sh)
+  echo '### END LIBTOOL CONFIG' >> "$ofile"
+  echo >> "$ofile"
+  case "$host_os" in
+  aix3*)
+    cat <<\EOF >> "$ofile"
+
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+EOF
+    ;;
+  esac
+
+  # Append the ltmain.sh script.
+  sed '$q' "$ltmain" >> "$ofile" || (rm -f "$ofile"; exit 1)
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+
+  chmod +x "$ofile"
+  ;;
+
+*)
+  # Compile the libtool program.
+  echo "FIXME: would compile $ltmain"
+  ;;
+esac
+
+test -n "$cache_file" || exit 0
+
+# AC_CACHE_SAVE
+trap '' 1 2 15
+cat > confcache <<\EOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs.  It is not useful on other systems.
+# If it contains results you don't want to keep, you may remove or edit it.
+#
+# By default, configure uses ./config.cache as the cache file,
+# creating it if it does not exist already.  You can give configure
+# the --cache-file=FILE option to use a different cache file; that is
+# what configure does when it calls configure scripts in
+# subdirectories, so they share the cache.
+# Giving --cache-file=/dev/null disables caching, for debugging configure.
+# config.status only pays attention to the cache file if you give it the
+# --recheck option to rerun configure.
+#
+EOF
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(set) 2>&1 |
+  case `(ac_space=' '; set | grep ac_space) 2>&1` in
+  *ac_space=\ *)
+    # `set' does not quote correctly, so add quotes (double-quote substitution
+    # turns \\\\ into \\, and sed turns \\ into \).
+    sed -n \
+      -e "s/'/'\\\\''/g" \
+      -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
+    ;;
+  *)
+    # `set' quotes correctly as required by POSIX, so do not add quotes.
+    sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
+    ;;
+  esac >> confcache
+if cmp -s $cache_file confcache; then
+  :
+else
+  if test -w $cache_file; then
+    echo "updating cache $cache_file"
+    cat confcache > $cache_file
+  else
+    echo "not updating unwritable cache $cache_file"
+  fi
+fi
+rm -f confcache
+
+exit 0
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
Index: xc/extras/expat/conftools/ltmain.sh
diff -u /dev/null xc/extras/expat/conftools/ltmain.sh:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/ltmain.sh	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,4028 @@
+# ltmain.sh - Provide generalized library-building support services.
+# NOTE: Changing this file will not affect anything until you rerun ltconfig.
+#
+# Copyright (C) 1996-1999 Free Software Foundation, Inc.
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Check that we have a working $echo.
+if test "X$1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X$1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell, and then maybe $echo will work.
+  exec $SHELL "$0" --no-reexec ${1+"$@"}
+fi
+
+if test "X$1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<EOF
+$*
+EOF
+  exit 0
+fi
+
+# The name of this program.
+progname=`$echo "$0" | sed 's%^.*/%%'`
+modename="$progname"
+
+# Constants.
+PROGRAM=ltmain.sh
+PACKAGE=libtool
+VERSION=1.3.5
+TIMESTAMP=" (1.385.2.206 2000/05/27 11:12:27)"
+
+default_mode=
+help="Try \`$progname --help' for more information."
+magic="%%%MAGIC variable%%%"
+mkdir="mkdir"
+mv="mv -f"
+rm="rm -f"
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='sed -e 1s/^X//'
+sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
+SP2NL='tr \040 \012'
+NL2SP='tr \015\012 \040\040'
+
+# NLS nuisances.
+# Only set LANG and LC_ALL to C if already set.
+# These must not be set unconditionally because not all systems understand
+# e.g. LANG=C (notably SCO).
+# We save the old values to restore during execute mode.
+if test "${LC_ALL+set}" = set; then
+  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
+fi
+if test "${LANG+set}" = set; then
+  save_LANG="$LANG"; LANG=C; export LANG
+fi
+
+if test "$LTCONFIG_VERSION" != "$VERSION"; then
+  echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
+  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+  exit 1
+fi
+
+if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+  echo "$modename: not configured to build any kind of library" 1>&2
+  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+  exit 1
+fi
+
+# Global variables.
+mode=$default_mode
+nonopt=
+prev=
+prevopt=
+run=
+show="$echo"
+show_help=
+execute_dlfiles=
+lo2o="s/\\.lo\$/.${objext}/"
+o2lo="s/\\.${objext}\$/.lo/"
+
+# Parse our command line options once, thoroughly.
+while test $# -gt 0
+do
+  arg="$1"
+  shift
+
+  case "$arg" in
+  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) optarg= ;;
+  esac
+
+  # If the previous option needs an argument, assign it.
+  if test -n "$prev"; then
+    case "$prev" in
+    execute_dlfiles)
+      eval "$prev=\"\$$prev \$arg\""
+      ;;
+    *)
+      eval "$prev=\$arg"
+      ;;
+    esac
+
+    prev=
+    prevopt=
+    continue
+  fi
+
+  # Have we seen a non-optional argument yet?
+  case "$arg" in
+  --help)
+    show_help=yes
+    ;;
+
+  --version)
+    echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
+    exit 0
+    ;;
+
+  --config)
+    sed -e '1,/^### BEGIN LIBTOOL CONFIG/d' -e '/^### END LIBTOOL CONFIG/,$d' $0
+    exit 0
+    ;;
+
+  --debug)
+    echo "$progname: enabling shell trace mode"
+    set -x
+    ;;
+
+  --dry-run | -n)
+    run=:
+    ;;
+
+  --features)
+    echo "host: $host"
+    if test "$build_libtool_libs" = yes; then
+      echo "enable shared libraries"
+    else
+      echo "disable shared libraries"
+    fi
+    if test "$build_old_libs" = yes; then
+      echo "enable static libraries"
+    else
+      echo "disable static libraries"
+    fi
+    exit 0
+    ;;
+
+  --finish) mode="finish" ;;
+
+  --mode) prevopt="--mode" prev=mode ;;
+  --mode=*) mode="$optarg" ;;
+
+  --quiet | --silent)
+    show=:
+    ;;
+
+  -dlopen)
+    prevopt="-dlopen"
+    prev=execute_dlfiles
+    ;;
+
+  -*)
+    $echo "$modename: unrecognized option \`$arg'" 1>&2
+    $echo "$help" 1>&2
+    exit 1
+    ;;
+
+  *)
+    nonopt="$arg"
+    break
+    ;;
+  esac
+done
+
+if test -n "$prevopt"; then
+  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
+  $echo "$help" 1>&2
+  exit 1
+fi
+
+if test -z "$show_help"; then
+
+  # Infer the operation mode.
+  if test -z "$mode"; then
+    case "$nonopt" in
+    *cc | *++ | gcc* | *-gcc*)
+      mode=link
+      for arg
+      do
+	case "$arg" in
+	-c)
+	   mode=compile
+	   break
+	   ;;
+	esac
+      done
+      ;;
+    *db | *dbx | *strace | *truss)
+      mode=execute
+      ;;
+    *install*|cp|mv)
+      mode=install
+      ;;
+    *rm)
+      mode=uninstall
+      ;;
+    *)
+      # If we have no mode, but dlfiles were specified, then do execute mode.
+      test -n "$execute_dlfiles" && mode=execute
+
+      # Just use the default operation mode.
+      if test -z "$mode"; then
+	if test -n "$nonopt"; then
+	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
+	else
+	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
+	fi
+      fi
+      ;;
+    esac
+  fi
+
+  # Only execute mode is allowed to have -dlopen flags.
+  if test -n "$execute_dlfiles" && test "$mode" != execute; then
+    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
+    $echo "$help" 1>&2
+    exit 1
+  fi
+
+  # Change the help message to a mode-specific one.
+  generic_help="$help"
+  help="Try \`$modename --help --mode=$mode' for more information."
+
+  # These modes are in order of execution frequency so that they run quickly.
+  case "$mode" in
+  # libtool compile mode
+  compile)
+    modename="$modename: compile"
+    # Get the compilation command and the source file.
+    base_compile=
+    lastarg=
+    srcfile="$nonopt"
+    suppress_output=
+
+    user_target=no
+    for arg
+    do
+      # Accept any command-line options.
+      case "$arg" in
+      -o)
+	if test "$user_target" != "no"; then
+	  $echo "$modename: you cannot specify \`-o' more than once" 1>&2
+	  exit 1
+	fi
+	user_target=next
+	;;
+
+      -static)
+	build_old_libs=yes
+	continue
+	;;
+      esac
+
+      case "$user_target" in
+      next)
+	# The next one is the -o target name
+	user_target=yes
+	continue
+	;;
+      yes)
+	# We got the output file
+	user_target=set
+	libobj="$arg"
+	continue
+	;;
+      esac
+
+      # Accept the current argument as the source file.
+      lastarg="$srcfile"
+      srcfile="$arg"
+
+      # Aesthetically quote the previous argument.
+
+      # Backslashify any backslashes, double quotes, and dollar signs.
+      # These are the only characters that are still specially
+      # interpreted inside of double-quoted scrings.
+      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
+
+      # Double-quote args containing other shell metacharacters.
+      # Many Bourne shells cannot handle close brackets correctly in scan
+      # sets, so we specify it separately.
+      case "$lastarg" in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
+	lastarg="\"$lastarg\""
+	;;
+      esac
+
+      # Add the previous argument to base_compile.
+      if test -z "$base_compile"; then
+	base_compile="$lastarg"
+      else
+	base_compile="$base_compile $lastarg"
+      fi
+    done
+
+    case "$user_target" in
+    set)
+      ;;
+    no)
+      # Get the name of the library object.
+      libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
+      ;;
+    *)
+      $echo "$modename: you must specify a target with \`-o'" 1>&2
+      exit 1
+      ;;
+    esac
+
+    # Recognize several different file suffixes.
+    # If the user specifies -o file.o, it is replaced with file.lo
+    xform='[cCFSfmso]'
+    case "$libobj" in
+    *.ada) xform=ada ;;
+    *.adb) xform=adb ;;
+    *.ads) xform=ads ;;
+    *.asm) xform=asm ;;
+    *.c++) xform=c++ ;;
+    *.cc) xform=cc ;;
+    *.cpp) xform=cpp ;;
+    *.cxx) xform=cxx ;;
+    *.f90) xform=f90 ;;
+    *.for) xform=for ;;
+    esac
+
+    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
+
+    case "$libobj" in
+    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
+    *)
+      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
+      exit 1
+      ;;
+    esac
+
+    if test -z "$base_compile"; then
+      $echo "$modename: you must specify a compilation command" 1>&2
+      $echo "$help" 1>&2
+      exit 1
+    fi
+
+    # Delete any leftover library objects.
+    if test "$build_old_libs" = yes; then
+      removelist="$obj $libobj"
+    else
+      removelist="$libobj"
+    fi
+
+    $run $rm $removelist
+    trap "$run $rm $removelist; exit 1" 1 2 15
+
+    # Calculate the filename of the output object if compiler does
+    # not support -o with -c
+    if test "$compiler_c_o" = no; then
+      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\..*$%%'`.${objext}
+      lockfile="$output_obj.lock"
+      removelist="$removelist $output_obj $lockfile"
+      trap "$run $rm $removelist; exit 1" 1 2 15
+    else
+      need_locks=no
+      lockfile=
+    fi
+
+    # Lock this critical section if it is needed
+    # We use this script file to make the link, it avoids creating a new file
+    if test "$need_locks" = yes; then
+      until ln "$0" "$lockfile" 2>/dev/null; do
+	$show "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    elif test "$need_locks" = warn; then
+      if test -f "$lockfile"; then
+	echo "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit 1
+      fi
+      echo $srcfile > "$lockfile"
+    fi
+
+    if test -n "$fix_srcfile_path"; then
+      eval srcfile=\"$fix_srcfile_path\"
+    fi
+
+    # Only build a PIC object if we are building libtool libraries.
+    if test "$build_libtool_libs" = yes; then
+      # Without this assignment, base_compile gets emptied.
+      fbsd_hideous_sh_bug=$base_compile
+
+      # All platforms use -DPIC, to notify preprocessed assembler code.
+      command="$base_compile $srcfile $pic_flag -DPIC"
+      if test "$build_old_libs" = yes; then
+	lo_libobj="$libobj"
+	dir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
+	if test "X$dir" = "X$libobj"; then
+	  dir="$objdir"
+	else
+	  dir="$dir/$objdir"
+	fi
+	libobj="$dir/"`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
+
+	if test -d "$dir"; then
+	  $show "$rm $libobj"
+	  $run $rm $libobj
+	else
+	  $show "$mkdir $dir"
+	  $run $mkdir $dir
+	  status=$?
+	  if test $status -ne 0 && test ! -d $dir; then
+	    exit $status
+	  fi
+	fi
+      fi
+      if test "$compiler_o_lo" = yes; then
+	output_obj="$libobj"
+	command="$command -o $output_obj"
+      elif test "$compiler_c_o" = yes; then
+	output_obj="$obj"
+	command="$command -o $output_obj"
+      fi
+
+      $run $rm "$output_obj"
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	test -n "$output_obj" && $run $rm $removelist
+	exit 1
+      fi
+
+      if test "$need_locks" = warn &&
+	 test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
+	echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit 1
+      fi
+
+      # Just move the object if needed, then go on to compile the next one
+      if test x"$output_obj" != x"$libobj"; then
+	$show "$mv $output_obj $libobj"
+	if $run $mv $output_obj $libobj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # If we have no pic_flag, then copy the object into place and finish.
+      if test -z "$pic_flag" && test "$build_old_libs" = yes; then
+	# Rename the .lo from within objdir to obj
+	if test -f $obj; then
+	  $show $rm $obj
+	  $run $rm $obj
+	fi
+
+	$show "$mv $libobj $obj"
+	if $run $mv $libobj $obj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+
+	xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
+	if test "X$xdir" = "X$obj"; then
+	  xdir="."
+	else
+	  xdir="$xdir"
+	fi
+	baseobj=`$echo "X$obj" | $Xsed -e "s%.*/%%"`
+	libobj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
+	# Now arrange that obj and lo_libobj become the same file
+	$show "(cd $xdir && $LN_S $baseobj $libobj)"
+	if $run eval '(cd $xdir && $LN_S $baseobj $libobj)'; then
+	  exit 0
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Allow error messages only from the first compilation.
+      suppress_output=' >/dev/null 2>&1'
+    fi
+
+    # Only build a position-dependent object if we build old libraries.
+    if test "$build_old_libs" = yes; then
+      command="$base_compile $srcfile"
+      if test "$compiler_c_o" = yes; then
+	command="$command -o $obj"
+	output_obj="$obj"
+      fi
+
+      # Suppress compiler output if we already did a PIC compilation.
+      command="$command$suppress_output"
+      $run $rm "$output_obj"
+      $show "$command"
+      if $run eval "$command"; then :
+      else
+	$run $rm $removelist
+	exit 1
+      fi
+
+      if test "$need_locks" = warn &&
+	 test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
+	echo "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$run $rm $removelist
+	exit 1
+      fi
+
+      # Just move the object if needed
+      if test x"$output_obj" != x"$obj"; then
+	$show "$mv $output_obj $obj"
+	if $run $mv $output_obj $obj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+
+      # Create an invalid libtool object if no PIC, so that we do not
+      # accidentally link it into a program.
+      if test "$build_libtool_libs" != yes; then
+	$show "echo timestamp > $libobj"
+	$run eval "echo timestamp > \$libobj" || exit $?
+      else
+	# Move the .lo from within objdir
+	$show "$mv $libobj $lo_libobj"
+	if $run $mv $libobj $lo_libobj; then :
+	else
+	  error=$?
+	  $run $rm $removelist
+	  exit $error
+	fi
+      fi
+    fi
+
+    # Unlock the critical section if it was locked
+    if test "$need_locks" != no; then
+      $rm "$lockfile"
+    fi
+
+    exit 0
+    ;;
+
+  # libtool link mode
+  link)
+    modename="$modename: link"
+    case "$host" in
+    *-*-cygwin* | *-*-mingw* | *-*-os2*)
+      # It is impossible to link a dll without this setting, and
+      # we shouldn't force the makefile maintainer to figure out
+      # which system we are compiling for in order to pass an extra
+      # flag for every libtool invokation.
+      # allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll which has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      allow_undefined=yes
+
+      # This is a source program that is used to create dlls on Windows
+      # Don't remove nor modify the starting and closing comments
+# /* ltdll.c starts here */
+# #define WIN32_LEAN_AND_MEAN
+# #include <windows.h>
+# #undef WIN32_LEAN_AND_MEAN
+# #include <stdio.h>
+#
+# #ifndef __CYGWIN__
+# #  ifdef __CYGWIN32__
+# #    define __CYGWIN__ __CYGWIN32__
+# #  endif
+# #endif
+#
+# #ifdef __cplusplus
+# extern "C" {
+# #endif
+# BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved);
+# #ifdef __cplusplus
+# }
+# #endif
+#
+# #ifdef __CYGWIN__
+# #include <cygwin/cygwin_dll.h>
+# DECLARE_CYGWIN_DLL( DllMain );
+# #endif
+# HINSTANCE __hDllInstance_base;
+#
+# BOOL APIENTRY
+# DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
+# {
+#   __hDllInstance_base = hInst;
+#   return TRUE;
+# }
+# /* ltdll.c ends here */
+      # This is a source program that is used to create import libraries
+      # on Windows for dlls which lack them. Don't remove nor modify the
+      # starting and closing comments
+# /* impgen.c starts here */
+# /*   Copyright (C) 1999 Free Software Foundation, Inc.
+# 
+#  This file is part of GNU libtool.
+# 
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+# 
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+# 
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#  */
+# 
+#  #include <stdio.h>		/* for printf() */
+#  #include <unistd.h>		/* for open(), lseek(), read() */
+#  #include <fcntl.h>		/* for O_RDONLY, O_BINARY */
+#  #include <string.h>		/* for strdup() */
+# 
+#  static unsigned int
+#  pe_get16 (fd, offset)
+#       int fd;
+#       int offset;
+#  {
+#    unsigned char b[2];
+#    lseek (fd, offset, SEEK_SET);
+#    read (fd, b, 2);
+#    return b[0] + (b[1]<<8);
+#  }
+# 
+#  static unsigned int
+#  pe_get32 (fd, offset)
+#      int fd;
+#      int offset;
+#  {
+#    unsigned char b[4];
+#    lseek (fd, offset, SEEK_SET);
+#    read (fd, b, 4);
+#    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
+#  }
+# 
+#  static unsigned int
+#  pe_as32 (ptr)
+#       void *ptr;
+#  {
+#    unsigned char *b = ptr;
+#    return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
+#  }
+# 
+#  int
+#  main (argc, argv)
+#      int argc;
+#      char *argv[];
+#  {
+#      int dll;
+#      unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
+#      unsigned long export_rva, export_size, nsections, secptr, expptr;
+#      unsigned long name_rvas, nexp;
+#      unsigned char *expdata, *erva;
+#      char *filename, *dll_name;
+# 
+#      filename = argv[1];
+# 
+#      dll = open(filename, O_RDONLY|O_BINARY);
+#      if (!dll)
+#  	return 1;
+# 
+#      dll_name = filename;
+#    
+#      for (i=0; filename[i]; i++)
+#  	if (filename[i] == '/' || filename[i] == '\\'  || filename[i] == ':')
+#  	    dll_name = filename + i +1;
+# 
+#      pe_header_offset = pe_get32 (dll, 0x3c);
+#      opthdr_ofs = pe_header_offset + 4 + 20;
+#      num_entries = pe_get32 (dll, opthdr_ofs + 92);
+# 
+#      if (num_entries < 1) /* no exports */
+#  	return 1;
+# 
+#      export_rva = pe_get32 (dll, opthdr_ofs + 96);
+#      export_size = pe_get32 (dll, opthdr_ofs + 100);
+#      nsections = pe_get16 (dll, pe_header_offset + 4 +2);
+#      secptr = (pe_header_offset + 4 + 20 +
+#  	      pe_get16 (dll, pe_header_offset + 4 + 16));
+# 
+#      expptr = 0;
+#      for (i = 0; i < nsections; i++)
+#      {
+#  	char sname[8];
+#  	unsigned long secptr1 = secptr + 40 * i;
+#  	unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
+#  	unsigned long vsize = pe_get32 (dll, secptr1 + 16);
+#  	unsigned long fptr = pe_get32 (dll, secptr1 + 20);
+#  	lseek(dll, secptr1, SEEK_SET);
+#  	read(dll, sname, 8);
+#  	if (vaddr <= export_rva && vaddr+vsize > export_rva)
+#  	{
+#  	    expptr = fptr + (export_rva - vaddr);
+#  	    if (export_rva + export_size > vaddr + vsize)
+#  		export_size = vsize - (export_rva - vaddr);
+#  	    break;
+#  	}
+#      }
+# 
+#      expdata = (unsigned char*)malloc(export_size);
+#      lseek (dll, expptr, SEEK_SET);
+#      read (dll, expdata, export_size);
+#      erva = expdata - export_rva;
+# 
+#      nexp = pe_as32 (expdata+24);
+#      name_rvas = pe_as32 (expdata+32);
+# 
+#      printf ("EXPORTS\n");
+#      for (i = 0; i<nexp; i++)
+#      {
+#  	unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);
+#  	printf ("\t%s @ %ld ;\n", erva+name_rva, 1+ i);
+#      }
+# 
+#      return 0;
+#  }
+# /* impgen.c ends here */
+      ;;
+    *)
+      allow_undefined=yes
+      ;;
+    esac
+    compile_command="$nonopt"
+    finalize_command="$nonopt"
+
+    compile_rpath=
+    finalize_rpath=
+    compile_shlibpath=
+    finalize_shlibpath=
+    convenience=
+    old_convenience=
+    deplibs=
+    linkopts=
+
+    if test -n "$shlibpath_var"; then
+      # get the directories listed in $shlibpath_var
+      eval lib_search_path=\`\$echo \"X \${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
+    else
+      lib_search_path=
+    fi
+    # now prepend the system-specific ones
+    eval lib_search_path=\"$sys_lib_search_path_spec\$lib_search_path\"
+    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+    
+    avoid_version=no
+    dlfiles=
+    dlprefiles=
+    dlself=no
+    export_dynamic=no
+    export_symbols=
+    export_symbols_regex=
+    generated=
+    libobjs=
+    link_against_libtool_libs=
+    ltlibs=
+    module=no
+    objs=
+    prefer_static_libs=no
+    preload=no
+    prev=
+    prevarg=
+    release=
+    rpath=
+    xrpath=
+    perm_rpath=
+    temp_rpath=
+    thread_safe=no
+    vinfo=
+
+    # We need to know -static, to get the right output filenames.
+    for arg
+    do
+      case "$arg" in
+      -all-static | -static)
+	if test "X$arg" = "X-all-static"; then
+	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
+	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
+	  fi
+	  if test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	else
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	fi
+	build_libtool_libs=no
+	build_old_libs=yes
+	prefer_static_libs=yes
+	break
+	;;
+      esac
+    done
+
+    # See if our shared archives depend on static archives.
+    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+    # Go through the arguments, transforming them on the way.
+    while test $# -gt 0; do
+      arg="$1"
+      shift
+
+      # If the previous option needs an argument, assign it.
+      if test -n "$prev"; then
+	case "$prev" in
+	output)
+	  compile_command="$compile_command @OUTPUT@"
+	  finalize_command="$finalize_command @OUTPUT@"
+	  ;;
+	esac
+
+	case "$prev" in
+	dlfiles|dlprefiles)
+	  if test "$preload" = no; then
+	    # Add the symbol object into the linking commands.
+	    compile_command="$compile_command @SYMFILE@"
+	    finalize_command="$finalize_command @SYMFILE@"
+	    preload=yes
+	  fi
+	  case "$arg" in
+	  *.la | *.lo) ;;  # We handle these cases below.
+	  force)
+	    if test "$dlself" = no; then
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  self)
+	    if test "$prev" = dlprefiles; then
+	      dlself=yes
+	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
+	      dlself=yes
+	    else
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  *)
+	    if test "$prev" = dlfiles; then
+	      dlfiles="$dlfiles $arg"
+	    else
+	      dlprefiles="$dlprefiles $arg"
+	    fi
+	    prev=
+	    ;;
+	  esac
+	  ;;
+	expsyms)
+	  export_symbols="$arg"
+	  if test ! -f "$arg"; then
+	    $echo "$modename: symbol file \`$arg' does not exist"
+	    exit 1
+	  fi
+	  prev=
+	  continue
+	  ;;
+	expsyms_regex)
+	  export_symbols_regex="$arg"
+	  prev=
+	  continue
+	  ;;
+	release)
+	  release="-$arg"
+	  prev=
+	  continue
+	  ;;
+	rpath | xrpath)
+	  # We need an absolute path.
+	  case "$arg" in
+	  [\\/]* | [A-Za-z]:[\\/]*) ;;
+	  *)
+	    $echo "$modename: only absolute run-paths are allowed" 1>&2
+	    exit 1
+	    ;;
+	  esac
+	  if test "$prev" = rpath; then
+	    case "$rpath " in
+	    *" $arg "*) ;;
+	    *) rpath="$rpath $arg" ;;
+	    esac
+	  else
+	    case "$xrpath " in
+	    *" $arg "*) ;;
+	    *) xrpath="$xrpath $arg" ;;
+	    esac
+	  fi
+	  prev=
+	  continue
+	  ;;
+	*)
+	  eval "$prev=\"\$arg\""
+	  prev=
+	  continue
+	  ;;
+	esac
+      fi
+
+      prevarg="$arg"
+
+      case "$arg" in
+      -all-static)
+	if test -n "$link_static_flag"; then
+	  compile_command="$compile_command $link_static_flag"
+	  finalize_command="$finalize_command $link_static_flag"
+	fi
+	continue
+	;;
+
+      -allow-undefined)
+	# FIXME: remove this flag sometime in the future.
+	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
+	continue
+	;;
+
+      -avoid-version)
+	avoid_version=yes
+	continue
+	;;
+
+      -dlopen)
+	prev=dlfiles
+	continue
+	;;
+
+      -dlpreopen)
+	prev=dlprefiles
+	continue
+	;;
+
+      -export-dynamic)
+	export_dynamic=yes
+	continue
+	;;
+
+      -export-symbols | -export-symbols-regex)
+	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	  $echo "$modename: not more than one -exported-symbols argument allowed"
+	  exit 1
+	fi
+	if test "X$arg" = "X-export-symbols"; then
+	  prev=expsyms
+	else
+	  prev=expsyms_regex
+	fi
+	continue
+	;;
+
+      -L*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
+	# We need an absolute path.
+	case "$dir" in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  absdir=`cd "$dir" && pwd`
+	  if test -z "$absdir"; then
+	    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
+	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
+	    absdir="$dir"
+	  fi
+	  dir="$absdir"
+	  ;;
+	esac
+	case " $deplibs " in
+	*" $arg "*) ;;
+	*) deplibs="$deplibs $arg";;
+	esac
+	case " $lib_search_path " in
+	*" $dir "*) ;;
+	*) lib_search_path="$lib_search_path $dir";;
+	esac
+	case "$host" in
+	*-*-cygwin* | *-*-mingw* | *-*-os2*)
+	  dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
+	  case ":$dllsearchpath:" in
+	  ::) dllsearchpath="$dllsearchdir";;
+	  *":$dllsearchdir:"*) ;;
+	  *) dllsearchpath="$dllsearchpath:$dllsearchdir";;
+	  esac
+	  ;;
+	esac
+	;;
+
+      -l*)
+	if test "$arg" = "-lc"; then
+	  case "$host" in
+	  *-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)
+	    # These systems don't actually have c library (as such)
+	    continue
+	    ;;
+	  esac
+	elif test "$arg" = "-lm"; then
+	  case "$host" in
+	  *-*-cygwin* | *-*-beos*)
+	    # These systems don't actually have math library (as such)
+	    continue
+	    ;;
+	  esac
+	fi
+	deplibs="$deplibs $arg"
+	;;
+
+      -module)
+	module=yes
+	continue
+	;;
+
+      -no-undefined)
+	allow_undefined=no
+	continue
+	;;
+
+      -o) prev=output ;;
+
+      -release)
+	prev=release
+	continue
+	;;
+
+      -rpath)
+	prev=rpath
+	continue
+	;;
+
+      -R)
+	prev=xrpath
+	continue
+	;;
+
+      -R*)
+	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
+	# We need an absolute path.
+	case "$dir" in
+	[\\/]* | [A-Za-z]:[\\/]*) ;;
+	*)
+	  $echo "$modename: only absolute run-paths are allowed" 1>&2
+	  exit 1
+	  ;;
+	esac
+	case "$xrpath " in
+	*" $dir "*) ;;
+	*) xrpath="$xrpath $dir" ;;
+	esac
+	continue
+	;;
+
+      -static)
+	# If we have no pic_flag, then this is the same as -all-static.
+	if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	  compile_command="$compile_command $link_static_flag"
+	  finalize_command="$finalize_command $link_static_flag"
+	fi
+	continue
+	;;
+
+      -thread-safe)
+	thread_safe=yes
+	continue
+	;;
+
+      -version-info)
+	prev=vinfo
+	continue
+	;;
+
+      # Some other compiler flag.
+      -* | +*)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case "$arg" in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+
+      *.o | *.obj | *.a | *.lib)
+	# A standard object.
+	objs="$objs $arg"
+	;;
+
+      *.lo)
+	# A library object.
+	if test "$prev" = dlfiles; then
+	  dlfiles="$dlfiles $arg"
+	  if test "$build_libtool_libs" = yes && test "$dlopen" = yes; then
+	    prev=
+	    continue
+	  else
+	    # If libtool objects are unsupported, then we need to preload.
+	    prev=dlprefiles
+	  fi
+	fi
+
+	if test "$prev" = dlprefiles; then
+	  # Preload the old-style object.
+	  dlprefiles="$dlprefiles "`$echo "X$arg" | $Xsed -e "$lo2o"`
+	  prev=
+	fi
+	libobjs="$libobjs $arg"
+	;;
+
+      *.la)
+	# A libtool-controlled library.
+
+	dlname=
+	libdir=
+	library_names=
+	old_library=
+
+	# Check to see that this really is a libtool archive.
+	if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$arg' is not a valid libtool archive" 1>&2
+	  exit 1
+	fi
+
+	# If the library was installed with an old release of libtool,
+	# it will not redefine variable installed.
+	installed=yes
+
+	# Read the .la file
+	# If there is no directory component, then add one.
+	case "$arg" in
+	*/* | *\\*) . $arg ;;
+	*) . ./$arg ;;
+	esac
+
+	# Get the name of the library we link against.
+	linklib=
+	for l in $old_library $library_names; do
+	  linklib="$l"
+	done
+
+	if test -z "$linklib"; then
+	  $echo "$modename: cannot find name of link library for \`$arg'" 1>&2
+	  exit 1
+	fi
+
+	# Find the relevant object directory and library name.
+	name=`$echo "X$arg" | $Xsed -e 's%^.*/%%' -e 's/\.la$//' -e 's/^lib//'`
+
+	if test "X$installed" = Xyes; then
+	  dir="$libdir"
+	else
+	  dir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
+	  if test "X$dir" = "X$arg"; then
+	    dir="$objdir"
+	  else
+	    dir="$dir/$objdir"
+	  fi
+	fi
+
+	if test -n "$dependency_libs"; then
+	  # Extract -R and -L from dependency_libs
+	  temp_deplibs=
+	  for deplib in $dependency_libs; do
+	    case "$deplib" in
+	    -R*) temp_xrpath=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
+		 case " $rpath $xrpath " in
+		 *" $temp_xrpath "*) ;;
+		 *) xrpath="$xrpath $temp_xrpath";;
+		 esac;;
+	    -L*) case "$compile_command $temp_deplibs " in
+		 *" $deplib "*) ;;
+		 *) temp_deplibs="$temp_deplibs $deplib";;
+		 esac
+		 temp_dir=`$echo "X$deplib" | $Xsed -e 's/^-L//'`
+		 case " $lib_search_path " in
+		 *" $temp_dir "*) ;;
+		 *) lib_search_path="$lib_search_path $temp_dir";;
+		 esac
+		 ;;
+	    *) temp_deplibs="$temp_deplibs $deplib";;
+	    esac
+	  done
+	  dependency_libs="$temp_deplibs"
+	fi
+
+	if test -z "$libdir"; then
+	  # It is a libtool convenience library, so add in its objects.
+	  convenience="$convenience $dir/$old_library"
+	  old_convenience="$old_convenience $dir/$old_library"
+	  deplibs="$deplibs$dependency_libs"
+	  compile_command="$compile_command $dir/$old_library$dependency_libs"
+	  finalize_command="$finalize_command $dir/$old_library$dependency_libs"
+	  continue
+	fi
+
+	# This library was specified with -dlopen.
+	if test "$prev" = dlfiles; then
+	  dlfiles="$dlfiles $arg"
+	  if test -z "$dlname" || test "$dlopen" != yes || test "$build_libtool_libs" = no; then
+	    # If there is no dlname, no dlopen support or we're linking statically,
+	    # we need to preload.
+	    prev=dlprefiles
+	  else
+	    # We should not create a dependency on this library, but we
+	    # may need any libraries it requires.
+	    compile_command="$compile_command$dependency_libs"
+	    finalize_command="$finalize_command$dependency_libs"
+	    prev=
+	    continue
+	  fi
+	fi
+
+	# The library was specified with -dlpreopen.
+	if test "$prev" = dlprefiles; then
+	  # Prefer using a static library (so that no silly _DYNAMIC symbols
+	  # are required to link).
+	  if test -n "$old_library"; then
+	    dlprefiles="$dlprefiles $dir/$old_library"
+	  else
+	    dlprefiles="$dlprefiles $dir/$linklib"
+	  fi
+	  prev=
+	fi
+
+	if test -n "$library_names" &&
+	   { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
+	  link_against_libtool_libs="$link_against_libtool_libs $arg"
+	  if test -n "$shlibpath_var"; then
+	    # Make sure the rpath contains only unique directories.
+	    case "$temp_rpath " in
+	    *" $dir "*) ;;
+	    *) temp_rpath="$temp_rpath $dir" ;;
+	    esac
+	  fi
+
+	  # We need an absolute path.
+	  case "$dir" in
+	  [\\/] | [A-Za-z]:[\\/]*) absdir="$dir" ;;
+	  *)
+	    absdir=`cd "$dir" && pwd`
+	    if test -z "$absdir"; then
+	      $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
+	      $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
+	      absdir="$dir"
+	    fi
+	    ;;
+	  esac
+	  
+	  # This is the magic to use -rpath.
+	  # Skip directories that are in the system default run-time
+	  # search path, unless they have been requested with -R.
+	  case " $sys_lib_dlsearch_path " in
+	  *" $absdir "*) ;;
+	  *)
+	    case "$compile_rpath " in
+	    *" $absdir "*) ;;
+	    *) compile_rpath="$compile_rpath $absdir" 
+	    esac
+	    ;;
+	  esac
+
+	  case " $sys_lib_dlsearch_path " in
+	  *" $libdir "*) ;;
+	  *)
+	    case "$finalize_rpath " in
+	    *" $libdir "*) ;;
+	    *) finalize_rpath="$finalize_rpath $libdir"
+	    esac
+	    ;;
+	  esac
+
+	  lib_linked=yes
+	  case "$hardcode_action" in
+	  immediate | unsupported)
+	    if test "$hardcode_direct" = no; then
+	      compile_command="$compile_command $dir/$linklib"
+	      deplibs="$deplibs $dir/$linklib"
+	      case "$host" in
+	      *-*-cygwin* | *-*-mingw* | *-*-os2*)
+		dllsearchdir=`cd "$dir" && pwd || echo "$dir"`
+		if test -n "$dllsearchpath"; then
+		  dllsearchpath="$dllsearchpath:$dllsearchdir"
+		else
+		  dllsearchpath="$dllsearchdir"
+		fi
+		;;
+	      esac
+	    elif test "$hardcode_minus_L" = no; then
+	      case "$host" in
+	      *-*-sunos*)
+		compile_shlibpath="$compile_shlibpath$dir:"
+		;;
+	      esac
+	      case "$compile_command " in
+	      *" -L$dir "*) ;;
+	      *) compile_command="$compile_command -L$dir";;
+	      esac
+	      compile_command="$compile_command -l$name"
+	      deplibs="$deplibs -L$dir -l$name"
+	    elif test "$hardcode_shlibpath_var" = no; then
+	      case ":$compile_shlibpath:" in
+	      *":$dir:"*) ;;
+	      *) compile_shlibpath="$compile_shlibpath$dir:";;
+	      esac
+	      compile_command="$compile_command -l$name"
+	      deplibs="$deplibs -l$name"
+	    else
+	      lib_linked=no
+	    fi
+	    ;;
+
+	  relink)
+	    if test "$hardcode_direct" = yes; then
+	      compile_command="$compile_command $absdir/$linklib"
+	      deplibs="$deplibs $absdir/$linklib"
+	    elif test "$hardcode_minus_L" = yes; then
+	      case "$compile_command " in
+	      *" -L$absdir "*) ;;
+	      *) compile_command="$compile_command -L$absdir";;
+	      esac
+	      compile_command="$compile_command -l$name"
+	      deplibs="$deplibs -L$absdir -l$name"
+	    elif test "$hardcode_shlibpath_var" = yes; then
+	      case ":$compile_shlibpath:" in
+	      *":$absdir:"*) ;;
+	      *) compile_shlibpath="$compile_shlibpath$absdir:";;
+	      esac
+	      compile_command="$compile_command -l$name"
+	      deplibs="$deplibs -l$name"
+	    else
+	      lib_linked=no
+	    fi
+	    ;;
+
+	  *)
+	    lib_linked=no
+	    ;;
+	  esac
+
+	  if test "$lib_linked" != yes; then
+	    $echo "$modename: configuration error: unsupported hardcode properties"
+	    exit 1
+	  fi
+
+	  # Finalize command for both is simple: just hardcode it.
+	  if test "$hardcode_direct" = yes; then
+	    finalize_command="$finalize_command $libdir/$linklib"
+	  elif test "$hardcode_minus_L" = yes; then
+	    case "$finalize_command " in
+	    *" -L$libdir "*) ;;
+	    *) finalize_command="$finalize_command -L$libdir";;
+	    esac
+	    finalize_command="$finalize_command -l$name"
+	  elif test "$hardcode_shlibpath_var" = yes; then
+	    case ":$finalize_shlibpath:" in
+	    *":$libdir:"*) ;;
+	    *) finalize_shlibpath="$finalize_shlibpath$libdir:";;
+	    esac
+	    finalize_command="$finalize_command -l$name"
+	  else
+	    # We cannot seem to hardcode it, guess we'll fake it.
+	    case "$finalize_command " in
+	    *" -L$dir "*) ;;
+	    *) finalize_command="$finalize_command -L$libdir";;
+	    esac
+	    finalize_command="$finalize_command -l$name"
+	  fi
+	else
+	  # Transform directly to old archives if we don't build new libraries.
+	  if test -n "$pic_flag" && test -z "$old_library"; then
+	    $echo "$modename: cannot find static library for \`$arg'" 1>&2
+	    exit 1
+	  fi
+
+	  # Here we assume that one of hardcode_direct or hardcode_minus_L
+	  # is not unsupported.  This is valid on all known static and
+	  # shared platforms.
+	  if test "$hardcode_direct" != unsupported; then
+	    test -n "$old_library" && linklib="$old_library"
+	    compile_command="$compile_command $dir/$linklib"
+	    finalize_command="$finalize_command $dir/$linklib"
+	  else
+	    case "$compile_command " in
+	    *" -L$dir "*) ;;
+	    *) compile_command="$compile_command -L$dir";;
+	    esac
+	    compile_command="$compile_command -l$name"
+	    case "$finalize_command " in
+	    *" -L$dir "*) ;;
+	    *) finalize_command="$finalize_command -L$dir";;
+	    esac
+	    finalize_command="$finalize_command -l$name"
+	  fi
+	fi
+
+	# Add in any libraries that this one depends upon.
+	compile_command="$compile_command$dependency_libs"
+	finalize_command="$finalize_command$dependency_libs"
+	continue
+	;;
+
+      # Some other compiler argument.
+      *)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+	case "$arg" in
+	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
+	  arg="\"$arg\""
+	  ;;
+	esac
+	;;
+      esac
+
+      # Now actually substitute the argument into the commands.
+      if test -n "$arg"; then
+	compile_command="$compile_command $arg"
+	finalize_command="$finalize_command $arg"
+      fi
+    done
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit 1
+    fi
+
+    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
+      eval arg=\"$export_dynamic_flag_spec\"
+      compile_command="$compile_command $arg"
+      finalize_command="$finalize_command $arg"
+    fi
+
+    oldlibs=
+    # calculate the name of the file, without its directory
+    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
+    libobjs_save="$libobjs"
+
+    case "$output" in
+    "")
+      $echo "$modename: you must specify an output file" 1>&2
+      $echo "$help" 1>&2
+      exit 1
+      ;;
+
+    *.a | *.lib)
+      if test -n "$link_against_libtool_libs"; then
+	$echo "$modename: error: cannot link libtool libraries into archives" 1>&2
+	exit 1
+      fi
+
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
+      fi
+
+      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
+      fi
+
+      # Now set the variables for building old libraries.
+      build_libtool_libs=no
+      oldlibs="$output"
+      ;;
+
+    *.la)
+      # Make sure we only generate libraries of the form `libNAME.la'.
+      case "$outputname" in
+      lib*)
+	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
+	eval libname=\"$libname_spec\"
+	;;
+      *)
+	if test "$module" = no; then
+	  $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
+	  $echo "$help" 1>&2
+	  exit 1
+	fi
+	if test "$need_lib_prefix" != no; then
+	  # Add the "lib" prefix for modules if required
+	  name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	  eval libname=\"$libname_spec\"
+	else
+	  libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
+	fi
+	;;
+      esac
+
+      output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
+      if test "X$output_objdir" = "X$output"; then
+	output_objdir="$objdir"
+      else
+	output_objdir="$output_objdir/$objdir"
+      fi
+
+      if test -n "$objs"; then
+	$echo "$modename: cannot build libtool library \`$output' from non-libtool objects:$objs" 2>&1
+	exit 1
+      fi
+
+      # How the heck are we supposed to write a wrapper for a shared library?
+      if test -n "$link_against_libtool_libs"; then
+	 $echo "$modename: error: cannot link shared libraries into libtool libraries" 1>&2
+	 exit 1
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for libtool libraries" 1>&2
+      fi
+
+      set dummy $rpath
+      if test $# -gt 2; then
+	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
+      fi
+      install_libdir="$2"
+
+      oldlibs=
+      if test -z "$rpath"; then
+	if test "$build_libtool_libs" = yes; then
+	  # Building a libtool convenience library.
+	  libext=al
+	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
+	  build_libtool_libs=convenience
+	  build_old_libs=yes
+	fi
+	dependency_libs="$deplibs"
+
+	if test -n "$vinfo"; then
+	  $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
+	fi
+
+	if test -n "$release"; then
+	  $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
+	fi
+      else
+
+	# Parse the version information argument.
+	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS=':'
+	set dummy $vinfo 0 0 0
+	IFS="$save_ifs"
+
+	if test -n "$8"; then
+	  $echo "$modename: too many parameters to \`-version-info'" 1>&2
+	  $echo "$help" 1>&2
+	  exit 1
+	fi
+
+	current="$2"
+	revision="$3"
+	age="$4"
+
+	# Check that each of the things are valid numbers.
+	case "$current" in
+	[0-9]*) ;;
+	*)
+	  $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit 1
+	  ;;
+	esac
+
+	case "$revision" in
+	[0-9]*) ;;
+	*)
+	  $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit 1
+	  ;;
+	esac
+
+	case "$age" in
+	[0-9]*) ;;
+	*)
+	  $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit 1
+	  ;;
+	esac
+
+	if test $age -gt $current; then
+	  $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
+	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
+	  exit 1
+	fi
+
+	# Calculate the version variables.
+	major=
+	versuffix=
+	verstring=
+	case "$version_type" in
+	none) ;;
+
+	irix)
+	  major=`expr $current - $age + 1`
+	  versuffix="$major.$revision"
+	  verstring="sgi$major.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$revision
+	  while test $loop != 0; do
+	    iface=`expr $revision - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="sgi$major.$iface:$verstring"
+	  done
+	  ;;
+
+	linux)
+	  major=.`expr $current - $age`
+	  versuffix="$major.$age.$revision"
+	  ;;
+
+	osf)
+	  major=`expr $current - $age`
+	  versuffix=".$current.$age.$revision"
+	  verstring="$current.$age.$revision"
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$age
+	  while test $loop != 0; do
+	    iface=`expr $current - $loop`
+	    loop=`expr $loop - 1`
+	    verstring="$verstring:${iface}.0"
+	  done
+
+	  # Make executables depend on our current version.
+	  verstring="$verstring:${current}.0"
+	  ;;
+
+	sunos)
+	  major=".$current"
+	  versuffix=".$current.$revision"
+	  ;;
+
+	freebsd-aout)
+	  major=".$current"
+	  versuffix=".$current.$revision";
+	  ;;
+
+	freebsd-elf)
+	  major=".$current"
+	  versuffix=".$current";
+	  ;;
+
+	windows)
+	  # Like Linux, but with '-' rather than '.', since we only
+	  # want one extension on Windows 95.
+	  major=`expr $current - $age`
+	  versuffix="-$major-$age-$revision"
+	  ;;
+
+	*)
+	  $echo "$modename: unknown library version type \`$version_type'" 1>&2
+	  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
+	  exit 1
+	  ;;
+	esac
+
+	# Clear the version info if we defaulted, and they specified a release.
+	if test -z "$vinfo" && test -n "$release"; then
+	  major=
+	  verstring="0.0"
+	  if test "$need_version" = no; then
+	    versuffix=
+	  else
+	    versuffix=".0.0"
+	  fi
+	fi
+
+	# Remove version info from name if versioning should be avoided
+	if test "$avoid_version" = yes && test "$need_version" = no; then
+	  major=
+	  versuffix=
+	  verstring=""
+	fi
+	
+	# Check to see if the archive will have undefined symbols.
+	if test "$allow_undefined" = yes; then
+	  if test "$allow_undefined_flag" = unsupported; then
+	    $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
+	    build_libtool_libs=no
+	    build_old_libs=yes
+	  fi
+	else
+	  # Don't allow undefined symbols.
+	  allow_undefined_flag="$no_undefined_flag"
+	fi
+
+	dependency_libs="$deplibs"
+	case "$host" in
+	*-*-cygwin* | *-*-mingw* | *-*-os2* | *-*-beos*)
+	  # these systems don't actually have a c library (as such)!
+	  ;;
+        *-*-rhapsody*)
+	  # rhapsody is a little odd...
+	  deplibs="$deplibs -framework System"
+	  ;;
+	*)
+	  # Add libc to deplibs on all other systems.
+	  deplibs="$deplibs -lc"
+	  ;;
+	esac
+      fi
+
+      # Create the output directory, or remove our outputs if we need to.
+      if test -d $output_objdir; then
+	$show "${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*"
+	$run ${rm}r $output_objdir/$outputname $output_objdir/$libname.* $output_objdir/${libname}${release}.*
+      else
+	$show "$mkdir $output_objdir"
+	$run $mkdir $output_objdir
+	status=$?
+	if test $status -ne 0 && test ! -d $output_objdir; then
+	  exit $status
+	fi
+      fi
+
+      # Now set the variables for building old libraries.
+      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
+	oldlibs="$oldlibs $output_objdir/$libname.$libext"
+
+	# Transform .lo files to .o files.
+	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
+      fi
+
+      if test "$build_libtool_libs" = yes; then
+	# Transform deplibs into only deplibs that can be linked in shared.
+	name_save=$name
+	libname_save=$libname
+	release_save=$release
+	versuffix_save=$versuffix
+	major_save=$major
+	# I'm not sure if I'm treating the release correctly.  I think
+	# release should show up in the -l (ie -lgmp5) so we don't want to
+	# add it in twice.  Is that correct?
+	release=""
+	versuffix=""
+	major=""
+	newdeplibs=
+	droppeddeps=no
+	case "$deplibs_check_method" in
+	pass_all)
+	  # Don't check for shared/static.  Everything works.
+	  # This might be a little naive.  We might want to check
+	  # whether the library exists or not.  But this is on
+	  # osf3 & osf4 and I'm not really sure... Just
+	  # implementing what was already the behaviour.
+	  newdeplibs=$deplibs
+	  ;;
+	test_compile)
+	  # This code stresses the "libraries are programs" paradigm to its
+	  # limits. Maybe even breaks it.  We compile a program, linking it
+	  # against the deplibs as a proxy for the library.  Then we can check
+	  # whether they linked in statically or dynamically with ldd.
+	  $rm conftest.c
+	  cat > conftest.c <<EOF
+	  int main() { return 0; }
+EOF
+	  $rm conftest
+	  $CC -o conftest conftest.c $deplibs
+	  if test $? -eq 0 ; then
+	    ldd_output=`ldd conftest`
+	    for i in $deplibs; do
+	      name="`expr $i : '-l\(.*\)'`"
+	      # If $name is empty we are operating on a -L argument.
+	      if test "$name" != "" ; then
+		libname=`eval \\$echo \"$libname_spec\"`
+		deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		set dummy $deplib_matches
+		deplib_match=$2
+		if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		  newdeplibs="$newdeplibs $i"
+		else
+		  droppeddeps=yes
+		  echo
+		  echo "*** Warning: This library needs some functionality provided by $i."
+		  echo "*** I have the capability to make that library automatically link in when"
+		  echo "*** you link to this library.  But I can only do this if you have a"
+		  echo "*** shared version of the library, which you do not appear to have."
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  else
+	    # Error occured in the first compile.  Let's try to salvage the situation:
+	    # Compile a seperate program for each library.
+	    for i in $deplibs; do
+	      name="`expr $i : '-l\(.*\)'`"
+	     # If $name is empty we are operating on a -L argument.
+	      if test "$name" != "" ; then
+		$rm conftest
+		$CC -o conftest conftest.c $i
+		# Did it work?
+		if test $? -eq 0 ; then
+		  ldd_output=`ldd conftest`
+		  libname=`eval \\$echo \"$libname_spec\"`
+		  deplib_matches=`eval \\$echo \"$library_names_spec\"`
+		  set dummy $deplib_matches
+		  deplib_match=$2
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+		    newdeplibs="$newdeplibs $i"
+		  else
+		    droppeddeps=yes
+		    echo
+		    echo "*** Warning: This library needs some functionality provided by $i."
+		    echo "*** I have the capability to make that library automatically link in when"
+		    echo "*** you link to this library.  But I can only do this if you have a"
+		    echo "*** shared version of the library, which you do not appear to have."
+		  fi
+		else
+		  droppeddeps=yes
+		  echo
+		  echo "*** Warning!  Library $i is needed by this library but I was not able to"
+		  echo "***  make it link in!  You will probably need to install it or some"
+		  echo "*** library that it depends on before this library will be fully"
+		  echo "*** functional.  Installing it before continuing would be even better."
+		fi
+	      else
+		newdeplibs="$newdeplibs $i"
+	      fi
+	    done
+	  fi
+	  ;;
+	file_magic*)
+	  set dummy $deplibs_check_method
+	  file_magic_regex="`expr \"$deplibs_check_method\" : \"$2 \(.*\)\"`"
+	  for a_deplib in $deplibs; do
+	    name="`expr $a_deplib : '-l\(.*\)'`"
+	    # If $name is empty we are operating on a -L argument.
+	    if test "$name" != "" ; then
+	      libname=`eval \\$echo \"$libname_spec\"`
+	      for i in $lib_search_path; do
+		    potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+		    for potent_lib in $potential_libs; do
+		      # Follow soft links.
+		      if ls -lLd "$potent_lib" 2>/dev/null \
+			 | grep " -> " >/dev/null; then
+			continue 
+		      fi
+		      # The statement above tries to avoid entering an
+		      # endless loop below, in case of cyclic links.
+		      # We might still enter an endless loop, since a link
+		      # loop can be closed while we follow links,
+		      # but so what?
+		      potlib="$potent_lib"
+		      while test -h "$potlib" 2>/dev/null; do
+			potliblink=`ls -ld $potlib | sed 's/.* -> //'`
+			case "$potliblink" in
+			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
+			*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
+			esac
+		      done
+		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
+			 | sed 10q \
+			 | egrep "$file_magic_regex" > /dev/null; then
+			newdeplibs="$newdeplibs $a_deplib"
+			a_deplib=""
+			break 2
+		      fi
+		    done
+	      done
+	      if test -n "$a_deplib" ; then
+		droppeddeps=yes
+		echo
+		echo "*** Warning: This library needs some functionality provided by $a_deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have."
+	      fi
+	    else
+	      # Add a -L argument.
+	      newdeplibs="$newdeplibs $a_deplib"
+	    fi
+	  done # Gone through all deplibs.
+	  ;;
+	none | unknown | *)
+	  newdeplibs=""
+	  if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
+	       -e 's/ -[LR][^ ]*//g' -e 's/[ 	]//g' |
+	     grep . >/dev/null; then
+	    echo
+	    if test "X$deplibs_check_method" = "Xnone"; then
+	      echo "*** Warning: inter-library dependencies are not supported in this platform."
+	    else
+	      echo "*** Warning: inter-library dependencies are not known to be supported."
+	    fi
+	    echo "*** All declared inter-library dependencies are being dropped."
+	    droppeddeps=yes
+	  fi
+	  ;;
+	esac
+	versuffix=$versuffix_save
+	major=$major_save
+	release=$release_save
+	libname=$libname_save
+	name=$name_save
+
+	if test "$droppeddeps" = yes; then
+	  if test "$module" = yes; then
+	    echo
+	    echo "*** Warning: libtool could not satisfy all declared inter-library"
+	    echo "*** dependencies of module $libname.  Therefore, libtool will create"
+	    echo "*** a static module, that should work as long as the dlopening"
+	    echo "*** application is linked with the -dlopen flag."
+	    if test -z "$global_symbol_pipe"; then
+	      echo
+	      echo "*** However, this would only work if libtool was able to extract symbol"
+	      echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+	      echo "*** not find such a program.  So, this module is probably useless."
+	      echo "*** \`nm' from GNU binutils and a full rebuild may help."
+	    fi
+	    if test "$build_old_libs" = no; then
+	      oldlibs="$output_objdir/$libname.$libext"
+	      build_libtool_libs=module
+	      build_old_libs=yes
+	    else
+	      build_libtool_libs=no
+	    fi
+	  else
+	    echo "*** The inter-library dependencies that have been dropped here will be"
+	    echo "*** automatically added whenever a program is linked with this library"
+	    echo "*** or is declared to -dlopen it."
+	  fi
+	fi
+	# Done checking deplibs!
+	deplibs=$newdeplibs
+      fi
+
+      # All the library-specific variables (install_libdir is set above).
+      library_names=
+      old_library=
+      dlname=
+      
+      # Test again, we may have decided not to build it any more
+      if test "$build_libtool_libs" = yes; then
+	# Get the real and link names of the library.
+	eval library_names=\"$library_names_spec\"
+	set dummy $library_names
+	realname="$2"
+	shift; shift
+
+	if test -n "$soname_spec"; then
+	  eval soname=\"$soname_spec\"
+	else
+	  soname="$realname"
+	fi
+
+	lib="$output_objdir/$realname"
+	for link
+	do
+	  linknames="$linknames $link"
+	done
+
+	# Ensure that we have .o objects for linkers which dislike .lo
+	# (e.g. aix) in case we are running --disable-static
+	for obj in $libobjs; do
+	  xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
+	  if test "X$xdir" = "X$obj"; then
+	    xdir="."
+	  else
+	    xdir="$xdir"
+	  fi
+	  baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
+	  oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
+	  if test ! -f $xdir/$oldobj; then
+	    $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
+	    $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
+	  fi
+	done
+
+	# Use standard objects if they are pic
+	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+
+	# Prepare the list of exported symbols
+	if test -z "$export_symbols"; then
+	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
+	    $show "generating symbol list for \`$libname.la'"
+	    export_symbols="$output_objdir/$libname.exp"
+	    $run $rm $export_symbols
+	    eval cmds=\"$export_symbols_cmds\"
+	    IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	    for cmd in $cmds; do
+	      IFS="$save_ifs"
+	      $show "$cmd"
+	      $run eval "$cmd" || exit $?
+	    done
+	    IFS="$save_ifs"
+	    if test -n "$export_symbols_regex"; then
+	      $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
+	      $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      $show "$mv \"${export_symbols}T\" \"$export_symbols\""
+	      $run eval '$mv "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+	fi
+
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
+	fi
+
+	if test -n "$convenience"; then
+	  if test -n "$whole_archive_flag_spec"; then
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	  else
+	    gentop="$output_objdir/${outputname}x"
+	    $show "${rm}r $gentop"
+	    $run ${rm}r "$gentop"
+	    $show "mkdir $gentop"
+	    $run mkdir "$gentop"
+	    status=$?
+	    if test $status -ne 0 && test ! -d "$gentop"; then
+	      exit $status
+	    fi
+	    generated="$generated $gentop"
+
+	    for xlib in $convenience; do
+	      # Extract the objects.
+	      case "$xlib" in
+	      [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
+	      *) xabs=`pwd`"/$xlib" ;;
+	      esac
+	      xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
+	      xdir="$gentop/$xlib"
+
+	      $show "${rm}r $xdir"
+	      $run ${rm}r "$xdir"
+	      $show "mkdir $xdir"
+	      $run mkdir "$xdir"
+	      status=$?
+	      if test $status -ne 0 && test ! -d "$xdir"; then
+		exit $status
+	      fi
+	      $show "(cd $xdir && $AR x $xabs)"
+	      $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
+
+	      libobjs="$libobjs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
+	    done
+	  fi
+	fi
+
+	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
+	  eval flag=\"$thread_safe_flag_spec\"
+	  linkopts="$linkopts $flag"
+	fi
+
+	# Do each of the archive commands.
+	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	  eval cmds=\"$archive_expsym_cmds\"
+	else
+	  eval cmds=\"$archive_cmds\"
+	fi
+	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  $show "$cmd"
+	  $run eval "$cmd" || exit $?
+	done
+	IFS="$save_ifs"
+
+	# Create links to the real library.
+	for linkname in $linknames; do
+	  if test "$realname" != "$linkname"; then
+	    $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
+	    $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
+	  fi
+	done
+
+	# If -module or -export-dynamic was specified, set the dlname.
+	if test "$module" = yes || test "$export_dynamic" = yes; then
+	  # On all known operating systems, these are identical.
+	  dlname="$soname"
+	fi
+      fi
+      ;;
+
+    *.lo | *.o | *.obj)
+      if test -n "$link_against_libtool_libs"; then
+	$echo "$modename: error: cannot link libtool libraries into objects" 1>&2
+	exit 1
+      fi
+
+      if test -n "$deplibs"; then
+	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
+      fi
+
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$rpath"; then
+	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$xrpath"; then
+	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
+      fi
+
+      case "$output" in
+      *.lo)
+	if test -n "$objs"; then
+	  $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
+	  exit 1
+	fi
+	libobj="$output"
+	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
+	;;
+      *)
+	libobj=
+	obj="$output"
+	;;
+      esac
+
+      # Delete the old objects.
+      $run $rm $obj $libobj
+
+      # Objects from convenience libraries.  This assumes
+      # single-version convenience libraries.  Whenever we create
+      # different ones for PIC/non-PIC, this we'll have to duplicate
+      # the extraction.
+      reload_conv_objs=
+      gentop=
+      # reload_cmds runs $LD directly, so let us get rid of
+      # -Wl from whole_archive_flag_spec
+      wl= 
+
+      if test -n "$convenience"; then
+	if test -n "$whole_archive_flag_spec"; then
+	  eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
+	else
+	  gentop="$output_objdir/${obj}x"
+	  $show "${rm}r $gentop"
+	  $run ${rm}r "$gentop"
+	  $show "mkdir $gentop"
+	  $run mkdir "$gentop"
+	  status=$?
+	  if test $status -ne 0 && test ! -d "$gentop"; then
+	    exit $status
+	  fi
+	  generated="$generated $gentop"
+
+	  for xlib in $convenience; do
+	    # Extract the objects.
+	    case "$xlib" in
+	    [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
+	    *) xabs=`pwd`"/$xlib" ;;
+	    esac
+	    xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
+	    xdir="$gentop/$xlib"
+
+	    $show "${rm}r $xdir"
+	    $run ${rm}r "$xdir"
+	    $show "mkdir $xdir"
+	    $run mkdir "$xdir"
+	    status=$?
+	    if test $status -ne 0 && test ! -d "$xdir"; then
+	      exit $status
+	    fi
+	    $show "(cd $xdir && $AR x $xabs)"
+	    $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
+
+	    reload_conv_objs="$reload_objs "`find $xdir -name \*.o -print -o -name \*.lo -print | $NL2SP`
+	  done
+	fi
+      fi
+
+      # Create the old-style object.
+      reload_objs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs"
+
+      output="$obj"
+      eval cmds=\"$reload_cmds\"
+      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+
+      # Exit if we aren't doing a library object file.
+      if test -z "$libobj"; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	exit 0
+      fi
+
+      if test "$build_libtool_libs" != yes; then
+	if test -n "$gentop"; then
+	  $show "${rm}r $gentop"
+	  $run ${rm}r $gentop
+	fi
+
+	# Create an invalid libtool object if no PIC, so that we don't
+	# accidentally link it into a program.
+	$show "echo timestamp > $libobj"
+	$run eval "echo timestamp > $libobj" || exit $?
+	exit 0
+      fi
+
+      if test -n "$pic_flag"; then
+	# Only do commands if we really have different PIC objects.
+	reload_objs="$libobjs $reload_conv_objs"
+	output="$libobj"
+	eval cmds=\"$reload_cmds\"
+	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	for cmd in $cmds; do
+	  IFS="$save_ifs"
+	  $show "$cmd"
+	  $run eval "$cmd" || exit $?
+	done
+	IFS="$save_ifs"
+      else
+	# Just create a symlink.
+	$show $rm $libobj
+	$run $rm $libobj
+	xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
+	if test "X$xdir" = "X$libobj"; then
+	  xdir="."
+	else
+	  xdir="$xdir"
+	fi
+	baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
+	oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
+	$show "(cd $xdir && $LN_S $oldobj $baseobj)"
+	$run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
+      fi
+
+      if test -n "$gentop"; then
+	$show "${rm}r $gentop"
+	$run ${rm}r $gentop
+      fi
+
+      exit 0
+      ;;
+
+    # Anything else should be a program.
+    *)
+      if test -n "$vinfo"; then
+	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
+      fi
+
+      if test -n "$release"; then
+	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
+      fi
+
+      if test "$preload" = yes; then
+	if test "$dlopen" = unknown && test "$dlopen_self" = unknown &&
+	   test "$dlopen_self_static" = unknown; then
+	  $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
+	fi 
+      fi
+    
+      if test -n "$rpath$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	for libdir in $rpath $xrpath; do
+	  # This is the magic to use -rpath.
+	  case "$compile_rpath " in
+	  *" $libdir "*) ;;
+	  *) compile_rpath="$compile_rpath $libdir" ;;
+	  esac
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_rpath="$finalize_rpath $libdir" ;;
+	  esac
+	done
+      fi
+
+      # Now hardcode the library paths
+      rpath=
+      hardcode_libdirs=
+      for libdir in $compile_rpath $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) perm_rpath="$perm_rpath $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      compile_rpath="$rpath"
+
+      rpath=
+      hardcode_libdirs=
+      for libdir in $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs="$libdir"
+	    else
+	      # Just accumulate the unique libdirs.
+	      case "$hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator" in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    rpath="$rpath $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$finalize_perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir="$hardcode_libdirs"
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      finalize_rpath="$rpath"
+
+      output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
+      if test "X$output_objdir" = "X$output"; then
+	output_objdir="$objdir"
+      else
+	output_objdir="$output_objdir/$objdir"
+      fi
+
+      # Create the binary in the object directory, then wrap it.
+      if test ! -d $output_objdir; then
+	$show "$mkdir $output_objdir"
+	$run $mkdir $output_objdir
+	status=$?
+	if test $status -ne 0 && test ! -d $output_objdir; then
+	  exit $status
+	fi
+      fi
+
+      if test -n "$libobjs" && test "$build_old_libs" = yes; then
+	# Transform all the library objects into standard objects.
+	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+      fi
+
+      dlsyms=
+      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+	if test -n "$NM" && test -n "$global_symbol_pipe"; then
+	  dlsyms="${outputname}S.c"
+	else
+	  $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
+	fi
+      fi
+
+      if test -n "$dlsyms"; then
+	case "$dlsyms" in
+	"") ;;
+	*.c)
+	  # Discover the nlist of each of the dlfiles.
+	  nlist="$output_objdir/${outputname}.nm"
+
+	  $show "$rm $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Parse the name list into a source file.
+	  $show "creating $output_objdir/$dlsyms"
+
+	  test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
+/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
+/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+/* Prevent the only kind of declaration conflicts we can make. */
+#define lt_preloaded_symbols some_other_symbol
+
+/* External symbol declarations for the compiler. */\
+"
+
+	  if test "$dlself" = yes; then
+	    $show "generating symbol list for \`$output'"
+
+	    test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
+
+	    # Add our own program objects to the symbol list.
+	    progfiles=`$echo "X$objs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
+	    for arg in $progfiles; do
+	      $show "extracting global C symbols from \`$arg'"
+	      $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	    done
+
+	    if test -n "$exclude_expsyms"; then
+	      $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+	    
+	    if test -n "$export_symbols_regex"; then
+	      $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      $run eval '$mv "$nlist"T "$nlist"'
+	    fi
+
+	    # Prepare the list of exported symbols
+	    if test -z "$export_symbols"; then
+	      export_symbols="$output_objdir/$output.exp"
+	      $run $rm $export_symbols
+	      $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+	    else
+	      $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
+	      $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
+	      $run eval 'mv "$nlist"T "$nlist"'
+	    fi
+	  fi
+
+	  for arg in $dlprefiles; do
+	    $show "extracting global C symbols from \`$arg'"
+	    name=`echo "$arg" | sed -e 's%^.*/%%'`
+	    $run eval 'echo ": $name " >> "$nlist"'
+	    $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
+	  done
+
+	  if test -z "$run"; then
+	    # Make sure we have at least an empty file.
+	    test -f "$nlist" || : > "$nlist"
+
+	    if test -n "$exclude_expsyms"; then
+	      egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
+	      $mv "$nlist"T "$nlist"
+	    fi
+
+	    # Try sorting and uniquifying the output.
+	    if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
+	      :
+	    else
+	      grep -v "^: " < "$nlist" > "$nlist"S
+	    fi
+
+	    if test -f "$nlist"S; then
+	      eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
+	    else
+	      echo '/* NONE */' >> "$output_objdir/$dlsyms"
+	    fi
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+
+#undef lt_preloaded_symbols
+
+#if defined (__STDC__) && __STDC__
+# define lt_ptr_t void *
+#else
+# define lt_ptr_t char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+const struct {
+  const char *name;
+  lt_ptr_t address;
+}
+lt_preloaded_symbols[] =
+{\
+"
+
+	    sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
+		-e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
+		  < "$nlist" >> "$output_objdir/$dlsyms"
+
+	    $echo >> "$output_objdir/$dlsyms" "\
+  {0, (lt_ptr_t) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+	  fi
+
+	  pic_flag_for_symtable=
+	  case "$host" in
+	  # compiling the symbol table file with pic_flag works around
+	  # a FreeBSD bug that causes programs to crash when -lm is
+	  # linked before any other PIC object.  But we must not use
+	  # pic_flag when linking with -static.  The problem exists in
+	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag -DPIC -DFREEBSD_WORKAROUND";;
+	    esac;;
+	  *-*-hpux*)
+	    case "$compile_command " in
+	    *" -static "*) ;;
+	    *) pic_flag_for_symtable=" $pic_flag -DPIC";;
+	    esac
+	  esac
+
+	  # Now compile the dynamic symbol file.
+	  $show "(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
+	  $run eval '(cd $output_objdir && $CC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
+
+	  # Clean up the generated files.
+	  $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
+	  $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
+
+	  # Transform the symbol file into the correct name.
+	  compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+	  finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
+	  ;;
+	*)
+	  $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
+	  exit 1
+	  ;;
+	esac
+      else
+	# We keep going just in case the user didn't refer to
+	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
+	# really was required.
+
+	# Nullify the symbol file.
+	compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
+	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
+      fi
+
+      if test -z "$link_against_libtool_libs" || test "$build_libtool_libs" != yes; then
+	# Replace the output file specification.
+	compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
+	link_command="$compile_command$compile_rpath"
+
+	# We have no uninstalled library dependencies, so finalize right now.
+	$show "$link_command"
+	$run eval "$link_command"
+	status=$?
+	
+	# Delete the generated files.
+	if test -n "$dlsyms"; then
+	  $show "$rm $output_objdir/${outputname}S.${objext}"
+	  $run $rm "$output_objdir/${outputname}S.${objext}"
+	fi
+
+	exit $status
+      fi
+
+      if test -n "$shlibpath_var"; then
+	# We should set the shlibpath_var
+	rpath=
+	for dir in $temp_rpath; do
+	  case "$dir" in
+	  [\\/]* | [A-Za-z]:[\\/]*)
+	    # Absolute path.
+	    rpath="$rpath$dir:"
+	    ;;
+	  *)
+	    # Relative path: add a thisdir entry.
+	    rpath="$rpath\$thisdir/$dir:"
+	    ;;
+	  esac
+	done
+	temp_rpath="$rpath"
+      fi
+
+      if test -n "$compile_shlibpath$finalize_shlibpath"; then
+	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+      fi
+      if test -n "$finalize_shlibpath"; then
+	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+      fi
+
+      compile_var=
+      finalize_var=
+      if test -n "$runpath_var"; then
+	if test -n "$perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+	if test -n "$finalize_perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $finalize_perm_rpath; do
+	    rpath="$rpath$dir:"
+	  done
+	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+      fi
+
+      if test "$hardcode_action" = relink; then
+	# Fast installation is not supported
+	link_command="$compile_var$compile_command$compile_rpath"
+	relink_command="$finalize_var$finalize_command$finalize_rpath"
+	
+	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
+	$echo "$modename: \`$output' will be relinked during installation" 1>&2
+      else
+	if test "$fast_install" != no; then
+	  link_command="$finalize_var$compile_command$finalize_rpath"
+	  if test "$fast_install" = yes; then
+	    relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
+	  else
+	    # fast_install is set to needless
+	    relink_command=
+	  fi
+	else
+	  link_command="$compile_var$compile_command$compile_rpath"
+	  relink_command="$finalize_var$finalize_command$finalize_rpath"
+	fi
+      fi
+
+      # Replace the output file specification.
+      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+      
+      # Delete the old output files.
+      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+      $show "$link_command"
+      $run eval "$link_command" || exit $?
+
+      # Now create the wrapper script.
+      $show "creating $output"
+
+      # Quote the relink command for shipping.
+      if test -n "$relink_command"; then
+	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Quote $echo for shipping.
+      if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
+	case "$0" in
+	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
+	*) qecho="$SHELL `pwd`/$0 --fallback-echo";;
+	esac
+	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
+      else
+	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
+      fi
+
+      # Only actually do things if our run command is non-null.
+      if test -z "$run"; then
+	# win32 will think the script is a binary if it has
+	# a .exe suffix, so we strip it off here.
+	case $output in
+	  *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
+	esac
+	$rm $output
+	trap "$rm $output; exit 1" 1 2 15
+
+	$echo > $output "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='sed -e 1s/^X//'
+sed_quote_subst='$sed_quote_subst'
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variable:
+  link_against_libtool_libs='$link_against_libtool_libs'
+else
+  # When we are sourced in execute mode, \$file and \$echo are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    echo=\"$qecho\"
+    file=\"\$0\"
+    # Make sure echo works.
+    if test \"X\$1\" = X--no-reexec; then
+      # Discard the --no-reexec flag, and continue.
+      shift
+    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
+      # Yippee, \$echo works!
+      :
+    else
+      # Restart under the correct shell, and then maybe \$echo will work.
+      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
+    fi
+  fi\
+"
+	$echo >> $output "\
+
+  # Find the directory that this script lives in.
+  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
+
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      [\\/]* | [A-Za-z]:[\\/]*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+
+    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
+  done
+
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+	if test "$fast_install" = yes; then
+	  echo >> $output "\
+  program=lt-'$outputname'
+  progdir=\"\$thisdir/$objdir\"
+  
+  if test ! -f \"\$progdir/\$program\" || \\
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | sed 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+    file=\"\$\$-\$program\"
+
+    if test ! -d \"\$progdir\"; then
+      $mkdir \"\$progdir\"
+    else
+      $rm \"\$progdir/\$file\"
+    fi"
+
+	  echo >> $output "\
+
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if (cd \"\$thisdir\" && eval \$relink_command); then :
+      else
+	$rm \"\$progdir/\$file\"
+	exit 1
+      fi
+    fi
+
+    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $rm \"\$progdir/\$program\";
+      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $rm \"\$progdir/\$file\"
+  fi"
+	else
+	  echo >> $output "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+	fi
+
+	echo >> $output "\
+
+  if test -f \"\$progdir/\$program\"; then"
+
+	# Export our shlibpath_var if we have one.
+	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $echo >> $output "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
+
+    export $shlibpath_var
+"
+	fi
+
+	# fixup the dll searchpath if we need to.
+	if test -n "$dllsearchpath"; then
+	  $echo >> $output "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+	fi
+
+	$echo >> $output "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+"
+	case $host in
+	  # win32 systems need to use the prog path for dll
+	  # lookup to work
+	*-*-cygwin*)
+	  $echo >> $output "\
+      exec \$progdir/\$program \${1+\"\$@\"}
+"
+	  ;;
+
+	# Backslashes separate directories on plain windows
+	*-*-mingw | *-*-os2*)
+	  $echo >> $output "\
+      exec \$progdir\\\\\$program \${1+\"\$@\"}
+"
+	  ;;
+
+	*)
+	  $echo >> $output "\
+      # Export the path to the program.
+      PATH=\"\$progdir:\$PATH\"
+      export PATH
+
+      exec \$program \${1+\"\$@\"}
+"
+	  ;;
+	esac
+	$echo >> $output "\
+      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
+      exit 1
+    fi
+  else
+    # The program doesn't exist.
+    \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
+    \$echo \"This script is just a wrapper for \$program.\" 1>&2
+    echo \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit 1
+  fi
+fi\
+"
+	chmod +x $output
+      fi
+      exit 0
+      ;;
+    esac
+
+    # See if we need to build an old-fashioned archive.
+    for oldlib in $oldlibs; do
+
+      if test "$build_libtool_libs" = convenience; then
+	oldobjs="$libobjs_save"
+	addlibs="$convenience"
+	build_libtool_libs=no
+      else
+	if test "$build_libtool_libs" = module; then
+	  oldobjs="$libobjs_save"
+	  build_libtool_libs=no
+	else
+	  oldobjs="$objs "`$echo "X$libobjs_save" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`
+	fi
+	addlibs="$old_convenience"
+      fi
+
+      if test -n "$addlibs"; then
+	gentop="$output_objdir/${outputname}x"
+	$show "${rm}r $gentop"
+	$run ${rm}r "$gentop"
+	$show "mkdir $gentop"
+	$run mkdir "$gentop"
+	status=$?
+	if test $status -ne 0 && test ! -d "$gentop"; then
+	  exit $status
+	fi
+	generated="$generated $gentop"
+	  
+	# Add in members from convenience archives.
+	for xlib in $addlibs; do
+	  # Extract the objects.
+	  case "$xlib" in
+	  [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
+	  *) xabs=`pwd`"/$xlib" ;;
+	  esac
+	  xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
+	  xdir="$gentop/$xlib"
+
+	  $show "${rm}r $xdir"
+	  $run ${rm}r "$xdir"
+	  $show "mkdir $xdir"
+	  $run mkdir "$xdir"
+	  status=$?
+	  if test $status -ne 0 && test ! -d "$xdir"; then
+	    exit $status
+	  fi
+	  $show "(cd $xdir && $AR x $xabs)"
+	  $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
+
+	  oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
+	done
+      fi
+
+      # Do each command in the archive commands.
+      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
+	eval cmds=\"$old_archive_from_new_cmds\"
+      else
+	# Ensure that we have .o objects in place in case we decided
+	# not to build a shared library, and have fallen back to building
+	# static libs even though --disable-static was passed!
+	for oldobj in $oldobjs; do
+	  if test ! -f $oldobj; then
+	    xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
+	    if test "X$xdir" = "X$oldobj"; then
+	      xdir="."
+	    else
+	      xdir="$xdir"
+	    fi
+	    baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
+	    obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
+	    $show "(cd $xdir && ${LN_S} $obj $baseobj)"
+	    $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
+	  fi
+	done
+
+	eval cmds=\"$old_archive_cmds\"
+      fi
+      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$generated"; then
+      $show "${rm}r$generated"
+      $run ${rm}r$generated
+    fi
+
+    # Now create the libtool archive.
+    case "$output" in
+    *.la)
+      old_library=
+      test "$build_old_libs" = yes && old_library="$libname.$libext"
+      $show "creating $output"
+
+      if test -n "$xrpath"; then
+	temp_xrpath=
+	for libdir in $xrpath; do
+	  temp_xrpath="$temp_xrpath -R$libdir"
+	done
+	dependency_libs="$temp_xrpath $dependency_libs"
+      fi
+
+      # Only create the output if not a dry run.
+      if test -z "$run"; then
+	for installed in no yes; do
+	  if test "$installed" = yes; then
+	    if test -z "$install_libdir"; then
+	      break
+	    fi
+	    output="$output_objdir/$outputname"i
+	  fi
+	  $rm $output
+	  $echo > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$dlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'\
+"
+	done
+      fi
+
+      # Do a symbolic link so that the libtool archive can be found in
+      # LD_LIBRARY_PATH before the program is installed.
+      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
+      $run eval "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)" || exit $?
+      ;;
+    esac
+    exit 0
+    ;;
+
+  # libtool install mode
+  install)
+    modename="$modename: install"
+
+    # There may be an optional sh(1) argument at the beginning of
+    # install_prog (especially on Windows NT).
+    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh; then
+      # Aesthetically quote it.
+      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
+      case "$arg" in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$arg "
+      arg="$1"
+      shift
+    else
+      install_prog=
+      arg="$nonopt"
+    fi
+
+    # The real first argument should be the name of the installation program.
+    # Aesthetically quote it.
+    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+    case "$arg" in
+    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
+      arg="\"$arg\""
+      ;;
+    esac
+    install_prog="$install_prog$arg"
+
+    # We need to accept at least all the BSD install flags.
+    dest=
+    files=
+    opts=
+    prev=
+    install_type=
+    isdir=no
+    stripme=
+    for arg
+    do
+      if test -n "$dest"; then
+	files="$files $dest"
+	dest="$arg"
+	continue
+      fi
+
+      case "$arg" in
+      -d) isdir=yes ;;
+      -f) prev="-f" ;;
+      -g) prev="-g" ;;
+      -m) prev="-m" ;;
+      -o) prev="-o" ;;
+      -s)
+	stripme=" -s"
+	continue
+	;;
+      -*) ;;
+
+      *)
+	# If the previous option needed an argument, then skip it.
+	if test -n "$prev"; then
+	  prev=
+	else
+	  dest="$arg"
+	  continue
+	fi
+	;;
+      esac
+
+      # Aesthetically quote the argument.
+      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
+      case "$arg" in
+      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
+	arg="\"$arg\""
+	;;
+      esac
+      install_prog="$install_prog $arg"
+    done
+
+    if test -z "$install_prog"; then
+      $echo "$modename: you must specify an install program" 1>&2
+      $echo "$help" 1>&2
+      exit 1
+    fi
+
+    if test -n "$prev"; then
+      $echo "$modename: the \`$prev' option requires an argument" 1>&2
+      $echo "$help" 1>&2
+      exit 1
+    fi
+
+    if test -z "$files"; then
+      if test -z "$dest"; then
+	$echo "$modename: no file or destination specified" 1>&2
+      else
+	$echo "$modename: you must specify a destination" 1>&2
+      fi
+      $echo "$help" 1>&2
+      exit 1
+    fi
+
+    # Strip any trailing slash from the destination.
+    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
+
+    # Check to see that the destination is a directory.
+    test -d "$dest" && isdir=yes
+    if test "$isdir" = yes; then
+      destdir="$dest"
+      destname=
+    else
+      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
+      test "X$destdir" = "X$dest" && destdir=.
+      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
+
+      # Not a directory, so check to see that there is only one file specified.
+      set dummy $files
+      if test $# -gt 2; then
+	$echo "$modename: \`$dest' is not a directory" 1>&2
+	$echo "$help" 1>&2
+	exit 1
+      fi
+    fi
+    case "$destdir" in
+    [\\/]* | [A-Za-z]:[\\/]*) ;;
+    *)
+      for file in $files; do
+	case "$file" in
+	*.lo) ;;
+	*)
+	  $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
+	  $echo "$help" 1>&2
+	  exit 1
+	  ;;
+	esac
+      done
+      ;;
+    esac
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic="$magic"
+
+    staticlibs=
+    future_libdirs=
+    current_libdirs=
+    for file in $files; do
+
+      # Do each installation.
+      case "$file" in
+      *.a | *.lib)
+	# Do the static libraries later.
+	staticlibs="$staticlibs $file"
+	;;
+
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit 1
+	fi
+
+	library_names=
+	old_library=
+	# If there is no directory component, then add one.
+	case "$file" in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Add the libdir to current_libdirs if it is the destination.
+	if test "X$destdir" = "X$libdir"; then
+	  case "$current_libdirs " in
+	  *" $libdir "*) ;;
+	  *) current_libdirs="$current_libdirs $libdir" ;;
+	  esac
+	else
+	  # Note the libdir as a future libdir.
+	  case "$future_libdirs " in
+	  *" $libdir "*) ;;
+	  *) future_libdirs="$future_libdirs $libdir" ;;
+	  esac
+	fi
+
+	dir="`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/"
+	test "X$dir" = "X$file/" && dir=
+	dir="$dir$objdir"
+
+	# See the names of the shared library.
+	set dummy $library_names
+	if test -n "$2"; then
+	  realname="$2"
+	  shift
+	  shift
+
+	  # Install the shared library and build the symlinks.
+	  $show "$install_prog $dir/$realname $destdir/$realname"
+	  $run eval "$install_prog $dir/$realname $destdir/$realname" || exit $?
+
+	  if test $# -gt 0; then
+	    # Delete the old symlinks, and create new ones.
+	    for linkname
+	    do
+	      if test "$linkname" != "$realname"; then
+		$show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
+		$run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
+	      fi
+	    done
+	  fi
+
+	  # Do each command in the postinstall commands.
+	  lib="$destdir/$realname"
+	  eval cmds=\"$postinstall_cmds\"
+	  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    $show "$cmd"
+	    $run eval "$cmd" || exit $?
+	  done
+	  IFS="$save_ifs"
+	fi
+
+	# Install the pseudo-library for information purposes.
+	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	instname="$dir/$name"i
+	$show "$install_prog $instname $destdir/$name"
+	$run eval "$install_prog $instname $destdir/$name" || exit $?
+
+	# Maybe install the static library, too.
+	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
+	;;
+
+      *.lo)
+	# Install (i.e. copy) a libtool object.
+
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# Deduce the name of the destination old-style object file.
+	case "$destfile" in
+	*.lo)
+	  staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
+	  ;;
+	*.o | *.obj)
+	  staticdest="$destfile"
+	  destfile=
+	  ;;
+	*)
+	  $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
+	  $echo "$help" 1>&2
+	  exit 1
+	  ;;
+	esac
+
+	# Install the libtool object if requested.
+	if test -n "$destfile"; then
+	  $show "$install_prog $file $destfile"
+	  $run eval "$install_prog $file $destfile" || exit $?
+	fi
+
+	# Install the old object if enabled.
+	if test "$build_old_libs" = yes; then
+	  # Deduce the name of the old-style object file.
+	  staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
+
+	  $show "$install_prog $staticobj $staticdest"
+	  $run eval "$install_prog \$staticobj \$staticdest" || exit $?
+	fi
+	exit 0
+	;;
+
+      *)
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile="$destdir/$destname"
+	else
+	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+	  destfile="$destdir/$destfile"
+	fi
+
+	# Do a test to see if this is really a libtool program.
+	if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  link_against_libtool_libs=
+	  relink_command=
+
+	  # If there is no directory component, then add one.
+	  case "$file" in
+	  */* | *\\*) . $file ;;
+	  *) . ./$file ;;
+	  esac
+
+	  # Check the variables that should have been set.
+	  if test -z "$link_against_libtool_libs"; then
+	    $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
+	    exit 1
+	  fi
+
+	  finalize=yes
+	  for lib in $link_against_libtool_libs; do
+	    # Check to see that each library is installed.
+	    libdir=
+	    if test -f "$lib"; then
+	      # If there is no directory component, then add one.
+	      case "$lib" in
+	      */* | *\\*) . $lib ;;
+	      *) . ./$lib ;;
+	      esac
+	    fi
+	    libfile="$libdir/`$echo "X$lib" | $Xsed -e 's%^.*/%%g'`"
+	    if test -n "$libdir" && test ! -f "$libfile"; then
+	      $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
+	      finalize=no
+	    fi
+	  done
+
+	  outputname=
+	  if test "$fast_install" = no && test -n "$relink_command"; then
+	    if test "$finalize" = yes && test -z "$run"; then
+	      tmpdir="/tmp"
+	      test -n "$TMPDIR" && tmpdir="$TMPDIR"
+              tmpdir=`mktemp -d $tmpdir/libtool-XXXXXX 2> /dev/null`
+              if test $? = 0 ; then :
+              else
+                tmpdir="$tmpdir/libtool-$$"
+              fi
+	      if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
+	      else
+		$echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
+		continue
+	      fi
+	      outputname="$tmpdir/$file"
+	      # Replace the output file specification.
+	      relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
+
+	      $show "$relink_command"
+	      if $run eval "$relink_command"; then :
+	      else
+		$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
+		${rm}r "$tmpdir"
+		continue
+	      fi
+	      file="$outputname"
+	    else
+	      $echo "$modename: warning: cannot relink \`$file'" 1>&2
+	    fi
+	  else
+	    # Install the binary that we compiled earlier.
+	    file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
+	  fi
+	fi
+
+	$show "$install_prog$stripme $file $destfile"
+	$run eval "$install_prog\$stripme \$file \$destfile" || exit $?
+	test -n "$outputname" && ${rm}r "$tmpdir"
+	;;
+      esac
+    done
+
+    for file in $staticlibs; do
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+
+      # Set up the ranlib parameters.
+      oldlib="$destdir/$name"
+
+      $show "$install_prog $file $oldlib"
+      $run eval "$install_prog \$file \$oldlib" || exit $?
+
+      # Do each command in the postinstall commands.
+      eval cmds=\"$old_postinstall_cmds\"
+      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+      for cmd in $cmds; do
+	IFS="$save_ifs"
+	$show "$cmd"
+	$run eval "$cmd" || exit $?
+      done
+      IFS="$save_ifs"
+    done
+
+    if test -n "$future_libdirs"; then
+      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
+    fi
+
+    if test -n "$current_libdirs"; then
+      # Maybe just do a dry run.
+      test -n "$run" && current_libdirs=" -n$current_libdirs"
+      exec $SHELL $0 --finish$current_libdirs
+      exit 1
+    fi
+
+    exit 0
+    ;;
+
+  # libtool finish mode
+  finish)
+    modename="$modename: finish"
+    libdirs="$nonopt"
+    admincmds=
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      for dir
+      do
+	libdirs="$libdirs $dir"
+      done
+
+      for libdir in $libdirs; do
+	if test -n "$finish_cmds"; then
+	  # Do each command in the finish commands.
+	  eval cmds=\"$finish_cmds\"
+	  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	  for cmd in $cmds; do
+	    IFS="$save_ifs"
+	    $show "$cmd"
+	    $run eval "$cmd" || admincmds="$admincmds
+       $cmd"
+	  done
+	  IFS="$save_ifs"
+	fi
+	if test -n "$finish_eval"; then
+	  # Do the single finish_eval.
+	  eval cmds=\"$finish_eval\"
+	  $run eval "$cmds" || admincmds="$admincmds
+       $cmds"
+	fi
+      done
+    fi
+
+    # Exit here if they wanted silent mode.
+    test "$show" = : && exit 0
+
+    echo "----------------------------------------------------------------------"
+    echo "Libraries have been installed in:"
+    for libdir in $libdirs; do
+      echo "   $libdir"
+    done
+    echo
+    echo "If you ever happen to want to link against installed libraries"
+    echo "in a given directory, LIBDIR, you must either use libtool, and"
+    echo "specify the full pathname of the library, or use \`-LLIBDIR'"
+    echo "flag during linking and do at least one of the following:"
+    if test -n "$shlibpath_var"; then
+      echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
+      echo "     during execution"
+    fi
+    if test -n "$runpath_var"; then
+      echo "   - add LIBDIR to the \`$runpath_var' environment variable"
+      echo "     during linking"
+    fi
+    if test -n "$hardcode_libdir_flag_spec"; then
+      libdir=LIBDIR
+      eval flag=\"$hardcode_libdir_flag_spec\"
+
+      echo "   - use the \`$flag' linker flag"
+    fi
+    if test -n "$admincmds"; then
+      echo "   - have your system administrator run these commands:$admincmds"
+    fi
+    if test -f /etc/ld.so.conf; then
+      echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
+    fi
+    echo
+    echo "See any operating system documentation about shared libraries for"
+    echo "more information, such as the ld(1) and ld.so(8) manual pages."
+    echo "----------------------------------------------------------------------"
+    exit 0
+    ;;
+
+  # libtool execute mode
+  execute)
+    modename="$modename: execute"
+
+    # The first argument is the command name.
+    cmd="$nonopt"
+    if test -z "$cmd"; then
+      $echo "$modename: you must specify a COMMAND" 1>&2
+      $echo "$help"
+      exit 1
+    fi
+
+    # Handle -dlopen flags immediately.
+    for file in $execute_dlfiles; do
+      if test ! -f "$file"; then
+	$echo "$modename: \`$file' is not a file" 1>&2
+	$echo "$help" 1>&2
+	exit 1
+      fi
+
+      dir=
+      case "$file" in
+      *.la)
+	# Check to see that this really is a libtool archive.
+	if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
+	else
+	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
+	  $echo "$help" 1>&2
+	  exit 1
+	fi
+
+	# Read the libtool library.
+	dlname=
+	library_names=
+
+	# If there is no directory component, then add one.
+	case "$file" in
+	*/* | *\\*) . $file ;;
+	*) . ./$file ;;
+	esac
+
+	# Skip this library if it cannot be dlopened.
+	if test -z "$dlname"; then
+	  # Warn if it was a shared library.
+	  test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
+	  continue
+	fi
+
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+
+	if test -f "$dir/$objdir/$dlname"; then
+	  dir="$dir/$objdir"
+	else
+	  $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
+	  exit 1
+	fi
+	;;
+
+      *.lo)
+	# Just add the directory containing the .lo file.
+	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+	test "X$dir" = "X$file" && dir=.
+	;;
+
+      *)
+	$echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
+	continue
+	;;
+      esac
+
+      # Get the absolute pathname.
+      absdir=`cd "$dir" && pwd`
+      test -n "$absdir" && dir="$absdir"
+
+      # Now add the directory to shlibpath_var.
+      if eval "test -z \"\$$shlibpath_var\""; then
+	eval "$shlibpath_var=\"\$dir\""
+      else
+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+      fi
+    done
+
+    # This variable tells wrapper scripts just to set shlibpath_var
+    # rather than running their programs.
+    libtool_execute_magic="$magic"
+
+    # Check if any of the arguments is a wrapper script.
+    args=
+    for file
+    do
+      case "$file" in
+      -*) ;;
+      *)
+	# Do a test to see if this is really a libtool program.
+	if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  # If there is no directory component, then add one.
+	  case "$file" in
+	  */* | *\\*) . $file ;;
+	  *) . ./$file ;;
+	  esac
+
+	  # Transform arg to wrapped name.
+	  file="$progdir/$program"
+	fi
+	;;
+      esac
+      # Quote arguments (to preserve shell metacharacters).
+      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
+      args="$args \"$file\""
+    done
+
+    if test -z "$run"; then
+      if test -n "$shlibpath_var"; then
+        # Export the shlibpath_var.
+        eval "export $shlibpath_var"
+      fi
+
+      # Restore saved enviroment variables
+      if test "${save_LC_ALL+set}" = set; then
+	LC_ALL="$save_LC_ALL"; export LC_ALL
+      fi
+      if test "${save_LANG+set}" = set; then
+	LANG="$save_LANG"; export LANG
+      fi
+
+      # Now actually exec the command.
+      eval "exec \$cmd$args"
+
+      $echo "$modename: cannot exec \$cmd$args"
+      exit 1
+    else
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+        eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
+        $echo "export $shlibpath_var"
+      fi
+      $echo "$cmd$args"
+      exit 0
+    fi
+    ;;
+
+  # libtool uninstall mode
+  uninstall)
+    modename="$modename: uninstall"
+    rm="$nonopt"
+    files=
+
+    for arg
+    do
+      case "$arg" in
+      -*) rm="$rm $arg" ;;
+      *) files="$files $arg" ;;
+      esac
+    done
+
+    if test -z "$rm"; then
+      $echo "$modename: you must specify an RM program" 1>&2
+      $echo "$help" 1>&2
+      exit 1
+    fi
+
+    for file in $files; do
+      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
+      test "X$dir" = "X$file" && dir=.
+      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
+
+      rmfiles="$file"
+
+      case "$name" in
+      *.la)
+	# Possibly a libtool archive, so verify it.
+	if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
+	  . $dir/$name
+
+	  # Delete the libtool libraries and symlinks.
+	  for n in $library_names; do
+	    rmfiles="$rmfiles $dir/$n"
+	  done
+	  test -n "$old_library" && rmfiles="$rmfiles $dir/$old_library"
+
+	  $show "$rm $rmfiles"
+	  $run $rm $rmfiles
+
+	  if test -n "$library_names"; then
+	    # Do each command in the postuninstall commands.
+	    eval cmds=\"$postuninstall_cmds\"
+	    IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	    for cmd in $cmds; do
+	      IFS="$save_ifs"
+	      $show "$cmd"
+	      $run eval "$cmd"
+	    done
+	    IFS="$save_ifs"
+	  fi
+
+	  if test -n "$old_library"; then
+	    # Do each command in the old_postuninstall commands.
+	    eval cmds=\"$old_postuninstall_cmds\"
+	    IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	    for cmd in $cmds; do
+	      IFS="$save_ifs"
+	      $show "$cmd"
+	      $run eval "$cmd"
+	    done
+	    IFS="$save_ifs"
+	  fi
+
+	  # FIXME: should reinstall the best remaining shared library.
+	fi
+	;;
+
+      *.lo)
+	if test "$build_old_libs" = yes; then
+	  oldobj=`$echo "X$name" | $Xsed -e "$lo2o"`
+	  rmfiles="$rmfiles $dir/$oldobj"
+	fi
+	$show "$rm $rmfiles"
+	$run $rm $rmfiles
+	;;
+
+      *)
+	$show "$rm $rmfiles"
+	$run $rm $rmfiles
+	;;
+      esac
+    done
+    exit 0
+    ;;
+
+  "")
+    $echo "$modename: you must specify a MODE" 1>&2
+    $echo "$generic_help" 1>&2
+    exit 1
+    ;;
+  esac
+
+  $echo "$modename: invalid operation mode \`$mode'" 1>&2
+  $echo "$generic_help" 1>&2
+  exit 1
+fi # test -z "$show_help"
+
+# We need to display help for each of the modes.
+case "$mode" in
+"") $echo \
+"Usage: $modename [OPTION]... [MODE-ARG]...
+
+Provide generalized library-building support services.
+
+    --config          show all configuration variables
+    --debug           enable verbose shell tracing
+-n, --dry-run         display commands without modifying any files
+    --features        display basic configuration information and exit
+    --finish          same as \`--mode=finish'
+    --help            display this help message and exit
+    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
+    --quiet           same as \`--silent'
+    --silent          don't print informational messages
+    --version         print version information
+
+MODE must be one of the following:
+
+      compile         compile a source file into a libtool object
+      execute         automatically set library path, then run a program
+      finish          complete the installation of libtool libraries
+      install         install libraries or executables
+      link            create a library or an executable
+      uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
+a more detailed description of MODE."
+  exit 0
+  ;;
+
+compile)
+  $echo \
+"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
+  -static           always build a \`.o' file suitable for static linking
+
+COMPILE-COMMAND is a command to be used in creating a \`standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix \`.c' with the
+library object suffix, \`.lo'."
+  ;;
+
+execute)
+  $echo \
+"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+  -dlopen FILE      add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to \`-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+  ;;
+
+finish)
+  $echo \
+"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges.  Use
+the \`--dry-run' option if you just want to see what would be executed."
+  ;;
+
+install)
+  $echo \
+"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command.  The first component should be
+either the \`install' or \`cp' program.
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+  ;;
+
+link)
+  $echo \
+"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+  -all-static       do not do any dynamic linking at all
+  -avoid-version    do not add a version suffix if possible
+  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
+  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+  -export-symbols SYMFILE
+		    try to export only the symbols listed in SYMFILE
+  -export-symbols-regex REGEX
+		    try to export only the symbols matching REGEX
+  -LLIBDIR          search LIBDIR for required installed libraries
+  -lNAME            OUTPUT-FILE requires the installed library libNAME
+  -module           build a library that can dlopened
+  -no-undefined     declare that a library does not refer to external symbols
+  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
+  -release RELEASE  specify package release information
+  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
+  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
+  -static           do not do any dynamic linking of libtool libraries
+  -version-info CURRENT[:REVISION[:AGE]]
+		    specify library version info [each variable defaults to 0]
+
+All other options (arguments beginning with \`-') are ignored.
+
+Every other argument is treated as a filename.  Files ending in \`.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
+only library objects (\`.lo' files) may be specified, and \`-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
+using \`ar' and \`ranlib', or on Windows using \`lib'.
+
+If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
+is created, otherwise an executable program is created."
+  ;;
+
+uninstall)
+  $echo \
+"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+  ;;
+
+*)
+  $echo "$modename: invalid operation mode \`$mode'" 1>&2
+  $echo "$help" 1>&2
+  exit 1
+  ;;
+esac
+
+echo
+$echo "Try \`$modename --help' for more information about other modes."
+
+exit 0
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
Index: xc/extras/expat/conftools/missing
diff -u /dev/null xc/extras/expat/conftools/missing:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/missing	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,190 @@
+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+# Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+# Franc,ois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try \`$0 --help' for more information"
+  exit 1
+fi
+
+case "$1" in
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+
+Supported PROGRAM values:
+  aclocal      touch file \`aclocal.m4'
+  autoconf     touch file \`configure'
+  autoheader   touch file \`config.h.in'
+  automake     touch all \`Makefile.in' files
+  bison        create \`y.tab.[ch]', if possible, from existing .[ch]
+  flex         create \`lex.yy.c', if possible, from existing .c
+  lex          create \`lex.yy.c', if possible, from existing .c
+  makeinfo     touch the output file
+  yacc         create \`y.tab.[ch]', if possible, from existing .[ch]"
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing - GNU libit 0.0"
+    ;;
+
+  -*)
+    echo 1>&2 "$0: Unknown \`$1' option"
+    echo 1>&2 "Try \`$0 --help' for more information"
+    exit 1
+    ;;
+
+  aclocal)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`acinclude.m4' or \`configure.in'.  You might want
+         to install the \`Automake' and \`Perl' packages.  Grab them from
+         any GNU archive site."
+    touch aclocal.m4
+    ;;
+
+  autoconf)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`configure.in'.  You might want to install the
+         \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
+         archive site."
+    touch configure
+    ;;
+
+  autoheader)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`acconfig.h' or \`configure.in'.  You might want
+         to install the \`Autoconf' and \`GNU m4' packages.  Grab them
+         from any GNU archive site."
+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' configure.in`
+    test -z "$files" && files="config.h"
+    touch_files=
+    for f in $files; do
+      case "$f" in
+      *:*) touch_files="$touch_files "`echo "$f" |
+				       sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+      *) touch_files="$touch_files $f.in";;
+      esac
+    done
+    touch $touch_files
+    ;;
+
+  automake)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`Makefile.am', \`acinclude.m4' or \`configure.in'.
+         You might want to install the \`Automake' and \`Perl' packages.
+         Grab them from any GNU archive site."
+    find . -type f -name Makefile.am -print |
+	   sed 's/\.am$/.in/' |
+	   while read f; do touch "$f"; done
+    ;;
+
+  bison|yacc)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.y' file.  You may need the \`Bison' package
+         in order for those modifications to take effect.  You can get
+         \`Bison' from any GNU archive site."
+    rm -f y.tab.c y.tab.h
+    if [ $# -ne 1 ]; then
+        eval LASTARG="\${$#}"
+	case "$LASTARG" in
+	*.y)
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" y.tab.c
+	    fi
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" y.tab.h
+	    fi
+	  ;;
+	esac
+    fi
+    if [ ! -f y.tab.h ]; then
+	echo >y.tab.h
+    fi
+    if [ ! -f y.tab.c ]; then
+	echo 'main() { return 0; }' >y.tab.c
+    fi
+    ;;
+
+  lex|flex)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.l' file.  You may need the \`Flex' package
+         in order for those modifications to take effect.  You can get
+         \`Flex' from any GNU archive site."
+    rm -f lex.yy.c
+    if [ $# -ne 1 ]; then
+        eval LASTARG="\${$#}"
+	case "$LASTARG" in
+	*.l)
+	    SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" lex.yy.c
+	    fi
+	  ;;
+	esac
+    fi
+    if [ ! -f lex.yy.c ]; then
+	echo 'main() { return 0; }' >lex.yy.c
+    fi
+    ;;
+
+  makeinfo)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.texi' or \`.texinfo' file, or any other file
+         indirectly affecting the aspect of the manual.  The spurious
+         call might also be the consequence of using a buggy \`make' (AIX,
+         DU, IRIX).  You might want to install the \`Texinfo' package or
+         the \`GNU make' package.  Grab either from any GNU archive site."
+    file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`
+    if test -z "$file"; then
+      file=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+      file=`sed -n '/^@setfilename/ { s/.* \([^ ]*\) *$/\1/; p; q; }' $file`
+    fi
+    touch $file
+    ;;
+
+  *)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, and you do not seem to have it handy on your
+         system.  You might have modified some files without having the
+         proper tools for further handling them.  Check the \`README' file,
+         it often tells you about the needed prerequirements for installing
+         this package.  You may also peek at any GNU archive site, in case
+         some other package would contain this missing \`$1' program."
+    exit 1
+    ;;
+esac
+
+exit 0
Index: xc/extras/expat/conftools/mkinstalldirs
diff -u /dev/null xc/extras/expat/conftools/mkinstalldirs:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/conftools/mkinstalldirs	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,40 @@
+#! /bin/sh
+# mkinstalldirs --- make directory hierarchy
+# Author: Noah Friedman <friedman@prep.ai.mit.edu>
+# Created: 1993-05-16
+# Public domain
+
+# $Id: mkinstalldirs,v 1.1 2000/09/18 16:26:21 coopercc Exp $
+
+errstatus=0
+
+for file
+do
+   set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'`
+   shift
+
+   pathcomp=
+   for d
+   do
+     pathcomp="$pathcomp$d"
+     case "$pathcomp" in
+       -* ) pathcomp=./$pathcomp ;;
+     esac
+
+     if test ! -d "$pathcomp"; then
+        echo "mkdir $pathcomp"
+
+        mkdir "$pathcomp" || lasterr=$?
+
+        if test ! -d "$pathcomp"; then
+  	  errstatus=$lasterr
+        fi
+     fi
+
+     pathcomp="$pathcomp/"
+   done
+done
+
+exit $errstatus
+
+# mkinstalldirs ends here
Index: xc/extras/expat/doc/reference.html
diff -u /dev/null xc/extras/expat/doc/reference.html:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/doc/reference.html	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,1518 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+                "http://www.w3.org/TR/REC-html40/loose.dtd">
+<html>
+<head>
+
+<!-- Copyright 1999,2000 Clark Cooper <coopercc@netheaven.com>
+     All rights reserved.
+     This is free software. You may distribute or modify according to
+     the terms of the MIT/X License -->
+  <title>Expat XML Parser</title>
+  <meta name="author" content="Clark Cooper, coopercc@netheaven.com">
+  <meta http-equiv="Content-Style-Type" content="text/css">
+  <link href="style.css" rel="stylesheet" type="text/css">
+</head>
+<body>
+<h1>Expat XML Parser</h1>
+
+<p>Expat is a library, written in C, for parsing XML documents. It's the
+underlying XML parser for the open source Mozilla project, perl's
+XML::Parser, and other open-source XML parsers.</p>
+
+<p>This library is the creation of James Clark, who's also given us
+groff (an nroff look-alike), Jade (an implemention of ISO's DSSSL stylesheet
+language for SGML), XP (a Java XML parser package), XT (a Java XSL engine).
+James was also the technical lead on the XML Working Group at W3 that produced
+the XML specification.</p>
+
+<p>This is free software, licensed under the
+<a href="../COPYING">MIT/X Consortium license</a>. You may download it from
+<a href="http://expat.sourceforge.net">the expat homepage on Source Forge</a>.
+</p>
+
+<p>The bulk of this document was originally commissioned as an article by
+<a href="http://www.xml.com/">XML.com</a>. They graciously allowed me to retain
+copyright and to distribute it with expat.
+
+<hr>
+<h2>Table of Contents</h2>
+<ul>
+  <li><a href="#overview">Overview</a></li>
+  <li><a href="#building">Building and Installing</a></li>
+  <li><a href="#using">Using expat</a></li>
+  <li><a href="#examples">Some examples</a></li>
+  <li><a href="#reference">Reference</a>
+      <ul>
+          <li><a href="#creation">Parser Creation Functions</a>
+              <ul>
+                  <li><a href="#XML_ParserCreate">XML_ParserCreate</a></li>
+		  <li><a href="#XML_ParserCreateNS">XML_ParserCreateNS</a></li>
+		  <li><a href="#XML_ParserCreate_MM">XML_ParserCreate_MM</a></li>
+		  <li><a href="#XML_ExternalEntityParserCreate">XML_ExternalEntityParserCreate</a></li>
+		  <li><a href="#XML_ParserFree">XML_ParserFree</a></li>
+              </ul>
+          </li>
+	  <li><a href="#parsing">Parsing Functions</a>
+	      <ul>
+	          <li><a href="#XML_Parse">XML_Parse</a></li>
+		  <li><a href="#XML_ParseBuffer">XML_ParseBuffer</a></li>
+		  <li><a href="#XML_GetBuffer">XML_GetBuffer</a></li>
+              </ul>
+	  </li>
+	  <li><a href="#setting">Handler Setting Functions</a>
+	      <ul>
+	          <li><a href="#XML_SetStartElementHandler">XML_SetStartElementHandler</a></li>
+		  <li><a href="#XML_SetEndElementHandler">XML_SetEndElementHandler</a></li>
+	          <li><a href="#XML_SetElementHandler">XML_SetElementHandler</a></li>
+		  <li><a href="#XML_SetCharacterDataHandler">XML_SetCharacterDataHandler</a></li>
+		  <li><a href="#XML_SetProcessingInstructionHandler">XML_SetProcessingInstructionHandler</a></li>
+		  <li><a href="#XML_SetCommentHandler">XML_SetCommentHandler</a></li>
+		  <li><a href="#XML_SetStartCdataSectionHandler">XML_SetStartCdataSectionHandler</a></li>
+		  <li><a href="#XML_SetEndCdataSectionHandler">XML_SetEndCdataSectionHandler</a></li>
+		  <li><a href="#XML_SetCdataSectionHandler">XML_SetCdataSectionHandler</a></li>
+		  <li><a href="#XML_SetDefaultHandler">XML_SetDefaultHandler</a></li>
+		  <li><a href="#XML_SetDefaultHandlerExpand">XML_SetDefaultHandlerExpand</a></li>
+		  <li><a href="#XML_SetExternalEntityRefHandler">XML_SetExternalEntityRefHandler</a></li>
+		  <li><a href="#XML_SetUnknownEncodingHandler">XML_SetUnknownEncodingHandler</a></li>
+		  <li><a href="#XML_SetStartNamespaceDeclHandler">XML_SetStartNamespaceDeclHandler</a></li>
+		  <li><a href="#XML_SetEndNamespaceDeclHandler">XML_SetEndNamespaceDeclHandler</a></li>
+		  <li><a href="#XML_SetNamespaceDeclHandler">XML_SetNamespaceDeclHandler</a></li>
+		  <li><a href="#XML_SetXmlDeclHandler">XML_SetXmlDeclHandler</a></li>		  
+		  <li><a href="#XML_SetStartDoctypeDeclHandler">XML_SetStartDoctypeDeclHandler</a></li>
+		  <li><a href="#XML_SetEndDoctypeDeclHandler">XML_SetEndDoctypeDeclHandler</a></li>
+		  <li><a href="#XML_SetDoctypeDeclHandler">XML_SetDoctypeDeclHandler</a></li>
+		  <li><a href="#XML_SetElementDeclHandler">XML_SetElementDeclHandler</a></li>
+		  <li><a href="#XML_SetAttlistDeclHandler">XML_SetAttlistDeclHandler</a></li>
+		  <li><a href="#XML_SetEntityDeclHandler">XML_SetEntityDeclHandler</a></li>
+		  <li><a href="#XML_SetUnparsedEntityDeclHandler">XML_SetUnparsedEntityDeclHandler</a></li>
+		  <li><a href="#XML_SetNotationDeclHandler">XML_SetNotationDeclHandler</a></li>
+		  <li><a href="#XML_SetNotStandaloneHandler">XML_SetNotStandaloneHandler</a></li>
+	      </ul>
+	  </li>
+	  <li><a href="#position">Parse Position and Error Reporting Functions</a>
+	      <ul>
+	          <li><a href="#XML_GetErrorCode">XML_GetErrorCode</a></li>
+		  <li><a href="#XML_ErrorString">XML_ErrorString</a></li>
+		  <li><a href="#XML_GetCurrentByteIndex">XML_GetCurrentByteIndex</a></li>
+		  <li><a href="#XML_GetCurrentLineNumber">XML_GetCurrentLineNumber</a></li>
+		  <li><a href="#XML_GetCurrentColumnNumber">XML_GetCurrentColumnNumber</a></li>
+		  <li><a href="#XML_GetCurrentByteCount">XML_GetCurrentByteCount</a></li>
+		  <li><a href="#XML_GetInputContext">XML_GetInputContext</a></li>
+	      </ul>
+	  </li>
+	  <li><a href="#miscellaneous">Miscellaneous Functions</a>
+	      <ul>
+	          <li><a href="#XML_SetUserData">XML_SetUserData</a></li>
+		  <li><a href="#XML_GetUserData">XML_GetUserData</a></li>
+		  <li><a href="#XML_UseParserAsHandlerArg">XML_UseParserAsHandlerArg</a></li>
+		  <li><a href="#XML_SetBase">XML_SetBase</a></li>
+		  <li><a href="#XML_GetBase">XML_GetBase</a></li>
+		  <li><a href="#XML_GetSpecifiedAttributeCount">XML_GetSpecifiedAttributeCount</a></li>
+		  <li><a href="#XML_GetIdAttributeIndex">XML_GetIdAttributeIndex</a></li>
+		  <li><a href="#XML_SetEncoding">XML_SetEncoding</a></li>
+		  <li><a href="#XML_SetParamEntityParsing">XML_SetParamEntityParsing</a></li>
+		  <li><a href="#XML_SetReturnNSTriplet">XML_SetReturnNSTriplet</a></li>
+		  <li><a href="#XML_ExpatVersion">XML_ExpatVersion</a></li>
+		  <li><a href="#XML_ExpatVersionInfo">XML_ExpatVersionInfo</a></li>
+	      </ul>
+	  </li>
+      </ul>  
+  </li>
+</ul>
+
+<hr>
+<h2><a name="overview">Overview</a></h2>
+<p>Expat is a stream-oriented parser. You register callback (or handler) 
+functions with
+the parser and then start feeding it the document.
+As the parser recognizes parts of
+the document, it will call the appropriate handler for that part (if you've
+registered one.) The document is fed to the parser in pieces, so you can
+start parsing before you have all the document. This also allows you to
+parse really huge documents that won't fit into memory.</p>
+
+<p>Expat can be intimidating due to the many kinds of handlers and options
+you can set. But you only need to learn four functions in order to do 90%
+of what you'll want to do with it:</p>
+
+<dl>
+
+<dt><code>XML_ParserCreate</code></dt>
+  <dd>Create a new parser object.</dd>
+
+<dt><code>XML_SetElementHandler</code></dt>
+  <dd>Set handlers for start and end tags.</dd>
+
+<dt><code>XML_SetCharacterDataHandler</code></dt>
+  <dd>Set handler for text.</dd>
+
+<dt><code>XML_Parse</code></dt>
+  <dd>Pass a buffer full of document to the parser</dd>
+</dl>
+
+<p>These functions and others are described in the
+<a href="#reference">reference</a> part of this document. The reference
+section also describes in detail the parameters passed to the different
+types of handlers.
+
+<p>Let's look at a very simple example program that only uses 3 of the above
+functions (it doesn't need to set a character handler.) The program
+<a href="../examples/outline.c">outline.c</a>
+prints an element outline, indenting child elements to distinguish them from
+the parent element that contains them. The start handler does all the work.
+It prints two indenting spaces for every level of ancestor elements, then
+it prints the element and attribute information. Finally it increments the
+global Depth variable.
+
+<div class="eg">
+<pre>
+int Depth;
+
+void
+start(void *data, const char *el, const char **attr) {
+  int i;
+
+  for (i = 0; i &lt; Depth; i++)
+    printf("  ");
+
+  printf("%s", el);
+
+  for (i = 0; attr[i]; i += 2) {
+    printf(" %s='%s'", attr[i], attr[i + 1]);
+  }
+
+  printf("\n");
+  Depth++;
+}  /* End of start handler */
+</pre>
+</div>
+
+<p>The end tag simply does the bookkeeping work of decrementing the Depth.
+<div class="eg">
+<pre>
+void
+end(void *data, const char *el) {
+  Depth--;
+}  /* End of end handler */
+</pre>
+</div>
+
+<p>After creating the parser, the main program just has the job of
+shoveling the document to the parser so that it can do its work.
+
+<hr>
+<h2><a name="building">Building and Installing expat</a></h2>
+<p>The expat distribution comes as a compressed (with GNU gzip) tar file.
+You may download the latest version from
+<a href="http://sourceforge.net/projects/expat/">Source Forge</a>.
+After unpacking this, cd into the directory. Then follow either the
+Win32 directions or Unix directions below.</p>
+
+<h3>Building under Win32</h3>
+<p>If you're using the GNU compiler under cygwin, follow the Unix directions
+in the next section. Otherwise if you have Microsoft's Developer Studio
+installed, then from Windows Explorer double-click on "expat.dsp" in the
+lib directory and build and install in the usual manner.</p>
+
+<p>Alternatively, you may download the win32 binary package that contains
+the expat.h include file and a pre-built dll.</p>
+
+<h3>Building under Unix (or GNU)</h3>
+<p>First you'll need to run the configure shell script in order to configure
+the Makefiles and headers for your system.</p>
+
+<p>If you're happy with all the defaults that configure picks for you,
+and you have permission on your system to install into /usr/local, you can
+install expat with this sequence of commands:</p>
+
+<pre>
+   ./configure
+   make
+   make install
+</pre>
+
+<p>There are some options that you can provide to this script, but the
+only one we'll mention here is the <code>--prefix</code> option. You can
+find out all the options available by running configure with just the
+<code>--help</code> option.
+</p>
+
+By default, the configure script sets things up so that the library gets
+installed in <code>/usr/local/lib</code> and the associated header file in
+<code>/usr/local/include</code>.
+But if you were to give the option, <code>--prefix=/home/me/mystuff</code>,
+then the library and header would get installed in
+<code>/home/me/mystuff/lib</code> and <code>/home/me/mystuff/include</code>
+respectively.
+</p>
+
+<hr>
+<h2><a name="using">Using Expat</a></h2>
+<h3>Compiling and Linking against expat</h3>
+<p>Unless you installed expat in a location not expected by your compiler
+and linker, all you have to do to use expat in your programs is to include
+the expat header (<code>#include &lt;expat.h&gt;</code>) in your files that
+make calls to it and to tell the linker
+that it needs to link against the expat library. On Unix systems, this would
+be the <code>-lexpat</code> argument.
+Otherwise, you'll need to tell the compiler where to look for the expat header
+and the linker where to find the expat library. You may also need to take
+steps to tell the operating system where to find this libary at run time.
+</p>
+<p>On a Unix based system, here's what a Makefile might look like when expat
+is installed in a standard location:</p>
+
+<div class="eg">
+<pre>
+CC=cc
+LDFLAGS=
+LIBS= -lexpat
+xmlapp: xmlapp.o
+        $(CC) $(LDFLAGS) -o xmlapp xmlapp.o $(LIBS)
+</pre>
+</div>
+
+<p>If you installed expat in, say, <code>/home/me/mystuff</code>, then
+the Makefile would look like this:</p>
+
+<div class="eg">
+<pre>
+CC=cc
+CFLAGS= -I/home/me/mystuff/include
+LDFLAGS=
+LIBS= -L/home/me/mystuff/lib -lexpat
+xmlapp: xmlapp.o
+        $(CC) $(LDFLAGS) -o xmlapp xmlapp.o $(LIBS)
+</pre>
+</div>
+
+<p>You'd also have to set the environment variable <code>LD_LIBRARY_PATH</code>
+to <code>/home/me/mystuff/lib</code> (or to
+<code>${LD_LIBRARY_PATH}:/home/me/mystuff/lib</code> if LD_LIBRARY_PATH
+already has some directories in it) in order to run your application.
+</p>
+
+<h3>Expat Basics</h3>
+<p>As we saw in the example in the overview, the first step in parsing an
+XML document with expat is to create a parser object. There are
+<a href="#creation">three functions</a> in the expat API for creating a
+parser object.
+However, only two of these
+(<a href="#XML_ParserCreate"><code>XML_ParserCreate</code></a> and
+<a href="#XML_ParserCreateNS"><code>XML_ParserCreateNS</code></a>)
+can be used for constructing a parser for a top-level document.
+The object returned by these functions is an opaque pointer
+(i.e. expat.h declares it as void *) to data with further internal structure. 
+In order to free the memory associated with this object you must call
+<a href="#XML_ParserFree"><code>XML_ParserFree</code></a>. Note that if
+you have provided any <a href="userdata">user data</a> that gets stored
+in the parser, then your application is responsible for freeing it prior to
+calling XML_ParserFree.
+</p>
+
+<p>The objects returned by the parser creation functions are good for
+parsing only one XML document or external parsed entity. If your application
+needs to parse many XML documents, then it needs to create a parser object
+for each one. The best way to deal with this is to create a higher level
+object that contains all the default initialization you want for your parser
+objects.
+
+<p>Walking through a document hierarchy with a stream oriented parser will
+require a good stack mechanism in order to keep track of current context.
+For instance, to answer the simple question,
+"What element does this text belong to?" requires a stack, since the
+parser may have descended into other elements that are children of the
+current one and has encountered this text on the way out.
+
+<p>The things you're likely to want to keep on a stack are the currently
+opened element and it's attributes. You push this information onto the
+stack in the start handler and you pop it off in the end handler.
+
+<p>For some tasks, it is sufficient to just keep information on what the
+depth of the stack is (or would be if you had one.) The outline program shown
+above presents one example. Another such task would be skipping over a
+complete element. When you see the start tag for the element you want to
+skip, you set a skip flag and record the depth at which the element started.
+When the end tag handler encounters the same depth, the skipped element has
+ended and the flag may be cleared. If you follow the convention that the
+root element starts at 1, then you can use the same variable for skip flag
+and skip depth.
+
+<div class="eg">
+<pre>
+void
+init_info(Parseinfo *info) {
+  info->skip = 0;
+  info->depth = 1;
+  /* Other initializations here */
+}  /* End of init_info */
+
+void
+rawstart(void *data, const char *el, const char **attr) {
+  Parseinfo *inf = (Parseinfo *) data;
+
+  if (! inf->skip) {
+    if (should_skip(inf, el, attr)) {
+      inf->skip = inf->depth;
+    }
+    else
+      start(inf, el, attr);     /* This does rest of start handling */
+  }
+
+  inf->depth++;
+}  /* End of rawstart */
+
+void
+rawend(void *data, const char *el) {
+  Parseinfo *inf = (Parseinfo *) data;
+
+  inf->depth--;
+
+  if (! inf->skip)
+    end(inf, el);              /* This does rest of end handling */
+
+  if (inf->skip == inf->depth)
+    inf->skip = 0;
+}  /* End rawend */
+
+</pre>
+</div>
+
+<p>Notice in the above example the difference in how depth is manipulated
+in the start and end handlers. The end tag handler should be the mirror
+image of the start tag handler. This is necessary to properly model
+containment. Since, in the start tag handler, we
+incremented depth <em>after</em> the main body of start tag code, then in
+the end handler, we need to manipulate it <em>before</em> the main body.
+If we'd decided to increment it first thing in the start handler, then
+we'd have had to decrement it last thing in the end handler.
+
+<h3>Communicating between handlers</h3>
+
+<p>In order to be able to pass information between different handlers
+without using globals, you'll need to define a data structure to hold
+the shared variables. You can then tell expat (with the XML_SetUserData
+function) to pass a pointer to this
+structure to the handlers. This is typically the first argument received
+by most handlers.
+
+<h3>Namespace Processing</h3>
+
+<p>When the parser is created using the <code>XML_ParserCreateNS</code>,
+function, expat performs namespace processing. Under namespace processing,
+expat consumes <code>xmlns</code> and <code>xmlns:...</code> attributes,
+which declare namespaces for the scope of the element in which they
+occur. This means that your start handler will not see these attributes.
+Your application can still be informed of these declarations by setting
+namespace declaration handlers with
+<a href="#XML_SetNamespaceDeclHandler">
+<code>XML_SetNamespaceDeclHandler</code></a>.
+
+<p>Element type and attribute names that belong to a given namespace are
+passed to the appropriate handler in expanded form. By default this expanded
+form is a concatenation of the namespace URI, the separator character (which
+is the 2nd argument to <code>XML_ParserCreateNS</code>), and the local
+name (i.e. the part after the colon). Names with undeclared prefixes are
+passed through to the handlers unchanged, with the prefix and colon still
+attached. Unprefixed attribute names are never expanded, and unprefixed
+element names are only expanded when they are in the scope of a default
+namespace.
+
+<p>However if <a href="XML_SetReturnNSTriplet">XML_SetReturnNSTriplet</a>
+has been called with a non-zero <code>do_nst</code> parameter, then the
+expanded form for names with an explicit prefix is a concatenation of:
+URI, separator, local name, separator, prefix.
+</p>
+
+<p>You can set handlers for the start of a namespace declaration and for
+the end of a scope of a declaration with the
+<code>XML_SetNamespaceDeclHandler</code> function.
+The StartNamespaceDeclHandler is called prior to the start tag handler
+and the EndNamespaceDeclHandler is called before the corresponding end tag
+that ends the namespace's scope.
+The namespace start handler gets passed the prefix and URI for the namespace.
+For a default namespace declaration (xmlns='...'), the prefix will be null.
+The URI will be null for the case where the default namespace is being unset.
+The namespace end handler just gets the prefix for the closing scope.
+
+<p>These handlers are called for each declaration. So if, for instance, a
+start tag had three namespace declarations, then the StartNamespaceDeclHandler
+would be called three times before the start tag handler is called, once for
+each declaration.
+
+<p>The <a href="src/namespace.c">namespace.c</a> example demonstrates the
+use of these features. Like outline.c, it produces an outline, but
+in addition it annotates when a namespace scope starts and when it ends.
+This example also demonstrates use of application user data.
+
+<h3>Character Encodings</h3>
+
+<p>While XML is based on Unicode, and every XML processor is required to
+recognized UTF-8 and UTF-16 (1 and 2 byte encodings of Unicode), other
+encodings may be declared in XML documents or entities. For the main
+document, an XML declaration may contain an encoding declaration:
+<pre>
+&lt;?xml version="1.0" encoding="ISO-8859-2"?&gt;
+</pre>
+
+<p>External parsed entities may begin with a text declaration, which
+looks like an XML declaration with just an encoding declaration:
+<pre>
+&lt;?xml encoding="Big5"?&gt;
+</pre>
+
+<p>With expat, you may also specify an encoding at the time of creating a
+parser. This is useful when the encoding information may come from a source
+outside the document itself (like a higher level protocol.)
+
+<p><a name="builtin_encodings"></a>There are four built-in encodings in expat:
+<ul>
+<li>UTF-8
+<li>UTF-16
+<li>ISO-8859-1
+<li>US-ASCII
+</ul>
+
+<p>Anything else discovered in an encoding declaration or in the
+protocol encoding specified in the parser constructor, triggers a call
+to the <code>UnknownEncodingHandler</code>. This handler gets passed
+the encoding name and a pointer to an <code>XML_Encoding</code> data
+structure. Your handler must fill in this structure and return 1 if 
+it knows how to deal with the encoding. Otherwise the handler should
+return 0.
+The handler also gets passed a pointer to an
+optional application data structure that you may indicate when you set
+the handler.
+
+<p>Expat places restrictions on character encodings that it can support
+by filling in the <code>XML_Encoding</code> structure.
+include file:
+<ol>
+<li>Every ASCII character that can appear in a well-formed XML document
+must be represented by a single byte, and that byte must correspond to
+it's ASCII encoding (except for the characters $@\^'{}~)</li>
+<li>Characters must be encoded in 4 bytes or less.</li>
+<li>All characters encoded must have Unicode scalar values less than or
+equal to 65535 (0xFFFF)<em>This does not apply to the built-in support
+for UTF-16 and UTF-8</em></li>
+<li>No character may be encoded by more that one distinct sequence of
+bytes</li>
+</ol>
+
+<p><code>XML_Encoding</code> contains an array of integers that correspond
+to the 1st byte of an encoding sequence. If the value in the array for a
+byte is zero or positive, then the byte is a single byte encoding that
+encodes the Unicode scalar value contained in the array. A -1 in this array
+indicates a malformed byte. If the value is
+-2, -3, or -4, then the byte is the beginning of a 2, 3, or 4 byte sequence
+respectively. Multi-byte sequences are sent to the convert function pointed
+at in the <code>XML_Encoding</code> structure. This function should return
+the Unicode scalar value for the sequence or -1 if the sequence is malformed.
+
+<p>One pitfall that novice expat users are likely to fall into is that
+although expat may accept input in various encodings, the strings that it
+passes to the handlers are always encoded in UTF-8. Your application is
+responsible for any translation of these strings into other encodings.
+
+<h3>Handling External Entity References</h3>
+
+<p>Expat does not read or parse external entities directly. Note that any
+external DTD is a special case of an external entity.
+If you've set no <code>ExternalEntityRefHandler</code>, then external
+entity references are silently ignored. Otherwise, it calls your handler with
+the information needed to read and parse the external entity.
+
+<p>Your handler
+isn't actually responsible for parsing the entity, but it is responsible
+for creating a subsidiary parser with
+<code>XML_ExternalEntityParserCreate</code> that will do the job. This returns
+an instance of <code>XML_Parser</code> that has handlers and other data
+structures initialized from the parent parser. You may then use
+<code>XML_Parse</code> or <code>XML_ParseBuffer</code> calls against this
+parser.
+Since external entities my refer to other external entities, your handler
+should be prepared to be called recursively.
+
+<h3>Parsing DTDs</h3>
+<p>In order to parse parameter entities,  before starting the parse, you must
+call <code>XML_SetParamEntityParsing</code> with one of the following
+arguments:
+<dl>
+<dt><code>XML_PARAM_ENTITY_PARSING_NEVER</code></dt>
+<dd>Don't parse parameter entities or the external subset</dd>
+<dt><code>XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE</code></dt>
+<dd>Parse parameter entites and the external subset unless
+<code>standalone</code> was set to "yes" in the XML declaration.</dd>
+<dt><code>XML_PARAM_ENTITY_PARSING_ALWAYS</code></dt>
+<dd>Always parse parameter entities and the external subset</dd>
+</dl>
+
+<p>In order to read an external DTD, you also have to set an
+external entity reference handler as described above.
+
+<hr>
+<h2><a name="examples">Some expat Examples</a></h2>
+
+<hr>
+<!-- ================================================================ -->
+
+<h2><a name="reference">Expat Reference</a></h2>
+
+<h3><a name="creation">Parser Creation</a></h3>
+
+<div class="fcndec"><a name="XML_ParserCreate"><pre>
+XML_Parser
+XML_ParserCreate(const XML_Char *encoding)
+</pre></a></div>
+<div class="fcndef">
+Construct a new parser. If encoding is non-null, it specifies a
+character encoding to use for the document. This overrides the document
+encoding declaration. There are four built-in encodings:
+<ul>
+<li>US-ASCII
+<li>UTF-8
+<li>UTF-16
+<li>ISO-8859-1
+</ul>
+Any other value will invoke a call to the UnknownEncodingHandler.
+</div>
+
+<div class="fcndec"><a name="XML_ParserCreateNS"><pre>
+XML_Parser
+XML_ParserCreateNS(const XML_Char *encoding,
+                   XML_Char sep)
+</pre></a></div>
+<div class="fcndef">
+Constructs a new parser that has namespace processing in effect. Namespace
+expanded element names and attribute names are returned as a concatenation
+of the namespace URI, <em>sep</em>, and the local part of the name. This
+means that you should pick a character for <em>sep</em> that can't be
+part of a legal URI.</div>
+
+<div class="fcndec"><a name="XML_ParserCreate_MM"><pre>
+XML_Parser
+XML_ParserCreate_MM(const XML_Char *encoding,
+                    const XML_Memory_Handling_Suite *ms,
+		    const XML_Char *sep)
+</pre></a></div>
+<div class="fcndef">
+<p>Construct a new parser using the suite of memory handling functions
+specified in <code>ms</code>. If <code>ms</code> is NULL, then use the
+standard set of memory management functions. If <code>sep</code> is
+non NULL, then namespace processing is enabled in the created parser
+and the character pointed at by sep is used as the separator between
+the namespace URI and the local part of the name</p>
+<div class="eg"><pre>
+typedef struct {
+  void *(*malloc_fcn)(size_t size);
+  void *(*realloc_fcn)(void *ptr, size_t size);
+  void (*free_fcn)(void *ptr);
+} XML_Memory_Handling_Suite;
+</pre></div>
+</div>
+
+<div class="fcndec"><a name="XML_ExternalEntityParserCreate"><pre>
+XML_Parser
+XML_ExternalEntityParserCreate(XML_Parser p,
+                               const XML_Char *context,
+                               const XML_Char *encoding)
+</pre></a></div>
+<div class="fcndef">
+Construct a new XML_Parser object for parsing an external general
+entity. Context is the context argument passed in a call to a
+ExternalEntityRefHandler. Other state information such as handlers, user data,
+namespace processing is inherited from the parser passed as the 1st
+argument. So you shouldn't need to call any of the behavior changing
+functions on this parser (unless you want it to act differently than the
+parent parser.)
+</div>
+
+<div class="fcndec"><a name="XML_ParserFree"><pre>
+void
+XML_ParserFree(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Free memory used by the parser. Your application is responsible for
+freeing any memory associated with <a href="#userdata">UserData</a>.
+</div>
+
+<h3><a name="parsing">Parsing</a></h3>
+
+
+<div class="fcndec"><a name="XML_Parse"><pre>
+int
+XML_Parse(XML_Parser p,
+          const char *s,
+          int len,
+          int isFinal)
+</pre></a></div>
+<div class="fcndef">
+Parse some more of the document. The string <code>s</code> is a buffer
+containing part (or perhaps all) of the document. The number of bytes of s
+that are part of the document is indicated by <code>len</code>. This means
+that <code>s</code> doesn't have to be null terminated. It also means that
+if <code>len</code> is larger than the number of bytes in the block of
+memory that <code>s</code> points at, then a memory fault is likely. The
+<code>isFinal</code> parameter informs the parser that this is the last
+piece of the document. Frequently, the last piece is empty (i.e.
+<code>len</code> is zero.)
+If a parse error occurred, it returns 0. Otherwise it returns a non-zero
+value.
+</div>
+
+<div class="fcndec"><a name="XML_ParseBuffer"><pre>
+int
+XML_ParseBuffer(XML_Parser p,
+                int len,
+                int isFinal)
+</pre></a></div>
+<div class="fcndef">
+This is just like XML_Parse, except in this case expat provides the buffer.
+By obtaining the buffer from expat with the <code>XML_GetBuffer</code>
+function, the application can avoid double copying of the input.
+</div>
+
+<div class="fcndec"><a name="XML_GetBuffer"><pre>
+void *
+XML_GetBuffer(XML_Parser p,
+              int len)
+</pre></a></div>
+<div class="fcndef">
+Obtain a buffer of size <code>len</code> to read a piece of the document
+into. A NULL value is returned if expat can't allocate enough memory for
+this buffer. This has to be called prior to every call to
+<code>XML_ParseBuffer</code>. A typical use would look like this:
+
+<div id="eg">
+<pre>
+for (;;) {
+  int bytes_read;
+  void *buff = XML_GetBuffer(p, BUFF_SIZE);
+  if (buff == NULL) {
+    /* handle error */
+  }
+
+  bytes_read = read(docfd, buff, BUFF_SIZE);
+  if (bytes_read < 0) {
+    /* handle error */
+  }
+
+  if (! XML_ParseBuffer(p, bytes_read, bytes_read == 0)) {
+    /* handle parse error */
+  }
+
+  if (bytes_read == 0)
+    break;
+}  
+</pre>
+</div>
+</div>
+
+<h3><a name="setting">Handler Setting</a></h3>
+<p>Although handlers are typically set prior to parsing and left alone, an
+application may choose to set or change the handler for a parsing event
+while the parse is in progress. For instance, your application may choose
+to ignore all text not descended from a <code>para</code> element. One
+way it could do this is to set the character handler when a para start tag
+is seen, and unset it for the corresponding end tag.
+
+<p>A handler may be <em>unset</em> by providing a NULL pointer to the
+appropriate handler setter. None of the handler setting functions have
+a return value.
+
+<p>Your handlers will be receiving strings in arrays of type
+<code>XML_Char</code>. This type is defined in expat.h as <code>char *</code>
+and contains bytes encoding UTF-8.
+Note that you'll receive them in this form independent of the original
+encoding of the document.</p>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetStartElementHandler"><pre>
+XML_SetStartElementHandler(XML_Parser p,
+                           XML_StartElementHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartElementHandler)(void *userData,
+                           const XML_Char *name,
+                           const XML_Char **atts);
+</pre></div>
+<p>Set handler for start (and empty) tags. Attributes are passed to the start
+handler as a pointer to a vector of char pointers. Each attribute seen in
+a start (or empty) tag occupies 2 consecutive places in this vector: the
+attribute name followed by the attribute value. These pairs are terminated
+by a null pointer.</p>
+<p>Note that an empty tag generates a call to both start and end handlers
+(in that order).</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetEndElementHandler"><pre>
+XML_SetEndElementHandler(XML_Parser p,
+                         XML_EndElementHandler);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndElementHandler)(void *userData,
+                         const XML_Char *name);
+</pre></div>
+<p>Set handler for end (and empty) tags. As noted above, an empty tag
+generates a call to both start and end handlers.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetElementHandler"><pre>
+XML_SetElementHandler(XML_Parser p,
+                      XML_StartElementHandler start,
+                      XML_EndElementHandler end);
+</pre></a></div>
+<p>Set handlers for start and end tags with one call.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetCharacterDataHandler"><pre>
+XML_SetCharacterDataHandler(XML_Parser p,
+                            XML_CharacterDataHandler charhndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_CharacterDataHandler)(void *userData,
+                            const XML_Char *s,
+                            int len);
+</pre></div>
+<p>Set a text handler. The string your handler receives
+is <em>NOT zero terminated</em>. You have to use the length argument
+to deal with the end of the string. A single block of contiguous text
+free of markup may still result in a sequence of calls to this handler.
+In other words, if you're searching for a pattern in the text, it may
+be split across calls to this handler.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetProcessingInstructionHandler"><pre>
+XML_SetProcessingInstructionHandler(XML_Parser p,
+                                    XML_ProcessingInstructionHandler proc)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_ProcessingInstructionHandler)(void *userData,
+                                    const XML_Char *target,
+                                    const XML_Char *data);
+
+</pre></div>
+<p>Set a handler for processing instructions. The target is the first word
+in the processing instruction. The data is the rest of the characters in
+it after skipping all whitespace after the initial word.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetCommentHandler"><pre>
+XML_SetCommentHandler(XML_Parser p,
+                      XML_CommentHandler cmnt)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_CommentHandler)(void *userData,
+                      const XML_Char *data);
+</pre></div>
+<p>Set a handler for comments. The data is all text inside the comment
+delimiters.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetStartCdataSectionHandler"><pre>
+XML_SetStartCdataSectionHandler(XML_Parser p,
+                                XML_StartCdataSectionHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartCdataSectionHandler)(void *userData);
+</pre></div>
+<p>Set a handler that gets called at the beginning of a CDATA section.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetEndCdataSectionHandler"><pre>
+XML_SetEndCdataSectionHandler(XML_Parser p,
+                              XML_EndCdataSectionHandler end);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndCdataSectionHandler)(void *userData);
+</pre></div>
+<p>Set a handler that gets called at the end of a CDATA section.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetCdataSectionHandler"><pre>
+XML_SetCdataSectionHandler(XML_Parser p,
+                           XML_StartCdataSectionHandler start,
+                           XML_EndCdataSectionHandler end)
+</pre></a></div>
+<p>Sets both CDATA section handlers with one call.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetDefaultHandler"><pre>
+XML_SetDefaultHandler(XML_Parser p,
+                      XML_DefaultHandler hndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_DefaultHandler)(void *userData,
+                      const XML_Char *s,
+                      int len);
+</pre></div>
+<p>Sets a handler for any characters in the document which wouldn't
+otherwise be handled. This includes both data for which no handlers can be
+set (like some kinds of DTD declarations) and data which could be reported
+but which currently has no handler set. Note that a contiguous piece of
+data that is destined to be reported to the default handler may actually
+be reported over several calls to the handler. Setting the handler with
+this call has the side effect of turning off expansion of references
+to internally defined general entities. Instead these references are
+passed to the default handler.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetDefaultHandlerExpand"><pre>
+XML_SetDefaultHandlerExpand(XML_Parser p,
+                            XML_DefaultHandler hndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_DefaultHandler)(void *userData,
+                      const XML_Char *s,
+                      int len);
+</pre></div>
+<p>This sets a default handler, but doesn't affect expansion of internal
+entity references.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetExternalEntityRefHandler"><pre>
+XML_SetExternalEntityRefHandler(XML_Parser p,
+                                XML_ExternalEntityRefHandler hndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef int
+(*XML_ExternalEntityRefHandler)(XML_Parser p,
+                                const XML_Char *context,
+                                const XML_Char *base,
+                                const XML_Char *systemId,
+                                const XML_Char *publicId);
+</pre></div>
+<p>Set an external entity reference handler. This handler is also
+called for processing an external DTD subset if parameter entity parsing
+is in effect. (See <a href="#XML_SetParamEntityParsing">
+<code>XML_SetParamEntityParsing</code></a>.)</p>
+
+
+<p>The base parameter is the base to use for relative system identifiers.
+It is set by <a href="#XML_SetBase">XML_SetBase</a> and may be null. The
+public id parameter is the public id given in the entity declaration and
+may be null. The system id is the system identifier specified in the entity
+declaration and is never null.</p>
+
+<p>There are a couple of ways in which this handler differs from others.
+First, this handler returns an integer. A non-zero value should be returned
+for successful handling of the external entity reference. Returning a zero
+indicates failure, and causes the calling parser to return
+an <code>XML_ERROR_EXTERNAL_ENTITY_HANDLING</code> error.</p>
+
+<p>Second, instead of having userData as its first argument, it receives the
+parser that encountered the entity reference. This, along with the context
+parameter, may be used as arguments to a call to
+<a href="#XML_ExternalEntityParserCreate">XML_ExternalEntityParserCreate</a>.
+Using the returned parser, the body of the external entity can be recursively
+parsed.</p>
+
+<p>Since this handler may be called recursively, it should not be saving
+information into global or static variables.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetUnknownEncodingHandler"><pre>
+XML_SetUnknownEncodingHandler(XML_Parser p,
+                              XML_UnknownEncodingHandler enchandler,
+			      void *encodingHandlerData)
+</pre></a></div>
+<div class="signature"><pre>
+typedef int
+(*XML_UnknownEncodingHandler)(void *encodingHandlerData,
+                              const XML_Char *name,
+                              XML_Encoding *info);
+</pre></div>
+<p>Set a handler to deal with encodings other than the
+<a href="#builtin_encodings">built in set</a>. If the handler knows how
+to deal with an encoding with the given name, it should fill in the info
+data structure and return 1. Otherwise it should return 0.</p>
+
+<pre>
+    typedef struct {
+      int map[256];
+      void *data;
+      int (*convert)(void *data, const char *s);
+      void (*release)(void *data);
+    } XML_Encoding;
+</pre>
+
+<p>The map array contains information for every possible possible leading
+byte in a byte sequence. If the corresponding value is &gt;= 0, then it's
+a single byte sequence and the byte encodes that Unicode value. If the
+value is -1, then that byte is invalid as the initial byte in a sequence.
+If the value is -n, where n is an integer &gt; 1, then n is the number of
+bytes in the sequence and the actual conversion is accomplished by a
+call to the function pointed at by convert. This function may return -1
+if the sequence itself is invalid. The convert pointer may be null if
+there are only single byte codes. The data parameter passed to the convert
+function is the data pointer from XML_Encoding. The string s is <em>NOT</em>
+null terminated and points at the sequence of bytes to be converted.</p>
+
+<p>The function pointed at by release is called by the parser when it is
+finished with the encoding. It may be null.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetStartNamespaceDeclHandler"><pre>
+XML_SetStartNamespaceDeclHandler(XML_Parser p,
+			         XML_StartNamespaceDeclHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartNamespaceDeclHandler)(void *userData,
+                                 const XML_Char *prefix,
+                                 const XML_Char *uri);
+</pre></div>
+<p>Set a handler to be called when a namespace is declared. Namespace
+declarations occur inside start tags. But the namespace declaration start
+handler is called before the start tag handler for each namespace declared
+in that start tag.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetEndNamespaceDeclHandler"><pre>
+XML_SetEndNamespaceDeclHandler(XML_Parser p,
+			       XML_EndNamespaceDeclHandler end);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndNamespaceDeclHandler)(void *userData,
+                               const XML_Char *prefix);
+</pre></div>
+<p>Set a handler to be called when leaving the scope of a namespace
+declaration. This will be called, for each namespace declaration, after
+the handler for the end tag of the element in which the namespace was declared.
+</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetNamespaceDeclHandler"><pre>
+XML_SetNamespaceDeclHandler(XML_Parser p,
+                            XML_StartNamespaceDeclHandler start,
+                            XML_EndNamespaceDeclHandler end)
+</pre></a></div>
+<p>Sets both namespace declaration handlers with a single call</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetXmlDeclHandler"><pre>
+XML_SetXmlDeclHandler(XML_Parser p,
+		      XML_XmlDeclHandler xmldecl);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_XmlDeclHandler) (void            *userData,
+                       const XML_Char  *version,
+                       const XML_Char  *encoding,
+                       int             standalone);
+</pre></div>
+<p>Sets a handler that is called for XML declarations and also for
+text declarations discovered in external entities. The way to distinguish
+is that the <code>version</code> parameter will be NULL for text
+declarations. The <code>encoding</code> parameter may be NULL for
+an XML declaration. The <code>standalone</code> argument will contain
+-1, 0, or 1  indicating respectively that there was no standalone parameter in
+the declaration, that it was given as no, or that it was given as yes.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetStartDoctypeDeclHandler"><pre>
+XML_SetStartDoctypeDeclHandler(XML_Parser p,
+			       XML_StartDoctypeDeclHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartDoctypeDeclHandler)(void           *userData,
+                               const XML_Char *doctypeName,
+                               const XML_Char *sysid,
+                               const XML_Char *pubid,
+                               int            has_internal_subset);
+</pre></div>
+<p>Set a handler that is called at the start of a DOCTYPE declaration,
+before any external or internal subset is parsed. Both <code>sysid</code>
+and <code>pubid</code> may be NULL. The <code>has_internal_subset</code>
+will be non-zero if the DOCTYPE declaration has an internal subset.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetEndDoctypeDeclHandler"><pre>
+XML_SetEndDoctypeDeclHandler(XML_Parser p,
+			     XML_EndDoctypeDeclHandler end);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndDoctypeDeclHandler)(void *userData);
+</pre></div>
+<p>Set a handler that is called at the end of a DOCTYPE declaration,
+after parsing any external subset.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetDoctypeDeclHandler"><pre>
+XML_SetDoctypeDeclHandler(XML_Parser p,
+			  XML_StartDoctypeDeclHandler start,
+			  XML_EndDoctypeDeclHandler end);
+</pre></a></div>
+<p>Set both doctype handlers with one call.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetElementDeclHandler"><pre>
+XML_SetElementDeclHandler(XML_Parser p,
+			  XML_ElementDeclHandler eldecl);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_ElementDeclHandler)(void *userData,
+                          const XML_Char *name,
+                          XML_Content *model);
+</pre></div>
+<div class="signature"><pre>
+enum XML_Content_Type {
+  XML_CTYPE_EMPTY = 1,
+  XML_CTYPE_ANY,
+  XML_CTYPE_MIXED,
+  XML_CTYPE_NAME,
+  XML_CTYPE_CHOICE,
+  XML_CTYPE_SEQ
+};
+
+enum XML_Content_Quant {
+  XML_CQUANT_NONE,
+  XML_CQUANT_OPT,
+  XML_CQUANT_REP,
+  XML_CQUANT_PLUS
+};
+
+typedef struct XML_cp XML_Content;
+
+struct XML_cp {
+  enum XML_Content_Type		type;
+  enum XML_Content_Quant	quant;
+  const XML_Char *		name;
+  unsigned int			numchildren;
+  XML_Content *			children;
+};
+</pre></div>
+<p>Sets a handler for element declarations in a DTD. The handler gets called
+with the name of the element in the declaration and a pointer to a structure
+that contains the element model. It is the application's responsibility to
+free this data structure.</p>
+
+<p>The <code>model</code> argument is the root of a tree of
+<code>XML_Content</code> nodes. If <code>type</code> equals
+<code>XML_CTYPE_EMPTY</code> or <code>XML_CTYPE_ANY</code>, then
+<code>quant</code> will be <code>XML_CQUANT_NONE</code>, and the other fields
+will be zero or NULL.
+If <code>type</code> is <code>XML_CTYPE_MIXED</code>, then <code>quant</code>
+will be <code>XML_CQUANT_NONE</code> or <code>XML_CQUANT_REP</code> and
+<code>numchildren</code> will contain the number of elements that are allowed
+to be mixed in and <code>children</code> points to an array of
+<code>XML_Content</code> structures that will all have type XML_CTYPE_NAME
+with no quantification.
+Only the root node can be type <code>XML_CTYPE_EMPTY</code>, <code>XML_CTYPE_ANY</code>, or <code>XML_CTYPE_MIXED</code>.</p>
+
+<p>For type <code>XML_CTYPE_NAME</code>, the <code>name</code> field points
+to the name and the <code>numchildren</code> and <code>children</code> fields
+will be zero and NULL. The <code>quant</code> field will indicate any
+quantifiers placed on the name.</p>
+
+<p>Types <code>XML_CTYPE_CHOICE</code> and <code>XML_CTYPE_SEQ</code>
+indicate a choice or sequence respectively. The <code>numchildren</code>
+field indicates how many nodes in the choice or sequence and
+<code>children</code> points to the nodes.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetAttlistDeclHandler"><pre>
+XML_SetAttlistDeclHandler(XML_Parser p,
+                          XML_AttlistDeclHandler attdecl);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_AttlistDeclHandler) (void           *userData,
+                           const XML_Char *elname,
+                           const XML_Char *attname,
+                           const XML_Char *att_type,
+                           const XML_Char *dflt,
+                           int            isrequired);
+</pre></div>
+<p>Set a handler for attlist declarations in the DTD. This handler is called
+for <em>each</em> attribute. So a single attlist declaration with multiple
+attributes declared will generate multiple calls to this handler. The
+<code>elname</code> parameter returns the name of the element for which the
+attribute is being declared. The attribute name is in the <code>attname</code>
+parameter. The attribute type is in the <code>att_type</code> parameter.
+It is the string representing the type in the declaration with whitespace
+removed.</p>
+
+<p>The <code>dflt</code> parameter holds the default value. It will
+be NULL in the case of "#IMPLIED" or "#REQUIRED" attributes. You can
+distinguish these two cases by checking the <code>isrequired</code>
+parameter, which will be true in the case of "#REQUIRED" attributes.
+Attributes which are "#FIXED" will have also have a true
+<code>isrequired</code>, but they will have the non-NULL fixed value in the
+<code>dflt</code> parameter.
+</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetEntityDeclHandler"><pre>
+XML_SetEntityDeclHandler(XML_Parser p,
+			 XML_EntityDeclHandler handler);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EntityDeclHandler) (void           *userData,
+                          const XML_Char *entityName,
+                          int            is_parameter_entity,
+                          const XML_Char *value,
+                          int            value_length,
+                          const XML_Char *base,
+                          const XML_Char *systemId,
+                          const XML_Char *publicId,
+                          const XML_Char *notationName);
+</pre></div>
+<p>Sets a handler that will be called for all entity declarations.
+The <code>is_parameter_entity</code> argument will be non-zero in the case
+of parameter entities and zero otherwise.
+</p>
+<p>For internal entities (<code>&lt;!ENTITY foo "bar"&gt;</code>),
+<code>value</code> will be non-NULL and <code>systemId</code>,
+<code>publicId</code>, and <code>notationName</code> will all be NULL.
+The value string is <em>not</em> NULL terminated; the length is provided in
+the <code>value_length</code> parameter. Do not use <code>value_length</code>
+to test for internal entities, since it is legal to have zero-length
+values. Instead check for whether or not <code>value</code> is NULL.</p>
+<p>The <code>notationName</code> argument will have a non-NULL value only
+for unparsed entity declarations.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetUnparsedEntityDeclHandler"><pre>
+XML_SetUnparsedEntityDeclHandler(XML_Parser p,
+                                 XML_UnparsedEntityDeclHandler h)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_UnparsedEntityDeclHandler)(void *userData,
+                                 const XML_Char *entityName,
+                                 const XML_Char *base,
+                                 const XML_Char *systemId,
+                                 const XML_Char *publicId,
+                                 const XML_Char *notationName);
+</pre></div>
+<p>Set a handler that receives declarations of unparsed entities. These
+are entity declarations that have a notation (NDATA) field:</p>
+
+<div id="eg"><pre>
+&lt;!ENTITY logo SYSTEM "images/logo.gif" NDATA gif&gt;
+</pre></div>
+
+<p>This handler is obsolete and is provided for backwards compatibility.
+Use instead <a href="#XML_SetEntityDeclHandler">XML_SetEntityDeclHandler</a>.
+</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetNotationDeclHandler"><pre>
+XML_SetNotationDeclHandler(XML_Parser p,
+                           XML_NotationDeclHandler h)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_NotationDeclHandler)(void *userData,
+                           const XML_Char *notationName,
+                           const XML_Char *base,
+                           const XML_Char *systemId,
+                           const XML_Char *publicId);
+</pre></div>
+<p>Set a handler that receives notation declarations.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetNotStandaloneHandler"><pre>
+XML_SetNotStandaloneHandler(XML_Parser p,
+                            XML_NotStandaloneHandler h)
+</pre></a></div>
+<div class="signature"><pre>
+typedef int 
+(*XML_NotStandaloneHandler)(void *userData);
+</pre></div>
+<p>Set a handler that is called if the document is not "standalone".
+This happens when there is an external subset or a reference to a parameter
+entity, but does not have standalone set to "yes" in an XML declaration.
+If this handler returns 0, then the parser will throw an
+<code>XML_ERROR_NOT_STANDALONE</code> error.</p>
+</div>
+
+<h3><a name="position">Parse position and error reporting functions</a></h3>
+<p>These are the functions you'll want to call when the parse functions
+return 0 (i.e. a parse error has ocurred), although the position reporting
+functions are useful outside of errors. The position reported is the byte
+position (in the original document or entity encoding) of the first of the
+sequence of characters that generated the current event (or the error that
+caused the parse functions to return 0.)</p>
+<p>The position reporting functions are accurate only outside of the DTD.
+In other words, they usually return bogus information when called from within
+a DTD declaration handler.</p>
+
+<div class="fcndec"><a name="XML_GetErrorCode"><pre>
+enum XML_Error
+XML_GetErrorCode(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return what type of error has occurred.
+</div>
+
+<div class="fcndec"><a name="XML_ErrorString"><pre>
+const XML_LChar *
+XML_ErrorString(int code)
+</pre></a></div>
+<div class="fcndef">
+Return a string describing the error corresponding to code.
+The code should be one of the enums that can be returned from
+XML_GetErrorCode.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentByteIndex"><pre>
+long
+XML_GetCurrentByteIndex(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the byte offset of the position.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentLineNumber"><pre>
+int
+XML_GetCurrentLineNumber(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the line number of the position.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentColumnNumber"><pre>
+int
+XML_GetCurrentColumnNumber(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the offset, from the beginning of the current line, of
+the position.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentByteCount"><pre>
+int
+XML_GetCurrentByteCount(XML_Parser p);
+</pre></a></div>
+<div class="fcndef">
+Return the number of bytes in the current event. Returns 0 if the event is
+inside a reference to an internal entity.
+</div>
+
+<div class="fcndec"><a name="XML_GetInputContext"><pre>
+const char *
+XML_GetInputContext(XML_Parser p,
+                    int *offset,
+                    int *size);
+</pre></a></div>
+<div class="fcndef">
+<p>Returns the parser's input buffer, sets the integer pointed at by
+<code>offset</code> to the offset within this buffer of the current
+parse position, and set the integer pointed at by <code>size</code>
+to the size of the returned buffer.</p>
+<p>This should only be called from within a handler during an active
+parse and the returned buffer should only be referred to from within
+the handler that made the call. This input buffer contains the untranslated
+bytes of the input.</p>
+<p>Only a limited amount of context is kept, so if the event triggering
+a call spans over a very large amount of input, the actual parse position
+may be before the beginning of the buffer.</p>
+</div>
+
+<h3><a name="miscellaneous">Miscellaneous functions</a></h3>
+<p>The functions in this section either obtain state information from the
+parser or can be used to dynamicly set parser options.
+
+<div class="fcndec"><a name="XML_SetUserData"><pre>
+void
+XML_SetUserData(XML_Parser p,
+                void *userData)
+</pre></a></div>
+<div class="fcndef">
+This sets the user data pointer that gets passed to handlers.
+It overwrites any previous value for this pointer. Note that the
+application is responsible for freeing the memory associated with
+<code>userData</code> when it is finished with the parser. So if
+you call this when there's already a pointer there, and you haven't
+freed the memory associated with it, then you've probably just leaked
+memory.
+</div>
+
+<div class="fcndec"><a name="XML_GetUserData"><pre>
+void *
+XML_GetUserData(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+This returns the user data pointer that gets passed to handlers.
+It is actually implemented as a macro.
+</div>
+
+<div class="fcndec"><a name="XML_UseParserAsHandlerArg"><pre>
+void
+XML_UseParserAsHandlerArg(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+After this is called, handlers receive the parser in the
+userData argument. The userData information can still be obtained using
+the XML_GetUserData function.
+</div>
+
+<div class="fcndec"><a name="XML_SetBase"><pre>
+int
+XML_SetBase(XML_Parser p,
+            const XML_Char *base)
+</pre></a></div>
+<div class="fcndef">
+Set the base to be used for resolving relative URIs in system identifiers.
+The return value is 0 if there's no memory to store base, otherwise it's
+non-zero.
+</div>
+
+<div class="fcndec"><a name="XML_GetBase"><pre>
+const XML_Char *
+XML_GetBase(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the base for resolving relative URIs.
+</div>
+
+<div class="fcndec"><a name="XML_GetSpecifiedAttributeCount"><pre>
+int
+XML_GetSpecifiedAttributeCount(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+When attributes are reported to the start handler in the atts vector,
+attributes that were explicitly set in the element occur before any
+attributes that receive their value from default information in an
+ATTLIST declaration. This function returns the number of attributes that
+were explicitly set times two, thus giving the offset in the <code>atts</code>
+array passed to the start tag handler of the first attribute set
+due to defaults. It supplies information for the last call to a start
+handler. If called inside a start handler, then that means the current call.
+</div>
+
+<div class="fcndec"><a name="XML_GetIdAttributeIndex"><pre>
+int
+XML_GetIdAttributeIndex(XML_Parser p);
+</pre></a></div>
+<div class="fcndef">
+Returns the index of the ID attribute passed in the atts array
+in the last call to XML_StartElementHandler, or -1 if there is no ID
+attribute. If called inside a start handler, then that means the current call.
+</div>
+
+<div class="fcndec"><a name="XML_SetEncoding"><pre>
+int
+XML_SetEncoding(XML_Parser p,
+                const XML_Char *encoding)
+</pre></a></div>
+<div class="fcndef">
+Set the encoding to be used by the parser. It is equivalent to
+passing a non-null encoding argument to the parser creation functions.
+It must not be called after XML_Parser or XML_ParseBuffer have been
+called on the given parser.
+</div>
+
+<div class="fcndec"><a name="XML_SetParamEntityParsing"><pre>
+int
+XML_SetParamEntityParsing(XML_Parser p,
+                          enum XML_ParamEntityParsing code)
+</pre></a></div>
+<div class="fcndef">
+This enables parsing of parameter entities, including the external
+parameter entity that is the external DTD subset, according to
+<code>code</code>.
+The choices for <code>code</code> are:
+<ul>
+<li><code>XML_PARAM_ENTITY_PARSING_NEVER</code></li>
+<li><code>XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE</code></li>
+<li><code>XML_PARAM_ENTITY_PARSING_ALWAYS</code></li>
+</ul>
+</div>
+
+<div class="fcndec"><a name="XML_SetReturnNSTriplet"><pre>
+void
+XML_SetReturnNSTriplet(XML_Parser parser,
+                       int        do_nst);
+</pre></a></div>
+<div class="fcndef">
+<p>
+This function only has an effect when using a parser created with
+<a href="#XML_ParserCreateNS">XML_ParserCreateNS</a>, i.e. when namespace
+processing is in effect. The <code>do_nst</code> sets whether or not prefixes
+are returned with names qualified with a namespace prefix. If this function
+is called with <code>do_nst</code> non-zero, then afterwards namespace
+qualified names (that is qualified with a prefix as opposed to belonging
+to a default namespace) are returned as a triplet with the three parts
+separated by the namespace separator specified when the parser was created.
+The order of returned parts is URI, local name, and prefix.</p>
+<p>If <code>do_nst</code> is zero, then namespaces are reported in the
+default manner, URI then local_name separated by the namespace separator.</p>
+</div>
+
+<div class="fcndec"><a name="XML_ExpatVersion"><pre>
+XML_LChar *
+XML_ExpatVersion();
+</pre></a></div>
+<div class="fcndef">
+Return the library version as a string (e.g. "expat_1.95.1").
+</div>
+
+<div class="fcndec"><a name="XML_ExpatVersionInfo"><pre>
+struct XML_expat_version
+XML_ExpatVersionInfo();
+</pre></a></div>
+<div class="fcndef">
+Return the library version information as a structure.
+<div class="eg"><pre>
+typedef struct {
+  int major;
+  int minor;
+  int micro;
+} XML_Expat_Version;
+</pre></div>
+Some macros are also defined that support compile-time tests of the
+library version:
+<ul>
+<li><code>XML_MAJOR_VERSION</code></li>
+<li><code>XML_MINOR_VERSION</code></li>
+<li><code>XML_MICRO_VERSION</code></li>
+</ul>
+Testing these constants is currently the best way to determine if
+particular parts of the Expat API are available.
+</div>
+</dl>
+
+</body>
+</html>
Index: xc/extras/expat/doc/style.css
diff -u /dev/null xc/extras/expat/doc/style.css:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/doc/style.css	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,47 @@
+body {
+  background-color: white
+}
+
+.eg {
+  padding-left: 1em;
+  padding-top: .5em;
+  border: solid thin;
+  margin: 1em 0;
+  background-color: tan;
+  margin-left: 5%;
+  margin-right: 10%;
+}
+
+.handler {
+  width: 100%;
+  border-top-width: thin;  
+  margin-left: 5%;
+  margin-bottom: 1em;
+}
+
+.handler p {
+  margin-left: 3%;
+}
+
+.setter {
+  font-weight: bold;
+}
+
+.signature {
+  color: navy;
+}
+
+.fcndec {
+  width: 100%;
+  border-top-width: thin;
+  font-weight: bold;
+}
+
+.fcndef {
+  margin-left: 5%;
+  margin-bottom: 2em;
+}
+
+dd {
+  margin-bottom: 2em;
+}
Index: xc/extras/expat/examples/Makefile.in
diff -u /dev/null xc/extras/expat/examples/Makefile.in:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/examples/Makefile.in	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,54 @@
+################################################################
+# Process this file with top-level configure script to produce Makefile
+#
+# Copyright 2000 Clark Cooper
+#
+#  This file is part of EXPAT.
+#
+#  EXPAT is free software; you can redistribute it and/or modify it
+#  under the terms of the License (based on the MIT/X license) contained
+#  in the file COPYING that comes with this distribution.
+#
+# EXPAT 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
+#
+
+LIBDIR = ../lib/.libs
+INCDIR = ../lib
+
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@ -static
+LIBS = -L$(LIBDIR) -lexpat 
+CC = @CC@
+CFLAGS = @CFLAGS@ -I$(INCDIR)
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+
+
+all: elements outline
+
+elements: elements.o
+	$(CC) -o $@ $< $(LDFLAGS) $(LIBS)
+
+outline: outline.o
+	$(CC) -o $@ $< $(LDFLAGS) $(LIBS)
+
+check:	$(SUBDIRS)
+	@echo
+	@echo This package does not yet have a regression test.
+	@echo
+
+clean:
+	rm -f elements outline core *.o
+
+distclean: clean
+	rm -f Makefile
+
+maintainer-clean: distclean
Index: xc/extras/expat/examples/elements.c
diff -u /dev/null xc/extras/expat/examples/elements.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/examples/elements.c	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,49 @@
+/* This is simple demonstration of how to use expat. This program
+reads an XML document from standard input and writes a line with the
+name of each element to standard output indenting child elements by
+one tab stop more than their parent element. */
+
+#include <stdio.h>
+#include "expat.h"
+
+static void
+startElement(void *userData, const char *name, const char **atts)
+{
+  int i;
+  int *depthPtr = userData;
+  for (i = 0; i < *depthPtr; i++)
+    putchar('\t');
+  puts(name);
+  *depthPtr += 1;
+}
+
+static void
+endElement(void *userData, const char *name)
+{
+  int *depthPtr = userData;
+  *depthPtr -= 1;
+}
+
+int
+main(int argc, char *argv[])
+{
+  char buf[BUFSIZ];
+  XML_Parser parser = XML_ParserCreate(NULL);
+  int done;
+  int depth = 0;
+  XML_SetUserData(parser, &depth);
+  XML_SetElementHandler(parser, startElement, endElement);
+  do {
+    size_t len = fread(buf, 1, sizeof(buf), stdin);
+    done = len < sizeof(buf);
+    if (!XML_Parse(parser, buf, len, done)) {
+      fprintf(stderr,
+	      "%s at line %d\n",
+	      XML_ErrorString(XML_GetErrorCode(parser)),
+	      XML_GetCurrentLineNumber(parser));
+      return 1;
+    }
+  } while (!done);
+  XML_ParserFree(parser);
+  return 0;
+}
Index: xc/extras/expat/examples/outline.c
diff -u /dev/null xc/extras/expat/examples/outline.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/examples/outline.c	Mon Feb 18 16:44:20 2002
@@ -0,0 +1,88 @@
+/*****************************************************************
+ * outline.c
+ *
+ * Copyright 1999, Clark Cooper
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the license contained in the
+ * COPYING file that comes with the expat distribution.
+ *
+ * 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Read an XML document from standard input and print an element
+ * outline on standard output.
+ */
+
+
+#include <stdio.h>
+#include <expat.h>
+
+#define BUFFSIZE	8192
+
+char Buff[BUFFSIZE];
+
+int Depth;
+
+static void
+start(void *data, const char *el, const char **attr) {
+  int i;
+
+  for (i = 0; i < Depth; i++)
+    printf("  ");
+
+  printf("%s", el);
+
+  for (i = 0; attr[i]; i += 2) {
+    printf(" %s='%s'", attr[i], attr[i + 1]);
+  }
+
+  printf("\n");
+  Depth++;
+}  /* End of start handler */
+
+static void
+end(void *data, const char *el) {
+  Depth--;
+}  /* End of end handler */
+
+int
+main(int argc, char *argv[]) {
+  XML_Parser p = XML_ParserCreate(NULL);
+  if (! p) {
+    fprintf(stderr, "Couldn't allocate memory for parser\n");
+    exit(-1);
+  }
+
+  XML_SetElementHandler(p, start, end);
+
+  for (;;) {
+    int done;
+    int len;
+
+    len = fread(Buff, 1, BUFFSIZE, stdin);
+    if (ferror(stdin)) {
+      fprintf(stderr, "Read error\n");
+      exit(-1);
+    }
+    done = feof(stdin);
+
+    if (! XML_Parse(p, Buff, len, done)) {
+      fprintf(stderr, "Parse error at line %d:\n%s\n",
+	      XML_GetCurrentLineNumber(p),
+	      XML_ErrorString(XML_GetErrorCode(p)));
+      exit(-1);
+    }
+
+    if (done)
+      break;
+  }
+  return 0;
+}  /* End of main */
+
Index: xc/extras/expat/lib/Makefile.in
diff -u /dev/null xc/extras/expat/lib/Makefile.in:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/lib/Makefile.in	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,158 @@
+################################################################
+# Process this file with top-level configure script to produce Makefile
+#
+# Copyright 2000 Clark Cooper
+#
+#  This file is part of EXPAT.
+#
+#  EXPAT is free software; you can redistribute it and/or modify it
+#  under the terms of the License (based on the MIT/X license) contained
+#  in the file COPYING that comes with this distribution.
+#
+# EXPAT 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
+#
+
+
+SHELL = @SHELL@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+bindir = @bindir@
+sbindir = @sbindir@
+libexecdir = @libexecdir@
+datadir = @datadir@
+sysconfdir = @sysconfdir@
+sharedstatedir = @sharedstatedir@
+localstatedir = @localstatedir@
+libdir = @libdir@
+infodir = @infodir@
+mandir = @mandir@
+includedir = @includedir@
+oldincludedir = /usr/include
+
+subdir = lib
+
+top_builddir = ..
+
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_DATA = @INSTALL_DATA@
+
+host_alias = @host_alias@
+host_triplet = @host@
+AS = @AS@
+CC = @CC@
+DLLTOOL = @DLLTOOL@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+OBJDUMP = @OBJDUMP@
+PACKAGE = @PACKAGE@
+RANLIB = @RANLIB@
+VERSION = @VERSION@
+
+LIBRARY = libexpat.la
+SOURCES = xmlparse.c xmltok.c xmlrole.c
+OBJECTS = $(SOURCES:.c=.o)
+LTOBJECTS = $(SOURCES:.c=.lo)
+
+TEMPLATES = xmltok_impl.c xmltok_ns.c
+APIHEADER = expat.h
+HEADERS = ascii.h iasciitab.h utf8tab.h xmltok.h asciitab.h latin1tab.h \
+          nametab.h xmldef.h xmlrole.h xmltok_impl.h
+
+mkinstalldirs = $(SHELL) $(top_srcdir)/conftools/mkinstalldirs
+CONFIG_HEADER = ../config.h
+CONFIG_CLEAN_FILES = 
+
+INCLUDES = -I$(srcdir) -I. -I..
+DEFS = @DEFS@ -DPACKAGE='"$(PACKAGE)"' -DVERSION='"$(PACKAGE)_$(VERSION)"'
+
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@
+LIBS = @LIBS@
+CFLAGS = @CFLAGS@
+
+LIBREVISION = @LIBREVISION@
+LIBCURRENT  = @LIBCURRENT@
+LIBAGE      = @LIBAGE@
+
+COMPILE = $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link  $(CCLD) -version-info $(LIBCURRENT):$(LIBREVISION):$(LIBAGE) $(CFLAGS) $(LDFLAGS) -o $@
+DIST_COMMON =  Makefile.in
+
+
+DISTFILES = $(DIST_COMMON) $(SOURCES) $(TEMPLATES) $(APIHEADER) $(HEADERS) 
+
+TAR = gtar
+GZIP_ENV = --best
+
+all: $(LIBRARY)
+
+.SUFFIXES: .c .lo .o
+.PHONY: all clean distclean maintainer-clean
+
+.c.o:
+	$(COMPILE) -c $<
+
+.c.lo:
+	$(LTCOMPILE) -c $<
+
+Makefile: $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) \
+	  && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
+
+$(top_builddir)/config.status: $(top_builddir)/configure
+	cd $(top_builddir) && $(MAKE) config.status
+
+$(top_builddir)/config.h: $(top_builddir)/config.h.in
+	cd $(top_builddir) && $(MAKE) config.h
+
+clean:
+	rm -f $(LIBRARY) *.o *.lo *~
+	rm -rf .libs _libs
+
+distclean: clean
+	rm -f Makefile
+
+maintainer-clean: distclean
+
+check:	$(SUBDIRS)
+	@echo
+	@echo This package does not yet have a regression test.
+	@echo
+
+install: $(LIBRARY) $(APIHEADER)
+	$(mkinstalldirs) $(libdir) $(includedir)
+	$(LIBTOOL) --mode=install $(INSTALL) $(LIBRARY) $(libdir)/$(LIBRARY)
+	$(INSTALL_DATA) $(APIHEADER) $(includedir)
+
+uninstall:
+	$(LIBTOOL) --mode=uninstall rm -f $(libdir)/$(LIBRARY);
+	rm -f $(libdir)/$(APIHEADER)
+
+$(LIBRARY): $(LTOBJECTS)
+	$(LINK) -rpath $(libdir) $(LDFLAGS) $(LTOBJECTS)
+
+xmlparse.o \
+xmlparse.lo: xmlparse.c expat.h xmlrole.h xmltok.h $(top_builddir)/config.h
+
+xmlrole.o \
+xmlrole.lo: xmlrole.c ascii.h xmlrole.h $(top_builddir)/config.h
+
+xmltok.o \
+xmltok.lo: xmltok.c xmltok_impl.c xmltok_ns.c \
+          ascii.h asciitab.h iasciitab.h latin1tab.h nametab.h utf8tab.h \
+          xmltok.h xmltok_impl.h $(top_builddir)/config.h
Index: xc/extras/expat/lib/ascii.h
diff -u /dev/null xc/extras/expat/lib/ascii.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/lib/ascii.h	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,86 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#define ASCII_A 0x41
+#define ASCII_B 0x42
+#define ASCII_C 0x43
+#define ASCII_D 0x44
+#define ASCII_E 0x45
+#define ASCII_F 0x46
+#define ASCII_G 0x47
+#define ASCII_H 0x48
+#define ASCII_I 0x49
+#define ASCII_J 0x4A
+#define ASCII_K 0x4B
+#define ASCII_L 0x4C
+#define ASCII_M 0x4D
+#define ASCII_N 0x4E
+#define ASCII_O 0x4F
+#define ASCII_P 0x50
+#define ASCII_Q 0x51
+#define ASCII_R 0x52
+#define ASCII_S 0x53
+#define ASCII_T 0x54
+#define ASCII_U 0x55
+#define ASCII_V 0x56
+#define ASCII_W 0x57
+#define ASCII_X 0x58
+#define ASCII_Y 0x59
+#define ASCII_Z 0x5A
+
+#define ASCII_a 0x61
+#define ASCII_b 0x62
+#define ASCII_c 0x63
+#define ASCII_d 0x64
+#define ASCII_e 0x65
+#define ASCII_f 0x66
+#define ASCII_g 0x67
+#define ASCII_h 0x68
+#define ASCII_i 0x69
+#define ASCII_j 0x6A
+#define ASCII_k 0x6B
+#define ASCII_l 0x6C
+#define ASCII_m 0x6D
+#define ASCII_n 0x6E
+#define ASCII_o 0x6F
+#define ASCII_p 0x70
+#define ASCII_q 0x71
+#define ASCII_r 0x72
+#define ASCII_s 0x73
+#define ASCII_t 0x74
+#define ASCII_u 0x75
+#define ASCII_v 0x76
+#define ASCII_w 0x77
+#define ASCII_x 0x78
+#define ASCII_y 0x79
+#define ASCII_z 0x7A
+
+#define ASCII_0 0x30
+#define ASCII_1 0x31
+#define ASCII_2 0x32
+#define ASCII_3 0x33
+#define ASCII_4 0x34
+#define ASCII_5 0x35
+#define ASCII_6 0x36
+#define ASCII_7 0x37
+#define ASCII_8 0x38
+#define ASCII_9 0x39
+
+#define ASCII_TAB 0x09
+#define ASCII_SPACE 0x20 
+#define ASCII_EXCL 0x21
+#define ASCII_QUOT 0x22
+#define ASCII_AMP 0x26
+#define ASCII_APOS 0x27
+#define ASCII_MINUS 0x2D
+#define ASCII_PERIOD 0x2E
+#define ASCII_COLON 0x3A
+#define ASCII_SEMI 0x3B
+#define ASCII_LT 0x3C
+#define ASCII_EQUALS 0x3D
+#define ASCII_GT 0x3E
+#define ASCII_LSQB 0x5B
+#define ASCII_RSQB 0x5D
+#define ASCII_UNDERSCORE 0x5F
Index: xc/extras/expat/lib/asciitab.h
diff -u /dev/null xc/extras/expat/lib/asciitab.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:26 2003
+++ xc/extras/expat/lib/asciitab.h	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,37 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
Index: xc/extras/expat/lib/expat.h.in
diff -u /dev/null xc/extras/expat/lib/expat.h.in:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/expat.h.in	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,735 @@
+/*
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#ifndef XmlParse_INCLUDED
+#define XmlParse_INCLUDED 1
+
+#include <stdlib.h>
+
+#ifndef XMLPARSEAPI
+#  if defined(__declspec) && !defined(__BEOS__)
+#    define XMLPARSEAPI(type) __declspec(dllimport) type __cdecl
+#  else
+#    define XMLPARSEAPI(type) type
+#  endif
+#endif  /* not defined XMLPARSEAPI */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *XML_Parser;
+
+/* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+
+enum XML_Content_Type {
+  XML_CTYPE_EMPTY = 1,
+  XML_CTYPE_ANY,
+  XML_CTYPE_MIXED,
+  XML_CTYPE_NAME,
+  XML_CTYPE_CHOICE,
+  XML_CTYPE_SEQ
+};
+
+enum XML_Content_Quant {
+  XML_CQUANT_NONE,
+  XML_CQUANT_OPT,
+  XML_CQUANT_REP,
+  XML_CQUANT_PLUS
+};
+
+/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
+   XML_CQUANT_NONE, and the other fields will be zero or NULL.
+   If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
+   numchildren will contain number of elements that may be mixed in
+   and children point to an array of XML_Content cells that will be
+   all of XML_CTYPE_NAME type with no quantification.
+
+   If type == XML_CTYPE_NAME, then the name points to the name, and
+   the numchildren field will be zero and children will be NULL. The
+   quant fields indicates any quantifiers placed on the name.
+
+   CHOICE and SEQ will have name NULL, the number of children in
+   numchildren and children will point, recursively, to an array
+   of XML_Content cells.
+
+   The EMPTY, ANY, and MIXED types will only occur at top level.
+*/
+
+typedef struct XML_cp XML_Content;
+
+struct XML_cp {
+  enum XML_Content_Type		type;
+  enum XML_Content_Quant	quant;
+  XML_Char *			name;
+  unsigned int			numchildren;
+  XML_Content *			children;
+};
+
+
+/* This is called for an element declaration. See above for
+   description of the model argument. It's the caller's responsibility
+   to free model when finished with it.
+*/
+
+typedef void (*XML_ElementDeclHandler) (void *userData,
+                                        const XML_Char *name,
+                                        XML_Content *model);
+
+XMLPARSEAPI(void)
+XML_SetElementDeclHandler(XML_Parser parser,
+			  XML_ElementDeclHandler eldecl);
+
+/*
+  The Attlist declaration handler is called for *each* attribute. So
+  a single Attlist declaration with multiple attributes declared will
+  generate multiple calls to this handler. The "default" parameter
+  may be NULL in the case of the "#IMPLIED" or "#REQUIRED" keyword.
+  The "isrequired" parameter will be true and the default value will
+  be NULL in the case of "#REQUIRED". If "isrequired" is true and
+  default is non-NULL, then this is a "#FIXED" default.
+ */
+
+typedef void (*XML_AttlistDeclHandler) (void	       *userData,
+                                        const XML_Char *elname,
+                                        const XML_Char *attname,
+                                        const XML_Char *att_type,
+                                        const XML_Char *dflt,
+                                        int		isrequired);
+
+XMLPARSEAPI(void)
+XML_SetAttlistDeclHandler(XML_Parser parser,
+			  XML_AttlistDeclHandler attdecl);
+
+
+  /* The XML declaration handler is called for *both* XML declarations and
+     text declarations. The way to distinguish is that the version parameter
+     will be null for text declarations. The encoding parameter may be null
+     for XML declarations. The standalone parameter will be -1, 0, or 1
+     indicating respectively that there was no standalone parameter in
+     the declaration, that it was given as no, or that it was given as yes.
+  */
+
+typedef void (*XML_XmlDeclHandler) (void		*userData,
+                                    const XML_Char	*version,
+                                    const XML_Char	*encoding,
+                                    int		 	 standalone);
+
+XMLPARSEAPI(void)
+XML_SetXmlDeclHandler(XML_Parser parser,
+		      XML_XmlDeclHandler xmldecl);
+
+
+typedef struct {
+  void *(*malloc_fcn)(size_t size);
+  void *(*realloc_fcn)(void *ptr, size_t size);
+  void (*free_fcn)(void *ptr);
+} XML_Memory_Handling_Suite;
+
+/* Constructs a new parser; encoding is the encoding specified by the
+external protocol or null if there is none specified. */
+
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate(const XML_Char *encoding);
+
+/* Constructs a new parser and namespace processor.  Element type
+names and attribute names that belong to a namespace will be expanded;
+unprefixed attribute names are never expanded; unprefixed element type
+names are expanded only if there is a default namespace. The expanded
+name is the concatenation of the namespace URI, the namespace
+separator character, and the local part of the name.  If the namespace
+separator is '\0' then the namespace URI and the local part will be
+concatenated without any separator.  When a namespace is not declared,
+the name and prefix will be passed through without expansion. */
+
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
+
+
+/* Constructs a new parser using the memory management suit referred to
+   by memsuite. If memsuite is NULL, then use the standard library memory
+   suite. If namespaceSeparator is non-NULL it creates a parser with
+   namespace processing as described above. The character pointed at
+   will serve as the namespace separator.
+
+   All further memory operations used for the created parser will come from
+   the given suite.
+*/
+
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate_MM(const XML_Char *encoding,
+		    const XML_Memory_Handling_Suite *memsuite,
+		    const XML_Char *namespaceSeparator);
+
+/* atts is array of name/value pairs, terminated by 0;
+   names and values are 0 terminated. */
+
+typedef void (*XML_StartElementHandler)(void *userData,
+                                        const XML_Char *name,
+                                        const XML_Char **atts);
+
+typedef void (*XML_EndElementHandler)(void *userData,
+                                      const XML_Char *name);
+
+
+/* s is not 0 terminated. */
+typedef void (*XML_CharacterDataHandler)(void *userData,
+                                         const XML_Char *s,
+                                         int len);
+
+/* target and data are 0 terminated */
+typedef void (*XML_ProcessingInstructionHandler)(void *userData,
+                                                 const XML_Char *target,
+                                                 const XML_Char *data);
+
+/* data is 0 terminated */
+typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
+
+typedef void (*XML_StartCdataSectionHandler)(void *userData);
+typedef void (*XML_EndCdataSectionHandler)(void *userData);
+
+/* This is called for any characters in the XML document for
+which there is no applicable handler.  This includes both
+characters that are part of markup which is of a kind that is
+not reported (comments, markup declarations), or characters
+that are part of a construct which could be reported but
+for which no handler has been supplied. The characters are passed
+exactly as they were in the XML document except that
+they will be encoded in UTF-8.  Line boundaries are not normalized.
+Note that a byte order mark character is not passed to the default handler.
+There are no guarantees about how characters are divided between calls
+to the default handler: for example, a comment might be split between
+multiple calls. */
+
+typedef void (*XML_DefaultHandler)(void *userData,
+                                   const XML_Char *s,
+                                   int len);
+
+/* This is called for the start of the DOCTYPE declaration, before
+   any DTD or internal subset is parsed. */
+
+typedef void (*XML_StartDoctypeDeclHandler)(void *userData,
+                                            const XML_Char *doctypeName,
+                                            const XML_Char *sysid,
+                                            const XML_Char *pubid,
+                                            int has_internal_subset);
+
+/* This is called for the start of the DOCTYPE declaration when the
+closing > is encountered, but after processing any external subset. */
+typedef void (*XML_EndDoctypeDeclHandler)(void *userData);
+
+/* This is called for entity declarations. The is_parameter_entity
+   argument will be non-zero if the entity is a parameter entity, zero
+   otherwise.
+
+   For internal entities (<!ENTITY foo "bar">), value will
+   be non-null and systemId, publicID, and notationName will be null.
+   The value string is NOT null terminated; the length is provided in
+   the value_length argument. Since it is legal to have zero-length
+   values, do not use this argument to test for internal entities.
+
+   For external entities, value will be null and systemId will be non-null.
+   The publicId argument will be null unless a public identifier was
+   provided. The notationName argument will have a non-null value only
+   for unparsed entity declarations.
+*/
+
+typedef void (*XML_EntityDeclHandler) (void *userData,
+                                       const XML_Char *entityName,
+                                       int is_parameter_entity,
+                                       const XML_Char *value,
+                                       int value_length,
+                                       const XML_Char *base,
+                                       const XML_Char *systemId,
+                                       const XML_Char *publicId,
+                                       const XML_Char *notationName);
+				       
+XMLPARSEAPI(void)
+XML_SetEntityDeclHandler(XML_Parser parser,
+			 XML_EntityDeclHandler handler);
+
+/* OBSOLETE -- OBSOLETE -- OBSOLETE
+   This handler has been superceded by the EntityDeclHandler above.
+   It is provided here for backward compatibility.
+This is called for a declaration of an unparsed (NDATA)
+entity.  The base argument is whatever was set by XML_SetBase.
+The entityName, systemId and notationName arguments will never be null.
+The other arguments may be. */
+
+typedef void (*XML_UnparsedEntityDeclHandler)(void *userData,
+                                              const XML_Char *entityName,
+                                              const XML_Char *base,
+                                              const XML_Char *systemId,
+                                              const XML_Char *publicId,
+                                              const XML_Char *notationName);
+
+/* This is called for a declaration of notation.
+The base argument is whatever was set by XML_SetBase.
+The notationName will never be null.  The other arguments can be. */
+
+typedef void (*XML_NotationDeclHandler)(void *userData,
+                                        const XML_Char *notationName,
+                                        const XML_Char *base,
+                                        const XML_Char *systemId,
+                                        const XML_Char *publicId);
+
+/* When namespace processing is enabled, these are called once for
+each namespace declaration. The call to the start and end element
+handlers occur between the calls to the start and end namespace
+declaration handlers. For an xmlns attribute, prefix will be null.
+For an xmlns="" attribute, uri will be null. */
+
+typedef void (*XML_StartNamespaceDeclHandler)(void *userData,
+                                              const XML_Char *prefix,
+                                              const XML_Char *uri);
+
+typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
+                                            const XML_Char *prefix);
+
+/* This is called if the document is not standalone (it has an
+external subset or a reference to a parameter entity, but does not
+have standalone="yes"). If this handler returns 0, then processing
+will not continue, and the parser will return a
+XML_ERROR_NOT_STANDALONE error. */
+
+typedef int (*XML_NotStandaloneHandler)(void *userData);
+
+/* This is called for a reference to an external parsed general entity.
+The referenced entity is not automatically parsed.
+The application can parse it immediately or later using
+XML_ExternalEntityParserCreate.
+The parser argument is the parser parsing the entity containing the reference;
+it can be passed as the parser argument to XML_ExternalEntityParserCreate.
+The systemId argument is the system identifier as specified in the entity
+declaration; it will not be null.
+The base argument is the system identifier that should be used as the base for
+resolving systemId if systemId was relative; this is set by XML_SetBase;
+it may be null.
+The publicId argument is the public identifier as specified in the entity
+declaration, or null if none was specified; the whitespace in the public
+identifier will have been normalized as required by the XML spec.
+The context argument specifies the parsing context in the format
+expected by the context argument to
+XML_ExternalEntityParserCreate; context is valid only until the handler
+returns, so if the referenced entity is to be parsed later, it must be copied.
+The handler should return 0 if processing should not continue because of
+a fatal error in the handling of the external entity.
+In this case the calling parser will return an
+XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
+Note that unlike other handlers the first argument is the parser, not
+userData. */
+
+typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,
+                                            const XML_Char *context,
+                                            const XML_Char *base,
+                                            const XML_Char *systemId,
+                                            const XML_Char *publicId);
+
+/* This structure is filled in by the XML_UnknownEncodingHandler
+to provide information to the parser about encodings that are unknown
+to the parser.
+The map[b] member gives information about byte sequences
+whose first byte is b.
+If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar
+value c.
+If map[b] is -1, then the byte sequence is malformed.
+If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
+sequence that encodes a single Unicode scalar value.
+The data member will be passed as the first argument to the convert function.
+The convert function is used to convert multibyte sequences;
+s will point to a n-byte sequence where map[(unsigned char)*s] == -n.
+The convert function must return the Unicode scalar value
+represented by this byte sequence or -1 if the byte sequence is malformed.
+The convert function may be null if the encoding is a single-byte encoding,
+that is if map[b] >= -1 for all bytes b.
+When the parser is finished with the encoding, then if release is not null,
+it will call release passing it the data member;
+once release has been called, the convert function will not be called again.
+
+Expat places certain restrictions on the encodings that are supported
+using this mechanism.
+
+1. Every ASCII character that can appear in a well-formed XML document,
+other than the characters
+
+  $@\^`{}~
+
+must be represented by a single byte, and that byte must be the
+same byte that represents that character in ASCII.
+
+2. No character may require more than 4 bytes to encode.
+
+3. All characters encoded must have Unicode scalar values <= 0xFFFF, (i.e.,
+characters that would be encoded by surrogates in UTF-16 are  not
+allowed).  Note that this restriction doesn't apply to the built-in
+support for UTF-8 and UTF-16.
+
+4. No Unicode character may be encoded by more than one distinct sequence
+of bytes. */
+
+typedef struct {
+  int map[256];
+  void *data;
+  int (*convert)(void *data, const char *s);
+  void (*release)(void *data);
+} XML_Encoding;
+
+/* This is called for an encoding that is unknown to the parser.
+The encodingHandlerData argument is that which was passed as the
+second argument to XML_SetUnknownEncodingHandler.
+The name argument gives the name of the encoding as specified in
+the encoding declaration.
+If the callback can provide information about the encoding,
+it must fill in the XML_Encoding structure, and return 1.
+Otherwise it must return 0.
+If info does not describe a suitable encoding,
+then the parser will return an XML_UNKNOWN_ENCODING error. */
+
+typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
+                                          const XML_Char *name,
+                                          XML_Encoding *info);
+
+XMLPARSEAPI(void)
+XML_SetElementHandler(XML_Parser parser,
+		      XML_StartElementHandler start,
+		      XML_EndElementHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);
+
+XMLPARSEAPI(void)
+XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler);
+
+XMLPARSEAPI(void)
+XML_SetCharacterDataHandler(XML_Parser parser,
+			    XML_CharacterDataHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetProcessingInstructionHandler(XML_Parser parser,
+				    XML_ProcessingInstructionHandler handler);
+XMLPARSEAPI(void)
+XML_SetCommentHandler(XML_Parser parser,
+                      XML_CommentHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetCdataSectionHandler(XML_Parser parser,
+			   XML_StartCdataSectionHandler start,
+			   XML_EndCdataSectionHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartCdataSectionHandler(XML_Parser parser,
+                                XML_StartCdataSectionHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndCdataSectionHandler(XML_Parser parser,
+                              XML_EndCdataSectionHandler end);
+
+/* This sets the default handler and also inhibits expansion of
+internal entities.  The entity reference will be passed to the default
+handler. */
+
+XMLPARSEAPI(void)
+XML_SetDefaultHandler(XML_Parser parser,
+		      XML_DefaultHandler handler);
+
+/* This sets the default handler but does not inhibit expansion of
+internal entities.  The entity reference will not be passed to the
+default handler. */
+
+XMLPARSEAPI(void)
+XML_SetDefaultHandlerExpand(XML_Parser parser,
+		            XML_DefaultHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetDoctypeDeclHandler(XML_Parser parser,
+			  XML_StartDoctypeDeclHandler start,
+			  XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,
+			       XML_StartDoctypeDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndDoctypeDeclHandler(XML_Parser parser,
+			     XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+				 XML_UnparsedEntityDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNotationDeclHandler(XML_Parser parser,
+			   XML_NotationDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+			    XML_StartNamespaceDeclHandler start,
+			    XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,
+				 XML_StartNamespaceDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,
+			       XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetNotStandaloneHandler(XML_Parser parser,
+			    XML_NotStandaloneHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+				XML_ExternalEntityRefHandler handler);
+
+/* If a non-null value for arg is specified here, then it will be passed
+as the first argument to the external entity ref handler instead
+of the parser object. */
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
+
+XMLPARSEAPI(void)
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+			      XML_UnknownEncodingHandler handler,
+			      void *encodingHandlerData);
+
+/* This can be called within a handler for a start element, end element,
+processing instruction or character data.  It causes the corresponding
+markup to be passed to the default handler. */
+XMLPARSEAPI(void)
+XML_DefaultCurrent(XML_Parser parser);
+
+/* If do_nst is non-zero, and namespace processing is in effect, and
+   a name has a prefix (i.e. an explicit namespace qualifier) then
+   that name is returned as a triplet in a single
+   string separated by the separator character specified when the parser
+   was created: URI + sep + local_name + sep + prefix.
+
+   If do_nst is zero, then namespace information is returned in the
+   default manner (URI + sep + local_name) whether or not the names
+   has a prefix.
+*/
+
+XMLPARSEAPI(void)
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
+
+/* This value is passed as the userData argument to callbacks. */
+XMLPARSEAPI(void)
+XML_SetUserData(XML_Parser parser, void *userData);
+
+/* Returns the last value set by XML_SetUserData or null. */
+#define XML_GetUserData(parser) (*(void **)(parser))
+
+/* This is equivalent to supplying an encoding argument
+to XML_ParserCreate. It must not be called after XML_Parse
+or XML_ParseBuffer. */
+
+XMLPARSEAPI(int)
+XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
+
+/* If this function is called, then the parser will be passed
+as the first argument to callbacks instead of userData.
+The userData will still be accessible using XML_GetUserData. */
+
+XMLPARSEAPI(void)
+XML_UseParserAsHandlerArg(XML_Parser parser);
+
+/* Sets the base to be used for resolving relative URIs in system
+identifiers in declarations.  Resolving relative identifiers is left
+to the application: this value will be passed through as the base
+argument to the XML_ExternalEntityRefHandler, XML_NotationDeclHandler
+and XML_UnparsedEntityDeclHandler. The base argument will be copied.
+Returns zero if out of memory, non-zero otherwise. */
+
+XMLPARSEAPI(int)
+XML_SetBase(XML_Parser parser, const XML_Char *base);
+
+XMLPARSEAPI(const XML_Char *)
+XML_GetBase(XML_Parser parser);
+
+/* Returns the number of the attribute/value pairs passed in last call
+to the XML_StartElementHandler that were specified in the start-tag
+rather than defaulted. Each attribute/value pair counts as 2; thus
+this correspondds to an index into the atts array passed to the
+XML_StartElementHandler. */
+
+XMLPARSEAPI(int)
+XML_GetSpecifiedAttributeCount(XML_Parser parser);
+
+/* Returns the index of the ID attribute passed in the last call to
+XML_StartElementHandler, or -1 if there is no ID attribute.  Each
+attribute/value pair counts as 2; thus this correspondds to an index
+into the atts array passed to the XML_StartElementHandler. */
+
+XMLPARSEAPI(int)
+XML_GetIdAttributeIndex(XML_Parser parser);
+
+/* Parses some input. Returns 0 if a fatal error is detected.
+The last call to XML_Parse must have isFinal true;
+len may be zero for this call (or any other). */
+XMLPARSEAPI(int)
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
+
+XMLPARSEAPI(void *)
+XML_GetBuffer(XML_Parser parser, int len);
+
+XMLPARSEAPI(int)
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
+
+/* Creates an XML_Parser object that can parse an external general
+entity; context is a '\0'-terminated string specifying the parse
+context; encoding is a '\0'-terminated string giving the name of the
+externally specified encoding, or null if there is no externally
+specified encoding.  The context string consists of a sequence of
+tokens separated by formfeeds (\f); a token consisting of a name
+specifies that the general entity of the name is open; a token of the
+form prefix=uri specifies the namespace for a particular prefix; a
+token of the form =uri specifies the default namespace.  This can be
+called at any point after the first call to an
+ExternalEntityRefHandler so longer as the parser has not yet been
+freed.  The new parser is completely independent and may safely be
+used in a separate thread.  The handlers and userData are initialized
+from the parser argument.  Returns 0 if out of memory.  Otherwise
+returns a new XML_Parser object. */
+XMLPARSEAPI(XML_Parser)
+XML_ExternalEntityParserCreate(XML_Parser parser,
+			       const XML_Char *context,
+			       const XML_Char *encoding);
+
+enum XML_ParamEntityParsing {
+  XML_PARAM_ENTITY_PARSING_NEVER,
+  XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
+  XML_PARAM_ENTITY_PARSING_ALWAYS
+};
+
+/* Controls parsing of parameter entities (including the external DTD
+subset). If parsing of parameter entities is enabled, then references
+to external parameter entities (including the external DTD subset)
+will be passed to the handler set with
+XML_SetExternalEntityRefHandler.  The context passed will be 0.
+Unlike external general entities, external parameter entities can only
+be parsed synchronously.  If the external parameter entity is to be
+parsed, it must be parsed during the call to the external entity ref
+handler: the complete sequence of XML_ExternalEntityParserCreate,
+XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during
+this call.  After XML_ExternalEntityParserCreate has been called to
+create the parser for the external parameter entity (context must be 0
+for this call), it is illegal to make any calls on the old parser
+until XML_ParserFree has been called on the newly created parser.  If
+the library has been compiled without support for parameter entity
+parsing (ie without XML_DTD being defined), then
+XML_SetParamEntityParsing will return 0 if parsing of parameter
+entities is requested; otherwise it will return non-zero. */
+
+XMLPARSEAPI(int)
+XML_SetParamEntityParsing(XML_Parser parser,
+			  enum XML_ParamEntityParsing parsing);
+
+enum XML_Error {
+  XML_ERROR_NONE,
+  XML_ERROR_NO_MEMORY,
+  XML_ERROR_SYNTAX,
+  XML_ERROR_NO_ELEMENTS,
+  XML_ERROR_INVALID_TOKEN,
+  XML_ERROR_UNCLOSED_TOKEN,
+  XML_ERROR_PARTIAL_CHAR,
+  XML_ERROR_TAG_MISMATCH,
+  XML_ERROR_DUPLICATE_ATTRIBUTE,
+  XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
+  XML_ERROR_PARAM_ENTITY_REF,
+  XML_ERROR_UNDEFINED_ENTITY,
+  XML_ERROR_RECURSIVE_ENTITY_REF,
+  XML_ERROR_ASYNC_ENTITY,
+  XML_ERROR_BAD_CHAR_REF,
+  XML_ERROR_BINARY_ENTITY_REF,
+  XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+  XML_ERROR_MISPLACED_XML_PI,
+  XML_ERROR_UNKNOWN_ENCODING,
+  XML_ERROR_INCORRECT_ENCODING,
+  XML_ERROR_UNCLOSED_CDATA_SECTION,
+  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+  XML_ERROR_NOT_STANDALONE,
+  XML_ERROR_UNEXPECTED_STATE
+};
+
+/* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode
+returns information about the error. */
+
+XMLPARSEAPI(enum XML_Error)
+XML_GetErrorCode(XML_Parser parser);
+
+/* These functions return information about the current parse location.
+They may be called when XML_Parse or XML_ParseBuffer return 0;
+in this case the location is the location of the character at which
+the error was detected.
+They may also be called from any other callback called to report
+some parse event; in this the location is the location of the first
+of the sequence of characters that generated the event. */
+
+XMLPARSEAPI(int) XML_GetCurrentLineNumber(XML_Parser parser);
+XMLPARSEAPI(int) XML_GetCurrentColumnNumber(XML_Parser parser);
+XMLPARSEAPI(long) XML_GetCurrentByteIndex(XML_Parser parser);
+
+/* Return the number of bytes in the current event.
+Returns 0 if the event is in an internal entity. */
+
+XMLPARSEAPI(int)
+XML_GetCurrentByteCount(XML_Parser parser);
+
+/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
+   the integer pointed to by offset to the offset within this buffer
+   of the current parse position, and sets the integer pointed to by size
+   to the size of this buffer (the number of input bytes). Otherwise
+   returns a null pointer. Also returns a null pointer if a parse isn't
+   active.
+
+   NOTE: The character pointer returned should not be used outside
+   the handler that makes the call. */
+
+XMLPARSEAPI(const char *)
+XML_GetInputContext(XML_Parser parser,
+		    int *offset,
+		    int *size);
+
+/* For backwards compatibility with previous versions. */
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
+#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
+
+/* Frees memory used by the parser. */
+XMLPARSEAPI(void)
+XML_ParserFree(XML_Parser parser);
+
+/* Returns a string describing the error. */
+XMLPARSEAPI(const XML_LChar *)
+XML_ErrorString(int code);
+
+/* Return a string containing the version number of this expat */
+XMLPARSEAPI(const XML_LChar *)
+XML_ExpatVersion(void);
+
+typedef struct {
+  int major;
+  int minor;
+  int micro;
+} XML_Expat_Version;
+
+/* Return an XML_Expat_Version structure containing numeric version
+   number information for this version of expat */
+
+XMLPARSEAPI(XML_Expat_Version)
+XML_ExpatVersionInfo(void);
+
+#define XML_MAJOR_VERSION @EXPAT_MAJOR_VERSION@
+#define XML_MINOR_VERSION @EXPAT_MINOR_VERSION@
+#define XML_MICRO_VERSION @EXPAT_EDIT@
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlParse_INCLUDED */
Index: xc/extras/expat/lib/iasciitab.h
diff -u /dev/null xc/extras/expat/lib/iasciitab.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/iasciitab.h	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,38 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
Index: xc/extras/expat/lib/latin1tab.h
diff -u /dev/null xc/extras/expat/lib/latin1tab.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/latin1tab.h	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,37 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
+/* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
Index: xc/extras/expat/lib/nametab.h
diff -u /dev/null xc/extras/expat/lib/nametab.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/nametab.h	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,150 @@
+static const unsigned namingBitmap[] = {
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE,
+0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
+0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF,
+0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
+0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF,
+0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000,
+0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
+0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003,
+0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003,
+0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
+0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001,
+0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003,
+0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
+0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003,
+0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003,
+0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000,
+0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
+0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF,
+0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB,
+0x40000000, 0xF580C900, 0x00000007, 0x02010800,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF,
+0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
+0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF,
+0x00000000, 0x00004C40, 0x00000000, 0x00000000,
+0x00000007, 0x00000000, 0x00000000, 0x00000000,
+0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF,
+0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF,
+0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000,
+0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
+0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF,
+0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003,
+0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
+0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
+0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF,
+0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF,
+0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
+0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF,
+0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0,
+0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
+0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3,
+0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80,
+0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
+0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3,
+0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000,
+0xFEF02596, 0x3BFF6CAE, 0x03FF3F5F, 0x00000000,
+0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
+0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
+0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF,
+0x661FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF,
+};
+static const unsigned char nmstrtPages[] = {
+0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00,
+0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
+0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x15, 0x16, 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, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+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,
+};
+static const unsigned char namePages[] = {
+0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00,
+0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
+0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
+0x26, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x27, 0x16, 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, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+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,
+};
Index: xc/extras/expat/lib/utf8tab.h
diff -u /dev/null xc/extras/expat/lib/utf8tab.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/utf8tab.h	Mon Feb 18 16:44:21 2002
@@ -0,0 +1,38 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+
+/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
+/* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
Index: xc/extras/expat/lib/winconfig.h
diff -u /dev/null xc/extras/expat/lib/winconfig.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/winconfig.h	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,27 @@
+/*================================================================
+** Copyright 2000, Clark Cooper
+** All rights reserved.
+**
+** This is free software. You are permitted to copy, distribute, or modify
+** it under the terms of the MIT/X license (contained in the COPYING file
+** with this distribution.)
+**
+**
+*/
+
+#ifndef WINCONFIG_H
+#define WINCONFIG_H
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include <memory.h>
+#include <string.h>
+
+#define XML_NS 1
+#define XML_DTD 1
+#define XML_BYTE_ORDER 12
+#define XML_CONTEXT_BYTES 1024
+
+#endif /* ndef WINCONFIG_H */
Index: xc/extras/expat/lib/xmlparse.c
diff -u /dev/null xc/extras/expat/lib/xmlparse.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmlparse.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,4635 @@
+/*
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#ifdef COMPILED_FROM_DSP
+#  include "winconfig.h"
+#  define XMLPARSEAPI(type) __declspec(dllexport) type __cdecl
+#  include "expat.h"
+#  undef XMLPARSEAPI
+#else
+#include <config.h>
+
+#ifdef __declspec
+#  define XMLPARSEAPI(type) __declspec(dllexport) type __cdecl
+#endif
+
+#include "expat.h"
+
+#ifdef __declspec
+#  undef XMLPARSEAPI
+#endif
+#endif /* ndef COMPILED_FROM_DSP */
+
+#include <stddef.h>
+#include <string.h>
+
+#ifdef XML_UNICODE
+#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
+#define XmlConvert XmlUtf16Convert
+#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
+#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
+#define XmlEncode XmlUtf16Encode
+#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
+typedef unsigned short ICHAR;
+#else
+#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
+#define XmlConvert XmlUtf8Convert
+#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
+#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
+#define XmlEncode XmlUtf8Encode
+#define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
+typedef char ICHAR;
+#endif
+
+
+#ifndef XML_NS
+
+#define XmlInitEncodingNS XmlInitEncoding
+#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
+#undef XmlGetInternalEncodingNS
+#define XmlGetInternalEncodingNS XmlGetInternalEncoding
+#define XmlParseXmlDeclNS XmlParseXmlDecl
+
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#define XML_T(x) L ## x
+#else
+#define XML_T(x) x
+#endif
+
+/* Round up n to be a multiple of sz, where sz is a power of 2. */
+#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
+
+#include "xmltok.h"
+#include "xmlrole.h"
+
+typedef const XML_Char *KEY;
+
+typedef struct {
+  KEY name;
+} NAMED;
+
+typedef struct {
+  NAMED **v;
+  size_t size;
+  size_t used;
+  size_t usedLim;
+  XML_Memory_Handling_Suite *mem;
+} HASH_TABLE;
+
+typedef struct {
+  NAMED **p;
+  NAMED **end;
+} HASH_TABLE_ITER;
+
+#define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */
+#define INIT_DATA_BUF_SIZE 1024
+#define INIT_ATTS_SIZE 16
+#define INIT_BLOCK_SIZE 1024
+#define INIT_BUFFER_SIZE 1024
+
+#define EXPAND_SPARE 24
+
+typedef struct binding {
+  struct prefix *prefix;
+  struct binding *nextTagBinding;
+  struct binding *prevPrefixBinding;
+  const struct attribute_id *attId;
+  XML_Char *uri;
+  int uriLen;
+  int uriAlloc;
+} BINDING;
+
+typedef struct prefix {
+  const XML_Char *name;
+  BINDING *binding;
+} PREFIX;
+
+typedef struct {
+  const XML_Char *str;
+  const XML_Char *localPart;
+  int uriLen;
+} TAG_NAME;
+
+typedef struct tag {
+  struct tag *parent;
+  const char *rawName;
+  int rawNameLength;
+  TAG_NAME name;
+  char *buf;
+  char *bufEnd;
+  BINDING *bindings;
+} TAG;
+
+typedef struct {
+  const XML_Char *name;
+  const XML_Char *textPtr;
+  int textLen;
+  const XML_Char *systemId;
+  const XML_Char *base;
+  const XML_Char *publicId;
+  const XML_Char *notation;
+  char open;
+  char is_param;
+} ENTITY;
+
+typedef struct {
+  enum XML_Content_Type		type;
+  enum XML_Content_Quant	quant;
+  const XML_Char *		name;
+  int				firstchild;
+  int				lastchild;
+  int				childcnt;
+  int				nextsib;
+} CONTENT_SCAFFOLD;
+
+typedef struct block {
+  struct block *next;
+  int size;
+  XML_Char s[1];
+} BLOCK;
+
+typedef struct {
+  BLOCK *blocks;
+  BLOCK *freeBlocks;
+  const XML_Char *end;
+  XML_Char *ptr;
+  XML_Char *start;
+  XML_Memory_Handling_Suite *mem;
+} STRING_POOL;
+
+/* The XML_Char before the name is used to determine whether
+an attribute has been specified. */
+typedef struct attribute_id {
+  XML_Char *name;
+  PREFIX *prefix;
+  char maybeTokenized;
+  char xmlns;
+} ATTRIBUTE_ID;
+
+typedef struct {
+  const ATTRIBUTE_ID *id;
+  char isCdata;
+  const XML_Char *value;
+} DEFAULT_ATTRIBUTE;
+
+typedef struct {
+  const XML_Char *name;
+  PREFIX *prefix;
+  const ATTRIBUTE_ID *idAtt;
+  int nDefaultAtts;
+  int allocDefaultAtts;
+  DEFAULT_ATTRIBUTE *defaultAtts;
+} ELEMENT_TYPE;
+
+typedef struct {
+  HASH_TABLE generalEntities;
+  HASH_TABLE elementTypes;
+  HASH_TABLE attributeIds;
+  HASH_TABLE prefixes;
+  STRING_POOL pool;
+  int complete;
+  int standalone;
+#ifdef XML_DTD
+  HASH_TABLE paramEntities;
+#endif /* XML_DTD */
+  PREFIX defaultPrefix;
+  /* === scaffolding for building content model === */
+  int in_eldecl;
+  CONTENT_SCAFFOLD *scaffold;
+  unsigned contentStringLen;
+  unsigned scaffSize;
+  unsigned scaffCount;
+  int scaffLevel;
+  int *scaffIndex;
+} DTD;
+
+typedef struct open_internal_entity {
+  const char *internalEventPtr;
+  const char *internalEventEndPtr;
+  struct open_internal_entity *next;
+  ENTITY *entity;
+} OPEN_INTERNAL_ENTITY;
+
+typedef enum XML_Error Processor(XML_Parser parser,
+				 const char *start,
+				 const char *end,
+				 const char **endPtr);
+
+static Processor prologProcessor;
+static Processor prologInitProcessor;
+static Processor contentProcessor;
+static Processor cdataSectionProcessor;
+#ifdef XML_DTD
+static Processor ignoreSectionProcessor;
+#endif /* XML_DTD */
+static Processor epilogProcessor;
+static Processor errorProcessor;
+static Processor externalEntityInitProcessor;
+static Processor externalEntityInitProcessor2;
+static Processor externalEntityInitProcessor3;
+static Processor externalEntityContentProcessor;
+
+static enum XML_Error
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
+static enum XML_Error
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *, const char *);
+static enum XML_Error
+initializeEncoding(XML_Parser parser);
+static enum XML_Error
+doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
+	 const char *end, int tok, const char *next, const char **nextPtr);
+static enum XML_Error
+processInternalParamEntity(XML_Parser parser, ENTITY *entity);
+static enum XML_Error
+doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
+	  const char *start, const char *end, const char **endPtr);
+static enum XML_Error
+doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);
+#ifdef XML_DTD
+static enum XML_Error
+doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);
+#endif /* XML_DTD */
+static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *, const char *s,
+				TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
+static
+int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr);
+
+static int
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *,
+		int isCdata, int isId, const XML_Char *dfltValue,
+		XML_Parser parser);
+
+static enum XML_Error
+storeAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
+		    STRING_POOL *);
+static enum XML_Error
+appendAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
+		    STRING_POOL *);
+static ATTRIBUTE_ID *
+getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
+static enum XML_Error
+storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+static int
+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+static int
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+static void
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+
+static const XML_Char *getContext(XML_Parser parser);
+static int setContext(XML_Parser parser, const XML_Char *context);
+static void normalizePublicId(XML_Char *s);
+static int dtdInit(DTD *, XML_Parser parser);
+
+static void dtdDestroy(DTD *, XML_Parser parser);
+
+static int dtdCopy(DTD *newDtd, const DTD *oldDtd, XML_Parser parser);
+
+static int copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *,
+			   XML_Parser parser);
+
+#ifdef XML_DTD
+static void dtdSwap(DTD *, DTD *);
+#endif /* XML_DTD */
+
+static NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize);
+
+static void hashTableInit(HASH_TABLE *, XML_Memory_Handling_Suite *ms);
+
+static void hashTableDestroy(HASH_TABLE *);
+static void hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
+static NAMED *hashTableIterNext(HASH_TABLE_ITER *);
+static void poolInit(STRING_POOL *, XML_Memory_Handling_Suite *ms);
+static void poolClear(STRING_POOL *);
+static void poolDestroy(STRING_POOL *);
+static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+			    const char *ptr, const char *end);
+static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+				  const char *ptr, const char *end);
+
+static int poolGrow(STRING_POOL *pool);
+
+static int nextScaffoldPart(XML_Parser parser);
+static XML_Content *build_model(XML_Parser parser);
+
+static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s);
+static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
+static const XML_Char *poolAppendString(STRING_POOL *pool, const XML_Char *s);
+static ELEMENT_TYPE * getElementType(XML_Parser Paraser,
+				     const ENCODING *enc,
+				     const char *ptr,
+				     const char *end);
+
+#define poolStart(pool) ((pool)->start)
+#define poolEnd(pool) ((pool)->ptr)
+#define poolLength(pool) ((pool)->ptr - (pool)->start)
+#define poolChop(pool) ((void)--(pool->ptr))
+#define poolLastChar(pool) (((pool)->ptr)[-1])
+#define poolDiscard(pool) ((pool)->ptr = (pool)->start)
+#define poolFinish(pool) ((pool)->start = (pool)->ptr)
+#define poolAppendChar(pool, c) \
+  (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
+   ? 0 \
+   : ((*((pool)->ptr)++ = c), 1))
+
+typedef struct {
+  /* The first member must be userData so that the XML_GetUserData macro works. */
+  void *m_userData;
+  void *m_handlerArg;
+  char *m_buffer;
+  XML_Memory_Handling_Suite m_mem;
+  /* first character to be parsed */
+  const char *m_bufferPtr;
+  /* past last character to be parsed */
+  char *m_bufferEnd;
+  /* allocated end of buffer */
+  const char *m_bufferLim;
+  long m_parseEndByteIndex;
+  const char *m_parseEndPtr;
+  XML_Char *m_dataBuf;
+  XML_Char *m_dataBufEnd;
+  XML_StartElementHandler m_startElementHandler;
+  XML_EndElementHandler m_endElementHandler;
+  XML_CharacterDataHandler m_characterDataHandler;
+  XML_ProcessingInstructionHandler m_processingInstructionHandler;
+  XML_CommentHandler m_commentHandler;
+  XML_StartCdataSectionHandler m_startCdataSectionHandler;
+  XML_EndCdataSectionHandler m_endCdataSectionHandler;
+  XML_DefaultHandler m_defaultHandler;
+  XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
+  XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
+  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
+  XML_NotationDeclHandler m_notationDeclHandler;
+  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
+  XML_NotStandaloneHandler m_notStandaloneHandler;
+  XML_ExternalEntityRefHandler m_externalEntityRefHandler;
+  void *m_externalEntityRefHandlerArg;
+  XML_UnknownEncodingHandler m_unknownEncodingHandler;
+  XML_ElementDeclHandler m_elementDeclHandler;
+  XML_AttlistDeclHandler m_attlistDeclHandler;
+  XML_EntityDeclHandler m_entityDeclHandler;
+  XML_XmlDeclHandler m_xmlDeclHandler;
+  const ENCODING *m_encoding;
+  INIT_ENCODING m_initEncoding;
+  const ENCODING *m_internalEncoding;
+  const XML_Char *m_protocolEncodingName;
+  int m_ns;
+  int m_ns_triplets;
+  void *m_unknownEncodingMem;
+  void *m_unknownEncodingData;
+  void *m_unknownEncodingHandlerData;
+  void (*m_unknownEncodingRelease)(void *);
+  PROLOG_STATE m_prologState;
+  Processor *m_processor;
+  enum XML_Error m_errorCode;
+  const char *m_eventPtr;
+  const char *m_eventEndPtr;
+  const char *m_positionPtr;
+  OPEN_INTERNAL_ENTITY *m_openInternalEntities;
+  int m_defaultExpandInternalEntities;
+  int m_tagLevel;
+  ENTITY *m_declEntity;
+  const XML_Char *m_doctypeName;
+  const XML_Char *m_doctypeSysid;
+  const XML_Char *m_doctypePubid;
+  const XML_Char *m_declAttributeType;
+  const XML_Char *m_declNotationName;
+  const XML_Char *m_declNotationPublicId;
+  ELEMENT_TYPE *m_declElementType;
+  ATTRIBUTE_ID *m_declAttributeId;
+  char m_declAttributeIsCdata;
+  char m_declAttributeIsId;
+  DTD m_dtd;
+  const XML_Char *m_curBase;
+  TAG *m_tagStack;
+  TAG *m_freeTagList;
+  BINDING *m_inheritedBindings;
+  BINDING *m_freeBindingList;
+  int m_attsSize;
+  int m_nSpecifiedAtts;
+  int m_idAttIndex;
+  ATTRIBUTE *m_atts;
+  POSITION m_position;
+  STRING_POOL m_tempPool;
+  STRING_POOL m_temp2Pool;
+  char *m_groupConnector;
+  unsigned m_groupSize;
+  int m_hadExternalDoctype;
+  XML_Char m_namespaceSeparator;
+#ifdef XML_DTD
+  enum XML_ParamEntityParsing m_paramEntityParsing;
+  XML_Parser m_parentParser;
+#endif
+} Parser;
+
+#define MALLOC(s) (((Parser *)parser)->m_mem.malloc_fcn((s)))
+#define REALLOC(p,s) (((Parser *)parser)->m_mem.realloc_fcn((p),(s)))
+#define FREE(p) (((Parser *)parser)->m_mem.free_fcn((p)))
+
+#define userData (((Parser *)parser)->m_userData)
+#define handlerArg (((Parser *)parser)->m_handlerArg)
+#define startElementHandler (((Parser *)parser)->m_startElementHandler)
+#define endElementHandler (((Parser *)parser)->m_endElementHandler)
+#define characterDataHandler (((Parser *)parser)->m_characterDataHandler)
+#define processingInstructionHandler (((Parser *)parser)->m_processingInstructionHandler)
+#define commentHandler (((Parser *)parser)->m_commentHandler)
+#define startCdataSectionHandler (((Parser *)parser)->m_startCdataSectionHandler)
+#define endCdataSectionHandler (((Parser *)parser)->m_endCdataSectionHandler)
+#define defaultHandler (((Parser *)parser)->m_defaultHandler)
+#define startDoctypeDeclHandler (((Parser *)parser)->m_startDoctypeDeclHandler)
+#define endDoctypeDeclHandler (((Parser *)parser)->m_endDoctypeDeclHandler)
+#define unparsedEntityDeclHandler (((Parser *)parser)->m_unparsedEntityDeclHandler)
+#define notationDeclHandler (((Parser *)parser)->m_notationDeclHandler)
+#define startNamespaceDeclHandler (((Parser *)parser)->m_startNamespaceDeclHandler)
+#define endNamespaceDeclHandler (((Parser *)parser)->m_endNamespaceDeclHandler)
+#define notStandaloneHandler (((Parser *)parser)->m_notStandaloneHandler)
+#define externalEntityRefHandler (((Parser *)parser)->m_externalEntityRefHandler)
+#define externalEntityRefHandlerArg (((Parser *)parser)->m_externalEntityRefHandlerArg)
+#define internalEntityRefHandler (((Parser *)parser)->m_internalEntityRefHandler)
+#define unknownEncodingHandler (((Parser *)parser)->m_unknownEncodingHandler)
+#define elementDeclHandler (((Parser *)parser)->m_elementDeclHandler)
+#define attlistDeclHandler (((Parser *)parser)->m_attlistDeclHandler)
+#define entityDeclHandler (((Parser *)parser)->m_entityDeclHandler)
+#define xmlDeclHandler (((Parser *)parser)->m_xmlDeclHandler)
+#define encoding (((Parser *)parser)->m_encoding)
+#define initEncoding (((Parser *)parser)->m_initEncoding)
+#define internalEncoding (((Parser *)parser)->m_internalEncoding)
+#define unknownEncodingMem (((Parser *)parser)->m_unknownEncodingMem)
+#define unknownEncodingData (((Parser *)parser)->m_unknownEncodingData)
+#define unknownEncodingHandlerData \
+  (((Parser *)parser)->m_unknownEncodingHandlerData)
+#define unknownEncodingRelease (((Parser *)parser)->m_unknownEncodingRelease)
+#define protocolEncodingName (((Parser *)parser)->m_protocolEncodingName)
+#define ns (((Parser *)parser)->m_ns)
+#define ns_triplets (((Parser *)parser)->m_ns_triplets)
+#define prologState (((Parser *)parser)->m_prologState)
+#define processor (((Parser *)parser)->m_processor)
+#define errorCode (((Parser *)parser)->m_errorCode)
+#define eventPtr (((Parser *)parser)->m_eventPtr)
+#define eventEndPtr (((Parser *)parser)->m_eventEndPtr)
+#define positionPtr (((Parser *)parser)->m_positionPtr)
+#define position (((Parser *)parser)->m_position)
+#define openInternalEntities (((Parser *)parser)->m_openInternalEntities)
+#define defaultExpandInternalEntities (((Parser *)parser)->m_defaultExpandInternalEntities)
+#define tagLevel (((Parser *)parser)->m_tagLevel)
+#define buffer (((Parser *)parser)->m_buffer)
+#define bufferPtr (((Parser *)parser)->m_bufferPtr)
+#define bufferEnd (((Parser *)parser)->m_bufferEnd)
+#define parseEndByteIndex (((Parser *)parser)->m_parseEndByteIndex)
+#define parseEndPtr (((Parser *)parser)->m_parseEndPtr)
+#define bufferLim (((Parser *)parser)->m_bufferLim)
+#define dataBuf (((Parser *)parser)->m_dataBuf)
+#define dataBufEnd (((Parser *)parser)->m_dataBufEnd)
+#define dtd (((Parser *)parser)->m_dtd)
+#define curBase (((Parser *)parser)->m_curBase)
+#define declEntity (((Parser *)parser)->m_declEntity)
+#define doctypeName (((Parser *)parser)->m_doctypeName)
+#define doctypeSysid (((Parser *)parser)->m_doctypeSysid)
+#define doctypePubid (((Parser *)parser)->m_doctypePubid)
+#define declAttributeType (((Parser *)parser)->m_declAttributeType)
+#define declNotationName (((Parser *)parser)->m_declNotationName)
+#define declNotationPublicId (((Parser *)parser)->m_declNotationPublicId)
+#define declElementType (((Parser *)parser)->m_declElementType)
+#define declAttributeId (((Parser *)parser)->m_declAttributeId)
+#define declAttributeIsCdata (((Parser *)parser)->m_declAttributeIsCdata)
+#define declAttributeIsId (((Parser *)parser)->m_declAttributeIsId)
+#define freeTagList (((Parser *)parser)->m_freeTagList)
+#define freeBindingList (((Parser *)parser)->m_freeBindingList)
+#define inheritedBindings (((Parser *)parser)->m_inheritedBindings)
+#define tagStack (((Parser *)parser)->m_tagStack)
+#define atts (((Parser *)parser)->m_atts)
+#define attsSize (((Parser *)parser)->m_attsSize)
+#define nSpecifiedAtts (((Parser *)parser)->m_nSpecifiedAtts)
+#define idAttIndex (((Parser *)parser)->m_idAttIndex)
+#define tempPool (((Parser *)parser)->m_tempPool)
+#define temp2Pool (((Parser *)parser)->m_temp2Pool)
+#define groupConnector (((Parser *)parser)->m_groupConnector)
+#define groupSize (((Parser *)parser)->m_groupSize)
+#define hadExternalDoctype (((Parser *)parser)->m_hadExternalDoctype)
+#define namespaceSeparator (((Parser *)parser)->m_namespaceSeparator)
+#ifdef XML_DTD
+#define parentParser (((Parser *)parser)->m_parentParser)
+#define paramEntityParsing (((Parser *)parser)->m_paramEntityParsing)
+#endif /* XML_DTD */
+
+#ifdef COMPILED_FROM_DSP
+BOOL WINAPI DllMain(HINSTANCE h, DWORD r, LPVOID p) {
+  return TRUE;
+}
+#endif /* def COMPILED_FROM_DSP */
+
+#ifdef _MSC_VER
+#ifdef _DEBUG
+Parser *asParser(XML_Parser parser)
+{
+  return parser;
+}
+#endif
+#endif
+
+XML_Parser XML_ParserCreate(const XML_Char *encodingName)
+{
+  return XML_ParserCreate_MM(encodingName, NULL, NULL);
+}
+
+XML_Parser XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
+{
+  XML_Char tmp[2];
+  *tmp = nsSep;
+  return XML_ParserCreate_MM(encodingName, NULL, tmp);
+}
+
+XML_Parser
+XML_ParserCreate_MM(const XML_Char *encodingName,
+		    const XML_Memory_Handling_Suite *memsuite,
+		    const XML_Char *nameSep) {
+  
+  XML_Parser parser;
+  static
+  const XML_Char implicitContext[] = {
+    XML_T('x'), XML_T('m'), XML_T('l'), XML_T('='),
+    XML_T('h'), XML_T('t'), XML_T('t'), XML_T('p'), XML_T(':'),
+    XML_T('/'), XML_T('/'), XML_T('w'), XML_T('w'), XML_T('w'),
+    XML_T('.'), XML_T('w'), XML_T('3'),
+    XML_T('.'), XML_T('o'), XML_T('r'), XML_T('g'),
+    XML_T('/'), XML_T('X'), XML_T('M'), XML_T('L'),
+    XML_T('/'), XML_T('1'), XML_T('9'), XML_T('9'), XML_T('8'),
+    XML_T('/'), XML_T('n'), XML_T('a'), XML_T('m'), XML_T('e'),
+    XML_T('s'), XML_T('p'), XML_T('a'), XML_T('c'), XML_T('e'),
+    XML_T('\0')
+  };
+
+
+  if (memsuite) {
+    XML_Memory_Handling_Suite *mtemp;
+    parser = memsuite->malloc_fcn(sizeof(Parser));
+    mtemp = &(((Parser *) parser)->m_mem);
+    mtemp->malloc_fcn = memsuite->malloc_fcn;
+    mtemp->realloc_fcn = memsuite->realloc_fcn;
+    mtemp->free_fcn = memsuite->free_fcn;
+  }
+  else {
+    XML_Memory_Handling_Suite *mtemp;
+    parser = malloc(sizeof(Parser));
+    mtemp = &(((Parser *) parser)->m_mem);
+    mtemp->malloc_fcn = malloc;
+    mtemp->realloc_fcn = realloc;
+    mtemp->free_fcn = free;
+  }
+
+  if (!parser)
+    return parser;
+  processor = prologInitProcessor;
+  XmlPrologStateInit(&prologState);
+  userData = 0;
+  handlerArg = 0;
+  startElementHandler = 0;
+  endElementHandler = 0;
+  characterDataHandler = 0;
+  processingInstructionHandler = 0;
+  commentHandler = 0;
+  startCdataSectionHandler = 0;
+  endCdataSectionHandler = 0;
+  defaultHandler = 0;
+  startDoctypeDeclHandler = 0;
+  endDoctypeDeclHandler = 0;
+  unparsedEntityDeclHandler = 0;
+  notationDeclHandler = 0;
+  startNamespaceDeclHandler = 0;
+  endNamespaceDeclHandler = 0;
+  notStandaloneHandler = 0;
+  externalEntityRefHandler = 0;
+  externalEntityRefHandlerArg = parser;
+  unknownEncodingHandler = 0;
+  elementDeclHandler = 0;
+  attlistDeclHandler = 0;
+  entityDeclHandler = 0;
+  xmlDeclHandler = 0;
+  buffer = 0;
+  bufferPtr = 0;
+  bufferEnd = 0;
+  parseEndByteIndex = 0;
+  parseEndPtr = 0;
+  bufferLim = 0;
+  declElementType = 0;
+  declAttributeId = 0;
+  declEntity = 0;
+  doctypeName = 0;
+  doctypeSysid = 0;
+  doctypePubid = 0;
+  declAttributeType = 0;
+  declNotationName = 0;
+  declNotationPublicId = 0;
+  memset(&position, 0, sizeof(POSITION));
+  errorCode = XML_ERROR_NONE;
+  eventPtr = 0;
+  eventEndPtr = 0;
+  positionPtr = 0;
+  openInternalEntities = 0;
+  tagLevel = 0;
+  tagStack = 0;
+  freeTagList = 0;
+  freeBindingList = 0;
+  inheritedBindings = 0;
+  attsSize = INIT_ATTS_SIZE;
+  atts = MALLOC(attsSize * sizeof(ATTRIBUTE));
+  nSpecifiedAtts = 0;
+  dataBuf = MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
+  groupSize = 0;
+  groupConnector = 0;
+  hadExternalDoctype = 0;
+  unknownEncodingMem = 0;
+  unknownEncodingRelease = 0;
+  unknownEncodingData = 0;
+  unknownEncodingHandlerData = 0;
+  namespaceSeparator = '!';
+#ifdef XML_DTD
+  parentParser = 0;
+  paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
+#endif
+  ns = 0;
+  ns_triplets = 0;
+  poolInit(&tempPool, &(((Parser *) parser)->m_mem));
+  poolInit(&temp2Pool, &(((Parser *) parser)->m_mem));
+  protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0;
+  curBase = 0;
+  if (!dtdInit(&dtd, parser) || !atts || !dataBuf
+      || (encodingName && !protocolEncodingName)) {
+    XML_ParserFree(parser);
+    return 0;
+  }
+  dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
+
+  if (nameSep) {
+    XmlInitEncodingNS(&initEncoding, &encoding, 0);
+    ns = 1;
+    internalEncoding = XmlGetInternalEncodingNS();
+    namespaceSeparator = *nameSep;
+
+    if (! setContext(parser, implicitContext)) {
+      XML_ParserFree(parser);
+      return 0;
+    }
+  }
+  else {
+    XmlInitEncoding(&initEncoding, &encoding, 0);
+    internalEncoding = XmlGetInternalEncoding();
+  }
+
+  return parser;
+}  /* End XML_ParserCreate_MM */
+
+int XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
+{
+  if (!encodingName)
+    protocolEncodingName = 0;
+  else {
+    protocolEncodingName = poolCopyString(&tempPool, encodingName);
+    if (!protocolEncodingName)
+      return 0;
+  }
+  return 1;
+}
+
+XML_Parser XML_ExternalEntityParserCreate(XML_Parser oldParser,
+					  const XML_Char *context,
+					  const XML_Char *encodingName)
+{
+  XML_Parser parser = oldParser;
+  DTD *oldDtd = &dtd;
+  XML_StartElementHandler oldStartElementHandler = startElementHandler;
+  XML_EndElementHandler oldEndElementHandler = endElementHandler;
+  XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
+  XML_ProcessingInstructionHandler oldProcessingInstructionHandler = processingInstructionHandler;
+  XML_CommentHandler oldCommentHandler = commentHandler;
+  XML_StartCdataSectionHandler oldStartCdataSectionHandler = startCdataSectionHandler;
+  XML_EndCdataSectionHandler oldEndCdataSectionHandler = endCdataSectionHandler;
+  XML_DefaultHandler oldDefaultHandler = defaultHandler;
+  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler = unparsedEntityDeclHandler;
+  XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;
+  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler = startNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler = endNamespaceDeclHandler;
+  XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;
+  XML_ExternalEntityRefHandler oldExternalEntityRefHandler = externalEntityRefHandler;
+  XML_UnknownEncodingHandler oldUnknownEncodingHandler = unknownEncodingHandler;
+  XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;
+  XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;
+  XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;
+  XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;
+  ELEMENT_TYPE * oldDeclElementType = declElementType;
+
+  void *oldUserData = userData;
+  void *oldHandlerArg = handlerArg;
+  int oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
+  void *oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
+#ifdef XML_DTD
+  int oldParamEntityParsing = paramEntityParsing;
+#endif
+  int oldns_triplets = ns_triplets;
+
+  if (ns) {
+    XML_Char tmp[2];
+
+    *tmp = namespaceSeparator;
+    parser = XML_ParserCreate_MM(encodingName, &((Parser *)parser)->m_mem,
+				 tmp);
+  }
+  else {
+    parser = XML_ParserCreate_MM(encodingName, &((Parser *)parser)->m_mem,
+				 NULL);
+  }
+
+  if (!parser)
+    return 0;
+
+  startElementHandler = oldStartElementHandler;
+  endElementHandler = oldEndElementHandler;
+  characterDataHandler = oldCharacterDataHandler;
+  processingInstructionHandler = oldProcessingInstructionHandler;
+  commentHandler = oldCommentHandler;
+  startCdataSectionHandler = oldStartCdataSectionHandler;
+  endCdataSectionHandler = oldEndCdataSectionHandler;
+  defaultHandler = oldDefaultHandler;
+  unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
+  notationDeclHandler = oldNotationDeclHandler;
+  startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
+  endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
+  notStandaloneHandler = oldNotStandaloneHandler;
+  externalEntityRefHandler = oldExternalEntityRefHandler;
+  unknownEncodingHandler = oldUnknownEncodingHandler;
+  elementDeclHandler = oldElementDeclHandler;
+  attlistDeclHandler = oldAttlistDeclHandler;
+  entityDeclHandler = oldEntityDeclHandler;
+  xmlDeclHandler = oldXmlDeclHandler;
+  declElementType = oldDeclElementType;
+  userData = oldUserData;
+  if (oldUserData == oldHandlerArg)
+    handlerArg = userData;
+  else
+    handlerArg = parser;
+  if (oldExternalEntityRefHandlerArg != oldParser)
+    externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
+  defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
+  ns_triplets = oldns_triplets;
+#ifdef XML_DTD
+  paramEntityParsing = oldParamEntityParsing;
+  if (context) {
+#endif /* XML_DTD */
+    if (!dtdCopy(&dtd, oldDtd, parser) || !setContext(parser, context)) {
+      XML_ParserFree(parser);
+      return 0;
+    }
+    processor = externalEntityInitProcessor;
+#ifdef XML_DTD
+  }
+  else {
+    dtdSwap(&dtd, oldDtd);
+    parentParser = oldParser;
+    XmlPrologStateInitExternalEntity(&prologState);
+    dtd.complete = 1;
+    hadExternalDoctype = 1;
+  }
+#endif /* XML_DTD */
+  return parser;
+}
+
+static
+void destroyBindings(BINDING *bindings, XML_Parser parser)
+{
+  for (;;) {
+    BINDING *b = bindings;
+    if (!b)
+      break;
+    bindings = b->nextTagBinding;
+    FREE(b->uri);
+    FREE(b);
+  }
+}
+
+void XML_ParserFree(XML_Parser parser)
+{
+  for (;;) {
+    TAG *p;
+    if (tagStack == 0) {
+      if (freeTagList == 0)
+	break;
+      tagStack = freeTagList;
+      freeTagList = 0;
+    }
+    p = tagStack;
+    tagStack = tagStack->parent;
+    FREE(p->buf);
+    destroyBindings(p->bindings, parser);
+    FREE(p);
+  }
+  destroyBindings(freeBindingList, parser);
+  destroyBindings(inheritedBindings, parser);
+  poolDestroy(&tempPool);
+  poolDestroy(&temp2Pool);
+#ifdef XML_DTD
+  if (parentParser) {
+    if (hadExternalDoctype)
+      dtd.complete = 0;
+    dtdSwap(&dtd, &((Parser *)parentParser)->m_dtd);
+  }
+#endif /* XML_DTD */
+  dtdDestroy(&dtd, parser);
+  FREE((void *)atts);
+  if (groupConnector)
+    FREE(groupConnector);
+  if (buffer)
+    FREE(buffer);
+  FREE(dataBuf);
+  if (unknownEncodingMem)
+    FREE(unknownEncodingMem);
+  if (unknownEncodingRelease)
+    unknownEncodingRelease(unknownEncodingData);
+  FREE(parser);
+}
+
+void XML_UseParserAsHandlerArg(XML_Parser parser)
+{
+  handlerArg = parser;
+}
+
+void
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
+  ns_triplets = do_nst;
+}
+
+void XML_SetUserData(XML_Parser parser, void *p)
+{
+  if (handlerArg == userData)
+    handlerArg = userData = p;
+  else
+    userData = p;
+}
+
+int XML_SetBase(XML_Parser parser, const XML_Char *p)
+{
+  if (p) {
+    p = poolCopyString(&dtd.pool, p);
+    if (!p)
+      return 0;
+    curBase = p;
+  }
+  else
+    curBase = 0;
+  return 1;
+}
+
+const XML_Char *XML_GetBase(XML_Parser parser)
+{
+  return curBase;
+}
+
+int XML_GetSpecifiedAttributeCount(XML_Parser parser)
+{
+  return nSpecifiedAtts;
+}
+
+int XML_GetIdAttributeIndex(XML_Parser parser)
+{
+  return idAttIndex;
+}
+
+void XML_SetElementHandler(XML_Parser parser,
+			   XML_StartElementHandler start,
+			   XML_EndElementHandler end)
+{
+  startElementHandler = start;
+  endElementHandler = end;
+}
+
+void XML_SetStartElementHandler(XML_Parser parser,
+				XML_StartElementHandler start) {
+  startElementHandler = start;
+}
+
+void XML_SetEndElementHandler(XML_Parser parser,
+			      XML_EndElementHandler end) {
+  endElementHandler = end;
+}
+
+void XML_SetCharacterDataHandler(XML_Parser parser,
+				 XML_CharacterDataHandler handler)
+{
+  characterDataHandler = handler;
+}
+
+void XML_SetProcessingInstructionHandler(XML_Parser parser,
+					 XML_ProcessingInstructionHandler handler)
+{
+  processingInstructionHandler = handler;
+}
+
+void XML_SetCommentHandler(XML_Parser parser,
+			   XML_CommentHandler handler)
+{
+  commentHandler = handler;
+}
+
+void XML_SetCdataSectionHandler(XML_Parser parser,
+				XML_StartCdataSectionHandler start,
+			        XML_EndCdataSectionHandler end)
+{
+  startCdataSectionHandler = start;
+  endCdataSectionHandler = end;
+}
+
+void XML_SetStartCdataSectionHandler(XML_Parser parser,
+                                     XML_StartCdataSectionHandler start) {
+  startCdataSectionHandler = start;
+}
+
+void XML_SetEndCdataSectionHandler(XML_Parser parser,
+                                   XML_EndCdataSectionHandler end) {
+  endCdataSectionHandler = end;
+}
+
+void XML_SetDefaultHandler(XML_Parser parser,
+			   XML_DefaultHandler handler)
+{
+  defaultHandler = handler;
+  defaultExpandInternalEntities = 0;
+}
+
+void XML_SetDefaultHandlerExpand(XML_Parser parser,
+				 XML_DefaultHandler handler)
+{
+  defaultHandler = handler;
+  defaultExpandInternalEntities = 1;
+}
+
+void XML_SetDoctypeDeclHandler(XML_Parser parser,
+			       XML_StartDoctypeDeclHandler start,
+			       XML_EndDoctypeDeclHandler end)
+{
+  startDoctypeDeclHandler = start;
+  endDoctypeDeclHandler = end;
+}
+
+void XML_SetStartDoctypeDeclHandler(XML_Parser parser,
+				    XML_StartDoctypeDeclHandler start) {
+  startDoctypeDeclHandler = start;
+}
+
+void XML_SetEndDoctypeDeclHandler(XML_Parser parser,
+				  XML_EndDoctypeDeclHandler end) {
+  endDoctypeDeclHandler = end;
+}
+
+void XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+				      XML_UnparsedEntityDeclHandler handler)
+{
+  unparsedEntityDeclHandler = handler;
+}
+
+void XML_SetNotationDeclHandler(XML_Parser parser,
+				XML_NotationDeclHandler handler)
+{
+  notationDeclHandler = handler;
+}
+
+void XML_SetNamespaceDeclHandler(XML_Parser parser,
+				 XML_StartNamespaceDeclHandler start,
+				 XML_EndNamespaceDeclHandler end)
+{
+  startNamespaceDeclHandler = start;
+  endNamespaceDeclHandler = end;
+}
+
+void XML_SetStartNamespaceDeclHandler(XML_Parser parser,
+				      XML_StartNamespaceDeclHandler start) {
+  startNamespaceDeclHandler = start;
+}
+
+void XML_SetEndNamespaceDeclHandler(XML_Parser parser,
+				    XML_EndNamespaceDeclHandler end) {
+  endNamespaceDeclHandler = end;
+}
+
+
+void XML_SetNotStandaloneHandler(XML_Parser parser,
+				 XML_NotStandaloneHandler handler)
+{
+  notStandaloneHandler = handler;
+}
+
+void XML_SetExternalEntityRefHandler(XML_Parser parser,
+				     XML_ExternalEntityRefHandler handler)
+{
+  externalEntityRefHandler = handler;
+}
+
+void XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
+{
+  if (arg)
+    externalEntityRefHandlerArg = arg;
+  else
+    externalEntityRefHandlerArg = parser;
+}
+
+void XML_SetUnknownEncodingHandler(XML_Parser parser,
+				   XML_UnknownEncodingHandler handler,
+				   void *data)
+{
+  unknownEncodingHandler = handler;
+  unknownEncodingHandlerData = data;
+}
+
+void XML_SetElementDeclHandler(XML_Parser parser,
+			       XML_ElementDeclHandler eldecl)
+{
+  elementDeclHandler = eldecl;
+}
+
+void XML_SetAttlistDeclHandler(XML_Parser parser,
+			       XML_AttlistDeclHandler attdecl)
+{
+  attlistDeclHandler = attdecl;
+}
+
+void XML_SetEntityDeclHandler(XML_Parser parser,
+			      XML_EntityDeclHandler handler)
+{
+  entityDeclHandler = handler;
+}
+
+void XML_SetXmlDeclHandler(XML_Parser parser,
+			   XML_XmlDeclHandler handler) {
+  xmlDeclHandler = handler;
+}
+
+int XML_SetParamEntityParsing(XML_Parser parser,
+			      enum XML_ParamEntityParsing parsing)
+{
+#ifdef XML_DTD
+  paramEntityParsing = parsing;
+  return 1;
+#else
+  return parsing == XML_PARAM_ENTITY_PARSING_NEVER;
+#endif
+}
+
+int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
+{
+  if (len == 0) {
+    if (!isFinal)
+      return 1;
+    positionPtr = bufferPtr;
+    errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);
+    if (errorCode == XML_ERROR_NONE)
+      return 1;
+    eventEndPtr = eventPtr;
+    processor = errorProcessor;
+    return 0;
+  }
+#ifndef XML_CONTEXT_BYTES
+  else if (bufferPtr == bufferEnd) {
+    const char *end;
+    int nLeftOver;
+    parseEndByteIndex += len;
+    positionPtr = s;
+    if (isFinal) {
+      errorCode = processor(parser, s, parseEndPtr = s + len, 0);
+      if (errorCode == XML_ERROR_NONE)
+	return 1;
+      eventEndPtr = eventPtr;
+      processor = errorProcessor;
+      return 0;
+    }
+    errorCode = processor(parser, s, parseEndPtr = s + len, &end);
+    if (errorCode != XML_ERROR_NONE) {
+      eventEndPtr = eventPtr;
+      processor = errorProcessor;
+      return 0;
+    }
+    XmlUpdatePosition(encoding, positionPtr, end, &position);
+    nLeftOver = s + len - end;
+    if (nLeftOver) {
+      if (buffer == 0 || nLeftOver > bufferLim - buffer) {
+	/* FIXME avoid integer overflow */
+	buffer = buffer == 0 ? MALLOC(len * 2) : REALLOC(buffer, len * 2);
+	/* FIXME storage leak if realloc fails */
+	if (!buffer) {
+	  errorCode = XML_ERROR_NO_MEMORY;
+	  eventPtr = eventEndPtr = 0;
+	  processor = errorProcessor;
+	  return 0;
+	}
+	bufferLim = buffer + len * 2;
+      }
+      memcpy(buffer, end, nLeftOver);
+      bufferPtr = buffer;
+      bufferEnd = buffer + nLeftOver;
+    }
+    return 1;
+  }
+#endif  /* not defined XML_CONTEXT_BYTES */
+  else {
+    memcpy(XML_GetBuffer(parser, len), s, len);
+    return XML_ParseBuffer(parser, len, isFinal);
+  }
+}
+
+int XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
+{
+  const char *start = bufferPtr;
+  positionPtr = start;
+  bufferEnd += len;
+  parseEndByteIndex += len;
+  errorCode = processor(parser, start, parseEndPtr = bufferEnd,
+			isFinal ? (const char **)0 : &bufferPtr);
+  if (errorCode == XML_ERROR_NONE) {
+    if (!isFinal)
+      XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
+    return 1;
+  }
+  else {
+    eventEndPtr = eventPtr;
+    processor = errorProcessor;
+    return 0;
+  }
+}
+
+void *XML_GetBuffer(XML_Parser parser, int len)
+{
+  if (len > bufferLim - bufferEnd) {
+    /* FIXME avoid integer overflow */
+    int neededSize = len + (bufferEnd - bufferPtr);
+#ifdef XML_CONTEXT_BYTES
+    int keep = bufferPtr - buffer;
+
+    if (keep > XML_CONTEXT_BYTES)
+      keep = XML_CONTEXT_BYTES;
+    neededSize += keep;
+#endif  /* defined XML_CONTEXT_BYTES */
+    if (neededSize  <= bufferLim - buffer) {
+#ifdef XML_CONTEXT_BYTES
+      if (keep < bufferPtr - buffer) {
+	int offset = (bufferPtr - buffer) - keep;
+	memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);
+	bufferEnd -= offset;
+	bufferPtr -= offset;
+      }
+#else
+      memmove(buffer, bufferPtr, bufferEnd - bufferPtr);
+      bufferEnd = buffer + (bufferEnd - bufferPtr);
+      bufferPtr = buffer;
+#endif  /* not defined XML_CONTEXT_BYTES */
+    }
+    else {
+      char *newBuf;
+      int bufferSize = bufferLim - bufferPtr;
+      if (bufferSize == 0)
+	bufferSize = INIT_BUFFER_SIZE;
+      do {
+	bufferSize *= 2;
+      } while (bufferSize < neededSize);
+      newBuf = MALLOC(bufferSize);
+      if (newBuf == 0) {
+	errorCode = XML_ERROR_NO_MEMORY;
+	return 0;
+      }
+      bufferLim = newBuf + bufferSize;
+#ifdef XML_CONTEXT_BYTES
+      if (bufferPtr) {
+	int keep = bufferPtr - buffer;
+	if (keep > XML_CONTEXT_BYTES)
+	  keep = XML_CONTEXT_BYTES;
+	memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);
+	FREE(buffer);
+	buffer = newBuf;
+	bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;
+	bufferPtr = buffer + keep;
+      }
+      else {
+	bufferEnd = newBuf + (bufferEnd - bufferPtr);
+	bufferPtr = buffer = newBuf;
+      }
+#else
+      if (bufferPtr) {
+	memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);
+	FREE(buffer);
+      }
+      bufferEnd = newBuf + (bufferEnd - bufferPtr);
+      bufferPtr = buffer = newBuf;
+#endif  /* not defined XML_CONTEXT_BYTES */
+    }
+  }
+  return bufferEnd;
+}
+
+enum XML_Error XML_GetErrorCode(XML_Parser parser)
+{
+  return errorCode;
+}
+
+long XML_GetCurrentByteIndex(XML_Parser parser)
+{
+  if (eventPtr)
+    return parseEndByteIndex - (parseEndPtr - eventPtr);
+  return -1;
+}
+
+int XML_GetCurrentByteCount(XML_Parser parser)
+{
+  if (eventEndPtr && eventPtr)
+    return eventEndPtr - eventPtr;
+  return 0;
+}
+
+const char * XML_GetInputContext(XML_Parser parser, int *offset, int *size)
+{
+#ifdef XML_CONTEXT_BYTES
+  if (eventPtr && buffer) {
+    *offset = eventPtr - buffer;
+    *size   = bufferEnd - buffer;
+    return buffer;
+  }
+#endif /* defined XML_CONTEXT_BYTES */
+  return (char *) 0;
+}
+
+int XML_GetCurrentLineNumber(XML_Parser parser)
+{
+  if (eventPtr) {
+    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
+    positionPtr = eventPtr;
+  }
+  return position.lineNumber + 1;
+}
+
+int XML_GetCurrentColumnNumber(XML_Parser parser)
+{
+  if (eventPtr) {
+    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
+    positionPtr = eventPtr;
+  }
+  return position.columnNumber;
+}
+
+void XML_DefaultCurrent(XML_Parser parser)
+{
+  if (defaultHandler) {
+    if (openInternalEntities)
+      reportDefault(parser,
+	            internalEncoding,
+		    openInternalEntities->internalEventPtr,
+		    openInternalEntities->internalEventEndPtr);
+    else
+      reportDefault(parser, encoding, eventPtr, eventEndPtr);
+  }
+}
+
+const XML_LChar *XML_ErrorString(int code)
+{
+  static const XML_LChar *message[] = {
+    0,
+    XML_T("out of memory"),
+    XML_T("syntax error"),
+    XML_T("no element found"),
+    XML_T("not well-formed (invalid token)"),
+    XML_T("unclosed token"),
+    XML_T("unclosed token"),
+    XML_T("mismatched tag"),
+    XML_T("duplicate attribute"),
+    XML_T("junk after document element"),
+    XML_T("illegal parameter entity reference"),
+    XML_T("undefined entity"),
+    XML_T("recursive entity reference"),
+    XML_T("asynchronous entity"),
+    XML_T("reference to invalid character number"),
+    XML_T("reference to binary entity"),
+    XML_T("reference to external entity in attribute"),
+    XML_T("xml processing instruction not at start of external entity"),
+    XML_T("unknown encoding"),
+    XML_T("encoding specified in XML declaration is incorrect"),
+    XML_T("unclosed CDATA section"),
+    XML_T("error in processing external entity reference"),
+    XML_T("document is not standalone"),
+    XML_T("unexpected parser state - please send a bug report")
+  };
+  if (code > 0 && code < sizeof(message)/sizeof(message[0]))
+    return message[code];
+  return 0;
+}
+
+const XML_LChar *
+XML_ExpatVersion(void) {
+  return VERSION;
+}
+
+XML_Expat_Version
+XML_ExpatVersionInfo(void) {
+  XML_Expat_Version version;
+
+  version.major = XML_MAJOR_VERSION;
+  version.minor = XML_MINOR_VERSION;
+  version.micro = XML_MICRO_VERSION;
+
+  return version;
+}
+
+static
+enum XML_Error contentProcessor(XML_Parser parser,
+				const char *start,
+				const char *end,
+				const char **endPtr)
+{
+  return doContent(parser, 0, encoding, start, end, endPtr);
+}
+
+static
+enum XML_Error externalEntityInitProcessor(XML_Parser parser,
+					   const char *start,
+					   const char *end,
+					   const char **endPtr)
+{
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  processor = externalEntityInitProcessor2;
+  return externalEntityInitProcessor2(parser, start, end, endPtr);
+}
+
+static
+enum XML_Error externalEntityInitProcessor2(XML_Parser parser,
+					    const char *start,
+					    const char *end,
+					    const char **endPtr)
+{
+  const char *next;
+  int tok = XmlContentTok(encoding, start, end, &next);
+  switch (tok) {
+  case XML_TOK_BOM:
+    start = next;
+    break;
+  case XML_TOK_PARTIAL:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  processor = externalEntityInitProcessor3;
+  return externalEntityInitProcessor3(parser, start, end, endPtr);
+}
+
+static
+enum XML_Error externalEntityInitProcessor3(XML_Parser parser,
+					    const char *start,
+					    const char *end,
+					    const char **endPtr)
+{
+  const char *next;
+  int tok = XmlContentTok(encoding, start, end, &next);
+  switch (tok) {
+  case XML_TOK_XML_DECL:
+    {
+      enum XML_Error result = processXmlDecl(parser, 1, start, next);
+      if (result != XML_ERROR_NONE)
+	return result;
+      start = next;
+    }
+    break;
+  case XML_TOK_PARTIAL:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  processor = externalEntityContentProcessor;
+  tagLevel = 1;
+  return doContent(parser, 1, encoding, start, end, endPtr);
+}
+
+static
+enum XML_Error externalEntityContentProcessor(XML_Parser parser,
+					      const char *start,
+					      const char *end,
+					      const char **endPtr)
+{
+  return doContent(parser, 1, encoding, start, end, endPtr);
+}
+
+static enum XML_Error
+doContent(XML_Parser parser,
+	  int startTagLevel,
+	  const ENCODING *enc,
+	  const char *s,
+	  const char *end,
+	  const char **nextPtr)
+{
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == encoding) {
+    eventPP = &eventPtr;
+    eventEndPP = &eventEndPtr;
+  }
+  else {
+    eventPP = &(openInternalEntities->internalEventPtr);
+    eventEndPP = &(openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+  for (;;) {
+    const char *next = s; /* XmlContentTok doesn't always set the last arg */
+    int tok = XmlContentTok(enc, s, end, &next);
+    *eventEndPP = next;
+    switch (tok) {
+    case XML_TOK_TRAILING_CR:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      *eventEndPP = end;
+      if (characterDataHandler) {
+	XML_Char c = 0xA;
+	characterDataHandler(handlerArg, &c, 1);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, end);
+      if (startTagLevel == 0)
+	return XML_ERROR_NO_ELEMENTS;
+      if (tagLevel != startTagLevel)
+	return XML_ERROR_ASYNC_ENTITY;
+      return XML_ERROR_NONE;
+    case XML_TOK_NONE:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      if (startTagLevel > 0) {
+	if (tagLevel != startTagLevel)
+	  return XML_ERROR_ASYNC_ENTITY;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_NO_ELEMENTS;
+    case XML_TOK_INVALID:
+      *eventPP = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_ENTITY_REF:
+      {
+	const XML_Char *name;
+	ENTITY *entity;
+	XML_Char ch = XmlPredefinedEntityName(enc,
+					      s + enc->minBytesPerChar,
+					      next - enc->minBytesPerChar);
+	if (ch) {
+	  if (characterDataHandler)
+	    characterDataHandler(handlerArg, &ch, 1);
+	  else if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
+	  break;
+	}
+	name = poolStoreString(&dtd.pool, enc,
+				s + enc->minBytesPerChar,
+				next - enc->minBytesPerChar);
+	if (!name)
+	  return XML_ERROR_NO_MEMORY;
+	entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
+	poolDiscard(&dtd.pool);
+	if (!entity) {
+	  if (dtd.complete || dtd.standalone)
+	    return XML_ERROR_UNDEFINED_ENTITY;
+	  if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
+	  break;
+	}
+	if (entity->open)
+	  return XML_ERROR_RECURSIVE_ENTITY_REF;
+	if (entity->notation)
+	  return XML_ERROR_BINARY_ENTITY_REF;
+	if (entity) {
+	  if (entity->textPtr) {
+	    enum XML_Error result;
+	    OPEN_INTERNAL_ENTITY openEntity;
+	    if (defaultHandler && !defaultExpandInternalEntities) {
+	      reportDefault(parser, enc, s, next);
+	      break;
+	    }
+	    entity->open = 1;
+	    openEntity.next = openInternalEntities;
+	    openInternalEntities = &openEntity;
+	    openEntity.entity = entity;
+	    openEntity.internalEventPtr = 0;
+	    openEntity.internalEventEndPtr = 0;
+	    result = doContent(parser,
+			       tagLevel,
+			       internalEncoding,
+			       (char *)entity->textPtr,
+			       (char *)(entity->textPtr + entity->textLen),
+			       0);
+	    entity->open = 0;
+	    openInternalEntities = openEntity.next;
+	    if (result)
+	      return result;
+	  }
+	  else if (externalEntityRefHandler) {
+	    const XML_Char *context;
+	    entity->open = 1;
+	    context = getContext(parser);
+	    entity->open = 0;
+	    if (!context)
+	      return XML_ERROR_NO_MEMORY;
+	    if (!externalEntityRefHandler(externalEntityRefHandlerArg,
+				          context,
+					  entity->base,
+					  entity->systemId,
+					  entity->publicId))
+	      return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+	    poolDiscard(&tempPool);
+	  }
+	  else if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
+	}
+	break;
+      }
+    case XML_TOK_START_TAG_WITH_ATTS:
+      if (!startElementHandler) {
+	enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
+	if (result)
+	  return result;
+      }
+      /* fall through */
+    case XML_TOK_START_TAG_NO_ATTS:
+      {
+	TAG *tag;
+	if (freeTagList) {
+	  tag = freeTagList;
+	  freeTagList = freeTagList->parent;
+	}
+	else {
+	  tag = MALLOC(sizeof(TAG));
+	  if (!tag)
+	    return XML_ERROR_NO_MEMORY;
+	  tag->buf = MALLOC(INIT_TAG_BUF_SIZE);
+	  if (!tag->buf)
+	    return XML_ERROR_NO_MEMORY;
+	  tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
+	}
+	tag->bindings = 0;
+	tag->parent = tagStack;
+	tagStack = tag;
+	tag->name.localPart = 0;
+	tag->rawName = s + enc->minBytesPerChar;
+	tag->rawNameLength = XmlNameLength(enc, tag->rawName);
+	if (nextPtr) {
+	  /* Need to guarantee that:
+	     tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)) <= tag->bufEnd - sizeof(XML_Char) */
+	  if (tag->rawNameLength + (int)(sizeof(XML_Char) - 1) + (int)sizeof(XML_Char) > tag->bufEnd - tag->buf) {
+	    int bufSize = tag->rawNameLength * 4;
+	    bufSize = ROUND_UP(bufSize, sizeof(XML_Char));
+	    tag->buf = REALLOC(tag->buf, bufSize);
+	    if (!tag->buf)
+	      return XML_ERROR_NO_MEMORY;
+	    tag->bufEnd = tag->buf + bufSize;
+	  }
+	  memcpy(tag->buf, tag->rawName, tag->rawNameLength);
+	  tag->rawName = tag->buf;
+	}
+	++tagLevel;
+	if (startElementHandler) {
+	  enum XML_Error result;
+	  XML_Char *toPtr;
+	  for (;;) {
+	    const char *rawNameEnd = tag->rawName + tag->rawNameLength;
+	    const char *fromPtr = tag->rawName;
+	    int bufSize;
+	    if (nextPtr)
+	      toPtr = (XML_Char *)(tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)));
+	    else
+	      toPtr = (XML_Char *)tag->buf;
+	    tag->name.str = toPtr;
+	    XmlConvert(enc,
+		       &fromPtr, rawNameEnd,
+		       (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
+	    if (fromPtr == rawNameEnd)
+	      break;
+	    bufSize = (tag->bufEnd - tag->buf) << 1;
+	    tag->buf = REALLOC(tag->buf, bufSize);
+	    if (!tag->buf)
+	      return XML_ERROR_NO_MEMORY;
+	    tag->bufEnd = tag->buf + bufSize;
+	    if (nextPtr)
+	      tag->rawName = tag->buf;
+	  }
+	  *toPtr = XML_T('\0');
+	  result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
+	  if (result)
+	    return result;
+	  startElementHandler(handlerArg, tag->name.str, (const XML_Char **)atts);
+	  poolClear(&tempPool);
+	}
+	else {
+	  tag->name.str = 0;
+	  if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
+	}
+	break;
+      }
+    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
+      if (!startElementHandler) {
+	enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
+	if (result)
+	  return result;
+      }
+      /* fall through */
+    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
+      if (startElementHandler || endElementHandler) {
+	const char *rawName = s + enc->minBytesPerChar;
+	enum XML_Error result;
+	BINDING *bindings = 0;
+	TAG_NAME name;
+	name.str = poolStoreString(&tempPool, enc, rawName,
+				   rawName + XmlNameLength(enc, rawName));
+	if (!name.str)
+	  return XML_ERROR_NO_MEMORY;
+	poolFinish(&tempPool);
+	result = storeAtts(parser, enc, s, &name, &bindings);
+	if (result)
+	  return result;
+	poolFinish(&tempPool);
+	if (startElementHandler)
+	  startElementHandler(handlerArg, name.str, (const XML_Char **)atts);
+	if (endElementHandler) {
+	  if (startElementHandler)
+	    *eventPP = *eventEndPP;
+	  endElementHandler(handlerArg, name.str);
+	}
+	poolClear(&tempPool);
+	while (bindings) {
+	  BINDING *b = bindings;
+	  if (endNamespaceDeclHandler)
+	    endNamespaceDeclHandler(handlerArg, b->prefix->name);
+	  bindings = bindings->nextTagBinding;
+	  b->nextTagBinding = freeBindingList;
+	  freeBindingList = b;
+	  b->prefix->binding = b->prevPrefixBinding;
+	}
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      if (tagLevel == 0)
+	return epilogProcessor(parser, next, end, nextPtr);
+      break;
+    case XML_TOK_END_TAG:
+      if (tagLevel == startTagLevel)
+        return XML_ERROR_ASYNC_ENTITY;
+      else {
+	int len;
+	const char *rawName;
+	TAG *tag = tagStack;
+	tagStack = tag->parent;
+	tag->parent = freeTagList;
+	freeTagList = tag;
+	rawName = s + enc->minBytesPerChar*2;
+	len = XmlNameLength(enc, rawName);
+	if (len != tag->rawNameLength
+	    || memcmp(tag->rawName, rawName, len) != 0) {
+	  *eventPP = rawName;
+	  return XML_ERROR_TAG_MISMATCH;
+	}
+	--tagLevel;
+	if (endElementHandler && tag->name.str) {
+	  if (tag->name.localPart) {
+	    XML_Char *to = (XML_Char *)tag->name.str + tag->name.uriLen;
+	    const XML_Char *from = tag->name.localPart;
+	    while ((*to++ = *from++) != 0)
+	      ;
+	  }
+	  endElementHandler(handlerArg, tag->name.str);
+	}
+	else if (defaultHandler)
+	  reportDefault(parser, enc, s, next);
+	while (tag->bindings) {
+	  BINDING *b = tag->bindings;
+	  if (endNamespaceDeclHandler)
+	    endNamespaceDeclHandler(handlerArg, b->prefix->name);
+	  tag->bindings = tag->bindings->nextTagBinding;
+	  b->nextTagBinding = freeBindingList;
+	  freeBindingList = b;
+	  b->prefix->binding = b->prevPrefixBinding;
+	}
+	if (tagLevel == 0)
+	  return epilogProcessor(parser, next, end, nextPtr);
+      }
+      break;
+    case XML_TOK_CHAR_REF:
+      {
+	int n = XmlCharRefNumber(enc, s);
+	if (n < 0)
+	  return XML_ERROR_BAD_CHAR_REF;
+	if (characterDataHandler) {
+	  XML_Char buf[XML_ENCODE_MAX];
+	  characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
+	}
+	else if (defaultHandler)
+	  reportDefault(parser, enc, s, next);
+      }
+      break;
+    case XML_TOK_XML_DECL:
+      return XML_ERROR_MISPLACED_XML_PI;
+    case XML_TOK_DATA_NEWLINE:
+      if (characterDataHandler) {
+	XML_Char c = 0xA;
+	characterDataHandler(handlerArg, &c, 1);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_CDATA_SECT_OPEN:
+      {
+	enum XML_Error result;
+	if (startCdataSectionHandler)
+  	  startCdataSectionHandler(handlerArg);
+#if 0
+	/* Suppose you doing a transformation on a document that involves
+	   changing only the character data.  You set up a defaultHandler
+	   and a characterDataHandler.  The defaultHandler simply copies
+	   characters through.  The characterDataHandler does the transformation
+	   and writes the characters out escaping them as necessary.  This case
+	   will fail to work if we leave out the following two lines (because &
+	   and < inside CDATA sections will be incorrectly escaped).
+
+	   However, now we have a start/endCdataSectionHandler, so it seems
+	   easier to let the user deal with this. */
+
+	else if (characterDataHandler)
+  	  characterDataHandler(handlerArg, dataBuf, 0);
+#endif
+	else if (defaultHandler)
+	  reportDefault(parser, enc, s, next);
+	result = doCdataSection(parser, enc, &next, end, nextPtr);
+	if (!next) {
+	  processor = cdataSectionProcessor;
+	  return result;
+	}
+      }
+      break;
+    case XML_TOK_TRAILING_RSQB:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      if (characterDataHandler) {
+	if (MUST_CONVERT(enc, s)) {
+	  ICHAR *dataPtr = (ICHAR *)dataBuf;
+	  XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
+	  characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
+	}
+	else
+	  characterDataHandler(handlerArg,
+		  	       (XML_Char *)s,
+			       (XML_Char *)end - (XML_Char *)s);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, end);
+      if (startTagLevel == 0) {
+        *eventPP = end;
+	return XML_ERROR_NO_ELEMENTS;
+      }
+      if (tagLevel != startTagLevel) {
+	*eventPP = end;
+	return XML_ERROR_ASYNC_ENTITY;
+      }
+      return XML_ERROR_NONE;
+    case XML_TOK_DATA_CHARS:
+      if (characterDataHandler) {
+	if (MUST_CONVERT(enc, s)) {
+	  for (;;) {
+	    ICHAR *dataPtr = (ICHAR *)dataBuf;
+	    XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
+	    *eventEndPP = s;
+	    characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
+	    if (s == next)
+	      break;
+	    *eventPP = s;
+	  }
+	}
+	else
+	  characterDataHandler(handlerArg,
+			       (XML_Char *)s,
+			       (XML_Char *)next - (XML_Char *)s);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_PI:
+      if (!reportProcessingInstruction(parser, enc, s, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_COMMENT:
+      if (!reportComment(parser, enc, s, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
+    default:
+      if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
+    }
+    *eventPP = s = next;
+  }
+  /* not reached */
+}
+
+/* If tagNamePtr is non-null, build a real list of attributes,
+otherwise just check the attributes for well-formedness. */
+
+static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
+				const char *attStr, TAG_NAME *tagNamePtr,
+				BINDING **bindingsPtr)
+{
+  ELEMENT_TYPE *elementType = 0;
+  int nDefaultAtts = 0;
+  const XML_Char **appAtts;   /* the attribute list to pass to the application */
+  int attIndex = 0;
+  int i;
+  int n;
+  int nPrefixes = 0;
+  BINDING *binding;
+  const XML_Char *localPart;
+
+  /* lookup the element type name */
+  if (tagNamePtr) {
+    elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str,0);
+    if (!elementType) {
+      tagNamePtr->str = poolCopyString(&dtd.pool, tagNamePtr->str);
+      if (!tagNamePtr->str)
+	return XML_ERROR_NO_MEMORY;
+      elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, sizeof(ELEMENT_TYPE));
+      if (!elementType)
+        return XML_ERROR_NO_MEMORY;
+      if (ns && !setElementTypePrefix(parser, elementType))
+        return XML_ERROR_NO_MEMORY;
+    }
+    nDefaultAtts = elementType->nDefaultAtts;
+  }
+  /* get the attributes from the tokenizer */
+  n = XmlGetAttributes(enc, attStr, attsSize, atts);
+  if (n + nDefaultAtts > attsSize) {
+    int oldAttsSize = attsSize;
+    attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
+    atts = REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
+    if (!atts)
+      return XML_ERROR_NO_MEMORY;
+    if (n > oldAttsSize)
+      XmlGetAttributes(enc, attStr, n, atts);
+  }
+  appAtts = (const XML_Char **)atts;
+  for (i = 0; i < n; i++) {
+    /* add the name and value to the attribute list */
+    ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
+					 atts[i].name
+					 + XmlNameLength(enc, atts[i].name));
+    if (!attId)
+      return XML_ERROR_NO_MEMORY;
+    /* detect duplicate attributes */
+    if ((attId->name)[-1]) {
+      if (enc == encoding)
+	eventPtr = atts[i].name;
+      return XML_ERROR_DUPLICATE_ATTRIBUTE;
+    }
+    (attId->name)[-1] = 1;
+    appAtts[attIndex++] = attId->name;
+    if (!atts[i].normalized) {
+      enum XML_Error result;
+      int isCdata = 1;
+
+      /* figure out whether declared as other than CDATA */
+      if (attId->maybeTokenized) {
+	int j;
+	for (j = 0; j < nDefaultAtts; j++) {
+	  if (attId == elementType->defaultAtts[j].id) {
+	    isCdata = elementType->defaultAtts[j].isCdata;
+	    break;
+	  }
+	}
+      }
+
+      /* normalize the attribute value */
+      result = storeAttributeValue(parser, enc, isCdata,
+				   atts[i].valuePtr, atts[i].valueEnd,
+			           &tempPool);
+      if (result)
+	return result;
+      if (tagNamePtr) {
+	appAtts[attIndex] = poolStart(&tempPool);
+	poolFinish(&tempPool);
+      }
+      else
+	poolDiscard(&tempPool);
+    }
+    else if (tagNamePtr) {
+      /* the value did not need normalizing */
+      appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd);
+      if (appAtts[attIndex] == 0)
+	return XML_ERROR_NO_MEMORY;
+      poolFinish(&tempPool);
+    }
+    /* handle prefixed attribute names */
+    if (attId->prefix && tagNamePtr) {
+      if (attId->xmlns) {
+	/* deal with namespace declarations here */
+        if (!addBinding(parser, attId->prefix, attId, appAtts[attIndex], bindingsPtr))
+          return XML_ERROR_NO_MEMORY;
+        --attIndex;
+      }
+      else {
+	/* deal with other prefixed names later */
+        attIndex++;
+        nPrefixes++;
+        (attId->name)[-1] = 2;
+      }
+    }
+    else
+      attIndex++;
+  }
+  if (tagNamePtr) {
+    int j;
+    nSpecifiedAtts = attIndex;
+    if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
+      for (i = 0; i < attIndex; i += 2)
+	if (appAtts[i] == elementType->idAtt->name) {
+	  idAttIndex = i;
+	  break;
+	}
+    }
+    else
+      idAttIndex = -1;
+    /* do attribute defaulting */
+    for (j = 0; j < nDefaultAtts; j++) {
+      const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + j;
+      if (!(da->id->name)[-1] && da->value) {
+        if (da->id->prefix) {
+          if (da->id->xmlns) {
+	    if (!addBinding(parser, da->id->prefix, da->id, da->value, bindingsPtr))
+	      return XML_ERROR_NO_MEMORY;
+	  }
+          else {
+	    (da->id->name)[-1] = 2;
+	    nPrefixes++;
+  	    appAtts[attIndex++] = da->id->name;
+	    appAtts[attIndex++] = da->value;
+	  }
+	}
+	else {
+	  (da->id->name)[-1] = 1;
+	  appAtts[attIndex++] = da->id->name;
+	  appAtts[attIndex++] = da->value;
+	}
+      }
+    }
+    appAtts[attIndex] = 0;
+  }
+  i = 0;
+  if (nPrefixes) {
+    /* expand prefixed attribute names */
+    for (; i < attIndex; i += 2) {
+      if (appAtts[i][-1] == 2) {
+        ATTRIBUTE_ID *id;
+        ((XML_Char *)(appAtts[i]))[-1] = 0;
+	id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, appAtts[i], 0);
+	if (id->prefix->binding) {
+	  int j;
+	  const BINDING *b = id->prefix->binding;
+	  const XML_Char *s = appAtts[i];
+	  for (j = 0; j < b->uriLen; j++) {
+	    if (!poolAppendChar(&tempPool, b->uri[j]))
+	      return XML_ERROR_NO_MEMORY;
+	  }
+	  while (*s++ != ':')
+	    ;
+	  do {
+	    if (!poolAppendChar(&tempPool, *s))
+	      return XML_ERROR_NO_MEMORY;
+	  } while (*s++);
+	  if (ns_triplets) {
+	    tempPool.ptr[-1] = namespaceSeparator;
+	    s = b->prefix->name;
+	    do {
+	      if (!poolAppendChar(&tempPool, *s))
+		return XML_ERROR_NO_MEMORY;
+	    } while (*s++);
+	  }
+
+	  appAtts[i] = poolStart(&tempPool);
+	  poolFinish(&tempPool);
+	}
+	if (!--nPrefixes)
+	  break;
+      }
+      else
+	((XML_Char *)(appAtts[i]))[-1] = 0;
+    }
+  }
+  /* clear the flags that say whether attributes were specified */
+  for (; i < attIndex; i += 2)
+    ((XML_Char *)(appAtts[i]))[-1] = 0;
+  if (!tagNamePtr)
+    return XML_ERROR_NONE;
+  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
+    binding->attId->name[-1] = 0;
+  /* expand the element type name */
+  if (elementType->prefix) {
+    binding = elementType->prefix->binding;
+    if (!binding)
+      return XML_ERROR_NONE;
+    localPart = tagNamePtr->str;
+    while (*localPart++ != XML_T(':'))
+      ;
+  }
+  else if (dtd.defaultPrefix.binding) {
+    binding = dtd.defaultPrefix.binding;
+    localPart = tagNamePtr->str;
+  }
+  else
+    return XML_ERROR_NONE;
+  tagNamePtr->localPart = localPart;
+  tagNamePtr->uriLen = binding->uriLen;
+  for (i = 0; localPart[i++];)
+    ;
+  n = i + binding->uriLen;
+  if (n > binding->uriAlloc) {
+    TAG *p;
+    XML_Char *uri = MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
+    if (!uri)
+      return XML_ERROR_NO_MEMORY;
+    binding->uriAlloc = n + EXPAND_SPARE;
+    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
+    for (p = tagStack; p; p = p->parent)
+      if (p->name.str == binding->uri)
+	p->name.str = uri;
+    FREE(binding->uri);
+    binding->uri = uri;
+  }
+  memcpy(binding->uri + binding->uriLen, localPart, i * sizeof(XML_Char));
+  tagNamePtr->str = binding->uri;
+  return XML_ERROR_NONE;
+}
+
+static
+int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr)
+{
+  BINDING *b;
+  int len;
+  for (len = 0; uri[len]; len++)
+    ;
+  if (namespaceSeparator)
+    len++;
+  if (freeBindingList) {
+    b = freeBindingList;
+    if (len > b->uriAlloc) {
+      b->uri = REALLOC(b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
+      if (!b->uri)
+	return 0;
+      b->uriAlloc = len + EXPAND_SPARE;
+    }
+    freeBindingList = b->nextTagBinding;
+  }
+  else {
+    b = MALLOC(sizeof(BINDING));
+    if (!b)
+      return 0;
+    b->uri = MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
+    if (!b->uri) {
+      FREE(b);
+      return 0;
+    }
+    b->uriAlloc = len + EXPAND_SPARE;
+  }
+  b->uriLen = len;
+  memcpy(b->uri, uri, len * sizeof(XML_Char));
+  if (namespaceSeparator)
+    b->uri[len - 1] = namespaceSeparator;
+  b->prefix = prefix;
+  b->attId = attId;
+  b->prevPrefixBinding = prefix->binding;
+  if (*uri == XML_T('\0') && prefix == &dtd.defaultPrefix)
+    prefix->binding = 0;
+  else
+    prefix->binding = b;
+  b->nextTagBinding = *bindingsPtr;
+  *bindingsPtr = b;
+  if (startNamespaceDeclHandler)
+    startNamespaceDeclHandler(handlerArg, prefix->name,
+			      prefix->binding ? uri : 0);
+  return 1;
+}
+
+/* The idea here is to avoid using stack for each CDATA section when
+the whole file is parsed with one call. */
+
+static
+enum XML_Error cdataSectionProcessor(XML_Parser parser,
+				     const char *start,
+			    	     const char *end,
+				     const char **endPtr)
+{
+  enum XML_Error result = doCdataSection(parser, encoding, &start, end, endPtr);
+  if (start) {
+    processor = contentProcessor;
+    return contentProcessor(parser, start, end, endPtr);
+  }
+  return result;
+}
+
+/* startPtr gets set to non-null is the section is closed, and to null if
+the section is not yet closed. */
+
+static
+enum XML_Error doCdataSection(XML_Parser parser,
+			      const ENCODING *enc,
+			      const char **startPtr,
+			      const char *end,
+			      const char **nextPtr)
+{
+  const char *s = *startPtr;
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == encoding) {
+    eventPP = &eventPtr;
+    *eventPP = s;
+    eventEndPP = &eventEndPtr;
+  }
+  else {
+    eventPP = &(openInternalEntities->internalEventPtr);
+    eventEndPP = &(openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+  *startPtr = 0;
+  for (;;) {
+    const char *next;
+    int tok = XmlCdataSectionTok(enc, s, end, &next);
+    *eventEndPP = next;
+    switch (tok) {
+    case XML_TOK_CDATA_SECT_CLOSE:
+      if (endCdataSectionHandler)
+	endCdataSectionHandler(handlerArg);
+#if 0
+      /* see comment under XML_TOK_CDATA_SECT_OPEN */
+      else if (characterDataHandler)
+	characterDataHandler(handlerArg, dataBuf, 0);
+#endif
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      *startPtr = next;
+      return XML_ERROR_NONE;
+    case XML_TOK_DATA_NEWLINE:
+      if (characterDataHandler) {
+	XML_Char c = 0xA;
+	characterDataHandler(handlerArg, &c, 1);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_DATA_CHARS:
+      if (characterDataHandler) {
+	if (MUST_CONVERT(enc, s)) {
+	  for (;;) {
+  	    ICHAR *dataPtr = (ICHAR *)dataBuf;
+	    XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
+	    *eventEndPP = next;
+	    characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
+	    if (s == next)
+	      break;
+	    *eventPP = s;
+	  }
+	}
+	else
+	  characterDataHandler(handlerArg,
+		  	       (XML_Char *)s,
+			       (XML_Char *)next - (XML_Char *)s);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_INVALID:
+      *eventPP = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_PARTIAL:
+    case XML_TOK_NONE:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_CDATA_SECTION;
+    default:
+      *eventPP = next;
+      return XML_ERROR_UNEXPECTED_STATE;
+    }
+    *eventPP = s = next;
+  }
+  /* not reached */
+}
+
+#ifdef XML_DTD
+
+/* The idea here is to avoid using stack for each IGNORE section when
+the whole file is parsed with one call. */
+
+static
+enum XML_Error ignoreSectionProcessor(XML_Parser parser,
+				      const char *start,
+				      const char *end,
+				      const char **endPtr)
+{
+  enum XML_Error result = doIgnoreSection(parser, encoding, &start, end, endPtr);
+  if (start) {
+    processor = prologProcessor;
+    return prologProcessor(parser, start, end, endPtr);
+  }
+  return result;
+}
+
+/* startPtr gets set to non-null is the section is closed, and to null if
+the section is not yet closed. */
+
+static
+enum XML_Error doIgnoreSection(XML_Parser parser,
+			       const ENCODING *enc,
+			       const char **startPtr,
+			       const char *end,
+			       const char **nextPtr)
+{
+  const char *next;
+  int tok;
+  const char *s = *startPtr;
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == encoding) {
+    eventPP = &eventPtr;
+    *eventPP = s;
+    eventEndPP = &eventEndPtr;
+  }
+  else {
+    eventPP = &(openInternalEntities->internalEventPtr);
+    eventEndPP = &(openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+  *startPtr = 0;
+  tok = XmlIgnoreSectionTok(enc, s, end, &next);
+  *eventEndPP = next;
+  switch (tok) {
+  case XML_TOK_IGNORE_SECT:
+    if (defaultHandler)
+      reportDefault(parser, enc, s, next);
+    *startPtr = next;
+    return XML_ERROR_NONE;
+  case XML_TOK_INVALID:
+    *eventPP = next;
+    return XML_ERROR_INVALID_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (nextPtr) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_PARTIAL_CHAR;
+  case XML_TOK_PARTIAL:
+  case XML_TOK_NONE:
+    if (nextPtr) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
+  default:
+    *eventPP = next;
+    return XML_ERROR_UNEXPECTED_STATE;
+  }
+  /* not reached */
+}
+
+#endif /* XML_DTD */
+
+static enum XML_Error
+initializeEncoding(XML_Parser parser)
+{
+  const char *s;
+#ifdef XML_UNICODE
+  char encodingBuf[128];
+  if (!protocolEncodingName)
+    s = 0;
+  else {
+    int i;
+    for (i = 0; protocolEncodingName[i]; i++) {
+      if (i == sizeof(encodingBuf) - 1
+	  || (protocolEncodingName[i] & ~0x7f) != 0) {
+	encodingBuf[0] = '\0';
+	break;
+      }
+      encodingBuf[i] = (char)protocolEncodingName[i];
+    }
+    encodingBuf[i] = '\0';
+    s = encodingBuf;
+  }
+#else
+  s = protocolEncodingName;
+#endif
+  if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))
+    return XML_ERROR_NONE;
+  return handleUnknownEncoding(parser, protocolEncodingName);
+}
+
+static enum XML_Error
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
+	       const char *s, const char *next)
+{
+  const char *encodingName = 0;
+  const char *storedEncName = 0;
+  const ENCODING *newEncoding = 0;
+  const char *version = 0;
+  const char *versionend;
+  const char *storedversion = 0;
+  int standalone = -1;
+  if (!(ns
+        ? XmlParseXmlDeclNS
+	: XmlParseXmlDecl)(isGeneralTextEntity,
+		           encoding,
+		           s,
+		           next,
+		           &eventPtr,
+		           &version,
+			   &versionend,
+		           &encodingName,
+		           &newEncoding,
+		           &standalone))
+    return XML_ERROR_SYNTAX;
+  if (!isGeneralTextEntity && standalone == 1) {
+    dtd.standalone = 1;
+#ifdef XML_DTD
+    if (paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
+      paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
+#endif /* XML_DTD */
+  }
+  if (xmlDeclHandler) {
+    if (encodingName) {
+      storedEncName = poolStoreString(&temp2Pool,
+				      encoding,
+				      encodingName,
+				      encodingName
+				      + XmlNameLength(encoding, encodingName));
+      if (! storedEncName)
+	return XML_ERROR_NO_MEMORY;
+      poolFinish(&temp2Pool);
+    }
+    if (version) {
+      storedversion = poolStoreString(&temp2Pool,
+				      encoding,
+				      version,
+				      versionend - encoding->minBytesPerChar);
+      if (! storedversion)
+	return XML_ERROR_NO_MEMORY;
+    }
+    xmlDeclHandler(handlerArg, storedversion, storedEncName, standalone);
+  }
+  else if (defaultHandler)
+    reportDefault(parser, encoding, s, next);
+  if (!protocolEncodingName) {
+    if (newEncoding) {
+      if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
+	eventPtr = encodingName;
+	return XML_ERROR_INCORRECT_ENCODING;
+      }
+      encoding = newEncoding;
+    }
+    else if (encodingName) {
+      enum XML_Error result;
+      if (! storedEncName) {
+	storedEncName = poolStoreString(&temp2Pool,
+					encoding,
+					encodingName,
+					encodingName
+					+ XmlNameLength(encoding, encodingName));
+	if (! storedEncName)
+	  return XML_ERROR_NO_MEMORY;
+      }
+      result = handleUnknownEncoding(parser, storedEncName);
+      poolClear(&tempPool);
+      if (result == XML_ERROR_UNKNOWN_ENCODING)
+	eventPtr = encodingName;
+      return result;
+    }
+  }
+
+  if (storedEncName || storedversion)
+    poolClear(&temp2Pool);
+
+  return XML_ERROR_NONE;
+}
+
+static enum XML_Error
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
+{
+  if (unknownEncodingHandler) {
+    XML_Encoding info;
+    int i;
+    for (i = 0; i < 256; i++)
+      info.map[i] = -1;
+    info.convert = 0;
+    info.data = 0;
+    info.release = 0;
+    if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName, &info)) {
+      ENCODING *enc;
+      unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());
+      if (!unknownEncodingMem) {
+	if (info.release)
+	  info.release(info.data);
+	return XML_ERROR_NO_MEMORY;
+      }
+      enc = (ns
+	     ? XmlInitUnknownEncodingNS
+	     : XmlInitUnknownEncoding)(unknownEncodingMem,
+				       info.map,
+				       info.convert,
+				       info.data);
+      if (enc) {
+	unknownEncodingData = info.data;
+	unknownEncodingRelease = info.release;
+	encoding = enc;
+	return XML_ERROR_NONE;
+      }
+    }
+    if (info.release)
+      info.release(info.data);
+  }
+  return XML_ERROR_UNKNOWN_ENCODING;
+}
+
+static enum XML_Error
+prologInitProcessor(XML_Parser parser,
+		    const char *s,
+		    const char *end,
+		    const char **nextPtr)
+{
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  processor = prologProcessor;
+  return prologProcessor(parser, s, end, nextPtr);
+}
+
+static enum XML_Error
+prologProcessor(XML_Parser parser,
+		const char *s,
+		const char *end,
+		const char **nextPtr)
+{
+  const char *next;
+  int tok = XmlPrologTok(encoding, s, end, &next);
+  return doProlog(parser, encoding, s, end, tok, next, nextPtr);
+}
+
+static enum XML_Error
+doProlog(XML_Parser parser,
+	 const ENCODING *enc,
+	 const char *s,
+	 const char *end,
+	 int tok,
+	 const char *next,
+	 const char **nextPtr)
+{
+#ifdef XML_DTD
+  static const XML_Char externalSubsetName[] = { '#' , '\0' };
+#endif /* XML_DTD */
+
+  const char **eventPP;
+  const char **eventEndPP;
+  enum XML_Content_Quant quant;
+
+  if (enc == encoding) {
+    eventPP = &eventPtr;
+    eventEndPP = &eventEndPtr;
+  }
+  else {
+    eventPP = &(openInternalEntities->internalEventPtr);
+    eventEndPP = &(openInternalEntities->internalEventEndPtr);
+  }
+  for (;;) {
+    int role;
+    *eventPP = s;
+    *eventEndPP = next;
+    if (tok <= 0) {
+      if (nextPtr != 0 && tok != XML_TOK_INVALID) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      switch (tok) {
+      case XML_TOK_INVALID:
+	*eventPP = next;
+	return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_PARTIAL:
+	return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+	return XML_ERROR_PARTIAL_CHAR;
+      case XML_TOK_NONE:
+#ifdef XML_DTD
+	if (enc != encoding)
+	  return XML_ERROR_NONE;
+	if (parentParser) {
+	  if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)
+	      == XML_ROLE_ERROR)
+	    return XML_ERROR_SYNTAX;
+	  hadExternalDoctype = 0;
+	  return XML_ERROR_NONE;
+	}
+#endif /* XML_DTD */
+	return XML_ERROR_NO_ELEMENTS;
+      default:
+	tok = -tok;
+	next = end;
+	break;
+      }
+    }
+    role = XmlTokenRole(&prologState, tok, s, next, enc);
+    switch (role) {
+    case XML_ROLE_XML_DECL:
+      {
+	enum XML_Error result = processXmlDecl(parser, 0, s, next);
+	if (result != XML_ERROR_NONE)
+	  return result;
+	enc = encoding;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_NAME:
+      if (startDoctypeDeclHandler) {
+	doctypeName = poolStoreString(&tempPool, enc, s, next);
+	if (! doctypeName)
+	  return XML_ERROR_NO_MEMORY;
+	poolFinish(&tempPool);
+	doctypeSysid = 0;
+	doctypePubid = 0;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
+      if (startDoctypeDeclHandler) {
+	startDoctypeDeclHandler(handlerArg, doctypeName, doctypeSysid,
+				doctypePubid, 1);
+	doctypeName = 0;
+	poolClear(&tempPool);
+      }
+      break;
+#ifdef XML_DTD
+    case XML_ROLE_TEXT_DECL:
+      {
+	enum XML_Error result = processXmlDecl(parser, 1, s, next);
+	if (result != XML_ERROR_NONE)
+	  return result;
+	enc = encoding;
+      }
+      break;
+#endif /* XML_DTD */
+    case XML_ROLE_DOCTYPE_PUBLIC_ID:
+      if (startDoctypeDeclHandler) {
+	doctypePubid = poolStoreString(&tempPool, enc, s + 1, next - 1);
+	if (! doctypePubid)
+	  return XML_ERROR_NO_MEMORY;
+	poolFinish(&tempPool);
+      }
+#ifdef XML_DTD
+      declEntity = (ENTITY *)lookup(&dtd.paramEntities,
+				    externalSubsetName,
+				    sizeof(ENTITY));
+      if (!declEntity)
+	return XML_ERROR_NO_MEMORY;
+#endif /* XML_DTD */
+      /* fall through */
+    case XML_ROLE_ENTITY_PUBLIC_ID:
+      if (!XmlIsPublicId(enc, s, next, eventPP))
+	return XML_ERROR_SYNTAX;
+      if (declEntity) {
+	XML_Char *tem = poolStoreString(&dtd.pool,
+	                                enc,
+					s + enc->minBytesPerChar,
+	  				next - enc->minBytesPerChar);
+	if (!tem)
+	  return XML_ERROR_NO_MEMORY;
+	normalizePublicId(tem);
+	declEntity->publicId = tem;
+	poolFinish(&dtd.pool);
+      }
+      break;
+    case XML_ROLE_DOCTYPE_CLOSE:
+      if (doctypeName) {
+	startDoctypeDeclHandler(handlerArg, doctypeName,
+				doctypeSysid, doctypePubid, 0);
+	poolClear(&tempPool);
+      }
+      if (dtd.complete && hadExternalDoctype) {
+	dtd.complete = 0;
+#ifdef XML_DTD
+	if (paramEntityParsing && externalEntityRefHandler) {
+	  ENTITY *entity = (ENTITY *)lookup(&dtd.paramEntities,
+					    externalSubsetName,
+					    0);
+	  if (!externalEntityRefHandler(externalEntityRefHandlerArg,
+					0,
+					entity->base,
+					entity->systemId,
+					entity->publicId))
+	   return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+	}
+#endif /* XML_DTD */
+	if (!dtd.complete
+	    && !dtd.standalone
+	    && notStandaloneHandler
+	    && !notStandaloneHandler(handlerArg))
+	  return XML_ERROR_NOT_STANDALONE;
+      }
+      if (endDoctypeDeclHandler)
+	endDoctypeDeclHandler(handlerArg);
+      break;
+    case XML_ROLE_INSTANCE_START:
+      processor = contentProcessor;
+      return contentProcessor(parser, s, end, nextPtr);
+    case XML_ROLE_ATTLIST_ELEMENT_NAME:
+      declElementType = getElementType(parser, enc, s, next);
+      if (!declElementType)
+	return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_ROLE_ATTRIBUTE_NAME:
+      declAttributeId = getAttributeId(parser, enc, s, next);
+      if (!declAttributeId)
+	return XML_ERROR_NO_MEMORY;
+      declAttributeIsCdata = 0;
+      declAttributeType = 0;
+      declAttributeIsId = 0;
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
+      declAttributeIsCdata = 1;
+      declAttributeType = "CDATA";
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_ID:
+      declAttributeIsId = 1;
+      declAttributeType = "ID";
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
+      declAttributeType = "IDREF";
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
+      declAttributeType = "IDREFS";
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
+      declAttributeType = "ENTITY";
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
+      declAttributeType = "ENTITIES";
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
+      declAttributeType = "NMTOKEN";
+      break;
+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
+      declAttributeType = "NMTOKENS";
+      break;
+
+    case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
+    case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
+      if (attlistDeclHandler)
+      {
+	char *prefix;
+	if (declAttributeType) {
+	  prefix = "|";
+	}
+	else {
+	  prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE
+		    ? "NOTATION("
+		    : "(");
+	}
+	if (! poolAppendString(&tempPool, prefix))
+	  return XML_ERROR_NO_MEMORY;
+	if (! poolAppend(&tempPool, enc, s, next))
+	  return XML_ERROR_NO_MEMORY;
+	declAttributeType = tempPool.start;
+      }
+      break;
+    case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
+    case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
+      if (dtd.complete
+	  && !defineAttribute(declElementType, declAttributeId,
+			      declAttributeIsCdata, declAttributeIsId, 0,
+			      parser))
+	return XML_ERROR_NO_MEMORY;
+      if (attlistDeclHandler && declAttributeType) {
+	if (*declAttributeType == '('
+	    || (*declAttributeType == 'N' && declAttributeType[1] == 'O')) {
+	  /* Enumerated or Notation type */
+	  if (! poolAppendChar(&tempPool, ')')
+	      || ! poolAppendChar(&tempPool, '\0'))
+	    return XML_ERROR_NO_MEMORY;
+	  declAttributeType = tempPool.start;
+	  poolFinish(&tempPool);
+	}
+	*eventEndPP = s;
+	attlistDeclHandler(handlerArg, declElementType->name,
+			   declAttributeId->name, declAttributeType,
+			   0, role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
+	poolClear(&tempPool);
+      }
+      break;
+    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
+    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
+      {
+	const XML_Char *attVal;
+	enum XML_Error result
+	  = storeAttributeValue(parser, enc, declAttributeIsCdata,
+				s + enc->minBytesPerChar,
+			        next - enc->minBytesPerChar,
+			        &dtd.pool);
+	if (result)
+	  return result;
+	attVal = poolStart(&dtd.pool);
+	poolFinish(&dtd.pool);
+	if (dtd.complete
+	    /* ID attributes aren't allowed to have a default */
+	    && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, 0, attVal, parser))
+	  return XML_ERROR_NO_MEMORY;
+	if (attlistDeclHandler && declAttributeType) {
+	  if (*declAttributeType == '('
+	      || (*declAttributeType == 'N' && declAttributeType[1] == 'O')) {
+	    /* Enumerated or Notation type */
+	    if (! poolAppendChar(&tempPool, ')')
+		|| ! poolAppendChar(&tempPool, '\0'))
+	      return XML_ERROR_NO_MEMORY;
+	    declAttributeType = tempPool.start;
+	    poolFinish(&tempPool);
+	  }
+	  *eventEndPP = s;
+	  attlistDeclHandler(handlerArg, declElementType->name,
+			     declAttributeId->name, declAttributeType,
+			     attVal,
+			     role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
+	  poolClear(&tempPool);
+	}
+	break;
+      }
+    case XML_ROLE_ENTITY_VALUE:
+      {
+	enum XML_Error result = storeEntityValue(parser, enc,
+						 s + enc->minBytesPerChar,
+						 next - enc->minBytesPerChar);
+	if (declEntity) {
+	  declEntity->textPtr = poolStart(&dtd.pool);
+	  declEntity->textLen = poolLength(&dtd.pool);
+	  poolFinish(&dtd.pool);
+	  if (entityDeclHandler) {
+	    *eventEndPP = s;
+	    entityDeclHandler(handlerArg,
+			      declEntity->name,
+			      declEntity->is_param,
+			      declEntity->textPtr,
+			      declEntity->textLen,
+			      curBase, 0, 0, 0);
+	  }
+	}
+	else
+	  poolDiscard(&dtd.pool);
+	if (result != XML_ERROR_NONE)
+	  return result;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_SYSTEM_ID:
+      if (startDoctypeDeclHandler) {
+	doctypeSysid = poolStoreString(&tempPool, enc, s + 1, next - 1);
+	if (! doctypeSysid)
+	  return XML_ERROR_NO_MEMORY;
+	poolFinish(&tempPool);
+      }
+      if (!dtd.standalone
+#ifdef XML_DTD
+	  && !paramEntityParsing
+#endif /* XML_DTD */
+	  && notStandaloneHandler
+	  && !notStandaloneHandler(handlerArg))
+	return XML_ERROR_NOT_STANDALONE;
+      hadExternalDoctype = 1;
+#ifndef XML_DTD
+      break;
+#else /* XML_DTD */
+      if (!declEntity) {
+	declEntity = (ENTITY *)lookup(&dtd.paramEntities,
+				      externalSubsetName,
+				      sizeof(ENTITY));
+	declEntity->publicId = 0;
+	if (!declEntity)
+	  return XML_ERROR_NO_MEMORY;
+      }
+      /* fall through */
+#endif /* XML_DTD */
+    case XML_ROLE_ENTITY_SYSTEM_ID:
+      if (declEntity) {
+	declEntity->systemId = poolStoreString(&dtd.pool, enc,
+	                                       s + enc->minBytesPerChar,
+	  				       next - enc->minBytesPerChar);
+	if (!declEntity->systemId)
+	  return XML_ERROR_NO_MEMORY;
+	declEntity->base = curBase;
+	poolFinish(&dtd.pool);
+      }
+      break;
+    case XML_ROLE_ENTITY_COMPLETE:
+      if (declEntity && entityDeclHandler) {
+	*eventEndPP = s;
+	entityDeclHandler(handlerArg,
+			  declEntity->name,
+			  0,0,0,
+			  declEntity->base,
+			  declEntity->systemId,
+			  declEntity->publicId,
+			  0);
+      }
+      break;
+    case XML_ROLE_ENTITY_NOTATION_NAME:
+      if (declEntity) {
+	declEntity->notation = poolStoreString(&dtd.pool, enc, s, next);
+	if (!declEntity->notation)
+	  return XML_ERROR_NO_MEMORY;
+	poolFinish(&dtd.pool);
+	if (unparsedEntityDeclHandler) {
+	  *eventEndPP = s;
+	  unparsedEntityDeclHandler(handlerArg,
+				    declEntity->name,
+				    declEntity->base,
+				    declEntity->systemId,
+				    declEntity->publicId,
+				    declEntity->notation);
+	}
+	else if (entityDeclHandler) {
+	  *eventEndPP = s;
+	  entityDeclHandler(handlerArg,
+			    declEntity->name,
+			    0,0,0,
+			    declEntity->base,
+			    declEntity->systemId,
+			    declEntity->publicId,
+			    declEntity->notation);
+	}
+      }
+      break;
+    case XML_ROLE_GENERAL_ENTITY_NAME:
+      {
+	const XML_Char *name;
+	if (XmlPredefinedEntityName(enc, s, next)) {
+	  declEntity = 0;
+	  break;
+	}
+	name = poolStoreString(&dtd.pool, enc, s, next);
+	if (!name)
+	  return XML_ERROR_NO_MEMORY;
+	if (dtd.complete) {
+	  declEntity = (ENTITY *)lookup(&dtd.generalEntities, name, sizeof(ENTITY));
+	  if (!declEntity)
+	    return XML_ERROR_NO_MEMORY;
+	  if (declEntity->name != name) {
+	    poolDiscard(&dtd.pool);
+	    declEntity = 0;
+	  }
+	  else {
+	    poolFinish(&dtd.pool);
+	    declEntity->publicId = 0;
+	    declEntity->is_param = 0;
+	  }
+	}
+	else {
+	  poolDiscard(&dtd.pool);
+	  declEntity = 0;
+	}
+      }
+      break;
+    case XML_ROLE_PARAM_ENTITY_NAME:
+#ifdef XML_DTD
+      if (dtd.complete) {
+	const XML_Char *name = poolStoreString(&dtd.pool, enc, s, next);
+	if (!name)
+	  return XML_ERROR_NO_MEMORY;
+	declEntity = (ENTITY *)lookup(&dtd.paramEntities,
+				      name, sizeof(ENTITY));
+	if (!declEntity)
+	  return XML_ERROR_NO_MEMORY;
+	if (declEntity->name != name) {
+	  poolDiscard(&dtd.pool);
+	  declEntity = 0;
+	}
+	else {
+	  poolFinish(&dtd.pool);
+	  declEntity->publicId = 0;
+	  declEntity->is_param = 1;
+	}
+      }
+#else /* not XML_DTD */
+      declEntity = 0;
+#endif /* not XML_DTD */
+      break;
+    case XML_ROLE_NOTATION_NAME:
+      declNotationPublicId = 0;
+      declNotationName = 0;
+      if (notationDeclHandler) {
+	declNotationName = poolStoreString(&tempPool, enc, s, next);
+	if (!declNotationName)
+	  return XML_ERROR_NO_MEMORY;
+	poolFinish(&tempPool);
+      }
+      break;
+    case XML_ROLE_NOTATION_PUBLIC_ID:
+      if (!XmlIsPublicId(enc, s, next, eventPP))
+	return XML_ERROR_SYNTAX;
+      if (declNotationName) {
+	XML_Char *tem = poolStoreString(&tempPool,
+	                                enc,
+					s + enc->minBytesPerChar,
+	  				next - enc->minBytesPerChar);
+	if (!tem)
+	  return XML_ERROR_NO_MEMORY;
+	normalizePublicId(tem);
+	declNotationPublicId = tem;
+	poolFinish(&tempPool);
+      }
+      break;
+    case XML_ROLE_NOTATION_SYSTEM_ID:
+      if (declNotationName && notationDeclHandler) {
+	const XML_Char *systemId
+	  = poolStoreString(&tempPool, enc,
+			    s + enc->minBytesPerChar,
+	  		    next - enc->minBytesPerChar);
+	if (!systemId)
+	  return XML_ERROR_NO_MEMORY;
+	*eventEndPP = s;
+	notationDeclHandler(handlerArg,
+			    declNotationName,
+			    curBase,
+			    systemId,
+			    declNotationPublicId);
+      }
+      poolClear(&tempPool);
+      break;
+    case XML_ROLE_NOTATION_NO_SYSTEM_ID:
+      if (declNotationPublicId && notationDeclHandler) {
+	*eventEndPP = s;
+	notationDeclHandler(handlerArg,
+			    declNotationName,
+			    curBase,
+			    0,
+			    declNotationPublicId);
+      }
+      poolClear(&tempPool);
+      break;
+    case XML_ROLE_ERROR:
+      switch (tok) {
+      case XML_TOK_PARAM_ENTITY_REF:
+	return XML_ERROR_PARAM_ENTITY_REF;
+      case XML_TOK_XML_DECL:
+	return XML_ERROR_MISPLACED_XML_PI;
+      default:
+	return XML_ERROR_SYNTAX;
+      }
+#ifdef XML_DTD
+    case XML_ROLE_IGNORE_SECT:
+      {
+	enum XML_Error result;
+	if (defaultHandler)
+	  reportDefault(parser, enc, s, next);
+	result = doIgnoreSection(parser, enc, &next, end, nextPtr);
+	if (!next) {
+	  processor = ignoreSectionProcessor;
+	  return result;
+	}
+      }
+      break;
+#endif /* XML_DTD */
+    case XML_ROLE_GROUP_OPEN:
+      if (prologState.level >= groupSize) {
+	if (groupSize) {
+	  groupConnector = REALLOC(groupConnector, groupSize *= 2);
+	  if (dtd.scaffIndex)
+	    dtd.scaffIndex = REALLOC(dtd.scaffIndex, groupSize * sizeof(int));
+	}
+	else
+	  groupConnector = MALLOC(groupSize = 32);
+	if (!groupConnector)
+	  return XML_ERROR_NO_MEMORY;
+      }
+      groupConnector[prologState.level] = 0;
+      if (dtd.in_eldecl) {
+	int myindex = nextScaffoldPart(parser);
+	if (myindex < 0)
+	  return XML_ERROR_NO_MEMORY;
+	dtd.scaffIndex[dtd.scaffLevel] = myindex;
+	dtd.scaffLevel++;
+	dtd.scaffold[myindex].type = XML_CTYPE_SEQ;
+      }
+      break;
+    case XML_ROLE_GROUP_SEQUENCE:
+      if (groupConnector[prologState.level] == '|')
+	return XML_ERROR_SYNTAX;
+      groupConnector[prologState.level] = ',';
+      break;
+    case XML_ROLE_GROUP_CHOICE:
+      if (groupConnector[prologState.level] == ',')
+	return XML_ERROR_SYNTAX;
+      if (dtd.in_eldecl
+	  && ! groupConnector[prologState.level]
+	  && dtd.scaffold[dtd.scaffIndex[dtd.scaffLevel - 1]].type != XML_CTYPE_MIXED
+	  ) {
+	dtd.scaffold[dtd.scaffIndex[dtd.scaffLevel - 1]].type = XML_CTYPE_CHOICE;
+      }
+      groupConnector[prologState.level] = '|';
+      break;
+    case XML_ROLE_PARAM_ENTITY_REF:
+#ifdef XML_DTD
+    case XML_ROLE_INNER_PARAM_ENTITY_REF:
+      if (paramEntityParsing
+	  && (dtd.complete || role == XML_ROLE_INNER_PARAM_ENTITY_REF)) {
+	const XML_Char *name;
+	ENTITY *entity;
+	name = poolStoreString(&dtd.pool, enc,
+				s + enc->minBytesPerChar,
+				next - enc->minBytesPerChar);
+	if (!name)
+	  return XML_ERROR_NO_MEMORY;
+	entity = (ENTITY *)lookup(&dtd.paramEntities, name, 0);
+	poolDiscard(&dtd.pool);
+	if (!entity) {
+	  /* FIXME what to do if !dtd.complete? */
+	  return XML_ERROR_UNDEFINED_ENTITY;
+	}
+	if (entity->open)
+	  return XML_ERROR_RECURSIVE_ENTITY_REF;
+	if (entity->textPtr) {
+	  enum XML_Error result;
+	  result = processInternalParamEntity(parser, entity);
+	  if (result != XML_ERROR_NONE)
+	    return result;
+	  break;
+	}
+	if (role == XML_ROLE_INNER_PARAM_ENTITY_REF)
+	  return XML_ERROR_PARAM_ENTITY_REF;
+	if (externalEntityRefHandler) {
+	  dtd.complete = 0;
+	  entity->open = 1;
+	  if (!externalEntityRefHandler(externalEntityRefHandlerArg,
+					0,
+					entity->base,
+					entity->systemId,
+					entity->publicId)) {
+	    entity->open = 0;
+	    return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+	  }
+	  entity->open = 0;
+	  if (dtd.complete)
+	    break;
+	}
+      }
+#endif /* XML_DTD */
+      if (!dtd.standalone
+	  && notStandaloneHandler
+	  && !notStandaloneHandler(handlerArg))
+	return XML_ERROR_NOT_STANDALONE;
+      dtd.complete = 0;
+      if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
+
+      /* Element declaration stuff */
+
+    case XML_ROLE_ELEMENT_NAME:
+      if (elementDeclHandler) {
+	declElementType = getElementType(parser, enc, s, next);
+	if (! declElementType)
+	  return XML_ERROR_NO_MEMORY;
+	dtd.scaffLevel = 0;
+	dtd.scaffCount = 0;
+	dtd.in_eldecl = 1;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_ANY:
+    case XML_ROLE_CONTENT_EMPTY:
+      if (dtd.in_eldecl) {
+	if (elementDeclHandler) {
+	  XML_Content * content = (XML_Content *) MALLOC(sizeof(XML_Content));
+	  if (! content)
+	    return XML_ERROR_NO_MEMORY;
+	  content->quant = XML_CQUANT_NONE;
+	  content->name = 0;
+	  content->numchildren = 0;
+	  content->children = 0;
+	  content->type = ((role == XML_ROLE_CONTENT_ANY) ?
+			   XML_CTYPE_ANY :
+			   XML_CTYPE_EMPTY);
+	  *eventEndPP = s;
+	  elementDeclHandler(handlerArg, declElementType->name, content);
+	}
+	dtd.in_eldecl = 0;
+      }
+      break;
+      
+    case XML_ROLE_CONTENT_PCDATA:
+      if (dtd.in_eldecl) {
+	dtd.scaffold[dtd.scaffIndex[dtd.scaffLevel - 1]].type = XML_CTYPE_MIXED;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_ELEMENT:
+      quant = XML_CQUANT_NONE;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_OPT:
+      quant = XML_CQUANT_OPT;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_REP:
+      quant = XML_CQUANT_REP;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_PLUS:
+      quant = XML_CQUANT_PLUS;
+    elementContent:
+      if (dtd.in_eldecl)
+	{
+	  ELEMENT_TYPE *el;
+	  const char *nxt = quant == XML_CQUANT_NONE ? next : next - 1;
+	  int myindex = nextScaffoldPart(parser);
+	  if (myindex < 0)
+	    return XML_ERROR_NO_MEMORY;
+	  dtd.scaffold[myindex].type = XML_CTYPE_NAME;
+	  dtd.scaffold[myindex].quant = quant;
+	  el = getElementType(parser, enc, s, nxt);
+	  if (! el)
+	    return XML_ERROR_NO_MEMORY;
+	  dtd.scaffold[myindex].name = el->name;
+	  dtd.contentStringLen +=  nxt - s + 1;
+	}
+      break;
+
+    case XML_ROLE_GROUP_CLOSE:
+      quant = XML_CQUANT_NONE;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_OPT:
+      quant = XML_CQUANT_OPT;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_REP:
+      quant = XML_CQUANT_REP;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_PLUS:
+      quant = XML_CQUANT_PLUS;
+    closeGroup:
+      if (dtd.in_eldecl) {
+	dtd.scaffLevel--;
+	dtd.scaffold[dtd.scaffIndex[dtd.scaffLevel]].quant = quant;
+	if (dtd.scaffLevel == 0) {
+	  if (elementDeclHandler) {
+	    XML_Content *model = build_model(parser);
+	    if (! model)
+	      return XML_ERROR_NO_MEMORY;
+	    *eventEndPP = s;
+	    elementDeclHandler(handlerArg, declElementType->name, model);
+	  }
+	  dtd.in_eldecl = 0;
+	  dtd.contentStringLen = 0;
+	}
+      }
+      break;
+      /* End element declaration stuff */
+
+    case XML_ROLE_NONE:
+      switch (tok) {
+      case XML_TOK_PI:
+	if (!reportProcessingInstruction(parser, enc, s, next))
+	  return XML_ERROR_NO_MEMORY;
+	break;
+      case XML_TOK_COMMENT:
+	if (!reportComment(parser, enc, s, next))
+	  return XML_ERROR_NO_MEMORY;
+	break;
+      }
+      break;
+    }
+    if (defaultHandler) {
+      switch (tok) {
+      case XML_TOK_PI:
+      case XML_TOK_COMMENT:
+      case XML_TOK_BOM:
+      case XML_TOK_XML_DECL:
+#ifdef XML_DTD
+      case XML_TOK_IGNORE_SECT:
+#endif /* XML_DTD */
+      case XML_TOK_PARAM_ENTITY_REF:
+	break;
+      default:
+#ifdef XML_DTD
+	if (role != XML_ROLE_IGNORE_SECT)
+#endif /* XML_DTD */
+	  reportDefault(parser, enc, s, next);
+      }
+    }
+    s = next;
+    tok = XmlPrologTok(enc, s, end, &next);
+  }
+  /* not reached */
+}
+
+static
+enum XML_Error epilogProcessor(XML_Parser parser,
+			       const char *s,
+			       const char *end,
+			       const char **nextPtr)
+{
+  processor = epilogProcessor;
+  eventPtr = s;
+  for (;;) {
+    const char *next;
+    int tok = XmlPrologTok(encoding, s, end, &next);
+    eventEndPtr = next;
+    switch (tok) {
+    case -XML_TOK_PROLOG_S:
+      if (defaultHandler) {
+	eventEndPtr = end;
+	reportDefault(parser, encoding, s, end);
+      }
+      /* fall through */
+    case XML_TOK_NONE:
+      if (nextPtr)
+	*nextPtr = end;
+      return XML_ERROR_NONE;
+    case XML_TOK_PROLOG_S:
+      if (defaultHandler)
+	reportDefault(parser, encoding, s, next);
+      break;
+    case XML_TOK_PI:
+      if (!reportProcessingInstruction(parser, encoding, s, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_COMMENT:
+      if (!reportComment(parser, encoding, s, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_INVALID:
+      eventPtr = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    default:
+      return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
+    }
+    eventPtr = s = next;
+  }
+}
+
+#ifdef XML_DTD
+
+static enum XML_Error
+processInternalParamEntity(XML_Parser parser, ENTITY *entity)
+{
+  const char *s, *end, *next;
+  int tok;
+  enum XML_Error result;
+  OPEN_INTERNAL_ENTITY openEntity;
+  entity->open = 1;
+  openEntity.next = openInternalEntities;
+  openInternalEntities = &openEntity;
+  openEntity.entity = entity;
+  openEntity.internalEventPtr = 0;
+  openEntity.internalEventEndPtr = 0;
+  s = (char *)entity->textPtr;
+  end = (char *)(entity->textPtr + entity->textLen);
+  tok = XmlPrologTok(internalEncoding, s, end, &next);
+  result = doProlog(parser, internalEncoding, s, end, tok, next, 0);
+  entity->open = 0;
+  openInternalEntities = openEntity.next;
+  return result;
+}
+
+#endif /* XML_DTD */
+
+static
+enum XML_Error errorProcessor(XML_Parser parser,
+			      const char *s,
+			      const char *end,
+			      const char **nextPtr)
+{
+  return errorCode;
+}
+
+static enum XML_Error
+storeAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
+		    const char *ptr, const char *end,
+		    STRING_POOL *pool)
+{
+  enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
+  if (result)
+    return result;
+  if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
+    poolChop(pool);
+  if (!poolAppendChar(pool, XML_T('\0')))
+    return XML_ERROR_NO_MEMORY;
+  return XML_ERROR_NONE;
+}
+
+static enum XML_Error
+appendAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
+		     const char *ptr, const char *end,
+		     STRING_POOL *pool)
+{
+  for (;;) {
+    const char *next;
+    int tok = XmlAttributeValueTok(enc, ptr, end, &next);
+    switch (tok) {
+    case XML_TOK_NONE:
+      return XML_ERROR_NONE;
+    case XML_TOK_INVALID:
+      if (enc == encoding)
+	eventPtr = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (enc == encoding)
+	eventPtr = ptr;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_CHAR_REF:
+      {
+	XML_Char buf[XML_ENCODE_MAX];
+	int i;
+	int n = XmlCharRefNumber(enc, ptr);
+	if (n < 0) {
+	  if (enc == encoding)
+	    eventPtr = ptr;
+      	  return XML_ERROR_BAD_CHAR_REF;
+	}
+	if (!isCdata
+	    && n == 0x20 /* space */
+	    && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+	  break;
+	n = XmlEncode(n, (ICHAR *)buf);
+	if (!n) {
+	  if (enc == encoding)
+	    eventPtr = ptr;
+	  return XML_ERROR_BAD_CHAR_REF;
+	}
+	for (i = 0; i < n; i++) {
+	  if (!poolAppendChar(pool, buf[i]))
+	    return XML_ERROR_NO_MEMORY;
+	}
+      }
+      break;
+    case XML_TOK_DATA_CHARS:
+      if (!poolAppend(pool, enc, ptr, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
+      break;
+    case XML_TOK_TRAILING_CR:
+      next = ptr + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_ATTRIBUTE_VALUE_S:
+    case XML_TOK_DATA_NEWLINE:
+      if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+	break;
+      if (!poolAppendChar(pool, 0x20))
+	return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_ENTITY_REF:
+      {
+	const XML_Char *name;
+	ENTITY *entity;
+	XML_Char ch = XmlPredefinedEntityName(enc,
+					      ptr + enc->minBytesPerChar,
+					      next - enc->minBytesPerChar);
+	if (ch) {
+	  if (!poolAppendChar(pool, ch))
+  	    return XML_ERROR_NO_MEMORY;
+	  break;
+	}
+	name = poolStoreString(&temp2Pool, enc,
+			       ptr + enc->minBytesPerChar,
+			       next - enc->minBytesPerChar);
+	if (!name)
+	  return XML_ERROR_NO_MEMORY;
+	entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
+	poolDiscard(&temp2Pool);
+	if (!entity) {
+	  if (dtd.complete) {
+	    if (enc == encoding)
+	      eventPtr = ptr;
+	    return XML_ERROR_UNDEFINED_ENTITY;
+	  }
+	}
+	else if (entity->open) {
+	  if (enc == encoding)
+	    eventPtr = ptr;
+	  return XML_ERROR_RECURSIVE_ENTITY_REF;
+	}
+	else if (entity->notation) {
+	  if (enc == encoding)
+	    eventPtr = ptr;
+	  return XML_ERROR_BINARY_ENTITY_REF;
+	}
+	else if (!entity->textPtr) {
+	  if (enc == encoding)
+	    eventPtr = ptr;
+  	  return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
+	}
+	else {
+	  enum XML_Error result;
+	  const XML_Char *textEnd = entity->textPtr + entity->textLen;
+	  entity->open = 1;
+	  result = appendAttributeValue(parser, internalEncoding, isCdata, (char *)entity->textPtr, (char *)textEnd, pool);
+	  entity->open = 0;
+	  if (result)
+	    return result;
+	}
+      }
+      break;
+    default:
+      if (enc == encoding)
+	eventPtr = ptr;
+      return XML_ERROR_UNEXPECTED_STATE;
+    }
+    ptr = next;
+  }
+  /* not reached */
+}
+
+static
+enum XML_Error storeEntityValue(XML_Parser parser,
+				const ENCODING *enc,
+				const char *entityTextPtr,
+				const char *entityTextEnd)
+{
+  STRING_POOL *pool = &(dtd.pool);
+  for (;;) {
+    const char *next;
+    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
+    switch (tok) {
+    case XML_TOK_PARAM_ENTITY_REF:
+#ifdef XML_DTD
+      if (parentParser || enc != encoding) {
+	enum XML_Error result;
+	const XML_Char *name;
+	ENTITY *entity;
+	name = poolStoreString(&tempPool, enc,
+			       entityTextPtr + enc->minBytesPerChar,
+			       next - enc->minBytesPerChar);
+	if (!name)
+	  return XML_ERROR_NO_MEMORY;
+	entity = (ENTITY *)lookup(&dtd.paramEntities, name, 0);
+	poolDiscard(&tempPool);
+	if (!entity) {
+	  if (enc == encoding)
+	    eventPtr = entityTextPtr;
+	  return XML_ERROR_UNDEFINED_ENTITY;
+	}
+	if (entity->open) {
+	  if (enc == encoding)
+	    eventPtr = entityTextPtr;
+	  return XML_ERROR_RECURSIVE_ENTITY_REF;
+	}
+	if (entity->systemId) {
+	  if (enc == encoding)
+	    eventPtr = entityTextPtr;
+	  return XML_ERROR_PARAM_ENTITY_REF;
+	}
+	entity->open = 1;
+	result = storeEntityValue(parser,
+				  internalEncoding,
+				  (char *)entity->textPtr,
+				  (char *)(entity->textPtr + entity->textLen));
+	entity->open = 0;
+	if (result)
+	  return result;
+	break;
+      }
+#endif /* XML_DTD */
+      eventPtr = entityTextPtr;
+      return XML_ERROR_SYNTAX;
+    case XML_TOK_NONE:
+      return XML_ERROR_NONE;
+    case XML_TOK_ENTITY_REF:
+    case XML_TOK_DATA_CHARS:
+      if (!poolAppend(pool, enc, entityTextPtr, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_TRAILING_CR:
+      next = entityTextPtr + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_DATA_NEWLINE:
+      if (pool->end == pool->ptr && !poolGrow(pool))
+	return XML_ERROR_NO_MEMORY;
+      *(pool->ptr)++ = 0xA;
+      break;
+    case XML_TOK_CHAR_REF:
+      {
+	XML_Char buf[XML_ENCODE_MAX];
+	int i;
+	int n = XmlCharRefNumber(enc, entityTextPtr);
+	if (n < 0) {
+	  if (enc == encoding)
+	    eventPtr = entityTextPtr;
+	  return XML_ERROR_BAD_CHAR_REF;
+	}
+	n = XmlEncode(n, (ICHAR *)buf);
+	if (!n) {
+	  if (enc == encoding)
+	    eventPtr = entityTextPtr;
+	  return XML_ERROR_BAD_CHAR_REF;
+	}
+	for (i = 0; i < n; i++) {
+	  if (pool->end == pool->ptr && !poolGrow(pool))
+	    return XML_ERROR_NO_MEMORY;
+	  *(pool->ptr)++ = buf[i];
+	}
+      }
+      break;
+    case XML_TOK_PARTIAL:
+      if (enc == encoding)
+	eventPtr = entityTextPtr;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_INVALID:
+      if (enc == encoding)
+	eventPtr = next;
+      return XML_ERROR_INVALID_TOKEN;
+    default:
+      if (enc == encoding)
+	eventPtr = entityTextPtr;
+      return XML_ERROR_UNEXPECTED_STATE;
+    }
+    entityTextPtr = next;
+  }
+  /* not reached */
+}
+
+static void
+normalizeLines(XML_Char *s)
+{
+  XML_Char *p;
+  for (;; s++) {
+    if (*s == XML_T('\0'))
+      return;
+    if (*s == 0xD)
+      break;
+  }
+  p = s;
+  do {
+    if (*s == 0xD) {
+      *p++ = 0xA;
+      if (*++s == 0xA)
+        s++;
+    }
+    else
+      *p++ = *s++;
+  } while (*s);
+  *p = XML_T('\0');
+}
+
+static int
+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
+{
+  const XML_Char *target;
+  XML_Char *data;
+  const char *tem;
+  if (!processingInstructionHandler) {
+    if (defaultHandler)
+      reportDefault(parser, enc, start, end);
+    return 1;
+  }
+  start += enc->minBytesPerChar * 2;
+  tem = start + XmlNameLength(enc, start);
+  target = poolStoreString(&tempPool, enc, start, tem);
+  if (!target)
+    return 0;
+  poolFinish(&tempPool);
+  data = poolStoreString(&tempPool, enc,
+			XmlSkipS(enc, tem),
+			end - enc->minBytesPerChar*2);
+  if (!data)
+    return 0;
+  normalizeLines(data);
+  processingInstructionHandler(handlerArg, target, data);
+  poolClear(&tempPool);
+  return 1;
+}
+
+static int
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
+{
+  XML_Char *data;
+  if (!commentHandler) {
+    if (defaultHandler)
+      reportDefault(parser, enc, start, end);
+    return 1;
+  }
+  data = poolStoreString(&tempPool,
+                         enc,
+                         start + enc->minBytesPerChar * 4, 
+			 end - enc->minBytesPerChar * 3);
+  if (!data)
+    return 0;
+  normalizeLines(data);
+  commentHandler(handlerArg, data);
+  poolClear(&tempPool);
+  return 1;
+}
+
+static void
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *s, const char *end)
+{
+  if (MUST_CONVERT(enc, s)) {
+    const char **eventPP;
+    const char **eventEndPP;
+    if (enc == encoding) {
+      eventPP = &eventPtr;
+      eventEndPP = &eventEndPtr;
+    }
+    else {
+      eventPP = &(openInternalEntities->internalEventPtr);
+      eventEndPP = &(openInternalEntities->internalEventEndPtr);
+    }
+    do {
+      ICHAR *dataPtr = (ICHAR *)dataBuf;
+      XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
+      *eventEndPP = s;
+      defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
+      *eventPP = s;
+    } while (s != end);
+  }
+  else
+    defaultHandler(handlerArg, (XML_Char *)s, (XML_Char *)end - (XML_Char *)s);
+}
+
+
+static int
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata,
+		int isId, const XML_Char *value, XML_Parser parser)
+{
+  DEFAULT_ATTRIBUTE *att;
+  if (value || isId) {
+    /* The handling of default attributes gets messed up if we have
+       a default which duplicates a non-default. */
+    int i;
+    for (i = 0; i < type->nDefaultAtts; i++)
+      if (attId == type->defaultAtts[i].id)
+	return 1;
+    if (isId && !type->idAtt && !attId->xmlns)
+      type->idAtt = attId;
+  }
+  if (type->nDefaultAtts == type->allocDefaultAtts) {
+    if (type->allocDefaultAtts == 0) {
+      type->allocDefaultAtts = 8;
+      type->defaultAtts = MALLOC(type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
+    }
+    else {
+      type->allocDefaultAtts *= 2;
+      type->defaultAtts = REALLOC(type->defaultAtts,
+				  type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
+    }
+    if (!type->defaultAtts)
+      return 0;
+  }
+  att = type->defaultAtts + type->nDefaultAtts;
+  att->id = attId;
+  att->value = value;
+  att->isCdata = isCdata;
+  if (!isCdata)
+    attId->maybeTokenized = 1;
+  type->nDefaultAtts += 1;
+  return 1;
+}
+
+static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
+{
+  const XML_Char *name;
+  for (name = elementType->name; *name; name++) {
+    if (*name == XML_T(':')) {
+      PREFIX *prefix;
+      const XML_Char *s;
+      for (s = elementType->name; s != name; s++) {
+	if (!poolAppendChar(&dtd.pool, *s))
+	  return 0;
+      }
+      if (!poolAppendChar(&dtd.pool, XML_T('\0')))
+	return 0;
+      prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
+      if (!prefix)
+	return 0;
+      if (prefix->name == poolStart(&dtd.pool))
+	poolFinish(&dtd.pool);
+      else
+	poolDiscard(&dtd.pool);
+      elementType->prefix = prefix;
+
+    }
+  }
+  return 1;
+}
+
+static ATTRIBUTE_ID *
+getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
+{
+  ATTRIBUTE_ID *id;
+  const XML_Char *name;
+  if (!poolAppendChar(&dtd.pool, XML_T('\0')))
+    return 0;
+  name = poolStoreString(&dtd.pool, enc, start, end);
+  if (!name)
+    return 0;
+  ++name;
+  id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, name, sizeof(ATTRIBUTE_ID));
+  if (!id)
+    return 0;
+  if (id->name != name)
+    poolDiscard(&dtd.pool);
+  else {
+    poolFinish(&dtd.pool);
+    if (!ns)
+      ;
+    else if (name[0] == 'x'
+	&& name[1] == 'm'
+	&& name[2] == 'l'
+	&& name[3] == 'n'
+	&& name[4] == 's'
+	&& (name[5] == XML_T('\0') || name[5] == XML_T(':'))) {
+      if (name[5] == '\0')
+	id->prefix = &dtd.defaultPrefix;
+      else
+	id->prefix = (PREFIX *)lookup(&dtd.prefixes, name + 6, sizeof(PREFIX));
+      id->xmlns = 1;
+    }
+    else {
+      int i;
+      for (i = 0; name[i]; i++) {
+	if (name[i] == XML_T(':')) {
+	  int j;
+	  for (j = 0; j < i; j++) {
+	    if (!poolAppendChar(&dtd.pool, name[j]))
+	      return 0;
+	  }
+	  if (!poolAppendChar(&dtd.pool, XML_T('\0')))
+	    return 0;
+	  id->prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
+	  if (id->prefix->name == poolStart(&dtd.pool))
+	    poolFinish(&dtd.pool);
+	  else
+	    poolDiscard(&dtd.pool);
+	  break;
+	}
+      }
+    }
+  }
+  return id;
+}
+
+#define CONTEXT_SEP XML_T('\f')
+
+static
+const XML_Char *getContext(XML_Parser parser)
+{
+  HASH_TABLE_ITER iter;
+  int needSep = 0;
+
+  if (dtd.defaultPrefix.binding) {
+    int i;
+    int len;
+    if (!poolAppendChar(&tempPool, XML_T('=')))
+      return 0;
+    len = dtd.defaultPrefix.binding->uriLen;
+    if (namespaceSeparator != XML_T('\0'))
+      len--;
+    for (i = 0; i < len; i++)
+      if (!poolAppendChar(&tempPool, dtd.defaultPrefix.binding->uri[i]))
+  	return 0;
+    needSep = 1;
+  }
+
+  hashTableIterInit(&iter, &(dtd.prefixes));
+  for (;;) {
+    int i;
+    int len;
+    const XML_Char *s;
+    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
+    if (!prefix)
+      break;
+    if (!prefix->binding)
+      continue;
+    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
+      return 0;
+    for (s = prefix->name; *s; s++)
+      if (!poolAppendChar(&tempPool, *s))
+        return 0;
+    if (!poolAppendChar(&tempPool, XML_T('=')))
+      return 0;
+    len = prefix->binding->uriLen;
+    if (namespaceSeparator != XML_T('\0'))
+      len--;
+    for (i = 0; i < len; i++)
+      if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))
+        return 0;
+    needSep = 1;
+  }
+
+
+  hashTableIterInit(&iter, &(dtd.generalEntities));
+  for (;;) {
+    const XML_Char *s;
+    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
+    if (!e)
+      break;
+    if (!e->open)
+      continue;
+    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
+      return 0;
+    for (s = e->name; *s; s++)
+      if (!poolAppendChar(&tempPool, *s))
+        return 0;
+    needSep = 1;
+  }
+
+  if (!poolAppendChar(&tempPool, XML_T('\0')))
+    return 0;
+  return tempPool.start;
+}
+
+static
+int setContext(XML_Parser parser, const XML_Char *context)
+{
+  const XML_Char *s = context;
+
+  while (*context != XML_T('\0')) {
+    if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
+      ENTITY *e;
+      if (!poolAppendChar(&tempPool, XML_T('\0')))
+	return 0;
+      e = (ENTITY *)lookup(&dtd.generalEntities, poolStart(&tempPool), 0);
+      if (e)
+	e->open = 1;
+      if (*s != XML_T('\0'))
+	s++;
+      context = s;
+      poolDiscard(&tempPool);
+    }
+    else if (*s == '=') {
+      PREFIX *prefix;
+      if (poolLength(&tempPool) == 0)
+	prefix = &dtd.defaultPrefix;
+      else {
+	if (!poolAppendChar(&tempPool, XML_T('\0')))
+	  return 0;
+	prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&tempPool), sizeof(PREFIX));
+	if (!prefix)
+	  return 0;
+        if (prefix->name == poolStart(&tempPool)) {
+	  prefix->name = poolCopyString(&dtd.pool, prefix->name);
+	  if (!prefix->name)
+	    return 0;
+	}
+	poolDiscard(&tempPool);
+      }
+      for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0'); context++)
+        if (!poolAppendChar(&tempPool, *context))
+          return 0;
+      if (!poolAppendChar(&tempPool, XML_T('\0')))
+	return 0;
+      if (!addBinding(parser, prefix, 0, poolStart(&tempPool), &inheritedBindings))
+	return 0;
+      poolDiscard(&tempPool);
+      if (*context != XML_T('\0'))
+	++context;
+      s = context;
+    }
+    else {
+      if (!poolAppendChar(&tempPool, *s))
+	return 0;
+      s++;
+    }
+  }
+  return 1;
+}
+
+
+static
+void normalizePublicId(XML_Char *publicId)
+{
+  XML_Char *p = publicId;
+  XML_Char *s;
+  for (s = publicId; *s; s++) {
+    switch (*s) {
+    case 0x20:
+    case 0xD:
+    case 0xA:
+      if (p != publicId && p[-1] != 0x20)
+	*p++ = 0x20;
+      break;
+    default:
+      *p++ = *s;
+    }
+  }
+  if (p != publicId && p[-1] == 0x20)
+    --p;
+  *p = XML_T('\0');
+}
+
+static int dtdInit(DTD *p, XML_Parser parser)
+{
+  XML_Memory_Handling_Suite *ms = &((Parser *) parser)->m_mem; 
+  poolInit(&(p->pool), ms);
+  hashTableInit(&(p->generalEntities), ms);
+  hashTableInit(&(p->elementTypes), ms);
+  hashTableInit(&(p->attributeIds), ms);
+  hashTableInit(&(p->prefixes), ms);
+  p->complete = 1;
+  p->standalone = 0;
+#ifdef XML_DTD
+  hashTableInit(&(p->paramEntities), ms);
+#endif /* XML_DTD */
+  p->defaultPrefix.name = 0;
+  p->defaultPrefix.binding = 0;
+
+  p->in_eldecl = 0;
+  p->scaffIndex = 0;
+  p->scaffLevel = 0;
+  p->scaffold = 0;
+  p->contentStringLen = 0;
+  p->scaffSize = 0;
+  p->scaffCount = 0;
+
+  return 1;
+}
+
+#ifdef XML_DTD
+
+static void dtdSwap(DTD *p1, DTD *p2)
+{
+  DTD tem;
+  memcpy(&tem, p1, sizeof(DTD));
+  memcpy(p1, p2, sizeof(DTD));
+  memcpy(p2, &tem, sizeof(DTD));
+}
+
+#endif /* XML_DTD */
+
+static void dtdDestroy(DTD *p, XML_Parser parser)
+{
+  HASH_TABLE_ITER iter;
+  hashTableIterInit(&iter, &(p->elementTypes));
+  for (;;) {
+    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (!e)
+      break;
+    if (e->allocDefaultAtts != 0)
+      FREE(e->defaultAtts);
+  }
+  hashTableDestroy(&(p->generalEntities));
+#ifdef XML_DTD
+  hashTableDestroy(&(p->paramEntities));
+#endif /* XML_DTD */
+  hashTableDestroy(&(p->elementTypes));
+  hashTableDestroy(&(p->attributeIds));
+  hashTableDestroy(&(p->prefixes));
+  poolDestroy(&(p->pool));
+  if (p->scaffIndex)
+    FREE(p->scaffIndex);
+  if (p->scaffold)
+    FREE(p->scaffold);
+}
+
+/* Do a deep copy of the DTD.  Return 0 for out of memory; non-zero otherwise.
+The new DTD has already been initialized. */
+
+static int dtdCopy(DTD *newDtd, const DTD *oldDtd, XML_Parser parser)
+{
+  HASH_TABLE_ITER iter;
+
+  /* Copy the prefix table. */
+
+  hashTableIterInit(&iter, &(oldDtd->prefixes));
+  for (;;) {
+    const XML_Char *name;
+    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
+    if (!oldP)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldP->name);
+    if (!name)
+      return 0;
+    if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))
+      return 0;
+  }
+
+  hashTableIterInit(&iter, &(oldDtd->attributeIds));
+
+  /* Copy the attribute id table. */
+
+  for (;;) {
+    ATTRIBUTE_ID *newA;
+    const XML_Char *name;
+    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
+
+    if (!oldA)
+      break;
+    /* Remember to allocate the scratch byte before the name. */
+    if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
+      return 0;
+    name = poolCopyString(&(newDtd->pool), oldA->name);
+    if (!name)
+      return 0;
+    ++name;
+    newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name, sizeof(ATTRIBUTE_ID));
+    if (!newA)
+      return 0;
+    newA->maybeTokenized = oldA->maybeTokenized;
+    if (oldA->prefix) {
+      newA->xmlns = oldA->xmlns;
+      if (oldA->prefix == &oldDtd->defaultPrefix)
+	newA->prefix = &newDtd->defaultPrefix;
+      else
+	newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldA->prefix->name, 0);
+    }
+  }
+
+  /* Copy the element type table. */
+
+  hashTableIterInit(&iter, &(oldDtd->elementTypes));
+
+  for (;;) {
+    int i;
+    ELEMENT_TYPE *newE;
+    const XML_Char *name;
+    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (!oldE)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldE->name);
+    if (!name)
+      return 0;
+    newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name, sizeof(ELEMENT_TYPE));
+    if (!newE)
+      return 0;
+    if (oldE->nDefaultAtts) {
+      newE->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (!newE->defaultAtts)
+	return 0;
+    }
+    if (oldE->idAtt)
+      newE->idAtt = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);
+    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
+    if (oldE->prefix)
+      newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldE->prefix->name, 0);
+    for (i = 0; i < newE->nDefaultAtts; i++) {
+      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
+      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
+      if (oldE->defaultAtts[i].value) {
+	newE->defaultAtts[i].value = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
+	if (!newE->defaultAtts[i].value)
+  	  return 0;
+      }
+      else
+	newE->defaultAtts[i].value = 0;
+    }
+  }
+
+  /* Copy the entity tables. */
+  if (!copyEntityTable(&(newDtd->generalEntities),
+		       &(newDtd->pool),
+		       &(oldDtd->generalEntities), parser))
+      return 0;
+
+#ifdef XML_DTD
+  if (!copyEntityTable(&(newDtd->paramEntities),
+		       &(newDtd->pool),
+		       &(oldDtd->paramEntities), parser))
+      return 0;
+#endif /* XML_DTD */
+
+  newDtd->complete = oldDtd->complete;
+  newDtd->standalone = oldDtd->standalone;
+
+  /* Don't want deep copying for scaffolding */
+  newDtd->in_eldecl = oldDtd->in_eldecl;
+  newDtd->scaffold = oldDtd->scaffold;
+  newDtd->contentStringLen = oldDtd->contentStringLen;
+  newDtd->scaffSize = oldDtd->scaffSize;
+  newDtd->scaffLevel = oldDtd->scaffLevel;
+  newDtd->scaffIndex = oldDtd->scaffIndex;
+
+  return 1;
+}  /* End dtdCopy */
+
+static int copyEntityTable(HASH_TABLE *newTable,
+			   STRING_POOL *newPool,
+			   const HASH_TABLE *oldTable,
+			   XML_Parser parser)
+{
+  HASH_TABLE_ITER iter;
+  const XML_Char *cachedOldBase = 0;
+  const XML_Char *cachedNewBase = 0;
+
+  hashTableIterInit(&iter, oldTable);
+
+  for (;;) {
+    ENTITY *newE;
+    const XML_Char *name;
+    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
+    if (!oldE)
+      break;
+    name = poolCopyString(newPool, oldE->name);
+    if (!name)
+      return 0;
+    newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));
+    if (!newE)
+      return 0;
+    if (oldE->systemId) {
+      const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
+      if (!tem)
+	return 0;
+      newE->systemId = tem;
+      if (oldE->base) {
+	if (oldE->base == cachedOldBase)
+	  newE->base = cachedNewBase;
+	else {
+	  cachedOldBase = oldE->base;
+	  tem = poolCopyString(newPool, cachedOldBase);
+	  if (!tem)
+	    return 0;
+	  cachedNewBase = newE->base = tem;
+	}
+      }
+    }
+    else {
+      const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);
+      if (!tem)
+	return 0;
+      newE->textPtr = tem;
+      newE->textLen = oldE->textLen;
+    }
+    if (oldE->notation) {
+      const XML_Char *tem = poolCopyString(newPool, oldE->notation);
+      if (!tem)
+	return 0;
+      newE->notation = tem;
+    }
+  }
+  return 1;
+}
+
+#define INIT_SIZE 64
+
+static
+int keyeq(KEY s1, KEY s2)
+{
+  for (; *s1 == *s2; s1++, s2++)
+    if (*s1 == 0)
+      return 1;
+  return 0;
+}
+
+static
+unsigned long hash(KEY s)
+{
+  unsigned long h = 0;
+  while (*s)
+    h = (h << 5) + h + (unsigned char)*s++;
+  return h;
+}
+
+static
+NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize)
+{
+  size_t i;
+  if (table->size == 0) {
+    size_t tsize;
+
+    if (!createSize)
+      return 0;
+    tsize = INIT_SIZE * sizeof(NAMED *);
+    table->v = table->mem->malloc_fcn(tsize);
+    if (!table->v)
+      return 0;
+    memset(table->v, 0, tsize);
+    table->size = INIT_SIZE;
+    table->usedLim = INIT_SIZE / 2;
+    i = hash(name) & (table->size - 1);
+  }
+  else {
+    unsigned long h = hash(name);
+    for (i = h & (table->size - 1);
+         table->v[i];
+         i == 0 ? i = table->size - 1 : --i) {
+      if (keyeq(name, table->v[i]->name))
+	return table->v[i];
+    }
+    if (!createSize)
+      return 0;
+    if (table->used == table->usedLim) {
+      /* check for overflow */
+      size_t newSize = table->size * 2;
+      size_t tsize = newSize * sizeof(NAMED *);
+      NAMED **newV = table->mem->malloc_fcn(tsize);
+      if (!newV)
+	return 0;
+      memset(newV, 0, tsize);
+      for (i = 0; i < table->size; i++)
+	if (table->v[i]) {
+	  size_t j;
+	  for (j = hash(table->v[i]->name) & (newSize - 1);
+	       newV[j];
+	       j == 0 ? j = newSize - 1 : --j)
+	    ;
+	  newV[j] = table->v[i];
+	}
+      table->mem->free_fcn(table->v);
+      table->v = newV;
+      table->size = newSize;
+      table->usedLim = newSize/2;
+      for (i = h & (table->size - 1);
+	   table->v[i];
+	   i == 0 ? i = table->size - 1 : --i)
+	;
+    }
+  }
+  table->v[i] = table->mem->malloc_fcn(createSize);
+  if (!table->v[i])
+    return 0;
+  memset(table->v[i], 0, createSize);
+  table->v[i]->name = name;
+  (table->used)++;
+  return table->v[i];
+}
+
+static
+void hashTableDestroy(HASH_TABLE *table)
+{
+  size_t i;
+  for (i = 0; i < table->size; i++) {
+    NAMED *p = table->v[i];
+    if (p)
+      table->mem->free_fcn(p);
+  }
+  if (table->v)
+    table->mem->free_fcn(table->v);
+}
+
+static
+void hashTableInit(HASH_TABLE *p, XML_Memory_Handling_Suite *ms)
+{
+  p->size = 0;
+  p->usedLim = 0;
+  p->used = 0;
+  p->v = 0;
+  p->mem = ms;
+}
+
+static
+void hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)
+{
+  iter->p = table->v;
+  iter->end = iter->p + table->size;
+}
+
+static
+NAMED *hashTableIterNext(HASH_TABLE_ITER *iter)
+{
+  while (iter->p != iter->end) {
+    NAMED *tem = *(iter->p)++;
+    if (tem)
+      return tem;
+  }
+  return 0;
+}
+
+
+static
+void poolInit(STRING_POOL *pool, XML_Memory_Handling_Suite *ms)
+{
+  pool->blocks = 0;
+  pool->freeBlocks = 0;
+  pool->start = 0;
+  pool->ptr = 0;
+  pool->end = 0;
+  pool->mem = ms;
+}
+
+static
+void poolClear(STRING_POOL *pool)
+{
+  if (!pool->freeBlocks)
+    pool->freeBlocks = pool->blocks;
+  else {
+    BLOCK *p = pool->blocks;
+    while (p) {
+      BLOCK *tem = p->next;
+      p->next = pool->freeBlocks;
+      pool->freeBlocks = p;
+      p = tem;
+    }
+  }
+  pool->blocks = 0;
+  pool->start = 0;
+  pool->ptr = 0;
+  pool->end = 0;
+}
+
+static
+void poolDestroy(STRING_POOL *pool)
+{
+  BLOCK *p = pool->blocks;
+  while (p) {
+    BLOCK *tem = p->next;
+    pool->mem->free_fcn(p);
+    p = tem;
+  }
+  pool->blocks = 0;
+  p = pool->freeBlocks;
+  while (p) {
+    BLOCK *tem = p->next;
+    pool->mem->free_fcn(p);
+    p = tem;
+  }
+  pool->freeBlocks = 0;
+  pool->ptr = 0;
+  pool->start = 0;
+  pool->end = 0;
+}
+
+static
+XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+		     const char *ptr, const char *end)
+{
+  if (!pool->ptr && !poolGrow(pool))
+    return 0;
+  for (;;) {
+    XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
+    if (ptr == end)
+      break;
+    if (!poolGrow(pool))
+      return 0;
+  }
+  return pool->start;
+}
+
+static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s)
+{
+  do {
+    if (!poolAppendChar(pool, *s))
+      return 0;
+  } while (*s++);
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
+
+static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
+{
+  if (!pool->ptr && !poolGrow(pool))
+    return 0;
+  for (; n > 0; --n, s++) {
+    if (!poolAppendChar(pool, *s))
+      return 0;
+
+  }
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
+
+static
+const XML_Char *poolAppendString(STRING_POOL *pool, const XML_Char *s)
+{
+  while (*s) {
+    if (!poolAppendChar(pool, *s))
+      return 0;
+    s++;
+  } 
+  return pool->start;
+}  /* End poolAppendString */
+
+static
+XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+			  const char *ptr, const char *end)
+{
+  if (!poolAppend(pool, enc, ptr, end))
+    return 0;
+  if (pool->ptr == pool->end && !poolGrow(pool))
+    return 0;
+  *(pool->ptr)++ = 0;
+  return pool->start;
+}
+
+static
+int poolGrow(STRING_POOL *pool)
+{
+  if (pool->freeBlocks) {
+    if (pool->start == 0) {
+      pool->blocks = pool->freeBlocks;
+      pool->freeBlocks = pool->freeBlocks->next;
+      pool->blocks->next = 0;
+      pool->start = pool->blocks->s;
+      pool->end = pool->start + pool->blocks->size;
+      pool->ptr = pool->start;
+      return 1;
+    }
+    if (pool->end - pool->start < pool->freeBlocks->size) {
+      BLOCK *tem = pool->freeBlocks->next;
+      pool->freeBlocks->next = pool->blocks;
+      pool->blocks = pool->freeBlocks;
+      pool->freeBlocks = tem;
+      memcpy(pool->blocks->s, pool->start, (pool->end - pool->start) * sizeof(XML_Char));
+      pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
+      pool->start = pool->blocks->s;
+      pool->end = pool->start + pool->blocks->size;
+      return 1;
+    }
+  }
+  if (pool->blocks && pool->start == pool->blocks->s) {
+    int blockSize = (pool->end - pool->start)*2;
+    pool->blocks = pool->mem->realloc_fcn(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
+    if (!pool->blocks)
+      return 0;
+    pool->blocks->size = blockSize;
+    pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
+    pool->start = pool->blocks->s;
+    pool->end = pool->start + blockSize;
+  }
+  else {
+    BLOCK *tem;
+    int blockSize = pool->end - pool->start;
+    if (blockSize < INIT_BLOCK_SIZE)
+      blockSize = INIT_BLOCK_SIZE;
+    else
+      blockSize *= 2;
+    tem = pool->mem->malloc_fcn(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
+    if (!tem)
+      return 0;
+    tem->size = blockSize;
+    tem->next = pool->blocks;
+    pool->blocks = tem;
+    if (pool->ptr != pool->start)
+      memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
+    pool->ptr = tem->s + (pool->ptr - pool->start);
+    pool->start = tem->s;
+    pool->end = tem->s + blockSize;
+  }
+  return 1;
+}
+
+static int
+nextScaffoldPart(XML_Parser parser)
+{
+  CONTENT_SCAFFOLD * me;
+  int next;
+
+  if (! dtd.scaffIndex) {
+    dtd.scaffIndex = MALLOC(groupSize * sizeof(int));
+    if (! dtd.scaffIndex)
+      return -1;
+    dtd.scaffIndex[0] = 0;
+  }
+
+  if (dtd.scaffCount >= dtd.scaffSize) {
+    if (dtd.scaffold) {
+      dtd.scaffSize *= 2;
+      dtd.scaffold = (CONTENT_SCAFFOLD *) REALLOC(dtd.scaffold,
+					      dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
+    }
+    else {
+      dtd.scaffSize = 32;
+      dtd.scaffold = (CONTENT_SCAFFOLD *) MALLOC(dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
+    }
+    if (! dtd.scaffold)
+      return -1;
+  }
+  next = dtd.scaffCount++;
+  me = &dtd.scaffold[next];
+  if (dtd.scaffLevel) { 
+    CONTENT_SCAFFOLD *parent = &dtd.scaffold[dtd.scaffIndex[dtd.scaffLevel - 1]];
+    if (parent->lastchild) {
+      dtd.scaffold[parent->lastchild].nextsib = next;
+    }
+    if (! parent->childcnt)
+      parent->firstchild = next;
+    parent->lastchild = next;
+    parent->childcnt++;
+  }
+  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
+  return next;
+}  /* End nextScaffoldPart */
+
+static void
+build_node (XML_Parser parser,
+	    int src_node,
+	    XML_Content *dest,
+	    XML_Content **contpos,
+	    char **strpos)
+{
+  dest->type = dtd.scaffold[src_node].type;
+  dest->quant = dtd.scaffold[src_node].quant;
+  if (dest->type == XML_CTYPE_NAME) {
+    const char *src;
+    dest->name = *strpos;
+    src = dtd.scaffold[src_node].name;
+    for (;;) {
+      *(*strpos)++ = *src;
+      if (! *src)
+	break;
+      src++;
+    }
+    dest->numchildren = 0;
+    dest->children = 0;
+  }
+  else {
+    unsigned int i;
+    int cn;
+    dest->numchildren = dtd.scaffold[src_node].childcnt;
+    dest->children = *contpos;
+    *contpos += dest->numchildren;
+    for (i = 0, cn = dtd.scaffold[src_node].firstchild;
+	 i < dest->numchildren;
+	 i++, cn = dtd.scaffold[cn].nextsib) {
+      build_node(parser, cn, &(dest->children[i]), contpos, strpos);
+    }
+    dest->name = 0;
+  }
+}  /* End build_node */
+
+static XML_Content *
+build_model (XML_Parser parser)
+{
+  XML_Content *ret;
+  XML_Content *cpos;
+  char * str;
+  int allocsize = dtd.scaffCount * sizeof(XML_Content) + dtd.contentStringLen;
+  
+  ret = MALLOC(allocsize);
+  if (! ret)
+    return 0;
+
+  str =  (char *) (&ret[dtd.scaffCount]);
+  cpos = &ret[1];
+
+  build_node(parser, 0, ret, &cpos, &str);
+  return ret;
+}  /* End build_model */
+
+static ELEMENT_TYPE *
+getElementType(XML_Parser parser,
+	       const ENCODING *enc,
+	       const char *ptr,
+	       const char *end)
+{
+  const XML_Char *name = poolStoreString(&dtd.pool, enc, ptr, end);
+  ELEMENT_TYPE *ret;
+
+  if (! name)
+    return 0;
+  ret = (ELEMENT_TYPE *) lookup(&dtd.elementTypes, name, sizeof(ELEMENT_TYPE));
+  if (! ret)
+    return 0;
+  if (ret->name != name)
+    poolDiscard(&dtd.pool);
+  else {
+    poolFinish(&dtd.pool);
+    if (!setElementTypePrefix(parser, ret))
+      return 0;
+  }
+  return ret;
+}  /* End getElementType */
Index: xc/extras/expat/lib/xmlrole.c
diff -u /dev/null xc/extras/expat/lib/xmlrole.c:1.2
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmlrole.c	Sat Apr  6 23:03:19 2002
@@ -0,0 +1,1279 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#if 0
+static char RCSId[]
+  = "$Header: /cvsroot/expat/expat/lib/xmlrole.c,v 1.5 2000/10/22 19:20:23 coopercc Exp $";
+#endif
+
+/* $XFree86: xc/extras/expat/lib/xmlrole.c,v 1.2 2002/04/07 04:03:19 tsi Exp $ */
+
+#ifdef COMPILED_FROM_DSP
+#  include "winconfig.h"
+#else
+#  include <config.h>
+#endif /* ndef COMPILED_FROM_DSP */
+
+#include "xmlrole.h"
+#include "ascii.h"
+
+/* Doesn't check:
+
+ that ,| are not mixed in a model group
+ content of literals
+
+*/
+
+static const char KW_ANY[] = { ASCII_A, ASCII_N, ASCII_Y, '\0' };
+static const char KW_ATTLIST[] = { ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
+static const char KW_CDATA[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
+static const char KW_DOCTYPE[] = { ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
+static const char KW_ELEMENT[] = { ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
+static const char KW_EMPTY[] = { ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
+static const char KW_ENTITIES[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
+static const char KW_ENTITY[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
+static const char KW_FIXED[] = { ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
+static const char KW_ID[] = { ASCII_I, ASCII_D, '\0' };
+static const char KW_IDREF[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
+static const char KW_IDREFS[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
+static const char KW_IGNORE[] = { ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
+static const char KW_IMPLIED[] = { ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
+static const char KW_INCLUDE[] = { ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
+static const char KW_NDATA[] = { ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
+static const char KW_NMTOKEN[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
+static const char KW_NMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
+static const char KW_NOTATION[] = { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0' };
+static const char KW_PCDATA[] = { ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
+static const char KW_PUBLIC[] = { ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
+static const char KW_REQUIRED[] = { ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0' };
+static const char KW_SYSTEM[] = { ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
+
+#ifndef MIN_BYTES_PER_CHAR
+#define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
+#endif
+
+#ifdef XML_DTD
+#define setTopLevel(state) \
+  ((state)->handler = ((state)->documentEntity \
+                       ? internalSubset \
+                       : externalSubset1))
+#else /* not XML_DTD */
+#define setTopLevel(state) ((state)->handler = internalSubset)
+#endif /* not XML_DTD */
+
+typedef int PROLOG_HANDLER(PROLOG_STATE *state,
+			   int tok,
+			   const char *ptr,
+			   const char *end,
+			   const ENCODING *enc);
+
+static PROLOG_HANDLER
+  prolog0, prolog1, prolog2,
+  doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
+  internalSubset,
+  entity0, entity1, entity2, entity3, entity4, entity5, entity6,
+  entity7, entity8, entity9,
+  notation0, notation1, notation2, notation3, notation4,
+  attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
+  attlist7, attlist8, attlist9,
+  element0, element1, element2, element3, element4, element5, element6,
+  element7,
+#ifdef XML_DTD
+  externalSubset0, externalSubset1,
+  condSect0, condSect1, condSect2,
+#endif /* XML_DTD */
+  declClose,
+  error;
+
+static
+int common(PROLOG_STATE *state, int tok);
+
+static
+int prolog0(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    state->handler = prolog1;
+    return XML_ROLE_NONE;
+  case XML_TOK_XML_DECL:
+    state->handler = prolog1;
+    return XML_ROLE_XML_DECL;
+  case XML_TOK_PI:
+    state->handler = prolog1;
+    return XML_ROLE_NONE;
+  case XML_TOK_COMMENT:
+    state->handler = prolog1;
+  case XML_TOK_BOM:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_OPEN:
+    if (!XmlNameMatchesAscii(enc,
+			     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
+			     end,
+			     KW_DOCTYPE))
+      break;
+    state->handler = doctype0;
+    return XML_ROLE_NONE;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static
+int prolog1(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_PI:
+  case XML_TOK_COMMENT:
+  case XML_TOK_BOM:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_OPEN:
+    if (!XmlNameMatchesAscii(enc,
+			     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
+			     end,
+			     KW_DOCTYPE))
+      break;
+    state->handler = doctype0;
+    return XML_ROLE_NONE;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static
+int prolog2(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_PI:
+  case XML_TOK_COMMENT:
+    return XML_ROLE_NONE;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static
+int doctype0(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = doctype1;
+    return XML_ROLE_DOCTYPE_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int doctype1(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = internalSubset;
+    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = doctype3;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = doctype2;
+      return XML_ROLE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static
+int doctype2(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = doctype3;
+    return XML_ROLE_DOCTYPE_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int doctype3(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = doctype4;
+    return XML_ROLE_DOCTYPE_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int doctype4(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = internalSubset;
+    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  }
+  return common(state, tok);
+}
+
+static
+int doctype5(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  }
+  return common(state, tok);
+}
+
+static
+int internalSubset(PROLOG_STATE *state,
+		   int tok,
+		   const char *ptr,
+		   const char *end,
+		   const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_OPEN:
+    if (XmlNameMatchesAscii(enc,
+			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_ENTITY)) {
+      state->handler = entity0;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc,
+			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_ATTLIST)) {
+      state->handler = attlist0;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc,
+			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_ELEMENT)) {
+      state->handler = element0;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc,
+			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_NOTATION)) {
+      state->handler = notation0;
+      return XML_ROLE_NONE;
+    }
+    break;
+  case XML_TOK_PI:
+  case XML_TOK_COMMENT:
+    return XML_ROLE_NONE;
+  case XML_TOK_PARAM_ENTITY_REF:
+    return XML_ROLE_PARAM_ENTITY_REF;
+  case XML_TOK_CLOSE_BRACKET:
+    state->handler = doctype5;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+#ifdef XML_DTD
+
+static
+int externalSubset0(PROLOG_STATE *state,
+		    int tok,
+		    const char *ptr,
+		    const char *end,
+		    const ENCODING *enc)
+{
+  state->handler = externalSubset1;
+  if (tok == XML_TOK_XML_DECL)
+    return XML_ROLE_TEXT_DECL;
+  return externalSubset1(state, tok, ptr, end, enc);
+}
+
+static
+int externalSubset1(PROLOG_STATE *state,
+		    int tok,
+		    const char *ptr,
+		    const char *end,
+		    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_COND_SECT_OPEN:
+    state->handler = condSect0;
+    return XML_ROLE_NONE;
+  case XML_TOK_COND_SECT_CLOSE:
+    if (state->includeLevel == 0)
+      break;
+    state->includeLevel -= 1;
+    return XML_ROLE_NONE;
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_BRACKET:
+    break;
+  case XML_TOK_NONE:
+    if (state->includeLevel)
+      break;
+    return XML_ROLE_NONE;
+  default:
+    return internalSubset(state, tok, ptr, end, enc);
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
+static
+int entity0(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_PERCENT:
+    state->handler = entity1;
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    state->handler = entity2;
+    return XML_ROLE_GENERAL_ENTITY_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int entity1(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    state->handler = entity7;
+    return XML_ROLE_PARAM_ENTITY_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int entity2(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = entity4;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = entity3;
+      return XML_ROLE_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    return XML_ROLE_ENTITY_VALUE;
+  }
+  return common(state, tok);
+}
+
+static
+int entity3(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity4;
+    return XML_ROLE_ENTITY_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+
+static
+int entity4(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity5;
+    return XML_ROLE_ENTITY_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int entity5(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_ENTITY_COMPLETE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
+      state->handler = entity6;
+      return XML_ROLE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static
+int entity6(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    state->handler = declClose;
+    return XML_ROLE_ENTITY_NOTATION_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int entity7(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = entity9;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = entity8;
+      return XML_ROLE_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    return XML_ROLE_ENTITY_VALUE;
+  }
+  return common(state, tok);
+}
+
+static
+int entity8(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity9;
+    return XML_ROLE_ENTITY_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int entity9(PROLOG_STATE *state,
+	    int tok,
+	    const char *ptr,
+	    const char *end,
+	    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    return XML_ROLE_ENTITY_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int notation0(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    state->handler = notation1;
+    return XML_ROLE_NOTATION_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int notation1(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = notation3;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = notation2;
+      return XML_ROLE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static
+int notation2(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = notation4;
+    return XML_ROLE_NOTATION_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int notation3(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    return XML_ROLE_NOTATION_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int notation4(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    return XML_ROLE_NOTATION_SYSTEM_ID;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist0(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist1;
+    return XML_ROLE_ATTLIST_ELEMENT_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist1(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist2;
+    return XML_ROLE_ATTRIBUTE_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist2(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    {
+      static const char *types[] = {
+	KW_CDATA,
+        KW_ID,
+        KW_IDREF,
+        KW_IDREFS,
+        KW_ENTITY,
+        KW_ENTITIES,
+        KW_NMTOKEN,
+        KW_NMTOKENS,
+      };
+      int i;
+      for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
+	if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
+	  state->handler = attlist8;
+	  return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
+	}
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
+      state->handler = attlist5;
+      return XML_ROLE_NONE;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = attlist3;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist3(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NMTOKEN:
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist4;
+    return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist4(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = attlist8;
+    return XML_ROLE_NONE;
+  case XML_TOK_OR:
+    state->handler = attlist3;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist5(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = attlist6;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+
+static
+int attlist6(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    state->handler = attlist7;
+    return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist7(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = attlist8;
+    return XML_ROLE_NONE;
+  case XML_TOK_OR:
+    state->handler = attlist6;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+/* default value */
+static
+int attlist8(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_POUND_NAME:
+    if (XmlNameMatchesAscii(enc,
+			    ptr + MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_IMPLIED)) {
+      state->handler = attlist1;
+      return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
+    }
+    if (XmlNameMatchesAscii(enc,
+			    ptr + MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_REQUIRED)) {
+      state->handler = attlist1;
+      return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
+    }
+    if (XmlNameMatchesAscii(enc,
+			    ptr + MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_FIXED)) {
+      state->handler = attlist9;
+      return XML_ROLE_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = attlist1;
+    return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
+  }
+  return common(state, tok);
+}
+
+static
+int attlist9(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = attlist1;
+    return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
+  }
+  return common(state, tok);
+}
+
+static
+int element0(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element1;
+    return XML_ROLE_ELEMENT_NAME;
+  }
+  return common(state, tok);
+}
+
+static
+int element1(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
+      state->handler = declClose;
+      return XML_ROLE_CONTENT_EMPTY;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
+      state->handler = declClose;
+      return XML_ROLE_CONTENT_ANY;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = element2;
+    state->level = 1;
+    return XML_ROLE_GROUP_OPEN;
+  }
+  return common(state, tok);
+}
+
+static
+int element2(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_POUND_NAME:
+    if (XmlNameMatchesAscii(enc,
+			    ptr + MIN_BYTES_PER_CHAR(enc),
+			    end,
+			    KW_PCDATA)) {
+      state->handler = element3;
+      return XML_ROLE_CONTENT_PCDATA;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->level = 2;
+    state->handler = element6;
+    return XML_ROLE_GROUP_OPEN;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT;
+  case XML_TOK_NAME_QUESTION:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_OPT;
+  case XML_TOK_NAME_ASTERISK:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_REP;
+  case XML_TOK_NAME_PLUS:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_PLUS;
+  }
+  return common(state, tok);
+}
+
+static
+int element3(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = declClose;
+    return XML_ROLE_GROUP_CLOSE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->handler = declClose;
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_OR:
+    state->handler = element4;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static
+int element4(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element5;
+    return XML_ROLE_CONTENT_ELEMENT;
+  }
+  return common(state, tok);
+}
+
+static
+int element5(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->handler = declClose;
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_OR:
+    state->handler = element4;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static
+int element6(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_PAREN:
+    state->level += 1;
+    return XML_ROLE_GROUP_OPEN;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT;
+  case XML_TOK_NAME_QUESTION:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_OPT;
+  case XML_TOK_NAME_ASTERISK:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_REP;
+  case XML_TOK_NAME_PLUS:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_PLUS;
+  }
+  return common(state, tok);
+}
+
+static
+int element7(PROLOG_STATE *state,
+	     int tok,
+	     const char *ptr,
+	     const char *end,
+	     const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->level -= 1;
+    if (state->level == 0)
+      state->handler = declClose;
+    return XML_ROLE_GROUP_CLOSE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->level -= 1;
+    if (state->level == 0)
+      state->handler = declClose;
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_CLOSE_PAREN_QUESTION:
+    state->level -= 1;
+    if (state->level == 0)
+      state->handler = declClose;
+    return XML_ROLE_GROUP_CLOSE_OPT;
+  case XML_TOK_CLOSE_PAREN_PLUS:
+    state->level -= 1;
+    if (state->level == 0)
+      state->handler = declClose;
+    return XML_ROLE_GROUP_CLOSE_PLUS;
+  case XML_TOK_COMMA:
+    state->handler = element6;
+    return XML_ROLE_GROUP_SEQUENCE;
+  case XML_TOK_OR:
+    state->handler = element6;
+    return XML_ROLE_GROUP_CHOICE;
+  }
+  return common(state, tok);
+}
+
+#ifdef XML_DTD
+
+static
+int condSect0(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
+      state->handler = condSect1;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
+      state->handler = condSect2;
+      return XML_ROLE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static
+int condSect1(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    state->includeLevel += 1;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static
+int condSect2(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    return XML_ROLE_IGNORE_SECT;
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
+static
+int declClose(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+#if 0
+
+static
+int ignore(PROLOG_STATE *state,
+	   int tok,
+	   const char *ptr,
+	   const char *end,
+	   const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_DECL_CLOSE:
+    state->handler = internalSubset;
+    return 0;
+  default:
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+#endif
+
+static
+int error(PROLOG_STATE *state,
+	  int tok,
+	  const char *ptr,
+	  const char *end,
+	  const ENCODING *enc)
+{
+  return XML_ROLE_NONE;
+}
+
+static
+int common(PROLOG_STATE *state, int tok)
+{
+#ifdef XML_DTD
+  if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
+    return XML_ROLE_INNER_PARAM_ENTITY_REF;
+#endif
+  state->handler = error;
+  return XML_ROLE_ERROR;
+}
+
+void XmlPrologStateInit(PROLOG_STATE *state)
+{
+  state->handler = prolog0;
+#ifdef XML_DTD
+  state->documentEntity = 1;
+  state->includeLevel = 0;
+#endif /* XML_DTD */
+}
+
+#ifdef XML_DTD
+
+void XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
+{
+  state->handler = externalSubset0;
+  state->documentEntity = 0;
+  state->includeLevel = 0;
+}
+
+#endif /* XML_DTD */
Index: xc/extras/expat/lib/xmlrole.h
diff -u /dev/null xc/extras/expat/lib/xmlrole.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmlrole.h	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,100 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#ifndef XmlRole_INCLUDED
+#define XmlRole_INCLUDED 1
+
+#include "xmltok.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  XML_ROLE_ERROR = -1,
+  XML_ROLE_NONE = 0,
+  XML_ROLE_XML_DECL,
+  XML_ROLE_INSTANCE_START,
+  XML_ROLE_DOCTYPE_NAME,
+  XML_ROLE_DOCTYPE_SYSTEM_ID,
+  XML_ROLE_DOCTYPE_PUBLIC_ID,
+  XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
+  XML_ROLE_DOCTYPE_CLOSE,
+  XML_ROLE_GENERAL_ENTITY_NAME,
+  XML_ROLE_PARAM_ENTITY_NAME,
+  XML_ROLE_ENTITY_VALUE,
+  XML_ROLE_ENTITY_SYSTEM_ID,
+  XML_ROLE_ENTITY_PUBLIC_ID,
+  XML_ROLE_ENTITY_COMPLETE,
+  XML_ROLE_ENTITY_NOTATION_NAME,
+  XML_ROLE_NOTATION_NAME,
+  XML_ROLE_NOTATION_SYSTEM_ID,
+  XML_ROLE_NOTATION_NO_SYSTEM_ID,
+  XML_ROLE_NOTATION_PUBLIC_ID,
+  XML_ROLE_ATTRIBUTE_NAME,
+  XML_ROLE_ATTRIBUTE_TYPE_CDATA,
+  XML_ROLE_ATTRIBUTE_TYPE_ID,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREF,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
+  XML_ROLE_ATTRIBUTE_ENUM_VALUE,
+  XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
+  XML_ROLE_ATTLIST_ELEMENT_NAME,
+  XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
+  XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
+  XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
+  XML_ROLE_FIXED_ATTRIBUTE_VALUE,
+  XML_ROLE_ELEMENT_NAME,
+  XML_ROLE_CONTENT_ANY,
+  XML_ROLE_CONTENT_EMPTY,
+  XML_ROLE_CONTENT_PCDATA,
+  XML_ROLE_GROUP_OPEN,
+  XML_ROLE_GROUP_CLOSE,
+  XML_ROLE_GROUP_CLOSE_REP,
+  XML_ROLE_GROUP_CLOSE_OPT,
+  XML_ROLE_GROUP_CLOSE_PLUS,
+  XML_ROLE_GROUP_CHOICE,
+  XML_ROLE_GROUP_SEQUENCE,
+  XML_ROLE_CONTENT_ELEMENT,
+  XML_ROLE_CONTENT_ELEMENT_REP,
+  XML_ROLE_CONTENT_ELEMENT_OPT,
+  XML_ROLE_CONTENT_ELEMENT_PLUS,
+#ifdef XML_DTD
+  XML_ROLE_TEXT_DECL,
+  XML_ROLE_IGNORE_SECT,
+  XML_ROLE_INNER_PARAM_ENTITY_REF,
+#endif /* XML_DTD */
+  XML_ROLE_PARAM_ENTITY_REF
+};
+
+typedef struct prolog_state {
+  int (*handler)(struct prolog_state *state,
+	         int tok,
+		 const char *ptr,
+		 const char *end,
+		 const ENCODING *enc);
+  unsigned level;
+#ifdef XML_DTD
+  unsigned includeLevel;
+  int documentEntity;
+#endif /* XML_DTD */
+} PROLOG_STATE;
+
+void XmlPrologStateInit(PROLOG_STATE *);
+#ifdef XML_DTD
+void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
+#endif /* XML_DTD */
+
+#define XmlTokenRole(state, tok, ptr, end, enc) \
+ (((state)->handler)(state, tok, ptr, end, enc))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlRole_INCLUDED */
Index: xc/extras/expat/lib/xmltok.c
diff -u /dev/null xc/extras/expat/lib/xmltok.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmltok.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,1566 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#ifdef COMPILED_FROM_DSP
+#  include "winconfig.h"
+#else
+#  include <config.h>
+#endif /* ndef COMPILED_FROM_DSP */
+
+#include "xmltok.h"
+#include "nametab.h"
+
+#ifdef XML_DTD
+#define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok)
+#else
+#define IGNORE_SECTION_TOK_VTABLE /* as nothing */
+#endif
+
+#define VTABLE1 \
+  { PREFIX(prologTok), PREFIX(contentTok), \
+    PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE }, \
+  { PREFIX(attributeValueTok), PREFIX(entityValueTok) }, \
+  PREFIX(sameName), \
+  PREFIX(nameMatchesAscii), \
+  PREFIX(nameLength), \
+  PREFIX(skipS), \
+  PREFIX(getAtts), \
+  PREFIX(charRefNumber), \
+  PREFIX(predefinedEntityName), \
+  PREFIX(updatePosition), \
+  PREFIX(isPublicId)
+
+#define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
+
+#define UCS2_GET_NAMING(pages, hi, lo) \
+   (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1 << ((lo) & 0x1F)))
+
+/* A 2 byte UTF-8 representation splits the characters 11 bits
+between the bottom 5 and 6 bits of the bytes.
+We need 8 bits to index into pages, 3 bits to add to that index and
+5 bits to generate the mask. */
+#define UTF8_GET_NAMING2(pages, byte) \
+    (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \
+                      + ((((byte)[0]) & 3) << 1) \
+                      + ((((byte)[1]) >> 5) & 1)] \
+         & (1 << (((byte)[1]) & 0x1F)))
+
+/* A 3 byte UTF-8 representation splits the characters 16 bits
+between the bottom 4, 6 and 6 bits of the bytes.
+We need 8 bits to index into pages, 3 bits to add to that index and
+5 bits to generate the mask. */
+#define UTF8_GET_NAMING3(pages, byte) \
+  (namingBitmap[((pages)[((((byte)[0]) & 0xF) << 4) \
+                             + ((((byte)[1]) >> 2) & 0xF)] \
+		       << 3) \
+                      + ((((byte)[1]) & 3) << 1) \
+                      + ((((byte)[2]) >> 5) & 1)] \
+         & (1 << (((byte)[2]) & 0x1F)))
+
+#define UTF8_GET_NAMING(pages, p, n) \
+  ((n) == 2 \
+  ? UTF8_GET_NAMING2(pages, (const unsigned char *)(p)) \
+  : ((n) == 3 \
+     ? UTF8_GET_NAMING3(pages, (const unsigned char *)(p)) \
+     : 0))
+
+#define UTF8_INVALID3(p) \
+  ((*p) == 0xED \
+  ? (((p)[1] & 0x20) != 0) \
+  : ((*p) == 0xEF \
+     ? ((p)[1] == 0xBF && ((p)[2] == 0xBF || (p)[2] == 0xBE)) \
+     : 0))
+
+#define UTF8_INVALID4(p) ((*p) == 0xF4 && ((p)[1] & 0x30) != 0)
+
+static
+int isNever(const ENCODING *enc, const char *p)
+{
+  return 0;
+}
+
+static
+int utf8_isName2(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
+}
+
+static
+int utf8_isName3(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
+}
+
+#define utf8_isName4 isNever
+
+static
+int utf8_isNmstrt2(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
+}
+
+static
+int utf8_isNmstrt3(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
+}
+
+#define utf8_isNmstrt4 isNever
+
+#define utf8_isInvalid2 isNever
+
+static
+int utf8_isInvalid3(const ENCODING *enc, const char *p)
+{
+  return UTF8_INVALID3((const unsigned char *)p);
+}
+
+static
+int utf8_isInvalid4(const ENCODING *enc, const char *p)
+{
+  return UTF8_INVALID4((const unsigned char *)p);
+}
+
+struct normal_encoding {
+  ENCODING enc;
+  unsigned char type[256];
+#ifdef XML_MIN_SIZE
+  int (*byteType)(const ENCODING *, const char *);
+  int (*isNameMin)(const ENCODING *, const char *);
+  int (*isNmstrtMin)(const ENCODING *, const char *);
+  int (*byteToAscii)(const ENCODING *, const char *);
+  int (*charMatches)(const ENCODING *, const char *, int);
+#endif /* XML_MIN_SIZE */
+  int (*isName2)(const ENCODING *, const char *);
+  int (*isName3)(const ENCODING *, const char *);
+  int (*isName4)(const ENCODING *, const char *);
+  int (*isNmstrt2)(const ENCODING *, const char *);
+  int (*isNmstrt3)(const ENCODING *, const char *);
+  int (*isNmstrt4)(const ENCODING *, const char *);
+  int (*isInvalid2)(const ENCODING *, const char *);
+  int (*isInvalid3)(const ENCODING *, const char *);
+  int (*isInvalid4)(const ENCODING *, const char *);
+};
+
+#ifdef XML_MIN_SIZE
+
+#define STANDARD_VTABLE(E) \
+ E ## byteType, \
+ E ## isNameMin, \
+ E ## isNmstrtMin, \
+ E ## byteToAscii, \
+ E ## charMatches,
+
+#else
+
+#define STANDARD_VTABLE(E) /* as nothing */
+
+#endif
+
+#define NORMAL_VTABLE(E) \
+ E ## isName2, \
+ E ## isName3, \
+ E ## isName4, \
+ E ## isNmstrt2, \
+ E ## isNmstrt3, \
+ E ## isNmstrt4, \
+ E ## isInvalid2, \
+ E ## isInvalid3, \
+ E ## isInvalid4
+
+static int checkCharRefNumber(int);
+
+#include "xmltok_impl.h"
+#include "ascii.h"
+
+#ifdef XML_MIN_SIZE
+#define sb_isNameMin isNever
+#define sb_isNmstrtMin isNever
+#endif
+
+#ifdef XML_MIN_SIZE
+#define MINBPC(enc) ((enc)->minBytesPerChar)
+#else
+/* minimum bytes per character */
+#define MINBPC(enc) 1
+#endif
+
+#define SB_BYTE_TYPE(enc, p) \
+  (((struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
+
+#ifdef XML_MIN_SIZE
+static
+int sb_byteType(const ENCODING *enc, const char *p)
+{
+  return SB_BYTE_TYPE(enc, p);
+}
+#define BYTE_TYPE(enc, p) \
+ (((const struct normal_encoding *)(enc))->byteType(enc, p))
+#else
+#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
+#endif
+
+#ifdef XML_MIN_SIZE
+#define BYTE_TO_ASCII(enc, p) \
+ (((const struct normal_encoding *)(enc))->byteToAscii(enc, p))
+static
+int sb_byteToAscii(const ENCODING *enc, const char *p)
+{
+  return *p;
+}
+#else
+#define BYTE_TO_ASCII(enc, p) (*(p))
+#endif
+
+#define IS_NAME_CHAR(enc, p, n) \
+ (((const struct normal_encoding *)(enc))->isName ## n(enc, p))
+#define IS_NMSTRT_CHAR(enc, p, n) \
+ (((const struct normal_encoding *)(enc))->isNmstrt ## n(enc, p))
+#define IS_INVALID_CHAR(enc, p, n) \
+ (((const struct normal_encoding *)(enc))->isInvalid ## n(enc, p))
+
+#ifdef XML_MIN_SIZE
+#define IS_NAME_CHAR_MINBPC(enc, p) \
+ (((const struct normal_encoding *)(enc))->isNameMin(enc, p))
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) \
+ (((const struct normal_encoding *)(enc))->isNmstrtMin(enc, p))
+#else
+#define IS_NAME_CHAR_MINBPC(enc, p) (0)
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
+#endif
+
+#ifdef XML_MIN_SIZE
+#define CHAR_MATCHES(enc, p, c) \
+ (((const struct normal_encoding *)(enc))->charMatches(enc, p, c))
+static
+int sb_charMatches(const ENCODING *enc, const char *p, int c)
+{
+  return *p == c;
+}
+#else
+/* c is an ASCII character */
+#define CHAR_MATCHES(enc, p, c) (*(p) == c)
+#endif
+
+#define PREFIX(ident) normal_ ## ident
+#include "xmltok_impl.c"
+
+#undef MINBPC
+#undef BYTE_TYPE
+#undef BYTE_TO_ASCII
+#undef CHAR_MATCHES
+#undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
+#undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
+#undef IS_INVALID_CHAR
+
+enum {  /* UTF8_cvalN is value of masked first byte of N byte sequence */
+  UTF8_cval1 = 0x00,
+  UTF8_cval2 = 0xc0,
+  UTF8_cval3 = 0xe0,
+  UTF8_cval4 = 0xf0
+};
+
+static
+void utf8_toUtf8(const ENCODING *enc,
+		 const char **fromP, const char *fromLim,
+		 char **toP, const char *toLim)
+{
+  char *to;
+  const char *from;
+  if (fromLim - *fromP > toLim - *toP) {
+    /* Avoid copying partial characters. */
+    for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
+      if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
+	break;
+  }
+  for (to = *toP, from = *fromP; from != fromLim; from++, to++)
+    *to = *from;
+  *fromP = from;
+  *toP = to;
+}
+
+static
+void utf8_toUtf16(const ENCODING *enc,
+		  const char **fromP, const char *fromLim,
+		  unsigned short **toP, const unsigned short *toLim)
+{
+  unsigned short *to = *toP;
+  const char *from = *fromP;
+  while (from != fromLim && to != toLim) {
+    switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
+    case BT_LEAD2:
+      *to++ = ((from[0] & 0x1f) << 6) | (from[1] & 0x3f);
+      from += 2;
+      break;
+    case BT_LEAD3:
+      *to++ = ((from[0] & 0xf) << 12) | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f);
+      from += 3;
+      break;
+    case BT_LEAD4:
+      {
+	unsigned long n;
+	if (to + 1 == toLim)
+	  break;
+	n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12) | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
+	n -= 0x10000;
+	to[0] = (unsigned short)((n >> 10) | 0xD800);
+	to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
+	to += 2;
+	from += 4;
+      }
+      break;
+    default:
+      *to++ = *from++;
+      break;
+    }
+  }
+  *fromP = from;
+  *toP = to;
+}
+
+#ifdef XML_NS
+static const struct normal_encoding utf8_encoding_ns = {
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
+  {
+#include "asciitab.h"
+#include "utf8tab.h"
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
+};
+#endif
+
+static const struct normal_encoding utf8_encoding = {
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "utf8tab.h"
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
+};
+
+#ifdef XML_NS
+
+static const struct normal_encoding internal_utf8_encoding_ns = {
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
+  {
+#include "iasciitab.h"
+#include "utf8tab.h"
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
+};
+
+#endif
+
+static const struct normal_encoding internal_utf8_encoding = {
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "utf8tab.h"
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
+};
+
+static
+void latin1_toUtf8(const ENCODING *enc,
+		   const char **fromP, const char *fromLim,
+		   char **toP, const char *toLim)
+{
+  for (;;) {
+    unsigned char c;
+    if (*fromP == fromLim)
+      break;
+    c = (unsigned char)**fromP;
+    if (c & 0x80) {
+      if (toLim - *toP < 2)
+	break;
+      *(*toP)++ = ((c >> 6) | UTF8_cval2);
+      *(*toP)++ = ((c & 0x3f) | 0x80);
+      (*fromP)++;
+    }
+    else {
+      if (*toP == toLim)
+	break;
+      *(*toP)++ = *(*fromP)++;
+    }
+  }
+}
+
+static
+void latin1_toUtf16(const ENCODING *enc,
+		    const char **fromP, const char *fromLim,
+		    unsigned short **toP, const unsigned short *toLim)
+{
+  while (*fromP != fromLim && *toP != toLim)
+    *(*toP)++ = (unsigned char)*(*fromP)++;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding latin1_encoding_ns = {
+  { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
+  {
+#include "asciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(sb_)
+};
+
+#endif
+
+static const struct normal_encoding latin1_encoding = {
+  { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(sb_)
+};
+
+static
+void ascii_toUtf8(const ENCODING *enc,
+		  const char **fromP, const char *fromLim,
+		  char **toP, const char *toLim)
+{
+  while (*fromP != fromLim && *toP != toLim)
+    *(*toP)++ = *(*fromP)++;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding ascii_encoding_ns = {
+  { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
+  {
+#include "asciitab.h"
+/* BT_NONXML == 0 */
+  },
+  STANDARD_VTABLE(sb_)
+};
+
+#endif
+
+static const struct normal_encoding ascii_encoding = {
+  { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+/* BT_NONXML == 0 */
+  },
+  STANDARD_VTABLE(sb_)
+};
+
+static int unicode_byte_type(char hi, char lo)
+{
+  switch ((unsigned char)hi) {
+  case 0xD8: case 0xD9: case 0xDA: case 0xDB:
+    return BT_LEAD4;
+  case 0xDC: case 0xDD: case 0xDE: case 0xDF:
+    return BT_TRAIL;
+  case 0xFF:
+    switch ((unsigned char)lo) {
+    case 0xFF:
+    case 0xFE:
+      return BT_NONXML;
+    }
+    break;
+  }
+  return BT_NONASCII;
+}
+
+#define DEFINE_UTF16_TO_UTF8(E) \
+static \
+void E ## toUtf8(const ENCODING *enc, \
+		 const char **fromP, const char *fromLim, \
+		 char **toP, const char *toLim) \
+{ \
+  const char *from; \
+  for (from = *fromP; from != fromLim; from += 2) { \
+    int plane; \
+    unsigned char lo2; \
+    unsigned char lo = GET_LO(from); \
+    unsigned char hi = GET_HI(from); \
+    switch (hi) { \
+    case 0: \
+      if (lo < 0x80) { \
+        if (*toP == toLim) { \
+          *fromP = from; \
+	  return; \
+        } \
+        *(*toP)++ = lo; \
+        break; \
+      } \
+      /* fall through */ \
+    case 0x1: case 0x2: case 0x3: \
+    case 0x4: case 0x5: case 0x6: case 0x7: \
+      if (toLim -  *toP < 2) { \
+        *fromP = from; \
+	return; \
+      } \
+      *(*toP)++ = ((lo >> 6) | (hi << 2) |  UTF8_cval2); \
+      *(*toP)++ = ((lo & 0x3f) | 0x80); \
+      break; \
+    default: \
+      if (toLim -  *toP < 3)  { \
+        *fromP = from; \
+	return; \
+      } \
+      /* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
+      *(*toP)++ = ((hi >> 4) | UTF8_cval3); \
+      *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \
+      *(*toP)++ = ((lo & 0x3f) | 0x80); \
+      break; \
+    case 0xD8: case 0xD9: case 0xDA: case 0xDB: \
+      if (toLim -  *toP < 4) { \
+	*fromP = from; \
+	return; \
+      } \
+      plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
+      *(*toP)++ = ((plane >> 2) | UTF8_cval4); \
+      *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
+      from += 2; \
+      lo2 = GET_LO(from); \
+      *(*toP)++ = (((lo & 0x3) << 4) \
+	           | ((GET_HI(from) & 0x3) << 2) \
+		   | (lo2 >> 6) \
+		   | 0x80); \
+      *(*toP)++ = ((lo2 & 0x3f) | 0x80); \
+      break; \
+    } \
+  } \
+  *fromP = from; \
+}
+
+#define DEFINE_UTF16_TO_UTF16(E) \
+static \
+void E ## toUtf16(const ENCODING *enc, \
+		  const char **fromP, const char *fromLim, \
+		  unsigned short **toP, const unsigned short *toLim) \
+{ \
+  /* Avoid copying first half only of surrogate */ \
+  if (fromLim - *fromP > ((toLim - *toP) << 1) \
+      && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \
+    fromLim -= 2; \
+  for (; *fromP != fromLim && *toP != toLim; *fromP += 2) \
+    *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
+}
+
+#define SET2(ptr, ch) \
+  (((ptr)[0] = ((ch) & 0xff)), ((ptr)[1] = ((ch) >> 8)))
+#define GET_LO(ptr) ((unsigned char)(ptr)[0])
+#define GET_HI(ptr) ((unsigned char)(ptr)[1])
+
+DEFINE_UTF16_TO_UTF8(little2_)
+DEFINE_UTF16_TO_UTF16(little2_)
+
+#undef SET2
+#undef GET_LO
+#undef GET_HI
+
+#define SET2(ptr, ch) \
+  (((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch) & 0xFF)))
+#define GET_LO(ptr) ((unsigned char)(ptr)[1])
+#define GET_HI(ptr) ((unsigned char)(ptr)[0])
+
+DEFINE_UTF16_TO_UTF8(big2_)
+DEFINE_UTF16_TO_UTF16(big2_)
+
+#undef SET2
+#undef GET_LO
+#undef GET_HI
+
+#define LITTLE2_BYTE_TYPE(enc, p) \
+ ((p)[1] == 0 \
+  ? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)] \
+  : unicode_byte_type((p)[1], (p)[0]))
+#define LITTLE2_BYTE_TO_ASCII(enc, p) ((p)[1] == 0 ? (p)[0] : -1)
+#define LITTLE2_CHAR_MATCHES(enc, p, c) ((p)[1] == 0 && (p)[0] == c)
+#define LITTLE2_IS_NAME_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
+#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
+
+#ifdef XML_MIN_SIZE
+
+static
+int little2_byteType(const ENCODING *enc, const char *p)
+{
+  return LITTLE2_BYTE_TYPE(enc, p);
+}
+
+static
+int little2_byteToAscii(const ENCODING *enc, const char *p)
+{
+  return LITTLE2_BYTE_TO_ASCII(enc, p);
+}
+
+static
+int little2_charMatches(const ENCODING *enc, const char *p, int c)
+{
+  return LITTLE2_CHAR_MATCHES(enc, p, c);
+}
+
+static
+int little2_isNameMin(const ENCODING *enc, const char *p)
+{
+  return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p);
+}
+
+static
+int little2_isNmstrtMin(const ENCODING *enc, const char *p)
+{
+  return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p);
+}
+
+#undef VTABLE
+#define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
+
+#else /* not XML_MIN_SIZE */
+
+#undef PREFIX
+#define PREFIX(ident) little2_ ## ident
+#define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
+#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p) 
+#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
+#define IS_NAME_CHAR(enc, p, n) 0
+#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
+#define IS_NMSTRT_CHAR(enc, p, n) (0)
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
+
+#include "xmltok_impl.c"
+
+#undef MINBPC
+#undef BYTE_TYPE
+#undef BYTE_TO_ASCII
+#undef CHAR_MATCHES
+#undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
+#undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
+#undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding little2_encoding_ns = { 
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 12
+    1
+#else
+    0
+#endif
+  },
+  {
+#include "asciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#endif
+
+static const struct normal_encoding little2_encoding = { 
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 12
+    1
+#else
+    0
+#endif
+  },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#if XML_BYTE_ORDER != 21
+
+#ifdef XML_NS
+
+static const struct normal_encoding internal_little2_encoding_ns = { 
+  { VTABLE, 2, 0, 1 },
+  {
+#include "iasciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#endif
+
+static const struct normal_encoding internal_little2_encoding = { 
+  { VTABLE, 2, 0, 1 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#endif
+
+
+#define BIG2_BYTE_TYPE(enc, p) \
+ ((p)[0] == 0 \
+  ? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]] \
+  : unicode_byte_type((p)[0], (p)[1]))
+#define BIG2_BYTE_TO_ASCII(enc, p) ((p)[0] == 0 ? (p)[1] : -1)
+#define BIG2_CHAR_MATCHES(enc, p, c) ((p)[0] == 0 && (p)[1] == c)
+#define BIG2_IS_NAME_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
+#define BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
+
+#ifdef XML_MIN_SIZE
+
+static
+int big2_byteType(const ENCODING *enc, const char *p)
+{
+  return BIG2_BYTE_TYPE(enc, p);
+}
+
+static
+int big2_byteToAscii(const ENCODING *enc, const char *p)
+{
+  return BIG2_BYTE_TO_ASCII(enc, p);
+}
+
+static
+int big2_charMatches(const ENCODING *enc, const char *p, int c)
+{
+  return BIG2_CHAR_MATCHES(enc, p, c);
+}
+
+static
+int big2_isNameMin(const ENCODING *enc, const char *p)
+{
+  return BIG2_IS_NAME_CHAR_MINBPC(enc, p);
+}
+
+static
+int big2_isNmstrtMin(const ENCODING *enc, const char *p)
+{
+  return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p);
+}
+
+#undef VTABLE
+#define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
+
+#else /* not XML_MIN_SIZE */
+
+#undef PREFIX
+#define PREFIX(ident) big2_ ## ident
+#define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
+#define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p) 
+#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
+#define IS_NAME_CHAR(enc, p, n) 0
+#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
+#define IS_NMSTRT_CHAR(enc, p, n) (0)
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
+
+#include "xmltok_impl.c"
+
+#undef MINBPC
+#undef BYTE_TYPE
+#undef BYTE_TO_ASCII
+#undef CHAR_MATCHES
+#undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
+#undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
+#undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding big2_encoding_ns = {
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 21
+  1
+#else
+  0
+#endif
+  },
+  {
+#include "asciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#endif
+
+static const struct normal_encoding big2_encoding = {
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 21
+  1
+#else
+  0
+#endif
+  },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#if XML_BYTE_ORDER != 12
+
+#ifdef XML_NS
+
+static const struct normal_encoding internal_big2_encoding_ns = {
+  { VTABLE, 2, 0, 1 },
+  {
+#include "iasciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#endif
+
+static const struct normal_encoding internal_big2_encoding = {
+  { VTABLE, 2, 0, 1 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#endif
+
+#undef PREFIX
+
+static
+int streqci(const char *s1, const char *s2)
+{
+  for (;;) {
+    char c1 = *s1++;
+    char c2 = *s2++;
+    if (ASCII_a <= c1 && c1 <= ASCII_z)
+      c1 += ASCII_A - ASCII_a;
+    if (ASCII_a <= c2 && c2 <= ASCII_z)
+      c2 += ASCII_A - ASCII_a;
+    if (c1 != c2)
+      return 0;
+    if (!c1)
+      break;
+  }
+  return 1;
+}
+
+static
+void initUpdatePosition(const ENCODING *enc, const char *ptr,
+			const char *end, POSITION *pos)
+{
+  normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
+}
+
+static
+int toAscii(const ENCODING *enc, const char *ptr, const char *end)
+{
+  char buf[1];
+  char *p = buf;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
+  if (p == buf)
+    return -1;
+  else
+    return buf[0];
+}
+
+static
+int isSpace(int c)
+{
+  switch (c) {
+  case 0x20:
+  case 0xD:
+  case 0xA:
+  case 0x9:	
+    return 1;
+  }
+  return 0;
+}
+
+/* Return 1 if there's just optional white space
+or there's an S followed by name=val. */
+static
+int parsePseudoAttribute(const ENCODING *enc,
+			 const char *ptr,
+			 const char *end,
+			 const char **namePtr,
+			 const char **nameEndPtr,
+			 const char **valPtr,
+			 const char **nextTokPtr)
+{
+  int c;
+  char open;
+  if (ptr == end) {
+    *namePtr = 0;
+    return 1;
+  }
+  if (!isSpace(toAscii(enc, ptr, end))) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  do {
+    ptr += enc->minBytesPerChar;
+  } while (isSpace(toAscii(enc, ptr, end)));
+  if (ptr == end) {
+    *namePtr = 0;
+    return 1;
+  }
+  *namePtr = ptr;
+  for (;;) {
+    c = toAscii(enc, ptr, end);
+    if (c == -1) {
+      *nextTokPtr = ptr;
+      return 0;
+    }
+    if (c == ASCII_EQUALS) {
+      *nameEndPtr = ptr;
+      break;
+    }
+    if (isSpace(c)) {
+      *nameEndPtr = ptr;
+      do {
+	ptr += enc->minBytesPerChar;
+      } while (isSpace(c = toAscii(enc, ptr, end)));
+      if (c != ASCII_EQUALS) {
+	*nextTokPtr = ptr;
+	return 0;
+      }
+      break;
+    }
+    ptr += enc->minBytesPerChar;
+  }
+  if (ptr == *namePtr) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  ptr += enc->minBytesPerChar;
+  c = toAscii(enc, ptr, end);
+  while (isSpace(c)) {
+    ptr += enc->minBytesPerChar;
+    c = toAscii(enc, ptr, end);
+  }
+  if (c != ASCII_QUOT && c != ASCII_APOS) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  open = c;
+  ptr += enc->minBytesPerChar;
+  *valPtr = ptr;
+  for (;; ptr += enc->minBytesPerChar) {
+    c = toAscii(enc, ptr, end);
+    if (c == open)
+      break;
+    if (!(ASCII_a <= c && c <= ASCII_z)
+	&& !(ASCII_A <= c && c <= ASCII_Z)
+	&& !(ASCII_0 <= c && c <= ASCII_9)
+	&& c != ASCII_PERIOD
+	&& c != ASCII_MINUS
+	&& c != ASCII_UNDERSCORE) {
+      *nextTokPtr = ptr;
+      return 0;
+    }
+  }
+  *nextTokPtr = ptr + enc->minBytesPerChar;
+  return 1;
+}
+
+static const char KW_version[] = {
+  ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0'
+};
+
+static const char KW_encoding[] = {
+  ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d, ASCII_i, ASCII_n, ASCII_g, '\0'
+};
+
+static const char KW_standalone[] = {
+  ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a, ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\0'
+};
+
+static const char KW_yes[] = {
+  ASCII_y, ASCII_e, ASCII_s,  '\0'
+};
+
+static const char KW_no[] = {
+  ASCII_n, ASCII_o,  '\0'
+};
+
+static
+int doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
+		                                     const char *,
+						     const char *),
+		   int isGeneralTextEntity,
+		   const ENCODING *enc,
+		   const char *ptr,
+		   const char *end,
+		   const char **badPtr,
+		   const char **versionPtr,
+		   const char **versionEndPtr,
+		   const char **encodingName,
+		   const ENCODING **encoding,
+		   int *standalone)
+{
+  const char *val = 0;
+  const char *name = 0;
+  const char *nameEnd = 0;
+  ptr += 5 * enc->minBytesPerChar;
+  end -= 2 * enc->minBytesPerChar;
+  if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr) || !name) {
+    *badPtr = ptr;
+    return 0;
+  }
+  if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
+    if (!isGeneralTextEntity) {
+      *badPtr = name;
+      return 0;
+    }
+  }
+  else {
+    if (versionPtr)
+      *versionPtr = val;
+    if (versionEndPtr)
+      *versionEndPtr = ptr;
+    if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+      *badPtr = ptr;
+      return 0;
+    }
+    if (!name) {
+      if (isGeneralTextEntity) {
+	/* a TextDecl must have an EncodingDecl */
+	*badPtr = ptr;
+	return 0;
+      }
+      return 1;
+    }
+  }
+  if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
+    int c = toAscii(enc, val, end);
+    if (!(ASCII_a <= c && c <= ASCII_z) && !(ASCII_A <= c && c <= ASCII_Z)) {
+      *badPtr = val;
+      return 0;
+    }
+    if (encodingName)
+      *encodingName = val;
+    if (encoding)
+      *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
+    if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+      *badPtr = ptr;
+      return 0;
+    }
+    if (!name)
+      return 1;
+  }
+  if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone) || isGeneralTextEntity) {
+    *badPtr = name;
+    return 0;
+  }
+  if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
+    if (standalone)
+      *standalone = 1;
+  }
+  else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
+    if (standalone)
+      *standalone = 0;
+  }
+  else {
+    *badPtr = val;
+    return 0;
+  }
+  while (isSpace(toAscii(enc, ptr, end)))
+    ptr += enc->minBytesPerChar;
+  if (ptr != end) {
+    *badPtr = ptr;
+    return 0;
+  }
+  return 1;
+}
+
+static
+int checkCharRefNumber(int result)
+{
+  switch (result >> 8) {
+  case 0xD8: case 0xD9: case 0xDA: case 0xDB:
+  case 0xDC: case 0xDD: case 0xDE: case 0xDF:
+    return -1;
+  case 0:
+    if (latin1_encoding.type[result] == BT_NONXML)
+      return -1;
+    break;
+  case 0xFF:
+    if (result == 0xFFFE || result == 0xFFFF)
+      return -1;
+    break;
+  }
+  return result;
+}
+
+int XmlUtf8Encode(int c, char *buf)
+{
+  enum {
+    /* minN is minimum legal resulting value for N byte sequence */
+    min2 = 0x80,
+    min3 = 0x800,
+    min4 = 0x10000
+  };
+
+  if (c < 0)
+    return 0;
+  if (c < min2) {
+    buf[0] = (c | UTF8_cval1);
+    return 1;
+  }
+  if (c < min3) {
+    buf[0] = ((c >> 6) | UTF8_cval2);
+    buf[1] = ((c & 0x3f) | 0x80);
+    return 2;
+  }
+  if (c < min4) {
+    buf[0] = ((c >> 12) | UTF8_cval3);
+    buf[1] = (((c >> 6) & 0x3f) | 0x80);
+    buf[2] = ((c & 0x3f) | 0x80);
+    return 3;
+  }
+  if (c < 0x110000) {
+    buf[0] = ((c >> 18) | UTF8_cval4);
+    buf[1] = (((c >> 12) & 0x3f) | 0x80);
+    buf[2] = (((c >> 6) & 0x3f) | 0x80);
+    buf[3] = ((c & 0x3f) | 0x80);
+    return 4;
+  }
+  return 0;
+}
+
+int XmlUtf16Encode(int charNum, unsigned short *buf)
+{
+  if (charNum < 0)
+    return 0;
+  if (charNum < 0x10000) {
+    buf[0] = charNum;
+    return 1;
+  }
+  if (charNum < 0x110000) {
+    charNum -= 0x10000;
+    buf[0] = (charNum >> 10) + 0xD800;
+    buf[1] = (charNum & 0x3FF) + 0xDC00;
+    return 2;
+  }
+  return 0;
+}
+
+struct unknown_encoding {
+  struct normal_encoding normal;
+  int (*convert)(void *userData, const char *p);
+  void *userData;
+  unsigned short utf16[256];
+  char utf8[256][4];
+};
+
+int XmlSizeOfUnknownEncoding(void)
+{
+  return sizeof(struct unknown_encoding);
+}
+
+static
+int unknown_isName(const ENCODING *enc, const char *p)
+{
+  int c = ((const struct unknown_encoding *)enc)
+	  ->convert(((const struct unknown_encoding *)enc)->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
+}
+
+static
+int unknown_isNmstrt(const ENCODING *enc, const char *p)
+{
+  int c = ((const struct unknown_encoding *)enc)
+	  ->convert(((const struct unknown_encoding *)enc)->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
+}
+
+static
+int unknown_isInvalid(const ENCODING *enc, const char *p)
+{
+  int c = ((const struct unknown_encoding *)enc)
+	   ->convert(((const struct unknown_encoding *)enc)->userData, p);
+  return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
+}
+
+static
+void unknown_toUtf8(const ENCODING *enc,
+		    const char **fromP, const char *fromLim,
+		    char **toP, const char *toLim)
+{
+  char buf[XML_UTF8_ENCODE_MAX];
+  for (;;) {
+    const char *utf8;
+    int n;
+    if (*fromP == fromLim)
+      break;
+    utf8 = ((const struct unknown_encoding *)enc)->utf8[(unsigned char)**fromP];
+    n = *utf8++;
+    if (n == 0) {
+      int c = ((const struct unknown_encoding *)enc)
+	      ->convert(((const struct unknown_encoding *)enc)->userData, *fromP);
+      n = XmlUtf8Encode(c, buf);
+      if (n > toLim - *toP)
+	break;
+      utf8 = buf;
+      *fromP += ((const struct normal_encoding *)enc)->type[(unsigned char)**fromP]
+	         - (BT_LEAD2 - 2);
+    }
+    else {
+      if (n > toLim - *toP)
+	break;
+      (*fromP)++;
+    }
+    do {
+      *(*toP)++ = *utf8++;
+    } while (--n != 0);
+  }
+}
+
+static
+void unknown_toUtf16(const ENCODING *enc,
+		     const char **fromP, const char *fromLim,
+		     unsigned short **toP, const unsigned short *toLim)
+{
+  while (*fromP != fromLim && *toP != toLim) {
+    unsigned short c
+      = ((const struct unknown_encoding *)enc)->utf16[(unsigned char)**fromP];
+    if (c == 0) {
+      c = (unsigned short)((const struct unknown_encoding *)enc)
+	   ->convert(((const struct unknown_encoding *)enc)->userData, *fromP);
+      *fromP += ((const struct normal_encoding *)enc)->type[(unsigned char)**fromP]
+	         - (BT_LEAD2 - 2);
+    }
+    else
+      (*fromP)++;
+    *(*toP)++ = c;
+  }
+}
+
+ENCODING *
+XmlInitUnknownEncoding(void *mem,
+		       int *table,
+		       int (*convert)(void *userData, const char *p),
+		       void *userData)
+{
+  int i;
+  struct unknown_encoding *e = mem;
+  for (i = 0; i < (int)sizeof(struct normal_encoding); i++)
+    ((char *)mem)[i] = ((char *)&latin1_encoding)[i];
+  for (i = 0; i < 128; i++)
+    if (latin1_encoding.type[i] != BT_OTHER
+        && latin1_encoding.type[i] != BT_NONXML
+	&& table[i] != i)
+      return 0;
+  for (i = 0; i < 256; i++) {
+    int c = table[i];
+    if (c == -1) {
+      e->normal.type[i] = BT_MALFORM;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    }
+    else if (c < 0) {
+      if (c < -4)
+	return 0;
+      e->normal.type[i] = BT_LEAD2 - (c + 2);
+      e->utf8[i][0] = 0;
+      e->utf16[i] = 0;
+    }
+    else if (c < 0x80) {
+      if (latin1_encoding.type[c] != BT_OTHER
+	  && latin1_encoding.type[c] != BT_NONXML
+	  && c != i)
+	return 0;
+      e->normal.type[i] = latin1_encoding.type[c];
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = (char)c;
+      e->utf16[i] = c == 0 ? 0xFFFF : c;
+    }
+    else if (checkCharRefNumber(c) < 0) {
+      e->normal.type[i] = BT_NONXML;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    }
+    else {
+      if (c > 0xFFFF)
+	return 0;
+      if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff))
+	e->normal.type[i] = BT_NMSTRT;
+      else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
+	e->normal.type[i] = BT_NAME;
+      else
+	e->normal.type[i] = BT_OTHER;
+      e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
+      e->utf16[i] = c;
+    }
+  }
+  e->userData = userData;
+  e->convert = convert;
+  if (convert) {
+    e->normal.isName2 = unknown_isName;
+    e->normal.isName3 = unknown_isName;
+    e->normal.isName4 = unknown_isName;
+    e->normal.isNmstrt2 = unknown_isNmstrt;
+    e->normal.isNmstrt3 = unknown_isNmstrt;
+    e->normal.isNmstrt4 = unknown_isNmstrt;
+    e->normal.isInvalid2 = unknown_isInvalid;
+    e->normal.isInvalid3 = unknown_isInvalid;
+    e->normal.isInvalid4 = unknown_isInvalid;
+  }
+  e->normal.enc.utf8Convert = unknown_toUtf8;
+  e->normal.enc.utf16Convert = unknown_toUtf16;
+  return &(e->normal.enc);
+}
+
+/* If this enumeration is changed, getEncodingIndex and encodings
+must also be changed. */
+enum {
+  UNKNOWN_ENC = -1,
+  ISO_8859_1_ENC = 0,
+  US_ASCII_ENC,
+  UTF_8_ENC,
+  UTF_16_ENC,
+  UTF_16BE_ENC,
+  UTF_16LE_ENC,
+  /* must match encodingNames up to here */
+  NO_ENC
+};
+
+static const char KW_ISO_8859_1[] = {
+  ASCII_I, ASCII_S, ASCII_O, ASCII_MINUS, ASCII_8, ASCII_8, ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1, '\0'
+};
+static const char KW_US_ASCII[] = {
+  ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S, ASCII_C, ASCII_I, ASCII_I, '\0'
+};
+static const char KW_UTF_8[] =	{
+  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'
+};
+static const char KW_UTF_16[] =	{
+  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'
+};
+static const char KW_UTF_16BE[] = {
+  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_B, ASCII_E, '\0'
+};
+static const char KW_UTF_16LE[] = {
+  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_L, ASCII_E, '\0'
+};
+
+static
+int getEncodingIndex(const char *name)
+{
+  static const char *encodingNames[] = {
+    KW_ISO_8859_1,
+    KW_US_ASCII,
+    KW_UTF_8,
+    KW_UTF_16,
+    KW_UTF_16BE,
+    KW_UTF_16LE,
+  };
+  int i;
+  if (name == 0)
+    return NO_ENC;
+  for (i = 0; i < (int)(sizeof(encodingNames)/sizeof(encodingNames[0])); i++)
+    if (streqci(name, encodingNames[i]))
+      return i;
+  return UNKNOWN_ENC;
+}
+
+/* For binary compatibility, we store the index of the encoding specified
+at initialization in the isUtf16 member. */
+
+#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
+#define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
+
+/* This is what detects the encoding.
+encodingTable maps from encoding indices to encodings;
+INIT_ENC_INDEX(enc) is the index of the external (protocol) specified encoding;
+state is XML_CONTENT_STATE if we're parsing an external text entity,
+and XML_PROLOG_STATE otherwise.
+*/
+
+
+static
+int initScan(const ENCODING **encodingTable,
+	     const INIT_ENCODING *enc,
+	     int state,
+	     const char *ptr,
+	     const char *end,
+	     const char **nextTokPtr)
+{
+  const ENCODING **encPtr;
+
+  if (ptr == end)
+    return XML_TOK_NONE;
+  encPtr = enc->encPtr;
+  if (ptr + 1 == end) {
+    /* only a single byte available for auto-detection */
+#ifndef XML_DTD /* FIXME */
+    /* a well-formed document entity must have more than one byte */
+    if (state != XML_CONTENT_STATE)
+      return XML_TOK_PARTIAL;
+#endif
+    /* so we're parsing an external text entity... */
+    /* if UTF-16 was externally specified, then we need at least 2 bytes */
+    switch (INIT_ENC_INDEX(enc)) {
+    case UTF_16_ENC:
+    case UTF_16LE_ENC:
+    case UTF_16BE_ENC:
+      return XML_TOK_PARTIAL;
+    }
+    switch ((unsigned char)*ptr) {
+    case 0xFE:
+    case 0xFF:
+    case 0xEF: /* possibly first byte of UTF-8 BOM */
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
+	  && state == XML_CONTENT_STATE)
+	break;
+      /* fall through */
+    case 0x00:
+    case 0x3C:
+      return XML_TOK_PARTIAL;
+    }
+  }
+  else {
+    switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
+    case 0xFEFF:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
+	  && state == XML_CONTENT_STATE)
+	break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16BE_ENC];
+      return XML_TOK_BOM;
+    /* 00 3C is handled in the default case */
+    case 0x3C00:
+      if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
+	   || INIT_ENC_INDEX(enc) == UTF_16_ENC)
+	  && state == XML_CONTENT_STATE)
+	break;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+    case 0xFFFE:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
+	  && state == XML_CONTENT_STATE)
+	break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XML_TOK_BOM;
+    case 0xEFBB:
+      /* Maybe a UTF-8 BOM (EF BB BF) */
+      /* If there's an explicitly specified (external) encoding
+         of ISO-8859-1 or some flavour of UTF-16
+         and this is an external text entity,
+	 don't look for the BOM,
+         because it might be a legal data. */
+      if (state == XML_CONTENT_STATE) {
+	int e = INIT_ENC_INDEX(enc);
+	if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC || e == UTF_16_ENC)
+	  break;
+      }
+      if (ptr + 2 == end)
+	return XML_TOK_PARTIAL;
+      if ((unsigned char)ptr[2] == 0xBF) {
+	*nextTokPtr = ptr + 3;
+	*encPtr = encodingTable[UTF_8_ENC];
+	return XML_TOK_BOM;
+      }
+      break;
+    default:
+      if (ptr[0] == '\0') {
+	/* 0 isn't a legal data character. Furthermore a document entity can only
+	   start with ASCII characters.  So the only way this can fail to be big-endian
+	   UTF-16 if it it's an external parsed general entity that's labelled as
+	   UTF-16LE. */
+	if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
+	  break;
+	*encPtr = encodingTable[UTF_16BE_ENC];
+	return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      }
+      else if (ptr[1] == '\0') {
+	/* We could recover here in the case:
+	    - parsing an external entity
+	    - second byte is 0
+	    - no externally specified encoding
+	    - no encoding declaration
+	   by assuming UTF-16LE.  But we don't, because this would mean when
+	   presented just with a single byte, we couldn't reliably determine
+	   whether we needed further bytes. */
+	if (state == XML_CONTENT_STATE)
+	  break;
+	*encPtr = encodingTable[UTF_16LE_ENC];
+	return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      }
+      break;
+    }
+  }
+  *encPtr = encodingTable[INIT_ENC_INDEX(enc)];
+  return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+}
+
+
+#define NS(x) x
+#define ns(x) x
+#include "xmltok_ns.c"
+#undef NS
+#undef ns
+
+#ifdef XML_NS
+
+#define NS(x) x ## NS
+#define ns(x) x ## _ns
+
+#include "xmltok_ns.c"
+
+#undef NS
+#undef ns
+
+ENCODING *
+XmlInitUnknownEncodingNS(void *mem,
+		         int *table,
+		         int (*convert)(void *userData, const char *p),
+		         void *userData)
+{
+  ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
+  if (enc)
+    ((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
+  return enc;
+}
+
+#endif /* XML_NS */
Index: xc/extras/expat/lib/xmltok.h
diff -u /dev/null xc/extras/expat/lib/xmltok.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmltok.h	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,299 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#ifndef XmlTok_INCLUDED
+#define XmlTok_INCLUDED 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The following token may be returned by XmlContentTok */
+#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be start of
+                                    illegal ]]> sequence */
+/* The following tokens may be returned by both XmlPrologTok and XmlContentTok */
+#define XML_TOK_NONE -4    /* The string to be scanned is empty */
+#define XML_TOK_TRAILING_CR -3 /* A CR at the end of the scan;
+                                  might be part of CRLF sequence */ 
+#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
+#define XML_TOK_PARTIAL -1 /* only part of a token */
+#define XML_TOK_INVALID 0
+
+/* The following tokens are returned by XmlContentTok; some are also
+  returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok */
+
+#define XML_TOK_START_TAG_WITH_ATTS 1
+#define XML_TOK_START_TAG_NO_ATTS 2
+#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
+#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
+#define XML_TOK_END_TAG 5
+#define XML_TOK_DATA_CHARS 6
+#define XML_TOK_DATA_NEWLINE 7
+#define XML_TOK_CDATA_SECT_OPEN 8
+#define XML_TOK_ENTITY_REF 9
+#define XML_TOK_CHAR_REF 10     /* numeric character reference */
+
+/* The following tokens may be returned by both XmlPrologTok and XmlContentTok */
+#define XML_TOK_PI 11      /* processing instruction */
+#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
+#define XML_TOK_COMMENT 13
+#define XML_TOK_BOM 14     /* Byte order mark */
+
+/* The following tokens are returned only by XmlPrologTok */
+#define XML_TOK_PROLOG_S 15
+#define XML_TOK_DECL_OPEN 16 /* <!foo */
+#define XML_TOK_DECL_CLOSE 17 /* > */
+#define XML_TOK_NAME 18
+#define XML_TOK_NMTOKEN 19
+#define XML_TOK_POUND_NAME 20 /* #name */
+#define XML_TOK_OR 21 /* | */
+#define XML_TOK_PERCENT 22
+#define XML_TOK_OPEN_PAREN 23
+#define XML_TOK_CLOSE_PAREN 24
+#define XML_TOK_OPEN_BRACKET 25
+#define XML_TOK_CLOSE_BRACKET 26
+#define XML_TOK_LITERAL 27
+#define XML_TOK_PARAM_ENTITY_REF 28
+#define XML_TOK_INSTANCE_START 29
+
+/* The following occur only in element type declarations */
+#define XML_TOK_NAME_QUESTION 30 /* name? */
+#define XML_TOK_NAME_ASTERISK 31 /* name* */
+#define XML_TOK_NAME_PLUS 32 /* name+ */
+#define XML_TOK_COND_SECT_OPEN 33 /* <![ */
+#define XML_TOK_COND_SECT_CLOSE 34 /* ]]> */
+#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
+#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
+#define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */
+#define XML_TOK_COMMA 38
+
+/* The following token is returned only by XmlAttributeValueTok */
+#define XML_TOK_ATTRIBUTE_VALUE_S 39
+
+/* The following token is returned only by XmlCdataSectionTok */
+#define XML_TOK_CDATA_SECT_CLOSE 40
+
+/* With namespace processing this is returned by XmlPrologTok
+   for a name with a colon. */
+#define XML_TOK_PREFIXED_NAME 41
+
+#ifdef XML_DTD
+#define XML_TOK_IGNORE_SECT 42
+#endif /* XML_DTD */
+
+#ifdef XML_DTD
+#define XML_N_STATES 4
+#else /* not XML_DTD */
+#define XML_N_STATES 3
+#endif /* not XML_DTD */
+
+#define XML_PROLOG_STATE 0
+#define XML_CONTENT_STATE 1
+#define XML_CDATA_SECTION_STATE 2
+#ifdef XML_DTD
+#define XML_IGNORE_SECTION_STATE 3
+#endif /* XML_DTD */
+
+#define XML_N_LITERAL_TYPES 2
+#define XML_ATTRIBUTE_VALUE_LITERAL 0
+#define XML_ENTITY_VALUE_LITERAL 1
+
+/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
+#define XML_UTF8_ENCODE_MAX 4
+/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
+#define XML_UTF16_ENCODE_MAX 2
+
+typedef struct position {
+  /* first line and first column are 0 not 1 */
+  unsigned long lineNumber;
+  unsigned long columnNumber;
+} POSITION;
+
+typedef struct {
+  const char *name;
+  const char *valuePtr;
+  const char *valueEnd;
+  char normalized;
+} ATTRIBUTE;
+
+struct encoding;
+typedef struct encoding ENCODING;
+
+struct encoding {
+  int (*scanners[XML_N_STATES])(const ENCODING *,
+			        const char *,
+			        const char *,
+			        const char **);
+  int (*literalScanners[XML_N_LITERAL_TYPES])(const ENCODING *,
+					      const char *,
+					      const char *,
+					      const char **);
+  int (*sameName)(const ENCODING *,
+	          const char *, const char *);
+  int (*nameMatchesAscii)(const ENCODING *,
+			  const char *, const char *, const char *);
+  int (*nameLength)(const ENCODING *, const char *);
+  const char *(*skipS)(const ENCODING *, const char *);
+  int (*getAtts)(const ENCODING *enc, const char *ptr,
+	         int attsMax, ATTRIBUTE *atts);
+  int (*charRefNumber)(const ENCODING *enc, const char *ptr);
+  int (*predefinedEntityName)(const ENCODING *, const char *, const char *);
+  void (*updatePosition)(const ENCODING *,
+			 const char *ptr,
+			 const char *end,
+			 POSITION *);
+  int (*isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
+		    const char **badPtr);
+  void (*utf8Convert)(const ENCODING *enc,
+		      const char **fromP,
+		      const char *fromLim,
+		      char **toP,
+		      const char *toLim);
+  void (*utf16Convert)(const ENCODING *enc,
+		       const char **fromP,
+		       const char *fromLim,
+		       unsigned short **toP,
+		       const unsigned short *toLim);
+  int minBytesPerChar;
+  char isUtf8;
+  char isUtf16;
+};
+
+/*
+Scan the string starting at ptr until the end of the next complete token,
+but do not scan past eptr.  Return an integer giving the type of token.
+
+Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
+
+Return XML_TOK_PARTIAL when the string does not contain a complete token;
+nextTokPtr will not be set.
+
+Return XML_TOK_INVALID when the string does not start a valid token; nextTokPtr
+will be set to point to the character which made the token invalid.
+
+Otherwise the string starts with a valid token; nextTokPtr will be set to point
+to the character following the end of that token.
+
+Each data character counts as a single token, but adjacent data characters
+may be returned together.  Similarly for characters in the prolog outside
+literals, comments and processing instructions.
+*/
+
+
+#define XmlTok(enc, state, ptr, end, nextTokPtr) \
+  (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
+
+#define XmlPrologTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
+
+#define XmlContentTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
+
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+
+#ifdef XML_DTD
+
+#define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+
+#endif /* XML_DTD */
+
+/* This is used for performing a 2nd-level tokenization on
+the content of a literal that has already been returned by XmlTok. */ 
+
+#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
+  (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
+
+#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlSameName(enc, ptr1, ptr2) (((enc)->sameName)(enc, ptr1, ptr2))
+
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
+  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
+
+#define XmlNameLength(enc, ptr) \
+  (((enc)->nameLength)(enc, ptr))
+
+#define XmlSkipS(enc, ptr) \
+  (((enc)->skipS)(enc, ptr))
+
+#define XmlGetAttributes(enc, ptr, attsMax, atts) \
+  (((enc)->getAtts)(enc, ptr, attsMax, atts))
+
+#define XmlCharRefNumber(enc, ptr) \
+  (((enc)->charRefNumber)(enc, ptr))
+
+#define XmlPredefinedEntityName(enc, ptr, end) \
+  (((enc)->predefinedEntityName)(enc, ptr, end))
+
+#define XmlUpdatePosition(enc, ptr, end, pos) \
+  (((enc)->updatePosition)(enc, ptr, end, pos))
+
+#define XmlIsPublicId(enc, ptr, end, badPtr) \
+  (((enc)->isPublicId)(enc, ptr, end, badPtr))
+
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
+
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
+
+typedef struct {
+  ENCODING initEnc;
+  const ENCODING **encPtr;
+} INIT_ENCODING;
+
+int  XmlParseXmlDecl(int isGeneralTextEntity,
+			      const ENCODING *enc,
+			      const char *ptr,
+	  		      const char *end,
+			      const char **badPtr,
+			      const char **versionPtr,
+			      const char **versionEndPtr,
+			      const char **encodingNamePtr,
+			      const ENCODING **namedEncodingPtr,
+			      int *standalonePtr);
+
+int  XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING  *XmlGetUtf8InternalEncoding(void);
+const ENCODING  *XmlGetUtf16InternalEncoding(void);
+int  XmlUtf8Encode(int charNumber, char *buf);
+int  XmlUtf16Encode(int charNumber, unsigned short *buf);
+
+int  XmlSizeOfUnknownEncoding(void);
+ENCODING  *
+XmlInitUnknownEncoding(void *mem,
+		       int *table,
+		       int (*conv)(void *userData, const char *p),
+		       void *userData);
+
+int  XmlParseXmlDeclNS(int isGeneralTextEntity,
+			        const ENCODING *enc,
+			        const char *ptr,
+	  		        const char *end,
+			        const char **badPtr,
+			        const char **versionPtr,
+				const char **versionEndPtr,
+			        const char **encodingNamePtr,
+			        const ENCODING **namedEncodingPtr,
+			        int *standalonePtr);
+int  XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING  *XmlGetUtf8InternalEncodingNS(void);
+const ENCODING  *XmlGetUtf16InternalEncodingNS(void);
+ENCODING  *
+XmlInitUnknownEncodingNS(void *mem,
+		         int *table,
+		         int (*conv)(void *userData, const char *p),
+		         void *userData);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlTok_INCLUDED */
Index: xc/extras/expat/lib/xmltok_impl.c
diff -u /dev/null xc/extras/expat/lib/xmltok_impl.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmltok_impl.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,1768 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#ifndef IS_INVALID_CHAR
+#define IS_INVALID_CHAR(enc, ptr, n) (0)
+#endif
+
+#define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
+    case BT_LEAD ## n: \
+      if (end - ptr < n) \
+	return XML_TOK_PARTIAL_CHAR; \
+      if (IS_INVALID_CHAR(enc, ptr, n)) { \
+        *(nextTokPtr) = (ptr); \
+        return XML_TOK_INVALID; \
+      } \
+      ptr += n; \
+      break;
+
+#define INVALID_CASES(ptr, nextTokPtr) \
+  INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
+  INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
+  INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
+  case BT_NONXML: \
+  case BT_MALFORM: \
+  case BT_TRAIL: \
+    *(nextTokPtr) = (ptr); \
+    return XML_TOK_INVALID;
+
+#define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
+   case BT_LEAD ## n: \
+     if (end - ptr < n) \
+       return XML_TOK_PARTIAL_CHAR; \
+     if (!IS_NAME_CHAR(enc, ptr, n)) { \
+       *nextTokPtr = ptr; \
+       return XML_TOK_INVALID; \
+     } \
+     ptr += n; \
+     break;
+
+#define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
+  case BT_NONASCII: \
+    if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
+      *nextTokPtr = ptr; \
+      return XML_TOK_INVALID; \
+    } \
+  case BT_NMSTRT: \
+  case BT_HEX: \
+  case BT_DIGIT: \
+  case BT_NAME: \
+  case BT_MINUS: \
+    ptr += MINBPC(enc); \
+    break; \
+  CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
+  CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
+  CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
+
+#define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
+   case BT_LEAD ## n: \
+     if (end - ptr < n) \
+       return XML_TOK_PARTIAL_CHAR; \
+     if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
+       *nextTokPtr = ptr; \
+       return XML_TOK_INVALID; \
+     } \
+     ptr += n; \
+     break;
+
+#define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
+  case BT_NONASCII: \
+    if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
+      *nextTokPtr = ptr; \
+      return XML_TOK_INVALID; \
+    } \
+  case BT_NMSTRT: \
+  case BT_HEX: \
+    ptr += MINBPC(enc); \
+    break; \
+  CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
+  CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
+  CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
+
+#ifndef PREFIX
+#define PREFIX(ident) ident
+#endif
+
+/* ptr points to character following "<!-" */
+
+static
+int PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
+			const char **nextTokPtr)
+{
+  if (ptr != end) {
+    if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    ptr += MINBPC(enc);
+    while (ptr != end) {
+      switch (BYTE_TYPE(enc, ptr)) {
+      INVALID_CASES(ptr, nextTokPtr)
+      case BT_MINUS:
+	if ((ptr += MINBPC(enc)) == end)
+	  return XML_TOK_PARTIAL;
+	if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
+	  if ((ptr += MINBPC(enc)) == end)
+	    return XML_TOK_PARTIAL;
+	  if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+	    *nextTokPtr = ptr;
+	    return XML_TOK_INVALID;
+	  }
+	  *nextTokPtr = ptr + MINBPC(enc);
+	  return XML_TOK_COMMENT;
+	}
+	break;
+      default:
+	ptr += MINBPC(enc);
+	break;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "<!" */
+
+static
+int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
+		     const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_PARTIAL;
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_MINUS:
+    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_LSQB:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_COND_SECT_OPEN;
+  case BT_NMSTRT:
+  case BT_HEX:
+    ptr += MINBPC(enc);
+    break;
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_PERCNT:
+      if (ptr + MINBPC(enc) == end)
+	return XML_TOK_PARTIAL;
+      /* don't allow <!ENTITY% foo "whatever"> */
+      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
+      case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      /* fall through */
+    case BT_S: case BT_CR: case BT_LF:
+      *nextTokPtr = ptr;
+      return XML_TOK_DECL_OPEN;
+    case BT_NMSTRT:
+    case BT_HEX:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static
+int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end, int *tokPtr)
+{
+  int upper = 0;
+  *tokPtr = XML_TOK_PI;
+  if (end - ptr != MINBPC(enc)*3)
+    return 1;
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_x:
+    break;
+  case ASCII_X:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  ptr += MINBPC(enc);
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_m:
+    break;
+  case ASCII_M:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  ptr += MINBPC(enc);
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_l:
+    break;
+  case ASCII_L:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  if (upper)
+    return 0;
+  *tokPtr = XML_TOK_XML_DECL;
+  return 1;
+}
+
+/* ptr points to character following "<?" */
+
+static
+int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
+		   const char **nextTokPtr)
+{
+  int tok;
+  const char *target = ptr;
+  if (ptr == end)
+    return XML_TOK_PARTIAL;
+  switch (BYTE_TYPE(enc, ptr)) {
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S: case BT_CR: case BT_LF:
+      if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      ptr += MINBPC(enc);
+      while (ptr != end) {
+        switch (BYTE_TYPE(enc, ptr)) {
+        INVALID_CASES(ptr, nextTokPtr)
+	case BT_QUEST:
+	  ptr += MINBPC(enc);
+	  if (ptr == end)
+	    return XML_TOK_PARTIAL;
+	  if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+	    *nextTokPtr = ptr + MINBPC(enc);
+	    return tok;
+	  }
+	  break;
+	default:
+	  ptr += MINBPC(enc);
+	  break;
+	}
+      }
+      return XML_TOK_PARTIAL;
+    case BT_QUEST:
+      if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	return XML_TOK_PARTIAL;
+      if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+	*nextTokPtr = ptr + MINBPC(enc);
+	return tok;
+      }
+      /* fall through */
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+
+static
+int PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
+			     const char **nextTokPtr)
+{
+  static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB };
+  int i;
+  /* CDATA[ */
+  if (end - ptr < 6 * MINBPC(enc))
+    return XML_TOK_PARTIAL;
+  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
+    if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_CDATA_SECT_OPEN;
+}
+
+static
+int PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+			    const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+	return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_PARTIAL;
+    if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+      break;
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_PARTIAL;
+    if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+      ptr -= MINBPC(enc);
+      break;
+    }
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_CDATA_SECT_CLOSE;
+  case BT_CR:
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_PARTIAL;
+    if (BYTE_TYPE(enc, ptr) == BT_LF)
+      ptr += MINBPC(enc);
+    *nextTokPtr = ptr;
+    return XML_TOK_DATA_NEWLINE;
+  case BT_LF:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DATA_NEWLINE;
+  INVALID_CASES(ptr, nextTokPtr)
+  default:
+    ptr += MINBPC(enc);
+    break;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: \
+      if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
+	*nextTokPtr = ptr; \
+	return XML_TOK_DATA_CHARS; \
+      } \
+      ptr += n; \
+      break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_NONXML:
+    case BT_MALFORM:
+    case BT_TRAIL:
+    case BT_CR:
+    case BT_LF:
+    case BT_RSQB:
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+/* ptr points to character following "</" */
+
+static
+int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
+		       const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_PARTIAL;
+  switch (BYTE_TYPE(enc, ptr)) {
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S: case BT_CR: case BT_LF:
+      for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
+	switch (BYTE_TYPE(enc, ptr)) {
+	case BT_S: case BT_CR: case BT_LF:
+	  break;
+	case BT_GT:
+	  *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_END_TAG;
+	default:
+	  *nextTokPtr = ptr;
+	  return XML_TOK_INVALID;
+	}
+      }
+      return XML_TOK_PARTIAL;
+#ifdef XML_NS
+    case BT_COLON:
+      /* no need to check qname syntax here, since end-tag must match exactly */
+      ptr += MINBPC(enc);
+      break;
+#endif
+    case BT_GT:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_END_TAG;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&#X" */
+
+static
+int PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+			   const char **nextTokPtr)
+{
+  if (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+    case BT_HEX:
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_DIGIT:
+      case BT_HEX:
+	break;
+      case BT_SEMI:
+	*nextTokPtr = ptr + MINBPC(enc);
+	return XML_TOK_CHAR_REF;
+      default:
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&#" */
+
+static
+int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+			const char **nextTokPtr)
+{
+  if (ptr != end) {
+    if (CHAR_MATCHES(enc, ptr, ASCII_x))
+      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_DIGIT:
+	break;
+      case BT_SEMI:
+	*nextTokPtr = ptr + MINBPC(enc);
+	return XML_TOK_CHAR_REF;
+      default:
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&" */
+
+static
+int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
+		    const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_PARTIAL;
+  switch (BYTE_TYPE(enc, ptr)) {
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_NUM:
+    return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_SEMI:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_ENTITY_REF;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following first character of attribute name */
+
+static
+int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
+		     const char **nextTokPtr)
+{
+#ifdef XML_NS
+  int hadColon = 0;
+#endif
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	return XML_TOK_PARTIAL;
+      switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      break;
+#endif
+    case BT_S: case BT_CR: case BT_LF:
+      for (;;) {
+	int t;
+
+	ptr += MINBPC(enc);
+	if (ptr == end)
+	  return XML_TOK_PARTIAL;
+	t = BYTE_TYPE(enc, ptr);
+	if (t == BT_EQUALS)
+	  break;
+	switch (t) {
+	case BT_S:
+	case BT_LF:
+	case BT_CR:
+	  break;
+	default:
+	  *nextTokPtr = ptr;
+	  return XML_TOK_INVALID;
+	}
+      }
+    /* fall through */
+    case BT_EQUALS:
+      {
+	int open;
+#ifdef XML_NS
+	hadColon = 0;
+#endif
+	for (;;) {
+	  
+	  ptr += MINBPC(enc);
+	  if (ptr == end)
+	    return XML_TOK_PARTIAL;
+	  open = BYTE_TYPE(enc, ptr);
+	  if (open == BT_QUOT || open == BT_APOS)
+	    break;
+	  switch (open) {
+	  case BT_S:
+	  case BT_LF:
+	  case BT_CR:
+	    break;
+	  default:
+	    *nextTokPtr = ptr;
+	    return XML_TOK_INVALID;
+	  }
+	}
+	ptr += MINBPC(enc);
+	/* in attribute value */
+	for (;;) {
+	  int t;
+	  if (ptr == end)
+	    return XML_TOK_PARTIAL;
+	  t = BYTE_TYPE(enc, ptr);
+	  if (t == open)
+	    break;
+	  switch (t) {
+	  INVALID_CASES(ptr, nextTokPtr)
+	  case BT_AMP:
+	    {
+	      int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
+	      if (tok <= 0) {
+		if (tok == XML_TOK_INVALID)
+		  *nextTokPtr = ptr;
+		return tok;
+	      }
+	      break;
+	    }
+	  case BT_LT:
+	    *nextTokPtr = ptr;
+	    return XML_TOK_INVALID;
+	  default:
+	    ptr += MINBPC(enc);
+	    break;
+	  }
+	}
+	ptr += MINBPC(enc);
+	if (ptr == end)
+	  return XML_TOK_PARTIAL;
+	switch (BYTE_TYPE(enc, ptr)) {
+	case BT_S:
+	case BT_CR:
+	case BT_LF:
+	  break;
+	case BT_SOL:
+	  goto sol;
+	case BT_GT:
+	  goto gt;
+	default:
+	  *nextTokPtr = ptr;
+	  return XML_TOK_INVALID;
+	}
+	/* ptr points to closing quote */
+	for (;;) {
+	  ptr += MINBPC(enc);
+	  if (ptr == end)
+	    return XML_TOK_PARTIAL;
+	  switch (BYTE_TYPE(enc, ptr)) {
+	  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+	  case BT_S: case BT_CR: case BT_LF:
+	    continue;
+	  case BT_GT:
+          gt:
+	    *nextTokPtr = ptr + MINBPC(enc);
+	    return XML_TOK_START_TAG_WITH_ATTS;
+	  case BT_SOL:
+          sol:
+	    ptr += MINBPC(enc);
+	    if (ptr == end)
+	      return XML_TOK_PARTIAL;
+	    if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+	      *nextTokPtr = ptr;
+	      return XML_TOK_INVALID;
+	    }
+	    *nextTokPtr = ptr + MINBPC(enc);
+	    return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
+	  default:
+	    *nextTokPtr = ptr;
+	    return XML_TOK_INVALID;
+	  }
+	  break;
+	}
+	break;
+      }
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "<" */
+
+static
+int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
+		   const char **nextTokPtr)
+{
+#ifdef XML_NS
+  int hadColon;
+#endif
+  if (ptr == end)
+    return XML_TOK_PARTIAL;
+  switch (BYTE_TYPE(enc, ptr)) {
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_EXCL:
+    if ((ptr += MINBPC(enc)) == end)
+      return XML_TOK_PARTIAL;
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_MINUS:
+      return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_LSQB:
+      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  case BT_QUEST:
+    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_SOL:
+    return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+#ifdef XML_NS
+  hadColon = 0;
+#endif
+  /* we have a start-tag */
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	return XML_TOK_PARTIAL;
+      switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      break;
+#endif
+    case BT_S: case BT_CR: case BT_LF:
+      {
+        ptr += MINBPC(enc);
+	while (ptr != end) {
+	  switch (BYTE_TYPE(enc, ptr)) {
+	  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+	  case BT_GT:
+	    goto gt;
+	  case BT_SOL:
+	    goto sol;
+	  case BT_S: case BT_CR: case BT_LF:
+	    ptr += MINBPC(enc);
+	    continue;
+	  default:
+	    *nextTokPtr = ptr;
+	    return XML_TOK_INVALID;
+	  }
+	  return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
+	}
+	return XML_TOK_PARTIAL;
+      }
+    case BT_GT:
+    gt:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_START_TAG_NO_ATTS;
+    case BT_SOL:
+    sol:
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	return XML_TOK_PARTIAL;
+      if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static
+int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
+		       const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+	return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_LT:
+    return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_AMP:
+    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_CR:
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_TRAILING_CR;
+    if (BYTE_TYPE(enc, ptr) == BT_LF)
+      ptr += MINBPC(enc);
+    *nextTokPtr = ptr;
+    return XML_TOK_DATA_NEWLINE;
+  case BT_LF:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DATA_NEWLINE;
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_TRAILING_RSQB;
+    if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+      break;
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_TRAILING_RSQB;
+    if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+      ptr -= MINBPC(enc);
+      break;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  INVALID_CASES(ptr, nextTokPtr)
+  default:
+    ptr += MINBPC(enc);
+    break;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: \
+      if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
+	*nextTokPtr = ptr; \
+	return XML_TOK_DATA_CHARS; \
+      } \
+      ptr += n; \
+      break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_RSQB:
+      if (ptr + MINBPC(enc) != end) {
+	 if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
+	   ptr += MINBPC(enc);
+	   break;
+	 }
+	 if (ptr + 2*MINBPC(enc) != end) {
+	   if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
+	     ptr += MINBPC(enc);
+	     break;
+	   }
+	   *nextTokPtr = ptr + 2*MINBPC(enc);
+	   return XML_TOK_INVALID;
+	 }
+      }
+      /* fall through */
+    case BT_AMP:
+    case BT_LT:
+    case BT_NONXML:
+    case BT_MALFORM:
+    case BT_TRAIL:
+    case BT_CR:
+    case BT_LF:
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+/* ptr points to character following "%" */
+
+static
+int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
+			const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_PARTIAL;
+  switch (BYTE_TYPE(enc, ptr)) {
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
+    *nextTokPtr = ptr;
+    return XML_TOK_PERCENT;
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_SEMI:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_PARAM_ENTITY_REF;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static
+int PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
+			  const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_PARTIAL;
+  switch (BYTE_TYPE(enc, ptr)) {
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_CR: case BT_LF: case BT_S:
+    case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
+      *nextTokPtr = ptr;
+      return XML_TOK_POUND_NAME;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return -XML_TOK_POUND_NAME;
+}
+
+static
+int PREFIX(scanLit)(int open, const ENCODING *enc,
+		    const char *ptr, const char *end,
+		    const char **nextTokPtr)
+{
+  while (ptr != end) {
+    int t = BYTE_TYPE(enc, ptr);
+    switch (t) {
+    INVALID_CASES(ptr, nextTokPtr)
+    case BT_QUOT:
+    case BT_APOS:
+      ptr += MINBPC(enc);
+      if (t != open)
+	break;
+      if (ptr == end)
+	return -XML_TOK_LITERAL;
+      *nextTokPtr = ptr;
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S: case BT_CR: case BT_LF:
+      case BT_GT: case BT_PERCNT: case BT_LSQB:
+	return XML_TOK_LITERAL;
+      default:
+	return XML_TOK_INVALID;
+      }
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static
+int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
+		      const char **nextTokPtr)
+{
+  int tok;
+  if (ptr == end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+	return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_QUOT:
+    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_APOS:
+    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_LT:
+    {
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	return XML_TOK_PARTIAL;
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_EXCL:
+	return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      case BT_QUEST:
+	return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      case BT_NMSTRT:
+      case BT_HEX:
+      case BT_NONASCII:
+      case BT_LEAD2:
+      case BT_LEAD3:
+      case BT_LEAD4:
+	*nextTokPtr = ptr - MINBPC(enc);
+	return XML_TOK_INSTANCE_START;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  case BT_CR:
+    if (ptr + MINBPC(enc) == end)
+      return -XML_TOK_PROLOG_S;
+    /* fall through */
+  case BT_S: case BT_LF:
+    for (;;) {
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	break;
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S: case BT_LF:
+	break;
+      case BT_CR:
+	/* don't split CR/LF pair */
+	if (ptr + MINBPC(enc) != end)
+	  break;
+	/* fall through */
+      default:
+	*nextTokPtr = ptr;
+	return XML_TOK_PROLOG_S;
+      }
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_PROLOG_S;
+  case BT_PERCNT:
+    return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_COMMA:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_COMMA;
+  case BT_LSQB:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OPEN_BRACKET;
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return -XML_TOK_CLOSE_BRACKET;
+    if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
+      if (ptr + MINBPC(enc) == end)
+	return XML_TOK_PARTIAL;
+      if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
+	*nextTokPtr = ptr + 2*MINBPC(enc);
+	return XML_TOK_COND_SECT_CLOSE;
+      }
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_CLOSE_BRACKET;
+  case BT_LPAR:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OPEN_PAREN;
+  case BT_RPAR:
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return -XML_TOK_CLOSE_PAREN;
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_AST:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_ASTERISK;
+    case BT_QUEST:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_QUESTION;
+    case BT_PLUS:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_PLUS;
+    case BT_CR: case BT_LF: case BT_S:
+    case BT_GT: case BT_COMMA: case BT_VERBAR:
+    case BT_RPAR:
+      *nextTokPtr = ptr;
+      return XML_TOK_CLOSE_PAREN;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  case BT_VERBAR:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OR;
+  case BT_GT:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DECL_CLOSE;
+  case BT_NUM:
+    return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+#define LEAD_CASE(n) \
+  case BT_LEAD ## n: \
+    if (end - ptr < n) \
+      return XML_TOK_PARTIAL_CHAR; \
+    if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
+      ptr += n; \
+      tok = XML_TOK_NAME; \
+      break; \
+    } \
+    if (IS_NAME_CHAR(enc, ptr, n)) { \
+      ptr += n; \
+      tok = XML_TOK_NMTOKEN; \
+      break; \
+    } \
+    *nextTokPtr = ptr; \
+    return XML_TOK_INVALID;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+  case BT_NMSTRT:
+  case BT_HEX:
+    tok = XML_TOK_NAME;
+    ptr += MINBPC(enc);
+    break;
+  case BT_DIGIT:
+  case BT_NAME:
+  case BT_MINUS:
+#ifdef XML_NS
+  case BT_COLON:
+#endif
+    tok = XML_TOK_NMTOKEN;
+    ptr += MINBPC(enc);
+    break;
+  case BT_NONASCII:
+    if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
+      tok = XML_TOK_NAME;
+      break;
+    }
+    if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
+      tok = XML_TOK_NMTOKEN;
+      break;
+    }
+    /* fall through */
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_GT: case BT_RPAR: case BT_COMMA:
+    case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
+    case BT_S: case BT_CR: case BT_LF:
+      *nextTokPtr = ptr;
+      return tok;
+#ifdef XML_NS
+    case BT_COLON:
+      ptr += MINBPC(enc);
+      switch (tok) {
+      case XML_TOK_NAME:
+	if (ptr == end)
+	  return XML_TOK_PARTIAL;
+	tok = XML_TOK_PREFIXED_NAME;
+	switch (BYTE_TYPE(enc, ptr)) {
+	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+	default:
+	  tok = XML_TOK_NMTOKEN;
+	  break;
+	}
+	break;
+      case XML_TOK_PREFIXED_NAME:
+	tok = XML_TOK_NMTOKEN;
+	break;
+      }
+      break;
+#endif
+    case BT_PLUS:
+      if (tok == XML_TOK_NMTOKEN)  {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_PLUS;
+    case BT_AST:
+      if (tok == XML_TOK_NMTOKEN)  {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_ASTERISK;
+    case BT_QUEST:
+      if (tok == XML_TOK_NMTOKEN)  {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_QUESTION;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return -tok;
+}
+
+static
+int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+			      const char **nextTokPtr)
+{
+  const char *start;
+  if (ptr == end)
+    return XML_TOK_NONE;
+  start = ptr;
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: ptr += n; break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_AMP:
+      if (ptr == start)
+	return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_LT:
+      /* this is for inside entity references */
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    case BT_LF:
+      if (ptr == start) {
+	*nextTokPtr = ptr + MINBPC(enc);
+	return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_CR:
+      if (ptr == start) {
+	ptr += MINBPC(enc);
+	if (ptr == end)
+	  return XML_TOK_TRAILING_CR;
+	if (BYTE_TYPE(enc, ptr) == BT_LF)
+	  ptr += MINBPC(enc);
+	*nextTokPtr = ptr;
+	return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_S:
+      if (ptr == start) {
+	*nextTokPtr = ptr + MINBPC(enc);
+	return XML_TOK_ATTRIBUTE_VALUE_S;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+static
+int PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+			   const char **nextTokPtr)
+{
+  const char *start;
+  if (ptr == end)
+    return XML_TOK_NONE;
+  start = ptr;
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: ptr += n; break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_AMP:
+      if (ptr == start)
+	return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_PERCNT:
+      if (ptr == start) {
+	int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
+				       end, nextTokPtr);
+	return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_LF:
+      if (ptr == start) {
+	*nextTokPtr = ptr + MINBPC(enc);
+	return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_CR:
+      if (ptr == start) {
+	ptr += MINBPC(enc);
+	if (ptr == end)
+	  return XML_TOK_TRAILING_CR;
+	if (BYTE_TYPE(enc, ptr) == BT_LF)
+	  ptr += MINBPC(enc);
+	*nextTokPtr = ptr;
+	return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+#ifdef XML_DTD
+
+static
+int PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+			     const char **nextTokPtr)
+{
+  int level = 0;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      end = ptr + n;
+    }
+  }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    INVALID_CASES(ptr, nextTokPtr)
+    case BT_LT:
+      if ((ptr += MINBPC(enc)) == end)
+	return XML_TOK_PARTIAL;
+      if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
+	if ((ptr += MINBPC(enc)) == end)
+	  return XML_TOK_PARTIAL;
+	if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
+	  ++level;
+	  ptr += MINBPC(enc);
+	}
+      }
+      break;
+    case BT_RSQB:
+      if ((ptr += MINBPC(enc)) == end)
+	return XML_TOK_PARTIAL;
+      if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
+	if ((ptr += MINBPC(enc)) == end)
+	  return XML_TOK_PARTIAL;
+	if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+	  ptr += MINBPC(enc);
+	  if (level == 0) {
+	    *nextTokPtr = ptr;
+	    return XML_TOK_IGNORE_SECT;
+	  }
+	  --level;
+	}
+      }
+      break;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+#endif /* XML_DTD */
+
+static
+int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
+		       const char **badPtr)
+{
+  ptr += MINBPC(enc);
+  end -= MINBPC(enc);
+  for (; ptr != end; ptr += MINBPC(enc)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+    case BT_HEX:
+    case BT_MINUS:
+    case BT_APOS:
+    case BT_LPAR:
+    case BT_RPAR:
+    case BT_PLUS:
+    case BT_COMMA:
+    case BT_SOL:
+    case BT_EQUALS:
+    case BT_QUEST:
+    case BT_CR:
+    case BT_LF:
+    case BT_SEMI:
+    case BT_EXCL:
+    case BT_AST:
+    case BT_PERCNT:
+    case BT_NUM:
+#ifdef XML_NS
+    case BT_COLON:
+#endif
+      break;
+    case BT_S:
+      if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
+	*badPtr = ptr;
+	return 0;
+      }
+      break;
+    case BT_NAME:
+    case BT_NMSTRT:
+      if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
+	break;
+    default:
+      switch (BYTE_TO_ASCII(enc, ptr)) {
+      case 0x24: /* $ */
+      case 0x40: /* @ */
+	break;
+      default:
+	*badPtr = ptr;
+	return 0;
+      }
+      break;
+    }
+  }
+  return 1;
+}
+
+/* This must only be called for a well-formed start-tag or empty element tag.
+Returns the number of attributes.  Pointers to the first attsMax attributes 
+are stored in atts. */
+
+static
+int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
+		    int attsMax, ATTRIBUTE *atts)
+{
+  enum { other, inName, inValue } state = inName;
+  int nAtts = 0;
+  int open = 0; /* defined when state == inValue;
+		   initialization just to shut up compilers */
+
+  for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define START_NAME \
+      if (state == other) { \
+	if (nAtts < attsMax) { \
+	  atts[nAtts].name = ptr; \
+	  atts[nAtts].normalized = 1; \
+	} \
+	state = inName; \
+      }
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_NONASCII:
+    case BT_NMSTRT:
+    case BT_HEX:
+      START_NAME
+      break;
+#undef START_NAME
+    case BT_QUOT:
+      if (state != inValue) {
+	if (nAtts < attsMax)
+	  atts[nAtts].valuePtr = ptr + MINBPC(enc);
+        state = inValue;
+        open = BT_QUOT;
+      }
+      else if (open == BT_QUOT) {
+        state = other;
+	if (nAtts < attsMax)
+	  atts[nAtts].valueEnd = ptr;
+	nAtts++;
+      }
+      break;
+    case BT_APOS:
+      if (state != inValue) {
+	if (nAtts < attsMax)
+	  atts[nAtts].valuePtr = ptr + MINBPC(enc);
+        state = inValue;
+        open = BT_APOS;
+      }
+      else if (open == BT_APOS) {
+        state = other;
+	if (nAtts < attsMax)
+	  atts[nAtts].valueEnd = ptr;
+	nAtts++;
+      }
+      break;
+    case BT_AMP:
+      if (nAtts < attsMax)
+	atts[nAtts].normalized = 0;
+      break;
+    case BT_S:
+      if (state == inName)
+        state = other;
+      else if (state == inValue
+	       && nAtts < attsMax
+	       && atts[nAtts].normalized
+	       && (ptr == atts[nAtts].valuePtr
+		   || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
+		   || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
+	           || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
+	atts[nAtts].normalized = 0;
+      break;
+    case BT_CR: case BT_LF:
+      /* This case ensures that the first attribute name is counted
+         Apart from that we could just change state on the quote. */
+      if (state == inName)
+        state = other;
+      else if (state == inValue && nAtts < attsMax)
+	atts[nAtts].normalized = 0;
+      break;
+    case BT_GT:
+    case BT_SOL:
+      if (state != inValue)
+	return nAtts;
+      break;
+    default:
+      break;
+    }
+  }
+  /* not reached */
+}
+
+static
+int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
+{
+  int result = 0;
+  /* skip &# */
+  ptr += 2*MINBPC(enc);
+  if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
+    for (ptr += MINBPC(enc); !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
+      int c = BYTE_TO_ASCII(enc, ptr);
+      switch (c) {
+      case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
+      case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
+	result <<= 4;
+	result |= (c - ASCII_0);
+	break;
+      case ASCII_A: case ASCII_B: case ASCII_C: case ASCII_D: case ASCII_E: case ASCII_F:
+	result <<= 4;
+	result += 10 + (c - ASCII_A);
+	break;
+      case ASCII_a: case ASCII_b: case ASCII_c: case ASCII_d: case ASCII_e: case ASCII_f:
+	result <<= 4;
+	result += 10 + (c - ASCII_a);
+	break;
+      }
+      if (result >= 0x110000)
+	return -1;
+    }
+  }
+  else {
+    for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
+      int c = BYTE_TO_ASCII(enc, ptr);
+      result *= 10;
+      result += (c - ASCII_0);
+      if (result >= 0x110000)
+	return -1;
+    }
+  }
+  return checkCharRefNumber(result);
+}
+
+static
+int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const char *end)
+{
+  switch ((end - ptr)/MINBPC(enc)) {
+  case 2:
+    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
+      switch (BYTE_TO_ASCII(enc, ptr)) {
+      case ASCII_l:
+	return ASCII_LT;
+      case ASCII_g:
+	return ASCII_GT;
+      }
+    }
+    break;
+  case 3:
+    if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
+	ptr += MINBPC(enc);
+	if (CHAR_MATCHES(enc, ptr, ASCII_p))
+	  return ASCII_AMP;
+      }
+    }
+    break;
+  case 4:
+    switch (BYTE_TO_ASCII(enc, ptr)) {
+    case ASCII_q:
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
+	ptr += MINBPC(enc);
+	if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
+	  ptr += MINBPC(enc);
+  	  if (CHAR_MATCHES(enc, ptr, ASCII_t))
+	    return ASCII_QUOT;
+	}
+      }
+      break;
+    case ASCII_a:
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
+	ptr += MINBPC(enc);
+	if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
+	  ptr += MINBPC(enc);
+  	  if (CHAR_MATCHES(enc, ptr, ASCII_s))
+	    return ASCII_APOS;
+	}
+      }
+      break;
+    }
+  }
+  return 0;
+}
+
+static
+int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
+{
+  for (;;) {
+    switch (BYTE_TYPE(enc, ptr1)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: \
+      if (*ptr1++ != *ptr2++) \
+	return 0;
+    LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
+#undef LEAD_CASE
+      /* fall through */
+      if (*ptr1++ != *ptr2++)
+	return 0;
+      break;
+    case BT_NONASCII:
+    case BT_NMSTRT:
+#ifdef XML_NS
+    case BT_COLON:
+#endif
+    case BT_HEX:
+    case BT_DIGIT:
+    case BT_NAME:
+    case BT_MINUS:
+      if (*ptr2++ != *ptr1++)
+	return 0;
+      if (MINBPC(enc) > 1) {
+	if (*ptr2++ != *ptr1++)
+	  return 0;
+	if (MINBPC(enc) > 2) {
+	  if (*ptr2++ != *ptr1++)
+	    return 0;
+          if (MINBPC(enc) > 3) {
+	    if (*ptr2++ != *ptr1++)
+      	      return 0;
+	  }
+	}
+      }
+      break;
+    default:
+      if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
+	return 1;
+      switch (BYTE_TYPE(enc, ptr2)) {
+      case BT_LEAD2:
+      case BT_LEAD3:
+      case BT_LEAD4:
+      case BT_NONASCII:
+      case BT_NMSTRT:
+#ifdef XML_NS
+      case BT_COLON:
+#endif
+      case BT_HEX:
+      case BT_DIGIT:
+      case BT_NAME:
+      case BT_MINUS:
+	return 0;
+      default:
+	return 1;
+      }
+    }
+  }
+  /* not reached */
+}
+
+static
+int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
+			     const char *end1, const char *ptr2)
+{
+  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
+    if (ptr1 == end1)
+      return 0;
+    if (!CHAR_MATCHES(enc, ptr1, *ptr2))
+      return 0;
+  }
+  return ptr1 == end1;
+}
+
+static
+int PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
+{
+  const char *start = ptr;
+  for (;;) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: ptr += n; break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_NONASCII:
+    case BT_NMSTRT:
+#ifdef XML_NS
+    case BT_COLON:
+#endif
+    case BT_HEX:
+    case BT_DIGIT:
+    case BT_NAME:
+    case BT_MINUS:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      return ptr - start;
+    }
+  }
+}
+
+static
+const char *PREFIX(skipS)(const ENCODING *enc, const char *ptr)
+{
+  for (;;) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_LF:
+    case BT_CR:
+    case BT_S:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      return ptr;
+    }
+  }
+}
+
+static
+void PREFIX(updatePosition)(const ENCODING *enc,
+			    const char *ptr,
+			    const char *end,
+			    POSITION *pos)
+{
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: \
+      ptr += n; \
+      break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_LF:
+      pos->columnNumber = (unsigned)-1;
+      pos->lineNumber++;
+      ptr += MINBPC(enc);
+      break;
+    case BT_CR:
+      pos->lineNumber++;
+      ptr += MINBPC(enc);
+      if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
+	ptr += MINBPC(enc);
+      pos->columnNumber = (unsigned)-1;
+      break;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+    pos->columnNumber++;
+  }
+}
+
+#undef DO_LEAD_CASE
+#undef MULTIBYTE_CASES
+#undef INVALID_CASES
+#undef CHECK_NAME_CASE
+#undef CHECK_NAME_CASES
+#undef CHECK_NMSTRT_CASE
+#undef CHECK_NMSTRT_CASES
Index: xc/extras/expat/lib/xmltok_impl.h
diff -u /dev/null xc/extras/expat/lib/xmltok_impl.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmltok_impl.h	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,46 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+enum {
+  BT_NONXML,
+  BT_MALFORM,
+  BT_LT,
+  BT_AMP,
+  BT_RSQB,
+  BT_LEAD2,
+  BT_LEAD3,
+  BT_LEAD4,
+  BT_TRAIL,
+  BT_CR,
+  BT_LF,
+  BT_GT,
+  BT_QUOT,
+  BT_APOS,
+  BT_EQUALS,
+  BT_QUEST,
+  BT_EXCL,
+  BT_SOL,
+  BT_SEMI,
+  BT_NUM,
+  BT_LSQB,
+  BT_S,
+  BT_NMSTRT,
+  BT_COLON,
+  BT_HEX,
+  BT_DIGIT,
+  BT_NAME,
+  BT_MINUS,
+  BT_OTHER, /* known not to be a name or name start character */
+  BT_NONASCII, /* might be a name or name start character */
+  BT_PERCNT,
+  BT_LPAR,
+  BT_RPAR,
+  BT_AST,
+  BT_PLUS,
+  BT_COMMA,
+  BT_VERBAR
+};
+
+#include <stddef.h>
Index: xc/extras/expat/lib/xmltok_ns.c
diff -u /dev/null xc/extras/expat/lib/xmltok_ns.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/lib/xmltok_ns.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,98 @@
+const ENCODING *NS(XmlGetUtf8InternalEncoding)(void)
+{
+  return &ns(internal_utf8_encoding).enc;
+}
+
+const ENCODING *NS(XmlGetUtf16InternalEncoding)(void)
+{
+#if XML_BYTE_ORDER == 12
+  return &ns(internal_little2_encoding).enc;
+#elif XML_BYTE_ORDER == 21
+  return &ns(internal_big2_encoding).enc;
+#else
+  const short n = 1;
+  return *(const char *)&n ? &ns(internal_little2_encoding).enc : &ns(internal_big2_encoding).enc;
+#endif
+}
+
+static
+const ENCODING *NS(encodings)[] = {
+  &ns(latin1_encoding).enc,
+  &ns(ascii_encoding).enc,
+  &ns(utf8_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(little2_encoding).enc,
+  &ns(utf8_encoding).enc /* NO_ENC */
+};
+
+static
+int NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
+		       const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ptr, end, nextTokPtr);
+}
+
+static
+int NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
+		       const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE, ptr, end, nextTokPtr);
+}
+
+int NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr, const char *name)
+{
+  int i = getEncodingIndex(name);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  SET_INIT_ENC_INDEX(p, i);
+  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
+  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
+  p->initEnc.updatePosition = initUpdatePosition;
+  p->encPtr = encPtr;
+  *encPtr = &(p->initEnc);
+  return 1;
+}
+
+static
+const ENCODING *NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
+{
+#define ENCODING_MAX 128
+  char buf[ENCODING_MAX];
+  char *p = buf;
+  int i;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
+  if (ptr != end)
+    return 0;
+  *p = 0;
+  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
+    return enc;
+  i = getEncodingIndex(buf);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  return NS(encodings)[i];
+}
+
+int NS(XmlParseXmlDecl)(int isGeneralTextEntity,
+			const ENCODING *enc,
+			const char *ptr,
+			const char *end,
+			const char **badPtr,
+			const char **versionPtr,
+			const char **versionEndPtr,
+			const char **encodingName,
+			const ENCODING **encoding,
+			int *standalone)
+{
+  return doParseXmlDecl(NS(findEncoding),
+			isGeneralTextEntity,
+			enc,
+			ptr,
+			end,
+			badPtr,
+			versionPtr,
+			versionEndPtr,
+			encodingName,
+			encoding,
+			standalone);
+}
Index: xc/extras/expat/xmlwf/Makefile.in
diff -u /dev/null xc/extras/expat/xmlwf/Makefile.in:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/xmlwf/Makefile.in	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,68 @@
+################################################################
+# Process this file with top-level configure script to produce Makefile
+#
+# Copyright 2000 Clark Cooper
+#
+#  This file is part of EXPAT.
+#
+#  EXPAT is free software; you can redistribute it and/or modify it
+#  under the terms of the License (based on the MIT/X license) contained
+#  in the file COPYING that comes with this distribution.
+#
+# EXPAT 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
+#
+
+bindir = @bindir@
+
+LIBDIR= ../lib/.libs
+INCDIR= ../lib
+
+LDFLAGS= @LDFLAGS@ -static
+CFLAGS= @CFLAGS@ -I$(INCDIR)
+CC = @CC@
+
+FILEMAP_OBJ= @FILEMAP_OBJ@
+OBJS= xmlwf.o xmlfile.o codepage.o $(FILEMAP_OBJ)
+LIBS= -L$(LIBDIR) -lexpat
+
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = ${INSTALL}
+LIBTOOL = @LIBTOOL@
+mkinstalldirs = $(SHELL) $(top_srcdir)/conftools/mkinstalldirs
+
+srcdir = @srcdir@
+top_builddir = ..
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+
+xmlwf: $(OBJS)
+	$(CC) -o xmlwf $(LDFLAGS) $(OBJS) $(LIBS)
+
+install: xmlwf
+	$(mkinstalldirs) $(bindir)
+	$(LIBTOOL) --mode=install $(INSTALL_PROGRAM) xmlwf $(bindir)/xmlwf
+
+uninstall:
+	$(LIBTOOL) --mode=uninstall rm -f $(bindir)/xmlwf
+
+check:	$(SUBDIRS)
+	@echo
+	@echo This package does not yet have a regression test.
+	@echo
+
+clean:
+	rm -f xmlwf core *.o
+
+distclean: clean
+	rm -f Makefile
+
+maintainer-clean: distclean
Index: xc/extras/expat/xmlwf/codepage.c
diff -u /dev/null xc/extras/expat/xmlwf/codepage.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/xmlwf/codepage.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,65 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#include "codepage.h"
+
+#ifdef WIN32
+#define STRICT 1
+#define WIN32_LEAN_AND_MEAN 1
+
+#include <windows.h>
+
+int codepageMap(int cp, int *map)
+{
+  int i;
+  CPINFO info;
+  if (!GetCPInfo(cp, &info) || info.MaxCharSize > 2)
+    return 0;
+  for (i = 0; i < 256; i++)
+    map[i] = -1;
+  if (info.MaxCharSize > 1) {
+    for (i = 0; i < MAX_LEADBYTES; i++) {
+      int j, lim;
+      if (info.LeadByte[i] == 0 && info.LeadByte[i + 1] == 0)
+        break;
+      lim = info.LeadByte[i + 1];
+      for (j = info.LeadByte[i]; j < lim; j++)
+	map[j] = -2;
+    }
+  }
+  for (i = 0; i < 256; i++) {
+   if (map[i] == -1) {
+     char c = i;
+     unsigned short n;
+     if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
+		             &c, 1, &n, 1) == 1)
+       map[i] = n;
+   }
+  }
+  return 1;
+}
+
+int codepageConvert(int cp, const char *p)
+{
+  unsigned short c;
+  if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
+		          p, 2, &c, 1) == 1)
+    return c;
+  return -1;
+}
+
+#else /* not WIN32 */
+
+int codepageMap(int cp, int *map)
+{
+  return 0;
+}
+
+int codepageConvert(int cp, const char *p)
+{
+  return -1;
+}
+
+#endif /* not WIN32 */
Index: xc/extras/expat/xmlwf/codepage.h
diff -u /dev/null xc/extras/expat/xmlwf/codepage.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:27 2003
+++ xc/extras/expat/xmlwf/codepage.h	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,7 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+int codepageMap(int cp, int *map);
+int codepageConvert(int cp, const char *p);
Index: xc/extras/expat/xmlwf/ct.c
diff -u /dev/null xc/extras/expat/xmlwf/ct.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/ct.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,145 @@
+#define CHARSET_MAX 41
+
+static
+const char *getTok(const char **pp)
+{
+  enum { inAtom, inString, init, inComment };
+  int state = init;
+  const char *tokStart = 0;
+  for (;;) {
+    switch (**pp) {
+    case '\0':
+      return 0;
+    case ' ':
+    case '\r':
+    case '\t':
+    case '\n':
+      if (state == inAtom)
+	return tokStart;
+      break;
+    case '(':
+      if (state == inAtom)
+	return tokStart;
+      if (state != inString)
+	state++;
+      break;
+    case ')':
+      if (state > init)
+	--state;
+      else if (state != inString)
+	return 0;
+      break;
+    case ';':
+    case '/':
+    case '=':
+      if (state == inAtom)
+	return tokStart;
+      if (state == init)
+	return (*pp)++;
+      break;
+    case '\\':
+      ++*pp;
+      if (**pp == '\0')
+	return 0;
+      break;
+    case '"':
+      switch (state) {
+      case inString:
+	++*pp;
+	return tokStart;
+      case inAtom:
+	return tokStart;
+      case init:
+	tokStart = *pp;
+	state = inString;
+	break;
+      }
+      break;
+    default:
+      if (state == init) {
+	tokStart = *pp;
+	state = inAtom;
+      }
+      break;
+    }
+    ++*pp;
+  }
+  /* not reached */
+}
+
+/* key must be lowercase ASCII */
+
+static
+int matchkey(const char *start, const char *end, const char *key)
+{
+  if (!start)
+    return 0;
+  for (; start != end; start++, key++)
+    if (*start != *key && *start != 'A' + (*key - 'a'))
+      return 0;
+  return *key == '\0';
+}
+
+void getXMLCharset(const char *buf, char *charset)
+{
+  const char *next, *p;
+
+  charset[0] = '\0';
+  next = buf;
+  p = getTok(&next);
+  if (matchkey(p, next, "text"))
+    strcpy(charset, "us-ascii");
+  else if (!matchkey(p, next, "application"))
+    return;
+  p = getTok(&next);
+  if (!p || *p != '/')
+    return;
+  p = getTok(&next);
+  if (matchkey(p, next, "xml"))
+    isXml = 1;
+  p = getTok(&next);
+  while (p) {
+    if (*p == ';') {
+      p = getTok(&next);
+      if (matchkey(p, next, "charset")) {
+	p = getTok(&next);
+	if (p && *p == '=') {
+	  p = getTok(&next);
+	  if (p) {
+	    char *s = charset;
+	    if (*p == '"') {
+	      while (++p != next - 1) {
+		if (*p == '\\')
+		  ++p;
+		if (s == charset + CHARSET_MAX - 1) {
+		  charset[0] = '\0';
+		  break;
+		}
+		*s++ = *p;
+	      }
+	      *s++ = '\0';
+	    }
+	    else {
+	      if (next - p > CHARSET_MAX - 1)
+		break;
+	      while (p != next)
+		*s++ = *p++;
+	      *s = 0;
+	      break;
+	    }
+	  }
+	}
+      }
+    }
+  else
+    p = getTok(&next);
+  }
+}
+
+int main(int argc, char **argv)
+{
+  char buf[CHARSET_MAX];
+  getXMLCharset(argv[1], buf);
+  printf("charset = \"%s\"\n", buf);
+  return 0;
+}
Index: xc/extras/expat/xmlwf/filemap.h
diff -u /dev/null xc/extras/expat/xmlwf/filemap.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/filemap.h	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,17 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+
+#include <stddef.h>
+
+#ifdef XML_UNICODE
+int filemap(const wchar_t *name,
+	    void (*processor)(const void *, size_t, const wchar_t *, void *arg),
+	    void *arg);
+#else
+int filemap(const char *name,
+	    void (*processor)(const void *, size_t, const char *, void *arg),
+	    void *arg);
+#endif
Index: xc/extras/expat/xmlwf/readfilemap.c
diff -u /dev/null xc/extras/expat/xmlwf/readfilemap.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/readfilemap.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,74 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifndef S_ISREG
+#ifndef S_IFREG
+#define S_IFREG _S_IFREG
+#endif
+#ifndef S_IFMT
+#define S_IFMT _S_IFMT
+#endif
+#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#endif /* not S_ISREG */
+
+#ifndef O_BINARY
+#ifdef _O_BINARY
+#define O_BINARY _O_BINARY
+#else
+#define O_BINARY 0
+#endif
+#endif
+
+int filemap(const char *name,
+	    void (*processor)(const void *, size_t, const char *, void *arg),
+	    void *arg)
+{
+  size_t nbytes;
+  int fd;
+  int n;
+  struct stat sb;
+  void *p;
+
+  fd = open(name, O_RDONLY|O_BINARY);
+  if (fd < 0) {
+    perror(name);
+    return 0;
+  }
+  if (fstat(fd, &sb) < 0) {
+    perror(name);
+    return 0;
+  }
+  if (!S_ISREG(sb.st_mode)) {
+    fprintf(stderr, "%s: not a regular file\n", name);
+    return 0;
+  }
+  nbytes = sb.st_size;
+  p = malloc(nbytes);
+  if (!p) {
+    fprintf(stderr, "%s: out of memory\n", name);
+    return 0;
+  }
+  n = read(fd, p, nbytes);
+  if (n < 0) {
+    perror(name);
+    close(fd);
+    return 0;
+  }
+  if (n != nbytes) {
+    fprintf(stderr, "%s: read unexpected number of bytes\n", name);
+    close(fd);
+    return 0;
+  }
+  processor(p, nbytes, name, arg);
+  free(p);
+  close(fd);
+  return 1;
+}
Index: xc/extras/expat/xmlwf/unixfilemap.c
diff -u /dev/null xc/extras/expat/xmlwf/unixfilemap.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/unixfilemap.c	Mon Feb 18 16:44:22 2002
@@ -0,0 +1,58 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
+
+#include "filemap.h"
+
+int filemap(const char *name,
+	    void (*processor)(const void *, size_t, const char *, void *arg),
+	    void *arg)
+{
+  int fd;
+  size_t nbytes;
+  struct stat sb;
+  void *p;
+
+  fd = open(name, O_RDONLY);
+  if (fd < 0) {
+    perror(name);
+    return 0;
+  }
+  if (fstat(fd, &sb) < 0) {
+    perror(name);
+    close(fd);
+    return 0;
+  }
+  if (!S_ISREG(sb.st_mode)) {
+    close(fd);
+    fprintf(stderr, "%s: not a regular file\n", name);
+    return 0;
+  }
+  
+  nbytes = sb.st_size;
+  p = (void *)mmap((caddr_t)0, (size_t)nbytes, PROT_READ,
+		   MAP_FILE|MAP_PRIVATE, fd, (off_t)0);
+  if (p == (void *)-1) {
+    perror(name);
+    close(fd);
+    return 0;
+  }
+  processor(p, nbytes, name, arg);
+  munmap((caddr_t)p, nbytes);
+  close(fd);
+  return 1;
+}
Index: xc/extras/expat/xmlwf/wfcheck.c
diff -u /dev/null xc/extras/expat/xmlwf/wfcheck.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/wfcheck.c	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,953 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "wfcheck.h"
+#include "hashtable.h"
+
+#include "xmltok.h"
+#include "xmlrole.h"
+
+typedef struct {
+  const char *name;
+  const char *textPtr;
+  size_t textLen;
+  const char *docTextPtr;
+  const char *systemId;
+  const char *publicId;
+  const char *notation;
+  char open;
+  char wfInContent;
+  char wfInAttribute;
+  char magic;
+} ENTITY;
+
+#define INIT_BLOCK_SIZE 1024
+
+typedef struct block {
+  struct block *next;
+  char s[1];
+} BLOCK;
+
+typedef struct {
+  BLOCK *blocks;
+  const char *end;
+  char *ptr;
+  char *start;
+} STRING_POOL;
+
+typedef struct {
+  HASH_TABLE generalEntities;
+  HASH_TABLE paramEntities;
+  STRING_POOL pool;
+  int containsRef;
+  int standalone;
+  char *groupConnector;
+  size_t groupSize;
+} DTD;
+
+typedef struct {
+  DTD dtd;
+  size_t stackSize;
+  const char **startName;
+  int attsSize;
+  ATTRIBUTE *atts;
+} CONTEXT;
+
+static void poolInit(STRING_POOL *);
+static void poolDestroy(STRING_POOL *);
+static const char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+			      const char *ptr, const char *end);
+static const char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+			    const char *ptr, const char *end);
+static int poolGrow(STRING_POOL *);
+static int dtdInit(DTD *);
+static void dtdDestroy(DTD *);
+static int contextInit(CONTEXT *);
+static void contextDestroy(CONTEXT *);
+
+#define poolStart(pool) ((pool)->start)
+#define poolDiscard(pool) ((pool)->ptr = (pool)->start)
+#define poolFinish(pool) ((pool)->start = (pool)->ptr)
+
+static enum WfCheckResult
+checkProlog(DTD *, const char *s, const char *end, const char **, const ENCODING **enc);
+static enum WfCheckResult
+checkContent(size_t level, CONTEXT *context, const ENCODING *enc,
+  	     const char *s, const char *end, const char **badPtr);
+static enum WfCheckResult
+checkGeneralTextEntity(CONTEXT *context,
+		       const char *s, const char *end,
+		       const char **nextPtr,
+		       const ENCODING **enc);
+static enum WfCheckResult
+checkAttributeValue(DTD *, const ENCODING *, const char *, const char *, const char **);
+static enum WfCheckResult
+checkAttributeUniqueness(CONTEXT *context, const ENCODING *enc, int nAtts,
+			 const char **badPtr);
+static enum WfCheckResult
+checkParsedEntities(CONTEXT *context, const char **badPtr);
+
+static
+enum WfCheckResult storeEntity(DTD *dtd,
+			       const ENCODING *enc,
+			       int isParam,
+			       const char *entityNamePtr,
+			       const char *entityNameEnd,
+			       const char *entityTextPtr,
+			       const char *entityTextEnd,
+			       const char **badPtr);
+
+
+enum WfCheckResult
+wfCheck(enum EntityType entityType, const char *s, size_t n,
+	const char **badPtr, unsigned long *badLine, unsigned long *badCol)
+{
+  CONTEXT context;
+  const ENCODING *enc;
+  const char *start = s;
+  const char *end = s + n;
+  const char *next = 0;
+  enum WfCheckResult result;
+
+  if (!contextInit(&context)) {
+    contextDestroy(&context);
+    return noMemory;
+  }
+  if (entityType == documentEntity) {
+    result = checkProlog(&context.dtd, s, end, &next, &enc);
+    s = next;
+    if (!result) {
+      result = checkParsedEntities(&context, &next);
+      s = next;
+      if (!result) {
+	result = checkContent(0, &context, enc, s, end, &next);
+	s = next;
+      }
+    }
+  }
+  else {
+    result = checkGeneralTextEntity(&context, s, end, &next, &enc);
+    s = next;
+  }
+  if (result && s) {
+    POSITION pos;
+    memset(&pos, 0, sizeof(POSITION));
+    XmlUpdatePosition(enc, start, s, &pos);
+    *badPtr = s;
+    *badLine = pos.lineNumber;
+    *badCol = pos.columnNumber;
+  }
+  contextDestroy(&context);
+  return result;
+}
+
+static
+int contextInit(CONTEXT *p)
+{
+  p->stackSize = 1024;
+  p->startName = malloc(p->stackSize * sizeof(char *));
+  p->attsSize = 1024;
+  p->atts = malloc(p->attsSize * sizeof(ATTRIBUTE));
+  return dtdInit(&(p->dtd)) && p->atts && p->startName;
+}
+
+static
+void contextDestroy(CONTEXT *p)
+{
+  dtdDestroy(&(p->dtd));
+  free((void *)p->startName);
+  free((void *)p->atts);
+}
+
+static enum WfCheckResult
+checkContent(size_t level, CONTEXT *context, const ENCODING *enc,
+	     const char *s, const char *end, const char **badPtr)
+{
+  size_t startLevel = level;
+  const char *next;
+  int tok = XmlContentTok(enc, s, end, &next);
+  for (;;) {
+    switch (tok) {
+    case XML_TOK_TRAILING_CR:
+    case XML_TOK_NONE:
+      if (startLevel > 0) {
+	if (level != startLevel) {
+	  *badPtr = s;
+	  return asyncEntity;
+        }
+	return wellFormed;
+      }
+      *badPtr = s;
+      return noElements;
+    case XML_TOK_INVALID:
+      *badPtr = next;
+      return invalidToken;
+    case XML_TOK_PARTIAL:
+      *badPtr = s;
+      return unclosedToken;
+    case XML_TOK_PARTIAL_CHAR:
+      *badPtr = s;
+      return partialChar;
+    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
+      break;
+    case XML_TOK_ENTITY_REF:
+      {
+	const char *name = poolStoreString(&context->dtd.pool, enc,
+					   s + enc->minBytesPerChar,
+					   next - enc->minBytesPerChar);
+	ENTITY *entity = (ENTITY *)lookup(&context->dtd.generalEntities, name, 0);
+	poolDiscard(&context->dtd.pool);
+	if (!entity) {
+	  if (!context->dtd.containsRef || context->dtd.standalone) {
+	    *badPtr = s;
+	    return undefinedEntity;
+	  }
+	  break;
+	}
+	if (entity->wfInContent)
+	  break;
+	if (entity->open) {
+	  *badPtr = s;
+	  return recursiveEntityRef;
+	}
+	if (entity->notation) {
+	  *badPtr = s;
+	  return binaryEntityRef;
+	}
+	if (entity) {
+	  if (entity->textPtr) {
+	    enum WfCheckResult result;
+	    const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
+	    entity->open = 1;
+	    result = checkContent(level, context, internalEnc,
+				  entity->textPtr, entity->textPtr + entity->textLen,
+				  badPtr);
+	    entity->open = 0;
+	    if (result && *badPtr) {
+	      *badPtr = s;
+	      return result;
+	    }
+	    entity->wfInContent = 1;
+	  }
+	}
+	break;
+      }
+    case XML_TOK_START_TAG_NO_ATTS:
+      if (level == context->stackSize) {
+	context->startName
+	  = realloc((void *)context->startName, (context->stackSize *= 2) * sizeof(char *));
+	if (!context->startName)
+	  return noMemory;
+      }
+      context->startName[level++] = s + enc->minBytesPerChar;
+      break;
+    case XML_TOK_START_TAG_WITH_ATTS:
+      if (level == context->stackSize) {
+	context->startName = realloc((void *)context->startName, (context->stackSize *= 2) * sizeof(char *));
+	if (!context->startName)
+	  return noMemory;
+      }
+      context->startName[level++] = s + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
+      {
+	int i;
+	int n = XmlGetAttributes(enc, s, context->attsSize, context->atts);
+	if (n > context->attsSize) {
+	  context->attsSize = 2*n;
+	  context->atts = realloc((void *)context->atts, context->attsSize * sizeof(ATTRIBUTE));
+	  if (!context->atts)
+	    return noMemory;
+	  XmlGetAttributes(enc, s, n, context->atts);
+	}
+	for (i = 0; i < n; i++) {
+	  if (!context->atts[i].normalized) {
+	    enum WfCheckResult result
+	      = checkAttributeValue(&context->dtd, enc,
+			  	    context->atts[i].valuePtr,
+				    context->atts[i].valueEnd,
+				    badPtr);
+	    if (result)
+	      return result;
+	  }
+	}
+	if (i > 1) {
+	  enum WfCheckResult result = checkAttributeUniqueness(context, enc, n, badPtr);
+	  if (result)
+	    return result;
+	}
+      }
+      break;
+    case XML_TOK_END_TAG:
+      if (level == startLevel) {
+        *badPtr = s;
+        return asyncEntity;
+      }
+      --level;
+      if (!XmlSameName(enc, context->startName[level], s + enc->minBytesPerChar * 2)) {
+	*badPtr = s;
+	return tagMismatch;
+      }
+      break;
+    case XML_TOK_CHAR_REF:
+      if (XmlCharRefNumber(enc, s) < 0) {
+	*badPtr = s;
+	return badCharRef;
+      }
+      break;
+    case XML_TOK_XML_DECL:
+      *badPtr = s;
+      return misplacedXmlPi;
+    }
+    s = next;
+    if (level == 0) {
+      do {
+	tok = XmlPrologTok(enc, s, end, &next);
+	switch (tok) {
+	case XML_TOK_TRAILING_CR:
+	case XML_TOK_NONE:
+	  return wellFormed;
+	case XML_TOK_PROLOG_S:
+	case XML_TOK_COMMENT:
+	case XML_TOK_PI:
+	  s = next;
+	  break;
+	default:
+	  if (tok > 0) {
+	    *badPtr = s;
+	    return junkAfterDocElement;
+	  }
+	  break;
+	}
+      } while (tok > 0);
+    }
+    else
+      tok = XmlContentTok(enc, s, end, &next);
+  }
+  /* not reached */
+}
+
+static
+int attcmp(const void *p1, const void *p2)
+{
+  const ATTRIBUTE *a1 = p1;
+  const ATTRIBUTE *a2 = p2;
+  size_t n1 = a1->valuePtr - a1->name;
+  size_t n2 = a2->valuePtr - a2->name;
+
+  if (n1 == n2) {
+    int n = memcmp(a1->name, a2->name, n1);
+    if (n)
+      return n;
+    /* Sort identical attribute names by position, so that we always
+       report the first duplicate attribute. */
+    if (a1->name < a2->name)
+      return -1;
+    else if (a1->name > a2->name)
+      return 1;
+    else
+      return 0;
+  }
+  else if (n1 < n2)
+    return -1;
+  else
+    return 1;
+}
+
+/* Note that this trashes the attribute values. */
+
+static enum WfCheckResult
+checkAttributeUniqueness(CONTEXT *context, const ENCODING *enc, int nAtts,
+			 const char **badPtr)
+{
+#define QSORT_MIN_ATTS 10
+  if (nAtts < QSORT_MIN_ATTS) {
+    int i;
+    for (i = 1; i < nAtts; i++) {
+      int j;
+      for (j = 0; j < i; j++) {
+	if (XmlSameName(enc, context->atts[i].name, context->atts[j].name)) {
+	  *badPtr = context->atts[i].name;
+  	  return duplicateAttribute;
+	}
+      }
+    }
+  }
+  else {
+    int i;
+    const char *dup = 0;
+    /* Store the end of the name in valuePtr */
+    for (i = 0; i < nAtts; i++) {
+      ATTRIBUTE *a = context->atts + i;
+      a->valuePtr = a->name + XmlNameLength(enc, a->name);
+    }
+    qsort(context->atts, nAtts, sizeof(ATTRIBUTE), attcmp);
+    for (i = 1; i < nAtts; i++) {
+      ATTRIBUTE *a = context->atts + i;
+      if (XmlSameName(enc, a->name, a[-1].name)) {
+	if (!dup || a->name < dup)
+	  dup = a->name;
+      }
+    }
+    if (dup) {
+      *badPtr = dup;
+      return duplicateAttribute;
+    }
+  }
+  return wellFormed;
+}
+
+static enum WfCheckResult
+checkProlog(DTD *dtd, const char *s, const char *end,
+	    const char **nextPtr, const ENCODING **enc)
+{
+  const char *entityNamePtr, *entityNameEnd;
+  int entityIsParam;
+  PROLOG_STATE state;
+  ENTITY *entity;
+  INIT_ENCODING initEnc;
+  XmlInitEncoding(&initEnc, enc);
+  XmlPrologStateInit(&state);
+  for (;;) {
+    const char *next;
+    int tok = XmlPrologTok(*enc, s, end, &next);
+    switch (XmlTokenRole(&state, tok, s, next, *enc)) {
+    case XML_ROLE_XML_DECL:
+      {
+	const char *encodingName = 0;
+	const ENCODING *encoding = 0;
+	const char *version;
+	int standalone = -1;
+	if (!XmlParseXmlDecl(0,
+			     *enc,
+			     s,
+			     next,
+			     nextPtr,
+			     &version,
+			     &encodingName,
+			     &encoding,
+			     &standalone))
+	  return syntaxError;
+	if (encoding) {
+	  if (encoding->minBytesPerChar != (*enc)->minBytesPerChar) {
+	    *nextPtr = encodingName;
+	    return incorrectEncoding;
+	  }
+	  *enc = encoding;
+	}
+	else if (encodingName) {
+	  *nextPtr = encodingName;
+	  return unknownEncoding;
+	}
+	if (standalone == 1)
+	  dtd->standalone = 1;
+	break;
+      }
+    case XML_ROLE_DOCTYPE_SYSTEM_ID:
+      dtd->containsRef = 1;
+      break;
+    case XML_ROLE_DOCTYPE_PUBLIC_ID:
+    case XML_ROLE_ENTITY_PUBLIC_ID:
+    case XML_ROLE_NOTATION_PUBLIC_ID:
+      if (!XmlIsPublicId(*enc, s, next, nextPtr))
+	return syntaxError;
+      break;
+    case XML_ROLE_INSTANCE_START:
+      *nextPtr = s;
+      return wellFormed;
+    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
+    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
+      {
+	const char *tem = 0;
+	enum WfCheckResult result
+	  = checkAttributeValue(dtd, *enc, s + (*enc)->minBytesPerChar,
+				next - (*enc)->minBytesPerChar,
+				&tem);
+	if (result) {
+	  if (tem)
+	    *nextPtr = tem;
+	  return result;
+	}
+	break;
+      }
+    case XML_ROLE_ENTITY_VALUE:
+      {
+	enum WfCheckResult result
+	  = storeEntity(dtd,
+			*enc,
+			entityIsParam,
+			entityNamePtr,
+			entityNameEnd,
+			s,
+			next,
+			nextPtr);
+	if (result != wellFormed)
+	  return result;
+      }
+      break;
+    case XML_ROLE_ENTITY_SYSTEM_ID:
+      {
+	const char *name = poolStoreString(&dtd->pool, *enc, entityNamePtr, entityNameEnd);
+	entity = (ENTITY *)lookup(entityIsParam ? &dtd->paramEntities : &dtd->generalEntities,
+				  name, sizeof(ENTITY));
+	if (entity->name != name) {
+	  poolDiscard(&dtd->pool);
+	  entity = 0;
+	}
+	else {
+	  poolFinish(&dtd->pool);
+	  entity->systemId = poolStoreString(&dtd->pool, *enc,
+					     s + (*enc)->minBytesPerChar,
+					     next - (*enc)->minBytesPerChar);
+	  poolFinish(&dtd->pool);
+	}
+      }
+      break;
+    case XML_ROLE_PARAM_ENTITY_REF:
+      {
+	const char *name = poolStoreString(&dtd->pool, *enc,
+					   s + (*enc)->minBytesPerChar,
+					   next - (*enc)->minBytesPerChar);
+	ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
+	poolDiscard(&dtd->pool);
+	if (!entity) {
+	  if (!dtd->containsRef || dtd->standalone) {
+	    *nextPtr = s;
+	    return undefinedEntity;
+	  }
+	}
+      }
+      break;
+    case XML_ROLE_ENTITY_NOTATION_NAME:
+      if (entity) {
+	entity->notation = poolStoreString(&dtd->pool, *enc, s, next);
+	poolFinish(&dtd->pool);
+      }
+      break;
+    case XML_ROLE_GENERAL_ENTITY_NAME:
+      entityNamePtr = s;
+      entityNameEnd = next;
+      entityIsParam = 0;
+      break;
+    case XML_ROLE_PARAM_ENTITY_NAME:
+      entityNamePtr = s;
+      entityNameEnd = next;
+      entityIsParam = 1;
+      break;
+    case XML_ROLE_ERROR:
+      *nextPtr = s;
+      switch (tok) {
+      case XML_TOK_PARAM_ENTITY_REF:
+	return paramEntityRef;
+      case XML_TOK_INVALID:
+	*nextPtr = next;
+	return invalidToken;
+      case XML_TOK_NONE:
+	return noElements;
+      case XML_TOK_PARTIAL:
+	return unclosedToken;
+      case XML_TOK_PARTIAL_CHAR:
+	return partialChar;
+      case XML_TOK_TRAILING_CR:
+	*nextPtr = s + (*enc)->minBytesPerChar;
+	return noElements;
+      case XML_TOK_XML_DECL:
+	return misplacedXmlPi;
+      default:
+	return syntaxError;
+      }
+    case XML_ROLE_GROUP_OPEN:
+      if (state.level >= dtd->groupSize) {
+	if (dtd->groupSize)
+	  dtd->groupConnector = realloc(dtd->groupConnector, dtd->groupSize *= 2);
+	else
+	  dtd->groupConnector = malloc(dtd->groupSize = 32);
+	if (!dtd->groupConnector)
+	  return noMemory;
+      }
+      dtd->groupConnector[state.level] = 0;
+      break;
+    case XML_ROLE_GROUP_SEQUENCE:
+      if (dtd->groupConnector[state.level] == '|') {
+	*nextPtr = s;
+	return syntaxError;
+      }
+      dtd->groupConnector[state.level] = ',';
+      break;
+    case XML_ROLE_GROUP_CHOICE:
+      if (dtd->groupConnector[state.level] == ',') {
+	*nextPtr = s;
+	return syntaxError;
+      }
+      dtd->groupConnector[state.level] = '|';
+      break;
+    case XML_ROLE_NONE:
+      if (tok == XML_TOK_PARAM_ENTITY_REF)
+	dtd->containsRef = 1;
+      break;
+    }
+    s = next;
+  }
+  /* not reached */
+}
+
+static enum WfCheckResult
+checkParsedEntities(CONTEXT *context, const char **badPtr)
+{
+  HASH_TABLE_ITER iter;
+  hashTableIterInit(&iter, &context->dtd.generalEntities);
+  for (;;) {
+    ENTITY *entity = (ENTITY *)hashTableIterNext(&iter);
+    if (!entity)
+      break;
+    if (entity->textPtr && !entity->wfInContent && !entity->magic) {
+      enum WfCheckResult result;
+      const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
+      entity->open = 1;
+      result = checkContent(1, context, internalEnc,
+			    entity->textPtr, entity->textPtr + entity->textLen,
+			    badPtr);
+      entity->open = 0;
+      if (result && *badPtr) {
+	*badPtr = entity->docTextPtr;
+	return result;
+      }
+      entity->wfInContent = 1;
+    }
+  }
+  return wellFormed;
+}
+
+static enum WfCheckResult
+checkGeneralTextEntity(CONTEXT *context,
+		       const char *s, const char *end,
+		       const char **nextPtr,
+		       const ENCODING **enc)
+{
+  INIT_ENCODING initEnc;
+  const char *next;
+  int tok;
+
+  XmlInitEncoding(&initEnc, enc);
+  tok = XmlContentTok(*enc, s, end, &next);
+
+  if (tok == XML_TOK_BOM) {
+    s = next;
+    tok = XmlContentTok(*enc, s, end, &next);
+  }
+  if (tok == XML_TOK_XML_DECL) {
+    const char *encodingName = 0;
+    const ENCODING *encoding = 0;
+    const char *version;
+    if (!XmlParseXmlDecl(1,
+			 *enc,
+			 s,
+			 next,
+			 nextPtr,
+			 &version,
+			 &encodingName,
+			 &encoding,
+			 0))
+      return syntaxError;
+    if (encoding) {
+      if (encoding->minBytesPerChar != (*enc)->minBytesPerChar) {
+	*nextPtr = encodingName;
+	return incorrectEncoding;
+      }
+      *enc = encoding;
+    }
+    else if (encodingName) {
+      *nextPtr = encodingName;
+      return unknownEncoding;
+    }
+    s = next;
+  }
+  context->dtd.containsRef = 1;
+  return checkContent(1, context, *enc, s, end, nextPtr);
+}
+
+static enum WfCheckResult
+checkAttributeValue(DTD *dtd, const ENCODING *enc,
+		    const char *ptr, const char *end, const char **badPtr)
+{
+  for (;;) {
+    const char *next;
+    int tok = XmlAttributeValueTok(enc, ptr, end, &next);
+    switch (tok) {
+    case XML_TOK_TRAILING_CR:
+    case XML_TOK_NONE:
+      return wellFormed;
+    case XML_TOK_INVALID:
+      *badPtr = next;
+      return invalidToken;
+    case XML_TOK_PARTIAL:
+      *badPtr = ptr;
+      return invalidToken;
+    case XML_TOK_CHAR_REF:
+      if (XmlCharRefNumber(enc, ptr) < 0) {
+	*badPtr = ptr;
+	return badCharRef;
+      }
+      break;
+    case XML_TOK_DATA_CHARS:
+    case XML_TOK_DATA_NEWLINE:
+      break;
+    case XML_TOK_ENTITY_REF:
+      {
+	const char *name = poolStoreString(&dtd->pool, enc,
+					   ptr + enc->minBytesPerChar,
+					   next - enc->minBytesPerChar);
+	ENTITY *entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
+	poolDiscard(&dtd->pool);
+	if (!entity) {
+	  if (!dtd->containsRef) {
+	    *badPtr = ptr;
+	    return undefinedEntity;
+	  }
+	  break;
+	}
+	if (entity->wfInAttribute)
+	  break;
+	if (entity->open) {
+	  *badPtr = ptr;
+	  return recursiveEntityRef;
+	}
+	if (entity->notation) {
+	  *badPtr = ptr;
+	  return binaryEntityRef;
+	}
+	if (entity) {
+	  if (entity->textPtr) {
+	    enum WfCheckResult result;
+	    const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
+	    const char *textEnd = entity->textPtr + entity->textLen;
+	    entity->open = 1;
+	    result = checkAttributeValue(dtd, internalEnc, entity->textPtr, textEnd, badPtr);
+	    entity->open = 0;
+	    if (result && *badPtr) {
+	      *badPtr = ptr;
+	      return result;
+	    }
+	    entity->wfInAttribute = 1;
+	  }
+	  else {
+	    *badPtr = ptr;
+	    return attributeExternalEntityRef;
+	  }
+	}
+	break;
+      }
+      break;
+    default:
+      abort();
+    }
+    ptr = next;
+  }
+  /* not reached */
+}
+
+static
+void poolInit(STRING_POOL *pool)
+{
+  pool->blocks = 0;
+  pool->start = 0;
+  pool->ptr = 0;
+  pool->end = 0;
+}
+
+static
+void poolDestroy(STRING_POOL *pool)
+{
+  BLOCK *p = pool->blocks;
+  while (p) {
+    BLOCK *tem = p->next;
+    free(p);
+    p = tem;
+  }
+  pool->blocks = 0;
+  pool->ptr = 0;
+  pool->start = 0;
+  pool->end = 0;
+}
+
+static
+const char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+		       const char *ptr, const char *end)
+{
+  for (;;) {
+    XmlConvert(enc, XML_UTF8_ENCODING, &ptr, end, &(pool->ptr), pool->end);
+    if (ptr == end)
+      break;
+    if (!poolGrow(pool))
+      return 0;
+  }
+  return pool->start;
+}
+
+static
+const char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+			    const char *ptr, const char *end)
+{
+  if (!poolAppend(pool, enc, ptr, end))
+    return 0;
+  if (pool->ptr == pool->end && !poolGrow(pool))
+    return 0;
+  *(pool->ptr)++ = 0;
+  return pool->start;
+}
+
+static
+int poolGrow(STRING_POOL *pool)
+{
+  if (pool->blocks && pool->start == pool->blocks->s) {
+    size_t blockSize = (pool->end - pool->start)*2;
+    pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize);
+    if (!pool->blocks)
+      return 0;
+    pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
+    pool->start = pool->blocks->s;
+    pool->end = pool->start + blockSize;
+  }
+  else {
+    BLOCK *tem;
+    size_t blockSize = pool->end - pool->start;
+    if (blockSize < INIT_BLOCK_SIZE)
+      blockSize = INIT_BLOCK_SIZE;
+    else
+      blockSize *= 2;
+    tem = malloc(offsetof(BLOCK, s) + blockSize);
+    if (!tem)
+      return 0;
+    tem->next = pool->blocks;
+    pool->blocks = tem;
+    memcpy(tem->s, pool->start, pool->ptr - pool->start);
+    pool->ptr = tem->s + (pool->ptr - pool->start);
+    pool->start = tem->s;
+    pool->end = tem->s + blockSize;
+  }
+  return 1;
+}
+
+static int dtdInit(DTD *dtd)
+{
+  static const char *names[] = { "lt", "amp", "gt", "quot", "apos" };
+  static const char chars[] = { '<', '&', '>', '"', '\'' };
+  int i;
+
+  poolInit(&(dtd->pool));
+  hashTableInit(&(dtd->generalEntities));
+  for (i = 0; i < 5; i++) {
+    ENTITY *entity = (ENTITY *)lookup(&(dtd->generalEntities), names[i], sizeof(ENTITY));
+    if (!entity)
+      return 0;
+    entity->textPtr = chars + i;
+    entity->textLen = 1;
+    entity->magic = 1;
+    entity->wfInContent = 1;
+    entity->wfInAttribute = 1;
+  }
+  hashTableInit(&(dtd->paramEntities));
+  dtd->containsRef = 0;
+  dtd->groupSize = 0;
+  dtd->groupConnector = 0;
+  return 1;
+}
+
+static void dtdDestroy(DTD *dtd)
+{
+  poolDestroy(&(dtd->pool));
+  hashTableDestroy(&(dtd->generalEntities));
+  hashTableDestroy(&(dtd->paramEntities));
+  free(dtd->groupConnector);
+}
+
+static
+enum WfCheckResult storeEntity(DTD *dtd,
+			       const ENCODING *enc,
+			       int isParam,
+			       const char *entityNamePtr,
+			       const char *entityNameEnd,
+			       const char *entityTextPtr,
+			       const char *entityTextEnd,
+			       const char **badPtr)
+{
+  ENTITY *entity;
+  const ENCODING *utf8 = XmlGetInternalEncoding(XML_UTF8_ENCODING);
+  STRING_POOL *pool = &(dtd->pool);
+  if (!poolStoreString(pool, enc, entityNamePtr, entityNameEnd))
+    return noMemory;
+  entity = (ENTITY *)lookup(isParam ? &(dtd->paramEntities) : &(dtd->generalEntities),
+			    pool->start,
+			    sizeof(ENTITY));
+  if (entity->name != pool->start) {
+    poolDiscard(pool);
+    entityNamePtr = 0;
+  }
+  else
+    poolFinish(pool);
+  entityTextPtr += enc->minBytesPerChar;
+  entityTextEnd -= enc->minBytesPerChar;
+  entity->docTextPtr = entityTextPtr;
+  for (;;) {
+    const char *next;
+    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
+    switch (tok) {
+    case XML_TOK_PARAM_ENTITY_REF:
+      *badPtr = entityTextPtr;
+      return syntaxError;
+    case XML_TOK_NONE:
+      if (entityNamePtr) {
+	entity->textPtr = pool->start;
+	entity->textLen = pool->ptr - pool->start;
+	poolFinish(pool);
+      }
+      else
+	poolDiscard(pool);
+      return wellFormed;
+    case XML_TOK_ENTITY_REF:
+    case XML_TOK_DATA_CHARS:
+      if (!poolAppend(pool, enc, entityTextPtr, next))
+	return noMemory;
+      break;
+    case XML_TOK_TRAILING_CR:
+      next = entityTextPtr + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_DATA_NEWLINE:
+      if (pool->end == pool->ptr && !poolGrow(pool))
+	return noMemory;
+      *(pool->ptr)++ = '\n';
+      break;
+    case XML_TOK_CHAR_REF:
+      {
+	char buf[XML_MAX_BYTES_PER_CHAR];
+	int i;
+	int n = XmlCharRefNumber(enc, entityTextPtr);
+	if (n < 0) {
+	  *badPtr = entityTextPtr;
+	  return badCharRef;
+	}
+	n = XmlEncode(utf8, n, buf);
+	if (!n) {
+	  *badPtr = entityTextPtr;
+	  return badCharRef;
+	}
+	for (i = 0; i < n; i++) {
+	  if (pool->end == pool->ptr && !poolGrow(pool))
+	    return noMemory;
+	  *(pool->ptr)++ = buf[i];
+	}
+      }
+      break;
+    case XML_TOK_PARTIAL:
+      *badPtr = entityTextPtr;
+      return invalidToken;
+    case XML_TOK_INVALID:
+      *badPtr = next;
+      return invalidToken;
+    default:
+      abort();
+    }
+    entityTextPtr = next;
+  }
+  /* not reached */
+}
Index: xc/extras/expat/xmlwf/wfcheck.h
diff -u /dev/null xc/extras/expat/xmlwf/wfcheck.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/wfcheck.h	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,38 @@
+
+#include <stddef.h>
+
+enum WfCheckResult {
+  wellFormed,
+  noMemory,
+  syntaxError,
+  noElements,
+  invalidToken,
+  unclosedToken,
+  partialChar,
+  tagMismatch,
+  duplicateAttribute,
+  junkAfterDocElement,
+  paramEntityRef,
+  undefinedEntity,
+  recursiveEntityRef,
+  asyncEntity,
+  badCharRef,
+  binaryEntityRef,
+  attributeExternalEntityRef,
+  misplacedXmlPi,
+  unknownEncoding,
+  incorrectEncoding
+};
+
+enum EntityType {
+  documentEntity,
+  generalTextEntity
+};
+
+enum WfCheckResult wfCheck(enum EntityType entityType,
+			   const char *s, size_t n,
+			   const char **errorPtr,
+			   unsigned long *errorLineNumber,
+			   unsigned long *errorColNumber);
+const char *wfCheckMessage(enum WfCheckResult);
+
Index: xc/extras/expat/xmlwf/wfcheckmessage.c
diff -u /dev/null xc/extras/expat/xmlwf/wfcheckmessage.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/wfcheckmessage.c	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,30 @@
+#include "wfcheck.h"
+
+const char *wfCheckMessage(enum WfCheckResult result)
+{
+  static const char *message[] = {
+    0,
+    "out of memory",
+    "syntax error",
+    "no element found",
+    "not well-formed",
+    "unclosed token",
+    "unclosed token",
+    "mismatched tag",
+    "duplicate attribute",
+    "junk after document element",
+    "parameter entity reference not allowed within declaration in internal subset",
+    "undefined entity",
+    "recursive entity reference",
+    "asynchronous entity",
+    "reference to invalid character number",
+    "reference to binary entity",
+    "reference to external entity in attribute",
+    "xml pi not at start of external entity",
+    "unknown encoding",
+    "encoding specified in XML declaration is incorrect"
+  };
+  if (result > 0 && result < sizeof(message)/sizeof(message[0]))
+    return message[result];
+  return 0;
+}
Index: xc/extras/expat/xmlwf/win32filemap.c
diff -u /dev/null xc/extras/expat/xmlwf/win32filemap.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/win32filemap.c	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,95 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#define STRICT 1
+#define WIN32_LEAN_AND_MEAN 1
+
+#ifdef XML_UNICODE_WCHAR_T
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+#endif
+
+#ifdef XML_UNICODE
+#define UNICODE
+#define _UNICODE
+#endif /* XML_UNICODE */
+#include <windows.h>
+#include <stdio.h>
+#include <tchar.h>
+#include "filemap.h"
+
+static void win32perror(const TCHAR *);
+
+int filemap(const TCHAR *name,
+	    void (*processor)(const void *, size_t, const TCHAR *, void *arg),
+	    void *arg)
+{
+  HANDLE f;
+  HANDLE m;
+  DWORD size;
+  DWORD sizeHi;
+  void *p;
+
+  f = CreateFile(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+			  FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+  if (f == INVALID_HANDLE_VALUE) {
+    win32perror(name);
+    return 0;
+  }
+  size = GetFileSize(f, &sizeHi);
+  if (size == (DWORD)-1) {
+    win32perror(name);
+    return 0;
+  }
+  if (sizeHi) {
+    _ftprintf(stderr, _T("%s: bigger than 2Gb\n"), name);
+    return 0;
+  }
+  /* CreateFileMapping barfs on zero length files */
+  if (size == 0) {
+    static const char c = '\0';
+    processor(&c, 0, name, arg);
+    CloseHandle(f);
+    return 1;
+  }
+  m = CreateFileMapping(f, NULL, PAGE_READONLY, 0, 0, NULL);
+  if (m == NULL) {
+    win32perror(name);
+    CloseHandle(f);
+    return 0;
+  }
+  p = MapViewOfFile(m, FILE_MAP_READ, 0, 0, 0);
+  if (p == NULL) {
+    win32perror(name);
+    CloseHandle(m);
+    CloseHandle(f);
+    return 0;
+  }
+  processor(p, size, name, arg); 
+  UnmapViewOfFile(p);
+  CloseHandle(m);
+  CloseHandle(f);
+  return 1;
+}
+
+static
+void win32perror(const TCHAR *s)
+{
+  LPVOID buf;
+  if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+		    NULL,
+		    GetLastError(),
+		    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		    (LPTSTR) &buf,
+		    0,
+		    NULL)) {
+    _ftprintf(stderr, _T("%s: %s"), s, buf);
+    fflush(stderr);
+    LocalFree(buf);
+  }
+  else
+    _ftprintf(stderr, _T("%s: unknown Windows error\n"), s);
+}
Index: xc/extras/expat/xmlwf/xmlfile.c
diff -u /dev/null xc/extras/expat/xmlwf/xmlfile.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmlfile.c	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,217 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <fcntl.h>
+#include "expat.h"
+#include "xmlfile.h"
+#include "xmltchar.h"
+#include "filemap.h"
+
+#ifdef _MSC_VER
+#include <io.h>
+#endif
+
+#ifdef _POSIX_SOURCE
+#include <unistd.h>
+#endif
+
+#ifndef O_BINARY
+#ifdef _O_BINARY
+#define O_BINARY _O_BINARY
+#else
+#define O_BINARY 0
+#endif
+#endif
+
+#ifdef _DEBUG
+#define READ_SIZE 16
+#else
+#define READ_SIZE (1024*8)
+#endif
+
+
+
+typedef struct {
+  XML_Parser parser;
+  int *retPtr;
+} PROCESS_ARGS;
+
+static
+void reportError(XML_Parser parser, const XML_Char *filename)
+{
+  int code = XML_GetErrorCode(parser);
+  const XML_Char *message = XML_ErrorString(code);
+  if (message)
+    ftprintf(stdout, T("%s:%d:%d: %s\n"),
+	     filename,
+	     XML_GetErrorLineNumber(parser),
+	     XML_GetErrorColumnNumber(parser),
+	     message);
+  else
+    ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
+}
+
+static
+void processFile(const void *data,
+		 size_t size,
+		 const XML_Char *filename,
+		 void *args)
+{
+  XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
+  int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
+  if (!XML_Parse(parser, data, size, 1)) {
+    reportError(parser, filename);
+    *retPtr = 0;
+  }
+  else
+    *retPtr = 1;
+}
+
+#ifdef WIN32
+
+static
+int isAsciiLetter(XML_Char c)
+{
+  return (T('a') <= c && c <= T('z')) || (T('A') <= c && c <= T('Z'));
+}
+
+#endif /* WIN32 */
+
+static
+const XML_Char *resolveSystemId(const XML_Char *base, const XML_Char *systemId, XML_Char **toFree)
+{
+  XML_Char *s;
+  *toFree = 0;
+  if (!base
+      || *systemId == T('/')
+#ifdef WIN32
+      || *systemId == T('\\')
+      || (isAsciiLetter(systemId[0]) && systemId[1] == T(':'))
+#endif
+     )
+    return systemId;
+  *toFree = (XML_Char *)malloc((tcslen(base) + tcslen(systemId) + 2)*sizeof(XML_Char));
+  if (!*toFree)
+    return systemId;
+  tcscpy(*toFree, base);
+  s = *toFree;
+  if (tcsrchr(s, T('/')))
+    s = tcsrchr(s, T('/')) + 1;
+#ifdef WIN32
+  if (tcsrchr(s, T('\\')))
+    s = tcsrchr(s, T('\\')) + 1;
+#endif
+  tcscpy(s, systemId);
+  return *toFree;
+}
+
+static
+int externalEntityRefFilemap(XML_Parser parser,
+			     const XML_Char *context,
+			     const XML_Char *base,
+			     const XML_Char *systemId,
+			     const XML_Char *publicId)
+{
+  int result;
+  XML_Char *s;
+  const XML_Char *filename;
+  XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
+  PROCESS_ARGS args;
+  args.retPtr = &result;
+  args.parser = entParser;
+  filename = resolveSystemId(base, systemId, &s);
+  XML_SetBase(entParser, filename);
+  if (!filemap(filename, processFile, &args))
+    result = 0;
+  free(s);
+  XML_ParserFree(entParser);
+  return result;
+}
+
+static
+int processStream(const XML_Char *filename, XML_Parser parser)
+{
+  int fd = topen(filename, O_BINARY|O_RDONLY);
+  if (fd < 0) {
+    tperror(filename);
+    return 0;
+  }
+  for (;;) {
+    int nread;
+    char *buf = XML_GetBuffer(parser, READ_SIZE);
+    if (!buf) {
+      close(fd);
+      ftprintf(stderr, T("%s: out of memory\n"), filename);
+      return 0;
+    }
+    nread = read(fd, buf, READ_SIZE);
+    if (nread < 0) {
+      tperror(filename);
+      close(fd);
+      return 0;
+    }
+    if (!XML_ParseBuffer(parser, nread, nread == 0)) {
+      reportError(parser, filename);
+      close(fd);
+      return 0;
+    }
+    if (nread == 0) {
+      close(fd);
+      break;;
+    }
+  }
+  return 1;
+}
+
+static
+int externalEntityRefStream(XML_Parser parser,
+			    const XML_Char *context,
+			    const XML_Char *base,
+			    const XML_Char *systemId,
+			    const XML_Char *publicId)
+{
+  XML_Char *s;
+  const XML_Char *filename;
+  int ret;
+  XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
+  filename = resolveSystemId(base, systemId, &s);
+  XML_SetBase(entParser, filename);
+  ret = processStream(filename, entParser);
+  free(s);
+  XML_ParserFree(entParser);
+  return ret;
+}
+
+int XML_ProcessFile(XML_Parser parser,
+		    const XML_Char *filename,
+		    unsigned flags)
+{
+  int result;
+
+  if (!XML_SetBase(parser, filename)) {
+    ftprintf(stderr, T("%s: out of memory"), filename);
+    exit(1);
+  }
+
+  if (flags & XML_EXTERNAL_ENTITIES)
+      XML_SetExternalEntityRefHandler(parser,
+	                              (flags & XML_MAP_FILE)
+				      ? externalEntityRefFilemap
+				      : externalEntityRefStream);
+  if (flags & XML_MAP_FILE) {
+    PROCESS_ARGS args;
+    args.retPtr = &result;
+    args.parser = parser;
+    if (!filemap(filename, processFile, &args))
+      result = 0;
+  }
+  else
+    result = processStream(filename, parser);
+  return result;
+}
Index: xc/extras/expat/xmlwf/xmlfile.h
diff -u /dev/null xc/extras/expat/xmlwf/xmlfile.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmlfile.h	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,11 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#define XML_MAP_FILE 01
+#define XML_EXTERNAL_ENTITIES 02
+
+extern int XML_ProcessFile(XML_Parser parser,
+			   const XML_Char *filename,
+			   unsigned flags);
Index: xc/extras/expat/xmlwf/xmlmime.c
diff -u /dev/null xc/extras/expat/xmlwf/xmlmime.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmlmime.c	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,161 @@
+#include <string.h>
+#include "xmlmime.h"
+
+static
+const char *getTok(const char **pp)
+{
+  /* inComment means one level of nesting; inComment+1 means two levels etc */
+  enum { inAtom, inString, init, inComment };
+  int state = init;
+  const char *tokStart = 0;
+  for (;;) {
+    switch (**pp) {
+    case '\0':
+      if (state == inAtom)
+	return tokStart;
+      return 0;
+    case ' ':
+    case '\r':
+    case '\t':
+    case '\n':
+      if (state == inAtom)
+	return tokStart;
+      break;
+    case '(':
+      if (state == inAtom)
+	return tokStart;
+      if (state != inString)
+	state++;
+      break;
+    case ')':
+      if (state > init)
+	--state;
+      else if (state != inString)
+	return 0;
+      break;
+    case ';':
+    case '/':
+    case '=':
+      if (state == inAtom)
+	return tokStart;
+      if (state == init)
+	return (*pp)++;
+      break;
+    case '\\':
+      ++*pp;
+      if (**pp == '\0')
+	return 0;
+      break;
+    case '"':
+      switch (state) {
+      case inString:
+	++*pp;
+	return tokStart;
+      case inAtom:
+	return tokStart;
+      case init:
+	tokStart = *pp;
+	state = inString;
+	break;
+      }
+      break;
+    default:
+      if (state == init) {
+	tokStart = *pp;
+	state = inAtom;
+      }
+      break;
+    }
+    ++*pp;
+  }
+  /* not reached */
+}
+
+/* key must be lowercase ASCII */
+
+static
+int matchkey(const char *start, const char *end, const char *key)
+{
+  if (!start)
+    return 0;
+  for (; start != end; start++, key++)
+    if (*start != *key && *start != 'A' + (*key - 'a'))
+      return 0;
+  return *key == '\0';
+}
+
+void getXMLCharset(const char *buf, char *charset)
+{
+  const char *next, *p;
+
+  charset[0] = '\0';
+  next = buf;
+  p = getTok(&next);
+  if (matchkey(p, next, "text"))
+    strcpy(charset, "us-ascii");
+  else if (!matchkey(p, next, "application"))
+    return;
+  p = getTok(&next);
+  if (!p || *p != '/')
+    return;
+  p = getTok(&next);
+#if 0
+  if (!matchkey(p, next, "xml") && charset[0] == '\0')
+    return;
+#endif
+  p = getTok(&next);
+  while (p) {
+    if (*p == ';') {
+      p = getTok(&next);
+      if (matchkey(p, next, "charset")) {
+	p = getTok(&next);
+	if (p && *p == '=') {
+	  p = getTok(&next);
+	  if (p) {
+	    char *s = charset;
+	    if (*p == '"') {
+	      while (++p != next - 1) {
+		if (*p == '\\')
+		  ++p;
+		if (s == charset + CHARSET_MAX - 1) {
+		  charset[0] = '\0';
+		  break;
+		}
+		*s++ = *p;
+	      }
+	      *s++ = '\0';
+	    }
+	    else {
+	      if (next - p > CHARSET_MAX - 1)
+		break;
+	      while (p != next)
+		*s++ = *p++;
+	      *s = 0;
+	      break;
+	    }
+	  }
+	}
+	break;
+      }
+    }
+  else
+    p = getTok(&next);
+  }
+}
+
+#ifdef TEST
+
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+  char buf[CHARSET_MAX];
+  if (argc <= 1)
+    return 1;
+  printf("%s\n", argv[1]);
+  getXMLCharset(argv[1], buf);
+  printf("charset=\"%s\"\n", buf);
+  return 0;
+}
+
+#endif /* TEST */
Index: xc/extras/expat/xmlwf/xmlmime.h
diff -u /dev/null xc/extras/expat/xmlwf/xmlmime.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmlmime.h	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,19 @@
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Registered charset names are at most 40 characters long. */
+
+#define CHARSET_MAX 41
+
+/* Figure out the charset to use from the ContentType.
+buf contains the body of the header field (the part after "Content-Type:").
+charset gets the charset to use.  It must be at least CHARSET_MAX chars long.
+charset will be empty if the default charset should be used. */
+
+void getXMLCharset(const char *buf, char *charset);
+
+#ifdef __cplusplus
+}
+#endif
Index: xc/extras/expat/xmlwf/xmltchar.h
diff -u /dev/null xc/extras/expat/xmlwf/xmltchar.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmltchar.h	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,36 @@
+#ifdef XML_UNICODE
+#ifndef XML_UNICODE_WCHAR_T
+#error xmlwf requires a 16-bit Unicode-compatible wchar_t 
+#endif
+#define T(x) L ## x
+#define ftprintf fwprintf
+#define tfopen _wfopen
+#define fputts fputws
+#define puttc putwc
+#define tcscmp wcscmp
+#define tcscpy wcscpy
+#define tcscat wcscat
+#define tcschr wcschr
+#define tcsrchr wcsrchr
+#define tcslen wcslen
+#define tperror _wperror
+#define topen _wopen
+#define tmain wmain
+#define tremove _wremove
+#else /* not XML_UNICODE */
+#define T(x) x
+#define ftprintf fprintf
+#define tfopen fopen
+#define fputts fputs
+#define puttc putc
+#define tcscmp strcmp
+#define tcscpy strcpy
+#define tcscat strcat
+#define tcschr strchr
+#define tcsrchr strrchr
+#define tcslen strlen
+#define tperror perror
+#define topen open
+#define tmain main
+#define tremove remove
+#endif /* not XML_UNICODE */
Index: xc/extras/expat/xmlwf/xmlurl.h
diff -u /dev/null xc/extras/expat/xmlwf/xmlurl.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmlurl.h	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,13 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int XML_URLInit();
+void XML_URLUninit();
+int XML_ProcessURL(XML_Parser parser,
+		   const XML_Char *url,
+		   unsigned flags);
+
+#ifdef __cplusplus
+}
+#endif
Index: xc/extras/expat/xmlwf/xmlwf.c
diff -u /dev/null xc/extras/expat/xmlwf/xmlwf.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmlwf.c	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,759 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+
+#include "expat.h"
+#include "codepage.h"
+#include "xmlfile.h"
+#include "xmltchar.h"
+
+#ifdef _MSC_VER
+#include <crtdbg.h>
+#endif
+
+/* This ensures proper sorting. */
+
+#define NSSEP T('\001')
+
+static void characterData(void *userData, const XML_Char *s, int len)
+{
+  FILE *fp = userData;
+  for (; len > 0; --len, ++s) {
+    switch (*s) {
+    case T('&'):
+      fputts(T("&amp;"), fp);
+      break;
+    case T('<'):
+      fputts(T("&lt;"), fp);
+      break;
+    case T('>'):
+      fputts(T("&gt;"), fp);
+      break;
+#ifdef W3C14N
+    case 13:
+      fputts(T("&#xD;"), fp);
+      break;
+#else
+    case T('"'):
+      fputts(T("&quot;"), fp);
+      break;
+    case 9:
+    case 10:
+    case 13:
+      ftprintf(fp, T("&#%d;"), *s);
+      break;
+#endif
+    default:
+      puttc(*s, fp);
+      break;
+    }
+  }
+}
+
+static void attributeValue(FILE *fp, const XML_Char *s)
+{
+  puttc(T('='), fp);
+  puttc(T('"'), fp);
+  for (;;) {
+    switch (*s) {
+    case 0:
+    case NSSEP:
+      puttc(T('"'), fp);
+      return;
+    case T('&'):
+      fputts(T("&amp;"), fp);
+      break;
+    case T('<'):
+      fputts(T("&lt;"), fp);
+      break;
+    case T('"'):
+      fputts(T("&quot;"), fp);
+      break;
+#ifdef W3C14N
+    case 9:
+      fputts(T("&#x9;"), fp);
+      break;
+    case 10:
+      fputts(T("&#xA;"), fp);
+      break;
+    case 13:
+      fputts(T("&#xD;"), fp);
+      break;
+#else
+    case T('>'):
+      fputts(T("&gt;"), fp);
+      break;
+    case 9:
+    case 10:
+    case 13:
+      ftprintf(fp, T("&#%d;"), *s);
+      break;
+#endif
+    default:
+      puttc(*s, fp);
+      break;
+    }
+    s++;
+  }
+}
+
+/* Lexicographically comparing UTF-8 encoded attribute values,
+is equivalent to lexicographically comparing based on the character number. */
+
+static int attcmp(const void *att1, const void *att2)
+{
+  return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
+}
+
+static void startElement(void *userData, const XML_Char *name, const XML_Char **atts)
+{
+  int nAtts;
+  const XML_Char **p;
+  FILE *fp = userData;
+  puttc(T('<'), fp);
+  fputts(name, fp);
+
+  p = atts;
+  while (*p)
+    ++p;
+  nAtts = (p - atts) >> 1;
+  if (nAtts > 1)
+    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
+  while (*atts) {
+    puttc(T(' '), fp);
+    fputts(*atts++, fp);
+    attributeValue(fp, *atts);
+    atts++;
+  }
+  puttc(T('>'), fp);
+}
+
+static void endElement(void *userData, const XML_Char *name)
+{
+  FILE *fp = userData;
+  puttc(T('<'), fp);
+  puttc(T('/'), fp);
+  fputts(name, fp);
+  puttc(T('>'), fp);
+}
+
+static int nsattcmp(const void *p1, const void *p2)
+{
+  const XML_Char *att1 = *(const XML_Char **)p1;
+  const XML_Char *att2 = *(const XML_Char **)p2;
+  int sep1 = (tcsrchr(att1, NSSEP) != 0);
+  int sep2 = (tcsrchr(att1, NSSEP) != 0);
+  if (sep1 != sep2)
+    return sep1 - sep2;
+  return tcscmp(att1, att2);
+}
+
+static void startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
+{
+  int nAtts;
+  int nsi;
+  const XML_Char **p;
+  FILE *fp = userData;
+  const XML_Char *sep;
+  puttc(T('<'), fp);
+
+  sep = tcsrchr(name, NSSEP);
+  if (sep) {
+    fputts(T("n1:"), fp);
+    fputts(sep + 1, fp);
+    fputts(T(" xmlns:n1"), fp);
+    attributeValue(fp, name);
+    nsi = 2;
+  }
+  else {
+    fputts(name, fp);
+    nsi = 1;
+  }
+
+  p = atts;
+  while (*p)
+    ++p;
+  nAtts = (p - atts) >> 1;
+  if (nAtts > 1)
+    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
+  while (*atts) {
+    name = *atts++;
+    sep = tcsrchr(name, NSSEP);
+    puttc(T(' '), fp);
+    if (sep) {
+      ftprintf(fp, T("n%d:"), nsi);
+      fputts(sep + 1, fp);
+    }
+    else
+      fputts(name, fp);
+    attributeValue(fp, *atts);
+    if (sep) {
+      ftprintf(fp, T(" xmlns:n%d"), nsi++);
+      attributeValue(fp, name);
+    }
+    atts++;
+  }
+  puttc(T('>'), fp);
+}
+
+static void endElementNS(void *userData, const XML_Char *name)
+{
+  FILE *fp = userData;
+  const XML_Char *sep;
+  puttc(T('<'), fp);
+  puttc(T('/'), fp);
+  sep = tcsrchr(name, NSSEP);
+  if (sep) {
+    fputts(T("n1:"), fp);
+    fputts(sep + 1, fp);
+  }
+  else
+    fputts(name, fp);
+  puttc(T('>'), fp);
+}
+
+#ifndef W3C14N
+
+static void processingInstruction(void *userData, const XML_Char *target, const XML_Char *data)
+{
+  FILE *fp = userData;
+  puttc(T('<'), fp);
+  puttc(T('?'), fp);
+  fputts(target, fp);
+  puttc(T(' '), fp);
+  fputts(data, fp);
+  puttc(T('?'), fp);
+  puttc(T('>'), fp);
+}
+
+#endif /* not W3C14N */
+
+static void defaultCharacterData(XML_Parser parser, const XML_Char *s, int len)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void defaultStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void defaultEndElement(XML_Parser parser, const XML_Char *name)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void defaultProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void nopCharacterData(XML_Parser parser, const XML_Char *s, int len)
+{
+}
+
+static void nopStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
+{
+}
+
+static void nopEndElement(XML_Parser parser, const XML_Char *name)
+{
+}
+
+static void nopProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
+{
+}
+
+static void markup(XML_Parser parser, const XML_Char *s, int len)
+{
+  FILE *fp = XML_GetUserData(parser);
+  for (; len > 0; --len, ++s)
+    puttc(*s, fp);
+}
+
+static
+void metaLocation(XML_Parser parser)
+{
+  const XML_Char *uri = XML_GetBase(parser);
+  if (uri)
+    ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
+  ftprintf(XML_GetUserData(parser),
+           T(" byte=\"%ld\" nbytes=\"%d\" line=\"%d\" col=\"%d\""),
+	   XML_GetCurrentByteIndex(parser),
+	   XML_GetCurrentByteCount(parser),
+	   XML_GetCurrentLineNumber(parser),
+	   XML_GetCurrentColumnNumber(parser));
+}
+
+static
+void metaStartDocument(XML_Parser parser)
+{
+  fputts(T("<document>\n"), XML_GetUserData(parser));
+}
+
+static
+void metaEndDocument(XML_Parser parser)
+{
+  fputts(T("</document>\n"), XML_GetUserData(parser));
+}
+
+static
+void metaStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
+{
+  FILE *fp = XML_GetUserData(parser);
+  const XML_Char **specifiedAttsEnd
+    = atts + XML_GetSpecifiedAttributeCount(parser);
+  const XML_Char **idAttPtr;
+  int idAttIndex = XML_GetIdAttributeIndex(parser);
+  if (idAttIndex < 0)
+    idAttPtr = 0;
+  else
+    idAttPtr = atts + idAttIndex;
+    
+  ftprintf(fp, T("<starttag name=\"%s\""), name);
+  metaLocation(parser);
+  if (*atts) {
+    fputts(T(">\n"), fp);
+    do {
+      ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
+      characterData(fp, atts[1], tcslen(atts[1]));
+      if (atts >= specifiedAttsEnd)
+	fputts(T("\" defaulted=\"yes\"/>\n"), fp);
+      else if (atts == idAttPtr)
+	fputts(T("\" id=\"yes\"/>\n"), fp);
+      else
+	fputts(T("\"/>\n"), fp);
+    } while (*(atts += 2));
+    fputts(T("</starttag>\n"), fp);
+  }
+  else
+    fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndElement(XML_Parser parser, const XML_Char *name)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<endtag name=\"%s\""), name);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
+  characterData(fp, data, tcslen(data));
+  puttc(T('"'), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaComment(XML_Parser parser, const XML_Char *data)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<comment data=\""), fp);
+  characterData(fp, data, tcslen(data));
+  puttc(T('"'), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaStartCdataSection(XML_Parser parser)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<startcdata"), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndCdataSection(XML_Parser parser)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<endcdata"), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaCharacterData(XML_Parser parser, const XML_Char *s, int len)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<chars str=\""), fp);
+  characterData(fp, s, len);
+  puttc(T('"'), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaStartDoctypeDecl(XML_Parser parser,
+			  const XML_Char *doctypeName,
+			  const XML_Char *sysid,
+			  const XML_Char *pubid,
+			  int has_internal_subset)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndDoctypeDecl(XML_Parser parser)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<enddoctype"), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaNotationDecl(XML_Parser parser,
+		      const XML_Char *notationName,
+		      const XML_Char *base,
+		      const XML_Char *systemId,
+		      const XML_Char *publicId)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<notation name=\"%s\""), notationName);
+  if (publicId)
+    ftprintf(fp, T(" public=\"%s\""), publicId);
+  if (systemId) {
+    fputts(T(" system=\""), fp);
+    characterData(fp, systemId, tcslen(systemId));
+    puttc(T('"'), fp);
+  }
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+
+static
+void metaEntityDecl(XML_Parser parser,
+		    const XML_Char *entityName,
+		    int  is_param,
+		    const XML_Char *value,
+		    int  value_length,
+		    const XML_Char *base,
+		    const XML_Char *systemId,
+		    const XML_Char *publicId,
+		    const XML_Char *notationName)
+{
+  FILE *fp = XML_GetUserData(parser);
+
+  if (value) {
+    ftprintf(fp, T("<entity name=\"%s\""), entityName);
+    metaLocation(parser);
+    puttc(T('>'), fp);
+    characterData(fp, value, value_length);
+    fputts(T("</entity/>\n"), fp);
+  }
+  else if (notationName) {
+    ftprintf(fp, T("<entity name=\"%s\""), entityName);
+    if (publicId)
+      ftprintf(fp, T(" public=\"%s\""), publicId);
+    fputts(T(" system=\""), fp);
+    characterData(fp, systemId, tcslen(systemId));
+    puttc(T('"'), fp);
+    ftprintf(fp, T(" notation=\"%s\""), notationName);
+    metaLocation(parser);
+    fputts(T("/>\n"), fp);
+  }
+  else {
+    ftprintf(fp, T("<entity name=\"%s\""), entityName);
+    if (publicId)
+      ftprintf(fp, T(" public=\"%s\""), publicId);
+    fputts(T(" system=\""), fp);
+    characterData(fp, systemId, tcslen(systemId));
+    puttc(T('"'), fp);
+    metaLocation(parser);
+    fputts(T("/>\n"), fp);
+  }
+}
+
+static
+void metaStartNamespaceDecl(XML_Parser parser,
+			    const XML_Char *prefix,
+			    const XML_Char *uri)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<startns"), fp);
+  if (prefix)
+    ftprintf(fp, T(" prefix=\"%s\""), prefix);
+  if (uri) {
+    fputts(T(" ns=\""), fp);
+    characterData(fp, uri, tcslen(uri));
+    fputts(T("\"/>\n"), fp);
+  }
+  else
+    fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndNamespaceDecl(XML_Parser parser, const XML_Char *prefix)
+{
+  FILE *fp = XML_GetUserData(parser);
+  if (!prefix)
+    fputts(T("<endns/>\n"), fp);
+  else
+    ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
+}
+
+static
+int unknownEncodingConvert(void *data, const char *p)
+{
+  return codepageConvert(*(int *)data, p);
+}
+
+static
+int unknownEncoding(void *userData,
+		    const XML_Char *name,
+		    XML_Encoding *info)
+{
+  int cp;
+  static const XML_Char prefixL[] = T("windows-");
+  static const XML_Char prefixU[] = T("WINDOWS-");
+  int i;
+
+  for (i = 0; prefixU[i]; i++)
+    if (name[i] != prefixU[i] && name[i] != prefixL[i])
+      return 0;
+  
+  cp = 0;
+  for (; name[i]; i++) {
+    static const XML_Char digits[] = T("0123456789");
+    const XML_Char *s = tcschr(digits, name[i]);
+    if (!s)
+      return 0;
+    cp *= 10;
+    cp += s - digits;
+    if (cp >= 0x10000)
+      return 0;
+  }
+  if (!codepageMap(cp, info->map))
+    return 0;
+  info->convert = unknownEncodingConvert;
+  /* We could just cast the code page integer to a void *,
+  and avoid the use of release. */
+  info->release = free;
+  info->data = malloc(sizeof(int));
+  if (!info->data)
+    return 0;
+  *(int *)info->data = cp;
+  return 1;
+}
+
+static
+int notStandalone(void *userData)
+{
+  return 0;
+}
+
+static
+void usage(const XML_Char *prog)
+{
+  ftprintf(stderr, T("usage: %s [-n] [-p] [-r] [-s] [-w] [-x] [-d output-dir] [-e encoding] file ...\n"), prog);
+  exit(1);
+}
+
+int tmain(int argc, XML_Char **argv)
+{
+  int i, j;
+  const XML_Char *outputDir = 0;
+  const XML_Char *encoding = 0;
+  unsigned processFlags = XML_MAP_FILE;
+  int windowsCodePages = 0;
+  int outputType = 0;
+  int useNamespaces = 0;
+  int requireStandalone = 0;
+  int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
+
+#ifdef _MSC_VER
+  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
+#endif
+
+  i = 1;
+  j = 0;
+  while (i < argc) {
+    if (j == 0) {
+      if (argv[i][0] != T('-'))
+	break;
+      if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
+	i++;
+	break;
+      }
+      j++;
+    }
+    switch (argv[i][j]) {
+    case T('r'):
+      processFlags &= ~XML_MAP_FILE;
+      j++;
+      break;
+    case T('s'):
+      requireStandalone = 1;
+      j++;
+      break;
+    case T('n'):
+      useNamespaces = 1;
+      j++;
+      break;
+    case T('p'):
+      paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
+      /* fall through */
+    case T('x'):
+      processFlags |= XML_EXTERNAL_ENTITIES;
+      j++;
+      break;
+    case T('w'):
+      windowsCodePages = 1;
+      j++;
+      break;
+    case T('m'):
+      outputType = 'm';
+      j++;
+      break;
+    case T('c'):
+      outputType = 'c';
+      useNamespaces = 0;
+      j++;
+      break;
+    case T('t'):
+      outputType = 't';
+      j++;
+      break;
+    case T('d'):
+      if (argv[i][j + 1] == T('\0')) {
+	if (++i == argc)
+	  usage(argv[0]);
+	outputDir = argv[i];
+      }
+      else
+	outputDir = argv[i] + j + 1;
+      i++;
+      j = 0;
+      break;
+    case T('e'):
+      if (argv[i][j + 1] == T('\0')) {
+	if (++i == argc)
+	  usage(argv[0]);
+	encoding = argv[i];
+      }
+      else
+	encoding = argv[i] + j + 1;
+      i++;
+      j = 0;
+      break;
+    case T('\0'):
+      if (j > 1) {
+	i++;
+	j = 0;
+	break;
+      }
+      /* fall through */
+    default:
+      usage(argv[0]);
+    }
+  }
+  if (i == argc)
+    usage(argv[0]);
+  for (; i < argc; i++) {
+    FILE *fp = 0;
+    XML_Char *outName = 0;
+    int result;
+    XML_Parser parser;
+    if (useNamespaces)
+      parser = XML_ParserCreateNS(encoding, NSSEP);
+    else
+      parser = XML_ParserCreate(encoding);
+    if (requireStandalone)
+      XML_SetNotStandaloneHandler(parser, notStandalone);
+    XML_SetParamEntityParsing(parser, paramEntityParsing);
+    if (outputType == 't') {
+      /* This is for doing timings; this gives a more realistic estimate of
+	 the parsing time. */
+      outputDir = 0;
+      XML_SetElementHandler(parser, nopStartElement, nopEndElement);
+      XML_SetCharacterDataHandler(parser, nopCharacterData);
+      XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
+    }
+    else if (outputDir) {
+      const XML_Char *file = argv[i];
+      if (tcsrchr(file, T('/')))
+	file = tcsrchr(file, T('/')) + 1;
+#ifdef WIN32
+      if (tcsrchr(file, T('\\')))
+	file = tcsrchr(file, T('\\')) + 1;
+#endif
+      outName = malloc((tcslen(outputDir) + tcslen(file) + 2) * sizeof(XML_Char));
+      tcscpy(outName, outputDir);
+      tcscat(outName, T("/"));
+      tcscat(outName, file);
+      fp = tfopen(outName, T("wb"));
+      if (!fp) {
+	tperror(outName);
+	exit(1);
+      }
+      setvbuf(fp, NULL, _IOFBF, 16384);
+#ifdef XML_UNICODE
+      puttc(0xFEFF, fp);
+#endif
+      XML_SetUserData(parser, fp);
+      switch (outputType) {
+      case 'm':
+	XML_UseParserAsHandlerArg(parser);
+	XML_SetElementHandler(parser, metaStartElement, metaEndElement);
+	XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
+	XML_SetCommentHandler(parser, metaComment);
+	XML_SetCdataSectionHandler(parser, metaStartCdataSection, metaEndCdataSection);
+	XML_SetCharacterDataHandler(parser, metaCharacterData);
+	XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl, metaEndDoctypeDecl);
+	XML_SetEntityDeclHandler(parser, metaEntityDecl);
+	XML_SetNotationDeclHandler(parser, metaNotationDecl);
+	XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl, metaEndNamespaceDecl);
+	metaStartDocument(parser);
+	break;
+      case 'c':
+	XML_UseParserAsHandlerArg(parser);
+	XML_SetDefaultHandler(parser, markup);
+	XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
+	XML_SetCharacterDataHandler(parser, defaultCharacterData);
+	XML_SetProcessingInstructionHandler(parser, defaultProcessingInstruction);
+	break;
+      default:
+	if (useNamespaces)
+	  XML_SetElementHandler(parser, startElementNS, endElementNS);
+	else
+	  XML_SetElementHandler(parser, startElement, endElement);
+	XML_SetCharacterDataHandler(parser, characterData);
+#ifndef W3C14N
+	XML_SetProcessingInstructionHandler(parser, processingInstruction);
+#endif /* not W3C14N */
+	break;
+      }
+    }
+    if (windowsCodePages)
+      XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
+    result = XML_ProcessFile(parser, argv[i], processFlags);
+    if (outputDir) {
+      if (outputType == 'm')
+	metaEndDocument(parser);
+      fclose(fp);
+      if (!result)
+	tremove(outName);
+      free(outName);
+    }
+    XML_ParserFree(parser);
+  }
+  return 0;
+}
Index: xc/extras/expat/xmlwf/xmlwin32url.cxx
diff -u /dev/null xc/extras/expat/xmlwf/xmlwin32url.cxx:1.1.1.1
--- /dev/null	Thu Feb 27 12:16:28 2003
+++ xc/extras/expat/xmlwf/xmlwin32url.cxx	Mon Feb 18 16:44:23 2002
@@ -0,0 +1,371 @@
+#include "xmlparse.h"
+#ifdef XML_UNICODE
+#define UNICODE
+#endif
+#include <windows.h>
+#include <urlmon.h>
+#include <wininet.h>
+#include <stdio.h>
+#include <tchar.h>
+#include "xmlurl.h"
+#include "xmlmime.h"
+
+static
+int processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url);
+
+typedef void (*StopHandler)(void *, HRESULT);
+
+class Callback : public IBindStatusCallback {
+public:
+  // IUnknown methods
+  STDMETHODIMP QueryInterface(REFIID,void **);
+  STDMETHODIMP_(ULONG) AddRef();
+  STDMETHODIMP_(ULONG) Release();
+  // IBindStatusCallback methods
+  STDMETHODIMP OnStartBinding(DWORD, IBinding *);
+  STDMETHODIMP GetPriority(LONG *);
+  STDMETHODIMP OnLowResource(DWORD);
+  STDMETHODIMP OnProgress(ULONG, ULONG, ULONG, LPCWSTR);
+  STDMETHODIMP OnStopBinding(HRESULT, LPCWSTR);
+  STDMETHODIMP GetBindInfo(DWORD *, BINDINFO *);
+  STDMETHODIMP OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *);
+  STDMETHODIMP OnObjectAvailable(REFIID, IUnknown *);
+  Callback(XML_Parser, IMoniker *, StopHandler, void *);
+  ~Callback();
+  int externalEntityRef(const XML_Char *context, const XML_Char *systemId, const XML_Char *publicId);
+private:
+  XML_Parser parser_;
+  IMoniker *baseMoniker_;
+  DWORD totalRead_;
+  ULONG ref_;
+  IBinding *pBinding_;
+  StopHandler stopHandler_;
+  void *stopArg_;
+};
+
+STDMETHODIMP_(ULONG) Callback::AddRef()
+{ 
+  return ref_++;
+}
+
+STDMETHODIMP_(ULONG) Callback::Release()
+{ 
+  if (--ref_ == 0) {
+    delete this;
+    return 0;
+  }
+  return ref_;
+}
+
+STDMETHODIMP Callback::QueryInterface(REFIID riid, void** ppv)
+{ 
+  if (IsEqualGUID(riid, IID_IUnknown))
+    *ppv = (IUnknown *)this;
+  else if (IsEqualGUID(riid, IID_IBindStatusCallback))
+    *ppv = (IBindStatusCallback *)this;
+  else
+    return E_NOINTERFACE;
+  ((LPUNKNOWN)*ppv)->AddRef();
+  return S_OK;
+}
+
+STDMETHODIMP Callback::OnStartBinding(DWORD, IBinding* pBinding)
+{
+  pBinding_ = pBinding;
+  pBinding->AddRef();
+  return S_OK;
+}
+
+STDMETHODIMP Callback::GetPriority(LONG *)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP Callback::OnLowResource(DWORD)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP Callback::OnProgress(ULONG, ULONG, ULONG, LPCWSTR)
+{
+  return S_OK;
+}
+
+STDMETHODIMP Callback::OnStopBinding(HRESULT hr, LPCWSTR szError)
+{
+  if (pBinding_) {
+    pBinding_->Release();
+    pBinding_ = 0;
+  }
+  if (baseMoniker_) {
+    baseMoniker_->Release();
+    baseMoniker_ = 0;
+  }
+  stopHandler_(stopArg_, hr);
+  return S_OK;
+}
+
+STDMETHODIMP Callback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo)
+{
+  *pgrfBINDF = BINDF_ASYNCHRONOUS;
+  return S_OK;
+}
+
+static
+void reportError(XML_Parser parser)
+{
+  int code = XML_GetErrorCode(parser);
+  const XML_Char *message = XML_ErrorString(code);
+  if (message)
+    _ftprintf(stderr, _T("%s:%d:%ld: %s\n"),
+	     XML_GetBase(parser),
+	     XML_GetErrorLineNumber(parser),
+	     XML_GetErrorColumnNumber(parser),
+	     message);
+  else
+    _ftprintf(stderr, _T("%s: (unknown message %d)\n"), XML_GetBase(parser), code);
+}
+
+STDMETHODIMP Callback::OnDataAvailable(DWORD grfBSCF,
+				       DWORD dwSize,
+				       FORMATETC *pfmtetc,
+				       STGMEDIUM* pstgmed)
+{
+  if (grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
+    IWinInetHttpInfo *hp;
+    HRESULT hr = pBinding_->QueryInterface(IID_IWinInetHttpInfo, (void **)&hp);
+    if (SUCCEEDED(hr)) {
+      char contentType[1024];
+      DWORD bufSize = sizeof(contentType);
+      DWORD flags = 0;
+      contentType[0] = 0;
+      hr = hp->QueryInfo(HTTP_QUERY_CONTENT_TYPE, contentType, &bufSize, 0, NULL);
+      if (SUCCEEDED(hr)) {
+	char charset[CHARSET_MAX];
+	getXMLCharset(contentType, charset);
+	if (charset[0]) {
+#ifdef XML_UNICODE
+	  XML_Char wcharset[CHARSET_MAX];
+	  XML_Char *p1 = wcharset;
+	  const char *p2 = charset;
+	  while ((*p1++ = (unsigned char)*p2++) != 0)
+	    ;
+	  XML_SetEncoding(parser_, wcharset);
+#else
+	  XML_SetEncoding(parser_, charset);
+#endif
+	}
+      }
+      hp->Release();
+    }
+  }
+  if (!parser_)
+    return E_ABORT;
+  if (pstgmed->tymed == TYMED_ISTREAM) {
+    while (totalRead_ < dwSize) {
+#define READ_MAX (64*1024)
+      DWORD nToRead = dwSize - totalRead_;
+      if (nToRead > READ_MAX)
+	nToRead = READ_MAX;
+      void *buf = XML_GetBuffer(parser_, nToRead);
+      if (!buf) {
+	_ftprintf(stderr, _T("out of memory\n"));
+	return E_ABORT;
+      }
+      DWORD nRead;
+      HRESULT hr = pstgmed->pstm->Read(buf, nToRead, &nRead);
+      if (SUCCEEDED(hr)) {
+	totalRead_ += nRead;
+	if (!XML_ParseBuffer(parser_,
+			     nRead,
+			     (grfBSCF & BSCF_LASTDATANOTIFICATION) != 0
+			     && totalRead_ == dwSize)) {
+	  reportError(parser_);
+	  return E_ABORT;
+	}
+      }
+    }
+  }
+  return S_OK;
+}
+
+STDMETHODIMP Callback::OnObjectAvailable(REFIID, IUnknown *)
+{
+  return S_OK;
+}
+
+int Callback::externalEntityRef(const XML_Char *context, const XML_Char *systemId, const XML_Char *publicId)
+{
+  XML_Parser entParser = XML_ExternalEntityParserCreate(parser_, context, 0);
+  XML_SetBase(entParser, systemId);
+  int ret = processURL(entParser, baseMoniker_, systemId);
+  XML_ParserFree(entParser);
+  return ret;
+}
+
+Callback::Callback(XML_Parser parser, IMoniker *baseMoniker, StopHandler stopHandler, void *stopArg)
+: parser_(parser),
+  baseMoniker_(baseMoniker),
+  ref_(0),
+  pBinding_(0),
+  totalRead_(0),
+  stopHandler_(stopHandler),
+  stopArg_(stopArg)
+{
+  if (baseMoniker_)
+    baseMoniker_->AddRef();
+}
+
+Callback::~Callback()
+{
+  if (pBinding_)
+    pBinding_->Release();
+  if (baseMoniker_)
+    baseMoniker_->Release();
+}
+
+static
+int externalEntityRef(void *arg,
+		      const XML_Char *context,
+		      const XML_Char *base,
+		      const XML_Char *systemId,
+		      const XML_Char *publicId)
+{
+  return ((Callback *)arg)->externalEntityRef(context, systemId, publicId);
+}
+
+
+static
+HRESULT openStream(XML_Parser parser,
+		   IMoniker *baseMoniker,
+		   const XML_Char *uri,
+		   StopHandler stopHandler, void *stopArg)
+{
+  if (!XML_SetBase(parser, uri))
+    return E_OUTOFMEMORY;
+  HRESULT hr;
+  IMoniker *m;
+#ifdef XML_UNICODE
+  hr = CreateURLMoniker(0, uri, &m);
+#else
+  LPWSTR uriw = new wchar_t[strlen(uri) + 1];
+  for (int i = 0;; i++) {
+    uriw[i] = uri[i];
+    if (uriw[i] == 0)
+      break;
+  }
+  hr = CreateURLMoniker(baseMoniker, uriw, &m);
+  delete [] uriw;
+#endif
+  if (FAILED(hr))
+    return hr;
+  IBindStatusCallback *cb = new Callback(parser, m, stopHandler, stopArg);
+  XML_SetExternalEntityRefHandler(parser, externalEntityRef);
+  XML_SetExternalEntityRefHandlerArg(parser, cb);
+  cb->AddRef();
+  IBindCtx *b;
+  if (FAILED(hr = CreateAsyncBindCtx(0, cb, 0, &b))) {
+    cb->Release();
+    m->Release();
+    return hr;
+  }
+  cb->Release();
+  IStream *pStream;
+  hr = m->BindToStorage(b, 0, IID_IStream, (void **)&pStream);
+  if (SUCCEEDED(hr)) {
+    if (pStream)
+      pStream->Release();
+  }
+  if (hr == MK_S_ASYNCHRONOUS)
+    hr = S_OK;
+  m->Release();
+  b->Release();
+  return hr;
+}
+
+struct QuitInfo {
+  const XML_Char *url;
+  HRESULT hr;
+  int stop;
+};
+
+static
+void winPerror(const XML_Char *url, HRESULT hr)
+{
+  LPVOID buf;
+  if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
+		    | FORMAT_MESSAGE_FROM_HMODULE,
+		    GetModuleHandleA("urlmon.dll"),
+		    hr,
+		    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		    (LPTSTR) &buf,
+		    0,
+		    NULL)
+      || FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
+		      | FORMAT_MESSAGE_FROM_SYSTEM,
+		      0,
+		      hr,
+		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		      (LPTSTR) &buf,
+		      0,
+		      NULL)) {
+    /* The system error messages seem to end with a newline. */
+    _ftprintf(stderr, _T("%s: %s"), url, buf);
+    fflush(stderr);
+    LocalFree(buf);
+  }
+  else
+    _ftprintf(stderr, _T("%s: error %x\n"), url, hr);
+}
+
+static void threadQuit(void *p, HRESULT hr)
+{
+  QuitInfo *qi = (QuitInfo *)p;
+  qi->hr = hr;
+  qi->stop = 1;
+}
+
+extern "C"
+int XML_URLInit()
+{
+  return SUCCEEDED(CoInitialize(0));
+}
+
+extern "C"
+void XML_URLUninit()
+{
+  CoUninitialize();
+}
+
+static
+int processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url)
+{
+  QuitInfo qi;
+  qi.stop = 0;
+  qi.url = url;
+
+  XML_SetBase(parser, url);
+  HRESULT hr = openStream(parser, baseMoniker, url, threadQuit, &qi);
+  if (FAILED(hr)) {
+    winPerror(url, hr);
+    return 0;
+  }
+  else if (FAILED(qi.hr)) {
+    winPerror(url, qi.hr);
+    return 0;
+  }
+  MSG msg;
+  while (!qi.stop && GetMessage (&msg, NULL, 0, 0)) {
+    TranslateMessage (&msg);
+    DispatchMessage (&msg);
+  }
+  return 1;
+}
+
+extern "C"
+int XML_ProcessURL(XML_Parser parser,
+		   const XML_Char *url,
+		   unsigned flags)
+{
+  return processURL(parser, 0, url);
+}
Index: xc/extras/fonts/ClearlyU/README
diff -u xc/extras/fonts/ClearlyU/README:1.4 xc/extras/fonts/ClearlyU/README:1.5
--- xc/extras/fonts/ClearlyU/README:1.4	Wed Nov 21 15:58:10 2001
+++ xc/extras/fonts/ClearlyU/README	Fri Dec 13 22:51:39 2002
@@ -1,7 +1,7 @@
 #
-# Id: README,v 1.13 2001/10/29 18:54:35 mleisher Exp $
+# Id: README,v 1.19 2002/11/22 23:11:31 mleisher Exp $
 #
-# Copyright 2001 Computing Research Lab, New Mexico State University
+# Copyright 2002 Computing Research Lab, New Mexico State University
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the "Software"),
@@ -22,14 +22,16 @@
 # THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-Version: 1.8
-29 October 2001
+Version: 1.9
+22 November 2002
 
 This set of fonts provides a 12pt, 100dpi proportional font with many of
 the glyphs needed for Unicode text.  I call the typeface "ClearlyU" and
 it was influenced by Donald Knuth's Computer Modern.
 
-The fonts together contain 8669 glyphs at the moment.
+The fonts together contain 9538 glyphs at the moment.  This does not include
+cuarabic12.bdf and cudevnag12.bdf which contain glyphs from cu12.bdf and and
+cu-pua12.bdf.
 
 Information about this font and samples, are located at:
 
@@ -46,12 +48,70 @@
 Thanks to Ahmed Abdelali <ahmed@crl.nmsu.edu> for his help in improving the
 Arabic glyphs.
 
+Thanks to Séamus Ó Ciardhuáin <seoc@cnds.ucd.ie> for a much cleaner version
+of the Ogham glyphs.
+
+Thanks go to Daniel Yacob <yacob@ethiopiaonline.net> for a major cleanup of
+the Ethiopic block glyphs!
+
 AUTHOR
 ======
 Mark Leisher <mleisher@crl.nmsu.edu>
 
 CHANGES
 =======
+
+CHANGES FROM 1.8
+----------------
+  o  Adjusted positioning of several math symbols.
+
+  o  Fixed the Hebrew FB39 glyph.
+
+  o  Added Hangul Jamo and Hangul Compatibility Jamo glyphs.
+
+  o  Changed the apostrophe and double quotes to the straight versions, and
+     fixed the grave accent to look right.
+
+  o  Added Koranic marks.
+
+  o  Made the Geometric Shapes a bit larger.
+
+  o  Cleaned up Control Pictures.
+
+  o  Added Miscellaneous Technical symbols.
+
+  o  Fixed a couple currency symbols.
+
+  o  Added Runes.
+
+  o  Added Ogham.
+
+  o  Adjusted the positioning of the Arabic decimal and thousands separator.
+
+  o  Changed some of the Greek glyphs to represent the trailing
+     ypogegrammeni.
+
+  o  Swapped the Greek phi letter and symbol glyphs.
+
+  o  Cleaned up Cherokee a bit.
+
+  o  Fixed the non-spacing Dhivehi vowels.
+
+  o  Adjusted some of the UCAS shapes.
+
+  o  Replaced Ogham glyphs with better version.
+
+  o  Major cleanup of Ethiopic glyphs.
+
+  o  Added some glyphs to the Cyrillic block.
+
+  o  Added a couple missing Arabic glyphs.
+
+  o  Minor adjustment to U+1EF5.
+
+  o  Added a Devanagari-only font.
+
+  o  Added the Braille block.
 
 CHANGES FROM 1.7
 ----------------
Index: xc/extras/fonts/ClearlyU/cu-alt12.bdf
diff -u xc/extras/fonts/ClearlyU/cu-alt12.bdf:1.4 xc/extras/fonts/ClearlyU/cu-alt12.bdf:1.5
--- xc/extras/fonts/ClearlyU/cu-alt12.bdf:1.4	Wed Nov 21 15:58:11 2001
+++ xc/extras/fonts/ClearlyU/cu-alt12.bdf	Fri Dec 13 22:51:39 2002
@@ -1,8 +1,8 @@
 STARTFONT 2.1
 COMMENT 
-COMMENT Id: cu-alt12.bdf,v 1.10 2001/10/23 23:55:30 mleisher Exp $
+COMMENT Id: cu-alt12.bdf,v 1.12 2002/11/22 22:46:24 mleisher Exp $
 COMMENT 
-COMMENT Copyright 2001 Computing Research Labs, New Mexico State University
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
 COMMENT 
 COMMENT Permission is hereby granted, free of charge, to any person
 COMMENT obtaining a copy of this software and associated documentation
@@ -28,9 +28,9 @@
 COMMENT This font contains alternate glyphs for Arabic and Georgian blocks.
 COMMENT Some have been added to the Private Use Area as well.
 COMMENT 
-FONT -MUTT-ClearlyU Alternate Glyphs-Medium-R-Normal--17-120-100-100-P-91-ISO10646-1
+FONT -MUTT-ClearlyU Alternate Glyphs-Medium-R-Normal--17-120-100-100-P-122-ISO10646-1
 SIZE 12 100 100
-FONTBOUNDINGBOX 18 24 -1 -7
+FONTBOUNDINGBOX 21 24 -1 -7
 STARTPROPERTIES 21
 COPYRIGHT "2001 Computing Research Lab, New Mexico State University."
 POINT_SIZE 120
@@ -39,7 +39,7 @@
 RESOLUTION_Y 100
 FONT_ASCENT 12
 FONT_DESCENT 6
-AVERAGE_WIDTH 91
+AVERAGE_WIDTH 122
 SPACING "P"
 FOUNDRY "MUTT"
 FAMILY_NAME "ClearlyU Alternate Glyphs"
@@ -54,7 +54,7 @@
 X_HEIGHT 7
 DEFAULT_CHAR 65534
 ENDPROPERTIES
-CHARS 420
+CHARS 663
 STARTCHAR char0
 ENCODING -1
 SWIDTH 0 0
@@ -2042,6 +2042,4298 @@
 84
 78
 ENDCHAR
+STARTCHAR uni1100
+ENCODING 4352
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 10 3 0
+BITMAP
+8000
+FFE0
+0020
+0020
+0020
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uni1101
+ENCODING 4353
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+8100
+FDF0
+0410
+0410
+0410
+0410
+0410
+0410
+0410
+ENDCHAR
+STARTCHAR uni1102
+ENCODING 4354
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 7 2 2
+BITMAP
+C000
+4000
+4000
+4000
+4000
+4060
+3FF0
+ENDCHAR
+STARTCHAR uni1103
+ENCODING 4355
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 8 2 2
+BITMAP
+0040
+FFE0
+4000
+4000
+4000
+4000
+4060
+7FF0
+ENDCHAR
+STARTCHAR uni1104
+ENCODING 4356
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+0820
+FDF0
+4100
+4100
+4100
+4100
+4300
+4D10
+71F8
+ENDCHAR
+STARTCHAR uni1105
+ENCODING 4357
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+0040
+FFC0
+4040
+0040
+7FC0
+4000
+4000
+4060
+7FF0
+ENDCHAR
+STARTCHAR uni1106
+ENCODING 4358
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 8 3 1
+BITMAP
+FFE0
+4020
+4040
+4040
+4040
+4040
+7FC0
+4000
+ENDCHAR
+STARTCHAR uni1107
+ENCODING 4359
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 11 3 0
+BITMAP
+00C0
+C040
+4040
+4040
+7FC0
+4040
+4040
+4040
+4040
+7FC0
+4040
+ENDCHAR
+STARTCHAR uni1108
+ENCODING 4360
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 11 2 0
+BITMAP
+0018
+0988
+C488
+4488
+44F8
+7C88
+4488
+4488
+4488
+7CF8
+4488
+ENDCHAR
+STARTCHAR uni1109
+ENCODING 4361
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+0800
+0600
+0400
+0C00
+0B00
+1080
+2060
+4020
+8010
+ENDCHAR
+STARTCHAR uni110A
+ENCODING 4362
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1860
+0C30
+0820
+0820
+1450
+1248
+2184
+4104
+8200
+ENDCHAR
+STARTCHAR uni110B
+ENCODING 4363
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
+BITMAP
+0800
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+3E00
+ENDCHAR
+STARTCHAR uni110C
+ENCODING 4364
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 9 3 1
+BITMAP
+0080
+FFC0
+0400
+0400
+0C00
+0A00
+1180
+60C0
+8040
+ENDCHAR
+STARTCHAR uni110D
+ENCODING 4365
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+0204
+7F7C
+0820
+0820
+0820
+1450
+1248
+2184
+4104
+8200
+ENDCHAR
+STARTCHAR uni110E
+ENCODING 4366
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 9 2 1
+BITMAP
+1F00
+0000
+FFE0
+4400
+0400
+0A00
+1180
+2040
+C020
+ENDCHAR
+STARTCHAR uni110F
+ENCODING 4367
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 10 3 1
+BITMAP
+00C0
+FF40
+6040
+0040
+01C0
+1E40
+E040
+0080
+0080
+0080
+ENDCHAR
+STARTCHAR uni1110
+ENCODING 4368
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+00C0
+FFE0
+4000
+4180
+7FC0
+4000
+4000
+4060
+7FF0
+ENDCHAR
+STARTCHAR uni1111
+ENCODING 4369
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+4060
+7FF0
+0000
+00C0
+1040
+0880
+0880
+8130
+FFF8
+ENDCHAR
+STARTCHAR uni1112
+ENCODING 4370
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0F80
+0010
+FFF8
+0200
+0F80
+1040
+1040
+1040
+1040
+0F80
+ENDCHAR
+STARTCHAR uni1113
+ENCODING 4371
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 9 3 1
+BITMAP
+0400
+C7C0
+4040
+4040
+4040
+4040
+4440
+5840
+2040
+ENDCHAR
+STARTCHAR uni1114
+ENCODING 4372
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+0300
+C100
+4100
+4100
+4100
+4100
+4500
+59F8
+2000
+ENDCHAR
+STARTCHAR uni1115
+ENCODING 4373
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+0010
+C1F0
+4100
+4100
+4100
+4100
+4500
+5910
+61F8
+ENDCHAR
+STARTCHAR uni1116
+ENCODING 4374
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 10 2 1
+BITMAP
+0030
+0310
+C110
+4110
+41F0
+4110
+4110
+4510
+59F0
+6110
+ENDCHAR
+STARTCHAR uni1117
+ENCODING 4375
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+0900
+F9F0
+8010
+8010
+8010
+8010
+8010
+8810
+FC10
+ENDCHAR
+STARTCHAR uni1118
+ENCODING 4376
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
+BITMAP
+FCC0
+0840
+0840
+FC40
+4040
+4044
+4258
+7C20
+ENDCHAR
+STARTCHAR uni1119
+ENCODING 4377
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
+BITMAP
+FDF8
+0810
+0810
+FDF8
+4080
+4080
+4284
+7CF8
+ENDCHAR
+STARTCHAR uni111A
+ENCODING 4378
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 2 1
+BITMAP
+0004
+FDFE
+4800
+0820
+F870
+4088
+4088
+4288
+7C70
+ENDCHAR
+STARTCHAR uni111B
+ENCODING 4379
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 14 4 -1
+BITMAP
+FF80
+0100
+0100
+FF80
+4000
+4000
+7F80
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
+ENDCHAR
+STARTCHAR uni111C
+ENCODING 4380
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0018
+FD88
+4488
+4488
+44F8
+4488
+4488
+7E88
+40F8
+0088
+ENDCHAR
+STARTCHAR uni111D
+ENCODING 4381
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 13 3 -1
+BITMAP
+FF00
+4100
+4100
+4100
+7F80
+4000
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
+ENDCHAR
+STARTCHAR uni111E
+ENCODING 4382
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 10 2 0
+BITMAP
+0D00
+C5F0
+4410
+4410
+7C10
+4410
+4410
+4410
+7C10
+4400
+ENDCHAR
+STARTCHAR uni111F
+ENCODING 4383
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+0D00
+C480
+4480
+4480
+7C80
+4480
+4480
+4488
+7CFC
+4400
+ENDCHAR
+STARTCHAR uni1120
+ENCODING 4384
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0C10
+C5F0
+4500
+4500
+7D00
+4500
+4500
+4510
+7DF8
+4400
+ENDCHAR
+STARTCHAR uni1121
+ENCODING 4385
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+0C40
+C430
+4420
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
+ENDCHAR
+STARTCHAR uni1122
+ENCODING 4386
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
+BITMAP
+1920
+C8BC
+4884
+4884
+7984
+4944
+4A24
+4C24
+7C04
+4000
+ENDCHAR
+STARTCHAR uni1123
+ENCODING 4387
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
+BITMAP
+1A04
+C93C
+4920
+4920
+7920
+4B20
+4AA0
+4CA4
+7CBC
+4000
+ENDCHAR
+STARTCHAR uni1124
+ENCODING 4388
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
+BITMAP
+1A0C
+C964
+4924
+4924
+793C
+4B24
+4AA4
+4CA4
+7CBC
+4024
+ENDCHAR
+STARTCHAR uni1125
+ENCODING 4389
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
+BITMAP
+1910
+C888
+4888
+4888
+7888
+4998
+4954
+4A64
+7C44
+4000
+ENDCHAR
+STARTCHAR uni1126
+ENCODING 4390
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
+BITMAP
+0004
+197E
+C888
+4888
+4888
+7888
+4994
+4954
+4A64
+7C44
+4000
+ENDCHAR
+STARTCHAR uni1127
+ENCODING 4391
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+0C04
+C5FC
+4420
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
+ENDCHAR
+STARTCHAR uni1128
+ENCODING 4392
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
+BITMAP
+00F0
+0C04
+C5FC
+4420
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
+ENDCHAR
+STARTCHAR uni1129
+ENCODING 4393
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+0C08
+C5FC
+4480
+4490
+7CF8
+4480
+4480
+4488
+7CFC
+4400
+ENDCHAR
+STARTCHAR uni112A
+ENCODING 4394
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 2 0
+BITMAP
+0C04
+C5FC
+4400
+4518
+7C88
+4488
+4490
+4412
+7DFE
+4400
+ENDCHAR
+STARTCHAR uni112B
+ENCODING 4395
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
+BITMAP
+0180
+C080
+4080
+7F80
+4080
+4080
+7F80
+4080
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
+ENDCHAR
+STARTCHAR uni112C
+ENCODING 4396
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0C30
+C710
+4510
+7DF0
+4510
+4510
+7DF0
+4510
+0200
+0F80
+1040
+1040
+1040
+1040
+0F80
+ENDCHAR
+STARTCHAR uni112D
+ENCODING 4397
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1900
+0DF8
+0808
+0808
+1408
+1408
+2208
+4208
+8008
+ENDCHAR
+STARTCHAR uni112E
+ENCODING 4398
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1800
+0D80
+0880
+0880
+1880
+1480
+2488
+42B0
+8240
+ENDCHAR
+STARTCHAR uni112F
+ENCODING 4399
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1808
+0CF8
+0880
+0880
+1480
+1480
+2280
+4288
+80FC
+ENDCHAR
+STARTCHAR uni1130
+ENCODING 4400
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1800
+0DF8
+0810
+0810
+15F8
+1480
+2280
+4284
+81F8
+ENDCHAR
+STARTCHAR uni1131
+ENCODING 4401
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1800
+0DF8
+0888
+0888
+1488
+1488
+2288
+42FC
+8080
+ENDCHAR
+STARTCHAR uni1132
+ENCODING 4402
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+1818
+0D88
+0888
+0888
+14F8
+1488
+2288
+4288
+80F8
+0088
+ENDCHAR
+STARTCHAR uni1133
+ENCODING 4403
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 1
+BITMAP
+00C0
+2650
+125C
+1244
+13C4
+3244
+2A44
+4A44
+8BC4
+8244
+ENDCHAR
+STARTCHAR uni1134
+ENCODING 4404
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
+BITMAP
+2108
+1084
+1084
+1084
+294A
+294A
+4A52
+8C62
+8420
+ENDCHAR
+STARTCHAR uni1135
+ENCODING 4405
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1820
+0C20
+0870
+0888
+1488
+1488
+2288
+4288
+8070
+ENDCHAR
+STARTCHAR uni1136
+ENCODING 4406
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+1804
+0DFC
+0820
+0820
+1420
+1450
+2248
+4284
+8104
+0200
+ENDCHAR
+STARTCHAR uni1137
+ENCODING 4407
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
+BITMAP
+00F0
+1804
+0DFC
+0820
+0820
+1420
+1450
+2248
+4284
+8104
+0200
+ENDCHAR
+STARTCHAR uni1138
+ENCODING 4408
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+1804
+0CFC
+0884
+0804
+141C
+14E8
+2208
+4210
+8020
+0040
+ENDCHAR
+STARTCHAR uni1139
+ENCODING 4409
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1808
+0DFC
+0880
+0890
+14F8
+1480
+2280
+4288
+80FC
+ENDCHAR
+STARTCHAR uni113A
+ENCODING 4410
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
+BITMAP
+1802
+0CFE
+0800
+088C
+1444
+1444
+2248
+4209
+80FF
+ENDCHAR
+STARTCHAR uni113B
+ENCODING 4411
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 2 1
+BITMAP
+1804
+0DFE
+0800
+0820
+1470
+1288
+2188
+4188
+8070
+ENDCHAR
+STARTCHAR uni113C
+ENCODING 4412
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 10 4 -1
+BITMAP
+0400
+0400
+0A00
+1100
+1100
+2080
+2000
+4000
+8000
+8000
+ENDCHAR
+STARTCHAR uni113D
+ENCODING 4413
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 -1
+BITMAP
+0410
+0410
+0A28
+1144
+1144
+2082
+2080
+4100
+8200
+8200
+ENDCHAR
+STARTCHAR uni113E
+ENCODING 4414
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 10 4 -1
+BITMAP
+1000
+1000
+2800
+4400
+4400
+8200
+0200
+0100
+0080
+0080
+ENDCHAR
+STARTCHAR uni113F
+ENCODING 4415
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 -1
+BITMAP
+1040
+1040
+28A0
+4510
+4510
+8208
+0208
+0104
+0082
+0082
+ENDCHAR
+STARTCHAR uni1140
+ENCODING 4416
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
+BITMAP
+0800
+0800
+1400
+2200
+2200
+4100
+8080
+8080
+FF80
+ENDCHAR
+STARTCHAR uni1141
+ENCODING 4417
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+1200
+13F0
+7810
+8410
+8410
+8410
+8410
+8410
+7810
+ENDCHAR
+STARTCHAR uni1142
+ENCODING 4418
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1010
+11F0
+7900
+8500
+8500
+8500
+8500
+8510
+79F8
+ENDCHAR
+STARTCHAR uni1143
+ENCODING 4419
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1000
+13F0
+7910
+8510
+8510
+8510
+8510
+85F8
+7900
+ENDCHAR
+STARTCHAR uni1144
+ENCODING 4420
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 10 2 0
+BITMAP
+1030
+1310
+7910
+8510
+85F0
+8510
+8510
+8510
+79F0
+0110
+ENDCHAR
+STARTCHAR uni1145
+ENCODING 4421
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+10C0
+1060
+7840
+8440
+84A0
+8490
+8508
+8608
+7C00
+ENDCHAR
+STARTCHAR uni1146
+ENCODING 4422
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1020
+1020
+7850
+8450
+8488
+8488
+8504
+8504
+79FC
+ENDCHAR
+STARTCHAR uni1147
+ENCODING 4423
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1020
+1020
+78F0
+8508
+8508
+8508
+8508
+8508
+78F0
+ENDCHAR
+STARTCHAR uni1148
+ENCODING 4424
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+1008
+13F8
+7840
+8440
+8440
+84A0
+8490
+8508
+7A08
+0400
+ENDCHAR
+STARTCHAR uni1149
+ENCODING 4425
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 11 2 0
+BITMAP
+01E0
+1008
+13F8
+7840
+8440
+8440
+84A0
+8490
+8508
+7A08
+0400
+ENDCHAR
+STARTCHAR uni114A
+ENCODING 4426
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1010
+13F8
+7900
+8520
+85F0
+8500
+8500
+8510
+79F8
+ENDCHAR
+STARTCHAR uni114B
+ENCODING 4427
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
+BITMAP
+1004
+11FC
+7800
+8518
+8488
+8488
+8490
+8412
+79FE
+ENDCHAR
+STARTCHAR uni114C
+ENCODING 4428
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 8 5 2
+BITMAP
+10
+10
+7C
+82
+82
+82
+82
+7C
+ENDCHAR
+STARTCHAR uni114D
+ENCODING 4429
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 2 0
+BITMAP
+0108
+7F08
+083C
+0842
+0842
+1442
+1242
+2142
+413C
+8000
+ENDCHAR
+STARTCHAR uni114E
+ENCODING 4430
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 4 1
+BITMAP
+00C0
+FFE0
+0400
+0A00
+1100
+1100
+2080
+2000
+4000
+8000
+8000
+ENDCHAR
+STARTCHAR uni114F
+ENCODING 4431
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 1
+BITMAP
+000C
+7FFE
+0410
+0A28
+1144
+1144
+2082
+2080
+4100
+8200
+8200
+ENDCHAR
+STARTCHAR uni1150
+ENCODING 4432
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 4 -1
+BITMAP
+00C0
+FFE0
+0400
+0A00
+1100
+1100
+2080
+0080
+0040
+0020
+0020
+ENDCHAR
+STARTCHAR uni1151
+ENCODING 4433
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 -1
+BITMAP
+0018
+FFFC
+1040
+28A0
+4510
+4510
+8208
+0208
+0104
+0082
+0082
+ENDCHAR
+STARTCHAR uni1152
+ENCODING 4434
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
+BITMAP
+0102
+7F7E
+0842
+0802
+080E
+1474
+1204
+2108
+4110
+8020
+ENDCHAR
+STARTCHAR uni1153
+ENCODING 4435
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
+BITMAP
+3C00
+0138
+7F02
+087F
+0808
+083C
+1442
+1242
+2142
+413C
+8000
+ENDCHAR
+STARTCHAR uni1154
+ENCODING 4436
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
+BITMAP
+0200
+0100
+0118
+FFFC
+0100
+0280
+0440
+0440
+0820
+0800
+1000
+2000
+2000
+ENDCHAR
+STARTCHAR uni1155
+ENCODING 4437
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
+BITMAP
+0200
+0100
+0118
+FFFC
+0100
+0280
+0440
+0440
+0820
+0020
+0010
+0008
+0008
+ENDCHAR
+STARTCHAR uni1156
+ENCODING 4438
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
+BITMAP
+0206
+FE62
+0022
+8C22
+443E
+4422
+4822
+0922
+FF3E
+0022
+ENDCHAR
+STARTCHAR uni1157
+ENCODING 4439
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+0080
+7FC0
+0000
+2300
+1100
+1100
+0240
+FFE0
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
+ENDCHAR
+STARTCHAR uni1158
+ENCODING 4440
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+70E0
+0408
+FDFC
+1020
+78F0
+8508
+8508
+8508
+78F0
+ENDCHAR
+STARTCHAR uni1159
+ENCODING 4441
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 3 0
+BITMAP
+00C0
+FFE0
+0000
+0000
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
+ENDCHAR
+STARTCHAR uni115F
+ENCODING 4447
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
+BITMAP
+B6D6
+8000
+1272
+9280
+1E82
+9282
+9270
+0002
+83C2
+8200
+03C2
+8202
+8200
+0002
+DB6A
+ENDCHAR
+STARTCHAR uni1160
+ENCODING 4448
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
+BITMAP
+B6D6
+8000
+1212
+9210
+1E12
+9292
+9260
+0002
+83C2
+8200
+03C2
+8202
+8200
+0002
+DB6A
+ENDCHAR
+STARTCHAR uni1161
+ENCODING 4449
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 15 5 -2
+BITMAP
+E0
+20
+20
+20
+20
+22
+3E
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni1162
+ENCODING 4450
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 15 6 -2
+BITMAP
+38
+08
+C8
+48
+48
+48
+48
+48
+78
+48
+48
+48
+48
+48
+08
+ENDCHAR
+STARTCHAR uni1163
+ENCODING 4451
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 15 5 -2
+BITMAP
+E0
+20
+20
+20
+22
+3E
+20
+20
+20
+22
+3E
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni1164
+ENCODING 4452
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 5 15 5 -2
+BITMAP
+38
+08
+C8
+48
+48
+78
+48
+48
+48
+78
+48
+48
+48
+48
+08
+ENDCHAR
+STARTCHAR uni1165
+ENCODING 4453
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 15 6 -2
+BITMAP
+38
+08
+08
+08
+08
+08
+88
+F8
+08
+08
+08
+08
+08
+08
+08
+ENDCHAR
+STARTCHAR uni1166
+ENCODING 4454
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 8 15 4 -2
+BITMAP
+07
+01
+19
+09
+09
+09
+89
+F9
+09
+09
+09
+09
+09
+09
+01
+ENDCHAR
+STARTCHAR uni1167
+ENCODING 4455
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 15 6 -2
+BITMAP
+38
+08
+08
+08
+88
+F8
+08
+08
+08
+88
+F8
+08
+08
+08
+08
+ENDCHAR
+STARTCHAR uni1168
+ENCODING 4456
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 8 15 4 -2
+BITMAP
+07
+01
+19
+09
+89
+F9
+09
+09
+89
+F9
+09
+09
+09
+09
+01
+ENDCHAR
+STARTCHAR uni1169
+ENCODING 4457
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 8 1 2
+BITMAP
+0300
+0100
+0100
+0100
+0100
+0100
+010C
+FFFE
+ENDCHAR
+STARTCHAR uni116A
+ENCODING 4458
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+00E0
+0020
+0020
+0C20
+0420
+0420
+0422
+043E
+0420
+05E0
+FE20
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uni116B
+ENCODING 4459
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0070
+0010
+0190
+0090
+0090
+3090
+1090
+10F0
+1190
+1E90
+E090
+0090
+0090
+0090
+0010
+ENDCHAR
+STARTCHAR uni116C
+ENCODING 4460
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 1 -2
+BITMAP
+0070
+0010
+0010
+0C10
+0410
+0410
+0410
+0410
+0410
+04F0
+FF10
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uni116D
+ENCODING 4461
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 7 2 2
+BITMAP
+1860
+0820
+0820
+0840
+0840
+0844
+FFFE
+ENDCHAR
+STARTCHAR uni116E
+ENCODING 4462
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 -2
+BITMAP
+000C
+FFFE
+4100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni116F
+ENCODING 4463
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0038
+0008
+0008
+0008
+0008
+00E8
+FF08
+0408
+0478
+0448
+0408
+0408
+0408
+0408
+0008
+ENDCHAR
+STARTCHAR uni1170
+ENCODING 4464
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 15 2 -2
+BITMAP
+0038
+0008
+00C8
+0048
+0048
+0348
+FC48
+0848
+0A48
+0BC8
+0848
+0848
+0848
+0848
+0008
+ENDCHAR
+STARTCHAR uni1171
+ENCODING 4465
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0070
+0010
+0010
+0010
+0010
+01D0
+FE10
+0810
+0810
+0810
+0810
+0810
+0810
+0810
+0010
+ENDCHAR
+STARTCHAR uni1172
+ENCODING 4466
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 -2
+BITMAP
+0006
+FFFE
+6820
+0820
+0820
+0820
+0820
+0820
+0820
+0820
+0820
+0820
+ENDCHAR
+STARTCHAR uni1173
+ENCODING 4467
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 2 2 4
+BITMAP
+0018
+FFFC
+ENDCHAR
+STARTCHAR uni1174
+ENCODING 4468
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 1 -2
+BITMAP
+0070
+0010
+0010
+0010
+0010
+0010
+0010
+0010
+01F0
+FE10
+0010
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uni1175
+ENCODING 4469
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 3 15 6 -2
+BITMAP
+E0
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni1176
+ENCODING 4470
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
+BITMAP
+00C0
+0040
+0040
+0040
+0048
+0078
+0040
+0040
+0C40
+0440
+0440
+0400
+0420
+FFF0
+ENDCHAR
+STARTCHAR uni1177
+ENCODING 4471
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 4 -2
+BITMAP
+0600
+0200
+0240
+03C0
+0200
+0200
+0200
+0000
+0100
+FF80
+0800
+0800
+0800
+0800
+0800
+ENDCHAR
+STARTCHAR uni1178
+ENCODING 4472
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
+BITMAP
+00C0
+0040
+0048
+0078
+0040
+0040
+0048
+0078
+0C40
+0440
+0440
+0400
+0420
+FFF0
+ENDCHAR
+STARTCHAR uni1179
+ENCODING 4473
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -1
+BITMAP
+0060
+0020
+0024
+003C
+0020
+0020
+0024
+003C
+31A0
+10A0
+10A0
+1100
+1120
+FFF0
+ENDCHAR
+STARTCHAR uni117A
+ENCODING 4474
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -1
+BITMAP
+00C0
+0040
+0040
+0040
+0240
+03C0
+0040
+0040
+0C40
+0440
+0440
+0400
+0420
+FFF0
+ENDCHAR
+STARTCHAR uni117B
+ENCODING 4475
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
+BITMAP
+0600
+0200
+0200
+1E00
+0200
+0200
+0200
+0000
+0100
+FF80
+0800
+0800
+0800
+0800
+0800
+ENDCHAR
+STARTCHAR uni117C
+ENCODING 4476
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -1
+BITMAP
+00C0
+0040
+0040
+0040
+0240
+03C0
+0040
+0040
+0040
+0040
+0040
+0000
+0020
+FFF0
+ENDCHAR
+STARTCHAR uni117D
+ENCODING 4477
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -1
+BITMAP
+0060
+0020
+0120
+01E0
+0020
+0020
+0120
+01E0
+0C20
+0420
+0420
+0400
+0420
+FFF0
+ENDCHAR
+STARTCHAR uni117E
+ENCODING 4478
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
+BITMAP
+0600
+0200
+1E00
+0200
+0200
+1E00
+0200
+0200
+0100
+FF80
+0800
+0800
+0800
+0800
+0800
+ENDCHAR
+STARTCHAR uni117F
+ENCODING 4479
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0070
+0010
+0010
+0010
+0010
+0C10
+0510
+05F0
+0410
+0410
+0410
+05D0
+FE10
+0010
+0010
+ENDCHAR
+STARTCHAR uni1180
+ENCODING 4480
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+000E
+0002
+0032
+0012
+0012
+0012
+0112
+0DF2
+0412
+0412
+0412
+05D2
+0E12
+F012
+0002
+ENDCHAR
+STARTCHAR uni1181
+ENCODING 4481
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+000E
+0002
+0032
+0012
+0112
+01F2
+0012
+0C12
+0512
+05F2
+0412
+05D2
+0E12
+F012
+0002
+ENDCHAR
+STARTCHAR uni1182
+ENCODING 4482
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 13 2 0
+BITMAP
+0600
+0200
+0200
+0200
+0230
+FFF8
+0000
+0600
+0200
+0200
+0200
+0230
+FFF8
+ENDCHAR
+STARTCHAR uni1183
+ENCODING 4483
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 14 3 -2
+BITMAP
+0C00
+0400
+0400
+0400
+0440
+FFE0
+0000
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni1184
+ENCODING 4484
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+001C
+0010
+0010
+0010
+0012
+001E
+0010
+3310
+1110
+1112
+111E
+1170
+1790
+F810
+0010
+ENDCHAR
+STARTCHAR uni1185
+ENCODING 4485
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+000E
+0002
+0032
+0012
+0012
+001E
+0012
+3312
+1112
+111E
+1112
+1172
+1792
+F812
+0002
+ENDCHAR
+STARTCHAR uni1186
+ENCODING 4486
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+000E
+0002
+0002
+0002
+0022
+003E
+0002
+3302
+1122
+113E
+1102
+1162
+1782
+F802
+0002
+ENDCHAR
+STARTCHAR uni1187
+ENCODING 4487
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 13 2 0
+BITMAP
+30C0
+1040
+1040
+1080
+1090
+FFF8
+0000
+0600
+0200
+0200
+0200
+0230
+FFF8
+ENDCHAR
+STARTCHAR uni1188
+ENCODING 4488
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0070
+0010
+0010
+0010
+0010
+0010
+0010
+0C10
+0410
+0410
+0410
+05D0
+0E10
+F010
+0010
+ENDCHAR
+STARTCHAR uni1189
+ENCODING 4489
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 15 1 -2
+BITMAP
+0070
+0010
+0010
+0010
+0010
+0010
+0011
+0C1F
+0410
+0410
+0410
+05D0
+0E10
+F010
+0010
+ENDCHAR
+STARTCHAR uni118A
+ENCODING 4490
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+00E0
+0020
+0020
+0020
+0020
+0020
+0022
+013E
+FFA0
+0820
+0820
+0820
+0820
+0820
+0020
+ENDCHAR
+STARTCHAR uni118B
+ENCODING 4491
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+001C
+0004
+0064
+0024
+0024
+003C
+0024
+0124
+FFA4
+083C
+0824
+0824
+0824
+0824
+0004
+ENDCHAR
+STARTCHAR uni118C
+ENCODING 4492
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
+BITMAP
+00E0
+0020
+0020
+0020
+0020
+0020
+0022
+013E
+FFA0
+0820
+0820
+0820
+0820
+0820
+00E0
+FFC0
+ENDCHAR
+STARTCHAR uni118D
+ENCODING 4493
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 14 3 -2
+BITMAP
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni118E
+ENCODING 4494
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+01C0
+0040
+0040
+0040
+0040
+0048
+0078
+0040
+0F40
+F440
+2440
+2440
+2440
+2440
+0040
+ENDCHAR
+STARTCHAR uni118F
+ENCODING 4495
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 3 -2
+BITMAP
+01C0
+0040
+0040
+0040
+0040
+0240
+03C0
+0040
+0F40
+F440
+2440
+2440
+2440
+2440
+0040
+ENDCHAR
+STARTCHAR uni1190
+ENCODING 4496
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+000E
+0002
+0032
+0012
+0F12
+F412
+2512
+25F2
+2412
+2412
+0012
+0012
+0012
+0012
+0002
+ENDCHAR
+STARTCHAR uni1191
+ENCODING 4497
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 1 -2
+BITMAP
+0070
+0010
+0010
+0010
+0090
+00F0
+0010
+0F10
+F410
+2490
+24F0
+2410
+2410
+0010
+0010
+ENDCHAR
+STARTCHAR uni1192
+ENCODING 4498
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+000E
+0002
+0032
+0012
+0092
+00F2
+0012
+0F12
+F492
+24F2
+2412
+2412
+2412
+0012
+0002
+ENDCHAR
+STARTCHAR uni1193
+ENCODING 4499
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+0040
+FFE0
+1100
+1100
+1100
+1100
+1100
+0000
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni1194
+ENCODING 4500
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 3 -2
+BITMAP
+01C0
+0040
+0040
+0040
+0040
+0040
+0040
+0040
+0F40
+F440
+2440
+2440
+2440
+2440
+0040
+ENDCHAR
+STARTCHAR uni1195
+ENCODING 4501
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 10 3 1
+BITMAP
+0040
+FFE0
+0000
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni1196
+ENCODING 4502
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 5 3 4
+BITMAP
+0040
+FFE0
+0000
+0040
+FFE0
+ENDCHAR
+STARTCHAR uni1197
+ENCODING 4503
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+01C0
+0040
+0040
+0040
+0040
+00C0
+0740
+F800
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni1198
+ENCODING 4504
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+EE00
+2200
+2200
+2200
+2200
+2200
+2220
+23E0
+2200
+2200
+2200
+2200
+2200
+2200
+2200
+ENDCHAR
+STARTCHAR uni1199
+ENCODING 4505
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+EE00
+2200
+2200
+2200
+2220
+23E0
+2200
+2200
+2220
+23E0
+2200
+2200
+2200
+2200
+2200
+ENDCHAR
+STARTCHAR uni119A
+ENCODING 4506
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 13 2 0
+BITMAP
+00E0
+0020
+0020
+0020
+0020
+0020
+0020
+0620
+0200
+0200
+0200
+0230
+FFF8
+ENDCHAR
+STARTCHAR uni119B
+ENCODING 4507
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+00E0
+0020
+0020
+0020
+0020
+0020
+0020
+0000
+0030
+FFF8
+0200
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni119C
+ENCODING 4508
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 1
+BITMAP
+0070
+0010
+0010
+0010
+0010
+0010
+0010
+0010
+0010
+0000
+000C
+FFFE
+ENDCHAR
+STARTCHAR uni119D
+ENCODING 4509
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 3 13 4 0
+BITMAP
+C0
+40
+40
+40
+40
+40
+40
+00
+00
+40
+20
+20
+20
+ENDCHAR
+STARTCHAR uni119E
+ENCODING 4510
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 2 4 6 5
+BITMAP
+80
+40
+40
+40
+ENDCHAR
+STARTCHAR uni119F
+ENCODING 4511
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 15 4 -2
+BITMAP
+0E
+02
+02
+02
+02
+02
+22
+3E
+02
+82
+42
+42
+42
+02
+02
+ENDCHAR
+STARTCHAR uni11A0
+ENCODING 4512
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 12 3 1
+BITMAP
+0800
+0400
+0400
+0400
+0000
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni11A1
+ENCODING 4513
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 6 15 4 -2
+BITMAP
+1C
+04
+04
+04
+04
+04
+84
+44
+44
+44
+04
+04
+04
+04
+04
+ENDCHAR
+STARTCHAR uni11A2
+ENCODING 4514
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 4 5 5
+BITMAP
+90
+48
+48
+48
+ENDCHAR
+STARTCHAR uni11A8
+ENCODING 4520
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 10 3 0
+BITMAP
+8000
+FFE0
+0020
+0020
+0020
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uni11A9
+ENCODING 4521
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+8100
+FDF0
+0410
+0410
+0410
+0410
+0410
+0410
+0410
+ENDCHAR
+STARTCHAR uni11AA
+ENCODING 4522
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+8000
+FCC0
+0460
+0440
+0440
+04A0
+0490
+0508
+0608
+0400
+ENDCHAR
+STARTCHAR uni11AB
+ENCODING 4523
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 7 2 2
+BITMAP
+C000
+4000
+4000
+4000
+4000
+4060
+3FF0
+ENDCHAR
+STARTCHAR uni11AC
+ENCODING 4524
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 0
+BITMAP
+C0C0
+4060
+4040
+4040
+40A0
+4490
+5908
+2208
+0400
+ENDCHAR
+STARTCHAR uni11AD
+ENCODING 4525
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 0
+BITMAP
+C0E0
+4008
+41FC
+4020
+40F0
+4508
+5908
+2108
+00F0
+ENDCHAR
+STARTCHAR uni11AE
+ENCODING 4526
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 8 2 2
+BITMAP
+0040
+FFE0
+4000
+4000
+4000
+4000
+4060
+7FF0
+ENDCHAR
+STARTCHAR uni11AF
+ENCODING 4527
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+0040
+FFC0
+4040
+0040
+7FC0
+4000
+4000
+4060
+7FF0
+ENDCHAR
+STARTCHAR uni11B0
+ENCODING 4528
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 3 1
+BITMAP
+0100
+FDF0
+0810
+0810
+FC10
+4010
+4010
+4210
+7C10
+ENDCHAR
+STARTCHAR uni11B1
+ENCODING 4529
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
+BITMAP
+FDF8
+0888
+0888
+FC88
+4088
+4088
+42FC
+7C80
+ENDCHAR
+STARTCHAR uni11B2
+ENCODING 4530
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0018
+FD88
+0888
+0888
+FCF8
+4088
+4088
+4288
+7CF8
+0088
+ENDCHAR
+STARTCHAR uni11B3
+ENCODING 4531
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
+BITMAP
+0030
+FC18
+0810
+0810
+FC28
+4024
+4042
+4282
+7D00
+ENDCHAR
+STARTCHAR uni11B4
+ENCODING 4532
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
+BITMAP
+0008
+FDFC
+0880
+0890
+FCF8
+4080
+4080
+4288
+7CFC
+ENDCHAR
+STARTCHAR uni11B5
+ENCODING 4533
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
+BITMAP
+0004
+FDFC
+0800
+0918
+FC88
+4088
+4090
+4212
+7DFE
+ENDCHAR
+STARTCHAR uni11B6
+ENCODING 4534
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
+BITMAP
+00E0
+FC08
+09FC
+0820
+FCF0
+4108
+4108
+4308
+7CF0
+ENDCHAR
+STARTCHAR uni11B7
+ENCODING 4535
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 8 3 1
+BITMAP
+FFE0
+4020
+4040
+4040
+4040
+4040
+7FC0
+4000
+ENDCHAR
+STARTCHAR uni11B8
+ENCODING 4536
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 11 3 0
+BITMAP
+00C0
+C040
+4040
+4040
+7FC0
+4040
+4040
+4040
+4040
+7FC0
+4040
+ENDCHAR
+STARTCHAR uni11B9
+ENCODING 4537
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
+BITMAP
+0C30
+C418
+4410
+4410
+7C28
+4424
+4442
+4482
+7D00
+4400
+ENDCHAR
+STARTCHAR uni11BA
+ENCODING 4538
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+0800
+0600
+0400
+0C00
+0B00
+1080
+2060
+4020
+8010
+ENDCHAR
+STARTCHAR uni11BB
+ENCODING 4539
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1860
+0C30
+0820
+0820
+1450
+1248
+2184
+4104
+8200
+ENDCHAR
+STARTCHAR uni11BC
+ENCODING 4540
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
+BITMAP
+0800
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+3E00
+ENDCHAR
+STARTCHAR uni11BD
+ENCODING 4541
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 9 3 1
+BITMAP
+0080
+FFC0
+0400
+0400
+0C00
+0A00
+1180
+60C0
+8040
+ENDCHAR
+STARTCHAR uni11BE
+ENCODING 4542
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 9 2 1
+BITMAP
+1F00
+0000
+FFE0
+4400
+0400
+0A00
+1180
+2040
+C020
+ENDCHAR
+STARTCHAR uni11BF
+ENCODING 4543
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 10 3 1
+BITMAP
+00C0
+FF40
+6040
+0040
+01C0
+1E40
+E040
+0080
+0080
+0080
+ENDCHAR
+STARTCHAR uni11C0
+ENCODING 4544
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+00C0
+FFE0
+4000
+4180
+7FC0
+4000
+4000
+4060
+7FF0
+ENDCHAR
+STARTCHAR uni11C1
+ENCODING 4545
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+4060
+7FF0
+0000
+00C0
+1040
+0880
+0880
+8130
+FFF8
+ENDCHAR
+STARTCHAR uni11C2
+ENCODING 4546
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0F80
+0010
+FFF8
+0200
+0F80
+1040
+1040
+1040
+1040
+0F80
+ENDCHAR
+STARTCHAR uni11C3
+ENCODING 4547
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+8000
+FDF8
+0410
+0410
+05F8
+0480
+0480
+0484
+04F8
+ENDCHAR
+STARTCHAR uni11C4
+ENCODING 4548
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+8240
+F178
+1108
+1108
+1288
+1288
+1448
+1848
+1808
+ENDCHAR
+STARTCHAR uni11C5
+ENCODING 4549
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 9 3 1
+BITMAP
+0400
+C7C0
+4040
+4040
+4040
+4040
+4440
+5840
+2040
+ENDCHAR
+STARTCHAR uni11C6
+ENCODING 4550
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+0010
+C1F0
+4100
+4100
+4100
+4100
+4500
+5910
+61F8
+ENDCHAR
+STARTCHAR uni11C7
+ENCODING 4551
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+00C0
+C060
+4040
+4040
+40A0
+4090
+4508
+5A08
+2400
+ENDCHAR
+STARTCHAR uni11C8
+ENCODING 4552
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 8 2 1
+BITMAP
+C040
+4040
+40A0
+40A0
+4110
+4510
+5A08
+23F8
+ENDCHAR
+STARTCHAR uni11C9
+ENCODING 4553
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+0010
+C3F8
+4100
+4120
+41F0
+4100
+4500
+5910
+61F8
+ENDCHAR
+STARTCHAR uni11CA
+ENCODING 4554
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+0900
+F9F0
+8010
+8010
+8010
+8010
+8010
+8810
+FC10
+ENDCHAR
+STARTCHAR uni11CB
+ENCODING 4555
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+0800
+FBF0
+8020
+8020
+83F0
+8100
+8100
+8908
+FDF0
+ENDCHAR
+STARTCHAR uni11CC
+ENCODING 4556
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
+BITMAP
+0410
+FF88
+1088
+1088
+F894
+4094
+40A2
+44A2
+78C0
+ENDCHAR
+STARTCHAR uni11CD
+ENCODING 4557
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
+BITMAP
+FCC0
+0840
+0840
+FC40
+4040
+4044
+4258
+7C20
+ENDCHAR
+STARTCHAR uni11CE
+ENCODING 4558
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
+BITMAP
+0008
+FCF8
+0880
+0880
+FC80
+4080
+4080
+4288
+7CFC
+ENDCHAR
+STARTCHAR uni11CF
+ENCODING 4559
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
+BITMAP
+004C
+FBC1
+121F
+1204
+FA0E
+4211
+4211
+4651
+7BCE
+ENDCHAR
+STARTCHAR uni11D0
+ENCODING 4560
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
+BITMAP
+FDF8
+0810
+0810
+FDF8
+4080
+4080
+4284
+7CF8
+ENDCHAR
+STARTCHAR uni11D1
+ENCODING 4561
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
+BITMAP
+0008
+FBEF
+1121
+1121
+F921
+4121
+4121
+45F1
+7901
+ENDCHAR
+STARTCHAR uni11D2
+ENCODING 4562
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
+BITMAP
+0008
+FFC4
+1244
+1244
+FA4A
+424A
+4251
+47F1
+7A20
+ENDCHAR
+STARTCHAR uni11D3
+ENCODING 4563
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 10 1 0
+BITMAP
+00C8
+FE44
+1244
+1244
+FBCA
+424A
+4251
+4251
+7BE0
+0240
+ENDCHAR
+STARTCHAR uni11D4
+ENCODING 4564
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
+BITMAP
+00D8
+FE42
+127E
+1248
+FBDC
+4262
+4262
+4262
+7BDC
+0240
+ENDCHAR
+STARTCHAR uni11D5
+ENCODING 4565
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -1
+BITMAP
+000C
+0184
+0084
+00FC
+FC84
+0884
+08FC
+FC84
+4020
+4078
+4284
+7C84
+0084
+0078
+ENDCHAR
+STARTCHAR uni11D6
+ENCODING 4566
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
+BITMAP
+0110
+F888
+1088
+1088
+F888
+4198
+4154
+4664
+7C44
+ENDCHAR
+STARTCHAR uni11D7
+ENCODING 4567
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 1 1
+BITMAP
+FE20
+0420
+0450
+FE50
+4088
+4088
+4104
+7FFC
+ENDCHAR
+STARTCHAR uni11D8
+ENCODING 4568
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0008
+FDF8
+0908
+0808
+FC38
+41D0
+4010
+4220
+7C40
+0080
+ENDCHAR
+STARTCHAR uni11D9
+ENCODING 4569
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 2 1
+BITMAP
+0004
+FDFE
+0800
+0820
+F870
+4088
+4088
+4288
+7C70
+ENDCHAR
+STARTCHAR uni11DA
+ENCODING 4570
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+0100
+FDF0
+4410
+4410
+4410
+4410
+4410
+7E10
+4010
+ENDCHAR
+STARTCHAR uni11DB
+ENCODING 4571
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 1 1
+BITMAP
+FDF8
+4410
+4410
+45F0
+4480
+4480
+7E84
+40F8
+ENDCHAR
+STARTCHAR uni11DC
+ENCODING 4572
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0018
+FD88
+4488
+4488
+44F8
+4488
+4488
+7E88
+40F8
+0088
+ENDCHAR
+STARTCHAR uni11DD
+ENCODING 4573
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+0060
+FC30
+4420
+4420
+4450
+4448
+4484
+7F04
+4200
+ENDCHAR
+STARTCHAR uni11DE
+ENCODING 4574
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
+BITMAP
+0088
+FC44
+4444
+4444
+44AA
+44AA
+4511
+7F11
+4220
+ENDCHAR
+STARTCHAR uni11DF
+ENCODING 4575
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 8 1 1
+BITMAP
+FC10
+4410
+4428
+4428
+4444
+4444
+7E82
+40FE
+ENDCHAR
+STARTCHAR uni11E0
+ENCODING 4576
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
+BITMAP
+00F0
+0004
+FDFC
+4420
+4420
+4420
+4450
+4448
+7E84
+4104
+0200
+ENDCHAR
+STARTCHAR uni11E1
+ENCODING 4577
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+0070
+FC04
+44FC
+4410
+4478
+4484
+4484
+7E84
+4078
+ENDCHAR
+STARTCHAR uni11E2
+ENCODING 4578
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 13 3 -1
+BITMAP
+FF00
+4100
+4100
+4100
+7F80
+4000
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
+ENDCHAR
+STARTCHAR uni11E3
+ENCODING 4579
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+0C00
+C5F8
+4410
+4410
+7DF8
+4480
+4480
+4484
+7CF8
+4400
+ENDCHAR
+STARTCHAR uni11E4
+ENCODING 4580
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
+BITMAP
+0C04
+C5FC
+4400
+4518
+7C88
+4488
+4490
+4412
+7DFE
+4400
+ENDCHAR
+STARTCHAR uni11E5
+ENCODING 4581
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0C00
+C4E0
+4408
+45F8
+7C20
+44F0
+4508
+4508
+7D08
+44F0
+ENDCHAR
+STARTCHAR uni11E6
+ENCODING 4582
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
+BITMAP
+0180
+C080
+4080
+7F80
+4080
+4080
+7F80
+4080
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
+ENDCHAR
+STARTCHAR uni11E7
+ENCODING 4583
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1900
+0DF8
+0808
+0808
+1408
+1408
+2208
+4208
+8008
+ENDCHAR
+STARTCHAR uni11E8
+ENCODING 4584
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1808
+0CF8
+0880
+0880
+1480
+1480
+2280
+4288
+80FC
+ENDCHAR
+STARTCHAR uni11E9
+ENCODING 4585
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1800
+0DF8
+0810
+0810
+15F8
+1480
+2280
+4284
+81F8
+ENDCHAR
+STARTCHAR uni11EA
+ENCODING 4586
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+1818
+0D88
+0888
+0888
+14F8
+1488
+2288
+4288
+80F8
+0088
+ENDCHAR
+STARTCHAR uni11EB
+ENCODING 4587
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
+BITMAP
+0800
+0800
+1400
+2200
+2200
+4100
+8080
+8080
+FF80
+ENDCHAR
+STARTCHAR uni11EC
+ENCODING 4588
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
+BITMAP
+1200
+13F0
+7810
+8410
+8410
+8410
+8410
+8410
+7810
+ENDCHAR
+STARTCHAR uni11ED
+ENCODING 4589
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
+BITMAP
+2420
+27BC
+7084
+8884
+8884
+8884
+8884
+8884
+7084
+ENDCHAR
+STARTCHAR uni11EE
+ENCODING 4590
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+1020
+1020
+78F0
+8508
+8508
+8508
+8508
+8508
+78F0
+ENDCHAR
+STARTCHAR uni11EF
+ENCODING 4591
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+1008
+11F8
+7908
+8408
+8438
+85D0
+8410
+8420
+7840
+0080
+ENDCHAR
+STARTCHAR uni11F0
+ENCODING 4592
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
+BITMAP
+0800
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+3E00
+ENDCHAR
+STARTCHAR uni11F1
+ENCODING 4593
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+10C0
+1060
+7840
+8440
+84A0
+8490
+8508
+8608
+7C00
+ENDCHAR
+STARTCHAR uni11F2
+ENCODING 4594
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1020
+1020
+7850
+8450
+8488
+8488
+8504
+8504
+79FC
+ENDCHAR
+STARTCHAR uni11F3
+ENCODING 4595
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
+BITMAP
+020C
+FEC4
+0044
+8C44
+447C
+4444
+4844
+0944
+FF7C
+0044
+ENDCHAR
+STARTCHAR uni11F4
+ENCODING 4596
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+0080
+7FC0
+0000
+2300
+1100
+1100
+0240
+FFE0
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
+ENDCHAR
+STARTCHAR uni11F5
+ENCODING 4597
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
+BITMAP
+7000
+0580
+FC80
+1080
+7880
+8480
+8488
+84B0
+78C0
+ENDCHAR
+STARTCHAR uni11F6
+ENCODING 4598
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+7000
+05F8
+FC10
+1010
+79F8
+8480
+8480
+8484
+78F8
+ENDCHAR
+STARTCHAR uni11F7
+ENCODING 4599
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+7000
+05F8
+FC88
+1088
+7888
+8488
+8488
+84FC
+7880
+ENDCHAR
+STARTCHAR uni11F8
+ENCODING 4600
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
+BITMAP
+0018
+7188
+0488
+FC88
+10F8
+7888
+8488
+8488
+84F8
+7888
+ENDCHAR
+STARTCHAR uni11F9
+ENCODING 4601
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 3 0
+BITMAP
+00C0
+FFE0
+0000
+0000
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
+ENDCHAR
+STARTCHAR uni137F
+ENCODING 4991
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -1
+BITMAP
+0FE0
+1838
+37CC
+6CCC
+ECC6
+CCC6
+C8C6
+C8C6
+C8C4
+C8CC
+60F0
+7000
+3800
+0F80
+ENDCHAR
 STARTCHAR uni1F06
 ENCODING 7942
 SWIDTH 480 0
@@ -2511,9 +6803,9 @@
 ENDCHAR
 STARTCHAR uni1F8E
 ENCODING 8078
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 19 -1 -4
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 15 -1 0
 BITMAP
 7800
 8400
@@ -2526,20 +6818,16 @@
 0500
 0880
 0880
-0F80
-1040
-1040
-78F0
-0600
-0200
-0280
-0100
+0F8C
+1044
+1045
+78F2
 ENDCHAR
 STARTCHAR uni1F8F
 ENCODING 8079
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 19 -1 -4
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 15 -1 0
 BITMAP
 7800
 8400
@@ -2552,14 +6840,10 @@
 0500
 0880
 0880
-0F80
-1040
-1040
-78F0
-0600
-0200
-0280
-0100
+0F8C
+1044
+1045
+78F2
 ENDCHAR
 STARTCHAR uni1F96
 ENCODING 8086
@@ -2613,57 +6897,47 @@
 ENDCHAR
 STARTCHAR uni1F9E
 ENCODING 8094
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 20 0 -5
-BITMAP
-7800
-8400
-3000
-3000
-17DF
-2104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-0000
-00C0
-0040
-0050
-0020
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 15 0 0
+BITMAP
+780000
+840000
+300000
+300000
+17DF00
+210400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
 STARTCHAR uni1F9F
 ENCODING 8095
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 20 0 -5
-BITMAP
-7800
-8400
-3000
-3000
-27DF
-1104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-0000
-00C0
-0040
-0050
-0020
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 15 0 0
+BITMAP
+780000
+840000
+300000
+300000
+27DF00
+110400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
 STARTCHAR uni1FA6
 ENCODING 8102
@@ -2719,55 +6993,47 @@
 ENDCHAR
 STARTCHAR uni1FAE
 ENCODING 8110
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 19 0 -4
-BITMAP
-7800
-8400
-3000
-3000
-13E0
-2410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
-0180
-0080
-00A0
-0040
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 15 0 0
+BITMAP
+780000
+840000
+300000
+300000
+13E000
+241000
+080800
+080800
+080800
+080800
+041000
+041300
+022100
+0A2940
+0E3880
 ENDCHAR
 STARTCHAR uni1FAF
 ENCODING 8111
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 19 0 -4
-BITMAP
-7800
-8400
-3000
-3000
-23E0
-1410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
-0180
-0080
-00A0
-0040
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 15 0 0
+BITMAP
+780000
+840000
+300000
+300000
+23E000
+141000
+080800
+080800
+080800
+080800
+041000
+041300
+022100
+0A2940
+0E3880
 ENDCHAR
 STARTCHAR uni1FB6
 ENCODING 8118
@@ -3037,23 +7303,59 @@
 BE
 BC
 ENDCHAR
-STARTCHAR uni20A3
+STARTCHAR C070
 ENCODING 8355
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 0 0
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 11 2 0
 BITMAP
 FF80
 2080
 2080
-2000
-7F00
 2000
-7F00
+2700
+3C80
+2480
+2700
+2500
+2480
+FC80
+ENDCHAR
+STARTCHAR C080
+ENCODING 8359
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 0
+BITMAP
+FF00
+2180
+2080
+FFE0
+2080
+2180
+3F00
 2000
 2000
 2000
 F800
+ENDCHAR
+STARTCHAR C082
+ENCODING 8360
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 11 2 0
+BITMAP
+FE00
+2100
+2080
+FFE0
+209E
+2122
+3E20
+231C
+2102
+2122
+F8FC
 ENDCHAR
 STARTCHAR uni20AF
 ENCODING 8367
Index: xc/extras/fonts/ClearlyU/cu-arabic12.bdf
diff -u xc/extras/fonts/ClearlyU/cu-arabic12.bdf:1.4 xc/extras/fonts/ClearlyU/cu-arabic12.bdf:1.5
--- xc/extras/fonts/ClearlyU/cu-arabic12.bdf:1.4	Wed Nov 21 15:58:14 2001
+++ xc/extras/fonts/ClearlyU/cu-arabic12.bdf	Fri Dec 13 22:51:39 2002
@@ -1,8 +1,8 @@
 STARTFONT 2.1
 COMMENT 
-COMMENT Id: cu-arabic12.bdf,v 1.6 2001/10/23 23:55:31 mleisher Exp $
+COMMENT Id: cu-arabic12.bdf,v 1.7 2002/11/22 22:46:24 mleisher Exp $
 COMMENT 
-COMMENT Copyright 2001 Computing Research Labs, New Mexico State University
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
 COMMENT 
 COMMENT Permission is hereby granted, free of charge, to any person
 COMMENT obtaining a copy of this software and associated documentation
@@ -28,7 +28,7 @@
 COMMENT This font contains the contextual glyph forms that are not encoded
 COMMENT in Unicode.
 COMMENT 
-FONT -MUTT-ClearlyU Arabic Extra-Medium-R-Normal--17-120-100-100-P-103-FontSpecific-0
+FONT -MUTT-ClearlyU Arabic Extra-Medium-R-Normal--17-120-100-100-P-101-FontSpecific-0
 SIZE 12 100 100
 FONTBOUNDINGBOX 21 27 -1 -10
 STARTPROPERTIES 20
@@ -39,7 +39,7 @@
 RESOLUTION_Y 100
 FONT_ASCENT 17
 FONT_DESCENT 9
-AVERAGE_WIDTH 103
+AVERAGE_WIDTH 101
 SPACING "P"
 FOUNDRY "MUTT"
 FAMILY_NAME "ClearlyU Arabic Extra"
Index: xc/extras/fonts/ClearlyU/cu-devnag12.bdf
diff -u xc/extras/fonts/ClearlyU/cu-devnag12.bdf:1.2 xc/extras/fonts/ClearlyU/cu-devnag12.bdf:1.3
--- xc/extras/fonts/ClearlyU/cu-devnag12.bdf:1.2	Wed Nov 21 15:58:15 2001
+++ xc/extras/fonts/ClearlyU/cu-devnag12.bdf	Fri Dec 13 22:51:39 2002
@@ -1,8 +1,8 @@
 STARTFONT 2.1
 COMMENT 
-COMMENT Id: cu-devnag12.bdf,v 1.1 2001/10/23 23:55:31 mleisher Exp $
+COMMENT Id: cu-devnag12.bdf,v 1.2 2002/11/22 22:46:25 mleisher Exp $
 COMMENT 
-COMMENT Copyright 2001 Computing Research Labs, New Mexico State University
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
 COMMENT 
 COMMENT Permission is hereby granted, free of charge, to any person
 COMMENT obtaining a copy of this software and associated documentation
@@ -28,7 +28,7 @@
 COMMENT This font contains some of the basic glyph forms that are not encoded
 COMMENT in Unicode.
 COMMENT 
-FONT -MUTT-ClearlyU Devangari Extra-Medium-R-Normal--17-120-100-100-P-111-FontSpecific-0
+FONT -MUTT-ClearlyU Devangari Extra-Medium-R-Normal--17-120-100-100-P-105-FontSpecific-0
 SIZE 12 100 100
 FONTBOUNDINGBOX 25 25 -6 -7
 STARTPROPERTIES 18
@@ -39,7 +39,7 @@
 RESOLUTION_Y 100
 FONT_ASCENT 12
 FONT_DESCENT 3
-AVERAGE_WIDTH 111
+AVERAGE_WIDTH 105
 SPACING "P"
 FOUNDRY "MUTT"
 FAMILY_NAME "ClearlyU Devangari Extra"
@@ -49,7 +49,7 @@
 ADD_STYLE_NAME ""
 CHARSET_REGISTRY "FontSpecific"
 CHARSET_ENCODING "0"
-_XMBDFED_INFO "Edited with xmbdfed 4.3."
+_XMBDFED_INFO "Edited with xmbdfed 4.4."
 ENDPROPERTIES
 CHARS 114
 STARTCHAR uni0000
Index: xc/extras/fonts/ClearlyU/cu-lig12.bdf
diff -u xc/extras/fonts/ClearlyU/cu-lig12.bdf:1.4 xc/extras/fonts/ClearlyU/cu-lig12.bdf:1.5
--- xc/extras/fonts/ClearlyU/cu-lig12.bdf:1.4	Wed Nov 21 15:58:15 2001
+++ xc/extras/fonts/ClearlyU/cu-lig12.bdf	Fri Dec 13 22:51:39 2002
@@ -1,8 +1,8 @@
 STARTFONT 2.1
 COMMENT 
-COMMENT Id: cu-lig12.bdf,v 1.6 2001/10/23 23:55:31 mleisher Exp $
+COMMENT Id: cu-lig12.bdf,v 1.7 2002/11/22 22:46:25 mleisher Exp $
 COMMENT 
-COMMENT Copyright 2001 Computing Research Labs, New Mexico State University
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
 COMMENT 
 COMMENT Permission is hereby granted, free of charge, to any person
 COMMENT obtaining a copy of this software and associated documentation
Index: xc/extras/fonts/ClearlyU/cu-pua12.bdf
diff -u xc/extras/fonts/ClearlyU/cu-pua12.bdf:1.4 xc/extras/fonts/ClearlyU/cu-pua12.bdf:1.5
--- xc/extras/fonts/ClearlyU/cu-pua12.bdf:1.4	Wed Nov 21 15:58:15 2001
+++ xc/extras/fonts/ClearlyU/cu-pua12.bdf	Fri Dec 13 22:51:39 2002
@@ -1,8 +1,8 @@
 STARTFONT 2.1
 COMMENT 
-COMMENT Id: cu-pua12.bdf,v 1.7 2001/10/23 23:55:31 mleisher Exp $
+COMMENT Id: cu-pua12.bdf,v 1.8 2002/11/22 22:46:25 mleisher Exp $
 COMMENT 
-COMMENT Copyright 2001 Computing Research Labs, New Mexico State University
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
 COMMENT 
 COMMENT Permission is hereby granted, free of charge, to any person
 COMMENT obtaining a copy of this software and associated documentation
@@ -57,7 +57,7 @@
 _XMBDFED_INFO "Edited with xmbdfed 4.4."
 DEFAULT_CHAR 65534
 ENDPROPERTIES
-CHARS 59
+CHARS 53
 STARTCHAR uniE12E
 ENCODING 57646
 SWIDTH 360 0
@@ -188,122 +188,6 @@
 10
 90
 E0
-ENDCHAR
-STARTCHAR uni04C5
-ENCODING 58565
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 13 1 -2
-BITMAP
-7FC0
-2100
-2100
-2100
-2100
-2100
-2100
-2100
-2100
-A100
-C7C0
-00C0
-0040
-ENDCHAR
-STARTCHAR uni04C6
-ENCODING 58566
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 9 1 -2
-BITMAP
-FE
-44
-44
-44
-44
-C4
-CE
-02
-02
-ENDCHAR
-STARTCHAR uni04C9
-ENCODING 58569
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 17 0 -2
-BITMAP
-1100
-0E00
-0000
-0000
-FBE0
-2180
-2180
-2280
-2280
-2480
-2880
-2880
-3080
-3080
-FBE0
-0060
-0020
-ENDCHAR
-STARTCHAR uni04CA
-ENCODING 58570
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 13 1 -2
-BITMAP
-44
-38
-00
-00
-EE
-4C
-54
-54
-54
-64
-EE
-02
-02
-ENDCHAR
-STARTCHAR uni04CD
-ENCODING 58573
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 13 0 -2
-BITMAP
-F03C
-3030
-3030
-2850
-2850
-2890
-2490
-2490
-2310
-2310
-FB7C
-000C
-0004
-ENDCHAR
-STARTCHAR uni04CE
-ENCODING 58574
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 -2
-BITMAP
-C180
-6300
-6300
-5500
-5500
-4900
-EB80
-0080
-0080
 ENDCHAR
 STARTCHAR uni04FA
 ENCODING 58618
Index: xc/extras/fonts/ClearlyU/cu12.bdf
diff -u xc/extras/fonts/ClearlyU/cu12.bdf:1.6 xc/extras/fonts/ClearlyU/cu12.bdf:1.7
--- xc/extras/fonts/ClearlyU/cu12.bdf:1.6	Wed Nov 21 15:58:15 2001
+++ xc/extras/fonts/ClearlyU/cu12.bdf	Fri Dec 13 22:51:39 2002
@@ -1,8 +1,8 @@
 STARTFONT 2.1
 COMMENT 
-COMMENT Id: cu12.bdf,v 1.16 2001/10/29 18:54:12 mleisher Exp $
+COMMENT Id: cu12.bdf,v 1.26 2002/11/22 23:07:56 mleisher Exp $
 COMMENT 
-COMMENT Copyright 2001 Computing Research Labs, New Mexico State University
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
 COMMENT 
 COMMENT Permission is hereby granted, free of charge, to any person
 COMMENT obtaining a copy of this software and associated documentation
@@ -25,9 +25,9 @@
 COMMENT OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 COMMENT SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 COMMENT 
-FONT -MUTT-ClearlyU-Medium-R-Normal--17-120-100-100-P-124-ISO10646-1
+FONT -MUTT-ClearlyU-Medium-R-Normal--17-120-100-100-P-123-ISO10646-1
 SIZE 12 100 100
-FONTBOUNDINGBOX 31 30 -7 -10
+FONTBOUNDINGBOX 40 30 -9 -10
 STARTPROPERTIES 21
 FONT_ASCENT 20
 FONT_DESCENT 9
@@ -44,22 +44,22 @@
 RESOLUTION_X 100
 RESOLUTION_Y 100
 SPACING "P"
-AVERAGE_WIDTH 124
+AVERAGE_WIDTH 123
 CHARSET_REGISTRY "ISO10646"
 CHARSET_ENCODING "1"
 DEFAULT_CHAR 65533
 CAP_HEIGHT 11
 X_HEIGHT 7
 ENDPROPERTIES
-CHARS 8241
-STARTCHAR space
+CHARS 8453
+STARTCHAR uni0020
 ENCODING 32
 SWIDTH 300 0
 DWIDTH 5 0
 BBX 0 0 0 0
 BITMAP
 ENDCHAR
-STARTCHAR C033
+STARTCHAR uni0021
 ENCODING 33
 SWIDTH 300 0
 DWIDTH 5 0
@@ -78,19 +78,19 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C034
+STARTCHAR uni0022
 ENCODING 34
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 7
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 5 2 7
 BITMAP
-D8
-D8
-48
-48
 90
+90
+90
+90
+90
 ENDCHAR
-STARTCHAR C035
+STARTCHAR uni0023
 ENCODING 35
 SWIDTH 720 0
 DWIDTH 12 0
@@ -112,7 +112,7 @@
 4800
 4800
 ENDCHAR
-STARTCHAR C036
+STARTCHAR uni0024
 ENCODING 36
 SWIDTH 480 0
 DWIDTH 8 0
@@ -133,7 +133,7 @@
 70
 20
 ENDCHAR
-STARTCHAR C037
+STARTCHAR uni0025
 ENCODING 37
 SWIDTH 840 0
 DWIDTH 14 0
@@ -153,7 +153,7 @@
 2120
 40C0
 ENDCHAR
-STARTCHAR C038
+STARTCHAR uni0026
 ENCODING 38
 SWIDTH 780 0
 DWIDTH 13 0
@@ -172,19 +172,19 @@
 C440
 7B80
 ENDCHAR
-STARTCHAR C039
+STARTCHAR uni0027
 ENCODING 39
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 2 5 1 7
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 1 5 2 7
 BITMAP
-C0
-C0
-40
-40
 80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uni0028
 ENCODING 40
 SWIDTH 360 0
 DWIDTH 6 0
@@ -206,7 +206,7 @@
 20
 10
 ENDCHAR
-STARTCHAR C041
+STARTCHAR uni0029
 ENCODING 41
 SWIDTH 360 0
 DWIDTH 6 0
@@ -228,7 +228,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C042
+STARTCHAR uni002A
 ENCODING 42
 SWIDTH 420 0
 DWIDTH 7 0
@@ -242,25 +242,23 @@
 92
 10
 ENDCHAR
-STARTCHAR C043
+STARTCHAR uni002B
 ENCODING 43
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 2 -1
+BBX 9 9 2 -1
 BITMAP
 0800
 0800
 0800
 0800
-0800
 FF80
 0800
 0800
 0800
 0800
-0800
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni002C
 ENCODING 44
 SWIDTH 300 0
 DWIDTH 5 0
@@ -272,7 +270,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C045
+STARTCHAR uni002D
 ENCODING 45
 SWIDTH 420 0
 DWIDTH 7 0
@@ -280,7 +278,7 @@
 BITMAP
 F0
 ENDCHAR
-STARTCHAR C046
+STARTCHAR uni002E
 ENCODING 46
 SWIDTH 300 0
 DWIDTH 5 0
@@ -289,7 +287,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C047
+STARTCHAR uni002F
 ENCODING 47
 SWIDTH 480 0
 DWIDTH 8 0
@@ -312,7 +310,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C048
+STARTCHAR uni0030
 ENCODING 48
 SWIDTH 420 0
 DWIDTH 7 0
@@ -330,7 +328,7 @@
 50
 70
 ENDCHAR
-STARTCHAR C049
+STARTCHAR uni0031
 ENCODING 49
 SWIDTH 420 0
 DWIDTH 7 0
@@ -348,7 +346,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C050
+STARTCHAR uni0032
 ENCODING 50
 SWIDTH 420 0
 DWIDTH 7 0
@@ -366,7 +364,7 @@
 48
 F8
 ENDCHAR
-STARTCHAR C051
+STARTCHAR uni0033
 ENCODING 51
 SWIDTH 420 0
 DWIDTH 7 0
@@ -384,7 +382,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C052
+STARTCHAR uni0034
 ENCODING 52
 SWIDTH 540 0
 DWIDTH 9 0
@@ -402,7 +400,7 @@
 08
 3E
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni0035
 ENCODING 53
 SWIDTH 420 0
 DWIDTH 7 0
@@ -420,7 +418,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C054
+STARTCHAR uni0036
 ENCODING 54
 SWIDTH 420 0
 DWIDTH 7 0
@@ -438,7 +436,7 @@
 50
 70
 ENDCHAR
-STARTCHAR C055
+STARTCHAR uni0037
 ENCODING 55
 SWIDTH 480 0
 DWIDTH 8 0
@@ -457,7 +455,7 @@
 20
 20
 ENDCHAR
-STARTCHAR C056
+STARTCHAR uni0038
 ENCODING 56
 SWIDTH 420 0
 DWIDTH 7 0
@@ -475,7 +473,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C057
+STARTCHAR uni0039
 ENCODING 57
 SWIDTH 420 0
 DWIDTH 7 0
@@ -493,7 +491,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C058
+STARTCHAR uni003A
 ENCODING 58
 SWIDTH 420 0
 DWIDTH 7 0
@@ -507,7 +505,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C059
+STARTCHAR uni003B
 ENCODING 59
 SWIDTH 300 0
 DWIDTH 5 0
@@ -524,7 +522,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char60
+STARTCHAR uni003C
 ENCODING 60
 SWIDTH 360 0
 DWIDTH 6 0
@@ -540,7 +538,7 @@
 10
 08
 ENDCHAR
-STARTCHAR C061
+STARTCHAR uni003D
 ENCODING 61
 SWIDTH 780 0
 DWIDTH 13 0
@@ -552,7 +550,7 @@
 0000
 FFC0
 ENDCHAR
-STARTCHAR char60
+STARTCHAR uni003E
 ENCODING 62
 SWIDTH 360 0
 DWIDTH 6 0
@@ -568,7 +566,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C063
+STARTCHAR uni003F
 ENCODING 63
 SWIDTH 480 0
 DWIDTH 8 0
@@ -587,7 +585,7 @@
 60
 60
 ENDCHAR
-STARTCHAR C064
+STARTCHAR uni0040
 ENCODING 64
 SWIDTH 720 0
 DWIDTH 12 0
@@ -606,7 +604,7 @@
 20C0
 1F00
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0041
 ENCODING 65
 SWIDTH 660 0
 DWIDTH 11 0
@@ -624,7 +622,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C066
+STARTCHAR uni0042
 ENCODING 66
 SWIDTH 600 0
 DWIDTH 10 0
@@ -642,7 +640,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni0043
 ENCODING 67
 SWIDTH 600 0
 DWIDTH 10 0
@@ -660,7 +658,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni0044
 ENCODING 68
 SWIDTH 600 0
 DWIDTH 10 0
@@ -678,7 +676,7 @@
 2180
 FE00
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0045
 ENCODING 69
 SWIDTH 600 0
 DWIDTH 10 0
@@ -696,7 +694,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C070
+STARTCHAR uni0046
 ENCODING 70
 SWIDTH 540 0
 DWIDTH 9 0
@@ -714,7 +712,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni0047
 ENCODING 71
 SWIDTH 600 0
 DWIDTH 10 0
@@ -732,7 +730,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni0048
 ENCODING 72
 SWIDTH 660 0
 DWIDTH 11 0
@@ -750,7 +748,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0049
 ENCODING 73
 SWIDTH 300 0
 DWIDTH 5 0
@@ -768,7 +766,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C074
+STARTCHAR uni004A
 ENCODING 74
 SWIDTH 360 0
 DWIDTH 6 0
@@ -786,7 +784,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni004B
 ENCODING 75
 SWIDTH 660 0
 DWIDTH 11 0
@@ -804,7 +802,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni004C
 ENCODING 76
 SWIDTH 480 0
 DWIDTH 8 0
@@ -822,7 +820,7 @@
 23
 FF
 ENDCHAR
-STARTCHAR C077
+STARTCHAR uni004D
 ENCODING 77
 SWIDTH 840 0
 DWIDTH 14 0
@@ -840,7 +838,7 @@
 2310
 FB7C
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni004E
 ENCODING 78
 SWIDTH 660 0
 DWIDTH 11 0
@@ -858,7 +856,7 @@
 2180
 F880
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni004F
 ENCODING 79
 SWIDTH 600 0
 DWIDTH 10 0
@@ -876,7 +874,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C080
+STARTCHAR uni0050
 ENCODING 80
 SWIDTH 540 0
 DWIDTH 9 0
@@ -894,7 +892,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C081
+STARTCHAR uni0051
 ENCODING 81
 SWIDTH 600 0
 DWIDTH 10 0
@@ -915,7 +913,7 @@
 0240
 0180
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0052
 ENCODING 82
 SWIDTH 660 0
 DWIDTH 11 0
@@ -933,7 +931,7 @@
 2100
 F8E0
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni0053
 ENCODING 83
 SWIDTH 420 0
 DWIDTH 7 0
@@ -951,7 +949,7 @@
 84
 F8
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni0054
 ENCODING 84
 SWIDTH 540 0
 DWIDTH 9 0
@@ -969,7 +967,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0055
 ENCODING 85
 SWIDTH 660 0
 DWIDTH 11 0
@@ -987,7 +985,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C086
+STARTCHAR uni0056
 ENCODING 86
 SWIDTH 660 0
 DWIDTH 11 0
@@ -1005,7 +1003,7 @@
 0400
 0400
 ENDCHAR
-STARTCHAR C087
+STARTCHAR uni0057
 ENCODING 87
 SWIDTH 960 0
 DWIDTH 16 0
@@ -1023,7 +1021,7 @@
 0C30
 0810
 ENDCHAR
-STARTCHAR C088
+STARTCHAR uni0058
 ENCODING 88
 SWIDTH 660 0
 DWIDTH 11 0
@@ -1041,7 +1039,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni0059
 ENCODING 89
 SWIDTH 660 0
 DWIDTH 11 0
@@ -1059,7 +1057,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni005A
 ENCODING 90
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1077,7 +1075,7 @@
 46
 FE
 ENDCHAR
-STARTCHAR C091
+STARTCHAR uni005B
 ENCODING 91
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1100,7 +1098,7 @@
 80
 E0
 ENDCHAR
-STARTCHAR C047
+STARTCHAR uni005C
 ENCODING 92
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1123,7 +1121,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C093
+STARTCHAR uni005D
 ENCODING 93
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1146,7 +1144,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR C094
+STARTCHAR uni005E
 ENCODING 94
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1156,7 +1154,7 @@
 70
 88
 ENDCHAR
-STARTCHAR char95
+STARTCHAR uni005F
 ENCODING 95
 SWIDTH 720 0
 DWIDTH 12 0
@@ -1164,19 +1162,18 @@
 BITMAP
 FFE0
 ENDCHAR
-STARTCHAR C096
+STARTCHAR uni0060
 ENCODING 96
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 2 5 1 7
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 3 4 3 8
 BITMAP
-40
 80
-80
-C0
 C0
+40
+20
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0061
 ENCODING 97
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1190,7 +1187,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0062
 ENCODING 98
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1209,7 +1206,7 @@
 44
 78
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0063
 ENCODING 99
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1223,7 +1220,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni0064
 ENCODING 100
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1242,7 +1239,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0065
 ENCODING 101
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1256,7 +1253,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni0066
 ENCODING 102
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1275,7 +1272,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni0067
 ENCODING 103
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1293,7 +1290,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0068
 ENCODING 104
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1312,7 +1309,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR 0x0069
+STARTCHAR uni0069
 ENCODING 105
 SWIDTH 240 0
 DWIDTH 4 0
@@ -1330,7 +1327,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR 0x006A
+STARTCHAR uni006A
 ENCODING 106
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1351,7 +1348,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni006B
 ENCODING 107
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1370,7 +1367,7 @@
 48
 EE
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni006C
 ENCODING 108
 SWIDTH 240 0
 DWIDTH 4 0
@@ -1389,7 +1386,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C109
+STARTCHAR uni006D
 ENCODING 109
 SWIDTH 720 0
 DWIDTH 12 0
@@ -1403,7 +1400,7 @@
 4440
 EEE0
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni006E
 ENCODING 110
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1417,7 +1414,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni006F
 ENCODING 111
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1431,7 +1428,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C112
+STARTCHAR uni0070
 ENCODING 112
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1448,7 +1445,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C113
+STARTCHAR uni0071
 ENCODING 113
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1465,7 +1462,7 @@
 08
 1C
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0072
 ENCODING 114
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1479,7 +1476,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni0073
 ENCODING 115
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1493,7 +1490,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0074
 ENCODING 116
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1510,7 +1507,7 @@
 24
 18
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0075
 ENCODING 117
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1524,7 +1521,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C118
+STARTCHAR uni0076
 ENCODING 118
 SWIDTH 540 0
 DWIDTH 9 0
@@ -1538,7 +1535,7 @@
 18
 18
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni0077
 ENCODING 119
 SWIDTH 660 0
 DWIDTH 11 0
@@ -1552,7 +1549,7 @@
 1B00
 1100
 ENDCHAR
-STARTCHAR C120
+STARTCHAR uni0078
 ENCODING 120
 SWIDTH 540 0
 DWIDTH 9 0
@@ -1566,7 +1563,7 @@
 24
 E7
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni0079
 ENCODING 121
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1583,7 +1580,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni007A
 ENCODING 122
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1597,7 +1594,7 @@
 48
 F8
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uni007B
 ENCODING 123
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1620,7 +1617,7 @@
 20
 18
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uni007C
 ENCODING 124
 SWIDTH 180 0
 DWIDTH 3 0
@@ -1643,7 +1640,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char124
+STARTCHAR uni007D
 ENCODING 125
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1666,7 +1663,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR C126
+STARTCHAR uni007E
 ENCODING 126
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1676,14 +1673,14 @@
 A8
 90
 ENDCHAR
-STARTCHAR space
+STARTCHAR uni00A0
 ENCODING 160
 SWIDTH 300 0
 DWIDTH 5 0
 BBX 0 0 0 0
 BITMAP
 ENDCHAR
-STARTCHAR C060
+STARTCHAR uni00A1
 ENCODING 161
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1702,7 +1699,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni00A2
 ENCODING 162
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1720,7 +1717,7 @@
 40
 40
 ENDCHAR
-STARTCHAR C036
+STARTCHAR uni00A3
 ENCODING 163
 SWIDTH 540 0
 DWIDTH 9 0
@@ -1739,7 +1736,7 @@
 B2
 CC
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni00A4
 ENCODING 164
 SWIDTH 540 0
 DWIDTH 9 0
@@ -1753,7 +1750,7 @@
 7C
 82
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni00A5
 ENCODING 165
 SWIDTH 720 0
 DWIDTH 12 0
@@ -1771,7 +1768,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uni00A6
 ENCODING 166
 SWIDTH 180 0
 DWIDTH 3 0
@@ -1794,7 +1791,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char167
+STARTCHAR uni00A7
 ENCODING 167
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1814,7 +1811,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C127
+STARTCHAR uni00A8
 ENCODING 168
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1823,7 +1820,7 @@
 D8
 D8
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni00A9
 ENCODING 169
 SWIDTH 600 0
 DWIDTH 10 0
@@ -1840,7 +1837,7 @@
 4100
 3E00
 ENDCHAR
-STARTCHAR char170
+STARTCHAR uni00AA
 ENCODING 170
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1853,7 +1850,7 @@
 70
 F0
 ENDCHAR
-STARTCHAR char171
+STARTCHAR uni00AB
 ENCODING 171
 SWIDTH 540 0
 DWIDTH 9 0
@@ -1867,7 +1864,7 @@
 24
 12
 ENDCHAR
-STARTCHAR char172
+STARTCHAR uni00AC
 ENCODING 172
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1878,7 +1875,7 @@
 04
 04
 ENDCHAR
-STARTCHAR C045
+STARTCHAR uni00AD
 ENCODING 173
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1886,7 +1883,7 @@
 BITMAP
 E0
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni00AE
 ENCODING 174
 SWIDTH 600 0
 DWIDTH 10 0
@@ -1903,7 +1900,7 @@
 4100
 3E00
 ENDCHAR
-STARTCHAR C022
+STARTCHAR uni00AF
 ENCODING 175
 SWIDTH 420 0
 DWIDTH 7 0
@@ -1911,7 +1908,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C023
+STARTCHAR uni00B0
 ENCODING 176
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1922,7 +1919,7 @@
 90
 60
 ENDCHAR
-STARTCHAR char177
+STARTCHAR uni00B1
 ENCODING 177
 SWIDTH 540 0
 DWIDTH 9 0
@@ -1938,7 +1935,7 @@
 00
 FE
 ENDCHAR
-STARTCHAR char178
+STARTCHAR uni00B2
 ENCODING 178
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1952,7 +1949,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR char179
+STARTCHAR uni00B3
 ENCODING 179
 SWIDTH 300 0
 DWIDTH 5 0
@@ -1966,7 +1963,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni00B4
 ENCODING 180
 SWIDTH 360 0
 DWIDTH 6 0
@@ -1977,7 +1974,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni00B5
 ENCODING 181
 SWIDTH 480 0
 DWIDTH 8 0
@@ -1994,7 +1991,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char182
+STARTCHAR uni00B6
 ENCODING 182
 SWIDTH 480 0
 DWIDTH 8 0
@@ -2016,7 +2013,7 @@
 14
 14
 ENDCHAR
-STARTCHAR char183
+STARTCHAR uni00B7
 ENCODING 183
 SWIDTH 240 0
 DWIDTH 4 0
@@ -2025,7 +2022,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C024
+STARTCHAR uni00B8
 ENCODING 184
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2035,7 +2032,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR char185
+STARTCHAR uni00B9
 ENCODING 185
 SWIDTH 240 0
 DWIDTH 4 0
@@ -2049,7 +2046,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR char171
+STARTCHAR uni00BA
 ENCODING 186
 SWIDTH 300 0
 DWIDTH 5 0
@@ -2062,7 +2059,7 @@
 60
 F0
 ENDCHAR
-STARTCHAR char171
+STARTCHAR uni00BB
 ENCODING 187
 SWIDTH 480 0
 DWIDTH 8 0
@@ -2076,7 +2073,7 @@
 48
 90
 ENDCHAR
-STARTCHAR char185
+STARTCHAR uni00BC
 ENCODING 188
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2094,7 +2091,7 @@
 1040
 10E0
 ENDCHAR
-STARTCHAR char185
+STARTCHAR uni00BD
 ENCODING 189
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2112,7 +2109,7 @@
 1080
 11E0
 ENDCHAR
-STARTCHAR char185
+STARTCHAR uni00BE
 ENCODING 190
 SWIDTH 780 0
 DWIDTH 13 0
@@ -2130,7 +2127,7 @@
 0820
 0870
 ENDCHAR
-STARTCHAR C062
+STARTCHAR uni00BF
 ENCODING 191
 SWIDTH 480 0
 DWIDTH 8 0
@@ -2149,7 +2146,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni00C0
 ENCODING 192
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2172,7 +2169,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni00C1
 ENCODING 193
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2195,7 +2192,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni00C2
 ENCODING 194
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2217,7 +2214,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni00C3
 ENCODING 195
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2239,7 +2236,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni00C4
 ENCODING 196
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2260,7 +2257,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni00C5
 ENCODING 197
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2282,7 +2279,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C029
+STARTCHAR uni00C6
 ENCODING 198
 SWIDTH 900 0
 DWIDTH 15 0
@@ -2300,7 +2297,7 @@
 2208
 F7F8
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni00C7
 ENCODING 199
 SWIDTH 600 0
 DWIDTH 10 0
@@ -2321,7 +2318,7 @@
 0400
 1C00
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni00C8
 ENCODING 200
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2344,7 +2341,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni00C9
 ENCODING 201
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2367,7 +2364,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni00CA
 ENCODING 202
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2389,7 +2386,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni00CB
 ENCODING 203
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2410,7 +2407,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni00CC
 ENCODING 204
 SWIDTH 360 0
 DWIDTH 6 0
@@ -2433,7 +2430,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni00CD
 ENCODING 205
 SWIDTH 360 0
 DWIDTH 6 0
@@ -2456,7 +2453,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni00CE
 ENCODING 206
 SWIDTH 360 0
 DWIDTH 6 0
@@ -2478,7 +2475,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni00CF
 ENCODING 207
 SWIDTH 360 0
 DWIDTH 6 0
@@ -2499,7 +2496,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C032
+STARTCHAR uni00D0
 ENCODING 208
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2517,7 +2514,7 @@
 2180
 FE00
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni00D1
 ENCODING 209
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2539,7 +2536,7 @@
 2180
 F880
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni00D2
 ENCODING 210
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2562,7 +2559,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni00D3
 ENCODING 211
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2585,7 +2582,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni00D4
 ENCODING 212
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2607,7 +2604,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni00D5
 ENCODING 213
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2629,7 +2626,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni00D6
 ENCODING 214
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2650,11 +2647,11 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR char215
+STARTCHAR uni00D7
 ENCODING 215
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 7 1 2
+BBX 7 7 1 0
 BITMAP
 82
 44
@@ -2664,7 +2661,7 @@
 44
 82
 ENDCHAR
-STARTCHAR C031
+STARTCHAR uni00D8
 ENCODING 216
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2684,7 +2681,7 @@
 3E00
 4000
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni00D9
 ENCODING 217
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2707,7 +2704,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni00DA
 ENCODING 218
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2730,7 +2727,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni00DB
 ENCODING 219
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2752,7 +2749,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni00DC
 ENCODING 220
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2773,7 +2770,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni00DD
 ENCODING 221
 SWIDTH 720 0
 DWIDTH 12 0
@@ -2796,7 +2793,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C030
+STARTCHAR uni00DE
 ENCODING 222
 SWIDTH 600 0
 DWIDTH 10 0
@@ -2814,7 +2811,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C025
+STARTCHAR uni00DF
 ENCODING 223
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2833,7 +2830,7 @@
 44
 D8
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni00E0
 ENCODING 224
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2852,7 +2849,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni00E1
 ENCODING 225
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2871,7 +2868,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni00E2
 ENCODING 226
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2889,7 +2886,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni00E3
 ENCODING 227
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2907,7 +2904,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni00E4
 ENCODING 228
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2924,7 +2921,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni00E5
 ENCODING 229
 SWIDTH 420 0
 DWIDTH 7 0
@@ -2942,7 +2939,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C026
+STARTCHAR uni00E6
 ENCODING 230
 SWIDTH 660 0
 DWIDTH 11 0
@@ -2956,7 +2953,7 @@
 8C40
 7380
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni00E7
 ENCODING 231
 SWIDTH 360 0
 DWIDTH 6 0
@@ -2973,7 +2970,7 @@
 10
 70
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni00E8
 ENCODING 232
 SWIDTH 360 0
 DWIDTH 6 0
@@ -2992,7 +2989,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni00E9
 ENCODING 233
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3011,7 +3008,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni00EA
 ENCODING 234
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3029,7 +3026,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni00EB
 ENCODING 235
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3046,7 +3043,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni00EC
 ENCODING 236
 SWIDTH 240 0
 DWIDTH 4 0
@@ -3065,7 +3062,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni00ED
 ENCODING 237
 SWIDTH 240 0
 DWIDTH 4 0
@@ -3084,7 +3081,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni00EE
 ENCODING 238
 SWIDTH 300 0
 DWIDTH 5 0
@@ -3102,7 +3099,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni00EF
 ENCODING 239
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3119,7 +3116,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C031
+STARTCHAR uni00F0
 ENCODING 240
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3138,7 +3135,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni00F1
 ENCODING 241
 SWIDTH 480 0
 DWIDTH 8 0
@@ -3156,7 +3153,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni00F2
 ENCODING 242
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3175,7 +3172,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni00F3
 ENCODING 243
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3194,7 +3191,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni00F4
 ENCODING 244
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3212,7 +3209,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni00F5
 ENCODING 245
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3230,7 +3227,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni00F6
 ENCODING 246
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3247,11 +3244,11 @@
 88
 70
 ENDCHAR
-STARTCHAR char247
+STARTCHAR uni00F7
 ENCODING 247
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 7 1 2
+BBX 9 7 1 0
 BITMAP
 0800
 0800
@@ -3261,7 +3258,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR C028
+STARTCHAR uni00F8
 ENCODING 248
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3279,7 +3276,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni00F9
 ENCODING 249
 SWIDTH 480 0
 DWIDTH 8 0
@@ -3298,7 +3295,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni00FA
 ENCODING 250
 SWIDTH 480 0
 DWIDTH 8 0
@@ -3317,7 +3314,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni00FB
 ENCODING 251
 SWIDTH 480 0
 DWIDTH 8 0
@@ -3335,7 +3332,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni00FC
 ENCODING 252
 SWIDTH 480 0
 DWIDTH 8 0
@@ -3352,7 +3349,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni00FD
 ENCODING 253
 SWIDTH 480 0
 DWIDTH 8 0
@@ -3374,7 +3371,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C028
+STARTCHAR uni00FE
 ENCODING 254
 SWIDTH 420 0
 DWIDTH 7 0
@@ -3396,7 +3393,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni00FF
 ENCODING 255
 SWIDTH 480 0
 DWIDTH 8 0
@@ -3416,7 +3413,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0100
 ENCODING 256
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3436,7 +3433,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0101
 ENCODING 257
 SWIDTH 420 0
 DWIDTH 7 0
@@ -3452,7 +3449,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0102
 ENCODING 258
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3473,7 +3470,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0103
 ENCODING 259
 SWIDTH 420 0
 DWIDTH 7 0
@@ -3490,7 +3487,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0104
 ENCODING 260
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3511,7 +3508,7 @@
 0120
 00C0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0105
 ENCODING 261
 SWIDTH 420 0
 DWIDTH 7 0
@@ -3528,7 +3525,7 @@
 12
 0C
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni0106
 ENCODING 262
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3551,7 +3548,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0107
 ENCODING 263
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3570,7 +3567,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni0108
 ENCODING 264
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3592,7 +3589,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0109
 ENCODING 265
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3610,7 +3607,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni010A
 ENCODING 266
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3631,7 +3628,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni010B
 ENCODING 267
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3648,7 +3645,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni010C
 ENCODING 268
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3670,7 +3667,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni010D
 ENCODING 269
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3688,7 +3685,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C032
+STARTCHAR uni010E
 ENCODING 270
 SWIDTH 720 0
 DWIDTH 12 0
@@ -3710,7 +3707,7 @@
 2180
 FF00
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni010F
 ENCODING 271
 SWIDTH 420 0
 DWIDTH 7 0
@@ -3729,7 +3726,7 @@
 48
 7C
 ENDCHAR
-STARTCHAR C032
+STARTCHAR uni0110
 ENCODING 272
 SWIDTH 720 0
 DWIDTH 12 0
@@ -3747,7 +3744,7 @@
 2180
 FF00
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni0111
 ENCODING 273
 SWIDTH 420 0
 DWIDTH 7 0
@@ -3766,7 +3763,7 @@
 48
 7C
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0112
 ENCODING 274
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3786,7 +3783,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0113
 ENCODING 275
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3802,7 +3799,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0114
 ENCODING 276
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3823,7 +3820,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0115
 ENCODING 277
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3840,7 +3837,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0116
 ENCODING 278
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3861,7 +3858,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0117
 ENCODING 279
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3878,7 +3875,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0118
 ENCODING 280
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3899,7 +3896,7 @@
 1200
 0C00
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0119
 ENCODING 281
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3916,7 +3913,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni011A
 ENCODING 282
 SWIDTH 660 0
 DWIDTH 11 0
@@ -3938,7 +3935,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni011B
 ENCODING 283
 SWIDTH 360 0
 DWIDTH 6 0
@@ -3956,7 +3953,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni011C
 ENCODING 284
 SWIDTH 780 0
 DWIDTH 13 0
@@ -3978,7 +3975,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni011D
 ENCODING 285
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4000,7 +3997,7 @@
 C6
 38
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni011E
 ENCODING 286
 SWIDTH 780 0
 DWIDTH 13 0
@@ -4021,7 +4018,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni011F
 ENCODING 287
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4042,7 +4039,7 @@
 C6
 38
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni0120
 ENCODING 288
 SWIDTH 780 0
 DWIDTH 13 0
@@ -4063,7 +4060,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni0121
 ENCODING 289
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4084,7 +4081,7 @@
 C6
 38
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni0122
 ENCODING 290
 SWIDTH 780 0
 DWIDTH 13 0
@@ -4105,7 +4102,7 @@
 0400
 1C00
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni0123
 ENCODING 291
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4130,7 +4127,7 @@
 C6
 38
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni0124
 ENCODING 292
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4152,7 +4149,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0125
 ENCODING 293
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4175,7 +4172,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni0126
 ENCODING 294
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4193,7 +4190,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0127
 ENCODING 295
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4212,7 +4209,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0128
 ENCODING 296
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4234,7 +4231,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni0129
 ENCODING 297
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4252,7 +4249,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni012A
 ENCODING 298
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4272,7 +4269,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni012B
 ENCODING 299
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4288,7 +4285,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni012C
 ENCODING 300
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4309,7 +4306,7 @@
 10
 7C
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni012D
 ENCODING 301
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4327,7 +4324,7 @@
 10
 38
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni012E
 ENCODING 302
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4348,7 +4345,7 @@
 48
 30
 ENDCHAR
-STARTCHAR 0x012F
+STARTCHAR uni012F
 ENCODING 303
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4369,7 +4366,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0130
 ENCODING 304
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4390,7 +4387,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C016
+STARTCHAR uni0131
 ENCODING 305
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4404,7 +4401,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0132
 ENCODING 306
 SWIDTH 780 0
 DWIDTH 13 0
@@ -4422,7 +4419,7 @@
 2240
 FB80
 ENDCHAR
-STARTCHAR 0x0133
+STARTCHAR uni0133
 ENCODING 307
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4443,7 +4440,7 @@
 12
 1C
 ENDCHAR
-STARTCHAR C074
+STARTCHAR uni0134
 ENCODING 308
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4465,7 +4462,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni0135
 ENCODING 309
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4486,7 +4483,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni0136
 ENCODING 310
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4507,7 +4504,7 @@
 0800
 3800
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni0137
 ENCODING 311
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4529,7 +4526,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni0138
 ENCODING 312
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4543,7 +4540,7 @@
 48
 E6
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni0139
 ENCODING 313
 SWIDTH 600 0
 DWIDTH 10 0
@@ -4566,7 +4563,7 @@
 23
 FF
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni013A
 ENCODING 314
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4590,7 +4587,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni013B
 ENCODING 315
 SWIDTH 600 0
 DWIDTH 10 0
@@ -4611,7 +4608,7 @@
 04
 1C
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni013C
 ENCODING 316
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4633,7 +4630,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni013D
 ENCODING 317
 SWIDTH 600 0
 DWIDTH 10 0
@@ -4651,7 +4648,7 @@
 23
 FF
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni013E
 ENCODING 318
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4670,7 +4667,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni013F
 ENCODING 319
 SWIDTH 600 0
 DWIDTH 10 0
@@ -4688,7 +4685,7 @@
 23
 FF
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni0140
 ENCODING 320
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4707,7 +4704,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni0141
 ENCODING 321
 SWIDTH 600 0
 DWIDTH 10 0
@@ -4725,7 +4722,7 @@
 23
 FF
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni0142
 ENCODING 322
 SWIDTH 240 0
 DWIDTH 4 0
@@ -4744,7 +4741,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni0143
 ENCODING 323
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4767,7 +4764,7 @@
 2180
 F880
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0144
 ENCODING 324
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4786,7 +4783,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni0145
 ENCODING 325
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4807,7 +4804,7 @@
 0800
 3800
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0146
 ENCODING 326
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4824,7 +4821,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni0147
 ENCODING 327
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4846,7 +4843,7 @@
 2180
 F880
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0148
 ENCODING 328
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4864,7 +4861,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0149
 ENCODING 329
 SWIDTH 480 0
 DWIDTH 8 0
@@ -4884,7 +4881,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni014A
 ENCODING 330
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4905,7 +4902,7 @@
 0480
 0700
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni014B
 ENCODING 331
 SWIDTH 420 0
 DWIDTH 7 0
@@ -4922,7 +4919,7 @@
 14
 18
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni014C
 ENCODING 332
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4942,7 +4939,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni014D
 ENCODING 333
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4958,7 +4955,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni014E
 ENCODING 334
 SWIDTH 720 0
 DWIDTH 12 0
@@ -4979,7 +4976,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni014F
 ENCODING 335
 SWIDTH 360 0
 DWIDTH 6 0
@@ -4996,7 +4993,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0150
 ENCODING 336
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5019,7 +5016,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni0151
 ENCODING 337
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5038,7 +5035,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C030
+STARTCHAR uni0152
 ENCODING 338
 SWIDTH 900 0
 DWIDTH 15 0
@@ -5056,7 +5053,7 @@
 6308
 1FF8
 ENDCHAR
-STARTCHAR C027
+STARTCHAR uni0153
 ENCODING 339
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5070,7 +5067,7 @@
 4A20
 31C0
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0154
 ENCODING 340
 SWIDTH 660 0
 DWIDTH 11 0
@@ -5093,7 +5090,7 @@
 2100
 F8E0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0155
 ENCODING 341
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5112,7 +5109,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0156
 ENCODING 342
 SWIDTH 660 0
 DWIDTH 11 0
@@ -5133,7 +5130,7 @@
 0800
 3800
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0157
 ENCODING 343
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5150,7 +5147,7 @@
 10
 70
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0158
 ENCODING 344
 SWIDTH 660 0
 DWIDTH 11 0
@@ -5172,7 +5169,7 @@
 2100
 F8E0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0159
 ENCODING 345
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5190,7 +5187,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni015A
 ENCODING 346
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5213,7 +5210,7 @@
 84
 F8
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni015B
 ENCODING 347
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5232,7 +5229,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni015C
 ENCODING 348
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5254,7 +5251,7 @@
 84
 F8
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni015D
 ENCODING 349
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5272,7 +5269,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni015E
 ENCODING 350
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5293,7 +5290,7 @@
 10
 70
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni015F
 ENCODING 351
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5310,7 +5307,7 @@
 10
 70
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni0160
 ENCODING 352
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5332,7 +5329,7 @@
 84
 F8
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni0161
 ENCODING 353
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5350,7 +5347,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni0162
 ENCODING 354
 SWIDTH 660 0
 DWIDTH 11 0
@@ -5371,7 +5368,7 @@
 0400
 1C00
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0163
 ENCODING 355
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5391,7 +5388,7 @@
 04
 1C
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni0164
 ENCODING 356
 SWIDTH 660 0
 DWIDTH 11 0
@@ -5413,7 +5410,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0165
 ENCODING 357
 SWIDTH 420 0
 DWIDTH 7 0
@@ -5432,7 +5429,7 @@
 24
 18
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni0166
 ENCODING 358
 SWIDTH 660 0
 DWIDTH 11 0
@@ -5450,7 +5447,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0167
 ENCODING 359
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5467,7 +5464,7 @@
 24
 18
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0168
 ENCODING 360
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5489,7 +5486,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0169
 ENCODING 361
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5507,7 +5504,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni016A
 ENCODING 362
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5527,7 +5524,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni016B
 ENCODING 363
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5543,7 +5540,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni016C
 ENCODING 364
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5564,7 +5561,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni016D
 ENCODING 365
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5581,7 +5578,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni016E
 ENCODING 366
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5604,7 +5601,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni016F
 ENCODING 367
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5623,7 +5620,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0170
 ENCODING 368
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5646,7 +5643,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0171
 ENCODING 369
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5665,7 +5662,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0172
 ENCODING 370
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5686,7 +5683,7 @@
 0900
 0600
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0173
 ENCODING 371
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5703,7 +5700,7 @@
 09
 06
 ENDCHAR
-STARTCHAR C087
+STARTCHAR uni0174
 ENCODING 372
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -5725,7 +5722,7 @@
 0C30
 0810
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni0175
 ENCODING 373
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5743,7 +5740,7 @@
 1B00
 1100
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni0176
 ENCODING 374
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5765,7 +5762,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni0177
 ENCODING 375
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5786,7 +5783,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni0178
 ENCODING 376
 SWIDTH 720 0
 DWIDTH 12 0
@@ -5807,7 +5804,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni0179
 ENCODING 377
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5830,7 +5827,7 @@
 46
 FE
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni017A
 ENCODING 378
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5849,7 +5846,7 @@
 48
 F8
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni017B
 ENCODING 379
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5870,7 +5867,7 @@
 46
 FE
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni017C
 ENCODING 380
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5887,7 +5884,7 @@
 48
 F8
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni017D
 ENCODING 381
 SWIDTH 480 0
 DWIDTH 8 0
@@ -5909,7 +5906,7 @@
 46
 FE
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni017E
 ENCODING 382
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5927,7 +5924,7 @@
 48
 F8
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni017F
 ENCODING 383
 SWIDTH 360 0
 DWIDTH 6 0
@@ -5946,7 +5943,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0180
 ENCODING 384
 SWIDTH 420 0
 DWIDTH 7 0
@@ -5965,7 +5962,7 @@
 44
 78
 ENDCHAR
-STARTCHAR C066
+STARTCHAR uni0181
 ENCODING 385
 SWIDTH 660 0
 DWIDTH 11 0
@@ -5983,7 +5980,7 @@
 1040
 7F80
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0182
 ENCODING 386
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6001,7 +5998,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0183
 ENCODING 387
 SWIDTH 420 0
 DWIDTH 7 0
@@ -6020,7 +6017,7 @@
 44
 78
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0184
 ENCODING 388
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6038,7 +6035,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0185
 ENCODING 389
 SWIDTH 480 0
 DWIDTH 8 0
@@ -6057,7 +6054,7 @@
 22
 3C
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni0186
 ENCODING 390
 SWIDTH 660 0
 DWIDTH 11 0
@@ -6075,7 +6072,7 @@
 C200
 BC00
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni0187
 ENCODING 391
 SWIDTH 660 0
 DWIDTH 11 0
@@ -6095,7 +6092,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0188
 ENCODING 392
 SWIDTH 420 0
 DWIDTH 7 0
@@ -6111,7 +6108,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C032
+STARTCHAR uni0189
 ENCODING 393
 SWIDTH 660 0
 DWIDTH 11 0
@@ -6129,7 +6126,7 @@
 2180
 FE00
 ENDCHAR
-STARTCHAR C032
+STARTCHAR uni018A
 ENCODING 394
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6147,7 +6144,7 @@
 10C0
 7F00
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni018B
 ENCODING 395
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6165,7 +6162,7 @@
 8200
 7F80
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni018C
 ENCODING 396
 SWIDTH 420 0
 DWIDTH 7 0
@@ -6184,7 +6181,7 @@
 88
 78
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni018D
 ENCODING 397
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6202,7 +6199,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni018E
 ENCODING 398
 SWIDTH 660 0
 DWIDTH 11 0
@@ -6220,7 +6217,7 @@
 4100
 7FC0
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni018F
 ENCODING 399
 SWIDTH 660 0
 DWIDTH 11 0
@@ -6238,7 +6235,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C051
+STARTCHAR uni0190
 ENCODING 400
 SWIDTH 480 0
 DWIDTH 8 0
@@ -6256,7 +6253,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C070
+STARTCHAR uni0191
 ENCODING 401
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6277,7 +6274,7 @@
 9000
 E000
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni0192
 ENCODING 402
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6299,7 +6296,7 @@
 A0
 C0
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni0193
 ENCODING 403
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6319,7 +6316,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni0194
 ENCODING 404
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6337,7 +6334,7 @@
 0A00
 0400
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0195
 ENCODING 405
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6355,7 +6352,7 @@
 4880
 E700
 ENDCHAR
-STARTCHAR char405
+STARTCHAR uni0196
 ENCODING 406
 SWIDTH 300 0
 DWIDTH 5 0
@@ -6375,7 +6372,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0197
 ENCODING 407
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6393,7 +6390,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni0198
 ENCODING 408
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6411,7 +6408,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni0199
 ENCODING 409
 SWIDTH 480 0
 DWIDTH 8 0
@@ -6431,7 +6428,7 @@
 48
 EE
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni019A
 ENCODING 410
 SWIDTH 240 0
 DWIDTH 4 0
@@ -6450,7 +6447,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni019B
 ENCODING 411
 SWIDTH 540 0
 DWIDTH 9 0
@@ -6467,7 +6464,7 @@
 42
 E7
 ENDCHAR
-STARTCHAR C087
+STARTCHAR uni019C
 ENCODING 412
 SWIDTH 960 0
 DWIDTH 16 0
@@ -6485,7 +6482,7 @@
 2298
 1C6E
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni019D
 ENCODING 413
 SWIDTH 780 0
 DWIDTH 13 0
@@ -6506,7 +6503,7 @@
 9000
 E000
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni019E
 ENCODING 414
 SWIDTH 420 0
 DWIDTH 7 0
@@ -6523,7 +6520,7 @@
 04
 06
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni019F
 ENCODING 415
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6541,7 +6538,7 @@
 6180
 1E00
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni01A0
 ENCODING 416
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6560,7 +6557,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni01A1
 ENCODING 417
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6575,7 +6572,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni01A2
 ENCODING 418
 SWIDTH 900 0
 DWIDTH 15 0
@@ -6596,7 +6593,7 @@
 0008
 001C
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni01A3
 ENCODING 419
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6614,7 +6611,7 @@
 0100
 0380
 ENDCHAR
-STARTCHAR C080
+STARTCHAR uni01A4
 ENCODING 420
 SWIDTH 660 0
 DWIDTH 11 0
@@ -6632,7 +6629,7 @@
 1000
 7C00
 ENDCHAR
-STARTCHAR C112
+STARTCHAR uni01A5
 ENCODING 421
 SWIDTH 540 0
 DWIDTH 9 0
@@ -6651,7 +6648,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni01A6
 ENCODING 422
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6671,7 +6668,7 @@
 0100
 00E0
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni01A7
 ENCODING 423
 SWIDTH 420 0
 DWIDTH 7 0
@@ -6689,7 +6686,7 @@
 84
 7C
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni01A8
 ENCODING 424
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6703,7 +6700,7 @@
 88
 78
 ENDCHAR
-STARTCHAR C006
+STARTCHAR uni01A9
 ENCODING 425
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6721,7 +6718,7 @@
 4180
 FF80
 ENDCHAR
-STARTCHAR char405
+STARTCHAR uni01AA
 ENCODING 426
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6741,7 +6738,7 @@
 24
 18
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni01AB
 ENCODING 427
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6760,7 +6757,7 @@
 44
 38
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni01AC
 ENCODING 428
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6778,7 +6775,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni01AD
 ENCODING 429
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6797,7 +6794,7 @@
 24
 18
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni01AE
 ENCODING 430
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6818,7 +6815,7 @@
 0A00
 0600
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni01AF
 ENCODING 431
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6838,7 +6835,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni01B0
 ENCODING 432
 SWIDTH 480 0
 DWIDTH 8 0
@@ -6854,7 +6851,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C010
+STARTCHAR uni01B1
 ENCODING 433
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6872,7 +6869,7 @@
 2080
 1F00
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni01B2
 ENCODING 434
 SWIDTH 660 0
 DWIDTH 11 0
@@ -6891,7 +6888,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni01B3
 ENCODING 435
 SWIDTH 720 0
 DWIDTH 12 0
@@ -6909,7 +6906,7 @@
 0200
 0F80
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni01B4
 ENCODING 436
 SWIDTH 480 0
 DWIDTH 8 0
@@ -6928,7 +6925,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni01B5
 ENCODING 437
 SWIDTH 480 0
 DWIDTH 8 0
@@ -6946,7 +6943,7 @@
 46
 FE
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni01B6
 ENCODING 438
 SWIDTH 360 0
 DWIDTH 6 0
@@ -6960,7 +6957,7 @@
 48
 F8
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01B7
 ENCODING 439
 SWIDTH 600 0
 DWIDTH 10 0
@@ -6981,7 +6978,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01B8
 ENCODING 440
 SWIDTH 600 0
 DWIDTH 10 0
@@ -7002,7 +6999,7 @@
 41
 3E
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01B9
 ENCODING 441
 SWIDTH 360 0
 DWIDTH 6 0
@@ -7018,7 +7015,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01BA
 ENCODING 442
 SWIDTH 360 0
 DWIDTH 6 0
@@ -7034,7 +7031,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C050
+STARTCHAR uni01BB
 ENCODING 443
 SWIDTH 420 0
 DWIDTH 7 0
@@ -7052,7 +7049,7 @@
 48
 F8
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01BC
 ENCODING 444
 SWIDTH 420 0
 DWIDTH 7 0
@@ -7070,7 +7067,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01BD
 ENCODING 445
 SWIDTH 360 0
 DWIDTH 6 0
@@ -7084,7 +7081,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni01BE
 ENCODING 446
 SWIDTH 360 0
 DWIDTH 6 0
@@ -7102,7 +7099,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C112
+STARTCHAR uni01BF
 ENCODING 447
 SWIDTH 420 0
 DWIDTH 7 0
@@ -7119,7 +7116,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uni01C0
 ENCODING 448
 SWIDTH 240 0
 DWIDTH 4 0
@@ -7138,7 +7135,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uni01C1
 ENCODING 449
 SWIDTH 300 0
 DWIDTH 5 0
@@ -7157,7 +7154,7 @@
 A0
 A0
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uni01C2
 ENCODING 450
 SWIDTH 420 0
 DWIDTH 7 0
@@ -7176,7 +7173,7 @@
 20
 20
 ENDCHAR
-STARTCHAR C033
+STARTCHAR uni01C3
 ENCODING 451
 SWIDTH 300 0
 DWIDTH 5 0
@@ -7195,7 +7192,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni01C4
 ENCODING 452
 SWIDTH 1140 0
 DWIDTH 19 0
@@ -7217,7 +7214,7 @@
 2188C0
 FF1FC0
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni01C5
 ENCODING 453
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -7235,7 +7232,7 @@
 2189
 FF1F
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni01C6
 ENCODING 454
 SWIDTH 780 0
 DWIDTH 13 0
@@ -7254,7 +7251,7 @@
 4890
 7DF0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni01C7
 ENCODING 455
 SWIDTH 960 0
 DWIDTH 16 0
@@ -7272,7 +7269,7 @@
 2348
 FF70
 ENDCHAR
-STARTCHAR 0x01C8
+STARTCHAR uni01C8
 ENCODING 456
 SWIDTH 780 0
 DWIDTH 13 0
@@ -7293,7 +7290,7 @@
 0090
 00E0
 ENDCHAR
-STARTCHAR 0x01C9
+STARTCHAR uni01C9
 ENCODING 457
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7315,7 +7312,7 @@
 12
 1C
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni01CA
 ENCODING 458
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -7333,7 +7330,7 @@
 219200
 F89C00
 ENDCHAR
-STARTCHAR 0x01CB
+STARTCHAR uni01CB
 ENCODING 459
 SWIDTH 960 0
 DWIDTH 16 0
@@ -7354,7 +7351,7 @@
 0012
 001C
 ENDCHAR
-STARTCHAR 0x01CC
+STARTCHAR uni01CC
 ENCODING 460
 SWIDTH 660 0
 DWIDTH 11 0
@@ -7375,7 +7372,7 @@
 0240
 0380
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni01CD
 ENCODING 461
 SWIDTH 660 0
 DWIDTH 11 0
@@ -7397,7 +7394,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni01CE
 ENCODING 462
 SWIDTH 420 0
 DWIDTH 7 0
@@ -7415,7 +7412,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni01CF
 ENCODING 463
 SWIDTH 360 0
 DWIDTH 6 0
@@ -7437,7 +7434,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni01D0
 ENCODING 464
 SWIDTH 240 0
 DWIDTH 4 0
@@ -7455,7 +7452,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni01D1
 ENCODING 465
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7477,7 +7474,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni01D2
 ENCODING 466
 SWIDTH 360 0
 DWIDTH 6 0
@@ -7495,7 +7492,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni01D3
 ENCODING 467
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7517,7 +7514,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni01D4
 ENCODING 468
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7535,7 +7532,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni01D5
 ENCODING 469
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7558,7 +7555,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni01D6
 ENCODING 470
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7577,7 +7574,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni01D7
 ENCODING 471
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7603,7 +7600,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni01D8
 ENCODING 472
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7625,7 +7622,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni01D9
 ENCODING 473
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7650,7 +7647,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni01DA
 ENCODING 474
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7671,7 +7668,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni01DB
 ENCODING 475
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7697,7 +7694,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni01DC
 ENCODING 476
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7719,7 +7716,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni01DD
 ENCODING 477
 SWIDTH 360 0
 DWIDTH 6 0
@@ -7733,7 +7730,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni01DE
 ENCODING 478
 SWIDTH 660 0
 DWIDTH 11 0
@@ -7756,7 +7753,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni01DF
 ENCODING 479
 SWIDTH 420 0
 DWIDTH 7 0
@@ -7775,7 +7772,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni01E0
 ENCODING 480
 SWIDTH 660 0
 DWIDTH 11 0
@@ -7798,7 +7795,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni01E1
 ENCODING 481
 SWIDTH 420 0
 DWIDTH 7 0
@@ -7817,7 +7814,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C029
+STARTCHAR uni01E2
 ENCODING 482
 SWIDTH 900 0
 DWIDTH 15 0
@@ -7837,7 +7834,7 @@
 2208
 F7F8
 ENDCHAR
-STARTCHAR C026
+STARTCHAR uni01E3
 ENCODING 483
 SWIDTH 660 0
 DWIDTH 11 0
@@ -7853,7 +7850,7 @@
 8C40
 7380
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni01E4
 ENCODING 484
 SWIDTH 660 0
 DWIDTH 11 0
@@ -7871,7 +7868,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni01E5
 ENCODING 485
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7889,7 +7886,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni01E6
 ENCODING 486
 SWIDTH 660 0
 DWIDTH 11 0
@@ -7911,7 +7908,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni01E7
 ENCODING 487
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7933,7 +7930,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni01E8
 ENCODING 488
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7955,7 +7952,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni01E9
 ENCODING 489
 SWIDTH 480 0
 DWIDTH 8 0
@@ -7978,7 +7975,7 @@
 48
 EE
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni01EA
 ENCODING 490
 SWIDTH 720 0
 DWIDTH 12 0
@@ -7999,7 +7996,7 @@
 1200
 0C00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni01EB
 ENCODING 491
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8016,7 +8013,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni01EC
 ENCODING 492
 SWIDTH 720 0
 DWIDTH 12 0
@@ -8039,7 +8036,7 @@
 1200
 0C00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni01ED
 ENCODING 493
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8058,7 +8055,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01EE
 ENCODING 494
 SWIDTH 600 0
 DWIDTH 10 0
@@ -8083,7 +8080,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni01EF
 ENCODING 495
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8103,7 +8100,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni01F0
 ENCODING 496
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8124,7 +8121,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni01F1
 ENCODING 497
 SWIDTH 1140 0
 DWIDTH 19 0
@@ -8142,7 +8139,7 @@
 2188C0
 FF1FC0
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni01F2
 ENCODING 498
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -8160,7 +8157,7 @@
 2189
 FF1F
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni01F3
 ENCODING 499
 SWIDTH 780 0
 DWIDTH 13 0
@@ -8179,7 +8176,7 @@
 8890
 7DF0
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni01F4
 ENCODING 500
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8202,7 +8199,7 @@
 2080
 1F80
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni01F5
 ENCODING 501
 SWIDTH 480 0
 DWIDTH 8 0
@@ -8225,7 +8222,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni01F6
 ENCODING 502
 SWIDTH 900 0
 DWIDTH 15 0
@@ -8243,7 +8240,7 @@
 2084
 F878
 ENDCHAR
-STARTCHAR C080
+STARTCHAR uni01F7
 ENCODING 503
 SWIDTH 540 0
 DWIDTH 9 0
@@ -8263,7 +8260,7 @@
 2000
 4000
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni01F8
 ENCODING 504
 SWIDTH 720 0
 DWIDTH 12 0
@@ -8286,7 +8283,7 @@
 2180
 F880
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni01F9
 ENCODING 505
 SWIDTH 480 0
 DWIDTH 8 0
@@ -8305,7 +8302,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni01FA
 ENCODING 506
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8332,7 +8329,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni01FB
 ENCODING 507
 SWIDTH 420 0
 DWIDTH 7 0
@@ -8355,7 +8352,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C029
+STARTCHAR uni01FC
 ENCODING 508
 SWIDTH 900 0
 DWIDTH 15 0
@@ -8378,7 +8375,7 @@
 2208
 F7F8
 ENDCHAR
-STARTCHAR C026
+STARTCHAR uni01FD
 ENCODING 509
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8397,7 +8394,7 @@
 8C40
 7380
 ENDCHAR
-STARTCHAR C031
+STARTCHAR uni01FE
 ENCODING 510
 SWIDTH 720 0
 DWIDTH 12 0
@@ -8421,7 +8418,7 @@
 3E00
 4000
 ENDCHAR
-STARTCHAR C028
+STARTCHAR uni01FF
 ENCODING 511
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8442,7 +8439,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0200
 ENCODING 512
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8465,7 +8462,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0201
 ENCODING 513
 SWIDTH 420 0
 DWIDTH 7 0
@@ -8484,7 +8481,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0202
 ENCODING 514
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8505,7 +8502,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0203
 ENCODING 515
 SWIDTH 420 0
 DWIDTH 7 0
@@ -8522,7 +8519,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0204
 ENCODING 516
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8545,7 +8542,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0205
 ENCODING 517
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8564,7 +8561,7 @@
 44
 38
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0206
 ENCODING 518
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8585,7 +8582,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0207
 ENCODING 519
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8602,7 +8599,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0208
 ENCODING 520
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8625,7 +8622,7 @@
 10
 7C
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni0209
 ENCODING 521
 SWIDTH 240 0
 DWIDTH 4 0
@@ -8644,7 +8641,7 @@
 10
 38
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni020A
 ENCODING 522
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8665,7 +8662,7 @@
 10
 7C
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni020B
 ENCODING 523
 SWIDTH 240 0
 DWIDTH 4 0
@@ -8682,7 +8679,7 @@
 10
 38
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni020C
 ENCODING 524
 SWIDTH 720 0
 DWIDTH 12 0
@@ -8705,7 +8702,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni020D
 ENCODING 525
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8724,7 +8721,7 @@
 44
 38
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni020E
 ENCODING 526
 SWIDTH 720 0
 DWIDTH 12 0
@@ -8745,7 +8742,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni020F
 ENCODING 527
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8762,7 +8759,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0210
 ENCODING 528
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8785,7 +8782,7 @@
 2100
 F8E0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0211
 ENCODING 529
 SWIDTH 420 0
 DWIDTH 7 0
@@ -8804,7 +8801,7 @@
 20
 78
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0212
 ENCODING 530
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8825,7 +8822,7 @@
 2100
 F8E0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0213
 ENCODING 531
 SWIDTH 420 0
 DWIDTH 7 0
@@ -8842,7 +8839,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0214
 ENCODING 532
 SWIDTH 720 0
 DWIDTH 12 0
@@ -8865,7 +8862,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0215
 ENCODING 533
 SWIDTH 480 0
 DWIDTH 8 0
@@ -8884,7 +8881,7 @@
 22
 1F
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0216
 ENCODING 534
 SWIDTH 720 0
 DWIDTH 12 0
@@ -8905,7 +8902,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0217
 ENCODING 535
 SWIDTH 480 0
 DWIDTH 8 0
@@ -8922,7 +8919,7 @@
 44
 3E
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni0218
 ENCODING 536
 SWIDTH 480 0
 DWIDTH 8 0
@@ -8946,7 +8943,7 @@
 10
 20
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni0219
 ENCODING 537
 SWIDTH 360 0
 DWIDTH 6 0
@@ -8966,7 +8963,7 @@
 10
 20
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni021A
 ENCODING 538
 SWIDTH 660 0
 DWIDTH 11 0
@@ -8990,7 +8987,7 @@
 0400
 0800
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni021B
 ENCODING 539
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9013,7 +9010,7 @@
 10
 20
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni021C
 ENCODING 540
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9034,7 +9031,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni021D
 ENCODING 541
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9051,7 +9048,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni021E
 ENCODING 542
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9073,7 +9070,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni021F
 ENCODING 543
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9096,7 +9093,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni0222
 ENCODING 546
 SWIDTH 540 0
 DWIDTH 9 0
@@ -9114,7 +9111,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni0223
 ENCODING 547
 SWIDTH 420 0
 DWIDTH 7 0
@@ -9130,7 +9127,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni0224
 ENCODING 548
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9151,7 +9148,7 @@
 02
 04
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni0225
 ENCODING 549
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9168,7 +9165,7 @@
 08
 10
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0226
 ENCODING 550
 SWIDTH 660 0
 DWIDTH 11 0
@@ -9189,7 +9186,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0227
 ENCODING 551
 SWIDTH 420 0
 DWIDTH 7 0
@@ -9206,7 +9203,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0228
 ENCODING 552
 SWIDTH 660 0
 DWIDTH 11 0
@@ -9227,7 +9224,7 @@
 0400
 1C00
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0229
 ENCODING 553
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9244,7 +9241,7 @@
 10
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni022A
 ENCODING 554
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9267,7 +9264,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni022B
 ENCODING 555
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9286,7 +9283,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni022C
 ENCODING 556
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9310,7 +9307,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni022D
 ENCODING 557
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9330,7 +9327,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni022E
 ENCODING 558
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9351,7 +9348,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni022F
 ENCODING 559
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9368,7 +9365,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0230
 ENCODING 560
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9391,7 +9388,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni0231
 ENCODING 561
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9410,7 +9407,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni0232
 ENCODING 562
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9431,7 +9428,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni0233
 ENCODING 563
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9450,7 +9447,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0250
 ENCODING 592
 SWIDTH 420 0
 DWIDTH 7 0
@@ -9464,7 +9461,7 @@
 44
 38
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0251
 ENCODING 593
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9478,7 +9475,7 @@
 9A
 6C
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0252
 ENCODING 594
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9492,7 +9489,7 @@
 32
 2C
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0253
 ENCODING 595
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9512,7 +9509,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0254
 ENCODING 596
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9526,7 +9523,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0255
 ENCODING 597
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9541,7 +9538,7 @@
 70
 80
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni0256
 ENCODING 598
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9563,7 +9560,7 @@
 09
 07
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni0257
 ENCODING 599
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9583,7 +9580,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0258
 ENCODING 600
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9597,7 +9594,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0259
 ENCODING 601
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9611,7 +9608,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni025A
 ENCODING 602
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9625,7 +9622,7 @@
 90
 60
 ENDCHAR
-STARTCHAR char603
+STARTCHAR uni025B
 ENCODING 603
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9639,7 +9636,7 @@
 88
 70
 ENDCHAR
-STARTCHAR char603
+STARTCHAR uni025C
 ENCODING 604
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9653,7 +9650,7 @@
 88
 70
 ENDCHAR
-STARTCHAR char603
+STARTCHAR uni025D
 ENCODING 605
 SWIDTH 600 0
 DWIDTH 10 0
@@ -9667,7 +9664,7 @@
 8800
 7000
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni025E
 ENCODING 606
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9681,7 +9678,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni025F
 ENCODING 607
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9698,7 +9695,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0260
 ENCODING 608
 SWIDTH 420 0
 DWIDTH 7 0
@@ -9717,7 +9714,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0261
 ENCODING 609
 SWIDTH 360 0
 DWIDTH 6 0
@@ -9734,7 +9731,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR char610
+STARTCHAR uni0262
 ENCODING 610
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9748,7 +9745,7 @@
 44
 3C
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni0263
 ENCODING 611
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9766,7 +9763,7 @@
 0A00
 0400
 ENDCHAR
-STARTCHAR C118
+STARTCHAR uni0264
 ENCODING 612
 SWIDTH 540 0
 DWIDTH 9 0
@@ -9780,7 +9777,7 @@
 24
 18
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0265
 ENCODING 613
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9797,7 +9794,7 @@
 04
 06
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0266
 ENCODING 614
 SWIDTH 480 0
 DWIDTH 8 0
@@ -9817,7 +9814,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0267
 ENCODING 615
 SWIDTH 420 0
 DWIDTH 7 0
@@ -9840,7 +9837,7 @@
 24
 38
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni0268
 ENCODING 616
 SWIDTH 240 0
 DWIDTH 4 0
@@ -9859,7 +9856,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni0269
 ENCODING 617
 SWIDTH 300 0
 DWIDTH 5 0
@@ -9873,7 +9870,7 @@
 50
 70
 ENDCHAR
-STARTCHAR char618
+STARTCHAR uni026A
 ENCODING 618
 SWIDTH 240 0
 DWIDTH 4 0
@@ -9887,7 +9884,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni026B
 ENCODING 619
 SWIDTH 300 0
 DWIDTH 5 0
@@ -9906,7 +9903,7 @@
 20
 70
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni026C
 ENCODING 620
 SWIDTH 420 0
 DWIDTH 7 0
@@ -9925,7 +9922,7 @@
 10
 38
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni026D
 ENCODING 621
 SWIDTH 240 0
 DWIDTH 4 0
@@ -9947,7 +9944,7 @@
 48
 38
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni026E
 ENCODING 622
 SWIDTH 420 0
 DWIDTH 7 0
@@ -9969,7 +9966,7 @@
 22
 1C
 ENDCHAR
-STARTCHAR C109
+STARTCHAR uni026F
 ENCODING 623
 SWIDTH 720 0
 DWIDTH 12 0
@@ -9983,7 +9980,7 @@
 4440
 3BE0
 ENDCHAR
-STARTCHAR C109
+STARTCHAR uni0270
 ENCODING 624
 SWIDTH 720 0
 DWIDTH 12 0
@@ -10000,7 +9997,7 @@
 0040
 0060
 ENDCHAR
-STARTCHAR C109
+STARTCHAR uni0271
 ENCODING 625
 SWIDTH 660 0
 DWIDTH 11 0
@@ -10017,7 +10014,7 @@
 0240
 0380
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0272
 ENCODING 626
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10034,7 +10031,7 @@
 9000
 E000
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0273
 ENCODING 627
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10051,7 +10048,7 @@
 0480
 0380
 ENDCHAR
-STARTCHAR char628
+STARTCHAR uni0274
 ENCODING 628
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10065,7 +10062,7 @@
 4C
 E4
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni0275
 ENCODING 629
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10079,7 +10076,7 @@
 88
 70
 ENDCHAR
-STARTCHAR char630
+STARTCHAR uni0276
 ENCODING 630
 SWIDTH 600 0
 DWIDTH 10 0
@@ -10093,7 +10090,7 @@
 4900
 3F00
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni0277
 ENCODING 631
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10107,7 +10104,7 @@
 92
 6C
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0278
 ENCODING 632
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10125,7 +10122,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0279
 ENCODING 633
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10139,7 +10136,7 @@
 B0
 58
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni027A
 ENCODING 634
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10157,7 +10154,7 @@
 B0
 58
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni027B
 ENCODING 635
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10174,7 +10171,7 @@
 12
 0E
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni027C
 ENCODING 636
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10192,7 +10189,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni027D
 ENCODING 637
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10209,7 +10206,7 @@
 48
 38
 ENDCHAR
-STARTCHAR char638
+STARTCHAR uni027E
 ENCODING 638
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10223,7 +10220,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR char638
+STARTCHAR uni027F
 ENCODING 639
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10237,7 +10234,7 @@
 10
 78
 ENDCHAR
-STARTCHAR char640
+STARTCHAR uni0280
 ENCODING 640
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10251,7 +10248,7 @@
 48
 E6
 ENDCHAR
-STARTCHAR char640
+STARTCHAR uni0281
 ENCODING 641
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10265,7 +10262,7 @@
 48
 F0
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni0282
 ENCODING 642
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10282,7 +10279,7 @@
 A0
 60
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni0283
 ENCODING 643
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10303,7 +10300,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni0284
 ENCODING 644
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10324,7 +10321,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni0285
 ENCODING 645
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10345,7 +10342,7 @@
 12
 0E
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni0286
 ENCODING 646
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10366,7 +10363,7 @@
 94
 74
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0287
 ENCODING 647
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10383,7 +10380,7 @@
 20
 20
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0288
 ENCODING 648
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10403,7 +10400,7 @@
 24
 1C
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0289
 ENCODING 649
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10417,7 +10414,7 @@
 48
 3C
 ENDCHAR
-STARTCHAR char650
+STARTCHAR uni028A
 ENCODING 650
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10431,7 +10428,7 @@
 84
 78
 ENDCHAR
-STARTCHAR char651
+STARTCHAR uni028B
 ENCODING 651
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10446,7 +10443,7 @@
 44
 38
 ENDCHAR
-STARTCHAR C118
+STARTCHAR uni028C
 ENCODING 652
 SWIDTH 540 0
 DWIDTH 9 0
@@ -10460,7 +10457,7 @@
 24
 E7
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni028D
 ENCODING 653
 SWIDTH 720 0
 DWIDTH 12 0
@@ -10474,7 +10471,7 @@
 2480
 EEE0
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni028E
 ENCODING 654
 SWIDTH 540 0
 DWIDTH 9 0
@@ -10491,7 +10488,7 @@
 24
 E7
 ENDCHAR
-STARTCHAR char655
+STARTCHAR uni028F
 ENCODING 655
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10505,7 +10502,7 @@
 10
 38
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni0290
 ENCODING 656
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10522,7 +10519,7 @@
 09
 07
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni0291
 ENCODING 657
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10537,7 +10534,7 @@
 FC
 20
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni0292
 ENCODING 658
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10553,7 +10550,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni0293
 ENCODING 659
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10570,7 +10567,7 @@
 70
 08
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0294
 ENCODING 660
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10588,7 +10585,7 @@
 40
 40
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0295
 ENCODING 661
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10606,7 +10603,7 @@
 10
 10
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0296
 ENCODING 662
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10624,7 +10621,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0297
 ENCODING 663
 SWIDTH 360 0
 DWIDTH 6 0
@@ -10642,7 +10639,7 @@
 88
 70
 ENDCHAR
-STARTCHAR char664
+STARTCHAR uni0298
 ENCODING 664
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10655,7 +10652,7 @@
 48
 30
 ENDCHAR
-STARTCHAR char665
+STARTCHAR uni0299
 ENCODING 665
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10669,7 +10666,7 @@
 44
 F8
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni029A
 ENCODING 666
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10683,7 +10680,7 @@
 84
 78
 ENDCHAR
-STARTCHAR char610
+STARTCHAR uni029B
 ENCODING 667
 SWIDTH 540 0
 DWIDTH 9 0
@@ -10698,7 +10695,7 @@
 44
 3C
 ENDCHAR
-STARTCHAR char668
+STARTCHAR uni029C
 ENCODING 668
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10712,7 +10709,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni029D
 ENCODING 669
 SWIDTH 240 0
 DWIDTH 4 0
@@ -10734,7 +10731,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni029E
 ENCODING 670
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10753,7 +10750,7 @@
 04
 06
 ENDCHAR
-STARTCHAR char671
+STARTCHAR uni029F
 ENCODING 671
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10767,7 +10764,7 @@
 4C
 FC
 ENDCHAR
-STARTCHAR C113
+STARTCHAR uni02A0
 ENCODING 672
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10786,7 +10783,7 @@
 08
 1C
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02A1
 ENCODING 673
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10804,7 +10801,7 @@
 20
 20
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02A2
 ENCODING 674
 SWIDTH 420 0
 DWIDTH 7 0
@@ -10822,7 +10819,7 @@
 10
 10
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni02A3
 ENCODING 675
 SWIDTH 660 0
 DWIDTH 11 0
@@ -10841,7 +10838,7 @@
 8A40
 7FC0
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni02A4
 ENCODING 676
 SWIDTH 660 0
 DWIDTH 11 0
@@ -10862,7 +10859,7 @@
 0440
 0380
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni02A5
 ENCODING 677
 SWIDTH 720 0
 DWIDTH 12 0
@@ -10882,7 +10879,7 @@
 7FC0
 0100
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni02A6
 ENCODING 678
 SWIDTH 600 0
 DWIDTH 10 0
@@ -10899,7 +10896,7 @@
 2080
 1F00
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni02A7
 ENCODING 679
 SWIDTH 540 0
 DWIDTH 9 0
@@ -10920,7 +10917,7 @@
 1200
 1C00
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni02A8
 ENCODING 680
 SWIDTH 720 0
 DWIDTH 12 0
@@ -10938,7 +10935,7 @@
 19C0
 0200
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni02A9
 ENCODING 681
 SWIDTH 660 0
 DWIDTH 11 0
@@ -10960,7 +10957,7 @@
 0140
 0180
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni02AA
 ENCODING 682
 SWIDTH 540 0
 DWIDTH 9 0
@@ -10979,7 +10976,7 @@
 61
 DE
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni02AB
 ENCODING 683
 SWIDTH 480 0
 DWIDTH 8 0
@@ -10998,7 +10995,7 @@
 52
 FE
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni02AC
 ENCODING 684
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11016,7 +11013,7 @@
 38
 28
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni02AD
 ENCODING 685
 SWIDTH 420 0
 DWIDTH 7 0
@@ -11032,7 +11029,7 @@
 84
 84
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni02B0
 ENCODING 688
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11051,7 +11048,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni02B1
 ENCODING 689
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11070,7 +11067,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni02B2
 ENCODING 690
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11090,7 +11087,7 @@
 A0
 C0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni02B3
 ENCODING 691
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11104,7 +11101,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni02B4
 ENCODING 692
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11118,7 +11115,7 @@
 B0
 58
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni02B5
 ENCODING 693
 SWIDTH 420 0
 DWIDTH 7 0
@@ -11134,7 +11131,7 @@
 14
 08
 ENDCHAR
-STARTCHAR char640
+STARTCHAR uni02B6
 ENCODING 694
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11148,7 +11145,7 @@
 48
 F0
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni02B7
 ENCODING 695
 SWIDTH 660 0
 DWIDTH 11 0
@@ -11162,7 +11159,7 @@
 1B00
 1100
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni02B8
 ENCODING 696
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11179,7 +11176,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni02B9
 ENCODING 697
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11191,7 +11188,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni02BA
 ENCODING 698
 SWIDTH 540 0
 DWIDTH 9 0
@@ -11203,7 +11200,7 @@
 44
 88
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni02BB
 ENCODING 699
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11215,7 +11212,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni02BC
 ENCODING 700
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11227,7 +11224,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni02BD
 ENCODING 701
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11239,7 +11236,7 @@
 80
 40
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni02BE
 ENCODING 702
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11251,7 +11248,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni02BF
 ENCODING 703
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11263,7 +11260,7 @@
 80
 40
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02C0
 ENCODING 704
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11280,7 +11277,7 @@
 40
 40
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02C1
 ENCODING 705
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11297,7 +11294,7 @@
 10
 10
 ENDCHAR
-STARTCHAR char60
+STARTCHAR uni02C2
 ENCODING 706
 SWIDTH 540 0
 DWIDTH 9 0
@@ -11311,7 +11308,7 @@
 0C
 03
 ENDCHAR
-STARTCHAR char60
+STARTCHAR uni02C3
 ENCODING 707
 SWIDTH 540 0
 DWIDTH 9 0
@@ -11325,7 +11322,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR char60
+STARTCHAR uni02C4
 ENCODING 708
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11340,7 +11337,7 @@
 10
 10
 ENDCHAR
-STARTCHAR char60
+STARTCHAR uni02C5
 ENCODING 709
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11355,7 +11352,7 @@
 82
 82
 ENDCHAR
-STARTCHAR char710
+STARTCHAR uni02C6
 ENCODING 710
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11365,7 +11362,7 @@
 70
 88
 ENDCHAR
-STARTCHAR char710
+STARTCHAR uni02C7
 ENCODING 711
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11375,7 +11372,7 @@
 70
 20
 ENDCHAR
-STARTCHAR char712
+STARTCHAR uni02C8
 ENCODING 712
 SWIDTH 120 0
 DWIDTH 2 0
@@ -11385,7 +11382,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char713
+STARTCHAR uni02C9
 ENCODING 713
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11393,7 +11390,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni02CA
 ENCODING 714
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11404,7 +11401,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni02CB
 ENCODING 715
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11415,7 +11412,7 @@
 40
 20
 ENDCHAR
-STARTCHAR char716
+STARTCHAR uni02CC
 ENCODING 716
 SWIDTH 120 0
 DWIDTH 2 0
@@ -11425,7 +11422,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char717
+STARTCHAR uni02CD
 ENCODING 717
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11433,7 +11430,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni02CE
 ENCODING 718
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11444,7 +11441,7 @@
 40
 20
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni02CF
 ENCODING 719
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11455,7 +11452,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char720
+STARTCHAR uni02D0
 ENCODING 720
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11471,7 +11468,7 @@
 E0
 E0
 ENDCHAR
-STARTCHAR char720
+STARTCHAR uni02D1
 ENCODING 721
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11481,7 +11478,7 @@
 E0
 40
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni02D2
 ENCODING 722
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11493,7 +11490,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni02D3
 ENCODING 723
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11505,7 +11502,7 @@
 80
 40
 ENDCHAR
-STARTCHAR char724
+STARTCHAR uni02D4
 ENCODING 724
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11516,7 +11513,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR char724
+STARTCHAR uni02D5
 ENCODING 725
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11527,7 +11524,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char724
+STARTCHAR uni02D6
 ENCODING 726
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11539,7 +11536,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char724
+STARTCHAR uni02D7
 ENCODING 727
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11547,7 +11544,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni02D8
 ENCODING 728
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11556,7 +11553,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C095
+STARTCHAR uni02D9
 ENCODING 729
 SWIDTH 180 0
 DWIDTH 3 0
@@ -11565,7 +11562,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni02DA
 ENCODING 730
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11576,7 +11573,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C024
+STARTCHAR uni02DB
 ENCODING 731
 SWIDTH 300 0
 DWIDTH 5 0
@@ -11586,7 +11583,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni02DC
 ENCODING 732
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11596,7 +11593,7 @@
 A8
 90
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni02DD
 ENCODING 733
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11607,7 +11604,7 @@
 48
 90
 ENDCHAR
-STARTCHAR char603
+STARTCHAR uni02DE
 ENCODING 734
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11618,7 +11615,7 @@
 28
 10
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni02E0
 ENCODING 736
 SWIDTH 600 0
 DWIDTH 10 0
@@ -11635,7 +11632,7 @@
 1400
 0800
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni02E1
 ENCODING 737
 SWIDTH 240 0
 DWIDTH 4 0
@@ -11654,7 +11651,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni02E2
 ENCODING 738
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11668,7 +11665,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR C120
+STARTCHAR uni02E3
 ENCODING 739
 SWIDTH 420 0
 DWIDTH 7 0
@@ -11682,7 +11679,7 @@
 48
 CC
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02E4
 ENCODING 740
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11701,7 +11698,7 @@
 10
 10
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02E5
 ENCODING 741
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11717,7 +11714,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02E6
 ENCODING 742
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11733,7 +11730,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02E7
 ENCODING 743
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11749,7 +11746,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02E8
 ENCODING 744
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11765,7 +11762,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02E9
 ENCODING 745
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11781,7 +11778,7 @@
 08
 F8
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02EA
 ENCODING 746
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11795,7 +11792,7 @@
 80
 F8
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni02EB
 ENCODING 747
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11809,7 +11806,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char716
+STARTCHAR uni02EC
 ENCODING 748
 SWIDTH 360 0
 DWIDTH 6 0
@@ -11819,7 +11816,7 @@
 50
 20
 ENDCHAR
-STARTCHAR char749
+STARTCHAR uni02ED
 ENCODING 749
 SWIDTH 540 0
 DWIDTH 9 0
@@ -11829,7 +11826,7 @@
 00
 FE
 ENDCHAR
-STARTCHAR C034
+STARTCHAR uni02EE
 ENCODING 750
 SWIDTH 480 0
 DWIDTH 8 0
@@ -11841,7 +11838,7 @@
 48
 90
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0300
 ENCODING 768
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11852,7 +11849,7 @@
 40
 20
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0301
 ENCODING 769
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11863,7 +11860,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0302
 ENCODING 770
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11873,7 +11870,7 @@
 70
 88
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0303
 ENCODING 771
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11883,7 +11880,7 @@
 A8
 90
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0304
 ENCODING 772
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11891,7 +11888,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0305
 ENCODING 773
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11899,7 +11896,7 @@
 BITMAP
 FFC0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0306
 ENCODING 774
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11908,7 +11905,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C095
+STARTCHAR uni0307
 ENCODING 775
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11917,7 +11914,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0308
 ENCODING 776
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11926,7 +11923,7 @@
 D8
 D8
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0309
 ENCODING 777
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11938,7 +11935,7 @@
 40
 40
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni030A
 ENCODING 778
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11949,7 +11946,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni030B
 ENCODING 779
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11960,7 +11957,7 @@
 48
 90
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni030C
 ENCODING 780
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11970,7 +11967,7 @@
 70
 20
 ENDCHAR
-STARTCHAR char781
+STARTCHAR uni030D
 ENCODING 781
 SWIDTH 0 0
 DWIDTH 0 0
@@ -11981,7 +11978,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char781
+STARTCHAR uni030E
 ENCODING 782
 SWIDTH 120 0
 DWIDTH 2 0
@@ -11992,7 +11989,7 @@
 A0
 A0
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni030F
 ENCODING 783
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12003,7 +12000,7 @@
 48
 24
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0310
 ENCODING 784
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12014,7 +12011,7 @@
 84
 78
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0311
 ENCODING 785
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12023,7 +12020,7 @@
 70
 88
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni0312
 ENCODING 786
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12035,7 +12032,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni0313
 ENCODING 787
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12047,7 +12044,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni0314
 ENCODING 788
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12059,7 +12056,7 @@
 80
 40
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni0315
 ENCODING 789
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12071,7 +12068,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0316
 ENCODING 790
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12082,7 +12079,7 @@
 40
 20
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0317
 ENCODING 791
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12093,7 +12090,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni0318
 ENCODING 792
 SWIDTH 180 0
 DWIDTH 3 0
@@ -12105,7 +12102,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni0319
 ENCODING 793
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12117,7 +12114,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char794
+STARTCHAR uni031A
 ENCODING 794
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12127,7 +12124,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni031B
 ENCODING 795
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12138,7 +12135,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni031C
 ENCODING 796
 SWIDTH 120 0
 DWIDTH 2 0
@@ -12150,7 +12147,7 @@
 80
 40
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni031D
 ENCODING 797
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12160,7 +12157,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni031E
 ENCODING 798
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12170,7 +12167,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni031F
 ENCODING 799
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12182,7 +12179,7 @@
 20
 20
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0320
 ENCODING 800
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12190,7 +12187,7 @@
 BITMAP
 F0
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0321
 ENCODING 801
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12202,7 +12199,7 @@
 A0
 C0
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0322
 ENCODING 802
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12214,7 +12211,7 @@
 A0
 60
 ENDCHAR
-STARTCHAR C095
+STARTCHAR uni0323
 ENCODING 803
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12223,7 +12220,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0324
 ENCODING 804
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12232,7 +12229,7 @@
 D8
 D8
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0325
 ENCODING 805
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12243,7 +12240,7 @@
 90
 60
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni0326
 ENCODING 806
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12255,7 +12252,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C024
+STARTCHAR uni0327
 ENCODING 807
 SWIDTH 420 0
 DWIDTH 7 0
@@ -12265,7 +12262,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR C024
+STARTCHAR uni0328
 ENCODING 808
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12275,7 +12272,7 @@
 90
 60
 ENDCHAR
-STARTCHAR char781
+STARTCHAR uni0329
 ENCODING 809
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12286,7 +12283,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char810
+STARTCHAR uni032A
 ENCODING 810
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12295,7 +12292,7 @@
 F8
 88
 ENDCHAR
-STARTCHAR char810
+STARTCHAR uni032B
 ENCODING 811
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12305,7 +12302,7 @@
 A8
 50
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni032C
 ENCODING 812
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12315,7 +12312,7 @@
 70
 20
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni032D
 ENCODING 813
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12325,7 +12322,7 @@
 70
 88
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni032E
 ENCODING 814
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12334,7 +12331,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni032F
 ENCODING 815
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12343,7 +12340,7 @@
 70
 88
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0330
 ENCODING 816
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12353,7 +12350,7 @@
 A8
 90
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0331
 ENCODING 817
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12361,7 +12358,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0332
 ENCODING 818
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12369,7 +12366,7 @@
 BITMAP
 FFC0
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0333
 ENCODING 819
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12379,7 +12376,7 @@
 0000
 FFC0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0334
 ENCODING 820
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12389,7 +12386,7 @@
 A8
 90
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0335
 ENCODING 821
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12397,7 +12394,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0336
 ENCODING 822
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12405,7 +12402,7 @@
 BITMAP
 FFC0
 ENDCHAR
-STARTCHAR C047
+STARTCHAR uni0337
 ENCODING 823
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12418,7 +12415,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C047
+STARTCHAR uni0338
 ENCODING 824
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12437,7 +12434,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0339
 ENCODING 825
 SWIDTH 120 0
 DWIDTH 2 0
@@ -12449,7 +12446,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char810
+STARTCHAR uni033A
 ENCODING 826
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12458,7 +12455,7 @@
 88
 F8
 ENDCHAR
-STARTCHAR char827
+STARTCHAR uni033B
 ENCODING 827
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12468,7 +12465,7 @@
 A0
 E0
 ENDCHAR
-STARTCHAR char828
+STARTCHAR uni033C
 ENCODING 828
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12478,7 +12475,7 @@
 20
 20
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni033D
 ENCODING 829
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12488,7 +12485,7 @@
 60
 90
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni033E
 ENCODING 830
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12500,7 +12497,7 @@
 20
 40
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni033F
 ENCODING 831
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12510,7 +12507,7 @@
 0000
 FFC0
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0340
 ENCODING 832
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12521,7 +12518,7 @@
 40
 20
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0341
 ENCODING 833
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12532,7 +12529,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0342
 ENCODING 834
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12542,7 +12539,7 @@
 A8
 90
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni0343
 ENCODING 835
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12554,7 +12551,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char901
+STARTCHAR uni0344
 ENCODING 836
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12566,7 +12563,7 @@
 D8
 D8
 ENDCHAR
-STARTCHAR char837
+STARTCHAR uni0345
 ENCODING 837
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12577,7 +12574,7 @@
 50
 20
 ENDCHAR
-STARTCHAR char810
+STARTCHAR uni0346
 ENCODING 838
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12586,7 +12583,7 @@
 F8
 88
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0347
 ENCODING 839
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12596,7 +12593,7 @@
 00
 F8
 ENDCHAR
-STARTCHAR char781
+STARTCHAR uni0348
 ENCODING 840
 SWIDTH 120 0
 DWIDTH 2 0
@@ -12607,7 +12604,7 @@
 A0
 A0
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni0349
 ENCODING 841
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12618,7 +12615,7 @@
 10
 10
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni034A
 ENCODING 842
 SWIDTH 60 0
 DWIDTH 1 0
@@ -12630,7 +12627,7 @@
 A8
 20
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni034B
 ENCODING 843
 SWIDTH 60 0
 DWIDTH 1 0
@@ -12642,7 +12639,7 @@
 88
 20
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni034C
 ENCODING 844
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12655,7 +12652,7 @@
 A8
 90
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni034D
 ENCODING 845
 SWIDTH 480 0
 DWIDTH 8 0
@@ -12665,7 +12662,7 @@
 FF
 42
 ENDCHAR
-STARTCHAR char792
+STARTCHAR uni034E
 ENCODING 846
 SWIDTH 240 0
 DWIDTH 4 0
@@ -12677,7 +12674,7 @@
 40
 40
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0360
 ENCODING 864
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12687,7 +12684,7 @@
 8420
 83C0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0361
 ENCODING 865
 SWIDTH 0 0
 DWIDTH 0 0
@@ -12697,7 +12694,7 @@
 4040
 8020
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0362
 ENCODING 866
 SWIDTH 600 0
 DWIDTH 10 0
@@ -12707,7 +12704,7 @@
 FFC0
 0080
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0374
 ENCODING 884
 SWIDTH 420 0
 DWIDTH 7 0
@@ -12718,7 +12715,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0375
 ENCODING 885
 SWIDTH 420 0
 DWIDTH 7 0
@@ -12729,7 +12726,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C024
+STARTCHAR uni037A
 ENCODING 890
 SWIDTH 420 0
 DWIDTH 7 0
@@ -12740,7 +12737,7 @@
 50
 20
 ENDCHAR
-STARTCHAR C059
+STARTCHAR uni037E
 ENCODING 894
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12757,7 +12754,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char900
+STARTCHAR uni0384
 ENCODING 900
 SWIDTH 300 0
 DWIDTH 5 0
@@ -12767,7 +12764,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char901
+STARTCHAR uni0385
 ENCODING 901
 SWIDTH 540 0
 DWIDTH 9 0
@@ -12778,7 +12775,7 @@
 EC
 CC
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0386
 ENCODING 902
 SWIDTH 660 0
 DWIDTH 11 0
@@ -12797,7 +12794,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR char183
+STARTCHAR uni0387
 ENCODING 903
 SWIDTH 420 0
 DWIDTH 7 0
@@ -12806,7 +12803,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR 0x0388
+STARTCHAR uni0388
 ENCODING 904
 SWIDTH 780 0
 DWIDTH 13 0
@@ -12825,7 +12822,7 @@
 0820
 3FE0
 ENDCHAR
-STARTCHAR 0x0389
+STARTCHAR uni0389
 ENCODING 905
 SWIDTH 840 0
 DWIDTH 14 0
@@ -12844,7 +12841,7 @@
 0820
 3EF8
 ENDCHAR
-STARTCHAR 0x038A
+STARTCHAR uni038A
 ENCODING 906
 SWIDTH 420 0
 DWIDTH 7 0
@@ -12863,7 +12860,7 @@
 08
 3E
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni038C
 ENCODING 908
 SWIDTH 780 0
 DWIDTH 13 0
@@ -12882,7 +12879,7 @@
 1080
 0F00
 ENDCHAR
-STARTCHAR 0x038E
+STARTCHAR uni038E
 ENCODING 910
 SWIDTH 840 0
 DWIDTH 14 0
@@ -12901,7 +12898,7 @@
 0100
 07C0
 ENDCHAR
-STARTCHAR 0x038F
+STARTCHAR uni038F
 ENCODING 911
 SWIDTH 720 0
 DWIDTH 12 0
@@ -12920,7 +12917,7 @@
 28A0
 38E0
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni0390
 ENCODING 912
 SWIDTH 360 0
 DWIDTH 6 0
@@ -12939,7 +12936,7 @@
 28
 10
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0391
 ENCODING 913
 SWIDTH 660 0
 DWIDTH 11 0
@@ -12957,7 +12954,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C066
+STARTCHAR uni0392
 ENCODING 914
 SWIDTH 660 0
 DWIDTH 11 0
@@ -12975,7 +12972,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni0393
 ENCODING 915
 SWIDTH 540 0
 DWIDTH 9 0
@@ -12993,7 +12990,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni0394
 ENCODING 916
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13011,7 +13008,7 @@
 8020
 FFE0
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0395
 ENCODING 917
 SWIDTH 660 0
 DWIDTH 11 0
@@ -13029,7 +13026,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni0396
 ENCODING 918
 SWIDTH 480 0
 DWIDTH 8 0
@@ -13047,7 +13044,7 @@
 46
 FE
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni0397
 ENCODING 919
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13065,7 +13062,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C081
+STARTCHAR uni0398
 ENCODING 920
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13083,7 +13080,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0399
 ENCODING 921
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13101,7 +13098,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni039A
 ENCODING 922
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13119,7 +13116,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni039B
 ENCODING 923
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13137,7 +13134,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C077
+STARTCHAR uni039C
 ENCODING 924
 SWIDTH 900 0
 DWIDTH 15 0
@@ -13155,7 +13152,7 @@
 2310
 FB7C
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni039D
 ENCODING 925
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13173,7 +13170,7 @@
 2180
 F880
 ENDCHAR
-STARTCHAR C004
+STARTCHAR uni039E
 ENCODING 926
 SWIDTH 540 0
 DWIDTH 9 0
@@ -13191,7 +13188,7 @@
 81
 FF
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni039F
 ENCODING 927
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13209,7 +13206,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C080
+STARTCHAR uni03A0
 ENCODING 928
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13227,7 +13224,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni03A1
 ENCODING 929
 SWIDTH 600 0
 DWIDTH 10 0
@@ -13245,7 +13242,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni03A3
 ENCODING 931
 SWIDTH 600 0
 DWIDTH 10 0
@@ -13263,7 +13260,7 @@
 4180
 FF80
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni03A4
 ENCODING 932
 SWIDTH 600 0
 DWIDTH 10 0
@@ -13281,7 +13278,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni03A5
 ENCODING 933
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13299,7 +13296,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C070
+STARTCHAR uni03A6
 ENCODING 934
 SWIDTH 600 0
 DWIDTH 10 0
@@ -13317,7 +13314,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C088
+STARTCHAR uni03A7
 ENCODING 935
 SWIDTH 660 0
 DWIDTH 11 0
@@ -13335,7 +13332,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni03A8
 ENCODING 936
 SWIDTH 660 0
 DWIDTH 11 0
@@ -13353,7 +13350,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR 0x03A9
+STARTCHAR uni03A9
 ENCODING 937
 SWIDTH 600 0
 DWIDTH 10 0
@@ -13371,7 +13368,7 @@
 A280
 E380
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni03AA
 ENCODING 938
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13392,7 +13389,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni03AB
 ENCODING 939
 SWIDTH 720 0
 DWIDTH 12 0
@@ -13413,7 +13410,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni03AC
 ENCODING 940
 SWIDTH 480 0
 DWIDTH 8 0
@@ -13431,7 +13428,7 @@
 98
 66
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni03AD
 ENCODING 941
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13449,7 +13446,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni03AE
 ENCODING 942
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13471,7 +13468,7 @@
 04
 04
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni03AF
 ENCODING 943
 SWIDTH 300 0
 DWIDTH 5 0
@@ -13489,7 +13486,7 @@
 50
 20
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni03B0
 ENCODING 944
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13508,7 +13505,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni03B1
 ENCODING 945
 SWIDTH 480 0
 DWIDTH 8 0
@@ -13522,7 +13519,7 @@
 98
 66
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni03B2
 ENCODING 946
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13545,7 +13542,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char947
+STARTCHAR uni03B3
 ENCODING 947
 SWIDTH 540 0
 DWIDTH 9 0
@@ -13562,7 +13559,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni03B4
 ENCODING 948
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13581,7 +13578,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni03B5
 ENCODING 949
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13595,7 +13592,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni03B6
 ENCODING 950
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13616,7 +13613,7 @@
 04
 08
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni03B7
 ENCODING 951
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13634,7 +13631,7 @@
 04
 04
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni03B8
 ENCODING 952
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13652,7 +13649,7 @@
 50
 20
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni03B9
 ENCODING 953
 SWIDTH 300 0
 DWIDTH 5 0
@@ -13666,7 +13663,7 @@
 50
 20
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni03BA
 ENCODING 954
 SWIDTH 480 0
 DWIDTH 8 0
@@ -13680,7 +13677,7 @@
 48
 E6
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni03BB
 ENCODING 955
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13697,7 +13694,7 @@
 84
 84
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni03BC
 ENCODING 956
 SWIDTH 480 0
 DWIDTH 8 0
@@ -13714,7 +13711,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni03BD
 ENCODING 957
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13728,7 +13725,7 @@
 30
 20
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni03BE
 ENCODING 958
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13749,7 +13746,7 @@
 04
 08
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni03BF
 ENCODING 959
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13763,7 +13760,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C112
+STARTCHAR uni03C0
 ENCODING 960
 SWIDTH 480 0
 DWIDTH 8 0
@@ -13777,7 +13774,7 @@
 88
 86
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni03C1
 ENCODING 961
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13795,7 +13792,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni03C2
 ENCODING 962
 SWIDTH 300 0
 DWIDTH 5 0
@@ -13812,7 +13809,7 @@
 10
 20
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni03C3
 ENCODING 963
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13826,7 +13823,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni03C4
 ENCODING 964
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13840,7 +13837,7 @@
 14
 08
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni03C5
 ENCODING 965
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13854,27 +13851,25 @@
 48
 30
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni03D5
 ENCODING 966
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 13 1 -3
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 -4
 BITMAP
-20
-20
-20
-70
-A8
-A8
-A8
-A8
-A8
-70
-20
-20
-20
+4C
+92
+92
+92
+92
+54
+38
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR C120
+STARTCHAR uni03C7
 ENCODING 967
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13891,7 +13886,7 @@
 54
 8C
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni03C8
 ENCODING 968
 SWIDTH 600 0
 DWIDTH 10 0
@@ -13912,7 +13907,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni03C9
 ENCODING 969
 SWIDTH 600 0
 DWIDTH 10 0
@@ -13926,7 +13921,7 @@
 8880
 7700
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni03CA
 ENCODING 970
 SWIDTH 300 0
 DWIDTH 5 0
@@ -13943,7 +13938,7 @@
 28
 10
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni03CB
 ENCODING 971
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13960,7 +13955,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni03CC
 ENCODING 972
 SWIDTH 360 0
 DWIDTH 6 0
@@ -13978,7 +13973,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni03CD
 ENCODING 973
 SWIDTH 420 0
 DWIDTH 7 0
@@ -13996,7 +13991,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni03CE
 ENCODING 974
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14014,7 +14009,7 @@
 8880
 7700
 ENDCHAR
-STARTCHAR C025
+STARTCHAR uni03D0
 ENCODING 976
 SWIDTH 420 0
 DWIDTH 7 0
@@ -14033,7 +14028,7 @@
 84
 78
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni03D1
 ENCODING 977
 SWIDTH 480 0
 DWIDTH 8 0
@@ -14050,7 +14045,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni03D2
 ENCODING 978
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14068,7 +14063,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR 0x03D3
+STARTCHAR uni03D3
 ENCODING 979
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14087,7 +14082,7 @@
 0200
 0F80
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni03D4
 ENCODING 980
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14108,25 +14103,27 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni03C6
 ENCODING 981
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 -4
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 1 -3
 BITMAP
-4C
-92
-92
-92
-92
-54
-38
-10
-10
-10
-10
+20
+20
+20
+70
+A8
+A8
+A8
+A8
+A8
+70
+20
+20
+20
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni03D6
 ENCODING 982
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14140,7 +14137,7 @@
 8880
 7700
 ENDCHAR
-STARTCHAR 0x03C7
+STARTCHAR uni03D7
 ENCODING 983
 SWIDTH 540 0
 DWIDTH 9 0
@@ -14156,7 +14153,7 @@
 0A
 0C
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni03DA
 ENCODING 986
 SWIDTH 480 0
 DWIDTH 8 0
@@ -14176,7 +14173,7 @@
 02
 1C
 ENDCHAR
-STARTCHAR 0x03C2
+STARTCHAR uni03DB
 ENCODING 987
 SWIDTH 300 0
 DWIDTH 5 0
@@ -14193,7 +14190,7 @@
 10
 20
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni03DC
 ENCODING 988
 SWIDTH 540 0
 DWIDTH 9 0
@@ -14211,7 +14208,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR 0x0066
+STARTCHAR uni03DD
 ENCODING 989
 SWIDTH 360 0
 DWIDTH 6 0
@@ -14265,7 +14262,7 @@
 10
 20
 ENDCHAR
-STARTCHAR 0x03E0
+STARTCHAR uni03E0
 ENCODING 992
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14284,7 +14281,7 @@
 0900
 0200
 ENDCHAR
-STARTCHAR 0x03E0
+STARTCHAR uni03E1
 ENCODING 993
 SWIDTH 420 0
 DWIDTH 7 0
@@ -14302,7 +14299,7 @@
 04
 04
 ENDCHAR
-STARTCHAR C087
+STARTCHAR uni03E2
 ENCODING 994
 SWIDTH 840 0
 DWIDTH 14 0
@@ -14323,7 +14320,7 @@
 03E0
 0600
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni03E3
 ENCODING 995
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14340,7 +14337,7 @@
 0F00
 1800
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni03E4
 ENCODING 996
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14358,7 +14355,7 @@
 0200
 0F80
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni03E5
 ENCODING 997
 SWIDTH 360 0
 DWIDTH 6 0
@@ -14376,7 +14373,7 @@
 08
 08
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni03E6
 ENCODING 998
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14397,7 +14394,7 @@
 FF00
 8000
 ENDCHAR
-STARTCHAR char999
+STARTCHAR uni03E7
 ENCODING 999
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14412,7 +14409,7 @@
 9180
 4F00
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni03E8
 ENCODING 1000
 SWIDTH 480 0
 DWIDTH 8 0
@@ -14432,7 +14429,7 @@
 70
 1C
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni03E9
 ENCODING 1001
 SWIDTH 360 0
 DWIDTH 6 0
@@ -14448,7 +14445,7 @@
 60
 38
 ENDCHAR
-STARTCHAR C088
+STARTCHAR uni03EA
 ENCODING 1002
 SWIDTH 720 0
 DWIDTH 12 0
@@ -14466,7 +14463,7 @@
 2080
 FFE0
 ENDCHAR
-STARTCHAR C120
+STARTCHAR uni03EB
 ENCODING 1003
 SWIDTH 540 0
 DWIDTH 9 0
@@ -14480,7 +14477,7 @@
 24
 FF
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni03EC
 ENCODING 1004
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14499,7 +14496,7 @@
 4080
 3F00
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni03ED
 ENCODING 1005
 SWIDTH 420 0
 DWIDTH 7 0
@@ -14514,7 +14511,7 @@
 84
 78
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni03EE
 ENCODING 1006
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14532,7 +14529,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni03EF
 ENCODING 1007
 SWIDTH 480 0
 DWIDTH 8 0
@@ -14549,7 +14546,7 @@
 10
 38
 ENDCHAR
-STARTCHAR 0x03C7
+STARTCHAR uni03F0
 ENCODING 1008
 SWIDTH 540 0
 DWIDTH 9 0
@@ -14563,7 +14560,7 @@
 45
 42
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni03F1
 ENCODING 1009
 SWIDTH 360 0
 DWIDTH 6 0
@@ -14581,7 +14578,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni03F2
 ENCODING 1010
 SWIDTH 420 0
 DWIDTH 7 0
@@ -14595,7 +14592,7 @@
 84
 78
 ENDCHAR
-STARTCHAR 0x03F3
+STARTCHAR uni03F3
 ENCODING 1011
 SWIDTH 300 0
 DWIDTH 5 0
@@ -14616,7 +14613,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0400
 ENCODING 1024
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14638,7 +14635,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C062
+STARTCHAR uni0401
 ENCODING 1025
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14659,7 +14656,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0402
 ENCODING 1026
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14680,7 +14677,7 @@
 0320
 01C0
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni0403
 ENCODING 1027
 SWIDTH 540 0
 DWIDTH 9 0
@@ -14702,7 +14699,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C124
+STARTCHAR uni0404
 ENCODING 1028
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14720,7 +14717,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni0405
 ENCODING 1029
 SWIDTH 420 0
 DWIDTH 7 0
@@ -14738,7 +14735,7 @@
 84
 F8
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0406
 ENCODING 1030
 SWIDTH 300 0
 DWIDTH 5 0
@@ -14756,7 +14753,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0407
 ENCODING 1031
 SWIDTH 300 0
 DWIDTH 5 0
@@ -14777,7 +14774,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR C074
+STARTCHAR uni0408
 ENCODING 1032
 SWIDTH 360 0
 DWIDTH 6 0
@@ -14795,7 +14792,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni0409
 ENCODING 1033
 SWIDTH 900 0
 DWIDTH 15 0
@@ -14813,7 +14810,7 @@
 A108
 C7F0
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni040A
 ENCODING 1034
 SWIDTH 960 0
 DWIDTH 16 0
@@ -14831,7 +14828,7 @@
 2084
 FBF8
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni040B
 ENCODING 1035
 SWIDTH 780 0
 DWIDTH 13 0
@@ -14849,7 +14846,7 @@
 0820
 3EF8
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni040C
 ENCODING 1036
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14871,7 +14868,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni040D
 ENCODING 1037
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14893,7 +14890,7 @@
 3080
 FBE0
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni040E
 ENCODING 1038
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14914,7 +14911,7 @@
 4400
 3800
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni040F
 ENCODING 1039
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14934,7 +14931,7 @@
 0400
 0400
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0410
 ENCODING 1040
 SWIDTH 660 0
 DWIDTH 11 0
@@ -14952,7 +14949,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni0411
 ENCODING 1041
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14970,7 +14967,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni0412
 ENCODING 1042
 SWIDTH 600 0
 DWIDTH 10 0
@@ -14988,7 +14985,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni0413
 ENCODING 1043
 SWIDTH 540 0
 DWIDTH 9 0
@@ -15006,7 +15003,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni0414
 ENCODING 1044
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15026,7 +15023,7 @@
 8060
 8020
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0415
 ENCODING 1045
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15044,7 +15041,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR C118
+STARTCHAR uni0416
 ENCODING 1046
 SWIDTH 900 0
 DWIDTH 15 0
@@ -15062,7 +15059,7 @@
 2108
 F39E
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni0417
 ENCODING 1047
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15080,7 +15077,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni0418
 ENCODING 1048
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15098,7 +15095,7 @@
 3080
 FBE0
 ENDCHAR
-STARTCHAR C106
+STARTCHAR uni0419
 ENCODING 1049
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15120,7 +15117,7 @@
 3080
 FBE0
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni041A
 ENCODING 1050
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15138,7 +15135,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni041B
 ENCODING 1051
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15156,7 +15153,7 @@
 A100
 C7C0
 ENDCHAR
-STARTCHAR C109
+STARTCHAR uni041C
 ENCODING 1052
 SWIDTH 840 0
 DWIDTH 14 0
@@ -15174,7 +15171,7 @@
 2310
 FB7C
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni041D
 ENCODING 1053
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15192,7 +15189,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni041E
 ENCODING 1054
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15210,7 +15207,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C112
+STARTCHAR uni041F
 ENCODING 1055
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15228,7 +15225,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0420
 ENCODING 1056
 SWIDTH 540 0
 DWIDTH 9 0
@@ -15246,7 +15243,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni0421
 ENCODING 1057
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15264,7 +15261,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0422
 ENCODING 1058
 SWIDTH 540 0
 DWIDTH 9 0
@@ -15282,7 +15279,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0423
 ENCODING 1059
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15300,7 +15297,7 @@
 4400
 3800
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni0424
 ENCODING 1060
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15318,7 +15315,7 @@
 0400
 0E00
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0425
 ENCODING 1061
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15336,7 +15333,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni0426
 ENCODING 1062
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15356,7 +15353,7 @@
 0060
 0020
 ENDCHAR
-STARTCHAR C126
+STARTCHAR uni0427
 ENCODING 1063
 SWIDTH 540 0
 DWIDTH 9 0
@@ -15374,7 +15371,7 @@
 0100
 0380
 ENDCHAR
-STARTCHAR C123
+STARTCHAR uni0428
 ENCODING 1064
 SWIDTH 900 0
 DWIDTH 15 0
@@ -15392,7 +15389,7 @@
 2108
 FFFE
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni0429
 ENCODING 1065
 SWIDTH 900 0
 DWIDTH 15 0
@@ -15412,7 +15409,7 @@
 0006
 0002
 ENDCHAR
-STARTCHAR C127
+STARTCHAR uni042A
 ENCODING 1066
 SWIDTH 840 0
 DWIDTH 14 0
@@ -15430,7 +15427,7 @@
 0410
 1FE0
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni042B
 ENCODING 1067
 SWIDTH 900 0
 DWIDTH 15 0
@@ -15448,7 +15445,7 @@
 20C8
 FF3E
 ENDCHAR
-STARTCHAR C120
+STARTCHAR uni042C
 ENCODING 1068
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15466,7 +15463,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C124
+STARTCHAR uni042D
 ENCODING 1069
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15484,7 +15481,7 @@
 4200
 3C00
 ENDCHAR
-STARTCHAR C096
+STARTCHAR uni042E
 ENCODING 1070
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -15502,7 +15499,7 @@
 208200
 F87C00
 ENDCHAR
-STARTCHAR C113
+STARTCHAR uni042F
 ENCODING 1071
 SWIDTH 660 0
 DWIDTH 11 0
@@ -15520,7 +15517,7 @@
 2080
 E3E0
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni0430
 ENCODING 1072
 SWIDTH 420 0
 DWIDTH 7 0
@@ -15534,7 +15531,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR C066
+STARTCHAR uni0431
 ENCODING 1073
 SWIDTH 360 0
 DWIDTH 6 0
@@ -15552,7 +15549,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C087
+STARTCHAR uni0432
 ENCODING 1074
 SWIDTH 420 0
 DWIDTH 7 0
@@ -15566,7 +15563,7 @@
 44
 F8
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni0433
 ENCODING 1075
 SWIDTH 420 0
 DWIDTH 7 0
@@ -15580,7 +15577,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni0434
 ENCODING 1076
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15596,7 +15593,7 @@
 82
 82
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0435
 ENCODING 1077
 SWIDTH 360 0
 DWIDTH 6 0
@@ -15610,7 +15607,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C086
+STARTCHAR uni0436
 ENCODING 1078
 SWIDTH 720 0
 DWIDTH 12 0
@@ -15624,7 +15621,7 @@
 2480
 EEE0
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni0437
 ENCODING 1079
 SWIDTH 360 0
 DWIDTH 6 0
@@ -15638,7 +15635,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni0438
 ENCODING 1080
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15652,7 +15649,7 @@
 64
 EE
 ENDCHAR
-STARTCHAR C074
+STARTCHAR uni0439
 ENCODING 1081
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15670,7 +15667,7 @@
 64
 EE
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni043A
 ENCODING 1082
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15684,7 +15681,7 @@
 48
 E6
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni043B
 ENCODING 1083
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15698,7 +15695,7 @@
 C4
 CE
 ENDCHAR
-STARTCHAR C077
+STARTCHAR uni043C
 ENCODING 1084
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15712,7 +15709,7 @@
 4900
 EB80
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni043D
 ENCODING 1085
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15726,7 +15723,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni043E
 ENCODING 1086
 SWIDTH 360 0
 DWIDTH 6 0
@@ -15740,7 +15737,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C080
+STARTCHAR uni043F
 ENCODING 1087
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15754,7 +15751,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0440
 ENCODING 1088
 SWIDTH 420 0
 DWIDTH 7 0
@@ -15771,7 +15768,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni0441
 ENCODING 1089
 SWIDTH 360 0
 DWIDTH 6 0
@@ -15785,7 +15782,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni0442
 ENCODING 1090
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15799,7 +15796,7 @@
 10
 7C
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0443
 ENCODING 1091
 SWIDTH 540 0
 DWIDTH 9 0
@@ -15816,7 +15813,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR C070
+STARTCHAR uni0444
 ENCODING 1092
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15836,7 +15833,7 @@
 0800
 1C00
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni0445
 ENCODING 1093
 SWIDTH 540 0
 DWIDTH 9 0
@@ -15850,7 +15847,7 @@
 24
 E7
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni0446
 ENCODING 1094
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15866,7 +15863,7 @@
 02
 02
 ENDCHAR
-STARTCHAR C094
+STARTCHAR uni0447
 ENCODING 1095
 SWIDTH 480 0
 DWIDTH 8 0
@@ -15880,7 +15877,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR C091
+STARTCHAR uni0448
 ENCODING 1096
 SWIDTH 720 0
 DWIDTH 12 0
@@ -15894,7 +15891,7 @@
 4440
 FFE0
 ENDCHAR
-STARTCHAR C093
+STARTCHAR uni0449
 ENCODING 1097
 SWIDTH 720 0
 DWIDTH 12 0
@@ -15910,7 +15907,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR C095
+STARTCHAR uni044A
 ENCODING 1098
 SWIDTH 540 0
 DWIDTH 9 0
@@ -15924,7 +15921,7 @@
 11
 3E
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni044B
 ENCODING 1099
 SWIDTH 600 0
 DWIDTH 10 0
@@ -15938,7 +15935,7 @@
 4500
 FB80
 ENDCHAR
-STARTCHAR C088
+STARTCHAR uni044C
 ENCODING 1100
 SWIDTH 420 0
 DWIDTH 7 0
@@ -15952,7 +15949,7 @@
 44
 F8
 ENDCHAR
-STARTCHAR C092
+STARTCHAR uni044D
 ENCODING 1101
 SWIDTH 420 0
 DWIDTH 7 0
@@ -15966,7 +15963,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C064
+STARTCHAR uni044E
 ENCODING 1102
 SWIDTH 720 0
 DWIDTH 12 0
@@ -15980,7 +15977,7 @@
 4440
 E380
 ENDCHAR
-STARTCHAR C081
+STARTCHAR uni044F
 ENCODING 1103
 SWIDTH 420 0
 DWIDTH 7 0
@@ -15994,7 +15991,7 @@
 28
 CC
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0450
 ENCODING 1104
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16012,7 +16009,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C060
+STARTCHAR uni0451
 ENCODING 1105
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16029,7 +16026,7 @@
 88
 70
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0452
 ENCODING 1106
 SWIDTH 420 0
 DWIDTH 7 0
@@ -16050,7 +16047,7 @@
 34
 18
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni0453
 ENCODING 1107
 SWIDTH 420 0
 DWIDTH 7 0
@@ -16068,7 +16065,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR C092
+STARTCHAR uni0454
 ENCODING 1108
 SWIDTH 420 0
 DWIDTH 7 0
@@ -16082,7 +16079,7 @@
 44
 38
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni0455
 ENCODING 1109
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16096,7 +16093,7 @@
 88
 F0
 ENDCHAR
-STARTCHAR 0x0456
+STARTCHAR uni0456
 ENCODING 1110
 SWIDTH 240 0
 DWIDTH 4 0
@@ -16114,7 +16111,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni0457
 ENCODING 1111
 SWIDTH 240 0
 DWIDTH 4 0
@@ -16131,7 +16128,7 @@
 20
 70
 ENDCHAR
-STARTCHAR 0x0458
+STARTCHAR uni0458
 ENCODING 1112
 SWIDTH 300 0
 DWIDTH 5 0
@@ -16152,7 +16149,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni0459
 ENCODING 1113
 SWIDTH 660 0
 DWIDTH 11 0
@@ -16166,7 +16163,7 @@
 C440
 CF80
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni045A
 ENCODING 1114
 SWIDTH 660 0
 DWIDTH 11 0
@@ -16180,7 +16177,7 @@
 4440
 EF80
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni045B
 ENCODING 1115
 SWIDTH 480 0
 DWIDTH 8 0
@@ -16198,7 +16195,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni045C
 ENCODING 1116
 SWIDTH 480 0
 DWIDTH 8 0
@@ -16216,7 +16213,7 @@
 48
 E6
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni045D
 ENCODING 1117
 SWIDTH 480 0
 DWIDTH 8 0
@@ -16234,7 +16231,7 @@
 64
 EE
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni045E
 ENCODING 1118
 SWIDTH 540 0
 DWIDTH 9 0
@@ -16254,7 +16251,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR C080
+STARTCHAR uni045F
 ENCODING 1119
 SWIDTH 480 0
 DWIDTH 8 0
@@ -16270,7 +16267,7 @@
 10
 10
 ENDCHAR
-STARTCHAR 0x0460
+STARTCHAR uni0460
 ENCODING 1120
 SWIDTH 780 0
 DWIDTH 13 0
@@ -16288,7 +16285,7 @@
 4510
 38E0
 ENDCHAR
-STARTCHAR 0x0461
+STARTCHAR uni0461
 ENCODING 1121
 SWIDTH 600 0
 DWIDTH 10 0
@@ -16302,7 +16299,7 @@
 4900
 3600
 ENDCHAR
-STARTCHAR 0x0462
+STARTCHAR uni0462
 ENCODING 1122
 SWIDTH 720 0
 DWIDTH 12 0
@@ -16320,7 +16317,7 @@
 1040
 7F80
 ENDCHAR
-STARTCHAR 0x0463
+STARTCHAR uni0463
 ENCODING 1123
 SWIDTH 540 0
 DWIDTH 9 0
@@ -16338,7 +16335,7 @@
 11
 3E
 ENDCHAR
-STARTCHAR 0x0464
+STARTCHAR uni0464
 ENCODING 1124
 SWIDTH 960 0
 DWIDTH 16 0
@@ -16356,7 +16353,7 @@
 2084
 F878
 ENDCHAR
-STARTCHAR 0x0465
+STARTCHAR uni0465
 ENCODING 1125
 SWIDTH 660 0
 DWIDTH 11 0
@@ -16370,7 +16367,7 @@
 4440
 E380
 ENDCHAR
-STARTCHAR 0x0466
+STARTCHAR uni0466
 ENCODING 1126
 SWIDTH 900 0
 DWIDTH 15 0
@@ -16388,7 +16385,7 @@
 2108
 F39E
 ENDCHAR
-STARTCHAR 0x0467
+STARTCHAR uni0467
 ENCODING 1127
 SWIDTH 720 0
 DWIDTH 12 0
@@ -16402,7 +16399,7 @@
 4440
 EEE0
 ENDCHAR
-STARTCHAR 0x0468
+STARTCHAR uni0468
 ENCODING 1128
 SWIDTH 1200 0
 DWIDTH 20 0
@@ -16420,7 +16417,7 @@
 210840
 FB9CF0
 ENDCHAR
-STARTCHAR 0x0469
+STARTCHAR uni0469
 ENCODING 1129
 SWIDTH 900 0
 DWIDTH 15 0
@@ -16434,7 +16431,7 @@
 4888
 FDDC
 ENDCHAR
-STARTCHAR 0x046A
+STARTCHAR uni046A
 ENCODING 1130
 SWIDTH 900 0
 DWIDTH 15 0
@@ -16452,7 +16449,7 @@
 2108
 F39E
 ENDCHAR
-STARTCHAR 0x046B
+STARTCHAR uni046B
 ENCODING 1131
 SWIDTH 720 0
 DWIDTH 12 0
@@ -16466,7 +16463,7 @@
 4440
 EEE0
 ENDCHAR
-STARTCHAR 0x046C
+STARTCHAR uni046C
 ENCODING 1132
 SWIDTH 1200 0
 DWIDTH 20 0
@@ -16484,7 +16481,7 @@
 210840
 FB9CF0
 ENDCHAR
-STARTCHAR 0x046D
+STARTCHAR uni046D
 ENCODING 1133
 SWIDTH 900 0
 DWIDTH 15 0
@@ -16498,7 +16495,7 @@
 4888
 EDDC
 ENDCHAR
-STARTCHAR 0x046E
+STARTCHAR uni046E
 ENCODING 1134
 SWIDTH 540 0
 DWIDTH 9 0
@@ -16523,7 +16520,7 @@
 7F
 01
 ENDCHAR
-STARTCHAR 0x046F
+STARTCHAR uni046F
 ENCODING 1135
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16544,7 +16541,7 @@
 78
 08
 ENDCHAR
-STARTCHAR 0x0470
+STARTCHAR uni0470
 ENCODING 1136
 SWIDTH 600 0
 DWIDTH 10 0
@@ -16562,7 +16559,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR 0x0471
+STARTCHAR uni0471
 ENCODING 1137
 SWIDTH 600 0
 DWIDTH 10 0
@@ -16583,7 +16580,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR 0x0472
+STARTCHAR uni0472
 ENCODING 1138
 SWIDTH 600 0
 DWIDTH 10 0
@@ -16601,7 +16598,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR 0x0473
+STARTCHAR uni0473
 ENCODING 1139
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16615,7 +16612,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x0474
+STARTCHAR uni0474
 ENCODING 1140
 SWIDTH 660 0
 DWIDTH 11 0
@@ -16633,7 +16630,7 @@
 0400
 0400
 ENDCHAR
-STARTCHAR 0x0475
+STARTCHAR uni0475
 ENCODING 1141
 SWIDTH 540 0
 DWIDTH 9 0
@@ -16647,7 +16644,7 @@
 18
 18
 ENDCHAR
-STARTCHAR 0x0476
+STARTCHAR uni0476
 ENCODING 1142
 SWIDTH 660 0
 DWIDTH 11 0
@@ -16670,7 +16667,7 @@
 0400
 0400
 ENDCHAR
-STARTCHAR 0x0477
+STARTCHAR uni0477
 ENCODING 1143
 SWIDTH 540 0
 DWIDTH 9 0
@@ -16689,7 +16686,7 @@
 18
 18
 ENDCHAR
-STARTCHAR 0x0478
+STARTCHAR uni0478
 ENCODING 1144
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -16710,7 +16707,7 @@
 000800
 000800
 ENDCHAR
-STARTCHAR 0x0479
+STARTCHAR uni0479
 ENCODING 1145
 SWIDTH 840 0
 DWIDTH 14 0
@@ -16727,7 +16724,7 @@
 0080
 0080
 ENDCHAR
-STARTCHAR 0x047A
+STARTCHAR uni047A
 ENCODING 1146
 SWIDTH 720 0
 DWIDTH 12 0
@@ -16747,7 +16744,7 @@
 1F80
 0600
 ENDCHAR
-STARTCHAR 0x047B
+STARTCHAR uni047B
 ENCODING 1147
 SWIDTH 540 0
 DWIDTH 9 0
@@ -16763,7 +16760,7 @@
 3C
 18
 ENDCHAR
-STARTCHAR 0x047C
+STARTCHAR uni047C
 ENCODING 1148
 SWIDTH 780 0
 DWIDTH 13 0
@@ -16786,7 +16783,7 @@
 4510
 38E0
 ENDCHAR
-STARTCHAR 0x047D
+STARTCHAR uni047D
 ENCODING 1149
 SWIDTH 600 0
 DWIDTH 10 0
@@ -16805,7 +16802,7 @@
 4900
 3600
 ENDCHAR
-STARTCHAR 0x047E
+STARTCHAR uni047E
 ENCODING 1150
 SWIDTH 780 0
 DWIDTH 13 0
@@ -16826,7 +16823,7 @@
 4510
 38E0
 ENDCHAR
-STARTCHAR 0x047F
+STARTCHAR uni047F
 ENCODING 1151
 SWIDTH 600 0
 DWIDTH 10 0
@@ -16843,7 +16840,7 @@
 4900
 3600
 ENDCHAR
-STARTCHAR 0x0480
+STARTCHAR uni0480
 ENCODING 1152
 SWIDTH 540 0
 DWIDTH 9 0
@@ -16864,7 +16861,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR 0x0481
+STARTCHAR uni0481
 ENCODING 1153
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16881,7 +16878,7 @@
 10
 38
 ENDCHAR
-STARTCHAR 0x0482
+STARTCHAR uni0482
 ENCODING 1154
 SWIDTH 600 0
 DWIDTH 10 0
@@ -16897,7 +16894,7 @@
 4000
 2000
 ENDCHAR
-STARTCHAR 0x0483
+STARTCHAR uni0483
 ENCODING 1155
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -16908,7 +16905,7 @@
 D8
 C0
 ENDCHAR
-STARTCHAR 0x0484
+STARTCHAR uni0484
 ENCODING 1156
 SWIDTH 420 0
 DWIDTH 7 0
@@ -16918,7 +16915,7 @@
 24
 C0
 ENDCHAR
-STARTCHAR 0x0485
+STARTCHAR uni0485
 ENCODING 1157
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16928,7 +16925,7 @@
 F8
 80
 ENDCHAR
-STARTCHAR 0x0486
+STARTCHAR uni0486
 ENCODING 1158
 SWIDTH 360 0
 DWIDTH 6 0
@@ -16938,7 +16935,7 @@
 F8
 08
 ENDCHAR
-STARTCHAR char1160
+STARTCHAR uni0488
 ENCODING 1160
 SWIDTH 900 0
 DWIDTH 15 0
@@ -16960,7 +16957,7 @@
 0100
 0280
 ENDCHAR
-STARTCHAR char1161
+STARTCHAR uni0489
 ENCODING 1161
 SWIDTH 960 0
 DWIDTH 16 0
@@ -16985,7 +16982,7 @@
 0080
 0100
 ENDCHAR
-STARTCHAR C120
+STARTCHAR uni048C
 ENCODING 1164
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17003,7 +17000,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR C088
+STARTCHAR uni048D
 ENCODING 1165
 SWIDTH 420 0
 DWIDTH 7 0
@@ -17017,7 +17014,7 @@
 44
 F8
 ENDCHAR
-STARTCHAR 0x048E
+STARTCHAR uni048E
 ENCODING 1166
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17035,7 +17032,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR 0x048F
+STARTCHAR uni048F
 ENCODING 1167
 SWIDTH 420 0
 DWIDTH 7 0
@@ -17052,7 +17049,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR 0x0490
+STARTCHAR uni0490
 ENCODING 1168
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17073,7 +17070,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR 0x0491
+STARTCHAR uni0491
 ENCODING 1169
 SWIDTH 420 0
 DWIDTH 7 0
@@ -17089,7 +17086,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR 0x0492
+STARTCHAR uni0492
 ENCODING 1170
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17107,7 +17104,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR 0x0493
+STARTCHAR uni0493
 ENCODING 1171
 SWIDTH 420 0
 DWIDTH 7 0
@@ -17121,7 +17118,7 @@
 40
 F0
 ENDCHAR
-STARTCHAR 0x0494
+STARTCHAR uni0494
 ENCODING 1172
 SWIDTH 600 0
 DWIDTH 10 0
@@ -17142,7 +17139,7 @@
 0C80
 0700
 ENDCHAR
-STARTCHAR 0x0495
+STARTCHAR uni0495
 ENCODING 1173
 SWIDTH 420 0
 DWIDTH 7 0
@@ -17159,7 +17156,7 @@
 34
 18
 ENDCHAR
-STARTCHAR 0x0496
+STARTCHAR uni0496
 ENCODING 1174
 SWIDTH 900 0
 DWIDTH 15 0
@@ -17180,7 +17177,7 @@
 0002
 0002
 ENDCHAR
-STARTCHAR 0x0497
+STARTCHAR uni0497
 ENCODING 1175
 SWIDTH 720 0
 DWIDTH 12 0
@@ -17196,7 +17193,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0x0498
+STARTCHAR uni0498
 ENCODING 1176
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17217,7 +17214,7 @@
 08
 38
 ENDCHAR
-STARTCHAR 0x0499
+STARTCHAR uni0499
 ENCODING 1177
 SWIDTH 360 0
 DWIDTH 6 0
@@ -17234,7 +17231,7 @@
 10
 70
 ENDCHAR
-STARTCHAR 0x049A
+STARTCHAR uni049A
 ENCODING 1178
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17255,7 +17252,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0x049B
+STARTCHAR uni049B
 ENCODING 1179
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17271,7 +17268,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0x049C
+STARTCHAR uni049C
 ENCODING 1180
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17289,7 +17286,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR 0x049D
+STARTCHAR uni049D
 ENCODING 1181
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17303,7 +17300,7 @@
 54
 E6
 ENDCHAR
-STARTCHAR 0x049E
+STARTCHAR uni049E
 ENCODING 1182
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17321,7 +17318,7 @@
 2080
 F9E0
 ENDCHAR
-STARTCHAR 0x049F
+STARTCHAR uni049F
 ENCODING 1183
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17335,7 +17332,7 @@
 48
 E6
 ENDCHAR
-STARTCHAR 0x04A0
+STARTCHAR uni04A0
 ENCODING 1184
 SWIDTH 840 0
 DWIDTH 14 0
@@ -17353,7 +17350,7 @@
 0410
 1F3C
 ENDCHAR
-STARTCHAR 0x04A1
+STARTCHAR uni04A1
 ENCODING 1185
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17367,7 +17364,7 @@
 0900
 1CC0
 ENDCHAR
-STARTCHAR 0x04A2
+STARTCHAR uni04A2
 ENCODING 1186
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17388,7 +17385,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0x04A3
+STARTCHAR uni04A3
 ENCODING 1187
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17404,7 +17401,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0x04A4
+STARTCHAR uni04A4
 ENCODING 1188
 SWIDTH 840 0
 DWIDTH 14 0
@@ -17422,7 +17419,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR 0x04A5
+STARTCHAR uni04A5
 ENCODING 1189
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17436,7 +17433,7 @@
 4400
 EE00
 ENDCHAR
-STARTCHAR 0x04A6
+STARTCHAR uni04A6
 ENCODING 1190
 SWIDTH 960 0
 DWIDTH 16 0
@@ -17457,7 +17454,7 @@
 0032
 001C
 ENDCHAR
-STARTCHAR 0x04A7
+STARTCHAR uni04A7
 ENCODING 1191
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17474,7 +17471,7 @@
 0340
 0180
 ENDCHAR
-STARTCHAR 0x04A8
+STARTCHAR uni04A8
 ENCODING 1192
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17492,7 +17489,7 @@
 2120
 1EC0
 ENDCHAR
-STARTCHAR 0x04A9
+STARTCHAR uni04A9
 ENCODING 1193
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17506,7 +17503,7 @@
 4A
 3C
 ENDCHAR
-STARTCHAR 0x04AA
+STARTCHAR uni04AA
 ENCODING 1194
 SWIDTH 600 0
 DWIDTH 10 0
@@ -17527,7 +17524,7 @@
 1200
 0C00
 ENDCHAR
-STARTCHAR 0x04AB
+STARTCHAR uni04AB
 ENCODING 1195
 SWIDTH 360 0
 DWIDTH 6 0
@@ -17544,7 +17541,7 @@
 48
 30
 ENDCHAR
-STARTCHAR 0x04AC
+STARTCHAR uni04AC
 ENCODING 1196
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17565,7 +17562,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 0x04AD
+STARTCHAR uni04AD
 ENCODING 1197
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17581,7 +17578,7 @@
 04
 04
 ENDCHAR
-STARTCHAR 0x04AE
+STARTCHAR uni04AE
 ENCODING 1198
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17602,7 +17599,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR 0x04AF
+STARTCHAR uni04AF
 ENCODING 1199
 SWIDTH 600 0
 DWIDTH 10 0
@@ -17619,7 +17616,7 @@
 0800
 1C00
 ENDCHAR
-STARTCHAR 0x04B0
+STARTCHAR uni04B0
 ENCODING 1200
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17640,7 +17637,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR 0x04B1
+STARTCHAR uni04B1
 ENCODING 1201
 SWIDTH 600 0
 DWIDTH 10 0
@@ -17657,7 +17654,7 @@
 0800
 1C00
 ENDCHAR
-STARTCHAR 0x04B2
+STARTCHAR uni04B2
 ENCODING 1202
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17678,7 +17675,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0x04B3
+STARTCHAR uni04B3
 ENCODING 1203
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17694,7 +17691,7 @@
 01
 01
 ENDCHAR
-STARTCHAR 0x04B4
+STARTCHAR uni04B4
 ENCODING 1204
 SWIDTH 900 0
 DWIDTH 15 0
@@ -17714,7 +17711,7 @@
 0006
 0002
 ENDCHAR
-STARTCHAR 0x04B5
+STARTCHAR uni04B5
 ENCODING 1205
 SWIDTH 720 0
 DWIDTH 12 0
@@ -17730,7 +17727,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0x04B6
+STARTCHAR uni04B6
 ENCODING 1206
 SWIDTH 600 0
 DWIDTH 10 0
@@ -17751,7 +17748,7 @@
 0040
 0040
 ENDCHAR
-STARTCHAR 0x04B7
+STARTCHAR uni04B7
 ENCODING 1207
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17767,7 +17764,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0x04B8
+STARTCHAR uni04B8
 ENCODING 1208
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17785,7 +17782,7 @@
 0100
 0380
 ENDCHAR
-STARTCHAR 0x04B9
+STARTCHAR uni04B9
 ENCODING 1209
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17799,7 +17796,7 @@
 14
 0E
 ENDCHAR
-STARTCHAR 0x04BA
+STARTCHAR uni04BA
 ENCODING 1210
 SWIDTH 600 0
 DWIDTH 10 0
@@ -17817,7 +17814,7 @@
 4100
 E380
 ENDCHAR
-STARTCHAR 0x04BB
+STARTCHAR uni04BB
 ENCODING 1211
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17831,7 +17828,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR 0x04BC
+STARTCHAR uni04BC
 ENCODING 1212
 SWIDTH 780 0
 DWIDTH 13 0
@@ -17849,7 +17846,7 @@
 0C10
 03E0
 ENDCHAR
-STARTCHAR 0x04BD
+STARTCHAR uni04BD
 ENCODING 1213
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17863,7 +17860,7 @@
 11
 0E
 ENDCHAR
-STARTCHAR 0x04BE
+STARTCHAR uni04BE
 ENCODING 1214
 SWIDTH 780 0
 DWIDTH 13 0
@@ -17884,7 +17881,7 @@
 0120
 00C0
 ENDCHAR
-STARTCHAR 0x04BF
+STARTCHAR uni04BF
 ENCODING 1215
 SWIDTH 540 0
 DWIDTH 9 0
@@ -17901,7 +17898,7 @@
 12
 0C
 ENDCHAR
-STARTCHAR 0x04C0
+STARTCHAR uni04C0
 ENCODING 1216
 SWIDTH 300 0
 DWIDTH 5 0
@@ -17919,7 +17916,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR 0x04C1
+STARTCHAR uni04C1
 ENCODING 1217
 SWIDTH 900 0
 DWIDTH 15 0
@@ -17940,7 +17937,7 @@
 2108
 F39E
 ENDCHAR
-STARTCHAR 0x04C2
+STARTCHAR uni04C2
 ENCODING 1218
 SWIDTH 720 0
 DWIDTH 12 0
@@ -17957,7 +17954,7 @@
 2480
 EEE0
 ENDCHAR
-STARTCHAR 0x04C3
+STARTCHAR uni04C3
 ENCODING 1219
 SWIDTH 660 0
 DWIDTH 11 0
@@ -17978,7 +17975,7 @@
 0C80
 0700
 ENDCHAR
-STARTCHAR 0x04C4
+STARTCHAR uni04C4
 ENCODING 1220
 SWIDTH 480 0
 DWIDTH 8 0
@@ -17994,8 +17991,44 @@
 04
 34
 18
+ENDCHAR
+STARTCHAR uni04C5
+ENCODING 1221
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 13 1 -2
+BITMAP
+7FC0
+2100
+2100
+2100
+2100
+2100
+2100
+2100
+2100
+A100
+C7C0
+00C0
+0040
+ENDCHAR
+STARTCHAR uni04C6
+ENCODING 1222
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 9 1 -2
+BITMAP
+FE
+44
+44
+44
+44
+C4
+CE
+02
+02
 ENDCHAR
-STARTCHAR 0x04C7
+STARTCHAR uni04C7
 ENCODING 1223
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18016,7 +18049,7 @@
 0C80
 0700
 ENDCHAR
-STARTCHAR 0x04C8
+STARTCHAR uni04C8
 ENCODING 1224
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18032,8 +18065,45 @@
 04
 34
 18
+ENDCHAR
+STARTCHAR uni04A2
+ENCODING 1225
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 0 -3
+BITMAP
+FBE0
+2080
+2080
+2080
+2080
+3F80
+2080
+2080
+2080
+2080
+FBE0
+0020
+0040
+0080
+ENDCHAR
+STARTCHAR uni04A3
+ENCODING 1226
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 -2
+BITMAP
+EE
+44
+44
+7C
+44
+44
+EE
+02
+04
 ENDCHAR
-STARTCHAR 0x04CB
+STARTCHAR uni04CB
 ENCODING 1227
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18054,7 +18124,7 @@
 0400
 0400
 ENDCHAR
-STARTCHAR 0x04CC
+STARTCHAR uni04CC
 ENCODING 1228
 SWIDTH 480 0
 DWIDTH 8 0
@@ -18069,8 +18139,45 @@
 0E
 08
 08
+ENDCHAR
+STARTCHAR uni04CD
+ENCODING 1229
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 14 0 -3
+BITMAP
+F03C
+3030
+3030
+2850
+2850
+2890
+2490
+2490
+2310
+2310
+FB7C
+0004
+0008
+0010
+ENDCHAR
+STARTCHAR uni04CE
+ENCODING 1230
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 -2
+BITMAP
+C180
+6300
+6300
+5500
+5500
+4900
+EB80
+0080
+0100
 ENDCHAR
-STARTCHAR 0x04D0
+STARTCHAR uni04D0
 ENCODING 1232
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18091,7 +18198,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR 0x04D1
+STARTCHAR uni04D1
 ENCODING 1233
 SWIDTH 420 0
 DWIDTH 7 0
@@ -18108,7 +18215,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR 0x04D2
+STARTCHAR uni04D2
 ENCODING 1234
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18129,7 +18236,7 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR 0x04D3
+STARTCHAR uni04D3
 ENCODING 1235
 SWIDTH 420 0
 DWIDTH 7 0
@@ -18146,7 +18253,7 @@
 88
 7C
 ENDCHAR
-STARTCHAR 0x04D4
+STARTCHAR uni04D4
 ENCODING 1236
 SWIDTH 840 0
 DWIDTH 14 0
@@ -18164,7 +18271,7 @@
 2208
 F7F8
 ENDCHAR
-STARTCHAR 0x04D5
+STARTCHAR uni04D5
 ENCODING 1237
 SWIDTH 720 0
 DWIDTH 12 0
@@ -18178,7 +18285,7 @@
 8C40
 7380
 ENDCHAR
-STARTCHAR 0x04D6
+STARTCHAR uni04D6
 ENCODING 1238
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18199,7 +18306,7 @@
 2080
 FF80
 ENDCHAR
-STARTCHAR 0x04D7
+STARTCHAR uni04D7
 ENCODING 1239
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18216,7 +18323,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04D8
+STARTCHAR uni04D8
 ENCODING 1240
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18234,7 +18341,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR 0x04D9
+STARTCHAR uni04D9
 ENCODING 1241
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18248,7 +18355,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04DA
+STARTCHAR uni04DA
 ENCODING 1242
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18269,7 +18376,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR 0x04DB
+STARTCHAR uni04DB
 ENCODING 1243
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18286,7 +18393,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04DC
+STARTCHAR uni04DC
 ENCODING 1244
 SWIDTH 900 0
 DWIDTH 15 0
@@ -18307,7 +18414,7 @@
 2108
 F39E
 ENDCHAR
-STARTCHAR 0x04DD
+STARTCHAR uni04DD
 ENCODING 1245
 SWIDTH 720 0
 DWIDTH 12 0
@@ -18324,7 +18431,7 @@
 2480
 EEE0
 ENDCHAR
-STARTCHAR 0x04DE
+STARTCHAR uni04DE
 ENCODING 1246
 SWIDTH 480 0
 DWIDTH 8 0
@@ -18345,7 +18452,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR 0x04DF
+STARTCHAR uni04DF
 ENCODING 1247
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18362,7 +18469,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04E0
+STARTCHAR uni04E0
 ENCODING 1248
 SWIDTH 420 0
 DWIDTH 7 0
@@ -18380,7 +18487,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04E1
+STARTCHAR uni04E1
 ENCODING 1249
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18396,7 +18503,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04E2
+STARTCHAR uni04E2
 ENCODING 1250
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18416,7 +18523,7 @@
 3080
 FBE0
 ENDCHAR
-STARTCHAR 0x04E3
+STARTCHAR uni04E3
 ENCODING 1251
 SWIDTH 480 0
 DWIDTH 8 0
@@ -18432,7 +18539,7 @@
 64
 EE
 ENDCHAR
-STARTCHAR 0x04E4
+STARTCHAR uni04E4
 ENCODING 1252
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18453,7 +18560,7 @@
 3080
 FBE0
 ENDCHAR
-STARTCHAR 0x04E5
+STARTCHAR uni04E5
 ENCODING 1253
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18470,7 +18577,7 @@
 64
 EE
 ENDCHAR
-STARTCHAR 0x04E6
+STARTCHAR uni04E6
 ENCODING 1254
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18491,7 +18598,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR 0x04E7
+STARTCHAR uni04E7
 ENCODING 1255
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18508,7 +18615,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04E8
+STARTCHAR uni04E8
 ENCODING 1256
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18526,7 +18633,7 @@
 6180
 1E00
 ENDCHAR
-STARTCHAR 0x04E9
+STARTCHAR uni04E9
 ENCODING 1257
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18540,7 +18647,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04EA
+STARTCHAR uni04EA
 ENCODING 1258
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18561,7 +18668,7 @@
 6180
 1E00
 ENDCHAR
-STARTCHAR 0x04EB
+STARTCHAR uni04EB
 ENCODING 1259
 SWIDTH 360 0
 DWIDTH 6 0
@@ -18578,7 +18685,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04EC
+STARTCHAR uni04EC
 ENCODING 1260
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18599,7 +18706,7 @@
 4200
 3C00
 ENDCHAR
-STARTCHAR 0x04ED
+STARTCHAR uni04ED
 ENCODING 1261
 SWIDTH 420 0
 DWIDTH 7 0
@@ -18616,7 +18723,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x04EE
+STARTCHAR uni04EE
 ENCODING 1262
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18636,7 +18743,7 @@
 4400
 3800
 ENDCHAR
-STARTCHAR 0x04EF
+STARTCHAR uni04EF
 ENCODING 1263
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18655,7 +18762,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR 0x04F0
+STARTCHAR uni04F0
 ENCODING 1264
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18676,7 +18783,7 @@
 4400
 3800
 ENDCHAR
-STARTCHAR 0x04F1
+STARTCHAR uni04F1
 ENCODING 1265
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18696,7 +18803,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR 0x04F2
+STARTCHAR uni04F2
 ENCODING 1266
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18718,7 +18825,7 @@
 4400
 3800
 ENDCHAR
-STARTCHAR 0x04F3
+STARTCHAR uni04F3
 ENCODING 1267
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18739,7 +18846,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR 0x04F4
+STARTCHAR uni04F4
 ENCODING 1268
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18760,7 +18867,7 @@
 0100
 0380
 ENDCHAR
-STARTCHAR 0x04F5
+STARTCHAR uni04F5
 ENCODING 1269
 SWIDTH 480 0
 DWIDTH 8 0
@@ -18777,7 +18884,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR 0x04F8
+STARTCHAR uni04F8
 ENCODING 1272
 SWIDTH 900 0
 DWIDTH 15 0
@@ -18798,7 +18905,7 @@
 20C8
 FF3E
 ENDCHAR
-STARTCHAR 0x04F9
+STARTCHAR uni04F9
 ENCODING 1273
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18814,8 +18921,270 @@
 4500
 4500
 FB80
+ENDCHAR
+STARTCHAR uni042C
+ENCODING 1280
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+07C0
+0100
+0100
+0100
+0100
+7F00
+C100
+8100
+8100
+4100
+3FC0
+ENDCHAR
+STARTCHAR uni044C
+ENCODING 1281
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 7 1 0
+BITMAP
+1C
+08
+08
+78
+88
+88
+7C
+ENDCHAR
+STARTCHAR uni042C
+ENCODING 1282
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+07C0
+0100
+0100
+0100
+0100
+7F00
+C11C
+8108
+8108
+4108
+3EF0
+ENDCHAR
+STARTCHAR uni044C
+ENCODING 1283
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 7 1 0
+BITMAP
+1C00
+0800
+0800
+79C0
+8880
+8880
+7700
+ENDCHAR
+STARTCHAR uni0498
+ENCODING 1284
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
+BITMAP
+BC00
+C200
+8200
+0200
+0400
+3C00
+0238
+0210
+0210
+0210
+01E0
+ENDCHAR
+STARTCHAR uni0499
+ENCODING 1285
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 7 2 0
+BITMAP
+E000
+9000
+1000
+6380
+1100
+1100
+0E00
+ENDCHAR
+STARTCHAR uni0498
+ENCODING 1286
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 1 -3
+BITMAP
+BC00
+C200
+8200
+0200
+0400
+3C00
+0200
+0200
+0200
+0200
+0180
+0040
+0040
+0040
+ENDCHAR
+STARTCHAR uni0499
+ENCODING 1287
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 2 -3
+BITMAP
+E0
+90
+10
+60
+10
+10
+10
+08
+04
+04
+ENDCHAR
+STARTCHAR uni041B
+ENCODING 1288
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+7FC0
+2100
+2100
+2100
+2100
+2100
+211C
+2108
+2108
+A108
+C0F0
+ENDCHAR
+STARTCHAR uni043B
+ENCODING 1289
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
+BITMAP
+FE00
+4400
+4400
+44E0
+4440
+C440
+C380
+ENDCHAR
+STARTCHAR uni04A2
+ENCODING 1290
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 0 0
+BITMAP
+FBE0
+2080
+2080
+2080
+2080
+3F80
+208E
+2084
+2084
+2084
+F878
+ENDCHAR
+STARTCHAR uni04A3
+ENCODING 1291
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
+BITMAP
+EE00
+4400
+4400
+7CE0
+4440
+4440
+E380
+ENDCHAR
+STARTCHAR uni04AA
+ENCODING 1292
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+1E80
+2180
+4080
+8080
+8000
+81C0
+8080
+8080
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR C065
+STARTCHAR uni04AB
+ENCODING 1293
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 7 1 0
+BITMAP
+70
+88
+80
+9C
+88
+88
+70
+ENDCHAR
+STARTCHAR uni04AC
+ENCODING 1294
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+FF80
+8880
+8880
+8880
+0800
+0800
+09C0
+0880
+0880
+0880
+3F00
+ENDCHAR
+STARTCHAR uni04AD
+ENCODING 1295
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 7 1 0
+BITMAP
+FE00
+9200
+1000
+1380
+1100
+1100
+7E00
+ENDCHAR
+STARTCHAR uni0531
 ENCODING 1329
 SWIDTH 780 0
 DWIDTH 13 0
@@ -18833,7 +19202,7 @@
 1130
 0E10
 ENDCHAR
-STARTCHAR C080
+STARTCHAR uni0532
 ENCODING 1330
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18851,7 +19220,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C075
+STARTCHAR uni0533
 ENCODING 1331
 SWIDTH 720 0
 DWIDTH 12 0
@@ -18869,7 +19238,7 @@
 0200
 0F80
 ENDCHAR
-STARTCHAR C084
+STARTCHAR uni0534
 ENCODING 1332
 SWIDTH 780 0
 DWIDTH 13 0
@@ -18887,7 +19256,7 @@
 0100
 07C0
 ENDCHAR
-STARTCHAR C069
+STARTCHAR uni0535
 ENCODING 1333
 SWIDTH 660 0
 DWIDTH 11 0
@@ -18905,7 +19274,7 @@
 2080
 1F00
 ENDCHAR
-STARTCHAR C090
+STARTCHAR uni0536
 ENCODING 1334
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18924,7 +19293,7 @@
 FE00
 C300
 ENDCHAR
-STARTCHAR C063
+STARTCHAR uni0537
 ENCODING 1335
 SWIDTH 540 0
 DWIDTH 9 0
@@ -18944,7 +19313,7 @@
 06
 02
 ENDCHAR
-STARTCHAR C087
+STARTCHAR uni0538
 ENCODING 1336
 SWIDTH 600 0
 DWIDTH 10 0
@@ -18964,7 +19333,7 @@
 0180
 0080
 ENDCHAR
-STARTCHAR C041
+STARTCHAR uni0539
 ENCODING 1337
 SWIDTH 780 0
 DWIDTH 13 0
@@ -18982,7 +19351,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C067
+STARTCHAR uni053A
 ENCODING 1338
 SWIDTH 720 0
 DWIDTH 12 0
@@ -19000,7 +19369,7 @@
 4400
 3800
 ENDCHAR
-STARTCHAR C073
+STARTCHAR uni053B
 ENCODING 1339
 SWIDTH 720 0
 DWIDTH 12 0
@@ -19018,7 +19387,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C076
+STARTCHAR uni053C
 ENCODING 1340
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19038,7 +19407,7 @@
 02
 02
 ENDCHAR
-STARTCHAR C088
+STARTCHAR uni053D
 ENCODING 1341
 SWIDTH 720 0
 DWIDTH 12 0
@@ -19056,7 +19425,7 @@
 23C0
 F800
 ENDCHAR
-STARTCHAR C091
+STARTCHAR uni053E
 ENCODING 1342
 SWIDTH 780 0
 DWIDTH 13 0
@@ -19075,7 +19444,7 @@
 2080
 1F00
 ENDCHAR
-STARTCHAR C071
+STARTCHAR uni053F
 ENCODING 1343
 SWIDTH 660 0
 DWIDTH 11 0
@@ -19093,7 +19462,7 @@
 0100
 07C0
 ENDCHAR
-STARTCHAR C072
+STARTCHAR uni0540
 ENCODING 1344
 SWIDTH 660 0
 DWIDTH 11 0
@@ -19111,7 +19480,7 @@
 0080
 0040
 ENDCHAR
-STARTCHAR C124
+STARTCHAR uni0541
 ENCODING 1345
 SWIDTH 540 0
 DWIDTH 9 0
@@ -19129,7 +19498,7 @@
 99
 66
 ENDCHAR
-STARTCHAR C081
+STARTCHAR uni0542
 ENCODING 1346
 SWIDTH 780 0
 DWIDTH 13 0
@@ -19149,7 +19518,7 @@
 0030
 0010
 ENDCHAR
-STARTCHAR C074
+STARTCHAR uni0543
 ENCODING 1347
 SWIDTH 660 0
 DWIDTH 11 0
@@ -19167,7 +19536,7 @@
 2300
 1DC0
 ENDCHAR
-STARTCHAR C077
+STARTCHAR uni0544
 ENCODING 1348
 SWIDTH 780 0
 DWIDTH 13 0
@@ -19185,7 +19554,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uni0545
 ENCODING 1349
 SWIDTH 540 0
 DWIDTH 9 0
@@ -19203,7 +19572,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR C078
+STARTCHAR uni0546
 ENCODING 1350
 SWIDTH 660 0
 DWIDTH 11 0
@@ -19221,7 +19590,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C070
+STARTCHAR uni0547
 ENCODING 1351
 SWIDTH 600 0
 DWIDTH 10 0
@@ -19239,7 +19608,7 @@
 4100
 3E00
 ENDCHAR
-STARTCHAR C060
+STARTCHAR uni0548
 ENCODING 1352
 SWIDTH 720 0
 DWIDTH 12 0
@@ -19257,7 +19626,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C043
+STARTCHAR uni0549
 ENCODING 1353
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19277,7 +19646,7 @@
 1C
 04
 ENDCHAR
-STARTCHAR C066
+STARTCHAR uni054A
 ENCODING 1354
 SWIDTH 780 0
 DWIDTH 13 0
@@ -19295,7 +19664,7 @@
 0040
 01F0
 ENDCHAR
-STARTCHAR C061
+STARTCHAR uni054B
 ENCODING 1355
 SWIDTH 600 0
 DWIDTH 10 0
@@ -19315,7 +19684,7 @@
 C180
 0080
 ENDCHAR
-STARTCHAR C042
+STARTCHAR uni054C
 ENCODING 1356
 SWIDTH 840 0
 DWIDTH 14 0
@@ -19333,7 +19702,7 @@
 2080
 FBE0
 ENDCHAR
-STARTCHAR C083
+STARTCHAR uni054D
 ENCODING 1357
 SWIDTH 720 0
 DWIDTH 12 0
@@ -19351,7 +19720,7 @@
 1100
 0E00
 ENDCHAR
-STARTCHAR C086
+STARTCHAR uni054E
 ENCODING 1358
 SWIDTH 780 0
 DWIDTH 13 0
@@ -19371,7 +19740,7 @@
 0030
 0010
 ENDCHAR
-STARTCHAR C068
+STARTCHAR uni054F
 ENCODING 1359
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19389,7 +19758,7 @@
 C4
 B8
 ENDCHAR
-STARTCHAR C082
+STARTCHAR uni0550
 ENCODING 1360
 SWIDTH 660 0
 DWIDTH 11 0
@@ -19407,7 +19776,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C093
+STARTCHAR uni0551
 ENCODING 1361
 SWIDTH 540 0
 DWIDTH 9 0
@@ -19425,7 +19794,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR C085
+STARTCHAR uni0552
 ENCODING 1362
 SWIDTH 720 0
 DWIDTH 12 0
@@ -19443,7 +19812,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR C033
+STARTCHAR uni0553
 ENCODING 1363
 SWIDTH 600 0
 DWIDTH 10 0
@@ -19461,7 +19830,7 @@
 0800
 3E00
 ENDCHAR
-STARTCHAR C062
+STARTCHAR uni0554
 ENCODING 1364
 SWIDTH 660 0
 DWIDTH 11 0
@@ -19479,7 +19848,7 @@
 1000
 7C00
 ENDCHAR
-STARTCHAR C079
+STARTCHAR uni0555
 ENCODING 1365
 SWIDTH 600 0
 DWIDTH 10 0
@@ -19497,7 +19866,7 @@
 4100
 3E00
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uni0556
 ENCODING 1366
 SWIDTH 600 0
 DWIDTH 10 0
@@ -19515,7 +19884,7 @@
 4900
 3E00
 ENDCHAR
-STARTCHAR char1369
+STARTCHAR uni0559
 ENCODING 1369
 SWIDTH 120 0
 DWIDTH 2 0
@@ -19526,7 +19895,7 @@
 80
 40
 ENDCHAR
-STARTCHAR char1369
+STARTCHAR uni055A
 ENCODING 1370
 SWIDTH 120 0
 DWIDTH 2 0
@@ -19537,7 +19906,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C125
+STARTCHAR uni055B
 ENCODING 1371
 SWIDTH 180 0
 DWIDTH 3 0
@@ -19548,7 +19917,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C021
+STARTCHAR uni055C
 ENCODING 1372
 SWIDTH 420 0
 DWIDTH 7 0
@@ -19557,7 +19926,7 @@
 72
 9C
 ENDCHAR
-STARTCHAR C127
+STARTCHAR uni055D
 ENCODING 1373
 SWIDTH 180 0
 DWIDTH 3 0
@@ -19568,7 +19937,7 @@
 40
 20
 ENDCHAR
-STARTCHAR C022
+STARTCHAR uni055E
 ENCODING 1374
 SWIDTH 360 0
 DWIDTH 6 0
@@ -19578,7 +19947,7 @@
 4C
 8C
 ENDCHAR
-STARTCHAR C022
+STARTCHAR uni055F
 ENCODING 1375
 SWIDTH 300 0
 DWIDTH 5 0
@@ -19590,7 +19959,7 @@
 80
 78
 ENDCHAR
-STARTCHAR C097
+STARTCHAR uni0561
 ENCODING 1377
 SWIDTH 720 0
 DWIDTH 12 0
@@ -19604,7 +19973,7 @@
 4440
 3BE0
 ENDCHAR
-STARTCHAR C112
+STARTCHAR uni0562
 ENCODING 1378
 SWIDTH 420 0
 DWIDTH 7 0
@@ -19621,7 +19990,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C107
+STARTCHAR uni0563
 ENCODING 1379
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19638,7 +20007,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR C116
+STARTCHAR uni0564
 ENCODING 1380
 SWIDTH 540 0
 DWIDTH 9 0
@@ -19655,7 +20024,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR C101
+STARTCHAR uni0565
 ENCODING 1381
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19673,7 +20042,7 @@
 4C
 36
 ENDCHAR
-STARTCHAR C122
+STARTCHAR uni0566
 ENCODING 1382
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19690,7 +20059,7 @@
 04
 07
 ENDCHAR
-STARTCHAR C047
+STARTCHAR uni0567
 ENCODING 1383
 SWIDTH 360 0
 DWIDTH 6 0
@@ -19709,7 +20078,7 @@
 78
 0C
 ENDCHAR
-STARTCHAR C119
+STARTCHAR uni0568
 ENCODING 1384
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19726,7 +20095,7 @@
 40
 7E
 ENDCHAR
-STARTCHAR C057
+STARTCHAR uni0569
 ENCODING 1385
 SWIDTH 540 0
 DWIDTH 9 0
@@ -19743,7 +20112,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni056A
 ENCODING 1386
 SWIDTH 540 0
 DWIDTH 9 0
@@ -19761,7 +20130,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C105
+STARTCHAR uni056B
 ENCODING 1387
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19782,7 +20151,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C108
+STARTCHAR uni056C
 ENCODING 1388
 SWIDTH 240 0
 DWIDTH 4 0
@@ -19800,7 +20169,7 @@
 40
 70
 ENDCHAR
-STARTCHAR C120
+STARTCHAR uni056D
 ENCODING 1389
 SWIDTH 660 0
 DWIDTH 11 0
@@ -19821,7 +20190,7 @@
 4000
 E000
 ENDCHAR
-STARTCHAR C099
+STARTCHAR uni056E
 ENCODING 1390
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19838,7 +20207,7 @@
 48
 30
 ENDCHAR
-STARTCHAR C103
+STARTCHAR uni056F
 ENCODING 1391
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19859,7 +20228,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR C104
+STARTCHAR uni0570
 ENCODING 1392
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19877,7 +20246,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C048
+STARTCHAR uni0571
 ENCODING 1393
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19895,7 +20264,7 @@
 4C
 36
 ENDCHAR
-STARTCHAR C113
+STARTCHAR uni0572
 ENCODING 1394
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19912,7 +20281,7 @@
 04
 06
 ENDCHAR
-STARTCHAR C053
+STARTCHAR uni0573
 ENCODING 1395
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19930,7 +20299,7 @@
 8C
 76
 ENDCHAR
-STARTCHAR C109
+STARTCHAR uni0574
 ENCODING 1396
 SWIDTH 480 0
 DWIDTH 8 0
@@ -19948,7 +20317,7 @@
 4C
 36
 ENDCHAR
-STARTCHAR C121
+STARTCHAR uni0575
 ENCODING 1397
 SWIDTH 300 0
 DWIDTH 5 0
@@ -19965,7 +20334,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR C110
+STARTCHAR uni0576
 ENCODING 1398
 SWIDTH 420 0
 DWIDTH 7 0
@@ -19983,7 +20352,7 @@
 98
 6C
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uni0577
 ENCODING 1399
 SWIDTH 360 0
 DWIDTH 6 0
@@ -20000,7 +20369,7 @@
 80
 F8
 ENDCHAR
-STARTCHAR C055
+STARTCHAR uni0578
 ENCODING 1400
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20014,7 +20383,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR C059
+STARTCHAR uni0579
 ENCODING 1401
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20031,7 +20400,7 @@
 80
 70
 ENDCHAR
-STARTCHAR C098
+STARTCHAR uni057A
 ENCODING 1402
 SWIDTH 720 0
 DWIDTH 12 0
@@ -20048,7 +20417,7 @@
 0040
 00E0
 ENDCHAR
-STARTCHAR C050
+STARTCHAR uni057B
 ENCODING 1403
 SWIDTH 360 0
 DWIDTH 6 0
@@ -20065,7 +20434,7 @@
 40
 78
 ENDCHAR
-STARTCHAR C052
+STARTCHAR uni057C
 ENCODING 1404
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20079,7 +20448,7 @@
 48
 EE
 ENDCHAR
-STARTCHAR C115
+STARTCHAR uni057D
 ENCODING 1405
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20093,7 +20462,7 @@
 4C
 36
 ENDCHAR
-STARTCHAR C118
+STARTCHAR uni057E
 ENCODING 1406
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20114,7 +20483,7 @@
 04
 06
 ENDCHAR
-STARTCHAR C100
+STARTCHAR uni057F
 ENCODING 1407
 SWIDTH 720 0
 DWIDTH 12 0
@@ -20128,7 +20497,7 @@
 4C40
 36E0
 ENDCHAR
-STARTCHAR C114
+STARTCHAR uni0580
 ENCODING 1408
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20145,7 +20514,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C054
+STARTCHAR uni0581
 ENCODING 1409
 SWIDTH 420 0
 DWIDTH 7 0
@@ -20162,7 +20531,7 @@
 C8
 70
 ENDCHAR
-STARTCHAR C117
+STARTCHAR uni0582
 ENCODING 1410
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20176,7 +20545,7 @@
 40
 70
 ENDCHAR
-STARTCHAR C049
+STARTCHAR uni0583
 ENCODING 1411
 SWIDTH 720 0
 DWIDTH 12 0
@@ -20197,7 +20566,7 @@
 0400
 0E00
 ENDCHAR
-STARTCHAR C051
+STARTCHAR uni0584
 ENCODING 1412
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20214,7 +20583,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR C111
+STARTCHAR uni0585
 ENCODING 1413
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20228,7 +20597,7 @@
 44
 38
 ENDCHAR
-STARTCHAR C056
+STARTCHAR uni0586
 ENCODING 1414
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20249,7 +20618,7 @@
 10
 38
 ENDCHAR
-STARTCHAR C000
+STARTCHAR uni0587
 ENCODING 1415
 SWIDTH 540 0
 DWIDTH 9 0
@@ -20267,7 +20636,7 @@
 4C
 37
 ENDCHAR
-STARTCHAR C058
+STARTCHAR uni0589
 ENCODING 1417
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20281,7 +20650,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uni058A
 ENCODING 1418
 SWIDTH 540 0
 DWIDTH 9 0
@@ -20291,7 +20660,7 @@
 C2
 7C
 ENDCHAR
-STARTCHAR char1425
+STARTCHAR uni0591
 ENCODING 1425
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20302,7 +20671,7 @@
 70
 88
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni0592
 ENCODING 1426
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20313,7 +20682,7 @@
 CC
 CC
 ENDCHAR
-STARTCHAR char1427
+STARTCHAR uni0593
 ENCODING 1427
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20327,7 +20696,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni0594
 ENCODING 1428
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20339,7 +20708,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni0595
 ENCODING 1429
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20351,7 +20720,7 @@
 B0
 B0
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni0596
 ENCODING 1430
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20361,7 +20730,7 @@
 80
 60
 ENDCHAR
-STARTCHAR char1431
+STARTCHAR uni0597
 ENCODING 1431
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20373,7 +20742,7 @@
 70
 20
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni0598
 ENCODING 1432
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20384,7 +20753,7 @@
 92
 4C
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni0599
 ENCODING 1433
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20394,7 +20763,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char1434
+STARTCHAR uni059A
 ENCODING 1434
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20406,7 +20775,7 @@
 40
 20
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni059B
 ENCODING 1435
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20416,7 +20785,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni059C
 ENCODING 1436
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20426,7 +20795,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni059D
 ENCODING 1437
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20436,7 +20805,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni059E
 ENCODING 1438
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20446,7 +20815,7 @@
 90
 90
 ENDCHAR
-STARTCHAR char1439
+STARTCHAR uni059F
 ENCODING 1439
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20457,7 +20826,7 @@
 44
 28
 ENDCHAR
-STARTCHAR char1439
+STARTCHAR uni05A0
 ENCODING 1440
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20468,7 +20837,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char1441
+STARTCHAR uni05A1
 ENCODING 1441
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20478,7 +20847,7 @@
 70
 80
 ENDCHAR
-STARTCHAR char1443
+STARTCHAR uni05A3
 ENCODING 1443
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20488,7 +20857,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR char1434
+STARTCHAR uni05A4
 ENCODING 1444
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20500,7 +20869,7 @@
 40
 20
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni05A5
 ENCODING 1445
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20510,7 +20879,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni05A6
 ENCODING 1446
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20520,7 +20889,7 @@
 24
 D8
 ENDCHAR
-STARTCHAR char1447
+STARTCHAR uni05A7
 ENCODING 1447
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20532,7 +20901,7 @@
 10
 60
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni05A8
 ENCODING 1448
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20542,7 +20911,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char1439
+STARTCHAR uni05A9
 ENCODING 1449
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20553,7 +20922,7 @@
 40
 20
 ENDCHAR
-STARTCHAR char1425
+STARTCHAR uni05AA
 ENCODING 1450
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20564,7 +20933,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char1434
+STARTCHAR uni05AB
 ENCODING 1451
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20576,7 +20945,7 @@
 40
 20
 ENDCHAR
-STARTCHAR char1452
+STARTCHAR uni05AC
 ENCODING 1452
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20586,7 +20955,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni05AD
 ENCODING 1453
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20596,7 +20965,7 @@
 80
 60
 ENDCHAR
-STARTCHAR char1430
+STARTCHAR uni05AE
 ENCODING 1454
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20607,7 +20976,7 @@
 92
 4C
 ENDCHAR
-STARTCHAR char1439
+STARTCHAR uni05AF
 ENCODING 1455
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20617,7 +20986,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B0
 ENCODING 1456
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20629,7 +20998,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B1
 ENCODING 1457
 SWIDTH 480 0
 DWIDTH 8 0
@@ -20641,7 +21010,7 @@
 44
 44
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B2
 ENCODING 1458
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20653,7 +21022,7 @@
 08
 08
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B3
 ENCODING 1459
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20665,7 +21034,7 @@
 48
 08
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B4
 ENCODING 1460
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20674,7 +21043,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B5
 ENCODING 1461
 SWIDTH 240 0
 DWIDTH 4 0
@@ -20683,7 +21052,7 @@
 A0
 A0
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B6
 ENCODING 1462
 SWIDTH 240 0
 DWIDTH 4 0
@@ -20695,7 +21064,7 @@
 40
 40
 ENDCHAR
-STARTCHAR char1463
+STARTCHAR uni05B7
 ENCODING 1463
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20703,7 +21072,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR char1463
+STARTCHAR uni05B8
 ENCODING 1464
 SWIDTH 300 0
 DWIDTH 5 0
@@ -20713,7 +21082,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05B9
 ENCODING 1465
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20722,7 +21091,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05BB
 ENCODING 1467
 SWIDTH 360 0
 DWIDTH 6 0
@@ -20733,7 +21102,7 @@
 28
 08
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05BC
 ENCODING 1468
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20742,7 +21111,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1468
+STARTCHAR uni05BD
 ENCODING 1469
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20753,7 +21122,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1469
+STARTCHAR uni05BE
 ENCODING 1470
 SWIDTH 420 0
 DWIDTH 7 0
@@ -20762,7 +21131,7 @@
 7C
 F8
 ENDCHAR
-STARTCHAR char1463
+STARTCHAR uni05BF
 ENCODING 1471
 SWIDTH 0 0
 DWIDTH 0 0
@@ -20770,7 +21139,7 @@
 BITMAP
 F0
 ENDCHAR
-STARTCHAR char1472
+STARTCHAR uni05C0
 ENCODING 1472
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20785,7 +21154,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05C1
 ENCODING 1473
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20794,7 +21163,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05C2
 ENCODING 1474
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20803,7 +21172,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char1475
+STARTCHAR uni05C3
 ENCODING 1475
 SWIDTH 180 0
 DWIDTH 3 0
@@ -20816,7 +21185,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR char1456
+STARTCHAR uni05C4
 ENCODING 1476
 SWIDTH 120 0
 DWIDTH 2 0
@@ -20827,8 +21196,8 @@
 ENDCHAR
 STARTCHAR 0x05D0
 ENCODING 1488
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 84
@@ -20843,8 +21212,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 1489
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 80
@@ -20859,8 +21228,8 @@
 ENDCHAR
 STARTCHAR 0x05D2
 ENCODING 1490
-SWIDTH 360 0
-DWIDTH 6 0
+SWIDTH 420 0
+DWIDTH 7 0
 BBX 5 9 1 0
 BITMAP
 80
@@ -20875,8 +21244,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 1491
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 80
@@ -20891,8 +21260,8 @@
 ENDCHAR
 STARTCHAR 0x05D4
 ENCODING 1492
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 80
@@ -20907,8 +21276,8 @@
 ENDCHAR
 STARTCHAR 0x05D5
 ENCODING 1493
-SWIDTH 300 0
-DWIDTH 5 0
+SWIDTH 360 0
+DWIDTH 6 0
 BBX 4 9 1 0
 BITMAP
 80
@@ -20923,8 +21292,8 @@
 ENDCHAR
 STARTCHAR 0x05D5
 ENCODING 1494
-SWIDTH 360 0
-DWIDTH 6 0
+SWIDTH 420 0
+DWIDTH 7 0
 BBX 5 9 1 0
 BITMAP
 80
@@ -20939,8 +21308,8 @@
 ENDCHAR
 STARTCHAR 0x05D4
 ENCODING 1495
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 80
@@ -20971,8 +21340,8 @@
 ENDCHAR
 STARTCHAR 0x05D9
 ENCODING 1497
-SWIDTH 240 0
-DWIDTH 4 0
+SWIDTH 300 0
+DWIDTH 5 0
 BBX 3 5 1 4
 BITMAP
 80
@@ -20983,8 +21352,8 @@
 ENDCHAR
 STARTCHAR 0x05DA
 ENCODING 1498
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 13 1 -4
 BITMAP
 80
@@ -21003,8 +21372,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 1499
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -21021,26 +21390,26 @@
 ENCODING 1500
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 0 0
+BBX 7 13 0 0
 BITMAP
 80
 C0
 40
 40
 40
-7F
-01
-01
-01
-01
+7E
+02
 02
+02
+02
 04
-18
+08
+30
 ENDCHAR
 STARTCHAR 0x05DD
 ENCODING 1501
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -21067,12 +21436,12 @@
 82
 82
 84
-B8
+BC
 ENDCHAR
 STARTCHAR 0x05D5
 ENCODING 1503
-SWIDTH 300 0
-DWIDTH 5 0
+SWIDTH 360 0
+DWIDTH 6 0
 BBX 4 13 1 -4
 BITMAP
 80
@@ -21091,8 +21460,8 @@
 ENDCHAR
 STARTCHAR 0x05D2
 ENCODING 1504
-SWIDTH 300 0
-DWIDTH 5 0
+SWIDTH 360 0
+DWIDTH 6 0
 BBX 4 9 1 0
 BITMAP
 80
@@ -21107,8 +21476,8 @@
 ENDCHAR
 STARTCHAR 0x05E1
 ENCODING 1505
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -21123,8 +21492,8 @@
 ENDCHAR
 STARTCHAR 0x05E2
 ENCODING 1506
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 44
@@ -21139,8 +21508,8 @@
 ENDCHAR
 STARTCHAR 0x05DA
 ENCODING 1507
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 13 1 -4
 BITMAP
 80
@@ -21159,8 +21528,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 1508
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -21175,8 +21544,8 @@
 ENDCHAR
 STARTCHAR 0x05E5
 ENCODING 1509
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 13 1 -4
 BITMAP
 88
@@ -21195,8 +21564,8 @@
 ENDCHAR
 STARTCHAR 0x05E6
 ENCODING 1510
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 84
@@ -21211,8 +21580,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 1511
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 13 1 -4
 BITMAP
 80
@@ -21231,8 +21600,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 1512
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -21247,8 +21616,8 @@
 ENDCHAR
 STARTCHAR 0x05E9
 ENCODING 1513
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 9 1 0
 BITMAP
 9100
@@ -21263,8 +21632,8 @@
 ENDCHAR
 STARTCHAR 0x05D4
 ENCODING 1514
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 40
@@ -21279,8 +21648,8 @@
 ENDCHAR
 STARTCHAR 0x05F0
 ENCODING 1520
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 88
@@ -21295,8 +21664,8 @@
 ENDCHAR
 STARTCHAR 0x05F1
 ENCODING 1521
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 88
@@ -21311,8 +21680,8 @@
 ENDCHAR
 STARTCHAR 0x05F2
 ENCODING 1522
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 5 1 4
 BITMAP
 88
@@ -21323,9 +21692,9 @@
 ENDCHAR
 STARTCHAR 0x05F3
 ENCODING 1523
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 4 1 7
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 2 4 1 5
 BITMAP
 40
 40
@@ -21334,16 +21703,16 @@
 ENDCHAR
 STARTCHAR 0x05F4
 ENCODING 1524
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 4 1 7
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 4 1 5
 BITMAP
 48
 48
 90
 90
 ENDCHAR
-STARTCHAR 0x060C
+STARTCHAR uni060C
 ENCODING 1548
 SWIDTH 180 0
 DWIDTH 3 0
@@ -21354,7 +21723,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR 0x061B
+STARTCHAR uni061B
 ENCODING 1563
 SWIDTH 240 0
 DWIDTH 4 0
@@ -21368,7 +21737,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR 0x061F
+STARTCHAR uni061F
 ENCODING 1567
 SWIDTH 480 0
 DWIDTH 8 0
@@ -21385,7 +21754,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0x0621
+STARTCHAR uni0621
 ENCODING 1569
 SWIDTH 300 0
 DWIDTH 5 0
@@ -21398,7 +21767,7 @@
 C0
 80
 ENDCHAR
-STARTCHAR 0xFE81
+STARTCHAR uni0622
 ENCODING 1570
 SWIDTH 300 0
 DWIDTH 5 0
@@ -21419,7 +21788,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0xFE83
+STARTCHAR uni0623
 ENCODING 1571
 SWIDTH 240 0
 DWIDTH 4 0
@@ -21442,7 +21811,7 @@
 40
 40
 ENDCHAR
-STARTCHAR 0xFE85
+STARTCHAR uni0624
 ENCODING 1572
 SWIDTH 540 0
 DWIDTH 9 0
@@ -21463,7 +21832,7 @@
 84
 78
 ENDCHAR
-STARTCHAR 0xFE87
+STARTCHAR uni0625
 ENCODING 1573
 SWIDTH 300 0
 DWIDTH 5 0
@@ -21486,7 +21855,7 @@
 60
 80
 ENDCHAR
-STARTCHAR 00F0
+STARTCHAR uni0626
 ENCODING 1574
 SWIDTH 660 0
 DWIDTH 11 0
@@ -21506,7 +21875,7 @@
 4180
 3E00
 ENDCHAR
-STARTCHAR 0xFE8D
+STARTCHAR uni0627
 ENCODING 1575
 SWIDTH 300 0
 DWIDTH 5 0
@@ -21523,7 +21892,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 0048
+STARTCHAR uni0628
 ENCODING 1576
 SWIDTH 780 0
 DWIDTH 13 0
@@ -21539,7 +21908,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0xFE93
+STARTCHAR uni0629
 ENCODING 1577
 SWIDTH 420 0
 DWIDTH 7 0
@@ -21556,7 +21925,7 @@
 88
 78
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni062A
 ENCODING 1578
 SWIDTH 780 0
 DWIDTH 13 0
@@ -21571,7 +21940,7 @@
 C030
 7FC0
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni062B
 ENCODING 1579
 SWIDTH 840 0
 DWIDTH 14 0
@@ -21588,7 +21957,7 @@
 C030
 7FC0
 ENDCHAR
-STARTCHAR 0057
+STARTCHAR uni062C
 ENCODING 1580
 SWIDTH 660 0
 DWIDTH 11 0
@@ -21606,7 +21975,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR 0057
+STARTCHAR uni062D
 ENCODING 1581
 SWIDTH 660 0
 DWIDTH 11 0
@@ -21624,7 +21993,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR 0057
+STARTCHAR uni062E
 ENCODING 1582
 SWIDTH 660 0
 DWIDTH 11 0
@@ -21904,7 +22273,7 @@
 4200
 3C00
 ENDCHAR
-STARTCHAR uni0075
+STARTCHAR uni0643
 ENCODING 1603
 SWIDTH 660 0
 DWIDTH 11 0
@@ -21940,7 +22309,7 @@
 84
 78
 ENDCHAR
-STARTCHAR 00E3
+STARTCHAR uni0645
 ENCODING 1605
 SWIDTH 420 0
 DWIDTH 7 0
@@ -21960,7 +22329,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 00E7
+STARTCHAR uni0646
 ENCODING 1606
 SWIDTH 600 0
 DWIDTH 10 0
@@ -21977,7 +22346,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR 0xFEE9
+STARTCHAR uni0647
 ENCODING 1607
 SWIDTH 420 0
 DWIDTH 7 0
@@ -21990,7 +22359,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0xFEED
+STARTCHAR uni0648
 ENCODING 1608
 SWIDTH 540 0
 DWIDTH 9 0
@@ -22005,7 +22374,7 @@
 84
 78
 ENDCHAR
-STARTCHAR 00F0
+STARTCHAR uni0649
 ENCODING 1609
 SWIDTH 660 0
 DWIDTH 11 0
@@ -22020,7 +22389,7 @@
 4180
 3E00
 ENDCHAR
-STARTCHAR 00F0
+STARTCHAR uni064A
 ENCODING 1610
 SWIDTH 720 0
 DWIDTH 12 0
@@ -22038,7 +22407,7 @@
 2800
 2800
 ENDCHAR
-STARTCHAR 0x064B
+STARTCHAR uni064B
 ENCODING 1611
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22049,7 +22418,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR 0x064C
+STARTCHAR uni064C
 ENCODING 1612
 SWIDTH 360 0
 DWIDTH 6 0
@@ -22060,7 +22429,7 @@
 D0
 60
 ENDCHAR
-STARTCHAR 0x064D
+STARTCHAR uni064D
 ENCODING 1613
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22071,7 +22440,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR 0x064E
+STARTCHAR uni064E
 ENCODING 1614
 SWIDTH 360 0
 DWIDTH 6 0
@@ -22081,7 +22450,7 @@
 60
 80
 ENDCHAR
-STARTCHAR 0x064F
+STARTCHAR uni064F
 ENCODING 1615
 SWIDTH 300 0
 DWIDTH 5 0
@@ -22093,7 +22462,7 @@
 50
 80
 ENDCHAR
-STARTCHAR 0x0650
+STARTCHAR uni0650
 ENCODING 1616
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22103,7 +22472,7 @@
 60
 80
 ENDCHAR
-STARTCHAR 0x0651
+STARTCHAR uni0651
 ENCODING 1617
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22113,7 +22482,7 @@
 A8
 D0
 ENDCHAR
-STARTCHAR 0x0652
+STARTCHAR uni0652
 ENCODING 1618
 SWIDTH 240 0
 DWIDTH 4 0
@@ -22124,7 +22493,7 @@
 A0
 C0
 ENDCHAR
-STARTCHAR char1619
+STARTCHAR uni0653
 ENCODING 1619
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22134,7 +22503,7 @@
 78
 80
 ENDCHAR
-STARTCHAR char1620
+STARTCHAR uni0654
 ENCODING 1620
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22145,7 +22514,7 @@
 60
 80
 ENDCHAR
-STARTCHAR char1620
+STARTCHAR uni0655
 ENCODING 1621
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22156,7 +22525,7 @@
 60
 80
 ENDCHAR
-STARTCHAR 0030
+STARTCHAR uni0660
 ENCODING 1632
 SWIDTH 300 0
 DWIDTH 5 0
@@ -22166,7 +22535,7 @@
 E0
 40
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni0661
 ENCODING 1633
 SWIDTH 300 0
 DWIDTH 5 0
@@ -22183,7 +22552,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni0662
 ENCODING 1634
 SWIDTH 480 0
 DWIDTH 8 0
@@ -22200,7 +22569,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0x0663
+STARTCHAR uni0663
 ENCODING 1635
 SWIDTH 480 0
 DWIDTH 8 0
@@ -22217,7 +22586,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0x0664
+STARTCHAR uni0664
 ENCODING 1636
 SWIDTH 420 0
 DWIDTH 7 0
@@ -22235,7 +22604,7 @@
 F8
 70
 ENDCHAR
-STARTCHAR 0x0665
+STARTCHAR uni0665
 ENCODING 1637
 SWIDTH 420 0
 DWIDTH 7 0
@@ -22250,7 +22619,7 @@
 F0
 60
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni0666
 ENCODING 1638
 SWIDTH 480 0
 DWIDTH 8 0
@@ -22266,7 +22635,7 @@
 04
 04
 ENDCHAR
-STARTCHAR 0037
+STARTCHAR uni0667
 ENCODING 1639
 SWIDTH 480 0
 DWIDTH 8 0
@@ -22283,7 +22652,7 @@
 10
 10
 ENDCHAR
-STARTCHAR 0037
+STARTCHAR uni0668
 ENCODING 1640
 SWIDTH 480 0
 DWIDTH 8 0
@@ -22300,7 +22669,7 @@
 84
 84
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni0669
 ENCODING 1641
 SWIDTH 420 0
 DWIDTH 7 0
@@ -22317,7 +22686,7 @@
 08
 08
 ENDCHAR
-STARTCHAR 0x066A
+STARTCHAR uni066A
 ENCODING 1642
 SWIDTH 600 0
 DWIDTH 10 0
@@ -22334,11 +22703,11 @@
 40
 40
 ENDCHAR
-STARTCHAR 0x066B
+STARTCHAR uni066B
 ENCODING 1643
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 5 0 -3
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 4 5 -1 -3
 BITMAP
 10
 10
@@ -22346,11 +22715,11 @@
 20
 C0
 ENDCHAR
-STARTCHAR 0x066C
+STARTCHAR uni066C
 ENCODING 1644
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 2 5 1 -3
+BBX 2 5 1 0
 BITMAP
 C0
 C0
@@ -22358,7 +22727,7 @@
 40
 80
 ENDCHAR
-STARTCHAR 0x066D
+STARTCHAR uni066D
 ENCODING 1645
 SWIDTH 540 0
 DWIDTH 9 0
@@ -22370,8 +22739,38 @@
 38
 28
 44
+ENDCHAR
+STARTCHAR uni067A
+ENCODING 1646
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 6 0 -1
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni0642
+ENCODING 1647
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 1 -3
+BITMAP
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
 ENDCHAR
-STARTCHAR 0x0670
+STARTCHAR uni0670
 ENCODING 1648
 SWIDTH 0 0
 DWIDTH 0 0
@@ -22382,7 +22781,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 0xFB50
+STARTCHAR uni0671
 ENCODING 1649
 SWIDTH 300 0
 DWIDTH 5 0
@@ -22404,7 +22803,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0x0000
+STARTCHAR uni0672
 ENCODING 1650
 SWIDTH 300 0
 DWIDTH 5 0
@@ -22426,7 +22825,7 @@
 10
 10
 ENDCHAR
-STARTCHAR 0x0002
+STARTCHAR uni0673
 ENCODING 1651
 SWIDTH 300 0
 DWIDTH 5 0
@@ -22448,7 +22847,7 @@
 18
 E0
 ENDCHAR
-STARTCHAR 0x0674
+STARTCHAR uni0674
 ENCODING 1652
 SWIDTH 300 0
 DWIDTH 5 0
@@ -22459,7 +22858,7 @@
 60
 80
 ENDCHAR
-STARTCHAR 0x0004
+STARTCHAR uni0675
 ENCODING 1653
 SWIDTH 360 0
 DWIDTH 6 0
@@ -22479,7 +22878,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 0xFE85
+STARTCHAR uni0676
 ENCODING 1654
 SWIDTH 540 0
 DWIDTH 9 0
@@ -22500,7 +22899,7 @@
 8400
 7800
 ENDCHAR
-STARTCHAR 0xFE85
+STARTCHAR uni0677
 ENCODING 1655
 SWIDTH 540 0
 DWIDTH 9 0
@@ -22521,7 +22920,7 @@
 8400
 7800
 ENDCHAR
-STARTCHAR 00F0
+STARTCHAR uni0678
 ENCODING 1656
 SWIDTH 840 0
 DWIDTH 14 0
@@ -22542,7 +22941,7 @@
 4180
 3E00
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni0679
 ENCODING 1657
 SWIDTH 840 0
 DWIDTH 14 0
@@ -22558,7 +22957,7 @@
 C030
 7FC0
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni067A
 ENCODING 1658
 SWIDTH 780 0
 DWIDTH 13 0
@@ -22576,7 +22975,7 @@
 C030
 7FC0
 ENDCHAR
-STARTCHAR 0048
+STARTCHAR uni067B
 ENCODING 1659
 SWIDTH 840 0
 DWIDTH 14 0
@@ -22595,7 +22994,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni067C
 ENCODING 1660
 SWIDTH 780 0
 DWIDTH 13 0
@@ -22613,7 +23012,7 @@
 0900
 0600
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni067D
 ENCODING 1661
 SWIDTH 840 0
 DWIDTH 14 0
@@ -22630,7 +23029,7 @@
 C030
 7FC0
 ENDCHAR
-STARTCHAR 004C
+STARTCHAR uni067E
 ENCODING 1662
 SWIDTH 840 0
 DWIDTH 14 0
@@ -22648,7 +23047,7 @@
 0400
 0400
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni067F
 ENCODING 1663
 SWIDTH 840 0
 DWIDTH 14 0
@@ -23524,7 +23923,7 @@
 8060
 7F80
 ENDCHAR
-STARTCHAR uni0075
+STARTCHAR uni06AC
 ENCODING 1708
 SWIDTH 660 0
 DWIDTH 11 0
@@ -23544,7 +23943,7 @@
 C080
 7F00
 ENDCHAR
-STARTCHAR uni0075
+STARTCHAR uni06AD
 ENCODING 1709
 SWIDTH 660 0
 DWIDTH 11 0
@@ -23566,7 +23965,7 @@
 C080
 7F00
 ENDCHAR
-STARTCHAR uni0075
+STARTCHAR uni06AE
 ENCODING 1710
 SWIDTH 660 0
 DWIDTH 11 0
@@ -24149,7 +24548,7 @@
 4180
 3E00
 ENDCHAR
-STARTCHAR 00F0
+STARTCHAR uni06D0
 ENCODING 1744
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24170,7 +24569,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR 00F0
+STARTCHAR uni06D1
 ENCODING 1745
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24190,7 +24589,7 @@
 1000
 1000
 ENDCHAR
-STARTCHAR 0xFBAE
+STARTCHAR uni06D2
 ENCODING 1746
 SWIDTH 900 0
 DWIDTH 15 0
@@ -24205,7 +24604,7 @@
 8000
 7FF8
 ENDCHAR
-STARTCHAR 0xFBAE
+STARTCHAR uni06D3
 ENCODING 1747
 SWIDTH 900 0
 DWIDTH 15 0
@@ -24223,7 +24622,7 @@
 8000
 7FF8
 ENDCHAR
-STARTCHAR 0x06D4
+STARTCHAR uni06D4
 ENCODING 1748
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24231,7 +24630,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR 0x06D5
+STARTCHAR uni06D5
 ENCODING 1749
 SWIDTH 300 0
 DWIDTH 5 0
@@ -24243,8 +24642,260 @@
 90
 90
 60
+ENDCHAR
+STARTCHAR uni06D6
+ENCODING 1750
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 10 7 1 10
+BITMAP
+2000
+2000
+2180
+2A40
+5780
+8000
+7E00
+ENDCHAR
+STARTCHAR uni06D7
+ENCODING 1751
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 8 1 10
+BITMAP
+0A
+20
+24
+2A
+26
+5C
+80
+7E
+ENDCHAR
+STARTCHAR uni06D8
+ENCODING 1752
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 4 1 10
+BITMAP
+20
+50
+60
+80
+ENDCHAR
+STARTCHAR uni06D9
+ENCODING 1753
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 6 1 10
+BITMAP
+90
+50
+50
+30
+60
+60
+ENDCHAR
+STARTCHAR uni06DA
+ENCODING 1754
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 8 1 10
+BITMAP
+60
+9C
+20
+40
+48
+40
+42
+3C
+ENDCHAR
+STARTCHAR uni06DB
+ENCODING 1755
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 3 1 10
+BITMAP
+40
+00
+A0
+ENDCHAR
+STARTCHAR uni06DC
+ENCODING 1756
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 9 4 1 10
+BITMAP
+0A80
+4D00
+8800
+7000
+ENDCHAR
+STARTCHAR uni06DF
+ENCODING 1759
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 3 1 10
+BITMAP
+40
+E0
+40
+ENDCHAR
+STARTCHAR uni06E0
+ENCODING 1760
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 2 3 1 10
+BITMAP
+C0
+C0
+C0
+ENDCHAR
+STARTCHAR uni06E1
+ENCODING 1761
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 3 1 14
+BITMAP
+60
+10
+F8
+ENDCHAR
+STARTCHAR uni06E2
+ENCODING 1762
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 8 1 10
+BITMAP
+40
+20
+70
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni06E3
+ENCODING 1763
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 9 4 1 -5
+BITMAP
+0A80
+4D00
+8800
+7000
+ENDCHAR
+STARTCHAR uni06E4
+ENCODING 1764
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 2 1 10
+BITMAP
+48
+B0
+ENDCHAR
+STARTCHAR uni06E5
+ENCODING 1765
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 4
+BITMAP
+20
+50
+30
+10
+20
+C0
+ENDCHAR
+STARTCHAR uni06E6
+ENCODING 1766
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 5 1 4
+BITMAP
+1000
+2800
+4000
+8000
+FF80
+ENDCHAR
+STARTCHAR uni06E7
+ENCODING 1767
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 9 5 1 10
+BITMAP
+1000
+2800
+4000
+8000
+FF80
+ENDCHAR
+STARTCHAR uni06E8
+ENCODING 1768
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 5 1 10
+BITMAP
+40
+10
+90
+90
+60
+ENDCHAR
+STARTCHAR uni06EA
+ENCODING 1770
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 5 1 -6
+BITMAP
+20
+50
+88
+50
+20
+ENDCHAR
+STARTCHAR uni06EB
+ENCODING 1771
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 5 1 10
+BITMAP
+20
+50
+88
+50
+20
+ENDCHAR
+STARTCHAR uni06EC
+ENCODING 1772
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 3 1 10
+BITMAP
+40
+E0
+40
+ENDCHAR
+STARTCHAR uni06ED
+ENCODING 1773
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 8 1 -9
+BITMAP
+40
+20
+70
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 0030
+STARTCHAR uni06F0
 ENCODING 1776
 SWIDTH 240 0
 DWIDTH 4 0
@@ -24254,7 +24905,7 @@
 E0
 40
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni06F1
 ENCODING 1777
 SWIDTH 300 0
 DWIDTH 5 0
@@ -24271,7 +24922,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni06F2
 ENCODING 1778
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24288,7 +24939,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0x0663
+STARTCHAR uni06F3
 ENCODING 1779
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24305,7 +24956,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni06F4
 ENCODING 1780
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24322,7 +24973,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0035
+STARTCHAR uni06F5
 ENCODING 1781
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24339,7 +24990,7 @@
 FC
 68
 ENDCHAR
-STARTCHAR 0036
+STARTCHAR uni06F6
 ENCODING 1782
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24356,7 +25007,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 0037
+STARTCHAR uni06F7
 ENCODING 1783
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24373,7 +25024,7 @@
 10
 10
 ENDCHAR
-STARTCHAR 0037
+STARTCHAR uni06F8
 ENCODING 1784
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24390,7 +25041,7 @@
 84
 84
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni06F9
 ENCODING 1785
 SWIDTH 420 0
 DWIDTH 7 0
@@ -24407,7 +25058,7 @@
 08
 08
 ENDCHAR
-STARTCHAR 0072
+STARTCHAR uni06FA
 ENCODING 1786
 SWIDTH 960 0
 DWIDTH 16 0
@@ -24428,7 +25079,7 @@
 4308
 3C00
 ENDCHAR
-STARTCHAR 0079
+STARTCHAR uni06FB
 ENCODING 1787
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -24447,7 +25098,7 @@
 430400
 3C0000
 ENDCHAR
-STARTCHAR 00CB
+STARTCHAR uni06FC
 ENCODING 1788
 SWIDTH 600 0
 DWIDTH 10 0
@@ -24470,7 +25121,7 @@
 4180
 3E00
 ENDCHAR
-STARTCHAR 0x0621
+STARTCHAR uni06FD
 ENCODING 1789
 SWIDTH 300 0
 DWIDTH 5 0
@@ -24490,7 +25141,7 @@
 50
 50
 ENDCHAR
-STARTCHAR 00E3
+STARTCHAR uni06FE
 ENCODING 1790
 SWIDTH 420 0
 DWIDTH 7 0
@@ -24510,7 +25161,7 @@
 94
 80
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0780
 ENCODING 1920
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24523,7 +25174,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0781
 ENCODING 1921
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24536,7 +25187,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0782
 ENCODING 1922
 SWIDTH 900 0
 DWIDTH 15 0
@@ -24549,7 +25200,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0783
 ENCODING 1923
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24562,7 +25213,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1988
+STARTCHAR uni0784
 ENCODING 1924
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24573,7 +25224,7 @@
 94
 78
 ENDCHAR
-STARTCHAR char1989
+STARTCHAR uni0785
 ENCODING 1925
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24584,7 +25235,7 @@
 84
 78
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0786
 ENCODING 1926
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24595,7 +25246,7 @@
 98
 E0
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0787
 ENCODING 1927
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24606,7 +25257,7 @@
 44
 88
 ENDCHAR
-STARTCHAR char1988
+STARTCHAR uni0788
 ENCODING 1928
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24619,7 +25270,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0789
 ENCODING 1929
 SWIDTH 660 0
 DWIDTH 11 0
@@ -24632,7 +25283,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni078A
 ENCODING 1930
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24646,7 +25297,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni078B
 ENCODING 1931
 SWIDTH 660 0
 DWIDTH 11 0
@@ -24660,7 +25311,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1996
+STARTCHAR uni078C
 ENCODING 1932
 SWIDTH 420 0
 DWIDTH 7 0
@@ -24674,7 +25325,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni078D
 ENCODING 1933
 SWIDTH 660 0
 DWIDTH 11 0
@@ -24689,7 +25340,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1989
+STARTCHAR uni078E
 ENCODING 1934
 SWIDTH 300 0
 DWIDTH 5 0
@@ -24700,7 +25351,7 @@
 90
 60
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni078F
 ENCODING 1935
 SWIDTH 600 0
 DWIDTH 10 0
@@ -24714,7 +25365,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR char1936
+STARTCHAR uni0790
 ENCODING 1936
 SWIDTH 960 0
 DWIDTH 16 0
@@ -24726,7 +25377,7 @@
 4000
 8000
 ENDCHAR
-STARTCHAR char1937
+STARTCHAR uni0791
 ENCODING 1937
 SWIDTH 420 0
 DWIDTH 7 0
@@ -24739,7 +25390,7 @@
 C0
 38
 ENDCHAR
-STARTCHAR char1988
+STARTCHAR uni0792
 ENCODING 1938
 SWIDTH 420 0
 DWIDTH 7 0
@@ -24754,7 +25405,7 @@
 88
 70
 ENDCHAR
-STARTCHAR char1988
+STARTCHAR uni0793
 ENCODING 1939
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24768,7 +25419,7 @@
 84
 78
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0794
 ENCODING 1940
 SWIDTH 660 0
 DWIDTH 11 0
@@ -24781,7 +25432,7 @@
 3100
 C000
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0795
 ENCODING 1941
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24796,7 +25447,7 @@
 C4
 04
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0796
 ENCODING 1942
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24811,7 +25462,7 @@
 88
 70
 ENDCHAR
-STARTCHAR char1996
+STARTCHAR uni0797
 ENCODING 1943
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24828,7 +25479,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR char1996
+STARTCHAR uni0798
 ENCODING 1944
 SWIDTH 480 0
 DWIDTH 8 0
@@ -24846,7 +25497,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni0799
 ENCODING 1945
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24859,7 +25510,7 @@
 3080
 C080
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni079A
 ENCODING 1946
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24876,7 +25527,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni079B
 ENCODING 1947
 SWIDTH 660 0
 DWIDTH 11 0
@@ -24893,7 +25544,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni079C
 ENCODING 1948
 SWIDTH 720 0
 DWIDTH 12 0
@@ -24910,7 +25561,7 @@
 3000
 C000
 ENDCHAR
-STARTCHAR char1936
+STARTCHAR uni079D
 ENCODING 1949
 SWIDTH 960 0
 DWIDTH 16 0
@@ -24926,7 +25577,7 @@
 4000
 8000
 ENDCHAR
-STARTCHAR char1936
+STARTCHAR uni079E
 ENCODING 1950
 SWIDTH 960 0
 DWIDTH 16 0
@@ -24940,7 +25591,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR char1936
+STARTCHAR uni079F
 ENCODING 1951
 SWIDTH 960 0
 DWIDTH 16 0
@@ -24954,7 +25605,7 @@
 4000
 8000
 ENDCHAR
-STARTCHAR char1996
+STARTCHAR uni07A0
 ENCODING 1952
 SWIDTH 420 0
 DWIDTH 7 0
@@ -24968,7 +25619,7 @@
 14
 E0
 ENDCHAR
-STARTCHAR char1996
+STARTCHAR uni07A1
 ENCODING 1953
 SWIDTH 420 0
 DWIDTH 7 0
@@ -24985,7 +25636,7 @@
 10
 E0
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni07A2
 ENCODING 1954
 SWIDTH 540 0
 DWIDTH 9 0
@@ -24999,7 +25650,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char1984
+STARTCHAR uni07A3
 ENCODING 1955
 SWIDTH 540 0
 DWIDTH 9 0
@@ -25014,7 +25665,7 @@
 44
 88
 ENDCHAR
-STARTCHAR char1989
+STARTCHAR uni07A4
 ENCODING 1956
 SWIDTH 420 0
 DWIDTH 7 0
@@ -25028,7 +25679,7 @@
 90
 60
 ENDCHAR
-STARTCHAR char1988
+STARTCHAR uni07A5
 ENCODING 1957
 SWIDTH 540 0
 DWIDTH 9 0
@@ -25045,42 +25696,42 @@
 30
 C0
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07A6
 ENCODING 1958
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 6 3 11 8
+BBX 6 3 -5 8
 BITMAP
 0C
 30
 C0
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07A7
 ENCODING 1959
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 9 4 10 7
+BBX 9 4 -7 7
 BITMAP
 0C00
 3180
 C600
 1800
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07A8
 ENCODING 1960
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 6 3 9 -7
+BBX 6 3 -5 -7
 BITMAP
 0C
 30
 C0
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07A9
 ENCODING 1961
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 5 9 -9
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 5 -7 -9
 BITMAP
 0C
 30
@@ -25088,84 +25739,84 @@
 18
 60
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07AA
 ENCODING 1962
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 3 4 12 7
+BBX 3 4 -5 7
 BITMAP
 C0
 20
 40
 80
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07AB
 ENCODING 1963
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 7 4 10 7
+BBX 7 4 -7 7
 BITMAP
 CC
 22
 44
 88
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07AC
 ENCODING 1964
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 3 4 12 7
+BBX 3 4 -5 7
 BITMAP
 60
 80
 40
 20
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07AD
 ENCODING 1965
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 7 4 10 7
+BBX 7 4 -7 7
 BITMAP
 66
 88
 44
 22
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07AE
 ENCODING 1966
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 7 4 10 7
+BBX 6 4 -6 7
 BITMAP
-C6
-28
-44
-82
+CC
+30
+48
+84
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07AF
 ENCODING 1967
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 6 4 12 7
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 4 -6 7
 BITMAP
 18
 64
 88
 C0
 ENDCHAR
-STARTCHAR char1963
+STARTCHAR uni07B0
 ENCODING 1968
 SWIDTH 0 0
 DWIDTH 0 0
-BBX 4 4 11 7
+BBX 4 4 -6 7
 BITMAP
 60
 90
 90
 60
 ENDCHAR
-STARTCHAR 00FA
+STARTCHAR uni0901
 ENCODING 2305
 SWIDTH 0 0
 DWIDTH 0 0
@@ -25176,7 +25827,7 @@
 8C
 78
 ENDCHAR
-STARTCHAR 00F7
+STARTCHAR uni0902
 ENCODING 2306
 SWIDTH 0 0
 DWIDTH 0 0
@@ -25185,7 +25836,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 0048
+STARTCHAR uni0903
 ENCODING 2307
 SWIDTH 420 0
 DWIDTH 7 0
@@ -25201,7 +25852,7 @@
 E0
 40
 ENDCHAR
-STARTCHAR 0041
+STARTCHAR uni0905
 ENCODING 2309
 SWIDTH 840 0
 DWIDTH 14 0
@@ -25220,7 +25871,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0041
+STARTCHAR uni0906
 ENCODING 2310
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -25239,7 +25890,7 @@
 002100
 002100
 ENDCHAR
-STARTCHAR 0045
+STARTCHAR uni0907
 ENCODING 2311
 SWIDTH 600 0
 DWIDTH 10 0
@@ -25259,7 +25910,7 @@
 0200
 0100
 ENDCHAR
-STARTCHAR 0049
+STARTCHAR uni0908
 ENCODING 2312
 SWIDTH 600 0
 DWIDTH 10 0
@@ -25284,7 +25935,7 @@
 0200
 0100
 ENDCHAR
-STARTCHAR 0055
+STARTCHAR uni0909
 ENCODING 2313
 SWIDTH 900 0
 DWIDTH 15 0
@@ -25302,7 +25953,7 @@
 3180
 0F00
 ENDCHAR
-STARTCHAR 0055
+STARTCHAR uni090A
 ENCODING 2314
 SWIDTH 900 0
 DWIDTH 15 0
@@ -25320,7 +25971,7 @@
 3190
 0F00
 ENDCHAR
-STARTCHAR 003F
+STARTCHAR uni090B
 ENCODING 2315
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -25339,7 +25990,7 @@
 012000
 001C00
 ENDCHAR
-STARTCHAR 003B
+STARTCHAR uni090C
 ENCODING 2316
 SWIDTH 900 0
 DWIDTH 15 0
@@ -25359,7 +26010,7 @@
 1080
 0078
 ENDCHAR
-STARTCHAR 004F
+STARTCHAR uni090D
 ENCODING 2317
 SWIDTH 720 0
 DWIDTH 12 0
@@ -25387,7 +26038,7 @@
 0040
 0080
 ENDCHAR
-STARTCHAR 004F
+STARTCHAR uni090E
 ENCODING 2318
 SWIDTH 720 0
 DWIDTH 12 0
@@ -25415,7 +26066,7 @@
 0040
 0080
 ENDCHAR
-STARTCHAR 004F
+STARTCHAR uni090F
 ENCODING 2319
 SWIDTH 720 0
 DWIDTH 12 0
@@ -25438,7 +26089,7 @@
 0040
 0080
 ENDCHAR
-STARTCHAR 004F
+STARTCHAR uni0910
 ENCODING 2320
 SWIDTH 720 0
 DWIDTH 12 0
@@ -25466,7 +26117,7 @@
 0040
 0080
 ENDCHAR
-STARTCHAR 0041
+STARTCHAR uni0911
 ENCODING 2321
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -25489,7 +26140,7 @@
 002100
 002100
 ENDCHAR
-STARTCHAR 0041
+STARTCHAR uni0912
 ENCODING 2322
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -25513,7 +26164,7 @@
 002100
 002100
 ENDCHAR
-STARTCHAR 0041
+STARTCHAR uni0913
 ENCODING 2323
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -25537,7 +26188,7 @@
 002100
 002100
 ENDCHAR
-STARTCHAR 0041
+STARTCHAR uni0914
 ENCODING 2324
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -25562,7 +26213,7 @@
 002100
 002100
 ENDCHAR
-STARTCHAR 006B
+STARTCHAR uni0915
 ENCODING 2325
 SWIDTH 780 0
 DWIDTH 13 0
@@ -25580,7 +26231,7 @@
 0440
 0400
 ENDCHAR
-STARTCHAR 004B
+STARTCHAR uni0916
 ENCODING 2326
 SWIDTH 840 0
 DWIDTH 14 0
@@ -25598,7 +26249,7 @@
 1060
 0FA0
 ENDCHAR
-STARTCHAR 005E
+STARTCHAR uni0917
 ENCODING 2327
 SWIDTH 720 0
 DWIDTH 12 0
@@ -25616,7 +26267,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 0047
+STARTCHAR uni0918
 ENCODING 2328
 SWIDTH 780 0
 DWIDTH 13 0
@@ -25634,7 +26285,7 @@
 0080
 0080
 ENDCHAR
-STARTCHAR 007B
+STARTCHAR uni0919
 ENCODING 2329
 SWIDTH 780 0
 DWIDTH 13 0
@@ -25651,7 +26302,7 @@
 4100
 3E00
 ENDCHAR
-STARTCHAR 0063
+STARTCHAR uni091A
 ENCODING 2330
 SWIDTH 780 0
 DWIDTH 13 0
@@ -25669,7 +26320,7 @@
 0080
 0080
 ENDCHAR
-STARTCHAR 0043
+STARTCHAR uni091B
 ENCODING 2331
 SWIDTH 960 0
 DWIDTH 16 0
@@ -25688,7 +26339,7 @@
 1864
 0F84
 ENDCHAR
-STARTCHAR 006A
+STARTCHAR uni091C
 ENCODING 2332
 SWIDTH 840 0
 DWIDTH 14 0
@@ -25706,7 +26357,7 @@
 1C40
 0040
 ENDCHAR
-STARTCHAR 004A
+STARTCHAR uni091D
 ENCODING 2333
 SWIDTH 900 0
 DWIDTH 15 0
@@ -25725,7 +26376,7 @@
 0420
 0200
 ENDCHAR
-STARTCHAR 0057
+STARTCHAR uni091E
 ENCODING 2334
 SWIDTH 780 0
 DWIDTH 13 0
@@ -25743,7 +26394,7 @@
 0080
 0080
 ENDCHAR
-STARTCHAR 0058
+STARTCHAR uni091F
 ENCODING 2335
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25761,7 +26412,7 @@
 4300
 3E00
 ENDCHAR
-STARTCHAR 0059
+STARTCHAR uni0920
 ENCODING 2336
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25779,7 +26430,7 @@
 2180
 1F00
 ENDCHAR
-STARTCHAR 0052
+STARTCHAR uni0921
 ENCODING 2337
 SWIDTH 720 0
 DWIDTH 12 0
@@ -25796,7 +26447,7 @@
 4080
 3F00
 ENDCHAR
-STARTCHAR 005A
+STARTCHAR uni0922
 ENCODING 2338
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25814,7 +26465,7 @@
 2900
 1E00
 ENDCHAR
-STARTCHAR 004E
+STARTCHAR uni0923
 ENCODING 2339
 SWIDTH 840 0
 DWIDTH 14 0
@@ -25832,7 +26483,7 @@
 0040
 0040
 ENDCHAR
-STARTCHAR 0074
+STARTCHAR uni0924
 ENCODING 2340
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25851,7 +26502,7 @@
 2100
 1000
 ENDCHAR
-STARTCHAR 0054
+STARTCHAR uni0925
 ENCODING 2341
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25869,7 +26520,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 0064
+STARTCHAR uni0926
 ENCODING 2342
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25887,7 +26538,7 @@
 0200
 0100
 ENDCHAR
-STARTCHAR 0044
+STARTCHAR uni0927
 ENCODING 2343
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25905,7 +26556,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 006E
+STARTCHAR uni0928
 ENCODING 2344
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25923,7 +26574,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 006E
+STARTCHAR uni0929
 ENCODING 2345
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25941,7 +26592,7 @@
 0900
 0900
 ENDCHAR
-STARTCHAR 0070
+STARTCHAR uni092A
 ENCODING 2346
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25959,7 +26610,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni092B
 ENCODING 2347
 SWIDTH 840 0
 DWIDTH 14 0
@@ -25977,7 +26628,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0062
+STARTCHAR uni092C
 ENCODING 2348
 SWIDTH 660 0
 DWIDTH 11 0
@@ -25995,7 +26646,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0042
+STARTCHAR uni092D
 ENCODING 2349
 SWIDTH 720 0
 DWIDTH 12 0
@@ -26013,7 +26664,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 006D
+STARTCHAR uni092E
 ENCODING 2350
 SWIDTH 720 0
 DWIDTH 12 0
@@ -26031,7 +26682,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 0079
+STARTCHAR uni092F
 ENCODING 2351
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26049,7 +26700,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 0072
+STARTCHAR uni0930
 ENCODING 2352
 SWIDTH 600 0
 DWIDTH 10 0
@@ -26068,7 +26719,7 @@
 0400
 0200
 ENDCHAR
-STARTCHAR 0072
+STARTCHAR uni0931
 ENCODING 2353
 SWIDTH 600 0
 DWIDTH 10 0
@@ -26087,7 +26738,7 @@
 2400
 0200
 ENDCHAR
-STARTCHAR 006C
+STARTCHAR uni0932
 ENCODING 2354
 SWIDTH 840 0
 DWIDTH 14 0
@@ -26105,7 +26756,7 @@
 4020
 2020
 ENDCHAR
-STARTCHAR 004C
+STARTCHAR uni0933
 ENCODING 2355
 SWIDTH 840 0
 DWIDTH 14 0
@@ -26123,7 +26774,7 @@
 4498
 3870
 ENDCHAR
-STARTCHAR 004C
+STARTCHAR uni0934
 ENCODING 2356
 SWIDTH 840 0
 DWIDTH 14 0
@@ -26145,7 +26796,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0076
+STARTCHAR uni0935
 ENCODING 2357
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26163,7 +26814,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0053
+STARTCHAR uni0936
 ENCODING 2358
 SWIDTH 840 0
 DWIDTH 14 0
@@ -26181,7 +26832,7 @@
 0440
 0440
 ENDCHAR
-STARTCHAR 005C
+STARTCHAR uni0937
 ENCODING 2359
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26199,7 +26850,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0073
+STARTCHAR uni0938
 ENCODING 2360
 SWIDTH 780 0
 DWIDTH 13 0
@@ -26218,7 +26869,7 @@
 1080
 0800
 ENDCHAR
-STARTCHAR 0068
+STARTCHAR uni0939
 ENCODING 2361
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26239,7 +26890,7 @@
 0800
 0600
 ENDCHAR
-STARTCHAR 0026
+STARTCHAR uni093C
 ENCODING 2364
 SWIDTH 60 0
 DWIDTH 1 0
@@ -26248,7 +26899,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 007C
+STARTCHAR uni093D
 ENCODING 2365
 SWIDTH 600 0
 DWIDTH 10 0
@@ -26267,7 +26918,7 @@
 4C
 38
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni093E
 ENCODING 2366
 SWIDTH 360 0
 DWIDTH 6 0
@@ -26285,7 +26936,7 @@
 40
 40
 ENDCHAR
-STARTCHAR 0065
+STARTCHAR uni093F
 ENCODING 2367
 SWIDTH 360 0
 DWIDTH 6 0
@@ -26308,7 +26959,7 @@
 4000
 4000
 ENDCHAR
-STARTCHAR 0069
+STARTCHAR uni0940
 ENCODING 2368
 SWIDTH 300 0
 DWIDTH 5 0
@@ -26331,7 +26982,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 00D8
+STARTCHAR uni0941
 ENCODING 2369
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26342,7 +26993,7 @@
 61
 1F
 ENDCHAR
-STARTCHAR 00DC
+STARTCHAR uni0942
 ENCODING 2370
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26354,7 +27005,7 @@
 42
 30
 ENDCHAR
-STARTCHAR 00E0
+STARTCHAR uni0943
 ENCODING 2371
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26365,7 +27016,7 @@
 80
 78
 ENDCHAR
-STARTCHAR 00E4
+STARTCHAR uni0944
 ENCODING 2372
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26379,7 +27030,7 @@
 80
 7C
 ENDCHAR
-STARTCHAR 00F4
+STARTCHAR uni0945
 ENCODING 2373
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26389,7 +27040,7 @@
 44
 38
 ENDCHAR
-STARTCHAR 00F1
+STARTCHAR uni0946
 ENCODING 2374
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26401,7 +27052,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 00F1
+STARTCHAR uni0947
 ENCODING 2375
 SWIDTH 420 0
 DWIDTH 7 0
@@ -26413,7 +27064,7 @@
 04
 02
 ENDCHAR
-STARTCHAR 00F2
+STARTCHAR uni0948
 ENCODING 2376
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26426,7 +27077,7 @@
 06
 01
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni0949
 ENCODING 2377
 SWIDTH 420 0
 DWIDTH 7 0
@@ -26448,7 +27099,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni094A
 ENCODING 2378
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26471,7 +27122,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni094B
 ENCODING 2379
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26494,7 +27145,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni094C
 ENCODING 2380
 SWIDTH 720 0
 DWIDTH 12 0
@@ -26518,7 +27169,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 00CE
+STARTCHAR uni094D
 ENCODING 2381
 SWIDTH 0 0
 DWIDTH 0 0
@@ -26528,7 +27179,7 @@
 10
 08
 ENDCHAR
-STARTCHAR 0021
+STARTCHAR uni0950
 ENCODING 2384
 SWIDTH 960 0
 DWIDTH 16 0
@@ -26548,7 +27199,7 @@
 2300
 1E00
 ENDCHAR
-STARTCHAR 00F1
+STARTCHAR uni0951
 ENCODING 2385
 SWIDTH 60 0
 DWIDTH 1 0
@@ -26559,7 +27210,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni0952
 ENCODING 2386
 SWIDTH 240 0
 DWIDTH 4 0
@@ -26570,7 +27221,7 @@
 20
 10
 ENDCHAR
-STARTCHAR C019
+STARTCHAR uni0953
 ENCODING 2387
 SWIDTH 240 0
 DWIDTH 4 0
@@ -26581,7 +27232,7 @@
 40
 80
 ENDCHAR
-STARTCHAR 006B
+STARTCHAR uni0958
 ENCODING 2392
 SWIDTH 780 0
 DWIDTH 13 0
@@ -26599,7 +27250,7 @@
 2440
 2400
 ENDCHAR
-STARTCHAR 004B
+STARTCHAR uni0959
 ENCODING 2393
 SWIDTH 840 0
 DWIDTH 14 0
@@ -26621,7 +27272,7 @@
 0100
 0100
 ENDCHAR
-STARTCHAR 005E
+STARTCHAR uni095A
 ENCODING 2394
 SWIDTH 720 0
 DWIDTH 12 0
@@ -26639,7 +27290,7 @@
 0900
 0900
 ENDCHAR
-STARTCHAR 006A
+STARTCHAR uni095B
 ENCODING 2395
 SWIDTH 840 0
 DWIDTH 14 0
@@ -26661,7 +27312,7 @@
 0200
 0200
 ENDCHAR
-STARTCHAR 0052
+STARTCHAR uni095C
 ENCODING 2396
 SWIDTH 720 0
 DWIDTH 12 0
@@ -26683,7 +27334,7 @@
 0400
 0400
 ENDCHAR
-STARTCHAR 005A
+STARTCHAR uni095D
 ENCODING 2397
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26705,7 +27356,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni095E
 ENCODING 2398
 SWIDTH 840 0
 DWIDTH 14 0
@@ -26723,7 +27374,7 @@
 1220
 1200
 ENDCHAR
-STARTCHAR 0079
+STARTCHAR uni095F
 ENCODING 2399
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26745,7 +27396,7 @@
 1000
 1000
 ENDCHAR
-STARTCHAR 0040
+STARTCHAR uni0960
 ENCODING 2400
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -26766,7 +27417,7 @@
 001400
 000800
 ENDCHAR
-STARTCHAR 003D
+STARTCHAR uni0961
 ENCODING 2401
 SWIDTH 900 0
 DWIDTH 15 0
@@ -26788,7 +27439,7 @@
 0080
 0078
 ENDCHAR
-STARTCHAR 00E8
+STARTCHAR uni0962
 ENCODING 2402
 SWIDTH 480 0
 DWIDTH 8 0
@@ -26800,7 +27451,7 @@
 44
 03
 ENDCHAR
-STARTCHAR 00EC
+STARTCHAR uni0963
 ENCODING 2403
 SWIDTH 420 0
 DWIDTH 7 0
@@ -26814,7 +27465,7 @@
 08
 06
 ENDCHAR
-STARTCHAR 002E
+STARTCHAR uni0964
 ENCODING 2404
 SWIDTH 420 0
 DWIDTH 7 0
@@ -26832,7 +27483,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 002F
+STARTCHAR uni0965
 ENCODING 2405
 SWIDTH 540 0
 DWIDTH 9 0
@@ -26850,7 +27501,7 @@
 88
 88
 ENDCHAR
-STARTCHAR 0030
+STARTCHAR uni0966
 ENCODING 2406
 SWIDTH 360 0
 DWIDTH 6 0
@@ -26864,7 +27515,7 @@
 4C
 38
 ENDCHAR
-STARTCHAR 0031
+STARTCHAR uni0967
 ENCODING 2407
 SWIDTH 420 0
 DWIDTH 7 0
@@ -26886,7 +27537,7 @@
 38
 08
 ENDCHAR
-STARTCHAR 0032
+STARTCHAR uni0968
 ENCODING 2408
 SWIDTH 600 0
 DWIDTH 10 0
@@ -26905,7 +27556,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0033
+STARTCHAR uni0969
 ENCODING 2409
 SWIDTH 540 0
 DWIDTH 9 0
@@ -26925,7 +27576,7 @@
 04
 02
 ENDCHAR
-STARTCHAR 0034
+STARTCHAR uni096A
 ENCODING 2410
 SWIDTH 660 0
 DWIDTH 11 0
@@ -26942,7 +27593,7 @@
 1600
 0C00
 ENDCHAR
-STARTCHAR 0035
+STARTCHAR uni096B
 ENCODING 2411
 SWIDTH 600 0
 DWIDTH 10 0
@@ -26961,7 +27612,7 @@
 0080
 0080
 ENDCHAR
-STARTCHAR 0033
+STARTCHAR uni096C
 ENCODING 2412
 SWIDTH 480 0
 DWIDTH 8 0
@@ -26981,7 +27632,7 @@
 40
 80
 ENDCHAR
-STARTCHAR 0037
+STARTCHAR uni096D
 ENCODING 2413
 SWIDTH 780 0
 DWIDTH 13 0
@@ -26999,7 +27650,7 @@
 1880
 0700
 ENDCHAR
-STARTCHAR 0039
+STARTCHAR uni096E
 ENCODING 2414
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27017,7 +27668,7 @@
 4C
 38
 ENDCHAR
-STARTCHAR 0039
+STARTCHAR uni096F
 ENCODING 2415
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27038,7 +27689,7 @@
 0380
 0100
 ENDCHAR
-STARTCHAR 007D
+STARTCHAR uni0970
 ENCODING 2416
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27050,7 +27701,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0x0E01
+STARTCHAR uni0E01
 ENCODING 3585
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27066,7 +27717,7 @@
 82
 82
 ENDCHAR
-STARTCHAR 0x0E02
+STARTCHAR uni0E02
 ENCODING 3586
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27082,7 +27733,7 @@
 11
 3F
 ENDCHAR
-STARTCHAR 0x0E03
+STARTCHAR uni0E03
 ENCODING 3587
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27098,7 +27749,7 @@
 0880
 1F80
 ENDCHAR
-STARTCHAR 0x0E04
+STARTCHAR uni0E04
 ENCODING 3588
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27114,7 +27765,7 @@
 41
 41
 ENDCHAR
-STARTCHAR 0x0E05
+STARTCHAR uni0E05
 ENCODING 3589
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27130,7 +27781,7 @@
 41
 41
 ENDCHAR
-STARTCHAR 0x0E06
+STARTCHAR uni0E06
 ENCODING 3590
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27146,7 +27797,7 @@
 28C0
 1840
 ENDCHAR
-STARTCHAR 0x0E07
+STARTCHAR uni0E07
 ENCODING 3591
 SWIDTH 420 0
 DWIDTH 7 0
@@ -27162,7 +27813,7 @@
 14
 0C
 ENDCHAR
-STARTCHAR 0x0E08
+STARTCHAR uni0E08
 ENCODING 3592
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27178,7 +27829,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0x0E09
+STARTCHAR uni0E09
 ENCODING 3593
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27194,7 +27845,7 @@
 3280
 2100
 ENDCHAR
-STARTCHAR 0x0E0A
+STARTCHAR uni0E0A
 ENCODING 3594
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27210,7 +27861,7 @@
 1100
 3F00
 ENDCHAR
-STARTCHAR 0x0E0B
+STARTCHAR uni0E0B
 ENCODING 3595
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27226,7 +27877,7 @@
 0880
 1F80
 ENDCHAR
-STARTCHAR 0x0E0C
+STARTCHAR uni0E0C
 ENCODING 3596
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27242,7 +27893,7 @@
 B4C0
 4840
 ENDCHAR
-STARTCHAR 0x0E0D
+STARTCHAR uni0E0D
 ENCODING 3597
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27262,7 +27913,7 @@
 0A40
 0780
 ENDCHAR
-STARTCHAR 0x0E0E
+STARTCHAR uni0E0E
 ENCODING 3598
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27283,7 +27934,7 @@
 3180
 0080
 ENDCHAR
-STARTCHAR 0x0E0F
+STARTCHAR uni0E0F
 ENCODING 3599
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27304,7 +27955,7 @@
 3580
 0080
 ENDCHAR
-STARTCHAR 0x0E10
+STARTCHAR uni0E10
 ENCODING 3600
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27325,7 +27976,7 @@
 AA
 D4
 ENDCHAR
-STARTCHAR 0x0E11
+STARTCHAR uni0E11
 ENCODING 3601
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27341,7 +27992,7 @@
 0840
 0840
 ENDCHAR
-STARTCHAR 0x0E12
+STARTCHAR uni0E12
 ENCODING 3602
 SWIDTH 780 0
 DWIDTH 13 0
@@ -27357,7 +28008,7 @@
 6530
 6310
 ENDCHAR
-STARTCHAR 0x0E13
+STARTCHAR uni0E13
 ENCODING 3603
 SWIDTH 780 0
 DWIDTH 13 0
@@ -27373,7 +28024,7 @@
 A650
 4460
 ENDCHAR
-STARTCHAR 0x0E14
+STARTCHAR uni0E14
 ENCODING 3604
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27389,7 +28040,7 @@
 41
 41
 ENDCHAR
-STARTCHAR 0x0E15
+STARTCHAR uni0E15
 ENCODING 3605
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27405,7 +28056,7 @@
 41
 41
 ENDCHAR
-STARTCHAR 0x0E16
+STARTCHAR uni0E16
 ENCODING 3606
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27421,7 +28072,7 @@
 A2
 42
 ENDCHAR
-STARTCHAR 0x0E17
+STARTCHAR uni0E17
 ENCODING 3607
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27437,7 +28088,7 @@
 21
 21
 ENDCHAR
-STARTCHAR 0x0E18
+STARTCHAR uni0E18
 ENCODING 3608
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27453,7 +28104,7 @@
 24
 7C
 ENDCHAR
-STARTCHAR 0x0E19
+STARTCHAR uni0E19
 ENCODING 3609
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27469,7 +28120,7 @@
 3140
 2180
 ENDCHAR
-STARTCHAR 0x0E1A
+STARTCHAR uni0E1A
 ENCODING 3610
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27485,7 +28136,7 @@
 2080
 7F80
 ENDCHAR
-STARTCHAR 0x0E1B
+STARTCHAR uni0E1B
 ENCODING 3611
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27505,7 +28156,7 @@
 2080
 7F80
 ENDCHAR
-STARTCHAR 0x0E1C
+STARTCHAR uni0E1C
 ENCODING 3612
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27521,7 +28172,7 @@
 82
 82
 ENDCHAR
-STARTCHAR 0x0E1D
+STARTCHAR uni0E1D
 ENCODING 3613
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27541,7 +28192,7 @@
 82
 82
 ENDCHAR
-STARTCHAR 0x0E1E
+STARTCHAR uni0E1E
 ENCODING 3614
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27557,7 +28208,7 @@
 2040
 2040
 ENDCHAR
-STARTCHAR 0x0E1F
+STARTCHAR uni0E1F
 ENCODING 3615
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27577,7 +28228,7 @@
 2040
 2040
 ENDCHAR
-STARTCHAR 0x0E20
+STARTCHAR uni0E20
 ENCODING 3616
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27593,7 +28244,7 @@
 A080
 4080
 ENDCHAR
-STARTCHAR 0x0E21
+STARTCHAR uni0E21
 ENCODING 3617
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27609,7 +28260,7 @@
 A3
 61
 ENDCHAR
-STARTCHAR 0x0E22
+STARTCHAR uni0E22
 ENCODING 3618
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27625,7 +28276,7 @@
 82
 FC
 ENDCHAR
-STARTCHAR 0x0E23
+STARTCHAR uni0E23
 ENCODING 3619
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27641,7 +28292,7 @@
 14
 08
 ENDCHAR
-STARTCHAR 0x0E24
+STARTCHAR uni0E24
 ENCODING 3620
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27662,7 +28313,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0x0E25
+STARTCHAR uni0E25
 ENCODING 3621
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27678,7 +28329,7 @@
 A2
 42
 ENDCHAR
-STARTCHAR 0x0E26
+STARTCHAR uni0E26
 ENCODING 3622
 SWIDTH 600 0
 DWIDTH 10 0
@@ -27699,7 +28350,7 @@
 0080
 0080
 ENDCHAR
-STARTCHAR 0x0E27
+STARTCHAR uni0E27
 ENCODING 3623
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27715,7 +28366,7 @@
 0A
 04
 ENDCHAR
-STARTCHAR 0x0E28
+STARTCHAR uni0E28
 ENCODING 3624
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27732,7 +28383,7 @@
 41
 41
 ENDCHAR
-STARTCHAR 0x0E29
+STARTCHAR uni0E29
 ENCODING 3625
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27748,7 +28399,7 @@
 2100
 7F00
 ENDCHAR
-STARTCHAR 0x0E2A
+STARTCHAR uni0E2A
 ENCODING 3626
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27765,7 +28416,7 @@
 92
 62
 ENDCHAR
-STARTCHAR 0x0E2B
+STARTCHAR uni0E2B
 ENCODING 3627
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27781,7 +28432,7 @@
 21
 21
 ENDCHAR
-STARTCHAR 0x0E2C
+STARTCHAR uni0E2C
 ENCODING 3628
 SWIDTH 660 0
 DWIDTH 11 0
@@ -27798,7 +28449,7 @@
 2040
 2040
 ENDCHAR
-STARTCHAR 0x0E2D
+STARTCHAR uni0E2D
 ENCODING 3629
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27814,7 +28465,7 @@
 82
 FE
 ENDCHAR
-STARTCHAR 0x0E2E
+STARTCHAR uni0E2E
 ENCODING 3630
 SWIDTH 540 0
 DWIDTH 9 0
@@ -27830,7 +28481,7 @@
 82
 7E
 ENDCHAR
-STARTCHAR 0x0E2F
+STARTCHAR uni0E2F
 ENCODING 3631
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27846,7 +28497,7 @@
 06
 18
 ENDCHAR
-STARTCHAR 0x0E30
+STARTCHAR uni0E30
 ENCODING 3632
 SWIDTH 420 0
 DWIDTH 7 0
@@ -27862,7 +28513,7 @@
 C4
 78
 ENDCHAR
-STARTCHAR 0x0E31
+STARTCHAR uni0E31
 ENCODING 3633
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27873,7 +28524,7 @@
 C4
 78
 ENDCHAR
-STARTCHAR 0x0E32
+STARTCHAR uni0E32
 ENCODING 3634
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27889,7 +28540,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0x0E33
+STARTCHAR uni0E33
 ENCODING 3635
 SWIDTH 480 0
 DWIDTH 8 0
@@ -27911,7 +28562,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0x0E34
+STARTCHAR uni0E34
 ENCODING 3636
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27922,7 +28573,7 @@
 FE
 02
 ENDCHAR
-STARTCHAR 0x0E35
+STARTCHAR uni0E35
 ENCODING 3637
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27934,7 +28585,7 @@
 FE
 02
 ENDCHAR
-STARTCHAR 0x0E36
+STARTCHAR uni0E36
 ENCODING 3638
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27946,7 +28597,7 @@
 FE
 02
 ENDCHAR
-STARTCHAR 0x0E37
+STARTCHAR uni0E37
 ENCODING 3639
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27958,7 +28609,7 @@
 FE
 02
 ENDCHAR
-STARTCHAR 0x0E38
+STARTCHAR uni0E38
 ENCODING 3640
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27971,7 +28622,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 0x0E39
+STARTCHAR uni0E39
 ENCODING 3641
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27984,7 +28635,7 @@
 24
 18
 ENDCHAR
-STARTCHAR 0x0E3A
+STARTCHAR uni0E3A
 ENCODING 3642
 SWIDTH 0 0
 DWIDTH 0 0
@@ -27993,7 +28644,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR 0x0E3F
+STARTCHAR uni0E3F
 ENCODING 3647
 SWIDTH 660 0
 DWIDTH 11 0
@@ -28013,7 +28664,7 @@
 FC
 08
 ENDCHAR
-STARTCHAR 0x0E40
+STARTCHAR uni0E40
 ENCODING 3648
 SWIDTH 240 0
 DWIDTH 4 0
@@ -28029,7 +28680,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR 0x0E41
+STARTCHAR uni0E41
 ENCODING 3649
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28045,7 +28696,7 @@
 AA
 44
 ENDCHAR
-STARTCHAR 0x0E42
+STARTCHAR uni0E42
 ENCODING 3650
 SWIDTH 420 0
 DWIDTH 7 0
@@ -28069,7 +28720,7 @@
 14
 08
 ENDCHAR
-STARTCHAR 0x0E43
+STARTCHAR uni0E43
 ENCODING 3651
 SWIDTH 360 0
 DWIDTH 6 0
@@ -28093,7 +28744,7 @@
 14
 08
 ENDCHAR
-STARTCHAR 0x0E44
+STARTCHAR uni0E44
 ENCODING 3652
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28117,7 +28768,7 @@
 05
 02
 ENDCHAR
-STARTCHAR 0x0E45
+STARTCHAR uni0E45
 ENCODING 3653
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28138,7 +28789,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0x0E46
+STARTCHAR uni0E46
 ENCODING 3654
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28158,7 +28809,7 @@
 04
 18
 ENDCHAR
-STARTCHAR 0x0E47
+STARTCHAR uni0E47
 ENCODING 3655
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28170,7 +28821,7 @@
 F4
 18
 ENDCHAR
-STARTCHAR 0x0E48
+STARTCHAR uni0E48
 ENCODING 3656
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28180,7 +28831,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 0x0E49
+STARTCHAR uni0E49
 ENCODING 3657
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28191,7 +28842,7 @@
 44
 F8
 ENDCHAR
-STARTCHAR 0x0E4A
+STARTCHAR uni0E4A
 ENCODING 3658
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28202,7 +28853,7 @@
 D300
 D600
 ENDCHAR
-STARTCHAR 0x0E4B
+STARTCHAR uni0E4B
 ENCODING 3659
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28212,7 +28863,7 @@
 E0
 40
 ENDCHAR
-STARTCHAR 0x0E4C
+STARTCHAR uni0E4C
 ENCODING 3660
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28223,7 +28874,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR 0x0E4D
+STARTCHAR uni0E4D
 ENCODING 3661
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28234,7 +28885,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR 0x0E4E
+STARTCHAR uni0E4E
 ENCODING 3662
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28246,7 +28897,7 @@
 80
 60
 ENDCHAR
-STARTCHAR 0x0E4F
+STARTCHAR uni0E4F
 ENCODING 3663
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28261,7 +28912,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR 0x0E50
+STARTCHAR uni0E50
 ENCODING 3664
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28275,7 +28926,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR 0x0E51
+STARTCHAR uni0E51
 ENCODING 3665
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28290,7 +28941,7 @@
 32
 04
 ENDCHAR
-STARTCHAR 0x0E52
+STARTCHAR uni0E52
 ENCODING 3666
 SWIDTH 660 0
 DWIDTH 11 0
@@ -28307,7 +28958,7 @@
 4040
 3F80
 ENDCHAR
-STARTCHAR 0x0E53
+STARTCHAR uni0E53
 ENCODING 3667
 SWIDTH 600 0
 DWIDTH 10 0
@@ -28321,7 +28972,7 @@
 A880
 4900
 ENDCHAR
-STARTCHAR 0x0E54
+STARTCHAR uni0E54
 ENCODING 3668
 SWIDTH 720 0
 DWIDTH 12 0
@@ -28339,7 +28990,7 @@
 4700
 3FC0
 ENDCHAR
-STARTCHAR 0x0E55
+STARTCHAR uni0E55
 ENCODING 3669
 SWIDTH 720 0
 DWIDTH 12 0
@@ -28356,7 +29007,7 @@
 4E00
 3FC0
 ENDCHAR
-STARTCHAR 0x0E56
+STARTCHAR uni0E56
 ENCODING 3670
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28374,7 +29025,7 @@
 54
 38
 ENDCHAR
-STARTCHAR 0x0E57
+STARTCHAR uni0E57
 ENCODING 3671
 SWIDTH 720 0
 DWIDTH 12 0
@@ -28392,7 +29043,7 @@
 D180
 6300
 ENDCHAR
-STARTCHAR 0x0E58
+STARTCHAR uni0E58
 ENCODING 3672
 SWIDTH 660 0
 DWIDTH 11 0
@@ -28409,7 +29060,7 @@
 6480
 2300
 ENDCHAR
-STARTCHAR 0x0E59
+STARTCHAR uni0E59
 ENCODING 3673
 SWIDTH 600 0
 DWIDTH 10 0
@@ -28427,7 +29078,7 @@
 A900
 7100
 ENDCHAR
-STARTCHAR 0x0E5A
+STARTCHAR uni0E5A
 ENCODING 3674
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28443,7 +29094,7 @@
 05
 0A
 ENDCHAR
-STARTCHAR 0x0E5B
+STARTCHAR uni0E5B
 ENCODING 3675
 SWIDTH 840 0
 DWIDTH 14 0
@@ -28461,7 +29112,7 @@
 4400
 3800
 ENDCHAR
-STARTCHAR 0064
+STARTCHAR uni0E81
 ENCODING 3713
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28477,7 +29128,7 @@
 A2
 42
 ENDCHAR
-STARTCHAR 0030
+STARTCHAR uni0E82
 ENCODING 3714
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28493,7 +29144,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR 0037
+STARTCHAR uni0E84
 ENCODING 3716
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28509,7 +29160,7 @@
 B2
 72
 ENDCHAR
-STARTCHAR 0043
+STARTCHAR uni0E87
 ENCODING 3719
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28527,7 +29178,7 @@
 44
 38
 ENDCHAR
-STARTCHAR 0039
+STARTCHAR uni0E88
 ENCODING 3720
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28543,7 +29194,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 002D
+STARTCHAR uni0E8A
 ENCODING 3722
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28563,7 +29214,7 @@
 04
 02
 ENDCHAR
-STARTCHAR 0070
+STARTCHAR uni0E8D
 ENCODING 3725
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28579,7 +29230,7 @@
 C6
 7C
 ENDCHAR
-STARTCHAR 0066
+STARTCHAR uni0E94
 ENCODING 3732
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28595,7 +29246,7 @@
 A2
 62
 ENDCHAR
-STARTCHAR 0038
+STARTCHAR uni0E95
 ENCODING 3733
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28611,7 +29262,7 @@
 A2
 42
 ENDCHAR
-STARTCHAR 0034
+STARTCHAR uni0E96
 ENCODING 3734
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28631,7 +29282,7 @@
 01
 01
 ENDCHAR
-STARTCHAR 006D
+STARTCHAR uni0E97
 ENCODING 3735
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28647,7 +29298,7 @@
 89
 71
 ENDCHAR
-STARTCHAR 006F
+STARTCHAR uni0E99
 ENCODING 3737
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28663,7 +29314,7 @@
 21
 DE
 ENDCHAR
-STARTCHAR 005B
+STARTCHAR uni0E9A
 ENCODING 3738
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28679,7 +29330,7 @@
 C6
 7C
 ENDCHAR
-STARTCHAR 005B
+STARTCHAR uni0E9B
 ENCODING 3739
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28699,7 +29350,7 @@
 C6
 7C
 ENDCHAR
-STARTCHAR 007A
+STARTCHAR uni0E9C
 ENCODING 3740
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28715,7 +29366,7 @@
 92
 6C
 ENDCHAR
-STARTCHAR 002F
+STARTCHAR uni0E9D
 ENCODING 3741
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28735,7 +29386,7 @@
 92
 6C
 ENDCHAR
-STARTCHAR 0072
+STARTCHAR uni0E9E
 ENCODING 3742
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28751,7 +29402,7 @@
 92
 6C
 ENDCHAR
-STARTCHAR 0032
+STARTCHAR uni0E9F
 ENCODING 3743
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28771,7 +29422,7 @@
 92
 6C
 ENDCHAR
-STARTCHAR 002C
+STARTCHAR uni0EA1
 ENCODING 3745
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28787,7 +29438,7 @@
 B1
 4E
 ENDCHAR
-STARTCHAR 0070
+STARTCHAR uni0EA2
 ENCODING 3746
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28807,7 +29458,7 @@
 C6
 7C
 ENDCHAR
-STARTCHAR 0069
+STARTCHAR uni0EA3
 ENCODING 3747
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28823,7 +29474,7 @@
 C6
 7C
 ENDCHAR
-STARTCHAR 005D
+STARTCHAR uni0EA5
 ENCODING 3749
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28839,7 +29490,7 @@
 AA
 44
 ENDCHAR
-STARTCHAR 003B
+STARTCHAR uni0EA7
 ENCODING 3751
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28855,7 +29506,7 @@
 C2
 7C
 ENDCHAR
-STARTCHAR 006C
+STARTCHAR uni0EAA
 ENCODING 3754
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28871,7 +29522,7 @@
 AA
 44
 ENDCHAR
-STARTCHAR 0073
+STARTCHAR uni0EAB
 ENCODING 3755
 SWIDTH 720 0
 DWIDTH 12 0
@@ -28887,7 +29538,7 @@
 C620
 7C20
 ENDCHAR
-STARTCHAR 0076
+STARTCHAR uni0EAD
 ENCODING 3757
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28903,7 +29554,7 @@
 C2
 7C
 ENDCHAR
-STARTCHAR 0049
+STARTCHAR uni0EAE
 ENCODING 3758
 SWIDTH 540 0
 DWIDTH 9 0
@@ -28919,7 +29570,7 @@
 C6
 7C
 ENDCHAR
-STARTCHAR 004D
+STARTCHAR uni0EAF
 ENCODING 3759
 SWIDTH 480 0
 DWIDTH 8 0
@@ -28941,7 +29592,7 @@
 46
 3C
 ENDCHAR
-STARTCHAR 0074
+STARTCHAR uni0EB0
 ENCODING 3760
 SWIDTH 420 0
 DWIDTH 7 0
@@ -28955,7 +29606,7 @@
 A4
 7C
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni0EB1
 ENCODING 3761
 SWIDTH 0 0
 DWIDTH 0 0
@@ -28965,7 +29616,7 @@
 A1
 7E
 ENDCHAR
-STARTCHAR 006B
+STARTCHAR uni0EB2
 ENCODING 3762
 SWIDTH 420 0
 DWIDTH 7 0
@@ -28981,7 +29632,7 @@
 04
 04
 ENDCHAR
-STARTCHAR 0065
+STARTCHAR uni0EB3
 ENCODING 3763
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29002,7 +29653,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 0079
+STARTCHAR uni0EB4
 ENCODING 3764
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29012,7 +29663,7 @@
 82
 44
 ENDCHAR
-STARTCHAR 0075
+STARTCHAR uni0EB5
 ENCODING 3765
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29022,7 +29673,7 @@
 8280
 4700
 ENDCHAR
-STARTCHAR 0079
+STARTCHAR uni0EB6
 ENCODING 3766
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29032,7 +29683,7 @@
 92
 54
 ENDCHAR
-STARTCHAR 0075
+STARTCHAR uni0EB7
 ENCODING 3767
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29042,7 +29693,7 @@
 9280
 5700
 ENDCHAR
-STARTCHAR 0035
+STARTCHAR uni0EB8
 ENCODING 3768
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29054,7 +29705,7 @@
 20
 40
 ENDCHAR
-STARTCHAR 0036
+STARTCHAR uni0EB9
 ENCODING 3769
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29066,7 +29717,7 @@
 90
 60
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni0EBB
 ENCODING 3771
 SWIDTH 60 0
 DWIDTH 1 0
@@ -29076,7 +29727,7 @@
 A1
 40
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni0EBC
 ENCODING 3772
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29086,7 +29737,7 @@
 AC
 40
 ENDCHAR
-STARTCHAR 0050
+STARTCHAR uni0EBD
 ENCODING 3773
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29106,7 +29757,7 @@
 C6
 7C
 ENDCHAR
-STARTCHAR 0067
+STARTCHAR uni0EC0
 ENCODING 3776
 SWIDTH 360 0
 DWIDTH 6 0
@@ -29122,7 +29773,7 @@
 A8
 70
 ENDCHAR
-STARTCHAR 0067
+STARTCHAR uni0EC1
 ENCODING 3777
 SWIDTH 660 0
 DWIDTH 11 0
@@ -29138,7 +29789,7 @@
 AD40
 7380
 ENDCHAR
-STARTCHAR 0033
+STARTCHAR uni0EC2
 ENCODING 3778
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29160,7 +29811,7 @@
 0A
 04
 ENDCHAR
-STARTCHAR 002E
+STARTCHAR uni0EC3
 ENCODING 3779
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29182,7 +29833,7 @@
 14
 08
 ENDCHAR
-STARTCHAR 0077
+STARTCHAR uni0EC4
 ENCODING 3780
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29204,7 +29855,7 @@
 1A
 0C
 ENDCHAR
-STARTCHAR 004D
+STARTCHAR uni0EC6
 ENCODING 3782
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29226,7 +29877,7 @@
 46
 3C
 ENDCHAR
-STARTCHAR char3784
+STARTCHAR uni0EC8
 ENCODING 3784
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29236,7 +29887,7 @@
 80
 80
 ENDCHAR
-STARTCHAR 0068
+STARTCHAR uni0EC9
 ENCODING 3785
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29247,7 +29898,7 @@
 44
 FC
 ENDCHAR
-STARTCHAR 0048
+STARTCHAR uni0ECA
 ENCODING 3786
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29258,7 +29909,7 @@
 C3
 C6
 ENDCHAR
-STARTCHAR char3784
+STARTCHAR uni0ECB
 ENCODING 3787
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29268,7 +29919,7 @@
 E0
 40
 ENDCHAR
-STARTCHAR 0061
+STARTCHAR uni0ECC
 ENCODING 3788
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29279,7 +29930,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR 003D
+STARTCHAR uni0ECD
 ENCODING 3789
 SWIDTH 0 0
 DWIDTH 0 0
@@ -29290,7 +29941,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR 0057
+STARTCHAR uni0ED0
 ENCODING 3792
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29306,7 +29957,7 @@
 44
 38
 ENDCHAR
-STARTCHAR 0021
+STARTCHAR uni0ED1
 ENCODING 3793
 SWIDTH 540 0
 DWIDTH 9 0
@@ -29323,7 +29974,7 @@
 1C
 20
 ENDCHAR
-STARTCHAR 0040
+STARTCHAR uni0ED2
 ENCODING 3794
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29343,7 +29994,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR 0023
+STARTCHAR uni0ED3
 ENCODING 3795
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29363,7 +30014,7 @@
 B2
 6C
 ENDCHAR
-STARTCHAR 0024
+STARTCHAR uni0ED4
 ENCODING 3796
 SWIDTH 540 0
 DWIDTH 9 0
@@ -29383,7 +30034,7 @@
 84
 7B
 ENDCHAR
-STARTCHAR 0026
+STARTCHAR uni0ED5
 ENCODING 3797
 SWIDTH 540 0
 DWIDTH 9 0
@@ -29403,7 +30054,7 @@
 84
 7B
 ENDCHAR
-STARTCHAR 002A
+STARTCHAR uni0ED6
 ENCODING 3798
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29423,7 +30074,7 @@
 92
 6C
 ENDCHAR
-STARTCHAR 0028
+STARTCHAR uni0ED7
 ENCODING 3799
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29443,7 +30094,7 @@
 02
 02
 ENDCHAR
-STARTCHAR 0029
+STARTCHAR uni0ED8
 ENCODING 3800
 SWIDTH 540 0
 DWIDTH 9 0
@@ -29463,7 +30114,7 @@
 1680
 0900
 ENDCHAR
-STARTCHAR 005F
+STARTCHAR uni0ED9
 ENCODING 3801
 SWIDTH 600 0
 DWIDTH 10 0
@@ -29479,7 +30130,7 @@
 A880
 4700
 ENDCHAR
-STARTCHAR 007C
+STARTCHAR uni0EDC
 ENCODING 3804
 SWIDTH 960 0
 DWIDTH 16 0
@@ -29495,7 +30146,7 @@
 C622
 7CDC
 ENDCHAR
-STARTCHAR 005C
+STARTCHAR uni0EDD
 ENCODING 3805
 SWIDTH 960 0
 DWIDTH 16 0
@@ -29511,151 +30162,1090 @@
 C6B6
 7C4C
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER AN
-ENCODING 4256
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR F03C
+ENCODING 3840
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 16 1 0
 BITMAP
-DC
-66
-00
-E0
-40
-40
-40
-78
-04
-04
-0E
+0600
+0B00
+0900
+0600
+70F8
+0980
+0600
+0400
+EF60
+4620
+4B20
+4920
+44A0
+64A0
+3860
+0020
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER BAN
-ENCODING 4257
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR F023
+ENCODING 3841
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 9 1 -1
 BITMAP
-EE00
-4400
-4400
-4400
+EF00
+4600
+4900
+4D80
+4480
+6440
+3840
+0040
+0020
+ENDCHAR
+STARTCHAR F029
+ENCODING 3842
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 20 1 -4
+BITMAP
+1800
+2C00
+2400
+5900
+4200
 3C00
-0400
-0400
-0F00
-0080
-0080
-01C0
+0000
+7E30
+4248
+4230
+4200
+6C30
+1E48
+0330
+C100
+2200
+1100
+1900
+0D00
+0600
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER GAN
-ENCODING 4258
+STARTCHAR F029
+ENCODING 3843
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 20 1 -4
+BITMAP
+1800
+2C00
+2400
+5900
+4200
+3C00
+0030
+7E48
+4230
+4284
+4278
+6C00
+1E30
+0348
+C130
+2200
+1100
+1900
+0D00
+0600
+ENDCHAR
+STARTCHAR F022
+ENCODING 3844
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 11 1 0
+BBX 9 9 1 -1
 BITMAP
-FE00
-4400
-4400
-E400
-0400
-0400
+8300
+4480
+2480
+3280
+1880
+4F00
+2080
+1F00
 0E00
-0100
-0380
-0040
-00E0
-ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER DON
-ENCODING 4259
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
-BITMAP
-FE
-92
-10
-10
-38
-44
-82
-82
-82
-44
-38
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER EN
-ENCODING 4260
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR F022
+ENCODING 3845
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 9 2 -1
 BITMAP
-FE
-44
-44
-E4
-04
-04
-04
-04
-04
-04
-0E
+06
+09
+89
+45
+31
+9E
+41
+3E
+1C
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER VIN
-ENCODING 4261
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR F022
+ENCODING 3846
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 18 1 -10
 BITMAP
-FE00
-4400
-4400
-E400
+8300
+4480
+2480
+3280
+1880
+4F00
+2080
+1F00
+0E00
+0000
+0E00
 0400
-07C0
-0440
-04E0
 0400
 0400
-0E00
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER ZEN
-ENCODING 4262
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR F022
+ENCODING 3847
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 7 1 1
 BITMAP
-E000
-4000
-3C00
-0800
-0800
-0F00
-0880
-0880
-0880
-0880
-0700
+8322
+44AA
+24AA
+32A2
+18AA
+0F2A
+0022
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER TAN
-ENCODING 4263
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR F02D
+ENCODING 3851
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 2 0 6
 BITMAP
-1E00
-6400
-4400
-8400
-8580
-8640
-8440
-84E0
+E0
+40
+ENDCHAR
+STARTCHAR F02D
+ENCODING 3852
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 2 0 6
+BITMAP
+E0
+40
+ENDCHAR
+STARTCHAR F02C
+ENCODING 3853
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 15 1 -7
+BITMAP
+E0
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR F02C
+ENCODING 3854
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 15 1 -7
+BITMAP
+EE
+44
+44
+44
+44
+44
+44
+44
+44
+44
+44
+44
+44
+44
+44
+ENDCHAR
+STARTCHAR F02D
+ENCODING 3855
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 15 0 -7
+BITMAP
+E0
+40
+00
+E0
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR F02D
+ENCODING 3856
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 0 -7
+BITMAP
+EE
+44
+00
+38
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR F02D
+ENCODING 3857
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 0 -7
+BITMAP
+EE
+44
+00
+38
+10
+00
+38
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR F03B
+ENCODING 3860
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 9 0 1
+BITMAP
+30
+48
+30
+84
+78
+00
+30
+48
+30
+ENDCHAR
+STARTCHAR F02D
+ENCODING 3865
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 12 0 -7
+BITMAP
+E0
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR F03B
+ENCODING 3866
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 3 1 -1
+BITMAP
+60
+90
+60
+ENDCHAR
+STARTCHAR F03B
+ENCODING 3867
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 3 1 -1
+BITMAP
+6300
+9480
+6300
+ENDCHAR
+STARTCHAR F03B
+ENCODING 3868
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 7 1 -1
+BITMAP
+0C00
+1200
+0C00
+0000
+6300
+9480
+6300
+ENDCHAR
+STARTCHAR F03B
+ENCODING 3869
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 4 1 -1
+BITMAP
+90
+60
+60
+90
+ENDCHAR
+STARTCHAR F03B
+ENCODING 3870
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 4 1 -1
+BITMAP
+9240
+6180
+6180
+9240
+ENDCHAR
+STARTCHAR F03B
+ENCODING 3871
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 4 1 -1
+BITMAP
+6240
+B180
+9180
+6240
+ENDCHAR
+STARTCHAR F030
+ENCODING 3872
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 8 0 1
+BITMAP
+38
+6C
+C4
+84
+84
+8C
+E8
+70
+ENDCHAR
+STARTCHAR F031
+ENCODING 3873
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 12 1 -3
+BITMAP
+38
+2C
+64
+64
+64
+44
+08
+08
+10
+20
+40
+80
+ENDCHAR
+STARTCHAR F032
+ENCODING 3874
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 2 -3
+BITMAP
+3C
+64
+C4
+08
+18
+3C
+42
+02
+02
+04
+ENDCHAR
+STARTCHAR F033
+ENCODING 3875
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 10 3 -3
+BITMAP
+FC
+04
+38
+7C
+04
+3C
+42
+02
+02
+04
+ENDCHAR
+STARTCHAR F034
+ENCODING 3876
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 8 1 1
+BITMAP
+1000
+7800
+6800
+4C00
+6700
+3000
+1800
+07C0
+ENDCHAR
+STARTCHAR F035
+ENCODING 3877
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 12 0 -4
+BITMAP
+C6
+84
+8C
+8C
+F8
+08
+08
+08
+08
+08
+04
+04
+ENDCHAR
+STARTCHAR F036
+ENCODING 3878
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 1
+BITMAP
+40
+40
+80
+80
+84
+8C
+90
+98
+84
+C4
+78
+ENDCHAR
+STARTCHAR F037
+ENCODING 3879
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 6 1 3
+BITMAP
+7880
+8480
+0480
+0980
+1F00
+2000
+ENDCHAR
+STARTCHAR F038
+ENCODING 3880
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 2 -2
+BITMAP
+08
+18
+30
+60
+C0
+F0
+18
+0C
+04
+04
+ENDCHAR
+STARTCHAR F039
+ENCODING 3881
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 12 0 -4
+BITMAP
+0F00
+1180
+3380
+2700
+6C00
+4800
+4E00
+4000
+4000
+8000
+8000
+8000
+ENDCHAR
+STARTCHAR F031
+ENCODING 3882
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 1 -3
+BITMAP
+0E00
+0B00
+1900
+1BC0
+1D20
+1920
+2220
+4240
+8480
+0800
+1000
+2000
+ENDCHAR
+STARTCHAR F032
+ENCODING 3883
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 10 2 -3
+BITMAP
+3C00
+6400
+C7C0
+0C20
+1820
+3C20
+4240
+8200
+0200
+0400
+ENDCHAR
+STARTCHAR F033
+ENCODING 3884
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 10 2 -3
+BITMAP
+FC00
+07C0
+3C20
+7C20
+2420
+7C40
+C200
+0200
+0200
+0400
+ENDCHAR
+STARTCHAR F034
+ENCODING 3885
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 10 2 -1
+BITMAP
+0800
+3C00
+3400
+2600
+33C0
+1C20
+1C20
+23E0
+4040
+8080
+ENDCHAR
+STARTCHAR F035
+ENCODING 3886
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 2 -4
+BITMAP
+03C0
+6720
+5A20
+6620
+4640
+FC80
+0400
+0400
+0400
+0400
+0400
+0200
+0200
+ENDCHAR
+STARTCHAR F036
+ENCODING 3887
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 1 -1
+BITMAP
+0800
+0800
+1000
+1000
+1080
+1180
+1200
+13C0
+14A0
+18A0
+2F20
+4040
+8080
+ENDCHAR
+STARTCHAR F037
+ENCODING 3888
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 6 1 3
+BITMAP
+78F0
+8588
+0688
+0988
+1F10
+2020
+ENDCHAR
+STARTCHAR F038
+ENCODING 3889
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 10 2 -2
+BITMAP
+0800
+1800
+3000
+63C0
+C420
+F820
+3820
+4C40
+8480
+0400
+ENDCHAR
+STARTCHAR F039
+ENCODING 3890
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 1 -4
+BITMAP
+0780
+08C0
+19C0
+13C0
+3620
+3C20
+2720
+6040
+A080
+4000
+4000
+4000
+ENDCHAR
+STARTCHAR F030
+ENCODING 3891
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 8 1 1
+BITMAP
+1C00
+37C0
+6620
+5A20
+6220
+4640
+F480
+3800
+ENDCHAR
+STARTCHAR F02D
+ENCODING 3892
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 8 2 0
+BITMAP
+E0
+40
+00
+C0
+A0
+00
+C0
+A0
+ENDCHAR
+STARTCHAR F026
+ENCODING 3893
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 6 -9 -7
+BITMAP
+30
+58
+48
+B0
+84
+78
+ENDCHAR
+STARTCHAR F02D
+ENCODING 3894
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 9 1 0
+BITMAP
+0800
+1C00
+0800
+4100
+E380
+4100
+0800
+1C00
+0800
+ENDCHAR
+STARTCHAR F026
+ENCODING 3895
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 4 -8 -5
+BITMAP
+60
+B0
+90
+60
+ENDCHAR
+STARTCHAR F040
+ENCODING 3904
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 0 -7
+BITMAP
+FF
+49
+49
+C9
+89
+09
+09
+01
+01
+01
+01
+01
+01
+01
+01
+ENDCHAR
+STARTCHAR F043
+ENCODING 3905
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -7
+BITMAP
+FF
+C9
+D1
+D1
+9D
+87
+81
+81
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR F043
+ENCODING 3906
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 0 -7
+BITMAP
+7F80
+4980
+8980
+8980
+E880
+3880
+0880
+0880
+0080
+0080
+0080
+0080
+0080
+0080
+0080
+ENDCHAR
+STARTCHAR F042
+ENCODING 3907
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 14 0 -6
+BITMAP
+FF
+49
+89
+E9
+39
+09
+7D
+21
+61
+7E
+11
+01
+02
+04
+ENDCHAR
+STARTCHAR F045
+ENCODING 3908
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 8 0 -1
+BITMAP
+7C
+40
+40
+80
+F8
+06
+01
+01
+ENDCHAR
+STARTCHAR F046
+ENCODING 3909
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 9 0 0
+BITMAP
+7F
+08
+08
+1C
+E2
+41
+21
+11
+0E
+ENDCHAR
+STARTCHAR F047
+ENCODING 3910
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 9 0 0
+BITMAP
+7F00
+0800
+0800
+3E00
+4900
+8880
+8880
+8880
+7700
+ENDCHAR
+STARTCHAR F059
+ENCODING 3933
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 9 0 -1
+BITMAP
+73
+91
+91
+3F
+21
+31
+3D
+07
+01
+ENDCHAR
+STARTCHAR uni10A0
+ENCODING 4256
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+DC
+66
+00
+E0
+40
+40
+40
+78
+04
+04
+0E
+ENDCHAR
+STARTCHAR uni10A1
+ENCODING 4257
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+EE00
+4400
+4400
+4400
+3C00
+0400
+0400
+0F00
+0080
+0080
+01C0
+ENDCHAR
+STARTCHAR uni10A2
+ENCODING 4258
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 1 0
+BITMAP
+FE00
+4400
+4400
+E400
+0400
+0400
+0E00
+0100
+0380
+0040
+00E0
+ENDCHAR
+STARTCHAR uni10A3
+ENCODING 4259
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+FE
+92
+10
+10
+38
+44
+82
+82
+82
+44
+38
+ENDCHAR
+STARTCHAR uni10A4
+ENCODING 4260
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+FE
+44
+44
+E4
+04
+04
+04
+04
+04
+04
+0E
+ENDCHAR
+STARTCHAR uni10A5
+ENCODING 4261
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+FE00
+4400
+4400
+E400
+0400
+07C0
+0440
+04E0
+0400
+0400
+0E00
+ENDCHAR
+STARTCHAR uni10A6
+ENCODING 4262
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+E000
+4000
+3C00
+0800
+0800
+0F00
+0880
+0880
+0880
+0880
+0700
+ENDCHAR
+STARTCHAR uni10A7
+ENCODING 4263
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+1E00
+6400
+4400
+8400
+8580
+8640
+8440
+84E0
 4400
 6400
 1E00
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER IN
+STARTCHAR uni10A8
 ENCODING 4264
 SWIDTH 420 0
 DWIDTH 7 0
@@ -29673,7 +31263,7 @@
 08
 1C
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER KAN
+STARTCHAR uni10A9
 ENCODING 4265
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29691,7 +31281,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER LAS
+STARTCHAR uni10AA
 ENCODING 4266
 SWIDTH 600 0
 DWIDTH 10 0
@@ -29709,7 +31299,7 @@
 0880
 0700
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER MAN
+STARTCHAR uni10AB
 ENCODING 4267
 SWIDTH 600 0
 DWIDTH 10 0
@@ -29727,7 +31317,7 @@
 8880
 71C0
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER NAR
+STARTCHAR uni10AC
 ENCODING 4268
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29745,7 +31335,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER ON
+STARTCHAR uni10AD
 ENCODING 4269
 SWIDTH 660 0
 DWIDTH 11 0
@@ -29763,7 +31353,7 @@
 6C40
 1380
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER PAR
+STARTCHAR uni10AE
 ENCODING 4270
 SWIDTH 660 0
 DWIDTH 11 0
@@ -29781,7 +31371,7 @@
 0880
 0700
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER ZHAR
+STARTCHAR uni10AF
 ENCODING 4271
 SWIDTH 540 0
 DWIDTH 9 0
@@ -29799,7 +31389,7 @@
 02
 07
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER RAE
+STARTCHAR uni10B0
 ENCODING 4272
 SWIDTH 600 0
 DWIDTH 10 0
@@ -29817,7 +31407,7 @@
 8800
 7000
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER SAN
+STARTCHAR uni10B1
 ENCODING 4273
 SWIDTH 360 0
 DWIDTH 6 0
@@ -29835,7 +31425,7 @@
 44
 38
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER TAR
+STARTCHAR uni10B2
 ENCODING 4274
 SWIDTH 420 0
 DWIDTH 7 0
@@ -29853,7 +31443,7 @@
 08
 1C
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER UN
+STARTCHAR uni10B3
 ENCODING 4275
 SWIDTH 660 0
 DWIDTH 11 0
@@ -29871,7 +31461,7 @@
 6C40
 10E0
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER PHAR
+STARTCHAR uni10B4
 ENCODING 4276
 SWIDTH 600 0
 DWIDTH 10 0
@@ -29889,7 +31479,7 @@
 0800
 1C00
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER KHAR
+STARTCHAR uni10B5
 ENCODING 4277
 SWIDTH 600 0
 DWIDTH 10 0
@@ -29907,7 +31497,7 @@
 0800
 1C00
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER GHAN
+STARTCHAR uni10B6
 ENCODING 4278
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29925,7 +31515,7 @@
 44
 EE
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER QAR
+STARTCHAR uni10B7
 ENCODING 4279
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29943,7 +31533,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER SHIN
+STARTCHAR uni10B8
 ENCODING 4280
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29961,7 +31551,7 @@
 44
 38
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER CHIN
+STARTCHAR uni10B9
 ENCODING 4281
 SWIDTH 480 0
 DWIDTH 8 0
@@ -29979,7 +31569,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER CAN
+STARTCHAR uni10BA
 ENCODING 4282
 SWIDTH 720 0
 DWIDTH 12 0
@@ -29997,7 +31587,7 @@
 62E0
 1C00
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER JIL
+STARTCHAR uni10BB
 ENCODING 4283
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30015,7 +31605,7 @@
 8880
 71C0
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER CIL
+STARTCHAR uni10BC
 ENCODING 4284
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30033,7 +31623,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER CHAR
+STARTCHAR uni10BD
 ENCODING 4285
 SWIDTH 540 0
 DWIDTH 9 0
@@ -30051,7 +31641,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER XAN
+STARTCHAR uni10BE
 ENCODING 4286
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30069,7 +31659,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER JHANe
+STARTCHAR uni10BF
 ENCODING 4287
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30087,7 +31677,7 @@
 4800
 FC00
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER HAE
+STARTCHAR uni10C0
 ENCODING 4288
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30105,7 +31695,7 @@
 0880
 0700
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER HE
+STARTCHAR uni10C1
 ENCODING 4289
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30123,7 +31713,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER HIE
+STARTCHAR uni10C2
 ENCODING 4290
 SWIDTH 540 0
 DWIDTH 9 0
@@ -30141,7 +31731,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER WE
+STARTCHAR uni10C3
 ENCODING 4291
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30159,7 +31749,7 @@
 04
 0E
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER HAR
+STARTCHAR uni10C4
 ENCODING 4292
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30177,7 +31767,7 @@
 10
 38
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER HOE
+STARTCHAR uni10C5
 ENCODING 4293
 SWIDTH 660 0
 DWIDTH 11 0
@@ -30195,7 +31785,7 @@
 8880
 71C0
 ENDCHAR
-STARTCHAR GEORGIAN LETTER AN
+STARTCHAR uni10D0
 ENCODING 4304
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30209,7 +31799,7 @@
 84
 78
 ENDCHAR
-STARTCHAR GEORGIAN LETTER BAN
+STARTCHAR uni10D1
 ENCODING 4305
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30228,7 +31818,7 @@
 84
 78
 ENDCHAR
-STARTCHAR GEORGIAN LETTER GAN
+STARTCHAR uni10D2
 ENCODING 4306
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30246,7 +31836,7 @@
 44
 38
 ENDCHAR
-STARTCHAR GEORGIAN LETTER DON
+STARTCHAR uni10D3
 ENCODING 4307
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30263,7 +31853,7 @@
 8400
 0200
 ENDCHAR
-STARTCHAR GEORGIAN LETTER EN
+STARTCHAR uni10D4
 ENCODING 4308
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30281,7 +31871,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER VIN
+STARTCHAR uni10D5
 ENCODING 4309
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30299,7 +31889,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER ZEN
+STARTCHAR uni10D6
 ENCODING 4310
 SWIDTH 540 0
 DWIDTH 9 0
@@ -30318,7 +31908,7 @@
 11
 0E
 ENDCHAR
-STARTCHAR GEORGIAN LETTER TAN
+STARTCHAR uni10D7
 ENCODING 4311
 SWIDTH 660 0
 DWIDTH 11 0
@@ -30332,7 +31922,7 @@
 4880
 3100
 ENDCHAR
-STARTCHAR GEORGIAN LETTER IN
+STARTCHAR uni10D8
 ENCODING 4312
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30346,7 +31936,7 @@
 84
 48
 ENDCHAR
-STARTCHAR GEORGIAN LETTER KAN
+STARTCHAR uni10D9
 ENCODING 4313
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30364,7 +31954,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER LAS
+STARTCHAR uni10DA
 ENCODING 4314
 SWIDTH 840 0
 DWIDTH 14 0
@@ -30381,7 +31971,7 @@
 80C0
 0020
 ENDCHAR
-STARTCHAR GEORGIAN LETTER MAN
+STARTCHAR uni10DB
 ENCODING 4315
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30399,7 +31989,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER NAR
+STARTCHAR uni10DC
 ENCODING 4316
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30417,7 +32007,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER ON
+STARTCHAR uni10DD
 ENCODING 4317
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30431,7 +32021,7 @@
 8080
 4100
 ENDCHAR
-STARTCHAR GEORGIAN LETTER PAR
+STARTCHAR uni10DE
 ENCODING 4318
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30450,7 +32040,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER ZHAR
+STARTCHAR uni10DF
 ENCODING 4319
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30468,7 +32058,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER RAE
+STARTCHAR uni10E0
 ENCODING 4320
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30487,7 +32077,7 @@
 8080
 4100
 ENDCHAR
-STARTCHAR GEORGIAN LETTER SAN
+STARTCHAR uni10E1
 ENCODING 4321
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30505,7 +32095,7 @@
 22
 1C
 ENDCHAR
-STARTCHAR GEORGIAN LETTER TAR
+STARTCHAR uni10E2
 ENCODING 4322
 SWIDTH 540 0
 DWIDTH 9 0
@@ -30526,7 +32116,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR GEORGIAN LETTER UN
+STARTCHAR uni10E3
 ENCODING 4323
 SWIDTH 540 0
 DWIDTH 9 0
@@ -30544,7 +32134,7 @@
 11
 0E
 ENDCHAR
-STARTCHAR GEORGIAN LETTER PHAR
+STARTCHAR uni10E4
 ENCODING 4324
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30562,7 +32152,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR GEORGIAN LETTER KHAR
+STARTCHAR uni10E5
 ENCODING 4325
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30585,7 +32175,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER GHAN
+STARTCHAR uni10E6
 ENCODING 4326
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30602,7 +32192,7 @@
 8200
 0100
 ENDCHAR
-STARTCHAR GEORGIAN LETTER QAR
+STARTCHAR uni10E7
 ENCODING 4327
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30620,7 +32210,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER SHIN
+STARTCHAR uni10E8
 ENCODING 4328
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30638,7 +32228,7 @@
 22
 1C
 ENDCHAR
-STARTCHAR GEORGIAN LETTER CHIN
+STARTCHAR uni10E9
 ENCODING 4329
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30656,7 +32246,7 @@
 88
 90
 ENDCHAR
-STARTCHAR GEORGIAN LETTER CAN
+STARTCHAR uni10EA
 ENCODING 4330
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30674,7 +32264,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR GEORGIAN LETTER JIL
+STARTCHAR uni10EB
 ENCODING 4331
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30692,7 +32282,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER CIL
+STARTCHAR uni10EC
 ENCODING 4332
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30714,7 +32304,7 @@
 10
 10
 ENDCHAR
-STARTCHAR GEORGIAN LETTER CHAR
+STARTCHAR uni10ED
 ENCODING 4333
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30737,7 +32327,7 @@
 84
 78
 ENDCHAR
-STARTCHAR GEORGIAN LETTER XAN
+STARTCHAR uni10EE
 ENCODING 4334
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30755,7 +32345,7 @@
 22
 1C
 ENDCHAR
-STARTCHAR GEORGIAN LETTER JHAN
+STARTCHAR uni10EF
 ENCODING 4335
 SWIDTH 660 0
 DWIDTH 11 0
@@ -30773,7 +32363,7 @@
 1180
 E000
 ENDCHAR
-STARTCHAR GEORGIAN LETTER HAE
+STARTCHAR uni10F0
 ENCODING 4336
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30791,7 +32381,7 @@
 84
 78
 ENDCHAR
-STARTCHAR GEORGIAN LETTER HE
+STARTCHAR uni10F1
 ENCODING 4337
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30809,7 +32399,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR GEORGIAN LETTER HIE
+STARTCHAR uni10F2
 ENCODING 4338
 SWIDTH 480 0
 DWIDTH 8 0
@@ -30823,7 +32413,7 @@
 92
 EE
 ENDCHAR
-STARTCHAR GEORGIAN LETTER WE
+STARTCHAR uni10F3
 ENCODING 4339
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30841,7 +32431,7 @@
 84
 78
 ENDCHAR
-STARTCHAR GEORGIAN LETTER HAR
+STARTCHAR uni10F4
 ENCODING 4340
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30859,7 +32449,7 @@
 84
 78
 ENDCHAR
-STARTCHAR GEORGIAN LETTER HOE
+STARTCHAR uni10F5
 ENCODING 4341
 SWIDTH 420 0
 DWIDTH 7 0
@@ -30877,7 +32467,7 @@
 88
 70
 ENDCHAR
-STARTCHAR GEORGIAN LETTER FI
+STARTCHAR uni10F6
 ENCODING 4342
 SWIDTH 600 0
 DWIDTH 10 0
@@ -30900,7 +32490,7 @@
 0880
 0700
 ENDCHAR
-STARTCHAR GEORGIAN PARAGRAPH SEPARATOR
+STARTCHAR uni10FB
 ENCODING 4347
 SWIDTH 360 0
 DWIDTH 6 0
@@ -30913,11 +32503,11 @@
 C0
 C0
 ENDCHAR
-STARTCHAR 3131
+STARTCHAR uni1100
 ENCODING 4352
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 10 2 0
+BBX 11 10 3 0
 BITMAP
 8000
 FFE0
@@ -30930,7 +32520,7 @@
 0020
 0020
 ENDCHAR
-STARTCHAR 3132
+STARTCHAR uni1101
 ENCODING 4353
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -30946,11 +32536,11 @@
 0410
 0410
 ENDCHAR
-STARTCHAR 3134
+STARTCHAR uni1102
 ENCODING 4354
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 7 3 2
+BBX 12 7 2 2
 BITMAP
 C000
 4000
@@ -30960,11 +32550,11 @@
 4060
 3FF0
 ENDCHAR
-STARTCHAR 3137
+STARTCHAR uni1103
 ENCODING 4355
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 8 3 2
+BBX 12 8 2 2
 BITMAP
 0040
 FFE0
@@ -30972,29 +32562,30 @@
 4000
 4000
 4000
-4070
+4060
 7FF0
 ENDCHAR
-STARTCHAR 3138
+STARTCHAR uni1104
 ENCODING 4356
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 8 2 1
+BBX 13 9 2 1
 BITMAP
+0820
 FDF0
 4100
 4100
 4100
 4100
 4300
-4D00
+4D10
 71F8
 ENDCHAR
-STARTCHAR 3139
+STARTCHAR uni1105
 ENCODING 4357
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 9 3 1
+BBX 12 9 2 1
 BITMAP
 0040
 FFC0
@@ -31006,7 +32597,7 @@
 4060
 7FF0
 ENDCHAR
-STARTCHAR 3141
+STARTCHAR uni1106
 ENCODING 4358
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31021,7 +32612,7 @@
 7FC0
 4000
 ENDCHAR
-STARTCHAR 3142
+STARTCHAR uni1107
 ENCODING 4359
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31037,9 +32628,9 @@
 4040
 4040
 7FC0
-0040
+4040
 ENDCHAR
-STARTCHAR 3143
+STARTCHAR uni1108
 ENCODING 4360
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31057,11 +32648,11 @@
 7CF8
 4488
 ENDCHAR
-STARTCHAR 3145
+STARTCHAR uni1109
 ENCODING 4361
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 9 3 1
+BBX 12 9 2 1
 BITMAP
 0800
 0600
@@ -31073,23 +32664,23 @@
 4020
 8010
 ENDCHAR
-STARTCHAR 3146
+STARTCHAR uni110A
 ENCODING 4362
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 9 2 1
+BBX 14 9 2 1
 BITMAP
-1040
+1860
+0C30
 0820
 0820
-1040
-18C0
-27A0
-4110
-8208
-0008
+1450
+1248
+2184
+4104
+8200
 ENDCHAR
-STARTCHAR 3147
+STARTCHAR uni110B
 ENCODING 4363
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31105,7 +32696,7 @@
 4100
 3E00
 ENDCHAR
-STARTCHAR 3148
+STARTCHAR uni110C
 ENCODING 4364
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31121,27 +32712,28 @@
 60C0
 8040
 ENDCHAR
-STARTCHAR 3149
+STARTCHAR uni110D
 ENCODING 4365
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 9 1 1
+BBX 14 10 2 0
 BITMAP
 0204
 7F7C
-2820
 0820
 0820
-1658
+0820
+1450
+1248
 2184
-4102
+4104
 8200
 ENDCHAR
-STARTCHAR 314A
+STARTCHAR uni110E
 ENCODING 4366
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 9 3 1
+BBX 11 9 2 1
 BITMAP
 1F00
 0000
@@ -31150,17 +32742,17 @@
 0400
 0A00
 1180
-2060
+2040
 C020
 ENDCHAR
-STARTCHAR 314B
+STARTCHAR uni110F
 ENCODING 4367
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 10 10 3 1
 BITMAP
-0040
-FFC0
+00C0
+FF40
 6040
 0040
 01C0
@@ -31170,38 +32762,39 @@
 0080
 0080
 ENDCHAR
-STARTCHAR 314C
+STARTCHAR uni1110
 ENCODING 4368
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 8 3 1
+BBX 12 9 2 1
 BITMAP
+00C0
 FFE0
-4000
 4000
+4180
 7FC0
 4000
 4000
-4070
+4060
 7FF0
 ENDCHAR
-STARTCHAR 314D
+STARTCHAR uni1111
 ENCODING 4369
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 9 2 1
 BITMAP
-0030
+4060
 7FF0
-20C0
-0040
-10C0
+0000
+00C0
+1040
 0880
-0890
-0BF8
-FC00
+0880
+8130
+FFF8
 ENDCHAR
-STARTCHAR 314E
+STARTCHAR uni1112
 ENCODING 4370
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31211,18 +32804,18 @@
 0010
 FFF8
 0200
-0D00
-10C0
+0F80
 1040
 1040
-18C0
+1040
+1040
 0F80
 ENDCHAR
-STARTCHAR 3165
+STARTCHAR uni1113
 ENCODING 4371
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 9 2 1
+BBX 10 9 3 1
 BITMAP
 0400
 C7C0
@@ -31234,7 +32827,7 @@
 5840
 2040
 ENDCHAR
-STARTCHAR 3165
+STARTCHAR uni1114
 ENCODING 4372
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31250,7 +32843,7 @@
 59F8
 2000
 ENDCHAR
-STARTCHAR 3166
+STARTCHAR uni1115
 ENCODING 4373
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31262,28 +32855,28 @@
 4100
 4100
 4100
-4100
-5D18
+4500
+5910
 61F8
 ENDCHAR
-STARTCHAR 3166
+STARTCHAR uni1116
 ENCODING 4374
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 10 2 1
 BITMAP
-0020
+0030
 0310
 C110
 4110
 41F0
 4110
 4110
-4110
-5DF0
+4510
+59F0
 6110
 ENDCHAR
-STARTCHAR 3166
+STARTCHAR uni1117
 ENCODING 4375
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31296,10 +32889,10 @@
 8010
 8010
 8010
-8C10
+8810
 FC10
 ENDCHAR
-STARTCHAR 316A
+STARTCHAR uni1118
 ENCODING 4376
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31314,7 +32907,7 @@
 4258
 7C20
 ENDCHAR
-STARTCHAR 316A
+STARTCHAR uni1119
 ENCODING 4377
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -31329,10372 +32922,11422 @@
 4284
 7CF8
 ENDCHAR
-STARTCHAR 316D
+STARTCHAR uni111A
 ENCODING 4378
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 9 1 1
+BBX 15 9 2 1
 BITMAP
 0004
 FDFE
 4800
 0820
-F878
+F870
 4088
-4084
+4088
 4288
-7C78
+7C70
 ENDCHAR
-STARTCHAR 317F
-ENCODING 4416
+STARTCHAR uni111B
+ENCODING 4379
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 9 4 1
+BBX 9 14 4 -1
 BITMAP
-0800
+FF80
+0100
+0100
+FF80
+4000
+4000
+7F80
 0800
-1400
-1200
-2200
+3E00
 4100
-4080
-8080
-FFC0
+4100
+4100
+4100
+3E00
 ENDCHAR
-STARTCHAR 3182
-ENCODING 4421
+STARTCHAR uni111C
+ENCODING 4380
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 9 2 1
+BBX 13 10 2 0
 BITMAP
-30C0
-1060
-7840
-CC40
-84C0
-84A0
-8510
-CE08
-7808
+0018
+FD88
+4488
+4488
+44F8
+4488
+4488
+7E88
+40F8
+0088
 ENDCHAR
-STARTCHAR 3183
-ENCODING 4422
+STARTCHAR uni111D
+ENCODING 4381
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 9 2 1
+BBX 9 13 3 -1
 BITMAP
-1040
-1040
-78A0
-CCA0
-8490
-8510
-8508
-CD08
-7BF8
+FF00
+4100
+4100
+4100
+7F80
+4000
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
 ENDCHAR
-STARTCHAR 3180
-ENCODING 4423
+STARTCHAR uni111E
+ENCODING 4382
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 8 2 1
+BBX 12 10 2 0
 BITMAP
-1020
-78F0
-8988
-8508
-8508
-8508
-8D88
-78F0
+0D00
+C5F0
+4410
+4410
+7C10
+4410
+4410
+4410
+7C10
+4400
 ENDCHAR
-STARTCHAR 3184
-ENCODING 4439
+STARTCHAR uni111F
+ENCODING 4383
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 13 3 -1
+BBX 14 10 2 0
 BITMAP
-0040
-7FE0
-0180
-1100
-1100
-0100
-FFE0
-1E00
-3180
-2080
-2080
-3180
-1F00
+0D00
+C480
+4480
+4480
+7C80
+4480
+4480
+4488
+7CFC
+4400
 ENDCHAR
-STARTCHAR 3185
-ENCODING 4440
+STARTCHAR uni1120
+ENCODING 4384
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 10 1 0
+BBX 13 10 2 0
 BITMAP
-1C38
-0000
-0202
-FEFE
-0830
-3448
-4284
-4284
-66CC
-3C78
+0C10
+C5F0
+4500
+4500
+7D00
+4500
+4500
+4510
+7DF8
+4400
 ENDCHAR
-STARTCHAR 3186
-ENCODING 4441
+STARTCHAR uni1121
+ENCODING 4385
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 11 3 0
+BBX 14 10 2 0
 BITMAP
-0060
-FFE0
-0000
-0000
-0000
-1F00
-3180
-2080
-2080
-3180
-1F00
+0C40
+C430
+4420
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
 ENDCHAR
-STARTCHAR he
-ENCODING 4608
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uni1122
+ENCODING 4386
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
 BITMAP
-07
-C3
-C3
-C3
-C3
-C3
-C3
-C6
-C6
-7C
-38
+1920
+C8BC
+4884
+4884
+7984
+4944
+4A24
+4C24
+7C04
+4000
 ENDCHAR
-STARTCHAR hu
-ENCODING 4609
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uni1123
+ENCODING 4387
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
 BITMAP
-0700
-C300
-C300
-C300
-C3F0
-C330
-C300
-C600
-C600
-7C00
-3800
+1A04
+C93C
+4920
+4920
+7920
+4B20
+4AA0
+4CA4
+7CBC
+4000
 ENDCHAR
-STARTCHAR hi
-ENCODING 4610
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni1124
+ENCODING 4388
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
 BITMAP
-66
-C6
-C6
-C6
-C6
-7C
-3C
-0C
-18
-30
-33
-3F
+1A0C
+C964
+4924
+4924
+793C
+4B24
+4AA4
+4CA4
+7CBC
+4024
 ENDCHAR
-STARTCHAR ha
-ENCODING 4611
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni1125
+ENCODING 4389
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
 BITMAP
-66
-C6
-C6
-C6
-C6
-7C
-3C
-0C
-18
-30
-30
-30
+1910
+C888
+4888
+4888
+7888
+4998
+4954
+4A64
+7C44
+4000
 ENDCHAR
-STARTCHAR hE
-ENCODING 4612
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni1126
+ENCODING 4390
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
 BITMAP
-66
-C6
-C6
-C6
-C6
-7C
-3C
-0C
-1C
-34
-32
-3E
+0004
+197E
+C888
+4888
+4888
+7888
+4994
+4954
+4A64
+7C44
+4000
 ENDCHAR
-STARTCHAR h
-ENCODING 4613
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni1127
+ENCODING 4391
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
 BITMAP
-C380
-C180
-E180
-7180
-3180
-6180
-6180
-6180
-6300
-3F00
-1E00
+0C04
+C5FC
+4420
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
 ENDCHAR
-STARTCHAR ho
-ENCODING 4614
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni1128
+ENCODING 4392
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
 BITMAP
-03C0
-C320
-C360
-C380
-C300
-C300
-C300
-C600
-C600
-7C00
-3800
+00F0
+0C04
+C5FC
+4420
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
 ENDCHAR
-STARTCHAR le
-ENCODING 4616
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni1129
+ENCODING 4393
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
 BITMAP
-30
-30
-30
-78
-7C
-CE
-C6
-C6
-C6
-C6
-C6
-C6
+0C08
+C5FC
+4480
+4490
+7CF8
+4480
+4480
+4488
+7CFC
+4400
 ENDCHAR
-STARTCHAR lu
-ENCODING 4617
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni112A
+ENCODING 4394
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 2 0
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C7E0
-C660
-C600
-C600
+0C04
+C5FC
+4400
+4518
+7C88
+4488
+4490
+4412
+7DFE
+4400
 ENDCHAR
-STARTCHAR li
-ENCODING 4618
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni112B
+ENCODING 4395
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C600
-C600
-C660
-C7E0
+0180
+C080
+4080
+7F80
+4080
+4080
+7F80
+4080
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
 ENDCHAR
-STARTCHAR la
-ENCODING 4619
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni112C
+ENCODING 4396
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-30
-30
-30
-78
-7C
-CE
-C6
-C6
-C6
-06
-06
-06
+0C30
+C710
+4510
+7DF0
+4510
+4510
+7DF0
+4510
+0200
+0F80
+1040
+1040
+1040
+1040
+0F80
 ENDCHAR
-STARTCHAR lE
-ENCODING 4620
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni112D
+ENCODING 4397
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C600
-C7C0
-C660
-C7C0
+1900
+0DF8
+0808
+0808
+1408
+1408
+2208
+4208
+8008
 ENDCHAR
-STARTCHAR l
-ENCODING 4621
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni112E
+ENCODING 4398
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-18
-18
-18
-3C
-3E
-67
-63
-C3
-C3
-F3
-DB
-F3
+1800
+0D80
+0880
+0880
+1880
+1480
+2488
+42B0
+8240
 ENDCHAR
-STARTCHAR lo
-ENCODING 4622
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni112F
+ENCODING 4399
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C7E0
-C6B0
-C6E0
-C600
-C600
+1808
+0CF8
+0880
+0880
+1480
+1480
+2280
+4288
+80FC
 ENDCHAR
-STARTCHAR lWa
-ENCODING 4623
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni1130
+ENCODING 4400
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C600
-0600
-0600
-0600
-1F80
-30C0
+1800
+0DF8
+0810
+0810
+15F8
+1480
+2280
+4284
+81F8
 ENDCHAR
-STARTCHAR He
-ENCODING 4624
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1131
+ENCODING 4401
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-CCC0
-CCC0
-CCC0
+1800
+0DF8
+0888
+0888
+1488
+1488
+2288
+42FC
+8080
 ENDCHAR
-STARTCHAR Hu
-ENCODING 4625
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni1132
+ENCODING 4402
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCFC
-CCCC
-CCC0
-CCC0
+1818
+0D88
+0888
+0888
+14F8
+1488
+2288
+4288
+80F8
+0088
 ENDCHAR
-STARTCHAR Hi
-ENCODING 4626
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni1133
+ENCODING 4403
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 1
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-CCC0
-CCCC
-CCFC
+00C0
+2650
+125C
+1244
+13C4
+3244
+2A44
+4A44
+8BC4
+8244
 ENDCHAR
-STARTCHAR Ha
-ENCODING 4627
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1134
+ENCODING 4404
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-00C0
-00C0
-00C0
+2108
+1084
+1084
+1084
+294A
+294A
+4A52
+8C62
+8420
 ENDCHAR
-STARTCHAR HE
-ENCODING 4628
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni1135
+ENCODING 4405
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CC80
-CCF0
-CC98
-CCF0
+1820
+0C20
+0870
+0888
+1488
+1488
+2288
+4288
+8070
 ENDCHAR
-STARTCHAR H
-ENCODING 4629
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1136
+ENCODING 4406
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
 BITMAP
-3000
-3000
-3000
-3C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-CCC0
-CCC0
-CCC0
+1804
+0DFC
+0820
+0820
+1420
+1450
+2248
+4284
+8104
+0200
 ENDCHAR
-STARTCHAR Ho
-ENCODING 4630
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1137
+ENCODING 4407
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-C000
-C000
-C000
+00F0
+1804
+0DFC
+0820
+0820
+1420
+1450
+2248
+4284
+8104
+0200
 ENDCHAR
-STARTCHAR HWa
-ENCODING 4631
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 14 0 -2
+STARTCHAR uni1138
+ENCODING 4408
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-00C0
-00C0
-00C0
-07F8
-0E1C
+1804
+0CFC
+0884
+0804
+141C
+14E8
+2208
+4210
+8020
+0040
 ENDCHAR
-STARTCHAR me
-ENCODING 4632
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 8 0 2
+STARTCHAR uni1139
+ENCODING 4409
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-3FF0
-7FF0
-4490
-C590
-8D10
-9930
-F1E0
-F1C0
+1808
+0DFC
+0880
+0890
+14F8
+1480
+2280
+4288
+80FC
 ENDCHAR
-STARTCHAR mu
-ENCODING 4633
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 8 0 2
+STARTCHAR uni113A
+ENCODING 4410
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
 BITMAP
-3FF0
-7FF0
-4490
-C59E
-8D12
-9932
-F1E0
-F1C0
+1802
+0CFE
+0800
+088C
+1444
+1444
+2248
+4209
+80FF
 ENDCHAR
-STARTCHAR mi
-ENCODING 4634
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni113B
+ENCODING 4411
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 2 1
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0040
-004C
-007C
+1804
+0DFE
+0800
+0820
+1470
+1288
+2188
+4188
+8070
 ENDCHAR
-STARTCHAR ma
-ENCODING 4635
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni113C
+ENCODING 4412
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 10 4 -1
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0040
-0040
-0040
+0400
+0400
+0A00
+1100
+1100
+2080
+2000
+4000
+8000
+8000
 ENDCHAR
-STARTCHAR mE
-ENCODING 4636
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni113D
+ENCODING 4413
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 -1
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0078
-004C
-0078
+0410
+0410
+0A28
+1144
+1144
+2082
+2080
+4100
+8200
+8200
 ENDCHAR
-STARTCHAR m
-ENCODING 4637
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni113E
+ENCODING 4414
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 10 4 -1
 BITMAP
-7FC0
-7FE0
-CA20
-8A20
-8A20
-8BE0
-F9C0
-7800
-0800
-1800
-3000
-6000
+1000
+1000
+2800
+4400
+4400
+8200
+0200
+0100
+0080
+0080
 ENDCHAR
-STARTCHAR mo
-ENCODING 4638
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni113F
+ENCODING 4415
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 -1
 BITMAP
-7FC0
-7FE0
-CA20
-8A20
-8A20
-8BE0
-F9C0
-7800
-0800
+1040
+1040
+28A0
+4510
+4510
+8208
+0208
+0104
+0082
+0082
+ENDCHAR
+STARTCHAR uni1140
+ENCODING 4416
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
+BITMAP
 0800
 0800
-0C00
+1400
+2200
+2200
+4100
+8080
+8080
+FF80
 ENDCHAR
-STARTCHAR mWa
-ENCODING 4639
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 14 0 -2
+STARTCHAR uni1141
+ENCODING 4417
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0060
-0040
-0040
-03F0
-0618
+1200
+13F0
+7810
+8410
+8410
+8410
+8410
+8410
+7810
 ENDCHAR
-STARTCHAR `se/s2e
-ENCODING 4640
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 9 0 1
+STARTCHAR uni1142
+ENCODING 4418
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-4CC0
-CCC0
-CCC0
-CCC0
-CCC0
-CD80
-CF80
-6C00
-3C00
+1010
+11F0
+7900
+8500
+8500
+8500
+8500
+8510
+79F8
 ENDCHAR
-STARTCHAR `su/s2u
-ENCODING 4641
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 9 0 1
+STARTCHAR uni1143
+ENCODING 4419
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-4D80
-CD80
-CDF8
-CD98
-CD80
-CD80
-CF80
-6C00
-3C00
+1000
+13F0
+7910
+8510
+8510
+8510
+8510
+85F8
+7900
 ENDCHAR
-STARTCHAR `si/s2i
-ENCODING 4642
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni1144
+ENCODING 4420
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 10 2 0
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7FC0
-00C0
-00C0
-00C0
-00CC
-00FC
+1030
+1310
+7910
+8510
+85F0
+8510
+8510
+8510
+79F0
+0110
 ENDCHAR
-STARTCHAR `sa/s2a
-ENCODING 4643
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1145
+ENCODING 4421
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7FC0
-00C0
-00C0
-00C0
-00C0
-00C0
+10C0
+1060
+7840
+8440
+84A0
+8490
+8508
+8608
+7C00
 ENDCHAR
-STARTCHAR `sE/s2E
-ENCODING 4644
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1146
+ENCODING 4422
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7FC0
-00C0
-00C0
-00E0
-0190
-01E0
+1020
+1020
+7850
+8450
+8488
+8488
+8504
+8504
+79FC
 ENDCHAR
-STARTCHAR `s/s2
-ENCODING 4645
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1147
+ENCODING 4423
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-FF80
-E000
-C000
-C000
-C000
-C000
+1020
+1020
+78F0
+8508
+8508
+8508
+8508
+8508
+78F0
 ENDCHAR
-STARTCHAR `so/s2o
-ENCODING 4646
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1148
+ENCODING 4424
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-CCC0
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7F80
-1C00
-1800
-3800
-7000
-6000
+1008
+13F8
+7840
+8440
+8440
+84A0
+8490
+8508
+7A08
+0400
 ENDCHAR
-STARTCHAR `sWa/s2Wa
-ENCODING 4647
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 14 0 -2
+STARTCHAR uni1149
+ENCODING 4425
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 11 2 0
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7FC0
-00C0
-00C0
-00C0
-00C0
-00C0
-07F8
-0E1C
+01E0
+1008
+13F8
+7840
+8440
+8440
+84A0
+8490
+8508
+7A08
+0400
 ENDCHAR
-STARTCHAR re
-ENCODING 4648
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni114A
+ENCODING 4426
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-0C
-0C
-0C
-18
-38
-70
-E0
-C0
-C0
-E3
-7F
-3F
+1010
+13F8
+7900
+8520
+85F0
+8500
+8500
+8510
+79F8
 ENDCHAR
-STARTCHAR ru
-ENCODING 4649
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni114B
+ENCODING 4427
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
 BITMAP
-0C00
-0C00
-1C00
-3800
-7000
-6000
-C000
-E000
-7FC0
-3FC0
-0600
-0600
+1004
+11FC
+7800
+8518
+8488
+8488
+8490
+8412
+79FE
 ENDCHAR
-STARTCHAR ri
-ENCODING 4650
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni114C
+ENCODING 4428
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 8 5 2
 BITMAP
-0C00
-0C00
-0C00
-1800
-3800
-7000
-E000
-C300
-C380
-E180
-7F00
-3E00
+10
+10
+7C
+82
+82
+82
+82
+7C
 ENDCHAR
-STARTCHAR ra
-ENCODING 4651
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni114D
+ENCODING 4429
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 2 0
 BITMAP
-0C00
-0C00
-0C00
-1800
-3800
-7000
-E000
-C1E0
-C3E0
-E660
-7E00
-3C00
+0108
+7F08
+083C
+0842
+0842
+1442
+1242
+2142
+413C
+8000
 ENDCHAR
-STARTCHAR rE
-ENCODING 4652
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni114E
+ENCODING 4430
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 4 1
 BITMAP
-0C00
-0C00
-0C00
-1800
-3800
-7000
-E000
-C000
-C000
-E780
-7CC0
-3F80
+00C0
+FFE0
+0400
+0A00
+1100
+1100
+2080
+2000
+4000
+8000
+8000
 ENDCHAR
-STARTCHAR r
-ENCODING 4653
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uni114F
+ENCODING 4431
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 1
 BITMAP
-3F
-7F
-C3
-C0
-C0
-C0
-C0
-C0
-C3
-FF
-7E
+000C
+7FFE
+0410
+0A28
+1144
+1144
+2082
+2080
+4100
+8200
+8200
 ENDCHAR
-STARTCHAR ro
-ENCODING 4654
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR uni1150
+ENCODING 4432
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 4 -1
 BITMAP
-3F80
-7CC0
-C780
-C000
-C000
-C000
-C000
-C000
-C300
-FF00
-7E00
+00C0
+FFE0
+0400
+0A00
+1100
+1100
+2080
+0080
+0040
+0020
+0020
 ENDCHAR
-STARTCHAR rWa
-ENCODING 4655
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 0 -2
+STARTCHAR uni1151
+ENCODING 4433
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 -1
 BITMAP
-C0C0
-7380
-0C00
-0C00
-1800
-3800
-7000
-E000
-C1E0
-C3E0
-E660
-7E00
-3C00
+0018
+FFFC
+1040
+28A0
+4510
+4510
+8208
+0208
+0104
+0082
+0082
 ENDCHAR
-STARTCHAR se
-ENCODING 4656
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni1152
+ENCODING 4434
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
 BITMAP
-10
-10
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-C6
+0102
+7F7E
+0842
+0802
+080E
+1474
+1204
+2108
+4110
+8020
 ENDCHAR
-STARTCHAR su
-ENCODING 4657
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni1153
+ENCODING 4435
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
 BITMAP
-1000
-1000
-3800
-7C00
-C600
-C600
-C600
-C7E0
-C660
-C600
-C600
-C600
+3C00
+0138
+7F02
+087F
+0808
+083C
+1442
+1242
+2142
+413C
+8000
 ENDCHAR
-STARTCHAR si
-ENCODING 4658
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni1154
+ENCODING 4436
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
 BITMAP
-1000
+0200
+0100
+0118
+FFFC
+0100
+0280
+0440
+0440
+0820
+0800
 1000
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-C600
-C660
-C7E0
+2000
+2000
 ENDCHAR
-STARTCHAR sa
-ENCODING 4659
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni1155
+ENCODING 4437
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
 BITMAP
-10
-10
-38
-7C
-C6
-C6
-C6
-C6
-C6
-06
-06
-06
+0200
+0100
+0118
+FFFC
+0100
+0280
+0440
+0440
+0820
+0020
+0010
+0008
+0008
 ENDCHAR
-STARTCHAR sE
-ENCODING 4660
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1156
+ENCODING 4438
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
 BITMAP
-1000
-1000
-3800
-7C00
-C600
-C600
-C600
-C600
-C700
-C680
-C640
-C7C0
+0206
+FE62
+0022
+8C22
+443E
+4422
+4822
+0922
+FF3E
+0022
 ENDCHAR
-STARTCHAR s
-ENCODING 4661
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uni1157
+ENCODING 4439
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-30
-18
-1C
-3E
-63
-63
-63
-63
-63
-63
-63
+0080
+7FC0
+0000
+2300
+1100
+1100
+0240
+FFE0
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
 ENDCHAR
-STARTCHAR so
-ENCODING 4662
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni1158
+ENCODING 4440
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-10
-10
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C0
-C0
-C0
+70E0
+0408
+FDFC
+1020
+78F0
+8508
+8508
+8508
+78F0
 ENDCHAR
-STARTCHAR sWa
-ENCODING 4663
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni1159
+ENCODING 4441
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 3 0
 BITMAP
-1000
-1000
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-0600
-0600
-0600
-1F80
-30C0
+00C0
+FFE0
+0000
+0000
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
 ENDCHAR
-STARTCHAR xe
-ENCODING 4664
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni115F
+ENCODING 4447
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6300
-6300
+B6D6
+8000
+1272
+9280
+1E82
+9282
+9270
+0002
+83C2
+8200
+03C2
+8202
+8200
+0002
+DB6A
 ENDCHAR
-STARTCHAR xu
-ENCODING 4665
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1160
+ENCODING 4448
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-63F0
-6330
-6330
-6300
-6300
+B6D6
+8000
+1212
+9210
+1E12
+9292
+9260
+0002
+83C2
+8200
+03C2
+8202
+8200
+0002
+DB6A
 ENDCHAR
-STARTCHAR xi
-ENCODING 4666
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1161
+ENCODING 4449
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 15 5 -2
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6330
-63F0
+E0
+20
+20
+20
+20
+22
+3E
+20
+20
+20
+20
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR xa
-ENCODING 4667
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni1162
+ENCODING 4450
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 15 6 -2
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-0300
-0300
-0300
+38
+08
+C8
+48
+48
+48
+48
+48
+78
+48
+48
+48
+48
+48
+08
 ENDCHAR
-STARTCHAR xE
-ENCODING 4668
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1163
+ENCODING 4451
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 15 5 -2
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-63E0
-6330
-63E0
+E0
+20
+20
+20
+22
+3E
+20
+20
+20
+22
+3E
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR x
-ENCODING 4669
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni1164
+ENCODING 4452
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 5 15 5 -2
 BITMAP
-C300
-7E00
-0C00
-0E00
-1F00
-1980
-3180
-3180
-3180
-3180
-3180
-3180
+38
+08
+C8
+48
+48
+78
+48
+48
+48
+78
+48
+48
+48
+48
+08
 ENDCHAR
-STARTCHAR xo
-ENCODING 4670
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni1165
+ENCODING 4453
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 15 6 -2
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6000
-6000
-6000
+38
+08
+08
+08
+08
+08
+88
+F8
+08
+08
+08
+08
+08
+08
+08
 ENDCHAR
-STARTCHAR xWa
-ENCODING 4671
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR uni1166
+ENCODING 4454
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 8 15 4 -2
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-0300
-0300
-0FC0
-1860
+07
+01
+19
+09
+09
+09
+89
+F9
+09
+09
+09
+09
+09
+09
+01
 ENDCHAR
-STARTCHAR qe
-ENCODING 4672
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1167
+ENCODING 4455
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 15 6 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-0C00
+38
+08
+08
+08
+88
+F8
+08
+08
+08
+88
+F8
+08
+08
+08
+08
 ENDCHAR
-STARTCHAR qu
-ENCODING 4673
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1168
+ENCODING 4456
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 8 15 4 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0FC0
-0CC0
-0C00
+07
+01
+19
+09
+89
+F9
+09
+09
+89
+F9
+09
+09
+09
+09
+01
 ENDCHAR
-STARTCHAR qi
-ENCODING 4674
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1169
+ENCODING 4457
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 8 1 2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0CC0
-0FC0
+0300
+0100
+0100
+0100
+0100
+0100
+010C
+FFFE
 ENDCHAR
-STARTCHAR qa
-ENCODING 4675
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni116A
+ENCODING 4458
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-1800
-3000
-6000
+00E0
+0020
+0020
+0C20
+0420
+0420
+0422
+043E
+0420
+05E0
+FE20
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR qE
-ENCODING 4676
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni116B
+ENCODING 4459
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0F80
-0CC0
-0F80
+0070
+0010
+0190
+0090
+0090
+3090
+1090
+10F0
+1190
+1E90
+E090
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR q
-ENCODING 4677
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni116C
+ENCODING 4460
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 1 -2
 BITMAP
-3000
-3000
-3C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+0070
+0010
+0010
+0C10
+0410
+0410
+0410
+0410
+0410
+04F0
+FF10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR qo
-ENCODING 4678
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni116D
+ENCODING 4461
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 7 2 2
 BITMAP
-0700
-0980
-0B00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+1860
+0820
+0820
+0840
+0840
+0844
+FFFE
 ENDCHAR
-STARTCHAR qWe
-ENCODING 4680
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni116E
+ENCODING 4462
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0FC0
-0D60
-0DC0
-0C00
+000C
+FFFE
+4100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR qWi
-ENCODING 4682
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni116F
+ENCODING 4463
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CD8
-CCD8
-CDF8
-7E0C
-0C0C
-0C00
-0C00
-0C00
+0038
+0008
+0008
+0008
+0008
+00E8
+FF08
+0408
+0478
+0448
+0408
+0408
+0408
+0408
+0008
 ENDCHAR
-STARTCHAR qWa
-ENCODING 4683
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni1170
+ENCODING 4464
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 15 2 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-0C00
-3F00
-6180
+0038
+0008
+00C8
+0048
+0048
+0348
+FC48
+0848
+0A48
+0BC8
+0848
+0848
+0848
+0848
+0008
 ENDCHAR
-STARTCHAR qWE
-ENCODING 4684
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni1171
+ENCODING 4465
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0F80
-0CC0
-3F80
-6000
+0070
+0010
+0010
+0010
+0010
+01D0
+FE10
+0810
+0810
+0810
+0810
+0810
+0810
+0810
+0010
 ENDCHAR
-STARTCHAR qWu/qW
-ENCODING 4685
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni1172
+ENCODING 4466
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 -2
 BITMAP
-0C00
-0C30
-0C30
-1FFC
-6CCC
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-0C00
-ENDCHAR
-STARTCHAR Qe
-ENCODING 4688
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
-BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+0006
+FFFE
+6820
+0820
+0820
+0820
+0820
+0820
+0820
+0820
+0820
+0820
 ENDCHAR
-STARTCHAR Qu
-ENCODING 4689
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1173
+ENCODING 4467
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 2 2 4
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0FC0
-0CC0
+0018
+FFFC
 ENDCHAR
-STARTCHAR Qi
-ENCODING 4690
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1174
+ENCODING 4468
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 1 -2
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0CC0
-0FC0
+0070
+0010
+0010
+0010
+0010
+0010
+0010
+0010
+01F0
+FE10
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR Qa
-ENCODING 4691
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1175
+ENCODING 4469
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 3 15 6 -2
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-1800
-3000
+E0
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR QE
-ENCODING 4692
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni1176
+ENCODING 4470
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
 BITMAP
-6180
-3F00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0F80
-0CC0
-0F80
+00C0
+0040
+0040
+0040
+0048
+0078
+0040
+0040
+0C40
+0440
+0440
+0400
+0420
+FFF0
 ENDCHAR
-STARTCHAR Q
-ENCODING 4693
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni1177
+ENCODING 4471
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 4 -2
 BITMAP
-C300
-7E00
-1800
-1E00
-0600
-0FC0
-3660
-6660
-66C0
-3F00
-0600
 0600
-ENDCHAR
-STARTCHAR Qo
-ENCODING 4694
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
-BITMAP
-60C0
-3F80
-0900
-0B00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-ENDCHAR
-STARTCHAR QWe
-ENCODING 4696
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
-BITMAP
-6180
-3F00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0FC0
-0D60
-0DC0
-0C00
-ENDCHAR
-STARTCHAR QWi
-ENCODING 4698
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
-BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CD8
-CCD8
-CDF8
-7E0C
-0C0C
-0C00
-0C00
+0200
+0240
+03C0
+0200
+0200
+0200
+0000
+0100
+FF80
+0800
+0800
+0800
+0800
+0800
 ENDCHAR
-STARTCHAR QWa
-ENCODING 4699
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 0
+STARTCHAR uni1178
+ENCODING 4472
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-3F00
-6180
+00C0
+0040
+0048
+0078
+0040
+0040
+0048
+0078
+0C40
+0440
+0440
+0400
+0420
+FFF0
 ENDCHAR
-STARTCHAR QWE
-ENCODING 4700
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni1179
+ENCODING 4473
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -1
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0F80
-0CC0
-3F80
-6000
+0060
+0020
+0024
+003C
+0020
+0020
+0024
+003C
+31A0
+10A0
+10A0
+1100
+1120
+FFF0
 ENDCHAR
-STARTCHAR QWu/QW
-ENCODING 4701
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni117A
+ENCODING 4474
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -1
 BITMAP
-6180
-3F00
-0C30
-0C30
-1FFC
-6CCC
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+00C0
+0040
+0040
+0040
+0240
+03C0
+0040
+0040
+0C40
+0440
+0440
+0400
+0420
+FFF0
 ENDCHAR
-STARTCHAR be
-ENCODING 4704
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uni117B
+ENCODING 4475
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
 BITMAP
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-C6
+0600
+0200
+0200
+1E00
+0200
+0200
+0200
+0000
+0100
+FF80
+0800
+0800
+0800
+0800
+0800
 ENDCHAR
-STARTCHAR bu
-ENCODING 4705
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni117C
+ENCODING 4476
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -1
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C7E0
-C660
-C660
-C600
-C600
-C600
+00C0
+0040
+0040
+0040
+0240
+03C0
+0040
+0040
+0040
+0040
+0040
+0000
+0020
+FFF0
 ENDCHAR
-STARTCHAR bi
-ENCODING 4706
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni117D
+ENCODING 4477
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -1
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-C600
-C600
-C660
-C7E0
+0060
+0020
+0120
+01E0
+0020
+0020
+0120
+01E0
+0C20
+0420
+0420
+0400
+0420
+FFF0
 ENDCHAR
-STARTCHAR ba
-ENCODING 4707
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uni117E
+ENCODING 4478
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
 BITMAP
-38
-7C
-C6
-C6
-C6
-C6
-C6
-06
-06
-06
-06
+0600
+0200
+1E00
+0200
+0200
+1E00
+0200
+0200
+0100
+FF80
+0800
+0800
+0800
+0800
+0800
 ENDCHAR
-STARTCHAR bE
-ENCODING 4708
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni117F
+ENCODING 4479
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-C600
-C7C0
-C660
-C7C0
+0070
+0010
+0010
+0010
+0010
+0C10
+0510
+05F0
+0410
+0410
+0410
+05D0
+FE10
+0010
+0010
 ENDCHAR
-STARTCHAR b
-ENCODING 4709
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni1180
+ENCODING 4480
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-0380
-07C0
-0C60
-0C60
-0C60
-FC60
-CC60
-CC60
-0C60
-0C60
-0C60
+000E
+0002
+0032
+0012
+0012
+0012
+0112
+0DF2
+0412
+0412
+0412
+05D2
+0E12
+F012
+0002
 ENDCHAR
-STARTCHAR bo
-ENCODING 4710
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uni1181
+ENCODING 4481
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C0
-C0
-C0
-C0
+000E
+0002
+0032
+0012
+0112
+01F2
+0012
+0C12
+0512
+05F2
+0412
+05D2
+0E12
+F012
+0002
 ENDCHAR
-STARTCHAR bWa
-ENCODING 4711
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -2
+STARTCHAR uni1182
+ENCODING 4482
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 13 2 0
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-0600
 0600
-0600
+0200
+0200
+0200
+0230
+FFF8
+0000
 0600
-1F80
-30C0
+0200
+0200
+0200
+0230
+FFF8
 ENDCHAR
-STARTCHAR ve
-ENCODING 4712
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni1183
+ENCODING 4483
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 14 3 -2
 BITMAP
-C180
-7F00
+0C00
+0400
+0400
+0400
+0440
+FFE0
 0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6300
-6300
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR vu
-ENCODING 4713
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1184
+ENCODING 4484
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-63F0
-6330
-6330
-6300
-6300
+001C
+0010
+0010
+0010
+0012
+001E
+0010
+3310
+1110
+1112
+111E
+1170
+1790
+F810
+0010
 ENDCHAR
-STARTCHAR vi
-ENCODING 4714
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1185
+ENCODING 4485
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6330
-63F0
+000E
+0002
+0032
+0012
+0012
+001E
+0012
+3312
+1112
+111E
+1112
+1172
+1792
+F812
+0002
 ENDCHAR
-STARTCHAR va
-ENCODING 4715
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni1186
+ENCODING 4486
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-0300
-0300
+000E
+0002
+0002
+0002
+0022
+003E
+0002
+3302
+1122
+113E
+1102
+1162
+1782
+F802
+0002
 ENDCHAR
-STARTCHAR vE
-ENCODING 4716
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1187
+ENCODING 4487
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 13 2 0
 BITMAP
-C180
-7F00
+30C0
+1040
+1040
+1080
+1090
+FFF8
 0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-63E0
-6330
-63E0
+0600
+0200
+0200
+0200
+0230
+FFF8
 ENDCHAR
-STARTCHAR v
-ENCODING 4717
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1188
+ENCODING 4488
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-1830
-0FE0
-0000
-0380
-07C0
-0C60
-0C60
-FC60
-CC60
-CC60
-0C60
-0C60
+0070
+0010
+0010
+0010
+0010
+0010
+0010
+0C10
+0410
+0410
+0410
+05D0
+0E10
+F010
+0010
 ENDCHAR
-STARTCHAR vo
-ENCODING 4718
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni1189
+ENCODING 4489
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 15 1 -2
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6000
-6000
+0070
+0010
+0010
+0010
+0010
+0010
+0011
+0C1F
+0410
+0410
+0410
+05D0
+0E10
+F010
+0010
 ENDCHAR
-STARTCHAR vWa
-ENCODING 4719
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR uni118A
+ENCODING 4490
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-0300
-0300
-0FC0
-1860
+00E0
+0020
+0020
+0020
+0020
+0020
+0022
+013E
+FFA0
+0820
+0820
+0820
+0820
+0820
+0020
 ENDCHAR
-STARTCHAR te
-ENCODING 4720
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni118B
+ENCODING 4491
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
-0600
+001C
+0004
+0064
+0024
+0024
+003C
+0024
+0124
+FFA4
+083C
+0824
+0824
+0824
+0824
+0004
 ENDCHAR
-STARTCHAR tu
-ENCODING 4721
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni118C
+ENCODING 4492
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-07E0
-0660
-0600
-0600
+00E0
+0020
+0020
+0020
+0020
+0020
+0022
+013E
+FFA0
+0820
+0820
+0820
+0820
+0820
+00E0
+FFC0
 ENDCHAR
-STARTCHAR ti
-ENCODING 4722
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni118D
+ENCODING 4493
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 14 3 -2
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0660
-07E0
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR ta
-ENCODING 4723
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni118E
+ENCODING 4494
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0E00
-1C00
-3800
+01C0
+0040
+0040
+0040
+0040
+0048
+0078
+0040
+0F40
+F440
+2440
+2440
+2440
+2440
+0040
 ENDCHAR
-STARTCHAR tE
-ENCODING 4724
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni118F
+ENCODING 4495
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 3 -2
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-07C0
-0660
-07C0
+01C0
+0040
+0040
+0040
+0040
+0240
+03C0
+0040
+0F40
+F440
+2440
+2440
+2440
+2440
+0040
 ENDCHAR
-STARTCHAR t
-ENCODING 4725
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1190
+ENCODING 4496
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-1800
-1C00
-0E00
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
+000E
+0002
+0032
+0012
+0F12
+F412
+2512
+25F2
+2412
+2412
+0012
+0012
+0012
+0012
+0002
 ENDCHAR
-STARTCHAR to
-ENCODING 4726
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1191
+ENCODING 4497
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 1 -2
 BITMAP
-0F80
-0C80
-0580
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
-0600
+0070
+0010
+0010
+0010
+0090
+00F0
+0010
+0F10
+F410
+2490
+24F0
+2410
+2410
+0010
+0010
 ENDCHAR
-STARTCHAR tWa
-ENCODING 4727
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 14 0 -2
+STARTCHAR uni1192
+ENCODING 4498
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
-0600
-1F80
-30C0
+000E
+0002
+0032
+0012
+0092
+00F2
+0012
+0F12
+F492
+24F2
+2412
+2412
+2412
+0012
+0002
 ENDCHAR
-STARTCHAR ce
-ENCODING 4728
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1193
+ENCODING 4499
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
+0040
+FFE0
+1100
+1100
+1100
+1100
+1100
+0000
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR cu
-ENCODING 4729
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1194
+ENCODING 4500
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 3 -2
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-07E0
-0660
-0600
+01C0
+0040
+0040
+0040
+0040
+0040
+0040
+0040
+0F40
+F440
+2440
+2440
+2440
+2440
+0040
 ENDCHAR
-STARTCHAR ci
-ENCODING 4730
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1195
+ENCODING 4501
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 10 3 1
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0660
-07E0
+0040
+FFE0
+0000
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR ca
-ENCODING 4731
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1196
+ENCODING 4502
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 5 3 4
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-0E00
-1C00
-3800
+0040
+FFE0
+0000
+0040
+FFE0
 ENDCHAR
-STARTCHAR cE
-ENCODING 4732
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1197
+ENCODING 4503
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-07C0
-0660
-07C0
+01C0
+0040
+0040
+0040
+0040
+00C0
+0740
+F800
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR c
-ENCODING 4733
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni1198
+ENCODING 4504
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0E00
-0300
-3FF0
-7FF8
-6318
-0300
-0300
-0300
+EE00
+2200
+2200
+2200
+2200
+2200
+2220
+23E0
+2200
+2200
+2200
+2200
+2200
+2200
+2200
 ENDCHAR
-STARTCHAR co
-ENCODING 4734
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni1199
+ENCODING 4505
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-30C0
-7FE0
-6960
-0900
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
+EE00
+2200
+2200
+2200
+2220
+23E0
+2200
+2200
+2220
+23E0
+2200
+2200
+2200
+2200
+2200
 ENDCHAR
-STARTCHAR cWa
-ENCODING 4735
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 14 0 -2
+STARTCHAR uni119A
+ENCODING 4506
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 13 2 0
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
-1F80
-30C0
+00E0
+0020
+0020
+0020
+0020
+0020
+0020
+0620
+0200
+0200
+0200
+0230
+FFF8
 ENDCHAR
-STARTCHAR `he/h2e
-ENCODING 4736
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni119B
+ENCODING 4507
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-0C
-0C
-0C
-FC
-CF
-03
-03
-03
-03
-03
-03
-03
+00E0
+0020
+0020
+0020
+0020
+0020
+0020
+0000
+0030
+FFF8
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR `hu/h2u
-ENCODING 4737
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni119C
+ENCODING 4508
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 1
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-03F0
-0330
-0300
-0300
-0300
+0070
+0010
+0010
+0010
+0010
+0010
+0010
+0010
+0010
+0000
+000C
+FFFE
 ENDCHAR
-STARTCHAR `hi/h2i
-ENCODING 4738
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni119D
+ENCODING 4509
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 3 13 4 0
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
-0300
-0300
-0330
-03F0
+C0
+40
+40
+40
+40
+40
+40
+00
+00
+40
+20
+20
+20
 ENDCHAR
-STARTCHAR `ha/h2a
-ENCODING 4739
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni119E
+ENCODING 4510
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 2 4 6 5
 BITMAP
-0C
-0C
-0C
-FC
-CF
-03
-03
-03
-0E
-18
-30
-30
+80
+40
+40
+40
 ENDCHAR
-STARTCHAR `hE/h2E
-ENCODING 4740
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni119F
+ENCODING 4511
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 7 15 4 -2
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
-0300
-03E0
-0330
-03E0
+0E
+02
+02
+02
+02
+02
+22
+3E
+02
+82
+42
+42
+42
+02
+02
 ENDCHAR
-STARTCHAR `h/h2
-ENCODING 4741
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni11A0
+ENCODING 4512
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 12 3 1
 BITMAP
-0C
-0C
-0C
-3C
-6F
-C3
-C3
-03
-03
-03
-03
-03
+0800
+0400
+0400
+0400
+0000
+0040
+FFE0
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR `ho/h2o
-ENCODING 4742
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni11A1
+ENCODING 4513
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 6 15 4 -2
 BITMAP
-07E0
-0F90
-18E0
-F800
-D800
-1800
-1F80
-0F80
-0180
-0180
-0180
-0180
+1C
+04
+04
+04
+04
+04
+84
+44
+44
+44
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR hWe
-ENCODING 4744
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni11A2
+ENCODING 4514
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 5 4 5 5
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-03F0
-0358
-0370
-0300
-0300
-0300
+90
+48
+48
+48
 ENDCHAR
-STARTCHAR hWi
-ENCODING 4746
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni11A8
+ENCODING 4520
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 10 3 0
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0330
-0330
-03F0
-0318
-0318
-0300
-0300
+8000
+FFE0
+0020
+0020
+0020
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR hWa
-ENCODING 4747
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR uni11A9
+ENCODING 4521
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
-0300
-0300
-0300
-0300
-0FC0
-1860
+8100
+FDF0
+0410
+0410
+0410
+0410
+0410
+0410
+0410
 ENDCHAR
-STARTCHAR hWE
-ENCODING 4748
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 14 0 -2
+STARTCHAR uni11AA
+ENCODING 4522
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
-0300
-0300
-03E0
-0330
-0FE0
-1800
+8000
+FCC0
+0460
+0440
+0440
+04A0
+0490
+0508
+0608
+0400
 ENDCHAR
-STARTCHAR hWu/hW
-ENCODING 4749
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni11AB
+ENCODING 4523
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 7 2 2
 BITMAP
-0C00
-0C00
-0C00
-FC60
-CF60
-03F8
-0318
-0300
-0300
-0300
-0300
-0300
+C000
+4000
+4000
+4000
+4000
+4060
+3FF0
 ENDCHAR
-STARTCHAR ne
-ENCODING 4752
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 5 12 0 0
+STARTCHAR uni11AC
+ENCODING 4524
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 0
 BITMAP
-C0
-C0
-C0
-F0
-38
-30
-30
-30
-60
-60
-60
-60
+C0C0
+4060
+4040
+4040
+40A0
+4490
+5908
+2208
+0400
 ENDCHAR
-STARTCHAR nu
-ENCODING 4753
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11AD
+ENCODING 4525
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 0
 BITMAP
-C0
-C0
-C0
-F0
-38
-30
-30
-3E
-66
-60
-60
-60
+C0E0
+4008
+41FC
+4020
+40F0
+4508
+5908
+2108
+00F0
 ENDCHAR
-STARTCHAR ni
-ENCODING 4754
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11AE
+ENCODING 4526
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 8 2 2
 BITMAP
-C0
-C0
-C0
-F0
-38
-30
-30
-30
-60
-60
-66
-7E
+0040
+FFE0
+4000
+4000
+4000
+4000
+4060
+7FF0
 ENDCHAR
-STARTCHAR na
-ENCODING 4755
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni11AF
+ENCODING 4527
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0400
-0C00
-0C00
-0C00
+0040
+FFC0
+4040
+0040
+7FC0
+4000
+4000
+4060
+7FF0
 ENDCHAR
-STARTCHAR nE
-ENCODING 4756
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 6 12 0 0
+STARTCHAR uni11B0
+ENCODING 4528
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 3 1
 BITMAP
-C0
-C0
-C0
-F0
-38
-30
-30
-30
-78
-64
-6C
-78
+0100
+FDF0
+0810
+0810
+FC10
+4010
+4010
+4210
+7C10
 ENDCHAR
-STARTCHAR n
-ENCODING 4757
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni11B1
+ENCODING 4529
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
 BITMAP
-FF
-FE
-C6
-0C
-1F
-03
-06
-0C
-0C
-18
-18
-30
+FDF8
+0888
+0888
+FC88
+4088
+4088
+42FC
+7C80
 ENDCHAR
-STARTCHAR no
-ENCODING 4758
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11B2
+ENCODING 4530
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-1FC0
-3F20
-6160
-C0C0
-E000
-7C00
-0E00
-0600
-0400
-0C00
-0C00
-0C00
+0018
+FD88
+0888
+0888
+FCF8
+4088
+4088
+4288
+7CF8
+0088
 ENDCHAR
-STARTCHAR nWa
-ENCODING 4759
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -2
+STARTCHAR uni11B3
+ENCODING 4531
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
 BITMAP
-1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0400
-0C00
-0C00
-3F00
-6180
+0030
+FC18
+0810
+0810
+FC28
+4024
+4042
+4282
+7D00
 ENDCHAR
-STARTCHAR Ne
-ENCODING 4760
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni11B4
+ENCODING 4532
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-0300
-0600
-0600
-0600
-0600
+0008
+FDFC
+0880
+0890
+FCF8
+4080
+4080
+4288
+7CFC
 ENDCHAR
-STARTCHAR Nu
-ENCODING 4761
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11B5
+ENCODING 4533
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-03E0
-0660
-0600
-0600
-0600
+0004
+FDFC
+0800
+0918
+FC88
+4088
+4090
+4212
+7DFE
 ENDCHAR
-STARTCHAR Ni
-ENCODING 4762
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11B6
+ENCODING 4534
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-0300
-0600
-0600
-0660
-07E0
+00E0
+FC08
+09FC
+0820
+FCF0
+4108
+4108
+4308
+7CF0
 ENDCHAR
-STARTCHAR Na
-ENCODING 4763
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 0 0
+STARTCHAR uni11B7
+ENCODING 4535
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 8 3 1
 BITMAP
-30C0
-7FE0
-4620
-1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0C00
-0C00
+FFE0
+4020
+4040
+4040
+4040
+4040
+7FC0
+4000
 ENDCHAR
-STARTCHAR NE
-ENCODING 4764
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni11B8
+ENCODING 4536
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 11 3 0
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-0300
-0780
-0640
-06C0
-0780
+00C0
+C040
+4040
+4040
+7FC0
+4040
+4040
+4040
+4040
+7FC0
+4040
 ENDCHAR
-STARTCHAR N
-ENCODING 4765
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 0
+STARTCHAR uni11B9
+ENCODING 4537
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
 BITMAP
-6180
-FFC0
-8C40
-3F80
-7F00
-6300
-0600
-0F80
-0180
-0300
-0600
-0600
-0600
+0C30
+C418
+4410
+4410
+7C28
+4424
+4442
+4482
+7D00
+4400
 ENDCHAR
-STARTCHAR No
-ENCODING 4766
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 0 0
+STARTCHAR uni11BA
+ENCODING 4538
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-3180
-7FC0
-4440
-1FC0
-3F20
-6160
-C0C0
-E000
-7C00
-0E00
+0800
 0600
+0400
 0C00
+0B00
+1080
+2060
+4020
+8010
+ENDCHAR
+STARTCHAR uni11BB
+ENCODING 4539
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
+BITMAP
+1860
+0C30
+0820
+0820
+1450
+1248
+2184
+4104
+8200
+ENDCHAR
+STARTCHAR uni11BC
+ENCODING 4540
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
+BITMAP
+0800
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+3E00
+ENDCHAR
+STARTCHAR uni11BD
+ENCODING 4541
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 9 3 1
+BITMAP
+0080
+FFC0
+0400
+0400
 0C00
+0A00
+1180
+60C0
+8040
 ENDCHAR
-STARTCHAR NWa
-ENCODING 4767
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 15 0 -2
+STARTCHAR uni11BE
+ENCODING 4542
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 9 2 1
 BITMAP
-30C0
-7FE0
-4620
 1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0C00
-0C00
-3F00
-6180
+0000
+FFE0
+4400
+0400
+0A00
+1180
+2040
+C020
 ENDCHAR
-STARTCHAR e/a
-ENCODING 4768
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11BF
+ENCODING 4543
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 10 3 1
 BITMAP
-60
-60
-60
-78
-18
-38
-3C
-6E
-E6
-C6
-C6
-C6
+00C0
+FF40
+6040
+0040
+01C0
+1E40
+E040
+0080
+0080
+0080
 ENDCHAR
-STARTCHAR u/U
-ENCODING 4769
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11C0
+ENCODING 4544
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-6000
-6000
-6000
-7800
-1800
-3800
-3C00
-6E00
-E7E0
-C660
-C600
-C600
+00C0
+FFE0
+4000
+4180
+7FC0
+4000
+4000
+4060
+7FF0
 ENDCHAR
-STARTCHAR i
-ENCODING 4770
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11C1
+ENCODING 4545
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-6000
-6000
-6000
-7800
-1800
-3800
-3C00
-6E00
-E600
-C600
-C660
-C7E0
+4060
+7FF0
+0000
+00C0
+1040
+0880
+0880
+8130
+FFF8
 ENDCHAR
-STARTCHAR a/A
-ENCODING 4771
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11C2
+ENCODING 4546
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-60
-60
-60
-78
-18
-3C
-6E
-C6
-C6
-C6
-06
-06
+0F80
+0010
+FFF8
+0200
+0F80
+1040
+1040
+1040
+1040
+0F80
 ENDCHAR
-STARTCHAR E
-ENCODING 4772
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11C3
+ENCODING 4547
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-6000
-6000
-6000
-7800
-1800
-3800
-3C00
-6E00
-E600
-C7C0
-C660
-C7C0
+8000
+FDF8
+0410
+0410
+05F8
+0480
+0480
+0484
+04F8
 ENDCHAR
-STARTCHAR I
-ENCODING 4773
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11C4
+ENCODING 4548
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-C0
-C0
-E0
-60
-30
-38
-7C
-EE
-C6
-C6
-C6
-C6
+8240
+F178
+1108
+1108
+1288
+1288
+1448
+1848
+1808
 ENDCHAR
-STARTCHAR o/O
-ENCODING 4774
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11C5
+ENCODING 4549
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 9 3 1
 BITMAP
-60
-60
-60
-78
-18
-3C
-6E
-C6
-C6
-C6
-C0
-C0
+0400
+C7C0
+4040
+4040
+4040
+4040
+4440
+5840
+2040
 ENDCHAR
-STARTCHAR e3
-ENCODING 4775
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 0
+STARTCHAR uni11C6
+ENCODING 4550
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-6300
-7F00
-D980
-1800
-1E00
-0600
-0E00
-0F00
-1B80
-3980
-3180
-3180
-3180
+0010
+C1F0
+4100
+4100
+4100
+4100
+4500
+5910
+61F8
 ENDCHAR
-STARTCHAR ke
-ENCODING 4776
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni11C7
+ENCODING 4551
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-3180
-3180
-3180
+00C0
+C060
+4040
+4040
+40A0
+4090
+4508
+5A08
+2400
 ENDCHAR
-STARTCHAR ku
-ENCODING 4777
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni11C8
+ENCODING 4552
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 8 2 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-31F8
-3198
-3180
-3180
-3180
+C040
+4040
+40A0
+40A0
+4110
+4510
+5A08
+23F8
 ENDCHAR
-STARTCHAR ki
-ENCODING 4778
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni11C9
+ENCODING 4553
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-3180
-3198
-31F8
+0010
+C3F8
+4100
+4120
+41F0
+4100
+4500
+5910
+61F8
 ENDCHAR
-STARTCHAR ka
-ENCODING 4779
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni11CA
+ENCODING 4554
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-0180
-0180
-0180
+0900
+F9F0
+8010
+8010
+8010
+8010
+8010
+8810
+FC10
 ENDCHAR
-STARTCHAR kE
-ENCODING 4780
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni11CB
+ENCODING 4555
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-31F0
-3198
-31F0
+0800
+FBF0
+8020
+8020
+83F0
+8100
+8100
+8908
+FDF0
 ENDCHAR
-STARTCHAR k
-ENCODING 4781
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni11CC
+ENCODING 4556
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 1 1
 BITMAP
-C000
-CE00
-DF00
-F180
-6180
-7180
-3180
-3180
-3180
-3180
-3180
+0410
+FF88
+1088
+1088
+F894
+4094
+40A2
+44A2
+78C0
 ENDCHAR
-STARTCHAR ko
-ENCODING 4782
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni11CD
+ENCODING 4557
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-3000
-3000
-3000
+FCC0
+0840
+0840
+FC40
+4040
+4044
+4258
+7C20
 ENDCHAR
-STARTCHAR kWe
-ENCODING 4784
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni11CE
+ENCODING 4558
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
 BITMAP
-C000
-CC00
-FE00
-F300
-3300
-33F0
-3358
-3370
-3300
-3300
-3300
+0008
+FCF8
+0880
+0880
+FC80
+4080
+4080
+4288
+7CFC
 ENDCHAR
-STARTCHAR kWi
-ENCODING 4786
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni11CF
+ENCODING 4559
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
 BITMAP
-C000
-CC00
-FE00
-F300
-3330
-3330
-33F0
-3318
-3318
-3300
-3300
+004C
+FBC1
+121F
+1204
+FA0E
+4211
+4211
+4651
+7BCE
 ENDCHAR
-STARTCHAR kWa
-ENCODING 4787
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 -2
+STARTCHAR uni11D0
+ENCODING 4560
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 2 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-0180
-0180
-0180
-07E0
-0C30
+FDF8
+0810
+0810
+FDF8
+4080
+4080
+4284
+7CF8
 ENDCHAR
-STARTCHAR kWE
-ENCODING 4788
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 13 0 -2
+STARTCHAR uni11D1
+ENCODING 4561
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-0180
-01F0
-0198
-07F0
-0C00
+0008
+FBEF
+1121
+1121
+F921
+4121
+4121
+45F1
+7901
 ENDCHAR
-STARTCHAR kWu/kW
-ENCODING 4789
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni11D2
+ENCODING 4562
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
 BITMAP
-C000
-CC60
-FE60
-F3F8
-3318
-3300
-3300
-3300
-3300
-3300
-3300
+0008
+FFC4
+1244
+1244
+FA4A
+424A
+4251
+47F1
+7A20
 ENDCHAR
-STARTCHAR Ke
-ENCODING 4792
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11D3
+ENCODING 4563
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 10 1 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C60
-0C60
-0C60
+00C8
+FE44
+1244
+1244
+FBCA
+424A
+4251
+4251
+7BE0
+0240
 ENDCHAR
-STARTCHAR Ku
-ENCODING 4793
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 12 0 0
+STARTCHAR uni11D4
+ENCODING 4564
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C7E
-0C66
-0C60
-0C60
-0C60
+00D8
+FE42
+127E
+1248
+FBDC
+4262
+4262
+4262
+7BDC
+0240
 ENDCHAR
-STARTCHAR Ki
-ENCODING 4794
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 12 0 0
+STARTCHAR uni11D5
+ENCODING 4565
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C60
-0C66
-0C7E
+000C
+0184
+0084
+00FC
+FC84
+0884
+08FC
+FC84
+4020
+4078
+4284
+7C84
+0084
+0078
 ENDCHAR
-STARTCHAR Ka
-ENCODING 4795
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11D6
+ENCODING 4566
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0060
-0060
-0060
+0110
+F888
+1088
+1088
+F888
+4198
+4154
+4664
+7C44
 ENDCHAR
-STARTCHAR KE
-ENCODING 4796
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 12 0 0
+STARTCHAR uni11D7
+ENCODING 4567
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 1 1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C7C
-0C66
-0C7C
+FE20
+0420
+0450
+FE50
+4088
+4088
+4104
+7FFC
 ENDCHAR
-STARTCHAR K
-ENCODING 4797
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni11D8
+ENCODING 4568
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-C300
-7E00
-1800
-1DC0
-1FE0
-0630
-0730
-0330
-0330
-0330
-0330
-0330
+0008
+FDF8
+0908
+0808
+FC38
+41D0
+4010
+4220
+7C40
+0080
 ENDCHAR
-STARTCHAR Ko
-ENCODING 4798
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11D9
+ENCODING 4569
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 9 2 1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C00
-0C00
-0C00
+0004
+FDFE
+0800
+0820
+F870
+4088
+4088
+4288
+7C70
 ENDCHAR
-STARTCHAR KWe
-ENCODING 4800
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 0 0
+STARTCHAR uni11DA
+ENCODING 4570
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C7E
-0C6B
-0C6E
-0C60
-0C60
-0C60
+0100
+FDF0
+4410
+4410
+4410
+4410
+4410
+7E10
+4010
 ENDCHAR
-STARTCHAR KWi
-ENCODING 4802
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 0 0
+STARTCHAR uni11DB
+ENCODING 4571
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 8 1 1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C66
-0C66
-0C7E
-0C63
-0C63
-0C60
-0C60
+FDF8
+4410
+4410
+45F0
+4480
+4480
+7E84
+40F8
 ENDCHAR
-STARTCHAR KWa
-ENCODING 4803
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 14 0 -2
+STARTCHAR uni11DC
+ENCODING 4572
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0CE0
-0C60
-0C60
-0C60
-0060
-0060
-0060
-01F8
-030C
+0018
+FD88
+4488
+4488
+44F8
+4488
+4488
+7E88
+40F8
+0088
 ENDCHAR
-STARTCHAR KWE
-ENCODING 4804
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 14 0 -2
+STARTCHAR uni11DD
+ENCODING 4573
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0CE0
-0C60
-0C60
-0C60
 0060
-007C
-0066
-01FC
-0300
+FC30
+4420
+4420
+4450
+4448
+4484
+7F04
+4200
 ENDCHAR
-STARTCHAR KWu/KW
-ENCODING 4805
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 0 0
+STARTCHAR uni11DE
+ENCODING 4574
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 1
 BITMAP
-C300
-7E00
-180C
-1B8C
-1FFF
-0C63
-0C60
-0C60
-0C60
-0C60
-0C60
-0C60
+0088
+FC44
+4444
+4444
+44AA
+44AA
+4511
+7F11
+4220
 ENDCHAR
-STARTCHAR we
-ENCODING 4808
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 8 0 1
+STARTCHAR uni11DF
+ENCODING 4575
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 8 1 1
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-CCC0
-EDC0
-7F00
+FC10
+4410
+4428
+4428
+4444
+4444
+7E82
+40FE
 ENDCHAR
-STARTCHAR wu
-ENCODING 4809
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 9 0 -1
+STARTCHAR uni11E0
+ENCODING 4576
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-CCE0
-EDC6
-7FFC
-000C
+00F0
+0004
+FDFC
+4420
+4420
+4420
+4450
+4448
+7E84
+4104
+0200
 ENDCHAR
-STARTCHAR wi
-ENCODING 4810
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11E1
+ENCODING 4577
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
-7F80
-0C00
-0C00
-1C00
-18C0
-1FC0
+0070
+FC04
+44FC
+4410
+4478
+4484
+4484
+7E84
+4078
 ENDCHAR
-STARTCHAR wa
-ENCODING 4811
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11E2
+ENCODING 4578
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 13 3 -1
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
+FF00
+4100
+4100
+4100
 7F80
-0C00
-0C00
-0C00
-0C00
-1C00
+4000
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
 ENDCHAR
-STARTCHAR wE
-ENCODING 4812
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11E3
+ENCODING 4579
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
-7F80
-0C00
 0C00
-1E00
-1980
-1F00
+C5F8
+4410
+4410
+7DF8
+4480
+4480
+4484
+7CF8
+4400
 ENDCHAR
-STARTCHAR w
-ENCODING 4813
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 8 0 1
+STARTCHAR uni11E4
+ENCODING 4580
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
 BITMAP
-3FC0
-76E0
-C660
-C67E
-CC66
-CCC2
-EDC0
-7F00
+0C04
+C5FC
+4400
+4518
+7C88
+4488
+4490
+4412
+7DFE
+4400
 ENDCHAR
-STARTCHAR wo
-ENCODING 4814
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11E5
+ENCODING 4581
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
-7F80
 0C00
-1800
-3000
-6000
-6000
-ENDCHAR
-STARTCHAR `e/e2
-ENCODING 4816
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
-BITMAP
-1E
-63
-C3
-C3
-C3
-C3
-C3
-C3
-C3
-7F
-60
-ENDCHAR
-STARTCHAR `u/u2
-ENCODING 4817
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
-BITMAP
-1E00
-6300
-C300
-C300
-C300
-C300
-C3F0
-C330
-C300
-7F00
-6000
+C4E0
+4408
+45F8
+7C20
+44F0
+4508
+4508
+7D08
+44F0
 ENDCHAR
-STARTCHAR `i/i2
-ENCODING 4818
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uni11E6
+ENCODING 4582
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 15 4 -2
 BITMAP
-3E00
-6300
-C300
-C300
-C300
-7F80
 0180
-0180
-0300
-0330
-03F0
-ENDCHAR
-STARTCHAR `a/A2
-ENCODING 4819
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
-BITMAP
-3E00
-6300
-C300
-C300
-C300
+C080
+4080
 7F80
-0180
-0180
-0180
-0300
-0300
+4080
+4080
+7F80
+4080
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
 ENDCHAR
-STARTCHAR `E/E2
-ENCODING 4820
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uni11E7
+ENCODING 4583
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-3E00
-6300
-C300
-C300
-C300
-7F80
-0180
-0180
-03E0
-0330
-03E0
+1900
+0DF8
+0808
+0808
+1408
+1408
+2208
+4208
+8008
 ENDCHAR
-STARTCHAR `I/I2
-ENCODING 4821
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 0
+STARTCHAR uni11E8
+ENCODING 4584
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-18
-18
-18
-7E
-E3
-C3
-C3
-C3
-C3
-C3
-C3
-7F
-60
+1808
+0CF8
+0880
+0880
+1480
+1480
+2280
+4288
+80FC
 ENDCHAR
-STARTCHAR `o/o2
-ENCODING 4822
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni11E9
+ENCODING 4585
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-3C
-66
-C3
-C3
-C3
-E7
-7E
-3C
-70
-C0
-C0
-C0
+1800
+0DF8
+0810
+0810
+15F8
+1480
+2280
+4284
+81F8
 ENDCHAR
-STARTCHAR ze
-ENCODING 4824
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11EA
+ENCODING 4586
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-C6
-C6
-C6
-C6
-C6
-FE
-FE
-C6
-C6
-C6
-C6
-C6
+1818
+0D88
+0888
+0888
+14F8
+1488
+2288
+4288
+80F8
+0088
 ENDCHAR
-STARTCHAR zu
-ENCODING 4825
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11EB
+ENCODING 4587
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
 BITMAP
-C600
-C600
-C600
-C600
-C600
-FE00
-FE00
-C7E0
-C660
-C660
-C600
-C600
+0800
+0800
+1400
+2200
+2200
+4100
+8080
+8080
+FF80
 ENDCHAR
-STARTCHAR zi
-ENCODING 4826
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11EC
+ENCODING 4588
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 9 2 1
 BITMAP
-C600
-C600
-C600
-C600
-C600
-FE00
-FE00
-C600
-C600
-C600
-C660
-C7E0
+1200
+13F0
+7810
+8410
+8410
+8410
+8410
+8410
+7810
 ENDCHAR
-STARTCHAR za
-ENCODING 4827
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11ED
+ENCODING 4589
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 1 1
 BITMAP
-C6
-C6
-C6
-C6
-FE
-FE
-C6
-C6
-C6
-06
-06
-06
+2420
+27BC
+7084
+8884
+8884
+8884
+8884
+8884
+7084
 ENDCHAR
-STARTCHAR zE
-ENCODING 4828
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni11EE
+ENCODING 4590
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-C600
-C600
-C600
-C600
-C600
-FE00
-FE00
-C600
-C600
-C7C0
-C660
-C7C0
+1020
+1020
+78F0
+8508
+8508
+8508
+8508
+8508
+78F0
 ENDCHAR
-STARTCHAR z
-ENCODING 4829
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni11EF
+ENCODING 4591
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-70C0
-D8C0
-D8C0
-18C0
-18C0
-1FC0
-1FC0
-18C0
-18C0
-18C0
-18C0
-18C0
+1008
+11F8
+7908
+8408
+8438
+85D0
+8410
+8420
+7840
+0080
 ENDCHAR
-STARTCHAR zo
-ENCODING 4830
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni11F0
+ENCODING 4592
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 9 9 4 1
 BITMAP
-C6
-C6
-C6
-C6
-FE
-FE
-C6
-C6
-C6
-C0
-C0
-C0
+0800
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR zWa
-ENCODING 4831
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni11F1
+ENCODING 4593
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-C600
-C600
-C600
-C600
-FE00
-FE00
-C600
-C600
-C600
-0600
-0600
-0600
-1F80
-30C0
+10C0
+1060
+7840
+8440
+84A0
+8490
+8508
+8608
+7C00
 ENDCHAR
-STARTCHAR Ze
-ENCODING 4832
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni11F2
+ENCODING 4594
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-1980
-1980
-1980
-1980
-1980
+1020
+1020
+7850
+8450
+8488
+8488
+8504
+8504
+79FC
 ENDCHAR
-STARTCHAR Zu
-ENCODING 4833
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni11F3
+ENCODING 4595
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 1 0
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-19F8
-1998
-1998
-1980
-1980
+020C
+FEC4
+0044
+8C44
+447C
+4444
+4844
+0944
+FF7C
+0044
 ENDCHAR
-STARTCHAR Zi
-ENCODING 4834
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni11F4
+ENCODING 4596
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-1980
-1980
-1980
-1998
-19F8
+0080
+7FC0
+0000
+2300
+1100
+1100
+0240
+FFE0
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
 ENDCHAR
-STARTCHAR Za
-ENCODING 4835
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni11F5
+ENCODING 4597
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 9 2 1
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1F80
-1F80
-1980
-1980
-1980
-0180
-0180
-0180
+7000
+0580
+FC80
+1080
+7880
+8480
+8488
+84B0
+78C0
 ENDCHAR
-STARTCHAR ZE
-ENCODING 4836
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni11F6
+ENCODING 4598
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-1980
-1980
-19F0
-1998
-19F0
+7000
+05F8
+FC10
+1010
+79F8
+8480
+8480
+8484
+78F8
 ENDCHAR
-STARTCHAR Z
-ENCODING 4837
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 13 0 0
+STARTCHAR uni11F7
+ENCODING 4599
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 1
 BITMAP
-C300
-7E00
-1800
-3870
-6CD8
-6CD8
-0CC0
-0FC0
-0FC0
-0CC0
-0CC0
-0CC0
-0CC0
+7000
+05F8
+FC88
+1088
+7888
+8488
+8488
+84FC
+7880
 ENDCHAR
-STARTCHAR Zo
-ENCODING 4838
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni11F8
+ENCODING 4600
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 10 2 0
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1F80
-1F80
-1980
-1980
-1980
-1800
-1800
-1800
+0018
+7188
+0488
+FC88
+10F8
+7888
+8488
+8488
+84F8
+7888
 ENDCHAR
-STARTCHAR ZWa
-ENCODING 4839
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 14 0 -2
+STARTCHAR uni11F9
+ENCODING 4601
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 11 3 0
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1F80
-1F80
-1980
-1980
-1980
-0180
-0180
-0180
-07E0
-0C30
+00C0
+FFE0
+0000
+0000
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
 ENDCHAR
-STARTCHAR ye
-ENCODING 4840
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR hoy-geez
+ENCODING 4608
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 0 0
 BITMAP
-38
-6C
-C6
-C6
-C6
-C6
-EC
-78
-30
-30
-30
-30
+0380
+E180
+6180
+6180
+6180
+6180
+6180
+6300
+6300
+3E00
+1C00
 ENDCHAR
-STARTCHAR yu
-ENCODING 4841
+STARTCHAR hoy-kaib
+ENCODING 4609
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 8 12 0 0
+BBX 14 11 0 0
 BITMAP
-38
-6C
-C6
-C6
-C6
-C6
-EC
-78
-30
-3F
-33
-30
+0380
+E180
+6180
+61FC
+6198
+6198
+618C
+6300
+6300
+3E00
+1C00
 ENDCHAR
-STARTCHAR yi
-ENCODING 4842
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR hoy-salis
+ENCODING 4610
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 13 0 -1
 BITMAP
-3800
-6C00
-C600
-C600
-C600
-C600
-EC00
-7800
+E700
+6300
+6300
+6300
+6600
+7E00
+0C00
+0C00
+1800
+1980
 3300
-3FC0
-30C0
-3000
+1F00
+0180
 ENDCHAR
-STARTCHAR ya
-ENCODING 4843
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR hoy-rabi
+ENCODING 4611
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 0 0
 BITMAP
-38
-6C
-C6
-C6
-C6
-CC
-F8
-70
-38
+E7
+63
+63
+63
+66
+7E
+06
+06
 0C
-38
-70
+0C
+18
+0C
 ENDCHAR
-STARTCHAR yE
-ENCODING 4844
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR hoy-hamis
+ENCODING 4612
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
 BITMAP
-3800
-6C00
-C600
-C600
-C600
-C600
-EC00
-7800
-3780
-3CC0
-3780
-3000
+E700
+6300
+6300
+6300
+6600
+7E00
+0C00
+0C00
+1980
+1980
+3300
+1C00
 ENDCHAR
-STARTCHAR y
-ENCODING 4845
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR hoy-sadis
+ENCODING 4613
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 11 0 0
 BITMAP
-0F00
-1980
-3180
+01C0
+E0C0
+60C0
+60C0
+F8C0
+30C0
+30C0
 3180
 3180
-1B00
-1E60
-0E60
-07C0
-7C00
-E000
-C000
-ENDCHAR
-STARTCHAR yo
-ENCODING 4846
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
-BITMAP
-3800
-6C00
-C600
-C7E0
-C660
-C600
-EC00
-7800
-3000
-3000
-3000
-3000
+1F00
+0E00
 ENDCHAR
-STARTCHAR yWa
-ENCODING 4847
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 15 0 -2
+STARTCHAR hoy-sabi
+ENCODING 4614
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
-E380
-7F00
-1C00
-1C00
-3600
-6300
-6300
+00F0
+0398
+E198
+6198
+61F0
+6180
+6180
+6180
 6300
 6300
-7600
-3C00
-1800
-1800
-1800
-1800
+3E00
+1C00
 ENDCHAR
-STARTCHAR de
-ENCODING 4848
-SWIDTH 960 0
-DWIDTH 16 0
+STARTCHAR lawi-geez
+ENCODING 4616
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 12 0 0
 BITMAP
+3000
+3800
 1C00
 3E00
-6200
-6200
+7600
 6600
-7C00
-3000
-1800
-1800
-0C00
-FFC0
-C0C0
+E700
+C300
+C300
+C300
+C380
+E1C0
 ENDCHAR
-STARTCHAR du
-ENCODING 4849
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR lawi-kaib
+ENCODING 4617
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
+3000
+3800
 1C00
 3E00
-6200
-6600
-7C00
-3000
-1800
-7F00
+7618
+6670
+E7B0
+C318
 C300
-C3F0
-0630
-0600
+C300
+C380
+E1C0
 ENDCHAR
-STARTCHAR di
-ENCODING 4850
+STARTCHAR lawi-salis
+ENCODING 4618
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 11 12 0 0
+BBX 14 13 0 -1
 BITMAP
+3000
+3800
 1C00
 3E00
-6200
+7600
 6600
-7C00
-3000
-1800
-7F00
+E700
 C300
 C300
-0660
-07E0
-ENDCHAR
-STARTCHAR da
-ENCODING 4851
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
-BITMAP
-1C
-3E
-62
-66
-7C
-30
-18
-FF
-C3
-C3
-03
-03
+C30C
+C398
+E1F8
+000C
 ENDCHAR
-STARTCHAR dE
-ENCODING 4852
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR lawi-rabi
+ENCODING 4619
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
+3000
+3800
 1C00
 3E00
-6200
-6200
+7600
 6600
-7C00
-3000
-1800
-1800
-0FC0
-FE60
-C3C0
+E700
+C300
+E300
+0300
+0380
+01C0
 ENDCHAR
-STARTCHAR d
-ENCODING 4853
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR lawi-hamis
+ENCODING 4620
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
+3000
+3800
 1C00
 3E00
-63E0
-6260
+7600
 6600
-7C00
-3000
-1800
-1800
-0C00
-FFC0
-C0C0
+E700
+C300
+C3F0
+C318
+C318
+E1F0
 ENDCHAR
-STARTCHAR do
-ENCODING 4854
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR lawi-sadis
+ENCODING 4621
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 0 0
 BITMAP
-0E00
-1F00
-3100
-3300
-3E00
+3000
+3800
 1C00
-3F80
-6180
-C000
-C000
-C000
-C000
+3E00
+7600
+6700
+E300
+C380
+F980
+CD80
+CDC0
+F8E0
 ENDCHAR
-STARTCHAR dWa
-ENCODING 4855
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR lawi-sabi
+ENCODING 4622
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 12 0 0
 BITMAP
+3000
+3800
 1C00
 3E00
-6200
-6600
-7C00
-3000
-1800
-FF00
+763E
+6673
+E7B3
+C31E
 C300
 C300
-0300
-0300
-0FC0
-1860
-ENDCHAR
-STARTCHAR De
-ENCODING 4856
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
-BITMAP
-10
-10
-38
-7C
-C4
-CC
-F8
-60
-30
-18
-FF
-C3
+C380
+E1C0
 ENDCHAR
-STARTCHAR Du
-ENCODING 4857
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR lawi-zemede-rabi
+ENCODING 4623
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 14 0 -2
 BITMAP
-0800
-0800
+3000
+3800
 1C00
 3E00
-6200
+7600
 6600
-7C00
-3000
-7F00
-C3F0
-C630
-0600
-ENDCHAR
-STARTCHAR Di
-ENCODING 4858
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
-BITMAP
-0800
-0800
-1C00
-3E00
-6200
-6600
-7C00
-3000
-7F00
+E700
 C300
-C660
-07E0
+E300
+0380
+01C0
+0FF0
+0C30
+1818
 ENDCHAR
-STARTCHAR Da
-ENCODING 4859
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR hawt-geez
+ENCODING 4624
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
-08
-08
-1C
-3E
-62
-66
-7C
-30
-FF
-C3
-03
-03
+0E00
+0600
+0600
+0600
+07C0
+3EE0
+6660
+6670
+C630
+C630
+C630
+E738
 ENDCHAR
-STARTCHAR DE
-ENCODING 4860
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR hawt-kaib
+ENCODING 4625
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 0
 BITMAP
-1000
-1000
-3800
-7C00
-C400
-CC00
-F800
-6000
-3000
-1BC0
-FE60
-C3C0
+0E0000
+060000
+060000
+060000
+07C000
+3EE180
+666700
+667B00
+C63180
+C63000
+C63000
+E73800
 ENDCHAR
-STARTCHAR D
-ENCODING 4861
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR hawt-salis
+ENCODING 4626
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 13 0 -1
 BITMAP
-1000
-1000
+0E00
+0600
+0600
+0600
+07C0
+3EE0
+6660
+6670
+C630
+C633
+C636
+E73E
+0003
+ENDCHAR
+STARTCHAR hawt-rabi
+ENCODING 4627
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
+BITMAP
+0E00
+0600
+0600
+0600
+07C0
+3EE0
+6660
+6670
+C630
+E730
+0030
+0038
+ENDCHAR
+STARTCHAR hawt-hamis
+ENCODING 4628
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 0
+BITMAP
+0E0000
+060000
+060000
+060000
+07C000
+3EE000
+666000
+667000
+C63F00
+C63180
+C63180
+E73F00
+ENDCHAR
+STARTCHAR hawt-sadis
+ENCODING 4629
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
+BITMAP
 3800
-7C00
-C7C0
-CCC0
-F800
-6000
-3000
 1800
-FF00
-C300
+1800
+1E00
+07C0
+3EE0
+6660
+6670
+C630
+C630
+C630
+E738
 ENDCHAR
-STARTCHAR Do
-ENCODING 4862
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR hawt-sabi
+ENCODING 4630
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
-0400
-0400
 0E00
-1F00
-3100
-3300
-3E00
-1FC0
-30C0
-6000
-6000
-6000
+0600
+0600
+0600
+07C0
+3EE0
+6660
+6670
+C630
+C738
+C000
+E000
 ENDCHAR
-STARTCHAR DWa
-ENCODING 4863
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 16 0 -2
+STARTCHAR hawt-zemede-rabi
+ENCODING 4631
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 15 0 -2
 BITMAP
-0800
-0800
-1C00
-3E00
-6200
-6600
-7C00
-3000
-1800
-FF00
-C300
-C300
-0300
-0300
-0FC0
-1860
+0E00
+0600
+0600
+0600
+07C0
+7EE0
+E660
+C670
+C630
+E730
+0030
+0030
+01FE
+0186
+0303
 ENDCHAR
-STARTCHAR je
-ENCODING 4864
+STARTCHAR may-geez
+ENCODING 4632
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 13 0 0
+BBX 14 7 0 3
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3100
-3300
-1E00
-1800
-1C00
-0C00
-7F80
-6180
+1FF8
+334C
+66CC
+C6CC
+CCCC
+CCF8
+F800
 ENDCHAR
-STARTCHAR ju
-ENCODING 4865
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 13 0 0
+STARTCHAR may-kaib
+ENCODING 4633
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 18 7 0 3
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-0C00
-3F80
-6180
-61F8
-0318
-0300
+1FF800
+334CC0
+66CF80
+C6CD80
+CCCCC0
+CCF800
+F80000
 ENDCHAR
-STARTCHAR ji
-ENCODING 4866
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 0
+STARTCHAR may-salis
+ENCODING 4634
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 14 0 -1
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-0C00
-3F80
-6180
-6180
-0330
-03F0
+0070
+3F98
+6598
+CD98
+CD98
+CD98
+CCF0
+D830
+6030
+0030
+0063
+0066
+007E
+0003
 ENDCHAR
-STARTCHAR ja
-ENCODING 4867
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 0
+STARTCHAR may-rabi
+ENCODING 4635
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 0 0
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-0C00
-7F80
-6180
-6180
-0180
-0180
+0070
+3F98
+6598
+CD98
+CD98
+CD98
+CCF0
+D830
+6030
+0030
+0060
+0060
+0070
 ENDCHAR
-STARTCHAR jE
-ENCODING 4868
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 0
+STARTCHAR may-hamis
+ENCODING 4636
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 13 0 0
 BITMAP
-C0C0
-7F80
+0070
+3F98
+6598
+CD98
+CD98
+CD98
+CCF0
+D830
+6030
+003E
+0063
+0063
+007E
+ENDCHAR
+STARTCHAR may-sadis
+ENCODING 4637
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 1 0
+BITMAP
+3FF0
+6D98
+CD98
+CD98
+CD98
+CDF0
+7C00
 0C00
-1E00
-3300
-3100
-3300
-1E00
 1800
-1C00
-0FE0
-7F30
-61E0
+3000
+6000
+E000
 ENDCHAR
-STARTCHAR j
-ENCODING 4869
+STARTCHAR may-sabi
+ENCODING 4638
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 12 13 0 0
+BBX 14 12 0 0
 BITMAP
-C0C0
-7F80
+3FF8
+66CC
+C6CC
+CCCC
+CCCC
+CCF8
+7C00
 0C00
-1E00
-3300
-31F0
-3330
-1E00
 1800
+1800
+1800
 1C00
-0C00
-7F80
-6180
 ENDCHAR
-STARTCHAR jo
-ENCODING 4870
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 0
+STARTCHAR may-zemede-rabi
+ENCODING 4639
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 0 -2
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-1FC0
-30C0
-6000
-6000
-6000
-6000
+0070
+3F98
+6598
+CD98
+CD98
+CD98
+CCF0
+D830
+6030
+0030
+0060
+0060
+03FC
+030C
+0606
 ENDCHAR
-STARTCHAR jWa
-ENCODING 4871
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 15 0 -2
+STARTCHAR sewt-geez
+ENCODING 4640
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 8 0 2
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-0C00
-7F80
-6180
-6180
-0180
-0180
-0FF0
-1C38
+E738
+6318
+6318
+C318
+C318
+C3B0
+67C0
+3E00
 ENDCHAR
-STARTCHAR ge
-ENCODING 4872
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR sewt-kaib
+ENCODING 4641
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 18 8 0 2
 BITMAP
-7C
-C6
-C6
-06
-06
-06
-0C
-0C
-0C
-0C
-0C
+E73800
+631800
+6318C0
+C31F80
+C31980
+C3B0C0
+67C000
+3E0000
 ENDCHAR
-STARTCHAR gu
-ENCODING 4873
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR sewt-salis
+ENCODING 4642
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 0 -1
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-0600
-0FE0
-0C60
-0C00
-0C00
-0C00
+EE70
+6630
+6630
+C670
+C660
+6FE0
+3C60
+0060
+0060
+00C6
+00CC
+00FC
+0006
 ENDCHAR
-STARTCHAR gi
-ENCODING 4874
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR sewt-rabi
+ENCODING 4643
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-0600
-0C00
-0C00
-0C00
-0CC0
-0FC0
+EE70
+6630
+6630
+C670
+C660
+6FE0
+3C60
+0060
+0060
+00C0
+00C0
+00E0
 ENDCHAR
-STARTCHAR ga
-ENCODING 4875
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR sewt-hamis
+ENCODING 4644
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 0 0
 BITMAP
-78
-FE
-C6
-06
-06
-06
-0C
-1C
-78
-E0
-C0
+EE70
+6630
+6630
+C670
+C660
+6FE0
+3C60
+0060
+007C
+00C6
+00C6
+00FC
 ENDCHAR
-STARTCHAR gE
-ENCODING 4876
+STARTCHAR sewt-sadis
+ENCODING 4645
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 11 0 0
+BBX 14 12 0 0
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-0600
-0C00
+3B9C
+198C
+198C
+319C
+3198
+3BF8
+7F00
+6000
+6000
+C000
+C000
+E000
+ENDCHAR
+STARTCHAR sewt-sabi
+ENCODING 4646
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
+BITMAP
+EE70
+6630
+6630
+C670
+C660
+6FC0
+3E00
 0C00
-0F80
-0CC0
-0F80
+1C00
+3800
+7000
+7000
 ENDCHAR
-STARTCHAR g
-ENCODING 4877
+STARTCHAR sewt-zemede-rabi
+ENCODING 4647
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 9 11 0 0
+BBX 14 14 0 -2
+BITMAP
+EE70
+6630
+6630
+C670
+C660
+6FE0
+3C60
+0060
+0060
+00C0
+00C0
+07F8
+0618
+0C0C
+ENDCHAR
+STARTCHAR ris-geez
+ENCODING 4648
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 13 0 -1
 BITMAP
+0780
+0380
+0700
+0E00
+1C00
+3800
+7000
+E000
+C000
+C180
+E300
 7F00
-CD80
-7980
-0180
 0180
-0300
-0300
-0300
-0300
-0300
-0300
 ENDCHAR
-STARTCHAR go
-ENCODING 4878
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR ris-kaib
+ENCODING 4649
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 -1
 BITMAP
-10
-10
-10
-7C
-C6
-C6
-06
-04
-0C
-0C
-0C
-0C
+1E00
+0E00
+1C00
+3800
+7000
+E000
+C000
+E000
+7FF0
+0660
+0660
+0630
+0700
 ENDCHAR
-STARTCHAR gWe
-ENCODING 4880
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR ris-salis
+ENCODING 4650
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-7C00
-C600
-C600
-0600
+0F00
+0700
 0600
-07E0
-0EB0
-0CE0
-0C00
-0C00
-0C00
+0E00
+1C00
+3800
+7000
+E1C0
+C0C0
+C0C0
+E300
+7C00
 ENDCHAR
-STARTCHAR gWi
-ENCODING 4882
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR ris-rabi
+ENCODING 4651
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
+0780
+0380
+0700
+0E00
+1C00
+3800
+7000
+E1F8
+C330
+C730
+E618
 7C00
-C600
-C600
-0600
-06C0
-06C0
-0FC0
-0C60
-0C60
-0C00
-0C00
 ENDCHAR
-STARTCHAR gWa
-ENCODING 4883
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR ris-hamis
+ENCODING 4652
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 -1
 BITMAP
-78
-CC
-CC
-0C
-7E
-66
-06
-06
-06
-06
-06
+0780
+0380
+0700
+0E00
+1C00
+3800
+7000
+E000
+C1E0
+C330
+E330
+7F30
+01E0
 ENDCHAR
-STARTCHAR gWE
-ENCODING 4884
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -2
+STARTCHAR ris-sadis
+ENCODING 4653
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 -1
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-0600
-0C00
-0C00
-0C00
-0F80
-0CC0
-3F80
-6000
+3F00
+6300
+C300
+C180
+C000
+C000
+C000
+C000
+C180
+E300
+7F00
+0180
 ENDCHAR
-STARTCHAR gWu/gW
-ENCODING 4885
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR ris-sabi
+ENCODING 4654
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 0 -1
 BITMAP
-7C00
-C6C0
-C6C0
-07F0
-0630
-0600
-0E00
-0C00
-0C00
-0C00
-0C00
+03C0
+3E60
+6660
+C660
+C3C0
+C000
+C000
+C000
+C000
+C180
+E300
+7F00
+0180
 ENDCHAR
-STARTCHAR Ge
-ENCODING 4888
+STARTCHAR ris-zemede-rabi
+ENCODING 4655
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 8 12 0 0
+BBX 14 15 0 0
 BITMAP
-C3
-7E
-00
-7C
-C6
-C6
-06
-04
-0C
-0C
-0C
-0C
+600C
+3018
+3FF8
+0380
+0380
+0700
+0E00
+1C00
+3800
+7000
+E1F8
+C330
+C730
+E618
+7C00
 ENDCHAR
-STARTCHAR Gu
-ENCODING 4889
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR sat-geez
+ENCODING 4656
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
 BITMAP
-C300
+1800
+1800
+1800
 7E00
-0000
-7C00
-C600
-C600
-0600
-0600
-0FE0
-0C60
-0C00
-0C00
+E700
+C300
+C300
+C300
+C300
+C300
+C300
+E380
 ENDCHAR
-STARTCHAR Gi
-ENCODING 4890
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR sat-kaib
+ENCODING 4657
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
+1800
+1800
+1800
+7E00
+E700
+C318
+C3F0
+C330
+C318
 C300
+C300
+E380
+ENDCHAR
+STARTCHAR sat-salis
+ENCODING 4658
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 0 -1
+BITMAP
+1800
+1800
+1800
 7E00
-0000
-7C00
-C600
-C600
-0600
-0400
-0C00
-0C00
-0CC0
-0FC0
+E700
+C300
+C300
+C300
+C300
+C318
+C330
+E3F0
+0018
 ENDCHAR
-STARTCHAR Ga
-ENCODING 4891
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR sat-rabi
+ENCODING 4659
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
 BITMAP
-C3
-7E
-00
-3C
-7F
-43
-03
-03
-0E
-3C
-70
-E0
+1800
+1800
+1800
+7E00
+E700
+C300
+C300
+C300
+E300
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR GE
-ENCODING 4892
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR sat-hamis
+ENCODING 4660
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
+1800
+1800
+1800
+7E00
+E700
+C300
 C300
+C300
+C3F0
+C318
+C318
+E3F0
+ENDCHAR
+STARTCHAR sat-sadis
+ENCODING 4661
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
+BITMAP
+6000
+3000
+1800
 7E00
-0000
-7C00
-C600
-C600
-0600
-0400
-0C00
-0F80
-0CC0
-0F80
+E700
+C300
+C300
+C300
+C300
+C300
+C300
+E380
 ENDCHAR
-STARTCHAR G
-ENCODING 4893
-SWIDTH 960 0
-DWIDTH 16 0
+STARTCHAR sat-sabi
+ENCODING 4662
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 9 12 0 0
 BITMAP
+1800
+1800
+1800
+7E00
+E700
+C300
+C300
 C300
+C380
+C000
+C000
+E000
+ENDCHAR
+STARTCHAR sat-zemede-rabi
+ENCODING 4663
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 -2
+BITMAP
+1800
+1800
+1800
 7E00
-0000
-7F00
-CD80
-7980
-0180
-0100
-0300
-0300
+E700
+C300
+C300
+C300
+E300
 0300
 0300
-ENDCHAR
-STARTCHAR Go
-ENCODING 4894
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
-BITMAP
-C6
-7C
-10
-7C
-C6
-C6
-06
-04
-0C
-0C
-0C
-0C
+1FE0
+1860
+3030
 ENDCHAR
-STARTCHAR GWa
-ENCODING 4895
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 14 0 -2
+STARTCHAR sha-sat-geez
+ENCODING 4664
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
 BITMAP
-C3
-7E
-00
-78
-CC
-CC
-0C
-7E
-66
-06
-06
-06
-06
-06
+0030
+0060
+E3E0
+7E70
+6600
+C600
+1F80
+39C0
+30C0
+30C0
+30C0
+30C0
+30C0
+30C0
+38E0
 ENDCHAR
-STARTCHAR Te
-ENCODING 4896
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 10 0 0
+STARTCHAR sha-sat-kaib
+ENCODING 4665
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 0 0
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C980
-C980
-C980
+0030
+0060
+E3E0
+7E70
+6600
+C600
+1F80
+39C0
+30CE
+30FC
+30CC
+30C6
+30C0
+30C0
+38E0
 ENDCHAR
-STARTCHAR Tu
-ENCODING 4897
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 10 0 0
+STARTCHAR sha-sat-salis
+ENCODING 4666
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 0 -1
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C9F8
-C998
-C980
-C980
-C980
+0030
+0060
+E3E0
+7E70
+6600
+C600
+1F80
+39C0
+30C0
+30C0
+30C0
+30C0
+30C6
+30CC
+38FC
+0006
 ENDCHAR
-STARTCHAR Ti
-ENCODING 4898
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 10 0 0
+STARTCHAR sha-sat-rabi
+ENCODING 4667
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C980
-C998
-C9F8
+0030
+0060
+E3E0
+7E70
+6600
+C600
+1F80
+39C0
+30C0
+30C0
+30C0
+38C0
+00C0
+00C0
+00E0
 ENDCHAR
-STARTCHAR Ta
-ENCODING 4899
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR sha-sat-hamis
+ENCODING 4668
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 0 0
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-0180
-0180
+0030
+0060
+E3E0
+7E70
+6600
+C600
+1F80
+39C0
+30C0
+30C0
+30C0
+30FC
+30C6
+30C6
+38FC
+ENDCHAR
+STARTCHAR sha-sat-sadis
+ENCODING 4669
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
+BITMAP
+0030
+0060
+E3E0
+7E70
+6600
+C300
+0FC0
+1CE0
+1860
+1860
+1860
+1860
+1860
+1860
+1C70
+ENDCHAR
+STARTCHAR sha-sat-sabi
+ENCODING 4670
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
+BITMAP
+0030
+0060
+E3E0
+7E70
+6600
+C600
+1F80
+39C0
+30C0
+30C0
+30C0
+30E0
+3000
+3000
+3800
+ENDCHAR
+STARTCHAR sha-sat-zemede-rabi
+ENCODING 4671
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 16 0 -2
+BITMAP
+C0C0
+6180
+7F80
+0C00
+0C00
+3F00
+7380
+6180
+6180
+6180
+7180
 0180
 0180
+0FF0
+0C30
+1818
 ENDCHAR
-STARTCHAR TE
-ENCODING 4900
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR qaf-geez
+ENCODING 4672
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C980
-C9F0
-C998
-C9F0
+1C00
+0C00
+0C00
+3F80
+6CC0
+CCC0
+CD80
+7F00
+0C00
+0C00
+0C00
+0E00
 ENDCHAR
-STARTCHAR T
-ENCODING 4901
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR qaf-kaib
+ENCODING 4673
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 0 0
 BITMAP
+1C00
+0C00
+0C00
 3F80
-7FC0
-4CC0
-CC60
-CE60
-C660
-0600
-0600
-0600
-0600
-0600
+6CC0
+CCC0
+CD80
+7F00
+0C60
+0FC0
+0CC0
+0E60
 ENDCHAR
-STARTCHAR To
-ENCODING 4902
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR qaf-salis
+ENCODING 4674
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 0 -1
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C000
-C000
-C000
+1C00
+0C00
+0C00
+3F80
+6CC0
+CCC0
+CD80
+7F00
+0C00
+0C60
+0CC0
+0FC0
+0060
+ENDCHAR
+STARTCHAR qaf-rabi
+ENCODING 4675
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 -2
+BITMAP
+0700
+0300
+0300
+0FE0
+1B30
+3330
+3360
+1FC0
+0300
+0600
+FC00
+6000
+6000
 C000
 ENDCHAR
-STARTCHAR TWa
-ENCODING 4903
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 -2
+STARTCHAR qaf-hamis
+ENCODING 4676
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 0 -1
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-0180
-0180
-0180
-0180
-07E0
-0C30
+1C00
+0C00
+0C00
+3F80
+6CC0
+CCC0
+CD80
+7F00
+0C00
+0FC0
+0C60
+0C60
+0FC0
 ENDCHAR
-STARTCHAR Ce
-ENCODING 4904
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 10 0 0
+STARTCHAR qaf-sadis
+ENCODING 4677
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-1F80
-3FC0
-6260
-C230
-C230
-C230
-F338
-DAB6
-CAB2
-FBBE
+E000
+6000
+FC00
+0C00
+3F80
+6CC0
+CCC0
+CD80
+7F00
+0C00
+0C00
+0E00
 ENDCHAR
-STARTCHAR Cu
-ENCODING 4905
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 10 0 0
+STARTCHAR qaf-sabi
+ENCODING 4678
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 13 0 0
 BITMAP
-1F80
-3FC0
-6260
-C230
-C23F
-C233
-F338
-DAB4
-CAB2
-FBBE
+0F00
+1980
+1980
+1B00
+0C00
+3F80
+6CC0
+CCC0
+CD80
+7F00
+0C00
+0C00
+0E00
 ENDCHAR
-STARTCHAR Ci
-ENCODING 4906
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 10 0 0
+STARTCHAR qaf-zemede-geez
+ENCODING 4680
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-1F80
-3FC0
-6260
-C230
-C230
-C230
-F330
-DAB0
-CAB3
-FBBF
+1C00
+0C00
+0C00
+3F80
+6CC0
+CCC0
+CD80
+7F00
+0DE0
+0F30
+0D30
+0EE0
 ENDCHAR
-STARTCHAR Ca
-ENCODING 4907
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR qaf-zemede-salis
+ENCODING 4682
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 0
 BITMAP
-1FC0
-3FE0
-6230
-C230
-E330
-D2B0
-CAB0
-FBB0
-0030
-0068
-0064
-007C
+1C0000
+0C0000
+0C1800
+3F9800
+6CF800
+CCDF80
+CD8300
+7F0300
+0C0180
+0C0000
+0C0000
+0E0000
 ENDCHAR
-STARTCHAR CE
-ENCODING 4908
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 10 0 0
+STARTCHAR qaf-zemede-rabi
+ENCODING 4683
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 13 0 -1
 BITMAP
-1F80
-3FC0
-6260
-C23F
-C239
-C237
-F330
-DABC
-CAB2
-FBBE
+1C00
+0C00
+0C00
+3F80
+6CC0
+CCC0
+CD80
+7F00
+0C00
+FF80
+6180
+C180
+01C0
 ENDCHAR
-STARTCHAR C
-ENCODING 4909
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 11 0 0
+STARTCHAR qaf-zemede-hamis
+ENCODING 4684
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 -2
 BITMAP
+0E00
+0600
+0600
 1FC0
+3660
+6660
+66C0
+3F80
+0600
+07E0
+0630
+0630
 7FE0
-C630
-E638
-9724
-F33C
-0300
-0380
-0340
-0320
-03E0
+6000
+C000
 ENDCHAR
-STARTCHAR Co
-ENCODING 4910
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR qaf-zemede-kaib
+ENCODING 4685
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 12 0 0
 BITMAP
-1FC0
-3FE0
-3430
-6430
-4630
-C528
-C4A4
-C738
-E000
-D000
-C800
-F800
+1C00
+0C00
+0C18
+3F98
+6CFF
+CCC6
+CD86
+7F03
+0C00
+0C00
+0C00
+0E00
 ENDCHAR
-STARTCHAR CWa
-ENCODING 4911
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 13 0 -2
+STARTCHAR qha-qaf-geez
+ENCODING 4688
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
 BITMAP
+0030
+0060
+E3E0
+7E70
+6600
+C600
 1FC0
-3FE0
-6230
-C230
-E330
-D2B0
-CAB0
-FBB0
+3660
+6660
+66C0
+3F80
+0600
+0600
+0600
+0700
+ENDCHAR
+STARTCHAR qha-qaf-kaib
+ENCODING 4689
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
+BITMAP
 0030
 0060
+E3E0
+7E70
+6600
+C600
+1FC0
+3660
+6660
+66C0
+3F80
+0630
+07E0
+0660
+0730
+ENDCHAR
+STARTCHAR qha-qaf-salis
+ENCODING 4690
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 16 0 -1
+BITMAP
+0030
 0060
-01F8
-030C
+E3E0
+7E70
+6600
+C600
+1FC0
+3660
+6660
+66C0
+3F80
+0600
+0630
+0660
+07E0
+0030
 ENDCHAR
-STARTCHAR Pe
-ENCODING 4912
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR qha-qaf-rabi
+ENCODING 4691
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 17 0 -2
 BITMAP
-18
-18
-18
-3C
-66
-66
-3C
-7E
-E7
-C3
-C3
-C3
+0018
+0030
+71F0
+3F38
+3300
+6300
+0FE0
+1B30
+3330
+3360
+1FC0
+0300
+0600
+FC00
+6000
+6000
+C000
 ENDCHAR
-STARTCHAR Pu
-ENCODING 4913
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR qha-qaf-hamis
+ENCODING 4692
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 16 0 -1
 BITMAP
-1800
-1800
-1800
-3C00
-6600
+0030
+0060
+E3E0
+7E70
 6600
-3C00
-7E00
-E700
-C3F0
-C330
-C300
+C600
+1FC0
+3660
+6660
+66C0
+3F80
+0600
+07E0
+0630
+0630
+07E0
 ENDCHAR
-STARTCHAR Pi
-ENCODING 4914
+STARTCHAR qha-qaf-sadis
+ENCODING 4693
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 12 12 0 0
+BBX 14 15 0 0
 BITMAP
-1800
-1800
-1800
-3C00
-6600
+0030
+0060
+E3E0
+7E70
 6600
-3C00
-7E00
-E700
-C300
-C330
-C3F0
+C7C0
+00C0
+03F8
+06CC
+0CCC
+0CD8
+07F0
+00C0
+00C0
+00E0
 ENDCHAR
-STARTCHAR Pa
-ENCODING 4915
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR qha-qaf-sabi
+ENCODING 4694
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 18 0 0
 BITMAP
-18
-18
-18
-3C
-66
-3C
-7E
-E7
-C7
-C3
-03
-03
+0030
+0060
+E3E0
+7E70
+6600
+C780
+0CC0
+0CC0
+0D80
+0600
+1FC0
+3660
+6660
+66C0
+3F80
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR PE
-ENCODING 4916
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR qha-qaf-zemede-geez
+ENCODING 4696
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 15 0 0
 BITMAP
-1800
-1800
-1800
-3C00
+0030
+0060
+E3E0
+7E70
 6600
+C600
+1FC0
+3660
+6660
+66C0
+3F80
+06F0
+0798
+0698
+0770
+ENDCHAR
+STARTCHAR qha-qaf-zemede-salis
+ENCODING 4698
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 18 15 0 0
+BITMAP
+003000
+006000
+E3E000
+7E7000
+660000
+C60C00
+1FCC00
+367C00
+666FC0
+66C180
+3F8180
+0600C0
+060000
+060000
+070000
+ENDCHAR
+STARTCHAR qha-qaf-zemede-rabi
+ENCODING 4699
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 16 0 -1
+BITMAP
+0030
+0060
+E3E0
+7E70
 6600
-3C00
-7E00
-E700
-C3E0
-C330
-C3E0
+C600
+1FC0
+3660
+6660
+66C0
+3F80
+0600
+7FC0
+30C0
+60C0
+00E0
 ENDCHAR
-STARTCHAR P
-ENCODING 4917
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR qha-qaf-zemede-hamis
+ENCODING 4700
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 18 0 -2
 BITMAP
-1800
-1800
-1800
-3C00
-67E0
+0030
+0060
+E3E0
+7E70
+6600
+C600
+1FC0
+3660
 6660
-3C00
-7E00
-E700
-C300
-C300
-C300
+66C0
+3F80
+0600
+07E0
+0630
+0630
+7FE0
+6000
+C000
 ENDCHAR
-STARTCHAR Po
-ENCODING 4918
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR qha-qaf-zemede-kaib
+ENCODING 4701
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 15 0 0
 BITMAP
-18
-18
-18
-3C
-66
-3C
-7E
-E7
-C3
-C3
-C0
-C0
+003000
+006000
+E3E000
+7E7000
+660000
+C60C00
+1FCC00
+367F80
+666300
+66C300
+3F8180
+060000
+060000
+060000
+070000
 ENDCHAR
-STARTCHAR PWa
-ENCODING 4919
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR bet-geez
+ENCODING 4704
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
 BITMAP
-1800
-1800
-1800
 3C00
-6600
-3C00
 7E00
 E700
 C300
 C300
-0300
-0300
-0FC0
-1860
-ENDCHAR
-STARTCHAR Se
-ENCODING 4920
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 10 0 0
-BITMAP
-18
-3C
-66
-66
-3C
-7E
-E7
-C3
-C3
-C3
+C300
+C300
+C300
+C300
+C300
+C300
+E380
 ENDCHAR
-STARTCHAR Su
-ENCODING 4921
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 10 0 0
+STARTCHAR bet-kaib
+ENCODING 4705
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
-1800
-3C00
-6600
-6600
 3C00
 7E00
-E700
+C300
+C300
+C318
 C3F0
 C330
+C318
+C300
 C300
+C300
+E380
 ENDCHAR
-STARTCHAR Si
-ENCODING 4922
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 10 0 0
+STARTCHAR bet-salis
+ENCODING 4706
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 0 -1
 BITMAP
-1800
-3C00
-6600
-6600
 3C00
 7E00
 E700
 C300
+C300
+C300
+C300
+C300
+C300
+C318
 C330
-C3F0
-ENDCHAR
-STARTCHAR Sa
-ENCODING 4923
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
-BITMAP
-18
-3C
-66
-66
-3C
-7E
-E6
-C7
-C3
-03
-03
+E3F0
+0018
 ENDCHAR
-STARTCHAR SE
-ENCODING 4924
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 10 0 0
+STARTCHAR bet-rabi
+ENCODING 4707
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
 BITMAP
-1800
-3C00
-6600
-6600
 3C00
 7E00
 E700
-C3C0
-C360
-C3C0
+C300
+C300
+C300
+C300
+E300
+0300
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR S
-ENCODING 4925
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 10 0 0
+STARTCHAR bet-hamis
+ENCODING 4708
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
-1800
 3C00
-67E0
-6660
-3C00
 7E00
 E700
 C300
 C300
 C300
+C300
+C300
+C3F0
+C318
+C318
+E3F0
 ENDCHAR
-STARTCHAR So
-ENCODING 4926
+STARTCHAR bet-sadis
+ENCODING 4709
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 8 11 0 0
+BBX 14 12 0 0
 BITMAP
-18
-3C
-66
-66
+01E0
+03F0
+0738
+0618
+0618
+7E18
+6618
+C618
+0618
+0618
+0618
+071C
+ENDCHAR
+STARTCHAR bet-sabi
+ENCODING 4710
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 0 0
+BITMAP
 3C
 7E
 E7
 C3
 C3
+C3
+C3
+C3
 C0
 C0
+C0
+E0
 ENDCHAR
-STARTCHAR SWa
-ENCODING 4927
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 0 -2
+STARTCHAR bet-zemede-rabi
+ENCODING 4711
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 -2
 BITMAP
-1800
-3C00
-6600
-6600
 3C00
 7E00
-E600
-C700
+E700
+C300
 C300
+C300
+C300
+E300
 0300
 0300
-0FC0
+0380
+1FE0
 1860
+3030
 ENDCHAR
-STARTCHAR `Se/S2e
-ENCODING 4928
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR ve-bet-geez
+ENCODING 4712
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 0 0
 BITMAP
-1E
-63
-C3
-C3
-C3
-FF
-C3
-C3
-C3
-7F
-60
+0060
+E0C0
+7FC0
+6060
+CF00
+1F80
+39C0
+30C0
+30C0
+30C0
+30C0
+30C0
+38E0
 ENDCHAR
-STARTCHAR `Su/S2u
-ENCODING 4929
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR ve-bet-kaib
+ENCODING 4713
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 0 0
 BITMAP
-1E00
-6300
-C300
-C300
-C300
-FF00
-C3F0
-C330
-C300
-7F00
-6000
+0060
+E0C0
+7FC0
+6060
+CF00
+1F80
+39C0
+30C6
+30FC
+30CC
+30C6
+30C0
+38E0
 ENDCHAR
-STARTCHAR `Si/S2i
-ENCODING 4930
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR ve-bet-salis
+ENCODING 4714
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 0 -1
 BITMAP
-7E00
-C300
-C300
-FF00
-C300
-C300
-7F00
-0300
-0300
-0300
-0330
-03F0
+0060
+E0C0
+7FC0
+6060
+CF00
+1F80
+39C0
+30C0
+30C0
+30C0
+30C6
+30CC
+38FC
+0006
 ENDCHAR
-STARTCHAR `Sa/S2a
-ENCODING 4931
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR ve-bet-rabi
+ENCODING 4715
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 0 0
 BITMAP
-7E
-C3
-C3
-FF
-C3
-C3
-7F
-03
-03
-03
-03
-03
+0060
+E0C0
+7FC0
+6060
+CF00
+1F80
+39C0
+30C0
+30C0
+30C0
+38C0
+00C0
+00E0
 ENDCHAR
-STARTCHAR `SE/S2E
-ENCODING 4932
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR ve-bet-hamis
+ENCODING 4716
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 0 0
 BITMAP
-7E00
-C300
-C300
-FF00
-C300
-C300
-7F00
-0300
-0300
-03E0
-0330
-03E0
+0060
+E0C0
+7FC0
+6060
+CF00
+1F80
+39C0
+30C0
+30C0
+30FC
+30C6
+30C6
+38FC
 ENDCHAR
-STARTCHAR `S/S2
-ENCODING 4933
+STARTCHAR ve-bet-sadis
+ENCODING 4717
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 8 13 0 0
+BBX 14 13 0 0
 BITMAP
-18
-18
-18
-7E
-E3
-C3
-C3
-FF
-C3
-C3
-C3
-7F
-60
+000C
+1C18
+0FF8
+0C0C
+19E0
+03F0
+0738
+0618
+FE18
+6618
+6618
+C618
+071C
 ENDCHAR
-STARTCHAR `So/S2o
-ENCODING 4934
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR ve-bet-sabi
+ENCODING 4718
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 0 0
 BITMAP
-3C
-66
-C3
-FF
-C3
-E7
-7E
-3C
-70
-C0
-C0
-C0
+0060
+E0C0
+7FC0
+6060
+CF00
+1F80
+39C0
+30C0
+30C0
+30C0
+30E0
+3000
+3800
 ENDCHAR
-STARTCHAR fe
-ENCODING 4936
+STARTCHAR ve-bet-zemede-rabi
+ENCODING 4719
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 11 0 0
+BBX 14 15 0 -2
+BITMAP
+0060
+E0C0
+7FC0
+6060
+CF00
+1F80
+39C0
+30C0
+30C0
+30C0
+38C0
+00C0
+07F8
+0618
+0C0C
+ENDCHAR
+STARTCHAR taw-geez
+ENCODING 4720
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
+0E00
 0600
-0200
 0600
-0C00
-1800
-3000
-7800
-CC00
-C440
-7FC0
-1F40
+07F0
+FE60
+6660
+6630
+C600
+0600
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR fu
-ENCODING 4937
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR taw-kaib
+ENCODING 4721
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-0400
-0C00
-1800
-3000
-6000
-F800
-C880
-CF80
-FE00
-1800
-3000
-3000
+0E00
+0600
+0600
+07F0
+FE60
+6660
+6630
+C600
+07F0
+0660
+0630
+0700
 ENDCHAR
-STARTCHAR fi
-ENCODING 4938
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR taw-salis
+ENCODING 4722
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 -1
 BITMAP
+0E00
 0600
-0200
 0600
-0C00
-1800
-3000
-78C0
-CC40
-C4C0
-7F80
-3E00
+07F0
+FE60
+6660
+6630
+C600
+0600
+0630
+0660
+07E0
+0030
 ENDCHAR
-STARTCHAR fa
-ENCODING 4939
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR taw-rabi
+ENCODING 4723
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 14 0 -2
 BITMAP
-0800
-0C00
-1800
-1000
-3000
-7000
-D800
-CC80
-7FC0
-0C40
-0C00
-0C00
+0700
+0300
+0300
+03F8
+7F30
+3330
+3318
+6300
+0300
+0600
+FC00
+6000
+6000
+C000
 ENDCHAR
-STARTCHAR fE
-ENCODING 4940
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR taw-hamis
+ENCODING 4724
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
+0E00
 0600
-0200
 0600
-0C00
-1800
-3000
-7800
-CC00
-C4C0
-7FA0
-1F20
-01C0
+07F0
+FE60
+6660
+6630
+C600
+07E0
+0630
+0630
+0FE0
 ENDCHAR
-STARTCHAR f
-ENCODING 4941
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR taw-sadis
+ENCODING 4725
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 0
 BITMAP
-3E
-67
-43
-C0
-C0
-F8
-CF
-DD
-6C
-0C
-0C
-0C
+7000
+3000
+3E00
+6600
+0600
+0600
+FFF0
+6660
+6660
+C630
+0600
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR fo
-ENCODING 4942
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR taw-sabi
+ENCODING 4726
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-1F80
-3E40
-63C0
-C000
-C000
-C000
-F000
-E800
-C4C0
-6D80
-3F80
+0F00
+1980
+1980
+1980
+0F00
+FE00
+67F0
+6660
+C660
+0630
+0600
+0700
 ENDCHAR
-STARTCHAR fWa
-ENCODING 4943
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -2
+STARTCHAR taw-bet-zemede-rabi
+ENCODING 4727
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 -2
 BITMAP
-0800
-0C00
-1800
-1000
-3000
-7000
-D800
-CC80
-7FC0
-0C40
-0C00
-3F00
-6180
+0E00
+0600
+0600
+07F0
+FE60
+6660
+6630
+C600
+0600
+0600
+0600
+7FE0
+6060
+C030
 ENDCHAR
-STARTCHAR pe
-ENCODING 4944
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR cha-taw-geez
+ENCODING 4728
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
+0070
+E7E0
+7E60
+6670
+E600
+07F0
+FE60
+6660
+6630
+C600
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR pu
-ENCODING 4945
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR cha-taw-kaib
+ENCODING 4729
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0FC0
-0CC0
-0C00
-0C00
-0C00
+0070
+E3E0
+7E60
+6630
+C600
+07F0
+FE60
+6660
+6630
+C600
+07F0
+0660
+0630
+0600
 ENDCHAR
-STARTCHAR pi
-ENCODING 4946
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR cha-taw-salis
+ENCODING 4730
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 16 0 -1
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0CC0
-0FC0
+0030
+0060
+E1E0
+7E70
+6600
+C600
+07F0
+FE60
+6660
+6630
+C600
+0600
+0630
+0660
+07E0
+0030
 ENDCHAR
-STARTCHAR pa
-ENCODING 4947
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR cha-taw-rabi
+ENCODING 4731
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 18 0 -3
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-1800
-3000
+0030
+0060
+E1E0
+7E70
+6600
+C600
+07F0
+FE60
+6660
+6630
+C600
+0600
+0600
+1C00
+F000
+7000
 6000
-4000
+C000
 ENDCHAR
-STARTCHAR pE
-ENCODING 4948
+STARTCHAR cha-taw-hamis
+ENCODING 4732
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
+BITMAP
+0030
+0060
+E3E0
+7E70
+6600
+C600
+07F0
+FE60
+6660
+6630
+C600
+07E0
+0630
+0630
+0FE0
+ENDCHAR
+STARTCHAR cha-taw-sadis
+ENCODING 4733
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 12 0 0
+BBX 14 14 0 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-0C00
-0F80
-0CC0
-0F80
+E030
+7060
+7FE0
+0670
+0600
+0180
+0180
+3FFC
+1998
+1998
+318C
+0180
+0180
+01C0
 ENDCHAR
-STARTCHAR p
-ENCODING 4949
+STARTCHAR cha-taw-sabi
+ENCODING 4734
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 12 0 0
+BBX 14 17 0 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0F00
-0300
-0300
-0300
-0300
+0078
+E038
+7030
+7FE0
+E780
+0CC0
+0CC0
+0CC0
+0780
+FF00
+63FC
+6318
+C318
+030C
 0300
 0300
+0380
 ENDCHAR
-STARTCHAR po
-ENCODING 4950
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR cha-taw-bet-zemede-rabi
+ENCODING 4735
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 -2
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-1800
-1800
-3000
-3000
-3000
-3000
+03F0
+FE60
+6660
+6630
+C600
+07F0
+FE60
+6660
+6630
+C600
+0600
+0600
+7FE0
+70E0
+E070
 ENDCHAR
-STARTCHAR pWa
-ENCODING 4951
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR harm-geez
+ENCODING 4736
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-7F80
-E1C0
+0E00
+0600
+0600
+7E00
+67C0
+C0C0
+00C0
+01C0
+0180
+0180
+0180
+01C0
 ENDCHAR
-STARTCHAR mYa
-ENCODING 4952
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 15 2 -1
+STARTCHAR harm-kaib
+ENCODING 4737
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 0 0
 BITMAP
-7070
-1FC0
-0700
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0040
-0040
-0040
+0E00
+0600
+0600
+7E00
+67C0
+C0C0
+00FE
+01CC
+018C
+0186
+0180
+01C0
 ENDCHAR
-STARTCHAR rYa
-ENCODING 4953
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 3 -1
+STARTCHAR harm-salis
+ENCODING 4738
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 0 -1
 BITMAP
-C0C0
-7F80
-0C00
-0C00
-0C00
-1800
-3800
-7000
-E000
-C300
-C380
-E180
-7F00
-3E00
+0E00
+0600
+0600
+7E00
+6780
+C180
+0180
+0380
+0300
+0318
+0330
+03F0
+0018
 ENDCHAR
-STARTCHAR fYa
-ENCODING 4954
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 2 0
+STARTCHAR harm-rabi
+ENCODING 4739
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 14 0 -2
 BITMAP
-6060
-3FC0
+0E00
 0600
-0200
 0600
-0C00
-1800
-3000
-78C0
-CC40
-C4C0
-7F80
-3E00
+7E00
+6780
+C180
+0180
+0180
+0300
+0E00
+F800
+6000
+6000
+C000
 ENDCHAR
-STARTCHAR Space
-ENCODING 4960
+STARTCHAR harm-hamis
+ENCODING 4740
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 0 0 0 0
+BBX 14 12 0 0
 BITMAP
+0600
+0600
+0600
+7E00
+67C0
+C0C0
+00C0
+01C0
+01F8
+018C
+018C
+01F8
 ENDCHAR
-STARTCHAR Ethiopic-Wordspace
-ENCODING 4961
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 2 6 2 2
+STARTCHAR harm-sadis
+ENCODING 4741
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
 BITMAP
-C0
-C0
-00
-00
-C0
-C0
+1C00
+0C00
+0C00
+3C00
+6F80
+C180
+C180
+0380
+0300
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR Ethiopic-Full-Stop
-ENCODING 4962
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 6 6 0 2
+STARTCHAR harm-sabi
+ENCODING 4742
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 13 0 0
 BITMAP
-CC
-CC
-00
-00
-CC
-CC
+000F00
+01F980
+031980
+061980
+7E0F00
+660000
+C70000
+03F000
+003000
+003000
+003000
+003000
+003800
 ENDCHAR
-STARTCHAR Ethiopic-Comma
-ENCODING 4963
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 6 7 0 2
+STARTCHAR harm-zemede-geez
+ENCODING 4744
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 0
 BITMAP
-FC
-00
-30
-30
-00
-30
-30
+0E0000
+060000
+060000
+7E0000
+67C000
+C0FF00
+00D980
+01D980
+018F00
+018000
+018000
+01C000
 ENDCHAR
-STARTCHAR Ethiopic-Semicolon
-ENCODING 4964
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 6 9 0 1
+STARTCHAR harm-zemede-salis
+ENCODING 4746
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 0
 BITMAP
-FC
-00
-30
-30
-00
-30
-30
-00
-FC
+0E0000
+060000
+060000
+7E1800
+67D800
+C0F800
+00DF80
+01C300
+018300
+018180
+018000
+01C000
 ENDCHAR
-STARTCHAR Ethiopic-Colon
-ENCODING 4965
+STARTCHAR harm-zemede-rabi
+ENCODING 4747
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 6 7 0 2
+BBX 14 13 0 -1
 BITMAP
-30
-30
-00
-FC
-00
-30
-30
+0E00
+0600
+0600
+7E00
+67C0
+C0C0
+00C0
+00C0
+00C0
+1FF8
+0C18
+1818
+001C
 ENDCHAR
-STARTCHAR Ethiopic-Preface-Colon
-ENCODING 4966
+STARTCHAR harm-zemede-hamis
+ENCODING 4748
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 6 7 0 2
+BBX 14 14 0 -2
 BITMAP
-C0
-C0
-00
-7C
-00
-C0
-C0
+0E00
+0600
+0600
+7E00
+67C0
+C0C0
+00C0
+01C0
+01F8
+018C
+018C
+1FF8
+1800
+3000
 ENDCHAR
-STARTCHAR Ethiopic-Question-Mark
-ENCODING 4967
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 2 10 0 1
+STARTCHAR harm-zemede-kaib
+ENCODING 4749
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 12 0 0
 BITMAP
-C0
-C0
-00
-00
-C0
-C0
-00
-00
-C0
-C0
+0E00
+0600
+0600
+7E00
+67D8
+C0D8
+00FF
+01C6
+0186
+0183
+0180
+01C0
 ENDCHAR
-STARTCHAR Ethiopic-End-Paragraph
-ENCODING 4968
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 9 0 1
+STARTCHAR nehas-geez
+ENCODING 4752
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 0 0
 BITMAP
+E0
+60
+60
+60
+7E
+0E
+0C
+0C
 18
 18
-C3
-DB
-18
-C3
-C3
-18
 18
+1C
 ENDCHAR
-STARTCHAR Ethiopic-1
-ENCODING 4969
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -1
+STARTCHAR nehas-kaib
+ENCODING 4753
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 0 0
 BITMAP
-C180
-7F00
-0000
-0C00
+E000
+6000
+6000
+6000
+7E00
 0C00
+0FE0
+0CC0
+18C0
+1860
 1800
-3E00
-6300
-6300
-3E00
-0000
-7F00
-C180
+1C00
 ENDCHAR
-STARTCHAR Ethiopic-2
-ENCODING 4970
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -1
+STARTCHAR nehas-salis
+ENCODING 4754
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 13 0 -1
 BITMAP
-C180
-7F00
-0000
-1C00
-3600
-6600
-7C00
+E000
 6000
-7C00
-3600
-1C00
-7F00
-C180
+6000
+6000
+7E00
+0E00
+0C00
+0C00
+1800
+18C0
+1980
+1F80
+00C0
 ENDCHAR
-STARTCHAR Ethiopic-3
-ENCODING 4971
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
-BITMAP
-C3
-7E
-00
-7E
-66
-60
-60
-60
-60
-00
-7E
-C3
-ENDCHAR
-STARTCHAR Ethiopic-4
-ENCODING 4972
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
+STARTCHAR nehas-rabi
+ENCODING 4755
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-C3
-7E
-00
-3C
-66
-66
-66
-66
-3C
-00
-7E
-C3
+3FC0
+7180
+E180
+C0C0
+C000
+E000
+7E00
+0600
+0600
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR Ethiopic-5
-ENCODING 4973
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -1
+STARTCHAR nehas-hamis
+ENCODING 4756
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-C180
-7F00
-0000
-1800
-1800
-3F00
-7300
+E000
 6000
-6300
-3F00
-0000
-7F00
-C180
+6000
+6000
+7E00
+0E00
+0C00
+0C00
+1F80
+18C0
+18C0
+1F80
 ENDCHAR
-STARTCHAR Ethiopic-6
-ENCODING 4974
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 14 0 -1
+STARTCHAR nehas-sadis
+ENCODING 4757
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-C180
-7F00
-0000
-3C00
-7E00
+FF00
+6700
 6600
+C600
+0FC0
+0180
+0180
+0300
+0300
 0600
-0C00
-0E00
-1B00
-1E00
-0000
-7F00
-C180
+0600
+0700
 ENDCHAR
-STARTCHAR Ethiopic-7
-ENCODING 4975
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 14 0 -1
+STARTCHAR nehas-sabi
+ENCODING 4758
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 0
 BITMAP
-C180
-7F00
-0000
-3C00
+01E0
+3F30
+7330
+E330
+C1E0
+C000
+E000
 7E00
-6600
 0600
-0C00
-0800
-1900
-1F00
-0000
-7F00
-C180
+0600
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR Ethiopic-8
-ENCODING 4976
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -1
+STARTCHAR neHes-zemede-rabi
+ENCODING 4759
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 14 0 -2
 BITMAP
-C0C0
-7F80
-0000
-7F80
-6D80
-0C00
-0C00
-0C00
-7F80
-6180
-0000
-7F80
+3FC0
+7180
+E180
 C0C0
+C000
+E000
+7E00
+0600
+0600
+0600
+0600
+3FC0
+30C0
+6060
 ENDCHAR
-STARTCHAR Ethiopic-9
-ENCODING 4977
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 -1
+STARTCHAR nye-nehas-geez
+ENCODING 4760
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 0
 BITMAP
-C3
-7E
-00
-00
-66
-66
-7E
-66
-64
-38
-00
-7E
-C3
+0030
+E060
+7FE0
+6670
+C600
+0600
+07E0
+00E0
+00C0
+00C0
+0180
+0180
+0180
+01C0
 ENDCHAR
-STARTCHAR Ethiopic-10
-ENCODING 4978
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
+STARTCHAR nye-nehas-kaib
+ENCODING 4761
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 0 0
 BITMAP
-C3
-7E
-00
-18
-18
-18
-18
-18
-18
-00
-7E
-C3
+0030
+E060
+7FE0
+6670
+C600
+0600
+07E0
+00C0
+00FE
+00CC
+018C
+0186
+0180
+01C0
 ENDCHAR
-STARTCHAR Ethiopic-20
-ENCODING 4979
+STARTCHAR nye-nehas-salis
+ENCODING 4762
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 12 0 -1
+BBX 14 15 0 -1
 BITMAP
-C0C0
-7F80
-0000
+0030
+E060
+7FE0
+6670
+C600
+0600
+07E0
+00E0
+00C0
+00C0
+0180
+018C
+0198
+01F8
+000C
+ENDCHAR
+STARTCHAR nye-nehas-rabi
+ENCODING 4763
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 16 0 0
+BITMAP
+0030
+C060
+7FE0
+6670
+C600
+1FE0
+38C0
+70C0
+6060
+6000
+7000
 3F00
-2D00
-0C00
-1E00
-3300
-3300
-0000
-7F80
-C0C0
+0300
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR Ethiopic-30
-ENCODING 4980
+STARTCHAR nye-nehas-hamis
+ENCODING 4764
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 12 0 -1
+BBX 14 14 0 0
 BITMAP
-C0C0
-7F80
-0000
-2F00
-6D80
-6D80
-6D80
-6D80
-3980
-0000
-7F80
-C0C0
+0030
+E060
+7FE0
+6670
+C600
+0600
+07E0
+00E0
+00C0
+00C0
+01F8
+018C
+018C
+01F8
 ENDCHAR
-STARTCHAR Ethiopic-40
-ENCODING 4981
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -1
+STARTCHAR nye-nehas-sadis
+ENCODING 4765
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 0
 BITMAP
-C0C0
-7F80
-0000
-6D80
-6D80
-6D80
-3F80
-0180
-0180
+C030
+6060
+7FE0
+0600
+3FC0
+19C0
+1980
+3180
+03F0
+0060
+0060
+00C0
+00C0
 0180
-0000
-7F80
-C0C0
+01C0
 ENDCHAR
-STARTCHAR Ethiopic-50
-ENCODING 4982
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 -1
+STARTCHAR nye-nehas-sabi
+ENCODING 4766
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 16 0 0
 BITMAP
-C3
-7E
-00
-3E
-66
-3E
-06
-0C
-0C
-0C
-00
-7E
-C3
+0030
+E060
+7FE0
+6670
+C600
+1FF0
+3998
+7198
+6198
+60F0
+7000
+3F00
+0300
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR Ethiopic-60
-ENCODING 4983
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -1
+STARTCHAR nye-neHes-zemede-rabi
+ENCODING 4767
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 19 0 -2
 BITMAP
-C0C0
-7F80
-0000
-7F80
-6D80
-0C00
-0E00
+C030
+6060
+7FE0
 0600
-7F80
-6180
-0000
-7F80
-C0C0
+0600
+1FE0
+38C0
+70C0
+6060
+6000
+7000
+3F00
+0300
+0300
+0300
+0300
+1FE0
+1860
+3030
 ENDCHAR
-STARTCHAR Ethiopic-70
-ENCODING 4984
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
+STARTCHAR alef-geez
+ENCODING 4768
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
 BITMAP
-C3
-7E
-00
-3E
-6B
-6E
-60
-66
-3E
-00
-7E
-C3
+E000
+6000
+7E00
+0C00
+1800
+1F00
+3300
+3180
+6180
+6180
+6180
+71C0
 ENDCHAR
-STARTCHAR Ethiopic-80
-ENCODING 4985
+STARTCHAR alef-kaib
+ENCODING 4769
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 11 12 0 -1
+BBX 14 12 0 0
 BITMAP
-C060
-7FC0
-0000
-7FC0
-5B40
-1B00
-1B00
-1B00
-1B00
-0000
-7FC0
-C060
+E000
+6000
+7E00
+0C00
+1800
+1F00
+33FC
+3198
+6198
+618C
+6180
+71C0
 ENDCHAR
-STARTCHAR Ethiopic-90
-ENCODING 4986
+STARTCHAR alef-salis
+ENCODING 4770
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 9 14 0 -1
+BBX 14 13 0 -1
 BITMAP
-C180
-7F00
-0000
-3E00
-3600
-0C00
-0E00
-0600
-0C00
+E000
+6000
+7E00
 0C00
+1800
+1F00
+3300
+3180
+6180
+618C
+6198
+71F8
+000C
+ENDCHAR
+STARTCHAR alef-rabi
+ENCODING 4771
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 0 0
+BITMAP
+E000
+6000
+7E00
 0C00
-0000
-7F00
-C180
+1800
+1F00
+3300
+3180
+6180
+7180
+0180
+01C0
 ENDCHAR
-STARTCHAR Ethiopic-100
-ENCODING 4987
+STARTCHAR alef-hamis
+ENCODING 4772
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 8 13 0 -1
+BBX 14 12 0 0
 BITMAP
-C3
-7E
-00
-3C
-66
-7C
-60
-30
-30
-30
-00
-7E
-C3
+E000
+6000
+7E00
+0C00
+1800
+1F00
+3300
+3180
+61F8
+618C
+618C
+71F8
 ENDCHAR
-STARTCHAR Ethiopic-10000
-ENCODING 4988
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 -1
+STARTCHAR alef-sadis
+ENCODING 4773
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 13 0 0
 BITMAP
-C030
-7FE0
-0000
-79E0
-CF30
-FBE0
-C300
+E000
+F800
+3000
+7E00
+0C00
+1800
+1F00
+3300
+3180
 6180
 6180
 6180
-0000
-7FE0
-C030
-ENDCHAR
-STARTCHAR char4991
-ENCODING 4991
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -1
-BITMAP
-0FE0
-1838
-37CC
-6CCC
-ECC6
-CCC6
-C8C6
-C8C6
-C8C4
-C8CC
-60F0
-7000
-3800
-0F80
-ENDCHAR
-STARTCHAR C068
-ENCODING 5024
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 0 0
-BITMAP
-FE00
-2180
-2080
-2040
-2040
-2040
-2040
-2040
-2080
-2180
-FE00
+71C0
 ENDCHAR
-STARTCHAR C082
-ENCODING 5025
+STARTCHAR alef-sabi
+ENCODING 4774
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 11 1 0
+BBX 9 12 0 0
 BITMAP
-FE00
-2100
-2080
-2080
-2100
-3E00
-2300
-2100
-2100
-2100
-F8E0
+E000
+6000
+7E00
+0C00
+1800
+1F00
+3300
+3180
+6180
+6000
+6000
+7000
 ENDCHAR
-STARTCHAR C084
-ENCODING 5026
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR alef-zemede-geez
+ENCODING 4775
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 14 0 0
 BITMAP
-FF80
-8880
-8880
-8880
-0800
-0800
-0800
-0800
-0800
-0800
-3E00
+C0C0
+6180
+7F80
+0C00
+0FC0
+0180
+0300
+03E0
+0660
+0630
+0C30
+0C30
+0C30
+0E38
 ENDCHAR
-STARTCHAR 0071
-ENCODING 5027
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR kaf-geez
+ENCODING 4776
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-0E00
-0400
-0E00
-1100
-2080
-6080
-9080
-9080
-9080
-9300
-4000
+E000
+6000
+6780
+6FC0
+1CE0
+1860
+1860
+1860
+1860
+1860
+1860
+1C70
 ENDCHAR
-STARTCHAR C079
-ENCODING 5028
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR kaf-kaib
+ENCODING 4777
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 12 0 0
 BITMAP
-3800
-4460
-8250
-8210
-8230
-83E0
-8200
-8200
-8200
-4400
-3800
+E000
+6000
+6780
+6FC0
+1CE0
+1863
+187E
+1866
+1863
+1860
+1860
+1C70
 ENDCHAR
-STARTCHAR 0x0069
-ENCODING 5029
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 11 1 0
+STARTCHAR kaf-salis
+ENCODING 4778
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 13 0 -1
 BITMAP
-C0
-C0
-00
-00
-C0
-40
-40
-40
-40
-40
-E0
+E000
+6000
+6780
+6FC0
+1CE0
+1860
+1860
+1860
+1860
+1863
+1866
+1C7E
+0003
 ENDCHAR
-STARTCHAR C083
-ENCODING 5030
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 11 0 0
+STARTCHAR kaf-rabi
+ENCODING 4779
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-3E
-42
-42
-40
-20
-FF
-04
-02
-42
-42
-7C
+E000
+6000
+6780
+6FC0
+1CE0
+1860
+1860
+1860
+1C60
+0060
+0060
+0070
 ENDCHAR
-STARTCHAR C079
-ENCODING 5031
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR kaf-hamis
+ENCODING 4780
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 12 0 0
 BITMAP
-3E00
-0100
-6080
-9040
-9040
-9040
-A040
-C040
-8080
-4100
-3E00
+E000
+6000
+6780
+6FC0
+1CE0
+1860
+1860
+1860
+187E
+1863
+1863
+1C7E
 ENDCHAR
-STARTCHAR C073
-ENCODING 5032
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR kaf-sadis
+ENCODING 4781
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-F8
-20
-20
-29
-29
-3A
-24
-20
-20
-20
-F8
+E000
+6000
+6780
+6FC0
+1CE0
+3860
+0E60
+0C60
+1860
+1860
+1860
+1C70
 ENDCHAR
-STARTCHAR C117
-ENCODING 5033
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 0
+STARTCHAR kaf-sabi
+ENCODING 4782
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-F1E0
-2080
-1080
-1100
-0900
-0900
-0A00
-0600
-4400
-4400
-3800
+E000
+6000
+6780
+6FC0
+1CE0
+1860
+1860
+1860
+1870
+1800
+1800
+1C00
 ENDCHAR
-STARTCHAR C065
-ENCODING 5034
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 0
+STARTCHAR kaf-zemede-geez
+ENCODING 4784
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 18 12 0 0
 BITMAP
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+E00000
+600000
+678000
+6FC000
+1CE000
+187F80
+186CC0
+186CC0
+186780
+186000
+186000
+1C7000
 ENDCHAR
-STARTCHAR C074
-ENCODING 5035
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 11 1 0
+STARTCHAR kaf-zemede-salis
+ENCODING 4786
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 19 12 0 0
 BITMAP
-7C
-10
-10
-10
-10
-10
-10
-10
-10
-90
-E0
+E00000
+600000
+678000
+6FC600
+1CE600
+187E00
+1867E0
+1860C0
+1860C0
+186060
+186000
+1C7000
 ENDCHAR
-STARTCHAR C069
-ENCODING 5036
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 1 0
+STARTCHAR kaf-zemede-rabi
+ENCODING 4787
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 0 -1
 BITMAP
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
+E000
+6000
+6780
+6FC0
+1CE0
+1860
+1860
+1C60
+0060
+07FC
+030C
+060C
+000E
 ENDCHAR
-STARTCHAR C052
-ENCODING 5037
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR kaf-zemede-hamis
+ENCODING 4788
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 15 0 -2
 BITMAP
-1F00
-0400
-0400
-6400
-9FE0
-9420
-6440
-0480
-0500
+E000
+6000
+6780
+6FC0
+1CE0
+1860
+1860
+1860
+1C60
+007E
+0063
+0063
+07FE
 0600
-0400
+0C00
 ENDCHAR
-STARTCHAR 0x0069
-ENCODING 5038
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR kaf-zemede-kaib
+ENCODING 4789
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 0
 BITMAP
-78
-84
-82
-02
-02
-E2
-42
-44
-78
-40
-40
-E0
+E00000
+600000
+678C00
+6FCC00
+1CFF80
+186300
+186300
+186180
+186000
+186000
+186000
+1C7000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5039
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR kha-kaf-geez
+ENCODING 4792
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 0 0
 BITMAP
-0200
-0500
-0880
-0880
-0880
-1080
-1F80
-1080
-2100
-2100
-E700
+00C0
+0180
+E780
+7DC0
+6C00
+CCF0
+0DF8
+039C
+030C
+030C
+030C
+030C
+030C
+030C
+038E
 ENDCHAR
-STARTCHAR C073
-ENCODING 5040
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR kha-kaf-kaib
+ENCODING 4793
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 19 15 0 0
 BITMAP
-F8
-20
-20
-20
-22
-3E
-22
-20
-20
-20
-F8
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF000
+0DF800
+039C00
+030C60
+030FC0
+030CC0
+030C60
+030C00
+030C00
+038E00
 ENDCHAR
-STARTCHAR C103
-ENCODING 5041
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 11 0 0
+STARTCHAR kha-kaf-salis
+ENCODING 4794
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 19 16 0 -1
 BITMAP
-FF80
-2180
-2080
-2080
-2000
-2000
-2000
-2000
-2000
-2000
-F800
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF000
+0DF800
+039C00
+030C00
+030C00
+030C00
+030C00
+030C60
+030CC0
+038FC0
+000060
 ENDCHAR
-STARTCHAR C054
-ENCODING 5042
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR kha-kaf-rabi
+ENCODING 4795
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 0 0
 BITMAP
-1C00
-2200
-2200
-2200
-2200
-2200
-1400
-54E0
-8840
-8C40
-7380
+00C0
+0180
+E780
+7DC0
+6C00
+CCF0
+0DF8
+039C
+030C
+030C
+030C
+038C
+000C
+000C
+000E
 ENDCHAR
-STARTCHAR C087
-ENCODING 5043
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 11 1 0
+STARTCHAR kha-kaf-hamis
+ENCODING 4796
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 19 15 0 0
 BITMAP
-F1CF
-2184
-2184
-2244
-1248
-1248
-1248
-1428
-0C30
-0C30
-0810
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF000
+0DF800
+039C00
+030C00
+030C00
+030C00
+030FC0
+030C60
+030C60
+038FC0
 ENDCHAR
-STARTCHAR C111
-ENCODING 5044
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR kha-kaf-sadis
+ENCODING 4797
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 0 0
 BITMAP
-0C
-12
-22
-26
-60
-90
-88
-88
-88
-88
-70
+00C0
+0180
+E780
+7DC0
+6C00
+CCF0
+0DF8
+039C
+070C
+01CC
+018C
+030C
+030C
+030C
+038E
 ENDCHAR
-STARTCHAR C103
-ENCODING 5045
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR kha-kaf-sabi
+ENCODING 4798
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 0 0
 BITMAP
-1E
-21
-21
-21
-25
-26
-20
-20
-20
-20
-F8
+00C0
+0180
+E780
+7DC0
+6C00
+CCF0
+0DF8
+039C
+030C
+030C
+030C
+030E
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR C067
-ENCODING 5046
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR kha-kaf-zemede-geez
+ENCODING 4800
+SWIDTH 1380 0
+DWIDTH 23 0
+BBX 21 15 0 0
 BITMAP
-1E80
-2180
-4080
-8480
-8400
-8700
-8480
-8480
-4080
-2100
-1E00
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF000
+0DF800
+039C00
+030FF0
+030D98
+030D98
+030CF0
+030C00
+030C00
+038E00
 ENDCHAR
-STARTCHAR C077
-ENCODING 5047
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 11 1 0
+STARTCHAR kha-kaf-zemede-salis
+ENCODING 4802
+SWIDTH 1440 0
+DWIDTH 24 0
+BBX 22 15 0 0
 BITMAP
-F03C
-3030
-3030
-2850
-2850
-2890
-2490
-2490
-2310
-2310
-FB7C
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF000
+0DF8C0
+039CC0
+030FC0
+030CFC
+030C18
+030C18
+030C0C
+030C00
+038E00
 ENDCHAR
-STARTCHAR C103
-ENCODING 5048
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 11 1 0
+STARTCHAR kha-kaf-zemede-rabi
+ENCODING 4803
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 18 16 0 -1
 BITMAP
-F0
-C8
-84
-04
-04
-84
-E4
-9C
-04
-04
-1F
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF000
+0DF800
+039C00
+030C00
+030C00
+038C00
+000C00
+00FF80
+006180
+00C180
+0001C0
 ENDCHAR
-STARTCHAR C073
-ENCODING 5049
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 11 1 0
+STARTCHAR kha-kaf-zemede-hamis
+ENCODING 4804
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 19 18 0 -2
 BITMAP
-0F80
-0200
-0200
-0D0C
-7912
-94E0
-2200
-2200
-2200
-2200
-1C00
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF000
+0DF800
+039C00
+030C00
+030C00
+030C00
+038C00
+000FC0
+000C60
+000C60
+00FFC0
+00C000
+018000
 ENDCHAR
-STARTCHAR C096
-ENCODING 5050
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
-BITMAP
-1C20
-2220
-4120
-80A0
-80A0
-80E0
-80A0
-80A0
-4120
-2220
-1C20
+STARTCHAR kha-kaf-zemede-kaib
+ENCODING 4805
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 20 15 0 0
+BITMAP
+00C000
+018000
+E78000
+7DC000
+6C0000
+CCF180
+0DF980
+039FF0
+030C60
+030C60
+030C30
+030C00
+030C00
+030C00
+038E00
 ENDCHAR
-STARTCHAR C072
-ENCODING 5051
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 1 0
+STARTCHAR wewe-geez
+ENCODING 4808
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 9 0 2
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-FBE0
+3DC0
+6660
+C630
+C630
+C630
+C630
+C660
+EFC0
+7C00
 ENDCHAR
-STARTCHAR C099
-ENCODING 5052
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
+STARTCHAR wewe-kaib
+ENCODING 4809
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 0 1
 BITMAP
-F8
-20
-20
-70
-88
-08
-08
-08
-08
-88
-70
+3DC0
+6660
+C630
+C630
+C630
+C630
+C666
+EFFC
+7C0C
+0006
 ENDCHAR
-STARTCHAR C117
-ENCODING 5053
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR wewe-salis
+ENCODING 4810
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 -1
 BITMAP
-21E0
-2080
-1080
-1100
-0900
-0900
-0A00
+3FE0
+7670
+C630
+C630
+C630
+E660
+7FC0
 0600
-F400
-4400
-3800
+0600
+0630
+0660
+07E0
+0030
 ENDCHAR
-STARTCHAR C079
-ENCODING 5054
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 1 0
+STARTCHAR wewe-rabi
+ENCODING 4811
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-1E00
-2100
-4080
-8040
-8040
-FFC0
-8040
-8040
-4080
-2100
-1E00
+3FE0
+7670
+C630
+C630
+C630
+E660
+7FC0
+0600
+0600
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR C116
-ENCODING 5055
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR wewe-hamis
+ENCODING 4812
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-2000
-2000
-2000
-F800
-2000
-2000
-2000
-2380
-2100
-2100
-1F00
+3FE0
+7670
+C630
+C630
+C630
+E660
+7FC0
+0600
+07E0
+0630
+0630
+07E0
 ENDCHAR
-STARTCHAR C071
-ENCODING 5056
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 1 0
+STARTCHAR wewe-sadis
+ENCODING 4813
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 9 0 2
 BITMAP
-1E80
-2180
-4080
-8080
-8000
-8000
-83C0
-8080
-4080
-2180
-1E80
+3DC000
+666000
+C63180
+C63F00
+C63300
+C63180
+C66000
+EFC000
+7C0000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5057
+STARTCHAR wewe-sabi
+ENCODING 4814
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 13 11 1 0
+BBX 12 12 0 0
 BITMAP
+3FE0
+7670
+C630
+C630
+C630
+E660
+7FC0
 0E00
-1100
-1080
-1080
-1080
-1040
-1040
-1040
-D020
-9020
-6078
-ENDCHAR
-STARTCHAR C126
-ENCODING 5058
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 11 1 0
-BITMAP
-E0
-40
-40
-40
-40
-7C
-42
-42
-42
-42
-E7
-ENDCHAR
-STARTCHAR C090
-ENCODING 5059
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
-BITMAP
-FE
-C4
-84
-88
-08
-10
-22
-22
-42
-46
-FE
+1800
+3000
+3000
+3800
 ENDCHAR
-STARTCHAR C103
-ENCODING 5060
+STARTCHAR ayin-geez
+ENCODING 4816
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 11 1 0
+BBX 8 11 0 0
 BITMAP
-3C00
-4200
-E200
-0200
-0200
-E200
-4200
-3E00
-0200
-0200
-0F80
+0E
+7F
+E3
+C3
+C3
+C3
+C3
+C3
+C7
+FE
+70
 ENDCHAR
-STARTCHAR C096
-ENCODING 5061
+STARTCHAR ayin-kaib
+ENCODING 4817
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 14 11 1 0
-BITMAP
-1C00
-2200
-4100
-80A4
-80A4
-80E8
-8090
-8080
-4100
-2200
-1C00
-ENDCHAR
-STARTCHAR C084
-ENCODING 5062
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 11 1 0
+BBX 13 11 0 0
 BITMAP
-FF80
-8880
-8880
-8880
-0800
-0800
-0800
-0800
-8880
-8880
-FF80
+0E00
+7F00
+E300
+C300
+C3F8
+C330
+C330
+C318
+C700
+FE00
+7000
 ENDCHAR
-STARTCHAR char5063
-ENCODING 5063
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 11 1 0
+STARTCHAR ayin-salis
+ENCODING 4818
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 -1
 BITMAP
-0780
-0840
-0820
-0010
-0010
-4210
-8410
-8410
-8410
-8C20
-73C0
+3C00
+6600
+C600
+C600
+CC00
+7FC0
+0180
+0180
+0318
+0330
+03F0
+0018
 ENDCHAR
-STARTCHAR C054
-ENCODING 5064
+STARTCHAR ayin-rabi
+ENCODING 4819
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 0 0
 BITMAP
-6300
-9480
-9840
-9A40
-1980
-2400
-2400
-2400
-2400
-2400
-1800
+3C00
+6600
+C600
+C600
+CC00
+7F80
+0180
+0180
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR C086
-ENCODING 5065
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 11 1 0
+STARTCHAR ayin-hamis
+ENCODING 4820
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 -1
 BITMAP
-00C6
-08A9
-1871
-9442
-6440
-0440
-0280
-0280
-0280
-0100
-0100
+3C00
+6600
+C600
+C600
+CC00
+7FC0
+0180
+0180
+03F0
+0318
+0638
+07F0
 ENDCHAR
-STARTCHAR char5063
-ENCODING 5066
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR ayin-sadis
+ENCODING 4821
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 0 0
 BITMAP
-0780
-0840
-0820
-0010
-4010
-8310
-8510
-8410
-8410
-8C20
-73C0
+38
+18
+18
+3E
+7F
+E3
+C3
+C3
+C3
+C3
+C7
+FE
+70
 ENDCHAR
-STARTCHAR 0x0498
-ENCODING 5067
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR ayin-sabi
+ENCODING 4822
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
 BITMAP
-7A
-86
-82
-80
-78
-40
-8C
-92
-82
-82
-7C
+0F00
+1980
+3180
+3180
+3180
+3B00
+1C00
+3000
+6000
+C000
+C000
+E000
 ENDCHAR
-STARTCHAR C072
-ENCODING 5068
+STARTCHAR zey-geez
+ENCODING 4824
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 11 1 0
+BBX 9 12 0 0
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-1F00
+0700
+E300
+6300
+6300
+7F00
+6300
+6300
+6300
+6300
+6300
+6300
+7380
 ENDCHAR
-STARTCHAR C064
-ENCODING 5069
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 11 1 0
+STARTCHAR zey-kaib
+ENCODING 4825
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
-00F8
-0104
-0102
-0002
-3382
-4902
-8502
-8702
-8502
-4884
-3078
+0700
+E300
+6300
+6300
+7F00
+6300
+6318
+63F0
+6330
+6318
+6300
+7380
 ENDCHAR
-STARTCHAR C052
-ENCODING 5070
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR zey-salis
+ENCODING 4826
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 0 -1
 BITMAP
-0400
-0C00
-1400
-2400
-4480
-8480
-FF80
-0480
-0480
-0400
-1F00
+0700
+E300
+6300
+6300
+7F00
+6300
+6300
+6300
+6300
+6318
+6330
+73F0
+0018
 ENDCHAR
-STARTCHAR C120
-ENCODING 5071
+STARTCHAR zey-rabi
+ENCODING 4827
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 0 0
+BBX 9 12 0 0
 BITMAP
-F800
-2000
-2000
-2000
-2000
-3F80
-20C0
-2040
-2040
-2080
-FF00
+0700
+E300
+6300
+6300
+7F00
+6300
+6300
+6300
+7300
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR C073
-ENCODING 5072
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR zey-hamis
+ENCODING 4828
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 0
 BITMAP
-3E00
-0800
-0800
-0800
-CF80
-F980
-0800
-0800
-0800
-0800
-3E00
+0700
+E300
+6300
+6300
+7F00
+6300
+6300
+6300
+63F0
+6318
+6318
+73F0
 ENDCHAR
-STARTCHAR C111
-ENCODING 5073
+STARTCHAR zey-sadis
+ENCODING 4829
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
+BITMAP
+78E0
+6C60
+CC60
+0C60
+0FE0
+0C60
+0C60
+0C60
+0C60
+0C60
+0C60
+0E70
+ENDCHAR
+STARTCHAR zey-sabi
+ENCODING 4830
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 12 0 0
 BITMAP
-3180
-4A40
-3C40
-4040
-7180
-8800
-8800
-8800
-8800
-8800
+0700
+E300
+6300
+6300
+7F00
+6300
+6300
+6300
+6380
+6000
+6000
 7000
 ENDCHAR
-STARTCHAR C082
-ENCODING 5074
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR zey-zemede-rabi
+ENCODING 4831
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 -2
 BITMAP
-FE00
-2100
-2080
-2080
-3900
-2600
-2100
-2080
-2080
-2080
-FBE0
+0700
+E300
+6300
+6300
+7F00
+6300
+6300
+6300
+7300
+0300
+0300
+1FE0
+1860
+3030
 ENDCHAR
-STARTCHAR C074
-ENCODING 5075
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 11 1 0
+STARTCHAR zhe-zey-geez
+ENCODING 4832
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 0 0
 BITMAP
-F8
-20
-20
-20
-20
-20
-20
-20
-20
-24
-1C
+783C
+6C6C
+CC66
+0C60
+0FE0
+0C60
+0C60
+0C60
+0C60
+0C60
+0C60
+0E70
 ENDCHAR
-STARTCHAR C086
-ENCODING 5076
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR zhe-zey-kaib
+ENCODING 4833
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 12 0 0
 BITMAP
-8A20
-8A20
-8A20
-4440
-4440
-4440
-2A80
-2A80
-2A80
-1100
-1100
+783C
+6C6C
+CC66
+0C60
+0FE0
+0C63
+0C7E
+0C66
+0C63
+0C60
+0C60
+0E70
 ENDCHAR
-STARTCHAR C083
-ENCODING 5077
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR zhe-zey-salis
+ENCODING 4834
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 13 0 -1
 BITMAP
-78
-84
-9E
-80
-40
-36
-78
-04
-84
-84
-F8
+783C
+6C6C
+CC66
+0C60
+0FE0
+0C60
+0C60
+0C60
+0C60
+0C63
+0C66
+0E7E
+0003
 ENDCHAR
-STARTCHAR C084
-ENCODING 5078
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR zhe-zey-rabi
+ENCODING 4835
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 0 0
 BITMAP
-FF00
-8800
-8800
-8800
-0800
-0800
-0880
-0840
-0840
-0840
-0780
+783C
+6C6C
+CC66
+0C60
+0FE0
+0C60
+0C60
+0C60
+0E60
+0060
+0060
+0070
 ENDCHAR
-STARTCHAR C073
-ENCODING 5079
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR zhe-zey-hamis
+ENCODING 4836
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 12 0 0
 BITMAP
-07C0
-0100
-0100
-0100
-0300
-0500
-0900
-1100
-A100
-C100
-87C0
+783C
+6C6C
+CC66
+0C60
+0FE0
+0C60
+0C60
+0C60
+0C7E
+0C63
+0C63
+0E7E
 ENDCHAR
-STARTCHAR C103
-ENCODING 5080
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR zhe-zey-sadis
+ENCODING 4837
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 17 0 0
 BITMAP
-7FC0
-6100
-4100
-4100
-0300
-0500
-0900
-1100
-A100
-C100
-87C0
+C0C0
+6180
+7F80
+0C00
+0C00
+3C1E
+3636
+6633
+0630
+07F0
+0630
+0630
+0630
+0630
+0630
+0630
+0738
 ENDCHAR
-STARTCHAR C086
-ENCODING 5081
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 1 0
-BITMAP
-F1E0
-2080
-2080
-1100
-1100
-1100
-0A00
-0A00
-0A00
-0400
-0400
-ENDCHAR
-STARTCHAR C083
-ENCODING 5082
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
-BITMAP
-7C
-84
-84
-80
-40
-30
-08
-04
-84
-84
-F8
-ENDCHAR
-STARTCHAR char5083
-ENCODING 5083
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
-BITMAP
-39C0
-4620
-4420
-B020
-8840
-8400
-8400
-8400
-8400
-4800
-3000
-ENDCHAR
-STARTCHAR C111
-ENCODING 5084
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR zhe-zey-sabi
+ENCODING 4838
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 0 0
 BITMAP
+783C
+6C6C
+CC66
+0C60
+0FE0
+0C60
+0C60
+0C60
+0C70
 0C00
-1200
-1200
 0C00
-3300
-6180
-9240
-9240
-9240
-9240
-6180
+0E00
 ENDCHAR
-STARTCHAR C076
-ENCODING 5085
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 11 0 0
+STARTCHAR zhe-zey-zemede-rabi
+ENCODING 4839
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 0 -2
 BITMAP
-1C
-22
-22
-26
-20
-20
-21
-21
-21
-23
-FF
+783C
+6C6C
+CC66
+0C60
+0FE0
+0C60
+0C60
+0C60
+0E60
+0060
+0060
+03FC
+030C
+0606
 ENDCHAR
-STARTCHAR C076
-ENCODING 5086
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 11 0 0
+STARTCHAR yemen-geez
+ENCODING 4840
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 0 0
 BITMAP
+3C
+66
+C6
+C6
+CC
 F8
-20
-20
-20
-20
-20
-21
-21
-21
-23
-FF
-ENDCHAR
-STARTCHAR C067
-ENCODING 5087
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
-BITMAP
-1E80
-2180
-4080
-8080
-8000
-8000
-8000
-8080
-4080
-2100
-1E00
+70
+30
+30
+30
+30
+38
 ENDCHAR
-STARTCHAR C074
-ENCODING 5088
+STARTCHAR yemen-kaib
+ENCODING 4841
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 12 0 0
 BITMAP
-07C0
-0100
-6100
-9100
-7FC0
-1100
-1100
-1100
-1100
-1100
-0E00
+3C00
+6600
+C600
+C600
+CC00
+D800
+7000
+3F00
+3300
+3180
+3000
+3800
 ENDCHAR
-STARTCHAR C054
-ENCODING 5089
+STARTCHAR yemen-salis
+ENCODING 4842
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
-BITMAP
-39C0
-4620
-4220
-E540
-0500
-0880
-0880
-0880
-0880
-0880
-0700
-ENDCHAR
-STARTCHAR C080
-ENCODING 5090
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 11 1 0
+BBX 10 12 0 0
 BITMAP
-FF00
-2180
-2080
-2080
-2180
-3F00
-2000
-2000
-2000
-2000
+3C00
+6600
+C600
+C600
+CC00
 F800
+7600
+3600
+3F80
+3180
+30C0
+3800
 ENDCHAR
-STARTCHAR C067
-ENCODING 5091
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR yemen-rabi
+ENCODING 4843
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 15 0 -3
 BITMAP
-1E00
-2100
-4100
-8380
-8000
-8000
-8300
-8100
-4100
-2200
+0F00
+1980
+3180
+3180
+3300
+3E00
+3C00
+1800
 1C00
+0C00
+0E00
+F800
+6000
+6000
+C000
 ENDCHAR
-STARTCHAR C073
-ENCODING 5092
+STARTCHAR yemen-hamis
+ENCODING 4844
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 12 11 1 0
-BITMAP
-FCF0
-9040
-1040
-1080
-1080
-1100
-1200
-1200
-1400
-1400
-1800
-ENDCHAR
-STARTCHAR C072
-ENCODING 5093
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+BBX 11 12 0 0
 BITMAP
+3C00
+6600
+C600
+C600
+CC00
 F800
-2000
-20C0
-2320
-2D40
-3100
-2100
-2100
-2100
-2100
-F3C0
+73C0
+3E60
+3660
+33C0
+3000
+3800
 ENDCHAR
-STARTCHAR C075
-ENCODING 5094
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 1 0
+STARTCHAR yemen-sadis
+ENCODING 4845
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 0 -1
 BITMAP
-F9E0
-2080
-2100
-2200
-2400
-2E00
-3200
-2100
-2100
-2080
-F9E0
+0780
+0CC0
+18C0
+18C0
+1980
+1F00
+1E00
+0C38
+0E18
+FB30
+61E0
+6000
+C000
 ENDCHAR
-STARTCHAR C074
-ENCODING 5095
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR yemen-sabi
+ENCODING 4846
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-0E
-04
-04
-04
-34
-4C
-84
-84
-84
-44
-38
+3C00
+6600
+C600
+C7E0
+CC60
+F830
+7000
+3000
+3000
+3000
+3000
+3800
 ENDCHAR
-STARTCHAR C067
-ENCODING 5096
+STARTCHAR dint-geez
+ENCODING 4848
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 13 11 1 0
+BBX 12 12 0 0
 BITMAP
-1E00
-2100
-4148
-81B0
-8120
-8000
-8120
-81B0
-4148
-2100
-1E00
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
 ENDCHAR
-STARTCHAR C071
-ENCODING 5097
+STARTCHAR dint-kaib
+ENCODING 4849
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 0 -1
+BITMAP
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60FE
+C0CC
+018C
+01C6
+ENDCHAR
+STARTCHAR dint-salis
+ENCODING 4850
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 14 0 -2
+BITMAP
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60C0
+C0CC
+0198
+01F8
+001C
+ENDCHAR
+STARTCHAR dint-rabi
+ENCODING 4851
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 13 1 -2
+BBX 10 13 0 -1
 BITMAP
-1E80
-2180
-4080
-8080
-8000
-8000
-83C0
-8080
-4080
-2180
-1E80
-0080
-0060
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60C0
+C0C0
+0180
+01C0
 ENDCHAR
-STARTCHAR C054
-ENCODING 5098
+STARTCHAR dint-hamis
+ENCODING 4852
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 0 -1
+BITMAP
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FFC
+60C6
+C0C6
+007C
+ENDCHAR
+STARTCHAR dint-sadis
+ENCODING 4853
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 12 0 0
+BITMAP
+0780
+0CC0
+18F8
+18D8
+198C
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
+ENDCHAR
+STARTCHAR dint-sabi
+ENCODING 4854
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 13 11 1 0
+BBX 12 14 0 -2
 BITMAP
-0630
-0948
-1148
-1148
-1228
-1218
-1408
-9410
-8810
-9820
-67C0
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+1FE0
+3060
+6030
+C000
+C000
+E000
 ENDCHAR
-STARTCHAR C079
-ENCODING 5099
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 1 0
+STARTCHAR dint-zemede-rabi
+ENCODING 4855
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 15 0 -3
 BITMAP
-1E00
-2100
-4080
-F040
-8840
-8440
-8440
-83C0
-4080
-2100
-1E00
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
+01FE
+0186
+0303
 ENDCHAR
-STARTCHAR C079
-ENCODING 5100
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 10 1 0
+STARTCHAR dhi-dint-geez
+ENCODING 4856
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 0 -3
 BITMAP
+0700
 0300
-6280
-9240
-9040
-9040
-A040
-C040
-8080
-4100
-3E00
+0300
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
 ENDCHAR
-STARTCHAR C079
-ENCODING 5101
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR dhi-dint-kaib
+ENCODING 4857
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 17 0 -3
 BITMAP
-18
-24
-24
-24
-14
-0C
-04
-08
-88
-B0
-C0
+0700
+0300
+0300
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60FE
+C0CC
+018C
+0186
+01C0
 ENDCHAR
-STARTCHAR C054
-ENCODING 5102
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR dhi-dint-salis
+ENCODING 4858
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 18 0 -3
 BITMAP
-3C
-44
-44
-80
-80
-B8
-C4
-84
-84
-84
-78
+0700
+0300
+0300
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60C0
+C0C0
+018C
+0198
+01F8
+001C
 ENDCHAR
-STARTCHAR char5063
-ENCODING 5103
+STARTCHAR dhi-dint-rabi
+ENCODING 4859
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 11 1 0
+BBX 10 17 0 -3
 BITMAP
+0700
+0300
+0300
 0780
-0840
-0820
-0010
-1110
-5BD0
-8410
-8410
-8410
-8C20
-73C0
-ENDCHAR
-STARTCHAR C025
-ENCODING 5104
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 12 1 0
-BITMAP
-0E
-11
-21
-21
-21
-2E
-21
-21
-A1
-61
-72
-CC
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60C0
+C0C0
+0180
+0180
+01C0
 ENDCHAR
-STARTCHAR 0071
-ENCODING 5105
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 1 0
+STARTCHAR dhi-dint-hamis
+ENCODING 4860
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 0 -3
 BITMAP
-0700
-0200
 0700
-0880
-0840
-1040
-1040
-2240
-A440
-C480
-4300
+0300
+0300
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FFC
+60C6
+C0C6
+007C
 ENDCHAR
-STARTCHAR C126
-ENCODING 5106
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR dhi-dint-sadis
+ENCODING 4861
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 15 0 -3
 BITMAP
-3C
-42
-46
-40
-40
-7C
-42
-42
-42
-42
-E7
+0700
+0300
+0300
+0780
+0CC0
+18F8
+18D8
+198C
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
 ENDCHAR
-STARTCHAR C071
-ENCODING 5107
+STARTCHAR dhi-dint-sabi
+ENCODING 4862
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 13 11 1 0
+BBX 12 17 0 -3
 BITMAP
-1EA8
-21F8
-4150
-8000
-8000
-8000
-83C0
-8080
-4080
-2180
-1E80
+0700
+0300
+0300
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+1FE0
+3060
+6030
+C000
+C000
+E000
 ENDCHAR
-STARTCHAR C066
-ENCODING 5108
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 0 0
+STARTCHAR dhi-dint-zemede-rabi
+ENCODING 4863
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 18 0 -3
 BITMAP
-FF00
-2080
-2040
-2040
-2080
-3F00
-2080
-2040
-2040
-2080
-FF00
+0700
+0300
+0300
+0780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
+01FE
+0186
+0303
 ENDCHAR
-STARTCHAR C065
-ENCODING 5121
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR ji-dint-geez
+ENCODING 4864
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 16 0 -3
 BITMAP
-FF80
-8080
-4100
-4100
-2200
-2200
-2200
-1400
-1400
-0800
-0800
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
 ENDCHAR
-STARTCHAR C065
-ENCODING 5122
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 15 1 0
+STARTCHAR ji-dint-kaib
+ENCODING 4865
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 17 0 -2
 BITMAP
-0800
-1400
-0800
-0000
-0800
-0800
-1400
-1400
-2200
-2200
-2200
-4100
-4100
-8080
-FF80
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60FE
+C0CC
+018C
+01C6
 ENDCHAR
-STARTCHAR C065
-ENCODING 5123
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR ji-dint-salis
+ENCODING 4866
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 18 0 -2
 BITMAP
-0800
-0800
-1400
-1400
-2200
-2200
-2200
-4100
-4100
-8080
-FF80
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+3C00
+EFC0
+60C0
+C0CC
+0198
+01F8
+001C
 ENDCHAR
-STARTCHAR C065
-ENCODING 5124
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 15 1 0
+STARTCHAR ji-dint-rabi
+ENCODING 4867
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 17 0 -2
 BITMAP
-0800
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18C0
+18C0
+1980
+1B00
 1C00
-0800
-0000
-0800
-0800
-1400
-1400
-2200
-2200
-2200
-4100
-4100
-8080
-FF80
+3C00
+EFC0
+60C0
+C0C0
+0180
+01C0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5125
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR ji-dint-hamis
+ENCODING 4868
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 17 0 -3
 BITMAP
-C000
-B000
-8C00
-8300
-8080
-8040
-8080
-8300
-8C00
-B000
-C000
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FFC
+60C6
+C0C6
+007C
 ENDCHAR
-STARTCHAR C065
-ENCODING 5126
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR ji-dint-sadis
+ENCODING 4869
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 16 0 -3
 BITMAP
-0400
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18F8
+18D8
+198C
+1B00
+1C00
+0C00
 0E00
-0400
-0000
-C000
-B000
-8C00
-8300
-8080
-8040
-8080
-8300
-8C00
-B000
-C000
+7FE0
+6060
+C030
 ENDCHAR
-STARTCHAR C065
-ENCODING 5127
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR ji-dint-sabi
+ENCODING 4870
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 18 0 -3
 BITMAP
-2200
-7700
-2200
-0000
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+1FE0
+3060
+6030
 C000
-B000
-8C00
-8300
-8080
-8040
-8080
-8300
-8C00
-B000
 C000
+E000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5128
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR ji-dint-zemede-rabi
+ENCODING 4871
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 19 0 -3
 BITMAP
-C000
-B000
-8C00
-A300
-A080
-A040
-A080
-A300
-8C00
-B000
-C000
+0018
+7030
+3FF0
+3338
+6780
+0CC0
+18C0
+18C0
+1980
+1B00
+1C00
+0C00
+0E00
+7FE0
+6060
+C030
+01FE
+0186
+0303
 ENDCHAR
-STARTCHAR C065
-ENCODING 5129
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR gemel-geez
+ENCODING 4872
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 0 0
 BITMAP
-C000
-B000
-8C00
-8300
-9080
-B840
-9080
-8300
-8C00
-B000
-C000
+3E
+E3
+63
+63
+C3
+03
+06
+06
+06
+06
+07
 ENDCHAR
-STARTCHAR C065
-ENCODING 5130
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR gemel-kaib
+ENCODING 4873
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 0 0
 BITMAP
-00C0
-0340
-0C40
-3040
-4040
-8040
-4040
-3040
-0C40
-0340
-00C0
+3E00
+E300
+6300
+6300
+C3F8
+0330
+0630
+0618
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR C065
-ENCODING 5131
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR gemel-salis
+ENCODING 4874
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 -1
 BITMAP
-0800
-1C00
-0800
-0000
-00C0
-0340
-0C40
-3040
-4040
-8040
-4040
-3040
-0C40
-0340
-00C0
+3E00
+E300
+6300
+6300
+C300
+0300
+0600
+0600
+0630
+0660
+07E0
+0030
 ENDCHAR
-STARTCHAR C065
-ENCODING 5132
+STARTCHAR gemel-rabi
+ENCODING 4875
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
+BBX 10 13 0 -2
 BITMAP
-3FE0
-2020
-1040
-1040
-4880
-E880
-4880
-0500
-0500
-0200
-0200
+0F80
+38C0
+18C0
+18C0
+30C0
+00C0
+00C0
+0180
+0700
+F800
+6000
+6000
+C000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5133
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR gemel-hamis
+ENCODING 4876
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 11 0 0
 BITMAP
-FF80
-8080
-4100
-4100
-2240
-22E0
-2240
-1400
-1400
-0800
-0800
+3E00
+E300
+6300
+6300
+C300
+0300
+0600
+07E0
+0630
+0630
+07E0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5134
+STARTCHAR gemel-sadis
+ENCODING 4877
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
+BBX 10 11 0 0
 BITMAP
-0200
-0200
-0500
-0500
-4880
-E880
-4880
-1040
-1040
-2020
-3FE0
+7F80
+CCC0
+CCC0
+CCC0
+78C0
+0180
+0180
+0180
+0180
+0180
+01C0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5135
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR gemel-sabi
+ENCODING 4878
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 0 0
 BITMAP
-0800
-0800
-1400
-1400
-2240
-22E0
-2240
-4100
-4100
-8080
-FF80
+1C
+0C
+0C
+FF
+63
+63
+C3
+03
+06
+06
+06
+07
 ENDCHAR
-STARTCHAR C065
-ENCODING 5136
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR gemel-zemede-geez
+ENCODING 4880
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 0 0
 BITMAP
-0200
+3E00
+E300
+6300
+63FC
+C366
+0366
+073C
+0600
+0600
+0600
 0700
-0200
-0000
-0200
-0200
-0500
-4500
-E880
-4880
-0880
-1040
-1040
-2020
-3FE0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5137
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR gemel-zemede-salis
+ENCODING 4882
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 0 0
 BITMAP
-0800
-1C00
-0800
-0000
-0800
-0800
-1400
-1440
-22E0
-2240
-2200
-4100
-4100
-8080
-FF80
+3E00
+E360
+6360
+63E0
+C37E
+030C
+070C
+0606
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR C065
-ENCODING 5138
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 11 1 0
+STARTCHAR gemel-zemede-rabi
+ENCODING 4883
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 0 0
 BITMAP
-0C00
-0B00
-08C0
-0830
-4808
-E804
-4808
-0830
-08C0
-0B00
+3C00
+E600
+6600
+6600
+CC00
 0C00
+FF00
+6300
+C300
+0300
+0380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5139
+STARTCHAR gemel-zemede-hamis
+ENCODING 4884
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 14 11 1 0
+BBX 13 14 0 -2
 BITMAP
-C000
-B000
-8C00
-8300
-8088
-805C
-8088
-8300
-8C00
-B000
+1F00
+7180
+3180
+3180
+6180
+0180
+0300
+0300
+03F0
+0318
+0718
+7FF0
+6000
 C000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5140
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR gemel-zemede-kaib
+ENCODING 4885
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 11 0 0
 BITMAP
-0400
-0E00
-0400
-0000
-0C00
-0B00
-08C0
-0830
-4808
-E804
-4808
-0830
-08C0
-0B00
-0C00
+3E00
+E360
+6360
+63FC
+C318
+0318
+070C
+0600
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR C065
-ENCODING 5141
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR nge-gemel-geez
+ENCODING 4888
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 16 0 0
 BITMAP
-4000
-E000
-4000
-0000
-C000
-B000
-8C00
-8300
-8088
-805C
-8088
-8300
-8C00
-B000
-C000
+00C0
+E180
+7F80
+6CC0
+CC00
+1F00
+7180
+3180
+3180
+6180
+0180
+0300
+0300
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5142
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR nge-gemel-kaib
+ENCODING 4889
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 16 0 0
 BITMAP
-2000
-7000
-2000
-0080
-C1C0
-B080
-8C00
-8300
-8080
-8040
-8080
-8300
-8C00
-B000
-C000
+00C0
+E180
+7F80
+6DC0
+CC00
+1F00
+7180
+3180
+3180
+61FC
+0198
+0318
+030C
+0300
+0300
+0380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5143
+STARTCHAR nge-gemel-salis
+ENCODING 4890
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 14 11 1 0
+BBX 13 17 0 -1
 BITMAP
-000C
-0034
-00C4
-0304
-4404
-E804
-4404
-0304
-00C4
-0034
-000C
+00C0
+E180
+7F80
+6CC0
+CC00
+1F00
+7180
+3180
+3180
+6180
+0180
+0300
+0300
+0318
+0330
+03F0
+0018
 ENDCHAR
-STARTCHAR C065
-ENCODING 5144
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 11 1 0
+STARTCHAR nge-gemel-rabi
+ENCODING 4891
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 18 0 -2
 BITMAP
+0060
+70C0
+3FC0
+3660
+6600
+0F80
+38C0
+18C0
+18C0
+30C0
 00C0
-0340
-0C40
-3040
-4048
-805C
-4048
-3040
-0C40
-0340
 00C0
+0180
+0700
+F800
+6000
+6000
+C000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5145
+STARTCHAR nge-gemel-hamis
+ENCODING 4892
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 14 15 1 0
+BBX 13 16 0 0
 BITMAP
-0008
-001C
-0008
-0000
-000C
-0034
-00C4
-0304
-4404
-E804
-4404
-0304
-00C4
-0034
-000C
+00C0
+E180
+7F80
+6CC0
+CC00
+1F00
+7180
+3180
+3180
+6180
+0180
+0300
+03F0
+0318
+0318
+03F0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5146
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR nge-gemel-sadis
+ENCODING 4893
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 16 0 0
 BITMAP
-0080
+C0C0
+6180
+7F80
+CCC0
+0C00
+7F80
+CCC0
+CCC0
+CCC0
+78C0
+0180
+0180
+0180
+0180
+0180
 01C0
-0080
-0000
-00C0
-0340
-0C40
-3040
-4048
-805C
-4048
-3040
-0C40
-0340
-00C0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5147
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR nge-gemel-sabi
+ENCODING 4894
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 17 0 0
 BITMAP
-0100
+C030
+6060
+7FE0
+CF30
+1980
+1980
+1B00
+0C00
+7F80
+3180
+3180
+6180
+0180
+0300
+0300
+0300
 0380
-0100
-4000
-E0C0
-4340
-0C40
-3040
-4040
-8040
-4040
-3040
-0C40
-0340
-00C0
-ENDCHAR
-STARTCHAR char5141
-ENCODING 5148
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 6 1 5
-BITMAP
-92
-92
-92
-92
-92
-6C
 ENDCHAR
-STARTCHAR char5149
-ENCODING 5149
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 5
+STARTCHAR teyt-geez
+ENCODING 4896
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 10 0 0
 BITMAP
-08
-14
-08
-40
-E0
-40
+1FC0
+3660
+6630
+6630
+C630
+C630
+C630
+C630
+C630
+E738
 ENDCHAR
-STARTCHAR char5150
-ENCODING 5150
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 6 1 5
+STARTCHAR teyt-kaib
+ENCODING 4897
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 10 0 0
 BITMAP
-20
-20
-50
-50
-88
-F8
+1FC0
+3660
+6633
+6636
+C63E
+C633
+C630
+C630
+C630
+E738
 ENDCHAR
-STARTCHAR char5151
-ENCODING 5151
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 4 1 7
+STARTCHAR teyt-salis
+ENCODING 4898
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 -2
 BITMAP
-10
-20
-40
-80
+1FC000
+366000
+663000
+663000
+C63000
+C63000
+C63000
+C63000
+C63180
+E73F00
+000300
+000180
 ENDCHAR
-STARTCHAR char5151
-ENCODING 5152
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 4 1 7
+STARTCHAR teyt-rabi
+ENCODING 4899
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 10 0 0
 BITMAP
-80
-40
-20
-10
+1FC0
+3660
+6630
+6630
+C630
+C630
+E730
+0030
+0030
+0038
 ENDCHAR
-STARTCHAR char5153
-ENCODING 5153
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 4 1 7
+STARTCHAR teyt-hamis
+ENCODING 4900
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 10 0 0
 BITMAP
-84
-84
-84
-78
+1FC000
+366000
+663000
+663000
+C63000
+C63000
+C63F00
+C63180
+C63180
+E73F00
 ENDCHAR
-STARTCHAR char5153
-ENCODING 5154
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 4 1 7
+STARTCHAR teyt-sadis
+ENCODING 4901
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 10 0 0
 BITMAP
-78
-84
-84
-84
+1FC0
+3660
+6630
+CC30
+CFB8
+E300
+0300
+0600
+0600
+0700
 ENDCHAR
-STARTCHAR char5153
-ENCODING 5155
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 6 1 5
+STARTCHAR teyt-sabi
+ENCODING 4902
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 10 0 0
 BITMAP
-E0
-10
-10
-10
-10
-E0
+1FC0
+3660
+6630
+6630
+C630
+C630
+C738
+C000
+C000
+E000
 ENDCHAR
-STARTCHAR char5156
-ENCODING 5156
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 4 1 4
+STARTCHAR teyt-zemede-rabi
+ENCODING 4903
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 12 0 -2
 BITMAP
-60
-90
-90
-60
+1FC000
+366000
+663000
+663000
+C63000
+C63000
+C63000
+C73000
+E03000
+03FF00
+030300
+060180
 ENDCHAR
-STARTCHAR char5151
-ENCODING 5157
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 4 1 7
-BITMAP
-12
-24
-48
-90
+STARTCHAR che-teyt-geez
+ENCODING 4904
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 20 10 0 0
+BITMAP
+0FFC00
+398600
+618300
+618300
+C18300
+C18300
+F9F3E0
+CD9B30
+CD9B30
+F9F3E0
 ENDCHAR
-STARTCHAR char5158
-ENCODING 5158
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 5 1 6
+STARTCHAR che-teyt-kaib
+ENCODING 4905
+SWIDTH 1440 0
+DWIDTH 24 0
+BBX 22 10 0 0
 BITMAP
-90
-90
-90
-90
-90
+0FFC00
+398600
+618300
+6183FC
+C18318
+C18318
+F9F3EC
+CD9B30
+CD9B30
+F9F3E0
 ENDCHAR
-STARTCHAR char5156
-ENCODING 5159
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 3 1 5
+STARTCHAR che-teyt-salis
+ENCODING 4906
+SWIDTH 1380 0
+DWIDTH 23 0
+BBX 21 12 0 -2
 BITMAP
-40
-E0
-40
+0FFC00
+398600
+618300
+618300
+C18300
+C18300
+F9F300
+CD9B00
+CD9B00
+F9F3F0
+000070
+000038
 ENDCHAR
-STARTCHAR char5160
-ENCODING 5160
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 1 1 10
-BITMAP
-FE
+STARTCHAR che-teyt-rabi
+ENCODING 4907
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 20 10 0 0
+BITMAP
+0FFC00
+398600
+618300
+F9F300
+CD9B00
+CD9B00
+F9F3E0
+000330
+000330
+0003E0
 ENDCHAR
-STARTCHAR char5161
-ENCODING 5161
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 5 1 6
-BITMAP
-20
-20
-F8
-20
-20
+STARTCHAR che-teyt-hamis
+ENCODING 4908
+SWIDTH 1560 0
+DWIDTH 26 0
+BBX 24 10 0 0
+BITMAP
+0FFC00
+398600
+61831E
+6183F3
+C18333
+C1831E
+F9F3E0
+CD9B30
+CD9B30
+F9F3E0
 ENDCHAR
-STARTCHAR char5161
-ENCODING 5162
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 1 6
-BITMAP
-F8
-20
-20
-20
-20
+STARTCHAR che-teyt-sadis
+ENCODING 4909
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 20 10 0 0
+BITMAP
+0FFC00
+38C600
+60C300
+F9F3E0
+CC6330
+CCC330
+F8F3E0
+019800
+019800
+01F000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5163
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 1 0
-BITMAP
-0020
-FF90
-8088
-4104
-4100
-2200
-2200
-2200
-1400
-1400
-0800
-0800
+STARTCHAR che-teyt-sabi
+ENCODING 4910
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 20 10 0 0
+BITMAP
+0FFC00
+398600
+618300
+61F3E0
+C19B30
+C19B30
+F9F3E0
+CC0000
+CC0000
+F80000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5164
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 12 1 0
+STARTCHAR che-teyt-zemede-rabi
+ENCODING 4911
+SWIDTH 1380 0
+DWIDTH 23 0
+BBX 21 12 0 -2
 BITMAP
-0200
-0900
-0880
-1440
-1400
-2200
-2200
-2200
-4100
-4100
-8080
-FF80
+0FFC00
+398600
+618300
+F9F300
+CD9B00
+CD9B00
+F9F300
+000300
+000300
+003FF0
+003030
+006018
 ENDCHAR
-STARTCHAR C065
-ENCODING 5165
+STARTCHAR peyt-geez
+ENCODING 4912
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 1
+BBX 9 14 0 0
 BITMAP
-0200
-C100
-B080
-8C40
-8300
-8080
-8080
-8300
-8C00
-B000
-C000
+1C00
+0C00
+0C00
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+C300
+E380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5166
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 11 1 1
+STARTCHAR peyt-kaib
+ENCODING 4913
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 0
 BITMAP
-0020
-0190
-0688
-1884
-6080
-8080
-8080
-6080
-1880
-0680
-0180
+1C00
+0C00
+0C00
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E30
+E3E0
+C360
+C330
+E380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5167
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR peyt-salis
+ENCODING 4914
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 15 0 -1
 BITMAP
-8080
-8080
-4100
-4100
-2200
-2200
-2200
-1400
-1400
-0800
-0800
+1C00
+0C00
+0C00
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C318
+C330
+E3F0
+0018
 ENDCHAR
-STARTCHAR C065
-ENCODING 5168
+STARTCHAR peyt-rabi
+ENCODING 4915
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 15 1 0
+BBX 9 14 0 0
 BITMAP
-0800
-1400
-0800
-0000
-0800
-0800
-1400
-1400
-2200
-2200
-2200
-4100
-4100
-8080
-8080
-ENDCHAR
-STARTCHAR C065
-ENCODING 5169
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
-BITMAP
-0800
-0800
-1400
-1400
-2200
-2200
-2200
-4100
-4100
-8080
-8080
-ENDCHAR
-STARTCHAR C065
-ENCODING 5170
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 15 1 0
-BITMAP
-0800
 1C00
-0800
-0000
-0800
-0800
-1400
-1400
-2200
-2200
-2200
-4100
-4100
-8080
-8080
+0C00
+0C00
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+E300
+0380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5171
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR peyt-hamis
+ENCODING 4916
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 14 0 0
 BITMAP
-C000
-3000
+1C00
 0C00
-0300
-0080
-0040
-0080
-0300
 0C00
-3000
-C000
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E3F0
+C318
+C318
+E3F0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5172
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR peyt-sadis
+ENCODING 4917
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 14 0 0
 BITMAP
-0400
-0E00
-0400
-0000
-C000
-3000
+1C00
 0C00
-0300
-0080
-0040
-0080
-0300
 0C00
-3000
-C000
+3E00
+63E0
+6360
+6720
+1E00
+3800
+7E00
+E300
+C300
+C300
+E380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5173
+STARTCHAR peyt-sabi
+ENCODING 4918
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 9 14 0 0
 BITMAP
-2200
-7700
-2200
-0000
-C000
-3000
+1C00
 0C00
-0300
-0080
-0040
-0080
-0300
 0C00
-3000
-C000
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+C380
+E000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5174
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR peyt-zemede-rabi
+ENCODING 4919
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 16 0 -2
 BITMAP
-C000
-3000
+1C00
 0C00
-2300
-2080
-2040
-2080
-2300
 0C00
-3000
-C000
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+E300
+0380
+1FF0
+3838
 ENDCHAR
-STARTCHAR C065
-ENCODING 5175
+STARTCHAR sedey-geez
+ENCODING 4920
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 0 0
 BITMAP
-C000
-3000
-0C00
-0300
-1080
-3840
-1080
-0300
-0C00
-3000
-C000
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+C300
+E380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5176
+STARTCHAR sedey-kaib
+ENCODING 4921
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 11 0 0
+BITMAP
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E30
+E3E0
+C360
+C330
+E380
+ENDCHAR
+STARTCHAR sedey-salis
+ENCODING 4922
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 0 -1
+BITMAP
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C318
+C330
+E3F0
+0018
+ENDCHAR
+STARTCHAR sedey-rabi
+ENCODING 4923
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 0 0
 BITMAP
-00C0
-0300
-0C00
-3000
-4000
-8000
-4000
-3000
-0C00
-0300
-00C0
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+E300
+0380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5177
+STARTCHAR sedey-hamis
+ENCODING 4924
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 0 0
+BITMAP
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E3F0
+C318
+C318
+E3F0
+ENDCHAR
+STARTCHAR sedey-sadis
+ENCODING 4925
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 0 0
+BITMAP
+3E00
+63E0
+6360
+6720
+1E00
+3800
+7E00
+E300
+C300
+C300
+E380
+ENDCHAR
+STARTCHAR sedey-sabi
+ENCODING 4926
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 9 11 0 0
 BITMAP
-0800
-1C00
-0800
-0000
-00C0
-0300
-0C00
-3000
-4000
-8000
-4000
-3000
-0C00
-0300
-00C0
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+C380
+E000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5178
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 -1 0
+STARTCHAR sedey-zemede-rabi
+ENCODING 4927
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 0 -2
 BITMAP
-2020
-2020
-1040
-1040
-0880
-4880
-E880
-4500
-0500
-0200
-0200
+3E00
+6300
+6300
+6700
+1E00
+3800
+7E00
+E300
+C300
+E300
+0380
+1FF0
+3838
 ENDCHAR
-STARTCHAR C065
-ENCODING 5179
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR sepa-geez
+ENCODING 4928
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 0 0
 BITMAP
-8080
-8080
-4100
-4100
-2200
-2240
-22E0
-1440
-1400
-0800
-0800
+0E
+7F
+E3
+C3
+CF
+F3
+C3
+C3
+C7
+FE
+70
 ENDCHAR
-STARTCHAR C065
-ENCODING 5180
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 -1 0
+STARTCHAR sepa-kaib
+ENCODING 4929
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 0 0
 BITMAP
-0200
-0200
-0500
-4500
-E880
-4880
-0880
-1040
-1040
-2020
-2020
+0E00
+7F00
+E300
+C300
+CFF8
+F330
+C330
+C318
+C700
+FE00
+7000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5181
+STARTCHAR sepa-salis
+ENCODING 4930
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
+BBX 10 13 0 -1
 BITMAP
-0800
-0800
-1400
-1440
-22E0
-2240
-2200
-4100
-4100
-8080
-8080
+3C00
+6600
+CE00
+F600
+C600
+7C00
+0C00
+0C00
+0C00
+18C0
+1980
+1F80
+00C0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5182
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR sepa-rabi
+ENCODING 4931
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 0 0
 BITMAP
-0200
-0700
-0200
-0000
-0200
-0200
-0500
-4500
-E880
-4880
-0880
-1040
-1040
-2020
-2020
+3C
+66
+CE
+F6
+C6
+7C
+0C
+0C
+0C
+18
+18
+1C
 ENDCHAR
-STARTCHAR C065
-ENCODING 5183
+STARTCHAR sepa-hamis
+ENCODING 4932
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 15 1 0
-BITMAP
-0800
-1C00
-0800
-0000
-0800
-0800
-1400
-1440
-22E0
-2240
-2200
-4100
-4100
-8080
-8080
-ENDCHAR
-STARTCHAR C065
-ENCODING 5184
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 11 1 0
+BBX 10 12 0 0
 BITMAP
+3C00
+6600
+CE00
+F600
+C600
+7C00
 0C00
-0300
-00C0
-0030
-4008
-E004
-4008
-0030
-00C0
-0300
 0C00
+0F80
+18C0
+18C0
+1F80
 ENDCHAR
-STARTCHAR C065
-ENCODING 5185
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 11 1 0
+STARTCHAR sepa-sadis
+ENCODING 4933
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 0 0
 BITMAP
-C000
-3000
-0C00
-0300
-0088
-005C
-0088
-0300
-0C00
+38
+18
+18
+3E
+7F
+E3
+C3
+CF
+F3
+C3
+C7
+FE
+70
+ENDCHAR
+STARTCHAR sepa-sabi
+ENCODING 4934
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 0 0
+BITMAP
+0F00
+1980
+3180
+3F80
+3180
+3B00
+1C00
 3000
+6000
 C000
+C000
+E000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5186
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR af-geez
+ENCODING 4936
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 -1
 BITMAP
-0400
+0780
+0380
+0700
 0E00
-0400
-0000
-0C00
-0300
-00C0
-0030
-4008
-E004
-4008
+1C00
+3800
+7000
+EC00
+C630
+C660
+E7E0
+7860
 0030
-00C0
-0300
-0C00
 ENDCHAR
-STARTCHAR C065
-ENCODING 5187
+STARTCHAR af-kaib
+ENCODING 4937
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 14 15 1 0
+BBX 13 14 0 -1
 BITMAP
-4000
-E000
-4000
-0000
-C000
-3000
-0C00
-0300
-0088
-005C
-0088
-0300
-0C00
-3000
-C000
+0F00
+0700
+0E00
+1C00
+3800
+7700
+E380
+E398
+7FF0
+0730
+0E18
+1C00
+1C00
+1E00
 ENDCHAR
-STARTCHAR C065
-ENCODING 5188
+STARTCHAR af-salis
+ENCODING 4938
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 0 0
+BITMAP
+0780
+0380
+0700
+0E00
+1C00
+3800
+7000
+ECE0
+C660
+C660
+E7C0
+7800
+ENDCHAR
+STARTCHAR af-rabi
+ENCODING 4939
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 14 11 1 0
+BBX 13 14 0 -1
 BITMAP
-000C
-0030
-00C0
-0300
-4400
-E800
-4400
+0F00
+0700
+0E00
+1C00
+3800
+7700
+E300
+E300
+7FF0
+0330
+0330
+0318
 0300
-00C0
+0380
+ENDCHAR
+STARTCHAR af-hamis
+ENCODING 4940
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 13 0 -1
+BITMAP
+0780
+0380
+0700
+0E00
+1C00
+3800
+7000
+EC00
+C678
+C6CC
+E7CC
+78CC
+0078
+ENDCHAR
+STARTCHAR af-sadis
+ENCODING 4941
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
+BITMAP
+1FE0
+3060
+6060
+E030
+DC00
+C600
+C600
+7FE0
+0660
+0660
+0630
+0700
+ENDCHAR
+STARTCHAR af-sabi
+ENCODING 4942
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 -1
+BITMAP
+07C0
+3E60
+6660
+C3C0
+C000
+C000
+C000
+FC00
+CE00
+C630
+E7E0
+7C60
 0030
-000C
 ENDCHAR
-STARTCHAR C065
-ENCODING 5189
+STARTCHAR af-zemede-rabi
+ENCODING 4943
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 14 11 1 0
+BBX 13 15 0 -2
 BITMAP
-00C0
-0300
-0C00
-3000
-4008
-801C
-4008
-3000
-0C00
-0300
-00C0
+0F00
+0700
+0E00
+1C00
+3800
+7700
+E300
+E300
+7FF0
+0330
+0330
+0318
+1FE0
+1860
+3030
 ENDCHAR
-STARTCHAR C065
-ENCODING 5190
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR psa-geez
+ENCODING 4944
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-0008
-001C
-0008
-0000
-000C
+FFF0
+6660
+6660
+C630
+0600
+0600
+0600
+0600
+0600
+0600
+0600
+0700
+ENDCHAR
+STARTCHAR psa-kaib
+ENCODING 4945
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
+BITMAP
+FFF0
+6660
+6660
+C630
+0600
+0600
+0670
+07E0
+0660
+0630
+0600
+0700
+ENDCHAR
+STARTCHAR psa-salis
+ENCODING 4946
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 -1
+BITMAP
+FFF0
+6660
+6660
+C630
+0600
+0600
+0600
+0600
+0600
+0630
+0660
+07E0
 0030
+ENDCHAR
+STARTCHAR psa-rabi
+ENCODING 4947
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 0 -2
+BITMAP
+1FFE
+0CCC
+0CCC
+18C6
 00C0
-0300
-4400
-E800
-4400
-0300
 00C0
-0030
-000C
+00C0
+00C0
+0180
+0700
+F800
+6000
+6000
+C000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5191
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR psa-hamis
+ENCODING 4948
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-0080
+FFF0
+6660
+6660
+C630
+0600
+0600
+0600
+0600
+07E0
+0630
+0630
+07E0
+ENDCHAR
+STARTCHAR psa-sadis
+ENCODING 4949
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
+BITMAP
+FFF0
+6660
+6660
+C630
+0600
+0780
+0180
+0180
+0180
+0180
+0180
 01C0
-0080
-0000
-00C0
-0300
-0C00
-3000
-4008
-801C
-4008
-3000
-0C00
-0300
-00C0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5192
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR psa-sabi
+ENCODING 4950
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 12 0 0
 BITMAP
-1100
-3B80
-1100
-0000
-00C0
-0300
+FFF0
+6660
+6660
+C630
+0600
 0C00
+1800
+1800
 3000
-4000
-8000
-4000
 3000
-0C00
-0300
-00C0
+7000
+3800
 ENDCHAR
-STARTCHAR char5150
-ENCODING 5193
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 5 1 6
+STARTCHAR psa-zemede-rabi
+ENCODING 4951
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 14 0 -2
 BITMAP
-0C
-30
-C0
-30
-0C
+FFF0
+6660
+6660
+C630
+0600
+0600
+0600
+0600
+0600
+0600
+0600
+7FE0
+6060
+C030
 ENDCHAR
-STARTCHAR char5158
-ENCODING 5194
-SWIDTH 120 0
-DWIDTH 2 0
-BBX 1 5 1 6
+STARTCHAR ris-zemede-ya
+ENCODING 4952
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 15 0 0
 BITMAP
-80
-80
-80
-80
-80
+C018
+6030
+7FF0
+0700
+0700
+0E00
+1C00
+3800
+7000
+E000
+C1C0
+C0C0
+C0C0
+E300
+7C00
 ENDCHAR
-STARTCHAR char5195
-ENCODING 5195
+STARTCHAR may-zemede-ya
+ENCODING 4953
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 18 0 -1
+BITMAP
+C00C
+6018
+7FF8
+0300
+0370
+3F98
+6598
+CD98
+CD98
+CD98
+CCF0
+D830
+6030
+0030
+0063
+0066
+007E
+0003
+ENDCHAR
+STARTCHAR af-zemede-ya
+ENCODING 4954
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 15 0 0
+BITMAP
+600C
+3018
+3FF8
+0380
+0380
+0700
+0E00
+1C00
+3800
+7000
+ECE0
+C660
+C660
+E7C0
+7800
+ENDCHAR
+STARTCHAR neus-neteb
+ENCODING 4961
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 8 1 3
+BBX 4 6 2 3
 BITMAP
-80
-80
-80
-B0
-C8
-88
-88
-88
+E0
+70
+00
+00
+E0
+70
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5196
+STARTCHAR ebiy-neteb
+ENCODING 4962
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 9 6 0 3
 BITMAP
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-4100
-3E00
+E700
+7380
+0000
+0000
+E700
+7380
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5197
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 15 1 0
+STARTCHAR netela-serez
+ENCODING 4963
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 7 0 3
 BITMAP
-0800
-1400
-0800
-0000
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
+FC
+00
+70
+38
+00
+70
+38
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5198
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR neus-serez
+ENCODING 4964
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 9 0 1
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
+FC
+00
+70
+38
+00
+70
+38
+00
+FC
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5199
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 15 1 0
+STARTCHAR asteamro
+ENCODING 4965
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 7 0 3
 BITMAP
-0800
-1C00
-0800
-0000
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
+70
+38
+00
+FC
+00
+70
+38
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5200
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR ebiy-serez
+ENCODING 4966
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 7 0 3
 BITMAP
-F8
-04
-02
-01
-01
-01
-01
-01
-02
-04
-F8
+E0
+70
+00
+7F
+00
+E0
+70
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5201
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR seleste-neteb
+ENCODING 4967
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 10 0 1
 BITMAP
-20
+E0
 70
-20
 00
-F8
-04
-02
-01
-01
-01
-01
-01
-02
-04
-F8
+00
+E0
+70
+00
+00
+E0
+70
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5202
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR sebate-neteb
+ENCODING 4968
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 10 0 1
 BITMAP
-44
-EE
-44
-00
-F8
-04
-02
-01
-01
-01
-01
-01
-02
-04
-F8
+18
+18
+C3
+C3
+18
+18
+C3
+C3
+18
+18
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5203
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR ahadu
+ENCODING 4969
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
 BITMAP
-F8
-04
-02
-21
-21
-21
-21
-21
-02
-04
-F8
+7E
+E7
+00
+30
+30
+30
+7C
+66
+C6
+C6
+CE
+7C
+00
+7E
+66
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5204
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR kileitu
+ENCODING 4970
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
 BITMAP
-F8
-04
-02
-01
-21
-71
-21
-01
-02
-04
-F8
+7E
+E7
+00
+3C
+66
+66
+6C
+70
+7C
+66
+66
+3C
+00
+7E
+66
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5205
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR selestu
+ENCODING 4971
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
 BITMAP
-1F
-20
-40
-80
-80
-80
-80
-80
-40
-20
+7E
+E7
+00
 1F
+63
+60
+60
+60
+60
+60
+60
+70
+00
+7E
+66
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5206
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR arbaitu
+ENCODING 4972
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 14 0 -2
 BITMAP
-04
-0E
-04
+7E
+E7
 00
-1F
-20
-40
-80
-80
-80
-80
-80
-40
-20
-1F
+3C
+66
+E6
+C6
+C6
+CE
+CC
+78
+00
+FC
+CC
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5207
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 11 1 0
+STARTCHAR hamistu
+ENCODING 4973
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 15 0 -3
 BITMAP
-0808
-0808
-0808
-0808
-4808
-E808
-4808
-0808
-0808
-0410
-03E0
+3F00
+7380
+0000
+1800
+1800
+1800
+3F00
+7300
+E000
+C000
+C700
+7F00
+0000
+7E00
+6600
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5208
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 11 1 0
+STARTCHAR sidistu
+ENCODING 4974
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
 BITMAP
-8080
-8080
-8080
-8080
-8090
-80B8
-8090
-8080
-8080
-4100
-3E00
+7E
+E7
+00
+FC
+CC
+8C
+18
+18
+1E
+33
+33
+3E
+00
+7E
+66
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5209
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 11 1 0
+STARTCHAR sebatu
+ENCODING 4975
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 15 0 -3
 BITMAP
-03E0
-0410
-0808
-0808
-4808
-E808
-4808
-0808
-0808
-0808
-0808
+3F00
+7380
+0000
+FC00
+CC00
+8C00
+1C00
+1800
+1800
+3180
+3300
+3F80
+0000
+7E00
+6600
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5210
+STARTCHAR sementu
+ENCODING 4976
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 13 11 1 0
+BBX 12 15 0 -3
 BITMAP
-3E00
-4100
-8080
-8080
-8090
-80B8
-8090
-8080
-8080
-8080
-8080
+1F80
+39C0
+0000
+7FE0
+6660
+C630
+0600
+0600
+0600
+0600
+7FE0
+6060
+4020
+1F80
+1980
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5211
+STARTCHAR tesatu
+ENCODING 4977
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
+BITMAP
+7E
+E7
+00
+E7
+63
+63
+7F
+63
+63
+66
+7E
+3C
+00
+FE
+C6
+ENDCHAR
+STARTCHAR asertu
+ENCODING 4978
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
+BITMAP
+7E
+E7
+00
+1C
+1C
+1C
+1C
+3C
+38
+38
+38
+38
+00
+FE
+C6
+ENDCHAR
+STARTCHAR isra
+ENCODING 4979
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 15 0 -3
+BITMAP
+1F80
+39C0
+0000
+FFE0
+CE60
+0C00
+1800
+3F00
+3380
+6380
+6380
+71C0
+0000
+3F00
+3300
+ENDCHAR
+STARTCHAR selasa
+ENCODING 4980
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 13 15 1 0
+BBX 12 15 0 -3
 BITMAP
-0080
+0FC0
+1CE0
+0000
+01E0
+2270
+6670
+C670
+C670
+C660
+C660
+6860
+3800
+0000
+1FC0
+18C0
+ENDCHAR
+STARTCHAR arba
+ENCODING 4981
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 15 0 -3
+BITMAP
+1F80
+39C0
+0000
+EEE0
+6660
+6660
+CE60
+CFC0
+78C0
+00C0
+0180
+0180
 01C0
-0080
+3F00
+3300
+ENDCHAR
+STARTCHAR hamsa
+ENCODING 4982
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
+BITMAP
+7E
+E7
+00
+67
+63
+67
+7E
+06
+06
+0C
+0C
+0E
+00
+7E
+66
+ENDCHAR
+STARTCHAR sisa
+ENCODING 4983
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 15 0 -3
+BITMAP
+1FC0
+38E0
 0000
-03E0
-0410
-0808
-0808
-4808
-E808
-4808
-0808
-0808
-0808
-0808
+7FF0
+6730
+C618
+0E00
+0380
+0300
+0700
+7FF0
+6030
+4010
+1F80
+1980
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5212
+STARTCHAR seba
+ENCODING 4984
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 13 15 1 0
+BBX 12 15 0 -3
 BITMAP
-0800
-1C00
-0800
+0FC0
+1CE0
 0000
-3E00
-4100
-8080
-8080
-8090
-80B8
-8090
-8080
-8080
-8080
-8080
+0DF0
+3330
+3330
+63F0
+6000
+C000
+C080
+C780
+7F80
+0000
+1F80
+1980
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5213
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR semanya
+ENCODING 4985
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 15 0 -3
 BITMAP
-1F00
-0080
-0040
-0020
-4020
-E020
-4020
-0020
-0040
-0080
-1F00
+07E0
+0E70
+0000
+007C
+FFEC
+CCC4
+8CC0
+0CC0
+0CC0
+0CC0
+0CC0
+0EE0
+0000
+0FC0
+0CC0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5214
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR tesa
+ENCODING 4986
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
 BITMAP
-F800
-0400
-0200
-0100
-0120
-0170
-0120
-0100
-0200
-0400
-F800
+7E
+E7
+00
+FE
+CE
+8C
+1F
+06
+06
+0C
+0C
+0E
+00
+7E
+66
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5215
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR meet
+ENCODING 4987
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 15 0 -3
 BITMAP
-0400
-0E00
-0400
-0000
-1F00
-0080
-0040
-0020
-4020
-E020
-4020
-0020
-0040
-0080
-1F00
+7E
+E7
+1C
+66
+66
+66
+74
+38
+30
+30
+30
+38
+00
+7E
+66
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5216
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 15 1 0
+STARTCHAR ilf
+ENCODING 4988
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 15 0 -3
 BITMAP
-2000
-7000
-2000
+0FC0
+1CE0
 0000
-F800
-0400
-0200
-0100
-0120
-0170
-0120
-0100
-0200
-0400
-F800
+78F0
+CD98
+CD98
+D9B0
+7FE0
+60C0
+60C0
+60C0
+60C0
+0000
+1F80
+1980
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5217
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni13A0
+ENCODING 5024
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 0 0
 BITMAP
-01F0
-0200
-0400
-0800
-4800
-E800
-4800
-0800
-0400
-0200
-01F0
+FE00
+2180
+2080
+2040
+2040
+2040
+2040
+2040
+2080
+2180
+FE00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5218
-SWIDTH 720 0
-DWIDTH 12 0
+STARTCHAR uni13A1
+ENCODING 5025
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 11 11 1 0
 BITMAP
-1F00
-2000
-4000
-8000
-8040
-80E0
-8040
-8000
-4000
-2000
-1F00
+FE00
+2100
+2080
+2080
+2100
+3E00
+2300
+2100
+2100
+2100
+F8E0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5219
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 15 1 0
+STARTCHAR uni13A2
+ENCODING 5026
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-0040
-00E0
-0040
-0000
-01F0
-0200
-0400
+FF80
+8880
+8880
+8880
 0800
-4800
-E800
-4800
 0800
-0400
-0200
-01F0
+0800
+0800
+0800
+0800
+3E00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5220
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR uni13A3
+ENCODING 5027
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-0400
 0E00
 0400
-0000
-1F00
-2000
-4000
-8000
-8040
-80E0
-8040
-8000
+0E00
+1100
+2080
+6080
+9080
+9080
+9080
+9300
 4000
-2000
-1F00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5221
+STARTCHAR uni13A4
+ENCODING 5028
 SWIDTH 780 0
 DWIDTH 13 0
 BBX 12 11 1 0
 BITMAP
-01F0
-0200
-4400
-E800
-4800
-0800
-4800
-E800
+3800
+4460
+8250
+8210
+8230
+83E0
+8200
+8200
+8200
 4400
-0200
-01F0
+3800
 ENDCHAR
-STARTCHAR char5153
-ENCODING 5222
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 6 1 5
+STARTCHAR uni13A5
+ENCODING 5029
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 11 1 0
 BITMAP
-70
-80
-80
-80
-80
-70
+C0
+C0
+00
+00
+C0
+40
+40
+40
+40
+40
+E0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5223
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni13A6
+ENCODING 5030
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 11 0 0
 BITMAP
-8090
-8090
-8090
-8090
-8090
-8080
-8080
-8080
+3E
+42
+42
+40
+20
+FF
+04
+02
+42
+42
+7C
+ENDCHAR
+STARTCHAR uni13A7
+ENCODING 5031
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+3E00
+0100
+6080
+9040
+9040
+9040
+A040
+C040
 8080
 4100
 3E00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5224
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni13A8
+ENCODING 5032
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-3E10
-4110
-8090
-8090
-8090
-8080
-8080
-8080
-8080
-8080
-8080
+F8
+20
+20
+29
+29
+3A
+24
+20
+20
+20
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5225
-SWIDTH 720 0
-DWIDTH 12 0
+STARTCHAR uni13A9
+ENCODING 5033
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 11 11 1 0
 BITMAP
-F820
-0420
-0220
-0120
-0120
-0100
-0100
-0100
-0200
-0400
-F800
+F1E0
+2080
+1080
+1100
+0900
+0900
+0A00
+0600
+4400
+4400
+3800
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5226
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni13AA
+ENCODING 5034
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 0
 BITMAP
-1F20
-2020
-4020
-8020
-8020
-8000
-8000
-8000
-4000
-2000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
 1F00
+2080
+2080
+F1E0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5227
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni13AB
+ENCODING 5035
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 1 0
 BITMAP
-78
-84
-84
-84
-84
 7C
-04
-04
-04
-04
-04
+10
+10
+10
+10
+10
+10
+10
+10
+90
+E0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5228
+STARTCHAR uni13AC
+ENCODING 5036
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 0
+BITMAP
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+ENDCHAR
+STARTCHAR uni13AD
+ENCODING 5037
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+1F00
+0400
+0400
+6400
+9FE0
+9420
+6440
+0480
+0500
+0600
+0400
+ENDCHAR
+STARTCHAR uni13AE
+ENCODING 5038
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 0
+BBX 6 12 1 0
+BITMAP
+70
+88
+84
+04
+04
+E4
+44
+48
+70
+40
+40
+E0
+ENDCHAR
+STARTCHAR uni13AF
+ENCODING 5039
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0100
+0280
+0440
+0440
+0440
+0840
+0FC0
+0840
+D280
+9480
+6300
+ENDCHAR
+STARTCHAR uni13B0
+ENCODING 5040
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
+F8
 20
-50
 20
-00
-78
-84
-84
-84
-84
+20
+22
+3E
+22
+20
+20
+20
 F8
-80
-80
-80
-80
-80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5229
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni13B1
+ENCODING 5041
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-78
-84
-84
-84
-84
-F8
-80
-80
-80
-80
-80
+FF80
+2180
+2080
+2080
+2000
+2000
+2000
+2000
+2000
+2000
+F800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5230
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 0
+STARTCHAR uni13B2
+ENCODING 5042
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-20
+1C00
+2200
+2200
+2200
+2200
+2200
+1400
+54E0
+8840
+8C40
+7380
+ENDCHAR
+STARTCHAR uni13B3
+ENCODING 5043
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 11 1 0
+BITMAP
+F1CF
+2184
+2184
+2244
+1248
+1248
+1248
+1428
+0C30
+0C30
+0810
+ENDCHAR
+STARTCHAR uni13B4
+ENCODING 5044
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
+BITMAP
+06
+09
+11
+13
+70
+88
+88
+88
+88
+88
 70
+ENDCHAR
+STARTCHAR uni13B5
+ENCODING 5045
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
+BITMAP
+1E
+21
+21
+21
+25
+26
 20
-00
-78
-84
-84
-84
-84
+20
+20
+20
 F8
-80
-80
-80
-80
-80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5231
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni13B6
+ENCODING 5046
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-04
-04
-04
-04
-04
-7C
-84
-84
-84
-84
-78
+1E80
+2180
+4080
+8480
+8400
+8700
+8480
+8480
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5232
+STARTCHAR uni13B7
+ENCODING 5047
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 11 1 0
+BITMAP
+F03C
+3030
+3030
+2850
+2850
+2890
+2490
+2490
+2310
+2310
+FB7C
+ENDCHAR
+STARTCHAR uni13B8
+ENCODING 5048
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 0
+BBX 8 11 1 0
 BITMAP
-04
-0E
-04
-00
-04
+F0
+C8
+84
 04
 04
+84
+E4
+9C
 04
 04
-7C
-84
-84
-84
-84
-78
+1F
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5233
+STARTCHAR uni13B9
+ENCODING 5049
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 11 1 0
+BITMAP
+0F80
+0200
+0200
+0D0C
+7912
+94E0
+2200
+2200
+2200
+2200
+1C00
+ENDCHAR
+STARTCHAR uni13BA
+ENCODING 5050
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+1C20
+2220
+4120
+80A0
+80A0
+80E0
+80A0
+80A0
+4120
+2220
+1C20
+ENDCHAR
+STARTCHAR uni13BB
+ENCODING 5051
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 1 0
+BITMAP
+FBE0
+2080
+2080
+2080
+2080
+3F80
+2080
+2080
+2080
+2080
+FBE0
+ENDCHAR
+STARTCHAR uni13BC
+ENCODING 5052
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 0
+BITMAP
+F8
+20
+20
+70
+88
+08
+08
+08
+08
+88
+70
+ENDCHAR
+STARTCHAR uni13BD
+ENCODING 5053
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+21E0
+2080
+1080
+1100
+0900
+0900
+0A00
+0600
+F400
+4400
+3800
+ENDCHAR
+STARTCHAR uni13BE
+ENCODING 5054
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+1E00
+2100
+4080
+8040
+8040
+FFC0
+8040
+8040
+4080
+2100
+1E00
+ENDCHAR
+STARTCHAR uni13BF
+ENCODING 5055
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 15 1 0
+BBX 9 11 1 0
 BITMAP
-1100
-3B80
-1100
-0000
-0400
-0400
-0400
-0400
-0400
-7C00
-8400
-8400
-8400
-8400
-7800
+2000
+2000
+2000
+F800
+2000
+2000
+2000
+2380
+2100
+2100
+1F00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5234
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni13C0
+ENCODING 5056
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 0
 BITMAP
-80
-80
-80
-80
-80
-F8
-84
-84
-84
-84
-78
+1E80
+2180
+4080
+8080
+8000
+8000
+83C0
+8080
+4080
+2180
+1E80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5235
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 15 0 0
+STARTCHAR uni13C1
+ENCODING 5057
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-40
+0600
+0900
+0900
+0900
+0880
+1080
+1080
+1040
+D040
+9040
+60F0
+ENDCHAR
+STARTCHAR uni13C2
+ENCODING 5058
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 11 1 0
+BITMAP
 E0
 40
-00
-40
-40
 40
 40
 40
@@ -41703,816 +44346,1108 @@
 42
 42
 42
-3C
+E7
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5236
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni13C3
+ENCODING 5059
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+FE
+C4
+84
+88
+08
+10
+22
+22
+42
+46
+FE
+ENDCHAR
+STARTCHAR uni13C4
+ENCODING 5060
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+3C00
+4200
+E200
+0200
+0200
+E200
+4200
+3E00
+0200
+0200
+0F80
+ENDCHAR
+STARTCHAR uni13C5
+ENCODING 5061
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+1C00
+2200
+4100
+80A4
+80A4
+80E8
+8090
+8080
+4100
+2200
+1C00
+ENDCHAR
+STARTCHAR uni13C6
+ENCODING 5062
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 1 0
+BITMAP
+FF80
+8880
+8880
+8880
+0800
+0800
+0800
+0800
+8880
+8880
+FF80
+ENDCHAR
+STARTCHAR uni13C7
+ENCODING 5063
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 11 1 0
 BITMAP
 0780
-0840
-0840
 0840
-4840
-E7C0
-4040
-0040
-0040
-0040
-0040
+0820
+0010
+0010
+4210
+8410
+8410
+8410
+8C20
+73C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5237
+STARTCHAR uni13C8
+ENCODING 5064
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
 BITMAP
-7800
-8400
-8400
-8400
-8480
-7DC0
-0480
-0400
-0400
-0400
-0400
+6300
+9480
+9840
+9A40
+1980
+2400
+2400
+2400
+2400
+2400
+1800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5238
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni13C9
+ENCODING 5065
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
+BITMAP
+00C6
+08A9
+1871
+9442
+6440
+0440
+0280
+0280
+0280
+0100
+0100
+ENDCHAR
+STARTCHAR uni13CA
+ENCODING 5066
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
 0780
-0840
 0840
-0840
-4840
-EF80
-4800
-0800
-0800
-0800
-0800
+0820
+0010
+4010
+8310
+8510
+8410
+8410
+8C20
+73C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5239
+STARTCHAR uni13CB
+ENCODING 5067
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+7A
+86
+82
+80
+78
+40
+8C
+92
+82
+82
+7C
+ENDCHAR
+STARTCHAR uni13CC
+ENCODING 5068
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 11 11 1 0
 BITMAP
-7800
-8400
-8400
-8400
+FBE0
+2080
+2080
+2080
+2080
+3F80
+2080
+2080
+2080
+2080
+1F00
+ENDCHAR
+STARTCHAR uni13CD
+ENCODING 5069
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+00F0
+0108
+0004
+0004
+0384
+3104
+4904
+8704
+8504
+4888
+3070
+ENDCHAR
+STARTCHAR uni13CE
+ENCODING 5070
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+0400
+0C00
+1400
+2400
+4480
 8480
-F9C0
-8080
-8000
-8000
-8000
-8000
+FF80
+0480
+0480
+0400
+1F00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5240
+STARTCHAR uni13CF
+ENCODING 5071
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 11 0 0
 BITMAP
-0200
-0700
-0200
-0000
-0780
-0840
-0840
-0840
-4840
-EF80
-4800
+F800
+2000
+2000
+2000
+2000
+3F80
+20C0
+2040
+2040
+2080
+FF00
+ENDCHAR
+STARTCHAR uni13D0
+ENCODING 5072
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+3E00
+0800
 0800
 0800
+CF80
+F980
+0800
+0800
 0800
 0800
+3E00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5241
+STARTCHAR uni13D1
+ENCODING 5073
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 11 1 0
 BITMAP
-2000
+3180
+4A40
+3C40
+4040
+7180
+8800
+8800
+8800
+8800
+8800
 7000
-2000
-0000
-7800
-8400
-8400
-8400
-8480
-F9C0
-8080
-8000
-8000
-8000
-8000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5242
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni13D2
+ENCODING 5074
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-0040
-0040
-0040
-0040
-4040
-E7C0
-4840
-0840
-0840
-0840
-0780
+FE00
+2100
+2080
+2080
+3900
+2600
+2100
+2080
+2080
+2080
+FBE0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5243
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni13D3
+ENCODING 5075
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 1 0
 BITMAP
-0400
-0400
-0400
-0400
-0480
-7DC0
-8480
-8400
-8400
-8400
-7800
+F8
+20
+20
+20
+20
+20
+20
+20
+20
+24
+1C
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5244
+STARTCHAR uni13D4
+ENCODING 5076
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 15 1 0
+BBX 11 11 1 0
 BITMAP
-0040
-00E0
-0040
-0000
-0040
-0040
-0040
-0040
-4040
-E7C0
-4840
-0840
-0840
-0840
-0780
+8A20
+8A20
+8A20
+4440
+4440
+4440
+2A80
+2A80
+2A80
+1100
+1100
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5245
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR uni13D5
+ENCODING 5077
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-0400
-0E00
-0400
-0000
-0400
-0400
-0400
-0400
-0480
-7DC0
-8480
-8400
-8400
-8400
-7800
+78
+84
+9E
+80
+40
+36
+78
+04
+84
+84
+F8
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5246
+STARTCHAR uni13D6
+ENCODING 5078
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
 BITMAP
-0800
-0800
+FF00
+8800
+8800
+8800
 0800
 0800
-4800
-EF80
-4840
+0880
 0840
 0840
 0840
 0780
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5247
+STARTCHAR uni13D7
+ENCODING 5079
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
 BITMAP
-8000
-8000
-8000
-8000
-8080
-F9C0
-8480
-8400
-8400
-8400
-7800
+07C0
+0100
+0100
+0100
+0300
+0500
+0900
+1100
+A100
+C100
+87C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5248
+STARTCHAR uni13D8
+ENCODING 5080
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 11 1 0
 BITMAP
-0800
-1C00
-0800
-0000
-0800
-0800
-0800
-0800
-4800
-EF80
-4840
-0840
-0840
-0840
-0780
+7FC0
+6100
+4100
+4100
+0300
+0500
+0900
+1100
+A100
+C100
+87C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5249
+STARTCHAR uni13D9
+ENCODING 5081
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 15 0 0
+BBX 11 11 1 0
 BITMAP
-4000
-E000
-4000
-0000
-4000
-4000
-4000
-4000
-4040
-7CE0
-4240
-4200
-4200
-4200
-3C00
+F1E0
+2080
+2080
+1100
+1100
+1100
+0A00
+0A00
+0A00
+0400
+0400
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5250
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni13DA
+ENCODING 5082
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-0800
-0800
-4800
-E800
-4800
-0F80
-4840
-E840
-4840
-0840
-0780
+7C
+84
+84
+80
+40
+30
+08
+04
+84
+84
+F8
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5251
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 6 1 5
+STARTCHAR uni13DB
+ENCODING 5083
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-80
-80
-E0
-90
-90
-E0
+39C0
+4620
+4420
+B020
+8840
+8400
+8400
+8400
+8400
+4800
+3000
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5252
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 6 1 5
+STARTCHAR uni13DC
+ENCODING 5084
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-10
-10
-70
-90
-90
-70
+0C00
+1200
+1200
+0C00
+3300
+6180
+9240
+9240
+9240
+9240
+6180
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5253
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni13DD
+ENCODING 5085
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 11 0 0
 BITMAP
-7880
-8480
-8480
-8480
-8480
-7C00
-0400
-0400
-0400
-0400
-0400
+1C
+22
+22
+26
+20
+20
+21
+21
+21
+23
+FF
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5254
+STARTCHAR uni13DE
+ENCODING 5086
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 11 0 0
+BITMAP
+F8
+20
+20
+20
+20
+20
+21
+21
+21
+23
+FF
+ENDCHAR
+STARTCHAR uni13DF
+ENCODING 5087
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-7880
-8480
-8480
-8480
-8480
-F880
-8000
-8000
+1E80
+2180
+4080
+8080
 8000
 8000
 8000
+8080
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5255
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni13E0
+ENCODING 5088
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0480
-0480
-0480
-0480
-0480
-7C00
-8400
-8400
-8400
-8400
-7800
+07C0
+0100
+6100
+9100
+7FC0
+1100
+1100
+1100
+1100
+1100
+0E00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5256
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni13E1
+ENCODING 5089
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-81
-81
-81
-81
-81
-F8
-84
-84
-84
-84
-78
+39C0
+4620
+4220
+E540
+0500
+0880
+0880
+0880
+0880
+0880
+0700
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5257
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni13E2
+ENCODING 5090
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 1 0
 BITMAP
-78
-84
-84
-04
-04
-04
-04
-04
-04
-04
-04
+FF00
+2180
+2080
+2080
+2180
+3F00
+2000
+2000
+2000
+2000
+F800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5258
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 0
+STARTCHAR uni13E3
+ENCODING 5091
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-20
-50
-20
-00
-78
-84
-84
-80
-80
-80
-80
-80
-80
-80
-80
+1E00
+2100
+4100
+8380
+8000
+8000
+8300
+8100
+4100
+2200
+1C00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5259
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni13E4
+ENCODING 5092
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-78
-84
-84
-80
-80
-80
-80
-80
-80
-80
-80
+FCF0
+9040
+1040
+1080
+1080
+1100
+1200
+1200
+1400
+1400
+1800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5260
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 0
+STARTCHAR uni13E5
+ENCODING 5093
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-20
-70
-20
-00
-78
-84
-84
-80
-80
-80
-80
-80
-80
-80
-80
+F800
+2000
+20C0
+2320
+2D40
+3100
+2100
+2100
+2100
+2100
+F3C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5261
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni13E6
+ENCODING 5094
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 1 0
 BITMAP
-04
-04
-04
-04
-04
-04
-04
-04
-84
-84
-78
+F9E0
+2080
+2100
+2200
+2400
+2E00
+3200
+2100
+2100
+2080
+F9E0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5262
+STARTCHAR uni13E7
+ENCODING 5095
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 0
+BBX 7 11 1 0
 BITMAP
-04
 0E
 04
-00
-04
-04
 04
 04
-04
-04
-04
-04
+34
+4C
 84
 84
-78
+84
+44
+38
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5263
+STARTCHAR uni13E8
+ENCODING 5096
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
+BITMAP
+1E00
+2100
+4148
+81B0
+8120
+8000
+8120
+81B0
+4148
+2100
+1E00
+ENDCHAR
+STARTCHAR uni13E9
+ENCODING 5097
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -2
+BITMAP
+1E80
+2180
+4080
+8080
+8000
+8000
+83C0
+8080
+4080
+2180
+1E80
+0080
+0060
+ENDCHAR
+STARTCHAR uni13EA
+ENCODING 5098
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
+BITMAP
+0630
+0948
+1148
+1148
+1228
+1218
+1408
+9410
+8810
+9820
+67C0
+ENDCHAR
+STARTCHAR uni13EB
+ENCODING 5099
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 15 1 0
+BBX 10 11 1 0
 BITMAP
-1100
-3B80
-1100
-0000
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-8400
-8400
-7800
+1E00
+2100
+4080
+F040
+8840
+8440
+8440
+83C0
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5264
+STARTCHAR uni13EC
+ENCODING 5100
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 1 0
+BITMAP
+0300
+6280
+9240
+9040
+9040
+A040
+C040
+8080
+4100
+3E00
+ENDCHAR
+STARTCHAR uni13ED
+ENCODING 5101
 SWIDTH 420 0
 DWIDTH 7 0
 BBX 6 11 1 0
 BITMAP
-80
-80
-80
-80
-80
-80
+18
+24
+24
+24
+14
+0C
+04
+08
+88
+B0
+C0
+ENDCHAR
+STARTCHAR uni13EE
+ENCODING 5102
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
+BITMAP
+3C
+44
+44
 80
 80
+B8
+C4
+84
 84
 84
 78
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5265
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 15 1 0
+STARTCHAR uni13EF
+ENCODING 5103
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 11 1 0
 BITMAP
-40
-E0
-40
-00
-40
-40
-40
-40
-40
-40
+0780
+0840
+0820
+0010
+1110
+5BD0
+8410
+8410
+8410
+8C20
+73C0
+ENDCHAR
+STARTCHAR uni13F0
+ENCODING 5104
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 0
+BITMAP
+0E
+11
+21
+21
+21
+2E
+21
+21
+A1
+61
+72
+CC
+ENDCHAR
+STARTCHAR uni13F1
+ENCODING 5105
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 0
+BITMAP
+0700
+0200
+0700
+0880
+0840
+1040
+1040
+2240
+A440
+C480
+4300
+ENDCHAR
+STARTCHAR uni13F2
+ENCODING 5106
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
+BITMAP
+3C
+42
+46
 40
 40
+7C
 42
 42
-3C
+42
+42
+E7
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5266
+STARTCHAR uni13F3
+ENCODING 5107
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
+BITMAP
+1EA8
+21F8
+4150
+8000
+8000
+8000
+83C0
+8080
+4080
+2180
+1E80
+ENDCHAR
+STARTCHAR uni13F4
+ENCODING 5108
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 11 1 0
+BBX 10 11 0 0
 BITMAP
-0F00
-1080
-1080
-0080
-4080
-E080
-4080
-0080
-0080
-0080
-0080
+FF00
+2080
+2040
+2040
+2080
+3F00
+2080
+2040
+2040
+2080
+FF00
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5267
+STARTCHAR uni1401
+ENCODING 5121
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 1 0
 BITMAP
-7800
-8400
-8400
-0400
-0480
-05C0
-0480
-0400
-0400
-0400
-0400
+FF80
+8080
+4100
+4100
+2200
+2200
+2200
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5268
+STARTCHAR uni1402
+ENCODING 5122
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 15 1 0
 BITMAP
-0780
-0840
-0840
-0800
-4800
-E800
-4800
 0800
+1400
 0800
+0000
 0800
 0800
+1400
+1400
+2200
+2200
+2200
+4100
+4100
+8080
+FF80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5269
-SWIDTH 600 0
-DWIDTH 10 0
+STARTCHAR uni1403
+ENCODING 5123
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
-7800
-8400
-8400
-8000
-8100
-8380
-8100
-8000
-8000
-8000
-8000
+0800
+0800
+1400
+1400
+2200
+2200
+2200
+4100
+4100
+8080
+FF80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5270
+STARTCHAR uni1404
+ENCODING 5124
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 9 15 1 0
 BITMAP
-0200
-0700
-0200
-0000
-0780
-0840
-0840
-0800
-4800
-E800
-4800
 0800
+1C00
 0800
+0000
 0800
 0800
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5271
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
-BITMAP
-2000
-7000
-2000
-0000
-7800
-8400
-8400
-8000
-8100
-8380
-8100
-8000
-8000
-8000
-8000
+1400
+1400
+2200
+2200
+2200
+4100
+4100
+8080
+FF80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5272
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni1405
+ENCODING 5125
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0080
-0080
-0080
-0080
-4080
-E080
-4080
-0080
-1080
-1080
-0F00
+C000
+B000
+8C00
+8300
+8080
+8040
+8080
+8300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5273
+STARTCHAR uni1406
+ENCODING 5126
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 15 1 0
 BITMAP
-0400
-0400
 0400
-0400
-0480
-05C0
-0480
+0E00
 0400
-8400
-8400
-7800
+0000
+C000
+B000
+8C00
+8300
+8080
+8040
+8080
+8300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5274
+STARTCHAR uni1407
+ENCODING 5127
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 15 1 0
 BITMAP
-0080
-01C0
-0080
+2200
+7700
+2200
 0000
-0080
-0080
-0080
-0080
-4080
-E080
-4080
-0080
-1080
-1080
-0F00
+C000
+B000
+8C00
+8300
+8080
+8040
+8080
+8300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5275
+STARTCHAR uni1408
+ENCODING 5128
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 11 1 0
 BITMAP
-0400
-0E00
-0400
-0000
-0400
-0400
-0400
-0400
-0480
-05C0
-0480
-0400
-8400
-8400
-7800
+C000
+B000
+8C00
+A300
+A080
+A040
+A080
+A300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5276
+STARTCHAR uni1409
+ENCODING 5129
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
 BITMAP
-0800
-0800
-0800
-0800
-4800
-E800
-4800
-0800
-0840
-0840
-0780
+C000
+B000
+8C00
+8300
+9080
+B840
+9080
+8300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5277
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni140A
+ENCODING 5130
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8000
-8000
-8000
-8000
-8100
-8380
-8100
-8000
-8400
-8400
-7800
+00C0
+0340
+0C40
+3040
+4040
+8040
+4040
+3040
+0C40
+0340
+00C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5278
+STARTCHAR uni140B
+ENCODING 5131
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 15 1 0
@@ -42521,500 +45456,782 @@
 1C00
 0800
 0000
-0800
-0800
-0800
-0800
-4800
-E800
-4800
-0800
-0840
-0840
-0780
+00C0
+0340
+0C40
+3040
+4040
+8040
+4040
+3040
+0C40
+0340
+00C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5279
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 15 0 0
+STARTCHAR uni140C
+ENCODING 5132
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-4000
-E000
-4000
-0000
-4000
-4000
-4000
-4000
-4080
-41C0
-4080
-4000
-4200
-4200
-3C00
+3FE0
+2020
+1040
+1040
+4880
+E880
+4880
+0500
+0500
+0200
+0200
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5280
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni140D
+ENCODING 5133
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
+FF80
+8080
+4100
+4100
+2240
+22E0
+2240
+1400
+1400
 0800
 0800
-4800
-E800
-4800
-0800
-4800
-E800
-4840
-0840
-0780
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5281
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 6 1 5
+STARTCHAR uni140E
+ENCODING 5134
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-80
-80
-80
-90
-90
-60
+0200
+0200
+0500
+0500
+4880
+E880
+4880
+1040
+1040
+2020
+3FE0
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5282
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 6 1 5
+STARTCHAR uni140F
+ENCODING 5135
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-10
-10
-10
-90
-90
-60
+0800
+0800
+1400
+1400
+2240
+22E0
+2240
+4100
+4100
+8080
+FF80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5283
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR uni1410
+ENCODING 5136
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
-FC
-04
-04
-04
-04
-04
-04
-04
-04
-04
-04
+0200
+0700
+0200
+0000
+0200
+0200
+0500
+4500
+E880
+4880
+0880
+1040
+1040
+2020
+3FE0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5284
+STARTCHAR uni1411
+ENCODING 5137
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
+BITMAP
+0800
+1C00
+0800
+0000
+0800
+0800
+1400
+1440
+22E0
+2240
+2200
+4100
+4100
+8080
+FF80
+ENDCHAR
+STARTCHAR uni1412
+ENCODING 5138
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+0C00
+0B00
+08C0
+0830
+4808
+E804
+4808
+0830
+08C0
+0B00
+0C00
+ENDCHAR
+STARTCHAR uni1413
+ENCODING 5139
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+C000
+B000
+8C00
+8300
+8088
+805C
+8088
+8300
+8C00
+B000
+C000
+ENDCHAR
+STARTCHAR uni1414
+ENCODING 5140
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+0400
+0E00
+0400
+0000
+0C00
+0B00
+08C0
+0830
+4808
+E804
+4808
+0830
+08C0
+0B00
+0C00
+ENDCHAR
+STARTCHAR uni1415
+ENCODING 5141
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+4000
+E000
+4000
+0000
+C000
+B000
+8C00
+8300
+8088
+805C
+8088
+8300
+8C00
+B000
+C000
+ENDCHAR
+STARTCHAR uni1416
+ENCODING 5142
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+2000
+7000
+2000
+0080
+C1C0
+B080
+8C00
+8300
+8080
+8040
+8080
+8300
+8C00
+B000
+C000
+ENDCHAR
+STARTCHAR uni1417
+ENCODING 5143
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+000C
+0034
+00C4
+0304
+4404
+E804
+4404
+0304
+00C4
+0034
+000C
+ENDCHAR
+STARTCHAR uni1418
+ENCODING 5144
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+00C0
+0340
+0C40
+3040
+4048
+805C
+4048
+3040
+0C40
+0340
+00C0
+ENDCHAR
+STARTCHAR uni1419
+ENCODING 5145
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+0008
+001C
+0008
+0000
+000C
+0034
+00C4
+0304
+4404
+E804
+4404
+0304
+00C4
+0034
+000C
+ENDCHAR
+STARTCHAR uni141A
+ENCODING 5146
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+0080
+01C0
+0080
+0000
+00C0
+0340
+0C40
+3040
+4048
+805C
+4048
+3040
+0C40
+0340
+00C0
+ENDCHAR
+STARTCHAR uni141B
+ENCODING 5147
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0100
+0380
+0100
+4000
+E0C0
+4340
+0C40
+3040
+4040
+8040
+4040
+3040
+0C40
+0340
+00C0
+ENDCHAR
+STARTCHAR uni141C
+ENCODING 5148
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 6 1 5
+BITMAP
+92
+92
+92
+92
+92
+6C
+ENDCHAR
+STARTCHAR uni141D
+ENCODING 5149
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 0
+BBX 6 6 1 5
+BITMAP
+08
+14
+08
+40
+E0
+40
+ENDCHAR
+STARTCHAR uni141E
+ENCODING 5150
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 6 1 5
 BITMAP
 20
+20
 50
+50
+88
+F8
+ENDCHAR
+STARTCHAR uni141F
+ENCODING 5151
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 4 1 7
+BITMAP
+10
 20
-00
-FC
-80
-80
-80
-80
-80
-80
-80
-80
+40
 80
+ENDCHAR
+STARTCHAR uni1420
+ENCODING 5152
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 4 1 7
+BITMAP
 80
+40
+20
+10
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5285
+STARTCHAR uni1421
+ENCODING 5153
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 11 1 0
+BBX 6 4 1 7
 BITMAP
-FC
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
+84
+84
+84
+78
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5286
+STARTCHAR uni1422
+ENCODING 5154
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 0
+BBX 6 4 1 7
 BITMAP
-20
-70
-20
-00
-FC
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
+78
+84
+84
+84
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5287
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR uni1423
+ENCODING 5155
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 5
 BITMAP
-04
-04
-04
-04
-04
-04
-04
-04
-04
-04
-FC
+E0
+10
+10
+10
+10
+E0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5288
+STARTCHAR uni1424
+ENCODING 5156
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 4 1 4
+BITMAP
+60
+90
+90
+60
+ENDCHAR
+STARTCHAR uni1425
+ENCODING 5157
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 0
+BBX 7 4 1 7
 BITMAP
-04
-0E
-04
-00
-04
-04
-04
-04
-04
-04
-04
-04
-04
-04
-FC
+12
+24
+48
+90
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5289
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
+STARTCHAR uni1426
+ENCODING 5158
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 5 1 6
 BITMAP
-1100
-3B80
-1100
-0000
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-FC00
+90
+90
+90
+90
+90
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5290
+STARTCHAR uni1427
+ENCODING 5159
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 3 1 5
+BITMAP
+40
+E0
+40
+ENDCHAR
+STARTCHAR uni1428
+ENCODING 5160
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 1 1 10
+BITMAP
+FE
+ENDCHAR
+STARTCHAR uni1429
+ENCODING 5161
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 11 1 0
+BBX 5 5 1 6
 BITMAP
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
-FC
+20
+20
+F8
+20
+20
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5291
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 15 1 0
+STARTCHAR uni142A
+ENCODING 5162
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 6
 BITMAP
-40
-E0
-40
-00
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
-7E
+F8
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5292
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni142B
+ENCODING 5163
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 12 1 0
 BITMAP
-1F80
-0080
-0080
-0080
-4080
-E080
-4080
-0080
-0080
-0080
-0080
+0020
+FF90
+8088
+4104
+4100
+2200
+2200
+2200
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5293
+STARTCHAR uni142C
+ENCODING 5164
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 1 0
+BITMAP
+0200
+0900
+0880
+1440
+1400
+2200
+2200
+2200
+4100
+4100
+8080
+FF80
+ENDCHAR
+STARTCHAR uni142D
+ENCODING 5165
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 11 1 1
 BITMAP
-FC00
-0400
-0400
-0400
-0480
-05C0
-0480
-0400
-0400
-0400
-0400
+0200
+C100
+B080
+8C40
+8300
+8080
+8080
+8300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5294
+STARTCHAR uni142E
+ENCODING 5166
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 11 1 1
+BITMAP
+0020
+0190
+0688
+1884
+6080
+8080
+8080
+6080
+1880
+0680
+0180
+ENDCHAR
+STARTCHAR uni142F
+ENCODING 5167
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 1 0
 BITMAP
-0FC0
-0800
+8080
+8080
+4100
+4100
+2200
+2200
+2200
+1400
+1400
 0800
 0800
-4800
-E800
-4800
+ENDCHAR
+STARTCHAR uni1430
+ENCODING 5168
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 15 1 0
+BITMAP
 0800
+1400
 0800
+0000
 0800
 0800
+1400
+1400
+2200
+2200
+2200
+4100
+4100
+8080
+8080
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5295
-SWIDTH 600 0
-DWIDTH 10 0
+STARTCHAR uni1431
+ENCODING 5169
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
-FC00
-8000
-8000
-8000
-8100
-8380
-8100
-8000
-8000
-8000
-8000
+0800
+0800
+1400
+1400
+2200
+2200
+2200
+4100
+4100
+8080
+8080
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5296
+STARTCHAR uni1432
+ENCODING 5170
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 9 15 1 0
 BITMAP
-0200
-0700
-0200
-0000
-0FC0
 0800
-0800
-0800
-4800
-E800
-4800
-0800
+1C00
 0800
+0000
 0800
 0800
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5297
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
-BITMAP
-2000
-7000
-2000
-0000
-FC00
-8000
-8000
-8000
-8100
-8380
-8100
-8000
-8000
-8000
-8000
+1400
+1400
+2200
+2200
+2200
+4100
+4100
+8080
+8080
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5298
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni1433
+ENCODING 5171
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0080
-0080
-0080
-0080
-4080
-E080
-4080
-0080
+C000
+3000
+0C00
+0300
 0080
+0040
 0080
-1F80
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5299
+STARTCHAR uni1434
+ENCODING 5172
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 15 1 0
 BITMAP
-0400
-0400
-0400
-0400
-0480
-05C0
-0480
-0400
 0400
+0E00
 0400
-FC00
+0000
+C000
+3000
+0C00
+0300
+0080
+0040
+0080
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5300
+STARTCHAR uni1435
+ENCODING 5173
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 15 1 0
 BITMAP
-0080
-01C0
-0080
+2200
+7700
+2200
 0000
-0080
-0080
-0080
-0080
-4080
-E080
-4080
-0080
+C000
+3000
+0C00
+0300
 0080
+0040
 0080
-1F80
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5301
+STARTCHAR uni1436
+ENCODING 5174
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 11 1 0
 BITMAP
-0400
-0E00
-0400
-0000
-0400
-0400
-0400
-0400
-0480
-05C0
-0480
-0400
-0400
-0400
-FC00
+C000
+3000
+0C00
+2300
+2080
+2040
+2080
+2300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5302
+STARTCHAR uni1437
+ENCODING 5175
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
 BITMAP
-0800
-0800
-0800
-0800
-4800
-E800
-4800
-0800
-0800
-0800
-0FC0
+C000
+3000
+0C00
+0300
+1080
+3840
+1080
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5303
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni1438
+ENCODING 5176
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8000
-8000
-8000
-8000
-8100
-8380
-8100
-8000
-8000
+00C0
+0300
+0C00
+3000
+4000
 8000
-FC00
+4000
+3000
+0C00
+0300
+00C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5304
+STARTCHAR uni1439
+ENCODING 5177
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 15 1 0
@@ -43023,966 +46240,1117 @@
 1C00
 0800
 0000
+00C0
+0300
+0C00
+3000
+4000
+8000
+4000
+3000
+0C00
+0300
+00C0
+ENDCHAR
+STARTCHAR uni143A
+ENCODING 5178
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 -1 0
+BITMAP
+2020
+2020
+1040
+1040
+0880
+4880
+E880
+4500
+0500
+0200
+0200
+ENDCHAR
+STARTCHAR uni143B
+ENCODING 5179
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+8080
+8080
+4100
+4100
+2200
+2240
+22E0
+1440
+1400
 0800
-0800
-0800
-0800
-4800
-E800
-4800
 0800
+ENDCHAR
+STARTCHAR uni143C
+ENCODING 5180
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 -1 0
+BITMAP
+0200
+0200
+0500
+4500
+E880
+4880
+0880
+1040
+1040
+2020
+2020
+ENDCHAR
+STARTCHAR uni143D
+ENCODING 5181
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
 0800
 0800
-0FC0
+1400
+1440
+22E0
+2240
+2200
+4100
+4100
+8080
+8080
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5305
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 15 0 0
+STARTCHAR uni143E
+ENCODING 5182
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
-4000
-E000
-4000
+0200
+0700
+0200
 0000
-4000
-4000
-4000
-4000
-4080
-41C0
-4080
-4000
-4000
-4000
-7E00
+0200
+0200
+0500
+4500
+E880
+4880
+0880
+1040
+1040
+2020
+2020
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5306
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni143F
+ENCODING 5183
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
 0800
+1C00
 0800
-4800
-E800
-4800
+0000
 0800
-4800
-E800
-4800
 0800
-0FC0
+1400
+1440
+22E0
+2240
+2200
+4100
+4100
+8080
+8080
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5307
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 6 1 5
+STARTCHAR uni1440
+ENCODING 5184
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
 BITMAP
-80
-80
-80
-80
-80
-F0
+0C00
+0300
+00C0
+0030
+4008
+E004
+4008
+0030
+00C0
+0300
+0C00
 ENDCHAR
-STARTCHAR char5153
-ENCODING 5308
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 6 1 5
+STARTCHAR uni1441
+ENCODING 5185
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
 BITMAP
-70
-80
-80
-80
-80
-70
+C000
+3000
+0C00
+0300
+0088
+005C
+0088
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5309
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 6 1 5
+STARTCHAR uni1442
+ENCODING 5186
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
 BITMAP
-10
-10
-10
-10
-10
-F0
+0400
+0E00
+0400
+0000
+0C00
+0300
+00C0
+0030
+4008
+E004
+4008
+0030
+00C0
+0300
+0C00
 ENDCHAR
-STARTCHAR char5310
-ENCODING 5310
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 6 1 5
+STARTCHAR uni1443
+ENCODING 5187
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
 BITMAP
-60
-90
-10
-20
-40
-F0
+4000
+E000
+4000
+0000
+C000
+3000
+0C00
+0300
+0088
+005C
+0088
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5311
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni1444
+ENCODING 5188
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
 BITMAP
-38
-44
-82
-02
-02
-04
-08
-10
-20
-42
-FE
+000C
+0030
+00C0
+0300
+4400
+E800
+4400
+0300
+00C0
+0030
+000C
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5312
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 6 1 0
+STARTCHAR uni1445
+ENCODING 5189
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
 BITMAP
-FF80
-0840
-0840
-0840
-0840
-0780
+00C0
+0300
+0C00
+3000
+4008
+801C
+4008
+3000
+0C00
+0300
+00C0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5313
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 0
+STARTCHAR uni1446
+ENCODING 5190
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
 BITMAP
-1000
-2800
-1000
+0008
+001C
+0008
 0000
-7FC0
-8400
-8400
-8400
-8400
-7800
+000C
+0030
+00C0
+0300
+4400
+E800
+4400
+0300
+00C0
+0030
+000C
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5314
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 6 1 0
+STARTCHAR uni1447
+ENCODING 5191
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
 BITMAP
-7FC0
-8400
-8400
-8400
-8400
-7800
+0080
+01C0
+0080
+0000
+00C0
+0300
+0C00
+3000
+4008
+801C
+4008
+3000
+0C00
+0300
+00C0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5315
+STARTCHAR uni1448
+ENCODING 5192
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 10 1 0
+BBX 10 15 1 0
 BITMAP
-1000
-3800
-1000
+1100
+3B80
+1100
 0000
-7FC0
-8400
-8400
-8400
-8400
-7800
+00C0
+0300
+0C00
+3000
+4000
+8000
+4000
+3000
+0C00
+0300
+00C0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5316
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 6 1 0
+STARTCHAR uni1449
+ENCODING 5193
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 5 1 6
 BITMAP
-0780
-0840
-0840
-0840
-0840
-FF80
+0C
+30
+C0
+30
+0C
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5317
+STARTCHAR uni144A
+ENCODING 5194
+SWIDTH 120 0
+DWIDTH 2 0
+BBX 1 5 1 6
+BITMAP
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni144B
+ENCODING 5195
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 8 1 3
+BITMAP
+80
+80
+80
+B0
+C8
+88
+88
+88
+ENDCHAR
+STARTCHAR uni144C
+ENCODING 5196
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 10 1 0
+BBX 9 11 1 0
 BITMAP
-0200
-0700
-0200
-0000
-0780
-0840
-0840
-0840
-0840
-FF80
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5318
+STARTCHAR uni144D
+ENCODING 5197
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 10 1 0
+BBX 9 15 1 0
 BITMAP
-0880
-1DC0
-0880
+0800
+1400
+0800
 0000
-0780
-0840
-0840
-0840
-0840
-FF80
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5319
+STARTCHAR uni144E
+ENCODING 5198
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 6 1 0
+BBX 9 11 1 0
 BITMAP
-7800
-8400
-8400
-8400
-8400
-7FC0
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5320
+STARTCHAR uni144F
+ENCODING 5199
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 10 1 0
+BBX 9 15 1 0
 BITMAP
-1000
-3800
-1000
+0800
+1C00
+0800
 0000
-7800
-8400
-8400
-8400
-8400
-7FC0
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5321
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1450
+ENCODING 5200
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-4000
-EFF8
-4084
-0084
-0084
-0084
-0078
+F8
+04
+02
+01
+01
+01
+01
+01
+02
+04
+F8
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5322
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1451
+ENCODING 5201
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-0008
-FF9C
-0848
-0840
-0840
-0840
-0780
+20
+70
+20
+00
+F8
+04
+02
+01
+01
+01
+01
+01
+02
+04
+F8
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5323
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1452
+ENCODING 5202
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-4000
-E780
-4840
-0840
-0840
-0840
-07FC
+44
+EE
+44
+00
+F8
+04
+02
+01
+01
+01
+01
+01
+02
+04
+F8
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5324
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
+STARTCHAR uni1453
+ENCODING 5203
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-0040
-78E0
-8440
-8400
-8400
-8400
-7FC0
+F8
+04
+02
+21
+21
+21
+21
+21
+02
+04
+F8
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5325
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
+STARTCHAR uni1454
+ENCODING 5204
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-0100
-0380
-0100
-4000
-E780
-4840
-0840
-0840
-0840
-07FC
+F8
+04
+02
+01
+21
+71
+21
+01
+02
+04
+F8
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5326
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 10 1 0
+STARTCHAR uni1455
+ENCODING 5205
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-1000
-3800
-1000
-0040
-78E0
-8440
-8400
-8400
-8400
-7FC0
+1F
+20
+40
+80
+80
+80
+80
+80
+40
+20
+1F
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5327
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 0
+STARTCHAR uni1456
+ENCODING 5206
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-4400
-EE00
-4400
-0000
-7800
-8400
-8400
-8400
-8400
-7FC0
+04
+0E
+04
+00
+1F
+20
+40
+80
+80
+80
+80
+80
+40
+20
+1F
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5328
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 4 1 7
+STARTCHAR uni1457
+ENCODING 5207
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
 BITMAP
-60
-90
-90
-7C
+0808
+0808
+0808
+0808
+4808
+E808
+4808
+0808
+0808
+0410
+03E0
 ENDCHAR
-STARTCHAR char5153
-ENCODING 5329
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 6 1 5
+STARTCHAR uni1458
+ENCODING 5208
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
 BITMAP
-84
-84
-84
-84
-84
-78
+8080
+8080
+8080
+8080
+8090
+80B8
+8090
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5330
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 4 1 7
+STARTCHAR uni1459
+ENCODING 5209
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
 BITMAP
-18
-24
-24
-F8
+03E0
+0410
+0808
+0808
+4808
+E808
+4808
+0808
+0808
+0808
+0808
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5331
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 6 1 0
+STARTCHAR uni145A
+ENCODING 5210
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 0
 BITMAP
-FF80
-0040
-0040
-0040
-0040
-0180
+3E00
+4100
+8080
+8080
+8090
+80B8
+8090
+8080
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5332
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 0
+STARTCHAR uni145B
+ENCODING 5211
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 15 1 0
 BITMAP
-0400
-0A00
-0400
+0080
+01C0
+0080
 0000
-7FC0
-8000
-8000
-8000
-8000
-6000
-ENDCHAR
-STARTCHAR 006B
-ENCODING 5333
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 6 1 0
-BITMAP
-7FC0
-8000
-8000
-8000
-8000
-6000
+03E0
+0410
+0808
+0808
+4808
+E808
+4808
+0808
+0808
+0808
+0808
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5334
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 0
+STARTCHAR uni145C
+ENCODING 5212
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 15 1 0
 BITMAP
-0400
-0E00
-0400
+0800
+1C00
+0800
 0000
-7FC0
-8000
-8000
-8000
-8000
-6000
+3E00
+4100
+8080
+8080
+8090
+80B8
+8090
+8080
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5335
+STARTCHAR uni145D
+ENCODING 5213
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 6 1 0
+BBX 11 11 1 0
 BITMAP
-0180
-0040
-0040
+1F00
+0080
 0040
+0020
+4020
+E020
+4020
+0020
 0040
-FF80
+0080
+1F00
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5336
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 10 1 0
+STARTCHAR uni145E
+ENCODING 5214
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
+F800
 0400
-0E00
+0200
+0100
+0120
+0170
+0120
+0100
+0200
 0400
-0000
-0180
-0040
-0040
-0040
-0040
-FF80
+F800
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5337
+STARTCHAR uni145F
+ENCODING 5215
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 10 1 0
+BBX 11 15 1 0
 BITMAP
-1100
-3B80
-1100
+0400
+0E00
+0400
 0000
-0180
-0040
-0040
+1F00
+0080
 0040
+0020
+4020
+E020
+4020
+0020
 0040
-FF80
-ENDCHAR
-STARTCHAR 006B
-ENCODING 5338
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 6 1 0
-BITMAP
-6000
-8000
-8000
-8000
-8000
-7FC0
+0080
+1F00
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5339
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 0
+STARTCHAR uni1460
+ENCODING 5216
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 15 1 0
 BITMAP
+2000
+7000
+2000
+0000
+F800
 0400
-0E00
+0200
+0100
+0120
+0170
+0120
+0100
+0200
 0400
-0000
-6000
-8000
-8000
-8000
-8000
-7FC0
-ENDCHAR
-STARTCHAR 006B
-ENCODING 5340
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
-BITMAP
-4000
-EFF8
-4004
-0004
-0004
-0004
-0018
-ENDCHAR
-STARTCHAR 006B
-ENCODING 5341
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
-BITMAP
-0008
-FF9C
-0048
-0040
-0040
-0040
-0180
+F800
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5342
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1461
+ENCODING 5217
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-4000
-E7FC
-4800
-0800
+01F0
+0200
+0400
 0800
+4800
+E800
+4800
 0800
-0600
+0400
+0200
+01F0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5343
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1462
+ENCODING 5218
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-0008
-7FDC
-8008
-8000
+1F00
+2000
+4000
 8000
+8040
+80E0
+8040
 8000
-6000
+4000
+2000
+1F00
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5344
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
+STARTCHAR uni1463
+ENCODING 5219
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 15 1 0
 BITMAP
 0040
 00E0
 0040
-4000
-E7FC
-4800
-0800
+0000
+01F0
+0200
+0400
 0800
+4800
+E800
+4800
 0800
-0600
+0400
+0200
+01F0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5345
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
+STARTCHAR uni1464
+ENCODING 5220
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
 0400
 0E00
 0400
-0008
-7FDC
-8008
-8000
+0000
+1F00
+2000
+4000
 8000
+8040
+80E0
+8040
 8000
-6000
-ENDCHAR
-STARTCHAR 006B
-ENCODING 5346
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
-BITMAP
 4000
-E018
-4004
-0004
-0004
-0004
-0FF8
+2000
+1F00
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5347
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1465
+ENCODING 5221
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-0008
-019C
-0048
-0040
-0040
-0040
-FF80
+01F0
+0200
+4400
+E800
+4800
+0800
+4800
+E800
+4400
+0200
+01F0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5348
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
-BITMAP
-0040
-00E0
-0040
-4000
-E018
-4004
-0004
-0004
-0004
-0FF8
-ENDCHAR
-STARTCHAR 006B
-ENCODING 5349
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
+STARTCHAR uni1466
+ENCODING 5222
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 5
 BITMAP
-0400
-0E00
-0400
-0008
-019C
-0048
-0040
-0040
-0040
-FF80
+70
+80
+80
+80
+80
+70
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5350
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1467
+ENCODING 5223
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-4000
-E600
-4800
-0800
-0800
-0800
-07FC
+8090
+8090
+8090
+8090
+8090
+8080
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5351
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 7 1 0
+STARTCHAR uni1468
+ENCODING 5224
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-0008
-601C
-8008
-8000
-8000
-8000
-7FC0
+3E10
+4110
+8090
+8090
+8090
+8080
+8080
+8080
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5352
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
+STARTCHAR uni1469
+ENCODING 5225
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-0040
-00E0
-0040
-4000
-E600
-4800
-0800
-0800
-0800
-07FC
+F820
+0420
+0220
+0120
+0120
+0100
+0100
+0100
+0200
+0400
+F800
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5353
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
+STARTCHAR uni146A
+ENCODING 5226
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-0400
-0E00
-0400
-0008
-601C
-8008
+1F20
+2020
+4020
+8020
+8020
 8000
 8000
 8000
-7FC0
+4000
+2000
+1F00
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5354
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 4 1 7
+STARTCHAR uni146B
+ENCODING 5227
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-60
-80
-80
+78
+84
+84
+84
+84
 7C
-ENDCHAR
-STARTCHAR char5355
-ENCODING 5355
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 4
-BITMAP
-30
-C0
-C0
-30
-C0
-C0
-30
-ENDCHAR
-STARTCHAR C087
-ENCODING 5356
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
-BITMAP
-0380
-1C00
-E000
-7000
-0C00
-0380
-0C00
-7000
-E000
-1C00
-0380
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5357
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
+STARTCHAR uni146C
+ENCODING 5228
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
-80
-80
-80
-80
-40
 20
-1E
-02
-02
-02
-02
-ENDCHAR
-STARTCHAR 0079
-ENCODING 5358
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
-BITMAP
-02
-05
-02
+50
+20
 00
-02
-02
-02
-02
-04
-08
-F0
+78
+84
+84
+84
+84
+F8
+80
 80
 80
 80
 80
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5359
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
+STARTCHAR uni146D
+ENCODING 5229
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-02
-02
-02
-02
-04
-08
-F0
+78
+84
+84
+84
+84
+F8
+80
 80
 80
 80
 80
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5360
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR uni146E
+ENCODING 5230
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
-02
-07
-02
+20
+70
+20
 00
-02
-02
-02
-02
-04
-08
-F0
+78
+84
+84
+84
+84
+F8
+80
 80
 80
 80
 80
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5361
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
+STARTCHAR uni146F
+ENCODING 5231
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-02
-02
-02
-02
-1E
-20
-40
-80
-80
-80
-80
+04
+04
+04
+04
+04
+7C
+84
+84
+84
+84
+78
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5362
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR uni1470
+ENCODING 5232
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 15 1 0
 BITMAP
-02
-07
-02
+04
+0E
+04
 00
-02
-02
-02
-02
-1E
-20
-40
-80
-80
-80
-80
+04
+04
+04
+04
+04
+7C
+84
+84
+84
+84
+78
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5363
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR uni1471
+ENCODING 5233
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
-0880
-1DC0
-0880
+1100
+3B80
+1100
 0000
-0200
-0200
-0200
-0200
-1E00
-2000
-4000
-8000
-8000
-8000
-8000
+0400
+0400
+0400
+0400
+0400
+7C00
+8400
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5364
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
+STARTCHAR uni1472
+ENCODING 5234
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
 80
 80
 80
 80
-F0
-08
-04
-02
-02
-02
-02
+80
+F8
+84
+84
+84
+84
+78
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5365
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR uni1473
+ENCODING 5235
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 15 0 0
 BITMAP
 40
 E0
@@ -43992,772 +47360,684 @@
 40
 40
 40
-78
-04
-02
-01
-01
-01
-01
+40
+7C
+42
+42
+42
+42
+3C
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5366
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni1474
+ENCODING 5236
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0800
-0800
-0800
-4800
-E400
-4200
-01E0
-0020
-0020
-0020
-0020
+0780
+0840
+0840
+0840
+4840
+E7C0
+4040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5367
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni1475
+ENCODING 5237
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8000
-8000
-8000
-8040
-40E0
-2040
-1E00
-0200
-0200
-0200
-0200
+7800
+8400
+8400
+8400
+8480
+7DC0
+0480
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5368
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni1476
+ENCODING 5238
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0020
-0020
-0020
-4020
-E040
-4080
-0F00
+0780
+0840
+0840
+0840
+4840
+EF80
+4800
 0800
 0800
 0800
 0800
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5369
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni1477
+ENCODING 5239
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0200
-0200
-0200
-0240
-04E0
-0840
-F000
+7800
+8400
+8400
+8400
+8480
+F9C0
+8080
 8000
 8000
 8000
 8000
-ENDCHAR
-STARTCHAR 0079
-ENCODING 5370
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 15 1 0
-BITMAP
-0020
-0070
-0020
-0000
-0020
-0020
-0020
-4020
-E040
-4080
-0F00
-0800
-0800
-0800
-0800
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5371
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR uni1478
+ENCODING 5240
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
 0200
 0700
 0200
 0000
-0200
-0200
-0200
-0240
-04E0
+0780
 0840
-F000
-8000
-8000
-8000
-8000
-ENDCHAR
-STARTCHAR 0079
-ENCODING 5372
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
-BITMAP
-0020
-0020
-0020
-0020
-41E0
-E200
-4400
+0840
+0840
+4840
+EF80
+4800
 0800
 0800
 0800
 0800
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5373
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni1479
+ENCODING 5241
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
-0200
-0200
-0200
-0200
-1E40
-20E0
-4040
+2000
+7000
+2000
+0000
+7800
+8400
+8400
+8400
+8480
+F9C0
+8080
 8000
 8000
 8000
 8000
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5374
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 15 1 0
+STARTCHAR uni147A
+ENCODING 5242
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0020
-0070
-0020
-0000
-0020
-0020
-0020
-0020
-41E0
-E200
-4400
-0800
-0800
-0800
-0800
+0040
+0040
+0040
+0040
+4040
+E7C0
+4840
+0840
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5375
-SWIDTH 720 0
-DWIDTH 12 0
+STARTCHAR uni147B
+ENCODING 5243
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0400
+0400
+0400
+0400
+0480
+7DC0
+8480
+8400
+8400
+8400
+7800
+ENDCHAR
+STARTCHAR uni147C
+ENCODING 5244
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 11 15 1 0
 BITMAP
-0200
-0700
-0200
+0040
+00E0
+0040
 0000
-0200
-0200
-0200
-0200
-1E40
-20E0
+0040
+0040
+0040
+0040
 4040
-8000
-8000
-8000
-8000
+E7C0
+4840
+0840
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5376
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni147D
+ENCODING 5245
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
 0400
+0E00
 0400
+0000
 0400
 0400
-4780
-E040
-4020
-0010
-0010
-0010
-0010
+0400
+0400
+0480
+7DC0
+8480
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5377
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni147E
+ENCODING 5246
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0800
+0800
+0800
+0800
+4800
+EF80
+4840
+0840
+0840
+0840
+0780
+ENDCHAR
+STARTCHAR uni147F
+ENCODING 5247
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
 8000
 8000
 8000
 8000
-F040
-08E0
-0440
-0200
-0200
-0200
-0200
+8080
+F9C0
+8480
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5378
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 15 1 0
+STARTCHAR uni1480
+ENCODING 5248
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
-0020
-0070
-0020
+0800
+1C00
+0800
 0000
 0800
 0800
 0800
 0800
-4F00
-E080
-4040
-0020
-0020
-0020
-0020
+4800
+EF80
+4840
+0840
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5379
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR uni1481
+ENCODING 5249
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 0 0
 BITMAP
-0200
-0700
-0200
+4000
+E000
+4000
 0000
-8000
-8000
-8000
-8000
-F040
-08E0
-0440
-0200
-0200
-0200
-0200
+4000
+4000
+4000
+4000
+4040
+7CE0
+4240
+4200
+4200
+4200
+3C00
 ENDCHAR
-STARTCHAR 0079
-ENCODING 5380
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni1482
+ENCODING 5250
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
 0800
 0800
 4800
 E800
-4F00
-0080
-4040
-E020
-4020
-0020
-0020
-ENDCHAR
-STARTCHAR char5381
-ENCODING 5381
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 6 1 5
-BITMAP
-80
-80
-C0
-20
-10
-10
+4800
+0F80
+4840
+E840
+4840
+0840
+0780
 ENDCHAR
-STARTCHAR char5382
-ENCODING 5382
+STARTCHAR uni1483
+ENCODING 5251
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 7 1 4
+BBX 4 6 1 5
 BITMAP
-70
-88
 80
-70
-08
-88
-70
+80
+E0
+90
+90
+E0
 ENDCHAR
-STARTCHAR char5381
-ENCODING 5383
+STARTCHAR uni1484
+ENCODING 5252
 SWIDTH 300 0
 DWIDTH 5 0
 BBX 4 6 1 5
 BITMAP
 10
 10
-30
-40
-80
-80
+70
+90
+90
+70
 ENDCHAR
-STARTCHAR char5384
-ENCODING 5384
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 1 6
+STARTCHAR uni1485
+ENCODING 5253
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-80
-80
-80
-40
-38
+7880
+8480
+8480
+8480
+8480
+7C00
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR char5381
-ENCODING 5385
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 8 1 3
+STARTCHAR uni1486
+ENCODING 5254
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-80
-80
-C0
-20
-10
-30
-50
-20
+7880
+8480
+8480
+8480
+8480
+F880
+8000
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR char5381
-ENCODING 5386
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 8 1 3
+STARTCHAR uni1487
+ENCODING 5255
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-10
-10
-30
-40
-80
-C0
-A0
-40
+0480
+0480
+0480
+0480
+0480
+7C00
+8400
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR char5381
-ENCODING 5387
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 14 0 1
+STARTCHAR uni1488
+ENCODING 5256
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-40
-E0
-40
-00
-40
-40
-60
-10
-08
-08
-00
-08
-1C
-08
+81
+81
+81
+81
+81
+F8
+84
+84
+84
+84
+78
 ENDCHAR
-STARTCHAR C065
-ENCODING 5388
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 0 0
+STARTCHAR uni1489
+ENCODING 5257
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-400000
-E00000
-400000
-000000
-400180
-400600
-601800
-106000
-088000
-090000
-008000
-086000
-1C1800
-080600
-000180
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5389
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 15 0 0
-BITMAP
-4000
-E000
-4000
-0000
-403E
-4040
-6080
-1100
-0900
-0900
-0100
-0900
-1C80
-0840
-003E
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5390
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 15 0 0
-BITMAP
-4000
-E000
-4000
-0000
-4100
-4100
-6100
-1100
-0900
-09F0
-0108
-0908
-1D08
-0908
-00F0
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5391
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 15 0 0
-BITMAP
-4000
-E000
-4000
-0000
-4100
-4100
-6100
-1100
-0900
-0900
-0100
-0900
-1D08
-0908
-00F0
-ENDCHAR
-STARTCHAR char5383
-ENCODING 5392
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 9 6 1 0
-BITMAP
-7080
-8880
-8880
-8880
-8880
-8700
-ENDCHAR
-STARTCHAR char5383
-ENCODING 5393
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 9 6 1 0
-BITMAP
-8700
-8880
-8880
-8880
-8880
-7080
-ENDCHAR
-STARTCHAR char5383
-ENCODING 5394
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 9 10 1 0
-BITMAP
-0800
-1C00
-0800
-0000
-8700
-8880
-8880
-8880
-8880
-7080
-ENDCHAR
-STARTCHAR char5383
-ENCODING 5395
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
-BITMAP
-F0
-08
-08
-08
-08
-70
-80
-80
-80
-80
 78
+84
+84
+04
+04
+04
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5396
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 0
+STARTCHAR uni148A
+ENCODING 5258
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
 20
-70
+50
 20
 00
-F0
-08
-08
-08
-08
-70
+78
+84
+84
 80
 80
 80
 80
-78
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5397
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
+STARTCHAR uni148B
+ENCODING 5259
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
 78
+84
+84
 80
 80
 80
 80
-70
-08
-08
-08
-08
-F0
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5398
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 0
+STARTCHAR uni148C
+ENCODING 5260
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
 20
 70
 20
 00
 78
+84
+84
 80
 80
 80
 80
-70
-08
-08
-08
-08
-F0
-ENDCHAR
-STARTCHAR char5383
-ENCODING 5399
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 7 1 0
-BITMAP
-4000
-E708
-4888
-0888
-0888
-0888
-0870
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5400
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 7 1 0
+STARTCHAR uni148D
+ENCODING 5261
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-0010
-70B8
-8890
-8880
-8880
-8880
-8700
+04
+04
+04
+04
+04
+04
+04
+04
+84
+84
+78
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5401
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 13 7 1 0
+STARTCHAR uni148E
+ENCODING 5262
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 15 1 0
 BITMAP
-4000
-E870
-4888
-0888
-0888
-0888
-0708
+04
+0E
+04
+00
+04
+04
+04
+04
+04
+04
+04
+04
+84
+84
+78
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5402
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 13 7 1 0
+STARTCHAR uni148F
+ENCODING 5263
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
-0010
-8738
-8890
-8880
-8880
-8880
-7080
+1100
+3B80
+1100
+0000
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5403
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 13 10 1 0
+STARTCHAR uni1490
+ENCODING 5264
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-0080
-01C0
-0080
-4000
-E870
-4888
-0888
-0888
-0888
-0708
+80
+80
+80
+80
+80
+80
+80
+80
+84
+84
+78
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5404
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 13 10 1 0
+STARTCHAR uni1491
+ENCODING 5265
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 15 0 0
 BITMAP
-0800
-1C00
-0800
-0010
-8738
-8890
-8880
-8880
-8880
-7080
+40
+E0
+40
+00
+40
+40
+40
+40
+40
+40
+40
+40
+42
+42
+3C
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5405
+STARTCHAR uni1492
+ENCODING 5266
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
 0F00
+1080
+1080
+0080
+4080
+E080
+4080
 0080
 0080
 0080
-4080
-E700
+0080
+ENDCHAR
+STARTCHAR uni1493
+ENCODING 5267
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+7800
+8400
+8400
+0400
+0480
+05C0
+0480
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni1494
+ENCODING 5268
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0780
+0840
+0840
+0800
+4800
+E800
 4800
 0800
 0800
 0800
-0780
+0800
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5406
+STARTCHAR uni1495
+ENCODING 5269
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-F000
-0800
-0800
-0800
-0900
-7380
+7800
+8400
+8400
+8000
+8100
+8380
 8100
 8000
 8000
 8000
-7800
+8000
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5407
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
+STARTCHAR uni1496
+ENCODING 5270
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
 0200
 0700
 0200
 0000
-0F00
-0080
-0080
-0080
-4080
-E700
+0780
+0840
+0840
+0800
+4800
+E800
 4800
 0800
 0800
 0800
-0780
+0800
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5408
+STARTCHAR uni1497
+ENCODING 5271
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 15 1 0
@@ -44766,194 +48046,304 @@
 7000
 2000
 0000
-F000
-0800
-0800
-0800
-0900
-7380
+7800
+8400
+8400
+8000
+8100
+8380
 8100
 8000
 8000
 8000
-7800
+8000
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5409
+STARTCHAR uni1498
+ENCODING 5272
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-0780
-0800
-0800
-0800
-4800
-E700
-4080
 0080
 0080
 0080
+0080
+4080
+E080
+4080
+0080
+1080
+1080
 0F00
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5410
+STARTCHAR uni1499
+ENCODING 5273
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0400
+0400
+0400
+0400
+0480
+05C0
+0480
+0400
+8400
+8400
+7800
+ENDCHAR
+STARTCHAR uni149A
+ENCODING 5274
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 11 1 0
+BBX 10 15 1 0
+BITMAP
+0080
+01C0
+0080
+0000
+0080
+0080
+0080
+0080
+4080
+E080
+4080
+0080
+1080
+1080
+0F00
+ENDCHAR
+STARTCHAR uni149B
+ENCODING 5275
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
+0400
+0E00
+0400
+0000
+0400
+0400
+0400
+0400
+0480
+05C0
+0480
+0400
+8400
+8400
 7800
-8000
-8000
-8000
-8100
-7380
-0900
+ENDCHAR
+STARTCHAR uni149C
+ENCODING 5276
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
 0800
 0800
 0800
-F000
+0800
+4800
+E800
+4800
+0800
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5411
+STARTCHAR uni149D
+ENCODING 5277
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 15 1 0
+BBX 9 11 1 0
 BITMAP
-0200
-0700
-0200
+8000
+8000
+8000
+8000
+8100
+8380
+8100
+8000
+8400
+8400
+7800
+ENDCHAR
+STARTCHAR uni149E
+ENCODING 5278
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0800
+1C00
+0800
 0000
-0780
 0800
 0800
 0800
+0800
 4800
-E700
-4080
-0080
-0080
-0080
-0F00
+E800
+4800
+0800
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR char5383
-ENCODING 5412
+STARTCHAR uni149F
+ENCODING 5279
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 15 1 0
+BBX 10 15 0 0
 BITMAP
-2000
-7000
-2000
+4000
+E000
+4000
 0000
-7800
-8000
-8000
-8000
-8100
-7380
-0900
+4000
+4000
+4000
+4000
+4080
+41C0
+4080
+4000
+4200
+4200
+3C00
+ENDCHAR
+STARTCHAR uni14A0
+ENCODING 5280
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
 0800
 0800
+4800
+E800
+4800
 0800
-F000
+4800
+E800
+4840
+0840
+0780
 ENDCHAR
-STARTCHAR char5382
-ENCODING 5413
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 4
+STARTCHAR uni14A1
+ENCODING 5281
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 5
 BITMAP
-70
 80
 80
+80
+90
+90
 60
+ENDCHAR
+STARTCHAR uni14A2
+ENCODING 5282
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 5
+BITMAP
 10
 10
-E0
+10
+90
+90
+60
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5414
+STARTCHAR uni14A3
+ENCODING 5283
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
 BITMAP
-08
-10
-20
-40
-80
 FC
 04
 04
 04
 04
 04
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5415
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 15 0 0
+STARTCHAR uni14A4
+ENCODING 5284
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
-40
-A0
-40
-00
 20
-10
-08
-04
-02
-7E
-40
-40
-40
-40
-40
+50
+20
+00
+FC
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5416
-SWIDTH 480 0
-DWIDTH 8 0
+STARTCHAR uni14A5
+ENCODING 5285
+SWIDTH 420 0
+DWIDTH 7 0
 BBX 6 11 1 0
 BITMAP
-40
-20
-10
-08
-04
 FC
 80
 80
 80
 80
 80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5417
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 15 0 0
+STARTCHAR uni14A6
+ENCODING 5286
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
-40
-E0
-40
-00
 20
-10
-08
-04
-02
-7E
-40
-40
-40
-40
-40
+70
+20
+00
+FC
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5418
+STARTCHAR uni14A7
+ENCODING 5287
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
@@ -44963,15 +48353,15 @@
 04
 04
 04
+04
+04
+04
+04
+04
 FC
-80
-40
-20
-10
-08
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5419
+STARTCHAR uni14A8
+ENCODING 5288
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 7 15 1 0
@@ -44985,15 +48375,15 @@
 04
 04
 04
+04
+04
+04
+04
+04
 FC
-80
-40
-20
-10
-08
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5420
+STARTCHAR uni14A9
+ENCODING 5289
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 15 1 0
@@ -45007,17 +48397,17 @@
 0400
 0400
 0400
+0400
+0400
+0400
+0400
+0400
 FC00
-8000
-4000
-2000
-1000
-0800
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5421
-SWIDTH 480 0
-DWIDTH 8 0
+STARTCHAR uni14AA
+ENCODING 5290
+SWIDTH 420 0
+DWIDTH 7 0
 BBX 6 11 1 0
 BITMAP
 80
@@ -45025,15 +48415,15 @@
 80
 80
 80
+80
+80
+80
+80
+80
 FC
-04
-08
-10
-20
-40
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5422
+STARTCHAR uni14AB
+ENCODING 5291
 SWIDTH 420 0
 DWIDTH 7 0
 BBX 7 15 0 0
@@ -45047,149 +48437,149 @@
 40
 40
 40
+40
+40
+40
+40
+40
 7E
-02
-04
-08
-10
-20
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5423
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni14AC
+ENCODING 5292
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
+1F80
 0080
-0100
-0200
-0400
-4800
-EFC0
-4040
-0040
-0040
-0040
-0040
+0080
+0080
+4080
+E080
+4080
+0080
+0080
+0080
+0080
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5424
+STARTCHAR uni14AD
+ENCODING 5293
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
 BITMAP
-0800
-1000
-2000
-4000
-8080
-FDC0
+FC00
+0400
+0400
+0400
+0480
+05C0
 0480
 0400
 0400
 0400
 0400
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5425
+STARTCHAR uni14AE
+ENCODING 5294
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
 BITMAP
-0400
-0200
-0100
-0080
-4040
-EFC0
+0FC0
+0800
+0800
+0800
+4800
+E800
 4800
 0800
 0800
 0800
 0800
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5426
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni14AF
+ENCODING 5295
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-4000
-2000
-1000
-0800
-0480
-FDC0
-8080
+FC00
+8000
 8000
 8000
+8100
+8380
+8100
+8000
 8000
 8000
+8000
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5427
+STARTCHAR uni14B0
+ENCODING 5296
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 15 1 0
 BITMAP
+0200
+0700
+0200
+0000
+0FC0
 0800
-1C00
 0800
-0000
-0400
-0200
-0100
-0080
-4040
-EFC0
+0800
+4800
+E800
 4800
 0800
 0800
 0800
 0800
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5428
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 15 0 0
+STARTCHAR uni14B1
+ENCODING 5297
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
-4000
-E000
-4000
-0000
 2000
-1000
-0800
-0400
-0240
-7EE0
-4040
-4000
-4000
-4000
-4000
+7000
+2000
+0000
+FC00
+8000
+8000
+8000
+8100
+8380
+8100
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5429
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni14B2
+ENCODING 5298
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-0040
-0040
-0040
-0040
-4040
-EFC0
-4800
-0400
-0200
-0100
 0080
+0080
+0080
+0080
+4080
+E080
+4080
+0080
+0080
+0080
+1F80
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5430
+STARTCHAR uni14B3
+ENCODING 5299
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
@@ -45199,59 +48589,59 @@
 0400
 0400
 0480
-FDC0
-8080
-4000
-2000
-1000
-0800
-ENDCHAR
-STARTCHAR 00F7
-ENCODING 5431
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
-BITMAP
-0040
-00E0
-0040
-0000
-0040
-0040
-0040
-0040
-4040
-EFC0
-4800
+05C0
+0480
 0400
-0200
-0100
-0080
+0400
+0400
+FC00
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5432
-SWIDTH 660 0
-DWIDTH 11 0
+STARTCHAR uni14B4
+ENCODING 5300
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 10 15 1 0
 BITMAP
-0400
-0E00
-0400
+0080
+01C0
+0080
 0000
-0400
-0400
-0400
-0400
+0080
+0080
+0080
+0080
+4080
+E080
+4080
+0080
+0080
+0080
+1F80
+ENDCHAR
+STARTCHAR uni14B5
+ENCODING 5301
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0400
+0E00
+0400
+0000
+0400
+0400
+0400
+0400
 0480
-FDC0
-8080
-4000
-2000
-1000
-0800
+05C0
+0480
+0400
+0400
+0400
+FC00
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5433
+STARTCHAR uni14B6
+ENCODING 5302
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
@@ -45261,33 +48651,33 @@
 0800
 0800
 4800
-EFC0
-4040
-0080
-0100
-0200
-0400
+E800
+4800
+0800
+0800
+0800
+0FC0
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5434
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni14B7
+ENCODING 5303
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
 8000
 8000
 8000
 8000
-8080
-FDC0
-0480
-0800
-1000
-2000
-4000
+8100
+8380
+8100
+8000
+8000
+8000
+FC00
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5435
+STARTCHAR uni14B8
+ENCODING 5304
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 15 1 0
@@ -45301,18 +48691,18 @@
 0800
 0800
 4800
-EFC0
-4040
-0080
-0100
-0200
-0400
+E800
+4800
+0800
+0800
+0800
+0FC0
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5436
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 15 0 0
+STARTCHAR uni14B9
+ENCODING 5305
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 15 0 0
 BITMAP
 4000
 E000
@@ -45322,16 +48712,16 @@
 4000
 4000
 4000
-4040
-7EE0
-0240
-0400
-0800
-1000
-2000
+4080
+41C0
+4080
+4000
+4000
+4000
+7E00
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5437
+STARTCHAR uni14BA
+ENCODING 5306
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 10 11 1 0
@@ -45341,1898 +48731,1815 @@
 4800
 E800
 4800
+0800
+4800
+E800
+4800
+0800
 0FC0
-4040
-E080
-4100
-0200
-0400
 ENDCHAR
-STARTCHAR char5438
-ENCODING 5438
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 6 1 5
+STARTCHAR uni14BB
+ENCODING 5307
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 5
 BITMAP
 80
 80
-E0
-20
-40
 80
+80
+80
+F0
 ENDCHAR
-STARTCHAR char5355
-ENCODING 5439
+STARTCHAR uni14BC
+ENCODING 5308
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 7 4 1 7
+BBX 4 6 1 5
 BITMAP
-6C
-6C
-92
-92
+70
+80
+80
+80
+80
+70
 ENDCHAR
-STARTCHAR char5161
-ENCODING 5440
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 5 1 6
+STARTCHAR uni14BD
+ENCODING 5309
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 5
 BITMAP
-20
-20
-F8
-20
+10
+10
+10
+10
+10
+F0
+ENDCHAR
+STARTCHAR uni14BE
+ENCODING 5310
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 5
+BITMAP
+60
+90
+10
 20
+40
+F0
 ENDCHAR
-STARTCHAR char5441
-ENCODING 5441
+STARTCHAR uni14BF
+ENCODING 5311
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 6 6 1 5
-BITMAP
-84
-48
-30
-30
-48
-84
-ENDCHAR
-STARTCHAR 0045
-ENCODING 5442
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 6 1 0
-BITMAP
-83C0
-8200
-8200
-8200
-4400
-3800
-ENDCHAR
-STARTCHAR 0045
-ENCODING 5443
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 6 1 0
+BBX 7 11 1 0
 BITMAP
-F040
-1040
-1040
-1040
-0880
-0700
+38
+44
+82
+02
+02
+04
+08
+10
+20
+42
+FE
 ENDCHAR
-STARTCHAR 0045
-ENCODING 5444
-SWIDTH 720 0
-DWIDTH 12 0
+STARTCHAR uni14C0
+ENCODING 5312
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 10 6 1 0
 BITMAP
-0700
-0880
-1040
-1040
-1040
-F040
+FF80
+0840
+0840
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR 0045
-ENCODING 5445
-SWIDTH 720 0
-DWIDTH 12 0
+STARTCHAR uni14C1
+ENCODING 5313
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 10 10 1 0
 BITMAP
 1000
 2800
 1000
 0000
-3800
-4400
-8200
-8200
-8200
-83C0
+7FC0
+8400
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 0045
-ENCODING 5446
-SWIDTH 720 0
-DWIDTH 12 0
+STARTCHAR uni14C2
+ENCODING 5314
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 10 6 1 0
 BITMAP
-3800
-4400
-8200
-8200
-8200
-83C0
+7FC0
+8400
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 0045
-ENCODING 5447
-SWIDTH 720 0
-DWIDTH 12 0
+STARTCHAR uni14C3
+ENCODING 5315
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 10 10 1 0
 BITMAP
 1000
 3800
 1000
 0000
-3800
-4400
-8200
-8200
-8200
-83C0
-ENDCHAR
-STARTCHAR 0044
-ENCODING 5448
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
-BITMAP
-F0
-08
-04
-04
-04
-08
-F0
-80
-80
-80
-80
-ENDCHAR
-STARTCHAR 0044
-ENCODING 5449
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 15 1 0
-BITMAP
-20
-70
-20
-00
-F0
-08
-04
-04
-04
-08
-F0
-80
-80
-80
-80
-ENDCHAR
-STARTCHAR 0044
-ENCODING 5450
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
-BITMAP
-80
-80
-80
-80
-F0
-08
-04
-04
-04
-08
-F0
+7FC0
+8400
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5451
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR uni14C4
+ENCODING 5316
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 6 1 0
 BITMAP
-3C
-40
-80
-80
-80
-40
-3C
-04
-04
-04
-04
+0780
+0840
+0840
+0840
+0840
+FF80
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5452
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 15 1 0
+STARTCHAR uni14C5
+ENCODING 5317
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 10 1 0
 BITMAP
-10
-38
-10
-00
-3C
-40
-80
-80
-80
-40
-3C
-04
-04
-04
-04
+0200
+0700
+0200
+0000
+0780
+0840
+0840
+0840
+0840
+FF80
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5453
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR uni14C6
+ENCODING 5318
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 10 1 0
 BITMAP
-04
-04
-04
-04
-3C
-40
-80
-80
-80
-40
-3C
+0880
+1DC0
+0880
+0000
+0780
+0840
+0840
+0840
+0840
+FF80
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5454
+STARTCHAR uni14C7
+ENCODING 5319
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 6 1 0
 BITMAP
-0100
-0380
-0100
-0000
-03C0
-0400
-0800
-0800
-4800
-E400
-43C0
-0040
-0040
-0040
-0040
+7800
+8400
+8400
+8400
+8400
+7FC0
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5455
+STARTCHAR uni14C8
+ENCODING 5320
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 10 1 0
 BITMAP
 1000
 3800
 1000
 0000
-3C00
+7800
+8400
+8400
+8400
+8400
+7FC0
+ENDCHAR
+STARTCHAR uni14C9
+ENCODING 5321
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
+BITMAP
 4000
-8000
-8000
-8080
-41C0
-3C80
-0400
-0400
-0400
-0400
+EFF8
+4084
+0084
+0084
+0084
+0078
 ENDCHAR
-STARTCHAR char5456
-ENCODING 5456
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 6 1 5
+STARTCHAR uni14CA
+ENCODING 5322
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
 BITMAP
-60
-80
-80
-60
-20
-20
+0008
+FF9C
+0848
+0840
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR char5355
-ENCODING 5457
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 4
+STARTCHAR uni14CB
+ENCODING 5323
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
 BITMAP
-C0
-30
-30
-C0
-30
-30
-C0
+4000
+E780
+4840
+0840
+0840
+0840
+07FC
 ENDCHAR
-STARTCHAR C087
-ENCODING 5458
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni14CC
+ENCODING 5324
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
 BITMAP
-E000
-1C00
-0380
-0700
-1800
-E000
-1800
-0700
+0040
+78E0
+8440
+8400
+8400
+8400
+7FC0
+ENDCHAR
+STARTCHAR uni14CD
+ENCODING 5325
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
+BITMAP
+0100
 0380
-1C00
-E000
+0100
+4000
+E780
+4840
+0840
+0840
+0840
+07FC
 ENDCHAR
-STARTCHAR 0046
-ENCODING 5459
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni14CE
+ENCODING 5326
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 10 1 0
 BITMAP
-6000
-9080
-9080
-E100
-4100
-6200
-2200
-1400
-1400
-0800
-0800
+1000
+3800
+1000
+0040
+78E0
+8440
+8400
+8400
+8400
+7FC0
 ENDCHAR
-STARTCHAR 0046
-ENCODING 5460
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
+STARTCHAR uni14CF
+ENCODING 5327
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 10 1 0
 BITMAP
-0800
-1400
-0800
+4400
+EE00
+4400
 0000
-0800
-0800
-1400
-1400
-2200
-2200
-4100
-E100
-9080
-9080
-6000
+7800
+8400
+8400
+8400
+8400
+7FC0
 ENDCHAR
-STARTCHAR 0046
-ENCODING 5461
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni14D0
+ENCODING 5328
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 4 1 7
 BITMAP
-0800
-0800
-1400
-1400
-2200
-2200
-4100
-E100
-9080
-9080
-6000
+60
+90
+90
+7C
 ENDCHAR
-STARTCHAR 0046
-ENCODING 5462
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
+STARTCHAR uni14D1
+ENCODING 5329
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 6 1 5
 BITMAP
-0800
-1C00
-0800
-0000
-0800
-0800
-1400
-1400
-2200
-2200
-4100
-E100
-9080
-9080
-6000
+84
+84
+84
+84
+84
+78
 ENDCHAR
-STARTCHAR C065
-ENCODING 5463
+STARTCHAR uni14D2
+ENCODING 5330
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 4 1 7
+BITMAP
+18
+24
+24
+F8
+ENDCHAR
+STARTCHAR uni14D3
+ENCODING 5331
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 10 1 0
+BBX 10 6 1 0
 BITMAP
-7000
-9C00
-9300
-6080
+FF80
 0040
-0080
-0300
-0C00
-3000
-C000
+0040
+0040
+0040
+0380
 ENDCHAR
-STARTCHAR C065
-ENCODING 5464
+STARTCHAR uni14D4
+ENCODING 5332
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 10 1 0
 BITMAP
-0400
-0E00
-0400
-0000
+1000
+2800
+1000
 0000
+7FC0
+8000
+8000
+8000
+8000
 7000
-9C00
-9300
-6080
-0040
-0080
-0300
-0C00
-3000
-C000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5465
+STARTCHAR uni14D5
+ENCODING 5333
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 10 1 0
+BBX 10 6 1 0
 BITMAP
-0380
-0E40
-3240
-4180
+7FC0
 8000
-4000
-3000
-0C00
-0300
-00C0
+8000
+8000
+8000
+7000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5466
+STARTCHAR uni14D6
+ENCODING 5334
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 1 0
+BBX 10 10 1 0
 BITMAP
-0400
-0E00
-0400
-0000
+1000
+3800
+1000
 0000
-0380
-0E40
-3240
-4180
+7FC0
 8000
-4000
-3000
-0C00
-0300
-00C0
+8000
+8000
+8000
+7000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5467
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR uni14D7
+ENCODING 5335
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 0
 BITMAP
+0380
 0040
-00E0
 0040
-0000
-0000
-0038
-00E4
-0324
-4418
-E800
-4400
-0300
-00C0
-0030
-000C
+0040
+0040
+FF80
 ENDCHAR
-STARTCHAR C065
-ENCODING 5468
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 15 1 0
+STARTCHAR uni14D8
+ENCODING 5336
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 10 1 0
 BITMAP
-0400
-0E00
-0400
-0000
+0200
+0700
+0200
 0000
 0380
-0E40
-3240
-4188
-801C
-4008
-3000
-0C00
-0300
-00C0
+0040
+0040
+0040
+0040
+FF80
 ENDCHAR
-STARTCHAR char5150
-ENCODING 5469
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 5
+STARTCHAR uni14D9
+ENCODING 5337
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 10 1 0
 BITMAP
-08
-34
-C8
-60
-18
-04
+0880
+1DC0
+0880
+0000
+0380
+0040
+0040
+0040
+0040
+FF80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5470
+STARTCHAR uni14DA
+ENCODING 5338
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 10 6 1 0
 BITMAP
-6080
-9080
-9080
-E080
-8080
-8080
-8080
-8080
-8080
-4100
-3E00
+7000
+8000
+8000
+8000
+8000
+7FC0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5471
+STARTCHAR uni14DB
+ENCODING 5339
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 10 10 1 0
 BITMAP
-8300
-8480
-8480
-8380
-8080
-8080
-8080
-8080
-8080
-4100
-3E00
+1000
+3800
+1000
+0000
+7000
+8000
+8000
+8000
+8000
+7FC0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5472
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni14DC
+ENCODING 5340
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-E080
-9080
-9080
-6080
+4000
+EFF8
+4004
+0004
+0004
+0004
+0038
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5473
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni14DD
+ENCODING 5341
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-8380
-8480
-8480
-8300
+0008
+FF9C
+0048
+0040
+0040
+0040
+0380
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5474
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 15 1 0
+STARTCHAR uni14DE
+ENCODING 5342
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
 BITMAP
+4000
+E7FC
+4800
 0800
-1C00
 0800
-0000
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-E080
-9080
-9080
-6080
+0800
+0700
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5475
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 15 1 0
+STARTCHAR uni14DF
+ENCODING 5343
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
+BITMAP
+0008
+7FDC
+8008
+8000
+8000
+8000
+7000
+ENDCHAR
+STARTCHAR uni14E0
+ENCODING 5344
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
 BITMAP
+0100
+0380
+0100
+4000
+E7FC
+4800
 0800
-1C00
 0800
-0000
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-8380
-8480
-8480
-8300
+0800
+0700
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5476
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni14E1
+ENCODING 5345
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
 BITMAP
-78
-94
-92
-61
-01
-01
-01
-01
-02
-04
-F8
+1000
+3800
+1000
+0008
+7FDC
+8008
+8000
+8000
+8000
+7000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5477
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR uni14E2
+ENCODING 5346
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
 BITMAP
-10
-38
-10
-00
-78
-94
-92
-61
-01
-01
-01
-01
-02
-04
-F8
+4000
+E038
+4004
+0004
+0004
+0004
+0FF8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5478
+STARTCHAR uni14E3
+ENCODING 5347
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
+BITMAP
+0008
+039C
+0048
+0040
+0040
+0040
+FF80
+ENDCHAR
+STARTCHAR uni14E4
+ENCODING 5348
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
+BITMAP
+0020
+0070
+0020
+4000
+E038
+4004
+0004
+0004
+0004
+0FF8
+ENDCHAR
+STARTCHAR uni14E5
+ENCODING 5349
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
+BITMAP
+0200
+0700
+0200
+0008
+039C
+0048
+0040
+0040
+0040
+FF80
+ENDCHAR
+STARTCHAR uni14E6
+ENCODING 5350
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
+BITMAP
+4000
+E700
+4800
+0800
+0800
+0800
+07FC
+ENDCHAR
+STARTCHAR uni14E7
+ENCODING 5351
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 7 1 0
+BITMAP
+0008
+701C
+8008
+8000
+8000
+8000
+7FC0
+ENDCHAR
+STARTCHAR uni14E8
+ENCODING 5352
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
+BITMAP
+0100
+0380
+0100
+4000
+E700
+4800
+0800
+0800
+0800
+07FC
+ENDCHAR
+STARTCHAR uni14E9
+ENCODING 5353
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
+BITMAP
+1000
+3800
+1000
+0008
+701C
+8008
+8000
+8000
+8000
+7FC0
+ENDCHAR
+STARTCHAR uni14EA
+ENCODING 5354
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 4 1 7
+BITMAP
+60
+80
+80
+7C
+ENDCHAR
+STARTCHAR uni14EB
+ENCODING 5355
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 4
+BITMAP
+30
+C0
+C0
+30
+C0
+C0
+30
+ENDCHAR
+STARTCHAR uni14EC
+ENCODING 5356
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+0380
+1C00
+E000
+7000
+0C00
+0380
+0C00
+7000
+E000
+1C00
+0380
+ENDCHAR
+STARTCHAR uni14ED
+ENCODING 5357
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 7 11 1 0
 BITMAP
-1E
-29
-49
-86
 80
 80
 80
 80
 40
 20
-1F
+1E
+02
+02
+02
+02
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5479
+STARTCHAR uni14EE
+ENCODING 5358
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 15 1 0
 BITMAP
-08
-1C
-08
+02
+05
+02
 00
-1E
-29
-49
-86
+02
+02
+02
+02
+04
+08
+F0
 80
 80
 80
 80
-40
-20
-1F
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5480
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 15 1 0
-BITMAP
-0080
-01C0
-0080
-0000
-01E0
-0290
-0490
-0860
-4800
-E800
-4800
-0800
-0400
-0200
-01F0
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5481
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
-BITMAP
-0800
-1C00
-0800
-0000
-1E00
-2900
-4900
-8600
-8040
-80E0
-8040
-8000
-4000
-2000
-1F00
 ENDCHAR
-STARTCHAR char5153
-ENCODING 5482
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 6 1 5
+STARTCHAR uni14EF
+ENCODING 5359
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 11 1 0
 BITMAP
-70
-A8
-90
+02
+02
+02
+02
+04
+08
+F0
 80
 80
-70
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5483
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
-BITMAP
-8880
-8880
-8880
-8880
-8880
-8080
-8080
-8080
-8080
-4100
-3E00
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5484
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
-BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-8880
-8880
-8880
-8880
-8880
+80
+80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5485
+STARTCHAR uni14F0
+ENCODING 5360
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 8 15 1 0
 BITMAP
-F8
-04
 02
-01
-01
-F1
-01
-01
+07
+02
+00
+02
+02
 02
+02
 04
-F8
+08
+F0
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5486
+STARTCHAR uni14F1
+ENCODING 5361
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 7 11 1 0
 BITMAP
-1F
+02
+02
+02
+02
+1E
 20
 40
 80
 80
-8F
 80
 80
-40
-20
-1F
-ENDCHAR
-STARTCHAR char5487
-ENCODING 5487
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 12 5 1 4
-BITMAP
-2040
-A950
-70E0
-A950
-2040
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5488
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni14F2
+ENCODING 5362
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-A280
-A280
-A280
-A280
-A280
-9C80
-8080
-8080
-8080
-4100
-3E00
+02
+07
+02
+00
+02
+02
+02
+02
+1E
+20
+40
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5489
+STARTCHAR uni14F3
+ENCODING 5363
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 10 15 1 0
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-9C80
-A280
-A280
-A280
-A280
-A280
+0880
+1DC0
+0880
+0000
+0200
+0200
+0200
+0200
+1E00
+2000
+4000
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5490
+STARTCHAR uni14F4
+ENCODING 5364
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 7 11 1 0
 BITMAP
-F8
+80
+80
+80
+80
+F0
+08
 04
 02
-E1
-11
-11
-11
-E1
 02
-04
-F8
+02
+02
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5491
+STARTCHAR uni14F5
+ENCODING 5365
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 8 15 0 0
 BITMAP
-1F
-20
 40
-87
-88
-88
-88
-87
+E0
 40
-20
-1F
+00
+40
+40
+40
+40
+78
+04
+02
+01
+01
+01
+01
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5492
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni14F6
+ENCODING 5366
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-7800
-8400
-8400
-8400
-8400
-7C00
-0400
-0480
-0500
-0600
-0400
+0800
+0800
+0800
+4800
+E400
+4200
+01E0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5493
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni14F7
+ENCODING 5367
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-0F00
-1080
-1080
-1080
-1080
-1F00
-1000
-9000
-5000
-3000
-1000
+8000
+8000
+8000
+8040
+40E0
+2040
+1E00
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5494
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
+STARTCHAR uni14F8
+ENCODING 5368
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-0400
-0E00
-0400
-0000
+0020
+0020
+0020
+4020
+E040
+4080
 0F00
-1080
-1080
-1080
-1080
-1F00
-1000
-9000
-5000
-3000
-1000
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5495
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
-BITMAP
-0400
-0600
-0500
-0480
-0400
-7C00
-8400
-8400
-8400
-8400
-7800
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5496
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
-BITMAP
-0400
-0E00
-0400
-0000
-0400
-0600
-0500
-0480
-0400
-7C00
-8400
-8400
-8400
-8400
-7800
+0800
+0800
+0800
+0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5497
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni14F9
+ENCODING 5369
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-1000
-3000
-5000
-9000
-1000
-1F00
-1080
-1080
-1080
-1080
-0F00
+0200
+0200
+0200
+0240
+04E0
+0840
+F000
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5498
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 0
+STARTCHAR uni14FA
+ENCODING 5370
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 15 1 0
 BITMAP
-1000
-3800
-1000
+0020
+0070
+0020
 0000
-1000
-3000
-5000
-9000
-1000
-1F00
-1080
-1080
-1080
-1080
+0020
+0020
+0020
+4020
+E040
+4080
 0F00
-ENDCHAR
-STARTCHAR char5251
-ENCODING 5499
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 5
-BITMAP
-20
-60
-B8
-24
-24
-38
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5500
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
-BITMAP
-8080
-8080
-8080
-8080
-8080
-FF80
-8080
-8080
-8080
-8080
-8080
-ENDCHAR
-STARTCHAR char5441
-ENCODING 5501
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 6 1 5
-BITMAP
-84
-48
-30
-30
-48
-84
+0800
+0800
+0800
+0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5502
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR uni14FB
+ENCODING 5371
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
 0200
-0500
+0700
 0200
 0000
-6780
-8840
-8840
-6840
-2840
-2F80
-0800
+0200
+0200
+0200
+0240
+04E0
+0840
+F000
+8000
+8000
+8000
+8000
+ENDCHAR
+STARTCHAR uni14FC
+ENCODING 5372
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+0020
+0020
+0020
+0020
+41E0
+E200
+4400
 0800
 0800
 0800
 0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5503
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni14FD
+ENCODING 5373
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-6780
-8840
-8840
-6840
-2840
-2F80
-0800
+0200
+0200
+0200
+0200
+1E40
+20E0
+4040
+8000
+8000
+8000
+8000
+ENDCHAR
+STARTCHAR uni14FE
+ENCODING 5374
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 15 1 0
+BITMAP
+0020
+0070
+0020
+0000
+0020
+0020
+0020
+0020
+41E0
+E200
+4400
 0800
 0800
 0800
 0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5504
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 0
+STARTCHAR uni14FF
+ENCODING 5375
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
 0200
 0700
 0200
 0000
-6780
-8840
-8840
-6840
-2840
-2F80
-0800
-0800
-0800
-0800
-0800
+0200
+0200
+0200
+0200
+1E40
+20E0
+4040
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5505
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni1500
+ENCODING 5376
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 11 1 0
 BITMAP
-6040
-8040
-8040
-6040
-2040
-27C0
-0840
-0840
-0840
-0840
-0780
+0400
+0400
+0400
+0400
+4780
+E040
+4020
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5506
+STARTCHAR uni1501
+ENCODING 5377
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 15 1 0
+BBX 11 11 1 0
 BITMAP
-0040
-00E0
-0040
-0000
-6040
-8040
-8040
-6040
-2040
-27C0
-0840
-0840
-0840
-0840
-0780
+8000
+8000
+8000
+8000
+F040
+08E0
+0440
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5507
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni1502
+ENCODING 5378
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 15 1 0
 BITMAP
-6800
-8800
-8800
-6800
-2800
-2F80
-0840
-0840
-0840
-0840
-0780
+0020
+0070
+0020
+0000
+0800
+0800
+0800
+0800
+4F00
+E080
+4040
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5508
+STARTCHAR uni1503
+ENCODING 5379
 SWIDTH 720 0
 DWIDTH 12 0
 BBX 11 15 1 0
 BITMAP
-0040
-00E0
-0040
+0200
+0700
+0200
 0000
-6800
-8800
-8800
-6800
-2800
-2F80
-0840
-0840
-0840
-0840
-0780
+8000
+8000
+8000
+8000
+F040
+08E0
+0440
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5509
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 6 1 5
+STARTCHAR uni1504
+ENCODING 5380
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-68
-88
-8E
-69
-29
-2E
+0800
+0800
+4800
+E800
+4F00
+0080
+4040
+E020
+4020
+0020
+0020
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5510
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1505
+ENCODING 5381
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 5
 BITMAP
-1E
-21
-21
-21
-21
-1F
-09
-11
-21
-41
-81
+80
+80
+C0
+20
+10
+10
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5511
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
-BITMAP
-78
-84
-84
-84
-84
-F8
-90
-88
-84
-82
-81
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5512
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
-BITMAP
-81
-41
-21
-11
-09
-1F
-21
-21
-21
-21
-1E
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5513
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1506
+ENCODING 5382
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 7 1 4
 BITMAP
-81
-82
-84
+70
 88
-90
-F8
-84
-84
-84
-84
-78
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5514
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
-BITMAP
-7800
-8400
-8400
-0400
-0400
-0400
-0400
-0580
-0600
-0400
-0400
+80
+70
+08
+88
+70
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5515
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni1507
+ENCODING 5383
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 5
 BITMAP
-0F00
-1080
-1080
-1000
-1000
-1000
-1000
-D000
-3000
-1000
-1000
+10
+10
+30
+40
+80
+80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5516
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni1508
+ENCODING 5384
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 6
 BITMAP
-0400
-0400
-0600
-0580
-0400
-0400
-0400
-0400
-8400
-8400
-7800
+80
+80
+80
+40
+38
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5517
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni1509
+ENCODING 5385
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 8 1 3
 BITMAP
-1000
-1000
-3000
-D000
-1000
-1000
-1000
-1000
-1080
-1080
-0F00
+80
+80
+C0
+20
+10
+30
+50
+20
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5518
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 0
+STARTCHAR uni150A
+ENCODING 5386
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 8 1 3
 BITMAP
-000400
-000A00
-000400
-000000
-600F00
-901080
-901080
-7C1000
-041000
-049000
-049000
-031000
-001000
-001000
-001000
+10
+10
+30
+40
+80
+C0
+A0
+40
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5519
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 11 1 0
+STARTCHAR uni150B
+ENCODING 5387
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 14 0 1
 BITMAP
-600F00
-901080
-901080
-7C1000
-041000
-049000
-049000
-031000
-001000
-001000
-001000
+40
+E0
+40
+00
+40
+40
+60
+10
+08
+08
+00
+08
+1C
+08
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5520
+STARTCHAR uni150C
+ENCODING 5388
 SWIDTH 1080 0
 DWIDTH 18 0
-BBX 17 15 1 0
+BBX 17 15 0 0
 BITMAP
-000400
-000E00
-000400
+400000
+E00000
+400000
 000000
-600F00
-901080
-901080
-7C1000
-041000
-049000
-049000
-031000
-001000
-001000
-001000
+400180
+400600
+601800
+106000
+088000
+090000
+008000
+086000
+1C1800
+080600
+000180
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5521
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 11 1 0
+STARTCHAR uni150D
+ENCODING 5389
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 15 0 0
 BITMAP
-600080
-900080
-900080
-7C0080
-040080
-048080
-048080
-030080
-001080
-001080
-000F00
+4000
+E000
+4000
+0000
+403E
+4040
+6080
+1100
+0900
+0900
+0100
+0900
+1C80
+0840
+003E
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5522
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 18 15 1 0
+STARTCHAR uni150E
+ENCODING 5390
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 15 0 0
 BITMAP
-000080
-0001C0
-000080
-000000
-600080
-900080
-900080
-7C0080
-040080
-048080
-048080
-030080
-001080
-001080
-000F00
+4000
+E000
+4000
+0000
+4100
+4100
+6100
+1100
+0900
+09F0
+0108
+0908
+1D08
+0908
+00F0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5523
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 11 1 0
+STARTCHAR uni150F
+ENCODING 5391
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 15 0 0
 BITMAP
-601000
-901000
-901000
-7C1000
-041000
-049000
-049000
-031000
-001080
-001080
-000F00
+4000
+E000
+4000
+0000
+4100
+4100
+6100
+1100
+0900
+0900
+0100
+0900
+1D08
+0908
+00F0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5524
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 0
+STARTCHAR uni1510
+ENCODING 5392
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 9 6 1 0
 BITMAP
-001000
-003800
-001000
-000000
-601000
-901000
-901000
-7C1000
-041000
-049000
-049000
-031000
-001080
-001080
-000F00
+7080
+8880
+8880
+8880
+8880
+8700
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5525
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 8 1 3
+STARTCHAR uni1511
+ENCODING 5393
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 9 6 1 0
 BITMAP
-6000
-9000
-9000
-7C00
-0400
-0480
-0480
-0300
+8700
+8880
+8880
+8880
+8880
+7080
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5526
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 8 1 3
+STARTCHAR uni1512
+ENCODING 5394
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 9 10 1 0
 BITMAP
-6300
-9480
-9480
-7BE0
-0020
-0024
-0024
-0018
+0800
+1C00
+0800
+0000
+8700
+8880
+8880
+8880
+8880
+7080
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5527
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni1513
+ENCODING 5395
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 0
 BITMAP
-38
-44
-92
-AA
-8A
-72
-02
-02
-02
-02
-02
+F0
+08
+08
+08
+08
+70
+80
+80
+80
+80
+78
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5528
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni1514
+ENCODING 5396
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 0
 BITMAP
-38
-44
-92
-AA
-A2
-9C
-80
+20
+70
+20
+00
+F0
+08
+08
+08
+08
+70
 80
 80
 80
 80
+78
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5529
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni1515
+ENCODING 5397
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 0
 BITMAP
-02
-02
-02
-02
-02
-72
-8A
-AA
-92
-44
-38
+78
+80
+80
+80
+80
+70
+08
+08
+08
+08
+F0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5530
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni1516
+ENCODING 5398
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 0
 BITMAP
-80
+20
+70
+20
+00
+78
 80
 80
 80
 80
-9C
-A2
-AA
-92
-44
-38
+70
+08
+08
+08
+08
+F0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5531
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 8 1 0
+STARTCHAR uni1517
+ENCODING 5399
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 7 1 0
 BITMAP
-FF80
-0000
-FF80
-0840
-0840
-0840
-0840
-0780
+4000
+E708
+4888
+0888
+0888
+0888
+0870
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5532
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 8 1 0
+STARTCHAR uni1518
+ENCODING 5400
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 7 1 0
 BITMAP
-7FC0
-0000
-7FC0
-8400
-8400
-8400
-8400
-7800
+0010
+70B8
+8890
+8880
+8880
+8880
+8700
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5533
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 8 1 0
+STARTCHAR uni1519
+ENCODING 5401
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 13 7 1 0
 BITMAP
-FF80
-0000
-0780
-0840
-0840
-0840
-0840
-FF80
+4000
+E870
+4888
+0888
+0888
+0888
+0708
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5534
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 8 1 0
+STARTCHAR uni151A
+ENCODING 5402
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 13 7 1 0
 BITMAP
-7FC0
-0000
-7800
-8400
-8400
-8400
-8400
-7FC0
+0010
+8738
+8890
+8880
+8880
+8880
+7080
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5535
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 6 1 5
+STARTCHAR uni151B
+ENCODING 5403
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 13 10 1 0
 BITMAP
-7C
-00
-60
-90
-90
-7C
+0080
+01C0
+0080
+4000
+E870
+4888
+0888
+0888
+0888
+0708
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5536
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 9 1 0
+STARTCHAR uni151C
+ENCODING 5404
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 13 10 1 0
 BITMAP
-0200
-0100
-0080
-7FC0
-8000
-8000
-8000
-8000
-6000
+0800
+1C00
+0800
+0010
+8738
+8890
+8880
+8880
+8880
+7080
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5537
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 0
+STARTCHAR uni151D
+ENCODING 5405
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-1000
-3A00
-1100
+0F00
 0080
-7FC0
-8000
+0080
+0080
+4080
+E700
+4800
+0800
+0800
+0800
+0780
+ENDCHAR
+STARTCHAR uni151E
+ENCODING 5406
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+F000
+0800
+0800
+0800
+0900
+7380
+8100
 8000
 8000
 8000
-6000
-ENDCHAR
-STARTCHAR 006B
-ENCODING 5538
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 9 1 -3
-BITMAP
-0180
-0040
-0040
-0040
-0040
-FF80
-4000
-2000
-1000
+7800
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5539
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 1 -3
+STARTCHAR uni151F
+ENCODING 5407
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
 0200
 0700
 0200
 0000
-0180
-0040
-0040
-0040
-0040
-FF80
-4000
-2000
-1000
+0F00
+0080
+0080
+0080
+4080
+E700
+4800
+0800
+0800
+0800
+0780
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5540
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 9 1 -3
+STARTCHAR uni1520
+ENCODING 5408
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
-6000
-8000
+2000
+7000
+2000
+0000
+F000
+0800
+0800
+0800
+0900
+7380
+8100
 8000
 8000
 8000
-7FC0
+7800
+ENDCHAR
+STARTCHAR uni1521
+ENCODING 5409
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+0780
+0800
+0800
+0800
+4800
+E700
+4080
 0080
-0100
+0080
+0080
+0F00
+ENDCHAR
+STARTCHAR uni1522
+ENCODING 5410
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+7800
+8000
+8000
+8000
+8100
+7380
+0900
+0800
+0800
+0800
+F000
+ENDCHAR
+STARTCHAR uni1523
+ENCODING 5411
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
+BITMAP
+0200
+0700
 0200
+0000
+0780
+0800
+0800
+0800
+4800
+E700
+4080
+0080
+0080
+0080
+0F00
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5541
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 1 -3
+STARTCHAR uni1524
+ENCODING 5412
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
-1000
-3800
-1000
+2000
+7000
+2000
 0000
-6000
-8000
+7800
 8000
 8000
 8000
-7FC0
-0080
-0100
-0200
+8100
+7380
+0900
+0800
+0800
+0800
+F000
 ENDCHAR
-STARTCHAR char5251
-ENCODING 5542
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 6 1 5
+STARTCHAR uni1525
+ENCODING 5413
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 4
 BITMAP
-60
+70
 80
 80
-7C
-08
+60
 10
+10
+E0
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5543
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1526
+ENCODING 5414
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
 BITMAP
 08
 10
@@ -47242,61 +50549,83 @@
 FC
 04
 04
-1F
+04
 04
 04
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5544
+STARTCHAR uni1527
+ENCODING 5415
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 7 15 0 0
 BITMAP
+40
+A0
+40
+00
+20
 10
 08
 04
 02
-01
-3F
-20
-20
-F8
-20
-20
+7E
+40
+40
+40
+40
+40
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5545
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR uni1528
+ENCODING 5416
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
 BITMAP
-10
-38
+40
+20
 10
+08
+04
+FC
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni1529
+ENCODING 5417
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 0 0
+BITMAP
+40
+E0
+40
 00
+20
 10
 08
 04
 02
-01
-3F
-20
-20
-F8
-20
-20
+7E
+40
+40
+40
+40
+40
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5546
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni152A
+ENCODING 5418
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
 BITMAP
 04
 04
-1F
 04
 04
+04
 FC
 80
 40
@@ -47304,11 +50633,11 @@
 10
 08
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5547
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR uni152B
+ENCODING 5419
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 1 0
 BITMAP
 04
 0E
@@ -47316,9 +50645,9 @@
 00
 04
 04
-1F
 04
 04
+04
 FC
 80
 40
@@ -47326,188 +50655,539 @@
 10
 08
 ENDCHAR
-STARTCHAR 00F7
-ENCODING 5548
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni152C
+ENCODING 5420
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
-20
-20
-F8
-20
-20
-3F
-01
-02
+1100
+3B80
+1100
+0000
+0400
+0400
+0400
+0400
+0400
+FC00
+8000
+4000
+2000
+1000
+0800
+ENDCHAR
+STARTCHAR uni152D
+ENCODING 5421
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
+BITMAP
+80
+80
+80
+80
+80
+FC
 04
 08
 10
-ENDCHAR
-STARTCHAR 00F7
-ENCODING 5549
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
-BITMAP
 20
-70
-20
+40
+ENDCHAR
+STARTCHAR uni152E
+ENCODING 5422
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 0 0
+BITMAP
+40
+E0
+40
 00
-20
-20
-F8
-20
-20
-3F
-01
+40
+40
+40
+40
+40
+7E
 02
 04
 08
 10
+20
 ENDCHAR
-STARTCHAR char5438
-ENCODING 5550
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 4
+STARTCHAR uni152F
+ENCODING 5423
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-40
+0080
+0100
+0200
+0400
+4800
+EFC0
+4040
+0040
+0040
+0040
+0040
+ENDCHAR
+STARTCHAR uni1530
+ENCODING 5424
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0800
+1000
+2000
+4000
+8080
+FDC0
+0480
+0400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni1531
+ENCODING 5425
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0400
+0200
+0100
+0080
+4040
+EFC0
+4800
+0800
+0800
+0800
+0800
+ENDCHAR
+STARTCHAR uni1532
+ENCODING 5426
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+4000
+2000
+1000
+0800
+0480
+FDC0
+8080
+8000
+8000
+8000
+8000
+ENDCHAR
+STARTCHAR uni1533
+ENCODING 5427
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0800
+1C00
+0800
+0000
+0400
+0200
+0100
+0080
+4040
+EFC0
+4800
+0800
+0800
+0800
+0800
+ENDCHAR
+STARTCHAR uni1534
+ENCODING 5428
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 0 0
+BITMAP
+4000
+E000
+4000
+0000
+2000
+1000
+0800
+0400
+0240
+7EE0
+4040
+4000
+4000
+4000
+4000
+ENDCHAR
+STARTCHAR uni1535
+ENCODING 5429
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0040
+0040
+0040
+0040
+4040
+EFC0
+4800
+0400
+0200
+0100
+0080
+ENDCHAR
+STARTCHAR uni1536
+ENCODING 5430
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0400
+0400
+0400
+0400
+0480
+FDC0
+8080
+4000
+2000
+1000
+0800
+ENDCHAR
+STARTCHAR uni1537
+ENCODING 5431
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 1 0
+BITMAP
+0040
+00E0
+0040
+0000
+0040
+0040
+0040
+0040
+4040
+EFC0
+4800
+0400
+0200
+0100
+0080
+ENDCHAR
+STARTCHAR uni1538
+ENCODING 5432
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0400
+0E00
+0400
+0000
+0400
+0400
+0400
+0400
+0480
+FDC0
+8080
+4000
+2000
+1000
+0800
+ENDCHAR
+STARTCHAR uni1539
+ENCODING 5433
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0800
+0800
+0800
+0800
+4800
+EFC0
+4040
+0080
+0100
+0200
+0400
+ENDCHAR
+STARTCHAR uni153A
+ENCODING 5434
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+8000
+8000
+8000
+8000
+8080
+FDC0
+0480
+0800
+1000
+2000
+4000
+ENDCHAR
+STARTCHAR uni153B
+ENCODING 5435
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0800
+1C00
+0800
+0000
+0800
+0800
+0800
+0800
+4800
+EFC0
+4040
+0080
+0100
+0200
+0400
+ENDCHAR
+STARTCHAR uni153C
+ENCODING 5436
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 0 0
+BITMAP
+4000
+E000
+4000
+0000
+4000
+4000
+4000
+4000
+4040
+7EE0
+0240
+0400
+0800
+1000
+2000
+ENDCHAR
+STARTCHAR uni153D
+ENCODING 5437
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+0800
+0800
+4800
+E800
+4800
+0FC0
+4040
+E080
+4100
+0200
+0400
+ENDCHAR
+STARTCHAR uni153E
+ENCODING 5438
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 6 1 5
+BITMAP
+80
+80
 E0
-40
-70
-10
 20
 40
+80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5551
+STARTCHAR uni153F
+ENCODING 5439
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 7 4 1 7
+BITMAP
+6C
+6C
+92
+92
+ENDCHAR
+STARTCHAR uni1540
+ENCODING 5440
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 11 1 0
+BBX 5 5 1 6
 BITMAP
-80
-80
-80
-80
-80
-B8
-C4
+20
+20
+F8
+20
+20
+ENDCHAR
+STARTCHAR uni1541
+ENCODING 5441
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 6 1 5
+BITMAP
 84
+48
+30
+30
+48
 84
-C4
-B8
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5552
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni1542
+ENCODING 5442
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 0
 BITMAP
-B8
-FC
-FC
-FC
-FC
-B8
-80
-80
-80
-80
-80
+83C0
+8200
+8200
+8200
+4400
+3800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5553
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni1543
+ENCODING 5443
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 0
 BITMAP
-04
-04
-04
-04
-04
-74
-FC
-FC
-FC
-FC
-74
+F040
+1040
+1040
+1040
+0880
+0700
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5554
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni1544
+ENCODING 5444
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 0
 BITMAP
-80
-80
-80
-80
-80
-B8
-FC
-FC
-FC
-FC
-B8
+0700
+0880
+1040
+1040
+1040
+F040
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5555
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni1545
+ENCODING 5445
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 10 1 0
 BITMAP
-74
-FC
-FC
-FC
-FC
-74
-04
-04
-04
-04
-04
+1000
+2800
+1000
+0000
+3800
+4400
+8200
+8200
+8200
+83C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5556
+STARTCHAR uni1546
+ENCODING 5446
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 0
+BITMAP
+3800
+4400
+8200
+8200
+8200
+83C0
+ENDCHAR
+STARTCHAR uni1547
+ENCODING 5447
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 10 1 0
+BITMAP
+1000
+3800
+1000
+0000
+3800
+4400
+8200
+8200
+8200
+83C0
+ENDCHAR
+STARTCHAR uni1548
+ENCODING 5448
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
 BITMAP
-FC
-80
-80
-80
-FC
-80
-80
+F0
+08
+04
+04
+04
+08
+F0
 80
 80
 80
 80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5557
+STARTCHAR uni1549
+ENCODING 5449
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 6 11 1 0
+BBX 6 15 1 0
 BITMAP
-04
-04
-04
-04
-04
-04
-FC
+20
+70
+20
+00
+F0
+08
 04
 04
 04
-FC
+08
+F0
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5558
+STARTCHAR uni154A
+ENCODING 5450
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
@@ -47515,692 +51195,641 @@
 80
 80
 80
-80
-80
-80
-FC
-80
-80
 80
-FC
+F0
+08
+04
+04
+04
+08
+F0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5559
+STARTCHAR uni154B
+ENCODING 5451
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
 BITMAP
-FC
-04
-04
-04
-FC
-04
-04
+3C
+40
+80
+80
+80
+40
+3C
 04
 04
 04
 04
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5560
+STARTCHAR uni154C
+ENCODING 5452
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 11 1 0
+BBX 6 15 1 0
 BITMAP
-E2
-A2
-A2
-A2
-A2
-9C
-80
-80
+10
+38
+10
+00
+3C
+40
 80
 80
 80
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5561
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
-BITMAP
-02
-02
-02
-02
-02
-72
-8A
-8A
-8A
-8A
-8E
+40
+3C
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5562
+STARTCHAR uni154D
+ENCODING 5453
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 11 1 0
+BBX 6 11 1 0
 BITMAP
-80
-80
+04
+04
+04
+04
+3C
+40
 80
 80
 80
-9C
-A2
-A2
-A2
-A2
-E2
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5563
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
-BITMAP
-8E
-8A
-8A
-8A
-8A
-72
-02
-02
-02
-02
-02
+40
+3C
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5564
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni154E
+ENCODING 5454
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
-C2
-C2
-A4
-A4
-98
-98
-80
-80
-80
-80
-80
+0100
+0380
+0100
+0000
+03C0
+0400
+0800
+0800
+4800
+E400
+43C0
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5565
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni154F
+ENCODING 5455
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
 BITMAP
-02
-02
-02
-02
-02
-32
-32
-4A
-4A
-86
-86
+1000
+3800
+1000
+0000
+3C00
+4000
+8000
+8000
+8080
+41C0
+3C80
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5566
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni1550
+ENCODING 5456
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 6 1 5
 BITMAP
-80
-80
-80
+60
 80
 80
-98
-98
-A4
-A4
-C2
-C2
+60
+20
+20
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5567
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni1551
+ENCODING 5457
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 4
 BITMAP
-86
-86
-4A
-4A
-32
-32
-02
-02
-02
-02
-02
+C0
+30
+30
+C0
+30
+30
+C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5568
+STARTCHAR uni1552
+ENCODING 5458
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-0080
-0080
-0080
-0080
-7880
-8480
-8480
-8480
-0280
-0180
-0080
+E000
+1C00
+0380
+0700
+1800
+E000
+1800
+0700
+0380
+1C00
+E000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5569
+STARTCHAR uni1553
+ENCODING 5459
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-8000
-8000
-8000
-8000
-8F00
-9080
+6000
 9080
 9080
-A000
-C000
-8000
+E100
+4100
+6200
+2200
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5570
+STARTCHAR uni1554
+ENCODING 5460
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 11 1 0
+BBX 9 15 1 0
 BITMAP
-0080
-0180
-0280
-8480
-8480
-8480
-7880
-0080
-0080
-0080
-0080
+0800
+1400
+0800
+0000
+0800
+0800
+1400
+1400
+2200
+2200
+4100
+E100
+9080
+9080
+6000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5571
+STARTCHAR uni1555
+ENCODING 5461
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-8000
-C000
-A000
-9080
+0800
+0800
+1400
+1400
+2200
+2200
+4100
+E100
 9080
 9080
-8F00
-8000
-8000
-8000
-8000
+6000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5572
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni1556
+ENCODING 5462
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
 BITMAP
-8080
-8080
-4100
-4100
-3E00
-2200
-2200
-1400
-1400
 0800
+1C00
 0800
-ENDCHAR
-STARTCHAR C065
-ENCODING 5573
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
-BITMAP
+0000
 0800
 0800
 1400
 1400
 2200
 2200
-3E00
-4100
 4100
-8080
-8080
+E100
+9080
+9080
+6000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5574
+STARTCHAR uni1557
+ENCODING 5463
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 10 1 0
 BITMAP
-C000
-3000
-0C00
-0B00
-0880
-0840
-0880
-0B00
+7000
+9C00
+9300
+6080
+0040
+0080
+0300
 0C00
 3000
 C000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5575
+STARTCHAR uni1558
+ENCODING 5464
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 15 1 0
 BITMAP
-C000
-3000
-0C00
-4B00
-4880
-4840
-4880
-4B00
+0400
+0E00
+0400
+0000
+0000
+7000
+9C00
+9300
+6080
+0040
+0080
+0300
 0C00
 3000
 C000
 ENDCHAR
-STARTCHAR C065
-ENCODING 5576
+STARTCHAR uni1559
+ENCODING 5465
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 10 1 0
 BITMAP
-C000
+0380
+0E40
+3240
+4180
+8000
+4000
 3000
 0C00
-0B00
-4880
-E840
-4880
-0B00
-0C00
-3000
-C000
+0300
+00C0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5577
+STARTCHAR uni155A
+ENCODING 5466
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 15 1 0
 BITMAP
-00C0
-0300
+0400
+0E00
+0400
+0000
+0000
+0380
+0E40
+3240
+4180
+8000
+4000
+3000
 0C00
-3400
-4400
-8400
+0300
+00C0
+ENDCHAR
+STARTCHAR uni155B
+ENCODING 5467
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+0040
+00E0
+0040
+0000
+0000
+0038
+00E4
+0324
+4418
+E800
 4400
-3400
+0300
+00C0
+0030
+000C
+ENDCHAR
+STARTCHAR uni155C
+ENCODING 5468
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+0400
+0E00
+0400
+0000
+0000
+0380
+0E40
+3240
+4188
+801C
+4008
+3000
 0C00
 0300
 00C0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5578
+STARTCHAR uni155D
+ENCODING 5469
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 6 1 5
+BITMAP
+08
+34
+C8
+60
+18
+04
+ENDCHAR
+STARTCHAR uni155E
+ENCODING 5470
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
-8080
-8080
-7F00
+6080
+9080
+9080
+E080
+8080
+8080
+8080
+8080
+8080
 4100
-2200
-2200
-2200
-1400
-1400
-0800
-0800
+3E00
 ENDCHAR
-STARTCHAR C065
-ENCODING 5579
+STARTCHAR uni155F
+ENCODING 5471
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
-0800
-0800
-1400
-1400
-2200
-2200
-2200
-4100
-7F00
+8300
+8480
+8480
+8380
 8080
 8080
-ENDCHAR
-STARTCHAR C065
-ENCODING 5580
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
-BITMAP
-C000
-3000
-2C00
-2300
-2080
-2040
-2080
-2300
-2C00
-3000
-C000
-ENDCHAR
-STARTCHAR C065
-ENCODING 5581
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
-BITMAP
-C000
-3000
-2C00
-2300
-2880
-2840
-2880
-2300
-2C00
-3000
-C000
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR C065
-ENCODING 5582
+STARTCHAR uni1560
+ENCODING 5472
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 1 0
 BITMAP
-C000
-3000
-2C00
-2300
-2480
-2E40
-2480
-2300
-2C00
-3000
-C000
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+E080
+9080
+9080
+6080
 ENDCHAR
-STARTCHAR C065
-ENCODING 5583
+STARTCHAR uni1561
+ENCODING 5473
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 1 0
 BITMAP
-00C0
-0300
-0D00
-3100
-4100
-8100
+3E00
 4100
-3100
-0D00
-0300
-00C0
+8080
+8080
+8080
+8080
+8080
+8380
+8480
+8480
+8300
 ENDCHAR
-STARTCHAR C065
-ENCODING 5584
+STARTCHAR uni1562
+ENCODING 5474
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 9 15 1 0
 BITMAP
-8880
-8880
-4900
-4900
-2A00
-2A00
-2A00
-1C00
-1C00
 0800
+1C00
 0800
+0000
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+E080
+9080
+9080
+6080
 ENDCHAR
-STARTCHAR C065
-ENCODING 5585
+STARTCHAR uni1563
+ENCODING 5475
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 9 15 1 0
 BITMAP
 0800
-0800
-1C00
 1C00
-2A00
-2A00
-2A00
-4900
-4900
-8880
-8880
+0800
+0000
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+8380
+8480
+8480
+8300
 ENDCHAR
-STARTCHAR C065
-ENCODING 5586
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni1564
+ENCODING 5476
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-C000
-3000
-0C00
-0300
-0080
-FFC0
-0080
-0300
-0C00
-3000
-C000
+78
+94
+92
+61
+01
+01
+01
+01
+02
+04
+F8
 ENDCHAR
-STARTCHAR C065
-ENCODING 5587
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni1565
+ENCODING 5477
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-C000
-3000
-0C00
-4300
-4080
-FFC0
-4080
-4300
-0C00
-3000
-C000
+10
+38
+10
+00
+78
+94
+92
+61
+01
+01
+01
+01
+02
+04
+F8
 ENDCHAR
-STARTCHAR C065
-ENCODING 5588
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni1566
+ENCODING 5478
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-C000
-3000
-0C00
-0300
-2080
-FFC0
-2080
-0300
-0C00
-3000
-C000
+1E
+29
+49
+86
+80
+80
+80
+80
+40
+20
+1F
 ENDCHAR
-STARTCHAR C065
-ENCODING 5589
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni1567
+ENCODING 5479
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-00C0
-0300
-0C00
-3000
-4000
-FFC0
-4000
-3000
-0C00
-0300
-00C0
+08
+1C
+08
+00
+1E
+29
+49
+86
+80
+80
+80
+80
+40
+20
+1F
 ENDCHAR
-STARTCHAR C065
-ENCODING 5590
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni1568
+ENCODING 5480
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 15 1 0
 BITMAP
-8880
-8880
-4900
-4900
-3E00
-2A00
-2A00
-1C00
-1C00
-0800
+0080
+01C0
+0080
+0000
+01E0
+0290
+0490
+0860
+4800
+E800
+4800
 0800
+0400
+0200
+01F0
 ENDCHAR
-STARTCHAR C065
-ENCODING 5591
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni1569
+ENCODING 5481
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
 0800
-0800
-1C00
 1C00
-2A00
-2A00
-3E00
-4900
+0800
+0000
+1E00
+2900
 4900
-8880
-8880
-ENDCHAR
-STARTCHAR C065
-ENCODING 5592
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
-BITMAP
-C000
-3000
-0C00
-0B00
-0880
-FFC0
-0880
-0B00
-0C00
-3000
-C000
-ENDCHAR
-STARTCHAR C065
-ENCODING 5593
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
-BITMAP
-C000
-3000
-0C00
-4B00
-4880
-FFC0
-4880
-4B00
-0C00
-3000
-C000
-ENDCHAR
-STARTCHAR C065
-ENCODING 5594
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
-BITMAP
-C000
-3000
-0C00
-0B00
-2880
-FFC0
-2880
-0B00
-0C00
-3000
-C000
+8600
+8040
+80E0
+8040
+8000
+4000
+2000
+1F00
 ENDCHAR
-STARTCHAR C065
-ENCODING 5595
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 1 0
+STARTCHAR uni156A
+ENCODING 5482
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 6 1 5
 BITMAP
-00C0
-0300
-0C00
-3400
-4400
-FFC0
-4400
-3400
-0C00
-0300
-00C0
+70
+A8
+90
+80
+80
+70
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5596
+STARTCHAR uni156B
+ENCODING 5483
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
-FF80
-8080
-8080
-8080
-8080
+8880
+8880
+8880
+8880
+8880
 8080
 8080
 8080
@@ -48208,8 +51837,8 @@
 4100
 3E00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5597
+STARTCHAR uni156C
+ENCODING 5484
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 9 11 1 0
@@ -48219,105 +51848,81 @@
 8080
 8080
 8080
-8080
-8080
-8080
-8080
 8080
-FF80
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5598
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
-BITMAP
-F8
-84
-82
-81
-81
-81
-81
-81
-82
-84
-F8
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5599
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
-BITMAP
-F8
-84
-82
-91
-91
-91
-91
-91
-82
-84
-F8
+8880
+8880
+8880
+8880
+8880
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5600
+STARTCHAR uni156D
+ENCODING 5485
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
 F8
-84
-82
-81
-91
-B9
-91
-81
-82
-84
+04
+02
+01
+01
+F1
+01
+01
+02
+04
 F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5601
+STARTCHAR uni156E
+ENCODING 5486
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
 1F
-21
-41
-81
-81
-81
-81
-81
-41
-21
+20
+40
+80
+80
+8F
+80
+80
+40
+20
 1F
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5602
+STARTCHAR uni156F
+ENCODING 5487
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 5 1 4
+BITMAP
+2040
+A950
+70E0
+A950
+2040
+ENDCHAR
+STARTCHAR uni1570
+ENCODING 5488
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
-8080
-C180
 A280
-9480
-8880
-8080
+A280
+A280
+A280
+A280
+9C80
 8080
 8080
 8080
 4100
 3E00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5603
+STARTCHAR uni1571
+ENCODING 5489
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 9 11 1 0
@@ -48326,88 +51931,203 @@
 4100
 8080
 8080
-8080
 8080
-8880
-9480
+9C80
 A280
-C180
-8080
+A280
+A280
+A280
+A280
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5604
+STARTCHAR uni1572
+ENCODING 5490
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
 F8
-84
-82
-41
-41
-21
-41
-41
-82
-84
+04
+02
+E1
+11
+11
+11
+E1
+02
+04
 F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5605
+STARTCHAR uni1573
+ENCODING 5491
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-F8
-84
-82
-49
-49
-29
-49
-49
-82
-84
-F8
+1F
+20
+40
+87
+88
+88
+88
+87
+40
+20
+1F
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5606
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1574
+ENCODING 5492
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-F8
-84
-82
-41
-49
-3D
-49
-41
-82
-84
-F8
+7800
+8400
+8400
+8400
+8400
+7C00
+0400
+0480
+0500
+0600
+0400
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5607
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1575
+ENCODING 5493
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-1F
-21
-41
-82
-82
-84
-82
-82
-41
-21
-1F
+0F00
+1080
+1080
+1080
+1080
+1F00
+1000
+9000
+5000
+3000
+1000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5608
+STARTCHAR uni1576
+ENCODING 5494
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
+BITMAP
+0400
+0E00
+0400
+0000
+0F00
+1080
+1080
+1080
+1080
+1F00
+1000
+9000
+5000
+3000
+1000
+ENDCHAR
+STARTCHAR uni1577
+ENCODING 5495
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+0400
+0600
+0500
+0480
+0400
+7C00
+8400
+8400
+8400
+8400
+7800
+ENDCHAR
+STARTCHAR uni1578
+ENCODING 5496
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
+BITMAP
+0400
+0E00
+0400
+0000
+0400
+0600
+0500
+0480
+0400
+7C00
+8400
+8400
+8400
+8400
+7800
+ENDCHAR
+STARTCHAR uni1579
+ENCODING 5497
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+1000
+3000
+5000
+9000
+1000
+1F00
+1080
+1080
+1080
+1080
+0F00
+ENDCHAR
+STARTCHAR uni157A
+ENCODING 5498
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 0
+BITMAP
+1000
+3800
+1000
+0000
+1000
+3000
+5000
+9000
+1000
+1F00
+1080
+1080
+1080
+1080
+0F00
+ENDCHAR
+STARTCHAR uni157B
+ENCODING 5499
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 6 1 5
+BITMAP
+20
+60
+B8
+24
+24
+38
+ENDCHAR
+STARTCHAR uni157C
+ENCODING 5500
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 9 11 1 0
@@ -48415,1020 +52135,1042 @@
 8080
 8080
 8080
+8080
+8080
 FF80
 8080
 8080
 8080
 8080
 8080
-4100
-3E00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5609
+STARTCHAR uni157D
+ENCODING 5501
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 6 1 5
+BITMAP
+84
+48
+30
+30
+48
+84
+ENDCHAR
+STARTCHAR uni157E
+ENCODING 5502
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 10 15 1 0
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-8080
-FF80
-8080
-8080
-8080
+0200
+0500
+0200
+0000
+6780
+8840
+8840
+6840
+2840
+2F80
+0800
+0800
+0800
+0800
+0800
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5610
+STARTCHAR uni157F
+ENCODING 5503
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+6780
+8840
+8840
+6840
+2840
+2F80
+0800
+0800
+0800
+0800
+0800
+ENDCHAR
+STARTCHAR uni1580
+ENCODING 5504
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0200
+0700
+0200
+0000
+6780
+8840
+8840
+6840
+2840
+2F80
+0800
+0800
+0800
+0800
+0800
+ENDCHAR
+STARTCHAR uni1581
+ENCODING 5505
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+6040
+8040
+8040
+6040
+2040
+27C0
+0840
+0840
+0840
+0840
+0780
+ENDCHAR
+STARTCHAR uni1582
+ENCODING 5506
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 1 0
+BITMAP
+0040
+00E0
+0040
+0000
+6040
+8040
+8040
+6040
+2040
+27C0
+0840
+0840
+0840
+0840
+0780
+ENDCHAR
+STARTCHAR uni1583
+ENCODING 5507
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+6800
+8800
+8800
+6800
+2800
+2F80
+0840
+0840
+0840
+0840
+0780
+ENDCHAR
+STARTCHAR uni1584
+ENCODING 5508
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 1 0
+BITMAP
+0040
+00E0
+0040
+0000
+6800
+8800
+8800
+6800
+2800
+2F80
+0840
+0840
+0840
+0840
+0780
+ENDCHAR
+STARTCHAR uni1585
+ENCODING 5509
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 6 1 5
+BITMAP
+68
+88
+8E
+69
+29
+2E
+ENDCHAR
+STARTCHAR uni1586
+ENCODING 5510
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-F8
-24
-22
+1E
 21
 21
 21
 21
+1F
+09
+11
 21
-22
-24
-F8
+41
+81
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5611
+STARTCHAR uni1587
+ENCODING 5511
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-F8
-24
-22
-29
-29
-29
-29
-29
-22
-24
+78
+84
+84
+84
+84
 F8
+90
+88
+84
+82
+81
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5612
+STARTCHAR uni1588
+ENCODING 5512
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-F8
-24
-22
+81
+41
 21
-29
-3D
-29
+11
+09
+1F
 21
-22
-24
-F8
+21
+21
+21
+1E
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5613
+STARTCHAR uni1589
+ENCODING 5513
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-1F
-24
-44
+81
+82
 84
+88
+90
+F8
 84
 84
 84
 84
-44
-24
-1F
-ENDCHAR
-STARTCHAR char5161
-ENCODING 5614
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 5 1 6
-BITMAP
-20
-20
-20
-20
-F8
+78
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5615
-SWIDTH 660 0
-DWIDTH 11 0
+STARTCHAR uni158A
+ENCODING 5514
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-5500
-2200
+7800
+8400
+8400
+0400
+0400
+0400
+0400
+0580
+0600
+0400
+0400
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5616
-SWIDTH 660 0
-DWIDTH 11 0
+STARTCHAR uni158B
+ENCODING 5515
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 9 11 1 0
-BITMAP
-2200
-5500
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5617
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
-BITMAP
-FC
-02
-01
-01
-02
-FC
-02
-01
-01
-02
-FC
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5618
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
 BITMAP
-FC
-02
-01
-41
-42
-FC
-42
-41
-01
-02
-FC
+0F00
+1080
+1080
+1000
+1000
+1000
+1000
+D000
+3000
+1000
+1000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5619
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni158C
+ENCODING 5516
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-FC
-02
-01
-01
-22
-FC
-22
-01
-01
-02
-FC
+0400
+0400
+0600
+0580
+0400
+0400
+0400
+0400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5620
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni158D
+ENCODING 5517
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-3F
-40
-80
-80
-40
-3F
-40
-80
-80
-40
-3F
+1000
+1000
+3000
+D000
+1000
+1000
+1000
+1000
+1080
+1080
+0F00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5621
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni158E
+ENCODING 5518
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 15 1 0
 BITMAP
-FF80
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-5500
-2200
+000400
+000A00
+000400
+000000
+600F00
+901080
+901080
+7C1000
+041000
+049000
+049000
+031000
+001000
+001000
+001000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5622
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni158F
+ENCODING 5519
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 11 1 0
 BITMAP
-2200
-5500
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-FF80
+600F00
+901080
+901080
+7C1000
+041000
+049000
+049000
+031000
+001000
+001000
+001000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5623
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1590
+ENCODING 5520
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 15 1 0
 BITMAP
-FC
-82
-81
-81
-82
-FC
-82
-81
-81
-82
-FC
+000400
+000E00
+000400
+000000
+600F00
+901080
+901080
+7C1000
+041000
+049000
+049000
+031000
+001000
+001000
+001000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5624
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1591
+ENCODING 5521
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 11 1 0
 BITMAP
-FC
-82
-81
-91
-92
-FC
-92
-91
-81
-82
-FC
+600080
+900080
+900080
+7C0080
+040080
+048080
+048080
+030080
+001080
+001080
+000F00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5625
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1592
+ENCODING 5522
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 15 1 0
 BITMAP
-FC
-82
-81
-81
-92
-FC
-92
-81
-81
-82
-FC
+000080
+0001C0
+000080
+000000
+600080
+900080
+900080
+7C0080
+040080
+048080
+048080
+030080
+001080
+001080
+000F00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5626
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1593
+ENCODING 5523
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 11 1 0
 BITMAP
-3F
-41
-81
-81
-41
-3F
-41
-81
-81
-41
-3F
+601000
+901000
+901000
+7C1000
+041000
+049000
+049000
+031000
+001080
+001080
+000F00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5627
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni1594
+ENCODING 5524
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 15 1 0
 BITMAP
-8880
-C980
-AA80
-9C80
-8880
-8880
-8880
-8880
-8880
-5500
-2200
+001000
+003800
+001000
+000000
+601000
+901000
+901000
+7C1000
+041000
+049000
+049000
+031000
+001080
+001080
+000F00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5628
+STARTCHAR uni1595
+ENCODING 5525
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
-BITMAP
-2200
-5500
-8880
-8880
-8880
-8880
-8880
-9C80
-AA80
-C980
-8880
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5629
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+BBX 9 8 1 3
 BITMAP
-FC
-82
-41
-41
-22
-FC
-22
-41
-41
-82
-FC
+6000
+9000
+9000
+7C00
+0400
+0480
+0480
+0300
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5630
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1596
+ENCODING 5526
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 8 1 3
 BITMAP
-FC
-82
-41
-49
-2A
-FC
-2A
-49
-41
-82
-FC
+6300
+9480
+9480
+7BE0
+0020
+0024
+0024
+0018
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5631
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1597
+ENCODING 5527
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-FC
-82
-41
-41
-2A
-FC
-2A
-41
-41
-82
-FC
+38
+44
+92
+AA
+8A
+72
+02
+02
+02
+02
+02
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5632
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni1598
+ENCODING 5528
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-3F
-41
-82
-82
-44
-3F
+38
 44
-82
-82
-41
-3F
+92
+AA
+A2
+9C
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char5150
-ENCODING 5633
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 6 1 5
+STARTCHAR uni1599
+ENCODING 5529
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-88
-88
-50
-50
-20
-20
+02
+02
+02
+02
+02
+72
+8A
+AA
+92
+44
+38
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5634
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni159A
+ENCODING 5530
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
 80
 80
 80
 80
-80
-80
-80
 80
-84
-84
-78
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5635
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
-BITMAP
-78
-84
-84
-04
-04
-04
-04
-04
-04
-04
-04
+9C
+A2
+AA
+92
+44
+38
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5636
+STARTCHAR uni159B
+ENCODING 5531
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 6 1 0
+BBX 10 8 1 0
 BITMAP
 FF80
-0040
-0040
-0040
-0040
-0180
+0000
+FF80
+0840
+0840
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5637
+STARTCHAR uni159C
+ENCODING 5532
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 6 1 0
+BBX 10 8 1 0
 BITMAP
-FF80
-0040
-0440
-0440
-0440
-0180
+7FC0
+0000
+7FC0
+8400
+8400
+8400
+8400
+7800
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5638
+STARTCHAR uni159D
+ENCODING 5533
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 6 1 0
+BBX 10 8 1 0
 BITMAP
 FF80
-0040
-0440
-0E40
-0440
-0180
+0000
+0780
+0840
+0840
+0840
+0840
+FF80
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5639
+STARTCHAR uni159E
+ENCODING 5534
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 6 1 0
+BBX 10 8 1 0
 BITMAP
-6000
-8000
-8000
-8000
-8000
+7FC0
+0000
+7800
+8400
+8400
+8400
+8400
 7FC0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5640
+STARTCHAR uni159F
+ENCODING 5535
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 11 1 0
+BBX 6 6 1 5
 BITMAP
-80
-80
-80
-80
-80
-92
-92
-92
-92
-92
-6C
+7C
+00
+60
+90
+90
+7C
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5641
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni15A0
+ENCODING 5536
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 9 1 0
 BITMAP
-6C
-92
-92
-92
-92
-92
-02
-02
-02
-02
-02
+0200
+0100
+0080
+7FC0
+8000
+8000
+8000
+8000
+6000
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5642
+STARTCHAR uni15A1
+ENCODING 5537
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 10 1 0
 BITMAP
-FF80
-0040
-0040
-0040
-0040
-0780
-0040
-0040
-0040
-0040
-0780
+1000
+3A00
+1100
+0080
+7FC0
+8000
+8000
+8000
+8000
+6000
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5643
+STARTCHAR uni15A2
+ENCODING 5538
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 9 1 -3
 BITMAP
-FF80
+0180
 0040
 0040
-0840
-0840
-0F80
-0840
-0840
 0040
 0040
-0780
+FF80
+4000
+2000
+1000
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5644
+STARTCHAR uni15A3
+ENCODING 5539
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 13 1 -3
 BITMAP
-FF80
-0040
-0040
+0200
+0700
+0200
+0000
+0180
 0040
-0840
-1F80
-0840
 0040
 0040
 0040
-0780
+FF80
+4000
+2000
+1000
 ENDCHAR
-STARTCHAR 006B
-ENCODING 5645
+STARTCHAR uni15A4
+ENCODING 5540
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 10 9 1 -3
 BITMAP
-7800
-8000
-8000
-8000
-8000
-7800
+6000
 8000
 8000
 8000
 8000
 7FC0
+0080
+0100
+0200
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5646
+STARTCHAR uni15A5
+ENCODING 5541
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 10 13 1 -3
 BITMAP
-8600
-8900
-9080
-9080
-8880
-8080
-8080
-8080
-8080
-4100
-3E00
+1000
+3800
+1000
+0000
+6000
+8000
+8000
+8000
+8000
+7FC0
+0080
+0100
+0200
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5647
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni15A6
+ENCODING 5542
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 6 1 5
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-8880
-8480
-8480
-4880
-3080
+60
+80
+80
+7C
+08
+10
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5648
+STARTCHAR uni15A7
+ENCODING 5543
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-F8
+08
+10
+20
+40
+80
+FC
 04
-02
-01
-61
-91
-91
-81
-82
-44
-38
+04
+1F
+04
+04
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5649
+STARTCHAR uni15A8
+ENCODING 5544
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-F8
+10
+08
 04
 02
-11
-51
-B1
-91
-91
-82
-44
-38
+01
+3F
+20
+20
+F8
+20
+20
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5650
+STARTCHAR uni15A9
+ENCODING 5545
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 8 15 1 0
 BITMAP
-F8
+10
+38
+10
+00
+10
+08
 04
 02
 01
-51
-B9
-91
-81
-82
-44
-38
+3F
+20
+20
+F8
+20
+20
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5651
+STARTCHAR uni15AA
+ENCODING 5546
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 11 1 0
 BITMAP
-1C
-22
-41
-81
-89
-89
-86
+04
+04
+1F
+04
+04
+FC
 80
 40
 20
-1F
-ENDCHAR
-STARTCHAR char5311
-ENCODING 5652
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
-BITMAP
-FE
-84
-08
 10
-20
-4C
-92
-92
-82
-44
-38
+08
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5653
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni15AB
+ENCODING 5547
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-FE
-42
+04
+0E
+04
+00
+04
+04
+1F
+04
+04
+FC
+80
+40
 20
 10
 08
-64
-92
-92
-82
-44
-38
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5654
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni15AC
+ENCODING 5548
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-38
-44
-82
-92
-92
-64
+20
+20
+F8
+20
+20
+3F
+01
+02
+04
 08
 10
+ENDCHAR
+STARTCHAR uni15AD
+ENCODING 5549
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
+BITMAP
 20
-42
-FE
+70
+20
+00
+20
+20
+F8
+20
+20
+3F
+01
+02
+04
+08
+10
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5655
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
+STARTCHAR uni15AE
+ENCODING 5550
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 4
 BITMAP
-C380
-8440
-8820
-9320
-A420
-C440
-8380
+40
+E0
+40
+70
+10
+20
+40
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5656
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
+STARTCHAR uni15AF
+ENCODING 5551
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-C380
-8440
-8920
-9320
-A520
-C440
-8380
+80
+80
+80
+80
+80
+B8
+C4
+84
+84
+C4
+B8
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5657
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
+STARTCHAR uni15B0
+ENCODING 5552
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-C380
-8440
-8920
-97A0
-A520
-C440
-8380
+B8
+FC
+FC
+FC
+FC
+B8
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5658
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
+STARTCHAR uni15B1
+ENCODING 5553
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-8380
-C440
-A420
-9320
-8820
-8440
-C380
+04
+04
+04
+04
+04
+74
+FC
+FC
+FC
+FC
+74
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5659
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
+STARTCHAR uni15B2
+ENCODING 5554
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-3820
-4460
-84A0
-9920
-8220
-4420
-3860
+80
+80
+80
+80
+80
+B8
+FC
+FC
+FC
+FC
+B8
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5660
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni15B3
+ENCODING 5555
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-82
-44
-28
-10
-20
-4C
-92
-92
-82
-44
-38
+74
+FC
+FC
+FC
+FC
+74
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR char5311
-ENCODING 5661
+STARTCHAR uni15B4
+ENCODING 5556
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 11 1 0
-BITMAP
-38
-44
-82
-92
-92
-64
-08
-10
-28
-44
-82
-ENDCHAR
-STARTCHAR char5311
-ENCODING 5662
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
-BITMAP
-8380
-4440
-2820
-1320
-2420
-4440
-8380
-ENDCHAR
-STARTCHAR char5311
-ENCODING 5663
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
-BITMAP
-8380
-4440
-2920
-1320
-2520
-4440
-8380
-ENDCHAR
-STARTCHAR char5311
-ENCODING 5664
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
-BITMAP
-8380
-4440
-2920
-17A0
-2520
-4440
-8380
-ENDCHAR
-STARTCHAR char5311
-ENCODING 5665
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 0
-BITMAP
-3820
-4440
-8480
-9900
-8280
-4440
-3820
-ENDCHAR
-STARTCHAR 0045
-ENCODING 5666
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 6 1 0
-BITMAP
-FC40
-0840
-1040
-1040
-0880
-0700
-ENDCHAR
-STARTCHAR 0045
-ENCODING 5667
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 6 1 0
+BBX 6 11 1 0
 BITMAP
-3800
-4400
-8200
-8200
-8400
-8FC0
+FC
+80
+80
+80
+FC
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5668
+STARTCHAR uni15B5
+ENCODING 5557
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
 BITMAP
-80
-80
-80
-B0
-C8
-84
 04
 04
 04
-08
-F0
+04
+04
+04
+FC
+04
+04
+04
+FC
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5669
+STARTCHAR uni15B6
+ENCODING 5558
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
@@ -49436,9222 +53178,9095 @@
 80
 80
 80
-B0
-C8
-84
-24
-24
-24
-08
-F0
-ENDCHAR
-STARTCHAR 0044
-ENCODING 5670
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
-BITMAP
 80
 80
 80
-B0
-C8
-84
-24
-74
-24
-08
-F0
+FC
+80
+80
+80
+FC
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5671
+STARTCHAR uni15B7
+ENCODING 5559
 SWIDTH 480 0
 DWIDTH 8 0
 BBX 6 11 1 0
 BITMAP
+FC
 04
 04
 04
-34
-4C
-84
+FC
+04
+04
+04
+04
+04
+04
+ENDCHAR
+STARTCHAR uni15B8
+ENCODING 5560
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+E2
+A2
+A2
+A2
+A2
+9C
 80
 80
 80
-40
-3C
-ENDCHAR
-STARTCHAR 0045
-ENCODING 5672
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 8 1 0
-BITMAP
-8000
-8000
-FC40
-8840
-9040
-1040
-0880
-0700
-ENDCHAR
-STARTCHAR 0045
-ENCODING 5673
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 8 1 -2
-BITMAP
-3800
-4400
-8200
-8240
-8440
-8FC0
-0040
-0040
+80
+80
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5674
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 0 0
+STARTCHAR uni15B9
+ENCODING 5561
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-F8
-20
-20
-2C
-32
-21
-01
-01
-01
 02
-3C
-ENDCHAR
-STARTCHAR 0044
-ENCODING 5675
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 0 0
-BITMAP
-F8
-20
-20
-2C
-32
-21
-09
-09
-09
 02
-3C
-ENDCHAR
-STARTCHAR 0044
-ENCODING 5676
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 0 0
-BITMAP
-F8
-20
-20
-2C
-32
-21
-09
-1D
-09
 02
-3C
+02
+02
+72
+8A
+8A
+8A
+8A
+8E
 ENDCHAR
-STARTCHAR 0044
-ENCODING 5677
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni15BA
+ENCODING 5562
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-1F
-04
-04
-34
-4C
-84
 80
 80
 80
-40
-3C
-ENDCHAR
-STARTCHAR char5678
-ENCODING 5678
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 7 1 0
-BITMAP
-F780
-2200
-4100
-4100
-4100
-2200
-1C00
+80
+80
+9C
+A2
+A2
+A2
+A2
+E2
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5679
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 7 1 0
+STARTCHAR uni15BB
+ENCODING 5563
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-1C00
-2200
-4100
-4100
-4100
-2200
-F780
+8E
+8A
+8A
+8A
+8A
+72
+02
+02
+02
+02
+02
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5680
+STARTCHAR uni15BC
+ENCODING 5564
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 9 1 0
+BBX 7 11 1 0
 BITMAP
+C2
+C2
+A4
+A4
+98
+98
 80
-B8
-C4
-82
-02
-82
-C4
-B8
+80
+80
+80
 80
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5681
+STARTCHAR uni15BD
+ENCODING 5565
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 9 1 0
+BBX 7 11 1 0
 BITMAP
-80
-B8
-C4
-92
-12
-92
-C4
-B8
-80
+02
+02
+02
+02
+02
+32
+32
+4A
+4A
+86
+86
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5682
+STARTCHAR uni15BE
+ENCODING 5566
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 9 1 0
+BBX 7 11 1 0
 BITMAP
 80
-B8
-C4
-92
-3A
-92
-C4
-B8
 80
+80
+80
+80
+98
+98
+A4
+A4
+C2
+C2
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5683
+STARTCHAR uni15BF
+ENCODING 5567
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 9 1 0
+BBX 7 11 1 0
 BITMAP
+86
+86
+4A
+4A
+32
+32
 02
-3A
-46
-82
-80
-82
-46
-3A
+02
+02
+02
 02
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5684
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 9 1 0
+STARTCHAR uni15C0
+ENCODING 5568
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-0020
-0020
-F7E0
-2220
-4120
-4100
-4100
-2200
-1C00
+0080
+0080
+0080
+0080
+7880
+8480
+8480
+8480
+0280
+0180
+0080
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5685
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 9 1 -2
+STARTCHAR uni15C1
+ENCODING 5569
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-0700
-0880
-1040
-1040
-9040
-8880
-FDE0
 8000
 8000
+8000
+8000
+8F00
+9080
+9080
+9080
+A000
+C000
+8000
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5686
+STARTCHAR uni15C2
+ENCODING 5570
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-F800
-2000
-2000
-2E00
-3100
-2080
 0080
-2080
-3100
-2E00
-2000
+0180
+0280
+8480
+8480
+8480
+7880
+0080
+0080
+0080
+0080
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5687
+STARTCHAR uni15C3
+ENCODING 5571
 SWIDTH 600 0
 DWIDTH 10 0
 BBX 9 11 1 0
 BITMAP
-F800
-2000
-2000
-2E00
-3100
-2480
-0480
-2480
-3100
-2E00
-2000
+8000
+C000
+A000
+9080
+9080
+9080
+8F00
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5688
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 10 1 0
+STARTCHAR uni15C4
+ENCODING 5572
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-E0
-40
-5C
-62
-49
-1D
-49
-62
-5C
-40
+8080
+8080
+4100
+4100
+3E00
+2200
+2200
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR char5678
-ENCODING 5689
-SWIDTH 600 0
-DWIDTH 10 0
+STARTCHAR uni15C5
+ENCODING 5573
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
-0F80
-0200
-0200
-3A00
-4600
-8200
-8000
-8200
-4600
-3A00
-0200
+0800
+0800
+1400
+1400
+2200
+2200
+3E00
+4100
+4100
+8080
+8080
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5690
+STARTCHAR uni15C6
+ENCODING 5574
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 9 1 0
+BBX 10 11 1 0
 BITMAP
-0040
-0040
-83C0
-8240
-9240
-9200
-9200
-9200
-6C00
+C000
+3000
+0C00
+0B00
+0880
+0840
+0880
+0B00
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5691
+STARTCHAR uni15C7
+ENCODING 5575
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 9 1 -2
+BBX 10 11 1 0
 BITMAP
-0D80
-1240
-1240
-1240
-9240
-9040
-F040
-8000
-8000
+C000
+3000
+0C00
+4B00
+4880
+4840
+4880
+4B00
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5692
+STARTCHAR uni15C8
+ENCODING 5576
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 10 1 0
+BBX 10 11 1 0
 BITMAP
-F800
-2000
-2000
-3F00
-0080
-0080
-0F00
-0080
-0080
-3F00
+C000
+3000
+0C00
+0B00
+4880
+E840
+4880
+0B00
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5693
+STARTCHAR uni15C9
+ENCODING 5577
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 10 1 0
+BBX 10 11 1 0
 BITMAP
-F800
-2000
-2000
-3F00
-0080
-0880
-0F00
-0880
-0080
-3F00
+00C0
+0300
+0C00
+3400
+4400
+8400
+4400
+3400
+0C00
+0300
+00C0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5694
+STARTCHAR uni15CA
+ENCODING 5578
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 10 1 0
+BBX 9 11 1 0
 BITMAP
-F800
-2000
-2000
-3F00
-0080
-0880
-1F00
-0880
-0080
-3F00
+8080
+8080
+7F00
+4100
+2200
+2200
+2200
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5695
+STARTCHAR uni15CB
+ENCODING 5579
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 10 1 0
+BBX 9 11 1 0
 BITMAP
-0F80
-0200
-0200
-7E00
-8000
-8000
-7800
-8000
-8000
-7E00
+0800
+0800
+1400
+1400
+2200
+2200
+2200
+4100
+7F00
+8080
+8080
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5696
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni15CC
+ENCODING 5580
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8020
-4040
-4040
-4040
-4040
-4040
-4040
-4040
-4040
+C000
+3000
+2C00
+2300
 2080
-1F00
-ENDCHAR
-STARTCHAR 0074
-ENCODING 5697
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
-BITMAP
-1F00
+2040
 2080
-4040
-4040
-4040
-4040
-4040
-4040
-4040
-4040
-8020
+2300
+2C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5698
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -1
+STARTCHAR uni15CD
+ENCODING 5581
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8000
-7F80
-0040
-0020
-0020
-0020
-0020
-0020
-0020
-0020
-0040
-7F80
-8000
+C000
+3000
+2C00
+2300
+2880
+2840
+2880
+2300
+2C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5699
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -1
+STARTCHAR uni15CE
+ENCODING 5582
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8000
-7F80
-0040
-0020
-0820
-0820
-0820
-0820
-0820
-0020
-0040
-7F80
-8000
+C000
+3000
+2C00
+2300
+2480
+2E40
+2480
+2300
+2C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5700
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -1
+STARTCHAR uni15CF
+ENCODING 5583
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8000
-7F80
-0040
-0020
-0020
-0820
-1C20
-0820
-0020
-0020
-0040
-7F80
-8000
+00C0
+0300
+0D00
+3100
+4100
+8100
+4100
+3100
+0D00
+0300
+00C0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5701
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 -1
+STARTCHAR uni15D0
+ENCODING 5584
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-0020
-3FC0
-4000
-8000
-8000
-8000
-8000
-8000
-8000
-4000
-3FC0
-0020
+8880
+8880
+4900
+4900
+2A00
+2A00
+2A00
+1C00
+1C00
+0800
+0800
 ENDCHAR
-STARTCHAR char5702
-ENCODING 5702
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 1 6
+STARTCHAR uni15D1
+ENCODING 5585
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-F8
-10
-20
-40
-F8
-ENDCHAR
-STARTCHAR char5702
-ENCODING 5703
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 9 1 4
+0800
+0800
+1C00
+1C00
+2A00
+2A00
+2A00
+4900
+4900
+8880
+8880
+ENDCHAR
+STARTCHAR uni15D2
+ENCODING 5586
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-20
-20
-F8
-30
-20
-60
-F8
-20
-20
+C000
+3000
+0C00
+0300
+0080
+FFC0
+0080
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5704
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni15D3
+ENCODING 5587
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-9F20
-4440
-4440
-4440
-4440
-4040
-4040
-4040
-4040
-2080
-1F00
+C000
+3000
+0C00
+4300
+4080
+FFC0
+4080
+4300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5705
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni15D4
+ENCODING 5588
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-1F00
+C000
+3000
+0C00
+0300
 2080
-4040
-4040
-4040
-4040
-4440
-4440
-4440
-4440
-9F20
+FFC0
+2080
+0300
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5706
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -1
+STARTCHAR uni15D5
+ENCODING 5589
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8000
-7F80
-0040
-0020
-8020
-8020
-F820
-8020
-8020
-0020
-0040
-7F80
-8000
+00C0
+0300
+0C00
+3000
+4000
+FFC0
+4000
+3000
+0C00
+0300
+00C0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5707
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -1
+STARTCHAR uni15D6
+ENCODING 5590
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-8000
-7F80
-0040
-0020
-8120
-8120
-F920
-8120
-8120
-0020
-0040
-7F80
-8000
+8880
+8880
+4900
+4900
+3E00
+2A00
+2A00
+1C00
+1C00
+0800
+0800
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5708
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -1
+STARTCHAR uni15D7
+ENCODING 5591
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-8000
-7F80
-0040
-0020
-8020
-8120
-FBA0
-8120
-8020
-0020
-0040
-7F80
-8000
+0800
+0800
+1C00
+1C00
+2A00
+2A00
+3E00
+4900
+4900
+8880
+8880
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5709
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -1
+STARTCHAR uni15D8
+ENCODING 5592
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0020
-3FC0
-4000
-8000
-8020
-8020
-83E0
-8020
-8020
-8000
-4000
-3FC0
-0020
+C000
+3000
+0C00
+0B00
+0880
+FFC0
+0880
+0B00
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5710
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15D9
+ENCODING 5593
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-8020
-4040
-4040
-4440
-4440
-4440
-4440
-4440
-4440
-2A80
-1100
+C000
+3000
+0C00
+4B00
+4880
+FFC0
+4880
+4B00
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5711
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15DA
+ENCODING 5594
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-1100
-2A80
-4440
-4440
-4440
-4440
-4440
-4440
-4040
-4040
-8020
+C000
+3000
+0C00
+0B00
+2880
+FFC0
+2880
+0B00
+0C00
+3000
+C000
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5712
+STARTCHAR uni15DB
+ENCODING 5595
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
+BITMAP
+00C0
+0300
+0C00
+3400
+4400
+FFC0
+4400
+3400
+0C00
+0300
+00C0
+ENDCHAR
+STARTCHAR uni15DC
+ENCODING 5596
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
+BITMAP
+FF80
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+4100
+3E00
+ENDCHAR
+STARTCHAR uni15DD
+ENCODING 5597
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
+BITMAP
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+FF80
+ENDCHAR
+STARTCHAR uni15DE
+ENCODING 5598
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
-02
-01
-01
-02
-3C
-02
-01
-01
-02
-7C
-80
+F8
+84
+82
+81
+81
+81
+81
+81
+82
+84
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5713
+STARTCHAR uni15DF
+ENCODING 5599
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
-02
-01
-41
-42
-7C
-42
-41
-01
-02
-7C
-80
+F8
+84
+82
+91
+91
+91
+91
+91
+82
+84
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5714
+STARTCHAR uni15E0
+ENCODING 5600
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
-02
-01
-01
-42
-FC
-42
-01
-01
-02
-7C
-80
+F8
+84
+82
+81
+91
+B9
+91
+81
+82
+84
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5715
+STARTCHAR uni15E1
+ENCODING 5601
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-01
-3E
-40
-80
-80
-40
-3C
-40
-80
-80
-40
-3E
-01
+1F
+21
+41
+81
+81
+81
+81
+81
+41
+21
+1F
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5716
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15E2
+ENCODING 5602
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-8420
-4440
-7FC0
-4440
-4440
-4440
-4440
-4440
-4440
-2A80
-1100
+8080
+C180
+A280
+9480
+8880
+8080
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5717
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15E3
+ENCODING 5603
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-1100
-2A80
-4440
-4440
-4440
-4440
-4440
-4440
-7FC0
-4440
-8420
+3E00
+4100
+8080
+8080
+8080
+8080
+8880
+9480
+A280
+C180
+8080
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5718
+STARTCHAR uni15E4
+ENCODING 5604
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
-42
+F8
+84
+82
 41
 41
-42
-FC
-42
+21
 41
 41
-42
-7C
-80
+82
+84
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5719
+STARTCHAR uni15E5
+ENCODING 5605
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
-42
-41
-51
-52
-FC
-52
-51
-41
-42
-7C
-80
+F8
+84
+82
+49
+49
+29
+49
+49
+82
+84
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5720
+STARTCHAR uni15E6
+ENCODING 5606
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
-42
-41
-41
-52
-FC
-52
+F8
+84
+82
 41
+49
+3D
+49
 41
-42
-7C
-80
+82
+84
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5721
+STARTCHAR uni15E7
+ENCODING 5607
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-01
-3E
-42
+1F
+21
+41
 82
 82
-42
-3F
-42
+84
 82
 82
-42
-3E
-01
-ENDCHAR
-STARTCHAR char5382
-ENCODING 5722
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 2
-BITMAP
-20
-20
-70
-A8
-A0
-70
-28
-A8
-70
-20
-20
+41
+21
+1F
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5723
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15E8
+ENCODING 5608
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-9F20
-4440
-7FC0
-4440
-4440
-4440
-4440
-4440
-4440
-2A80
-1100
+8080
+8080
+8080
+FF80
+8080
+8080
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5724
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15E9
+ENCODING 5609
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-1100
-2A80
-4440
-4440
-4440
-4440
-4440
-4440
-7FC0
-4440
-9F20
+3E00
+4100
+8080
+8080
+8080
+8080
+8080
+FF80
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5725
+STARTCHAR uni15EA
+ENCODING 5610
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
+F8
+24
 22
 21
-A1
-A2
-FC
-A2
-A1
 21
+21
+21
+21
 22
-7C
-80
+24
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5726
+STARTCHAR uni15EB
+ENCODING 5611
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
+F8
+24
 22
-21
-A9
-AA
-FC
-AA
-A9
-21
+29
+29
+29
+29
+29
 22
-7C
-80
+24
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5727
+STARTCHAR uni15EC
+ENCODING 5612
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
+F8
+24
 22
 21
-A1
-AA
-FC
-AA
-A1
+29
+3D
+29
 21
 22
-7C
-80
+24
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5728
+STARTCHAR uni15ED
+ENCODING 5613
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-01
-3E
+1F
+24
 44
 84
-85
-45
-3F
-45
-85
 84
+84
+84
+84
 44
-3E
-01
+24
+1F
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5729
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15EE
+ENCODING 5614
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 5 1 6
 BITMAP
-9F20
-4440
-4440
-4440
-4440
-4440
-4440
-4440
-4440
-2A80
-1100
+20
+20
+20
+20
+F8
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5730
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15EF
+ENCODING 5615
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-1100
-2A80
-4440
-4440
-4440
-4440
-4440
-4440
-4440
-4440
-9F20
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+5500
+2200
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5731
+STARTCHAR uni15F0
+ENCODING 5616
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
+BITMAP
+2200
+5500
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+ENDCHAR
+STARTCHAR uni15F1
+ENCODING 5617
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
+FC
 02
 01
-81
-82
+01
+02
 FC
-82
-81
+02
 01
+01
 02
-7C
-80
+FC
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5732
+STARTCHAR uni15F2
+ENCODING 5618
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
+FC
 02
 01
-91
-92
+41
+42
 FC
-92
-91
+42
+41
 01
 02
-7C
-80
+FC
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5733
+STARTCHAR uni15F3
+ENCODING 5619
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
-7C
+FC
 02
 01
-81
-92
+01
+22
 FC
-92
-81
+22
 01
+01
 02
-7C
-80
+FC
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5734
+STARTCHAR uni15F4
+ENCODING 5620
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-01
-3E
+3F
 40
 80
-81
-41
+80
+40
 3F
-41
-81
+40
 80
+80
 40
-3E
-01
+3F
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5735
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15F5
+ENCODING 5621
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-9F20
-64C0
-5540
-4E40
-4440
-4440
-4440
-4440
-4440
-2A80
-1100
+FF80
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+5500
+2200
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5736
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni15F6
+ENCODING 5622
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-1100
-2A80
-4440
-4440
-4440
-4440
-4440
-4E40
-5540
-64C0
-9F20
+2200
+5500
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+8880
+FF80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5737
+STARTCHAR uni15F7
+ENCODING 5623
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
 FC
 82
-41
-A1
-92
+81
+81
+82
 FC
-92
-A1
-41
+82
+81
+81
 82
 FC
-80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5738
+STARTCHAR uni15F8
+ENCODING 5624
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
 FC
-42
-41
-A9
-9A
+82
+81
+91
+92
 FC
-9A
-A9
-41
+92
+91
+81
 82
 FC
-80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5739
+STARTCHAR uni15F9
+ENCODING 5625
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-80
 FC
 82
-41
-A1
-9A
+81
+81
+92
 FC
-9A
-A1
-41
+92
+81
+81
 82
 FC
-80
 ENDCHAR
-STARTCHAR 0074
-ENCODING 5740
+STARTCHAR uni15FA
+ENCODING 5626
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 1 -1
+BBX 8 11 1 0
 BITMAP
-01
 3F
 41
-82
-85
-49
+81
+81
+41
 3F
-49
-85
-82
+41
+81
+81
 41
 3F
-01
-ENDCHAR
-STARTCHAR char5741
-ENCODING 5741
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 2 0
-BITMAP
-C020
-2040
-1080
-0900
-0A00
-0400
-0A00
-1200
-2100
-4080
-8060
-ENDCHAR
-STARTCHAR char5441
-ENCODING 5742
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 5 1 0
-BITMAP
-88
-50
-20
-50
-88
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5743
+STARTCHAR uni15FB
+ENCODING 5627
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
-BITMAP
-6780
-8840
-8840
-6840
-2840
-27C0
-0040
-0040
-0040
-0040
-0040
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5744
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 11 1 0
-BITMAP
-600F00
-901080
-901080
-7C0080
-040080
-048080
-048080
-030080
-000080
-000080
-000080
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5745
-SWIDTH 1380 0
-DWIDTH 23 0
-BBX 22 11 1 0
-BITMAP
-630078
-948084
-948084
-7BE080
-002080
-002480
-002480
-001880
-000080
-000080
-000080
-ENDCHAR
-STARTCHAR 0066
-ENCODING 5746
-SWIDTH 1380 0
-DWIDTH 23 0
-BBX 22 15 1 0
+BBX 9 11 1 0
 BITMAP
-000020
-000070
-000020
-000000
-630078
-948084
-948084
-7BE080
-002080
-002480
-002480
-001880
-000080
-000080
-000080
+8880
+C980
+AA80
+9C80
+8880
+8880
+8880
+8880
+8880
+5500
+2200
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5747
-SWIDTH 1380 0
-DWIDTH 23 0
-BBX 22 11 1 0
+STARTCHAR uni15FC
+ENCODING 5628
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-630004
-948004
-948004
-7BE004
-002004
-002404
-002404
-001804
-000084
-000084
-000078
+2200
+5500
+8880
+8880
+8880
+8880
+8880
+9C80
+AA80
+C980
+8880
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5748
-SWIDTH 1440 0
-DWIDTH 24 0
-BBX 23 15 1 0
+STARTCHAR uni15FD
+ENCODING 5629
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-000004
-00000E
-000004
-000000
-630004
-948004
-948004
-7BE004
-002004
-002404
-002404
-001804
-000084
-000084
-000078
+FC
+82
+41
+41
+22
+FC
+22
+41
+41
+82
+FC
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5749
-SWIDTH 1380 0
-DWIDTH 23 0
-BBX 22 11 1 0
+STARTCHAR uni15FE
+ENCODING 5630
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-630080
-948080
-948080
-7BE080
-002080
-002480
-002480
-001880
-000084
-000084
-000078
+FC
+82
+41
+49
+2A
+FC
+2A
+49
+41
+82
+FC
 ENDCHAR
-STARTCHAR 0066
-ENCODING 5750
-SWIDTH 1440 0
-DWIDTH 24 0
-BBX 23 15 1 0
+STARTCHAR uni15FF
+ENCODING 5631
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-000040
-0000E0
-000040
-000000
-630040
-948040
-948040
-7BE040
-002040
-002440
-002440
-001840
-000042
-000042
-00003C
+FC
+82
+41
+41
+2A
+FC
+2A
+41
+41
+82
+FC
 ENDCHAR
-STARTCHAR C065
-ENCODING 7680
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 15 0 -4
+STARTCHAR uni1600
+ENCODING 5632
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-0C00
-1200
-1200
-0C00
+3F
+41
+82
+82
+44
+3F
+44
+82
+82
+41
+3F
 ENDCHAR
-STARTCHAR C097
-ENCODING 7681
+STARTCHAR uni1601
+ENCODING 5633
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 11 1 -4
+BBX 5 6 1 5
 BITMAP
-70
-88
-08
-78
 88
 88
-7C
-30
-48
-48
-30
+50
+50
+20
+20
 ENDCHAR
-STARTCHAR C066
-ENCODING 7682
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 14 0 0
+STARTCHAR uni1602
+ENCODING 5634
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-0C00
-0C00
-0000
-FF00
-2080
-2040
-2040
-2080
-3F00
-2080
-2040
-2040
-2080
-FF00
+80
+80
+80
+80
+80
+80
+80
+80
+84
+84
+78
 ENDCHAR
-STARTCHAR C098
-ENCODING 7683
+STARTCHAR uni1603
+ENCODING 5635
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 0
+BBX 6 11 1 0
 BITMAP
-30
-30
-00
-C0
-40
-40
-40
-40
-78
-44
-44
-44
-44
-44
 78
+84
+84
+04
+04
+04
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR C066
-ENCODING 7684
+STARTCHAR uni1604
+ENCODING 5636
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 14 0 -3
-BITMAP
-FF00
-2080
-2040
-2040
-2080
-3F00
-2080
-2040
-2040
-2080
-FF00
-0000
-0C00
-0C00
-ENDCHAR
-STARTCHAR C098
-ENCODING 7685
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 -3
+BBX 10 6 1 0
 BITMAP
-C0
-40
-40
-40
-40
-78
-44
-44
-44
-44
-44
-78
-00
-30
-30
+FF80
+0040
+0040
+0040
+0040
+0380
 ENDCHAR
-STARTCHAR C066
-ENCODING 7686
+STARTCHAR uni1605
+ENCODING 5637
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 13 0 -2
+BBX 10 6 1 0
 BITMAP
-FF00
-2080
-2040
-2040
-2080
-3F00
-2080
-2040
-2040
-2080
-FF00
-0000
-1F00
+FF80
+0040
+0840
+0840
+0840
+0380
 ENDCHAR
-STARTCHAR C098
-ENCODING 7687
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 -2
+STARTCHAR uni1606
+ENCODING 5638
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 6 1 0
 BITMAP
-C0
-40
-40
-40
-40
-78
-44
-44
-44
-44
-44
-78
-00
-7C
+FF80
+0040
+0840
+1C40
+0840
+0380
 ENDCHAR
-STARTCHAR C067
-ENCODING 7688
+STARTCHAR uni1607
+ENCODING 5639
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 19 1 -3
+BBX 10 6 1 0
 BITMAP
-0400
-0C00
-0800
-1000
-0000
-1E80
-2180
-4080
-8080
+7000
 8000
 8000
 8000
-8080
-4080
-2100
-1E00
-0800
-0400
-1C00
+8000
+7FC0
 ENDCHAR
-STARTCHAR C099
-ENCODING 7689
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 -3
+STARTCHAR uni1608
+ENCODING 5640
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-10
-30
-20
-40
-00
-70
-88
 80
 80
 80
-88
-70
-20
-10
-70
-ENDCHAR
-STARTCHAR C068
-ENCODING 7690
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 14 0 0
-BITMAP
-0C00
-0C00
-0000
-FE00
-2180
-2080
-2040
-2040
-2040
-2040
-2040
-2080
-2180
-FE00
+80
+80
+92
+92
+92
+92
+92
+6C
 ENDCHAR
-STARTCHAR C100
-ENCODING 7691
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 0
+STARTCHAR uni1609
+ENCODING 5641
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-30
-30
-00
-18
-08
-08
-08
-08
-78
-88
-88
-88
-88
-88
-7C
+6C
+92
+92
+92
+92
+92
+02
+02
+02
+02
+02
 ENDCHAR
-STARTCHAR C068
-ENCODING 7692
+STARTCHAR uni160A
+ENCODING 5642
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 14 0 -3
-BITMAP
-FE00
-2180
-2080
-2040
-2040
-2040
-2040
-2040
-2080
-2180
-FE00
-0000
-0C00
-0C00
-ENDCHAR
-STARTCHAR C100
-ENCODING 7693
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 -3
+BBX 10 11 1 0
 BITMAP
-18
-08
-08
-08
-08
-78
-88
-88
-88
-88
-88
-7C
-00
-30
-30
+FF80
+0040
+0040
+0040
+0040
+0780
+0040
+0040
+0040
+0040
+0780
 ENDCHAR
-STARTCHAR C068
-ENCODING 7694
+STARTCHAR uni160B
+ENCODING 5643
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 13 0 -2
-BITMAP
-FE00
-2180
-2080
-2040
-2040
-2040
-2040
-2040
-2080
-2180
-FE00
-0000
-3E00
-ENDCHAR
-STARTCHAR C100
-ENCODING 7695
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 -2
+BBX 10 11 1 0
 BITMAP
-18
-08
-08
-08
-08
-78
-88
-88
-88
-88
-88
-7C
-00
-F8
+FF80
+0040
+0040
+0840
+0840
+0F80
+0840
+0840
+0040
+0040
+0780
 ENDCHAR
-STARTCHAR C068
-ENCODING 7696
+STARTCHAR uni160C
+ENCODING 5644
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 14 0 -3
-BITMAP
-FE00
-2180
-2080
-2040
-2040
-2040
-2040
-2040
-2080
-2180
-FE00
-0800
-0400
-1C00
-ENDCHAR
-STARTCHAR C100
-ENCODING 7697
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 -3
+BBX 10 11 1 0
 BITMAP
-18
-08
-08
-08
-08
-78
-88
-88
-88
-88
-88
-7C
-20
-10
-70
+FF80
+0040
+0040
+0040
+0840
+1F80
+0840
+0040
+0040
+0040
+0780
 ENDCHAR
-STARTCHAR C032
-ENCODING 7698
+STARTCHAR uni160D
+ENCODING 5645
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 15 0 -4
-BITMAP
-FE00
-2180
-2080
-2040
-2040
-2040
-2040
-2040
-2080
-2180
-FE00
-0000
-0800
-1C00
-2200
-ENDCHAR
-STARTCHAR C100
-ENCODING 7699
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+BBX 10 11 1 0
 BITMAP
-18
-08
-08
-08
-08
-78
-88
-88
-88
-88
-88
-7C
-00
-20
-70
-88
+7800
+8000
+8000
+8000
+8000
+7800
+8000
+8000
+8000
+8000
+7FC0
 ENDCHAR
-STARTCHAR C069
-ENCODING 7700
+STARTCHAR uni160E
+ENCODING 5646
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 18 0 0
+BBX 9 11 1 0
 BITMAP
-1000
-1800
-0800
-0400
-0000
-3E00
-0000
-FF80
-2080
-2080
-2280
-2200
+8600
+8900
+9080
+9080
+8880
+8080
+8080
+8080
+8080
+4100
 3E00
-2240
-2240
-2080
-2080
-FF80
-ENDCHAR
-STARTCHAR C101
-ENCODING 7701
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 0
-BITMAP
-40
-60
-20
-10
-00
-F8
-00
-70
-88
-F8
-80
-80
-88
-70
 ENDCHAR
-STARTCHAR C069
-ENCODING 7702
+STARTCHAR uni160F
+ENCODING 5647
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 18 0 0
+BBX 9 11 1 0
 BITMAP
-0400
-0C00
-0800
-1000
-0000
 3E00
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
+4100
+8080
+8080
+8080
+8080
+8880
+8480
+8480
+4880
+3080
 ENDCHAR
-STARTCHAR C101
-ENCODING 7703
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 0
+STARTCHAR uni1610
+ENCODING 5648
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-10
-30
-20
-40
-00
-F8
-00
-70
-88
 F8
-80
-80
-88
-70
+04
+02
+01
+61
+91
+91
+81
+82
+44
+38
 ENDCHAR
-STARTCHAR C069
-ENCODING 7704
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 0 -4
+STARTCHAR uni1611
+ENCODING 5649
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
-0000
-0800
-1C00
-2200
+F8
+04
+02
+11
+51
+B1
+91
+91
+82
+44
+38
 ENDCHAR
-STARTCHAR C101
-ENCODING 7705
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 -4
+STARTCHAR uni1612
+ENCODING 5650
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-70
-88
 F8
-80
+04
+02
+01
+51
+B9
+91
+81
+82
+44
+38
+ENDCHAR
+STARTCHAR uni1613
+ENCODING 5651
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
+BITMAP
+1C
+22
+41
+81
+89
+89
+86
 80
-88
-70
-00
+40
 20
-70
-88
+1F
 ENDCHAR
-STARTCHAR C069
-ENCODING 7706
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 0 -4
+STARTCHAR uni1614
+ENCODING 5652
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
-0000
-1200
-2A00
-2400
+FE
+84
+08
+10
+20
+4C
+92
+92
+82
+44
+38
 ENDCHAR
-STARTCHAR C101
-ENCODING 7707
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 -4
+STARTCHAR uni1615
+ENCODING 5653
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-70
-88
-F8
-80
-80
-88
-70
-00
-48
-A8
-90
+FE
+42
+20
+10
+08
+64
+92
+92
+82
+44
+38
 ENDCHAR
-STARTCHAR C069
-ENCODING 7708
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 0 -3
+STARTCHAR uni1616
+ENCODING 5654
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-2100
-1E00
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
-0800
-0400
-1C00
-ENDCHAR
-STARTCHAR C101
-ENCODING 7709
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 13 0 -3
-BITMAP
-84
-78
-00
-38
-44
-7C
-40
-40
-44
-38
-10
-08
-38
-ENDCHAR
-STARTCHAR C070
-ENCODING 7710
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 0 0
-BITMAP
-1800
-1800
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2200
-2200
-2000
-2000
-F800
-ENDCHAR
-STARTCHAR C102
-ENCODING 7711
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 0
-BITMAP
-60
-60
-00
 38
-48
-40
-40
-40
-F0
-40
-40
-40
-40
-40
-E0
-ENDCHAR
-STARTCHAR C071
-ENCODING 7712
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 1 0
-BITMAP
-3E00
-0000
-1E80
-2180
-4080
-8080
-8000
-8000
-83C0
-8080
-4080
-2080
-1F80
-ENDCHAR
-STARTCHAR C103
-ENCODING 7713
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 13 1 -4
-BITMAP
-7C
-00
-3E
 44
-44
-44
-78
-40
-7C
-82
 82
-82
-7C
+92
+92
+64
+08
+10
+20
+42
+FE
 ENDCHAR
-STARTCHAR C072
-ENCODING 7714
+STARTCHAR uni1617
+ENCODING 5655
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 0 0
+BBX 11 7 1 0
 BITMAP
-0C00
-0C00
-0000
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-FBE0
+C380
+8440
+8820
+9320
+A420
+C440
+8380
 ENDCHAR
-STARTCHAR C104
-ENCODING 7715
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 15 1 0
+STARTCHAR uni1618
+ENCODING 5656
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
 BITMAP
-30
-30
-00
-C0
-40
-40
-40
-40
-78
-44
-44
-44
-44
-44
-EE
+C380
+8440
+8920
+9320
+A520
+C440
+8380
 ENDCHAR
-STARTCHAR C072
-ENCODING 7716
+STARTCHAR uni1619
+ENCODING 5657
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 0 -3
+BBX 11 7 1 0
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-FBE0
-0000
-0C00
-0C00
+C380
+8440
+8920
+97A0
+A520
+C440
+8380
 ENDCHAR
-STARTCHAR C104
-ENCODING 7717
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 15 1 -3
+STARTCHAR uni161A
+ENCODING 5658
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
 BITMAP
-C0
-40
-40
-40
-40
-78
-44
-44
-44
-44
-44
-EE
-00
-18
-18
+8380
+C440
+A420
+9320
+8820
+8440
+C380
 ENDCHAR
-STARTCHAR C072
-ENCODING 7718
+STARTCHAR uni161B
+ENCODING 5659
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 0 0
+BBX 11 7 1 0
 BITMAP
-1B00
-1B00
-0000
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-FBE0
+3820
+4460
+84A0
+9920
+8220
+4420
+3860
 ENDCHAR
-STARTCHAR C104
-ENCODING 7719
+STARTCHAR uni161C
+ENCODING 5660
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 0
+BBX 7 11 1 0
 BITMAP
-D8
-D8
-00
-C0
-40
-40
-40
-40
-78
-44
-44
-44
+82
 44
+28
+10
+20
+4C
+92
+92
+82
 44
-EE
-ENDCHAR
-STARTCHAR C072
-ENCODING 7720
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 14 0 -3
-BITMAP
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-FBE0
-1000
-0800
-3800
+38
 ENDCHAR
-STARTCHAR C104
-ENCODING 7721
+STARTCHAR uni161D
+ENCODING 5661
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 -3
+BBX 7 11 1 0
 BITMAP
-C0
-40
-40
-40
-40
-78
-44
-44
-44
+38
 44
+82
+92
+92
+64
+08
+10
+28
 44
-EE
-40
-20
-E0
+82
 ENDCHAR
-STARTCHAR C072
-ENCODING 7722
+STARTCHAR uni161E
+ENCODING 5662
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 0 -3
-BITMAP
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-FBE0
-0000
-1080
-0F00
-ENDCHAR
-STARTCHAR C104
-ENCODING 7723
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 15 1 -3
+BBX 11 7 1 0
 BITMAP
-C0
-40
-40
-40
-40
-78
-44
-44
-44
-44
-44
-EE
-00
-42
-3C
+8380
+4440
+2820
+1320
+2420
+4440
+8380
 ENDCHAR
-STARTCHAR C073
-ENCODING 7724
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 -4
+STARTCHAR uni161F
+ENCODING 5663
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
 BITMAP
-F8
-20
-20
-20
-20
-20
-20
-20
-20
-20
-F8
-00
-48
-A8
-90
+8380
+4440
+2920
+1320
+2520
+4440
+8380
 ENDCHAR
-STARTCHAR C105
-ENCODING 7725
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 5 11 0 -4
+STARTCHAR uni1620
+ENCODING 5664
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
 BITMAP
-60
-20
-20
-20
-20
-20
-70
-00
-48
-A8
-90
+8380
+4440
+2920
+17A0
+2520
+4440
+8380
 ENDCHAR
-STARTCHAR C073
-ENCODING 7726
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 19 1 0
+STARTCHAR uni1621
+ENCODING 5665
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
 BITMAP
-10
-30
-20
-40
-00
-D8
-D8
-00
-F8
-20
-20
-20
-20
-20
-20
-20
-20
-20
-F8
+3820
+4440
+8480
+9900
+8280
+4440
+3820
 ENDCHAR
-STARTCHAR C105
-ENCODING 7727
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 5 15 0 0
+STARTCHAR uni1622
+ENCODING 5666
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 0
 BITMAP
-10
-30
-20
-40
-00
-D8
-D8
-00
-60
-20
-20
-20
-20
-20
-70
+FC40
+0840
+1040
+1040
+0880
+0700
 ENDCHAR
-STARTCHAR C075
-ENCODING 7728
+STARTCHAR uni1623
+ENCODING 5667
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 16 1 0
+BBX 10 6 1 0
 BITMAP
-0200
-0600
-0400
-0800
-0000
-F9E0
-2080
-2100
-2200
-2400
-2E00
-3200
-2100
-2100
-2080
-F9E0
+3800
+4400
+8200
+8200
+8400
+8FC0
 ENDCHAR
-STARTCHAR C107
-ENCODING 7729
+STARTCHAR uni1624
+ENCODING 5668
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 17 1 0
+BBX 6 11 1 0
 BITMAP
+80
+80
+80
+B0
+C8
+84
+04
+04
+04
 08
-18
-10
-20
-00
-C0
-40
-40
-40
-40
-5E
-48
-50
-70
-58
-48
-EE
+F0
 ENDCHAR
-STARTCHAR C075
-ENCODING 7730
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 14 1 -3
+STARTCHAR uni1625
+ENCODING 5669
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
 BITMAP
-F9E0
-2080
-2100
-2200
-2400
-2E00
-3200
-2100
-2100
-2080
-F9E0
-0000
-0600
-0600
+80
+80
+80
+B0
+C8
+84
+24
+24
+24
+08
+F0
 ENDCHAR
-STARTCHAR C107
-ENCODING 7731
+STARTCHAR uni1626
+ENCODING 5670
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 -3
+BBX 6 11 1 0
 BITMAP
-C0
-40
-40
-40
+80
+80
+80
+B0
+C8
+84
+24
+74
+24
+08
+F0
+ENDCHAR
+STARTCHAR uni1627
+ENCODING 5671
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
+BITMAP
+04
+04
+04
+34
+4C
+84
+80
+80
+80
 40
-5E
-48
-50
-70
-58
-48
-EE
-00
-30
-30
+3C
 ENDCHAR
-STARTCHAR C075
-ENCODING 7732
+STARTCHAR uni1628
+ENCODING 5672
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 13 1 -2
+BBX 10 8 1 0
 BITMAP
-F9E0
-2080
-2100
-2200
-2400
-2E00
-3200
-2100
-2100
-2080
-F9E0
-0000
-1F00
+8000
+8000
+FC40
+8840
+9040
+1040
+0880
+0700
 ENDCHAR
-STARTCHAR C107
-ENCODING 7733
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 14 1 -2
+STARTCHAR uni1629
+ENCODING 5673
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 8 1 -2
 BITMAP
-C0
-40
-40
-40
-40
-5E
-48
-50
-70
-58
-48
-EE
-00
-7C
+3800
+4400
+8200
+8240
+8440
+8FC0
+0040
+0040
 ENDCHAR
-STARTCHAR C076
-ENCODING 7734
+STARTCHAR uni162A
+ENCODING 5674
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 14 0 -3
+BBX 8 11 0 0
 BITMAP
 F8
 20
-20
-20
-20
 20
-21
-21
+2C
+32
 21
-23
-FF
-00
-18
-18
-ENDCHAR
-STARTCHAR C108
-ENCODING 7735
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 15 1 -3
-BITMAP
-C0
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
-E0
-00
-60
-60
+01
+01
+01
+02
+3C
 ENDCHAR
-STARTCHAR C076
-ENCODING 7736
+STARTCHAR uni162B
+ENCODING 5675
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 16 0 -3
+BBX 8 11 0 0
 BITMAP
 F8
-00
-F8
-20
-20
-20
 20
 20
-21
-21
+2C
+32
 21
-23
-FF
-00
-18
-18
-ENDCHAR
-STARTCHAR C108
-ENCODING 7737
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 5 17 0 -3
-BITMAP
-F8
-00
-60
-20
-20
-20
-20
-20
-20
-20
-20
-20
-20
-70
-00
-30
-30
+09
+09
+09
+02
+3C
 ENDCHAR
-STARTCHAR C076
-ENCODING 7738
+STARTCHAR uni162C
+ENCODING 5676
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 0 -2
+BBX 8 11 0 0
 BITMAP
 F8
 20
-20
-20
-20
 20
-21
-21
+2C
+32
 21
-23
-FF
-00
-3E
-ENDCHAR
-STARTCHAR C108
-ENCODING 7739
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 5 14 0 -2
-BITMAP
-60
-20
-20
-20
-20
-20
-20
-20
-20
-20
-20
-70
-00
-F8
+09
+1D
+09
+02
+3C
 ENDCHAR
-STARTCHAR C076
-ENCODING 7740
+STARTCHAR uni162D
+ENCODING 5677
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 15 0 -4
+BBX 8 11 1 0
 BITMAP
-F8
-20
-20
-20
-20
-20
-21
-21
-21
-23
-FF
-00
-10
-38
-44
+1F
+04
+04
+34
+4C
+84
+80
+80
+80
+40
+3C
 ENDCHAR
-STARTCHAR C108
-ENCODING 7741
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 5 16 0 -4
+STARTCHAR uni162E
+ENCODING 5678
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 7 1 0
 BITMAP
-60
-20
-20
-20
-20
-20
-20
-20
-20
-20
-20
-70
-00
-20
-70
-88
+F780
+2200
+4100
+4100
+4100
+2200
+1C00
 ENDCHAR
-STARTCHAR C077
-ENCODING 7742
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 16 1 0
+STARTCHAR uni162F
+ENCODING 5679
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 7 1 0
 BITMAP
-0100
-0300
-0200
-0400
-0000
-F03C
-3030
-3030
-2850
-2850
-2890
-2490
-2490
-2310
-2310
-FB7C
+1C00
+2200
+4100
+4100
+4100
+2200
+F780
 ENDCHAR
-STARTCHAR C109
-ENCODING 7743
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 0
+STARTCHAR uni1630
+ENCODING 5680
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 9 1 0
 BITMAP
-0200
-0600
-0400
-0800
-0000
-FB80
-4440
-4440
-4440
-4440
-4440
-E660
+80
+B8
+C4
+82
+02
+82
+C4
+B8
+80
 ENDCHAR
-STARTCHAR C077
-ENCODING 7744
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 14 1 0
+STARTCHAR uni1631
+ENCODING 5681
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 9 1 0
 BITMAP
-0300
-0300
-0000
-F03C
-3030
-3030
-2850
-2850
-2890
-2490
-2490
-2310
-2310
-FB7C
+80
+B8
+C4
+92
+12
+92
+C4
+B8
+80
 ENDCHAR
-STARTCHAR C109
-ENCODING 7745
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 10 1 0
+STARTCHAR uni1632
+ENCODING 5682
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 9 1 0
 BITMAP
-0C00
-0C00
-0000
-FB80
-4440
-4440
-4440
-4440
-4440
-E660
+80
+B8
+C4
+92
+3A
+92
+C4
+B8
+80
 ENDCHAR
-STARTCHAR C077
-ENCODING 7746
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 14 1 -3
+STARTCHAR uni1633
+ENCODING 5683
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 9 1 0
 BITMAP
-F03C
-3030
-3030
-2850
-2850
-2890
-2490
-2490
-2310
-2310
-FB7C
-0000
-0300
-0300
+02
+3A
+46
+82
+80
+82
+46
+3A
+02
 ENDCHAR
-STARTCHAR C109
-ENCODING 7747
+STARTCHAR uni1634
+ENCODING 5684
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 10 1 -3
+BBX 11 9 1 0
 BITMAP
-FB80
-4440
-4440
-4440
-4440
-4440
-E660
-0000
-0C00
-0C00
+0020
+0020
+F7E0
+2220
+4120
+4100
+4100
+2200
+1C00
 ENDCHAR
-STARTCHAR C078
-ENCODING 7748
+STARTCHAR uni1635
+ENCODING 5685
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 1 0
+BBX 11 9 1 -2
 BITMAP
-0C00
-0C00
-0000
-E3E0
-3080
-3080
-2880
-2880
-2480
-2280
-2280
-2180
-2180
-F880
+0700
+0880
+1040
+1040
+9040
+8880
+FDE0
+8000
+8000
 ENDCHAR
-STARTCHAR C110
-ENCODING 7749
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 10 1 0
+STARTCHAR uni1636
+ENCODING 5686
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-30
-30
-00
-F8
-44
-44
-44
-44
-44
-EE
+F800
+2000
+2000
+2E00
+3100
+2080
+0080
+2080
+3100
+2E00
+2000
 ENDCHAR
-STARTCHAR C078
-ENCODING 7750
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 14 1 -3
+STARTCHAR uni1637
+ENCODING 5687
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-E3E0
-3080
-3080
-2880
-2880
+F800
+2000
+2000
+2E00
+3100
 2480
-2280
-2280
-2180
-2180
-F880
-0000
-0C00
-0C00
+0480
+2480
+3100
+2E00
+2000
 ENDCHAR
-STARTCHAR C110
-ENCODING 7751
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 10 1 -3
+STARTCHAR uni1638
+ENCODING 5688
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
 BITMAP
-F8
-44
-44
-44
-44
-44
-EE
-00
-18
-18
+E0
+40
+5C
+62
+49
+1D
+49
+62
+5C
+40
 ENDCHAR
-STARTCHAR C078
-ENCODING 7752
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -2
+STARTCHAR uni1639
+ENCODING 5689
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-E3E0
-3080
-3080
-2880
-2880
-2480
-2280
-2280
-2180
-2180
-F880
-0000
-1F00
+0F80
+0200
+0200
+3A00
+4600
+8200
+8000
+8200
+4600
+3A00
+0200
 ENDCHAR
-STARTCHAR C110
-ENCODING 7753
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 9 1 -2
+STARTCHAR uni163A
+ENCODING 5690
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 9 1 0
 BITMAP
-F8
-44
-44
-44
-44
-44
-EE
-00
-7C
+0040
+0040
+83C0
+8240
+9240
+9200
+9200
+9200
+6C00
 ENDCHAR
-STARTCHAR C078
-ENCODING 7754
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 -4
+STARTCHAR uni163B
+ENCODING 5691
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 9 1 -2
 BITMAP
-E3E0
-3080
-3080
-2880
-2880
-2480
-2280
-2280
-2180
-2180
-F880
-0000
-0400
-0E00
-1100
+0D80
+1240
+1240
+1240
+9240
+9040
+F040
+8000
+8000
 ENDCHAR
-STARTCHAR C110
-ENCODING 7755
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 -4
+STARTCHAR uni163C
+ENCODING 5692
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 0
 BITMAP
-F8
-4C
-44
-44
-44
-44
-EE
-00
-10
-38
-44
+F800
+2000
+2000
+3F00
+0080
+0080
+0F00
+0080
+0080
+3F00
 ENDCHAR
-STARTCHAR C079
-ENCODING 7756
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 20 1 0
+STARTCHAR uni163D
+ENCODING 5693
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 0
 BITMAP
-0400
-0C00
-0800
-1000
-0000
-1200
-2A00
-2400
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+F800
+2000
+2000
+3F00
+0080
+0880
+0F00
+0880
+0080
+3F00
 ENDCHAR
-STARTCHAR C111
-ENCODING 7757
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 16 1 0
+STARTCHAR uni163E
+ENCODING 5694
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 0
 BITMAP
-10
-30
-20
-40
-00
-48
-A8
-90
-00
-70
-88
-88
-88
-88
-88
-70
+F800
+2000
+2000
+3F00
+0080
+0880
+1F00
+0880
+0080
+3F00
 ENDCHAR
-STARTCHAR C079
-ENCODING 7758
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 18 1 0
+STARTCHAR uni163F
+ENCODING 5695
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 0
 BITMAP
-3600
-3600
-0000
-1200
-2A00
-2400
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+0F80
+0200
+0200
+7E00
+8000
+8000
+7800
+8000
+8000
+7E00
 ENDCHAR
-STARTCHAR C111
-ENCODING 7759
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 0
+STARTCHAR uni1640
+ENCODING 5696
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-D8
-D8
-00
-48
-A8
-90
-00
-70
-88
-88
-88
-88
-88
-70
+8020
+4040
+4040
+4040
+4040
+4040
+4040
+4040
+4040
+2080
+1F00
 ENDCHAR
-STARTCHAR C079
-ENCODING 7760
+STARTCHAR uni1641
+ENCODING 5697
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
+BITMAP
+1F00
+2080
+4040
+4040
+4040
+4040
+4040
+4040
+4040
+4040
+8020
+ENDCHAR
+STARTCHAR uni1642
+ENCODING 5698
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 18 1 0
+BBX 11 13 1 -1
 BITMAP
-1000
-1800
-0800
-0400
-0000
-3E00
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+8000
+7F80
+0040
+0020
+0020
+0020
+0020
+0020
+0020
+0020
+0040
+7F80
+8000
 ENDCHAR
-STARTCHAR C111
-ENCODING 7761
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 0
+STARTCHAR uni1643
+ENCODING 5699
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -1
 BITMAP
-40
-60
-20
-10
-00
-F8
-00
-70
-88
-88
-88
-88
-88
-70
+8000
+7F80
+0040
+0020
+0820
+0820
+0820
+0820
+0820
+0020
+0040
+7F80
+8000
 ENDCHAR
-STARTCHAR C079
-ENCODING 7762
+STARTCHAR uni1644
+ENCODING 5700
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 18 1 0
+BBX 11 13 1 -1
 BITMAP
-0400
-0C00
-0800
-1000
-0000
-3E00
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+8000
+7F80
+0040
+0020
+0020
+0820
+1C20
+0820
+0020
+0020
+0040
+7F80
+8000
 ENDCHAR
-STARTCHAR C111
-ENCODING 7763
+STARTCHAR uni1645
+ENCODING 5701
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 12 1 -1
+BITMAP
+0020
+3FC0
+4000
+8000
+8000
+8000
+8000
+8000
+8000
+4000
+3FC0
+0020
+ENDCHAR
+STARTCHAR uni1646
+ENCODING 5702
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 14 1 0
+BBX 5 5 1 6
 BITMAP
+F8
 10
-30
 20
 40
-00
 F8
-00
-70
-88
-88
-88
-88
-88
-70
-ENDCHAR
-STARTCHAR C080
-ENCODING 7764
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 16 0 0
-BITMAP
-0400
-0C00
-0800
-1000
-0000
-FF00
-2180
-2080
-2080
-2180
-3F00
-2000
-2000
-2000
-2000
-F800
 ENDCHAR
-STARTCHAR C112
-ENCODING 7765
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 -3
+STARTCHAR uni1647
+ENCODING 5703
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 4
 BITMAP
-10
-30
 20
-40
-00
+20
 F8
-44
-44
-44
-44
-44
-78
-40
-40
-E0
-ENDCHAR
-STARTCHAR C080
-ENCODING 7766
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 0 0
-BITMAP
-1800
-1800
-0000
-FF00
-2180
-2080
-2080
-2180
-3F00
-2000
-2000
-2000
-2000
-F800
-ENDCHAR
-STARTCHAR C112
-ENCODING 7767
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 13 1 -3
-BITMAP
 30
-30
-00
+20
+60
 F8
-44
-44
-44
-44
-44
-78
-40
-40
-E0
+20
+20
 ENDCHAR
-STARTCHAR C082
-ENCODING 7768
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 1 0
+STARTCHAR uni1648
+ENCODING 5704
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-1800
-1800
-0000
-FE00
-2100
-2080
+9F20
+4440
+4440
+4440
+4440
+4040
+4040
+4040
+4040
 2080
-2100
-3E00
-2300
-2100
-2100
-2100
-F8E0
+1F00
 ENDCHAR
-STARTCHAR C114
-ENCODING 7769
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 0
+STARTCHAR uni1649
+ENCODING 5705
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-60
-60
-00
-D0
-68
-40
-40
-40
-40
-F0
+1F00
+2080
+4040
+4040
+4040
+4040
+4440
+4440
+4440
+4440
+9F20
 ENDCHAR
-STARTCHAR C082
-ENCODING 7770
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 1 -3
+STARTCHAR uni164A
+ENCODING 5706
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -1
 BITMAP
-FE00
-2100
-2080
-2080
-2100
-3E00
-2300
-2100
-2100
-2100
-F8E0
-0000
-0C00
-0C00
+8000
+7F80
+0040
+0020
+8020
+8020
+F820
+8020
+8020
+0020
+0040
+7F80
+8000
 ENDCHAR
-STARTCHAR C114
-ENCODING 7771
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 -3
+STARTCHAR uni164B
+ENCODING 5707
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -1
 BITMAP
-D0
-68
-40
-40
-40
-40
-F0
-00
-60
-60
+8000
+7F80
+0040
+0020
+8120
+8120
+F920
+8120
+8120
+0020
+0040
+7F80
+8000
 ENDCHAR
-STARTCHAR C082
-ENCODING 7772
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 16 1 -3
+STARTCHAR uni164C
+ENCODING 5708
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -1
 BITMAP
-3E00
-0000
-FE00
-2100
-2080
-2080
-2100
-3E00
-2300
-2100
-2100
-2100
-F8E0
-0000
-0C00
-0C00
+8000
+7F80
+0040
+0020
+8020
+8120
+FBA0
+8120
+8020
+0020
+0040
+7F80
+8000
 ENDCHAR
-STARTCHAR C114
-ENCODING 7773
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 12 1 -3
+STARTCHAR uni164D
+ENCODING 5709
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -1
 BITMAP
-F8
-00
-D0
-68
-40
-40
-40
-40
-F0
-00
-60
-60
+0020
+3FC0
+4000
+8000
+8020
+8020
+83E0
+8020
+8020
+8000
+4000
+3FC0
+0020
 ENDCHAR
-STARTCHAR C082
-ENCODING 7774
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 13 1 -2
+STARTCHAR uni164E
+ENCODING 5710
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-FE00
-2100
-2080
-2080
-2100
-3E00
-2300
-2100
-2100
-2100
-F8E0
-0000
-1F00
+8020
+4040
+4040
+4440
+4440
+4440
+4440
+4440
+4440
+2A80
+1100
 ENDCHAR
-STARTCHAR C114
-ENCODING 7775
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 9 1 -2
+STARTCHAR uni164F
+ENCODING 5711
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-D0
-68
-40
-40
-40
-40
-F0
-00
-F8
+1100
+2A80
+4440
+4440
+4440
+4440
+4440
+4440
+4040
+4040
+8020
 ENDCHAR
-STARTCHAR C083
-ENCODING 7776
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 0
+STARTCHAR uni1650
+ENCODING 5712
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-30
-30
-00
+80
 7C
-84
-84
+02
+01
+01
+02
+3C
+02
+01
+01
+02
+7C
 80
-40
-30
-08
-04
-84
-84
-F8
 ENDCHAR
-STARTCHAR C115
-ENCODING 7777
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 0
+STARTCHAR uni1651
+ENCODING 5713
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-60
-60
-00
-78
-88
 80
-70
-08
-88
-F0
-ENDCHAR
-STARTCHAR C083
-ENCODING 7778
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 -3
-BITMAP
 7C
-84
-84
+02
+01
+41
+42
+7C
+42
+41
+01
+02
+7C
 80
-40
-30
-08
-04
-84
-84
-F8
-00
-30
-30
 ENDCHAR
-STARTCHAR C115
-ENCODING 7779
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 -3
+STARTCHAR uni1652
+ENCODING 5714
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-78
-88
 80
-70
-08
-88
-F0
-00
-60
-60
-ENDCHAR
-STARTCHAR C083
-ENCODING 7780
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 19 1 0
-BITMAP
-30
-30
-00
-08
-18
-10
-20
-00
 7C
-84
-84
+02
+01
+01
+42
+FC
+42
+01
+01
+02
+7C
 80
-40
-30
-08
-04
-84
-84
-F8
 ENDCHAR
-STARTCHAR C115
-ENCODING 7781
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 0
+STARTCHAR uni1653
+ENCODING 5715
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-60
-60
-00
-10
-30
-20
+01
+3E
 40
-00
-78
-88
 80
-70
-08
-88
-F0
-ENDCHAR
-STARTCHAR C083
-ENCODING 7782
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 18 1 0
-BITMAP
-30
-30
-00
-44
-38
-10
-00
-7C
-84
-84
 80
 40
-30
-08
-04
-84
-84
-F8
-ENDCHAR
-STARTCHAR C115
-ENCODING 7783
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 0
-BITMAP
-60
-60
-00
-88
-70
-20
-00
-78
-88
+3C
+40
 80
-70
-08
-88
-F0
-ENDCHAR
-STARTCHAR C083
-ENCODING 7784
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 17 1 -3
-BITMAP
-30
-30
-00
-7C
-84
-84
 80
 40
-30
-08
-04
-84
-84
-F8
-00
-30
-30
-ENDCHAR
-STARTCHAR C115
-ENCODING 7785
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 13 1 -3
-BITMAP
-60
-60
-00
-78
-88
-80
-70
-08
-88
-F0
-00
-60
-60
-ENDCHAR
-STARTCHAR C084
-ENCODING 7786
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 0
-BITMAP
-1800
-1800
-0000
-FF80
-8880
-8880
-8880
-0800
-0800
-0800
-0800
-0800
-0800
-3E00
+3E
+01
 ENDCHAR
-STARTCHAR C116
-ENCODING 7787
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 13 1 0
+STARTCHAR uni1654
+ENCODING 5716
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-30
-30
-00
-20
-20
-20
-F8
-20
-20
-20
-24
-24
-18
+8420
+4440
+7FC0
+4440
+4440
+4440
+4440
+4440
+4440
+2A80
+1100
 ENDCHAR
-STARTCHAR C084
-ENCODING 7788
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 -3
+STARTCHAR uni1655
+ENCODING 5717
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-FF80
-8880
-8880
-8880
-0800
-0800
-0800
-0800
-0800
-0800
-3E00
-0000
-1800
-1800
+1100
+2A80
+4440
+4440
+4440
+4440
+4440
+4440
+7FC0
+4440
+8420
 ENDCHAR
-STARTCHAR C116
-ENCODING 7789
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 13 1 -3
+STARTCHAR uni1656
+ENCODING 5718
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-20
-20
-20
-F8
-20
-20
-20
-24
-24
-18
-00
-30
-30
+80
+7C
+42
+41
+41
+42
+FC
+42
+41
+41
+42
+7C
+80
 ENDCHAR
-STARTCHAR C084
-ENCODING 7790
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 13 1 -2
+STARTCHAR uni1657
+ENCODING 5719
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-FF80
-8880
-8880
-8880
-0800
-0800
-0800
-0800
-0800
-0800
-3E00
-0000
-3E00
+80
+7C
+42
+41
+51
+52
+FC
+52
+51
+41
+42
+7C
+80
 ENDCHAR
-STARTCHAR C116
-ENCODING 7791
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 -2
+STARTCHAR uni1658
+ENCODING 5720
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-20
-20
-20
-F8
-20
-20
-20
-24
-24
-18
-00
+80
 7C
+42
+41
+41
+52
+FC
+52
+41
+41
+42
+7C
+80
 ENDCHAR
-STARTCHAR C084
-ENCODING 7792
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 -4
+STARTCHAR uni1659
+ENCODING 5721
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-FF80
-8880
-8880
-8880
-0800
-0800
-0800
-0800
-0800
-0800
-3E00
-0000
-0800
-1C00
-2200
+01
+3E
+42
+82
+82
+42
+3F
+42
+82
+82
+42
+3E
+01
 ENDCHAR
-STARTCHAR C116
-ENCODING 7793
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 -4
+STARTCHAR uni165A
+ENCODING 5722
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 2
 BITMAP
 20
-20
 20
-F8
-20
+70
+A8
+A0
+70
+28
+A8
+70
 20
 20
-24
-24
-18
-00
-10
-38
-44
 ENDCHAR
-STARTCHAR C085
-ENCODING 7794
+STARTCHAR uni165B
+ENCODING 5723
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 1 -3
+BBX 11 11 1 0
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
+9F20
+4440
+7FC0
+4440
+4440
+4440
+4440
+4440
+4440
+2A80
 1100
-0E00
-0000
-1B00
-1B00
-ENDCHAR
-STARTCHAR C117
-ENCODING 7795
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 10 1 -3
-BITMAP
-CC
-44
-44
-44
-44
-44
-3E
-00
-6C
-6C
 ENDCHAR
-STARTCHAR C085
-ENCODING 7796
+STARTCHAR uni165C
+ENCODING 5724
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 15 1 -4
+BBX 11 11 1 0
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
 1100
-0E00
-0000
-0900
-1500
-1200
+2A80
+4440
+4440
+4440
+4440
+4440
+4440
+7FC0
+4440
+9F20
 ENDCHAR
-STARTCHAR C117
-ENCODING 7797
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 -4
+STARTCHAR uni165D
+ENCODING 5725
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-CC
-44
-44
-44
-44
-44
-3E
-00
-24
-54
-48
+80
+7C
+22
+21
+A1
+A2
+FC
+A2
+A1
+21
+22
+7C
+80
 ENDCHAR
-STARTCHAR C085
-ENCODING 7798
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 -4
+STARTCHAR uni165E
+ENCODING 5726
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-1100
-0E00
-0000
-0400
-0E00
-1100
+80
+7C
+22
+21
+A9
+AA
+FC
+AA
+A9
+21
+22
+7C
+80
 ENDCHAR
-STARTCHAR C117
-ENCODING 7799
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 -4
+STARTCHAR uni165F
+ENCODING 5727
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-CC
-44
-44
-44
+80
+7C
+22
+21
+A1
+AA
+FC
+AA
+A1
+21
+22
+7C
+80
+ENDCHAR
+STARTCHAR uni1660
+ENCODING 5728
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
+BITMAP
+01
+3E
 44
+84
+85
+45
+3F
+45
+85
+84
 44
 3E
-00
-10
-38
-44
+01
 ENDCHAR
-STARTCHAR C085
-ENCODING 7800
+STARTCHAR uni1661
+ENCODING 5729
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 20 1 0
+BBX 11 11 1 0
 BITMAP
-0200
-0600
-0400
-0800
-0000
-0900
-1500
-1200
-0000
-FBE0
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
+9F20
+4440
+4440
+4440
+4440
+4440
+4440
+4440
+4440
+2A80
 1100
-0E00
-ENDCHAR
-STARTCHAR C117
-ENCODING 7801
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 16 1 0
-BITMAP
-08
-18
-10
-20
-00
-24
-54
-48
-00
-CC
-44
-44
-44
-44
-44
-3E
 ENDCHAR
-STARTCHAR C085
-ENCODING 7802
+STARTCHAR uni1662
+ENCODING 5730
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 16 1 0
+BBX 11 11 1 0
 BITMAP
-1B00
-1B00
-0000
-1F00
-0000
-FBE0
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
 1100
-0E00
+2A80
+4440
+4440
+4440
+4440
+4440
+4440
+4440
+4440
+9F20
 ENDCHAR
-STARTCHAR C117
-ENCODING 7803
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni1663
+ENCODING 5731
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-6C
-6C
-00
+80
 7C
-00
-CC
-44
-44
-44
-44
-44
-3E
+02
+01
+81
+82
+FC
+82
+81
+01
+02
+7C
+80
 ENDCHAR
-STARTCHAR C086
-ENCODING 7804
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 0 0
+STARTCHAR uni1664
+ENCODING 5732
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-0900
-1500
-1200
-0000
-F1E0
-2080
-2080
-1100
-1100
-1100
-0A00
-0A00
-0A00
-0400
-0400
+80
+7C
+02
+01
+91
+92
+FC
+92
+91
+01
+02
+7C
+80
 ENDCHAR
-STARTCHAR C118
-ENCODING 7805
+STARTCHAR uni1665
+ENCODING 5733
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 8 13 1 -1
 BITMAP
-12
-2A
-24
-00
-E7
-24
-24
-24
-18
-18
-18
+80
+7C
+02
+01
+81
+92
+FC
+92
+81
+01
+02
+7C
+80
 ENDCHAR
-STARTCHAR C086
-ENCODING 7806
+STARTCHAR uni1666
+ENCODING 5734
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
+BITMAP
+01
+3E
+40
+80
+81
+41
+3F
+41
+81
+80
+40
+3E
+01
+ENDCHAR
+STARTCHAR uni1667
+ENCODING 5735
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 0 -3
+BBX 11 11 1 0
 BITMAP
-F1E0
-2080
-2080
-1100
+9F20
+64C0
+5540
+4E40
+4440
+4440
+4440
+4440
+4440
+2A80
 1100
+ENDCHAR
+STARTCHAR uni1668
+ENCODING 5736
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
 1100
-0A00
-0A00
-0A00
-0400
-0400
-0000
-0C00
-0C00
+2A80
+4440
+4440
+4440
+4440
+4440
+4E40
+5540
+64C0
+9F20
 ENDCHAR
-STARTCHAR C118
-ENCODING 7807
+STARTCHAR uni1669
+ENCODING 5737
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 10 1 -3
+BBX 8 13 1 -1
 BITMAP
-E7
-24
-24
-24
-18
-18
-18
-00
-18
-18
+80
+FC
+82
+41
+A1
+92
+FC
+92
+A1
+41
+82
+FC
+80
 ENDCHAR
-STARTCHAR C087
-ENCODING 7808
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 16 0 0
+STARTCHAR uni166A
+ENCODING 5738
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-0200
-0300
-0100
-0080
-0000
-F1CF
-2184
-2184
-2244
-1248
-1248
-1248
-1428
-0C30
-0C30
-0810
+80
+FC
+42
+41
+A9
+9A
+FC
+9A
+A9
+41
+82
+FC
+80
 ENDCHAR
-STARTCHAR C119
-ENCODING 7809
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 12 0 0
+STARTCHAR uni166B
+ENCODING 5739
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-0800
-0C00
-0400
-0200
-0000
-EEE0
-2480
-2A80
-2A80
-2A80
-1B00
-1100
+80
+FC
+82
+41
+A1
+9A
+FC
+9A
+A1
+41
+82
+FC
+80
 ENDCHAR
-STARTCHAR C087
-ENCODING 7810
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 16 0 0
+STARTCHAR uni166C
+ENCODING 5740
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -1
 BITMAP
-0080
-0180
-0100
-0200
-0000
-F1CF
-2184
-2184
-2244
-1248
-1248
-1248
-1428
-0C30
-0C30
-0810
+01
+3F
+41
+82
+85
+49
+3F
+49
+85
+82
+41
+3F
+01
 ENDCHAR
-STARTCHAR C119
-ENCODING 7811
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 12 0 0
+STARTCHAR uni166D
+ENCODING 5741
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 2 0
 BITMAP
-0200
-0600
+C020
+2040
+1080
+0900
+0A00
 0400
-0800
-0000
-EEE0
-2480
-2A80
-2A80
-2A80
-1B00
-1100
+0A00
+1200
+2100
+4080
+8060
 ENDCHAR
-STARTCHAR C087
-ENCODING 7812
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 14 0 0
+STARTCHAR uni166E
+ENCODING 5742
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 5 1 0
 BITMAP
-06C0
-06C0
-0000
-F1CF
-2184
-2184
-2244
-1248
-1248
-1248
-1428
-0C30
-0C30
-0810
+88
+50
+20
+50
+88
 ENDCHAR
-STARTCHAR C119
-ENCODING 7813
+STARTCHAR uni166F
+ENCODING 5743
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 10 0 0
+BBX 10 11 1 0
 BITMAP
-1B00
-1B00
-0000
-EEE0
-2480
-2A80
-2A80
-2A80
-1B00
-1100
+6780
+8840
+8840
+6840
+2840
+27C0
+0040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C087
-ENCODING 7814
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 14 0 0
+STARTCHAR uni1670
+ENCODING 5744
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 11 1 0
 BITMAP
-0180
-0180
-0000
-F1CF
-2184
-2184
-2244
-1248
-1248
-1248
-1428
-0C30
-0C30
-0810
+600F00
+901080
+901080
+7C0080
+040080
+048080
+048080
+030080
+000080
+000080
+000080
 ENDCHAR
-STARTCHAR C119
-ENCODING 7815
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 10 0 0
+STARTCHAR uni1671
+ENCODING 5745
+SWIDTH 1380 0
+DWIDTH 23 0
+BBX 22 11 1 0
 BITMAP
-0600
-0600
-0000
-EEE0
-2480
-2A80
-2A80
-2A80
-1B00
-1100
+630078
+948084
+948084
+7BE080
+002080
+002480
+002480
+001880
+000080
+000080
+000080
 ENDCHAR
-STARTCHAR C087
-ENCODING 7816
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 14 0 -3
+STARTCHAR uni1672
+ENCODING 5746
+SWIDTH 1380 0
+DWIDTH 23 0
+BBX 22 15 1 0
 BITMAP
-F1CF
-2184
-2184
-2244
-1248
-1248
-1248
-1428
-0C30
-0C30
-0810
-0000
-0180
-0180
+000020
+000070
+000020
+000000
+630078
+948084
+948084
+7BE080
+002080
+002480
+002480
+001880
+000080
+000080
+000080
 ENDCHAR
-STARTCHAR C119
-ENCODING 7817
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 10 0 -3
+STARTCHAR uni1673
+ENCODING 5747
+SWIDTH 1380 0
+DWIDTH 23 0
+BBX 22 11 1 0
 BITMAP
-EEE0
-2480
-2A80
-2A80
-2A80
-1B00
-1100
-0000
-0C00
-0C00
+630004
+948004
+948004
+7BE004
+002004
+002404
+002404
+001804
+000084
+000084
+000078
 ENDCHAR
-STARTCHAR C088
-ENCODING 7818
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 1 0
+STARTCHAR uni1674
+ENCODING 5748
+SWIDTH 1440 0
+DWIDTH 24 0
+BBX 23 15 1 0
 BITMAP
-0C00
-0C00
-0000
-F3C0
-1100
-1200
-0A00
-0C00
-0400
-0A00
-1A00
-1100
-2080
-F1E0
+000004
+00000E
+000004
+000000
+630004
+948004
+948004
+7BE004
+002004
+002404
+002404
+001804
+000084
+000084
+000078
 ENDCHAR
-STARTCHAR C120
-ENCODING 7819
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 10 1 0
+STARTCHAR uni1675
+ENCODING 5749
+SWIDTH 1380 0
+DWIDTH 23 0
+BBX 22 11 1 0
 BITMAP
-18
-18
-00
-E7
-24
-18
-18
-18
-24
-E7
+630080
+948080
+948080
+7BE080
+002080
+002480
+002480
+001880
+000084
+000084
+000078
 ENDCHAR
-STARTCHAR C088
-ENCODING 7820
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 1 0
+STARTCHAR uni1676
+ENCODING 5750
+SWIDTH 1440 0
+DWIDTH 24 0
+BBX 23 15 1 0
 BITMAP
-1B00
-1B00
-0000
-F3C0
-1100
-1200
-0A00
-0C00
-0400
-0A00
-1A00
-1100
-2080
-F1E0
+000040
+0000E0
+000040
+000000
+630040
+948040
+948040
+7BE040
+002040
+002440
+002440
+001840
+000042
+000042
+00003C
 ENDCHAR
-STARTCHAR C120
-ENCODING 7821
+STARTCHAR uni1680
+ENCODING 5760
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 1 0 5
+BITMAP
+FFF0
+ENDCHAR
+STARTCHAR uni1681
+ENCODING 5761
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 10 1 0
+BBX 9 9 0 -3
 BITMAP
-36
-36
-00
-E7
-24
-18
-18
-18
-24
-E7
+FF80
+0800
+0800
+0800
+0800
+0800
+0800
+0800
+0800
 ENDCHAR
-STARTCHAR C089
-ENCODING 7822
+STARTCHAR uni1682
+ENCODING 5762
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 0 0
-BITMAP
-0C00
-0C00
-0000
-F1E0
-2080
-1100
-1100
-0A00
-0E00
-0400
-0400
-0400
-0400
-1F00
-ENDCHAR
-STARTCHAR C121
-ENCODING 7823
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 13 1 -3
+BBX 12 9 0 -3
 BITMAP
-18
-18
-00
-E7
-24
-24
-24
-18
-18
-18
-10
-90
-E0
+FFF0
+0900
+0900
+0900
+0900
+0900
+0900
+0900
+0900
 ENDCHAR
-STARTCHAR C090
-ENCODING 7824
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 15 1 0
+STARTCHAR uni1683
+ENCODING 5763
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 9 0 -3
 BITMAP
-10
-38
-44
-00
-FE
-C4
-84
-88
-08
-10
-20
-22
-42
-46
-FE
+FFFE
+0920
+0920
+0920
+0920
+0920
+0920
+0920
+0920
 ENDCHAR
-STARTCHAR C122
-ENCODING 7825
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
+STARTCHAR uni1684
+ENCODING 5764
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 9 0 -3
 BITMAP
-20
-70
-88
-00
-F8
-90
-90
-20
-48
-48
-F8
+FFFFC0
+092400
+092400
+092400
+092400
+092400
+092400
+092400
+092400
 ENDCHAR
-STARTCHAR C090
-ENCODING 7826
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 14 1 -3
+STARTCHAR uni1685
+ENCODING 5765
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 21 9 0 -3
 BITMAP
-FE
-C4
-84
-88
-08
-10
-20
-22
-42
-46
-FE
-00
-30
-30
+FFFFF8
+092480
+092480
+092480
+092480
+092480
+092480
+092480
+092480
 ENDCHAR
-STARTCHAR C122
-ENCODING 7827
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 -3
+STARTCHAR uni1686
+ENCODING 5766
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 9 0 5
 BITMAP
-F8
-90
-90
-20
-48
-48
-F8
-00
-60
-60
+0800
+0800
+0800
+0800
+0800
+0800
+0800
+0800
+FF80
 ENDCHAR
-STARTCHAR C090
-ENCODING 7828
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 13 1 -2
+STARTCHAR uni1687
+ENCODING 5767
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 9 0 5
 BITMAP
-FE
-C4
-84
-88
-08
-10
-20
-22
-42
-46
-FE
-00
-7C
+0900
+0900
+0900
+0900
+0900
+0900
+0900
+0900
+FFF0
 ENDCHAR
-STARTCHAR C122
-ENCODING 7829
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 9 1 -2
+STARTCHAR uni1688
+ENCODING 5768
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 9 0 5
 BITMAP
-F8
-90
-90
-20
-48
-48
-F8
-00
-F8
+0920
+0920
+0920
+0920
+0920
+0920
+0920
+0920
+FFFE
 ENDCHAR
-STARTCHAR C104
-ENCODING 7830
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 14 1 -2
+STARTCHAR uni1689
+ENCODING 5769
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 9 0 5
 BITMAP
-C0
-40
-40
-40
-40
-78
-44
-44
-44
-44
-44
-EE
-00
-7C
+092400
+092400
+092400
+092400
+092400
+092400
+092400
+092400
+FFFFC0
 ENDCHAR
-STARTCHAR C116
-ENCODING 7831
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 13 1 0
+STARTCHAR uni168A
+ENCODING 5770
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 21 9 0 5
 BITMAP
-D8
-D8
-00
-20
-20
-20
-F8
-20
-20
-20
-24
-24
-18
+092480
+092480
+092480
+092480
+092480
+092480
+092480
+092480
+FFFFF8
 ENDCHAR
-STARTCHAR C119
-ENCODING 7832
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 12 0 0
+STARTCHAR uni168B
+ENCODING 5771
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 11 0 0
 BITMAP
-0600
-0900
-0900
+0018
+0030
+0060
+00C0
+0180
+FFFC
 0600
-0000
-EEE0
-2480
-2A80
-2A80
-2A80
-1B00
-1100
-ENDCHAR
-STARTCHAR C121
-ENCODING 7833
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 15 1 -3
-BITMAP
-18
-24
-24
-18
-00
-E7
-24
-24
-24
-18
-18
-18
-10
-90
-E0
+0C00
+1800
+3000
+6000
 ENDCHAR
-STARTCHAR C097
-ENCODING 7834
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni168C
+ENCODING 5772
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 11 0 0
 BITMAP
-18
-04
-04
-18
-00
-70
-88
-08
-78
-88
-88
-7C
-ENDCHAR
-STARTCHAR C102
-ENCODING 7835
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 0
+001980
+003300
+006600
+00CC00
+019800
+FFFFC0
+066000
+0CC000
+198000
+330000
+660000
+ENDCHAR
+STARTCHAR uni168D
+ENCODING 5773
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 22 11 0 0
 BITMAP
-60
-60
-00
-38
-48
-40
-40
-40
-C0
-40
-40
-40
-40
-40
-E0
+001998
+003330
+006660
+00CCC0
+019980
+FFFFFC
+066600
+0CCC00
+199800
+333000
+666000
+ENDCHAR
+STARTCHAR uni168E
+ENCODING 5774
+SWIDTH 1560 0
+DWIDTH 26 0
+BBX 26 11 0 0
+BITMAP
+00199980
+00333300
+00666600
+00CCCC00
+01999800
+FFFFFFC0
+06666000
+0CCCC000
+19998000
+33330000
+66660000
+ENDCHAR
+STARTCHAR uni168F
+ENCODING 5775
+SWIDTH 1800 0
+DWIDTH 30 0
+BBX 30 11 0 0
+BITMAP
+00199998
+00333330
+00666660
+00CCCCC0
+01999980
+FFFFFFFC
+06666600
+0CCCCC00
+19999800
+33333000
+66666000
 ENDCHAR
-STARTCHAR C065
-ENCODING 7840
+STARTCHAR uni1690
+ENCODING 5776
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 14 0 -3
+BBX 11 5 0 3
 BITMAP
 0400
+0E00
+FFE0
+0E00
 0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-0000
-0600
-0600
 ENDCHAR
-STARTCHAR C097
-ENCODING 7841
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 10 1 -3
+STARTCHAR uni1691
+ENCODING 5777
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 5 0 3
 BITMAP
-70
-88
-08
-78
-88
-88
-7C
-00
-30
-30
+0420
+0E70
+FFFF
+0E70
+0420
 ENDCHAR
-STARTCHAR C065
-ENCODING 7842
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 17 0 0
+STARTCHAR uni1692
+ENCODING 5778
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 21 5 0 3
 BITMAP
-0400
-0A00
-0200
-0400
-0400
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+042100
+0E7380
+FFFFF8
+0E7380
+042100
 ENDCHAR
-STARTCHAR C097
-ENCODING 7843
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 13 1 0
-BITMAP
-20
-50
-10
-20
-20
-00
-70
-88
-08
-78
-88
-88
-7C
+STARTCHAR uni1693
+ENCODING 5779
+SWIDTH 1560 0
+DWIDTH 26 0
+BBX 26 5 0 3
+BITMAP
+04210800
+0E739C00
+FFFFFFC0
+0E739C00
+04210800
+ENDCHAR
+STARTCHAR uni1694
+ENCODING 5780
+SWIDTH 1860 0
+DWIDTH 31 0
+BBX 31 5 0 3
+BITMAP
+04210840
+0E739CE0
+FFFFFFFE
+0E739CE0
+04210840
 ENDCHAR
-STARTCHAR C065
-ENCODING 7844
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 16 0 0
+STARTCHAR uni1695
+ENCODING 5781
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 11 0 0
 BITMAP
-0080
-0500
-0E00
-1100
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+2010
+1020
+0840
+0480
+0300
+FFFC
+0300
+0480
+0840
+1020
+2010
 ENDCHAR
-STARTCHAR C097
-ENCODING 7845
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni1696
+ENCODING 5782
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 13 0 -1
 BITMAP
-04
-28
-70
-88
-00
-70
-88
-08
-78
-88
-88
-7C
+0100
+0280
+0440
+0820
+1010
+2008
+FFFE
+2008
+1010
+0820
+0440
+0280
+0100
 ENDCHAR
-STARTCHAR C065
-ENCODING 7846
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 16 0 0
+STARTCHAR uni1697
+ENCODING 5783
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 9 0 -3
 BITMAP
+FFF8
 2000
-1400
-0E00
-1100
+2000
+23E0
+2220
+2220
+2020
+2020
+3FE0
+ENDCHAR
+STARTCHAR uni1698
+ENCODING 5784
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 20 12 0 -6
+BITMAP
+FFFFF0
+210840
+109080
+086100
+046200
+029400
+010800
+029400
+046200
+086100
+109080
+210840
+ENDCHAR
+STARTCHAR uni1699
+ENCODING 5785
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 10 0 5
+BITMAP
+092400
+3FFF00
+092400
+3FFF00
+092400
+3FFF00
+092400
+3FFF00
+092400
+FFFFC0
+ENDCHAR
+STARTCHAR uni169A
+ENCODING 5786
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 4 0 2
+BITMAP
+FFFF
 0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+1FF8
+1FF8
 ENDCHAR
-STARTCHAR C097
-ENCODING 7847
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 12 0 0
+STARTCHAR uni169B
+ENCODING 5787
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 0 0
 BITMAP
-80
-50
-38
-44
-00
-38
-44
-04
-3C
-44
-44
-3E
+8000
+4000
+2000
+1000
+0800
+0F80
+0800
+1000
+2000
+4000
+8000
 ENDCHAR
-STARTCHAR C065
-ENCODING 7848
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 18 0 0
+STARTCHAR uni169C
+ENCODING 5788
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 0 0
 BITMAP
-0100
-0280
 0080
-0500
-0F00
-1100
-0000
+0100
+0200
 0400
+0800
+F800
+0800
 0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+0200
+0100
+0080
 ENDCHAR
-STARTCHAR C097
-ENCODING 7849
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 0
+STARTCHAR uni16A0
+ENCODING 5792
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 3 0
 BITMAP
-08
-14
-04
-28
-78
 88
-00
-70
+8A
+92
+E4
 88
-08
-78
+F0
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni16A1
+ENCODING 5793
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 14 2 0
+BITMAP
+60
+E8
+8A
+92
+E4
 88
+F0
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni16A2
+ENCODING 5794
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+F0
 88
-7C
+84
+82
+82
+82
+82
+82
+82
+82
+82
+82
+82
 ENDCHAR
-STARTCHAR C065
-ENCODING 7850
+STARTCHAR uni16A3
+ENCODING 5795
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 19 0 0
-BITMAP
-0900
-1500
-1200
-0000
-0400
-0E00
-1100
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-ENDCHAR
-STARTCHAR C097
-ENCODING 7851
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 0
+BBX 8 13 2 0
 BITMAP
-48
-A8
+E0
 90
-00
-20
-70
+90
 88
-00
-70
 88
-08
-78
+84
+84
+84
+92
+92
+92
+91
+81
+ENDCHAR
+STARTCHAR uni16A4
+ENCODING 5796
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+F0
 88
+84
+82
+82
+82
+82
+B2
+B2
+82
+82
+82
+82
+ENDCHAR
+STARTCHAR uni16A5
+ENCODING 5797
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+F0
+8C
+84
+F2
+8A
+8A
+8A
+8A
+8A
+8A
+8A
+8A
+8A
+ENDCHAR
+STARTCHAR uni16A6
+ENCODING 5798
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
+BITMAP
+80
+80
+80
+F8
+84
+84
+84
+84
 88
-7C
+F0
+80
+80
+80
 ENDCHAR
-STARTCHAR C065
-ENCODING 7852
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 18 0 -3
+STARTCHAR uni16A7
+ENCODING 5799
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
 BITMAP
-0400
-0E00
-1100
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-0000
-0600
-0600
+80
+80
+80
+F8
+84
+B4
+B4
+84
+88
+F0
+80
+80
+80
 ENDCHAR
-STARTCHAR C097
-ENCODING 7853
+STARTCHAR uni16A8
+ENCODING 5800
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 14 1 -3
+BBX 4 13 2 0
 BITMAP
-20
-70
-88
-00
-70
-88
-08
-78
-88
-88
-7C
-00
-30
-30
+80
+C0
+A0
+90
+C0
+A0
+90
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C065
-ENCODING 7854
+STARTCHAR uni16A9
+ENCODING 5801
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 18 0 0
+BBX 8 13 2 0
 BITMAP
-0100
-0300
-0200
-0400
-1100
-0E00
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-ENDCHAR
-STARTCHAR C097
-ENCODING 7855
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 0
-BITMAP
-08
-18
-10
-20
-88
-70
-00
-70
-88
-08
-78
-88
-88
-7C
+81
+E6
+98
+80
+C2
+A4
+98
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C065
-ENCODING 7856
+STARTCHAR uni16AA
+ENCODING 5802
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 18 0 0
-BITMAP
-1000
-1800
-0800
-0400
-1100
-0E00
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-ENDCHAR
-STARTCHAR C097
-ENCODING 7857
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 0
+BBX 8 13 2 0
 BITMAP
+81
+E6
+98
 80
 C0
-40
-20
-88
-70
-00
-70
-88
-08
-78
-88
-88
-7C
+A0
+98
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C065
-ENCODING 7858
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 19 0 0
+STARTCHAR uni16AB
+ENCODING 5803
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
-0400
-0A00
-0200
-0400
-0400
-1100
-0E00
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+80
+E0
+98
+80
+C0
+A0
+98
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C097
-ENCODING 7859
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 0
+STARTCHAR uni16AC
+ENCODING 5804
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
 20
-50
-10
 20
 20
-88
-70
-00
-70
-88
-08
-78
-88
-88
-7C
-ENDCHAR
-STARTCHAR C065
-ENCODING 7860
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 18 0 0
-BITMAP
-0900
-1500
-1200
-0000
-1100
-0E00
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+A0
+60
+30
+A8
+60
+30
+28
+20
+20
+20
 ENDCHAR
-STARTCHAR C097
-ENCODING 7861
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 14 1 0
+STARTCHAR uni16AD
+ENCODING 5805
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 3 13 2 0
 BITMAP
-48
-A8
-90
-00
-88
-70
-00
-70
-88
-08
-78
-88
-88
-7C
+80
+80
+80
+80
+C0
+A0
+80
+C0
+A0
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C065
-ENCODING 7862
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 17 0 -3
+STARTCHAR uni16AE
+ENCODING 5806
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 3 13 2 0
 BITMAP
-1100
-0E00
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-0000
-0600
-0600
+20
+20
+20
+20
+60
+A0
+20
+60
+A0
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR C097
-ENCODING 7863
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 13 1 -3
+STARTCHAR uni16AF
+ENCODING 5807
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
-88
-70
-00
-70
-88
-08
-78
-88
-88
-7C
-00
+20
+20
+20
+28
 30
+60
+A8
 30
+60
+A0
+20
+20
+20
 ENDCHAR
-STARTCHAR C069
-ENCODING 7864
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 14 0 -3
+STARTCHAR uni16B0
+ENCODING 5808
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
-0000
-0C00
-0C00
+20
+20
+20
+28
+30
+60
+A0
+20
+60
+A0
+20
+20
+20
 ENDCHAR
-STARTCHAR C101
-ENCODING 7865
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 -3
+STARTCHAR uni16B1
+ENCODING 5809
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-70
-88
 F8
-80
-80
+84
+84
+84
+84
+84
+F8
+A0
+90
 88
-70
-00
-30
-30
-ENDCHAR
-STARTCHAR C069
-ENCODING 7866
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 0 0
-BITMAP
-0800
-1400
-0400
-0800
-0800
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
+88
+84
+82
 ENDCHAR
-STARTCHAR C101
-ENCODING 7867
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 13 1 0
+STARTCHAR uni16B2
+ENCODING 5810
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 7 2 4
 BITMAP
-20
-50
 10
 20
+40
+80
+40
 20
-00
-70
-88
-F8
+10
+ENDCHAR
+STARTCHAR uni16B3
+ENCODING 5811
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
+BITMAP
+80
+80
+80
+80
+80
 80
 80
+C0
+A0
+90
 88
-70
-ENDCHAR
-STARTCHAR C069
-ENCODING 7868
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 0 0
-BITMAP
-1200
-2A00
-2400
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
+84
+84
 ENDCHAR
-STARTCHAR C101
-ENCODING 7869
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
+STARTCHAR uni16B4
+ENCODING 5812
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-48
-A8
-90
-00
-70
+80
+82
+82
+84
 88
-F8
+F0
 80
 80
-88
-70
-ENDCHAR
-STARTCHAR C069
-ENCODING 7870
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 16 0 0
-BITMAP
-0100
-0A00
-1C00
-2200
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C101
-ENCODING 7871
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 12 1 0
+STARTCHAR uni16B5
+ENCODING 5813
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-04
-28
-70
-88
-00
-70
+B0
+B2
+82
+84
 88
-F8
+F0
 80
 80
-88
-70
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C069
-ENCODING 7872
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 16 0 0
+STARTCHAR uni16B6
+ENCODING 5814
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 13 2 0
 BITMAP
-4000
-2800
-1C00
-2200
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
+2000
 2080
 2080
-FF80
+2100
+7200
+BC00
+A800
+A800
+7000
+2000
+2000
+2000
+2000
 ENDCHAR
-STARTCHAR C101
-ENCODING 7873
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 12 0 0
+STARTCHAR uni16B7
+ENCODING 5815
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-80
-50
-38
+82
+82
 44
-00
-38
 44
-7C
-40
-40
+28
+10
+10
+10
+28
 44
-38
+44
+82
+82
 ENDCHAR
-STARTCHAR C069
-ENCODING 7874
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 18 0 0
+STARTCHAR uni16B8
+ENCODING 5816
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 13 2 0
 BITMAP
-0200
-0500
-0100
-0A00
-1E00
+4100
+4100
 2200
-0000
-FF80
-2080
-2080
-2280
 2200
-3E00
-2240
-2240
-2080
-2080
-FF80
+3600
+4900
+8880
+4900
+3600
+2200
+2200
+4100
+4100
 ENDCHAR
-STARTCHAR C101
-ENCODING 7875
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 14 1 0
+STARTCHAR uni16B9
+ENCODING 5817
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
 BITMAP
-08
-14
-04
-28
-78
-88
-00
-70
-88
 F8
+84
+84
+84
+84
+84
+B8
+C0
 80
 80
-88
-70
+80
+80
+80
 ENDCHAR
-STARTCHAR C069
-ENCODING 7876
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 19 0 0
+STARTCHAR uni16BA
+ENCODING 5818
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-1200
-2A00
-2400
-0000
-0800
-1C00
-2200
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
+82
+82
+82
+82
+C2
+A2
+9A
+86
+82
+82
+82
+82
+82
 ENDCHAR
-STARTCHAR C101
-ENCODING 7877
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 0
+STARTCHAR uni16BB
+ENCODING 5819
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-48
-A8
-90
-00
-20
-70
-88
-00
-70
-88
-F8
-80
-80
-88
-70
+82
+82
+82
+C2
+A2
+9A
+C6
+A2
+9A
+86
+82
+82
+82
 ENDCHAR
-STARTCHAR C069
-ENCODING 7878
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 18 0 -3
+STARTCHAR uni16BC
+ENCODING 5820
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-0800
-1C00
-2200
-0000
-FF80
-2080
-2080
-2280
-2200
-3E00
-2240
-2240
-2080
-2080
-FF80
-0000
-0C00
-0C00
+10
+10
+10
+92
+54
+38
+38
+54
+92
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR C101
-ENCODING 7879
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 -3
+STARTCHAR uni16BD
+ENCODING 5821
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
 20
-70
-88
-00
+20
+20
+20
 70
-88
-F8
-80
-80
-88
+A8
+A8
+A8
 70
-00
-30
-30
-ENDCHAR
-STARTCHAR C073
-ENCODING 7880
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 17 1 0
-BITMAP
 20
-50
-10
 20
 20
-00
-F8
+20
+ENDCHAR
+STARTCHAR uni16BE
+ENCODING 5822
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
+BITMAP
 20
 20
 20
 20
+A0
+60
+30
+28
 20
 20
 20
 20
 20
-F8
 ENDCHAR
-STARTCHAR C105
-ENCODING 7881
+STARTCHAR uni16BF
+ENCODING 5823
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 3 13 2 0
+BITMAP
+80
+80
+80
+80
+80
+80
+C0
+A0
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni16C0
+ENCODING 5824
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+10
+10
+10
+90
+78
+74
+54
+5C
+3C
+12
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16C1
+ENCODING 5825
 SWIDTH 240 0
 DWIDTH 4 0
-BBX 3 13 1 0
+BBX 1 13 2 0
+BITMAP
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni16C2
+ENCODING 5826
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 3 13 2 0
 BITMAP
 40
-A0
-20
 40
 40
-00
-C0
 40
 40
+E0
+E0
+40
 40
 40
 40
-E0
+40
+40
 ENDCHAR
-STARTCHAR C073
-ENCODING 7882
+STARTCHAR uni16C3
+ENCODING 5827
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 8 10 2 2
+BITMAP
+10
+20
+60
+C8
+64
+26
+13
+06
+04
+08
+ENDCHAR
+STARTCHAR uni16C4
+ENCODING 5828
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+10
+10
+10
+10
+38
+54
+92
+54
+38
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16C5
+ENCODING 5829
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
+BITMAP
+20
+20
+20
+20
+28
+30
+60
+A0
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni16C6
+ENCODING 5830
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 14 1 -3
+BBX 3 13 2 0
 BITMAP
-F8
 20
 20
 20
 20
 20
 20
+60
+A0
 20
 20
 20
-F8
-00
-60
+20
+20
+ENDCHAR
+STARTCHAR uni16C7
+ENCODING 5831
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
+BITMAP
+20
+30
+28
+20
+20
+20
+20
+20
+20
+20
+A0
 60
+20
 ENDCHAR
-STARTCHAR 0x1ECB
-ENCODING 7883
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 14 1 -3
+STARTCHAR uni16C8
+ENCODING 5832
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-C0
-C0
-00
-00
-C0
-40
+80
+C2
+A4
+98
+80
+80
+80
+80
+80
+98
+A4
+C2
+80
+ENDCHAR
+STARTCHAR uni16C9
+ENCODING 5833
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+92
+92
+54
+54
+38
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16CA
+ENCODING 5834
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 13 2 0
+BITMAP
+10
+20
 40
+80
 40
+20
+10
+20
 40
+80
 40
-E0
-00
-C0
-C0
+20
+10
 ENDCHAR
-STARTCHAR C079
-ENCODING 7884
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 14 1 -3
+STARTCHAR uni16CB
+ENCODING 5835
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
-0000
-0C00
-0C00
+80
+80
+80
+80
+88
+98
+A8
+C8
+08
+08
+08
+08
+08
 ENDCHAR
-STARTCHAR C111
-ENCODING 7885
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 -3
+STARTCHAR uni16CC
+ENCODING 5836
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 1 5 2 8
+BITMAP
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni16CD
+ENCODING 5837
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 9 2 4
 BITMAP
+20
+20
+20
+20
 70
 88
 88
 88
-88
-88
 70
-00
-30
-30
 ENDCHAR
-STARTCHAR C079
-ENCODING 7886
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 17 1 0
+STARTCHAR uni16CE
+ENCODING 5838
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 7 2 6
 BITMAP
-0800
-1400
-0400
-0800
-0800
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+10
+10
+10
+10
+D6
+38
+10
 ENDCHAR
-STARTCHAR C111
-ENCODING 7887
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 13 1 0
+STARTCHAR uni16CF
+ENCODING 5839
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-20
-50
 10
-20
-20
-00
-70
-88
+38
+D6
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16D0
+ENCODING 5840
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 13 2 0
+BITMAP
+10
+30
+D0
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16D1
+ENCODING 5841
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+10
+30
+D0
+10
+38
+54
+92
+54
+38
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16D2
+ENCODING 5842
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
+BITMAP
+C0
+B0
 88
+84
+8C
+B0
+C0
+B0
 88
+84
 88
+B0
+C0
+ENDCHAR
+STARTCHAR uni16D3
+ENCODING 5843
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
+BITMAP
+80
+80
 88
-70
+B0
+C0
+80
+90
+A0
+C0
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C079
-ENCODING 7888
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 16 1 0
+STARTCHAR uni16D4
+ENCODING 5844
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
-0100
-0A00
-1C00
-2200
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+F0
+88
+A8
+A8
+88
+B0
+C0
+B0
+88
+A8
+A8
+88
+F0
 ENDCHAR
-STARTCHAR C111
-ENCODING 7889
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 12 1 0
+STARTCHAR uni16D5
+ENCODING 5845
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
 BITMAP
-04
-28
-70
 88
-00
-70
 88
 88
+90
+90
+A0
+C0
+C0
+A0
+90
+90
+88
+88
+ENDCHAR
+STARTCHAR uni16D6
+ENCODING 5846
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+82
+C6
+AA
+92
+82
+82
+82
+82
+82
+82
+82
+82
+82
+ENDCHAR
+STARTCHAR uni16D7
+ENCODING 5847
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+82
+C6
+AA
+92
+AA
+C6
+82
+82
+82
+82
+82
+82
+82
+ENDCHAR
+STARTCHAR uni16D8
+ENCODING 5848
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+92
+92
+92
+54
+38
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16D9
+ENCODING 5849
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 13 2 0
+BITMAP
+70
 88
 88
 88
 70
+20
+20
+20
+20
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR C079
-ENCODING 7890
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 16 1 0
+STARTCHAR uni16DA
+ENCODING 5850
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 13 2 0
 BITMAP
-4000
-2800
-1C00
-2200
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+80
+C0
+B0
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C111
-ENCODING 7891
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 12 0 0
+STARTCHAR uni16DB
+ENCODING 5851
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-80
-50
+10
+18
+16
+10
 38
-44
-00
+54
+92
+54
 38
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni16DC
+ENCODING 5852
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 7 2 3
+BITMAP
+10
+28
+44
+82
+44
+28
+10
+ENDCHAR
+STARTCHAR uni16DD
+ENCODING 5853
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+82
+44
+28
+10
+28
+44
+82
+44
+28
+10
+28
 44
+82
+ENDCHAR
+STARTCHAR uni16DE
+ENCODING 5854
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+82
+C6
+C6
+AA
+AA
+92
+92
+92
+AA
+AA
+C6
+C6
+82
+ENDCHAR
+STARTCHAR uni16DF
+ENCODING 5855
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+10
+28
 44
+82
+82
 44
+28
+10
+28
 44
 44
+82
+82
+ENDCHAR
+STARTCHAR uni16E0
+ENCODING 5856
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
+BITMAP
+0200
+CF98
+3260
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni16E1
+ENCODING 5857
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
+BITMAP
+10
+10
+10
+92
+54
+38
 38
+54
+92
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR C079
-ENCODING 7892
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 18 1 0
+STARTCHAR uni16E2
+ENCODING 5858
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
 0200
-0500
-0100
-0A00
-1E00
-2200
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+0398
+0260
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+3200
+CE00
+0200
 ENDCHAR
-STARTCHAR C111
-ENCODING 7893
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 14 1 0
+STARTCHAR uni16E3
+ENCODING 5859
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-08
-14
-04
-28
-78
-88
-00
-70
-88
-88
-88
-88
-88
-70
+10
+10
+10
+10
+10
+10
+10
+10
+38
+54
+54
+92
+92
 ENDCHAR
-STARTCHAR C079
-ENCODING 7894
+STARTCHAR uni16E4
+ENCODING 5860
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 19 1 0
+BBX 9 13 2 0
 BITMAP
-1200
+4900
+4900
 2A00
-2400
-0000
-0800
-1C00
-2200
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+2A00
+3E00
+4900
+8880
+4900
+3E00
+2A00
+2A00
+4900
+4900
 ENDCHAR
-STARTCHAR C111
-ENCODING 7895
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 1 0
+STARTCHAR uni16E5
+ENCODING 5861
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-48
-A8
-90
-00
-20
-70
-88
-00
-70
-88
-88
-88
-88
-88
-70
+82
+C6
+AA
+92
+AA
+C6
+82
+C6
+AA
+92
+AA
+C6
+82
 ENDCHAR
-STARTCHAR C079
-ENCODING 7896
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 18 1 -3
+STARTCHAR uni16E6
+ENCODING 5862
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-0800
-1C00
-2200
-0000
-1E00
-2100
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
-0000
-0C00
-0C00
+10
+10
+10
+10
+10
+10
+10
+10
+38
+54
+92
+92
+92
 ENDCHAR
-STARTCHAR C111
-ENCODING 7897
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 -3
+STARTCHAR uni16E7
+ENCODING 5863
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 1 5 2 0
 BITMAP
-20
-70
-88
-00
-70
-88
-88
-88
-88
-88
-70
-00
-30
-30
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C079
-ENCODING 7898
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 16 1 0
+STARTCHAR uni16E8
+ENCODING 5864
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-0400
-0C00
-0800
-1000
-0060
-1E20
-21C0
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+10
+38
+D6
+10
+10
+10
+10
+10
+10
+10
+D6
+38
+10
 ENDCHAR
-STARTCHAR C111
-ENCODING 7899
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 7 12 1 0
+STARTCHAR uni16E9
+ENCODING 5865
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
 BITMAP
-10
-30
-20
-40
-06
-72
-8C
-88
-88
-88
-88
-70
+7C
+84
+84
+84
+84
+84
+74
+0C
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR C079
-ENCODING 7900
+STARTCHAR uni16EA
+ENCODING 5866
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 16 1 0
+BBX 9 13 2 0
 BITMAP
-1000
-1800
-0800
-0400
-0060
-1E20
-21C0
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+2000
+2000
+F800
+2000
+2200
+2600
+2A00
+3200
+0200
+0200
+0200
+0F80
+0200
 ENDCHAR
-STARTCHAR C111
-ENCODING 7901
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 7 12 1 0
+STARTCHAR uni16EB
+ENCODING 5867
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 2 2 2 6
 BITMAP
-40
-60
-20
-10
-06
-72
-8C
-88
-88
-88
-88
-70
+C0
+C0
 ENDCHAR
-STARTCHAR C079
-ENCODING 7902
+STARTCHAR uni16EC
+ENCODING 5868
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 2 7 2 3
+BITMAP
+C0
+C0
+00
+00
+00
+C0
+C0
+ENDCHAR
+STARTCHAR uni16ED
+ENCODING 5869
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 17 1 0
+BBX 9 9 2 2
 BITMAP
-0800
-1400
-0400
-0800
-0800
-0060
-1E20
-21C0
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+3E00
+1C00
+8880
+C980
+FF80
+C980
+8880
+1C00
+3E00
 ENDCHAR
-STARTCHAR C111
-ENCODING 7903
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 7 13 1 0
+STARTCHAR uni16EE
+ENCODING 5870
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
 BITMAP
-20
+10
+18
+14
+10
+10
+30
 50
+90
 10
-20
-20
-06
-72
-8C
-88
-88
-88
-88
-70
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR C079
-ENCODING 7904
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 0
+STARTCHAR uni16EF
+ENCODING 5871
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-1200
-2A00
-2400
-0060
-1E20
-21C0
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
+92
+92
+92
+54
+38
+10
+10
+10
+38
+54
+92
+92
+92
 ENDCHAR
-STARTCHAR C111
-ENCODING 7905
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 7 11 1 0
+STARTCHAR uni16F0
+ENCODING 5872
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 0
 BITMAP
-48
-A8
-90
-06
-72
-8C
-88
-88
-88
-88
-70
+10
+10
+10
+38
+54
+92
+92
+92
+54
+38
+10
+10
+10
 ENDCHAR
-STARTCHAR C079
-ENCODING 7906
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 1 -3
+STARTCHAR uni1E00
+ENCODING 7680
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 0 -4
 BITMAP
-0060
-1E20
-21C0
-4080
-8040
-8040
-8040
-8040
-8040
-4080
-2100
-1E00
-0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
 0C00
+1200
+1200
 0C00
 ENDCHAR
-STARTCHAR C111
-ENCODING 7907
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 7 11 1 -3
+STARTCHAR uni1E01
+ENCODING 7681
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 -4
 BITMAP
-06
-72
-8C
-88
+70
 88
+08
+78
 88
 88
-70
-00
+7C
 30
+48
+48
 30
 ENDCHAR
-STARTCHAR C085
-ENCODING 7908
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 14 1 -3
+STARTCHAR uni1E02
+ENCODING 7682
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 0 0
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
+0C00
+0C00
+0000
+FF00
 2080
+2040
+2040
 2080
+3F00
 2080
+2040
+2040
 2080
-1100
-0E00
-0000
-0C00
-0C00
+FF00
 ENDCHAR
-STARTCHAR C117
-ENCODING 7909
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 10 1 -3
+STARTCHAR uni1E03
+ENCODING 7683
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
-CC
+30
+30
+00
+C0
+40
+40
+40
+40
+78
 44
 44
 44
 44
 44
-3E
-00
-18
-18
+78
 ENDCHAR
-STARTCHAR C085
-ENCODING 7910
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 17 1 0
+STARTCHAR uni1E04
+ENCODING 7684
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 0 -3
 BITMAP
-0400
-0A00
-0200
-0400
-0400
-0000
-FBE0
-2080
-2080
-2080
-2080
+FF00
 2080
+2040
+2040
 2080
+3F00
 2080
+2040
+2040
 2080
-1100
-0E00
+FF00
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR C117
-ENCODING 7911
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 13 1 0
+STARTCHAR uni1E05
+ENCODING 7685
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -3
 BITMAP
-10
-28
-08
-10
-10
-00
-CC
+C0
+40
+40
+40
+40
+78
 44
 44
 44
 44
 44
-3E
+78
+00
+30
+30
 ENDCHAR
-STARTCHAR C085
-ENCODING 7912
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 16 1 0
+STARTCHAR uni1E06
+ENCODING 7686
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 0 -2
 BITMAP
-0200
-0600
-0400
-0830
-0010
-FBE0
+FF00
 2080
+2040
+2040
 2080
+3F00
 2080
+2040
+2040
 2080
+FF00
+0000
+1F00
+ENDCHAR
+STARTCHAR uni1E07
+ENCODING 7687
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -2
+BITMAP
+C0
+40
+40
+40
+40
+78
+44
+44
+44
+44
+44
+78
+00
+7C
+ENDCHAR
+STARTCHAR uni1E08
+ENCODING 7688
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 19 1 -3
+BITMAP
+0400
+0C00
+0800
+1000
+0000
+1E80
+2180
+4080
+8080
+8000
+8000
+8000
+8080
+4080
+2100
+1E00
+0800
+0400
+1C00
+ENDCHAR
+STARTCHAR uni1E09
+ENCODING 7689
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 -3
+BITMAP
+10
+30
+20
+40
+00
+70
+88
+80
+80
+80
+88
+70
+20
+10
+70
+ENDCHAR
+STARTCHAR uni1E0A
+ENCODING 7690
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 0 0
+BITMAP
+0C00
+0C00
+0000
+FE00
+2180
 2080
+2040
+2040
+2040
+2040
+2040
 2080
+2180
+FE00
+ENDCHAR
+STARTCHAR uni1E0B
+ENCODING 7691
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
+BITMAP
+30
+30
+00
+18
+08
+08
+08
+08
+78
+88
+88
+88
+88
+88
+7C
+ENDCHAR
+STARTCHAR uni1E0C
+ENCODING 7692
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 0 -3
+BITMAP
+FE00
+2180
 2080
+2040
+2040
+2040
+2040
+2040
 2080
-1100
-0E00
+2180
+FE00
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR C117
-ENCODING 7913
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 12 1 0
+STARTCHAR uni1E0D
+ENCODING 7693
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -3
 BITMAP
-04
-0C
+18
 08
-13
-01
-CE
+08
+08
+08
+78
+88
+88
+88
+88
+88
+7C
+00
+30
+30
+ENDCHAR
+STARTCHAR uni1E0E
+ENCODING 7694
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 0 -2
+BITMAP
+FE00
+2180
+2080
+2040
+2040
+2040
+2040
+2040
+2080
+2180
+FE00
+0000
+3E00
+ENDCHAR
+STARTCHAR uni1E0F
+ENCODING 7695
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -2
+BITMAP
+18
+08
+08
+08
+08
+78
+88
+88
+88
+88
+88
+7C
+00
+F8
+ENDCHAR
+STARTCHAR uni1E10
+ENCODING 7696
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 0 -3
+BITMAP
+FE00
+2180
+2080
+2040
+2040
+2040
+2040
+2040
+2080
+2180
+FE00
+0800
+0400
+1C00
+ENDCHAR
+STARTCHAR uni1E11
+ENCODING 7697
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -3
+BITMAP
+18
+08
+08
+08
+08
+78
+88
+88
+88
+88
+88
+7C
+20
+10
+70
+ENDCHAR
+STARTCHAR uni1E12
+ENCODING 7698
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 0 -4
+BITMAP
+FE00
+2180
+2080
+2040
+2040
+2040
+2040
+2040
+2080
+2180
+FE00
+0000
+0800
+1C00
+2200
+ENDCHAR
+STARTCHAR uni1E13
+ENCODING 7699
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
+BITMAP
+18
+08
+08
+08
+08
+78
+88
+88
+88
+88
+88
+7C
+00
+20
+70
+88
+ENDCHAR
+STARTCHAR uni1E14
+ENCODING 7700
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 18 0 0
+BITMAP
+1000
+1800
+0800
+0400
+0000
+3E00
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+ENDCHAR
+STARTCHAR uni1E15
+ENCODING 7701
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 14 1 0
+BITMAP
+40
+60
+20
+10
+00
+F8
+00
+70
+88
+F8
+80
+80
+88
+70
+ENDCHAR
+STARTCHAR uni1E16
+ENCODING 7702
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 18 0 0
+BITMAP
+0400
+0C00
+0800
+1000
+0000
+3E00
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+ENDCHAR
+STARTCHAR uni1E17
+ENCODING 7703
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 14 1 0
+BITMAP
+10
+30
+20
+40
+00
+F8
+00
+70
+88
+F8
+80
+80
+88
+70
+ENDCHAR
+STARTCHAR uni1E18
+ENCODING 7704
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 0 -4
+BITMAP
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+0000
+0800
+1C00
+2200
+ENDCHAR
+STARTCHAR uni1E19
+ENCODING 7705
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 -4
+BITMAP
+70
+88
+F8
+80
+80
+88
+70
+00
+20
+70
+88
+ENDCHAR
+STARTCHAR uni1E1A
+ENCODING 7706
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 0 -4
+BITMAP
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+0000
+1200
+2A00
+2400
+ENDCHAR
+STARTCHAR uni1E1B
+ENCODING 7707
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 -4
+BITMAP
+70
+88
+F8
+80
+80
+88
+70
+00
+48
+A8
+90
+ENDCHAR
+STARTCHAR uni1E1C
+ENCODING 7708
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 0 -3
+BITMAP
+2100
+1E00
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+0800
+0400
+1C00
+ENDCHAR
+STARTCHAR uni1E1D
+ENCODING 7709
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 13 0 -3
+BITMAP
+84
+78
+00
+38
 44
+7C
+40
+40
 44
+38
+10
+08
+38
+ENDCHAR
+STARTCHAR uni1E1E
+ENCODING 7710
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 0 0
+BITMAP
+1800
+1800
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2200
+2200
+2000
+2000
+F800
+ENDCHAR
+STARTCHAR uni1E1F
+ENCODING 7711
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 0
+BITMAP
+60
+60
+00
+38
+48
+40
+40
+40
+F0
+40
+40
+40
+40
+40
+E0
+ENDCHAR
+STARTCHAR uni1E20
+ENCODING 7712
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 1 0
+BITMAP
+3E00
+0000
+1E80
+2180
+4080
+8080
+8000
+8000
+83C0
+8080
+4080
+2080
+1F80
+ENDCHAR
+STARTCHAR uni1E21
+ENCODING 7713
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 13 1 -4
+BITMAP
+7C
+00
+3E
 44
 44
 44
-3E
+78
+40
+7C
+82
+82
+82
+7C
 ENDCHAR
-STARTCHAR C085
-ENCODING 7914
+STARTCHAR uni1E22
+ENCODING 7714
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 16 1 0
+BBX 11 14 0 0
 BITMAP
-0800
 0C00
-0400
-0230
-0010
+0C00
+0000
 FBE0
 2080
 2080
 2080
 2080
+3F80
 2080
 2080
 2080
 2080
-1100
-0E00
+FBE0
 ENDCHAR
-STARTCHAR C117
-ENCODING 7915
+STARTCHAR uni1E23
+ENCODING 7715
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 8 12 1 0
+BBX 7 15 1 0
 BITMAP
+30
+30
+00
+C0
 40
-60
-20
-13
-01
-CE
+40
+40
+40
+78
 44
 44
 44
 44
 44
-3E
+EE
 ENDCHAR
-STARTCHAR C085
-ENCODING 7916
+STARTCHAR uni1E24
+ENCODING 7716
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 17 1 0
+BBX 11 14 0 -3
 BITMAP
-0400
-0A00
-0200
-0400
-0430
-0010
 FBE0
 2080
 2080
 2080
 2080
+3F80
 2080
 2080
 2080
 2080
-1100
-0E00
+FBE0
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR C117
-ENCODING 7917
+STARTCHAR uni1E25
+ENCODING 7717
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 8 13 1 0
+BBX 7 15 1 -3
 BITMAP
-10
-28
-08
-10
-13
-01
-CE
+C0
+40
+40
+40
+40
+78
 44
 44
 44
 44
 44
-3E
+EE
+00
+18
+18
 ENDCHAR
-STARTCHAR C085
-ENCODING 7918
+STARTCHAR uni1E26
+ENCODING 7718
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 15 1 0
+BBX 11 14 0 0
 BITMAP
-0900
-1500
-1230
-0010
+1B00
+1B00
+0000
 FBE0
 2080
 2080
 2080
 2080
+3F80
 2080
 2080
 2080
 2080
-1100
-0E00
+FBE0
 ENDCHAR
-STARTCHAR C117
-ENCODING 7919
+STARTCHAR uni1E27
+ENCODING 7719
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 8 12 1 0
+BBX 7 15 1 0
 BITMAP
-24
-54
-48
-03
-01
-CE
+D8
+D8
+00
+C0
+40
+40
+40
+40
+78
 44
 44
 44
 44
 44
-3E
+EE
 ENDCHAR
-STARTCHAR C085
-ENCODING 7920
+STARTCHAR uni1E28
+ENCODING 7720
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 16 1 -3
+BBX 11 14 0 -3
 BITMAP
-0030
-0010
 FBE0
 2080
 2080
 2080
 2080
+3F80
 2080
 2080
 2080
 2080
-1100
-0E00
-0000
-0C00
-0C00
+FBE0
+1000
+0800
+3800
 ENDCHAR
-STARTCHAR C117
-ENCODING 7921
+STARTCHAR uni1E29
+ENCODING 7721
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 8 12 1 -3
+BBX 7 15 1 -3
 BITMAP
-03
-01
-CE
+C0
+40
+40
+40
+40
+78
 44
 44
 44
 44
 44
-3E
-00
-18
-18
+EE
+40
+20
+E0
 ENDCHAR
-STARTCHAR C089
-ENCODING 7922
+STARTCHAR uni1E2A
+ENCODING 7722
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 16 0 0
+BBX 11 14 0 -3
 BITMAP
-0800
-0C00
-0400
-0200
-0000
-F1E0
+FBE0
 2080
-1100
-1100
-0A00
-0E00
-0400
-0400
-0400
-0400
-1F00
+2080
+2080
+2080
+3F80
+2080
+2080
+2080
+2080
+FBE0
+0000
+1080
+0F00
 ENDCHAR
-STARTCHAR C121
-ENCODING 7923
+STARTCHAR uni1E2B
+ENCODING 7723
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 8 15 1 -3
+BBX 7 15 1 -3
+BITMAP
+C0
+40
+40
+40
+40
+78
+44
+44
+44
+44
+44
+EE
+00
+42
+3C
+ENDCHAR
+STARTCHAR uni1E2C
+ENCODING 7724
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 -4
 BITMAP
+F8
 20
-30
-10
-08
+20
+20
+20
+20
+20
+20
+20
+20
+F8
 00
-E7
-24
-24
-24
-18
-18
-18
-10
+48
+A8
 90
-E0
 ENDCHAR
-STARTCHAR C089
-ENCODING 7924
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 14 0 -3
+STARTCHAR uni1E2D
+ENCODING 7725
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 11 0 -4
 BITMAP
-F1E0
-2080
-1100
-1100
-0A00
-0E00
-0400
-0400
-0400
-0400
-1F00
-0000
-0C00
-0C00
+60
+20
+20
+20
+20
+20
+70
+00
+48
+A8
+90
 ENDCHAR
-STARTCHAR C121
-ENCODING 7925
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 10 1 -3
+STARTCHAR uni1E2E
+ENCODING 7726
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 19 1 0
 BITMAP
-E7
-24
-24
-24
-18
-18
-18
 10
-96
-E6
+30
+20
+40
+00
+D8
+D8
+00
+F8
+20
+20
+20
+20
+20
+20
+20
+20
+20
+F8
 ENDCHAR
-STARTCHAR C089
-ENCODING 7926
+STARTCHAR uni1E2F
+ENCODING 7727
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 15 0 0
+BITMAP
+10
+30
+20
+40
+00
+D8
+D8
+00
+60
+20
+20
+20
+20
+20
+70
+ENDCHAR
+STARTCHAR uni1E30
+ENCODING 7728
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 17 0 0
+BBX 11 16 1 0
 BITMAP
-0400
-0A00
 0200
-0400
+0600
 0400
+0800
 0000
-F1E0
+F9E0
 2080
-1100
-1100
-0A00
-0E00
-0400
-0400
-0400
-0400
-1F00
+2100
+2200
+2400
+2E00
+3200
+2100
+2100
+2080
+F9E0
 ENDCHAR
-STARTCHAR C121
-ENCODING 7927
+STARTCHAR uni1E31
+ENCODING 7729
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 8 16 1 -3
+BBX 7 17 1 0
 BITMAP
-10
-28
 08
-10
-10
-00
-E7
-24
-24
-24
-18
 18
-18
 10
-90
-E0
+20
+00
+C0
+40
+40
+40
+40
+5E
+48
+50
+70
+58
+48
+EE
 ENDCHAR
-STARTCHAR C089
-ENCODING 7928
+STARTCHAR uni1E32
+ENCODING 7730
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 15 0 0
+BBX 11 14 1 -3
 BITMAP
-0900
-1500
-1200
-0000
-F1E0
+F9E0
 2080
-1100
-1100
-0A00
-0E00
-0400
-0400
-0400
-0400
-1F00
+2100
+2200
+2400
+2E00
+3200
+2100
+2100
+2080
+F9E0
+0000
+0600
+0600
 ENDCHAR
-STARTCHAR C121
-ENCODING 7929
+STARTCHAR uni1E33
+ENCODING 7731
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 8 14 1 -3
+BBX 7 15 1 -3
 BITMAP
-12
-2A
-24
+C0
+40
+40
+40
+40
+5E
+48
+50
+70
+58
+48
+EE
 00
-E7
-24
-24
-24
-18
-18
-18
-10
-90
-E0
+30
+30
 ENDCHAR
-STARTCHAR C130
-ENCODING 7936
+STARTCHAR uni1E34
+ENCODING 7732
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -2
+BITMAP
+F9E0
+2080
+2100
+2200
+2400
+2E00
+3200
+2100
+2100
+2080
+F9E0
+0000
+1F00
+ENDCHAR
+STARTCHAR uni1E35
+ENCODING 7733
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 12 1 0
+BBX 7 14 1 -2
 BITMAP
-18
-18
-08
-10
+C0
+40
+40
+40
+40
+5E
+48
+50
+70
+58
+48
+EE
 00
-62
-92
-94
-8C
-88
-98
-66
+7C
 ENDCHAR
-STARTCHAR C129
-ENCODING 7937
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni1E36
+ENCODING 7734
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 14 0 -3
 BITMAP
-30
-30
+F8
 20
-10
+20
+20
+20
+20
+21
+21
+21
+23
+FF
 00
-62
-92
-94
-8C
-88
-98
-66
+18
+18
 ENDCHAR
-STARTCHAR C138
-ENCODING 7938
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni1E37
+ENCODING 7735
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 15 1 -3
 BITMAP
-68
-68
-24
-44
+C0
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+E0
 00
-62
-92
-94
-8C
-88
-98
-66
+60
+60
 ENDCHAR
-STARTCHAR C138
-ENCODING 7939
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni1E38
+ENCODING 7736
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 16 0 -3
 BITMAP
-68
-68
-44
-24
+F8
 00
-62
-92
-94
-8C
-88
-98
-66
+F8
+20
+20
+20
+20
+20
+21
+21
+21
+23
+FF
+00
+18
+18
 ENDCHAR
-STARTCHAR C138
-ENCODING 7940
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni1E39
+ENCODING 7737
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 17 0 -3
 BITMAP
-64
-64
-28
-48
+F8
 00
-62
-92
-94
-8C
-88
-98
-66
+60
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+70
+00
+30
+30
 ENDCHAR
-STARTCHAR C138
-ENCODING 7941
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni1E3A
+ENCODING 7738
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 0 -2
 BITMAP
-64
-64
-48
-28
+F8
+20
+20
+20
+20
+20
+21
+21
+21
+23
+FF
 00
-62
-92
-94
-8C
-88
-98
-66
+3E
 ENDCHAR
-STARTCHAR C130
-ENCODING 7942
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 16 1 0
+STARTCHAR uni1E3B
+ENCODING 7739
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 14 0 -2
 BITMAP
-24
-54
-48
-00
-18
-18
-08
-10
+60
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+70
 00
-62
-92
-94
-8C
-88
-98
-66
+F8
 ENDCHAR
-STARTCHAR C129
-ENCODING 7943
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 16 1 0
+STARTCHAR uni1E3C
+ENCODING 7740
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 0 -4
 BITMAP
-24
-54
-48
-00
-30
-30
+F8
+20
+20
+20
+20
 20
+21
+21
+21
+23
+FF
+00
 10
+38
+44
+ENDCHAR
+STARTCHAR uni1E3D
+ENCODING 7741
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 16 0 -4
+BITMAP
+60
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+70
 00
-62
-92
-94
-8C
+20
+70
 88
-98
-66
 ENDCHAR
-STARTCHAR C065
-ENCODING 7944
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 13 0 0
+STARTCHAR uni1E3E
+ENCODING 7742
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 16 1 0
 BITMAP
-6000
-6000
-2400
-4400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+0100
+0300
+0200
+0400
+0000
+F03C
+3030
+3030
+2850
+2850
+2890
+2490
+2490
+2310
+2310
+FB7C
 ENDCHAR
-STARTCHAR C065
-ENCODING 7945
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 13 0 0
+STARTCHAR uni1E3F
+ENCODING 7743
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 12 1 0
 BITMAP
-6000
-6000
-4400
-2400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+0200
+0600
+0400
+0800
+0000
+FB80
+4440
+4440
+4440
+4440
+4440
+E660
 ENDCHAR
-STARTCHAR 0x1F0A
-ENCODING 7946
+STARTCHAR uni1E40
+ENCODING 7744
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 14 1 0
+BITMAP
+0300
+0300
+0000
+F03C
+3030
+3030
+2850
+2850
+2890
+2490
+2490
+2310
+2310
+FB7C
+ENDCHAR
+STARTCHAR uni1E41
+ENCODING 7745
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 13 0 0
+BBX 11 10 1 0
 BITMAP
-D000
-D000
-4A00
-8A00
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
+0C00
+0C00
+0000
+FB80
+4440
+4440
+4440
+4440
+4440
+E660
 ENDCHAR
-STARTCHAR 0x1F0B
-ENCODING 7947
+STARTCHAR uni1E42
+ENCODING 7746
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 14 1 -3
+BITMAP
+F03C
+3030
+3030
+2850
+2850
+2890
+2490
+2490
+2310
+2310
+FB7C
+0000
+0300
+0300
+ENDCHAR
+STARTCHAR uni1E43
+ENCODING 7747
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 13 0 0
+BBX 11 10 1 -3
 BITMAP
-D000
-D000
-8A00
-4A00
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
+FB80
+4440
+4440
+4440
+4440
+4440
+E660
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR 0x1F0C
-ENCODING 7948
+STARTCHAR uni1E44
+ENCODING 7748
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 13 0 0
+BBX 11 14 1 0
 BITMAP
-C800
-C800
-5200
-9200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
+0C00
+0C00
+0000
+E3E0
+3080
+3080
+2880
+2880
+2480
+2280
+2280
+2180
+2180
+F880
 ENDCHAR
-STARTCHAR 0x1F0D
-ENCODING 7949
+STARTCHAR uni1E45
+ENCODING 7749
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 10 1 0
+BITMAP
+30
+30
+00
+F8
+44
+44
+44
+44
+44
+EE
+ENDCHAR
+STARTCHAR uni1E46
+ENCODING 7750
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 13 0 0
+BBX 11 14 1 -3
 BITMAP
-C800
-C800
-9200
-5200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
+E3E0
+3080
+3080
+2880
+2880
+2480
+2280
+2280
+2180
+2180
+F880
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR 0x1F0E
-ENCODING 7950
+STARTCHAR uni1E47
+ENCODING 7751
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 10 1 -3
+BITMAP
+F8
+44
+44
+44
+44
+44
+EE
+00
+18
+18
+ENDCHAR
+STARTCHAR uni1E48
+ENCODING 7752
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 17 0 0
+BBX 11 13 1 -2
 BITMAP
-4800
-A800
-9000
+E3E0
+3080
+3080
+2880
+2880
+2480
+2280
+2280
+2180
+2180
+F880
 0000
-3000
-3000
-1200
-2200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
+1F00
 ENDCHAR
-STARTCHAR 0x1F0F
-ENCODING 7951
+STARTCHAR uni1E49
+ENCODING 7753
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 9 1 -2
+BITMAP
+F8
+44
+44
+44
+44
+44
+EE
+00
+7C
+ENDCHAR
+STARTCHAR uni1E4A
+ENCODING 7754
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 17 0 0
+BBX 11 15 1 -4
 BITMAP
-4800
-A800
-9000
+E3E0
+3080
+3080
+2880
+2880
+2480
+2280
+2280
+2180
+2180
+F880
 0000
-3000
-3000
-2200
+0400
+0E00
+1100
+ENDCHAR
+STARTCHAR uni1E4B
+ENCODING 7755
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 -4
+BITMAP
+F8
+4C
+44
+44
+44
+44
+EE
+00
+10
+38
+44
+ENDCHAR
+STARTCHAR uni1E4C
+ENCODING 7756
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 20 1 0
+BITMAP
+0400
+0C00
+0800
+1000
+0000
 1200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
+2A00
+2400
+0000
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR C090
-ENCODING 7952
+STARTCHAR uni1E4D
+ENCODING 7757
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 16 1 0
 BITMAP
-60
-60
+10
+30
 20
 40
 00
-70
+48
+A8
 90
-80
-60
-80
-88
-70
-ENDCHAR
-STARTCHAR C090
-ENCODING 7953
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 12 1 0
-BITMAP
-60
-60
-40
-20
 00
 70
-90
-80
-60
-80
 88
-70
-ENDCHAR
-STARTCHAR C090
-ENCODING 7954
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 12 1 0
-BITMAP
-D0
-D0
-48
 88
-00
-70
-90
-80
-60
-80
 88
+88
+88
 70
 ENDCHAR
-STARTCHAR C090
-ENCODING 7955
+STARTCHAR uni1E4E
+ENCODING 7758
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 18 1 0
+BITMAP
+3600
+3600
+0000
+1200
+2A00
+2400
+0000
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
+ENDCHAR
+STARTCHAR uni1E4F
+ENCODING 7759
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 14 1 0
 BITMAP
-D0
-D0
-88
+D8
+D8
+00
 48
+A8
+90
 00
 70
-90
-80
-60
-80
 88
+88
+88
+88
+88
 70
 ENDCHAR
-STARTCHAR C090
-ENCODING 7956
+STARTCHAR uni1E50
+ENCODING 7760
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 18 1 0
+BITMAP
+1000
+1800
+0800
+0400
+0000
+3E00
+0000
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
+ENDCHAR
+STARTCHAR uni1E51
+ENCODING 7761
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 14 1 0
 BITMAP
-C8
-C8
-50
-90
+40
+60
+20
+10
+00
+F8
 00
 70
-90
-80
-60
-80
+88
+88
+88
+88
 88
 70
 ENDCHAR
-STARTCHAR C090
-ENCODING 7957
+STARTCHAR uni1E52
+ENCODING 7762
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 18 1 0
+BITMAP
+0400
+0C00
+0800
+1000
+0000
+3E00
+0000
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
+ENDCHAR
+STARTCHAR uni1E53
+ENCODING 7763
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 14 1 0
 BITMAP
-C8
-C8
-90
-50
+10
+30
+20
+40
 00
+F8
+00
 70
-90
-80
-60
-80
 88
+88
+88
+88
+88
 70
-ENDCHAR
-STARTCHAR 0x1F18
-ENCODING 7960
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 13 0 0
-BITMAP
-C000
-C000
-5FF0
-8410
-0410
-0450
-0440
-07C0
-0448
-0448
-0410
-0410
-1FF0
-ENDCHAR
-STARTCHAR 0x1F19
-ENCODING 7961
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 13 0 0
-BITMAP
-C000
-C000
-9FF0
-4410
-0410
-0450
-0440
-07C0
-0448
-0448
-0410
-0410
-1FF0
-ENDCHAR
-STARTCHAR 0x1F1A
-ENCODING 7962
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 13 0 0
-BITMAP
-D000
-D000
-4FFC
-8904
-0104
-0114
-0110
-01F0
-0112
-0112
-0104
-0104
-07FC
-ENDCHAR
-STARTCHAR 0x1F1B
-ENCODING 7963
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 13 0 0
-BITMAP
-D000
-D000
-8FFC
-4904
-0104
-0114
-0110
-01F0
-0112
-0112
-0104
-0104
-07FC
-ENDCHAR
-STARTCHAR 0x1F1C
-ENCODING 7964
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 13 0 0
-BITMAP
-C800
-C800
-57FC
-9104
-0104
-0114
-0110
-01F0
-0112
-0112
-0104
-0104
-07FC
 ENDCHAR
-STARTCHAR 0x1F1D
-ENCODING 7965
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 13 0 0
+STARTCHAR uni1E54
+ENCODING 7764
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 0 0
 BITMAP
-C800
-C800
-97FC
-5104
-0104
-0114
-0110
-01F0
-0112
-0112
-0104
-0104
-07FC
+0400
+0C00
+0800
+1000
+0000
+FF00
+2180
+2080
+2080
+2180
+3F00
+2000
+2000
+2000
+2000
+F800
 ENDCHAR
-STARTCHAR C090
-ENCODING 7968
+STARTCHAR uni1E55
+ENCODING 7765
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 16 1 -4
+BBX 6 15 1 -3
 BITMAP
-30
-30
 10
+30
 20
+40
 00
-98
-64
+F8
 44
 44
 44
 44
 44
-04
-04
-04
-04
+78
+40
+40
+E0
 ENDCHAR
-STARTCHAR C090
-ENCODING 7969
+STARTCHAR uni1E56
+ENCODING 7766
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 0 0
+BITMAP
+1800
+1800
+0000
+FF00
+2180
+2080
+2080
+2180
+3F00
+2000
+2000
+2000
+2000
+F800
+ENDCHAR
+STARTCHAR uni1E57
+ENCODING 7767
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 16 1 -4
+BBX 6 13 1 -3
 BITMAP
 30
 30
-20
-10
 00
-98
-64
+F8
 44
 44
 44
 44
 44
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C090
-ENCODING 7970
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
-BITMAP
-68
-68
-24
-44
-00
-98
-64
-44
-44
-44
-44
-44
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C090
-ENCODING 7971
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
-BITMAP
-68
-68
-44
-24
-00
-98
-64
-44
-44
-44
-44
-44
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C090
-ENCODING 7972
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
-BITMAP
-64
-64
-28
-48
-00
-98
-64
-44
-44
-44
-44
-44
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C090
-ENCODING 7973
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
-BITMAP
-64
-64
-48
-28
-00
-98
-64
-44
-44
-44
-44
-44
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C130
-ENCODING 7974
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 20 1 -4
-BITMAP
-48
-A8
-90
-00
-30
-30
-10
-20
-00
-98
-64
-44
-44
-44
-44
-44
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C130
-ENCODING 7975
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 20 1 -4
-BITMAP
-48
-A8
-90
-00
-30
-30
-20
-10
-00
-98
-64
-44
-44
-44
-44
-44
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C072
-ENCODING 7976
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
-BITMAP
-C000
-C000
-5F7C
-8410
-0410
-0410
-0410
-07F0
-0410
-0410
-0410
-0410
-1F7C
-ENDCHAR
-STARTCHAR C072
-ENCODING 7977
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
-BITMAP
-C000
-C000
-9F7C
-4410
-0410
-0410
-0410
-07F0
-0410
-0410
-0410
-0410
-1F7C
-ENDCHAR
-STARTCHAR C072
-ENCODING 7978
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 13 0 0
-BITMAP
-D000
-D000
-4FDF
-8904
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-ENDCHAR
-STARTCHAR C072
-ENCODING 7979
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 13 0 0
-BITMAP
-D000
-D000
-8FDF
-4904
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-ENDCHAR
-STARTCHAR C072
-ENCODING 7980
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 13 0 0
-BITMAP
-C800
-C800
-57DF
-9104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-ENDCHAR
-STARTCHAR C072
-ENCODING 7981
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 13 0 0
-BITMAP
-C800
-C800
-97DF
-5104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-ENDCHAR
-STARTCHAR 0x1F2E
-ENCODING 7982
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 17 0 0
-BITMAP
-4800
-A800
-9000
-0000
-3000
-3000
-17DF
-2104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
+78
+40
+40
+E0
 ENDCHAR
-STARTCHAR 0x1F2F
-ENCODING 7983
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 17 0 0
+STARTCHAR uni1E58
+ENCODING 7768
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 1 0
 BITMAP
-4800
-A800
-9000
+1800
+1800
 0000
-3000
-3000
-27DF
-1104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
+FE00
+2100
+2080
+2080
+2100
+3E00
+2300
+2100
+2100
+2100
+F8E0
 ENDCHAR
-STARTCHAR C090
-ENCODING 7984
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 12 1 0
+STARTCHAR uni1E59
+ENCODING 7769
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 0
 BITMAP
 60
 60
-20
-40
 00
+D0
+68
 40
-C0
 40
 40
 40
-50
-20
+F0
 ENDCHAR
-STARTCHAR C090
-ENCODING 7985
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 12 1 0
+STARTCHAR uni1E5A
+ENCODING 7770
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 1 -3
 BITMAP
-60
-60
-40
-20
-00
-40
-C0
-40
-40
-40
-50
-20
+FE00
+2100
+2080
+2080
+2100
+3E00
+2300
+2100
+2100
+2100
+F8E0
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR C090
-ENCODING 7986
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 12 1 0
+STARTCHAR uni1E5B
+ENCODING 7771
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 -3
 BITMAP
 D0
-D0
-48
-88
-00
+68
 40
-C0
 40
 40
 40
-50
-20
+F0
+00
+60
+60
 ENDCHAR
-STARTCHAR C090
-ENCODING 7987
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 12 1 0
+STARTCHAR uni1E5C
+ENCODING 7772
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 16 1 -3
 BITMAP
-D0
-D0
-88
-48
-00
-40
-C0
-40
-40
-40
-50
-20
+3E00
+0000
+FE00
+2100
+2080
+2080
+2100
+3E00
+2300
+2100
+2100
+2100
+F8E0
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR C090
-ENCODING 7988
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 12 1 0
+STARTCHAR uni1E5D
+ENCODING 7773
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 -3
 BITMAP
-C8
-C8
-50
-90
+F8
 00
+D0
+68
 40
-C0
 40
 40
 40
-50
-20
+F0
+00
+60
+60
 ENDCHAR
-STARTCHAR C090
-ENCODING 7989
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 12 1 0
+STARTCHAR uni1E5E
+ENCODING 7774
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 1 -2
 BITMAP
-C8
-C8
-90
-50
-00
+FE00
+2100
+2080
+2080
+2100
+3E00
+2300
+2100
+2100
+2100
+F8E0
+0000
+1F00
+ENDCHAR
+STARTCHAR uni1E5F
+ENCODING 7775
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 -2
+BITMAP
+D0
+68
 40
-C0
 40
 40
 40
-50
-20
+F0
+00
+F8
 ENDCHAR
-STARTCHAR C090
-ENCODING 7990
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 16 1 0
+STARTCHAR uni1E60
+ENCODING 7776
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 0
 BITMAP
-48
-A8
-90
-00
-60
-60
-20
-40
+30
+30
 00
-40
-C0
-40
-40
+7C
+84
+84
+80
 40
-50
-20
+30
+08
+04
+84
+84
+F8
 ENDCHAR
-STARTCHAR C090
-ENCODING 7991
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 16 1 0
+STARTCHAR uni1E61
+ENCODING 7777
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 0
 BITMAP
-48
-A8
-90
-00
 60
 60
-40
-20
 00
-40
-C0
-40
-40
-40
-50
-20
+78
+88
+80
+70
+08
+88
+F0
 ENDCHAR
-STARTCHAR C072
-ENCODING 7992
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 13 0 0
+STARTCHAR uni1E62
+ENCODING 7778
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -3
 BITMAP
-C0
-C0
-5F
+7C
 84
-04
-04
-04
-04
-04
-04
-04
-04
-1F
-ENDCHAR
-STARTCHAR C072
-ENCODING 7993
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 13 0 0
-BITMAP
-C0
-C0
-9F
-44
-04
-04
-04
-04
-04
-04
-04
+84
+80
+40
+30
+08
 04
-1F
-ENDCHAR
-STARTCHAR C072
-ENCODING 7994
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 0 0
-BITMAP
-D000
-D000
-4FC0
-8900
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-07C0
-ENDCHAR
-STARTCHAR C072
-ENCODING 7995
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 0 0
-BITMAP
-D000
-D000
-8FC0
-4900
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-07C0
-ENDCHAR
-STARTCHAR C072
-ENCODING 7996
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 0 0
-BITMAP
-C800
-C800
-57C0
-9100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-07C0
-ENDCHAR
-STARTCHAR C072
-ENCODING 7997
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 0 0
-BITMAP
-C800
-C800
-97C0
-5100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-07C0
-ENDCHAR
-STARTCHAR C072
-ENCODING 7998
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 0 0
-BITMAP
-4800
-A800
-9000
-0000
-3000
-3000
-17C0
-2100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-07C0
-ENDCHAR
-STARTCHAR C072
-ENCODING 7999
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 0 0
-BITMAP
-4800
-A800
-9000
-0000
-3000
-3000
-27C0
-1100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-07C0
+84
+84
+F8
+00
+30
+30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8000
+STARTCHAR uni1E63
+ENCODING 7779
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 10 1 -3
 BITMAP
+78
+88
+80
+70
+08
+88
+F0
+00
 60
 60
+ENDCHAR
+STARTCHAR uni1E64
+ENCODING 7780
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 19 1 0
+BITMAP
+30
+30
+00
+08
+18
+10
 20
-40
 00
-70
-88
-88
-88
-88
-88
-70
+7C
+84
+84
+80
+40
+30
+08
+04
+84
+84
+F8
 ENDCHAR
-STARTCHAR C090
-ENCODING 8001
+STARTCHAR uni1E65
+ENCODING 7781
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 15 1 0
 BITMAP
 60
 60
-40
+00
+10
+30
 20
+40
 00
-70
-88
-88
-88
-88
+78
 88
+80
 70
+08
+88
+F0
 ENDCHAR
-STARTCHAR C090
-ENCODING 8002
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 12 1 0
+STARTCHAR uni1E66
+ENCODING 7782
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 18 1 0
 BITMAP
-D0
-D0
-48
-88
+30
+30
 00
-70
-88
-88
-88
-88
-88
-70
+44
+38
+10
+00
+7C
+84
+84
+80
+40
+30
+08
+04
+84
+84
+F8
 ENDCHAR
-STARTCHAR C090
-ENCODING 8003
+STARTCHAR uni1E67
+ENCODING 7783
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 14 1 0
 BITMAP
-D0
-D0
-88
-48
+60
+60
 00
-70
-88
 88
-88
-88
+70
+20
+00
+78
 88
+80
 70
+08
+88
+F0
 ENDCHAR
-STARTCHAR C090
-ENCODING 8004
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 12 1 0
+STARTCHAR uni1E68
+ENCODING 7784
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 17 1 -3
 BITMAP
-C8
-C8
-50
-90
+30
+30
 00
-70
-88
-88
-88
-88
-88
-70
+7C
+84
+84
+80
+40
+30
+08
+04
+84
+84
+F8
+00
+30
+30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8005
+STARTCHAR uni1E69
+ENCODING 7785
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 13 1 -3
 BITMAP
-C8
-C8
-90
-50
+60
+60
 00
-70
-88
-88
-88
-88
+78
 88
+80
 70
+08
+88
+F0
+00
+60
+60
 ENDCHAR
-STARTCHAR C079
-ENCODING 8008
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 13 0 0
+STARTCHAR uni1E6A
+ENCODING 7786
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 0
 BITMAP
-C000
-C000
-4F00
-9080
-2040
-4020
-4020
-4020
-4020
-4020
-2040
-1080
-0F00
+1800
+1800
+0000
+FF80
+8880
+8880
+8880
+0800
+0800
+0800
+0800
+0800
+0800
+3E00
 ENDCHAR
-STARTCHAR C079
-ENCODING 8009
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 13 0 0
+STARTCHAR uni1E6B
+ENCODING 7787
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 0
 BITMAP
-C000
-C000
-8F00
-5080
-2040
-4020
-4020
-4020
-4020
-4020
-2040
-1080
-0F00
+30
+30
+00
+20
+20
+20
+F8
+20
+20
+20
+24
+24
+18
 ENDCHAR
-STARTCHAR 0x1F4A
-ENCODING 8010
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
+STARTCHAR uni1E6C
+ENCODING 7788
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -3
 BITMAP
-D000
-D000
-49E0
-8A10
-0408
-0804
-0804
-0804
-0804
-0804
-0408
-0210
-01E0
+FF80
+8880
+8880
+8880
+0800
+0800
+0800
+0800
+0800
+0800
+3E00
+0000
+1800
+1800
 ENDCHAR
-STARTCHAR 0x1F4B
-ENCODING 8011
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
+STARTCHAR uni1E6D
+ENCODING 7789
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 -3
 BITMAP
-D000
-D000
-89E0
-4A10
-0408
-0804
-0804
-0804
-0804
-0804
-0408
-0210
-01E0
-ENDCHAR
-STARTCHAR 0x1F4C
-ENCODING 8012
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
-BITMAP
-C800
-C800
-51E0
-9210
-0408
-0804
-0804
-0804
-0804
-0804
-0408
-0210
-01E0
+20
+20
+20
+F8
+20
+20
+20
+24
+24
+18
+00
+30
+30
 ENDCHAR
-STARTCHAR 0x1F4D
-ENCODING 8013
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
+STARTCHAR uni1E6E
+ENCODING 7790
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 13 1 -2
 BITMAP
-C800
-C800
-91E0
-5210
-0408
-0804
-0804
-0804
-0804
-0804
-0408
-0210
-01E0
+FF80
+8880
+8880
+8880
+0800
+0800
+0800
+0800
+0800
+0800
+3E00
+0000
+3E00
 ENDCHAR
-STARTCHAR C117
-ENCODING 8016
+STARTCHAR uni1E6F
+ENCODING 7791
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 12 1 0
+BBX 6 12 1 -2
 BITMAP
-30
-30
-10
 20
+20
+20
+F8
+20
+20
+20
+24
+24
+18
 00
-C8
-44
-44
-44
-44
-48
-30
+7C
 ENDCHAR
-STARTCHAR C117
-ENCODING 8017
+STARTCHAR uni1E70
+ENCODING 7792
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 -4
+BITMAP
+FF80
+8880
+8880
+8880
+0800
+0800
+0800
+0800
+0800
+0800
+3E00
+0000
+0800
+1C00
+2200
+ENDCHAR
+STARTCHAR uni1E71
+ENCODING 7793
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 12 1 0
+BBX 6 14 1 -4
 BITMAP
-30
-30
 20
-10
+20
+20
+F8
+20
+20
+20
+24
+24
+18
 00
-C8
-44
-44
-44
+10
+38
 44
-48
-30
 ENDCHAR
-STARTCHAR C117
-ENCODING 8018
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni1E72
+ENCODING 7794
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 -3
 BITMAP
-68
-68
-24
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
+0000
+1B00
+1B00
+ENDCHAR
+STARTCHAR uni1E73
+ENCODING 7795
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 10 1 -3
+BITMAP
+CC
 44
-00
-C8
 44
 44
 44
 44
-48
-30
+3E
+00
+6C
+6C
 ENDCHAR
-STARTCHAR C117
-ENCODING 8019
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni1E74
+ENCODING 7796
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 -4
 BITMAP
-68
-68
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
+0000
+0900
+1500
+1200
+ENDCHAR
+STARTCHAR uni1E75
+ENCODING 7797
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 -4
+BITMAP
+CC
 44
-24
-00
-C8
 44
 44
 44
 44
+3E
+00
+24
+54
 48
-30
 ENDCHAR
-STARTCHAR C117
-ENCODING 8020
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni1E76
+ENCODING 7798
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 -4
 BITMAP
-64
-64
-28
-48
-00
-C8
-44
-44
-44
-44
-48
-30
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
+0000
+0400
+0E00
+1100
 ENDCHAR
-STARTCHAR C117
-ENCODING 8021
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni1E77
+ENCODING 7799
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 -4
 BITMAP
-64
-64
-48
-28
-00
-C8
+CC
 44
 44
 44
 44
-48
-30
+44
+3E
+00
+10
+38
+44
 ENDCHAR
-STARTCHAR C117
-ENCODING 8022
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 0
+STARTCHAR uni1E78
+ENCODING 7800
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 20 1 0
 BITMAP
-48
-A8
-90
-00
-30
-30
+0200
+0600
+0400
+0800
+0000
+0900
+1500
+1200
+0000
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
+ENDCHAR
+STARTCHAR uni1E79
+ENCODING 7801
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 16 1 0
+BITMAP
+08
+18
 10
 20
 00
-C8
+24
+54
+48
+00
+CC
 44
 44
 44
 44
-48
-30
+44
+3E
 ENDCHAR
-STARTCHAR C117
-ENCODING 8023
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 0
+STARTCHAR uni1E7A
+ENCODING 7802
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 16 1 0
 BITMAP
-48
-A8
-90
+1B00
+1B00
+0000
+1F00
+0000
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
+ENDCHAR
+STARTCHAR uni1E7B
+ENCODING 7803
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 0
+BITMAP
+6C
+6C
 00
-30
-30
-20
-10
+7C
 00
-C8
+CC
 44
 44
 44
 44
-48
-30
+44
+3E
 ENDCHAR
-STARTCHAR 0x1F59
-ENCODING 8025
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 12 0 0
+STARTCHAR uni1E7C
+ENCODING 7804
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 0 0
 BITMAP
-C000
-FC78
-4820
-8440
-0440
-0280
-0380
-0100
-0100
-0100
-0100
-07C0
+0900
+1500
+1200
+0000
+F1E0
+2080
+2080
+1100
+1100
+1100
+0A00
+0A00
+0A00
+0400
+0400
 ENDCHAR
-STARTCHAR 0x1F5B
-ENCODING 8027
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 12 0 0
+STARTCHAR uni1E7D
+ENCODING 7805
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
 BITMAP
-D000
-D78F
-8904
-4888
-0088
-0050
-0070
-0020
-0020
-0020
-0020
-00F8
+12
+2A
+24
+00
+E7
+24
+24
+24
+18
+18
+18
 ENDCHAR
-STARTCHAR 0x1F5D
-ENCODING 8029
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 12 0 0
+STARTCHAR uni1E7E
+ENCODING 7806
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 0 -3
 BITMAP
-C800
-CF8F
-9104
-5088
-0088
-0050
-0070
-0020
-0020
-0020
-0020
-00F8
+F1E0
+2080
+2080
+1100
+1100
+1100
+0A00
+0A00
+0A00
+0400
+0400
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR 0x1F5F
-ENCODING 8031
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 16 0 0
+STARTCHAR uni1E7F
+ENCODING 7807
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 -3
 BITMAP
-4800
-A800
-9000
-0000
-3000
-3F1E
-2208
-1110
-0110
-00A0
-00E0
-0040
-0040
-0040
-0040
-01F0
+E7
+24
+24
+24
+18
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR C117
-ENCODING 8032
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 0
+STARTCHAR uni1E80
+ENCODING 7808
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 16 0 0
 BITMAP
-1800
-1800
-0800
-1000
+0200
+0300
+0100
+0080
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+F1CF
+2184
+2184
+2244
+1248
+1248
+1248
+1428
+0C30
+0C30
+0810
 ENDCHAR
-STARTCHAR C117
-ENCODING 8033
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 0
+STARTCHAR uni1E81
+ENCODING 7809
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 12 0 0
 BITMAP
-1800
-1800
-1000
 0800
+0C00
+0400
+0200
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+EEE0
+2480
+2A80
+2A80
+2A80
+1B00
+1100
 ENDCHAR
-STARTCHAR C117
-ENCODING 8034
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 0
+STARTCHAR uni1E82
+ENCODING 7810
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 16 0 0
 BITMAP
-3400
-3400
-1200
-2200
+0080
+0180
+0100
+0200
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+F1CF
+2184
+2184
+2244
+1248
+1248
+1248
+1428
+0C30
+0C30
+0810
 ENDCHAR
-STARTCHAR C117
-ENCODING 8035
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 0
+STARTCHAR uni1E83
+ENCODING 7811
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 12 0 0
 BITMAP
-3400
-3400
-2200
-1200
+0200
+0600
+0400
+0800
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+EEE0
+2480
+2A80
+2A80
+2A80
+1B00
+1100
 ENDCHAR
-STARTCHAR C117
-ENCODING 8036
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 0
+STARTCHAR uni1E84
+ENCODING 7812
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 14 0 0
 BITMAP
-3200
-3200
-1400
-2400
+06C0
+06C0
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+F1CF
+2184
+2184
+2244
+1248
+1248
+1248
+1428
+0C30
+0C30
+0810
 ENDCHAR
-STARTCHAR C117
-ENCODING 8037
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 0
+STARTCHAR uni1E85
+ENCODING 7813
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 0 0
 BITMAP
-3200
-3200
-2400
-1400
+1B00
+1B00
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+EEE0
+2480
+2A80
+2A80
+2A80
+1B00
+1100
 ENDCHAR
-STARTCHAR C117
-ENCODING 8038
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 16 1 0
+STARTCHAR uni1E86
+ENCODING 7814
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 14 0 0
 BITMAP
-2400
-5400
-4800
-0000
-1800
-1800
-0800
-1000
+0180
+0180
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+F1CF
+2184
+2184
+2244
+1248
+1248
+1248
+1428
+0C30
+0C30
+0810
 ENDCHAR
-STARTCHAR C117
-ENCODING 8039
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 16 1 0
+STARTCHAR uni1E87
+ENCODING 7815
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 0 0
 BITMAP
-2400
-5400
-4800
-0000
-1800
-1800
-1000
-0800
+0600
+0600
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
-ENDCHAR
-STARTCHAR 0x1F68
-ENCODING 8040
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 0 0
-BITMAP
-C000
-C000
-4F80
-9040
-2020
-2020
-2020
-2020
-1040
-1040
-0880
-28A0
-38E0
+EEE0
+2480
+2A80
+2A80
+2A80
+1B00
+1100
 ENDCHAR
-STARTCHAR 0x1F69
-ENCODING 8041
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 0 0
+STARTCHAR uni1E88
+ENCODING 7816
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 14 0 -3
 BITMAP
-C000
-C000
-8F80
-5040
-2020
-2020
-2020
-2020
-1040
-1040
-0880
-28A0
-38E0
+F1CF
+2184
+2184
+2244
+1248
+1248
+1248
+1428
+0C30
+0C30
+0810
+0000
+0180
+0180
 ENDCHAR
-STARTCHAR 0x1F6A
-ENCODING 8042
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
+STARTCHAR uni1E89
+ENCODING 7817
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 0 -3
 BITMAP
-D000
-D000
-49F0
-8A08
-0404
-0404
-0404
-0404
-0208
-0208
-0110
-0514
-071C
+EEE0
+2480
+2A80
+2A80
+2A80
+1B00
+1100
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR 0x1F6B
-ENCODING 8043
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 0 0
+STARTCHAR uni1E8A
+ENCODING 7818
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 1 0
 BITMAP
-D000
-D000
-89F0
-4A08
-0404
-0404
-0404
-0404
-0208
-0208
-0110
-0514
-071C
+0C00
+0C00
+0000
+F3C0
+1100
+1200
+0A00
+0C00
+0400
+0A00
+1A00
+1100
+2080
+F1E0
 ENDCHAR
-STARTCHAR 0x1F6C
-ENCODING 8044
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 13 0 0
+STARTCHAR uni1E8B
+ENCODING 7819
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
 BITMAP
-C800
-C800
-53E0
-9410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
+18
+18
+00
+E7
+24
+18
+18
+18
+24
+E7
 ENDCHAR
-STARTCHAR 0x1F6D
-ENCODING 8045
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 13 0 0
+STARTCHAR uni1E8C
+ENCODING 7820
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 1 0
 BITMAP
-C800
-C800
-93E0
-5410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
+1B00
+1B00
+0000
+F3C0
+1100
+1200
+0A00
+0C00
+0400
+0A00
+1A00
+1100
+2080
+F1E0
 ENDCHAR
-STARTCHAR 0x1F6E
-ENCODING 8046
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 17 0 0
+STARTCHAR uni1E8D
+ENCODING 7821
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
 BITMAP
-4800
-A800
-9000
-0000
-3000
-3000
-13E0
-2410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
+36
+36
+00
+E7
+24
+18
+18
+18
+24
+E7
 ENDCHAR
-STARTCHAR 0x1F6F
-ENCODING 8047
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 17 0 0
+STARTCHAR uni1E8E
+ENCODING 7822
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 0 0
 BITMAP
-4800
-A800
-9000
+0C00
+0C00
 0000
-3000
-3000
-23E0
-1410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
+F1E0
+2080
+1100
+1100
+0A00
+0E00
+0400
+0400
+0400
+0400
+1F00
 ENDCHAR
-STARTCHAR C138
-ENCODING 8048
+STARTCHAR uni1E8F
+ENCODING 7823
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 12 1 0
+BBX 8 13 1 -3
 BITMAP
-20
-20
-10
-10
+18
+18
 00
-62
-92
-94
-8C
-88
-98
-66
+E7
+24
+24
+24
+18
+18
+18
+10
+90
+E0
 ENDCHAR
-STARTCHAR C138
-ENCODING 8049
+STARTCHAR uni1E90
+ENCODING 7824
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 12 1 0
+BBX 7 15 1 0
 BITMAP
-10
 10
-20
-20
+38
+44
 00
-62
-92
-94
-8C
+FE
+C4
+84
 88
-98
-66
+08
+10
+20
+22
+42
+46
+FE
 ENDCHAR
-STARTCHAR C090
-ENCODING 8050
+STARTCHAR uni1E91
+ENCODING 7825
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 11 1 0
 BITMAP
-40
-40
 20
-20
-00
 70
+88
+00
+F8
 90
-80
-60
-80
+90
+20
+48
+48
+F8
+ENDCHAR
+STARTCHAR uni1E92
+ENCODING 7826
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 14 1 -3
+BITMAP
+FE
+C4
+84
 88
-70
+08
+10
+20
+22
+42
+46
+FE
+00
+30
+30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8051
+STARTCHAR uni1E93
+ENCODING 7827
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 12 1 0
+BBX 5 10 1 -3
 BITMAP
-10
-10
-20
+F8
+90
+90
 20
+48
+48
+F8
 00
-70
-90
-80
 60
-80
-88
-70
+60
 ENDCHAR
-STARTCHAR C090
-ENCODING 8052
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+STARTCHAR uni1E94
+ENCODING 7828
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 13 1 -2
 BITMAP
+FE
+C4
+84
+88
+08
+10
 20
+22
+42
+46
+FE
+00
+7C
+ENDCHAR
+STARTCHAR uni1E95
+ENCODING 7829
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 -2
+BITMAP
+F8
+90
+90
 20
-10
-10
+48
+48
+F8
 00
-98
-64
+F8
+ENDCHAR
+STARTCHAR uni1E96
+ENCODING 7830
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 14 1 -2
+BITMAP
+C0
+40
+40
+40
+40
+78
 44
 44
 44
 44
 44
-04
-04
-04
-04
+EE
+00
+7C
 ENDCHAR
-STARTCHAR C090
-ENCODING 8053
+STARTCHAR uni1E97
+ENCODING 7831
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 16 1 -4
+BBX 6 13 1 0
 BITMAP
-10
-10
+D8
+D8
+00
+20
+20
 20
+F8
+20
 20
+20
+24
+24
+18
+ENDCHAR
+STARTCHAR uni1E98
+ENCODING 7832
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 12 0 0
+BITMAP
+0600
+0900
+0900
+0600
+0000
+EEE0
+2480
+2A80
+2A80
+2A80
+1B00
+1100
+ENDCHAR
+STARTCHAR uni1E99
+ENCODING 7833
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 15 1 -3
+BITMAP
+18
+24
+24
+18
 00
-98
-64
-44
-44
-44
-44
-44
-04
-04
+E7
+24
+24
+24
+18
+18
+18
+10
+90
+E0
+ENDCHAR
+STARTCHAR uni1E9A
+ENCODING 7834
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
+BITMAP
+18
 04
 04
+18
+00
+70
+88
+08
+78
+88
+88
+7C
 ENDCHAR
-STARTCHAR C090
-ENCODING 8054
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 11 1 0
+STARTCHAR uni1E9B
+ENCODING 7835
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 0
 BITMAP
-80
-80
-40
+60
+60
 00
-40
-C0
+38
+48
 40
 40
 40
-50
-20
-ENDCHAR
-STARTCHAR C090
-ENCODING 8055
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 11 1 0
-BITMAP
-20
-20
+C0
 40
-00
 40
-C0
 40
 40
 40
-50
-20
+E0
 ENDCHAR
-STARTCHAR C090
-ENCODING 8056
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
+STARTCHAR uni1EA0
+ENCODING 7840
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 0 -3
 BITMAP
-40
-40
-20
-00
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+0000
+0600
+0600
+ENDCHAR
+STARTCHAR uni1EA1
+ENCODING 7841
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 -3
+BITMAP
 70
-88
-88
 88
+08
+78
 88
 88
-70
+7C
+00
+30
+30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8057
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
+STARTCHAR uni1EA2
+ENCODING 7842
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 17 0 0
+BITMAP
+0400
+0A00
+0200
+0400
+0400
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1EA3
+ENCODING 7843
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 0
 BITMAP
 20
+50
+10
+20
 20
-40
 00
 70
-88
-88
 88
+08
+78
 88
 88
-70
+7C
 ENDCHAR
-STARTCHAR C117
-ENCODING 8058
+STARTCHAR uni1EA4
+ENCODING 7844
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 16 0 0
+BITMAP
+0080
+0500
+0E00
+1100
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1EA5
+ENCODING 7845
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 11 1 0
+BBX 6 12 1 0
 BITMAP
-20
-20
-10
+04
+28
+70
+88
 00
-C8
-44
-44
-44
-44
-48
-30
+70
+88
+08
+78
+88
+88
+7C
 ENDCHAR
-STARTCHAR C117
-ENCODING 8059
+STARTCHAR uni1EA6
+ENCODING 7846
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 16 0 0
+BITMAP
+2000
+1400
+0E00
+1100
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1EA7
+ENCODING 7847
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 11 1 0
+BBX 7 12 0 0
 BITMAP
-10
-10
-20
-00
-C8
+80
+50
+38
 44
+00
+38
 44
+04
+3C
 44
 44
-48
-30
+3E
 ENDCHAR
-STARTCHAR C117
-ENCODING 8060
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni1EA8
+ENCODING 7848
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 18 0 0
 BITMAP
-1000
-1000
-0800
+0100
+0280
+0080
+0500
+0F00
+1100
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
-ENDCHAR
-STARTCHAR C117
-ENCODING 8061
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
-BITMAP
 0400
 0400
-0800
-0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
 ENDCHAR
-STARTCHAR C130
-ENCODING 8064
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 17 1 -5
+STARTCHAR uni1EA9
+ENCODING 7849
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 0
 BITMAP
-18
-18
 08
-10
-00
-62
-92
-94
-8C
+14
+04
+28
+78
 88
-98
-66
 00
-60
-20
-28
-10
+70
+88
+08
+78
+88
+88
+7C
 ENDCHAR
-STARTCHAR C129
-ENCODING 8065
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 17 1 -5
+STARTCHAR uni1EAA
+ENCODING 7850
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 19 0 0
 BITMAP
-30
-30
-20
-10
-00
-62
-92
-94
-8C
-88
-98
-66
-00
-60
-20
-28
-10
+0900
+1500
+1200
+0000
+0400
+0E00
+1100
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
 ENDCHAR
-STARTCHAR C138
-ENCODING 8066
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 17 1 -5
+STARTCHAR uni1EAB
+ENCODING 7851
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
 BITMAP
-68
-68
-24
-44
+48
+A8
+90
 00
-62
-92
-94
-8C
+20
+70
 88
-98
-66
 00
-60
-20
-28
-10
+70
+88
+08
+78
+88
+88
+7C
 ENDCHAR
-STARTCHAR C138
-ENCODING 8067
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 17 1 -5
+STARTCHAR uni1EAC
+ENCODING 7852
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 18 0 -3
 BITMAP
-68
-68
-44
-24
-00
-62
-92
-94
-8C
-88
-98
-66
-00
-60
-20
-28
-10
+0400
+0E00
+1100
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+0000
+0600
+0600
 ENDCHAR
-STARTCHAR C138
-ENCODING 8068
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 17 1 -5
+STARTCHAR uni1EAD
+ENCODING 7853
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -3
 BITMAP
-64
-64
-28
-48
+20
+70
+88
 00
-62
-92
-94
-8C
+70
 88
-98
-66
+08
+78
+88
+88
+7C
 00
-60
-20
-28
-10
+30
+30
 ENDCHAR
-STARTCHAR C138
-ENCODING 8069
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 17 1 -5
+STARTCHAR uni1EAE
+ENCODING 7854
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 18 0 0
 BITMAP
-64
-64
-48
-28
-00
-62
-92
-94
-8C
-88
-98
-66
-00
-60
-20
-28
-10
+0100
+0300
+0200
+0400
+1100
+0E00
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
 ENDCHAR
-STARTCHAR C130
-ENCODING 8070
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 21 1 -5
+STARTCHAR uni1EAF
+ENCODING 7855
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 0
 BITMAP
-24
-54
-48
-00
-18
-18
 08
+18
 10
-00
-62
-92
-94
-8C
+20
 88
-98
-66
+70
 00
-60
-20
-28
-10
+70
+88
+08
+78
+88
+88
+7C
 ENDCHAR
-STARTCHAR C129
-ENCODING 8071
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 21 1 -5
+STARTCHAR uni1EB0
+ENCODING 7856
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 18 0 0
 BITMAP
-24
-54
-48
-00
-30
-30
+1000
+1800
+0800
+0400
+1100
+0E00
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1EB1
+ENCODING 7857
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 0
+BITMAP
+80
+C0
+40
 20
-10
-00
-62
-92
-94
-8C
 88
-98
-66
+70
 00
-60
-20
-28
-10
+70
+88
+08
+78
+88
+88
+7C
 ENDCHAR
-STARTCHAR C065
-ENCODING 8072
+STARTCHAR uni1EB2
+ENCODING 7858
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 17 0 -4
+BBX 11 19 0 0
 BITMAP
-6000
-6000
-2400
-4400
+0400
+0A00
+0200
+0400
+0400
+1100
+0E00
+0000
+0400
+0400
 0A00
 0A00
 0A00
@@ -58661,21 +62276,44 @@
 2080
 2080
 F1E0
-0C00
-0400
-0500
-0200
 ENDCHAR
-STARTCHAR C065
-ENCODING 8073
+STARTCHAR uni1EB3
+ENCODING 7859
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
+BITMAP
+20
+50
+10
+20
+20
+88
+70
+00
+70
+88
+08
+78
+88
+88
+7C
+ENDCHAR
+STARTCHAR uni1EB4
+ENCODING 7860
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 17 0 -4
+BBX 11 18 0 0
 BITMAP
-6000
-6000
-4400
-2400
+0900
+1500
+1200
+0000
+1100
+0E00
+0000
+0400
+0400
 0A00
 0A00
 0A00
@@ -58685,972 +62323,1495 @@
 2080
 2080
 F1E0
-0C00
-0400
-0500
-0200
 ENDCHAR
-STARTCHAR 0x1F8A
-ENCODING 8074
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 -4
+STARTCHAR uni1EB5
+ENCODING 7861
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 0
 BITMAP
-D000
-D000
-4A00
-8A00
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
-0600
-0200
-0280
-0100
+48
+A8
+90
+00
+88
+70
+00
+70
+88
+08
+78
+88
+88
+7C
 ENDCHAR
-STARTCHAR 0x1F8B
-ENCODING 8075
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 -4
+STARTCHAR uni1EB6
+ENCODING 7862
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 17 0 -3
 BITMAP
-D000
-D000
-8A00
-4A00
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
+1100
+0E00
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+0000
 0600
-0200
-0280
-0100
-ENDCHAR
-STARTCHAR 0x1F8C
-ENCODING 8076
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 -4
-BITMAP
-C800
-C800
-5200
-9200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
 0600
-0200
-0280
-0100
 ENDCHAR
-STARTCHAR 0x1F8D
-ENCODING 8077
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 -4
+STARTCHAR uni1EB7
+ENCODING 7863
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 -3
 BITMAP
-C800
-C800
-9200
-5200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
-0600
-0200
-0280
-0100
+88
+70
+00
+70
+88
+08
+78
+88
+88
+7C
+00
+30
+30
 ENDCHAR
-STARTCHAR 0x1F8E
-ENCODING 8078
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 21 0 -4
+STARTCHAR uni1EB8
+ENCODING 7864
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 0 -3
 BITMAP
-4800
-A800
-9000
-0000
-3000
-3000
-1200
+FF80
+2080
+2080
+2280
 2200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
-0600
-0200
-0280
-0100
+3E00
+2240
+2240
+2080
+2080
+FF80
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR 0x1F8F
-ENCODING 8079
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 21 0 -4
+STARTCHAR uni1EB9
+ENCODING 7865
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 -3
 BITMAP
-4800
-A800
-9000
+70
+88
+F8
+80
+80
+88
+70
+00
+30
+30
+ENDCHAR
+STARTCHAR uni1EBA
+ENCODING 7866
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 0 0
+BITMAP
+0800
+1400
+0400
+0800
+0800
 0000
-3000
-3000
+FF80
+2080
+2080
+2280
 2200
-1200
-0500
-0500
-0500
-0880
-0880
-0F80
-1040
-1040
-78F0
-0600
-0200
-0280
-0100
+3E00
+2240
+2240
+2080
+2080
+FF80
 ENDCHAR
-STARTCHAR C090
-ENCODING 8080
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+STARTCHAR uni1EBB
+ENCODING 7867
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 1 0
 BITMAP
-30
-30
+20
+50
 10
 20
+20
 00
-98
-64
-44
-44
-44
-44
-44
-04
-C4
-44
-64
+70
+88
+F8
+80
+80
+88
+70
 ENDCHAR
-STARTCHAR C090
-ENCODING 8081
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+STARTCHAR uni1EBC
+ENCODING 7868
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 0 0
 BITMAP
-30
-30
-20
-10
-00
-98
-64
-44
-44
-44
-44
-44
-04
-C4
-44
-64
+1200
+2A00
+2400
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
 ENDCHAR
-STARTCHAR C090
-ENCODING 8082
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+STARTCHAR uni1EBD
+ENCODING 7869
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 0
 BITMAP
-68
-68
-24
-44
+48
+A8
+90
 00
-98
-64
-44
-44
-44
-44
-44
-04
-C4
-44
-64
+70
+88
+F8
+80
+80
+88
+70
 ENDCHAR
-STARTCHAR C090
-ENCODING 8083
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+STARTCHAR uni1EBE
+ENCODING 7870
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 16 0 0
 BITMAP
-68
-68
-44
-24
-00
-98
-64
-44
-44
-44
-44
-44
-04
-C4
-44
-64
+0100
+0A00
+1C00
+2200
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
 ENDCHAR
-STARTCHAR C090
-ENCODING 8084
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+STARTCHAR uni1EBF
+ENCODING 7871
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 12 1 0
 BITMAP
-64
-64
+04
 28
-48
+70
+88
 00
-98
-64
-44
-44
-44
+70
+88
+F8
+80
+80
+88
+70
+ENDCHAR
+STARTCHAR uni1EC0
+ENCODING 7872
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 16 0 0
+BITMAP
+4000
+2800
+1C00
+2200
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+ENDCHAR
+STARTCHAR uni1EC1
+ENCODING 7873
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 12 0 0
+BITMAP
+80
+50
+38
 44
+00
+38
 44
-04
-C4
+7C
+40
+40
 44
-64
+38
 ENDCHAR
-STARTCHAR C090
-ENCODING 8085
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 16 1 -4
+STARTCHAR uni1EC2
+ENCODING 7874
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 18 0 0
 BITMAP
-64
-64
-48
+0200
+0500
+0100
+0A00
+1E00
+2200
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+ENDCHAR
+STARTCHAR uni1EC3
+ENCODING 7875
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 14 1 0
+BITMAP
+08
+14
+04
 28
+78
+88
 00
-98
-64
-44
-44
-44
-44
-44
-04
-C4
-44
-64
+70
+88
+F8
+80
+80
+88
+70
 ENDCHAR
-STARTCHAR C130
-ENCODING 8086
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 20 1 -4
+STARTCHAR uni1EC4
+ENCODING 7876
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 19 0 0
+BITMAP
+1200
+2A00
+2400
+0000
+0800
+1C00
+2200
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+ENDCHAR
+STARTCHAR uni1EC5
+ENCODING 7877
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 0
 BITMAP
 48
 A8
 90
 00
-30
-30
-10
 20
+70
+88
 00
-98
-64
-44
-44
-44
-44
-44
-04
-C4
-44
-64
+70
+88
+F8
+80
+80
+88
+70
 ENDCHAR
-STARTCHAR C130
-ENCODING 8087
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 20 1 -4
+STARTCHAR uni1EC6
+ENCODING 7878
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 18 0 -3
 BITMAP
-48
-A8
-90
+0800
+1C00
+2200
+0000
+FF80
+2080
+2080
+2280
+2200
+3E00
+2240
+2240
+2080
+2080
+FF80
+0000
+0C00
+0C00
+ENDCHAR
+STARTCHAR uni1EC7
+ENCODING 7879
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 14 1 -3
+BITMAP
+20
+70
+88
+00
+70
+88
+F8
+80
+80
+88
+70
 00
 30
 30
+ENDCHAR
+STARTCHAR uni1EC8
+ENCODING 7880
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 17 1 0
+BITMAP
 20
+50
 10
+20
+20
 00
-98
-64
-44
-44
-44
-44
-44
-04
-C4
-44
-64
+F8
+20
+20
+20
+20
+20
+20
+20
+20
+20
+F8
 ENDCHAR
-STARTCHAR C072
-ENCODING 8088
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 18 0 -5
+STARTCHAR uni1EC9
+ENCODING 7881
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 13 1 0
 BITMAP
-C000
-C000
-5F7C
-8410
-0410
-0410
-0410
-07F0
-0410
-0410
-0410
-0410
-1F7C
-0000
-0180
-0080
-00A0
-0040
+40
+A0
+20
+40
+40
+00
+C0
+40
+40
+40
+40
+40
+E0
 ENDCHAR
-STARTCHAR C072
-ENCODING 8089
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 18 0 -5
+STARTCHAR uni1ECA
+ENCODING 7882
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 14 1 -3
 BITMAP
-C000
-C000
-9F7C
-4410
-0410
-0410
-0410
-07F0
-0410
-0410
-0410
-0410
-1F7C
-0000
-00C0
-0040
-0050
-0020
+F8
+20
+20
+20
+20
+20
+20
+20
+20
+20
+F8
+00
+60
+60
 ENDCHAR
-STARTCHAR C072
-ENCODING 8090
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 18 0 -5
+STARTCHAR uni1ECB
+ENCODING 7883
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 14 1 -3
 BITMAP
-D000
-D000
-4FDF
-8904
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-0000
-00C0
-0040
-0050
-0020
+C0
+C0
+00
+00
+C0
+40
+40
+40
+40
+40
+E0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR C072
-ENCODING 8091
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 18 0 -5
+STARTCHAR uni1ECC
+ENCODING 7884
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 14 1 -3
 BITMAP
-D000
-D000
-8FDF
-4904
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 0000
-00C0
-0040
-0050
-0020
+0C00
+0C00
 ENDCHAR
-STARTCHAR C072
-ENCODING 8092
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 18 0 -5
+STARTCHAR uni1ECD
+ENCODING 7885
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 -3
 BITMAP
-C800
-C800
-57DF
-9104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-0000
-00C0
-0040
-0050
-0020
+70
+88
+88
+88
+88
+88
+70
+00
+30
+30
 ENDCHAR
-STARTCHAR C072
-ENCODING 8093
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 18 0 -5
+STARTCHAR uni1ECE
+ENCODING 7886
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 17 1 0
 BITMAP
-C800
-C800
-97DF
-5104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
+0800
+1400
+0400
+0800
+0800
 0000
-00C0
-0040
-0050
-0020
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR 0x1F9E
-ENCODING 8094
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 22 0 -5
+STARTCHAR uni1ECF
+ENCODING 7887
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 1 0
 BITMAP
-4800
-A800
-9000
-0000
-3000
-3000
-17DF
-2104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
-0000
-00C0
-0040
-0050
-0020
+20
+50
+10
+20
+20
+00
+70
+88
+88
+88
+88
+88
+70
 ENDCHAR
-STARTCHAR 0x1F9F
-ENCODING 8095
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 22 0 -5
+STARTCHAR uni1ED0
+ENCODING 7888
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 16 1 0
 BITMAP
-4800
-A800
-9000
-0000
-3000
-3000
-27DF
-1104
-0104
-0104
-0104
-01FC
-0104
-0104
-0104
-0104
-07DF
+0100
+0A00
+1C00
+2200
 0000
-00C0
-0040
-0050
-0020
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR C117
-ENCODING 8096
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 -5
+STARTCHAR uni1ED1
+ENCODING 7889
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 12 1 0
 BITMAP
-1800
-1800
-0800
-1000
-0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
-0000
-1800
-0800
-0A00
-0400
+04
+28
+70
+88
+00
+70
+88
+88
+88
+88
+88
+70
 ENDCHAR
-STARTCHAR C117
-ENCODING 8097
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 -5
+STARTCHAR uni1ED2
+ENCODING 7890
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 16 1 0
 BITMAP
-1800
-1800
-1000
-0800
-0000
+4000
+2800
+1C00
 2200
-4100
-8080
-8880
-8880
-8880
-7700
 0000
-1800
-0800
-0A00
-0400
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR C117
-ENCODING 8098
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 -5
+STARTCHAR uni1ED3
+ENCODING 7891
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 12 0 0
 BITMAP
-3400
-3400
-1200
-2200
-0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
-0000
-1800
-0800
-0A00
-0400
+80
+50
+38
+44
+00
+38
+44
+44
+44
+44
+44
+38
 ENDCHAR
-STARTCHAR C117
-ENCODING 8099
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 -5
+STARTCHAR uni1ED4
+ENCODING 7892
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 18 1 0
 BITMAP
-3400
-3400
-2200
-1200
-0000
+0200
+0500
+0100
+0A00
+1E00
 2200
-4100
-8080
-8880
-8880
-8880
-7700
 0000
-1800
-0800
-0A00
-0400
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR C117
-ENCODING 8100
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 -5
+STARTCHAR uni1ED5
+ENCODING 7893
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 14 1 0
 BITMAP
-3200
-3200
-1400
-2400
-0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
-0000
-1800
-0800
-0A00
-0400
+08
+14
+04
+28
+78
+88
+00
+70
+88
+88
+88
+88
+88
+70
 ENDCHAR
-STARTCHAR C117
-ENCODING 8101
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 -5
+STARTCHAR uni1ED6
+ENCODING 7894
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 19 1 0
 BITMAP
-3200
-3200
+1200
+2A00
 2400
-1400
 0000
+0800
+1C00
 2200
-4100
-8080
-8880
-8880
-8880
-7700
 0000
-1800
-0800
-0A00
-0400
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR C117
-ENCODING 8102
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 21 1 -5
+STARTCHAR uni1ED7
+ENCODING 7895
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 1 0
 BITMAP
-2400
-5400
-4800
-0000
-1800
-1800
+48
+A8
+90
+00
+20
+70
+88
+00
+70
+88
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1ED8
+ENCODING 7896
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 18 1 -3
+BITMAP
 0800
-1000
-0000
+1C00
 2200
-4100
-8080
-8880
-8880
-8880
-7700
 0000
+1E00
+2100
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
+0000
+0C00
+0C00
+ENDCHAR
+STARTCHAR uni1ED9
+ENCODING 7897
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 14 1 -3
+BITMAP
+20
+70
+88
+00
+70
+88
+88
+88
+88
+88
+70
+00
+30
+30
+ENDCHAR
+STARTCHAR uni1EDA
+ENCODING 7898
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 16 1 0
+BITMAP
+0400
+0C00
+0800
+1000
+0060
+1E20
+21C0
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
+ENDCHAR
+STARTCHAR uni1EDB
+ENCODING 7899
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 7 12 1 0
+BITMAP
+10
+30
+20
+40
+06
+72
+8C
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1EDC
+ENCODING 7900
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 16 1 0
+BITMAP
+1000
 1800
 0800
-0A00
 0400
+0060
+1E20
+21C0
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
+ENDCHAR
+STARTCHAR uni1EDD
+ENCODING 7901
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 7 12 1 0
+BITMAP
+40
+60
+20
+10
+06
+72
+8C
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1EDE
+ENCODING 7902
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 17 1 0
+BITMAP
+0800
+1400
+0400
+0800
+0800
+0060
+1E20
+21C0
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR C117
-ENCODING 8103
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 21 1 -5
+STARTCHAR uni1EDF
+ENCODING 7903
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 7 13 1 0
+BITMAP
+20
+50
+10
+20
+20
+06
+72
+8C
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1EE0
+ENCODING 7904
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 0
 BITMAP
+1200
+2A00
 2400
-5400
-4800
-0000
-1800
-1800
-1000
-0800
+0060
+1E20
+21C0
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
+ENDCHAR
+STARTCHAR uni1EE1
+ENCODING 7905
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 7 11 1 0
+BITMAP
+48
+A8
+90
+06
+72
+8C
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1EE2
+ENCODING 7906
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 1 -3
+BITMAP
+0060
+1E20
+21C0
+4080
+8040
+8040
+8040
+8040
+8040
+4080
+2100
+1E00
 0000
-2200
-4100
-8080
-8880
-8880
-8880
-7700
+0C00
+0C00
+ENDCHAR
+STARTCHAR uni1EE3
+ENCODING 7907
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 7 11 1 -3
+BITMAP
+06
+72
+8C
+88
+88
+88
+88
+70
+00
+30
+30
+ENDCHAR
+STARTCHAR uni1EE4
+ENCODING 7908
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 -3
+BITMAP
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
 0000
-1800
-0800
+0C00
+0C00
+ENDCHAR
+STARTCHAR uni1EE5
+ENCODING 7909
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 10 1 -3
+BITMAP
+CC
+44
+44
+44
+44
+44
+3E
+00
+18
+18
+ENDCHAR
+STARTCHAR uni1EE6
+ENCODING 7910
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 17 1 0
+BITMAP
+0400
 0A00
+0200
 0400
+0400
+0000
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
 ENDCHAR
-STARTCHAR 0x1FA8
-ENCODING 8104
+STARTCHAR uni1EE7
+ENCODING 7911
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 13 1 0
+BITMAP
+10
+28
+08
+10
+10
+00
+CC
+44
+44
+44
+44
+44
+3E
+ENDCHAR
+STARTCHAR uni1EE8
+ENCODING 7912
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 17 0 -4
+BBX 12 16 1 0
 BITMAP
-C000
-C000
-4F80
-9040
-2020
-2020
-2020
-2020
-1040
-1040
-0880
-28A0
-38E0
-0600
 0200
-0280
-0100
+0600
+0400
+0830
+0010
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
 ENDCHAR
-STARTCHAR 0x1FA9
-ENCODING 8105
+STARTCHAR uni1EE9
+ENCODING 7913
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 1 0
+BITMAP
+04
+0C
+08
+13
+01
+CE
+44
+44
+44
+44
+44
+3E
+ENDCHAR
+STARTCHAR uni1EEA
+ENCODING 7914
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 17 0 -4
+BBX 12 16 1 0
 BITMAP
-C000
-C000
-8F80
-5040
-2020
-2020
-2020
-2020
-1040
-1040
-0880
-28A0
-38E0
-0600
+0800
+0C00
+0400
+0230
+0010
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
+ENDCHAR
+STARTCHAR uni1EEB
+ENCODING 7915
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 1 0
+BITMAP
+40
+60
+20
+13
+01
+CE
+44
+44
+44
+44
+44
+3E
+ENDCHAR
+STARTCHAR uni1EEC
+ENCODING 7916
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 1 0
+BITMAP
+0400
+0A00
 0200
-0280
-0100
+0400
+0430
+0010
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
 ENDCHAR
-STARTCHAR 0x1FAA
-ENCODING 8106
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 17 0 -4
+STARTCHAR uni1EED
+ENCODING 7917
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 1 0
 BITMAP
-D000
-D000
-49F0
-8A08
-0404
-0404
-0404
-0404
-0208
-0208
-0110
-0514
-071C
-00C0
-0040
-0050
-0020
+10
+28
+08
+10
+13
+01
+CE
+44
+44
+44
+44
+44
+3E
 ENDCHAR
-STARTCHAR 0x1FAB
-ENCODING 8107
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 17 0 -4
+STARTCHAR uni1EEE
+ENCODING 7918
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 15 1 0
 BITMAP
-D000
-D000
-89F0
-4A08
-0404
-0404
-0404
-0404
-0208
-0208
-0110
-0514
-071C
-00C0
-0040
-0050
-0020
+0900
+1500
+1230
+0010
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
 ENDCHAR
-STARTCHAR 0x1FAC
-ENCODING 8108
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 17 0 -4
+STARTCHAR uni1EEF
+ENCODING 7919
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 1 0
 BITMAP
-C800
-C800
-53E0
-9410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
-0180
-0080
-00A0
-0040
+24
+54
+48
+03
+01
+CE
+44
+44
+44
+44
+44
+3E
 ENDCHAR
-STARTCHAR 0x1FAD
-ENCODING 8109
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 17 0 -4
+STARTCHAR uni1EF0
+ENCODING 7920
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 16 1 -3
 BITMAP
-C800
-C800
-93E0
-5410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
-0180
-0080
-00A0
-0040
+0030
+0010
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+1100
+0E00
+0000
+0C00
+0C00
 ENDCHAR
-STARTCHAR 0x1FAE
-ENCODING 8110
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 21 0 -4
+STARTCHAR uni1EF1
+ENCODING 7921
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 1 -3
 BITMAP
-4800
-A800
-9000
+03
+01
+CE
+44
+44
+44
+44
+44
+3E
+00
+18
+18
+ENDCHAR
+STARTCHAR uni1EF2
+ENCODING 7922
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 16 0 0
+BITMAP
+0800
+0C00
+0400
+0200
 0000
-3000
-3000
-13E0
-2410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
-0180
-0080
-00A0
-0040
+F1E0
+2080
+1100
+1100
+0A00
+0E00
+0400
+0400
+0400
+0400
+1F00
 ENDCHAR
-STARTCHAR 0x1FAF
-ENCODING 8111
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 21 0 -4
+STARTCHAR uni1EF3
+ENCODING 7923
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 15 1 -3
 BITMAP
-4800
-A800
-9000
+20
+30
+10
+08
+00
+E7
+24
+24
+24
+18
+18
+18
+10
+90
+E0
+ENDCHAR
+STARTCHAR uni1EF4
+ENCODING 7924
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 0 -3
+BITMAP
+F1E0
+2080
+1100
+1100
+0A00
+0E00
+0400
+0400
+0400
+0400
+1F00
 0000
-3000
-3000
-23E0
-1410
-0808
-0808
-0808
-0808
-0410
-0410
-0220
-0A28
-0E38
-0180
-0080
-00A0
-0040
+0C00
+0C00
 ENDCHAR
-STARTCHAR C130
-ENCODING 8112
+STARTCHAR uni1EF5
+ENCODING 7925
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 11 1 0
+BBX 8 11 1 -4
 BITMAP
-44
-38
+E7
+24
+24
+24
+18
+18
+18
+10
+90
+E6
+06
+ENDCHAR
+STARTCHAR uni1EF6
+ENCODING 7926
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 17 0 0
+BITMAP
+0400
+0A00
+0200
+0400
+0400
+0000
+F1E0
+2080
+1100
+1100
+0A00
+0E00
+0400
+0400
+0400
+0400
+1F00
+ENDCHAR
+STARTCHAR uni1EF7
+ENCODING 7927
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 16 1 -3
+BITMAP
+10
+28
+08
+10
+10
+00
+E7
+24
+24
+24
+18
+18
+18
+10
+90
+E0
+ENDCHAR
+STARTCHAR uni1EF8
+ENCODING 7928
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 0 0
+BITMAP
+0900
+1500
+1200
+0000
+F1E0
+2080
+1100
+1100
+0A00
+0E00
+0400
+0400
+0400
+0400
+1F00
+ENDCHAR
+STARTCHAR uni1EF9
+ENCODING 7929
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 14 1 -3
+BITMAP
+12
+2A
+24
 00
+E7
+24
+24
+24
+18
+18
+18
+10
+90
+E0
+ENDCHAR
+STARTCHAR uni1F00
+ENCODING 7936
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 0
+BITMAP
+18
+18
+08
+10
 00
 62
 92
@@ -59660,14 +63821,16 @@
 98
 66
 ENDCHAR
-STARTCHAR C130
-ENCODING 8113
+STARTCHAR uni1F01
+ENCODING 7937
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 10 1 0
+BBX 7 12 1 0
 BITMAP
-7C
-00
+30
+30
+20
+10
 00
 62
 92
@@ -59677,16 +63840,16 @@
 98
 66
 ENDCHAR
-STARTCHAR C130
-ENCODING 8114
+STARTCHAR uni1F02
+ENCODING 7938
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 17 1 -5
+BBX 7 12 1 0
 BITMAP
-10
-10
-08
-08
+68
+68
+24
+44
 00
 62
 92
@@ -59695,18 +63858,18 @@
 88
 98
 66
-00
-60
-20
-28
-10
 ENDCHAR
-STARTCHAR C130
-ENCODING 8115
+STARTCHAR uni1F03
+ENCODING 7939
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 12 1 -5
+BBX 7 12 1 0
 BITMAP
+68
+68
+44
+24
+00
 62
 92
 94
@@ -59714,22 +63877,17 @@
 88
 98
 66
-00
-60
-20
-28
-10
 ENDCHAR
-STARTCHAR C130
-ENCODING 8116
+STARTCHAR uni1F04
+ENCODING 7940
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 17 1 -5
+BBX 7 12 1 0
 BITMAP
-08
-08
-10
-10
+64
+64
+28
+48
 00
 62
 92
@@ -59738,21 +63896,17 @@
 88
 98
 66
-00
-60
-20
-28
-10
 ENDCHAR
-STARTCHAR C130
-ENCODING 8118
+STARTCHAR uni1F05
+ENCODING 7941
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 11 1 0
+BBX 7 12 1 0
 BITMAP
-24
-54
+64
+64
 48
+28
 00
 62
 92
@@ -59762,16 +63916,21 @@
 98
 66
 ENDCHAR
-STARTCHAR C130
-ENCODING 8119
+STARTCHAR uni1F06
+ENCODING 7942
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 16 1 -5
+BBX 7 16 1 0
 BITMAP
 24
 54
 48
 00
+18
+18
+08
+10
+00
 62
 92
 94
@@ -59779,43 +63938,40 @@
 88
 98
 66
+ENDCHAR
+STARTCHAR uni1F07
+ENCODING 7943
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 16 1 0
+BITMAP
+24
+54
+48
 00
-60
+30
+30
 20
-28
 10
-ENDCHAR
-STARTCHAR C065
-ENCODING 8120
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 0 0
-BITMAP
-1100
-0E00
-0000
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+00
+62
+92
+94
+8C
+88
+98
+66
 ENDCHAR
-STARTCHAR C065
-ENCODING 8121
+STARTCHAR uni1F08
+ENCODING 7944
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 11 13 0 0
 BITMAP
-1F00
-0000
-0400
-0400
+6000
+6000
+2400
+4400
 0A00
 0A00
 0A00
@@ -59826,15 +63982,15 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C065
-ENCODING 8122
+STARTCHAR uni1F09
+ENCODING 7945
 SWIDTH 660 0
 DWIDTH 11 0
 BBX 11 13 0 0
 BITMAP
-4000
-4000
-2400
+6000
+6000
+4400
 2400
 0A00
 0A00
@@ -59846,115 +64002,378 @@
 2080
 F1E0
 ENDCHAR
-STARTCHAR C065
-ENCODING 8123
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 13 0 0
+STARTCHAR uni1F0A
+ENCODING 7946
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 13 0 0
 BITMAP
-2000
-2000
-4400
-4400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+D000
+D000
+4A00
+8A00
+0500
+0500
+0500
+0880
+0880
+0F80
+1040
+1040
+78F0
 ENDCHAR
-STARTCHAR C065
-ENCODING 8124
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 15 0 -4
+STARTCHAR uni1F0B
+ENCODING 7947
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 13 0 0
 BITMAP
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
-0C00
-0400
+D000
+D000
+8A00
+4A00
 0500
-0200
+0500
+0500
+0880
+0880
+0F80
+1040
+1040
+78F0
 ENDCHAR
-STARTCHAR C044
-ENCODING 8125
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 5 1 11
+STARTCHAR uni1F0C
+ENCODING 7948
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 13 0 0
 BITMAP
-C0
-C0
-40
+C800
+C800
+5200
+9200
+0500
+0500
+0500
+0880
+0880
+0F80
+1040
+1040
+78F0
+ENDCHAR
+STARTCHAR uni1F0D
+ENCODING 7949
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 13 0 0
+BITMAP
+C800
+C800
+9200
+5200
+0500
+0500
+0500
+0880
+0880
+0F80
+1040
+1040
+78F0
+ENDCHAR
+STARTCHAR uni1F0E
+ENCODING 7950
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 0 0
+BITMAP
+4800
+A800
+9000
+0000
+3000
+3000
+1200
+2200
+0500
+0500
+0500
+0880
+0880
+0F80
+1040
+1040
+78F0
+ENDCHAR
+STARTCHAR uni1F0F
+ENCODING 7951
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 0 0
+BITMAP
+4800
+A800
+9000
+0000
+3000
+3000
+2200
+1200
+0500
+0500
+0500
+0880
+0880
+0F80
+1040
+1040
+78F0
+ENDCHAR
+STARTCHAR uni1F10
+ENCODING 7952
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+60
+60
+20
 40
+00
+70
+90
+80
+60
 80
+88
+70
 ENDCHAR
-STARTCHAR char837
-ENCODING 8126
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 4 1 -4
+STARTCHAR uni1F11
+ENCODING 7953
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
 BITMAP
-C0
+60
+60
 40
-50
 20
+00
+70
+90
+80
+60
+80
+88
+70
 ENDCHAR
-STARTCHAR C044
-ENCODING 8127
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 5 1 11
+STARTCHAR uni1F12
+ENCODING 7954
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
 BITMAP
-C0
-C0
-40
-40
+D0
+D0
+48
+88
+00
+70
+90
+80
+60
 80
+88
+70
 ENDCHAR
-STARTCHAR char8128
-ENCODING 8128
+STARTCHAR uni1F13
+ENCODING 7955
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 3 1 11
+BBX 5 12 1 0
 BITMAP
+D0
+D0
+88
 48
-A8
+00
+70
 90
+80
+60
+80
+88
+70
 ENDCHAR
-STARTCHAR char8128
-ENCODING 8129
+STARTCHAR uni1F14
+ENCODING 7956
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 6 1 11
+BBX 5 12 1 0
 BITMAP
-48
-A8
+C8
+C8
+50
 90
 00
-D8
-D8
+70
+90
+80
+60
+80
+88
+70
 ENDCHAR
-STARTCHAR C090
-ENCODING 8130
+STARTCHAR uni1F15
+ENCODING 7957
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+C8
+C8
+90
+50
+00
+70
+90
+80
+60
+80
+88
+70
+ENDCHAR
+STARTCHAR uni1F18
+ENCODING 7960
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 13 0 0
+BITMAP
+C000
+C000
+5FF0
+8410
+0410
+0450
+0440
+07C0
+0448
+0448
+0410
+0410
+1FF0
+ENDCHAR
+STARTCHAR uni1F19
+ENCODING 7961
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 13 0 0
+BITMAP
+C000
+C000
+9FF0
+4410
+0410
+0450
+0440
+07C0
+0448
+0448
+0410
+0410
+1FF0
+ENDCHAR
+STARTCHAR uni1F1A
+ENCODING 7962
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 13 0 0
+BITMAP
+D000
+D000
+4FFC
+8904
+0104
+0114
+0110
+01F0
+0112
+0112
+0104
+0104
+07FC
+ENDCHAR
+STARTCHAR uni1F1B
+ENCODING 7963
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 13 0 0
+BITMAP
+D000
+D000
+8FFC
+4904
+0104
+0114
+0110
+01F0
+0112
+0112
+0104
+0104
+07FC
+ENDCHAR
+STARTCHAR uni1F1C
+ENCODING 7964
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 13 0 0
+BITMAP
+C800
+C800
+57FC
+9104
+0104
+0114
+0110
+01F0
+0112
+0112
+0104
+0104
+07FC
+ENDCHAR
+STARTCHAR uni1F1D
+ENCODING 7965
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 13 0 0
+BITMAP
+C800
+C800
+97FC
+5104
+0104
+0114
+0110
+01F0
+0112
+0112
+0104
+0104
+07FC
+ENDCHAR
+STARTCHAR uni1F20
+ENCODING 7968
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 -4
+BBX 6 16 1 -4
 BITMAP
-20
-20
+30
+30
 10
+20
 00
 98
 64
@@ -59964,16 +64383,21 @@
 44
 44
 04
-C4
-44
-64
+04
+04
+04
 ENDCHAR
-STARTCHAR C090
-ENCODING 8131
+STARTCHAR uni1F21
+ENCODING 7969
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 11 1 -4
+BBX 6 16 1 -4
 BITMAP
+30
+30
+20
+10
+00
 98
 64
 44
@@ -59982,19 +64406,20 @@
 44
 44
 04
-C4
-44
-64
+04
+04
+04
 ENDCHAR
-STARTCHAR C090
-ENCODING 8132
+STARTCHAR uni1F22
+ENCODING 7970
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 -4
+BBX 6 16 1 -4
 BITMAP
-10
-10
-20
+68
+68
+24
+44
 00
 98
 64
@@ -60004,18 +64429,42 @@
 44
 44
 04
-C4
+04
+04
+04
+ENDCHAR
+STARTCHAR uni1F23
+ENCODING 7971
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
+BITMAP
+68
+68
 44
+24
+00
+98
 64
+44
+44
+44
+44
+44
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR C090
-ENCODING 8134
+STARTCHAR uni1F24
+ENCODING 7972
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 -4
+BBX 6 16 1 -4
 BITMAP
-24
-54
+64
+64
+28
 48
 00
 98
@@ -60030,15 +64479,16 @@
 04
 04
 ENDCHAR
-STARTCHAR C090
-ENCODING 8135
+STARTCHAR uni1F25
+ENCODING 7973
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 -4
+BBX 6 16 1 -4
 BITMAP
-24
-54
+64
+64
 48
+28
 00
 98
 64
@@ -60048,60 +64498,74 @@
 44
 44
 04
-C4
-44
-64
+04
+04
+04
 ENDCHAR
-STARTCHAR 0x1FC8
-ENCODING 8136
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 13 0 0
+STARTCHAR uni1F26
+ENCODING 7974
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 20 1 -4
 BITMAP
-8000
-8000
-5FF0
-4410
-0410
-0450
-0440
-07C0
-0448
-0448
-0410
-0410
-1FF0
+48
+A8
+90
+00
+30
+30
+10
+20
+00
+98
+64
+44
+44
+44
+44
+44
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR 0x1FC9
-ENCODING 8137
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 13 0 0
+STARTCHAR uni1F27
+ENCODING 7975
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 20 1 -4
 BITMAP
-4000
-4000
-9FF0
-8410
-0410
-0450
-0440
-07C0
-0448
-0448
-0410
-0410
-1FF0
+48
+A8
+90
+00
+30
+30
+20
+10
+00
+98
+64
+44
+44
+44
+44
+44
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR 0x1FCA
-ENCODING 8138
+STARTCHAR uni1F28
+ENCODING 7976
 SWIDTH 900 0
 DWIDTH 15 0
 BBX 14 13 0 0
 BITMAP
-8000
-8000
+C000
+C000
 5F7C
-4410
+8410
 0410
 0410
 0410
@@ -60112,16 +64576,16 @@
 0410
 1F7C
 ENDCHAR
-STARTCHAR 0x1FCB
-ENCODING 8139
+STARTCHAR uni1F29
+ENCODING 7977
 SWIDTH 900 0
 DWIDTH 15 0
 BBX 14 13 0 0
 BITMAP
-4000
-4000
+C000
+C000
 9F7C
-8410
+4410
 0410
 0410
 0410
@@ -60132,233 +64596,304 @@
 0410
 1F7C
 ENDCHAR
-STARTCHAR 0x1FCC
-ENCODING 8140
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 16 0 -5
+STARTCHAR uni1F2A
+ENCODING 7978
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 13 0 0
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-3F80
-2080
-2080
-2080
-2080
-FBE0
+D000
+D000
+4FDF
+8904
+0104
+0104
+0104
+01FC
+0104
+0104
+0104
+0104
+07DF
+ENDCHAR
+STARTCHAR uni1F2B
+ENCODING 7979
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 13 0 0
+BITMAP
+D000
+D000
+8FDF
+4904
+0104
+0104
+0104
+01FC
+0104
+0104
+0104
+0104
+07DF
+ENDCHAR
+STARTCHAR uni1F2C
+ENCODING 7980
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 13 0 0
+BITMAP
+C800
+C800
+57DF
+9104
+0104
+0104
+0104
+01FC
+0104
+0104
+0104
+0104
+07DF
+ENDCHAR
+STARTCHAR uni1F2D
+ENCODING 7981
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 13 0 0
+BITMAP
+C800
+C800
+97DF
+5104
+0104
+0104
+0104
+01FC
+0104
+0104
+0104
+0104
+07DF
+ENDCHAR
+STARTCHAR uni1F2E
+ENCODING 7982
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 17 0 0
+BITMAP
+4800
+A800
+9000
 0000
-0C00
-0400
-0500
-0200
+3000
+3000
+17DF
+2104
+0104
+0104
+0104
+01FC
+0104
+0104
+0104
+0104
+07DF
 ENDCHAR
-STARTCHAR char8141
-ENCODING 8141
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 4 1 11
+STARTCHAR uni1F2F
+ENCODING 7983
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 17 0 0
 BITMAP
-D0
-D0
-48
-88
+4800
+A800
+9000
+0000
+3000
+3000
+27DF
+1104
+0104
+0104
+0104
+01FC
+0104
+0104
+0104
+0104
+07DF
 ENDCHAR
-STARTCHAR char8141
-ENCODING 8142
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 4 1 11
+STARTCHAR uni1F30
+ENCODING 7984
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 12 1 0
 BITMAP
-C8
-C8
+60
+60
+20
+40
+00
+40
+C0
+40
+40
+40
 50
-90
+20
 ENDCHAR
-STARTCHAR char8143
-ENCODING 8143
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 8 1 11
+STARTCHAR uni1F31
+ENCODING 7985
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 12 1 0
 BITMAP
-48
-A8
-90
+60
+60
+40
+20
 00
-30
-30
-10
+40
+C0
+40
+40
+40
+50
 20
 ENDCHAR
-STARTCHAR C090
-ENCODING 8144
+STARTCHAR uni1F32
+ENCODING 7986
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 5 11 0 0
+BBX 5 12 1 0
 BITMAP
+D0
+D0
+48
 88
-70
-00
 00
+40
+C0
+40
+40
+40
+50
 20
-60
-20
-20
-20
-28
-10
 ENDCHAR
-STARTCHAR C090
-ENCODING 8145
+STARTCHAR uni1F33
+ENCODING 7987
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 5 10 0 0
+BBX 5 12 1 0
 BITMAP
-F8
-00
+D0
+D0
+88
+48
 00
+40
+C0
+40
+40
+40
+50
 20
-60
-20
-20
-20
-28
-10
 ENDCHAR
-STARTCHAR C090
-ENCODING 8146
+STARTCHAR uni1F34
+ENCODING 7988
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 6 13 -1 0
+BBX 5 12 1 0
 BITMAP
-20
-20
-DC
-CC
-00
+C8
+C8
+50
+90
 00
-10
-30
-10
-10
-10
-14
-08
+40
+C0
+40
+40
+40
+50
+20
 ENDCHAR
-STARTCHAR C090
-ENCODING 8147
+STARTCHAR uni1F35
+ENCODING 7989
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 6 13 -1 0
+BBX 5 12 1 0
 BITMAP
-10
-10
-EC
-CC
-00
+C8
+C8
+90
+50
 00
-10
-30
-10
-10
-10
-14
-08
+40
+C0
+40
+40
+40
+50
+20
 ENDCHAR
-STARTCHAR C090
-ENCODING 8150
+STARTCHAR uni1F36
+ENCODING 7990
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 5 12 0 0
+BBX 5 16 1 0
 BITMAP
 48
 A8
 90
 00
-00
-20
 60
-20
+60
 20
+40
+00
+40
+C0
+40
+40
+40
+50
 20
-28
-10
 ENDCHAR
-STARTCHAR C090
-ENCODING 8151
+STARTCHAR uni1F37
+ENCODING 7991
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 5 15 0 0
+BBX 5 16 1 0
 BITMAP
 48
 A8
 90
 00
-D8
-D8
-00
-00
-20
 60
+60
+40
 20
-20
-20
-28
-10
-ENDCHAR
-STARTCHAR C072
-ENCODING 8152
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 14 1 0
-BITMAP
-88
-70
-00
-F8
-20
-20
-20
-20
-20
-20
-20
-20
-20
-F8
-ENDCHAR
-STARTCHAR C072
-ENCODING 8153
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 13 1 0
-BITMAP
-F8
 00
-F8
-20
-20
-20
-20
-20
-20
-20
-20
+40
+C0
+40
+40
+40
+50
 20
-F8
 ENDCHAR
-STARTCHAR C072
-ENCODING 8154
+STARTCHAR uni1F38
+ENCODING 7992
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 13 0 0
 BITMAP
-80
-80
+C0
+C0
 5F
-44
+84
 04
 04
 04
@@ -60369,16 +64904,16 @@
 04
 1F
 ENDCHAR
-STARTCHAR C072
-ENCODING 8155
+STARTCHAR uni1F39
+ENCODING 7993
 SWIDTH 540 0
 DWIDTH 9 0
 BBX 8 13 0 0
 BITMAP
-40
-40
+C0
+C0
 9F
-84
+44
 04
 04
 04
@@ -60389,52 +64924,378 @@
 04
 1F
 ENDCHAR
-STARTCHAR char8141
-ENCODING 8157
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 4 1 11
+STARTCHAR uni1F3A
+ENCODING 7994
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 0 0
 BITMAP
-D0
-D0
-88
-48
+D000
+D000
+4FC0
+8900
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+07C0
 ENDCHAR
-STARTCHAR char8141
-ENCODING 8158
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 4 1 11
+STARTCHAR uni1F3B
+ENCODING 7995
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 0 0
 BITMAP
-C8
-C8
-90
-50
+D000
+D000
+8FC0
+4900
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+07C0
 ENDCHAR
-STARTCHAR char8143
-ENCODING 8159
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 8 1 11
+STARTCHAR uni1F3C
+ENCODING 7996
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 0 0
 BITMAP
-48
-A8
-90
-00
-30
-30
-20
-10
+C800
+C800
+57C0
+9100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+07C0
 ENDCHAR
-STARTCHAR C090
-ENCODING 8160
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni1F3D
+ENCODING 7997
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 0 0
 BITMAP
-44
-38
+C800
+C800
+97C0
+5100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+07C0
+ENDCHAR
+STARTCHAR uni1F3E
+ENCODING 7998
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 0 0
+BITMAP
+4800
+A800
+9000
+0000
+3000
+3000
+17C0
+2100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+07C0
+ENDCHAR
+STARTCHAR uni1F3F
+ENCODING 7999
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 0 0
+BITMAP
+4800
+A800
+9000
+0000
+3000
+3000
+27C0
+1100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+07C0
+ENDCHAR
+STARTCHAR uni1F40
+ENCODING 8000
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+60
+60
+20
+40
+00
+70
+88
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1F41
+ENCODING 8001
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+60
+60
+40
+20
+00
+70
+88
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1F42
+ENCODING 8002
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+D0
+D0
+48
+88
+00
+70
+88
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1F43
+ENCODING 8003
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+D0
+D0
+88
+48
+00
+70
+88
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1F44
+ENCODING 8004
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+C8
+C8
+50
+90
+00
+70
+88
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1F45
+ENCODING 8005
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+C8
+C8
+90
+50
 00
+70
+88
+88
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni1F48
+ENCODING 8008
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+C000
+C000
+4F00
+9080
+2040
+4020
+4020
+4020
+4020
+4020
+2040
+1080
+0F00
+ENDCHAR
+STARTCHAR uni1F49
+ENCODING 8009
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+C000
+C000
+8F00
+5080
+2040
+4020
+4020
+4020
+4020
+4020
+2040
+1080
+0F00
+ENDCHAR
+STARTCHAR uni1F4A
+ENCODING 8010
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+D000
+D000
+49E0
+8A10
+0408
+0804
+0804
+0804
+0804
+0804
+0408
+0210
+01E0
+ENDCHAR
+STARTCHAR uni1F4B
+ENCODING 8011
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+D000
+D000
+89E0
+4A10
+0408
+0804
+0804
+0804
+0804
+0804
+0408
+0210
+01E0
+ENDCHAR
+STARTCHAR uni1F4C
+ENCODING 8012
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+C800
+C800
+51E0
+9210
+0408
+0804
+0804
+0804
+0804
+0804
+0408
+0210
+01E0
+ENDCHAR
+STARTCHAR uni1F4D
+ENCODING 8013
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+C800
+C800
+91E0
+5210
+0408
+0804
+0804
+0804
+0804
+0804
+0408
+0210
+01E0
+ENDCHAR
+STARTCHAR uni1F50
+ENCODING 8016
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
+BITMAP
+30
+30
+10
+20
 00
 C8
 44
@@ -60444,14 +65305,16 @@
 48
 30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8161
+STARTCHAR uni1F51
+ENCODING 8017
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 10 1 0
+BBX 6 12 1 0
 BITMAP
-7C
-00
+30
+30
+20
+10
 00
 C8
 44
@@ -60461,17 +65324,16 @@
 48
 30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8162
+STARTCHAR uni1F52
+ENCODING 8018
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 13 1 0
+BBX 6 12 1 0
 BITMAP
-20
-20
-DC
-CC
-00
+68
+68
+24
+44
 00
 C8
 44
@@ -60481,17 +65343,16 @@
 48
 30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8163
+STARTCHAR uni1F53
+ENCODING 8019
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 13 1 0
+BBX 6 12 1 0
 BITMAP
-10
-10
-EC
-CC
-00
+68
+68
+44
+24
 00
 C8
 44
@@ -60501,64 +65362,58 @@
 48
 30
 ENDCHAR
-STARTCHAR C114
-ENCODING 8164
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 17 1 -4
+STARTCHAR uni1F54
+ENCODING 8020
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
 BITMAP
-30
-30
-10
-20
-00
+64
+64
+28
+48
 00
-70
-88
-88
-88
-88
-88
-F0
-80
-80
-80
-80
+C8
+44
+44
+44
+44
+48
+30
 ENDCHAR
-STARTCHAR C114
-ENCODING 8165
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 17 1 -4
+STARTCHAR uni1F55
+ENCODING 8021
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
 BITMAP
-60
-60
-40
-20
-00
+64
+64
+48
+28
 00
-70
-88
-88
-88
-88
-88
-F0
-80
-80
-80
-80
+C8
+44
+44
+44
+44
+48
+30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8166
+STARTCHAR uni1F56
+ENCODING 8022
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 12 1 0
+BBX 6 16 1 0
 BITMAP
-24
-54
 48
+A8
+90
 00
+30
+30
+10
+20
 00
 C8
 44
@@ -60568,19 +65423,20 @@
 48
 30
 ENDCHAR
-STARTCHAR C090
-ENCODING 8167
+STARTCHAR uni1F57
+ENCODING 8023
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 15 1 0
+BBX 6 16 1 0
 BITMAP
-24
-54
 48
-00
-6C
-6C
+A8
+90
 00
+30
+30
+20
+10
 00
 C8
 44
@@ -60589,76 +65445,16 @@
 44
 48
 30
-ENDCHAR
-STARTCHAR C085
-ENCODING 8168
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 11 14 0 0
-BITMAP
-1100
-0E00
-0000
-F1E0
-2080
-1100
-1100
-0A00
-0E00
-0400
-0400
-0400
-0400
-1F00
-ENDCHAR
-STARTCHAR C085
-ENCODING 8169
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 11 13 0 0
-BITMAP
-1F00
-0000
-F1E0
-2080
-1100
-1100
-0A00
-0E00
-0400
-0400
-0400
-0400
-1F00
 ENDCHAR
-STARTCHAR 0x1FEA
-ENCODING 8170
+STARTCHAR uni1F59
+ENCODING 8025
 SWIDTH 840 0
 DWIDTH 14 0
 BBX 13 12 0 0
 BITMAP
-8000
-BC78
+C000
+FC78
 4820
-4440
-0440
-0280
-0380
-0100
-0100
-0100
-0100
-07C0
-ENDCHAR
-STARTCHAR 0x1FEB
-ENCODING 8171
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 12 0 0
-BITMAP
-4000
-7C78
-8820
 8440
 0440
 0280
@@ -60669,66 +65465,94 @@
 0100
 07C0
 ENDCHAR
-STARTCHAR C082
-ENCODING 8172
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 13 0 0
+STARTCHAR uni1F5B
+ENCODING 8027
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 12 0 0
 BITMAP
-C000
-C000
-9FE0
-8430
-4410
-0410
-0430
-07E0
-0400
-0400
-0400
-0400
-1F00
+D000
+D78F
+8904
+4888
+0088
+0050
+0070
+0020
+0020
+0020
+0020
+00F8
 ENDCHAR
-STARTCHAR char901
-ENCODING 8173
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 4 2 11
+STARTCHAR uni1F5D
+ENCODING 8029
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 12 0 0
 BITMAP
-20
-20
-DC
-CC
+C800
+CF8F
+9104
+5088
+0088
+0050
+0070
+0020
+0020
+0020
+0020
+00F8
 ENDCHAR
-STARTCHAR char901
-ENCODING 8174
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 4 2 11
+STARTCHAR uni1F5F
+ENCODING 8031
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 16 0 0
 BITMAP
-10
-10
-EC
-CC
+4800
+A800
+9000
+0000
+3000
+3F1E
+2208
+1110
+0110
+00A0
+00E0
+0040
+0040
+0040
+0040
+01F0
 ENDCHAR
-STARTCHAR char8141
-ENCODING 8175
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 4 1 11
+STARTCHAR uni1F60
+ENCODING 8032
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 0
 BITMAP
-80
-80
-40
-40
+1800
+1800
+0800
+1000
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
 ENDCHAR
-STARTCHAR C117
-ENCODING 8178
+STARTCHAR uni1F61
+ENCODING 8033
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 16 1 -5
+BBX 9 12 1 0
 BITMAP
-1000
+1800
+1800
 1000
 0800
 0000
@@ -60739,18 +65563,18 @@
 8880
 8880
 7700
-0000
-1800
-0800
-0A00
-0400
 ENDCHAR
-STARTCHAR C117
-ENCODING 8179
+STARTCHAR uni1F62
+ENCODING 8034
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 12 1 -5
+BBX 9 12 1 0
 BITMAP
+3400
+3400
+1200
+2200
+0000
 2200
 4100
 8080
@@ -60758,21 +65582,17 @@
 8880
 8880
 7700
-0000
-1800
-0800
-0A00
-0400
 ENDCHAR
-STARTCHAR C117
-ENCODING 8180
+STARTCHAR uni1F63
+ENCODING 8035
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 16 1 -5
+BBX 9 12 1 0
 BITMAP
-0400
-0400
-0800
+3400
+3400
+2200
+1200
 0000
 2200
 4100
@@ -60781,21 +65601,36 @@
 8880
 8880
 7700
+ENDCHAR
+STARTCHAR uni1F64
+ENCODING 8036
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 0
+BITMAP
+3200
+3200
+1400
+2400
 0000
-1800
-0800
-0A00
-0400
+2200
+4100
+8080
+8880
+8880
+8880
+7700
 ENDCHAR
-STARTCHAR C117
-ENCODING 8182
+STARTCHAR uni1F65
+ENCODING 8037
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 11 1 0
+BBX 9 12 1 0
 BITMAP
-1200
-2A00
+3200
+3200
 2400
+1400
 0000
 2200
 4100
@@ -60805,15 +65640,20 @@
 8880
 7700
 ENDCHAR
-STARTCHAR C117
-ENCODING 8183
+STARTCHAR uni1F66
+ENCODING 8038
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 16 1 -5
+BBX 9 16 1 0
 BITMAP
-1200
-2A00
 2400
+5400
+4800
+0000
+1800
+1800
+0800
+1000
 0000
 2200
 4100
@@ -60822,4288 +65662,5227 @@
 8880
 8880
 7700
+ENDCHAR
+STARTCHAR uni1F67
+ENCODING 8039
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 0
+BITMAP
+2400
+5400
+4800
 0000
 1800
+1800
+1000
 0800
-0A00
-0400
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
 ENDCHAR
-STARTCHAR C079
-ENCODING 8184
+STARTCHAR uni1F68
+ENCODING 8040
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 0 0
+BITMAP
+C000
+C000
+4F80
+9040
+2020
+2020
+2020
+2020
+1040
+1040
+0880
+28A0
+38E0
+ENDCHAR
+STARTCHAR uni1F69
+ENCODING 8041
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 0 0
+BITMAP
+C000
+C000
+8F80
+5040
+2020
+2020
+2020
+2020
+1040
+1040
+0880
+28A0
+38E0
+ENDCHAR
+STARTCHAR uni1F6A
+ENCODING 8042
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+D000
+D000
+49F0
+8A08
+0404
+0404
+0404
+0404
+0208
+0208
+0110
+0514
+071C
+ENDCHAR
+STARTCHAR uni1F6B
+ENCODING 8043
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+D000
+D000
+89F0
+4A08
+0404
+0404
+0404
+0404
+0208
+0208
+0110
+0514
+071C
+ENDCHAR
+STARTCHAR uni1F6C
+ENCODING 8044
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 12 13 0 0
+BBX 13 13 0 0
 BITMAP
-8000
-8000
-4780
-4840
-1020
-2010
-2010
-2010
-2010
-2010
-1020
-0840
-0780
+C800
+C800
+53E0
+9410
+0808
+0808
+0808
+0808
+0410
+0410
+0220
+0A28
+0E38
 ENDCHAR
-STARTCHAR C079
-ENCODING 8185
+STARTCHAR uni1F6D
+ENCODING 8045
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 12 13 0 0
+BBX 13 13 0 0
 BITMAP
-4000
-4000
-8780
-8840
-1020
-2010
-2010
-2010
-2010
-2010
-1020
-0840
-0780
+C800
+C800
+93E0
+5410
+0808
+0808
+0808
+0808
+0410
+0410
+0220
+0A28
+0E38
 ENDCHAR
-STARTCHAR 0x1FFA
-ENCODING 8186
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 13 0 0
+STARTCHAR uni1F6E
+ENCODING 8046
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 17 0 0
 BITMAP
-8000
-8000
-47C0
-4820
-1010
-1010
-1010
-1010
-0820
-0820
-0440
-1450
-1C70
+4800
+A800
+9000
+0000
+3000
+3000
+13E0
+2410
+0808
+0808
+0808
+0808
+0410
+0410
+0220
+0A28
+0E38
 ENDCHAR
-STARTCHAR 0x1FFB
-ENCODING 8187
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 13 0 0
+STARTCHAR uni1F6F
+ENCODING 8047
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 17 0 0
 BITMAP
-4000
-4000
-87C0
-8820
-1010
-1010
-1010
-1010
-0820
-0820
-0440
-1450
-1C70
+4800
+A800
+9000
+0000
+3000
+3000
+23E0
+1410
+0808
+0808
+0808
+0808
+0410
+0410
+0220
+0A28
+0E38
 ENDCHAR
-STARTCHAR 0x1FFC
-ENCODING 8188
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 -4
+STARTCHAR uni1F70
+ENCODING 8048
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 0
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-4100
-4100
-2200
-A280
-E380
-1800
-0800
-0A00
-0400
+20
+20
+10
+10
+00
+62
+92
+94
+8C
+88
+98
+66
 ENDCHAR
-STARTCHAR char8141
-ENCODING 8189
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 4 1 11
+STARTCHAR uni1F71
+ENCODING 8049
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 0
+BITMAP
+10
+10
+20
+20
+00
+62
+92
+94
+8C
+88
+98
+66
+ENDCHAR
+STARTCHAR uni1F72
+ENCODING 8050
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
 BITMAP
 40
 40
+20
+20
+00
+70
+90
 80
+60
 80
+88
+70
 ENDCHAR
-STARTCHAR C044
-ENCODING 8190
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 5 1 11
+STARTCHAR uni1F73
+ENCODING 8051
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
 BITMAP
-C0
-C0
+10
+10
+20
+20
+00
+70
+90
 80
+60
 80
-40
+88
+70
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8192
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
+STARTCHAR uni1F74
+ENCODING 8052
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
 BITMAP
-B6D6
-8000
-2272
-B288
-2A8A
-A69A
-A278
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8193
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-2272
-B688
-2A8A
-A29A
-A278
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8194
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3E8A
-A0C8
-38AA
-A09A
-BE88
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8195
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3E8A
-A0D8
-38AA
-A08A
-BE88
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8196
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-388A
-84D8
-18AA
-848A
-B888
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8197
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-288A
-A8D8
-3CAA
-888A
-8888
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8198
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-1C8A
-A0D8
-38AA
-A48A
-9888
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8199
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-07C2
-8400
-0702
-8402
-8400
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8200
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-0782
-8440
-0782
-8402
-8400
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8201
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3E8A
-8888
-08FA
-888A
-8888
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8202
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-0442
-8440
-07C2
-8442
-8440
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8203
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3EAA
-84A8
-08AA
-90AA
-BE50
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8204
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3EAA
-84A8
-08AA
-90AA
-BE50
-0002
-A20A
-B208
-2A0A
-A68A
-A270
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8205
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3EAA
-84A8
-08AA
-90AA
-BE50
-0002
-8042
-8040
-0042
-8442
-8380
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8206
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-20F2
-A088
-20F2
-A092
-BE88
-0002
-8442
-86C0
-0542
-8442
-8440
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8207
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3C82
-A280
-3C82
-A482
-A2F8
-0002
-8442
-86C0
-0542
-8442
-8440
-0002
-DB6A
+20
+20
+10
+10
+00
+98
+64
+44
+44
+44
+44
+44
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR C032
-ENCODING 8208
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 1 1 4
+STARTCHAR uni1F75
+ENCODING 8053
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
 BITMAP
-F0
+10
+10
+20
+20
+00
+98
+64
+44
+44
+44
+44
+44
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR C045
-ENCODING 8209
+STARTCHAR uni1F76
+ENCODING 8054
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 4 1 1 4
-BITMAP
-F0
-ENDCHAR
-STARTCHAR EN DASH
-ENCODING 8210
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 1 1 4
-BITMAP
-FE
-ENDCHAR
-STARTCHAR EN DASH
-ENCODING 8211
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 1 1 4
-BITMAP
-FE
-ENDCHAR
-STARTCHAR EM DASH
-ENCODING 8212
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 1 1 4
-BITMAP
-FFFE
-ENDCHAR
-STARTCHAR EM DASH
-ENCODING 8213
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 1 1 4
-BITMAP
-FFFF
-ENDCHAR
-STARTCHAR EM DASH
-ENCODING 8214
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 13 0 0
-BITMAP
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-ENDCHAR
-STARTCHAR C069
-ENCODING 8215
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 3 0 -3
-BITMAP
-FFC0
-0000
-FFC0
-ENDCHAR
-STARTCHAR C044
-ENCODING 8216
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 5 1 7
+BBX 4 11 1 0
 BITMAP
-40
 80
 80
-C0
-C0
-ENDCHAR
-STARTCHAR C044
-ENCODING 8217
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 5 1 7
-BITMAP
-C0
-C0
 40
+00
 40
-80
-ENDCHAR
-STARTCHAR C044
-ENCODING 8218
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 5 1 -3
-BITMAP
 C0
-C0
 40
 40
-80
+40
+50
+20
 ENDCHAR
-STARTCHAR C044
-ENCODING 8219
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 5 1 7
+STARTCHAR uni1F77
+ENCODING 8055
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 11 1 0
 BITMAP
-C0
+20
+20
+40
+00
+40
 C0
-80
-80
 40
+40
+40
+50
+20
 ENDCHAR
-STARTCHAR C092
-ENCODING 8220
+STARTCHAR uni1F78
+ENCODING 8056
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 5 1 7
+BBX 5 11 1 0
 BITMAP
-48
-90
-90
-D8
-D8
+40
+40
+20
+00
+70
+88
+88
+88
+88
+88
+70
 ENDCHAR
-STARTCHAR C034
-ENCODING 8221
+STARTCHAR uni1F79
+ENCODING 8057
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 5 1 7
+BBX 5 11 1 0
 BITMAP
-D8
-D8
-48
-48
-90
+20
+20
+40
+00
+70
+88
+88
+88
+88
+88
+70
 ENDCHAR
-STARTCHAR C034
-ENCODING 8222
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 1 -3
+STARTCHAR uni1F7A
+ENCODING 8058
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-D8
-D8
-48
+20
+20
+10
+00
+C8
+44
+44
+44
+44
 48
-90
+30
 ENDCHAR
-STARTCHAR C034
-ENCODING 8223
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 1 7
+STARTCHAR uni1F7B
+ENCODING 8059
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-D8
-D8
-90
-90
+10
+10
+20
+00
+C8
+44
+44
+44
+44
 48
+30
 ENDCHAR
-STARTCHAR C121
-ENCODING 8224
+STARTCHAR uni1F7C
+ENCODING 8060
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+1000
+1000
+0800
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+ENDCHAR
+STARTCHAR uni1F7D
+ENCODING 8061
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+0400
+0400
+0800
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+ENDCHAR
+STARTCHAR uni1F80
+ENCODING 8064
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 -3
+BBX 7 17 1 -5
 BITMAP
-10
-38
-10
-10
-54
-FE
-54
-10
-10
-38
-10
-10
-10
+18
+18
+08
 10
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
 10
 ENDCHAR
-STARTCHAR C121
-ENCODING 8225
+STARTCHAR uni1F81
+ENCODING 8065
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 15 1 -3
+BBX 7 17 1 -5
 BITMAP
-10
-38
-10
-10
-54
-FE
-56
-10
-54
-FE
-54
-10
+30
+30
+20
 10
-38
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
 10
 ENDCHAR
-STARTCHAR C045
-ENCODING 8226
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 4 1 3
+STARTCHAR uni1F82
+ENCODING 8066
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 17 1 -5
 BITMAP
-60
-F0
-F0
+68
+68
+24
+44
+00
+62
+92
+94
+8C
+88
+98
+66
+00
 60
+20
+28
+10
 ENDCHAR
-STARTCHAR C045
-ENCODING 8227
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 6 1 2
+STARTCHAR uni1F83
+ENCODING 8067
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 17 1 -5
 BITMAP
-80
-E0
-F8
-F8
-E0
-80
+68
+68
+44
+24
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
+10
 ENDCHAR
-STARTCHAR C046
-ENCODING 8228
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 2 2 1 0
+STARTCHAR uni1F84
+ENCODING 8068
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 17 1 -5
 BITMAP
-C0
-C0
+64
+64
+28
+48
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
+10
 ENDCHAR
-STARTCHAR C046
-ENCODING 8229
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 6 2 1 0
+STARTCHAR uni1F85
+ENCODING 8069
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 17 1 -5
 BITMAP
-CC
-CC
+64
+64
+48
+28
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
+10
 ENDCHAR
-STARTCHAR C046
-ENCODING 8230
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 10 2 1 0
+STARTCHAR uni1F86
+ENCODING 8070
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 21 1 -5
 BITMAP
-CCC0
-CCC0
+24
+54
+48
+00
+18
+18
+08
+10
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
+10
 ENDCHAR
-STARTCHAR C046
-ENCODING 8231
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 2 1 3
+STARTCHAR uni1F87
+ENCODING 8071
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 21 1 -5
 BITMAP
-C0
-C0
+24
+54
+48
+00
+30
+30
+20
+10
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
+10
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8232
+STARTCHAR uni1F88
+ENCODING 8072
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 15 15 0 0
+BBX 15 13 0 0
 BITMAP
-B6D6
-8000
-0202
-8200
-0202
-8202
-83E0
-0002
-9BB2
-A228
-1332
-8A22
-B3A0
-0002
-DB6A
+6000
+6000
+2400
+4400
+0A00
+0A00
+0A00
+1100
+1100
+1F18
+2088
+208A
+F1E4
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8233
+STARTCHAR uni1F89
+ENCODING 8073
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 15 15 0 0
+BBX 15 13 0 0
 BITMAP
-B6D6
-8000
-03C2
-8220
-03C2
-8202
-8200
-0002
-9BB2
-A228
-1332
-8A22
-B3A0
-0002
-DB6A
+6000
+6000
+4400
+2400
+0A00
+0A00
+0A00
+1100
+1100
+1F18
+2088
+208A
+F1E4
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8234
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
+STARTCHAR uni1F8A
+ENCODING 8074
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 13 0 0
 BITMAP
-B6D6
-8000
-0002
-8000
-0002
-A33A
-A2A0
-2332
-A322
-BAB8
-0002
-8002
-8000
-0002
-DB6A
+D000
+D000
+4A00
+8A00
+0500
+0500
+0500
+0880
+0880
+0F8C
+1044
+1045
+78F2
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8235
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
+STARTCHAR uni1F8B
+ENCODING 8075
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 13 0 0
 BITMAP
-B6D6
-8000
-0002
-8000
-0002
-B23A
-AA20
-3232
-B222
-ABB8
-0002
-8002
-8000
-0002
-DB6A
+D000
+D000
+8A00
+4A00
+0500
+0500
+0500
+0880
+0880
+0F8C
+1044
+1045
+78F2
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8236
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
+STARTCHAR uni1F8C
+ENCODING 8076
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 13 0 0
 BITMAP
-B6D6
-8000
-0002
-8000
-0002
-B33A
-AAA0
-32B2
-A2A2
-A320
-0002
-8002
-8000
-0002
-DB6A
+C800
+C800
+5200
+9200
+0500
+0500
+0500
+0880
+0880
+0F8C
+1044
+1045
+78F2
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8237
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
+STARTCHAR uni1F8D
+ENCODING 8077
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 13 0 0
 BITMAP
-B6D6
-8000
-0002
-8000
-0002
-A312
-A2A8
-232A
-A32A
-BA90
-0002
-8002
-8000
-0002
-DB6A
+C800
+C800
+9200
+5200
+0500
+0500
+0500
+0880
+0880
+0F8C
+1044
+1045
+78F2
 ENDCHAR
-STARTCHAR char8192
-ENCODING 8238
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
+STARTCHAR uni1F8E
+ENCODING 8078
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 17 0 0
 BITMAP
-B6D6
-8000
-0002
-8000
-0002
-B212
-AA28
-322A
-B22A
-AB90
-0002
-8002
-8000
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 8239
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-2AB2
-AAA8
-3BB2
-BBAA
-AAB0
-0002
-9EF2
-A088
-1CF2
-8282
-BC80
-0002
-DB6A
+4800
+A800
+9000
+0000
+3000
+3000
+1200
+2200
+0500
+0500
+0500
+0880
+0880
+0F8C
+1044
+1045
+78F2
 ENDCHAR
-STARTCHAR C037
-ENCODING 8240
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 1 -1
+STARTCHAR uni1F8F
+ENCODING 8079
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 17 0 0
 BITMAP
-6080
-9900
-9700
-9200
-9400
-6400
-0800
-1318
-14A4
-24A4
-44A4
-44A4
-8318
+4800
+A800
+9000
+0000
+3000
+3000
+2200
+1200
+0500
+0500
+0500
+0880
+0880
+0F8C
+1044
+1045
+78F2
 ENDCHAR
-STARTCHAR C037
-ENCODING 8241
-SWIDTH 1200 0
-DWIDTH 20 0
-BBX 19 13 1 -1
+STARTCHAR uni1F90
+ENCODING 8080
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
 BITMAP
-608000
-990000
-970000
-920000
-940000
-640000
-080000
-1318C0
-14A520
-24A520
-44A520
-44A520
-8318C0
+30
+30
+10
+20
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR C125
-ENCODING 8242
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 4 1 7
+STARTCHAR uni1F91
+ENCODING 8081
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
 BITMAP
+30
+30
 20
-60
-40
-80
+10
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR C125
-ENCODING 8243
+STARTCHAR uni1F92
+ENCODING 8082
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 4 1 7
+BBX 6 16 1 -4
 BITMAP
+68
+68
 24
-6C
-48
-90
-ENDCHAR
-STARTCHAR C125
-ENCODING 8244
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 4 1 7
-BITMAP
-2480
-6D80
-4900
-9200
-ENDCHAR
-STARTCHAR C125
-ENCODING 8245
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 4 1 7
-BITMAP
-80
-C0
-40
-20
+44
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR C125
-ENCODING 8246
+STARTCHAR uni1F93
+ENCODING 8083
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 6 4 1 7
+BBX 6 16 1 -4
 BITMAP
-90
-D8
-48
+68
+68
+44
 24
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR C125
-ENCODING 8247
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 4 1 7
+STARTCHAR uni1F94
+ENCODING 8084
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
 BITMAP
-9200
-DB00
-4900
-2480
+64
+64
+28
+48
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR char8248
-ENCODING 8248
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 4 1 -2
+STARTCHAR uni1F95
+ENCODING 8085
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 16 1 -4
 BITMAP
-40
-40
-A0
-A0
+64
+64
+48
+28
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR char171
-ENCODING 8249
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 0
+STARTCHAR uni1F96
+ENCODING 8086
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 20 1 -4
 BITMAP
+48
+A8
+90
+00
+30
+30
 10
 20
-60
-C0
-60
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
+ENDCHAR
+STARTCHAR uni1F97
+ENCODING 8087
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 20 1 -4
+BITMAP
+48
+A8
+90
+00
+30
+30
 20
 10
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR char171
-ENCODING 8250
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 0
+STARTCHAR uni1F98
+ENCODING 8088
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 13 0 0
 BITMAP
-80
-40
-60
-30
-60
-40
-80
+C00000
+C00000
+5F7C00
+841000
+041000
+041000
+041000
+07F000
+041000
+041300
+041100
+041140
+1F7C80
 ENDCHAR
-STARTCHAR char8251
-ENCODING 8251
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 1 0
+STARTCHAR uni1F99
+ENCODING 8089
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 13 0 0
 BITMAP
-8040
-4C80
-4C80
-2100
-1200
-1200
-CCC0
-D2C0
-1200
-2100
-4C80
-4C80
-8040
+C00000
+C00000
+9F7C00
+441000
+041000
+041000
+041000
+07F000
+041000
+041300
+041100
+041140
+1F7C80
 ENDCHAR
-STARTCHAR C033
-ENCODING 8252
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 12 1 0
+STARTCHAR uni1F9A
+ENCODING 8090
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 13 0 0
 BITMAP
-D8
-D8
-D8
-D8
-D8
-D8
-D8
-00
-00
-00
-D8
-D8
+D00000
+D00000
+4FDF00
+890400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
-STARTCHAR C063
-ENCODING 8253
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni1F9B
+ENCODING 8091
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 13 0 0
 BITMAP
-78
-84
-A4
-24
-28
-30
-20
-60
-60
-00
-60
-60
+D00000
+D00000
+8FDF00
+490400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
-STARTCHAR C069
-ENCODING 8254
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 1 0 12
+STARTCHAR uni1F9C
+ENCODING 8092
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 13 0 0
 BITMAP
-FFC0
+C80000
+C80000
+57DF00
+910400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
-STARTCHAR C065
-ENCODING 8255
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 3 1 0
+STARTCHAR uni1F9D
+ENCODING 8093
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 13 0 0
 BITMAP
-8020
-4040
-3F80
+C80000
+C80000
+97DF00
+510400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
-STARTCHAR C065
-ENCODING 8256
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 3 1 12
+STARTCHAR uni1F9E
+ENCODING 8094
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 17 0 0
 BITMAP
-3F80
-4040
-8020
+480000
+A80000
+900000
+000000
+300000
+300000
+17DF00
+210400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
-STARTCHAR C047
-ENCODING 8257
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 8 1 -4
+STARTCHAR uni1F9F
+ENCODING 8095
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 17 0 0
 BITMAP
-10
-10
-20
-20
-40
-60
-90
-90
+480000
+A80000
+900000
+000000
+300000
+300000
+27DF00
+110400
+010400
+010400
+010400
+01FC00
+010400
+0104C0
+010440
+010450
+07DF20
 ENDCHAR
-STARTCHAR C042
-ENCODING 8258
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 10 1 1
+STARTCHAR uni1FA0
+ENCODING 8096
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -5
 BITMAP
+1800
+1800
+0800
+1000
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
 0400
-1500
-0E00
-1500
+ENDCHAR
+STARTCHAR uni1FA1
+ENCODING 8097
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -5
+BITMAP
+1800
+1800
+1000
+0800
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
 0400
-2080
-AAA0
-71C0
-AAA0
-2080
 ENDCHAR
-STARTCHAR C045
-ENCODING 8259
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 2 1 3
+STARTCHAR uni1FA2
+ENCODING 8098
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -5
 BITMAP
-F0
-F0
+3400
+3400
+1200
+2200
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR C047
-ENCODING 8260
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 16 1 -4
+STARTCHAR uni1FA3
+ENCODING 8099
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -5
 BITMAP
-01
-01
-02
-02
-04
-04
-08
-08
-10
-10
-20
-20
-40
-40
-80
-80
+3400
+3400
+2200
+1200
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR C091
-ENCODING 8261
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 3 16 1 -4
+STARTCHAR uni1FA4
+ENCODING 8100
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -5
 BITMAP
-E0
-80
-80
-80
-80
-80
-80
-E0
-80
-80
-80
-80
-80
-80
-80
-E0
+3200
+3200
+1400
+2400
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR C093
-ENCODING 8262
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 3 16 0 -4
+STARTCHAR uni1FA5
+ENCODING 8101
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -5
 BITMAP
-E0
-20
-20
-20
-20
-20
-20
-E0
-20
-20
-20
-20
-20
-20
-20
-E0
+3200
+3200
+2400
+1400
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR C063
-ENCODING 8264
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 9 12 1 0
+STARTCHAR uni1FA6
+ENCODING 8102
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 21 1 -5
 BITMAP
-7180
-8980
-8980
-1180
-2180
-2180
-6180
+2400
+5400
+4800
 0000
+1800
+1800
+0800
+1000
 0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
 0000
-6180
-6180
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR C063
-ENCODING 8265
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 9 12 1 0
+STARTCHAR uni1FA7
+ENCODING 8103
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 21 1 -5
 BITMAP
-C700
-C880
-C880
-C100
-C200
-C200
-C600
+2400
+5400
+4800
 0000
+1800
+1800
+1000
+0800
 0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
 0000
-C600
-C600
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR char171
-ENCODING 8266
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 7 1 0
+STARTCHAR uni1FA8
+ENCODING 8104
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 13 0 0
 BITMAP
-80
-F8
-08
-10
-20
-40
-80
+C000
+C000
+4F80
+9040
+2020
+2020
+2020
+2020
+1040
+104C
+0884
+28A5
+38E2
 ENDCHAR
-STARTCHAR char182
-ENCODING 8267
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 15 1 -4
+STARTCHAR uni1FA9
+ENCODING 8105
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 13 0 0
 BITMAP
-F8
-5C
-5E
-5E
-5E
-5C
-58
-50
-50
-50
-50
-50
-50
-50
-50
+C000
+C000
+8F80
+5040
+2020
+2020
+2020
+2020
+1040
+104C
+0884
+28A5
+38E2
 ENDCHAR
-STARTCHAR char8268
-ENCODING 8268
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 7 1 2
+STARTCHAR uni1FAA
+ENCODING 8106
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 19 13 0 0
 BITMAP
-3C
-74
-F4
-F4
-F4
-74
-3C
+D00000
+D00000
+49F000
+8A0800
+040400
+040400
+040400
+040400
+020800
+020980
+011080
+0514A0
+071C40
 ENDCHAR
-STARTCHAR char8268
-ENCODING 8269
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 7 1 2
+STARTCHAR uni1FAB
+ENCODING 8107
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 19 13 0 0
 BITMAP
-F0
-B8
-BC
-BC
-BC
-B8
-F0
+D00000
+D00000
+89F000
+4A0800
+040400
+040400
+040400
+040400
+020800
+020980
+011080
+0514A0
+071C40
 ENDCHAR
-STARTCHAR char8304
-ENCODING 8304
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 6
+STARTCHAR uni1FAC
+ENCODING 8108
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 13 0 0
 BITMAP
-60
-90
-90
-90
-90
-90
-60
+C80000
+C80000
+53E000
+941000
+080800
+080800
+080800
+080800
+041000
+041300
+022100
+0A2940
+0E3880
 ENDCHAR
-STARTCHAR char185
-ENCODING 8308
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 7 1 6
+STARTCHAR uni1FAD
+ENCODING 8109
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 13 0 0
 BITMAP
-10
-30
-50
-90
-F8
-10
-38
+C80000
+C80000
+93E000
+541000
+080800
+080800
+080800
+080800
+041000
+041300
+022100
+0A2940
+0E3880
 ENDCHAR
-STARTCHAR char8309
-ENCODING 8309
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 6
+STARTCHAR uni1FAE
+ENCODING 8110
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 17 0 0
 BITMAP
-F0
-80
-A0
-D0
-10
-90
-60
+480000
+A80000
+900000
+000000
+300000
+300000
+13E000
+241000
+080800
+080800
+080800
+080800
+041000
+041300
+022100
+0A2940
+0E3880
 ENDCHAR
-STARTCHAR char8310
-ENCODING 8310
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 6
+STARTCHAR uni1FAF
+ENCODING 8111
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 17 0 0
 BITMAP
-60
-90
-80
-E0
-90
-90
-60
+480000
+A80000
+900000
+000000
+300000
+300000
+23E000
+141000
+080800
+080800
+080800
+080800
+041000
+041300
+022100
+0A2940
+0E3880
 ENDCHAR
-STARTCHAR char8311
-ENCODING 8311
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 6
+STARTCHAR uni1FB0
+ENCODING 8112
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-F0
-90
-20
-20
-40
-40
-40
+44
+38
+00
+00
+62
+92
+94
+8C
+88
+98
+66
 ENDCHAR
-STARTCHAR char8310
-ENCODING 8312
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 6
+STARTCHAR uni1FB1
+ENCODING 8113
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 10 1 0
 BITMAP
-60
-90
-90
-60
-90
-90
-60
+7C
+00
+00
+62
+92
+94
+8C
+88
+98
+66
 ENDCHAR
-STARTCHAR char8310
-ENCODING 8313
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 6
+STARTCHAR uni1FB2
+ENCODING 8114
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 17 1 -5
 BITMAP
-60
-90
-90
-70
 10
-90
+10
+08
+08
+00
+62
+92
+94
+8C
+88
+98
+66
+00
 60
-ENDCHAR
-STARTCHAR char8314
-ENCODING 8314
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 1 7
-BITMAP
-20
-20
-F8
 20
-20
-ENDCHAR
-STARTCHAR char8314
-ENCODING 8315
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 1 1 9
-BITMAP
-F8
+28
+10
 ENDCHAR
-STARTCHAR char8314
-ENCODING 8316
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 3 1 8
+STARTCHAR uni1FB3
+ENCODING 8115
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 -5
 BITMAP
-F8
+62
+92
+94
+8C
+88
+98
+66
 00
-F8
+60
+20
+28
+10
 ENDCHAR
-STARTCHAR char8317
-ENCODING 8317
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 7 1 6
+STARTCHAR uni1FB4
+ENCODING 8116
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 17 1 -5
 BITMAP
-40
-80
-80
-80
-80
-80
-40
+08
+08
+10
+10
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
+10
 ENDCHAR
-STARTCHAR char8317
-ENCODING 8318
+STARTCHAR uni1FB6
+ENCODING 8118
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+24
+54
+48
+00
+62
+92
+94
+8C
+88
+98
+66
+ENDCHAR
+STARTCHAR uni1FB7
+ENCODING 8119
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 16 1 -5
+BITMAP
+24
+54
+48
+00
+62
+92
+94
+8C
+88
+98
+66
+00
+60
+20
+28
+10
+ENDCHAR
+STARTCHAR uni1FB8
+ENCODING 8120
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 0 0
+BITMAP
+1100
+0E00
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1FB9
+ENCODING 8121
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+1F00
+0000
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1FBA
+ENCODING 8122
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+4000
+4000
+2400
+2400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1FBB
+ENCODING 8123
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+2000
+2000
+4400
+4400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni1FBC
+ENCODING 8124
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 0 0
+BITMAP
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F18
+2088
+208A
+F1E4
+ENDCHAR
+STARTCHAR uni1FBD
+ENCODING 8125
 SWIDTH 180 0
 DWIDTH 3 0
-BBX 2 7 1 6
+BBX 2 5 1 11
 BITMAP
-80
+C0
+C0
 40
 40
+80
+ENDCHAR
+STARTCHAR uni1FBE
+ENCODING 8126
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 4 1 -4
+BITMAP
+C0
 40
+50
+20
+ENDCHAR
+STARTCHAR uni1FBF
+ENCODING 8127
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 5 1 11
+BITMAP
+C0
+C0
 40
 40
 80
 ENDCHAR
-STARTCHAR C110
-ENCODING 8319
+STARTCHAR uni1FC0
+ENCODING 8128
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 5 1 6
+BBX 5 3 1 11
 BITMAP
-D0
-68
 48
-48
-48
+A8
+90
 ENDCHAR
-STARTCHAR char8304
-ENCODING 8320
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 -4
+STARTCHAR uni1FC1
+ENCODING 8129
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 6 1 11
 BITMAP
-60
-90
-90
-90
-90
+48
+A8
 90
-60
+00
+D8
+D8
 ENDCHAR
-STARTCHAR char185
-ENCODING 8321
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 7 1 -4
+STARTCHAR uni1FC2
+ENCODING 8130
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -4
 BITMAP
-40
-C0
-40
-40
-40
-40
-E0
+20
+20
+10
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR char178
-ENCODING 8322
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 -4
+STARTCHAR uni1FC3
+ENCODING 8131
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 -4
 BITMAP
-60
-90
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
+ENDCHAR
+STARTCHAR uni1FC4
+ENCODING 8132
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -4
+BITMAP
 10
 10
 20
-40
-F0
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
 ENDCHAR
-STARTCHAR char8323
-ENCODING 8323
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 7 1 -4
+STARTCHAR uni1FC6
+ENCODING 8134
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -4
 BITMAP
-60
-90
-10
-20
-10
-90
-60
+24
+54
+48
+00
+98
+64
+44
+44
+44
+44
+44
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR char185
-ENCODING 8324
+STARTCHAR uni1FC7
+ENCODING 8135
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -4
+BITMAP
+24
+54
+48
+00
+98
+64
+44
+44
+44
+44
+44
+04
+C4
+44
+64
+ENDCHAR
+STARTCHAR uni1FC8
+ENCODING 8136
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 13 0 0
+BITMAP
+8000
+8000
+5FF0
+4410
+0410
+0450
+0440
+07C0
+0448
+0448
+0410
+0410
+1FF0
+ENDCHAR
+STARTCHAR uni1FC9
+ENCODING 8137
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 13 0 0
+BITMAP
+4000
+4000
+9FF0
+8410
+0410
+0450
+0440
+07C0
+0448
+0448
+0410
+0410
+1FF0
+ENDCHAR
+STARTCHAR uni1FCA
+ENCODING 8138
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+8000
+8000
+5F7C
+4410
+0410
+0410
+0410
+07F0
+0410
+0410
+0410
+0410
+1F7C
+ENDCHAR
+STARTCHAR uni1FCB
+ENCODING 8139
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 0 0
+BITMAP
+4000
+4000
+9F7C
+8410
+0410
+0410
+0410
+07F0
+0410
+0410
+0410
+0410
+1F7C
+ENDCHAR
+STARTCHAR uni1FCC
+ENCODING 8140
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 11 0 0
+BITMAP
+FBE0
+2080
+2080
+2080
+2080
+3F80
+2080
+2098
+2088
+208A
+FBE4
+ENDCHAR
+STARTCHAR uni1FCD
+ENCODING 8141
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 7 1 -4
+BBX 5 4 1 11
 BITMAP
-10
-30
+D0
+D0
+48
+88
+ENDCHAR
+STARTCHAR uni1FCE
+ENCODING 8142
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 4 1 11
+BITMAP
+C8
+C8
 50
 90
-F8
+ENDCHAR
+STARTCHAR uni1FCF
+ENCODING 8143
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 8 1 11
+BITMAP
+48
+A8
+90
+00
+30
+30
 10
-38
+20
 ENDCHAR
-STARTCHAR char8309
-ENCODING 8325
+STARTCHAR uni1FD0
+ENCODING 8144
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 4 7 1 -4
+BBX 5 11 0 0
 BITMAP
-F0
-80
-A0
-D0
-10
-90
+88
+70
+00
+00
+20
 60
+20
+20
+20
+28
+10
 ENDCHAR
-STARTCHAR char8310
-ENCODING 8326
+STARTCHAR uni1FD1
+ENCODING 8145
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 4 7 1 -4
+BBX 5 10 0 0
 BITMAP
-60
-90
-80
-E0
-90
-90
+F8
+00
+00
+20
 60
+20
+20
+20
+28
+10
 ENDCHAR
-STARTCHAR char8311
-ENCODING 8327
+STARTCHAR uni1FD2
+ENCODING 8146
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 4 7 1 -4
+BBX 6 13 -1 0
 BITMAP
-F0
-90
 20
 20
-40
-40
-40
+DC
+CC
+00
+00
+10
+30
+10
+10
+10
+14
+08
 ENDCHAR
-STARTCHAR char8310
-ENCODING 8328
+STARTCHAR uni1FD3
+ENCODING 8147
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 4 7 1 -4
+BBX 6 13 -1 0
 BITMAP
-60
-90
-90
-60
-90
-90
-60
+10
+10
+EC
+CC
+00
+00
+10
+30
+10
+10
+10
+14
+08
 ENDCHAR
-STARTCHAR char8310
-ENCODING 8329
+STARTCHAR uni1FD6
+ENCODING 8150
 SWIDTH 300 0
 DWIDTH 5 0
-BBX 4 7 1 -4
+BBX 5 12 0 0
 BITMAP
-60
-90
-90
-70
-10
+48
+A8
 90
+00
+00
+20
 60
+20
+20
+20
+28
+10
 ENDCHAR
-STARTCHAR char8314
-ENCODING 8330
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 1 -3
+STARTCHAR uni1FD7
+ENCODING 8151
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
 BITMAP
+48
+A8
+90
+00
+D8
+D8
+00
+00
 20
+60
 20
-F8
 20
 20
+28
+10
 ENDCHAR
-STARTCHAR char8314
-ENCODING 8331
+STARTCHAR uni1FD8
+ENCODING 8152
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 1 1 -1
+BBX 5 14 1 0
 BITMAP
+88
+70
+00
+F8
+20
+20
+20
+20
+20
+20
+20
+20
+20
 F8
 ENDCHAR
-STARTCHAR char8314
-ENCODING 8332
+STARTCHAR uni1FD9
+ENCODING 8153
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 3 1 -2
+BBX 5 13 1 0
 BITMAP
 F8
 00
 F8
+20
+20
+20
+20
+20
+20
+20
+20
+20
+F8
 ENDCHAR
-STARTCHAR char8317
-ENCODING 8333
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 7 1 -4
+STARTCHAR uni1FDA
+ENCODING 8154
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 0 0
 BITMAP
-40
-80
 80
 80
-80
-80
-40
+5F
+44
+04
+04
+04
+04
+04
+04
+04
+04
+1F
 ENDCHAR
-STARTCHAR char8317
-ENCODING 8334
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 2 7 1 -4
+STARTCHAR uni1FDB
+ENCODING 8155
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 0 0
 BITMAP
-80
-40
 40
 40
-40
-40
-80
+9F
+84
+04
+04
+04
+04
+04
+04
+04
+04
+1F
 ENDCHAR
-STARTCHAR C067
-ENCODING 8352
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 8 12 2 0
+STARTCHAR uni1FDD
+ENCODING 8157
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 4 1 11
 BITMAP
-34
-4C
-84
-80
-9F
-89
+D0
+D0
+88
 48
-3E
-08
-08
-09
-1F
 ENDCHAR
-STARTCHAR C067
-ENCODING 8353
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 9 16 2 -2
+STARTCHAR uni1FDE
+ENCODING 8158
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 4 1 11
 BITMAP
-0500
-0500
-0A00
-1E80
-2B80
-4A80
-9480
-9400
-9400
-9400
-A880
-6880
-2900
-3E00
-5000
-5000
+C8
+C8
+90
+50
 ENDCHAR
-STARTCHAR C067
-ENCODING 8354
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 9 11 2 0
+STARTCHAR uni1FDF
+ENCODING 8159
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 8 1 11
 BITMAP
-1E80
-2180
-4080
-8080
-9A00
-8D00
-8800
-8880
-4880
-2900
-1E00
+48
+A8
+90
+00
+30
+30
+20
+10
 ENDCHAR
-STARTCHAR C070
-ENCODING 8355
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 9 11 2 0
+STARTCHAR uni1FE0
+ENCODING 8160
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-FF80
-2080
-2080
-2000
-2700
-3C80
-2480
-2700
-2500
-2480
-FC80
+44
+38
+00
+00
+C8
+44
+44
+44
+44
+48
+30
 ENDCHAR
-STARTCHAR C036
-ENCODING 8356
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 8 12 2 0
+STARTCHAR uni1FE1
+ENCODING 8161
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 0
 BITMAP
-06
-09
-11
-10
-7C
-10
 7C
+00
+00
+C8
+44
+44
+44
+44
+48
+30
+ENDCHAR
+STARTCHAR uni1FE2
+ENCODING 8162
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 0
+BITMAP
+20
+20
+DC
+CC
+00
+00
+C8
+44
+44
+44
+44
+48
+30
+ENDCHAR
+STARTCHAR uni1FE3
+ENCODING 8163
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 0
+BITMAP
 10
 10
-51
-B2
+EC
 CC
+00
+00
+C8
+44
+44
+44
+44
+48
+30
 ENDCHAR
-STARTCHAR C109
-ENCODING 8357
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 11 11 2 -2
+STARTCHAR uni1FE4
+ENCODING 8164
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 17 1 -4
 BITMAP
-0100
-0100
-FB80
-4640
-4440
-4440
-4C40
-4C40
-FEE0
-1000
-1000
+30
+30
+10
+20
+00
+00
+70
+88
+88
+88
+88
+88
+F0
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C078
-ENCODING 8358
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 11 11 2 0
+STARTCHAR uni1FE5
+ENCODING 8165
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 17 1 -4
 BITMAP
-E3E0
-3080
-3080
-2880
-FFE0
-2480
-FFE0
-2280
-2180
-2180
-F880
+60
+60
+40
+20
+00
+00
+70
+88
+88
+88
+88
+88
+F0
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C080
-ENCODING 8359
+STARTCHAR uni1FE6
+ENCODING 8166
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
+BITMAP
+24
+54
+48
+00
+00
+C8
+44
+44
+44
+44
+48
+30
+ENDCHAR
+STARTCHAR uni1FE7
+ENCODING 8167
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 0
+BITMAP
+24
+54
+48
+00
+6C
+6C
+00
+00
+C8
+44
+44
+44
+44
+48
+30
+ENDCHAR
+STARTCHAR uni1FE8
+ENCODING 8168
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 11 11 2 0
+BBX 11 14 0 0
 BITMAP
-FF00
-2180
-2080
-FFE0
+1100
+0E00
+0000
+F1E0
 2080
-2180
-3F00
-2000
-2000
-2000
-F800
+1100
+1100
+0A00
+0E00
+0400
+0400
+0400
+0400
+1F00
 ENDCHAR
-STARTCHAR C082
-ENCODING 8360
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 15 11 2 0
+STARTCHAR uni1FE9
+ENCODING 8169
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 13 0 0
 BITMAP
-FE00
-2100
+1F00
+0000
+F1E0
 2080
-FFE0
-209E
-2122
-3E20
-231C
-2102
-2122
-F8FC
+1100
+1100
+0A00
+0E00
+0400
+0400
+0400
+0400
+1F00
 ENDCHAR
-STARTCHAR C087
-ENCODING 8361
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 16 11 2 0
+STARTCHAR uni1FEA
+ENCODING 8170
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 12 0 0
 BITMAP
-F1CF
-2184
-2184
-2244
-FFFF
-1248
-FFFF
-1428
-0C30
-0C30
-0810
+8000
+BC78
+4820
+4440
+0440
+0280
+0380
+0100
+0100
+0100
+0100
+07C0
 ENDCHAR
-STARTCHAR 00A6
-ENCODING 8362
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 10 9 2 0
+STARTCHAR uni1FEB
+ENCODING 8171
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 12 0 0
 BITMAP
-FC00
-8600
-9240
-9240
-9240
-9240
-9040
-10C0
-1F80
+4000
+7C78
+8820
+8440
+0440
+0280
+0380
+0100
+0100
+0100
+0100
+07C0
 ENDCHAR
-STARTCHAR C100
-ENCODING 8363
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 6 14 2 -2
+STARTCHAR uni1FEC
+ENCODING 8172
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 13 0 0
 BITMAP
-18
-08
-7C
-08
-08
-78
-48
-88
-88
-88
-48
-7C
-00
-7C
+C000
+C000
+9FE0
+8430
+4410
+0410
+0430
+07E0
+0400
+0400
+0400
+0400
+1F00
 ENDCHAR
-STARTCHAR C067
-ENCODING 8364
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 11 11 2 0
+STARTCHAR uni1FED
+ENCODING 8173
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 4 2 11
 BITMAP
-07A0
-0860
-1020
-2020
-FF80
-2000
-FE00
-2020
-1020
-0840
-0780
+20
+20
+DC
+CC
 ENDCHAR
-STARTCHAR C075
-ENCODING 8365
+STARTCHAR uni1FEE
+ENCODING 8174
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 4 2 11
+BITMAP
+10
+10
+EC
+CC
+ENDCHAR
+STARTCHAR uni1FEF
+ENCODING 8175
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 4 1 11
+BITMAP
+80
+80
+40
+40
+ENDCHAR
+STARTCHAR uni1FF2
+ENCODING 8178
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 8 11 2 0
+BBX 9 16 1 -5
 BITMAP
-E7
-42
-44
-48
-50
-FE
-50
-48
-44
-42
-E7
+1000
+1000
+0800
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR C084
-ENCODING 8366
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 2 0
+STARTCHAR uni1FF3
+ENCODING 8179
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 -5
 BITMAP
-FF80
+2200
+4100
+8080
 8880
 8880
-8A80
-0C00
-1A00
-2C00
+8880
+7700
+0000
 1800
-2800
 0800
-3E00
+0A00
+0400
 ENDCHAR
-STARTCHAR C036
-ENCODING 8367
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 2 -3
+STARTCHAR uni1FF4
+ENCODING 8180
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -5
 BITMAP
-0180
-0200
-1F80
-2440
-0420
-0820
-0820
-1020
-1020
-104C
-7052
-B192
-CE2C
-0020
-0040
-0040
+0400
+0400
+0800
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR C069
-ENCODING 8400
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 6 2 0 12
+STARTCHAR uni1FF6
+ENCODING 8182
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-40
-FC
+1200
+2A00
+2400
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
 ENDCHAR
-STARTCHAR C069
-ENCODING 8401
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 6 2 0 12
+STARTCHAR uni1FF7
+ENCODING 8183
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -5
 BITMAP
-08
-FC
+1200
+2A00
+2400
+0000
+2200
+4100
+8080
+8880
+8880
+8880
+7700
+0000
+1800
+0800
+0A00
+0400
 ENDCHAR
-STARTCHAR EM DASH
-ENCODING 8402
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 1 13 0 -2
+STARTCHAR uni1FF8
+ENCODING 8184
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 0
 BITMAP
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
+8000
+8000
+4780
+4840
+1020
+2010
+2010
+2010
+2010
+2010
+1020
+0840
+0780
 ENDCHAR
-STARTCHAR EM DASH
-ENCODING 8403
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 1 7 0 1
+STARTCHAR uni1FF9
+ENCODING 8185
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 13 0 0
 BITMAP
-80
-80
-80
-80
-80
-80
-80
+4000
+4000
+8780
+8840
+1020
+2010
+2010
+2010
+2010
+2010
+1020
+0840
+0780
 ENDCHAR
-STARTCHAR char8404
-ENCODING 8404
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 13 5 0 9
+STARTCHAR uni1FFA
+ENCODING 8186
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 13 0 0
 BITMAP
-0780
-1860
-A010
-C008
-E000
+8000
+8000
+47C0
+4820
+1010
+1010
+1010
+1010
+0820
+0820
+0440
+1450
+1C70
 ENDCHAR
-STARTCHAR char8404
-ENCODING 8405
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 13 5 0 9
+STARTCHAR uni1FFB
+ENCODING 8187
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 13 0 0
 BITMAP
-0F00
-30C0
-4028
-8018
-0038
+4000
+4000
+87C0
+8820
+1010
+1010
+1010
+1010
+0820
+0820
+0440
+1450
+1C70
 ENDCHAR
-STARTCHAR C069
-ENCODING 8406
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 6 3 0 11
+STARTCHAR uni1FFC
+ENCODING 8188
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
+BITMAP
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+4130
+2210
+A294
+E388
+ENDCHAR
+STARTCHAR uni1FFD
+ENCODING 8189
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 4 1 11
 BITMAP
 40
-FC
 40
+80
+80
 ENDCHAR
-STARTCHAR C069
-ENCODING 8407
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 6 3 0 11
+STARTCHAR uni1FFE
+ENCODING 8190
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 5 1 11
 BITMAP
-08
-FC
-08
+C0
+C0
+80
+80
+40
 ENDCHAR
-STARTCHAR C023
-ENCODING 8408
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 5 5 0 4
+STARTCHAR uni2000
+ENCODING 8192
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-70
-88
-88
-88
-70
+B6D6
+8000
+2272
+B288
+2A8A
+A69A
+A278
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C023
-ENCODING 8409
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 6 6 0 4
+STARTCHAR uni2001
+ENCODING 8193
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-04
-78
-98
-A8
-88
-70
+B6D6
+8000
+2272
+B688
+2A8A
+A29A
+A278
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C023
-ENCODING 8410
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 6 6 0 3
+STARTCHAR uni2002
+ENCODING 8194
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-70
-88
-A8
-98
-78
-04
+B6D6
+8000
+3E8A
+A0C8
+38AA
+A09A
+BE88
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C046
-ENCODING 8411
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 8 2 0 11
+STARTCHAR uni2003
+ENCODING 8195
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-DB
-DB
+B6D6
+8000
+3E8A
+A0D8
+38AA
+A08A
+BE88
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C046
-ENCODING 8412
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 11 2 0 11
+STARTCHAR uni2004
+ENCODING 8196
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-DB60
-DB60
+B6D6
+8000
+388A
+84D8
+18AA
+848A
+B888
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C040
-ENCODING 8413
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 17 17 0 -3
+STARTCHAR uni2005
+ENCODING 8197
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-400100
-400100
-200200
-180C00
-07F000
+B6D6
+8000
+288A
+A8D8
+3CAA
+888A
+8888
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C040
-ENCODING 8414
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 17 17 0 -3
+STARTCHAR uni2006
+ENCODING 8198
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-FFFF80
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-FFFF80
+B6D6
+8000
+1C8A
+A0D8
+38AA
+A48A
+9888
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C040
-ENCODING 8415
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 17 17 0 -3
+STARTCHAR uni2007
+ENCODING 8199
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-008000
-014000
-022000
-041000
-080800
-100400
-200200
-400100
-800080
-400100
-200200
-100400
-080800
-041000
-022000
-014000
-008000
+B6D6
+8000
+07C2
+8400
+0702
+8402
+8400
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C040
-ENCODING 8416
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 17 17 0 -3
+STARTCHAR uni2008
+ENCODING 8200
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-07F000
-180C00
-200200
-500100
-480100
-840080
-820080
-810080
-808080
-804080
-802080
-801080
-400900
-400500
-200200
-180C00
-07F000
+B6D6
+8000
+0782
+8440
+0782
+8402
+8400
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C069
-ENCODING 8417
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 7 3 0 11
+STARTCHAR uni2009
+ENCODING 8201
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-44
-FE
-44
+B6D6
+8000
+3E8A
+8888
+08FA
+888A
+8888
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C040
-ENCODING 8418
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 17 16 1 -1
+STARTCHAR uni200A
+ENCODING 8202
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-3FFE00
-400100
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-800080
-400100
-3FFE00
+B6D6
+8000
+0442
+8440
+07C2
+8442
+8440
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C040
-ENCODING 8419
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 17 16 1 -1
+STARTCHAR uni200B
+ENCODING 8203
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-3FFE00
-7FFF00
-DFFD80
-EFFB80
-F00780
-F00780
-F00780
-F00780
-F00780
-F00780
-F00780
-F00780
-EFFB80
-DFFD80
-7FFF00
-3FFE00
+B6D6
+8000
+3EAA
+84A8
+08AA
+90AA
+BE50
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR char8448
-ENCODING 8448
+STARTCHAR uni200C
+ENCODING 8204
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 13 11 1 0
+BBX 15 15 0 0
 BITMAP
-3440
-4840
-8880
-9080
-9500
-6930
-0248
-0280
-0480
-0490
-0060
+B6D6
+8000
+3EAA
+84A8
+08AA
+90AA
+BE50
+0002
+A20A
+B208
+2A0A
+A68A
+A270
+0002
+DB6A
 ENDCHAR
-STARTCHAR char8448
-ENCODING 8449
+STARTCHAR uni200D
+ENCODING 8205
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 13 11 1 0
+BBX 15 15 0 0
 BITMAP
-3440
-4840
-8880
-9080
-9500
-6938
-0248
-0220
-0410
-0448
-0070
+B6D6
+8000
+3EAA
+84A8
+08AA
+90AA
+BE50
+0002
+8042
+8040
+0042
+8442
+8380
+0002
+DB6A
 ENDCHAR
-STARTCHAR C067
-ENCODING 8450
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 11 1 0
+STARTCHAR uni200E
+ENCODING 8206
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-1F40
-30C0
-5040
-A040
-A000
-A000
-A000
-A040
-5040
-3080
-1F00
+B6D6
+8000
+20F2
+A088
+20F2
+A092
+BE88
+0002
+8442
+86C0
+0542
+8442
+8440
+0002
+DB6A
 ENDCHAR
-STARTCHAR C067
-ENCODING 8451
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 0
+STARTCHAR uni200F
+ENCODING 8207
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-7000
-887A
-8886
-8902
-7202
-0200
-0200
-0200
-0202
-0102
-0084
-0078
+B6D6
+8000
+3C82
+A280
+3C82
+A482
+A2F8
+0002
+8442
+86C0
+0542
+8442
+8440
+0002
+DB6A
 ENDCHAR
-STARTCHAR C076
-ENCODING 8452
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2010
+ENCODING 8208
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 1 1 4
 BITMAP
-7C00
-1000
-3C00
-5200
-9000
-9000
-9000
-5200
-3C00
-1080
-7F00
+F0
 ENDCHAR
-STARTCHAR char8448
-ENCODING 8453
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 11 1 0
+STARTCHAR uni2011
+ENCODING 8209
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 1 1 4
 BITMAP
-3080
-4880
-8100
-8100
-9200
-6230
-0448
-0488
-0888
-0890
-0060
+F0
 ENDCHAR
-STARTCHAR char8448
-ENCODING 8454
+STARTCHAR uni2012
+ENCODING 8210
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 1 1 4
+BITMAP
+FE
+ENDCHAR
+STARTCHAR uni2013
+ENCODING 8211
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 1 1 4
+BITMAP
+FE
+ENDCHAR
+STARTCHAR uni2014
+ENCODING 8212
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 15 11 1 0
+BBX 15 1 1 4
 BITMAP
-3080
-4880
-8100
-8100
-9200
-6264
-0424
-0424
-0848
-084A
-0034
+FFFE
 ENDCHAR
-STARTCHAR C119
-ENCODING 8455
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
+STARTCHAR uni2015
+ENCODING 8213
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 1 1 4
 BITMAP
-3D
-43
-81
-81
-40
-38
-40
-80
-81
-41
-3E
+FFFF
 ENDCHAR
-STARTCHAR C124
-ENCODING 8456
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2016
+ENCODING 8214
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 13 0 0
 BITMAP
-BC00
-C200
-8100
-8080
-0080
-1F80
-0080
-8080
-8100
-4200
-3C00
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
 ENDCHAR
-STARTCHAR C067
-ENCODING 8457
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 0
+STARTCHAR uni2017
+ENCODING 8215
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 3 0 -3
 BITMAP
-7000
-8BFE
-8882
-8882
-708A
-0088
-00F8
-0088
-0088
-0080
-0080
-03E0
+FFC0
+0000
+FFC0
 ENDCHAR
-STARTCHAR C113
-ENCODING 8458
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 10 1 -4
+STARTCHAR uni2018
+ENCODING 8216
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 5 1 7
 BITMAP
-18
-24
-44
-44
+40
+80
+80
+C0
+C0
+ENDCHAR
+STARTCHAR uni2019
+ENCODING 8217
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 5 1 7
+BITMAP
+C0
+C0
+40
+40
+80
+ENDCHAR
+STARTCHAR uni201A
+ENCODING 8218
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 5 1 -3
+BITMAP
+C0
+C0
+40
+40
+80
+ENDCHAR
+STARTCHAR uni201B
+ENCODING 8219
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 5 1 7
+BITMAP
+C0
+C0
+80
+80
+40
+ENDCHAR
+STARTCHAR uni201C
+ENCODING 8220
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 7
+BITMAP
 48
-38
-1C
-70
 90
-E0
+90
+D8
+D8
 ENDCHAR
-STARTCHAR char8464
-ENCODING 8459
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 12 11 1 0
+STARTCHAR uni201D
+ENCODING 8221
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 7
 BITMAP
-0A10
-1610
-0210
-0420
-0420
-1FE0
-2840
-4840
-4840
-9090
-60E0
+D8
+D8
+48
+48
+90
 ENDCHAR
-STARTCHAR char8460
-ENCODING 8460
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 12 1 -1
+STARTCHAR uni201E
+ENCODING 8222
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 -3
 BITMAP
-7038
-D850
-8840
-C840
-4840
-4FC0
-0840
-0840
-1840
-F058
-6070
-0060
+D8
+D8
+48
+48
+90
 ENDCHAR
-STARTCHAR C072
-ENCODING 8461
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 12 11 1 0
+STARTCHAR uni201F
+ENCODING 8223
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 7
 BITMAP
-F9F0
-50A0
-50A0
-50A0
-50A0
-5FA0
-50A0
-50A0
-50A0
-50A0
-F9F0
+D8
+D8
+90
+90
+48
 ENDCHAR
-STARTCHAR char104
-ENCODING 8462
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 12 1 0
+STARTCHAR uni2020
+ENCODING 8224
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 1 -3
 BITMAP
-30
+10
+38
 10
 10
-20
-20
+54
+FE
+54
+10
+10
 38
-44
-44
-44
-88
-8A
-8C
+10
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR char104
-ENCODING 8463
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 12 1 0
+STARTCHAR uni2021
+ENCODING 8225
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 1 -3
 BITMAP
-30
 10
-1C
-30
-E0
 38
-44
-44
-44
-88
-8A
-8C
+10
+10
+54
+FE
+56
+10
+54
+FE
+54
+10
+10
+38
+10
 ENDCHAR
-STARTCHAR char8464
-ENCODING 8464
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
+STARTCHAR uni2022
+ENCODING 8226
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 4 1 3
 BITMAP
-0E
-12
-22
-04
-04
-04
-08
-38
-48
-90
 60
+F0
+F0
+60
 ENDCHAR
-STARTCHAR char8465
-ENCODING 8465
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2023
+ENCODING 8227
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 6 1 2
 BITMAP
-7F00
-C200
-8600
-C400
-6600
-2200
-0300
-0180
-4080
-E180
-3F00
+80
+E0
+F8
+F8
+E0
+80
 ENDCHAR
-STARTCHAR C036
-ENCODING 8466
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 11 1 0
+STARTCHAR uni2024
+ENCODING 8228
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 2 2 1 0
 BITMAP
-0380
-0440
-0480
-3F00
-0800
-0800
-0800
-1000
-5000
-B100
-CE00
+C0
+C0
 ENDCHAR
-STARTCHAR C036
-ENCODING 8467
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR uni2025
+ENCODING 8229
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 2 1 0
 BITMAP
-10
-28
-28
-28
-50
-50
-50
-60
-60
-C4
-38
+CC
+CC
 ENDCHAR
-STARTCHAR C108
-ENCODING 8468
+STARTCHAR uni2026
+ENCODING 8230
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 12 1 0
+BBX 10 2 1 0
 BITMAP
-6600
-2200
-FFE0
-2200
-2200
-23C0
-2220
-2220
-2220
-2220
-2220
-73C0
+CCC0
+CCC0
 ENDCHAR
-STARTCHAR C078
-ENCODING 8469
+STARTCHAR uni2027
+ENCODING 8231
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 2 1 3
+BITMAP
+C0
+C0
+ENDCHAR
+STARTCHAR uni2028
+ENCODING 8232
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 13 11 1 0
+BBX 15 15 0 0
 BITMAP
-F8F8
-2420
-3420
-2A20
-2A20
-2520
-22A0
-22A0
-2160
-2120
-F8E0
+B6D6
+8000
+0202
+8200
+0202
+8202
+83E0
+0002
+9BB2
+A228
+1332
+8A22
+B3A0
+0002
+DB6A
 ENDCHAR
-STARTCHAR C078
-ENCODING 8470
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 11 1 0
+STARTCHAR uni2029
+ENCODING 8233
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-E3E0
-3080
-3080
-289C
-28A2
-24A2
-22A2
-22A2
-219C
-2180
-F8BE
+B6D6
+8000
+03C2
+8220
+03C2
+8202
+8200
+0002
+9BB2
+A228
+1332
+8A22
+B3A0
+0002
+DB6A
 ENDCHAR
-STARTCHAR C099
-ENCODING 8471
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 10 1 3
+STARTCHAR uni202A
+ENCODING 8234
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-3E00
-4100
-BC80
-9280
-9280
-9C80
-9080
-B880
-4100
-3E00
+B6D6
+8000
+0002
+8000
+0002
+A33A
+A2A0
+2332
+A322
+BAB8
+0002
+8002
+8000
+0002
+DB6A
 ENDCHAR
-STARTCHAR char8472
-ENCODING 8472
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 13 1 -4
+STARTCHAR uni202B
+ENCODING 8235
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-4000
-8700
-8880
-9080
-9080
-A480
-AC80
-4900
-A600
-A000
-9000
-9000
-6000
+B6D6
+8000
+0002
+8000
+0002
+B23A
+AA20
+3232
+B222
+ABB8
+0002
+8002
+8000
+0002
+DB6A
 ENDCHAR
-STARTCHAR C080
-ENCODING 8473
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 11 1 0
+STARTCHAR uni202C
+ENCODING 8236
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-FF80
-52C0
-5140
-5140
-5140
-52C0
-5F80
-5000
-5000
-5000
-F800
+B6D6
+8000
+0002
+8000
+0002
+B33A
+AAA0
+32B2
+A2A2
+A320
+0002
+8002
+8000
+0002
+DB6A
 ENDCHAR
-STARTCHAR C081
-ENCODING 8474
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 14 1 -3
+STARTCHAR uni202D
+ENCODING 8237
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-1F00
-3180
-5140
-A0A0
-A0A0
-A0A0
-A0A0
-A0A0
-5540
-3B80
-1F00
-0500
-0520
-03C0
+B6D6
+8000
+0002
+8000
+0002
+A312
+A2A8
+232A
+A32A
+BA90
+0002
+8002
+8000
+0002
+DB6A
 ENDCHAR
-STARTCHAR C036
-ENCODING 8475
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni202E
+ENCODING 8238
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-01C0
-0620
-0A20
-1440
-2480
-4B00
-4A00
-8A00
-9100
-9120
-60C0
+B6D6
+8000
+0002
+8000
+0002
+B212
+AA28
+322A
+B22A
+AB90
+0002
+8002
+8000
+0002
+DB6A
 ENDCHAR
-STARTCHAR char8460
-ENCODING 8476
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 11 1 0
+STARTCHAR uni202F
+ENCODING 8239
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-7380
-DCC0
-8840
-C8C0
-4880
-4B00
-0B00
-0B00
-1900
-F1C0
-6180
+B6D6
+8000
+2AB2
+AAA8
+3BB2
+BBAA
+AAB0
+0002
+9EF2
+A088
+1CF2
+8282
+BC80
+0002
+DB6A
 ENDCHAR
-STARTCHAR C082
-ENCODING 8477
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 12 11 1 0
+STARTCHAR uni2030
+ENCODING 8240
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 1 -1
 BITMAP
-FF00
-5280
-5140
-5140
-5280
-5F00
-5580
-5280
-5280
-5280
-F970
+6080
+9900
+9700
+9200
+9400
+6400
+0800
+1318
+14A4
+24A4
+44A4
+44A4
+8318
 ENDCHAR
-STARTCHAR C082
-ENCODING 8478
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2031
+ENCODING 8241
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 19 13 1 -1
 BITMAP
-FE00
-2100
-2080
-2080
-2100
-3E20
-2340
-2180
-2100
-2300
-F4E0
+608000
+990000
+970000
+920000
+940000
+640000
+080000
+1318C0
+14A520
+24A520
+44A520
+44A520
+8318C0
 ENDCHAR
-STARTCHAR C082
-ENCODING 8479
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 17 1 -3
+STARTCHAR uni2032
+ENCODING 8242
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 4 1 7
 BITMAP
-1800
-0600
-0200
-FE00
-2500
-2480
-2480
-2900
-3E00
-2B00
-2900
-3100
-3100
-F8E0
-1000
-2000
-2000
+20
+60
+40
+80
 ENDCHAR
-STARTCHAR char8480
-ENCODING 8480
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 7 1 4
+STARTCHAR uni2033
+ENCODING 8243
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 4 1 7
 BITMAP
-7618
-9330
-8330
-62D0
-12D0
-9210
-E738
+24
+6C
+48
+90
 ENDCHAR
-STARTCHAR char8480
-ENCODING 8481
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 4
+STARTCHAR uni2034
+ENCODING 8244
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 4 1 7
 BITMAP
-FBEE00
-A92400
-210400
-21C400
-210400
-212480
-73EF80
+2480
+6D80
+4900
+9200
 ENDCHAR
-STARTCHAR char8480
-ENCODING 8482
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 7 1 4
+STARTCHAR uni2035
+ENCODING 8245
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 4 1 7
 BITMAP
-FB0C
-A998
-2198
-2168
-2168
-2108
-739C
+80
+C0
+40
+20
 ENDCHAR
-STARTCHAR C086
-ENCODING 8483
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 17 1 -2
+STARTCHAR uni2036
+ENCODING 8246
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 4 1 7
 BITMAP
-1800
-0600
-0200
-0400
-F5E0
-2480
+90
+D8
+48
+24
+ENDCHAR
+STARTCHAR uni2037
+ENCODING 8247
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 4 1 7
+BITMAP
+9200
+DB00
+4900
 2480
-1900
-1900
-1900
-0A00
-1A00
-1A00
-1400
-1400
-2000
-2000
 ENDCHAR
-STARTCHAR C090
-ENCODING 8484
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
+STARTCHAR uni2038
+ENCODING 8248
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 4 1 -2
 BITMAP
-FE
-CA
-8A
-94
-14
-28
-52
-52
-A2
-A6
-FE
+40
+40
+A0
+A0
 ENDCHAR
-STARTCHAR C053
-ENCODING 8485
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 15 1 -4
+STARTCHAR uni2039
+ENCODING 8249
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 0
 BITMAP
-7C
-08
 10
 20
-7C
-08
-10
+60
+C0
+60
 20
-70
-08
-04
-04
-C4
-88
-70
+10
 ENDCHAR
-STARTCHAR C087
-ENCODING 8486
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni203A
+ENCODING 8250
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 0
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-8080
-4100
-4100
-2200
-A280
-E380
+80
+40
+60
+30
+60
+40
+80
 ENDCHAR
-STARTCHAR C087
-ENCODING 8487
+STARTCHAR uni203B
+ENCODING 8251
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 11 1 0
+BBX 10 13 1 0
 BITMAP
-E380
-A280
-2200
-4100
-4100
-8080
-8080
-8080
-8080
-4100
-3E00
+8040
+4C80
+4C80
+2100
+1200
+1200
+CCC0
+D2C0
+1200
+2100
+4C80
+4C80
+8040
 ENDCHAR
-STARTCHAR C119
-ENCODING 8488
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
+STARTCHAR uni203C
+ENCODING 8252
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 12 1 0
 BITMAP
-78
-84
-02
-22
-44
-38
-44
-02
-02
-64
-98
+D8
+D8
+D8
+D8
+D8
+D8
+D8
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR C105
-ENCODING 8489
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 7 1 0
+STARTCHAR uni203D
+ENCODING 8253
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
 BITMAP
-40
-A0
-20
-20
-20
+78
+84
+A4
+24
+28
 30
 20
+60
+60
+00
+60
+60
 ENDCHAR
-STARTCHAR C075
-ENCODING 8490
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni203E
+ENCODING 8254
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 1 0 12
 BITMAP
-F9E0
-2180
-2300
-2600
-2C00
-2E00
-3200
-2100
-2100
-2080
-F9E0
+FFC0
 ENDCHAR
-STARTCHAR C065
-ENCODING 8491
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 15 1 0
+STARTCHAR uni203F
+ENCODING 8255
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 3 1 0
 BITMAP
-0600
-0900
-0900
-0600
-0400
-0400
-0A00
-0A00
-0A00
-1100
-1100
-1F00
-2080
-2080
-F1E0
+8020
+4040
+3F80
 ENDCHAR
-STARTCHAR C036
-ENCODING 8492
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2040
+ENCODING 8256
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 3 1 12
 BITMAP
-01C0
-0620
-0A20
-1440
-2480
-4BC0
-4C20
-8820
-9020
-9840
-6780
+3F80
+4040
+8020
 ENDCHAR
-STARTCHAR C067
-ENCODING 8493
+STARTCHAR uni2041
+ENCODING 8257
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 8 1 -4
+BITMAP
+10
+10
+20
+20
+40
+60
+90
+90
+ENDCHAR
+STARTCHAR uni2042
+ENCODING 8258
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 11 1 0
+BBX 11 10 1 1
 BITMAP
-1F40
-3180
-6300
-C180
-C080
-C180
-C300
-C000
-6040
-3080
-1F00
+0400
+1500
+0E00
+1500
+0400
+2080
+AAA0
+71C0
+AAA0
+2080
 ENDCHAR
-STARTCHAR C101
-ENCODING 8494
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 0
+STARTCHAR uni2043
+ENCODING 8259
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 2 1 3
 BITMAP
-38
-44
-C6
-C6
-FE
-C0
-C0
-46
-3C
+F0
+F0
 ENDCHAR
-STARTCHAR C101
-ENCODING 8495
+STARTCHAR uni2044
+ENCODING 8260
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 7 1 0
+BBX 8 16 1 -4
 BITMAP
-1C
-22
-4C
-70
+01
+01
+02
+02
+04
+04
+08
+08
+10
+10
+20
+20
+40
+40
 80
-88
-70
+80
 ENDCHAR
-STARTCHAR char8497
-ENCODING 8496
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2045
+ENCODING 8261
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 16 1 -4
 BITMAP
-0700
-0880
-1080
-1100
-1000
-3C00
-4000
-8F00
-9080
-8100
-7E00
+E0
+80
+80
+80
+80
+80
+80
+E0
+80
+80
+80
+80
+80
+80
+80
+E0
 ENDCHAR
-STARTCHAR C036
-ENCODING 8497
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2046
+ENCODING 8262
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 16 0 -4
 BITMAP
-1880
-2700
-3100
-0200
-7F80
-0400
-0400
-7C00
-8C00
-9200
-6200
+E0
+20
+20
+20
+20
+20
+20
+E0
+20
+20
+20
+20
+20
+20
+20
+E0
 ENDCHAR
-STARTCHAR C070
-ENCODING 8498
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2048
+ENCODING 8264
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 12 1 0
 BITMAP
-0F80
-0200
-0200
-2200
-2200
-3E00
-2200
-A200
-8200
-8200
-FF80
+7180
+8980
+8980
+1180
+2180
+2180
+6180
+0000
+0000
+0000
+6180
+6180
 ENDCHAR
-STARTCHAR char8499
-ENCODING 8499
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 16 11 1 0
+STARTCHAR uni2049
+ENCODING 8265
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 12 1 0
 BITMAP
-00C6
-00C6
-014A
-014A
-0294
-0294
-04A4
-64A4
-8948
-8949
-7086
+C700
+C880
+C880
+C100
+C200
+C200
+C600
+0000
+0000
+0000
+C600
+C600
 ENDCHAR
-STARTCHAR C111
-ENCODING 8500
-SWIDTH 420 0
-DWIDTH 7 0
+STARTCHAR uni204A
+ENCODING 8266
+SWIDTH 360 0
+DWIDTH 6 0
 BBX 5 7 1 0
 BITMAP
-30
-48
-88
-88
-88
-90
-60
+80
+F8
+08
+10
+20
+40
+80
 ENDCHAR
-STARTCHAR 00E0
-ENCODING 8501
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 11 1 0
+STARTCHAR uni204B
+ENCODING 8267
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 15 1 -4
 BITMAP
-4100
-4100
-6180
-30C0
-1940
-2E40
-4600
-4300
-4180
-6080
-C080
+F8
+5C
+5E
+5E
+5E
+5C
+58
+50
+50
+50
+50
+50
+50
+50
+50
 ENDCHAR
-STARTCHAR 00E1
-ENCODING 8502
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni204C
+ENCODING 8268
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 7 1 2
 BITMAP
-4000
-FC00
-7E00
-0600
-0200
-0200
-0200
-0200
-0200
-7F80
-FF00
+3C
+74
+F4
+F4
+F4
+74
+3C
 ENDCHAR
-STARTCHAR 00E2
-ENCODING 8503
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR uni204D
+ENCODING 8269
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 7 1 2
 BITMAP
-40
 F0
-78
-08
-08
-08
-08
-78
-C8
-8C
-88
+B8
+BC
+BC
+BC
+B8
+F0
 ENDCHAR
-STARTCHAR 00E3
-ENCODING 8504
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
+STARTCHAR uni2070
+ENCODING 8304
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 6
 BITMAP
-40
-FE
-7F
-04
-04
-04
-04
-04
-04
-04
-04
+60
+90
+90
+90
+90
+90
+60
 ENDCHAR
-STARTCHAR 0x2170
-ENCODING 8505
+STARTCHAR uni2074
+ENCODING 8308
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 4 11 2 0
+BBX 5 7 1 6
+BITMAP
+10
+30
+50
+90
+F8
+10
+38
+ENDCHAR
+STARTCHAR uni2075
+ENCODING 8309
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 6
 BITMAP
+F0
+80
+A0
+D0
+10
+90
 60
+ENDCHAR
+STARTCHAR uni2076
+ENCODING 8310
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 6
+BITMAP
 60
-00
-E0
+90
+80
 E0
+90
+90
+60
+ENDCHAR
+STARTCHAR uni2077
+ENCODING 8311
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 6
+BITMAP
+F0
+90
+20
+20
+40
+40
+40
+ENDCHAR
+STARTCHAR uni2078
+ENCODING 8312
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 6
+BITMAP
 60
+90
+90
 60
+90
+90
 60
+ENDCHAR
+STARTCHAR uni2079
+ENCODING 8313
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 6
+BITMAP
 60
+90
+90
+70
+10
+90
 60
-F0
 ENDCHAR
-STARTCHAR C081
-ENCODING 8506
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 10 1 0
+STARTCHAR uni207A
+ENCODING 8314
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 7
 BITMAP
-1F08
-2084
-4044
-8078
-80A0
-80A0
-80E0
-4040
-2080
-1F00
+20
+20
+F8
+20
+20
 ENDCHAR
-STARTCHAR char185
-ENCODING 8531
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 0
+STARTCHAR uni207B
+ENCODING 8315
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 1 1 9
 BITMAP
-4200
-C200
-4200
-4400
-4400
-44C0
-E920
-0820
-0840
-1020
-1120
-10C0
+F8
 ENDCHAR
-STARTCHAR char185
-ENCODING 8532
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 12 1 0
+STARTCHAR uni207C
+ENCODING 8316
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 3 1 8
 BITMAP
-6100
-9100
-1100
-1200
-2200
-4260
-F490
-0410
-0420
-0810
-0890
-0860
+F8
+00
+F8
 ENDCHAR
-STARTCHAR char185
-ENCODING 8533
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 0
+STARTCHAR uni207D
+ENCODING 8317
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 7 1 6
 BITMAP
-4200
-C200
-4200
-4400
-4400
-45E0
-E900
-0940
-09A0
-1020
-1120
-10C0
+40
+80
+80
+80
+80
+80
+40
 ENDCHAR
-STARTCHAR char185
-ENCODING 8534
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 12 1 0
+STARTCHAR uni207E
+ENCODING 8318
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 7 1 6
 BITMAP
-6100
-9100
-1100
-1200
-2200
-42F0
-F480
-04A0
-04D0
-0810
-0890
-0860
+80
+40
+40
+40
+40
+40
+80
 ENDCHAR
-STARTCHAR char185
-ENCODING 8535
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 12 1 0
+STARTCHAR uni207F
+ENCODING 8319
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 1 6
 BITMAP
-6100
-9100
-1100
-2200
-1200
-92F0
-6480
-04A0
-04D0
-0810
-0890
-0860
+D0
+68
+48
+48
+48
 ENDCHAR
-STARTCHAR char185
-ENCODING 8536
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 12 1 0
+STARTCHAR uni2080
+ENCODING 8320
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
 BITMAP
-1080
-3080
-5080
-9100
-F900
-1178
-3A40
-0250
-0268
-0408
-0448
-0430
+60
+90
+90
+90
+90
+90
+60
 ENDCHAR
-STARTCHAR char185
-ENCODING 8537
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 0
+STARTCHAR uni2081
+ENCODING 8321
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 7 1 -4
 BITMAP
-4200
-C200
-4200
-4400
-4400
-44C0
-E920
-0900
-09C0
-1120
-1120
-10C0
+40
+C0
+40
+40
+40
+40
+E0
 ENDCHAR
-STARTCHAR char185
-ENCODING 8538
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 12 1 0
+STARTCHAR uni2082
+ENCODING 8322
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
 BITMAP
-F100
-8100
-A100
-D200
-1200
-9260
-6490
-0480
-04E0
-0890
-0890
-0860
+60
+90
+10
+10
+20
+40
+F0
 ENDCHAR
-STARTCHAR char185
-ENCODING 8539
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 0
+STARTCHAR uni2083
+ENCODING 8323
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
 BITMAP
-4200
-C200
-4200
-4400
-4400
-44C0
-E920
-0920
-08C0
-1120
-1120
-10C0
+60
+90
+10
+20
+10
+90
+60
 ENDCHAR
-STARTCHAR char185
-ENCODING 8540
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 12 1 0
+STARTCHAR uni2084
+ENCODING 8324
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 7 1 -4
 BITMAP
-6100
-9100
-1100
-2200
-1200
-9260
-6490
-0490
-0460
-0890
-0890
-0860
+10
+30
+50
+90
+F8
+10
+38
 ENDCHAR
-STARTCHAR char185
-ENCODING 8541
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 12 1 0
+STARTCHAR uni2085
+ENCODING 8325
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
 BITMAP
-F100
-8100
-A100
-D200
-1200
-9260
-6490
-0490
-0460
-0890
-0890
-0860
+F0
+80
+A0
+D0
+10
+90
+60
 ENDCHAR
-STARTCHAR char185
-ENCODING 8542
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 0
+STARTCHAR uni2086
+ENCODING 8326
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
 BITMAP
-F200
-9200
-2200
-2400
-4400
-44C0
-4920
-0920
-08C0
-1120
-1120
-10C0
+60
+90
+80
+E0
+90
+90
+60
 ENDCHAR
-STARTCHAR char185
-ENCODING 8543
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni2087
+ENCODING 8327
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
 BITMAP
-42
-C2
-42
-44
-44
-44
-E8
-08
-08
-10
-10
+F0
+90
+20
+20
+40
+40
+40
+ENDCHAR
+STARTCHAR uni2088
+ENCODING 8328
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
+BITMAP
+60
+90
+90
+60
+90
+90
+60
+ENDCHAR
+STARTCHAR uni2089
+ENCODING 8329
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 7 1 -4
+BITMAP
+60
+90
+90
+70
 10
+90
+60
 ENDCHAR
-STARTCHAR C073
-ENCODING 8544
+STARTCHAR uni208A
+ENCODING 8330
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 11 1 0
+BBX 5 5 1 -3
 BITMAP
-F8
-20
-20
-20
 20
 20
-20
-20
+F8
 20
 20
+ENDCHAR
+STARTCHAR uni208B
+ENCODING 8331
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 1 1 -1
+BITMAP
 F8
 ENDCHAR
-STARTCHAR C073
-ENCODING 8545
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni208C
+ENCODING 8332
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 3 1 -2
 BITMAP
-FF
-24
-24
-24
-24
-24
-24
-24
-24
-24
-FF
+F8
+00
+F8
 ENDCHAR
-STARTCHAR C073
-ENCODING 8546
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni208D
+ENCODING 8333
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 7 1 -4
 BITMAP
-FFE0
-2480
-2480
-2480
-2480
-2480
-2480
-2480
-2480
-2480
-FFE0
+40
+80
+80
+80
+80
+80
+40
 ENDCHAR
-STARTCHAR C086
-ENCODING 8547
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 11 1 0
+STARTCHAR uni208E
+ENCODING 8334
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 7 1 -4
 BITMAP
-FF8F
-2104
-2104
-2088
-2088
-2088
-2050
-2050
-2050
-2020
-F820
+80
+40
+40
+40
+40
+40
+80
 ENDCHAR
-STARTCHAR C086
-ENCODING 8548
+STARTCHAR uni20A0
+ENCODING 8352
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 8 12 2 0
+BITMAP
+34
+4C
+84
+80
+9F
+89
+48
+3E
+08
+08
+09
+1F
+ENDCHAR
+STARTCHAR uni20A1
+ENCODING 8353
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
+BBX 9 16 2 -2
 BITMAP
-F1E0
-2080
-2080
-1100
-1100
-1100
-0A00
-0A00
+0500
+0500
 0A00
-0400
-0400
+1E80
+2B80
+4A80
+9480
+9400
+9400
+9400
+A880
+6880
+2900
+3E00
+5000
+5000
 ENDCHAR
-STARTCHAR C086
-ENCODING 8549
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 11 1 0
+STARTCHAR uni20A2
+ENCODING 8354
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 11 2 0
 BITMAP
-F1FF
-2084
-2084
-1104
-1104
-1104
-0A04
-0A04
-0A04
-0404
-041F
+1E80
+2180
+4080
+8080
+9A00
+8D00
+8800
+8880
+4880
+2900
+1E00
 ENDCHAR
-STARTCHAR C086
-ENCODING 8550
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 11 1 0
+STARTCHAR uni20A3
+ENCODING 8355
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 0 0
 BITMAP
-F3FF80
-211200
-211200
-121200
-121200
-121200
-121200
-141200
-081200
-081200
-087F80
+FF80
+2080
+2080
+2000
+7C00
+2000
+7C00
+2000
+2000
+2000
+F800
 ENDCHAR
-STARTCHAR C086
-ENCODING 8551
-SWIDTH 1260 0
-DWIDTH 21 0
-BBX 20 11 1 0
+STARTCHAR uni20A4
+ENCODING 8356
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 8 12 2 0
 BITMAP
-F3FFF0
-211240
-211240
-121240
-121240
-121240
-121240
-141240
-081240
-081240
-087FF0
+06
+09
+11
+10
+7C
+10
+7C
+10
+10
+51
+B2
+CC
 ENDCHAR
-STARTCHAR C088
-ENCODING 8552
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 11 1 0
+STARTCHAR uni20A5
+ENCODING 8357
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 -2
 BITMAP
-FF9E
-2088
-2090
-2050
-2060
-2020
-2050
-20D0
-2088
-2104
-FF8F
+0100
+0100
+FB80
+4640
+4440
+4440
+4C40
+4C40
+FEE0
+1000
+1000
 ENDCHAR
-STARTCHAR C088
-ENCODING 8553
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni20A6
+ENCODING 8358
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 0
 BITMAP
-F3C0
-1100
-1200
-0A00
-0C00
-0400
-0A00
-1A00
-1100
-2080
-F1E0
+E3E0
+3080
+3080
+2880
+FFE0
+2480
+FFE0
+2280
+2180
+2180
+F880
 ENDCHAR
-STARTCHAR C088
-ENCODING 8554
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 11 1 0
+STARTCHAR uni20A7
+ENCODING 8359
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 18 11 2 0
 BITMAP
-F3FE
-1108
-1208
-0A08
-0C08
-0408
-0A08
-1A08
-1108
-2088
-F1FE
+FC0000
+224000
+224000
+224000
+23F3C0
+224440
+3C4400
+204380
+204840
+204C40
+F83780
 ENDCHAR
-STARTCHAR C088
-ENCODING 8555
+STARTCHAR uni20A8
+ENCODING 8360
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 11 2 0
+BITMAP
+FE00
+2100
+2080
+2080
+209E
+2122
+3E20
+231C
+2102
+2122
+F8FC
+ENDCHAR
+STARTCHAR uni20A9
+ENCODING 8361
 SWIDTH 1140 0
 DWIDTH 19 0
-BBX 18 11 1 0
+BBX 16 11 2 0
 BITMAP
-F3FFC0
-110900
-120900
-0A0900
-0C0900
-040900
-0A0900
-1A0900
-110900
-208900
-F1FFC0
+F1CF
+2184
+2184
+2244
+FFFF
+1248
+FFFF
+1428
+0C30
+0C30
+0810
 ENDCHAR
-STARTCHAR C076
-ENCODING 8556
+STARTCHAR uni20AA
+ENCODING 8362
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 10 9 2 0
+BITMAP
+FC00
+8600
+9240
+9240
+9240
+9240
+9040
+10C0
+1F80
+ENDCHAR
+STARTCHAR uni20AB
+ENCODING 8363
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 11 1 0
+BBX 6 14 2 -2
 BITMAP
-F8
-20
-20
-20
-20
-20
-21
-21
-21
-23
-FF
+18
+08
+7C
+08
+08
+78
+48
+88
+88
+88
+48
+7C
+00
+7C
 ENDCHAR
-STARTCHAR C067
-ENCODING 8557
+STARTCHAR uni20AC
+ENCODING 8364
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 0
+BITMAP
+07A0
+0860
+1020
+2020
+FF80
+2000
+FE00
+2020
+1020
+0840
+0780
+ENDCHAR
+STARTCHAR uni20AD
+ENCODING 8365
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 11 1 0
+BBX 8 11 2 0
 BITMAP
-1E80
-2180
-4080
-8080
-8000
-8000
-8000
-8080
-4080
-2100
-1E00
+E7
+42
+44
+48
+50
+FE
+50
+48
+44
+42
+E7
 ENDCHAR
-STARTCHAR C068
-ENCODING 8558
+STARTCHAR uni20AE
+ENCODING 8366
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 2 0
 BITMAP
-FE00
-2180
-2080
-2040
-2040
-2040
-2040
-2040
-2080
-2180
-FE00
+FF80
+8880
+8880
+8A80
+0C00
+1A00
+2C00
+1800
+2800
+0800
+3E00
 ENDCHAR
-STARTCHAR C077
-ENCODING 8559
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 11 1 0
+STARTCHAR uni20AF
+ENCODING 8367
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 2 -3
 BITMAP
-F03C
-3030
-3030
-2850
-2850
-2890
-2490
-2490
-2310
-2310
-FB7C
+0180
+0200
+1F80
+2440
+0420
+0820
+0820
+1020
+1020
+104C
+7052
+B192
+CE2C
+0020
+0040
+0040
 ENDCHAR
-STARTCHAR 0x2170
-ENCODING 8560
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 11 1 0
+STARTCHAR uni20D0
+ENCODING 8400
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 2 0 12
 BITMAP
-C0
-C0
-00
-00
-C0
-40
 40
-40
+FC
+ENDCHAR
+STARTCHAR uni20D1
+ENCODING 8401
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 2 0 12
+BITMAP
+08
+FC
+ENDCHAR
+STARTCHAR uni20D2
+ENCODING 8402
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 1 13 0 -2
+BITMAP
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni20D3
+ENCODING 8403
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 1 7 0 1
+BITMAP
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni20D4
+ENCODING 8404
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 13 5 0 9
+BITMAP
+0780
+1860
+A010
+C008
+E000
+ENDCHAR
+STARTCHAR uni20D5
+ENCODING 8405
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 13 5 0 9
+BITMAP
+0F00
+30C0
+4028
+8018
+0038
+ENDCHAR
+STARTCHAR uni20D6
+ENCODING 8406
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 3 0 11
+BITMAP
 40
+FC
 40
-E0
 ENDCHAR
-STARTCHAR 0x2171
-ENCODING 8561
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 0
+STARTCHAR uni20D7
+ENCODING 8407
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 3 0 11
 BITMAP
-CC
-CC
-00
-00
-CC
-44
-44
-44
-44
-44
-EE
+08
+FC
+08
 ENDCHAR
-STARTCHAR 0x2172
-ENCODING 8562
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni20D8
+ENCODING 8408
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 5 0 4
 BITMAP
-CCC0
-CCC0
-0000
-0000
-CCC0
-4440
-4440
-4440
-4440
-4440
-EEE0
+70
+88
+88
+88
+70
 ENDCHAR
-STARTCHAR 0x2173
-ENCODING 8563
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni20D9
+ENCODING 8409
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 6 0 4
 BITMAP
-C000
-C000
-0000
-0000
-CE70
-4240
-4240
-4240
-4180
-4180
-E180
+04
+78
+98
+A8
+88
+70
 ENDCHAR
-STARTCHAR C118
-ENCODING 8564
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 7 1 0
+STARTCHAR uni20DA
+ENCODING 8410
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 6 0 3
 BITMAP
-E7
-24
-24
-24
-18
-18
-18
+70
+88
+A8
+98
+78
+04
 ENDCHAR
-STARTCHAR 0x2175
-ENCODING 8565
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni20DB
+ENCODING 8411
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 8 2 0 11
 BITMAP
-0060
-0060
-0000
-0000
-E760
-2420
-2420
-2420
-1820
-1820
-1870
+DB
+DB
 ENDCHAR
-STARTCHAR 0x2176
-ENCODING 8566
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 11 1 0
+STARTCHAR uni20DC
+ENCODING 8412
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 11 2 0 11
 BITMAP
-0066
-0066
-0000
-0000
-E766
-2422
-2422
-2422
-1822
-1822
-1877
+DB60
+DB60
 ENDCHAR
-STARTCHAR 0x2177
-ENCODING 8567
-SWIDTH 1260 0
-DWIDTH 21 0
-BBX 20 11 1 0
+STARTCHAR uni20DD
+ENCODING 8413
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 17 17 0 -3
 BITMAP
-006660
-006660
-000000
-000000
-E76660
-242220
-242220
-242220
-182220
-182220
-187770
+07F000
+180C00
+200200
+400100
+400100
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 0x2178
-ENCODING 8568
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni20DE
+ENCODING 8414
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 17 17 0 -3
 BITMAP
-C000
-C000
-0000
-0000
-CE70
-4240
-4180
-4180
-4180
-4240
-EE70
+FFFF80
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+FFFF80
 ENDCHAR
-STARTCHAR C120
-ENCODING 8569
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 7 1 0
+STARTCHAR uni20DF
+ENCODING 8415
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 17 17 0 -3
 BITMAP
-E7
-24
-18
-18
-18
-24
-E7
+008000
+014000
+022000
+041000
+080800
+100400
+200200
+400100
+800080
+400100
+200200
+100400
+080800
+041000
+022000
+014000
+008000
 ENDCHAR
-STARTCHAR 0x217A
-ENCODING 8570
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 11 1 0
+STARTCHAR uni20E0
+ENCODING 8416
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 17 17 0 -3
 BITMAP
-0060
-0060
-0000
-0000
-E760
-2420
-1820
-1820
-1820
-2420
-E770
+07F000
+180C00
+200200
+500100
+480100
+840080
+820080
+810080
+808080
+804080
+802080
+801080
+400900
+400500
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 0x217B
-ENCODING 8571
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 11 1 0
+STARTCHAR uni20E1
+ENCODING 8417
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 3 0 11
 BITMAP
-0066
-0066
-0000
-0000
-E766
-2422
-1822
-1822
-1822
-2422
-E777
+44
+FE
+44
 ENDCHAR
-STARTCHAR C108
-ENCODING 8572
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 12 1 0
+STARTCHAR uni20E2
+ENCODING 8418
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 17 16 1 -1
 BITMAP
-C0
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
-E0
+3FFE00
+400100
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+800080
+400100
+3FFE00
 ENDCHAR
-STARTCHAR C099
-ENCODING 8573
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 7 1 0
+STARTCHAR uni20E3
+ENCODING 8419
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 17 16 1 -1
 BITMAP
-70
-88
-80
-80
-80
-88
-70
+3FFE00
+7FFF00
+DFFD80
+EFFB80
+F00780
+F00780
+F00780
+F00780
+F00780
+F00780
+F00780
+F00780
+EFFB80
+DFFD80
+7FFF00
+3FFE00
 ENDCHAR
-STARTCHAR C100
-ENCODING 8574
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uni2100
+ENCODING 8448
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 1 0
 BITMAP
-18
-08
-08
-08
-08
-78
-88
-88
-88
-88
-88
-7C
+3440
+4840
+8880
+9080
+9500
+6930
+0248
+0280
+0480
+0490
+0060
 ENDCHAR
-STARTCHAR C109
-ENCODING 8575
+STARTCHAR uni2101
+ENCODING 8449
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 1 0
+BITMAP
+3440
+4840
+8880
+9080
+9500
+6938
+0248
+0220
+0410
+0448
+0070
+ENDCHAR
+STARTCHAR uni2102
+ENCODING 8450
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 7 1 0
+BBX 10 11 1 0
 BITMAP
-FB80
-4440
-4440
-4440
-4440
-4440
-EEE0
+1F40
+30C0
+5040
+A040
+A000
+A000
+A000
+A040
+5040
+3080
+1F00
 ENDCHAR
-STARTCHAR C067
-ENCODING 8576
+STARTCHAR uni2103
+ENCODING 8451
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 16 11 1 0
+BBX 15 12 1 0
 BITMAP
-1FF8
-2186
-4082
-8081
-8081
-8081
-8081
-8081
-4082
-2186
-1FF8
+7000
+887A
+8886
+8902
+7202
+0200
+0200
+0200
+0202
+0102
+0084
+0078
 ENDCHAR
-STARTCHAR char8577
-ENCODING 8577
+STARTCHAR uni2104
+ENCODING 8452
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 11 1 0
+BBX 9 11 1 0
 BITMAP
-FE00
-2180
-3880
-2440
-2240
-2240
-2240
-2440
-3880
-2180
-FE00
+7C00
+1000
+3C00
+5200
+9000
+9000
+9000
+5200
+3C00
+1080
+7F00
 ENDCHAR
-STARTCHAR C067
-ENCODING 8578
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 11 1 0
+STARTCHAR uni2105
+ENCODING 8453
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 1 0
 BITMAP
-1FF8
-2186
-43E2
-8491
-8889
-8889
-8889
-8491
-43E2
-2186
-1FF8
+3080
+4880
+8100
+8100
+9200
+6230
+0448
+0488
+0888
+0890
+0060
 ENDCHAR
-STARTCHAR C067
-ENCODING 8579
+STARTCHAR uni2106
+ENCODING 8454
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 11 1 0
+BITMAP
+3080
+4880
+8100
+8100
+9200
+6264
+0424
+0424
+0848
+084A
+0034
+ENDCHAR
+STARTCHAR uni2107
+ENCODING 8455
 SWIDTH 600 0
 DWIDTH 10 0
+BBX 8 11 1 0
+BITMAP
+3D
+43
+81
+81
+40
+38
+40
+80
+81
+41
+3E
+ENDCHAR
+STARTCHAR uni2108
+ENCODING 8456
+SWIDTH 660 0
+DWIDTH 11 0
 BBX 9 11 1 0
 BITMAP
 BC00
@@ -65111,2204 +70890,2288 @@
 8100
 8080
 0080
-0080
+1F80
 0080
 8080
 8100
 4200
 3C00
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8592
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
-BITMAP
-2000
-4000
-FFE0
-4000
-2000
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8593
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
-BITMAP
-20
-70
-A8
-20
-20
-20
-20
-20
-20
-20
-20
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8594
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
+STARTCHAR uni2109
+ENCODING 8457
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 0
 BITMAP
+7000
+8BFE
+8882
+8882
+708A
+0088
+00F8
+0088
+0088
 0080
-0040
-FFE0
-0040
 0080
+03E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8595
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
+STARTCHAR uni210A
+ENCODING 8458
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 -4
 BITMAP
-20
-20
-20
-20
-20
-20
-20
-20
-A8
+18
+24
+44
+44
+48
+38
+1C
 70
-20
+90
+E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8596
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
+STARTCHAR uni210B
+ENCODING 8459
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 11 1 0
 BITMAP
-2080
-4040
-FFE0
-4040
-2080
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8597
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
-BITMAP
-20
-70
-A8
-20
-20
-20
-20
-20
-A8
-70
-20
-ENDCHAR
-STARTCHAR char8598
-ENCODING 8598
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
-BITMAP
-F000
-C000
-A000
-9000
-0800
-0400
-0200
-0100
-0080
-ENDCHAR
-STARTCHAR char8598
-ENCODING 8599
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
-BITMAP
-0780
-0180
-0280
-0480
-0800
-1000
-2000
-4000
-8000
-ENDCHAR
-STARTCHAR char8598
-ENCODING 8600
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
-BITMAP
-8000
-4000
-2000
-1000
-0800
-0480
-0280
-0180
-0780
-ENDCHAR
-STARTCHAR char8598
-ENCODING 8601
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
-BITMAP
-0080
-0100
-0200
-0400
-0800
-9000
-A000
-C000
-F000
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8602
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
-BITMAP
-2080
-4100
-FFE0
-4200
-2400
+0A10
+1610
+0210
+0420
+0420
+1FE0
+2840
+4840
+4840
+9090
+60E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8603
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
+STARTCHAR uni210C
+ENCODING 8460
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 12 1 -1
 BITMAP
-0480
+7038
+D850
+8840
+C840
+4840
+4FC0
 0840
-FFE0
-1040
-2080
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8604
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 4 1 5
-BITMAP
-F000
-C1C0
-A220
-9C10
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8605
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 4 1 5
-BITMAP
-00F0
-3830
-4450
-8390
+0840
+1840
+F058
+6070
+0060
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8606
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
+STARTCHAR uni210D
+ENCODING 8461
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 11 1 0
 BITMAP
-2800
-5000
-FFE0
-5000
-2800
+F9F0
+50A0
+50A0
+50A0
+50A0
+5FA0
+50A0
+50A0
+50A0
+50A0
+F9F0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8607
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
+STARTCHAR uni210E
+ENCODING 8462
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 1 0
 BITMAP
-20
-70
-A8
-70
-A8
-20
-20
-20
-20
+30
+10
+10
 20
 20
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8608
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
-BITMAP
-0280
-0140
-FFE0
-0140
-0280
+38
+44
+44
+44
+88
+8A
+8C
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8609
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
+STARTCHAR uni210F
+ENCODING 8463
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 1 0
 BITMAP
-20
-20
-20
-20
-20
-20
-A8
-70
-A8
-70
-20
+30
+10
+1C
+30
+E0
+38
+44
+44
+44
+88
+8A
+8C
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8610
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
+STARTCHAR uni2110
+ENCODING 8464
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 11 1 0
 BITMAP
-2060
-4180
-FF00
-4180
-2060
+0E
+12
+22
+04
+04
+04
+08
+38
+48
+90
+60
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8611
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 5 1 4
+STARTCHAR uni2111
+ENCODING 8465
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-C080
-3040
-1FE0
-3040
-C080
+7F00
+C200
+8600
+C400
+6600
+2200
+0300
+0180
+4080
+E180
+3F00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8612
+STARTCHAR uni2112
+ENCODING 8466
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 7 1 3
+BBX 10 11 1 0
 BITMAP
-0020
-2020
-4020
-FFE0
-4020
-2020
-0020
+0380
+0440
+0480
+3F00
+0800
+0800
+0800
+1000
+5000
+B100
+CE00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8613
+STARTCHAR uni2113
+ENCODING 8467
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 7 11 1 1
+BBX 6 11 1 0
 BITMAP
 10
+28
+28
+28
+50
+50
+50
+60
+60
+C4
 38
-54
-10
-10
-10
-10
-10
-10
-10
-FE
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8614
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 3
+STARTCHAR uni2114
+ENCODING 8468
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 1 0
 BITMAP
-8000
-8080
-8040
+6600
+2200
 FFE0
-8040
-8080
-8000
+2200
+2200
+23C0
+2220
+2220
+2220
+2220
+2220
+73C0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8615
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
+STARTCHAR uni2115
+ENCODING 8469
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 1 0
 BITMAP
-FE
-10
-10
-10
-10
-10
-10
-10
-54
-38
-10
+F8F8
+2420
+3420
+2A20
+2A20
+2520
+22A0
+22A0
+2160
+2120
+F8E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8616
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
+STARTCHAR uni2116
+ENCODING 8470
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
 BITMAP
-10
-38
-54
-10
-10
-10
-10
-10
-54
-38
-FE
+E3E0
+3080
+3080
+289C
+28A2
+24A2
+22A2
+22A2
+219C
+2180
+F8BE
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8617
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 4
+STARTCHAR uni2117
+ENCODING 8471
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 3
 BITMAP
-01C0
-0020
-2020
-4020
-FFC0
+3E00
+4100
+BC80
+9280
+9280
+9C80
+9080
+B880
+4100
+3E00
+ENDCHAR
+STARTCHAR uni2118
+ENCODING 8472
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 13 1 -4
+BITMAP
 4000
-2000
+8700
+8880
+9080
+9080
+A480
+AC80
+4900
+A600
+A000
+9000
+9000
+6000
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8618
+STARTCHAR uni2119
+ENCODING 8473
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 7 1 4
+BBX 10 11 1 0
 BITMAP
-7000
-8000
-8080
-8040
-7FE0
-0040
-0080
+FF80
+52C0
+5140
+5140
+5140
+52C0
+5F80
+5000
+5000
+5000
+F800
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8619
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 4
+STARTCHAR uni211A
+ENCODING 8474
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 14 1 -3
+BITMAP
+1F00
+3180
+5140
+A0A0
+A0A0
+A0A0
+A0A0
+A0A0
+5540
+3B80
+1F00
+0500
+0520
+03C0
+ENDCHAR
+STARTCHAR uni211B
+ENCODING 8475
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
 01C0
-0220
-2220
-4220
-FFC0
-4200
-2200
+0620
+0A20
+1440
+2480
+4B00
+4A00
+8A00
+9100
+9120
+60C0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8620
+STARTCHAR uni211C
+ENCODING 8476
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 7 1 4
+BBX 10 11 1 0
 BITMAP
-7000
-8800
-8880
+7380
+DCC0
 8840
-7FE0
-0840
-0880
+C8C0
+4880
+4B00
+0B00
+0B00
+1900
+F1C0
+6180
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8621
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 5 1 4
+STARTCHAR uni211D
+ENCODING 8477
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 11 1 0
 BITMAP
-2640
-4920
-E970
-50A0
-2040
+FF00
+5280
+5140
+5140
+5280
+5F00
+5580
+5280
+5280
+5280
+F970
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8622
+STARTCHAR uni211E
+ENCODING 8478
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 12 5 1 4
+BBX 11 11 1 0
 BITMAP
-2140
-4220
-FFF0
-4420
-2840
+FE00
+2100
+2080
+2080
+2100
+3E20
+2340
+2180
+2100
+2300
+F4E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8623
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 11 1 1
+STARTCHAR uni211F
+ENCODING 8479
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 17 1 -3
 BITMAP
-10
-10
-20
-40
-B0
-D0
-20
-A0
-A0
-C0
-F0
+1800
+0600
+0200
+FE00
+2500
+2480
+2480
+2900
+3E00
+2B00
+2900
+3100
+3100
+F8E0
+1000
+2000
+2000
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8624
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 1
+STARTCHAR uni2120
+ENCODING 8480
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 7 1 4
 BITMAP
-20
-40
-FC
-44
-24
-04
-04
-04
-04
-04
-04
+7618
+9330
+8330
+62D0
+12D0
+9210
+E738
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8625
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 1
+STARTCHAR uni2121
+ENCODING 8481
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 7 1 4
 BITMAP
-10
-08
-FC
-88
-90
-80
-80
-80
-80
-80
-80
+FBEE00
+A92400
+210400
+21C400
+210400
+212480
+73EF80
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8626
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 1
+STARTCHAR uni2122
+ENCODING 8482
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 7 1 4
 BITMAP
-04
-04
-04
-04
-04
-04
-24
-44
-FC
-40
-20
+FB0C
+A998
+2198
+2168
+2168
+2108
+739C
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8627
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 1
+STARTCHAR uni2123
+ENCODING 8483
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 17 1 -2
 BITMAP
-80
-80
-80
-80
-80
-80
-90
-88
-FC
-08
-10
+1800
+0600
+0200
+0400
+F5E0
+2480
+2480
+1900
+1900
+1900
+0A00
+1A00
+1A00
+1400
+1400
+2000
+2000
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8628
+STARTCHAR uni2124
+ENCODING 8484
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 6 1 2
+BBX 7 11 1 0
 BITMAP
-FC
-04
-04
-15
-0E
-04
+FE
+CA
+8A
+94
+14
+28
+52
+52
+A2
+A6
+FE
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8629
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 8 1 1
+STARTCHAR uni2125
+ENCODING 8485
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 15 1 -4
 BITMAP
-04
+7C
+08
+10
+20
+7C
+08
+10
+20
+70
+08
 04
 04
-24
-44
-FC
-40
-20
-ENDCHAR
-STARTCHAR char8630
-ENCODING 8630
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 8 1 1
-BITMAP
-0F80
-1040
-2020
-2020
-2020
-A820
-7000
-2000
+C4
+88
+70
 ENDCHAR
-STARTCHAR char8630
-ENCODING 8631
+STARTCHAR uni2126
+ENCODING 8486
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 11 8 1 1
+BBX 9 11 1 0
 BITMAP
 3E00
 4100
 8080
 8080
 8080
-82A0
-01C0
-0080
-ENDCHAR
-STARTCHAR char8598
-ENCODING 8632
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 1
-BITMAP
-FF80
-0000
-F000
-C000
-A000
-9000
-0800
-0400
-0200
-0100
-0080
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8633
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 13 1 0
-BITMAP
-8000
-9000
-A000
-FFF0
-A000
-9000
-8010
-0090
-0050
-FFF0
-0050
-0090
-0010
+8080
+4100
+4100
+2200
+A280
+E380
 ENDCHAR
-STARTCHAR char8630
-ENCODING 8634
+STARTCHAR uni2127
+ENCODING 8487
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 7 1 2
+BBX 9 11 1 0
 BITMAP
-03C0
-4300
-8280
-8280
+E380
+A280
+2200
+4100
+4100
+8080
+8080
+8080
 8080
 4100
 3E00
-ENDCHAR
-STARTCHAR char8630
-ENCODING 8635
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 7 1 2
-BITMAP
-F000
-3080
-5040
-5040
-4040
-2080
-1F00
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8636
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 3 1 6
-BITMAP
-2000
-4000
-FFE0
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8637
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 3 1 6
-BITMAP
-FFE0
-4000
-2000
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8638
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 11 1 1
+STARTCHAR uni2128
+ENCODING 8488
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 11 1 0
 BITMAP
-80
-C0
-A0
-80
-80
-80
-80
-80
-80
-80
-80
+78
+84
+02
+22
+44
+38
+44
+02
+02
+64
+98
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8639
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 11 1 1
+STARTCHAR uni2129
+ENCODING 8489
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 7 1 0
 BITMAP
-20
-60
+40
 A0
 20
 20
 20
-20
-20
-20
-20
+30
 20
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8640
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 3 1 6
+STARTCHAR uni212A
+ENCODING 8490
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-0080
-0040
-FFE0
+F9E0
+2180
+2300
+2600
+2C00
+2E00
+3200
+2100
+2100
+2080
+F9E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8641
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 3 1 6
+STARTCHAR uni212B
+ENCODING 8491
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 15 1 0
 BITMAP
-FFE0
-0040
-0080
+0600
+0900
+0900
+0600
+0400
+0400
+0A00
+0A00
+0A00
+1100
+1100
+1F00
+2080
+2080
+F1E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8642
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 11 1 1
+STARTCHAR uni212C
+ENCODING 8492
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-80
-80
-80
-80
-80
-80
-80
-80
-A0
-C0
-80
+01C0
+0620
+0A20
+1440
+2480
+4BC0
+4C20
+8820
+9020
+9840
+6780
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8643
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 11 1 1
+STARTCHAR uni212D
+ENCODING 8493
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 11 1 0
 BITMAP
-20
-20
-20
-20
-20
-20
-20
-20
-A0
-60
-20
+1F40
+3180
+6300
+C180
+C080
+C180
+C300
+C000
+6040
+3080
+1F00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8644
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni212E
+ENCODING 8494
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 0
 BITMAP
-0080
-0040
-FFE0
-0040
-0080
-0000
-2000
-4000
-FFE0
-4000
-2000
+38
+44
+C6
+C6
+FE
+C0
+C0
+46
+3C
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8645
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni212F
+ENCODING 8495
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 7 1 0
 BITMAP
-2080
-7080
-A880
-2080
-2080
-2080
-2080
-2080
-22A0
-21C0
-2080
+1C
+22
+4C
+70
+80
+88
+70
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8646
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni2130
+ENCODING 8496
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-2000
-4000
-FFE0
+0700
+0880
+1080
+1100
+1000
+3C00
 4000
-2000
-0000
-0080
-0040
-FFE0
-0040
-0080
+8F00
+9080
+8100
+7E00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8647
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni2131
+ENCODING 8497
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-2000
-4000
-FFE0
-4000
-2000
-0000
-2000
-4000
-FFE0
-4000
-2000
+1880
+2700
+3100
+0200
+7F80
+0400
+0400
+7C00
+8C00
+9200
+6200
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8648
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni2132
+ENCODING 8498
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-2080
-71C0
-AAA0
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
+0F80
+0200
+0200
+2200
+2200
+3E00
+2200
+A200
+8200
+8200
+FF80
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8649
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni2133
+ENCODING 8499
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 16 11 1 0
 BITMAP
-0080
-0040
-FFE0
-0040
-0080
-0000
-0080
-0040
-FFE0
-0040
-0080
+00C6
+00C6
+014A
+014A
+0294
+0294
+04A4
+64A4
+8948
+8949
+7086
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8650
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni2134
+ENCODING 8500
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 7 1 0
 BITMAP
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-AAA0
-71C0
-2080
+30
+48
+88
+88
+88
+90
+60
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8651
+STARTCHAR uni2135
+ENCODING 8501
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 8 1 3
+BBX 10 11 1 0
 BITMAP
-2000
-4000
-FFE0
-0000
-0000
-FFE0
-0040
-0080
+4100
+4100
+6180
+30C0
+1940
+2E40
+4600
+4300
+4180
+6080
+C080
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8652
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 8 1 3
+STARTCHAR uni2136
+ENCODING 8502
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-0080
-0040
-FFE0
-0000
-0000
-FFE0
 4000
-2000
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8653
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 3
-BITMAP
-1080
-2080
-7FE0
-8100
-7FE0
-2200
-1200
+FC00
+7E00
+0600
+0200
+0200
+0200
+0200
+0200
+7F80
+FF00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8654
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 7 1 3
+STARTCHAR uni2137
+ENCODING 8503
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
 BITMAP
-1140
-2120
-7FF0
-8208
-7FF0
-2420
-1440
+40
+F0
+78
+08
+08
+08
+08
+78
+C8
+8C
+88
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8655
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 3
+STARTCHAR uni2138
+ENCODING 8504
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 0
 BITMAP
-0900
-0880
-FFC0
-1020
-FFC0
-2080
-2100
+40
+FE
+7F
+04
+04
+04
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8656
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 7 1 3
+STARTCHAR uni2139
+ENCODING 8505
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 11 2 0
 BITMAP
-1000
-2000
-7FE0
-8000
-7FE0
-2000
-1000
+60
+60
+00
+E0
+E0
+60
+60
+60
+60
+60
+F0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8657
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
+STARTCHAR uni213A
+ENCODING 8506
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 10 1 0
 BITMAP
-10
-28
-6C
-AA
-28
-28
-28
-28
-28
-28
-28
+1F08
+2084
+4044
+8078
+80A0
+80A0
+80E0
+4040
+2080
+1F00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8658
+STARTCHAR uni2153
+ENCODING 8531
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 7 1 3
+BBX 11 12 1 0
 BITMAP
-0100
-0080
-FFC0
-0020
-FFC0
-0080
-0100
+4200
+C200
+4200
+4400
+4400
+44C0
+E920
+0820
+0840
+1020
+1120
+10C0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8659
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
+STARTCHAR uni2154
+ENCODING 8532
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 12 1 0
 BITMAP
-28
-28
-28
-28
-28
-28
-28
-AA
-6C
-28
-10
+6100
+9100
+1100
+1200
+2200
+4260
+F490
+0410
+0420
+0810
+0890
+0860
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8660
+STARTCHAR uni2155
+ENCODING 8533
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 12 7 1 3
-BITMAP
-1080
-2040
-7FE0
-8010
-7FE0
-2040
-1080
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8661
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+BBX 11 12 1 0
 BITMAP
-10
-28
-6C
-AA
-28
-28
-28
-28
-AA
-6C
-28
-10
+4200
+C200
+4200
+4400
+4400
+45E0
+E900
+0940
+09A0
+1020
+1120
+10C0
 ENDCHAR
-STARTCHAR char8598
-ENCODING 8662
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 1
+STARTCHAR uni2156
+ENCODING 8534
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 12 1 0
 BITMAP
-F800
-9000
-8800
-C400
-A200
+6100
+9100
 1100
-0880
-0440
-0200
-0100
-ENDCHAR
-STARTCHAR char8598
-ENCODING 8663
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 1
-BITMAP
-07C0
-0240
-0440
-08C0
-1140
+1200
 2200
-4400
-8800
-1000
-2000
+42F0
+F480
+04A0
+04D0
+0810
+0890
+0860
 ENDCHAR
-STARTCHAR char8598
-ENCODING 8664
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 1
+STARTCHAR uni2157
+ENCODING 8535
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 12 1 0
 BITMAP
-2000
-1000
-8800
-4400
+6100
+9100
+1100
 2200
-1140
-08C0
-0440
-0240
-07C0
+1200
+92F0
+6480
+04A0
+04D0
+0810
+0890
+0860
 ENDCHAR
-STARTCHAR char8598
-ENCODING 8665
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 10 1 1
+STARTCHAR uni2158
+ENCODING 8536
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 12 1 0
 BITMAP
-0100
-0200
-0440
-0880
-1100
-A200
-C400
-8800
-9000
-F800
+1080
+3080
+5080
+9100
+F900
+1178
+3A40
+0250
+0268
+0408
+0448
+0430
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8666
+STARTCHAR uni2159
+ENCODING 8537
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 7 1 3
+BBX 11 12 1 0
 BITMAP
-1000
-3FE0
-4000
-FFE0
-4000
-3FE0
-1000
+4200
+C200
+4200
+4400
+4400
+44C0
+E920
+0900
+09C0
+1120
+1120
+10C0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8667
+STARTCHAR uni215A
+ENCODING 8538
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 12 1 0
+BITMAP
+F100
+8100
+A100
+D200
+1200
+9260
+6490
+0480
+04E0
+0890
+0890
+0860
+ENDCHAR
+STARTCHAR uni215B
+ENCODING 8539
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 7 1 3
+BBX 11 12 1 0
 BITMAP
-0100
-FF80
-0040
-FFE0
-0040
-FF80
-0100
+4200
+C200
+4200
+4400
+4400
+44C0
+E920
+0920
+08C0
+1120
+1120
+10C0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8668
+STARTCHAR uni215C
+ENCODING 8540
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 12 5 1 4
+BBX 12 12 1 0
 BITMAP
-2000
-4880
-F550
-4220
-2000
+6100
+9100
+1100
+2200
+1200
+9260
+6490
+0490
+0460
+0890
+0890
+0860
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8669
+STARTCHAR uni215D
+ENCODING 8541
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 12 5 1 4
+BBX 12 12 1 0
 BITMAP
-0040
+F100
+8100
+A100
+D200
+1200
+9260
+6490
+0490
+0460
+0890
+0890
+0860
+ENDCHAR
+STARTCHAR uni215E
+ENCODING 8542
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 12 1 0
+BITMAP
+F200
+9200
+2200
+2400
+4400
+44C0
+4920
+0920
+08C0
 1120
-AAF0
-4420
-0040
+1120
+10C0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8670
+STARTCHAR uni215F
+ENCODING 8543
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 0
+BITMAP
+42
+C2
+42
+44
+44
+44
+E8
+08
+08
+10
+10
+10
+ENDCHAR
+STARTCHAR uni2160
+ENCODING 8544
 SWIDTH 360 0
 DWIDTH 6 0
-BBX 5 11 1 1
+BBX 5 11 1 0
 BITMAP
-20
-70
-A8
-20
-20
-F8
-20
 F8
 20
 20
 20
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8671
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
-BITMAP
-20
 20
 20
-F8
 20
-F8
 20
 20
-A8
-70
 20
+F8
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8672
+STARTCHAR uni2161
+ENCODING 8545
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
+BITMAP
+FF
+24
+24
+24
+24
+24
+24
+24
+24
+24
+FF
+ENDCHAR
+STARTCHAR uni2162
+ENCODING 8546
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 5 1 4
+BBX 11 11 1 0
 BITMAP
-2000
-4000
-EEE0
-4000
-2000
+FFE0
+2480
+2480
+2480
+2480
+2480
+2480
+2480
+2480
+2480
+FFE0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8673
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
+STARTCHAR uni2163
+ENCODING 8547
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
 BITMAP
-20
-70
-A8
-00
-20
-20
-20
-00
-20
-20
-20
+FF8F
+2104
+2104
+2088
+2088
+2088
+2050
+2050
+2050
+2020
+F820
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8674
+STARTCHAR uni2164
+ENCODING 8548
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 5 1 4
+BBX 11 11 1 0
 BITMAP
-0080
-0040
-EEE0
-0040
-0080
+F1E0
+2080
+2080
+1100
+1100
+1100
+0A00
+0A00
+0A00
+0400
+0400
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8675
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 1
+STARTCHAR uni2165
+ENCODING 8549
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
 BITMAP
+F1FF
+2084
+2084
+1104
+1104
+1104
+0A04
+0A04
+0A04
+0404
+041F
+ENDCHAR
+STARTCHAR uni2166
+ENCODING 8550
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 11 1 0
+BITMAP
+F3FF80
+211200
+211200
+121200
+121200
+121200
+121200
+141200
+081200
+081200
+087F80
+ENDCHAR
+STARTCHAR uni2167
+ENCODING 8551
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 11 1 0
+BITMAP
+F3FFF0
+211240
+211240
+121240
+121240
+121240
+121240
+141240
+081240
+081240
+087FF0
+ENDCHAR
+STARTCHAR uni2168
+ENCODING 8552
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
+BITMAP
+FF9E
+2088
+2090
+2050
+2060
+2020
+2050
+20D0
+2088
+2104
+FF8F
+ENDCHAR
+STARTCHAR uni2169
+ENCODING 8553
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
+BITMAP
+F3C0
+1100
+1200
+0A00
+0C00
+0400
+0A00
+1A00
+1100
+2080
+F1E0
+ENDCHAR
+STARTCHAR uni216A
+ENCODING 8554
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 11 1 0
+BITMAP
+F3FE
+1108
+1208
+0A08
+0C08
+0408
+0A08
+1A08
+1108
+2088
+F1FE
+ENDCHAR
+STARTCHAR uni216B
+ENCODING 8555
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 18 11 1 0
+BITMAP
+F3FFC0
+110900
+120900
+0A0900
+0C0900
+040900
+0A0900
+1A0900
+110900
+208900
+F1FFC0
+ENDCHAR
+STARTCHAR uni216C
+ENCODING 8556
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 11 1 0
+BITMAP
+F8
 20
 20
 20
-00
-20
-20
 20
-00
-A8
-70
 20
+21
+21
+21
+23
+FF
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8676
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 7 1 3
+STARTCHAR uni216D
+ENCODING 8557
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
+1E80
+2180
+4080
+8080
 8000
-9000
-A000
-FFF0
-A000
-9000
 8000
+8000
+8080
+4080
+2100
+1E00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8677
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 7 1 3
+STARTCHAR uni216E
+ENCODING 8558
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-0010
-0090
-0050
-FFF0
-0050
-0090
-0010
+FE00
+2180
+2080
+2040
+2040
+2040
+2040
+2040
+2080
+2180
+FE00
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8678
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 9 1 2
+STARTCHAR uni216F
+ENCODING 8559
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 11 1 0
 BITMAP
-0800
-1800
-2FF0
-4010
-8010
-4010
-2FF0
-1800
-0800
-ENDCHAR
-STARTCHAR char8592
-ENCODING 8679
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 1
-BITMAP
-0800
-1400
-2200
-4100
-E380
-2200
-2200
-2200
-2200
-2200
-2200
-3E00
+F03C
+3030
+3030
+2850
+2850
+2890
+2490
+2490
+2310
+2310
+FB7C
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8680
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 9 1 2
+STARTCHAR uni2170
+ENCODING 8560
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 11 1 0
 BITMAP
-0100
-0180
-FF40
-8020
-8010
-8020
-FF40
-0180
-0100
+C0
+C0
+00
+00
+C0
+40
+40
+40
+40
+40
+E0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8681
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 1
+STARTCHAR uni2171
+ENCODING 8561
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 0
 BITMAP
-3E00
-2200
-2200
-2200
-2200
-2200
-2200
-E380
-4100
-2200
-1400
-0800
+CC
+CC
+00
+00
+CC
+44
+44
+44
+44
+44
+EE
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8682
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 0
+STARTCHAR uni2172
+ENCODING 8562
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-0800
-1400
-2200
-4100
-E380
-2200
-2200
-2200
-2200
-2200
-2200
-3E00
+CCC0
+CCC0
 0000
-3E00
-2200
-2200
-3E00
+0000
+CCC0
+4440
+4440
+4440
+4440
+4440
+EEE0
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8683
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 0
+STARTCHAR uni2173
+ENCODING 8563
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-0800
-1400
-2200
-4100
-E380
-2200
-2200
-2200
-2200
-2200
-2200
-E380
-8080
-FF80
+C000
+C000
+0000
+0000
+CE70
+4240
+4240
+4240
+4180
+4180
+E180
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8684
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 0
+STARTCHAR uni2174
+ENCODING 8564
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 7 1 0
 BITMAP
-0800
-1400
-3E00
-4100
-E380
-2200
-2200
-2200
-2200
-2200
-2200
-E380
-8080
-FF80
+E7
+24
+24
+24
+18
+18
+18
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8685
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 0
+STARTCHAR uni2175
+ENCODING 8565
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-0800
-1C00
-2A00
-4900
-EB80
-2A00
-2A00
-2A00
-2A00
-2A00
-2A00
-EB80
-8880
-FF80
+0060
+0060
+0000
+0000
+E760
+2420
+2420
+2420
+1820
+1820
+1870
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8686
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 15 1 2
+STARTCHAR uni2176
+ENCODING 8566
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
 BITMAP
-0800
-1400
-2200
-4900
-D580
-2200
-4100
-E380
-2200
-2200
-2200
-2200
-2200
-2200
-3E00
+0066
+0066
+0000
+0000
+E766
+2422
+2422
+2422
+1822
+1822
+1877
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8687
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 0
+STARTCHAR uni2177
+ENCODING 8567
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 20 11 1 0
 BITMAP
-0800
-1400
-2200
-4900
-D580
-2200
-4100
-E380
-2200
-2200
-2200
-2200
-2200
-2200
-E380
-8080
-FF80
+006660
+006660
+000000
+000000
+E76660
+242220
+242220
+242220
+182220
+182220
+187770
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8688
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 9 2 2
+STARTCHAR uni2178
+ENCODING 8568
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-E040
-A060
-BFD0
-8018
-8014
-8018
-BFD0
-A060
-E040
+C000
+C000
+0000
+0000
+CE70
+4240
+4180
+4180
+4180
+4240
+EE70
 ENDCHAR
-STARTCHAR char8598
-ENCODING 8689
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni2179
+ENCODING 8569
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 7 1 0
 BITMAP
-FFE0
-8000
-BC00
-B000
-A800
-A400
-8200
-8100
-8080
-8040
-8020
+E7
+24
+18
+18
+18
+24
+E7
 ENDCHAR
-STARTCHAR char8598
-ENCODING 8690
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 1
+STARTCHAR uni217A
+ENCODING 8570
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 0
 BITMAP
-8020
-4020
-2020
-1020
-0820
-04A0
-02A0
-01A0
-07A0
-0020
-FFE0
+0060
+0060
+0000
+0000
+E760
+2420
+1820
+1820
+1820
+2420
+E770
 ENDCHAR
-STARTCHAR char8592
-ENCODING 8691
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 16 1 0
+STARTCHAR uni217B
+ENCODING 8571
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
 BITMAP
-0800
-1400
-2200
-4100
-E380
-2200
-2200
-2200
-2200
-2200
-2200
-E380
-4100
-2200
-1400
-0800
+0066
+0066
+0000
+0000
+E766
+2422
+1822
+1822
+1822
+2422
+E777
 ENDCHAR
-STARTCHAR C068
-ENCODING 8704
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni217C
+ENCODING 8572
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 12 1 0
 BITMAP
-8020
-8020
-4040
-4040
-3F80
-2080
-1100
-1100
-0A00
-0A00
-0400
+C0
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+E0
 ENDCHAR
-STARTCHAR C067
-ENCODING 8705
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 11 1 0
+STARTCHAR uni217D
+ENCODING 8573
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 7 1 0
 BITMAP
-78
-84
-84
-80
-80
+70
+88
 80
 80
 80
-84
-84
-78
+88
+70
 ENDCHAR
-STARTCHAR C100
-ENCODING 8706
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 0
+STARTCHAR uni217E
+ENCODING 8574
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
 BITMAP
-60
-10
-10
+18
 08
-38
-48
+08
+08
+08
+78
 88
 88
 88
-90
-60
+88
+88
+7C
 ENDCHAR
-STARTCHAR C069
-ENCODING 8707
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni217F
+ENCODING 8575
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 0
 BITMAP
-FF
-01
-01
-01
-01
-FF
-01
-01
-01
-01
-FF
+FB80
+4440
+4440
+4440
+4440
+4440
+EEE0
 ENDCHAR
-STARTCHAR C069
-ENCODING 8708
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 -2
+STARTCHAR uni2180
+ENCODING 8576
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
 BITMAP
-02
-02
-FF
-05
-05
-05
-09
-FF
-09
-09
-11
-11
-FF
-20
-20
+1FF8
+2186
+4082
+8081
+8081
+8081
+8081
+8081
+4082
+2186
+1FF8
 ENDCHAR
-STARTCHAR C079
-ENCODING 8709
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
+STARTCHAR uni2181
+ENCODING 8577
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 0
 BITMAP
-1F20
-20C0
-40C0
-8120
-8220
-8420
-8820
-9020
-6040
-6080
-9F00
+FE00
+2180
+3880
+2440
+2240
+2240
+2240
+2440
+3880
+2180
+FE00
 ENDCHAR
-STARTCHAR C068
-ENCODING 8710
+STARTCHAR uni2182
+ENCODING 8578
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 11 1 0
+BITMAP
+1FF8
+2186
+43E2
+8491
+8889
+8889
+8889
+8491
+43E2
+2186
+1FF8
+ENDCHAR
+STARTCHAR uni2183
+ENCODING 8579
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
+BITMAP
+BC00
+C200
+8100
+8080
+0080
+0080
+0080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni2190
+ENCODING 8592
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
+BBX 11 5 1 4
 BITMAP
-0400
-0E00
-0E00
-1300
-1300
-2180
-2180
-40C0
-40C0
-8060
+2000
+4000
 FFE0
+4000
+2000
 ENDCHAR
-STARTCHAR C068
-ENCODING 8711
+STARTCHAR uni2191
+ENCODING 8593
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
+BITMAP
+20
+70
+A8
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni2192
+ENCODING 8594
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
+BBX 11 5 1 4
 BITMAP
+0080
+0040
 FFE0
-8060
-40C0
-40C0
-2180
-2180
-1300
-1300
-0E00
-0E00
-0400
+0040
+0080
 ENDCHAR
-STARTCHAR C069
-ENCODING 8712
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni2193
+ENCODING 8595
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
 BITMAP
-1F
 20
-40
-80
-80
-FF
-80
-80
-40
 20
-1F
+20
+20
+20
+20
+20
+20
+A8
+70
+20
 ENDCHAR
-STARTCHAR C069
-ENCODING 8713
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 -2
+STARTCHAR uni2194
+ENCODING 8596
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 5 1 4
 BITMAP
-02
-02
-1F
-24
-44
-84
-88
-FF
-88
-88
-50
-30
-1F
+2080
+4040
+FFE0
+4040
+2080
+ENDCHAR
+STARTCHAR uni2195
+ENCODING 8597
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
+BITMAP
+20
+70
+A8
+20
+20
 20
 20
+20
+A8
+70
+20
 ENDCHAR
-STARTCHAR C069
-ENCODING 8714
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni2196
+ENCODING 8598
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 1
 BITMAP
-3E
-40
-80
-FE
-80
-40
-3E
+F000
+C000
+A000
+9000
+0800
+0400
+0200
+0100
+0080
 ENDCHAR
-STARTCHAR C069
-ENCODING 8715
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 11 1 0
+STARTCHAR uni2197
+ENCODING 8599
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 1
 BITMAP
-F8
-04
-02
-01
-01
-FF
-01
-01
-02
-04
-F8
+0780
+0180
+0280
+0480
+0800
+1000
+2000
+4000
+8000
 ENDCHAR
-STARTCHAR C069
-ENCODING 8716
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 -2
+STARTCHAR uni2198
+ENCODING 8600
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 1
 BITMAP
-40
-40
-F8
-24
-22
-21
-11
-FF
-11
-11
-0A
-0C
-F8
-04
-04
+8000
+4000
+2000
+1000
+0800
+0480
+0280
+0180
+0780
 ENDCHAR
-STARTCHAR C069
-ENCODING 8717
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni2199
+ENCODING 8601
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 1
 BITMAP
-F8
-04
-02
-FE
-02
-04
-F8
+0080
+0100
+0200
+0400
+0800
+9000
+A000
+C000
+F000
 ENDCHAR
-STARTCHAR char9632
-ENCODING 8718
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 9 1 1
+STARTCHAR uni219A
+ENCODING 8602
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 5 1 4
 BITMAP
-F8
-F8
-F8
-F8
-F8
-F8
-F8
-F8
-F8
+2080
+4100
+FFE0
+4200
+2400
 ENDCHAR
-STARTCHAR C080
-ENCODING 8719
+STARTCHAR uni219B
+ENCODING 8603
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 0 0
+BBX 11 5 1 4
 BITMAP
+0480
+0840
 FFE0
+1040
 2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-FBE0
 ENDCHAR
-STARTCHAR C080
-ENCODING 8720
+STARTCHAR uni219C
+ENCODING 8604
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 4 1 5
+BITMAP
+F000
+C1C0
+A220
+9C10
+ENDCHAR
+STARTCHAR uni219D
+ENCODING 8605
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 4 1 5
+BITMAP
+00F0
+3830
+4450
+8390
+ENDCHAR
+STARTCHAR uni219E
+ENCODING 8606
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 0 0
+BBX 11 5 1 4
 BITMAP
-FBE0
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2080
+2800
+5000
 FFE0
+5000
+2800
 ENDCHAR
-STARTCHAR C083
-ENCODING 8721
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni219F
+ENCODING 8607
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
 BITMAP
-FF80
+20
+70
+A8
+70
+A8
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni21A0
+ENCODING 8608
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 5 1 4
+BITMAP
+0280
+0140
+FFE0
+0140
+0280
+ENDCHAR
+STARTCHAR uni21A1
+ENCODING 8609
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
+BITMAP
+20
+20
+20
+20
+20
+20
+A8
+70
+A8
+70
+20
+ENDCHAR
+STARTCHAR uni21A2
+ENCODING 8610
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 5 1 4
+BITMAP
+2060
 4180
-2080
-2080
-1000
-1800
-1000
-2080
-2080
+FF00
 4180
-FF80
+2060
 ENDCHAR
-STARTCHAR C043
-ENCODING 8722
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 1 1 5
+STARTCHAR uni21A3
+ENCODING 8611
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 5 1 4
 BITMAP
-FE
+C080
+3040
+1FE0
+3040
+C080
 ENDCHAR
-STARTCHAR char177
-ENCODING 8723
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 1
+STARTCHAR uni21A4
+ENCODING 8612
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 3
 BITMAP
-FE
-00
+0020
+2020
+4020
+FFE0
+4020
+2020
+0020
+ENDCHAR
+STARTCHAR uni21A5
+ENCODING 8613
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 1
+BITMAP
+10
+38
+54
 10
 10
 10
-FE
 10
 10
 10
+10
+FE
 ENDCHAR
-STARTCHAR char177
-ENCODING 8724
-SWIDTH 540 0
-DWIDTH 9 0
+STARTCHAR uni21A6
+ENCODING 8614
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 3
+BITMAP
+8000
+8080
+8040
+FFE0
+8040
+8080
+8000
+ENDCHAR
+STARTCHAR uni21A7
+ENCODING 8615
+SWIDTH 480 0
+DWIDTH 8 0
 BBX 7 11 1 1
 BITMAP
+FE
 10
-38
 10
-00
 10
 10
 10
-FE
 10
 10
+54
+38
 10
 ENDCHAR
-STARTCHAR C047
-ENCODING 8725
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 16 1 -4
+STARTCHAR uni21A8
+ENCODING 8616
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 1
 BITMAP
-01
-01
-02
-02
-04
-04
-08
-08
 10
+38
+54
 10
-20
-20
-40
-40
-80
-80
-ENDCHAR
-STARTCHAR C047
-ENCODING 8726
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
-BITMAP
-80
-80
-40
-40
-20
-20
 10
 10
-08
-08
-04
-04
-ENDCHAR
-STARTCHAR C042
-ENCODING 8727
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 7 1 2
-BITMAP
 10
-92
+10
 54
 38
-54
-92
-10
-ENDCHAR
-STARTCHAR C023
-ENCODING 8728
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 4 1 4
-BITMAP
-60
-90
-90
-60
+FE
 ENDCHAR
-STARTCHAR C023
-ENCODING 8729
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 4 1 4
+STARTCHAR uni21A9
+ENCODING 8617
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 4
 BITMAP
-60
-F0
-F0
-60
+01C0
+0020
+2020
+4020
+FFC0
+4000
+2000
 ENDCHAR
-STARTCHAR C068
-ENCODING 8730
+STARTCHAR uni21AA
+ENCODING 8618
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 11 1 0
+BBX 11 7 1 4
 BITMAP
-0020
-0020
-0040
+7000
+8000
+8080
+8040
+7FE0
 0040
-F080
-3080
-1900
-1900
-0E00
-0E00
-0400
+0080
 ENDCHAR
-STARTCHAR C068
-ENCODING 8731
+STARTCHAR uni21AB
+ENCODING 8619
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 1 0
+BBX 11 7 1 4
 BITMAP
-0600
-0900
-0100
+01C0
 0220
-0120
-0940
-0640
-F080
-3080
-1900
-1900
-0E00
-0E00
-0400
+2220
+4220
+FFC0
+4200
+2200
 ENDCHAR
-STARTCHAR C068
-ENCODING 8732
+STARTCHAR uni21AC
+ENCODING 8620
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 11 14 1 0
-BITMAP
-0200
-0600
-0A00
-1220
-1F20
-0240
-0740
-F080
-3080
-1900
-1900
-0E00
-0E00
-0400
-ENDCHAR
-STARTCHAR char8733
-ENCODING 8733
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 5 1 3
+BBX 11 7 1 4
 BITMAP
-7180
-8A00
-8400
-8A00
-7180
+7000
+8800
+8880
+8840
+7FE0
+0840
+0880
 ENDCHAR
-STARTCHAR char8733
-ENCODING 8734
+STARTCHAR uni21AD
+ENCODING 8621
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 5 1 3
+BBX 12 5 1 4
 BITMAP
-71C0
-8A20
-8420
-8A20
-71C0
+2640
+4920
+E970
+50A0
+2040
 ENDCHAR
-STARTCHAR char8735
-ENCODING 8735
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 7 1 2
+STARTCHAR uni21AE
+ENCODING 8622
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 5 1 4
 BITMAP
-80
-80
-80
-80
-80
-80
-FE
+2140
+4220
+FFF0
+4420
+2840
 ENDCHAR
-STARTCHAR char8735
-ENCODING 8736
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 7 1 2
+STARTCHAR uni21AF
+ENCODING 8623
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 11 1 1
 BITMAP
-04
-08
+10
 10
 20
 40
-80
-FE
+B0
+D0
+20
+A0
+A0
+C0
+F0
 ENDCHAR
-STARTCHAR char8735
-ENCODING 8737
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 9 1 0
+STARTCHAR uni21B0
+ENCODING 8624
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 1
 BITMAP
-04
-68
-10
-28
+20
+40
+FC
 44
-84
-FF
+24
+04
+04
+04
 04
 04
+04
 ENDCHAR
-STARTCHAR char8735
-ENCODING 8738
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 1
+STARTCHAR uni21B1
+ENCODING 8625
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 1
 BITMAP
-20
-16
-18
-68
+10
+08
+FC
 88
-68
-18
-16
-20
-ENDCHAR
-STARTCHAR char123
-ENCODING 8739
-SWIDTH 180 0
-DWIDTH 3 0
-BBX 1 12 1 0
-BITMAP
-80
-80
-80
-80
-80
-80
+90
 80
 80
 80
@@ -67316,3144 +73179,2820 @@
 80
 80
 ENDCHAR
-STARTCHAR char123
-ENCODING 8740
+STARTCHAR uni21B2
+ENCODING 8626
 SWIDTH 420 0
 DWIDTH 7 0
-BBX 5 12 1 0
+BBX 6 11 1 1
 BITMAP
+04
+04
+04
+04
+04
+04
+24
+44
+FC
+40
 20
-20
-20
-28
-30
-20
-60
-A0
-20
-20
-20
-20
-ENDCHAR
-STARTCHAR char123
-ENCODING 8741
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 3 12 1 0
-BITMAP
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-ENDCHAR
-STARTCHAR char123
-ENCODING 8742
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 12 1 0
-BITMAP
-28
-28
-2A
-2C
-28
-38
-28
-68
-A8
-28
-28
-28
-ENDCHAR
-STARTCHAR C068
-ENCODING 8743
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
-BITMAP
-0400
-0A00
-0A00
-1100
-1100
-2080
-2080
-4040
-4040
-8020
-8020
-ENDCHAR
-STARTCHAR C068
-ENCODING 8744
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 0
-BITMAP
-8020
-8020
-4040
-4040
-2080
-2080
-1100
-1100
-0A00
-0A00
-0400
-ENDCHAR
-STARTCHAR C060
-ENCODING 8745
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
-BITMAP
-3C
-42
-81
-81
-81
-81
-81
-81
-81
-81
-81
-ENDCHAR
-STARTCHAR C060
-ENCODING 8746
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
-BITMAP
-81
-81
-81
-81
-81
-81
-81
-81
-81
-42
-3C
 ENDCHAR
-STARTCHAR char8747
-ENCODING 8747
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 19 1 -4
+STARTCHAR uni21B3
+ENCODING 8627
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 1
 BITMAP
-0E
-12
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
+80
+80
+80
+80
+80
+80
 90
-E0
-ENDCHAR
-STARTCHAR char8747
-ENCODING 8748
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 12 19 1 -4
-BITMAP
-0E70
-1290
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-1080
-9480
-E700
-ENDCHAR
-STARTCHAR char8747
-ENCODING 8749
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 19 1 -4
-BITMAP
-0E7380
-129480
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-108400
-94A400
-E73800
+88
+FC
+08
+10
 ENDCHAR
-STARTCHAR char8747
-ENCODING 8750
+STARTCHAR uni21B4
+ENCODING 8628
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 19 1 -4
+BBX 8 6 1 2
 BITMAP
+FC
+04
+04
+15
 0E
-12
-10
-10
-10
-10
-38
-54
-92
-92
-92
-54
-38
-10
-10
-10
-10
-90
-E0
-ENDCHAR
-STARTCHAR char8747
-ENCODING 8751
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 19 1 -4
-BITMAP
-0E70
-1290
-1080
-1080
-1080
-1080
-3FC0
-50A0
-9090
-9090
-9090
-50A0
-3FC0
-1080
-1080
-1080
-1080
-9480
-E700
+04
 ENDCHAR
-STARTCHAR char8747
-ENCODING 8752
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 19 1 -4
+STARTCHAR uni21B5
+ENCODING 8629
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 8 1 1
 BITMAP
-0E7380
-129480
-108400
-108400
-108400
-108400
-3FFE00
-508500
-908480
-908480
-908480
-508500
-3FFE00
-108400
-108400
-108400
-108400
-94A400
-E73800
+04
+04
+04
+24
+44
+FC
+40
+20
 ENDCHAR
-STARTCHAR char8747
-ENCODING 8753
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 19 1 -4
+STARTCHAR uni21B6
+ENCODING 8630
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 8 1 1
 BITMAP
-0E
-12
-10
-10
-10
-10
-10
-7D
-93
-17
-10
-10
-10
-10
-10
-10
-10
-90
-E0
+0F80
+1040
+2020
+2020
+2020
+A820
+7000
+2000
 ENDCHAR
-STARTCHAR char8747
-ENCODING 8754
+STARTCHAR uni21B7
+ENCODING 8631
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 19 1 -4
+BBX 11 8 1 1
 BITMAP
-0700
-0900
-0800
-0800
-0800
-0800
-3E80
-4980
-8B80
-8880
-8880
-4900
 3E00
-0800
-0800
-0800
-0800
-4800
-7000
+4100
+8080
+8080
+8080
+82A0
+01C0
+0080
 ENDCHAR
-STARTCHAR char8747
-ENCODING 8755
+STARTCHAR uni21B8
+ENCODING 8632
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 19 1 -4
-BITMAP
-0700
-0900
-0800
-0800
-0800
-0800
-3F80
-4B00
-8A80
-8880
-8880
-4900
-3E00
-0800
-0800
-0800
-0800
-4800
-7000
-ENDCHAR
-STARTCHAR char8756
-ENCODING 8756
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 11 1 0
-BITMAP
-0200
-0700
-0200
-0000
-0000
-0000
-0000
-0000
-4010
-E038
-4010
-ENDCHAR
-STARTCHAR char8756
-ENCODING 8757
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 11 1 0
+BBX 9 11 1 1
 BITMAP
-4010
-E038
-4010
-0000
-0000
-0000
-0000
+FF80
 0000
-0200
-0700
+F000
+C000
+A000
+9000
+0800
+0400
 0200
+0100
+0080
 ENDCHAR
-STARTCHAR char8756
-ENCODING 8758
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 3 11 1 0
+STARTCHAR uni21B9
+ENCODING 8633
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 13 1 0
 BITMAP
-40
-E0
-40
-00
-00
-00
-00
-00
-40
-E0
-40
+8000
+9000
+A000
+FFF0
+A000
+9000
+8010
+0090
+0050
+FFF0
+0050
+0090
+0010
 ENDCHAR
-STARTCHAR char8756
-ENCODING 8759
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 11 1 0
+STARTCHAR uni21BA
+ENCODING 8634
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 7 1 2
 BITMAP
-4010
-E038
-4010
-0000
-0000
-0000
-0000
-0000
-4010
-E038
-4010
+03C0
+4300
+8280
+8280
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR C043
-ENCODING 8760
+STARTCHAR uni21BB
+ENCODING 8635
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 5 1 5
+BBX 10 7 1 2
 BITMAP
-0800
-1C00
-0800
-0000
-FF80
+F000
+3080
+5040
+5040
+4040
+2080
+1F00
 ENDCHAR
-STARTCHAR C043
-ENCODING 8761
+STARTCHAR uni21BC
+ENCODING 8636
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 9 1 1
+BBX 11 3 1 6
 BITMAP
-0080
-01C0
-0080
-0000
-FE00
-0000
-0080
-01C0
-0080
+2000
+4000
+FFE0
 ENDCHAR
-STARTCHAR C043
-ENCODING 8762
+STARTCHAR uni21BD
+ENCODING 8637
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 9 1 1
-BITMAP
-4080
-E1C0
-4080
-0000
-FFC0
-0000
-4080
-E1C0
-4080
-ENDCHAR
-STARTCHAR C043
-ENCODING 8763
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 10 10 1 1
+BBX 11 3 1 6
 BITMAP
-0400
-0E00
-0400
-0000
-7840
-8780
-0000
-0400
-0E00
-0400
+FFE0
+4000
+2000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8764
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 2 1 6
+STARTCHAR uni21BE
+ENCODING 8638
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 11 1 1
 BITMAP
-7840
-8780
+80
+C0
+A0
+80
+80
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C043
-ENCODING 8765
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 2 1 6
+STARTCHAR uni21BF
+ENCODING 8639
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 11 1 1
 BITMAP
-8780
-7840
+20
+60
+A0
+20
+20
+20
+20
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR C043
-ENCODING 8766
+STARTCHAR uni21C0
+ENCODING 8640
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 4 1 4
+BBX 11 3 1 6
 BITMAP
-7080
-8840
-8440
-4380
+0080
+0040
+FFE0
 ENDCHAR
-STARTCHAR C043
-ENCODING 8767
+STARTCHAR uni21C1
+ENCODING 8641
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 8 1 2
+BBX 11 3 1 6
 BITMAP
-7000
-8800
-8800
-8800
-0440
-0440
-0440
-0380
+FFE0
+0040
+0080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8768
+STARTCHAR uni21C2
+ENCODING 8642
 SWIDTH 240 0
 DWIDTH 4 0
-BBX 2 10 1 2
+BBX 3 11 1 1
 BITMAP
 80
-40
-40
-40
-40
 80
 80
 80
 80
-40
+80
+80
+80
+A0
+C0
+80
 ENDCHAR
-STARTCHAR C043
-ENCODING 8769
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 6 1 4
+STARTCHAR uni21C3
+ENCODING 8643
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 11 1 1
 BITMAP
-0200
-0200
-7C40
-8780
-0800
-0800
+20
+20
+20
+20
+20
+20
+20
+20
+A0
+60
+20
 ENDCHAR
-STARTCHAR C043
-ENCODING 8770
+STARTCHAR uni21C4
+ENCODING 8644
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 4 1 4
+BBX 11 11 1 1
 BITMAP
-FFC0
+0080
+0040
+FFE0
+0040
+0080
 0000
-7840
-8780
+2000
+4000
+FFE0
+4000
+2000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8771
+STARTCHAR uni21C5
+ENCODING 8645
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 4 1 4
+BBX 11 11 1 1
 BITMAP
-7840
-8780
-0000
-FFC0
+2080
+7080
+A880
+2080
+2080
+2080
+2080
+2080
+22A0
+21C0
+2080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8772
+STARTCHAR uni21C6
+ENCODING 8646
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 8 1 2
+BBX 11 11 1 1
 BITMAP
-0200
-0200
-7C40
-8780
-0800
-FFC0
-1000
-1000
+2000
+4000
+FFE0
+4000
+2000
+0000
+0080
+0040
+FFE0
+0040
+0080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8773
+STARTCHAR uni21C7
+ENCODING 8647
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 6 1 3
+BBX 11 11 1 1
 BITMAP
-7840
-8780
+2000
+4000
+FFE0
+4000
+2000
 0000
-FFC0
-0000
-FFC0
+2000
+4000
+FFE0
+4000
+2000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8774
+STARTCHAR uni21C8
+ENCODING 8648
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 8 1 1
+BBX 11 11 1 1
 BITMAP
-7840
-8780
-0400
-FFC0
-0800
-FFC0
-1000
-1000
+2080
+71C0
+AAA0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8775
+STARTCHAR uni21C9
+ENCODING 8649
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 9 1 1
+BBX 11 11 1 1
 BITMAP
-0200
-7A40
-8780
-0400
-FFC0
-0800
-FFC0
-1000
-1000
+0080
+0040
+FFE0
+0040
+0080
+0000
+0080
+0040
+FFE0
+0040
+0080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8776
+STARTCHAR uni21CA
+ENCODING 8650
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 5 1 3
+BBX 11 11 1 1
 BITMAP
-7840
-8780
-0000
-7840
-8780
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+AAA0
+71C0
+2080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8777
+STARTCHAR uni21CB
+ENCODING 8651
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 8 1 1
+BBX 11 8 1 3
 BITMAP
-0200
-7A40
-8780
-0400
-7C40
-8F80
-0800
-0800
+2000
+4000
+FFE0
+0000
+0000
+FFE0
+0040
+0080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8778
+STARTCHAR uni21CC
+ENCODING 8652
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 7 1 3
+BBX 11 8 1 3
 BITMAP
-7840
-8780
+0080
+0040
+FFE0
 0000
-7840
-8780
 0000
-FFC0
+FFE0
+4000
+2000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8779
+STARTCHAR uni21CD
+ENCODING 8653
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 8 1 2
+BBX 11 7 1 3
 BITMAP
-7840
-8780
-0000
-7840
-8780
-0000
-7840
-8780
+1080
+2080
+7FE0
+8100
+7FE0
+2200
+1200
 ENDCHAR
-STARTCHAR C043
-ENCODING 8780
+STARTCHAR uni21CE
+ENCODING 8654
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 7 1 3
+BITMAP
+1140
+2120
+7FF0
+8208
+7FF0
+2420
+1440
+ENDCHAR
+STARTCHAR uni21CF
+ENCODING 8655
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 8 1 2
+BBX 11 7 1 3
 BITMAP
-7080
-8840
-8440
-4380
-0000
+0900
+0880
 FFC0
-0000
+1020
 FFC0
+2080
+2100
 ENDCHAR
-STARTCHAR C043
-ENCODING 8781
+STARTCHAR uni21D0
+ENCODING 8656
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 5 1 3
+BBX 11 7 1 3
 BITMAP
-C0C0
-3F00
-0000
-3F00
-C0C0
+1000
+2000
+7FE0
+8000
+7FE0
+2000
+1000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8782
+STARTCHAR uni21D1
+ENCODING 8657
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 1
+BITMAP
+10
+28
+6C
+AA
+28
+28
+28
+28
+28
+28
+28
+ENDCHAR
+STARTCHAR uni21D2
+ENCODING 8658
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 7 1 2
+BBX 11 7 1 3
 BITMAP
-0C00
-1200
-F3C0
-0000
-F3C0
-1200
-0C00
+0100
+0080
+FFC0
+0020
+FFC0
+0080
+0100
 ENDCHAR
-STARTCHAR C043
-ENCODING 8783
+STARTCHAR uni21D3
+ENCODING 8659
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 11 1 1
+BITMAP
+28
+28
+28
+28
+28
+28
+28
+AA
+6C
+28
+10
+ENDCHAR
+STARTCHAR uni21D4
+ENCODING 8660
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 5 1 4
+BBX 12 7 1 3
 BITMAP
-0C00
-1200
-F3C0
-0000
-FFC0
+1080
+2040
+7FE0
+8010
+7FE0
+2040
+1080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8784
+STARTCHAR uni21D5
+ENCODING 8661
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 0
+BITMAP
+10
+28
+6C
+AA
+28
+28
+28
+28
+AA
+6C
+28
+10
+ENDCHAR
+STARTCHAR uni21D6
+ENCODING 8662
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 8 1 4
+BBX 10 10 1 1
 BITMAP
-0800
-1C00
-0800
-0000
-FF80
-0000
-0000
-FF80
+F800
+9000
+8800
+C400
+A200
+1100
+0880
+0440
+0200
+0100
 ENDCHAR
-STARTCHAR C043
-ENCODING 8785
+STARTCHAR uni21D7
+ENCODING 8663
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 12 1 0
+BBX 10 10 1 1
 BITMAP
-0800
-1C00
-0800
-0000
-FF80
-0000
-0000
-FF80
-0000
-0800
-1C00
-0800
+07C0
+0240
+0440
+08C0
+1140
+2200
+4400
+8800
+1000
+2000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8786
+STARTCHAR uni21D8
+ENCODING 8664
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 12 1 0
+BBX 10 10 1 1
 BITMAP
-4000
-E000
-4000
-0000
-FF80
-0000
-0000
-FF80
-0000
-0100
-0380
-0100
+2000
+1000
+8800
+4400
+2200
+1140
+08C0
+0440
+0240
+07C0
 ENDCHAR
-STARTCHAR C043
-ENCODING 8787
+STARTCHAR uni21D9
+ENCODING 8665
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 12 1 0
+BBX 10 10 1 1
 BITMAP
 0100
-0380
+0200
+0440
+0880
+1100
+A200
+C400
+8800
+9000
+F800
+ENDCHAR
+STARTCHAR uni21DA
+ENCODING 8666
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 3
+BITMAP
+1000
+3FE0
+4000
+FFE0
+4000
+3FE0
+1000
+ENDCHAR
+STARTCHAR uni21DB
+ENCODING 8667
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 7 1 3
+BITMAP
 0100
-0000
 FF80
-0000
-0000
+0040
+FFE0
+0040
 FF80
-0000
-4000
-E000
-4000
+0100
 ENDCHAR
-STARTCHAR C043
-ENCODING 8788
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 7 1 2
+STARTCHAR uni21DC
+ENCODING 8668
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 5 1 4
 BITMAP
-4000
-EFF8
-4000
-0000
-4000
-EFF8
-4000
+2000
+4880
+F550
+4220
+2000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8789
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 7 1 2
+STARTCHAR uni21DD
+ENCODING 8669
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 5 1 4
 BITMAP
-0010
-FFB8
-0010
-0000
-0010
-FFB8
-0010
+0040
+1120
+AAF0
+4420
+0040
 ENDCHAR
-STARTCHAR C043
-ENCODING 8790
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 4 1 4
+STARTCHAR uni21DE
+ENCODING 8670
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
 BITMAP
-FF80
-1400
-1400
-FF80
+20
+70
+A8
+20
+20
+F8
+20
+F8
+20
+20
+20
 ENDCHAR
-STARTCHAR C043
-ENCODING 8791
+STARTCHAR uni21DF
+ENCODING 8671
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
+BITMAP
+20
+20
+20
+F8
+20
+F8
+20
+20
+A8
+70
+20
+ENDCHAR
+STARTCHAR uni21E0
+ENCODING 8672
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 9 1 4
+BBX 11 5 1 4
 BITMAP
-0C00
-1200
-1200
-0C00
-0000
-FFC0
-0000
-0000
-FFC0
+2000
+4000
+EEE0
+4000
+2000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8792
+STARTCHAR uni21E1
+ENCODING 8673
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
+BITMAP
+20
+70
+A8
+00
+20
+20
+20
+00
+20
+20
+20
+ENDCHAR
+STARTCHAR uni21E2
+ENCODING 8674
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 7 1 4
+BBX 11 5 1 4
 BITMAP
-1E00
-2100
-0000
-FFC0
-0000
-0000
-FFC0
+0080
+0040
+EEE0
+0040
+0080
 ENDCHAR
-STARTCHAR C043
-ENCODING 8793
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 9 1 4
+STARTCHAR uni21E3
+ENCODING 8675
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 1
+BITMAP
+20
+20
+20
+00
+20
+20
+20
+00
+A8
+70
+20
+ENDCHAR
+STARTCHAR uni21E4
+ENCODING 8676
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 7 1 3
+BITMAP
+8000
+9000
+A000
+FFF0
+A000
+9000
+8000
+ENDCHAR
+STARTCHAR uni21E5
+ENCODING 8677
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 7 1 3
+BITMAP
+0010
+0090
+0050
+FFF0
+0050
+0090
+0010
+ENDCHAR
+STARTCHAR uni21E6
+ENCODING 8678
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 9 1 2
+BITMAP
+0800
+1800
+2FF0
+4010
+8010
+4010
+2FF0
+1800
+0800
+ENDCHAR
+STARTCHAR uni21E7
+ENCODING 8679
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 1
 BITMAP
 0800
 1400
 2200
 4100
-0000
-FF80
-0000
-0000
-FF80
+E380
+2200
+2200
+2200
+2200
+2200
+2200
+3E00
 ENDCHAR
-STARTCHAR C043
-ENCODING 8794
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 9 1 4
+STARTCHAR uni21E8
+ENCODING 8680
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 9 1 2
+BITMAP
+0100
+0180
+FF40
+8020
+8010
+8020
+FF40
+0180
+0100
+ENDCHAR
+STARTCHAR uni21E9
+ENCODING 8681
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 1
 BITMAP
+3E00
+2200
+2200
+2200
+2200
+2200
+2200
+E380
 4100
 2200
 1400
 0800
-0000
-FF80
-0000
-0000
-FF80
 ENDCHAR
-STARTCHAR C043
-ENCODING 8795
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 10 1 4
+STARTCHAR uni21EA
+ENCODING 8682
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 0
 BITMAP
 0800
-0800
+1400
+2200
+4100
+E380
+2200
+2200
+2200
+2200
+2200
+2200
 3E00
-1C00
-3600
-0000
-FF80
-0000
 0000
-FF80
+3E00
+2200
+2200
+3E00
 ENDCHAR
-STARTCHAR C043
-ENCODING 8796
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 10 1 4
+STARTCHAR uni21EB
+ENCODING 8683
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 0
 BITMAP
 0800
 1400
 2200
 4100
-7F00
-0000
-FF80
-0000
-0000
+E380
+2200
+2200
+2200
+2200
+2200
+2200
+E380
+8080
 FF80
 ENDCHAR
-STARTCHAR C043
-ENCODING 8797
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 12 1 4
+STARTCHAR uni21EC
+ENCODING 8684
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 0
 BITMAP
-1040
-10A0
-1480
-7BC0
-9E80
-9880
-7680
-0000
-FFE0
-0000
-0000
-FFE0
+0800
+1400
+3E00
+4100
+E380
+2200
+2200
+2200
+2200
+2200
+2200
+E380
+8080
+FF80
 ENDCHAR
-STARTCHAR C043
-ENCODING 8798
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 10 1 4
+STARTCHAR uni21ED
+ENCODING 8685
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 0
 BITMAP
-F600
-4900
-4900
-4900
+0800
+1C00
+2A00
 4900
-0000
-FF80
-0000
-0000
+EB80
+2A00
+2A00
+2A00
+2A00
+2A00
+2A00
+EB80
+8880
 FF80
 ENDCHAR
-STARTCHAR C043
-ENCODING 8799
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 12 1 4
+STARTCHAR uni21EE
+ENCODING 8686
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 15 1 2
 BITMAP
-1800
-2400
-0C00
-1000
-1000
-0000
-1000
-0000
-FF80
-0000
-0000
-FF80
+0800
+1400
+2200
+4900
+D580
+2200
+4100
+E380
+2200
+2200
+2200
+2200
+2200
+2200
+3E00
 ENDCHAR
-STARTCHAR C043
-ENCODING 8800
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 8 1 2
+STARTCHAR uni21EF
+ENCODING 8687
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 0
 BITMAP
-0400
-0400
-FF80
-0800
 0800
+1400
+2200
+4900
+D580
+2200
+4100
+E380
+2200
+2200
+2200
+2200
+2200
+2200
+E380
+8080
 FF80
-1000
-1000
 ENDCHAR
-STARTCHAR C043
-ENCODING 8801
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 5 1 3
+STARTCHAR uni21F0
+ENCODING 8688
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 9 2 2
 BITMAP
-FF80
-0000
-FF80
-0000
-FF80
+E040
+A060
+BFD0
+8018
+8014
+8018
+BFD0
+A060
+E040
 ENDCHAR
-STARTCHAR C043
-ENCODING 8802
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 9 1 1
+STARTCHAR uni21F1
+ENCODING 8689
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 1
 BITMAP
-0400
-0400
-FF80
-0800
-FF80
-1000
-FF80
-2000
-2000
+FFE0
+8000
+BC00
+B000
+A800
+A400
+8200
+8100
+8080
+8040
+8020
 ENDCHAR
-STARTCHAR C043
-ENCODING 8803
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 7 1 3
+STARTCHAR uni21F2
+ENCODING 8690
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 1
 BITMAP
-FF80
-0000
-FF80
-0000
-FF80
-0000
-FF80
+8020
+4020
+2020
+1020
+0820
+04A0
+02A0
+01A0
+07A0
+0020
+FFE0
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8804
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
+STARTCHAR uni21F3
+ENCODING 8691
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 0
 BITMAP
-06
-18
-60
-80
-60
-18
-06
-00
-FE
+0800
+1400
+2200
+4100
+E380
+2200
+2200
+2200
+2200
+2200
+2200
+E380
+4100
+2200
+1400
+0800
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8805
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
+STARTCHAR uni2200
+ENCODING 8704
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-C0
-30
-0C
-02
-0C
-30
-C0
-00
-FE
+8020
+8020
+4040
+4040
+3F80
+2080
+1100
+1100
+0A00
+0A00
+0400
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8806
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
+STARTCHAR uni2201
+ENCODING 8705
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
 BITMAP
-0E
-70
+78
+84
+84
 80
-70
-0E
-00
-FE
-00
-FE
+80
+80
+80
+80
+84
+84
+78
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8807
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
+STARTCHAR uni2202
+ENCODING 8706
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 0
 BITMAP
-E0
-1C
-02
-1C
-E0
-00
-FE
-00
-FE
+60
+10
+10
+08
+38
+48
+88
+88
+88
+90
+60
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8808
+STARTCHAR uni2203
+ENCODING 8707
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 10 1 1
+BBX 8 11 1 0
 BITMAP
-0E
-70
-80
-70
-0E
-10
-FE
-20
-FE
-40
+FF
+01
+01
+01
+01
+FF
+01
+01
+01
+01
+FF
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8809
+STARTCHAR uni2204
+ENCODING 8708
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 10 1 1
+BBX 8 15 1 -2
 BITMAP
-E0
-1C
 02
-1C
-E0
-08
-FE
-10
-FE
+02
+FF
+05
+05
+05
+09
+FF
+09
+09
+11
+11
+FF
 20
-ENDCHAR
-STARTCHAR char8804
-ENCODING 8810
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 12 7 1 3
-BITMAP
-0630
-18C0
-6300
-8400
-6300
-18C0
-0630
+20
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8811
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 12 7 1 3
+STARTCHAR uni2205
+ENCODING 8709
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-C600
-3180
-0C60
-0210
-0C60
-3180
-C600
+1F20
+20C0
+40C0
+8120
+8220
+8420
+8820
+9020
+6040
+6080
+9F00
 ENDCHAR
-STARTCHAR char8812
-ENCODING 8812
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 3 11 1 1
+STARTCHAR uni2206
+ENCODING 8710
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-A0
-40
-A0
-A0
-A0
-A0
-A0
-A0
-A0
-40
-A0
+0400
+0E00
+0E00
+1300
+1300
+2180
+2180
+40C0
+40C0
+8060
+FFE0
 ENDCHAR
-STARTCHAR C043
-ENCODING 8813
+STARTCHAR uni2207
+ENCODING 8711
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 7 1 2
+BBX 11 11 1 0
 BITMAP
-0200
-C2C0
-3F00
+FFE0
+8060
+40C0
+40C0
+2180
+2180
+1300
+1300
+0E00
+0E00
 0400
-3F00
-C8C0
-0800
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8814
+STARTCHAR uni2208
+ENCODING 8712
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 10 1 2
+BBX 8 11 1 0
 BITMAP
-08
-08
-0E
-18
-70
-90
-60
-38
-26
+1F
+20
+40
+80
+80
+FF
+80
+80
+40
 20
+1F
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8815
+STARTCHAR uni2209
+ENCODING 8713
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 9 1 2
+BBX 8 15 1 -2
 BITMAP
-08
-C8
-38
-14
-12
-1C
+02
+02
+1F
+24
+44
+84
+88
+FF
+88
+88
+50
 30
-E0
+1F
+20
 20
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8816
+STARTCHAR uni220A
+ENCODING 8714
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 7 1 2
+BITMAP
+3E
+40
+80
+FE
+80
+40
+3E
+ENDCHAR
+STARTCHAR uni220B
+ENCODING 8715
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 11 1 1
+BBX 8 11 1 0
 BITMAP
-08
-08
-0E
-18
-70
-90
-60
-B8
-66
-78
-46
+F8
+04
+02
+01
+01
+FF
+01
+01
+02
+04
+F8
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8817
+STARTCHAR uni220C
+ENCODING 8716
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 11 1 0
+BBX 8 15 1 -2
 BITMAP
-08
-C8
-38
-14
-12
-1C
-32
-EC
-30
-E0
-20
+40
+40
+F8
+24
+22
+21
+11
+FF
+11
+11
+0A
+0C
+F8
+04
+04
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8818
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 10 1 1
+STARTCHAR uni220D
+ENCODING 8717
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 7 1 2
 BITMAP
-06
-18
-60
-80
-60
-18
-06
-00
-71
-8E
+F8
+04
+02
+FE
+02
+04
+F8
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8819
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 10 1 1
+STARTCHAR uni220E
+ENCODING 8718
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 1
 BITMAP
-60
-18
-06
-01
-06
-18
-60
-00
-71
-8E
+F8
+F8
+F8
+F8
+F8
+F8
+F8
+F8
+F8
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8820
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 13 1 0
+STARTCHAR uni220F
+ENCODING 8719
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 0 0
 BITMAP
-04
-04
-06
-18
-68
-88
-70
-38
-16
-20
-71
-AE
-20
+FFE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+FBE0
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8821
+STARTCHAR uni2210
+ENCODING 8720
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 0 0
+BITMAP
+FBE0
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+FFE0
+ENDCHAR
+STARTCHAR uni2211
+ENCODING 8721
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 8 13 1 0
+BBX 9 11 1 0
 BITMAP
-02
-02
-62
-1C
-06
-05
-0E
-18
-68
-10
-71
-9E
-20
+FF80
+4180
+2080
+2080
+1000
+1800
+1000
+2080
+2080
+4180
+FF80
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8822
+STARTCHAR uni2212
+ENCODING 8722
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 10 1 1
+BBX 7 1 1 5
 BITMAP
-0E
-70
-80
-70
-0E
-E0
-1C
-02
-1C
-E0
+FE
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8823
+STARTCHAR uni2213
+ENCODING 8723
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 10 1 1
+BBX 7 9 1 1
 BITMAP
-E0
-1C
-02
-1C
-E0
-0E
-70
-80
-70
-0E
+FE
+00
+10
+10
+10
+FE
+10
+10
+10
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8824
+STARTCHAR uni2214
+ENCODING 8724
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 14 1 -1
+BBX 7 11 1 1
 BITMAP
 10
+38
 10
-1E
-70
-90
-70
-1E
-F0
-1C
-12
-1C
-F0
+00
+10
+10
+10
+FE
 10
 10
+10
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8825
+STARTCHAR uni2215
+ENCODING 8725
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 14 1 -1
+BBX 8 16 1 -4
 BITMAP
+01
+01
+02
+02
+04
+04
+08
+08
 10
 10
-F0
-1C
-12
-1C
-F0
-1E
-70
-90
-70
-1E
+20
+20
+40
+40
+80
+80
+ENDCHAR
+STARTCHAR uni2216
+ENCODING 8726
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
+BITMAP
+80
+80
+40
+40
+20
+20
 10
 10
+08
+08
+04
+04
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8826
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 2
+STARTCHAR uni2217
+ENCODING 8727
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 7 1 2
 BITMAP
-0080
-0100
-0600
-3800
-C000
-3800
-0600
-0100
-0080
+10
+92
+54
+38
+54
+92
+10
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8827
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 2
+STARTCHAR uni2218
+ENCODING 8728
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 4 1 4
 BITMAP
-8000
-4000
-3000
-0E00
-0180
-0E00
-3000
-4000
-8000
+60
+90
+90
+60
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8828
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni2219
+ENCODING 8729
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 4 1 4
 BITMAP
-0080
-0100
-0600
-3800
-C000
-3800
-C600
-3900
-0480
-0200
-0100
+60
+F0
+F0
+60
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8829
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni221A
+ENCODING 8730
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-8000
-4000
-3000
+0020
+0020
+0040
+0040
+F080
+3080
+1900
+1900
 0E00
-0180
 0E00
-3180
-4E00
-9000
-2000
-4000
+0400
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8830
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 12 1 1
+STARTCHAR uni221B
+ENCODING 8731
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 0
 BITMAP
-0040
-0080
-0300
-1C00
-6000
-1C00
-0300
-0080
-0040
-0000
-7840
-8780
+0600
+0900
+0100
+0220
+0120
+0940
+0640
+F080
+3080
+1900
+1900
+0E00
+0E00
+0400
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8831
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 12 1 1
+STARTCHAR uni221C
+ENCODING 8732
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 0
 BITMAP
-8000
-4000
-3000
+0200
+0600
+0A00
+1220
+1F20
+0240
+0740
+F080
+3080
+1900
+1900
 0E00
-0180
 0E00
-3000
-4000
-8000
-0000
-7840
-8780
+0400
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8832
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 2
+STARTCHAR uni221D
+ENCODING 8733
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 5 1 3
 BITMAP
-0400
-0480
-0500
-0E00
-3800
-C800
-3800
-1600
-1100
-1080
+7180
+8A00
+8400
+8A00
+7180
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8833
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 1
+STARTCHAR uni221E
+ENCODING 8734
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 5 1 3
 BITMAP
-8200
-4200
-3400
-0E00
-0980
-0E00
-3000
-5000
-A000
-2000
+71C0
+8A20
+8420
+8A20
+71C0
 ENDCHAR
-STARTCHAR C060
-ENCODING 8834
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 9 1 2
+STARTCHAR uni221F
+ENCODING 8735
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 7 1 2
 BITMAP
-3F
-40
 80
 80
 80
 80
 80
-40
-3F
+80
+FE
 ENDCHAR
-STARTCHAR C060
-ENCODING 8835
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 9 1 2
+STARTCHAR uni2220
+ENCODING 8736
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 7 1 2
 BITMAP
-FC
-02
-01
-01
-01
-01
-01
-02
-FC
+04
+08
+10
+20
+40
+80
+FE
 ENDCHAR
-STARTCHAR C060
-ENCODING 8836
+STARTCHAR uni2221
+ENCODING 8737
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 8 13 1 0
+BBX 8 9 1 0
 BITMAP
-02
-02
-3F
+04
+68
+10
+28
 44
 84
-88
-88
-90
-90
-60
-3F
-40
-40
+FF
+04
+04
 ENDCHAR
-STARTCHAR C060
-ENCODING 8837
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 13 1 0
+STARTCHAR uni2222
+ENCODING 8738
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 1
 BITMAP
-02
-02
-FC
-06
-09
-09
-11
-11
-21
-22
-FC
-40
-40
+20
+16
+18
+68
+88
+68
+18
+16
+20
 ENDCHAR
-STARTCHAR C060
-ENCODING 8838
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
+STARTCHAR uni2223
+ENCODING 8739
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 1 12 1 0
 BITMAP
-3F
-40
 80
 80
 80
 80
 80
-40
-3F
-00
-FF
-ENDCHAR
-STARTCHAR C060
-ENCODING 8839
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
-BITMAP
-FC
-02
-01
-01
-01
-01
-01
-02
-FC
-00
-FF
-ENDCHAR
-STARTCHAR C060
-ENCODING 8840
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 14 1 -1
-BITMAP
-02
-02
-3F
-44
-84
-88
-88
-90
-90
-60
-3F
-40
-FF
 80
-ENDCHAR
-STARTCHAR C060
-ENCODING 8841
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 14 1 -1
-BITMAP
-02
-02
-FC
-06
-09
-09
-11
-11
-21
-22
-FC
-40
-FF
 80
-ENDCHAR
-STARTCHAR C060
-ENCODING 8842
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 12 1 -1
-BITMAP
-3F
-40
 80
 80
 80
 80
 80
-40
-3F
-08
-FF
-10
 ENDCHAR
-STARTCHAR C060
-ENCODING 8843
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 12 1 -1
+STARTCHAR uni2224
+ENCODING 8740
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 12 1 0
 BITMAP
-FC
-02
-01
-01
-01
-01
-01
-02
-FC
-08
-FF
-10
+20
+20
+20
+28
+30
+20
+60
+A0
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR C060
-ENCODING 8844
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2225
+ENCODING 8741
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 12 1 0
 BITMAP
-8080
-8080
-8080
-8080
-9080
-B080
-FF80
-B080
-9080
-4100
-3E00
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+A0
 ENDCHAR
-STARTCHAR C060
-ENCODING 8845
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2226
+ENCODING 8742
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 1 0
 BITMAP
-8080
-8080
-8080
-8080
-8080
-9C80
-9C80
-9C80
-8080
-4100
-3E00
+28
+28
+2A
+2C
+28
+38
+28
+68
+A8
+28
+28
+28
 ENDCHAR
-STARTCHAR C060
-ENCODING 8846
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni2227
+ENCODING 8743
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-8080
-8080
-8080
-8080
-8880
-8880
-BE80
-8880
-8880
-4100
-3E00
+0400
+0A00
+0A00
+1100
+1100
+2080
+2080
+4040
+4040
+8020
+8020
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8847
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 10 1 2
+STARTCHAR uni2228
+ENCODING 8744
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 0
 BITMAP
-FF
-80
-80
-80
-80
-80
-80
-80
-80
-FF
+8020
+8020
+4040
+4040
+2080
+2080
+1100
+1100
+0A00
+0A00
+0400
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8848
+STARTCHAR uni2229
+ENCODING 8745
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 8 10 1 2
+BBX 8 11 1 0
 BITMAP
-FF
-01
-01
-01
-01
-01
-01
-01
-01
-FF
+3C
+42
+81
+81
+81
+81
+81
+81
+81
+81
+81
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8849
+STARTCHAR uni222A
+ENCODING 8746
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 8 12 1 0
+BBX 8 11 1 0
 BITMAP
-FF
-80
-80
-80
-80
-80
-80
-80
-80
-FF
-00
-FF
-ENDCHAR
-STARTCHAR char8847
-ENCODING 8850
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 12 1 0
+81
+81
+81
+81
+81
+81
+81
+81
+81
+42
+3C
+ENDCHAR
+STARTCHAR uni222B
+ENCODING 8747
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 19 1 -4
 BITMAP
-FF
-01
-01
-01
-01
-01
-01
-01
-01
-FF
-00
-FF
+0E
+12
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+90
+E0
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8851
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 10 1 2
+STARTCHAR uni222C
+ENCODING 8748
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 19 1 -4
 BITMAP
-FF80
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
+0E70
+1290
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+9480
+E700
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8852
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 10 1 2
+STARTCHAR uni222D
+ENCODING 8749
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 19 1 -4
 BITMAP
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-FF80
+0E7380
+129480
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+108400
+94A400
+E73800
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8853
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 13 1 0
+STARTCHAR uni222E
+ENCODING 8750
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 19 1 -4
 BITMAP
-0F80
-3260
-6230
-4210
-8208
-8208
-FFF8
-8208
-8208
-4210
-6230
-3260
-0F80
+0E
+12
+10
+10
+10
+10
+38
+54
+92
+92
+92
+54
+38
+10
+10
+10
+10
+90
+E0
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8854
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 13 1 0
+STARTCHAR uni222F
+ENCODING 8751
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 19 1 -4
 BITMAP
-0F80
-3060
-6030
-4010
-8008
-8008
-FFF8
-8008
-8008
-4010
-6030
-3060
-0F80
+0E70
+1290
+1080
+1080
+1080
+1080
+3FC0
+50A0
+9090
+9090
+9090
+50A0
+3FC0
+1080
+1080
+1080
+1080
+9480
+E700
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8855
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 13 1 0
+STARTCHAR uni2230
+ENCODING 8752
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 19 1 -4
 BITMAP
-0F80
-3060
-6030
-5050
-8888
-8508
-8208
-8508
-8888
-5050
-6030
-3060
-0F80
+0E7380
+129480
+108400
+108400
+108400
+108400
+3FFE00
+508500
+908480
+908480
+908480
+508500
+3FFE00
+108400
+108400
+108400
+108400
+94A400
+E73800
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8856
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 13 1 0
+STARTCHAR uni2231
+ENCODING 8753
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 19 1 -4
 BITMAP
-0F80
-3060
-6030
-4050
-8088
-8108
-8208
-8408
-8808
-5010
-6030
-3060
-0F80
+0E
+12
+10
+10
+10
+10
+10
+7D
+93
+17
+10
+10
+10
+10
+10
+10
+10
+90
+E0
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8857
+STARTCHAR uni2232
+ENCODING 8754
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 19 1 -4
+BITMAP
+0700
+0900
+0800
+0800
+0800
+0800
+3E80
+4980
+8B80
+8880
+8880
+4900
+3E00
+0800
+0800
+0800
+0800
+4800
+7000
+ENDCHAR
+STARTCHAR uni2233
+ENCODING 8755
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 19 1 -4
+BITMAP
+0700
+0900
+0800
+0800
+0800
+0800
+3F80
+4B00
+8A80
+8880
+8880
+4900
+3E00
+0800
+0800
+0800
+0800
+4800
+7000
+ENDCHAR
+STARTCHAR uni2234
+ENCODING 8756
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 13 13 1 0
+BBX 13 11 1 0
 BITMAP
-0F80
-3060
-6030
+0200
+0700
+0200
+0000
+0000
+0000
+0000
+0000
 4010
-8008
-8708
-8708
-8708
-8008
+E038
 4010
-6030
-3060
-0F80
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8858
+STARTCHAR uni2235
+ENCODING 8757
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 13 13 1 0
+BBX 13 11 1 0
 BITMAP
-0F80
-3060
-6030
 4010
-8708
-8888
-8888
-8888
-8708
+E038
 4010
-6030
-3060
-0F80
+0000
+0000
+0000
+0000
+0000
+0200
+0700
+0200
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8859
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 13 1 0
+STARTCHAR uni2236
+ENCODING 8758
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 11 1 0
 BITMAP
-0F80
-3060
-6030
-4210
-9248
-8A88
-8708
-8A88
-9248
-4210
-6030
-3060
-0F80
+40
+E0
+40
+00
+00
+00
+00
+00
+40
+E0
+40
 ENDCHAR
-STARTCHAR char8853
-ENCODING 8860
+STARTCHAR uni2237
+ENCODING 8759
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 13 13 1 0
+BBX 13 11 1 0
 BITMAP
-0F80
-3060
-6030
 4010
-8008
-9FC8
-8008
-9FC8
-8008
+E038
 4010
-6030
-3060
-0F80
-ENDCHAR
-STARTCHAR char8853
-ENCODING 8861
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 13 1 0
-BITMAP
-0F80
-3060
-6030
+0000
+0000
+0000
+0000
+0000
 4010
-8008
-8008
-9FC8
-8008
-8008
+E038
 4010
-6030
-3060
-0F80
-ENDCHAR
-STARTCHAR char8847
-ENCODING 8862
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
-BITMAP
-FFE0
-8420
-8420
-8420
-8420
-FFE0
-8420
-8420
-8420
-8420
-FFE0
-ENDCHAR
-STARTCHAR char8847
-ENCODING 8863
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
-BITMAP
-FFE0
-8020
-8020
-8020
-8020
-FFE0
-8020
-8020
-8020
-8020
-FFE0
-ENDCHAR
-STARTCHAR char8847
-ENCODING 8864
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
-BITMAP
-FFE0
-C060
-A0A0
-9120
-8A20
-8420
-8A20
-9120
-A0A0
-C060
-FFE0
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8865
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2238
+ENCODING 8760
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 5 1 5
 BITMAP
-FFE0
-8020
-8020
-8020
-8420
-8E20
-8420
-8020
-8020
-8020
-FFE0
+0800
+1C00
+0800
+0000
+FF80
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8866
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2239
+ENCODING 8761
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 9 1 1
 BITMAP
-8000
-8000
-8000
-8000
-8000
-FFE0
-8000
-8000
-8000
-8000
-8000
+0080
+01C0
+0080
+0000
+FE00
+0000
+0080
+01C0
+0080
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8867
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni223A
+ENCODING 8762
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 9 1 1
 BITMAP
-0020
-0020
-0020
-0020
-0020
-FFE0
-0020
-0020
-0020
-0020
-0020
+4080
+E1C0
+4080
+0000
+FFC0
+0000
+4080
+E1C0
+4080
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8868
+STARTCHAR uni223B
+ENCODING 8763
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 11 1 0
+BBX 10 10 1 1
 BITMAP
-FFE0
-0400
-0400
 0400
-0400
-0400
-0400
-0400
+0E00
 0400
+0000
+7840
+8780
+0000
 0400
+0E00
 0400
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8869
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni223C
+ENCODING 8764
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 2 1 6
 BITMAP
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-0400
-FFE0
+7840
+8780
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8870
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 11 1 0
+STARTCHAR uni223D
+ENCODING 8765
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 2 1 6
 BITMAP
-80
-80
-80
-80
-80
-FC
-80
-80
-80
-80
-80
+8780
+7840
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8871
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 12 1 0
+STARTCHAR uni223E
+ENCODING 8766
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 4 1 4
 BITMAP
-80
-80
-80
-80
-FE
-80
+7080
+8840
+8440
+4380
+ENDCHAR
+STARTCHAR uni223F
+ENCODING 8767
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 8 1 2
+BITMAP
+7000
+8800
+8800
+8800
+0440
+0440
+0440
+0380
+ENDCHAR
+STARTCHAR uni2240
+ENCODING 8768
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 2 10 1 2
+BITMAP
 80
-FE
+40
+40
+40
+40
 80
 80
 80
 80
-ENDCHAR
-STARTCHAR char8847
-ENCODING 8872
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 12 1 0
-BITMAP
-8000
-8000
-8000
-8000
-FFE0
-8000
-8000
-FFE0
-8000
-8000
-8000
-8000
+40
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8873
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2241
+ENCODING 8769
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 4
 BITMAP
-9000
-9000
-9000
-9000
-9000
-9FE0
-9000
-9000
-9000
-9000
-9000
+0200
+0200
+7C40
+8780
+0800
+0800
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8874
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2242
+ENCODING 8770
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 4 1 4
 BITMAP
-9200
-9200
-9200
-9200
-9200
-93E0
-9200
-9200
-9200
-9200
-9200
+FFC0
+0000
+7840
+8780
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8875
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 12 1 0
+STARTCHAR uni2243
+ENCODING 8771
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 4 1 4
 BITMAP
-9000
-9000
-9000
-9000
-9FE0
-9000
-9000
-9FE0
-9000
-9000
-9000
-9000
+7840
+8780
+0000
+FFC0
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8876
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 14 1 -2
+STARTCHAR uni2244
+ENCODING 8772
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 8 1 2
 BITMAP
-0080
-8080
-8100
-8100
-8200
-8200
-FFE0
-8400
-8800
-8800
-9000
-9000
-2000
-2000
+0200
+0200
+7C40
+8780
+0800
+FFC0
+1000
+1000
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8877
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 16 1 -2
+STARTCHAR uni2245
+ENCODING 8773
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 6 1 3
 BITMAP
-0080
-0080
-8100
-8100
-8200
-8200
-FFE0
-8400
-8400
-FFE0
-8800
-8800
-9000
-9000
-2000
-2000
+7840
+8780
+0000
+FFC0
+0000
+FFC0
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8878
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 14 1 -2
+STARTCHAR uni2246
+ENCODING 8774
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 8 1 1
 BITMAP
-0040
-9040
-9080
-9080
-9100
-9100
-9FE0
-9200
-9400
-9400
-9800
-9800
+7840
+8780
+0400
+FFC0
+0800
+FFC0
 1000
 1000
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8879
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 16 1 -2
+STARTCHAR uni2247
+ENCODING 8775
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 9 1 1
 BITMAP
-0040
-0040
-9080
-9080
-9100
-9100
-9FE0
-9200
-9200
-9FE0
-9400
-9400
-9800
-9800
+0200
+7A40
+8780
+0400
+FFC0
+0800
+FFC0
 1000
 1000
-ENDCHAR
-STARTCHAR char8804
-ENCODING 8880
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 1
-BITMAP
-02
-05
-01
-06
-38
-C0
-38
-06
-01
-05
-02
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8881
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 1
+STARTCHAR uni2248
+ENCODING 8776
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 5 1 3
 BITMAP
-40
-A0
-80
-60
-1C
-03
-1C
-60
-80
-A0
-40
+7840
+8780
+0000
+7840
+8780
 ENDCHAR
-STARTCHAR char8882
-ENCODING 8882
+STARTCHAR uni2249
+ENCODING 8777
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 9 6 1 3
+BBX 10 8 1 1
 BITMAP
-0380
-1C80
-E080
-E080
-1C80
-0380
+0200
+7A40
+8780
+0400
+7C40
+8F80
+0800
+0800
 ENDCHAR
-STARTCHAR char8882
-ENCODING 8883
+STARTCHAR uni224A
+ENCODING 8778
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 9 6 1 3
+BBX 10 7 1 3
 BITMAP
-E000
-9C00
-8380
-8380
-9C00
-E000
+7840
+8780
+0000
+7840
+8780
+0000
+FFC0
 ENDCHAR
-STARTCHAR char8882
-ENCODING 8884
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 9 1 0
+STARTCHAR uni224B
+ENCODING 8779
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 8 1 2
 BITMAP
-0380
-1C80
-E080
-E080
-1C80
-0380
+7840
+8780
 0000
+7840
+8780
 0000
-FF80
+7840
+8780
 ENDCHAR
-STARTCHAR char8882
-ENCODING 8885
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 0
+STARTCHAR uni224C
+ENCODING 8780
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 8 1 2
 BITMAP
-E000
-9C00
-8380
-8380
-9C00
-E000
+7080
+8840
+8440
+4380
 0000
+FFC0
 0000
-FF80
+FFC0
 ENDCHAR
-STARTCHAR char8886
-ENCODING 8886
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 5 1 3
+STARTCHAR uni224D
+ENCODING 8781
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 5 1 3
 BITMAP
-6018
-903C
-9FFC
-903C
-6018
-ENDCHAR
-STARTCHAR char8886
-ENCODING 8887
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 5 1 3
-BITMAP
-6018
-F024
-FFE4
-F024
-6018
-ENDCHAR
-STARTCHAR char8886
-ENCODING 8888
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 5 1 3
-BITMAP
-00C0
-0120
-FF20
-0120
-00C0
-ENDCHAR
-STARTCHAR char8853
-ENCODING 8889
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 13 13 1 0
-BITMAP
-0200
-0200
-0200
-0200
-0200
-0000
-F8F8
+C0C0
+3F00
 0000
-0200
-0200
-0200
-0200
-0200
-ENDCHAR
-STARTCHAR char8847
-ENCODING 8890
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 11 1 0
-BITMAP
-FE
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-ENDCHAR
-STARTCHAR char8804
-ENCODING 8891
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
-BITMAP
-82
-82
-44
-44
-28
-28
-10
-00
-FE
-ENDCHAR
-STARTCHAR char8804
-ENCODING 8892
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
-BITMAP
-FE
-00
-10
-28
-28
-44
-44
-82
-82
-ENDCHAR
-STARTCHAR char8804
-ENCODING 8893
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
-BITMAP
-FE
-00
-82
-82
-44
-44
-28
-28
-10
+3F00
+C0C0
 ENDCHAR
-STARTCHAR char8894
-ENCODING 8894
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni224E
+ENCODING 8782
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 7 1 2
 BITMAP
-8000
-8000
-8000
-E000
-9800
-8400
-8200
-8200
-8100
-8100
-FFE0
+0C00
+1200
+F3C0
+0000
+F3C0
+1200
+0C00
 ENDCHAR
-STARTCHAR char8894
-ENCODING 8895
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni224F
+ENCODING 8783
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 5 1 4
 BITMAP
-0020
-0060
-00A0
-0120
-0220
-0420
-0820
-1020
-2020
-4020
-FFE0
+0C00
+1200
+F3C0
+0000
+FFC0
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8896
+STARTCHAR uni2250
+ENCODING 8784
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 8 1 3
+BBX 9 8 1 4
 BITMAP
 0800
 1C00
-3600
-3600
-6300
-6300
-C180
-C180
+0800
+0000
+FF80
+0000
+0000
+FF80
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8897
+STARTCHAR uni2251
+ENCODING 8785
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 8 1 3
+BBX 9 12 1 0
 BITMAP
-C180
-C180
-6300
-6300
-3600
-3600
+0800
 1C00
 0800
-ENDCHAR
-STARTCHAR C060
-ENCODING 8898
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 3
-BITMAP
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-ENDCHAR
-STARTCHAR C060
-ENCODING 8899
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 3
-BITMAP
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-7C
-38
-ENDCHAR
-STARTCHAR char8900
-ENCODING 8900
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 10 1 2
-BITMAP
-20
-20
-50
-50
-88
-88
-50
-50
-20
-20
-ENDCHAR
-STARTCHAR char8901
-ENCODING 8901
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 2 2 1 5
-BITMAP
-C0
-C0
-ENDCHAR
-STARTCHAR char8902
-ENCODING 8902
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 5 5 1 4
-BITMAP
-20
-20
-F8
-70
-D8
+0000
+FF80
+0000
+0000
+FF80
+0000
+0800
+1C00
+0800
 ENDCHAR
-STARTCHAR char8903
-ENCODING 8903
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2252
+ENCODING 8786
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 1 0
 BITMAP
-8420
-4E40
-2480
-1100
-0A00
-FFE0
-0A00
-1100
-2480
-4E40
-8420
+4000
+E000
+4000
+0000
+FF80
+0000
+0000
+FF80
+0000
+0100
+0380
+0100
 ENDCHAR
-STARTCHAR char8903
-ENCODING 8904
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2253
+ENCODING 8787
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 1 0
 BITMAP
-8020
-C060
-A0A0
-9120
-8A20
-8420
-8A20
-9120
-A0A0
-C060
-8020
+0100
+0380
+0100
+0000
+FF80
+0000
+0000
+FF80
+0000
+4000
+E000
+4000
 ENDCHAR
-STARTCHAR char8903
-ENCODING 8905
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2254
+ENCODING 8788
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 7 1 2
 BITMAP
-8020
-C040
-A080
-9100
-8A00
-8400
-8A00
-9100
-A080
-C040
-8020
+4000
+EFF8
+4000
+0000
+4000
+EFF8
+4000
 ENDCHAR
-STARTCHAR char8903
-ENCODING 8906
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2255
+ENCODING 8789
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 7 1 2
 BITMAP
-8020
-4060
-20A0
-1120
-0A20
-0420
-0A20
-1120
-20A0
-4060
-8020
+0010
+FFB8
+0010
+0000
+0010
+FFB8
+0010
 ENDCHAR
-STARTCHAR char8903
-ENCODING 8907
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2256
+ENCODING 8790
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 4 1 4
 BITMAP
-8000
-4000
-2000
-1000
-0800
-0400
-0A00
-1100
-2080
-4040
-8020
+FF80
+1400
+1400
+FF80
 ENDCHAR
-STARTCHAR char8903
-ENCODING 8908
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 11 1 0
+STARTCHAR uni2257
+ENCODING 8791
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 9 1 4
 BITMAP
-0020
-0040
-0080
-0100
-0200
-0400
-0A00
-1100
-2080
-4040
-8020
+0C00
+1200
+1200
+0C00
+0000
+FFC0
+0000
+0000
+FFC0
 ENDCHAR
-STARTCHAR C043
-ENCODING 8909
+STARTCHAR uni2258
+ENCODING 8792
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 10 4 1 4
+BBX 10 7 1 4
 BITMAP
-8780
-7840
+1E00
+2100
+0000
+FFC0
 0000
+0000
 FFC0
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8910
+STARTCHAR uni2259
+ENCODING 8793
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 9 1 2
+BBX 9 9 1 4
 BITMAP
-8080
-4100
+0800
+1400
 2200
+4100
+0000
+FF80
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR uni225A
+ENCODING 8794
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 9 1 4
+BITMAP
+4100
 2200
 1400
-1400
-1400
 0800
-0800
+0000
+FF80
+0000
+0000
+FF80
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8911
+STARTCHAR uni225B
+ENCODING 8795
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 9 1 2
+BBX 9 10 1 4
 BITMAP
 0800
 0800
+3E00
+1C00
+3600
+0000
+FF80
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR uni225C
+ENCODING 8796
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 4
+BITMAP
+0800
 1400
-1400
-1400
-2200
 2200
 4100
-8080
-ENDCHAR
-STARTCHAR C060
-ENCODING 8912
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 9 1 2
-BITMAP
-3F
-40
-9F
-A0
-A0
-A0
-9F
-40
-3F
+7F00
+0000
+FF80
+0000
+0000
+FF80
 ENDCHAR
-STARTCHAR C060
-ENCODING 8913
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 9 1 2
+STARTCHAR uni225D
+ENCODING 8797
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 12 1 4
 BITMAP
-FC
-02
-F9
-05
-05
-05
-F9
-02
-FC
+1040
+10A0
+1480
+7BC0
+9E80
+9880
+7680
+0000
+FFE0
+0000
+0000
+FFE0
 ENDCHAR
-STARTCHAR C060
-ENCODING 8914
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
+STARTCHAR uni225E
+ENCODING 8798
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 4
 BITMAP
-3C
-42
-99
-A5
-A5
-A5
-A5
-A5
-A5
-A5
-A5
+F600
+4900
+4900
+4900
+4900
+0000
+FF80
+0000
+0000
+FF80
 ENDCHAR
-STARTCHAR C060
-ENCODING 8915
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 11 1 0
+STARTCHAR uni225F
+ENCODING 8799
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 1 4
 BITMAP
-A5
-A5
-A5
-A5
-A5
-A5
-A5
-A5
-99
-42
-3C
+1800
+2400
+0C00
+1000
+1000
+0000
+1000
+0000
+FF80
+0000
+0000
+FF80
 ENDCHAR
-STARTCHAR C060
-ENCODING 8916
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 13 1 0
+STARTCHAR uni2260
+ENCODING 8800
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 8 1 2
 BITMAP
-10
-10
-10
-38
-54
-92
-92
-92
-92
-92
-92
-92
-92
+0400
+0400
+FF80
+0800
+0800
+FF80
+1000
+1000
 ENDCHAR
-STARTCHAR char123
-ENCODING 8917
+STARTCHAR uni2261
+ENCODING 8801
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 12 1 0
+BBX 9 5 1 3
 BITMAP
-1400
-1400
-1400
-1400
 FF80
-1400
-1400
+0000
 FF80
-1400
-1400
-1400
-1400
+0000
+FF80
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8918
+STARTCHAR uni2262
+ENCODING 8802
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 7 1 4
+BBX 9 9 1 1
 BITMAP
-0380
-1C00
-6200
-8700
-6200
-1C00
-0380
+0400
+0400
+FF80
+0800
+FF80
+1000
+FF80
+2000
+2000
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8919
+STARTCHAR uni2263
+ENCODING 8803
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 7 1 4
+BBX 9 7 1 3
 BITMAP
-E000
-1C00
-2300
-7080
-2300
-1C00
-E000
+FF80
+0000
+FF80
+0000
+FF80
+0000
+FF80
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8920
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni2264
+ENCODING 8804
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 2
 BITMAP
-063180
-18C600
-631800
-842000
-631800
-18C600
-063180
+06
+18
+60
+80
+60
+18
+06
+00
+FE
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8921
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni2265
+ENCODING 8805
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 2
 BITMAP
-C63000
-318C00
-0C6300
-021080
-0C6300
-318C00
-C63000
+C0
+30
+0C
+02
+0C
+30
+C0
+00
+FE
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8922
+STARTCHAR uni2266
+ENCODING 8806
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 13 1 1
+BBX 7 9 1 2
 BITMAP
 0E
 70
@@ -70463,17 +76002,13 @@
 00
 FE
 00
-E0
-1C
-02
-1C
-E0
+FE
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8923
+STARTCHAR uni2267
+ENCODING 8807
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 13 1 1
+BBX 7 9 1 2
 BITMAP
 E0
 1C
@@ -70483,208 +76018,176 @@
 00
 FE
 00
+FE
+ENDCHAR
+STARTCHAR uni2268
+ENCODING 8808
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 1 1
+BITMAP
 0E
 70
 80
 70
 0E
-ENDCHAR
-STARTCHAR char8804
-ENCODING 8924
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 9 1 2
-BITMAP
+10
 FE
-00
-06
-18
-60
-80
-60
-18
-06
+20
+FE
+40
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8925
+STARTCHAR uni2269
+ENCODING 8809
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 9 1 2
+BBX 7 10 1 1
 BITMAP
-FE
-00
-C0
-30
-0C
+E0
+1C
 02
-0C
-30
-C0
+1C
+E0
+08
+FE
+10
+FE
+20
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8926
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni226A
+ENCODING 8810
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 7 1 3
 BITMAP
-0100
-0200
-0480
-3900
-C600
-3800
-C000
-3800
-0600
-0100
-0080
+0630
+18C0
+6300
+8400
+6300
+18C0
+0630
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8927
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 0
+STARTCHAR uni226B
+ENCODING 8811
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 7 1 3
 BITMAP
-4000
-2000
-9000
-4E00
+C600
 3180
-0E00
-0180
-0E00
-3000
-4000
-8000
+0C60
+0210
+0C60
+3180
+C600
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8928
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 0
+STARTCHAR uni226C
+ENCODING 8812
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 11 1 1
 BITMAP
-0400
-0480
-0500
-0E00
-3800
-C800
-3800
-D600
-3900
-1480
-1200
-0100
+A0
+40
+A0
+A0
+A0
+A0
+A0
+A0
+A0
+40
+A0
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8929
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 11 1 0
+STARTCHAR uni226D
+ENCODING 8813
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 7 1 2
 BITMAP
-8200
-4200
-3400
-0E00
-0980
-0E00
-3180
-5E00
-9000
-2000
-6000
+0200
+C2C0
+3F00
+0400
+3F00
+C8C0
+0800
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8930
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 16 1 -2
+STARTCHAR uni226E
+ENCODING 8814
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 1 2
 BITMAP
-02
-02
-FF
-84
-84
-84
-88
-88
-88
-88
+08
+08
+0E
+18
+70
 90
-FF
-10
-FF
-20
+60
+38
+26
 20
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8931
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 16 1 -2
+STARTCHAR uni226F
+ENCODING 8815
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 2
 BITMAP
-40
-40
-FF
-21
-21
-21
-11
-11
-11
-11
-09
-FF
 08
-FF
-04
-04
+C8
+38
+14
+12
+1C
+30
+E0
+20
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8932
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 13 1 -1
+STARTCHAR uni2270
+ENCODING 8816
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 11 1 1
 BITMAP
-FF
-80
-80
-80
-80
-80
-80
-80
-80
-FF
 08
-FF
-20
+08
+0E
+18
+70
+90
+60
+B8
+66
+78
+46
 ENDCHAR
-STARTCHAR char8847
-ENCODING 8933
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 13 1 -1
+STARTCHAR uni2271
+ENCODING 8817
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 11 1 0
 BITMAP
-FF
-01
-01
-01
-01
-01
-01
-01
-01
-FF
 08
-FF
-10
+C8
+38
+14
+12
+1C
+32
+EC
+30
+E0
+20
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8934
+STARTCHAR uni2272
+ENCODING 8818
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 8 11 1 0
+BBX 8 10 1 1
 BITMAP
 06
 18
@@ -70693,16 +76196,15 @@
 60
 18
 06
-04
-79
-9E
-20
-ENDCHAR
-STARTCHAR char8804
-ENCODING 8935
+00
+71
+8E
+ENDCHAR
+STARTCHAR uni2273
+ENCODING 8819
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 8 11 1 0
+BBX 8 10 1 1
 BITMAP
 60
 18
@@ -70711,36 +76213,147 @@
 06
 18
 60
+00
+71
+8E
+ENDCHAR
+STARTCHAR uni2274
+ENCODING 8820
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 0
+BITMAP
 04
-79
+04
+06
+18
+68
+88
+70
+38
+16
+20
+71
+AE
+20
+ENDCHAR
+STARTCHAR uni2275
+ENCODING 8821
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 0
+BITMAP
+02
+02
+62
+1C
+06
+05
+0E
+18
+68
+10
+71
 9E
 20
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8936
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 0 0
+STARTCHAR uni2276
+ENCODING 8822
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 1 1
 BITMAP
-0040
+0E
+70
+80
+70
+0E
+E0
+1C
+02
+1C
+E0
+ENDCHAR
+STARTCHAR uni2277
+ENCODING 8823
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 1 1
+BITMAP
+E0
+1C
+02
+1C
+E0
+0E
+70
+80
+70
+0E
+ENDCHAR
+STARTCHAR uni2278
+ENCODING 8824
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 1 -1
+BITMAP
+10
+10
+1E
+70
+90
+70
+1E
+F0
+1C
+12
+1C
+F0
+10
+10
+ENDCHAR
+STARTCHAR uni2279
+ENCODING 8825
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 1 -1
+BITMAP
+10
+10
+F0
+1C
+12
+1C
+F0
+1E
+70
+90
+70
+1E
+10
+10
+ENDCHAR
+STARTCHAR uni227A
+ENCODING 8826
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 2
+BITMAP
 0080
-0300
-1C00
-6000
-1C00
-0300
+0100
+0600
+3800
+C000
+3800
+0600
+0100
 0080
-0040
-0200
-7C40
-8F80
-1000
 ENDCHAR
-STARTCHAR char8804
-ENCODING 8937
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 1 0
+STARTCHAR uni227B
+ENCODING 8827
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 2
 BITMAP
 8000
 4000
@@ -70751,21446 +76364,18174 @@
 3000
 4000
 8000
-0200
-7C40
-8F80
-1000
-ENDCHAR
-STARTCHAR char8882
-ENCODING 8938
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 9 10 1 1
-BITMAP
-0200
-0200
-0380
-1C80
-E480
-E480
-1C80
-0B80
-0800
-0800
-ENDCHAR
-STARTCHAR char8882
-ENCODING 8939
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 9 9 1 1
-BITMAP
-0400
-E400
-9C00
-8B80
-8B80
-9C00
-F000
-1000
-1000
 ENDCHAR
-STARTCHAR char8882
-ENCODING 8940
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 13 1 -2
+STARTCHAR uni227C
+ENCODING 8828
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
+0080
 0100
+0600
+3800
+C000
+3800
+C600
+3900
+0480
+0200
 0100
-01C0
-0E40
-7240
-7240
-0E40
-05C0
-0400
-0400
-FFC0
-0800
-0800
 ENDCHAR
-STARTCHAR char8882
-ENCODING 8941
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 10 12 1 -2
+STARTCHAR uni227D
+ENCODING 8829
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-0400
-E400
-9C00
-8B80
-8B80
-9C00
-E800
-1000
-1000
-FFC0
-1000
+8000
+4000
+3000
+0E00
+0180
+0E00
+3180
+4E00
+9000
 2000
-ENDCHAR
-STARTCHAR char8756
-ENCODING 8942
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 3 11 1 0
-BITMAP
-40
-E0
-40
-00
-40
-E0
-40
-00
-40
-E0
-40
-ENDCHAR
-STARTCHAR char8756
-ENCODING 8943
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 3 1 5
-BITMAP
-4440
-EEE0
-4440
+4000
 ENDCHAR
-STARTCHAR char8756
-ENCODING 8944
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 13 1 0
+STARTCHAR uni227E
+ENCODING 8830
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 12 1 1
 BITMAP
 0040
-00E0
+0080
+0300
+1C00
+6000
+1C00
+0300
+0080
 0040
-0000
 0000
-0400
-0E00
-0400
-0000
-0000
-4000
-E000
-4000
+7840
+8780
 ENDCHAR
-STARTCHAR char8756
-ENCODING 8945
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 11 13 1 0
+STARTCHAR uni227F
+ENCODING 8831
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 12 1 1
 BITMAP
+8000
 4000
-E000
+3000
+0E00
+0180
+0E00
+3000
 4000
-0000
+8000
 0000
+7840
+8780
+ENDCHAR
+STARTCHAR uni2280
+ENCODING 8832
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 1 2
+BITMAP
 0400
+0480
+0500
 0E00
-0400
-0000
-0000
-0040
-00E0
-0040
+3800
+C800
+3800
+1600
+1100
+1080
 ENDCHAR
-STARTCHAR char8960
-ENCODING 8960
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 8 1 2
+STARTCHAR uni2281
+ENCODING 8833
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 1 1
 BITMAP
-3D
-42
-85
-89
-91
-A1
-42
-BC
+8200
+4200
+3400
+0E00
+0980
+0E00
+3000
+5000
+A000
+2000
 ENDCHAR
-STARTCHAR char8961
-ENCODING 8961
+STARTCHAR uni2282
+ENCODING 8834
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 5 1 4
+BBX 8 9 1 2
 BITMAP
-8800
-4C00
-2A00
-1900
-0880
+3F
+40
+80
+80
+80
+80
+80
+40
+3F
 ENDCHAR
-STARTCHAR char8962
-ENCODING 8962
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 12 1 0
+STARTCHAR uni2283
+ENCODING 8835
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 9 1 2
 BITMAP
-0400
-0A00
-1100
-2080
-4040
-8020
-8020
-8020
-8020
-8020
-8020
-FFE0
+FC
+02
+01
+01
+01
+01
+01
+02
+FC
 ENDCHAR
-STARTCHAR char8963
-ENCODING 8963
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 7
+STARTCHAR uni2284
+ENCODING 8836
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 0
 BITMAP
-10
-28
-28
-44
+02
+02
+3F
 44
-82
-82
+84
+88
+88
+90
+90
+60
+3F
+40
+40
 ENDCHAR
-STARTCHAR char8963
-ENCODING 8964
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 -3
+STARTCHAR uni2285
+ENCODING 8837
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 0
 BITMAP
-82
-82
-44
-44
-28
-28
-10
+02
+02
+FC
+06
+09
+09
+11
+11
+21
+22
+FC
+40
+40
 ENDCHAR
-STARTCHAR char8963
-ENCODING 8965
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 9 1 2
+STARTCHAR uni2286
+ENCODING 8838
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 0
 BITMAP
-FE
+3F
+40
+80
+80
+80
+80
+80
+40
+3F
 00
-10
-28
-28
-44
-44
-82
-82
+FF
 ENDCHAR
-STARTCHAR char8963
-ENCODING 8966
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 2
+STARTCHAR uni2287
+ENCODING 8839
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 0
 BITMAP
-FE
-00
-FE
+FC
+02
+01
+01
+01
+01
+01
+02
+FC
 00
-10
-28
-28
-44
-44
-82
-82
+FF
 ENDCHAR
-STARTCHAR char8967
-ENCODING 8967
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 4 15 1 -1
+STARTCHAR uni2288
+ENCODING 8840
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 14 1 -1
 BITMAP
-80
-60
-10
-10
-60
-80
-80
-60
-10
-10
+02
+02
+3F
+44
+84
+88
+88
+90
+90
 60
+3F
+40
+FF
 80
-80
-60
-10
 ENDCHAR
-STARTCHAR C091
-ENCODING 8968
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 12 1 0
+STARTCHAR uni2289
+ENCODING 8841
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 14 1 -1
 BITMAP
-F0
-80
-80
-80
-80
-80
+02
+02
+FC
+06
+09
+09
+11
+11
+21
+22
+FC
+40
+FF
 80
+ENDCHAR
+STARTCHAR uni228A
+ENCODING 8842
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 1 -1
+BITMAP
+3F
+40
 80
 80
 80
 80
 80
+40
+3F
+08
+FF
+10
 ENDCHAR
-STARTCHAR C091
-ENCODING 8969
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 12 1 0
+STARTCHAR uni228B
+ENCODING 8843
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 1 -1
 BITMAP
-F0
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
+FC
+02
+01
+01
+01
+01
+01
+02
+FC
+08
+FF
 10
 ENDCHAR
-STARTCHAR C091
-ENCODING 8970
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 12 1 0
+STARTCHAR uni228C
+ENCODING 8844
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
-80
-F0
+8080
+8080
+8080
+8080
+9080
+B080
+FF80
+B080
+9080
+4100
+3E00
 ENDCHAR
-STARTCHAR C091
-ENCODING 8971
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 12 1 0
+STARTCHAR uni228D
+ENCODING 8845
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-10
-F0
+8080
+8080
+8080
+8080
+8080
+9C80
+9C80
+9C80
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR C091
-ENCODING 8972
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 0
+STARTCHAR uni228E
+ENCODING 8846
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-3C
+8080
+8080
+8080
+8080
+8880
+8880
+BE80
+8880
+8880
+4100
+3E00
+ENDCHAR
+STARTCHAR uni228F
+ENCODING 8847
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 10 1 2
+BITMAP
+FF
+80
+80
+80
 80
 80
 80
 80
 80
+FF
 ENDCHAR
-STARTCHAR C091
-ENCODING 8973
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 0
+STARTCHAR uni2290
+ENCODING 8848
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 10 1 2
 BITMAP
-F0
-04
-04
-04
-04
-04
+FF
+01
+01
+01
+01
+01
+01
+01
+01
+FF
 ENDCHAR
-STARTCHAR C091
-ENCODING 8974
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 6
+STARTCHAR uni2291
+ENCODING 8849
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 1 0
 BITMAP
+FF
 80
 80
 80
 80
 80
-3C
-ENDCHAR
-STARTCHAR C091
-ENCODING 8975
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 6
-BITMAP
-04
-04
-04
-04
-04
-F0
-ENDCHAR
-STARTCHAR char172
-ENCODING 8976
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 4 1 2
-BITMAP
-FC
 80
 80
 80
+FF
+00
+FF
 ENDCHAR
-STARTCHAR char8977
-ENCODING 8977
+STARTCHAR uni2292
+ENCODING 8850
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 7 7 2 1
-BITMAP
-82
-7C
-44
-44
-44
-7C
-82
-ENDCHAR
-STARTCHAR char8978
-ENCODING 8978
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 12 7 2 0
-BITMAP
-0F00
-30C0
-4020
-4020
-8010
-8010
-8010
-ENDCHAR
-STARTCHAR char8978
-ENCODING 8979
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 12 7 2 0
+BBX 8 12 1 0
 BITMAP
-0F00
-30C0
-4020
-4020
-8010
-8010
-FFF0
+FF
+01
+01
+01
+01
+01
+01
+01
+01
+FF
+00
+FF
 ENDCHAR
-STARTCHAR char8978
-ENCODING 8980
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 9 7 2 0
+STARTCHAR uni2293
+ENCODING 8851
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 2
 BITMAP
-3E00
-4100
+FF80
 8080
-4100
-2200
-1400
-0800
-ENDCHAR
-STARTCHAR char8960
-ENCODING 8981
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 10 10 2 0
-BITMAP
-0F00
-1080
-2040
-2040
-2040
-2040
-1080
-2F00
-4000
-8000
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
 ENDCHAR
-STARTCHAR char8960
-ENCODING 8982
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 0
+STARTCHAR uni2294
+ENCODING 8852
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 1 2
 BITMAP
-0400
-0400
-0400
-0E00
-1500
-2480
-FFE0
-2480
-1500
-0E00
-0400
-0400
-0400
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+8080
+FF80
 ENDCHAR
-STARTCHAR char8983
-ENCODING 8983
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 15 15 2 -2
+STARTCHAR uni2295
+ENCODING 8853
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
 BITMAP
-0820
-0820
-0820
-0820
-FFFE
-0820
-0820
-0820
-0820
-0820
-FFFE
-0820
-0820
-0820
-0820
+0F80
+3260
+6230
+4210
+8208
+8208
+FFF8
+8208
+8208
+4210
+6230
+3260
+0F80
 ENDCHAR
-STARTCHAR char8984
-ENCODING 8984
+STARTCHAR uni2296
+ENCODING 8854
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 11 10 2 1
+BBX 13 13 1 0
 BITMAP
-60C0
-9120
-9120
-7FC0
-1100
-1100
-7FC0
-9120
-9120
-60C0
+0F80
+3060
+6030
+4010
+8008
+8008
+FFF8
+8008
+8008
+4010
+6030
+3060
+0F80
 ENDCHAR
-STARTCHAR char172
-ENCODING 8985
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 4 1 2
+STARTCHAR uni2297
+ENCODING 8855
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
 BITMAP
-80
-80
-80
-FC
+0F80
+3060
+6030
+5050
+8888
+8508
+8208
+8508
+8888
+5050
+6030
+3060
+0F80
 ENDCHAR
-STARTCHAR char8960
-ENCODING 8986
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 15 2 0
+STARTCHAR uni2298
+ENCODING 8856
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
 BITMAP
 0F80
-1FC0
-2020
-4210
-8048
+3060
+6030
+4050
 8088
 8108
-AE28
-8008
+8208
+8408
+8808
+5010
+6030
+3060
+0F80
+ENDCHAR
+STARTCHAR uni2299
+ENCODING 8857
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
+BITMAP
+0F80
+3060
+6030
+4010
 8008
+8708
+8708
+8708
 8008
-4210
-2020
-1FC0
+4010
+6030
+3060
 0F80
 ENDCHAR
-STARTCHAR char8987
-ENCODING 8987
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 13 1 0
+STARTCHAR uni229A
+ENCODING 8858
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
 BITMAP
-FF80
-4100
-4100
-4100
-4100
-2200
-1400
-2A00
-4100
-5D00
-4100
-5D00
-FF80
-ENDCHAR
-STARTCHAR C091
-ENCODING 8988
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 6 6 1 6
-BITMAP
-FC
-80
-80
-80
-80
-80
-ENDCHAR
-STARTCHAR C091
-ENCODING 8989
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 6 6 1 6
-BITMAP
-FC
-04
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR C091
-ENCODING 8990
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 0
-BITMAP
-80
-80
-80
-80
-80
-FC
-ENDCHAR
-STARTCHAR C091
-ENCODING 8991
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 6 1 0
-BITMAP
-04
-04
-04
-04
-04
-FC
-ENDCHAR
-STARTCHAR char8960
-ENCODING 9005
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 10 2 2
-BITMAP
-0804
-0804
-1708
-1888
-3050
-3050
-5060
-48A0
-8740
-8040
-ENDCHAR
-STARTCHAR char8960
-ENCODING 9006
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 9 2 1
-BITMAP
-0E00
-1100
-2080
-27E0
-2880
-1100
-2E00
-C000
-C000
+0F80
+3060
+6030
+4010
+8708
+8888
+8888
+8888
+8708
+4010
+6030
+3060
+0F80
 ENDCHAR
-STARTCHAR char8960
-ENCODING 9009
+STARTCHAR uni229B
+ENCODING 8859
 SWIDTH 900 0
 DWIDTH 15 0
-BBX 12 11 3 1
-BITMAP
-1000
-1000
-3800
-5400
-9220
-FFF0
-9220
-5400
-3800
-1000
-1000
-ENDCHAR
-STARTCHAR char9216
-ENCODING 9216
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-8A2800
-8A2800
-CA2800
-AA2800
-9A2800
-8A2800
-89CF80
-ENDCHAR
-STARTCHAR char9217
-ENCODING 9217
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-71C880
-8A2880
-822880
-722F80
-0A2880
-8A2880
-71C880
-ENDCHAR
-STARTCHAR char9218
-ENCODING 9218
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-73E880
-888880
-808500
-708200
-088500
-888880
-708880
-ENDCHAR
-STARTCHAR char9219
-ENCODING 9219
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-FBE880
-808880
-808500
-F08200
-808500
-808880
-F88880
-ENDCHAR
-STARTCHAR char9220
-ENCODING 9220
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-F9CF80
-822200
-822200
-F22200
-822200
-822200
-F9C200
-ENDCHAR
-STARTCHAR char9221
-ENCODING 9221
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 8 1 2
+BBX 13 13 1 0
 BITMAP
-FA2700
-822880
-832880
-F2A880
-826880
-822A80
-FA2700
-000080
+0F80
+3060
+6030
+4210
+9248
+8A88
+8708
+8A88
+9248
+4210
+6030
+3060
+0F80
 ENDCHAR
-STARTCHAR char9222
-ENCODING 9222
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni229C
+ENCODING 8860
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
 BITMAP
-21C880
-522900
-8A0A00
-8A0C00
-FA0A00
-8A2900
-89C880
+0F80
+3060
+6030
+4010
+8008
+9FC8
+8008
+9FC8
+8008
+4010
+6030
+3060
+0F80
 ENDCHAR
-STARTCHAR char9223
-ENCODING 9223
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni229D
+ENCODING 8861
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
 BITMAP
-F3E800
-4A0800
-4A0800
-73C800
-4A0800
-4A0800
-F3EF80
+0F80
+3060
+6030
+4010
+8008
+8008
+9FC8
+8008
+8008
+4010
+6030
+3060
+0F80
 ENDCHAR
-STARTCHAR char9224
-ENCODING 9224
+STARTCHAR uni229E
+ENCODING 8862
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 11 1 0
 BITMAP
-F1C0
-4A20
-4A00
-71C0
-4820
-4A20
-F1C0
+FFE0
+8420
+8420
+8420
+8420
+FFE0
+8420
+8420
+8420
+8420
+FFE0
 ENDCHAR
-STARTCHAR char9225
-ENCODING 9225
+STARTCHAR uni229F
+ENCODING 8863
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 11 1 0
 BITMAP
-8BE0
-8880
-8880
-F880
-8880
-8880
-8880
+FFE0
+8020
+8020
+8020
+8020
+FFE0
+8020
+8020
+8020
+8020
+FFE0
 ENDCHAR
-STARTCHAR char9226
-ENCODING 9226
+STARTCHAR uni22A0
+ENCODING 8864
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 11 1 0
 BITMAP
-83E0
-8200
-8200
-83C0
-8200
-8200
-FA00
+FFE0
+C060
+A0A0
+9120
+8A20
+8420
+8A20
+9120
+A0A0
+C060
+FFE0
 ENDCHAR
-STARTCHAR char9227
-ENCODING 9227
+STARTCHAR uni22A1
+ENCODING 8865
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 4
+BBX 11 11 1 0
 BITMAP
-8BE0
-8880
-8880
-5080
-5080
-5080
-2080
+FFE0
+8020
+8020
+8020
+8420
+8E20
+8420
+8020
+8020
+8020
+FFE0
 ENDCHAR
-STARTCHAR char9228
-ENCODING 9228
+STARTCHAR uni22A2
+ENCODING 8866
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 11 1 0
 BITMAP
-FBE0
-8200
-8200
-F3C0
-8200
-8200
-8200
+8000
+8000
+8000
+8000
+8000
+FFE0
+8000
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR char9229
-ENCODING 9229
+STARTCHAR uni22A3
+ENCODING 8867
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 11 1 0
 BITMAP
-73C0
-8A20
-8220
-83C0
-8280
-8A40
-7220
+0020
+0020
+0020
+0020
+0020
+FFE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR char9230
-ENCODING 9230
+STARTCHAR uni22A4
+ENCODING 8868
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
-BITMAP
-71C0
-8A20
-8220
-7220
-0A20
-8A20
-71C0
-ENDCHAR
-STARTCHAR char9231
-ENCODING 9231
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 7 1 3
-BITMAP
-7380
-8900
-8100
-7100
-0900
-8900
-7380
-ENDCHAR
-STARTCHAR char9232
-ENCODING 9232
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-F20F80
-4A0800
-4A0800
-4A0F00
-4A0800
-4A0800
-F3EF80
-ENDCHAR
-STARTCHAR char9233
-ENCODING 9233
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-F1C200
-4A2600
-4A0A00
-4A0200
-4A0200
-4A2200
-F1CF80
-ENDCHAR
-STARTCHAR char9234
-ENCODING 9234
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-F1C700
-4A2880
-4A0080
-4A0300
-4A0400
-4A2800
-F1CF80
-ENDCHAR
-STARTCHAR char9235
-ENCODING 9235
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-F1CF80
-4A2080
-4A0100
-4A0300
-4A0080
-4A2880
-F1C700
-ENDCHAR
-STARTCHAR char9236
-ENCODING 9236
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
-BITMAP
-F1C100
-4A2300
-4A0500
-4A0900
-4A0F80
-4A2100
-F1C100
-ENDCHAR
-STARTCHAR char9237
-ENCODING 9237
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+BBX 11 11 1 0
 BITMAP
-888880
-894900
-CA2A00
-AA2C00
-9BEA00
-8A2900
-8A2880
+FFE0
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR char9238
-ENCODING 9238
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni22A5
+ENCODING 8869
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-722880
-8A2880
-814C80
-708A80
-088980
-888880
-708880
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+FFE0
 ENDCHAR
-STARTCHAR char9239
-ENCODING 9239
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni22A6
+ENCODING 8870
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 1 0
 BITMAP
-FBEF00
-808480
-808480
-F08700
-808480
-808480
-F88F00
+80
+80
+80
+80
+80
+FC
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char9240
-ENCODING 9240
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni22A7
+ENCODING 8871
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 1 0
 BITMAP
-708880
-894880
-822C80
-822A80
-83E980
-8A2880
-722880
+80
+80
+80
+80
+FE
+80
+80
+FE
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char9241
-ENCODING 9241
+STARTCHAR uni22A8
+ENCODING 8872
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 12 1 0
 BITMAP
-FA20
-8220
-8360
-F2A0
-8220
-8220
-FA20
+8000
+8000
+8000
+8000
+FFE0
+8000
+8000
+FFE0
+8000
+8000
+8000
+8000
 ENDCHAR
-STARTCHAR char9242
-ENCODING 9242
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni22A9
+ENCODING 8873
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-722F00
-8A2480
-822480
-722700
-0A2480
-8A2480
-71CF00
+9000
+9000
+9000
+9000
+9000
+9FE0
+9000
+9000
+9000
+9000
+9000
 ENDCHAR
-STARTCHAR char9243
-ENCODING 9243
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni22AA
+ENCODING 8874
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-F9C700
-822880
-820800
-F1C800
-802800
-822880
-F9C700
+9200
+9200
+9200
+9200
+9200
+93E0
+9200
+9200
+9200
+9200
+9200
 ENDCHAR
-STARTCHAR char9244
-ENCODING 9244
+STARTCHAR uni22AB
+ENCODING 8875
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 12 1 0
 BITMAP
-F9C0
-8220
-8200
-F1C0
-8020
-8220
-81C0
+9000
+9000
+9000
+9000
+9FE0
+9000
+9000
+9FE0
+9000
+9000
+9000
+9000
 ENDCHAR
-STARTCHAR char9245
-ENCODING 9245
+STARTCHAR uni22AC
+ENCODING 8876
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 14 1 -2
 BITMAP
-71C0
-8A20
+0080
+8080
+8100
+8100
 8200
-81C0
-9820
-8A20
-71C0
+8200
+FFE0
+8400
+8800
+8800
+9000
+9000
+2000
+2000
 ENDCHAR
-STARTCHAR char9246
-ENCODING 9246
+STARTCHAR uni22AD
+ENCODING 8877
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 16 1 -2
 BITMAP
-F1C0
-8A20
-8A00
-F1C0
-A020
-9220
-89C0
+0080
+0080
+8100
+8100
+8200
+8200
+FFE0
+8400
+8400
+FFE0
+8800
+8800
+9000
+9000
+2000
+2000
 ENDCHAR
-STARTCHAR char9247
-ENCODING 9247
+STARTCHAR uni22AE
+ENCODING 8878
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 14 1 -2
 BITMAP
-89C0
-8A20
-8A00
-89C0
-8820
-8A20
-71C0
+0040
+9040
+9080
+9080
+9100
+9100
+9FE0
+9200
+9400
+9400
+9800
+9800
+1000
+1000
 ENDCHAR
-STARTCHAR char9248
-ENCODING 9248
+STARTCHAR uni22AF
+ENCODING 8879
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 7 1 3
+BBX 11 16 1 -2
 BITMAP
-73C0
-8A20
-8220
-73C0
-0A00
-8A00
-7200
+0040
+0040
+9080
+9080
+9100
+9100
+9FE0
+9200
+9200
+9FE0
+9400
+9400
+9800
+9800
+1000
+1000
 ENDCHAR
-STARTCHAR char9249
-ENCODING 9249
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 17 7 1 3
+STARTCHAR uni22B0
+ENCODING 8880
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 1
 BITMAP
-F3E800
-4A0800
-4A0800
-4BC800
-4A0800
-4A0800
-F3EF80
+02
+05
+01
+06
+38
+C0
+38
+06
+01
+05
+02
 ENDCHAR
-STARTCHAR C098
-ENCODING 9250
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 13 1 -3
+STARTCHAR uni22B1
+ENCODING 8881
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 1
 BITMAP
-C8
-48
-48
-78
-54
-54
-54
-64
-64
-78
-20
 40
+A0
+80
+60
+1C
+03
+1C
+60
+80
+A0
 40
 ENDCHAR
-STARTCHAR char9251
-ENCODING 9251
+STARTCHAR uni22B2
+ENCODING 8882
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 6 1 3
+BITMAP
+0380
+1C80
+E080
+E080
+1C80
+0380
+ENDCHAR
+STARTCHAR uni22B3
+ENCODING 8883
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 6 1 3
+BITMAP
+E000
+9C00
+8380
+8380
+9C00
+E000
+ENDCHAR
+STARTCHAR uni22B4
+ENCODING 8884
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 9 3 1 -2
+BBX 9 9 1 0
 BITMAP
-8080
-8080
+0380
+1C80
+E080
+E080
+1C80
+0380
+0000
+0000
 FF80
 ENDCHAR
-STARTCHAR char9216
-ENCODING 9252
+STARTCHAR uni22B5
+ENCODING 8885
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 1 0
+BITMAP
+E000
+9C00
+8380
+8380
+9C00
+E000
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR uni22B6
+ENCODING 8886
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 5 1 3
+BITMAP
+6018
+903C
+9FFC
+903C
+6018
+ENDCHAR
+STARTCHAR uni22B7
+ENCODING 8887
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 5 1 3
+BITMAP
+6018
+F024
+FFE4
+F024
+6018
+ENDCHAR
+STARTCHAR uni22B8
+ENCODING 8888
 SWIDTH 780 0
 DWIDTH 13 0
-BBX 11 11 1 1
+BBX 11 5 1 3
 BITMAP
-8800
-8800
-C800
-A800
-9A00
-8A00
-8A00
+00C0
+0120
+FF20
+0120
+00C0
+ENDCHAR
+STARTCHAR uni22B9
+ENCODING 8889
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 13 1 0
+BITMAP
 0200
 0200
 0200
-03E0
+0200
+0200
+0000
+F8F8
+0000
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR char9280
-ENCODING 9280
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
+STARTCHAR uni22BA
+ENCODING 8890
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 11 1 0
 BITMAP
-1E
-12
-12
-12
-10
+FE
 10
 10
-90
-90
-90
-F0
-ENDCHAR
-STARTCHAR char9281
-ENCODING 9281
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
-BITMAP
-02
-02
-02
-02
-02
-FE
-82
-82
-82
-82
-82
-ENDCHAR
-STARTCHAR char9281
-ENCODING 9282
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
-BITMAP
-82
-82
-82
-82
-82
-FE
 10
 10
 10
 10
 10
-ENDCHAR
-STARTCHAR char9281
-ENCODING 9283
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
-BITMAP
-FE
-92
-92
-92
 10
 10
 10
-92
-92
-92
-FE
 ENDCHAR
-STARTCHAR char9284
-ENCODING 9284
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 5 1 7
+STARTCHAR uni22BB
+ENCODING 8891
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 2
 BITMAP
-C6
-AA
-92
-AA
-C6
+82
+82
+44
+44
+28
+28
+10
+00
+FE
 ENDCHAR
-STARTCHAR char9285
-ENCODING 9285
-SWIDTH 480 0
-DWIDTH 8 0
+STARTCHAR uni22BC
+ENCODING 8892
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 2
 BITMAP
-0E
-CE
-CE
-C0
-C0
-C0
-CE
-CE
-0E
+FE
+00
+10
+28
+28
+44
+44
+82
+82
 ENDCHAR
-STARTCHAR char9285
-ENCODING 9286
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 11 1 1
+STARTCHAR uni22BD
+ENCODING 8893
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 2
 BITMAP
-06
-06
-06
-16
-16
+FE
+00
+82
+82
+44
+44
+28
+28
 10
-D0
-D0
-C0
-C0
-C0
 ENDCHAR
-STARTCHAR char9287
-ENCODING 9287
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 8 1 2
+STARTCHAR uni22BE
+ENCODING 8894
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-0E
-0E
-AE
-AE
-AE
-A0
-A0
-A0
+8000
+8000
+8000
+E000
+9800
+8400
+8200
+8200
+8100
+8100
+FFE0
 ENDCHAR
-STARTCHAR char9285
-ENCODING 9288
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 5 1 4
+STARTCHAR uni22BF
+ENCODING 8895
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-DA
-DA
-DA
-DA
-DA
+0020
+0060
+00A0
+0120
+0220
+0420
+0820
+1020
+2020
+4020
+FFE0
 ENDCHAR
-STARTCHAR C047
-ENCODING 9289
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni22C0
+ENCODING 8896
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 8 1 3
 BITMAP
-90
-90
-48
-48
-48
-48
-24
-24
-24
-24
-12
-12
+0800
+1C00
+3600
+3600
+6300
+6300
+C180
+C180
 ENDCHAR
-STARTCHAR C040
-ENCODING 9312
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C1
+ENCODING 8897
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 8 1 3
 BITMAP
-07F000
-180C00
-200200
-408100
-438100
-808080
-808080
-808080
-808080
-808080
-808080
-808080
-408100
-43E100
-200200
-180C00
-07F000
+C180
+C180
+6300
+6300
+3600
+3600
+1C00
+0800
 ENDCHAR
-STARTCHAR C040
-ENCODING 9313
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C2
+ENCODING 8898
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 3
 BITMAP
-07F000
-180C00
-200200
-41C100
-422100
-822080
-822080
-802080
-804080
-804080
-808080
-812080
-412100
-43E100
-200200
-180C00
-07F000
+38
+7C
+C6
+C6
+C6
+C6
+C6
+C6
+C6
 ENDCHAR
-STARTCHAR C040
-ENCODING 9314
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C3
+ENCODING 8899
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 3
 BITMAP
-07F000
-180C00
-200200
-41C100
-422100
-822080
-802080
-802080
-80C080
-802080
-802080
-822080
-422100
-41C100
-200200
-180C00
-07F000
+C6
+C6
+C6
+C6
+C6
+C6
+C6
+7C
+38
 ENDCHAR
-STARTCHAR C040
-ENCODING 9315
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C4
+ENCODING 8900
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 10 1 2
 BITMAP
-07F000
-180C00
-200200
-40C100
-40C100
-814080
-814080
-824080
-864080
-87F080
-804080
-804080
-404100
-41F100
-200200
-180C00
-07F000
+20
+20
+50
+50
+88
+88
+50
+50
+20
+20
 ENDCHAR
-STARTCHAR C040
-ENCODING 9316
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C5
+ENCODING 8901
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 2 2 1 5
 BITMAP
-07F000
-180C00
-200200
-422100
-43C100
-820080
-820080
-83C080
-832080
-802080
-802080
-822080
-424100
-418100
-200200
-180C00
-07F000
+C0
+C0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9317
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C6
+ENCODING 8902
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 5 1 4
 BITMAP
-07F000
-180C00
-200200
-40C100
-412100
-810080
-820080
-83C080
-822080
-822080
-822080
-822080
-414100
-41C100
-200200
-180C00
-07F000
+20
+20
+F8
+70
+D8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9318
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C7
+ENCODING 8903
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-07F000
-180C00
-220200
-43F100
-421100
-822080
-804080
-804080
-804080
-808080
-808080
-808080
-408100
-408100
-200200
-180C00
-07F000
+8420
+4E40
+2480
+1100
+0A00
+FFE0
+0A00
+1100
+2480
+4E40
+8420
 ENDCHAR
-STARTCHAR C040
-ENCODING 9319
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C8
+ENCODING 8904
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-07F000
-180C00
-200200
-41C100
-422100
-822080
-822080
-814080
-81C080
-822080
-822080
-822080
-422100
-41C100
-200200
-180C00
-07F000
+8020
+C060
+A0A0
+9120
+8A20
+8420
+8A20
+9120
+A0A0
+C060
+8020
 ENDCHAR
-STARTCHAR C040
-ENCODING 9320
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22C9
+ENCODING 8905
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-07F000
-180C00
-200200
-41C100
-414100
-822080
-822080
-822080
-822080
-81E080
-802080
-804080
-424100
-418100
-200200
-180C00
-07F000
+8020
+C040
+A080
+9100
+8A00
+8400
+8A00
+9100
+A080
+C040
+8020
 ENDCHAR
-STARTCHAR C040
-ENCODING 9321
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22CA
+ENCODING 8906
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-07F000
-180C00
-200200
-447100
-5C5100
-848880
-848880
-848880
-848880
-848880
-848880
-848880
-445100
-5F7100
-200200
-180C00
-07F000
+8020
+4060
+20A0
+1120
+0A20
+0420
+0A20
+1120
+20A0
+4060
+8020
 ENDCHAR
-STARTCHAR C040
-ENCODING 9322
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22CB
+ENCODING 8907
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-07F000
-180C00
-200200
-441100
-5C7100
-841080
-841080
-841080
-841080
-841080
-841080
-841080
-441100
-5F7D00
-200200
-180C00
-07F000
+8000
+4000
+2000
+1000
+0800
+0400
+0A00
+1100
+2080
+4040
+8020
 ENDCHAR
-STARTCHAR C040
-ENCODING 9323
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22CC
+ENCODING 8908
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 11 1 0
 BITMAP
-07F000
-180C00
-200200
-447100
-5C8900
-848880
-848880
-840880
-841080
-841080
-842080
-844880
-444900
-5FF900
-200200
-180C00
-07F000
+0020
+0040
+0080
+0100
+0200
+0400
+0A00
+1100
+2080
+4040
+8020
 ENDCHAR
-STARTCHAR C040
-ENCODING 9324
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22CD
+ENCODING 8909
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 4 1 4
 BITMAP
-07F000
-180C00
-200200
-447100
-5C8900
-848880
-840880
-840880
-843080
-840880
-840880
-848880
-448900
-5F7100
-200200
-180C00
-07F000
+8780
+7840
+0000
+FFC0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9325
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22CE
+ENCODING 8910
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 9 1 2
 BITMAP
-07F000
-180C00
-200200
-443100
-5C3100
-845080
-845080
-849080
-859080
-85FC80
-841080
-841080
-441100
-5F7D00
-200200
-180C00
-07F000
+8080
+4100
+2200
+2200
+1400
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR C040
-ENCODING 9326
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22CF
+ENCODING 8911
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 9 1 2
 BITMAP
-07F000
-180C00
-200200
-448900
-5CF100
-848080
-848080
-84F080
-84C880
-840880
-840880
-848880
-449100
-5F6100
-200200
-180C00
-07F000
+0800
+0800
+1400
+1400
+1400
+2200
+2200
+4100
+8080
 ENDCHAR
-STARTCHAR C040
-ENCODING 9327
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22D0
+ENCODING 8912
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 9 1 2
 BITMAP
-07F000
-180C00
-200200
-443100
-5C4900
-844080
-848080
-84F080
-848880
-848880
-848880
-848880
-445100
-5F7100
-200200
-180C00
-07F000
+3F
+40
+9F
+A0
+A0
+A0
+9F
+40
+3F
 ENDCHAR
-STARTCHAR C040
-ENCODING 9328
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22D1
+ENCODING 8913
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 9 1 2
 BITMAP
-07F000
-180C00
-208200
-44FD00
-5C8500
-848880
-841080
-841080
-841080
-842080
-842080
-842080
-442100
-5F2100
-200200
-180C00
-07F000
+FC
+02
+F9
+05
+05
+05
+F9
+02
+FC
 ENDCHAR
-STARTCHAR C040
-ENCODING 9329
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22D2
+ENCODING 8914
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 0
 BITMAP
-07F000
-180C00
-200200
-447100
-5C8900
-848880
-848880
-845080
-847080
-848880
-848880
-848880
-448900
-5F7100
-200200
-180C00
-07F000
+3C
+42
+99
+A5
+A5
+A5
+A5
+A5
+A5
+A5
+A5
 ENDCHAR
-STARTCHAR C040
-ENCODING 9330
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22D3
+ENCODING 8915
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 0
 BITMAP
-07F000
-180C00
-200200
-447100
-5C5100
-848880
-848880
-848880
-848880
-847880
-840880
-841080
-449100
-5F6100
-200200
-180C00
-07F000
+A5
+A5
+A5
+A5
+A5
+A5
+A5
+A5
+99
+42
+3C
 ENDCHAR
-STARTCHAR C040
-ENCODING 9331
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni22D4
+ENCODING 8916
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 13 1 0
 BITMAP
-07F000
-180C00
-200200
-4E3900
-512900
-914480
-914480
-814480
-824480
-824480
-844480
-894480
-492900
-5F3900
-200200
-180C00
-07F000
+10
+10
+10
+38
+54
+92
+92
+92
+92
+92
+92
+92
+92
 ENDCHAR
-STARTCHAR C040
-ENCODING 9332
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22D5
+ENCODING 8917
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 12 1 0
 BITMAP
-100400
-208200
-438100
-408100
-808080
-808080
-808080
-808080
-808080
-808080
-808080
-43E100
-400100
-200200
-100400
+1400
+1400
+1400
+1400
+FF80
+1400
+1400
+FF80
+1400
+1400
+1400
+1400
 ENDCHAR
-STARTCHAR C040
-ENCODING 9333
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22D6
+ENCODING 8918
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 7 1 4
 BITMAP
-100400
-21C200
-422100
-422100
-822080
-802080
-804080
-804080
-808080
-812080
-812080
-43E100
-400100
-200200
-100400
+0380
+1C00
+6200
+8700
+6200
+1C00
+0380
 ENDCHAR
-STARTCHAR C040
-ENCODING 9334
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22D7
+ENCODING 8919
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 7 1 4
 BITMAP
-100400
-21C200
-422100
-422100
-802080
-802080
-80C080
-802080
-802080
-822080
-822080
-41C100
-400100
-200200
-100400
+E000
+1C00
+2300
+7080
+2300
+1C00
+E000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9335
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22D8
+ENCODING 8920
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 7 1 3
 BITMAP
-100400
-20C200
-40C100
-414100
-814080
-824080
-864080
-87F080
-804080
-804080
-804080
-41F100
-400100
-200200
-100400
+063180
+18C600
+631800
+842000
+631800
+18C600
+063180
 ENDCHAR
-STARTCHAR C040
-ENCODING 9336
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22D9
+ENCODING 8921
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 17 7 1 3
 BITMAP
-100400
-222200
-43C100
-420100
-820080
-83C080
-832080
-802080
-802080
-822080
-824080
-418100
-400100
-200200
-100400
+C63000
+318C00
+0C6300
+021080
+0C6300
+318C00
+C63000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9337
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22DA
+ENCODING 8922
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 13 1 1
 BITMAP
-100400
-20C200
-412100
-410100
-820080
-83C080
-822080
-822080
-822080
-822080
-814080
-41C100
-400100
-200200
-100400
+0E
+70
+80
+70
+0E
+00
+FE
+00
+E0
+1C
+02
+1C
+E0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9338
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22DB
+ENCODING 8923
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 13 1 1
 BITMAP
-120400
-23F200
-421100
-422100
-804080
-804080
-804080
-808080
-808080
-808080
-808080
-408100
-400100
-200200
-100400
+E0
+1C
+02
+1C
+E0
+00
+FE
+00
+0E
+70
+80
+70
+0E
 ENDCHAR
-STARTCHAR C040
-ENCODING 9339
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22DC
+ENCODING 8924
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 2
 BITMAP
-100400
-21C200
-422100
-422100
-822080
-814080
-81C080
-822080
-822080
-822080
-822080
-41C100
-400100
-200200
-100400
+FE
+00
+06
+18
+60
+80
+60
+18
+06
 ENDCHAR
-STARTCHAR C040
-ENCODING 9340
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22DD
+ENCODING 8925
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 9 1 2
 BITMAP
-100400
-21C200
-414100
-422100
-822080
-822080
-822080
-81E080
-802080
-804080
-824080
-418100
-400100
-200200
-100400
+FE
+00
+C0
+30
+0C
+02
+0C
+30
+C0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9341
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22DE
+ENCODING 8926
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-100400
-247200
-5C5100
-448900
-848880
-848880
-848880
-848880
-848880
-848880
-845080
-5F7100
-400100
-200200
-100400
+0100
+0200
+0480
+3900
+C600
+3800
+C000
+3800
+0600
+0100
+0080
 ENDCHAR
-STARTCHAR C040
-ENCODING 9342
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22DF
+ENCODING 8927
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 0
 BITMAP
-100400
-241200
-5C7100
-441100
-841080
-841080
-841080
-841080
-841080
-841080
-841080
-5F7D00
-400100
-200200
-100400
+4000
+2000
+9000
+4E00
+3180
+0E00
+0180
+0E00
+3000
+4000
+8000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9343
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E0
+ENCODING 8928
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 0
 BITMAP
-100400
-247200
-5C8900
-448900
-848880
-840880
-841080
-841080
-842080
-844880
-844880
-5FF900
-400100
-200200
-100400
+0400
+0480
+0500
+0E00
+3800
+C800
+3800
+D600
+3900
+1480
+1200
+0100
 ENDCHAR
-STARTCHAR C040
-ENCODING 9344
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E1
+ENCODING 8929
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 1 0
 BITMAP
-100400
-247200
-5C8900
-448900
-840880
-840880
-843080
-840880
-840880
-848880
-848880
-5F7100
-400100
-200200
-100400
+8200
+4200
+3400
+0E00
+0980
+0E00
+3180
+5E00
+9000
+2000
+6000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9345
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E2
+ENCODING 8930
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 16 1 -2
 BITMAP
-100400
-243200
-5C3100
-445100
-845080
-849080
-859080
-85F880
-841080
-841080
-841080
-5F7900
-400100
-200200
-100400
+02
+02
+FF
+84
+84
+84
+88
+88
+88
+88
+90
+FF
+10
+FF
+20
+20
 ENDCHAR
-STARTCHAR C040
-ENCODING 9346
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E3
+ENCODING 8931
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 16 1 -2
 BITMAP
-100400
-248A00
-5CF100
-448100
-848080
-84F080
-84C880
-840880
-840880
-848880
-849080
-5F6100
-400100
-200200
-100400
+40
+40
+FF
+21
+21
+21
+11
+11
+11
+11
+09
+FF
+08
+FF
+04
+04
 ENDCHAR
-STARTCHAR C040
-ENCODING 9347
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E4
+ENCODING 8932
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 -1
 BITMAP
-100400
-243200
-5C4900
-444100
-848080
-84F080
-848880
-848880
-848880
-848880
-845080
-5F7100
-400100
-200200
-100400
+FF
+80
+80
+80
+80
+80
+80
+80
+80
+FF
+08
+FF
+20
 ENDCHAR
-STARTCHAR C040
-ENCODING 9348
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E5
+ENCODING 8933
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 -1
 BITMAP
-108400
-24FE00
-5C8500
-448900
-841080
-841080
-841080
-842080
-842080
-842080
-842080
-5F2100
-400100
-200200
-100400
+FF
+01
+01
+01
+01
+01
+01
+01
+01
+FF
+08
+FF
+10
 ENDCHAR
-STARTCHAR C040
-ENCODING 9349
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E6
+ENCODING 8934
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 0
 BITMAP
-100400
-247200
-5C8900
-448900
-848880
-845080
-847080
-848880
-848880
-848880
-848880
-5F7100
-400100
-200200
-100400
+06
+18
+60
+80
+60
+18
+06
+04
+79
+9E
+20
 ENDCHAR
-STARTCHAR C040
-ENCODING 9350
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E7
+ENCODING 8935
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 11 1 0
 BITMAP
-100400
-247200
-5C5100
-448900
-848880
-848880
-848880
-847880
-840880
-841080
-849080
-5F6100
-400100
-200200
-100400
+60
+18
+06
+01
+06
+18
+60
+04
+79
+9E
+20
 ENDCHAR
-STARTCHAR C040
-ENCODING 9351
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni22E8
+ENCODING 8936
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 0 0
 BITMAP
-100400
-2E3A00
-512900
-514500
-914480
-814480
-824480
-824480
-844480
-894480
-892880
-5F3900
-400100
-200200
-100400
+0040
+0080
+0300
+1C00
+6000
+1C00
+0300
+0080
+0040
+0200
+7C40
+8F80
+1000
 ENDCHAR
-STARTCHAR C049
-ENCODING 9352
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 9 11 3 0
+STARTCHAR uni22E9
+ENCODING 8937
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 1 0
 BITMAP
-2000
-E000
-2000
-2000
-2000
-2000
-2000
-2000
-2000
-2180
-F980
+8000
+4000
+3000
+0E00
+0180
+0E00
+3000
+4000
+8000
+0200
+7C40
+8F80
+1000
 ENDCHAR
-STARTCHAR C050
-ENCODING 9353
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 9 11 3 0
+STARTCHAR uni22EA
+ENCODING 8938
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 10 1 1
 BITMAP
-7000
-8800
-8800
-8800
+0200
+0200
+0380
+1C80
+E480
+E480
+1C80
+0B80
 0800
+0800
+ENDCHAR
+STARTCHAR uni22EB
+ENCODING 8939
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 9 1 1
+BITMAP
+0400
+E400
+9C00
+8B80
+8B80
+9C00
+F000
 1000
 1000
-2000
-4800
-4980
-F980
 ENDCHAR
-STARTCHAR C051
-ENCODING 9354
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 9 11 3 0
+STARTCHAR uni22EC
+ENCODING 8940
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 13 1 -2
 BITMAP
-7000
-8800
-8800
-0800
-0800
-3000
+0100
+0100
+01C0
+0E40
+7240
+7240
+0E40
+05C0
+0400
+0400
+FFC0
 0800
 0800
-8800
-8980
-7180
 ENDCHAR
-STARTCHAR C052
-ENCODING 9355
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 3 0
+STARTCHAR uni22ED
+ENCODING 8941
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 10 12 1 -2
 BITMAP
-1800
-1800
-2800
-2800
-4800
-C800
-FE00
-0800
-0800
-0860
-3E60
+0400
+E400
+9C00
+8B80
+8B80
+9C00
+E800
+1000
+1000
+FFC0
+1000
+2000
 ENDCHAR
-STARTCHAR C053
-ENCODING 9356
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 9 11 3 0
+STARTCHAR uni22EE
+ENCODING 8942
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 11 1 0
 BITMAP
-8800
-F000
-8000
-8000
-F000
-C800
-0800
-0800
-8800
-9180
-6180
+40
+E0
+40
+00
+40
+E0
+40
+00
+40
+E0
+40
 ENDCHAR
-STARTCHAR C054
-ENCODING 9357
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 9 11 3 0
+STARTCHAR uni22EF
+ENCODING 8943
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 3 1 5
 BITMAP
-3000
-4800
+4440
+EEE0
+4440
+ENDCHAR
+STARTCHAR uni22F0
+ENCODING 8944
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 1 0
+BITMAP
+0040
+00E0
+0040
+0000
+0000
+0400
+0E00
+0400
+0000
+0000
 4000
-8000
-F000
-8800
-8800
-8800
-8800
-5180
-7180
+E000
+4000
 ENDCHAR
-STARTCHAR C055
-ENCODING 9358
+STARTCHAR uni22F1
+ENCODING 8945
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 11 13 1 0
+BITMAP
+4000
+E000
+4000
+0000
+0000
+0400
+0E00
+0400
+0000
+0000
+0040
+00E0
+0040
+ENDCHAR
+STARTCHAR uni2300
+ENCODING 8960
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 8 8 2 2
+BITMAP
+3D
+42
+85
+89
+91
+A1
+42
+BC
+ENDCHAR
+STARTCHAR uni2301
+ENCODING 8961
 SWIDTH 720 0
 DWIDTH 12 0
-BBX 7 12 3 0
+BBX 9 5 2 4
 BITMAP
-80
-FC
-84
-88
-10
-10
-10
-20
-20
-20
-26
-26
+8800
+4C00
+2A00
+1900
+0880
 ENDCHAR
-STARTCHAR C056
-ENCODING 9359
+STARTCHAR uni2302
+ENCODING 8962
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 9 11 3 0
+BBX 11 12 2 0
 BITMAP
-7000
-8800
-8800
-8800
-5000
-7000
-8800
-8800
-8800
-8980
-7180
+0400
+0A00
+1100
+2080
+4040
+8020
+8020
+8020
+8020
+8020
+8020
+FFE0
 ENDCHAR
-STARTCHAR C057
-ENCODING 9360
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 8 11 3 0
+STARTCHAR uni2303
+ENCODING 8963
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 7 2 7
 BITMAP
-70
-50
-88
-88
-88
-88
-78
-08
 10
-93
-63
+28
+28
+44
+44
+82
+82
 ENDCHAR
-STARTCHAR C040
-ENCODING 9361
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 13 11 3 0
+STARTCHAR uni2304
+ENCODING 8964
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 7 2 -3
 BITMAP
-2380
-E280
-2440
-2440
-2440
-2440
-2440
-2440
-2440
-2298
-FB98
+82
+82
+44
+44
+28
+28
+10
 ENDCHAR
-STARTCHAR C040
-ENCODING 9362
-SWIDTH 1200 0
-DWIDTH 20 0
-BBX 15 11 3 0
+STARTCHAR uni2305
+ENCODING 8965
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 9 2 2
 BITMAP
-2080
-E380
-2080
-2080
-2080
-2080
-2080
-2080
-2080
-2086
-FBE6
+FE
+00
+10
+28
+28
+44
+44
+82
+82
 ENDCHAR
-STARTCHAR C040
-ENCODING 9363
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 14 11 3 0
+STARTCHAR uni2306
+ENCODING 8966
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 11 2 2
 BITMAP
-2380
-E440
-2440
-2440
-2040
-2080
-2080
-2100
-2240
-224C
-FFCC
+FE
+00
+FE
+00
+10
+28
+28
+44
+44
+82
+82
 ENDCHAR
-STARTCHAR C040
-ENCODING 9364
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 14 11 3 0
+STARTCHAR uni2307
+ENCODING 8967
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 15 2 -1
 BITMAP
-2380
-E440
-2440
-2040
-2040
-2180
-2040
-2040
-2440
-244C
-FB8C
+80
+60
+10
+10
+60
+80
+80
+60
+10
+10
+60
+80
+80
+60
+10
 ENDCHAR
-STARTCHAR C040
-ENCODING 9365
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 14 11 3 0
+STARTCHAR uni2308
+ENCODING 8968
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 12 2 0
 BITMAP
-2180
-E180
-2280
-2280
-2480
-2C80
-2FC0
-2080
-2080
-208C
-FBCC
+F0
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C040
-ENCODING 9366
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 13 11 3 0
+STARTCHAR uni2309
+ENCODING 8969
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 12 2 0
 BITMAP
-2440
-E780
-2400
-2400
-2780
-2640
-2040
-2040
-2440
-2498
-FB18
+F0
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR C040
-ENCODING 9367
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 13 11 3 0
+STARTCHAR uni230A
+ENCODING 8970
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 12 2 0
 BITMAP
-2180
-E240
-2200
-2400
-2780
-2440
-2440
-2440
-2440
-2298
-FB98
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+F0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9368
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 12 3 0
+STARTCHAR uni230B
+ENCODING 8971
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 12 2 0
 BITMAP
-0400
-27E0
-E420
-2440
-2080
-2080
-2080
-2100
-2100
-2100
-2130
-F930
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
+F0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9369
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 14 11 3 0
+STARTCHAR uni230C
+ENCODING 8972
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 0
 BITMAP
-2380
-E440
-2440
-2440
-2280
-2380
-2440
-2440
-2440
-244C
-FB8C
+3C
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C040
-ENCODING 9370
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 13 11 3 0
+STARTCHAR uni230D
+ENCODING 8973
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 0
 BITMAP
-2380
-E280
-2440
-2440
-2440
-2440
-23C0
-2040
-2080
-2498
-FB18
+F0
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR C040
-ENCODING 9371
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 14 11 3 0
+STARTCHAR uni230E
+ENCODING 8974
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 6
 BITMAP
-71C0
-8940
-8A20
-8A20
-0A20
-1220
-1220
-2220
-4A20
-494C
-F9CC
+80
+80
+80
+80
+80
+3C
 ENDCHAR
-STARTCHAR C109
-ENCODING 9372
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni230F
+ENCODING 8975
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 6
 BITMAP
-100400
-200200
-400100
-400100
-800080
-838080
-844080
-804080
-83C080
-844080
-844080
-43E100
-400100
-200200
-100400
+04
+04
+04
+04
+04
+F0
 ENDCHAR
-STARTCHAR C109
-ENCODING 9373
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2310
+ENCODING 8976
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 4 2 2
 BITMAP
-160400
-220200
-420100
-420100
-820080
-83C080
-822080
-822080
-822080
-822080
-822080
-43C100
-400100
-200200
-100400
+FC
+80
+80
+80
 ENDCHAR
-STARTCHAR C109
-ENCODING 9374
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2311
+ENCODING 8977
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 7 2 1
 BITMAP
-100400
-200200
-400100
-400100
-800080
-81C080
-822080
-820080
-820080
-820080
-822080
-41C100
-400100
-200200
-100400
+82
+7C
+44
+44
+44
+7C
+82
 ENDCHAR
-STARTCHAR C109
-ENCODING 9375
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2312
+ENCODING 8978
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 7 2 0
 BITMAP
-10C400
-204200
-404100
-404100
-804080
-83C080
-844080
-844080
-844080
-844080
-844080
-43E100
-400100
-200200
-100400
+0F00
+30C0
+4020
+4020
+8010
+8010
+8010
 ENDCHAR
-STARTCHAR C109
-ENCODING 9376
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2313
+ENCODING 8979
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 7 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-81C080
-822080
-83E080
-820080
-820080
-822080
-41C100
-400100
-200200
-100400
+0F00
+30C0
+4020
+4020
+8010
+8010
+FFF0
 ENDCHAR
-STARTCHAR C109
-ENCODING 9377
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2314
+ENCODING 8980
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 7 2 0
 BITMAP
-10E400
-212200
-410100
-410100
-810080
-83C080
-810080
-810080
-810080
-810080
-810080
-438100
-400100
-200200
-100400
+3E00
+4100
+8080
+4100
+2200
+1400
+0800
 ENDCHAR
-STARTCHAR C109
-ENCODING 9378
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 16 1 -4
+STARTCHAR uni2315
+ENCODING 8981
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 10 10 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-81F080
-822080
-822080
-822080
-83C080
-820080
-43E100
-441100
-241200
-141400
-03E000
+0F00
+1080
+2040
+2040
+2040
+2040
+1080
+2F00
+4000
+8000
 ENDCHAR
-STARTCHAR C109
-ENCODING 9379
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2316
+ENCODING 8982
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 13 2 0
 BITMAP
-160400
-220200
-420100
-420100
-820080
-83C080
-822080
-822080
-822080
-822080
-822080
-477100
-400100
-200200
-100400
+0400
+0400
+0400
+0E00
+1500
+2480
+FFE0
+2480
+1500
+0E00
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR 0x24A4
-ENCODING 9380
+STARTCHAR uni2317
+ENCODING 8983
 SWIDTH 1080 0
 DWIDTH 18 0
-BBX 17 15 1 -3
+BBX 15 15 2 -2
 BITMAP
-100400
-218200
-418100
-400100
-800080
-818080
-808080
-808080
-808080
-808080
-808080
-41C100
-400100
-200200
-100400
+0820
+0820
+0820
+0820
+FFFE
+0820
+0820
+0820
+0820
+0820
+FFFE
+0820
+0820
+0820
+0820
 ENDCHAR
-STARTCHAR 0x24A5
-ENCODING 9381
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2318
+ENCODING 8984
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 10 2 1
 BITMAP
-100400
-20C200
-40C100
-400100
-800080
-80C080
-804080
-804080
-804080
-804080
-804080
-404100
-404100
-224200
-138400
+60C0
+9120
+9120
+7FC0
+1100
+1100
+7FC0
+9120
+9120
+60C0
 ENDCHAR
-STARTCHAR C109
-ENCODING 9382
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2319
+ENCODING 8985
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 4 2 2
 BITMAP
-160400
-220200
-420100
-420100
-820080
-82F080
-824080
-828080
-838080
-82C080
-824080
-477100
-400100
-200200
-100400
+80
+80
+80
+FC
 ENDCHAR
-STARTCHAR C109
-ENCODING 9383
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni231A
+ENCODING 8986
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 0
 BITMAP
-118400
-208200
-408100
-408100
-808080
-808080
-808080
-808080
-808080
-808080
-808080
-41C100
-400100
-200200
-100400
+0F80
+1FC0
+2020
+4210
+8048
+8088
+8108
+AE28
+8008
+8008
+8008
+4210
+2020
+1FC0
+0F80
 ENDCHAR
-STARTCHAR C109
-ENCODING 9384
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni231B
+ENCODING 8987
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 13 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-9F7080
-888880
-888880
-888880
-888880
-888880
-5DDD00
-400100
-200200
-100400
+FF80
+4100
+4100
+4100
+4100
+2200
+1400
+2A00
+4100
+5D00
+4100
+5D00
+FF80
 ENDCHAR
-STARTCHAR C109
-ENCODING 9385
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni231C
+ENCODING 8988
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 6
 BITMAP
-100400
-200200
-400100
-400100
-800080
-87C080
-822080
-822080
-822080
-822080
-822080
-477100
-400100
-200200
-100400
+FC
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C109
-ENCODING 9386
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni231D
+ENCODING 8989
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 6
 BITMAP
-100400
-200200
-400100
-400100
-800080
-81C080
-822080
-822080
-822080
-822080
-822080
-41C100
-400100
-200200
-100400
+FC
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR C109
-ENCODING 9387
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni231E
+ENCODING 8990
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-87C080
-822080
-822080
-822080
-822080
-822080
-43C100
-420100
-220200
-170400
+80
+80
+80
+80
+80
+FC
 ENDCHAR
-STARTCHAR C109
-ENCODING 9388
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni231F
+ENCODING 8991
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 6 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-83C080
-844080
-844080
-844080
-844080
-844080
-43C100
-404100
-204200
-10E400
+04
+04
+04
+04
+04
+FC
 ENDCHAR
-STARTCHAR C109
-ENCODING 9389
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2320
+ENCODING 8992
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 10 2 5
 BITMAP
-100400
-200200
-400100
-400100
-800080
-834080
-81A080
-810080
-810080
-810080
-810080
-43C100
-400100
-200200
-100400
+70
+90
+80
+80
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR C109
-ENCODING 9390
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2321
+ENCODING 8993
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 10 2 5
 BITMAP
-100400
-200200
-400100
-400100
-800080
-81E080
-822080
-820080
-81C080
-802080
-822080
-43C100
-400100
-200200
-100400
+10
+10
+10
+10
+10
+10
+10
+10
+90
+E0
 ENDCHAR
-STARTCHAR C109
-ENCODING 9391
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2322
+ENCODING 8994
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 4 2 3
 BITMAP
-100400
-200200
-410100
-410100
-830080
-87C080
-810080
-810080
-810080
-812080
-812080
-40C100
-400100
-200200
-100400
+0F00
+30C0
+4020
+8010
 ENDCHAR
-STARTCHAR C109
-ENCODING 9392
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2323
+ENCODING 8995
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 4 2 3
 BITMAP
-100400
-200200
-400100
-400100
-800080
-866080
-822080
-822080
-822080
-822080
-822080
-41F100
-400100
-200200
-100400
+8010
+4020
+30C0
+0F00
 ENDCHAR
-STARTCHAR C109
-ENCODING 9393
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2324
+ENCODING 8996
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 7 2 3
 BITMAP
-100400
-200200
-400100
-400100
-800080
-8E7080
-824080
-824080
-824080
-818080
-818080
-418100
-400100
-200200
-100400
+F278
+0500
+0500
+0880
+0880
+1040
+1040
 ENDCHAR
-STARTCHAR C119
-ENCODING 9394
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2325
+ENCODING 8997
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 7 2 3
 BITMAP
-100400
-200200
-400100
-400100
-800080
-9DDC80
-849080
-855080
-855080
-855080
-836080
-422100
-400100
-200200
-100400
+F1E0
+0800
+0800
+0400
+0400
+0200
+03E0
 ENDCHAR
-STARTCHAR C109
-ENCODING 9395
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2326
+ENCODING 8998
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 18 13 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-8E7080
-824080
-818080
-818080
-818080
-824080
-4E7100
-400100
-200200
-100400
+FFF000
+904800
+888400
+888200
+850100
+850080
+820040
+850080
+850100
+888200
+888400
+904800
+FFF000
 ENDCHAR
-STARTCHAR C109
-ENCODING 9396
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2327
+ENCODING 8999
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 13 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-873880
-812080
-812080
-812080
-80C080
-80C080
-40C100
-408100
-248200
-170400
+FFF0
+9050
+8890
+8890
+8510
+8510
+8210
+8510
+8510
+8890
+8890
+9050
+FFF0
 ENDCHAR
-STARTCHAR C109
-ENCODING 9397
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -3
+STARTCHAR uni2328
+ENCODING 9000
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 19 14 2 0
 BITMAP
-100400
-200200
-400100
-400100
-800080
-83E080
-824080
-824080
-808080
-812080
-812080
-43E100
-400100
-200200
-100400
+FFFFE0
+800020
+924920
+924920
+800020
+924920
+924920
+800020
+924920
+924920
+800020
+83F820
+800020
+FFFFE0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9398
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2329
+ENCODING 9001
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 17 1 -3
 BITMAP
-07F000
-180C00
-200200
-408100
-408100
-814080
-814080
-814080
-822080
-822080
-83E080
-841080
-441100
-5E3D00
-200200
-180C00
-07F000
+08
+08
+10
+10
+20
+20
+40
+40
+80
+40
+40
+20
+20
+10
+10
+08
+08
 ENDCHAR
-STARTCHAR C040
-ENCODING 9399
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni232A
+ENCODING 9002
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 17 1 -3
 BITMAP
-07F000
-180C00
-200200
-5FE100
-441100
-840880
-840880
-841080
-87E080
-841080
-840880
-840880
-441100
-5FE100
-200200
-180C00
-07F000
+80
+80
+40
+40
+20
+20
+10
+10
+08
+10
+10
+20
+20
+40
+40
+80
+80
 ENDCHAR
-STARTCHAR C040
-ENCODING 9400
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni232B
+ENCODING 9003
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 18 13 2 0
 BITMAP
-07F000
-180C00
-200200
-41E900
-421900
-840880
-880880
-880080
-880080
-880080
-880880
-840880
-421100
-41E100
-200200
-180C00
-07F000
+03FFC0
+048240
+084440
+104440
+202840
+402840
+801040
+402840
+202840
+104440
+084440
+048240
+03FFC0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9401
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni232C
+ENCODING 9004
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 14 2 1
 BITMAP
-07F000
-180C00
-200200
-5FC100
-443100
-841080
-840880
-840880
-840880
-840880
-840880
-841080
-443100
-5FC100
-200200
-180C00
-07F000
+0200
+0D80
+3060
+C218
+8188
+9048
+9008
+9008
+9048
+8188
+C218
+3060
+0D80
+0200
 ENDCHAR
-STARTCHAR C040
-ENCODING 9402
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni232D
+ENCODING 9005
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 2
 BITMAP
-07F000
-180C00
-200200
-5FF100
-441100
-841080
-845080
-844080
-87C080
-844880
-844880
-841080
-441100
-5FF100
-200200
-180C00
-07F000
+0804
+0804
+1708
+1888
+3050
+3050
+5060
+48A0
+8740
+8040
 ENDCHAR
-STARTCHAR C040
-ENCODING 9403
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni232E
+ENCODING 9006
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 9 2 1
 BITMAP
-07F000
-180C00
-200200
-4FF900
-420900
-820880
-822880
-822080
-83E080
-822080
-822080
-820080
-420100
-4F8100
-200200
-180C00
-07F000
+0E00
+1100
+2080
+27E0
+2880
+1100
+2E00
+C000
+C000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9404
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni232F
+ENCODING 9007
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 8 7 2 3
 BITMAP
-07F000
-180C00
-200200
-43D100
-443100
-881080
-901080
-900080
-900080
-907880
-901080
-881080
-441100
-43F100
-200200
-180C00
-07F000
+3C
+00
+00
+FF
+00
+00
+3C
 ENDCHAR
-STARTCHAR C040
-ENCODING 9405
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2330
+ENCODING 9008
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 12 2 0
 BITMAP
-07F000
-180C00
-200200
-5F7D00
-441100
-841080
-841080
-841080
-87F080
-841080
-841080
-841080
-441100
-5F7D00
-200200
-180C00
-07F000
+0E70
+0630
+0A50
+0840
+1080
+1080
+2100
+2100
+4200
+4200
+8400
+FC00
 ENDCHAR
-STARTCHAR C040
-ENCODING 9406
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2331
+ENCODING 9009
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 11 2 1
 BITMAP
-07F000
-180C00
-200200
-43E100
-408100
-808080
-808080
-808080
-808080
-808080
-808080
-808080
-408100
-43E100
-200200
-180C00
-07F000
+1000
+1000
+3800
+5400
+9220
+FFF0
+9220
+5400
+3800
+1000
+1000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9407
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2332
+ENCODING 9010
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 11 2 1
 BITMAP
-07F000
-180C00
-200200
-41F100
-404100
-804080
-804080
-804080
-804080
-804080
-804080
-804080
-424100
-438100
-200200
-180C00
-07F000
-ENDCHAR
-STARTCHAR C040
-ENCODING 9408
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
-BITMAP
-07F000
-180C00
-200200
-5F3D00
-441100
-842080
-844080
-848080
-85C080
-864080
-842080
-842080
-441100
-5F3D00
-200200
-180C00
-07F000
+C000
+B000
+8C00
+8300
+80C0
+FFF0
+80C0
+8300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9409
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2333
+ENCODING 9011
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 6 2 6
 BITMAP
-07F000
-180C00
-200200
-47C100
-410100
-810080
-810080
-810080
-810080
-810880
-810880
-810880
-411900
-47F900
-200200
-180C00
-07F000
+C000
+B000
+8C00
+8300
+80C0
+FFF0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9410
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2334
+ENCODING 9012
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 8 2 0
 BITMAP
-07F000
-180C00
-200200
-5C1D00
-4C1900
-8C1880
-8A2880
-8A2880
-8A4880
-894880
-894880
-888880
-488900
-5C9D00
-200200
-180C00
-07F000
+8020
+8020
+8020
+8020
+8020
+8020
+8020
+FFE0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9411
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2335
+ENCODING 9013
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 8 2 0
 BITMAP
-07F000
-180C00
-200200
-5C7D00
-461100
-861080
-851080
-851080
-849080
-845080
-845080
-843080
-443100
-5F1100
-200200
-180C00
-07F000
+8080
+8080
+4100
+4100
+2200
+2200
+1400
+0800
 ENDCHAR
-STARTCHAR C040
-ENCODING 9412
-SWIDTH 2100 0
-DWIDTH 35 0
-BBX 17 17 1 -3
+STARTCHAR uni2336
+ENCODING 9014
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 15 2 0
 BITMAP
-07F000
-180C00
-200200
-43C100
-442100
-881080
-900880
-900880
-900880
-900880
-900880
-881080
-442100
-43C100
-200200
-180C00
-07F000
+FFE0
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+FFE0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9413
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2337
+ENCODING 9015
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 15 2 0
 BITMAP
-07F000
-180C00
-200200
-4FF100
-421900
-820880
-820880
-821880
-83F080
-820080
-820080
-820080
-420100
-4F8100
-200200
-180C00
-07F000
+FC
+84
+84
+84
+84
+84
+84
+84
+84
+84
+84
+84
+84
+84
+FC
 ENDCHAR
-STARTCHAR C040
-ENCODING 9414
+STARTCHAR uni2338
+ENCODING 9016
 SWIDTH 1080 0
 DWIDTH 18 0
-BBX 17 17 1 -3
+BBX 15 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-43C100
-442100
-881080
-900880
-900880
-900880
-900880
-900880
-8B9080
-466100
-43C100
-204A00
-183C00
-07F000
+FFFE
+8002
+8002
+8002
+8002
+8002
+8002
+8002
+BFFA
+8002
+8002
+8002
+BFFA
+8002
+8002
+8002
+FFFE
 ENDCHAR
-STARTCHAR C040
-ENCODING 9415
+STARTCHAR uni2339
+ENCODING 9017
 SWIDTH 1080 0
 DWIDTH 18 0
-BBX 17 17 1 -3
+BBX 15 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-4FE100
-421100
-820880
-820880
-821080
-83E080
-823080
-821080
-821080
-421100
-4F8F00
-200200
-180C00
-07F000
+FFFE
+8002
+8002
+8002
+8002
+8002
+8302
+8782
+8302
+8002
+BFFA
+8002
+8302
+8782
+8302
+8002
+FFFE
 ENDCHAR
-STARTCHAR C040
-ENCODING 9416
+STARTCHAR uni233A
+ENCODING 9018
 SWIDTH 1080 0
 DWIDTH 18 0
-BBX 17 17 1 -3
+BBX 15 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-43E100
-442100
-842080
-840080
-820080
-818080
-804080
-802080
-842080
-442100
-47C100
-200200
-180C00
-07F000
+FFFE
+8002
+8102
+8282
+8442
+8822
+9012
+A00A
+C006
+A00A
+9012
+8822
+8442
+8282
+8102
+8002
+FFFE
 ENDCHAR
-STARTCHAR C040
-ENCODING 9417
+STARTCHAR uni233B
+ENCODING 9019
 SWIDTH 1080 0
 DWIDTH 18 0
-BBX 17 17 1 -3
+BBX 15 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-4FF900
-488900
-888880
-888880
-808080
-808080
-808080
-808080
-808080
-408100
-43E100
-200200
-180C00
-07F000
+FFFE
+8002
+8002
+8002
+8002
+8382
+8442
+8822
+8822
+8822
+8442
+8382
+8002
+8002
+8002
+8002
+FFFE
 ENDCHAR
-STARTCHAR C040
-ENCODING 9418
+STARTCHAR uni233C
+ENCODING 9020
 SWIDTH 1080 0
 DWIDTH 18 0
-BBX 17 17 1 -3
+BBX 15 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-5F7D00
-441100
-841080
-841080
-841080
-841080
-841080
-841080
-841080
-422100
-41C100
-200200
-180C00
-07F000
+FFFE
+8002
+8382
+8C62
+9012
+A00A
+A00A
+C006
+C006
+C006
+A00A
+A00A
+9012
+8C62
+8382
+8002
+FFFE
 ENDCHAR
-STARTCHAR C040
-ENCODING 9419
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni233D
+ENCODING 9021
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 -1
 BITMAP
-07F000
-180C00
-200200
-5E3D00
-441100
-841080
-822080
-822080
-822080
-814080
-814080
-814080
-408100
-408100
-200200
-180C00
-07F000
+0200
+0700
+1AC0
+2220
+4210
+4210
+8208
+8208
+8208
+4210
+4210
+2220
+1AC0
+0700
+0200
 ENDCHAR
-STARTCHAR C040
-ENCODING 9420
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni233E
+ENCODING 9022
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-07F000
-180C00
-200200
-400100
-788F00
-908480
-908480
-914480
-894880
-894880
-894880
-8A2880
-463100
-463100
-241200
-180C00
-07F000
+0700
+18C0
+2020
+4710
+4890
+9048
+9048
+9048
+4890
+4710
+2020
+18C0
+0700
 ENDCHAR
-STARTCHAR C040
-ENCODING 9421
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni233F
+ENCODING 9023
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-5E7900
-422100
-824080
-814080
-818080
-808080
-814080
-834080
-822080
-441100
-5E3D00
-200200
-180C00
-07F000
+0040
+0040
+0080
+0080
+0100
+0100
+0200
+0200
+FFF0
+0400
+0400
+0800
+0800
+1000
+1000
+2000
+2000
 ENDCHAR
-STARTCHAR C040
-ENCODING 9422
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2340
+ENCODING 9024
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-5E3D00
-441100
-822080
-822080
-814080
-81C080
-808080
-808080
-808080
-408100
-43E100
-200200
-180C00
-07F000
+2000
+2000
+1000
+1000
+0800
+0800
+0400
+0400
+FFF0
+0200
+0200
+0100
+0100
+0080
+0080
+0040
+0040
 ENDCHAR
-STARTCHAR C040
-ENCODING 9423
-SWIDTH 2100 0
-DWIDTH 35 0
-BBX 17 17 1 -3
+STARTCHAR uni2341
+ENCODING 9025
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-47F100
-462100
-842080
-844080
-804080
-808080
-811080
-811080
-821080
-423100
-47F100
-200200
-180C00
-07F000
+FFF8
+8018
+8028
+8048
+8048
+8088
+8108
+8108
+8208
+8408
+8408
+8808
+9008
+9008
+A008
+C008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9424
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2342
+ENCODING 9026
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-838080
-844080
-804080
-83C080
-844080
-844080
-83E080
-400100
-400100
-200200
-180C00
-07F000
+FFF8
+C008
+A008
+9008
+9008
+8808
+8408
+8408
+8208
+8108
+8108
+8088
+8048
+8048
+8028
+8018
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9425
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2343
+ENCODING 9027
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-230200
-410100
-410100
-810080
-810080
-81E080
-811080
-811080
-811080
-811080
-411100
-41E100
-200200
-180C00
-07F000
+FFF8
+8008
+8008
+8008
+8038
+81C8
+8608
+B808
+C008
+B808
+8608
+81C8
+8038
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9426
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2344
+ENCODING 9028
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-81C080
-822080
-820080
-820080
-820080
-822080
-81C080
-400100
-400100
-200200
-180C00
-07F000
+FFF8
+8008
+8008
+8008
+E008
+9C08
+8308
+80E8
+8018
+80E8
+8308
+9C08
+E008
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9427
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2345
+ENCODING 9029
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-20C200
-404100
-404100
-804080
-804080
-83C080
-844080
-844080
-844080
-844080
-444100
-43E100
-200200
-180C00
-07F000
+0200
+0200
+0200
+0200
+0200
+0200
+2200
+4200
+FFF8
+4200
+2200
+0200
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR C040
-ENCODING 9428
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2346
+ENCODING 9030
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-81C080
-822080
-83E080
-820080
-820080
-822080
-81C080
-400100
-400100
-200200
-180C00
-07F000
+0200
+0200
+0200
+0200
+0200
+0200
+0220
+0210
+FFF8
+0210
+0220
+0200
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR C040
-ENCODING 9429
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2347
+ENCODING 9031
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-20E200
-412100
-410100
-810080
-810080
-83C080
-810080
-810080
-810080
-810080
-410100
-438100
-200200
-180C00
-07F000
+FFF8
+8008
+8008
+8008
+8008
+8008
+9008
+A008
+FFF8
+A008
+9008
+8008
+8008
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9430
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2348
+ENCODING 9032
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-41F100
-422100
-822080
-822080
-83C080
-820080
-83E080
-841080
-841080
-441100
-43E100
-200200
-180C00
-07F000
+FFF8
+8008
+8008
+8008
+8008
+8008
+8048
+8028
+FFF8
+8028
+8048
+8008
+8008
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9431
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2349
+ENCODING 9033
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-260200
-420100
-420100
-820080
-820080
-83C080
-822080
-822080
-822080
-822080
-422100
-477100
-200200
-180C00
-07F000
+2000
+2000
+1700
+18C0
+2820
+4810
+4410
+8408
+8208
+8108
+4110
+4090
+20A0
+18C0
+0740
+0020
+0020
 ENDCHAR
-STARTCHAR 0x24D8
-ENCODING 9432
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni234A
+ENCODING 9034
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-418100
-418100
-800080
-800080
-818080
-808080
-808080
-808080
-808080
-408100
-41C100
-200200
-180C00
-07F000
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+FFE0
+0000
+FFE0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9433
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni234B
+ENCODING 9035
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 11 17 2 -2
 BITMAP
-07F000
-180C00
-20C200
-40C100
-400100
-800080
-80C080
-804080
-804080
-804080
-804080
-804080
-404100
-424100
-238200
-180C00
-07F000
+0400
+0400
+0400
+0400
+0E00
+0E00
+1700
+1500
+2580
+2480
+44C0
+4440
+8460
+FFE0
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR C040
-ENCODING 9434
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni234C
+ENCODING 9036
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-260200
-420100
-420100
-820080
-820080
-82F080
-824080
-828080
-838080
-82C080
-424100
-477100
-200200
-180C00
-07F000
+FFF8
+8008
+8008
+8008
+C018
+C018
+A028
+A028
+9048
+9048
+8888
+8888
+8508
+8508
+8208
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9435
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni234D
+ENCODING 9037
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-218200
-408100
-408100
-808080
-808080
-808080
-808080
-808080
-808080
-808080
-408100
-41C100
-200200
-180C00
-07F000
+FFF8
+8008
+8008
+8208
+8208
+8708
+8508
+8988
+8888
+90C8
+9048
+A068
+A028
+C038
+FFF8
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9436
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni234E
+ENCODING 9038
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 15 2 0
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-9F7080
-888880
-888880
-888880
-888880
-888880
-9DDC80
-400100
-400100
-200200
-180C00
-07F000
-ENDCHAR
-STARTCHAR C040
-ENCODING 9437
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
-BITMAP
-07F000
-180C00
-200200
-400100
-400100
-87C080
-822080
-822080
-822080
-822080
-822080
-877080
-400100
-400100
-200200
-180C00
-07F000
-ENDCHAR
-STARTCHAR C040
-ENCODING 9438
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
-BITMAP
-07F000
-180C00
-200200
-400100
-400100
-81C080
-822080
-822080
-822080
-822080
-822080
-81C080
-400100
-400100
-200200
-180C00
-07F000
+0400
+0400
+0400
+0400
+0400
+0E00
+1500
+1500
+1500
+0E00
+0400
+0400
+0400
+0400
+FFE0
 ENDCHAR
-STARTCHAR C040
-ENCODING 9439
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni234F
+ENCODING 9039
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-47C100
-822080
-822080
-822080
-822080
-822080
-83C080
-820080
-420100
-470100
-200200
-180C00
-07F000
+0200
+0700
+0A80
+0200
+0200
+0200
+0200
+0200
+FFF8
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR C040
-ENCODING 9440
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2350
+ENCODING 9040
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-43C100
-844080
-844080
-844080
-844080
-844080
-83C080
-804080
-404100
-40E100
-200200
-180C00
-07F000
+FFF8
+8208
+8708
+8A88
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9441
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2351
+ENCODING 9041
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-834080
-81A080
-810080
-810080
-810080
-810080
-83C080
-400100
-400100
-200200
-180C00
-07F000
+FFE0
+0000
+FFE0
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR C040
-ENCODING 9442
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2352
+ENCODING 9042
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 11 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-81E080
-822080
-820080
-81C080
-802080
-822080
-83C080
-400100
-400100
-200200
-180C00
-07F000
+0400
+0400
+0400
+FFE0
+8460
+4440
+44C0
+2480
+2580
+1500
+1700
+0E00
+0E00
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR C040
-ENCODING 9443
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2353
+ENCODING 9043
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-410100
-410100
-830080
-87C080
-810080
-810080
-810080
-812080
-812080
-40C100
-400100
-200200
-180C00
-07F000
+FFF8
+8008
+8208
+8508
+8508
+8888
+8888
+9048
+9048
+A028
+A028
+C018
+C018
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9444
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2354
+ENCODING 9044
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-866080
-822080
-822080
-822080
-822080
-822080
-81F080
-400100
-400100
-200200
-180C00
-07F000
+FFF8
+8008
+FFF8
+C038
+A028
+A068
+9048
+90C8
+8888
+8988
+8508
+8708
+8208
+8208
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9445
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2355
+ENCODING 9045
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 15 2 0
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-873880
-812080
-812080
-812080
-80C080
-80C080
-80C080
-400100
-400100
-200200
-180C00
-07F000
+FFE0
+0400
+0400
+0400
+0400
+0E00
+1500
+1500
+1500
+0E00
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR C040
-ENCODING 9446
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2356
+ENCODING 9046
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-9DDC80
-849080
-855080
-855080
-855080
-836080
-822080
-400100
-400100
-200200
-180C00
-07F000
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+FFF8
+0200
+0200
+0200
+0200
+0200
+0A80
+0700
+0200
 ENDCHAR
-STARTCHAR C040
-ENCODING 9447
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2357
+ENCODING 9047
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-8E7080
-824080
-818080
-818080
-818080
-824080
-8E7080
-400100
-400100
-200200
-180C00
-07F000
+FFF8
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8A88
+8708
+8208
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9448
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2358
+ENCODING 9048
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 7 16 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-473900
-812080
-812080
-812080
-80C080
-80C080
-80C080
-808080
-448100
-470100
-200200
-180C00
-07F000
+10
+10
+10
+10
+10
+00
+00
+00
+00
+00
+00
+00
+00
+00
+00
+FE
 ENDCHAR
-STARTCHAR C040
-ENCODING 9449
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni2359
+ENCODING 9049
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 14 2 -2
 BITMAP
-07F000
-180C00
-200200
-400100
-400100
-83E080
-824080
-824080
-808080
-812080
-812080
-83E080
-400100
-400100
-200200
-180C00
-07F000
+0200
+0200
+0700
+0500
+0980
+0880
+10C0
+1040
+2060
+2020
+4030
+FFF8
+0000
+FFF8
 ENDCHAR
-STARTCHAR C040
-ENCODING 9450
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 17 1 -3
+STARTCHAR uni235A
+ENCODING 9050
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 -1
 BITMAP
-07F000
-180C00
-200200
-41C100
-414100
-822080
-822080
-822080
-822080
-822080
-822080
-822080
-414100
-41C100
-200200
-180C00
-07F000
+0200
+0500
+0880
+1040
+2020
+4010
+8008
+4010
+2020
+1040
+0880
+0500
+0200
+0000
+FFF8
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9632
+STARTCHAR uni235B
+ENCODING 9051
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 9 1 1
+BBX 7 12 2 -2
 BITMAP
-FF80
-FF80
-FF80
-FF80
-FF80
-FF80
-FF80
-FF80
-FF80
+38
+44
+82
+82
+82
+44
+38
+00
+00
+00
+00
+FE
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9633
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni235C
+ENCODING 9052
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 -2
 BITMAP
-FF80
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-FF80
+0700
+18C0
+2020
+4010
+4010
+8008
+8008
+8008
+4010
+4010
+2020
+18C0
+0700
+0000
+FFF8
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9634
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni235D
+ENCODING 9053
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 0
 BITMAP
-7F00
-8080
-8080
-8080
-8080
-8080
-8080
-8080
-7F00
+1FC0
+6030
+4010
+8008
+8008
+8708
+8888
+9048
+9048
+9048
+8888
+8708
+8008
+8008
+8008
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9635
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni235E
+ENCODING 9054
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-FF80
-8080
-BE80
-BE80
-BE80
-BE80
-BE80
-8080
-FF80
+FFF8
+8008
+8208
+8208
+8208
+8208
+8208
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9636
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni235F
+ENCODING 9055
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 2 0
 BITMAP
-FF80
-8080
-FF80
-8080
-FF80
-8080
-FF80
-8080
-FF80
+07C0
+1830
+2008
+4104
+4104
+8382
+9FF2
+87C2
+8382
+87C2
+4444
+4824
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9637
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2360
+ENCODING 9056
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-FF80
-AA80
-AA80
-AA80
-AA80
-AA80
-AA80
-AA80
-FF80
+FFF8
+8008
+8008
+8208
+8708
+8708
+8208
+8008
+8008
+8008
+8208
+8708
+8708
+8208
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9638
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2361
+ENCODING 9057
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 18 2 -2
 BITMAP
-FF80
-AA80
-FF80
-AA80
-FF80
-AA80
-FF80
-AA80
-FF80
+3180
+3180
+0000
+FFE0
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9639
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2362
+ENCODING 9058
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 0
 BITMAP
-FF80
-9280
-C980
-A480
-9280
-C980
-A480
-9280
-FF80
+18C0
+18C0
+0000
+FFF8
+4030
+2020
+2060
+1040
+10C0
+0880
+0980
+0500
+0700
+0200
+0200
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9640
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2363
+ENCODING 9059
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 12 3 3
 BITMAP
-FF80
-A480
-C980
-9280
-A480
-C980
-9280
-A480
+6300
+6300
+0000
+0800
+0800
+1C00
 FF80
+3E00
+1C00
+3E00
+2200
+4100
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9641
+STARTCHAR uni2364
+ENCODING 9060
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 9 1 1
-BITMAP
-FF80
-D580
-AA80
-D580
-AA80
-D580
-AA80
-D580
-FF80
-ENDCHAR
-STARTCHAR char9632
-ENCODING 9642
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 3 3
-BITMAP
-F8
-F8
-F8
-F8
-F8
-ENDCHAR
-STARTCHAR char9632
-ENCODING 9643
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 3 3
-BITMAP
-F8
-88
-88
-88
-F8
-ENDCHAR
-STARTCHAR char9632
-ENCODING 9644
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 5 1 3
-BITMAP
-FFC0
-FFC0
-FFC0
-FFC0
-FFC0
-ENDCHAR
-STARTCHAR char9632
-ENCODING 9645
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 5 1 3
+BBX 7 11 2 4
 BITMAP
-FFC0
-8040
-8040
-8040
-FFC0
+C6
+C6
+00
+00
+38
+44
+82
+82
+82
+44
+38
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9646
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 0
+STARTCHAR uni2365
+ENCODING 9061
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 16 2 0
 BITMAP
-F8
-F8
-F8
-F8
-F8
-F8
-F8
-F8
-F8
-F8
+18C0
+18C0
+0000
+0700
+18C0
+2020
+4010
+4010
+8008
+8008
+8008
+4010
+4010
+2020
+18C0
+0700
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9647
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 0
+STARTCHAR uni2366
+ENCODING 9062
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-F8
-88
-88
-88
-88
-88
-88
-88
-88
-F8
+0200
+0200
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+4210
+6230
+1FC0
+0200
+0200
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9648
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 5 1 3
+STARTCHAR uni2367
+ENCODING 9063
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-1FF0
-3FE0
-7FE0
-7FC0
-FF80
+0100
+0100
+1FF8
+6100
+4100
+8100
+8100
+8100
+8100
+8100
+8100
+8100
+4100
+6100
+1FF8
+0100
+0100
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9649
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 12 5 1 3
+STARTCHAR uni2368
+ENCODING 9064
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 8 2 7
 BITMAP
-1FF0
-2010
-4020
-8040
-FF80
+3180
+3180
+0000
+0000
+0000
+7820
+8420
+83C0
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9650
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 1
+STARTCHAR uni2369
+ENCODING 9065
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 2
 BITMAP
-0800
-0800
+3180
+3180
+0000
+0000
+E000
 1C00
+0300
+00E0
+0018
+00E0
+0300
 1C00
-3E00
-3E00
-7F00
-7F00
-FF80
-FF80
+E000
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9651
+STARTCHAR uni236A
+ENCODING 9066
 SWIDTH 600 0
 DWIDTH 10 0
-BBX 9 10 1 1
-BITMAP
-0800
-0800
-1400
-1400
-2200
-2200
-4100
-4100
-8080
-FF80
-ENDCHAR
-STARTCHAR char9650
-ENCODING 9652
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+BBX 7 9 2 4
 BITMAP
+FE
+00
 10
 38
 38
-7C
-7C
-FE
-FE
+18
+08
+10
+20
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9653
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni236B
+ENCODING 9067
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 12 2 0
 BITMAP
-10
-28
-28
-44
-44
-82
-FE
+FFF8
+4030
+2020
+2060
+1040
+38D0
+4F90
+48E0
+0500
+0700
+0200
+0200
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9654
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 9 1 1
+STARTCHAR uni236C
+ENCODING 9068
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 13 2 0
 BITMAP
-C000
-F000
-FC00
-FF00
-FFC0
-FF00
-FC00
-F000
-C000
+0E00
+1100
+2080
+2080
+2080
+70A0
+AEA0
+A1C0
+2080
+2080
+2080
+1100
+0E00
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9655
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 9 1 1
+STARTCHAR uni236D
+ENCODING 9069
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 17 2 -2
 BITMAP
-C000
-B000
-8C00
-8300
-80C0
-8300
-8C00
-B000
-C000
+0400
+0400
+0400
+0400
+0400
+0400
+7420
+8E20
+85C0
+0400
+0400
+0400
+0400
+0400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9656
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni236E
+ENCODING 9070
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 -2
 BITMAP
-C0
-F0
-FC
+10
+38
+38
+10
+00
+00
+10
+38
+38
+18
 FE
-FC
-F0
-C0
+10
+20
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9657
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni236F
+ENCODING 9071
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 18 2 -3
 BITMAP
-C0
-B0
-8C
-82
-8C
-B0
-C0
+FFFE
+8002
+8002
+8002
+8002
+8002
+8002
+8042
+8042
+9FF2
+8082
+8102
+8102
+9FF2
+8202
+8402
+8002
+FFFE
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9658
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 5 1 3
+STARTCHAR uni2370
+ENCODING 9072
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 18 2 -3
 BITMAP
-F000
-FF00
-FFC0
-FF00
-F000
+FFFE
+8002
+8782
+8CC2
+8842
+8842
+80C2
+8182
+8102
+8302
+8302
+8302
+8002
+8002
+8302
+8302
+8002
+FFFE
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9659
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 5 1 3
+STARTCHAR uni2371
+ENCODING 9073
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 15 2 0
 BITMAP
-F000
-8F00
-80C0
-8F00
-F000
+8002
+8002
+4004
+4004
+2008
+2008
+1010
+1E18
+2928
+28F0
+0440
+0440
+0280
+0280
+0100
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9660
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 1
+STARTCHAR uni2372
+ENCODING 9074
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 15 2 0
 BITMAP
-FF80
-FF80
-7F00
-7F00
-3E00
-3E00
-1C00
-1C00
-0800
-0800
+0100
+0280
+0280
+0440
+0440
+28F0
+2928
+1E18
+1010
+2008
+2008
+4004
+4004
+8002
+8002
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9661
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 1
+STARTCHAR uni2373
+ENCODING 9075
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 9 2 0
 BITMAP
-FF80
-8080
-4100
-4100
-2200
-2200
-1400
-1400
-0800
-0800
+40
+C0
+40
+40
+40
+40
+40
+48
+30
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9662
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni2374
+ENCODING 9076
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 13 2 -4
 BITMAP
-FE
-FE
-7C
-7C
-38
 38
-10
-ENDCHAR
-STARTCHAR char9650
-ENCODING 9663
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
-BITMAP
-FE
-82
-44
 44
-28
-28
-10
-ENDCHAR
-STARTCHAR char9650
-ENCODING 9664
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 9 1 1
-BITMAP
-00C0
-03C0
-0FC0
-3FC0
-FFC0
-3FC0
-0FC0
-03C0
-00C0
+82
+82
+82
+82
+82
+C4
+B8
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9665
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 9 1 1
+STARTCHAR uni2375
+ENCODING 9077
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 9 2 0
 BITMAP
-00C0
-0340
-0C40
-3040
-C040
-3040
-0C40
-0340
-00C0
+2020
+4010
+8008
+8208
+8208
+8208
+8208
+4510
+38E0
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9666
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni2376
+ENCODING 9078
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 10 9 2 0
 BITMAP
-06
-1E
-7E
-FE
-7E
-1E
-06
+3880
+4480
+8500
+8300
+8200
+8200
+8200
+4640
+3980
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9667
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni2377
+ENCODING 9079
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 11 2 -2
 BITMAP
-06
-1A
-62
-82
-62
-1A
-06
+78
+84
+80
+80
+60
+80
+80
+84
+78
+00
+FC
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9668
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 5 1 3
+STARTCHAR uni2378
+ENCODING 9080
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 11 2 -2
 BITMAP
-03C0
-3FC0
-FFC0
-3FC0
-03C0
+40
+C0
+40
+40
+40
+40
+40
+48
+30
+00
+F8
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9669
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 5 1 3
+STARTCHAR uni2379
+ENCODING 9081
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 11 2 -2
 BITMAP
-03C0
-3C40
-C040
-3C40
-03C0
+2020
+4010
+8008
+8208
+8208
+8208
+8208
+4510
+38E0
+0000
+FFF8
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9670
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni237A
+ENCODING 9082
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 10 9 2 0
 BITMAP
-0800
-1C00
-3E00
-7F00
-FF80
-7F00
-3E00
-1C00
-0800
+3880
+4480
+8500
+8300
+8200
+8200
+8200
+4640
+3980
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9671
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni237B
+ENCODING 9083
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 0
 BITMAP
-0800
-1400
-2200
-4100
+0010
+0010
+0020
+0020
+01F8
+0040
+8080
 8080
 4100
+4100
+2200
 2200
 1400
+1400
 0800
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9672
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni237D
+ENCODING 9085
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 6 2 0
 BITMAP
-0800
-1400
-2A00
-5D00
-BE80
-5D00
-2A00
-1400
-0800
+F01E
+1010
+1010
+1010
+1010
+1FF0
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9673
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni237E
+ENCODING 9086
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 12 2 0
 BITMAP
-3E00
-4100
-9C80
-BE80
-BE80
-BE80
-9C80
-4100
-3E00
+0F00
+30C0
+4020
+4020
+8010
+8010
+FFF0
+1080
+1080
+1080
+1080
+F0F0
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9674
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 12 1 0
+STARTCHAR uni237F
+ENCODING 9087
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 3 12 2 0
 BITMAP
-10
-28
-28
-44
-44
-82
-82
-44
-44
-28
-28
-10
+40
+40
+40
+40
+40
+E0
+E0
+40
+40
+40
+40
+40
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9675
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2380
+ENCODING 9088
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 9 12 3 0
 BITMAP
+3800
+4400
+0400
+3C00
+4400
+4400
 3E00
-4100
-8080
-8080
 8080
-8080
-8080
 4100
-3E00
+2200
+1400
+0800
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9676
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2381
+ENCODING 9089
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 9 2 3
 BITMAP
-3600
-0000
-8080
-8080
-0000
-8080
-8080
+7000
+8800
+0800
+7800
+8800
+8892
+7C92
 0000
-3600
+FFFE
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9677
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2382
+ENCODING 9090
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 9 2 3
 BITMAP
-3E00
-6B00
-AA80
-AA80
-AA80
-AA80
-AA80
-6B00
-3E00
+7070
+8888
+0808
+7878
+8888
+8888
+7C7C
+0000
+FCFC
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9678
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2383
+ENCODING 9091
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 17 9 2 4
 BITMAP
-3E00
-4100
-9C80
-A280
-A280
-A280
-9C80
-4100
-3E00
+300180
+0CE600
+011000
+002000
+79E780
+022000
+044000
+33EC00
+C00300
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9679
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2384
+ENCODING 9092
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 16 13 2 0
 BITMAP
-3E00
-7F00
-FF80
-FF80
-FF80
-FF80
-FF80
-7F00
-3E00
+FFE0
+8358
+8444
+8842
+8842
+9041
+9041
+9041
+8842
+8842
+8444
+8358
+FFE0
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9680
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2385
+ENCODING 9093
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 17 2 -2
 BITMAP
-3E00
-7100
-F080
-F080
-F080
-F080
-F080
-7100
-3E00
+0200
+0200
+FFF8
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+8208
+FFF8
+0200
+0200
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9681
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2386
+ENCODING 9094
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 13 2 0
 BITMAP
-3E00
-4700
-8780
-8780
-8780
-8780
-8780
-4700
-3E00
+0180
+0240
+0420
+0910
+0188
+FF44
+8022
+FF44
+0188
+0910
+0420
+0240
+0180
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9682
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2387
+ENCODING 9095
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 16 7 2 3
 BITMAP
-3E00
-7F00
-FF80
-FF80
-8080
-8080
-8080
-4100
-3E00
+0010
+0008
+007C
+0088
+0110
+0200
+FC7F
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9683
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2388
+ENCODING 9096
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-3E00
-4100
-8080
-8080
-8080
-FF80
-FF80
-7F00
-3E00
+0200
+4210
+2FA0
+1240
+2AA0
+2720
+FFF8
+2720
+2AA0
+1240
+2FA0
+4210
+0200
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9684
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2389
+ENCODING 9097
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-3E00
-4F00
-8F80
-8F80
-8F80
-8080
-8080
-4100
-3E00
+0700
+18C0
+2020
+4010
+4010
+F078
+9048
+8888
+4510
+4510
+2220
+1AC0
+0700
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9685
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni238A
+ENCODING 9098
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-3E00
-4700
-8780
-8780
-8780
-FF80
-FF80
-7F00
-3E00
+0700
+18C0
+2020
+5FD0
+5050
+9048
+8888
+8508
+4510
+4210
+2220
+18C0
+0700
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9686
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 9 1 1
+STARTCHAR uni238B
+ENCODING 9099
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-30
-70
-F0
-F0
-F0
-F0
-F0
-70
-30
+0700
+00C0
+3C20
+2410
+2810
+B408
+8208
+8108
+4090
+4010
+2020
+18C0
+0700
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9687
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 9 1 1
+STARTCHAR uni238C
+ENCODING 9100
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 11 2 0
 BITMAP
-C0
-E0
-F0
-F0
-F0
-F0
-F0
-E0
-C0
+03C0
+1430
+1808
+1C00
+0000
+3018
+4824
+8442
+8442
+4824
+3018
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9688
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni238D
+ENCODING 9101
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 13 2 0
 BITMAP
-FF80
-FF80
-E380
-C180
-C180
-C180
-E380
-FF80
-FF80
+1F80
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+F0F0
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9689
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni238E
+ENCODING 9102
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 13 2 0
 BITMAP
-FF80
-E380
-DD80
-BE80
-BE80
-BE80
-DD80
-E380
-FF80
+07F0
+0880
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1080
+1100
+FE00
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9690
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 5 1 0
+STARTCHAR uni238F
+ENCODING 9103
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-FF80
-E380
-DD80
-BE80
-BE80
+FFF8
+0500
+0880
+1040
+2020
+4010
+8008
+4010
+2020
+1040
+0880
+0500
+0200
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9691
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 5 1 0
+STARTCHAR uni2390
+ENCODING 9104
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-BE80
-BE80
-DD80
-E380
-FF80
+0200
+0500
+0880
+1040
+2020
+4010
+8008
+4010
+2020
+1040
+0880
+0500
+FFF8
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9692
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 5 0 0
+STARTCHAR uni2391
+ENCODING 9105
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-38
-40
-80
-80
-80
+FFF8
+0500
+0880
+1040
+2020
+4010
+FFF8
+4010
+2020
+1040
+0880
+0500
+0200
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9693
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 0 0
+STARTCHAR uni2392
+ENCODING 9106
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-E0
-10
-08
-08
-08
+0200
+0500
+0880
+1040
+2020
+4010
+FFF8
+4010
+2020
+1040
+0880
+0500
+FFF8
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9694
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 0 0
+STARTCHAR uni2393
+ENCODING 9107
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 3 2 4
 BITMAP
-08
-08
-08
-10
-E0
+FFF8
+0000
+E738
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9695
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 5 0 0
+STARTCHAR uni2394
+ENCODING 9108
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 13 2 0
 BITMAP
-80
-80
-80
-40
-38
+0FE0
+1010
+2008
+2008
+4004
+4004
+8002
+4004
+4004
+2008
+2008
+1010
+0FE0
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9696
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 5 1 -1
-BITMAP
-3E00
-4100
-8080
-8080
-8080
+STARTCHAR uni2395
+ENCODING 9109
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 15 2 -2
+BITMAP
+FFF8
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9697
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 5 1 0
+STARTCHAR uni2396
+ENCODING 9110
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 12 2 1
 BITMAP
-8080
-8080
+FC
+FC
+F8
+F8
+F0
+F0
+E0
+E0
+C0
+C0
+80
+80
+ENDCHAR
+STARTCHAR uni2397
+ENCODING 9111
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 15 2 0
+BITMAP
+FF80
 8080
-4100
-3E00
+83FE
+8202
+8202
+BA02
+B202
+BA02
+AFE2
+87E2
+8202
+8202
+FE02
+0202
+03FE
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9698
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2398
+ENCODING 9112
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 15 15 2 0
 BITMAP
-0080
-0180
-0380
-0780
-0F80
-1F80
-3F80
-7F80
 FF80
+8080
+83FE
+8202
+8202
+BF02
+BFA2
+82E2
+8262
+82E2
+8202
+8202
+FE02
+0202
+03FE
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9699
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2399
+ENCODING 9113
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 17 16 2 0
+BITMAP
+01F000
+031000
+071000
+3F1E00
+441100
+841080
+841080
+841080
+841080
+841080
+841080
+87F080
+800080
+800080
+400100
+3FFE00
+ENDCHAR
+STARTCHAR uni239A
+ENCODING 9114
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 17 13 2 0
+BITMAP
+3FFE00
+400100
+800080
+809080
+812080
+824880
+849080
+892080
+824080
+848080
+800080
+400100
+3FFE00
+ENDCHAR
+STARTCHAR uni2400
+ENCODING 9216
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+9000
+9000
+D000
+B480
+9480
+9480
+04A0
+04A0
+0320
+0020
+0020
+003C
+ENDCHAR
+STARTCHAR uni2401
+ENCODING 9217
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+6000
+9000
+4000
+2300
+9480
+6480
+04A4
+04A4
+0324
+003C
+0024
+0024
+ENDCHAR
+STARTCHAR uni2402
+ENCODING 9218
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 13 12 2 0
+BITMAP
+6000
+9000
+4000
+2700
+9200
+6200
+0248
+0248
+0230
+0030
+0048
+0048
+ENDCHAR
+STARTCHAR uni2403
+ENCODING 9219
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 13 12 2 0
 BITMAP
+F000
 8000
-C000
 E000
-F000
-F800
-FC00
-FE00
-FF00
-FF80
+8700
+8200
+F200
+0248
+0248
+0230
+0030
+0048
+0048
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9700
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2404
+ENCODING 9220
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 13 12 2 0
 BITMAP
-FF80
-FF00
-FE00
-FC00
-F800
 F000
+8000
 E000
-C000
+8300
+8480
+F480
+04B8
+0490
+0310
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uni2405
+ENCODING 9221
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 13 2 -1
+BITMAP
+F000
 8000
+E000
+8480
+8480
+F680
+0598
+04A4
+04A4
+0024
+0034
+0018
+0004
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9701
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2406
+ENCODING 9222
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
 BITMAP
-FF80
-7F80
-3F80
-1F80
-0F80
-0780
-0380
-0180
-0080
+6000
+9000
+9000
+F300
+9480
+9400
+0424
+04A8
+0330
+0028
+0028
+0024
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9702
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 7 1 2
+STARTCHAR uni2407
+ENCODING 9223
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
 BITMAP
-38
-44
-82
-82
-82
-44
-38
+E000
+5000
+6000
+5780
+5400
+E700
+0420
+0420
+07A0
+0020
+0020
+003C
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9703
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2408
+ENCODING 9224
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
 BITMAP
-FF80
-F080
-F080
-F080
-F080
-F080
-F080
-F080
-FF80
+E000
+5000
+7000
+5300
+5480
+E200
+0100
+0480
+0300
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9704
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni2409
+ENCODING 9225
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 8 9 5 2
 BITMAP
-FF80
-8780
-8780
-8780
-8780
-8780
-8780
+90
+90
+F0
+97
+92
+92
+02
+02
+02
+ENDCHAR
+STARTCHAR uni240A
+ENCODING 9226
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
+BITMAP
+8000
+8000
+8000
 8780
-FF80
+8400
+F700
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9705
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni240B
+ENCODING 9227
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
 BITMAP
-FF80
-FF80
-FE80
-FC80
-F880
-F080
-E080
-C080
-FF80
+8800
+8800
+5000
+5380
+5100
+2100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9706
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni240C
+ENCODING 9228
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
 BITMAP
-FF80
-8180
-8380
+F000
+8000
+E000
 8780
-8F80
-9F80
-BF80
-FF80
-FF80
+8400
+8700
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR char9632
-ENCODING 9707
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 9 1 1
+STARTCHAR uni240D
+ENCODING 9229
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
 BITMAP
-FF80
-8880
-8880
-8880
-8880
-8880
-8880
-8880
-FF80
+6000
+9000
+8000
+8700
+9480
+6700
+0500
+0500
+0480
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9708
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 1
+STARTCHAR uni240E
+ENCODING 9230
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
 BITMAP
-0800
-0800
-1400
-1400
-2200
-2A00
-5D00
-4900
-8080
-FF80
+6000
+9000
+4000
+2300
+9480
+6480
+0480
+0480
+0300
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9709
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 1
+STARTCHAR uni240F
+ENCODING 9231
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 8 9 4 2
 BITMAP
-0800
-0800
-1C00
-1C00
-3A00
-3A00
-7900
-7900
-F880
-FF80
+60
+90
+40
+27
+92
+62
+02
+02
+07
 ENDCHAR
-STARTCHAR char9650
-ENCODING 9710
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 1
+STARTCHAR uni2410
+ENCODING 9232
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
 BITMAP
-0800
-0800
-1C00
-1C00
-2E00
-2E00
-4F00
-4F00
-8F80
-FF80
+E000
+5000
+5000
+5400
+5400
+E400
+043C
+0420
+07B8
+0020
+0020
+003C
 ENDCHAR
-STARTCHAR char9670
-ENCODING 9711
+STARTCHAR uni2411
+ENCODING 9233
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 13 12 2 0
+BITMAP
+E000
+5000
+5000
+5300
+5480
+E400
+0410
+04B0
+0310
+0010
+0010
+0038
+ENDCHAR
+STARTCHAR uni2412
+ENCODING 9234
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+E000
+5000
+5000
+5300
+5480
+E400
+0418
+04A4
+0308
+0010
+0020
+003C
+ENDCHAR
+STARTCHAR uni2413
+ENCODING 9235
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+E000
+5000
+5000
+5300
+5480
+E400
+043C
+0484
+0308
+0004
+0024
+0018
+ENDCHAR
+STARTCHAR uni2414
+ENCODING 9236
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+E000
+5000
+5000
+5300
+5480
+E400
+0408
+0498
+0328
+007C
+0008
+0008
+ENDCHAR
+STARTCHAR uni2415
+ENCODING 9237
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+9000
+9000
+D000
+B300
+9480
+9480
+07A4
+04A8
+04B0
+0028
+0028
+0024
+ENDCHAR
+STARTCHAR uni2416
+ENCODING 9238
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+6000
+9000
+4000
+2440
+9280
+6100
+0124
+0124
+0134
+002C
+0024
+0024
+ENDCHAR
+STARTCHAR uni2417
+ENCODING 9239
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 13 12 2 0
+BITMAP
+F000
+8000
+E000
+8700
+8200
+F200
+0270
+0228
+0230
+0028
+0028
+0070
+ENDCHAR
+STARTCHAR uni2418
+ENCODING 9240
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+6000
+9000
+8000
+8300
+9480
+6480
+07A4
+04A4
+04B4
+002C
+0024
+0024
+ENDCHAR
+STARTCHAR uni2419
+ENCODING 9241
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 10 9 4 2
+BITMAP
+F000
+8000
+E000
+8440
+86C0
+F540
+0440
+0440
+0440
+ENDCHAR
+STARTCHAR uni241A
+ENCODING 9242
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+6000
+9000
+4000
+2480
+9480
+6480
+04B8
+0494
+0318
+0014
+0014
+0038
+ENDCHAR
+STARTCHAR uni241B
+ENCODING 9243
+SWIDTH 1800 0
+DWIDTH 30 0
+BBX 14 12 2 0
+BITMAP
+F000
+8000
+E000
+8300
+8480
+F200
+0118
+04A4
+0320
+0020
+0024
+0018
+ENDCHAR
+STARTCHAR uni241C
+ENCODING 9244
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
+BITMAP
+F000
+8000
+E000
+8300
+8480
+8200
+0100
+0480
+0300
+ENDCHAR
+STARTCHAR uni241D
+ENCODING 9245
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
+BITMAP
+6000
+9000
+8000
+B300
+9480
+6200
+0100
+0480
+0300
+ENDCHAR
+STARTCHAR uni241E
+ENCODING 9246
+SWIDTH 1320 0
+DWIDTH 22 0
+BBX 9 9 4 2
+BITMAP
+E000
+9000
+E000
+A300
+A480
+9200
+0100
+0480
+0300
+ENDCHAR
+STARTCHAR uni241F
+ENCODING 9247
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
+BITMAP
+9000
+9000
+9000
+9300
+9480
+6200
+0100
+0480
+0300
+ENDCHAR
+STARTCHAR uni2420
+ENCODING 9248
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
+BITMAP
+6000
+9000
+4000
+2700
+9480
+6700
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni2421
+ENCODING 9249
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 14 12 2 0
+BITMAP
+E000
+5000
+5000
+5780
+5400
+E700
+0420
+0420
+07A0
+0020
+0020
+003C
+ENDCHAR
+STARTCHAR uni2422
+ENCODING 9250
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 0
+BITMAP
+64
+28
+30
+20
+60
+AC
+32
+21
+21
+21
+32
+2C
+ENDCHAR
+STARTCHAR uni2423
+ENCODING 9251
 SWIDTH 660 0
 DWIDTH 11 0
-BBX 10 10 1 0
+BBX 9 3 1 -2
 BITMAP
-1E00
-6180
-4080
-8040
-8040
-8040
-8040
-4080
-6180
-1E00
+8080
+8080
+FF80
 ENDCHAR
-STARTCHAR char10049
-ENCODING 10049
+STARTCHAR uni2424
+ENCODING 9252
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 9 9 4 2
+BITMAP
+9000
+9000
+D000
+B400
+9400
+9400
+0400
+0400
+0780
+ENDCHAR
+STARTCHAR uni2425
+ENCODING 9253
 SWIDTH 840 0
 DWIDTH 14 0
-BBX 11 11 2 1
+BBX 11 11 2 2
 BITMAP
-1700
-2880
-4540
-B520
-8A40
-B5A0
-4A20
-95A0
-5440
-2280
-1D00
+0120
+0240
+0480
+0920
+1240
+2480
+4900
+9200
+2400
+4800
+9000
 ENDCHAR
-STARTCHAR uni2800
-ENCODING 10240
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 0 0 0 0
+STARTCHAR uni2426
+ENCODING 9254
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 0
 BITMAP
+78
+CC
+84
+84
+C0
+60
+30
+30
+30
+00
+00
+30
+30
 ENDCHAR
-STARTCHAR uni2801
-ENCODING 10241
+STARTCHAR uni2440
+ENCODING 9280
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 2 1 9
+BBX 7 11 1 1
 BITMAP
-C0
-C0
+1E
+12
+12
+12
+10
+10
+10
+90
+90
+90
+F0
 ENDCHAR
-STARTCHAR uni2802
-ENCODING 10242
+STARTCHAR uni2441
+ENCODING 9281
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 2 1 6
+BBX 7 11 1 1
 BITMAP
-C0
-C0
+02
+02
+02
+02
+02
+FE
+82
+82
+82
+82
+82
 ENDCHAR
-STARTCHAR uni2803
-ENCODING 10243
+STARTCHAR uni2442
+ENCODING 9282
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 5 1 6
+BBX 7 11 1 1
 BITMAP
-C0
-C0
-00
-C0
-C0
+82
+82
+82
+82
+82
+FE
+10
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR uni2804
-ENCODING 10244
+STARTCHAR uni2443
+ENCODING 9283
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 2 1 3
+BBX 7 11 1 1
 BITMAP
-C0
-C0
+FE
+92
+92
+92
+10
+10
+10
+92
+92
+92
+FE
 ENDCHAR
-STARTCHAR uni2805
-ENCODING 10245
+STARTCHAR uni2444
+ENCODING 9284
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 8 1 3
+BBX 7 5 1 7
 BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
+C6
+AA
+92
+AA
+C6
 ENDCHAR
-STARTCHAR uni2806
-ENCODING 10246
+STARTCHAR uni2445
+ENCODING 9285
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 5 1 3
+BBX 7 9 1 2
 BITMAP
+0E
+CE
+CE
 C0
 C0
-00
-C0
 C0
+CE
+CE
+0E
 ENDCHAR
-STARTCHAR uni2807
-ENCODING 10247
+STARTCHAR uni2446
+ENCODING 9286
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 8 1 3
+BBX 7 11 1 1
 BITMAP
+06
+06
+06
+16
+16
+10
+D0
+D0
 C0
 C0
-00
-C0
-C0
-00
-C0
 C0
 ENDCHAR
-STARTCHAR uni2808
-ENCODING 10248
+STARTCHAR uni2447
+ENCODING 9287
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 2 2 4 9
+BBX 7 8 1 2
 BITMAP
-C0
-C0
+0E
+0E
+AE
+AE
+AE
+A0
+A0
+A0
 ENDCHAR
-STARTCHAR uni2809
-ENCODING 10249
+STARTCHAR uni2448
+ENCODING 9288
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 5 2 1 9
+BBX 7 5 1 4
 BITMAP
-D8
-D8
+DA
+DA
+DA
+DA
+DA
 ENDCHAR
-STARTCHAR uni280A
-ENCODING 10250
+STARTCHAR uni2449
+ENCODING 9289
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 5 5 1 6
+BBX 7 12 1 0
 BITMAP
-18
-18
-00
-C0
-C0
+90
+90
+48
+48
+48
+48
+24
+24
+24
+24
+12
+12
 ENDCHAR
-STARTCHAR uni280B
-ENCODING 10251
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 6
+STARTCHAR uni2460
+ENCODING 9312
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni280C
-ENCODING 10252
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
-BITMAP
-18
-18
-00
-00
-00
-00
-C0
-C0
+07F000
+180C00
+200200
+408100
+438100
+808080
+808080
+808080
+808080
+808080
+808080
+808080
+408100
+43E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni280D
-ENCODING 10253
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2461
+ENCODING 9313
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-00
-00
-00
-C0
-C0
+07F000
+180C00
+200200
+41C100
+422100
+822080
+822080
+802080
+804080
+804080
+808080
+812080
+412100
+43E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni280E
-ENCODING 10254
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2462
+ENCODING 9314
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-C0
-C0
-00
-C0
-C0
+07F000
+180C00
+200200
+41C100
+422100
+822080
+802080
+802080
+80C080
+802080
+802080
+822080
+422100
+41C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni280F
-ENCODING 10255
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2463
+ENCODING 9315
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
+07F000
+180C00
+200200
+40C100
+40C100
+814080
+814080
+824080
+864080
+87F080
+804080
+804080
+404100
+41F100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2810
-ENCODING 10256
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 2 4 6
+STARTCHAR uni2464
+ENCODING 9316
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
+07F000
+180C00
+200200
+422100
+43C100
+820080
+820080
+83C080
+832080
+802080
+802080
+822080
+424100
+418100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2811
-ENCODING 10257
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 6
+STARTCHAR uni2465
+ENCODING 9317
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-18
-18
+07F000
+180C00
+200200
+40C100
+412100
+810080
+820080
+83C080
+822080
+822080
+822080
+822080
+414100
+41C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2812
-ENCODING 10258
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 2 1 6
+STARTCHAR uni2466
+ENCODING 9318
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
+07F000
+180C00
+220200
+43F100
+421100
+822080
+804080
+804080
+804080
+808080
+808080
+808080
+408100
+408100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2813
-ENCODING 10259
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 6
+STARTCHAR uni2467
+ENCODING 9319
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-D8
-D8
+07F000
+180C00
+200200
+41C100
+422100
+822080
+822080
+814080
+81C080
+822080
+822080
+822080
+422100
+41C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2814
-ENCODING 10260
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 3
+STARTCHAR uni2468
+ENCODING 9320
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-C0
-C0
+07F000
+180C00
+200200
+41C100
+414100
+822080
+822080
+822080
+822080
+81E080
+802080
+804080
+424100
+418100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2815
-ENCODING 10261
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2469
+ENCODING 9321
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-18
-18
-00
-C0
-C0
+07F000
+180C00
+200200
+447100
+5C5100
+848880
+848880
+848880
+848880
+848880
+848880
+848880
+445100
+5F7100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2816
-ENCODING 10262
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 3
+STARTCHAR uni246A
+ENCODING 9322
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
+07F000
+180C00
+200200
+441100
+5C7100
+841080
+841080
+841080
+841080
+841080
+841080
+841080
+441100
+5F7D00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2817
-ENCODING 10263
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni246B
+ENCODING 9323
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
+07F000
+180C00
+200200
+447100
+5C8900
+848880
+848880
+840880
+841080
+841080
+842080
+844880
+444900
+5FF900
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2818
-ENCODING 10264
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 5 4 6
+STARTCHAR uni246C
+ENCODING 9324
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-C0
-C0
+07F000
+180C00
+200200
+447100
+5C8900
+848880
+840880
+840880
+843080
+840880
+840880
+848880
+448900
+5F7100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2819
-ENCODING 10265
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 6
+STARTCHAR uni246D
+ENCODING 9325
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-18
-18
+07F000
+180C00
+200200
+443100
+5C3100
+845080
+845080
+849080
+859080
+85FC80
+841080
+841080
+441100
+5F7D00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni281A
-ENCODING 10266
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 6
+STARTCHAR uni246E
+ENCODING 9326
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+448900
+5CF100
+848080
+848080
+84F080
+84C880
+840880
+840880
+848880
+449100
+5F6100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni281B
-ENCODING 10267
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 6
+STARTCHAR uni246F
+ENCODING 9327
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+443100
+5C4900
+844080
+848080
+84F080
+848880
+848880
+848880
+848880
+445100
+5F7100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni281C
-ENCODING 10268
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2470
+ENCODING 9328
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-18
-18
-00
-C0
-C0
+07F000
+180C00
+208200
+44FD00
+5C8500
+848880
+841080
+841080
+841080
+842080
+842080
+842080
+442100
+5F2100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni281D
-ENCODING 10269
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2471
+ENCODING 9329
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-18
-18
-00
-C0
-C0
+07F000
+180C00
+200200
+447100
+5C8900
+848880
+848880
+845080
+847080
+848880
+848880
+848880
+448900
+5F7100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni281E
-ENCODING 10270
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2472
+ENCODING 9330
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
-00
-C0
-C0
+07F000
+180C00
+200200
+447100
+5C5100
+848880
+848880
+848880
+848880
+847880
+840880
+841080
+449100
+5F6100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni281F
-ENCODING 10271
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2473
+ENCODING 9331
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
+07F000
+180C00
+200200
+4E3900
+512900
+914480
+914480
+814480
+824480
+824480
+844480
+894480
+492900
+5F3900
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni2820
-ENCODING 10272
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 2 4 3
+STARTCHAR uni2474
+ENCODING 9332
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
+100400
+208200
+438100
+408100
+808080
+808080
+808080
+808080
+808080
+808080
+808080
+43E100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2821
-ENCODING 10273
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2475
+ENCODING 9333
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-00
-00
-00
-18
-18
+100400
+21C200
+422100
+422100
+822080
+802080
+804080
+804080
+808080
+812080
+812080
+43E100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2822
-ENCODING 10274
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 3
+STARTCHAR uni2476
+ENCODING 9334
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-18
-18
+100400
+21C200
+422100
+422100
+802080
+802080
+80C080
+802080
+802080
+822080
+822080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2823
-ENCODING 10275
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2477
+ENCODING 9335
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-18
-18
+100400
+20C200
+40C100
+414100
+814080
+824080
+864080
+87F080
+804080
+804080
+804080
+41F100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2824
-ENCODING 10276
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 2 1 3
+STARTCHAR uni2478
+ENCODING 9336
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
+100400
+222200
+43C100
+420100
+820080
+83C080
+832080
+802080
+802080
+822080
+824080
+418100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2825
-ENCODING 10277
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2479
+ENCODING 9337
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-00
-00
-00
-D8
-D8
+100400
+20C200
+412100
+410100
+820080
+83C080
+822080
+822080
+822080
+822080
+814080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2826
-ENCODING 10278
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 3
+STARTCHAR uni247A
+ENCODING 9338
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-D8
-D8
+120400
+23F200
+421100
+422100
+804080
+804080
+804080
+808080
+808080
+808080
+808080
+408100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2827
-ENCODING 10279
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni247B
+ENCODING 9339
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
+100400
+21C200
+422100
+422100
+822080
+814080
+81C080
+822080
+822080
+822080
+822080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2828
-ENCODING 10280
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 8 4 3
+STARTCHAR uni247C
+ENCODING 9340
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
+100400
+21C200
+414100
+422100
+822080
+822080
+822080
+81E080
+802080
+804080
+824080
+418100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2829
-ENCODING 10281
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni247D
+ENCODING 9341
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-00
-00
-00
-18
-18
+100400
+247200
+5C5100
+448900
+848880
+848880
+848880
+848880
+848880
+848880
+845080
+5F7100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni282A
-ENCODING 10282
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni247E
+ENCODING 9342
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-C0
-C0
-00
-18
-18
+100400
+241200
+5C7100
+441100
+841080
+841080
+841080
+841080
+841080
+841080
+841080
+5F7D00
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni282B
-ENCODING 10283
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni247F
+ENCODING 9343
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
-00
-18
-18
+100400
+247200
+5C8900
+448900
+848880
+840880
+841080
+841080
+842080
+844880
+844880
+5FF900
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni282C
-ENCODING 10284
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2480
+ENCODING 9344
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-00
-00
-00
-D8
-D8
+100400
+247200
+5C8900
+448900
+840880
+840880
+843080
+840880
+840880
+848880
+848880
+5F7100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni282D
-ENCODING 10285
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2481
+ENCODING 9345
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-00
-00
-00
-D8
-D8
+100400
+243200
+5C3100
+445100
+845080
+849080
+859080
+85F880
+841080
+841080
+841080
+5F7900
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni282E
-ENCODING 10286
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2482
+ENCODING 9346
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-C0
-C0
-00
-D8
-D8
+100400
+248A00
+5CF100
+448100
+848080
+84F080
+84C880
+840880
+840880
+848880
+849080
+5F6100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni282F
-ENCODING 10287
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2483
+ENCODING 9347
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
+100400
+243200
+5C4900
+444100
+848080
+84F080
+848880
+848880
+848880
+848880
+845080
+5F7100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2830
-ENCODING 10288
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 5 4 3
+STARTCHAR uni2484
+ENCODING 9348
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-C0
-C0
+108400
+24FE00
+5C8500
+448900
+841080
+841080
+841080
+842080
+842080
+842080
+842080
+5F2100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2831
-ENCODING 10289
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2485
+ENCODING 9349
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-18
-18
-00
-18
-18
+100400
+247200
+5C8900
+448900
+848880
+845080
+847080
+848880
+848880
+848880
+848880
+5F7100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2832
-ENCODING 10290
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 3
+STARTCHAR uni2486
+ENCODING 9350
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-18
-18
+100400
+247200
+5C5100
+448900
+848880
+848880
+848880
+847880
+840880
+841080
+849080
+5F6100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2833
-ENCODING 10291
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2487
+ENCODING 9351
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-D8
-D8
-00
-18
-18
+100400
+2E3A00
+512900
+514500
+914480
+814480
+824480
+824480
+844480
+894480
+892880
+5F3900
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2834
-ENCODING 10292
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 3
+STARTCHAR uni2488
+ENCODING 9352
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 9 11 3 0
 BITMAP
-18
-18
-00
-D8
-D8
+2000
+E000
+2000
+2000
+2000
+2000
+2000
+2000
+2000
+2180
+F980
 ENDCHAR
-STARTCHAR uni2835
-ENCODING 10293
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2489
+ENCODING 9353
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 9 11 3 0
 BITMAP
-C0
-C0
-00
-18
-18
-00
-D8
-D8
+7000
+8800
+8800
+8800
+0800
+1000
+1000
+2000
+4800
+4980
+F980
 ENDCHAR
-STARTCHAR uni2836
-ENCODING 10294
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 3
+STARTCHAR uni248A
+ENCODING 9354
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 9 11 3 0
 BITMAP
-D8
-D8
-00
-D8
-D8
+7000
+8800
+8800
+0800
+0800
+3000
+0800
+0800
+8800
+8980
+7180
 ENDCHAR
-STARTCHAR uni2837
-ENCODING 10295
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni248B
+ENCODING 9355
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 11 11 3 0
 BITMAP
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
+1800
+1800
+2800
+2800
+4800
+C800
+FE00
+0800
+0800
+0860
+3E60
 ENDCHAR
-STARTCHAR uni2838
-ENCODING 10296
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 8 4 3
+STARTCHAR uni248C
+ENCODING 9356
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 9 11 3 0
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
+8800
+F000
+8000
+8000
+F000
+C800
+0800
+0800
+8800
+9180
+6180
 ENDCHAR
-STARTCHAR uni2839
-ENCODING 10297
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni248D
+ENCODING 9357
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 9 11 3 0
 BITMAP
-D8
-D8
-00
-18
-18
-00
-18
-18
+3000
+4800
+4000
+8000
+F000
+8800
+8800
+8800
+8800
+5180
+7180
 ENDCHAR
-STARTCHAR uni283A
-ENCODING 10298
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni248E
+ENCODING 9358
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 7 12 3 0
 BITMAP
-18
-18
-00
-D8
-D8
-00
-18
-18
+80
+FC
+84
+88
+10
+10
+10
+20
+20
+20
+26
+26
 ENDCHAR
-STARTCHAR uni283B
-ENCODING 10299
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni248F
+ENCODING 9359
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 9 11 3 0
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-18
-18
+7000
+8800
+8800
+8800
+5000
+7000
+8800
+8800
+8800
+8980
+7180
 ENDCHAR
-STARTCHAR uni283C
-ENCODING 10300
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2490
+ENCODING 9360
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 8 11 3 0
 BITMAP
-18
-18
-00
-18
-18
-00
-D8
-D8
+70
+50
+88
+88
+88
+88
+78
+08
+10
+93
+63
 ENDCHAR
-STARTCHAR uni283D
-ENCODING 10301
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2491
+ENCODING 9361
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 13 11 3 0
 BITMAP
-D8
-D8
-00
-18
-18
-00
-D8
-D8
+2380
+E280
+2440
+2440
+2440
+2440
+2440
+2440
+2440
+2298
+FB98
 ENDCHAR
-STARTCHAR uni283E
-ENCODING 10302
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2492
+ENCODING 9362
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 15 11 3 0
 BITMAP
-18
-18
-00
-D8
-D8
-00
-D8
-D8
+2080
+E380
+2080
+2080
+2080
+2080
+2080
+2080
+2080
+2086
+FBE6
 ENDCHAR
-STARTCHAR uni283F
-ENCODING 10303
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 3
+STARTCHAR uni2493
+ENCODING 9363
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 14 11 3 0
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
+2380
+E440
+2440
+2440
+2040
+2080
+2080
+2100
+2240
+224C
+FFCC
 ENDCHAR
-STARTCHAR uni2840
-ENCODING 10304
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 2 1 0
+STARTCHAR uni2494
+ENCODING 9364
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 14 11 3 0
 BITMAP
-C0
-C0
+2380
+E440
+2440
+2040
+2040
+2180
+2040
+2040
+2440
+244C
+FB8C
 ENDCHAR
-STARTCHAR uni2841
-ENCODING 10305
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 1 0
+STARTCHAR uni2495
+ENCODING 9365
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 14 11 3 0
 BITMAP
-C0
-C0
-00
-00
-00
-00
-00
-00
-00
-C0
-C0
+2180
+E180
+2280
+2280
+2480
+2C80
+2FC0
+2080
+2080
+208C
+FBCC
 ENDCHAR
-STARTCHAR uni2842
-ENCODING 10306
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 8 1 0
+STARTCHAR uni2496
+ENCODING 9366
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 13 11 3 0
 BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
+2440
+E780
+2400
+2400
+2780
+2640
+2040
+2040
+2440
+2498
+FB18
 ENDCHAR
-STARTCHAR uni2843
-ENCODING 10307
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 1 0
+STARTCHAR uni2497
+ENCODING 9367
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 13 11 3 0
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-00
-00
-00
-C0
-C0
+2180
+E240
+2200
+2400
+2780
+2440
+2440
+2440
+2440
+2298
+FB98
 ENDCHAR
-STARTCHAR uni2844
-ENCODING 10308
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 5 1 0
+STARTCHAR uni2498
+ENCODING 9368
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 12 3 0
 BITMAP
-C0
-C0
-00
-C0
-C0
+0400
+27E0
+E420
+2440
+2080
+2080
+2080
+2100
+2100
+2100
+2130
+F930
 ENDCHAR
-STARTCHAR uni2845
-ENCODING 10309
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 1 0
+STARTCHAR uni2499
+ENCODING 9369
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 14 11 3 0
 BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
-00
-C0
-C0
+2380
+E440
+2440
+2440
+2280
+2380
+2440
+2440
+2440
+244C
+FB8C
 ENDCHAR
-STARTCHAR uni2846
-ENCODING 10310
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 8 1 0
+STARTCHAR uni249A
+ENCODING 9370
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 13 11 3 0
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
+2380
+E280
+2440
+2440
+2440
+2440
+23C0
+2040
+2080
+2498
+FB18
 ENDCHAR
-STARTCHAR uni2847
-ENCODING 10311
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 1 0
+STARTCHAR uni249B
+ENCODING 9371
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 14 11 3 0
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
+71C0
+8940
+8A20
+8A20
+0A20
+1220
+1220
+2220
+4A20
+494C
+F9CC
 ENDCHAR
-STARTCHAR uni2848
-ENCODING 10312
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni249C
+ENCODING 9372
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-00
-00
-00
-00
-00
-00
-C0
-C0
+100400
+200200
+400100
+400100
+800080
+838080
+844080
+804080
+83C080
+844080
+844080
+43E100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni2849
-ENCODING 10313
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni249D
+ENCODING 9373
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-00
-00
-00
-00
-00
-00
-C0
-C0
+160400
+220200
+420100
+420100
+820080
+83C080
+822080
+822080
+822080
+822080
+822080
+43C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni284A
-ENCODING 10314
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni249E
+ENCODING 9374
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-C0
-C0
-00
-00
-00
-00
-C0
-C0
+100400
+200200
+400100
+400100
+800080
+81C080
+822080
+820080
+820080
+820080
+822080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni284B
-ENCODING 10315
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni249F
+ENCODING 9375
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
-00
-00
-00
-00
-C0
-C0
+10C400
+204200
+404100
+404100
+804080
+83C080
+844080
+844080
+844080
+844080
+844080
+43E100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni284C
-ENCODING 10316
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A0
+ENCODING 9376
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-00
-00
-00
-C0
-C0
-00
-C0
-C0
+100400
+200200
+400100
+400100
+800080
+81C080
+822080
+83E080
+820080
+820080
+822080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni284D
-ENCODING 10317
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A1
+ENCODING 9377
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-00
-00
-00
-C0
-C0
-00
-C0
-C0
+10E400
+212200
+410100
+410100
+810080
+83C080
+810080
+810080
+810080
+810080
+810080
+438100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni284E
-ENCODING 10318
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A2
+ENCODING 9378
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 16 1 -4
 BITMAP
-18
-18
-00
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni284F
-ENCODING 10319
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2850
-ENCODING 10320
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2851
-ENCODING 10321
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2852
-ENCODING 10322
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2853
-ENCODING 10323
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2854
-ENCODING 10324
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2855
-ENCODING 10325
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2856
-ENCODING 10326
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2857
-ENCODING 10327
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2858
-ENCODING 10328
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2859
-ENCODING 10329
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni285A
-ENCODING 10330
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni285B
-ENCODING 10331
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni285C
-ENCODING 10332
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni285D
-ENCODING 10333
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni285E
-ENCODING 10334
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni285F
-ENCODING 10335
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2860
-ENCODING 10336
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2861
-ENCODING 10337
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2862
-ENCODING 10338
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2863
-ENCODING 10339
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2864
-ENCODING 10340
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2865
-ENCODING 10341
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2866
-ENCODING 10342
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2867
-ENCODING 10343
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2868
-ENCODING 10344
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2869
-ENCODING 10345
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni286A
-ENCODING 10346
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni286B
-ENCODING 10347
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni286C
-ENCODING 10348
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni286D
-ENCODING 10349
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni286E
-ENCODING 10350
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni286F
-ENCODING 10351
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2870
-ENCODING 10352
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2871
-ENCODING 10353
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2872
-ENCODING 10354
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2873
-ENCODING 10355
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2874
-ENCODING 10356
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2875
-ENCODING 10357
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2876
-ENCODING 10358
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2877
-ENCODING 10359
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2878
-ENCODING 10360
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2879
-ENCODING 10361
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni287A
-ENCODING 10362
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni287B
-ENCODING 10363
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-18
-18
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni287C
-ENCODING 10364
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni287D
-ENCODING 10365
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni287E
-ENCODING 10366
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni287F
-ENCODING 10367
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2880
-ENCODING 10368
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 2 4 0
-BITMAP
-C0
-C0
-ENDCHAR
-STARTCHAR uni2881
-ENCODING 10369
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2882
-ENCODING 10370
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2883
-ENCODING 10371
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2884
-ENCODING 10372
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2885
-ENCODING 10373
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2886
-ENCODING 10374
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2887
-ENCODING 10375
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2888
-ENCODING 10376
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 4 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2889
-ENCODING 10377
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni288A
-ENCODING 10378
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni288B
-ENCODING 10379
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni288C
-ENCODING 10380
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni288D
-ENCODING 10381
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni288E
-ENCODING 10382
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni288F
-ENCODING 10383
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2890
-ENCODING 10384
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 8 4 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2891
-ENCODING 10385
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2892
-ENCODING 10386
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2893
-ENCODING 10387
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2894
-ENCODING 10388
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2895
-ENCODING 10389
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2896
-ENCODING 10390
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2897
-ENCODING 10391
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni2898
-ENCODING 10392
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 4 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-00
-00
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni2899
-ENCODING 10393
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni289A
-ENCODING 10394
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni289B
-ENCODING 10395
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-00
-00
-00
-18
-18
-ENDCHAR
-STARTCHAR uni289C
-ENCODING 10396
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni289D
-ENCODING 10397
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni289E
-ENCODING 10398
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni289F
-ENCODING 10399
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A0
-ENCODING 10400
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 5 4 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni28A1
-ENCODING 10401
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A2
-ENCODING 10402
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A3
-ENCODING 10403
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A4
-ENCODING 10404
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A5
-ENCODING 10405
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A6
-ENCODING 10406
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A7
-ENCODING 10407
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28A8
-ENCODING 10408
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 4 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni28A9
-ENCODING 10409
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28AA
-ENCODING 10410
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28AB
-ENCODING 10411
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28AC
-ENCODING 10412
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28AD
-ENCODING 10413
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28AE
-ENCODING 10414
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28AF
-ENCODING 10415
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B0
-ENCODING 10416
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 8 4 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni28B1
-ENCODING 10417
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B2
-ENCODING 10418
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B3
-ENCODING 10419
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B4
-ENCODING 10420
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B5
-ENCODING 10421
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B6
-ENCODING 10422
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B7
-ENCODING 10423
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28B8
-ENCODING 10424
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 2 11 4 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-ENDCHAR
-STARTCHAR uni28B9
-ENCODING 10425
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28BA
-ENCODING 10426
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28BB
-ENCODING 10427
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-18
-18
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28BC
-ENCODING 10428
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28BD
-ENCODING 10429
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28BE
-ENCODING 10430
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-D8
-D8
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28BF
-ENCODING 10431
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
-00
-18
-18
-ENDCHAR
-STARTCHAR uni28C0
-ENCODING 10432
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 2 1 0
-BITMAP
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C1
-ENCODING 10433
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C2
-ENCODING 10434
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C3
-ENCODING 10435
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C4
-ENCODING 10436
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C5
-ENCODING 10437
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-00
-00
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C6
-ENCODING 10438
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C7
-ENCODING 10439
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C8
-ENCODING 10440
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28C9
-ENCODING 10441
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28CA
-ENCODING 10442
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28CB
-ENCODING 10443
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28CC
-ENCODING 10444
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28CD
-ENCODING 10445
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28CE
-ENCODING 10446
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28CF
-ENCODING 10447
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D0
-ENCODING 10448
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D1
-ENCODING 10449
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D2
-ENCODING 10450
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D3
-ENCODING 10451
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D4
-ENCODING 10452
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-18
-18
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D5
-ENCODING 10453
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-18
-18
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D6
-ENCODING 10454
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
-BITMAP
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D7
-ENCODING 10455
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-C0
-C0
-00
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D8
-ENCODING 10456
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-18
-18
-00
-18
-18
-00
-00
-00
-00
-D8
-D8
-ENDCHAR
-STARTCHAR uni28D9
-ENCODING 10457
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
-BITMAP
-D8
-D8
-00
-18
-18
-00
-00
-00
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+81F080
+822080
+822080
+822080
+83C080
+820080
+43E100
+441100
+241200
+141400
+03E000
 ENDCHAR
-STARTCHAR uni28DA
-ENCODING 10458
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A3
+ENCODING 9379
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
-00
-00
-00
-00
-D8
-D8
+160400
+220200
+420100
+420100
+820080
+83C080
+822080
+822080
+822080
+822080
+822080
+477100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28DB
-ENCODING 10459
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A4
+ENCODING 9380
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-00
-00
-00
-D8
-D8
+100400
+218200
+418100
+400100
+800080
+818080
+808080
+808080
+808080
+808080
+808080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28DC
-ENCODING 10460
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A5
+ENCODING 9381
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-18
-18
-00
-C0
-C0
-00
-D8
-D8
+100400
+20C200
+40C100
+400100
+800080
+80C080
+804080
+804080
+804080
+804080
+804080
+404100
+404100
+224200
+138400
 ENDCHAR
-STARTCHAR uni28DD
-ENCODING 10461
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A6
+ENCODING 9382
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-18
-18
-00
-C0
-C0
-00
-D8
-D8
+160400
+220200
+420100
+420100
+820080
+82F080
+824080
+828080
+838080
+82C080
+824080
+477100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28DE
-ENCODING 10462
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A7
+ENCODING 9383
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
+118400
+208200
+408100
+408100
+808080
+808080
+808080
+808080
+808080
+808080
+808080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28DF
-ENCODING 10463
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24A8
+ENCODING 9384
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+9F7080
+888880
+888880
+888880
+888880
+888880
+5DDD00
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E0
-ENCODING 10464
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 0
+STARTCHAR uni24A9
+ENCODING 9385
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+87C080
+822080
+822080
+822080
+822080
+822080
+477100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E1
-ENCODING 10465
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24AA
+ENCODING 9386
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-00
-00
-00
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+81C080
+822080
+822080
+822080
+822080
+822080
+41C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E2
-ENCODING 10466
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
+STARTCHAR uni24AB
+ENCODING 9387
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+87C080
+822080
+822080
+822080
+822080
+822080
+43C100
+420100
+220200
+170400
 ENDCHAR
-STARTCHAR uni28E3
-ENCODING 10467
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24AC
+ENCODING 9388
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+83C080
+844080
+844080
+844080
+844080
+844080
+43C100
+404100
+204200
+10E400
 ENDCHAR
-STARTCHAR uni28E4
-ENCODING 10468
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 5 1 0
+STARTCHAR uni24AD
+ENCODING 9389
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+834080
+81A080
+810080
+810080
+810080
+810080
+43C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E5
-ENCODING 10469
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24AE
+ENCODING 9390
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-00
-00
-00
-D8
-D8
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+81E080
+822080
+820080
+81C080
+802080
+822080
+43C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E6
-ENCODING 10470
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
+STARTCHAR uni24AF
+ENCODING 9391
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
+100400
+200200
+410100
+410100
+830080
+87C080
+810080
+810080
+810080
+812080
+812080
+40C100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E7
-ENCODING 10471
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B0
+ENCODING 9392
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-C0
-C0
-00
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+866080
+822080
+822080
+822080
+822080
+822080
+41F100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E8
-ENCODING 10472
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B1
+ENCODING 9393
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-00
-00
-00
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+8E7080
+824080
+824080
+824080
+818080
+818080
+418100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28E9
-ENCODING 10473
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B2
+ENCODING 9394
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-00
-00
-00
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+9DDC80
+849080
+855080
+855080
+855080
+836080
+422100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28EA
-ENCODING 10474
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B3
+ENCODING 9395
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-C0
-C0
-00
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+8E7080
+824080
+818080
+818080
+818080
+824080
+4E7100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28EB
-ENCODING 10475
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B4
+ENCODING 9396
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
-00
-18
-18
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+873880
+812080
+812080
+812080
+80C080
+80C080
+40C100
+408100
+248200
+170400
 ENDCHAR
-STARTCHAR uni28EC
-ENCODING 10476
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B5
+ENCODING 9397
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -3
 BITMAP
-18
-18
-00
-00
-00
-00
-D8
-D8
-00
-D8
-D8
+100400
+200200
+400100
+400100
+800080
+83E080
+824080
+824080
+808080
+812080
+812080
+43E100
+400100
+200200
+100400
 ENDCHAR
-STARTCHAR uni28ED
-ENCODING 10477
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B6
+ENCODING 9398
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-00
-00
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+408100
+408100
+814080
+814080
+814080
+822080
+822080
+83E080
+841080
+441100
+5E3D00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28EE
-ENCODING 10478
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B7
+ENCODING 9399
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+5FE100
+441100
+840880
+840880
+841080
+87E080
+841080
+840880
+840880
+441100
+5FE100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28EF
-ENCODING 10479
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24B8
+ENCODING 9400
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+41E900
+421900
+840880
+880880
+880080
+880080
+880080
+880880
+840880
+421100
+41E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F0
-ENCODING 10480
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
+STARTCHAR uni24B9
+ENCODING 9401
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+5FC100
+443100
+841080
+840880
+840880
+840880
+840880
+840880
+841080
+443100
+5FC100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F1
-ENCODING 10481
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24BA
+ENCODING 9402
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-18
-18
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+5FF100
+441100
+841080
+845080
+844080
+87C080
+844880
+844880
+841080
+441100
+5FF100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F2
-ENCODING 10482
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
+STARTCHAR uni24BB
+ENCODING 9403
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+4FF900
+420900
+820880
+822880
+822080
+83E080
+822080
+822080
+820080
+420100
+4F8100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F3
-ENCODING 10483
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24BC
+ENCODING 9404
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-D8
-D8
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+43D100
+443100
+881080
+901080
+900080
+900080
+907880
+901080
+881080
+441100
+43F100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F4
-ENCODING 10484
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
+STARTCHAR uni24BD
+ENCODING 9405
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+5F7D00
+441100
+841080
+841080
+841080
+87F080
+841080
+841080
+841080
+441100
+5F7D00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F5
-ENCODING 10485
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24BE
+ENCODING 9406
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-18
-18
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+43E100
+408100
+808080
+808080
+808080
+808080
+808080
+808080
+808080
+408100
+43E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F6
-ENCODING 10486
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 8 1 0
+STARTCHAR uni24BF
+ENCODING 9407
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+41F100
+404100
+804080
+804080
+804080
+804080
+804080
+804080
+804080
+424100
+438100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F7
-ENCODING 10487
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C0
+ENCODING 9408
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-C0
-00
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+5F3D00
+441100
+842080
+844080
+848080
+85C080
+864080
+842080
+842080
+441100
+5F3D00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F8
-ENCODING 10488
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C1
+ENCODING 9409
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-18
-18
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+47C100
+410100
+810080
+810080
+810080
+810080
+810880
+810880
+810880
+411900
+47F900
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28F9
-ENCODING 10489
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C2
+ENCODING 9410
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-18
-18
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+5C1D00
+4C1900
+8C1880
+8A2880
+8A2880
+8A4880
+894880
+894880
+888880
+488900
+5C9D00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28FA
-ENCODING 10490
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C3
+ENCODING 9411
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+5C7D00
+461100
+861080
+851080
+851080
+849080
+845080
+845080
+843080
+443100
+5F1100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28FB
-ENCODING 10491
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C4
+ENCODING 9412
+SWIDTH 2100 0
+DWIDTH 35 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-18
-18
-00
-D8
-D8
+07F000
+180C00
+200200
+43C100
+442100
+881080
+900880
+900880
+900880
+900880
+900880
+881080
+442100
+43C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28FC
-ENCODING 10492
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C5
+ENCODING 9413
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-18
-18
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+4FF100
+421900
+820880
+820880
+821880
+83F080
+820080
+820080
+820080
+420100
+4F8100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28FD
-ENCODING 10493
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C6
+ENCODING 9414
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-18
-18
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+43C100
+442100
+881080
+900880
+900880
+900880
+900880
+900880
+8B9080
+466100
+43C100
+204A00
+183C00
+07F000
 ENDCHAR
-STARTCHAR uni28FE
-ENCODING 10494
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C7
+ENCODING 9415
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-18
-18
-00
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+4FE100
+421100
+820880
+820880
+821080
+83E080
+823080
+821080
+821080
+421100
+4F8F00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR uni28FF
-ENCODING 10495
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 5 11 1 0
+STARTCHAR uni24C8
+ENCODING 9416
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
-00
-D8
-D8
+07F000
+180C00
+200200
+43E100
+442100
+842080
+840080
+820080
+818080
+804080
+802080
+842080
+442100
+47C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3131
-ENCODING 12593
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 9 2 0
+STARTCHAR uni24C9
+ENCODING 9417
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-FFE0
-6020
-0020
-0020
-0020
-0020
-0020
-0020
-0020
+07F000
+180C00
+200200
+4FF900
+488900
+888880
+888880
+808080
+808080
+808080
+808080
+808080
+408100
+43E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3132
-ENCODING 12594
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 8 2 1
+STARTCHAR uni24CA
+ENCODING 9418
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-FDF0
-0410
-0410
-0410
-0410
-0410
-0410
-0410
+07F000
+180C00
+200200
+5F7D00
+441100
+841080
+841080
+841080
+841080
+841080
+841080
+841080
+422100
+41C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3133
-ENCODING 12595
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni24CB
+ENCODING 9419
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0080
-F860
-0840
-0840
-08C0
-08A0
-0910
-0908
-0A08
+07F000
+180C00
+200200
+5E3D00
+441100
+841080
+822080
+822080
+822080
+814080
+814080
+814080
+408100
+408100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3134
-ENCODING 12596
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 7 3 2
+STARTCHAR uni24CC
+ENCODING 9420
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C000
-4000
-4000
-4000
-4000
-4060
-3FF0
+07F000
+180C00
+200200
+400100
+788F00
+908480
+908480
+914480
+894880
+894880
+894880
+8A2880
+463100
+463100
+241200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3135
-ENCODING 12597
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 0
+STARTCHAR uni24CD
+ENCODING 9421
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C3F8
-4140
-4060
-4040
-4060
-4490
-5908
-6208
-0400
+07F000
+180C00
+200200
+5E7900
+422100
+824080
+814080
+818080
+808080
+814080
+834080
+822080
+441100
+5E3D00
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3136
-ENCODING 12598
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 10 2 0
+STARTCHAR uni24CE
+ENCODING 9422
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-00F0
-C000
-400C
-43F0
-4020
-40F0
-4108
-5D08
-6108
-00F0
+07F000
+180C00
+200200
+5E3D00
+441100
+822080
+822080
+814080
+81C080
+808080
+808080
+808080
+408100
+43E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3137
-ENCODING 12599
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 8 3 2
+STARTCHAR uni24CF
+ENCODING 9423
+SWIDTH 2100 0
+DWIDTH 35 0
+BBX 17 17 1 -3
 BITMAP
-0040
-FFE0
-4000
-4000
-4000
-4000
-4070
-7FF0
+07F000
+180C00
+200200
+47F100
+462100
+842080
+844080
+804080
+808080
+811080
+811080
+821080
+423100
+47F100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3138
-ENCODING 12600
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 8 2 1
+STARTCHAR uni24D0
+ENCODING 9424
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-FDF0
-4100
-4100
-4100
-4100
-4300
-4D00
-71F8
+07F000
+180C00
+200200
+400100
+400100
+838080
+844080
+804080
+83C080
+844080
+844080
+83E080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3139
-ENCODING 12601
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 9 3 1
+STARTCHAR uni24D1
+ENCODING 9425
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0040
-FFC0
-4040
-0040
-7FC0
-4000
-4000
-4060
-7FF0
+07F000
+180C00
+230200
+410100
+410100
+810080
+810080
+81E080
+811080
+811080
+811080
+811080
+411100
+41E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 313A
-ENCODING 12602
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 8 2 1
+STARTCHAR uni24D2
+ENCODING 9426
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-FDF0
-0410
-0810
-FC10
-4010
-4010
-4210
-7C10
+07F000
+180C00
+200200
+400100
+400100
+81C080
+822080
+820080
+820080
+820080
+822080
+81C080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 313B
-ENCODING 12603
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 8 2 1
+STARTCHAR uni24D3
+ENCODING 9427
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-7CF8
-0488
-0888
-FC88
-4088
-4088
-42F8
-7C80
+07F000
+180C00
+20C200
+404100
+404100
+804080
+804080
+83C080
+844080
+844080
+844080
+844080
+444100
+43E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 313C
-ENCODING 12604
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 10 2 1
+STARTCHAR uni24D4
+ENCODING 9428
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0010
-0208
-7D08
-0508
-09F8
-FD08
-4108
-4108
-43F8
-7D08
+07F000
+180C00
+200200
+400100
+400100
+81C080
+822080
+83E080
+820080
+820080
+822080
+81C080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 313D
-ENCODING 12605
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni24D5
+ENCODING 9429
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0040
-7C20
-0460
-0840
-FC40
-40A0
-4090
-4308
-7C08
+07F000
+180C00
+20E200
+412100
+410100
+810080
+810080
+83C080
+810080
+810080
+810080
+810080
+410100
+438100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 313E
-ENCODING 12606
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni24D6
+ENCODING 9430
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0010
-7DF8
-0900
-0910
-FDF0
-4100
-4100
-4308
-7DF8
+07F000
+180C00
+200200
+41F100
+422100
+822080
+822080
+83C080
+820080
+83E080
+841080
+841080
+441100
+43E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 313F
-ENCODING 12607
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 8 2 1
+STARTCHAR uni24D7
+ENCODING 9431
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-7FF8
-0410
-0810
-FD10
-4120
-40A0
-442C
-7FF4
+07F000
+180C00
+260200
+420100
+420100
+820080
+820080
+83C080
+822080
+822080
+822080
+822080
+422100
+477100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3140
-ENCODING 12608
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 10 1 0
+STARTCHAR uni24D8
+ENCODING 9432
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-FC70
-0800
-0800
-0BFE
-78F0
-4188
-4108
-4508
-7888
-00F0
+07F000
+180C00
+200200
+418100
+418100
+800080
+800080
+818080
+808080
+808080
+808080
+808080
+408100
+41C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3141
-ENCODING 12609
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 8 3 1
+STARTCHAR uni24D9
+ENCODING 9433
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-FFE0
-4020
-4040
-4040
-4040
-4040
-7FC0
-4000
+07F000
+180C00
+20C200
+40C100
+400100
+800080
+80C080
+804080
+804080
+804080
+804080
+804080
+404100
+424100
+238200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3142
-ENCODING 12610
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 10 11 3 0
+STARTCHAR uni24DA
+ENCODING 9434
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-00C0
-C040
-4040
-4040
-7FC0
-4040
-4040
-4040
-4040
-7FC0
-0040
+07F000
+180C00
+260200
+420100
+420100
+820080
+820080
+82F080
+824080
+828080
+838080
+82C080
+424100
+477100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3143
-ENCODING 12611
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 11 2 0
+STARTCHAR uni24DB
+ENCODING 9435
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0018
-0988
-C488
-4488
-44F8
-7C88
-4488
-4488
-4488
-7CF8
-4488
+07F000
+180C00
+218200
+408100
+408100
+808080
+808080
+808080
+808080
+808080
+808080
+808080
+408100
+41C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3144
-ENCODING 12612
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 11 2 0
+STARTCHAR uni24DC
+ENCODING 9436
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0C00
-C440
-4420
-4440
-7C40
-4440
-44A0
-4490
-4508
-7E08
-4000
+07F000
+180C00
+200200
+400100
+400100
+9F7080
+888880
+888880
+888880
+888880
+888880
+9DDC80
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3145
-ENCODING 12613
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 9 3 1
+STARTCHAR uni24DD
+ENCODING 9437
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0800
-0600
-0400
-0C00
-0B00
-1080
-2060
-4020
-8010
+07F000
+180C00
+200200
+400100
+400100
+87C080
+822080
+822080
+822080
+822080
+822080
+877080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3146
-ENCODING 12614
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni24DE
+ENCODING 9438
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-1040
-0860
-0860
-1040
-18C0
-27A0
-4110
-8208
-0008
+07F000
+180C00
+200200
+400100
+400100
+81C080
+822080
+822080
+822080
+822080
+822080
+81C080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3147
-ENCODING 12615
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 9 9 4 1
+STARTCHAR uni24DF
+ENCODING 9439
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0800
-3E00
-4100
-8080
-8080
-8080
-8080
-4100
-3E00
+07F000
+180C00
+200200
+400100
+47C100
+822080
+822080
+822080
+822080
+822080
+83C080
+820080
+420100
+470100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3148
-ENCODING 12616
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 9 3 1
+STARTCHAR uni24E0
+ENCODING 9440
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0040
-FFE0
-0600
-0600
-0E00
-0900
-10C0
-6060
-8020
+07F000
+180C00
+200200
+400100
+43C100
+844080
+844080
+844080
+844080
+844080
+83C080
+804080
+404100
+40E100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3149
-ENCODING 12617
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 9 2 1
+STARTCHAR uni24E1
+ENCODING 9441
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0008
-FEF0
-5860
-1840
-10C0
-28B0
-4508
-8204
-0400
+07F000
+180C00
+200200
+400100
+400100
+834080
+81A080
+810080
+810080
+810080
+810080
+83C080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 314A
-ENCODING 12618
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 9 3 1
+STARTCHAR uni24E2
+ENCODING 9442
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-1F00
-0000
-FFE0
-4400
-0400
-0A00
-1180
-2060
-C020
+07F000
+180C00
+200200
+400100
+400100
+81E080
+822080
+820080
+81C080
+802080
+822080
+83C080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 314B
-ENCODING 12619
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 10 10 3 1
+STARTCHAR uni24E3
+ENCODING 9443
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0040
-FFC0
-6040
-0040
-01C0
-1E40
-E040
-0080
-0080
-0080
+07F000
+180C00
+200200
+410100
+410100
+830080
+87C080
+810080
+810080
+810080
+812080
+812080
+40C100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 314C
-ENCODING 12620
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 8 3 1
+STARTCHAR uni24E4
+ENCODING 9444
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-FFE0
-4000
-4000
-7FC0
-4000
-4000
-4070
-7FF0
+07F000
+180C00
+200200
+400100
+400100
+866080
+822080
+822080
+822080
+822080
+822080
+81F080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 314D
-ENCODING 12621
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni24E5
+ENCODING 9445
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0030
-7FF0
-20C0
-0040
-10C0
-0880
-0890
-0BF8
-FC00
+07F000
+180C00
+200200
+400100
+400100
+873880
+812080
+812080
+812080
+80C080
+80C080
+80C080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 314E
-ENCODING 12622
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 10 2 0
+STARTCHAR uni24E6
+ENCODING 9446
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-0F80
-0010
-FFF8
-0200
-0D00
-10C0
-1040
-1040
-18C0
-0F80
+07F000
+180C00
+200200
+400100
+400100
+9DDC80
+849080
+855080
+855080
+855080
+836080
+822080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 314F
-ENCODING 12623
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 6 14 7 -2
+STARTCHAR uni24E7
+ENCODING 9447
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C0
-40
-40
-40
-40
-44
-7C
-40
-40
-40
-40
-40
-40
-40
+07F000
+180C00
+200200
+400100
+400100
+8E7080
+824080
+818080
+818080
+818080
+824080
+8E7080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3150
-ENCODING 12624
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 6 15 6 -2
+STARTCHAR uni24E8
+ENCODING 9448
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-1C
-04
-C4
-44
-44
-44
-44
-44
-7C
-44
-44
-44
-44
-44
-44
+07F000
+180C00
+200200
+400100
+473900
+812080
+812080
+812080
+80C080
+80C080
+80C080
+808080
+448100
+470100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3151
-ENCODING 12625
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 7 15 5 -2
+STARTCHAR uni24E9
+ENCODING 9449
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-E0
-20
-20
-20
-24
-3E
-20
-20
-20
-24
-3E
-20
-20
-20
-20
+07F000
+180C00
+200200
+400100
+400100
+83E080
+824080
+824080
+808080
+812080
+812080
+83E080
+400100
+400100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3152
-ENCODING 12626
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 8 14 4 -2
+STARTCHAR uni24EA
+ENCODING 9450
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 17 1 -3
 BITMAP
-C3
-21
-21
-21
-3F
-21
-21
-21
-3F
-21
-21
-21
-21
-01
+07F000
+180C00
+200200
+41C100
+414100
+822080
+822080
+822080
+822080
+822080
+822080
+822080
+414100
+41C100
+200200
+180C00
+07F000
 ENDCHAR
-STARTCHAR 3153
-ENCODING 12627
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 6 15 5 -2
+STARTCHAR uni25A0
+ENCODING 9632
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-10
-0C
-04
-04
-04
-04
-04
-FC
-04
-04
-04
-04
-04
-04
-04
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
 ENDCHAR
-STARTCHAR 3154
-ENCODING 12628
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 9 15 3 -2
+STARTCHAR uni25A1
+ENCODING 9633
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0180
-0080
-0C80
-0480
-0480
-0480
-0480
-FC80
-0480
-0480
-0480
-0480
-0480
-0480
-0080
+FFE0
+8020
+8020
+8020
+8020
+8020
+8020
+8020
+8020
+8020
+FFE0
 ENDCHAR
-STARTCHAR 3155
-ENCODING 12629
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 6 14 5 -2
+STARTCHAR uni25A2
+ENCODING 9634
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0C
-04
-04
-04
-FC
-44
-04
-04
-04
-FC
-04
-04
-04
-04
+3F80
+4040
+8020
+8020
+8020
+8020
+8020
+8020
+8020
+4040
+3F80
 ENDCHAR
-STARTCHAR 3156
-ENCODING 12630
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 9 15 3 -2
+STARTCHAR uni25A3
+ENCODING 9635
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0380
-0880
-0480
-0480
-0480
-FC80
-4480
-0480
-0480
-0480
-7C80
-0480
-0480
-0480
-0080
+FFE0
+8020
+BFA0
+BFA0
+BFA0
+BFA0
+BFA0
+BFA0
+BFA0
+8020
+FFE0
 ENDCHAR
-STARTCHAR 3157
-ENCODING 12631
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 7 1 2
+STARTCHAR uni25A4
+ENCODING 9636
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0300
-0100
-0100
-0100
-0100
-010C
-FFFE
+FFE0
+8020
+FFE0
+8020
+FFE0
+8020
+FFE0
+8020
+FFE0
+8020
+FFE0
 ENDCHAR
-STARTCHAR 3158
-ENCODING 12632
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
+STARTCHAR uni25A5
+ENCODING 9637
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-00E0
-0020
-0020
-1C20
-0420
-0420
-0420
-043E
-0420
-05E0
-FE20
-0020
-0020
-0020
-0020
+FFE0
+AAA0
+AAA0
+AAA0
+AAA0
+AAA0
+AAA0
+AAA0
+AAA0
+AAA0
+FFE0
 ENDCHAR
-STARTCHAR 3159
-ENCODING 12633
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni25A6
+ENCODING 9638
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0030
-0190
-0090
-3090
-1090
-1090
-1090
-10F0
-1190
-1E90
-E090
-0090
-0090
-0090
-0010
+FFE0
+AAA0
+FFE0
+AAA0
+FFE0
+AAA0
+FFE0
+AAA0
+FFE0
+AAA0
+FFE0
 ENDCHAR
-STARTCHAR 315A
-ENCODING 12634
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 1 -2
+STARTCHAR uni25A7
+ENCODING 9639
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0030
-0010
-0810
-0410
-0410
-0410
-0410
-0410
-04F0
-FF10
-2010
-0010
-0010
-0010
+FFE0
+C920
+A4A0
+9260
+C920
+A4A0
+9260
+C920
+A4A0
+9260
+FFE0
 ENDCHAR
-STARTCHAR 315B
-ENCODING 12635
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 7 2 2
+STARTCHAR uni25A8
+ENCODING 9640
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1860
-0860
-0840
-0840
-0840
-0840
-FFFE
+FFE0
+9260
+A4A0
+C920
+9260
+A4A0
+C920
+9260
+A4A0
+C920
+FFE0
 ENDCHAR
-STARTCHAR 315C
-ENCODING 12636
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 -2
+STARTCHAR uni25A9
+ENCODING 9641
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0004
-FFFE
-6100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+FFE0
+D560
+AAA0
+D560
+AAA0
+D560
+AAA0
+D560
+AAA0
+D560
+FFE0
 ENDCHAR
-STARTCHAR 315D
-ENCODING 12637
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 1 -2
+STARTCHAR uni25AA
+ENCODING 9642
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 7 7 3 3
 BITMAP
-0018
-0008
-0008
-0008
-FF88
-2408
-0408
-0478
-0408
-0408
-0408
-0408
-0008
-0008
+FE
+FE
+FE
+FE
+FE
+FE
+FE
 ENDCHAR
-STARTCHAR 315E
-ENCODING 12638
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni25AB
+ENCODING 9643
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 7 7 3 3
 BITMAP
-0018
-0008
-0048
-0048
-0048
-0348
-FC48
-0848
-0BC8
-0848
-0848
-0848
-0048
-0008
-0008
+FE
+82
+82
+82
+82
+82
+FE
 ENDCHAR
-STARTCHAR 315F
-ENCODING 12639
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni25AC
+ENCODING 9644
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 6 2 3
 BITMAP
-0040
-0030
-0010
-0010
-0010
-00F0
-FF10
-0410
-0410
-0410
-0410
-0410
-0410
-0010
-0010
+FFF8
+FFF8
+FFF8
+FFF8
+FFF8
+FFF8
 ENDCHAR
-STARTCHAR 3160
-ENCODING 12640
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 -2
+STARTCHAR uni25AD
+ENCODING 9645
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 6 2 3
 BITMAP
-0006
-FFFE
-6820
-0820
-0820
-0820
-0820
-0820
-0820
-0820
-0820
-0820
+FFF8
+8008
+8008
+8008
+8008
+FFF8
 ENDCHAR
-STARTCHAR 3161
-ENCODING 12641
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 2 2 4
+STARTCHAR uni25AE
+ENCODING 9646
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 -2
 BITMAP
-001C
-FFFC
+FC
+FC
+FC
+FC
+FC
+FC
+FC
+FC
+FC
+FC
+FC
+FC
+FC
 ENDCHAR
-STARTCHAR 3162
-ENCODING 12642
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 1 -2
+STARTCHAR uni25AF
+ENCODING 9647
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 13 2 -2
 BITMAP
-0040
-0030
-0010
-0010
-0010
-0010
-0010
-0010
-01F0
-FE10
-0010
-0010
-0010
-0010
-0010
+FC
+84
+84
+84
+84
+84
+84
+84
+84
+84
+84
+84
+FC
 ENDCHAR
-STARTCHAR 3163
-ENCODING 12643
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 2 15 7 -2
+STARTCHAR uni25B0
+ENCODING 9648
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 16 6 2 3
 BITMAP
-C0
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
+1FFF
+3FFE
+3FFE
+7FFC
+7FFC
+FFF8
 ENDCHAR
-STARTCHAR 3164
-ENCODING 12644
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 0 0 0 0
+STARTCHAR uni25B1
+ENCODING 9649
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 16 6 2 3
 BITMAP
+1FFF
+2002
+2002
+4004
+4004
+FFF8
 ENDCHAR
-STARTCHAR 3165
-ENCODING 12645
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni25B2
+ENCODING 9650
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 12 2 1
 BITMAP
-0300
-C100
-4100
-4100
-4100
-4100
-4500
-59F8
-2000
-ENDCHAR
-STARTCHAR 3166
-ENCODING 12646
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+0400
+0400
+0E00
+0E00
+1F00
+1F00
+3F80
+3F80
+7FC0
+7FC0
+FFE0
+FFE0
+ENDCHAR
+STARTCHAR uni25B3
+ENCODING 9651
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 12 2 1
 BITMAP
-0010
-C1F0
-4100
-4100
-4100
-4100
-4100
-5D18
-61F8
+0400
+0400
+0A00
+0A00
+1100
+1100
+2080
+2080
+4040
+4040
+8020
+FFE0
 ENDCHAR
-STARTCHAR 3167
-ENCODING 12647
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 8 3 2
+STARTCHAR uni25B4
+ENCODING 9652
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 7 8 3 1
 BITMAP
-0180
-8080
-8080
-8100
-8180
-8240
-9420
-E810
+10
+10
+38
+38
+7C
+7C
+FE
+FE
 ENDCHAR
-STARTCHAR 3168
-ENCODING 12648
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 9 2 1
+STARTCHAR uni25B5
+ENCODING 9653
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 7 8 3 1
 BITMAP
-00C0
-C040
-40C0
-40A0
-4120
-4110
-4508
-5A08
-63FC
+10
+10
+28
+28
+44
+44
+82
+FE
 ENDCHAR
-STARTCHAR 3169
-ENCODING 12649
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 9 1 1
+STARTCHAR uni25B6
+ENCODING 9654
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 11 2 1
 BITMAP
-FB90
-1098
-1090
-9090
-6090
-40A8
-40A4
-58C4
-6080
+C000
+F000
+FC00
+FF00
+FFC0
+FFF0
+FFC0
+FF00
+FC00
+F000
+C000
 ENDCHAR
-STARTCHAR 316A
-ENCODING 12650
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 9 2 1
+STARTCHAR uni25B7
+ENCODING 9655
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 11 2 1
 BITMAP
-0018
-FFF8
-0900
-0900
-FD00
-4100
-4100
-4300
-7DFC
+C000
+B000
+8C00
+8300
+80C0
+8030
+80C0
+8300
+8C00
+B000
+C000
 ENDCHAR
-STARTCHAR 316B
-ENCODING 12651
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 10 3 0
+STARTCHAR uni25B8
+ENCODING 9656
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 8 7 3 1
 BITMAP
-0240
-F920
-2920
-2920
-EF20
-8960
-8950
-8998
-EF08
-0800
+C0
+F0
+FC
+FF
+FC
+F0
+C0
 ENDCHAR
-STARTCHAR 316C
-ENCODING 12652
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni25B9
+ENCODING 9657
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 8 7 3 1
 BITMAP
-0040
-FC60
-0460
-0460
-7C90
-4090
-4108
-4508
-79F8
+C0
+B0
+8C
+83
+8C
+B0
+C0
 ENDCHAR
-STARTCHAR 316D
-ENCODING 12653
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 9 1 1
+STARTCHAR uni25BA
+ENCODING 9658
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 7 2 1
 BITMAP
-0004
-FDFE
-4800
-0820
-F878
-4088
-4084
-4288
-7C78
+C000
+FC00
+FFC0
+FFF0
+FFC0
+FC00
+C000
 ENDCHAR
-STARTCHAR 316E
-ENCODING 12654
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 10 2 0
+STARTCHAR uni25BB
+ENCODING 9659
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 7 2 1
 BITMAP
-0018
-0108
-FC88
-8888
-88F8
-8888
-8888
-8888
-F8F8
-8008
+C000
+BC00
+83C0
+8030
+83C0
+BC00
+C000
 ENDCHAR
-STARTCHAR 316F
-ENCODING 12655
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni25BC
+ENCODING 9660
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 12 2 1
 BITMAP
-00C0
-F860
-8840
-8840
-88C0
-88A0
-8910
-FA08
-8408
+FFE0
+FFE0
+7FC0
+7FC0
+3F80
+3F80
+1F00
+1F00
+0E00
+0E00
+0400
+0400
 ENDCHAR
-STARTCHAR 3170
-ENCODING 12656
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 8 2 1
+STARTCHAR uni25BD
+ENCODING 9661
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 12 2 1
 BITMAP
-F840
-8860
-88A0
-88A0
-8890
-8910
-8908
-F9F8
+FFE0
+8020
+4040
+4040
+2080
+2080
+1100
+1100
+0A00
+0A00
+0400
+0400
 ENDCHAR
-STARTCHAR 3171
-ENCODING 12657
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 8 12 5 -1
+STARTCHAR uni25BE
+ENCODING 9662
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 7 8 3 1
 BITMAP
-FF
-82
-82
-82
 FE
-00
+FE
 7C
-C6
-82
-82
-C6
 7C
+38
+38
+10
+10
 ENDCHAR
-STARTCHAR 3172
-ENCODING 12658
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 9 2 0
+STARTCHAR uni25BF
+ENCODING 9663
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 7 8 3 1
 BITMAP
-CDF0
-4410
-4410
-7C10
-4410
-4410
-4410
-7C10
-0400
+FE
+82
+44
+44
+28
+28
+10
+10
 ENDCHAR
-STARTCHAR 3173
-ENCODING 12659
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 10 2 0
+STARTCHAR uni25C0
+ENCODING 9664
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 11 2 1
 BITMAP
-0118
-CCE0
-4480
-4480
-7C80
-4480
-4480
-4488
-7CFC
-4400
+0030
+00F0
+03F0
+0FF0
+3FF0
+FFF0
+3FF0
+0FF0
+03F0
+00F0
+0030
 ENDCHAR
-STARTCHAR 3174
-ENCODING 12660
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 10 1 0
+STARTCHAR uni25C1
+ENCODING 9665
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 11 2 1
 BITMAP
-1900
-C8BC
-4884
-4884
-7984
-4944
-4A64
-4C24
-7C04
-4000
+0030
+00D0
+0310
+0C10
+3010
+C010
+3010
+0C10
+0310
+00D0
+0030
 ENDCHAR
-STARTCHAR 3175
-ENCODING 12661
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni25C2
+ENCODING 9666
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 8 7 3 1
 BITMAP
-3200
-91F8
-9240
-9240
-F240
-9540
-94C0
-98C0
-F838
+03
+0F
+3F
+FF
+3F
+0F
+03
 ENDCHAR
-STARTCHAR 3176
-ENCODING 12662
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 10 2 0
+STARTCHAR uni25C3
+ENCODING 9667
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 8 7 3 1
 BITMAP
-1800
-CBF8
-4840
-4840
-7840
-48A0
-4890
-4918
-7A08
-4400
+03
+0D
+31
+C1
+31
+0D
+03
 ENDCHAR
-STARTCHAR 3177
-ENCODING 12663
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 10 2 0
+STARTCHAR uni25C4
+ENCODING 9668
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 7 2 1
 BITMAP
-1018
-89F8
-8900
-8900
-F9F0
-8900
-8900
-8900
-F9F8
-8000
+0030
+03F0
+3FF0
+FFF0
+3FF0
+03F0
+0030
 ENDCHAR
-STARTCHAR 3178
-ENCODING 12664
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 8 14 5 -2
+STARTCHAR uni25C5
+ENCODING 9669
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 7 2 1
 BITMAP
-03
-81
-81
-FF
-81
-81
-FF
-81
-7C
-C2
-82
-82
-C2
-7C
+0030
+03D0
+3C10
+C010
+3C10
+03D0
+0030
 ENDCHAR
-STARTCHAR 3179
-ENCODING 12665
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 2 -2
+STARTCHAR uni25C6
+ENCODING 9670
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-C510
-4510
-7DF0
-4510
-4510
-45F0
-7D00
-4000
-0F80
-10C0
-1040
-1040
-10C0
-0F80
+0400
+0E00
+1F00
+3F80
+7FC0
+FFE0
+7FC0
+3F80
+1F00
+0E00
+0400
 ENDCHAR
-STARTCHAR 317A
-ENCODING 12666
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni25C7
+ENCODING 9671
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1000
-09F8
-0808
-1808
-1808
-2808
-2608
-4208
-8008
+0400
+0A00
+1100
+2080
+4040
+8020
+4040
+2080
+1100
+0A00
+0400
 ENDCHAR
-STARTCHAR 317B
-ENCODING 12667
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 9 1 1
+STARTCHAR uni25C8
+ENCODING 9672
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1800
-0C40
-0840
-0840
-1840
-1440
-2240
-4344
-807E
+0400
+0A00
+1100
+2480
+4E40
+9F20
+4E40
+2480
+1100
+0A00
+0400
 ENDCHAR
-STARTCHAR 317C
-ENCODING 12668
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 9 1 1
+STARTCHAR uni25C9
+ENCODING 9673
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1008
-0CFC
-0880
-0880
-1880
-1480
-2280
-4280
-80FC
+1F00
+60C0
+4040
+8E20
+9F20
+9F20
+9F20
+8E20
+4040
+60C0
+1F00
 ENDCHAR
-STARTCHAR 317D
-ENCODING 12669
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 9 1 1
+STARTCHAR uni25CA
+ENCODING 9674
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 12 1 0
 BITMAP
-198C
-0C84
-0884
-08FC
-1884
-1484
-2284
-43FC
-8084
+10
+28
+28
+44
+44
+82
+82
+44
+44
+28
+28
+10
 ENDCHAR
-STARTCHAR 317E
-ENCODING 12670
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 10 1 0
+STARTCHAR uni25CB
+ENCODING 9675
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1000
-0DFC
-0820
-0830
-1820
-1430
-2250
-428C
-8084
-0100
+1F00
+60C0
+4040
+8020
+8020
+8020
+8020
+8020
+4040
+60C0
+1F00
 ENDCHAR
-STARTCHAR 317F
-ENCODING 12671
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 10 9 4 1
+STARTCHAR uni25CC
+ENCODING 9676
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0800
-0800
-1400
-1200
-2200
-4100
-4080
-8080
-FFC0
+0E00
+2080
+4040
+0000
+8020
+8020
+8020
+0000
+4040
+2080
+0E00
 ENDCHAR
-STARTCHAR 3180
-ENCODING 12672
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 7 2 1
+STARTCHAR uni25CD
+ENCODING 9677
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-78F0
-8988
-8508
-8508
-8508
-8D88
-78F0
+1F00
+6AC0
+6AC0
+AAA0
+AAA0
+AAA0
+AAA0
+AAA0
+6AC0
+6AC0
+1F00
 ENDCHAR
-STARTCHAR 3181
-ENCODING 12673
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 7 9 5 1
+STARTCHAR uni25CE
+ENCODING 9678
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-10
-10
-7C
-C6
-82
-82
-82
-C6
-7C
+1F00
+60C0
+4040
+8E20
+9120
+9120
+9120
+8E20
+4040
+60C0
+1F00
 ENDCHAR
-STARTCHAR 3182
-ENCODING 12674
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni25CF
+ENCODING 9679
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-30C0
-1060
+1F00
+7FC0
+7FC0
+FFE0
+FFE0
+FFE0
+FFE0
+FFE0
+7FC0
+7FC0
+1F00
+ENDCHAR
+STARTCHAR uni25D0
+ENCODING 9680
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
+BITMAP
+1F00
+78C0
 7840
-CC40
-84C0
-84A0
-8510
-CE08
-7808
+F820
+F820
+F820
+F820
+F820
+7840
+78C0
+1F00
 ENDCHAR
-STARTCHAR 3183
-ENCODING 12675
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 9 2 1
+STARTCHAR uni25D1
+ENCODING 9681
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1040
-1040
-78A0
-CCA0
-8490
-8510
-8508
-CD08
-7BF8
+1F00
+63C0
+43C0
+83E0
+83E0
+83E0
+83E0
+83E0
+43C0
+63C0
+1F00
 ENDCHAR
-STARTCHAR 3184
-ENCODING 12676
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 13 3 -1
+STARTCHAR uni25D2
+ENCODING 9682
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0040
-7FE0
-0180
-1100
-1100
-0100
+1F00
+7FC0
+7FC0
 FFE0
-1E00
-3180
-2080
-2080
-3180
+FFE0
+8020
+8020
+8020
+4040
+60C0
 1F00
 ENDCHAR
-STARTCHAR 3185
-ENCODING 12677
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 10 1 0
+STARTCHAR uni25D3
+ENCODING 9683
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1C38
-0000
-0202
-FEFE
-0830
-3448
-4284
-4284
-66CC
-3C78
+1F00
+60C0
+4040
+8020
+8020
+8020
+FFE0
+FFE0
+7FC0
+7FC0
+1F00
 ENDCHAR
-STARTCHAR 3186
-ENCODING 12678
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 11 3 0
+STARTCHAR uni25D4
+ENCODING 9684
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0060
-FFE0
-0000
-0000
-0000
 1F00
-3180
-2080
-2080
-3180
+67C0
+47C0
+87E0
+87E0
+87E0
+8020
+8020
+4040
+60C0
 1F00
 ENDCHAR
-STARTCHAR 3187
-ENCODING 12679
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25D5
+ENCODING 9685
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-0070
-0010
-0010
-0110
-1110
-111E
-1110
-1110
-1170
-FE9E
-0010
-0010
-0010
-0010
+1F00
+63C0
+43C0
+83E0
+83E0
+83E0
+FFE0
+FFE0
+7FC0
+7FC0
+1F00
 ENDCHAR
-STARTCHAR 3188
-ENCODING 12680
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 14 3 -2
+STARTCHAR uni25D6
+ENCODING 9686
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 11 2 1
 BITMAP
-00E0
-0160
-0960
-0560
-65E0
-2520
-2520
-25E0
-3F20
-C120
-0120
-0120
-0120
-0020
+1C
+7C
+7C
+FC
+FC
+FC
+FC
+FC
+7C
+7C
+1C
 ENDCHAR
-STARTCHAR 3189
-ENCODING 12681
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 2 -2
+STARTCHAR uni25D7
+ENCODING 9687
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 11 2 1
 BITMAP
-0030
-0010
-0010
-0110
-1110
-1110
-1110
-1110
-11F0
-FE10
-0010
-0010
-0010
-0010
+E0
+F8
+F8
+FC
+FC
+FC
+FC
+FC
+F8
+F8
+E0
 ENDCHAR
-STARTCHAR 318A
-ENCODING 12682
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 14 3 -2
+STARTCHAR uni25D8
+ENCODING 9688
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 12 2 1
 BITMAP
-0060
-0020
-0020
-0020
-7F20
-A420
-25E0
-2420
-2420
-25E0
-2420
-0420
-0020
-0020
+FE
+FE
+FE
+FE
+FE
+C6
+82
+82
+82
+C6
+FE
+FE
 ENDCHAR
-STARTCHAR 318B
-ENCODING 12683
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 1 -2
+STARTCHAR uni25D9
+ENCODING 9689
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-0018
-00C8
-0048
-0048
-00C8
-FF48
-13C8
-1248
-1248
-13C8
-1248
-0048
-0008
-0008
+FFF8
+F078
+CF98
+DFD8
+BFE8
+BFE8
+BFE8
+BFE8
+BFE8
+DFD8
+CF98
+F078
+FFF8
 ENDCHAR
-STARTCHAR 318C
-ENCODING 12684
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 2 -2
+STARTCHAR uni25DA
+ENCODING 9690
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 7 2 6
 BITMAP
-0030
-0010
-0010
-0010
-00D0
-FF10
-1110
-1110
-1110
-1110
-1110
-1110
-0010
-0010
+FFF8
+F078
+CF98
+DFD8
+BFE8
+BFE8
+BFE8
+ENDCHAR
+STARTCHAR uni25DB
+ENCODING 9691
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 7 2 0
+BITMAP
+BFE8
+BFE8
+BFE8
+DFD8
+CF98
+F078
+FFF8
+ENDCHAR
+STARTCHAR uni25DC
+ENCODING 9692
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 6 2 6
+BITMAP
+1C
+60
+40
+80
+80
+80
+ENDCHAR
+STARTCHAR uni25DD
+ENCODING 9693
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 6 6 7 6
+BITMAP
+E0
+18
+08
+04
+04
+04
 ENDCHAR
-STARTCHAR 318D
-ENCODING 12685
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 3 3 7 4
+STARTCHAR uni25DE
+ENCODING 9694
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 6 6 7 1
 BITMAP
+04
+04
+04
+08
+18
 E0
-E0
-60
 ENDCHAR
-STARTCHAR 318E
-ENCODING 12686
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 9 14 4 -2
+STARTCHAR uni25DF
+ENCODING 9695
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 6 2 1
 BITMAP
-0180
-0080
-0080
-0080
-6080
-E080
-6080
-0080
-0080
-0080
-0080
-0080
-0080
-0080
+80
+80
+80
+40
+60
+1C
 ENDCHAR
-STARTCHAR 3200
-ENCODING 12800
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E0
+ENCODING 9696
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 6 2 6
 BITMAP
-1010
-2008
-4004
-4004
-BFE2
-8022
-8022
-8022
-8022
-8022
-4024
-4024
-2008
-1010
+1F00
+60C0
+4040
+8020
+8020
+8020
 ENDCHAR
-STARTCHAR 3201
-ENCODING 12801
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E1
+ENCODING 9697
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 6 2 1
 BITMAP
-0010
-0008
-2004
-4004
-7802
-8802
-8802
-8802
-8802
-883A
-8FC4
-4004
-4008
-2010
+8020
+8020
+8020
+4040
+60C0
+1F00
 ENDCHAR
-STARTCHAR 3202
-ENCODING 12802
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E2
+ENCODING 9698
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 12 2 1
 BITMAP
-1010
-2008
-4004
-4004
-9FF2
-8802
-8802
-8802
-8802
-8802
-4FF4
-4004
-2008
-1010
+0010
+0030
+0070
+00F0
+01F0
+03F0
+07F0
+0FF0
+1FF0
+3FF0
+7FF0
+FFF0
 ENDCHAR
-STARTCHAR 3203
-ENCODING 12803
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E3
+ENCODING 9699
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 12 2 1
 BITMAP
-1010
-2008
-4004
-5FE4
-8022
-8022
-8FE2
-8802
-8802
-8802
-4FF4
-4004
-2008
-1010
+8000
+C000
+E000
+F000
+F800
+FC00
+FE00
+FF00
+FF80
+FFC0
+FFE0
+FFF0
 ENDCHAR
-STARTCHAR 3204
-ENCODING 12804
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E4
+ENCODING 9700
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 12 2 1
 BITMAP
-1010
-2008
-4004
-4004
-9FF2
-8822
-8822
-8822
-8822
-8FE2
-4804
-4004
-2008
-1010
+FFF0
+FFE0
+FFC0
+FF80
+FF00
+FE00
+FC00
+F800
+F000
+E000
+C000
+8000
 ENDCHAR
-STARTCHAR 3205
-ENCODING 12805
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E5
+ENCODING 9701
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 12 12 2 1
 BITMAP
-1010
-2008
-4004
-4064
-8822
-8822
-8FE2
-8822
-8822
-8822
-4FE4
-4824
-2008
-1010
+FFF0
+7FF0
+3FF0
+1FF0
+0FF0
+07F0
+03F0
+01F0
+00F0
+0070
+0030
+0010
 ENDCHAR
-STARTCHAR 3206
-ENCODING 12806
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E6
+ENCODING 9702
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 7 1 2
 BITMAP
-1010
-2008
-4004
-4104
-8082
-8102
-8382
-8242
-8432
-8812
-5004
-4004
-2008
-1010
+38
+44
+82
+82
+82
+44
+38
 ENDCHAR
-STARTCHAR 3207
-ENCODING 12807
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E7
+ENCODING 9703
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1000
-2008
-4104
-47C4
-8822
-9012
-9012
-9012
-9012
-8824
-47C4
-4008
-2000
-1000
+FFE0
+F820
+F820
+F820
+F820
+F820
+F820
+F820
+F820
+F820
+FFE0
 ENDCHAR
-STARTCHAR 3208
-ENCODING 12808
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E8
+ENCODING 9704
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2008
-4024
-5FF4
-8822
-8042
-8082
-8182
-8262
-8C32
-5004
-4004
-2008
-1010
+FFE0
+83E0
+83E0
+83E0
+83E0
+83E0
+83E0
+83E0
+83E0
+83E0
+FFE0
 ENDCHAR
-STARTCHAR 3209
-ENCODING 12809
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25E9
+ENCODING 9705
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2408
-43C4
-4004
-8022
-8FE2
-8042
-8182
-8242
-8C32
-7014
-4004
-2008
-1010
+FFE0
+FFE0
+FFA0
+FF20
+FE20
+FC20
+F820
+F020
+E020
+C020
+FFE0
 ENDCHAR
-STARTCHAR 320A
-ENCODING 12810
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25EA
+ENCODING 9706
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2008
-4014
-4FF4
-8812
-8012
-80E2
-8F22
-8022
-8042
-4044
-4084
-2008
-1010
+FFE0
+8060
+80E0
+81E0
+83E0
+87E0
+8FE0
+9FE0
+BFE0
+FFE0
+FFE0
 ENDCHAR
-STARTCHAR 320B
-ENCODING 12811
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25EB
+ENCODING 9707
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2008
-4024
-4FE4
-8802
-8802
-8822
-8FE2
-8802
-8802
-4FFC
-4004
-2008
-1010
+FFE0
+8420
+8420
+8420
+8420
+8420
+8420
+8420
+8420
+8420
+FFE0
 ENDCHAR
-STARTCHAR 320C
-ENCODING 12812
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25EC
+ENCODING 9708
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 12 2 1
 BITMAP
-0010
-0008
-2004
-5FF4
-4002
-80C2
-8442
-8442
-8282
-8082
-BFFC
-4004
-4008
-2010
+0400
+0400
+0A00
+0A00
+1100
+1100
+2080
+2480
+4E40
+4440
+8020
+FFE0
 ENDCHAR
-STARTCHAR 320D
-ENCODING 12813
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25ED
+ENCODING 9709
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 12 2 1
 BITMAP
-1010
-2008
-4004
-43C4
-8002
-9FFA
-8102
-87C2
-8822
-8822
-4824
-47C4
-2008
-1010
+0400
+0400
+0E00
+0E00
+1D00
+1D00
+3C80
+3C80
+7C40
+7C40
+FC20
+FFE0
 ENDCHAR
-STARTCHAR 320E
-ENCODING 12814
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25EE
+ENCODING 9710
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 12 2 1
 BITMAP
-1010
-2068
-4024
-4024
-9FA2
-8122
-8122
-823E
-8422
-8822
-7024
-4024
-2028
-1010
+0400
+0400
+0E00
+0E00
+1700
+1700
+2780
+2780
+47C0
+47C0
+87E0
+FFE0
 ENDCHAR
-STARTCHAR 320F
-ENCODING 12815
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25EF
+ENCODING 9711
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 13 13 2 0
 BITMAP
-1010
-2068
-4024
-6024
-9022
-9022
-9022
-903A
-90A2
-9F22
-4024
-4024
-2028
-1010
+1FC0
+2020
+4010
+8008
+8008
+8008
+8008
+8008
+8008
+8008
+4010
+2020
+1FC0
 ENDCHAR
-STARTCHAR 3210
-ENCODING 12816
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F0
+ENCODING 9712
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2068
-4024
-4124
-9FA2
-9022
-9022
-903A
-90A2
-9F22
-4024
-4024
-2028
-1010
+FFE0
+8420
+8420
+8420
+8420
+FC20
+8020
+8020
+8020
+8020
+FFE0
 ENDCHAR
-STARTCHAR 3211
-ENCODING 12817
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F1
+ENCODING 9713
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2068
-4024
-4024
-BF22
-8122
-8122
-9F3A
-9022
-9022
-53A4
-5C24
-2028
-1010
+FFE0
+8020
+8020
+8020
+8020
+FC20
+8420
+8420
+8420
+8420
+FFE0
 ENDCHAR
-STARTCHAR 3212
-ENCODING 12818
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F2
+ENCODING 9714
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2068
-4024
-4024
-BF22
-9122
-9122
-913E
-9F22
-9022
-4024
-4024
-2028
-1010
+FFE0
+8020
+8020
+8020
+8020
+87E0
+8420
+8420
+8420
+8420
+FFE0
 ENDCHAR
-STARTCHAR 3213
-ENCODING 12819
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F3
+ENCODING 9715
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2068
-4024
-4324
-9122
-9122
-9F22
-913A
-9122
-9F22
-5024
-4024
-2028
-1010
+FFE0
+8420
+8420
+8420
+8420
+87E0
+8020
+8020
+8020
+8020
+FFE0
 ENDCHAR
-STARTCHAR 3214
-ENCODING 12820
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F4
+ENCODING 9716
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2068
-4024
-4624
-8222
-8422
-8422
-8B3E
-91A2
-8022
-4024
-4024
-2028
-1010
+1F00
+64C0
+4440
+8420
+8420
+FC20
+8020
+8020
+4040
+60C0
+1F00
 ENDCHAR
-STARTCHAR 3215
-ENCODING 12821
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F5
+ENCODING 9717
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2028
-4024
-4C24
-9E22
-A322
-A122
-A13A
-B322
-9E22
-4024
-4024
-2028
-1010
+1F00
+60C0
+4040
+8020
+8020
+FC20
+8420
+8420
+4440
+64C0
+1F00
 ENDCHAR
-STARTCHAR 3216
-ENCODING 12822
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F6
+ENCODING 9718
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2068
-4024
-4024
-9F22
-8222
-8422
-8A3A
-91A2
-A022
-4024
-4024
-2028
-1010
+1F00
+60C0
+4040
+8020
+8020
+87E0
+8420
+8420
+4440
+64C0
+1F00
 ENDCHAR
-STARTCHAR 3217
-ENCODING 12823
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni25F7
+ENCODING 9719
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2028
-4024
-4E24
-8022
-9F22
-8222
-843A
-8B22
-90A2
-4024
-4024
-2028
-1010
+1F00
+64C0
+4440
+8420
+8420
+87E0
+8020
+8020
+4040
+60C0
+1F00
 ENDCHAR
-STARTCHAR 3218
-ENCODING 12824
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2741
+ENCODING 10049
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 11 11 2 1
 BITMAP
-1010
-2068
-4024
-4024
-9F22
-8122
-8222
-9E3E
-8422
-8822
-5024
-4024
-2028
-1010
+1700
+2880
+4540
+B520
+8A40
+B5A0
+4A20
+95A0
+5440
+2280
+1D00
 ENDCHAR
-STARTCHAR 3219
-ENCODING 12825
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2800
+ENCODING 10240
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 0 0 0 0
 BITMAP
-1010
-2068
-4024
-4024
-BF22
-9022
-9F22
-903E
-9062
-9FA2
-4024
-4024
-2028
-1010
 ENDCHAR
-STARTCHAR 321A
-ENCODING 12826
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2801
+ENCODING 10241
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 1 9
 BITMAP
-1010
-2068
-4024
-41A4
-9E22
-9122
-8922
-893A
-82A2
-BD22
-4024
-4024
-2028
-1010
+C0
+C0
 ENDCHAR
-STARTCHAR 321B
-ENCODING 12827
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2802
+ENCODING 10242
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 1 6
 BITMAP
-1000
-2060
-4028
-4E24
-8024
-BFA2
-8722
-88BA
-88A2
-88A2
-4724
-4024
-2028
-1008
+C0
+C0
 ENDCHAR
-STARTCHAR 321C
-ENCODING 12828
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -1
+STARTCHAR uni2803
+ENCODING 10243
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 5 1 6
 BITMAP
-0008
-5FE4
-80C4
-8182
-8282
-8C72
-9002
-BFFA
-8102
-8102
-8104
-4104
-0108
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3260
-ENCODING 12896
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2804
+ENCODING 10244
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 1 3
 BITMAP
-07C0
-1830
-2008
-600C
-4004
-9FF2
-8012
-8012
-8012
-8012
-8012
-4014
-601C
-2018
-1830
-07C0
+C0
+C0
 ENDCHAR
-STARTCHAR 3261
-ENCODING 12897
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2805
+ENCODING 10245
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 1 3
 BITMAP
-07C0
-1830
-2008
-600C
-5804
-8802
-8802
-8802
-8802
-8812
-87FA
-4004
-600C
-2008
-1830
-07C0
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3262
-ENCODING 12898
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
-BITMAP
-07C0
-1830
-2008
-600C
-4004
-8FF2
-8802
-8802
-8802
-8802
-8802
-4FF4
-600C
-2008
-1830
-07C0
+STARTCHAR uni2806
+ENCODING 10246
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 5 1 3
+BITMAP
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3263
-ENCODING 12899
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2807
+ENCODING 10247
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 1 3
 BITMAP
-07C0
-1830
-2008
-400C
-5FE4
-8022
-8022
-8FE2
-8802
-8802
-8802
-4FF4
-600C
-2018
-1830
-07C0
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3264
-ENCODING 12900
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2808
+ENCODING 10248
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 4 9
 BITMAP
-07C0
-1830
-2008
-600C
-4004
-9FF2
-8822
-8822
-8822
-8822
-8FE2
-4804
-600C
-2008
-1830
-07C0
+C0
+C0
 ENDCHAR
-STARTCHAR 3265
-ENCODING 12901
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2809
+ENCODING 10249
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 2 1 9
 BITMAP
-07C0
-1830
-2008
-606C
-4824
-8822
-8FE2
-8822
-8822
-8822
-8FE2
-4824
-600C
-2008
-1830
-07C0
+D8
+D8
 ENDCHAR
-STARTCHAR 3266
-ENCODING 12902
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni280A
+ENCODING 10250
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 6
 BITMAP
-07C0
-1830
-2008
-400C
-4184
-8182
-8102
-8282
-8642
-8832
-9012
-4004
-600C
-2008
-1830
-07C0
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3267
-ENCODING 12903
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni280B
+ENCODING 10251
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 6
 BITMAP
-07C0
-1830
-2008
-600C
-4104
-87C2
-8C32
-8812
-8812
-8812
-8C22
-47C4
-600C
-2008
-1830
-07C0
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3268
-ENCODING 12904
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni280C
+ENCODING 10252
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2008
-400C
-4024
-9FF2
-8822
-8042
-80C2
-8182
-8262
-4C14
-600C
-2008
-1830
-07C0
+18
+18
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3269
-ENCODING 12905
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni280D
+ENCODING 10253
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2008
-440C
-43C4
-8022
-9FF2
-8862
-80C2
-8182
-8242
-4C34
-600C
-2008
-1830
-07C0
+D8
+D8
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 326A
-ENCODING 12906
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni280E
+ENCODING 10254
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2008
-600C
-4014
-9FF2
-8012
-8012
-80F2
-9F22
-8022
-4044
-604C
-2088
-1830
-07C0
+18
+18
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 326B
-ENCODING 12907
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni280F
+ENCODING 10255
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2008
-402C
-4FE4
-8802
-8802
-8802
-8FE2
-8802
-8802
-4FFC
-600C
-2008
-1830
-07C0
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 326C
-ENCODING 12908
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2810
+ENCODING 10256
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 4 6
 BITMAP
-07C0
-1830
-2008
-600C
-5FF4
-80C2
-8042
-8442
-8482
-8082
-BFFA
-4004
-600C
-2008
-1830
-07C0
+C0
+C0
 ENDCHAR
-STARTCHAR 326D
-ENCODING 12909
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2811
+ENCODING 10257
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 6
 BITMAP
-07C0
-1830
-2008
-400C
-43C4
-8002
-BFFA
-8102
-87C2
-8822
-8822
-4824
-67CC
-2008
-1830
-07C0
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR 326E
-ENCODING 12910
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2812
+ENCODING 10258
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 2 1 6
 BITMAP
-07C0
-1830
-2008
-402C
-4024
-9F22
-8122
-8222
-843E
-8822
-9022
-4024
-602C
-2028
-1830
-07C0
+D8
+D8
 ENDCHAR
-STARTCHAR 326F
-ENCODING 12911
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2813
+ENCODING 10259
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 6
 BITMAP
-07C0
-1830
-2008
-602C
-4024
-9022
-9022
-9022
-903A
-93A2
-9C22
-4024
-602C
-2028
-1830
-07C0
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR 3270
-ENCODING 12912
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2814
+ENCODING 10260
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 3
 BITMAP
-07C0
-1830
-2048
-602C
-4024
-BF22
-9022
-9022
-903A
-9062
-9FA2
-4024
-602C
-2028
-1830
-07C0
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3271
-ENCODING 12913
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2815
+ENCODING 10261
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2008
-602C
-4024
-9F22
-8122
-BF22
-903E
-9022
-97A2
-5824
-602C
-2028
-1830
-07C0
+C0
+C0
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3272
-ENCODING 12914
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2816
+ENCODING 10262
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 3
 BITMAP
-07C0
-1830
-2008
-402C
-4024
-9F22
-9122
-9122
-923E
-9F22
-9022
-4024
-602C
-2028
-1830
-07C0
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3273
-ENCODING 12915
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2817
+ENCODING 10263
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2008
-402C
-4324
-9122
-9122
-9F22
-913A
-9122
-9F22
-5124
-602C
-2028
-1830
-07C0
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3274
-ENCODING 12916
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2818
+ENCODING 10264
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 5 4 6
 BITMAP
-07C0
-1830
-2048
-602C
-4424
-8222
-8422
-8422
-8B3A
-9122
-A022
-4024
-602C
-2028
-1830
-07C0
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3275
-ENCODING 12917
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2819
+ENCODING 10265
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 6
 BITMAP
-07C0
-1830
-2008
-402C
-4824
-9E22
-A322
-A122
-A13E
-A322
-9E22
-4024
-602C
-2028
-1830
-07C0
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR 3276
-ENCODING 12918
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni281A
+ENCODING 10266
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 6
 BITMAP
-07C0
-1830
-2008
-602C
-4024
-BF22
-8222
-8622
-863E
-8922
-B022
-4024
-602C
-2028
-1830
-07C0
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR 3277
-ENCODING 12919
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni281B
+ENCODING 10267
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 6
 BITMAP
-07C0
-1830
-2048
-602C
-4624
-8022
-BF22
-8322
-823E
-8622
-8922
-7024
-602C
-2028
-1830
-07C0
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR 3278
-ENCODING 12920
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni281C
+ENCODING 10268
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2048
-402C
-4024
-9F22
-8122
-BE22
-823A
-8422
-8822
-5024
-602C
-2028
-1830
-07C0
+18
+18
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 3279
-ENCODING 12921
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni281D
+ENCODING 10269
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2008
-402C
-4024
-BF22
-9022
-9F22
-903E
-90A2
-9F22
-4024
-602C
-2028
-1830
-07C0
+D8
+D8
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 327A
-ENCODING 12922
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni281E
+ENCODING 10270
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2048
-602C
-4124
-9E22
-9122
-892A
-8A32
-83E2
-BC22
-4024
-602C
-2028
-1830
-07C0
+18
+18
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 327B
-ENCODING 12923
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni281F
+ENCODING 10271
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-07C0
-1830
-2048
-602C
-4E24
-8022
-BFA2
-9E2A
-B132
-A122
-B122
-5E24
-602C
-2028
-1830
-07C0
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR 327F
-ENCODING 12927
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -1
+STARTCHAR uni2820
+ENCODING 10272
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 4 3
 BITMAP
-0FC0
-3060
-6010
-4888
-8908
-8A00
-EE3C
-090C
-8988
-C898
-6850
-3060
-0F80
+C0
+C0
 ENDCHAR
-STARTCHAR AC00
-ENCODING 44032
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 2 -2
+STARTCHAR uni2821
+ENCODING 10273
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0080
-0060
-0020
-FE20
-0220
-0420
-0420
-083E
-1020
-1020
-6020
-8020
-0020
-0020
-0020
+C0
+C0
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AC01
-ENCODING 44033
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni2822
+ENCODING 10274
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 3
 BITMAP
-0040
-0030
-0010
-7F10
-0310
-0210
-041E
-0810
-1010
-2000
-DFF0
-0010
-0010
-0010
-0010
-0010
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AC04
-ENCODING 44036
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
+STARTCHAR uni2823
+ENCODING 10275
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0060
-0020
-7E20
-0420
-0420
-0820
-103C
-2020
-4020
-B820
-0800
-0800
-0800
-0FF0
+C0
+C0
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AC07
-ENCODING 44039
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2824
+ENCODING 10276
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 2 1 3
 BITMAP
-0060
-0020
-0020
-FE20
-0220
-043C
-0820
-1020
-2020
-4020
-1FE0
-0800
-0800
-0800
-0FF0
+D8
+D8
 ENDCHAR
-STARTCHAR AC08
-ENCODING 44040
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2825
+ENCODING 10277
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0060
-0020
-0020
-FE20
-0620
-043C
-0820
-1020
-2000
-5FE0
-8020
-0020
-0FE0
-0800
-0FF0
+C0
+C0
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC09
-ENCODING 44041
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2826
+ENCODING 10278
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 3
 BITMAP
-00E0
-0020
-FE20
-0620
-0424
-0838
-1020
-2020
-4000
-7DE0
-0420
-7C20
-2020
-2220
-3C20
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC0A
-ENCODING 44042
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 3 -2
+STARTCHAR uni2827
+ENCODING 10279
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-FC40
-0C40
-0840
-1048
-2070
-4040
-8040
-7BC0
-0A40
-DA40
-6240
-47C0
-7A00
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC10
-ENCODING 44048
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
+STARTCHAR uni2828
+ENCODING 10280
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 4 3
 BITMAP
-00C0
-0060
-0020
-FE20
-0620
-0420
-083C
-1020
-2020
-4000
-9FE0
-0820
-0820
-0840
-0FE0
-0800
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC11
-ENCODING 44049
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
+STARTCHAR uni2829
+ENCODING 10281
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-0060
-0020
-FE20
-0620
-0420
-083C
-1020
-2020
-5020
-8820
-0FE0
-0820
-0820
-0FE0
-0820
+D8
+D8
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AC12
-ENCODING 44050
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
+STARTCHAR uni282A
+ENCODING 10282
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0080
-0060
-0020
-FE20
-0620
-0420
-083C
-1020
-2020
-6260
-9220
-1E40
-1270
-1290
-1F08
-1200
+18
+18
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AC13
-ENCODING 44051
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni282B
+ENCODING 10283
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0060
-0020
-0020
-FE20
-0620
-043C
-0820
-1020
-2020
-4120
-8100
-0380
-0660
-0830
-1010
+D8
+D8
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AC14
-ENCODING 44052
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni282C
+ENCODING 10284
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-0060
-0020
-FE20
-0620
-0420
-083C
-1020
-2020
-5840
-8860
-0840
-16A0
-2310
-4000
+18
+18
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC15
-ENCODING 44053
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni282D
+ENCODING 10285
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0060
-0020
-0020
-FE20
-0620
-043C
-0820
-1020
-2020
-4180
-8660
-0420
-0420
-0660
-03C0
+D8
+D8
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC16
-ENCODING 44054
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
+STARTCHAR uni282E
+ENCODING 10286
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-0060
-0020
-FE20
-0620
-0420
-083C
-1020
-2020
-4000
-BFC0
-0300
-0680
-0860
-1010
-2000
+18
+18
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC17
-ENCODING 44055
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
+STARTCHAR uni282F
+ENCODING 10287
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-0020
-FE20
-0220
-0420
-082C
-1030
-2020
-4380
-8000
-3FF0
-0100
-0280
-0470
-1818
-2000
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC19
-ENCODING 44057
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2830
+ENCODING 10288
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 5 4 3
 BITMAP
-00C0
-0060
-0020
-FE20
-0620
-0420
-083C
-1020
-2020
-4000
-8FE0
-0800
-0FE0
-0800
-0FF0
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC1A
-ENCODING 44058
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
+STARTCHAR uni2831
+ENCODING 10289
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-0060
-0020
-FE20
-0620
-0420
-083C
-1020
-2020
-4000
-9FE0
-0840
-0440
-0480
-3FF0
-1800
+C0
+C0
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AC1B
-ENCODING 44059
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
+STARTCHAR uni2832
+ENCODING 10290
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 3
 BITMAP
-0100
-00C0
-FE40
-0440
-0C40
-1840
-1070
-6040
-8040
-0740
-7E80
-0300
-0C80
-0880
-0700
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AC1C
-ENCODING 44060
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2833
+ENCODING 10291
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0030
-0190
-0090
-0090
-FC90
-0890
-0890
-10F0
-1090
-2090
-4090
-8090
-0090
-0090
-0010
+C0
+C0
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AC1D
-ENCODING 44061
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni2834
+ENCODING 10292
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 3
 BITMAP
-0030
-0110
-0090
-FC90
-0C90
-0890
-10F0
-1090
-2090
-4090
-1FF0
-0010
-0010
-0010
-0010
-0010
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC20
-ENCODING 44064
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2835
+ENCODING 10293
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0030
-0110
-0090
-FC90
-0C90
-0890
-1890
-10F0
-2090
-4090
-9090
-0890
-0800
-0800
-0FF8
+C0
+C0
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC24
-ENCODING 44068
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2836
+ENCODING 10294
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 3
 BITMAP
-0030
-0190
-0090
-FC90
-0C90
-0890
-10F0
-1090
-2090
-4090
-1FF0
-0020
-0FF0
-0800
-0FF0
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC2C
-ENCODING 44076
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni2837
+ENCODING 10295
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0030
-0190
-0090
-FC90
-0C90
-0890
-10F0
-1090
-2090
-4090
-0FF0
-0410
-0420
-0420
-07F0
-0400
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC2D
-ENCODING 44077
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni2838
+ENCODING 10296
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 4 3
 BITMAP
-0030
-0190
-0090
-FC90
-0C90
-0890
-10F0
-1090
-2090
-48B0
-0410
-07F0
-0410
-0410
-07F0
-0410
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC2F
-ENCODING 44079
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2839
+ENCODING 10297
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0030
-0090
-0090
-FC90
-0490
-0890
-10F0
-1090
-2090
-4190
-0080
-0180
-0260
-0410
-1808
+D8
+D8
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AC30
-ENCODING 44080
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -2
+STARTCHAR uni283A
+ENCODING 10298
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0330
-0090
-FC90
-0490
-0890
-08F0
-1090
-2090
-44B0
-0420
-0C60
-0A50
-1088
-6100
+18
+18
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AC31
-ENCODING 44081
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni283B
+ENCODING 10299
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0030
-0190
-0090
-FC90
-0C90
-0890
-18F0
-1090
-2090
-4090
-03E0
-0630
-0410
-0410
-0630
-01E0
+D8
+D8
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AC38
-ENCODING 44088
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni283C
+ENCODING 10300
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00E0
-0020
-0020
-FE20
-0220
-043C
-0420
-0820
-1020
-102C
-6030
-8020
-0020
-0020
-0020
+18
+18
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC39
-ENCODING 44089
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
+STARTCHAR uni283D
+ENCODING 10301
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-0060
-0020
-FE20
-0620
-0438
-0820
-1820
-203C
-4020
-8000
-3FE0
-1020
-0020
-0020
-0020
-0020
+D8
+D8
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC3C
-ENCODING 44092
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni283E
+ENCODING 10302
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-0040
-0040
-FE40
-0478
-0840
-0840
-1040
-2078
-4040
-A040
-1000
-1000
-1020
-1FE0
+18
+18
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC40
-ENCODING 44096
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni283F
+ENCODING 10303
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 3
 BITMAP
-00C0
-0060
-FE20
-0620
-042C
-0830
-1020
-2020
-4038
-8020
-1FE0
-0020
-1FE0
-0800
-0FF0
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AC4B
-ENCODING 44107
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2840
+ENCODING 10304
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 1 0
 BITMAP
-0060
-0020
-0020
-FE2C
-0630
-0420
-0824
-1038
-2220
-4120
-0100
-0280
-0460
-0810
-1000
+C0
+C0
 ENDCHAR
-STARTCHAR AC4D
-ENCODING 44109
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2841
+ENCODING 10305
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 1 0
 BITMAP
-0060
-0020
-FE20
-0620
-043C
-0820
-1020
-202C
-4130
-83A0
-0440
-0820
-0820
-0460
-0380
+C0
+C0
+00
+00
+00
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC54
-ENCODING 44116
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni2842
+ENCODING 10306
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 1 0
 BITMAP
-0018
-0088
-0088
-0088
-7E88
-06F8
-0488
-0488
-0888
-10F8
-1088
-2088
-C088
-0088
-0008
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC58
-ENCODING 44120
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 1 -2
+STARTCHAR uni2843
+ENCODING 10307
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 1 0
 BITMAP
-0098
-0048
-7E48
-0448
-0478
-0848
-1878
-1048
-6048
-8848
-0408
-0400
-0400
-07FC
+C0
+C0
+00
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC5C
-ENCODING 44124
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2844
+ENCODING 10308
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 5 1 0
 BITMAP
-0020
-0190
-0090
-FC90
-0CF0
-0890
-10F0
-2090
-4090
-9FE0
-0020
-1FE0
-0800
-0800
-0FF0
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC70
-ENCODING 44144
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2845
+ENCODING 10309
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 1 0
 BITMAP
-0070
-0030
-0010
-FF10
-0210
-0610
-0410
-09F0
-0810
-1010
-2010
-C010
-0010
-0010
-0010
+C0
+C0
+00
+00
+00
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC71
-ENCODING 44145
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni2846
+ENCODING 10310
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 1 0
 BITMAP
-0018
-0008
-4308
-3D08
-0208
-0278
-0408
-0808
-1008
-6FF8
-8408
-0008
-0008
-0008
-0008
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC74
-ENCODING 44148
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2847
+ENCODING 10311
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 1 0
 BITMAP
-0030
-0010
-0010
-7E10
-0210
-0410
-09F0
-0810
-1010
-6010
-B010
-0810
-0800
-0810
-0FF0
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC77
-ENCODING 44151
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2848
+ENCODING 10312
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FE10
-0610
-0410
-09F0
-1810
-3010
-4010
-8020
-1FE0
-0800
-0800
-0800
-0FF0
+18
+18
+00
+00
+00
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC78
-ENCODING 44152
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2849
+ENCODING 10313
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0020
-0010
-FE10
-0210
-0410
-0DF0
-0810
-1010
-2010
-C010
-1FF0
-0020
-1FF0
-0800
-0FF0
+D8
+D8
+00
+00
+00
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC7A
-ENCODING 44154
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni284A
+ENCODING 10314
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F10
-0210
-0410
-05F0
-0810
-1010
-6010
-8000
-3DE0
-0520
-3D20
-11E0
-1700
-0800
+18
+18
+00
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC80
-ENCODING 44160
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni284B
+ENCODING 10315
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FE10
-0210
-0410
-0DF0
-0810
-1010
-2010
-C000
-1FE0
-0820
-0820
-0840
-0FE0
-0800
+D8
+D8
+00
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC81
-ENCODING 44161
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni284C
+ENCODING 10316
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FE10
-0210
-0410
-0CF0
-0810
-1010
-2010
-C830
-0420
-07E0
-0420
-0420
-07E0
-0420
+18
+18
+00
+00
+00
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC83
-ENCODING 44163
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni284D
+ENCODING 10317
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FF10
-0210
-0410
-0DF0
-0810
-1010
-2010
-C110
-0100
-0380
-0660
-0C30
-1018
+D8
+D8
+00
+00
+00
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC84
-ENCODING 44164
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni284E
+ENCODING 10318
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FE10
-0610
-05F0
-0810
-1810
-1010
-6040
-8420
-0420
-0A60
-1290
-2108
-4200
+18
+18
+00
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC85
-ENCODING 44165
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni284F
+ENCODING 10319
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FF10
-0210
-0410
-0DF0
-0810
-1010
-2010
-C010
-0080
-0360
-0410
-0410
-0630
-03E0
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC86
-ENCODING 44166
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 1 -3
+STARTCHAR uni2850
+ENCODING 10320
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0018
-0008
-4308
-3D08
-0208
-0278
-0408
-0808
-1000
-6018
-8FF8
-00C0
-00C0
-0130
-0208
-0C04
+18
+18
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC89
-ENCODING 44169
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2851
+ENCODING 10321
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FE10
-0210
-0410
-09F0
-0810
-1010
-6010
-8000
-0FE0
-0820
-0FE0
-0800
-07F0
+C0
+C0
+00
+18
+18
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC8A
-ENCODING 44170
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2852
+ENCODING 10322
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0010
-FE10
-0210
-0410
-0DF0
-0810
-1010
-2030
-DFF0
-0000
-0060
-0440
-0440
-3FF8
+D8
+D8
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC8B
-ENCODING 44171
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2853
+ENCODING 10323
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0210
-7E10
-0410
-0CF0
-0810
-1010
-6010
-83D0
-1F20
-01C0
-0220
-0260
-03C0
+C0
+C0
+00
+D8
+D8
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC8C
-ENCODING 44172
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2854
+ENCODING 10324
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0060
-0030
-0190
-0090
-FC90
-0890
-0890
-0F90
-1090
-2090
-2090
-4090
-0090
-0090
-0090
+18
+18
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC90
-ENCODING 44176
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2855
+ENCODING 10325
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0110
-0090
-FC90
-0490
-0890
-0F90
-1090
-2090
-4090
-9090
-0890
-0800
-0800
-0FF8
+C0
+C0
+00
+18
+18
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC94
-ENCODING 44180
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni2856
+ENCODING 10326
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0060
-0220
-0120
-F920
-1920
-1120
-3F20
-2120
-4120
-BFC0
-0040
-0040
-3FC0
-1000
-1FE0
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC9C
-ENCODING 44188
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni2857
+ENCODING 10327
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0090
-0490
-7C90
-0890
-0F90
-1090
-2090
-4080
-8FF0
-0420
-0420
-0420
-07F0
-0400
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC9D
-ENCODING 44189
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni2858
+ENCODING 10328
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0110
-0090
-FC90
-0490
-0890
-0F90
-1090
-2080
-48B0
-8410
-07F0
-0410
-0410
-07F0
-0410
+18
+18
+00
+18
+18
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AC9F
-ENCODING 44191
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
+STARTCHAR uni2859
+ENCODING 10329
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0220
-0120
-F920
-1920
-1120
-3F20
-2120
-4120
-8620
-0100
-0300
-0480
-0860
-3010
+D8
+D8
+00
+18
+18
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACA0
-ENCODING 44192
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni285A
+ENCODING 10330
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0110
-0090
-FC90
-0490
-0890
-1F90
-1090
-2090
-4000
-0430
-0420
-0A50
-1288
-2108
+18
+18
+00
+D8
+D8
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACA1
-ENCODING 44193
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni285B
+ENCODING 10331
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0110
-0090
-FC90
-0490
-0890
-0F90
-1090
-2090
-43C0
-8660
-0420
-0420
-0660
-03C0
+D8
+D8
+00
+D8
+D8
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACA8
-ENCODING 44200
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni285C
+ENCODING 10332
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0010
-7E10
-03F0
-0410
-0410
-0810
-11F0
-2010
-4010
-8010
-0010
-0010
-0010
+18
+18
+00
+18
+18
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACA9
-ENCODING 44201
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni285D
+ENCODING 10333
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0030
-FE10
-0210
-04F0
-0410
-0810
-11F0
-2010
-DFF0
-0010
-0010
-0010
-0010
-0010
+D8
+D8
+00
+18
+18
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACAA
-ENCODING 44202
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni285E
+ENCODING 10334
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0018
-4308
-3D08
-0278
-0208
-0408
-08F8
-1008
-6008
-8F78
-0108
-0108
-0108
-0108
+18
+18
+00
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACAC
-ENCODING 44204
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
+STARTCHAR uni285F
+ENCODING 10335
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-0020
-FE20
-05E0
-0820
-0820
-1020
-21E0
-4020
-B820
-0800
-0800
-0810
-0FF0
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACAF
-ENCODING 44207
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 2 -1
+STARTCHAR uni2860
+ENCODING 10336
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 0
 BITMAP
-0030
-0010
-7F10
-0230
-07F0
-0410
-0810
-11F0
-2010
-C020
-1FE0
-0800
-0810
-0FF0
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACB0
-ENCODING 44208
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2861
+ENCODING 10337
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0030
-FE10
-0610
-04F0
-0810
-1810
-33F0
-4010
-8010
-1FE0
-0020
-1FE0
-0800
-0FF8
+C0
+C0
+00
+00
+00
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACB8
-ENCODING 44216
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 16 3 -3
+STARTCHAR uni2862
+ENCODING 10338
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-00C0
-0060
-FE20
-0420
-07E0
-0820
-1020
-2020
-43E0
-8020
-1FE0
-0820
-0840
-0840
-0FE0
-0800
+C0
+C0
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACB9
-ENCODING 44217
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni2863
+ENCODING 10339
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0030
-FE10
-0210
-04F0
-0C10
-0810
-11F0
-2010
-C810
-0410
-07F0
-0410
-0410
-07F0
-0410
+C0
+C0
+00
+C0
+C0
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACBB
-ENCODING 44219
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2864
+ENCODING 10340
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 0
 BITMAP
-0030
-0010
-FF10
-0270
-03F0
-0410
-0C10
-0810
-11F0
-6110
-0190
-0190
-0240
-0430
-1818
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACBC
-ENCODING 44220
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2865
+ENCODING 10341
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0030
-FE10
-0210
-04F0
-0C10
-0810
-11F0
-2010
-C070
-0C30
-0820
-1E50
-1288
-6108
+C0
+C0
+00
+00
+00
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACBD
-ENCODING 44221
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2866
+ENCODING 10342
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0060
-0030
-FE10
-0210
-04F0
-0C10
-0810
-11F0
-2010
-C090
-0360
-0410
-0410
-0630
-03E0
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACC1
-ENCODING 44225
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2867
+ENCODING 10343
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0030
-FE10
-0210
-04F0
-0C10
-0810
-11F0
-2010
-C000
-07F0
-0400
-07F0
-0400
-07F8
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACC4
-ENCODING 44228
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2868
+ENCODING 10344
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0190
-0490
-7C90
-0F90
-0890
-0890
-1790
-2090
-4090
-8090
-0090
-0090
-0010
+18
+18
+00
+00
+00
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACC8
-ENCODING 44232
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
+STARTCHAR uni2869
+ENCODING 10345
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0220
-0120
-F920
-0920
-1720
-3120
-2F20
-4120
-8120
-6120
-1020
-1000
-1000
-1FF0
+D8
+D8
+00
+00
+00
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACCC
-ENCODING 44236
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni286A
+ENCODING 10346
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0220
-0120
-F920
-0920
-1720
-1120
-2F20
-7FC0
-8040
-0040
-3FC0
-1000
-1000
-1FE0
+18
+18
+00
+C0
+C0
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACD5
-ENCODING 44245
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni286B
+ENCODING 10347
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0090
-FC90
-0490
-0B90
-0890
-1790
-2090
-48B0
-0410
-07F0
-0410
-0410
-07F0
-0410
+D8
+D8
+00
+C0
+C0
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACD7
-ENCODING 44247
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni286C
+ENCODING 10348
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0030
-0090
-FC90
-0490
-0B90
-1890
-1790
-2090
-4190
-8090
-0180
-0240
-0430
-1808
+18
+18
+00
+00
+00
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACE0
-ENCODING 44256
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 10 2 0
+STARTCHAR uni286D
+ENCODING 10349
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-7FF0
-0030
-0020
-0020
-0620
-0240
-0240
-0200
-0200
-FFFC
+D8
+D8
+00
+00
+00
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACE1
-ENCODING 44257
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni286E
+ENCODING 10350
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-1FF8
-0010
-0310
-0100
-0100
-FFFE
-0000
-00F0
-1F10
-0010
-0010
-0010
-0010
+18
+18
+00
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACE4
-ENCODING 44260
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni286F
+ENCODING 10351
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-3FF8
-0008
-0010
-0310
-0110
-0100
-FFFE
-0000
-0000
-1800
-0800
-0800
-0FF8
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACE7
-ENCODING 44263
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2870
+ENCODING 10352
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0018
-1FF8
-0010
-0310
-0100
-0100
-FFFE
-2000
-0000
-1FE0
-0800
-0800
-0800
-0FF8
+18
+18
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACE8
-ENCODING 44264
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2871
+ENCODING 10353
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-1FF8
-0010
-0310
-0100
-0100
-FFFE
-2000
-0000
-1FE0
-0020
-1FF0
-0800
-0FF0
+C0
+C0
+00
+18
+18
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACEA
-ENCODING 44266
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
+STARTCHAR uni2872
+ENCODING 10354
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-3FF8
-0010
-0010
-0310
-0100
-0100
-FFFE
-0000
-0000
-1EF8
-0288
-3690
-1890
-13F0
-1C80
+D8
+D8
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACEC
-ENCODING 44268
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2873
+ENCODING 10355
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-1FF8
-0310
-0110
-0100
-01FE
-FF00
-0000
-1E10
-0230
-3E30
-1048
-1284
-1C00
+C0
+C0
+00
+D8
+D8
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACEF
-ENCODING 44271
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2874
+ENCODING 10356
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-1FF8
-0010
-0010
-0110
-0100
-FFFE
-0000
-00F0
-1E00
-02F8
-1ED0
-1088
-1688
-0870
+18
+18
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACF0
-ENCODING 44272
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
+STARTCHAR uni2875
+ENCODING 10357
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0038
-1FD8
-0010
-0310
-0100
-0100
-FFFE
-2000
-0000
-1FE0
-0820
-0820
-0820
-0FE0
-0800
+C0
+C0
+00
+18
+18
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACF1
-ENCODING 44273
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
+STARTCHAR uni2876
+ENCODING 10358
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0038
-1FD8
-0010
-0310
-0100
-0100
-FFFE
-0000
-1060
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACF3
-ENCODING 44275
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
+STARTCHAR uni2877
+ENCODING 10359
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-2078
-1F98
-0010
-0310
-0100
-0100
-FFFE
-0000
-0200
-0100
-0300
-06C0
-0830
-1010
-2000
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACF5
-ENCODING 44277
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2878
+ENCODING 10360
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-1FF8
-0010
-0310
-0100
-0100
-FFFE
-0000
-0100
-06C0
-0820
-0820
-0C60
-07C0
+18
+18
+00
+18
+18
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACF6
-ENCODING 44278
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2879
+ENCODING 10361
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-1FF8
-0010
-0310
-0100
-0100
-FFFE
-2000
-3FF8
-0100
-0380
-0660
-0810
-3008
+D8
+D8
+00
+18
+18
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACFC
-ENCODING 44284
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni287A
+ENCODING 10362
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-0020
-7F20
-0120
-0120
-1220
-0A3C
-0820
-0BE0
-F420
-0020
-0020
-0020
-0020
+18
+18
+00
+D8
+D8
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ACFD
-ENCODING 44285
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni287B
+ENCODING 10363
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-0110
-1910
-0912
-087C
-FF90
-0010
-0000
-0FF0
-0010
-0010
-0010
-0010
-0010
+D8
+D8
+00
+D8
+D8
+00
+18
+18
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD00
-ENCODING 44288
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni287C
+ENCODING 10364
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-0020
-7F20
-0120
-3220
-122C
-10F0
-FF20
-0020
-0020
-0800
-0800
-0800
-0FF8
+18
+18
+00
+18
+18
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD04
-ENCODING 44292
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni287D
+ENCODING 10365
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-7F20
-0120
-3220
-122C
-10F0
-FF20
-0020
-0000
-1FE0
-0040
-1FE0
-0800
-0FF0
+D8
+D8
+00
+18
+18
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD06
-ENCODING 44294
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
+STARTCHAR uni287E
+ENCODING 10366
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-7F20
-0120
-0220
-1220
-102C
-13F0
-FC20
-7C30
-05D0
-7D20
-2120
-3DE0
-0100
+18
+18
+00
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD0C
-ENCODING 44300
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni287F
+ENCODING 10367
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-7F20
-0120
-1220
-123C
-13E0
-FC20
-0000
-0FE0
-0820
-0820
-0840
-0FE0
-0800
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD0D
-ENCODING 44301
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2880
+ENCODING 10368
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 2 4 0
 BITMAP
-0060
-0020
-7F20
-0120
-3220
-122C
-11F0
-FE20
-0000
-1020
-0820
-0FE0
-0820
-0FE0
-0820
+C0
+C0
 ENDCHAR
-STARTCHAR AD0F
-ENCODING 44303
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni2881
+ENCODING 10369
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-FF20
-0120
-2120
-1220
-127C
-1FA0
-E020
-0300
-0100
-0380
-0240
-0C30
-1010
+C0
+C0
+00
+00
+00
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD11
-ENCODING 44305
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
+STARTCHAR uni2882
+ENCODING 10370
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0010
-3F90
-0090
-0110
-0916
-0838
-DFD0
-2010
-0080
-03E0
-0630
-0410
-0630
-03E0
+C0
+C0
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD18
-ENCODING 44312
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni2883
+ENCODING 10371
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0080
-0260
-0120
-0120
-F920
-0920
-4920
-29E0
-2120
-3F20
-C120
-0120
-0120
-0120
-0020
+C0
+C0
+00
+C0
+C0
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD1C
-ENCODING 44316
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
+STARTCHAR uni2884
+ENCODING 10372
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 0
+BITMAP
+C0
+C0
+00
+18
+18
+ENDCHAR
+STARTCHAR uni2885
+ENCODING 10373
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-0088
-0048
-7F48
-0248
-0248
-1A48
-0878
-09C8
-FE48
-0848
-0448
-0400
-0400
-03FC
+C0
+C0
+00
+00
+00
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD20
-ENCODING 44320
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 2 -2
+STARTCHAR uni2886
+ENCODING 10374
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-01B0
-0090
-FC90
-0490
-3490
-14F0
-1390
-FC90
-0090
-1FE0
-0020
-1FE0
-0800
-0FF0
+C0
+C0
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD29
-ENCODING 44329
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni2887
+ENCODING 10375
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0190
-0090
-FE90
-0490
-3490
-14F0
-1390
-FC90
-0CB0
-0420
-07E0
-0420
-0420
-07E0
-0420
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD2C
-ENCODING 44332
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 16 2 -3
+STARTCHAR uni2888
+ENCODING 10376
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 4 0
 BITMAP
-0030
-0190
-0090
-FC90
-0490
-3490
-14F0
-1390
-FC90
-00D0
-0C20
-0840
-0C60
-1298
-2108
-C000
+C0
+C0
+00
+00
+00
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD2D
-ENCODING 44333
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni2889
+ENCODING 10377
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0090
-0090
-FE90
-0490
-3490
-14F0
-1790
-F890
-0090
-03E0
-0630
-0410
-0630
-03E0
+D8
+D8
+00
+00
+00
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD34
-ENCODING 44340
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni288A
+ENCODING 10378
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-0020
-FF20
-0220
-0220
-1220
-1420
-10E0
-3F20
-C020
-0020
-0020
-0020
-0020
+18
+18
+00
+C0
+C0
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD35
-ENCODING 44341
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni288B
+ENCODING 10379
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-3F90
-0090
-1910
-0910
-0870
-FF90
-0010
-0000
-1FF0
-0810
-0010
-0010
-0010
-0010
+D8
+D8
+00
+C0
+C0
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD38
-ENCODING 44344
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni288C
+ENCODING 10380
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0010
-7F90
-0110
-1910
-0910
-08F0
-FF10
-0010
-0010
-1800
-0800
-0800
-07F8
+18
+18
+00
+00
+00
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD3C
-ENCODING 44348
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
+STARTCHAR uni288D
+ENCODING 10381
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-FF20
-0220
-3220
-1220
-11E0
-FE20
-0000
-3FC0
-0040
-3FC0
-1000
-1000
-1FF0
+D8
+D8
+00
+00
+00
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD44
-ENCODING 44356
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni288E
+ENCODING 10382
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-0090
-1910
-0910
-0870
-FF90
-0010
-0000
-0BF0
-0410
-0420
-0420
-07F0
-0400
+18
+18
+00
+C0
+C0
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD45
-ENCODING 44357
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni288F
+ENCODING 10383
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-0110
-1110
-0910
-0870
-FF90
-0010
-0C10
-0410
-07F0
-0410
-0410
-07F0
-0410
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD47
-ENCODING 44359
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni2890
+ENCODING 10384
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 4 0
 BITMAP
-0030
-0010
-7F90
-0110
-0110
-0910
-0810
-09F0
-FE10
-0010
-0180
-0180
-0240
-0430
-1808
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD49
-ENCODING 44361
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni2891
+ENCODING 10385
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-FF20
-0220
-0220
-1220
-1020
-1FE0
-E020
-0120
-06C0
-0820
-0820
-0C60
-07C0
+C0
+C0
+00
+18
+18
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD50
-ENCODING 44368
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 10 1 0
+STARTCHAR uni2892
+ENCODING 10386
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-3FF8
-0008
-0008
-0010
-0990
-0490
-0490
-0480
-0480
-FFFE
+D8
+D8
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD54
-ENCODING 44372
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 -1
+STARTCHAR uni2893
+ENCODING 10387
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0008
-0010
-0850
-0440
-0444
-FFFE
-1000
-0800
-0800
-0800
-07F8
+C0
+C0
+00
+D8
+D8
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD58
-ENCODING 44376
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -1
+STARTCHAR uni2894
+ENCODING 10388
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-3FF0
-0020
-01A0
-09A0
-0900
-FFFC
-0000
-3FE0
-0020
-0040
-1FE0
-1000
-0FF0
+18
+18
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD61
-ENCODING 44385
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -2
+STARTCHAR uni2895
+ENCODING 10389
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-3FF0
-01A0
-09A0
-0920
-FFFC
-0000
-3040
-1040
-1FC0
-1040
-1040
-1FC0
-1040
+C0
+C0
+00
+18
+18
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD63
-ENCODING 44387
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni2896
+ENCODING 10390
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-1FF8
-0008
-0010
-0850
-0450
-0440
-FFFE
-0100
-0100
-0380
-0660
-0818
-1008
+D8
+D8
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD6C
-ENCODING 44396
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni2897
+ENCODING 10391
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-0020
-FFDE
-0120
-0100
-0100
-0100
-0100
-0100
-0100
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD6D
-ENCODING 44397
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni2898
+ENCODING 10392
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 4 0
 BITMAP
-1FE0
-0010
-0010
-0020
-0020
-FFFE
-0100
-0100
-3FE0
-0020
-0020
-0020
-0020
-0020
+C0
+C0
+00
+C0
+C0
+00
+00
+00
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD70
-ENCODING 44400
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni2899
+ENCODING 10393
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF0
-0010
-0010
-0020
-0020
-FFDE
-0120
-0100
-1900
-0900
-0800
-0800
-07F8
+D8
+D8
+00
+18
+18
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD73
-ENCODING 44403
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni289A
+ENCODING 10394
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-FFFE
-0100
-0100
-0100
-1FF0
-0800
-0800
-0800
-0FF0
+18
+18
+00
+D8
+D8
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD74
-ENCODING 44404
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni289B
+ENCODING 10395
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FE0
-0010
-0010
-0010
-0020
-FFFE
-0100
-0100
-1F20
-00E0
-0020
-1FF0
-0800
-0FF8
+D8
+D8
+00
+D8
+D8
+00
+00
+00
+00
+18
+18
 ENDCHAR
-STARTCHAR AD75
-ENCODING 44405
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni289C
+ENCODING 10396
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0010
-0020
-FFFE
-0100
-1F30
-0250
-3E10
-1010
-1310
-1C10
+18
+18
+00
+18
+18
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD76
-ENCODING 44406
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni289D
+ENCODING 10397
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-FFFE
-0100
-0100
-1EF8
-0248
-1E48
-1048
-1E78
-0040
+D8
+D8
+00
+18
+18
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD7B
-ENCODING 44411
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni289E
+ENCODING 10398
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-FFFE
-0100
-0160
-1E10
-03FC
-3620
-18D8
-1188
-1EC8
-0070
+18
+18
+00
+D8
+D8
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD7C
-ENCODING 44412
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni289F
+ENCODING 10399
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF0
-0010
-0010
-0020
-0020
-FFFE
-0100
-0100
-0100
-0FE0
-0820
-0820
-0FE0
-0800
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
+00
+18
+18
 ENDCHAR
-STARTCHAR AD7D
-ENCODING 44413
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni28A0
+ENCODING 10400
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 5 4 0
 BITMAP
-1FF8
-0010
-0010
-0020
-0020
-FFFE
-0100
-0100
-0960
-0420
-07E0
-0420
-07E0
-0420
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD7F
-ENCODING 44415
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -3
+STARTCHAR uni28A1
+ENCODING 10401
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-0020
-FFFE
-0100
-0100
-0300
-0100
-0280
-0460
-1810
-2000
+C0
+C0
+00
+00
+00
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AD81
-ENCODING 44417
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni28A2
+ENCODING 10402
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-1FF0
-0010
-0020
-0020
-03FE
-FF00
-0100
-0100
-07C0
-0C60
-0820
-0C60
-07C0
+C0
+C0
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AD82
-ENCODING 44418
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni28A3
+ENCODING 10403
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-3FF0
-0010
-0010
-0020
-0020
-FFFE
-0100
-0100
-01F8
-1F00
-0300
-06C0
-0830
-3008
+C0
+C0
+00
+C0
+C0
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AD88
-ENCODING 44424
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28A4
+ENCODING 10404
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 0
 BITMAP
-0030
-0010
-FF10
-0310
-0210
-0210
-0210
-0F10
-F810
-09F0
-0810
-0810
-0810
-0810
-0010
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AD89
-ENCODING 44425
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni28A5
+ENCODING 10405
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FF10
-0210
-0210
-0310
-FC10
-08F0
-0810
-0800
-1FF0
-0010
-0010
-0010
-0010
-0010
+C0
+C0
+00
+00
+00
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AD8C
-ENCODING 44428
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28A6
+ENCODING 10406
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0010
-0010
-3F10
-0110
-0210
-0390
-FC10
-09F0
-0810
-0010
-0C00
-0400
-0400
-03F8
+C0
+C0
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AD90
-ENCODING 44432
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
+STARTCHAR uni28A7
+ENCODING 10407
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-0008
-3F88
-0188
-0108
-0108
-FF88
-2478
-0408
-0400
-07F8
-0008
-07F8
-0200
-03FC
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AD9C
-ENCODING 44444
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni28A8
+ENCODING 10408
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 4 0
 BITMAP
-0030
-0010
-7F10
-0110
-0210
-0390
-FC10
-08F0
-0810
-0060
-0420
-0420
-0A50
-1188
-2104
+C0
+C0
+00
+00
+00
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR AD9D
-ENCODING 44445
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 1 -2
+STARTCHAR uni28A9
+ENCODING 10409
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-3F88
-0108
-0108
-02C8
-FD08
-0478
-0408
-0448
-01A0
-0210
-0210
-0330
-01E0
+D8
+D8
+00
+00
+00
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR ADA4
-ENCODING 44452
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni28AA
+ENCODING 10410
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0120
-00A0
-FCA0
-04A0
-04A0
-08A0
-0CA0
-F0A0
-17A0
-10A0
-10A0
-10A0
-00A0
-0020
+18
+18
+00
+C0
+C0
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR ADB7
-ENCODING 44471
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
+STARTCHAR uni28AB
+ENCODING 10411
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-0068
-0028
-7E28
-0228
-0228
-0428
-FE28
-09E8
-08A8
-0840
-0080
-0160
-0218
-0C0C
+D8
+D8
+00
+C0
+C0
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR ADC0
-ENCODING 44480
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28AC
+ENCODING 10412
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-FF10
-0310
-0210
-0210
-0210
-0790
-F810
-0810
-0810
-0810
-0810
-0810
-0010
+18
+18
+00
+00
+00
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADC1
-ENCODING 44481
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni28AD
+ENCODING 10413
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0020
-0010
-3F90
-0110
-0110
-02F0
-FF10
-0410
-0410
-0410
-3FE0
-0020
-0020
-0020
-0020
-0020
+D8
+D8
+00
+00
+00
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADC4
-ENCODING 44484
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28AE
+ENCODING 10414
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F10
-0110
-0110
-0230
-01D0
-FE10
-0410
-0410
-0010
-1810
-0800
-0800
-0FF8
+18
+18
+00
+C0
+C0
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADC8
-ENCODING 44488
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28AF
+ENCODING 10415
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0020
-0010
-7F90
-0090
-0110
-01F0
-FF10
-0410
-0410
-0FF0
-0010
-0FF0
-0400
-0400
-07F8
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADD0
-ENCODING 44496
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni28B0
+ENCODING 10416
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 8 4 0
 BITMAP
-0020
-0010
-3F90
-0110
-0110
-01F0
-FF10
-0410
-0410
-0010
-0FF0
-0410
-0420
-0420
-07F0
-0400
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ADD1
-ENCODING 44497
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni28B1
+ENCODING 10417
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-3F90
-0110
-0110
-01F0
-FF90
-0410
-0410
-0C30
-0410
-07F0
-0410
-0410
-07F0
-0410
+C0
+C0
+00
+18
+18
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR ADD3
-ENCODING 44499
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28B2
+ENCODING 10418
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0020
-0010
-3F90
-0110
-0110
-02F0
-FF90
-0410
-0410
-0590
-0190
-0180
-0240
-0C30
-1008
+D8
+D8
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR ADDC
-ENCODING 44508
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -2
+STARTCHAR uni28B3
+ENCODING 10419
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-3FF0
-0020
-0020
-0020
-0040
-FFFC
-0840
-0840
-0840
-0840
-0840
-0840
-0840
+C0
+C0
+00
+D8
+D8
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR ADE0
-ENCODING 44512
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -2
+STARTCHAR uni28B4
+ENCODING 10420
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-3FE0
-0020
-0040
-0040
-0040
-FFFC
-0880
-0880
-4880
-2880
-2080
-2000
-3FE0
+18
+18
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADE4
-ENCODING 44516
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -2
+STARTCHAR uni28B5
+ENCODING 10421
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-3FE0
-0020
-0040
-0040
-FFFC
-0880
-0880
-3FC0
-0040
-3FC0
-1000
-1000
-1FE0
+C0
+C0
+00
+18
+18
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADF8
-ENCODING 44536
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 10 1 0
+STARTCHAR uni28B6
+ENCODING 10422
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-3FF8
-0018
-0010
-0010
-0010
-0010
-0020
-0020
-FFFE
-2000
+D8
+D8
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADF9
-ENCODING 44537
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni28B7
+ENCODING 10423
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0010
-FFFE
-0000
-0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR ADFC
-ENCODING 44540
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 -1
+STARTCHAR uni28B8
+ENCODING 10424
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 2 11 4 0
 BITMAP
-1FF8
-0018
-0010
-0010
-0010
-FFFE
-0000
-3800
-0800
-0800
-0800
-07F8
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
 ENDCHAR
-STARTCHAR ADFF
-ENCODING 44543
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 -1
+STARTCHAR uni28B9
+ENCODING 10425
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-FFFE
-0000
-0000
-0FF0
-0800
-0800
-0800
-0FF0
+D8
+D8
+00
+18
+18
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AE00
-ENCODING 44544
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 12 2 -1
+STARTCHAR uni28BA
+ENCODING 10426
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF0
-0010
-0020
-0020
-FFFC
-0000
-0000
-1FE0
-0040
-1FE0
-0800
-0FF0
+18
+18
+00
+D8
+D8
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AE01
-ENCODING 44545
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni28BB
+ENCODING 10427
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-FFFE
-0000
-0000
-1E10
-02F0
-3E10
-1010
-1310
-1C10
+D8
+D8
+00
+D8
+D8
+00
+18
+18
+00
+18
+18
 ENDCHAR
-STARTCHAR AE08
-ENCODING 44552
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni28BC
+ENCODING 10428
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-FFFE
-0000
-0000
-0FF0
-0410
-0410
-0410
-07F0
-0400
+18
+18
+00
+18
+18
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AE09
-ENCODING 44553
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni28BD
+ENCODING 10429
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0010
-0010
-0020
-FFFE
-0000
-0860
-0420
-07E0
-0420
-0420
-07E0
-0420
+D8
+D8
+00
+18
+18
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AE0B
-ENCODING 44555
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni28BE
+ENCODING 10430
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0018
-0010
-0010
-0020
-FFFE
-2000
-0100
-0100
-0280
-0460
-0818
-3008
+18
+18
+00
+D8
+D8
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AE0D
-ENCODING 44557
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -2
+STARTCHAR uni28BF
+ENCODING 10431
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-1FF8
-0018
-0010
-0010
-FFFE
-0000
-0100
-07C0
-0C60
-0820
-0820
-0C60
-03C0
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
+00
+18
+18
 ENDCHAR
-STARTCHAR AE14
-ENCODING 44564
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28C0
+ENCODING 10432
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 2 1 0
 BITMAP
-0030
-0010
-0010
-7F90
-0110
-0110
-0110
-0110
-0030
-FFD0
-6010
-0010
-0010
-0010
-0010
+D8
+D8
 ENDCHAR
-STARTCHAR AE30
-ENCODING 44592
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28C1
+ENCODING 10433
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0010
-0010
-7F10
-0210
-0410
-0410
-0810
-1010
-2010
-4010
-8010
-0010
-0010
-0010
+C0
+C0
+00
+00
+00
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE31
-ENCODING 44593
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28C2
+ENCODING 10434
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0010
-FF10
-0210
-0610
-0410
-0810
-1010
-6010
-9FF0
-0010
-0010
-0010
-0010
-0010
+C0
+C0
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE34
-ENCODING 44596
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
+STARTCHAR uni28C3
+ENCODING 10435
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-0020
-FE20
-0420
-0820
-0820
-1020
-2020
-4020
-F020
-1020
-1000
-1020
-1FF0
+C0
+C0
+00
+C0
+C0
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE37
-ENCODING 44599
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -1
+STARTCHAR uni28C4
+ENCODING 10436
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 0
 BITMAP
-0030
-0010
-7E10
-0210
-0410
-0810
-0810
-1010
-6000
-9FE0
-0800
-0800
-0810
-0FF8
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE38
-ENCODING 44600
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28C5
+ENCODING 10437
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7E10
-0210
-0410
-0410
-0810
-1010
-2000
-DFE0
-0020
-1FE0
-0800
-0800
-0FF0
+C0
+C0
+00
+00
+00
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE3A
-ENCODING 44602
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28C6
+ENCODING 10438
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0010
-FE10
-0410
-0410
-0810
-1010
-2010
-C400
-3DE0
-0920
-7D20
-2120
-21E0
-3D00
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE40
-ENCODING 44608
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28C7
+ENCODING 10439
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7E10
-0210
-0410
-0410
-0810
-1010
-2010
-C7F0
-0410
-0410
-0420
-07F0
-0400
+C0
+C0
+00
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE41
-ENCODING 44609
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28C8
+ENCODING 10440
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7E10
-0210
-0410
-0410
-0810
-1010
-2000
-CC10
-0410
-07F0
-0410
-07F0
-0410
+18
+18
+00
+00
+00
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE43
-ENCODING 44611
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28C9
+ENCODING 10441
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7E10
-0210
-0410
-0410
-0810
-1010
-2010
-C190
-0180
-0140
-0230
-0C18
-1000
+D8
+D8
+00
+00
+00
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE45
-ENCODING 44613
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni28CA
+ENCODING 10442
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-00C0
-0060
-0620
-7C20
-0420
-0820
-1020
-2020
-4020
-8120
-0680
-0840
-0840
-0CC0
-0780
+18
+18
+00
+C0
+C0
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE46
-ENCODING 44614
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
+STARTCHAR uni28CB
+ENCODING 10443
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-FE20
-0420
-0820
-1820
-3020
-4020
-8000
-21F0
-1F00
-0300
-04C0
-0830
-3010
+D8
+D8
+00
+C0
+C0
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE4A
-ENCODING 44618
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28CC
+ENCODING 10444
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7E10
-0210
-0410
-0410
-0810
-1010
-2010
-DFF0
-0000
-0460
-0440
-0040
-3FF8
+18
+18
+00
+00
+00
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE4C
-ENCODING 44620
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 2 -2
+STARTCHAR uni28CD
+ENCODING 10445
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0040
-0020
-0020
-FFA0
-1120
-1120
-2220
-623E
-4620
-8420
-0820
-1020
-0020
-0020
-0020
+D8
+D8
+00
+00
+00
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE4D
-ENCODING 44621
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28CE
+ENCODING 10446
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0080
-0040
-3340
-DF40
-2240
-4448
-4470
-8840
-3040
-7FC0
-0040
-0040
-0040
-0040
-0040
+18
+18
+00
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE4E
-ENCODING 44622
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28CF
+ENCODING 10447
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0080
-0040
-3340
-DF40
-2240
-4458
-4460
-8840
-1040
-0040
-7BC0
-0840
-0840
-0840
-0840
+D8
+D8
+00
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE50
-ENCODING 44624
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
+STARTCHAR uni28D0
+ENCODING 10448
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0060
-0010
-0010
-3F90
-0910
-1110
-221E
-4210
-8410
-0810
-0810
-0410
-0400
-0400
-07F8
+18
+18
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE54
-ENCODING 44628
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28D1
+ENCODING 10449
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0080
-0040
-3340
-DF40
-2240
-4448
-4470
-8840
-1040
-3FC0
-0080
-3FC0
-1000
-1000
-1FE0
+C0
+C0
+00
+18
+18
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE56
-ENCODING 44630
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
+STARTCHAR uni28D2
+ENCODING 10450
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0060
-F920
-1720
-1120
-2224
-4438
-8020
-7C00
-05F0
-0920
-3120
-2120
-3DE0
-0100
+D8
+D8
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE5C
-ENCODING 44636
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28D3
+ENCODING 10451
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0080
-0040
-3340
-DF40
-2240
-2448
-4470
-8840
-1040
-3FC0
-0840
-0840
-0840
-0FC0
-0800
+C0
+C0
+00
+D8
+D8
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE5D
-ENCODING 44637
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28D4
+ENCODING 10452
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0080
-0040
-3340
-DF40
-2240
-2448
-4470
-8840
-1040
-3040
-0840
-0FC0
-0840
-0FC0
-0840
+18
+18
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE5F
-ENCODING 44639
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28D5
+ENCODING 10453
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0180
-0040
-0040
-FF40
-2240
-2240
-4478
-8840
-1440
-2240
-0600
-0500
-08C0
-1060
-6020
+C0
+C0
+00
+18
+18
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE60
-ENCODING 44640
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -1
+STARTCHAR uni28D6
+ENCODING 10454
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0040
-0020
-19A0
-7FA0
-1120
-222C
-2230
-C420
-0800
-1420
-0C20
-0C60
-1290
-2088
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE61
-ENCODING 44641
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28D7
+ENCODING 10455
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0080
-0040
-3340
-DF40
-2240
-2448
-4470
-8840
-1040
-2340
-0CC0
-0840
-0840
-0CC0
-0780
+C0
+C0
+00
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE65
-ENCODING 44645
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28D8
+ENCODING 10456
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0080
-0040
-3340
-DF40
-2240
-2448
-4470
-8840
-1040
-20C0
-1F00
-1000
-1FC0
-1000
-1FE0
+18
+18
+00
+18
+18
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE68
-ENCODING 44648
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28D9
+ENCODING 10457
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0190
-0090
-0290
-7E90
-2490
-2490
-48F0
-8890
-1090
-1090
-2090
-0090
-0090
-0010
+D8
+D8
+00
+18
+18
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE69
-ENCODING 44649
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni28DA
+ENCODING 10458
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-0048
-0048
-7F48
-0948
-1248
-2278
-4448
-8848
-1040
-0FF8
-0008
-0008
-0008
-0008
+18
+18
+00
+D8
+D8
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE6C
-ENCODING 44652
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
+STARTCHAR uni28DB
+ENCODING 10459
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-00C8
-0048
-0048
-3F48
-1148
-1248
-2478
-4448
-8848
-1048
-0248
-0200
-0200
-03FC
+D8
+D8
+00
+D8
+D8
+00
+00
+00
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE70
-ENCODING 44656
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28DC
+ENCODING 10460
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0020
-0110
-0090
-7E90
-2290
-2490
-44F0
-8890
-1090
-2FF0
-0010
-0FF0
-0400
-0400
-07F8
+18
+18
+00
+18
+18
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE78
-ENCODING 44664
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni28DD
+ENCODING 10461
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-00C8
-0048
-7F48
-1348
-1248
-2478
-4448
-8848
-1040
-07F8
-0208
-0210
-03F8
-0200
+D8
+D8
+00
+18
+18
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE79
-ENCODING 44665
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
+STARTCHAR uni28DE
+ENCODING 10462
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0130
-0090
-0090
-7E90
-2290
-24F0
-4490
-8890
-1080
-2C10
-0410
-07F0
-0410
-0410
-07F0
-0410
+18
+18
+00
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE7B
-ENCODING 44667
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
+STARTCHAR uni28DF
+ENCODING 10463
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-0048
-0048
-7FC8
-0948
-1148
-1278
-2448
-C448
-08C8
-0040
-00C0
-0120
-0218
-0C04
+D8
+D8
+00
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE7C
-ENCODING 44668
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28E0
+ENCODING 10464
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 0
 BITMAP
-0060
-0190
-0090
-7E90
-1290
-2490
-44F0
-8890
-1090
-0860
-0420
-0460
-0A50
-1088
-6108
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE7D
-ENCODING 44669
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28E1
+ENCODING 10465
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0190
-0090
-7E90
-1290
-2490
-44F0
-8890
-1090
-0090
-0160
-0210
-0210
-0330
-01E0
+C0
+C0
+00
+00
+00
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE84
-ENCODING 44676
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
+STARTCHAR uni28E2
+ENCODING 10466
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0060
-0020
-0020
-7FA0
-0920
-113C
-2220
-2220
-4420
-843C
-0820
-1020
-0020
-0020
-0020
+C0
+C0
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE85
-ENCODING 44677
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
+STARTCHAR uni28E3
+ENCODING 10467
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0070
-0010
-0010
-7F92
-199C
-1110
-2210
-421E
-8410
-0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+C0
+C0
+00
+C0
+C0
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AE8C
-ENCODING 44684
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
+STARTCHAR uni28E4
+ENCODING 10468
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 5 1 0
 BITMAP
-00E0
-FFA0
-1120
-332C
-2230
-4420
-882C
-1030
-1FE0
-0020
-1FE0
-0800
-0800
-0FF0
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEBC
-ENCODING 44732
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28E5
+ENCODING 10469
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0010
-3F90
-0890
-1110
-11F0
-2210
-4210
-8410
-0810
-1010
-0010
-0010
-0010
+C0
+C0
+00
+00
+00
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEBD
-ENCODING 44733
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28E6
+ENCODING 10470
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0010
-7F90
-1190
-11F0
-2210
-4410
-8810
-0010
-3FE0
-0020
-0020
-0020
-0020
-0020
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEBE
-ENCODING 44734
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28E7
+ENCODING 10471
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-1190
-11F0
-2210
-4410
-8810
-0010
-47E0
-3C20
-0420
-0420
-0420
-0420
+C0
+C0
+00
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEC0
-ENCODING 44736
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
+STARTCHAR uni28E8
+ENCODING 10472
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-0020
-FF20
-2220
-6220
-45E0
-8820
-0820
-3020
-3820
-0800
-0800
-0800
-0FF8
+18
+18
+00
+00
+00
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEC4
-ENCODING 44740
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28E9
+ENCODING 10473
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-1190
-11F0
-2210
-4410
-8410
-1800
-0FF0
-0010
-0FF0
-0400
-0400
-07F8
+D8
+D8
+00
+00
+00
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AECC
-ENCODING 44748
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28EA
+ENCODING 10474
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-1990
-11F0
-2210
-4210
-8410
-0810
-0FF0
-0410
-0420
-0420
-07F0
-0400
+18
+18
+00
+C0
+C0
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AECD
-ENCODING 44749
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28EB
+ENCODING 10475
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-1990
-11F0
-2210
-4210
-8410
-0800
-0820
-0420
-07E0
-0420
-07E0
-0420
+D8
+D8
+00
+C0
+C0
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AECF
-ENCODING 44751
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28EC
+ENCODING 10476
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-0890
-1110
-11F0
-2210
-4410
-8410
-0910
-0190
-0180
-0260
-0410
-1808
+18
+18
+00
+00
+00
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AED0
-ENCODING 44752
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28ED
+ENCODING 10477
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-0890
-1110
-21F0
-4210
-8410
-0800
-0830
-0430
-0C20
-0A50
-1188
-2108
+D8
+D8
+00
+00
+00
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AED1
-ENCODING 44753
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28EE
+ENCODING 10478
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-1990
-11F0
-2210
-4210
-8410
-0810
-0080
-0360
-0410
-0410
-0630
-03E0
+18
+18
+00
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AED8
-ENCODING 44760
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni28EF
+ENCODING 10479
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0020
-0098
-0048
-1948
-3748
-1248
-2248
-25C8
-4448
-8848
-1048
-0048
-0048
-0048
-0008
+D8
+D8
+00
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AED9
-ENCODING 44761
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28F0
+ENCODING 10480
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0110
-0090
-FE90
-2490
-4490
-4B90
-9090
-1090
-0080
-1FF0
-1010
-0010
-0010
-0010
+18
+18
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEDC
-ENCODING 44764
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
+STARTCHAR uni28F1
+ENCODING 10481
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0018
-0088
-0048
-7F48
-1248
-1248
-25C8
-4448
-8848
-1048
-0048
-0400
-0400
-0400
-07FC
+C0
+C0
+00
+18
+18
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEE8
-ENCODING 44776
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28F2
+ENCODING 10482
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0090
-0050
-7F50
-1250
-2650
-45D0
-8850
-1050
-2000
-07F0
-0410
-0420
-07F0
-0400
+D8
+D8
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEEB
-ENCODING 44779
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28F3
+ENCODING 10483
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0110
-0090
-7E90
-2490
-4490
-4B90
-9090
-1090
-0110
-0100
-0380
-0640
-0830
-3008
+C0
+C0
+00
+D8
+D8
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEED
-ENCODING 44781
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28F4
+ENCODING 10484
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0110
-0090
-FE90
-2490
-4490
-4B90
-9090
-1090
-0080
-03E0
-0630
-0410
-0630
-03E0
+18
+18
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEF4
-ENCODING 44788
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
+STARTCHAR uni28F5
+ENCODING 10485
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-0010
-FF90
-1110
-11F0
-2310
-2210
-45F0
-0810
-0810
-0010
-0010
-0010
-0010
+C0
+C0
+00
+18
+18
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEF8
-ENCODING 44792
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -2
+STARTCHAR uni28F6
+ENCODING 10486
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 8 1 0
 BITMAP
-0030
-0010
-FF90
-1110
-11F0
-2210
-4410
-89F0
-1010
-1010
-0810
-0800
-0800
-0FF8
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AEFC
-ENCODING 44796
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28F7
+ENCODING 10487
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0030
-0010
-7F90
-1190
-1170
-2210
-42F0
-8410
-1800
-0FF0
-0010
-0FF0
-0400
-0400
-07F8
+C0
+C0
+00
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF07
-ENCODING 44807
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 14 3 -2
+STARTCHAR uni28F8
+ENCODING 10488
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-FF20
-1120
-22E0
-2220
-47E0
-8820
-1620
-2320
-0300
-04C0
-0860
-3020
+18
+18
+00
+18
+18
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF08
-ENCODING 44808
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
+STARTCHAR uni28F9
+ENCODING 10489
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0020
-0010
-7F90
-1190
-1170
-2210
-4210
-84F0
-0810
-0830
-0430
-0C20
-0A50
-1188
-2008
+D8
+D8
+00
+18
+18
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF0D
-ENCODING 44813
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
+STARTCHAR uni28FA
+ENCODING 10490
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0060
-0020
-FF20
-2260
-23A0
-4420
-8BE0
-1020
-2040
-1FC0
-1000
-1FC0
-1000
-1000
-0FE0
+18
+18
+00
+D8
+D8
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF10
-ENCODING 44816
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
+STARTCHAR uni28FB
+ENCODING 10491
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-0020
-0098
-0048
-1B48
-3748
-13C8
-2248
-2448
-45C8
-8848
-1048
-0048
-0048
-0048
-0008
+D8
+D8
+00
+D8
+D8
+00
+18
+18
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF2C
-ENCODING 44844
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 10 1 1
+STARTCHAR uni28FC
+ENCODING 10492
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-FDF8
-0C10
-0810
-0810
-0820
-1320
-1120
-0100
-0100
-FFFE
+18
+18
+00
+18
+18
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF2D
-ENCODING 44845
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni28FD
+ENCODING 10493
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-04F8
-3C10
-0410
-0990
-08A0
-0084
-FFFE
-0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+D8
+D8
+00
+18
+18
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF30
-ENCODING 44848
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 -1
+STARTCHAR uni28FE
+ENCODING 10494
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-7CF8
-0410
-0410
-0B10
-0900
-0104
-FFFE
-0000
-1800
-0800
-0808
-07F8
+18
+18
+00
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF32
-ENCODING 44850
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
+STARTCHAR uni28FF
+ENCODING 10495
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
 BITMAP
-04F8
-3C08
-0410
-0710
-0910
-0900
-FFFE
-0100
-30FC
-11E0
-10F0
-1088
-1C90
-0060
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
+00
+D8
+D8
 ENDCHAR
-STARTCHAR AF34
-ENCODING 44852
+STARTCHAR uni3131
+ENCODING 12593
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 11 10 3 0
 BITMAP
-04F8
-3C10
-0410
-0B10
-0920
-0104
-FFFE
-0000
-1FF0
+8000
+FFE0
 0020
-1FE0
-0800
-0800
-0FF8
+0020
+0020
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR AF3C
-ENCODING 44860
+STARTCHAR uni3132
+ENCODING 12594
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 9 2 1
 BITMAP
-00F8
-3C18
+8100
+FDF0
 0410
-0710
-0900
-0900
-FFFE
-0000
-0000
-1FE0
-0820
-0820
-0FE0
-0800
-ENDCHAR
-STARTCHAR AF3D
-ENCODING 44861
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-04F8
-3C18
 0410
-0B10
-0900
-0104
-FFFE
-0000
-1060
-0820
-0FE0
-0820
-0FE0
-0820
-ENDCHAR
-STARTCHAR AF3F
-ENCODING 44863
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-04F8
-1C08
 0410
-0910
-0910
-0100
-FFFE
-0000
-0100
-0100
-03C0
-0630
-0818
-3008
-ENDCHAR
-STARTCHAR AF41
-ENCODING 44865
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-01F8
-3E10
 0410
-0710
-09A0
-0904
-FFFE
-0000
-0080
-0340
-0420
-0420
-0660
-03C0
+0410
+0410
+0410
 ENDCHAR
-STARTCHAR AF42
-ENCODING 44866
+STARTCHAR uni3133
+ENCODING 12595
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 10 2 0
 BITMAP
-3EF8
-0408
-0410
-0610
-0100
-0100
-FFFE
-0000
-1FF0
-0100
-0380
-0660
-0810
-3000
+8000
+FCC0
+0460
+0440
+0440
+04A0
+0490
+0508
+0608
+0400
 ENDCHAR
-STARTCHAR AF43
-ENCODING 44867
+STARTCHAR uni3134
+ENCODING 12596
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 7 2 2
 BITMAP
-3EF8
-2448
-0410
-0510
-0900
-FFFE
-0000
-0000
-03C0
-3FF8
-0100
-02C0
-0430
-1818
+C000
+4000
+4000
+4000
+4000
+4060
+3FF0
 ENDCHAR
-STARTCHAR AF48
-ENCODING 44872
+STARTCHAR uni3135
+ENCODING 12597
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 9 2 0
 BITMAP
-0060
-0010
-0010
-7B90
-0890
-1090
-1890
-1416
-0418
-05D0
-FE10
-0010
-0010
-0010
-0010
+C0C0
+4060
+4040
+4040
+40A0
+4490
+5908
+2208
+0400
 ENDCHAR
-STARTCHAR AF49
-ENCODING 44873
+STARTCHAR uni3136
+ENCODING 12598
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 9 2 0
 BITMAP
-0060
-0020
-11A0
-F2A0
-1120
-1520
-253C
-04E0
-FF20
-0020
-3FE0
-0020
-0020
-0020
-0020
+C0E0
+4008
+41FC
+4020
+40F0
+4508
+5908
+2108
+00F0
 ENDCHAR
-STARTCHAR AF50
-ENCODING 44880
+STARTCHAR uni3137
+ENCODING 12599
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 8 2 2
 BITMAP
-00C0
-0020
-FFA0
-10A0
-1120
-1520
-2438
-05E0
-FA20
-1FE0
-0020
 0040
-1FE0
-0800
-0FF0
+FFE0
+4000
+4000
+4000
+4000
+4060
+7FF0
 ENDCHAR
-STARTCHAR AF5C
-ENCODING 44892
+STARTCHAR uni3138
+ENCODING 12600
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 9 2 1
 BITMAP
-00C0
-0020
-F7A0
-1120
-1120
-2520
-243C
-05E0
-FA20
-0040
-0420
-0420
-0A60
-1198
-2108
+0820
+FDF0
+4100
+4100
+4100
+4100
+4300
+4D10
+71F8
 ENDCHAR
-STARTCHAR AF5D
-ENCODING 44893
+STARTCHAR uni3139
+ENCODING 12601
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 9 2 1
 BITMAP
-00C0
-0020
-17A0
-70A0
-1120
-1520
-253C
-04E0
-FF20
-00A0
-03C0
-0420
-0420
-0660
-03C0
+0040
+FFC0
+4040
+0040
+7FC0
+4000
+4000
+4060
+7FF0
 ENDCHAR
-STARTCHAR AF64
-ENCODING 44900
+STARTCHAR uni313A
+ENCODING 12602
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 9 3 1
 BITMAP
-0060
-0190
-0050
-FF50
-2250
-2250
-3A50
-4870
-4850
-0F50
-7050
-0050
-0050
-0050
-0010
+0100
+FDF0
+0810
+0810
+FC10
+4010
+4010
+4210
+7C10
 ENDCHAR
-STARTCHAR AF65
-ENCODING 44901
+STARTCHAR uni313B
+ENCODING 12603
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 8 2 1
 BITMAP
-0030
-0090
-0090
-EE90
-2290
-2A90
-48F0
-0990
-FE90
-0090
-1FF0
-0010
-0010
-0010
-0010
-0010
+FDF8
+0888
+0888
+FC88
+4088
+4088
+42FC
+7C80
 ENDCHAR
-STARTCHAR AF79
-ENCODING 44921
+STARTCHAR uni313C
+ENCODING 12604
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 10 2 0
 BITMAP
 0018
-0048
-0048
-7F48
-1148
-1948
-1478
-0448
-FFC8
-0048
-01F0
-0318
-0208
-0318
-01F0
+FD88
+0888
+0888
+FCF8
+4088
+4088
+4288
+7CF8
+0088
 ENDCHAR
-STARTCHAR AF80
-ENCODING 44928
+STARTCHAR uni313D
+ENCODING 12605
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 9 1 1
 BITMAP
-0060
-0010
-0010
-7790
-1090
-2110
-3910
-2910
+0030
+FC18
 0810
-0FD0
-F010
-0010
-0010
-0010
-0010
+0810
+FC28
+4024
+4042
+4282
+7D00
 ENDCHAR
-STARTCHAR AF84
-ENCODING 44932
+STARTCHAR uni313E
+ENCODING 12606
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 9 1 1
 BITMAP
-0030
-0010
-0010
-7B90
+0008
+FDFC
+0880
 0890
-1910
-1510
-0530
-FED0
-0010
-0010
-0400
-0400
-0400
-07F8
+FCF8
+4080
+4080
+4288
+7CFC
 ENDCHAR
-STARTCHAR AF88
-ENCODING 44936
+STARTCHAR uni313F
+ENCODING 12607
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 15 9 1 1
 BITMAP
-00C0
-0020
-FF20
-2120
-2220
-2E20
-0A20
-0FE0
-F020
-1FE0
-0020
-0040
-1FE0
+0004
+FDFC
 0800
-0FF0
+0918
+FC88
+4088
+4090
+4212
+7DFE
 ENDCHAR
-STARTCHAR AF90
-ENCODING 44944
+STARTCHAR uni3140
+ENCODING 12608
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 9 2 1
 BITMAP
-0040
-0030
-0590
-3A90
-1090
-1D10
-1510
-04F0
-FF10
-0000
-0FE0
+0004
+FDFE
+4800
 0820
-0840
-0FE0
-0800
+F870
+4088
+4088
+4288
+7C70
 ENDCHAR
-STARTCHAR AF91
-ENCODING 44945
+STARTCHAR uni3141
+ENCODING 12609
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 11 8 3 1
 BITMAP
-00C0
-0020
-FF20
-1120
-2120
-2E20
-2A20
-0BE0
-F400
-10E0
-0840
-0FC0
-0840
-0FC0
-0800
+FFE0
+4020
+4040
+4040
+4040
+4040
+7FC0
+4000
 ENDCHAR
-STARTCHAR AF95
-ENCODING 44949
+STARTCHAR uni3142
+ENCODING 12610
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 10 11 3 0
 BITMAP
-0030
-0090
-3B90
-1090
-1D10
-1510
-0470
-FF90
-0090
-0360
-0410
-0410
-0630
-03E0
+00C0
+C040
+4040
+4040
+7FC0
+4040
+4040
+4040
+4040
+7FC0
+4040
 ENDCHAR
-STARTCHAR AF9C
-ENCODING 44956
+STARTCHAR uni3143
+ENCODING 12611
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 11 2 0
+BBX 13 11 2 0
 BITMAP
-F9F8
-0808
-0818
-1010
-1010
-3890
-28A0
-08A0
-0880
-088C
-F770
+0018
+0988
+C488
+4488
+44F8
+7C88
+4488
+4488
+4488
+7CF8
+4488
 ENDCHAR
-STARTCHAR AFB8
-ENCODING 44984
+STARTCHAR uni3144
+ENCODING 12612
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 10 2 0
 BITMAP
-00F8
-1E08
-0410
-0410
-0410
-0004
-FFFE
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+0C40
+C430
+4420
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
 ENDCHAR
-STARTCHAR AFB9
-ENCODING 44985
+STARTCHAR uni3145
+ENCODING 12613
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 9 2 1
 BITMAP
-00F8
-1E18
-0210
-0410
-0404
-FFFE
-0100
-0100
-0100
-3FF0
-0010
-0010
-0010
-0010
+0800
+0600
+0400
+0C00
+0B00
+1080
+2060
+4020
+8010
 ENDCHAR
-STARTCHAR AFBC
-ENCODING 44988
+STARTCHAR uni3146
+ENCODING 12614
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 9 2 1
 BITMAP
-3EF8
-1610
-0410
-0410
-0404
-07FE
-FF00
-0100
-0100
-3100
-1100
-1100
-1000
-1FF0
+1860
+0C30
+0820
+0820
+1450
+1248
+2184
+4104
+8200
 ENDCHAR
-STARTCHAR AFC0
-ENCODING 44992
+STARTCHAR uni3147
+ENCODING 12615
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 9 9 4 1
 BITMAP
-3EF8
-0418
-0410
-0410
-0000
-FFFE
-0100
-0100
-1FF0
-0020
-1FE0
 0800
-0800
-07F0
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR AFC7
-ENCODING 44999
+STARTCHAR uni3148
+ENCODING 12616
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 10 9 3 1
 BITMAP
-01F0
-3820
-0820
-0840
-1040
-FFFC
-0200
-3E60
-0418
-7DE0
-20E0
-2110
-3910
-00E0
+0080
+FFC0
+0400
+0400
+0C00
+0A00
+1180
+60C0
+8040
 ENDCHAR
-STARTCHAR AFC8
-ENCODING 45000
+STARTCHAR uni3149
+ENCODING 12617
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 10 2 0
 BITMAP
-00F8
-3E08
-0210
-0410
-0400
-FFFE
-0100
-0100
-0100
-0FE0
+0204
+7F7C
 0820
 0820
-0FE0
-0800
+0820
+1450
+1248
+2184
+4104
+8200
 ENDCHAR
-STARTCHAR AFC9
-ENCODING 45001
+STARTCHAR uni314A
+ENCODING 12618
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 11 9 2 1
 BITMAP
-3EF8
-0208
-0410
-0410
-0810
-FFFE
-0100
-0100
-1920
-0820
-0FE0
-0820
-0FE0
-0820
+1F00
+0000
+FFE0
+4400
+0400
+0A00
+1180
+2040
+C020
 ENDCHAR
-STARTCHAR AFCB
-ENCODING 45003
+STARTCHAR uni314B
+ENCODING 12619
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 10 10 3 1
 BITMAP
-7DF0
-0820
-0820
-0840
-1040
-FFFC
-0200
-0200
-0600
-0200
-0700
-0C80
-1060
-6000
+00C0
+FF40
+6040
+0040
+01C0
+1E40
+E040
+0080
+0080
+0080
 ENDCHAR
-STARTCHAR AFCD
-ENCODING 45005
+STARTCHAR uni314C
+ENCODING 12620
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 9 2 1
 BITMAP
-3E00
-0278
-0408
-0410
-0410
-FFFE
-0100
-0100
-0100
-0EC0
-0820
-0820
-0C60
-03C0
+00C0
+FFE0
+4000
+4180
+7FC0
+4000
+4000
+4060
+7FF0
 ENDCHAR
-STARTCHAR AFCE
-ENCODING 45006
+STARTCHAR uni314D
+ENCODING 12621
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 9 2 1
 BITMAP
-7DF0
-0830
-0820
-0820
+4060
+7FF0
+0000
+00C0
 1040
-FFFC
-4200
-0200
-3FF0
-0200
-0300
-04C0
-1830
-6010
+0880
+0880
+8130
+FFF8
 ENDCHAR
-STARTCHAR AFD4
-ENCODING 45012
+STARTCHAR uni314E
+ENCODING 12622
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 10 2 0
 BITMAP
-0030
-0010
-1190
-7310
-1110
-2110
-2010
-1F10
-E810
-08F0
-0810
-0810
-0810
-0010
+0F80
 0010
+FFF8
+0200
+0F80
+1040
+1040
+1040
+1040
+0F80
 ENDCHAR
-STARTCHAR AFDC
-ENCODING 45020
+STARTCHAR uni314F
+ENCODING 12623
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 7 15 5 -2
 BITMAP
-0018
-0008
-3FC8
-0848
-0888
-08A8
-FF48
-02F8
-0408
-0FF8
-0010
-0010
-0FF8
-0400
-07F8
+E0
+20
+20
+20
+20
+22
+3E
+20
+20
+20
+20
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR AFE8
-ENCODING 45032
+STARTCHAR uni3150
+ENCODING 12624
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 5 15 6 -2
 BITMAP
-0030
-0010
-F710
-1110
-2110
-2290
-FD10
-08F0
-0810
-1060
-0820
-0860
-1660
-2298
-C108
+38
+08
+C8
+48
+48
+48
+48
+48
+78
+48
+48
+48
+48
+48
+08
 ENDCHAR
-STARTCHAR AFE9
-ENCODING 45033
+STARTCHAR uni3151
+ENCODING 12625
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 7 15 5 -2
 BITMAP
-0010
-0008
-3B88
-0888
-0888
-1148
-FE88
-0408
-0478
-0448
-01E8
-0210
-0210
-0330
-01E0
+E0
+20
+20
+20
+22
+3E
+20
+20
+20
+22
+3E
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR AFF0
-ENCODING 45040
+STARTCHAR uni3152
+ENCODING 12626
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 5 15 5 -2
+BITMAP
+38
+08
+C8
+48
+48
+78
+48
+48
+48
+78
+48
+48
+48
+48
+08
+ENDCHAR
+STARTCHAR uni3153
+ENCODING 12627
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 5 15 6 -2
 BITMAP
-0030
-0110
-0090
-2E90
-6290
-2490
-2490
-0C90
-F090
-1790
-1090
-1090
-1090
-0090
-0010
+38
+08
+08
+08
+08
+08
+88
+F8
+08
+08
+08
+08
+08
+08
+08
+ENDCHAR
+STARTCHAR uni3154
+ENCODING 12628
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 8 15 4 -2
+BITMAP
+07
+01
+19
+09
+09
+09
+89
+F9
+09
+09
+09
+09
+09
+09
+01
 ENDCHAR
-STARTCHAR AFF1
-ENCODING 45041
+STARTCHAR uni3155
+ENCODING 12629
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 5 15 6 -2
 BITMAP
-0030
-0088
-0048
-7748
-1148
-1248
-2248
-FD48
-0BC8
-0840
-0FF8
-0008
-0008
-0008
-0008
-0008
+38
+08
+08
+08
+88
+F8
+08
+08
+08
+88
+F8
+08
+08
+08
+08
 ENDCHAR
-STARTCHAR AFF4
-ENCODING 45044
+STARTCHAR uni3156
+ENCODING 12630
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 8 15 4 -2
 BITMAP
-0060
-0130
-0090
-0090
-7690
-2290
-2290
-2290
-FC90
-0B90
-0090
-0C10
-0400
-0400
-07F8
+07
+01
+19
+09
+89
+F9
+09
+09
+89
+F9
+09
+09
+09
+09
+01
 ENDCHAR
-STARTCHAR AFF8
-ENCODING 45048
+STARTCHAR uni3157
+ENCODING 12631
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 8 1 2
 BITMAP
-0030
-0110
-00D0
-2ED0
-62D0
-2490
-2490
-F890
-1790
-1000
-0FF0
-0020
-0FF0
-0400
-07F8
+0300
+0100
+0100
+0100
+0100
+0100
+010C
+FFFE
 ENDCHAR
-STARTCHAR B000
-ENCODING 45056
+STARTCHAR uni3158
+ENCODING 12632
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 15 15 1 -2
 BITMAP
-0030
-00D8
-0048
-7748
-1148
-1248
-1248
-FD48
-0BC8
-0848
-07F8
-0208
-0208
-0210
-03F8
-0200
+00E0
+0020
+0020
+0C20
+0420
+0420
+0422
+043E
+0420
+05E0
+FE20
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR B001
-ENCODING 45057
+STARTCHAR uni3159
+ENCODING 12633
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0030
+0070
+0010
 0190
 0090
-EE90
-2290
-2490
-2490
-F890
-1790
-0830
+0090
+3090
+1090
+10F0
+1190
+1E90
+E090
+0090
+0090
+0090
+0010
+ENDCHAR
+STARTCHAR uni315A
+ENCODING 12634
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 1 -2
+BITMAP
+0070
+0010
+0010
+0C10
 0410
-07F0
 0410
 0410
-07F0
 0410
+0410
+04F0
+FF10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B004
-ENCODING 45060
+STARTCHAR uni315B
+ENCODING 12635
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 15 7 2 2
 BITMAP
-0030
-0190
-0090
-EE90
-2290
-2490
-4490
-FA90
-1790
-1000
-0420
-0C60
-0C60
-1298
-2108
-4000
+1860
+0820
+0820
+0840
+0840
+0844
+FFFE
 ENDCHAR
-STARTCHAR B00C
-ENCODING 45068
+STARTCHAR uni315C
+ENCODING 12636
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 -2
+BITMAP
+000C
+FFFE
+4100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni315D
+ENCODING 12637
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
-0018
+0038
 0008
-03C8
-38C8
-0888
-0888
-1088
-11C8
-FE08
+0008
+0008
+0008
+00E8
+FF08
 0408
+0478
+0448
 0408
 0408
 0408
 0408
 0008
-ENDCHAR
-STARTCHAR B010
-ENCODING 45072
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
-BITMAP
-0060
-0020
-F720
-2120
-2220
-2220
-4FE0
-F820
-0820
-0820
-0020
-3000
-1000
-1020
-1FF0
 ENDCHAR
-STARTCHAR B014
-ENCODING 45076
-SWIDTH 1020 0
-DWIDTH 17 0
+STARTCHAR uni315E
+ENCODING 12638
+SWIDTH 900 0
+DWIDTH 15 0
 BBX 13 15 2 -2
 BITMAP
-0030
-0010
-3B90
-1110
-1110
-11F0
-FE10
-0410
-0400
-0FF0
-0010
-0020
-0FF0
-0400
-07F8
+0038
+0008
+00C8
+0048
+0048
+0348
+FC48
+0848
+0A48
+0BC8
+0848
+0848
+0848
+0848
+0008
 ENDCHAR
-STARTCHAR B01C
-ENCODING 45084
+STARTCHAR uni315F
+ENCODING 12639
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
+0070
 0010
-7B90
-0890
-1110
-1130
-FED0
-0410
-0410
-0000
-07F0
-0410
-0420
-07E0
-0400
-ENDCHAR
-STARTCHAR B01D
-ENCODING 45085
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0030
 0010
-3B90
-0890
-0890
-10F0
-FF10
-0410
-0400
-0C30
-0410
-07F0
-0410
-0410
-07F0
-0410
+0010
+0010
+01D0
+FE10
+0810
+0810
+0810
+0810
+0810
+0810
+0810
+0010
 ENDCHAR
-STARTCHAR B028
-ENCODING 45096
+STARTCHAR uni3160
+ENCODING 12640
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 12 1 -2
 BITMAP
-7DF0
-0410
-0410
+0006
+FFFE
+6820
 0820
 0820
-1020
-FFFC
-0840
-0840
-0840
-0840
-0840
-0840
-0840
-0040
+0820
+0820
+0820
+0820
+0820
+0820
+0820
 ENDCHAR
-STARTCHAR B044
-ENCODING 45124
+STARTCHAR uni3161
+ENCODING 12641
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 10 1 0
+BBX 14 2 2 4
 BITMAP
-3EF8
-0608
-0408
-0410
-0410
-0410
-0820
-0804
-FFFE
-2000
+0018
+FFFC
 ENDCHAR
-STARTCHAR B045
-ENCODING 45125
+STARTCHAR uni3162
+ENCODING 12642
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 1 -2
 BITMAP
-3EF8
-0408
-0410
-0810
-0810
-CFFE
-3000
-0000
-3FF0
+0070
+0010
+0010
+0010
+0010
+0010
+0010
+0010
+01F0
+FE10
 0010
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B048
-ENCODING 45128
+STARTCHAR uni3163
+ENCODING 12643
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 3 15 6 -2
 BITMAP
-00F8
-1E08
-0410
-0410
-0410
-0006
-FFFE
-0000
-3800
-0800
-0800
-0800
-0FF8
+E0
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR B04A
-ENCODING 45130
+STARTCHAR uni3164
+ENCODING 12644
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
+BITMAP
+B6D6
+8000
+1212
+9210
+1E12
+9292
+9260
+0002
+83C2
+8200
+03C2
+8202
+8200
+0002
+DB6A
+ENDCHAR
+STARTCHAR uni3165
+ENCODING 12645
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 9 2 1
 BITMAP
-00F8
-1E08
-0408
-0410
-0400
-FFFE
-0000
-20E0
-13F8
-10E0
-1110
-1308
-1D10
-00E0
+0300
+C100
+4100
+4100
+4100
+4100
+4500
+59F8
+2000
 ENDCHAR
-STARTCHAR B04C
-ENCODING 45132
+STARTCHAR uni3166
+ENCODING 12646
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 9 2 1
 BITMAP
-3EFC
-0608
-0408
-0410
-0410
-FFFE
-0000
-0000
-1FE0
-0020
-1FE0
-0800
-0800
-07E0
+0010
+C1F0
+4100
+4100
+4100
+4100
+4500
+5910
+61F8
 ENDCHAR
-STARTCHAR B04E
-ENCODING 45134
+STARTCHAR uni3167
+ENCODING 12647
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 9 2 1
 BITMAP
-7EF8
-0408
-0410
-0410
-0810
-FFFE
-0000
-3E00
-02F0
-0490
-1890
-1090
-16F0
-0880
+00C0
+C060
+4040
+4040
+40A0
+4090
+4508
+5A08
+2400
 ENDCHAR
-STARTCHAR B053
-ENCODING 45139
+STARTCHAR uni3168
+ENCODING 12648
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 8 2 1
 BITMAP
-3CF8
-0408
-0410
-0410
-FFFE
-0000
-00F0
-3C00
-05F8
-7CE0
-2110
-2308
-3D10
-00F0
+C040
+4040
+40A0
+40A0
+4110
+4510
+5A08
+23F8
 ENDCHAR
-STARTCHAR B054
-ENCODING 45140
+STARTCHAR uni3169
+ENCODING 12649
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 9 1 1
 BITMAP
-1EF8
-0608
-0410
 0410
-0814
-FFFE
-0000
-0000
-1FE0
-0820
-0820
-0820
-0FE0
-0800
+FF88
+1088
+1088
+F894
+4094
+40A2
+44A2
+78C0
 ENDCHAR
-STARTCHAR B055
-ENCODING 45141
+STARTCHAR uni316A
+ENCODING 12650
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 9 1 1
 BITMAP
-7EF8
-0408
-0410
-0410
-0810
-0820
-CFFE
-7820
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0008
+FCF8
+0880
+0880
+FC80
+4080
+4080
+4288
+7CFC
 ENDCHAR
-STARTCHAR B057
-ENCODING 45143
+STARTCHAR uni316B
+ENCODING 12651
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 16 10 1 0
 BITMAP
-7C00
-04F0
-0810
-0820
-0820
-0000
-FFFC
-0000
-0200
-0200
-0500
-08C0
-3020
-4010
+00C8
+FE44
+1244
+1244
+FBCA
+424A
+4251
+4251
+7BE0
+0240
 ENDCHAR
-STARTCHAR B059
-ENCODING 45145
+STARTCHAR uni316C
+ENCODING 12652
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 8 1 1
 BITMAP
-3EF8
-0408
-0408
-0410
-0810
-8FFE
-7000
-0000
-0100
-06C0
-0820
-0820
-0460
-0380
+FE20
+0420
+0450
+FE50
+4088
+4088
+4104
+7FFC
 ENDCHAR
-STARTCHAR B05D
-ENCODING 45149
+STARTCHAR uni316D
+ENCODING 12653
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 9 2 1
 BITMAP
-06F8
-1C08
-0410
-0410
-0000
-FFFE
-0000
-0000
-1FF0
-0800
-0FF0
+0004
+FDFE
 0800
-0FF8
+0820
+F870
+4088
+4088
+4288
+7C70
 ENDCHAR
-STARTCHAR B07C
-ENCODING 45180
+STARTCHAR uni316E
+ENCODING 12654
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 10 2 0
 BITMAP
-0038
-0008
-0008
-7FC8
-0C48
-0888
-1888
-1108
-2108
-4208
-8408
-0808
-0008
-0008
-0008
+0018
+FD88
+4488
+4488
+44F8
+4488
+4488
+7E88
+40F8
+0088
 ENDCHAR
-STARTCHAR B07D
-ENCODING 45181
+STARTCHAR uni316F
+ENCODING 12655
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 9 2 1
 BITMAP
-0030
-0010
-0010
-7F90
-1110
-3210
-2210
-C410
-0810
-1000
-3FE0
-1020
-0020
-0020
-0020
-0020
+0060
+FC30
+4420
+4420
+4450
+4448
+4484
+7F04
+4200
 ENDCHAR
-STARTCHAR B080
-ENCODING 45184
+STARTCHAR uni3170
+ENCODING 12656
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 8 1 1
 BITMAP
-0018
-0008
-0008
-3FC8
-0888
-1188
-2108
-4208
-8408
-0808
-0C08
-0400
-0400
-0400
-07FC
+FC10
+4410
+4428
+4428
+4444
+4444
+7E82
+40FE
 ENDCHAR
-STARTCHAR B084
-ENCODING 45188
+STARTCHAR uni3171
+ENCODING 12657
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 9 13 3 -1
 BITMAP
-0030
-0010
-7F90
-1190
-1110
-2210
-4210
-8410
+FF00
+4100
+4100
+4100
+7F80
+4000
 0800
-17F0
-0020
-0FF0
-0400
-0400
-03F0
+3E00
+4100
+4100
+4100
+4100
+3E00
 ENDCHAR
-STARTCHAR B08C
-ENCODING 45196
+STARTCHAR uni3172
+ENCODING 12658
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 10 2 0
 BITMAP
-0030
-0010
-FF90
-0890
-1110
-2110
-2210
+0D00
+C5F0
 4410
-8810
-1000
-27F0
-0410
-0420
-07F0
-0400
+4410
+7C10
+4410
+4410
+4410
+7C10
+4400
 ENDCHAR
-STARTCHAR B08D
-ENCODING 45197
+STARTCHAR uni3173
+ENCODING 12659
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 13 10 2 0
 BITMAP
-0018
-0008
-04C8
-3B48
-0888
-1188
-2108
-4208
-8400
-0E08
-0208
-03F8
-0208
-0208
-03F8
-0208
+0C10
+C5F0
+4500
+4500
+7D00
+4500
+4500
+4510
+7DF8
+4400
 ENDCHAR
-STARTCHAR B08F
-ENCODING 45199
+STARTCHAR uni3174
+ENCODING 12660
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 10 1 0
 BITMAP
-0060
-0020
-0320
-FF20
-2220
-2420
-4420
-8820
-1020
-2320
-0300
-0300
-04C0
-0860
-3020
+1920
+C8BC
+4884
+4884
+7984
+4944
+4A24
+4C24
+7C04
+4000
 ENDCHAR
-STARTCHAR B091
-ENCODING 45201
+STARTCHAR uni3175
+ENCODING 12661
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 10 1 0
 BITMAP
-0060
-0020
-0020
-FF20
-2220
-2220
+1A04
+C93C
+4920
+4920
+7920
+4B20
+4AA0
+4CA4
+7CBC
+4000
+ENDCHAR
+STARTCHAR uni3176
+ENCODING 12662
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+0C04
+C5FC
 4420
-8820
-1020
-2120
-06C0
-0820
-0820
-0C60
-03C0
+4420
+7C20
+4450
+4448
+4484
+7D04
+4200
 ENDCHAR
-STARTCHAR B098
-ENCODING 45208
+STARTCHAR uni3177
+ENCODING 12663
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 10 2 0
 BITMAP
-0040
-0020
-0020
-0020
-C020
-4020
-4020
-403C
-4060
-4FA0
-7020
-0020
-0020
-0020
-0020
+0C08
+C5FC
+4480
+4490
+7CF8
+4480
+4480
+4488
+7CFC
+4400
 ENDCHAR
-STARTCHAR B099
-ENCODING 45209
+STARTCHAR uni3178
+ENCODING 12664
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 9 15 4 -2
 BITMAP
-0060
-0020
-0020
-C020
-4020
-403C
-43A0
-7C20
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+0180
+C080
+4080
+7F80
+4080
+4080
+7F80
+4080
+0800
+3E00
+4100
+4100
+4100
+4100
+3E00
 ENDCHAR
-STARTCHAR B09A
-ENCODING 45210
+STARTCHAR uni3179
+ENCODING 12665
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-0020
-C020
-4020
-403C
-43A0
-7C20
-0000
-7DE0
-0420
-0420
-0420
-0420
-0420
+0C30
+C710
+4510
+7DF0
+4510
+4510
+7DF0
+4510
+0200
+0F80
+1040
+1040
+1040
+1040
+0F80
 ENDCHAR
-STARTCHAR B09C
-ENCODING 45212
+STARTCHAR uni317A
+ENCODING 12666
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 9 2 1
 BITMAP
-0030
-0010
-0010
-E010
-2010
-2010
-201C
-21D0
-3E10
-0010
-1C10
-0400
-0400
-0400
-07FC
+1900
+0DF8
+0808
+0808
+1408
+1408
+2208
+4208
+8008
 ENDCHAR
-STARTCHAR B09F
-ENCODING 45215
+STARTCHAR uni317B
+ENCODING 12667
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 9 2 1
 BITMAP
-0030
-0010
-C010
-2010
-2010
-2016
-23F8
-3C10
-0010
-0000
-0FF0
-0400
-0400
-0400
-07F8
+1800
+0D80
+0880
+0880
+1880
+1480
+2488
+42B0
+8240
 ENDCHAR
-STARTCHAR B0A0
-ENCODING 45216
+STARTCHAR uni317C
+ENCODING 12668
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 9 2 1
 BITMAP
-0060
-0020
-0020
-C020
-4024
-4038
-43A0
-7C20
-0000
-1FE0
-0020
-0FE0
-0800
-0800
-07E0
+1808
+0CF8
+0880
+0880
+1480
+1480
+2280
+4288
+80FC
 ENDCHAR
-STARTCHAR B0A1
-ENCODING 45217
+STARTCHAR uni317D
+ENCODING 12669
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 10 2 0
 BITMAP
-0060
-0020
-0020
-C020
-4020
-41B8
-7E20
-0020
-0C20
-34E0
-0820
-3020
-2020
-3C20
-0020
+1818
+0D88
+0888
+0888
+14F8
+1488
+2288
+4288
+80F8
+0088
 ENDCHAR
-STARTCHAR B0A2
-ENCODING 45218
+STARTCHAR uni317E
+ENCODING 12670
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 10 2 0
 BITMAP
-0030
-0010
-E010
-2010
-2016
-20F8
-3F10
-0010
-1EF0
-0290
-3E90
-1090
-11F0
-1E80
+1804
+0DFC
+0820
+0820
+1420
+1450
+2248
+4284
+8104
+0200
 ENDCHAR
-STARTCHAR B0A8
-ENCODING 45224
+STARTCHAR uni317F
+ENCODING 12671
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 9 9 4 1
 BITMAP
-0060
-0020
-0020
-C020
-4020
-403C
-43A0
-7C20
-0020
-0000
-0FE0
-0820
-0820
-0FE0
 0800
+0800
+1400
+2200
+2200
+4100
+8080
+8080
+FF80
 ENDCHAR
-STARTCHAR B0A9
-ENCODING 45225
+STARTCHAR uni3180
+ENCODING 12672
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 9 2 1
 BITMAP
-0060
-0020
-0020
-C020
-4020
-4078
-43A0
-7C20
-0000
 1020
-0820
-0FE0
-0820
-0FE0
-0820
+1020
+78F0
+8508
+8508
+8508
+8508
+8508
+78F0
 ENDCHAR
-STARTCHAR B0AB
-ENCODING 45227
+STARTCHAR uni3181
+ENCODING 12673
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 7 8 5 2
 BITMAP
-0030
-0010
-E010
-2010
-2010
-203E
-21D0
-3E10
-0090
-0090
-01C0
-0320
-0618
-080C
+10
+10
+7C
+82
+82
+82
+82
+7C
 ENDCHAR
-STARTCHAR B0AC
-ENCODING 45228
+STARTCHAR uni3182
+ENCODING 12674
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 9 9 4 1
 BITMAP
-0030
-0010
-E010
-2010
-2010
-2016
-21D8
-3E10
-0000
-0630
-0210
-0620
-0950
-108C
-2104
+0800
+3E00
+4100
+8080
+8080
+8080
+8080
+4100
+3E00
 ENDCHAR
-STARTCHAR B0AD
-ENCODING 45229
+STARTCHAR uni3183
+ENCODING 12675
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 9 2 1
 BITMAP
-0060
-0020
-0020
-C020
-4020
-402C
-40B0
-7F20
-0020
-0100
-06C0
-0820
-0820
-0C60
-03C0
+10C0
+1060
+7840
+8440
+84A0
+8490
+8508
+8608
+7C00
 ENDCHAR
-STARTCHAR B0AE
-ENCODING 45230
+STARTCHAR uni3184
+ENCODING 12676
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0010
-E010
-2010
-2010
-203E
-27D0
-3810
-0000
-1FF8
 0080
-0180
-0360
-0418
-1808
+7FC0
+0000
+2300
+1100
+1100
+0240
+FFE0
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
 ENDCHAR
-STARTCHAR B0AF
-ENCODING 45231
+STARTCHAR uni3185
+ENCODING 12677
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 14 9 2 1
 BITMAP
-0060
-0020
-8020
-4020
-4020
-4078
-43A0
-7C20
-0380
-03F0
-3F00
-0100
-0380
-0660
-0810
-3000
+70E0
+0408
+FDFC
+1020
+78F0
+8508
+8508
+8508
+78F0
 ENDCHAR
-STARTCHAR B0B1
-ENCODING 45233
+STARTCHAR uni3186
+ENCODING 12678
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -1
+BBX 11 11 3 0
 BITMAP
-0060
-0020
-C020
-4020
-402C
-43B0
-7C20
+00C0
+FFE0
 0000
-0020
-0FE0
-0800
-0FE0
-0800
-0FF0
+0000
+0400
+1F00
+2080
+2080
+2080
+2080
+1F00
 ENDCHAR
-STARTCHAR B0B3
-ENCODING 45235
+STARTCHAR uni3187
+ENCODING 12679
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
-0030
+001C
 0010
-E010
-2010
-2016
-2058
-3F90
-0200
-01C0
-0FFC
-01E0
-0210
-0210
-0310
-01E0
+0010
+0010
+0012
+001E
+0010
+3310
+1110
+1112
+111E
+1170
+1790
+F810
+0010
 ENDCHAR
-STARTCHAR B0B4
-ENCODING 45236
+STARTCHAR uni3188
+ENCODING 12680
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 15 1 -2
 BITMAP
-0318
-0088
-0088
-E088
-2088
-2088
-2088
-20F8
-2088
-2F88
-3088
-0088
-0088
-0088
-0008
+000E
+0002
+0032
+0012
+0012
+001E
+0012
+3312
+1112
+111E
+1112
+1172
+1792
+F812
+0002
 ENDCHAR
-STARTCHAR B0B5
-ENCODING 45237
+STARTCHAR uni3189
+ENCODING 12681
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 3 -2
 BITMAP
-0020
-0610
-0110
-C110
-4110
-4110
-41F0
-4710
-7910
-0110
-1FF0
+0070
 0010
 0010
 0010
 0010
 0010
+0010
+3310
+1110
+1110
+1110
+1170
+1790
+F810
+0010
 ENDCHAR
-STARTCHAR B0B8
-ENCODING 45240
+STARTCHAR uni318A
+ENCODING 12682
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 12 15 1 -2
+BITMAP
+0070
+0010
+0010
+0010
+0090
+00F0
+0010
+0F10
+F410
+2490
+24F0
+2410
+2410
+0010
+0010
+ENDCHAR
+STARTCHAR uni318B
+ENCODING 12683
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
+BITMAP
+000E
+0002
+0032
+0012
+0092
+00F2
+0012
+0F12
+F492
+24F2
+2412
+2412
+2412
+0012
+0002
+ENDCHAR
+STARTCHAR uni318C
+ENCODING 12684
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 3 -2
 BITMAP
+01C0
 0040
-0330
-0090
-8090
-4090
-4090
-4090
-47F0
-7890
-0090
-0C90
-0490
-0400
-0400
-07FC
+0040
+0040
+0040
+0040
+0040
+0040
+0F40
+F440
+2440
+2440
+2440
+2440
+0040
 ENDCHAR
-STARTCHAR B0BC
-ENCODING 45244
+STARTCHAR uni318D
+ENCODING 12685
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 4 3 7 4
 BITMAP
-0018
-0188
-E088
-2088
-2088
-20F8
-2788
-3888
-0080
-0FF0
-0010
-0FF0
-0400
-0400
-07FC
+60
+F0
+60
 ENDCHAR
-STARTCHAR B0C4
-ENCODING 45252
+STARTCHAR uni318E
+ENCODING 12686
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 7 15 3 -2
 BITMAP
-0060
-0310
-0110
-C110
-4110
-4110
-41F0
-4710
-7910
-0110
-1FF0
-0830
-0820
-0820
-0FC0
+0E
+02
+02
+02
+02
+02
+62
+F2
+62
+02
+02
+02
+02
+02
+02
 ENDCHAR
-STARTCHAR B0C5
-ENCODING 45253
+STARTCHAR uni3200
+ENCODING 12800
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 1 -2
+BBX 15 14 1 -2
 BITMAP
-0318
-0088
-E088
-2088
-2088
-20F8
-2188
-3E88
-0E08
-0208
-03F8
-0208
-03F8
-0208
+1010
+2008
+4004
+4004
+BFE2
+8022
+8022
+8022
+8022
+8022
+4024
+4024
+2008
+1010
 ENDCHAR
-STARTCHAR B0C7
-ENCODING 45255
+STARTCHAR uni3201
+ENCODING 12801
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0190
-0090
-C090
-4090
-4090
-41F0
-4E90
-7090
-0310
-0180
-0180
-0240
-0C30
-1018
+0010
+0008
+2004
+4004
+7802
+8802
+8802
+8802
+8802
+883A
+8FC4
+4004
+4008
+2010
 ENDCHAR
-STARTCHAR B0C8
-ENCODING 45256
+STARTCHAR uni3202
+ENCODING 12802
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0190
-0090
-C090
-4090
-4090
-41F0
-4690
-7890
-08A0
-0420
-0C60
-1250
-2188
-4108
+1010
+2008
+4004
+4004
+9FF2
+8802
+8802
+8802
+8802
+8802
+4FF4
+4004
+2008
+1010
 ENDCHAR
-STARTCHAR B0C9
-ENCODING 45257
+STARTCHAR uni3203
+ENCODING 12803
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0020
-0318
-0088
-E088
-2088
-2088
-20F8
-2188
-2E88
-3048
-01A0
-0210
-0210
-0330
-01E0
+1010
+2008
+4004
+5FE4
+8022
+8022
+8FE2
+8802
+8802
+8802
+4FF4
+4004
+2008
+1010
 ENDCHAR
-STARTCHAR B0D0
-ENCODING 45264
+STARTCHAR uni3204
+ENCODING 12804
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0020
-0020
-8020
-4020
-403C
-4020
-4020
-40E0
-4F2C
-7030
-0020
-0020
-0020
-0020
+1010
+2008
+4004
+4004
+9FF2
+8822
+8822
+8822
+8822
+8FE2
+4804
+4004
+2008
+1010
 ENDCHAR
-STARTCHAR B0D1
-ENCODING 45265
+STARTCHAR uni3205
+ENCODING 12805
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-0020
-C020
-4038
-4020
-47E0
-783C
-0020
-01E0
-3E20
-0020
-0020
-0020
-0020
+1010
+2008
+4004
+4064
+8822
+8822
+8FE2
+8822
+8822
+8822
+4FE4
+4824
+2008
+1010
 ENDCHAR
-STARTCHAR B0D4
-ENCODING 45268
+STARTCHAR uni3206
+ENCODING 12806
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-0020
-C020
-403C
-4020
-4020
-43E0
-7C2C
-0030
-1020
-0800
-0800
-0800
-0FF0
+1010
+2008
+4004
+4104
+8082
+8102
+8382
+8242
+8432
+8812
+5004
+4004
+2008
+1010
 ENDCHAR
-STARTCHAR B0D8
-ENCODING 45272
+STARTCHAR uni3207
+ENCODING 12807
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-E020
-202C
-2030
-2060
-27A4
-3838
-0000
-1FE0
-0020
-0040
-0FE0
-0800
-0FF0
+1000
+2008
+4104
+47C4
+8822
+9012
+9012
+9012
+9012
+8824
+47C4
+4008
+2000
+1000
 ENDCHAR
-STARTCHAR B0E0
-ENCODING 45280
+STARTCHAR uni3208
+ENCODING 12808
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-0020
-C020
-403C
-4020
-43E0
-7C3C
-0020
-0FE0
-0820
-0820
-0840
-0FE0
-0800
+1010
+2008
+4024
+5FF4
+8822
+8042
+8082
+8182
+8262
+8C32
+5004
+4004
+2008
+1010
 ENDCHAR
-STARTCHAR B0E5
-ENCODING 45285
+STARTCHAR uni3209
+ENCODING 12809
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0040
-0020
-0020
-C020
-403C
-4020
-40A0
-7F3C
-0020
-00A0
-0340
-0420
-0420
-0660
-03C0
+1010
+2408
+43C4
+4004
+8022
+8FE2
+8042
+8182
+8242
+8C32
+7014
+4004
+2008
+1010
 ENDCHAR
-STARTCHAR B108
-ENCODING 45320
+STARTCHAR uni320A
+ENCODING 12810
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0018
-0008
-0008
-E008
+1010
 2008
-21F8
+4014
+4FF4
+8812
+8012
+80E2
+8F22
+8022
+8042
+4044
+4084
 2008
+1010
+ENDCHAR
+STARTCHAR uni320B
+ENCODING 12811
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1010
 2008
+4024
+4FE4
+8802
+8802
+8822
+8FE2
+8802
+8802
+4FFC
+4004
 2008
-2188
-3E08
-0008
-0008
-0008
-0008
+1010
 ENDCHAR
-STARTCHAR B109
-ENCODING 45321
+STARTCHAR uni320C
+ENCODING 12812
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 15 14 1 -2
 BITMAP
-00C0
-0020
-0020
-C020
-41E0
-4020
-4020
-7F20
-2020
-0000
-7FC0
-2040
-0040
-0040
-0040
-0040
+0010
+0008
+2004
+5FF4
+4002
+80C2
+8442
+8442
+8282
+8082
+BFFC
+4004
+4008
+2010
 ENDCHAR
-STARTCHAR B10B
-ENCODING 45323
+STARTCHAR uni320D
+ENCODING 12813
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0018
-0008
-E008
-21F8
+1010
 2008
+4004
+43C4
+8002
+9FFA
+8102
+87C2
+8822
+8822
+4824
+47C4
 2008
-2388
-3C08
-0020
-7E10
-0210
-0230
-0268
-0244
-0284
+1010
+ENDCHAR
+STARTCHAR uni320E
+ENCODING 12814
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1010
+2068
+4024
+4024
+9FA2
+8122
+8122
+823E
+8422
+8822
+7024
+4024
+2028
+1010
+ENDCHAR
+STARTCHAR uni320F
+ENCODING 12815
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1010
+2068
+4024
+6024
+9022
+9022
+9022
+903A
+90A2
+9F22
+4024
+4024
+2028
+1010
+ENDCHAR
+STARTCHAR uni3210
+ENCODING 12816
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1010
+2068
+4024
+4124
+9FA2
+9022
+9022
+903A
+90A2
+9F22
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B10C
-ENCODING 45324
+STARTCHAR uni3211
+ENCODING 12817
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 15 14 1 -2
 BITMAP
-0060
-0010
-0010
-C010
-43F0
-4010
-4010
-4310
-7C10
-0010
-1810
-0800
-0800
-0FF8
+1010
+2068
+4024
+4024
+BF22
+8122
+8122
+9F3A
+9022
+9022
+53A4
+5C24
+2028
+1010
 ENDCHAR
-STARTCHAR B110
-ENCODING 45328
+STARTCHAR uni3212
+ENCODING 12818
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0010
-0008
-E008
-20F8
-2008
-2008
-2308
-3C08
-0008
-07F8
-0010
-0FF8
-0400
-0400
-07FC
+1010
+2068
+4024
+4024
+BF22
+9122
+9122
+913E
+9F22
+9022
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B112
-ENCODING 45330
+STARTCHAR uni3213
+ENCODING 12819
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0030
-8010
-41F0
-4010
-4010
-4210
-7C10
-0000
-3CF0
-0490
-7C90
-2090
-22F0
-3C80
+1010
+2068
+4024
+4324
+9122
+9122
+9F22
+913A
+9122
+9F22
+5024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B113
-ENCODING 45331
+STARTCHAR uni3214
+ENCODING 12820
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0020
-0010
-C010
-41F0
-4010
-4010
-5E10
-2000
-0310
-7D10
-05F0
-6D10
-3110
-23F0
-3D10
+1010
+2068
+4024
+4624
+8222
+8422
+8422
+8B3E
+91A2
+8022
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B118
-ENCODING 45336
+STARTCHAR uni3215
+ENCODING 12821
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0008
-E008
-2008
-21F8
-2008
-2048
-3F88
-0008
-07F8
-0208
-0208
-0210
-03F8
-0200
+1010
+2028
+4024
+4C24
+9E22
+A322
+A122
+A13A
+B322
+9E22
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B119
-ENCODING 45337
+STARTCHAR uni3216
+ENCODING 12822
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0008
-E008
-2008
-20F8
-2008
-2048
-2788
-3808
-0618
-0210
-03F0
-0210
-0210
-03F0
-0210
+1010
+2068
+4024
+4024
+9F22
+8222
+8422
+8A3A
+91A2
+A022
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B11B
-ENCODING 45339
+STARTCHAR uni3217
+ENCODING 12823
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0008
-E008
-2008
-20F8
-2008
-2048
-2788
-3808
-0088
-00C8
-01C0
-0330
-0418
-1804
+1010
+2028
+4024
+4E24
+8022
+9F22
+8222
+843A
+8B22
+90A2
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B11C
-ENCODING 45340
+STARTCHAR uni3218
+ENCODING 12824
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0010
-0008
-E008
-21F8
-2008
-2008
-2088
-3F08
-0000
-0610
-0210
-0630
-0D28
-1044
-2080
+1010
+2068
+4024
+4024
+9F22
+8122
+8222
+9E3E
+8422
+8822
+5024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B11D
-ENCODING 45341
+STARTCHAR uni3219
+ENCODING 12825
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0008
-E008
-2008
-21F8
-2008
-2088
-3F08
-0008
-0048
-01A0
-0210
-0210
-0330
-01E0
+1010
+2068
+4024
+4024
+BF22
+9022
+9F22
+903E
+9062
+9FA2
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B123
-ENCODING 45347
+STARTCHAR uni321A
+ENCODING 12826
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0018
-0008
-E008
-20F8
-2008
-2008
-2F08
-1000
-01C0
-1FBC
-00C0
-0320
-0210
-0220
-01E0
+1010
+2068
+4024
+41A4
+9E22
+9122
+8922
+893A
+82A2
+BD22
+4024
+4024
+2028
+1010
 ENDCHAR
-STARTCHAR B124
-ENCODING 45348
+STARTCHAR uni321B
+ENCODING 12827
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0610
-0110
-0110
-C110
-4110
-4F10
-4110
-4110
-4510
-7910
-0110
-0110
-0110
-0010
+1000
+2060
+4028
+4E24
+8024
+BFA2
+8722
+88BA
+88A2
+88A2
+4724
+4024
+2028
+1008
 ENDCHAR
-STARTCHAR B125
-ENCODING 45349
+STARTCHAR uni321C
+ENCODING 12828
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 13 1 -1
 BITMAP
-0030
-0190
-0090
-C090
-4F90
-4090
-4090
-7C90
-0090
-0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+0008
+5FE4
+80C4
+8182
+8282
+8C72
+9002
+BFFA
+8102
+8102
+8104
+4104
+0108
 ENDCHAR
-STARTCHAR B128
-ENCODING 45352
+STARTCHAR uni3260
+ENCODING 12896
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0110
-0090
-C090
-4090
-4790
-4090
-4090
-7890
-0090
-0890
-0400
-0400
-0400
-07FC
+07C0
+1830
+2008
+600C
+4004
+9FF2
+8012
+8012
+8012
+8012
+8012
+4014
+601C
+2018
+1830
+07C0
 ENDCHAR
-STARTCHAR B12C
-ENCODING 45356
+STARTCHAR uni3261
+ENCODING 12897
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0310
-0090
-C090
-4B90
-4490
-4090
-5C90
-2090
-1FE0
-0020
-0020
-1FE0
-0800
-0FF0
+07C0
+1830
+2008
+600C
+5804
+8802
+8802
+8802
+8802
+8812
+87FA
+4004
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B134
-ENCODING 45364
+STARTCHAR uni3262
+ENCODING 12898
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 16 1 -3
 BITMAP
-0030
-0110
-0090
-C090
-4090
-4390
-4090
-4890
-3090
-0000
-0FF0
-0410
-0420
-0420
-07F0
-0400
+07C0
+1830
+2008
+600C
+4004
+8FF2
+8802
+8802
+8802
+8802
+8802
+4FF4
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B135
-ENCODING 45365
+STARTCHAR uni3263
+ENCODING 12899
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -3
+BBX 15 16 1 -3
 BITMAP
-0030
-0090
-C090
-4090
-4F90
-4090
-4C90
-7090
-0830
-0410
-07F0
-0410
-0410
-07F0
-0410
+07C0
+1830
+2008
+400C
+5FE4
+8022
+8022
+8FE2
+8802
+8802
+8802
+4FF4
+600C
+2018
+1830
+07C0
 ENDCHAR
-STARTCHAR B137
-ENCODING 45367
+STARTCHAR uni3264
+ENCODING 12900
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0110
-0090
-0090
-C090
-4790
-4090
-4290
-7C90
-0310
-0190
-0180
-0240
-0430
-1818
+07C0
+1830
+2008
+600C
+4004
+9FF2
+8822
+8822
+8822
+8822
+8FE2
+4804
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B138
-ENCODING 45368
+STARTCHAR uni3265
+ENCODING 12901
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0110
-0090
-C090
-4090
-4390
-4090
-5C90
-6090
-0060
-0420
-0C60
-0A50
-1288
-6308
+07C0
+1830
+2008
+606C
+4824
+8822
+8FE2
+8822
+8822
+8822
+8FE2
+4824
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B139
-ENCODING 45369
+STARTCHAR uni3266
+ENCODING 12902
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0110
-0090
-C090
-4090
-4390
-4090
-5C90
-6090
-0110
-02C0
-0420
-0420
-0660
-03C0
+07C0
+1830
+2008
+400C
+4184
+8182
+8102
+8282
+8642
+8832
+9012
+4004
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B140
-ENCODING 45376
+STARTCHAR uni3267
+ENCODING 12903
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0010
-0010
-C030
-40D0
-4010
-4010
-41F0
-4010
-4210
-7C10
-0010
-0010
-0010
-0010
+07C0
+1830
+2008
+600C
+4104
+87C2
+8C32
+8812
+8812
+8812
+8C22
+47C4
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B141
-ENCODING 45377
+STARTCHAR uni3268
+ENCODING 12904
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 15 16 1 -3
 BITMAP
-0018
-0008
-E008
-2078
+07C0
+1830
 2008
-2088
-23F8
-3C08
-0008
-0000
-1FF0
-0810
-0010
-0010
-0010
-0010
+400C
+4024
+9FF2
+8822
+8042
+80C2
+8182
+8262
+4C14
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B144
-ENCODING 45380
+STARTCHAR uni3269
+ENCODING 12905
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0010
-0010
-C170
-4090
-4010
-4010
-4FF0
-7010
-0010
-0010
-1800
-0800
-0800
-0FF8
+07C0
+1830
+2008
+440C
+43C4
+8022
+9FF2
+8862
+80C2
+8182
+8242
+4C34
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B148
-ENCODING 45384
+STARTCHAR uni326A
+ENCODING 12906
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0010
-0010
-C1F0
-4010
-4010
-41F0
-4410
-7810
-1FE0
-0020
-0020
-1FE0
-0800
-0FF0
+07C0
+1830
+2008
+600C
+4014
+9FF2
+8012
+8012
+80F2
+9F22
+8022
+4044
+604C
+2088
+1830
+07C0
 ENDCHAR
-STARTCHAR B150
-ENCODING 45392
+STARTCHAR uni326B
+ENCODING 12907
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 16 1 -3
 BITMAP
-0070
-0010
-0010
-C1F0
-4010
-4010
-4210
-7CF0
-0010
-0000
-1FE0
-0820
-0820
-0820
-0FE0
-0800
+07C0
+1830
+2008
+402C
+4FE4
+8802
+8802
+8802
+8FE2
+8802
+8802
+4FFC
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B151
-ENCODING 45393
+STARTCHAR uni326C
+ENCODING 12908
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 16 1 -3
 BITMAP
-0030
-0010
-0010
-C1F0
-4010
-4010
-41F0
-4410
-7810
-0C10
-0410
-07F0
-0410
-0410
-07F0
-0410
+07C0
+1830
+2008
+600C
+5FF4
+80C2
+8042
+8442
+8482
+8082
+BFFA
+4004
+600C
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B154
-ENCODING 45396
+STARTCHAR uni326D
+ENCODING 12909
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0010
-0010
-C0F0
-4010
-4010
-47F0
-7810
-0010
-0860
-0420
-0860
-1E50
-2288
-4108
+07C0
+1830
+2008
+400C
+43C4
+8002
+BFFA
+8102
+87C2
+8822
+8822
+4824
+67CC
+2008
+1830
+07C0
 ENDCHAR
-STARTCHAR B155
-ENCODING 45397
+STARTCHAR uni326E
+ENCODING 12910
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0060
-0010
-0010
-C1F0
-4010
-4010
-4610
-79F0
-0010
-0090
-0340
-0420
-0420
-0660
-03C0
+07C0
+1830
+2008
+402C
+4024
+9F22
+8122
+8222
+843E
+8822
+9022
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B158
-ENCODING 45400
+STARTCHAR uni326F
+ENCODING 12911
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 16 1 -3
 BITMAP
-0030
-0010
-8010
-41F0
-4010
-4010
-41F0
-5C10
-6010
-0000
-1FF0
-0020
-01E0
-1E20
-0040
-0040
+07C0
+1830
+2008
+602C
+4024
+9022
+9022
+9022
+903A
+93A2
+9C22
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B15C
-ENCODING 45404
+STARTCHAR uni3270
+ENCODING 12912
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 16 1 -3
 BITMAP
-0018
-00C8
-0048
-C048
-2048
-23C8
-2048
-27C8
+07C0
+1830
 2048
-2648
-3848
-0048
-0048
-0048
-0008
+602C
+4024
+BF22
+9022
+9022
+903A
+9062
+9FA2
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B160
-ENCODING 45408
+STARTCHAR uni3271
+ENCODING 12913
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-0190
-0090
-C090
-4790
-4090
-4790
-5890
-6090
-1C90
-0410
-0400
-0400
-07F8
+07C0
+1830
+2008
+602C
+4024
+9F22
+8122
+BF22
+903E
+9022
+97A2
+5824
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B178
-ENCODING 45432
+STARTCHAR uni3272
+ENCODING 12914
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 9 1 1
+BBX 15 16 1 -3
 BITMAP
-3000
-1000
-1000
-1018
-1FF8
-0100
-0100
-0100
-FFFE
+07C0
+1830
+2008
+402C
+4024
+9F22
+9122
+9122
+923E
+9F22
+9022
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B179
-ENCODING 45433
+STARTCHAR uni3273
+ENCODING 12915
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 16 1 -3
 BITMAP
-3000
-1000
-1010
-0FF8
-0100
-0100
-FFFE
-0000
-0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+07C0
+1830
+2008
+402C
+4324
+9122
+9122
+9F22
+913A
+9122
+9F22
+5124
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B17C
-ENCODING 45436
+STARTCHAR uni3274
+ENCODING 12916
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 16 1 -3
 BITMAP
-7000
-1000
-1000
-1010
-0FF8
-0100
-0100
-FFFE
-0000
-1800
-0800
-0800
-0FF8
+07C0
+1830
+2048
+602C
+4424
+8222
+8422
+8422
+8B3A
+9122
+A022
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B180
-ENCODING 45440
+STARTCHAR uni3275
+ENCODING 12917
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 16 1 -3
 BITMAP
-3000
-1000
-1010
-0FF0
-0100
-0100
-FFFE
-0000
-1FF0
-0010
-1FF0
-0800
-0FF8
+07C0
+1830
+2008
+402C
+4824
+9E22
+A322
+A122
+A13E
+A322
+9E22
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B182
-ENCODING 45442
+STARTCHAR uni3276
+ENCODING 12918
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 16 1 -3
 BITMAP
-3000
-1000
-1000
-0FF0
-0100
-0100
-FFFE
-0000
-1EF8
-0290
-1E90
-1190
-1EF0
-0080
+07C0
+1830
+2008
+602C
+4024
+BF22
+8222
+8622
+863E
+8922
+B022
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B188
-ENCODING 45448
+STARTCHAR uni3277
+ENCODING 12919
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 16 1 -3
 BITMAP
-3000
-1000
-1000
-0FF0
-0100
-0100
-FFFE
-0000
-0000
-1FE0
-0820
-0820
-0820
-0FE0
-0800
+07C0
+1830
+2048
+602C
+4624
+8022
+BF22
+8322
+823E
+8622
+8922
+7024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B189
-ENCODING 45449
+STARTCHAR uni3278
+ENCODING 12920
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 16 1 -3
 BITMAP
-2000
-1000
-1000
-1010
-0FF0
-0100
-0100
-FFFE
-0000
-1820
-0820
-0FE0
-0820
-0FE0
-0820
+07C0
+1830
+2048
+402C
+4024
+9F22
+8122
+BE22
+823A
+8422
+8822
+5024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B18B
-ENCODING 45451
+STARTCHAR uni3279
+ENCODING 12921
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-6000
-1000
-1000
-1030
-0FF0
-0300
-0200
-03FE
-FF00
-0600
-0200
-0700
-04C0
-1820
-2010
+07C0
+1830
+2008
+402C
+4024
+BF22
+9022
+9F22
+903E
+90A2
+9F22
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B18D
-ENCODING 45453
+STARTCHAR uni327A
+ENCODING 12922
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 16 1 -3
 BITMAP
-3000
-1000
-1010
-0FF8
-0100
-0100
-FFFE
-0000
-0100
-06C0
-0820
-0820
-0460
-0380
+07C0
+1830
+2048
+602C
+4124
+9E22
+9122
+892A
+8A32
+83E2
+BC22
+4024
+602C
+2028
+1830
+07C0
 ENDCHAR
-STARTCHAR B192
-ENCODING 45458
+STARTCHAR uni327B
+ENCODING 12923
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
+BITMAP
+07C0
+1830
+2048
+602C
+4E24
+8022
+BFA2
+9E2A
+B132
+A122
+B122
+5E24
+602C
+2028
+1830
+07C0
+ENDCHAR
+STARTCHAR uni327F
+ENCODING 12927
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 13 2 -1
 BITMAP
-6000
-2000
-2000
-1FE0
-0200
-0200
-FFFC
-0000
-3FE0
-00C0
-0880
-0880
-7FF8
+0FC0
+3060
+6010
+4888
+8908
+8A00
+EE3C
+090C
+8988
+C898
+6850
+3060
+0F80
 ENDCHAR
-STARTCHAR B193
-ENCODING 45459
+STARTCHAR uniAC00
+ENCODING 44032
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 2 -2
 BITMAP
-3000
-1000
-1010
-0FF0
-0100
-FFFE
-0000
-03C0
-1FF8
-0100
-06C0
+0080
+0060
+0020
+FE20
+0220
 0420
-0440
-03C0
+0420
+083E
+1020
+1020
+6020
+8020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR B194
-ENCODING 45460
+STARTCHAR uniAC01
+ENCODING 44033
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 16 1 -3
 BITMAP
-0070
+0040
+0030
 0010
-E010
-2010
-2010
-20D0
-1F10
-021E
+7F10
+0310
 0210
-0FF0
-3010
+041E
+0810
+1010
+2000
+DFF0
 0010
 0010
 0010
 0010
+0010
 ENDCHAR
-STARTCHAR B198
-ENCODING 45464
+STARTCHAR uniAC04
+ENCODING 44036
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
 0060
-0020
-6020
-2020
-2120
-1E20
-042C
-04F0
-FF20
 0020
+7E20
+0420
+0420
 0820
+103C
+2020
+4020
+B820
 0800
 0800
-0FF8
+0800
+0FF0
 ENDCHAR
-STARTCHAR B19C
-ENCODING 45468
+STARTCHAR uniAC07
+ENCODING 44039
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
-6020
-2020
-2020
-3F20
-082C
-0870
-FFA0
 0020
-1FE0
 0020
-0040
+FE20
+0220
+043C
+0820
+1020
+2020
+4020
 1FE0
 0800
+0800
+0800
 0FF0
 ENDCHAR
-STARTCHAR B1A8
-ENCODING 45480
+STARTCHAR uniAC08
+ENCODING 44040
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0060
 0020
-6020
-2020
-21A0
-3E20
-0438
-04E0
-FB20
-0040
-0C20
-0840
-0CE0
-1298
-6308
-ENDCHAR
-STARTCHAR B1CC
-ENCODING 45516
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0060
-0010
-4010
-2010
-2010
-2090
-3F10
-0410
-0410
-05D0
-FA10
-0010
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR B1D0
-ENCODING 45520
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 3 -1
-BITMAP
-0060
 0020
-C020
-4020
-4020
-4720
-3820
+FE20
+0620
+043C
 0820
-1FE0
-E020
-3020
-1000
-1000
-1FF0
-ENDCHAR
-STARTCHAR B1D4
-ENCODING 45524
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-0010
-2010
-2010
-2190
-1E10
-0430
-FFD0
-0000
-1FE0
+1020
+2000
+5FE0
+8020
 0020
-1FE0
-0800
+0FE0
 0800
 0FF0
-ENDCHAR
-STARTCHAR B1DC
-ENCODING 45532
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0070
-0010
-6010
-2010
-2190
-3E10
-0410
-0470
-FF90
-0010
-1FF0
-0830
-0820
-0820
-0FF0
-0800
 ENDCHAR
-STARTCHAR B1DD
-ENCODING 45533
+STARTCHAR uniAC09
+ENCODING 44041
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-0060
+00E0
 0020
-4020
-4020
-4320
+FE20
+0620
+0424
+0838
+1020
+2020
+4000
+7DE0
+0420
+7C20
+2020
+2220
 3C20
-0820
-0FC0
-F000
-1040
-0840
-0FC0
-0840
-0FC0
-0840
 ENDCHAR
-STARTCHAR B1DF
-ENCODING 45535
+STARTCHAR uniAC0A
+ENCODING 44042
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 14 3 -2
 BITMAP
-0030
-0010
-6010
-2010
-2010
-3F10
-0410
-05F0
-FA10
-0010
-0090
-0180
-0340
-0430
-1808
+00C0
+FC40
+0C40
+0840
+1048
+2070
+4040
+8040
+7BC0
+0A40
+DA40
+6240
+47C0
+7A00
 ENDCHAR
-STARTCHAR B1E8
-ENCODING 45544
+STARTCHAR uniAC10
+ENCODING 44048
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 10 1 1
+BBX 14 16 2 -3
 BITMAP
-3000
-1000
-1000
-1000
-1FF8
-0040
-0420
+00C0
+0060
+0020
+FE20
+0620
 0420
-0440
-FFFE
-ENDCHAR
-STARTCHAR B1E9
-ENCODING 45545
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-6000
-2000
-2000
-3FE0
-18C0
-0880
-FFFC
-0000
-3FE0
+083C
 1020
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR B1EC
-ENCODING 45548
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -1
-BITMAP
-2000
-1000
-1000
-1010
-1FE0
-0440
-0440
-FFFE
-0000
-1800
-0800
-0800
-0FF8
-ENDCHAR
-STARTCHAR B1F0
-ENCODING 45552
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -1
-BITMAP
-3000
-1000
-1000
-0FF0
-0480
-0480
-FFFE
-0000
-1FF0
-0010
-1FF0
+2020
+4000
+9FE0
+0820
+0820
+0840
+0FE0
 0800
-0FF8
 ENDCHAR
-STARTCHAR B1F9
-ENCODING 45561
+STARTCHAR uniAC11
+ENCODING 44049
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 16 2 -3
 BITMAP
-3000
-1000
-1000
-1FF0
-0C40
-0440
-FFFE
-0000
-1060
-0820
+00C0
+0060
+0020
+FE20
+0620
+0420
+083C
+1020
+2020
+5020
+8820
 0FE0
 0820
+0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR B1FB
-ENCODING 45563
+STARTCHAR uniAC12
+ENCODING 44050
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-7000
-1000
-1000
-1010
-0FF0
-04C0
-04C0
-0880
-FFFC
-0400
-0200
-0600
-0D80
-1060
-6030
+0080
+0060
+0020
+FE20
+0620
+0420
+083C
+1020
+2020
+6260
+9220
+1E40
+1270
+1290
+1F08
+1200
 ENDCHAR
-STARTCHAR B1FD
-ENCODING 45565
+STARTCHAR uniAC13
+ENCODING 44051
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-3000
-1000
-1000
-0FF8
-0440
-0440
-FFFC
-0000
-0100
-06C0
-0820
+0060
+0020
+0020
+FE20
+0620
+043C
 0820
-0460
+1020
+2020
+4120
+8100
 0380
+0660
+0830
+1010
 ENDCHAR
-STARTCHAR B204
-ENCODING 45572
+STARTCHAR uniAC14
+ENCODING 44052
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-6000
-1000
-1000
-1000
-1FF0
-0000
-0000
-FFFE
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+00C0
+0060
+0020
+FE20
+0620
+0420
+083C
+1020
+2020
+5840
+8860
+0840
+16A0
+2310
+4000
 ENDCHAR
-STARTCHAR B205
-ENCODING 45573
+STARTCHAR uniAC15
+ENCODING 44053
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 15 2 -2
 BITMAP
-7000
-1000
-1000
-1FF0
-0000
-0004
-FFFE
-0100
-0100
-0160
-0EA0
-0020
-0020
+0060
 0020
 0020
-ENDCHAR
-STARTCHAR B208
-ENCODING 45576
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -1
-BITMAP
-7000
-1000
-1000
-1FF0
-0000
-0004
-FFFE
-0100
-2100
-1100
-1100
-1100
-1FF0
+FE20
+0620
+043C
+0820
+1020
+2020
+4180
+8660
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR B20B
-ENCODING 45579
+STARTCHAR uniAC16
+ENCODING 44054
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 16 2 -3
 BITMAP
-3000
-1000
-1000
-1FF0
-0000
-0008
-FFFC
-0200
-0200
-1FE0
-1000
-1000
-1000
-0FE0
+00C0
+0060
+0020
+FE20
+0620
+0420
+083C
+1020
+2020
+4000
+BFC0
+0300
+0680
+0860
+1010
+2000
 ENDCHAR
-STARTCHAR B20C
-ENCODING 45580
+STARTCHAR uniAC17
+ENCODING 44055
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 16 2 -3
 BITMAP
-7000
-1000
+00C0
+0020
+FE20
+0220
+0420
+082C
 1030
-1FF0
-0000
-FFFE
-0100
-0100
+2020
+4380
+8000
 3FF0
-0020
-1FE0
-0800
-0800
-0FF8
-ENDCHAR
-STARTCHAR B214
-ENCODING 45588
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-7000
-1000
-1000
-1FF0
-0000
-0000
-FFFE
-0100
 0100
-0FE0
-0820
-0820
-0FE0
-0800
-ENDCHAR
-STARTCHAR B215
-ENCODING 45589
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-6000
-2000
-2000
-3FE0
-0000
-0000
-FFFC
-0200
-22C0
-1240
-1FC0
-1040
-1FC0
-1040
-ENDCHAR
-STARTCHAR B217
-ENCODING 45591
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-6000
+0280
+0470
+1818
 2000
-2060
-3FE0
-0000
-0000
-FFFC
-0200
-0200
-0200
-0200
-0580
-1860
-6000
 ENDCHAR
-STARTCHAR B219
-ENCODING 45593
+STARTCHAR uniAC19
+ENCODING 44057
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-1800
-0800
+00C0
+0060
+0020
+FE20
+0620
+0420
+083C
+1020
+2020
+4000
+8FE0
 0800
-0FF8
-0000
-0000
-FFFE
-0100
-0100
-06C0
-0820
-0820
-0C60
-07C0
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B220
-ENCODING 45600
+STARTCHAR uniAC1A
+ENCODING 44058
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 16 2 -3
 BITMAP
-0038
-0008
-6008
-2008
-2188
-3F88
-0008
-0048
-FF88
-04F8
-0408
-0408
-0408
-0408
-0008
+00C0
+0060
+0020
+FE20
+0620
+0420
+083C
+1020
+2020
+4000
+9FE0
+0840
+0440
+0480
+3FF0
+1800
 ENDCHAR
-STARTCHAR B234
-ENCODING 45620
+STARTCHAR uniAC1B
+ENCODING 44059
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0010
-C010
-2010
-2110
-3F10
-0090
-FF10
-08F0
-0800
-0C30
-0C20
-1A70
-22C8
-4108
+0100
+00C0
+FE40
+0440
+0C40
+1840
+1070
+6040
+8040
+0740
+7E80
+0300
+0C80
+0880
+0700
 ENDCHAR
-STARTCHAR B23C
-ENCODING 45628
+STARTCHAR uniAC1C
+ENCODING 44060
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0088
-0048
-0048
-2048
-2048
-2048
-2748
-1B48
-FC48
-09C8
-0848
-0848
-0048
-0008
+0030
+0190
+0090
+0090
+FC90
+0890
+0890
+10F0
+1090
+2090
+4090
+8090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR B258
-ENCODING 45656
+STARTCHAR uniAC1D
+ENCODING 44061
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0070
+0030
+0110
+0090
+FC90
+0C90
+0890
+10F0
+1090
+2090
+4090
+1FF0
 0010
-E010
-2010
-2010
-2390
-1C10
 0010
-00D0
-FF10
-0410
-0410
-0410
-0410
-0410
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B25C
-ENCODING 45660
+STARTCHAR uniAC20
+ENCODING 44064
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0030
-0010
-6010
-2010
-2110
-3F10
 0030
-FFD0
-0410
-0410
-0010
-0C00
-0400
-0400
-07F8
+0110
+0090
+FC90
+0C90
+0890
+1890
+10F0
+2090
+4090
+9090
+0890
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B260
-ENCODING 45664
+STARTCHAR uniAC24
+ENCODING 44068
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-6010
-2010
-2110
-3F10
-00F0
-FF10
-0410
-0400
+0190
+0090
+FC90
+0C90
+0890
+10F0
+1090
+2090
+4090
+1FF0
+0020
 0FF0
-0010
+0800
 0FF0
-0400
-0400
-07F8
 ENDCHAR
-STARTCHAR B268
-ENCODING 45672
+STARTCHAR uniAC2C
+ENCODING 44076
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0010
-6010
-2010
-2110
-3F10
-01F0
-FE10
-0410
-0000
+0190
+0090
+FC90
+0C90
+0890
+10F0
+1090
+2090
+4090
 0FF0
 0410
-0410
+0420
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR B269
-ENCODING 45673
+STARTCHAR uniAC2D
+ENCODING 44077
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-6010
-2010
-2010
-3F10
-0010
-00F0
-FF10
-0410
-0830
+0190
+0090
+FC90
+0C90
+0890
+10F0
+1090
+2090
+48B0
 0410
 07F0
 0410
@@ -92198,1493 +94539,1710 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR B274
-ENCODING 45684
+STARTCHAR uniAC2F
+ENCODING 44079
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-6000
-2000
-2000
-3FE0
-0000
-0000
-FFFC
-0840
-0840
-0840
-0840
-0840
-0840
-0840
+0030
+0090
+0090
+FC90
+0490
+0890
+10F0
+1090
+2090
+4190
+0080
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR B275
-ENCODING 45685
+STARTCHAR uniAC30
+ENCODING 44080
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 14 2 -2
 BITMAP
-3000
-1000
-1000
-1FF0
-0000
-0008
-FFF8
-0880
-0880
-3FC0
-0040
-0040
-0040
-0040
+0330
+0090
+FC90
+0490
+0890
+08F0
+1090
+2090
+44B0
+0420
+0C60
+0A50
+1088
+6100
 ENDCHAR
-STARTCHAR B27C
-ENCODING 45692
+STARTCHAR uniAC31
+ENCODING 44081
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 12 16 2 -3
 BITMAP
-3000
-1000
-1000
-1FF0
-0000
-0000
-FFFC
-0880
-3F80
-0040
-1FC0
-1000
-1FE0
+0030
+0190
+0090
+FC90
+0C90
+0890
+18F0
+1090
+2090
+4090
+03E0
+0630
+0410
+0410
+0630
+01E0
 ENDCHAR
-STARTCHAR B284
-ENCODING 45700
+STARTCHAR uniAC38
+ENCODING 44088
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-7000
-1000
-1000
-1FF0
-0000
-FFFC
+00E0
+0020
+0020
+FE20
+0220
+043C
+0420
+0820
+1020
+102C
+6030
+8020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniAC39
+ENCODING 44089
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+0020
+FE20
+0620
+0438
+0820
+1820
+203C
+4020
+8000
+3FE0
+1020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniAC3C
+ENCODING 44092
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
+BITMAP
+00C0
+0040
+0040
+FE40
+0478
 0840
 0840
-0000
-1FC0
 1040
-1080
-1F80
+2078
+4040
+A040
+1000
 1000
+1020
+1FE0
 ENDCHAR
-STARTCHAR B285
-ENCODING 45701
+STARTCHAR uniAC40
+ENCODING 44096
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-6000
-2000
-2000
-3FE0
-0000
-FFFC
-0880
-0880
-30C0
-1040
-1FC0
-1040
-1FC0
-1040
+00C0
+0060
+FE20
+0620
+042C
+0830
+1020
+2020
+4038
+8020
+1FE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B289
-ENCODING 45705
+STARTCHAR uniAC4B
+ENCODING 44107
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-3000
-1000
-1000
-1FF8
-0000
-0000
-FFFE
+0060
+0020
+0020
+FE2C
+0630
 0420
-0920
-06C0
-0820
-0820
-0C60
-03C0
+0824
+1038
+2220
+4120
+0100
+0280
+0460
+0810
+1000
 ENDCHAR
-STARTCHAR B290
-ENCODING 45712
+STARTCHAR uniAC4D
+ENCODING 44109
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 10 1 0
+BBX 14 15 2 -2
 BITMAP
-3000
-1000
-1000
-1010
-1FF8
-0000
-0000
-0000
-0000
-FFFE
+0060
+0020
+FE20
+0620
+043C
+0820
+1020
+202C
+4130
+83A0
+0440
+0820
+0820
+0460
+0380
 ENDCHAR
-STARTCHAR B291
-ENCODING 45713
+STARTCHAR uniAC54
+ENCODING 44116
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 13 15 1 -2
 BITMAP
-2000
-1000
-1000
-1000
-1FF0
-0000
-FFFE
-0000
-0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+0018
+0088
+0088
+0088
+7E88
+06F8
+0488
+0488
+0888
+10F8
+1088
+2088
+C088
+0088
+0008
 ENDCHAR
-STARTCHAR B294
-ENCODING 45716
+STARTCHAR uniAC58
+ENCODING 44120
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 -1
+BBX 14 14 1 -2
 BITMAP
-3000
-1000
-1030
-1FF0
-0000
-0004
-FFFE
-3000
-0800
-0800
-0800
-0FF8
+0098
+0048
+7E48
+0448
+0478
+0848
+1878
+1048
+6048
+8848
+0408
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B298
-ENCODING 45720
+STARTCHAR uniAC5C
+ENCODING 44124
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-7000
-1000
-1000
-1FF0
-0000
-0000
-FFFE
-0000
-1FF0
-0010
-1FF0
+0020
+0190
+0090
+FC90
+0CF0
+0890
+10F0
+2090
+4090
+9FE0
+0020
+1FE0
 0800
 0800
-07F0
+0FF0
 ENDCHAR
-STARTCHAR B299
-ENCODING 45721
+STARTCHAR uniAC70
+ENCODING 44144
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-3000
-1000
-1000
-1FF0
-0000
-FFFE
-0000
-0000
-3EF0
+0070
+0030
+0010
+FF10
 0210
-3E10
+0610
+0410
+09F0
+0810
 1010
-1110
-1E10
+2010
+C010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B29A
-ENCODING 45722
+STARTCHAR uniAC71
+ENCODING 44145
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 1 -2
 BITMAP
-3000
-1000
-1000
-1FF0
-0000
+0018
 0008
-FFFC
-0000
-7C00
-05F0
-6D20
-3120
-2DE0
-1100
+4308
+3D08
+0208
+0278
+0408
+0808
+1008
+6FF8
+8408
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR B2A0
-ENCODING 45728
+STARTCHAR uniAC74
+ENCODING 44148
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-7000
-1000
-1000
-1FF0
-0000
-0000
-FFFE
-0000
-0000
-1FF0
-0820
-0820
-0FE0
+0030
+0010
+0010
+7E10
+0210
+0410
+09F0
+0810
+1010
+6010
+B010
+0810
 0800
+0810
+0FF0
 ENDCHAR
-STARTCHAR B2A1
-ENCODING 45729
+STARTCHAR uniAC77
+ENCODING 44151
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-3000
-1000
-1000
-1FF0
-0000
-0000
-FFFC
-3040
-1040
-1FC0
-1040
-1040
-1FC0
-1040
+0030
+0010
+FE10
+0610
+0410
+09F0
+1810
+3010
+4010
+8020
+1FE0
+0800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR B2A3
-ENCODING 45731
+STARTCHAR uniAC78
+ENCODING 44152
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-3000
-1000
-1000
-1000
+0020
+0010
+FE10
+0210
+0410
+0DF0
+0810
+1010
+2010
+C010
 1FF0
-0000
-FFFC
-0000
-0200
-0200
-0700
-0CC0
-1020
-2000
+0020
+1FF0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B2A5
-ENCODING 45733
+STARTCHAR uniAC7A
+ENCODING 44154
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 16 2 -3
 BITMAP
-3000
-1000
+0030
+0010
+7F10
+0210
+0410
+05F0
+0810
 1010
-1FF0
-0000
-0004
-FFFE
-2100
-07C0
-0C60
-0820
-0820
-0C60
-03C0
+6010
+8000
+3DE0
+0520
+3D20
+11E0
+1700
+0800
 ENDCHAR
-STARTCHAR B2A6
-ENCODING 45734
+STARTCHAR uniAC80
+ENCODING 44160
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 16 2 -3
 BITMAP
-3000
-1000
+0030
+0010
+FE10
+0210
+0410
+0DF0
+0810
 1010
+2010
+C000
+1FE0
+0820
+0820
+0840
 0FE0
-0000
-0000
-FFFE
-2000
-2078
-1F80
-0100
-02C0
-0C30
-1008
+0800
 ENDCHAR
-STARTCHAR B2AA
-ENCODING 45738
+STARTCHAR uniAC81
+ENCODING 44161
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 12 16 2 -3
 BITMAP
-E000
-2000
-2020
-3FE0
-0000
-0000
-FFFC
-4000
-40E0
-3FC0
-0880
-0880
-7FF0
+0030
+0010
+FE10
+0210
+0410
+0CF0
+0810
+1010
+2010
+C830
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR B2AC
-ENCODING 45740
+STARTCHAR uniAC83
+ENCODING 44163
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0008
-2008
-1008
-1008
-1048
-1FC8
-0008
-0008
-00E8
-FF08
-0008
-0008
-0008
-0008
+0010
+FF10
+0210
+0410
+0DF0
+0810
+1010
+2010
+C110
+0100
+0380
+0660
+0C30
+1018
 ENDCHAR
-STARTCHAR B2B0
-ENCODING 45744
+STARTCHAR uniAC84
+ENCODING 44164
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 13 15 2 -2
 BITMAP
 0030
 0010
-4010
-2010
-2010
-2010
-3F90
-0010
-FFF0
-2010
-1810
-0800
+FE10
+0610
+05F0
 0810
-0FF8
+1810
+1010
+6040
+8420
+0420
+0A60
+1290
+2108
+4200
 ENDCHAR
-STARTCHAR B2B4
-ENCODING 45748
+STARTCHAR uniAC85
+ENCODING 44165
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 16 2 -3
 BITMAP
-00C0
-0060
-C020
-4020
-4120
-7F20
-0020
+0030
+0010
+FF10
+0210
+0410
+0DF0
+0810
+1010
+2010
+C010
+0080
+0360
+0410
+0410
+0630
 03E0
-FC20
-3FE0
-0020
-3FE0
-1000
-1000
-1FE0
 ENDCHAR
-STARTCHAR B2C8
-ENCODING 45768
+STARTCHAR uniAC86
+ENCODING 44166
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 16 1 -3
 BITMAP
-0038
-0008
-0008
-E008
-2008
-2008
-2008
-2008
-2068
-3F88
-3008
-0008
-0008
-0008
+0018
 0008
+4308
+3D08
+0208
+0278
+0408
+0808
+1000
+6018
+8FF8
+00C0
+00C0
+0130
+0208
+0C04
 ENDCHAR
-STARTCHAR B2C9
-ENCODING 45769
+STARTCHAR uniAC89
+ENCODING 44169
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-E008
-2008
-2008
-2008
-21C8
-3E08
-0000
-1FF0
-0010
-0010
-0010
-0010
+0030
 0010
+FE10
+0210
+0410
+09F0
+0810
+1010
+6010
+8000
+0FE0
+0820
+0FE0
+0800
+07F0
 ENDCHAR
-STARTCHAR B2CC
-ENCODING 45772
+STARTCHAR uniAC8A
+ENCODING 44170
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -1
+BBX 13 15 2 -2
 BITMAP
-0018
-0008
-C008
-2008
-2008
-2008
-2048
-2F88
-3008
-0008
-0C08
-0400
-0400
-07FC
+0030
+0010
+FE10
+0210
+0410
+0DF0
+0810
+1010
+2030
+DFF0
+0000
+0060
+0440
+0440
+3FF8
 ENDCHAR
-STARTCHAR B2D0
-ENCODING 45776
+STARTCHAR uniAC8B
+ENCODING 44171
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -1
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-E008
-2008
-2008
-2028
-2FC8
-1008
-0010
-0FF0
+0030
 0010
-07F8
-0400
-07FC
+0210
+7E10
+0410
+0CF0
+0810
+1010
+6010
+83D0
+1F20
+01C0
+0220
+0260
+03C0
 ENDCHAR
-STARTCHAR B2D2
-ENCODING 45778
+STARTCHAR uniAC8C
+ENCODING 44172
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 12 15 2 -2
 BITMAP
 0060
-0020
-C020
-4020
-4020
-43E0
-7C20
-7C20
-04D0
+0030
+0190
+0090
+FC90
 0890
-3090
+0890
+0F90
+1090
 2090
-3CF0
-0080
+2090
+4090
+0090
+0090
+0090
 ENDCHAR
-STARTCHAR B2D8
-ENCODING 45784
+STARTCHAR uniAC90
+ENCODING 44176
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-8010
-4010
-4010
-4010
-4390
-7C10
-0000
-1FE0
-0820
-0820
-0820
-0FE0
+0110
+0090
+FC90
+0490
+0890
+0F90
+1090
+2090
+4090
+9090
+0890
 0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B2D9
-ENCODING 45785
+STARTCHAR uniAC94
+ENCODING 44180
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0070
-0010
+0060
+0220
+0120
+F920
+1920
+1120
+3F20
+2120
+4120
+BFC0
+0040
+0040
+3FC0
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniAC9C
+ENCODING 44188
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
 0010
-C010
-4010
-4010
-43D0
-7C10
-0000
-1C10
-0410
+0090
+0490
+7C90
+0890
+0F90
+1090
+2090
+4080
+8FF0
+0420
+0420
+0420
+07F0
+0400
+ENDCHAR
+STARTCHAR uniAC9D
+ENCODING 44189
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0110
+0090
+FC90
+0490
+0890
+0F90
+1090
+2080
+48B0
+8410
 07F0
 0410
+0410
 07F0
 0410
 ENDCHAR
-STARTCHAR B2DB
-ENCODING 45787
+STARTCHAR uniAC9F
+ENCODING 44191
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 3 -2
 BITMAP
-0040
-0020
-8020
-4020
-4020
-4020
-43E0
-7C20
-0020
+0060
 0220
+0120
+F920
+1920
+1120
+3F20
+2120
+4120
+8620
 0100
 0300
 0480
-1860
-2010
+0860
+3010
 ENDCHAR
-STARTCHAR B2DD
-ENCODING 45789
+STARTCHAR uniACA0
+ENCODING 44192
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-0010
-C010
-4010
-4010
-4090
-7F10
-0010
+0110
 0090
-0360
-0410
-0410
-0630
-03E0
+FC90
+0490
+0890
+1F90
+1090
+2090
+4000
+0430
+0420
+0A50
+1288
+2108
 ENDCHAR
-STARTCHAR B2E2
-ENCODING 45794
+STARTCHAR uniACA1
+ENCODING 44193
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
-8010
-4010
-4010
-4010
-41F0
-7E10
-0010
-1FF0
-0060
-0440
-0640
-3FF8
+0110
+0090
+FC90
+0490
+0890
+0F90
+1090
+2090
+43C0
+8660
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR B2E4
-ENCODING 45796
+STARTCHAR uniACA8
+ENCODING 44200
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0070
+0030
 0010
 0010
-FF90
-2010
-2010
+7E10
+03F0
+0410
+0410
+0810
+11F0
 2010
-201E
-2030
-23D0
-3C10
-0010
+4010
+8010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B2E5
-ENCODING 45797
+STARTCHAR uniACA9
+ENCODING 44201
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0060
-0020
-0220
-FC20
-4020
-402C
-40B0
-5F20
-2020
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+0030
+FE10
+0210
+04F0
+0410
+0810
+11F0
+2010
+DFF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B2E6
-ENCODING 45798
+STARTCHAR uniACAA
+ENCODING 44202
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 13 15 1 -2
 BITMAP
-00C0
-0440
-FC40
-8040
-8040
-8078
-8740
-F840
-0000
-7BC0
-0840
-0840
-0840
-0840
-0040
+0030
+0018
+4308
+3D08
+0278
+0208
+0408
+08F8
+1008
+6008
+8F78
+0108
+0108
+0108
+0108
 ENDCHAR
-STARTCHAR B2E8
-ENCODING 45800
+STARTCHAR uniACAC
+ENCODING 44204
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-00E0
+0060
 0020
-0220
+0020
 FE20
-4020
-4024
-4038
-40A0
-4F20
-7020
+05E0
+0820
+0820
 1020
-0800
+21E0
+4020
+B820
 0800
 0800
-0FF8
+0810
+0FF0
 ENDCHAR
-STARTCHAR B2EB
-ENCODING 45803
+STARTCHAR uniACAF
+ENCODING 44207
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 14 2 -1
 BITMAP
-0060
 0030
-0110
-FF10
-2010
+0010
+7F10
+0230
+07F0
+0410
+0810
+11F0
 2010
-201E
-21D0
-3E10
-0000
+C020
+1FE0
+0800
+0810
 0FF0
-0400
-0400
-0408
-07FC
 ENDCHAR
-STARTCHAR B2EC
-ENCODING 45804
+STARTCHAR uniACB0
+ENCODING 44208
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-00C0
-0260
-FE20
-4020
-4020
-402C
-43B0
-7C20
-0020
+0060
+0030
+FE10
+0610
+04F0
+0810
+1810
+33F0
+4010
+8010
 1FE0
 0020
 1FE0
 0800
-0800
-07F0
+0FF8
 ENDCHAR
-STARTCHAR B2ED
-ENCODING 45805
+STARTCHAR uniACB8
+ENCODING 44216
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 11 16 3 -3
 BITMAP
+00C0
 0060
-0220
 FE20
-4020
-4024
-4078
-4FA0
-3020
-0000
-7DE0
 0420
-6C20
-3020
-2220
-3C20
+07E0
+0820
+1020
+2020
+43E0
+8020
+1FE0
+0820
+0840
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR B2EE
-ENCODING 45806
+STARTCHAR uniACB9
+ENCODING 44217
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0060
-0020
-FE20
-4020
-402C
-40F0
-4F20
-7020
-0000
-7DF0
-0520
-7D20
-2120
-23E0
-3D00
+0030
+FE10
+0210
+04F0
+0C10
+0810
+11F0
+2010
+C810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR B2EF
-ENCODING 45807
+STARTCHAR uniACBB
+ENCODING 44219
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 3 -3
+BBX 13 15 2 -2
 BITMAP
-00C0
-0040
-FC40
-8040
-8040
-8058
-87E0
-F840
-0000
-FA40
-1240
-0BC0
-7240
-4640
-7BC0
+0030
+0010
+FF10
+0270
+03F0
+0410
+0C10
+0810
+11F0
+6110
+0190
+0190
 0240
+0430
+1818
 ENDCHAR
-STARTCHAR B2F3
-ENCODING 45811
+STARTCHAR uniACBC
+ENCODING 44220
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-00E0
-0020
-8E20
-7020
-4020
-4078
-5FA0
-2000
-00E0
-3C18
-09E0
-30A0
-2110
-3D10
-00E0
+0060
+0030
+FE10
+0210
+04F0
+0C10
+0810
+11F0
+2010
+C070
+0C30
+0820
+1E50
+1288
+6108
 ENDCHAR
-STARTCHAR B2F4
-ENCODING 45812
+STARTCHAR uniACBD
+ENCODING 44221
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-00E0
-0020
-0220
-FE20
-4020
-403C
-4020
-43A0
-7C20
-0000
-0FE0
-0820
-0820
-0FE0
-0800
+0060
+0030
+FE10
+0210
+04F0
+0C10
+0810
+11F0
+2010
+C090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR B2F5
-ENCODING 45813
+STARTCHAR uniACC1
+ENCODING 44225
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-01C0
-0040
-0C40
-F040
-8040
-8078
-8140
-FE40
-0000
-30C0
-1040
-1FC0
-1040
-1FC0
-1040
+0060
+0030
+FE10
+0210
+04F0
+0C10
+0810
+11F0
+2010
+C000
+07F0
+0400
+07F0
+0400
+07F8
 ENDCHAR
-STARTCHAR B2F7
-ENCODING 45815
+STARTCHAR uniACC4
+ENCODING 44228
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0100
-00C0
-0040
-F840
-8040
-8040
-80F8
-8F40
-F040
-0240
-0100
-0300
-0480
-0860
-3010
+0030
+0010
+0190
+0490
+7C90
+0F90
+0890
+0890
+1790
+2090
+4090
+8090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR B2F8
-ENCODING 45816
+STARTCHAR uniACC8
+ENCODING 44232
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 3 -2
 BITMAP
-00C0
-0440
-FC40
-8040
-8040
-80F0
-8F40
-7040
-0000
-10C0
-0840
-1880
-24C0
-4130
-8610
+0060
+0220
+0120
+F920
+0920
+1720
+3120
+2F20
+4120
+8120
+6120
+1020
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR B2F9
-ENCODING 45817
+STARTCHAR uniACCC
+ENCODING 44236
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
-0020
-8620
-7820
-4020
-403C
-40A0
-7F20
-0020
-0100
-06C0
-0820
-0820
-0C60
-03C0
+0220
+0120
+F920
+0920
+1720
+1120
+2F20
+7FC0
+8040
+0040
+3FC0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR B2FA
-ENCODING 45818
+STARTCHAR uniACD5
+ENCODING 44245
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0020
-FF20
-4020
-4020
-403C
-47E0
-7820
-0020
-3FF0
-0100
-0380
-0640
-0830
-3010
+0030
+0010
+0090
+FC90
+0490
+0B90
+0890
+1790
+2090
+48B0
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR B2FB
-ENCODING 45819
+STARTCHAR uniACD7
+ENCODING 44247
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 15 2 -2
 BITMAP
 0060
+0030
+0090
+FC90
+0490
+0B90
+1890
+1790
+2090
+4190
+8090
+0180
+0240
+0430
+1808
+ENDCHAR
+STARTCHAR uniACE0
+ENCODING 44256
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 0
+BITMAP
+7FF0
+0030
 0020
 0020
-FE20
-4020
-403C
-43A0
-7C20
-0780
+0620
+0240
+0240
+0200
+0200
+FFFC
+ENDCHAR
+STARTCHAR uniACE1
+ENCODING 44257
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+0018
+1FF8
+0010
+0310
+0100
+0100
+FFFE
 0000
-3FF0
+00F0
+1F10
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniACE4
+ENCODING 44260
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -2
+BITMAP
+3FF8
+0008
+0010
+0310
+0110
 0100
-0280
-0460
-1810
-2000
+FFFE
+0000
+0000
+1800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B2FF
-ENCODING 45823
+STARTCHAR uniACE7
+ENCODING 44263
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 3 -3
+BBX 15 14 1 -2
 BITMAP
-00C0
-0040
-0840
-F040
-8040
-8040
-8170
-FE40
-0040
-0700
-7FE0
-0200
-0F80
-0880
-0880
-0700
+0018
+1FF8
+0010
+0310
+0100
+0100
+FFFE
+2000
+0000
+1FE0
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B300
-ENCODING 45824
+STARTCHAR uniACE8
+ENCODING 44264
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0220
-0120
-0120
-F120
-8120
-8120
-8120
-81E0
-8720
-F920
-0120
-0120
-0120
+0018
+1FF8
+0010
+0310
+0100
+0100
+FFFE
+2000
+0000
+1FE0
 0020
+1FF0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B301
-ENCODING 45825
+STARTCHAR uniACEA
+ENCODING 44266
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -3
 BITMAP
-0040
-0230
-0110
-FD10
-4110
-4110
-41F0
-4310
-7D10
-0110
-1FF0
-0810
-0010
-0010
+3FF8
 0010
 0010
+0310
+0100
+0100
+FFFE
+0000
+0000
+1EF8
+0288
+3690
+1890
+13F0
+1C80
 ENDCHAR
-STARTCHAR B304
-ENCODING 45828
+STARTCHAR uniACEC
+ENCODING 44268
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0040
-0130
-0090
-8890
-7090
-4090
-4090
-47F0
-7890
-0090
-0C90
-0490
-0400
-0400
-03FC
+0018
+1FF8
+0310
+0110
+0100
+01FE
+FF00
+0000
+1E10
+0230
+3E30
+1048
+1284
+1C00
 ENDCHAR
-STARTCHAR B308
-ENCODING 45832
+STARTCHAR uniACEF
+ENCODING 44271
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0130
-0090
-8C90
-7090
-4090
-40F0
-4390
-7C90
-0FF0
+1FF8
 0010
-0020
-0FF0
-0400
-0400
-07F8
+0010
+0110
+0100
+FFFE
+0000
+00F0
+1E00
+02F8
+1ED0
+1088
+1688
+0870
 ENDCHAR
-STARTCHAR B310
-ENCODING 45840
+STARTCHAR uniACF0
+ENCODING 44272
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0060
+0038
+1FD8
 0010
 0310
-FD10
-4110
-4110
-43F0
-5D10
-7110
-0110
+0100
+0100
+FFFE
+2000
+0000
 1FE0
 0820
 0820
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR B311
-ENCODING 45841
+STARTCHAR uniACF1
+ENCODING 44273
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -3
 BITMAP
-0030
-0190
-FC90
-4090
-4090
-40F0
-4190
-7E90
-0080
-0810
-0410
-07F0
-0410
-0410
-07F0
-0410
+0038
+1FD8
+0010
+0310
+0100
+0100
+FFFE
+0000
+1060
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR B313
-ENCODING 45843
+STARTCHAR uniACF3
+ENCODING 44275
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0030
-0090
-0090
-F890
-4090
-4090
-40F0
-4390
-7C90
-0190
-0180
-0180
-0260
-0C10
-1008
+2078
+1F98
+0010
+0310
+0100
+0100
+FFFE
+0000
+0200
+0100
+0300
+06C0
+0830
+1010
+2000
 ENDCHAR
-STARTCHAR B314
-ENCODING 45844
+STARTCHAR uniACF5
+ENCODING 44277
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
+0018
+1FF8
+0010
 0310
-0090
-FC90
-4090
-4090
-41F0
-5E90
-6090
+0100
+0100
+FFFE
+0000
+0100
+06C0
 0820
-0420
-0C20
-1A50
-2188
-4108
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR B315
-ENCODING 45845
+STARTCHAR uniACF6
+ENCODING 44278
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0190
-0090
-8C90
-7090
-4090
-40F0
-4190
-4E90
-7090
-0340
-0420
-0420
+0018
+1FF8
+0010
+0310
+0100
+0100
+FFFE
+2000
+3FF8
+0100
+0380
 0660
-03C0
+0810
+3008
 ENDCHAR
-STARTCHAR B31C
-ENCODING 45852
+STARTCHAR uniACFC
+ENCODING 44284
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-00E0
+0060
 0020
-0220
-FF20
-4020
-4038
-4020
-4020
-40E0
-473C
-3820
+0020
+7F20
+0120
+0120
+1220
+0A3C
+0820
+0BE0
+F420
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR B354
-ENCODING 45908
+STARTCHAR uniACFD
+ENCODING 44285
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0070
+0030
 0010
-0210
-FE10
-4010
-4010
-41F0
-4010
-4010
-4090
-7F10
+7F90
+0110
+1910
+0912
+087C
+FF90
+0010
+0000
+0FF0
 0010
 0010
 0010
 0010
+0010
 ENDCHAR
-STARTCHAR B355
-ENCODING 45909
+STARTCHAR uniAD00
+ENCODING 44288
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0070
-0210
-FE10
-4010
-43F0
-4010
-4010
-4610
-7810
-0000
-3FE0
-0020
+0060
 0020
 0020
+7F20
+0120
+3220
+122C
+10F0
+FF20
 0020
 0020
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B356
-ENCODING 45910
+STARTCHAR uniAD04
+ENCODING 44292
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0070
-0010
-CE10
-7010
-41F0
-4010
-4010
-7E10
-0010
+0060
+0020
+7F20
+0120
+3220
+122C
+10F0
+FF20
+0020
 0000
-7CF0
-0410
-0410
-0410
-0410
+1FE0
+0040
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B358
-ENCODING 45912
+STARTCHAR uniAD06
+ENCODING 44294
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 14 2 -2
 BITMAP
-00E0
-0020
-0420
-F820
-8020
-83E0
-8020
-8020
+0060
+7F20
+0120
+0220
+1220
+102C
+13F0
 FC20
-0020
-0020
-3000
-1000
-1000
-1FF0
+7C30
+05D0
+7D20
+2120
+3DE0
+0100
 ENDCHAR
-STARTCHAR B35B
-ENCODING 45915
+STARTCHAR uniAD0C
+ENCODING 44300
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-0070
-0610
-F810
-4010
-41F0
-4010
-7E10
-0010
-0010
-1FF0
-0800
-0800
+0060
+0020
+7F20
+0120
+1220
+123C
+13E0
+FC20
+0000
+0FE0
+0820
+0820
+0840
+0FE0
 0800
-0FF0
 ENDCHAR
-STARTCHAR B35C
-ENCODING 45916
+STARTCHAR uniAD0D
+ENCODING 44301
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-CE10
-7010
-41F0
-4010
-4110
-7E10
-1FE0
-0020
+0060
 0020
-1FE0
-0800
-0800
-07F0
+7F20
+0120
+3220
+122C
+11F0
+FE20
+0000
+1020
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR B35E
-ENCODING 45918
+STARTCHAR uniAD0F
+ENCODING 44303
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0210
-FE10
-4010
-41F0
-4010
-4110
-7E10
-0000
-3CF8
-0490
-6C90
-3090
-20F0
-3E80
+0060
+0020
+FF20
+0120
+2120
+1220
+127C
+1FA0
+E020
+0300
+0100
+0380
+0240
+0C30
+1010
 ENDCHAR
-STARTCHAR B35F
-ENCODING 45919
+STARTCHAR uniAD11
+ENCODING 44305
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
-FE10
-4010
-41F0
-4010
-4110
-7E10
+3F90
+0090
 0110
-7D10
-05F0
-6D10
-3110
-23F0
-3D10
+0916
+0838
+DFD0
+2010
+0080
+03E0
+0630
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR B364
-ENCODING 45924
+STARTCHAR uniAD18
+ENCODING 44312
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -3
+BBX 11 15 3 -2
+BITMAP
+0080
+0260
+0120
+0120
+F920
+0920
+4920
+29E0
+2120
+3F20
+C120
+0120
+0120
+0120
+0020
+ENDCHAR
+STARTCHAR uniAD1C
+ENCODING 44316
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
 BITMAP
 0018
-E308
-3C08
-2008
-21F8
-2008
-2188
-3E08
-0008
-0FF0
-0410
-0410
-0410
-07F0
+0088
+0048
+7F48
+0248
+0248
+1A48
+0878
+09C8
+FE48
+0848
+0448
+0400
 0400
+03FC
 ENDCHAR
-STARTCHAR B365
-ENCODING 45925
+STARTCHAR uniAD20
+ENCODING 44320
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 14 2 -2
+BITMAP
+01B0
+0090
+FC90
+0490
+3490
+14F0
+1390
+FC90
+0090
+1FE0
+0020
+1FE0
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniAD29
+ENCODING 44329
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
 0030
-0010
-C610
-7810
-41F0
-4010
-4010
-4610
-7C30
+0190
+0090
+FE90
+0490
+3490
+14F0
+1390
+FC90
+0CB0
 0420
 07E0
 0420
@@ -93692,218 +96250,178 @@
 07E0
 0420
 ENDCHAR
-STARTCHAR B367
-ENCODING 45927
+STARTCHAR uniAD2C
+ENCODING 44332
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 16 2 -3
 BITMAP
 0030
-0010
-8610
-7810
-4010
-41F0
-4010
-4110
-7E10
-0110
 0190
-0180
-0240
-0C30
-1008
+0090
+FC90
+0490
+3490
+14F0
+1390
+FC90
+00D0
+0C20
+0840
+0C60
+1298
+2108
+C000
 ENDCHAR
-STARTCHAR B369
-ENCODING 45929
+STARTCHAR uniAD2D
+ENCODING 44333
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0210
-FE10
-4010
-43F0
-4010
-4010
-4610
-7810
-0080
-0360
-0410
+0090
+0090
+FE90
+0490
+3490
+14F0
+1790
+F890
+0090
+03E0
+0630
 0410
 0630
-01E0
+03E0
 ENDCHAR
-STARTCHAR B36B
-ENCODING 45931
+STARTCHAR uniAD34
+ENCODING 44340
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 11 15 3 -2
 BITMAP
 0060
 0020
-FE20
-4020
-43E0
-4020
-4020
-7E20
 0020
-0700
-3FE0
-0200
-0500
-18C0
-6020
-ENDCHAR
-STARTCHAR B36E
-ENCODING 45934
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 1 -1
-BITMAP
-0018
-0008
-FF08
-2008
-20F8
-2008
-2088
-3F08
-0018
-1FF8
+FF20
+0220
+0220
+1220
+1420
+10E0
+3F20
+C020
 0020
-0420
-0240
-3FFC
-ENDCHAR
-STARTCHAR B370
-ENCODING 45936
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-0060
-0620
-0120
-1120
-E120
-8120
-8320
-8D20
-8120
-8920
-F120
-0120
-0120
-0120
+0020
+0020
 0020
 ENDCHAR
-STARTCHAR B371
-ENCODING 45937
+STARTCHAR uniAD35
+ENCODING 44341
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0190
-0090
-F890
-4090
-4790
-4090
-4C90
-3090
+0010
+3F90
 0090
-1FF0
+1910
+0910
+0870
+FF90
 0010
+0000
+1FF0
+0810
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B374
-ENCODING 45940
+STARTCHAR uniAD38
+ENCODING 44344
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
+0010
+0010
+7F90
 0110
-0090
-F890
-4090
-4390
-4090
-4090
-5C90
-2090
-0090
-0C00
-0400
-0400
+1910
+0910
+08F0
+FF10
+0010
+0010
+1800
+0800
+0800
 07F8
 ENDCHAR
-STARTCHAR B378
-ENCODING 45944
+STARTCHAR uniAD3C
+ENCODING 44348
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0110
-0090
-F890
-4090
-4790
-4090
-4C90
-7090
-0080
-1FF0
+0060
 0020
-1FE0
-0800
-0FF0
+FF20
+0220
+3220
+1220
+11E0
+FE20
+0000
+3FC0
+0040
+3FC0
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR B380
-ENCODING 45952
+STARTCHAR uniAD44
+ENCODING 44356
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0090
-FC90
-4090
-4F90
-4090
-4490
-7890
+0010
+7F90
 0090
-07F0
+1910
+0910
+0870
+FF90
+0010
+0000
+0BF0
 0410
 0420
+0420
 07F0
 0400
 ENDCHAR
-STARTCHAR B381
-ENCODING 45953
+STARTCHAR uniAD45
+ENCODING 44357
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
+0010
+7F90
 0110
-0090
-F890
-4090
-4790
-4090
-4C90
-7090
+1110
+0910
+0870
+FF90
+0010
 0C10
 0410
 07F0
@@ -93912,793 +96430,836 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR B383
-ENCODING 45955
+STARTCHAR uniAD47
+ENCODING 44359
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
+0010
+7F90
 0110
-0090
-F890
-4090
-4790
-4090
-4090
-7C90
 0110
-0090
+0910
+0810
+09F0
+FE10
+0010
 0180
-0360
-0410
+0180
+0240
+0430
 1808
-ENDCHAR
-STARTCHAR B384
-ENCODING 45956
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0110
-0090
-F890
-4090
-4790
-4090
-4C90
-7090
-0040
-0420
-0840
-1E60
-1298
-6308
 ENDCHAR
-STARTCHAR B385
-ENCODING 45957
+STARTCHAR uniAD49
+ENCODING 44361
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0190
-0090
-F890
-4090
-4790
-4090
-4C90
-7090
-0080
-0340
-0420
-0420
-0660
-03C0
+0060
+0020
+FF20
+0220
+0220
+1220
+1020
+1FE0
+E020
+0120
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR B38C
-ENCODING 45964
+STARTCHAR uniAD50
+ENCODING 44368
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 10 1 0
 BITMAP
-0030
-0010
-0210
-FE10
-40F0
-4010
-4010
-4010
-40F0
-4090
-7F10
-0010
-0010
-0010
+3FF8
+0008
+0008
 0010
+0990
+0490
+0490
+0480
+0480
+FFFE
 ENDCHAR
-STARTCHAR B390
-ENCODING 45968
+STARTCHAR uniAD54
+ENCODING 44372
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 3 -1
+BBX 15 12 1 -1
 BITMAP
-0060
-0020
-0C20
-F3E0
-8020
-8020
-83E0
-8020
-F820
-2020
-1020
+1FF8
+0008
+0010
+0850
+0440
+0444
+FFFE
 1000
-1020
-1FF0
+0800
+0800
+0800
+07F8
 ENDCHAR
-STARTCHAR B394
-ENCODING 45972
+STARTCHAR uniAD58
+ENCODING 44376
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 13 2 -1
 BITMAP
-0070
-0010
-CE10
-71F0
-4010
-41F0
-4110
-7E10
-1FF0
+3FF0
 0020
+01A0
+09A0
+0900
+FFFC
+0000
+3FE0
 0020
+0040
 1FE0
-0800
-0800
-0FF8
+1000
+0FF0
 ENDCHAR
-STARTCHAR B3A0
-ENCODING 45984
+STARTCHAR uniAD61
+ENCODING 44385
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 13 2 -2
 BITMAP
-0060
-0020
-0C20
-F1E0
-8020
-8020
-83E0
-F820
+3FF0
+01A0
+09A0
+0920
+FFFC
 0000
+3040
 1040
-0840
-1840
-24A0
-4510
-8210
+1FC0
+1040
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR B3A1
-ENCODING 45985
+STARTCHAR uniAD63
+ENCODING 44387
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 13 1 -2
 BITMAP
-0030
+1FF8
+0008
 0010
-C610
-78F0
-4010
-4010
-40F0
-4210
-7C10
-0040
-03A0
-0210
-0210
-0230
-01E0
+0850
+0450
+0440
+FFFE
+0100
+0100
+0380
+0660
+0818
+1008
 ENDCHAR
-STARTCHAR B3A8
-ENCODING 45992
+STARTCHAR uniAD6C
+ENCODING 44396
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 15 13 1 -2
 BITMAP
-0060
-0620
-0120
-1120
-E120
-8F20
-8120
-8F20
-8120
-8920
-F120
-0120
-0120
-0120
+1FF8
+0010
+0010
 0020
-ENDCHAR
-STARTCHAR B3AC
-ENCODING 45996
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0310
-0090
-FC90
-4790
-4090
-4190
-4290
-5C90
-6090
-0890
-0400
-0400
-0408
-07F8
+0020
+FFDE
+0120
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR B3C4
-ENCODING 46020
+STARTCHAR uniAD6D
+ENCODING 44397
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 14 1 -2
 BITMAP
+1FE0
 0010
-3FF0
-1000
-1000
-1000
-1000
-1FF8
-0100
+0010
+0020
+0020
+FFFE
 0100
 0100
-FFFE
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR B3C5
-ENCODING 46021
+STARTCHAR uniAD70
+ENCODING 44400
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 15 13 1 -2
 BITMAP
 1FF0
-1000
-1000
-1000
-0FF0
-0100
-0100
-FFFC
-0000
-3FF0
-0010
 0010
 0010
-0010
-ENDCHAR
-STARTCHAR B3C8
-ENCODING 46024
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-3FF0
-1000
-1000
-1000
-1FE0
-0100
+0020
+0020
+FFDE
+0120
 0100
-FFFE
-0000
-1000
-0800
+1900
+0900
 0800
 0800
-0FF8
+07F8
 ENDCHAR
-STARTCHAR B3CB
-ENCODING 46027
+STARTCHAR uniAD73
+ENCODING 44403
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 13 1 -2
 BITMAP
-0030
-3FF0
-1000
-1000
-1020
-1FC0
+1FF8
+0010
+0010
+0020
+FFFE
 0100
 0100
-FFFC
-0000
-77F0
-1800
-1000
-1000
+0100
+1FF0
+0800
+0800
+0800
 0FF0
 ENDCHAR
-STARTCHAR B3CC
-ENCODING 46028
+STARTCHAR uniAD74
+ENCODING 44404
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-30F0
-1F00
-1000
-1000
-1FF0
-0100
-FFFE
-0000
-3FF0
-0010
 1FE0
-0800
+0010
+0010
+0010
+0020
+FFFE
+0100
+0100
+1F20
+00E0
+0020
+1FF0
 0800
 0FF8
 ENDCHAR
-STARTCHAR B3CE
-ENCODING 46030
+STARTCHAR uniAD75
+ENCODING 44405
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 13 1 -2
 BITMAP
-3FF0
-1000
-1000
-1000
-1FF0
-0100
+1FF8
+0010
+0010
+0010
+0020
 FFFE
-0000
-3E00
-06F8
-3E90
-1090
-16F0
-0880
+0100
+1F30
+0250
+3E10
+1010
+1310
+1C10
 ENDCHAR
-STARTCHAR B3D0
-ENCODING 46032
+STARTCHAR uniAD76
+ENCODING 44406
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 13 1 -2
 BITMAP
-31E0
-1E00
-1000
-1000
-1FE0
-0200
-FFFC
-0000
-3CC0
-0440
-6CC0
-30A0
-2D10
-3200
+1FF8
+0010
+0010
+0020
+FFFE
+0100
+0100
+1EF8
+0248
+1E48
+1048
+1E78
+0040
 ENDCHAR
-STARTCHAR B3D4
-ENCODING 46036
+STARTCHAR uniAD7B
+ENCODING 44411
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-1FF0
-1000
-1000
-1020
-1FC0
+1FF8
+0010
+0010
+0020
+FFFE
 0100
-FFFC
-0000
-0000
-1FC0
-1040
-1040
-1FC0
-1000
+0160
+1E10
+03FC
+3620
+18D8
+1188
+1EC8
+0070
 ENDCHAR
-STARTCHAR B3D5
-ENCODING 46037
+STARTCHAR uniAD7C
+ENCODING 44412
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
 1FF0
-1000
-1000
-1010
-0FF0
-0100
+0010
+0010
+0020
+0020
 FFFE
-0000
-1820
-0820
+0100
+0100
+0100
 0FE0
 0820
-0FE0
 0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR B3D7
-ENCODING 46039
+STARTCHAR uniAD7D
+ENCODING 44413
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-3FF0
-1000
-1000
-1030
-1FC0
+1FF8
+0010
+0010
+0020
+0020
+FFFE
 0100
 0100
+0960
+0420
+07E0
+0420
+07E0
+0420
+ENDCHAR
+STARTCHAR uniAD7F
+ENCODING 44415
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -3
+BITMAP
+1FF8
+0010
+0010
+0020
+0020
 FFFE
-0400
+0100
+0100
 0300
-0200
-0580
-0860
-3010
+0100
+0280
+0460
+1810
+2000
 ENDCHAR
-STARTCHAR B3D9
-ENCODING 46041
+STARTCHAR uniAD81
+ENCODING 44417
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 13 1 -2
 BITMAP
-0FF0
-1000
-1000
-1000
 1FF0
+0010
+0020
+0020
+03FE
+FF00
 0100
-FFFC
-0000
-0200
-0D80
-1040
-1040
-18C0
-0F80
+0100
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR B3DB
-ENCODING 46043
+STARTCHAR uniAD82
+ENCODING 44418
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 14 1 -2
 BITMAP
-1FF0
-1000
-1000
-1030
-0FC0
-0200
-FFFC
-0780
-0000
-7FF0
-0200
-0700
-0CC0
-1020
-2000
+3FF0
+0010
+0010
+0020
+0020
+FFFE
+0100
+0100
+01F8
+1F00
+0300
+06C0
+0830
+3008
 ENDCHAR
-STARTCHAR B3DD
-ENCODING 46045
+STARTCHAR uniAD88
+ENCODING 44424
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-1FE0
-1000
-1000
-1000
-1FF0
-0200
-FFFC
-0000
-0000
-1FE0
-1000
-1FE0
-1000
-1FE0
+0030
+0010
+FF10
+0310
+0210
+0210
+0210
+0F10
+F810
+09F0
+0810
+0810
+0810
+0810
+0010
 ENDCHAR
-STARTCHAR B3E0
-ENCODING 46048
+STARTCHAR uniAD89
+ENCODING 44425
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 12 16 2 -3
 BITMAP
-0060
+0030
 0010
-0110
-7F10
-2010
-2010
-2010
-2190
-1E16
-0418
-04F0
 FF10
+0210
+0210
+0310
+FC10
+08F0
+0810
+0800
+1FF0
+0010
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B3E4
-ENCODING 46052
+STARTCHAR uniAD8C
+ENCODING 44428
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 3 -2
+BBX 13 15 2 -2
 BITMAP
-00C0
-0040
-8740
-7840
-4040
-4240
-3C48
-0870
-0FC0
-F040
-3040
-1000
-1000
-1FF0
+0030
+0010
+0010
+3F10
+0110
+0210
+0390
+FC10
+09F0
+0810
+0010
+0C00
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR B3E8
-ENCODING 46056
+STARTCHAR uniAD90
+ENCODING 44432
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 1 -2
 BITMAP
-0030
-0110
-3F10
-2010
-2010
-1F96
-0418
-FFF0
-0000
-0FF0
-0020
-0020
-0FF0
+0018
+0008
+3F88
+0188
+0108
+0108
+FF88
+2478
+0408
 0400
 07F8
+0008
+07F8
+0200
+03FC
 ENDCHAR
-STARTCHAR B3FC
-ENCODING 46076
+STARTCHAR uniAD9C
+ENCODING 44444
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0060
-0110
-0090
-DC90
-6090
-4090
-4490
-7890
-10F0
-1090
-1E90
-F090
-0090
-0090
+0030
 0010
+7F10
+0110
+0210
+0390
+FC10
+08F0
+0810
+0060
+0420
+0420
+0A50
+1188
+2104
 ENDCHAR
-STARTCHAR B410
-ENCODING 46096
+STARTCHAR uniAD9D
+ENCODING 44445
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 14 1 -2
 BITMAP
-0030
-0110
-0090
-7C90
-4090
-7E90
-10F0
-1390
-FC90
-0040
-0C20
-0C40
-0E60
-3298
-4108
+0018
+3F88
+0108
+0108
+02C8
+FD08
+0478
+0408
+0448
+01A0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR B418
-ENCODING 46104
+STARTCHAR uniADA4
+ENCODING 44452
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 11 15 3 -2
 BITMAP
-00E0
+0060
+0120
+00A0
+FCA0
+04A0
+04A0
+08A0
+0CA0
+F0A0
+17A0
+10A0
+10A0
+10A0
+00A0
 0020
-0220
-FE20
-4020
-4020
-4120
-7F20
-0820
-0820
-0FA0
-F020
+ENDCHAR
+STARTCHAR uniADB7
+ENCODING 44471
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0068
+0028
+7E28
+0228
+0228
+0428
+FE28
+09E8
+08A8
+0840
+0080
+0160
+0218
+0C0C
+ENDCHAR
+STARTCHAR uniADC0
+ENCODING 44480
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+FF10
+0310
+0210
+0210
+0210
+0790
+F810
+0810
+0810
+0810
+0810
+0810
+0010
+ENDCHAR
+STARTCHAR uniADC1
+ENCODING 44481
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0020
+0010
+3F90
+0110
+0110
+02F0
+FF10
+0410
+0410
+0410
+3FE0
 0020
 0020
 0020
+0020
+0020
 ENDCHAR
-STARTCHAR B41C
-ENCODING 46108
+STARTCHAR uniADC4
+ENCODING 44484
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 13 15 2 -2
 BITMAP
 0030
-0110
+0010
 7F10
-2010
-2010
-2090
-3F90
+0110
+0110
+0230
+01D0
+FE10
 0410
-0430
-FFD0
+0410
+0010
 1810
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR B420
-ENCODING 46112
+STARTCHAR uniADC8
+ENCODING 44488
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0220
-FE20
-4020
-4020
-4F20
-3820
-0BA0
-F400
-3FC0
-0040
-3FC0
-1000
-1000
-1FE0
+0020
+0010
+7F90
+0090
+0110
+01F0
+FF10
+0410
+0410
+0FF0
+0010
+0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR B428
-ENCODING 46120
+STARTCHAR uniADD0
+ENCODING 44496
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
+0020
 0010
-7F10
-2010
-2010
-2190
-1E10
+3F90
+0110
+0110
+01F0
+FF10
 0410
-FFD0
-0000
+0410
+0010
 0FF0
 0410
 0420
+0420
 07F0
 0400
 ENDCHAR
-STARTCHAR B429
-ENCODING 46121
+STARTCHAR uniADD1
+ENCODING 44497
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
 0010
-7F90
-2010
-2010
-2190
-1E10
+3F90
+0110
+0110
+01F0
+FF90
 0410
-FFC0
-2C30
 0410
+0C30
+0410
 07F0
 0410
+0410
 07F0
 0410
 ENDCHAR
-STARTCHAR B42B
-ENCODING 46123
+STARTCHAR uniADD3
+ENCODING 44499
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-00E0
 0020
-7E20
-4020
-4020
-4320
-3C20
-0860
-F7A0
-0220
-0100
-0300
-0480
-0860
-3010
+0010
+3F90
+0110
+0110
+02F0
+FF90
+0410
+0410
+0590
+0190
+0180
+0240
+0C30
+1008
 ENDCHAR
-STARTCHAR B434
-ENCODING 46132
+STARTCHAR uniADDC
+ENCODING 44508
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 14 13 2 -2
 BITMAP
 3FF0
-1000
-1000
-1000
-1010
-1FF8
-0000
-0C60
-0420
-0440
-FFFE
+0020
+0020
+0020
+0040
+FFFC
+0840
+0840
+0840
+0840
+0840
+0840
+0840
 ENDCHAR
-STARTCHAR B450
-ENCODING 46160
+STARTCHAR uniADE0
+ENCODING 44512
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 13 2 -2
 BITMAP
-3FF0
+3FE0
+0020
+0040
+0040
+0040
+FFFC
+0880
+0880
+4880
+2880
+2080
+2000
+3FE0
+ENDCHAR
+STARTCHAR uniADE4
+ENCODING 44516
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -2
+BITMAP
+3FE0
+0020
+0040
+0040
+FFFC
+0880
+0880
+3FC0
+0040
+3FC0
 1000
 1000
-1010
-1FF0
-0000
-0004
+1FE0
+ENDCHAR
+STARTCHAR uniADF8
+ENCODING 44536
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
+BITMAP
+3FF8
+0018
+0010
+0010
+0010
+0010
+0020
+0020
 FFFE
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+2000
 ENDCHAR
-STARTCHAR B451
-ENCODING 46161
+STARTCHAR uniADF9
+ENCODING 44537
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 13 1 -2
 BITMAP
-1FF0
-1000
-1000
-1000
-1FF0
-0000
+1FF8
+0010
+0010
+0010
 FFFE
-0100
-0100
+0000
+0000
 1FF0
 0010
 0010
@@ -94706,837 +97267,836 @@
 0010
 0010
 ENDCHAR
-STARTCHAR B454
-ENCODING 46164
+STARTCHAR uniADFC
+ENCODING 44540
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 12 1 -1
 BITMAP
-3FF0
-1000
-1000
-1000
-1FF0
-0000
+1FF8
+0018
+0010
+0010
+0010
 FFFE
-0100
-0100
-0900
-0900
+0000
+3800
+0800
 0800
+0800
 07F8
 ENDCHAR
-STARTCHAR B458
-ENCODING 46168
+STARTCHAR uniADFF
+ENCODING 44543
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 12 1 -1
 BITMAP
-3FE0
-1000
-1000
-1000
-1FF0
-0000
+1FF8
+0010
+0010
+0020
 FFFE
-0100
-3F00
-00E0
-1FE0
+0000
+0000
+0FF0
 0800
 0800
+0800
 0FF0
 ENDCHAR
-STARTCHAR B460
-ENCODING 46176
+STARTCHAR uniAE00
+ENCODING 44544
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 12 2 -1
 BITMAP
-1FB0
-0840
-0800
+1FF0
+0010
+0020
+0020
+FFFC
+0000
+0000
+1FE0
+0040
+1FE0
 0800
 0FF0
-0004
-FFFE
-0100
-0100
-0FE0
-0820
-0820
-0FE0
-0800
 ENDCHAR
-STARTCHAR B461
-ENCODING 46177
+STARTCHAR uniAE01
+ENCODING 44545
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 13 1 -2
 BITMAP
-3FE0
-1000
-1000
-1000
-1FF0
+1FF8
+0010
+0010
+0020
+FFFE
 0000
-FFFC
-0200
-22C0
-1040
-1FC0
-1040
-1040
-1FC0
-1040
+0000
+1E10
+02F0
+3E10
+1010
+1310
+1C10
 ENDCHAR
-STARTCHAR B463
-ENCODING 46179
+STARTCHAR uniAE08
+ENCODING 44552
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 13 1 -2
 BITMAP
-0FE0
-1000
-1000
-1000
-1FF0
+1FF8
+0010
+0010
+0020
+FFFE
 0000
-FFFC
-0200
-0200
-0300
-0200
-0580
-1860
-6010
+0000
+0FF0
+0410
+0410
+0410
+07F0
+0400
 ENDCHAR
-STARTCHAR B465
-ENCODING 46181
+STARTCHAR uniAE09
+ENCODING 44553
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 13 1 -2
 BITMAP
-1FE0
-1000
-1000
-1000
-1FF0
+1FF8
+0010
+0010
+0020
+FFFE
 0000
-FFFC
+0860
+0420
+07E0
+0420
+0420
+07E0
+0420
+ENDCHAR
+STARTCHAR uniAE0B
+ENCODING 44555
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -2
+BITMAP
+1FF8
+0018
+0010
+0010
+0020
+FFFE
+2000
 0100
 0100
-0780
-0840
-0840
-0C40
-0780
+0280
+0460
+0818
+3008
 ENDCHAR
-STARTCHAR B46C
-ENCODING 46188
+STARTCHAR uniAE0D
+ENCODING 44557
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -2
+BITMAP
+1FF8
+0018
+0010
+0010
+FFFE
+0000
+0100
+07C0
+0C60
+0820
+0820
+0C60
+03C0
+ENDCHAR
+STARTCHAR uniAE14
+ENCODING 44564
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-6790
-3810
-2010
-2110
-3F10
 0010
+7F90
 0110
-FE30
-08D0
-0810
-0810
-0810
+0110
+0110
+0110
+0030
+FFD0
+6010
 0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B480
-ENCODING 46208
+STARTCHAR uniAE30
+ENCODING 44592
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0030
+0060
 0010
-3F10
+0010
+7F10
+0210
+0410
+0410
+0810
+1010
 2010
-2110
-3F10
-0190
-FEF0
+4010
+8010
 0010
-0060
-0420
-0C60
-0A50
-1288
-6108
+0010
+0010
 ENDCHAR
-STARTCHAR B488
-ENCODING 46216
+STARTCHAR uniAE31
+ENCODING 44593
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
-0110
-0090
-FE90
-4090
-4090
-4490
-3890
-0290
-7C90
-0F90
-0890
-0890
-0890
+0030
 0010
+FF10
+0210
+0610
+0410
+0810
+1010
+6010
+9FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B49D
-ENCODING 46237
+STARTCHAR uniAE34
+ENCODING 44596
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
+0060
 0020
-01B0
-0C90
-7090
-4090
-4E90
-3090
-FE90
-1390
-1090
-03D0
-0420
+0020
+FE20
 0420
-0620
-03C0
+0820
+0820
+1020
+2020
+4020
+F020
+1020
+1000
+1020
+1FF0
 ENDCHAR
-STARTCHAR B4A4
-ENCODING 46244
+STARTCHAR uniAE37
+ENCODING 44599
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 2 -1
 BITMAP
 0030
-0110
-7F10
-2010
-2010
-2110
-3F90
 0010
-00D0
-FF10
-0410
-0410
-0410
+7E10
+0210
 0410
-0010
+0810
+0810
+1010
+6000
+9FE0
+0800
+0800
+0810
+0FF8
 ENDCHAR
-STARTCHAR B4A8
-ENCODING 46248
+STARTCHAR uniAE38
+ENCODING 44600
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0030
-0110
-3E10
-2010
-2110
-3F90
 0030
-FFD0
+0010
+7E10
+0210
 0410
 0410
-0010
-0C00
-0400
-0400
-07F8
+0810
+1010
+2000
+DFE0
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR B4AC
-ENCODING 46252
+STARTCHAR uniAE3A
+ENCODING 44602
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-0010
-3F10
-2110
-3F10
-0030
-FFD0
+FE10
 0410
-1FE0
-0020
-0020
-1FE0
+0410
 0810
-0FF0
+1010
+2010
+C400
+3DE0
+0920
+7D20
+2120
+21E0
+3D00
 ENDCHAR
-STARTCHAR B4B5
-ENCODING 46261
+STARTCHAR uniAE40
+ENCODING 44608
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0070
-0110
-3F10
-2010
-2110
-1F10
+0030
 0010
-FFF0
+7E10
+0210
 0410
-0810
 0410
-07F0
+0810
+1010
+2010
+C7F0
 0410
 0410
+0420
 07F0
-0410
-ENDCHAR
-STARTCHAR B4B7
-ENCODING 46263
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 16 2 -3
-BITMAP
-0070
-0110
-3F10
-2010
-2010
-2110
-1F90
-00D0
-FF10
-0810
-0890
-0180
-0140
-0630
-0808
-1000
+0400
 ENDCHAR
-STARTCHAR B4B9
-ENCODING 46265
+STARTCHAR uniAE41
+ENCODING 44609
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0110
-3F10
-2010
-2110
-3F10
 0010
-FFF0
+7E10
+0210
 0410
-0490
-0360
 0410
+0810
+1010
+2000
+CC10
 0410
-0630
-03E0
+07F0
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR B4C0
-ENCODING 46272
+STARTCHAR uniAE43
+ENCODING 44611
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 13 15 2 -2
 BITMAP
-3FF0
-1000
-1000
+0030
+0010
+7E10
+0210
+0410
+0410
+0810
+1010
+2010
+C190
+0180
+0140
+0230
+0C18
 1000
-1FF0
-0000
-0000
-FFFC
-0840
-0840
-0840
-0840
-0840
-0840
-0040
 ENDCHAR
-STARTCHAR B4C4
-ENCODING 46276
+STARTCHAR uniAE45
+ENCODING 44613
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 11 15 3 -2
 BITMAP
-1FF8
-0800
-0800
-0800
-0FF8
-0000
-FFFE
-0420
+00C0
+0060
+0620
+7C20
 0420
-1C20
 0820
-0800
-0FF8
-ENDCHAR
-STARTCHAR B4C8
-ENCODING 46280
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -1
-BITMAP
-30E0
-1F00
-1000
-1020
-1FF0
-0000
-FFFC
-08C0
-2FE0
 1020
-1FE0
-0800
-0FF0
-ENDCHAR
-STARTCHAR B4D0
-ENCODING 46288
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -3
-BITMAP
-1FE0
-1000
-1000
-1000
-1FE0
-C03C
-FFE0
+2020
+4020
+8120
+0680
 0840
-0800
-3FC0
-1040
-1080
-1080
-1FC0
-1000
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR B4D5
-ENCODING 46293
+STARTCHAR uniAE46
+ENCODING 44614
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 3 -2
 BITMAP
-07F8
-0800
-0800
-0800
-0FF8
-0000
-FFFE
+0060
+0020
+FE20
 0420
-0520
-06C0
-0820
 0820
-0C60
-03C0
+1820
+3020
+4020
+8000
+21F0
+1F00
+0300
+04C0
+0830
+3010
 ENDCHAR
-STARTCHAR B4DC
-ENCODING 46300
+STARTCHAR uniAE4A
+ENCODING 44618
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 11 2 0
+BBX 13 15 2 -2
 BITMAP
-0060
-7FE0
-2000
-2000
-2060
-3FE0
-0000
+0030
+0010
+7E10
+0210
+0410
+0410
+0810
+1010
+2010
+DFF0
 0000
-0008
-03FC
-FE00
+0460
+0440
+0040
+3FF8
 ENDCHAR
-STARTCHAR B4DD
-ENCODING 46301
+STARTCHAR uniAE4C
+ENCODING 44620
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 15 2 -2
 BITMAP
-0020
-3FF0
-1000
-1030
-1FF0
-0000
-0000
-FFFC
-0000
-3FE0
+0040
 0020
 0020
+FFA0
+1120
+1120
+2220
+623E
+4620
+8420
+0820
+1020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR B4E0
-ENCODING 46304
+STARTCHAR uniAE4D
+ENCODING 44621
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 12 2 -1
+BBX 13 15 3 -2
 BITMAP
-1FF0
-1000
-1030
-1FF0
-0000
-0000
-FFFC
-6000
-1000
-1000
-1000
-1FF0
+0080
+0040
+3340
+DF40
+2240
+4448
+4470
+8840
+3040
+7FC0
+0040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR B4E3
-ENCODING 46307
+STARTCHAR uniAE4E
+ENCODING 44622
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 3 -2
 BITMAP
-3FF0
-1000
-1000
-1000
-1FF0
-0000
-FFFE
-0000
-0000
-0FF0
-0800
-0800
-0800
-07F8
+0080
+0040
+3340
+DF40
+2240
+4458
+4460
+8840
+1040
+0040
+7BC0
+0840
+0840
+0840
+0840
 ENDCHAR
-STARTCHAR B4E4
-ENCODING 46308
+STARTCHAR uniAE50
+ENCODING 44624
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-0FF0
-3000
-1000
-1000
-1FF0
-0000
-FFFE
-0000
-1FF0
-0020
-1FF0
-0800
-0800
-07F0
+0060
+0010
+0010
+3F90
+0910
+1110
+221E
+4210
+8410
+0810
+0810
+0410
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR B4E6
-ENCODING 46310
+STARTCHAR uniAE54
+ENCODING 44628
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 3 -2
 BITMAP
-3FE0
-1000
+0080
+0040
+3340
+DF40
+2240
+4448
+4470
+8840
+1040
+3FC0
+0080
+3FC0
 1000
 1000
 1FE0
-0000
-FFFC
-0000
-0000
-3DF0
-0510
-3920
-2DE0
-1100
 ENDCHAR
-STARTCHAR B4EC
-ENCODING 46316
+STARTCHAR uniAE56
+ENCODING 44630
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-3FF0
-1000
-1000
-1000
-1FF0
-0000
-FFFC
-0000
-0000
-3FC0
-1040
-1040
-1FC0
-1000
+0060
+F920
+1720
+1120
+2224
+4438
+8020
+7C00
+05F0
+0920
+3120
+2120
+3DE0
+0100
 ENDCHAR
-STARTCHAR B4ED
-ENCODING 46317
+STARTCHAR uniAE5C
+ENCODING 44636
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 3 -2
 BITMAP
-0030
-0FF0
+0080
+0040
+3340
+DF40
+2240
+2448
+4470
+8840
+1040
+3FC0
+0840
+0840
+0840
+0FC0
 0800
-0810
-0FF8
-0000
-FFFE
-0000
-1820
-0820
-0FE0
-0820
-0FE0
-0820
 ENDCHAR
-STARTCHAR B4EF
-ENCODING 46319
+STARTCHAR uniAE5D
+ENCODING 44637
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 3 -2
 BITMAP
-0060
-3FE0
-1000
-1020
-1FF0
-0000
-0000
-FFFC
-0400
-0300
-0300
-0480
-1860
-2010
+0080
+0040
+3340
+DF40
+2240
+2448
+4470
+8840
+1040
+3040
+0840
+0FC0
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR B4F1
-ENCODING 46321
+STARTCHAR uniAE5F
+ENCODING 44639
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 3 -2
 BITMAP
-0038
-1FF8
-0800
-0800
-0FF8
-0000
-0000
-FFFE
-0100
-07C0
-0C60
-0820
-0C60
-03C0
+0180
+0040
+0040
+FF40
+2240
+2240
+4478
+8840
+1440
+2240
+0600
+0500
+08C0
+1060
+6020
 ENDCHAR
-STARTCHAR B4F8
-ENCODING 46328
+STARTCHAR uniAE60
+ENCODING 44640
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -1
 BITMAP
-0060
-0010
-0110
-3F10
-2010
-2010
-2090
-3F90
-0010
-0010
-00F0
-FF10
-0010
-0010
-0010
-0010
+0040
+0020
+19A0
+7FA0
+1120
+222C
+2230
+C420
+0800
+1420
+0C20
+0C60
+1290
+2088
 ENDCHAR
-STARTCHAR B514
-ENCODING 46356
+STARTCHAR uniAE61
+ENCODING 44641
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-0070
-0010
-0010
-FF10
-4010
-4010
-4010
-4010
-4010
-4390
-7C10
-0010
-0010
-0010
-0010
+0080
+0040
+3340
+DF40
+2240
+2448
+4470
+8840
+1040
+2340
+0CC0
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR B515
-ENCODING 46357
+STARTCHAR uniAE65
+ENCODING 44645
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 16 4 -3
+BBX 13 15 3 -2
 BITMAP
-00C0
-0040
-0C40
-F040
-8040
-8040
-8140
-FE40
-0040
-0000
-FF80
-0080
-0080
-0080
-0080
 0080
+0040
+3340
+DF40
+2240
+2448
+4470
+8840
+1040
+20C0
+1F00
+1000
+1FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR B518
-ENCODING 46360
+STARTCHAR uniAE68
+ENCODING 44648
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
+0190
+0090
+0290
+7E90
+2490
+2490
+48F0
+8890
+1090
+1090
+2090
+0090
+0090
 0010
-0610
-F810
-4010
-4010
-4010
-4190
-7E10
-0010
-1C10
-0400
-0400
-0400
-07F8
 ENDCHAR
-STARTCHAR B51B
-ENCODING 46363
+STARTCHAR uniAE69
+ENCODING 44649
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
 0018
+0048
+0048
+7F48
+0948
+1248
+2278
+4448
+8848
+1040
+0FF8
 0008
-0108
-FF08
-2008
-2008
-2008
-20C8
-3F08
-0010
-0FF0
-0400
-0400
-0400
-07F8
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR B51C
-ENCODING 46364
+STARTCHAR uniAE6C
+ENCODING 44652
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 15 1 -2
 BITMAP
 0018
-0008
-E708
-3808
-2008
-2008
-21C8
-3E08
-0000
-0FF0
+00C8
+0048
+0048
+3F48
+1148
+1248
+2478
+4448
+8848
+1048
+0248
+0200
+0200
+03FC
+ENDCHAR
+STARTCHAR uniAE70
+ENCODING 44656
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0020
+0110
+0090
+7E90
+2290
+2490
+44F0
+8890
+1090
+2FF0
 0010
 0FF0
 0400
 0400
-03F8
+07F8
 ENDCHAR
-STARTCHAR B524
-ENCODING 46372
+STARTCHAR uniAE78
+ENCODING 44664
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0030
-0010
+0018
+00C8
+0048
+7F48
+1348
+1248
+2478
+4448
+8848
+1040
+07F8
+0208
 0210
-FE10
-4010
-4010
-4010
-4090
-7F10
-0000
-0FF0
-0410
-0420
-0420
-07C0
+03F8
+0200
 ENDCHAR
-STARTCHAR B525
-ENCODING 46373
+STARTCHAR uniAE79
+ENCODING 44665
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
-0210
-FE10
-4010
-4010
-4010
-4190
-7E10
-0000
-0830
+0130
+0090
+0090
+7E90
+2290
+24F0
+4490
+8890
+1080
+2C10
 0410
 07F0
 0410
@@ -95544,518 +98104,492 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR B527
-ENCODING 46375
+STARTCHAR uniAE7B
+ENCODING 44667
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 1 -2
 BITMAP
-0060
-0020
-0020
-FE20
-4020
-4020
-4020
-40A0
-7F20
-0320
-0180
-0180
-0240
-0C30
-1010
+0018
+0048
+0048
+7FC8
+0948
+1148
+1278
+2448
+C448
+08C8
+0040
+00C0
+0120
+0218
+0C04
 ENDCHAR
-STARTCHAR B528
-ENCODING 46376
+STARTCHAR uniAE7C
+ENCODING 44668
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-00C0
-0020
-0220
-FE20
-4020
-4020
-4020
-43E0
-3C20
-00C0
-0840
-0840
-14A0
-2310
-4208
+0060
+0190
+0090
+7E90
+1290
+2490
+44F0
+8890
+1090
+0860
+0420
+0460
+0A50
+1088
+6108
 ENDCHAR
-STARTCHAR B529
-ENCODING 46377
+STARTCHAR uniAE7D
+ENCODING 44669
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0210
-FE10
-4010
-4010
-4010
-4190
-7E10
-0040
-01A0
+0190
+0090
+7E90
+1290
+2490
+44F0
+8890
+1090
+0090
+0160
 0210
 0210
-0230
+0330
 01E0
-ENDCHAR
-STARTCHAR B52A
-ENCODING 46378
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-0010
-0210
-FE10
-4010
-4010
-4010
-4190
-7E10
-0000
-1FF0
-0100
-0380
-0470
-1810
-ENDCHAR
-STARTCHAR B530
-ENCODING 46384
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0060
-0020
-0020
-F7A0
-4420
-4420
-4420
-443C
-4460
-5FA0
-6020
-0020
-0020
-0020
-0020
 ENDCHAR
-STARTCHAR B531
-ENCODING 46385
+STARTCHAR uniAE84
+ENCODING 44676
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-0060
-0020
-FFA0
-4420
-4420
-443C
-4CE0
-7720
-0020
-0000
-3FE0
+BBX 14 15 2 -2
+BITMAP
+0060
 0020
 0020
+7FA0
+0920
+113C
+2220
+2220
+4420
+843C
+0820
+1020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR B534
-ENCODING 46388
+STARTCHAR uniAE85
+ENCODING 44677
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 15 16 1 -3
 BITMAP
-00C0
-0040
-3B40
-CC40
-8840
-8840
-8878
-BBC0
-CC40
-0040
-2040
-1040
-1000
-1000
-0FE0
+0070
+0010
+0010
+7F92
+199C
+1110
+2210
+421E
+8410
+0000
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B538
-ENCODING 46392
+STARTCHAR uniAE8C
+ENCODING 44684
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0020
-F7A0
-4420
+00E0
+FFA0
+1120
+332C
+2230
 4420
-443C
-5FE0
-6020
-0000
-0000
-0FE0
+882C
+1030
+1FE0
 0020
-0FE0
+1FE0
+0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR B540
-ENCODING 46400
+STARTCHAR uniAEBC
+ENCODING 44732
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-FFA0
-4420
-4420
-443C
-4CE0
-7720
-0020
-0000
-1FE0
-0820
-0840
-0840
-0FE0
-0800
+0030
+0010
+0010
+3F90
+0890
+1110
+11F0
+2210
+4210
+8410
+0810
+1010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B541
-ENCODING 46401
+STARTCHAR uniAEBD
+ENCODING 44733
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
+0030
+0010
+7F90
+1190
+11F0
+2210
+4410
+8810
+0010
+3FE0
 0020
-9FA0
-6420
-4420
-4424
-4478
-7FA0
 0020
-0C60
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniAEBE
+ENCODING 44734
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+7F90
+1190
+11F0
+2210
+4410
+8810
+0010
+47E0
+3C20
 0420
-07E0
 0420
 0420
-07E0
 0420
 ENDCHAR
-STARTCHAR B543
-ENCODING 46403
+STARTCHAR uniAEC0
+ENCODING 44736
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 3 -2
 BITMAP
-00C0
-0040
-0340
-CC40
-8840
-8848
-88F0
-FF40
-0040
-0340
-0200
-0700
-0C80
-1060
-2020
+0060
+0020
+0020
+FF20
+2220
+6220
+45E0
+8820
+0820
+3020
+3820
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B544
-ENCODING 46404
+STARTCHAR uniAEC4
+ENCODING 44740
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0020
-FFA0
-4420
-4420
-442C
-4470
-7FA0
-0020
-0860
-0420
-0420
-0A60
-1198
-2108
+0030
+0010
+7F90
+1190
+11F0
+2210
+4410
+8410
+1800
+0FF0
+0010
+0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR B545
-ENCODING 46405
+STARTCHAR uniAECC
+ENCODING 44748
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-9FA0
-6420
-4420
-442C
-4C70
-77A0
-0020
-0080
-0340
+0030
+0010
+7F90
+1990
+11F0
+2210
+4210
+8410
+0810
+0FF0
+0410
 0420
 0420
-0660
-03C0
+07F0
+0400
 ENDCHAR
-STARTCHAR B54B
-ENCODING 46411
+STARTCHAR uniAECD
+ENCODING 44749
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-01C0
-0040
-EF40
-8840
-8848
-8870
-FBC0
-0400
-0700
-3FF0
-0100
-0EC0
-0840
-0C40
-0780
+0030
+0010
+7F90
+1990
+11F0
+2210
+4210
+8410
+0800
+0820
+0420
+07E0
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR B54C
-ENCODING 46412
+STARTCHAR uniAECF
+ENCODING 44751
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0040
-0220
-0120
-2520
-D920
-9120
-9120
-91E0
-9120
-FF20
-8120
-0120
-0120
-0120
-0020
+0030
+0010
+7F90
+0890
+1110
+11F0
+2210
+4410
+8410
+0910
+0190
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR B54D
-ENCODING 46413
+STARTCHAR uniAED0
+ENCODING 44752
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -3
+BBX 13 15 2 -2
 BITMAP
-0060
-0120
-2520
-D920
-9120
-91E0
-9320
-FD20
-0120
-3FE0
-0020
-0020
-0020
-0020
-0020
+0030
+0010
+7F90
+0890
+1110
+21F0
+4210
+8410
+0800
+0830
+0430
+0C20
+0A50
+1188
+2108
 ENDCHAR
-STARTCHAR B550
-ENCODING 46416
+STARTCHAR uniAED1
+ENCODING 44753
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0020
-0110
-0090
-FE90
-4890
-4890
-4890
-48F0
+0030
+0010
 7F90
-0090
-0090
-0C90
-0400
-0400
-07F8
+1990
+11F0
+2210
+4210
+8410
+0810
+0080
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR B554
-ENCODING 46420
+STARTCHAR uniAED8
+ENCODING 44760
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0020
-00D0
-0050
-F750
-4450
-4450
-4470
-7FD0
-0FF0
 0020
-0020
-0FF0
-0400
-0400
-07F8
+0098
+0048
+1948
+3748
+1248
+2248
+25C8
+4448
+8848
+1048
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR B55C
-ENCODING 46428
+STARTCHAR uniAED9
+ENCODING 44761
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0020
+0030
 0110
 0090
 FE90
-4890
-4890
-48F0
-5B90
-6490
+2490
+4490
+4B90
+9090
+1090
 0080
-07F0
-0410
-0420
-0420
-07F0
+1FF0
+1010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniAEDC
+ENCODING 44764
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0088
+0048
+7F48
+1248
+1248
+25C8
+4448
+8848
+1048
+0048
 0400
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B55D
-ENCODING 46429
+STARTCHAR uniAEE8
+ENCODING 44776
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0020
-0110
-0090
-FE90
-4890
-4890
-48F0
-7F90
+0030
 0090
-0C10
-0410
+0050
+7F50
+1250
+2650
+45D0
+8850
+1050
+2000
 07F0
 0410
-0410
+0420
 07F0
-0410
+0400
 ENDCHAR
-STARTCHAR B55F
-ENCODING 46431
+STARTCHAR uniAEEB
+ENCODING 44779
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0020
+0030
+0110
 0090
-0050
-F750
-4450
-4450
-4470
-4DD0
-7650
+7E90
+2490
+4490
+4B90
+9090
+1090
 0110
-0180
-0140
-0220
-0C10
+0100
+0380
+0640
+0830
 3008
 ENDCHAR
-STARTCHAR B560
-ENCODING 46432
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0020
-0190
-0090
-EC90
-4890
-4890
-48F0
-7F90
-0090
-0C20
-0420
-0620
-0950
-1088
-6100
-ENDCHAR
-STARTCHAR B561
-ENCODING 46433
+STARTCHAR uniAEED
+ENCODING 44781
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 12 15 2 -2
 BITMAP
+0030
 0110
 0090
 FE90
-4890
-4890
-48F0
-5B90
-6C90
-0010
-03C0
-0420
-0420
-0660
-03C0
+2490
+4490
+4B90
+9090
+1090
+0080
+03E0
+0630
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR B5A0
-ENCODING 46496
+STARTCHAR uniAEF4
+ENCODING 44788
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
@@ -96063,993 +98597,1260 @@
 0030
 0010
 0010
-F790
-4410
-4410
-4470
-4410
-4410
-5C90
-6710
+FF90
+1110
+11F0
+2310
+2210
+45F0
+0810
+0810
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B5A1
-ENCODING 46497
+STARTCHAR uniAEF8
+ENCODING 44792
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 14 2 -2
 BITMAP
 0030
 0010
 FF90
-4410
-44F0
-4410
+1110
+11F0
+2210
 4410
-7F10
+89F0
+1010
+1010
+0810
+0800
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniAEFC
+ENCODING 44796
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
 0010
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+7F90
+1190
+1170
+2210
+42F0
+8410
+1800
+0FF0
+0010
+0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR B5A4
-ENCODING 46500
+STARTCHAR uniAF07
+ENCODING 44807
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 11 14 3 -2
 BITMAP
 0060
-0020
 0020
-CE20
-8820
-89E0
-8820
+FF20
+1120
+22E0
+2220
+47E0
 8820
-FE20
-0020
-0020
-1800
-0800
-0800
-0FF0
+1620
+2320
+0300
+04C0
+0860
+3020
 ENDCHAR
-STARTCHAR B5A8
-ENCODING 46504
+STARTCHAR uniAF08
+ENCODING 44808
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0030
+0020
 0010
-9F10
-6410
-44F0
-4410
-4C10
-7710
-1FE0
+7F90
+1190
+1170
+2210
+4210
+84F0
+0810
+0830
+0430
+0C20
+0A50
+1188
+2008
+ENDCHAR
+STARTCHAR uniAF0D
+ENCODING 44813
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+0060
 0020
+FF20
+2260
+23A0
+4420
+8BE0
+1020
+2040
+1FC0
+1000
+1FC0
+1000
+1000
+0FE0
+ENDCHAR
+STARTCHAR uniAF10
+ENCODING 44816
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
 0020
-1FE0
-0800
-0800
-0FF0
+0098
+0048
+1B48
+3748
+13C8
+2248
+2448
+45C8
+8848
+1048
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR B5AA
-ENCODING 46506
+STARTCHAR uniAF2C
+ENCODING 44844
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 10 1 1
 BITMAP
-0030
+FDF8
+0C10
+0810
+0810
+0820
+1320
+1120
+0100
+0100
+FFFE
+ENDCHAR
+STARTCHAR uniAF2D
+ENCODING 44845
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+04F8
+3C10
+0410
+0990
+08A0
+0084
+FFFE
+0000
+1FF0
 0010
-FF10
-4410
-44F0
-4410
-4C10
-7710
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniAF30
+ENCODING 44848
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 -1
+BITMAP
+7CF8
+0410
+0410
+0B10
+0900
+0104
+FFFE
 0000
-7C00
-05F0
-4530
-3930
-2130
-3DF0
+1800
+0800
+0808
+07F8
+ENDCHAR
+STARTCHAR uniAF32
+ENCODING 44850
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+04F8
+3C08
+0410
+0710
+0910
+0900
+FFFE
 0100
+30FC
+11E0
+10F0
+1088
+1C90
+0060
 ENDCHAR
-STARTCHAR B5AB
-ENCODING 46507
+STARTCHAR uniAF34
+ENCODING 44852
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-BF90
-4410
-44F0
-4410
-4C10
-7710
+04F8
+3C10
+0410
+0B10
+0920
+0104
+FFFE
 0000
-05B0
-3C90
-08F0
-3090
-2090
-3CF0
-0090
+1FF0
+0020
+1FE0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B5B0
-ENCODING 46512
+STARTCHAR uniAF3C
+ENCODING 44860
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-FF10
-4410
-44F0
-4410
-4C10
-7710
+00F8
+3C18
+0410
+0710
+0900
+0900
+FFFE
 0000
 0000
-0FE0
+1FE0
 0820
 0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR B5B1
-ENCODING 46513
+STARTCHAR uniAF3D
+ENCODING 44861
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-9F10
-6410
-44F0
-4410
-4C10
-7710
+04F8
+3C18
+0410
+0B10
+0900
+0104
+FFFE
 0000
-1C20
-0420
-07E0
-0420
+1060
+0820
+0FE0
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniAF3F
+ENCODING 44863
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+04F8
+1C08
+0410
+0910
+0910
+0100
+FFFE
+0000
+0100
+0100
+03C0
+0630
+0818
+3008
+ENDCHAR
+STARTCHAR uniAF41
+ENCODING 44865
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+01F8
+3E10
+0410
+0710
+09A0
+0904
+FFFE
+0000
+0080
+0340
 0420
-07E0
 0420
+0660
+03C0
+ENDCHAR
+STARTCHAR uniAF42
+ENCODING 44866
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+3EF8
+0408
+0410
+0610
+0100
+0100
+FFFE
+0000
+1FF0
+0100
+0380
+0660
+0810
+3000
+ENDCHAR
+STARTCHAR uniAF43
+ENCODING 44867
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+3EF8
+2448
+0410
+0510
+0900
+FFFE
+0000
+0000
+03C0
+3FF8
+0100
+02C0
+0430
+1818
+ENDCHAR
+STARTCHAR uniAF48
+ENCODING 44872
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0060
+0010
+0010
+7B90
+0890
+1090
+1890
+1416
+0418
+05D0
+FE10
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniAF49
+ENCODING 44873
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+11A0
+F2A0
+1120
+1520
+253C
+04E0
+FF20
+0020
+3FE0
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniAF50
+ENCODING 44880
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+00C0
+0020
+FFA0
+10A0
+1120
+1520
+2438
+05E0
+FA20
+1FE0
+0020
+0040
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B5B3
-ENCODING 46515
+STARTCHAR uniAF5C
+ENCODING 44892
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-DF90
-6410
-4410
-45F0
-4410
-5D90
-6610
-0310
-0110
-0380
-0660
-0830
-3010
+00C0
+0020
+F7A0
+1120
+1120
+2520
+243C
+05E0
+FA20
+0040
+0420
+0420
+0A60
+1198
+2108
 ENDCHAR
-STARTCHAR B5B4
-ENCODING 46516
+STARTCHAR uniAF5D
+ENCODING 44893
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-0060
+00C0
 0020
-3B20
-CC20
-8BE0
-8820
-8820
+17A0
+70A0
+1120
+1520
+253C
+04E0
 FF20
-8020
-1040
-0840
-18C0
-24A0
-4110
-8610
+00A0
+03C0
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR B5B5
-ENCODING 46517
+STARTCHAR uniAF64
+ENCODING 44900
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0010
-9F90
-6410
-44F0
-4410
-4410
-7F10
+0060
+0190
+0050
+FF50
+2250
+2250
+3A50
+4870
+4850
+0F50
+7050
+0050
+0050
+0050
 0010
-0080
-0360
-0410
-0410
-0630
-03E0
 ENDCHAR
-STARTCHAR B5BB
-ENCODING 46523
+STARTCHAR uniAF65
+ENCODING 44901
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
+0090
+0090
+EE90
+2290
+2A90
+48F0
+0990
+FE90
+0090
+1FF0
 0010
-9F10
-6410
-44F0
-4410
-4F90
-7610
-3FF0
-0100
-0380
-0440
-0440
-0440
-0380
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B5BC
-ENCODING 46524
+STARTCHAR uniAF79
+ENCODING 44921
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 1 -2
 BITMAP
-0040
-0220
-0120
-3520
-D920
-9120
-9120
-9720
-9120
-B520
-D920
-0120
-0120
-0120
-0020
+0018
+0048
+0048
+7F48
+1148
+1948
+1478
+0448
+FFC8
+0048
+01F0
+0318
+0208
+0318
+01F0
 ENDCHAR
-STARTCHAR B5BD
-ENCODING 46525
+STARTCHAR uniAF80
+ENCODING 44928
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0030
-0110
-0090
-EE90
-4890
-4B90
-4890
-7C90
-0090
-0000
-1FF0
+0060
+0010
 0010
+7790
+1090
+2110
+3910
+2910
+0810
+0FD0
+F010
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B5C0
-ENCODING 46528
+STARTCHAR uniAF84
+ENCODING 44932
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0090
-0050
-FE50
-4850
-49D0
-4850
-4950
-7E50
-0050
-0050
-0C50
+0010
+0010
+7B90
+0890
+1910
+1510
+0530
+FED0
+0010
+0010
 0400
 0400
-03F8
+0400
+07F8
 ENDCHAR
-STARTCHAR B5C4
-ENCODING 46532
+STARTCHAR uniAF88
+ENCODING 44936
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0090
-0050
-E750
-4450
-45D0
-4450
-7E50
-0050
-0000
-1FF0
+00C0
+0020
+FF20
+2120
+2220
+2E20
+0A20
+0FE0
+F020
 1FE0
-0800
+0020
+0040
+1FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR B5CC
-ENCODING 46540
+STARTCHAR uniAF90
+ENCODING 44944
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
+0040
 0030
-0110
-0090
-FC90
-4890
-4B90
-4890
-7E90
-0090
+0590
+3A90
+1090
+1D10
+1510
+04F0
+FF10
 0000
-07F0
-0410
-0410
-0420
-07F0
-0400
+0FE0
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR B5CD
-ENCODING 46541
+STARTCHAR uniAF91
+ENCODING 44945
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 11 15 3 -2
 BITMAP
-0060
-0120
-00A0
-D8A0
-90A0
-93A0
-90A0
-F8A0
-00A0
-1860
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+00C0
+0020
+FF20
+1120
+2120
+2E20
+2A20
+0BE0
+F400
+10E0
+0840
+0FC0
+0840
+0FC0
+0800
 ENDCHAR
-STARTCHAR B5CF
-ENCODING 46543
+STARTCHAR uniAF95
+ENCODING 44949
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 14 2 -2
 BITMAP
-0060
-0120
-00A0
-D8A0
-90A0
-93A0
-90A0
-F8A0
-00A0
-06A0
-0300
-0200
-0580
-1860
-2010
+0030
+0090
+3B90
+1090
+1D10
+1510
+0470
+FF90
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR B5D0
-ENCODING 46544
+STARTCHAR uniAF9C
+ENCODING 44956
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 14 11 2 0
 BITMAP
-0060
-0120
-00A0
-D8A0
-90A0
-93A0
-90A0
-F8A0
-00A0
-0040
-0820
-0860
-1460
-2498
-4108
+F9F8
+0808
+0818
+1010
+1010
+3890
+28A0
+08A0
+0880
+088C
+F770
 ENDCHAR
-STARTCHAR B5D1
-ENCODING 46545
+STARTCHAR uniAFB8
+ENCODING 44984
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0120
-00A0
-D8A0
-90A0
-93A0
-90A0
-F8A0
-00A0
+00F8
+1E08
+0410
+0410
+0410
+0004
+FFFE
 0100
-07C0
-0C60
-0820
-0C60
-07C0
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR B5D8
-ENCODING 46552
+STARTCHAR uniAFB9
+ENCODING 44985
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0060
-0010
-0010
-DF90
-6410
-44F0
-4410
-4410
-45F0
-5C90
-6710
-0010
+00F8
+1E18
+0210
+0410
+0404
+FFFE
+0100
+0100
+0100
+3FF0
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B5EC
-ENCODING 46572
+STARTCHAR uniAFBC
+ENCODING 44988
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-9D90
-6610
-44F0
-4410
-4470
-7F90
-0010
-0860
-0420
-0C40
-1AF0
-2118
-4208
+3EF8
+1610
+0410
+0410
+0404
+07FE
+FF00
+0100
+0100
+3100
+1100
+1100
+1000
+1FF0
 ENDCHAR
-STARTCHAR B610
-ENCODING 46608
+STARTCHAR uniAFC0
+ENCODING 44992
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 14 1 -2
 BITMAP
-7CF8
-2080
-2080
-2080
-2280
-3CFC
-0300
+3EF8
+0418
+0410
+0410
+0000
+FFFE
 0100
 0100
-010C
-FFFE
+1FF0
+0020
+1FE0
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR B611
-ENCODING 46609
+STARTCHAR uniAFC7
+ENCODING 44999
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-4F30
-31C0
-2100
-2100
-3CF0
-0300
-010C
+01F0
+3820
+0820
+0840
+1040
 FFFC
-0000
-3FE0
-0020
-0020
-0020
-0020
+0200
+3E60
+0418
+7DE0
+20E0
+2110
+3910
+00E0
 ENDCHAR
-STARTCHAR B614
-ENCODING 46612
+STARTCHAR uniAFC8
+ENCODING 45000
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 -1
+BBX 15 14 1 -2
 BITMAP
-38F8
-2080
-2080
-26F8
-3900
-0100
+00F8
+3E08
+0210
+0410
+0400
 FFFE
-0000
-0800
-0800
+0100
+0100
+0100
+0FE0
+0820
+0820
+0FE0
 0800
-0FF8
 ENDCHAR
-STARTCHAR B618
-ENCODING 46616
+STARTCHAR uniAFC9
+ENCODING 45001
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+3EF8
+0208
+0410
+0410
+0810
+FFFE
+0100
+0100
+1920
+0820
+0FE0
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniAFCB
+ENCODING 45003
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-6DF0
-3100
-2100
-2500
-3FF0
-0200
+7DF0
+0820
+0820
+0840
+1040
 FFFC
-0000
-3FC0
-0040
-3FC0
-1000
-1000
-1FE0
+0200
+0200
+0600
+0200
+0700
+0C80
+1060
+6000
 ENDCHAR
-STARTCHAR B625
-ENCODING 46629
+STARTCHAR uniAFCD
+ENCODING 45005
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-4CF8
-3080
-2080
-2080
-3CFC
-0100
-0104
+3E00
+0278
+0408
+0410
+0410
 FFFE
 0100
-06C0
+0100
+0100
+0EC0
 0820
 0820
 0C60
-07C0
-ENDCHAR
-STARTCHAR B62C
-ENCODING 46636
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
-BITMAP
-0030
-0010
-0010
-3390
-2210
-2210
-2610
-3DD6
-0418
-0470
-FF90
-0010
-0010
-0010
-0010
+03C0
 ENDCHAR
-STARTCHAR B634
-ENCODING 46644
+STARTCHAR uniAFCE
+ENCODING 45006
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0020
-B7A0
-4420
-4420
-77AC
-0870
-1FA0
-7FE0
-0040
-0040
-1FE0
-0800
-0800
-0FF0
+7DF0
+0830
+0820
+0820
+1040
+FFFC
+4200
+0200
+3FF0
+0200
+0300
+04C0
+1830
+6010
 ENDCHAR
-STARTCHAR B648
-ENCODING 46664
+STARTCHAR uniAFD4
+ENCODING 45012
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0020
+0030
 0010
-0090
-0090
-6C90
-4890
-4890
-7690
+1190
+7310
+1110
+2110
+2010
+1F10
+E810
 08F0
-0990
-FE90
-0090
-0090
-0090
+0810
+0810
+0810
 0010
+0010
 ENDCHAR
-STARTCHAR B664
-ENCODING 46692
+STARTCHAR uniAFDC
+ENCODING 45020
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
-0030
-0008
-0268
-3188
-2108
-2108
-2528
-38C8
-0208
-0218
-8FE8
-7008
-0008
-0008
+0018
 0008
+3FC8
+0848
+0888
+08A8
+FF48
+02F8
+0408
+0FF8
+0010
+0010
+0FF8
+0400
+07F8
 ENDCHAR
-STARTCHAR B668
-ENCODING 46696
+STARTCHAR uniAFE8
+ENCODING 45032
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 13 15 2 -2
 BITMAP
 0030
 0010
-1D90
-6610
-4410
-4490
-7F10
-0430
-9FD0
-6010
-1810
-0800
+F710
+1110
+2110
+2290
+FD10
+08F0
 0810
-0FF8
+1060
+0820
+0860
+1660
+2298
+C108
 ENDCHAR
-STARTCHAR B69C
-ENCODING 46748
+STARTCHAR uniAFE9
+ENCODING 45033
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 13 15 1 -2
 BITMAP
-27F8
-1880
-1080
-1080
-1EF8
-0000
-0000
-FFFE
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+0010
+0008
+3B88
+0888
+0888
+1148
+FE88
+0408
+0478
+0448
+01E8
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR B69D
-ENCODING 46749
+STARTCHAR uniAFF0
+ENCODING 45040
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-7DF8
-2080
-2080
-2280
-3CF8
-0000
-FFFE
-0100
-0100
-3FE0
-0020
-0020
-0020
-0020
+0030
+0110
+0090
+2E90
+6290
+2490
+2490
+0C90
+F090
+1790
+1090
+1090
+1090
+0090
+0010
 ENDCHAR
-STARTCHAR B6A0
-ENCODING 46752
+STARTCHAR uniAFF1
+ENCODING 45041
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 13 16 1 -3
 BITMAP
-02F8
-1C80
-1080
-1080
-1EFC
-0000
-FFFE
-0100
-0100
-0900
-0900
-0800
+0030
+0088
+0048
+7748
+1148
+1248
+2248
+FD48
+0BC8
+0840
 0FF8
+0008
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR B6A4
-ENCODING 46756
+STARTCHAR uniAFF4
+ENCODING 45044
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-3FF8
-1080
-1080
-1180
-1E78
-0004
-FFFE
-0100
-1F20
-00E0
-1FE0
-0800
-0800
-0FF0
+0060
+0130
+0090
+0090
+7690
+2290
+2290
+2290
+FC90
+0B90
+0090
+0C10
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR B6AB
-ENCODING 46763
+STARTCHAR uniAFF8
+ENCODING 45048
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-38F0
-2100
-2100
-3D10
-00E0
-87FC
-FE00
-02E0
-3E00
-07F0
-6CE0
-3110
-2710
-18E0
+0030
+0110
+00D0
+2ED0
+62D0
+2490
+2490
+F890
+1790
+1000
+0FF0
+0020
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR B6AC
-ENCODING 46764
+STARTCHAR uniB000
+ENCODING 45056
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 16 1 -3
 BITMAP
-05F8
-3880
-2080
-2080
-3CF8
-0004
-FFFE
-0100
-0100
-0FE0
-0820
-0820
-0820
-0FC0
+0030
+00D8
+0048
+7748
+1148
+1248
+1248
+FD48
+0BC8
+0848
+07F8
+0208
+0208
+0210
+03F8
+0200
 ENDCHAR
-STARTCHAR B6B1
-ENCODING 46769
+STARTCHAR uniB001
+ENCODING 45057
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 16 2 -3
 BITMAP
-99F0
-6100
-4100
-4500
-79F0
-0000
-7800
-87FC
-0200
-0E00
-1980
-1040
-18C0
-0780
+0030
+0190
+0090
+EE90
+2290
+2490
+2490
+F890
+1790
+0830
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR B6D4
-ENCODING 46804
+STARTCHAR uniB004
+ENCODING 45060
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 16 2 -3
 BITMAP
 0030
-0010
-0090
-0090
-FE90
-4890
-4890
-7E90
-0090
-0E90
-F890
-0B90
-0890
-0890
+0190
 0090
+EE90
+2290
+2490
+4490
+FA90
+1790
+1000
+0420
+0C60
+0C60
+1298
+2108
+4000
 ENDCHAR
-STARTCHAR B6F0
-ENCODING 46832
+STARTCHAR uniB00C
+ENCODING 45068
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0030
-0010
-9F90
-6410
-4410
-4410
-7F90
-0010
-00D0
-FF10
-0410
-0410
-0410
-0410
-0010
+0018
+0008
+03C8
+38C8
+0888
+0888
+1088
+11C8
+FE08
+0408
+0408
+0408
+0408
+0408
+0008
 ENDCHAR
-STARTCHAR B6F4
-ENCODING 46836
+STARTCHAR uniB010
+ENCODING 45072
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0010
-BF90
-4410
-4410
-4C90
-7310
-00D0
-FF10
-0810
-0810
-0C10
-0400
-0400
-07F8
+0060
+0020
+F720
+2120
+2220
+2220
+4FE0
+F820
+0820
+0820
+0020
+3000
+1000
+1020
+1FF0
 ENDCHAR
-STARTCHAR B6F8
-ENCODING 46840
+STARTCHAR uniB014
+ENCODING 45076
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
 0010
-F790
-4410
-4410
-7790
-00F0
-FF10
+3B90
+1110
+1110
+11F0
+FE10
+0410
+0400
 0FF0
 0010
 0020
 0FF0
 0400
-0400
 07F8
 ENDCHAR
-STARTCHAR B700
-ENCODING 46848
+STARTCHAR uniB01C
+ENCODING 45084
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-3F88
-1208
-1208
-19C8
-0018
-FFE8
-2208
-0200
-07F8
-0208
-0208
-0210
-03F8
-0200
+0030
+0010
+7B90
+0890
+1110
+1130
+FED0
+0410
+0410
+0000
+07F0
+0410
+0420
+07E0
+0400
 ENDCHAR
-STARTCHAR B701
-ENCODING 46849
+STARTCHAR uniB01D
+ENCODING 45085
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
 0010
-7F10
-2410
-2410
-3F90
-00F0
+3B90
+0890
+0890
+10F0
 FF10
 0410
-0C10
+0400
+0C30
 0410
 07F0
 0410
@@ -97057,526 +99858,629 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR B705
-ENCODING 46853
+STARTCHAR uniB028
+ENCODING 45096
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 1 -2
+BBX 14 15 2 -3
 BITMAP
-0018
-07C8
-1A08
-1208
-17C8
-1808
-0078
-FF88
-0208
-01E0
-0210
-0210
-0330
-01E0
+7DF0
+0410
+0410
+0820
+0820
+1020
+FFFC
+0840
+0840
+0840
+0840
+0840
+0840
+0840
+0040
 ENDCHAR
-STARTCHAR B728
-ENCODING 46888
+STARTCHAR uniB044
+ENCODING 45124
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 10 1 0
 BITMAP
-0400
-38F8
-2080
-2080
-2280
-3CF8
-0000
-0000
-0000
-0000
+3EF8
+0608
+0408
+0410
+0410
+0410
+0820
+0804
 FFFE
+2000
 ENDCHAR
-STARTCHAR B729
-ENCODING 46889
+STARTCHAR uniB045
+ENCODING 45125
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-7DF0
-2100
-2100
-2100
-3DF0
-0000
-07FC
-FF00
+3EF8
+0408
+0410
+0810
+0810
+CFFE
+3000
 0000
-3FE0
-0020
-0020
-0020
-0020
+3FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B72C
-ENCODING 46892
+STARTCHAR uniB048
+ENCODING 45128
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 13 1 -1
 BITMAP
-4CF8
-3080
-2080
-2080
-2CF8
-1000
-0000
+00F8
+1E08
+0410
+0410
+0410
+0006
 FFFE
 0000
+3800
 0800
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR B72F
-ENCODING 46895
+STARTCHAR uniB04A
+ENCODING 45130
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 13 2 -1
+BBX 15 14 1 -2
 BITMAP
-4F30
-31C0
-2100
-2300
-3DF8
-0000
-7800
-87F8
+00F8
+1E08
+0408
+0410
+0400
+FFFE
 0000
-1FE0
-1000
-1000
-1FF0
+20E0
+13F8
+10E0
+1110
+1308
+1D10
+00E0
 ENDCHAR
-STARTCHAR B730
-ENCODING 46896
+STARTCHAR uniB04C
+ENCODING 45132
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-3E18
-10E0
-1080
-11F8
-1E00
-0000
+3EFC
+0608
+0408
+0410
+0410
 FFFE
 0000
-1FF0
+0000
+1FE0
 0020
 1FE0
 0800
 0800
-0FF0
+07E0
 ENDCHAR
-STARTCHAR B738
-ENCODING 46904
+STARTCHAR uniB04E
+ENCODING 45134
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1EF8
-1080
-1080
-1680
-08F8
+7EF8
+0408
+0410
+0410
+0810
+FFFE
+0000
+3E00
+02F0
+0490
+1890
+1090
+16F0
+0880
+ENDCHAR
+STARTCHAR uniB053
+ENCODING 45139
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+3CF8
+0408
+0410
+0410
+FFFE
 0000
+00F0
+3C00
+05F8
+7CE0
+2110
+2308
+3D10
+00F0
+ENDCHAR
+STARTCHAR uniB054
+ENCODING 45140
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1EF8
+0608
+0410
+0410
+0814
 FFFE
 0000
 0000
-0FE0
+1FE0
 0820
-0840
+0820
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR B739
-ENCODING 46905
+STARTCHAR uniB055
+ENCODING 45141
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-00F8
-1C80
-1080
-1080
-12F8
-1C00
-0004
-FFFE
-1870
-0830
+7EF8
+0408
+0410
+0410
+0810
+0820
+CFFE
+7820
+0820
 0FE0
 0820
 0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR B73B
-ENCODING 46907
+STARTCHAR uniB057
+ENCODING 45143
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+7C00
+04F0
+0810
+0820
+0820
+0000
+FFFC
+0000
+0200
+0200
+0500
+08C0
+3020
+4010
+ENDCHAR
+STARTCHAR uniB059
+ENCODING 45145
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-78F8
-2080
-2080
-2280
-3C88
-00F8
-0004
-FFFE
-2200
+3EF8
+0408
+0408
+0410
+0810
+8FFE
+7000
+0000
 0100
-0300
-02C0
-0C30
-1018
+06C0
+0820
+0820
+0460
+0380
 ENDCHAR
-STARTCHAR B744
-ENCODING 46916
+STARTCHAR uniB05D
+ENCODING 45149
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 13 1 -1
+BITMAP
+06F8
+1C08
+0410
+0410
+0000
+FFFE
+0000
+0000
+1FF0
+0800
+0FF0
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniB07C
+ENCODING 45180
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0038
+0008
+0008
+7FC8
+0C48
+0888
+1888
+1108
+2108
+4208
+8408
+0808
+0008
+0008
+0008
+ENDCHAR
+STARTCHAR uniB07D
+ENCODING 45181
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
 0030
 0010
-0010
-F710
-4410
-4410
-4C10
-7390
-0010
-00D0
-FF10
-0010
 0010
-0010
-0010
+7F90
+1110
+3210
+2210
+C410
+0810
+1000
+3FE0
+1020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR B748
-ENCODING 46920
+STARTCHAR uniB080
+ENCODING 45184
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 14 15 1 -2
 BITMAP
-0030
-0010
-0190
-6610
-4410
-4410
-5790
-2030
-FFD0
-6010
-1C10
+0018
+0008
+0008
+3FC8
+0888
+1188
+2108
+4208
+8408
+0808
+0C08
 0400
 0400
-07F8
+0400
+07FC
 ENDCHAR
-STARTCHAR B74C
-ENCODING 46924
+STARTCHAR uniB084
+ENCODING 45188
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
-F790
-4410
-4410
 7F90
-0070
-FF90
-0FF0
-0010
+1190
+1110
+2210
+4210
+8410
+0800
+17F0
 0020
 0FF0
 0400
 0400
-07F8
+03F0
 ENDCHAR
-STARTCHAR B754
-ENCODING 46932
+STARTCHAR uniB08C
+ENCODING 45196
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-F790
-4410
-4410
-7790
-0070
 FF90
-0010
-0830
-07D0
+0890
+1110
+2110
+2210
+4410
+8810
+1000
+27F0
 0410
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR B755
-ENCODING 46933
+STARTCHAR uniB08D
+ENCODING 45197
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 16 1 -3
 BITMAP
-0030
-0010
-7F10
-2410
-2410
-3B90
-0070
-FFA0
-0000
-0C20
-0420
-07E0
-0420
-0420
-07E0
-0420
+0018
+0008
+04C8
+3B48
+0888
+1188
+2108
+4208
+8400
+0E08
+0208
+03F8
+0208
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR B760
-ENCODING 46944
+STARTCHAR uniB08F
+ENCODING 45199
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0010
-0010
-F790
-4410
-4410
-4410
-4410
-4C30
-77D0
-0010
-0010
-0010
-0010
-0010
+0060
+0020
+0320
+FF20
+2220
+2420
+4420
+8820
+1020
+2320
+0300
+0300
+04C0
+0860
+3020
 ENDCHAR
-STARTCHAR B764
-ENCODING 46948
+STARTCHAR uniB091
+ENCODING 45201
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
-0010
-0010
-F790
-4410
-4410
-4410
-4410
-7CF0
-0310
-0810
-0410
-0400
-0400
-07F8
+0020
+0020
+FF20
+2220
+2220
+4420
+8820
+1020
+2120
+06C0
+0820
+0820
+0C60
+03C0
 ENDCHAR
-STARTCHAR B768
-ENCODING 46952
+STARTCHAR uniB098
+ENCODING 45208
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-BF90
-4410
-4410
-4410
-4CF0
-7710
+0040
+0020
+0020
+0020
+C020
+4020
+4020
+403C
+4060
+4FA0
+7020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniB099
+ENCODING 45209
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+0020
+C020
+4020
+403C
+43A0
+7C20
 0000
-1FE0
+3FE0
 0020
-1FE0
-0800
-0800
-0FF0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR B770
-ENCODING 46960
+STARTCHAR uniB09A
+ENCODING 45210
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-97D0
-6210
-4210
-4210
-4670
-7B90
-0010
+0060
+0020
+0020
+C020
+4020
+403C
+43A0
+7C20
 0000
-0FF0
-0410
+7DE0
 0420
 0420
-07F0
-0400
+0420
+0420
+0420
 ENDCHAR
-STARTCHAR B771
-ENCODING 46961
+STARTCHAR uniB09C
+ENCODING 45212
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 15 1 -2
 BITMAP
 0030
 0010
-F3D0
-4210
-4210
-4210
-5EF0
-6310
 0010
-0C10
-0410
-07F0
-0410
-0410
-07F0
-0410
-ENDCHAR
-STARTCHAR B773
-ENCODING 46963
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
+E010
+2010
+2010
+201C
+21D0
+3E10
 0010
-9D90
-6610
-4410
-4410
-4410
-5C90
-6710
-0310
-0180
-0180
-0260
-0C10
-1008
+1C10
+0400
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B775
-ENCODING 46965
+STARTCHAR uniB09F
+ENCODING 45215
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
-F3D0
-4210
-4210
-4210
-4E70
-7190
+C010
+2010
+2010
+2016
+23F8
+3C10
 0010
-0080
-0360
-0410
-0410
-0630
-03E0
+0000
+0FF0
+0400
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR B77C
-ENCODING 46972
+STARTCHAR uniB0A0
+ENCODING 45216
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-00C0
+0060
 0020
 0020
-FE20
-0420
-0420
-FE20
-402C
-4030
-4060
+C020
+4024
+4038
 43A0
 7C20
-0020
-0020
+0000
+1FE0
 0020
+0FE0
+0800
+0800
+07E0
 ENDCHAR
-STARTCHAR B77D
-ENCODING 46973
+STARTCHAR uniB0A1
+ENCODING 45217
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-00C0
-0020
-FE20
-0220
-0220
-7E2C
-4030
-43A0
-7C20
-0000
-3FE0
-0020
+0060
 0020
 0020
+C020
+4020
+41B8
+7E20
 0020
+0C20
+34E0
+0820
+3020
+2020
+3C20
 0020
 ENDCHAR
-STARTCHAR B780
-ENCODING 46976
+STARTCHAR uniB0A2
+ENCODING 45218
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0060
-FE20
-0220
-0220
-FE20
-4024
-4038
-43A0
-7C20
-0020
-1820
-0800
-0800
-07F8
+0030
+0010
+E010
+2010
+2016
+20F8
+3F10
+0010
+1EF0
+0290
+3E90
+1090
+11F0
+1E80
 ENDCHAR
-STARTCHAR B784
-ENCODING 46980
+STARTCHAR uniB0A8
+ENCODING 45224
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
@@ -97584,397 +100488,394 @@
 0060
 0020
 0020
+C020
+4020
+403C
+43A0
 7C20
-0420
-FC2C
-4030
-4120
-7E00
-1FE0
-0040
-0040
-1FE0
-0800
-0FF0
-ENDCHAR
-STARTCHAR B78C
-ENCODING 46988
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-0060
 0020
-FE20
-0420
-0420
-FC2C
-4030
-40A0
-5F20
-2000
+0000
 0FE0
 0820
 0820
-0840
 0FE0
 0800
 ENDCHAR
-STARTCHAR B78D
-ENCODING 46989
+STARTCHAR uniB0A9
+ENCODING 45225
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-00C0
+0060
 0020
-FE20
-0420
-0420
-FC20
-403C
-40A0
-5F20
-3820
+0020
+C020
+4020
+4078
+43A0
+7C20
+0000
+1020
 0820
 0FE0
 0820
-0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR B78F
-ENCODING 46991
+STARTCHAR uniB0AB
+ENCODING 45227
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0040
-FE40
-0440
-0440
-FC40
-4078
-4040
-4340
-7E40
-0100
-0300
-06C0
-0830
-3010
+0030
+0010
+E010
+2010
+2010
+203E
+21D0
+3E10
+0090
+0090
+01C0
+0320
+0618
+080C
 ENDCHAR
-STARTCHAR B790
-ENCODING 46992
+STARTCHAR uniB0AC
+ENCODING 45228
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0020
-FE20
-0220
-0420
-FE24
-4038
-4020
-4720
-7840
-0420
-0C40
-0A60
-1198
-2108
+0030
+0010
+E010
+2010
+2010
+2016
+21D8
+3E10
+0000
+0630
+0210
+0620
+0950
+108C
+2104
 ENDCHAR
-STARTCHAR B791
-ENCODING 46993
+STARTCHAR uniB0AD
+ENCODING 45229
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-FE20
-0420
-0420
-FE2C
-4030
-40A0
-5F20
-6100
+0020
+C020
+4020
+402C
+40B0
+7F20
+0020
+0100
 06C0
 0820
 0820
 0C60
-07C0
+03C0
+ENDCHAR
+STARTCHAR uniB0AE
+ENCODING 45230
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0030
+0010
+E010
+2010
+2010
+203E
+27D0
+3810
+0000
+1FF8
+0080
+0180
+0360
+0418
+1808
 ENDCHAR
-STARTCHAR B792
-ENCODING 46994
+STARTCHAR uniB0AF
+ENCODING 45231
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 16 2 -3
 BITMAP
 0060
-FE20
-0420
-0420
-FC24
-4038
-40E0
-7F20
-33F0
-0D00
-0300
-04C0
-0830
-3010
+0020
+8020
+4020
+4020
+4078
+43A0
+7C20
+0380
+03F0
+3F00
+0100
+0380
+0660
+0810
+3000
 ENDCHAR
-STARTCHAR B796
-ENCODING 46998
+STARTCHAR uniB0B1
+ENCODING 45233
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 14 2 -1
 BITMAP
 0060
-FE20
-0420
-0420
-F820
-403C
-4FE0
+0020
+C020
+4020
+402C
+43B0
 7C20
+0000
 0020
-3FF0
-00C0
-0480
-0480
-3FF0
+0FE0
+0800
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B797
-ENCODING 46999
+STARTCHAR uniB0B3
+ENCODING 45235
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-00C0
-7E20
-0220
-0420
-FE20
-403C
-4120
-7E20
-03C0
-3FF8
-0380
-0440
-0440
-0440
-0380
+0030
+0010
+E010
+2010
+2016
+2058
+3F90
+0200
+01C0
+0FFC
+01E0
+0210
+0210
+0310
+01E0
 ENDCHAR
-STARTCHAR B798
-ENCODING 47000
+STARTCHAR uniB0B4
+ENCODING 45236
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-0310
-0090
-FC90
-0890
-0890
-0890
-7090
-40F0
-4190
-4E90
-7090
-0090
-0090
-0010
+0318
+0088
+0088
+E088
+2088
+2088
+2088
+20F8
+2088
+2F88
+3088
+0088
+0088
+0088
+0008
 ENDCHAR
-STARTCHAR B799
-ENCODING 47001
+STARTCHAR uniB0B5
+ENCODING 45237
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 16 2 -3
 BITMAP
-0060
-0320
-0120
-F920
-1120
-1920
-E1E0
-8720
-F920
-C120
-7FE0
-0020
-0020
-0020
-0020
 0020
+0610
+0110
+C110
+4110
+4110
+41F0
+4710
+7910
+0110
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B79C
-ENCODING 47004
+STARTCHAR uniB0B8
+ENCODING 45240
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
+0040
+0330
 0090
-FC90
-0890
-0890
-F890
-40F0
-4190
-4E90
-7090
-1890
-0810
-0800
-0FF8
+8090
+4090
+4090
+4090
+47F0
+7890
+0090
+0C90
+0490
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B7A0
-ENCODING 47008
+STARTCHAR uniB0BC
+ENCODING 45244
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 15 1 -2
 BITMAP
-0040
-0220
-0120
-F920
-1120
-1120
-E1E0
-8720
-F920
-FFC0
-0040
-0040
-1FC0
-1000
-1FE0
+0018
+0188
+E088
+2088
+2088
+20F8
+2788
+3888
+0080
+0FF0
+0010
+0FF0
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B7A8
-ENCODING 47016
+STARTCHAR uniB0C4
+ENCODING 45252
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 15 2 -2
 BITMAP
 0060
-0320
-0120
-F920
-0920
-0920
-F1E0
-8720
-F920
-C120
-1FE0
-0840
-0840
-0840
-0FE0
-0800
+0310
+0110
+C110
+4110
+4110
+41F0
+4710
+7910
+0110
+1FF0
+0830
+0820
+0820
+0FC0
 ENDCHAR
-STARTCHAR B7A9
-ENCODING 47017
+STARTCHAR uniB0C5
+ENCODING 45253
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 1 -2
 BITMAP
-0030
-0190
-FC90
-0490
-0890
-FC90
-40F0
-4190
-7E90
-7C30
-0410
-07F0
-0410
-07F0
-0410
+0318
+0088
+E088
+2088
+2088
+20F8
+2188
+3E88
+0E08
+0208
+03F8
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR B7AB
-ENCODING 47019
+STARTCHAR uniB0C7
+ENCODING 45255
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0220
-0120
-F120
-1120
-1120
-E1E0
-8120
-8720
-FF20
-0200
-0700
-0C80
-1860
-2000
+0030
+0190
+0090
+C090
+4090
+4090
+41F0
+4E90
+7090
+0310
+0180
+0180
+0240
+0C30
+1018
 ENDCHAR
-STARTCHAR B7AC
-ENCODING 47020
+STARTCHAR uniB0C8
+ENCODING 45256
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0060
-0130
-0090
+0190
 0090
-7890
-0890
-F8F0
+C090
 4090
-4390
-4CF0
-3420
-0C20
-0E60
-1298
-6108
+4090
+41F0
+4690
+7890
+08A0
+0420
+0C60
+1250
+2188
+4108
 ENDCHAR
-STARTCHAR B7AD
-ENCODING 47021
+STARTCHAR uniB0C9
+ENCODING 45257
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-0320
-0120
-F120
-1120
-1120
-E1E0
-8320
-BD20
-E120
-06C0
-0820
-0820
-0C60
-07C0
+0020
+0318
+0088
+E088
+2088
+2088
+20F8
+2188
+2E88
+3048
+01A0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR B7B4
-ENCODING 47028
+STARTCHAR uniB0D0
+ENCODING 45264
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
@@ -97982,167 +100883,210 @@
 00C0
 0020
 0020
-FE20
-0420
-043C
-FC20
+8020
 4020
-4060
-43AC
-7C30
+403C
+4020
+4020
+40E0
+4F2C
+7030
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR B7B5
-ENCODING 47029
+STARTCHAR uniB0D1
+ENCODING 45265
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 15 2 -2
 BITMAP
 0060
 0020
-FE20
-022C
-0230
-FE20
-4060
-43BC
-7C20
-0000
-3FE0
-1020
+0020
+C020
+4038
+4020
+47E0
+783C
+0020
+01E0
+3E20
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR B7B8
-ENCODING 47032
+STARTCHAR uniB0D4
+ENCODING 45268
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-FE20
-0220
-022C
-FE30
+0020
+C020
+403C
 4020
 4020
-43E4
-7C38
-0020
-1820
+43E0
+7C2C
+0030
+1020
+0800
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR B7C7
-ENCODING 47047
+STARTCHAR uniB0D8
+ENCODING 45272
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-FE20
-042C
-0430
-7E20
+E020
+202C
+2030
+2060
+27A4
+3838
+0000
+1FE0
+0020
+0040
+0FE0
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniB0E0
+ENCODING 45280
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+0020
+C020
+403C
 4020
-43FC
-7C20
-0180
-0100
-0180
-0260
-0410
-1808
+43E0
+7C3C
+0020
+0FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR B7C9
-ENCODING 47049
+STARTCHAR uniB0E5
+ENCODING 45285
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-00C0
 0040
-FE40
-0448
-0470
-F840
-4040
-4378
-7C40
-0100
-0680
-0840
-0840
-0CC0
-0780
+0020
+0020
+C020
+403C
+4020
+40A0
+7F3C
+0020
+00A0
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR B7EC
-ENCODING 47084
+STARTCHAR uniB108
+ENCODING 45320
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0030
-0010
-0010
-FE10
-0410
-0410
-FCF0
-4010
-4010
-4010
-4210
-7C10
-0010
-0010
-0010
+0018
+0008
+0008
+E008
+2008
+21F8
+2008
+2008
+2008
+2188
+3E08
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR B7ED
-ENCODING 47085
+STARTCHAR uniB109
+ENCODING 45321
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 16 3 -3
 BITMAP
-0030
-0010
-FE10
-0410
-0410
-FCF0
-4010
-4110
-4E10
-7000
-1FF0
-0010
-0010
-0010
-0010
+00C0
+0020
+0020
+C020
+41E0
+4020
+4020
+7F20
+2020
+0000
+7FC0
+2040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR B7F0
-ENCODING 47088
+STARTCHAR uniB10B
+ENCODING 45323
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 1 -2
 BITMAP
-0030
+0018
+0008
+E008
+21F8
+2008
+2008
+2388
+3C08
+0020
+7E10
+0210
+0230
+0268
+0244
+0284
+ENDCHAR
+STARTCHAR uniB10C
+ENCODING 45324
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
+BITMAP
+0060
 0010
-FE10
-0410
-0410
-FDF0
+0010
+C010
+43F0
 4010
 4010
-4210
+4310
 7C10
 0010
 1810
@@ -98150,199 +101094,243 @@
 0800
 0FF8
 ENDCHAR
-STARTCHAR B7F4
-ENCODING 47092
+STARTCHAR uniB110
+ENCODING 45328
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 3 -1
+BBX 14 15 1 -2
 BITMAP
-0060
-0020
-FE20
-0420
-FDE0
-4020
-4020
-4620
-7800
-3FE0
-0040
-1FE0
-1000
-0FF0
+0010
+0008
+E008
+20F8
+2008
+2008
+2308
+3C08
+0008
+07F8
+0010
+0FF8
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B7FC
-ENCODING 47100
+STARTCHAR uniB112
+ENCODING 45330
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
-0010
-FE10
-0410
-05F0
-FC10
+0060
+0030
+8010
+41F0
 4010
 4010
-4E10
-7000
-0FE0
-0820
-0820
-0FE0
-0800
+4210
+7C10
+0000
+3CF0
+0490
+7C90
+2090
+22F0
+3C80
 ENDCHAR
-STARTCHAR B7FD
-ENCODING 47101
+STARTCHAR uniB113
+ENCODING 45331
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
+0020
 0010
-FE10
-0410
-0410
-FDF0
+C010
+41F0
 4010
-4110
+4010
 5E10
-2070
-0830
-0FE0
-0820
-0820
-0FE0
-0820
+2000
+0310
+7D10
+05F0
+6D10
+3110
+23F0
+3D10
 ENDCHAR
-STARTCHAR B7FF
-ENCODING 47103
+STARTCHAR uniB118
+ENCODING 45336
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 13 15 1 -2
 BITMAP
 0030
-0010
-FE10
-0410
-0410
-FCF0
-4010
-4010
-4210
-7D10
-0080
-0180
-0340
-0430
-0818
-1000
+0008
+E008
+2008
+21F8
+2008
+2048
+3F88
+0008
+07F8
+0208
+0208
+0210
+03F8
+0200
 ENDCHAR
-STARTCHAR B800
-ENCODING 47104
+STARTCHAR uniB119
+ENCODING 45337
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 16 1 -3
 BITMAP
-0070
-0010
-FE10
-0410
-0410
-F8F0
-4010
-4210
-7C10
-0020
-0C20
-0860
-1650
-2288
-4108
+0030
+0008
+E008
+2008
+20F8
+2008
+2048
+2788
+3808
+0618
+0210
+03F0
+0210
+0210
+03F0
+0210
 ENDCHAR
-STARTCHAR B801
-ENCODING 47105
+STARTCHAR uniB11B
+ENCODING 45339
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 1 -2
 BITMAP
-0060
+0030
+0008
+E008
+2008
+20F8
+2008
+2048
+2788
+3808
+0088
+00C8
+01C0
+0330
+0418
+1804
+ENDCHAR
+STARTCHAR uniB11C
+ENCODING 45340
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
 0010
-FE10
-0410
-0410
-FCF0
-4010
-4010
-4C10
-7180
-0640
-0420
-0420
-0660
-03C0
+0008
+E008
+21F8
+2008
+2008
+2088
+3F08
+0000
+0610
+0210
+0630
+0D28
+1044
+2080
 ENDCHAR
-STARTCHAR B807
-ENCODING 47111
+STARTCHAR uniB11D
+ENCODING 45341
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 15 1 -2
 BITMAP
 0030
-FE10
+0008
+E008
+2008
+21F8
+2008
+2088
+3F08
+0008
+0048
+01A0
 0210
-0410
-FEF0
-4010
-4210
-7C10
-03C0
-3FF8
-0100
-06C0
-0420
-0640
-03C0
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR B808
-ENCODING 47112
+STARTCHAR uniB123
+ENCODING 45347
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 15 1 -2
 BITMAP
-0060
+0018
+0008
+E008
+20F8
+2008
+2008
+2F08
+1000
+01C0
+1FBC
+00C0
+0320
+0210
 0220
-0120
-3920
-D120
-1120
-1120
-EF20
-8120
-8520
-9920
-E120
-0120
-0120
-0020
+01E0
 ENDCHAR
-STARTCHAR B809
-ENCODING 47113
+STARTCHAR uniB124
+ENCODING 45348
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0610
+0110
+0110
+C110
+4110
+4F10
+4110
+4110
+4510
+7910
+0110
+0110
+0110
+0010
+ENDCHAR
+STARTCHAR uniB125
+ENCODING 45349
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0070
-0310
+0030
+0190
 0090
-7890
-0890
-9F90
-6090
+C090
+4F90
 4090
-7890
-0080
+4090
+7C90
+0090
+0000
 1FF0
 0010
 0010
@@ -98350,66 +101338,66 @@
 0010
 0010
 ENDCHAR
-STARTCHAR B80C
-ENCODING 47116
+STARTCHAR uniB128
+ENCODING 45352
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0030
-0310
+0110
 0090
-F890
-0890
-0890
-FB90
+C090
 4090
-4490
+4790
+4090
+4090
 7890
 0090
-0800
-0800
-0800
-0FF8
+0890
+0400
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B810
-ENCODING 47120
+STARTCHAR uniB12C
+ENCODING 45356
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0190
+0310
 0090
-7C90
-0890
-FB90
+C090
+4B90
+4490
 4090
-4290
-7C80
-0FF0
-0010
+5C90
+2090
+1FE0
+0020
+0020
+1FE0
+0800
 0FF0
-0400
-0400
-07F8
 ENDCHAR
-STARTCHAR B818
-ENCODING 47128
+STARTCHAR uniB134
+ENCODING 45364
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0190
+0110
 0090
-7890
-0890
-DF90
-6090
+C090
 4090
-7890
-0080
+4390
+4090
+4890
+3090
+0000
 0FF0
 0410
 0420
@@ -98417,22 +101405,21 @@
 07F0
 0400
 ENDCHAR
-STARTCHAR B819
-ENCODING 47129
+STARTCHAR uniB135
+ENCODING 45365
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -3
 BITMAP
 0030
-0310
 0090
-7890
-0890
-9F90
-6090
+C090
+4090
+4F90
 4090
-7880
-0810
+4C90
+7090
+0830
 0410
 07F0
 0410
@@ -98440,878 +101427,918 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR B81B
-ENCODING 47131
+STARTCHAR uniB137
+ENCODING 45367
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
+BITMAP
+0030
+0110
+0090
+0090
+C090
+4790
+4090
+4290
+7C90
+0310
+0190
+0180
+0240
+0430
+1818
+ENDCHAR
+STARTCHAR uniB138
+ENCODING 45368
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
+0030
+0110
+0090
+C090
+4090
+4390
+4090
+5C90
+6090
 0060
-0220
-0120
-F920
-1120
-1120
-E720
-8120
-8920
-F220
-0100
-0300
-0480
-0860
-3010
+0420
+0C60
+0A50
+1288
+6308
 ENDCHAR
-STARTCHAR B81D
-ENCODING 47133
+STARTCHAR uniB139
+ENCODING 45369
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0190
+0110
 0090
-7890
-0890
-9F90
+C090
+4090
+4390
+4090
+5C90
 6090
-4290
-7C90
-0010
-03C0
+0110
+02C0
 0420
 0420
 0660
 03C0
 ENDCHAR
-STARTCHAR B824
-ENCODING 47140
+STARTCHAR uniB140
+ENCODING 45376
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
+0030
 0010
 0010
-FE10
-05F0
-0410
-0410
-FC10
+C030
+40D0
+4010
+4010
 41F0
 4010
-4110
-4E10
-7010
+4210
+7C10
+0010
+0010
 0010
 0010
 ENDCHAR
-STARTCHAR B825
-ENCODING 47141
+STARTCHAR uniB141
+ENCODING 45377
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 16 1 -3
 BITMAP
-0070
+0018
+0008
+E008
+2078
+2008
+2088
+23F8
+3C08
+0008
+0000
+1FF0
+0810
 0010
-FE10
-0610
-04F0
-FE10
-4010
-4110
-5EF0
-2010
-3FE0
-0020
-0020
-0020
-0020
-0020
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B828
-ENCODING 47144
+STARTCHAR uniB144
+ENCODING 45380
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
 0010
-FE10
-0410
-05F0
-FC10
+0010
+C170
+4090
 4010
-4110
-4EF0
+4010
+4FF0
 7010
 0010
+0010
 1800
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR B82C
-ENCODING 47148
+STARTCHAR uniB148
+ENCODING 45384
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 12 15 2 -2
 BITMAP
-0060
+0030
 0010
-FC10
-05F0
-FC10
+0010
+C1F0
 4010
-4110
-5EF0
-2000
+4010
+41F0
+4410
+7810
 1FE0
 0020
+0020
 1FE0
-0810
-0FF8
-ENDCHAR
-STARTCHAR B834
-ENCODING 47156
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0060
-0010
-FC10
-0410
-04F0
-DC10
-6010
-4110
-47F0
-7810
-0FE0
-0820
-0820
-0FE0
 0800
+0FF0
 ENDCHAR
-STARTCHAR B835
-ENCODING 47157
+STARTCHAR uniB150
+ENCODING 45392
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0020
+0070
 0010
-FE10
-05F0
-0410
-F810
-4310
-5FF0
-7C10
-3820
+0010
+C1F0
+4010
+4010
+4210
+7CF0
+0010
+0000
+1FE0
 0820
-0FE0
 0820
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR B837
-ENCODING 47159
+STARTCHAR uniB151
+ENCODING 45393
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
 0010
-FE10
-02F0
-0410
-8610
-79F0
+0010
+C1F0
 4010
-4210
-7F10
-0110
-0380
-0640
-0830
-3000
+4010
+41F0
+4410
+7810
+0C10
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR B838
-ENCODING 47160
+STARTCHAR uniB154
+ENCODING 45396
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-FC10
-0410
-0470
-FC10
+0010
+0010
+C0F0
+4010
 4010
 47F0
 7810
+0010
 0860
 0420
-0C60
-1A50
-2298
+0860
+1E50
+2288
 4108
 ENDCHAR
-STARTCHAR B839
-ENCODING 47161
+STARTCHAR uniB155
+ENCODING 45397
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-FE10
-0410
-05F0
-0410
-FC10
-4090
-47F0
-7810
-6080
+0060
+0010
+0010
+C1F0
+4010
+4010
+4610
+79F0
+0010
+0090
 0340
 0420
 0420
 0660
 03C0
 ENDCHAR
-STARTCHAR B840
-ENCODING 47168
+STARTCHAR uniB158
+ENCODING 45400
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0010
-0190
-0C90
-7890
-0F90
-0890
-F890
-4790
-4090
-4C90
-7090
-0090
-0090
 0010
+8010
+41F0
+4010
+4010
+41F0
+5C10
+6010
+0000
+1FF0
+0020
+01E0
+1E20
+0040
+0040
 ENDCHAR
-STARTCHAR B844
-ENCODING 47172
+STARTCHAR uniB15C
+ENCODING 45404
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 13 15 1 -2
+BITMAP
+0018
+00C8
+0048
+C048
+2048
+23C8
+2048
+27C8
+2048
+2648
+3848
+0048
+0048
+0048
+0008
+ENDCHAR
+STARTCHAR uniB160
+ENCODING 45408
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -2
 BITMAP
 0030
-0310
+0190
 0090
-FC90
-0F90
-0890
-7890
+C090
 4790
-4490
-7890
-0C90
+4090
+4790
+5890
+6090
+1C90
+0410
 0400
 0400
 07F8
 ENDCHAR
-STARTCHAR B851
-ENCODING 47185
+STARTCHAR uniB178
+ENCODING 45432
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 9 1 1
 BITMAP
-0030
-0110
-0090
-7890
-0F90
-F890
-4390
-4090
-7880
-0C20
-0420
-07E0
-0420
-0420
-07E0
-0420
+3000
+1000
+1000
+1018
+1FF8
+0100
+0100
+0100
+FFFE
 ENDCHAR
-STARTCHAR B853
-ENCODING 47187
+STARTCHAR uniB179
+ENCODING 45433
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0030
-0110
-0090
-7890
-0F90
-9890
-6790
-4090
-7890
-0290
+3000
+1000
+1010
+0FF8
 0100
-0300
-06C0
-0830
-3010
+0100
+FFFE
+0000
+0000
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B85C
-ENCODING 47196
+STARTCHAR uniB17C
+ENCODING 45436
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 13 1 -1
 BITMAP
-1FF8
-0010
-0010
-1FF0
-0800
+7000
+1000
+1000
+1010
+0FF8
+0100
+0100
+FFFE
+0000
+1800
 0800
 0800
+0FF8
+ENDCHAR
+STARTCHAR uniB180
+ENCODING 45440
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -1
+BITMAP
+3000
+1000
+1010
 0FF0
 0100
-0104
+0100
 FFFE
+0000
+1FF0
+0010
+1FF0
+0800
+0FF8
 ENDCHAR
-STARTCHAR B85D
-ENCODING 47197
+STARTCHAR uniB182
+ENCODING 45442
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-3FE0
-0020
-3FE0
+3000
 1000
 1000
-1FF0
+0FF0
 0100
-FFFC
+0100
+FFFE
 0000
-3FE0
-0020
-0020
-0020
-0020
+1EF8
+0290
+1E90
+1190
+1EF0
+0080
 ENDCHAR
-STARTCHAR B860
-ENCODING 47200
+STARTCHAR uniB188
+ENCODING 45448
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 15 15 1 -3
 BITMAP
-3FE0
-0020
-0020
-1FE0
-1000
-1FF0
-0200
-FFFC
-0000
 3000
 1000
 1000
-1FF0
+0FF0
+0100
+0100
+FFFE
+0000
+0000
+1FE0
+0820
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR B864
-ENCODING 47204
+STARTCHAR uniB189
+ENCODING 45449
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 15 1 -2
 BITMAP
-3FE0
-0020
-3FE0
-1000
-1000
-1FE0
-0200
-FFFC
-3FE0
-0020
-3FE0
+2000
 1000
 1000
+1010
 0FF0
+0100
+0100
+FFFE
+0000
+1820
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR B86C
-ENCODING 47212
+STARTCHAR uniB18B
+ENCODING 45451
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 15 2 -2
 BITMAP
-3FE0
-0020
-3FE0
+6000
 1000
 1000
-1FE0
+1030
+0FF0
+0300
 0200
-FFFC
-0000
-3FE0
-1040
-1040
-1040
-1FC0
-1000
+03FE
+FF00
+0600
+0200
+0700
+04C0
+1820
+2010
 ENDCHAR
-STARTCHAR B86D
-ENCODING 47213
+STARTCHAR uniB18D
+ENCODING 45453
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-3FE0
-0040
-3FC0
-1000
+3000
 1000
-1FC0
-0200
-FFFC
-30C0
-1040
-1FC0
-1040
-1FC0
-1040
+1010
+0FF8
+0100
+0100
+FFFE
+0000
+0100
+06C0
+0820
+0820
+0460
+0380
 ENDCHAR
-STARTCHAR B86F
-ENCODING 47215
+STARTCHAR uniB192
+ENCODING 45458
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 13 2 -1
 BITMAP
-3FE0
-0040
-3FE0
-1000
-1000
-1FC0
+6000
+2000
+2000
+1FE0
 0200
+0200
 FFFC
 0000
-0200
-0600
-0D80
-1060
-6020
+3FE0
+00C0
+0880
+0880
+7FF8
 ENDCHAR
-STARTCHAR B871
-ENCODING 47217
+STARTCHAR uniB193
+ENCODING 45459
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-3FE0
-0020
-3FE0
-1000
+3000
 1000
-1FF0
-0200
+1010
+0FF0
+0100
 FFFE
-0200
-0F80
-18C0
-1040
-18C0
-0780
+0000
+03C0
+1FF8
+0100
+06C0
+0420
+0440
+03C0
 ENDCHAR
-STARTCHAR B878
-ENCODING 47224
+STARTCHAR uniB194
+ENCODING 45460
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-00E0
-0020
-7F20
-0120
-0220
-7F20
-2020
-2024
-1FB8
-0820
-08E0
-F720
-0020
-0020
-0020
+0070
+0010
+E010
+2010
+2010
+20D0
+1F10
+021E
+0210
+0FF0
+3010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B87C
-ENCODING 47228
+STARTCHAR uniB198
+ENCODING 45464
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-0030
-0010
-3F90
-0090
-3F90
-1010
-1196
-0E18
-FFF0
-0010
-0C10
-0400
-0400
-07F8
+0060
+0020
+6020
+2020
+2120
+1E20
+042C
+04F0
+FF20
+0020
+0820
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B88D
-ENCODING 47245
+STARTCHAR uniB19C
+ENCODING 45468
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-3F90
-0090
-3F90
-1010
-119C
-0E10
-FFF0
-0050
-01E0
-0210
-0210
-0330
-01E0
+0060
+6020
+2020
+2020
+3F20
+082C
+0870
+FFA0
+0020
+1FE0
+0020
+0040
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR B8A8
-ENCODING 47272
+STARTCHAR uniB1A8
+ENCODING 45480
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
+0060
 0020
-00D0
-0050
-1E50
-7E50
-2050
-2050
-1E70
-08D0
-FF50
-0630
-0220
-0570
-08C8
-1088
+6020
+2020
+21A0
+3E20
+0438
+04E0
+FB20
+0040
+0C20
+0840
+0CE0
+1298
+6308
 ENDCHAR
-STARTCHAR B8B0
-ENCODING 47280
+STARTCHAR uniB1CC
+ENCODING 45516
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
+0060
 0010
-7F10
-0110
-0210
-7F10
+4010
 2010
 2010
-3F90
+2090
+3F10
 0410
-0450
-FF90
+0410
+05D0
+FA10
+0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR B8B4
-ENCODING 47284
+STARTCHAR uniB1D0
+ENCODING 45520
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 14 3 -1
 BITMAP
 0060
-0010
-7F10
-0110
-0210
-7F10
-2010
-2190
-1E10
-05F0
-FA10
-1810
-0800
-0800
-0FF8
+0020
+C020
+4020
+4020
+4720
+3820
+0820
+1FE0
+E020
+3020
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR B8B8
-ENCODING 47288
+STARTCHAR uniB1D4
+ENCODING 45524
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0070
+0030
 0010
-7F10
-0110
-3F10
 2010
-2390
-1C10
-FFF0
-0FF0
-0010
+2010
+2190
+1E10
+0430
+FFD0
+0000
+1FE0
+0020
+1FE0
+0800
+0800
 0FF0
-0400
-0400
-07F8
 ENDCHAR
-STARTCHAR B8C0
-ENCODING 47296
+STARTCHAR uniB1DC
+ENCODING 45532
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
+0070
 0010
-7F10
-0110
-3F10
+6010
 2010
-3F90
+2190
+3E10
 0410
-FFF0
-0000
+0470
+FF90
+0010
+1FF0
+0830
+0820
+0820
 0FF0
-0410
-0420
-07F0
-0400
+0800
 ENDCHAR
-STARTCHAR B8C1
-ENCODING 47297
+STARTCHAR uniB1DD
+ENCODING 45533
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 11 15 3 -2
 BITMAP
 0060
 0020
-FE20
-0220
-FE20
+4020
 4020
 4320
 3C20
-0BE0
-F460
-0820
-0FE0
-0820
-0820
-0FE0
 0820
+0FC0
+F000
+1040
+0840
+0FC0
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR B8C3
-ENCODING 47299
+STARTCHAR uniB1DF
+ENCODING 45535
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 2 -2
 BITMAP
+0030
 0010
-0008
-3F88
-0088
-1F88
-1008
-1008
-0F88
-FFF8
-20C8
-0040
-00C0
-0120
-0218
-0C04
-ENDCHAR
-STARTCHAR B8C5
-ENCODING 47301
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0038
-0018
-3F88
-0088
-3F88
-1008
-10C8
-0F08
-FFF8
-0008
-01E0
-0210
-0210
-0330
-01E0
+6010
+2010
+2010
+3F10
+0410
+05F0
+FA10
+0010
+0090
+0180
+0340
+0430
+1808
 ENDCHAR
-STARTCHAR B8CC
-ENCODING 47308
+STARTCHAR uniB1E8
+ENCODING 45544
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 10 1 1
 BITMAP
+3000
+1000
+1000
+1000
 1FF8
-0010
-0010
-1FF0
-0800
-0800
-0FF8
-0860
+0040
 0420
 0420
+0440
 FFFE
 ENDCHAR
-STARTCHAR B8D0
-ENCODING 47312
+STARTCHAR uniB1E9
+ENCODING 45545
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 2 -1
+BBX 14 14 2 -2
 BITMAP
+6000
+2000
+2000
+3FE0
+18C0
+0880
+FFFC
+0000
 3FE0
+1020
 0020
 0020
-1FC0
+0020
+0020
+ENDCHAR
+STARTCHAR uniB1EC
+ENCODING 45548
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -1
+BITMAP
+2000
 1000
-0FF0
-0880
-F8FE
-0700
-3000
 1000
-1020
-0FF0
+1010
+1FE0
+0440
+0440
+FFFE
+0000
+1800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B8D4
-ENCODING 47316
+STARTCHAR uniB1F0
+ENCODING 45552
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 13 1 -1
 BITMAP
-0060
-3FE0
-0040
-1FE0
+3000
 1000
-1FC0
-0880
-FFFC
-0000
-3FC0
-0040
-0040
-1FC0
 1000
-1FE0
+0FF0
+0480
+0480
+FFFE
+0000
+1FF0
+0010
+1FF0
+0800
+0FF8
 ENDCHAR
-STARTCHAR B8DD
-ENCODING 47325
+STARTCHAR uniB1F9
+ENCODING 45561
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 14 1 -2
 BITMAP
-3FE0
-0040
-1FE0
+3000
 1000
-1FC0
-0880
-FFFC
+1000
+1FF0
+0C40
+0440
+FFFE
 0000
-30C0
-1040
-1FC0
-1040
-1040
-1FC0
-1040
+1060
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR B8DF
-ENCODING 47327
+STARTCHAR uniB1FB
+ENCODING 45563
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-3FE0
-0040
-1FE0
+7000
 1000
 1000
-0FC0
+1010
+0FF0
+04C0
+04C0
 0880
 FFFC
-0000
+0400
 0200
 0600
 0D80
 1060
-6020
+6030
 ENDCHAR
-STARTCHAR B8E1
-ENCODING 47329
+STARTCHAR uniB1FD
+ENCODING 45565
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 14 1 -2
 BITMAP
-3FE0
-0020
-3FE0
+3000
 1000
 1000
-1FF0
-08C0
+0FF8
+0440
+0440
 FFFC
-0200
-0D80
-1040
-1040
-18C0
-0780
+0000
+0100
+06C0
+0820
+0820
+0460
+0380
 ENDCHAR
-STARTCHAR B8E8
-ENCODING 47336
+STARTCHAR uniB204
+ENCODING 45572
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
+6000
+1000
+1000
+1000
 1FF0
-0010
-0010
-0FE0
-0800
-0FF8
 0000
+0000
 FFFE
 0100
 0100
@@ -99319,387 +102346,365 @@
 0100
 0100
 0100
+0100
 ENDCHAR
-STARTCHAR B8E9
-ENCODING 47337
+STARTCHAR uniB205
+ENCODING 45573
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
+7000
+1000
+1000
 1FF0
-0010
-1FF0
-0800
-0800
-0FF8
 0000
+0004
 FFFE
 0100
-01F0
-0E10
-0010
-0010
-0010
-0010
+0100
+0160
+0EA0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR B8EC
-ENCODING 47340
+STARTCHAR uniB208
+ENCODING 45576
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 13 1 -1
 BITMAP
+7000
+1000
+1000
 1FF0
-0020
-1FE0
-0800
-0800
-0FF8
+0000
 0004
 FFFE
-0100
 0100
-1900
-0900
-0800
-07F8
+2100
+1100
+1100
+1100
+1FF0
 ENDCHAR
-STARTCHAR B8F0
-ENCODING 47344
+STARTCHAR uniB20B
+ENCODING 45579
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-3FE0
-0020
-3FE0
-1000
+3000
 1000
-1FE8
-03FC
-FE00
-3E00
-01E0
-0040
-3FE0
 1000
+1FF0
+0000
+0008
+FFFC
+0200
+0200
 1FE0
+1000
+1000
+1000
+0FE0
 ENDCHAR
-STARTCHAR B8F8
-ENCODING 47352
+STARTCHAR uniB20C
+ENCODING 45580
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 14 1 -2
 BITMAP
+7000
+1000
+1030
 1FF0
-0010
-1FF0
-0800
-0800
-0FF0
 0000
 FFFE
 0100
+0100
+3FF0
+0020
 1FE0
-0820
-0820
-0820
-0FE0
 0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR B8F9
-ENCODING 47353
+STARTCHAR uniB214
+ENCODING 45588
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
+7000
+1000
+1000
 1FF0
-0020
-1FE0
-0800
-0FF0
+0000
 0000
 FFFE
 0100
-1160
-0820
+0100
 0FE0
 0820
-0FE0
 0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR B8FB
-ENCODING 47355
+STARTCHAR uniB215
+ENCODING 45589
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-1FF0
-0010
-1FF0
-0800
-0FF8
+6000
+2000
+2000
+3FE0
 0000
 0000
-FFFE
-0100
-0300
-0100
-0280
-0460
-1810
+FFFC
+0200
+22C0
+1240
+1FC0
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR B8FD
-ENCODING 47357
+STARTCHAR uniB217
+ENCODING 45591
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+6000
+2000
+2060
+3FE0
+0000
+0000
+FFFC
+0200
+0200
+0200
+0200
+0580
+1860
+6000
+ENDCHAR
+STARTCHAR uniB219
+ENCODING 45593
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF0
-0010
-1FF0
+1800
 0800
-0FF0
+0800
+0FF8
 0000
-0004
+0000
 FFFE
 0100
-0300
-0CE0
+0100
+06C0
+0820
 0820
 0C60
 07C0
 ENDCHAR
-STARTCHAR B904
-ENCODING 47364
+STARTCHAR uniB220
+ENCODING 45600
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
-0018
+0038
 0008
-3F88
-0088
+6008
+2008
+2188
 3F88
-1008
-1008
-1FC8
-0068
+0008
+0048
 FF88
 04F8
 0408
 0408
 0408
+0408
 0008
 ENDCHAR
-STARTCHAR B918
-ENCODING 47384
+STARTCHAR uniB234
+ENCODING 45620
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
 0010
-7F10
-7E10
+C010
 2010
+2110
 3F10
-0010
-0090
-FF30
-08D0
-0420
-0C60
-0A60
-1298
-6108
-ENDCHAR
-STARTCHAR B920
-ENCODING 47392
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
 0090
-0050
-FC50
-0450
-FC50
-4050
-4650
-3850
-FE50
-08D0
-0950
-0850
-0850
-0010
+FF10
+08F0
+0800
+0C30
+0C20
+1A70
+22C8
+4108
 ENDCHAR
-STARTCHAR B93C
-ENCODING 47420
+STARTCHAR uniB23C
+ENCODING 45628
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
 0018
-3F88
 0088
-0108
-3F88
-1008
-1FC8
-0008
-01C8
-FE08
-0408
-0408
-0408
-0408
+0048
+0048
+2048
+2048
+2048
+2748
+1B48
+FC48
+09C8
+0848
+0848
+0048
 0008
 ENDCHAR
-STARTCHAR B93D
-ENCODING 47421
+STARTCHAR uniB258
+ENCODING 45656
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 14 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-FE20
-0420
-FE20
-4020
-7E20
-1F20
-F020
-1020
-3FE0
-0020
-0020
-0020
-0020
+0070
+0010
+E010
+2010
+2010
+2390
+1C10
+0010
+00D0
+FF10
+0410
+0410
+0410
+0410
+0410
 ENDCHAR
-STARTCHAR B940
-ENCODING 47424
+STARTCHAR uniB25C
+ENCODING 45660
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0020
-FE20
-0220
-FE20
-4020
-7E20
-1F20
-F020
-1020
-1020
-0820
-0800
-0800
-0FF8
+0030
+0010
+6010
+2010
+2110
+3F10
+0030
+FFD0
+0410
+0410
+0010
+0C00
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR B944
-ENCODING 47428
+STARTCHAR uniB260
+ENCODING 45664
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0010
-3F10
-7F10
+6010
 2010
+2110
 3F10
-0010
+00F0
 FF10
-0800
+0410
+0400
 0FF0
 0010
 0FF0
 0400
 0400
-03F8
+07F8
 ENDCHAR
-STARTCHAR B94C
-ENCODING 47436
+STARTCHAR uniB268
+ENCODING 45672
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-7F10
-0210
-7F10
+0010
+6010
 2010
+2110
 3F10
-0010
-FF90
-0810
-0800
+01F0
+FE10
+0410
+0000
 0FF0
 0410
-0420
+0410
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR B94F
-ENCODING 47439
+STARTCHAR uniB269
+ENCODING 45673
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -3
+BBX 12 16 2 -3
 BITMAP
 0030
-7F10
-0110
-7F10
+6010
 2010
+2010
 3F10
-00D0
+0010
+00F0
 FF10
-0810
-0890
-0080
-0160
-0610
-0808
-1000
-ENDCHAR
-STARTCHAR B951
-ENCODING 47441
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 14 2 -2
-BITMAP
-0030
-7F10
-0210
-7F10
-2010
-3F90
-F810
-0810
-0890
-0350
-0420
-0420
-0660
-03C0
+0410
+0830
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR B958
-ENCODING 47448
+STARTCHAR uniB274
+ENCODING 45684
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-3FE0
-0020
-0040
+6000
+2000
+2000
 3FE0
-1000
-1FE0
+0000
 0000
 FFFC
 0840
@@ -99708,1150 +102713,676 @@
 0840
 0840
 0840
+0840
 ENDCHAR
-STARTCHAR B959
-ENCODING 47449
+STARTCHAR uniB275
+ENCODING 45685
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 14 2 -2
 BITMAP
-3FC0
-0040
-3FC0
+3000
 1000
 1000
-1FE0
+1FF0
 0000
+0008
 FFF8
 0880
-2FC0
-1040
+0880
+3FC0
 0040
 0040
 0040
+0040
 ENDCHAR
-STARTCHAR B95C
-ENCODING 47452
+STARTCHAR uniB27C
+ENCODING 45692
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 13 2 -1
 BITMAP
+3000
+1000
+1000
 1FF0
-0010
-1FF0
-0800
-0800
-0FF0
 0000
-FFFE
-0420
-0420
-1C20
-0820
-0800
-0FF8
-ENDCHAR
-STARTCHAR B960
-ENCODING 47456
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-3FE0
-0020
-3FE0
-1000
-1FE0
 0000
 FFFC
-08C0
 0880
-3FE0
+3F80
 0040
-3FE0
+1FC0
 1000
-1FF0
-ENDCHAR
-STARTCHAR B968
-ENCODING 47464
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0020
 1FE0
-0800
-0FF0
-0000
-FFFE
-0460
-0040
-0FE0
-0820
-0840
-0FC0
-0800
-ENDCHAR
-STARTCHAR B969
-ENCODING 47465
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-1FF0
-0020
-0020
-0FC0
-0830
-07C0
-FFFE
-0440
-1840
-0820
-0FE0
-0820
-0820
-0FE0
-0820
 ENDCHAR
-STARTCHAR B96B
-ENCODING 47467
+STARTCHAR uniB284
+ENCODING 45700
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-3FE0
-0040
-3FE0
+7000
 1000
-1FE0
+1000
+1FF0
 0000
 FFFC
 0840
 0840
-0B40
-0200
-0500
-08E0
-3020
-ENDCHAR
-STARTCHAR B96D
-ENCODING 47469
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0010
-0FF0
-0800
-0FF8
 0000
-FFFE
-0420
-04A0
-0340
-0420
-0420
-0660
-03C0
+1FC0
+1040
+1080
+1F80
+1000
 ENDCHAR
-STARTCHAR B974
-ENCODING 47476
+STARTCHAR uniB285
+ENCODING 45701
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 11 2 0
+BBX 14 14 2 -2
 BITMAP
-7FE0
-0040
-0040
-60C0
-3F00
+6000
 2000
-20E0
-1F00
-0000
-0018
-FFE0
-ENDCHAR
-STARTCHAR B975
-ENCODING 47477
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0020
-1FE0
-0800
-0FF0
-0000
-03FE
-FF80
-0000
+2000
 3FE0
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR B978
-ENCODING 47480
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 12 1 -1
-BITMAP
-1FF0
-0010
-1FF0
-0800
-0FF8
-0000
-01FE
-FF80
-1800
-0800
-0810
-0FF8
-ENDCHAR
-STARTCHAR B97C
-ENCODING 47484
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0010
-1FF0
-0800
-0800
-0FF4
-FFFE
-0000
-0FF0
-0020
-1FF0
-0800
-0800
-07F0
-ENDCHAR
-STARTCHAR B984
-ENCODING 47492
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0010
-1FF0
-0800
-0800
-0FF8
-0000
-FFFE
-0000
-1FF0
-0820
-0820
-0FE0
-0800
-ENDCHAR
-STARTCHAR B985
-ENCODING 47493
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-1FF0
-0020
-1FE0
-0800
-0800
-0FF0
 0000
-FFFE
-1820
-0820
-0FE0
-0820
-0820
-0FE0
-0820
-ENDCHAR
-STARTCHAR B987
-ENCODING 47495
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-3FE0
-0020
-0040
-1F80
-1000
-1FE0
-0008
 FFFC
-0400
-0200
-0600
-0D80
-1060
-6000
+0880
+0880
+30C0
+1040
+1FC0
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR B989
-ENCODING 47497
+STARTCHAR uniB289
+ENCODING 45705
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF0
-0010
-1FF0
-0800
-0800
-0FF0
-FFFE
-2100
-07C0
-0C60
-0820
-0820
-0460
-03C0
-ENDCHAR
-STARTCHAR B98A
-ENCODING 47498
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-1FF0
-0020
-1FE0
-0800
-0FF0
-0000
-FFFE
-0000
-0000
-1FF8
-0100
-0300
-06C0
-0830
 3000
-ENDCHAR
-STARTCHAR B98D
-ENCODING 47501
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0020
-1FE0
-0800
-0FF0
-0000
-FFFE
-0000
+1000
+1000
+1FF8
 0000
-0FF0
-0800
-0FE0
-0800
-0FF0
-ENDCHAR
-STARTCHAR B98E
-ENCODING 47502
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0010
-0010
-1FF0
-0800
-0FF0
 0000
 FFFE
-2000
-1FF0
-0840
-0440
-0498
-1B60
-ENDCHAR
-STARTCHAR B9AC
-ENCODING 47532
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0070
-0010
-0010
-FE10
-0210
-0410
-0410
-FE10
-4010
-4050
-4390
-7C10
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR B9AD
-ENCODING 47533
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0030
-0010
-FE10
-0410
-0410
-FE10
-4050
-4790
-7810
-0000
-3FE0
-1020
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR B9B0
-ENCODING 47536
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0040
-0030
-FE10
-0410
-0410
-FE10
-4010
-4050
-4390
-7C10
-0010
-1810
-0800
-0800
-0FF8
-ENDCHAR
-STARTCHAR B9B4
-ENCODING 47540
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-8E10
-7210
-0410
-7E10
-4010
-4390
-7C00
-1FE0
-0020
-1FE0
-0800
-0800
-0FF8
-ENDCHAR
-STARTCHAR B9BC
-ENCODING 47548
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 16 3 -3
-BITMAP
-0060
-0020
-FE20
-0220
-0420
-7E20
-4060
-47A0
-7820
-0000
-3FC0
-1040
-1040
-1040
-1FC0
-1000
-ENDCHAR
-STARTCHAR B9BD
-ENCODING 47549
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -3
-BITMAP
-0060
-FE20
-0420
-0420
-FE20
-4020
-40A0
-5F20
-3060
-0820
-0FE0
-0820
-0820
-0FE0
-0820
-ENDCHAR
-STARTCHAR B9BF
-ENCODING 47551
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-FE10
-0410
-0410
-FE10
-4010
-4050
-4790
-7910
-0080
-0180
-0260
-0410
-1808
-ENDCHAR
-STARTCHAR B9C1
-ENCODING 47553
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-0060
-0020
-FE20
-0220
 0420
-FE20
-4020
-40E0
-4F20
-7120
+0920
 06C0
 0820
 0820
 0C60
-07C0
+03C0
 ENDCHAR
-STARTCHAR B9C8
-ENCODING 47560
+STARTCHAR uniB290
+ENCODING 45712
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 15 10 1 0
 BITMAP
-00C0
-0040
-0040
-0040
-FC40
-8440
-8440
-8478
-8840
-FC40
-8040
-0040
-0040
-0040
-0040
+3000
+1000
+1000
+1010
+1FF8
+0000
+0000
+0000
+0000
+FFFE
 ENDCHAR
-STARTCHAR B9C9
-ENCODING 47561
+STARTCHAR uniB291
+ENCODING 45713
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0060
-0020
-FE20
-4220
-4220
-423C
-4420
-7E20
-4000
-3FE0
-0020
-0020
-0020
-0020
-0020
+2000
+1000
+1000
+1000
+1FF0
+0000
+FFFE
+0000
+0000
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B9CC
-ENCODING 47564
+STARTCHAR uniB294
+ENCODING 45716
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 12 1 -1
 BITMAP
-0060
-0020
-0020
-FE20
-4220
-4220
-4438
-7E20
-4020
-0020
-3820
+3000
+1000
+1030
+1FF0
+0000
+0004
+FFFE
+3000
 0800
 0800
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR B9CE
-ENCODING 47566
+STARTCHAR uniB298
+ENCODING 45720
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-FE20
-4220
-422C
-4230
-7E20
-4000
-00C0
-63F0
-20E0
-2110
-2510
-3910
-00E0
+7000
+1000
+1000
+1FF0
+0000
+0000
+FFFE
+0000
+1FF0
+0010
+1FF0
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR B9CF
-ENCODING 47567
+STARTCHAR uniB299
+ENCODING 45721
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0040
-0040
-FC40
-8440
-8448
-8870
-FC40
-8040
-0000
-3FC0
-1000
+3000
 1000
 1000
-1FE0
+1FF0
+0000
+FFFE
+0000
+0000
+3EF0
+0210
+3E10
+1010
+1110
+1E10
 ENDCHAR
-STARTCHAR B9D0
-ENCODING 47568
+STARTCHAR uniB29A
+ENCODING 45722
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-00C0
-0020
-FE20
-4220
-4220
-4420
-4438
-7E20
-4020
-1FE0
-0020
-1FE0
-0800
-0800
-0FF0
+3000
+1000
+1000
+1FF0
+0000
+0008
+FFFC
+0000
+7C00
+05F0
+6D20
+3120
+2DE0
+1100
 ENDCHAR
-STARTCHAR B9D1
-ENCODING 47569
+STARTCHAR uniB2A0
+ENCODING 45728
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0040
-FC40
-8440
-8458
-8860
-FC40
-8040
+7000
+1000
+1000
+1FF0
 0000
-FBC0
-0840
-D840
-6040
-4440
-7840
+0000
+FFFE
+0000
+0000
+1FF0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR B9D2
-ENCODING 47570
+STARTCHAR uniB2A1
+ENCODING 45729
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0020
-FE20
-4220
-4224
-4238
-4420
-7E20
-4400
-3DF0
-0520
-7D20
-2120
-23F0
-3D00
+3000
+1000
+1000
+1FF0
+0000
+0000
+FFFC
+3040
+1040
+1FC0
+1040
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR B9D8
-ENCODING 47576
+STARTCHAR uniB2A3
+ENCODING 45731
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0060
-0020
-0020
-FE20
-4220
-423C
-4220
-7E20
-4020
+3000
+1000
+1000
+1000
+1FF0
 0000
-0FE0
-0820
-0840
-0840
-0FE0
-0800
+FFFC
+0000
+0200
+0200
+0700
+0CC0
+1020
+2000
 ENDCHAR
-STARTCHAR B9D9
-ENCODING 47577
+STARTCHAR uniB2A5
+ENCODING 45733
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-00E0
-0020
-FE20
-4220
-4220
-423C
-4420
-7E20
-4020
-1820
-0820
-0FE0
+3000
+1000
+1010
+1FF0
+0000
+0004
+FFFE
+2100
+07C0
+0C60
 0820
-0FE0
 0820
+0C60
+03C0
 ENDCHAR
-STARTCHAR B9DB
-ENCODING 47579
+STARTCHAR uniB2A6
+ENCODING 45734
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 3 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0040
-FC40
-8440
-8440
-8878
-FC40
-8040
-0240
-0300
-0300
-04C0
-0820
-3010
+3000
+1000
+1010
+0FE0
+0000
+0000
+FFFE
+2000
+2078
+1F80
+0100
+02C0
+0C30
+1008
 ENDCHAR
-STARTCHAR B9DD
-ENCODING 47581
+STARTCHAR uniB2AA
+ENCODING 45738
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 3 -2
+BBX 14 13 2 -1
 BITMAP
-00C0
-0040
-0040
-FC40
-8440
-847C
-8440
-FC40
-8040
-0100
-0780
-0840
-0840
-0C40
-0780
+E000
+2000
+2020
+3FE0
+0000
+0000
+FFFC
+4000
+40E0
+3FC0
+0880
+0880
+7FF0
 ENDCHAR
-STARTCHAR B9DE
-ENCODING 47582
+STARTCHAR uniB2AC
+ENCODING 45740
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-0020
-FE20
-4220
-4220
-423C
-7E20
-4020
 0030
-1FC0
-0300
-06C0
-0830
-3000
+0008
+2008
+1008
+1008
+1048
+1FC8
+0008
+0008
+00E8
+FF08
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR B9E1
-ENCODING 47585
+STARTCHAR uniB2B0
+ENCODING 45744
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 14 2 -1
 BITMAP
-0060
-0020
-FE20
-4220
-4220
-423C
-4220
-7E20
-4000
-0FE0
-0800
-0FE0
-0800
+0030
+0010
+4010
+2010
+2010
+2010
+3F90
+0010
+FFF0
+2010
+1810
 0800
-07F0
+0810
+0FF8
 ENDCHAR
-STARTCHAR B9E3
-ENCODING 47587
+STARTCHAR uniB2B4
+ENCODING 45748
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 11 15 3 -2
 BITMAP
+00C0
 0060
+C020
+4020
+4120
+7F20
 0020
-FE20
-4220
-422C
-4230
-7E20
-4000
-0380
-0010
+03E0
+FC20
 3FE0
-0180
-0640
-0440
-0780
+0020
+3FE0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR B9E4
-ENCODING 47588
+STARTCHAR uniB2C8
+ENCODING 45768
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 1 -2
 BITMAP
-0080
-0260
-0120
-0120
-F920
-8920
-8920
-8920
-89E0
-F920
-8120
-0120
-0120
-0120
-0020
+0038
+0008
+0008
+E008
+2008
+2008
+2008
+2008
+2068
+3F88
+3008
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR B9E5
-ENCODING 47589
+STARTCHAR uniB2C9
+ENCODING 45769
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 13 15 1 -2
 BITMAP
-0060
-0220
-0120
-F920
-8920
-8920
-89E0
-F920
-8120
-0120
-3FE0
-0020
-0020
-0020
-0020
-0020
+0018
+0008
+E008
+2008
+2008
+2008
+21C8
+3E08
+0000
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR B9E8
-ENCODING 47592
+STARTCHAR uniB2CC
+ENCODING 45772
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 14 1 -1
 BITMAP
-0040
-0020
-0320
-0120
-F920
-8920
-8920
-89E0
-F920
-8120
-0120
-3120
-1000
-1000
-1FF0
+0018
+0008
+C008
+2008
+2008
+2008
+2048
+2F88
+3008
+0008
+0C08
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR B9EC
-ENCODING 47596
+STARTCHAR uniB2D0
+ENCODING 45776
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 14 1 -1
 BITMAP
-0030
-0110
-0090
-FC90
-4490
-4490
-44F0
-7C90
-4090
-0FF0
+0018
+0008
+E008
+2008
+2008
+2028
+2FC8
+1008
 0010
 0FF0
-0400
-0400
+0010
 07F8
+0400
+07FC
 ENDCHAR
-STARTCHAR B9F4
-ENCODING 47604
+STARTCHAR uniB2D2
+ENCODING 45778
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 14 2 -2
 BITMAP
-0030
-0190
-0090
-FC90
-4490
-4490
-44F0
-7C90
-4090
-0090
-0FF0
-0410
-0420
-0420
-07C0
+0060
+0020
+C020
+4020
+4020
+43E0
+7C20
+7C20
+04D0
+0890
+3090
+2090
+3CF0
+0080
 ENDCHAR
-STARTCHAR B9F5
-ENCODING 47605
+STARTCHAR uniB2D8
+ENCODING 45784
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 15 2 -2
 BITMAP
-0040
-0060
-0120
-F920
-8920
-8920
-89E0
-F920
-8120
-1820
+0030
+0010
+8010
+4010
+4010
+4010
+4390
+7C10
+0000
+1FE0
 0820
-0FE0
 0820
 0820
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR B9F7
-ENCODING 47607
+STARTCHAR uniB2D9
+ENCODING 45785
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0220
-0120
-F920
-8920
-8920
-89E0
-F920
-8120
-0320
-0100
-0280
-0440
-0820
-3010
+0070
+0010
+0010
+C010
+4010
+4010
+43D0
+7C10
+0000
+1C10
+0410
+07F0
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR B9F8
-ENCODING 47608
+STARTCHAR uniB2DB
+ENCODING 45787
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0110
-0090
-FE90
-4490
-4490
-44F0
-7C90
-4090
-08F0
-0420
-0C60
-1A60
-2298
-4108
+0040
+0020
+8020
+4020
+4020
+4020
+43E0
+7C20
+0020
+0220
+0100
+0300
+0480
+1860
+2010
 ENDCHAR
-STARTCHAR B9F9
-ENCODING 47609
+STARTCHAR uniB2DD
+ENCODING 45789
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
+0010
+0010
+C010
+4010
+4010
+4090
+7F10
+0010
 0090
-0090
-FC90
-4490
-44F0
-4490
-4490
-7C10
-4080
 0360
 0410
 0410
 0630
 03E0
 ENDCHAR
-STARTCHAR B9FA
-ENCODING 47610
+STARTCHAR uniB2E2
+ENCODING 45794
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 14 2 -1
 BITMAP
 0030
-0090
-0090
-FE90
-4490
-44F0
-4490
-7C90
-4090
-0000
-3FF0
-0100
-0300
-04C0
-0830
-7000
+0010
+8010
+4010
+4010
+4010
+41F0
+7E10
+0010
+1FF0
+0060
+0440
+0640
+3FF8
 ENDCHAR
-STARTCHAR BA00
-ENCODING 47616
+STARTCHAR uniB2E4
+ENCODING 45796
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0020
-0020
-FE20
-4220
-423C
-4220
-4420
-7E20
-403C
-0020
-0020
-0020
-0020
-0020
+0070
+0010
+0010
+FF90
+2010
+2010
+2010
+201E
+2030
+23D0
+3C10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BA01
-ENCODING 47617
+STARTCHAR uniB2E5
+ENCODING 45797
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
 0060
-0020
 0020
-FE20
-4238
-4220
-4420
-7E3C
+0220
+FC20
 4020
+402C
+40B0
+5F20
+2020
 0000
 3FE0
 0020
@@ -100860,429 +103391,497 @@
 0020
 0020
 ENDCHAR
-STARTCHAR BA08
-ENCODING 47624
+STARTCHAR uniB2E6
+ENCODING 45798
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 3 -2
 BITMAP
 00C0
+0440
+FC40
+8040
+8040
+8078
+8740
+F840
+0000
+7BC0
+0840
+0840
+0840
+0840
 0040
-0040
-FC58
-8460
-8440
-8848
-FC70
-8000
-3FC0
-0040
-0040
-1FC0
-1000
-1FE0
 ENDCHAR
-STARTCHAR BA15
-ENCODING 47637
+STARTCHAR uniB2E8
+ENCODING 45800
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0060
-0020
-0020
-FE20
-423C
-4220
-4220
-7E2C
-4030
-0100
-06C0
-0820
-0820
-0C60
-07C0
-ENDCHAR
-STARTCHAR BA38
-ENCODING 47672
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
 00E0
 0020
-0020
-0020
+0220
 FE20
-8420
-87E0
-8420
-8420
-FC20
-8020
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR BA39
-ENCODING 47673
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0060
-0010
-0010
-FF10
-4210
-43F0
-4210
-7E10
-4010
-0010
-3FE0
+4020
+4024
+4038
+40A0
+4F20
+7020
 1020
-0020
-0020
-0020
-0020
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR BA3C
-ENCODING 47676
+STARTCHAR uniB2EB
+ENCODING 45803
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0070
-0010
-0010
+0060
+0030
+0110
 FF10
-4210
-43F0
-4210
-7E10
-4010
-0010
-0010
-0C00
+2010
+2010
+201E
+21D0
+3E10
+0000
+0FF0
 0400
 0400
-07F8
+0408
+07FC
 ENDCHAR
-STARTCHAR BA40
-ENCODING 47680
+STARTCHAR uniB2EC
+ENCODING 45804
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
+00C0
+0260
+FE20
+4020
+4020
+402C
+43B0
+7C20
 0020
-0010
-FF10
-4210
-43F0
-4390
-4210
-7E10
-4010
 1FE0
 0020
 1FE0
 0800
 0800
-0FF0
+07F0
 ENDCHAR
-STARTCHAR BA42
-ENCODING 47682
+STARTCHAR uniB2ED
+ENCODING 45805
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
+BITMAP
+0060
+0220
+FE20
+4020
+4024
+4078
+4FA0
+3020
+0000
+7DE0
+0420
+6C20
+3020
+2220
+3C20
+ENDCHAR
+STARTCHAR uniB2EE
+ENCODING 45806
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
+0060
 0020
-0010
-FF10
-4210
-43F0
-4390
-4210
-7E10
-4010
-3DE0
+FE20
+4020
+402C
+40F0
+4F20
+7020
+0000
+7DF0
 0520
 7D20
 2120
 23E0
 3D00
+ENDCHAR
+STARTCHAR uniB2EF
+ENCODING 45807
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 3 -3
+BITMAP
+00C0
+0040
+FC40
+8040
+8040
+8058
+87E0
+F840
+0000
+FA40
+1240
+0BC0
+7240
+4640
+7BC0
+0240
 ENDCHAR
-STARTCHAR BA48
-ENCODING 47688
+STARTCHAR uniB2F3
+ENCODING 45811
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 13 15 2 -2
 BITMAP
-00C0
+00E0
 0020
+8E20
+7020
+4020
+4078
+5FA0
+2000
+00E0
+3C18
+09E0
+30A0
+2110
+3D10
+00E0
+ENDCHAR
+STARTCHAR uniB2F4
+ENCODING 45812
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+00E0
 0020
+0220
 FE20
-8420
-87E0
-8420
-FC20
-8020
-0020
-1FE0
+4020
+403C
+4020
+43A0
+7C20
+0000
+0FE0
 0820
 0820
-0840
 0FE0
 0800
 ENDCHAR
-STARTCHAR BA49
-ENCODING 47689
+STARTCHAR uniB2F5
+ENCODING 45813
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-0020
-0010
-FF10
-4210
-43F0
-4390
-4210
-7E10
-4010
-0C10
-0410
-07F0
-0410
-07F0
-0410
+01C0
+0040
+0C40
+F040
+8040
+8078
+8140
+FE40
+0000
+30C0
+1040
+1FC0
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR BA4B
-ENCODING 47691
+STARTCHAR uniB2F7
+ENCODING 45815
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 3 -2
 BITMAP
-00E0
-0020
-0020
-FE20
-8620
-85E0
-8420
-FE20
-8020
-0620
-0320
+0100
+00C0
+0040
+F840
+8040
+8040
+80F8
+8F40
+F040
+0240
+0100
 0300
 0480
 0860
 3010
 ENDCHAR
-STARTCHAR BA4D
-ENCODING 47693
+STARTCHAR uniB2F8
+ENCODING 45816
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 15 3 -2
 BITMAP
-00E0
+00C0
+0440
+FC40
+8040
+8040
+80F0
+8F40
+7040
+0000
+10C0
+0840
+1880
+24C0
+4130
+8610
+ENDCHAR
+STARTCHAR uniB2F9
+ENCODING 45817
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
 0020
+8620
+7820
+4020
+403C
+40A0
+7F20
 0020
-FE20
-8420
-87E0
-8420
-FC20
-8020
-0120
+0100
 06C0
 0820
 0820
 0C60
-07C0
+03C0
 ENDCHAR
-STARTCHAR BA4E
-ENCODING 47694
+STARTCHAR uniB2FA
+ENCODING 45818
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 14 15 2 -2
 BITMAP
-0180
-00C0
-0040
-FC40
-8440
-87C0
-8840
-FC40
-8040
 0060
-7F80
-0200
-0500
-18C0
-2020
-4000
+0020
+FF20
+4020
+4020
+403C
+47E0
+7820
+0020
+3FF0
+0100
+0380
+0640
+0830
+3010
 ENDCHAR
-STARTCHAR BA53
-ENCODING 47699
+STARTCHAR uniB2FB
+ENCODING 45819
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 16 2 -3
 BITMAP
 0060
-0010
-FF10
-4210
-43F0
-43D0
-4210
-7E10
-4010
-03D0
-1FF8
+0020
+0020
+FE20
+4020
+403C
+43A0
+7C20
+0780
+0000
+3FF0
 0100
-06C0
-0440
-03C0
+0280
+0460
+1810
+2000
 ENDCHAR
-STARTCHAR BA54
-ENCODING 47700
+STARTCHAR uniB2FF
+ENCODING 45823
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 16 3 -3
 BITMAP
-0018
-00C8
-0048
-FE48
-2248
-2248
-23C8
-2248
-2448
-3E48
-2048
-0048
-0048
-0048
-0008
+00C0
+0040
+0840
+F040
+8040
+8040
+8170
+FE40
+0040
+0700
+7FE0
+0200
+0F80
+0880
+0880
+0700
 ENDCHAR
-STARTCHAR BA55
-ENCODING 47701
+STARTCHAR uniB300
+ENCODING 45824
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 11 15 3 -2
 BITMAP
-0060
+00C0
 0220
 0120
-F920
-8920
-8F20
-9120
-F920
+0120
+F120
 8120
-0100
-3FE0
-0020
-0020
-0020
-0020
+8120
+8120
+81E0
+8720
+F920
+0120
+0120
+0120
 0020
 ENDCHAR
-STARTCHAR BA58
-ENCODING 47704
+STARTCHAR uniB301
+ENCODING 45825
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 12 16 2 -3
 BITMAP
-0030
+0040
+0230
+0110
+FD10
+4110
+4110
+41F0
+4310
+7D10
+0110
+1FF0
+0810
+0010
 0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniB304
+ENCODING 45828
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0040
+0130
 0090
-FC90
-4490
-4490
-4790
-4490
-7C90
+8890
+7090
 4090
-1890
-0880
-0800
-0FF8
+4090
+47F0
+7890
+0090
+0C90
+0490
+0400
+0400
+03FC
 ENDCHAR
-STARTCHAR BA5C
-ENCODING 47708
+STARTCHAR uniB308
+ENCODING 45832
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0060
-01B0
+0130
 0090
-FC90
-4490
-4790
-4490
-7C90
+8C90
+7090
 4090
-0F70
+40F0
+4390
+7C90
+0FF0
+0010
 0020
 0FF0
 0400
 0400
 07F8
 ENDCHAR
-STARTCHAR BA64
-ENCODING 47716
+STARTCHAR uniB310
+ENCODING 45840
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0060
-01B0
-0090
-FC90
-4490
-4790
-4490
-4490
-7C90
-4010
-0FF0
-0410
-0420
-0420
-07C0
+0010
+0310
+FD10
+4110
+4110
+43F0
+5D10
+7110
+0110
+1FE0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR BA65
-ENCODING 47717
+STARTCHAR uniB311
+ENCODING 45841
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0130
-0090
+0030
+0190
 FC90
-4490
-4790
-4890
-7C90
 4090
-08B0
+4090
+40F0
+4190
+7E90
+0080
+0810
 0410
 07F0
 0410
+0410
 07F0
 0410
 ENDCHAR
-STARTCHAR BA67
-ENCODING 47719
+STARTCHAR uniB313
+ENCODING 45843
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
@@ -101290,1260 +103889,1193 @@
 0030
 0090
 0090
-FC90
-4490
-4790
-4490
-4890
+F890
+4090
+4090
+40F0
+4390
 7C90
-4110
-0080
+0190
 0180
-0240
-0430
-1808
+0180
+0260
+0C10
+1008
 ENDCHAR
-STARTCHAR BA68
-ENCODING 47720
+STARTCHAR uniB314
+ENCODING 45844
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0060
-01B0
+0310
 0090
 FC90
-4490
-4790
-4890
-7C90
 4090
-0060
-0420
+4090
+41F0
+5E90
+6090
+0820
 0420
-0A50
-1088
-6100
+0C20
+1A50
+2188
+4108
 ENDCHAR
-STARTCHAR BA69
-ENCODING 47721
+STARTCHAR uniB315
+ENCODING 45845
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0060
-01B0
+0190
 0090
-FC90
-4490
-4790
-4890
-7C90
+8C90
+7090
 4090
-0090
-0360
-0410
-0410
-0630
-03E0
+40F0
+4190
+4E90
+7090
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR BA70
-ENCODING 47728
+STARTCHAR uniB31C
+ENCODING 45852
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
+00E0
+0020
+0220
+FF20
+4020
+4038
+4020
+4020
+40E0
+473C
+3820
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniB354
+ENCODING 45908
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0070
 0010
-FF10
-43F0
-4210
-4210
-4210
-43F0
-7E10
+0210
+FE10
 4010
-0010
+4010
+41F0
+4010
+4010
+4090
+7F10
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR BA71
-ENCODING 47729
+STARTCHAR uniB355
+ENCODING 45909
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0010
+0070
+0210
 FE10
+4010
 43F0
-4210
-4210
-4210
-7EF0
 4010
-0010
+4010
+4610
+7810
+0000
 3FE0
 0020
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR BA74
-ENCODING 47732
+STARTCHAR uniB356
+ENCODING 45910
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0070
+0010
+CE10
+7010
+41F0
+4010
+4010
+7E10
+0010
+0000
+7CF0
+0410
+0410
+0410
+0410
+ENDCHAR
+STARTCHAR uniB358
+ENCODING 45912
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 3 -2
 BITMAP
 00E0
 0020
-0020
-FE20
-85E0
-8420
-87E0
-FC20
+0420
+F820
 8020
+83E0
+8020
+8020
+FC20
 0020
-2020
-1000
+0020
+3000
 1000
 1000
 1FF0
 ENDCHAR
-STARTCHAR BA78
-ENCODING 47736
+STARTCHAR uniB35B
+ENCODING 45915
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 14 2 -2
 BITMAP
-0020
-0010
-FE10
-43F0
-43F0
-4210
-4210
-7EF0
+0070
+0610
+F810
 4010
-1FE0
-0020
-1FE0
+41F0
+4010
+7E10
+0010
+0010
+1FF0
 0800
 0800
+0800
 0FF0
 ENDCHAR
-STARTCHAR BA83
-ENCODING 47747
+STARTCHAR uniB35C
+ENCODING 45916
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
-FF10
-43F0
-4210
-4210
-4210
-7EF0
+CE10
+7010
+41F0
 4010
-0110
-0110
-0380
-0660
-0810
-3008
-ENDCHAR
-STARTCHAR BA84
-ENCODING 47748
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
-BITMAP
-0040
+4110
+7E10
+1FE0
 0020
-FE20
-87E0
-8420
-8420
-8420
-FDE0
-8020
-00A0
-1840
-10C0
-3CC0
-4530
-8610
-ENDCHAR
-STARTCHAR BA85
-ENCODING 47749
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-00C0
-0060
 0020
-FC20
-87E0
-8420
-8660
-FDA0
-8020
-0100
-0680
-0840
-0840
-0CC0
-0780
+1FE0
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR BA87
-ENCODING 47751
+STARTCHAR uniB35E
+ENCODING 45918
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 13 15 2 -2
 BITMAP
-0040
-0020
-FE20
-87E0
-8420
-8420
-FDE0
-8020
-0F20
+0030
+0210
+FE10
+4010
+41F0
+4010
+4110
+7E10
 0000
-7FE0
-0200
-0500
-08C0
-3020
-4000
+3CF8
+0490
+6C90
+3090
+20F0
+3E80
 ENDCHAR
-STARTCHAR BA8C
-ENCODING 47756
+STARTCHAR uniB35F
+ENCODING 45919
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0190
-0050
-0050
-FE50
-47D0
-4450
-4450
-47D0
-7C50
-4050
-0050
-0050
-0050
 0010
+FE10
+4010
+41F0
+4010
+4110
+7E10
+0110
+7D10
+05F0
+6D10
+3110
+23F0
+3D10
 ENDCHAR
-STARTCHAR BAA8
-ENCODING 47784
+STARTCHAR uniB364
+ENCODING 45924
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 10 1 0
+BBX 13 15 1 -3
 BITMAP
-0FF0
-0810
-0810
-0810
+0018
+E308
+3C08
+2008
+21F8
+2008
+2188
+3E08
+0008
 0FF0
-0800
-0100
-0100
-0100
-FFFE
-ENDCHAR
-STARTCHAR BAA9
-ENCODING 47785
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-1FE0
-1020
-1040
-1040
-1FC0
-1200
-0200
-FFFC
-0000
-7FC0
-0040
-0040
-0040
-0040
-ENDCHAR
-STARTCHAR BAAB
-ENCODING 47787
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FE0
-0820
-0820
-0820
-0FE0
-0900
-FFFE
-0000
-0460
-3C20
-0460
-0450
-0488
-0500
-ENDCHAR
-STARTCHAR BAAC
-ENCODING 47788
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 12 2 -1
-BITMAP
-1FE0
-1020
-1040
-1FC0
-1200
-0200
-FFFC
-2000
-1000
-1000
-1000
-1FF0
-ENDCHAR
-STARTCHAR BAB0
-ENCODING 47792
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-3FE0
-1040
-1040
-1040
-1FC0
-0200
-FFFC
-0000
-3FE0
-0040
-3FC0
-1000
-1000
-1FE0
-ENDCHAR
-STARTCHAR BAB2
-ENCODING 47794
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0820
-0820
-0820
-0FE0
-0100
-FFFE
-0000
-3E00
-02F8
-3E90
-1090
-16F0
-0880
-ENDCHAR
-STARTCHAR BAB8
-ENCODING 47800
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-1FE0
-1020
-1040
-1040
-1FC0
-1200
-FFFC
-0000
-0000
-1FC0
-1040
-1040
-1FC0
-1000
-ENDCHAR
-STARTCHAR BAB9
-ENCODING 47801
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-1FE0
-1020
-1040
-1040
-1FC0
-1200
-FFFC
-0000
-3040
-1040
-1FC0
-1040
-1FC0
-1040
+0410
+0410
+0410
+07F0
+0400
 ENDCHAR
-STARTCHAR BABB
-ENCODING 47803
+STARTCHAR uniB365
+ENCODING 45925
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-1FE0
-1020
-1020
-1040
-1FE0
-1200
-0200
-FFFC
-4400
-0200
-0700
-0C80
-1060
-6010
+0030
+0010
+C610
+7810
+41F0
+4010
+4010
+4610
+7C30
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR BABD
-ENCODING 47805
+STARTCHAR uniB367
+ENCODING 45927
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-1FF0
-0830
-0820
-0820
-0FE0
-0900
-01FE
-FF00
-0100
-07C0
-0C60
-0820
-0C60
-07C0
+0030
+0010
+8610
+7810
+4010
+41F0
+4010
+4110
+7E10
+0110
+0190
+0180
+0240
+0C30
+1008
 ENDCHAR
-STARTCHAR BAC4
-ENCODING 47812
+STARTCHAR uniB369
+ENCODING 45929
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-7FA0
-2120
-2120
-2120
-2120
-1F3C
-0420
-04E0
-FB20
-0020
-0020
-0020
-0020
+0030
+0210
+FE10
+4010
+43F0
+4010
+4010
+4610
+7810
+0080
+0360
+0410
+0410
+0630
+01E0
 ENDCHAR
-STARTCHAR BAC8
-ENCODING 47816
+STARTCHAR uniB36B
+ENCODING 45931
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
 0020
-0020
-7F20
-2220
-2220
-3E20
-083C
-08E0
-FF20
-0020
-1820
-0800
-0800
-0FF0
-ENDCHAR
-STARTCHAR BAD8
-ENCODING 47832
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-0060
-7F20
-2220
-2220
-3E20
-283C
-09E0
 FE20
-0000
-0420
-0C60
-0A60
-1290
-6108
+4020
+43E0
+4020
+4020
+7E20
+0020
+0700
+3FE0
+0200
+0500
+18C0
+6020
 ENDCHAR
-STARTCHAR BAD9
-ENCODING 47833
+STARTCHAR uniB36E
+ENCODING 45934
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 14 1 -1
 BITMAP
-0060
+0018
+0008
+FF08
+2008
+20F8
+2008
+2088
+3F08
+0018
+1FF8
 0020
-7F20
-2120
-2220
-3F2C
-0830
-09E0
-F6A0
-03E0
 0420
-0420
-0660
-03C0
+0240
+3FFC
 ENDCHAR
-STARTCHAR BAFC
-ENCODING 47868
+STARTCHAR uniB370
+ENCODING 45936
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
+0620
+0120
+1120
+E120
+8120
+8320
+8D20
+8120
+8920
+F120
+0120
+0120
+0120
+0020
+ENDCHAR
+STARTCHAR uniB371
+ENCODING 45937
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0190
+0090
+F890
+4090
+4790
+4090
+4C90
+3090
+0090
+1FF0
 0010
 0010
-3F90
-2110
-2110
-2110
-3F10
-0410
-0410
-05F0
-FA10
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR BB00
-ENCODING 47872
+STARTCHAR uniB374
+ENCODING 45940
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0010
-3F10
-2110
-2110
-3F10
-2410
-0430
-FFD0
-0010
-0010
-1C00
+0110
+0090
+F890
+4090
+4390
+4090
+4090
+5C90
+2090
+0090
+0C00
 0400
 0400
 07F8
 ENDCHAR
-STARTCHAR BB04
-ENCODING 47876
+STARTCHAR uniB378
+ENCODING 45944
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
-3F10
-2110
-2110
-3F10
-0410
-04F0
-FB10
-0000
-0FF0
+0110
+0090
+F890
+4090
+4790
+4090
+4C90
+7090
+0080
+1FF0
 0020
+1FE0
+0800
 0FF0
-0400
-07F8
 ENDCHAR
-STARTCHAR BB0D
-ENCODING 47885
+STARTCHAR uniB380
+ENCODING 45952
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 14 2 -2
 BITMAP
 0030
-0010
-3F10
-2110
-2110
-3F10
+0090
+FC90
+4090
+4F90
+4090
+4490
+7890
+0090
+07F0
 0410
-0430
-FFD0
-0860
-0420
-07E0
 0420
-0420
-07E0
-0420
+07F0
+0400
 ENDCHAR
-STARTCHAR BB0F
-ENCODING 47887
+STARTCHAR uniB381
+ENCODING 45953
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0020
-7E20
-4220
-4220
-3C20
-0820
-0FE0
-F020
-0200
-0200
-0500
-08C0
-1020
-6000
+0030
+0110
+0090
+F890
+4090
+4790
+4090
+4C90
+7090
+0C10
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR BB11
-ENCODING 47889
+STARTCHAR uniB383
+ENCODING 45955
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-7F10
-2110
-2110
-3F10
-2410
-0470
-FB90
+0110
+0090
+F890
+4090
+4790
+4090
+4090
+7C90
+0110
 0090
+0180
 0360
 0410
-0410
-0630
-03E0
+1808
 ENDCHAR
-STARTCHAR BB18
-ENCODING 47896
+STARTCHAR uniB384
+ENCODING 45956
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 10 2 0
+BBX 13 15 2 -2
 BITMAP
-3FE0
-1020
-1020
-1020
-1FE0
-1000
-1840
-0840
+0030
+0110
+0090
+F890
+4090
+4790
+4090
+4C90
+7090
+0040
+0420
 0840
-FFFC
+1E60
+1298
+6308
 ENDCHAR
-STARTCHAR BB1C
-ENCODING 47900
+STARTCHAR uniB385
+ENCODING 45957
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 12 15 2 -2
 BITMAP
-3FE0
+0030
+0190
+0090
+F890
+4090
+4790
+4090
+4C90
+7090
+0080
+0340
+0420
+0420
+0660
+03C0
+ENDCHAR
+STARTCHAR uniB38C
+ENCODING 45964
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+0210
+FE10
+40F0
+4010
+4010
+4010
+40F0
+4090
+7F10
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniB390
+ENCODING 45968
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 3 -1
+BITMAP
+0060
+0020
+0C20
+F3E0
+8020
+8020
+83E0
+8020
+F820
+2020
 1020
-1040
-1040
-1FE0
-08C0
-0880
-FFFC
-2000
-1000
 1000
 1020
 1FF0
 ENDCHAR
-STARTCHAR BB20
-ENCODING 47904
+STARTCHAR uniB394
+ENCODING 45972
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
+0070
+0010
+CE10
+71F0
+4010
+41F0
+4110
+7E10
+1FF0
+0020
+0020
 1FE0
-1040
-1040
-1040
-1F80
-0880
-FFFC
+0800
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniB3A0
+ENCODING 45984
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0060
+0020
+0C20
+F1E0
+8020
+8020
+83E0
+F820
 0000
-3FC0
+1040
+0840
+1840
+24A0
+4510
+8210
+ENDCHAR
+STARTCHAR uniB3A1
+ENCODING 45985
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+C610
+78F0
+4010
+4010
+40F0
+4210
+7C10
 0040
-3FC0
-1000
-1000
-1FE0
+03A0
+0210
+0210
+0230
+01E0
 ENDCHAR
-STARTCHAR BB29
-ENCODING 47913
+STARTCHAR uniB3A8
+ENCODING 45992
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 11 15 3 -2
 BITMAP
-3FE0
-1060
-1040
-1040
-1FC0
-1080
-0880
-FFFC
-3040
-1040
-1FC0
-1040
-1FC0
-1040
+0060
+0620
+0120
+1120
+E120
+8F20
+8120
+8F20
+8120
+8920
+F120
+0120
+0120
+0120
+0020
 ENDCHAR
-STARTCHAR BB2B
-ENCODING 47915
+STARTCHAR uniB3AC
+ENCODING 45996
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-1FE0
-1020
-1040
-1040
-1FC0
-10C0
-0888
-FF7C
+0030
+0310
+0090
+FC90
+4790
+4090
+4190
+4290
+5C90
+6090
+0890
 0400
-0300
-0300
-04C0
-1820
-2010
+0400
+0408
+07F8
 ENDCHAR
-STARTCHAR BB34
-ENCODING 47924
+STARTCHAR uniB3C4
+ENCODING 46020
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 11 1 0
 BITMAP
-1FF0
-0810
-0820
-0820
-0FE0
-0800
-0000
-FFFE
-0100
-0100
-0100
-0100
+0010
+3FF0
+1000
+1000
+1000
+1000
+1FF8
 0100
 0100
 0100
+FFFE
 ENDCHAR
-STARTCHAR BB35
-ENCODING 47925
+STARTCHAR uniB3C5
+ENCODING 46021
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 1 -2
 BITMAP
-1FE0
-0820
-0820
-0820
-0FE0
-0800
-FFFE
+1FF0
+1000
+1000
+1000
+0FF0
 0100
 0100
-1FE0
-0020
-0020
-0020
-0020
+FFFC
+0000
+3FF0
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BB36
-ENCODING 47926
+STARTCHAR uniB3C8
+ENCODING 46024
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-7FC0
-1040
-1040
-1FC0
+3FF0
 1000
+1000
+1000
+1FE0
+0100
+0100
+FFFE
 0000
-FFFC
-0200
-0200
-7DE0
-0420
-0420
-0420
-0420
+1000
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR BB38
-ENCODING 47928
+STARTCHAR uniB3CB
+ENCODING 46027
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 2 -1
+BBX 14 15 1 -2
 BITMAP
-3FE0
-1040
-1040
-1040
+0030
+3FF0
+1000
+1000
+1020
 1FC0
-1004
-FFFE
 0100
 0100
-3100
-1100
+FFFC
+0000
+77F0
+1800
 1000
+1000
 0FF0
 ENDCHAR
-STARTCHAR BB3B
-ENCODING 47931
+STARTCHAR uniB3CC
+ENCODING 46028
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
+30F0
+1F00
+1000
+1000
 1FF0
-0820
-0820
-0820
-0FE0
-0800
-FFFE
-0100
 0100
-0FF0
-0800
+FFFE
+0000
+3FF0
+0010
+1FE0
 0800
 0800
-07F0
+0FF8
 ENDCHAR
-STARTCHAR BB3C
-ENCODING 47932
+STARTCHAR uniB3CE
+ENCODING 46030
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-3FE0
-1040
-1040
-1040
-1FC0
+3FF0
 1000
-FFFC
-0200
-3E40
-01C0
-3FC0
 1000
 1000
-1FE0
-ENDCHAR
-STARTCHAR BB3D
-ENCODING 47933
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
 1FF0
-0820
-0820
-0820
-0FE0
-0800
-FFFE
 0100
-01F0
-1E10
-2410
-1810
-1310
-1C10
+FFFE
+0000
+3E00
+06F8
+3E90
+1090
+16F0
+0880
 ENDCHAR
-STARTCHAR BB3E
-ENCODING 47934
+STARTCHAR uniB3D0
+ENCODING 46032
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-7FE0
-1040
-1040
-1040
-1FC0
+31E0
+1E00
 1000
-FFFC
+1000
+1FE0
 0200
-3DF0
-0590
-6D90
+FFFC
+0000
+3CC0
+0440
+6CC0
 30A0
-22F0
-3C00
+2D10
+3200
 ENDCHAR
-STARTCHAR BB44
-ENCODING 47940
+STARTCHAR uniB3D4
+ENCODING 46036
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 14 2 -2
 BITMAP
 1FF0
-0820
-0820
-0820
-0FE0
-0800
-FFFE
-0100
+1000
+1000
+1020
+1FC0
 0100
-1F60
-08A0
-0820
-0820
-0FE0
-0800
+FFFC
+0000
+0000
+1FC0
+1040
+1040
+1FC0
+1000
 ENDCHAR
-STARTCHAR BB45
-ENCODING 47941
+STARTCHAR uniB3D5
+ENCODING 46037
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-1FE0
-0820
-0820
-0840
-0FE0
-0804
-FFFE
+1FF0
+1000
+1000
+1010
+0FF0
 0100
-1920
-0920
-0FE0
+FFFE
+0000
+1820
 0820
+0FE0
 0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR BB47
-ENCODING 47943
+STARTCHAR uniB3D7
+ENCODING 46039
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 14 2 -2
 BITMAP
-1FE0
-0820
-0820
-0820
-0FE0
-0804
-FFFE
-0100
+3FF0
+1000
+1000
+1030
+1FC0
 0100
 0100
+FFFE
+0400
 0300
-02C0
-0C30
-1010
+0200
+0580
+0860
+3010
 ENDCHAR
-STARTCHAR BB49
-ENCODING 47945
+STARTCHAR uniB3D9
+ENCODING 46041
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-1FE0
-0820
-0820
-0820
-0FE0
-0804
-FFFE
-0100
+0FF0
+1000
+1000
+1000
+1FF0
 0100
-06C0
-0820
-0820
-0C60
-07C0
+FFFC
+0000
+0200
+0D80
+1040
+1040
+18C0
+0F80
 ENDCHAR
-STARTCHAR BB4D
-ENCODING 47949
+STARTCHAR uniB3DB
+ENCODING 46043
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -3
 BITMAP
-1FE0
-0820
-0820
-0840
-0FE0
-0804
-FFFE
-2100
-0160
-0E80
-0800
-0FE0
-0800
-0FF0
+1FF0
+1000
+1000
+1030
+0FC0
+0200
+FFFC
+0780
+0000
+7FF0
+0200
+0700
+0CC0
+1020
+2000
 ENDCHAR
-STARTCHAR BB4F
-ENCODING 47951
+STARTCHAR uniB3DD
+ENCODING 46045
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
+1FE0
+1000
+1000
+1000
 1FF0
-0820
-0820
-0FE0
-0800
-C7FE
-7F00
-0100
-03C0
-1FF8
-0100
-06C0
-0640
-03C0
+0200
+FFFC
+0000
+0000
+1FE0
+1000
+1FE0
+1000
+1FE0
 ENDCHAR
-STARTCHAR BB50
-ENCODING 47952
+STARTCHAR uniB3E0
+ENCODING 46048
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
+0060
 0010
+0110
 7F10
-2110
-2110
-2210
-3F10
 2010
-0F10
-F9F0
-0810
-0810
-0810
-0810
-0010
-ENDCHAR
-STARTCHAR BB54
-ENCODING 47956
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-7F10
-2110
-2210
-3F10
 2010
-0190
-FE10
+2010
+2190
+1E16
+0418
 04F0
+FF10
 0010
-1800
-0800
-0810
-0FF8
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BB58
-ENCODING 47960
+STARTCHAR uniB3E4
+ENCODING 46052
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 3 -2
 BITMAP
-0030
-0010
-7F10
-2110
-2210
-3F10
-2050
-FF90
-08F0
-0800
-1FF0
-0020
+00C0
+0040
+8740
+7840
+4040
+4240
+3C48
+0870
+0FC0
+F040
+3040
+1000
+1000
 1FF0
-0800
-0FF0
 ENDCHAR
-STARTCHAR BB61
-ENCODING 47969
+STARTCHAR uniB3E8
+ENCODING 46056
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -2
 BITMAP
 0030
-0010
-7F10
-2110
-2210
+0110
 3F10
-2050
-FF90
-08F0
-0830
-0410
-07F0
-0410
-0410
-07F0
-0410
+2010
+2010
+1F96
+0418
+FFF0
+0000
+0FF0
+0020
+0020
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR BB63
-ENCODING 47971
+STARTCHAR uniB3FC
+ENCODING 46076
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0060
-0030
-7F10
-2110
-2210
-3F10
-2010
-FF10
-0830
-09D0
-0190
-0100
-02C0
-0430
-1808
+0110
+0090
+DC90
+6090
+4090
+4490
+7890
+10F0
+1090
+1E90
+F090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR BB6C
-ENCODING 47980
+STARTCHAR uniB410
+ENCODING 46096
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
 0110
 0090
-FC90
-4490
-4490
-4490
 7C90
-4C90
-F090
+4090
+7E90
+10F0
 1390
-1090
-1090
-0090
-0010
+FC90
+0040
+0C20
+0C40
+0E60
+3298
+4108
 ENDCHAR
-STARTCHAR BB88
-ENCODING 48008
+STARTCHAR uniB418
+ENCODING 46104
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
+BITMAP
+00E0
+0020
+0220
+FE20
+4020
+4020
+4120
+7F20
+0820
+0820
+0FA0
+F020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniB41C
+ENCODING 46108
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
 BITMAP
 0030
-0010
+0110
 7F10
-2110
-2210
-2210
-3F10
 2010
-0F10
-F810
-0810
-0810
-0810
-0810
-0010
+2010
+2090
+3F90
+0410
+0430
+FFD0
+1810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR BB8C
-ENCODING 48012
+STARTCHAR uniB420
+ENCODING 46112
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 3 -1
+BBX 11 15 3 -2
 BITMAP
-0060
-0020
-7E20
-4220
-4420
-7E20
+0060
+0220
+FE20
 4020
-0F20
-F820
-1020
-3020
+4020
+4F20
+3820
+0BA0
+F400
+3FC0
+0040
+3FC0
 1000
 1000
-1FF0
+1FE0
 ENDCHAR
-STARTCHAR BB90
-ENCODING 48016
+STARTCHAR uniB428
+ENCODING 46120
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
@@ -102551,967 +105083,956 @@
 0030
 0010
 7F10
-2110
-2210
-3E10
-2090
-FF10
-0810
-1FF0
-0010
-0020
-1FF0
-0800
+2010
+2010
+2190
+1E10
+0410
+FFD0
+0000
 0FF0
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR BBA4
-ENCODING 48036
+STARTCHAR uniB429
+ENCODING 46121
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-3FE0
-1040
-1040
-1040
-1FC0
-1000
-0000
-FFF8
-0880
-0880
-0880
-0880
-0880
-0880
+0030
+0010
+7F90
+2010
+2010
+2190
+1E10
+0410
+FFC0
+2C30
+0410
+07F0
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR BBA8
-ENCODING 48040
+STARTCHAR uniB42B
+ENCODING 46123
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 3 -2
 BITMAP
-1FE0
-1060
-1040
-1040
-1FE0
-1000
-FFFC
-0440
-0440
-0440
-3040
-1000
-1000
-1FF0
+00E0
+0020
+7E20
+4020
+4020
+4320
+3C20
+0860
+F7A0
+0220
+0100
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR BBAC
-ENCODING 48044
+STARTCHAR uniB434
+ENCODING 46132
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 11 1 0
 BITMAP
-7FE0
-1040
-1040
-1040
-1FC0
+3FF0
 1000
-FFFC
-0880
-0880
-3FC0
-0040
-3FC0
 1000
-1FE0
+1000
+1010
+1FF8
+0000
+0C60
+0420
+0440
+FFFE
 ENDCHAR
-STARTCHAR BBB4
-ENCODING 48052
+STARTCHAR uniB450
+ENCODING 46160
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 15 1 -3
 BITMAP
-3FC0
-1040
-1040
-1040
-1FC0
+3FF0
 1000
-FFFC
-0880
-0880
-3FE0
-1040
-1040
-1040
-1FC0
 1000
+1010
+1FF0
+0000
+0004
+FFFE
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR BBB7
-ENCODING 48055
+STARTCHAR uniB451
+ENCODING 46161
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 15 1 -3
 BITMAP
-3FE0
-1040
-1040
-1040
-1FC0
+1FF0
 1000
-FFFC
-0840
-0C40
-0A40
-0B40
-0480
-1860
-6010
-ENDCHAR
-STARTCHAR BBC0
-ENCODING 48064
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 10 1 0
-BITMAP
+1000
+1000
 1FF0
-0810
-0810
-0820
-0FF0
-0800
-0000
 0000
-0000
 FFFE
+0100
+0100
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BBC4
-ENCODING 48068
+STARTCHAR uniB454
+ENCODING 46164
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 13 1 -1
 BITMAP
-3FE0
-1040
-1040
-1040
-1FC0
-1008
-FFFC
-0000
-0000
-0000
-3000
+3FF0
+1000
 1000
 1000
 1FF0
+0000
+FFFE
+0100
+0100
+0900
+0900
+0800
+07F8
 ENDCHAR
-STARTCHAR BBC8
-ENCODING 48072
+STARTCHAR uniB458
+ENCODING 46168
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0FE0
-0820
-0820
-0FE0
-0800
-0004
-FFFE
+3FE0
+1000
+1000
+1000
+1FF0
 0000
-0FE0
-0020
+FFFE
+0100
+3F00
+00E0
 1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR BBD0
-ENCODING 48080
+STARTCHAR uniB460
+ENCODING 46176
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF0
-0820
-0820
-0820
-0FE0
-0804
+1FB0
+0840
+0800
+0800
+0FF0
+0004
 FFFE
-0000
-0000
+0100
+0100
 0FE0
 0820
 0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR BBD3
-ENCODING 48083
+STARTCHAR uniB461
+ENCODING 46177
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -3
 BITMAP
+3FE0
+1000
+1000
+1000
 1FF0
-0810
-0820
-0820
-0FF0
-0800
-0004
-FFFE
+0000
+FFFC
+0200
+22C0
+1040
+1FC0
+1040
+1040
+1FC0
+1040
+ENDCHAR
+STARTCHAR uniB463
+ENCODING 46179
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0FE0
+1000
+1000
+1000
+1FF0
+0000
+FFFC
 0200
+0200
+0300
+0200
+0580
+1860
+6010
+ENDCHAR
+STARTCHAR uniB465
+ENCODING 46181
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+1FE0
+1000
+1000
+1000
+1FF0
+0000
+FFFC
 0100
-0380
-0660
-0810
-1008
+0100
+0780
+0840
+0840
+0C40
+0780
 ENDCHAR
-STARTCHAR BBF8
-ENCODING 48120
+STARTCHAR uniB46C
+ENCODING 46188
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
 0010
-FF10
-4210
-4210
-4210
-4210
-4210
-7E10
-4010
+6790
+3810
+2010
+2110
+3F10
 0010
+0110
+FE30
+08D0
+0810
+0810
+0810
 0010
+ENDCHAR
+STARTCHAR uniB480
+ENCODING 46208
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
 0010
+3F10
+2010
+2110
+3F10
+0190
+FEF0
 0010
+0060
+0420
+0C60
+0A50
+1288
+6108
 ENDCHAR
-STARTCHAR BBF9
-ENCODING 48121
+STARTCHAR uniB488
+ENCODING 46216
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-FE20
-4220
-4220
-4220
-4420
-7E20
-4000
-7FC0
-0040
-0040
-0040
-0040
-0040
+0070
+0110
+0090
+FE90
+4090
+4090
+4490
+3890
+0290
+7C90
+0F90
+0890
+0890
+0890
+0010
 ENDCHAR
-STARTCHAR BBFC
-ENCODING 48124
+STARTCHAR uniB49D
+ENCODING 46237
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-0020
-FE20
-8420
-8420
-8420
-FC20
-8020
 0020
-7020
-1000
-1000
-1020
-1FF0
+01B0
+0C90
+7090
+4090
+4E90
+3090
+FE90
+1390
+1090
+03D0
+0420
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR BBFF
-ENCODING 48127
+STARTCHAR uniB4A4
+ENCODING 46244
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -1
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
+0110
+7F10
+2010
+2010
+2110
+3F90
 0010
+00D0
 FF10
-4210
-4210
-4210
-7E10
-4000
-0020
-0FE0
-0800
-0800
-0FF0
+0410
+0410
+0410
+0410
+0010
 ENDCHAR
-STARTCHAR BC00
-ENCODING 48128
+STARTCHAR uniB4A8
+ENCODING 46248
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -1
+BBX 13 15 2 -2
 BITMAP
 0030
+0110
+3E10
+2010
+2110
+3F90
+0030
+FFD0
+0410
+0410
 0010
-FF10
-4210
-4210
-4210
-7E10
-4010
-0000
-1FF0
-0020
-1FF0
-0800
-0FF0
+0C00
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BC02
-ENCODING 48130
+STARTCHAR uniB4AC
+ENCODING 46252
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
-FF20
-4220
-4220
-4220
-7E20
-4020
+0030
+0010
+0010
+3F10
+2110
+3F10
+0030
+FFD0
+0410
+1FE0
 0020
-3DE0
-0520
-6D20
-3120
-2120
-3DE0
-0100
+0020
+1FE0
+0810
+0FF0
 ENDCHAR
-STARTCHAR BC08
-ENCODING 48136
+STARTCHAR uniB4B5
+ENCODING 46261
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 16 4 -3
+BBX 12 16 2 -3
 BITMAP
-00C0
-0040
-0040
-FC40
-8440
-8440
-8440
-FC40
-8040
-0000
-1FC0
-1040
-1080
-1080
-1FC0
-1000
+0070
+0110
+3F10
+2010
+2110
+1F10
+0010
+FFF0
+0410
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR BC09
-ENCODING 48137
+STARTCHAR uniB4B7
+ENCODING 46263
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 16 2 -3
 BITMAP
-0060
-0020
-FE20
-8220
-8620
-8620
-8420
-FE20
-8000
-1820
-0820
-0FE0
-0820
-0FE0
-0820
+0070
+0110
+3F10
+2010
+2010
+2110
+1F90
+00D0
+FF10
+0810
+0890
+0180
+0140
+0630
+0808
+1000
 ENDCHAR
-STARTCHAR BC0B
-ENCODING 48139
+STARTCHAR uniB4B9
+ENCODING 46265
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0010
-FF10
-4210
-4210
-4210
-7E10
-4010
 0110
-0080
-0180
-0240
-0430
-1808
+3F10
+2010
+2110
+3F10
+0010
+FFF0
+0410
+0490
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR BC0C
-ENCODING 48140
+STARTCHAR uniB4C0
+ENCODING 46272
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -3
 BITMAP
-0030
-0010
-FF10
-4210
-4210
-4210
-7E10
-4010
+3FF0
+1000
+1000
+1000
+1FF0
 0000
-0860
-0C20
-0C60
-1250
-2088
-4308
+0000
+FFFC
+0840
+0840
+0840
+0840
+0840
+0840
+0040
 ENDCHAR
-STARTCHAR BC0D
-ENCODING 48141
+STARTCHAR uniB4C4
+ENCODING 46276
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 15 4 -2
+BBX 15 13 1 -1
 BITMAP
-00C0
-0040
-0040
-FC40
-8440
-8440
-8440
-FC40
-8040
-0200
-1D00
-1080
-1080
-1180
-0F00
+1FF8
+0800
+0800
+0800
+0FF8
+0000
+FFFE
+0420
+0420
+1C20
+0820
+0800
+0FF8
 ENDCHAR
-STARTCHAR BC0F
-ENCODING 48143
+STARTCHAR uniB4C8
+ENCODING 46280
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -3
+BBX 14 13 2 -1
 BITMAP
-0060
-FC20
-8420
-8420
-8420
-FC20
-8020
-0700
+30E0
+1F00
+1000
+1020
+1FF0
 0000
-7FF0
-0200
-0700
+FFFC
 08C0
-3020
-C000
+2FE0
+1020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR BC11
-ENCODING 48145
+STARTCHAR uniB4D0
+ENCODING 46288
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 14 3 -1
+BBX 14 15 2 -3
 BITMAP
-0060
-0020
-FC20
-8420
-8420
-8420
-FC20
-8020
-0000
 1FE0
 1000
-1FC0
+1000
 1000
 1FE0
+C03C
+FFE0
+0840
+0800
+3FC0
+1040
+1080
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR BC14
-ENCODING 48148
+STARTCHAR uniB4D5
+ENCODING 46293
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-0620
-C220
-4220
-7E20
-4220
-423C
-4220
-7E20
-4220
-0020
-0020
-0020
-0020
+07F8
+0800
+0800
+0800
+0FF8
+0000
+FFFE
+0420
+0520
+06C0
+0820
+0820
+0C60
+03C0
 ENDCHAR
-STARTCHAR BC15
-ENCODING 48149
+STARTCHAR uniB4DC
+ENCODING 46300
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 11 2 0
 BITMAP
 0060
-0420
-C220
-4220
-7E20
-422C
-4230
-7E20
-4220
+7FE0
+2000
+2000
+2060
+3FE0
+0000
+0000
+0008
+03FC
+FE00
+ENDCHAR
+STARTCHAR uniB4DD
+ENCODING 46301
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
+BITMAP
+0020
+3FF0
+1000
+1030
+1FF0
 0000
+0000
+FFFC
+0000
 3FE0
 0020
 0020
 0020
 0020
-ENDCHAR
-STARTCHAR BC16
-ENCODING 48150
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0060
 0020
-C220
-4220
-7E20
-423C
-4220
-7E20
-4200
-03E0
-3C20
-0420
-0420
-0420
-0420
 ENDCHAR
-STARTCHAR BC17
-ENCODING 48151
+STARTCHAR uniB4E0
+ENCODING 46304
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 12 2 -1
 BITMAP
-0060
-0020
-C220
-4220
-7E20
-422C
-4230
-7E20
-4220
-00C0
-3C60
-0440
-04A0
-0498
-0508
+1FF0
+1000
+1030
+1FF0
+0000
+0000
+FFFC
+6000
+1000
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR BC18
-ENCODING 48152
+STARTCHAR uniB4E3
+ENCODING 46307
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-0620
-C220
-4220
-7E20
-423C
-4220
-7E20
-4220
-0020
-1800
+3FF0
+1000
+1000
+1000
+1FF0
+0000
+FFFE
+0000
+0000
+0FF0
 0800
 0800
-0FF0
+0800
+07F8
 ENDCHAR
-STARTCHAR BC1B
-ENCODING 48155
+STARTCHAR uniB4E4
+ENCODING 46308
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0420
-C220
-4220
-7E20
-422C
-4230
-7E20
-4220
+0FF0
+3000
+1000
+1000
+1FF0
 0000
-1FE0
-0800
+FFFE
+0000
+1FF0
+0020
+1FF0
 0800
 0800
 07F0
 ENDCHAR
-STARTCHAR BC1C
-ENCODING 48156
+STARTCHAR uniB4E6
+ENCODING 46310
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0020
-C220
-4220
-7E20
-423C
-4220
-7E20
-4200
-1FE0
-0020
-0020
+3FE0
+1000
+1000
+1000
 1FE0
-0800
-0FF0
-ENDCHAR
-STARTCHAR BC1D
-ENCODING 48157
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0060
-0020
-C220
-4220
-7E24
-4238
-4220
-7E20
-4200
-7FE0
-0420
-0420
-3820
-2220
-3C20
-ENDCHAR
-STARTCHAR BC1E
-ENCODING 48158
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-0060
-0020
-C220
-4220
-7E20
-422C
-4230
-7E20
-4220
 0000
-7FF0
-0520
-7D20
-2120
+FFFC
+0000
+0000
+3DF0
+0510
+3920
 2DE0
 1100
 ENDCHAR
-STARTCHAR BC1F
-ENCODING 48159
+STARTCHAR uniB4EC
+ENCODING 46316
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
-BITMAP
-0060
-C220
-4220
-7E20
-4224
-4238
-7E20
-4220
-7F20
-0520
-05E0
-3920
-23E0
-3D20
-ENDCHAR
-STARTCHAR BC24
-ENCODING 48164
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
 BITMAP
-0030
-0010
-E110
-2110
-3F10
-211E
-2110
-3F10
-2110
+3FF0
+1000
+1000
+1000
+1FF0
 0000
-07F0
-0410
-0420
-07F0
-0400
+FFFC
+0000
+0000
+3FC0
+1040
+1040
+1FC0
+1000
 ENDCHAR
-STARTCHAR BC25
-ENCODING 48165
+STARTCHAR uniB4ED
+ENCODING 46317
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-C220
-4220
-7E20
-423C
-4220
-7E20
-4200
-1020
+0030
+0FF0
+0800
+0810
+0FF8
+0000
+FFFE
+0000
+1820
 0820
 0FE0
 0820
-0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR BC27
-ENCODING 48167
+STARTCHAR uniB4EF
+ENCODING 46319
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
 0060
-0020
-0420
-C220
-4220
-7E20
-423C
-4220
-7E20
-4320
-0080
-0180
-0260
-0410
-1808
+3FE0
+1000
+1020
+1FF0
+0000
+0000
+FFFC
+0400
+0300
+0300
+0480
+1860
+2010
 ENDCHAR
-STARTCHAR BC29
-ENCODING 48169
+STARTCHAR uniB4F1
+ENCODING 46321
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0420
-C220
-4220
-7E20
-423C
-4220
-7E20
-4220
-0080
-0340
-0420
-0420
-0660
+0038
+1FF8
+0800
+0800
+0FF8
+0000
+0000
+FFFE
+0100
+07C0
+0C60
+0820
+0C60
 03C0
 ENDCHAR
-STARTCHAR BC2D
-ENCODING 48173
+STARTCHAR uniB4F8
+ENCODING 46328
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 12 16 2 -3
 BITMAP
 0060
-C220
-4220
-7E20
-4220
-423C
-7E20
-4220
-0FE0
-0800
-0FE0
-0800
-0FF0
+0010
+0110
+3F10
+2010
+2010
+2090
+3F90
+0010
+0010
+00F0
+FF10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BC30
-ENCODING 48176
+STARTCHAR uniB514
+ENCODING 46356
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
+0070
 0010
-0190
-8490
-4490
-4490
-7C90
-4490
-44F0
-7C90
-4490
-0090
-0090
-0090
-0090
+0010
+FF10
+4010
+4010
+4010
+4010
+4010
+4390
+7C10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BC31
-ENCODING 48177
+STARTCHAR uniB515
+ENCODING 46357
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 10 16 4 -3
 BITMAP
-0070
-0130
-0090
-C490
-4490
-7C90
-44F0
-4490
-7C90
-4090
-3FF0
-1010
-0010
-0010
+00C0
+0040
+0C40
+F040
+8040
+8040
+8140
+FE40
+0040
+0000
+FF80
+0080
+0080
+0080
+0080
+0080
+ENDCHAR
+STARTCHAR uniB518
+ENCODING 46360
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
 0010
+0610
+F810
+4010
+4010
+4010
+4190
+7E10
 0010
+1C10
+0400
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BC34
-ENCODING 48180
+STARTCHAR uniB51B
+ENCODING 46363
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-0120
-1120
-8920
-8920
-F920
-89E0
-8920
-F920
-8920
-0120
-7020
-1000
-1000
-1FF0
+0018
+0008
+0108
+FF08
+2008
+2008
+2008
+20C8
+3F08
+0010
+0FF0
+0400
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BC38
-ENCODING 48184
+STARTCHAR uniB51C
+ENCODING 46364
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-0090
-C490
-4490
-7C90
-44F0
-4490
-7C90
-4490
-1FF0
-0020
-1FE0
-0800
-0800
-0FF8
+0018
+0008
+E708
+3808
+2008
+2008
+21C8
+3E08
+0000
+0FF0
+0010
+0FF0
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR BC40
-ENCODING 48192
+STARTCHAR uniB524
+ENCODING 46372
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-0190
-0890
-C490
-4490
-7C90
-44F0
-4490
-7C90
-4490
+0010
+0210
+FE10
+4010
+4010
+4010
+4090
+7F10
+0000
 0FF0
 0410
-0410
 0420
-07F0
-0400
+0420
+07C0
 ENDCHAR
-STARTCHAR BC41
-ENCODING 48193
+STARTCHAR uniB525
+ENCODING 46373
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0020
-0010
-0890
-C490
-4490
-7C90
-44F0
-4490
-7C90
-4C10
+0030
+0210
+FE10
+4010
+4010
+4010
+4190
+7E10
+0000
+0830
 0410
 07F0
 0410
@@ -103519,96 +106040,96 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR BC43
-ENCODING 48195
+STARTCHAR uniB527
+ENCODING 46375
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 3 -2
 BITMAP
 0060
+0020
+0020
+FE20
+4020
+4020
+4020
+40A0
+7F20
 0320
-1920
-8920
-8920
-F920
-89E0
-8920
-F920
-8920
-0300
-0300
-0480
-0860
-3010
+0180
+0180
+0240
+0C30
+1010
 ENDCHAR
-STARTCHAR BC44
-ENCODING 48196
+STARTCHAR uniB528
+ENCODING 46376
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 13 15 3 -2
 BITMAP
-0030
-0190
-C490
-4490
-7C90
-4490
-44F0
-7C90
-4490
-0090
-0C60
-0C60
-0C60
-1298
-2108
-4000
+00C0
+0020
+0220
+FE20
+4020
+4020
+4020
+43E0
+3C20
+00C0
+0840
+0840
+14A0
+2310
+4208
 ENDCHAR
-STARTCHAR BC45
-ENCODING 48197
+STARTCHAR uniB529
+ENCODING 46377
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0190
-0890
-C490
-4490
-7C90
-44F0
-4490
-7C90
-4490
-03E0
-0610
-0610
+0010
+0210
+FE10
+4010
+4010
+4010
+4190
+7E10
+0040
+01A0
+0210
 0210
+0230
 01E0
 ENDCHAR
-STARTCHAR BC49
-ENCODING 48201
+STARTCHAR uniB52A
+ENCODING 46378
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-00B0
-C490
-4490
-7C90
-44F0
-4490
-7C90
-4490
-0020
-0FE0
-0800
-0FE0
-0800
-0FF0
+0030
+0010
+0210
+FE10
+4010
+4010
+4010
+4190
+7E10
+0000
+1FF0
+0100
+0380
+0470
+1810
 ENDCHAR
-STARTCHAR BC4C
-ENCODING 48204
+STARTCHAR uniB530
+ENCODING 46384
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
@@ -103616,34 +106137,34 @@
 0060
 0020
 0020
-0620
-C220
-423C
-7E20
-4220
-4220
-7E2C
-4230
+F7A0
+4420
+4420
+4420
+443C
+4460
+5FA0
+6020
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR BC4D
-ENCODING 48205
+STARTCHAR uniB531
+ENCODING 46385
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
 0060
-0420
-C220
-4220
-7E3C
-4220
-4220
-7E3C
-4220
+0020
+FFA0
+4420
+4420
+443C
+4CE0
+7720
+0020
 0000
 3FE0
 0020
@@ -103652,223 +106173,311 @@
 0020
 0020
 ENDCHAR
-STARTCHAR BC50
-ENCODING 48208
+STARTCHAR uniB534
+ENCODING 46388
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
+BITMAP
+00C0
+0040
+3B40
+CC40
+8840
+8840
+8878
+BBC0
+CC40
+0040
+2040
+1040
+1000
+1000
+0FE0
+ENDCHAR
+STARTCHAR uniB538
+ENCODING 46392
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-0420
-C220
-423C
-7E20
-4220
-4220
-7E3C
-4220
-1020
-0800
-0800
+F7A0
+4420
+4420
+443C
+5FE0
+6020
+0000
+0000
+0FE0
+0020
+0FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR BC5D
-ENCODING 48221
+STARTCHAR uniB540
+ENCODING 46400
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 16 2 -3
 BITMAP
 0060
-C220
-4220
-7E3C
-4220
-4220
-7E38
-4200
-1820
-0820
-0FE0
+0020
+FFA0
+4420
+4420
+443C
+4CE0
+7720
+0020
+0000
+1FE0
 0820
+0840
+0840
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR BC84
-ENCODING 48260
+STARTCHAR uniB541
+ENCODING 46401
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 16 2 -3
 BITMAP
 0060
-0010
-0410
-8210
-4210
-4210
-7E10
-43F0
-4210
-4210
-7E10
-4210
-0010
-0010
-0010
-0010
+0020
+9FA0
+6420
+4420
+4424
+4478
+7FA0
+0020
+0C60
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR BC85
-ENCODING 48261
+STARTCHAR uniB543
+ENCODING 46403
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 3 -2
 BITMAP
-0070
-0410
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4210
-0000
-3FE0
-0020
+00C0
+0040
+0340
+CC40
+8840
+8848
+88F0
+FF40
+0040
+0340
+0200
+0700
+0C80
+1060
+2020
+ENDCHAR
+STARTCHAR uniB544
+ENCODING 46404
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
 0020
+FFA0
+4420
+4420
+442C
+4470
+7FA0
 0020
+0860
+0420
+0420
+0A60
+1198
+2108
+ENDCHAR
+STARTCHAR uniB545
+ENCODING 46405
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
 0020
+9FA0
+6420
+4420
+442C
+4C70
+77A0
 0020
+0080
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR BC88
-ENCODING 48264
+STARTCHAR uniB54B
+ENCODING 46411
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-0070
-0010
-0610
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4210
-1010
-2810
-0800
-0800
-0FF8
+01C0
+0040
+EF40
+8840
+8848
+8870
+FBC0
+0400
+0700
+3FF0
+0100
+0EC0
+0840
+0C40
+0780
 ENDCHAR
-STARTCHAR BC8B
-ENCODING 48267
+STARTCHAR uniB54C
+ENCODING 46412
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 11 15 3 -2
 BITMAP
 0040
-0820
-8420
-8420
-FC20
-87E0
-8520
-8420
-FC20
-8020
-3FC0
-1000
-1000
-1020
-1FE0
+0220
+0120
+2520
+D920
+9120
+9120
+91E0
+9120
+FF20
+8120
+0120
+0120
+0120
+0020
 ENDCHAR
-STARTCHAR BC8C
-ENCODING 48268
+STARTCHAR uniB54D
+ENCODING 46413
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 15 3 -3
 BITMAP
-0070
-0030
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4210
-1FE0
+0060
+0120
+2520
+D920
+9120
+91E0
+9320
+FD20
+0120
+3FE0
 0020
 0020
-1FE0
-0800
-0FF8
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BC8E
-ENCODING 48270
+STARTCHAR uniB550
+ENCODING 46416
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0060
-0030
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4210
-0010
-7FF0
-0920
-3D20
-2120
-3DE0
-0100
+0020
+0110
+0090
+FE90
+4890
+4890
+4890
+48F0
+7F90
+0090
+0090
+0C90
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BC94
-ENCODING 48276
+STARTCHAR uniB554
+ENCODING 46420
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0020
+00D0
+0050
+F750
+4450
+4450
+4470
+7FD0
+0FF0
+0020
+0020
+0FF0
+0400
+0400
+07F8
+ENDCHAR
+STARTCHAR uniB55C
+ENCODING 46428
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0070
-0030
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4210
-0000
-0FE0
-0820
-0820
-0840
-0FE0
-0800
+0020
+0110
+0090
+FE90
+4890
+4890
+48F0
+5B90
+6490
+0080
+07F0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR BC95
-ENCODING 48277
+STARTCHAR uniB55D
+ENCODING 46429
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0070
-0030
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4000
-0830
+0020
+0110
+0090
+FE90
+4890
+4890
+48F0
+7F90
+0090
+0C10
 0410
 07F0
 0410
@@ -103876,333 +106485,376 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR BC97
-ENCODING 48279
+STARTCHAR uniB55F
+ENCODING 46431
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0040
-0820
-8420
-8420
-FC20
-87E0
-8420
-8420
-FC20
-8220
-0320
-0300
-0480
-0860
-3010
+0020
+0090
+0050
+F750
+4450
+4450
+4470
+4DD0
+7650
+0110
+0180
+0140
+0220
+0C10
+3008
 ENDCHAR
-STARTCHAR BC99
-ENCODING 48281
+STARTCHAR uniB560
+ENCODING 46432
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0030
-0410
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4210
+0020
+0190
 0090
-0340
-0420
+EC90
+4890
+4890
+48F0
+7F90
+0090
+0C20
 0420
-0660
-03C0
+0620
+0950
+1088
+6100
 ENDCHAR
-STARTCHAR BC9A
-ENCODING 48282
+STARTCHAR uniB561
+ENCODING 46433
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 14 2 -2
 BITMAP
-0060
-0410
-C210
-4210
-7E10
-43F0
-4210
-7E10
-4210
-0020
-1FF0
-0100
-0300
-06E0
-0830
-3000
+0110
+0090
+FE90
+4890
+4890
+48F0
+5B90
+6C90
+0010
+03C0
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR BCA0
-ENCODING 48288
+STARTCHAR uniB5A0
+ENCODING 46496
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0110
-0090
-0C90
-C490
-4490
-7C90
-4790
-4490
-7C90
-4490
-0090
-0090
-0090
+0010
+0010
+F790
+4410
+4410
+4470
+4410
+4410
+5C90
+6710
+0010
+0010
+0010
 0010
 ENDCHAR
-STARTCHAR BCA1
-ENCODING 48289
+STARTCHAR uniB5A1
+ENCODING 46497
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0110
-C490
-4490
-7C90
-4490
-4790
-7C90
-4490
-0080
-1FF0
 0010
-0010
-0010
-0010
+FF90
+4410
+44F0
+4410
+4410
+7F10
 0010
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BCA4
-ENCODING 48292
+STARTCHAR uniB5A4
+ENCODING 46500
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0190
-0890
-C490
-4490
-7C90
-4790
-4490
-7C90
-4490
-0090
-0C00
-0400
-0400
-07F8
+0060
+0020
+0020
+CE20
+8820
+89E0
+8820
+8820
+FE20
+0020
+0020
+1800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR BCA7
-ENCODING 48295
+STARTCHAR uniB5A8
+ENCODING 46504
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0020
+0030
 0010
-0090
-C490
-4490
-7C90
-4790
-4490
-7C90
-44B0
+9F10
+6410
+44F0
+4410
+4C10
+7710
 1FE0
-0800
+0020
+0020
+1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR BCA8
-ENCODING 48296
+STARTCHAR uniB5AA
+ENCODING 46506
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0190
-0090
-C490
-4490
-7F90
-4490
-7C90
-4090
-0770
+0030
 0010
-0FF0
-0400
-0400
-07F8
+FF10
+4410
+44F0
+4410
+4C10
+7710
+0000
+7C00
+05F0
+4530
+3930
+2130
+3DF0
+0100
 ENDCHAR
-STARTCHAR BCB0
-ENCODING 48304
+STARTCHAR uniB5AB
+ENCODING 46507
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0110
+0010
+BF90
+4410
+44F0
+4410
+4C10
+7710
+0000
+05B0
+3C90
+08F0
+3090
+2090
+3CF0
 0090
-C490
-4490
-7C90
-4790
-4490
-7C90
-4480
-07F0
-0410
-0420
-0420
-07F0
-0400
 ENDCHAR
-STARTCHAR BCB1
-ENCODING 48305
+STARTCHAR uniB5B0
+ENCODING 46512
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-0110
-0090
-C490
-4490
-7C90
-4790
-7C90
-4490
-0810
-0410
-07F0
-0410
-0410
-07F0
-0410
+0010
+FF10
+4410
+44F0
+4410
+4C10
+7710
+0000
+0000
+0FE0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR BCB3
-ENCODING 48307
+STARTCHAR uniB5B1
+ENCODING 46513
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0110
-0090
-C490
-4490
-7C90
-4790
-7C90
-4490
-0190
-0180
-0100
-02C0
-0C30
-1018
+0010
+9F10
+6410
+44F0
+4410
+4C10
+7710
+0000
+1C20
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR BCB4
-ENCODING 48308
+STARTCHAR uniB5B3
+ENCODING 46515
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
-0090
-C490
-4490
-7C90
-4790
-7C90
-4490
-00C0
-0420
-0C60
-0E60
-1298
-6108
+DF90
+6410
+4410
+45F0
+4410
+5D90
+6610
+0310
+0110
+0380
+0660
+0830
+3010
 ENDCHAR
-STARTCHAR BCB5
-ENCODING 48309
+STARTCHAR uniB5B4
+ENCODING 46516
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
 0060
-0010
-0190
-C490
-4490
-7C90
-4790
-7C90
-4490
-0090
-0340
-0420
-0420
-0660
-03C0
+0020
+3B20
+CC20
+8BE0
+8820
+8820
+FF20
+8020
+1040
+0840
+18C0
+24A0
+4110
+8610
 ENDCHAR
-STARTCHAR BCBC
-ENCODING 48316
+STARTCHAR uniB5B5
+ENCODING 46517
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-0610
-C210
-43F0
-7E10
-4210
-4210
-43F0
+9F90
+6410
+44F0
+4410
+4410
 7F10
-4010
-0010
-0010
 0010
+0080
+0360
+0410
+0410
+0630
+03E0
+ENDCHAR
+STARTCHAR uniB5BB
+ENCODING 46523
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
 0010
+9F10
+6410
+44F0
+4410
+4F90
+7610
+3FF0
+0100
+0380
+0440
+0440
+0440
+0380
 ENDCHAR
-STARTCHAR BCBD
-ENCODING 48317
+STARTCHAR uniB5BC
+ENCODING 46524
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+0040
+0220
+0120
+3520
+D920
+9120
+9120
+9720
+9120
+B520
+D920
+0120
+0120
+0120
+0020
+ENDCHAR
+STARTCHAR uniB5BD
+ENCODING 46525
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0070
-0410
-C210
-43F0
-7E10
-4210
-4210
-7FF0
-4010
+0030
+0110
+0090
+EE90
+4890
+4B90
+4890
+7C90
+0090
 0000
 1FF0
 0010
@@ -104211,236 +106863,238 @@
 0010
 0010
 ENDCHAR
-STARTCHAR BCC0
-ENCODING 48320
+STARTCHAR uniB5C0
+ENCODING 46528
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0060
-0010
-0610
-C210
-4210
-7FF0
-4210
-4230
-7FD0
-4010
-1010
-0810
-0800
-0800
-0FF8
+0030
+0090
+0050
+FE50
+4850
+49D0
+4850
+4950
+7E50
+0050
+0050
+0C50
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR BCC4
-ENCODING 48324
+STARTCHAR uniB5C4
+ENCODING 46532
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0610
-C210
-43F0
-7E30
-4230
-4230
-7FD0
-4010
+0090
+0050
+E750
+4450
+45D0
+4450
+7E50
+0050
+0000
+1FF0
 1FE0
-0020
-0FE0
 0800
 0800
-07F0
+0FF0
 ENDCHAR
-STARTCHAR BCCD
-ENCODING 48333
+STARTCHAR uniB5CC
+ENCODING 46540
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0210
-C110
-41F0
-7F10
-4110
-4130
-7FD0
-4010
-0830
-0410
+0110
+0090
+FC90
+4890
+4B90
+4890
+7E90
+0090
+0000
 07F0
 0410
-07F0
 0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR BCCF
-ENCODING 48335
+STARTCHAR uniB5CD
+ENCODING 46541
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 16 3 -3
 BITMAP
-0030
-0210
-C110
-41F0
-7F10
-4110
-4110
-7FF0
-4010
-0110
-0100
-0300
-06C0
-0830
-3008
+0060
+0120
+00A0
+D8A0
+90A0
+93A0
+90A0
+F8A0
+00A0
+1860
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR BCD0
-ENCODING 48336
+STARTCHAR uniB5CF
+ENCODING 46543
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0210
-C110
-41F0
-7F10
-4110
-4110
-7FF0
-4010
-0050
-0C20
-0840
-1CE0
-2298
-4308
+0060
+0120
+00A0
+D8A0
+90A0
+93A0
+90A0
+F8A0
+00A0
+06A0
+0300
+0200
+0580
+1860
+2010
 ENDCHAR
-STARTCHAR BCD1
-ENCODING 48337
+STARTCHAR uniB5D0
+ENCODING 46544
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 3 -2
 BITMAP
-00C0
-0020
-8420
-87E0
-FC20
-8420
-8420
-87E0
-FD20
-8120
-06C0
-0820
+0060
+0120
+00A0
+D8A0
+90A0
+93A0
+90A0
+F8A0
+00A0
+0040
 0820
-0440
-0380
+0860
+1460
+2498
+4108
 ENDCHAR
-STARTCHAR BCD5
-ENCODING 48341
+STARTCHAR uniB5D1
+ENCODING 46545
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0210
-C110
-41F0
-7F10
-4110
-4110
-7FF0
-4010
-0000
-0FE0
-0800
-0FE0
-0800
-0FF8
+0060
+0120
+00A0
+D8A0
+90A0
+93A0
+90A0
+F8A0
+00A0
+0100
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR BCD8
-ENCODING 48344
+STARTCHAR uniB5D8
+ENCODING 46552
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0190
-0890
-0490
-C490
-4790
-7C90
-4490
-4790
-7C90
-4490
-0090
-0090
-0090
+0060
+0010
+0010
+DF90
+6410
+44F0
+4410
+4410
+45F0
+5C90
+6710
+0010
+0010
 0010
+0010
+0010
 ENDCHAR
-STARTCHAR BCDC
-ENCODING 48348
+STARTCHAR uniB5EC
+ENCODING 46572
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 2 -2
 BITMAP
 0030
-0010
-0190
-C490
-4490
+9D90
+6610
+44F0
+4410
+4470
 7F90
-4490
-4790
-7C90
-4490
-1090
-0890
-0800
-0810
-0FF0
+0010
+0860
+0420
+0C40
+1AF0
+2118
+4208
 ENDCHAR
-STARTCHAR BCF4
-ENCODING 48372
+STARTCHAR uniB610
+ENCODING 46608
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 11 1 0
 BITMAP
-0030
-1820
-0820
-0FE0
-0820
-0820
-0FE0
-0920
+7CF8
+2080
+2080
+2080
+2280
+3CFC
+0300
 0100
 0100
+010C
 FFFE
 ENDCHAR
-STARTCHAR BCF5
-ENCODING 48373
+STARTCHAR uniB611
+ENCODING 46609
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-1830
-0820
-0FE0
-0820
-0FE0
-0920
-0100
-FFFE
+4F30
+31C0
+2100
+2100
+3CF0
+0300
+010C
+FFFC
 0000
 3FE0
 0020
@@ -104448,1797 +107102,1810 @@
 0020
 0020
 ENDCHAR
-STARTCHAR BCF6
-ENCODING 48374
+STARTCHAR uniB614
+ENCODING 46612
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 12 1 -1
 BITMAP
-1820
-0820
-0FE0
-0820
-0820
-0FE0
-0920
-FF00
-00FE
+38F8
+2080
+2080
+26F8
+3900
+0100
+FFFE
 0000
-1EF0
-0210
-0210
-0210
-0210
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR BCF8
-ENCODING 48376
+STARTCHAR uniB618
+ENCODING 46616
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-3060
-1040
-1FC0
-1040
-1040
-1FC0
-0200
+6DF0
+3100
+2100
+2500
+3FF0
 0200
 FFFC
 0000
-1000
+3FC0
+0040
+3FC0
 1000
 1000
 1FE0
 ENDCHAR
-STARTCHAR BCFC
-ENCODING 48380
+STARTCHAR uniB625
+ENCODING 46629
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-3040
-1040
-1FC0
-1040
-1FC0
-1240
-03FC
-FC0C
-0000
-3FC0
-0040
-1FC0
-1000
-1FF0
+4CF8
+3080
+2080
+2080
+3CFC
+0100
+0104
+FFFE
+0100
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR BD04
-ENCODING 48388
+STARTCHAR uniB62C
+ENCODING 46636
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 15 1 -2
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0900
-0100
-FFFE
-0000
+0030
+0010
+0010
+3390
+2210
+2210
+2610
+3DD6
+0418
+0470
+FF90
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniB634
+ENCODING 46644
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+B7A0
+4420
+4420
+77AC
+0870
+1FA0
+7FE0
+0040
+0040
 1FE0
-0820
-0820
-0840
-0FE0
 0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR BD05
-ENCODING 48389
+STARTCHAR uniB648
+ENCODING 46664
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-1030
-0820
-0FE0
-0820
-0FE0
-0920
-0100
-C1FE
-3E60
-0820
-0FE0
-0820
-0FE0
-0820
+0020
+0010
+0090
+0090
+6C90
+4890
+4890
+7690
+08F0
+0990
+FE90
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR BD07
-ENCODING 48391
+STARTCHAR uniB664
+ENCODING 46692
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 1 -2
 BITMAP
-3040
-1040
-1FC0
-1040
-1040
-1FC0
-0200
-FFFC
-0000
-0200
-0600
-0D80
-1860
+0030
+0008
+0268
+3188
+2108
+2108
+2528
+38C8
+0208
+0218
+8FE8
+7008
+0008
+0008
+0008
+ENDCHAR
+STARTCHAR uniB668
+ENCODING 46696
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
+BITMAP
+0030
+0010
+1D90
+6610
+4410
+4490
+7F10
+0430
+9FD0
 6010
+1810
+0800
+0810
+0FF8
 ENDCHAR
-STARTCHAR BD09
-ENCODING 48393
+STARTCHAR uniB69C
+ENCODING 46748
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -3
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0900
+27F8
+1880
+1080
+1080
+1EF8
+0000
+0000
+FFFE
+0100
+0100
+0100
 0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uniB69D
+ENCODING 46749
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+7DF8
+2080
+2080
+2280
+3CF8
+0000
 FFFE
 0100
-06C0
-0820
-0820
-0C60
-0380
+0100
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BD10
-ENCODING 48400
+STARTCHAR uniB6A0
+ENCODING 46752
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 13 1 -1
 BITMAP
-0030
-0110
-6090
-2090
-3F90
-2090
-2090
-3F9E
-2410
-0430
-BFD0
-6010
-0010
-0010
-0010
+02F8
+1C80
+1080
+1080
+1EFC
+0000
+FFFE
+0100
+0100
+0900
+0900
+0800
+0FF8
 ENDCHAR
-STARTCHAR BD14
-ENCODING 48404
+STARTCHAR uniB6A4
+ENCODING 46756
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0040
-0020
-6320
-2120
-3F20
-2220
-3E20
-283C
-09E0
-FE20
-0020
-1820
+3FF8
+1080
+1080
+1180
+1E78
+0004
+FFFE
+0100
+1F20
+00E0
+1FE0
 0800
 0800
-0FF8
+0FF0
 ENDCHAR
-STARTCHAR BD24
-ENCODING 48420
+STARTCHAR uniB6AB
+ENCODING 46763
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-6320
-2120
-3F20
-2120
-212C
-3F30
-2820
-08E0
-FF00
-0C60
-0840
-1CE0
-1390
-6208
+38F0
+2100
+2100
+3D10
+00E0
+87FC
+FE00
+02E0
+3E00
+07F0
+6CE0
+3110
+2710
+18E0
 ENDCHAR
-STARTCHAR BD2C
-ENCODING 48428
+STARTCHAR uniB6AC
+ENCODING 46764
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0098
-0048
-6248
-2248
-3E48
-2248
-2248
-3E78
-2848
-0FC8
-F848
-0048
-0048
-0048
-0008
+05F8
+3880
+2080
+2080
+3CF8
+0004
+FFFE
+0100
+0100
+0FE0
+0820
+0820
+0820
+0FC0
 ENDCHAR
-STARTCHAR BD40
-ENCODING 48448
+STARTCHAR uniB6B1
+ENCODING 46769
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0320
-8D20
-4520
-7D20
-4520
-79E0
-5320
-1D20
-E080
-0840
-0880
-14E0
-2130
-C210
+99F0
+6100
+4100
+4500
+79F0
+0000
+7800
+87FC
+0200
+0E00
+1980
+1040
+18C0
+0780
 ENDCHAR
-STARTCHAR BD48
-ENCODING 48456
+STARTCHAR uniB6D4
+ENCODING 46804
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
-0010
-6110
-2110
-3F10
-2110
-2110
-3F10
-2810
-0810
-0FD0
-F010
-0010
-0010
+0030
 0010
+0090
+0090
+FE90
+4890
+4890
+7E90
+0090
+0E90
+F890
+0B90
+0890
+0890
+0090
 ENDCHAR
-STARTCHAR BD49
-ENCODING 48457
+STARTCHAR uniB6F0
+ENCODING 46832
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-0018
-2188
-1088
-1F88
-1088
-1088
-1F88
-1208
-02F8
-FD08
-1FF0
-0010
-0010
+0030
 0010
+9F90
+6410
+4410
+4410
+7F90
 0010
+00D0
+FF10
+0410
+0410
+0410
+0410
 0010
 ENDCHAR
-STARTCHAR BD4C
-ENCODING 48460
+STARTCHAR uniB6F4
+ENCODING 46836
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0020
+0030
 0010
-6110
-2110
-3F10
-2110
-3F10
-2810
-08F0
+BF90
+4410
+4410
+4C90
+7310
+00D0
 FF10
-0010
-1810
-0800
-0800
-0FF8
+0810
+0810
+0C10
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BD50
-ENCODING 48464
+STARTCHAR uniB6F8
+ENCODING 46840
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-4310
-2110
-3F10
-2110
-3F10
-2810
-0B90
-F410
-0000
-1FE0
+0010
+F790
+4410
+4410
+7790
+00F0
+FF10
+0FF0
+0010
 0020
-1FE0
-0800
 0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BD58
-ENCODING 48472
+STARTCHAR uniB700
+ENCODING 46848
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 16 1 -3
 BITMAP
 0018
-20C8
-10C8
-1F88
-1088
-1088
-1F88
+0008
+3F88
 1208
-8EF8
-7108
+1208
+19C8
+0018
+FFE8
+2208
+0200
 07F8
 0208
-0210
+0208
 0210
 03F8
 0200
 ENDCHAR
-STARTCHAR BD59
-ENCODING 48473
+STARTCHAR uniB701
+ENCODING 46849
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-4310
-2110
-3F10
-2110
-2110
-3F10
+0010
+7F10
 2410
-05F0
-FE30
+2410
+3F90
+00F0
+FF10
+0410
+0C10
 0410
 07F0
 0410
 0410
 07F0
 0410
-ENDCHAR
-STARTCHAR BD64
-ENCODING 48484
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 12 2 0
-BITMAP
-0020
-3020
-1020
-1FE0
-1020
-1020
-1020
-1FE0
-10C0
-0840
-0840
-FFFC
 ENDCHAR
-STARTCHAR BD68
-ENCODING 48488
+STARTCHAR uniB705
+ENCODING 46853
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 14 1 -2
 BITMAP
-30C0
-1040
-1FC0
-1040
-1040
-1FC0
-1880
-0880
-FFFC
-2000
-1000
-1000
-1000
-1FE0
+0018
+07C8
+1A08
+1208
+17C8
+1808
+0078
+FF88
+0208
+01E0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR BD80
-ENCODING 48512
+STARTCHAR uniB728
+ENCODING 46888
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 11 1 0
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0800
+0400
+38F8
+2080
+2080
+2280
+3CF8
+0000
+0000
 0000
+0000
 FFFE
-0100
-0100
-0100
-0100
-0100
-0100
 ENDCHAR
-STARTCHAR BD81
-ENCODING 48513
+STARTCHAR uniB729
+ENCODING 46889
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0820
-0004
-FFFE
-0100
-01F0
-1E20
+7DF0
+2100
+2100
+2100
+3DF0
+0000
+07FC
+FF00
+0000
+3FE0
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR BD84
-ENCODING 48516
+STARTCHAR uniB72C
+ENCODING 46892
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 13 1 -1
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0800
-0004
+4CF8
+3080
+2080
+2080
+2CF8
+1000
+0000
 FFFE
-0100
-0100
-1900
-0900
+0000
 0800
-07F8
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR BD87
-ENCODING 48519
+STARTCHAR uniB72F
+ENCODING 46895
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 13 2 -1
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0820
-0004
-FFFE
-0100
-1F20
-08C0
-0800
-0810
-0FF0
+4F30
+31C0
+2100
+2300
+3DF8
+0000
+7800
+87F8
+0000
+1FE0
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR BD88
-ENCODING 48520
+STARTCHAR uniB730
+ENCODING 46896
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-3820
-0820
-0FE0
-0820
-0FE0
-0804
+3E18
+10E0
+1080
+11F8
+1E00
+0000
 FFFE
-0100
-1100
-0EE0
+0000
+1FF0
 0020
-0FE0
+1FE0
 0800
+0800
 0FF0
 ENDCHAR
-STARTCHAR BD89
-ENCODING 48521
+STARTCHAR uniB738
+ENCODING 46904
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-1060
-0820
-0FE0
-0820
-0820
-0FE0
-0804
+1EF8
+1080
+1080
+1680
+08F8
+0000
 FFFE
-0100
-0310
-1EF0
-2610
-1810
-1310
-1C10
-ENDCHAR
-STARTCHAR BD8A
-ENCODING 48522
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
-BITMAP
-1860
-0820
+0000
+0000
 0FE0
-0820
 0820
+0840
 0FE0
 0800
-FFFE
-0100
-0100
-3EF8
-0288
-3690
-1890
-1EF0
-0080
 ENDCHAR
-STARTCHAR BD90
-ENCODING 48528
+STARTCHAR uniB739
+ENCODING 46905
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 15 1 -3
 BITMAP
-1860
-0820
+00F8
+1C80
+1080
+1080
+12F8
+1C00
+0004
+FFFE
+1870
+0830
 0FE0
 0820
 0820
 0FE0
-0800
-FFFE
-0100
-0100
-1FE0
-0820
 0820
-0820
-0FE0
-0800
 ENDCHAR
-STARTCHAR BD91
-ENCODING 48529
+STARTCHAR uniB73B
+ENCODING 46907
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1860
-0820
-0FE0
-0820
-0FE0
-0820
+78F8
+2080
+2080
+2280
+3C88
+00F8
+0004
 FFFE
+2200
 0100
-1160
-0820
-0FE0
-0820
-0FE0
-0820
+0300
+02C0
+0C30
+1018
 ENDCHAR
-STARTCHAR BD93
-ENCODING 48531
+STARTCHAR uniB744
+ENCODING 46916
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-3060
-0820
-0FE0
-0820
-0820
-0FE0
-0804
-C7FE
-7D00
-0100
-0100
-0100
-0300
-06C0
-0830
-3010
+0030
+0010
+0010
+F710
+4410
+4410
+4C10
+7390
+0010
+00D0
+FF10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BD95
-ENCODING 48533
+STARTCHAR uniB748
+ENCODING 46920
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 14 2 -1
 BITMAP
-1860
-0820
-0FE0
-0820
-0820
-0FE0
-0820
-FFFE
-0100
-0100
-06C0
-0820
-0820
-0C60
-07C0
+0030
+0010
+0190
+6610
+4410
+4410
+5790
+2030
+FFD0
+6010
+1C10
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BD99
-ENCODING 48537
+STARTCHAR uniB74C
+ENCODING 46924
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0824
-FFFE
-0100
-1FF0
-0800
-0800
-0FE0
-0800
+0030
+0010
+F790
+4410
+4410
+7F90
+0070
+FF90
+0FF0
+0010
+0020
 0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BD9A
-ENCODING 48538
+STARTCHAR uniB754
+ENCODING 46932
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-1860
-0820
-0FE0
-0820
-0820
-0FE0
-0820
-FFFE
-0100
-0100
-1FF0
-0040
-0440
-0280
-3FF8
+0030
+0010
+F790
+4410
+4410
+7790
+0070
+FF90
+0010
+0830
+07D0
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR BD9C
-ENCODING 48540
+STARTCHAR uniB755
+ENCODING 46933
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0010
+7F10
+2410
+2410
+3B90
+0070
+FFA0
+0000
+0C20
+0420
+07E0
+0420
+0420
+07E0
+0420
+ENDCHAR
+STARTCHAR uniB760
+ENCODING 46944
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-4110
-2110
-3F10
-2110
-2110
-3F10
-2110
-0710
-F810
-08F0
-0810
-0810
-0810
 0010
+0010
+F790
+4410
+4410
+4410
+4410
+4C30
+77D0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BDA4
-ENCODING 48548
+STARTCHAR uniB764
+ENCODING 46948
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0020
+0060
+0010
+0010
+F790
+4410
+4410
+4410
+4410
+7CF0
 0310
-2110
-3F10
-2110
-2110
-3F10
-2390
-FCF0
+0810
+0410
 0400
-0FF0
-0020
-0FF0
 0400
 07F8
-ENDCHAR
-STARTCHAR BDB0
-ENCODING 48560
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 3 -3
-BITMAP
-0C60
-4420
-7C20
-4420
-4420
-7C20
-4720
-F820
-11E0
-10A0
-1840
-1840
-18C0
-2530
-4210
-8000
 ENDCHAR
-STARTCHAR BDB8
-ENCODING 48568
+STARTCHAR uniB768
+ENCODING 46952
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0090
-8250
-4250
-7E50
-4250
-4250
-7E50
-4250
-0E50
-79D0
-0850
-0850
-0850
 0010
+BF90
+4410
+4410
+4410
+4CF0
+7710
+0000
+1FE0
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR BDD4
-ENCODING 48596
+STARTCHAR uniB770
+ENCODING 46960
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0070
-0210
-E110
-2110
-3F10
-2110
-3F10
-2010
-00D0
-FF10
-0410
-0410
-0410
-0410
+0030
+0010
+97D0
+6210
+4210
+4210
+4670
+7B90
 0010
+0000
+0FF0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR BDD5
-ENCODING 48597
+STARTCHAR uniB771
+ENCODING 46961
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0310
-2110
-3F10
-2110
-3F10
-20F0
-FF10
+0010
+F3D0
+4210
+4210
+4210
+5EF0
+6310
+0010
+0C10
 0410
-0400
-3FE0
-0020
-0020
-0020
-0020
-0020
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR BDD8
-ENCODING 48600
+STARTCHAR uniB773
+ENCODING 46963
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-6110
-2110
-3F10
-2110
-2110
-3F10
-2070
-FF90
-0410
-0410
-3810
-0800
-0810
-0FF8
+0010
+9D90
+6610
+4410
+4410
+4410
+5C90
+6710
+0310
+0180
+0180
+0260
+0C10
+1008
 ENDCHAR
-STARTCHAR BDDC
-ENCODING 48604
+STARTCHAR uniB775
+ENCODING 46965
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0310
-2110
-3F10
-2110
-3F10
-2030
-FFD0
-0410
-0400
-1FF0
 0010
-1FF0
-0800
-0FF0
+F3D0
+4210
+4210
+4210
+4E70
+7190
+0010
+0080
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR BDE9
-ENCODING 48617
+STARTCHAR uniB77C
+ENCODING 46972
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0310
-2110
-3F10
-2110
-3F10
-2030
-FFD0
-0410
-0480
-0340
+00C0
+0020
+0020
+FE20
 0420
 0420
-0660
-03C0
+FE20
+402C
+4030
+4060
+43A0
+7C20
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BDF0
-ENCODING 48624
+STARTCHAR uniB77D
+ENCODING 46973
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 16 2 -3
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0800
-000E
-FFF0
-0820
-0820
-0820
-0820
-0820
-0820
+00C0
+0020
+FE20
+0220
+0220
+7E2C
+4030
+43A0
+7C20
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BDF4
-ENCODING 48628
+STARTCHAR uniB780
+ENCODING 46976
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 14 15 2 -2
 BITMAP
+00C0
+0060
+FE20
+0220
+0220
+FE20
+4024
+4038
+43A0
+7C20
+0020
 1820
-0820
-0FE0
-0820
-0FE0
 0800
-FFFC
-0440
-0440
-0440
-1840
 0800
-0810
-0FF8
+07F8
 ENDCHAR
-STARTCHAR BDF8
-ENCODING 48632
+STARTCHAR uniB784
+ENCODING 46980
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-3040
-1040
-1FC0
-1040
-1FC0
-1040
-FFBC
-0880
-3FC0
+0060
+0020
+0020
+7C20
+0420
+FC2C
+4030
+4120
+7E00
+1FE0
 0040
-3FC0
-1000
-1000
-1FF0
+0040
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR BE00
-ENCODING 48640
+STARTCHAR uniB78C
+ENCODING 46988
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 16 2 -3
 BITMAP
-1060
-0820
-0FE0
-0820
-0820
+0060
+0020
+FE20
+0420
+0420
+FC2C
+4030
+40A0
+5F20
+2000
 0FE0
 0820
-FFFE
-0420
-0020
-1FE0
 0820
-0840
-0FC0
-0800
-ENDCHAR
-STARTCHAR BE03
-ENCODING 48643
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -3
-BITMAP
-3040
-1040
-1FC0
-1040
-1FC0
-1040
-0008
-FFFC
-0840
-0E40
-0600
-0D80
-1840
-2020
-4000
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR BE05
-ENCODING 48645
+STARTCHAR uniB78D
+ENCODING 46989
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 16 2 -3
 BITMAP
-3860
+00C0
+0020
+FE20
+0420
+0420
+FC20
+403C
+40A0
+5F20
+3820
 0820
 0FE0
 0820
+0820
 0FE0
 0820
-0000
-FFFE
-04A0
-07E0
-0420
-0420
-0620
-03C0
 ENDCHAR
-STARTCHAR BE0C
-ENCODING 48652
+STARTCHAR uniB78F
+ENCODING 46991
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 11 2 1
+BBX 13 15 3 -2
 BITMAP
+00C0
 0040
-3040
-1040
-1FC0
-1040
-1040
-1040
-1FC0
-1000
-0000
-FFFC
+FE40
+0440
+0440
+FC40
+4078
+4040
+4340
+7E40
+0100
+0300
+06C0
+0830
+3010
 ENDCHAR
-STARTCHAR BE0D
-ENCODING 48653
+STARTCHAR uniB790
+ENCODING 46992
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-3040
-1040
-1FC0
-1040
-1FC0
-1040
-0000
-FFFC
-0000
-7FC0
-0040
-0040
-0040
-0040
+0060
+0020
+FE20
+0220
+0420
+FE24
+4038
+4020
+4720
+7840
+0420
+0C40
+0A60
+1198
+2108
 ENDCHAR
-STARTCHAR BE10
-ENCODING 48656
+STARTCHAR uniB791
+ENCODING 46993
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0040
-1820
-0820
-0FE0
+0060
+0020
+FE20
+0420
+0420
+FE2C
+4030
+40A0
+5F20
+6100
+06C0
 0820
 0820
-0FE0
-0800
-FFFE
-0000
-0000
-0800
-0800
-0800
-07F0
+0C60
+07C0
 ENDCHAR
-STARTCHAR BE14
-ENCODING 48660
+STARTCHAR uniB792
+ENCODING 46994
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
-BITMAP
-20C0
-1040
-1FC0
-1040
-1FC0
-1000
-0000
-FFFC
-0000
-1FC0
-0040
-3FC0
-1000
-1FF0
-ENDCHAR
-STARTCHAR BE1C
-ENCODING 48668
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
 BITMAP
-30C0
-1040
-1FC0
-1040
-1040
-1FC0
-1040
-01FC
-FE00
-0000
-3FC0
-1040
-1040
-1080
-1FC0
-1000
+0060
+FE20
+0420
+0420
+FC24
+4038
+40E0
+7F20
+33F0
+0D00
+0300
+04C0
+0830
+3010
 ENDCHAR
-STARTCHAR BE1D
-ENCODING 48669
+STARTCHAR uniB796
+ENCODING 46998
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 14 2 -2
 BITMAP
-1820
-0820
-0FE0
-0820
-0FE0
-0824
-FFFE
-2000
-1820
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0060
+FE20
+0420
+0420
+F820
+403C
+4FE0
+7C20
+0020
+3FF0
+00C0
+0480
+0480
+3FF0
 ENDCHAR
-STARTCHAR BE1F
-ENCODING 48671
+STARTCHAR uniB797
+ENCODING 46999
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-3830
-0810
-0FF0
-0810
-0810
-0FF0
-0810
-FFFE
-0300
-0100
+00C0
+7E20
+0220
+0420
+FE20
+403C
+4120
+7E20
+03C0
+3FF8
 0380
-0660
-0830
-3000
+0440
+0440
+0440
+0380
 ENDCHAR
-STARTCHAR BE44
-ENCODING 48708
+STARTCHAR uniB798
+ENCODING 47000
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
-0010
-0610
-C210
-4210
-7E10
-4210
-4210
-4210
-7E10
-4210
-0010
-0010
-0010
+0060
+0310
+0090
+FC90
+0890
+0890
+0890
+7090
+40F0
+4190
+4E90
+7090
+0090
+0090
 0010
 ENDCHAR
-STARTCHAR BE45
-ENCODING 48709
+STARTCHAR uniB799
+ENCODING 47001
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 16 3 -3
 BITMAP
 0060
-0410
-C210
-4210
-7E10
-4210
-4210
-7E10
-4010
-0000
-3FE0
+0320
+0120
+F920
+1120
+1920
+E1E0
+8720
+F920
+C120
+7FE0
 0020
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR BE48
-ENCODING 48712
+STARTCHAR uniB79C
+ENCODING 47004
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0060
-0610
-C210
-4210
-7E10
-4210
-4210
-4210
-7E10
-4210
+0030
 0010
-1810
-0800
+0090
+FC90
+0890
+0890
+F890
+40F0
+4190
+4E90
+7090
+1890
 0810
+0800
 0FF8
 ENDCHAR
-STARTCHAR BE4C
-ENCODING 48716
+STARTCHAR uniB7A0
+ENCODING 47008
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0410
-C310
-4210
-7E10
-4210
-4210
-7E10
-4200
-1FE0
-0020
+0040
+0220
+0120
+F920
+1120
+1120
+E1E0
+8720
+F920
+FFC0
+0040
+0040
+1FC0
+1000
 1FE0
-0800
-0800
-0FF8
 ENDCHAR
-STARTCHAR BE4E
-ENCODING 48718
+STARTCHAR uniB7A8
+ENCODING 47016
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 16 3 -3
 BITMAP
-0070
-0210
-C110
-4110
-7F10
-4110
-4110
-7F10
-4110
-0000
-7C00
-09F0
-7D20
-2120
-3DE0
-0100
+0060
+0320
+0120
+F920
+0920
+0920
+F1E0
+8720
+F920
+C120
+1FE0
+0840
+0840
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR BE54
-ENCODING 48724
+STARTCHAR uniB7A9
+ENCODING 47017
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0070
+0030
+0190
+FC90
+0490
+0890
+FC90
+40F0
+4190
+7E90
+7C30
 0410
-C310
-4210
-7E10
-4210
-4210
-7E10
-4210
-0000
-1FF0
-0830
-0820
-0820
-0FF0
-0800
+07F0
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR BE55
-ENCODING 48725
+STARTCHAR uniB7AB
+ENCODING 47019
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 15 3 -2
 BITMAP
-0070
-0410
-C310
-4210
-7E10
-4210
-4210
-7E10
-4240
-1830
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0060
+0220
+0120
+F120
+1120
+1120
+E1E0
+8120
+8720
+FF20
+0200
+0700
+0C80
+1860
+2000
 ENDCHAR
-STARTCHAR BE57
-ENCODING 48727
+STARTCHAR uniB7AC
+ENCODING 47020
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0030
-0610
-C310
-4210
-7E10
-4210
-4210
-7E10
-4210
-0110
-0180
-0180
-0240
-0C30
-1010
+0060
+0130
+0090
+0090
+7890
+0890
+F8F0
+4090
+4390
+4CF0
+3420
+0C20
+0E60
+1298
+6108
 ENDCHAR
-STARTCHAR BE59
-ENCODING 48729
+STARTCHAR uniB7AD
+ENCODING 47021
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0070
-0410
-C310
-4210
-7E10
-4210
-4210
-7E10
-4210
-0080
-0740
-0420
-0420
-0660
-03C0
+0060
+0320
+0120
+F120
+1120
+1120
+E1E0
+8320
+BD20
+E120
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR BE5A
-ENCODING 48730
+STARTCHAR uniB7B4
+ENCODING 47028
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0210
-C110
-4110
-7F10
-4110
-4110
-7F10
-4110
-3FF0
-0100
-0380
-0660
-0830
-3000
+00C0
+0020
+0020
+FE20
+0420
+043C
+FC20
+4020
+4060
+43AC
+7C30
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BE5B
-ENCODING 48731
+STARTCHAR uniB7B5
+ENCODING 47029
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 16 2 -3
 BITMAP
-0030
-0410
-C310
-4210
-7E10
-4210
-4210
-7E10
-4200
-0380
-3FF0
-0100
-0280
-0470
-1810
-2000
+0060
+0020
+FE20
+022C
+0230
+FE20
+4060
+43BC
+7C20
+0000
+3FE0
+1020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BE60
-ENCODING 48736
+STARTCHAR uniB7B8
+ENCODING 47032
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
-0020
-0020
-D4A0
-54A0
-54A0
-77A0
-54AC
-54B0
-54A0
-77A0
-54A0
-0020
 0020
+FE20
+0220
+022C
+FE30
+4020
+4020
+43E4
+7C38
 0020
+1820
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR BE61
-ENCODING 48737
+STARTCHAR uniB7C7
+ENCODING 47047
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 3 -3
+BBX 14 15 2 -2
 BITMAP
-00C0
-0240
-4940
-A940
-AF40
-E958
-A960
-AF40
-E840
-0000
-7FC0
-0040
-0040
-0040
-0040
-0040
+0060
+0020
+FE20
+042C
+0430
+7E20
+4020
+43FC
+7C20
+0180
+0100
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR BE64
-ENCODING 48740
+STARTCHAR uniB7C9
+ENCODING 47049
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 3 -2
 BITMAP
 00C0
-0040
-7140
-A940
-A940
-EF40
-A958
-A960
-EF40
-A940
 0040
-3000
-1000
-1000
-1FE0
+FE40
+0448
+0470
+F840
+4040
+4378
+7C40
+0100
+0680
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR BE68
-ENCODING 48744
+STARTCHAR uniB7EC
+ENCODING 47084
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-00C0
-0240
-A540
-A540
-E740
-A558
-A560
-E740
-A500
-3FE0
-0040
-3FE0
-1000
-1000
-1FE0
+0030
+0010
+0010
+FE10
+0410
+0410
+FCF0
+4010
+4010
+4010
+4210
+7C10
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BE6A
-ENCODING 48746
+STARTCHAR uniB7ED
+ENCODING 47085
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 3 -3
+BBX 12 15 2 -2
 BITMAP
-00C0
-0440
-AB40
-A940
-EF40
-A940
-A970
-EF40
-A840
-0000
-F7C0
-1480
-9480
-6480
-5F80
-2400
+0030
+0010
+FE10
+0410
+0410
+FCF0
+4010
+4110
+4E10
+7000
+1FF0
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BE70
-ENCODING 48752
+STARTCHAR uniB7F0
+ENCODING 47088
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 15 2 -2
+BITMAP
+0030
+0010
+FE10
+0410
+0410
+FDF0
+4010
+4010
+4210
+7C10
+0010
+1810
+0800
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniB7F4
+ENCODING 47092
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 3 -1
 BITMAP
 0060
-01A0
-D4A0
-54A0
-77A0
-54A4
-54B8
-77A0
-54A0
-0000
+0020
+FE20
+0420
+FDE0
+4020
+4020
+4620
+7800
+3FE0
+0040
 1FE0
-0840
-0840
-0840
+1000
+0FF0
+ENDCHAR
+STARTCHAR uniB7FC
+ENCODING 47100
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0070
+0010
+FE10
+0410
+05F0
+FC10
+4010
+4010
+4E10
+7000
+0FE0
+0820
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR BE71
-ENCODING 48753
+STARTCHAR uniB7FD
+ENCODING 47101
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 3 -3
+BBX 12 16 2 -3
 BITMAP
-00C0
-0340
-A940
-A940
-EF40
-A958
-A960
-EF40
-A900
-3040
-1040
-1FC0
-1040
-1040
-1FC0
-1040
+0060
+0010
+FE10
+0410
+0410
+FDF0
+4010
+4110
+5E10
+2070
+0830
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR BE73
-ENCODING 48755
+STARTCHAR uniB7FF
+ENCODING 47103
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 16 2 -3
 BITMAP
-0060
-0020
-0120
-D2A0
-52A0
-73A0
-52BC
-52A0
-73A0
-53A0
+0030
+0010
+FE10
+0410
+0410
+FCF0
+4010
+4010
+4210
+7D10
 0080
 0180
-0260
-0410
-1800
+0340
+0430
+0818
+1000
 ENDCHAR
-STARTCHAR BE74
-ENCODING 48756
+STARTCHAR uniB800
+ENCODING 47104
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-01A0
-52A0
-52A0
-73A0
-52AC
-52B0
-73A0
-52A0
-1840
-0C40
-0840
-16A0
-2310
-C000
+0070
+0010
+FE10
+0410
+0410
+F8F0
+4010
+4210
+7C10
+0020
+0C20
+0860
+1650
+2288
+4108
 ENDCHAR
-STARTCHAR BE75
-ENCODING 48757
+STARTCHAR uniB801
+ENCODING 47105
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0060
-01A0
-02A0
-D2A0
-53A0
-72A4
-52B8
-52A0
-73A0
-5280
-03C0
-0460
+0010
+FE10
+0410
+0410
+FCF0
+4010
+4010
+4C10
+7180
+0640
 0420
+0420
 0660
 03C0
 ENDCHAR
-STARTCHAR BE7B
-ENCODING 48763
+STARTCHAR uniB807
+ENCODING 47111
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0180
-02C0
-9540
-9540
-F740
-9540
-9558
-F760
-9540
-07C0
-3FF0
-0700
-0880
-0880
-0700
+0030
+FE10
+0210
+0410
+FEF0
+4010
+4210
+7C10
+03C0
+3FF8
+0100
+06C0
+0420
+0640
+03C0
 ENDCHAR
-STARTCHAR BE7C
-ENCODING 48764
+STARTCHAR uniB808
+ENCODING 47112
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
-0090
-0050
-3950
-9950
-9950
-FF50
-9950
-9970
-9F50
-F950
-9050
-0050
-0050
-0010
-ENDCHAR
-STARTCHAR BE7D
-ENCODING 48765
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 16 3 -3
-BITMAP
-0040
-01A0
-46A0
-AAA0
-AAA0
-EEA0
-AAE0
-AAA0
-EEA0
-AA00
-3FE0
-1020
-0020
-0020
-0020
+0220
+0120
+3920
+D120
+1120
+1120
+EF20
+8120
+8520
+9920
+E120
+0120
+0120
 0020
 ENDCHAR
-STARTCHAR BE80
-ENCODING 48768
+STARTCHAR uniB809
+ENCODING 47113
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-01A0
-04A0
-AAA0
-AAA0
-EEA0
-AAE0
-AAA0
-EEA0
-AAA0
-20A0
-1000
-1000
-1000
-0FF0
+0070
+0310
+0090
+7890
+0890
+9F90
+6090
+4090
+7890
+0080
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BE84
-ENCODING 48772
+STARTCHAR uniB80C
+ENCODING 47116
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0020
+0030
+0310
 0090
-0050
-D550
-5550
-7750
-5570
-5750
-7050
-0000
+F890
+0890
+0890
+FB90
+4090
+4490
+7890
+0090
+0800
+0800
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniB810
+ENCODING 47120
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0190
+0090
+7C90
+0890
+FB90
+4090
+4290
+7C80
 0FF0
 0010
 0FF0
-0410
+0400
+0400
 07F8
 ENDCHAR
-STARTCHAR BE8C
-ENCODING 48780
+STARTCHAR uniB818
+ENCODING 47128
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0020
+0030
+0190
 0090
-0250
-D550
-5550
-7750
-5570
-5550
-7750
-0000
+7890
+0890
+DF90
+6090
+4090
+7890
+0080
 0FF0
 0410
 0420
@@ -106246,682 +108913,713 @@
 07F0
 0400
 ENDCHAR
-STARTCHAR BE8D
-ENCODING 48781
+STARTCHAR uniB819
+ENCODING 47129
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 16 2 -3
 BITMAP
-0040
-01A0
-0AA0
-AAA0
-AEA0
-EAA0
-AAE0
-EEA0
-88A0
-1860
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0030
+0310
+0090
+7890
+0890
+9F90
+6090
+4090
+7880
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR BE8F
-ENCODING 48783
+STARTCHAR uniB81B
+ENCODING 47131
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0020
-00D0
-0350
-D550
-5550
-7750
-5570
-5550
-7750
-0190
-0080
-0140
-0230
-0418
-1800
+0060
+0220
+0120
+F920
+1120
+1120
+E720
+8120
+8920
+F220
+0100
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR BE90
-ENCODING 48784
+STARTCHAR uniB81D
+ENCODING 47133
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0020
-00D0
-0350
-D550
-5550
-7750
-5570
-5550
-7750
+0030
+0190
+0090
+7890
+0890
+9F90
+6090
+4290
+7C90
+0010
+03C0
 0420
 0420
-0C20
-0A50
-1088
-2108
+0660
+03C0
 ENDCHAR
-STARTCHAR BE91
-ENCODING 48785
+STARTCHAR uniB824
+ENCODING 47140
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0020
-0090
-0350
-D550
-5550
-7750
-5570
-5550
-7750
-0050
-01A0
-0210
-0210
-0330
-01E0
+0070
+0010
+0010
+FE10
+05F0
+0410
+0410
+FC10
+41F0
+4010
+4110
+4E10
+7010
+0010
+0010
 ENDCHAR
-STARTCHAR BE98
-ENCODING 48792
+STARTCHAR uniB825
+ENCODING 47141
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 12 16 2 -3
 BITMAP
-00C0
-0020
+0070
+0010
+FE10
+0610
+04F0
+FE10
+4010
+4110
+5EF0
+2010
+3FE0
 0020
-94A0
-54A0
-54A4
-77B8
-54A0
-54A0
-54A0
-77AC
-5030
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR BE99
-ENCODING 48793
+STARTCHAR uniB828
+ENCODING 47144
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-00C0
-0240
-0940
-A940
-AF78
-E940
-A940
-EF70
-A840
-0000
-7FC0
-0040
-0040
-0040
-0040
+0030
+0010
+FE10
+0410
+05F0
+FC10
+4010
+4110
+4EF0
+7010
+0010
+1800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR BEA8
-ENCODING 48808
+STARTCHAR uniB82C
+ENCODING 47148
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 14 2 -1
 BITMAP
 0060
-0120
-D4A0
-54AC
-77B0
-54A0
-54A0
-77BC
-5420
-0000
+0010
+FC10
+05F0
+FC10
+4010
+4110
+5EF0
+2000
 1FE0
-0820
-0840
-0840
-0FE0
-0800
+0020
+1FE0
+0810
+0FF8
 ENDCHAR
-STARTCHAR BED0
-ENCODING 48848
+STARTCHAR uniB834
+ENCODING 47156
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0060
-0010
-BC90
-5490
-5490
-7790
-54F0
-5490
-5490
-7790
-5410
-0010
 0010
-0010
-0010
-ENDCHAR
-STARTCHAR BED1
-ENCODING 48849
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 16 3 -3
-BITMAP
-0060
-4B20
-B520
-A520
-E720
-A5E0
-A520
-E720
-A520
-0020
-7FC0
-0040
-0040
-0040
-0040
-0040
+FC10
+0410
+04F0
+DC10
+6010
+4110
+47F0
+7810
+0FE0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR BED4
-ENCODING 48852
+STARTCHAR uniB835
+ENCODING 47157
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0020
-2190
-D490
-5490
-7790
-5490
-54F0
-5490
-7790
-5410
-1010
-0810
-0810
+0010
+FE10
+05F0
+0410
+F810
+4310
+5FF0
+7C10
+3820
+0820
+0FE0
+0820
+0FE0
 0800
-0FF8
 ENDCHAR
-STARTCHAR BED7
-ENCODING 48855
+STARTCHAR uniB837
+ENCODING 47159
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-00E0
-0320
-4520
-A520
-A720
-E5E0
-A520
-A720
-E520
-A020
-1FE0
-0800
-0800
-0800
-0FF0
+0030
+0010
+FE10
+02F0
+0410
+8610
+79F0
+4010
+4210
+7F10
+0110
+0380
+0640
+0830
+3000
 ENDCHAR
-STARTCHAR BED8
-ENCODING 48856
+STARTCHAR uniB838
+ENCODING 47160
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 14 2 -2
 BITMAP
-0060
-0220
-A520
-A520
-E720
-A5E0
-A520
-E720
-A520
-3FC0
-0040
-0040
-1FC0
-1000
-1FF0
+0030
+FC10
+0410
+0470
+FC10
+4010
+47F0
+7810
+0860
+0420
+0C60
+1A50
+2298
+4108
 ENDCHAR
-STARTCHAR BEE0
-ENCODING 48864
+STARTCHAR uniB839
+ENCODING 47161
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0070
-0110
-0290
-CA90
-4B90
-7AF0
-4A90
-7B90
-4A90
-0010
-0FF0
+0030
+FE10
+0410
+05F0
 0410
+FC10
+4090
+47F0
+7810
+6080
+0340
 0420
 0420
-07F0
-0400
+0660
+03C0
 ENDCHAR
-STARTCHAR BEE3
-ENCODING 48867
+STARTCHAR uniB840
+ENCODING 47168
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0590
-CA90
-4A90
-7B90
-4AF0
-4A90
-4B90
-7A90
-4910
+0010
+0190
+0C90
+7890
+0F90
+0890
+F890
+4790
+4090
+4C90
+7090
 0090
-0180
-0340
-0430
-1808
+0090
+0010
 ENDCHAR
-STARTCHAR BEE4
-ENCODING 48868
+STARTCHAR uniB844
+ENCODING 47172
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 14 2 -1
 BITMAP
-0060
-0320
-A920
-A920
-EF20
-A9E0
-A920
-EF20
-A820
-00C0
-0840
-1840
-14C0
-2330
-4210
+0030
+0310
+0090
+FC90
+0F90
+0890
+7890
+4790
+4490
+7890
+0C90
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BEE5
-ENCODING 48869
+STARTCHAR uniB851
+ENCODING 47185
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 16 2 -3
 BITMAP
-00E0
-0220
-9520
-9520
-F720
-95E0
-9520
-F720
-9520
-0120
-06C0
-0820
-0820
-0C60
-07C0
+0030
+0110
+0090
+7890
+0F90
+F890
+4390
+4090
+7880
+0C20
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR BEEC
-ENCODING 48876
+STARTCHAR uniB853
+ENCODING 47187
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
+0110
 0090
-0050
-1B50
-D950
-5950
-7F50
-59D0
-5950
-5F50
-7950
-0050
-0050
-0010
-0010
-ENDCHAR
-STARTCHAR BF01
-ENCODING 48897
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-0060
-0120
-06A0
-AAA0
-AAA0
-EFA0
-AAA0
-AAA0
-EEA0
-0120
+7890
+0F90
+9890
+6790
+4090
+7890
+0290
+0100
+0300
 06C0
-0820
-0820
-0C60
-07C0
+0830
+3010
 ENDCHAR
-STARTCHAR BF08
-ENCODING 48904
+STARTCHAR uniB85C
+ENCODING 47196
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 11 1 0
 BITMAP
-0030
-0010
-D490
-5490
-54F0
-7790
-5490
-5490
-54F0
-7790
-5410
-0010
-0010
+1FF8
 0010
 0010
+1FF0
+0800
+0800
+0800
+0FF0
+0100
+0104
+FFFE
 ENDCHAR
-STARTCHAR BF09
-ENCODING 48905
+STARTCHAR uniB85D
+ENCODING 47197
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -2
 BITMAP
+3FE0
 0020
-0190
-CA90
-4AF0
-7B90
-4A90
-4AF0
-7BD0
-4A10
-0000
+3FE0
+1000
+1000
 1FF0
-0010
-0010
-0010
-0010
-0010
+0100
+FFFC
+0000
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR BF18
-ENCODING 48920
+STARTCHAR uniB860
+ENCODING 47200
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 13 2 -1
 BITMAP
-0030
-0110
-CA90
-4AF0
-7B90
-4A90
-4AF0
-7B90
-4A10
+3FE0
+0020
+0020
+1FE0
+1000
+1FF0
+0200
+FFFC
 0000
-07F0
-0410
-0420
-07F0
-0400
+3000
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR BF19
-ENCODING 48921
+STARTCHAR uniB864
+ENCODING 47204
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0030
-0190
-DA90
-52F0
-7390
-5290
-52F0
-7390
-5210
-0C60
-0420
-07E0
-0420
-0420
-07E0
-0420
+3FE0
+0020
+3FE0
+1000
+1000
+1FE0
+0200
+FFFC
+3FE0
+0020
+3FE0
+1000
+1000
+0FF0
 ENDCHAR
-STARTCHAR BF1B
-ENCODING 48923
+STARTCHAR uniB86C
+ENCODING 47212
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 2 -3
 BITMAP
-0060
-0820
-9520
-9520
-F7E0
-9520
-9520
-F7E0
-8420
-0220
-0120
-0300
-0480
-0860
-3010
+3FE0
+0020
+3FE0
+1000
+1000
+1FE0
+0200
+FFFC
+0000
+3FE0
+1040
+1040
+1040
+1FC0
+1000
 ENDCHAR
-STARTCHAR BF1C
-ENCODING 48924
+STARTCHAR uniB86D
+ENCODING 47213
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0020
-A520
-A520
-E7E0
-A520
-A5E0
-E720
-A400
-1060
-0C20
-0840
-16E0
-2290
-4108
+3FE0
+0040
+3FC0
+1000
+1000
+1FC0
+0200
+FFFC
+30C0
+1040
+1FC0
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR BF1D
-ENCODING 48925
+STARTCHAR uniB86F
+ENCODING 47215
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0220
-6520
-A5E0
-A720
-E520
-A5E0
-E520
-A740
-0500
-07C0
-0840
-0840
-0CC0
-0780
+3FE0
+0040
+3FE0
+1000
+1000
+1FC0
+0200
+FFFC
+0000
+0200
+0600
+0D80
+1060
+6020
 ENDCHAR
-STARTCHAR BF40
-ENCODING 48960
+STARTCHAR uniB871
+ENCODING 47217
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 0
+BBX 15 14 2 -2
 BITMAP
-0198
-0C88
-2488
-24F8
-3C88
-2488
-2488
-3CF8
-2588
-0100
-0100
+3FE0
+0020
+3FE0
+1000
+1000
+1FF0
+0200
 FFFE
+0200
+0F80
+18C0
+1040
+18C0
+0780
 ENDCHAR
-STARTCHAR BF41
-ENCODING 48961
+STARTCHAR uniB878
+ENCODING 47224
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-C510
-4510
-7DF0
-4510
-7DF0
-4710
-010C
-FFFC
-0000
-3FE0
+00E0
 0020
+7F20
+0120
+0220
+7F20
+2020
+2024
+1FB8
+0820
+08E0
+F720
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR BF44
-ENCODING 48964
+STARTCHAR uniB87C
+ENCODING 47228
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-6688
-2688
-3CF8
-2488
-3CF8
-2788
-0100
-FFFE
-0000
-0000
-0800
+0030
+0010
+3F90
+0090
+3F90
+1010
+1196
+0E18
+FFF0
+0010
+0C10
+0400
+0400
+07F8
+ENDCHAR
+STARTCHAR uniB88D
+ENCODING 47245
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -2
+BITMAP
+0030
+3F90
+0090
+3F90
+1010
+119C
+0E10
+FFF0
+0050
+01E0
+0210
+0210
+0330
+01E0
+ENDCHAR
+STARTCHAR uniB8A8
+ENCODING 47272
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0020
+00D0
+0050
+1E50
+7E50
+2050
+2050
+1E70
+08D0
+FF50
+0630
+0220
+0570
+08C8
+1088
+ENDCHAR
+STARTCHAR uniB8B0
+ENCODING 47280
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0070
+0010
+7F10
+0110
+0210
+7F10
+2010
+2010
+3F90
+0410
+0450
+FF90
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniB8B4
+ENCODING 47284
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0060
+0010
+7F10
+0110
+0210
+7F10
+2010
+2190
+1E10
+05F0
+FA10
+1810
 0800
 0800
-07F0
+0FF8
 ENDCHAR
-STARTCHAR BF48
-ENCODING 48968
+STARTCHAR uniB8B8
+ENCODING 47288
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-8490
-4490
-7CF0
-4490
-7CF0
-4790
-0100
-FFFC
-0000
-7FC0
-0040
-3FC0
-1000
-1FF0
+0070
+0010
+7F10
+0110
+3F10
+2010
+2390
+1C10
+FFF0
+0FF0
+0010
+0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR BF50
-ENCODING 48976
+STARTCHAR uniB8C0
+ENCODING 47296
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 15 2 -2
 BITMAP
-6248
-2248
-3E78
-2248
-3E78
-2148
-0100
-FFFE
+0030
+0010
+7F10
+0110
+3F10
+2010
+3F90
+0410
+FFF0
 0000
-1FE0
-0820
-0820
-0840
-0FE0
-0800
+0FF0
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR BF51
-ENCODING 48977
+STARTCHAR uniB8C1
+ENCODING 47297
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 11 16 3 -3
 BITMAP
-6488
-2488
-3CF8
-2488
-2488
-3FF8
-2180
-FFFE
-1860
+0060
+0020
+FE20
+0220
+FE20
+4020
+4320
+3C20
+0BE0
+F460
 0820
 0FE0
 0820
@@ -106929,104 +109627,187 @@
 0FE0
 0820
 ENDCHAR
-STARTCHAR BF55
-ENCODING 48981
+STARTCHAR uniB8C3
+ENCODING 47299
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 1 -2
 BITMAP
-4588
-2488
-3CF8
-2488
-2488
-3CF8
-2780
-01FE
-FF00
-03C0
-0420
-0420
-0460
-03C0
+0010
+0008
+3F88
+0088
+1F88
+1008
+1008
+0F88
+FFF8
+20C8
+0040
+00C0
+0120
+0218
+0C04
 ENDCHAR
-STARTCHAR BF94
-ENCODING 49044
+STARTCHAR uniB8C5
+ENCODING 47301
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 1 -2
 BITMAP
-0030
-0590
-0290
-4A90
-4B90
-7A90
-4B90
-7A90
-4890
-0870
-0FD0
-F810
-0010
-0010
-0010
-0010
+0038
+0018
+3F88
+0088
+3F88
+1008
+10C8
+0F08
+FFF8
+0008
+01E0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR BFB0
-ENCODING 49072
+STARTCHAR uniB8CC
+ENCODING 47308
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 0
+BBX 15 11 1 0
 BITMAP
-04C8
-2248
-2248
-3E78
-2248
-2248
-2248
-3E78
-2C60
+1FF8
+0010
+0010
+1FF0
+0800
+0800
+0FF8
+0860
 0420
-0440
+0420
 FFFE
 ENDCHAR
-STARTCHAR BFC5
-ENCODING 49093
+STARTCHAR uniB8D0
+ENCODING 47312
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 15 13 2 -1
 BITMAP
-C510
-4510
-7DF0
-4510
-7DF0
-4510
-0180
-F880
-07F8
+3FE0
+0020
+0020
+1FC0
+1000
+0FF0
+0880
+F8FE
 0700
-18C0
+3000
+1000
+1020
+0FF0
+ENDCHAR
+STARTCHAR uniB8D4
+ENCODING 47316
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+3FE0
+0040
+1FE0
+1000
+1FC0
+0880
+FFFC
+0000
+3FC0
+0040
+0040
+1FC0
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniB8DD
+ENCODING 47325
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
+BITMAP
+3FE0
+0040
+1FE0
+1000
+1FC0
+0880
+FFFC
+0000
+30C0
+1040
+1FC0
+1040
+1040
+1FC0
+1040
+ENDCHAR
+STARTCHAR uniB8DF
+ENCODING 47327
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+3FE0
+0040
+1FE0
+1000
+1000
+0FC0
+0880
+FFFC
+0000
+0200
+0600
+0D80
+1060
+6020
+ENDCHAR
+STARTCHAR uniB8E1
+ENCODING 47329
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+3FE0
+0020
+3FE0
+1000
+1000
+1FF0
+08C0
+FFFC
+0200
+0D80
+1040
 1040
 18C0
-0F80
+0780
 ENDCHAR
-STARTCHAR BFCC
-ENCODING 49100
+STARTCHAR uniB8E8
+ENCODING 47336
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 14 1 -2
 BITMAP
+1FF0
 0010
-6488
-2488
-3CF8
-2488
-2488
-3CF8
-2088
+0010
+0FE0
+0800
+0FF8
+0000
 FFFE
 0100
 0100
@@ -107034,1103 +109815,1164 @@
 0100
 0100
 0100
-0100
 ENDCHAR
-STARTCHAR BFCD
-ENCODING 49101
+STARTCHAR uniB8E9
+ENCODING 47337
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 15 1 -3
 BITMAP
-0198
-3688
-12F8
-1E88
-1288
-1EF8
-128C
+1FF0
+0010
+1FF0
+0800
+0800
+0FF8
+0000
 FFFE
 0100
-0100
-1FF0
-0020
-0020
-0020
-0020
+01F0
+0E10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR BFD0
-ENCODING 49104
+STARTCHAR uniB8EC
+ENCODING 47340
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-6688
-2288
-3EF8
-2288
-2288
-3EF8
-228C
+1FF0
+0020
+1FE0
+0800
+0800
+0FF8
+0004
 FFFE
 0100
 0100
 1900
 0900
 0800
-0FF8
+07F8
 ENDCHAR
-STARTCHAR BFD4
-ENCODING 49108
+STARTCHAR uniB8F0
+ENCODING 47344
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-6490
-2490
-3CF0
-2490
-3CF0
-2484
-FFFE
-0100
-0100
-1FE0
+3FE0
 0020
+3FE0
+1000
+1000
+1FE8
+03FC
+FE00
+3E00
+01E0
+0040
+3FE0
+1000
 1FE0
-0800
-0FF0
 ENDCHAR
-STARTCHAR BFDC
-ENCODING 49116
+STARTCHAR uniB8F8
+ENCODING 47352
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
-6448
-2448
-3C78
-2448
-3C78
-2448
+1FF0
+0010
+1FF0
+0800
+0800
+0FF0
 0000
 FFFE
 0100
-0100
-1EE0
+1FE0
 0820
-0840
+0820
+0820
 0FE0
 0800
-ENDCHAR
-STARTCHAR BFDF
-ENCODING 49119
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-6490
-2490
-3CF0
-2490
-3CF0
-2490
-FFFC
-0200
-0200
-0200
-0200
-0580
-1860
-2030
 ENDCHAR
-STARTCHAR BFE1
-ENCODING 49121
+STARTCHAR uniB8F9
+ENCODING 47353
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-3648
-1248
-1E78
-1248
-1E78
-1248
+1FF0
+0020
+1FE0
+0800
+0FF0
 0000
 FFFE
 0100
-0380
-0C60
+1160
 0820
-0C60
-07C0
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C03C
-ENCODING 49212
+STARTCHAR uniB8FB
+ENCODING 47355
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
+1FF0
 0010
-6248
-2248
-3E78
-2248
-2248
-3E78
-2248
-FFFE
-0420
-0420
-0420
-0420
-0420
-0420
-ENDCHAR
-STARTCHAR C051
-ENCODING 49233
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-6490
-2490
-3CF0
-2490
-3CD0
-2CF0
-3490
-CF6C
-0940
-07C0
-0840
-0840
-0CC0
-0780
-ENDCHAR
-STARTCHAR C058
-ENCODING 49240
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 11 1 1
-BITMAP
-0188
-0688
-1288
-12F8
-1E88
-1288
-1288
-1EF8
-1288
+1FF0
+0800
+0FF8
+0000
 0000
 FFFE
+0100
+0300
+0100
+0280
+0460
+1810
 ENDCHAR
-STARTCHAR C05C
-ENCODING 49244
+STARTCHAR uniB8FD
+ENCODING 47357
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-C490
-4490
-7CF0
-4490
-4490
-7CF0
-4480
-03FC
-FF00
-0000
-3000
-1000
-1000
 1FF0
-ENDCHAR
-STARTCHAR C060
-ENCODING 49248
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
-BITMAP
-0188
-2688
-12F8
-1E88
-1288
-1EF8
-1288
-FFFE
-0000
-1FE0
-0020
-0020
-1FE0
+0010
+1FF0
 0800
-0FF8
+0FF0
+0000
+0004
+FFFE
+0100
+0300
+0CE0
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR C068
-ENCODING 49256
+STARTCHAR uniB904
+ENCODING 47364
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0020
-6510
-2510
-3DF0
-2510
-25F0
-3D10
-2400
-FFFC
-0000
-3FC0
-1040
-1080
-1FC0
-1000
+0018
+0008
+3F88
+0088
+3F88
+1008
+1008
+1FC8
+0068
+FF88
+04F8
+0408
+0408
+0408
+0008
 ENDCHAR
-STARTCHAR C069
-ENCODING 49257
+STARTCHAR uniB918
+ENCODING 47384
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-3288
-1288
-1EF8
-1288
-12F8
-1E80
-1200
-FFFE
-0C60
-0420
-07E0
-0420
-07E0
+0030
+0010
+7F10
+7E10
+2010
+3F10
+0010
+0090
+FF30
+08D0
 0420
+0C60
+0A60
+1298
+6108
 ENDCHAR
-STARTCHAR C090
-ENCODING 49296
+STARTCHAR uniB920
+ENCODING 47392
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0290
-D290
-5290
-5390
-7290
-5290
-5290
-7390
-5290
-0010
-0010
-0010
+0090
+0050
+FC50
+0450
+FC50
+4050
+4650
+3850
+FE50
+08D0
+0950
+0850
+0850
 0010
 ENDCHAR
-STARTCHAR C091
-ENCODING 49297
+STARTCHAR uniB93C
+ENCODING 47420
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 1 -2
 BITMAP
-0030
-0110
-0290
-CA90
-4B90
-7A90
-4A90
-7B90
-4A10
-0000
+0018
+3F88
+0088
+0108
+3F88
+1008
+1FC8
+0008
+01C8
+FE08
+0408
+0408
+0408
+0408
+0008
+ENDCHAR
+STARTCHAR uniB93D
+ENCODING 47421
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 14 3 -2
+BITMAP
+0060
+FE20
+0420
+FE20
+4020
+7E20
+1F20
+F020
+1020
 3FE0
 0020
 0020
 0020
 0020
-0020
 ENDCHAR
-STARTCHAR C094
-ENCODING 49300
+STARTCHAR uniB940
+ENCODING 47424
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 3 -2
 BITMAP
 0060
-0020
-2920
-9520
-9520
-F720
-9520
-9520
-F720
-9520
 0020
+FE20
+0220
+FE20
+4020
+7E20
+1F20
+F020
+1020
+1020
 0820
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR C098
-ENCODING 49304
+STARTCHAR uniB944
+ENCODING 47428
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0220
-9520
-9520
-F720
-9520
-9520
-F720
-9500
-3FC0
-0040
-3FC0
-1000
-1000
-1FE0
+0030
+0010
+3F10
+7F10
+2010
+3F10
+0010
+FF10
+0800
+0FF0
+0010
+0FF0
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR C0A0
-ENCODING 49312
+STARTCHAR uniB94C
+ENCODING 47436
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
+7F10
+0210
+7F10
+2010
+3F10
 0010
-CA90
-4A90
-7B90
-4A90
-4A90
-7B90
-4A90
-0000
+FF90
+0810
+0800
 0FF0
 0410
-0410
+0420
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR C0A1
-ENCODING 49313
+STARTCHAR uniB94F
+ENCODING 47439
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -3
 BITMAP
 0030
+7F10
 0110
-CA90
-4A90
-7B90
-4A90
-4A90
-7B90
-4280
-0C30
-0420
-07E0
-0420
+7F10
+2010
+3F10
+00D0
+FF10
+0810
+0890
+0080
+0160
+0610
+0808
+1000
+ENDCHAR
+STARTCHAR uniB951
+ENCODING 47441
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -2
+BITMAP
+0030
+7F10
+0210
+7F10
+2010
+3F90
+F810
+0810
+0890
+0350
 0420
-07E0
 0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C0A3
-ENCODING 49315
+STARTCHAR uniB958
+ENCODING 47448
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 14 2 -2
 BITMAP
-0060
+3FE0
 0020
-0220
-D520
-5520
-7720
-5520
-5520
-7720
-5620
-0120
-0300
-02C0
-0C20
-1010
+0040
+3FE0
+1000
+1FE0
+0000
+FFFC
+0840
+0840
+0840
+0840
+0840
+0840
 ENDCHAR
-STARTCHAR C0A5
-ENCODING 49317
+STARTCHAR uniB959
+ENCODING 47449
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 14 2 -2
 BITMAP
-00E0
-0320
-0520
-9520
-9720
-F520
-9520
-9520
-F720
-8500
-0780
-0840
-0840
-0C40
-0780
+3FC0
+0040
+3FC0
+1000
+1000
+1FE0
+0000
+FFF8
+0880
+2FC0
+1040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C0AC
-ENCODING 49324
+STARTCHAR uniB95C
+ENCODING 47452
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-0810
-0410
-0410
-0810
-1C10
-121E
-2310
-4110
-8010
-0010
-0010
-0010
+1FF0
 0010
+1FF0
+0800
+0800
+0FF0
+0000
+FFFE
+0420
+0420
+1C20
+0820
+0800
+0FF8
 ENDCHAR
-STARTCHAR C0AD
-ENCODING 49325
+STARTCHAR uniB960
+ENCODING 47456
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0060
-0020
-1820
-0820
-1020
-382C
-4630
-8320
+3FE0
 0020
+3FE0
+1000
+1FE0
 0000
+FFFC
+08C0
+0880
 3FE0
-1020
-0020
-0020
-0020
-0020
+0040
+3FE0
+1000
+1FF0
 ENDCHAR
-STARTCHAR C0AF
-ENCODING 49327
+STARTCHAR uniB968
+ENCODING 47464
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-1020
+1FF0
+0020
+1FE0
+0800
+0FF0
+0000
+FFFE
+0460
+0040
+0FE0
 0820
-1820
-1820
-242C
-4230
-8020
-0080
-F860
 0840
-0860
-0890
-0918
-0A08
+0FC0
+0800
 ENDCHAR
-STARTCHAR C0B0
-ENCODING 49328
+STARTCHAR uniB969
+ENCODING 47465
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 15 1 -3
 BITMAP
-0030
-0010
-0410
-0410
-0C10
-0C10
-131E
-2090
-C010
-0010
-1C10
-0400
-0400
-0400
-07F8
+1FF0
+0020
+0020
+0FC0
+0830
+07C0
+FFFE
+0440
+1840
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C0B3
-ENCODING 49331
+STARTCHAR uniB96B
+ENCODING 47467
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+3FE0
+0040
+3FE0
+1000
+1FE0
+0000
+FFFC
+0840
+0840
+0B40
+0200
+0500
+08E0
+3020
+ENDCHAR
+STARTCHAR uniB96D
+ENCODING 47469
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0030
+1FF0
 0010
-0C10
-0410
-0C10
-0C1E
-1310
-2090
-C010
-0000
 0FF0
-0400
-0400
-0408
-03FC
+0800
+0FF8
+0000
+FFFE
+0420
+04A0
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C0B4
-ENCODING 49332
+STARTCHAR uniB974
+ENCODING 47476
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 11 2 0
 BITMAP
-0060
-0020
-0820
-0820
-1820
-343C
-4320
-8120
+7FE0
+0040
+0040
+60C0
+3F00
+2000
+20E0
+1F00
 0000
-1FE0
+0018
+FFE0
+ENDCHAR
+STARTCHAR uniB975
+ENCODING 47477
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1FF0
 0020
 1FE0
 0800
-0800
 0FF0
+0000
+03FE
+FF80
+0000
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C0B5
-ENCODING 49333
+STARTCHAR uniB978
+ENCODING 47480
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 12 1 -1
 BITMAP
-0060
-0020
-0820
-0820
-1820
-243C
-4320
-8120
+1FF0
+0010
+1FF0
+0800
+0FF8
 0000
-3DE0
-0420
-7E20
-2020
-2620
-3820
+01FE
+FF80
+1800
+0800
+0810
+0FF8
 ENDCHAR
-STARTCHAR C0B6
-ENCODING 49334
+STARTCHAR uniB97C
+ENCODING 47484
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-1020
-0C20
-0820
-1820
-263C
-4120
-8020
+1FF0
+0010
+1FF0
+0800
+0800
+0FF4
+FFFE
 0000
-3DF0
-0520
-6D20
-3120
-21F0
-3F00
+0FF0
+0020
+1FF0
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR C0BC
-ENCODING 49340
+STARTCHAR uniB984
+ENCODING 47492
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-0820
+1FF0
+0010
+1FF0
+0800
+0800
+0FF8
+0000
+FFFE
+0000
+1FF0
 0820
-1820
-142C
-2330
-C120
-0020
-1FE0
 0820
-0840
-0840
-0840
 0FE0
 0800
 ENDCHAR
-STARTCHAR C0BD
-ENCODING 49341
+STARTCHAR uniB985
+ENCODING 47493
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0040
+1FF0
 0020
-0820
-0820
-1020
-283C
-4620
-8320
+1FE0
+0800
+0800
+0FF0
 0000
+FFFE
 1820
 0820
 0FE0
 0820
+0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR C0BF
-ENCODING 49343
+STARTCHAR uniB987
+ENCODING 47495
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
+3FE0
 0020
-1820
-0820
-1020
-3824
-2638
-4220
-8020
-01A0
-0080
-0180
-0240
-0430
-1808
+0040
+1F80
+1000
+1FE0
+0008
+FFFC
+0400
+0200
+0600
+0D80
+1060
+6000
 ENDCHAR
-STARTCHAR C0C0
-ENCODING 49344
+STARTCHAR uniB989
+ENCODING 47497
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-1820
-0820
-1020
-3C3C
-6220
-8120
-0000
+1FF0
+0010
+1FF0
+0800
+0800
+0FF0
+FFFE
+2100
+07C0
 0C60
-0840
-0C40
-16B0
-2318
-C008
+0820
+0820
+0460
+03C0
 ENDCHAR
-STARTCHAR C0C1
-ENCODING 49345
+STARTCHAR uniB98A
+ENCODING 47498
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 15 1 -3
 BITMAP
-0030
-0010
-0410
-0410
-0C10
-0C16
-1318
-2090
-C010
-0050
-01A0
-0210
-0210
-0330
-01E0
+1FF0
+0020
+1FE0
+0800
+0FF0
+0000
+FFFE
+0000
+0000
+1FF8
+0100
+0300
+06C0
+0830
+3000
 ENDCHAR
-STARTCHAR C0C5
-ENCODING 49349
+STARTCHAR uniB98D
+ENCODING 47501
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-1020
-0C20
-0820
-1820
-343C
-6320
-8120
+1FF0
+0020
+1FE0
+0800
+0FF0
 0000
-0FE0
-0820
-0FE0
+FFFE
+0000
+0000
+0FF0
 0800
+0FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR C0C8
-ENCODING 49352
+STARTCHAR uniB98E
+ENCODING 47502
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0030
+1FF0
 0010
-0190
-1090
-1890
-1090
-3090
-2890
-4CF0
-8490
-0090
-0090
-0090
-0090
-0090
 0010
+1FF0
+0800
+0FF0
+0000
+FFFE
+2000
+1FF0
+0840
+0440
+0498
+1B60
 ENDCHAR
-STARTCHAR C0C9
-ENCODING 49353
+STARTCHAR uniB9AC
+ENCODING 47532
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0020
-0110
-1090
-0890
-1890
-1090
-2CF0
-4690
-8290
-0090
-1FF0
-0810
+0070
 0010
 0010
+FE10
+0210
+0410
+0410
+FE10
+4010
+4050
+4390
+7C10
+0010
 0010
 0010
 ENDCHAR
-STARTCHAR C0CC
-ENCODING 49356
+STARTCHAR uniB9AD
+ENCODING 47533
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0018
-0088
-0048
-0448
-0448
-0848
-1C48
-1278
-6248
-8048
-0048
-0C48
-0400
-0400
-07FC
+0030
+0010
+FE10
+0410
+0410
+FE10
+4050
+4790
+7810
+0000
+3FE0
+1020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C0D0
-ENCODING 49360
+STARTCHAR uniB9B0
+ENCODING 47536
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0020
-0110
-1090
-0890
-1090
-1090
-2CF0
-4490
-8090
-1FF0
+0040
+0030
+FE10
+0410
+0410
+FE10
+4010
+4050
+4390
+7C10
+0010
+1810
+0800
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniB9B4
+ENCODING 47540
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0010
+8E10
+7210
+0410
+7E10
+4010
+4390
+7C00
+1FE0
 0020
-1FF0
+1FE0
 0800
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR C0D8
-ENCODING 49368
+STARTCHAR uniB9BC
+ENCODING 47548
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 16 3 -3
 BITMAP
+0060
 0020
-0110
-0090
-0890
-0890
-1090
-28F0
-4490
-8290
-0090
-0FF0
-0410
-0420
+FE20
+0220
 0420
-07F0
-0400
+7E20
+4060
+47A0
+7820
+0000
+3FC0
+1040
+1040
+1040
+1FC0
+1000
 ENDCHAR
-STARTCHAR C0D9
-ENCODING 49369
+STARTCHAR uniB9BD
+ENCODING 47549
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 15 3 -3
 BITMAP
-0020
-0110
-1890
-0890
-1090
-1090
-2CF0
-4690
-8090
-0C10
-0410
-07F0
-0410
-0410
-07F0
-0410
+0060
+FE20
+0420
+0420
+FE20
+4020
+40A0
+5F20
+3060
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C0DB
-ENCODING 49371
+STARTCHAR uniB9BF
+ENCODING 47551
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 13 15 2 -2
 BITMAP
 0030
-0190
-0090
-0890
-1890
-1090
-28F0
-4690
-8290
-0110
+0010
+FE10
+0410
+0410
+FE10
+4010
+4050
+4790
+7910
 0080
 0180
-0360
+0260
 0410
-0808
-1000
+1808
 ENDCHAR
-STARTCHAR C0DC
-ENCODING 49372
+STARTCHAR uniB9C1
+ENCODING 47553
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 11 15 3 -2
 BITMAP
-0030
-0190
-0890
-0890
-1090
-2890
-44F0
-8290
-0090
-0090
-0C20
-0460
+0060
+0020
+FE20
+0220
+0420
+FE20
+4020
+40E0
+4F20
+7120
+06C0
+0820
+0820
 0C60
-1290
-2108
-4000
+07C0
 ENDCHAR
-STARTCHAR C0DD
-ENCODING 49373
+STARTCHAR uniB9C8
+ENCODING 47560
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-0030
-0110
-1090
-0890
-0890
-1090
-28F0
-4490
-8290
-0090
-0360
-0410
-0410
-0630
-03E0
+00C0
+0040
+0040
+0040
+FC40
+8440
+8440
+8478
+8840
+FC40
+8040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C0E4
-ENCODING 49380
+STARTCHAR uniB9C9
+ENCODING 47561
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-00E0
+0060
 0020
-1020
-0C20
-0820
-183C
-1820
-2420
+FE20
 4220
-812C
-0030
+4220
+423C
+4420
+7E20
+4000
+3FE0
 0020
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR C0E5
-ENCODING 49381
+STARTCHAR uniB9CC
+ENCODING 47564
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0060
 0020
-0820
-0824
-1838
-3820
-4620
-833C
-0020
-3FE0
-0020
 0020
-0020
-0020
+FE20
+4220
+4220
+4438
+7E20
+4020
 0020
+3820
+0800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR C0E8
-ENCODING 49384
+STARTCHAR uniB9CE
+ENCODING 47566
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-1820
-0C20
-083C
-1820
-2420
-4320
-812C
-0030
-3020
-0820
+FE20
+4220
+422C
+4230
+7E20
+4000
+00C0
+63F0
+20E0
+2110
+2510
+3910
+00E0
+ENDCHAR
+STARTCHAR uniB9CF
+ENCODING 47567
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
+BITMAP
+00C0
+0040
+0040
+FC40
+8440
+8448
+8870
+FC40
+8040
+0000
+3FC0
+1000
+1000
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniB9D0
+ENCODING 47568
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+00C0
+0020
+FE20
+4220
+4220
+4420
+4438
+7E20
+4020
+1FE0
+0020
+1FE0
 0800
-0810
+0800
 0FF0
 ENDCHAR
-STARTCHAR C0EC
-ENCODING 49388
+STARTCHAR uniB9D1
+ENCODING 47569
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 3 -2
 BITMAP
-0030
-0010
-0410
-0410
-0C1E
-1A10
-1110
-609E
-8010
-0FF0
-0010
-0FF0
-0400
-0400
-07F8
+00C0
+0040
+FC40
+8440
+8458
+8860
+FC40
+8040
+0000
+FBC0
+0840
+D840
+6040
+4440
+7840
 ENDCHAR
-STARTCHAR C0F4
-ENCODING 49396
+STARTCHAR uniB9D2
+ENCODING 47570
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+FE20
+4220
+4224
+4238
+4420
+7E20
+4400
+3DF0
+0520
+7D20
+2120
+23F0
+3D00
+ENDCHAR
+STARTCHAR uniB9D8
+ENCODING 47576
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
 0060
 0020
-1820
-0C24
-0838
-1820
-2620
-413C
-8020
+0020
+FE20
+4220
+423C
+4220
+7E20
+4020
 0000
-1FE0
-0820
+0FE0
 0820
 0840
+0840
 0FE0
 0800
 ENDCHAR
-STARTCHAR C0F5
-ENCODING 49397
+STARTCHAR uniB9D9
+ENCODING 47577
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0060
+00E0
 0020
-0820
-082C
-1030
-2C20
+FE20
+4220
+4220
 423C
-8120
-0000
+4420
+7E20
+4020
 1820
 0820
 0FE0
@@ -108138,950 +110980,951 @@
 0FE0
 0820
 ENDCHAR
-STARTCHAR C0F7
-ENCODING 49399
+STARTCHAR uniB9DB
+ENCODING 47579
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 3 -2
+BITMAP
+00C0
+0040
+FC40
+8440
+8440
+8878
+FC40
+8040
+0240
+0300
+0300
+04C0
+0820
+3010
+ENDCHAR
+STARTCHAR uniB9DD
+ENCODING 47581
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 3 -2
+BITMAP
+00C0
+0040
+0040
+FC40
+8440
+847C
+8440
+FC40
+8040
+0100
+0780
+0840
+0840
+0C40
+0780
+ENDCHAR
+STARTCHAR uniB9DE
+ENCODING 47582
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0060
+0020
+FE20
+4220
+4220
+423C
+7E20
+4020
+0030
+1FC0
+0300
+06C0
+0830
+3000
+ENDCHAR
+STARTCHAR uniB9E1
+ENCODING 47585
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-1820
-082C
-1030
-3820
-2620
+FE20
+4220
+4220
 423C
-8020
-01A0
-0180
-0180
-0260
-0410
-1808
+4220
+7E20
+4000
+0FE0
+0800
+0FE0
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR C0F9
-ENCODING 49401
+STARTCHAR uniB9E3
+ENCODING 47587
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-0C20
-0820
-083C
-1820
-2620
-4224
-8038
-00A0
-0340
-0420
-0420
-0660
-03C0
+FE20
+4220
+422C
+4230
+7E20
+4000
+0380
+0010
+3FE0
+0180
+0640
+0440
+0780
 ENDCHAR
-STARTCHAR C100
-ENCODING 49408
+STARTCHAR uniB9E4
+ENCODING 47588
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 11 15 3 -2
 BITMAP
-0018
-00C8
-0048
-1848
-0C48
-0878
-1848
-1848
-2648
-4278
-8048
-0048
-0048
-0048
-0008
+0080
+0260
+0120
+0120
+F920
+8920
+8920
+8920
+89E0
+F920
+8120
+0120
+0120
+0120
+0020
 ENDCHAR
-STARTCHAR C104
-ENCODING 49412
+STARTCHAR uniB9E5
+ENCODING 47589
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 11 16 3 -3
 BITMAP
-0018
-00C8
-0448
-0448
-0878
-1448
-1248
-6378
-8048
-0048
-0C48
-0400
-0400
-07FC
+0060
+0220
+0120
+F920
+8920
+8920
+89E0
+F920
+8120
+0120
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C108
-ENCODING 49416
+STARTCHAR uniB9E8
+ENCODING 47592
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
+BITMAP
+0040
+0020
+0320
+0120
+F920
+8920
+8920
+89E0
+F920
+8120
+0120
+3120
+1000
+1000
+1FF0
+ENDCHAR
+STARTCHAR uniB9EC
+ENCODING 47596
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
 0030
-0190
-1090
-0890
-18F0
-1090
-28F0
+0110
+0090
+FC90
 4490
-8080
-1FE0
-0020
-1FE0
-0800
-0800
+4490
+44F0
+7C90
+4090
+0FF0
+0010
 0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR C110
-ENCODING 49424
+STARTCHAR uniB9F4
+ENCODING 47604
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
-0110
+0030
+0190
 0090
-1890
-08F0
-1090
-2890
+FC90
+4490
+4490
 44F0
-8490
+7C90
+4090
 0090
 0FF0
 0410
 0420
 0420
-07F0
-0400
+07C0
 ENDCHAR
-STARTCHAR C115
-ENCODING 49429
+STARTCHAR uniB9F5
+ENCODING 47605
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 16 3 -3
+BITMAP
+0040
+0060
+0120
+F920
+8920
+8920
+89E0
+F920
+8120
+1820
+0820
+0FE0
+0820
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniB9F7
+ENCODING 47607
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0060
+0220
+0120
+F920
+8920
+8920
+89E0
+F920
+8120
+0320
+0100
+0280
+0440
+0820
+3010
+ENDCHAR
+STARTCHAR uniB9F8
+ENCODING 47608
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
 0030
 0110
-1090
-0890
-10F0
-1090
-2890
-44F0
-8090
 0090
-0340
-0420
+FE90
+4490
+4490
+44F0
+7C90
+4090
+08F0
 0420
-0660
-03C0
+0C60
+1A60
+2298
+4108
 ENDCHAR
-STARTCHAR C11C
-ENCODING 49436
+STARTCHAR uniB9F9
+ENCODING 47609
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-1010
-0810
-0810
-1010
-30F0
-2810
-4610
-8210
-0010
-0010
-0010
-0010
-0010
+0090
+0090
+FC90
+4490
+44F0
+4490
+4490
+7C10
+4080
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR C11D
-ENCODING 49437
+STARTCHAR uniB9FA
+ENCODING 47610
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0038
-0808
-0408
-0408
-08F8
-1408
-2308
-4108
-8008
-1FF0
-0810
-0010
-0010
-0010
-0010
+0030
+0090
+0090
+FE90
+4490
+44F0
+4490
+7C90
+4090
+0000
+3FF0
+0100
+0300
+04C0
+0830
+7000
 ENDCHAR
-STARTCHAR C11E
-ENCODING 49438
+STARTCHAR uniBA00
+ENCODING 47616
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-1010
-0C10
-0810
-18F0
-1410
-2210
-C210
+0060
+0020
+0020
+FE20
+4220
+423C
+4220
+4420
+7E20
+403C
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniBA01
+ENCODING 47617
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+0020
+0020
+FE20
+4238
+4220
+4420
+7E3C
+4020
 0000
-7DF0
-0410
-0410
-0410
-0410
-0410
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C11F
-ENCODING 49439
+STARTCHAR uniBA08
+ENCODING 47624
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 13 15 3 -2
 BITMAP
-0030
-0810
-0810
-0810
-1010
-2CF0
-4610
-8210
-00D0
-3C60
-0440
-04A0
-0498
-0508
+00C0
+0040
+0040
+FC58
+8460
+8440
+8848
+FC70
+8000
+3FC0
+0040
+0040
+1FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR C120
-ENCODING 49440
+STARTCHAR uniBA15
+ENCODING 47637
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+0020
+FE20
+423C
+4220
+4220
+7E2C
+4030
+0100
+06C0
+0820
+0820
+0C60
+07C0
+ENDCHAR
+STARTCHAR uniBA38
+ENCODING 47672
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+00E0
+0020
+0020
+0020
+FE20
+8420
+87E0
+8420
+8420
+FC20
+8020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniBA39
+ENCODING 47673
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0060
+0010
+0010
+FF10
+4210
+43F0
+4210
+7E10
+4010
+0010
+3FE0
+1020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniBA3C
+ENCODING 47676
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0030
+0070
 0010
-0810
-0C10
-0810
-18F0
-2410
+0010
+FF10
 4210
-8110
+43F0
+4210
+7E10
+4010
 0010
 0010
-1800
-0800
-0800
-0FF8
+0C00
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR C123
-ENCODING 49443
+STARTCHAR uniBA40
+ENCODING 47680
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
+0020
 0010
-0C10
-0C10
-0830
-18D0
-2410
+FF10
 4210
-8010
+43F0
+4390
+4210
+7E10
+4010
+1FE0
 0020
 1FE0
 0800
 0800
-0800
-0FF0
-ENDCHAR
-STARTCHAR C124
-ENCODING 49444
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0018
-0008
-0408
-0408
-08F8
-1C08
-3308
-4108
-8000
-0FF0
-0010
 0FF0
-0400
-0400
-07F8
 ENDCHAR
-STARTCHAR C126
-ENCODING 49446
+STARTCHAR uniBA42
+ENCODING 47682
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0070
+0020
 0010
-0810
-0810
-1810
-18F0
-2410
-4610
-8210
-0000
-7DF0
+FF10
+4210
+43F0
+4390
+4210
+7E10
+4010
+3DE0
 0520
 7D20
 2120
-3DE0
-0100
-ENDCHAR
-STARTCHAR C127
-ENCODING 49447
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 16 1 -3
-BITMAP
-0018
-0008
-0608
-0408
-0CF8
-0C08
-1308
-2108
-C000
-1F48
-0148
-0178
-0E48
-08C8
-0F78
-0048
+23E0
+3D00
 ENDCHAR
-STARTCHAR C12C
-ENCODING 49452
+STARTCHAR uniBA48
+ENCODING 47688
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 11 16 3 -3
 BITMAP
-0038
-0008
-0608
-0408
-04F8
-0A08
-1108
-6088
-8008
-0000
-0FF0
-0410
-0410
-0420
-07F0
-0400
+00C0
+0020
+0020
+FE20
+8420
+87E0
+8420
+FC20
+8020
+0020
+1FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR C12D
-ENCODING 49453
+STARTCHAR uniBA49
+ENCODING 47689
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0030
+0020
 0010
-0C10
-0810
-09F0
-1810
-2410
+FF10
 4210
-8000
-1C30
+43F0
+4390
+4210
+7E10
+4010
+0C10
 0410
 07F0
 0410
-0410
 07F0
 0410
 ENDCHAR
-STARTCHAR C12F
-ENCODING 49455
+STARTCHAR uniBA4B
+ENCODING 47691
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 3 -2
 BITMAP
-0018
-0008
-0608
-0408
-0CF8
-0C08
-1308
-2108
-C008
-00C8
-0040
-00C0
-0130
-0208
-0C04
+00E0
+0020
+0020
+FE20
+8620
+85E0
+8420
+FE20
+8020
+0620
+0320
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR C130
-ENCODING 49456
+STARTCHAR uniBA4D
+ENCODING 47693
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-1010
-0810
-0810
-19F0
-3410
-6610
-8210
-0000
+00E0
+0020
+0020
+FE20
+8420
+87E0
+8420
+FC20
+8020
+0120
+06C0
 0820
-0420
+0820
 0C60
-1250
-2088
-4100
+07C0
 ENDCHAR
-STARTCHAR C131
-ENCODING 49457
+STARTCHAR uniBA4E
+ENCODING 47694
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 16 3 -3
 BITMAP
-0030
-0010
-0810
-0C10
-09F0
-1810
-2410
-4210
-8010
-0080
-0360
-0410
-0410
-0630
-01E0
+0180
+00C0
+0040
+FC40
+8440
+87C0
+8840
+FC40
+8040
+0060
+7F80
+0200
+0500
+18C0
+2020
+4000
 ENDCHAR
-STARTCHAR C136
-ENCODING 49462
+STARTCHAR uniBA53
+ENCODING 47699
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-0008
-0608
-0408
-0CF8
-0A08
-1108
-6188
-8000
-0FF8
-0040
-0220
-0220
-0040
-1FFC
+0060
+0010
+FF10
+4210
+43F0
+43D0
+4210
+7E10
+4010
+03D0
+1FF8
+0100
+06C0
+0440
+03C0
 ENDCHAR
-STARTCHAR C138
-ENCODING 49464
+STARTCHAR uniBA54
+ENCODING 47700
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
 0018
-0088
+00C8
 0048
-0848
-0C48
-0848
-1BC8
-1848
+FE48
+2248
+2248
+23C8
+2248
 2448
-4248
-8048
+3E48
+2048
 0048
 0048
 0048
 0008
 ENDCHAR
-STARTCHAR C139
-ENCODING 49465
+STARTCHAR uniBA55
+ENCODING 47701
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 16 3 -3
 BITMAP
-0030
-0110
-0090
-0890
-1890
-1390
-2890
-4490
-8490
-0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+0060
+0220
+0120
+F920
+8920
+8F20
+9120
+F920
+8120
+0100
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C13C
-ENCODING 49468
+STARTCHAR uniBA58
+ENCODING 47704
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 14 2 -1
 BITMAP
 0030
-0110
+0010
 0090
-0890
-0890
-1090
-2B90
+FC90
 4490
-8490
-0090
-0090
-0890
-0800
+4490
+4790
+4490
+7C90
+4090
+1890
+0880
 0800
 0FF8
 ENDCHAR
-STARTCHAR C140
-ENCODING 49472
+STARTCHAR uniBA5C
+ENCODING 47708
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0030
-0110
+0060
+01B0
 0090
-0890
-0890
-1790
-2890
+FC90
 4490
-8480
-0FF0
-0010
-0010
+4790
+4490
+7C90
+4090
+0F70
+0020
 0FF0
 0400
+0400
 07F8
 ENDCHAR
-STARTCHAR C148
-ENCODING 49480
+STARTCHAR uniBA64
+ENCODING 47716
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0110
+0060
+01B0
 0090
-0890
-1890
-1790
-2890
+FC90
 4490
-8090
-0000
-07F0
+4790
+4490
+4490
+7C90
+4010
+0FF0
+0410
 0420
 0420
-07F0
-0400
+07C0
 ENDCHAR
-STARTCHAR C149
-ENCODING 49481
+STARTCHAR uniBA65
+ENCODING 47717
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0190
-1090
-0890
-1890
-1790
-2890
+0060
+0130
+0090
+FC90
 4490
-8480
-0C10
+4790
+4890
+7C90
+4090
+08B0
 0410
 07F0
 0410
 07F0
 0410
 ENDCHAR
-STARTCHAR C14B
-ENCODING 49483
+STARTCHAR uniBA67
+ENCODING 47719
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0110
 0090
-1890
-1890
-1090
-3390
+0090
+FC90
+4490
+4790
+4490
 4890
-8490
-0210
-0180
+7C90
+4110
+0080
 0180
 0240
 0430
-1810
+1808
 ENDCHAR
-STARTCHAR C14C
-ENCODING 49484
+STARTCHAR uniBA68
+ENCODING 47720
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-00C8
-1848
-0448
-0848
-1BC8
-1448
-2248
-C248
-0430
-0210
-0210
-0528
-08C4
-1086
+0060
+01B0
+0090
+FC90
+4490
+4790
+4890
+7C90
+4090
+0060
+0420
+0420
+0A50
+1088
+6100
 ENDCHAR
-STARTCHAR C14D
-ENCODING 49485
+STARTCHAR uniBA69
+ENCODING 47721
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0190
-1090
-0890
-1090
-1390
-2C90
+0060
+01B0
+0090
+FC90
 4490
-8090
+4790
+4890
+7C90
+4090
 0090
 0360
 0410
 0410
 0630
 03E0
-ENDCHAR
-STARTCHAR C154
-ENCODING 49492
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0070
-0010
-1010
-0810
-09F0
-1010
-1810
-2430
-44D0
-8210
-0010
-0010
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR C155
-ENCODING 49493
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0018
-0808
-0408
-0478
-0C08
-1C08
-13F8
-6108
-8008
-0FF8
-0008
-0008
-0008
-0008
-0008
-ENDCHAR
-STARTCHAR C158
-ENCODING 49496
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0070
-0010
-0810
-09F0
-1810
-1010
-2810
-46F0
-8210
-0010
-1C10
-0400
-0400
-0400
-07FC
-ENDCHAR
-STARTCHAR C15C
-ENCODING 49500
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0070
-1010
-0810
-09F0
-1010
-2C10
-4610
-82F0
-0010
-1FE0
-0020
-1FE0
-0800
-0800
-0FF8
-ENDCHAR
-STARTCHAR C164
-ENCODING 49508
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0038
-0008
-0408
-0478
-0808
-1408
-2308
-4178
-8008
-0000
-03F8
-0208
-0208
-03F8
-0200
 ENDCHAR
-STARTCHAR C165
-ENCODING 49509
+STARTCHAR uniBA70
+ENCODING 47728
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
 0010
-0C10
-0C10
-08F0
-1810
-2410
-46F0
-8210
-0C20
-0420
-07E0
-0420
-0420
-07E0
-0420
-ENDCHAR
-STARTCHAR C167
-ENCODING 49511
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
-BITMAP
-0018
-0008
-0408
-0478
-0808
-1C08
-13F8
-2108
-C008
-0088
-0080
-01C0
-0330
-0408
-1804
-ENDCHAR
-STARTCHAR C168
-ENCODING 49512
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
-BITMAP
-0038
-0C08
-0608
-04F8
-0C08
-1C08
-32F8
-4108
-8008
-0410
-0610
-0630
-0928
-1144
-2084
-ENDCHAR
-STARTCHAR C169
-ENCODING 49513
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0018
-0008
-0608
-04F8
-0C08
-0C08
-12F8
-2108
-C008
-0040
-01B0
-0208
-0208
-0318
-01F0
+0010
+FF10
+43F0
+4210
+4210
+4210
+43F0
+7E10
+4010
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C170
-ENCODING 49520
+STARTCHAR uniBA71
+ENCODING 47729
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-00C8
-1848
-0C48
-0BC8
-0848
-1848
-2448
-47C8
-8248
-0048
-0048
-0048
-0008
+0030
+0010
+FE10
+43F0
+4210
+4210
+4210
+7EF0
+4010
+0010
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C174
-ENCODING 49524
+STARTCHAR uniBA74
+ENCODING 47732
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0010
-0190
-0890
-0F90
-1090
-1890
-2F90
-4490
-8090
-0090
-0890
-0800
-0800
-0FF8
+00E0
+0020
+0020
+FE20
+85E0
+8420
+87E0
+FC20
+8020
+0020
+2020
+1000
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR C178
-ENCODING 49528
+STARTCHAR uniBA78
+ENCODING 47736
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
+0020
 0010
-0190
-1890
-0890
-1390
-3890
-4F90
-8480
+FE10
+43F0
+43F0
+4210
+4210
+7EF0
+4010
 1FE0
 0020
 1FE0
@@ -109089,822 +111932,654 @@
 0800
 0FF0
 ENDCHAR
-STARTCHAR C185
-ENCODING 49541
+STARTCHAR uniBA83
+ENCODING 47747
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
+0010
+FF10
+43F0
+4210
+4210
+4210
+7EF0
+4010
 0110
-2090
-1890
-1790
-3090
-2890
-4F90
-8490
-0090
-0360
-0410
-0410
-0630
-03E0
+0110
+0380
+0660
+0810
+3008
 ENDCHAR
-STARTCHAR C18C
-ENCODING 49548
+STARTCHAR uniBA84
+ENCODING 47748
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 0
+BBX 12 15 3 -2
 BITMAP
-0300
-0180
-0300
-0300
-04E0
-1818
-2004
-0200
-0100
-0100
-0100
-FFFE
+0040
+0020
+FE20
+87E0
+8420
+8420
+8420
+FDE0
+8020
+00A0
+1840
+10C0
+3CC0
+4530
+8610
 ENDCHAR
-STARTCHAR C18D
-ENCODING 49549
+STARTCHAR uniBA85
+ENCODING 47749
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 11 15 3 -2
 BITMAP
-0300
-0180
-0300
-04F0
-180C
-2300
-0100
-0100
-FFFE
-0000
-3FE0
-0020
-0020
-0020
+00C0
+0060
 0020
+FC20
+87E0
+8420
+8660
+FDA0
+8020
+0100
+0680
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR C18E
-ENCODING 49550
+STARTCHAR uniBA87
+ENCODING 47751
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 11 16 3 -3
 BITMAP
-0400
-0300
-0200
-0580
-1878
-6200
-0200
-FFFC
-0000
+0040
+0020
+FE20
+87E0
+8420
+8420
+FDE0
+8020
+0F20
 0000
-FBE0
-0820
-0820
-0820
-0820
+7FE0
+0200
+0500
+08C0
+3020
+4000
 ENDCHAR
-STARTCHAR C190
-ENCODING 49552
+STARTCHAR uniBA8C
+ENCODING 47756
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0200
-0180
-0100
-0380
-0C78
-1204
-2100
-0100
-FFFE
-0000
-1000
-0800
-0800
-0810
-07F8
+0030
+0190
+0050
+0050
+FE50
+47D0
+4450
+4450
+47D0
+7C50
+4050
+0050
+0050
+0050
+0010
 ENDCHAR
-STARTCHAR C194
-ENCODING 49556
+STARTCHAR uniBAA8
+ENCODING 47784
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 10 1 0
 BITMAP
-0200
-0180
+0FF0
+0810
+0810
+0810
+0FF0
+0800
 0100
-06C0
-0838
-3100
 0100
+0100
 FFFE
-0000
-1FE0
-0020
-0020
-0FE0
-0800
-0FF0
 ENDCHAR
-STARTCHAR C196
-ENCODING 49558
+STARTCHAR uniBAA9
+ENCODING 47785
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0200
-0300
-0700
-08F0
-3008
-4200
+1FE0
+1020
+1040
+1040
+1FC0
+1200
 0200
 FFFC
 0000
-0000
-7DF0
-0910
-6D20
-3120
-3DF0
-0100
+7FC0
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C19C
-ENCODING 49564
+STARTCHAR uniBAAB
+ENCODING 47787
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0200
-0180
-0300
-06C0
-0838
-3100
-0100
-FFFE
-0000
-0000
 1FE0
 0820
 0820
+0820
 0FE0
-0800
+0900
+FFFE
+0000
+0460
+3C20
+0460
+0450
+0488
+0500
 ENDCHAR
-STARTCHAR C19D
-ENCODING 49565
+STARTCHAR uniBAAC
+ENCODING 47788
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 12 2 -1
 BITMAP
-0600
-0200
-0700
-08F0
-3408
-C200
-0200
-FFFC
-0000
-3040
-1040
-1FC0
+1FE0
+1020
 1040
 1FC0
-1040
+1200
+0200
+FFFC
+2000
+1000
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR C19F
-ENCODING 49567
+STARTCHAR uniBAB0
+ENCODING 47792
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 14 2 -2
 BITMAP
-0300
-0100
-0300
-04F0
-1B08
-2100
-0100
-FFFE
+3FE0
+1040
+1040
+1040
+1FC0
 0200
-0100
-0300
-06C0
-0830
-1010
-2000
+FFFC
+0000
+3FE0
+0040
+3FC0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR C1A1
-ENCODING 49569
+STARTCHAR uniBAB2
+ENCODING 47794
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0180
-0100
-0280
-0C78
-3300
-0100
-0100
-FFFE
-0100
-07C0
-0C60
+1FF0
 0820
-0C60
-07C0
-ENDCHAR
-STARTCHAR C1A5
-ENCODING 49573
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
-BITMAP
-0300
-0100
-0380
-0478
-180C
-6100
+0820
+0820
+0FE0
 0100
 FFFE
-2000
 0000
-0FF0
-0800
-0FE0
-0810
-0FF0
+3E00
+02F8
+3E90
+1090
+16F0
+0880
 ENDCHAR
-STARTCHAR C1A8
-ENCODING 49576
+STARTCHAR uniBAB8
+ENCODING 47800
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 14 2 -2
 BITMAP
-0030
-0010
-0C10
-0410
-0410
-0B90
-1050
-6C16
-8418
-0470
-0F90
-7010
-0010
-0010
-0010
+1FE0
+1020
+1040
+1040
+1FC0
+1200
+FFFC
+0000
+0000
+1FC0
+1040
+1040
+1FC0
+1000
 ENDCHAR
-STARTCHAR C1A9
-ENCODING 49577
+STARTCHAR uniBAB9
+ENCODING 47801
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 14 2 -2
 BITMAP
-0030
-0410
-0210
-0410
-1BD0
-2C12
-441C
-04F0
-FF10
+1FE0
+1020
+1040
+1040
+1FC0
+1200
+FFFC
 0000
-1FF0
-0010
-0010
-0010
-0010
-0010
+3040
+1040
+1FC0
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR C1AC
-ENCODING 49580
+STARTCHAR uniBABB
+ENCODING 47803
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 14 2 -2
 BITMAP
-0030
-0010
-0410
-0610
-0C10
-13D0
-6416
-0438
-8FD0
-7010
-0010
-0C10
-0400
-0400
-07FC
+1FE0
+1020
+1020
+1040
+1FE0
+1200
+0200
+FFFC
+4400
+0200
+0700
+0C80
+1060
+6010
 ENDCHAR
-STARTCHAR C1B0
-ENCODING 49584
+STARTCHAR uniBABD
+ENCODING 47805
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0610
-0610
-0E10
-11D0
-6416
-0418
-9FF0
-6000
-0FF0
-0010
-0FF0
-0400
-0400
-07FC
+1FF0
+0830
+0820
+0820
+0FE0
+0900
+01FE
+FF00
+0100
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR C1BD
-ENCODING 49597
+STARTCHAR uniBAC4
+ENCODING 47812
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 14 15 2 -2
 BITMAP
 0060
-0C20
-0C20
-1E20
-21E0
-C020
-0C38
-09E0
-FEA0
-0360
-0420
+0020
+7FA0
+2120
+2120
+2120
+2120
+1F3C
 0420
-0620
-03C0
+04E0
+FB20
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C1C4
-ENCODING 49604
+STARTCHAR uniBAC8
+ENCODING 47816
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0060
-0110
-1090
-0890
-1090
-3C90
-4290
-8090
-18F0
-1090
-1F90
-E090
-0090
-0090
-0010
-ENDCHAR
-STARTCHAR C1C8
-ENCODING 49608
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -2
-BITMAP
-0030
-0190
-0890
-1890
-2E90
-4090
-18F0
-1090
-1F90
-E090
-1890
-0810
+0020
+0020
+7F20
+2220
+2220
+3E20
+083C
+08E0
+FF20
+0020
+1820
 0800
-0FF8
+0800
+0FF0
 ENDCHAR
-STARTCHAR C1CC
-ENCODING 49612
+STARTCHAR uniBAD8
+ENCODING 47832
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-0098
-0848
-0448
-0848
-3748
-0878
-0848
-FFC8
-0FF0
-0010
-0010
-0FF0
-0400
-07F8
+0060
+7F20
+2220
+2220
+3E20
+283C
+09E0
+FE20
+0000
+0420
+0C60
+0A60
+1290
+6108
 ENDCHAR
-STARTCHAR C1D4
-ENCODING 49620
+STARTCHAR uniBAD9
+ENCODING 47833
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 14 2 -2
 BITMAP
+0060
 0020
-0098
-0048
-0448
-0848
-1748
-7878
-0848
-8FC8
-7000
-07F8
-0208
-0210
-0210
+7F20
+2120
+2220
+3F2C
+0830
+09E0
+F6A0
 03E0
-ENDCHAR
-STARTCHAR C1D7
-ENCODING 49623
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -2
-BITMAP
-0130
-0090
-0890
-1090
-2E90
-F0F0
-1090
-1790
-EB10
-0180
-0180
-0260
-0410
-1808
-ENDCHAR
-STARTCHAR C1D8
-ENCODING 49624
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 1 -2
-BITMAP
-0098
-0848
-0448
-0848
-1748
-7878
-0848
-FFC8
-2030
-0210
-0210
-0528
-08C4
-1084
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C1E0
-ENCODING 49632
+STARTCHAR uniBAFC
+ENCODING 47868
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
+0060
 0010
-0C10
+0010
+3F90
+2110
+2110
+2110
+3F10
 0410
-0810
-1710
-20D0
-4810
-8410
 0410
-07D0
-7810
+05F0
+FA10
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C1E4
-ENCODING 49636
+STARTCHAR uniBB00
+ENCODING 47872
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
 0010
-0410
-0410
-0E10
-31D0
-4410
+3F10
+2110
+2110
+3F10
+2410
 0430
-DFD0
-2010
+FFD0
 0010
-0C00
+0010
+1C00
 0400
 0400
 07F8
 ENDCHAR
-STARTCHAR C1E8
-ENCODING 49640
+STARTCHAR uniBB04
+ENCODING 47876
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0810
-0410
-0810
-1790
-6C10
+0010
+3F10
+2110
+2110
+3F10
 0410
-05F0
-FA10
+04F0
+FB10
 0000
-1FE0
+0FF0
 0020
-1FE0
-0800
-0FF8
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR C1F0
-ENCODING 49648
+STARTCHAR uniBB0D
+ENCODING 47885
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-1020
-0820
-1020
-2F20
-D820
-0820
-0BE0
-F420
-0000
-1FE0
-0820
-0840
-0840
-0F80
+0030
+0010
+3F10
+2110
+2110
+3F10
+0410
+0430
+FFD0
+0860
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR C1F1
-ENCODING 49649
+STARTCHAR uniBB0F
+ENCODING 47887
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 11 15 3 -2
 BITMAP
 0060
-1020
-0820
-1820
-2720
-D820
+0020
+7E20
+4220
+4220
+3C20
 0820
 0FE0
 F020
-1840
-0840
-0FC0
-0840
-0840
-0FC0
-0840
+0200
+0200
+0500
+08C0
+1020
+6000
 ENDCHAR
-STARTCHAR C1F3
-ENCODING 49651
+STARTCHAR uniBB11
+ENCODING 47889
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
+7F10
+2110
+2110
+3F10
+2410
+0470
+FB90
+0090
+0360
 0410
-0C10
-1F90
-2810
-C410
-04F0
-FF10
-0010
-0180
-0180
-0240
-0430
-1818
-ENDCHAR
-STARTCHAR C1FC
-ENCODING 49660
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 12 1 0
-BITMAP
-0200
-0180
-0100
-0380
-0478
-080C
-3000
-0860
-0420
-0420
-0420
-FFFF
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR C1FD
-ENCODING 49661
+STARTCHAR uniBB18
+ENCODING 47896
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 10 2 0
 BITMAP
-0200
-0100
-0100
-0380
-0C78
-1044
-2420
-0420
-FFFE
-0000
 3FE0
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR C200
-ENCODING 49664
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-0100
-0180
-0300
-06F0
-084C
-3440
-0440
-FFFE
-0000
+1020
+1020
+1020
+1FE0
 1000
-0800
-0800
-0800
-07F8
+1840
+0840
+0840
+FFFC
 ENDCHAR
-STARTCHAR C204
-ENCODING 49668
+STARTCHAR uniBB1C
+ENCODING 47900
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 13 2 -1
 BITMAP
-0200
-0300
-0700
-08F0
-3840
-4840
+3FE0
+1020
+1040
+1040
+1FE0
+08C0
+0880
 FFFC
-0000
-3FC0
-0040
-0040
-1FC0
+2000
 1000
-1FE0
+1000
+1020
+1FF0
 ENDCHAR
-STARTCHAR C20C
-ENCODING 49676
+STARTCHAR uniBB20
+ENCODING 47904
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 14 14 2 -2
 BITMAP
-0300
-0200
-0580
-1870
-2088
-4840
-0840
-FFFC
-0000
 1FE0
-0820
-0820
-0820
-0FE0
-0800
-ENDCHAR
-STARTCHAR C20D
-ENCODING 49677
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -3
-BITMAP
-0200
-0300
-0700
-08F0
-3848
-4840
-FFFC
-0000
-1840
-0840
-0FC0
-0840
-0840
-0FC0
-0840
+1040
+1040
+1040
+1F80
+0880
+FFFC
+0000
+3FC0
+0040
+3FC0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR C20F
-ENCODING 49679
+STARTCHAR uniBB29
+ENCODING 47913
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-0200
-0300
-0700
-08F0
-3848
-C840
-FFFC
-0000
-0600
-0200
-0700
-0CC0
+3FE0
 1060
-2010
+1040
+1040
+1FC0
+1080
+0880
+FFFC
+3040
+1040
+1FC0
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR C211
-ENCODING 49681
+STARTCHAR uniBB2B
+ENCODING 47915
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-0100
-0180
-0380
-0478
-1C24
-6420
-FFFE
-0000
-03C0
-0660
-0420
-0420
-0660
-03C0
+1FE0
+1020
+1040
+1040
+1FC0
+10C0
+0888
+FF7C
+0400
+0300
+0300
+04C0
+1820
+2010
 ENDCHAR
-STARTCHAR C218
-ENCODING 49688
+STARTCHAR uniBB34
+ENCODING 47924
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 15 1 -3
 BITMAP
-0200
-0180
-0100
-02C0
-0C3C
-3000
+1FF0
+0810
+0820
+0820
+0FE0
+0800
 0000
-83FE
-FF00
+FFFE
 0100
 0100
 0100
@@ -109913,307 +112588,406 @@
 0100
 0100
 ENDCHAR
-STARTCHAR C219
-ENCODING 49689
+STARTCHAR uniBB35
+ENCODING 47925
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0300
-0100
-0300
-04F0
-180C
-6000
-0004
+1FE0
+0820
+0820
+0820
+0FE0
+0800
 FFFE
 0100
 0100
-21E0
-1E20
+1FE0
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR C21C
-ENCODING 49692
+STARTCHAR uniBB36
+ENCODING 47926
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 14 2 -2
 BITMAP
+7FC0
+1040
+1040
+1FC0
+1000
+0000
+FFFC
 0200
-0180
+0200
+7DE0
+0420
+0420
+0420
+0420
+ENDCHAR
+STARTCHAR uniBB38
+ENCODING 47928
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 2 -1
+BITMAP
+3FE0
+1040
+1040
+1040
+1FC0
+1004
+FFFE
 0100
-0280
-0C78
+0100
+3100
+1100
 1000
-2004
+0FF0
+ENDCHAR
+STARTCHAR uniBB3B
+ENCODING 47931
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1FF0
+0820
+0820
+0820
+0FE0
+0800
 FFFE
 0100
-0100
 0100
-0900
-0900
+0FF0
 0800
-07F8
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR C21F
-ENCODING 49695
+STARTCHAR uniBB3C
+ENCODING 47932
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0400
-0300
-0200
-0580
-1870
-6000
-0000
+3FE0
+1040
+1040
+1040
+1FC0
+1000
 FFFC
 0200
-0240
+3E40
+01C0
 3FC0
 1000
 1000
-1000
 1FE0
 ENDCHAR
-STARTCHAR C220
-ENCODING 49696
+STARTCHAR uniBB3D
+ENCODING 47933
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0300
-0180
-0300
-04F8
-1808
-2004
+1FF0
+0820
+0820
+0820
+0FE0
+0800
 FFFE
 0100
-0100
-0EE0
-0020
-1FE0
-0800
-0FF0
+01F0
+1E10
+2410
+1810
+1310
+1C10
 ENDCHAR
-STARTCHAR C228
-ENCODING 49704
+STARTCHAR uniBB3E
+ENCODING 47934
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 14 2 -2
 BITMAP
-0300
-0100
-0300
-0CF8
+7FE0
+1040
+1040
+1040
+1FC0
 1000
-2000
-0000
+FFFC
+0200
+3DF0
+0590
+6D90
+30A0
+22F0
+3C00
+ENDCHAR
+STARTCHAR uniBB44
+ENCODING 47940
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
+BITMAP
+1FF0
+0820
+0820
+0820
+0FE0
+0800
 FFFE
 0100
 0100
-1960
-0EA0
+1F60
+08A0
 0820
-0840
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR C229
-ENCODING 49705
+STARTCHAR uniBB45
+ENCODING 47941
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 15 1 -3
 BITMAP
-0300
-0100
-0380
-0478
-1804
-6000
-0000
+1FE0
+0820
+0820
+0840
+0FE0
+0804
 FFFE
 0100
-1960
-0820
+1920
+0920
 0FE0
 0820
 0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR C22B
-ENCODING 49707
+STARTCHAR uniBB47
+ENCODING 47943
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0180
-0100
-06E0
-081C
-3000
-0000
+1FE0
+0820
+0820
+0820
+0FE0
+0804
 FFFE
 0100
 0100
 0100
-0100
-0280
-0470
-1818
+0300
+02C0
+0C30
+1010
 ENDCHAR
-STARTCHAR C22D
-ENCODING 49709
+STARTCHAR uniBB49
+ENCODING 47945
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0300
-0180
-0100
-02C0
-0C3C
-3000
-0004
+1FE0
+0820
+0820
+0820
+0FE0
+0804
 FFFE
 0100
-07C0
-0C60
+0100
+06C0
 0820
 0820
-0460
-03C0
-ENDCHAR
-STARTCHAR C22F
-ENCODING 49711
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-0400
-0200
-0600
-0DC0
-3038
-C008
-0FFC
-FA00
-0200
-0F00
-03F0
-7E00
-0200
-0580
-0860
-3010
+0C60
+07C0
 ENDCHAR
-STARTCHAR C231
-ENCODING 49713
+STARTCHAR uniBB4D
+ENCODING 47949
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0400
-0300
-0600
-0DE0
-1010
-E000
-0FFC
-FE00
-0200
 1FE0
-1000
-1000
-1FC0
-1000
-1FF0
+0820
+0820
+0840
+0FE0
+0804
+FFFE
+2100
+0160
+0E80
+0800
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR C232
-ENCODING 49714
+STARTCHAR uniBB4F
+ENCODING 47951
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0300
-0100
-0300
-04F8
-180C
-6004
-FFFE
+1FF0
+0820
+0820
+0FE0
+0800
+C7FE
+7F00
 0100
+03C0
+1FF8
 0100
-1FF0
-0040
-0440
-0040
-3FF8
+06C0
+0640
+03C0
 ENDCHAR
-STARTCHAR C234
-ENCODING 49716
+STARTCHAR uniBB50
+ENCODING 47952
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0410
-0C10
-1C10
-23D0
-C010
 0010
-0F90
-F810
-08F0
+7F10
+2110
+2110
+2210
+3F10
+2010
+0F10
+F9F0
+0810
 0810
 0810
 0810
 0010
 ENDCHAR
-STARTCHAR C248
-ENCODING 49736
+STARTCHAR uniBB54
+ENCODING 47956
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
+0010
+7F10
+2110
+2210
+3F10
+2010
+0190
+FE10
+04F0
+0010
+1800
+0800
 0810
-0610
-0C10
-3390
-4010
-0090
-FF30
-08D0
-0840
-0420
-0420
-0A50
-1288
-2108
+0FF8
 ENDCHAR
-STARTCHAR C250
-ENCODING 49744
+STARTCHAR uniBB58
+ENCODING 47960
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+7F10
+2110
+2210
+3F10
+2050
+FF90
+08F0
+0800
+1FF0
+0020
+1FF0
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniBB61
+ENCODING 47969
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0010
+7F10
+2110
+2210
+3F10
+2050
+FF90
+08F0
+0830
+0410
+07F0
+0410
+0410
+07F0
+0410
+ENDCHAR
+STARTCHAR uniBB63
+ENCODING 47971
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0060
+0030
+7F10
+2110
+2210
+3F10
+2010
+FF10
+0830
+09D0
+0190
+0100
+02C0
+0430
+1808
+ENDCHAR
+STARTCHAR uniBB6C
+ENCODING 47980
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0110
-1090
-0890
-1890
-3890
-4690
-8090
-0C90
+0090
+FC90
+4490
+4490
+4490
+7C90
+4C90
 F090
 1390
 1090
@@ -110221,1318 +112995,1711 @@
 0090
 0010
 ENDCHAR
-STARTCHAR C251
-ENCODING 49745
+STARTCHAR uniBB88
+ENCODING 48008
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-0098
-0848
-0448
-1848
-27C8
-C048
-FF48
-0BC8
-0848
-0FF8
-0408
-0008
-0008
-0008
-0008
+0010
+7F10
+2110
+2210
+2210
+3F10
+2010
+0F10
+F810
+0810
+0810
+0810
+0810
+0010
 ENDCHAR
-STARTCHAR C254
-ENCODING 49748
+STARTCHAR uniBB8C
+ENCODING 48012
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 14 3 -1
 BITMAP
+0060
 0020
-0110
-0090
-0C90
-1890
-2790
-C090
-0290
-7C90
-0B90
-0090
-0C10
-0400
-0400
-03F8
+7E20
+4220
+4420
+7E20
+4020
+0F20
+F820
+1020
+3020
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR C258
-ENCODING 49752
+STARTCHAR uniBB90
+ENCODING 48016
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0090
-1050
-0850
-1850
-2650
-C050
-FC50
-13D0
+0010
+7F10
+2110
+2210
+3E10
+2090
+FF10
+0810
+1FF0
+0010
+0020
+1FF0
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniBBA4
+ENCODING 48036
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -2
+BITMAP
+3FE0
+1040
+1040
+1040
+1FC0
+1000
+0000
+FFF8
+0880
+0880
+0880
+0880
+0880
+0880
+ENDCHAR
+STARTCHAR uniBBA8
+ENCODING 48040
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+1FE0
+1060
+1040
+1040
+1FE0
+1000
+FFFC
+0440
+0440
+0440
+3040
+1000
+1000
+1FF0
+ENDCHAR
+STARTCHAR uniBBAC
+ENCODING 48044
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+7FE0
+1040
+1040
+1040
+1FC0
+1000
+FFFC
+0880
+0880
+3FC0
+0040
+3FC0
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniBBB4
+ENCODING 48052
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
+BITMAP
+3FC0
+1040
+1040
+1040
+1FC0
+1000
+FFFC
+0880
+0880
+3FE0
+1040
+1040
+1040
+1FC0
+1000
+ENDCHAR
+STARTCHAR uniBBB7
+ENCODING 48055
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+3FE0
+1040
+1040
+1040
+1FC0
 1000
+FFFC
+0840
+0C40
+0A40
+0B40
+0480
+1860
+6010
+ENDCHAR
+STARTCHAR uniBBC0
+ENCODING 48064
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 10 1 0
+BITMAP
+1FF0
+0810
+0810
+0820
 0FF0
-0010
+0800
+0000
+0000
+0000
+FFFE
+ENDCHAR
+STARTCHAR uniBBC4
+ENCODING 48068
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+3FE0
+1040
+1040
+1040
+1FC0
+1008
+FFFC
+0000
+0000
+0000
+3000
+1000
+1000
+1FF0
+ENDCHAR
+STARTCHAR uniBBC8
+ENCODING 48072
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+0FE0
+0820
+0820
+0FE0
+0800
+0004
+FFFE
+0000
+0FE0
+0020
+1FE0
+0800
+0800
 0FF0
-0400
-07F8
 ENDCHAR
-STARTCHAR C260
-ENCODING 49760
+STARTCHAR uniBBD0
+ENCODING 48080
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-0098
-0848
-0448
-0848
-3748
-4048
-FF48
-0BC8
-0848
-07F8
-0210
-0210
-0210
-03F8
-0200
+1FF0
+0820
+0820
+0820
+0FE0
+0804
+FFFE
+0000
+0000
+0FE0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR C265
-ENCODING 49765
+STARTCHAR uniBBD3
+ENCODING 48083
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0010
-00C8
-0848
-0C48
-1C48
-6348
-0048
-FF48
-09C8
-0848
-01F0
-0318
-0208
-0318
-01F0
+1FF0
+0810
+0820
+0820
+0FF0
+0800
+0004
+FFFE
+0200
+0100
+0380
+0660
+0810
+1008
 ENDCHAR
-STARTCHAR C26C
-ENCODING 49772
+STARTCHAR uniBBF8
+ENCODING 48120
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-0C10
-0C10
-1C10
-2390
-C010
 0010
-0F90
-F810
-0810
-0810
-0810
-0810
+FF10
+4210
+4210
+4210
+4210
+4210
+7E10
+4010
 0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C26D
-ENCODING 49773
+STARTCHAR uniBBF9
+ENCODING 48121
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 11 15 3 -2
 BITMAP
-00C0
-1060
-0820
-1020
-6FA0
-8020
 0060
-3FA0
-C820
-0820
-3FE0
-0020
 0020
+FE20
+4220
+4220
+4220
+4420
+7E20
+4000
+7FC0
+0040
+0040
+0040
+0040
+0040
+ENDCHAR
+STARTCHAR uniBBFC
+ENCODING 48124
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0060
 0020
 0020
+FE20
+8420
+8420
+8420
+FC20
+8020
 0020
+7020
+1000
+1000
+1020
+1FF0
 ENDCHAR
-STARTCHAR C270
-ENCODING 49776
+STARTCHAR uniBBFF
+ENCODING 48127
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 14 2 -1
 BITMAP
 0030
-0810
-0410
-0810
-1790
-6010
-8010
-03D0
-FC10
-0810
-0810
-1800
+0010
+0010
+FF10
+4210
+4210
+4210
+7E10
+4000
+0020
+0FE0
 0800
-0810
+0800
 0FF0
 ENDCHAR
-STARTCHAR C274
-ENCODING 49780
+STARTCHAR uniBC00
+ENCODING 48128
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 14 2 -1
 BITMAP
 0030
-1010
-0C10
-1810
-2790
-C010
-0F90
-F810
-0810
-1FE0
-0020
+0010
+FF10
+4210
+4210
+4210
+7E10
+4010
+0000
+1FF0
 0020
-1FE0
+1FF0
 0800
 0FF0
 ENDCHAR
-STARTCHAR C27C
-ENCODING 49788
+STARTCHAR uniBC02
+ENCODING 48130
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 11 15 2 -3
 BITMAP
-0018
-0608
-0608
-0E08
-11E8
-2008
-0078
-FF88
-0408
-0400
-0FF8
-0208
-0210
-0210
-03F8
-0200
+0060
+FF20
+4220
+4220
+4220
+7E20
+4020
+0020
+3DE0
+0520
+6D20
+3120
+2120
+3DE0
+0100
 ENDCHAR
-STARTCHAR C27D
-ENCODING 49789
+STARTCHAR uniBC08
+ENCODING 48136
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 16 4 -3
+BITMAP
+00C0
+0040
+0040
+FC40
+8440
+8440
+8440
+FC40
+8040
+0000
+1FC0
+1040
+1080
+1080
+1FC0
+1000
+ENDCHAR
+STARTCHAR uniBC09
+ENCODING 48137
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 15 3 -2
 BITMAP
-0030
-0810
-0410
-0810
-1790
-6010
-00D0
-FF10
-0410
-0830
-0410
-07F0
-0410
-0410
-07F0
-0400
+0060
+0020
+FE20
+8220
+8620
+8620
+8420
+FE20
+8000
+1820
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C27F
-ENCODING 49791
+STARTCHAR uniBC0B
+ENCODING 48139
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
 0010
-0610
-0C10
-1B90
-6010
-0070
-FF90
-0410
-0510
-0480
+0010
+FF10
+4210
+4210
+4210
+7E10
+4010
+0110
+0080
 0180
-0260
-0410
+0240
+0430
 1808
 ENDCHAR
-STARTCHAR C281
-ENCODING 49793
+STARTCHAR uniBC0C
+ENCODING 48140
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-1820
+0030
+0010
+FF10
+4210
+4210
+4210
+7E10
+4010
+0000
+0860
 0C20
-1820
-27A0
-C020
-07E0
-F820
-0820
-0900
-07C0
-0C60
-0820
 0C60
-07C0
+1250
+2088
+4308
 ENDCHAR
-STARTCHAR C288
-ENCODING 49800
+STARTCHAR uniBC0D
+ENCODING 48141
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 2 -3
+BBX 10 15 4 -2
 BITMAP
-0200
-0300
-0600
-09E0
-3018
-C000
-0000
-FFFE
-0840
-0840
-0840
-0840
-0840
-0840
+00C0
 0040
+0040
+FC40
+8440
+8440
+8440
+FC40
+8040
+0200
+1D00
+1080
+1080
+1180
+0F00
 ENDCHAR
-STARTCHAR C289
-ENCODING 49801
+STARTCHAR uniBC0F
+ENCODING 48143
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -3
 BITMAP
-0600
-0300
-0300
-0500
-18F0
-6018
-0008
-FFF8
-0880
-0880
-3FC0
-0040
-0040
-0040
-0040
+0060
+FC20
+8420
+8420
+8420
+FC20
+8020
+0700
+0000
+7FF0
+0200
+0700
+08C0
+3020
+C000
 ENDCHAR
-STARTCHAR C290
-ENCODING 49808
+STARTCHAR uniBC11
+ENCODING 48145
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 11 14 3 -1
 BITMAP
-0400
-0300
-0200
-0500
-18F0
-6000
+0060
+0020
+FC20
+8420
+8420
+8420
+FC20
+8020
 0000
-FFFC
-0880
-0FC0
-1040
-3FC0
+1FE0
 1000
+1FC0
 1000
 1FE0
 ENDCHAR
-STARTCHAR C298
-ENCODING 49816
+STARTCHAR uniBC14
+ENCODING 48148
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 15 2 -2
 BITMAP
-0100
-0180
-0300
-04F8
-1800
-2000
-FFFE
-2420
-0420
-1FE0
-0820
-0840
-0840
-0FE0
-0800
+0060
+0020
+0620
+C220
+4220
+7E20
+4220
+423C
+4220
+7E20
+4220
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C29B
-ENCODING 49819
+STARTCHAR uniBC15
+ENCODING 48149
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0400
-0300
-0200
-0D80
-1070
-6000
+0060
+0420
+C220
+4220
+7E20
+422C
+4230
+7E20
+4220
 0000
-FFFC
-0840
-0C40
-0A40
-0F40
-0C80
-1060
-6010
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C29D
-ENCODING 49821
+STARTCHAR uniBC16
+ENCODING 48150
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-0200
-0300
-0600
-09F0
-3018
-4000
-FFFC
-0840
-0A40
-0DC0
-1040
-1040
-18C0
-0F80
+0060
+0020
+C220
+4220
+7E20
+423C
+4220
+7E20
+4200
+03E0
+3C20
+0420
+0420
+0420
+0420
 ENDCHAR
-STARTCHAR C2A4
-ENCODING 49828
+STARTCHAR uniBC17
+ENCODING 48151
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 11 2 0
+BBX 14 15 2 -2
 BITMAP
-0300
-0300
-0600
-0DC0
-1838
-2000
-4000
-0000
-0008
-FFFC
-4000
+0060
+0020
+C220
+4220
+7E20
+422C
+4230
+7E20
+4220
+00C0
+3C60
+0440
+04A0
+0498
+0508
 ENDCHAR
-STARTCHAR C2A5
-ENCODING 49829
+STARTCHAR uniBC18
+ENCODING 48152
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0300
-0100
-0300
-04F0
-180C
-6000
-0004
-FFFE
-2000
-0000
-3FE0
-0020
-0020
+0060
 0020
+0620
+C220
+4220
+7E20
+423C
+4220
+7E20
+4220
 0020
+1800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR C2A8
-ENCODING 49832
+STARTCHAR uniBC1B
+ENCODING 48155
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 14 15 2 -2
 BITMAP
-0100
-0180
-0300
-06F8
-180C
-6000
-0004
-FFFE
-1000
+0060
+0420
+C220
+4220
+7E20
+422C
+4230
+7E20
+4220
+0000
+1FE0
 0800
 0800
-0810
-0FF8
+0800
+07F0
 ENDCHAR
-STARTCHAR C2AC
-ENCODING 49836
+STARTCHAR uniBC1C
+ENCODING 48156
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-0300
-0180
-0300
-0CF8
-3004
-0004
-FFFE
-0000
-1FF0
+0060
+0020
+C220
+4220
+7E20
+423C
+4220
+7E20
+4200
+1FE0
 0020
+0020
 1FE0
-0800
 0800
-07F8
+0FF0
 ENDCHAR
-STARTCHAR C2AD
-ENCODING 49837
+STARTCHAR uniBC1D
+ENCODING 48157
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-0100
-0100
-0380
-0C78
-3000
-0004
-FFFE
-0000
-1FF0
-0210
-3610
-1810
-1310
-1C10
+0060
+0020
+C220
+4220
+7E24
+4238
+4220
+7E20
+4200
+7FE0
+0420
+0420
+3820
+2220
+3C20
 ENDCHAR
-STARTCHAR C2B4
-ENCODING 49844
+STARTCHAR uniBC1E
+ENCODING 48158
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 16 2 -3
 BITMAP
-0100
-0180
-0300
-06F8
-1804
-6000
-FFFE
+0060
+0020
+C220
+4220
+7E20
+422C
+4230
+7E20
+4220
 0000
+7FF0
+0520
+7D20
+2120
+2DE0
+1100
+ENDCHAR
+STARTCHAR uniBC1F
+ENCODING 48159
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0060
+C220
+4220
+7E20
+4224
+4238
+7E20
+4220
+7F20
+0520
+05E0
+3920
+23E0
+3D20
+ENDCHAR
+STARTCHAR uniBC24
+ENCODING 48164
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0030
+0010
+E110
+2110
+3F10
+211E
+2110
+3F10
+2110
 0000
-1FE0
+07F0
+0410
+0420
+07F0
+0400
+ENDCHAR
+STARTCHAR uniBC25
+ENCODING 48165
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+0020
+C220
+4220
+7E20
+423C
+4220
+7E20
+4200
+1020
+0820
+0FE0
 0820
 0820
 0FE0
-0800
+0820
 ENDCHAR
-STARTCHAR C2B5
-ENCODING 49845
+STARTCHAR uniBC27
+ENCODING 48167
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 14 15 2 -2
 BITMAP
-0600
-0300
-0600
-09F0
-3018
-C000
-FFFC
-0000
-3040
-1040
-1FC0
-1040
-1040
-1FC0
-1040
+0060
+0020
+0420
+C220
+4220
+7E20
+423C
+4220
+7E20
+4320
+0080
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR C2B7
-ENCODING 49847
+STARTCHAR uniBC29
+ENCODING 48169
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-0100
-0180
-0300
-06F0
-080C
-3000
-FFFE
-0000
-0300
-0180
-0380
+0060
+0420
+C220
+4220
+7E20
+423C
+4220
+7E20
+4220
+0080
+0340
+0420
+0420
 0660
-0818
-3008
+03C0
 ENDCHAR
-STARTCHAR C2B9
-ENCODING 49849
+STARTCHAR uniBC2D
+ENCODING 48173
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 13 2 -1
 BITMAP
-0300
-0180
-0300
-04F0
-180C
-6004
-FFFE
-2000
-0100
-06C0
-0820
-0820
-0460
-0380
+0060
+C220
+4220
+7E20
+4220
+423C
+7E20
+4220
+0FE0
+0800
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR C2DC
-ENCODING 49884
+STARTCHAR uniBC30
+ENCODING 48176
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
-0010
-0010
-0C10
-0810
-0810
-1810
-2410
-4310
-8110
-0010
-0010
-0010
-0010
+0030
 0010
+0190
+8490
+4490
+4490
+7C90
+4490
+44F0
+7C90
+4490
+0090
+0090
+0090
+0090
 ENDCHAR
-STARTCHAR C2DD
-ENCODING 49885
+STARTCHAR uniBC31
+ENCODING 48177
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0018
-0008
-0608
-0608
-0408
-0A08
-1188
-2048
-C008
+0070
+0130
+0090
+C490
+4490
+7C90
+44F0
+4490
+7C90
+4090
 3FF0
-0810
+1010
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C2E0
-ENCODING 49888
+STARTCHAR uniBC34
+ENCODING 48180
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0060
+0120
+1120
+8920
+8920
+F920
+89E0
+8920
+F920
+8920
+0120
+7020
+1000
+1000
+1FF0
+ENDCHAR
+STARTCHAR uniBC38
+ENCODING 48184
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0060
-0010
-0810
-0C10
-0810
-1410
-2210
-4110
-8090
-0010
-3010
-0800
+0090
+C490
+4490
+7C90
+44F0
+4490
+7C90
+4490
+1FF0
+0020
+1FE0
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR C2E3
-ENCODING 49891
+STARTCHAR uniBC40
+ENCODING 48192
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0010
-0C10
+0030
+0190
+0890
+C490
+4490
+7C90
+44F0
+4490
+7C90
+4490
+0FF0
 0410
-0810
-1410
-2210
-4110
-8010
-0000
-0FE0
-0400
-0400
+0410
+0420
+07F0
 0400
-07F8
 ENDCHAR
-STARTCHAR C2E4
-ENCODING 49892
+STARTCHAR uniBC41
+ENCODING 48193
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0018
-0008
-0608
-0608
-0408
-0B88
-10C8
-6008
-8000
-0FF8
+0020
 0010
-0FF8
-0400
-0400
-07FC
+0890
+C490
+4490
+7C90
+44F0
+4490
+7C90
+4C10
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR C2EB
-ENCODING 49899
+STARTCHAR uniBC43
+ENCODING 48195
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 3 -2
 BITMAP
-0018
-0408
-0208
-0408
-0E08
-1188
-2088
-C000
-3E70
-040C
-04F0
-1858
-1088
-1C88
-0070
+0060
+0320
+1920
+8920
+8920
+F920
+89E0
+8920
+F920
+8920
+0300
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR C2EC
-ENCODING 49900
+STARTCHAR uniBC44
+ENCODING 48196
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 13 16 2 -3
 BITMAP
-0018
-0008
-0608
-0608
-0408
-0A08
-1108
-2088
-C008
-0000
-0FF0
-0410
-0410
-0410
-07F0
-0400
+0030
+0190
+C490
+4490
+7C90
+4490
+44F0
+7C90
+4490
+0090
+0C60
+0C60
+0C60
+1298
+2108
+4000
 ENDCHAR
-STARTCHAR C2ED
-ENCODING 49901
+STARTCHAR uniBC45
+ENCODING 48197
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0C10
-0C10
-0810
-1410
-2310
-4110
-8000
-0C20
-0420
-07E0
-0420
-07E0
-0420
+0190
+0890
+C490
+4490
+7C90
+44F0
+4490
+7C90
+4490
+03E0
+0610
+0610
+0210
+01E0
 ENDCHAR
-STARTCHAR C2EF
-ENCODING 49903
+STARTCHAR uniBC49
+ENCODING 48201
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 14 2 -2
 BITMAP
-0030
-0010
-0810
-0810
-0810
-1410
-2210
-4110
-8010
-0090
-0080
-0180
-0360
-0410
-0808
+00B0
+C490
+4490
+7C90
+44F0
+4490
+7C90
+4490
+0020
+0FE0
+0800
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR C2F1
-ENCODING 49905
+STARTCHAR uniBC4C
+ENCODING 48204
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-0C10
-0C10
-0810
-1410
-2310
-4110
-8010
-0090
-0340
+0060
+0020
+0020
+0620
+C220
+423C
+7E20
+4220
+4220
+7E2C
+4230
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniBC4D
+ENCODING 48205
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
 0420
+C220
+4220
+7E3C
+4220
+4220
+7E3C
+4220
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniBC50
+ENCODING 48208
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
 0420
-0660
-03E0
+C220
+423C
+7E20
+4220
+4220
+7E3C
+4220
+1020
+0800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR C2F6
-ENCODING 49910
+STARTCHAR uniBC5D
+ENCODING 48221
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 14 14 2 -2
 BITMAP
-0030
+0060
+C220
+4220
+7E3C
+4220
+4220
+7E38
+4200
+1820
+0820
+0FE0
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniBC84
+ENCODING 48260
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0060
 0010
-0C10
-0810
-1810
-1410
-2210
-C110
-0000
-3FF0
-0040
-0440
-0490
-7FF8
+0410
+8210
+4210
+4210
+7E10
+43F0
+4210
+4210
+7E10
+4210
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C2F8
-ENCODING 49912
+STARTCHAR uniBC85
+ENCODING 48261
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0040
+0070
+0410
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4210
+0000
+3FE0
 0020
 0020
-2120
-3120
-2220
-5220
-9E24
-0538
-08A0
-10A0
-2020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C2F9
-ENCODING 49913
+STARTCHAR uniBC88
+ENCODING 48264
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 13 15 2 -2
 BITMAP
-0030
-0010
-1190
-0890
-1110
-2B16
-4698
-8450
-0850
-0000
-1FF0
-0810
-0010
-0010
-0010
+0070
 0010
+0610
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4210
+1010
+2810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C2FB
-ENCODING 49915
+STARTCHAR uniBC8B
+ENCODING 48267
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0110
-0890
-0990
-1910
-2696
-4658
-8850
-0000
-7C30
-0420
-0430
-0448
-048C
-0504
+0040
+0820
+8420
+8420
+FC20
+87E0
+8520
+8420
+FC20
+8020
+3FC0
+1000
+1000
+1020
+1FE0
 ENDCHAR
-STARTCHAR C2FC
-ENCODING 49916
+STARTCHAR uniBC8C
+ENCODING 48268
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0060
+0070
+0030
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4210
+1FE0
 0020
-2320
-1120
-3120
-3220
-4D2C
-85B0
-08A0
-1020
-1020
-0820
+0020
+1FE0
 0800
-0810
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR C300
-ENCODING 49920
+STARTCHAR uniBC8E
+ENCODING 48270
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 16 2 -3
 BITMAP
+0060
 0030
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4210
 0010
-1190
-0990
-1110
-2F16
-42D8
-8450
+7FF0
+0920
+3D20
+2120
+3DE0
+0100
+ENDCHAR
+STARTCHAR uniBC94
+ENCODING 48276
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0070
+0030
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4210
+0000
+0FE0
+0820
+0820
+0840
+0FE0
 0800
-1FF0
-0020
-0FF0
-0400
-0400
-07F8
 ENDCHAR
-STARTCHAR C308
-ENCODING 49928
+STARTCHAR uniBC95
+ENCODING 48277
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 1 -3
+BBX 12 16 2 -3
 BITMAP
+0070
 0030
-0010
-1890
-0890
-1110
-2910
-42DC
-8450
-0810
-1000
-0FF0
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4000
+0830
 0410
-0420
-0420
 07F0
-0400
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR C309
-ENCODING 49929
+STARTCHAR uniBC97
+ENCODING 48279
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0060
-0220
-1120
-1120
-3220
-4B2C
-84B0
-08A0
-1000
-1020
-0820
-0FE0
-0820
-0FE0
+0040
 0820
+8420
+8420
+FC20
+87E0
+8420
+8420
+FC20
+8220
+0320
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR C30C
-ENCODING 49932
+STARTCHAR uniBC99
+ENCODING 48281
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-3320
-1120
-2220
-3B2C
-4CB0
-88A0
-1020
-0820
+0030
+0410
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4210
+0090
+0340
 0420
-0C60
-1250
-2088
-4108
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C30D
-ENCODING 49933
+STARTCHAR uniBC9A
+ENCODING 48282
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0010
-1190
-0890
-1110
-2910
-469E
-8450
-0810
-1050
-01A0
-0210
-0210
-0330
-01E0
+0060
+0410
+C210
+4210
+7E10
+43F0
+4210
+7E10
+4210
+0020
+1FF0
+0100
+0300
+06E0
+0830
+3000
 ENDCHAR
-STARTCHAR C313
-ENCODING 49939
+STARTCHAR uniBCA0
+ENCODING 48288
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
-1990
-1110
-3110
-4A9E
-8450
-0810
-01C0
-0000
-0FFC
-00C0
-0330
 0110
-00E0
+0090
+0C90
+C490
+4490
+7C90
+4790
+4490
+7C90
+4490
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR C314
-ENCODING 49940
+STARTCHAR uniBCA1
+ENCODING 48289
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0090
-0050
-6650
-3250
-2450
-5450
-5C50
-8A70
-1150
-2050
-0050
-0050
-0050
+0030
+0110
+C490
+4490
+7C90
+4490
+4790
+7C90
+4490
+0080
+1FF0
+0010
+0010
+0010
 0010
+0010
 ENDCHAR
-STARTCHAR C315
-ENCODING 49941
+STARTCHAR uniBCA4
+ENCODING 48292
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 13 15 2 -2
 BITMAP
-0018
-00C8
-0248
-1148
-1348
-3248
-4D78
-88C8
-1048
-2048
-0FF8
-0008
-0008
-0008
-0008
-0008
+0030
+0190
+0890
+C490
+4490
+7C90
+4790
+4490
+7C90
+4490
+0090
+0C00
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR C318
-ENCODING 49944
+STARTCHAR uniBCA7
+ENCODING 48295
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0030
-00D0
-2250
-2250
-2450
-5650
-8970
-1150
-0050
-0050
-1850
-0810
+0020
+0010
+0090
+C490
+4490
+7C90
+4790
+4490
+7C90
+44B0
+1FE0
 0800
-0FF8
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR C31C
-ENCODING 49948
+STARTCHAR uniBCA8
+ENCODING 48296
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-00C8
-0248
-1148
-1348
-2A48
-4D78
-88C8
-1048
-2FF0
+0060
+0190
+0090
+C490
+4490
+7F90
+4490
+7C90
+4090
+0770
 0010
 0FF0
 0400
 0400
 07F8
 ENDCHAR
-STARTCHAR C324
-ENCODING 49956
+STARTCHAR uniBCB0
+ENCODING 48304
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 16 2 -3
 BITMAP
-0018
-0068
-0228
-1128
-1128
-2A28
-4D38
-84A8
-1828
-0000
-07F8
-0208
-0208
-0208
-03F8
-0200
+0030
+0110
+0090
+C490
+4490
+7C90
+4790
+4490
+7C90
+4480
+07F0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR C325
-ENCODING 49957
+STARTCHAR uniBCB1
+ENCODING 48305
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 16 2 -3
 BITMAP
-0018
-0068
-0228
-1128
-1128
-2A28
-4D38
-88A8
-1028
-2408
-0208
-03F8
-0208
-0208
-03F8
-0208
+0030
+0110
+0090
+C490
+4490
+7C90
+4790
+7C90
+4490
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR C328
-ENCODING 49960
+STARTCHAR uniBCB3
+ENCODING 48307
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-0068
-0228
-1128
-1328
-2A28
-4D38
-88A8
-1028
-0008
-0218
-0210
-0728
-0CC4
-1082
+0030
+0110
+0090
+C490
+4490
+7C90
+4790
+7C90
+4490
+0190
+0180
+0100
+02C0
+0C30
+1018
 ENDCHAR
-STARTCHAR C329
-ENCODING 49961
+STARTCHAR uniBCB4
+ENCODING 48308
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-00C8
-0248
-1148
-1248
-3248
-4D78
-88C8
-1048
-2048
-01F0
-0208
-0208
-0318
-01F0
+0030
+0010
+0090
+C490
+4490
+7C90
+4790
+7C90
+4490
+00C0
+0420
+0C60
+0E60
+1298
+6108
 ENDCHAR
-STARTCHAR C345
-ENCODING 49989
+STARTCHAR uniBCB5
+ENCODING 48309
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-00C0
-0020
-3120
-1120
-323C
-4A20
-8520
-08A0
-103C
-0120
-06C0
-0820
-0820
-0C60
-07C0
+0060
+0010
+0190
+C490
+4490
+7C90
+4790
+7C90
+4490
+0090
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C368
-ENCODING 50024
+STARTCHAR uniBCBC
+ENCODING 48316
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
 0030
-0210
-3110
-2110
-2210
-52F0
-8E10
-0990
-1090
-0090
 0010
+0610
+C210
+43F0
+7E10
+4210
+4210
+43F0
+7F10
+4010
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C369
-ENCODING 50025
+STARTCHAR uniBCBD
+ENCODING 48317
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 16 2 -3
 BITMAP
-0018
-0008
-1188
-1188
-1108
-2B78
-4688
-84C8
-0848
-1000
+0070
+0410
+C210
+43F0
+7E10
+4210
+4210
+7FF0
+4010
+0000
 1FF0
 0010
 0010
@@ -111540,713 +114707,690 @@
 0010
 0010
 ENDCHAR
-STARTCHAR C36C
-ENCODING 50028
+STARTCHAR uniBCC0
+ENCODING 48320
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0070
+0060
 0010
-3110
-1990
-1110
-2A70
-4B90
-84D0
-0850
+0610
+C210
+4210
+7FF0
+4210
+4230
+7FD0
+4010
 1010
-0010
-0C00
-0400
-0400
-07F8
+0810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C370
-ENCODING 50032
+STARTCHAR uniBCC4
+ENCODING 48324
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-2310
-1310
-2210
-5670
-4610
-8910
-1000
+0610
+C210
+43F0
+7E30
+4230
+4230
+7FD0
+4010
 1FE0
 0020
-1FE0
+0FE0
 0800
 0800
-0FF0
-ENDCHAR
-STARTCHAR C372
-ENCODING 50034
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0030
-0010
-2310
-3110
-2210
-52F0
-8510
-0890
-1090
-2000
-7DF0
-0510
-7D10
-2130
-3DF0
-0100
+07F0
 ENDCHAR
-STARTCHAR C378
-ENCODING 50040
+STARTCHAR uniBCCD
+ENCODING 48333
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
-1110
-1110
-3210
-4A70
-8D10
-0890
-1010
-0000
-0FF0
+0210
+C110
+41F0
+7F10
+4110
+4130
+7FD0
+4010
+0830
 0410
-0420
-0420
 07F0
-0400
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR C379
-ENCODING 50041
+STARTCHAR uniBCCF
+ENCODING 48335
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 13 15 2 -2
 BITMAP
-0018
-0008
-18C8
-0888
-18F8
-1D88
-2648
-C428
-0800
-0608
-0208
-03F8
-0208
-0208
-03F8
-0208
+0030
+0210
+C110
+41F0
+7F10
+4110
+4110
+7FF0
+4010
+0110
+0100
+0300
+06C0
+0830
+3008
 ENDCHAR
-STARTCHAR C37C
-ENCODING 50044
+STARTCHAR uniBCD0
+ENCODING 48336
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0038
-0008
-1188
-0888
-1118
-2F28
-4688
-8448
-0808
-0430
+0030
 0210
-0630
-0530
-08CC
-3084
+C110
+41F0
+7F10
+4110
+4110
+7FF0
+4010
+0050
+0C20
+0840
+1CE0
+2298
+4308
 ENDCHAR
-STARTCHAR C37D
-ENCODING 50045
+STARTCHAR uniBCD1
+ENCODING 48337
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0070
-0010
-2310
-1110
-2310
-5270
-4D10
-8890
-1090
-0090
-0340
-0420
-0420
-0460
-03C0
+00C0
+0020
+8420
+87E0
+FC20
+8420
+8420
+87E0
+FD20
+8120
+06C0
+0820
+0820
+0440
+0380
 ENDCHAR
-STARTCHAR C384
-ENCODING 50052
+STARTCHAR uniBCD5
+ENCODING 48341
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0060
 0030
-0050
-6650
-2250
-2250
-5450
-95D0
-0A50
-1250
-2050
-0050
-0050
-0050
-0010
-0010
-ENDCHAR
-STARTCHAR C388
-ENCODING 50056
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
-BITMAP
-0018
-0048
-0028
-1128
-1128
-3268
-2BA8
-C4A8
-0828
-1028
-0828
-0400
-0400
-0400
-03FC
+0210
+C110
+41F0
+7F10
+4110
+4110
+7FF0
+4010
+0000
+0FE0
+0800
+0FE0
+0800
+0FF8
 ENDCHAR
-STARTCHAR C38C
-ENCODING 50060
+STARTCHAR uniBCD8
+ENCODING 48344
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-00C8
-0248
-1248
-1248
-3FC8
-4D48
-8948
-1048
-07F8
-0008
-07F8
-0200
-0200
-03FC
+0030
+0190
+0890
+0490
+C490
+4790
+7C90
+4490
+4790
+7C90
+4490
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR C399
-ENCODING 50073
+STARTCHAR uniBCDC
+ENCODING 48348
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-0130
-0090
+0030
+0010
+0190
+C490
 4490
-2690
-2790
-5490
-8D90
-9290
-1290
-3090
-0810
+7F90
+4490
+4790
+7C90
+4490
+1090
+0890
 0800
 0810
 0FF0
 ENDCHAR
-STARTCHAR C3D8
-ENCODING 50136
+STARTCHAR uniBCF4
+ENCODING 48372
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 11 1 0
 BITMAP
-0860
-0430
-0C20
-0E40
-12F0
-618C
-0204
-0700
+0030
+1820
+0820
+0FE0
+0820
+0820
+0FE0
+0920
 0100
 0100
 FFFE
 ENDCHAR
-STARTCHAR C3D9
-ENCODING 50137
+STARTCHAR uniBCF5
+ENCODING 48373
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-0420
-0C40
-1AE0
-219C
-0200
-0500
+BBX 15 14 1 -2
+BITMAP
+1830
+0820
+0FE0
+0820
+0FE0
+0920
 0100
 FFFE
-2000
+0000
 3FE0
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C3DC
-ENCODING 50140
+STARTCHAR uniBCF6
+ENCODING 48374
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -1
+BBX 15 15 1 -2
 BITMAP
-0040
-0C20
-0C40
-0CC0
-13BC
-6200
-0500
-0100
-FFFE
-1000
-0800
-0800
-0800
-0FF8
+1820
+0820
+0FE0
+0820
+0820
+0FE0
+0920
+FF00
+00FE
+0000
+1EF0
+0210
+0210
+0210
+0210
 ENDCHAR
-STARTCHAR C3DF
-ENCODING 50143
+STARTCHAR uniBCF8
+ENCODING 48376
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-1840
-0840
-1880
-2570
-4208
-0600
+3060
+1040
+1FC0
+1040
+1040
+1FC0
+0200
 0200
 FFFC
 0000
-1FE0
 1000
 1000
 1000
-0FE0
+1FE0
 ENDCHAR
-STARTCHAR C3E0
-ENCODING 50144
+STARTCHAR uniBCFC
+ENCODING 48380
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 14 2 -2
 BITMAP
+3040
+1040
+1FC0
+1040
+1FC0
+1240
+03FC
+FC0C
+0000
+3FC0
 0040
-0C20
-0440
-0CB8
-1304
-6580
-0100
-FFFE
-2000
-1FE0
-0020
-0020
-1FE0
-0800
-0FF8
+1FC0
+1000
+1FF0
 ENDCHAR
-STARTCHAR C3E2
-ENCODING 50146
+STARTCHAR uniBD04
+ENCODING 48388
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
-0C60
-0420
-0C40
-12B8
-6104
-0700
+1820
+0820
+0FE0
+0820
+0FE0
+0900
 0100
 FFFE
 0000
-3F00
-02F8
-1E90
-1090
-1EF0
-0080
+1FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR C3E8
-ENCODING 50152
+STARTCHAR uniBD05
+ENCODING 48389
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0860
-0420
-0C40
-12B8
-2104
-0380
+1030
+0820
+0FE0
+0820
+0FE0
+0920
 0100
-FFFE
-0000
-1FE0
+C1FE
+3E60
 0820
-0840
 0FE0
-0800
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C3E9
-ENCODING 50153
+STARTCHAR uniBD07
+ENCODING 48391
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 14 2 -2
 BITMAP
-0060
-0C60
-0440
-0CB8
-1304
-6500
-0100
-C17E
-FE8E
-0C20
-0420
-07E0
-0420
-0420
-07E0
-0420
+3040
+1040
+1FC0
+1040
+1040
+1FC0
+0200
+FFFC
+0000
+0200
+0600
+0D80
+1860
+6010
 ENDCHAR
-STARTCHAR C3ED
-ENCODING 50157
+STARTCHAR uniBD09
+ENCODING 48393
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
+1820
 0820
-0420
-0840
-16BC
-2100
-0700
+0FE0
+0820
+0FE0
+0900
 0100
 FFFE
-2100
-07C0
-0C60
+0100
+06C0
+0820
 0820
 0C60
-07C0
+0380
 ENDCHAR
-STARTCHAR C3F4
-ENCODING 50164
+STARTCHAR uniBD10
+ENCODING 48400
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
 0030
-0010
-1090
-0890
-1190
-3D90
-4250
-8436
-0A18
-0210
-7FD0
-2010
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR C3F5
-ENCODING 50165
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
-BITMAP
-0030
 0110
-1890
-0910
-1E90
-2450
-4E1E
-0270
-FD90
-0000
-1FF0
-0010
-0010
+6090
+2090
+3F90
+2090
+2090
+3F9E
+2410
+0430
+BFD0
+6010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C3F8
-ENCODING 50168
+STARTCHAR uniBD14
+ENCODING 48404
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0060
-0220
-3120
-1220
-3D20
-48A0
-943C
-04E0
-FB20
+0040
 0020
+6320
+2120
+3F20
+2220
+3E20
+283C
+09E0
+FE20
 0020
+1820
 0800
 0800
-0810
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR C408
-ENCODING 50184
+STARTCHAR uniBD24
+ENCODING 48420
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0110
-0890
-0910
-1E90
-2450
-4A1E
-0270
-FF90
-0000
-0630
-0420
-0B70
-114C
-2084
+0060
+6320
+2120
+3F20
+2120
+212C
+3F30
+2820
+08E0
+FF00
+0C60
+0840
+1CE0
+1390
+6208
 ENDCHAR
-STARTCHAR C410
-ENCODING 50192
+STARTCHAR uniBD2C
+ENCODING 48428
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 16 1 -3
 BITMAP
 0030
-0088
+0098
 0048
-1348
-1248
-1648
-2D48
-4848
-1878
-09C8
-FE48
+6248
+2248
+3E48
+2248
+2248
+3E78
+2848
+0FC8
+F848
 0048
 0048
 0048
 0008
 ENDCHAR
-STARTCHAR C424
-ENCODING 50212
+STARTCHAR uniBD40
+ENCODING 48448
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0190
-2690
-1490
-3C90
-4A90
-98F0
-0890
-1F90
-E040
-0420
-0C60
-0B50
-1188
-6100
+0060
+0320
+8D20
+4520
+7D20
+4520
+79E0
+5320
+1D20
+E080
+0840
+0880
+14E0
+2130
+C210
 ENDCHAR
-STARTCHAR C42C
-ENCODING 50220
+STARTCHAR uniBD48
+ENCODING 48456
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
+0070
 0010
-3110
-1910
-1210
-2F90
-44D0
-0C10
-3410
-0470
-FF90
+6110
+2110
+3F10
+2110
+2110
+3F10
+2810
+0810
+0FD0
+F010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniBD49
+ENCODING 48457
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
+BITMAP
+0018
+2188
+1088
+1F88
+1088
+1088
+1F88
+1208
+02F8
+FD08
+1FF0
 0010
 0010
 0010
 0010
+0010
 ENDCHAR
-STARTCHAR C430
-ENCODING 50224
+STARTCHAR uniBD4C
+ENCODING 48460
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 13 15 2 -2
 BITMAP
-0030
+0020
 0010
-1110
-1110
-3B10
-44D0
-8C10
-1430
-FFD0
-4010
+6110
+2110
+3F10
+2110
+3F10
+2810
+08F0
+FF10
+0010
 1810
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR C434
-ENCODING 50228
+STARTCHAR uniBD50
+ENCODING 48464
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0188
-0888
-0988
-1548
-2628
-CA08
-02F8
-3D08
-07F8
-0008
-07F8
-0200
-0200
-03FC
+0030
+4310
+2110
+3F10
+2110
+3F10
+2810
+0B90
+F410
+0000
+1FE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR C43C
-ENCODING 50236
+STARTCHAR uniBD58
+ENCODING 48472
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 16 1 -3
 BITMAP
-0030
-0010
-1110
-1110
-3B90
-4450
-8C10
-04F0
-FF10
-0000
-07F0
-0420
-0420
-07F0
-0400
+0018
+20C8
+10C8
+1F88
+1088
+1088
+1F88
+1208
+8EF8
+7108
+07F8
+0208
+0210
+0210
+03F8
+0200
 ENDCHAR
-STARTCHAR C43D
-ENCODING 50237
+STARTCHAR uniBD59
+ENCODING 48473
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0110
-1910
-1310
-2CD0
-4C10
-0410
-8FF0
-7000
-0C10
+4310
+2110
+3F10
+2110
+2110
+3F10
+2410
+05F0
+FE30
 0410
 07F0
 0410
+0410
 07F0
 0410
 ENDCHAR
-STARTCHAR C448
-ENCODING 50248
+STARTCHAR uniBD64
+ENCODING 48484
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 14 12 2 0
 BITMAP
-0C30
-0420
-0420
-0A60
-1198
-2104
-0200
-0420
-0420
-0440
-FFFE
+0020
+3020
+1020
+1FE0
+1020
+1020
+1020
+1FE0
+10C0
+0840
+0840
+FFFC
 ENDCHAR
-STARTCHAR C464
-ENCODING 50276
+STARTCHAR uniBD68
+ENCODING 48488
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 14 2 -2
 BITMAP
-0860
-0460
-0C40
-12B8
-2104
-C200
+30C0
+1040
+1FC0
+1040
+1040
+1FC0
+1880
+0880
+FFFC
+2000
+1000
+1000
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniBD80
+ENCODING 48512
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1820
+0820
+0FE0
+0820
+0FE0
+0800
 0000
 FFFE
 0100
@@ -112255,2103 +115399,1833 @@
 0100
 0100
 0100
-0100
 ENDCHAR
-STARTCHAR C465
-ENCODING 50277
+STARTCHAR uniBD81
+ENCODING 48513
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0040
-0420
-0C20
-0E60
-329C
-4100
-0604
+1820
+0820
+0FE0
+0820
+0FE0
+0820
+0004
 FFFE
 0100
-0100
-21F0
-1E10
-0010
-0010
-0010
+01F0
+1E20
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C468
-ENCODING 50280
+STARTCHAR uniBD84
+ENCODING 48516
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0040
-0420
-0420
-0C40
-12B8
-6104
-0200
-000E
-FFFC
+1820
+0820
+0FE0
+0820
+0FE0
+0800
+0004
+FFFE
 0100
 0100
 1900
 0900
-0900
-0FF8
+0800
+07F8
 ENDCHAR
-STARTCHAR C46C
-ENCODING 50284
+STARTCHAR uniBD87
+ENCODING 48519
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0040
-0420
-0420
-0C40
-32B8
-4104
-0604
+1820
+0820
+0FE0
+0820
+0FE0
+0820
+0004
 FFFE
 0100
-1F00
-00E0
-0020
-1FE0
+1F20
+08C0
 0800
+0810
 0FF0
 ENDCHAR
-STARTCHAR C474
-ENCODING 50292
+STARTCHAR uniBD88
+ENCODING 48520
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 14 1 -2
 BITMAP
-0020
-0420
-0460
-0C50
-138C
-6200
-0000
-FFFE
-0100
-0100
-1FE0
-0820
+3820
 0820
+0FE0
 0820
 0FE0
+0804
+FFFE
+0100
+1100
+0EE0
+0020
+0FE0
 0800
+0FF0
 ENDCHAR
-STARTCHAR C475
-ENCODING 50293
+STARTCHAR uniBD89
+ENCODING 48521
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
-0040
-0420
-0420
-0E40
-30BC
-4100
-0200
-FFFE
-0100
-1920
-0920
-0FE0
+1060
 0820
 0FE0
 0820
-ENDCHAR
-STARTCHAR C479
-ENCODING 50297
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
-BITMAP
-0060
-0420
-0460
-0ED8
-1184
-6200
-0004
+0820
+0FE0
+0804
 FFFE
 0100
-07C0
-0C60
-0820
-0820
-0C60
-03C0
-ENDCHAR
-STARTCHAR C480
-ENCODING 50304
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-0010
-1110
-1110
-3B10
-4C90
-8810
-1010
-0F90
-7410
-04F0
-0410
-0410
-0410
-0010
-ENDCHAR
-STARTCHAR C494
-ENCODING 50324
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-2310
-1110
-3210
-4D90
-8810
-0010
-FF10
-08F0
-0800
-0430
-0420
-0A60
-1198
-6108
-ENDCHAR
-STARTCHAR C49C
-ENCODING 50332
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-0060
-01A0
-00A0
-24A0
-24A0
-5CA0
-92A0
-20A0
-06A0
-F8A0
-13A0
-10A0
-10A0
-00A0
-0020
-ENDCHAR
-STARTCHAR C4B8
-ENCODING 50360
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0070
-0010
-3110
-1110
-3310
-4C90
-8810
-0010
-3F90
-C810
-0810
-0810
-0810
-0810
-0010
-ENDCHAR
-STARTCHAR C4BC
-ENCODING 50364
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
-BITMAP
-0018
-0008
-1888
-0988
-1D08
-22E8
-CC08
-FFF8
-2408
-0408
-0408
-0C08
-0400
-0400
-07FC
+0310
+1EF0
+2610
+1810
+1310
+1C10
 ENDCHAR
-STARTCHAR C4E9
-ENCODING 50409
+STARTCHAR uniBD8A
+ENCODING 48522
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 16 1 -3
 BITMAP
-0040
-0420
-0420
-0E60
-129C
-6104
-0204
-FFFE
-0420
-0520
-06E0
+1860
 0820
+0FE0
 0820
-0C60
-07C0
-ENDCHAR
-STARTCHAR C4F0
-ENCODING 50416
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 11 1 0
-BITMAP
 0820
-0430
-0420
-0C40
-12F0
-208C
-C300
-0400
-0000
-0000
-FFFE
-ENDCHAR
-STARTCHAR C4F1
-ENCODING 50417
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
-BITMAP
-0040
-0C20
-0420
-0E60
-129C
-6100
-0206
+0FE0
+0800
 FFFE
-2000
-0000
-1FF0
-0010
-0010
-0010
-0010
+0100
+0100
+3EF8
+0288
+3690
+1890
+1EF0
+0080
 ENDCHAR
-STARTCHAR C4F4
-ENCODING 50420
+STARTCHAR uniBD90
+ENCODING 48528
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 16 1 -3
 BITMAP
-0C20
-0430
-0C20
-1270
-608C
-0300
-0000
-FFFE
-0000
-1000
-0800
-0800
+1860
+0820
+0FE0
+0820
+0820
+0FE0
 0800
-0FF8
-ENDCHAR
-STARTCHAR C4F8
-ENCODING 50424
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-0C60
-0420
-0C40
-32B8
-410C
-0200
 FFFE
-0000
-0000
-1FF0
-0020
+0100
+0100
 1FE0
+0820
+0820
+0820
+0FE0
 0800
-0FF8
-ENDCHAR
-STARTCHAR C4FA
-ENCODING 50426
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 1 -3
-BITMAP
-0040
-0C30
-0420
-0C60
-1AD8
-218C
-C200
-0000
-7FFE
-0000
-3FF8
-0290
-3E90
-1090
-16F0
-0880
 ENDCHAR
-STARTCHAR C4FF
-ENCODING 50431
+STARTCHAR uniBD91
+ENCODING 48529
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0C20
-0420
-0C40
-12F8
-2104
-C204
-01FE
-FF00
-3E70
-041C
-3CE0
-1098
-1688
-1870
+1860
+0820
+0FE0
+0820
+0FE0
+0820
+FFFE
+0100
+1160
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C500
-ENCODING 50432
+STARTCHAR uniBD93
+ENCODING 48531
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 16 1 -3
 BITMAP
-0860
-0420
-0840
-16F0
-210C
-C200
-0404
-FFFE
-2000
-0000
-1FE0
+3060
+0820
+0FE0
+0820
+0820
+0FE0
+0804
+C7FE
+7D00
+0100
+0100
+0100
+0300
+06C0
+0830
+3010
+ENDCHAR
+STARTCHAR uniBD95
+ENCODING 48533
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+1860
 0820
+0FE0
+0820
 0820
 0FE0
-0800
+0820
+FFFE
+0100
+0100
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR C501
-ENCODING 50433
+STARTCHAR uniBD99
+ENCODING 48537
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0C60
-0C20
-0C40
-32B8
-4104
-0200
-FFFE
-0000
 1820
 0820
 0FE0
 0820
 0FE0
-0820
+0824
+FFFE
+0100
+1FF0
+0800
+0800
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR C50C
-ENCODING 50444
+STARTCHAR uniBD9A
+ENCODING 48538
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0020
-4220
-3220
-2220
-5620
-89A0
-10A0
-2020
-0060
-3FA0
-C020
-0020
-0020
-0020
+1860
+0820
+0FE0
+0820
+0820
+0FE0
+0820
+FFFE
+0100
+0100
+1FF0
+0040
+0440
+0280
+3FF8
 ENDCHAR
-STARTCHAR C510
-ENCODING 50448
+STARTCHAR uniBD9C
+ENCODING 48540
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
+4110
+2110
+3F10
+2110
+2110
+3F10
+2110
+0710
+F810
+08F0
+0810
+0810
+0810
 0010
-0110
-1910
-1310
-2ED0
-4450
-1810
-00F0
-FF10
-0010
-1810
-0800
-0800
-0FF8
 ENDCHAR
-STARTCHAR C514
-ENCODING 50452
+STARTCHAR uniBDA4
+ENCODING 48548
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0030
-0210
-1910
-1110
-2B90
-4450
-1870
-FF90
-0000
-1FE0
 0020
-1FE0
-0800
-0800
-0FF8
+0310
+2110
+3F10
+2110
+2110
+3F10
+2390
+FCF0
+0400
+0FF0
+0020
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR C51C
-ENCODING 50460
+STARTCHAR uniBDB0
+ENCODING 48560
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 16 3 -3
 BITMAP
-0060
-0030
-1110
-1910
-1B10
-66D0
-8850
-0010
-FFF0
-2010
-0FF0
-0410
-0410
-0420
-07F0
-0400
+0C60
+4420
+7C20
+4420
+4420
+7C20
+4720
+F820
+11E0
+10A0
+1840
+1840
+18C0
+2530
+4210
+8000
 ENDCHAR
-STARTCHAR C528
-ENCODING 50472
+STARTCHAR uniBDB8
+ENCODING 48568
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0310
-1190
-1110
-2110
-3210
-4F10
-8C90
+0090
+8250
+4250
+7E50
+4250
+4250
+7E50
+4250
+0E50
+79D0
 0850
-1010
-2010
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR C529
-ENCODING 50473
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 16 1 -3
-BITMAP
-0018
-0008
-1888
-0888
-1108
-2988
-4648
-8468
-0808
-0000
-1FF0
-0010
-0010
-0010
-0010
+0850
+0850
 0010
-ENDCHAR
-STARTCHAR C52C
-ENCODING 50476
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
-BITMAP
-0018
-0008
-1188
-0888
-0888
-1908
-2688
-4248
-8408
-0808
-0008
-0600
-0200
-0200
-03FC
 ENDCHAR
-STARTCHAR C530
-ENCODING 50480
+STARTCHAR uniBDD4
+ENCODING 48596
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-0888
-0888
-1088
-2D88
-4648
-8428
-0800
-0FF8
-0010
+0070
+0210
+E110
+2110
+3F10
+2110
+3F10
+2010
+00D0
+FF10
+0410
+0410
+0410
+0410
 0010
-1FF8
-0400
-07FC
 ENDCHAR
-STARTCHAR C538
-ENCODING 50488
+STARTCHAR uniBDD5
+ENCODING 48597
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0010
-1190
-1990
-1110
-2B10
-4290
-8450
-0810
-1000
-0FF0
+0310
+2110
+3F10
+2110
+3F10
+20F0
+FF10
 0410
-0420
-0420
-07F0
 0400
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C539
-ENCODING 50489
+STARTCHAR uniBDD8
+ENCODING 48600
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 13 15 2 -2
 BITMAP
 0030
-0018
-1888
-0888
-1888
-1D88
-2648
-C468
-0808
-0608
-0208
-03F8
-0208
-0208
-03F8
-0208
+6110
+2110
+3F10
+2110
+2110
+3F10
+2070
+FF90
+0410
+0410
+3810
+0800
+0810
+0FF8
 ENDCHAR
-STARTCHAR C53B
-ENCODING 50491
+STARTCHAR uniBDDC
+ENCODING 48604
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-1888
-0888
-1888
-1988
-2648
-C428
-0008
-00C8
-0040
-00C0
-0130
-0208
-0404
+0030
+0310
+2110
+3F10
+2110
+3F10
+2030
+FFD0
+0410
+0400
+1FF0
+0010
+1FF0
 0800
+0FF0
 ENDCHAR
-STARTCHAR C53D
-ENCODING 50493
+STARTCHAR uniBDE9
+ENCODING 48617
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-3110
-1110
-3110
-2B10
-4E90
-84D0
-0810
-00C0
-0320
-0410
+0310
+2110
+3F10
+2110
+3F10
+2030
+FFD0
 0410
-0630
-03E0
+0480
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C544
-ENCODING 50500
+STARTCHAR uniBDF0
+ENCODING 48624
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-00E0
-0020
-0020
+1820
 0820
-7C20
-C620
-8220
-822C
-C630
-3C20
-0020
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR C545
-ENCODING 50501
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-00C0
-1020
-7C20
-C620
-8220
-8224
-C638
-3C20
-0020
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+0FE0
+0820
+0FE0
+0800
+000E
+FFF0
+0820
+0820
+0820
+0820
+0820
+0820
 ENDCHAR
-STARTCHAR C548
-ENCODING 50504
+STARTCHAR uniBDF4
+ENCODING 48628
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 1 -2
 BITMAP
-0060
-0020
-1020
-7C20
-C620
-822C
-8230
-C620
-3C20
-0020
-3020
+1820
+0820
+0FE0
+0820
+0FE0
 0800
+FFFC
+0440
+0440
+0440
+1840
 0800
 0810
-0FF0
-ENDCHAR
-STARTCHAR C549
-ENCODING 50505
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-00C0
-1020
-7C20
-8220
-8220
-823C
-4420
-3820
-0000
-63F8
-2040
-20C0
-24B0
-3910
-0600
+0FF8
 ENDCHAR
-STARTCHAR C54A
-ENCODING 50506
+STARTCHAR uniBDF8
+ENCODING 48632
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-1020
-7C20
-8220
-822C
-8230
-4420
-3800
-01F0
-6780
-21C0
-2220
-2620
-3A20
-01C0
+3040
+1040
+1FC0
+1040
+1FC0
+1040
+FFBC
+0880
+3FC0
+0040
+3FC0
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR C54C
-ENCODING 50508
+STARTCHAR uniBE00
+ENCODING 48640
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0020
-1020
-6C20
-8220
-823C
-C620
-7C20
-0000
-1FE0
+1060
+0820
+0FE0
+0820
+0820
+0FE0
+0820
+FFFE
+0420
 0020
 1FE0
+0820
+0840
+0FC0
 0800
-0800
-0FF0
 ENDCHAR
-STARTCHAR C54D
-ENCODING 50509
+STARTCHAR uniBE03
+ENCODING 48643
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 15 2 -3
 BITMAP
-0060
-1020
-7C20
-C620
-822C
-8230
-C620
-7C00
-0000
-7E60
-04A0
-4620
-3820
-2220
-3C20
-0020
+3040
+1040
+1FC0
+1040
+1FC0
+1040
+0008
+FFFC
+0840
+0E40
+0600
+0D80
+1840
+2020
+4000
 ENDCHAR
-STARTCHAR C54E
-ENCODING 50510
+STARTCHAR uniBE05
+ENCODING 48645
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-1020
-7C20
-C620
-8220
-823C
-C620
-7820
+3860
+0820
+0FE0
+0820
+0FE0
+0820
 0000
-3DF0
-0520
-7D20
-2120
-27E0
-3900
+FFFE
+04A0
+07E0
+0420
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR C553
-ENCODING 50515
+STARTCHAR uniBE0C
+ENCODING 48652
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 11 2 1
 BITMAP
-0060
-1020
-3820
-C620
-8220
-8238
-6C20
+0040
+3040
+1040
+1FC0
+1040
+1040
+1040
+1FC0
 1000
-00E0
-7C00
-0BF0
-6CE0
-3110
-2110
-3CE0
+0000
+FFFC
 ENDCHAR
-STARTCHAR C554
-ENCODING 50516
+STARTCHAR uniBE0D
+ENCODING 48653
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0060
-1020
-7C20
-C620
-8220
-822C
-4630
-3C20
-0020
+3040
+1040
+1FC0
+1040
+1FC0
+1040
 0000
-1FE0
-0820
-0820
-0820
-0FE0
-0800
+FFFC
+0000
+7FC0
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C555
-ENCODING 50517
+STARTCHAR uniBE10
+ENCODING 48656
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 15 1 -2
 BITMAP
-0060
-1020
-7C20
-C620
-8220
-823C
-C620
-3820
-0000
+0040
 1820
 0820
 0FE0
 0820
 0820
 0FE0
-0820
+0800
+FFFE
+0000
+0000
+0800
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR C557
-ENCODING 50519
+STARTCHAR uniBE14
+ENCODING 48660
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-1020
-7C20
-C620
-8220
-822C
-4630
-3820
-0020
-0120
-0100
-0380
-0640
-0830
-1010
+20C0
+1040
+1FC0
+1040
+1FC0
+1000
+0000
+FFFC
+0000
+1FC0
+0040
+3FC0
+1000
+1FF0
 ENDCHAR
-STARTCHAR C558
-ENCODING 50520
+STARTCHAR uniBE1C
+ENCODING 48668
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-0060
-0020
-7C20
-C620
-8220
-823C
-C620
-3C20
+30C0
+1040
+1FC0
+1040
+1040
+1FC0
+1040
+01FC
+FE00
 0000
-0860
-0860
-0C40
-12A0
-2118
-4208
+3FC0
+1040
+1040
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR C559
-ENCODING 50521
+STARTCHAR uniBE1D
+ENCODING 48669
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0060
-1020
-3820
-C620
-8220
-822C
-4430
-3820
-0020
-0100
-06C0
+1820
 0820
+0FE0
 0820
-0C60
-03C0
-ENDCHAR
-STARTCHAR C55D
-ENCODING 50525
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0060
-1020
-7C20
-C620
-8220
-823C
-C620
-3C20
-0000
 0FE0
-0800
+0824
+FFFE
+2000
+1820
+0820
 0FE0
-0800
-0800
-07F0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C55E
-ENCODING 50526
+STARTCHAR uniBE1F
+ENCODING 48671
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-1020
-7C20
-C620
-8220
-823C
-C620
-3C20
-0000
-0000
-3FF0
-08C0
-0440
-0480
-7FF8
+3830
+0810
+0FF0
+0810
+0810
+0FF0
+0810
+FFFE
+0300
+0100
+0380
+0660
+0830
+3000
 ENDCHAR
-STARTCHAR C560
-ENCODING 50528
+STARTCHAR uniBE44
+ENCODING 48708
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0190
-0090
-1090
-6890
-8490
-8490
-CCF0
-7890
-0090
-0090
-0090
-0090
-0090
+0070
+0010
+0610
+C210
+4210
+7E10
+4210
+4210
+4210
+7E10
+4210
+0010
+0010
+0010
 0010
 ENDCHAR
-STARTCHAR C561
-ENCODING 50529
+STARTCHAR uniBE45
+ENCODING 48709
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
-0010
-1090
-6890
-8490
-8490
-CCF0
-7890
-0090
-0090
-1FF0
-1010
-0010
-0010
-0010
-0010
+0060
+0410
+C210
+4210
+7E10
+4210
+4210
+7E10
+4010
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C564
-ENCODING 50532
+STARTCHAR uniBE48
+ENCODING 48712
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0070
-0090
-0090
-0890
-7490
-8290
-82F0
-C690
-7C90
-0090
-0090
-1800
-0800
+0060
+0610
+C210
+4210
+7E10
+4210
+4210
+4210
+7E10
+4210
+0010
+1810
 0800
-07F8
+0810
+0FF8
 ENDCHAR
-STARTCHAR C568
-ENCODING 50536
+STARTCHAR uniBE4C
+ENCODING 48716
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0110
-1090
-7890
-CC90
-8490
-84F0
-7890
-0090
-1F90
-0060
+0410
+C310
+4210
+7E10
+4210
+4210
+7E10
+4200
+1FE0
 0020
 1FE0
 0800
-0FF0
+0800
+0FF8
 ENDCHAR
-STARTCHAR C570
-ENCODING 50544
+STARTCHAR uniBE4E
+ENCODING 48718
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
-0110
-1090
-6890
-8490
-8490
-CCF0
-7890
-0090
-0090
-0FF0
-0410
+0070
+0210
+C110
+4110
+7F10
+4110
+4110
+7F10
+4110
+0000
+7C00
+09F0
+7D20
+2120
+3DE0
+0100
+ENDCHAR
+STARTCHAR uniBE54
+ENCODING 48724
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0070
 0410
-0420
-07F0
-0400
+C310
+4210
+7E10
+4210
+4210
+7E10
+4210
+0000
+1FF0
+0830
+0820
+0820
+0FF0
+0800
 ENDCHAR
-STARTCHAR C571
-ENCODING 50545
+STARTCHAR uniBE55
+ENCODING 48725
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0070
-0090
-0090
-7890
-8490
-84F0
-8490
-7890
-0000
-0C10
-0410
-07F0
-0410
-07F0
 0410
+C310
+4210
+7E10
+4210
+4210
+7E10
+4240
+1830
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C573
-ENCODING 50547
+STARTCHAR uniBE57
+ENCODING 48727
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0070
-0130
-1090
-6890
-8490
-8490
-8CF0
-7890
-0090
-0190
-0080
-0140
-0220
-0418
-1808
+0030
+0610
+C310
+4210
+7E10
+4210
+4210
+7E10
+4210
+0110
+0180
+0180
+0240
+0C30
+1010
 ENDCHAR
-STARTCHAR C574
-ENCODING 50548
+STARTCHAR uniBE59
+ENCODING 48729
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0070
-0130
-1090
-6890
-8490
-8490
-CCF0
-7890
-0090
-0CB0
+0410
+C310
+4210
+7E10
+4210
+4210
+7E10
+4210
+0080
+0740
 0420
-0C60
-1250
-2088
-4100
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C575
-ENCODING 50549
+STARTCHAR uniBE5A
+ENCODING 48730
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0110
-1090
-6890
-8490
-8490
-8CF0
-7890
-0090
-0090
-0360
-0410
-0410
-0630
-03E0
+0210
+C110
+4110
+7F10
+4110
+4110
+7F10
+4110
+3FF0
+0100
+0380
+0660
+0830
+3000
 ENDCHAR
-STARTCHAR C57C
-ENCODING 50556
+STARTCHAR uniBE5B
+ENCODING 48731
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0040
-0020
-0020
-1020
-7C20
-C63C
-8220
-8220
-C620
-3C2C
 0030
-0020
-0020
-0020
-0020
+0410
+C310
+4210
+7E10
+4210
+4210
+7E10
+4200
+0380
+3FF0
+0100
+0280
+0470
+1810
+2000
 ENDCHAR
-STARTCHAR C57D
-ENCODING 50557
+STARTCHAR uniBE60
+ENCODING 48736
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
-1020
-1020
-6C24
-8238
-8220
-C620
-383C
-0020
-3FE0
 0020
 0020
+D4A0
+54A0
+54A0
+77A0
+54AC
+54B0
+54A0
+77A0
+54A0
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C580
-ENCODING 50560
+STARTCHAR uniBE61
+ENCODING 48737
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 16 3 -3
 BITMAP
-0060
-0020
-1020
-7820
-863C
-8220
-8220
-4420
-382C
-0030
-0020
-1820
-0800
-0800
-0FF0
+00C0
+0240
+4940
+A940
+AF40
+E958
+A960
+AF40
+E840
+0000
+7FC0
+0040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C584
-ENCODING 50564
+STARTCHAR uniBE64
+ENCODING 48740
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-0060
-1020
-7C20
-C62C
-8230
-8220
-C624
-3C38
-0000
-1FE0
-0020
-0020
+00C0
+0040
+7140
+A940
+A940
+EF40
+A958
+A960
+EF40
+A940
+0040
+3000
+1000
+1000
 1FE0
-0800
-0FF0
 ENDCHAR
-STARTCHAR C587
-ENCODING 50567
+STARTCHAR uniBE68
+ENCODING 48744
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 3 -2
 BITMAP
+00C0
+0240
+A540
+A540
+E740
+A558
+A560
+E740
+A500
+3FE0
 0040
-1020
-7C20
-C624
-8238
-8220
-4620
-3C3C
-0330
-7D10
-05F0
-6D10
-3110
-23F0
-3D10
+3FE0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR C58C
-ENCODING 50572
+STARTCHAR uniBE6A
+ENCODING 48746
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 12 16 3 -3
 BITMAP
-0060
-0020
-1020
-6C24
-8238
-8220
-C220
-7C3C
-0020
+00C0
+0440
+AB40
+A940
+EF40
+A940
+A970
+EF40
+A840
 0000
-1FE0
-0820
-0820
-0840
-0FE0
-0800
+F7C0
+1480
+9480
+6480
+5F80
+2400
 ENDCHAR
-STARTCHAR C58D
-ENCODING 50573
+STARTCHAR uniBE70
+ENCODING 48752
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
 0060
-1020
-7C20
-C62C
-8230
-8220
-C62C
-3C30
+01A0
+D4A0
+54A0
+77A0
+54A4
+54B8
+77A0
+54A0
 0000
-1820
-0820
-0FE0
-0820
-0820
+1FE0
+0840
+0840
+0840
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR C58F
-ENCODING 50575
+STARTCHAR uniBE71
+ENCODING 48753
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -1
+BBX 13 16 3 -3
 BITMAP
-0060
-1020
-3020
-4C20
-8238
-8220
-4620
-382C
-0330
-01A0
-0100
-0280
-0460
-1810
+00C0
+0340
+A940
+A940
+EF40
+A958
+A960
+EF40
+A900
+3040
+1040
+1FC0
+1040
+1040
+1FC0
+1040
 ENDCHAR
-STARTCHAR C591
-ENCODING 50577
+STARTCHAR uniBE73
+ENCODING 48755
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0040
-1020
-3020
-4C20
-823C
-8220
-C420
-382C
-0030
+0060
+0020
 0120
-06C0
-0820
-0820
-0C60
-07C0
+D2A0
+52A0
+73A0
+52BC
+52A0
+73A0
+53A0
+0080
+0180
+0260
+0410
+1800
 ENDCHAR
-STARTCHAR C595
-ENCODING 50581
+STARTCHAR uniBE74
+ENCODING 48756
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
-0020
-7C20
-C63C
-8220
-8220
-C62C
-3C30
-0020
-1FF0
-0800
-0800
-0FE0
-0800
-0FF0
+01A0
+52A0
+52A0
+73A0
+52AC
+52B0
+73A0
+52A0
+1840
+0C40
+0840
+16A0
+2310
+C000
 ENDCHAR
-STARTCHAR C597
-ENCODING 50583
+STARTCHAR uniBE75
+ENCODING 48757
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
-0020
-0020
-7C20
-C63C
-8220
-C620
-7C20
-003C
-03A0
-3F40
+01A0
+02A0
+D2A0
+53A0
+72A4
+52B8
+52A0
+73A0
+5280
+03C0
+0460
+0420
+0660
+03C0
+ENDCHAR
+STARTCHAR uniBE7B
+ENCODING 48763
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
+BITMAP
 0180
-0640
-0440
-0380
+02C0
+9540
+9540
+F740
+9540
+9558
+F760
+9540
+07C0
+3FF0
+0700
+0880
+0880
+0700
 ENDCHAR
-STARTCHAR C598
-ENCODING 50584
+STARTCHAR uniBE7C
+ENCODING 48764
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0190
-0090
-0090
-1090
-68F0
-8490
-8490
-CCF0
-7890
-0090
-0090
-0090
+0060
 0090
+0050
+3950
+9950
+9950
+FF50
+9950
+9970
+9F50
+F950
+9050
+0050
+0050
 0010
 ENDCHAR
-STARTCHAR C59C
-ENCODING 50588
+STARTCHAR uniBE7D
+ENCODING 48765
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 16 3 -3
+BITMAP
+0040
+01A0
+46A0
+AAA0
+AAA0
+EEA0
+AAE0
+AAA0
+EEA0
+AA00
+3FE0
+1020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniBE80
+ENCODING 48768
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
 0060
-0190
-0090
-1090
-68F0
-8490
-8490
-CCF0
-7890
-0090
-0090
-1810
-0800
-0800
-0FF8
+01A0
+04A0
+AAA0
+AAA0
+EEA0
+AAE0
+AAA0
+EEA0
+AAA0
+20A0
+1000
+1000
+1000
+0FF0
 ENDCHAR
-STARTCHAR C5A0
-ENCODING 50592
+STARTCHAR uniBE84
+ENCODING 48772
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0020
-0190
-1090
-7C90
-C6F0
-8290
-C690
-7CF0
-0080
-1FE0
 0020
-1FE0
-0800
-0800
+0090
+0050
+D550
+5550
+7750
+5570
+5750
+7050
+0000
+0FF0
+0010
 0FF0
+0410
+07F8
 ENDCHAR
-STARTCHAR C5A9
-ENCODING 50601
+STARTCHAR uniBE8C
+ENCODING 48780
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0060
-0190
-1090
-7890
-84F0
-8490
-8490
-78F0
+0020
 0090
-0C90
-0410
-07F0
-0410
+0250
+D550
+5550
+7750
+5570
+5550
+7750
+0000
+0FF0
 0410
+0420
+0420
 07F0
-0410
+0400
 ENDCHAR
-STARTCHAR C5B4
-ENCODING 50612
+STARTCHAR uniBE8D
+ENCODING 48781
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 16 3 -3
 BITMAP
-0060
-0010
-0010
-0810
-7C10
-C610
-8210
-83F0
-4610
-3C10
-0010
-0010
-0010
-0010
-0010
+0040
+01A0
+0AA0
+AAA0
+AEA0
+EAA0
+AAE0
+EEA0
+88A0
+1860
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C5B5
-ENCODING 50613
+STARTCHAR uniBE8F
+ENCODING 48783
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-1010
-3810
-C610
-8210
-83F0
-C610
-3C10
-0010
-0000
-3FE0
-1020
-0020
 0020
-0020
+00D0
+0350
+D550
+5550
+7750
+5570
+5550
+7750
+0190
+0080
+0140
+0230
+0418
+1800
 ENDCHAR
-STARTCHAR C5B8
-ENCODING 50616
+STARTCHAR uniBE90
+ENCODING 48784
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0060
-0010
-0810
-7C10
-C610
-8330
-82D0
-4610
-3C10
-0010
-1010
-0810
-0800
-0800
-0FF8
+0020
+00D0
+0350
+D550
+5550
+7750
+5570
+5550
+7750
+0420
+0420
+0C20
+0A50
+1088
+2108
 ENDCHAR
-STARTCHAR C5B9
-ENCODING 50617
+STARTCHAR uniBE91
+ENCODING 48785
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0810
-7C10
-C610
-83F0
-8310
-4610
-3C10
-0010
-4030
-23C0
-20C0
-20A0
-3D10
-0600
+0020
+0090
+0350
+D550
+5550
+7750
+5570
+5550
+7750
+0050
+01A0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR C5BB
-ENCODING 50619
+STARTCHAR uniBE98
+ENCODING 48792
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-0030
-1010
-3810
-4610
-8210
-83F0
-C610
-3C10
-0010
+00C0
+0020
+0020
+94A0
+54A0
+54A4
+77B8
+54A0
+54A0
+54A0
+77AC
+5030
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniBE99
+ENCODING 48793
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
+BITMAP
+00C0
+0240
+0940
+A940
+AF78
+E940
+A940
+EF70
+A840
 0000
-3FF0
-0800
-0800
-0800
-0FF8
+7FC0
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C5BC
-ENCODING 50620
+STARTCHAR uniBEA8
+ENCODING 48808
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-0030
-0010
-7C10
-8210
-83F0
-C610
-7C10
-0010
-3FE0
-0020
-0020
+0060
+0120
+D4A0
+54AC
+77B0
+54A0
+54A0
+77BC
+5420
+0000
 1FE0
+0820
+0840
+0840
+0FE0
 0800
-0800
-0FF8
 ENDCHAR
-STARTCHAR C5BD
-ENCODING 50621
+STARTCHAR uniBED0
+ENCODING 48848
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
-0810
-3C10
-4610
-83F0
-8310
-C610
-3C10
+0060
 0010
-0000
-3CF0
-0410
-3810
-2010
-3C10
+BC90
+5490
+5490
+7790
+54F0
+5490
+5490
+7790
+5410
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C5BE
-ENCODING 50622
+STARTCHAR uniBED1
+ENCODING 48849
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 11 16 3 -3
 BITMAP
-0070
-0810
-3C10
-4310
-83F0
-8310
-4210
-3C10
-0010
-3C00
-05F8
-6D30
-3130
-2330
-3DF0
-0100
+0060
+4B20
+B520
+A520
+E720
+A5E0
+A520
+E720
+A520
+0020
+7FC0
+0040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C5C4
-ENCODING 50628
+STARTCHAR uniBED4
+ENCODING 48852
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0070
+0020
+2190
+D490
+5490
+7790
+5490
+54F0
+5490
+7790
+5410
 1010
-7810
-8610
-8230
-83D0
-4610
-3C10
-0010
-0000
-1FE0
-0820
-0820
-0820
-0FE0
+0810
+0810
 0800
+0FF8
 ENDCHAR
-STARTCHAR C5C5
-ENCODING 50629
+STARTCHAR uniBED7
+ENCODING 48855
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 3 -2
 BITMAP
-0070
-1010
-3810
-C610
-8210
-83F0
-C610
-3C10
-0010
-1C30
-0420
-07E0
-0420
-0420
-07E0
-0420
+00E0
+0320
+4520
+A520
+A720
+E5E0
+A520
+A720
+E520
+A020
+1FE0
+0800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR C5C6
-ENCODING 50630
+STARTCHAR uniBED8
+ENCODING 48856
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-1010
-6E10
-8210
-83F0
-C610
-3C10
-0010
-4400
-2420
-3C20
-2460
-2450
-3C88
-2500
+0060
+0220
+A520
+A520
+E720
+A5E0
+A520
+E720
+A520
+3FC0
+0040
+0040
+1FC0
+1000
+1FF0
 ENDCHAR
-STARTCHAR C5C7
-ENCODING 50631
+STARTCHAR uniBEE0
+ENCODING 48864
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0810
-7C10
-C610
-8210
-83F0
-4610
-3C10
+0070
+0110
+0290
+CA90
+4B90
+7AF0
+4A90
+7B90
+4A90
 0010
-0190
-0110
-0380
-0660
-0810
-1008
+0FF0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR C5C8
-ENCODING 50632
+STARTCHAR uniBEE3
+ENCODING 48867
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0060
-1010
-7C10
-C610
-82F0
-8310
-C610
-3C10
-0010
-0820
-0820
-0860
-1650
-2288
-4108
+0030
+0590
+CA90
+4A90
+7B90
+4AF0
+4A90
+4B90
+7A90
+4910
+0090
+0180
+0340
+0430
+1808
 ENDCHAR
-STARTCHAR C5C9
-ENCODING 50633
+STARTCHAR uniBEE4
+ENCODING 48868
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0070
-1010
-3810
-C610
-8210
-83F0
-C610
-3C10
-0010
-0090
-0340
-0420
-0420
-0660
-03C0
+0060
+0320
+A920
+A920
+EF20
+A9E0
+A920
+EF20
+A820
+00C0
+0840
+1840
+14C0
+2330
+4210
 ENDCHAR
-STARTCHAR C5CA
-ENCODING 50634
+STARTCHAR uniBEE5
+ENCODING 48869
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0010
-7C10
-8210
-83F0
-C610
-7C10
-0010
-0000
-3FF0
-0100
-0300
+00E0
+0220
+9520
+9520
+F720
+95E0
+9520
+F720
+9520
+0120
 06C0
-0830
-3010
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR C5CC
-ENCODING 50636
+STARTCHAR uniBEEC
+ENCODING 48876
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0810
-7C10
-C610
-83F0
-8310
-4610
-3C10
+0090
+0050
+1B50
+D950
+5950
+7F50
+59D0
+5950
+5F50
+7950
+0050
+0050
 0010
-00F0
-1F30
-00E0
-3F20
-0040
-0040
+0010
 ENDCHAR
-STARTCHAR C5CE
-ENCODING 50638
+STARTCHAR uniBF01
+ENCODING 48897
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 11 15 3 -2
 BITMAP
-0030
-0810
-7C10
-C610
-83F0
-8210
-4610
-3C10
-0030
-1FF0
 0060
-0440
-0440
-3FF8
+0120
+06A0
+AAA0
+AAA0
+EFA0
+AAA0
+AAA0
+EEA0
+0120
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR C5D0
-ENCODING 50640
+STARTCHAR uniBF08
+ENCODING 48904
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-0190
-1090
-3890
-C490
-8490
-8790
-4490
-3890
-0090
-0090
-0090
-0090
+D490
+5490
+54F0
+7790
+5490
+5490
+54F0
+7790
+5410
+0010
+0010
+0010
 0010
 ENDCHAR
-STARTCHAR C5D1
-ENCODING 50641
+STARTCHAR uniBF09
+ENCODING 48905
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
+0020
 0190
-1090
-6890
-8490
-8790
-C490
-7890
-0090
+CA90
+4AF0
+7B90
+4A90
+4AF0
+7BD0
+4A10
 0000
 1FF0
-0810
 0010
 0010
 0010
 0010
-ENDCHAR
-STARTCHAR C5D4
-ENCODING 50644
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0030
-0190
-0090
-1090
-6C90
-8490
-8790
-C490
-7890
-0090
-0090
-0C10
-0400
-0408
-03FC
+0010
 ENDCHAR
-STARTCHAR C5D8
-ENCODING 50648
+STARTCHAR uniBF18
+ENCODING 48920
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0190
-1090
-6890
-8490
-8790
-C490
-7890
-0FE0
-0020
-0020
-1FE0
-0800
-0800
-0FF0
-ENDCHAR
-STARTCHAR C5E0
-ENCODING 50656
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0070
-0010
-0090
-1090
-6890
-8490
-8790
-C490
-7890
-0080
-0FF0
+0110
+CA90
+4AF0
+7B90
+4A90
+4AF0
+7B90
+4A10
+0000
+07F0
 0410
 0420
-0420
 07F0
 0400
 ENDCHAR
-STARTCHAR C5E1
-ENCODING 50657
+STARTCHAR uniBF19
+ENCODING 48921
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0060
-01B0
-1090
-6890
-8490
-8790
-C490
-7890
-0090
-0C30
+0030
+0190
+DA90
+52F0
+7390
+5290
+52F0
+7390
+5210
+0C60
 0420
 07E0
 0420
@@ -114359,1284 +117233,1176 @@
 07E0
 0420
 ENDCHAR
-STARTCHAR C5E3
-ENCODING 50659
+STARTCHAR uniBF1B
+ENCODING 48923
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-0110
-0090
-1090
-6C90
-8490
-8790
-C490
-7890
-0390
-0090
-0180
-0240
-0430
-1810
+0060
+0820
+9520
+9520
+F7E0
+9520
+9520
+F7E0
+8420
+0220
+0120
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR C5E5
-ENCODING 50661
+STARTCHAR uniBF1C
+ENCODING 48924
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-0070
-0190
-1090
-7890
-8490
-8490
-8790
-4C90
-3090
-0080
-0340
-0420
-0420
-0660
-03C0
+0060
+0020
+A520
+A520
+E7E0
+A520
+A5E0
+E720
+A400
+1060
+0C20
+0840
+16E0
+2290
+4108
 ENDCHAR
-STARTCHAR C5EC
-ENCODING 50668
+STARTCHAR uniBF1D
+ENCODING 48925
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0070
-0010
-0010
-1010
-7D70
-C690
-8210
-8210
-C7F0
-3C10
-0010
-0010
-0010
-0010
-0010
+0060
+0220
+6520
+A5E0
+A720
+E520
+A5E0
+E520
+A740
+0500
+07C0
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR C5ED
-ENCODING 50669
+STARTCHAR uniBF40
+ENCODING 48960
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -3
+BBX 15 12 1 0
 BITMAP
-1060
-3010
-4C10
-82F0
-8210
-C610
+0198
+0C88
+2488
+24F8
+3C88
+2488
+2488
+3CF8
+2588
+0100
+0100
+FFFE
+ENDCHAR
+STARTCHAR uniBF41
+ENCODING 48961
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+C510
+4510
 7DF0
-0010
-0010
+4510
+7DF0
+4710
+010C
+FFFC
+0000
 3FE0
-1020
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C5EE
-ENCODING 50670
+STARTCHAR uniBF44
+ENCODING 48964
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-1010
-6CF0
-8210
-8210
-C7F0
-7C10
+6688
+2688
+3CF8
+2488
+3CF8
+2788
+0100
+FFFE
 0000
-01F0
-7C10
-0410
-0410
-0410
-0410
-0400
-ENDCHAR
-STARTCHAR C5F0
-ENCODING 50672
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-1010
-6DF0
-8210
-8210
-C610
-7CF0
-0010
-0010
-1010
-0800
-0800
+0000
 0800
-0FF8
-ENDCHAR
-STARTCHAR C5F4
-ENCODING 50676
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-1010
-3010
-4CF0
-8210
-8210
-C7F0
-7C10
-0380
-0C60
-0020
-1FE0
 0800
 0800
-0FF8
+07F0
 ENDCHAR
-STARTCHAR C5F6
-ENCODING 50678
+STARTCHAR uniBF48
+ENCODING 48968
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0060
-0030
-1010
-6C10
-8270
-8210
-C610
-7DF0
-0010
-3DF0
-0530
-6D30
-3130
-2330
-3DF0
+8490
+4490
+7CF0
+4490
+7CF0
+4790
 0100
+FFFC
+0000
+7FC0
+0040
+3FC0
+1000
+1FF0
 ENDCHAR
-STARTCHAR C5F7
-ENCODING 50679
+STARTCHAR uniBF50
+ENCODING 48976
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0030
-0010
-1010
-6CF0
-8210
-8210
-C6F0
-7C10
-0010
-7D10
-09F0
-7D10
-2110
-25F0
-3910
+6248
+2248
+3E78
+2248
+3E78
+2148
+0100
+FFFE
+0000
+1FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR C5FC
-ENCODING 50684
+STARTCHAR uniBF51
+ENCODING 48977
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0030
-1010
-3810
-44F0
-8210
-8210
-C610
-7CF0
-0010
-0000
+6488
+2488
+3CF8
+2488
+2488
+3FF8
+2180
+FFFE
+1860
+0820
 0FE0
 0820
 0820
 0FE0
-0800
+0820
 ENDCHAR
-STARTCHAR C5FD
-ENCODING 50685
+STARTCHAR uniBF55
+ENCODING 48981
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-3010
-4CF0
-8210
-8210
-C2F0
-7C10
-0000
-0C70
-0420
-07E0
-0420
+4588
+2488
+3CF8
+2488
+2488
+3CF8
+2780
+01FE
+FF00
+03C0
 0420
-07E0
 0420
+0460
+03C0
 ENDCHAR
-STARTCHAR C5FE
-ENCODING 50686
+STARTCHAR uniBF94
+ENCODING 49044
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-1010
-6C10
-82F0
-8210
-C610
-7CF0
+0590
+0290
+4A90
+4B90
+7A90
+4B90
+7A90
+4890
+0870
+0FD0
+F810
 0010
-6200
-2230
-3E20
-2220
-2250
-3E88
-2304
-ENDCHAR
-STARTCHAR C5FF
-ENCODING 50687
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-1010
-7C10
-C6F0
-8210
-8210
-C7F0
-3C10
 0010
-0110
-0100
-0280
-0460
-0810
-3008
-ENDCHAR
-STARTCHAR C600
-ENCODING 50688
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-1010
-3810
-44F0
-8210
-8210
-C7F0
-3C10
-0000
-0820
-0C20
-0C60
-1250
-2298
-4108
-ENDCHAR
-STARTCHAR C601
-ENCODING 50689
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-1010
-1010
-6DF0
-8210
-8210
-C7F0
-3C10
 0010
-0080
-0340
-0420
-0420
-0660
-03C0
+0010
 ENDCHAR
-STARTCHAR C605
-ENCODING 50693
+STARTCHAR uniBFB0
+ENCODING 49072
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 12 1 0
 BITMAP
-0030
-1010
-3810
-C6F0
-8210
-8210
-C6F0
-3C10
-0000
-1FF0
-0800
-0800
-0FE0
-0800
-0FF0
+04C8
+2248
+2248
+3E78
+2248
+2248
+2248
+3E78
+2C60
+0420
+0440
+FFFE
 ENDCHAR
-STARTCHAR C606
-ENCODING 50694
+STARTCHAR uniBFC5
+ENCODING 49093
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 14 2 -2
 BITMAP
-0030
-1010
-3810
-46F0
-8210
-8210
-C7F0
-7C10
-0000
-0000
-1FF0
-0440
-0440
-0040
-3FF8
+C510
+4510
+7DF0
+4510
+7DF0
+4510
+0180
+F880
+07F8
+0700
+18C0
+1040
+18C0
+0F80
 ENDCHAR
-STARTCHAR C607
-ENCODING 50695
+STARTCHAR uniBFCC
+ENCODING 49100
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
 0010
-1010
-6DF0
-8210
-8210
-C7F0
-7C10
-0390
-0000
-1FF0
+6488
+2488
+3CF8
+2488
+2488
+3CF8
+2088
+FFFE
 0100
-06C0
-0440
-0380
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR C608
-ENCODING 50696
+STARTCHAR uniBFCD
+ENCODING 49101
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0030
-0390
-0090
-1090
-7890
-C790
-8490
-8490
-C490
-7B90
-0090
-0090
-0090
-0090
-0010
+0198
+3688
+12F8
+1E88
+1288
+1EF8
+128C
+FFFE
+0100
+0100
+1FF0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C60C
-ENCODING 50700
+STARTCHAR uniBFD0
+ENCODING 49104
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0090
-1090
-7890
-C790
-8490
-8490
-C790
-7890
-0090
-0090
-0C10
-0400
-0400
-03FC
+6688
+2288
+3EF8
+2288
+2288
+3EF8
+228C
+FFFE
+0100
+0100
+1900
+0900
+0800
+0FF8
 ENDCHAR
-STARTCHAR C610
-ENCODING 50704
+STARTCHAR uniBFD4
+ENCODING 49108
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0110
-1090
-7890
-8790
-8490
-C490
-7B90
-0080
+6490
+2490
+3CF0
+2490
+3CF0
+2484
+FFFE
+0100
+0100
 1FE0
 0020
 1FE0
 0800
-0800
 0FF0
 ENDCHAR
-STARTCHAR C618
-ENCODING 50712
+STARTCHAR uniBFDC
+ENCODING 49116
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -3
 BITMAP
-0030
-0190
-1090
-7890
-8790
-8490
-C490
-7B90
-0090
+6448
+2448
+3C78
+2448
+3C78
+2448
 0000
-0FF0
-0410
-0420
-0420
-07F0
-0400
+FFFE
+0100
+0100
+1EE0
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR C619
-ENCODING 50713
+STARTCHAR uniBFDF
+ENCODING 49119
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0030
-0190
-1090
-7890
-8790
-8490
-C490
-7B90
-0090
-0810
-0410
-07F0
-0410
-0410
-07F0
-0410
+6490
+2490
+3CF0
+2490
+3CF0
+2490
+FFFC
+0200
+0200
+0200
+0200
+0580
+1860
+2030
 ENDCHAR
-STARTCHAR C61B
-ENCODING 50715
+STARTCHAR uniBFE1
+ENCODING 49121
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0070
-0190
-1090
-7890
-8790
-8490
-8490
-CF90
-7890
-0090
-0190
-0180
-0340
-0430
-1810
+3648
+1248
+1E78
+1248
+1E78
+1248
+0000
+FFFE
+0100
+0380
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR C61C
-ENCODING 50716
+STARTCHAR uniC03C
+ENCODING 49212
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 15 15 1 -2
 BITMAP
-0030
-0190
-1090
-7890
-8790
-8490
-C490
-7B90
-0090
-0040
+0010
+6248
+2248
+3E78
+2248
+2248
+3E78
+2248
+FFFE
 0420
-0C60
-0E60
-1298
-2108
-4000
+0420
+0420
+0420
+0420
+0420
 ENDCHAR
-STARTCHAR C624
-ENCODING 50724
+STARTCHAR uniC051
+ENCODING 49233
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 0
+BBX 14 14 2 -2
 BITMAP
-0100
+6490
+2490
+3CF0
+2490
+3CD0
+2CF0
+3490
+CF6C
+0940
 07C0
-0C60
-0820
-0820
-0820
-0440
-0380
-0300
-0100
-0100
-FFFE
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR C625
-ENCODING 50725
+STARTCHAR uniC058
+ENCODING 49240
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 11 1 1
 BITMAP
-0100
-07C0
-0C60
-0820
-0820
-0460
-0380
-0100
-FFFE
+0188
+0688
+1288
+12F8
+1E88
+1288
+1288
+1EF8
+1288
 0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+FFFE
 ENDCHAR
-STARTCHAR C628
-ENCODING 50728
+STARTCHAR uniC05C
+ENCODING 49244
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0200
-0F80
-18C0
-1040
-1040
-0880
-0700
-0200
-FFFC
+0030
+C490
+4490
+7CF0
+4490
+4490
+7CF0
+4480
+03FC
+FF00
 0000
-2000
-1000
+3000
 1000
 1000
 1FF0
 ENDCHAR
-STARTCHAR C62C
-ENCODING 50732
+STARTCHAR uniC060
+ENCODING 49248
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
-0100
-0380
-0440
-0820
-0820
-0440
-0380
-0104
+0188
+2688
+12F8
+1E88
+1288
+1EF8
+1288
 FFFE
 0000
 1FE0
 0020
-0FE0
+0020
+1FE0
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR C62D
-ENCODING 50733
+STARTCHAR uniC068
+ENCODING 49256
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -2
+BBX 14 15 2 -2
 BITMAP
-0100
-0380
-0FC0
-0820
-0820
-0820
-06C0
-0104
-FFFE
+0020
+6510
+2510
+3DF0
+2510
+25F0
+3D10
+2400
+FFFC
 0000
-3EF0
-0210
-3610
-1810
-1110
-1E10
+3FC0
+1040
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR C62E
-ENCODING 50734
+STARTCHAR uniC069
+ENCODING 49257
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0100
-06C0
-0820
-0820
-0C60
-0380
-0100
+3288
+1288
+1EF8
+1288
+12F8
+1E80
+1200
 FFFE
-0000
-3EF8
-0290
-1C90
-16F0
-0880
+0C60
+0420
+07E0
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR C630
-ENCODING 50736
+STARTCHAR uniC090
+ENCODING 49296
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-0100
-06C0
-0820
-0820
-0C60
-07C0
-0100
-FFFE
-1E20
-0220
-3660
-1858
-1688
-1900
+0030
+0010
+0290
+D290
+5290
+5390
+7290
+5290
+5290
+7390
+5290
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C633
-ENCODING 50739
+STARTCHAR uniC091
+ENCODING 49297
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0100
-07C0
-0C60
-0820
-0820
-0440
-0380
-FFFE
+0030
+0110
+0290
+CA90
+4B90
+7A90
+4A90
+7B90
+4A10
 0000
-3E60
-03F8
-36C0
-18B0
-1690
-08F0
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C634
-ENCODING 50740
+STARTCHAR uniC094
+ENCODING 49300
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 13 15 3 -2
 BITMAP
-0100
-0380
-0C40
-0820
-0820
-0440
-0380
-0104
-FFFE
-0000
-1FF0
-0820
-0820
+0060
+0020
+2920
+9520
+9520
+F720
+9520
+9520
+F720
+9520
+0020
 0820
-0FE0
 0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C635
-ENCODING 50741
+STARTCHAR uniC098
+ENCODING 49304
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 11 15 3 -2
 BITMAP
-0100
-0380
-0C60
-0820
-0820
-0440
-0380
-0106
-FFF8
-1820
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0060
+0220
+9520
+9520
+F720
+9520
+9520
+F720
+9500
+3FC0
+0040
+3FC0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR C637
-ENCODING 50743
+STARTCHAR uniC0A0
+ENCODING 49312
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0100
-07C0
-0C60
-0820
-0820
-0440
-0380
-0104
-FFFE
+0030
+0010
+CA90
+4A90
+7B90
+4A90
+4A90
+7B90
+4A90
 0000
-0100
-0100
-02C0
-0430
-1810
+0FF0
+0410
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR C639
-ENCODING 50745
+STARTCHAR uniC0A1
+ENCODING 49313
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0100
-0380
-0C60
-0820
-0820
-06C0
-0100
-0104
-FFFE
-0100
-06C0
-0820
-0820
-0C60
-07C0
+0030
+0110
+CA90
+4A90
+7B90
+4A90
+4A90
+7B90
+4280
+0C30
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR C63B
-ENCODING 50747
+STARTCHAR uniC0A3
+ENCODING 49315
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 3 -2
 BITMAP
-0100
-07C0
-0C60
-0820
-0820
-04C0
+0060
+0020
+0220
+D520
+5520
+7720
+5520
+5520
+7720
+5620
+0120
 0300
-FFFE
-0000
-03C0
-0038
-1FC0
-0380
-0460
-1810
+02C0
+0C20
+1010
 ENDCHAR
-STARTCHAR C640
-ENCODING 50752
+STARTCHAR uniC0A5
+ENCODING 49317
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 00E0
+0320
+0520
+9520
+9720
+F520
+9520
+9520
+F720
+8500
+0780
+0840
+0840
+0C40
+0780
+ENDCHAR
+STARTCHAR uniC0AC
+ENCODING 49324
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0030
+0010
+0810
+0410
+0410
+0810
+1C10
+121E
+2310
+4110
+8010
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniC0AD
+ENCODING 49325
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
 0020
+1820
 0820
-3620
-4120
-4120
-4120
-3E2C
-0830
-09A0
-FE20
+1020
+382C
+4630
+8320
+0020
+0000
+3FE0
+1020
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C641
-ENCODING 50753
+STARTCHAR uniC0AF
+ENCODING 49327
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+1020
+0820
+1820
+1820
+242C
+4230
+8020
+0080
+F860
+0840
+0860
+0890
+0918
+0A08
+ENDCHAR
+STARTCHAR uniC0B0
+ENCODING 49328
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
 0030
 0010
-0E10
-3190
-2090
-3190
-1F1E
 0410
-8FD0
-7000
-1FF0
-0010
-0010
-0010
+0410
+0C10
+0C10
+131E
+2090
+C010
 0010
+1C10
+0400
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR C644
-ENCODING 50756
+STARTCHAR uniC0B3
+ENCODING 49331
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
 0030
-0410
-0E10
-3190
-3090
-3090
-1912
-061C
-0470
-FF90
 0010
 0C10
+0410
+0C10
+0C1E
+1310
+2090
+C010
+0000
+0FF0
 0400
 0400
-07F8
+0408
+03FC
 ENDCHAR
-STARTCHAR C648
-ENCODING 50760
+STARTCHAR uniC0B4
+ENCODING 49332
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
+0020
 0820
-3E20
-6320
-4120
-222C
-1C30
-0BA0
-F420
+0820
+1820
+343C
+4320
+8120
+0000
 1FE0
-0040
-0040
+0020
 1FE0
 0800
+0800
 0FF0
 ENDCHAR
-STARTCHAR C650
-ENCODING 50768
+STARTCHAR uniC0B5
+ENCODING 49333
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 15 2 -2
 BITMAP
 0060
-0030
-0E10
-3190
-2090
-3090
-1F16
-0638
-8FD0
-7010
-0FF0
-0410
-0410
+0020
+0820
+0820
+1820
+243C
+4320
+8120
+0000
+3DE0
 0420
-07F0
-0400
+7E20
+2020
+2620
+3820
 ENDCHAR
-STARTCHAR C651
-ENCODING 50769
+STARTCHAR uniC0B6
+ENCODING 49334
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 15 2 -2
 BITMAP
 0060
-0430
-0E10
-3190
-2090
-3190
-1F1E
-0430
-FFD0
-0C30
-0410
-07F0
-0410
-0410
-07F0
-0410
+1020
+0C20
+0820
+1820
+263C
+4120
+8020
+0000
+3DF0
+0520
+6D20
+3120
+21F0
+3F00
 ENDCHAR
-STARTCHAR C653
-ENCODING 50771
+STARTCHAR uniC0BC
+ENCODING 49340
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
 0060
-0420
-1E20
-2120
-2120
-2120
-1E3C
-04E0
-FF20
-0120
-0180
+0020
+0820
+0820
+1820
+142C
+2330
+C120
+0020
+1FE0
+0820
+0840
+0840
+0840
+0FE0
+0800
+ENDCHAR
+STARTCHAR uniC0BD
+ENCODING 49341
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0040
+0020
+0820
+0820
+1020
+283C
+4620
+8320
+0000
+1820
+0820
+0FE0
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniC0BF
+ENCODING 49343
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+1820
+0820
+1020
+3824
+2638
+4220
+8020
+01A0
+0080
 0180
 0240
 0430
-0808
-1000
+1808
 ENDCHAR
-STARTCHAR C654
-ENCODING 50772
+STARTCHAR uniC0C0
+ENCODING 49344
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0410
-1F10
-2090
-2090
-3090
-0F1E
-0450
-FF90
+0060
 0020
-0610
-0430
-0F30
-1948
-2084
+1820
+0820
+1020
+3C3C
+6220
+8120
+0000
+0C60
+0840
+0C40
+16B0
+2318
+C008
 ENDCHAR
-STARTCHAR C655
-ENCODING 50773
+STARTCHAR uniC0C1
+ENCODING 49345
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 15 1 -2
 BITMAP
 0030
+0010
 0410
-0E10
-3190
+0410
+0C10
+0C16
+1318
 2090
-3190
-1F1C
-0630
-9FD0
-6050
-01E0
+C010
+0050
+01A0
 0210
 0210
 0330
 01E0
-ENDCHAR
-STARTCHAR C65C
-ENCODING 50780
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0060
-0110
-0090
-1890
-6690
-4290
-4290
-2490
-18F0
-1190
-FE90
-0090
-0090
-0090
-0010
 ENDCHAR
-STARTCHAR C65D
-ENCODING 50781
+STARTCHAR uniC0C5
+ENCODING 49349
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0060
-0190
-1090
-6C90
-4490
-6490
-38F0
-1390
-FC90
+1020
+0C20
+0820
+1820
+343C
+6320
+8120
 0000
-1FF0
-0010
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR C660
-ENCODING 50784
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -2
-BITMAP
-0130
-0890
-7490
-4290
-4490
-3C90
-10F0
-0F90
-F090
-0090
-0810
+0FE0
+0820
+0FE0
 0800
 0800
-0FF8
+0FF0
 ENDCHAR
-STARTCHAR C66C
-ENCODING 50796
+STARTCHAR uniC0C8
+ENCODING 49352
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0060
+0030
+0010
 0190
+1090
+1890
+1090
+3090
+2890
+4CF0
+8490
 0090
-7C90
-4490
-4490
-3CF0
-1190
-FE90
-0000
-0FF0
-0420
-0420
-0420
-07F0
-0400
-ENDCHAR
-STARTCHAR C66F
-ENCODING 50799
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -2
-BITMAP
-0030
 0090
-3090
-4C90
-4490
-44F0
-3890
-1790
-E910
-0080
-0180
-0260
-0410
-1808
-ENDCHAR
-STARTCHAR C671
-ENCODING 50801
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0060
-0190
 0090
-7C90
-4290
-4490
-38F0
-1190
-FE90
 0090
-0360
-0410
-0410
-0630
-03E0
+0090
+0010
 ENDCHAR
-STARTCHAR C678
-ENCODING 50808
+STARTCHAR uniC0C9
+ENCODING 49353
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0070
-0810
-0810
-3610
-4110
-4110
-2310
-1C10
+0020
+0110
+1090
+0890
+1890
+1090
+2CF0
+4690
+8290
+0090
+1FF0
 0810
-09D0
-FE10
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C679
-ENCODING 50809
+STARTCHAR uniC0CC
+ENCODING 49356
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 14 15 1 -2
 BITMAP
-0060
-1820
-6620
-4220
-4220
-2420
-1820
-0FE0
-F020
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+0018
+0088
+0048
+0448
+0448
+0848
+1C48
+1278
+6248
+8048
+0048
+0C48
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR C67C
-ENCODING 50812
+STARTCHAR uniC0D0
+ENCODING 49360
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
 0020
-3C20
-4220
-4220
-4220
-3C20
-1020
-0FA0
-F020
+0110
+1090
+0890
+1090
+1090
+2CF0
+4490
+8090
+1FF0
 0020
-1800
-0800
-0800
-0FF0
-ENDCHAR
-STARTCHAR C680
-ENCODING 50816
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
-BITMAP
-0060
-0820
-7620
-4220
-4220
-2220
-1C20
-0FE0
-F020
-1FE0
-0040
-1FC0
+1FF0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR C688
-ENCODING 50824
+STARTCHAR uniC0D8
+ENCODING 49368
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
-0410
-3A10
-2110
-2110
-1210
-0C10
-0BF0
-FC10
-0000
+0020
+0110
+0090
+0890
+0890
+1090
+28F0
+4490
+8290
+0090
 0FF0
 0410
 0420
@@ -115644,22 +118410,22 @@
 07F0
 0400
 ENDCHAR
-STARTCHAR C689
-ENCODING 50825
+STARTCHAR uniC0D9
+ENCODING 49369
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
-0C10
-3310
-2110
-2110
-1210
+0020
+0110
+1890
+0890
+1090
+1090
+2CF0
+4690
+8090
 0C10
-0BF0
-F410
-0810
 0410
 07F0
 0410
@@ -115667,569 +118433,599 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR C68B
-ENCODING 50827
+STARTCHAR uniC0DB
+ENCODING 49371
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 16 2 -3
 BITMAP
-00C0
-0820
-3C20
-6620
-4220
-4220
-2420
-1860
-0FA0
-F020
-0320
-0300
-0480
-0860
-3010
+0030
+0190
+0090
+0890
+1890
+1090
+28F0
+4690
+8290
+0110
+0080
+0180
+0360
+0410
+0808
+1000
 ENDCHAR
-STARTCHAR C68D
-ENCODING 50829
+STARTCHAR uniC0DC
+ENCODING 49372
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 16 2 -3
 BITMAP
-0060
-0820
-7620
-4220
-4220
-2420
-1820
-17E0
-E820
-0020
-0780
-0840
-0840
-0CC0
-0780
+0030
+0190
+0890
+0890
+1090
+2890
+44F0
+8290
+0090
+0090
+0C20
+0460
+0C60
+1290
+2108
+4000
 ENDCHAR
-STARTCHAR C694
-ENCODING 50836
+STARTCHAR uniC0DD
+ENCODING 49373
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 12 15 2 -2
 BITMAP
-0100
-0100
-06C0
-0820
-0820
-0820
-0440
-03C0
-0420
-0420
-0444
-FFFE
-2000
+0030
+0110
+1090
+0890
+0890
+1090
+28F0
+4490
+8290
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR C695
-ENCODING 50837
+STARTCHAR uniC0E4
+ENCODING 49380
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0100
-07C0
-0C60
-0820
+00E0
+0020
+1020
+0C20
 0820
-0C40
-0FE0
-0420
-FFFE
-0000
-3FE0
+183C
+1820
+2420
+4220
+812C
+0030
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C698
-ENCODING 50840
+STARTCHAR uniC0E5
+ENCODING 49381
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-0100
-06C0
-0820
+0060
+0020
 0820
-0C60
-0FC0
-0420
-FF3E
-00C0
-0000
-0800
-0800
-0800
-0FF0
+0824
+1838
+3820
+4620
+833C
+0020
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C69C
-ENCODING 50844
+STARTCHAR uniC0E8
+ENCODING 49384
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0100
-07C0
-0860
-0820
-0820
-07C0
-0460
-0440
-FFFE
-0000
-1FE0
+0060
 0020
-1FE0
+1820
+0C20
+083C
+1820
+2420
+4320
+812C
+0030
+3020
+0820
 0800
+0810
 0FF0
 ENDCHAR
-STARTCHAR C6A4
-ENCODING 50852
+STARTCHAR uniC0EC
+ENCODING 49388
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 15 1 -2
 BITMAP
-0100
-07C0
-0820
-0820
-0820
-07C0
-0420
-0440
-FFFE
-0000
-0FF0
+0030
+0010
 0410
-0420
-0420
-07F0
+0410
+0C1E
+1A10
+1110
+609E
+8010
+0FF0
+0010
+0FF0
+0400
 0400
+07F8
 ENDCHAR
-STARTCHAR C6A5
-ENCODING 50853
+STARTCHAR uniC0F4
+ENCODING 49396
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 16 2 -3
 BITMAP
-0100
-07C0
-0820
-0820
-0820
-07C0
-0460
-044E
-FFB0
+0060
+0020
 1820
-0820
-0FE0
+0C24
+0838
+1820
+2620
+413C
+8020
+0000
+1FE0
 0820
 0820
+0840
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR C6A7
-ENCODING 50855
+STARTCHAR uniC0F5
+ENCODING 49397
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-0100
-06C0
+0060
+0020
+0820
+082C
+1030
+2C20
+423C
+8120
+0000
+1820
 0820
+0FE0
 0820
-0C60
-07C0
-0460
-0440
-FFFE
-0100
-0100
-02C0
-0430
-1818
+0FE0
+0820
 ENDCHAR
-STARTCHAR C6A9
-ENCODING 50857
+STARTCHAR uniC0F7
+ENCODING 49399
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0200
-0F80
-18C0
-1040
-1040
-0880
-1FC0
-0888
-FFFC
-0200
-0D80
-1040
-1040
-18C0
-0780
+0060
+0020
+1820
+082C
+1030
+3820
+2620
+423C
+8020
+01A0
+0180
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR C6B0
-ENCODING 50864
+STARTCHAR uniC0F9
+ENCODING 49401
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 15 2 -2
 BITMAP
-0100
-06C0
-0820
+0060
+0020
+0C20
 0820
-0C60
-07C0
-0000
-FFFE
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+083C
+1820
+2620
+4224
+8038
+00A0
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C6B1
-ENCODING 50865
+STARTCHAR uniC100
+ENCODING 49408
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 1 -2
 BITMAP
-0100
-07C0
-0C60
-0820
-0820
-0C60
-03C0
-0004
-FFFE
-0100
-0120
-0EE0
-0020
-0020
-0020
+0018
+00C8
+0048
+1848
+0C48
+0878
+1848
+1848
+2648
+4278
+8048
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR C6B4
-ENCODING 50868
+STARTCHAR uniC104
+ENCODING 49412
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 3 -2
+BBX 14 14 1 -2
 BITMAP
-0200
-0F80
-1040
-1040
-1040
-0D80
-0200
-FFF8
-0200
-0200
-1200
-1200
-1000
-1FE0
+0018
+00C8
+0448
+0448
+0878
+1448
+1248
+6378
+8048
+0048
+0C48
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR C6B8
-ENCODING 50872
+STARTCHAR uniC108
+ENCODING 49416
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0100
-07C0
-0860
-0820
-0820
-0440
-0384
-FFFE
-0100
-0100
-0EE0
-0040
+0030
+0190
+1090
+0890
+18F0
+1090
+28F0
+4490
+8080
+1FE0
+0020
 1FE0
 0800
+0800
 0FF0
-ENDCHAR
-STARTCHAR C6B9
-ENCODING 50873
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
-BITMAP
-0100
-06C0
-0C20
-0820
-0460
-03C0
-0000
-FFFE
-0100
-3F10
-0470
-3E10
-1010
-1310
-1C10
 ENDCHAR
-STARTCHAR C6BA
-ENCODING 50874
+STARTCHAR uniC110
+ENCODING 49424
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0100
-06C0
-0820
-0820
-0C60
-07C0
-0000
-FFFE
-0100
-1FF8
-04C8
-3E50
-1050
-1378
-1C00
+0060
+0110
+0090
+1890
+08F0
+1090
+2890
+44F0
+8490
+0090
+0FF0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR C6C0
-ENCODING 50880
+STARTCHAR uniC115
+ENCODING 49429
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -3
+BBX 12 15 2 -2
 BITMAP
-07C0
-0820
-0820
+0030
+0110
+1090
+0890
+10F0
+1090
+2890
+44F0
+8090
+0090
+0340
+0420
+0420
 0660
 03C0
-F800
-07FE
-0100
-1F00
-08E0
-0860
-0860
-0FE0
-0800
 ENDCHAR
-STARTCHAR C6C1
-ENCODING 50881
+STARTCHAR uniC11C
+ENCODING 49436
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-0100
-06C0
-0820
-0820
-0C60
-07C0
-0004
-FFFE
-0100
-1160
-0920
-0FE0
-0820
-0820
-0FE0
-0820
+0030
+0010
+1010
+0810
+0810
+1010
+30F0
+2810
+4610
+8210
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C6C3
-ENCODING 50883
+STARTCHAR uniC11D
+ENCODING 49437
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 1 -2
 BITMAP
-0F80
-08C0
-1040
-0840
-0480
-0300
-FFFC
-0200
-0200
-0200
-0200
-0580
-1860
-2000
+0038
+0808
+0408
+0408
+08F8
+1408
+2308
+4108
+8008
+1FF0
+0810
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C6C5
-ENCODING 50885
+STARTCHAR uniC11E
+ENCODING 49438
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0100
-03C0
-0420
-0420
-0420
-03C0
+0030
+1010
+0C10
+0810
+18F0
+1410
+2210
+C210
 0000
-FFFE
-0100
-0100
-07C0
-0860
-0820
-0C60
-07C0
+7DF0
+0410
+0410
+0410
+0410
+0410
 ENDCHAR
-STARTCHAR C6CC
-ENCODING 50892
+STARTCHAR uniC11F
+ENCODING 49439
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 2 -2
 BITMAP
 0030
 0810
-1E10
-2110
-2110
-2110
-1E10
-0190
-FE10
-09F0
 0810
 0810
+1010
+2CF0
+4610
+8210
+00D0
+3C60
+0440
+04A0
+0498
+0508
+ENDCHAR
+STARTCHAR uniC120
+ENCODING 49440
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0010
+0810
+0C10
 0810
+18F0
+2410
+4210
+8110
 0010
 0010
+1800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C6CD
-ENCODING 50893
+STARTCHAR uniC123
+ENCODING 49443
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
+0010
 0C10
-3310
-2110
-3110
-1E10
-0190
-FE30
-08D0
+0C10
+0830
+18D0
+2410
+4210
+8010
+0020
+1FE0
 0800
-1FF0
-0810
-0010
-0010
-0010
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR C6D0
-ENCODING 50896
+STARTCHAR uniC124
+ENCODING 49444
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 1 -2
 BITMAP
 0018
 0008
-0608
-1988
-1088
-1888
-0F08
-0188
-FE08
-0478
 0408
-0E08
-0200
-0200
-03FC
+0408
+08F8
+1C08
+3308
+4108
+8000
+0FF0
+0010
+0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR C6D4
-ENCODING 50900
+STARTCHAR uniC126
+ENCODING 49446
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0C10
-3310
-2110
-2110
-1E10
-0190
-FE70
-1FF0
+0070
 0010
-0020
-1FF0
-0800
-0800
-0FF0
+0810
+0810
+1810
+18F0
+2410
+4610
+8210
+0000
+7DF0
+0520
+7D20
+2120
+3DE0
+0100
 ENDCHAR
-STARTCHAR C6DC
-ENCODING 50908
+STARTCHAR uniC127
+ENCODING 49447
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 16 1 -3
 BITMAP
-0030
-0C10
-3310
-2110
-2110
-1E10
-0190
-FEF0
-0810
-0800
+0018
+0008
+0608
+0408
+0CF8
+0C08
+1308
+2108
+C000
+1F48
+0148
+0178
+0E48
+08C8
+0F78
+0048
+ENDCHAR
+STARTCHAR uniC12C
+ENCODING 49452
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
+BITMAP
+0038
+0008
+0608
+0408
+04F8
+0A08
+1108
+6088
+8008
+0000
 0FF0
 0410
-0420
+0410
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR C6DD
-ENCODING 50909
+STARTCHAR uniC12D
+ENCODING 49453
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
+0010
 0C10
-3310
-2110
-2110
-1E10
-0190
-FE70
-0890
-0830
+0810
+09F0
+1810
+2410
+4210
+8000
+1C30
 0410
 07F0
 0410
@@ -116237,118 +119033,163 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR C6E0
-ENCODING 50912
+STARTCHAR uniC12F
+ENCODING 49455
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0008
+0608
+0408
+0CF8
+0C08
+1308
+2108
+C008
+00C8
+0040
+00C0
+0130
+0208
+0C04
+ENDCHAR
+STARTCHAR uniC130
+ENCODING 49456
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0C10
-3310
-2110
-3110
-1E10
-0090
-FF10
-08F0
+1010
+0810
+0810
+19F0
+3410
+6610
+8210
 0000
-0C20
+0820
 0420
-0A60
-1298
-6108
+0C60
+1250
+2088
+4100
 ENDCHAR
-STARTCHAR C6E1
-ENCODING 50913
+STARTCHAR uniC131
+ENCODING 49457
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-1E10
-2110
-2110
-2110
-1E10
-0190
-FE10
-08F0
-0890
-03E0
-0610
+0010
+0810
+0C10
+09F0
+1810
+2410
+4210
+8010
+0080
+0360
 0410
+0410
 0630
-03C0
+01E0
 ENDCHAR
-STARTCHAR C6E8
-ENCODING 50920
+STARTCHAR uniC136
+ENCODING 49462
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0008
+0608
+0408
+0CF8
+0A08
+1108
+6188
+8000
+0FF8
+0040
+0220
+0220
+0040
+1FFC
+ENDCHAR
+STARTCHAR uniC138
+ENCODING 49464
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
-0030
+0018
 0088
 0048
-0848
-3648
-2248
-3248
-1C48
-0348
-FC48
-09C8
 0848
+0C48
 0848
+1BC8
+1848
+2448
+4248
+8048
 0048
+0048
+0048
 0008
 ENDCHAR
-STARTCHAR C6E9
-ENCODING 50921
+STARTCHAR uniC139
+ENCODING 49465
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0190
-7C90
-4290
+0110
+0090
+0890
+1890
+1390
+2890
 4490
-3C90
-0190
-FE90
-1790
-1080
+8490
+0000
 1FF0
 0010
 0010
 0010
 0010
+0010
 ENDCHAR
-STARTCHAR C6EC
-ENCODING 50924
+STARTCHAR uniC13C
+ENCODING 49468
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0070
-0010
+0030
+0110
+0090
 0890
-3690
-4290
-2690
-1C90
-0290
-FC90
-0B90
+0890
+1090
+2B90
+4490
+8490
 0090
-1C00
-0400
-0400
-07F8
+0090
+0890
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C6F0
-ENCODING 50928
+STARTCHAR uniC140
+ENCODING 49472
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
@@ -116356,2262 +119197,2726 @@
 0030
 0110
 0090
-7C90
+0890
+0890
+1790
+2890
 4490
-6490
-3C90
-0290
-FF90
-1FF0
-1020
+8480
 0FF0
-0400
+0010
+0010
+0FF0
 0400
-03F8
+07F8
 ENDCHAR
-STARTCHAR C6F8
-ENCODING 50936
+STARTCHAR uniC148
+ENCODING 49480
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
 0110
 0090
-7C90
-4290
+0890
+1890
+1790
+2890
 4490
-3C90
-0190
-FF90
-1080
-1FF0
-0410
+8090
+0000
+07F0
 0420
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR C6F9
-ENCODING 50937
+STARTCHAR uniC149
+ENCODING 49481
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0030
-0990
-7490
-4290
-4490
-3C90
+0030
 0190
-FE90
+1090
+0890
+1890
 1790
-1C90
+2890
+4490
+8480
+0C10
 0410
 07F0
 0410
-0410
 07F0
 0410
 ENDCHAR
-STARTCHAR C6FD
-ENCODING 50941
+STARTCHAR uniC14B
+ENCODING 49483
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 15 2 -2
+BITMAP
+0030
+0110
+0090
+1890
+1890
+1090
+3390
+4890
+8490
+0210
+0180
+0180
+0240
+0430
+1810
+ENDCHAR
+STARTCHAR uniC14C
+ENCODING 49484
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
 0018
-0048
-0048
-3E48
-2248
-2248
-1E48
 00C8
-FF48
+1848
+0448
 0848
-09E0
-0210
+1BC8
+1448
+2248
+C248
+0430
 0210
 0210
-01E0
+0528
+08C4
+1086
 ENDCHAR
-STARTCHAR C704
-ENCODING 50948
+STARTCHAR uniC14D
+ENCODING 49485
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0820
-3C20
-4220
-4220
-4220
-3C20
-0020
-01A0
-FE20
-0820
-0820
-0820
-0820
-0020
+0030
+0190
+1090
+0890
+1090
+1390
+2C90
+4490
+8090
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR C705
-ENCODING 50949
+STARTCHAR uniC154
+ENCODING 49492
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0C10
-3310
-2110
-3110
-1E10
 0070
-FF90
-0410
-0410
-1FF0
+0010
+1010
+0810
+09F0
+1010
+1810
+2430
+44D0
+8210
+0010
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C708
-ENCODING 50952
+STARTCHAR uniC155
+ENCODING 49493
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0030
+0018
+0808
+0408
+0478
+0C08
+1C08
+13F8
+6108
+8008
+0FF8
+0008
+0008
+0008
+0008
+0008
+ENDCHAR
+STARTCHAR uniC158
+ENCODING 49496
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0070
 0010
-1E10
-2110
-2110
-3110
-1E10
-00D0
-FF10
-0410
+0810
+09F0
+1810
+1010
+2810
+46F0
+8210
 0010
-0C00
+1C10
 0400
 0400
-07F8
+0400
+07FC
 ENDCHAR
-STARTCHAR C70C
-ENCODING 50956
+STARTCHAR uniC15C
+ENCODING 49500
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0030
-0C10
-3310
-2110
-3110
-1E10
-0190
-FE10
+0070
+1010
 0810
-0800
+09F0
+1010
+2C10
+4610
+82F0
+0010
 1FE0
+0020
 1FE0
 0800
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR C714
-ENCODING 50964
+STARTCHAR uniC164
+ENCODING 49508
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 1 -2
 BITMAP
-0030
-0C10
-3310
-2110
-3110
-1E10
-0070
-FF90
-0410
+0038
+0008
+0408
+0478
+0808
+1408
+2308
+4178
+8008
 0000
-0FF0
-0410
-0420
-0420
-07F0
-0400
+03F8
+0208
+0208
+03F8
+0200
 ENDCHAR
-STARTCHAR C715
-ENCODING 50965
+STARTCHAR uniC165
+ENCODING 49509
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-1E10
-3110
-2110
-2110
-1E10
-00F0
-FF10
-0410
-0810
-0410
-07F0
-0410
-0410
-07F0
-0410
-ENDCHAR
-STARTCHAR C717
-ENCODING 50967
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0020
 0010
 0C10
-3310
-2110
-3110
-1E10
-01D0
-FE10
-0510
-0480
-0180
-0240
-0430
-1808
-ENDCHAR
-STARTCHAR C719
-ENCODING 50969
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
 0C10
-3310
-2110
-3110
-1E10
-00D0
-FF10
-0410
-0080
-0340
+08F0
+1810
+2410
+46F0
+8210
+0C20
 0420
+07E0
 0420
-0660
-03C0
-ENDCHAR
-STARTCHAR C720
-ENCODING 50976
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -3
-BITMAP
-0200
-0D80
-1040
-1040
-18C0
-0F80
-0000
-FFFC
-4880
-0880
-0880
-0880
-0880
-0880
-0080
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR C721
-ENCODING 50977
+STARTCHAR uniC167
+ENCODING 49511
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 14 15 1 -2
 BITMAP
-0200
-0D80
-1040
-1040
-18C0
-0F80
+0018
 0008
-FFF0
-0880
-0FC0
-1040
-0040
-0040
-0040
+0408
+0478
+0808
+1C08
+13F8
+2108
+C008
+0088
+0080
+01C0
+0330
+0408
+1804
 ENDCHAR
-STARTCHAR C724
-ENCODING 50980
+STARTCHAR uniC168
+ENCODING 49512
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 1 -2
 BITMAP
-0200
-0D80
-1040
-1040
-18C0
-0F80
-001C
-FFE4
-0840
-0840
-3040
-1000
-1000
-1FF0
+0038
+0C08
+0608
+04F8
+0C08
+1C08
+32F8
+4108
+8008
+0410
+0610
+0630
+0928
+1144
+2084
 ENDCHAR
-STARTCHAR C728
-ENCODING 50984
+STARTCHAR uniC169
+ENCODING 49513
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0200
-0D80
-1040
-1040
-18C0
-0F80
-0000
-FFFC
-0880
-0880
-3FC0
+0018
+0008
+0608
+04F8
+0C08
+0C08
+12F8
+2108
+C008
 0040
-3FC0
-1000
-1FE0
+01B0
+0208
+0208
+0318
+01F0
 ENDCHAR
-STARTCHAR C730
-ENCODING 50992
+STARTCHAR uniC170
+ENCODING 49520
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 15 1 -2
 BITMAP
-0200
-0F80
-18C0
-1040
-1040
-0880
-0700
-FFFC
-0880
-0880
-3FC0
-1040
-1080
-1080
-1FC0
-1000
+0018
+0008
+00C8
+1848
+0C48
+0BC8
+0848
+1848
+2448
+47C8
+8248
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR C731
-ENCODING 50993
+STARTCHAR uniC174
+ENCODING 49524
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 13 15 2 -2
 BITMAP
-0100
-07C0
-0860
-0820
-0840
-06C0
-0104
-FFFA
-0440
-1840
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0030
+0010
+0190
+0890
+0F90
+1090
+1890
+2F90
+4490
+8090
+0090
+0890
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C733
-ENCODING 50995
+STARTCHAR uniC178
+ENCODING 49528
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0200
-0F80
-18C0
-1040
-1040
-0880
-0700
-FFFC
-0840
-0840
-0A40
-0240
-0580
-0860
-3030
+0030
+0010
+0190
+1890
+0890
+1390
+3890
+4F90
+8480
+1FE0
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR C735
-ENCODING 50997
+STARTCHAR uniC185
+ENCODING 49541
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-0200
-0D80
-1040
-1040
-18C0
-0780
-7800
-9FFC
-1040
-0700
-18C0
-1040
-18C0
-0F80
+0030
+0110
+2090
+1890
+1790
+3090
+2890
+4F90
+8490
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR C737
-ENCODING 50999
+STARTCHAR uniC18C
+ENCODING 49548
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 12 1 0
 BITMAP
+0300
+0180
+0300
+0300
+04E0
+1818
+2004
+0200
 0100
-07C0
-0820
-0820
-0820
-06C0
 0100
-FFFE
-0440
-0240
-0180
-1FF8
 0100
-03C0
-0430
-3800
+FFFE
 ENDCHAR
-STARTCHAR C73C
-ENCODING 51004
+STARTCHAR uniC18D
+ENCODING 49549
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 15 1 -2
 BITMAP
+0300
+0180
+0300
+04F0
+180C
+2300
 0100
-0EC0
-1020
-1020
-1020
-0840
-0780
-0000
-0000
-0000
+0100
 FFFE
+0000
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C73D
-ENCODING 51005
+STARTCHAR uniC18E
+ENCODING 49550
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 14 15 2 -2
 BITMAP
+0400
+0300
 0200
-1D80
-1040
-1040
-18C0
-0780
-0000
+0580
+1878
+6200
+0200
 FFFC
 0000
-7FC0
-0040
-0040
-0040
-0040
-0040
+0000
+FBE0
+0820
+0820
+0820
+0820
 ENDCHAR
-STARTCHAR C740
-ENCODING 51008
+STARTCHAR uniC190
+ENCODING 49552
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
+0200
+0180
 0100
-06C0
-0820
-0820
-0820
-07C0
-0004
+0380
+0C78
+1204
+2100
+0100
 FFFE
-2000
 0000
-1800
+1000
 0800
 0800
-0FF8
+0810
+07F8
 ENDCHAR
-STARTCHAR C744
-ENCODING 51012
+STARTCHAR uniC194
+ENCODING 49556
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 15 15 1 -2
 BITMAP
+0200
+0180
 0100
 06C0
-0820
-0820
-0C60
-07C0
-FE00
-01FC
+0838
+3100
+0100
+FFFE
 0000
 1FE0
 0020
-1FE0
+0020
+0FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR C74A
-ENCODING 51018
+STARTCHAR uniC196
+ENCODING 49558
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 16 2 -3
 BITMAP
 0200
-0F80
-10C0
-1040
-1040
-0D80
-0208
+0300
+0700
+08F0
+3008
+4200
+0200
 FFFC
 0000
-0270
-7DC0
-0920
-7D20
-2140
-3BF8
+0000
+7DF0
+0910
+6D20
+3120
+3DF0
+0100
 ENDCHAR
-STARTCHAR C74C
-ENCODING 51020
+STARTCHAR uniC19C
+ENCODING 49564
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
+0200
+0180
+0300
+06C0
+0838
+3100
 0100
-0EC0
-0820
-0820
-0C60
-07C0
-0000
 FFFE
 0000
-0FF0
+0000
+1FE0
 0820
 0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR C74D
-ENCODING 51021
+STARTCHAR uniC19D
+ENCODING 49565
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 14 15 2 -2
 BITMAP
+0600
 0200
-0D80
+0700
+08F0
+3408
+C200
+0200
+FFFC
+0000
+3040
 1040
+1FC0
 1040
-18C0
-0F80
-0000
-FFFC
-1840
-0840
-0FC0
-0840
-0840
-0FC0
-0840
+1FC0
+1040
 ENDCHAR
-STARTCHAR C74F
-ENCODING 51023
+STARTCHAR uniC19F
+ENCODING 49567
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 15 1 -3
 BITMAP
+0300
 0100
 0300
-04C0
-0820
-0820
-0C60
-03C0
-0004
-FFFE
-0000
+04F0
+1B08
+2100
 0100
+FFFE
+0200
 0100
-02C0
-0430
-1810
+0300
+06C0
+0830
+1010
+2000
 ENDCHAR
-STARTCHAR C751
-ENCODING 51025
+STARTCHAR uniC1A1
+ENCODING 49569
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
+0180
 0100
-06C0
-0820
-0820
-0C60
-07C0
-0004
+0280
+0C78
+3300
+0100
+0100
 FFFE
-2100
+0100
 07C0
 0C60
 0820
 0C60
 07C0
 ENDCHAR
-STARTCHAR C752
-ENCODING 51026
+STARTCHAR uniC1A5
+ENCODING 49573
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 15 1 -2
 BITMAP
+0300
 0100
-07C0
-0860
-0820
-0820
-0440
 0380
+0478
+180C
+6100
+0100
 FFFE
-0000
+2000
 0000
-3FF8
-0100
-0300
-06C0
-0C30
-3018
+0FF0
+0800
+0FE0
+0810
+0FF0
 ENDCHAR
-STARTCHAR C753
-ENCODING 51027
+STARTCHAR uniC1A8
+ENCODING 49576
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
-0100
-06C0
-0840
-0820
-0C40
-0780
-0000
-FFFE
+0030
+0010
+0C10
+0410
+0410
+0B90
+1050
+6C16
+8418
+0470
+0F90
+7010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniC1A9
+ENCODING 49577
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
+BITMAP
+0030
+0410
+0210
+0410
+1BD0
+2C12
+441C
+04F0
+FF10
 0000
-03C0
-0038
-1FC0
-0380
-0660
-1810
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C754
-ENCODING 51028
+STARTCHAR uniC1AC
+ENCODING 49580
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0030
+0010
+0410
+0610
+0C10
+13D0
+6416
+0438
+8FD0
+7010
+0010
+0C10
+0400
+0400
+07FC
+ENDCHAR
+STARTCHAR uniC1B0
+ENCODING 49584
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0030
+0610
+0610
+0E10
+11D0
+6416
+0418
+9FF0
+6000
+0FF0
+0010
+0FF0
+0400
+0400
+07FC
+ENDCHAR
+STARTCHAR uniC1BD
+ENCODING 49597
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 14 2 -2
 BITMAP
-0200
-0D80
-1040
-1040
-1880
-0F00
-0000
-FFF8
-0000
-1FE0
 0060
-7FC0
-0040
-0080
+0C20
+0C20
+1E20
+21E0
+C020
+0C38
+09E0
+FEA0
+0360
+0420
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR C755
-ENCODING 51029
+STARTCHAR uniC1C4
+ENCODING 49604
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-0100
-06C0
-0820
-0820
-0C40
-0780
-FC00
-03FC
-0FE0
-0800
-0800
-0FE0
+0060
+0110
+1090
+0890
+1090
+3C90
+4290
+8090
+18F0
+1090
+1F90
+E090
+0090
+0090
+0010
+ENDCHAR
+STARTCHAR uniC1C8
+ENCODING 49608
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -2
+BITMAP
+0030
+0190
+0890
+1890
+2E90
+4090
+18F0
+1090
+1F90
+E090
+1890
+0810
 0800
+0FF8
+ENDCHAR
+STARTCHAR uniC1CC
+ENCODING 49612
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 1 -2
+BITMAP
+0098
+0848
+0448
+0848
+3748
+0878
+0848
+FFC8
+0FF0
+0010
+0010
 0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR C756
-ENCODING 51030
+STARTCHAR uniC1D4
+ENCODING 49620
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 1 -2
 BITMAP
-0100
-06C0
-0820
-0820
-0C60
-07C0
-0000
-FFFE
-0000
-1FE0
-0440
-0240
-0080
-3FF8
+0020
+0098
+0048
+0448
+0848
+1748
+7878
+0848
+8FC8
+7000
+07F8
+0208
+0210
+0210
+03E0
 ENDCHAR
-STARTCHAR C757
-ENCODING 51031
+STARTCHAR uniC1D7
+ENCODING 49623
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 14 2 -2
 BITMAP
-0100
-06C0
-0820
-0820
-0C40
-07C0
-0000
-FFFE
-0000
-03C0
-1FF8
-0100
-06C0
-0640
-03C0
+0130
+0090
+0890
+1090
+2E90
+F0F0
+1090
+1790
+EB10
+0180
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR C758
-ENCODING 51032
+STARTCHAR uniC1D8
+ENCODING 49624
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -2
+BITMAP
+0098
+0848
+0448
+0848
+1748
+7878
+0848
+FFC8
+2030
+0210
+0210
+0528
+08C4
+1084
+ENDCHAR
+STARTCHAR uniC1E0
+ENCODING 49632
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
+0C10
+0410
 0810
-3E10
-4110
-4110
-4110
-3E10
-0010
-01D0
-FE10
-0010
+1710
+20D0
+4810
+8410
+0410
+07D0
+7810
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C75C
-ENCODING 51036
+STARTCHAR uniC1E4
+ENCODING 49636
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0410
-1A10
-2110
-2110
-3310
-1E10
 0010
-01F0
-FE10
+0410
+0410
+0E10
+31D0
+4410
+0430
+DFD0
+2010
 0010
-0C10
+0C00
 0400
 0400
-03F8
+07F8
 ENDCHAR
-STARTCHAR C760
-ENCODING 51040
+STARTCHAR uniC1E8
+ENCODING 49640
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0020
-1C20
-6220
-4220
-4620
-3C20
-03E0
-FC20
+0030
+0810
+0410
+0810
+1790
+6C10
+0410
+05F0
+FA10
+0000
 1FE0
 0020
-0040
 1FE0
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR C768
-ENCODING 51048
+STARTCHAR uniC1F0
+ENCODING 49648
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 11 15 3 -2
 BITMAP
 0060
-0020
-3820
-4620
-4220
-4620
-3C20
-03E0
-FC20
+1020
+0820
+1020
+2F20
+D820
+0820
+0BE0
+F420
+0000
 1FE0
 0820
 0840
 0840
-0FE0
-0800
+0F80
 ENDCHAR
-STARTCHAR C76B
-ENCODING 51051
+STARTCHAR uniC1F1
+ENCODING 49649
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 3 -3
+BBX 11 16 3 -3
 BITMAP
 0060
-0020
-1820
-6620
-4220
-4220
-3C20
-0020
-03E0
-FE20
-0320
-0300
-04C0
+1020
+0820
 1820
-2010
-4000
+2720
+D820
+0820
+0FE0
+F020
+1840
+0840
+0FC0
+0840
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR C774
-ENCODING 51060
+STARTCHAR uniC1F3
+ENCODING 49651
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-0010
-0010
-7C10
-C610
-8210
-8210
-C610
-3C10
-0010
-0010
-0010
 0010
+0410
+0C10
+1F90
+2810
+C410
+04F0
+FF10
 0010
+0180
+0180
+0240
+0430
+1818
 ENDCHAR
-STARTCHAR C775
-ENCODING 51061
+STARTCHAR uniC1FC
+ENCODING 49660
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 16 12 1 0
 BITMAP
-0060
-0010
-1010
-6C10
-8210
-8210
-C610
-7C10
+0200
+0180
+0100
+0380
+0478
+080C
+3000
+0860
+0420
+0420
+0420
+FFFF
+ENDCHAR
+STARTCHAR uniC1FD
+ENCODING 49661
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0200
+0100
+0100
+0380
+0C78
+1044
+2420
+0420
+FFFE
 0000
-01E0
-1E20
+3FE0
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C778
-ENCODING 51064
+STARTCHAR uniC200
+ENCODING 49664
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-1010
-3810
-C410
-8210
-8210
-C610
-3C10
-0010
-3010
-0800
-0800
+0100
+0180
+0300
+06F0
+084C
+3440
+0440
+FFFE
+0000
+1000
 0800
-0FF0
-ENDCHAR
-STARTCHAR C77C
-ENCODING 51068
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-1010
-6C10
-8210
-8210
-C610
-3C10
-0010
-1FF0
-0020
-0020
-1FF0
 0800
 0800
-0FF8
+07F8
 ENDCHAR
-STARTCHAR C77D
-ENCODING 51069
+STARTCHAR uniC204
+ENCODING 49668
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0030
-0010
-0810
-7410
-8210
-8210
-C610
-7C10
+0200
+0300
+0700
+08F0
+3840
+4840
+FFFC
 0000
-7DE0
-0420
-4C20
-3020
-2220
-3C20
+3FC0
+0040
+0040
+1FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR C77E
-ENCODING 51070
+STARTCHAR uniC20C
+ENCODING 49676
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -3
 BITMAP
-0030
-0010
-1010
-6C10
-8210
-8210
-C610
-7C10
+0300
+0200
+0580
+1870
+2088
+4840
+0840
+FFFC
 0000
-7FF0
-0520
-6D20
-3120
-23E0
-3D00
+1FE0
+0820
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR C783
-ENCODING 51075
+STARTCHAR uniC20D
+ENCODING 49677
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 2 -3
 BITMAP
-0060
-1020
-F820
-8420
-8420
-8420
-7820
+0200
+0300
+0700
+08F0
+3848
+4840
+FFFC
 0000
-F9C0
-0FF0
-9880
-6360
-4620
-7A20
-01C0
+1840
+0840
+0FC0
+0840
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR C784
-ENCODING 51076
+STARTCHAR uniC20F
+ENCODING 49679
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0030
-1010
-1010
-6C10
-8210
-8210
-C610
-3C10
-0010
+0200
+0300
+0700
+08F0
+3848
+C840
+FFFC
 0000
-1FE0
-0820
-0820
-0820
-0FE0
-0800
+0600
+0200
+0700
+0CC0
+1060
+2010
 ENDCHAR
-STARTCHAR C785
-ENCODING 51077
+STARTCHAR uniC211
+ENCODING 49681
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-1010
-6C10
-8210
-8210
-C610
-3C10
-0010
-1810
-0810
-0FF0
-0810
-0810
-0FF0
-0810
+0100
+0180
+0380
+0478
+1C24
+6420
+FFFE
+0000
+03C0
+0660
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR C787
-ENCODING 51079
+STARTCHAR uniC218
+ENCODING 49688
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0030
-1010
-1010
-6C10
-8210
-8210
-C610
-3C10
-0010
-0310
+0200
 0180
 0100
 02C0
-0430
-1810
+0C3C
+3000
+0000
+83FE
+FF00
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR C788
-ENCODING 51080
+STARTCHAR uniC219
+ENCODING 49689
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 15 15 1 -2
 BITMAP
-0060
+0300
+0100
+0300
+04F0
+180C
+6000
+0004
+FFFE
+0100
+0100
+21E0
+1E20
 0020
-1020
-6C20
-8220
-8220
-C420
-7820
-0000
-1040
-0840
-18C0
-24A0
-4110
-8600
+0020
+0020
 ENDCHAR
-STARTCHAR C789
-ENCODING 51081
+STARTCHAR uniC21C
+ENCODING 49692
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0030
-1010
-3810
-C410
-8210
-8210
-4610
-3810
-0010
+0200
+0180
 0100
-06C0
-0820
-0820
-0C60
-07C0
+0280
+0C78
+1000
+2004
+FFFE
+0100
+0100
+0100
+0900
+0900
+0800
+07F8
 ENDCHAR
-STARTCHAR C78A
-ENCODING 51082
+STARTCHAR uniC21F
+ENCODING 49695
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-1010
-7C10
-C610
-8210
-8210
-4410
-3810
-0030
+0400
+0300
+0200
+0580
+1870
+6000
+0000
+FFFC
+0200
+0240
 3FC0
+1000
+1000
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniC220
+ENCODING 49696
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+0300
+0180
+0300
+04F8
+1808
+2004
+FFFE
 0100
-0280
-0460
-1830
-6000
+0100
+0EE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR C78E
-ENCODING 51086
+STARTCHAR uniC228
+ENCODING 49704
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 15 16 1 -3
 BITMAP
-0030
-1010
-7C10
-8210
-8210
-8210
-4410
-3810
+0300
+0100
+0300
+0CF8
+1000
+2000
 0000
-1FE0
+FFFE
+0100
+0100
+1960
+0EA0
+0820
 0840
-0440
-0480
-3FF8
+0FE0
+0800
 ENDCHAR
-STARTCHAR C790
-ENCODING 51088
+STARTCHAR uniC229
+ENCODING 49705
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 16 1 -3
 BITMAP
-0060
-0010
-0010
-7F10
-0110
-0210
-0610
-0416
-0A18
-1190
-6090
-8010
-0010
-0010
-0010
+0300
+0100
+0380
+0478
+1804
+6000
+0000
+FFFE
+0100
+1960
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C791
-ENCODING 51089
+STARTCHAR uniC22B
+ENCODING 49707
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0080
-0060
-0020
-7F20
-0220
-0420
-083C
-1620
-2120
-C020
-3FE0
-0020
-0020
-0020
-0020
-0020
+0180
+0100
+06E0
+081C
+3000
+0000
+FFFE
+0100
+0100
+0100
+0100
+0280
+0470
+1818
 ENDCHAR
-STARTCHAR C794
-ENCODING 51092
+STARTCHAR uniC22D
+ENCODING 49709
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0080
-0060
-0020
-7F20
-0320
-0220
-042C
-0B30
-11A0
-60A0
-8820
-0420
-0400
-0408
-07FC
+0300
+0180
+0100
+02C0
+0C3C
+3000
+0004
+FFFE
+0100
+07C0
+0C60
+0820
+0820
+0460
+03C0
 ENDCHAR
-STARTCHAR C796
-ENCODING 51094
+STARTCHAR uniC22F
+ENCODING 49711
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-0080
-0060
-7E20
-0620
-0420
-0C3C
-1320
-6120
-81F0
-6F80
-20C0
-2320
-2620
-3B20
-01C0
+0400
+0200
+0600
+0DC0
+3038
+C008
+0FFC
+FA00
+0200
+0F00
+03F0
+7E00
+0200
+0580
+0860
+3010
 ENDCHAR
-STARTCHAR C797
-ENCODING 51095
+STARTCHAR uniC231
+ENCODING 49713
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0060
-0020
-7F20
-0220
-0420
-083C
-1620
-2120
-C020
-0020
+0400
+0300
+0600
+0DE0
+1010
+E000
+0FFC
+FE00
+0200
 1FE0
-0800
-0800
-0810
-0FF0
+1000
+1000
+1FC0
+1000
+1FF0
 ENDCHAR
-STARTCHAR C798
-ENCODING 51096
+STARTCHAR uniC232
+ENCODING 49714
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
-0020
-7E20
-0620
-0420
-0C20
-133C
-6120
-8020
-1FE0
+0300
+0100
+0300
+04F8
+180C
+6004
+FFFE
+0100
+0100
+1FF0
 0040
-1FE0
-0800
-0800
-0FF0
+0440
+0040
+3FF8
 ENDCHAR
-STARTCHAR C79A
-ENCODING 51098
+STARTCHAR uniC234
+ENCODING 49716
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-7F20
-0220
-0420
-083C
-1620
-2120
-C000
-3DF0
-0520
-6D20
-3120
-23E0
-3D00
+0030
+0010
+0410
+0C10
+1C10
+23D0
+C010
+0010
+0F90
+F810
+08F0
+0810
+0810
+0810
+0010
 ENDCHAR
-STARTCHAR C7A0
-ENCODING 51104
+STARTCHAR uniC248
+ENCODING 49736
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-00C0
-0020
-FE20
-0620
-0420
-0820
-1638
-2120
-C020
-0000
-1FE0
-0820
-0840
+0030
+0810
+0610
+0C10
+3390
+4010
+0090
+FF30
+08D0
 0840
-0FE0
-0800
+0420
+0420
+0A50
+1288
+2108
 ENDCHAR
-STARTCHAR C7A1
-ENCODING 51105
+STARTCHAR uniC250
+ENCODING 49744
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -3
+BBX 12 15 2 -2
 BITMAP
-00C0
-0040
-FE40
-0440
-0840
-1878
-3440
-4240
-B040
-1040
-1FC0
-1040
-1040
-1FC0
-1040
+0030
+0110
+1090
+0890
+1890
+3890
+4690
+8090
+0C90
+F090
+1390
+1090
+1090
+0090
+0010
 ENDCHAR
-STARTCHAR C7A3
-ENCODING 51107
+STARTCHAR uniC251
+ENCODING 49745
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 16 1 -3
 BITMAP
-00C0
-0020
-FE20
-0620
-0420
-0820
-163C
-6120
-8020
-0120
-01A0
-0380
-0240
-0C30
-1008
+0030
+0098
+0848
+0448
+1848
+27C8
+C048
+FF48
+0BC8
+0848
+0FF8
+0408
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR C7A4
-ENCODING 51108
+STARTCHAR uniC254
+ENCODING 49748
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-00C0
 0020
-7F20
-0220
-0420
-0C24
-1338
-2120
-C020
-0860
-0C20
-0840
-1670
-2298
-4108
+0110
+0090
+0C90
+1890
+2790
+C090
+0290
+7C90
+0B90
+0090
+0C10
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR C7A5
-ENCODING 51109
+STARTCHAR uniC258
+ENCODING 49752
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0020
-7F20
-0220
-0420
-083C
-1620
-2120
-C020
-0080
-0340
-0420
-0420
-0660
-03C0
+0030
+0090
+1050
+0850
+1850
+2650
+C050
+FC50
+13D0
+1000
+0FF0
+0010
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR C7A6
-ENCODING 51110
+STARTCHAR uniC260
+ENCODING 49760
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 1 -3
 BITMAP
-0080
-0060
-7F20
-0220
-0420
-0C2C
-1330
-2120
-C000
-1FF0
-0100
-0100
-06C0
-0830
-1010
+0098
+0848
+0448
+0848
+3748
+4048
+FF48
+0BC8
+0848
+07F8
+0210
+0210
+0210
+03F8
+0200
 ENDCHAR
-STARTCHAR C7AC
-ENCODING 51116
+STARTCHAR uniC265
+ENCODING 49765
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 1 -2
 BITMAP
-0060
-0010
-0190
-0090
-FC90
-0490
-0890
-0890
-18F0
-2490
-4690
-8090
-0090
-0090
-0090
 0010
+00C8
+0848
+0C48
+1C48
+6348
+0048
+FF48
+09C8
+0848
+01F0
+0318
+0208
+0318
+01F0
 ENDCHAR
-STARTCHAR C7AD
-ENCODING 51117
+STARTCHAR uniC26C
+ENCODING 49772
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-0110
-0090
-FC90
-0C90
-0890
-10F0
-2C90
-4690
-8090
-1FF0
-0010
 0010
-0010
+0C10
+0C10
+1C10
+2390
+C010
 0010
+0F90
+F810
+0810
+0810
+0810
+0810
 0010
 ENDCHAR
-STARTCHAR C7B0
-ENCODING 51120
+STARTCHAR uniC26D
+ENCODING 49773
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 16 3 -3
+BITMAP
+00C0
+1060
+0820
+1020
+6FA0
+8020
+0060
+3FA0
+C820
+0820
+3FE0
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniC270
+ENCODING 49776
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0090
-0090
-FC90
-0C90
-0890
-10F0
-2C90
-4290
-8090
-1890
-0800
+0810
+0410
+0810
+1790
+6010
+8010
+03D0
+FC10
+0810
+0810
+1800
 0800
-0FF8
+0810
+0FF0
 ENDCHAR
-STARTCHAR C7B4
-ENCODING 51124
+STARTCHAR uniC274
+ENCODING 49780
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0090
-0090
-7C90
-0890
-0890
-18F0
-2490
-C290
-0000
+1010
+0C10
+1810
+2790
+C010
+0F90
+F810
+0810
 1FE0
 0020
+0020
 1FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR C7BC
-ENCODING 51132
+STARTCHAR uniC27C
+ENCODING 49788
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 16 1 -3
 BITMAP
 0018
-00C8
-0048
-3E48
-0648
-0448
-0C78
-1248
-2148
-C048
-07F8
+0608
+0608
+0E08
+11E8
+2008
+0078
+FF88
+0408
+0400
+0FF8
 0208
 0210
 0210
 03F8
 0200
 ENDCHAR
-STARTCHAR C7BD
-ENCODING 51133
+STARTCHAR uniC27D
+ENCODING 49789
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0018
-0048
-0048
-3E48
-0648
-0478
-0C48
-1348
-2100
-C608
-0208
-03F8
-0208
-03F8
-0208
+0030
+0810
+0410
+0810
+1790
+6010
+00D0
+FF10
+0410
+0830
+0410
+07F0
+0410
+0410
+07F0
+0400
 ENDCHAR
-STARTCHAR C7BF
-ENCODING 51135
+STARTCHAR uniC27F
+ENCODING 49791
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0190
-0090
-7C90
-0890
-0890
-18F0
-2690
-C290
-0190
-0190
+0010
+0610
+0C10
+1B90
+6010
+0070
+FF90
+0410
+0510
+0480
 0180
-0240
-0430
+0260
+0410
 1808
 ENDCHAR
-STARTCHAR C7C0
-ENCODING 51136
+STARTCHAR uniC281
+ENCODING 49793
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0098
-0048
-3E48
-0648
-0448
-0C78
-1348
-6148
-8258
-0210
-0630
-0928
-1044
-2084
+0060
+1820
+0C20
+1820
+27A0
+C020
+07E0
+F820
+0820
+0900
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR C7C1
-ENCODING 51137
+STARTCHAR uniC288
+ENCODING 49800
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 15 2 -3
 BITMAP
-0018
-00C8
-0048
-7E48
-0648
-0448
-0C78
-1248
-2148
-C048
-01A0
-0210
-0210
-0330
-01E0
+0200
+0300
+0600
+09E0
+3018
+C000
+0000
+FFFE
+0840
+0840
+0840
+0840
+0840
+0840
+0040
 ENDCHAR
-STARTCHAR C7C8
-ENCODING 51144
+STARTCHAR uniC289
+ENCODING 49801
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0030
-0010
-0010
-7F90
-0110
-021E
-0210
-0410
-0B10
-109E
-2050
-C010
-0010
-0010
-0010
+0600
+0300
+0300
+0500
+18F0
+6018
+0008
+FFF8
+0880
+0880
+3FC0
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR C7C9
-ENCODING 51145
+STARTCHAR uniC290
+ENCODING 49808
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0060
-0020
-7F20
-0224
-0438
+0400
+0300
+0200
+0500
+18F0
+6000
+0000
+FFFC
+0880
+0FC0
+1040
+3FC0
+1000
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniC298
+ENCODING 49816
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
+BITMAP
+0100
+0180
+0300
+04F8
+1800
+2000
+FFFE
+2420
+0420
+1FE0
 0820
-1620
-213C
-C020
+0840
+0840
+0FE0
+0800
+ENDCHAR
+STARTCHAR uniC29B
+ENCODING 49819
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0400
+0300
+0200
+0D80
+1070
+6000
+0000
+FFFC
+0840
+0C40
+0A40
+0F40
+0C80
+1060
+6010
+ENDCHAR
+STARTCHAR uniC29D
+ENCODING 49821
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0200
+0300
+0600
+09F0
+3018
+4000
+FFFC
+0840
+0A40
+0DC0
+1040
+1040
+18C0
+0F80
+ENDCHAR
+STARTCHAR uniC2A4
+ENCODING 49828
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
+BITMAP
+0300
+0300
+0600
+0DC0
+1838
+2000
+4000
+0000
+0008
+FFFC
+4000
+ENDCHAR
+STARTCHAR uniC2A5
+ENCODING 49829
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0300
+0100
+0300
+04F0
+180C
+6000
+0004
+FFFE
+2000
 0000
 3FE0
 0020
 0020
 0020
 0020
-0020
 ENDCHAR
-STARTCHAR C7CC
-ENCODING 51148
+STARTCHAR uniC2A8
+ENCODING 49832
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 13 1 -1
 BITMAP
-0030
-0010
-0010
-3F90
-011E
-0210
-0610
-0910
-1096
-2058
-C810
-0410
-0400
-0400
-07F8
+0100
+0180
+0300
+06F8
+180C
+6000
+0004
+FFFE
+1000
+0800
+0800
+0810
+0FF8
 ENDCHAR
-STARTCHAR C7CE
-ENCODING 51150
+STARTCHAR uniC2AC
+ENCODING 49836
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
+0300
+0180
+0300
+0CF8
+3004
+0004
+FFFE
+0000
+1FF0
 0020
-7E20
-0620
-043C
-0820
-1620
-213C
-C020
-01E0
-67F8
-20C0
-2120
-2510
-3920
+1FE0
+0800
+0800
+07F8
 ENDCHAR
-STARTCHAR C7D0
-ENCODING 51152
+STARTCHAR uniC2AD
+ENCODING 49837
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-7E20
-062C
-0430
-0C20
-1324
-6138
-8000
-1FE0
-0020
-1FE0
-0800
-0800
-0FF0
+0100
+0100
+0380
+0C78
+3000
+0004
+FFFE
+0000
+1FF0
+0210
+3610
+1810
+1310
+1C10
 ENDCHAR
-STARTCHAR C7D8
-ENCODING 51160
+STARTCHAR uniC2B4
+ENCODING 49844
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-FE20
-0224
-0438
-0C20
-1220
-213C
-C020
+0100
+0180
+0300
+06F8
+1804
+6000
+FFFE
 0000
+0000
 1FE0
 0820
-0840
-0840
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR C7DD
-ENCODING 51165
+STARTCHAR uniC2B5
+ENCODING 49845
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 15 2 -3
 BITMAP
-0060
-0020
-7F20
-0220
-0438
-0820
-1620
-212C
-C030
+0600
+0300
+0600
+09F0
+3018
+C000
+FFFC
+0000
+3040
+1040
+1FC0
+1040
+1040
+1FC0
+1040
+ENDCHAR
+STARTCHAR uniC2B7
+ENCODING 49847
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+0100
+0180
+0300
+06F0
+080C
+3000
+FFFE
+0000
+0300
+0180
+0380
+0660
+0818
+3008
+ENDCHAR
+STARTCHAR uniC2B9
+ENCODING 49849
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+0300
+0180
+0300
+04F0
+180C
+6004
+FFFE
+2000
 0100
 06C0
 0820
 0820
-0C60
-03C0
+0460
+0380
 ENDCHAR
-STARTCHAR C7E4
-ENCODING 51172
+STARTCHAR uniC2DC
+ENCODING 49884
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0190
-0090
-0090
-FC90
-04F0
-0890
-0890
-1890
-24F0
-4490
-8090
-0090
-0090
+0070
+0010
+0010
+0C10
+0810
+0810
+1810
+2410
+4310
+8110
 0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C7E8
-ENCODING 51176
+STARTCHAR uniC2DD
+ENCODING 49885
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 13 15 1 -2
 BITMAP
-0030
-0190
-0090
-0C90
-34F0
-0890
-1890
-1490
-66F0
-9A90
-0890
+0018
+0008
+0608
+0608
+0408
+0A08
+1188
+2048
+C008
+3FF0
+0810
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniC2E0
+ENCODING 49888
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0060
+0010
+0810
+0C10
 0810
+1410
+2210
+4110
+8090
+0010
+3010
+0800
+0800
 0800
+0FF8
+ENDCHAR
+STARTCHAR uniC2E3
+ENCODING 49891
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0060
+0010
+0C10
+0410
+0810
+1410
+2210
+4110
+8010
+0000
+0FE0
+0400
+0400
+0400
 07F8
 ENDCHAR
-STARTCHAR C7EC
-ENCODING 51180
+STARTCHAR uniC2E4
+ENCODING 49892
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 1 -2
 BITMAP
-0020
-0098
-0048
-3E48
-0478
-0C48
-0C48
-1378
-6148
-8FF8
+0018
 0008
+0608
+0608
+0408
+0B88
+10C8
+6008
+8000
+0FF8
 0010
 0FF8
 0400
+0400
 07FC
 ENDCHAR
-STARTCHAR C800
-ENCODING 51200
+STARTCHAR uniC2EB
+ENCODING 49899
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 15 1 -2
 BITMAP
 0018
-0008
+0408
+0208
+0408
+0E08
+1188
+2088
+C000
+3E70
+040C
+04F0
+1858
+1088
+1C88
+0070
+ENDCHAR
+STARTCHAR uniC2EC
+ENCODING 49900
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
+BITMAP
+0018
 0008
-7F88
-0108
-0308
-02F8
+0608
+0608
 0408
 0A08
-1188
+1108
 2088
 C008
-0008
-0008
-0008
+0000
+0FF0
+0410
+0410
+0410
+07F0
+0400
 ENDCHAR
-STARTCHAR C801
-ENCODING 51201
+STARTCHAR uniC2ED
+ENCODING 49901
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0210
-0410
-08F0
-1610
+0C10
+0C10
+0810
+1410
 2310
 4110
-BFE0
-0020
-0020
-0020
-0020
-0020
+8000
+0C20
+0420
+07E0
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR C804
-ENCODING 51204
+STARTCHAR uniC2EF
+ENCODING 49903
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-0008
-0008
-3F88
-0108
-02F8
-0608
-0A08
-1108
-2088
-C808
-0408
-0400
-0400
-07FC
+0030
+0010
+0810
+0810
+0810
+1410
+2210
+4110
+8010
+0090
+0080
+0180
+0360
+0410
+0808
 ENDCHAR
-STARTCHAR C808
-ENCODING 51208
+STARTCHAR uniC2F1
+ENCODING 49905
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7E10
-0610
-05F0
+0C10
+0C10
 0810
-1610
-6310
-8100
-1FE0
+1410
+2310
+4110
+8010
+0090
+0340
+0420
+0420
+0660
+03E0
+ENDCHAR
+STARTCHAR uniC2F6
+ENCODING 49910
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
+BITMAP
+0030
+0010
+0C10
+0810
+1810
+1410
+2210
+C110
+0000
+3FF0
+0040
+0440
+0490
+7FF8
+ENDCHAR
+STARTCHAR uniC2F8
+ENCODING 49912
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0040
 0020
-1FE0
-0800
-0800
-0FF0
+0020
+2120
+3120
+2220
+5220
+9E24
+0538
+08A0
+10A0
+2020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR C80A
-ENCODING 51210
+STARTCHAR uniC2F9
+ENCODING 49913
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
 0030
 0010
-7E10
-0210
-05F0
+1190
+0890
+1110
+2B16
+4698
+8450
+0850
+0000
+1FF0
 0810
-1610
-6310
-8100
-7FF0
-0530
-6D30
-3130
-23F0
-3D00
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C810
-ENCODING 51216
+STARTCHAR uniC2FB
+ENCODING 49915
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 15 15 1 -2
+BITMAP
+0030
+0110
+0890
+0990
+1910
+2696
+4658
+8850
+0000
+7C30
+0420
+0430
+0448
+048C
+0504
+ENDCHAR
+STARTCHAR uniC2FC
+ENCODING 49916
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+2320
+1120
+3120
+3220
+4D2C
+85B0
+08A0
+1020
+1020
+0820
+0800
+0810
+0FF0
+ENDCHAR
+STARTCHAR uniC300
+ENCODING 49920
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-0060
+0030
+0010
+1190
+0990
+1110
+2F16
+42D8
+8450
+0800
+1FF0
 0020
-FE20
-0420
-0820
-11E0
-2820
-4620
-8220
-0000
-1FC0
-1040
-1040
-1FC0
-1000
+0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR C811
-ENCODING 51217
+STARTCHAR uniC308
+ENCODING 49928
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 16 1 -3
 BITMAP
 0030
 0010
-FF10
-0210
-0410
-08F0
-1410
-2310
-4100
-8C10
-0410
-07F0
-0410
+1890
+0890
+1110
+2910
+42DC
+8450
+0810
+1000
+0FF0
 0410
+0420
+0420
 07F0
-0410
+0400
 ENDCHAR
-STARTCHAR C813
-ENCODING 51219
+STARTCHAR uniC309
+ENCODING 49929
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
+BITMAP
+0060
+0220
+1120
+1120
+3220
+4B2C
+84B0
+08A0
+1000
+1020
+0820
+0FE0
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniC30C
+ENCODING 49932
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
+0060
 0020
-0010
-7F10
-0210
-0410
-08F0
-1610
-6310
-8010
-0110
-0190
-0180
-0240
-0C30
-1008
+3320
+1120
+2220
+3B2C
+4CB0
+88A0
+1020
+0820
+0420
+0C60
+1250
+2088
+4108
 ENDCHAR
-STARTCHAR C815
-ENCODING 51221
+STARTCHAR uniC30D
+ENCODING 49933
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 1 -2
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
-7F90
-0110
-0210
-04F0
-0A10
+1190
+0890
 1110
-2090
-C040
+2910
+469E
+8450
+0810
+1050
 01A0
 0210
 0210
 0330
 01E0
 ENDCHAR
-STARTCHAR C816
-ENCODING 51222
+STARTCHAR uniC313
+ENCODING 49939
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
-7E10
-0210
-0410
-08F0
-1610
-2310
-4110
-BFF0
-0100
-0100
-02C0
-0430
-1810
+1990
+1110
+3110
+4A9E
+8450
+0810
+01C0
+0000
+0FFC
+00C0
+0330
+0110
+00E0
 ENDCHAR
-STARTCHAR C81C
-ENCODING 51228
+STARTCHAR uniC314
+ENCODING 49940
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0040
-0030
-0190
-0090
-FC90
-0490
-0890
-1B90
-1890
-2490
-4490
-8090
-0090
+0060
 0090
-0010
+0050
+6650
+3250
+2450
+5450
+5C50
+8A70
+1150
+2050
+0050
+0050
+0050
 0010
 ENDCHAR
-STARTCHAR C81D
-ENCODING 51229
+STARTCHAR uniC315
+ENCODING 49941
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 16 1 -3
 BITMAP
-0030
-0110
-0090
-7C90
-0890
-1090
-3B90
-4490
-8090
-0080
-1FF0
-0010
-0010
-0010
-0010
-0010
+0018
+00C8
+0248
+1148
+1348
+3248
+4D78
+88C8
+1048
+2048
+0FF8
+0008
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR C820
-ENCODING 51232
+STARTCHAR uniC318
+ENCODING 49944
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
+0060
 0030
-0310
-0090
-FC90
-0C90
-0890
-1790
-2890
-4490
-8090
-0090
+00D0
+2250
+2250
+2450
+5650
+8970
+1150
+0050
+0050
+1850
 0810
 0800
-0800
-07F8
+0FF8
 ENDCHAR
-STARTCHAR C824
-ENCODING 51236
+STARTCHAR uniC31C
+ENCODING 49948
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0030
-0110
-0090
-FC90
-0890
-0890
-1390
-2890
-4490
-9FF0
-0020
-1FF0
-0C00
+0018
+00C8
+0248
+1148
+1348
+2A48
+4D78
+88C8
+1048
+2FF0
+0010
+0FF0
 0400
+0400
 07F8
 ENDCHAR
-STARTCHAR C82C
-ENCODING 51244
+STARTCHAR uniC324
+ENCODING 49956
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 16 1 -3
 BITMAP
-0030
-0110
-0090
-7C90
-0890
-1090
-2B90
-4490
-8090
-0080
-07F0
-0410
-0410
-0420
-07F0
-0400
+0018
+0068
+0228
+1128
+1128
+2A28
+4D38
+84A8
+1828
+0000
+07F8
+0208
+0208
+0208
+03F8
+0200
 ENDCHAR
-STARTCHAR C82D
-ENCODING 51245
+STARTCHAR uniC325
+ENCODING 49957
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 16 1 -3
 BITMAP
 0018
-0088
-0048
-3E48
-0448
-0848
-19C8
-1648
-6248
-8448
+0068
+0228
+1128
+1128
+2A28
+4D38
+88A8
+1028
+2408
 0208
 03F8
 0208
@@ -118619,155 +121924,224 @@
 03F8
 0208
 ENDCHAR
-STARTCHAR C82F
-ENCODING 51247
+STARTCHAR uniC328
+ENCODING 49960
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0030
-0190
-0090
-3C90
-0C90
-0890
-1B90
-2490
-4490
-8110
-0180
-0180
-0240
-0430
-1808
+0018
+0068
+0228
+1128
+1328
+2A28
+4D38
+88A8
+1028
+0008
+0218
+0210
+0728
+0CC4
+1082
 ENDCHAR
-STARTCHAR C831
-ENCODING 51249
+STARTCHAR uniC329
+ENCODING 49961
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 1 -2
+BITMAP
+0018
+00C8
+0248
+1148
+1248
+3248
+4D78
+88C8
+1048
+2048
+01F0
+0208
+0208
+0318
+01F0
+ENDCHAR
+STARTCHAR uniC345
+ENCODING 49989
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+00C0
+0020
+3120
+1120
+323C
+4A20
+8520
+08A0
+103C
+0120
+06C0
+0820
+0820
+0C60
+07C0
+ENDCHAR
+STARTCHAR uniC368
+ENCODING 50024
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
+0060
 0030
-0190
-0090
-7C90
-0890
+0210
+3110
+2110
+2210
+52F0
+8E10
+0990
 1090
-2B90
-4490
-8490
 0090
-0360
-0410
-0410
-0630
-03E0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C838
-ENCODING 51256
+STARTCHAR uniC369
+ENCODING 50025
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 16 1 -3
 BITMAP
-0070
+0018
+0008
+1188
+1188
+1108
+2B78
+4688
+84C8
+0848
+1000
+1FF0
 0010
 0010
-FF10
-0210
-04F0
-0C10
-0810
-15F0
-2210
-4310
-8010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C83C
-ENCODING 51260
+STARTCHAR uniC36C
+ENCODING 50028
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0070
-0010
-7F10
-03F0
-0410
-0810
-1410
-22F0
-C210
 0010
+3110
+1990
+1110
+2A70
+4B90
+84D0
+0850
 1010
-0800
-0800
-0800
+0010
+0C00
+0400
+0400
 07F8
 ENDCHAR
-STARTCHAR C840
-ENCODING 51264
+STARTCHAR uniC370
+ENCODING 50032
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-02F0
-0410
-0810
-16F0
-6110
-8000
+2310
+1310
+2210
+5670
+4610
+8910
+1000
 1FE0
-0020
 0020
-0FE0
+1FE0
 0800
-0FF8
+0800
+0FF0
 ENDCHAR
-STARTCHAR C848
-ENCODING 51272
+STARTCHAR uniC372
+ENCODING 50034
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 16 2 -3
 BITMAP
-0018
-0008
-3F08
-0378
-0208
-0408
-0A78
-1108
-6108
-87F8
-0208
-0210
-0210
-0210
-03F8
-0200
+0030
+0010
+2310
+3110
+2210
+52F0
+8510
+0890
+1090
+2000
+7DF0
+0510
+7D10
+2130
+3DF0
+0100
 ENDCHAR
-STARTCHAR C849
-ENCODING 51273
+STARTCHAR uniC378
+ENCODING 50040
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0010
+1110
+1110
+3210
+4A70
+8D10
+0890
+1010
+0000
+0FF0
+0410
+0420
+0420
+07F0
+0400
+ENDCHAR
+STARTCHAR uniC379
+ENCODING 50041
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 16 1 -3
 BITMAP
 0018
 0008
-3F08
-0378
-0208
-0408
-0A78
-1108
-6100
-8408
+18C8
+0888
+18F8
+1D88
+2648
+C428
+0800
+0608
 0208
 03F8
 0208
@@ -118775,770 +122149,601 @@
 03F8
 0208
 ENDCHAR
-STARTCHAR C84C
-ENCODING 51276
+STARTCHAR uniC37C
+ENCODING 50044
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 1 -2
+BITMAP
+0038
+0008
+1188
+0888
+1118
+2F28
+4688
+8448
+0808
+0430
+0210
+0630
+0530
+08CC
+3084
+ENDCHAR
+STARTCHAR uniC37D
+ENCODING 50045
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0070
+0010
+2310
+1110
+2310
+5270
+4D10
+8890
+1090
+0090
+0340
+0420
+0420
+0460
+03C0
+ENDCHAR
+STARTCHAR uniC384
+ENCODING 50052
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
+0060
 0030
+0050
+6650
+2250
+2250
+5450
+95D0
+0A50
+1250
+2050
+0050
+0050
+0050
 0010
-7E10
-02F0
-0410
-0810
-14F0
-2210
-C200
-1820
-0C20
-0820
-1650
-2298
-4108
+0010
 ENDCHAR
-STARTCHAR C84D
-ENCODING 51277
+STARTCHAR uniC388
+ENCODING 50056
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 15 1 -2
 BITMAP
 0018
-0008
-3F88
-0178
-0208
-0608
-0A78
-1188
-2088
-C040
-01B0
-0208
-0208
-0110
-00E0
+0048
+0028
+1128
+1128
+3268
+2BA8
+C4A8
+0828
+1028
+0828
+0400
+0400
+0400
+03FC
 ENDCHAR
-STARTCHAR C854
-ENCODING 51284
+STARTCHAR uniC38C
+ENCODING 50060
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 14 15 1 -2
 BITMAP
-0020
 0018
 00C8
-0048
-7E48
-07C8
-0448
-0C48
-0FC8
+0248
 1248
-2248
-C048
-0048
-0048
-0008
+1248
+3FC8
+4D48
+8948
+1048
+07F8
 0008
+07F8
+0200
+0200
+03FC
 ENDCHAR
-STARTCHAR C870
-ENCODING 51312
+STARTCHAR uniC399
+ENCODING 50073
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -2
+BITMAP
+0130
+0090
+4490
+2690
+2790
+5490
+8D90
+9290
+1290
+3090
+0810
+0800
+0810
+0FF0
+ENDCHAR
+STARTCHAR uniC3D8
+ENCODING 50136
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 11 1 0
 BITMAP
-3FF0
-0060
-00C0
-0180
-02C0
-0C3C
-3000
-0100
+0860
+0430
+0C20
+0E40
+12F0
+618C
+0204
+0700
 0100
 0100
 FFFE
 ENDCHAR
-STARTCHAR C871
-ENCODING 51313
+STARTCHAR uniC3D9
+ENCODING 50137
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-3FF0
-0060
-0180
-06F0
-180C
-E100
+0420
+0C40
+1AE0
+219C
+0200
+0500
 0100
 FFFE
-0000
+2000
 3FE0
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C874
-ENCODING 51316
+STARTCHAR uniC3DC
+ENCODING 50140
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 14 1 -1
 BITMAP
-3FF0
 0040
-0180
-06F8
-1804
-2100
-0104
+0C20
+0C40
+0CC0
+13BC
+6200
+0500
+0100
 FFFE
-0000
-1800
-0800
+1000
 0800
-0FF8
-ENDCHAR
-STARTCHAR C878
-ENCODING 51320
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-3FF0
-0060
-0180
-06F8
-1904
-2100
-FFFE
-0000
-1FF0
-0020
-1FF0
 0800
 0800
 0FF8
-ENDCHAR
-STARTCHAR C87A
-ENCODING 51322
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-1FF0
-0060
-0180
-02C0
-1C3C
-2100
-0100
-FFFE
-0000
-1E80
-02F8
-3E90
-1090
-1670
-0800
-ENDCHAR
-STARTCHAR C880
-ENCODING 51328
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-3FF0
-0060
-0080
-03F0
-0D0C
-3100
-C1FE
-FF00
-0000
-1FE0
-0820
-0820
-0840
-0FE0
-0800
-ENDCHAR
-STARTCHAR C881
-ENCODING 51329
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-3FF0
-0060
-0080
-03C0
-1D3C
-2100
-017E
-FF80
-1820
-0820
-0FE0
-0820
-0FE0
-0820
 ENDCHAR
-STARTCHAR C883
-ENCODING 51331
+STARTCHAR uniC3DF
+ENCODING 50143
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-3FE0
-00C0
-0300
-0580
-3878
-4200
+1840
+0840
+1880
+2570
+4208
+0600
 0200
 FFFC
 0000
-0200
-0600
-0D80
-1060
-6010
+1FE0
+1000
+1000
+1000
+0FE0
 ENDCHAR
-STARTCHAR C885
-ENCODING 51333
+STARTCHAR uniC3E0
+ENCODING 50144
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-3FF0
 0040
-0180
-06F8
-1800
-2100
-0104
-FFFE
-0000
-03C0
-0460
 0C20
-0460
-03C0
-ENDCHAR
-STARTCHAR C886
-ENCODING 51334
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-1FF0
-0060
-0180
-02C0
-1C3C
-2100
-0100
-FFFE
-0000
-1FF8
-0100
-0380
-0660
-0810
-3000
-ENDCHAR
-STARTCHAR C887
-ENCODING 51335
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-3FF0
-0060
-0180
-06F0
-1900
-2100
-FFFE
-0000
-07C0
-3FF8
-0100
-0280
-0470
-1808
-2000
-ENDCHAR
-STARTCHAR C88B
-ENCODING 51339
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-3FF0
-0040
-0180
-0F78
-3100
-01FE
-FF00
-0380
-0000
-3FF8
-0100
-06C0
 0440
-0380
-ENDCHAR
-STARTCHAR C88C
-ENCODING 51340
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 16 15 1 -2
-BITMAP
-0030
-0010
-3F90
-0110
-0210
-0610
-19D0
-201F
-0210
-0210
-87D0
-7810
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR C88D
-ENCODING 51341
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-0060
-0020
-7F20
-0320
-0C20
-3FE4
-C8F8
-FF20
-0020
-0000
-3FE0
-0020
-0020
-0020
+0CB8
+1304
+6580
+0100
+FFFE
+2000
+1FE0
 0020
 0020
+1FE0
+0800
+0FF8
 ENDCHAR
-STARTCHAR C894
-ENCODING 51348
+STARTCHAR uniC3E2
+ENCODING 50146
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0060
-0020
-7F20
-0220
-0C20
-3BAC
-CB70
-F420
+0C60
+0420
+0C40
+12B8
+6104
+0700
+0100
+FFFE
 0000
-1FE0
-0020
-1FE0
-0800
-0800
-0FF8
+3F00
+02F8
+1E90
+1090
+1EF0
+0080
 ENDCHAR
-STARTCHAR C89D
-ENCODING 51357
+STARTCHAR uniC3E8
+ENCODING 50152
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-7F20
-0220
-0C20
-3BBC
-CB60
-F420
+0860
+0420
+0C40
+12B8
+2104
+0380
+0100
+FFFE
 0000
-1820
-0820
-0FE0
+1FE0
 0820
+0840
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR C89F
-ENCODING 51359
+STARTCHAR uniC3E9
+ENCODING 50153
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 16 1 -3
 BITMAP
 0060
-0020
-7F20
-0220
+0C60
+0440
+0CB8
+1304
+6500
+0100
+C17E
+FE8E
 0C20
-33A0
-C838
-09E0
-F620
-0120
-0180
-0180
-0260
-0C10
-1000
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR C8A1
-ENCODING 51361
+STARTCHAR uniC3ED
+ENCODING 50157
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0020
-7F20
-0220
-0C20
-3BBC
-C8E0
-FF20
-0020
-0100
-06C0
 0820
+0420
+0840
+16BC
+2100
+0700
+0100
+FFFE
+2100
+07C0
+0C60
 0820
 0C60
 07C0
 ENDCHAR
-STARTCHAR C8A8
-ENCODING 51368
+STARTCHAR uniC3F4
+ENCODING 50164
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0110
-0090
-7E90
-0490
-0890
-1490
-6390
-98F0
-1090
-1F90
-E090
-0090
-0090
+0030
 0010
-ENDCHAR
-STARTCHAR C8BC
-ENCODING 51388
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 1 -2
-BITMAP
-0098
-0248
-3E48
-0C48
-13C8
-7878
-0848
-FFC8
-2030
-0210
+1090
+0890
+1190
+3D90
+4250
+8436
+0A18
 0210
-0528
-08C4
-1084
-ENDCHAR
-STARTCHAR C8BD
-ENCODING 51389
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 1 -2
-BITMAP
-0098
-0248
-3E48
-0C48
-13C8
-7878
-0848
-FFC8
-2028
-00F0
-0108
-0108
-0188
-00F0
-ENDCHAR
-STARTCHAR C8C4
-ENCODING 51396
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0060
-0010
-0010
-7F90
-0310
-0610
-0C10
-33D0
-C410
-0410
-07D0
-F810
+7FD0
+2010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR C8C8
-ENCODING 51400
+STARTCHAR uniC3F5
+ENCODING 50165
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 16 1 -3
 BITMAP
 0030
+0110
+1890
+0910
+1E90
+2450
+4E1E
+0270
+FD90
+0000
+1FF0
 0010
-7F90
-0310
-0610
-0B90
-3C10
-4430
-FFD0
-2010
 0010
-0C00
-0400
-0400
-07F8
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C8CC
-ENCODING 51404
+STARTCHAR uniC3F8
+ENCODING 50168
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 2 -2
 BITMAP
 0060
+0220
+3120
+1220
+3D20
+48A0
+943C
+04E0
+FB20
 0020
-FE20
-0420
-0820
-3720
-C820
-0FE0
-F020
-1FE0
 0020
-0040
-1FE0
 0800
+0800
+0810
 0FF0
 ENDCHAR
-STARTCHAR C8D4
-ENCODING 51412
+STARTCHAR uniC408
+ENCODING 50184
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
-0010
-7F10
-0210
-0C10
-3FD0
-C410
-07F0
-7810
+0110
+0890
+0910
+1E90
+2450
+4A1E
+0270
+FF90
 0000
-0FF0
-0410
+0630
 0420
-07F0
-0400
+0B70
+114C
+2084
 ENDCHAR
-STARTCHAR C8D5
-ENCODING 51413
+STARTCHAR uniC410
+ENCODING 50192
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -3
+BBX 13 15 1 -2
 BITMAP
 0030
-7F10
-0210
-0C10
-3390
-CC10
-0410
-07F0
-7860
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0088
+0048
+1348
+1248
+1648
+2D48
+4848
+1878
+09C8
+FE48
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR C8D7
-ENCODING 51415
+STARTCHAR uniC424
+ENCODING 50212
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0190
+2690
+1490
+3C90
+4A90
+98F0
+0890
+1F90
+E040
+0420
+0C60
+0B50
+1188
+6100
+ENDCHAR
+STARTCHAR uniC42C
+ENCODING 50220
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0210
-0410
-1F90
-6C10
-8470
+3110
+1910
+1210
+2F90
+44D0
+0C10
+3410
+0470
 FF90
 0010
-0180
-0100
-02C0
-0430
-1810
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C8D9
-ENCODING 51417
+STARTCHAR uniC430
+ENCODING 50224
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 2 -1
 BITMAP
 0030
 0010
-7F10
-0210
-0410
-1F90
-6C10
-8470
-FF90
-0090
-0360
-0410
-0410
-0630
-03E0
+1110
+1110
+3B10
+44D0
+8C10
+1430
+FFD0
+4010
+1810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C8E0
-ENCODING 51424
+STARTCHAR uniC434
+ENCODING 50228
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 14 15 1 -2
 BITMAP
-1FF0
-0020
-0040
-0180
-02C0
-0C3C
-3000
-0420
-0420
-0440
-FFFE
+0018
+0188
+0888
+0988
+1548
+2628
+CA08
+02F8
+3D08
+07F8
+0008
+07F8
+0200
+0200
+03FC
 ENDCHAR
-STARTCHAR C8E1
-ENCODING 51425
+STARTCHAR uniC43C
+ENCODING 50236
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 15 2 -2
 BITMAP
-1FF0
-0060
-0180
-03F8
-1C6C
-2460
-0440
-FFFE
-0000
-1FF0
-0010
-0010
-0010
-0010
+0030
 0010
+1110
+1110
+3B90
+4450
+8C10
+04F0
+FF10
+0000
+07F0
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR C8E4
-ENCODING 51428
+STARTCHAR uniC43D
+ENCODING 50237
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 12 15 2 -2
 BITMAP
-3FF0
-0040
-0180
-07C0
-183C
-6840
-0440
-0440
-FFFE
-0800
-0800
-0800
-0FF8
+0030
+0110
+1910
+1310
+2CD0
+4C10
+0410
+8FF0
+7000
+0C10
+0410
+07F0
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR C8F5
-ENCODING 51445
+STARTCHAR uniC448
+ENCODING 50248
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 11 1 0
 BITMAP
-3FF0
-0040
-0180
-06F8
-1860
-2440
+0C30
+0420
+0420
+0A60
+1198
+2104
+0200
+0420
+0420
 0440
 FFFE
-0000
-07C0
-0420
-0C20
-0460
-03C0
 ENDCHAR
-STARTCHAR C8FC
-ENCODING 51452
+STARTCHAR uniC464
+ENCODING 50276
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
-3FE0
-0040
-0080
-0380
-0C78
-7000
-000C
+0860
+0460
+0C40
+12B8
+2104
+C200
+0000
 FFFE
 0100
 0100
@@ -119548,41 +122753,43 @@
 0100
 0100
 ENDCHAR
-STARTCHAR C8FD
-ENCODING 51453
+STARTCHAR uniC465
+ENCODING 50277
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-1FF0
-0060
-0080
-03F8
-1C04
-2004
+0040
+0420
+0C20
+0E60
+329C
+4100
+0604
 FFFE
 0100
 0100
-3FE0
-0020
-0020
-0020
-0020
+21F0
+1E10
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C900
-ENCODING 51456
+STARTCHAR uniC468
+ENCODING 50280
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-3FF0
-0060
-00C0
-0380
-0C7C
-7000
-0004
-FFFE
+0040
+0420
+0420
+0C40
+12B8
+6104
+0200
+000E
+FFFC
 0100
 0100
 1900
@@ -119590,18 +122797,19 @@
 0900
 0FF8
 ENDCHAR
-STARTCHAR C904
-ENCODING 51460
+STARTCHAR uniC46C
+ENCODING 50284
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-1FF0
-0060
-0080
-03F8
-1C04
-2000
+0040
+0420
+0420
+0C40
+32B8
+4104
+0604
 FFFE
 0100
 1F00
@@ -119610,2590 +122818,2523 @@
 1FE0
 0800
 0FF0
-ENDCHAR
-STARTCHAR C905
-ENCODING 51461
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0060
-0080
-0378
-1C04
-2000
-FFFE
-0100
-1FF8
-0208
-3608
-1808
-1108
-1E08
-ENDCHAR
-STARTCHAR C906
-ENCODING 51462
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0060
-0080
-0378
-1C04
-2000
-FFFE
-0100
-1FF8
-02C8
-36C8
-18D0
-1150
-1E78
 ENDCHAR
-STARTCHAR C90C
-ENCODING 51468
+STARTCHAR uniC474
+ENCODING 50292
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 16 1 -3
 BITMAP
-3FF0
-0060
-0180
-06F8
-1804
-2000
+0020
+0420
+0460
+0C50
+138C
+6200
+0000
 FFFE
 0100
 0100
-1F20
-08E0
+1FE0
+0820
 0820
 0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR C90D
-ENCODING 51469
+STARTCHAR uniC475
+ENCODING 50293
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 15 1 -2
 BITMAP
-1FF0
-0060
-0180
-06F0
-180C
-2004
+0040
+0420
+0420
+0E40
+30BC
+4100
+0200
 FFFE
 0100
-1960
+1920
 0920
 0FE0
 0820
-0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR C90F
-ENCODING 51471
+STARTCHAR uniC479
+ENCODING 50297
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 15 1 -2
 BITMAP
-3FF0
 0060
-0080
-03C0
-0C3C
-7004
+0420
+0460
+0ED8
+1184
+6200
+0004
 FFFE
-0100
-0100
-0300
-0300
-06C0
-0830
-1008
-2000
-ENDCHAR
-STARTCHAR C911
-ENCODING 51473
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0060
-0080
-03F0
-1C0C
-2000
-FC00
-03FE
 0100
-0700
-08C0
+07C0
+0C60
+0820
 0820
 0C60
-07C0
+03C0
 ENDCHAR
-STARTCHAR C918
-ENCODING 51480
+STARTCHAR uniC480
+ENCODING 50304
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0310
-0410
+1110
+1110
+3B10
+4C90
+8810
+1010
 0F90
-3050
-C010
-03D0
-7C10
+7410
 04F0
 0410
 0410
 0410
 0010
 ENDCHAR
-STARTCHAR C92C
-ENCODING 51500
+STARTCHAR uniC494
+ENCODING 50324
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
+2310
+1110
+3210
+4D90
+8810
 0010
-7F10
-0210
-0C10
-1390
-E310
-FC10
-04F0
-0060
-0420
+FF10
+08F0
+0800
+0430
 0420
-0A50
-1088
-2100
+0A60
+1198
+6108
 ENDCHAR
-STARTCHAR C934
-ENCODING 51508
+STARTCHAR uniC49C
+ENCODING 50332
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0090
-0050
-7E50
-0450
-0850
-3650
-C050
-0650
-7850
-09D0
-0850
-0850
-0050
-0010
+0060
+01A0
+00A0
+24A0
+24A0
+5CA0
+92A0
+20A0
+06A0
+F8A0
+13A0
+10A0
+10A0
+00A0
+0020
 ENDCHAR
-STARTCHAR C950
-ENCODING 51536
+STARTCHAR uniC4B8
+ENCODING 50360
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0010
-7F10
-0310
-0410
-0F90
-3050
-C010
-03D0
-7C10
-0410
-0410
-0410
-0410
-0010
-ENDCHAR
-STARTCHAR C951
-ENCODING 51537
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
 0070
-0010
-7F10
-0210
-0C10
-33D0
-C0F0
-FF10
-0410
-0410
-1FF0
-0010
 0010
-0010
+3110
+1110
+3310
+4C90
+8810
 0010
+3F90
+C810
+0810
+0810
+0810
+0810
 0010
 ENDCHAR
-STARTCHAR C954
-ENCODING 51540
+STARTCHAR uniC4BC
+ENCODING 50364
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 1 -2
 BITMAP
 0018
-0008
-3F88
-0108
-0208
-0FC8
-3008
-C7F8
-7A08
-0208
-0008
-0C08
-0400
-0400
-07FC
-ENDCHAR
-STARTCHAR C958
-ENCODING 51544
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0020
-0010
-7F10
-0210
-0C10
-1390
-E7F0
-7C10
-0000
-0060
-0FA0
-0020
-1FE0
-0800
-0FF0
-ENDCHAR
-STARTCHAR C960
-ENCODING 51552
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0060
-0010
-7F10
-0210
-0C10
-33D0
-C010
-0FF0
-7410
-0410
-0FF0
-0410
-0420
-0420
-07F0
-0400
-ENDCHAR
-STARTCHAR C961
-ENCODING 51553
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0030
-0010
-7F10
-0210
-0410
-1BD0
-6070
-FF90
-0410
-1810
-0410
-07F0
-0410
-0410
-07F0
-0410
-ENDCHAR
-STARTCHAR C963
-ENCODING 51555
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-7F90
-0310
-0410
-1BD0
-E3B0
-7C10
-0410
-0510
-0180
-0100
-02C0
-0430
-1808
-ENDCHAR
-STARTCHAR C96C
-ENCODING 51564
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -3
-BITMAP
-7FC0
-0080
-0100
-0700
-18F8
-E000
 0008
-FFF8
-0880
-0880
-0880
-0880
-0880
-0880
-0080
-ENDCHAR
-STARTCHAR C970
-ENCODING 51568
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF0
-0020
-00C0
-0180
-067C
-3800
-FFFE
-0440
-0440
-0440
-0840
-0800
-0800
-0FF8
-ENDCHAR
-STARTCHAR C974
-ENCODING 51572
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-3FE0
-00C0
-0180
-0200
-1DF8
-E000
-FFFC
-0880
-3FC0
-0040
-3FC0
-1000
-1000
-1FE0
-ENDCHAR
-STARTCHAR C97C
-ENCODING 51580
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -2
-BITMAP
-3FE0
-0080
-0300
-0CF8
-F000
-0000
-FFF8
-0880
-0840
-3FC0
-1080
-1080
-1FC0
-1000
+1888
+0988
+1D08
+22E8
+CC08
+FFF8
+2408
+0408
+0408
+0C08
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR C988
-ENCODING 51592
+STARTCHAR uniC4E9
+ENCODING 50409
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 10 2 0
+BBX 15 15 1 -2
 BITMAP
-7FE0
 0040
-0080
-0300
-0580
-1870
-E000
+0420
+0420
+0E60
+129C
+6104
+0204
+FFFE
+0420
+0520
+06E0
+0820
+0820
+0C60
+07C0
+ENDCHAR
+STARTCHAR uniC4F0
+ENCODING 50416
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
+BITMAP
+0820
+0430
+0420
+0C40
+12F0
+208C
+C300
+0400
 0000
 0000
-FFFC
+FFFE
 ENDCHAR
-STARTCHAR C989
-ENCODING 51593
+STARTCHAR uniC4F1
+ENCODING 50417
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 15 1 -2
 BITMAP
-3FF0
-0060
-0180
-0380
-1C78
-2000
+0040
+0C20
+0420
+0E60
+129C
+6100
+0206
 FFFE
-0000
+2000
 0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+1FF0
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C98C
-ENCODING 51596
+STARTCHAR uniC4F4
+ENCODING 50420
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 14 1 -2
 BITMAP
-1FF0
-0060
-0080
-03C0
-1C3C
-2000
-0004
+0C20
+0430
+0C20
+1270
+608C
+0300
+0000
 FFFE
+0000
 1000
 0800
 0800
-0810
+0800
 0FF8
 ENDCHAR
-STARTCHAR C990
-ENCODING 51600
+STARTCHAR uniC4F8
+ENCODING 50424
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 14 1 -2
 BITMAP
-3FF0
-0060
-0180
-06F8
-1804
-2004
+0C60
+0420
+0C40
+32B8
+410C
+0200
 FFFE
 0000
-1FE0
+0000
+1FF0
 0020
 1FE0
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR C998
-ENCODING 51608
+STARTCHAR uniC4FA
+ENCODING 50426
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 16 1 -3
 BITMAP
-3FE0
-00C0
-0100
-0780
-3878
-4000
-FFFC
+0040
+0C30
+0420
+0C60
+1AD8
+218C
+C200
 0000
+7FFE
 0000
-3FC0
-1040
-1040
-1080
-1FC0
-1000
+3FF8
+0290
+3E90
+1090
+16F0
+0880
 ENDCHAR
-STARTCHAR C999
-ENCODING 51609
+STARTCHAR uniC4FF
+ENCODING 50431
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF0
-0060
-0180
-0378
-1C0C
-2004
-FFFE
-0000
-1820
-0820
-0FE0
-0820
-0FE0
-0820
+0C20
+0420
+0C40
+12F8
+2104
+C204
+01FE
+FF00
+3E70
+041C
+3CE0
+1098
+1688
+1870
 ENDCHAR
-STARTCHAR C99B
-ENCODING 51611
+STARTCHAR uniC500
+ENCODING 50432
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 15 1 -3
 BITMAP
-3FE0
-00C0
-0100
-0780
-3878
-4000
+0860
+0420
+0840
+16F0
+210C
+C200
+0404
+FFFE
+2000
 0000
-FFFC
-0600
-0200
-0700
-0C80
-1060
-6010
+1FE0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR C99D
-ENCODING 51613
+STARTCHAR uniC501
+ENCODING 50433
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-33F0
-1C20
-00C0
-0300
-0CF8
-7000
+0C60
+0C20
+0C40
+32B8
+4104
+0200
 FFFE
 0000
-0100
-06C0
-0840
-0860
-0440
-0380
-ENDCHAR
-STARTCHAR C9C0
-ENCODING 51648
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0070
-0010
-0010
-FF10
-0210
-0610
-0C10
-0C10
-3210
-4190
-8090
-0010
-0010
-0010
-0010
+1820
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C9C1
-ENCODING 51649
+STARTCHAR uniC50C
+ENCODING 50444
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 11 15 3 -2
 BITMAP
 0060
-0020
-FE20
-0420
-0C20
-1820
-3420
-4320
-8020
-3FE0
-1020
 0020
+4220
+3220
+2220
+5620
+89A0
+10A0
+2020
+0060
+3FA0
+C020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR C9C4
-ENCODING 51652
+STARTCHAR uniC510
+ENCODING 50448
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0008
-0008
-3F88
-0108
-0308
-0608
-0D08
-1088
-2048
-C808
-0400
-0400
-0400
-03FC
-ENDCHAR
-STARTCHAR C9C7
-ENCODING 51655
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-00C0
-0060
-FE20
-0620
-0420
-0820
-1420
-2320
-C120
-0040
-3FC0
-1000
-1000
-1000
-1FE0
+0010
+0110
+1910
+1310
+2ED0
+4450
+1810
+00F0
+FF10
+0010
+1810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR C9C8
-ENCODING 51656
+STARTCHAR uniC514
+ENCODING 50452
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-7F10
 0210
-0610
-0C10
-1B90
-2090
-C000
+1910
+1110
+2B90
+4450
+1870
+FF90
+0000
 1FE0
 0020
 1FE0
 0800
 0800
+0FF8
+ENDCHAR
+STARTCHAR uniC51C
+ENCODING 50460
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0060
+0030
+1110
+1910
+1B10
+66D0
+8850
+0010
+FFF0
+2010
 0FF0
+0410
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR C9CA
-ENCODING 51658
+STARTCHAR uniC528
+ENCODING 50472
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
+0310
+1190
+1110
+2110
+3210
+4F10
+8C90
+0850
+1010
+2010
+0010
 0010
-7F10
-0210
-0610
-0C10
-1310
-2080
-FC00
-04F8
-6C90
-3090
-2290
-3CF8
-0080
+0010
 ENDCHAR
-STARTCHAR C9D0
-ENCODING 51664
+STARTCHAR uniC529
+ENCODING 50473
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 13 16 1 -3
 BITMAP
-0060
-0020
-FE20
-0620
-0420
-0820
-1420
-6320
-8020
+0018
+0008
+1888
+0888
+1108
+2988
+4648
+8468
+0808
 0000
-0FE0
-0820
-0820
-0840
-0FE0
-0800
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C9D1
-ENCODING 51665
+STARTCHAR uniC52C
+ENCODING 50476
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 15 1 -2
 BITMAP
-0030
-0010
-7F10
-0210
-0610
-0C10
-1E20
-2100
-C000
-1860
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0018
+0008
+1188
+0888
+0888
+1908
+2688
+4248
+8408
+0808
+0008
+0600
+0200
+0200
+03FC
 ENDCHAR
-STARTCHAR C9D3
-ENCODING 51667
+STARTCHAR uniC530
+ENCODING 50480
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 1 -2
 BITMAP
-0030
+0018
+0008
+0888
+0888
+1088
+2D88
+4648
+8428
+0800
+0FF8
 0010
 0010
-7F10
-0210
-0410
-0C10
-1210
-2190
-C110
-0080
-0180
-0240
-0430
-1818
+1FF8
+0400
+07FC
 ENDCHAR
-STARTCHAR C9D5
-ENCODING 51669
+STARTCHAR uniC538
+ENCODING 50488
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
 0010
-7F10
-0210
-0610
-0C10
-1B10
-2190
-4010
-8090
-0360
-0410
+1190
+1990
+1110
+2B10
+4290
+8450
+0810
+1000
+0FF0
 0410
-0630
-03E0
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR C9D6
-ENCODING 51670
+STARTCHAR uniC539
+ENCODING 50489
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 16 1 -3
 BITMAP
 0030
-0010
-0010
-7F10
-0210
-0410
-0C10
-1390
-2080
-C070
-1F80
-0180
-0240
-0C30
-1008
+0018
+1888
+0888
+1888
+1D88
+2648
+C468
+0808
+0608
+0208
+03F8
+0208
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR C9D9
-ENCODING 51673
+STARTCHAR uniC53B
+ENCODING 50491
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 16 1 -3
 BITMAP
-0030
-0010
-7F10
-0210
-0610
-0C10
-1A10
-2190
-4000
-9FE0
-0800
-0FE0
-0800
+0018
+0008
+1888
+0888
+1888
+1988
+2648
+C428
+0008
+00C8
+0040
+00C0
+0130
+0208
+0404
 0800
-0FF0
 ENDCHAR
-STARTCHAR C9DA
-ENCODING 51674
+STARTCHAR uniC53D
+ENCODING 50493
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0210
-0610
-0C10
-1310
-2190
-C000
-3FF0
-0840
-0440
-0480
-7FF8
+3110
+1110
+3110
+2B10
+4E90
+84D0
+0810
+00C0
+0320
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR C9DC
-ENCODING 51676
+STARTCHAR uniC544
+ENCODING 50500
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0040
+00E0
 0020
 0020
-FFA0
-1120
-2120
-3220
-4F2C
-84B0
-08A0
-1020
+0820
+7C20
+C620
+8220
+822C
+C630
+3C20
 0020
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR C9DD
-ENCODING 51677
+STARTCHAR uniC545
+ENCODING 50501
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
-0060
-0020
-0020
-7F20
-3120
-3224
-4D38
-88A0
+00C0
 1020
+7C20
+C620
+8220
+8224
+C638
+3C20
+0020
 0000
 3FE0
-1020
 0020
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR C9E0
-ENCODING 51680
+STARTCHAR uniC548
+ENCODING 50504
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-0020
-7FA0
-1120
-3320
-4B2C
-84B0
-08A0
 1020
-1020
-0820
+7C20
+C620
+822C
+8230
+C620
+3C20
+0020
+3020
 0800
 0800
+0810
 0FF0
 ENDCHAR
-STARTCHAR C9E2
-ENCODING 51682
+STARTCHAR uniC549
+ENCODING 50505
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
+BITMAP
+00C0
+1020
+7C20
+8220
+8220
+823C
+4420
+3820
+0000
+63F8
+2040
+20C0
+24B0
+3910
+0600
+ENDCHAR
+STARTCHAR uniC54A
+ENCODING 50506
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
 0060
-0020
-99A0
-7720
-1120
-3220
-4DB8
-88A0
 1020
+7C20
+8220
+822C
+8230
+4420
+3800
+01F0
+6780
 21C0
-2070
-2380
-2160
-2520
-3920
+2220
+2620
+3A20
+01C0
 ENDCHAR
-STARTCHAR C9E4
-ENCODING 51684
+STARTCHAR uniC54C
+ENCODING 50508
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-FBA0
-1520
-3220
-2B3C
-4CA0
-88A0
-1000
+1020
+6C20
+8220
+823C
+C620
+7C20
+0000
 1FE0
-0040
+0020
 1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR C9E7
-ENCODING 51687
+STARTCHAR uniC54D
+ENCODING 50509
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 16 2 -3
 BITMAP
-0030
-0010
-7FD0
-0C90
-0890
-159E
-6250
-8430
-1B90
-0490
-02F0
-3E90
-1090
-11F0
-1E90
+0060
+1020
+7C20
+C620
+822C
+8230
+C620
+7C00
+0000
+7E60
+04A0
+4620
+3820
+2220
+3C20
+0020
 ENDCHAR
-STARTCHAR C9EC
-ENCODING 51692
+STARTCHAR uniC54E
+ENCODING 50510
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-0010
-3FD0
-0890
-1916
-2798
-4250
-8410
-0800
-0FF0
-0420
-0420
-0420
-07F0
-0400
+0060
+1020
+7C20
+C620
+8220
+823C
+C620
+7820
+0000
+3DF0
+0520
+7D20
+2120
+27E0
+3900
 ENDCHAR
-STARTCHAR C9ED
-ENCODING 51693
+STARTCHAR uniC553
+ENCODING 50515
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0060
+1020
+3820
+C620
+8220
+8238
+6C20
+1000
+00E0
+7C00
+0BF0
+6CE0
+3110
+2110
+3CE0
+ENDCHAR
+STARTCHAR uniC554
+ENCODING 50516
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
 0060
+1020
+7C20
+C620
+8220
+822C
+4630
+3C20
 0020
-79A0
-1F20
-1120
-2B2C
-4CB0
-8820
-1000
-2C20
-0420
-07E0
-0420
-0420
-07E0
-0420
+0000
+1FE0
+0820
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR C9EF
-ENCODING 51695
+STARTCHAR uniC555
+ENCODING 50517
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+1020
+7C20
+C620
+8220
+823C
+C620
+3820
+0000
+1820
+0820
+0FE0
+0820
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniC557
+ENCODING 50519
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
-0020
+1020
+7C20
+C620
+8220
+822C
+4630
+3820
 0020
-FFA0
-1120
-322C
-4B30
-84A0
-0820
-1120
-0180
+0120
 0100
-02C0
-0C30
-1008
+0380
+0640
+0830
+1010
 ENDCHAR
-STARTCHAR C9F0
-ENCODING 51696
+STARTCHAR uniC558
+ENCODING 50520
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-7FA0
-1120
-3320
-2B24
-4CB8
-88A0
-1000
-0840
-0420
+7C20
+C620
+8220
+823C
+C620
+3C20
+0000
+0860
+0860
 0C40
-1AE0
-2090
-4108
+12A0
+2118
+4208
 ENDCHAR
-STARTCHAR C9F1
-ENCODING 51697
+STARTCHAR uniC559
+ENCODING 50521
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-00C0
-0040
-0040
-7F40
-2240
-3258
-5660
-8940
-10C0
-2140
-0680
-0840
-0840
-0CC0
-0780
+0060
+1020
+3820
+C620
+8220
+822C
+4430
+3820
+0020
+0100
+06C0
+0820
+0820
+0C60
+03C0
+ENDCHAR
+STARTCHAR uniC55D
+ENCODING 50525
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+1020
+7C20
+C620
+8220
+823C
+C620
+3C20
+0000
+0FE0
+0800
+0FE0
+0800
+0800
+07F0
+ENDCHAR
+STARTCHAR uniC55E
+ENCODING 50526
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+1020
+7C20
+C620
+8220
+823C
+C620
+3C20
+0000
+0000
+3FF0
+08C0
+0440
+0480
+7FF8
 ENDCHAR
-STARTCHAR C9F8
-ENCODING 51704
+STARTCHAR uniC560
+ENCODING 50528
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0048
-0028
-0028
-3F28
-1128
-1228
-2A28
-4538
-88A8
-1028
-0028
-0028
-0028
-0008
+0190
+0090
+1090
+6890
+8490
+8490
+CCF0
+7890
+0090
+0090
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR C9F9
-ENCODING 51705
+STARTCHAR uniC561
+ENCODING 50529
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 16 2 -3
 BITMAP
 0030
-00C8
-0048
-3FC8
-0948
-1248
-2A78
-45C8
-88C8
-1048
-0FF8
-0008
-0008
-0008
-0008
-0008
+0010
+1090
+6890
+8490
+8490
+CCF0
+7890
+0090
+0090
+1FF0
+1010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR C9FC
-ENCODING 51708
+STARTCHAR uniC564
+ENCODING 50532
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-0048
-0048
-7F48
-1B48
-1248
-2E78
-4548
-88C8
-1048
-2048
-0C48
-0400
-0400
-03F8
+0070
+0090
+0090
+0890
+7490
+8290
+82F0
+C690
+7C90
+0090
+0090
+1800
+0800
+0800
+07F8
 ENDCHAR
-STARTCHAR CA00
-ENCODING 51712
+STARTCHAR uniC568
+ENCODING 50536
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
 0110
-0090
-7E90
-2290
-2490
-56F0
-8990
 1090
-0FF0
-0010
+7890
+CC90
+8490
+84F0
+7890
+0090
+1F90
+0060
 0020
+1FE0
+0800
 0FF0
-0400
-07F8
 ENDCHAR
-STARTCHAR CA08
-ENCODING 51720
+STARTCHAR uniC570
+ENCODING 50544
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0020
+0030
 0110
-0090
-7E90
-3290
-2490
-56F0
-8990
 1090
+6890
+8490
+8490
+CCF0
+7890
 0090
-07F0
-0420
-0420
+0090
+0FF0
+0410
+0410
 0420
-07E0
+07F0
 0400
 ENDCHAR
-STARTCHAR CA09
-ENCODING 51721
+STARTCHAR uniC571
+ENCODING 50545
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0030
-00D0
-0050
-7F50
-1250
-2450
-5670
-8950
-1150
-0810
+0070
+0090
+0090
+7890
+8490
+84F0
+8490
+7890
+0000
+0C10
 0410
 07F0
 0410
-0410
 07F0
 0410
 ENDCHAR
-STARTCHAR CA0B
-ENCODING 51723
+STARTCHAR uniC573
+ENCODING 50547
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-00C8
-0048
-7FC8
-0948
-1348
-2A78
-45C8
-88C8
-1048
-0040
-00C0
+0070
 0130
-0208
-0C04
+1090
+6890
+8490
+8490
+8CF0
+7890
+0090
+0190
+0080
+0140
+0220
+0418
+1808
 ENDCHAR
-STARTCHAR CA0C
-ENCODING 51724
+STARTCHAR uniC574
+ENCODING 50548
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0030
-00D0
-0050
-7F50
-1250
-2650
-5670
-8950
-1150
-0050
-0C20
-0C40
+0070
+0130
+1090
+6890
+8490
+8490
+CCF0
+7890
+0090
+0CB0
+0420
 0C60
-1298
-2108
-4000
-ENDCHAR
-STARTCHAR CA0D
-ENCODING 51725
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0018
-0068
-0028
-3FA8
-0928
-1328
-2B38
-44A8
-88A8
-0000
-01E0
-0210
-0210
-0330
-01E0
+1250
+2088
+4100
 ENDCHAR
-STARTCHAR CA14
-ENCODING 51732
+STARTCHAR uniC575
+ENCODING 50549
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0010
-4C50
-3FD0
-089E
-1990
-2590
-4650
-845E
-0810
-1010
-0010
-0010
-0010
+0110
+1090
+6890
+8490
+8490
+8CF0
+7890
+0090
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR CA18
-ENCODING 51736
+STARTCHAR uniC57C
+ENCODING 50556
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0060
+0040
 0020
 0020
-7FA0
-113C
-3120
-2B20
-44A0
-88BC
 1020
-1020
-0820
-0800
-0800
-0FF0
+7C20
+C63C
+8220
+8220
+C620
+3C2C
+0030
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR CA29
-ENCODING 51753
+STARTCHAR uniC57D
+ENCODING 50557
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
+1020
+1020
+6C24
+8238
+8220
+C620
+383C
 0020
+3FE0
 0020
-7F20
-1138
-3220
-4D20
-88AC
-10B0
-2100
-06C0
-0820
-0820
-0C60
-03C0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR CA4C
-ENCODING 51788
+STARTCHAR uniC580
+ENCODING 50560
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0060
+0020
+1020
+7820
+863C
+8220
+8220
+4420
+382C
 0030
-0010
-7FD0
-0890
-1090
-1910
-2570
-4290
-8450
-0850
-1010
-0010
-0010
-0010
+0020
+1820
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR CA4D
-ENCODING 51789
+STARTCHAR uniC584
+ENCODING 50564
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -3
+BBX 14 15 2 -2
 BITMAP
-0018
-0088
-3F88
-0888
-1908
-26B8
-4248
-8448
-0008
-0FF8
-0408
-0008
-0008
-0008
-0008
+0060
+1020
+7C20
+C62C
+8230
+8220
+C624
+3C38
+0000
+1FE0
+0020
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR CA50
-ENCODING 51792
+STARTCHAR uniC587
+ENCODING 50567
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-FF90
-1110
-2110
-32F0
-4E10
-8910
-1090
-2010
-1010
-0810
-0800
-0800
-0FF8
+0040
+1020
+7C20
+C624
+8238
+8220
+4620
+3C3C
+0330
+7D10
+05F0
+6D10
+3110
+23F0
+3D10
 ENDCHAR
-STARTCHAR CA54
-ENCODING 51796
+STARTCHAR uniC58C
+ENCODING 50572
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-0030
-0010
-FF90
-1110
-2110
-3A70
-4D90
-8890
-1000
-3FE0
+0060
+0020
+1020
+6C24
+8238
+8220
+C220
+7C3C
 0020
+0000
 1FE0
+0820
+0820
+0840
+0FE0
 0800
-0800
-0FF0
 ENDCHAR
-STARTCHAR CA5C
-ENCODING 51804
+STARTCHAR uniC58D
+ENCODING 50573
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 16 2 -3
 BITMAP
-0030
-0010
-FF90
-1110
-3310
-3270
-4D10
-8890
-1010
+0060
+1020
+7C20
+C62C
+8230
+8220
+C62C
+3C30
 0000
-1FE0
+1820
 0820
+0FE0
 0820
-0840
+0820
 0FE0
-0800
+0820
 ENDCHAR
-STARTCHAR CA5D
-ENCODING 51805
+STARTCHAR uniC58F
+ENCODING 50575
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -1
 BITMAP
-0030
-0010
-7F90
-1110
-2210
-3A70
-4D10
-8890
-1010
-0C60
-0420
-07E0
-0420
-0420
-07E0
-0420
+0060
+1020
+3020
+4C20
+8238
+8220
+4620
+382C
+0330
+01A0
+0100
+0280
+0460
+1810
 ENDCHAR
-STARTCHAR CA5F
-ENCODING 51807
+STARTCHAR uniC591
+ENCODING 50577
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
+0040
+1020
+3020
+4C20
+823C
+8220
+C420
+382C
 0030
-0010
-FB90
-1510
-1110
-3270
-4D10
-8890
-1090
-0110
-0100
-0380
-0660
-0810
-1008
+0120
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR CA60
-ENCODING 51808
+STARTCHAR uniC595
+ENCODING 50581
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-FF90
-1190
-3110
-2A70
-4B10
-8490
+0060
+0020
+7C20
+C63C
+8220
+8220
+C62C
+3C30
+0020
+1FF0
 0800
-0860
-0420
-0C60
-1290
-2118
-4208
+0800
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR CA61
-ENCODING 51809
+STARTCHAR uniC597
+ENCODING 50583
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0010
-FF90
-1110
-3310
-3270
-4D10
-8890
-1010
-0090
-03C0
-0420
-0420
-0420
-03C0
+0060
+0020
+0020
+7C20
+C63C
+8220
+C620
+7C20
+003C
+03A0
+3F40
+0180
+0640
+0440
+0380
 ENDCHAR
-STARTCHAR CA68
-ENCODING 51816
+STARTCHAR uniC598
+ENCODING 50584
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
+0190
 0090
-0050
-0050
-7E50
-2250
-2450
-55D0
-9C50
-1250
-1250
-2050
-0050
-0050
+0090
+1090
+68F0
+8490
+8490
+CCF0
+7890
+0090
+0090
+0090
+0090
 0010
 ENDCHAR
-STARTCHAR CA7D
-ENCODING 51837
+STARTCHAR uniC59C
+ENCODING 50588
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-0068
-0028
-3F28
-0928
-1AE8
-2B28
-44A8
-8828
-1028
-00D0
-0108
-0108
-0198
-00F0
+0060
+0190
+0090
+1090
+68F0
+8490
+8490
+CCF0
+7890
+0090
+0090
+1810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CA84
-ENCODING 51844
+STARTCHAR uniC5A0
+ENCODING 50592
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0030
-0010
-0010
-3FD0
-08F0
+0020
+0190
 1090
-1D10
-26F0
-4290
-8450
-0850
-1010
-0010
-0010
-0010
+7C90
+C6F0
+8290
+C690
+7CF0
+0080
+1FE0
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR CA98
-ENCODING 51864
+STARTCHAR uniC5A9
+ENCODING 50601
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0010
-FF90
-11F0
-3110
-2A10
-4B30
+0060
+0190
+1090
+7890
+84F0
 8490
-0810
-0860
-0420
-0C40
-12B0
-2118
-4208
+8490
+78F0
+0090
+0C90
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR CABC
-ENCODING 51900
+STARTCHAR uniC5B4
+ENCODING 50612
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 12 15 2 -2
 BITMAP
-7FF8
-0410
-0C20
-0A60
-13D8
-610C
-8200
-0500
-0100
-0100
-FFFE
+0060
+0010
+0010
+0810
+7C10
+C610
+8210
+83F0
+4610
+3C10
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR CABD
-ENCODING 51901
+STARTCHAR uniC5B5
+ENCODING 50613
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-3F30
-04E0
-0C40
-12B8
-6104
-0700
-0100
-FFFE
-2000
+0060
+1010
+3810
+C610
+8210
+83F0
+C610
+3C10
+0010
+0000
 3FE0
 1020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR CAC0
-ENCODING 51904
+STARTCHAR uniC5B8
+ENCODING 50616
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-3EF0
-0630
-0460
-1B9C
-2100
-0780
-0100
-FFFE
-2000
+0060
+0010
+0810
+7C10
+C610
+8330
+82D0
+4610
+3C10
+0010
+1010
+0810
+0800
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniC5B9
+ENCODING 50617
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0810
+7C10
+C610
+83F0
+8310
+4610
+3C10
+0010
+4030
+23C0
+20C0
+20A0
+3D10
+0600
+ENDCHAR
+STARTCHAR uniC5BB
+ENCODING 50619
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+1010
+3810
+4610
+8210
+83F0
+C610
+3C10
+0010
 0000
+3FF0
 0800
 0800
 0800
-07F8
+0FF8
 ENDCHAR
-STARTCHAR CAC4
-ENCODING 51908
+STARTCHAR uniC5BC
+ENCODING 50620
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-7DE0
-0C40
-1880
-2578
-C600
-0100
-FFFC
-0000
-3FC0
-0040
-3FC0
-1000
-1000
+0030
+0010
+7C10
+8210
+83F0
+C610
+7C10
+0010
+3FE0
+0020
+0020
 1FE0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CACC
-ENCODING 51916
+STARTCHAR uniC5BD
+ENCODING 50621
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-2210
-1E70
-0C60
-12F0
-210C
-0700
-0100
-FFFE
+0070
+0810
+3C10
+4610
+83F0
+8310
+C610
+3C10
+0010
 0000
-0FE0
-0820
-0840
-0FC0
-0800
+3CF0
+0410
+3810
+2010
+3C10
 ENDCHAR
-STARTCHAR CACD
-ENCODING 51917
+STARTCHAR uniC5BE
+ENCODING 50622
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 16 2 -3
 BITMAP
-2210
-1E70
-0460
-1AF0
-210C
-0700
+0070
+0810
+3C10
+4310
+83F0
+8310
+4210
+3C10
+0010
+3C00
+05F8
+6D30
+3130
+2330
+3DF0
 0100
-FFFE
-0C60
-0420
-07E0
-0420
-07E0
-0420
 ENDCHAR
-STARTCHAR CACF
-ENCODING 51919
+STARTCHAR uniC5C4
+ENCODING 50628
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 16 2 -3
 BITMAP
-3210
-0E70
-0C60
-12F0
-210C
-0700
-0100
-FFFE
-0180
-0100
-0380
-0660
-0810
-3008
+0070
+1010
+7810
+8610
+8230
+83D0
+4610
+3C10
+0010
+0000
+1FE0
+0820
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR CAD1
-ENCODING 51921
+STARTCHAR uniC5C5
+ENCODING 50629
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 16 2 -3
 BITMAP
-1E10
-0470
-0A20
-11F0
-210C
-0700
-0100
-FFFE
-0080
-03C0
+0070
+1010
+3810
+C610
+8210
+83F0
+C610
+3C10
+0010
+1C30
 0420
+07E0
 0420
 0420
-03C0
+07E0
+0420
 ENDCHAR
-STARTCHAR CAD3
-ENCODING 51923
+STARTCHAR uniC5C6
+ENCODING 50630
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-7DE0
-0C40
-1C80
-2378
-C600
-0200
-FFFC
-0000
-0700
-7FF0
-0200
-0700
-08E0
-7010
+0030
+1010
+6E10
+8210
+83F0
+C610
+3C10
+0010
+4400
+2420
+3C20
+2460
+2450
+3C88
+2500
 ENDCHAR
-STARTCHAR CAD8
-ENCODING 51928
+STARTCHAR uniC5C7
+ENCODING 50631
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-7FD0
-0890
-1990
-2590
-4250
-8416
-0A18
-02F0
-7D10
-0010
-0010
-0010
+0810
+7C10
+C610
+8210
+83F0
+4610
+3C10
 0010
+0190
+0110
+0380
+0660
+0810
+1008
 ENDCHAR
-STARTCHAR CAD9
-ENCODING 51929
+STARTCHAR uniC5C8
+ENCODING 50632
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 13 15 2 -2
 BITMAP
-0030
-0010
-7F90
-1990
-2B10
-44D6
-0E18
-0470
-FF90
-0000
-1FF0
-0010
-0010
-0010
-0010
+0060
+1010
+7C10
+C610
+82F0
+8310
+C610
+3C10
 0010
+0820
+0820
+0860
+1650
+2288
+4108
 ENDCHAR
-STARTCHAR CAE0
-ENCODING 51936
+STARTCHAR uniC5C9
+ENCODING 50633
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0020
-0010
-7FD0
-0890
-1990
-2670
-C61E
-1AF0
-0790
-7FF0
+0070
+1010
+3810
+C610
+8210
+83F0
+C610
+3C10
 0010
-0FF0
-0400
-0400
-07F8
+0090
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR CAEC
-ENCODING 51948
+STARTCHAR uniC5CA
+ENCODING 50634
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0020
+0030
 0010
-7FD0
-0890
-1990
-2670
-C616
-1AF8
-0790
-7820
-0210
-0210
-0530
-0848
-3084
+7C10
+8210
+83F0
+C610
+7C10
+0010
+0000
+3FF0
+0100
+0300
+06C0
+0830
+3010
 ENDCHAR
-STARTCHAR CAF4
-ENCODING 51956
+STARTCHAR uniC5CC
+ENCODING 50636
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0020
-0090
-0050
-FF50
-1350
-2250
-5F50
-8850
-1870
-0850
-1FD0
-6050
-0050
-0050
+0030
+0810
+7C10
+C610
+83F0
+8310
+4610
+3C10
 0010
+00F0
+1F30
+00E0
+3F20
+0040
+0040
 ENDCHAR
-STARTCHAR CB08
-ENCODING 51976
+STARTCHAR uniC5CE
+ENCODING 50638
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 14 2 -1
 BITMAP
 0030
-00D0
-7F50
-2250
-5750
-88F0
-1450
-07D0
-7870
-0620
-0420
-0B58
-1188
-6104
+0810
+7C10
+C610
+83F0
+8210
+4610
+3C10
+0030
+1FF0
+0060
+0440
+0440
+3FF8
 ENDCHAR
-STARTCHAR CB10
-ENCODING 51984
+STARTCHAR uniC5D0
+ENCODING 50640
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-FFD0
-1890
-1110
-2B10
-44D0
-0C10
-1410
-04F0
-FB10
+0190
+1090
+3890
+C490
+8490
+8790
+4490
+3890
+0090
+0090
+0090
+0090
+0010
+ENDCHAR
+STARTCHAR uniC5D1
+ENCODING 50641
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0190
+1090
+6890
+8490
+8790
+C490
+7890
+0090
+0000
+1FF0
+0810
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR CB14
-ENCODING 51988
+STARTCHAR uniC5D4
+ENCODING 50644
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-0060
-0020
-FFA0
-1120
-3320
-4CA0
-8C20
-34E0
-0F20
-F020
-0020
-1820
-0800
-0800
-0FF8
+0030
+0190
+0090
+1090
+6C90
+8490
+8790
+C490
+7890
+0090
+0090
+0C10
+0400
+0408
+03FC
 ENDCHAR
-STARTCHAR CB18
-ENCODING 51992
+STARTCHAR uniC5D8
+ENCODING 50648
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -1
+BBX 12 15 2 -2
 BITMAP
-0060
-0010
-7F90
-0890
-1190
-2E50
-C610
-0EF0
-0790
-7FF0
+0030
+0190
+1090
+6890
+8490
+8790
+C490
+7890
+0FE0
+0020
 0020
+1FE0
+0800
+0800
 0FF0
-0400
-07F8
 ENDCHAR
-STARTCHAR CB20
-ENCODING 52000
+STARTCHAR uniC5E0
+ENCODING 50656
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
+0070
 0010
-7F90
-0890
-1990
-2650
-C610
-0AF0
-0790
-7800
+0090
+1090
+6890
+8490
+8790
+C490
+7890
+0080
 0FF0
 0410
 0420
+0420
 07F0
 0400
 ENDCHAR
-STARTCHAR CB21
-ENCODING 52001
+STARTCHAR uniC5E1
+ENCODING 50657
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0060
+01B0
+1090
+6890
+8490
+8790
+C490
+7890
+0090
+0C30
+0420
+07E0
+0420
+0420
+07E0
+0420
+ENDCHAR
+STARTCHAR uniC5E3
+ENCODING 50659
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0C90
-3B90
-1110
-22D0
-C410
-0E10
-07F0
-7800
-0810
-0410
-07F0
-0410
-07F0
-0410
+0110
+0090
+1090
+6C90
+8490
+8790
+C490
+7890
+0390
+0090
+0180
+0240
+0430
+1810
 ENDCHAR
-STARTCHAR CB41
-ENCODING 52033
+STARTCHAR uniC5E5
+ENCODING 50661
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-7C00
-09E0
-1C40
-65C0
-8238
-0D80
-0888
-FFFC
-0200
-0F80
-18C0
-1040
-18C0
-0F80
+0070
+0190
+1090
+7890
+8490
+8490
+8790
+4C90
+3090
+0080
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR CB48
-ENCODING 52040
+STARTCHAR uniC5EC
+ENCODING 50668
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 15 2 -2
 BITMAP
-3E10
-06F0
-0420
-0A70
-308C
-0300
-0004
-FFFE
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+0070
+0010
+0010
+1010
+7D70
+C690
+8210
+8210
+C7F0
+3C10
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR CB49
-ENCODING 52041
+STARTCHAR uniC5ED
+ENCODING 50669
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -3
 BITMAP
-3EF0
-0420
-0C60
-12DC
-2100
-4204
-FFFE
-0100
-0100
+1060
+3010
+4C10
+82F0
+8210
+C610
+7DF0
+0010
+0010
 3FE0
+1020
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR CB4C
-ENCODING 52044
+STARTCHAR uniC5EE
+ENCODING 50670
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 16 2 -3
 BITMAP
-3EF0
-0610
-0420
-1B78
-2184
-0200
-FFFE
-0100
-0100
-0100
-1900
-0900
-0800
-07F8
+0030
+0010
+1010
+6CF0
+8210
+8210
+C7F0
+7C10
+0000
+01F0
+7C10
+0410
+0410
+0410
+0410
+0400
 ENDCHAR
-STARTCHAR CB50
-ENCODING 52048
+STARTCHAR uniC5F0
+ENCODING 50672
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-3FF0
-0430
-0E60
-11D8
-6104
-0600
-FFFE
-0100
-1F20
-00E0
-1FE0
+0030
+0010
+1010
+6DF0
+8210
+8210
+C610
+7CF0
+0010
+0010
+1010
 0800
 0800
-0FF0
+0800
+0FF8
 ENDCHAR
-STARTCHAR CB58
-ENCODING 52056
+STARTCHAR uniC5F4
+ENCODING 50676
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 13 15 2 -2
 BITMAP
-7DF0
-0C20
-0840
-34C0
-4338
-0208
-FFF4
-0200
-0200
-3FC0
-1040
-1040
-1040
-1FC0
-1000
+0030
+1010
+3010
+4CF0
+8210
+8210
+C7F0
+7C10
+0380
+0C60
+0020
+1FE0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CB59
-ENCODING 52057
+STARTCHAR uniC5F6
+ENCODING 50678
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 16 2 -3
 BITMAP
-3EF0
-0610
-0C20
-1A50
-208C
-0100
-FFFE
+0060
+0030
+1010
+6C10
+8270
+8210
+C610
+7DF0
+0010
+3DF0
+0530
+6D30
+3130
+2330
+3DF0
 0100
-1960
-0920
-0FE0
-0820
-0820
-0FE0
-0820
 ENDCHAR
-STARTCHAR CB5D
-ENCODING 52061
+STARTCHAR uniC5F7
+ENCODING 50679
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-3EF8
-0610
-0420
-0A5C
-3182
-0204
-FFFE
-0100
-0100
-06C0
-0820
-0820
-0C60
-07C0
+0030
+0010
+1010
+6CF0
+8210
+8210
+C6F0
+7C10
+0010
+7D10
+09F0
+7D10
+2110
+25F0
+3910
 ENDCHAR
-STARTCHAR CB64
-ENCODING 52068
+STARTCHAR uniC5FC
+ENCODING 50684
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-FF90
-1090
-1110
-2A90
-4450
-8810
-01D0
-7E10
-04F0
-0410
-0410
-0410
+1010
+3810
+44F0
+8210
+8210
+C610
+7CF0
 0010
+0000
+0FE0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR CB78
-ENCODING 52088
+STARTCHAR uniC5FD
+ENCODING 50685
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
 0010
-7F90
-1110
-3B10
-44D0
-0850
-FF90
-04F0
+3010
+4CF0
+8210
+8210
+C2F0
+7C10
 0000
-0C30
+0C70
 0420
-0A30
-1148
-2088
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR CB79
-ENCODING 52089
+STARTCHAR uniC5FE
+ENCODING 50686
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0030
+1010
+6C10
+82F0
+8210
+C610
+7CF0
 0010
-7F90
-1110
-2B10
-44D0
-0850
-FF90
-04F0
-0040
-01E0
-0210
-0210
-0310
-01E0
+6200
+2230
+3E20
+2220
+2250
+3E88
+2304
 ENDCHAR
-STARTCHAR CB9C
-ENCODING 52124
+STARTCHAR uniC5FF
+ENCODING 50687
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-D890
-2F90
-1110
-2B90
-4450
-8810
-00D0
-FF10
-0410
-0410
-0410
-0410
+1010
+7C10
+C6F0
+8210
+8210
+C7F0
+3C10
 0010
+0110
+0100
+0280
+0460
+0810
+3008
 ENDCHAR
-STARTCHAR CBB8
-ENCODING 52152
+STARTCHAR uniC600
+ENCODING 50688
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 2 -3
+BBX 13 15 2 -2
 BITMAP
-7C20
-0DE0
-0840
-14A0
-6118
-0600
-001E
-FFE0
-4840
-0840
-0840
-0840
-0840
-0840
-0040
+0030
+1010
+3810
+44F0
+8210
+8210
+C7F0
+3C10
+0000
+0820
+0C20
+0C60
+1250
+2298
+4108
 ENDCHAR
-STARTCHAR CBD4
-ENCODING 52180
+STARTCHAR uniC601
+ENCODING 50689
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 12 15 2 -2
 BITMAP
-3FF8
-0410
-0C30
-0A20
-1158
-6084
-0300
-0400
-000C
-FFFE
-2000
+0030
+1010
+1010
+6DF0
+8210
+8210
+C7F0
+3C10
+0010
+0080
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR CBE4
-ENCODING 52196
+STARTCHAR uniC605
+ENCODING 50693
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 15 2 -2
 BITMAP
-3E00
-04F0
-0C20
-1A70
-208C
-4100
-060E
-FFF8
-2000
-1FE0
-0820
-0820
-0840
+0030
+1010
+3810
+C6F0
+8210
+8210
+C6F0
+3C10
+0000
+1FF0
+0800
+0800
 0FE0
 0800
-ENDCHAR
-STARTCHAR CBE7
-ENCODING 52199
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-7DF0
-0C20
-0840
-14A0
-6318
-0200
-0008
-FFFC
-4600
-0300
-0700
-04C0
-1820
-6010
+0FF0
 ENDCHAR
-STARTCHAR CBE9
-ENCODING 52201
+STARTCHAR uniC606
+ENCODING 50694
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-3EF8
-0210
-0420
-0A50
-318C
-0104
-FFFE
+0030
+1010
+3810
+46F0
+8210
+8210
+C7F0
+7C10
 0000
-0100
-06C0
-0420
-0C20
-0460
-03C0
+0000
+1FF0
+0440
+0440
+0040
+3FF8
 ENDCHAR
-STARTCHAR CC0C
-ENCODING 52236
+STARTCHAR uniC607
+ENCODING 50695
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-0010
-7FD0
-0890
-1190
-2910
-2710
-4290
-8450
-0850
-0010
 0010
-0010
-0010
+1010
+6DF0
+8210
+8210
+C7F0
+7C10
+0390
+0000
+1FF0
+0100
+06C0
+0440
+0380
 ENDCHAR
-STARTCHAR CC0D
-ENCODING 52237
+STARTCHAR uniC608
+ENCODING 50696
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-FF90
-1190
-1110
-2B10
-4E90
-8450
-1850
-3FF0
-0810
-0010
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR CC10
-ENCODING 52240
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0060
-0010
-0010
-FF90
-1190
-1110
-2B10
-4A90
+0390
+0090
+1090
+7890
+C790
 8490
-0850
-1810
-0810
-0800
-0810
-07F8
+8490
+C490
+7B90
+0090
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR CC14
-ENCODING 52244
+STARTCHAR uniC60C
+ENCODING 50700
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0030
-0010
-7FD0
-1890
-1110
-2B10
-42D0
-8C50
-1000
-0FF0
-0010
-0FF0
+0090
+1090
+7890
+C790
+8490
+8490
+C790
+7890
+0090
+0090
+0C10
 0400
 0400
-07F8
+03FC
 ENDCHAR
-STARTCHAR CC1C
-ENCODING 52252
+STARTCHAR uniC610
+ENCODING 50704
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0110
+1090
+7890
+8790
+8490
+C490
+7B90
+0080
+1FE0
+0020
+1FE0
+0800
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniC618
+ENCODING 50712
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0010
-1810
-2F90
-1110
-2910
-4290
-84D0
-0850
+0190
+1090
+7890
+8790
+8490
+C490
+7B90
+0090
 0000
 0FF0
 0410
@@ -122202,22 +125343,22 @@
 07F0
 0400
 ENDCHAR
-STARTCHAR CC1D
-ENCODING 52253
+STARTCHAR uniC619
+ENCODING 50713
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0010
-F990
-1E90
-1110
-2B10
-42D0
-8450
+0190
+1090
+7890
+8790
+8490
+C490
+7B90
+0090
 0810
-0C30
 0410
 07F0
 0410
@@ -122225,110 +125366,86 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR CC21
-ENCODING 52257
+STARTCHAR uniC61B
+ENCODING 50715
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-0010
-F990
-1E90
-1110
-2B10
-42D0
-8450
-0810
+0070
+0190
+1090
+7890
+8790
+8490
+8490
+CF90
+7890
 0090
-03C0
-0420
-0420
-0660
-03C0
-ENDCHAR
-STARTCHAR CC22
-ENCODING 52258
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-FF90
-1990
-1110
-2B10
-4690
-8450
-0800
-3FF0
-0100
+0190
 0180
-0640
-0830
-3008
+0340
+0430
+1810
 ENDCHAR
-STARTCHAR CC27
-ENCODING 52263
+STARTCHAR uniC61C
+ENCODING 50716
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 16 2 -3
 BITMAP
 0030
-0010
+0190
+1090
+7890
+8790
+8490
+C490
+7B90
 0090
-7F90
-1110
-3110
-4A90
-8450
-0810
-03D0
-1F20
-02C0
-0440
-0240
-0380
+0040
+0420
+0C60
+0E60
+1298
+2108
+4000
 ENDCHAR
-STARTCHAR CC28
-ENCODING 52264
+STARTCHAR uniC624
+ENCODING 50724
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 12 1 0
 BITMAP
-0070
-0010
-0E10
-0010
-7F90
-0110
-0210
-041E
-0A10
-1190
-2090
-C010
-0010
-0010
-0010
+0100
+07C0
+0C60
+0820
+0820
+0820
+0440
+0380
+0300
+0100
+0100
+FFFE
 ENDCHAR
-STARTCHAR CC29
-ENCODING 52265
+STARTCHAR uniC625
+ENCODING 50725
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 15 16 1 -3
 BITMAP
-00C0
-1E20
-0020
-FF20
-0220
-0420
-0C38
-3320
-4020
-8000
+0100
+07C0
+0C60
+0820
+0820
+0460
+0380
+0100
+FFFE
+0000
 3FE0
 0020
 0020
@@ -122336,405 +125453,273 @@
 0020
 0020
 ENDCHAR
-STARTCHAR CC2C
-ENCODING 52268
+STARTCHAR uniC628
+ENCODING 50728
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0060
-0010
-0F10
-0010
-3F90
-0110
-0210
-061E
-0990
-3090
-C010
-0C10
-0400
-0400
-07F8
+0200
+0F80
+18C0
+1040
+1040
+0880
+0700
+0200
+FFFC
+0000
+2000
+1000
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR CC2E
-ENCODING 52270
+STARTCHAR uniC62C
+ENCODING 50732
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 3 -2
+BBX 15 15 1 -2
 BITMAP
-1CC0
-0040
-FE40
+0100
+0380
 0440
-0878
-1440
-2340
-C3C0
-C000
-47E0
-41E0
-4620
-7A20
-01E0
-ENDCHAR
-STARTCHAR CC30
-ENCODING 52272
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-00C0
-0020
-1E20
-0020
-7F20
-0224
-0438
-0A20
-3120
-5FE0
-8020
+0820
+0820
+0440
+0380
+0104
+FFFE
+0000
 1FE0
-0800
-0800
-0FF0
-ENDCHAR
-STARTCHAR CC38
-ENCODING 52280
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 16 2 -3
-BITMAP
-00C0
-0020
-1C20
 0020
-7F20
-0220
-043E
-0A20
-3120
-4000
-9FE0
-0840
-0840
-0840
 0FE0
 0800
+0FF0
 ENDCHAR
-STARTCHAR CC39
-ENCODING 52281
+STARTCHAR uniC62D
+ENCODING 50733
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 16 1 -2
 BITMAP
-0060
-3E20
-0020
-7F20
-0220
-043C
-0C20
-3320
-5920
-8820
-0FE0
+0100
+0380
+0FC0
 0820
 0820
-0FE0
 0820
-ENDCHAR
-STARTCHAR CC3B
-ENCODING 52283
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
-BITMAP
-0180
-0040
-3C40
-0040
-FE40
-0440
-0858
-1460
-2240
-C240
-0140
-0300
-0480
-0860
-3010
+06C0
+0104
+FFFE
+0000
+3EF0
+0210
+3610
+1810
+1110
+1E10
 ENDCHAR
-STARTCHAR CC3C
-ENCODING 52284
+STARTCHAR uniC62E
+ENCODING 50734
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-1E20
-0020
-7F20
-0220
-0420
-0C38
-3320
-4860
-8420
-0C40
-12E0
-2098
-4108
+0100
+06C0
+0820
+0820
+0C60
+0380
+0100
+FFFE
+0000
+3EF8
+0290
+1C90
+16F0
+0880
 ENDCHAR
-STARTCHAR CC3D
-ENCODING 52285
+STARTCHAR uniC630
+ENCODING 50736
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-00C0
+0100
+06C0
+0820
+0820
+0C60
+07C0
+0100
+FFFE
 1E20
-0020
-7F20
 0220
-0420
-0C3C
-1320
-6020
-80A0
-0340
-0420
-0420
-0660
-03C0
+3660
+1858
+1688
+1900
 ENDCHAR
-STARTCHAR CC3E
-ENCODING 52286
+STARTCHAR uniC633
+ENCODING 50739
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 15 1 -2
 BITMAP
-00C0
-0020
-1E20
-7F20
-0220
-0420
-0C3C
-3320
-40A0
-8000
-3FF0
 0100
-0300
-04C0
-1830
-6010
-ENDCHAR
-STARTCHAR CC44
-ENCODING 52292
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0060
-0110
-0090
-3C90
-0090
-7C90
-0490
-0890
-18F0
-2490
-4090
-8090
-0090
-0090
-0010
-ENDCHAR
-STARTCHAR CC45
-ENCODING 52293
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 16 3 -3
-BITMAP
-0060
-0320
-7920
-0120
-FD20
-0920
-11E0
-2920
-4520
-8120
-3FE0
-0020
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR CC48
-ENCODING 52296
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 3 -2
-BITMAP
-0060
-0320
-0120
-7920
-0120
-FD20
-0920
-11E0
-2920
-4520
-8120
-1920
-0800
-0810
-0FF0
+07C0
+0C60
+0820
+0820
+0440
+0380
+FFFE
+0000
+3E60
+03F8
+36C0
+18B0
+1690
+08F0
 ENDCHAR
-STARTCHAR CC4C
-ENCODING 52300
+STARTCHAR uniC634
+ENCODING 50740
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0060
-01B0
-3C90
-0090
-FE90
-0490
-08F0
-1490
-2290
-C090
+0100
+0380
+0C40
+0820
+0820
+0440
+0380
+0104
+FFFE
+0000
 1FF0
-0020
+0820
+0820
+0820
 0FE0
 0800
-0FF0
 ENDCHAR
-STARTCHAR CC54
-ENCODING 52308
+STARTCHAR uniC635
+ENCODING 50741
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 15 16 1 -3
 BITMAP
-0060
-0320
-3920
-0120
-FD20
-0920
-11E0
-2920
-4520
-8120
+0100
+0380
+0C60
+0820
+0820
+0440
+0380
+0106
+FFF8
+1820
+0820
 0FE0
 0820
 0820
-0840
 0FE0
-0800
+0820
 ENDCHAR
-STARTCHAR CC55
-ENCODING 52309
+STARTCHAR uniC637
+ENCODING 50743
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 15 1 -2
 BITMAP
-0010
-0048
-1C48
-0048
-7E48
-0678
-0C48
-1248
-2108
-C608
-0208
-03F8
-0208
-03F8
-0208
+0100
+07C0
+0C60
+0820
+0820
+0440
+0380
+0104
+FFFE
+0000
+0100
+0100
+02C0
+0430
+1810
 ENDCHAR
-STARTCHAR CC57
-ENCODING 52311
+STARTCHAR uniC639
+ENCODING 50745
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0030
-0090
-3C90
-0090
-FE90
-0490
-08F0
-1890
-6690
-8110
 0100
-0300
+0380
+0C60
+0820
+0820
 06C0
-0830
-3018
+0100
+0104
+FFFE
+0100
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR CC58
-ENCODING 52312
+STARTCHAR uniC63B
+ENCODING 50747
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0320
-3920
-0120
-FD20
-0920
-11E0
-3120
-4D20
-81A0
-0840
-0840
-14C0
-2730
-4010
+0100
+07C0
+0C60
+0820
+0820
+04C0
+0300
+FFFE
+0000
+03C0
+0038
+1FC0
+0380
+0460
+1810
 ENDCHAR
-STARTCHAR CC59
-ENCODING 52313
+STARTCHAR uniC640
+ENCODING 50752
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 14 2 -1
+BBX 14 15 2 -2
 BITMAP
-0060
-3B20
-0120
-0120
-7920
-1120
-29E0
-4520
-8120
-0680
-0860
+00E0
+0020
 0820
-0C60
-07C0
+3620
+4120
+4120
+4120
+3E2C
+0830
+09A0
+FE20
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR CC60
-ENCODING 52320
+STARTCHAR uniC641
+ENCODING 50753
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
@@ -122742,369 +125727,345 @@
 0030
 0010
 0E10
+3190
+2090
+3190
+1F1E
+0410
+8FD0
+7000
+1FF0
 0010
 0010
-7F9E
-0110
-0210
-0410
-0A16
-1198
-2090
-C010
 0010
 0010
 ENDCHAR
-STARTCHAR CC64
-ENCODING 52324
+STARTCHAR uniC644
+ENCODING 50756
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
 0030
-0F10
-0010
+0410
+0E10
+3190
+3090
+3090
+1912
+061C
+0470
+FF90
 0010
-3F96
-0118
-0210
-0610
-0996
-3098
-C810
-0400
+0C10
 0400
 0400
 07F8
-ENDCHAR
-STARTCHAR CC66
-ENCODING 52326
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
-BITMAP
-0180
-3C40
-0040
-0040
-FE78
-0440
-0840
-1458
-6260
-81C0
-2070
-23C0
-2120
-2D20
-31E0
 ENDCHAR
-STARTCHAR CC68
-ENCODING 52328
+STARTCHAR uniC648
+ENCODING 50760
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-00C0
+0060
+0820
+3E20
+6320
+4120
+222C
+1C30
+0BA0
+F420
+1FE0
 0040
-3C40
-0058
-FE60
-0440
-0848
-1470
-6200
-BFC0
 0040
-3FC0
-1000
-1000
 1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR CC70
-ENCODING 52336
+STARTCHAR uniC650
+ENCODING 50768
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 16 1 -3
 BITMAP
-0070
-0010
-0F10
-0010
-7F9E
-0110
-0210
-0510
-089C
-3000
-CFF0
-0420
-0420
+0060
+0030
+0E10
+3190
+2090
+3090
+1F16
+0638
+8FD0
+7010
+0FF0
+0410
+0410
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR CC75
-ENCODING 52341
+STARTCHAR uniC651
+ENCODING 50769
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 16 1 -3
 BITMAP
 0060
-1C20
-0020
-FE20
-063C
-0420
-0C20
-332C
-4030
-8120
-06C0
-0820
-0820
-0C60
-07C0
+0430
+0E10
+3190
+2090
+3190
+1F1E
+0430
+FFD0
+0C30
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR CC98
-ENCODING 52376
+STARTCHAR uniC653
+ENCODING 50771
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 16 2 -3
 BITMAP
-0018
-0008
-0E08
-0008
-7F08
-0308
-0298
-0468
-0A08
-1188
-6088
-8008
-0008
-0008
-0008
+0060
+0420
+1E20
+2120
+2120
+2120
+1E3C
+04E0
+FF20
+0120
+0180
+0180
+0240
+0430
+0808
+1000
 ENDCHAR
-STARTCHAR CC99
-ENCODING 52377
+STARTCHAR uniC654
+ENCODING 50772
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
-1E10
-0010
-7F10
-0210
-04F0
-0C10
-3310
-4110
-BFE0
-0020
-0020
-0020
-0020
+0410
+1F10
+2090
+2090
+3090
+0F1E
+0450
+FF90
 0020
+0610
+0430
+0F30
+1948
+2084
 ENDCHAR
-STARTCHAR CC9C
-ENCODING 52380
+STARTCHAR uniC655
+ENCODING 50773
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 1 -2
 BITMAP
-0060
-0010
-1E10
-0010
-7F10
-0210
+0030
 0410
-0CF0
-1210
-6110
-8010
-1810
-0800
-0800
-07F8
+0E10
+3190
+2090
+3190
+1F1C
+0630
+9FD0
+6050
+01E0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR CCA0
-ENCODING 52384
+STARTCHAR uniC65C
+ENCODING 50780
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-1E10
+0060
+0110
+0090
+1890
+6690
+4290
+4290
+2490
+18F0
+1190
+FE90
+0090
+0090
+0090
 0010
-7F10
-0210
-05F0
-0A10
-3110
-C000
-1FE0
-0020
-1FE0
-0800
-0800
-0FF0
 ENDCHAR
-STARTCHAR CCA8
-ENCODING 52392
+STARTCHAR uniC65D
+ENCODING 50781
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 15 2 -2
 BITMAP
 0060
-0020
-3C20
-0020
-FE20
-0420
-09E0
-1820
-2620
-C200
-0FE0
-0820
-0840
-0840
-0FE0
-0800
+0190
+1090
+6C90
+4490
+6490
+38F0
+1390
+FC90
+0000
+1FF0
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR CCA9
-ENCODING 52393
+STARTCHAR uniC660
+ENCODING 50784
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 14 2 -2
 BITMAP
-0030
-1E10
-0010
-0010
-7F10
-0210
-04F0
-0C10
-3200
-4D30
-8420
-07E0
-0420
-0420
-07E0
-0420
+0130
+0890
+7490
+4290
+4490
+3C90
+10F0
+0F90
+F090
+0090
+0810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CCAB
-ENCODING 52395
+STARTCHAR uniC66C
+ENCODING 50796
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 16 2 -3
 BITMAP
 0060
-0020
-3C20
-0020
-FE20
-07E0
-0820
-1820
-2620
-C620
-0320
-0300
-04C0
-1860
-2020
+0190
+0090
+7C90
+4490
+4490
+3CF0
+1190
+FE90
+0000
+0FF0
+0420
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR CCAC
-ENCODING 52396
+STARTCHAR uniC66F
+ENCODING 50799
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 14 2 -2
 BITMAP
 0030
-1E10
-0010
-7E10
-0610
-04F0
-0C10
-3310
-4100
-8820
-0420
-0C60
-1250
-2298
-4108
+0090
+3090
+4C90
+4490
+44F0
+3890
+1790
+E910
+0080
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR CCAD
-ENCODING 52397
+STARTCHAR uniC671
+ENCODING 50801
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 15 2 -2
 BITMAP
 0060
-3C20
-0020
-FE20
-0420
-0BE0
-1820
-2620
-C220
-0120
-0680
-0840
-0840
-0CC0
-0780
+0190
+0090
+7C90
+4290
+4490
+38F0
+1190
+FE90
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR CCB4
-ENCODING 52404
+STARTCHAR uniC678
+ENCODING 50808
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
-0130
-0090
-3C90
-0090
-FC90
-0C90
-0F90
-1090
-2890
-4490
-8090
-0090
-0090
+0070
+0810
+0810
+3610
+4110
+4110
+2310
+1C10
+0810
+09D0
+FE10
+0010
 0010
 0010
+0010
 ENDCHAR
-STARTCHAR CCB5
-ENCODING 52405
+STARTCHAR uniC679
+ENCODING 50809
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 11 16 3 -3
 BITMAP
 0060
-0220
-3920
-0120
-FD20
-0920
-1120
-3720
-4920
-8500
+1820
+6620
+4220
+4220
+2420
+1820
+0FE0
+F020
+0000
 3FE0
 0020
 0020
@@ -123112,67 +126073,66 @@
 0020
 0020
 ENDCHAR
-STARTCHAR CCB8
-ENCODING 52408
+STARTCHAR uniC67C
+ENCODING 50812
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
 0060
-0130
-3C90
-0090
-0090
-FC90
-0C90
-0F90
-1890
-2490
-4290
-1890
-0810
+0020
+3C20
+4220
+4220
+4220
+3C20
+1020
+0FA0
+F020
+0020
+1800
 0800
-0FF8
+0800
+0FF0
 ENDCHAR
-STARTCHAR CCBC
-ENCODING 52412
+STARTCHAR uniC680
+ENCODING 50816
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 3 -2
 BITMAP
-0020
-0110
-3890
-0090
-FC90
-0C90
-0F90
-1890
-2690
-C090
-1FF0
-0020
+0060
+0820
+7620
+4220
+4220
+2220
+1C20
+0FE0
+F020
 1FE0
+0040
+1FC0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR CCC4
-ENCODING 52420
+STARTCHAR uniC688
+ENCODING 50824
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0060
-0130
-3890
-0090
-FC90
-0C90
-0B90
-1490
-2690
-C290
+0030
+0410
+3A10
+2110
+2110
+1210
+0C10
+0BF0
+FC10
+0000
 0FF0
 0410
 0420
@@ -123180,22 +126140,22 @@
 07F0
 0400
 ENDCHAR
-STARTCHAR CCC5
-ENCODING 52421
+STARTCHAR uniC689
+ENCODING 50825
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0060
-0130
-3890
-0090
-FC90
-0890
-1F90
-1890
-6490
-8810
+0030
+0C10
+3310
+2110
+2110
+1210
+0C10
+0BF0
+F410
+0810
 0410
 07F0
 0410
@@ -123203,518 +126163,879 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR CCC7
-ENCODING 52423
+STARTCHAR uniC68B
+ENCODING 50827
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0060
-0130
-3C90
-FC90
-0C90
-0890
-1790
-2690
-C290
-0110
-0090
-0180
-0240
-0430
-1808
+00C0
+0820
+3C20
+6620
+4220
+4220
+2420
+1860
+0FA0
+F020
+0320
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR CCC9
-ENCODING 52425
+STARTCHAR uniC68D
+ENCODING 50829
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
-0130
-3890
-0090
-FC90
-0890
-1F90
-1890
-6490
-8290
-0340
+0820
+7620
+4220
+4220
+2420
+1820
+17E0
+E820
+0020
+0780
+0840
+0840
+0CC0
+0780
+ENDCHAR
+STARTCHAR uniC694
+ENCODING 50836
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -1
+BITMAP
+0100
+0100
+06C0
+0820
+0820
+0820
+0440
+03C0
 0420
 0420
-0660
-03C0
+0444
+FFFE
+2000
 ENDCHAR
-STARTCHAR CCD0
-ENCODING 52432
+STARTCHAR uniC695
+ENCODING 50837
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0030
-0010
-1E10
-0010
-7E10
-02F0
-0410
-0810
-15F0
-2210
-4110
-8010
-0010
-0010
-0010
+0100
+07C0
+0C60
+0820
+0820
+0C40
+0FE0
+0420
+FFFE
+0000
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR CCD4
-ENCODING 52436
+STARTCHAR uniC698
+ENCODING 50840
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-1E10
-0010
-7F10
-0270
-0610
-0C10
-1370
-2110
-C010
-0C10
-0400
-0400
-07FC
+0100
+06C0
+0820
+0820
+0C60
+0FC0
+0420
+FF3E
+00C0
+0000
+0800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR CCE4
-ENCODING 52452
+STARTCHAR uniC69C
+ENCODING 50844
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0070
-1C10
-0010
-0010
-7FF0
+0100
+07C0
+0860
+0820
+0820
+07C0
+0460
+0440
+FFFE
+0000
+1FE0
+0020
+1FE0
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniC6A4
+ENCODING 50852
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
+BITMAP
+0100
+07C0
+0820
+0820
+0820
+07C0
+0420
+0440
+FFFE
+0000
+0FF0
 0410
-0810
-15F0
-2210
-C860
 0420
-0C20
-0A50
-1098
-6108
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR CCEC
-ENCODING 52460
+STARTCHAR uniC6A5
+ENCODING 50853
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 16 1 -3
 BITMAP
-0040
-0030
-0190
-3890
-0090
-FC90
-0F90
-0890
-1090
-2B90
-4490
-8090
-0090
-0090
-0010
-0010
+0100
+07C0
+0820
+0820
+0820
+07C0
+0460
+044E
+FFB0
+1820
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR CCF0
-ENCODING 52464
+STARTCHAR uniC6A7
+ENCODING 50855
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0030
-00D0
-1E50
-0050
-7E50
-03D0
-0450
-0C50
-12D0
-2250
-CC50
-0450
-0400
-07F8
+0100
+06C0
+0820
+0820
+0C60
+07C0
+0460
+0440
+FFFE
+0100
+0100
+02C0
+0430
+1818
 ENDCHAR
-STARTCHAR CD01
-ENCODING 52481
+STARTCHAR uniC6A9
+ENCODING 50857
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0020
-0190
-3890
-0090
-FC90
-0B90
-1890
-3B90
-4490
-8090
-0360
-0410
-0410
-0630
-03E0
+0200
+0F80
+18C0
+1040
+1040
+0880
+1FC0
+0888
+FFFC
+0200
+0D80
+1040
+1040
+18C0
+0780
 ENDCHAR
-STARTCHAR CD08
-ENCODING 52488
+STARTCHAR uniC6B0
+ENCODING 50864
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 15 1 -3
 BITMAP
-03C0
+0100
+06C0
+0820
+0820
+0C60
+07C0
 0000
-3FF0
-0060
-0080
-0380
-0C78
-3100
+FFFE
 0100
 0100
-FFFE
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR CD09
-ENCODING 52489
+STARTCHAR uniC6B1
+ENCODING 50865
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-0780
-0060
-1FC0
-0180
-0E7C
-3100
 0100
+07C0
+0C60
+0820
+0820
+0C60
+03C0
+0004
 FFFE
-0000
-3FE0
-0020
+0100
+0120
+0EE0
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR CD0C
-ENCODING 52492
+STARTCHAR uniC6B4
+ENCODING 50868
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 14 3 -2
 BITMAP
-0380
-0000
-1FF0
-0060
-0180
-0678
-1904
-2104
-FFFE
-0000
-0800
-0800
-0800
-0FF8
+0200
+0F80
+1040
+1040
+1040
+0D80
+0200
+FFF8
+0200
+0200
+1200
+1200
+1000
+1FE0
 ENDCHAR
-STARTCHAR CD10
-ENCODING 52496
+STARTCHAR uniC6B8
+ENCODING 50872
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-03C0
-3FE0
-00C0
-0180
-0E7C
-7100
-0104
+0100
+07C0
+0860
+0820
+0820
+0440
+0384
 FFFE
-0000
-1FE0
-0020
+0100
+0100
+0EE0
+0040
 1FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR CD18
-ENCODING 52504
+STARTCHAR uniC6B9
+ENCODING 50873
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 15 1 -2
 BITMAP
-03C0
-1FE0
-00C0
-0180
-0E78
-7100
 0100
-FFFE
+06C0
+0C20
+0820
+0460
+03C0
 0000
-1FE0
+FFFE
+0100
+3F10
+0470
+3E10
+1010
+1310
+1C10
+ENDCHAR
+STARTCHAR uniC6BA
+ENCODING 50874
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0100
+06C0
 0820
 0820
+0C60
+07C0
+0000
+FFFE
+0100
+1FF8
+04C8
+3E50
+1050
+1378
+1C00
+ENDCHAR
+STARTCHAR uniC6C0
+ENCODING 50880
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -3
+BITMAP
+07C0
+0820
 0820
+0660
+03C0
+F800
+07FE
+0100
+1F00
+08E0
+0860
+0860
 0FE0
 0800
 ENDCHAR
-STARTCHAR CD19
-ENCODING 52505
+STARTCHAR uniC6C1
+ENCODING 50881
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 16 1 -3
 BITMAP
-0380
-1FE0
-0040
-0180
-0F78
-7100
-817E
-7F80
-3820
+0100
+06C0
+0820
 0820
+0C60
+07C0
+0004
+FFFE
+0100
+1160
+0920
 0FE0
 0820
 0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR CD1B
-ENCODING 52507
+STARTCHAR uniC6C3
+ENCODING 50883
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-0780
-3FE0
-00C0
-0180
-0678
-3900
-0100
-FFFE
-0000
+0F80
+08C0
+1040
+0840
+0480
 0300
-0100
-02C0
-0C30
-1008
+FFFC
+0200
+0200
+0200
+0200
+0580
+1860
+2000
 ENDCHAR
-STARTCHAR CD1D
-ENCODING 52509
+STARTCHAR uniC6C5
+ENCODING 50885
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-0780
-3FE0
-00C0
-0300
-0CF8
-7100
-0104
+0100
+03C0
+0420
+0420
+0420
+03C0
+0000
 FFFE
 0100
-06C0
-0820
+0100
+07C0
+0860
 0820
 0C60
-0380
+07C0
+ENDCHAR
+STARTCHAR uniC6CC
+ENCODING 50892
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0810
+1E10
+2110
+2110
+2110
+1E10
+0190
+FE10
+09F0
+0810
+0810
+0810
+0010
+0010
+ENDCHAR
+STARTCHAR uniC6CD
+ENCODING 50893
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0C10
+3310
+2110
+3110
+1E10
+0190
+FE30
+08D0
+0800
+1FF0
+0810
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniC6D0
+ENCODING 50896
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0008
+0608
+1988
+1088
+1888
+0F08
+0188
+FE08
+0478
+0408
+0E08
+0200
+0200
+03FC
+ENDCHAR
+STARTCHAR uniC6D4
+ENCODING 50900
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0C10
+3310
+2110
+2110
+1E10
+0190
+FE70
+1FF0
+0010
+0020
+1FF0
+0800
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniC6DC
+ENCODING 50908
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0C10
+3310
+2110
+2110
+1E10
+0190
+FEF0
+0810
+0800
+0FF0
+0410
+0420
+0420
+07F0
+0400
+ENDCHAR
+STARTCHAR uniC6DD
+ENCODING 50909
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0C10
+3310
+2110
+2110
+1E10
+0190
+FE70
+0890
+0830
+0410
+07F0
+0410
+0410
+07F0
+0410
+ENDCHAR
+STARTCHAR uniC6E0
+ENCODING 50912
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0C10
+3310
+2110
+3110
+1E10
+0090
+FF10
+08F0
+0000
+0C20
+0420
+0A60
+1298
+6108
+ENDCHAR
+STARTCHAR uniC6E1
+ENCODING 50913
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+1E10
+2110
+2110
+2110
+1E10
+0190
+FE10
+08F0
+0890
+03E0
+0610
+0410
+0630
+03C0
+ENDCHAR
+STARTCHAR uniC6E8
+ENCODING 50920
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0030
+0088
+0048
+0848
+3648
+2248
+3248
+1C48
+0348
+FC48
+09C8
+0848
+0848
+0048
+0008
+ENDCHAR
+STARTCHAR uniC6E9
+ENCODING 50921
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0190
+7C90
+4290
+4490
+3C90
+0190
+FE90
+1790
+1080
+1FF0
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniC6EC
+ENCODING 50924
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0070
+0010
+0890
+3690
+4290
+2690
+1C90
+0290
+FC90
+0B90
+0090
+1C00
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR CD24
-ENCODING 52516
+STARTCHAR uniC6F0
+ENCODING 50928
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 2 -2
 BITMAP
 0030
-0010
-0F10
-0010
-3F90
 0110
-0210
-0F16
-1CD8
-E410
-05F0
-7A10
-0010
-0010
-0010
+0090
+7C90
+4490
+6490
+3C90
+0290
+FF90
+1FF0
+1020
+0FF0
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR CD28
-ENCODING 52520
+STARTCHAR uniC6F8
+ENCODING 50936
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0020
-1E20
-0020
-7E20
-0C20
-13AC
-6C30
-09A0
-FE20
-0020
-1820
-0800
-0800
+0030
+0110
+0090
+7C90
+4290
+4490
+3C90
+0190
+FF90
+1080
+1FF0
+0410
+0420
+0420
 07F0
+0400
 ENDCHAR
-STARTCHAR CD2C
-ENCODING 52524
+STARTCHAR uniC6F9
+ENCODING 50937
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-1E20
-0020
-7F20
-0420
-1BA4
-6C38
-0460
-FFA0
-0000
-1FE0
-0020
-1FE0
-0800
-0FF0
+0030
+0990
+7490
+4290
+4490
+3C90
+0190
+FE90
+1790
+1C90
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR CD39
-ENCODING 52537
+STARTCHAR uniC6FD
+ENCODING 50941
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 13 15 1 -2
 BITMAP
-0030
-0F10
-3F90
-0110
-0610
-1FD0
-223C
-FFD0
-0010
-01E0
+0018
+0048
+0048
+3E48
+2248
+2248
+1E48
+00C8
+FF48
+0848
+09E0
 0210
 0210
-0330
+0210
 01E0
 ENDCHAR
-STARTCHAR CD5C
-ENCODING 52572
+STARTCHAR uniC704
+ENCODING 50948
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
+0820
+3C20
+4220
+4220
+4220
+3C20
+0020
+01A0
+FE20
+0820
+0820
+0820
+0820
+0020
+ENDCHAR
+STARTCHAR uniC705
+ENCODING 50949
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0C10
+3310
+2110
+3110
+1E10
+0070
+FF90
+0410
+0410
+1FF0
 0010
-0E10
-0010
-7F90
-0310
-0610
-0F10
-3CD0
-C410
-07D0
-7810
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR CD60
-ENCODING 52576
+STARTCHAR uniC708
+ENCODING 50952
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0020
-1C20
-0020
-7E20
-0820
-37A0
-C820
-1FE0
-E020
-0020
-1800
-0800
-0800
-0FF0
+0030
+0010
+1E10
+2110
+2110
+3110
+1E10
+00D0
+FF10
+0410
+0010
+0C00
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR CD64
-ENCODING 52580
+STARTCHAR uniC70C
+ENCODING 50956
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-1E10
-0010
-7F10
-0210
 0C10
-37D0
-C4F0
-FF10
-0000
-0FF0
-0020
+3310
+2110
+3110
+1E10
+0190
+FE10
+0810
+0800
+1FE0
+1FE0
+0800
+0800
 0FF0
-0400
-07F8
 ENDCHAR
-STARTCHAR CD6C
-ENCODING 52588
+STARTCHAR uniC714
+ENCODING 50964
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-1E10
-0010
-7F10
-0310
 0C10
-17D0
-E4F0
-FB10
+3310
+2110
+3110
+1E10
+0070
+FF90
+0410
 0000
 0FF0
 0410
@@ -123723,1367 +127044,1435 @@
 07F0
 0400
 ENDCHAR
-STARTCHAR CD6D
-ENCODING 52589
+STARTCHAR uniC715
+ENCODING 50965
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
 1E10
-0010
-7F10
-0210
-0C10
-3790
-C4F0
+3110
+2110
+2110
+1E10
+00F0
 FF10
-0C20
-0420
-07E0
-0420
-0420
-07E0
-0420
+0410
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR CD6F
-ENCODING 52591
+STARTCHAR uniC717
+ENCODING 50967
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0030
+0020
 0010
+0C10
+3310
+2110
+3110
 1E10
-0710
-3E10
-0F90
-3C10
-C4F0
-FF10
-0010
-0180
+01D0
+FE10
+0510
+0480
 0180
 0240
 0430
-0808
-1000
+1808
 ENDCHAR
-STARTCHAR CD71
-ENCODING 52593
+STARTCHAR uniC719
+ENCODING 50969
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-1E10
-7F10
-0210
 0C10
-33D0
-C410
-04F0
-FB10
-03D0
+3310
+2110
+3110
+1E10
+00D0
+FF10
+0410
+0080
+0340
 0420
 0420
-0620
+0660
 03C0
 ENDCHAR
-STARTCHAR CD78
-ENCODING 52600
+STARTCHAR uniC720
+ENCODING 50976
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 12 2 0
+BBX 14 15 2 -3
 BITMAP
-0780
-0000
+0200
+0D80
+1040
+1040
+18C0
+0F80
 0000
-3FE0
-00C0
-0180
-0380
-0C78
-70C0
-0840
-0848
 FFFC
+4880
+0880
+0880
+0880
+0880
+0880
+0080
 ENDCHAR
-STARTCHAR CD88
-ENCODING 52616
+STARTCHAR uniC721
+ENCODING 50977
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 13 14 2 -2
 BITMAP
-03C0
-1FE0
+0200
+0D80
+1040
+1040
+18C0
+0F80
+0008
+FFF0
+0880
+0FC0
+1040
 0040
-0180
-0678
-38C0
-0440
-FFFE
-2000
-1FE0
-0820
-0820
-0840
-0FE0
-0800
+0040
+0040
 ENDCHAR
-STARTCHAR CD94
-ENCODING 52628
+STARTCHAR uniC724
+ENCODING 50980
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-03C0
-3FE0
-00C0
-0180
-0678
-3800
-0004
-FFFE
-0100
-0100
-0100
-0100
-0100
-0100
+0200
+0D80
+1040
+1040
+18C0
+0F80
+001C
+FFE4
+0840
+0840
+3040
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR CD95
-ENCODING 52629
+STARTCHAR uniC728
+ENCODING 50984
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-0380
-1FF0
-0040
-0180
-0E78
-7000
+0200
+0D80
+1040
+1040
+18C0
+0F80
 0000
-FFFE
-0100
+FFFC
+0880
+0880
+3FC0
+0040
+3FC0
+1000
 1FE0
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR CD98
-ENCODING 52632
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-0780
-3FE0
-00C0
-0100
-06F8
-3800
-000C
-FFFE
-0100
-0100
-1900
-0900
-0810
-0FF8
 ENDCHAR
-STARTCHAR CD9C
-ENCODING 52636
+STARTCHAR uniC730
+ENCODING 50992
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 16 2 -3
 BITMAP
-0780
-3FE0
-00C0
-0100
-0EF8
-7004
-FFFE
-0100
-0100
-1FE0
-0020
-1FE0
-0800
-0FF0
+0200
+0F80
+18C0
+1040
+1040
+0880
+0700
+FFFC
+0880
+0880
+3FC0
+1040
+1080
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR CDA4
-ENCODING 52644
+STARTCHAR uniC731
+ENCODING 50993
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 16 1 -3
 BITMAP
-0780
-0000
-3FE0
-0040
-0180
-0678
-3804
-FFFE
 0100
-0100
-0FE0
-0820
+07C0
+0860
 0820
+0840
+06C0
+0104
+FFFA
+0440
+1840
 0820
 0FE0
-0800
-ENDCHAR
-STARTCHAR CDA5
-ENCODING 52645
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-0380
-3FE0
-0040
-0180
-0E7C
-7000
-FFFE
-0100
-1920
-0920
-0FE0
 0820
 0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR CDA7
-ENCODING 52647
+STARTCHAR uniC733
+ENCODING 50995
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -3
+BBX 14 15 2 -2
 BITMAP
-0780
-3FE0
-0040
-0180
-0EFC
-7000
-0004
-FFF8
-0100
-0100
-0100
-0380
-0660
-0810
-3000
+0200
+0F80
+18C0
+1040
+1040
+0880
+0700
+FFFC
+0840
+0840
+0A40
+0240
+0580
+0860
+3030
 ENDCHAR
-STARTCHAR CDA9
-ENCODING 52649
+STARTCHAR uniC735
+ENCODING 50997
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 14 2 -2
 BITMAP
-0380
-1FE0
-0040
-0180
-0678
-3800
-FFFE
-0100
-0100
-07C0
-0C60
-0820
-0C60
-07C0
+0200
+0D80
+1040
+1040
+18C0
+0780
+7800
+9FFC
+1040
+0700
+18C0
+1040
+18C0
+0F80
 ENDCHAR
-STARTCHAR CDB0
-ENCODING 52656
+STARTCHAR uniC737
+ENCODING 50999
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 15 16 1 -3
 BITMAP
-0060
-3C20
-0020
-FF20
-0420
-1820
-67A0
-8020
-0720
-F820
-09E0
+0100
+07C0
 0820
 0820
 0820
-0020
+06C0
+0100
+FFFE
+0440
+0240
+0180
+1FF8
+0100
+03C0
+0430
+3800
 ENDCHAR
-STARTCHAR CDC4
-ENCODING 52676
+STARTCHAR uniC73C
+ENCODING 51004
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 15 11 1 0
 BITMAP
-0060
-0020
-1C20
-FE20
-0420
-1C20
-6220
-8F20
-F9E0
-0000
-0840
+0100
+0EC0
+1020
+1020
+1020
 0840
-18C0
-2530
-4210
-ENDCHAR
-STARTCHAR CDCC
-ENCODING 52684
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-0060
-0320
-3920
-0120
-FD20
-1920
-3120
-4D20
-8D20
-F120
-1F20
-1120
-1120
-1120
-0020
+0780
+0000
+0000
+0000
+FFFE
 ENDCHAR
-STARTCHAR CDD0
-ENCODING 52688
+STARTCHAR uniC73D
+ENCODING 51005
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -3
 BITMAP
-0020
-01B0
-0090
-1C90
-7E90
-0C90
-1E90
-6290
-FC90
-1390
-1090
-0C90
-0410
-0400
-07F8
+0200
+1D80
+1040
+1040
+18C0
+0780
+0000
+FFFC
+0000
+7FC0
+0040
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR CDE8
-ENCODING 52712
+STARTCHAR uniC740
+ENCODING 51008
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0E10
-0010
-7F90
-0310
-0410
-1BD0
-6010
-0050
-FF90
-0410
-0410
-0410
-0410
-0010
+0100
+06C0
+0820
+0820
+0820
+07C0
+0004
+FFFE
+2000
+0000
+1800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CDEC
-ENCODING 52716
+STARTCHAR uniC744
+ENCODING 51012
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 14 1 -2
 BITMAP
-0030
-1E10
-0010
-7F10
-0210
-0C10
-13F0
-FF10
-6410
-0410
-0010
-0C00
-0400
-0400
-07F8
+0100
+06C0
+0820
+0820
+0C60
+07C0
+FE00
+01FC
+0000
+1FE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR CDF0
-ENCODING 52720
+STARTCHAR uniC74A
+ENCODING 51018
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0018
-0F08
-0008
-3F88
-0308
-0608
-19D8
-E7A8
-3A08
+0200
+0F80
+10C0
+1040
+1040
+0D80
+0208
+FFFC
 0000
-0FF8
-0010
-07F8
-0400
-03FC
+0270
+7DC0
+0920
+7D20
+2140
+3BF8
 ENDCHAR
-STARTCHAR CDF8
-ENCODING 52728
+STARTCHAR uniC74C
+ENCODING 51020
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0E10
-0010
-7F10
-0210
-0E10
-11D0
-E070
-8F90
-7400
+0100
+0EC0
+0820
+0820
+0C60
+07C0
+0000
+FFFE
+0000
 0FF0
-0410
-0420
-0420
-07F0
-0400
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR CDF9
-ENCODING 52729
+STARTCHAR uniC74D
+ENCODING 51021
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 15 2 -3
 BITMAP
-0030
-0E10
-0010
-7F10
-0210
-0C10
-13D0
-E070
-9F90
-6430
-0410
-07F0
-0410
-0410
-07F0
-0410
+0200
+0D80
+1040
+1040
+18C0
+0F80
+0000
+FFFC
+1840
+0840
+0FC0
+0840
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR CDFB
-ENCODING 52731
+STARTCHAR uniC74F
+ENCODING 51023
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 15 15 1 -2
 BITMAP
-0018
-0F08
-0008
-3F88
-0308
-0608
-19D8
-EFA8
-3208
-0288
-0040
-00A0
-0110
-0208
-0C04
+0100
+0300
+04C0
+0820
+0820
+0C60
+03C0
+0004
+FFFE
+0000
+0100
+0100
+02C0
+0430
+1810
 ENDCHAR
-STARTCHAR CDFD
-ENCODING 52733
+STARTCHAR uniC751
+ENCODING 51025
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0020
-1E10
-0010
-7F10
-0610
-0C10
-33B0
-DF50
-E810
-0890
-0360
-0410
-0410
-0630
-03E0
+0100
+06C0
+0820
+0820
+0C60
+07C0
+0004
+FFFE
+2100
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR CE04
-ENCODING 52740
+STARTCHAR uniC752
+ENCODING 51026
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 16 1 -3
 BITMAP
-0780
+0100
+07C0
+0860
+0820
+0820
+0440
+0380
+FFFE
 0000
-3FE0
-00C0
+0000
+3FF8
+0100
 0300
-0CF8
-7008
-FFFC
-4840
-0840
-0840
-0840
-0840
-0840
+06C0
+0C30
+3018
 ENDCHAR
-STARTCHAR CE08
-ENCODING 52744
+STARTCHAR uniC753
+ENCODING 51027
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -2
 BITMAP
-0780
-3FE0
-00C0
 0100
-06F8
-3800
+06C0
+0840
+0820
+0C40
+0780
 0000
 FFFE
-0840
-0840
-3840
-1040
-1000
-0FF0
+0000
+03C0
+0038
+1FC0
+0380
+0660
+1810
 ENDCHAR
-STARTCHAR CE0C
-ENCODING 52748
+STARTCHAR uniC754
+ENCODING 51028
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 13 14 2 -2
 BITMAP
-0700
+0200
+0D80
+1040
+1040
+1880
+0F00
+0000
+FFF8
+0000
+1FE0
+0060
 7FC0
-0080
-0300
-1CF0
-E008
-FFF4
-0880
-0880
-3FC0
 0040
-3FC0
-1000
-1000
-1FF0
+0080
 ENDCHAR
-STARTCHAR CE14
-ENCODING 52756
+STARTCHAR uniC755
+ENCODING 51029
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 14 14 1 -2
 BITMAP
-0380
-3FE0
-0040
-0180
-0E78
-7000
-803E
-7FE0
-0400
-0FE0
+0100
+06C0
 0820
 0820
-0840
+0C40
+0780
+FC00
+03FC
+0FE0
+0800
+0800
 0FE0
 0800
+0FF0
 ENDCHAR
-STARTCHAR CE19
-ENCODING 52761
+STARTCHAR uniC756
+ENCODING 51030
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0380
-3FE0
-0040
-0180
-0E78
-7000
-803E
-7FE0
-0520
+0100
 06C0
 0820
 0820
 0C60
 07C0
+0000
+FFFE
+0000
+1FE0
+0440
+0240
+0080
+3FF8
 ENDCHAR
-STARTCHAR CE20
-ENCODING 52768
+STARTCHAR uniC757
+ENCODING 51031
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 15 1 -2
 BITMAP
-07C0
-0000
-3FF0
-0060
-00C0
 0100
-06F8
-3800
-0000
+06C0
+0820
+0820
+0C40
+07C0
 0000
 FFFE
+0000
+03C0
+1FF8
+0100
+06C0
+0640
+03C0
 ENDCHAR
-STARTCHAR CE21
-ENCODING 52769
+STARTCHAR uniC758
+ENCODING 51032
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 15 2 -2
 BITMAP
-0380
-1FF0
-0060
-0180
-0678
-3800
-0000
-FFFE
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+0030
+0010
+0810
+3E10
+4110
+4110
+4110
+3E10
+0010
+01D0
+FE10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR CE24
-ENCODING 52772
+STARTCHAR uniC75C
+ENCODING 51036
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-0780
-0000
-3FE0
-0080
-0778
-3804
-83FE
-FF00
-2000
-0000
-1800
-0800
-0810
-0FF8
+0030
+0410
+1A10
+2110
+2110
+3310
+1E10
+0010
+01F0
+FE10
+0010
+0C10
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR CE28
-ENCODING 52776
+STARTCHAR uniC760
+ENCODING 51040
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 3 -2
 BITMAP
-0380
-3FE0
-0040
-0180
-0E78
-7004
-FFFE
-2000
-0000
+0060
+0020
+1C20
+6220
+4220
+4620
+3C20
+03E0
+FC20
 1FE0
 0020
+0040
 1FE0
 0800
 0FF0
-ENDCHAR
-STARTCHAR CE30
-ENCODING 52784
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -3
-BITMAP
-0700
-7FC0
-0080
-0300
-0CF0
-F000
-FFFC
-0000
-0000
-3FC0
-1040
-1040
-1080
-1FC0
-1000
 ENDCHAR
-STARTCHAR CE31
-ENCODING 52785
+STARTCHAR uniC768
+ENCODING 51048
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 11 15 3 -2
 BITMAP
-0380
-0000
-3FE0
-0040
-0180
-0EFC
-7000
-FFFE
-0000
-1820
-0820
-0FE0
-0820
+0060
+0020
+3820
+4620
+4220
+4620
+3C20
+03E0
+FC20
+1FE0
 0820
+0840
+0840
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR CE33
-ENCODING 52787
+STARTCHAR uniC76B
+ENCODING 51051
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 16 3 -3
 BITMAP
-0F00
-7FC0
-0080
+0060
+0020
+1820
+6620
+4220
+4220
+3C20
+0020
+03E0
+FE20
+0320
 0300
-0CF0
-7000
-0000
-FFFC
+04C0
+1820
+2010
 4000
-0200
-0200
-0580
-0860
-3010
-ENDCHAR
-STARTCHAR CE35
-ENCODING 52789
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-0780
-3FF0
-0040
-0180
-0E78
-7000
-0004
-FFFE
-0100
-07C0
-0C60
-0820
-0C60
-07C0
 ENDCHAR
-STARTCHAR CE58
-ENCODING 52824
+STARTCHAR uniC774
+ENCODING 51060
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-1E10
 0010
-7F10
-0310
-0610
-0C10
-1A10
-2110
-4090
-8010
+0010
+7C10
+C610
+8210
+8210
+C610
+3C10
 0010
 0010
 0010
+0010
+0010
 ENDCHAR
-STARTCHAR CE59
-ENCODING 52825
+STARTCHAR uniC775
+ENCODING 51061
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-1E10
-0010
+0060
 0010
-7F10
-0210
-0410
-0A10
-3190
-7FE0
-9020
+1010
+6C10
+8210
+8210
+C610
+7C10
+0000
+01E0
+1E20
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR CE5C
-ENCODING 52828
+STARTCHAR uniC778
+ENCODING 51064
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
+0030
 0010
-1E10
+1010
+3810
+C410
+8210
+8210
+C610
+3C10
 0010
-7F10
-0210
-0410
-0C10
-1210
-6110
-9010
-0810
+3010
 0800
 0800
-07F8
+0800
+0FF0
 ENDCHAR
-STARTCHAR CE5F
-ENCODING 52831
+STARTCHAR uniC77C
+ENCODING 51068
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-3C20
+0030
+1010
+6C10
+8210
+8210
+C610
+3C10
+0010
+1FF0
 0020
-FE20
-0420
-0820
-1420
-6320
-8020
-0040
-1FC0
-1000
-1000
-1000
-1FE0
+0020
+1FF0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CE60
-ENCODING 52832
+STARTCHAR uniC77D
+ENCODING 51069
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-3C20
-0020
-FE20
+0030
+0010
+0810
+7410
+8210
+8210
+C610
+7C10
+0000
+7DE0
 0420
-0820
-1420
-6220
-8000
-3FC0
-0040
-3FC0
-1000
-1000
-1FE0
+4C20
+3020
+2220
+3C20
 ENDCHAR
-STARTCHAR CE61
-ENCODING 52833
+STARTCHAR uniC77E
+ENCODING 51070
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0F08
-0008
-3F88
-0188
-0308
-0508
-08C8
-3048
-C000
-1EF0
-0210
-1C10
-1110
-1E10
+0030
+0010
+1010
+6C10
+8210
+8210
+C610
+7C10
+0000
+7FF0
+0520
+6D20
+3120
+23E0
+3D00
 ENDCHAR
-STARTCHAR CE68
-ENCODING 52840
+STARTCHAR uniC783
+ENCODING 51075
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0060
+1020
+F820
+8420
+8420
+8420
+7820
+0000
+F9C0
+0FF0
+9880
+6360
+4620
+7A20
+01C0
+ENDCHAR
+STARTCHAR uniC784
+ENCODING 51076
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-1E10
-0010
+1010
+1010
+6C10
+8210
+8210
+C610
+3C10
 0010
-7F10
-0210
-0410
-0A10
-1110
-6080
-8FF0
-0410
-0410
-0410
-07F0
-0400
+0000
+1FE0
+0820
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR CE69
-ENCODING 52841
+STARTCHAR uniC785
+ENCODING 51077
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-1E10
-0010
-0010
-7F10
-0210
-0410
-0A10
-1180
+1010
 6C10
-8410
-07F0
-0410
-0410
-07F0
-0410
+8210
+8210
+C610
+3C10
+0010
+1810
+0810
+0FF0
+0810
+0810
+0FF0
+0810
 ENDCHAR
-STARTCHAR CE6B
-ENCODING 52843
+STARTCHAR uniC787
+ENCODING 51079
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
 1010
-0E10
-7F10
-0210
-0410
-0A10
-1190
-6090
-8110
+1010
+6C10
+8210
+8210
+C610
+3C10
+0010
+0310
 0180
 0100
-06C0
-0C30
+02C0
+0430
+1810
+ENDCHAR
+STARTCHAR uniC788
+ENCODING 51080
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0060
+0020
+1020
+6C20
+8220
+8220
+C420
+7820
+0000
+1040
+0840
+18C0
+24A0
+4110
+8600
+ENDCHAR
+STARTCHAR uniC789
+ENCODING 51081
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
 1010
-2000
+3810
+C410
+8210
+8210
+4610
+3810
+0010
+0100
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR CE6D
-ENCODING 52845
+STARTCHAR uniC78A
+ENCODING 51082
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
+1010
+7C10
+C610
+8210
+8210
+4410
+3810
+0030
+3FC0
+0100
+0280
+0460
+1830
+6000
+ENDCHAR
+STARTCHAR uniC78E
+ENCODING 51086
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
+BITMAP
+0030
+1010
+7C10
+8210
+8210
+8210
+4410
+3810
+0000
+1FE0
+0840
+0440
+0480
+3FF8
+ENDCHAR
+STARTCHAR uniC790
+ENCODING 51088
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0060
 0010
-1E10
 0010
 7F10
+0110
 0210
-0410
-0A10
+0610
+0416
+0A18
 1190
 6090
-8360
-0420
-0420
-0660
-03C0
+8010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR CE74
-ENCODING 52852
+STARTCHAR uniC791
+ENCODING 51089
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-00C0
-0020
+0080
+0060
 0020
 7F20
-0320
 0220
-0620
-FC2C
-0830
-0820
-1020
-2020
-4020
+0420
+083C
+1620
+2120
+C020
+3FE0
+0020
+0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR CE75
-ENCODING 52853
+STARTCHAR uniC794
+ENCODING 51092
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 15 2 -2
 BITMAP
+0080
 0060
-0010
-7F90
-0110
-0210
-FE16
-0418
-0810
-1010
-2000
-5FF0
-0010
-0010
-0010
-0010
-0010
+0020
+7F20
+0320
+0220
+042C
+0B30
+11A0
+60A0
+8820
+0420
+0400
+0408
+07FC
 ENDCHAR
-STARTCHAR CE78
-ENCODING 52856
+STARTCHAR uniC796
+ENCODING 51094
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -2
 BITMAP
+0080
 0060
-0010
-0010
-3F90
-0110
-0110
-FE10
-041E
-0410
-0810
-1C10
-2410
-0400
-0408
-03FC
+7E20
+0620
+0420
+0C3C
+1320
+6120
+81F0
+6F80
+20C0
+2320
+2620
+3B20
+01C0
 ENDCHAR
-STARTCHAR CE7C
-ENCODING 52860
+STARTCHAR uniC797
+ENCODING 51095
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-00C0
+0060
 0020
 7F20
 0220
 0420
-FC20
-0838
-1020
-2000
-5FE0
+083C
+1620
+2120
+C020
 0020
 1FE0
 0800
 0800
-0FF8
+0810
+0FF0
 ENDCHAR
-STARTCHAR CE84
-ENCODING 52868
+STARTCHAR uniC798
+ENCODING 51096
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 15 2 -2
 BITMAP
+00C0
+0020
+7E20
+0620
+0420
+0C20
+133C
+6120
+8020
+1FE0
+0040
+1FE0
+0800
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniC79A
+ENCODING 51098
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
 0060
 0020
 7F20
-0220
 0220
-FC2C
-0830
-1020
-2020
-4000
-8FE0
+0420
+083C
+1620
+2120
+C000
+3DF0
+0520
+6D20
+3120
+23E0
+3D00
+ENDCHAR
+STARTCHAR uniC7A0
+ENCODING 51104
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 2 -3
+BITMAP
+00C0
+0020
+FE20
+0620
+0420
+0820
+1638
+2120
+C020
+0000
+1FE0
 0820
 0840
 0840
 0FE0
 0800
 ENDCHAR
-STARTCHAR CE85
-ENCODING 52869
+STARTCHAR uniC7A1
+ENCODING 51105
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 15 3 -3
+BITMAP
+00C0
+0040
+FE40
+0440
+0840
+1878
+3440
+4240
+B040
+1040
+1FC0
+1040
+1040
+1FC0
+1040
+ENDCHAR
+STARTCHAR uniC7A3
+ENCODING 51107
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
 00C0
 0020
-7F20
-0220
+FE20
 0620
-FC20
-083C
-1020
-2000
-5820
-0820
-0FE0
-0820
-0820
-0FE0
+0420
 0820
+163C
+6120
+8020
+0120
+01A0
+0380
+0240
+0C30
+1008
 ENDCHAR
-STARTCHAR CE87
-ENCODING 52871
+STARTCHAR uniC7A4
+ENCODING 51108
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0080
-0060
+00C0
+0020
 7F20
 0220
-0620
-FC20
-083C
-1020
-2020
-C320
-0120
-0300
-06C0
-0830
-1010
-2000
+0420
+0C24
+1338
+2120
+C020
+0860
+0C20
+0840
+1670
+2298
+4108
 ENDCHAR
-STARTCHAR CE89
-ENCODING 52873
+STARTCHAR uniC7A5
+ENCODING 51109
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-00C0
+0060
 0020
 7F20
 0220
-0620
-FC24
-0838
-1020
+0420
+083C
+1620
 2120
-4100
-86C0
-0820
-0820
-0C60
+C020
+0080
+0340
+0420
+0420
+0660
 03C0
 ENDCHAR
-STARTCHAR CE90
-ENCODING 52880
+STARTCHAR uniC7A6
+ENCODING 51110
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0018
-00C8
-0048
-7F48
-0248
-0248
-9C48
-6478
-0848
-1048
-2048
-4048
-0048
-0048
-0008
+0080
+0060
+7F20
+0220
+0420
+0C2C
+1330
+2120
+C000
+1FF0
+0100
+0100
+06C0
+0830
+1010
 ENDCHAR
-STARTCHAR CE91
-ENCODING 52881
+STARTCHAR uniC7AC
+ENCODING 51116
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 16 2 -3
 BITMAP
+0060
 0010
-00C8
-0048
-3E48
-0248
-BC48
-4478
-0848
-1048
-2048
-0FF8
-0008
-0008
-0008
-0008
-0008
+0190
+0090
+FC90
+0490
+0890
+0890
+18F0
+2490
+4690
+8090
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR CE94
-ENCODING 52884
+STARTCHAR uniC7AD
+ENCODING 51117
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0020
+0030
 0110
 0090
 FC90
-0490
+0C90
+0890
+10F0
+2C90
+4690
+8090
+1FF0
+0010
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniC7B0
+ENCODING 51120
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0010
+0090
+0090
+FC90
+0C90
 0890
-F890
 10F0
-2090
-4090
+2C90
+4290
 8090
 1890
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR CE98
-ENCODING 52888
+STARTCHAR uniC7B4
+ENCODING 51124
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0190
 0090
-7E90
-0490
-0490
-F8F0
-1090
-1090
-2770
-4020
-0FF0
-0400
-0400
-07F8
-ENDCHAR
-STARTCHAR CEA0
-ENCODING 52896
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0070
-0190
 0090
-7E90
-0490
-0490
-F8F0
+7C90
 0890
-1090
-2090
-4FF0
-0410
-0410
-0420
-07F0
-0400
+0890
+18F0
+2490
+C290
+0000
+1FE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR CEA1
-ENCODING 52897
+STARTCHAR uniC7BC
+ENCODING 51132
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 16 1 -3
 BITMAP
-0070
-0110
-0090
-FE90
-0490
-0490
-F8F0
-1090
-1090
-28B0
-4410
-07F0
-0410
-07F0
-0410
+0018
+00C8
+0048
+3E48
+0648
+0448
+0C78
+1248
+2148
+C048
+07F8
+0208
+0210
+0210
+03F8
+0200
 ENDCHAR
-STARTCHAR CEA3
-ENCODING 52899
+STARTCHAR uniC7BD
+ENCODING 51133
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 1 -2
 BITMAP
-0010
-00C8
+0018
+0048
 0048
 3E48
-0248
-FC48
+0648
 0478
-0848
-1048
-2088
-0040
-00C0
-0120
-0218
-0C0C
+0C48
+1348
+2100
+C608
+0208
+03F8
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR CEA4
-ENCODING 52900
+STARTCHAR uniC7BF
+ENCODING 51135
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
@@ -125091,153 +128480,308 @@
 0030
 0190
 0090
-7E90
-0490
-F890
-08F0
-1090
-2090
-4090
+7C90
+0890
+0890
+18F0
+2690
+C290
+0190
+0190
+0180
+0240
 0430
-0420
-0C60
-1298
-2108
+1808
 ENDCHAR
-STARTCHAR CEA5
-ENCODING 52901
+STARTCHAR uniC7C0
+ENCODING 51136
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 14 15 1 -2
 BITMAP
-0130
-0090
-0090
-7C90
-0490
-F8F0
-0890
-1090
-2090
-4360
-0410
-0410
+0030
+0098
+0048
+3E48
+0648
+0448
+0C78
+1348
+6148
+8258
+0210
 0630
-03E0
+0928
+1044
+2084
 ENDCHAR
-STARTCHAR CEAC
-ENCODING 52908
+STARTCHAR uniC7C1
+ENCODING 51137
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-0020
-0020
-7F20
-0220
-023C
-0C20
-F420
-0820
-083C
-1020
-2020
-4020
-0020
-0020
+0018
+00C8
+0048
+7E48
+0648
+0448
+0C78
+1248
+2148
+C048
+01A0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR CEAD
-ENCODING 52909
+STARTCHAR uniC7C8
+ENCODING 51144
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
 0010
-3F10
+7F90
+0110
 021E
-8E10
-7410
-0816
-1018
-2000
-5FF0
+0210
+0410
+0B10
+109E
+2050
+C010
 0010
 0010
 0010
+ENDCHAR
+STARTCHAR uniC7C9
+ENCODING 51145
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+0020
+7F20
+0224
+0438
+0820
+1620
+213C
+C020
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniC7CC
+ENCODING 51148
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+0030
 0010
 0010
+3F90
+011E
+0210
+0610
+0910
+1096
+2058
+C810
+0410
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR CEC1
-ENCODING 52929
+STARTCHAR uniC7CE
+ENCODING 51150
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-7F20
+7E20
+0620
+043C
+0820
+1620
+213C
+C020
+01E0
+67F8
+20C0
+2120
+2510
+3920
+ENDCHAR
+STARTCHAR uniC7D0
+ENCODING 51152
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+7E20
+062C
+0430
+0C20
+1324
+6138
+8000
+1FE0
+0020
+1FE0
+0800
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniC7D8
+ENCODING 51160
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+0020
+FE20
 0224
-0638
-FC20
+0438
+0C20
+1220
+213C
+C020
+0000
+1FE0
 0820
-103C
-2020
-4100
-86C0
+0840
+0840
+0FE0
+0800
+ENDCHAR
+STARTCHAR uniC7DD
+ENCODING 51165
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+7F20
+0220
+0438
+0820
+1620
+212C
+C030
+0100
+06C0
 0820
 0820
 0C60
 03C0
 ENDCHAR
-STARTCHAR CEE4
-ENCODING 52964
+STARTCHAR uniC7E4
+ENCODING 51172
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
+0190
+0090
+0090
+FC90
+04F0
+0890
+0890
+1890
+24F0
+4490
+8090
+0090
+0090
 0010
-7F10
-0210
-0210
-3C10
-44F0
+ENDCHAR
+STARTCHAR uniC7E8
+ENCODING 51176
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -1
+BITMAP
+0030
+0190
+0090
+0C90
+34F0
+0890
+1890
+1490
+66F0
+9A90
+0890
 0810
-1010
-2010
-4010
-8010
-0010
+0800
+07F8
+ENDCHAR
+STARTCHAR uniC7EC
+ENCODING 51180
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0020
+0098
+0048
+3E48
+0478
+0C48
+0C48
+1378
+6148
+8FF8
+0008
 0010
+0FF8
+0400
+07FC
 ENDCHAR
-STARTCHAR CEE5
-ENCODING 52965
+STARTCHAR uniC800
+ENCODING 51200
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
 0018
 0008
-3F88
-0108
+0008
+7F88
 0108
-FEF8
-0608
-0408
-0808
-3FF8
+0308
+02F8
 0408
-0008
+0A08
+1188
+2088
+C008
 0008
 0008
 0008
 ENDCHAR
-STARTCHAR CEE8
-ENCODING 52968
+STARTCHAR uniC801
+ENCODING 51201
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
@@ -125246,101 +128790,122 @@
 0010
 7F10
 0210
-0610
-FC30
-08D0
-0810
-1010
-2010
-C010
-1800
-0800
-0800
-0FF0
+0410
+08F0
+1610
+2310
+4110
+BFE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR CEEB
-ENCODING 52971
+STARTCHAR uniC804
+ENCODING 51204
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0008
+0008
+3F88
+0108
+02F8
+0608
+0A08
+1108
+2088
+C808
+0408
+0400
+0400
+07FC
+ENDCHAR
+STARTCHAR uniC808
+ENCODING 51208
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0210
-0210
-FCF0
+7E10
+0610
+05F0
 0810
-1810
-2010
-4020
-0FF0
-0800
+1610
+6310
+8100
+1FE0
+0020
+1FE0
 0800
 0800
-07F0
+0FF0
 ENDCHAR
-STARTCHAR CEEC
-ENCODING 52972
+STARTCHAR uniC80A
+ENCODING 51210
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0310
+7E10
 0210
-FCF0
-0410
+05F0
 0810
-1000
-7FE0
-8020
-1FE0
-0800
-0800
-0FF0
+1610
+6310
+8100
+7FF0
+0530
+6D30
+3130
+23F0
+3D00
 ENDCHAR
-STARTCHAR CEF4
-ENCODING 52980
+STARTCHAR uniC810
+ENCODING 51216
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 11 15 3 -2
 BITMAP
-0018
-0008
-7F08
-0108
-0208
-FEF8
-0408
-0808
-1008
-6000
-87F0
-0410
-0410
+0060
+0020
+FE20
 0420
-07F0
-0400
+0820
+11E0
+2820
+4620
+8220
+0000
+1FC0
+1040
+1040
+1FC0
+1000
 ENDCHAR
-STARTCHAR CEF5
-ENCODING 52981
+STARTCHAR uniC811
+ENCODING 51217
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
 0010
-7F10
-0210
+FF10
 0210
-FCF0
-0810
-1810
-2000
-4C10
+0410
+08F0
+1410
+2310
+4100
+8C10
 0410
 07F0
 0410
@@ -125348,2552 +128913,2461 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR CEF7
-ENCODING 52983
+STARTCHAR uniC813
+ENCODING 51219
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0030
+0020
 0010
 7F10
 0210
-0210
-FDF0
-0810
-1810
-2010
-4190
-0080
-0180
-0260
 0410
-1808
+08F0
+1610
+6310
+8010
+0110
+0190
+0180
+0240
+0C30
+1008
 ENDCHAR
-STARTCHAR CEF8
-ENCODING 52984
+STARTCHAR uniC815
+ENCODING 51221
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 1 -2
 BITMAP
 0030
 0010
-7F10
-0310
+7F90
+0110
 0210
-FCF0
-0810
-1010
-2000
-4430
-0420
-0C20
-1250
-2088
-4100
+04F0
+0A10
+1110
+2090
+C040
+01A0
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR CEF9
-ENCODING 52985
+STARTCHAR uniC816
+ENCODING 51222
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0210
+7E10
 0210
-FCF0
-0810
-1010
-2010
-4090
-0340
-0420
-0420
-0660
-03C0
+0410
+08F0
+1610
+2310
+4110
+BFF0
+0100
+0100
+02C0
+0430
+1810
 ENDCHAR
-STARTCHAR CF00
-ENCODING 52992
+STARTCHAR uniC81C
+ENCODING 51228
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0040
-01B0
+0030
+0190
 0090
-FE90
-0490
+FC90
 0490
+0890
+1B90
 1890
-EF90
-1090
-2090
-2090
-C090
+2490
+4490
+8090
 0090
 0090
 0010
 0010
 ENDCHAR
-STARTCHAR CF01
-ENCODING 52993
+STARTCHAR uniC81D
+ENCODING 51229
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0020
 0030
-0190
-FC90
-0490
+0110
+0090
+7C90
 0890
-FF90
 1090
-2090
-4090
-9FF0
-0810
+3B90
+4490
+8090
+0080
+1FF0
+0010
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR CF04
-ENCODING 52996
+STARTCHAR uniC820
+ENCODING 51232
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0060
-01B0
+0030
+0310
 0090
-7E90
-0490
-0490
-FF90
-1890
-1090
-2090
-7090
+FC90
+0C90
 0890
+1790
+2890
+4490
+8090
+0090
+0810
 0800
 0800
 07F8
 ENDCHAR
-STARTCHAR CF08
-ENCODING 53000
+STARTCHAR uniC824
+ENCODING 51236
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0010
-0098
-0048
-7E48
-0648
-0448
-FFC8
-0848
+0030
+0110
+0090
+FC90
+0890
+0890
+1390
+2890
+4490
+9FF0
+0020
 1FF0
-2010
-4010
-0FF0
-0400
+0C00
 0400
 07F8
 ENDCHAR
-STARTCHAR CF10
-ENCODING 53008
+STARTCHAR uniC82C
+ENCODING 51244
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0020
 0030
-0190
-FC90
-0490
+0110
+0090
+7C90
 0890
-FF90
 1090
-2090
-4090
-87F0
+2B90
+4490
+8090
+0080
+07F0
 0410
-0420
+0410
 0420
 07F0
+0400
 ENDCHAR
-STARTCHAR CF11
-ENCODING 53009
+STARTCHAR uniC82D
+ENCODING 51245
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 16 1 -3
 BITMAP
-0020
-0030
-0190
-FC90
-0490
-0890
-FF90
-1090
-2090
-4890
-8410
-07F0
-0410
-07F0
-0410
+0018
+0088
+0048
+3E48
+0448
+0848
+19C8
+1648
+6248
+8448
+0208
+03F8
+0208
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR CF13
-ENCODING 53011
+STARTCHAR uniC82F
+ENCODING 51247
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0020
 0030
+0190
 0090
-FC90
-0490
+3C90
+0C90
 0890
-FF90
-1090
-2090
-4190
-8100
-0380
+1B90
+2490
+4490
+8110
+0180
+0180
 0240
-0C30
-1008
+0430
+1808
 ENDCHAR
-STARTCHAR CF15
-ENCODING 53013
+STARTCHAR uniC831
+ENCODING 51249
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0020
 0030
 0190
-FC90
-0490
+0090
+7C90
 0890
-FF90
 1090
-2090
-4090
-8340
-0420
-0420
-0660
-03C0
-ENDCHAR
-STARTCHAR CF1C
-ENCODING 53020
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 16 3 -3
-BITMAP
-00C0
-0020
-0020
-FE20
-0220
-07E0
-1D20
-E820
-0820
-13E0
-2020
-4020
-8020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR CF20
-ENCODING 53024
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-7F10
-0110
-03F0
-FE10
+2B90
+4490
+8490
+0090
+0360
 0410
-0810
-11F0
-2010
-7810
-0810
-0800
-0800
-07F8
-ENDCHAR
-STARTCHAR CF24
-ENCODING 53028
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-7F10
-0110
-03F0
-FE10
 0410
-08F0
-1010
-2FF0
-C010
-0FF0
-0400
-0408
-07F8
+0630
+03E0
 ENDCHAR
-STARTCHAR CF2C
-ENCODING 53036
+STARTCHAR uniC838
+ENCODING 51256
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
-BITMAP
-0030
-0010
-7F10
-0170
-0290
-FE10
-0410
-09F0
-1010
-6010
-07F0
-0410
-0420
-0420
-07F0
-ENDCHAR
-STARTCHAR CF2D
-ENCODING 53037
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-00C0
-0020
-FE20
-0420
-07E0
-0C20
-F820
-1060
-23A0
-7020
-9020
-1FE0
-1020
-1FE0
-1020
-ENDCHAR
-STARTCHAR CF2F
-ENCODING 53039
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
 BITMAP
-0020
+0070
 0010
 0010
-7E10
-03F0
+FF10
+0210
+04F0
 0C10
-F410
 0810
-11F0
-2110
-C190
-0190
-0240
-0430
-1818
-ENDCHAR
-STARTCHAR CF30
-ENCODING 53040
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0020
-0010
-7F10
-0210
-03F0
-FE10
-0410
-09F0
-1010
-2860
-C420
-0C20
-1A50
-2198
-4108
-ENDCHAR
-STARTCHAR CF31
-ENCODING 53041
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
+15F0
+2210
+4310
+8010
 0010
-7F10
-01F0
-0290
-FC10
-0410
-08F0
-3010
-4090
-0360
-0410
-0410
-0630
-01C0
-ENDCHAR
-STARTCHAR CF38
-ENCODING 53048
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0060
-01B0
-0090
-FC90
-0490
-0490
-1B90
-E890
-1090
-2790
-2090
-C090
-0090
-0090
 0010
+0010
 ENDCHAR
-STARTCHAR CF54
-ENCODING 53076
+STARTCHAR uniC83C
+ENCODING 51260
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 10 2 1
+BBX 13 15 2 -2
 BITMAP
-3FF8
-0010
+0070
 0010
+7F10
+03F0
+0410
+0810
+1410
+22F0
+C210
 0010
-7FE0
-0020
-0220
-0200
-0200
-FFFC
+1010
+0800
+0800
+0800
+07F8
 ENDCHAR
-STARTCHAR CF55
-ENCODING 53077
+STARTCHAR uniC840
+ENCODING 51264
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-3FF0
+0030
 0010
-0020
-7FE0
-0220
-0240
-FFFC
-0000
-0000
+7F10
+02F0
+0410
+0810
+16F0
+6110
+8000
 1FE0
 0020
-0020
-0020
 0020
+0FE0
+0800
+0FF8
 ENDCHAR
-STARTCHAR CF58
-ENCODING 53080
+STARTCHAR uniC848
+ENCODING 51272
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 13 16 1 -3
 BITMAP
-1FF8
-0008
+0018
 0008
-3FF0
-0010
-0120
-0100
-FFFE
-3800
-0800
-0800
-0810
-0FF8
+3F08
+0378
+0208
+0408
+0A78
+1108
+6108
+87F8
+0208
+0210
+0210
+0210
+03F8
+0200
 ENDCHAR
-STARTCHAR CF5C
-ENCODING 53084
+STARTCHAR uniC849
+ENCODING 51273
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 16 1 -3
 BITMAP
-1FF8
 0018
-0010
-3FF0
-0310
-0104
-FFFE
-0000
-1FF0
-0020
-1FE0
-0800
-0800
-0FF8
+0008
+3F08
+0378
+0208
+0408
+0A78
+1108
+6100
+8408
+0208
+03F8
+0208
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR CF64
-ENCODING 53092
+STARTCHAR uniC84C
+ENCODING 51276
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-1FF8
-0008
+0030
 0010
-3FF0
-0110
-0104
-FFFE
-0000
-0000
-0FE0
-0820
+7E10
+02F0
+0410
+0810
+14F0
+2210
+C200
+1820
+0C20
 0820
-0FE0
-0800
+1650
+2298
+4108
 ENDCHAR
-STARTCHAR CF65
-ENCODING 53093
+STARTCHAR uniC84D
+ENCODING 51277
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 13 15 1 -2
 BITMAP
-1FF8
-0008
 0018
-3FF0
+0008
+3F88
+0178
+0208
+0608
+0A78
+1188
+2088
+C040
+01B0
+0208
+0208
 0110
-0104
-FFFE
-0000
-0C60
-0420
-07E0
-0420
-0420
-07E0
-0420
+00E0
 ENDCHAR
-STARTCHAR CF67
-ENCODING 53095
+STARTCHAR uniC854
+ENCODING 51284
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 16 1 -3
 BITMAP
-1FF8
-0010
-0030
-3FD0
 0020
-0100
-0100
-FFFE
-0200
-0100
-0380
-0260
-0C10
-3008
+0018
+00C8
+0048
+7E48
+07C8
+0448
+0C48
+0FC8
+1248
+2248
+C048
+0048
+0048
+0008
+0008
 ENDCHAR
-STARTCHAR CF69
-ENCODING 53097
+STARTCHAR uniC870
+ENCODING 51312
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 11 1 0
 BITMAP
-1FF8
-0018
-0010
 3FF0
-0110
-0120
-017E
-FF80
+0060
+00C0
+0180
+02C0
+0C3C
+3000
 0100
-07C0
-0C60
-0820
-0460
-03C0
+0100
+0100
+FFFE
 ENDCHAR
-STARTCHAR CF70
-ENCODING 53104
+STARTCHAR uniC871
+ENCODING 51313
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
+3FF0
 0060
+0180
+06F0
+180C
+E100
+0100
+FFFE
+0000
+3FE0
 0020
 0020
-7FA0
-0120
-0120
-0F20
-792C
-0A30
-08E0
-FF20
-4020
-0020
 0020
 0020
 ENDCHAR
-STARTCHAR CF71
-ENCODING 53105
+STARTCHAR uniC874
+ENCODING 51316
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 1 -3
+BBX 15 13 1 -1
 BITMAP
-0030
-0010
-3F90
-0090
-0090
-7F10
-051C
-05F0
-FA10
+3FF0
+0040
+0180
+06F8
+1804
+2100
+0104
+FFFE
 0000
-1FF0
-0810
-0010
-0010
-0010
-0010
+1800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CF74
-ENCODING 53108
+STARTCHAR uniC878
+ENCODING 51320
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0010
-3F90
-0090
-0090
-7F10
-0D16
-0878
-9F90
-6010
-0010
-0C10
-0400
-043C
-07C0
+3FF0
+0060
+0180
+06F8
+1904
+2100
+FFFE
+0000
+1FF0
+0020
+1FF0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR CF78
-ENCODING 53112
+STARTCHAR uniC87A
+ENCODING 51322
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -3
 BITMAP
+1FF0
 0060
-0020
-7F20
-0120
-0120
-7F20
-0A3C
-0FE0
-F020
+0180
+02C0
+1C3C
+2100
+0100
+FFFE
 0000
-1FE0
-0040
-1FE0
+1E80
+02F8
+3E90
+1090
+1670
 0800
-0FF0
 ENDCHAR
-STARTCHAR CF80
-ENCODING 53120
+STARTCHAR uniC880
+ENCODING 51328
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 15 1 -3
 BITMAP
+3FF0
 0060
-0020
-7F20
-0120
-0120
-7F20
-0A3C
-0FE0
-F020
+0080
+03F0
+0D0C
+3100
+C1FE
+FF00
 0000
 1FE0
 0820
-0840
+0820
 0840
 0FE0
 0800
 ENDCHAR
-STARTCHAR CF85
-ENCODING 53125
+STARTCHAR uniC881
+ENCODING 51329
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
+3FF0
 0060
-0020
-7FA0
-0120
-0120
-FF20
-0A3C
-09E0
-FE20
-00A0
-0340
-0420
-0420
-0660
+0080
 03C0
+1D3C
+2100
+017E
+FF80
+1820
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR CF8C
-ENCODING 53132
+STARTCHAR uniC883
+ENCODING 51331
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0060
-0110
-0090
-7E90
-0290
-0490
-FC90
-2490
-10F0
-1790
-E890
-0090
-0090
-0090
-0010
+3FE0
+00C0
+0300
+0580
+3878
+4200
+0200
+FFFC
+0000
+0200
+0600
+0D80
+1060
+6010
 ENDCHAR
-STARTCHAR CFA1
-ENCODING 53153
+STARTCHAR uniC885
+ENCODING 51333
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-0190
-0090
-7E90
-0290
-0C90
-7490
-11F0
-FE90
-0090
-0360
-0410
-0410
-0630
-03E0
+3FF0
+0040
+0180
+06F8
+1800
+2100
+0104
+FFFE
+0000
+03C0
+0460
+0C20
+0460
+03C0
 ENDCHAR
-STARTCHAR CFA8
-ENCODING 53160
+STARTCHAR uniC886
+ENCODING 51334
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0030
-0010
-7F90
-0190
-0190
-0710
-7910
-1910
+1FF0
+0060
+0180
+02C0
+1C3C
+2100
+0100
+FFFE
+0000
+1FF8
+0100
+0380
+0660
 0810
-08F0
-FF10
-0010
-0010
-0010
-0010
+3000
 ENDCHAR
-STARTCHAR CFB0
-ENCODING 53168
+STARTCHAR uniC887
+ENCODING 51335
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -1
+BBX 15 15 1 -3
 BITMAP
+3FF0
 0060
-0010
-7F90
-0190
-0110
-7F10
-0910
-09F0
-FE10
-1FF0
-0020
-1FF0
-0800
-0FF0
-ENDCHAR
-STARTCHAR CFC4
-ENCODING 53188
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 12 2 -1
-BITMAP
-0030
-7FF0
-0010
-0030
-0020
-FFE0
-21A0
-18A0
-0880
-0888
-FFFC
-4000
+0180
+06F0
+1900
+2100
+FFFE
+0000
+07C0
+3FF8
+0100
+0280
+0470
+1808
+2000
 ENDCHAR
-STARTCHAR CFE0
-ENCODING 53216
+STARTCHAR uniC88B
+ENCODING 51339
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-3BF8
-0418
-0010
-01F0
-1E10
-0020
-0020
-FFFE
-0100
-0100
-0100
-0100
-0100
-0100
+3FF0
+0040
+0180
+0F78
+3100
+01FE
+FF00
+0380
+0000
+3FF8
 0100
+06C0
+0440
+0380
 ENDCHAR
-STARTCHAR CFE1
-ENCODING 53217
+STARTCHAR uniC88C
+ENCODING 51340
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 16 15 1 -2
 BITMAP
-1FF0
-0010
-0010
-3FE0
-0020
-0020
-FFFE
-0100
-0100
-21F0
-1E10
+0030
 0010
+3F90
+0110
+0210
+0610
+19D0
+201F
+0210
+0210
+87D0
+7810
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR CFE4
-ENCODING 53220
+STARTCHAR uniC88D
+ENCODING 51341
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 14 16 2 -3
 BITMAP
-03F0
-1C10
-0030
+0060
+0020
+7F20
+0320
+0C20
+3FE4
+C8F8
+FF20
+0020
+0000
 3FE0
 0020
 0020
-FFFE
-0100
-0100
-1900
-0900
-0800
-07F8
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR CFE8
-ENCODING 53224
+STARTCHAR uniC894
+ENCODING 51348
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-1FF8
-0010
-0030
-1FD0
+0060
 0020
-FFFE
-0100
-0100
-0EE0
+7F20
+0220
+0C20
+3BAC
+CB70
+F420
+0000
+1FE0
 0020
-3FF0
+1FE0
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR CFF0
-ENCODING 53232
+STARTCHAR uniC89D
+ENCODING 51357
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-03F0
-1C20
 0060
-7FA0
-0040
-0040
-FFFC
-0200
-0200
-3FE0
-1040
-1040
-1FC0
-1000
-ENDCHAR
-STARTCHAR CFF1
-ENCODING 53233
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-01F0
-1E10
-0030
-3FE0
 0020
-0020
-FFFE
-0100
-1160
-0920
+7F20
+0220
+0C20
+3BBC
+CB60
+F420
+0000
+1820
+0820
 0FE0
 0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR CFF3
-ENCODING 53235
+STARTCHAR uniC89F
+ENCODING 51359
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-1FF0
-0010
-0030
-3FE0
-0020
+0060
 0020
-FFFE
-0100
-0100
-0300
-0300
-02C0
-0430
-1810
+7F20
+0220
+0C20
+33A0
+C838
+09E0
+F620
+0120
+0180
+0180
+0260
+0C10
+1000
 ENDCHAR
-STARTCHAR CFF5
-ENCODING 53237
+STARTCHAR uniC8A1
+ENCODING 51361
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -2
 BITMAP
-3FF8
-0010
-0010
-7FF0
-0010
+0060
 0020
-FFFE
-0100
+7F20
+0220
+0C20
+3BBC
+C8E0
+FF20
+0020
 0100
-0680
-0860
+06C0
+0820
 0820
 0C60
 07C0
-ENDCHAR
-STARTCHAR CFFC
-ENCODING 53244
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0018
-0008
-3F88
-0088
-0088
-7F08
-0108
-0148
-FE88
-2418
-0468
-0408
-0408
-0408
-0008
-ENDCHAR
-STARTCHAR D000
-ENCODING 53248
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 1 -2
-BITMAP
-0018
-0008
-0008
-1F88
-0088
-3F88
-0128
-FFC8
-2208
-0278
-0008
-0C08
-0400
-0408
-07FC
-ENDCHAR
-STARTCHAR D004
-ENCODING 53252
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0010
-3F90
-0090
-0110
-3F10
-0150
-FEB0
-04D0
-0400
-0FF0
-0010
-0FF0
-0400
-07F8
-ENDCHAR
-STARTCHAR D011
-ENCODING 53265
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0038
-0008
-3F88
-0088
-0188
-3F08
-0148
-FE88
-0478
-0448
-01E0
-0210
-0210
-0310
-01E0
 ENDCHAR
-STARTCHAR D018
-ENCODING 53272
+STARTCHAR uniC8A8
+ENCODING 51368
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
+0060
 0110
 0090
-FC90
+7E90
 0490
-1C90
-E890
-0E90
-F090
-1790
-1090
-1090
+0890
+1490
+6390
+98F0
 1090
+1F90
+E090
+0090
 0090
 0010
 ENDCHAR
-STARTCHAR D02D
-ENCODING 53293
+STARTCHAR uniC8BC
+ENCODING 51388
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 14 1 -2
 BITMAP
-0018
-00C8
-6E48
-1248
-0648
-7C48
-0448
-FF48
-09C8
-08C0
-01E0
+0098
+0248
+3E48
+0C48
+13C8
+7878
+0848
+FFC8
+2030
 0210
 0210
-0230
-01E0
+0528
+08C4
+1084
 ENDCHAR
-STARTCHAR D034
-ENCODING 53300
+STARTCHAR uniC8BD
+ENCODING 51389
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 1 -2
 BITMAP
-0030
-0010
-3F90
-0090
-0110
-7F10
-2110
-01F0
-FF10
-2410
-0410
-0410
-0410
-0410
-0010
+0098
+0248
+3E48
+0C48
+13C8
+7878
+0848
+FFC8
+2028
+00F0
+0108
+0108
+0188
+00F0
 ENDCHAR
-STARTCHAR D035
-ENCODING 53301
+STARTCHAR uniC8C4
+ENCODING 51396
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-3F88
-0088
-0188
-3F08
-0148
-FE88
-0408
-0400
-0FF8
-0008
-0008
-0008
-0008
-0008
+0060
+0010
+0010
+7F90
+0310
+0610
+0C10
+33D0
+C410
+0410
+07D0
+F810
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D038
-ENCODING 53304
+STARTCHAR uniC8C8
+ENCODING 51400
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0110
+7F90
 0310
-7E30
-01D0
-FE10
-0410
-0410
+0610
+0B90
+3C10
+4430
+FFD0
+2010
 0010
-1810
-0800
+0C00
+0400
+0400
+07F8
+ENDCHAR
+STARTCHAR uniC8CC
+ENCODING 51404
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+0060
+0020
+FE20
+0420
+0820
+3720
+C820
+0FE0
+F020
+1FE0
+0020
+0040
+1FE0
 0800
-0FF8
+0FF0
 ENDCHAR
-STARTCHAR D03C
-ENCODING 53308
+STARTCHAR uniC8D4
+ENCODING 51412
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-3F88
-0088
-0088
-3F08
-0168
-FE88
-0200
-07F8
-0008
-07F8
-0200
-0200
-03FC
+0030
+0010
+7F10
+0210
+0C10
+3FD0
+C410
+07F0
+7810
+0000
+0FF0
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR D044
-ENCODING 53316
+STARTCHAR uniC8D5
+ENCODING 51413
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 15 2 -3
 BITMAP
-0018
-0008
-3F88
-0088
-0088
-3F08
-0148
-FE88
-0408
-0400
-07F8
-0208
-0208
+0030
+7F10
 0210
-03F8
-0200
+0C10
+3390
+CC10
+0410
+07F0
+7860
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR D045
-ENCODING 53317
+STARTCHAR uniC8D7
+ENCODING 51415
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-3F88
-0088
-0088
-3F08
-0148
-FE88
-0408
-0608
-0208
-03F8
-0208
-0208
-03F8
-0208
+0030
+0010
+7F10
+0210
+0410
+1F90
+6C10
+8470
+FF90
+0010
+0180
+0100
+02C0
+0430
+1810
 ENDCHAR
-STARTCHAR D047
-ENCODING 53319
+STARTCHAR uniC8D9
+ENCODING 51417
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 2 -2
 BITMAP
-0018
-0008
-3F88
-0088
-0108
-3F08
-0148
-FE88
-0408
-0588
-04C0
-00C0
-0130
-0208
-0C04
+0030
+0010
+7F10
+0210
+0410
+1F90
+6C10
+8470
+FF90
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR D049
-ENCODING 53321
+STARTCHAR uniC8E0
+ENCODING 51424
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 11 1 0
 BITMAP
-0018
-0008
-3F88
-0088
-0188
-3F08
-0148
-FE88
-0408
-0448
-01B0
-0208
-0208
-0318
-01F0
+1FF0
+0020
+0040
+0180
+02C0
+0C3C
+3000
+0420
+0420
+0440
+FFFE
 ENDCHAR
-STARTCHAR D050
-ENCODING 53328
+STARTCHAR uniC8E1
+ENCODING 51425
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 15 1 -3
 BITMAP
-3FF0
+1FF0
+0060
+0180
+03F8
+1C6C
+2460
+0440
+FFFE
+0000
+1FF0
 0010
 0010
-7FE0
-0020
-0020
-FFFC
-0840
-0840
-0840
-0840
-0840
-0840
-0840
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D054
-ENCODING 53332
+STARTCHAR uniC8E4
+ENCODING 51428
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 15 13 1 -1
 BITMAP
 3FF0
-0010
-0030
-7FE0
-0020
 0040
-FFFC
+0180
+07C0
+183C
+6840
 0440
 0440
-1440
-1040
-1020
-1FF0
+FFFE
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR D058
-ENCODING 53336
+STARTCHAR uniC8F5
+ENCODING 51445
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0070
-3FE0
-0020
-00C0
-3F40
-007C
-FF80
-0880
-0880
-3FC0
+3FF0
 0040
-3FC0
-1000
-1000
-1FE0
+0180
+06F8
+1860
+2440
+0440
+FFFE
+0000
+07C0
+0420
+0C20
+0460
+03C0
 ENDCHAR
-STARTCHAR D060
-ENCODING 53344
+STARTCHAR uniC8FC
+ENCODING 51452
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 15 15 1 -3
 BITMAP
 3FE0
-0020
-0020
-7FC0
 0040
-0058
-FFA0
-0880
-0880
-3FC0
-1040
-1080
-1F80
-1000
-ENDCHAR
-STARTCHAR D06C
-ENCODING 53356
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 9 1 1
-BITMAP
-3FF8
-0008
-0018
-0030
-3FD0
-0010
-0020
-0020
+0080
+0380
+0C78
+7000
+000C
 FFFE
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR D06D
-ENCODING 53357
+STARTCHAR uniC8FD
+ENCODING 51453
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 14 1 -2
 BITMAP
-3FF0
-0030
-0020
-7FE0
-0020
-0040
-FFFC
-4000
-0000
+1FF0
+0060
+0080
+03F8
+1C04
+2004
+FFFE
+0100
+0100
 3FE0
 0020
 0020
 0020
 0020
-0020
 ENDCHAR
-STARTCHAR D070
-ENCODING 53360
+STARTCHAR uniC900
+ENCODING 51456
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 -1
+BBX 15 14 1 -2
 BITMAP
-1FF8
-0008
-0010
-0030
-1FD0
-0020
+3FF0
+0060
+00C0
+0380
+0C7C
+7000
+0004
 FFFE
-3000
-0800
-0800
-0800
+0100
+0100
+1900
+0900
+0900
 0FF8
 ENDCHAR
-STARTCHAR D074
-ENCODING 53364
+STARTCHAR uniC904
+ENCODING 51460
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF8
-0018
-0010
-3FF0
-0010
-0020
+1FF0
+0060
+0080
+03F8
+1C04
+2000
 FFFE
-0000
-0FE0
+0100
+1F00
+00E0
 0020
-1FF0
-0800
+1FE0
 0800
-07F8
+0FF0
 ENDCHAR
-STARTCHAR D07C
-ENCODING 53372
+STARTCHAR uniC905
+ENCODING 51461
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
+1FF0
+0060
+0080
+0378
+1C04
+2000
+FFFE
+0100
 1FF8
-0010
-0010
-0070
-1FA0
-0020
+0208
+3608
+1808
+1108
+1E08
+ENDCHAR
+STARTCHAR uniC906
+ENCODING 51462
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1FF0
+0060
+0080
+0378
+1C04
+2000
 FFFE
-0000
-0000
-1FE0
+0100
+1FF8
+02C8
+36C8
+18D0
+1150
+1E78
+ENDCHAR
+STARTCHAR uniC90C
+ENCODING 51468
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
+BITMAP
+3FF0
+0060
+0180
+06F8
+1804
+2000
+FFFE
+0100
+0100
+1F20
+08E0
 0820
 0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR D07D
-ENCODING 53373
+STARTCHAR uniC90D
+ENCODING 51469
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -3
 BITMAP
-1FF8
-0010
-0010
-3FF0
-0020
-0020
+1FF0
+0060
+0180
+06F0
+180C
+2004
 FFFE
-0000
-0C60
-0420
-07E0
-0420
-07E0
-0420
+0100
+1960
+0920
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR D081
-ENCODING 53377
+STARTCHAR uniC90F
+ENCODING 51471
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 15 1 -3
 BITMAP
-1FF8
-0010
-0010
 3FF0
-0020
-0020
+0060
+0080
+03C0
+0C3C
+7004
 FFFE
-0000
 0100
+0100
+0300
+0300
 06C0
-0820
+0830
+1008
+2000
+ENDCHAR
+STARTCHAR uniC911
+ENCODING 51473
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1FF0
+0060
+0080
+03F0
+1C0C
+2000
+FC00
+03FE
+0100
+0700
+08C0
 0820
 0C60
 07C0
 ENDCHAR
-STARTCHAR D0A4
-ENCODING 53412
+STARTCHAR uniC918
+ENCODING 51480
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0070
-0010
+0030
 0010
 7F10
 0310
-0210
-0E10
-F410
 0410
-0810
-1010
-2010
-4010
-0010
+0F90
+3050
+C010
+03D0
+7C10
+04F0
+0410
+0410
+0410
 0010
 ENDCHAR
-STARTCHAR D0A5
-ENCODING 53413
+STARTCHAR uniC92C
+ENCODING 51500
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
 0030
 0010
 7F10
 0210
-0610
+0C10
+1390
+E310
 FC10
-0810
-1010
-2010
-4000
-BFE0
-0020
-0020
-0020
-0020
-0020
+04F0
+0060
+0420
+0420
+0A50
+1088
+2100
 ENDCHAR
-STARTCHAR D0A8
-ENCODING 53416
+STARTCHAR uniC934
+ENCODING 51508
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-00C0
-0020
-0020
-7E20
-0420
-1C20
-E820
-1020
-2020
-4020
-A020
-1020
-1000
-1000
-0FF0
+0030
+0090
+0050
+7E50
+0450
+0850
+3650
+C050
+0650
+7850
+09D0
+0850
+0850
+0050
+0010
 ENDCHAR
-STARTCHAR D0AC
-ENCODING 53420
+STARTCHAR uniC950
+ENCODING 51536
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
 7F10
-0210
-0210
-FC10
-0810
-1010
-2000
-DFF0
-0020
-1FF0
-0800
-0800
-0FF8
+0310
+0410
+0F90
+3050
+C010
+03D0
+7C10
+0410
+0410
+0410
+0410
+0010
 ENDCHAR
-STARTCHAR D0B4
-ENCODING 53428
+STARTCHAR uniC951
+ENCODING 51537
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
+0070
 0010
 7F10
 0210
+0C10
+33D0
+C0F0
+FF10
+0410
+0410
+1FF0
+0010
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniC954
+ENCODING 51540
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0008
+3F88
+0108
+0208
+0FC8
+3008
+C7F8
+7A08
+0208
+0008
+0C08
+0400
+0400
+07FC
+ENDCHAR
+STARTCHAR uniC958
+ENCODING 51544
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0020
+0010
+7F10
 0210
-FC10
-0810
-1010
-2010
-4000
+0C10
+1390
+E7F0
+7C10
+0000
+0060
+0FA0
+0020
 1FE0
-0820
-0820
-0840
-0FE0
 0800
+0FF0
 ENDCHAR
-STARTCHAR D0B5
-ENCODING 53429
+STARTCHAR uniC960
+ENCODING 51552
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
+0060
 0010
-8710
-7A10
-0610
-FC10
-0810
-1010
-2000
-CC10
-0410
-07F0
+7F10
+0210
+0C10
+33D0
+C010
+0FF0
+7410
 0410
+0FF0
 0410
+0420
+0420
 07F0
-0410
+0400
 ENDCHAR
-STARTCHAR D0B7
-ENCODING 53431
+STARTCHAR uniC961
+ENCODING 51553
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
 0010
 7F10
 0210
-0210
-FC10
-0810
-1010
-2010
-4190
-0080
-0180
-0260
 0410
-1808
+1BD0
+6070
+FF90
+0410
+1810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D0B9
-ENCODING 53433
+STARTCHAR uniC963
+ENCODING 51555
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
 0030
 0010
-7F10
-0110
-0210
-FE10
+7F90
+0310
 0410
-0810
-1010
-6080
-0340
-0420
-0420
-0660
-03C0
-ENDCHAR
-STARTCHAR D0C0
-ENCODING 53440
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-0060
-0020
-0220
-FE20
-4020
-4020
-4220
-7E20
-403C
-4020
-41E0
-7E20
-2020
-0020
-0020
-0020
+1BD0
+E3B0
+7C10
+0410
+0510
+0180
+0100
+02C0
+0430
+1808
 ENDCHAR
-STARTCHAR D0C1
-ENCODING 53441
+STARTCHAR uniC96C
+ENCODING 51564
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 13 15 2 -3
 BITMAP
-00C0
-0220
-FE20
-4020
-4020
-7E3C
-4060
-43A0
-3C20
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+7FC0
+0080
+0100
+0700
+18F8
+E000
+0008
+FFF8
+0880
+0880
+0880
+0880
+0880
+0880
+0080
 ENDCHAR
-STARTCHAR D0C4
-ENCODING 53444
+STARTCHAR uniC970
+ENCODING 51568
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0040
+1FF0
 0020
-0220
-FF20
-4020
-7E20
-403C
-4060
-4FA0
-7020
-1020
-0820
+00C0
+0180
+067C
+3800
+FFFE
+0440
+0440
+0440
+0840
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR D0C8
-ENCODING 53448
+STARTCHAR uniC974
+ENCODING 51572
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 14 2 -2
 BITMAP
+3FE0
 00C0
-0220
-FE20
-4020
-4020
-7C3C
-40E0
-4F20
-3000
-1FE0
+0180
+0200
+1DF8
+E000
+FFFC
+0880
+3FC0
 0040
+3FC0
+1000
+1000
 1FE0
-0800
-0800
-0FF0
-ENDCHAR
-STARTCHAR D0C9
-ENCODING 53449
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0060
-0020
-FC20
-4020
-4E20
-703C
-41E0
-7E20
-0000
-3DE0
-0420
-7C20
-2020
-2620
-3820
 ENDCHAR
-STARTCHAR D0D0
-ENCODING 53456
+STARTCHAR uniC97C
+ENCODING 51580
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 14 2 -2
 BITMAP
-00C0
-0220
-FE20
-4020
-4020
-7E20
-4038
-40E0
-7F20
+3FE0
+0080
+0300
+0CF8
+F000
 0000
-1FE0
-0840
+FFF8
+0880
 0840
-0FC0
-0800
+3FC0
+1080
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR D0D1
-ENCODING 53457
+STARTCHAR uniC988
+ENCODING 51592
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 14 10 2 0
 BITMAP
+7FE0
 0040
-0020
-0620
-F820
-4020
-4E20
-7038
-43E0
-7C20
-1820
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0080
+0300
+0580
+1870
+E000
+0000
+0000
+FFFC
 ENDCHAR
-STARTCHAR D0D3
-ENCODING 53459
+STARTCHAR uniC989
+ENCODING 51593
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0040
-0020
-FE20
-4020
-4020
-4E2C
-7030
-40E0
-4F20
-3220
-0180
+3FF0
+0060
 0180
-0240
-0430
-1810
-ENDCHAR
-STARTCHAR D0D4
-ENCODING 53460
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0040
+0380
+1C78
+2000
+FFFE
+0000
+0000
+3FE0
 0020
-FE20
-4020
-4020
-5E3C
-6020
-43E0
-3C20
-0860
-0420
-0C60
-0A50
-1198
-6108
-ENDCHAR
-STARTCHAR D0D5
-ENCODING 53461
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0040
 0020
-CE20
-7020
-4020
-7E20
-403C
-43E0
-7C20
-00A0
-0340
-0420
-0420
-0660
-03C0
-ENDCHAR
-STARTCHAR D0DC
-ENCODING 53468
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-0190
-0090
-DC90
-6090
-4090
-4090
-7CF0
-4090
-4790
-7890
-0090
-0090
-0090
-0010
-ENDCHAR
-STARTCHAR D0DD
-ENCODING 53469
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-00C0
-0320
-0920
-F120
-8120
-B920
-C1E0
-8120
-9F20
-6120
-7FC0
-0040
-0040
-0040
-0040
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D0E0
-ENCODING 53472
+STARTCHAR uniC98C
+ENCODING 51596
 SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 14 2 -1
-BITMAP
-0030
-0010
-0190
-CC90
-7090
-4090
-7CF0
-4390
-7C90
-6090
-1890
-0810
+DWIDTH 17 0
+BBX 15 13 1 -1
+BITMAP
+1FF0
+0060
+0080
+03C0
+1C3C
+2000
+0004
+FFFE
+1000
 0800
+0800
+0810
 0FF8
 ENDCHAR
-STARTCHAR D0E4
-ENCODING 53476
+STARTCHAR uniC990
+ENCODING 51600
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 15 13 1 -1
 BITMAP
-0130
-CC90
-7090
-4090
-7C90
-40F0
-4390
-7C90
-7FE0
+3FF0
+0060
+0180
+06F8
+1804
+2004
+FFFE
+0000
+1FE0
 0020
 1FE0
 0800
-0800
 0FF0
 ENDCHAR
-STARTCHAR D0EC
-ENCODING 53484
+STARTCHAR uniC998
+ENCODING 51608
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 14 15 2 -3
 BITMAP
-0040
-0320
-1120
-E120
-8120
-F920
-81E0
-8320
-9D20
-E120
-1FC0
+3FE0
+00C0
+0100
+0780
+3878
+4000
+FFFC
+0000
+0000
+3FC0
 1040
 1040
 1080
 1FC0
 1000
 ENDCHAR
-STARTCHAR D0ED
-ENCODING 53485
+STARTCHAR uniC999
+ENCODING 51609
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0030
-0090
-8C90
-7090
-4090
-7890
-40F0
-4790
-7890
-0C90
-0410
-07F0
-0410
-0410
-07F0
-0410
+1FF0
+0060
+0180
+0378
+1C0C
+2004
+FFFE
+0000
+1820
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR D0EF
-ENCODING 53487
+STARTCHAR uniC99B
+ENCODING 51611
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 14 2 -2
 BITMAP
+3FE0
 00C0
-0320
-0120
-F120
-8120
-B920
-C1E0
-8120
-8F20
-F320
-0300
-0300
-04C0
-0820
-3010
+0100
+0780
+3878
+4000
+0000
+FFFC
+0600
+0200
+0700
+0C80
+1060
+6010
 ENDCHAR
-STARTCHAR D0F0
-ENCODING 53488
+STARTCHAR uniC99D
+ENCODING 51613
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0030
-0110
-8C90
-7090
-4090
-7C90
-41F0
-7E90
-7090
-00E0
-0420
-0420
-0A60
-1198
-2108
+33F0
+1C20
+00C0
+0300
+0CF8
+7000
+FFFE
+0000
+0100
+06C0
+0840
+0860
+0440
+0380
 ENDCHAR
-STARTCHAR D0F1
-ENCODING 53489
+STARTCHAR uniC9C0
+ENCODING 51648
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0020
-0110
-CC90
-7090
-4090
-7C90
-40F0
-4390
-7C90
-0090
-03C0
-0420
-0420
-0620
-03C0
+0070
+0010
+0010
+FF10
+0210
+0610
+0C10
+0C10
+3210
+4190
+8090
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D0F8
-ENCODING 53496
+STARTCHAR uniC9C1
+ENCODING 51649
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 11 15 3 -2
 BITMAP
 0060
 0020
-0220
 FE20
-4020
-402C
-4230
-7E20
-4020
-4020
-41FC
-7E20
-2020
+0420
+0C20
+1820
+3420
+4320
+8020
+3FE0
+1020
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR D10D
-ENCODING 53517
+STARTCHAR uniC9C4
+ENCODING 51652
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 15 1 -2
 BITMAP
-0080
-0060
-0020
-FC20
-403C
-4620
-7820
-4064
-47B8
-78A0
-0340
-0420
-0420
-0660
-03C0
+0030
+0008
+0008
+3F88
+0108
+0308
+0608
+0D08
+1088
+2048
+C808
+0400
+0400
+0400
+03FC
 ENDCHAR
-STARTCHAR D130
-ENCODING 53552
+STARTCHAR uniC9C7
+ENCODING 51655
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0010
-0010
-FC10
-4010
-4010
-4CF0
-7010
-4010
-4090
-4F10
-7010
-0010
-0010
-0010
+00C0
+0060
+FE20
+0620
+0420
+0820
+1420
+2320
+C120
+0040
+3FC0
+1000
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR D131
-ENCODING 53553
+STARTCHAR uniC9C8
+ENCODING 51656
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
 0010
-CE10
-7010
-41F0
-7C10
-4010
-4310
-7C10
-0000
-3FE0
-0020
-0020
-0020
-0020
+7F10
+0210
+0610
+0C10
+1B90
+2090
+C000
+1FE0
 0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR D134
-ENCODING 53556
+STARTCHAR uniC9CA
+ENCODING 51658
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 16 2 -3
 BITMAP
 0030
 0010
-FE10
-4010
-4010
-4CF0
-7010
-4010
-4310
-7C10
 0010
-1800
-0800
-0800
-0FF8
+7F10
+0210
+0610
+0C10
+1310
+2080
+FC00
+04F8
+6C90
+3090
+2290
+3CF8
+0080
 ENDCHAR
-STARTCHAR D138
-ENCODING 53560
+STARTCHAR uniC9D0
+ENCODING 51664
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 16 3 -3
 BITMAP
-0030
-0010
-0210
-FC10
-41F0
-5C10
-6010
-4110
-7FE0
-0020
+0060
 0020
-1FE0
+FE20
+0620
+0420
+0820
+1420
+6320
+8020
+0000
+0FE0
+0820
+0820
+0840
+0FE0
 0800
-0810
-0FF0
 ENDCHAR
-STARTCHAR D13A
-ENCODING 53562
+STARTCHAR uniC9D1
+ENCODING 51665
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
 0010
+7F10
 0210
-FC10
-41F0
-5C10
-6010
-4110
-7E00
-35F0
-0520
-6D20
-3120
-2320
-3DF0
-0100
+0610
+0C10
+1E20
+2100
+C000
+1860
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR D140
-ENCODING 53568
+STARTCHAR uniC9D3
+ENCODING 51667
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
 0030
-8610
-7810
-4010
-5CF0
-6010
-4010
-4610
-7810
-0000
-0FF0
-0410
-0410
+0010
+0010
+7F10
+0210
 0410
-07F0
-0400
+0C10
+1210
+2190
+C110
+0080
+0180
+0240
+0430
+1818
 ENDCHAR
-STARTCHAR D141
-ENCODING 53569
+STARTCHAR uniC9D5
+ENCODING 51669
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-8610
-7810
-4010
-5DF0
-6010
+0010
+7F10
+0210
+0610
+0C10
+1B10
+2190
 4010
-4610
-7C10
-0410
-07F0
-0410
+8090
+0360
 0410
-07F0
 0410
+0630
+03E0
 ENDCHAR
-STARTCHAR D143
-ENCODING 53571
+STARTCHAR uniC9D6
+ENCODING 51670
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
 0010
-0610
-F810
-4010
-5CF0
-6010
-4010
-4710
-7B10
-0090
-0100
-02C0
-0430
-1808
+0010
+7F10
+0210
+0410
+0C10
+1390
+2080
+C070
+1F80
+0180
+0240
+0C30
+1008
 ENDCHAR
-STARTCHAR D144
-ENCODING 53572
+STARTCHAR uniC9D9
+ENCODING 51673
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
+0010
+7F10
+0210
 0610
-F810
-4010
-5CF0
-6010
-4090
-4710
-7810
-0830
-0430
-0C20
-1A50
-2088
-4100
+0C10
+1A10
+2190
+4000
+9FE0
+0800
+0FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR D145
-ENCODING 53573
+STARTCHAR uniC9DA
+ENCODING 51674
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 14 2 -1
 BITMAP
 0030
 0010
-8610
-7810
-4010
-4DF0
-7010
-4010
-4610
-78D0
-0320
-0410
-0410
-0630
-03E0
+7F10
+0210
+0610
+0C10
+1310
+2190
+C000
+3FF0
+0840
+0440
+0480
+7FF8
 ENDCHAR
-STARTCHAR D14C
-ENCODING 53580
+STARTCHAR uniC9DC
+ENCODING 51676
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
+0040
 0020
-0310
-0090
-DC90
-6090
-4090
-5890
-6390
-4090
-4490
-7890
-0090
-0090
-0090
-0010
+0020
+FFA0
+1120
+2120
+3220
+4F2C
+84B0
+08A0
+1020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D14D
-ENCODING 53581
+STARTCHAR uniC9DD
+ENCODING 51677
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 16 2 -3
 BITMAP
 0060
-0320
-0120
-F920
-8120
-9F20
-E120
-8520
-F920
+0020
+0020
+7F20
+3120
+3224
+4D38
+88A0
+1020
 0000
 3FE0
+1020
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR D150
-ENCODING 53584
+STARTCHAR uniC9E0
+ENCODING 51680
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0030
-0110
-0090
-FC90
-4090
-4090
-7B90
-4090
-4490
-7890
-0890
-0410
-0400
-0400
-07FC
+0060
+0020
+0020
+7FA0
+1120
+3320
+4B2C
+84B0
+08A0
+1020
+1020
+0820
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR D154
-ENCODING 53588
+STARTCHAR uniC9E2
+ENCODING 51682
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
 BITMAP
 0060
-0220
-0120
-F120
-8120
-F720
-8120
-8920
-F100
-1FE0
 0020
+99A0
+7720
+1120
+3220
+4DB8
+88A0
+1020
+21C0
+2070
+2380
+2160
+2520
+3920
+ENDCHAR
+STARTCHAR uniC9E4
+ENCODING 51684
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+FBA0
+1520
+3220
+2B3C
+4CA0
+88A0
+1000
 1FE0
+0040
+1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR D15C
-ENCODING 53596
+STARTCHAR uniC9E7
+ENCODING 51687
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -2
 BITMAP
 0030
-0110
+0010
+7FD0
+0C90
 0890
-F090
-4090
-7F90
-4090
-4490
-7890
-0080
+159E
+6250
+8430
+1B90
+0490
+02F0
+3E90
+1090
+11F0
+1E90
+ENDCHAR
+STARTCHAR uniC9EC
+ENCODING 51692
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
+BITMAP
+0030
+0010
+0010
+3FD0
+0890
+1916
+2798
+4250
+8410
+0800
 0FF0
-0410
 0420
 0420
+0420
 07F0
 0400
 ENDCHAR
-STARTCHAR D15D
-ENCODING 53597
+STARTCHAR uniC9ED
+ENCODING 51693
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+0020
+79A0
+1F20
+1120
+2B2C
+4CB0
+8820
+1000
+2C20
+0420
+07E0
+0420
+0420
+07E0
+0420
+ENDCHAR
+STARTCHAR uniC9EF
+ENCODING 51695
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+0020
+FFA0
+1120
+322C
+4B30
+84A0
+0820
+1120
+0180
+0100
+02C0
+0C30
+1008
+ENDCHAR
+STARTCHAR uniC9F0
+ENCODING 51696
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+0020
+7FA0
+1120
+3320
+2B24
+4CB8
+88A0
+1000
+0840
+0420
+0C40
+1AE0
+2090
+4108
+ENDCHAR
+STARTCHAR uniC9F1
+ENCODING 51697
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
+BITMAP
+00C0
+0040
+0040
+7F40
+2240
+3258
+5660
+8940
+10C0
+2140
+0680
+0840
+0840
+0CC0
+0780
+ENDCHAR
+STARTCHAR uniC9F8
+ENCODING 51704
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0030
+0048
+0028
+0028
+3F28
+1128
+1228
+2A28
+4538
+88A8
+1028
+0028
+0028
+0028
+0008
+ENDCHAR
+STARTCHAR uniC9F9
+ENCODING 51705
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
+BITMAP
+0030
+00C8
+0048
+3FC8
+0948
+1248
+2A78
+45C8
+88C8
+1048
+0FF8
+0008
+0008
+0008
+0008
+0008
+ENDCHAR
+STARTCHAR uniC9FC
+ENCODING 51708
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0018
+0048
+0048
+7F48
+1B48
+1248
+2E78
+4548
+88C8
+1048
+2048
+0C48
+0400
+0400
+03F8
+ENDCHAR
+STARTCHAR uniCA00
+ENCODING 51712
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0110
+0090
+7E90
+2290
+2490
+56F0
+8990
+1090
+0FF0
+0010
+0020
+0FF0
+0400
+07F8
+ENDCHAR
+STARTCHAR uniCA08
+ENCODING 51720
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0020
+0110
+0090
+7E90
+3290
+2490
+56F0
+8990
+1090
+0090
+07F0
+0420
+0420
+0420
+07E0
+0400
+ENDCHAR
+STARTCHAR uniCA09
+ENCODING 51721
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-0190
-0C90
-F090
-4090
-7B90
-4090
-4C90
-7090
+00D0
+0050
+7F50
+1250
+2450
+5670
+8950
+1150
 0810
 0410
 07F0
@@ -127902,797 +131376,651 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR D15F
-ENCODING 53599
+STARTCHAR uniCA0B
+ENCODING 51723
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 1 -2
+BITMAP
+0018
+00C8
+0048
+7FC8
+0948
+1348
+2A78
+45C8
+88C8
+1048
+0040
+00C0
+0130
+0208
+0C04
+ENDCHAR
+STARTCHAR uniCA0C
+ENCODING 51724
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 2 -3
 BITMAP
 0030
-0190
-0C90
-F090
-4090
-7B90
-4090
-4490
-7890
-0190
-0180
-0180
-0240
-0430
-1808
+00D0
+0050
+7F50
+1250
+2650
+5670
+8950
+1150
+0050
+0C20
+0C40
+0C60
+1298
+2108
+4000
 ENDCHAR
-STARTCHAR D161
-ENCODING 53601
+STARTCHAR uniCA0D
+ENCODING 51725
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
-0030
-00C8
-EE48
-3048
-2048
-3DC8
-2048
-2248
-3C48
-00C8
-0320
+0018
+0068
+0028
+3FA8
+0928
+1328
+2B38
+44A8
+88A8
+0000
+01E0
 0210
 0210
 0330
 01E0
-ENDCHAR
-STARTCHAR D168
-ENCODING 53608
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-0010
-0010
-FC10
-41F0
-4010
-4C10
-7070
-4090
-4010
-4610
-7810
-0010
-0010
-0010
 ENDCHAR
-STARTCHAR D16C
-ENCODING 53612
+STARTCHAR uniCA14
+ENCODING 51732
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
-FE10
-41F0
-4010
-4C10
-71F0
-4010
-4210
-7C10
+0010
+4C50
+3FD0
+089E
+1990
+2590
+4650
+845E
+0810
 1010
-0800
-0800
-0830
-07F0
-ENDCHAR
-STARTCHAR D17C
-ENCODING 53628
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 16 2 -3
-BITMAP
-0030
 0010
-0610
-F9F0
-4010
-4C10
-71F0
-4010
-4610
-7810
-0C20
-0420
-0C60
-1290
-2108
-C000
+0010
+0010
 ENDCHAR
-STARTCHAR D184
-ENCODING 53636
+STARTCHAR uniCA18
+ENCODING 51736
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 2 -2
 BITMAP
+0060
 0020
-0310
-0090
-DC90
-6090
-4790
-5890
-6090
-4390
-4490
-7890
-0090
-0090
-0090
-0010
+0020
+7FA0
+113C
+3120
+2B20
+44A0
+88BC
+1020
+1020
+0820
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR D188
-ENCODING 53640
+STARTCHAR uniCA29
+ENCODING 51753
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 14 15 2 -2
 BITMAP
 0060
-0320
-0120
-F120
-8320
-B120
-C720
-8520
-F920
-0120
-0120
-1820
-0800
-0800
-0FF8
+0020
+0020
+7F20
+1138
+3220
+4D20
+88AC
+10B0
+2100
+06C0
+0820
+0820
+0C60
+03C0
 ENDCHAR
-STARTCHAR D1A0
-ENCODING 53664
+STARTCHAR uniCA4C
+ENCODING 51788
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 12 15 2 -2
 BITMAP
-3FF8
-1000
-1000
-1FF0
-1000
-1000
+0060
+0030
+0010
+7FD0
+0890
+1090
+1910
+2570
+4290
+8450
+0850
 1010
-1FF8
-0100
-0100
-FFFE
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D1A1
-ENCODING 53665
+STARTCHAR uniCA4D
+ENCODING 51789
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 13 15 1 -3
 BITMAP
-1FE0
-1000
-1000
-1FE0
-1020
-1FE0
-0104
-FFFC
-0000
-3FE0
-0020
-0020
-0020
-0020
+0018
+0088
+3F88
+0888
+1908
+26B8
+4248
+8448
+0008
+0FF8
+0408
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR D1A4
-ENCODING 53668
+STARTCHAR uniCA50
+ENCODING 51792
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-1FF0
-1000
-1000
-1FF0
+0030
+0010
+FF90
+1110
+2110
+32F0
+4E10
+8910
+1090
+2010
 1010
-1FF0
-0100
-C1FE
-FE00
-1000
-0800
+0810
 0800
 0800
-07F8
+0FF8
 ENDCHAR
-STARTCHAR D1A8
-ENCODING 53672
+STARTCHAR uniCA54
+ENCODING 51796
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-3FF0
-1000
-1FE0
+0030
+0010
+FF90
+1110
+2110
+3A70
+4D90
+8890
 1000
-1FF0
-0100
-0100
-FFFE
-1FF0
-0020
+3FE0
 0020
-0FF0
+1FE0
 0800
-0FF8
+0800
+0FF0
 ENDCHAR
-STARTCHAR D1B0
-ENCODING 53680
+STARTCHAR uniCA5C
+ENCODING 51804
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 16 2 -3
 BITMAP
-1F60
-1080
-1FE0
-1000
-1000
-0FE0
-0200
-FFFC
+0030
+0010
+FF90
+1110
+3310
+3270
+4D10
+8890
+1010
 0000
-3FC0
-1040
-1080
-1FC0
-1000
-ENDCHAR
-STARTCHAR D1B1
-ENCODING 53681
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-3FF0
-1000
 1FE0
-1000
-1030
-0FC0
-0100
-FFFE
-3860
 0820
-0FE0
 0820
+0840
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR D1B3
-ENCODING 53683
+STARTCHAR uniCA5D
+ENCODING 51805
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 12 16 2 -3
 BITMAP
-1FE0
-1000
-1000
-1FE0
-1000
-1FE0
-0100
-FFFC
-0000
-0100
-0300
-02C0
-0C30
+0030
+0010
+7F90
+1110
+2210
+3A70
+4D10
+8890
 1010
+0C60
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR D1B5
-ENCODING 53685
+STARTCHAR uniCA5F
+ENCODING 51807
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 13 15 2 -2
 BITMAP
-1FF0
-1000
-1FE0
-1000
-1030
-0FC0
-0100
-FFFE
+0030
+0010
+FB90
+1510
+1110
+3270
+4D10
+8890
+1090
+0110
 0100
-06C0
-0820
-0820
-0C60
-07C0
+0380
+0660
+0810
+1008
 ENDCHAR
-STARTCHAR D1BA
-ENCODING 53690
+STARTCHAR uniCA60
+ENCODING 51808
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-0FE0
-3000
-1FE0
-1000
-1020
-1FC0
-0200
-FFFC
-0000
-3FE0
-0880
-0C80
-0100
-7FF0
+0030
+0010
+FF90
+1190
+3110
+2A70
+4B10
+8490
+0800
+0860
+0420
+0C60
+1290
+2118
+4208
 ENDCHAR
-STARTCHAR D1BC
-ENCODING 53692
+STARTCHAR uniCA61
+ENCODING 51809
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-01A0
-7FA0
-2020
-2120
-3F20
-2020
-21A0
-3E3C
+0030
+0010
+FF90
+1110
+3310
+3270
+4D10
+8890
+1010
+0090
+03C0
 0420
-07E0
-F820
-0020
-0020
-0020
+0420
+0420
+03C0
 ENDCHAR
-STARTCHAR D1C0
-ENCODING 53696
+STARTCHAR uniCA68
+ENCODING 51816
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0110
-3F90
-2010
-3F90
-2090
-3F1E
-0410
-07F0
-F810
-0C10
-0410
-0400
-07F8
+0090
+0050
+0050
+7E50
+2250
+2450
+55D0
+9C50
+1250
+1250
+2050
+0050
+0050
+0010
 ENDCHAR
-STARTCHAR D1D8
-ENCODING 53720
+STARTCHAR uniCA7D
+ENCODING 51837
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -3
+BBX 13 15 1 -2
 BITMAP
-0130
-0090
-0C90
-7090
-4C90
-7090
-5E90
-28F0
-0990
-0E90
-F090
-0090
-0090
-0090
-0010
+0018
+0068
+0028
+3F28
+0928
+1AE8
+2B28
+44A8
+8828
+1028
+00D0
+0108
+0108
+0198
+00F0
 ENDCHAR
-STARTCHAR D1F4
-ENCODING 53748
+STARTCHAR uniCA84
+ENCODING 51844
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 1 -2
 BITMAP
 0030
 0010
-7F90
-2010
-2010
-3F10
-2010
-2090
-3F10
-0410
-07F0
-FE10
 0010
+3FD0
+08F0
+1090
+1D10
+26F0
+4290
+8450
+0850
+1010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR D1F8
-ENCODING 53752
+STARTCHAR uniCA98
+ENCODING 51864
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0110
-3F10
-2010
-3F10
-2190
-3E10
-0470
-0790
-F810
 0010
-1800
-0800
-0800
-0FF8
+FF90
+11F0
+3110
+2A10
+4B30
+8490
+0810
+0860
+0420
+0C40
+12B0
+2118
+4208
 ENDCHAR
-STARTCHAR D207
-ENCODING 53767
+STARTCHAR uniCABC
+ENCODING 51900
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 11 1 0
 BITMAP
-0070
-0130
-7F10
-2110
-3F10
-2090
-3F10
-04F0
-0F10
-F110
-0090
-0180
-0360
+7FF8
 0410
-1808
-ENDCHAR
-STARTCHAR D209
-ENCODING 53769
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-00E0
-0260
-7F20
-4020
-7E20
-4120
-7E20
-0820
-1FE0
-E220
-0580
-0840
-0840
-0CC0
-0780
-ENDCHAR
-STARTCHAR D210
-ENCODING 53776
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 13 2 -1
-BITMAP
-0060
-7FE0
-2000
-2000
-3FE0
-2000
-2020
-3FE0
-10C0
-0840
-0848
-FFFC
-4000
-ENDCHAR
-STARTCHAR D22C
-ENCODING 53804
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 14 1 -2
-BITMAP
-1FF8
-0800
-0800
-0FF0
-0800
-0FF8
-0000
-FFFE
-0100
-0100
-0100
-0100
+0C20
+0A60
+13D8
+610C
+8200
+0500
 0100
 0100
+FFFE
 ENDCHAR
-STARTCHAR D22D
-ENCODING 53805
+STARTCHAR uniCABD
+ENCODING 51901
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF0
-0800
-0FF0
-0800
-0FF0
-0000
-0000
-FFFE
+3F30
+04E0
+0C40
+12B8
+6104
+0700
 0100
-01E0
-1E20
+FFFE
+2000
+3FE0
+1020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR D230
-ENCODING 53808
+STARTCHAR uniCAC0
+ENCODING 51904
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-2070
-1FA0
-1FE0
-1000
-1000
-1FF0
-0004
-FFFE
-0100
+3EF0
+0630
+0460
+1B9C
+2100
+0780
 0100
-1900
-0900
+FFFE
+2000
+0000
 0800
-0FF0
+0800
+0800
+07F8
 ENDCHAR
-STARTCHAR D234
-ENCODING 53812
+STARTCHAR uniCAC4
+ENCODING 51908
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-0FF0
-3000
-1FE0
-1000
-1FE0
-0000
+7DE0
+0C40
+1880
+2578
+C600
+0100
 FFFC
-0200
-0200
-1DC0
+0000
+3FC0
 0040
-1FC0
+3FC0
 1000
-1FE0
-ENDCHAR
-STARTCHAR D23C
-ENCODING 53820
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-3FF0
 1000
 1FE0
-1000
-1000
-1FF0
-0000
-FFFE
-0100
-1F00
-08E0
-0820
-0820
-0FE0
-0800
 ENDCHAR
-STARTCHAR D23D
-ENCODING 53821
+STARTCHAR uniCACC
+ENCODING 51916
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-1FF8
-0810
-0FF0
-0810
-0FF0
-0000
-FFFE
+2210
+1E70
+0C60
+12F0
+210C
+0700
 0100
-1920
-0920
-0FE0
-0820
-0820
+FFFE
+0000
 0FE0
 0820
+0840
+0FC0
+0800
 ENDCHAR
-STARTCHAR D23F
-ENCODING 53823
+STARTCHAR uniCACD
+ENCODING 51917
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-0FF8
-0800
-0FF0
-0800
-0FF0
-0000
-0000
-FFFE
-0100
-0100
+2210
+1E70
+0460
+1AF0
+210C
+0700
 0100
-0300
-06C0
-0830
-3010
+FFFE
+0C60
+0420
+07E0
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR D241
-ENCODING 53825
+STARTCHAR uniCACF
+ENCODING 51919
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0FF8
-0800
-0FF0
-0800
-0FF8
-0000
-0000
+3210
+0E70
+0C60
+12F0
+210C
+0700
+0100
 FFFE
+0180
 0100
-0300
-0CE0
-0820
-0C60
-07C0
+0380
+0660
+0810
+3008
 ENDCHAR
-STARTCHAR D248
-ENCODING 53832
+STARTCHAR uniCAD1
+ENCODING 51921
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0018
-0008
-3FC8
-1008
-1F88
-10C8
-1FC8
-0008
-00C8
-FF08
-04F8
-0408
-0408
-0408
-0008
+1E10
+0470
+0A20
+11F0
+210C
+0700
+0100
+FFFE
+0080
+03C0
+0420
+0420
+0420
+03C0
 ENDCHAR
-STARTCHAR D25C
-ENCODING 53852
+STARTCHAR uniCAD3
+ENCODING 51923
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 14 2 -2
 BITMAP
-0030
-0110
-7F10
-2310
-3F10
-2110
-3F10
-FE10
-04F0
+7DE0
+0C40
+1C80
+2378
+C600
+0200
+FFFC
 0000
-0C30
-0420
-0A60
-1158
-2188
+0700
+7FF0
+0200
+0700
+08E0
+7010
 ENDCHAR
-STARTCHAR D264
-ENCODING 53860
+STARTCHAR uniCAD8
+ENCODING 51928
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
-0090
-0050
-FC50
-4050
-7C50
-4050
-7C50
-0050
-0E50
-7850
-09D0
-0850
-0850
 0010
-ENDCHAR
-STARTCHAR D280
-ENCODING 53888
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0070
+7FD0
+0890
+1990
+2590
+4250
+8416
+0A18
+02F0
+7D10
 0010
-3F90
-2010
-3810
-2610
-2010
-3F90
 0010
-00F0
-FF10
-0410
-0410
-0410
-0410
+0010
 0010
 ENDCHAR
-STARTCHAR D281
-ENCODING 53889
+STARTCHAR uniCAD9
+ENCODING 51929
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 16 1 -3
 BITMAP
 0030
-7F10
-2010
-3F10
-2010
-3F10
 0010
-FFF0
-0410
-0400
+7F90
+1990
+2B10
+44D6
+0E18
+0470
+FF90
+0000
 1FF0
 0010
 0010
@@ -128700,737 +132028,803 @@
 0010
 0010
 ENDCHAR
-STARTCHAR D284
-ENCODING 53892
+STARTCHAR uniCAE0
+ENCODING 51936
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0020
-FE20
-4220
-7E20
-4020
-7E60
-3FA0
-C820
-0820
 0020
-1800
-0800
-0800
+0010
+7FD0
+0890
+1990
+2670
+C61E
+1AF0
+0790
+7FF0
+0010
 0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR D288
-ENCODING 53896
+STARTCHAR uniCAEC
+ENCODING 51948
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 15 15 1 -2
 BITMAP
-0018
-0008
-3F88
-1008
-1F88
-1088
-1F88
-0078
-FF88
-0600
-07F8
-0008
-0FF8
-0400
-07F8
+0020
+0010
+7FD0
+0890
+1990
+2670
+C616
+1AF8
+0790
+7820
+0210
+0210
+0530
+0848
+3084
 ENDCHAR
-STARTCHAR D290
-ENCODING 53904
+STARTCHAR uniCAF4
+ENCODING 51956
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0030
-7F10
-2010
-3F10
-2010
-3F90
-0030
-FFD0
-0410
-0400
-0FF0
-0410
-0420
-0420
-07F0
-0400
+0020
+0090
+0050
+FF50
+1350
+2250
+5F50
+8850
+1870
+0850
+1FD0
+6050
+0050
+0050
+0010
 ENDCHAR
-STARTCHAR D291
-ENCODING 53905
+STARTCHAR uniCB08
+ENCODING 51976
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 14 14 2 -2
 BITMAP
-0018
-3F88
-1008
-1F88
-1008
-1F88
-0008
-FFF8
-2408
-0418
-0608
-03F8
-0208
-0208
-03F8
-0208
+0030
+00D0
+7F50
+2250
+5750
+88F0
+1450
+07D0
+7870
+0620
+0420
+0B58
+1188
+6104
 ENDCHAR
-STARTCHAR D295
-ENCODING 53909
+STARTCHAR uniCB10
+ENCODING 51984
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-3F10
-2010
-3F10
-2010
-3F10
 0010
-FFF0
-0410
-0490
-0360
-0410
-0410
-0630
-03E0
+FFD0
+1890
+1110
+2B10
+44D0
+0C10
+1410
+04F0
+FB10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D29C
-ENCODING 53916
+STARTCHAR uniCB14
+ENCODING 51988
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 15 3 -2
 BITMAP
-1FF0
-1000
-1FE0
-1000
-1000
-1FF0
-0000
-FFFC
-0840
-0840
-0840
-0840
-0840
-0840
+0060
+0020
+FFA0
+1120
+3320
+4CA0
+8C20
+34E0
+0F20
+F020
+0020
+1820
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR D2A0
-ENCODING 53920
+STARTCHAR uniCB18
+ENCODING 51992
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 14 2 -1
 BITMAP
-3FE0
-1000
-1000
-1FE0
-1000
-1FF0
-0000
-FFFC
-0840
-0840
-3040
-1040
-1000
-1FF0
+0060
+0010
+7F90
+0890
+1190
+2E50
+C610
+0EF0
+0790
+7FF0
+0020
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR D2A4
-ENCODING 53924
+STARTCHAR uniCB20
+ENCODING 52000
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-3FE0
-1000
-1FE0
-1020
-1FE0
-0000
-FFFC
-0880
-0880
-3FE0
-0040
-1FE0
-1000
-1FF0
+0030
+0010
+7F90
+0890
+1990
+2650
+C610
+0AF0
+0790
+7800
+0FF0
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR D2AC
-ENCODING 53932
+STARTCHAR uniCB21
+ENCODING 52001
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 15 2 -2
 BITMAP
-1FF0
-0800
-0FE0
+0030
+0C90
+3B90
+1110
+22D0
+C410
+0E10
+07F0
+7800
 0810
-0FF0
-0000
-FFFE
-0C40
-0C60
-1FE0
-0820
-0840
-0FE0
-0800
+0410
+07F0
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D2B1
-ENCODING 53937
+STARTCHAR uniCB41
+ENCODING 52033
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-1FF0
-1000
-1FE0
-1000
-1000
-1FF0
-0000
+7C00
+09E0
+1C40
+65C0
+8238
+0D80
+0888
 FFFC
-0940
-0FC0
-0840
-0840
-0840
-0780
+0200
+0F80
+18C0
+1040
+18C0
+0F80
 ENDCHAR
-STARTCHAR D2B8
-ENCODING 53944
+STARTCHAR uniCB48
+ENCODING 52040
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 15 15 1 -3
 BITMAP
-1FF0
-3000
-1000
-1000
-1FF0
-1000
-1030
-1FF0
-0000
-0000
+3E10
+06F0
+0420
+0A70
+308C
+0300
+0004
 FFFE
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR D2B9
-ENCODING 53945
+STARTCHAR uniCB49
+ENCODING 52041
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-3FE0
-1000
-1FE0
-1000
-1000
-1FF0
-0000
+3EF0
+0420
+0C60
+12DC
+2100
+4204
 FFFE
-2000
+0100
+0100
 3FE0
 0020
 0020
 0020
 0020
-0020
 ENDCHAR
-STARTCHAR D2BC
-ENCODING 53948
+STARTCHAR uniCB4C
+ENCODING 52044
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0070
-3FF0
-1000
-1FE0
-1000
-1FF0
-0004
+3EF0
+0610
+0420
+1B78
+2184
+0200
 FFFE
-0000
-0000
-0800
+0100
+0100
+0100
+1900
+0900
 0800
-0810
 07F8
 ENDCHAR
-STARTCHAR D2BF
-ENCODING 53951
+STARTCHAR uniCB50
+ENCODING 52048
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF0
-0800
-0FF0
-0800
-0FF0
-0000
+3FF0
+0430
+0E60
+11D8
+6104
+0600
 FFFE
-2000
-0020
-1FF0
-0800
+0100
+1F20
+00E0
+1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR D2C0
-ENCODING 53952
+STARTCHAR uniCB58
+ENCODING 52056
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 14 15 2 -3
 BITMAP
-1FC0
-6000
-3FC0
-2000
-2000
+7DF0
+0C20
+0840
+34C0
+4338
+0208
+FFF4
+0200
+0200
 3FC0
-7800
-87FC
-03E0
-3C40
-0040
-3FE0
+1040
+1040
+1040
+1FC0
 1000
-1FF0
-ENDCHAR
-STARTCHAR D2C2
-ENCODING 53954
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-1FF0
-0800
-0FF0
-0800
-0FF0
-0000
-0004
-FFFE
-2000
-3EF8
-0290
-3E90
-1090
-16F0
-0880
 ENDCHAR
-STARTCHAR D2C8
-ENCODING 53960
+STARTCHAR uniCB59
+ENCODING 52057
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
-3FF0
-1000
-1FE0
-1000
-1020
-1FF0
-0004
+3EF0
+0610
+0C20
+1A50
+208C
+0100
 FFFE
-0000
-1FE0
-0820
+0100
+1960
+0920
+0FE0
 0820
 0820
 0FE0
-0800
+0820
 ENDCHAR
-STARTCHAR D2C9
-ENCODING 53961
+STARTCHAR uniCB5D
+ENCODING 52061
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF0
-0800
-0FF0
-0800
-0FF0
-0000
-0004
+3EF8
+0610
+0420
+0A5C
+3182
+0204
 FFFE
-3820
-0820
-0FE0
+0100
+0100
+06C0
 0820
-0FE0
 0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR D2CB
-ENCODING 53963
+STARTCHAR uniCB64
+ENCODING 52068
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-3FF0
-1000
-1FE0
-1020
-1FF0
-0000
-0000
-FFFC
-0400
-0200
-0600
-0D80
-1060
-6020
+0030
+0010
+FF90
+1090
+1110
+2A90
+4450
+8810
+01D0
+7E10
+04F0
+0410
+0410
+0410
+0010
 ENDCHAR
-STARTCHAR D2D4
-ENCODING 53972
+STARTCHAR uniCB78
+ENCODING 52088
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0040
-0020
-7F20
-4020
-4020
-7F20
-4020
-4020
-3F20
-01E0
-FE20
-0020
-0020
-0020
-0020
+0030
+0010
+7F90
+1110
+3B10
+44D0
+0850
+FF90
+04F0
+0000
+0C30
+0420
+0A30
+1148
+2088
 ENDCHAR
-STARTCHAR D2D8
-ENCODING 53976
+STARTCHAR uniCB79
+ENCODING 52089
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 3 -1
+BBX 12 15 2 -2
 BITMAP
-0060
-0220
-FE20
-4020
-7E20
-4120
-7F20
-0020
-1FE0
-E020
-3020
-1000
-1000
-1FF0
+0030
+0010
+7F90
+1110
+2B10
+44D0
+0850
+FF90
+04F0
+0040
+01E0
+0210
+0210
+0310
+01E0
 ENDCHAR
-STARTCHAR D2DC
-ENCODING 53980
+STARTCHAR uniCB9C
+ENCODING 52124
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 2 -2
 BITMAP
 0030
-0110
-7F10
-2010
-3F10
-2190
-3F90
-00F0
+0010
+D890
+2F90
+1110
+2B90
+4450
+8810
+00D0
 FF10
-0000
-0FF0
+0410
+0410
+0410
+0410
 0010
-07F0
-0400
-07F8
 ENDCHAR
-STARTCHAR D2E4
-ENCODING 53988
+STARTCHAR uniCBB8
+ENCODING 52152
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 2 -3
 BITMAP
-0030
-0110
-7F10
-2010
-3F10
-2190
-3F90
-00F0
-FF10
-0000
-0FF0
+7C20
+0DE0
+0840
+14A0
+6118
+0600
+001E
+FFE0
+4840
+0840
+0840
+0840
+0840
+0840
+0040
+ENDCHAR
+STARTCHAR uniCBD4
+ENCODING 52180
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
+BITMAP
+3FF8
 0410
-0420
-07F0
+0C30
+0A20
+1158
+6084
+0300
 0400
+000C
+FFFE
+2000
 ENDCHAR
-STARTCHAR D2E5
-ENCODING 53989
+STARTCHAR uniCBE4
+ENCODING 52196
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 15 15 1 -3
 BITMAP
-0060
-0020
-7E20
-4020
-7E20
-4020
-7F20
-07E0
-F800
-1860
-0860
-0FC0
+3E00
+04F0
+0C20
+1A70
+208C
+4100
+060E
+FFF8
+2000
+1FE0
+0820
+0820
 0840
-0FC0
+0FE0
+0800
+ENDCHAR
+STARTCHAR uniCBE7
+ENCODING 52199
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+7DF0
+0C20
 0840
+14A0
+6318
+0200
+0008
+FFFC
+4600
+0300
+0700
+04C0
+1820
+6010
 ENDCHAR
-STARTCHAR D2F0
-ENCODING 54000
+STARTCHAR uniCBE9
+ENCODING 52201
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0060
-0010
+3EF8
 0210
-FE10
-4010
-4010
-4210
-7E10
-4010
-4010
-40F0
-7F10
+0420
+0A50
+318C
+0104
+FFFE
+0000
+0100
+06C0
+0420
+0C20
+0460
+03C0
+ENDCHAR
+STARTCHAR uniCC0C
+ENCODING 52236
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+0010
+7FD0
+0890
+1190
+2910
+2710
+4290
+8450
+0850
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR D2F1
-ENCODING 54001
+STARTCHAR uniCC0D
+ENCODING 52237
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 15 4 -2
+BBX 12 15 2 -2
 BITMAP
-01C0
-0440
-FC40
-8040
-8440
-FC40
-80C0
-8740
-7840
-0000
-7F80
-0080
-0080
-0080
-0080
+0030
+0010
+FF90
+1190
+1110
+2B10
+4E90
+8450
+1850
+3FF0
+0810
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D2F4
-ENCODING 54004
+STARTCHAR uniCC10
+ENCODING 52240
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
 BITMAP
 0060
-0020
-0420
-FC20
-8420
-FC20
-8020
-80E0
-FF20
-4020
-1020
-0820
-0800
+0010
+0010
+FF90
+1190
+1110
+2B10
+4A90
+8490
+0850
+1810
+0810
 0800
-07F0
+0810
+07F8
 ENDCHAR
-STARTCHAR D2F8
-ENCODING 54008
+STARTCHAR uniCC14
+ENCODING 52244
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 4 -2
+BBX 13 15 2 -2
 BITMAP
-01C0
-0040
-FC40
-8040
-8040
-FC40
-80C0
-8F40
-7000
-3FC0
-0040
-3FC0
-1000
+0030
+0010
+7FD0
+1890
+1110
+2B10
+42D0
+8C50
 1000
-1FE0
+0FF0
+0010
+0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR D300
-ENCODING 54016
+STARTCHAR uniCC1C
+ENCODING 52252
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 16 2 -3
 BITMAP
-0060
-0420
-FC20
-8020
-8420
-FC20
-8020
-83E0
-7C20
+0030
+0010
+1810
+2F90
+1110
+2910
+4290
+84D0
+0850
 0000
-3FC0
-1040
-1040
-1080
-1FC0
-1000
+0FF0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR D301
-ENCODING 54017
+STARTCHAR uniCC1D
+ENCODING 52253
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
 0010
-FF10
-2010
-2010
-3F10
-2010
-21F0
-3E10
-0C20
-0420
-07E0
-0420
+F990
+1E90
+1110
+2B10
+42D0
+8450
+0810
+0C30
+0410
+07F0
+0410
+0410
+07F0
+0410
+ENDCHAR
+STARTCHAR uniCC21
+ENCODING 52257
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+F990
+1E90
+1110
+2B10
+42D0
+8450
+0810
+0090
+03C0
 0420
-07E0
 0420
+0660
+03C0
 ENDCHAR
-STARTCHAR D303
-ENCODING 54019
+STARTCHAR uniCC22
+ENCODING 52258
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-0020
-FC20
-8020
-8020
-FC20
-8020
-80E0
-8F20
-7620
-0300
-0300
-0480
-1860
-2020
+0030
+0010
+FF90
+1990
+1110
+2B10
+4690
+8450
+0800
+3FF0
+0100
+0180
+0640
+0830
+3008
 ENDCHAR
-STARTCHAR D305
-ENCODING 54021
+STARTCHAR uniCC27
+ENCODING 52263
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-0020
-DE20
-6020
-4020
-7E20
-4020
-43E0
-7C20
-0120
-0680
-0840
-0840
-0CC0
-0780
+0030
+0010
+0090
+7F90
+1110
+3110
+4A90
+8450
+0810
+03D0
+1F20
+02C0
+0440
+0240
+0380
 ENDCHAR
-STARTCHAR D30C
-ENCODING 54028
+STARTCHAR uniCC28
+ENCODING 52264
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
-0060
-0020
-00A0
-7FA0
-0620
-2120
-1220
-123C
-1220
-03E0
-FC20
-0020
-0020
-0020
-0020
+0070
+0010
+0E10
+0010
+7F90
+0110
+0210
+041E
+0A10
+1190
+2090
+C010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D30D
-ENCODING 54029
+STARTCHAR uniCC29
+ENCODING 52265
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 16 2 -3
 BITMAP
 00C0
-01A0
-7FA0
+1E20
 0020
-2220
-122C
-1230
-03E0
-FC20
+FF20
+0220
+0420
+0C38
+3320
+4020
+8000
 3FE0
 0020
 0020
@@ -129438,930 +132832,843 @@
 0020
 0020
 ENDCHAR
-STARTCHAR D30E
-ENCODING 54030
+STARTCHAR uniCC2C
+ENCODING 52268
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0060
-01A0
-7F20
-0220
-2220
-143C
-13E0
-FC20
-0000
-07E0
-3C20
-0420
-0420
-0420
-0420
+0010
+0F10
+0010
+3F90
+0110
+0210
+061E
+0990
+3090
+C010
+0C10
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR D310
-ENCODING 54032
+STARTCHAR uniCC2E
+ENCODING 52270
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 14 3 -2
 BITMAP
-0060
-01A0
-7E20
-2620
-2220
-1220
-123C
-05E0
-FA20
+1CC0
+0040
+FE40
+0440
+0878
+1440
+2340
+C3C0
+C000
+47E0
+41E0
+4620
+7A20
+01E0
+ENDCHAR
+STARTCHAR uniCC30
+ENCODING 52272
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+00C0
 0020
-1820
-0820
+1E20
+0020
+7F20
+0224
+0438
+0A20
+3120
+5FE0
+8020
+1FE0
+0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR D314
-ENCODING 54036
+STARTCHAR uniCC38
+ENCODING 52280
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 16 2 -3
 BITMAP
-0160
-7F20
-0020
-2320
-1220
-123C
-03E0
-FC20
-1FE0
+00C0
 0020
+1C20
 0020
+7F20
+0220
+043E
+0A20
+3120
+4000
+9FE0
+0840
+0840
+0840
 0FE0
 0800
-0FF8
 ENDCHAR
-STARTCHAR D316
-ENCODING 54038
+STARTCHAR uniCC39
+ENCODING 52281
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 1 -3
+BBX 14 15 2 -3
 BITMAP
 0060
-0090
-3FD0
-0310
-1110
-1910
-027C
-FF90
-2010
-3EF8
-0290
-3690
-1890
-1190
-1EF8
-0080
-ENDCHAR
-STARTCHAR D31C
-ENCODING 54044
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 3 -2
-BITMAP
-0180
-0040
-FF40
-0040
-4440
-2448
-2470
-0FC0
-F040
-0000
-3FC0
-1080
-1080
-1080
-1F00
-ENDCHAR
-STARTCHAR D31D
-ENCODING 54045
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 16 2 -3
-BITMAP
-00C0
-0120
-7FA0
+3E20
 0020
-2220
-2220
-143C
-03E0
-FC20
-1820
-0820
+7F20
+0220
+043C
+0C20
+3320
+5920
+8820
 0FE0
 0820
 0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR D31F
-ENCODING 54047
+STARTCHAR uniCC3B
+ENCODING 52283
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-00C0
-0020
-01A0
-3E20
-2320
-1220
-123C
-1460
-FFA0
-4120
-00A0
 0180
-0260
-0410
-1808
+0040
+3C40
+0040
+FE40
+0440
+0858
+1460
+2240
+C240
+0140
+0300
+0480
+0860
+3010
 ENDCHAR
-STARTCHAR D320
-ENCODING 54048
+STARTCHAR uniCC3C
+ENCODING 52284
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 13 14 2 -2
 BITMAP
-0180
-0040
-FF40
+0060
+1E20
+0020
+7F20
+0220
+0420
+0C38
+3320
+4860
+8420
 0C40
-4440
-2448
-2470
-0FC0
-F040
-10C0
-0840
-1480
-2540
-4230
-8410
+12E0
+2098
+4108
 ENDCHAR
-STARTCHAR D321
-ENCODING 54049
+STARTCHAR uniCC3D
+ENCODING 52285
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 00C0
-0120
-7FA0
+1E20
 0020
-2320
-122C
-1230
-14E0
-FF20
-00A0
+7F20
+0220
+0420
+0C3C
+1320
+6020
+80A0
 0340
 0420
 0420
 0660
 03C0
 ENDCHAR
-STARTCHAR D325
-ENCODING 54053
+STARTCHAR uniCC3E
+ENCODING 52286
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 16 2 -3
 BITMAP
 00C0
-0020
-7FA0
 0020
-2220
-1220
-1478
-1FA0
-E000
-0FE0
-0800
-0FE0
-0800
-0800
-07F0
-ENDCHAR
-STARTCHAR D328
-ENCODING 54056
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0018
-00C8
-0048
-4748
-3848
-2248
-2248
-1478
-1448
-8FC8
-7048
-0048
-0048
-0048
-0008
+1E20
+7F20
+0220
+0420
+0C3C
+3320
+40A0
+8000
+3FF0
+0100
+0300
+04C0
+1830
+6010
 ENDCHAR
-STARTCHAR D329
-ENCODING 54057
+STARTCHAR uniCC44
+ENCODING 52292
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0060
+0110
 0090
-0050
-7E50
-0050
-2250
-2270
-0450
-05D0
-FA50
-1FF0
-0010
-0010
-0010
-0010
-0010
-ENDCHAR
-STARTCHAR D32C
-ENCODING 54060
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0030
-0190
+3C90
 0090
-7E90
-0490
+7C90
 0490
-2890
-28F0
-0F90
-F090
+0890
+18F0
+2490
+4090
+8090
 0090
-0C10
-0400
-0400
-07FC
+0090
+0010
 ENDCHAR
-STARTCHAR D330
-ENCODING 54064
+STARTCHAR uniCC45
+ENCODING 52293
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 16 3 -3
 BITMAP
 0060
-0190
-0090
-FE90
-4490
-2490
-28F0
-0F90
-F090
-1FE0
+0320
+7920
+0120
+FD20
+0920
+11E0
+2920
+4520
+8120
+3FE0
 0020
 0020
-1FE0
-0800
-0FF0
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D338
-ENCODING 54072
+STARTCHAR uniCC48
+ENCODING 52296
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0040
-0130
-0090
-FE90
-4C90
-2490
-24F0
-2B90
-F490
-0090
-07F0
-0410
-0420
-0420
-07F0
+0060
+0320
+0120
+7920
+0120
+FD20
+0920
+11E0
+2920
+4520
+8120
+1920
+0800
+0810
+0FF0
 ENDCHAR
-STARTCHAR D339
-ENCODING 54073
+STARTCHAR uniCC4C
+ENCODING 52300
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0060
-0110
+01B0
+3C90
 0090
 FE90
-4490
-2490
-24F0
-2B90
-F490
-0C90
-0410
-07F0
-0410
-0410
-07F0
-0410
+0490
+08F0
+1490
+2290
+C090
+1FF0
+0020
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR D33B
-ENCODING 54075
+STARTCHAR uniCC54
+ENCODING 52308
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -3
+BBX 11 16 3 -3
 BITMAP
-0130
-0090
-FE90
-4C90
-4490
-28F0
-2890
-1F90
-E110
-0080
-0180
-0240
-0430
-0808
-1000
+0060
+0320
+3920
+0120
+FD20
+0920
+11E0
+2920
+4520
+8120
+0FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR D33C
-ENCODING 54076
+STARTCHAR uniCC55
+ENCODING 52309
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-0190
-0090
-7C90
-4490
-2490
-24F0
-0790
-F890
-00D0
-0420
-0420
-0A60
-1298
-2104
+0010
+0048
+1C48
+0048
+7E48
+0678
+0C48
+1248
+2108
+C608
+0208
+03F8
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR D33D
-ENCODING 54077
+STARTCHAR uniCC57
+ENCODING 52311
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 14 2 -2
+BBX 13 15 2 -2
 BITMAP
-0130
+0030
 0090
-FC90
-4C90
-4490
-28F0
-2890
-1F90
-E090
-01C0
-0620
-0420
-0620
-03C0
+3C90
+0090
+FE90
+0490
+08F0
+1890
+6690
+8110
+0100
+0300
+06C0
+0830
+3018
 ENDCHAR
-STARTCHAR D344
-ENCODING 54084
+STARTCHAR uniCC58
+ENCODING 52312
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-00C0
-0020
-00A0
-7FA0
-0020
-032C
-2130
-1220
-1220
-1264
-FFB8
-4020
-0020
-0020
-0020
+0060
+0320
+3920
+0120
+FD20
+0920
+11E0
+3120
+4D20
+81A0
+0840
+0840
+14C0
+2730
+4010
 ENDCHAR
-STARTCHAR D345
-ENCODING 54085
+STARTCHAR uniCC59
+ENCODING 52313
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 11 14 2 -1
 BITMAP
 0060
-0010
-0010
-3F90
-011C
-1110
-0910
-02FE
-FD10
-1FF0
-0810
-0010
-0010
-0010
-0010
+3B20
+0120
+0120
+7920
+1120
+29E0
+4520
+8120
+0680
+0860
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR D37C
-ENCODING 54140
+STARTCHAR uniCC60
+ENCODING 52320
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
-0110
-FF10
-0010
-0310
-22F0
-3210
-1210
-0490
-FF10
+0E10
 0010
 0010
+7F9E
+0110
+0210
+0410
+0A16
+1198
+2090
+C010
 0010
 0010
 ENDCHAR
-STARTCHAR D37D
-ENCODING 54141
+STARTCHAR uniCC64
+ENCODING 52324
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -2
 BITMAP
 0030
-0110
-FF10
-0610
-2210
-2270
-1210
-0510
-FA10
-0000
-1FF0
-0010
-0010
-0010
+0F10
 0010
 0010
+3F96
+0118
+0210
+0610
+0996
+3098
+C810
+0400
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR D380
-ENCODING 54144
+STARTCHAR uniCC66
+ENCODING 52326
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 3 -2
 BITMAP
-0060
-0020
-FF20
-0020
-4420
-45E0
-2420
-2820
-1E20
-E020
-0020
-0820
-0800
-0800
-07F0
+0180
+3C40
+0040
+0040
+FE78
+0440
+0840
+1458
+6260
+81C0
+2070
+23C0
+2120
+2D20
+31E0
 ENDCHAR
-STARTCHAR D384
-ENCODING 54148
+STARTCHAR uniCC68
+ENCODING 52328
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 3 -2
 BITMAP
-0030
-0010
-FF10
-0610
-22F0
-3210
-1410
-0710
-7800
-1FE0
-0020
+00C0
+0040
+3C40
+0058
+FE60
+0440
+0848
+1470
+6200
+BFC0
+0040
+3FC0
+1000
+1000
 1FE0
-0800
-0810
-0FF0
 ENDCHAR
-STARTCHAR D38C
-ENCODING 54156
+STARTCHAR uniCC70
+ENCODING 52336
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 16 1 -3
 BITMAP
-0030
+0070
 0010
-7F90
-0410
-2210
-2270
-1210
-1590
-FA10
-0000
-0FF0
+0F10
+0010
+7F9E
+0110
+0210
+0510
+089C
+3000
+CFF0
 0420
 0420
 0420
 07F0
 0400
-ENDCHAR
-STARTCHAR D38D
-ENCODING 54157
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 16 2 -3
-BITMAP
-0030
-0110
-FF10
-0610
-22F0
-2210
-0410
-0F10
-F000
-0C10
-0410
-07F0
-0410
-0410
-07F0
-0410
-ENDCHAR
-STARTCHAR D38F
-ENCODING 54159
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 2 -2
-BITMAP
-0030
-0110
-FF10
-0610
-2310
-2270
-1210
-0590
-FA10
-0110
-0180
-0180
-0260
-0C10
-3008
 ENDCHAR
-STARTCHAR D390
-ENCODING 54160
+STARTCHAR uniCC75
+ENCODING 52341
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
-0030
-0110
-FF10
-0610
-2210
-2270
-2210
-0590
-FA10
 0060
+1C20
+0020
+FE20
+063C
+0420
 0C20
-0840
-1E60
-2290
-4108
-ENDCHAR
-STARTCHAR D391
-ENCODING 54161
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-0110
-FF10
-0610
-2310
-2270
-3210
-0590
-FA10
-0080
-0360
-0410
-0410
-0630
-03E0
+332C
+4030
+8120
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR D398
-ENCODING 54168
+STARTCHAR uniCC98
+ENCODING 52376
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
 0018
 0008
-00C8
-0748
-3848
-2448
-2448
-17C8
-1448
-1948
-FE48
-0048
-0048
-0048
+0E08
+0008
+7F08
+0308
+0298
+0468
+0A08
+1188
+6088
+8008
+0008
 0008
+0008
 ENDCHAR
-STARTCHAR D399
-ENCODING 54169
+STARTCHAR uniCC99
+ENCODING 52377
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-0098
-0348
-3C48
-2448
-17C8
-1448
-0648
-F848
-0008
-0FF8
-0408
-0008
-0008
-0008
-0008
+1E10
+0010
+7F10
+0210
+04F0
+0C10
+3310
+4110
+BFE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D39C
-ENCODING 54172
+STARTCHAR uniCC9C
+ENCODING 52380
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0030
-0110
-0090
-FE90
-0890
-4490
-2B90
-2890
-0C90
-F090
-0090
+0060
+0010
+1E10
+0010
+7F10
+0210
 0410
-0400
-0400
+0CF0
+1210
+6110
+8010
+1810
+0800
+0800
 07F8
 ENDCHAR
-STARTCHAR D3A0
-ENCODING 54176
+STARTCHAR uniCCA0
+ENCODING 52384
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0110
-0690
-7890
-4890
-2F90
-2890
-0C90
-FFE0
-0020
+1E10
+0010
+7F10
+0210
+05F0
+0A10
+3110
+C000
+1FE0
 0020
 1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR D3A8
-ENCODING 54184
+STARTCHAR uniCCA8
+ENCODING 52392
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 11 16 3 -3
 BITMAP
-0018
-0088
-0248
-7F48
-2448
-17C8
-1448
-0A48
-F448
-0040
-07F8
-0208
-0210
+0060
+0020
+3C20
+0020
+FE20
+0420
+09E0
+1820
+2620
+C200
+0FE0
+0820
+0840
+0840
+0FE0
+0800
+ENDCHAR
+STARTCHAR uniCCA9
+ENCODING 52393
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+1E10
+0010
+0010
+7F10
 0210
-03F8
-0200
+04F0
+0C10
+3200
+4D30
+8420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR D3A9
-ENCODING 54185
+STARTCHAR uniCCAB
+ENCODING 52395
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 11 15 3 -2
 BITMAP
-0018
-0088
-0348
-3C48
-2448
-17C8
-1448
-0A48
-F448
-0418
-0208
-03F8
-0208
-0208
-03F8
-0208
+0060
+0020
+3C20
+0020
+FE20
+07E0
+0820
+1820
+2620
+C620
+0320
+0300
+04C0
+1860
+2020
 ENDCHAR
-STARTCHAR D3AB
-ENCODING 54187
+STARTCHAR uniCCAC
+ENCODING 52396
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-0088
-0048
-7E48
-2448
-17C8
-1448
-0648
-F848
-01C8
-00C8
-0080
-0160
-0218
-0C04
+0030
+1E10
+0010
+7E10
+0610
+04F0
+0C10
+3310
+4100
+8820
+0420
+0C60
+1250
+2298
+4108
+ENDCHAR
+STARTCHAR uniCCAD
+ENCODING 52397
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+0060
+3C20
+0020
+FE20
+0420
+0BE0
+1820
+2620
+C220
+0120
+0680
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR D3AD
-ENCODING 54189
+STARTCHAR uniCCB4
+ENCODING 52404
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0110
+0060
+0130
 0090
-FE90
-4890
-2F90
-2890
+3C90
+0090
+FC90
 0C90
-F090
+0F90
+1090
+2890
+4490
+8090
 0090
-0360
-0410
-0410
-0630
-03E0
+0090
+0010
+0010
 ENDCHAR
-STARTCHAR D3B4
-ENCODING 54196
+STARTCHAR uniCCB5
+ENCODING 52405
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 11 16 3 -3
 BITMAP
-0018
-0008
-0088
-7F88
-0278
-0108
-1108
-1908
-1A38
-0248
-FF88
-0008
-0008
-0008
-0008
+0060
+0220
+3920
+0120
+FD20
+0920
+1120
+3720
+4920
+8500
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D3B8
-ENCODING 54200
+STARTCHAR uniCCB8
+ENCODING 52408
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0030
-0010
-FF10
-44F0
-4210
-2210
-24F0
-2410
-3E10
-4010
-0010
-1810
-0800
+0060
+0130
+3C90
+0090
+0090
+FC90
+0C90
+0F90
+1890
+2490
+4290
+1890
+0810
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR D3BC
-ENCODING 54204
+STARTCHAR uniCCBC
+ENCODING 52412
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0030
-0010
-FF10
-04F0
-2210
-2410
-24F0
-0710
-F800
-1FF0
 0020
+0110
+3890
+0090
+FC90
+0C90
+0F90
+1890
+2690
+C090
 1FF0
+0020
+1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR D3C4
-ENCODING 54212
+STARTCHAR uniCCC4
+ENCODING 52420
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -3
+BBX 12 16 2 -3
 BITMAP
-0030
-FF10
-0010
-0270
-2210
-2410
-0470
-0E10
-7010
+0060
+0130
+3890
+0090
+FC90
+0C90
+0B90
+1490
+2690
+C290
 0FF0
 0410
 0420
@@ -130369,22 +133676,22 @@
 07F0
 0400
 ENDCHAR
-STARTCHAR D3C5
-ENCODING 54213
+STARTCHAR uniCCC5
+ENCODING 52421
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0030
-0110
-FF10
-04F0
-2210
-2210
-24F0
-0710
-F800
-0C10
+0060
+0130
+3890
+0090
+FC90
+0890
+1F90
+1890
+6490
+8810
 0410
 07F0
 0410
@@ -130392,259 +133699,301 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR D3C8
-ENCODING 54216
+STARTCHAR uniCCC7
+ENCODING 52423
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0060
-0010
-FF10
-0410
-0270
-2410
-2410
-0970
-FE10
-1860
-0C20
-0C60
-1250
-2298
-4108
+0130
+3C90
+FC90
+0C90
+0890
+1790
+2690
+C290
+0110
+0090
+0180
+0240
+0430
+1808
 ENDCHAR
-STARTCHAR D3C9
-ENCODING 54217
+STARTCHAR uniCCC9
+ENCODING 52425
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0060
+0130
+3890
+0090
+FC90
+0890
+1F90
+1890
+6490
+8290
+0340
+0420
+0420
+0660
+03C0
+ENDCHAR
+STARTCHAR uniCCD0
+ENCODING 52432
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0310
-FF10
-00F0
-4210
-2410
-24F0
-2410
-0E10
-7090
-0360
-0410
+0010
+1E10
+0010
+7E10
+02F0
 0410
-0630
-03E0
+0810
+15F0
+2210
+4110
+8010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D3D0
-ENCODING 54224
+STARTCHAR uniCCD4
+ENCODING 52436
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 14 15 2 -2
 BITMAP
-0018
-0088
-0048
-4748
-3848
-27C8
-2448
-1448
-15C8
-1948
-FE48
-0048
-0048
-0048
-0008
+0030
+0010
+1E10
+0010
+7F10
+0270
+0610
+0C10
+1370
+2110
+C010
+0C10
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR D3D8
-ENCODING 54232
+STARTCHAR uniCCE4
+ENCODING 52452
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0030
-0110
-0690
-7890
-4790
-2890
-2B90
-0E90
-FFE0
-0020
-0020
-1FE0
-0800
-0800
-0FF0
+0070
+1C10
+0010
+0010
+7FF0
+0410
+0810
+15F0
+2210
+C860
+0420
+0C20
+0A50
+1098
+6108
 ENDCHAR
-STARTCHAR D3E1
-ENCODING 54241
+STARTCHAR uniCCEC
+ENCODING 52460
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 16 2 -3
 BITMAP
+0040
 0030
-0110
-0690
-7890
-4790
-2890
+0190
+3890
+0090
+FC90
+0F90
+0890
+1090
 2B90
-0E90
-F080
-0C10
-0410
-07F0
-0410
-07F0
-0410
+4490
+8090
+0090
+0090
+0010
+0010
 ENDCHAR
-STARTCHAR D3E3
-ENCODING 54243
+STARTCHAR uniCCF0
+ENCODING 52464
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 13 15 1 -2
 BITMAP
+0060
 0030
-0110
-0690
-7890
-4790
-2890
-2B90
-0E90
-F090
+00D0
+1E50
+0050
+7E50
+03D0
+0450
+0C50
+12D0
+2250
+CC50
+0450
+0400
+07F8
+ENDCHAR
+STARTCHAR uniCD01
+ENCODING 52481
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0020
 0190
-0080
-0180
-0260
+3890
+0090
+FC90
+0B90
+1890
+3B90
+4490
+8090
+0360
 0410
-1808
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR D3EC
-ENCODING 54252
+STARTCHAR uniCD08
+ENCODING 52488
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 12 1 0
+BBX 15 11 1 0
 BITMAP
-0010
-3FF8
+03C0
 0000
-0020
-0440
-0440
-0040
-3FF8
-0100
+3FF0
+0060
+0080
+0380
+0C78
+3100
 0100
 0100
 FFFE
 ENDCHAR
-STARTCHAR D3ED
-ENCODING 54253
+STARTCHAR uniCD09
+ENCODING 52489
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0010
-1FF8
-0840
-0440
-0480
-1FF0
-0100
+0780
+0060
+1FC0
+0180
+0E7C
+3100
 0100
 FFFE
-2000
+0000
 3FE0
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR D3F0
-ENCODING 54256
+STARTCHAR uniCD0C
+ENCODING 52492
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 15 14 1 -2
 BITMAP
-2078
-1FE0
-0440
-0480
+0380
+0000
 1FF0
-0100
-0100
+0060
+0180
+0678
+1904
+2104
 FFFE
-6000
+0000
 0800
 0800
 0800
-07F8
+0FF8
 ENDCHAR
-STARTCHAR D3F4
-ENCODING 54260
+STARTCHAR uniCD10
+ENCODING 52496
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0010
-1FF0
-0840
-0440
-0480
-1B60
-0100
+03C0
+3FE0
+00C0
+0180
+0E7C
+7100
+0104
 FFFE
 0000
-0000
-0FE0
+1FE0
 0020
 1FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR D3FC
-ENCODING 54268
+STARTCHAR uniCD18
+ENCODING 52504
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
-1FF8
-0040
-0480
-0680
-3FF0
-0100
+03C0
+1FE0
+00C0
+0180
+0E78
+7100
 0100
 FFFE
 0000
 1FE0
 0820
 0820
-0840
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR D3FD
-ENCODING 54269
+STARTCHAR uniCD19
+ENCODING 52505
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 15 1 -3
 BITMAP
-0010
-1FF0
-0840
-0440
-0480
-1B60
-0100
-FFFE
-0000
-1860
+0380
+1FE0
+0040
+0180
+0F78
+7100
+817E
+7F80
+3820
 0820
 0FE0
 0820
@@ -130652,253 +134001,345 @@
 0FE0
 0820
 ENDCHAR
-STARTCHAR D3FF
-ENCODING 54271
+STARTCHAR uniCD1B
+ENCODING 52507
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF8
-0000
-0460
-0440
-0040
-0FB0
+0780
+3FE0
+00C0
+0180
+0678
+3900
 0100
 FFFE
-0200
-0100
+0000
 0300
-06C0
-0830
-3018
+0100
+02C0
+0C30
+1008
 ENDCHAR
-STARTCHAR D401
-ENCODING 54273
+STARTCHAR uniCD1D
+ENCODING 52509
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF8
-0840
-0440
-0480
-01F0
-0F00
-0100
+0780
+3FE0
+00C0
+0300
+0CF8
+7100
+0104
 FFFE
 0100
-07C0
-0C60
+06C0
+0820
 0820
 0C60
-07C0
+0380
 ENDCHAR
-STARTCHAR D408
-ENCODING 54280
+STARTCHAR uniCD24
+ENCODING 52516
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -2
 BITMAP
-0060
-00D0
-7FD0
+0030
+0010
+0F10
+0010
+3F90
+0110
 0210
-1310
-0A10
-0A90
-7D16
-0418
-0430
-8FD0
-7010
+0F16
+1CD8
+E410
+05F0
+7A10
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR D41D
-ENCODING 54301
+STARTCHAR uniCD28
+ENCODING 52520
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0060
-0120
-FF20
+0020
+1E20
+0020
+7E20
+0C20
+13AC
+6C30
+09A0
+FE20
+0020
+1820
+0800
+0800
+07F0
+ENDCHAR
+STARTCHAR uniCD2C
+ENCODING 52524
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+1E20
+0020
+7F20
 0420
-2220
-1420
-FF20
-0838
-0FA0
-F120
-06C0
-0820
-0820
-0C60
-07C0
+1BA4
+6C38
+0460
+FFA0
+0000
+1FE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR D440
-ENCODING 54336
+STARTCHAR uniCD39
+ENCODING 52537
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -2
+BITMAP
+0030
+0F10
+3F90
+0110
+0610
+1FD0
+223C
+FFD0
+0010
+01E0
+0210
+0210
+0330
+01E0
+ENDCHAR
+STARTCHAR uniCD5C
+ENCODING 52572
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0060
-0090
+0010
+0E10
+0010
 7F90
-0210
-1310
-1210
-1290
-7F10
-0410
-0430
-8FD0
-7010
+0310
+0610
+0F10
+3CD0
+C410
+07D0
+7810
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR D444
-ENCODING 54340
+STARTCHAR uniCD60
+ENCODING 52576
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 12 15 3 -2
 BITMAP
-0018
-0048
-3FC8
-0108
-0A08
-0BC8
-7408
-0418
-8FE8
-7008
-0008
-0600
-0200
-0200
-03FC
+0060
+0020
+1C20
+0020
+7E20
+0820
+37A0
+C820
+1FE0
+E020
+0020
+1800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR D45C
-ENCODING 54364
+STARTCHAR uniCD64
+ENCODING 52580
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 12 2 0
+BBX 13 15 2 -2
 BITMAP
+0030
+1E10
+0010
+7F10
+0210
+0C10
+37D0
+C4F0
+FF10
+0000
+0FF0
 0020
-7FF0
-10C0
-1080
-0880
-0900
-7FF0
-18C0
-0840
-0840
-0848
-FFFC
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR D460
-ENCODING 54368
+STARTCHAR uniCD6C
+ENCODING 52588
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 13 1 -1
+BBX 12 16 2 -3
 BITMAP
-0018
-1FF8
-0460
-0440
-0040
-0FF0
-0440
-FFFE
+0030
+1E10
+0010
+7F10
+0310
+0C10
+17D0
+E4F0
+FB10
 0000
-0800
-0800
-0800
-0FF8
+0FF0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR D464
-ENCODING 54372
+STARTCHAR uniCD6D
+ENCODING 52589
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 12 16 2 -3
 BITMAP
-1FF8
-0040
-0440
-0480
-01E0
-1E40
-0440
-FFFE
-1FE0
-0020
-0020
-0FE0
-0800
-0FF0
+0030
+1E10
+0010
+7F10
+0210
+0C10
+3790
+C4F0
+FF10
+0C20
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR D46D
-ENCODING 54381
+STARTCHAR uniCD6F
+ENCODING 52591
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 2 -3
+BITMAP
+0030
+0010
+1E10
+0710
+3E10
+0F90
+3C10
+C4F0
+FF10
+0010
+0180
+0180
+0240
+0430
+0808
+1000
+ENDCHAR
+STARTCHAR uniCD71
+ENCODING 52593
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -2
+BITMAP
+0030
+1E10
+7F10
+0210
+0C10
+33D0
+C410
+04F0
+FB10
+03D0
+0420
+0420
+0620
+03C0
+ENDCHAR
+STARTCHAR uniCD78
+ENCODING 52600
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 12 2 0
+BITMAP
+0780
+0000
+0000
+3FE0
+00C0
+0180
+0380
+0C78
+70C0
+0840
+0848
+FFFC
+ENDCHAR
+STARTCHAR uniCD88
+ENCODING 52616
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
-1FF8
-0060
-0440
-0440
-01F0
-0E40
+03C0
+1FE0
+0040
+0180
+0678
+38C0
 0440
 FFFE
-1860
-0820
-0FE0
+2000
+1FE0
 0820
 0820
+0840
 0FE0
-0820
+0800
 ENDCHAR
-STARTCHAR D46F
-ENCODING 54383
+STARTCHAR uniCD94
+ENCODING 52628
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
-BITMAP
-1FF8
-0060
-0440
-0440
-01F0
-0E40
-0440
-FFFE
-0200
-0100
-0300
-06C0
-0830
-3008
-ENDCHAR
-STARTCHAR D478
-ENCODING 54392
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
 BITMAP
-0010
-3FF8
-0080
-0840
-0440
-0480
-3FF0
-0000
+03C0
+3FE0
+00C0
+0180
+0678
+3800
+0004
 FFFE
 0100
 0100
@@ -130907,941 +134348,1028 @@
 0100
 0100
 ENDCHAR
-STARTCHAR D479
-ENCODING 54393
+STARTCHAR uniCD95
+ENCODING 52629
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 14 1 -2
 BITMAP
-0010
-3FF0
-0840
-0440
-0480
+0380
 1FF0
+0040
+0180
+0E78
+7000
 0000
 FFFE
 0100
-0100
-3FE0
-0020
+1FE0
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR D47C
-ENCODING 54396
+STARTCHAR uniCD98
+ENCODING 52632
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0010
-3FF8
-0060
-0440
-0480
-1FF0
-0000
-0000
+0780
+3FE0
+00C0
+0100
+06F8
+3800
+000C
 FFFE
 0100
 0100
-0900
-0900
+1900
 0900
-07F8
+0810
+0FF8
 ENDCHAR
-STARTCHAR D47F
-ENCODING 54399
+STARTCHAR uniCD9C
+ENCODING 52636
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 14 1 -2
 BITMAP
-0010
-3FF8
-0060
-0440
-0480
-1FF0
-0000
-803E
-7FC0
+0780
+3FE0
+00C0
 0100
-0160
-1E80
-0800
-0800
-0FF0
-ENDCHAR
-STARTCHAR D480
-ENCODING 54400
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -2
-BITMAP
-0010
-1FF8
-0840
-0440
-0480
-1FF0
-0004
+0EF8
+7004
 FFFE
 0100
+0100
 1FE0
 0020
-0020
 1FE0
 0800
 0FF0
 ENDCHAR
-STARTCHAR D482
-ENCODING 54402
+STARTCHAR uniCDA4
+ENCODING 52644
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 16 1 -3
 BITMAP
-0010
-1FF8
-0860
-0440
-0490
-1FF0
+0780
 0000
-FFFE
-0100
-0100
-1EF8
-2288
-1C90
-1690
-08F0
-0080
+3FE0
+0040
+0180
+0678
+3804
+FFFE
+0100
+0100
+0FE0
+0820
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR D488
-ENCODING 54408
+STARTCHAR uniCDA5
+ENCODING 52645
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 15 1 -3
 BITMAP
-3FF8
+0380
+3FE0
 0040
-0440
-0490
-3FF0
-0000
-0004
+0180
+0E7C
+7000
 FFFE
 0100
-1F00
-08E0
+1920
+0920
+0FE0
 0820
-0840
+0820
 0FE0
-0800
+0820
 ENDCHAR
-STARTCHAR D489
-ENCODING 54409
+STARTCHAR uniCDA7
+ENCODING 52647
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 15 1 -3
 BITMAP
-0010
-3FF0
+0780
+3FE0
 0040
-0440
-0490
-1FF0
-0000
+0180
+0EFC
+7000
+0004
+FFF8
+0100
+0100
+0100
+0380
+0660
+0810
+3000
+ENDCHAR
+STARTCHAR uniCDA9
+ENCODING 52649
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+0380
+1FE0
+0040
+0180
+0678
+3800
 FFFE
 0100
-0D20
-0420
-07E0
-0420
-0420
-07E0
-0420
+0100
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR D48B
-ENCODING 54411
+STARTCHAR uniCDB0
+ENCODING 52656
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 11 15 3 -2
 BITMAP
-3FF0
-10C0
-0880
-0920
-3FF0
-0000
-0000
-FFFC
-0200
-0200
-0200
-0200
-0580
-0860
-3020
+0060
+3C20
+0020
+FF20
+0420
+1820
+67A0
+8020
+0720
+F820
+09E0
+0820
+0820
+0820
+0020
 ENDCHAR
-STARTCHAR D48D
-ENCODING 54413
+STARTCHAR uniCDC4
+ENCODING 52676
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 3 -2
 BITMAP
-3FF0
-00C0
-0880
-0880
-3FE0
+0060
+0020
+1C20
+FE20
+0420
+1C20
+6220
+8F20
+F9E0
 0000
-0008
-FFFC
-0100
-0200
-0DC0
 0840
-0C40
-0780
+0840
+18C0
+2530
+4210
 ENDCHAR
-STARTCHAR D494
-ENCODING 54420
+STARTCHAR uniCDCC
+ENCODING 52684
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 11 15 3 -2
 BITMAP
-0030
-0010
-FF90
-0610
-1210
-1410
-FF10
-0010
-0F10
-F9F0
-0810
-0810
-0810
-0810
-0010
+0060
+0320
+3920
+0120
+FD20
+1920
+3120
+4D20
+8D20
+F120
+1F20
+1120
+1120
+1120
+0020
 ENDCHAR
-STARTCHAR D4A9
-ENCODING 54441
+STARTCHAR uniCDD0
+ENCODING 52688
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0030
-0110
-FF10
-2610
-1410
-0590
-7A10
-0310
-FCF0
-0810
-0880
-0360
-0410
+0020
+01B0
+0090
+1C90
+7E90
+0C90
+1E90
+6290
+FC90
+1390
+1090
+0C90
 0410
-0630
-03E0
+0400
+07F8
 ENDCHAR
-STARTCHAR D4CC
-ENCODING 54476
+STARTCHAR uniCDE8
+ENCODING 52712
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
+0E10
 0010
 7F90
-2210
-1110
-1210
-05D0
-3A10
-01F0
-FE10
+0310
+0410
+1BD0
+6010
+0050
+FF90
 0410
 0410
 0410
 0410
 0010
 ENDCHAR
-STARTCHAR D4D0
-ENCODING 54480
+STARTCHAR uniCDEC
+ENCODING 52716
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
+1E10
 0010
-7F90
+7F10
 0210
-1210
-1390
-2C70
-FF90
-0410
+0C10
+13F0
+FF10
+6410
 0410
 0010
 0C00
 0400
 0400
-03F8
+07F8
 ENDCHAR
-STARTCHAR D4D4
-ENCODING 54484
+STARTCHAR uniCDF0
+ENCODING 52720
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 15 1 -2
 BITMAP
-0030
-0090
-3F90
-1210
-1210
-0290
-7F90
-87F0
-7C10
-0400
-0FF0
+0018
+0F08
+0008
+3F88
+0308
+0608
+19D8
+E7A8
+3A08
+0000
+0FF8
 0010
-0FF0
-0400
 07F8
+0400
+03FC
 ENDCHAR
-STARTCHAR D4DC
-ENCODING 54492
+STARTCHAR uniCDF8
+ENCODING 52728
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 16 2 -3
 BITMAP
-0060
-0020
-FF20
-2420
-2420
-0520
-FF20
-03E0
-FC20
-0800
-1FE0
-0820
-0840
-0840
-0FE0
-0800
+0030
+0E10
+0010
+7F10
+0210
+0E10
+11D0
+E070
+8F90
+7400
+0FF0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR D4DF
-ENCODING 54495
+STARTCHAR uniCDF9
+ENCODING 52729
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-7F90
+0E10
+0010
+7F10
 0210
-1210
-1290
-7F90
-0030
-FFD0
+0C10
+13D0
+E070
+9F90
+6430
 0410
-0590
-0080
-0180
-0240
-0430
-1808
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D4E8
-ENCODING 54504
+STARTCHAR uniCDFB
+ENCODING 52731
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 14 15 1 -2
 BITMAP
-7FF0
-10C0
-0880
-08A0
-3FF0
+0018
+0F08
+0008
+3F88
+0308
+0608
+19D8
+EFA8
+3208
+0288
+0040
+00A0
+0110
+0208
+0C04
+ENDCHAR
+STARTCHAR uniCDFD
+ENCODING 52733
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0020
+1E10
+0010
+7F10
+0610
+0C10
+33B0
+DF50
+E810
+0890
+0360
+0410
+0410
+0630
+03E0
+ENDCHAR
+STARTCHAR uniCE04
+ENCODING 52740
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0780
 0000
-0004
+3FE0
+00C0
+0300
+0CF8
+7008
 FFFC
+4840
 0840
 0840
 0840
 0840
 0840
-0840
-0040
 ENDCHAR
-STARTCHAR D4EC
-ENCODING 54508
+STARTCHAR uniCE08
+ENCODING 52744
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF8
-0000
-0040
-0440
-0480
-3FF0
+0780
+3FE0
+00C0
+0100
+06F8
+3800
 0000
 FFFE
-0440
 0840
-3040
+0840
+3840
 1040
 1000
-1FF0
+0FF0
 ENDCHAR
-STARTCHAR D4F0
-ENCODING 54512
+STARTCHAR uniCE0C
+ENCODING 52748
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 15 2 -3
 BITMAP
-1FF8
+0700
+7FC0
+0080
+0300
+1CF0
+E008
+FFF4
+0880
+0880
+3FC0
 0040
-0440
-0440
+3FC0
+1000
+1000
 1FF0
-0000
-FFFE
-0440
-1FC0
-0020
-0020
-0FE0
-0800
-0FF0
 ENDCHAR
-STARTCHAR D4F8
-ENCODING 54520
+STARTCHAR uniCE14
+ENCODING 52756
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 15 15 1 -3
 BITMAP
-3FF0
-1080
-0880
-0900
+0380
+3FE0
+0040
+0180
+0E78
+7000
+803E
 7FE0
-0008
-FFFC
-0880
-0880
-1FC0
-1040
-1040
-1FC0
+0400
+0FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR D4FB
-ENCODING 54523
+STARTCHAR uniCE19
+ENCODING 52761
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF8
-0840
-0440
-0480
-1FF8
-0004
-FFFE
-0840
-0A40
-0180
+0380
+3FE0
+0040
 0180
-0240
-0C30
-1008
+0E78
+7000
+803E
+7FE0
+0520
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR D4FD
-ENCODING 54525
+STARTCHAR uniCE20
+ENCODING 52768
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 15 11 1 0
 BITMAP
-1FF8
-0020
-0440
-0440
-1FF8
+07C0
+0000
+3FF0
+0060
+00C0
+0100
+06F8
+3800
 0000
 0000
 FFFE
-04A0
-07E0
-0420
-0420
-0620
-03C0
 ENDCHAR
-STARTCHAR D504
-ENCODING 54532
+STARTCHAR uniCE21
+ENCODING 52769
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 11 2 0
+BBX 15 15 1 -3
 BITMAP
-7FF0
-0000
-0040
-0880
-0880
-0900
-7FF0
-0000
+0380
+1FF0
+0060
+0180
+0678
+3800
 0000
+FFFE
 0000
-FFFC
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D508
-ENCODING 54536
+STARTCHAR uniCE24
+ENCODING 52772
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 15 14 1 -2
 BITMAP
-7FF0
-0000
-00C0
-0880
-0880
-3FF0
+0780
 0000
-FFFC
+3FE0
+0080
+0778
+3804
+83FE
+FF00
+2000
 0000
-3000
-1000
-1000
-1FF0
+1800
+0800
+0810
+0FF8
 ENDCHAR
-STARTCHAR D50C
-ENCODING 54540
+STARTCHAR uniCE28
+ENCODING 52776
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-1FF8
-0840
-0440
-0480
-1FF0
-0000
+0380
+3FE0
+0040
+0180
+0E78
+7004
 FFFE
+2000
 0000
 1FE0
 0020
 1FE0
 0800
-0800
 0FF0
 ENDCHAR
-STARTCHAR D514
-ENCODING 54548
+STARTCHAR uniCE30
+ENCODING 52784
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
+BITMAP
+0700
+7FC0
+0080
+0300
+0CF0
+F000
+FFFC
+0000
+0000
+3FC0
+1040
+1040
+1080
+1FC0
+1000
+ENDCHAR
+STARTCHAR uniCE31
+ENCODING 52785
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 16 1 -3
 BITMAP
-0010
-3FF8
-0040
-0440
-0480
-31F8
-0E00
+0380
 0000
+3FE0
+0040
+0180
+0EFC
+7000
 FFFE
 0000
-1FE0
+1820
 0820
+0FE0
 0820
 0820
 0FE0
-0800
+0820
 ENDCHAR
-STARTCHAR D515
-ENCODING 54549
+STARTCHAR uniCE33
+ENCODING 52787
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 14 14 2 -2
 BITMAP
-7FF0
+0F00
+7FC0
 0080
-0880
-0900
-3FE0
+0300
+0CF0
+7000
 0000
 FFFC
-0000
-1840
-0840
-0FC0
-0840
-0840
-0FC0
-0840
+4000
+0200
+0200
+0580
+0860
+3010
 ENDCHAR
-STARTCHAR D517
-ENCODING 54551
+STARTCHAR uniCE35
+ENCODING 52789
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 15 14 1 -2
 BITMAP
-0038
-0FE0
-0440
-0440
-01F8
-0E00
+0780
+3FF0
+0040
+0180
+0E78
+7000
 0004
 FFFE
-0300
 0100
-0380
-0660
-0830
-3000
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR D53C
-ENCODING 54588
+STARTCHAR uniCE58
+ENCODING 52824
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0040
 0030
-0190
-FF90
 0010
-2110
-2110
-1110
-1210
-12F0
-FD10
+1E10
 0010
+7F10
+0310
+0610
+0C10
+1A10
+2110
+4090
+8010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR D53D
-ENCODING 54589
+STARTCHAR uniCE59
+ENCODING 52825
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0060
-0190
-FF90
+0030
+1E10
+0010
+0010
+7F10
 0210
-2110
-1110
-1210
-13F0
-FC10
-0000
+0410
+0A10
+3190
 7FE0
-0020
+9020
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR D540
-ENCODING 54592
+STARTCHAR uniCE5C
+ENCODING 52828
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0060
 0010
-0190
-FF90
-2310
-2110
-1210
-1270
-1F90
-6010
+1E10
 0010
-1810
+7F10
+0210
+0410
+0C10
+1210
+6110
+9010
+0810
 0800
 0800
-0FF8
+07F8
 ENDCHAR
-STARTCHAR D544
-ENCODING 54596
+STARTCHAR uniCE5F
+ENCODING 52831
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
-0190
-FF90
+3C20
+0020
+FE20
+0420
+0820
+1420
+6320
+8020
+0040
+1FC0
+1000
+1000
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniCE60
+ENCODING 52832
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+0060
+3C20
+0020
+FE20
+0420
+0820
+1420
+6220
+8000
+3FC0
+0040
+3FC0
+1000
+1000
+1FE0
+ENDCHAR
+STARTCHAR uniCE61
+ENCODING 52833
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0018
+0F08
+0008
+3F88
+0188
+0308
+0508
+08C8
+3048
+C000
+1EF0
 0210
-2110
+1C10
 1110
-1210
-03F0
-7C10
-1FF0
-0020
-1FF0
-0800
-0800
-0FF8
+1E10
 ENDCHAR
-STARTCHAR D54C
-ENCODING 54604
+STARTCHAR uniCE68
+ENCODING 52840
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0060
-0190
-7F90
+0030
+1E10
 0010
-2310
-1210
-1210
-03F0
-FC10
-0000
-0FF0
+0010
+7F10
+0210
 0410
+0A10
+1110
+6080
+8FF0
 0410
-0420
+0410
+0410
 07F0
 0400
 ENDCHAR
-STARTCHAR D54D
-ENCODING 54605
+STARTCHAR uniCE69
+ENCODING 52841
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 16 2 -3
 BITMAP
-0080
-0060
-0320
-FC20
-4220
-2220
-2420
-07E0
-F820
-3060
-1020
-1FE0
-1020
-1FE0
-1020
+0030
+1E10
+0010
+0010
+7F10
+0210
+0410
+0A10
+1180
+6C10
+8410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D54F
-ENCODING 54607
+STARTCHAR uniCE6B
+ENCODING 52843
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
-0060
-0010
-0090
-FF90
-2110
-2110
-1210
-12F0
-FD10
-0090
-0090
+0030
+1010
+0E10
+7F10
+0210
+0410
+0A10
+1190
+6090
+8110
 0180
-0360
-0418
-1808
+0100
+06C0
+0C30
+1010
+2000
 ENDCHAR
-STARTCHAR D551
-ENCODING 54609
+STARTCHAR uniCE6D
+ENCODING 52845
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-00C0
-0120
-FF20
+0030
+0010
+1E10
+0010
+7F10
+0210
+0410
+0A10
+1190
+6090
+8360
 0420
-4220
-2220
-2420
-07E0
-F820
-0120
-0680
-0840
-0840
-0CC0
-0780
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR D558
-ENCODING 54616
+STARTCHAR uniCE74
+ENCODING 52852
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0060
+00C0
 0020
-1E20
-01A0
-FFA0
 0020
+7F20
+0320
+0220
+0620
+FC2C
+0830
 0820
-363C
-4120
-4120
-6320
-3E20
-0020
+1020
+2020
+4020
 0020
 0020
 ENDCHAR
-STARTCHAR D559
-ENCODING 54617
+STARTCHAR uniCE75
+ENCODING 52853
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 15 16 1 -3
 BITMAP
 0060
-3C20
-0020
-FFE0
-1820
-6624
-4138
-6320
-3E20
-0000
-3FE0
-0020
-0020
-0020
-0020
-0020
+0010
+7F90
+0110
+0210
+FE16
+0418
+0810
+1010
+2000
+5FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D55C
-ENCODING 54620
+STARTCHAR uniCE78
+ENCODING 52856
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -2
 BITMAP
 0060
-0020
-1E20
-0020
-FFA0
-1C20
-6324
-4138
-6320
-3E20
-0020
-0C00
-0400
+0010
+0010
+3F90
+0110
+0110
+FE10
+041E
+0410
+0810
+1C10
+2410
 0400
-07F8
+0408
+03FC
 ENDCHAR
-STARTCHAR D560
-ENCODING 54624
+STARTCHAR uniCE7C
+ENCODING 52860
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0060
-1C20
+00C0
 0020
-FFA0
-1820
-263C
-4220
-2220
-3C00
-1FE0
+7F20
+0220
+0420
+FC20
+0838
+1020
+2000
+5FE0
 0020
-0040
 1FE0
 0800
-0FF0
-ENDCHAR
-STARTCHAR D565
-ENCODING 54629
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 15 2 -2
-BITMAP
-0060
-1C20
-0020
-FFA0
-0820
-7420
-423C
-6220
-3C20
-0000
-3DE0
-0900
-31E0
-2300
-3DF0
+0800
+0FF8
 ENDCHAR
-STARTCHAR D568
-ENCODING 54632
+STARTCHAR uniCE84
+ENCODING 52868
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
 0060
-3C20
-0120
-FE20
-3C20
-4224
-4238
-6220
-3C20
-0000
-1FE0
+0020
+7F20
+0220
+0220
+FC2C
+0830
+1020
+2020
+4000
+8FE0
 0820
 0840
 0840
 0FE0
 0800
 ENDCHAR
-STARTCHAR D569
-ENCODING 54633
+STARTCHAR uniCE85
+ENCODING 52869
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 16 2 -3
 BITMAP
-0060
-3C20
-0120
-FE20
-3C20
-422C
-4230
-6220
-3C00
+00C0
+0020
+7F20
+0220
+0620
+FC20
+083C
 1020
+2000
+5820
 0820
 0FE0
 0820
@@ -131849,446 +135377,466 @@
 0FE0
 0820
 ENDCHAR
-STARTCHAR D56B
-ENCODING 54635
+STARTCHAR uniCE87
+ENCODING 52871
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 16 2 -3
 BITMAP
-0060
-1E20
-0020
-87A0
-7820
-3C20
-423C
-4220
-6220
-3D20
 0080
-0180
-0260
-0410
-1808
+0060
+7F20
+0220
+0620
+FC20
+083C
+1020
+2020
+C320
+0120
+0300
+06C0
+0830
+1010
+2000
 ENDCHAR
-STARTCHAR D56D
-ENCODING 54637
+STARTCHAR uniCE89
+ENCODING 52873
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
-0060
-2020
-1C20
-FF20
+00C0
+0020
+7F20
+0220
+0620
+FC24
+0838
+1020
+2120
+4100
+86C0
 0820
-3C20
-423C
-4220
-2620
-18A0
-03C0
-0420
-0420
-0660
+0820
+0C60
 03C0
 ENDCHAR
-STARTCHAR D574
-ENCODING 54644
+STARTCHAR uniCE90
+ENCODING 52880
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -3
+BBX 13 15 1 -2
 BITMAP
 0018
 00C8
-1C48
 0048
-FF48
+7F48
+0248
+0248
+9C48
+6478
 0848
-3C48
-4278
-4248
-6248
-3C48
-0048
+1048
+2048
+4048
 0048
 0048
 0008
 ENDCHAR
-STARTCHAR D575
-ENCODING 54645
+STARTCHAR uniCE91
+ENCODING 52881
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 16 1 -3
 BITMAP
-0030
-0090
-3890
-FE90
-3090
-4890
-84F0
-4490
-7890
-0080
-1FF0
-0010
-0010
-0010
 0010
-0010
+00C8
+0048
+3E48
+0248
+BC48
+4478
+0848
+1048
+2048
+0FF8
+0008
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR D578
-ENCODING 54648
+STARTCHAR uniCE94
+ENCODING 52884
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0060
-0030
-3C90
+0020
+0110
 0090
-FF90
+FC90
+0490
 0890
-3490
-42F0
-4290
-3C90
-0090
+F890
+10F0
+2090
+4090
+8090
 1890
 0800
 0800
 0FF8
 ENDCHAR
-STARTCHAR D57C
-ENCODING 54652
+STARTCHAR uniCE98
+ENCODING 52888
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 13 15 2 -2
 BITMAP
-0070
-0090
-3890
-1E90
-F090
-3C90
-44F0
-4490
-3890
+0030
+0190
 0090
-1FF0
-0020
-1FF0
-0800
+7E90
+0490
+0490
+F8F0
+1090
+1090
+2770
+4020
 0FF0
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR D584
-ENCODING 54660
+STARTCHAR uniCEA0
+ENCODING 52896
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 16 2 -3
 BITMAP
-0060
-0220
-7920
-0120
-FF20
-3120
-4920
-85E0
-4520
-7920
-1FE0
-0840
-0840
-0840
-0FE0
-0800
+0070
+0190
+0090
+7E90
+0490
+0490
+F8F0
+0890
+1090
+2090
+4FF0
+0410
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR D585
-ENCODING 54661
+STARTCHAR uniCEA1
+ENCODING 52897
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0030
-0090
-3890
+0070
+0110
 0090
 FE90
+0490
+0490
+F8F0
 1090
-6CF0
-4490
-4490
-3C30
-0410
+1090
+28B0
+4410
 07F0
 0410
-0410
 07F0
 0410
 ENDCHAR
-STARTCHAR D587
-ENCODING 54663
+STARTCHAR uniCEA3
+ENCODING 52899
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 1 -2
 BITMAP
-0060
-0120
-7920
+0010
+00C8
+0048
+3E48
+0248
+FC48
+0478
+0848
+1048
+2088
+0040
+00C0
 0120
-FF20
-7920
-C5E0
-8520
-4520
-7820
-0320
-0300
-0480
-0860
-3030
+0218
+0C0C
 ENDCHAR
-STARTCHAR D588
-ENCODING 54664
+STARTCHAR uniCEA4
+ENCODING 52900
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 13 15 2 -2
 BITMAP
-0260
-0120
-0120
-7920
-DF20
-3120
-4DE0
-8520
-4520
-7800
-0840
-0840
-1EA0
-2310
-4210
+0030
+0190
+0090
+7E90
+0490
+F890
+08F0
+1090
+2090
+4090
+0430
+0420
+0C60
+1298
+2108
 ENDCHAR
-STARTCHAR D589
-ENCODING 54665
+STARTCHAR uniCEA5
+ENCODING 52901
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 14 2 -2
 BITMAP
-0030
+0130
 0090
-3890
 0090
-FC90
-1890
-64F0
-4490
-4490
-3890
-03C0
-0420
-0420
-0620
-03C0
+7C90
+0490
+F8F0
+0890
+1090
+2090
+4360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR D590
-ENCODING 54672
+STARTCHAR uniCEAC
+ENCODING 52908
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 15 2 -2
 BITMAP
 0060
 0020
-1C20
-00A0
-FFA0
-083C
-3E20
-6320
-4120
-412C
-6330
-1E20
 0020
+7F20
+0220
+023C
+0C20
+F420
+0820
+083C
+1020
+2020
+4020
 0020
 0020
 ENDCHAR
-STARTCHAR D5A5
-ENCODING 54693
+STARTCHAR uniCEAD
+ENCODING 52909
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 16 1 -3
 BITMAP
-0060
-3820
-0420
-FFA0
-083C
-3420
-4220
-422C
-6630
-18A0
-0340
-0420
-0420
-0660
-03C0
+0030
+0010
+0010
+3F10
+021E
+8E10
+7410
+0816
+1018
+2000
+5FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D5C8
-ENCODING 54728
+STARTCHAR uniCEC1
+ENCODING 52929
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 2 -2
+BBX 14 15 2 -2
 BITMAP
 0060
 0020
-3C20
-0120
-FFA0
+7F20
+0224
+0638
+FC20
 0820
-3420
-43E0
-4220
-6620
-3C20
-0020
-0020
-0020
-0020
+103C
+2020
+4100
+86C0
+0820
+0820
+0C60
+03C0
 ENDCHAR
-STARTCHAR D5C9
-ENCODING 54729
+STARTCHAR uniCEE4
+ENCODING 52964
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-1810
-0490
-FFD0
-1810
-66F0
-4110
-6310
-3E10
-0000
-1FF0
-0010
 0010
 0010
+7F10
+0210
+0210
+3C10
+44F0
+0810
+1010
+2010
+4010
+8010
 0010
 0010
 ENDCHAR
-STARTCHAR D5CC
-ENCODING 54732
+STARTCHAR uniCEE5
+ENCODING 52965
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 13 15 1 -2
 BITMAP
-0060
-3C20
-0020
-FF20
-0820
-3C20
-43E0
-4220
-4220
-3C20
-0020
-0C20
-0400
-0400
-03FC
+0018
+0008
+3F88
+0108
+0108
+FEF8
+0608
+0408
+0808
+3FF8
+0408
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR D5D0
-ENCODING 54736
+STARTCHAR uniCEE8
+ENCODING 52968
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 15 2 -2
 BITMAP
-0060
-3820
-0020
-FE20
-7820
-C5E0
-8420
-4420
-7820
-3FC0
-0040
-0040
-3FC0
-1000
-1FF0
+0030
+0010
+7F10
+0210
+0610
+FC30
+08D0
+0810
+1010
+2010
+C010
+1800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR D5D2
-ENCODING 54738
+STARTCHAR uniCEEB
+ENCODING 52971
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-3C10
 0010
-FF90
-3C10
-63F0
-4210
-6210
-3C10
-0000
-09F0
-3510
-6920
-3120
-2DE0
-1100
+7F10
+0210
+0210
+FCF0
+0810
+1810
+2010
+4020
+0FF0
+0800
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR D5D8
-ENCODING 54744
+STARTCHAR uniCEEC
+ENCODING 52972
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-3810
-0510
-FF10
-3C10
-42F0
-4210
-4210
-3C10
-0000
+0010
+7F10
+0310
+0210
+FCF0
+0410
+0810
+1000
+7FE0
+8020
+1FE0
+0800
+0800
 0FF0
+ENDCHAR
+STARTCHAR uniCEF4
+ENCODING 52980
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
+BITMAP
+0018
+0008
+7F08
+0108
+0208
+FEF8
+0408
+0808
+1008
+6000
+87F0
 0410
 0410
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR D5D9
-ENCODING 54745
+STARTCHAR uniCEF5
+ENCODING 52981
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-3C10
 0010
-FF10
-3810
-44F0
-4210
-6210
-3C10
+7F10
+0210
+0210
+FCF0
 0810
+1810
+2000
+4C10
 0410
 07F0
 0410
@@ -132296,15239 +135844,15929 @@
 07F0
 0410
 ENDCHAR
-STARTCHAR D5DB
-ENCODING 54747
+STARTCHAR uniCEF7
+ENCODING 52983
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
-0020
+0030
 0010
-1E10
-0090
-FF10
-1EF0
-2110
-2110
-3110
-1E10
+7F10
+0210
+0210
+FDF0
+0810
+1810
+2010
+4190
 0080
 0180
-0340
-0430
+0260
+0410
 1808
 ENDCHAR
-STARTCHAR D5DD
-ENCODING 54749
+STARTCHAR uniCEF8
+ENCODING 52984
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0010
+7F10
+0310
+0210
+FCF0
+0810
+1010
+2000
+4430
+0420
+0C20
+1250
+2088
+4100
+ENDCHAR
+STARTCHAR uniCEF9
+ENCODING 52985
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-3C10
-0110
-FE10
-1C10
-62F0
-4210
-4210
-3C10
-0090
-03C0
+0010
+7F10
+0210
+0210
+FCF0
+0810
+1010
+2010
+4090
+0340
 0420
 0420
-0620
+0660
 03C0
 ENDCHAR
-STARTCHAR D5E4
-ENCODING 54756
+STARTCHAR uniCF00
+ENCODING 52992
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-0018
-00C8
-1C48
-0048
-0148
-FF48
-1C48
-23C8
-2248
-3248
-1C48
-0048
-0048
-0048
-0008
+0040
+01B0
+0090
+FE90
+0490
+0490
+1890
+EF90
+1090
+2090
+2090
+C090
+0090
+0090
+0010
+0010
 ENDCHAR
-STARTCHAR D5E5
-ENCODING 54757
+STARTCHAR uniCF01
+ENCODING 52993
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
-0060
+0020
 0030
-3890
-1E90
-F090
-3890
-4790
-4490
-3890
-0090
-1FF0
+0190
+FC90
+0490
+0890
+FF90
+1090
+2090
+4090
+9FF0
 0810
 0010
 0010
 0010
 0010
 ENDCHAR
-STARTCHAR D5E8
-ENCODING 54760
+STARTCHAR uniCF04
+ENCODING 52996
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
+0060
+01B0
+0090
+7E90
+0490
+0490
+FF90
+1890
+1090
+2090
+7090
+0890
+0800
+0800
+07F8
+ENDCHAR
+STARTCHAR uniCF08
+ENCODING 53000
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0010
+0098
+0048
+7E48
+0648
+0448
+FFC8
+0848
+1FF0
+2010
+4010
+0FF0
+0400
+0400
+07F8
+ENDCHAR
+STARTCHAR uniCF10
+ENCODING 53008
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0020
 0030
 0190
-3890
-0090
-FE90
-3090
-4C90
-4790
-4490
-3890
-0090
+FC90
+0490
+0890
+FF90
+1090
+2090
+4090
+87F0
 0410
-0400
-0408
-03F8
+0420
+0420
+07F0
 ENDCHAR
-STARTCHAR D5EC
-ENCODING 54764
+STARTCHAR uniCF11
+ENCODING 53009
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 12 15 2 -2
+BITMAP
+0020
+0030
+0190
+FC90
+0490
+0890
+FF90
+1090
+2090
+4890
+8410
+07F0
+0410
+07F0
+0410
+ENDCHAR
+STARTCHAR uniCF13
+ENCODING 53011
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0020
+0030
+0090
+FC90
+0490
+0890
+FF90
+1090
+2090
+4190
+8100
+0380
+0240
+0C30
+1008
+ENDCHAR
+STARTCHAR uniCF15
+ENCODING 53013
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0020
+0030
+0190
+FC90
+0490
+0890
+FF90
+1090
+2090
+4090
+8340
+0420
+0420
+0660
+03C0
+ENDCHAR
+STARTCHAR uniCF1C
+ENCODING 53020
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
 BITMAP
 00C0
-0320
-3920
+0020
+0020
+FE20
+0220
+07E0
 1D20
-E120
-7920
-8F20
-8920
-7120
-1FE0
-0040
-1FE0
+E820
+0820
+13E0
+2020
+4020
+8020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniCF20
+ENCODING 53024
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0010
+7F10
+0110
+03F0
+FE10
+0410
+0810
+11F0
+2010
+7810
+0810
 0800
 0800
+07F8
+ENDCHAR
+STARTCHAR uniCF24
+ENCODING 53028
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+0010
+7F10
+0110
+03F0
+FE10
+0410
+08F0
+1010
+2FF0
+C010
 0FF0
+0400
+0408
+07F8
+ENDCHAR
+STARTCHAR uniCF2C
+ENCODING 53036
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+7F10
+0170
+0290
+FE10
+0410
+09F0
+1010
+6010
+07F0
+0410
+0420
+0420
+07F0
 ENDCHAR
-STARTCHAR D5F4
-ENCODING 54772
+STARTCHAR uniCF2D
+ENCODING 53037
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 11 15 3 -2
 BITMAP
-0060
-01B0
-0090
-3890
-DE90
-3590
-4E90
-4490
-3890
-0090
-0FF0
-0410
-0410
+00C0
+0020
+FE20
 0420
-07F0
-0400
+07E0
+0C20
+F820
+1060
+23A0
+7020
+9020
+1FE0
+1020
+1FE0
+1020
 ENDCHAR
-STARTCHAR D5F5
-ENCODING 54773
+STARTCHAR uniCF2F
+ENCODING 53039
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0060
-01B0
-3890
-0090
-FC90
-7F90
-4490
-4490
-7890
+0020
+0010
+0010
+7E10
+03F0
+0C10
+F410
 0810
-0410
-07F0
-0410
-0410
-07F0
-0410
+11F0
+2110
+C190
+0190
+0240
+0430
+1818
 ENDCHAR
-STARTCHAR D5F7
-ENCODING 54775
+STARTCHAR uniCF30
+ENCODING 53040
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
-0070
-0110
-3890
-0090
-FE90
-3090
-4F90
-4490
-3890
-0310
-0110
-0300
-06C0
-0830
+0020
+0010
+7F10
+0210
+03F0
+FE10
+0410
+09F0
 1010
-2000
+2860
+C420
+0C20
+1A50
+2198
+4108
 ENDCHAR
-STARTCHAR D5F9
-ENCODING 54777
+STARTCHAR uniCF31
+ENCODING 53041
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0060
-0130
-0090
-3890
-DE90
-7490
-CB90
-C490
-7890
-0090
-03E0
-0430
+0030
+0010
+7F10
+01F0
+0290
+FC10
+0410
+08F0
+3010
+4090
+0360
+0410
 0410
 0630
-03E0
+01C0
 ENDCHAR
-STARTCHAR D600
-ENCODING 54784
+STARTCHAR uniCF38
+ENCODING 53048
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0020
-0010
-3C10
-0110
-FF10
-0810
-36F0
-4210
-4310
-63F0
-3C10
+0060
+01B0
+0090
+FC90
+0490
+0490
+1B90
+E890
+1090
+2790
+2090
+C090
+0090
+0090
 0010
+ENDCHAR
+STARTCHAR uniCF54
+ENCODING 53076
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 10 2 1
+BITMAP
+3FF8
 0010
 0010
 0010
+7FE0
+0020
+0220
+0200
+0200
+FFFC
 ENDCHAR
-STARTCHAR D601
-ENCODING 54785
+STARTCHAR uniCF55
+ENCODING 53077
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 14 14 2 -2
 BITMAP
-0030
-3C10
-0110
-FE10
-1DF0
-6210
-4210
-43F0
-3C20
-0000
 3FF0
+0010
 0020
+7FE0
+0220
+0240
+FFFC
+0000
+0000
+1FE0
 0020
 0020
 0020
 0020
 ENDCHAR
-STARTCHAR D604
-ENCODING 54788
+STARTCHAR uniCF58
+ENCODING 53080
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 13 1 -1
 BITMAP
-0020
-0010
-3C10
-0390
-FC10
-3EF0
-4210
-4310
-63F0
-3C10
+1FF8
+0008
+0008
+3FF0
 0010
-0C10
-0410
-0400
-07F8
+0120
+0100
+FFFE
+3800
+0800
+0800
+0810
+0FF8
 ENDCHAR
-STARTCHAR D608
-ENCODING 54792
+STARTCHAR uniCF5C
+ENCODING 53084
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-7820
+1FF8
+0018
+0010
+3FF0
+0310
+0104
+FFFE
+0000
+1FF0
 0020
-FEE0
-3D20
-4420
-87E0
-47E0
-3820
 1FE0
-0020
-0040
-0FE0
 0800
-0FF0
+0800
+0FF8
 ENDCHAR
-STARTCHAR D610
-ENCODING 54800
+STARTCHAR uniCF64
+ENCODING 53092
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 14 1 -2
 BITMAP
-0070
-3C10
+1FF8
+0008
 0010
-FF90
-1810
-66F0
-4210
-6210
-3DF0
+3FF0
+0110
+0104
+FFFE
 0000
-0FF0
-0410
-0410
-0420
-07F0
-0400
+0000
+0FE0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR D611
-ENCODING 54801
+STARTCHAR uniCF65
+ENCODING 53093
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -3
 BITMAP
-0070
-1E10
-0010
-FF90
-1810
-6670
-4210
-4210
-3DF0
-0870
-0430
+1FF8
+0008
+0018
+3FF0
+0110
+0104
+FFFE
+0000
+0C60
+0420
 07E0
 0420
 0420
 07E0
 0420
 ENDCHAR
-STARTCHAR D613
-ENCODING 54803
+STARTCHAR uniCF67
+ENCODING 53095
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0020
-1C10
+1FF8
 0010
-0F10
-F810
-1CF0
-6210
-4210
-42F0
-3D10
-0090
-0180
-0240
-0430
-1800
+0030
+3FD0
+0020
+0100
+0100
+FFFE
+0200
+0100
+0380
+0260
+0C10
+3008
 ENDCHAR
-STARTCHAR D614
-ENCODING 54804
+STARTCHAR uniCF69
+ENCODING 53097
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0070
-3C10
+1FF8
+0018
 0010
-FF90
-1810
-64F0
-4210
-6210
-3DF0
-0040
-0420
+3FF0
+0110
+0120
+017E
+FF80
+0100
+07C0
 0C60
-0A50
-1098
-2108
-ENDCHAR
-STARTCHAR D615
-ENCODING 54805
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-1C10
-0010
-FF10
-1CF0
-6610
-4210
-43F0
-3C10
-0090
-0340
-0420
-0420
-0660
+0820
+0460
 03C0
-ENDCHAR
-STARTCHAR D61C
-ENCODING 54812
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 12 15 2 -2
-BITMAP
-0030
-0010
-0090
-3890
-0090
-FE90
-7990
-8C90
-8490
-CF90
-7890
-0090
-0090
-0090
-0010
 ENDCHAR
-STARTCHAR D620
-ENCODING 54816
+STARTCHAR uniCF70
+ENCODING 53104
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 2 -2
 BITMAP
 0060
 0020
-7B20
+0020
+7FA0
 0120
-1D20
-E120
-7720
-8920
-8F20
-7920
 0120
-0820
-0800
-0810
-07F0
+0F20
+792C
+0A30
+08E0
+FF20
+4020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D624
-ENCODING 54820
+STARTCHAR uniCF71
+ENCODING 53105
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 14 16 1 -3
 BITMAP
 0030
-0190
-3C90
-0090
-FE90
+0010
 3F90
-4490
-4790
-3C90
-0FF0
+0090
+0090
+7F10
+051C
+05F0
+FA10
+0000
+1FF0
+0810
 0010
-0020
-0FF0
-0400
-07F8
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D62D
-ENCODING 54829
+STARTCHAR uniCF74
+ENCODING 53108
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 15 15 1 -2
 BITMAP
 0030
 0010
-3990
+3F90
 0090
-FE90
-7090
-CB90
-C790
-7890
-0810
-0410
-07F0
-0410
-0410
-07F0
-0410
-ENDCHAR
-STARTCHAR D638
-ENCODING 54840
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 13 1 -1
-BITMAP
-03C0
-0000
-0000
-3FF8
+0090
+7F10
+0D16
+0878
+9F90
+6010
+0010
+0C10
+0400
+043C
 07C0
-0C60
-0820
-0820
-0440
-0380
-0100
-E1FE
-1E00
 ENDCHAR
-STARTCHAR D639
-ENCODING 54841
+STARTCHAR uniCF78
+ENCODING 53112
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0780
-0000
-3FF0
-0600
-0F80
-0880
-0880
-0480
-0300
-FFFC
+0060
+0020
+7F20
+0120
+0120
+7F20
+0A3C
+0FE0
+F020
 0000
-7FC0
-0040
-0040
-0040
+1FE0
 0040
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR D63C
-ENCODING 54844
+STARTCHAR uniCF80
+ENCODING 53120
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 16 2 -3
 BITMAP
-0380
-3FF8
-0300
-0F80
+0060
+0020
+7F20
+0120
+0120
+7F20
+0A3C
+0FE0
+F020
+0000
+1FE0
+0820
 0840
 0840
-0480
-0300
-FFFE
-0000
-1800
-0800
+0FE0
 0800
-0FF0
 ENDCHAR
-STARTCHAR D640
-ENCODING 54848
+STARTCHAR uniCF85
+ENCODING 53125
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 2 -2
+BBX 14 15 2 -2
 BITMAP
-0780
-3FF0
-0600
-0DC0
-0840
-0840
-0780
-FFFE
-0000
-3FC0
-0040
-3FC0
-1000
-1FE0
+0060
+0020
+7FA0
+0120
+0120
+FF20
+0A3C
+09E0
+FE20
+00A0
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR D645
-ENCODING 54853
+STARTCHAR uniCF8C
+ENCODING 53132
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-0F00
-3BF0
-0600
-0D80
-0840
-0880
-0700
-FFFC
-03F0
-3D00
-0560
-3D80
-2130
-3CC0
+0060
+0110
+0090
+7E90
+0290
+0490
+FC90
+2490
+10F0
+1790
+E890
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR D648
-ENCODING 54856
+STARTCHAR uniCFA1
+ENCODING 53153
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 12 15 2 -2
 BITMAP
-0780
-0000
-3FF0
-0E00
-0980
-0880
-0880
-0700
-FFFC
-0000
-3FC0
-1040
-1040
-1080
-1FC0
-1000
+0060
+0190
+0090
+7E90
+0290
+0C90
+7490
+11F0
+FE90
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR D649
-ENCODING 54857
+STARTCHAR uniCFA8
+ENCODING 53160
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 12 15 2 -2
 BITMAP
-03C0
-0000
-3FF8
-0100
-0EE0
-0820
-0440
-0380
-FFFE
-0820
-0420
-07E0
-0420
-0420
-07E0
-0420
+0030
+0010
+7F90
+0190
+0190
+0710
+7910
+1910
+0810
+08F0
+FF10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D64B
-ENCODING 54859
+STARTCHAR uniCFB0
+ENCODING 53168
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 12 14 2 -1
 BITMAP
-0780
-3FF0
-0200
-0780
-0840
-0840
-0880
-0700
-FFFC
-0600
-0200
-0500
-08E0
-1020
-2000
+0060
+0010
+7F90
+0190
+0110
+7F10
+0910
+09F0
+FE10
+1FF0
+0020
+1FF0
+0800
+0FF0
 ENDCHAR
-STARTCHAR D64D
-ENCODING 54861
+STARTCHAR uniCFC4
+ENCODING 53188
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 14 12 2 -1
 BITMAP
-0780
-0000
-3FF0
-0600
-0F00
-0880
+0030
+7FF0
+0010
+0030
+0020
+FFE0
+21A0
+18A0
 0880
-0900
-0600
+0888
 FFFC
-0F80
-18C0
-1040
-18C0
-0780
+4000
 ENDCHAR
-STARTCHAR D651
-ENCODING 54865
+STARTCHAR uniCFE0
+ENCODING 53216
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 15 1 -3
 BITMAP
-0F00
-0000
-3FF0
-0600
-0980
-0840
-0880
-0700
-FFFC
-0000
-1FE0
-1000
-1FC0
-1000
-1FE0
+3BF8
+0418
+0010
+01F0
+1E10
+0020
+0020
+FFFE
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR D654
-ENCODING 54868
+STARTCHAR uniCFE1
+ENCODING 53217
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 15 15 1 -3
 BITMAP
-0060
-1E20
-0020
-7FA0
-0420
-3A20
-2120
-212C
-3F30
-0C20
-0FE0
-F820
-0020
+1FF0
+0010
+0010
+3FE0
 0020
 0020
+FFFE
+0100
+0100
+21F0
+1E10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D655
-ENCODING 54869
+STARTCHAR uniCFE4
+ENCODING 53220
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 13 1 -1
 BITMAP
-0060
-1E20
-7FA0
-0420
-3F20
-2120
-213C
-1E20
-07E0
-F820
+03F0
+1C10
+0030
 3FE0
 0020
 0020
+FFFE
+0100
+0100
+1900
+0900
+0800
+07F8
+ENDCHAR
+STARTCHAR uniCFE8
+ENCODING 53224
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1FF8
+0010
+0030
+1FD0
 0020
+FFFE
+0100
+0100
+0EE0
 0020
+3FF0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR D658
-ENCODING 54872
+STARTCHAR uniCFF0
+ENCODING 53232
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 14 14 2 -2
 BITMAP
+03F0
+1C20
 0060
-0F10
-0010
-3FD0
-0210
-1D10
-1090
-1990
-0F1C
-06F0
-F910
-0C10
-0400
-0408
-07F8
+7FA0
+0040
+0040
+FFFC
+0200
+0200
+3FE0
+1040
+1040
+1FC0
+1000
 ENDCHAR
-STARTCHAR D65C
-ENCODING 54876
+STARTCHAR uniCFF1
+ENCODING 53233
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0080
-1E60
+01F0
+1E10
+0030
+3FE0
 0020
-FFA0
-1820
-2620
-2220
-3E3C
-08E0
-FF20
-1FE0
 0020
+FFFE
+0100
+1160
+0920
 0FE0
-0800
-0FF0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR D667
-ENCODING 54887
+STARTCHAR uniCFF3
+ENCODING 53235
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 3 -2
+BBX 15 14 1 -2
 BITMAP
-0180
-3C40
-0040
-FF40
-1040
-6C40
-4240
-6C58
-3860
-1FC0
-E340
+1FF0
+0010
+0030
+3FE0
+0020
+0020
+FFFE
+0100
+0100
 0300
-0680
-0860
-3030
+0300
+02C0
+0430
+1810
 ENDCHAR
-STARTCHAR D669
-ENCODING 54889
+STARTCHAR uniCFF5
+ENCODING 53237
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -2
+BBX 15 14 1 -2
 BITMAP
-0060
-1C20
-7FA0
+3FF8
+0010
+0010
+7FF0
+0010
+0020
+FFFE
+0100
+0100
+0680
+0860
 0820
-1620
-2120
-223C
-1E20
-0DE0
-FA20
-0180
-0660
-0420
-0660
-03C0
+0C60
+07C0
 ENDCHAR
-STARTCHAR D670
-ENCODING 54896
+STARTCHAR uniCFFC
+ENCODING 53244
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 1 -3
+BBX 13 15 1 -2
 BITMAP
-0030
+0018
+0008
+3F88
 0088
-1E48
-0048
-7F48
-0848
-3648
-2248
-3278
-1E48
-09C8
-FE48
-0048
-0048
-0048
+0088
+7F08
+0108
+0148
+FE88
+2418
+0468
+0408
+0408
+0408
+0008
+ENDCHAR
+STARTCHAR uniD000
+ENCODING 53248
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
+BITMAP
+0018
+0008
+0008
+1F88
+0088
+3F88
+0128
+FFC8
+2208
+0278
 0008
+0C08
+0400
+0408
+07FC
 ENDCHAR
-STARTCHAR D671
-ENCODING 54897
+STARTCHAR uniD004
+ENCODING 53252
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
 0030
-0190
-1890
-FE90
-1090
-2C90
-24F0
-3890
-1F90
-E090
-1FF0
 0010
-0010
-0010
-0010
+3F90
+0090
+0110
+3F10
+0150
+FEB0
+04D0
+0400
+0FF0
 0010
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR D674
-ENCODING 54900
+STARTCHAR uniD011
+ENCODING 53265
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 14 2 -2
+BBX 13 15 1 -2
 BITMAP
-0130
-1C90
-0090
-FE90
-1890
-2490
-2290
-3CF0
-0990
-FE90
-0C90
-0410
-0400
-07F8
+0038
+0008
+3F88
+0088
+0188
+3F08
+0148
+FE88
+0478
+0448
+01E0
+0210
+0210
+0310
+01E0
 ENDCHAR
-STARTCHAR D683
-ENCODING 54915
+STARTCHAR uniD018
+ENCODING 53272
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -3
+BBX 12 15 2 -2
 BITMAP
-0130
-3C90
+0030
+0110
 0090
-FE90
-1890
-2490
-2290
-3CF0
-0990
-FF90
+FC90
+0490
+1C90
+E890
+0E90
+F090
+1790
+1090
+1090
+1090
 0090
-0140
-0230
-0C10
-1000
+0010
 ENDCHAR
-STARTCHAR D685
-ENCODING 54917
+STARTCHAR uniD02D
+ENCODING 53293
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 1 -2
 BITMAP
-0010
+0018
 00C8
-0C48
-7F48
-0C48
+6E48
 1248
-1278
-0C48
-FFC8
-2048
-01B0
-0208
-0208
-0318
+0648
+7C48
+0448
+FF48
+09C8
+08C0
+01E0
+0210
+0210
+0230
+01E0
+ENDCHAR
+STARTCHAR uniD034
+ENCODING 53300
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+3F90
+0090
+0110
+7F10
+2110
 01F0
+FF10
+2410
+0410
+0410
+0410
+0410
+0010
 ENDCHAR
-STARTCHAR D68C
-ENCODING 54924
+STARTCHAR uniD035
+ENCODING 53301
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -3
+BBX 13 16 1 -3
 BITMAP
 0018
-0F08
 0008
 3F88
-0608
-1988
-1088
-1088
-0F08
-0238
-FFC8
+0088
+0188
+3F08
+0148
+FE88
+0408
+0400
+0FF8
 0008
 0008
 0008
 0008
-ENDCHAR
-STARTCHAR D68D
-ENCODING 54925
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0030
-0708
-3FE8
-0E08
-1988
-1088
-1988
-0608
-DFF8
-2008
-1FF0
-0010
-0010
-0010
-0010
+0008
 ENDCHAR
-STARTCHAR D690
-ENCODING 54928
+STARTCHAR uniD038
+ENCODING 53304
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-1E10
 0010
-FFD0
+7F10
+0110
+0310
+7E30
+01D0
+FE10
 0410
-3B10
-2110
-3310
-1E10
-07F0
-F810
+0410
+0010
 1810
-0810
 0800
+0800
 0FF8
 ENDCHAR
-STARTCHAR D694
-ENCODING 54932
+STARTCHAR uniD03C
+ENCODING 53308
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 14 4 -2
+BBX 14 15 1 -2
 BITMAP
-38C0
-0040
-FF40
-3840
-4440
-4440
-2840
-1FC0
-E000
-3FC0
-0080
-3FC0
-1000
-1FE0
+0018
+0008
+3F88
+0088
+0088
+3F08
+0168
+FE88
+0200
+07F8
+0008
+07F8
+0200
+0200
+03FC
 ENDCHAR
-STARTCHAR D69D
-ENCODING 54941
+STARTCHAR uniD044
+ENCODING 53316
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 15 3 -3
+BBX 13 16 1 -3
 BITMAP
-1CC0
-0040
-7F40
-3C40
-4640
-4240
-2440
-1FC0
-F0C0
-0840
-0FC0
-0840
-0840
-0FC0
-0840
+0018
+0008
+3F88
+0088
+0088
+3F08
+0148
+FE88
+0408
+0400
+07F8
+0208
+0208
+0210
+03F8
+0200
 ENDCHAR
-STARTCHAR D69F
-ENCODING 54943
+STARTCHAR uniD045
+ENCODING 53317
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -2
+BBX 13 16 1 -3
 BITMAP
-0030
-0708
-0048
+0018
+0008
 3F88
-0D08
-1088
-1188
-0F08
-0678
-FD88
-00C0
-0080
-0160
-0218
-0C0C
+0088
+0088
+3F08
+0148
+FE88
+0408
+0608
+0208
+03F8
+0208
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR D6A1
-ENCODING 54945
+STARTCHAR uniD047
+ENCODING 53319
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 14 15 1 -2
 BITMAP
-0060
-1E10
-0090
-7F10
-1610
-2110
-2310
-1E10
-0DF0
-FA10
-0180
-0660
-0420
-0660
-03C0
+0018
+0008
+3F88
+0088
+0108
+3F08
+0148
+FE88
+0408
+0588
+04C0
+00C0
+0130
+0208
+0C04
 ENDCHAR
-STARTCHAR D6A8
-ENCODING 54952
+STARTCHAR uniD049
+ENCODING 53321
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 2 -1
+BBX 13 15 1 -2
 BITMAP
-0780
-0000
-7FF0
-0200
-0F80
-1040
-1040
-1040
-0F80
-18C0
-0840
-084C
-F7B0
+0018
+0008
+3F88
+0088
+0188
+3F08
+0148
+FE88
+0408
+0448
+01B0
+0208
+0208
+0318
+01F0
 ENDCHAR
-STARTCHAR D6AC
-ENCODING 54956
+STARTCHAR uniD050
+ENCODING 53328
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 14 14 2 -2
 BITMAP
-0790
-3FF8
-0200
-0780
+3FF0
+0010
+0010
+7FE0
+0020
+0020
+FFFC
 0840
 0840
-0C80
-07C0
-FFFC
-0000
-3000
-1000
-1020
-1FE0
+0840
+0840
+0840
+0840
+0840
 ENDCHAR
-STARTCHAR D6B0
-ENCODING 54960
+STARTCHAR uniD054
+ENCODING 53332
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 14 1 -2
+BBX 14 13 2 -1
 BITMAP
-03C0
-1FF8
-0300
-04E0
-0420
-0420
-03E0
-FFFE
-0000
-1FE0
+3FF0
+0010
+0030
+7FE0
 0020
-1FE0
-0800
-0FF0
+0040
+FFFC
+0440
+0440
+1440
+1040
+1020
+1FF0
 ENDCHAR
-STARTCHAR D6B9
-ENCODING 54969
+STARTCHAR uniD058
+ENCODING 53336
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0780
-0000
-3FF0
-0780
-0880
+0070
+3FE0
+0020
+00C0
+3F40
+007C
+FF80
 0880
 0880
-0F80
-FFFC
-10C0
-0840
-0FC0
-0840
-0840
-0FC0
-0840
+3FC0
+0040
+3FC0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR D6BB
-ENCODING 54971
+STARTCHAR uniD060
+ENCODING 53344
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 13 14 2 -2
 BITMAP
-0780
-3FF0
-0700
+3FE0
+0020
+0020
+7FC0
+0040
+0058
+FFA0
 0880
-0840
-0C40
-1FC0
-0840
-FFFC
-0200
-0200
-0580
-0860
-3020
+0880
+3FC0
+1040
+1080
+1F80
+1000
 ENDCHAR
-STARTCHAR D6C4
-ENCODING 54980
+STARTCHAR uniD06C
+ENCODING 53356
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 15 9 1 1
 BITMAP
-03C0
-1FF8
-0100
-03C0
-0420
-0420
-03C0
-0000
+3FF8
+0008
+0018
+0030
+3FD0
+0010
+0020
+0020
 FFFE
-0100
-0100
-0100
-0100
-0100
-0100
 ENDCHAR
-STARTCHAR D6C5
-ENCODING 54981
+STARTCHAR uniD06D
+ENCODING 53357
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 14 15 2 -3
 BITMAP
-0380
-0000
 3FF0
-0300
-0CC0
-0840
-0840
-0780
-FFFE
-0100
+0030
+0020
+7FE0
+0020
+0040
+FFFC
+4000
+0000
 3FE0
 0020
 0020
 0020
 0020
+0020
 ENDCHAR
-STARTCHAR D6C8
-ENCODING 54984
+STARTCHAR uniD070
+ENCODING 53360
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 15 12 1 -1
 BITMAP
-03C0
-0000
 1FF8
-03C0
-0420
-0420
-0420
-03C0
+0008
+0010
+0030
+1FD0
+0020
 FFFE
-0100
-0100
-0900
-0900
+3000
 0800
-07F8
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR D6CC
-ENCODING 54988
+STARTCHAR uniD074
+ENCODING 53364
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 15 14 1 -2
 BITMAP
-0700
+1FF8
+0018
+0010
+3FF0
+0010
+0020
+FFFE
 0000
-7FF0
-0900
-0880
-0880
-0F80
-FFFC
-0200
-1DC0
-0040
-3FC0
-1000
-1FE0
+0FE0
+0020
+1FF0
+0800
+0800
+07F8
 ENDCHAR
-STARTCHAR D6D1
-ENCODING 54993
+STARTCHAR uniD07C
+ENCODING 53372
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 1 -3
+BBX 15 14 1 -2
 BITMAP
-03C0
 1FF8
-03C0
-0440
-0440
-03C0
-FC00
-03FC
-0100
-3FB8
-02C0
-36B0
-18C0
-1298
-1C60
-ENDCHAR
-STARTCHAR D6D4
-ENCODING 54996
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-0780
-1F70
-0380
-0440
-0420
-0440
-0380
+0010
+0010
+0070
+1FA0
+0020
 FFFE
-0100
-0F00
-08E0
+0000
+0000
+1FE0
 0820
-0840
+0820
 0FE0
 0800
 ENDCHAR
-STARTCHAR D6D7
-ENCODING 54999
+STARTCHAR uniD07D
+ENCODING 53373
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 15 14 1 -2
 BITMAP
-0380
-0000
+1FF8
+0010
+0010
 3FF0
-0100
-0680
-0840
-0C40
-0780
+0020
+0020
 FFFE
-0100
-0300
-0100
-0380
-0460
-0810
-1000
+0000
+0C60
+0420
+07E0
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR D6D9
-ENCODING 55001
+STARTCHAR uniD081
+ENCODING 53377
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 1 -2
+BBX 15 14 1 -2
 BITMAP
-0380
-3FF8
+1FF8
+0010
+0010
+3FF0
+0020
+0020
+FFFE
+0000
 0100
 06C0
-0440
-0440
-0384
-FF78
-0100
-07C0
-0C60
 0820
+0820
 0C60
 07C0
 ENDCHAR
-STARTCHAR D6E0
-ENCODING 55008
+STARTCHAR uniD0A4
+ENCODING 53412
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0030
-1E10
+0070
 0010
-FF90
-0C10
-3310
-2110
-3110
+0010
+7F10
+0310
+0210
 0E10
-1F10
-E9F0
-0810
-0810
+F410
+0410
 0810
+1010
+2010
+4010
 0010
+0010
 ENDCHAR
-STARTCHAR D6E4
-ENCODING 55012
+STARTCHAR uniD0A5
+ENCODING 53413
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-1E10
 0010
-7F90
-1E10
-2210
-2210
-1E10
-0390
-FDF0
+7F10
+0210
+0610
+FC10
 0810
-1C10
-0400
-0400
-07F8
+1010
+2010
+4000
+BFE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D6E8
-ENCODING 55016
+STARTCHAR uniD0A8
+ENCODING 53416
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-1E10
-0790
-FC10
-3A10
-2310
-1E10
-0390
-FCF0
-0400
-0FF0
-0010
+00C0
+0020
+0020
+7E20
+0420
+1C20
+E820
+1020
+2020
+4020
+A020
+1020
+1000
+1000
 0FF0
-0400
-07F8
 ENDCHAR
-STARTCHAR D6F0
-ENCODING 55024
+STARTCHAR uniD0AC
+ENCODING 53420
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 13 15 2 -2
 BITMAP
 0030
-3C10
 0010
-7F90
-3410
-2210
-1C10
-0310
-FCF0
+7F10
+0210
+0210
+FC10
 0810
-0FF0
-0410
-0420
-0420
-07F0
-0400
+1010
+2000
+DFF0
+0020
+1FF0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR D6F5
-ENCODING 55029
+STARTCHAR uniD0B4
+ENCODING 53428
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-1C10
-0110
-7E10
-3610
-2210
-1C10
-0310
-FCF0
+0010
+7F10
+0210
+0210
+FC10
 0810
-0080
-0360
-0410
-0410
-0630
-03E0
-ENDCHAR
-STARTCHAR D6FC
-ENCODING 55036
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 11 16 3 -3
-BITMAP
-00C0
-0260
-7920
-0120
-F920
-3920
-4920
-4520
-4920
-3D20
-F120
-1720
-2120
-0120
-0020
-0020
+1010
+2010
+4000
+1FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR D6FD
-ENCODING 55037
+STARTCHAR uniD0B5
+ENCODING 53429
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-00D0
-1C50
-0650
-7C50
-2450
-2450
-1950
-FE50
-09D0
-1FF0
-0810
 0010
-0010
-0010
-0010
+8710
+7A10
+0610
+FC10
+0810
+1010
+2000
+CC10
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D700
-ENCODING 55040
+STARTCHAR uniD0B7
+ENCODING 53431
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
-BITMAP
-0020
-0110
-1C90
-8790
-3C90
-2690
-2490
-1890
-1E90
-6F90
-0890
-0C10
-0400
-0400
-07F8
-ENDCHAR
-STARTCHAR D704
-ENCODING 55044
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
-BITMAP
-0018
-0068
-1E28
-7F28
-0C28
-1228
-1E28
-1EA8
-FD28
-04E0
-0FF8
-0010
-0FF0
-0400
-07F8
-ENDCHAR
-STARTCHAR D711
-ENCODING 55057
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 15 1 -2
 BITMAP
+0030
 0010
-0058
-1E48
-7F48
-0C48
-1248
-1E48
-1EC8
-FFC8
-0488
-01E8
-0210
+7F10
 0210
 0210
-01E0
-ENDCHAR
-STARTCHAR D718
-ENCODING 55064
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 13 16 1 -3
-BITMAP
-0018
-0F08
-0008
-3FC8
-0608
-1908
-1088
-1088
-0F08
-00F8
-FF08
-0408
-0408
-0408
-0008
-0008
+FC10
+0810
+1010
+2010
+4190
+0080
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR D719
-ENCODING 55065
+STARTCHAR uniD0B9
+ENCODING 53433
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-1E10
-4390
-3C10
-1310
-1110
-1E10
-FFF0
-0410
+0010
+7F10
+0110
+0210
+FE10
 0410
-1FF0
 0810
-0010
-0010
-0010
+1010
+6080
+0340
+0420
+0420
+0660
+03C0
+ENDCHAR
+STARTCHAR uniD0C0
+ENCODING 53440
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
+BITMAP
+0060
+0020
+0220
+FE20
+4020
+4020
+4220
+7E20
+403C
+4020
+41E0
+7E20
+2020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D71C
-ENCODING 55068
+STARTCHAR uniD0C1
+ENCODING 53441
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 16 2 -3
 BITMAP
-0060
-3C20
-0320
-7C20
-3C20
-4220
-4220
+00C0
+0220
+FE20
+4020
+4020
+7E3C
+4060
+43A0
 3C20
-0FE0
-F820
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniD0C4
+ENCODING 53444
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0040
+0020
+0220
+FF20
+4020
+7E20
+403C
+4060
+4FA0
+7020
+1020
 0820
-3820
 0800
 0800
-0FF0
+0FF8
 ENDCHAR
-STARTCHAR D720
-ENCODING 55072
+STARTCHAR uniD0C8
+ENCODING 53448
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-0060
-3C20
-0020
-FF20
-3C20
-2620
-2620
-3C20
-01A0
-FFE0
-0020
+00C0
+0220
+FE20
+4020
+4020
+7C3C
+40E0
+4F20
+3000
+1FE0
+0040
 1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR D728
-ENCODING 55080
+STARTCHAR uniD0C9
+ENCODING 53449
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 14 15 2 -2
 BITMAP
 0060
-3C20
-0F20
+0020
+FC20
+4020
+4E20
+703C
+41E0
+7E20
+0000
+3DE0
+0420
 7C20
-2220
-2220
-3C20
-0FE0
-F820
-0820
+2020
+2620
+3820
+ENDCHAR
+STARTCHAR uniD0D0
+ENCODING 53456
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+00C0
+0220
+FE20
+4020
+4020
+7E20
+4038
+40E0
+7F20
+0000
 1FE0
-0820
-0820
 0840
-0B80
-0400
+0840
+0FC0
+0800
 ENDCHAR
-STARTCHAR D729
-ENCODING 55081
+STARTCHAR uniD0D1
+ENCODING 53457
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 13 16 2 -3
 BITMAP
-0060
-3C20
-0F20
-7820
-3C20
-6220
-2220
-3C60
-1FA0
-E800
-0860
+0040
+0020
+0620
+F820
+4020
+4E20
+7038
+43E0
+7C20
 1820
+0820
 0FE0
 0820
+0820
 0FE0
 0820
 ENDCHAR
-STARTCHAR D72B
-ENCODING 55083
+STARTCHAR uniD0D3
+ENCODING 53459
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 16 2 -3
+BBX 14 15 2 -2
 BITMAP
-0030
-1E10
-0010
-3F90
-1A10
-1110
-1E10
-01F0
-FE10
-0590
-0480
+0040
+0020
+FE20
+4020
+4020
+4E2C
+7030
+40E0
+4F20
+3220
 0180
+0180
 0240
-0438
-0808
-1000
+0430
+1810
 ENDCHAR
-STARTCHAR D72D
-ENCODING 55085
+STARTCHAR uniD0D4
+ENCODING 53460
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
+BBX 14 15 2 -2
 BITMAP
-0060
-3C20
-0F20
-7C20
-2220
-2220
+0040
+0020
+FE20
+4020
+4020
+5E3C
+6020
+43E0
 3C20
-1FE0
-E820
-0920
-06C0
-0820
-0820
+0860
+0420
 0C60
-0380
+0A50
+1198
+6108
 ENDCHAR
-STARTCHAR D734
-ENCODING 55092
+STARTCHAR uniD0D5
+ENCODING 53461
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -3
+BBX 14 15 2 -2
 BITMAP
-0780
-7FF0
-0200
-0D80
-1080
-1080
-0F00
-0000
-FFF8
-0880
-0880
-0880
-0880
-0880
-0080
+0040
+0020
+CE20
+7020
+4020
+7E20
+403C
+43E0
+7C20
+00A0
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR D735
-ENCODING 55093
+STARTCHAR uniD0DC
+ENCODING 53468
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 15 2 -2
 BITMAP
-0700
-3FE0
-0700
-0880
-0880
-0880
-FFC0
-087C
-0880
-3FC0
+0030
+0190
+0090
+DC90
+6090
+4090
+4090
+7CF0
+4090
+4790
+7890
+0090
+0090
+0090
+0010
+ENDCHAR
+STARTCHAR uniD0DD
+ENCODING 53469
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+00C0
+0320
+0920
+F120
+8120
+B920
+C1E0
+8120
+9F20
+6120
+7FC0
 0040
 0040
 0040
 0040
 ENDCHAR
-STARTCHAR D738
-ENCODING 55096
+STARTCHAR uniD0E0
+ENCODING 53472
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 13 1 -1
+BBX 13 14 2 -1
 BITMAP
-03C0
+0030
 0010
-1FE0
-06C0
-0440
-0640
-0380
-FFFC
-0440
-0C40
-0840
-0840
-07F8
+0190
+CC90
+7090
+4090
+7CF0
+4390
+7C90
+6090
+1890
+0810
+0800
+0FF8
 ENDCHAR
-STARTCHAR D73C
-ENCODING 55100
+STARTCHAR uniD0E4
+ENCODING 53476
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 12 14 2 -2
 BITMAP
-0700
-3FF0
-0700
-0880
-08C0
-0780
-FFFC
-0880
-0880
-3FC0
-0040
-3FC0
-1000
+0130
+CC90
+7090
+4090
+7C90
+40F0
+4390
+7C90
+7FE0
+0020
 1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR D744
-ENCODING 55108
+STARTCHAR uniD0EC
+ENCODING 53484
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 14 2 -2
+BBX 11 16 3 -3
 BITMAP
-0780
-3FF0
-0200
-0D80
-0840
-0880
-0788
-FFFC
-0880
-3F80
+0040
+0320
+1120
+E120
+8120
+F920
+81E0
+8320
+9D20
+E120
+1FC0
 1040
 1040
 1080
 1FC0
-ENDCHAR
-STARTCHAR D747
-ENCODING 55111
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-0780
-3FF0
-0780
-08C0
-0880
-0780
-FFFC
-0840
-0840
-0A40
-0200
-0500
-08E0
-3030
+1000
 ENDCHAR
-STARTCHAR D749
-ENCODING 55113
+STARTCHAR uniD0ED
+ENCODING 53485
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 12 16 2 -3
 BITMAP
-03C0
-0000
-1FF8
-0080
-0760
-0420
-0460
-03C0
-FFFE
-0420
-07A0
-0460
-0420
-0620
-03C0
+0030
+0090
+8C90
+7090
+4090
+7890
+40F0
+4790
+7890
+0C90
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D750
-ENCODING 55120
+STARTCHAR uniD0EF
+ENCODING 53487
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 11 1 0
+BBX 12 15 3 -2
 BITMAP
-03C0
-0000
-3FF8
-07C0
-0C60
-0820
+00C0
+0320
+0120
+F120
+8120
+B920
+C1E0
+8120
+8F20
+F320
+0300
+0300
+04C0
 0820
-0C60
-03C0
-0004
-FFFE
+3010
 ENDCHAR
-STARTCHAR D751
-ENCODING 55121
+STARTCHAR uniD0F0
+ENCODING 53488
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-03C0
-0000
-1FF8
-03C0
-0420
+0030
+0110
+8C90
+7090
+4090
+7C90
+41F0
+7E90
+7090
+00E0
 0420
 0420
-03C0
-FFFE
-0000
-3FE0
-0020
-0020
-0020
-0020
-ENDCHAR
-STARTCHAR D754
-ENCODING 55124
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-0780
-00F0
-3F00
-0780
-0840
-0840
-0840
-0788
-FFFC
-0000
-3000
-1000
-1000
-1FF0
-ENDCHAR
-STARTCHAR D756
-ENCODING 55126
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-0700
-39F0
-0780
-0C40
-0840
-0440
-0780
-FFFC
-01C0
-6078
-23C0
-21A0
-2520
-39E0
-ENDCHAR
-STARTCHAR D757
-ENCODING 55127
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 15 15 1 -3
-BITMAP
-0790
-3F60
-07C0
-0440
-0820
-0440
-0380
-01FE
-FF00
-0000
-0FF0
-0800
-0800
-0810
-07F8
-ENDCHAR
-STARTCHAR D758
-ENCODING 55128
-SWIDTH 1020 0
-DWIDTH 17 0
-BBX 14 14 2 -2
-BITMAP
-0780
-39F0
-0780
-0C40
-0840
-0C40
-0788
-FFFC
-0000
-3FC0
-0040
-3FC0
-1000
-1FE0
+0A60
+1198
+2108
 ENDCHAR
-STARTCHAR D759
-ENCODING 55129
+STARTCHAR uniD0F1
+ENCODING 53489
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 15 2 -2
 BITMAP
+0020
+0110
+CC90
+7090
+4090
+7C90
+40F0
+4390
+7C90
+0090
 03C0
-1BF8
-0500
-06E0
 0420
+0420
 0620
-01C4
-FFFE
-0000
-3E78
-0208
-3608
-1808
-1608
-0800
+03C0
 ENDCHAR
-STARTCHAR D760
-ENCODING 55136
+STARTCHAR uniD0F8
+ENCODING 53496
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 14 15 2 -3
+BBX 14 16 2 -3
 BITMAP
-07A0
-7E40
-0F80
-0880
-1040
-0880
-0700
-01FC
-FE00
-0000
-0FE0
-0820
-0840
-0FE0
-0800
+0060
+0020
+0220
+FE20
+4020
+402C
+4230
+7E20
+4020
+4020
+41FC
+7E20
+2020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D761
-ENCODING 55137
+STARTCHAR uniD10D
+ENCODING 53517
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 16 1 -3
+BBX 14 15 2 -2
 BITMAP
-03C0
-0000
-1FF8
-03C0
-0420
+0080
+0060
+0020
+FC20
+403C
+4620
+7820
+4064
+47B8
+78A0
+0340
 0420
 0420
-03C4
-FFFE
-0060
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0660
+03C0
 ENDCHAR
-STARTCHAR D763
-ENCODING 55139
+STARTCHAR uniD130
+ENCODING 53552
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -3
+BBX 12 15 2 -2
 BITMAP
-0380
-2078
-1F80
-06C0
-0440
-0440
-0380
-0004
-FFFE
-0300
-0100
-0280
-0470
-1810
-2000
+0030
+0010
+0010
+FC10
+4010
+4010
+4CF0
+7010
+4010
+4090
+4F10
+7010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR D765
-ENCODING 55141
+STARTCHAR uniD131
+ENCODING 53553
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -3
+BBX 12 16 2 -3
 BITMAP
-0700
-7FF0
-0300
-0C80
-1840
-1840
-0F80
-7C00
-83F8
-0200
-0F80
-10C0
-1040
-18C0
-0F80
+0030
+0010
+CE10
+7010
+41F0
+7C10
+4010
+4310
+7C10
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR D769
-ENCODING 55145
+STARTCHAR uniD134
+ENCODING 53556
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 15 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0380
-0000
-3FF8
-0100
-06E0
-0420
-0660
-03C6
-FFFE
-0000
-0FF0
+0030
+0010
+FE10
+4010
+4010
+4CF0
+7010
+4010
+4310
+7C10
+0010
+1800
 0800
-0FF0
 0800
-07F8
+0FF8
 ENDCHAR
-STARTCHAR D76C
-ENCODING 55148
+STARTCHAR uniD138
+ENCODING 53560
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
-0060
-0010
-1E10
-03D0
-7C10
-0E10
-3110
-2110
-2110
-1E10
-01F0
-FE10
-0010
-0010
+0030
 0010
+0210
+FC10
+41F0
+5C10
+6010
+4110
+7FE0
+0020
+0020
+1FE0
+0800
+0810
+0FF0
 ENDCHAR
-STARTCHAR D770
-ENCODING 55152
+STARTCHAR uniD13A
+ENCODING 53562
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0010
-1E10
-7F90
-1E10
-3210
-2110
-3210
-1EF0
-F910
 0010
-1810
-0800
-0800
-0FF8
+0210
+FC10
+41F0
+5C10
+6010
+4110
+7E00
+35F0
+0520
+6D20
+3120
+2320
+3DF0
+0100
 ENDCHAR
-STARTCHAR D774
-ENCODING 55156
+STARTCHAR uniD140
+ENCODING 53568
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 12 16 2 -3
 BITMAP
 0030
-0E10
-0010
-3F90
-1B10
-2110
-1110
-0E30
-FFD0
+8610
+7810
+4010
+5CF0
+6010
+4010
+4610
+7810
 0000
-0FF0
 0FF0
+0410
+0410
+0410
+07F0
 0400
-0400
-07F8
 ENDCHAR
-STARTCHAR D77C
-ENCODING 55164
+STARTCHAR uniD141
+ENCODING 53569
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 16 2 -3
+BBX 12 15 2 -2
 BITMAP
 0030
-1E10
-0010
-FF10
-3C10
-2210
-2210
-3C30
-FFD0
-0010
-1FE0
-0820
-0820
-0840
-0FE0
-0800
+8610
+7810
+4010
+5DF0
+6010
+4010
+4610
+7C10
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D77D
-ENCODING 55165
+STARTCHAR uniD143
+ENCODING 53571
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 2 -3
+BBX 13 15 2 -2
 BITMAP
-1E60
-0020
-7F20
-1620
-2220
-3220
-1C20
-00E0
-FF60
-0820
-0FE0
-0820
-0820
-0FE0
-0820
+0030
+0010
+0610
+F810
+4010
+5CF0
+6010
+4010
+4710
+7B10
+0090
+0100
+02C0
+0430
+1808
 ENDCHAR
-STARTCHAR D781
-ENCODING 55169
+STARTCHAR uniD144
+ENCODING 53572
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 1 -2
+BBX 13 15 2 -2
 BITMAP
-0018
-0708
-0008
-3F88
-0F08
-1108
-1108
-0F08
-83F8
-3C08
-01C0
-0230
-0210
-0330
-01E0
+0030
+0610
+F810
+4010
+5CF0
+6010
+4090
+4710
+7810
+0830
+0430
+0C20
+1A50
+2088
+4100
 ENDCHAR
-STARTCHAR D788
-ENCODING 55176
+STARTCHAR uniD145
+ENCODING 53573
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 15 2 -2
 BITMAP
 0030
-0010
-1E10
-0010
-0090
-FF90
-3E10
-6310
-4110
-6310
-3E10
-0010
-0010
-0010
 0010
+8610
+7810
+4010
+4DF0
+7010
+4010
+4610
+78D0
+0320
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR D789
-ENCODING 55177
+STARTCHAR uniD14C
+ENCODING 53580
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 10 16 4 -3
+BBX 12 15 2 -2
 BITMAP
-00C0
-7040
-0840
-0640
-F840
-8440
-8440
-C440
-7840
-0000
-7FC0
-0040
-0040
-0040
-0040
-0040
+0020
+0310
+0090
+DC90
+6090
+4090
+5890
+6390
+4090
+4490
+7890
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR D78C
-ENCODING 55180
+STARTCHAR uniD14D
+ENCODING 53581
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 13 15 2 -2
+BBX 11 15 3 -2
 BITMAP
 0060
-0010
-3C10
+0320
+0120
+F920
+8120
+9F20
+E120
+8520
+F920
+0000
+3FE0
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniD150
+ENCODING 53584
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0030
+0110
 0090
-FF90
-1810
-6610
-4210
-4210
-3C10
-0010
-0C10
+FC90
+4090
+4090
+7B90
+4090
+4490
+7890
+0890
+0410
 0400
 0400
-07F8
+07FC
 ENDCHAR
-STARTCHAR D790
-ENCODING 55184
+STARTCHAR uniD154
+ENCODING 53588
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 12 15 2 -2
+BBX 12 15 3 -2
 BITMAP
-0030
-1C10
-0010
-FF90
-1010
-6C10
-4210
-6210
-3C00
-1FF0
+0060
+0220
+0120
+F120
+8120
+F720
+8120
+8920
+F100
+1FE0
 0020
-1FF0
+1FE0
 0800
 0800
 0FF0
 ENDCHAR
-STARTCHAR D798
-ENCODING 55192
+STARTCHAR uniD15C
+ENCODING 53596
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 12 16 2 -3
 BITMAP
 0030
-1E10
-0010
-FF90
-1810
-6410
-4210
-6210
-3C10
-0000
+0110
+0890
+F090
+4090
+7F90
+4090
+4490
+7890
+0080
 0FF0
-0420
+0410
 0420
 0420
 07F0
 0400
 ENDCHAR
-STARTCHAR D799
-ENCODING 55193
+STARTCHAR uniD15D
+ENCODING 53597
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 16 3 -3
+BBX 12 16 2 -3
 BITMAP
-00C0
-3C20
-0020
-FFA0
-1820
-6420
-4220
-6220
-3C20
-1840
-0840
-0FC0
-0840
-0840
-0FC0
-0840
+0030
+0190
+0C90
+F090
+4090
+7B90
+4090
+4C90
+7090
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR D79B
-ENCODING 55195
+STARTCHAR uniD15F
+ENCODING 53599
 SWIDTH 1020 0
 DWIDTH 17 0
 BBX 13 15 2 -2
 BITMAP
 0030
-0010
-1E10
-FF90
-0410
-1E10
-2110
-2110
-2110
-1E10
-0080
+0190
+0C90
+F090
+4090
+7B90
+4090
+4490
+7890
+0190
 0180
-0340
+0180
+0240
 0430
 1808
 ENDCHAR
-STARTCHAR D79D
-ENCODING 55197
+STARTCHAR uniD161
+ENCODING 53601
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 11 15 3 -2
-BITMAP
-0060
-0020
-3C20
-FF20
-0820
-3C20
-4220
-4220
-6620
-1920
-0380
-0C60
-0820
-0C60
-07C0
-ENDCHAR
-STARTCHAR char8192
-ENCODING 57356
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3EAA
-84A8
-08AA
-90AA
-BE50
-0002
-A20A
-B208
-2A0A
-A68A
-A270
-0002
-DB6A
-ENDCHAR
-STARTCHAR char8192
-ENCODING 57357
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 15 0 0
-BITMAP
-B6D6
-8000
-3EAA
-84A8
-08AA
-90AA
-BE50
-0002
-8042
-8040
-0042
-8442
-8380
-0002
-DB6A
-ENDCHAR
-STARTCHAR C073
-ENCODING 57646
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 19 1 -3
-BITMAP
-10
-30
-20
-40
-00
-F8
-20
-20
-20
-20
-20
-20
-20
-20
-20
-F8
-20
-48
-30
-ENDCHAR
-STARTCHAR 0x012F
-ENCODING 57647
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 4 15 1 -3
-BITMAP
-10
-30
-20
-40
-00
-C0
-40
-40
-40
-40
-40
-E0
-40
-90
-60
-ENDCHAR
-STARTCHAR 00EA
-ENCODING 58842
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 13 1 -4
-BITMAP
-40
-FE
-04
-04
-74
-24
-04
-04
-04
-04
-04
-04
-04
-ENDCHAR
-STARTCHAR 0x0000
-ENCODING 58880
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 15 -1 0
+BBX 13 15 1 -2
 BITMAP
-18
-20
-18
-E0
-00
-10
-18
-10
-10
-10
-10
-10
-10
-10
-10
+0030
+00C8
+EE48
+3048
+2048
+3DC8
+2048
+2248
+3C48
+00C8
+0320
+0210
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR 0x0001
-ENCODING 58881
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 6 16 -1 0
+STARTCHAR uniD168
+ENCODING 53608
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-18
-20
-18
-E0
-00
-00
-10
-18
-10
-10
-10
-10
-10
-10
-10
-0C
+0030
+0010
+0010
+FC10
+41F0
+4010
+4C10
+7070
+4090
+4010
+4610
+7810
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0x0002
-ENCODING 58882
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 15 -1 -5
+STARTCHAR uniD16C
+ENCODING 53612
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-10
-18
-10
-10
-10
-10
-10
-10
-10
-10
-00
-18
-20
-18
-E0
+0030
+0010
+FE10
+41F0
+4010
+4C10
+71F0
+4010
+4210
+7C10
+1010
+0800
+0800
+0830
+07F0
 ENDCHAR
-STARTCHAR 0x0003
-ENCODING 58883
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 6 16 -1 -6
+STARTCHAR uniD17C
+ENCODING 53628
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 2 -3
 BITMAP
-10
-18
-10
-10
-10
-10
-10
-10
-10
-0C
-00
-00
-18
-20
-18
-E0
+0030
+0010
+0610
+F9F0
+4010
+4C10
+71F0
+4010
+4610
+7810
+0C20
+0420
+0C60
+1290
+2108
+C000
 ENDCHAR
-STARTCHAR 0x0004
-ENCODING 58884
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 13 2 0
+STARTCHAR uniD184
+ENCODING 53636
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0C
-10
-0C
-90
-C0
-80
-80
-80
-80
-80
-80
-80
-80
+0020
+0310
+0090
+DC90
+6090
+4790
+5890
+6090
+4390
+4490
+7890
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR 0x0005
-ENCODING 58885
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 13 2 0
+STARTCHAR uniD188
+ENCODING 53640
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
 BITMAP
-0C
-10
-8C
-90
-C0
-80
-80
-80
-80
-80
-80
-80
-60
+0060
+0320
+0120
+F120
+8320
+B120
+C720
+8520
+F920
+0120
+0120
+1820
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR 0xFE85
-ENCODING 58886
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 14 0 -3
+STARTCHAR uniD1A0
+ENCODING 53664
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
 BITMAP
-0180
-0200
-0180
-0200
-0000
-0000
-0400
-0A00
-0A00
-0E00
-0200
-0200
-8400
-7800
+3FF8
+1000
+1000
+1FF0
+1000
+1000
+1010
+1FF8
+0100
+0100
+FFFE
 ENDCHAR
-STARTCHAR 0xFE86
-ENCODING 58887
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 -4
+STARTCHAR uniD1A1
+ENCODING 53665
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -2
 BITMAP
-0180
-0200
-0180
-0200
-0000
+1FE0
+1000
+1000
+1FE0
+1020
+1FE0
+0104
+FFFC
 0000
-0400
-0A00
-0A00
-0780
-0200
-0200
-8400
-7800
-ENDCHAR
-STARTCHAR 00F0
-ENCODING 58888
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 14 1 -2
-BITMAP
-0018
+3FE0
 0020
-0018
 0020
-0000
-0000
-01E0
-0200
-4200
-8180
-8040
-8040
-4180
-3E00
-ENDCHAR
-STARTCHAR 00F0
-ENCODING 58889
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 12 1 -5
-BITMAP
-0018
 0020
-0018
 0020
-0000
-0000
-41E0
-8200
-8180
-8040
-4180
-3E00
-ENDCHAR
-STARTCHAR 00E4
-ENCODING 58890
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 11 0 0
-BITMAP
-06
-08
-06
-08
-00
-00
-10
-08
-08
-08
-F0
-ENDCHAR
-STARTCHAR 00E5
-ENCODING 58891
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 7 10 0 0
-BITMAP
-06
-08
-06
-08
-00
-00
-10
-10
-10
-EC
-ENDCHAR
-STARTCHAR 0050
-ENCODING 58892
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 11 0 -4
-BITMAP
-0500
-0500
-0008
-4008
-8008
-8008
-C030
-7FC0
-0600
-0900
-0600
-ENDCHAR
-STARTCHAR 004F
-ENCODING 58893
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 11 1 -4
-BITMAP
-0500
-0500
-0000
-4000
-8010
-8010
-C06E
-7F80
-0600
-0900
-0600
-ENDCHAR
-STARTCHAR 004D
-ENCODING 58894
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 0 -3
-BITMAP
-28
-28
-00
-10
-08
-08
-08
-F0
-60
-90
-60
-ENDCHAR
-STARTCHAR 004E
-ENCODING 58895
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 10 0 -3
-BITMAP
-28
-28
-00
-10
-10
-10
-EC
-60
-90
-60
-ENDCHAR
-STARTCHAR 0050
-ENCODING 58896
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 10 1 -1
-BITMAP
-0500
-0500
-0200
-0200
-0008
-4008
-8008
-8008
-C030
-7FC0
-ENDCHAR
-STARTCHAR 004F
-ENCODING 58897
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 10 1 -1
-BITMAP
-0500
-0500
-0200
-0200
-0000
-4000
-8010
-8010
-C06E
-7F80
-ENDCHAR
-STARTCHAR 004D
-ENCODING 58898
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 0 0
-BITMAP
-28
-28
-10
-10
-00
-10
-08
-08
-08
-F0
-ENDCHAR
-STARTCHAR 004E
-ENCODING 58899
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 10 0 0
-BITMAP
-28
-28
-10
-10
-00
-00
-10
-10
-10
-EC
 ENDCHAR
-STARTCHAR 0057
-ENCODING 58900
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 1 -6
+STARTCHAR uniD1A4
+ENCODING 53668
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0C00
+1FF0
 1000
-0C00
 1000
-0000
-0000
-7000
-8F00
-3800
-4000
-4000
-8000
-8000
-8000
-4000
-60C0
-1F00
-ENDCHAR
-STARTCHAR 0057
-ENCODING 58901
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 17 1 -6
-BITMAP
-0600
-0800
-0600
-0800
-0000
-0000
-7000
-8F00
-3A00
-4200
-41C0
-8000
-8000
-8000
-4000
-60C0
-1F00
-ENDCHAR
-STARTCHAR 0055
-ENCODING 58902
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 0 0
-BITMAP
-0300
-0400
-0300
-0400
-0000
-0000
-3800
-4780
-0C00
+1FF0
+1010
+1FF0
+0100
+C1FE
+FE00
 1000
-E000
-ENDCHAR
-STARTCHAR 0056
-ENCODING 58903
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 0 0
-BITMAP
-0300
-0400
-0300
-0400
-0000
-0000
-3800
-4780
-0D00
-1100
-E0C0
-ENDCHAR
-STARTCHAR 0057
-ENCODING 58904
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 18 1 -6
-BITMAP
-0800
-0800
-0000
-0800
-0800
-0000
-0000
-7000
-8F00
-3800
-4000
-4000
-8000
-8000
-8000
-4000
-60C0
-1F00
-ENDCHAR
-STARTCHAR 0057
-ENCODING 58905
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 18 1 -6
-BITMAP
-0800
 0800
-0000
 0800
 0800
-0000
-0000
-7000
-8F00
-3A00
-4200
-41C0
-8000
-8000
-8000
-4000
-60C0
-1F00
+07F8
 ENDCHAR
-STARTCHAR 0055
-ENCODING 58906
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 0 0
+STARTCHAR uniD1A8
+ENCODING 53672
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0400
-0400
-0000
-0400
-0400
-0000
-0000
-3800
-4780
-0C00
+3FF0
 1000
-E000
-ENDCHAR
-STARTCHAR 0056
-ENCODING 58907
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 12 0 0
-BITMAP
-0400
-0400
-0000
-0400
-0400
-0000
-0000
-3800
-4780
-0D00
-1100
-E0C0
-ENDCHAR
-STARTCHAR 0057
-ENCODING 58908
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 1 -6
-BITMAP
-0800
-0800
-1400
-1400
-0000
-0000
-7000
-8F00
-3800
-4000
-4000
-8000
-8000
-8000
-4000
-60C0
-1F00
-ENDCHAR
-STARTCHAR 0057
-ENCODING 58909
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 17 1 -6
-BITMAP
-0800
-0800
-1400
-1400
-0000
-0000
-7000
-8F00
-3A00
-4200
-41C0
-8000
-8000
-8000
-4000
-60C0
-1F00
-ENDCHAR
-STARTCHAR 0055
-ENCODING 58910
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 0 0
-BITMAP
-0400
-0400
-0A00
-0A00
-0000
-0000
-3800
-4780
-0C00
+1FE0
 1000
-E000
-ENDCHAR
-STARTCHAR 0056
-ENCODING 58911
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 0 0
-BITMAP
-0400
-0400
-0A00
-0A00
-0000
-0000
-3800
-4780
-0D00
-1100
-E0C0
+1FF0
+0100
+0100
+FFFE
+1FF0
+0020
+0020
+0FF0
+0800
+0FF8
 ENDCHAR
-STARTCHAR 0065
-ENCODING 58912
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 9 1 -3
+STARTCHAR uniD1B0
+ENCODING 53680
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-20
-10
-08
-08
-08
-F0
-20
-50
-20
+1F60
+1080
+1FE0
+1000
+1000
+0FE0
+0200
+FFFC
+0000
+3FC0
+1040
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR 0066
-ENCODING 58913
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 9 1 -2
+STARTCHAR uniD1B1
+ENCODING 53681
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-10
-10
-08
-08
-08
-98
-66
-50
-20
+3FF0
+1000
+1FE0
+1000
+1030
+0FC0
+0100
+FFFE
+3860
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 0065
-ENCODING 58914
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 1 -4
+STARTCHAR uniD1B3
+ENCODING 53683
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -2
 BITMAP
-20
-10
-08
-08
-08
-F0
-00
-00
-20
-20
+1FE0
+1000
+1000
+1FE0
+1000
+1FE0
+0100
+FFFC
+0000
+0100
+0300
+02C0
+0C30
+1010
 ENDCHAR
-STARTCHAR 0066
-ENCODING 58915
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 11 1 -4
+STARTCHAR uniD1B5
+ENCODING 53685
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-10
-10
-08
-08
-08
-98
-66
-00
-00
-20
-20
+1FF0
+1000
+1FE0
+1000
+1030
+0FC0
+0100
+FFFE
+0100
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR 0065
-ENCODING 58916
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 16 1 -4
+STARTCHAR uniD1BA
+ENCODING 53690
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-40
-40
-70
-70
-00
-00
-20
-10
-08
-08
-08
-F0
-00
-00
-20
-20
+0FE0
+3000
+1FE0
+1000
+1020
+1FC0
+0200
+FFFC
+0000
+3FE0
+0880
+0C80
+0100
+7FF0
 ENDCHAR
-STARTCHAR 0066
-ENCODING 58917
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 17 1 -4
+STARTCHAR uniD1BC
+ENCODING 53692
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-40
-40
-70
-70
-00
-00
-10
-10
-08
-08
-08
-98
-66
-00
-00
-20
-20
+0060
+01A0
+7FA0
+2020
+2120
+3F20
+2020
+21A0
+3E3C
+0420
+07E0
+F820
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0065
-ENCODING 58918
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 12 1 0
+STARTCHAR uniD1C0
+ENCODING 53696
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-50
-50
-20
-20
-00
-00
-20
-10
-08
-08
-08
-F0
+0030
+0110
+3F90
+2010
+3F90
+2090
+3F1E
+0410
+07F0
+F810
+0C10
+0410
+0400
+07F8
 ENDCHAR
-STARTCHAR 0066
-ENCODING 58919
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 13 1 0
+STARTCHAR uniD1D8
+ENCODING 53720
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -3
 BITMAP
-50
-50
-20
-20
-00
-00
-10
-10
-08
-08
-08
-98
-66
+0130
+0090
+0C90
+7090
+4C90
+7090
+5E90
+28F0
+0990
+0E90
+F090
+0090
+0090
+0090
+0010
 ENDCHAR
-STARTCHAR 0065
-ENCODING 58920
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 13 1 0
+STARTCHAR uniD1F4
+ENCODING 53748
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-50
-50
-00
-50
-50
-00
-00
-20
-10
-08
-08
-08
-F0
+0030
+0010
+7F90
+2010
+2010
+3F10
+2010
+2090
+3F10
+0410
+07F0
+FE10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0066
-ENCODING 58921
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 14 1 0
+STARTCHAR uniD1F8
+ENCODING 53752
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-50
-50
-00
-50
-50
-00
-00
-10
-10
-08
-08
-08
-98
-66
+0030
+0110
+3F10
+2010
+3F10
+2190
+3E10
+0470
+0790
+F810
+0010
+1800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58922
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 7 13 1 -4
+STARTCHAR uniD207
+ENCODING 53767
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-22
-14
-08
-00
-00
-08
-08
-04
-04
-04
-0C
-18
-F0
+0070
+0130
+7F10
+2110
+3F10
+2090
+3F10
+04F0
+0F10
+F110
+0090
+0180
+0360
+0410
+1808
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58923
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 13 1 -5
+STARTCHAR uniD209
+ENCODING 53769
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-22
-14
-08
-00
-00
-08
-0C
-07
-04
-04
-0C
-18
-F0
+00E0
+0260
+7F20
+4020
+7E20
+4120
+7E20
+0820
+1FE0
+E220
+0580
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58924
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 9 1 -5
+STARTCHAR uniD210
+ENCODING 53776
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
 BITMAP
-08
-08
-04
-04
-04
-0C
-18
-F4
-0C
+0060
+7FE0
+2000
+2000
+3FE0
+2000
+2020
+3FE0
+10C0
+0840
+0848
+FFFC
+4000
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58925
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 9 1 -6
+STARTCHAR uniD22C
+ENCODING 53804
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-08
-0C
-07
-04
-04
-0C
-18
-F4
-0C
+1FF8
+0800
+0800
+0FF0
+0800
+0FF8
+0000
+FFFE
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58926
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 10 1 -6
+STARTCHAR uniD22D
+ENCODING 53805
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-08
-08
-04
-04
-04
-0C
-18
-F0
-04
-04
+1FF0
+0800
+0FF0
+0800
+0FF0
+0000
+0000
+FFFE
+0100
+01E0
+1E20
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58927
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 10 1 -7
+STARTCHAR uniD230
+ENCODING 53808
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-08
-0C
-07
-04
-04
-0C
-18
-F0
-04
-04
+2070
+1FA0
+1FE0
+1000
+1000
+1FF0
+0004
+FFFE
+0100
+0100
+1900
+0900
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58928
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 -8
+STARTCHAR uniD234
+ENCODING 53812
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-08
-08
-04
-04
-04
-0C
-18
-F0
-00
-44
-28
-10
+0FF0
+3000
+1FE0
+1000
+1FE0
+0000
+FFFC
+0200
+0200
+1DC0
+0040
+1FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58929
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 12 1 -9
+STARTCHAR uniD23C
+ENCODING 53820
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-08
-0C
-07
-04
-04
-0C
-18
-F0
-00
-44
-28
-10
+3FF0
+1000
+1FE0
+1000
+1000
+1FF0
+0000
+FFFE
+0100
+1F00
+08E0
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58930
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 10 1 -6
+STARTCHAR uniD23D
+ENCODING 53821
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-08
-08
-04
-44
-44
-0C
-18
-F0
-04
-04
+1FF8
+0810
+0FF0
+0810
+0FF0
+0000
+FFFE
+0100
+1920
+0920
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58931
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 10 1 -7
+STARTCHAR uniD23F
+ENCODING 53823
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-08
-0C
-07
-44
-44
-0C
-18
-F0
-04
-04
+0FF8
+0800
+0FF0
+0800
+0FF0
+0000
+0000
+FFFE
+0100
+0100
+0100
+0300
+06C0
+0830
+3010
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58932
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 -4
+STARTCHAR uniD241
+ENCODING 53825
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-14
-14
-00
-00
-08
-08
-04
-04
-04
-0C
-18
-F0
+0FF8
+0800
+0FF0
+0800
+0FF8
+0000
+0000
+FFFE
+0100
+0300
+0CE0
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58933
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 12 1 -5
+STARTCHAR uniD248
+ENCODING 53832
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-14
-14
-00
-00
-08
-0C
-07
-04
-04
-0C
-18
-F0
+0018
+0008
+3FC8
+1008
+1F88
+10C8
+1FC8
+0008
+00C8
+FF08
+04F8
+0408
+0408
+0408
+0008
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58934
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 15 1 -4
+STARTCHAR uniD25C
+ENCODING 53852
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-14
-14
-00
-14
-14
-00
-00
-08
-08
-04
-04
-04
-0C
-18
-F0
+0030
+0110
+7F10
+2310
+3F10
+2110
+3F10
+FE10
+04F0
+0000
+0C30
+0420
+0A60
+1158
+2188
 ENDCHAR
-STARTCHAR 0069
-ENCODING 58935
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 -5
+STARTCHAR uniD264
+ENCODING 53860
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-14
-14
-00
-14
-14
-00
-00
-08
-0C
-07
-04
-04
-0C
-18
-F0
+0030
+0090
+0050
+FC50
+4050
+7C50
+4050
+7C50
+0050
+0E50
+7850
+09D0
+0850
+0850
+0010
 ENDCHAR
-STARTCHAR 0072
-ENCODING 58936
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 12 1 -5
+STARTCHAR uniD280
+ENCODING 53888
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
+0070
 0010
+3F90
+2010
+3810
+2610
+2010
+3F90
 0010
-0002
-0002
-0012
-0112
-40EC
-8080
-8080
-8088
-4308
-3C00
+00F0
+FF10
+0410
+0410
+0410
+0410
+0010
 ENDCHAR
-STARTCHAR 0071
-ENCODING 58937
+STARTCHAR uniD281
+ENCODING 53889
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 17 11 1 -5
+BBX 12 16 2 -3
 BITMAP
-001000
-001000
-000000
-000200
-011200
-40ED80
-808000
-808000
-808800
-430800
-3C0000
+0030
+7F10
+2010
+3F10
+2010
+3F10
+0010
+FFF0
+0410
+0400
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 006F
-ENCODING 58938
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 0 -4
+STARTCHAR uniD284
+ENCODING 53892
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-0100
-0100
-0000
+0060
 0020
-0120
-1120
-EEC0
-0000
-0000
-0080
-0080
+FE20
+4220
+7E20
+4020
+7E60
+3FA0
+C820
+0820
+0020
+1800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0070
-ENCODING 58939
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 11 0 -4
+STARTCHAR uniD288
+ENCODING 53896
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-0100
-0100
-0000
-0000
-0100
-1120
-EED8
-0000
-0000
-0080
-0080
+0018
+0008
+3F88
+1008
+1F88
+1088
+1F88
+0078
+FF88
+0600
+07F8
+0008
+0FF8
+0400
+07F8
 ENDCHAR
-STARTCHAR 0072
-ENCODING 58940
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 10 1 -6
+STARTCHAR uniD290
+ENCODING 53904
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-0002
-0012
-0112
-40EC
-8080
-8080
-8094
-4314
-3C08
+0030
+7F10
+2010
+3F10
+2010
+3F90
+0030
+FFD0
+0410
+0400
+0FF0
+0410
+0420
+0420
+07F0
+0400
+ENDCHAR
+STARTCHAR uniD291
+ENCODING 53905
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
+BITMAP
+0018
+3F88
+1008
+1F88
+1008
+1F88
 0008
+FFF8
+2408
+0418
+0608
+03F8
+0208
+0208
+03F8
+0208
+ENDCHAR
+STARTCHAR uniD295
+ENCODING 53909
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+3F10
+2010
+3F10
+2010
+3F10
+0010
+FFF0
+0410
+0490
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR 0071
-ENCODING 58941
+STARTCHAR uniD29C
+ENCODING 53916
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 17 9 1 -6
-BITMAP
-000200
-011200
-40ED80
-808000
-808000
-809400
-431400
-3C0800
-000800
-ENDCHAR
-STARTCHAR 006F
-ENCODING 58942
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 10 0 -6
+BBX 14 14 2 -2
 BITMAP
-0020
-0120
-1120
-EEC0
-0000
+1FF0
+1000
+1FE0
+1000
+1000
+1FF0
 0000
-0280
-0280
-0100
-0100
+FFFC
+0840
+0840
+0840
+0840
+0840
+0840
 ENDCHAR
-STARTCHAR 0070
-ENCODING 58943
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 9 0 -6
+STARTCHAR uniD2A0
+ENCODING 53920
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-0100
-1120
-EED8
-0000
+3FE0
+1000
+1000
+1FE0
+1000
+1FF0
 0000
-0280
-0280
-0100
-0100
+FFFC
+0840
+0840
+3040
+1040
+1000
+1FF0
 ENDCHAR
-STARTCHAR 0072
-ENCODING 58944
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 15 1 -6
+STARTCHAR uniD2A4
+ENCODING 53924
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-0010
-0010
-0028
-0028
+3FE0
+1000
+1FE0
+1020
+1FE0
 0000
-0002
-0012
-0112
-40EC
-8080
-8080
-8094
-4314
-3C08
-0008
+FFFC
+0880
+0880
+3FE0
+0040
+1FE0
+1000
+1FF0
 ENDCHAR
-STARTCHAR 0071
-ENCODING 58945
+STARTCHAR uniD2AC
+ENCODING 53932
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 17 14 1 -6
+BBX 15 14 1 -2
 BITMAP
-001000
-001000
-002800
-002800
-000000
-000200
-011200
-40ED80
-808000
-808000
-809400
-431400
-3C0800
-000800
+1FF0
+0800
+0FE0
+0810
+0FF0
+0000
+FFFE
+0C40
+0C60
+1FE0
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR 006F
-ENCODING 58946
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 15 0 -6
+STARTCHAR uniD2B1
+ENCODING 53937
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-0100
-0100
-0280
-0280
-0000
-0020
-0120
-1120
-EEC0
-0000
+1FF0
+1000
+1FE0
+1000
+1000
+1FF0
 0000
-0280
-0280
-0100
-0100
+FFFC
+0940
+0FC0
+0840
+0840
+0840
+0780
 ENDCHAR
-STARTCHAR 0070
-ENCODING 58947
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 15 0 -6
+STARTCHAR uniD2B8
+ENCODING 53944
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
 BITMAP
-0100
-0100
-0280
-0280
-0000
-0000
-0100
-1120
-EED8
+1FF0
+3000
+1000
+1000
+1FF0
+1000
+1030
+1FF0
 0000
 0000
-0280
-0280
-0100
-0100
-ENDCHAR
-STARTCHAR 0079
-ENCODING 58948
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 10 1 -5
-BITMAP
-000700
-000880
-001080
-012700
-40F800
-80C000
-808000
-808A00
-430A00
-3C0000
+FFFE
 ENDCHAR
-STARTCHAR 0079
-ENCODING 58949
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 18 10 1 -5
+STARTCHAR uniD2B9
+ENCODING 53945
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-000700
-000880
-001080
-012100
-40FFC0
-80C000
-808000
-808A00
-430A00
-3C0000
+3FE0
+1000
+1FE0
+1000
+1000
+1FF0
+0000
+FFFE
+2000
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0077
-ENCODING 58950
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 9 0 -4
+STARTCHAR uniD2BC
+ENCODING 53948
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
 0070
-0088
-0108
-2270
-DF80
-0400
+3FF0
+1000
+1FE0
+1000
+1FF0
+0004
+FFFE
 0000
-0140
-0140
+0000
+0800
+0800
+0810
+07F8
 ENDCHAR
-STARTCHAR 0078
-ENCODING 58951
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 9 0 -4
+STARTCHAR uniD2BF
+ENCODING 53951
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-00E0
-0110
-0210
-2420
-DFF8
+1FF0
 0800
+0FF0
+0800
+0FF0
 0000
-0280
-0280
-ENDCHAR
-STARTCHAR 0079
-ENCODING 58952
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 15 1 -5
-BITMAP
-001000
-001000
-002800
-002800
-000000
-000700
-000880
-001080
-012700
-40F800
-80C000
-808000
-808000
-430000
-3C0000
+FFFE
+2000
+0020
+1FF0
+0800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0079
-ENCODING 58953
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 18 15 1 -5
+STARTCHAR uniD2C0
+ENCODING 53952
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-001000
-001000
-002800
-002800
-000000
-000700
-000880
-001080
-012100
-40FFC0
-80C000
-808000
-808000
-430000
-3C0000
+1FC0
+6000
+3FC0
+2000
+2000
+3FC0
+7800
+87FC
+03E0
+3C40
+0040
+3FE0
+1000
+1FF0
 ENDCHAR
-STARTCHAR 0077
-ENCODING 58954
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 11 0 -1
+STARTCHAR uniD2C2
+ENCODING 53954
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-0100
-0100
-0280
-0280
+1FF0
+0800
+0FF0
+0800
+0FF0
 0000
-0070
-0088
-0108
-2270
-DF80
-0400
+0004
+FFFE
+2000
+3EF8
+0290
+3E90
+1090
+16F0
+0880
 ENDCHAR
-STARTCHAR 0078
-ENCODING 58955
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 11 0 -1
+STARTCHAR uniD2C8
+ENCODING 53960
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-0200
-0200
-0500
-0500
+3FF0
+1000
+1FE0
+1000
+1020
+1FF0
+0004
+FFFE
 0000
-00E0
-0110
-0210
-2420
-DFF8
+1FE0
+0820
+0820
+0820
+0FE0
 0800
 ENDCHAR
-STARTCHAR 00BC
-ENCODING 58956
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 10 1 0
-BITMAP
-22
-32
-25
-25
-20
-26
-29
-31
-26
-F8
-ENDCHAR
-STARTCHAR 00BD
-ENCODING 58957
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 10 1 0
+STARTCHAR uniD2C9
+ENCODING 53961
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-2200
-3200
-2500
-2500
-2000
-2600
-2900
-3100
-2200
-FFC0
+1FF0
+0800
+0FF0
+0800
+0FF0
+0000
+0004
+FFFE
+3820
+0820
+0FE0
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 00BC
-ENCODING 58958
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 10 0 0
+STARTCHAR uniD2CB
+ENCODING 53963
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-22
-32
-25
-25
-20
-26
-29
-31
-26
-F8
+3FF0
+1000
+1FE0
+1020
+1FF0
+0000
+0000
+FFFC
+0400
+0200
+0600
+0D80
+1060
+6020
 ENDCHAR
-STARTCHAR 00BD
-ENCODING 58959
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 10 0 0
+STARTCHAR uniD2D4
+ENCODING 53972
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-2200
-3200
-2500
-2500
-2000
-2600
-2900
-3100
-2200
-FFC0
+0040
+0020
+7F20
+4020
+4020
+7F20
+4020
+4020
+3F20
+01E0
+FE20
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00CB
-ENCODING 58960
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 18 1 -7
+STARTCHAR uniD2D8
+ENCODING 53976
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 3 -1
 BITMAP
+0060
+0220
+FE20
+4020
+7E20
+4120
+7F20
+0020
+1FE0
+E020
+3020
 1000
 1000
-2800
-2800
-0000
-0000
-3800
-4000
-8000
-4C00
-3000
-4000
-4000
-8000
-8000
-8000
-4180
-3E00
+1FF0
 ENDCHAR
-STARTCHAR 00CA
-ENCODING 58961
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 17 1 -6
+STARTCHAR uniD2DC
+ENCODING 53980
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-1000
-1000
-2800
-2800
-0000
+0030
+0110
+7F10
+2010
+3F10
+2190
+3F90
+00F0
+FF10
 0000
-3800
-6C00
-1000
-3800
-4780
-4000
-8000
-8000
-8000
-4180
-3E00
+0FF0
+0010
+07F0
+0400
+07F8
 ENDCHAR
-STARTCHAR 00C8
-ENCODING 58962
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 11 0 0
+STARTCHAR uniD2E4
+ENCODING 53988
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-08
-08
-14
-14
-00
-00
-1C
-20
-40
-26
-F8
+0030
+0110
+7F10
+2010
+3F10
+2190
+3F90
+00F0
+FF10
+0000
+0FF0
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR 00C5
-ENCODING 58963
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 11 0 0
+STARTCHAR uniD2E5
+ENCODING 53989
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-08
-08
-14
-14
-00
-00
-1C
-36
-08
-1C
-E3
+0060
+0020
+7E20
+4020
+7E20
+4020
+7F20
+07E0
+F800
+1860
+0860
+0FC0
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58964
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 8 1 0
+STARTCHAR uniD2F0
+ENCODING 54000
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-0018
-002C
-0024
-802C
-8014
-8004
-4038
-3FC0
+0060
+0010
+0210
+FE10
+4010
+4010
+4210
+7E10
+4010
+4010
+40F0
+7F10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58965
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 8 1 -1
+STARTCHAR uniD2F1
+ENCODING 54001
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 4 -2
 BITMAP
-0018
-002C
-0024
-802C
-8014
-8004
-403B
-3FC0
+01C0
+0440
+FC40
+8040
+8440
+FC40
+80C0
+8740
+7840
+0000
+7F80
+0080
+0080
+0080
+0080
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58966
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 7 0 0
+STARTCHAR uniD2F4
+ENCODING 54004
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-30
-58
-48
-58
-28
-08
-F0
+0060
+0020
+0420
+FC20
+8420
+FC20
+8020
+80E0
+FF20
+4020
+1020
+0820
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58967
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 6 0 0
+STARTCHAR uniD2F8
+ENCODING 54008
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 4 -2
 BITMAP
-18
-24
-24
-28
-10
-EF
+01C0
+0040
+FC40
+8040
+8040
+FC40
+80C0
+8F40
+7000
+3FC0
+0040
+3FC0
+1000
+1000
+1FE0
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58968
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 12 1 -4
+STARTCHAR uniD300
+ENCODING 54016
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
 BITMAP
-0018
-002C
-0024
-802C
-8014
-8004
-4038
-3FC0
-0000
+0060
+0420
+FC20
+8020
+8420
+FC20
+8020
+83E0
+7C20
 0000
-0100
-0100
+3FC0
+1040
+1040
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58969
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 1 -5
+STARTCHAR uniD301
+ENCODING 54017
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-0018
-002C
-0024
-802C
-8014
-8004
-403B
-3FC0
-0000
-0000
-0100
-0100
+0030
+0010
+FF10
+2010
+2010
+3F10
+2010
+21F0
+3E10
+0C20
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58970
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 0 -4
+STARTCHAR uniD303
+ENCODING 54019
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-30
-58
-48
-58
-28
-08
-F0
-00
-00
-80
-80
+0060
+0020
+FC20
+8020
+8020
+FC20
+8020
+80E0
+8F20
+7620
+0300
+0300
+0480
+1860
+2020
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58971
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 10 0 -4
+STARTCHAR uniD305
+ENCODING 54021
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-18
-24
-24
-28
-10
-EF
-00
-00
-40
-40
+0060
+0020
+DE20
+6020
+4020
+7E20
+4020
+43E0
+7C20
+0120
+0680
+0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58972
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 16 1 -4
+STARTCHAR uniD30C
+ENCODING 54028
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-0010
-0010
-0000
-0000
-0018
-002C
-0024
-802C
-8014
-8004
-4038
-3FC0
-0000
-0000
-0100
-0100
+0060
+0020
+00A0
+7FA0
+0620
+2120
+1220
+123C
+1220
+03E0
+FC20
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58973
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 16 1 -5
+STARTCHAR uniD30D
+ENCODING 54029
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-0010
-0010
-0000
-0000
-0018
-002C
-0024
-802C
-8014
-8004
-403B
-3FC0
-0000
+00C0
+01A0
+7FA0
+0020
+2220
+122C
+1230
+03E0
+FC20
+3FE0
+0020
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniD30E
+ENCODING 54030
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
+BITMAP
+0060
+01A0
+7F20
+0220
+2220
+143C
+13E0
+FC20
 0000
-0100
-0100
+07E0
+3C20
+0420
+0420
+0420
+0420
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58974
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 15 0 -4
+STARTCHAR uniD310
+ENCODING 54032
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-20
-20
-00
-00
-30
-58
-48
-58
-28
-08
-F0
-00
-00
-80
-80
+0060
+01A0
+7E20
+2620
+2220
+1220
+123C
+05E0
+FA20
+0020
+1820
+0820
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58975
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 14 0 -4
+STARTCHAR uniD314
+ENCODING 54036
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-08
-08
-00
-00
-18
-24
-24
-28
-10
-EF
-00
-00
-40
-40
+0160
+7F20
+0020
+2320
+1220
+123C
+03E0
+FC20
+1FE0
+0020
+0020
+0FE0
+0800
+0FF8
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58976
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 13 1 -5
+STARTCHAR uniD316
+ENCODING 54038
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 1 -3
 BITMAP
-0018
-002C
-0024
-802C
-8014
-8004
-4038
-3FC0
-0000
-0028
-0028
-0010
-0010
+0060
+0090
+3FD0
+0310
+1110
+1910
+027C
+FF90
+2010
+3EF8
+0290
+3690
+1890
+1190
+1EF8
+0080
 ENDCHAR
-STARTCHAR 00CF
-ENCODING 58977
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 13 1 -6
+STARTCHAR uniD31C
+ENCODING 54044
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
 BITMAP
-0018
-002C
-0024
-802C
-8014
-8004
-403B
-3FC0
+0180
+0040
+FF40
+0040
+4440
+2448
+2470
+0FC0
+F040
 0000
-0028
-0028
-0010
-0010
+3FC0
+1080
+1080
+1080
+1F00
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58978
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 13 0 -6
+STARTCHAR uniD31D
+ENCODING 54045
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
 BITMAP
-30
-58
-48
-58
-28
-08
-F0
-00
-00
-50
-50
-20
-20
+00C0
+0120
+7FA0
+0020
+2220
+2220
+143C
+03E0
+FC20
+1820
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58979
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 12 0 -6
+STARTCHAR uniD31F
+ENCODING 54047
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-18
-24
-24
-28
-10
-EF
-00
-00
-28
-28
-10
-10
+00C0
+0020
+01A0
+3E20
+2320
+1220
+123C
+1460
+FFA0
+4120
+00A0
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR 00D2
-ENCODING 58980
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 -3
+STARTCHAR uniD320
+ENCODING 54048
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
 BITMAP
-0200
-0200
-0000
-0000
-0300
-0580
-0480
-0480
-4380
-8080
-8080
-8100
-4200
-3C00
+0180
+0040
+FF40
+0C40
+4440
+2448
+2470
+0FC0
+F040
+10C0
+0840
+1480
+2540
+4230
+8410
 ENDCHAR
-STARTCHAR 00D2
-ENCODING 58981
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 14 1 -5
+STARTCHAR uniD321
+ENCODING 54049
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-0200
-0200
-0000
-0000
-0300
-0580
-0480
-0480
-43E0
-8080
-8080
-8100
-4200
-3C00
+00C0
+0120
+7FA0
+0020
+2320
+122C
+1230
+14E0
+FF20
+00A0
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58982
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 5 11 0 0
+STARTCHAR uniD325
+ENCODING 54053
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-20
-20
-00
-00
-30
-58
-48
-58
-28
-08
-F0
+00C0
+0020
+7FA0
+0020
+2220
+1220
+1478
+1FA0
+E000
+0FE0
+0800
+0FE0
+0800
+0800
+07F0
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58983
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 10 0 0
+STARTCHAR uniD328
+ENCODING 54056
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-10
-10
-00
-00
-18
-24
-24
-28
-10
-EF
+0018
+00C8
+0048
+4748
+3848
+2248
+2248
+1478
+1448
+8FC8
+7048
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR 00D2
-ENCODING 58984
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 16 1 -3
+STARTCHAR uniD329
+ENCODING 54057
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-0200
-0200
-0500
-0500
-0000
-0000
-0300
-0580
-0480
-0480
-4380
-8080
-8080
-8100
-4200
-3C00
+0060
+0090
+0050
+7E50
+0050
+2250
+2270
+0450
+05D0
+FA50
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 00D2
-ENCODING 58985
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 16 1 -5
+STARTCHAR uniD32C
+ENCODING 54060
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-0200
-0200
-0500
-0500
-0000
-0000
-0300
-0580
-0480
-0480
-43E0
-8080
-8080
-8100
-4200
-3C00
+0030
+0190
+0090
+7E90
+0490
+0490
+2890
+28F0
+0F90
+F090
+0090
+0C10
+0400
+0400
+07FC
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58986
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 5 13 0 0
+STARTCHAR uniD330
+ENCODING 54064
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-20
-20
-50
-50
-00
-00
-30
-58
-48
-58
-28
-08
-F0
+0060
+0190
+0090
+FE90
+4490
+2490
+28F0
+0F90
+F090
+1FE0
+0020
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00CC
-ENCODING 58987
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 12 0 0
+STARTCHAR uniD338
+ENCODING 54072
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-10
-10
-28
-28
-00
-00
-18
-24
-24
-28
-10
-EF
+0040
+0130
+0090
+FE90
+4C90
+2490
+24F0
+2B90
+F490
+0090
+07F0
+0410
+0420
+0420
+07F0
 ENDCHAR
-STARTCHAR 0x006C
-ENCODING 58988
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 8 0 0
+STARTCHAR uniD339
+ENCODING 54073
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-0600
-1800
-2000
-2000
-1FF8
-0004
-8004
-7FF8
+0060
+0110
+0090
+FE90
+4490
+2490
+24F0
+2B90
+F490
+0C90
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 0x006D
-ENCODING 58989
+STARTCHAR uniD33B
+ENCODING 54075
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 16 9 1 0
+BBX 13 15 2 -3
 BITMAP
+0130
+0090
+FE90
+4C90
+4490
+28F0
+2890
+1F90
+E110
+0080
 0180
-0600
-1800
-2000
-2000
-1FF8
-0004
-8004
-7FFB
+0240
+0430
+0808
+1000
 ENDCHAR
-STARTCHAR 0x006E
-ENCODING 58990
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 8 0 0
+STARTCHAR uniD33C
+ENCODING 54076
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-0600
-1800
-2000
-2000
-1FF8
-0004
-0004
-FFF8
+0060
+0190
+0090
+7C90
+4490
+2490
+24F0
+0790
+F890
+00D0
+0420
+0420
+0A60
+1298
+2104
 ENDCHAR
-STARTCHAR 0x006F
-ENCODING 58991
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 8 0 0
+STARTCHAR uniD33D
+ENCODING 54077
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 14 2 -2
 BITMAP
-0600
-1800
-2000
-2000
-1FF8
-0004
-0004
-FFFB
+0130
+0090
+FC90
+4C90
+4490
+28F0
+2890
+1F90
+E090
+01C0
+0620
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 58992
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 14 1 -1
+STARTCHAR uniD344
+ENCODING 54084
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-0006
-0018
-0068
-01A8
-0210
-0200
-0100
 00C0
 0020
-4010
-8008
-8008
-C030
-7FC0
+00A0
+7FA0
+0020
+032C
+2130
+1220
+1220
+1264
+FFB8
+4020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 58993
+STARTCHAR uniD345
+ENCODING 54085
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 16 14 1 -1
+BBX 15 15 1 -2
 BITMAP
-0006
-0018
-0068
-01A8
-0210
-0200
-0100
-00C0
-0020
-4010
-8008
-8008
-C037
-7FC0
+0060
+0010
+0010
+3F90
+011C
+1110
+0910
+02FE
+FD10
+1FF0
+0810
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 00D4
-ENCODING 58994
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 11 0 0
+STARTCHAR uniD37C
+ENCODING 54140
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-00C0
-0300
-0D00
-3500
-4200
-4000
-2000
-1800
-0400
-0400
-F800
+0030
+0010
+0110
+FF10
+0010
+0310
+22F0
+3210
+1210
+0490
+FF10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 00D5
-ENCODING 58995
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 0
+STARTCHAR uniD37D
+ENCODING 54141
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-00C0
-0300
-0D00
-3500
-4200
-4000
-2000
-1800
-0400
-0700
-F8E0
+0030
+0110
+FF10
+0610
+2210
+2270
+1210
+0510
+FA10
+0000
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0xFED9
-ENCODING 58996
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 13 1 0
+STARTCHAR uniD380
+ENCODING 54144
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
+0060
+0020
+FF20
+0020
+4420
+45E0
+2420
+2820
+1E20
+E020
+0020
+0820
 0800
 0800
-0000
-0100
-0180
-0100
-0900
-1900
-0900
-1900
-0100
-0100
-FE00
+07F0
 ENDCHAR
-STARTCHAR 0xFEDA
-ENCODING 58997
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 14 1 -1
+STARTCHAR uniD384
+ENCODING 54148
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0200
-0200
-0000
-0010
-0018
+0030
 0010
-0210
+FF10
 0610
-0210
-4610
-8010
-8010
-C06C
-7F80
+22F0
+3210
+1410
+0710
+7800
+1FE0
+0020
+1FE0
+0800
+0810
+0FF0
 ENDCHAR
-STARTCHAR 00D4
-ENCODING 58998
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 13 0 0
+STARTCHAR uniD38C
+ENCODING 54156
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-1000
-1000
-00C0
-0300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
+0030
+0010
+7F90
+0410
+2210
+2270
+1210
+1590
+FA10
+0000
+0FF0
+0420
+0420
+0420
+07F0
 0400
-F800
 ENDCHAR
-STARTCHAR 00D5
-ENCODING 58999
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 13 0 0
+STARTCHAR uniD38D
+ENCODING 54157
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-1000
-1000
-00C0
-0300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
-0700
-F8E0
+0030
+0110
+FF10
+0610
+22F0
+2210
+0410
+0F10
+F000
+0C10
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 0xFED9
-ENCODING 59000
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 16 1 -6
+STARTCHAR uniD38F
+ENCODING 54159
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-0100
+0030
+0110
+FF10
+0610
+2310
+2270
+1210
+0590
+FA10
+0110
 0180
-0100
-0900
-1900
-0900
-1900
-0100
-0100
-FE00
-0000
-0000
-2800
-2800
-1000
-1000
+0180
+0260
+0C10
+3008
 ENDCHAR
-STARTCHAR 0xFEDA
-ENCODING 59001
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 14 20 1 -7
+STARTCHAR uniD390
+ENCODING 54160
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-0200
-0200
-0000
-0010
-0018
-0010
-0210
+0030
+0110
+FF10
 0610
-0210
-4610
-8010
-8010
-C06C
-7F80
-0000
-0000
-0A00
-0A00
-0400
-0400
-ENDCHAR
-STARTCHAR 00D4
-ENCODING 59002
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 19 0 -6
-BITMAP
-1000
-1000
-00C0
-0300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
-0400
-F800
-0000
-0000
-5000
-5000
-2000
-2000
+2210
+2270
+2210
+0590
+FA10
+0060
+0C20
+0840
+1E60
+2290
+4108
 ENDCHAR
-STARTCHAR 00D5
-ENCODING 59003
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 19 0 -6
+STARTCHAR uniD391
+ENCODING 54161
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-1000
-1000
-00C0
-0300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
-0700
-F8E0
-0000
-0000
-5000
-5000
-2000
-2000
+0030
+0110
+FF10
+0610
+2310
+2270
+3210
+0590
+FA10
+0080
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 59004
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 17 1 -1
+STARTCHAR uniD398
+ENCODING 54168
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-0004
 0018
-0060
-0186
-0218
-0068
-01A8
-0210
-0200
-0100
-00C0
-0020
-4010
-8008
-8008
-C030
-7FC0
+0008
+00C8
+0748
+3848
+2448
+2448
+17C8
+1448
+1948
+FE48
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 59005
+STARTCHAR uniD399
+ENCODING 54169
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 16 17 1 -1
+BBX 13 16 1 -3
 BITMAP
-0004
-0018
-0060
-0186
-0218
-0068
-01A8
-0210
-0200
-0100
-00C0
-0020
-4010
-8008
-8008
-C037
-7FC0
+0030
+0098
+0348
+3C48
+2448
+17C8
+1448
+0648
+F848
+0008
+0FF8
+0408
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR 00D4
-ENCODING 59006
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 14 0 0
+STARTCHAR uniD39C
+ENCODING 54172
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-0080
-0300
-0C00
-30C0
-4300
-0D00
-3500
-4200
-4000
-2000
-1800
+0030
+0110
+0090
+FE90
+0890
+4490
+2B90
+2890
+0C90
+F090
+0090
+0410
 0400
 0400
-F800
+07F8
 ENDCHAR
-STARTCHAR 00D5
-ENCODING 59007
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 0 0
+STARTCHAR uniD3A0
+ENCODING 54176
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0080
-0300
-0C00
-30C0
-4300
-0D00
-3500
-4200
-4000
-2000
-1800
-0400
-0700
-F8E0
+0030
+0110
+0690
+7890
+4890
+2F90
+2890
+0C90
+FFE0
+0020
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 59008
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 21 1 -5
+STARTCHAR uniD3A8
+ENCODING 54184
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
 BITMAP
-0004
 0018
-0060
-0186
-0218
-0060
-0180
-0200
+0088
+0248
+7F48
+2448
+17C8
+1448
+0A48
+F448
+0040
+07F8
+0208
+0210
+0210
+03F8
 0200
-0100
-00C0
-0020
-4010
-8008
-8008
-C030
-7FC0
-0000
-0000
-0500
-0500
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 59009
+STARTCHAR uniD3A9
+ENCODING 54185
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 16 21 1 -5
+BBX 13 16 1 -3
 BITMAP
-0004
 0018
-0060
-0186
-0218
-0060
-0180
-0200
-0200
-0100
-00C0
-0020
-4010
-8008
-8008
-C037
-7FC0
-0000
-0000
-0500
-0500
+0088
+0348
+3C48
+2448
+17C8
+1448
+0A48
+F448
+0418
+0208
+03F8
+0208
+0208
+03F8
+0208
 ENDCHAR
-STARTCHAR 00D4
-ENCODING 59010
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 18 0 -4
+STARTCHAR uniD3AB
+ENCODING 54187
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
 BITMAP
+0018
+0088
+0048
+7E48
+2448
+17C8
+1448
+0648
+F848
+01C8
+00C8
 0080
-0300
-0C00
-30C0
-4300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
-0400
-F800
-0000
-0000
-5000
-5000
+0160
+0218
+0C04
 ENDCHAR
-STARTCHAR 00D5
-ENCODING 59011
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 18 0 -4
+STARTCHAR uniD3AD
+ENCODING 54189
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0080
-0300
-0C00
-30C0
-4300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
-0700
-F8E0
-0000
-0000
-5000
-5000
+0030
+0110
+0090
+FE90
+4890
+2F90
+2890
+0C90
+F090
+0090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 59012
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 20 1 -1
+STARTCHAR uniD3B4
+ENCODING 54196
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-0100
-0100
-0040
-0144
-0118
-0060
-0186
-0218
-0060
-0180
-0200
-0200
-0100
-00C0
-0020
-4010
-8008
-8008
-C030
-7FC0
+0018
+0008
+0088
+7F88
+0278
+0108
+1108
+1908
+1A38
+0248
+FF88
+0008
+0008
+0008
+0008
 ENDCHAR
-STARTCHAR 00D7
-ENCODING 59013
+STARTCHAR uniD3B8
+ENCODING 54200
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 16 20 1 -1
+BBX 12 15 2 -2
 BITMAP
-0100
-0100
-0040
-0144
-0118
-0060
-0186
-0218
-0060
-0180
-0200
-0200
-0100
-00C0
-0020
+0030
+0010
+FF10
+44F0
+4210
+2210
+24F0
+2410
+3E10
 4010
-8008
-8008
-C037
-7FC0
-ENDCHAR
-STARTCHAR 00D4
-ENCODING 59014
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 0 0
-BITMAP
-2000
-2000
+0010
+1810
 0800
-2880
-2300
-0C00
-30C0
-4300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
-0400
-F800
-ENDCHAR
-STARTCHAR 00D5
-ENCODING 59015
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 17 0 0
-BITMAP
-2000
-2000
 0800
-2880
-2300
-0C00
-30C0
-4300
-0C00
-3000
-4000
-4000
-2000
-1800
-0400
-0700
-F8E0
+0FF0
 ENDCHAR
-STARTCHAR 00DE
-ENCODING 59016
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 17 1 -2
+STARTCHAR uniD3BC
+ENCODING 54204
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0880
-0500
-0200
-0000
-0000
-0200
-0300
-0200
-0200
-0200
-0200
-0200
-4200
-8200
-8200
-8400
-7800
+0030
+0010
+FF10
+04F0
+2210
+2410
+24F0
+0710
+F800
+1FF0
+0020
+1FF0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00DE
-ENCODING 59017
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 19 1 -4
+STARTCHAR uniD3C4
+ENCODING 54212
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -3
 BITMAP
-0880
-0500
-0200
-0000
-0000
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0300
-4280
-8200
-8200
-8400
-7800
+0030
+FF10
+0010
+0270
+2210
+2410
+0470
+0E10
+7010
+0FF0
+0410
+0420
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR 00DC
-ENCODING 59018
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 15 0 0
+STARTCHAR uniD3C5
+ENCODING 54213
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-88
-50
-20
-00
-00
-20
-30
-20
-20
-20
-20
-20
-20
-20
-C0
+0030
+0110
+FF10
+04F0
+2210
+2210
+24F0
+0710
+F800
+0C10
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 00DC
-ENCODING 59019
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 5 15 0 0
+STARTCHAR uniD3C8
+ENCODING 54216
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-88
-50
-20
-00
-00
-20
-20
-20
-20
-20
-20
-20
-20
-20
-D0
+0060
+0010
+FF10
+0410
+0270
+2410
+2410
+0970
+FE10
+1860
+0C20
+0C60
+1250
+2298
+4108
 ENDCHAR
-STARTCHAR 00DE
-ENCODING 59020
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 16 1 -2
+STARTCHAR uniD3C9
+ENCODING 54217
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-02
-02
-00
-00
-02
-03
-02
-02
-02
-02
-02
-42
-82
-82
-84
-78
+0030
+0310
+FF10
+00F0
+4210
+2410
+24F0
+2410
+0E10
+7090
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR 00DE
-ENCODING 59021
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 18 1 -4
+STARTCHAR uniD3D0
+ENCODING 54224
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-0200
-0200
-0000
-0000
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0300
-4280
-8200
-8200
-8400
-7800
+0018
+0088
+0048
+4748
+3848
+27C8
+2448
+1448
+15C8
+1948
+FE48
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR 00DC
-ENCODING 59022
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 14 0 0
+STARTCHAR uniD3D8
+ENCODING 54232
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-20
-20
-00
-00
-20
-30
-20
-20
-20
-20
-20
-20
-20
-C0
+0030
+0110
+0690
+7890
+4790
+2890
+2B90
+0E90
+FFE0
+0020
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00DC
-ENCODING 59023
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 4 14 0 0
+STARTCHAR uniD3E1
+ENCODING 54241
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-20
-20
-00
-00
-20
-20
-20
-20
-20
-20
-20
-20
-20
-D0
+0030
+0110
+0690
+7890
+4790
+2890
+2B90
+0E90
+F080
+0C10
+0410
+07F0
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 00DE
-ENCODING 59024
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 18 1 -2
+STARTCHAR uniD3E3
+ENCODING 54243
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-02
-02
-05
-05
-00
-00
-02
-03
-02
-02
-02
-02
-02
-42
-82
-82
-84
-78
+0030
+0110
+0690
+7890
+4790
+2890
+2B90
+0E90
+F090
+0190
+0080
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR 00DE
-ENCODING 59025
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 20 1 -4
+STARTCHAR uniD3EC
+ENCODING 54252
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 12 1 0
 BITMAP
-0200
-0200
-0500
-0500
-0000
+0010
+3FF8
 0000
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0300
-4280
-8200
-8200
-8400
-7800
+0020
+0440
+0440
+0040
+3FF8
+0100
+0100
+0100
+FFFE
 ENDCHAR
-STARTCHAR 00DC
-ENCODING 59026
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 16 0 0
+STARTCHAR uniD3ED
+ENCODING 54253
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-20
-20
-50
-50
-00
-00
-20
-30
-20
-20
-20
-20
-20
-20
-20
-C0
+0010
+1FF8
+0840
+0440
+0480
+1FF0
+0100
+0100
+FFFE
+2000
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00DC
-ENCODING 59027
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 4 16 0 0
+STARTCHAR uniD3F0
+ENCODING 54256
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -1
 BITMAP
-20
-20
-50
-50
-00
-00
-20
-20
-20
-20
-20
-20
-20
-20
-20
-D0
+2078
+1FE0
+0440
+0480
+1FF0
+0100
+0100
+FFFE
+6000
+0800
+0800
+0800
+07F8
 ENDCHAR
-STARTCHAR 00E7
-ENCODING 59028
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 1 -3
+STARTCHAR uniD3F4
+ENCODING 54260
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-1000
-1000
+0010
+1FF0
+0840
+0440
+0480
+1B60
+0100
+FFFE
 0000
-0200
-0200
-4100
-8100
-8100
-8300
-7E80
-0380
-ENDCHAR
-STARTCHAR 00E7
-ENCODING 59029
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 11 1 -5
-BITMAP
-1000
-1000
 0000
-0200
-0200
-4180
-8100
-8100
-8300
-7E80
-0380
-ENDCHAR
-STARTCHAR 00E4
-ENCODING 59030
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 12 0 -3
-BITMAP
-20
-20
-00
-00
-10
-08
-08
-08
-F0
-60
-90
-60
+0FE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00E5
-ENCODING 59031
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 11 0 -3
+STARTCHAR uniD3FC
+ENCODING 54268
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-10
-10
-00
-00
-10
-10
-10
-EC
-60
-90
-60
+1FF8
+0040
+0480
+0680
+3FF0
+0100
+0100
+FFFE
+0000
+1FE0
+0820
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR 00E7
-ENCODING 59032
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 12 1 -2
+STARTCHAR uniD3FD
+ENCODING 54269
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-08
-08
-14
-14
-00
-02
-02
-41
-81
-81
-82
-7C
+0010
+1FF0
+0840
+0440
+0480
+1B60
+0100
+FFFE
+0000
+1860
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 00E7
-ENCODING 59033
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 12 1 -4
+STARTCHAR uniD3FF
+ENCODING 54271
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0800
-0800
-1400
-1400
+1FF8
 0000
-0200
+0460
+0440
+0040
+0FB0
+0100
+FFFE
 0200
-4180
-8100
-8100
-8200
-7C00
-ENDCHAR
-STARTCHAR 00E4
-ENCODING 59034
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 0 -6
-BITMAP
-10
-08
-08
-08
-F0
-00
-00
-28
-28
-10
-10
-ENDCHAR
-STARTCHAR 00E5
-ENCODING 59035
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 10 0 -6
-BITMAP
-10
-10
-10
-EC
-00
-00
-28
-28
-10
-10
+0100
+0300
+06C0
+0830
+3018
 ENDCHAR
-STARTCHAR 0x009C
-ENCODING 59036
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 4 11 1 0
+STARTCHAR uniD401
+ENCODING 54273
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-30
-40
-30
-40
-00
-20
-30
-50
-90
-90
-60
+1FF8
+0840
+0440
+0480
+01F0
+0F00
+0100
+FFFE
+0100
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR 0x009D
-ENCODING 59037
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 12 1 0
+STARTCHAR uniD408
+ENCODING 54280
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-18
-20
-18
-20
-00
-10
-30
-50
-90
-90
-70
-0C
+0060
+00D0
+7FD0
+0210
+1310
+0A10
+0A90
+7D16
+0418
+0430
+8FD0
+7010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0x009E
-ENCODING 59038
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 11 1 0
+STARTCHAR uniD41D
+ENCODING 54301
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-30
-40
-30
-40
-00
-20
-30
-50
-90
-90
-60
+0060
+0120
+FF20
+0420
+2220
+1420
+FF20
+0838
+0FA0
+F120
+06C0
+0820
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR 0x009F
-ENCODING 59039
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 10 1 0
+STARTCHAR uniD440
+ENCODING 54336
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-18
-20
-18
-20
-00
-00
-30
-78
-8C
-04
+0060
+0090
+7F90
+0210
+1310
+1210
+1290
+7F10
+0410
+0430
+8FD0
+7010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0x00A0
-ENCODING 59040
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 4 10 1 0
+STARTCHAR uniD444
+ENCODING 54340
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
 BITMAP
-50
-50
-00
-00
-20
-30
-50
-90
-90
-60
+0018
+0048
+3FC8
+0108
+0A08
+0BC8
+7408
+0418
+8FE8
+7008
+0008
+0600
+0200
+0200
+03FC
 ENDCHAR
-STARTCHAR 0x00A1
-ENCODING 59041
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 8 1 0
+STARTCHAR uniD45C
+ENCODING 54364
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 12 2 0
 BITMAP
-28
-28
-00
-00
-30
-78
-8C
-04
+0020
+7FF0
+10C0
+1080
+0880
+0900
+7FF0
+18C0
+0840
+0840
+0848
+FFFC
 ENDCHAR
-STARTCHAR 0xFE85
-ENCODING 59042
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 8 0 -3
+STARTCHAR uniD460
+ENCODING 54368
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -1
 BITMAP
-04
-0A
-0A
-0E
-12
-2A
-94
-78
+0018
+1FF8
+0460
+0440
+0040
+0FF0
+0440
+FFFE
+0000
+0800
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR 0xFE86
-ENCODING 59043
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 8 1 -4
+STARTCHAR uniD464
+ENCODING 54372
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0400
-0A00
-0A00
-0780
-1200
-2A00
-9400
-7800
+1FF8
+0040
+0440
+0480
+01E0
+1E40
+0440
+FFFE
+1FE0
+0020
+0020
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0xFE85
-ENCODING 59044
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 12 0 -3
+STARTCHAR uniD46D
+ENCODING 54381
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-0A
-0A
-00
-00
-04
-0A
-0A
-0E
-02
-02
-84
-78
+1FF8
+0060
+0440
+0440
+01F0
+0E40
+0440
+FFFE
+1860
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 0xFE86
-ENCODING 59045
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 12 1 -4
+STARTCHAR uniD46F
+ENCODING 54383
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0A00
-0A00
-0000
-0000
-0400
-0A00
-0A00
-0780
-0200
+1FF8
+0060
+0440
+0440
+01F0
+0E40
+0440
+FFFE
 0200
-8400
-7800
+0100
+0300
+06C0
+0830
+3008
 ENDCHAR
-STARTCHAR 00F0
-ENCODING 59046
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 8 0 -2
+STARTCHAR uniD478
+ENCODING 54392
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-0078
+0010
+3FF8
 0080
-1080
-2060
-6010
-A010
-1060
-0F80
+0840
+0440
+0480
+3FF0
+0000
+FFFE
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR 00F0
-ENCODING 59047
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 6 1 -5
+STARTCHAR uniD479
+ENCODING 54393
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-1078
-2080
-6060
-A010
-1060
-0F80
+0010
+3FF0
+0840
+0440
+0480
+1FF0
+0000
+FFFE
+0100
+0100
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00F0
-ENCODING 59048
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 -2
+STARTCHAR uniD47C
+ENCODING 54396
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-4400
-2800
-1000
-01E0
-0200
-4200
-8180
-8040
-8040
-4180
-3E00
+0010
+3FF8
+0060
+0440
+0480
+1FF0
+0000
+0000
+FFFE
+0100
+0100
+0900
+0900
+0900
+07F8
 ENDCHAR
-STARTCHAR 00F0
-ENCODING 59049
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 1 -5
+STARTCHAR uniD47F
+ENCODING 54399
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-2200
-1400
-0800
-0000
+0010
+3FF8
+0060
+0440
+0480
+1FF0
 0000
-41E0
-8200
-8180
-8040
-4180
-3E00
+803E
+7FC0
+0100
+0160
+1E80
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00E4
-ENCODING 59050
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 10 0 0
+STARTCHAR uniD480
+ENCODING 54400
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-44
-28
-10
-00
-00
-10
-08
-08
-08
-F0
+0010
+1FF8
+0840
+0440
+0480
+1FF0
+0004
+FFFE
+0100
+1FE0
+0020
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00E5
-ENCODING 59051
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 9 0 0
+STARTCHAR uniD482
+ENCODING 54402
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-44
-28
-10
-00
-00
-10
-10
-10
-EC
+0010
+1FF8
+0860
+0440
+0490
+1FF0
+0000
+FFFE
+0100
+0100
+1EF8
+2288
+1C90
+1690
+08F0
+0080
 ENDCHAR
-STARTCHAR 00F0
-ENCODING 59052
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 1 -7
+STARTCHAR uniD488
+ENCODING 54408
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-01E0
-0200
-4200
-8180
-8040
-8040
-4180
-3E00
+3FF8
+0040
+0440
+0490
+3FF0
 0000
-2800
-2800
-1000
-1000
+0004
+FFFE
+0100
+1F00
+08E0
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR 00F0
-ENCODING 59053
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 1 -10
+STARTCHAR uniD489
+ENCODING 54409
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-41E0
-8200
-8180
-8040
-4180
-3E00
+0010
+3FF0
+0040
+0440
+0490
+1FF0
 0000
-2800
-2800
-1000
-1000
+FFFE
+0100
+0D20
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR 00E4
-ENCODING 59054
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 10 0 -5
+STARTCHAR uniD48B
+ENCODING 54411
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
 BITMAP
-10
-08
-08
-08
-F0
-00
-50
-50
-20
-20
+3FF0
+10C0
+0880
+0920
+3FF0
+0000
+0000
+FFFC
+0200
+0200
+0200
+0200
+0580
+0860
+3020
 ENDCHAR
-STARTCHAR 00E5
-ENCODING 59055
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 9 0 -5
+STARTCHAR uniD48D
+ENCODING 54413
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-10
-10
-10
-EC
-00
-28
-28
-10
-10
+3FF0
+00C0
+0880
+0880
+3FE0
+0000
+0008
+FFFC
+0100
+0200
+0DC0
+0840
+0C40
+0780
 ENDCHAR
-STARTCHAR 00E4
-ENCODING 59056
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 5 0 0
+STARTCHAR uniD494
+ENCODING 54420
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-10
-08
-08
-08
-F0
+0030
+0010
+FF90
+0610
+1210
+1410
+FF10
+0010
+0F10
+F9F0
+0810
+0810
+0810
+0810
+0010
 ENDCHAR
-STARTCHAR 00E5
-ENCODING 59057
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 4 0 0
+STARTCHAR uniD4A9
+ENCODING 54441
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-10
-10
-10
-EC
+0030
+0110
+FF10
+2610
+1410
+0590
+7A10
+0310
+FCF0
+0810
+0880
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR 0xFE86
-ENCODING 59058
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 14 1 -4
+STARTCHAR uniD4CC
+ENCODING 54476
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-1180
-2A00
-1180
-2A00
-4000
-0000
-0400
-0A00
-0A00
-0780
-0200
-0200
-8400
-7800
+0030
+0010
+7F90
+2210
+1110
+1210
+05D0
+3A10
+01F0
+FE10
+0410
+0410
+0410
+0410
+0010
 ENDCHAR
-STARTCHAR 0072
-ENCODING 59059
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 14 1 -5
+STARTCHAR uniD4D0
+ENCODING 54480
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
+0030
 0010
+7F90
+0210
+1210
+1390
+2C70
+FF90
+0410
+0410
 0010
-0028
-0028
-0000
-0002
-0012
-0112
-40EC
-8080
-8080
-8088
-4308
-3C00
+0C00
+0400
+0400
+03F8
 ENDCHAR
-STARTCHAR 0071
-ENCODING 59060
+STARTCHAR uniD4D4
+ENCODING 54484
 SWIDTH 1020 0
 DWIDTH 17 0
-BBX 17 13 1 -5
+BBX 13 15 2 -2
 BITMAP
-001000
-001000
-002800
-002800
-000000
-000200
-011200
-40ED80
-808000
-808000
-808800
-430800
-3C0000
+0030
+0090
+3F90
+1210
+1210
+0290
+7F90
+87F0
+7C10
+0400
+0FF0
+0010
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR 006F
-ENCODING 59061
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 13 0 -4
+STARTCHAR uniD4DC
+ENCODING 54492
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
 BITMAP
-0100
-0100
-0280
-0280
-0000
+0060
 0020
-0120
-1120
-EEC0
-0000
-0000
-0080
+FF20
+2420
+2420
+0520
+FF20
+03E0
+FC20
+0800
+1FE0
+0820
+0840
+0840
+0FE0
+0800
+ENDCHAR
+STARTCHAR uniD4DF
+ENCODING 54495
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+7F90
+0210
+1210
+1290
+7F90
+0030
+FFD0
+0410
+0590
 0080
+0180
+0240
+0430
+1808
 ENDCHAR
-STARTCHAR 0070
-ENCODING 59062
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 13 0 -4
+STARTCHAR uniD4E8
+ENCODING 54504
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
 BITMAP
-0100
-0100
-0280
-0280
-0000
+7FF0
+10C0
+0880
+08A0
+3FF0
 0000
-0100
-1120
-EED8
+0004
+FFFC
+0840
+0840
+0840
+0840
+0840
+0840
+0040
+ENDCHAR
+STARTCHAR uniD4EC
+ENCODING 54508
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+1FF8
 0000
+0040
+0440
+0480
+3FF0
 0000
-0080
-0080
+FFFE
+0440
+0840
+3040
+1040
+1000
+1FF0
 ENDCHAR
-STARTCHAR 0079
-ENCODING 59063
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 17 12 1 -5
+STARTCHAR uniD4F0
+ENCODING 54512
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-002000
-002000
-000700
-000880
-001080
-012700
-40F800
-80C000
-808000
-808400
-430400
-3C0000
+1FF8
+0040
+0440
+0440
+1FF0
+0000
+FFFE
+0440
+1FC0
+0020
+0020
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0079
-ENCODING 59064
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 18 12 1 -5
+STARTCHAR uniD4F8
+ENCODING 54520
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
 BITMAP
-002000
-002000
-000700
-000880
-001080
-012100
-40FFC0
-80C000
-808000
-808400
-430400
-3C0000
+3FF0
+1080
+0880
+0900
+7FE0
+0008
+FFFC
+0880
+0880
+1FC0
+1040
+1040
+1FC0
 ENDCHAR
-STARTCHAR 0077
-ENCODING 59065
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 13 11 0 -4
+STARTCHAR uniD4FB
+ENCODING 54523
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0200
-0200
-0070
-0088
-0108
-2270
-DF80
-0400
-0000
-0040
-0040
+1FF8
+0840
+0440
+0480
+1FF8
+0004
+FFFE
+0840
+0A40
+0180
+0180
+0240
+0C30
+1008
 ENDCHAR
-STARTCHAR 0078
-ENCODING 59066
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 11 0 -4
+STARTCHAR uniD4FD
+ENCODING 54525
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0400
-0400
-00E0
-0110
-0210
-2420
-DFF8
-0800
+1FF8
+0020
+0440
+0440
+1FF8
 0000
-0080
-0080
+0000
+FFFE
+04A0
+07E0
+0420
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR 00CB
-ENCODING 59067
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 16 1 -7
+STARTCHAR uniD504
+ENCODING 54532
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 11 2 0
 BITMAP
-2000
-2000
+7FF0
+0000
+0040
+0880
+0880
+0900
+7FF0
 0000
 0000
-3800
-4000
-8000
-4C00
-3000
-4000
-4000
-8800
-8800
-8000
-4180
-3E00
+0000
+FFFC
 ENDCHAR
-STARTCHAR 00CA
-ENCODING 59068
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 15 1 -6
+STARTCHAR uniD508
+ENCODING 54536
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
 BITMAP
-1000
-1000
+7FF0
 0000
+00C0
+0880
+0880
+3FF0
 0000
-3800
-6C00
+FFFC
+0000
+3000
 1000
-3800
-4780
-4000
-8800
-8800
-8000
-4180
-3E00
-ENDCHAR
-STARTCHAR 00C8
-ENCODING 59069
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 13 0 -4
-BITMAP
-10
-10
-00
-00
-1C
-20
-40
-26
-F8
-00
-00
-10
-10
+1000
+1FF0
 ENDCHAR
-STARTCHAR 00C5
-ENCODING 59070
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 13 0 -4
+STARTCHAR uniD50C
+ENCODING 54540
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-08
-08
-00
-00
-1C
-36
-08
-1C
-E3
-00
-00
-08
-08
+1FF8
+0840
+0440
+0480
+1FF0
+0000
+FFFE
+0000
+1FE0
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00FA
-ENCODING 59088
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 15 1 0
+STARTCHAR uniD514
+ENCODING 54548
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-11
-0A
-04
-00
-00
-C4
-E6
-24
-14
-14
-08
-0C
-14
-24
-38
+0010
+3FF8
+0040
+0440
+0480
+31F8
+0E00
+0000
+FFFE
+0000
+1FE0
+0820
+0820
+0820
+0FE0
+0800
 ENDCHAR
-STARTCHAR 00FB
-ENCODING 59089
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 16 1 -1
+STARTCHAR uniD515
+ENCODING 54549
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
 BITMAP
+7FF0
+0080
 0880
-0500
-0200
+0900
+3FE0
 0000
+FFFC
 0000
-0200
-6300
-7200
-1200
-0A00
-0A00
-0A00
-0D00
-0900
-30C0
-E000
-ENDCHAR
-STARTCHAR 00FA
-ENCODING 59090
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 14 1 0
-BITMAP
-04
-04
-00
-00
-C4
-E6
-24
-14
-14
-08
-0C
-14
-24
-38
+1840
+0840
+0FC0
+0840
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR 00FB
-ENCODING 59091
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 15 1 -1
+STARTCHAR uniD517
+ENCODING 54551
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-0200
-0200
-0000
-0000
-0200
-6300
-7200
-1200
-0A00
-0A00
-0A00
-0D00
-0900
-30C0
-E000
+0038
+0FE0
+0440
+0440
+01F8
+0E00
+0004
+FFFE
+0300
+0100
+0380
+0660
+0830
+3000
 ENDCHAR
-STARTCHAR 00FA
-ENCODING 59092
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 16 1 0
+STARTCHAR uniD53C
+ENCODING 54588
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-04
-04
-0A
-0A
-00
-00
-C4
-E6
-24
-14
-14
-08
-0C
-14
-24
-38
+0040
+0030
+0190
+FF90
+0010
+2110
+2110
+1110
+1210
+12F0
+FD10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 00FB
-ENCODING 59093
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 10 17 1 -1
+STARTCHAR uniD53D
+ENCODING 54589
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-0200
-0200
-0500
-0500
-0000
+0060
+0190
+FF90
+0210
+2110
+1110
+1210
+13F0
+FC10
 0000
-0200
-6300
-7200
-1200
-0A00
-0A00
-0A00
-0D00
-0900
-30C0
-E000
+7FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0x00F0
-ENCODING 59120
-SWIDTH 1260 0
-DWIDTH 21 0
-BBX 19 14 1 -4
+STARTCHAR uniD540
+ENCODING 54592
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-028000
-028000
-02C000
-028000
-028000
-028000
-028840
-028460
-828420
-828420
-827820
-440040
-3858C0
-005780
+0060
+0010
+0190
+FF90
+2310
+2110
+1210
+1270
+1F90
+6010
+0010
+1810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR 0032
-ENCODING 59124
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 10 2 0
+STARTCHAR uniD544
+ENCODING 54596
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-B9
-EE
-E4
-60
-60
-20
-30
-10
-10
-10
+0060
+0190
+FF90
+0210
+2110
+1110
+1210
+03F0
+7C10
+1FF0
+0020
+1FF0
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR 0078
-ENCODING 59648
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 13 0 -2
+STARTCHAR uniD54C
+ENCODING 54604
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-31FE
-6840
-4440
-4CC0
-29C0
-7E40
-C040
-8040
-8440
-8E40
-7E40
+0060
+0190
+7F90
+0010
+2310
+1210
+1210
+03F0
+FC10
+0000
+0FF0
+0410
+0410
+0420
+07F0
 0400
-0200
 ENDCHAR
-STARTCHAR 0077
-ENCODING 59649
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 11 0 0
+STARTCHAR uniD54D
+ENCODING 54605
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-FFF8
-0100
-0100
-7F00
-3100
-0900
-0500
-6500
-7900
-1100
-0900
+0080
+0060
+0320
+FC20
+4220
+2220
+2420
+07E0
+F820
+3060
+1020
+1FE0
+1020
+1FE0
+1020
 ENDCHAR
-STARTCHAR 00B6
-ENCODING 59650
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 11 0 0
+STARTCHAR uniD54F
+ENCODING 54607
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FFFE
-0040
-0040
-0040
-FFC0
-1040
-2040
-2040
-2040
-1040
+0060
+0010
+0090
+FF90
+2110
+2110
+1210
+12F0
+FD10
+0090
+0090
+0180
+0360
+0418
+1808
+ENDCHAR
+STARTCHAR uniD551
+ENCODING 54609
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
+BITMAP
+00C0
+0120
+FF20
+0420
+4220
+2220
+2420
+07E0
+F820
+0120
+0680
 0840
+0840
+0CC0
+0780
 ENDCHAR
-STARTCHAR 002A
-ENCODING 59651
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 11 0 0
+STARTCHAR uniD558
+ENCODING 54616
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFF0
-0200
-0200
-3A00
-4600
-0600
-0A00
-1200
-2200
-0200
-0200
+0060
+0020
+1E20
+01A0
+FFA0
+0020
+0820
+363C
+4120
+4120
+6320
+3E20
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00C1
-ENCODING 59652
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 12 0 -1
+STARTCHAR uniD559
+ENCODING 54617
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
 BITMAP
-FFFE
-1840
-2440
-2440
-1840
-6740
-00C0
-7C40
-18C0
-10C0
-1140
-0E00
+0060
+3C20
+0020
+FFE0
+1820
+6624
+4138
+6320
+3E20
+0000
+3FE0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00C2
-ENCODING 59653
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 11 0 0
+STARTCHAR uniD55C
+ENCODING 54620
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFE
-1840
-2440
-2440
-1840
-6740
-00C0
-01C0
-0240
-0440
-0040
+0060
+0020
+1E20
+0020
+FFA0
+1C20
+6324
+4138
+6320
+3E20
+0020
+0C00
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR 00C3
-ENCODING 59654
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 11 0 0
+STARTCHAR uniD560
+ENCODING 54624
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFE
-1840
-2440
-2440
-1840
-6740
-08C0
-08C0
-08C0
-0740
+0060
+1C20
+0020
+FFA0
+1820
+263C
+4220
+2220
+3C00
+1FE0
+0020
 0040
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 006B
-ENCODING 59655
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 11 0 0
+STARTCHAR uniD565
+ENCODING 54629
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFC
-0400
-0400
-7400
-8DC0
-8620
-8C20
+0060
+1C20
+0020
+FFA0
+0820
 7420
-1420
-6440
-8400
+423C
+6220
+3C20
+0000
+3DE0
+0900
+31E0
+2300
+3DF0
 ENDCHAR
-STARTCHAR 0024
-ENCODING 59656
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 18 11 0 0
+STARTCHAR uniD568
+ENCODING 54632
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
 BITMAP
-FFFFC0
-000800
-000800
-000800
-8FF800
-840800
-820800
-421800
-232800
-1E4800
-008800
+0060
+3C20
+0120
+FE20
+3C20
+4224
+4238
+6220
+3C20
+0000
+1FE0
+0820
+0840
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR 0025
-ENCODING 59657
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 18 11 0 0
+STARTCHAR uniD569
+ENCODING 54633
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
 BITMAP
-FFFFC0
-000800
-000800
-000800
-8FF800
-840800
-82C800
-429800
-232800
-1E4800
-008800
+0060
+3C20
+0120
+FE20
+3C20
+422C
+4230
+6220
+3C00
+1020
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 0027
-ENCODING 59658
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 11 0 0
+STARTCHAR uniD56B
+ENCODING 54635
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFE
-4200
-4200
-42C0
-4320
-4210
-3E10
-0A10
-1210
-2220
-4200
+0060
+1E20
+0020
+87A0
+7820
+3C20
+423C
+4220
+6220
+3D20
+0080
+0180
+0260
+0410
+1808
 ENDCHAR
-STARTCHAR 0027
-ENCODING 59659
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 11 0 0
+STARTCHAR uniD56D
+ENCODING 54637
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFE
-4200
-4200
-42C0
-4320
-4210
-3E10
-8A10
-9210
-2220
-4200
+0060
+2020
+1C20
+FF20
+0820
+3C20
+423C
+4220
+2620
+18A0
+03C0
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR 0027
-ENCODING 59660
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 0
+STARTCHAR uniD574
+ENCODING 54644
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -3
 BITMAP
-FFE0
-4200
-4200
-4200
-4200
-4200
-3E00
-0A00
-1200
-2200
-4200
+0018
+00C8
+1C48
+0048
+FF48
+0848
+3C48
+4278
+4248
+6248
+3C48
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR 002B
-ENCODING 59661
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 12 0 -1
+STARTCHAR uniD575
+ENCODING 54645
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFFC
-1040
-1040
-1040
-B0C0
-FFC0
-40C0
-4140
-2240
-2440
-1040
-0800
+0030
+0090
+3890
+FE90
+3090
+4890
+84F0
+4490
+7890
+0080
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 002C
-ENCODING 59662
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 12 0 -1
+STARTCHAR uniD578
+ENCODING 54648
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FFF0
-0200
-0200
-0200
-2700
-3C80
-1080
-1180
+0060
+0030
+3C90
+0090
+FF90
+0890
+3490
+42F0
+4290
+3C90
+0090
+1890
 0800
-0400
-0200
-0100
+0800
+0FF8
 ENDCHAR
-STARTCHAR 002D
-ENCODING 59663
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 11 0 0
+STARTCHAR uniD57C
+ENCODING 54652
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-FFFC
-0400
-0400
-0400
-2D80
-1F60
-1210
-11C8
+0070
+0090
+3890
+1E90
+F090
+3C90
+44F0
+4490
+3890
+0090
+1FF0
+0020
+1FF0
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniD584
+ENCODING 54660
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
+BITMAP
+0060
+0220
+7920
+0120
+FF20
+3120
+4920
+85E0
+4520
+7920
+1FE0
+0840
+0840
+0840
+0FE0
 0800
-0400
-0200
 ENDCHAR
-STARTCHAR 006B
-ENCODING 59669
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 0 0
+STARTCHAR uniD585
+ENCODING 54661
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFC0
-0400
-0400
-7400
-8DC0
-8600
-8C00
-7400
-0400
-0400
-0400
+0030
+0090
+3890
+0090
+FE90
+1090
+6CF0
+4490
+4490
+3C30
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 004B
-ENCODING 59670
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 0 0
+STARTCHAR uniD587
+ENCODING 54663
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-FFC0
-1000
-1000
-1380
-B640
-E440
-44C0
-4380
-2000
-1040
-0F80
+0060
+0120
+7920
+0120
+FF20
+7920
+C5E0
+8520
+4520
+7820
+0320
+0300
+0480
+0860
+3030
 ENDCHAR
-STARTCHAR 005E
-ENCODING 59671
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 9 0 2
+STARTCHAR uniD588
+ENCODING 54664
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-FE
-20
-20
-20
-20
-20
-A0
-60
-20
+0260
+0120
+0120
+7920
+DF20
+3120
+4DE0
+8520
+4520
+7800
+0840
+0840
+1EA0
+2310
+4210
 ENDCHAR
-STARTCHAR 0047
-ENCODING 59672
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 8 0 3
+STARTCHAR uniD589
+ENCODING 54665
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-FF
-40
-40
-3C
-30
-20
-21
-1E
+0030
+0090
+3890
+0090
+FC90
+1890
+64F0
+4490
+4490
+3890
+03C0
+0420
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR 007B
-ENCODING 59673
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 10 0 1
+STARTCHAR uniD590
+ENCODING 54672
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFF8
-0200
-3E00
-2000
-2020
+0060
+0020
+1C20
+00A0
+FFA0
+083C
+3E20
+6320
+4120
+412C
+6330
 1E20
-8100
-8100
-4100
-3E00
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0063
-ENCODING 59674
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 9 0 2
+STARTCHAR uniD5A5
+ENCODING 54693
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FF
-00
-00
-00
-7F
-08
-10
-11
-0E
+0060
+3820
+0420
+FFA0
+083C
+3420
+4220
+422C
+6630
+18A0
+0340
+0420
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR 0043
-ENCODING 59675
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 0 -1
+STARTCHAR uniD5C8
+ENCODING 54728
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 2 -2
 BITMAP
-FFFF
+0060
+0020
+3C20
+0120
+FFA0
+0820
+3420
+43E0
+4220
+6620
+3C20
 0020
 0020
-3870
-40C8
-4088
-3E48
-1838
-1018
-1018
-1864
-0F84
+0020
+0020
 ENDCHAR
-STARTCHAR 006A
-ENCODING 59676
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 10 0 1
+STARTCHAR uniD5C9
+ENCODING 54729
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FF80
-0000
-0000
+0030
+1810
+0490
+FFD0
+1810
+66F0
+4110
+6310
+3E10
 0000
-8F80
-8400
-4200
-4200
-2200
-1C00
+1FF0
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 004A
-ENCODING 59677
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 12 0 -1
+STARTCHAR uniD5CC
+ENCODING 54732
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFC0
-0400
-7C00
-4000
-4000
-3FC0
-0400
+0060
+3C20
+0020
+FF20
+0820
+3C20
+43E0
+4220
+4220
+3C20
+0020
+0C20
 0400
-3C00
-3C00
 0400
-0200
+03FC
 ENDCHAR
-STARTCHAR 0057
-ENCODING 59678
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 8 0 3
+STARTCHAR uniD5D0
+ENCODING 54736
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-FF
-00
-18
-24
-07
-84
-4C
-38
+0060
+3820
+0020
+FE20
+7820
+C5E0
+8420
+4420
+7820
+3FC0
+0040
+0040
+3FC0
+1000
+1FF0
 ENDCHAR
-STARTCHAR 0058
-ENCODING 59679
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 11 0 0
+STARTCHAR uniD5D2
+ENCODING 54738
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFF0
-0200
-0200
-3E00
-6000
-C000
-8000
-8000
-8100
-4300
-3E00
+0030
+3C10
+0010
+FF90
+3C10
+63F0
+4210
+6210
+3C10
+0000
+09F0
+3510
+6920
+3120
+2DE0
+1100
 ENDCHAR
-STARTCHAR 0059
-ENCODING 59680
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 11 0 0
+STARTCHAR uniD5D8
+ENCODING 54744
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFF0
-0200
-0200
-1E00
-3100
-6080
-4080
-4080
-4080
-2180
-1F00
+0030
+3810
+0510
+FF10
+3C10
+42F0
+4210
+4210
+3C10
+0000
+0FF0
+0410
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR 0052
-ENCODING 59681
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 10 0 1
+STARTCHAR uniD5D9
+ENCODING 54745
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFF0
-0200
-3E00
-2000
-1000
-0E00
-8100
-8080
-4080
-3F00
+0030
+3C10
+0010
+FF10
+3810
+44F0
+4210
+6210
+3C10
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 005A
-ENCODING 59682
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 0
+STARTCHAR uniD5DB
+ENCODING 54747
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FFE0
-0200
-0200
-7E00
-C000
-8000
-8600
-8D00
-4900
-2900
-1E00
+0020
+0010
+1E10
+0090
+FF10
+1EF0
+2110
+2110
+3110
+1E10
+0080
+0180
+0340
+0430
+1808
 ENDCHAR
-STARTCHAR 004E
-ENCODING 59683
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 9 0 2
+STARTCHAR uniD5DD
+ENCODING 54749
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-FF80
-4400
-4400
-4400
-4400
-4400
-4400
-2400
-1800
+0030
+3C10
+0110
+FE10
+1C10
+62F0
+4210
+4210
+3C10
+0090
+03C0
+0420
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR 0074
-ENCODING 59684
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 12 0 -1
+STARTCHAR uniD5E4
+ENCODING 54756
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-FE
-00
-00
-00
-7E
-C0
-80
-80
-40
-40
-20
-10
+0018
+00C8
+1C48
+0048
+0148
+FF48
+1C48
+23C8
+2248
+3248
+1C48
+0048
+0048
+0048
+0008
 ENDCHAR
-STARTCHAR 0054
-ENCODING 59685
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 9 0 2
+STARTCHAR uniD5E5
+ENCODING 54757
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-66
-D0
-88
-78
-30
-E0
-40
-20
-1E
+0060
+0030
+3890
+1E90
+F090
+3890
+4790
+4490
+3890
+0090
+1FF0
+0810
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0064
-ENCODING 59686
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 0
+STARTCHAR uniD5E8
+ENCODING 54760
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FFE0
+0030
+0190
+3890
+0090
+FE90
+3090
+4C90
+4790
+4490
+3890
+0090
+0410
 0400
+0408
+03F8
+ENDCHAR
+STARTCHAR uniD5EC
+ENCODING 54764
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
+BITMAP
+00C0
+0320
+3920
+1D20
+E120
+7920
+8F20
+8920
+7120
+1FE0
+0040
+1FE0
+0800
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniD5F4
+ENCODING 54772
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0060
+01B0
+0090
+3890
+DE90
+3590
+4E90
+4490
+3890
+0090
+0FF0
+0410
+0410
+0420
+07F0
 0400
-7C00
-8000
-8000
-8600
-4600
-3E00
-0200
-0100
 ENDCHAR
-STARTCHAR 0044
-ENCODING 59687
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 8 0 3
+STARTCHAR uniD5F5
+ENCODING 54773
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-46
-80
-80
-78
-60
-40
-42
-3C
+0060
+01B0
+3890
+0090
+FC90
+7F90
+4490
+4490
+7890
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 006E
-ENCODING 59688
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 8 0 3
+STARTCHAR uniD5F7
+ENCODING 54775
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FE
-00
-00
-00
-FE
-C0
-40
-20
+0070
+0110
+3890
+0090
+FE90
+3090
+4F90
+4490
+3890
+0310
+0110
+0300
+06C0
+0830
+1010
+2000
 ENDCHAR
-STARTCHAR 006E
-ENCODING 59689
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 11 0 0
+STARTCHAR uniD5F9
+ENCODING 54777
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-FE
-00
-00
-00
-FE
-C0
-40
-20
-00
-08
-08
+0060
+0130
+0090
+3890
+DE90
+7490
+CB90
+C490
+7890
+0090
+03E0
+0430
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR 0070
-ENCODING 59690
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 8 0 3
+STARTCHAR uniD600
+ENCODING 54784
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-FC
-40
-40
-40
-40
-40
-44
-38
+0020
+0010
+3C10
+0110
+FF10
+0810
+36F0
+4210
+4310
+63F0
+3C10
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0050
-ENCODING 59691
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 11 0 0
+STARTCHAR uniD601
+ENCODING 54785
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFE0
-4200
-4200
-42E0
-4300
-4600
-3A00
-0200
-0200
-0200
-0200
+0030
+3C10
+0110
+FE10
+1DF0
+6210
+4210
+43F0
+3C20
+0000
+3FF0
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0062
-ENCODING 59692
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 8 0 3
+STARTCHAR uniD604
+ENCODING 54788
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FC
-00
-00
-78
-E4
-94
-8C
-78
+0020
+0010
+3C10
+0390
+FC10
+3EF0
+4210
+4310
+63F0
+3C10
+0010
+0C10
+0410
+0400
+07F8
 ENDCHAR
-STARTCHAR 0042
-ENCODING 59693
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 8 0 3
+STARTCHAR uniD608
+ENCODING 54792
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-C6
-A0
-90
-70
-10
-FE
-60
-20
+0060
+7820
+0020
+FEE0
+3D20
+4420
+87E0
+47E0
+3820
+1FE0
+0020
+0040
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 006D
-ENCODING 59694
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 8 0 3
+STARTCHAR uniD610
+ENCODING 54800
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FE
-20
-20
-20
-20
-FE
-60
-20
+0070
+3C10
+0010
+FF90
+1810
+66F0
+4210
+6210
+3DF0
+0000
+0FF0
+0410
+0410
+0420
+07F0
+0400
 ENDCHAR
-STARTCHAR 0079
-ENCODING 59695
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 8 0 3
+STARTCHAR uniD611
+ENCODING 54801
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FE
-10
-10
-20
-C0
-80
-42
-3C
+0070
+1E10
+0010
+FF90
+1810
+6670
+4210
+4210
+3DF0
+0870
+0430
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR 0072
-ENCODING 59696
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 12 0 -1
+STARTCHAR uniD613
+ENCODING 54803
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0020
+1C10
+0010
+0F10
+F810
+1CF0
+6210
+4210
+42F0
+3D10
+0090
+0180
+0240
+0430
+1800
+ENDCHAR
+STARTCHAR uniD614
+ENCODING 54804
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0070
+3C10
+0010
+FF90
+1810
+64F0
+4210
+6210
+3DF0
+0040
+0420
+0C60
+0A50
+1098
+2108
+ENDCHAR
+STARTCHAR uniD615
+ENCODING 54805
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+1C10
+0010
+FF10
+1CF0
+6610
+4210
+43F0
+3C10
+0090
+0340
+0420
+0420
+0660
+03C0
+ENDCHAR
+STARTCHAR uniD61C
+ENCODING 54812
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+0010
+0090
+3890
+0090
+FE90
+7990
+8C90
+8490
+CF90
+7890
+0090
+0090
+0090
+0010
+ENDCHAR
+STARTCHAR uniD620
+ENCODING 54816
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-FFE0
-0400
-0400
-0400
-2C00
-3800
-1000
-1000
-0800
+0060
+0020
+7B20
+0120
+1D20
+E120
+7720
+8920
+8F20
+7920
+0120
+0820
 0800
-0400
-0200
+0810
+07F0
 ENDCHAR
-STARTCHAR 0072
-ENCODING 59697
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 12 0 -1
+STARTCHAR uniD624
+ENCODING 54820
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FFE0
-0400
-0400
+0030
+0190
+3C90
+0090
+FE90
+3F90
+4490
+4790
+3C90
+0FF0
+0010
+0020
+0FF0
 0400
-2C00
-3800
-1000
-1000
-0800
-2800
-2400
-0200
+07F8
 ENDCHAR
-STARTCHAR 006C
-ENCODING 59698
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 10 11 0 0
+STARTCHAR uniD62D
+ENCODING 54829
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFC0
-0000
-0000
-0000
-78C0
-8500
-8200
-8000
-4000
-4000
-2000
+0030
+0010
+3990
+0090
+FE90
+7090
+CB90
+C790
+7890
+0810
+0410
+07F0
+0410
+0410
+07F0
+0410
 ENDCHAR
-STARTCHAR 004C
-ENCODING 59699
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 11 0 0
+STARTCHAR uniD638
+ENCODING 54840
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 13 1 -1
 BITMAP
-FFF8
-0000
+03C0
 0000
 0000
-7860
-C490
-8108
-8208
-8308
-4498
-3870
+3FF8
+07C0
+0C60
+0820
+0820
+0440
+0380
+0100
+E1FE
+1E00
 ENDCHAR
-STARTCHAR 004C
-ENCODING 59700
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 15 0 -4
+STARTCHAR uniD639
+ENCODING 54841
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
 BITMAP
-FFF8
-0000
-0000
+0780
 0000
-7860
-C490
-8108
-8208
-8308
-4498
-3870
+3FF0
+0600
+0F80
+0880
+0880
+0480
+0300
+FFFC
 0000
+7FC0
+0040
+0040
+0040
+0040
+ENDCHAR
+STARTCHAR uniD63C
+ENCODING 54844
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
+BITMAP
+0380
+3FF8
+0300
+0F80
+0840
+0840
+0480
+0300
+FFFE
 0000
-0200
-0200
+1800
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0076
-ENCODING 59701
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 8 0 3
+STARTCHAR uniD640
+ENCODING 54848
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 2 -2
 BITMAP
-FC
-00
-00
-78
-84
-84
-84
-78
+0780
+3FF0
+0600
+0DC0
+0840
+0840
+0780
+FFFE
+0000
+3FC0
+0040
+3FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR 0053
-ENCODING 59702
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 11 0 0
+STARTCHAR uniD645
+ENCODING 54853
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-FF80
-1400
-2200
-2200
-2200
-1E00
-2200
-5C00
-3800
-0400
-0400
+0F00
+3BF0
+0600
+0D80
+0840
+0880
+0700
+FFFC
+03F0
+3D00
+0560
+3D80
+2130
+3CC0
 ENDCHAR
-STARTCHAR 005C
-ENCODING 59703
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 8 0 3
+STARTCHAR uniD648
+ENCODING 54856
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
 BITMAP
-FC
-60
-50
-50
-48
-48
-24
-1C
+0780
+0000
+3FF0
+0E00
+0980
+0880
+0880
+0700
+FFFC
+0000
+3FC0
+1040
+1040
+1080
+1FC0
+1000
 ENDCHAR
-STARTCHAR 0073
-ENCODING 59704
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 8 12 0 -1
+STARTCHAR uniD649
+ENCODING 54857
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-FF
-10
-10
-10
-B1
-FE
-40
-40
-20
-20
-10
-08
+03C0
+0000
+3FF8
+0100
+0EE0
+0820
+0440
+0380
+FFFE
+0820
+0420
+07E0
+0420
+0420
+07E0
+0420
 ENDCHAR
-STARTCHAR 0068
-ENCODING 59705
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 0 -3
+STARTCHAR uniD64B
+ENCODING 54859
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
 BITMAP
-FFE0
+0780
+3FF0
 0200
+0780
+0840
+0840
+0880
+0700
+FFFC
+0600
 0200
-1E00
-2000
-1000
-1E00
-3100
-2100
-2200
+0500
+08E0
+1020
 2000
-1000
-0800
-0600
 ENDCHAR
-STARTCHAR 0056
-ENCODING 59712
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 11 0 0
+STARTCHAR uniD64D
+ENCODING 54861
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFC0
-0400
-7580
-8E40
-8C40
-7480
-8F80
-8C40
-7440
-0480
-0400
+0780
+0000
+3FF0
+0600
+0F00
+0880
+0880
+0900
+0600
+FFFC
+0F80
+18C0
+1040
+18C0
+0780
 ENDCHAR
-STARTCHAR 00B6
-ENCODING 59713
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 12 0 -1
+STARTCHAR uniD651
+ENCODING 54865
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFE
-0040
-0040
-0040
-FFDC
-3062
-2042
-2042
-2042
-1044
+0F00
+0000
+3FF0
+0600
+0980
 0840
-0400
+0880
+0700
+FFFC
+0000
+1FE0
+1000
+1FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR 00A2
-ENCODING 59714
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 16 0 -5
+STARTCHAR uniD654
+ENCODING 54868
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
 BITMAP
-FFFC
-0100
-3F00
-2000
-2020
+0060
 1E20
-8100
-8100
-4100
-3E00
-0400
-3500
-4E80
-4C80
-3480
-0400
+0020
+7FA0
+0420
+3A20
+2120
+212C
+3F30
+0C20
+0FE0
+F820
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00A3
-ENCODING 59715
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 16 0 -5
+STARTCHAR uniD655
+ENCODING 54869
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFC
-0100
-3F00
-2000
-2020
+0060
 1E20
-8100
-8100
-4100
-3F00
-6100
-CD00
-9300
-5300
-4D00
-2100
+7FA0
+0420
+3F20
+2120
+213C
+1E20
+07E0
+F820
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 00A4
-ENCODING 59716
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 16 0 -5
+STARTCHAR uniD658
+ENCODING 54872
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
 BITMAP
-FFFC
-0100
-3F00
-2000
-2020
-1E20
-8100
-8100
-4100
-3F00
-1100
-1100
-3100
-3100
-1100
-0100
+0060
+0F10
+0010
+3FD0
+0210
+1D10
+1090
+1990
+0F1C
+06F0
+F910
+0C10
+0400
+0408
+07F8
 ENDCHAR
-STARTCHAR 00A5
-ENCODING 59717
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 16 0 -5
+STARTCHAR uniD65C
+ENCODING 54876
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFC
-0200
-3E00
-2000
-2020
-1E20
-8100
-8100
-4100
-7E00
-4200
-4200
-3A00
-2200
-1E00
-0200
+0080
+1E60
+0020
+FFA0
+1820
+2620
+2220
+3E3C
+08E0
+FF20
+1FE0
+0020
+0FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 006A
-ENCODING 59718
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 11 0 0
+STARTCHAR uniD667
+ENCODING 54887
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 3 -2
 BITMAP
-FFFC
-0040
-1840
-47C0
-2440
-1840
+0180
+3C40
 0040
-47C0
-4440
-2240
-1C40
+FF40
+1040
+6C40
+4240
+6C58
+3860
+1FC0
+E340
+0300
+0680
+0860
+3030
 ENDCHAR
-STARTCHAR 00B9
-ENCODING 59719
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 13 0 -2
+STARTCHAR uniD669
+ENCODING 54889
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -2
 BITMAP
-FFFC
-0080
-0080
-0F80
-1000
-1000
-30C0
-50C0
-4FC0
-2040
-1840
-10C0
-0F40
+0060
+1C20
+7FA0
+0820
+1620
+2120
+223C
+1E20
+0DE0
+FA20
+0180
+0660
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR 00B8
-ENCODING 59720
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 0 -3
+STARTCHAR uniD670
+ENCODING 54896
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
 BITMAP
-FFE0
-0400
+0030
+0088
+1E48
+0048
+7F48
+0848
+3648
+2248
+3278
+1E48
+09C8
+FE48
+0048
+0048
+0048
+0008
+ENDCHAR
+STARTCHAR uniD671
+ENCODING 54897
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+0190
+1890
+FE90
+1090
+2C90
+24F0
+3890
+1F90
+E090
+1FF0
+0010
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniD674
+ENCODING 54900
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 14 2 -2
+BITMAP
+0130
+1C90
+0090
+FE90
+1890
+2490
+2290
+3CF0
+0990
+FE90
+0C90
+0410
 0400
-3C00
-4000
-2000
-3C00
-4000
-4000
-4300
-3F00
-0300
-0100
-0080
+07F8
 ENDCHAR
-STARTCHAR 00B9
-ENCODING 59721
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 13 0 -2
+STARTCHAR uniD683
+ENCODING 54915
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -3
 BITMAP
-FFFC
-0080
-0080
-0F80
-1000
+0130
+3C90
+0090
+FE90
+1890
+2490
+2290
+3CF0
+0990
+FF90
+0090
+0140
+0230
+0C10
 1000
-10C0
-50C0
-4FC0
-4040
-3860
-1080
-0F00
 ENDCHAR
-STARTCHAR 00BE
-ENCODING 59722
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 0 -3
+STARTCHAR uniD685
+ENCODING 54917
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-FFE0
-0400
-0400
-7C00
-8000
-8000
-8600
-8600
-7E00
-1E00
-3300
-2A80
-2600
-1C00
+0010
+00C8
+0C48
+7F48
+0C48
+1248
+1278
+0C48
+FFC8
+2048
+01B0
+0208
+0208
+0318
+01F0
 ENDCHAR
-STARTCHAR 00BB
-ENCODING 59723
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 13 0 -2
+STARTCHAR uniD68C
+ENCODING 54924
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -3
 BITMAP
-FFF8
-0080
+0018
+0F08
+0008
+3F88
+0608
+1988
+1088
+1088
+0F08
+0238
+FFC8
+0008
+0008
+0008
+0008
+ENDCHAR
+STARTCHAR uniD68D
+ENCODING 54925
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
+BITMAP
+0030
+0708
+3FE8
+0E08
+1988
+1088
+1988
+0608
+DFF8
+2008
+1FF0
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniD690
+ENCODING 54928
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
+1E10
+0010
+FFD0
+0410
+3B10
+2110
+3310
+1E10
+07F0
+F810
+1810
+0810
+0800
+0FF8
+ENDCHAR
+STARTCHAR uniD694
+ENCODING 54932
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 14 4 -2
+BITMAP
+38C0
+0040
+FF40
+3840
+4440
+4440
+2840
+1FC0
+E000
+3FC0
 0080
-0F80
-1000
+3FC0
 1000
-1180
-9180
-4F80
-4080
-4080
-FF80
-C080
+1FE0
 ENDCHAR
-STARTCHAR 00BC
-ENCODING 59724
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 12 0 -1
+STARTCHAR uniD69D
+ENCODING 54941
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 15 3 -3
 BITMAP
-FFFC
-0440
-0440
-7C40
-8040
-8040
-8C40
-8C40
-7C40
-0440
+1CC0
+0040
+7F40
+3C40
+4640
+4240
+2440
+1FC0
+F0C0
+0840
 0FC0
-0C40
+0840
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR 00BD
-ENCODING 59725
-SWIDTH 900 0
-DWIDTH 15 0
-BBX 15 12 0 -1
+STARTCHAR uniD69F
+ENCODING 54943
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -2
 BITMAP
-FFFE
-0220
-0220
-3E20
-4020
-4020
-4620
-4620
-3E20
-0420
-0260
-01C0
+0030
+0708
+0048
+3F88
+0D08
+1088
+1188
+0F08
+0678
+FD88
+00C0
+0080
+0160
+0218
+0C0C
 ENDCHAR
-STARTCHAR 00BE
-ENCODING 59726
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 14 0 -3
+STARTCHAR uniD6A1
+ENCODING 54945
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-FFE0
-0400
-0400
-7C00
-8000
-8000
-8600
-8600
-7E00
-1E00
-2300
-2280
-2200
-1C00
+0060
+1E10
+0090
+7F10
+1610
+2110
+2310
+1E10
+0DF0
+FA10
+0180
+0660
+0420
+0660
+03C0
 ENDCHAR
-STARTCHAR 00AC
-ENCODING 59727
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 -6
+STARTCHAR uniD6A8
+ENCODING 54952
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 2 -1
 BITMAP
-FFF0
-0200
-0200
-7E00
-C000
-8000
-8080
-C180
-7F00
+0780
+0000
+7FF0
 0200
+0F80
+1040
+1040
+1040
+0F80
+18C0
+0840
+084C
+F7B0
+ENDCHAR
+STARTCHAR uniD6AC
+ENCODING 54956
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0790
+3FF8
 0200
-7E00
-C000
-8000
-8080
-C180
-7F00
+0780
+0840
+0840
+0C80
+07C0
+FFFC
+0000
+3000
+1000
+1020
+1FE0
 ENDCHAR
-STARTCHAR 00AD
-ENCODING 59728
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 -6
+STARTCHAR uniD6B0
+ENCODING 54960
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 14 1 -2
 BITMAP
-FFF0
-0200
-0200
-7E00
-C000
-8000
-8100
-C300
-7E00
-0200
-3E00
-6200
-C100
-8100
-8100
-4300
-3E00
+03C0
+1FF8
+0300
+04E0
+0420
+0420
+03E0
+FFFE
+0000
+1FE0
+0020
+1FE0
+0800
+0FF0
 ENDCHAR
-STARTCHAR 00AD
-ENCODING 59729
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 16 0 -5
+STARTCHAR uniD6B9
+ENCODING 54969
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 16 2 -3
 BITMAP
-FFF0
-0200
+0780
+0000
+3FF0
+0780
+0880
+0880
+0880
+0F80
+FFFC
+10C0
+0840
+0FC0
+0840
+0840
+0FC0
+0840
+ENDCHAR
+STARTCHAR uniD6BB
+ENCODING 54971
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0780
+3FF0
+0700
+0880
+0840
+0C40
+1FC0
+0840
+FFFC
 0200
-3E00
-6100
-C100
-8100
-8300
-7E00
 0200
-3E00
-6100
-C100
-8100
-8300
-7E00
+0580
+0860
+3020
 ENDCHAR
-STARTCHAR 00A4
-ENCODING 59730
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 16 0 -5
+STARTCHAR uniD6C4
+ENCODING 54980
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-FFFC
+03C0
+1FF8
 0100
-3F00
-2000
-2000
-1E00
-8100
-8100
-4100
-3F00
-1100
-1100
-3100
-3100
-1100
+03C0
+0420
+0420
+03C0
+0000
+FFFE
 0100
-ENDCHAR
-STARTCHAR 00B2
-ENCODING 59731
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 18 0 -7
-BITMAP
-FFF0
 0100
 0100
-3F00
-2000
-3C00
-8600
-8200
-4600
-3E00
-0200
-3E00
-2000
-3C00
-8600
-8200
-4600
-3C00
-ENDCHAR
-STARTCHAR 00B2
-ENCODING 59732
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 18 0 -7
-BITMAP
-FFF0
 0100
 0100
-3F00
-2000
-3C00
-8600
-8200
-4600
-3E00
-0200
-3E00
-4000
-8000
-9C00
-A200
-6200
-3C00
-ENDCHAR
-STARTCHAR 00C0
-ENCODING 59733
-SWIDTH 840 0
-DWIDTH 14 0
-BBX 14 11 0 0
-BITMAP
-FFFC
-0080
-0080
-7880
-6480
-2380
-0E80
-3880
-3080
-1080
-0080
+0100
 ENDCHAR
-STARTCHAR 0068
-ENCODING 59734
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 15 0 -4
+STARTCHAR uniD6C5
+ENCODING 54981
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-FFFF
-0210
-0210
-3E10
-4010
-2010
-3C10
-6210
-4110
-43F0
-4310
-2010
-1000
-0C00
+0380
+0000
+3FF0
 0300
+0CC0
+0840
+0840
+0780
+FFFE
+0100
+3FE0
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR 0068
-ENCODING 59735
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 15 0 -4
+STARTCHAR uniD6C8
+ENCODING 54984
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-FFFF
-0210
-0210
-3E10
-4010
-2010
-3C10
-6210
-4110
-4130
-4250
-2190
-1000
-0C00
-0300
+03C0
+0000
+1FF8
+03C0
+0420
+0420
+0420
+03C0
+FFFE
+0100
+0100
+0900
+0900
+0800
+07F8
 ENDCHAR
-STARTCHAR 0068
-ENCODING 59736
-SWIDTH 1140 0
-DWIDTH 19 0
-BBX 19 15 0 -4
+STARTCHAR uniD6CC
+ENCODING 54988
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-FFFFE0
-000200
-000200
-003E00
-004000
-002000
-003C00
-006200
-004100
-3BC100
-464200
-422000
-401000
-200C00
-180300
+0700
+0000
+7FF0
+0900
+0880
+0880
+0F80
+FFFC
+0200
+1DC0
+0040
+3FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR 0068
-ENCODING 59737
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 15 0 -4
+STARTCHAR uniD6D1
+ENCODING 54993
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 1 -3
 BITMAP
-FFFF
-0010
-0010
-01F0
-0200
+03C0
+1FF8
+03C0
+0440
+0440
+03C0
+FC00
+03FC
 0100
-01E0
-0310
-0208
-0208
-3E10
-6300
-4280
-4660
-3C18
+3FB8
+02C0
+36B0
+18C0
+1298
+1C60
 ENDCHAR
-STARTCHAR 004B
-ENCODING 59738
-SWIDTH 1080 0
-DWIDTH 18 0
-BBX 18 11 0 0
+STARTCHAR uniD6D4
+ENCODING 54996
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-FFFFC0
-100800
-100800
-10E800
-B01800
-FE1800
-402800
-404800
-208800
-100800
-080800
+0780
+1F70
+0380
+0440
+0420
+0440
+0380
+FFFE
+0100
+0F00
+08E0
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR 0078
-ENCODING 59760
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 13 0 -2
+STARTCHAR uniD6D7
+ENCODING 54999
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-3180
-6800
-4400
-4C80
-2980
-7E00
-C000
-8000
-8400
-8E00
-7E00
-0400
-0200
+0380
+0000
+3FF0
+0100
+0680
+0840
+0C40
+0780
+FFFE
+0100
+0300
+0100
+0380
+0460
+0810
+1000
 ENDCHAR
-STARTCHAR 0077
-ENCODING 59761
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 11 0 0
+STARTCHAR uniD6D9
+ENCODING 55001
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 1 -2
 BITMAP
-FFF8
+0380
+3FF8
 0100
+06C0
+0440
+0440
+0384
+FF78
 0100
-7F00
-3100
-0900
-0500
-6500
-7900
-1100
-0900
+07C0
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR 00B6
-ENCODING 59762
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 11 0 0
+STARTCHAR uniD6E0
+ENCODING 55008
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-FF80
-0000
-0000
-0000
-FF80
-1000
-2000
-2000
-2000
-1000
-0800
+0030
+1E10
+0010
+FF90
+0C10
+3310
+2110
+3110
+0E10
+1F10
+E9F0
+0810
+0810
+0810
+0010
 ENDCHAR
-STARTCHAR 002A
-ENCODING 59763
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 9 0 2
+STARTCHAR uniD6E4
+ENCODING 55012
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FC
-00
-00
-78
-84
-04
-08
-30
-40
+0030
+1E10
+0010
+7F90
+1E10
+2210
+2210
+1E10
+0390
+FDF0
+0810
+1C10
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR 00C1
-ENCODING 59764
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 12 0 -1
+STARTCHAR uniD6E8
+ENCODING 55016
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FF80
-1800
-2400
-2400
-1800
-6700
-0080
-7C00
-1880
-1080
-1100
-0E00
+0030
+1E10
+0790
+FC10
+3A10
+2310
+1E10
+0390
+FCF0
+0400
+0FF0
+0010
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR 00C2
-ENCODING 59765
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 10 0 1
+STARTCHAR uniD6F0
+ENCODING 55024
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FF80
-1800
-2400
-2400
-1800
-6700
-0080
-0180
-0200
+0030
+3C10
+0010
+7F90
+3410
+2210
+1C10
+0310
+FCF0
+0810
+0FF0
+0410
+0420
+0420
+07F0
 0400
 ENDCHAR
-STARTCHAR 00C3
-ENCODING 59766
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 9 10 0 1
+STARTCHAR uniD6F5
+ENCODING 55029
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FF80
-1800
-2400
-2400
-1800
-6700
-0880
-0880
-0880
-0700
+0030
+1C10
+0110
+7E10
+3610
+2210
+1C10
+0310
+FCF0
+0810
+0080
+0360
+0410
+0410
+0630
+03E0
 ENDCHAR
-STARTCHAR 00FE
-ENCODING 59771
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 4 7 0 10
+STARTCHAR uniD6FC
+ENCODING 55036
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
 BITMAP
-60
-90
-A0
-A0
-80
-40
-20
+00C0
+0260
+7920
+0120
+F920
+3920
+4920
+4520
+4920
+3D20
+F120
+1720
+2120
+0120
+0020
+0020
 ENDCHAR
-STARTCHAR 0068
-ENCODING 59772
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 16 0 -5
+STARTCHAR uniD6FD
+ENCODING 55037
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
 BITMAP
-FFE0
-0200
-0200
-3E00
-4000
-2000
-3C00
-6200
-4100
-4100
-4200
-2000
-1000
-2C00
-4300
-8000
+0030
+00D0
+1C50
+0650
+7C50
+2450
+2450
+1950
+FE50
+09D0
+1FF0
+0810
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0022
-ENCODING 59773
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 8 7 0 4
+STARTCHAR uniD700
+ENCODING 55040
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-FF
-00
-00
-00
-00
-43
-3C
+0020
+0110
+1C90
+8790
+3C90
+2690
+2490
+1890
+1E90
+6F90
+0890
+0C10
+0400
+0400
+07F8
 ENDCHAR
-STARTCHAR 00FE
-ENCODING 59774
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 4 7 0 10
+STARTCHAR uniD704
+ENCODING 55044
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-60
-90
-80
-80
-80
-40
-20
+0018
+0068
+1E28
+7F28
+0C28
+1228
+1E28
+1EA8
+FD28
+04E0
+0FF8
+0010
+0FF0
+0400
+07F8
 ENDCHAR
-STARTCHAR 00D5
-ENCODING 59775
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 5 5 0 -5
+STARTCHAR uniD711
+ENCODING 55057
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-20
-30
-68
-C0
-80
+0010
+0058
+1E48
+7F48
+0C48
+1248
+1E48
+1EC8
+FFC8
+0488
+01E8
+0210
+0210
+0210
+01E0
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59776
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 15 -1 0
+STARTCHAR uniD718
+ENCODING 55064
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 1 -3
 BITMAP
-B4
-44
-38
-00
-7E
-20
-20
-20
-20
-20
-20
-20
-20
-20
-20
+0018
+0F08
+0008
+3FC8
+0608
+1908
+1088
+1088
+0F08
+00F8
+FF08
+0408
+0408
+0408
+0008
+0008
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59777
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 14 0 0
+STARTCHAR uniD719
+ENCODING 55065
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-60
-00
-00
-FC
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
+0030
+1E10
+4390
+3C10
+1310
+1110
+1E10
+FFF0
+0410
+0410
+1FF0
+0810
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59778
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 17 0 0
+STARTCHAR uniD71C
+ENCODING 55068
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-60
-90
-80
-80
-80
-40
-FC
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
+0060
+3C20
+0320
+7C20
+3C20
+4220
+4220
+3C20
+0FE0
+F820
+0820
+3820
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59779
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 6 17 0 0
+STARTCHAR uniD720
+ENCODING 55072
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 3 -2
 BITMAP
-60
-90
-A0
-A0
-80
-40
-FC
-40
-40
-40
-40
-40
-40
-40
-40
-40
-40
+0060
+3C20
+0020
+FF20
+3C20
+2620
+2620
+3C20
+01A0
+FFE0
+0020
+1FE0
+0800
+0800
+0FF0
 ENDCHAR
-STARTCHAR 0065
-ENCODING 59780
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 9 18 0 0
+STARTCHAR uniD728
+ENCODING 55080
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
 BITMAP
-0080
-0080
-3C00
-4300
-4080
-4000
-4000
-FC00
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
+0060
+3C20
+0F20
+7C20
+2220
+2220
+3C20
+0FE0
+F820
+0820
+1FE0
+0820
+0820
+0840
+0B80
+0400
 ENDCHAR
-STARTCHAR 0065
-ENCODING 59781
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 0
+STARTCHAR uniD729
+ENCODING 55081
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
 BITMAP
-0070
-3C80
-4380
-4080
-4000
-4000
-FC00
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
+0060
+3C20
+0F20
+7820
+3C20
+6220
+2220
+3C60
+1FA0
+E800
+0860
+1820
+0FE0
+0820
+0FE0
+0820
+ENDCHAR
+STARTCHAR uniD72B
+ENCODING 55083
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 16 2 -3
+BITMAP
+0030
+1E10
+0010
+3F90
+1A10
+1110
+1E10
+01F0
+FE10
+0590
+0480
+0180
+0240
+0438
+0808
+1000
 ENDCHAR
-STARTCHAR 0065
-ENCODING 59782
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 0 0
+STARTCHAR uniD72D
+ENCODING 55085
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
-0070
-3C80
-43A0
-40A0
-4000
-4000
-FC00
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
-4000
+0060
+3C20
+0F20
+7C20
+2220
+2220
+3C20
+1FE0
+E820
+0920
+06C0
+0820
+0820
+0C60
+0380
 ENDCHAR
-STARTCHAR 0069
-ENCODING 59783
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 12 16 -5 0
+STARTCHAR uniD734
+ENCODING 55092
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -3
 BITMAP
-7800
-8440
-8240
-8100
-0100
-03F0
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+0780
+7FF0
+0200
+0D80
+1080
+1080
+0F00
+0000
+FFF8
+0880
+0880
+0880
+0880
+0880
+0080
 ENDCHAR
-STARTCHAR 0069
-ENCODING 59784
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 12 16 -5 0
+STARTCHAR uniD735
+ENCODING 55093
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-78C0
-8520
-8300
-8100
-0100
-03F0
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+0700
+3FE0
+0700
+0880
+0880
+0880
+FFC0
+087C
+0880
+3FC0
+0040
+0040
+0040
+0040
 ENDCHAR
-STARTCHAR 0069
-ENCODING 59785
-SWIDTH 300 0
-DWIDTH 5 0
-BBX 12 16 -5 0
+STARTCHAR uniD738
+ENCODING 55096
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 13 1 -1
 BITMAP
-78C0
-8520
-8340
-8140
-0100
-03F0
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+03C0
+0010
+1FE0
+06C0
+0440
+0640
+0380
+FFFC
+0440
+0C40
+0840
+0840
+07F8
 ENDCHAR
-STARTCHAR 00F1
-ENCODING 59786
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 7 6 0 11
+STARTCHAR uniD73C
+ENCODING 55100
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-02
-E2
-10
-08
-04
-02
+0700
+3FF0
+0700
+0880
+08C0
+0780
+FFFC
+0880
+0880
+3FC0
+0040
+3FC0
+1000
+1FE0
 ENDCHAR
-STARTCHAR 00F1
-ENCODING 59787
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 5 0 11
+STARTCHAR uniD744
+ENCODING 55108
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-E180
-1240
-0A00
-0600
+0780
+3FF0
 0200
+0D80
+0840
+0880
+0788
+FFFC
+0880
+3F80
+1040
+1040
+1080
+1FC0
 ENDCHAR
-STARTCHAR 00F1
-ENCODING 59788
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 10 5 0 11
+STARTCHAR uniD747
+ENCODING 55111
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-E180
-1240
-0A80
-0680
+0780
+3FF0
+0780
+08C0
+0880
+0780
+FFFC
+0840
+0840
+0A40
 0200
+0500
+08E0
+3030
 ENDCHAR
-STARTCHAR 00F2
-ENCODING 59789
-SWIDTH 0 0
-DWIDTH 0 0
-BBX 8 6 0 11
+STARTCHAR uniD749
+ENCODING 55113
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-31
-19
-E4
-7A
-06
-01
+03C0
+0000
+1FF8
+0080
+0760
+0420
+0460
+03C0
+FFFE
+0420
+07A0
+0460
+0420
+0620
+03C0
 ENDCHAR
-STARTCHAR 00F2
-ENCODING 59790
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 6 0 11
+STARTCHAR uniD750
+ENCODING 55120
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 11 1 0
 BITMAP
-3000
-1830
-E448
-7A40
-0640
-0140
+03C0
+0000
+3FF8
+07C0
+0C60
+0820
+0820
+0C60
+03C0
+0004
+FFFE
 ENDCHAR
-STARTCHAR 00F2
-ENCODING 59791
-SWIDTH 780 0
-DWIDTH 13 0
-BBX 13 6 0 11
+STARTCHAR uniD751
+ENCODING 55121
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
+BITMAP
+03C0
+0000
+1FF8
+03C0
+0420
+0420
+0420
+03C0
+FFFE
+0000
+3FE0
+0020
+0020
+0020
+0020
+ENDCHAR
+STARTCHAR uniD754
+ENCODING 55124
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
+0780
+00F0
+3F00
+0780
+0840
+0840
+0840
+0788
+FFFC
+0000
 3000
-1830
-E448
-7A50
-0650
-0140
+1000
+1000
+1FF0
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59792
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 17 -5 0
+STARTCHAR uniD756
+ENCODING 55126
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
 BITMAP
-0200
-E200
+0700
+39F0
+0780
+0C40
+0840
+0440
+0780
+FFFC
+01C0
+6078
+23C0
+21A0
+2520
+39E0
+ENDCHAR
+STARTCHAR uniD757
+ENCODING 55127
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
+BITMAP
+0790
+3F60
+07C0
+0440
+0820
+0440
+0380
+01FE
+FF00
+0000
+0FF0
+0800
+0800
+0810
+07F8
+ENDCHAR
+STARTCHAR uniD758
+ENCODING 55128
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 14 2 -2
+BITMAP
+0780
+39F0
+0780
+0C40
+0840
+0C40
+0788
+FFFC
+0000
+3FC0
+0040
+3FC0
 1000
+1FE0
+ENDCHAR
+STARTCHAR uniD759
+ENCODING 55129
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
+BITMAP
+03C0
+1BF8
+0500
+06E0
+0420
+0620
+01C4
+FFFE
+0000
+3E78
+0208
+3608
+1808
+1608
 0800
-0400
-0200
-07E0
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59793
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 16 -5 0
+STARTCHAR uniD760
+ENCODING 55136
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 14 15 2 -3
 BITMAP
-E180
-1240
-0A00
-0600
-0200
-07E0
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
+07A0
+7E40
+0F80
+0880
+1040
+0880
+0700
+01FC
+FE00
+0000
+0FE0
+0820
+0840
+0FE0
+0800
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59794
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 11 16 -5 0
+STARTCHAR uniD761
+ENCODING 55137
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 16 1 -3
 BITMAP
-E180
-1240
-0A80
-0680
-0200
-07E0
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
-0200
+03C0
+0000
+1FF8
+03C0
+0420
+0420
+0420
+03C4
+FFFE
+0060
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59795
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 17 -6 0
+STARTCHAR uniD763
+ENCODING 55139
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -3
 BITMAP
-3100
-1900
-E400
-7A00
-0600
-0100
-03F0
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
+0380
+2078
+1F80
+06C0
+0440
+0440
+0380
+0004
+FFFE
+0300
 0100
+0280
+0470
+1810
+2000
 ENDCHAR
-STARTCHAR 0061
-ENCODING 59796
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 12 18 -6 0
+STARTCHAR uniD765
+ENCODING 55141
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -3
 BITMAP
+0700
+7FF0
+0300
+0C80
+1840
+1840
+0F80
+7C00
+83F8
 0200
-3200
+0F80
+10C0
+1040
 18C0
-E520
-7B00
-0700
-0100
-03F0
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-0100
-ENDCHAR
-STARTCHAR C099
-ENCODING 60896
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 10 1 3
-BITMAP
-3E00
-4100
-A280
-B680
-B680
-AA80
-A280
-A280
-4100
-3E00
+0F80
 ENDCHAR
-STARTCHAR 0065
-ENCODING 60909
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 12 19 -5 0
+STARTCHAR uniD769
+ENCODING 55145
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 15 15 1 -2
 BITMAP
-4000
-A000
-4400
-FC00
+0380
 0000
-2000
-5000
-5000
-2000
+3FF8
+0100
+06E0
+0420
+0660
+03C6
+FFFE
 0000
-01E0
-0310
-0290
-0110
+0FF0
+0800
+0FF0
+0800
+07F8
+ENDCHAR
+STARTCHAR uniD76C
+ENCODING 55148
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0060
+0010
+1E10
+03D0
+7C10
+0E10
+3110
+2110
+2110
+1E10
+01F0
+FE10
 0010
 0010
 0010
+ENDCHAR
+STARTCHAR uniD770
+ENCODING 55152
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0030
 0010
+1E10
+7F90
+1E10
+3210
+2110
+3210
+1EF0
+F910
 0010
+1810
+0800
+0800
+0FF8
 ENDCHAR
-STARTCHAR 0065
-ENCODING 60910
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 11 18 -4 0
+STARTCHAR uniD774
+ENCODING 55156
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-4000
-4000
-4000
-0000
-4000
-A000
-A000
-4000
+0030
+0E10
+0010
+3F90
+1B10
+2110
+1110
+0E30
+FFD0
 0000
-03C0
-0620
-0520
-0220
-0020
-0020
-0020
-0020
+0FF0
+0FF0
+0400
+0400
+07F8
+ENDCHAR
+STARTCHAR uniD77C
+ENCODING 55164
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+1E10
+0010
+FF10
+3C10
+2210
+2210
+3C30
+FFD0
+0010
+1FE0
+0820
+0820
+0840
+0FE0
+0800
+ENDCHAR
+STARTCHAR uniD77D
+ENCODING 55165
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 2 -3
+BITMAP
+1E60
 0020
+7F20
+1620
+2220
+3220
+1C20
+00E0
+FF60
+0820
+0FE0
+0820
+0820
+0FE0
+0820
 ENDCHAR
-STARTCHAR C070
-ENCODING 60911
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 9 11 0 0
+STARTCHAR uniD781
+ENCODING 55169
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 1 -2
 BITMAP
-FF80
-2080
-2080
-2000
-7F00
-2000
-7F00
-2000
-2000
-2000
-F800
+0018
+0708
+0008
+3F88
+0F08
+1108
+1108
+0F08
+83F8
+3C08
+01C0
+0230
+0210
+0330
+01E0
 ENDCHAR
-STARTCHAR GEORGIAN CAPITAL LETTER FI
-ENCODING 61638
-SWIDTH 720 0
-DWIDTH 12 0
-BBX 11 11 0 0
+STARTCHAR uniD788
+ENCODING 55176
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
 BITMAP
-0E00
-0400
+0030
+0010
+1E10
+0010
+0090
+FF90
+3E10
+6310
+4110
+6310
+3E10
+0010
+0010
+0010
+0010
+ENDCHAR
+STARTCHAR uniD789
+ENCODING 55177
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 10 16 4 -3
+BITMAP
+00C0
+7040
+0840
+0640
+F840
+8440
+8440
+C440
+7840
+0000
+7FC0
+0040
+0040
+0040
+0040
+0040
+ENDCHAR
+STARTCHAR uniD78C
+ENCODING 55180
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
+BITMAP
+0060
+0010
+3C10
+0090
+FF90
+1810
+6610
+4210
+4210
+3C10
+0010
+0C10
 0400
-3F80
-4440
-8420
-4440
-3F80
 0400
+07F8
+ENDCHAR
+STARTCHAR uniD790
+ENCODING 55184
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 15 2 -2
+BITMAP
+0030
+1C10
+0010
+FF90
+1010
+6C10
+4210
+6210
+3C00
+1FF0
+0020
+1FF0
+0800
+0800
+0FF0
+ENDCHAR
+STARTCHAR uniD798
+ENCODING 55192
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 12 16 2 -3
+BITMAP
+0030
+1E10
+0010
+FF90
+1810
+6410
+4210
+6210
+3C10
+0000
+0FF0
+0420
+0420
+0420
+07F0
 0400
-0E00
 ENDCHAR
-STARTCHAR char4343
-ENCODING 61687
-SWIDTH 360 0
-DWIDTH 6 0
-BBX 5 11 1 -4
+STARTCHAR uniD799
+ENCODING 55193
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 16 3 -3
 BITMAP
-70
-88
-C8
-08
-10
-20
-40
-80
-98
-88
-70
+00C0
+3C20
+0020
+FFA0
+1820
+6420
+4220
+6220
+3C20
+1840
+0840
+0FC0
+0840
+0840
+0FC0
+0840
 ENDCHAR
-STARTCHAR char4344
-ENCODING 61688
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 6 9 1 0
+STARTCHAR uniD79B
+ENCODING 55195
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 13 15 2 -2
 BITMAP
-30
-48
-40
-20
-18
-44
-84
-84
-78
+0030
+0010
+1E10
+FF90
+0410
+1E10
+2110
+2110
+2110
+1E10
+0080
+0180
+0340
+0430
+1808
 ENDCHAR
-STARTCHAR space
-ENCODING 61952
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 0 0 0 0
+STARTCHAR uniD79D
+ENCODING 55197
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 11 15 3 -2
 BITMAP
+0060
+0020
+3C20
+FF20
+0820
+3C20
+4220
+4220
+6620
+1920
+0380
+0C60
+0820
+0C60
+07C0
 ENDCHAR
-STARTCHAR Ethspace
-ENCODING 61953
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 2 6 2 2
+STARTCHAR uniE00C
+ENCODING 57356
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-C0
-C0
-00
-00
-C0
-C0
+B6D6
+8000
+3EAA
+84A8
+08AA
+90AA
+BE50
+0002
+A20A
+B208
+2A0A
+A68A
+A270
+0002
+DB6A
 ENDCHAR
-STARTCHAR comma
-ENCODING 61954
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 7 1 2
+STARTCHAR uniE00D
+ENCODING 57357
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 15 0 0
 BITMAP
-FC
-00
-30
-30
-00
-30
-30
+B6D6
+8000
+3EAA
+84A8
+08AA
+90AA
+BE50
+0002
+8042
+8040
+0042
+8442
+8380
+0002
+DB6A
 ENDCHAR
-STARTCHAR semicolon
-ENCODING 61955
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 9 1 1
+STARTCHAR uniE12E
+ENCODING 57646
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 19 1 -3
 BITMAP
-FC
-00
-30
+10
 30
+20
+40
 00
+F8
+20
+20
+20
+20
+20
+20
+20
+20
+20
+F8
+20
+48
 30
-30
-00
-FC
 ENDCHAR
-STARTCHAR preface-colon
-ENCODING 61956
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 7 1 2
+STARTCHAR uniE12F
+ENCODING 57647
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 15 1 -3
 BITMAP
-C0
-C0
-00
-7C
+10
+30
+20
+40
 00
-C0
 C0
+40
+40
+40
+40
+40
+E0
+40
+90
+60
 ENDCHAR
-STARTCHAR colon
-ENCODING 61957
+STARTCHAR uniE5DA
+ENCODING 58842
 SWIDTH 480 0
 DWIDTH 8 0
-BBX 6 7 1 2
+BBX 7 13 1 -4
 BITMAP
-30
-30
-00
-FC
-00
-30
-30
+40
+FE
+04
+04
+74
+24
+04
+04
+04
+04
+04
+04
+04
 ENDCHAR
-STARTCHAR period
-ENCODING 61958
-SWIDTH 480 0
-DWIDTH 8 0
-BBX 6 6 1 2
+STARTCHAR uni0000
+ENCODING 58880
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 -1 0
 BITMAP
-CC
-CC
-00
+18
+20
+18
+E0
 00
-CC
-CC
+10
+18
+10
+10
+10
+10
+10
+10
+10
+10
 ENDCHAR
-STARTCHAR questionmark
-ENCODING 61959
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 2 10 1 1
+STARTCHAR uni0001
+ENCODING 58881
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 6 16 -1 0
 BITMAP
-C0
-C0
-00
-00
-C0
-C0
+18
+20
+18
+E0
 00
 00
-C0
-C0
+10
+18
+10
+10
+10
+10
+10
+10
+10
+0C
 ENDCHAR
-STARTCHAR paragraph
-ENCODING 61960
-SWIDTH 600 0
-DWIDTH 10 0
-BBX 8 9 1 1
+STARTCHAR uni0002
+ENCODING 58882
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 -1 -5
 BITMAP
+10
 18
+10
+10
+10
+10
+10
+10
+10
+10
+00
 18
-C3
-DB
+20
 18
-C3
-C3
+E0
+ENDCHAR
+STARTCHAR uni0003
+ENCODING 58883
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 6 16 -1 -6
+BITMAP
+10
+18
+10
+10
+10
+10
+10
+10
+10
+0C
+00
+00
 18
+20
 18
+E0
 ENDCHAR
-STARTCHAR gemination
-ENCODING 61961
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 2 1 11
+STARTCHAR uni0004
+ENCODING 58884
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 13 2 0
 BITMAP
-C6
-C6
+0C
+10
+0C
+90
+C0
+80
+80
+80
+80
+80
+80
+80
+80
 ENDCHAR
-STARTCHAR left-quote
-ENCODING 61962
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 7 6 2 3
+STARTCHAR uni0005
+ENCODING 58885
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 13 2 0
 BITMAP
-36
-6C
-D8
-D8
-6C
-36
+0C
+10
+8C
+90
+C0
+80
+80
+80
+80
+80
+80
+80
+60
 ENDCHAR
-STARTCHAR right-quote
-ENCODING 61963
+STARTCHAR uni0006
+ENCODING 58886
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 7 6 1 3
+BBX 9 14 0 -3
 BITMAP
-D8
-6C
-36
-36
-6C
-D8
+0180
+0200
+0180
+0200
+0000
+0000
+0400
+0A00
+0A00
+0E00
+0200
+0200
+8400
+7800
 ENDCHAR
-STARTCHAR and
-ENCODING 61964
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -1
+STARTCHAR uni0007
+ENCODING 58887
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
 BITMAP
-C180
-7F00
+0180
+0200
+0180
+0200
 0000
-0C00
-0C00
-1800
-3E00
-6300
-6300
-3E00
 0000
-7F00
-C180
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
 ENDCHAR
-STARTCHAR hulet
-ENCODING 61965
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -1
+STARTCHAR uni0008
+ENCODING 58888
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 14 1 -2
 BITMAP
-C180
-7F00
+0018
+0020
+0018
+0020
 0000
-1C00
-3600
-6600
-7C00
-6000
-7C00
-3600
-1C00
-7F00
-C180
+0000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
 ENDCHAR
-STARTCHAR sost
-ENCODING 61966
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
+STARTCHAR uni0009
+ENCODING 58889
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 12 1 -5
 BITMAP
-C3
-7E
-00
-7E
-66
-60
-60
-60
-60
-00
-7E
-C3
+0018
+0020
+0018
+0020
+0000
+0000
+41E0
+8200
+8180
+8040
+4180
+3E00
 ENDCHAR
-STARTCHAR arat
-ENCODING 61967
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
+STARTCHAR uni000A
+ENCODING 58890
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 0 0
 BITMAP
-C3
-7E
+06
+08
+06
+08
 00
-3C
-66
-66
-66
-66
-3C
 00
-7E
-C3
+10
+08
+08
+08
+F0
 ENDCHAR
-STARTCHAR amst
-ENCODING 61968
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -1
+STARTCHAR uni000B
+ENCODING 58891
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 7 10 0 0
 BITMAP
-C180
-7F00
-0000
-1800
-1800
-3F00
-7300
-6000
-6300
-3F00
-0000
-7F00
-C180
+06
+08
+06
+08
+00
+00
+10
+10
+10
+FC
 ENDCHAR
-STARTCHAR sadst
-ENCODING 61969
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 14 0 -1
+STARTCHAR uni000C
+ENCODING 58892
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -4
 BITMAP
-C180
-7F00
-0000
-3C00
-7E00
-6600
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
 0600
-0C00
-0E00
-1B00
-1E00
-0000
-7F00
-C180
-ENDCHAR
-STARTCHAR sabat
-ENCODING 61970
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 14 0 -1
-BITMAP
-C180
-7F00
-0000
-3C00
-7E00
-6600
+0900
 0600
-0C00
-0800
-1900
-1F00
-0000
-7F00
-C180
 ENDCHAR
-STARTCHAR smnt
-ENCODING 61971
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -1
+STARTCHAR uni000D
+ENCODING 58893
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 1 -4
 BITMAP
-C0C0
-7F80
-0000
-7F80
-6D80
-0C00
-0C00
-0C00
-7F80
-6180
+0500
+0500
 0000
+4000
+8010
+8010
+C07E
 7F80
-C0C0
+0600
+0900
+0600
 ENDCHAR
-STARTCHAR zeteN
-ENCODING 61972
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 -1
+STARTCHAR uni000E
+ENCODING 58894
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -3
 BITMAP
-C3
-7E
-00
-00
-66
-66
-7E
-66
-64
-38
+28
+28
 00
-7E
-C3
+10
+08
+08
+08
+F0
+60
+90
+60
 ENDCHAR
-STARTCHAR asr
-ENCODING 61973
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
+STARTCHAR uni000F
+ENCODING 58895
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 -3
 BITMAP
-C3
-7E
-00
-18
-18
-18
-18
-18
-18
+28
+28
 00
-7E
-C3
+10
+10
+10
+FC
+60
+90
+60
 ENDCHAR
-STARTCHAR heya
-ENCODING 61974
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 -1
+STARTCHAR uni0010
+ENCODING 58896
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 10 1 -1
 BITMAP
-C0C0
-7F80
-0000
-3F00
-2D00
-0C00
-1E00
-3300
-3300
-0000
-7F80
-C0C0
+0500
+0500
+0200
+0200
+0008
+4008
+8008
+8008
+C030
+7FC0
 ENDCHAR
-STARTCHAR selasa
-ENCODING 61975
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 -1
+STARTCHAR uni0011
+ENCODING 58897
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 10 1 -1
 BITMAP
-C0C0
-7F80
-0000
-2F00
-6D80
-6D80
-6D80
-6D80
-3980
+0500
+0500
+0200
+0200
 0000
+4000
+8010
+8010
+C07E
 7F80
-C0C0
 ENDCHAR
-STARTCHAR arba
-ENCODING 61976
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -1
+STARTCHAR uni0012
+ENCODING 58898
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 0 0
 BITMAP
-C0C0
-7F80
-0000
-6D80
-6D80
-6D80
-3F80
-0180
-0180
-0180
-0000
-7F80
-C0C0
+28
+28
+10
+10
+00
+10
+08
+08
+08
+F0
 ENDCHAR
-STARTCHAR hemsa
-ENCODING 61977
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 -1
+STARTCHAR uni0013
+ENCODING 58899
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 0
 BITMAP
-C3
-7E
+28
+28
+10
+10
 00
-3E
-66
-3E
-06
-0C
-0C
-0C
 00
-7E
-C3
+10
+10
+10
+FC
 ENDCHAR
-STARTCHAR slsa
-ENCODING 61978
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -1
+STARTCHAR uni0014
+ENCODING 58900
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -6
 BITMAP
-C0C0
-7F80
-0000
-7F80
-6D80
 0C00
-0E00
-0600
-7F80
-6180
+1000
+0C00
+1000
 0000
-7F80
-C0C0
-ENDCHAR
-STARTCHAR seba
-ENCODING 61979
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 -1
-BITMAP
-C3
-7E
-00
-3E
-6B
-6E
-60
-66
-3E
-00
-7E
-C3
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
 ENDCHAR
-STARTCHAR semanya
-ENCODING 61980
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 -1
+STARTCHAR uni0015
+ENCODING 58901
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 17 1 -6
 BITMAP
-C060
-7FC0
+0600
+0800
+0600
+0800
 0000
-7FC0
-5B40
-1B00
-1B00
-1B00
-1B00
 0000
-7FC0
-C060
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
 ENDCHAR
-STARTCHAR zeTana
-ENCODING 61981
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 14 0 -1
+STARTCHAR uni0016
+ENCODING 58902
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 0 0
 BITMAP
-C180
-7F00
+0300
+0400
+0300
+0400
 0000
-3E00
-3600
-0C00
-0E00
-0600
-0C00
-0C00
-0C00
 0000
-7F00
-C180
-ENDCHAR
-STARTCHAR meto
-ENCODING 61982
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 -1
-BITMAP
-C3
-7E
-00
-3C
-66
-7C
-60
-30
-30
-30
-00
-7E
-C3
+3800
+4600
+0100
+FF80
 ENDCHAR
-STARTCHAR asr-xi
-ENCODING 61983
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 -1
+STARTCHAR uni0016
+ENCODING 58903
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 0 0
 BITMAP
-C030
-7FE0
+0300
+0400
+0300
+0400
 0000
-79E0
-CF30
-FBE0
-C300
-6180
-6180
-6180
 0000
-7FE0
-C030
-ENDCHAR
-STARTCHAR he
-ENCODING 61984
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
-BITMAP
-07
-C3
-C3
-C3
-C3
-C3
-C3
-C6
-C6
-7C
-38
-ENDCHAR
-STARTCHAR hu
-ENCODING 61985
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
-BITMAP
-0700
-C300
-C300
-C300
-C3F0
-C330
-C300
-C600
-C600
-7C00
 3800
-ENDCHAR
-STARTCHAR hi
-ENCODING 61986
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
-BITMAP
-66
-C6
-C6
-C6
-C6
-7C
-3C
-0C
-18
-30
-33
-3F
-ENDCHAR
-STARTCHAR ha
-ENCODING 61987
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
-BITMAP
-66
-C6
-C6
-C6
-C6
-7C
-3C
-0C
-18
-30
-30
-30
-ENDCHAR
-STARTCHAR hE
-ENCODING 61988
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
-BITMAP
-66
-C6
-C6
-C6
-C6
-7C
-3C
-0C
-1C
-34
-32
-3E
-ENDCHAR
-STARTCHAR h
-ENCODING 61989
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
-BITMAP
-C380
-C180
-E180
-7180
-3180
-6180
-6180
-6180
-6300
-3F00
-1E00
+4600
+0100
+FFC0
 ENDCHAR
-STARTCHAR ho
-ENCODING 61990
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni0018
+ENCODING 58904
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 18 1 -6
 BITMAP
-03C0
-C320
-C360
-C380
-C300
-C300
-C300
-C600
-C600
-7C00
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+7000
+8F00
 3800
-ENDCHAR
-STARTCHAR le
-ENCODING 61992
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
-BITMAP
-30
-30
-30
-78
-7C
-CE
-C6
-C6
-C6
-C6
-C6
-C6
-ENDCHAR
-STARTCHAR lu
-ENCODING 61993
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
-BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C7E0
-C660
-C600
-C600
-ENDCHAR
-STARTCHAR li
-ENCODING 61994
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
-BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C600
-C600
-C660
-C7E0
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
 ENDCHAR
-STARTCHAR la
-ENCODING 61995
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni0019
+ENCODING 58905
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 18 1 -6
 BITMAP
-30
-30
-30
-78
-7C
-CE
-C6
-C6
-C6
-06
-06
-06
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
 ENDCHAR
-STARTCHAR lE
-ENCODING 61996
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni0016
+ENCODING 58906
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 0 0
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C600
-C7C0
-C660
-C7C0
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+3800
+4600
+0100
+FF80
 ENDCHAR
-STARTCHAR l
-ENCODING 61997
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni0016
+ENCODING 58907
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 0
 BITMAP
-18
-18
-18
-3C
-3E
-67
-63
-C3
-C3
-F3
-DB
-F3
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+3800
+4600
+0100
+FFC0
 ENDCHAR
-STARTCHAR lo
-ENCODING 61998
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni001C
+ENCODING 58908
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -6
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C7E0
-C6B0
-C6E0
-C600
-C600
+0800
+0800
+1400
+1400
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
 ENDCHAR
-STARTCHAR lWa
-ENCODING 61999
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni001D
+ENCODING 58909
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 17 1 -6
 BITMAP
-3000
-3000
-3000
-7800
-7C00
-CE00
-C600
-C600
-C600
-0600
-0600
-0600
-1F80
-30C0
+0800
+0800
+1400
+1400
+0000
+0000
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
 ENDCHAR
-STARTCHAR He
-ENCODING 62000
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0016
+ENCODING 58910
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 0 0
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-CCC0
-CCC0
-CCC0
+0800
+0800
+1400
+1400
+0000
+0000
+3800
+4600
+0100
+FF80
 ENDCHAR
-STARTCHAR Hu
-ENCODING 62001
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni0016
+ENCODING 58911
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 1 0
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCFC
-CCCC
-CCC0
-CCC0
+0800
+0800
+1400
+1400
+0000
+0000
+3800
+4600
+0100
+FFC0
 ENDCHAR
-STARTCHAR Hi
-ENCODING 62002
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni0020
+ENCODING 58912
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 -3
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-CCC0
-CCCC
-CCFC
+10
+10
+08
+08
+98
+60
+20
+50
+20
 ENDCHAR
-STARTCHAR Ha
-ENCODING 62003
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0021
+ENCODING 58913
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 9 1 -2
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-00C0
-00C0
-00C0
+10
+10
+08
+08
+08
+98
+66
+50
+20
 ENDCHAR
-STARTCHAR HE
-ENCODING 62004
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni0022
+ENCODING 58914
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 -4
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CC80
-CCF0
-CC98
-CCF0
+10
+10
+08
+08
+98
+60
+00
+00
+20
+20
 ENDCHAR
-STARTCHAR H
-ENCODING 62005
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0023
+ENCODING 58915
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 1 -4
 BITMAP
-3000
-3000
-3000
-3C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-CCC0
-CCC0
-CCC0
+10
+10
+08
+08
+08
+98
+66
+00
+00
+20
+20
 ENDCHAR
-STARTCHAR Ho
-ENCODING 62006
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0024
+ENCODING 58916
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 16 1 -4
 BITMAP
-0C00
-0C00
-0C00
-0C00
-0C00
-3F00
-6D80
-6D80
-CCC0
-C000
-C000
-C000
+40
+40
+70
+70
+00
+00
+10
+10
+08
+08
+98
+60
+00
+00
+20
+20
 ENDCHAR
-STARTCHAR me
-ENCODING 62008
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 8 0 2
+STARTCHAR uni0025
+ENCODING 58917
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 17 1 -4
 BITMAP
-3FF0
-7FF0
-4490
-C590
-8D10
-9930
-F1E0
-F1C0
+40
+40
+70
+70
+00
+00
+10
+10
+08
+08
+08
+98
+66
+00
+00
+20
+20
 ENDCHAR
-STARTCHAR mu
-ENCODING 62009
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 8 0 2
+STARTCHAR uni0026
+ENCODING 58918
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
 BITMAP
-3FF0
-7FF0
-4490
-C59E
-8D12
-9932
-F1E0
-F1C0
+50
+50
+20
+20
+00
+00
+10
+10
+08
+08
+98
+60
 ENDCHAR
-STARTCHAR mi
-ENCODING 62010
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni0027
+ENCODING 58919
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 13 1 0
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0040
-004C
-007C
+50
+50
+20
+20
+00
+00
+10
+10
+08
+08
+08
+98
+66
 ENDCHAR
-STARTCHAR ma
-ENCODING 62011
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0028
+ENCODING 58920
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 1 0
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0040
-0040
-0040
+50
+50
+00
+50
+50
+00
+00
+10
+10
+08
+08
+98
+60
 ENDCHAR
-STARTCHAR mE
-ENCODING 62012
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni0029
+ENCODING 58921
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 14 1 0
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0078
-004C
-0078
+50
+50
+00
+50
+50
+00
+00
+10
+10
+08
+08
+08
+98
+66
 ENDCHAR
-STARTCHAR m
-ENCODING 62013
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni002A
+ENCODING 58922
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 13 1 -4
 BITMAP
-7FC0
-7FE0
-CA20
-8A20
-8A20
-8BE0
-F9C0
-7800
-0800
-1800
-3000
-6000
+22
+14
+08
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
 ENDCHAR
-STARTCHAR mo
-ENCODING 62014
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni002B
+ENCODING 58923
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -5
 BITMAP
-7FC0
-7FE0
-CA20
-8A20
-8A20
-8BE0
-F9C0
-7800
-0800
-1000
-1000
-1000
+22
+14
+08
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
 ENDCHAR
-STARTCHAR mWa
-ENCODING 62015
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 14 0 -2
+STARTCHAR uni002C
+ENCODING 58924
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 9 1 -5
 BITMAP
-3FF0
-7FF0
-C510
-8510
-8A10
-FBF0
-71F0
-0020
-0020
-0060
-0040
-0040
-03F0
-0618
+08
+08
+04
+04
+04
+0C
+18
+F4
+0C
 ENDCHAR
-STARTCHAR `se/s2e
-ENCODING 62016
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 9 0 1
+STARTCHAR uni002D
+ENCODING 58925
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 9 1 -6
 BITMAP
-4CC0
-CCC0
-CCC0
-CCC0
-CCC0
-CD80
-CF80
-6C00
-3C00
+08
+0C
+07
+04
+04
+0C
+18
+F4
+0C
 ENDCHAR
-STARTCHAR `su/s2u
-ENCODING 62017
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 9 0 1
+STARTCHAR uni002E
+ENCODING 58926
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 -6
 BITMAP
-4D80
-CD80
-CDF8
-CD98
-CD80
-CD80
-CF80
-6C00
-3C00
+08
+08
+04
+04
+04
+0C
+18
+F0
+04
+04
 ENDCHAR
-STARTCHAR `si/s2i
-ENCODING 62018
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni002F
+ENCODING 58927
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 -7
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7FC0
-00C0
-00C0
-00C0
-00CC
-00FC
+08
+0C
+07
+04
+04
+0C
+18
+F0
+04
+04
 ENDCHAR
-STARTCHAR `sa/s2a
-ENCODING 62019
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0030
+ENCODING 58928
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -8
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7FC0
-00C0
-00C0
-00C0
-00C0
-00C0
+08
+08
+04
+04
+04
+0C
+18
+F0
+00
+44
+28
+10
 ENDCHAR
-STARTCHAR `sE/s2E
-ENCODING 62020
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0031
+ENCODING 58929
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -9
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7FC0
-00C0
-00C0
-00E0
-0190
-01E0
+08
+0C
+07
+04
+04
+0C
+18
+F0
+00
+44
+28
+10
 ENDCHAR
-STARTCHAR `s/s2
-ENCODING 62021
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0032
+ENCODING 58930
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 -6
 BITMAP
-CC80
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-FF80
-E000
-C000
-C000
-C000
-C000
+08
+08
+04
+44
+44
+0C
+18
+F0
+04
+04
 ENDCHAR
-STARTCHAR `so/s2o
-ENCODING 62022
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0033
+ENCODING 58931
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 -7
 BITMAP
-CCC0
-CCC0
-CCC0
-CCC0
-CCC0
-EDC0
-7F80
-1C00
-1800
-3800
-7000
-6000
+08
+0C
+07
+44
+44
+0C
+18
+F0
+04
+04
 ENDCHAR
-STARTCHAR re
-ENCODING 62024
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni0034
+ENCODING 58932
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -4
 BITMAP
+14
+14
+00
+00
+08
+08
+04
+04
+04
 0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0035
+ENCODING 58933
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -5
+BITMAP
+14
+14
+00
+00
+08
 0C
+07
+04
+04
 0C
 18
-38
-70
-E0
-C0
-C0
-E3
-7F
-3F
+F0
 ENDCHAR
-STARTCHAR ru
-ENCODING 62025
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0036
+ENCODING 58934
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -4
 BITMAP
-0C00
-0C00
-1C00
-3800
-7000
-6000
-C000
-E000
-7FC0
-3FC0
-0600
-0600
+14
+14
+00
+14
+14
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
 ENDCHAR
-STARTCHAR ri
-ENCODING 62026
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni0037
+ENCODING 58935
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 -5
 BITMAP
-0C00
-0C00
-0C00
-1800
-3800
-7000
-E000
-C300
-C380
-E180
-7F00
-3E00
+14
+14
+00
+14
+14
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
 ENDCHAR
-STARTCHAR ra
-ENCODING 62027
+STARTCHAR uni0038
+ENCODING 58936
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 11 12 0 0
+BBX 15 12 1 -5
 BITMAP
-0C00
-0C00
-0C00
-1800
-3800
-7000
-E000
-C1E0
-C3E0
-E660
-7E00
+0010
+0010
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8088
+4308
 3C00
 ENDCHAR
-STARTCHAR rE
-ENCODING 62028
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0039
+ENCODING 58937
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 12 1 -5
 BITMAP
-0C00
-0C00
-0C00
-1800
-3800
-7000
-E000
-C000
-C000
-E780
-7CC0
-3F80
+001000
+001000
+000000
+000000
+011200
+011200
+40FF80
+808000
+808000
+808800
+430800
+3C0000
 ENDCHAR
-STARTCHAR r
-ENCODING 62029
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uni003A
+ENCODING 58938
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 0 -4
 BITMAP
-3F
-7F
-C3
-C0
-C0
-C0
-C0
-C0
-C3
-FF
-7E
+0100
+0100
+0000
+0000
+1120
+1120
+FFE0
+0000
+0000
+0080
+0080
 ENDCHAR
-STARTCHAR ro
-ENCODING 62030
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR uni003B
+ENCODING 58939
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -4
 BITMAP
-3F80
-7CC0
-C780
-C000
-C000
-C000
-C000
-C000
-C300
-FF00
-7E00
+0100
+0100
+0000
+0000
+1120
+1120
+FFF8
+0000
+0000
+0080
+0080
 ENDCHAR
-STARTCHAR rWa
-ENCODING 62031
+STARTCHAR uni003C
+ENCODING 58940
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 11 13 0 -2
+BBX 15 9 1 -6
 BITMAP
-C0C0
-7380
-0C00
-0C00
-1800
-3800
-7000
-E000
-C1E0
-C3E0
-E660
-7E00
-3C00
+0112
+0112
+40EC
+8080
+8080
+8094
+4314
+3C08
+0008
 ENDCHAR
-STARTCHAR se
-ENCODING 62032
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni003D
+ENCODING 58941
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 9 1 -6
 BITMAP
-10
-10
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-C6
+011200
+011200
+40FF80
+808000
+808000
+809400
+431400
+3C0800
+000800
 ENDCHAR
-STARTCHAR su
-ENCODING 62033
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni003E
+ENCODING 58942
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 9 0 -6
 BITMAP
-1000
-1000
-3800
-7C00
-C600
-C600
-C600
-C7E0
-C660
-C600
-C600
-C600
+1120
+1120
+FFE0
+0000
+0000
+0280
+0280
+0100
+0100
 ENDCHAR
-STARTCHAR si
-ENCODING 62034
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni003F
+ENCODING 58943
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 9 0 -6
 BITMAP
-1000
-1000
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-C600
-C660
-C7E0
+1120
+1120
+FFF8
+0000
+0000
+0280
+0280
+0100
+0100
 ENDCHAR
-STARTCHAR sa
-ENCODING 62035
+STARTCHAR uni0040
+ENCODING 58944
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 7 12 0 0
+BBX 15 15 1 -6
 BITMAP
-10
-10
-38
-7C
-C6
-C6
-C6
-C6
-C6
-06
-06
-06
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8094
+4314
+3C08
+0008
 ENDCHAR
-STARTCHAR sE
-ENCODING 62036
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0041
+ENCODING 58945
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 15 1 -6
 BITMAP
-1000
-1000
-3800
-7C00
-C600
-C600
-C600
-C600
-C700
-C680
-C640
-C7C0
+001000
+001000
+002800
+002800
+000000
+000000
+011200
+011200
+40FF80
+808000
+808000
+809400
+431400
+3C0800
+000800
 ENDCHAR
-STARTCHAR s
-ENCODING 62037
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uni0042
+ENCODING 58946
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 0 -6
 BITMAP
-30
-18
-1C
-3E
-63
-63
-63
-63
-63
-63
-63
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFE0
+0000
+0000
+0280
+0280
+0100
+0100
 ENDCHAR
-STARTCHAR so
-ENCODING 62038
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni0043
+ENCODING 58947
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 15 0 -6
 BITMAP
-10
-10
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C0
-C0
-C0
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFF8
+0000
+0000
+0280
+0280
+0100
+0100
 ENDCHAR
-STARTCHAR sWa
-ENCODING 62039
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni0044
+ENCODING 58948
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 9 1 -5
 BITMAP
-1000
-1000
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-0600
-0600
-0600
-1F80
-30C0
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808A00
+430A00
+3C0000
 ENDCHAR
-STARTCHAR xe
-ENCODING 62040
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni0045
+ENCODING 58949
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 9 1 -5
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6300
-6300
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808A00
+430A00
+3C0000
 ENDCHAR
-STARTCHAR xu
-ENCODING 62041
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0046
+ENCODING 58950
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 8 0 -4
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-63F0
-6330
-6330
-6300
-6300
+0070
+2188
+2208
+FFF0
+0000
+0000
+0140
+0140
 ENDCHAR
-STARTCHAR xi
-ENCODING 62042
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0047
+ENCODING 58951
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 8 0 -4
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6330
-63F0
+00E0
+2310
+2410
+FFF8
+0000
+0000
+0280
+0280
 ENDCHAR
-STARTCHAR xa
-ENCODING 62043
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni0048
+ENCODING 58952
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -5
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-0300
-0300
-0300
+001000
+001000
+002800
+002800
+000000
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808000
+430000
+3C0000
 ENDCHAR
-STARTCHAR xE
-ENCODING 62044
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0049
+ENCODING 58953
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 15 1 -5
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-63E0
-6330
-63E0
+001000
+001000
+002800
+002800
+000000
+000000
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808000
+430000
+3C0000
 ENDCHAR
-STARTCHAR x
-ENCODING 62045
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni004A
+ENCODING 58954
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 10 0 0
 BITMAP
-C300
-7E00
-0C00
-0E00
-1F00
-1980
-3180
-3180
-3180
-3180
-3180
-3180
+0100
+0100
+0280
+0280
+0000
+0000
+0070
+2188
+2208
+FFF0
 ENDCHAR
-STARTCHAR xo
-ENCODING 62046
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni004B
+ENCODING 58955
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 10 0 0
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6000
-6000
-6000
+0200
+0200
+0500
+0500
+0000
+0000
+00E0
+2310
+2410
+FFF8
 ENDCHAR
-STARTCHAR xWa
-ENCODING 62047
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR uni004C
+ENCODING 58956
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
 BITMAP
-C180
-7F00
-0800
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-0300
-0300
-0FC0
-1860
+22
+32
+25
+25
+20
+20
+2E
+31
+21
+FE
 ENDCHAR
-STARTCHAR qe
-ENCODING 62048
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni004D
+ENCODING 58957
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 1 0
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-0C00
+2200
+3200
+2500
+2500
+2000
+2000
+2E00
+3100
+2100
+FFC0
 ENDCHAR
-STARTCHAR qu
-ENCODING 62049
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni004E
+ENCODING 58958
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 0 0
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0FC0
-0CC0
-0C00
+22
+32
+25
+25
+20
+20
+2E
+31
+21
+FE
 ENDCHAR
-STARTCHAR qi
-ENCODING 62050
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni004F
+ENCODING 58959
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 0 0
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0CC0
-0FC0
+2200
+3200
+2500
+2500
+2000
+2000
+2E00
+3100
+2100
+FFC0
 ENDCHAR
-STARTCHAR qa
-ENCODING 62051
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0050
+ENCODING 58960
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 18 1 -7
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-1800
+1000
+1000
+2800
+2800
+0000
+0000
+3800
+4000
+8000
+4C00
 3000
-6000
+4000
+4000
+8000
+8000
+8000
+4180
+3E00
 ENDCHAR
-STARTCHAR qE
-ENCODING 62052
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0051
+ENCODING 58961
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 17 1 -6
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0F80
-0CC0
-0F80
+1000
+1000
+2800
+2800
+0000
+0000
+3800
+6C00
+1000
+3800
+4780
+4000
+8000
+8000
+8000
+4180
+3E00
 ENDCHAR
-STARTCHAR q
-ENCODING 62053
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0052
+ENCODING 58962
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 0 0
 BITMAP
-3000
-3000
-3C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+08
+08
+14
+14
+00
+00
+1C
+20
+40
+22
+FC
 ENDCHAR
-STARTCHAR qo
-ENCODING 62054
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0053
+ENCODING 58963
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 11 0 0
 BITMAP
-0700
-0980
-0B00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+08
+08
+14
+14
+00
+00
+1C
+36
+08
+1C
+E3
 ENDCHAR
-STARTCHAR qWe
-ENCODING 62056
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni0054
+ENCODING 58964
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 8 1 0
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0FC0
-0D60
-0DC0
-0C00
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
 ENDCHAR
-STARTCHAR qWu/qW
-ENCODING 62057
+STARTCHAR uni0055
+ENCODING 58965
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 14 12 0 0
+BBX 16 8 1 -1
 BITMAP
-0C00
-0C30
-0C30
-1FFC
-6CCC
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-0C00
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
 ENDCHAR
-STARTCHAR qWi
-ENCODING 62058
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni0056
+ENCODING 58966
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 7 0 0
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CD8
-CCD8
-CDF8
-7E0C
-0C0C
-0C00
-0C00
-0C00
+30
+58
+48
+58
+28
+08
+F0
 ENDCHAR
-STARTCHAR qWa
-ENCODING 62059
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni0057
+ENCODING 58967
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 6 0 0
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-0C00
-3F00
-6180
+18
+24
+24
+18
+18
+E7
 ENDCHAR
-STARTCHAR qWE
-ENCODING 62060
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni0058
+ENCODING 58968
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 12 1 -4
 BITMAP
-0C00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0F80
-0CC0
-3F80
-6000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0000
+0100
+0100
 ENDCHAR
-STARTCHAR Qe
-ENCODING 62064
+STARTCHAR uni0059
+ENCODING 58969
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 12 0 0
+BBX 16 12 1 -5
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+0000
+0000
+0100
+0100
 ENDCHAR
-STARTCHAR Qu
-ENCODING 62065
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni005A
+ENCODING 58970
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -4
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0FC0
-0CC0
+30
+58
+48
+58
+28
+08
+F0
+00
+00
+80
+80
 ENDCHAR
-STARTCHAR Qi
-ENCODING 62066
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni005B
+ENCODING 58971
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 -4
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0CC0
-0FC0
+18
+24
+24
+18
+18
+E7
+00
+00
+40
+40
 ENDCHAR
-STARTCHAR Qa
-ENCODING 62067
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni005C
+ENCODING 58972
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 16 1 -4
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-1800
-3000
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0000
+0100
+0100
 ENDCHAR
-STARTCHAR QE
-ENCODING 62068
+STARTCHAR uni005D
+ENCODING 58973
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 10 12 0 0
+BBX 16 16 1 -5
 BITMAP
-6180
-3F00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0F80
-0CC0
-0F80
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+403F
+3FC0
+0000
+0000
+0100
+0100
 ENDCHAR
-STARTCHAR Q
-ENCODING 62069
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni005E
+ENCODING 58974
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 0 -4
 BITMAP
-C300
-7E00
-1800
-1E00
-0600
-0FC0
-3660
-6660
-66C0
-3F00
-0600
-0600
+20
+20
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+00
+00
+80
+80
+ENDCHAR
+STARTCHAR uni005F
+ENCODING 58975
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 14 0 -4
+BITMAP
+08
+08
+00
+00
+18
+24
+24
+18
+18
+E7
+00
+00
+40
+40
 ENDCHAR
-STARTCHAR Qo
-ENCODING 62070
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni0060
+ENCODING 58976
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 1 -5
 BITMAP
-60C0
-3F80
-0900
-0B00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0028
+0028
+0010
+0010
 ENDCHAR
-STARTCHAR QWe
-ENCODING 62072
+STARTCHAR uni0061
+ENCODING 58977
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 11 12 0 0
+BBX 16 13 1 -6
 BITMAP
-6180
-3F00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0FC0
-0D60
-0DC0
-0C00
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+0000
+0028
+0028
+0010
+0010
 ENDCHAR
-STARTCHAR QWu/QW
-ENCODING 62073
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni0062
+ENCODING 58978
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 0 -6
 BITMAP
-6180
-3F00
-0C30
-0C30
-1FFC
-6CCC
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
+30
+58
+48
+58
+28
+08
+F0
+00
+00
+50
+50
+20
+20
 ENDCHAR
-STARTCHAR QWi
-ENCODING 62074
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uni0063
+ENCODING 58979
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 0 -6
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CD8
-CCD8
-CDF8
-7E0C
-0C0C
-0C00
-0C00
+18
+24
+24
+18
+18
+E7
+00
+00
+28
+28
+10
+10
 ENDCHAR
-STARTCHAR QWa
-ENCODING 62075
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 0
+STARTCHAR uni0064
+ENCODING 58980
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -3
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0C00
-0C00
-3F00
-6180
+0200
+0200
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
 ENDCHAR
-STARTCHAR QWE
-ENCODING 62076
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uni0065
+ENCODING 58981
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 -5
 BITMAP
-6180
-3F00
-0C00
-0C00
-1F80
-6CC0
-CCC0
-CD80
-7E00
-0C00
-0F80
-0CC0
-3F80
-6000
+0200
+0200
+0000
+0000
+0300
+0580
+0480
+0480
+43E0
+8080
+8080
+8100
+4200
+3C00
 ENDCHAR
-STARTCHAR be
-ENCODING 62080
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uni0066
+ENCODING 58982
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 11 0 0
 BITMAP
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-C6
-C6
+20
+20
+00
+00
+30
+58
+48
+58
+28
+08
+F0
 ENDCHAR
-STARTCHAR bu
-ENCODING 62081
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni0067
+ENCODING 58983
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 0
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C7E0
-C660
-C660
-C600
-C600
-C600
+10
+10
+00
+00
+18
+24
+24
+28
+10
+FF
 ENDCHAR
-STARTCHAR bi
-ENCODING 62082
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni0068
+ENCODING 58984
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -3
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-C600
-C600
-C660
-C7E0
+0200
+0200
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
 ENDCHAR
-STARTCHAR ba
-ENCODING 62083
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uni0069
+ENCODING 58985
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 16 1 -5
 BITMAP
-38
-7C
-C6
-C6
-C6
-C6
-C6
-06
-06
-06
-06
+0200
+0200
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+43E0
+8080
+8080
+8100
+4200
+3C00
 ENDCHAR
-STARTCHAR bE
-ENCODING 62084
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni006A
+ENCODING 58986
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 13 0 0
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-C600
-C7C0
-C660
-C7C0
+20
+20
+50
+50
+00
+00
+30
+58
+48
+58
+28
+08
+F0
 ENDCHAR
-STARTCHAR b
-ENCODING 62085
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uni006B
+ENCODING 58987
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 0 0
 BITMAP
-0380
-07C0
-0C60
-0C60
-0C60
-FC60
-CC60
-CC60
-0C60
-0C60
-0C60
+10
+10
+28
+28
+00
+00
+18
+24
+24
+28
+10
+FF
 ENDCHAR
-STARTCHAR bo
-ENCODING 62086
+STARTCHAR uni006C
+ENCODING 58988
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 7 11 0 0
+BBX 14 9 0 0
 BITMAP
-38
-7C
-C6
-C6
-C6
-C6
-C6
-C0
-C0
-C0
-C0
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+8004
+7FF8
 ENDCHAR
-STARTCHAR bWa
-ENCODING 62087
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -2
+STARTCHAR uni006D
+ENCODING 58989
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 0
 BITMAP
-3800
-7C00
-C600
-C600
-C600
-C600
-C600
-0600
-0600
-0600
+0180
 0600
-1F80
-30C0
+1800
+2000
+2000
+1FF8
+0004
+8004
+7FFF
 ENDCHAR
-STARTCHAR ve
-ENCODING 62088
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni006E
+ENCODING 58990
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 9 0 0
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6300
-6300
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+0004
+FFF8
 ENDCHAR
-STARTCHAR vu
-ENCODING 62089
+STARTCHAR uni006F
+ENCODING 58991
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 12 12 0 0
+BBX 16 9 0 0
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-63F0
-6330
-6330
-6300
-6300
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+0004
+FFFF
 ENDCHAR
-STARTCHAR vi
-ENCODING 62090
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0070
+ENCODING 58992
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 -1
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6330
-63F0
+0008
+0030
+00E8
+0128
+0110
+0080
+4060
+8010
+8010
+8060
+7F80
 ENDCHAR
-STARTCHAR va
-ENCODING 62091
+STARTCHAR uni0071
+ENCODING 58993
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 9 12 0 0
+BBX 15 10 1 0
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-0300
-0300
+0008
+0030
+00E8
+0128
+0110
+4080
+8060
+8010
+8010
+7FFE
 ENDCHAR
-STARTCHAR vE
-ENCODING 62092
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0072
+ENCODING 58994
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 0 0
 BITMAP
-C180
-7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-63E0
-6330
-63E0
+01
+06
+1D
+25
+22
+10
+0C
+02
+02
+FC
 ENDCHAR
-STARTCHAR v
-ENCODING 62093
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0073
+ENCODING 58995
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 0 0
 BITMAP
-1830
-0FE0
-0000
-0380
-07C0
-0C60
-0C60
-FC60
-CC60
-CC60
-0C60
-0C60
+0080
+0300
+0E80
+1280
+1100
+0800
+0600
+0100
+0100
+FFE0
 ENDCHAR
-STARTCHAR vo
-ENCODING 62094
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni0075
+ENCODING 58996
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 1 0
 BITMAP
-C180
-7F00
+0400
+0400
 0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-6000
-6000
-ENDCHAR
-STARTCHAR vWa
-ENCODING 62095
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
-BITMAP
-C180
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
 7F00
-0000
-1C00
-3E00
-6300
-6300
-6300
-6300
-6300
-0300
-0300
-0FC0
-1860
 ENDCHAR
-STARTCHAR te
-ENCODING 62096
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0075
+ENCODING 58997
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 1 0
 BITMAP
-0E00
-0600
-0600
-0600
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
 7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
-0600
 ENDCHAR
-STARTCHAR tu
-ENCODING 62097
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0076
+ENCODING 58998
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 0 0
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-07E0
-0660
-0600
-0600
+08
+08
+00
+01
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
 ENDCHAR
-STARTCHAR ti
-ENCODING 62098
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0077
+ENCODING 58999
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
+0400
+0400
+0000
+0080
+0300
+0C00
+1000
+1000
+0800
 0600
-0660
-07E0
+0100
+0100
+FFE0
 ENDCHAR
-STARTCHAR ta
-ENCODING 62099
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0079
+ENCODING 59000
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 19 1 -6
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0E00
-1C00
-3800
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+0000
+0000
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR tE
-ENCODING 62100
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0079
+ENCODING 59001
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 19 1 -6
 BITMAP
-0E00
-0600
-0600
-0600
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
 7FE0
-FFF0
-C630
-0600
-0600
-07C0
-0660
-07C0
+0000
+0000
+1400
+1400
+0800
+0800
 ENDCHAR
-STARTCHAR t
-ENCODING 62101
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni007A
+ENCODING 59002
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 19 0 -6
 BITMAP
-1800
-1C00
-0E00
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
+08
+08
+00
+01
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+00
+00
+50
+50
+20
+20
 ENDCHAR
-STARTCHAR to
-ENCODING 62102
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni007B
+ENCODING 59003
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 19 0 -6
 BITMAP
-0F80
-0C80
-0580
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
+0400
+0400
+0000
+0080
+0300
+0C00
+1000
+1000
+0800
 0600
+0100
+0100
+FFE0
+0000
+0000
+2800
+2800
+1000
+1000
 ENDCHAR
-STARTCHAR tWa
-ENCODING 62103
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 14 0 -2
+STARTCHAR uni007C
+ENCODING 59004
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 14 1 -1
 BITMAP
-0E00
-0600
-0600
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
-0600
-1F80
-30C0
+0008
+0030
+00C0
+0108
+0030
+00E8
+0128
+0110
+0080
+4060
+8010
+8010
+8060
+7F80
 ENDCHAR
-STARTCHAR ce
-ENCODING 62104
+STARTCHAR uni007D
+ENCODING 59005
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 12 12 0 0
+BBX 15 13 1 0
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
+0008
+0030
+00C0
+0108
+0030
+00E8
+0128
+0110
+4080
+8060
+8010
+8010
+7FFE
 ENDCHAR
-STARTCHAR cu
-ENCODING 62105
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni007E
+ENCODING 59006
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 0
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-07E0
-0660
-0600
+01
+06
+18
+21
+07
+1D
+25
+22
+10
+0C
+02
+02
+FC
 ENDCHAR
-STARTCHAR ci
-ENCODING 62106
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni007F
+ENCODING 59007
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
+0080
+0300
+0C00
+1080
+0300
+0E80
+1280
+1100
+0800
 0600
-0660
-07E0
+0100
+0100
+FFE0
 ENDCHAR
-STARTCHAR ca
-ENCODING 62107
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0080
+ENCODING 59008
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 18 1 -5
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-0E00
-1C00
-3800
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+C060
+7F80
+0000
+0000
+0500
+0500
 ENDCHAR
-STARTCHAR cE
-ENCODING 62108
+STARTCHAR uni0081
+ENCODING 59009
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 12 12 0 0
+BBX 15 17 1 -4
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-07C0
-0660
-07C0
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
+0000
+0000
+0500
+0500
 ENDCHAR
-STARTCHAR c
-ENCODING 62109
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni0082
+ENCODING 59010
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 17 0 -4
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0E00
-0300
-3FF0
-7FF8
-6318
-0300
+01
+06
+18
+21
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+00
+00
+50
+50
+ENDCHAR
+STARTCHAR uni0083
+ENCODING 59011
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 17 0 -4
+BITMAP
+0080
 0300
+0C00
+1080
 0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+0000
+0000
+2800
+2800
 ENDCHAR
-STARTCHAR co
-ENCODING 62110
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0084
+ENCODING 59012
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 18 1 -1
 BITMAP
-30C0
-7FE0
-6960
-0900
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
+0080
+0080
+0020
+00A0
+0088
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+8060
+7F80
 ENDCHAR
-STARTCHAR cWa
-ENCODING 62111
+STARTCHAR uni0085
+ENCODING 59013
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 12 14 0 -2
+BBX 15 17 1 0
 BITMAP
-6060
-7FE0
-FFF0
-C630
-0600
-7FE0
-FFF0
-C630
-0600
-0600
-0600
-0600
-1F80
-30C0
+0080
+0080
+0020
+00A0
+0088
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
 ENDCHAR
-STARTCHAR `he/h2e
-ENCODING 62112
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni0086
+ENCODING 59014
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 17 0 0
 BITMAP
-0C
-0C
+10
+10
+04
+14
+11
+06
+18
+21
+06
+18
+20
+20
+10
 0C
+02
+02
 FC
-CF
-03
-03
-03
-03
-03
-03
-03
 ENDCHAR
-STARTCHAR `hu/h2u
-ENCODING 62113
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0087
+ENCODING 59015
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 17 0 0
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-03F0
-0330
-0300
+0800
+0800
+0200
+0A00
+0880
 0300
+0C00
+1080
 0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
 ENDCHAR
-STARTCHAR `hi/h2i
-ENCODING 62114
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni0088
+ENCODING 59016
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -2
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
+0880
+0500
+0200
+0000
+0000
+0200
 0300
+0200
+0200
+0200
+0200
+0200
+4200
+8200
+8200
+8400
+7800
+ENDCHAR
+STARTCHAR uni0089
+ENCODING 59017
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 19 1 -4
+BITMAP
+0880
+0500
+0200
+0000
+0000
+0200
 0300
-0330
-03F0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+4380
+8200
+8200
+8400
+7800
 ENDCHAR
-STARTCHAR `ha/h2a
-ENCODING 62115
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni008A
+ENCODING 59018
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
 BITMAP
-0C
-0C
-0C
-FC
-CF
-03
-03
-03
-0E
-18
+88
+50
+20
+00
+00
+20
 30
+20
+20
+20
+20
+20
+20
+20
+C0
+ENDCHAR
+STARTCHAR uni008B
+ENCODING 59019
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
+BITMAP
+88
+50
+20
+00
+00
+20
 30
+20
+20
+20
+20
+20
+20
+20
+F0
 ENDCHAR
-STARTCHAR `hE/h2E
-ENCODING 62116
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni008C
+ENCODING 59020
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 16 1 -2
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
+02
+02
+00
+00
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
+ENDCHAR
+STARTCHAR uni008D
+ENCODING 59021
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 18 1 -4
+BITMAP
+0200
+0200
+0000
+0000
+0200
 0300
-03E0
-0330
-03E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+4380
+8200
+8200
+8400
+7800
 ENDCHAR
-STARTCHAR `h/h2
-ENCODING 62117
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni008E
+ENCODING 59022
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 14 0 0
 BITMAP
-0C
-0C
-0C
-3C
-6F
-C3
-C3
-03
-03
-03
-03
-03
+20
+20
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+C0
 ENDCHAR
-STARTCHAR `ho/h2o
-ENCODING 62118
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uni008F
+ENCODING 59023
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 14 0 0
 BITMAP
-07E0
-0F90
-18E0
-F800
-D800
-1800
-1F80
-0F80
-0180
-0180
-0180
-0180
+20
+20
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+F0
 ENDCHAR
-STARTCHAR hWe
-ENCODING 62120
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni0090
+ENCODING 59024
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 18 1 -2
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-03F0
-0358
-0370
-0300
-0300
-0300
+02
+02
+05
+05
+00
+00
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
 ENDCHAR
-STARTCHAR hWu/hW
-ENCODING 62121
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni0091
+ENCODING 59025
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 20 1 -4
 BITMAP
-0C00
-0C00
-0C00
-FC60
-CF60
-03F8
-0318
-0300
-0300
-0300
-0300
+0200
+0200
+0500
+0500
+0000
+0000
+0200
 0300
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+4380
+8200
+8200
+8400
+7800
 ENDCHAR
-STARTCHAR hWi
-ENCODING 62122
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uni0092
+ENCODING 59026
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 16 0 0
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0330
-0330
-03F0
-0318
-0318
-0300
-0300
+20
+20
+50
+50
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+C0
 ENDCHAR
-STARTCHAR hWa
-ENCODING 62123
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR uni0093
+ENCODING 59027
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 16 0 0
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
-0300
-0300
-0300
-0300
-0FC0
-1860
+20
+20
+50
+50
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+F0
 ENDCHAR
-STARTCHAR hWE
-ENCODING 62124
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 14 0 -2
+STARTCHAR uni0094
+ENCODING 59028
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 -3
 BITMAP
-0C00
-0C00
-0C00
-FC00
-CF00
-0300
-0300
-0300
-0300
-0300
-03E0
-0330
-0FE0
-1800
+1000
+1000
+0000
+0200
+0200
+4100
+8100
+8100
+8300
+7E80
+0380
 ENDCHAR
-STARTCHAR ne
-ENCODING 62128
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 5 12 0 0
+STARTCHAR uni0095
+ENCODING 59029
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 1 -5
 BITMAP
-C0
-C0
-C0
+1000
+1000
+0000
+0200
+0200
+4180
+8100
+8100
+8300
+7E80
+0380
+ENDCHAR
+STARTCHAR uni0096
+ENCODING 59030
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 0 -3
+BITMAP
+20
+20
+00
+00
+10
+08
+08
+08
 F0
-38
-30
-30
-30
 60
-60
-60
+90
 60
 ENDCHAR
-STARTCHAR nu
-ENCODING 62129
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni0097
+ENCODING 59031
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 0 -3
 BITMAP
-C0
-C0
-C0
-F0
-38
-30
-30
-3E
-66
-60
+10
+10
+00
+00
+10
+10
+10
+FC
 60
+90
 60
 ENDCHAR
-STARTCHAR ni
-ENCODING 62130
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni0098
+ENCODING 59032
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 1 -2
 BITMAP
-C0
-C0
-C0
+08
+08
+14
+14
+00
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uni0099
+ENCODING 59033
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 12 1 -4
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0200
+0200
+4180
+8100
+8100
+8200
+7C00
+ENDCHAR
+STARTCHAR uni009A
+ENCODING 59034
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -6
+BITMAP
+10
+08
+08
+08
 F0
-38
+00
+00
+28
+28
+10
+10
+ENDCHAR
+STARTCHAR uni009B
+ENCODING 59035
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 -6
+BITMAP
+10
+10
+10
+FC
+00
+00
+28
+28
+10
+10
+ENDCHAR
+STARTCHAR uni009C
+ENCODING 59036
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 11 1 0
+BITMAP
 30
+40
 30
+40
+00
+20
 30
+50
+90
+90
 60
-60
-66
-7E
 ENDCHAR
-STARTCHAR na
-ENCODING 62131
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uni009D
+ENCODING 59037
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
 BITMAP
-1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0400
-0C00
-0C00
-0C00
+18
+20
+18
+20
+00
+10
+30
+50
+90
+90
+70
+0C
 ENDCHAR
-STARTCHAR nE
-ENCODING 62132
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 6 12 0 0
+STARTCHAR uni009E
+ENCODING 59038
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 11 1 0
 BITMAP
-C0
-C0
-C0
-F0
-38
 30
+40
 30
+40
+00
+20
 30
-78
-64
-6C
-78
+50
+90
+90
+60
 ENDCHAR
-STARTCHAR n
-ENCODING 62133
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uni009F
+ENCODING 59039
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 0
 BITMAP
-FF
-FE
-C6
-0C
-1F
-03
-06
-0C
-0C
 18
+20
 18
+20
+00
+00
 30
-ENDCHAR
-STARTCHAR no
-ENCODING 62134
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
-BITMAP
-1FC0
-3F20
-6160
-C0C0
-E000
-7C00
-0E00
-0600
-0400
-0C00
-0C00
-0C00
+78
+8C
+04
 ENDCHAR
-STARTCHAR nWa
-ENCODING 62135
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 -2
+STARTCHAR uni00A0
+ENCODING 59040
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 10 1 0
 BITMAP
-1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0400
-0C00
-0C00
-3F00
-6180
+50
+50
+00
+00
+20
+30
+50
+90
+90
+60
 ENDCHAR
-STARTCHAR Ne
-ENCODING 62136
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni00A1
+ENCODING 59041
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 8 1 0
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-0300
-0600
-0600
-0600
-0600
+28
+28
+00
+00
+30
+78
+8C
+04
 ENDCHAR
-STARTCHAR Nu
-ENCODING 62137
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00A2
+ENCODING 59042
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 8 0 -3
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-03E0
-0660
-0600
-0600
-0600
+04
+0A
+0A
+0E
+12
+2A
+94
+78
 ENDCHAR
-STARTCHAR Ni
-ENCODING 62138
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00A3
+ENCODING 59043
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 8 1 -4
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-0300
-0600
-0600
-0660
-07E0
+0400
+0A00
+0A00
+0780
+1200
+2A00
+9400
+7800
 ENDCHAR
-STARTCHAR Na
-ENCODING 62139
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 0 0
+STARTCHAR uni00A4
+ENCODING 59044
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 0 -3
 BITMAP
-30C0
-7FE0
-4620
-1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0C00
-0C00
+0A
+0A
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
 ENDCHAR
-STARTCHAR NE
-ENCODING 62140
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uni00A5
+ENCODING 59045
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 -4
 BITMAP
-6180
-FFC0
-8C40
-0C00
-0F00
-0380
-0300
-0300
-0780
-0640
-06C0
+0A00
+0A00
+0000
+0000
+0400
+0A00
+0A00
 0780
+0200
+0200
+8400
+7800
 ENDCHAR
-STARTCHAR N
-ENCODING 62141
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 0
+STARTCHAR uni00A6
+ENCODING 59046
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 8 0 -2
 BITMAP
-6180
-FFC0
-8C40
-3F80
-7F00
-6300
-0600
+0078
+0080
+1080
+2060
+6010
+A010
+1060
 0F80
-0180
-0300
-0600
-0600
-0600
 ENDCHAR
-STARTCHAR No
-ENCODING 62142
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 0 0
+STARTCHAR uni00A7
+ENCODING 59047
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 6 1 -5
 BITMAP
-3180
-7FC0
-4440
-1FC0
-3F20
-6160
-C0C0
-E000
-7C00
-0E00
-0600
-0C00
-0C00
+1078
+2080
+6060
+A010
+1060
+0F80
 ENDCHAR
-STARTCHAR NWa
-ENCODING 62143
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 15 0 -2
+STARTCHAR uni00A8
+ENCODING 59048
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 -2
 BITMAP
-30C0
-7FE0
-4620
-1F00
-3F80
-6180
-C000
-E000
-7C00
-0E00
-0600
-0C00
-0C00
-3F00
-6180
+4400
+2800
+1000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
 ENDCHAR
-STARTCHAR e/a
-ENCODING 62144
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni00A9
+ENCODING 59049
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 -5
 BITMAP
-60
-60
-60
-78
-18
-38
-3C
-6E
-E6
-C6
-C6
-C6
+2200
+1400
+0800
+0000
+0000
+41E0
+8200
+8180
+8040
+4180
+3E00
 ENDCHAR
-STARTCHAR u/U
-ENCODING 62145
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00AA
+ENCODING 59050
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 0
 BITMAP
-6000
-6000
-6000
-7800
-1800
-3800
-3C00
-6E00
-E7E0
-C660
-C600
-C600
+44
+28
+10
+00
+00
+10
+08
+08
+08
+F0
 ENDCHAR
-STARTCHAR i
-ENCODING 62146
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00AB
+ENCODING 59051
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 9 0 0
 BITMAP
-6000
-6000
-6000
-7800
-1800
-3800
-3C00
-6E00
-E600
-C600
-C660
-C7E0
+44
+28
+10
+00
+00
+10
+10
+10
+FC
 ENDCHAR
-STARTCHAR A
-ENCODING 62147
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni00AC
+ENCODING 59052
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -7
 BITMAP
-60
-60
-60
-78
-18
-3C
-6E
-C6
-C6
-C6
-06
-06
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+0000
+2800
+2800
+1000
+1000
 ENDCHAR
-STARTCHAR E
-ENCODING 62148
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00AD
+ENCODING 59053
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 1 -10
 BITMAP
-6000
-6000
-6000
-7800
-1800
-3800
-3C00
-6E00
-E600
-C7C0
-C660
-C7C0
+41E0
+8200
+8180
+8040
+4180
+3E00
+0000
+2800
+2800
+1000
+1000
 ENDCHAR
-STARTCHAR I
-ENCODING 62149
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni00AE
+ENCODING 59054
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 0 -5
 BITMAP
-C0
-C0
-E0
-60
-30
-38
-7C
-EE
-C6
-C6
-C6
-C6
+10
+08
+08
+08
+F0
+00
+50
+50
+20
+20
 ENDCHAR
-STARTCHAR o/O
-ENCODING 62150
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uni00AF
+ENCODING 59055
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 9 0 -5
 BITMAP
-60
-60
-60
-78
-18
-3C
-6E
-C6
-C6
-C6
-C0
-C0
+10
+10
+10
+FC
+00
+28
+28
+10
+10
 ENDCHAR
-STARTCHAR e3
-ENCODING 62151
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 13 0 0
+STARTCHAR uni00B0
+ENCODING 59056
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 0 0
 BITMAP
-6300
-7F00
-D980
-1800
-1E00
-0600
-0E00
-0F00
-1B80
-3980
-3180
-3180
-3180
+10
+08
+08
+08
+F0
 ENDCHAR
-STARTCHAR ke
-ENCODING 62152
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni00B1
+ENCODING 59057
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 4 0 0
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-3180
-3180
-3180
+10
+10
+10
+FC
 ENDCHAR
-STARTCHAR ku
-ENCODING 62153
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni00B2
+ENCODING 59058
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-31F8
-3198
-3180
-3180
-3180
+1180
+2A00
+1180
+2A00
+4000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
 ENDCHAR
-STARTCHAR ki
-ENCODING 62154
+STARTCHAR uni00B3
+ENCODING 59059
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 13 11 0 0
+BBX 15 14 1 -5
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-3180
-3198
-31F8
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8088
+4308
+3C00
 ENDCHAR
-STARTCHAR ka
-ENCODING 62155
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni00B4
+ENCODING 59060
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 14 1 -5
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-0180
-0180
-0180
+001000
+001000
+002800
+002800
+000000
+000000
+011200
+011200
+40FF80
+808000
+808000
+808800
+430800
+3C0000
 ENDCHAR
-STARTCHAR kE
-ENCODING 62156
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni00B5
+ENCODING 59061
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 0 -4
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-31F0
-3198
-31F0
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFE0
+0000
+0000
+0080
+0080
 ENDCHAR
-STARTCHAR k
-ENCODING 62157
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni00B6
+ENCODING 59062
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 13 0 -4
 BITMAP
-C000
-CE00
-DF00
-F180
-6180
-7180
-3180
-3180
-3180
-3180
-3180
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFF8
+0000
+0000
+0080
+0080
 ENDCHAR
-STARTCHAR ko
-ENCODING 62158
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uni00B7
+ENCODING 59063
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 12 1 -5
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-3000
-3000
-3000
+002000
+002000
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808400
+430400
+3C0000
 ENDCHAR
-STARTCHAR kWe
-ENCODING 62160
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni00B8
+ENCODING 59064
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 12 1 -5
 BITMAP
-C000
-CC00
-FE00
-F300
-3300
-33F0
-3358
-3370
-3300
-3300
-3300
+002000
+002000
+000000
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808400
+430400
+3C0000
 ENDCHAR
-STARTCHAR kWu/kW
-ENCODING 62161
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni00B9
+ENCODING 59065
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 0 -4
 BITMAP
-C000
-CC60
-FE60
-F3F8
-3318
-3300
-3300
-3300
-3300
-3300
-3300
+0200
+0200
+0000
+0070
+2188
+2208
+FFF0
+0000
+0000
+0040
+0040
 ENDCHAR
-STARTCHAR kWi
-ENCODING 62162
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uni00BA
+ENCODING 59066
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -4
 BITMAP
-C000
-CC00
-FE00
-F300
-3330
-3330
-33F0
-3318
-3318
-3300
-3300
+0400
+0400
+0000
+00E0
+0310
+2410
+DFF8
+0000
+0000
+0080
+0080
 ENDCHAR
-STARTCHAR kWa
-ENCODING 62163
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 -2
+STARTCHAR uni00BB
+ENCODING 59067
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -7
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-0180
-0180
-0180
-07E0
-0C30
+2000
+2000
+0000
+0000
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8800
+8800
+8000
+4180
+3E00
 ENDCHAR
-STARTCHAR kWE
-ENCODING 62164
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 13 0 -2
+STARTCHAR uni00BC
+ENCODING 59068
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 15 1 -6
 BITMAP
-C000
-CE00
-FF00
-F180
-3180
-3180
-3180
-3180
-0180
-01F0
-0198
-07F0
-0C00
+1000
+1000
+0000
+0000
+3800
+6C00
+1000
+3800
+4780
+4000
+8800
+8800
+8000
+4180
+3E00
 ENDCHAR
-STARTCHAR Ke
-ENCODING 62168
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00BD
+ENCODING 59069
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 13 0 -4
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C60
-0C60
-0C60
+10
+10
+00
+00
+1C
+20
+40
+22
+FC
+00
+00
+10
+10
 ENDCHAR
-STARTCHAR Ku
-ENCODING 62169
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 12 0 0
+STARTCHAR uni00BE
+ENCODING 59070
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 -4
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C7E
-0C66
-0C60
-0C60
-0C60
+08
+08
+00
+00
+1C
+36
+08
+1C
+E3
+00
+00
+08
+08
 ENDCHAR
-STARTCHAR Ki
-ENCODING 62170
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 12 0 0
+STARTCHAR uni06C1
+ENCODING 59073
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C60
-0C66
-0C7E
+20
+30
+50
+90
+90
+60
 ENDCHAR
-STARTCHAR Ka
-ENCODING 62171
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni06C2
+ENCODING 59074
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 11 1 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0060
-0060
-0060
+30
+40
+30
+40
+00
+20
+30
+50
+90
+90
+60
 ENDCHAR
-STARTCHAR KE
-ENCODING 62172
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 12 0 0
+STARTCHAR uni06C3
+ENCODING 59075
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 10 1 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C7C
-0C66
-0C7C
+50
+50
+00
+00
+20
+30
+50
+90
+90
+60
 ENDCHAR
-STARTCHAR K
-ENCODING 62173
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniFB5E
+ENCODING 59077
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 6 0 -1
 BITMAP
-C300
-7E00
-1800
-1DC0
-1FE0
-0630
-0730
-0330
-0330
-0330
-0330
-0330
+0008
+4008
+8008
+8008
+C030
+7FC0
 ENDCHAR
-STARTCHAR Ko
-ENCODING 62174
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniFB5F
+ENCODING 59078
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 5 1 -1
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C60
-0C60
-0C60
-0C00
-0C00
-0C00
+4000
+8010
+8010
+C07E
+7F80
 ENDCHAR
-STARTCHAR KWe
-ENCODING 62176
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 0 0
+STARTCHAR uniFB60
+ENCODING 59079
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 0 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C60
-0C7E
-0C6B
-0C6E
-0C60
-0C60
-0C60
+10
+08
+08
+08
+F0
 ENDCHAR
-STARTCHAR KWu/KW
-ENCODING 62177
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 0 0
+STARTCHAR uniFB61
+ENCODING 59080
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 4 0 0
 BITMAP
-C300
-7E00
-180C
-1B8C
-1FFF
-0C63
-0C60
-0C60
-0C60
-0C60
-0C60
-0C60
+10
+10
+10
+FC
 ENDCHAR
-STARTCHAR KWi
-ENCODING 62178
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 12 0 0
+STARTCHAR uniFED5
+ENCODING 59081
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 1 -3
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0C66
-0C66
-0C7E
-0C63
-0C63
-0C60
-0C60
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
 ENDCHAR
-STARTCHAR KWa
-ENCODING 62179
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 14 0 -2
+STARTCHAR uniFED6
+ENCODING 59082
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 10 1 -5
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0CE0
-0C60
-0C60
-0C60
-0060
-0060
-0060
-01F8
-030C
+0300
+0580
+0480
+0480
+43E0
+8080
+8080
+8100
+4200
+3C00
 ENDCHAR
-STARTCHAR KWE
-ENCODING 62180
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 14 0 -2
+STARTCHAR uniFED7
+ENCODING 59083
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 7 0 0
 BITMAP
-C300
-7E00
-1800
-1B80
-1FC0
-0CE0
-0C60
-0C60
-0C60
-0060
-007C
-0066
-01FC
-0300
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uniFED8
+ENCODING 59084
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 6 0 0
+BITMAP
+18
+24
+24
+18
+18
+E7
 ENDCHAR
-STARTCHAR we
-ENCODING 62184
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 8 0 1
+STARTCHAR uni00D0
+ENCODING 59088
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-CCC0
-EDC0
-7F00
+11
+0A
+04
+00
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
 ENDCHAR
-STARTCHAR wu
-ENCODING 62185
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 9 0 -1
+STARTCHAR uni00D1
+ENCODING 59089
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 16 1 -1
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-CCE0
-EDC6
-7FFC
-000C
+0880
+0500
+0200
+0000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
 ENDCHAR
-STARTCHAR wi
-ENCODING 62186
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00D2
+ENCODING 59090
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 1 0
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
-7F80
-0C00
-0C00
-1C00
-18C0
-1FC0
+04
+04
+00
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
 ENDCHAR
-STARTCHAR wa
-ENCODING 62187
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00D3
+ENCODING 59091
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 -1
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
-7F80
-0C00
-0C00
-1C00
-1800
-1800
+0200
+0200
+0000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
 ENDCHAR
-STARTCHAR wE
-ENCODING 62188
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00D4
+ENCODING 59092
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 16 1 0
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
-7F80
-0C00
-0C00
-1E00
-1980
-1F00
+04
+04
+0A
+0A
+00
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
 ENDCHAR
-STARTCHAR w
-ENCODING 62189
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 15 8 0 1
+STARTCHAR uni00D5
+ENCODING 59093
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -1
 BITMAP
-3FC0
-76E0
-C660
-C67E
-CC66
-CCC2
-EDC0
-7F00
+0200
+0200
+0500
+0500
+0000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
 ENDCHAR
-STARTCHAR wo
-ENCODING 62190
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uni00F0
+ENCODING 59120
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 19 14 1 -4
 BITMAP
-3FC0
-76E0
-C660
-C660
-CC60
-EEC0
-7F80
-0C00
-1800
-3000
-6000
-6000
+028000
+028000
+02C000
+028000
+028000
+028000
+028840
+028460
+828420
+828420
+827820
+440040
+3858C0
+005780
 ENDCHAR
-STARTCHAR `e/e2
-ENCODING 62192
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uniE6F4
+ENCODING 59124
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 10 2 0
 BITMAP
-1E
-63
-C3
-C3
-C3
-C3
-C3
-C3
-C3
-7F
+B9
+EE
+E4
 60
+60
+20
+30
+10
+10
+10
 ENDCHAR
-STARTCHAR `u/u2
-ENCODING 62193
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uni06F7
+ENCODING 59127
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 8 1 1
 BITMAP
-1E00
-6300
-C300
-C300
-C300
-C300
-C3F0
-C330
-C300
-7F00
-6000
+03
+0E
+38
+60
+E0
+78
+1E
+07
 ENDCHAR
-STARTCHAR `i/i2
-ENCODING 62194
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uniE900
+ENCODING 59648
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 13 0 -2
 BITMAP
-3E00
-6300
-C300
-C300
-C300
-7F80
-0180
-0180
-0300
-0330
-03F0
+31FE
+6840
+4440
+4CC0
+29C0
+7E40
+C040
+8040
+8440
+8E40
+7E40
+0400
+0200
 ENDCHAR
-STARTCHAR `a/A2
-ENCODING 62195
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uniE901
+ENCODING 59649
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 0
 BITMAP
-3E00
-6300
-C300
-C300
-C300
-7F80
-0180
-0180
-0180
-0300
-0300
+FFF8
+0100
+0100
+7F00
+3100
+0900
+0500
+6500
+7900
+1100
+0900
 ENDCHAR
-STARTCHAR `E/E2
-ENCODING 62196
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uniE902
+ENCODING 59650
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 0 0
 BITMAP
-3E00
-6300
-C300
-C300
-C300
-7F80
-0180
-0180
-03E0
-0330
-03E0
+FFFE
+0040
+0040
+0040
+FFC0
+1040
+2040
+2040
+2040
+1040
+0840
 ENDCHAR
-STARTCHAR `I/I2
-ENCODING 62197
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 0
+STARTCHAR uniE903
+ENCODING 59651
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 11 0 0
 BITMAP
-18
-18
-18
-7E
-E3
-C3
-C3
-C3
-C3
-C3
-C3
-7F
-60
+FFF0
+0200
+0200
+3A00
+4600
+0600
+0A00
+1200
+2200
+0200
+0200
 ENDCHAR
-STARTCHAR `o/o2
-ENCODING 62198
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE904
+ENCODING 59652
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 12 0 -1
 BITMAP
-3C
-66
-C3
-C3
-C3
-E7
-7E
-3C
-70
-C0
-C0
-C0
+FFFE
+1840
+2440
+2440
+1840
+6740
+00C0
+7C40
+18C0
+10C0
+1140
+0E00
 ENDCHAR
-STARTCHAR ze
-ENCODING 62200
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uniE905
+ENCODING 59653
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 0 0
 BITMAP
-C6
-C6
-C6
-C6
-C6
-FE
-FE
-C6
-C6
-C6
-C6
-C6
+FFFE
+1840
+2440
+2440
+1840
+6740
+00C0
+01C0
+0240
+0440
+0040
 ENDCHAR
-STARTCHAR zu
-ENCODING 62201
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE906
+ENCODING 59654
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 0 0
 BITMAP
-C600
-C600
-C600
-C600
-C600
-FE00
-FE00
-C7E0
-C660
-C660
-C600
-C600
+FFFE
+1840
+2440
+2440
+1840
+6740
+08C0
+08C0
+08C0
+0740
+0040
 ENDCHAR
-STARTCHAR zi
-ENCODING 62202
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE907
+ENCODING 59655
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 11 0 0
 BITMAP
-C600
-C600
-C600
-C600
-C600
-FE00
-FE00
-C600
-C600
-C600
-C660
-C7E0
+FFFC
+0400
+0400
+7400
+8DC0
+8620
+8C20
+7420
+1420
+6440
+8400
 ENDCHAR
-STARTCHAR za
-ENCODING 62203
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uniE908
+ENCODING 59656
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 11 0 0
 BITMAP
-C6
-C6
-C6
-C6
-FE
-FE
-C6
-C6
-C6
-06
-06
-06
+FFFFC0
+000800
+000800
+000800
+8FF800
+840800
+820800
+421800
+232800
+1E4800
+008800
 ENDCHAR
-STARTCHAR zE
-ENCODING 62204
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE909
+ENCODING 59657
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 11 0 0
 BITMAP
-C600
-C600
-C600
-C600
-C600
-FE00
-FE00
-C600
-C600
-C7C0
-C660
-C7C0
+FFFFC0
+000800
+000800
+000800
+8FF800
+840800
+82C800
+429800
+232800
+1E4800
+008800
 ENDCHAR
-STARTCHAR z
-ENCODING 62205
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE90A
+ENCODING 59658
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 0 0
 BITMAP
-70C0
-D8C0
-D8C0
-18C0
-18C0
-1FC0
-1FC0
-18C0
-18C0
-18C0
-18C0
-18C0
+FFFE
+4200
+4200
+42C0
+4320
+4210
+3E10
+0A10
+1210
+2220
+4200
 ENDCHAR
-STARTCHAR zo
-ENCODING 62206
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uniE90B
+ENCODING 59659
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 0 0
 BITMAP
-C6
-C6
-C6
-C6
-FE
-FE
-C6
-C6
-C6
-C0
-C0
-C0
+FFFE
+4200
+4200
+42C0
+4320
+4210
+3E10
+8A10
+9210
+2220
+4200
 ENDCHAR
-STARTCHAR zWa
-ENCODING 62207
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 14 0 -2
+STARTCHAR uniE90C
+ENCODING 59660
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 0
 BITMAP
-C600
-C600
-C600
-C600
-FE00
-FE00
-C600
-C600
-C600
-0600
-0600
-0600
-1F80
-30C0
+FFE0
+4200
+4200
+4200
+4200
+4200
+3E00
+0A00
+1200
+2200
+4200
 ENDCHAR
-STARTCHAR Ze
-ENCODING 62208
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE90D
+ENCODING 59661
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 12 0 -1
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-1980
-1980
-1980
-1980
-1980
+FFFC
+1040
+1040
+1040
+B0C0
+FFC0
+40C0
+4140
+2240
+2440
+1040
+0800
 ENDCHAR
-STARTCHAR Zu
-ENCODING 62209
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uniE90E
+ENCODING 59662
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 12 0 -1
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-19F8
-1998
-1998
-1980
-1980
+FFF0
+0200
+0200
+0200
+2700
+3C80
+1080
+1180
+0800
+0400
+0200
+0100
 ENDCHAR
-STARTCHAR Zi
-ENCODING 62210
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uniE90F
+ENCODING 59663
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 11 0 0
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-1980
-1980
-1980
-1998
-19F8
+FFFC
+0400
+0400
+0400
+2D80
+1F60
+1210
+11C8
+0800
+0400
+0200
 ENDCHAR
-STARTCHAR Za
-ENCODING 62211
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE915
+ENCODING 59669
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 0 0
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1F80
-1F80
-1980
-1980
-1980
-0180
-0180
-0180
+FFC0
+0400
+0400
+7400
+8DC0
+8600
+8C00
+7400
+0400
+0400
+0400
 ENDCHAR
-STARTCHAR ZE
-ENCODING 62212
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 12 0 0
+STARTCHAR uniE916
+ENCODING 59670
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 0 0
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1980
-1F80
-1F80
-1980
-1980
-19F0
-1998
-19F0
+FFC0
+1000
+1000
+1380
+B640
+E440
+44C0
+4380
+2000
+1040
+0F80
 ENDCHAR
-STARTCHAR Z
-ENCODING 62213
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 13 0 0
+STARTCHAR uniE917
+ENCODING 59671
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 9 0 2
 BITMAP
-C300
-7E00
-1800
-3870
-6CD8
-6CD8
-0CC0
-0FC0
-0FC0
-0CC0
-0CC0
-0CC0
-0CC0
+FE
+20
+20
+20
+20
+20
+A0
+60
+20
 ENDCHAR
-STARTCHAR Zo
-ENCODING 62214
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE918
+ENCODING 59672
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 8 0 3
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1F80
-1F80
-1980
-1980
-1980
-1800
-1800
-1800
+FF
+40
+40
+3C
+30
+20
+21
+1E
 ENDCHAR
-STARTCHAR ZWa
-ENCODING 62215
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 14 0 -2
+STARTCHAR uniE919
+ENCODING 59673
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 10 0 1
 BITMAP
-70E0
-D9B0
-D9B0
-1980
-1F80
-1F80
-1980
-1980
-1980
-0180
-0180
-0180
-07E0
-0C30
+FFF8
+0200
+3E00
+2000
+2020
+1E20
+8100
+8100
+4100
+3E00
 ENDCHAR
-STARTCHAR ye
-ENCODING 62216
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uniE91A
+ENCODING 59674
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 9 0 2
 BITMAP
-38
-6C
-C6
-C6
-C6
-C6
-EC
-78
-30
-30
-30
-30
+FF
+00
+00
+00
+7F
+08
+10
+11
+0E
 ENDCHAR
-STARTCHAR yu
-ENCODING 62217
+STARTCHAR uniE91B
+ENCODING 59675
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 8 12 0 0
+BBX 16 12 0 -1
 BITMAP
-38
-6C
-C6
-C6
-C6
-C6
-EC
-78
-30
-3F
-33
-30
+FFFF
+0020
+0020
+3870
+40C8
+4088
+3E48
+1838
+1018
+1018
+1864
+0F84
 ENDCHAR
-STARTCHAR yi
-ENCODING 62218
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE91C
+ENCODING 59676
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 10 0 1
 BITMAP
-3800
-6C00
-C600
-C600
-C600
-C600
-EC00
-7800
-3300
-3FC0
-30C0
-3000
+FF80
+0000
+0000
+0000
+8F80
+8400
+4200
+4200
+2200
+1C00
 ENDCHAR
-STARTCHAR ya
-ENCODING 62219
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uniE91D
+ENCODING 59677
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 12 0 -1
 BITMAP
-38
-6C
-C6
-C6
-C6
-CC
-F8
-70
-38
-0C
-38
-70
+FFC0
+0400
+7C00
+4000
+4000
+3FC0
+0400
+0400
+3C00
+3C00
+0400
+0200
 ENDCHAR
-STARTCHAR yE
-ENCODING 62220
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
-BITMAP
-3800
-6C00
-C600
-C600
-C600
-C600
-EC00
-7800
-3780
-3CC0
-3780
-3000
+STARTCHAR uniE91E
+ENCODING 59678
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 8 0 3
+BITMAP
+FF
+00
+18
+24
+07
+84
+4C
+38
 ENDCHAR
-STARTCHAR y
-ENCODING 62221
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE91F
+ENCODING 59679
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 11 0 0
 BITMAP
-0F00
-1980
-3180
-3180
-3180
-1B00
-1E60
-0E60
-07C0
-7C00
-E000
+FFF0
+0200
+0200
+3E00
+6000
 C000
+8000
+8000
+8100
+4300
+3E00
 ENDCHAR
-STARTCHAR yo
-ENCODING 62222
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE920
+ENCODING 59680
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 11 0 0
 BITMAP
-3800
-6C00
-C600
-C7E0
-C660
-C600
-EC00
-7800
-3000
-3000
-3000
-3000
+FFF0
+0200
+0200
+1E00
+3100
+6080
+4080
+4080
+4080
+2180
+1F00
 ENDCHAR
-STARTCHAR de
-ENCODING 62224
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE921
+ENCODING 59681
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 10 0 1
 BITMAP
-1C00
+FFF0
+0200
 3E00
-6200
-6200
-6600
-7C00
-3000
-1800
-1800
-0C00
-FFC0
-C0C0
+2000
+1000
+0E00
+8100
+8080
+4080
+3F00
 ENDCHAR
-STARTCHAR du
-ENCODING 62225
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE922
+ENCODING 59682
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 0
 BITMAP
-1C00
-3E00
-6200
-6600
-7C00
-3000
-1800
-7F00
-C300
-C3F0
-0630
-0600
+FFE0
+0200
+0200
+7E00
+C000
+8000
+8600
+8D00
+4900
+2900
+1E00
 ENDCHAR
-STARTCHAR di
-ENCODING 62226
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE923
+ENCODING 59683
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 9 0 2
 BITMAP
-1C00
-3E00
-6200
-6600
-7C00
-3000
+FF80
+4400
+4400
+4400
+4400
+4400
+4400
+2400
 1800
-7F00
-C300
-C300
-0660
-07E0
 ENDCHAR
-STARTCHAR da
-ENCODING 62227
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE924
+ENCODING 59684
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 12 0 -1
 BITMAP
-1C
-3E
-62
+FE
+00
+00
+00
+7E
+C0
+80
+80
+40
+40
+20
+10
+ENDCHAR
+STARTCHAR uniE925
+ENCODING 59685
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 9 0 2
+BITMAP
 66
-7C
+D0
+88
+78
 30
-18
-FF
-C3
-C3
-03
-03
+E0
+40
+20
+1E
 ENDCHAR
-STARTCHAR dE
-ENCODING 62228
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE926
+ENCODING 59686
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 0
 BITMAP
-1C00
-3E00
-6200
-6200
-6600
+FFE0
+0400
+0400
 7C00
-3000
-1800
-1800
-0FC0
-FE60
-C3C0
+8000
+8000
+8600
+4600
+3E00
+0200
+0100
 ENDCHAR
-STARTCHAR d
-ENCODING 62229
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE927
+ENCODING 59687
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 8 0 3
 BITMAP
-1C00
-3E00
-63E0
-6260
-6600
-7C00
-3000
-1800
-1800
-0C00
-FFC0
-C0C0
+46
+80
+80
+78
+60
+40
+42
+3C
 ENDCHAR
-STARTCHAR do
-ENCODING 62230
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uniE928
+ENCODING 59688
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 8 0 3
 BITMAP
-0E00
-1F00
-3100
-3300
-3E00
-1C00
-3F80
-6180
-C000
-C000
-C000
-C000
+FE
+00
+00
+00
+FE
+C0
+40
+20
 ENDCHAR
-STARTCHAR dWa
-ENCODING 62231
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR uniE929
+ENCODING 59689
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 0 0
 BITMAP
-1C00
-3E00
-6200
-6600
-7C00
-3000
-1800
-FF00
-C300
-C300
-0300
-0300
-0FC0
-1860
+FE
+00
+00
+00
+FE
+C0
+40
+20
+00
+08
+08
 ENDCHAR
-STARTCHAR De
-ENCODING 62232
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE92A
+ENCODING 59690
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 8 0 3
 BITMAP
-10
-10
+FC
+40
+40
+40
+40
+40
+44
 38
-7C
-C4
-CC
-F8
-60
-30
-18
-FF
-C3
 ENDCHAR
-STARTCHAR Du
-ENCODING 62233
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE92B
+ENCODING 59691
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 0
 BITMAP
-0800
-0800
-1C00
-3E00
-6200
-6600
-7C00
-3000
-7F00
-C3F0
-C630
-0600
+FFE0
+4200
+4200
+42E0
+4300
+4600
+3A00
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR Di
-ENCODING 62234
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE92C
+ENCODING 59692
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 8 0 3
 BITMAP
-0800
-0800
-1C00
-3E00
-6200
-6600
-7C00
-3000
-7F00
-C300
-C660
-07E0
+FC
+00
+00
+78
+E4
+94
+8C
+78
 ENDCHAR
-STARTCHAR Da
-ENCODING 62235
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE92D
+ENCODING 59693
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 8 0 3
 BITMAP
-08
-08
-1C
-3E
-62
-66
-7C
-30
-FF
-C3
-03
-03
+C6
+A0
+90
+70
+10
+FE
+60
+20
 ENDCHAR
-STARTCHAR DE
-ENCODING 62236
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE92E
+ENCODING 59694
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 8 0 3
 BITMAP
-1000
-1000
-3800
-7C00
-C400
-CC00
-F800
-6000
-3000
-1BC0
-FE60
-C3C0
+FE
+20
+20
+20
+20
+FE
+60
+20
 ENDCHAR
-STARTCHAR D
-ENCODING 62237
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE92F
+ENCODING 59695
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 8 0 3
 BITMAP
-1000
-1000
-3800
-7C00
-C7C0
-CCC0
-F800
-6000
-3000
-1800
-FF00
-C300
+FE
+10
+10
+20
+C0
+80
+42
+3C
 ENDCHAR
-STARTCHAR Do
-ENCODING 62238
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE930
+ENCODING 59696
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 12 0 -1
 BITMAP
+FFE0
 0400
 0400
-0E00
-1F00
-3100
-3300
-3E00
-1FC0
-30C0
-6000
-6000
-6000
+0400
+2C00
+3800
+1000
+1000
+0800
+0800
+0400
+0200
 ENDCHAR
-STARTCHAR je
-ENCODING 62240
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 0
+STARTCHAR uniE931
+ENCODING 59697
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 12 0 -1
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3100
-3300
-1E00
-1800
-1C00
-0C00
-7F80
-6180
+FFE0
+0400
+0400
+0400
+2C00
+3800
+1000
+1000
+0800
+2800
+2400
+0200
 ENDCHAR
-STARTCHAR ju
-ENCODING 62241
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 13 0 0
+STARTCHAR uniE932
+ENCODING 59698
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 10 11 0 0
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-0C00
-3F80
-6180
-61F8
-0318
-0300
+FFC0
+0000
+0000
+0000
+78C0
+8500
+8200
+8000
+4000
+4000
+2000
 ENDCHAR
-STARTCHAR ji
-ENCODING 62242
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 0
+STARTCHAR uniE933
+ENCODING 59699
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 0
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-0C00
-3F80
-6180
-6180
-0330
-03F0
+FFF8
+0000
+0000
+0000
+7860
+C490
+8108
+8208
+8308
+4498
+3870
 ENDCHAR
-STARTCHAR ja
-ENCODING 62243
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 0
+STARTCHAR uniE934
+ENCODING 59700
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 15 0 -4
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-0C00
-7F80
-6180
-6180
-0180
-0180
+FFF8
+0000
+0000
+0000
+7860
+C490
+8108
+8208
+8308
+4498
+3870
+0000
+0000
+0200
+0200
 ENDCHAR
-STARTCHAR jE
-ENCODING 62244
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 0
+STARTCHAR uniE935
+ENCODING 59701
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 8 0 3
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3100
-3300
-1E00
-1800
-1C00
-0FE0
-7F30
-61E0
+FC
+00
+00
+78
+84
+84
+84
+78
 ENDCHAR
-STARTCHAR j
-ENCODING 62245
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 0
+STARTCHAR uniE936
+ENCODING 59702
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 0 0
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-31F0
-3330
+FF80
+1400
+2200
+2200
+2200
 1E00
-1800
-1C00
-0C00
-7F80
-6180
+2200
+5C00
+3800
+0400
+0400
 ENDCHAR
-STARTCHAR jo
-ENCODING 62246
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 0
+STARTCHAR uniE937
+ENCODING 59703
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 8 0 3
 BITMAP
-C0C0
-7F80
-0C00
-1E00
-3300
-3300
-1E00
-1FC0
-30C0
-6000
-6000
-6000
-6000
+FC
+60
+50
+50
+48
+48
+24
+1C
 ENDCHAR
-STARTCHAR ge
-ENCODING 62248
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uniE938
+ENCODING 59704
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 0 -1
 BITMAP
-7C
-C6
-C6
-06
-06
-06
-0C
-0C
-0C
-0C
-0C
+FF
+10
+10
+10
+B1
+FE
+40
+40
+20
+20
+10
+08
 ENDCHAR
-STARTCHAR gu
-ENCODING 62249
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uniE939
+ENCODING 59705
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 0 -3
 BITMAP
-7C00
-C600
-C600
-0600
-0600
+FFE0
+0200
+0200
+1E00
+2000
+1000
+1E00
+3100
+2100
+2200
+2000
+1000
+0800
 0600
-0FE0
-0C60
-0C00
-0C00
-0C00
 ENDCHAR
-STARTCHAR gi
-ENCODING 62250
-SWIDTH 960 0
-DWIDTH 16 0
+STARTCHAR uniE940
+ENCODING 59712
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 10 11 0 0
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-0600
-0C00
-0C00
-0C00
-0CC0
-0FC0
+FFC0
+0400
+7580
+8E40
+8C40
+7480
+8F80
+8C40
+7440
+0480
+0400
 ENDCHAR
-STARTCHAR ga
-ENCODING 62251
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uniE941
+ENCODING 59713
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 12 0 -1
 BITMAP
-78
-FE
-C6
-06
-06
-06
-0C
-1C
-78
-E0
-C0
+FFFE
+0040
+0040
+0040
+FFDC
+3062
+2042
+2042
+2042
+1044
+0840
+0400
 ENDCHAR
-STARTCHAR gE
-ENCODING 62252
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR uniE942
+ENCODING 59714
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 16 0 -5
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-0600
-0C00
-0C00
-0F80
-0CC0
-0F80
+FFFC
+0100
+3F00
+2000
+2020
+1E20
+8100
+8100
+4100
+3E00
+0400
+3500
+4E80
+4C80
+3480
+0400
 ENDCHAR
-STARTCHAR g
-ENCODING 62253
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uniE943
+ENCODING 59715
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 16 0 -5
 BITMAP
-7F00
-CD80
-7980
-0180
-0180
-0300
-0300
-0300
-0300
-0300
-0300
+FFFC
+0100
+3F00
+2000
+2020
+1E20
+8100
+8100
+4100
+3F00
+6100
+CD00
+9300
+5300
+4D00
+2100
 ENDCHAR
-STARTCHAR go
-ENCODING 62254
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
+STARTCHAR uniE944
+ENCODING 59716
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 16 0 -5
 BITMAP
-10
-10
-10
-7C
-C6
-C6
-06
-04
-0C
-0C
-0C
-0C
+FFFC
+0100
+3F00
+2000
+2020
+1E20
+8100
+8100
+4100
+3F00
+1100
+1100
+3100
+3100
+1100
+0100
 ENDCHAR
-STARTCHAR gWe
-ENCODING 62256
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uniE945
+ENCODING 59717
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 16 0 -5
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-07E0
-0EB0
-0CE0
-0C00
-0C00
-0C00
+FFFC
+0200
+3E00
+2000
+2020
+1E20
+8100
+8100
+4100
+7E00
+4200
+4200
+3A00
+2200
+1E00
+0200
 ENDCHAR
-STARTCHAR gWu/gW
-ENCODING 62257
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uniE946
+ENCODING 59718
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 11 0 0
 BITMAP
-7C00
-C6C0
-C6C0
-07F0
-0630
-0600
-0E00
-0C00
-0C00
-0C00
-0C00
+FFFC
+0040
+1840
+47C0
+2440
+1840
+0040
+47C0
+4440
+2240
+1C40
 ENDCHAR
-STARTCHAR gWi
-ENCODING 62258
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uniE947
+ENCODING 59719
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 13 0 -2
 BITMAP
-7C00
-C600
-C600
-0600
-06C0
-06C0
-0FC0
-0C60
-0C60
-0C00
-0C00
+FFFC
+0080
+0080
+0F80
+1000
+1000
+30C0
+50C0
+4FC0
+2040
+1840
+10C0
+0F40
 ENDCHAR
-STARTCHAR gWa
-ENCODING 62259
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 11 0 0
+STARTCHAR uniE948
+ENCODING 59720
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 0 -3
 BITMAP
-78
-CC
-CC
-0C
-7E
-66
-06
-06
-06
-06
-06
+FFE0
+0400
+0400
+3C00
+4000
+2000
+3C00
+4000
+4000
+4300
+3F00
+0300
+0100
+0080
 ENDCHAR
-STARTCHAR gWE
-ENCODING 62260
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -2
+STARTCHAR uniE949
+ENCODING 59721
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 13 0 -2
 BITMAP
-7C00
-C600
-C600
-0600
-0600
-0600
-0C00
-0C00
-0C00
+FFFC
+0080
+0080
 0F80
-0CC0
-3F80
-6000
+1000
+1000
+10C0
+50C0
+4FC0
+4040
+3860
+1080
+0F00
 ENDCHAR
-STARTCHAR Ge
-ENCODING 62264
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE94A
+ENCODING 59722
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 0 -3
 BITMAP
-C3
-7E
-00
-7C
-C6
-C6
-06
-04
-0C
-0C
-0C
-0C
+FFE0
+0400
+0400
+7C00
+8000
+8000
+8600
+8600
+7E00
+1E00
+3300
+2A80
+2600
+1C00
 ENDCHAR
-STARTCHAR Gu
-ENCODING 62265
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE94B
+ENCODING 59723
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 13 0 -2
 BITMAP
-C300
-7E00
-0000
-7C00
-C600
-C600
-0600
-0600
-0FE0
-0C60
-0C00
-0C00
+FFF8
+0080
+0080
+0F80
+1000
+1000
+1180
+9180
+4F80
+4080
+4080
+FF80
+C080
 ENDCHAR
-STARTCHAR Gi
-ENCODING 62266
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE94C
+ENCODING 59724
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 12 0 -1
 BITMAP
-C300
-7E00
-0000
-7C00
-C600
-C600
-0600
-0400
-0C00
-0C00
-0CC0
+FFFC
+0440
+0440
+7C40
+8040
+8040
+8C40
+8C40
+7C40
+0440
 0FC0
+0C40
 ENDCHAR
-STARTCHAR Ga
-ENCODING 62267
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE94D
+ENCODING 59725
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 12 0 -1
 BITMAP
-C3
-7E
-00
-3C
-7F
-43
-03
-03
-0E
-3C
-70
-E0
+FFFE
+0220
+0220
+3E20
+4020
+4020
+4620
+4620
+3E20
+0420
+0260
+01C0
 ENDCHAR
-STARTCHAR GE
-ENCODING 62268
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE94E
+ENCODING 59726
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 14 0 -3
 BITMAP
-C300
-7E00
-0000
-7C00
-C600
-C600
-0600
+FFE0
 0400
-0C00
-0F80
-0CC0
-0F80
+0400
+7C00
+8000
+8000
+8600
+8600
+7E00
+1E00
+2300
+2280
+2200
+1C00
 ENDCHAR
-STARTCHAR G
-ENCODING 62269
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uniE94F
+ENCODING 59727
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 0 -6
 BITMAP
-C300
+FFF0
+0200
+0200
 7E00
-0000
+C000
+8000
+8080
+C180
 7F00
-CD80
-7980
-0180
-0100
-0300
-0300
-0300
-0300
-ENDCHAR
-STARTCHAR Go
-ENCODING 62270
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 7 12 0 0
-BITMAP
-C6
-7C
-10
-7C
-C6
-C6
-06
-04
-0C
-0C
-0C
-0C
+0200
+0200
+7E00
+C000
+8000
+8080
+C180
+7F00
 ENDCHAR
-STARTCHAR Te
-ENCODING 62272
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 10 0 0
+STARTCHAR uniE950
+ENCODING 59728
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 0 -6
 BITMAP
+FFF0
+0200
+0200
+7E00
+C000
+8000
+8100
+C300
+7E00
+0200
 3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C980
-C980
-C980
-ENDCHAR
-STARTCHAR Tu
-ENCODING 62273
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 10 0 0
-BITMAP
+6200
+C100
+8100
+8100
+4300
 3E00
-6B00
-6B00
-C980
-C980
-C9F8
-C998
-C980
-C980
-C980
 ENDCHAR
-STARTCHAR Ti
-ENCODING 62274
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 10 0 0
+STARTCHAR uniE951
+ENCODING 59729
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 16 0 -5
 BITMAP
+FFF0
+0200
+0200
 3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C980
-C998
-C9F8
-ENDCHAR
-STARTCHAR Ta
-ENCODING 62275
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
-BITMAP
+6100
+C100
+8100
+8300
+7E00
+0200
 3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-0180
-0180
-0180
-0180
+6100
+C100
+8100
+8300
+7E00
 ENDCHAR
-STARTCHAR TE
-ENCODING 62276
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 13 11 0 0
+STARTCHAR uniE952
+ENCODING 59730
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 16 0 -5
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C980
-C9F0
-C998
-C9F0
+FFFC
+0100
+3F00
+2000
+2000
+1E00
+8100
+8100
+4100
+3F00
+1100
+1100
+3100
+3100
+1100
+0100
 ENDCHAR
-STARTCHAR T
-ENCODING 62277
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 11 0 0
+STARTCHAR uniE953
+ENCODING 59731
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 18 0 -7
 BITMAP
-3F80
-7FC0
-4CC0
-CC60
-CE60
-C660
-0600
-0600
-0600
-0600
-0600
+FFF0
+0100
+0100
+3F00
+2000
+3C00
+8600
+8200
+4600
+3E00
+0200
+3E00
+2000
+3C00
+8600
+8200
+4600
+3C00
 ENDCHAR
-STARTCHAR To
-ENCODING 62278
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 11 0 0
+STARTCHAR uniE954
+ENCODING 59732
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 18 0 -7
 BITMAP
+FFF0
+0100
+0100
+3F00
+2000
+3C00
+8600
+8200
+4600
 3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-C000
-C000
-C000
-C000
+0200
+3E00
+4000
+8000
+9C00
+A200
+6200
+3C00
 ENDCHAR
-STARTCHAR TWa
-ENCODING 62279
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 13 0 -2
+STARTCHAR uniE955
+ENCODING 59733
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 14 11 0 0
 BITMAP
-3E00
-6B00
-6B00
-C980
-C980
-C980
-C980
-0180
-0180
-0180
-0180
-07E0
-0C30
+FFFC
+0080
+0080
+7880
+6480
+2380
+0E80
+3880
+3080
+1080
+0080
 ENDCHAR
-STARTCHAR Ce
-ENCODING 62280
+STARTCHAR uniE956
+ENCODING 59734
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 15 10 0 0
+BBX 16 15 0 -4
 BITMAP
-1F80
-3FC0
-6260
-C230
-C230
-C230
-F338
-DAB6
-CAB2
-FBBE
+FFFF
+0210
+0210
+3E10
+4010
+2010
+3C10
+6210
+4110
+43F0
+4310
+2010
+1000
+0C00
+0300
 ENDCHAR
-STARTCHAR Cu
-ENCODING 62281
+STARTCHAR uniE957
+ENCODING 59735
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 16 10 0 0
+BBX 16 15 0 -4
 BITMAP
-1F80
-3FC0
-6260
-C230
-C23F
-C233
-F338
-DAB4
-CAB2
-FBBE
+FFFF
+0210
+0210
+3E10
+4010
+2010
+3C10
+6210
+4110
+4130
+4250
+2190
+1000
+0C00
+0300
 ENDCHAR
-STARTCHAR Ci
-ENCODING 62282
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 10 0 0
+STARTCHAR uniE958
+ENCODING 59736
+SWIDTH 1140 0
+DWIDTH 19 0
+BBX 19 15 0 -4
 BITMAP
-1F80
-3FC0
-6260
-C230
-C230
-C230
-F330
-DAB0
-CAB3
-FBBF
+FFFFE0
+000200
+000200
+003E00
+004000
+002000
+003C00
+006200
+004100
+3BC100
+464200
+422000
+401000
+200C00
+180300
 ENDCHAR
-STARTCHAR Ca
-ENCODING 62283
+STARTCHAR uniE959
+ENCODING 59737
 SWIDTH 960 0
 DWIDTH 16 0
-BBX 14 12 0 0
+BBX 16 15 0 -4
 BITMAP
-1FC0
-3FE0
-6230
-C230
-E330
-D2B0
-CAB0
-FBB0
-0030
-0068
-0064
-007C
+FFFF
+0010
+0010
+01F0
+0200
+0100
+01E0
+0310
+0208
+0208
+3E10
+6300
+4280
+4660
+3C18
 ENDCHAR
-STARTCHAR CE
-ENCODING 62284
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 16 10 0 0
+STARTCHAR uniE95A
+ENCODING 59738
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 11 0 0
 BITMAP
-1F80
-3FC0
-6260
-C23F
-C239
-C237
-F330
-DABC
-CAB2
-FBBE
+FFFFC0
+100800
+100800
+10E800
+B01800
+FE1800
+402800
+404800
+208800
+100800
+080800
 ENDCHAR
-STARTCHAR C
-ENCODING 62285
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 11 0 0
+STARTCHAR uniE970
+ENCODING 59760
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 13 0 -2
 BITMAP
-1FC0
-7FE0
-C630
-E638
-9724
-F33C
-0300
-0380
-0340
-0320
-03E0
+3180
+6800
+4400
+4C80
+2980
+7E00
+C000
+8000
+8400
+8E00
+7E00
+0400
+0200
 ENDCHAR
-STARTCHAR Co
-ENCODING 62286
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 12 0 0
+STARTCHAR uniE971
+ENCODING 59761
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 0
 BITMAP
-1FC0
-3FE0
-3430
-6430
-4630
-C528
-C4A4
-C738
-E000
-D000
-C800
-F800
+FFF8
+0100
+0100
+7F00
+3100
+0900
+0500
+6500
+7900
+1100
+0900
 ENDCHAR
-STARTCHAR CWa
-ENCODING 62287
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 14 13 0 -2
+STARTCHAR uniE972
+ENCODING 59762
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 0 0
 BITMAP
-1FC0
-3FE0
-6230
-C230
-E330
-D2B0
-CAB0
-FBB0
-0030
-0060
-0060
-01F8
-030C
+FF80
+0000
+0000
+0000
+FF80
+1000
+2000
+2000
+2000
+1000
+0800
 ENDCHAR
-STARTCHAR Pe
-ENCODING 62288
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE973
+ENCODING 59763
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 9 0 2
 BITMAP
-18
-18
-18
-3C
-66
-66
-3C
-7E
-E7
-C3
-C3
-C3
+FC
+00
+00
+78
+84
+04
+08
+30
+40
 ENDCHAR
-STARTCHAR Pu
-ENCODING 62289
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE974
+ENCODING 59764
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 12 0 -1
 BITMAP
-1800
+FF80
 1800
+2400
+2400
 1800
-3C00
-6600
-6600
-3C00
-7E00
-E700
-C3F0
-C330
-C300
+6700
+0080
+7C00
+1880
+1080
+1100
+0E00
 ENDCHAR
-STARTCHAR Pi
-ENCODING 62290
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE975
+ENCODING 59765
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 10 0 1
 BITMAP
-1800
+FF80
 1800
+2400
+2400
 1800
-3C00
-6600
-6600
-3C00
-7E00
-E700
-C300
-C330
-C3F0
-ENDCHAR
-STARTCHAR Pa
-ENCODING 62291
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
-BITMAP
-18
-18
-18
-3C
-66
-3C
-7E
-E7
-C7
-C3
-03
-03
+6700
+0080
+0180
+0200
+0400
 ENDCHAR
-STARTCHAR PE
-ENCODING 62292
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE976
+ENCODING 59766
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 10 0 1
 BITMAP
-1800
+FF80
 1800
+2400
+2400
 1800
-3C00
-6600
-6600
-3C00
-7E00
-E700
-C3E0
-C330
-C3E0
+6700
+0880
+0880
+0880
+0700
 ENDCHAR
-STARTCHAR P
-ENCODING 62293
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE97B
+ENCODING 59771
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 7 0 10
 BITMAP
-1800
-1800
-1800
-3C00
-67E0
-6660
-3C00
-7E00
-E700
-C300
-C300
-C300
+60
+90
+A0
+A0
+80
+40
+20
 ENDCHAR
-STARTCHAR Po
-ENCODING 62294
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE97C
+ENCODING 59772
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 16 0 -5
 BITMAP
-18
-18
-18
-3C
-66
-3C
-7E
-E7
-C3
-C3
-C0
-C0
+FFE0
+0200
+0200
+3E00
+4000
+2000
+3C00
+6200
+4100
+4100
+4200
+2000
+1000
+2C00
+4300
+8000
 ENDCHAR
-STARTCHAR Se
-ENCODING 62296
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 10 0 0
+STARTCHAR uniE97D
+ENCODING 59773
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 8 7 0 4
 BITMAP
-18
-3C
-66
-66
+FF
+00
+00
+00
+00
+43
 3C
-7E
-E7
-C3
-C3
-C3
 ENDCHAR
-STARTCHAR Su
-ENCODING 62297
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 10 0 0
+STARTCHAR uniE97E
+ENCODING 59774
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 7 0 10
 BITMAP
-1800
-3C00
-6600
-6600
-3C00
-7E00
-E700
-C3F0
-C330
-C300
+60
+90
+80
+80
+80
+40
+20
 ENDCHAR
-STARTCHAR Si
-ENCODING 62298
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 10 0 0
+STARTCHAR uniE97F
+ENCODING 59775
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 5 0 -5
 BITMAP
-1800
-3C00
-6600
-6600
-3C00
-7E00
-E700
-C300
-C330
-C3F0
+20
+30
+68
+C0
+80
 ENDCHAR
-STARTCHAR Sa
-ENCODING 62299
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uniE980
+ENCODING 59776
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 15 -1 0
 BITMAP
-18
-3C
-66
-66
-3C
+B4
+44
+38
+00
 7E
-E6
-C7
-C3
-03
-03
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
 ENDCHAR
-STARTCHAR SE
-ENCODING 62300
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 10 0 0
+STARTCHAR uniE981
+ENCODING 59777
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 14 0 0
 BITMAP
-1800
-3C00
-6600
-6600
-3C00
-7E00
-E700
-C3C0
-C360
-C3C0
+60
+00
+00
+FC
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
 ENDCHAR
-STARTCHAR S
-ENCODING 62301
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 10 0 0
+STARTCHAR uniE982
+ENCODING 59778
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 17 0 0
 BITMAP
-1800
-3C00
-67E0
-6660
-3C00
-7E00
-E700
-C300
-C300
-C300
+60
+90
+80
+80
+80
+40
+FC
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
 ENDCHAR
-STARTCHAR So
-ENCODING 62302
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uniE983
+ENCODING 59779
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 17 0 0
 BITMAP
-18
-3C
-66
-66
-3C
-7E
-E7
-C3
-C3
-C0
-C0
+60
+90
+A0
+A0
+80
+40
+FC
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
 ENDCHAR
-STARTCHAR SWa
-ENCODING 62303
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 13 0 -2
+STARTCHAR uniE984
+ENCODING 59780
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 9 18 0 0
 BITMAP
-1800
-3C00
-6600
-6600
+0080
+0080
 3C00
-7E00
-E600
-C700
-C300
-0300
-0300
-0FC0
-1860
+4300
+4080
+4000
+4000
+FC00
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
 ENDCHAR
-STARTCHAR `Se/S2e
-ENCODING 62304
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 11 0 0
+STARTCHAR uniE985
+ENCODING 59781
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 0 0
 BITMAP
-1E
-63
-C3
-C3
-C3
-FF
-C3
-C3
-C3
-7F
-60
+0070
+3C80
+4380
+4080
+4000
+4000
+FC00
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
 ENDCHAR
-STARTCHAR `Su/S2u
-ENCODING 62305
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 11 0 0
+STARTCHAR uniE986
+ENCODING 59782
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 0 0
 BITMAP
-1E00
-6300
-C300
-C300
-C300
-FF00
-C3F0
-C330
-C300
-7F00
-6000
+0070
+3C80
+43A0
+40A0
+4000
+4000
+FC00
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
 ENDCHAR
-STARTCHAR `Si/S2i
-ENCODING 62306
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE987
+ENCODING 59783
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 12 16 -5 0
 BITMAP
-3E00
-6300
-C300
-FF00
-C300
-C300
-7F80
-0180
-0180
-0300
-0330
+7800
+8440
+8240
+8100
+0100
 03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR `Sa/S2a
-ENCODING 62307
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uniE988
+ENCODING 59784
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 12 16 -5 0
 BITMAP
-3E00
-6300
-C300
-FF00
-C300
-C300
-7F80
-0180
-0180
-0180
-0300
-0300
+78C0
+8520
+8300
+8100
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR `SE/S2E
-ENCODING 62308
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 12 12 0 0
+STARTCHAR uniE989
+ENCODING 59785
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 12 16 -5 0
 BITMAP
-3E00
-6300
-C300
-FF00
-C300
-C300
-7F80
-0180
-0180
-03E0
-0330
-03E0
+78C0
+8520
+8340
+8140
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR `S/S2
-ENCODING 62309
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 13 0 0
+STARTCHAR uniE98A
+ENCODING 59786
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 6 0 11
 BITMAP
-18
-18
-18
-7E
-E3
-C3
-C3
-FF
-C3
-C3
-C3
-7F
-60
+02
+E2
+10
+08
+04
+02
 ENDCHAR
-STARTCHAR `So/S2o
-ENCODING 62310
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE98B
+ENCODING 59787
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 5 0 11
 BITMAP
-3C
-66
-C3
-FF
-C3
-E7
-7E
-3C
-70
-C0
-C0
-C0
+E180
+1240
+0A00
+0600
+0200
 ENDCHAR
-STARTCHAR `SWa
-ENCODING 62311
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 14 0 -2
+STARTCHAR uniE98C
+ENCODING 59788
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 5 0 11
 BITMAP
-3E00
-6300
-C300
-FF00
-C300
-C300
-7F80
-0180
-0180
-0180
-0300
-0300
-0FC0
-1860
+E180
+1240
+0A80
+0680
+0200
 ENDCHAR
-STARTCHAR fe
-ENCODING 62312
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR uniE98D
+ENCODING 59789
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 8 6 0 11
 BITMAP
-0600
-0200
-0600
-0C00
-1800
-3000
-7800
-CC00
-C440
-7FC0
-1F40
+31
+19
+E4
+7A
+06
+01
 ENDCHAR
-STARTCHAR fu
-ENCODING 62313
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 9 12 0 0
+STARTCHAR uniE98E
+ENCODING 59790
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 6 0 11
 BITMAP
-0400
-0C00
-1800
-3000
-6000
-F800
-C880
-CF80
-FE00
-1800
 3000
-3000
+1830
+E448
+7A40
+0640
+0140
 ENDCHAR
-STARTCHAR fi
-ENCODING 62314
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR uniE98F
+ENCODING 59791
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 6 0 11
 BITMAP
-0600
-0200
-0600
-0C00
-1800
 3000
-78C0
-CC40
-C4C0
-7F80
-3E00
+1830
+E448
+7A50
+0650
+0140
 ENDCHAR
-STARTCHAR fa
-ENCODING 62315
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniE990
+ENCODING 59792
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 17 -5 0
 BITMAP
-0800
-0C00
-1800
+0200
+E200
 1000
-3000
-7000
-D800
-CC80
-7FC0
-0C40
-0C00
-0C00
+0800
+0400
+0200
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR fE
-ENCODING 62316
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 11 12 0 0
+STARTCHAR uniE991
+ENCODING 59793
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 16 -5 0
 BITMAP
+E180
+1240
+0A00
 0600
 0200
-0600
-0C00
-1800
-3000
-7800
-CC00
-C4C0
-7FA0
-1F20
-01C0
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR f
-ENCODING 62317
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 8 12 0 0
+STARTCHAR uniE992
+ENCODING 59794
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 16 -5 0
 BITMAP
-3E
-67
-43
-C0
-C0
-F8
-CF
-DD
-6C
-0C
-0C
-0C
+E180
+1240
+0A80
+0680
+0200
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
 ENDCHAR
-STARTCHAR fo
-ENCODING 62318
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 11 0 0
+STARTCHAR uniE993
+ENCODING 59795
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 17 -6 0
 BITMAP
-1F80
-3E40
-63C0
-C000
-C000
-C000
-F000
-E800
-C4C0
-6D80
-3F80
+3100
+1900
+E400
+7A00
+0600
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR fWa
-ENCODING 62319
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 13 0 -2
+STARTCHAR uniE994
+ENCODING 59796
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 12 18 -6 0
 BITMAP
-0800
-0C00
-1800
-1000
-3000
-7000
-D800
-CC80
-7FC0
-0C40
-0C00
-3F00
-6180
+0200
+3200
+18C0
+E520
+7B00
+0700
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
 ENDCHAR
-STARTCHAR pe
-ENCODING 62320
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniEDE0
+ENCODING 60896
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 1 3
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
+3E00
+4100
+A280
+B680
+B680
+AA80
+A280
+A280
+4100
+3E00
 ENDCHAR
-STARTCHAR pu
-ENCODING 62321
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniEDED
+ENCODING 60909
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 12 19 -5 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0FC0
-0CC0
-0C00
-0C00
-0C00
+4000
+A000
+4400
+FC00
+0000
+2000
+5000
+5000
+2000
+0000
+01E0
+0310
+0290
+0110
+0010
+0010
+0010
+0010
+0010
 ENDCHAR
-STARTCHAR pi
-ENCODING 62322
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniEDEE
+ENCODING 60910
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 11 18 -4 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-0C00
-0C00
-0CC0
-0FC0
+4000
+4000
+4000
+0000
+4000
+A000
+A000
+4000
+0000
+03C0
+0620
+0520
+0220
+0020
+0020
+0020
+0020
+0020
 ENDCHAR
-STARTCHAR pa
-ENCODING 62323
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniEDEF
+ENCODING 60911
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 0 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-1800
-3000
-6000
-4000
+FF80
+2080
+2080
+2000
+7F00
+2000
+7F00
+2000
+2000
+2000
+F800
 ENDCHAR
-STARTCHAR pE
-ENCODING 62324
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniF0C6
+ENCODING 61638
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 0 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-0C00
-0C00
-0C00
-0F80
-0CC0
-0F80
+0E00
+0400
+0400
+3F80
+4440
+8420
+4440
+3F80
+0400
+0400
+0E00
 ENDCHAR
-STARTCHAR p
-ENCODING 62325
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniF0F7
+ENCODING 61687
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 1 -4
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0F00
-0300
-0300
-0300
-0300
-0300
-0300
+70
+88
+C8
+08
+10
+20
+40
+80
+98
+88
+70
 ENDCHAR
-STARTCHAR po
-ENCODING 62326
-SWIDTH 960 0
-DWIDTH 16 0
-BBX 10 12 0 0
+STARTCHAR uniF0F8
+ENCODING 61688
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 9 1 0
 BITMAP
-6180
-7F80
-FFC0
-CCC0
-0C00
-0C00
-1800
-1800
-3000
-3000
-3000
-3000
+30
+48
+40
+20
+18
+44
+84
+84
+78
 ENDCHAR
-STARTCHAR char63696
+STARTCHAR uniF8D0
 ENCODING 63696
 SWIDTH 900 0
 DWIDTH 15 0
@@ -147549,7 +151787,7 @@
 000C
 0004
 ENDCHAR
-STARTCHAR char63697
+STARTCHAR uniF8D1
 ENCODING 63697
 SWIDTH 840 0
 DWIDTH 14 0
@@ -147570,7 +151808,7 @@
 0060
 0020
 ENDCHAR
-STARTCHAR char63698
+STARTCHAR uniF8D2
 ENCODING 63698
 SWIDTH 900 0
 DWIDTH 15 0
@@ -147590,7 +151828,7 @@
 0FF0
 03E0
 ENDCHAR
-STARTCHAR char63699
+STARTCHAR uniF8D3
 ENCODING 63699
 SWIDTH 720 0
 DWIDTH 12 0
@@ -147610,7 +151848,7 @@
 FF80
 7E00
 ENDCHAR
-STARTCHAR char63700
+STARTCHAR uniF8D4
 ENCODING 63700
 SWIDTH 660 0
 DWIDTH 11 0
@@ -147630,7 +151868,7 @@
 6000
 6000
 ENDCHAR
-STARTCHAR char63701
+STARTCHAR uniF8D5
 ENCODING 63701
 SWIDTH 960 0
 DWIDTH 16 0
@@ -147650,7 +151888,7 @@
 7C02
 E000
 ENDCHAR
-STARTCHAR char63702
+STARTCHAR uniF8D6
 ENCODING 63702
 SWIDTH 480 0
 DWIDTH 8 0
@@ -147670,7 +151908,7 @@
 18
 08
 ENDCHAR
-STARTCHAR char63703
+STARTCHAR uniF8D7
 ENCODING 63703
 SWIDTH 780 0
 DWIDTH 13 0
@@ -147690,7 +151928,7 @@
 0380
 01C0
 ENDCHAR
-STARTCHAR char63704
+STARTCHAR uniF8D8
 ENCODING 63704
 SWIDTH 840 0
 DWIDTH 14 0
@@ -147709,7 +151947,7 @@
 4000
 8000
 ENDCHAR
-STARTCHAR char63705
+STARTCHAR uniF8D9
 ENCODING 63705
 SWIDTH 600 0
 DWIDTH 10 0
@@ -147728,7 +151966,7 @@
 FF80
 0180
 ENDCHAR
-STARTCHAR char63706
+STARTCHAR uniF8DA
 ENCODING 63706
 SWIDTH 660 0
 DWIDTH 11 0
@@ -147748,7 +151986,7 @@
 1C00
 0C00
 ENDCHAR
-STARTCHAR char63707
+STARTCHAR uniF8DB
 ENCODING 63707
 SWIDTH 780 0
 DWIDTH 13 0
@@ -147769,7 +152007,7 @@
 03F0
 01F0
 ENDCHAR
-STARTCHAR char63708
+STARTCHAR uniF8DC
 ENCODING 63708
 SWIDTH 960 0
 DWIDTH 16 0
@@ -147789,7 +152027,7 @@
 0300
 00C0
 ENDCHAR
-STARTCHAR char63709
+STARTCHAR uniF8DD
 ENCODING 63709
 SWIDTH 840 0
 DWIDTH 14 0
@@ -147810,7 +152048,7 @@
 00F0
 0038
 ENDCHAR
-STARTCHAR char63710
+STARTCHAR uniF8DE
 ENCODING 63710
 SWIDTH 600 0
 DWIDTH 10 0
@@ -147829,7 +152067,7 @@
 3C00
 F000
 ENDCHAR
-STARTCHAR char63711
+STARTCHAR uniF8DF
 ENCODING 63711
 SWIDTH 420 0
 DWIDTH 7 0
@@ -147848,7 +152086,7 @@
 18
 10
 ENDCHAR
-STARTCHAR char63712
+STARTCHAR uniF8E0
 ENCODING 63712
 SWIDTH 600 0
 DWIDTH 10 0
@@ -147868,7 +152106,7 @@
 7000
 E000
 ENDCHAR
-STARTCHAR char63713
+STARTCHAR uniF8E1
 ENCODING 63713
 SWIDTH 780 0
 DWIDTH 13 0
@@ -147887,7 +152125,7 @@
 3000
 4000
 ENDCHAR
-STARTCHAR char63714
+STARTCHAR uniF8E2
 ENCODING 63714
 SWIDTH 840 0
 DWIDTH 14 0
@@ -147906,7 +152144,7 @@
 7FF0
 E038
 ENDCHAR
-STARTCHAR char63715
+STARTCHAR uniF8E3
 ENCODING 63715
 SWIDTH 840 0
 DWIDTH 14 0
@@ -147926,7 +152164,7 @@
 E000
 C000
 ENDCHAR
-STARTCHAR char63716
+STARTCHAR uniF8E4
 ENCODING 63716
 SWIDTH 900 0
 DWIDTH 15 0
@@ -147947,7 +152185,7 @@
 07C0
 01E0
 ENDCHAR
-STARTCHAR char63717
+STARTCHAR uniF8E5
 ENCODING 63717
 SWIDTH 840 0
 DWIDTH 14 0
@@ -147966,7 +152204,7 @@
 E000
 8000
 ENDCHAR
-STARTCHAR char63718
+STARTCHAR uniF8E6
 ENCODING 63718
 SWIDTH 960 0
 DWIDTH 16 0
@@ -147986,7 +152224,7 @@
 E00E
 C000
 ENDCHAR
-STARTCHAR char63719
+STARTCHAR uniF8E7
 ENCODING 63719
 SWIDTH 780 0
 DWIDTH 13 0
@@ -148006,7 +152244,7 @@
 1800
 0800
 ENDCHAR
-STARTCHAR char63720
+STARTCHAR uniF8E8
 ENCODING 63720
 SWIDTH 840 0
 DWIDTH 14 0
@@ -148028,7 +152266,7 @@
 0070
 0030
 ENDCHAR
-STARTCHAR char63721
+STARTCHAR uniF8E9
 ENCODING 63721
 SWIDTH 300 0
 DWIDTH 5 0
@@ -148043,7 +152281,7 @@
 C0
 60
 ENDCHAR
-STARTCHAR char63728
+STARTCHAR uniF8F0
 ENCODING 63728
 SWIDTH 840 0
 DWIDTH 14 0
@@ -148054,7 +152292,7 @@
 FFF8
 3FE0
 ENDCHAR
-STARTCHAR char63729
+STARTCHAR uniF8F1
 ENCODING 63729
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148074,7 +152312,7 @@
 8000
 8000
 ENDCHAR
-STARTCHAR char63730
+STARTCHAR uniF8F2
 ENCODING 63730
 SWIDTH 360 0
 DWIDTH 6 0
@@ -148093,7 +152331,7 @@
 30
 18
 ENDCHAR
-STARTCHAR char63731
+STARTCHAR uniF8F3
 ENCODING 63731
 SWIDTH 660 0
 DWIDTH 11 0
@@ -148112,7 +152350,7 @@
 0700
 01C0
 ENDCHAR
-STARTCHAR char63732
+STARTCHAR uniF8F4
 ENCODING 63732
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148132,7 +152370,7 @@
 7FF8
 3FFC
 ENDCHAR
-STARTCHAR char63733
+STARTCHAR uniF8F5
 ENCODING 63733
 SWIDTH 480 0
 DWIDTH 8 0
@@ -148153,7 +152391,7 @@
 18
 08
 ENDCHAR
-STARTCHAR char63734
+STARTCHAR uniF8F6
 ENCODING 63734
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148172,7 +152410,7 @@
 2010
 0010
 ENDCHAR
-STARTCHAR char63735
+STARTCHAR uniF8F7
 ENCODING 63735
 SWIDTH 660 0
 DWIDTH 11 0
@@ -148191,7 +152429,7 @@
 0080
 0040
 ENDCHAR
-STARTCHAR char63736
+STARTCHAR uniF8F8
 ENCODING 63736
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148211,7 +152449,7 @@
 6798
 CFCC
 ENDCHAR
-STARTCHAR char63737
+STARTCHAR uniF8F9
 ENCODING 63737
 SWIDTH 660 0
 DWIDTH 11 0
@@ -148231,7 +152469,7 @@
 1E00
 3300
 ENDCHAR
-STARTCHAR C011
+STARTCHAR uniFB00
 ENCODING 64256
 SWIDTH 540 0
 DWIDTH 9 0
@@ -148250,7 +152488,7 @@
 2400
 7E00
 ENDCHAR
-STARTCHAR C012
+STARTCHAR uniFB01
 ENCODING 64257
 SWIDTH 480 0
 DWIDTH 8 0
@@ -148269,7 +152507,7 @@
 24
 7E
 ENDCHAR
-STARTCHAR C013
+STARTCHAR uniFB02
 ENCODING 64258
 SWIDTH 420 0
 DWIDTH 7 0
@@ -148288,7 +152526,7 @@
 24
 7E
 ENDCHAR
-STARTCHAR C014
+STARTCHAR uniFB03
 ENCODING 64259
 SWIDTH 780 0
 DWIDTH 13 0
@@ -148307,7 +152545,7 @@
 2220
 7770
 ENDCHAR
-STARTCHAR C015
+STARTCHAR uniFB04
 ENCODING 64260
 SWIDTH 720 0
 DWIDTH 12 0
@@ -148326,7 +152564,7 @@
 2220
 7770
 ENDCHAR
-STARTCHAR C102
+STARTCHAR uniFB05
 ENCODING 64261
 SWIDTH 540 0
 DWIDTH 9 0
@@ -148345,7 +152583,7 @@
 49
 E6
 ENDCHAR
-STARTCHAR LATIN SMALL LIGATURE ST
+STARTCHAR uniFB06
 ENCODING 64262
 SWIDTH 780 0
 DWIDTH 13 0
@@ -148364,7 +152602,7 @@
 8890
 F060
 ENDCHAR
-STARTCHAR ARMENIAN LIGATURE MEN NOW
+STARTCHAR uniFB13
 ENCODING 64275
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148382,7 +152620,7 @@
 4C98
 346C
 ENDCHAR
-STARTCHAR ARMENIAN LIGATURE MEN ECH
+STARTCHAR uniFB14
 ENCODING 64276
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148400,7 +152638,7 @@
 4C98
 366C
 ENDCHAR
-STARTCHAR ARMENIAN LIGATURE MEN INI
+STARTCHAR uniFB15
 ENCODING 64277
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148421,7 +152659,7 @@
 0080
 01C0
 ENDCHAR
-STARTCHAR ARMENIAN LIGATURE VEW NOW
+STARTCHAR uniFB16
 ENCODING 64278
 SWIDTH 900 0
 DWIDTH 15 0
@@ -148442,7 +152680,7 @@
 0400
 0600
 ENDCHAR
-STARTCHAR ARMENIAN LIGATURE MEN XEH
+STARTCHAR uniFB17
 ENCODING 64279
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -148465,8 +152703,8 @@
 ENDCHAR
 STARTCHAR 0x05F2
 ENCODING 64285
-SWIDTH 240 0
-DWIDTH 4 0
+SWIDTH 300 0
+DWIDTH 5 0
 BBX 3 8 1 1
 BITMAP
 80
@@ -148489,8 +152727,8 @@
 ENDCHAR
 STARTCHAR 0x05F2
 ENCODING 64287
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 7 1 2
 BITMAP
 88
@@ -148503,9 +152741,9 @@
 ENDCHAR
 STARTCHAR 0xFB20
 ENCODING 64288
-SWIDTH 420 0
-DWIDTH 7 0
-BBX 7 10 0 0
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 1 0
 BITMAP
 42
 46
@@ -148520,8 +152758,8 @@
 ENDCHAR
 STARTCHAR 0xFB21
 ENCODING 64289
-SWIDTH 780 0
-DWIDTH 13 0
+SWIDTH 840 0
+DWIDTH 14 0
 BBX 12 9 1 0
 BITMAP
 8040
@@ -148536,8 +152774,8 @@
 ENDCHAR
 STARTCHAR 0xFB22
 ENCODING 64290
-SWIDTH 780 0
-DWIDTH 13 0
+SWIDTH 840 0
+DWIDTH 14 0
 BBX 12 9 1 0
 BITMAP
 8000
@@ -148552,8 +152790,8 @@
 ENDCHAR
 STARTCHAR 0x05D4
 ENCODING 64291
-SWIDTH 720 0
-DWIDTH 12 0
+SWIDTH 780 0
+DWIDTH 13 0
 BBX 11 9 1 0
 BITMAP
 8000
@@ -148568,8 +152806,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 64292
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 9 1 0
 BITMAP
 8000
@@ -148584,8 +152822,8 @@
 ENDCHAR
 STARTCHAR 0x05DC
 ENCODING 64293
-SWIDTH 720 0
-DWIDTH 12 0
+SWIDTH 780 0
+DWIDTH 13 0
 BBX 11 13 0 0
 BITMAP
 8000
@@ -148604,8 +152842,8 @@
 ENDCHAR
 STARTCHAR 0x05DD
 ENCODING 64294
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 9 1 0
 BITMAP
 8000
@@ -148620,8 +152858,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 64295
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 9 1 0
 BITMAP
 8000
@@ -148636,8 +152874,8 @@
 ENDCHAR
 STARTCHAR 0x05D4
 ENCODING 64296
-SWIDTH 720 0
-DWIDTH 12 0
+SWIDTH 780 0
+DWIDTH 13 0
 BBX 11 9 1 0
 BITMAP
 4000
@@ -148652,9 +152890,9 @@
 ENDCHAR
 STARTCHAR 0xFB29
 ENCODING 64297
-SWIDTH 660 0
-DWIDTH 11 0
-BBX 9 6 2 0
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 9 6 0 0
 BITMAP
 0800
 0800
@@ -148665,8 +152903,8 @@
 ENDCHAR
 STARTCHAR 0x05E9
 ENCODING 64298
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 12 1 0
 BITMAP
 0080
@@ -148684,8 +152922,8 @@
 ENDCHAR
 STARTCHAR 0x05E9
 ENCODING 64299
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 12 1 0
 BITMAP
 4000
@@ -148703,8 +152941,8 @@
 ENDCHAR
 STARTCHAR 0x05E9
 ENCODING 64300
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 12 1 0
 BITMAP
 0080
@@ -148722,8 +152960,8 @@
 ENDCHAR
 STARTCHAR 0x05E9
 ENCODING 64301
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 12 1 0
 BITMAP
 4000
@@ -148741,8 +152979,8 @@
 ENDCHAR
 STARTCHAR 0x05D0
 ENCODING 64302
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 11 1 -2
 BITMAP
 84
@@ -148759,8 +152997,8 @@
 ENDCHAR
 STARTCHAR 0x05D0
 ENCODING 64303
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 13 1 -4
 BITMAP
 84
@@ -148779,8 +153017,8 @@
 ENDCHAR
 STARTCHAR 0x05D0
 ENCODING 64304
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 84
@@ -148795,8 +153033,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 64305
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 80
@@ -148811,8 +153049,8 @@
 ENDCHAR
 STARTCHAR 0x05D2
 ENCODING 64306
-SWIDTH 360 0
-DWIDTH 6 0
+SWIDTH 420 0
+DWIDTH 7 0
 BBX 5 9 1 0
 BITMAP
 80
@@ -148827,8 +153065,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 64307
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 80
@@ -148843,8 +153081,8 @@
 ENDCHAR
 STARTCHAR 0x05D4
 ENCODING 64308
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 80
@@ -148859,8 +153097,8 @@
 ENDCHAR
 STARTCHAR 0x05D5
 ENCODING 64309
-SWIDTH 300 0
-DWIDTH 5 0
+SWIDTH 360 0
+DWIDTH 6 0
 BBX 4 9 1 0
 BITMAP
 80
@@ -148875,8 +153113,8 @@
 ENDCHAR
 STARTCHAR 0x05D5
 ENCODING 64310
-SWIDTH 360 0
-DWIDTH 6 0
+SWIDTH 420 0
+DWIDTH 7 0
 BBX 5 9 1 0
 BITMAP
 80
@@ -148907,41 +153145,42 @@
 ENDCHAR
 STARTCHAR 0x05F2
 ENCODING 64313
-SWIDTH 240 0
-DWIDTH 4 0
-BBX 3 6 1 3
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 3
 BITMAP
-80
-E0
-20
+40
+70
+10
+90
+90
 20
-C0
-80
 ENDCHAR
 STARTCHAR 0x05DA
 ENCODING 64314
-SWIDTH 540 0
-DWIDTH 9 0
-BBX 8 13 1 -4
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 14 2 -5
 BITMAP
 80
-FF
-02
+F0
+0F
 02
 22
 22
-02
-02
 02
-02
-02
-02
-02
+04
+04
+04
+04
+04
+04
+04
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 64315
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -148958,21 +153197,21 @@
 ENCODING 64316
 SWIDTH 540 0
 DWIDTH 9 0
-BBX 8 13 0 0
+BBX 7 13 0 0
 BITMAP
 80
 C0
 40
 40
 40
-7F
-01
-01
-11
-11
+7E
 02
+02
+22
+22
 04
-18
+08
+30
 ENDCHAR
 STARTCHAR 0x05DE
 ENCODING 64318
@@ -148988,12 +153227,12 @@
 92
 82
 84
-B8
+BC
 ENDCHAR
 STARTCHAR 0x05D2
 ENCODING 64320
-SWIDTH 300 0
-DWIDTH 5 0
+SWIDTH 360 0
+DWIDTH 6 0
 BBX 4 9 1 0
 BITMAP
 80
@@ -149008,8 +153247,8 @@
 ENDCHAR
 STARTCHAR 0x05E1
 ENCODING 64321
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -149024,8 +153263,8 @@
 ENDCHAR
 STARTCHAR 0x05DA
 ENCODING 64323
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 13 1 -4
 BITMAP
 80
@@ -149044,8 +153283,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 64324
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -149060,8 +153299,8 @@
 ENDCHAR
 STARTCHAR 0x05E6
 ENCODING 64326
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 84
@@ -149076,8 +153315,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 64327
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 13 1 -4
 BITMAP
 80
@@ -149096,8 +153335,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 64328
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 9 1 0
 BITMAP
 80
@@ -149112,8 +153351,8 @@
 ENDCHAR
 STARTCHAR 0x05E9
 ENCODING 64329
-SWIDTH 660 0
-DWIDTH 11 0
+SWIDTH 720 0
+DWIDTH 12 0
 BBX 10 9 1 0
 BITMAP
 9100
@@ -149128,8 +153367,8 @@
 ENDCHAR
 STARTCHAR 0x05D4
 ENCODING 64330
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 9 1 0
 BITMAP
 40
@@ -149144,8 +153383,8 @@
 ENDCHAR
 STARTCHAR 0x05D5
 ENCODING 64331
-SWIDTH 300 0
-DWIDTH 5 0
+SWIDTH 360 0
+DWIDTH 6 0
 BBX 4 12 1 0
 BITMAP
 40
@@ -149163,8 +153402,8 @@
 ENDCHAR
 STARTCHAR 0x05D3
 ENCODING 64332
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 11 1 0
 BITMAP
 3C
@@ -149181,8 +153420,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 64333
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 11 1 0
 BITMAP
 3C
@@ -149199,8 +153438,8 @@
 ENDCHAR
 STARTCHAR 0x05DB
 ENCODING 64334
-SWIDTH 480 0
-DWIDTH 8 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 7 11 1 0
 BITMAP
 3C
@@ -149217,8 +153456,8 @@
 ENDCHAR
 STARTCHAR 0x05D0
 ENCODING 64335
-SWIDTH 540 0
-DWIDTH 9 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 8 12 0 0
 BITMAP
 80
@@ -149905,7 +154144,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR uniFB80
+STARTCHAR uniFB74
 ENCODING 64372
 SWIDTH 600 0
 DWIDTH 10 0
@@ -149922,7 +154161,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFB75
 ENCODING 64373
 SWIDTH 1200 0
 DWIDTH 20 0
@@ -149975,7 +154214,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR uniFB80
+STARTCHAR uniFB78
 ENCODING 64376
 SWIDTH 600 0
 DWIDTH 10 0
@@ -149989,7 +154228,7 @@
 1400
 1400
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFB79
 ENCODING 64377
 SWIDTH 1200 0
 DWIDTH 20 0
@@ -150039,7 +154278,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR uniFB80
+STARTCHAR uniFB7C
 ENCODING 64380
 SWIDTH 600 0
 DWIDTH 10 0
@@ -150055,10 +154294,10 @@
 0800
 0800
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFB7D
 ENCODING 64381
-SWIDTH 1200 0
-DWIDTH 20 0
+SWIDTH 600 0
+DWIDTH 10 0
 BBX 10 9 0 -5
 BITMAP
 3800
@@ -150124,7 +154363,7 @@
 1400
 1400
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFB81
 ENCODING 64385
 SWIDTH 1200 0
 DWIDTH 20 0
@@ -150406,7 +154645,7 @@
 8010
 7FFE
 ENDCHAR
-STARTCHAR uniFEDB
+STARTCHAR uniFB90
 ENCODING 64400
 SWIDTH 480 0
 DWIDTH 8 0
@@ -150423,7 +154662,7 @@
 02
 FC
 ENDCHAR
-STARTCHAR uniFEDC
+STARTCHAR uniFB91
 ENCODING 64401
 SWIDTH 660 0
 DWIDTH 11 0
@@ -150821,7 +155060,7 @@
 10
 FC
 ENDCHAR
-STARTCHAR 0xFEE9
+STARTCHAR uniFBA4
 ENCODING 64420
 SWIDTH 420 0
 DWIDTH 7 0
@@ -150840,7 +155079,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0xFEEA
+STARTCHAR uniFBA5
 ENCODING 64421
 SWIDTH 420 0
 DWIDTH 7 0
@@ -150859,7 +155098,7 @@
 70
 0C
 ENDCHAR
-STARTCHAR 0xFEE9
+STARTCHAR uniFBA6
 ENCODING 64422
 SWIDTH 420 0
 DWIDTH 7 0
@@ -150872,7 +155111,7 @@
 88
 70
 ENDCHAR
-STARTCHAR 0xFBA7
+STARTCHAR uniFBA7
 ENCODING 64423
 SWIDTH 540 0
 DWIDTH 9 0
@@ -150883,7 +155122,7 @@
 46
 83
 ENDCHAR
-STARTCHAR 0xFBA8
+STARTCHAR uniFBA8
 ENCODING 64424
 SWIDTH 180 0
 DWIDTH 3 0
@@ -150900,7 +155139,7 @@
 40
 60
 ENDCHAR
-STARTCHAR 0xFBA9
+STARTCHAR uniFBA9
 ENCODING 64425
 SWIDTH 360 0
 DWIDTH 6 0
@@ -150914,7 +155153,7 @@
 20
 20
 ENDCHAR
-STARTCHAR 00EA
+STARTCHAR uniFBAA
 ENCODING 64426
 SWIDTH 600 0
 DWIDTH 10 0
@@ -150927,7 +155166,7 @@
 26
 C0
 ENDCHAR
-STARTCHAR 00EA
+STARTCHAR uniFBAB
 ENCODING 64427
 SWIDTH 660 0
 DWIDTH 11 0
@@ -150940,7 +155179,7 @@
 27C0
 C000
 ENDCHAR
-STARTCHAR 00EA
+STARTCHAR uniFBAC
 ENCODING 64428
 SWIDTH 600 0
 DWIDTH 10 0
@@ -150952,7 +155191,7 @@
 2C80
 D300
 ENDCHAR
-STARTCHAR 00EA
+STARTCHAR uniFBAD
 ENCODING 64429
 SWIDTH 600 0
 DWIDTH 10 0
@@ -150964,7 +155203,7 @@
 2C80
 D3C0
 ENDCHAR
-STARTCHAR 0xFBAE
+STARTCHAR uniFBAE
 ENCODING 64430
 SWIDTH 900 0
 DWIDTH 15 0
@@ -150979,10 +155218,10 @@
 8000
 7FF8
 ENDCHAR
-STARTCHAR 0xFBAF
+STARTCHAR uniFBAF
 ENCODING 64431
-SWIDTH 720 0
-DWIDTH 12 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 11 8 1 -7
 BITMAP
 0300
@@ -150994,7 +155233,7 @@
 8000
 7FE0
 ENDCHAR
-STARTCHAR 0xFBAE
+STARTCHAR uniFBB0
 ENCODING 64432
 SWIDTH 900 0
 DWIDTH 15 0
@@ -151012,10 +155251,10 @@
 8000
 7FF8
 ENDCHAR
-STARTCHAR 0xFBAF
+STARTCHAR uniFBB1
 ENCODING 64433
-SWIDTH 720 0
-DWIDTH 12 0
+SWIDTH 540 0
+DWIDTH 9 0
 BBX 11 11 1 -7
 BITMAP
 3000
@@ -151030,7 +155269,7 @@
 8000
 7FE0
 ENDCHAR
-STARTCHAR uni0075
+STARTCHAR uniFBD3
 ENCODING 64467
 SWIDTH 660 0
 DWIDTH 11 0
@@ -151528,7 +155767,7 @@
 28
 28
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uniFD3E
 ENCODING 64830
 SWIDTH 660 0
 DWIDTH 11 0
@@ -151555,7 +155794,7 @@
 0300
 0080
 ENDCHAR
-STARTCHAR char123
+STARTCHAR uniFD3F
 ENCODING 64831
 SWIDTH 660 0
 DWIDTH 11 0
@@ -151582,7 +155821,7 @@
 6000
 8000
 ENDCHAR
-STARTCHAR char203
+STARTCHAR uniFDF2
 ENCODING 65010
 SWIDTH 660 0
 DWIDTH 11 0
@@ -151605,7 +155844,7 @@
 64A0
 1B20
 ENDCHAR
-STARTCHAR char65056
+STARTCHAR uniFE20
 ENCODING 65056
 SWIDTH 0 0
 DWIDTH 0 0
@@ -151615,7 +155854,7 @@
 40
 80
 ENDCHAR
-STARTCHAR char65056
+STARTCHAR uniFE21
 ENCODING 65057
 SWIDTH 0 0
 DWIDTH 0 0
@@ -151625,7 +155864,7 @@
 08
 04
 ENDCHAR
-STARTCHAR char65056
+STARTCHAR uniFE22
 ENCODING 65058
 SWIDTH 0 0
 DWIDTH 0 0
@@ -151635,7 +155874,7 @@
 42
 80
 ENDCHAR
-STARTCHAR char65056
+STARTCHAR uniFE23
 ENCODING 65059
 SWIDTH 0 0
 DWIDTH 0 0
@@ -151645,7 +155884,7 @@
 84
 78
 ENDCHAR
-STARTCHAR C044
+STARTCHAR uniFE50
 ENCODING 65104
 SWIDTH 300 0
 DWIDTH 5 0
@@ -151655,7 +155894,7 @@
 40
 80
 ENDCHAR
-STARTCHAR 3001
+STARTCHAR uniFE51
 ENCODING 65105
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151665,7 +155904,7 @@
 40
 20
 ENDCHAR
-STARTCHAR C046
+STARTCHAR uniFE52
 ENCODING 65106
 SWIDTH 240 0
 DWIDTH 4 0
@@ -151674,7 +155913,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C059
+STARTCHAR uniFE54
 ENCODING 65108
 SWIDTH 300 0
 DWIDTH 5 0
@@ -151688,7 +155927,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C058
+STARTCHAR uniFE55
 ENCODING 65109
 SWIDTH 240 0
 DWIDTH 4 0
@@ -151701,7 +155940,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C063
+STARTCHAR uniFE56
 ENCODING 65110
 SWIDTH 420 0
 DWIDTH 7 0
@@ -151717,7 +155956,7 @@
 40
 40
 ENDCHAR
-STARTCHAR C063
+STARTCHAR uniFE57
 ENCODING 65111
 SWIDTH 300 0
 DWIDTH 5 0
@@ -151733,7 +155972,7 @@
 80
 80
 ENDCHAR
-STARTCHAR char8314
+STARTCHAR uniFE58
 ENCODING 65112
 SWIDTH 480 0
 DWIDTH 8 0
@@ -151741,7 +155980,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uniFE59
 ENCODING 65113
 SWIDTH 300 0
 DWIDTH 5 0
@@ -151758,7 +155997,7 @@
 40
 20
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uniFE5A
 ENCODING 65114
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151775,7 +156014,7 @@
 40
 80
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uniFE5B
 ENCODING 65115
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151792,7 +156031,7 @@
 40
 30
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uniFE5C
 ENCODING 65116
 SWIDTH 420 0
 DWIDTH 7 0
@@ -151809,7 +156048,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uniFE5D
 ENCODING 65117
 SWIDTH 300 0
 DWIDTH 5 0
@@ -151825,7 +156064,7 @@
 80
 E0
 ENDCHAR
-STARTCHAR C040
+STARTCHAR uniFE5E
 ENCODING 65118
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151841,7 +156080,7 @@
 20
 E0
 ENDCHAR
-STARTCHAR char65119
+STARTCHAR uniFE5F
 ENCODING 65119
 SWIDTH 540 0
 DWIDTH 9 0
@@ -151855,7 +156094,7 @@
 50
 A0
 ENDCHAR
-STARTCHAR char8314
+STARTCHAR uniFE62
 ENCODING 65122
 SWIDTH 480 0
 DWIDTH 8 0
@@ -151867,7 +156106,7 @@
 20
 20
 ENDCHAR
-STARTCHAR char8314
+STARTCHAR uniFE63
 ENCODING 65123
 SWIDTH 420 0
 DWIDTH 7 0
@@ -151875,7 +156114,7 @@
 BITMAP
 F0
 ENDCHAR
-STARTCHAR char8314
+STARTCHAR uniFE66
 ENCODING 65126
 SWIDTH 480 0
 DWIDTH 8 0
@@ -151885,7 +156124,7 @@
 00
 F8
 ENDCHAR
-STARTCHAR 0xFE70
+STARTCHAR uniFE70
 ENCODING 65136
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151896,7 +156135,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR 0xFE71
+STARTCHAR uniFE71
 ENCODING 65137
 SWIDTH 660 0
 DWIDTH 11 0
@@ -151913,7 +156152,7 @@
 0000
 FF80
 ENDCHAR
-STARTCHAR 0x064C
+STARTCHAR uniFE72
 ENCODING 65138
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151924,7 +156163,7 @@
 D0
 60
 ENDCHAR
-STARTCHAR 0xFE74
+STARTCHAR uniFE74
 ENCODING 65140
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151935,7 +156174,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR 0xFE76
+STARTCHAR uniFE76
 ENCODING 65142
 SWIDTH 360 0
 DWIDTH 6 0
@@ -151944,7 +156183,7 @@
 30
 C0
 ENDCHAR
-STARTCHAR 0xFE77
+STARTCHAR uniFE77
 ENCODING 65143
 SWIDTH 660 0
 DWIDTH 11 0
@@ -151959,7 +156198,7 @@
 0000
 FF80
 ENDCHAR
-STARTCHAR 0xFE78
+STARTCHAR uniFE78
 ENCODING 65144
 SWIDTH 300 0
 DWIDTH 5 0
@@ -151971,7 +156210,7 @@
 50
 80
 ENDCHAR
-STARTCHAR 0xFE79
+STARTCHAR uniFE79
 ENCODING 65145
 SWIDTH 540 0
 DWIDTH 9 0
@@ -151990,7 +156229,7 @@
 0000
 FF80
 ENDCHAR
-STARTCHAR 0xFE7A
+STARTCHAR uniFE7A
 ENCODING 65146
 SWIDTH 360 0
 DWIDTH 6 0
@@ -152000,7 +156239,7 @@
 60
 80
 ENDCHAR
-STARTCHAR 0xFE7B
+STARTCHAR uniFE7B
 ENCODING 65147
 SWIDTH 660 0
 DWIDTH 11 0
@@ -152016,7 +156255,7 @@
 3000
 4000
 ENDCHAR
-STARTCHAR 0x0651
+STARTCHAR uniFE7C
 ENCODING 65148
 SWIDTH 0 0
 DWIDTH 0 0
@@ -152026,7 +156265,7 @@
 A8
 D0
 ENDCHAR
-STARTCHAR 0xFE7D
+STARTCHAR uniFE7D
 ENCODING 65149
 SWIDTH 660 0
 DWIDTH 11 0
@@ -152044,7 +156283,7 @@
 0000
 FF80
 ENDCHAR
-STARTCHAR 0xFE7E
+STARTCHAR uniFE7E
 ENCODING 65150
 SWIDTH 240 0
 DWIDTH 4 0
@@ -152055,7 +156294,7 @@
 A0
 C0
 ENDCHAR
-STARTCHAR 0xFE7F
+STARTCHAR uniFE7F
 ENCODING 65151
 SWIDTH 540 0
 DWIDTH 9 0
@@ -152628,7 +156867,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFE9F
 ENCODING 65183
 SWIDTH 600 0
 DWIDTH 10 0
@@ -152643,7 +156882,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFEA0
 ENCODING 65184
 SWIDTH 600 0
 DWIDTH 10 0
@@ -152694,7 +156933,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFEA3
 ENCODING 65187
 SWIDTH 600 0
 DWIDTH 10 0
@@ -152705,7 +156944,7 @@
 0100
 FF80
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFEA4
 ENCODING 65188
 SWIDTH 600 0
 DWIDTH 10 0
@@ -152760,7 +156999,7 @@
 60C0
 1F00
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFEA7
 ENCODING 65191
 SWIDTH 600 0
 DWIDTH 10 0
@@ -152775,7 +157014,7 @@
 0100
 FF80
 ENDCHAR
-STARTCHAR uni0016
+STARTCHAR uniFEA8
 ENCODING 65192
 SWIDTH 600 0
 DWIDTH 10 0
@@ -153098,7 +157337,7 @@
 2410
 FFF8
 ENDCHAR
-STARTCHAR uniFEB9
+STARTCHAR uniFEBD
 ENCODING 65213
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -153117,7 +157356,7 @@
 430000
 3C0000
 ENDCHAR
-STARTCHAR uniFEBA
+STARTCHAR uniFEBE
 ENCODING 65214
 SWIDTH 1080 0
 DWIDTH 18 0
@@ -153136,7 +157375,7 @@
 430000
 3C0000
 ENDCHAR
-STARTCHAR uniFEBB
+STARTCHAR uniFEBF
 ENCODING 65215
 SWIDTH 840 0
 DWIDTH 14 0
@@ -153150,7 +157389,7 @@
 2208
 FFF0
 ENDCHAR
-STARTCHAR uniFEBC
+STARTCHAR uniFEC0
 ENCODING 65216
 SWIDTH 780 0
 DWIDTH 13 0
@@ -153588,7 +157827,7 @@
 18
 E7
 ENDCHAR
-STARTCHAR uni0075
+STARTCHAR uniFED9
 ENCODING 65241
 SWIDTH 660 0
 DWIDTH 11 0
@@ -153605,7 +157844,7 @@
 C080
 7F00
 ENDCHAR
-STARTCHAR uni0075
+STARTCHAR uniFEDA
 ENCODING 65242
 SWIDTH 660 0
 DWIDTH 11 0
@@ -154207,7 +158446,7 @@
 30C0
 E000
 ENDCHAR
-STARTCHAR char8192
+STARTCHAR uniFEFF
 ENCODING 65279
 SWIDTH 900 0
 DWIDTH 15 0
@@ -154229,7 +158468,7 @@
 0002
 DB6A
 ENDCHAR
-STARTCHAR FF01
+STARTCHAR uniFF01
 ENCODING 65281
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154248,7 +158487,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR FF02
+STARTCHAR uniFF02
 ENCODING 65282
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154259,7 +158498,7 @@
 90
 90
 ENDCHAR
-STARTCHAR FF03
+STARTCHAR uniFF03
 ENCODING 65283
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154279,7 +158518,7 @@
 2200
 2200
 ENDCHAR
-STARTCHAR FF04
+STARTCHAR uniFF04
 ENCODING 65284
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154301,7 +158540,7 @@
 78
 10
 ENDCHAR
-STARTCHAR FF05
+STARTCHAR uniFF05
 ENCODING 65285
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154321,7 +158560,7 @@
 8110
 00E0
 ENDCHAR
-STARTCHAR FF06
+STARTCHAR uniFF06
 ENCODING 65286
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154341,7 +158580,7 @@
 6190
 1E60
 ENDCHAR
-STARTCHAR FF07
+STARTCHAR uniFF07
 ENCODING 65287
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154352,7 +158591,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FF08
+STARTCHAR uniFF08
 ENCODING 65288
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154373,7 +158612,7 @@
 20
 10
 ENDCHAR
-STARTCHAR FF09
+STARTCHAR uniFF09
 ENCODING 65289
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154394,7 +158633,7 @@
 40
 80
 ENDCHAR
-STARTCHAR FF0A
+STARTCHAR uniFF0A
 ENCODING 65290
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154411,7 +158650,7 @@
 0C00
 0C00
 ENDCHAR
-STARTCHAR FF0B
+STARTCHAR uniFF0B
 ENCODING 65291
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154427,7 +158666,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR FF0C
+STARTCHAR uniFF0C
 ENCODING 65292
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154438,7 +158677,7 @@
 40
 80
 ENDCHAR
-STARTCHAR FF0D
+STARTCHAR uniFF0D
 ENCODING 65293
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154446,7 +158685,7 @@
 BITMAP
 FFF0
 ENDCHAR
-STARTCHAR FF0E
+STARTCHAR uniFF0E
 ENCODING 65294
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154455,7 +158694,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR FF0F
+STARTCHAR uniFF0F
 ENCODING 65295
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154476,7 +158715,7 @@
 4000
 8000
 ENDCHAR
-STARTCHAR FF10
+STARTCHAR uniFF10
 ENCODING 65296
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154496,7 +158735,7 @@
 44
 38
 ENDCHAR
-STARTCHAR FF11
+STARTCHAR uniFF11
 ENCODING 65297
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154516,7 +158755,7 @@
 10
 FE
 ENDCHAR
-STARTCHAR FF12
+STARTCHAR uniFF12
 ENCODING 65298
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154536,7 +158775,7 @@
 81
 FF
 ENDCHAR
-STARTCHAR FF13
+STARTCHAR uniFF13
 ENCODING 65299
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154556,7 +158795,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR FF14
+STARTCHAR uniFF14
 ENCODING 65300
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154576,7 +158815,7 @@
 0100
 0780
 ENDCHAR
-STARTCHAR FF15
+STARTCHAR uniFF15
 ENCODING 65301
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154596,7 +158835,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR FF16
+STARTCHAR uniFF16
 ENCODING 65302
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154616,7 +158855,7 @@
 82
 7C
 ENDCHAR
-STARTCHAR FF17
+STARTCHAR uniFF17
 ENCODING 65303
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154636,7 +158875,7 @@
 0800
 0800
 ENDCHAR
-STARTCHAR FF18
+STARTCHAR uniFF18
 ENCODING 65304
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154656,7 +158895,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR FF19
+STARTCHAR uniFF19
 ENCODING 65305
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154676,7 +158915,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR FF1A
+STARTCHAR uniFF1A
 ENCODING 65306
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154691,7 +158930,7 @@
 C0
 C0
 ENDCHAR
-STARTCHAR FF1B
+STARTCHAR uniFF1B
 ENCODING 65307
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154708,7 +158947,7 @@
 40
 80
 ENDCHAR
-STARTCHAR FF1C
+STARTCHAR uniFF1C
 ENCODING 65308
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154726,7 +158965,7 @@
 0300
 0080
 ENDCHAR
-STARTCHAR FF1D
+STARTCHAR uniFF1D
 ENCODING 65309
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154737,7 +158976,7 @@
 0000
 FFF0
 ENDCHAR
-STARTCHAR FF1E
+STARTCHAR uniFF1E
 ENCODING 65310
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154755,7 +158994,7 @@
 6000
 8000
 ENDCHAR
-STARTCHAR FF1F
+STARTCHAR uniFF1F
 ENCODING 65311
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154775,7 +159014,7 @@
 18
 18
 ENDCHAR
-STARTCHAR FF20
+STARTCHAR uniFF20
 ENCODING 65312
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154797,7 +159036,7 @@
 0C60
 0380
 ENDCHAR
-STARTCHAR FF21
+STARTCHAR uniFF21
 ENCODING 65313
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154816,7 +159055,7 @@
 2040
 F0F0
 ENDCHAR
-STARTCHAR FF22
+STARTCHAR uniFF22
 ENCODING 65314
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154835,7 +159074,7 @@
 2080
 FF00
 ENDCHAR
-STARTCHAR FF23
+STARTCHAR uniFF23
 ENCODING 65315
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154854,7 +159093,7 @@
 2100
 1E00
 ENDCHAR
-STARTCHAR FF24
+STARTCHAR uniFF24
 ENCODING 65316
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154873,7 +159112,7 @@
 20C0
 FF00
 ENDCHAR
-STARTCHAR FF25
+STARTCHAR uniFF25
 ENCODING 65317
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154892,7 +159131,7 @@
 2040
 FFC0
 ENDCHAR
-STARTCHAR FF26
+STARTCHAR uniFF26
 ENCODING 65318
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154911,7 +159150,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR FF27
+STARTCHAR uniFF27
 ENCODING 65319
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154930,7 +159169,7 @@
 2080
 1F00
 ENDCHAR
-STARTCHAR FF28
+STARTCHAR uniFF28
 ENCODING 65320
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154949,7 +159188,7 @@
 2020
 F8F8
 ENDCHAR
-STARTCHAR FF29
+STARTCHAR uniFF29
 ENCODING 65321
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154968,7 +159207,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR FF2A
+STARTCHAR uniFF2A
 ENCODING 65322
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -154987,7 +159226,7 @@
 90
 E0
 ENDCHAR
-STARTCHAR FF2B
+STARTCHAR uniFF2B
 ENCODING 65323
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155006,7 +159245,7 @@
 2040
 F9F0
 ENDCHAR
-STARTCHAR FF2C
+STARTCHAR uniFF2C
 ENCODING 65324
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155025,7 +159264,7 @@
 2040
 FFC0
 ENDCHAR
-STARTCHAR FF2D
+STARTCHAR uniFF2D
 ENCODING 65325
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155044,7 +159283,7 @@
 2108
 F93E
 ENDCHAR
-STARTCHAR FF2E
+STARTCHAR uniFF2E
 ENCODING 65326
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155063,7 +159302,7 @@
 2020
 F820
 ENDCHAR
-STARTCHAR FF2F
+STARTCHAR uniFF2F
 ENCODING 65327
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155082,7 +159321,7 @@
 6180
 1E00
 ENDCHAR
-STARTCHAR FF30
+STARTCHAR uniFF30
 ENCODING 65328
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155101,7 +159340,7 @@
 2000
 F800
 ENDCHAR
-STARTCHAR FF31
+STARTCHAR uniFF31
 ENCODING 65329
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155122,7 +159361,7 @@
 0100
 0080
 ENDCHAR
-STARTCHAR FF32
+STARTCHAR uniFF32
 ENCODING 65330
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155141,7 +159380,7 @@
 2040
 F8F0
 ENDCHAR
-STARTCHAR FF33
+STARTCHAR uniFF33
 ENCODING 65331
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155160,7 +159399,7 @@
 41
 3E
 ENDCHAR
-STARTCHAR FF34
+STARTCHAR uniFF34
 ENCODING 65332
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155179,7 +159418,7 @@
 0200
 0F80
 ENDCHAR
-STARTCHAR FF35
+STARTCHAR uniFF35
 ENCODING 65333
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155198,7 +159437,7 @@
 2080
 1F00
 ENDCHAR
-STARTCHAR FF36
+STARTCHAR uniFF36
 ENCODING 65334
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155216,7 +159455,7 @@
 0600
 0600
 ENDCHAR
-STARTCHAR FF37
+STARTCHAR uniFF37
 ENCODING 65335
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155235,7 +159474,7 @@
 0840
 0840
 ENDCHAR
-STARTCHAR FF38
+STARTCHAR uniFF38
 ENCODING 65336
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155254,7 +159493,7 @@
 2040
 F9F0
 ENDCHAR
-STARTCHAR FF39
+STARTCHAR uniFF39
 ENCODING 65337
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155273,7 +159512,7 @@
 0600
 1F80
 ENDCHAR
-STARTCHAR FF3A
+STARTCHAR uniFF3A
 ENCODING 65338
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155292,7 +159531,7 @@
 81
 FF
 ENDCHAR
-STARTCHAR FF3B
+STARTCHAR uniFF3B
 ENCODING 65339
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155314,7 +159553,7 @@
 80
 F0
 ENDCHAR
-STARTCHAR FF3C
+STARTCHAR uniFF3C
 ENCODING 65340
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155335,7 +159574,7 @@
 0008
 0004
 ENDCHAR
-STARTCHAR FF3D
+STARTCHAR uniFF3D
 ENCODING 65341
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155357,7 +159596,7 @@
 10
 F0
 ENDCHAR
-STARTCHAR FF3E
+STARTCHAR uniFF3E
 ENCODING 65342
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155368,7 +159607,7 @@
 44
 82
 ENDCHAR
-STARTCHAR FF3F
+STARTCHAR uniFF3F
 ENCODING 65343
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155376,7 +159615,7 @@
 BITMAP
 FFFC
 ENDCHAR
-STARTCHAR FF3E
+STARTCHAR uniFF40
 ENCODING 65344
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155387,7 +159626,7 @@
 20
 10
 ENDCHAR
-STARTCHAR FF41
+STARTCHAR uniFF41
 ENCODING 65345
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155403,7 +159642,7 @@
 8E
 72
 ENDCHAR
-STARTCHAR FF42
+STARTCHAR uniFF42
 ENCODING 65346
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155422,7 +159661,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR FF43
+STARTCHAR uniFF43
 ENCODING 65347
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155438,7 +159677,7 @@
 44
 38
 ENDCHAR
-STARTCHAR FF44
+STARTCHAR uniFF44
 ENCODING 65348
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155457,7 +159696,7 @@
 4200
 3D80
 ENDCHAR
-STARTCHAR FF45
+STARTCHAR uniFF45
 ENCODING 65349
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155473,7 +159712,7 @@
 44
 38
 ENDCHAR
-STARTCHAR FF46
+STARTCHAR uniFF46
 ENCODING 65350
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155493,7 +159732,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR FF47
+STARTCHAR uniFF47
 ENCODING 65351
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155512,7 +159751,7 @@
 8200
 7C00
 ENDCHAR
-STARTCHAR FF48
+STARTCHAR uniFF48
 ENCODING 65352
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155531,7 +159770,7 @@
 42
 E7
 ENDCHAR
-STARTCHAR FF49
+STARTCHAR uniFF49
 ENCODING 65353
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155550,7 +159789,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR FF4A
+STARTCHAR uniFF4A
 ENCODING 65354
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155572,7 +159811,7 @@
 88
 70
 ENDCHAR
-STARTCHAR FF4B
+STARTCHAR uniFF4B
 ENCODING 65355
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155591,7 +159830,7 @@
 4200
 E780
 ENDCHAR
-STARTCHAR FF4C
+STARTCHAR uniFF4C
 ENCODING 65356
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155610,7 +159849,7 @@
 20
 F8
 ENDCHAR
-STARTCHAR FF4D
+STARTCHAR uniFF4D
 ENCODING 65357
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155626,7 +159865,7 @@
 4210
 E738
 ENDCHAR
-STARTCHAR FF4E
+STARTCHAR uniFF4E
 ENCODING 65358
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155642,7 +159881,7 @@
 4100
 E380
 ENDCHAR
-STARTCHAR FF4F
+STARTCHAR uniFF4F
 ENCODING 65359
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155658,7 +159897,7 @@
 42
 3C
 ENDCHAR
-STARTCHAR FF50
+STARTCHAR uniFF50
 ENCODING 65360
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155676,7 +159915,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR FF51
+STARTCHAR uniFF51
 ENCODING 65361
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155694,7 +159933,7 @@
 02
 07
 ENDCHAR
-STARTCHAR FF52
+STARTCHAR uniFF52
 ENCODING 65362
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155709,7 +159948,7 @@
 40
 E0
 ENDCHAR
-STARTCHAR FF53
+STARTCHAR uniFF53
 ENCODING 65363
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155725,7 +159964,7 @@
 84
 78
 ENDCHAR
-STARTCHAR FF54
+STARTCHAR uniFF54
 ENCODING 65364
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155743,7 +159982,7 @@
 48
 30
 ENDCHAR
-STARTCHAR FF55
+STARTCHAR uniFF55
 ENCODING 65365
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155758,7 +159997,7 @@
 84
 7E
 ENDCHAR
-STARTCHAR FF56
+STARTCHAR uniFF56
 ENCODING 65366
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155772,7 +160011,7 @@
 18
 18
 ENDCHAR
-STARTCHAR FF57
+STARTCHAR uniFF57
 ENCODING 65367
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155786,7 +160025,7 @@
 3180
 1100
 ENDCHAR
-STARTCHAR FF58
+STARTCHAR uniFF58
 ENCODING 65368
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155801,7 +160040,7 @@
 42
 E7
 ENDCHAR
-STARTCHAR FF59
+STARTCHAR uniFF59
 ENCODING 65369
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155818,7 +160057,7 @@
 90
 60
 ENDCHAR
-STARTCHAR FF5A
+STARTCHAR uniFF5A
 ENCODING 65370
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155833,7 +160072,7 @@
 84
 FC
 ENDCHAR
-STARTCHAR FF5B
+STARTCHAR uniFF5B
 ENCODING 65371
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155856,7 +160095,7 @@
 40
 30
 ENDCHAR
-STARTCHAR FF5C
+STARTCHAR uniFF5C
 ENCODING 65372
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155876,7 +160115,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FF5D
+STARTCHAR uniFF5D
 ENCODING 65373
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155899,7 +160138,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR FF5E
+STARTCHAR uniFF5E
 ENCODING 65374
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -155910,7 +160149,7 @@
 8220
 01C0
 ENDCHAR
-STARTCHAR FF66
+STARTCHAR uniFF66
 ENCODING 65382
 SWIDTH 480 0
 DWIDTH 8 0
@@ -155930,7 +160169,7 @@
 40
 80
 ENDCHAR
-STARTCHAR FF67
+STARTCHAR uniFF67
 ENCODING 65383
 SWIDTH 480 0
 DWIDTH 8 0
@@ -155947,7 +160186,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FF68
+STARTCHAR uniFF68
 ENCODING 65384
 SWIDTH 480 0
 DWIDTH 8 0
@@ -155965,7 +160204,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF69
+STARTCHAR uniFF69
 ENCODING 65385
 SWIDTH 480 0
 DWIDTH 8 0
@@ -155981,7 +160220,7 @@
 20
 40
 ENDCHAR
-STARTCHAR FF6A
+STARTCHAR uniFF6A
 ENCODING 65386
 SWIDTH 480 0
 DWIDTH 8 0
@@ -155996,7 +160235,7 @@
 78
 80
 ENDCHAR
-STARTCHAR FF6B
+STARTCHAR uniFF6B
 ENCODING 65387
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156014,7 +160253,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF6C
+STARTCHAR uniFF6C
 ENCODING 65388
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156032,7 +160271,7 @@
 10
 10
 ENDCHAR
-STARTCHAR FF6D
+STARTCHAR uniFF6D
 ENCODING 65389
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156046,7 +160285,7 @@
 38
 C0
 ENDCHAR
-STARTCHAR FF6E
+STARTCHAR uniFF6E
 ENCODING 65390
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156062,7 +160301,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR FF6F
+STARTCHAR uniFF6F
 ENCODING 65391
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156078,7 +160317,7 @@
 40
 40
 ENDCHAR
-STARTCHAR FF70
+STARTCHAR uniFF70
 ENCODING 65392
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156086,7 +160325,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR FF71
+STARTCHAR uniFF71
 ENCODING 65393
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156104,7 +160343,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FF72
+STARTCHAR uniFF72
 ENCODING 65394
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156124,7 +160363,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF73
+STARTCHAR uniFF73
 ENCODING 65395
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156144,7 +160383,7 @@
 10
 20
 ENDCHAR
-STARTCHAR FF74
+STARTCHAR uniFF74
 ENCODING 65396
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156160,7 +160399,7 @@
 2C
 D0
 ENDCHAR
-STARTCHAR FF75
+STARTCHAR uniFF75
 ENCODING 65397
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156180,7 +160419,7 @@
 30
 10
 ENDCHAR
-STARTCHAR FF76
+STARTCHAR uniFF76
 ENCODING 65398
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156200,7 +160439,7 @@
 98
 08
 ENDCHAR
-STARTCHAR FF77
+STARTCHAR uniFF77
 ENCODING 65399
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156221,7 +160460,7 @@
 10
 10
 ENDCHAR
-STARTCHAR FF78
+STARTCHAR uniFF78
 ENCODING 65400
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156241,7 +160480,7 @@
 40
 40
 ENDCHAR
-STARTCHAR FF79
+STARTCHAR uniFF79
 ENCODING 65401
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156260,7 +160499,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF7A
+STARTCHAR uniFF7A
 ENCODING 65402
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156276,7 +160515,7 @@
 08
 F0
 ENDCHAR
-STARTCHAR FF7B
+STARTCHAR uniFF7B
 ENCODING 65403
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156296,7 +160535,7 @@
 10
 20
 ENDCHAR
-STARTCHAR FF7C
+STARTCHAR uniFF7C
 ENCODING 65404
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156314,7 +160553,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR FF7D
+STARTCHAR uniFF7D
 ENCODING 65405
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156333,7 +160572,7 @@
 84
 80
 ENDCHAR
-STARTCHAR FF7E
+STARTCHAR uniFF7E
 ENCODING 65406
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156351,7 +160590,7 @@
 20
 1C
 ENDCHAR
-STARTCHAR FF7F
+STARTCHAR uniFF7F
 ENCODING 65407
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156370,7 +160609,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FF66
+STARTCHAR uniFF80
 ENCODING 65408
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156390,7 +160629,7 @@
 40
 80
 ENDCHAR
-STARTCHAR FF67
+STARTCHAR uniFF81
 ENCODING 65409
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156407,7 +160646,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FF68
+STARTCHAR uniFF82
 ENCODING 65410
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156425,7 +160664,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF69
+STARTCHAR uniFF83
 ENCODING 65411
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156441,7 +160680,7 @@
 20
 40
 ENDCHAR
-STARTCHAR FF6A
+STARTCHAR uniFF84
 ENCODING 65412
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156456,7 +160695,7 @@
 78
 80
 ENDCHAR
-STARTCHAR FF6B
+STARTCHAR uniFF85
 ENCODING 65413
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156474,7 +160713,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF6C
+STARTCHAR uniFF86
 ENCODING 65414
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156492,7 +160731,7 @@
 10
 10
 ENDCHAR
-STARTCHAR FF6D
+STARTCHAR uniFF87
 ENCODING 65415
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156506,7 +160745,7 @@
 38
 C0
 ENDCHAR
-STARTCHAR FF6E
+STARTCHAR uniFF88
 ENCODING 65416
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156522,7 +160761,7 @@
 20
 C0
 ENDCHAR
-STARTCHAR FF6F
+STARTCHAR uniFF89
 ENCODING 65417
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156538,7 +160777,7 @@
 40
 40
 ENDCHAR
-STARTCHAR FF70
+STARTCHAR uniFF8A
 ENCODING 65418
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156546,7 +160785,7 @@
 BITMAP
 F8
 ENDCHAR
-STARTCHAR FF71
+STARTCHAR uniFF8B
 ENCODING 65419
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156564,7 +160803,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FF72
+STARTCHAR uniFF8C
 ENCODING 65420
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156584,7 +160823,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF73
+STARTCHAR uniFF8D
 ENCODING 65421
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156604,7 +160843,7 @@
 10
 20
 ENDCHAR
-STARTCHAR FF74
+STARTCHAR uniFF8E
 ENCODING 65422
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156620,7 +160859,7 @@
 2C
 D0
 ENDCHAR
-STARTCHAR FF75
+STARTCHAR uniFF8F
 ENCODING 65423
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156640,7 +160879,7 @@
 30
 10
 ENDCHAR
-STARTCHAR FF76
+STARTCHAR uniFF90
 ENCODING 65424
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156660,7 +160899,7 @@
 98
 08
 ENDCHAR
-STARTCHAR FF77
+STARTCHAR uniFF91
 ENCODING 65425
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156681,7 +160920,7 @@
 10
 10
 ENDCHAR
-STARTCHAR FF78
+STARTCHAR uniFF92
 ENCODING 65426
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156701,7 +160940,7 @@
 40
 40
 ENDCHAR
-STARTCHAR FF79
+STARTCHAR uniFF93
 ENCODING 65427
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156720,7 +160959,7 @@
 20
 20
 ENDCHAR
-STARTCHAR FF7A
+STARTCHAR uniFF94
 ENCODING 65428
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156736,7 +160975,7 @@
 08
 F0
 ENDCHAR
-STARTCHAR FF7B
+STARTCHAR uniFF95
 ENCODING 65429
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156756,7 +160995,7 @@
 10
 20
 ENDCHAR
-STARTCHAR FF7C
+STARTCHAR uniFF96
 ENCODING 65430
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156774,7 +161013,7 @@
 A0
 40
 ENDCHAR
-STARTCHAR FF7D
+STARTCHAR uniFF97
 ENCODING 65431
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156793,7 +161032,7 @@
 84
 80
 ENDCHAR
-STARTCHAR FF7E
+STARTCHAR uniFF98
 ENCODING 65432
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156811,7 +161050,7 @@
 20
 1C
 ENDCHAR
-STARTCHAR FF7F
+STARTCHAR uniFF99
 ENCODING 65433
 SWIDTH 480 0
 DWIDTH 8 0
@@ -156830,7 +161069,7 @@
 80
 80
 ENDCHAR
-STARTCHAR FFE1
+STARTCHAR uniFFE0
 ENCODING 65504
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -156850,7 +161089,7 @@
 9480
 6300
 ENDCHAR
-STARTCHAR FFE2
+STARTCHAR uniFFE1
 ENCODING 65505
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -156866,7 +161105,7 @@
 0010
 0010
 ENDCHAR
-STARTCHAR FFE3
+STARTCHAR uniFFE2
 ENCODING 65506
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -156874,7 +161113,7 @@
 BITMAP
 FFFF
 ENDCHAR
-STARTCHAR FFE4
+STARTCHAR uniFFE3
 ENCODING 65507
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -156895,7 +161134,7 @@
 80
 80
 ENDCHAR
-STARTCHAR C089
+STARTCHAR uniFFE4
 ENCODING 65508
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -156914,7 +161153,7 @@
 0400
 1F00
 ENDCHAR
-STARTCHAR FFE6
+STARTCHAR uniFFE5
 ENCODING 65509
 SWIDTH 1020 0
 DWIDTH 17 0
@@ -156933,7 +161172,7 @@
 0840
 0840
 ENDCHAR
-STARTCHAR char65533
+STARTCHAR uniFFFD
 ENCODING 65533
 SWIDTH 1080 0
 DWIDTH 18 0
Index: xc/extras/fonts/ClearlyU/cuarabic12.bdf
diff -u /dev/null xc/extras/fonts/ClearlyU/cuarabic12.bdf:1.2
--- /dev/null	Thu Feb 27 12:20:28 2003
+++ xc/extras/fonts/ClearlyU/cuarabic12.bdf	Fri Dec 13 23:00:04 2002
@@ -0,0 +1,12214 @@
+STARTFONT 2.1
+COMMENT 
+COMMENT Id: cuarabic12.bdf,v 1.6 2002/11/22 22:46:31 mleisher Exp $
+COMMENT 
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
+COMMENT 
+COMMENT Permission is hereby granted, free of charge, to any person
+COMMENT obtaining a copy of this software and associated documentation
+COMMENT files (the "Software"), to deal in the Software without
+COMMENT restriction, including without limitation the rights to use,
+COMMENT copy, modify, merge, publish, distribute, sublicense, and/or
+COMMENT sell copies of the Software, and to permit persons to whom the
+COMMENT Software is furnished to do so, subject to the following
+COMMENT conditions:
+COMMENT 
+COMMENT The above copyright notice and this permission notice shall be
+COMMENT included in all copies or substantial portions of the Software.
+COMMENT 
+COMMENT THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+COMMENT EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+COMMENT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+COMMENT NONINFRINGEMENT.  IN NO EVENT SHALL THE COMPUTING RESEARCH LAB
+COMMENT OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY CLAIM, DAMAGES
+COMMENT OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+COMMENT OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+COMMENT SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+COMMENT 
+COMMENT This font contains glyphs to support text encoded in the Arabic
+COMMENT section of Unicode.  It includes a number of alternate digits and
+COMMENT glyphs as well.
+COMMENT 
+FONT -MUTT-ClearlyU Arabic-Medium-R-Normal--17-120-100-100-P-93-ISO10646-1
+SIZE 12 100 100
+FONTBOUNDINGBOX 21 28 -1 -10
+STARTPROPERTIES 20
+COPYRIGHT "2001 Computing Research Lab, New Mexico State University."
+POINT_SIZE 120
+PIXEL_SIZE 17
+RESOLUTION_X 100
+RESOLUTION_Y 100
+FONT_ASCENT 17
+FONT_DESCENT 9
+AVERAGE_WIDTH 93
+SPACING "P"
+FOUNDRY "MUTT"
+FAMILY_NAME "ClearlyU Arabic Extra"
+WEIGHT_NAME "Medium"
+SLANT "R"
+SETWIDTH_NAME "Normal"
+ADD_STYLE_NAME ""
+CHARSET_REGISTRY "FontSpecific"
+CHARSET_ENCODING "0"
+_XMBDFED_INFO "Edited with xmbdfed 4.4."
+CAP_HEIGHT 11
+X_HEIGHT 7
+ENDPROPERTIES
+CHARS 678
+STARTCHAR 0x060C
+ENCODING 1548
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 2 4 1 0
+BITMAP
+40
+80
+C0
+C0
+ENDCHAR
+STARTCHAR 0x061B
+ENCODING 1563
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 2 7 1 0
+BITMAP
+40
+80
+C0
+C0
+00
+C0
+C0
+ENDCHAR
+STARTCHAR 0x061F
+ENCODING 1567
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 10 1 0
+BITMAP
+70
+88
+88
+40
+20
+20
+00
+00
+20
+20
+ENDCHAR
+STARTCHAR uni0621
+ENCODING 1569
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 0
+BITMAP
+70
+80
+80
+70
+C0
+80
+ENDCHAR
+STARTCHAR uni0622
+ENCODING 1570
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 6 14 0 0
+BITMAP
+04
+78
+80
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni0623
+ENCODING 1571
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 16 1 0
+BITMAP
+60
+80
+60
+80
+00
+00
+40
+60
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR uni0624
+ENCODING 1572
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+06
+08
+06
+08
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni0625
+ENCODING 1573
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 16 1 -6
+BITMAP
+40
+60
+40
+40
+40
+40
+40
+40
+40
+40
+00
+00
+60
+80
+60
+80
+ENDCHAR
+STARTCHAR uni0626
+ENCODING 1574
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 -2
+BITMAP
+1800
+2000
+1800
+2000
+0000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni0627
+ENCODING 1575
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 2 10 2 0
+BITMAP
+80
+C0
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni0628
+ENCODING 1576
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 9 0 -4
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0200
+0200
+ENDCHAR
+STARTCHAR uni0629
+ENCODING 1577
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 10 1 0
+BITMAP
+50
+50
+00
+00
+20
+30
+50
+98
+88
+78
+ENDCHAR
+STARTCHAR uni062A
+ENCODING 1578
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 8 0 -1
+BITMAP
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni062B
+ENCODING 1579
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 10 1 -1
+BITMAP
+0200
+0200
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni062C
+ENCODING 1580
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+8800
+8800
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni062D
+ENCODING 1581
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni062E
+ENCODING 1582
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 14 1 -6
+BITMAP
+0800
+0800
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni062F
+ENCODING 1583
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 6 1 0
+BITMAP
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni0630
+ENCODING 1584
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 0
+BITMAP
+20
+20
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni0631
+ENCODING 1585
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 8 1 -4
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0632
+ENCODING 1586
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -4
+BITMAP
+08
+08
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0633
+ENCODING 1587
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 8 1 -5
+BITMAP
+0112
+0112
+40EC
+8080
+8080
+8080
+4300
+3C00
+ENDCHAR
+STARTCHAR uni0634
+ENCODING 1588
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 14 1 -5
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8080
+4300
+3C00
+ENDCHAR
+STARTCHAR uni0635
+ENCODING 1589
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 9 1 -5
+BITMAP
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uni0636
+ENCODING 1590
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 12 1 -5
+BITMAP
+002000
+002000
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uni0637
+ENCODING 1591
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
+BITMAP
+20
+30
+20
+20
+20
+20
+26
+39
+21
+FE
+ENDCHAR
+STARTCHAR uni0638
+ENCODING 1592
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
+BITMAP
+20
+30
+26
+20
+20
+20
+26
+39
+21
+FE
+ENDCHAR
+STARTCHAR uni0639
+ENCODING 1593
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 -7
+BITMAP
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni063A
+ENCODING 1594
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -7
+BITMAP
+2000
+2000
+0000
+0000
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni0640
+ENCODING 1600
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 1 0 0
+BITMAP
+FF80
+ENDCHAR
+STARTCHAR uni0641
+ENCODING 1601
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 12 1 0
+BITMAP
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uni0642
+ENCODING 1602
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -3
+BITMAP
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 1603
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 10 1 0
+BITMAP
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+ENDCHAR
+STARTCHAR uni0644
+ENCODING 1604
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -2
+BITMAP
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
+ENDCHAR
+STARTCHAR uni0645
+ENCODING 1605
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 -9
+BITMAP
+40
+B0
+08
+7C
+80
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni0646
+ENCODING 1606
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 10 1 -2
+BITMAP
+10
+10
+00
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uni0647
+ENCODING 1607
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 6 1 0
+BITMAP
+20
+30
+50
+88
+88
+70
+ENDCHAR
+STARTCHAR uni0648
+ENCODING 1608
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 8 0 -3
+BITMAP
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni0649
+ENCODING 1609
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 8 0 -2
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni064A
+ENCODING 1610
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 -5
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+0000
+2800
+2800
+ENDCHAR
+STARTCHAR uni064B
+ENCODING 1611
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 4 1 10
+BITMAP
+30
+C0
+30
+C0
+ENDCHAR
+STARTCHAR uni064C
+ENCODING 1612
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 4 1 11
+BITMAP
+18
+58
+D0
+60
+ENDCHAR
+STARTCHAR uni064D
+ENCODING 1613
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 4 1 -6
+BITMAP
+30
+C0
+30
+C0
+ENDCHAR
+STARTCHAR uni064E
+ENCODING 1614
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 3 1 10
+BITMAP
+10
+60
+80
+ENDCHAR
+STARTCHAR uni064F
+ENCODING 1615
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 5 1 11
+BITMAP
+20
+50
+20
+50
+80
+ENDCHAR
+STARTCHAR uni0650
+ENCODING 1616
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 3 1 -4
+BITMAP
+10
+60
+80
+ENDCHAR
+STARTCHAR uni0651
+ENCODING 1617
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 3 1 12
+BITMAP
+08
+A8
+D0
+ENDCHAR
+STARTCHAR uni0652
+ENCODING 1618
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 4 1 11
+BITMAP
+40
+A0
+A0
+C0
+ENDCHAR
+STARTCHAR uni0653
+ENCODING 1619
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 3 1 11
+BITMAP
+04
+78
+80
+ENDCHAR
+STARTCHAR uni0654
+ENCODING 1620
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 4 1 11
+BITMAP
+60
+80
+60
+80
+ENDCHAR
+STARTCHAR uni0655
+ENCODING 1621
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 4 1 -4
+BITMAP
+60
+80
+60
+80
+ENDCHAR
+STARTCHAR uni0660
+ENCODING 1632
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 3 1 3
+BITMAP
+40
+E0
+40
+ENDCHAR
+STARTCHAR uni0661
+ENCODING 1633
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 10 1 0
+BITMAP
+C0
+C0
+C0
+E0
+60
+60
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni0662
+ENCODING 1634
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+C4
+FC
+F8
+60
+60
+60
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni0663
+ENCODING 1635
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+94
+FC
+E8
+60
+60
+60
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni0664
+ENCODING 1636
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 11 1 -1
+BITMAP
+20
+60
+C0
+80
+F0
+60
+C0
+80
+80
+F8
+70
+ENDCHAR
+STARTCHAR uni0665
+ENCODING 1637
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 8 2 1
+BITMAP
+30
+70
+58
+88
+88
+D8
+F0
+60
+ENDCHAR
+STARTCHAR uni0666
+ENCODING 1638
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 9 1 0
+BITMAP
+88
+F8
+78
+08
+08
+0C
+0C
+04
+04
+ENDCHAR
+STARTCHAR uni0667
+ENCODING 1639
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+84
+84
+CC
+C8
+68
+68
+38
+30
+10
+10
+ENDCHAR
+STARTCHAR uni0668
+ENCODING 1640
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+20
+20
+30
+70
+58
+58
+4C
+CC
+84
+84
+ENDCHAR
+STARTCHAR uni0669
+ENCODING 1641
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 10 1 0
+BITMAP
+60
+B0
+90
+F0
+50
+10
+18
+18
+08
+08
+ENDCHAR
+STARTCHAR uni066A
+ENCODING 1642
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 7 10 1 0
+BITMAP
+04
+C4
+08
+08
+10
+10
+20
+26
+40
+40
+ENDCHAR
+STARTCHAR uni066B
+ENCODING 1643
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 4 5 -1 -3
+BITMAP
+10
+10
+10
+20
+C0
+ENDCHAR
+STARTCHAR uni066C
+ENCODING 1644
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 2 5 1 0
+BITMAP
+C0
+C0
+40
+40
+80
+ENDCHAR
+STARTCHAR uni066D
+ENCODING 1645
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 6 1 5
+BITMAP
+10
+10
+FE
+38
+28
+44
+ENDCHAR
+STARTCHAR uni067A
+ENCODING 1646
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 6 0 -1
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni0642
+ENCODING 1647
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 1 -3
+BITMAP
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni0670
+ENCODING 1648
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 1 4 1 10
+BITMAP
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni0671
+ENCODING 1649
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
+BITMAP
+10
+28
+78
+80
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni0672
+ENCODING 1650
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 -1 0
+BITMAP
+18
+20
+18
+E0
+00
+10
+18
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni0673
+ENCODING 1651
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 -1 -5
+BITMAP
+10
+18
+10
+10
+10
+10
+10
+10
+10
+10
+00
+18
+20
+18
+E0
+ENDCHAR
+STARTCHAR uni0674
+ENCODING 1652
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 4 1 12
+BITMAP
+60
+80
+60
+80
+ENDCHAR
+STARTCHAR uni0675
+ENCODING 1653
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 13 2 0
+BITMAP
+0C
+10
+0C
+90
+C0
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni0676
+ENCODING 1654
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 14 0 -3
+BITMAP
+0180
+0200
+0180
+0200
+0000
+0000
+0400
+0A00
+0A00
+0E00
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uni0677
+ENCODING 1655
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 14 0 -3
+BITMAP
+1180
+2A00
+1180
+2A00
+4000
+0000
+0400
+0A00
+0A00
+0E00
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uni0678
+ENCODING 1656
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 14 1 -2
+BITMAP
+0018
+0020
+0018
+0020
+0000
+0000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni0679
+ENCODING 1657
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 9 1 -1
+BITMAP
+0400
+0400
+0700
+0708
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni067A
+ENCODING 1658
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -1
+BITMAP
+0200
+0200
+0000
+0200
+0200
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni067B
+ENCODING 1659
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 12 1 -7
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0200
+0200
+0000
+0200
+0200
+ENDCHAR
+STARTCHAR uni067C
+ENCODING 1660
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -4
+BITMAP
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+0600
+0900
+0600
+ENDCHAR
+STARTCHAR uni067D
+ENCODING 1661
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 10 1 -1
+BITMAP
+0500
+0500
+0200
+0200
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni067E
+ENCODING 1662
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 -6
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0A00
+0A00
+0400
+0400
+ENDCHAR
+STARTCHAR uni067F
+ENCODING 1663
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 -1
+BITMAP
+0500
+0500
+0000
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni0680
+ENCODING 1664
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 12 1 -7
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0500
+0500
+0000
+0500
+0500
+ENDCHAR
+STARTCHAR uni0681
+ENCODING 1665
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -6
+BITMAP
+0C00
+1000
+0C00
+1000
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0682
+ENCODING 1666
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 18 1 -6
+BITMAP
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0683
+ENCODING 1667
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+8A00
+8A00
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0684
+ENCODING 1668
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4800
+8800
+8000
+8800
+4800
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0685
+ENCODING 1669
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -6
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0686
+ENCODING 1670
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+9400
+9400
+8800
+4800
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0687
+ENCODING 1671
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4A00
+8A00
+8000
+8A00
+4A00
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0688
+ENCODING 1672
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+80
+80
+E0
+E0
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni0689
+ENCODING 1673
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 -3
+BITMAP
+10
+10
+08
+08
+98
+60
+20
+50
+20
+ENDCHAR
+STARTCHAR uni068A
+ENCODING 1674
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 -4
+BITMAP
+10
+10
+08
+08
+98
+60
+00
+00
+20
+20
+ENDCHAR
+STARTCHAR uni068B
+ENCODING 1675
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 16 1 -4
+BITMAP
+40
+40
+70
+70
+00
+00
+10
+10
+08
+08
+98
+60
+00
+00
+20
+20
+ENDCHAR
+STARTCHAR uni068C
+ENCODING 1676
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 0
+BITMAP
+50
+50
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni068D
+ENCODING 1677
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 -3
+BITMAP
+10
+10
+08
+08
+98
+60
+00
+50
+50
+ENDCHAR
+STARTCHAR uni068E
+ENCODING 1678
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+20
+20
+50
+50
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni068F
+ENCODING 1679
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+50
+50
+20
+20
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni0690
+ENCODING 1680
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 1 0
+BITMAP
+50
+50
+00
+50
+50
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni0691
+ENCODING 1681
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -4
+BITMAP
+20
+20
+38
+38
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0692
+ENCODING 1682
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 13 1 -4
+BITMAP
+22
+14
+08
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0693
+ENCODING 1683
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 9 1 -5
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F4
+0C
+ENDCHAR
+STARTCHAR uni0694
+ENCODING 1684
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 -6
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F0
+04
+04
+ENDCHAR
+STARTCHAR uni0695
+ENCODING 1685
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -8
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F0
+00
+44
+28
+10
+ENDCHAR
+STARTCHAR uni0696
+ENCODING 1686
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 -6
+BITMAP
+08
+08
+04
+44
+44
+0C
+18
+F0
+04
+04
+ENDCHAR
+STARTCHAR uni0697
+ENCODING 1687
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -4
+BITMAP
+14
+14
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0698
+ENCODING 1688
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -4
+BITMAP
+08
+08
+14
+14
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0699
+ENCODING 1689
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -4
+BITMAP
+14
+14
+00
+14
+14
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni069A
+ENCODING 1690
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 12 1 -5
+BITMAP
+0010
+0010
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8088
+4308
+3C00
+ENDCHAR
+STARTCHAR uni069B
+ENCODING 1691
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 9 1 -6
+BITMAP
+0112
+0112
+40EC
+8080
+8080
+8094
+4314
+3C08
+0008
+ENDCHAR
+STARTCHAR uni069C
+ENCODING 1692
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 15 1 -6
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8094
+4314
+3C08
+0008
+ENDCHAR
+STARTCHAR uni069D
+ENCODING 1693
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 9 1 -5
+BITMAP
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808A00
+430A00
+3C0000
+ENDCHAR
+STARTCHAR uni069E
+ENCODING 1694
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -5
+BITMAP
+001000
+001000
+002800
+002800
+000000
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uni069F
+ENCODING 1695
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
+BITMAP
+22
+32
+25
+25
+20
+20
+26
+39
+21
+FE
+ENDCHAR
+STARTCHAR uni06A0
+ENCODING 1696
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 18 1 -7
+BITMAP
+1000
+1000
+2800
+2800
+0000
+0000
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni06A1
+ENCODING 1697
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 8 1 0
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uni06A2
+ENCODING 1698
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 12 1 -4
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0000
+0100
+0100
+ENDCHAR
+STARTCHAR uni06A3
+ENCODING 1699
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 16 1 -4
+BITMAP
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0000
+0100
+0100
+ENDCHAR
+STARTCHAR uni06A4
+ENCODING 1700
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 14 1 0
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uni06A5
+ENCODING 1701
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 1 -5
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0028
+0028
+0010
+0010
+ENDCHAR
+STARTCHAR uni06A6
+ENCODING 1702
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+0028
+0028
+0000
+0028
+0028
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uni06A7
+ENCODING 1703
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -3
+BITMAP
+0200
+0200
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni06A8
+ENCODING 1704
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -3
+BITMAP
+0200
+0200
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni06A9
+ENCODING 1705
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 14 1 -1
+BITMAP
+0010
+0060
+0180
+0210
+0060
+0180
+0200
+0200
+0100
+40C0
+8020
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni06AA
+ENCODING 1706
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 9 1 0
+BITMAP
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+8004
+7FF8
+ENDCHAR
+STARTCHAR uni06AB
+ENCODING 1707
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 11 1 -1
+BITMAP
+0010
+0060
+01D0
+0250
+0220
+0100
+40C0
+8020
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 1708
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 1 0
+BITMAP
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 1709
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0400
+0400
+0A00
+0A00
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 1710
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 16 1 -6
+BITMAP
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+0000
+0000
+0A00
+0A00
+0400
+0400
+ENDCHAR
+STARTCHAR uni06AF
+ENCODING 1711
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 15 1 -1
+BITMAP
+0010
+0060
+0180
+0210
+0060
+0180
+0200
+0200
+0100
+00C0
+4020
+8010
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni06B0
+ENCODING 1712
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 14 1 -1
+BITMAP
+0010
+0060
+0180
+0210
+0060
+01D0
+0250
+0220
+0100
+40C0
+8020
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni06B1
+ENCODING 1713
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 16 1 -1
+BITMAP
+0040
+0140
+0110
+0060
+0180
+0210
+0060
+0180
+0200
+0200
+0100
+40C0
+8020
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni06B2
+ENCODING 1714
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 18 1 -5
+BITMAP
+0010
+0060
+0180
+0210
+0060
+0180
+0200
+0200
+0100
+40C0
+8020
+8010
+8060
+7F80
+0000
+0000
+0A00
+0A00
+ENDCHAR
+STARTCHAR uni06B3
+ENCODING 1715
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 20 1 -7
+BITMAP
+0010
+0060
+0180
+0210
+0060
+0180
+0200
+0200
+0100
+40C0
+8020
+8010
+8060
+7F80
+0000
+0400
+0400
+0000
+0400
+0400
+ENDCHAR
+STARTCHAR uni06B4
+ENCODING 1716
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 12 18 1 -1
+BITMAP
+0100
+0100
+0040
+0140
+0110
+0060
+0180
+0210
+0060
+0180
+0200
+0200
+0100
+40C0
+8020
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni06B5
+ENCODING 1717
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -2
+BITMAP
+0880
+0500
+0200
+0000
+0000
+0200
+0300
+0200
+0200
+0200
+0200
+0200
+4200
+8200
+8200
+8400
+7800
+ENDCHAR
+STARTCHAR uni06B6
+ENCODING 1718
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 16 1 -2
+BITMAP
+02
+02
+00
+00
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
+ENDCHAR
+STARTCHAR uni06B7
+ENCODING 1719
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 18 1 -2
+BITMAP
+02
+02
+05
+05
+00
+00
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
+ENDCHAR
+STARTCHAR uni06BA
+ENCODING 1722
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 7 1 -2
+BITMAP
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uni06BB
+ENCODING 1723
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 -2
+BITMAP
+20
+20
+38
+38
+00
+00
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uni06BC
+ENCODING 1724
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 -3
+BITMAP
+1000
+1000
+0000
+0200
+0200
+4100
+8100
+8100
+8300
+7E80
+0380
+ENDCHAR
+STARTCHAR uni06BD
+ENCODING 1725
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 1 -2
+BITMAP
+08
+08
+14
+14
+00
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uni06BE
+ENCODING 1726
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 6 1 -1
+BITMAP
+38
+4E
+49
+59
+26
+C0
+ENDCHAR
+STARTCHAR uni06C0
+ENCODING 1728
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 11 1 0
+BITMAP
+30
+40
+30
+40
+00
+20
+30
+50
+98
+88
+78
+ENDCHAR
+STARTCHAR uni06C1
+ENCODING 1729
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 4 1 0
+BITMAP
+30
+78
+8C
+04
+ENDCHAR
+STARTCHAR uni06C2
+ENCODING 1730
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 10 1 0
+BITMAP
+18
+20
+18
+20
+00
+00
+30
+78
+8C
+04
+ENDCHAR
+STARTCHAR uni06C3
+ENCODING 1731
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 6 8 1 0
+BITMAP
+28
+28
+00
+00
+30
+78
+8C
+04
+ENDCHAR
+STARTCHAR uni06C4
+ENCODING 1732
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 8 0 -3
+BITMAP
+04
+0A
+0A
+0E
+12
+2A
+94
+78
+ENDCHAR
+STARTCHAR uni06C5
+ENCODING 1733
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 8 0 -3
+BITMAP
+04
+0A
+0A
+0E
+02
+3E
+84
+78
+ENDCHAR
+STARTCHAR uni06C6
+ENCODING 1734
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 -3
+BITMAP
+11
+0A
+04
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni06C7
+ENCODING 1735
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+04
+0A
+04
+0A
+10
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni06C8
+ENCODING 1736
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+04
+04
+04
+04
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni06C9
+ENCODING 1737
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 -3
+BITMAP
+04
+0A
+11
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni06CA
+ENCODING 1738
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 0 -3
+BITMAP
+0A
+0A
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni06CB
+ENCODING 1739
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+04
+04
+0A
+0A
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni06CC
+ENCODING 1740
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 8 1 -2
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni06CD
+ENCODING 1741
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 8 0 -2
+BITMAP
+0078
+0080
+1080
+2060
+6010
+A010
+1060
+0F80
+ENDCHAR
+STARTCHAR uni06CE
+ENCODING 1742
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 -2
+BITMAP
+4400
+2800
+1000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni06D0
+ENCODING 1744
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 -8
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+0000
+0800
+0800
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uni06D1
+ENCODING 1745
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -7
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+0000
+2800
+2800
+1000
+1000
+ENDCHAR
+STARTCHAR uni06D2
+ENCODING 1746
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 8 1 -4
+BITMAP
+0200
+0500
+0500
+1800
+6000
+8000
+8000
+7FF8
+ENDCHAR
+STARTCHAR uni06D3
+ENCODING 1747
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 1 -4
+BITMAP
+3000
+4000
+3000
+4200
+0500
+0500
+1800
+6000
+8000
+8000
+7FF8
+ENDCHAR
+STARTCHAR uni06D4
+ENCODING 1748
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 5 1 1 3
+BITMAP
+F8
+ENDCHAR
+STARTCHAR uni06D5
+ENCODING 1749
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 0
+BITMAP
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR char1750
+ENCODING 1750
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 10 7 1 10
+BITMAP
+2000
+2000
+2180
+2A40
+5780
+8000
+7E00
+ENDCHAR
+STARTCHAR char1750
+ENCODING 1751
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 8 1 10
+BITMAP
+0A
+20
+24
+2A
+26
+5C
+80
+7E
+ENDCHAR
+STARTCHAR char1752
+ENCODING 1752
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 4 1 10
+BITMAP
+20
+50
+60
+80
+ENDCHAR
+STARTCHAR char1753
+ENCODING 1753
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 6 1 10
+BITMAP
+90
+50
+50
+30
+60
+60
+ENDCHAR
+STARTCHAR char1754
+ENCODING 1754
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 8 1 10
+BITMAP
+60
+9C
+20
+40
+48
+40
+42
+3C
+ENDCHAR
+STARTCHAR char1755
+ENCODING 1755
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 3 1 10
+BITMAP
+40
+00
+A0
+ENDCHAR
+STARTCHAR char1756
+ENCODING 1756
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 9 4 1 10
+BITMAP
+0A80
+4D00
+8800
+7000
+ENDCHAR
+STARTCHAR C095
+ENCODING 1759
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 3 1 10
+BITMAP
+40
+E0
+40
+ENDCHAR
+STARTCHAR C095
+ENCODING 1760
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 2 3 1 10
+BITMAP
+C0
+C0
+C0
+ENDCHAR
+STARTCHAR char1754
+ENCODING 1761
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 3 1 14
+BITMAP
+60
+10
+F8
+ENDCHAR
+STARTCHAR char1754
+ENCODING 1762
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 8 1 10
+BITMAP
+40
+20
+70
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR char1756
+ENCODING 1763
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 9 4 1 -5
+BITMAP
+0A80
+4D00
+8800
+7000
+ENDCHAR
+STARTCHAR char1764
+ENCODING 1764
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 2 1 10
+BITMAP
+48
+B0
+ENDCHAR
+STARTCHAR char1765
+ENCODING 1765
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 4
+BITMAP
+20
+50
+30
+10
+20
+C0
+ENDCHAR
+STARTCHAR char1765
+ENCODING 1766
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 5 1 4
+BITMAP
+1000
+2800
+4000
+8000
+FF80
+ENDCHAR
+STARTCHAR char1765
+ENCODING 1767
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 9 5 1 10
+BITMAP
+1000
+2800
+4000
+8000
+FF80
+ENDCHAR
+STARTCHAR char1768
+ENCODING 1768
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 5 1 10
+BITMAP
+40
+10
+90
+90
+60
+ENDCHAR
+STARTCHAR char1770
+ENCODING 1770
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 5 1 -6
+BITMAP
+20
+50
+88
+50
+20
+ENDCHAR
+STARTCHAR char1770
+ENCODING 1771
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 5 1 10
+BITMAP
+20
+50
+88
+50
+20
+ENDCHAR
+STARTCHAR C095
+ENCODING 1772
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 3 3 1 10
+BITMAP
+40
+E0
+40
+ENDCHAR
+STARTCHAR char1754
+ENCODING 1773
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 8 1 -9
+BITMAP
+40
+20
+70
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni06F0
+ENCODING 1776
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 3 1 3
+BITMAP
+40
+E0
+40
+ENDCHAR
+STARTCHAR uni06F1
+ENCODING 1777
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 10 1 0
+BITMAP
+C0
+C0
+C0
+E0
+60
+60
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni06F2
+ENCODING 1778
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+C4
+FC
+F8
+60
+60
+60
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni06F3
+ENCODING 1779
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+94
+FC
+E8
+60
+60
+60
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni06F4
+ENCODING 1780
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+98
+FC
+C0
+64
+7C
+78
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni06F5
+ENCODING 1781
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+20
+30
+70
+58
+58
+8C
+84
+94
+FC
+68
+ENDCHAR
+STARTCHAR uni06F6
+ENCODING 1782
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+30
+78
+C0
+C4
+78
+30
+60
+C0
+80
+80
+ENDCHAR
+STARTCHAR uni06F7
+ENCODING 1783
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+84
+84
+CC
+C8
+68
+68
+38
+30
+10
+10
+ENDCHAR
+STARTCHAR uni06F8
+ENCODING 1784
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 6 10 1 0
+BITMAP
+20
+20
+30
+70
+58
+58
+4C
+CC
+84
+84
+ENDCHAR
+STARTCHAR uni06F9
+ENCODING 1785
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 10 1 0
+BITMAP
+60
+B0
+90
+F0
+50
+10
+18
+18
+08
+08
+ENDCHAR
+STARTCHAR uni06FA
+ENCODING 1786
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 14 1 -5
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8088
+4308
+3C00
+ENDCHAR
+STARTCHAR uni06FB
+ENCODING 1787
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 12 1 -5
+BITMAP
+002000
+002000
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808400
+430400
+3C0000
+ENDCHAR
+STARTCHAR uni06FC
+ENCODING 1788
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -7
+BITMAP
+2000
+2000
+0000
+0000
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8800
+8800
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni06FD
+ENCODING 1789
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 13 1 0
+BITMAP
+70
+80
+80
+70
+C0
+80
+00
+50
+50
+50
+50
+50
+50
+ENDCHAR
+STARTCHAR uni06FE
+ENCODING 1790
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 -1
+BITMAP
+40
+B0
+08
+7C
+80
+80
+94
+94
+94
+94
+94
+94
+80
+ENDCHAR
+STARTCHAR uni0000
+ENCODING 58880
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 -1 0
+BITMAP
+18
+20
+18
+E0
+00
+10
+18
+10
+10
+10
+10
+10
+10
+10
+10
+ENDCHAR
+STARTCHAR uni0001
+ENCODING 58881
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 6 16 -1 0
+BITMAP
+18
+20
+18
+E0
+00
+00
+10
+18
+10
+10
+10
+10
+10
+10
+10
+0C
+ENDCHAR
+STARTCHAR uni0002
+ENCODING 58882
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 -1 -5
+BITMAP
+10
+18
+10
+10
+10
+10
+10
+10
+10
+10
+00
+18
+20
+18
+E0
+ENDCHAR
+STARTCHAR uni0003
+ENCODING 58883
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 6 16 -1 -6
+BITMAP
+10
+18
+10
+10
+10
+10
+10
+10
+10
+0C
+00
+00
+18
+20
+18
+E0
+ENDCHAR
+STARTCHAR uni0004
+ENCODING 58884
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 13 2 0
+BITMAP
+0C
+10
+0C
+90
+C0
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni0005
+ENCODING 58885
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 13 2 0
+BITMAP
+0C
+10
+8C
+90
+C0
+80
+80
+80
+80
+80
+80
+80
+60
+ENDCHAR
+STARTCHAR uni0006
+ENCODING 58886
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 14 0 -3
+BITMAP
+0180
+0200
+0180
+0200
+0000
+0000
+0400
+0A00
+0A00
+0E00
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uni0007
+ENCODING 58887
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
+BITMAP
+0180
+0200
+0180
+0200
+0000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uni0008
+ENCODING 58888
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 14 1 -2
+BITMAP
+0018
+0020
+0018
+0020
+0000
+0000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni0009
+ENCODING 58889
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 12 1 -5
+BITMAP
+0018
+0020
+0018
+0020
+0000
+0000
+41E0
+8200
+8180
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni000A
+ENCODING 58890
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 0 0
+BITMAP
+06
+08
+06
+08
+00
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uni000B
+ENCODING 58891
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 7 10 0 0
+BITMAP
+06
+08
+06
+08
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uni000C
+ENCODING 58892
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -4
+BITMAP
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+0600
+0900
+0600
+ENDCHAR
+STARTCHAR uni000D
+ENCODING 58893
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 1 -4
+BITMAP
+0500
+0500
+0000
+4000
+8010
+8010
+C07E
+7F80
+0600
+0900
+0600
+ENDCHAR
+STARTCHAR uni000E
+ENCODING 58894
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -3
+BITMAP
+28
+28
+00
+10
+08
+08
+08
+F0
+60
+90
+60
+ENDCHAR
+STARTCHAR uni000F
+ENCODING 58895
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 -3
+BITMAP
+28
+28
+00
+10
+10
+10
+FC
+60
+90
+60
+ENDCHAR
+STARTCHAR uni0010
+ENCODING 58896
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 10 1 -1
+BITMAP
+0500
+0500
+0200
+0200
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uni0011
+ENCODING 58897
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 10 1 -1
+BITMAP
+0500
+0500
+0200
+0200
+0000
+4000
+8010
+8010
+C07E
+7F80
+ENDCHAR
+STARTCHAR uni0012
+ENCODING 58898
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 0 0
+BITMAP
+28
+28
+10
+10
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uni0013
+ENCODING 58899
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 0
+BITMAP
+28
+28
+10
+10
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uni0014
+ENCODING 58900
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -6
+BITMAP
+0C00
+1000
+0C00
+1000
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0015
+ENCODING 58901
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 17 1 -6
+BITMAP
+0600
+0800
+0600
+0800
+0000
+0000
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 58902
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 0 0
+BITMAP
+0300
+0400
+0300
+0400
+0000
+0000
+3800
+4600
+0100
+FF80
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 58903
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 0 0
+BITMAP
+0300
+0400
+0300
+0400
+0000
+0000
+3800
+4600
+0100
+FFC0
+ENDCHAR
+STARTCHAR uni0018
+ENCODING 58904
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 18 1 -6
+BITMAP
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0019
+ENCODING 58905
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 18 1 -6
+BITMAP
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 58906
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 0 0
+BITMAP
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+3800
+4600
+0100
+FF80
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 58907
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 0
+BITMAP
+0800
+0800
+0000
+0800
+0800
+0000
+0000
+3800
+4600
+0100
+FFC0
+ENDCHAR
+STARTCHAR uni001C
+ENCODING 58908
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -6
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni001D
+ENCODING 58909
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 17 1 -6
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0000
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 58910
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 0 0
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0000
+3800
+4600
+0100
+FF80
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 58911
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 1 0
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0000
+3800
+4600
+0100
+FFC0
+ENDCHAR
+STARTCHAR uni0020
+ENCODING 58912
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 -3
+BITMAP
+10
+10
+08
+08
+98
+60
+20
+50
+20
+ENDCHAR
+STARTCHAR uni0021
+ENCODING 58913
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 9 1 -2
+BITMAP
+10
+10
+08
+08
+08
+98
+66
+50
+20
+ENDCHAR
+STARTCHAR uni0022
+ENCODING 58914
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 -4
+BITMAP
+10
+10
+08
+08
+98
+60
+00
+00
+20
+20
+ENDCHAR
+STARTCHAR uni0023
+ENCODING 58915
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 1 -4
+BITMAP
+10
+10
+08
+08
+08
+98
+66
+00
+00
+20
+20
+ENDCHAR
+STARTCHAR uni0024
+ENCODING 58916
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 16 1 -4
+BITMAP
+40
+40
+70
+70
+00
+00
+10
+10
+08
+08
+98
+60
+00
+00
+20
+20
+ENDCHAR
+STARTCHAR uni0025
+ENCODING 58917
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 17 1 -4
+BITMAP
+40
+40
+70
+70
+00
+00
+10
+10
+08
+08
+08
+98
+66
+00
+00
+20
+20
+ENDCHAR
+STARTCHAR uni0026
+ENCODING 58918
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+50
+50
+20
+20
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni0027
+ENCODING 58919
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 13 1 0
+BITMAP
+50
+50
+20
+20
+00
+00
+10
+10
+08
+08
+08
+98
+66
+ENDCHAR
+STARTCHAR uni0028
+ENCODING 58920
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 1 0
+BITMAP
+50
+50
+00
+50
+50
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uni0029
+ENCODING 58921
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 14 1 0
+BITMAP
+50
+50
+00
+50
+50
+00
+00
+10
+10
+08
+08
+08
+98
+66
+ENDCHAR
+STARTCHAR uni002A
+ENCODING 58922
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 13 1 -4
+BITMAP
+22
+14
+08
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni002B
+ENCODING 58923
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 1 -5
+BITMAP
+22
+14
+08
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni002C
+ENCODING 58924
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 9 1 -5
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F4
+0C
+ENDCHAR
+STARTCHAR uni002D
+ENCODING 58925
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 9 1 -6
+BITMAP
+08
+0C
+07
+04
+04
+0C
+18
+F4
+0C
+ENDCHAR
+STARTCHAR uni002E
+ENCODING 58926
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 -6
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F0
+04
+04
+ENDCHAR
+STARTCHAR uni002F
+ENCODING 58927
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 -7
+BITMAP
+08
+0C
+07
+04
+04
+0C
+18
+F0
+04
+04
+ENDCHAR
+STARTCHAR uni0030
+ENCODING 58928
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -8
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F0
+00
+44
+28
+10
+ENDCHAR
+STARTCHAR uni0031
+ENCODING 58929
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -9
+BITMAP
+08
+0C
+07
+04
+04
+0C
+18
+F0
+00
+44
+28
+10
+ENDCHAR
+STARTCHAR uni0032
+ENCODING 58930
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 -6
+BITMAP
+08
+08
+04
+44
+44
+0C
+18
+F0
+04
+04
+ENDCHAR
+STARTCHAR uni0033
+ENCODING 58931
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 -7
+BITMAP
+08
+0C
+07
+44
+44
+0C
+18
+F0
+04
+04
+ENDCHAR
+STARTCHAR uni0034
+ENCODING 58932
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -4
+BITMAP
+14
+14
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0035
+ENCODING 58933
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -5
+BITMAP
+14
+14
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0036
+ENCODING 58934
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 15 1 -4
+BITMAP
+14
+14
+00
+14
+14
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0037
+ENCODING 58935
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 -5
+BITMAP
+14
+14
+00
+14
+14
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uni0038
+ENCODING 58936
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 12 1 -5
+BITMAP
+0010
+0010
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8088
+4308
+3C00
+ENDCHAR
+STARTCHAR uni0039
+ENCODING 58937
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 12 1 -5
+BITMAP
+001000
+001000
+000000
+000000
+011200
+011200
+40FF80
+808000
+808000
+808800
+430800
+3C0000
+ENDCHAR
+STARTCHAR uni003A
+ENCODING 58938
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 0 -4
+BITMAP
+0100
+0100
+0000
+0000
+1120
+1120
+FFE0
+0000
+0000
+0080
+0080
+ENDCHAR
+STARTCHAR uni003B
+ENCODING 58939
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -4
+BITMAP
+0100
+0100
+0000
+0000
+1120
+1120
+FFF8
+0000
+0000
+0080
+0080
+ENDCHAR
+STARTCHAR uni003C
+ENCODING 58940
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 9 1 -6
+BITMAP
+0112
+0112
+40EC
+8080
+8080
+8094
+4314
+3C08
+0008
+ENDCHAR
+STARTCHAR uni003D
+ENCODING 58941
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 9 1 -6
+BITMAP
+011200
+011200
+40FF80
+808000
+808000
+809400
+431400
+3C0800
+000800
+ENDCHAR
+STARTCHAR uni003E
+ENCODING 58942
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 9 0 -6
+BITMAP
+1120
+1120
+FFE0
+0000
+0000
+0280
+0280
+0100
+0100
+ENDCHAR
+STARTCHAR uni003F
+ENCODING 58943
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 9 0 -6
+BITMAP
+1120
+1120
+FFF8
+0000
+0000
+0280
+0280
+0100
+0100
+ENDCHAR
+STARTCHAR uni0040
+ENCODING 58944
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 15 1 -6
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8094
+4314
+3C08
+0008
+ENDCHAR
+STARTCHAR uni0041
+ENCODING 58945
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 15 1 -6
+BITMAP
+001000
+001000
+002800
+002800
+000000
+000000
+011200
+011200
+40FF80
+808000
+808000
+809400
+431400
+3C0800
+000800
+ENDCHAR
+STARTCHAR uni0042
+ENCODING 58946
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 15 0 -6
+BITMAP
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFE0
+0000
+0000
+0280
+0280
+0100
+0100
+ENDCHAR
+STARTCHAR uni0043
+ENCODING 58947
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 15 0 -6
+BITMAP
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFF8
+0000
+0000
+0280
+0280
+0100
+0100
+ENDCHAR
+STARTCHAR uni0044
+ENCODING 58948
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 9 1 -5
+BITMAP
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808A00
+430A00
+3C0000
+ENDCHAR
+STARTCHAR uni0045
+ENCODING 58949
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 9 1 -5
+BITMAP
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808A00
+430A00
+3C0000
+ENDCHAR
+STARTCHAR uni0046
+ENCODING 58950
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 8 0 -4
+BITMAP
+0070
+2188
+2208
+FFF0
+0000
+0000
+0140
+0140
+ENDCHAR
+STARTCHAR uni0047
+ENCODING 58951
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 8 0 -4
+BITMAP
+00E0
+2310
+2410
+FFF8
+0000
+0000
+0280
+0280
+ENDCHAR
+STARTCHAR uni0048
+ENCODING 58952
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 15 1 -5
+BITMAP
+001000
+001000
+002800
+002800
+000000
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uni0049
+ENCODING 58953
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 15 1 -5
+BITMAP
+001000
+001000
+002800
+002800
+000000
+000000
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uni004A
+ENCODING 58954
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 10 0 0
+BITMAP
+0100
+0100
+0280
+0280
+0000
+0000
+0070
+2188
+2208
+FFF0
+ENDCHAR
+STARTCHAR uni004B
+ENCODING 58955
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 10 0 0
+BITMAP
+0200
+0200
+0500
+0500
+0000
+0000
+00E0
+2310
+2410
+FFF8
+ENDCHAR
+STARTCHAR uni004C
+ENCODING 58956
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
+BITMAP
+22
+32
+25
+25
+20
+20
+2E
+31
+21
+FE
+ENDCHAR
+STARTCHAR uni004D
+ENCODING 58957
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 1 0
+BITMAP
+2200
+3200
+2500
+2500
+2000
+2000
+2E00
+3100
+2100
+FFC0
+ENDCHAR
+STARTCHAR uni004E
+ENCODING 58958
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 0 0
+BITMAP
+22
+32
+25
+25
+20
+20
+2E
+31
+21
+FE
+ENDCHAR
+STARTCHAR uni004F
+ENCODING 58959
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 0 0
+BITMAP
+2200
+3200
+2500
+2500
+2000
+2000
+2E00
+3100
+2100
+FFC0
+ENDCHAR
+STARTCHAR uni0050
+ENCODING 58960
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 18 1 -7
+BITMAP
+1000
+1000
+2800
+2800
+0000
+0000
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni0051
+ENCODING 58961
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 17 1 -6
+BITMAP
+1000
+1000
+2800
+2800
+0000
+0000
+3800
+6C00
+1000
+3800
+4780
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni0052
+ENCODING 58962
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 0 0
+BITMAP
+08
+08
+14
+14
+00
+00
+1C
+20
+40
+22
+FC
+ENDCHAR
+STARTCHAR uni0053
+ENCODING 58963
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 11 0 0
+BITMAP
+08
+08
+14
+14
+00
+00
+1C
+36
+08
+1C
+E3
+ENDCHAR
+STARTCHAR uni0054
+ENCODING 58964
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 8 1 0
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uni0055
+ENCODING 58965
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 8 1 -1
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+ENDCHAR
+STARTCHAR uni0056
+ENCODING 58966
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 7 0 0
+BITMAP
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uni0057
+ENCODING 58967
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 6 0 0
+BITMAP
+18
+24
+24
+18
+18
+E7
+ENDCHAR
+STARTCHAR uni0058
+ENCODING 58968
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 12 1 -4
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0000
+0100
+0100
+ENDCHAR
+STARTCHAR uni0059
+ENCODING 58969
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 12 1 -5
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+0000
+0000
+0100
+0100
+ENDCHAR
+STARTCHAR uni005A
+ENCODING 58970
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -4
+BITMAP
+30
+58
+48
+58
+28
+08
+F0
+00
+00
+80
+80
+ENDCHAR
+STARTCHAR uni005B
+ENCODING 58971
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 -4
+BITMAP
+18
+24
+24
+18
+18
+E7
+00
+00
+40
+40
+ENDCHAR
+STARTCHAR uni005C
+ENCODING 58972
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 16 1 -4
+BITMAP
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0000
+0100
+0100
+ENDCHAR
+STARTCHAR uni005D
+ENCODING 58973
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 16 1 -5
+BITMAP
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+403F
+3FC0
+0000
+0000
+0100
+0100
+ENDCHAR
+STARTCHAR uni005E
+ENCODING 58974
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 15 0 -4
+BITMAP
+20
+20
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+00
+00
+80
+80
+ENDCHAR
+STARTCHAR uni005F
+ENCODING 58975
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 14 0 -4
+BITMAP
+08
+08
+00
+00
+18
+24
+24
+18
+18
+E7
+00
+00
+40
+40
+ENDCHAR
+STARTCHAR uni0060
+ENCODING 58976
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 13 1 -5
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+0000
+0028
+0028
+0010
+0010
+ENDCHAR
+STARTCHAR uni0061
+ENCODING 58977
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 13 1 -6
+BITMAP
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+0000
+0028
+0028
+0010
+0010
+ENDCHAR
+STARTCHAR uni0062
+ENCODING 58978
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 0 -6
+BITMAP
+30
+58
+48
+58
+28
+08
+F0
+00
+00
+50
+50
+20
+20
+ENDCHAR
+STARTCHAR uni0063
+ENCODING 58979
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 0 -6
+BITMAP
+18
+24
+24
+18
+18
+E7
+00
+00
+28
+28
+10
+10
+ENDCHAR
+STARTCHAR uni0064
+ENCODING 58980
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -3
+BITMAP
+0200
+0200
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni0065
+ENCODING 58981
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 -5
+BITMAP
+0200
+0200
+0000
+0000
+0300
+0580
+0480
+0480
+43E0
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni0066
+ENCODING 58982
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 11 0 0
+BITMAP
+20
+20
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uni0067
+ENCODING 58983
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 0
+BITMAP
+10
+10
+00
+00
+18
+24
+24
+28
+10
+FF
+ENDCHAR
+STARTCHAR uni0068
+ENCODING 58984
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -3
+BITMAP
+0200
+0200
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni0069
+ENCODING 58985
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 16 1 -5
+BITMAP
+0200
+0200
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+43E0
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uni006A
+ENCODING 58986
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 13 0 0
+BITMAP
+20
+20
+50
+50
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uni006B
+ENCODING 58987
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 0 0
+BITMAP
+10
+10
+28
+28
+00
+00
+18
+24
+24
+28
+10
+FF
+ENDCHAR
+STARTCHAR uni006C
+ENCODING 58988
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 14 9 0 0
+BITMAP
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+8004
+7FF8
+ENDCHAR
+STARTCHAR uni006D
+ENCODING 58989
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 16 9 1 0
+BITMAP
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+8004
+7FFF
+ENDCHAR
+STARTCHAR uni006E
+ENCODING 58990
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 9 0 0
+BITMAP
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+0004
+FFF8
+ENDCHAR
+STARTCHAR uni006F
+ENCODING 58991
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 9 0 0
+BITMAP
+0180
+0600
+1800
+2000
+2000
+1FF8
+0004
+0004
+FFFF
+ENDCHAR
+STARTCHAR uni0070
+ENCODING 58992
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 -1
+BITMAP
+0008
+0030
+00E8
+0128
+0110
+0080
+4060
+8010
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni0071
+ENCODING 58993
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 10 1 0
+BITMAP
+0008
+0030
+00E8
+0128
+0110
+4080
+8060
+8010
+8010
+7FFE
+ENDCHAR
+STARTCHAR uni0072
+ENCODING 58994
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 0 0
+BITMAP
+01
+06
+1D
+25
+22
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uni0073
+ENCODING 58995
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 0 0
+BITMAP
+0080
+0300
+0E80
+1280
+1100
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 58996
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 13 1 0
+BITMAP
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 58997
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 1 0
+BITMAP
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7FE0
+ENDCHAR
+STARTCHAR uni0076
+ENCODING 58998
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 13 0 0
+BITMAP
+08
+08
+00
+01
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uni0077
+ENCODING 58999
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+0400
+0400
+0000
+0080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uni0079
+ENCODING 59000
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 19 1 -6
+BITMAP
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+0000
+0000
+1400
+1400
+0800
+0800
+ENDCHAR
+STARTCHAR uni0079
+ENCODING 59001
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 19 1 -6
+BITMAP
+0400
+0400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7FE0
+0000
+0000
+1400
+1400
+0800
+0800
+ENDCHAR
+STARTCHAR uni007A
+ENCODING 59002
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 19 0 -6
+BITMAP
+08
+08
+00
+01
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+00
+00
+50
+50
+20
+20
+ENDCHAR
+STARTCHAR uni007B
+ENCODING 59003
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 19 0 -6
+BITMAP
+0400
+0400
+0000
+0080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+0000
+0000
+2800
+2800
+1000
+1000
+ENDCHAR
+STARTCHAR uni007C
+ENCODING 59004
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 14 1 -1
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00E8
+0128
+0110
+0080
+4060
+8010
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni007D
+ENCODING 59005
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 13 1 0
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00E8
+0128
+0110
+4080
+8060
+8010
+8010
+7FFE
+ENDCHAR
+STARTCHAR uni007E
+ENCODING 59006
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 0
+BITMAP
+01
+06
+18
+21
+07
+1D
+25
+22
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uni007F
+ENCODING 59007
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+0080
+0300
+0C00
+1080
+0300
+0E80
+1280
+1100
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uni0080
+ENCODING 59008
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 18 1 -5
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+C060
+7F80
+0000
+0000
+0500
+0500
+ENDCHAR
+STARTCHAR uni0081
+ENCODING 59009
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 17 1 -4
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
+0000
+0000
+0500
+0500
+ENDCHAR
+STARTCHAR uni0082
+ENCODING 59010
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 17 0 -4
+BITMAP
+01
+06
+18
+21
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+00
+00
+50
+50
+ENDCHAR
+STARTCHAR uni0083
+ENCODING 59011
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 17 0 -4
+BITMAP
+0080
+0300
+0C00
+1080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+0000
+0000
+2800
+2800
+ENDCHAR
+STARTCHAR uni0084
+ENCODING 59012
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 18 1 -1
+BITMAP
+0080
+0080
+0020
+00A0
+0088
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uni0085
+ENCODING 59013
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 17 1 0
+BITMAP
+0080
+0080
+0020
+00A0
+0088
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
+ENDCHAR
+STARTCHAR uni0086
+ENCODING 59014
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 17 0 0
+BITMAP
+10
+10
+04
+14
+11
+06
+18
+21
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uni0087
+ENCODING 59015
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 17 0 0
+BITMAP
+0800
+0800
+0200
+0A00
+0880
+0300
+0C00
+1080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uni0088
+ENCODING 59016
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 17 1 -2
+BITMAP
+0880
+0500
+0200
+0000
+0000
+0200
+0300
+0200
+0200
+0200
+0200
+0200
+4200
+8200
+8200
+8400
+7800
+ENDCHAR
+STARTCHAR uni0089
+ENCODING 59017
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 19 1 -4
+BITMAP
+0880
+0500
+0200
+0000
+0000
+0200
+0300
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+4380
+8200
+8200
+8400
+7800
+ENDCHAR
+STARTCHAR uni008A
+ENCODING 59018
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
+BITMAP
+88
+50
+20
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+C0
+ENDCHAR
+STARTCHAR uni008B
+ENCODING 59019
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
+BITMAP
+88
+50
+20
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+F0
+ENDCHAR
+STARTCHAR uni008C
+ENCODING 59020
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 16 1 -2
+BITMAP
+02
+02
+00
+00
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
+ENDCHAR
+STARTCHAR uni008D
+ENCODING 59021
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 18 1 -4
+BITMAP
+0200
+0200
+0000
+0000
+0200
+0300
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+4380
+8200
+8200
+8400
+7800
+ENDCHAR
+STARTCHAR uni008E
+ENCODING 59022
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 14 0 0
+BITMAP
+20
+20
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+C0
+ENDCHAR
+STARTCHAR uni008F
+ENCODING 59023
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 14 0 0
+BITMAP
+20
+20
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+F0
+ENDCHAR
+STARTCHAR uni0090
+ENCODING 59024
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 18 1 -2
+BITMAP
+02
+02
+05
+05
+00
+00
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
+ENDCHAR
+STARTCHAR uni0091
+ENCODING 59025
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 20 1 -4
+BITMAP
+0200
+0200
+0500
+0500
+0000
+0000
+0200
+0300
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+4380
+8200
+8200
+8400
+7800
+ENDCHAR
+STARTCHAR uni0092
+ENCODING 59026
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 16 0 0
+BITMAP
+20
+20
+50
+50
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+C0
+ENDCHAR
+STARTCHAR uni0093
+ENCODING 59027
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 16 0 0
+BITMAP
+20
+20
+50
+50
+00
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+F0
+ENDCHAR
+STARTCHAR uni0094
+ENCODING 59028
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 11 1 -3
+BITMAP
+1000
+1000
+0000
+0200
+0200
+4100
+8100
+8100
+8300
+7E80
+0380
+ENDCHAR
+STARTCHAR uni0095
+ENCODING 59029
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 1 -5
+BITMAP
+1000
+1000
+0000
+0200
+0200
+4180
+8100
+8100
+8300
+7E80
+0380
+ENDCHAR
+STARTCHAR uni0096
+ENCODING 59030
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 0 -3
+BITMAP
+20
+20
+00
+00
+10
+08
+08
+08
+F0
+60
+90
+60
+ENDCHAR
+STARTCHAR uni0097
+ENCODING 59031
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 0 -3
+BITMAP
+10
+10
+00
+00
+10
+10
+10
+FC
+60
+90
+60
+ENDCHAR
+STARTCHAR uni0098
+ENCODING 59032
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 12 1 -2
+BITMAP
+08
+08
+14
+14
+00
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uni0099
+ENCODING 59033
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 12 1 -4
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0200
+0200
+4180
+8100
+8100
+8200
+7C00
+ENDCHAR
+STARTCHAR uni009A
+ENCODING 59034
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -6
+BITMAP
+10
+08
+08
+08
+F0
+00
+00
+28
+28
+10
+10
+ENDCHAR
+STARTCHAR uni009B
+ENCODING 59035
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 -6
+BITMAP
+10
+10
+10
+FC
+00
+00
+28
+28
+10
+10
+ENDCHAR
+STARTCHAR uni009C
+ENCODING 59036
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 4 11 1 0
+BITMAP
+30
+40
+30
+40
+00
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR uni009D
+ENCODING 59037
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
+BITMAP
+18
+20
+18
+20
+00
+10
+30
+50
+90
+90
+70
+0C
+ENDCHAR
+STARTCHAR uni009E
+ENCODING 59038
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 11 1 0
+BITMAP
+30
+40
+30
+40
+00
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR uni009F
+ENCODING 59039
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 10 1 0
+BITMAP
+18
+20
+18
+20
+00
+00
+30
+78
+8C
+04
+ENDCHAR
+STARTCHAR uni00A0
+ENCODING 59040
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 10 1 0
+BITMAP
+50
+50
+00
+00
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR uni00A1
+ENCODING 59041
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 8 1 0
+BITMAP
+28
+28
+00
+00
+30
+78
+8C
+04
+ENDCHAR
+STARTCHAR uni00A2
+ENCODING 59042
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 8 0 -3
+BITMAP
+04
+0A
+0A
+0E
+12
+2A
+94
+78
+ENDCHAR
+STARTCHAR uni00A3
+ENCODING 59043
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 8 1 -4
+BITMAP
+0400
+0A00
+0A00
+0780
+1200
+2A00
+9400
+7800
+ENDCHAR
+STARTCHAR uni00A4
+ENCODING 59044
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 12 0 -3
+BITMAP
+0A
+0A
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uni00A5
+ENCODING 59045
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 -4
+BITMAP
+0A00
+0A00
+0000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uni00A6
+ENCODING 59046
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 8 0 -2
+BITMAP
+0078
+0080
+1080
+2060
+6010
+A010
+1060
+0F80
+ENDCHAR
+STARTCHAR uni00A7
+ENCODING 59047
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 6 1 -5
+BITMAP
+1078
+2080
+6060
+A010
+1060
+0F80
+ENDCHAR
+STARTCHAR uni00A8
+ENCODING 59048
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 0 -2
+BITMAP
+4400
+2800
+1000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni00A9
+ENCODING 59049
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 -5
+BITMAP
+2200
+1400
+0800
+0000
+0000
+41E0
+8200
+8180
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uni00AA
+ENCODING 59050
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 0
+BITMAP
+44
+28
+10
+00
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uni00AB
+ENCODING 59051
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 9 0 0
+BITMAP
+44
+28
+10
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uni00AC
+ENCODING 59052
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 1 -7
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+0000
+2800
+2800
+1000
+1000
+ENDCHAR
+STARTCHAR uni00AD
+ENCODING 59053
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 11 1 -10
+BITMAP
+41E0
+8200
+8180
+8040
+4180
+3E00
+0000
+2800
+2800
+1000
+1000
+ENDCHAR
+STARTCHAR uni00AE
+ENCODING 59054
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 0 -5
+BITMAP
+10
+08
+08
+08
+F0
+00
+50
+50
+20
+20
+ENDCHAR
+STARTCHAR uni00AF
+ENCODING 59055
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 9 0 -5
+BITMAP
+10
+10
+10
+FC
+00
+28
+28
+10
+10
+ENDCHAR
+STARTCHAR uni00B0
+ENCODING 59056
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 0 0
+BITMAP
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uni00B1
+ENCODING 59057
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 4 0 0
+BITMAP
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uni00B2
+ENCODING 59058
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
+BITMAP
+1180
+2A00
+1180
+2A00
+4000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uni00B3
+ENCODING 59059
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 14 1 -5
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8088
+4308
+3C00
+ENDCHAR
+STARTCHAR uni00B4
+ENCODING 59060
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 14 1 -5
+BITMAP
+001000
+001000
+002800
+002800
+000000
+000000
+011200
+011200
+40FF80
+808000
+808000
+808800
+430800
+3C0000
+ENDCHAR
+STARTCHAR uni00B5
+ENCODING 59061
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 13 0 -4
+BITMAP
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFE0
+0000
+0000
+0080
+0080
+ENDCHAR
+STARTCHAR uni00B6
+ENCODING 59062
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 13 0 -4
+BITMAP
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFF8
+0000
+0000
+0080
+0080
+ENDCHAR
+STARTCHAR uni00B7
+ENCODING 59063
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 12 1 -5
+BITMAP
+002000
+002000
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808400
+430400
+3C0000
+ENDCHAR
+STARTCHAR uni00B8
+ENCODING 59064
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 12 1 -5
+BITMAP
+002000
+002000
+000000
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808400
+430400
+3C0000
+ENDCHAR
+STARTCHAR uni00B9
+ENCODING 59065
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 0 -4
+BITMAP
+0200
+0200
+0000
+0070
+2188
+2208
+FFF0
+0000
+0000
+0040
+0040
+ENDCHAR
+STARTCHAR uni00BA
+ENCODING 59066
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -4
+BITMAP
+0400
+0400
+0000
+00E0
+0310
+2410
+DFF8
+0000
+0000
+0080
+0080
+ENDCHAR
+STARTCHAR uni00BB
+ENCODING 59067
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -7
+BITMAP
+2000
+2000
+0000
+0000
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8800
+8800
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni00BC
+ENCODING 59068
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 15 1 -6
+BITMAP
+1000
+1000
+0000
+0000
+3800
+6C00
+1000
+3800
+4780
+4000
+8800
+8800
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uni00BD
+ENCODING 59069
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 13 0 -4
+BITMAP
+10
+10
+00
+00
+1C
+20
+40
+22
+FC
+00
+00
+10
+10
+ENDCHAR
+STARTCHAR uni00BE
+ENCODING 59070
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 -4
+BITMAP
+08
+08
+00
+00
+1C
+36
+08
+1C
+E3
+00
+00
+08
+08
+ENDCHAR
+STARTCHAR uni06C1
+ENCODING 59073
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 0
+BITMAP
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR uni06C2
+ENCODING 59074
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 11 1 0
+BITMAP
+30
+40
+30
+40
+00
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR uni06C3
+ENCODING 59075
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 10 1 0
+BITMAP
+50
+50
+00
+00
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR uniFB5E
+ENCODING 59077
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 6 0 -1
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uniFB5F
+ENCODING 59078
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 5 1 -1
+BITMAP
+4000
+8010
+8010
+C07E
+7F80
+ENDCHAR
+STARTCHAR uniFB60
+ENCODING 59079
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 0 0
+BITMAP
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFB61
+ENCODING 59080
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 4 0 0
+BITMAP
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFED5
+ENCODING 59081
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 1 -3
+BITMAP
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uniFED6
+ENCODING 59082
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 10 1 -5
+BITMAP
+0300
+0580
+0480
+0480
+43E0
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uniFED7
+ENCODING 59083
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 7 0 0
+BITMAP
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uniFED8
+ENCODING 59084
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 6 0 0
+BITMAP
+18
+24
+24
+18
+18
+E7
+ENDCHAR
+STARTCHAR uni00D0
+ENCODING 59088
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 15 1 0
+BITMAP
+11
+0A
+04
+00
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
+ENDCHAR
+STARTCHAR uni00D1
+ENCODING 59089
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 16 1 -1
+BITMAP
+0880
+0500
+0200
+0000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
+ENDCHAR
+STARTCHAR uni00D2
+ENCODING 59090
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 1 0
+BITMAP
+04
+04
+00
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
+ENDCHAR
+STARTCHAR uni00D3
+ENCODING 59091
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 -1
+BITMAP
+0200
+0200
+0000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
+ENDCHAR
+STARTCHAR uni00D4
+ENCODING 59092
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 16 1 0
+BITMAP
+04
+04
+0A
+0A
+00
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
+ENDCHAR
+STARTCHAR uni00D5
+ENCODING 59093
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -1
+BITMAP
+0200
+0200
+0500
+0500
+0000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
+ENDCHAR
+STARTCHAR uni00F0
+ENCODING 59120
+SWIDTH 1260 0
+DWIDTH 21 0
+BBX 19 14 1 -4
+BITMAP
+028000
+028000
+02C000
+028000
+028000
+028000
+028840
+028460
+828420
+828420
+827820
+440040
+3858C0
+005780
+ENDCHAR
+STARTCHAR uni06F4
+ENCODING 59124
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 1 0
+BITMAP
+72
+FE
+CC
+48
+60
+60
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni06F7
+ENCODING 59127
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 8 1 1
+BITMAP
+03
+0E
+38
+60
+E0
+78
+1E
+07
+ENDCHAR
+STARTCHAR uniFBA8
+ENCODING 60328
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 10 0 -4
+BITMAP
+10
+10
+10
+10
+10
+FE
+00
+10
+20
+30
+ENDCHAR
+STARTCHAR uniFEEC
+ENCODING 61164
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 8 0 -6
+BITMAP
+40
+CC
+30
+20
+20
+24
+28
+0C
+ENDCHAR
+STARTCHAR uniFB50
+ENCODING 64336
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
+BITMAP
+10
+28
+78
+80
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uniFB51
+ENCODING 64337
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 15 0 0
+BITMAP
+10
+28
+78
+80
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+18
+ENDCHAR
+STARTCHAR uniFB52
+ENCODING 64338
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 12 1 -7
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0200
+0200
+0000
+0200
+0200
+ENDCHAR
+STARTCHAR uniFB53
+ENCODING 64339
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 11 1 -7
+BITMAP
+4000
+8010
+8010
+C07E
+7F80
+0000
+0400
+0400
+0000
+0400
+0400
+ENDCHAR
+STARTCHAR uniFB54
+ENCODING 64340
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -6
+BITMAP
+10
+08
+08
+08
+F0
+00
+40
+40
+00
+40
+40
+ENDCHAR
+STARTCHAR uniFB55
+ENCODING 64341
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 -6
+BITMAP
+10
+10
+10
+FC
+00
+10
+10
+00
+10
+10
+ENDCHAR
+STARTCHAR uniFB56
+ENCODING 64342
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 -6
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0A00
+0A00
+0400
+0400
+ENDCHAR
+STARTCHAR uniFB57
+ENCODING 64343
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 10 1 -6
+BITMAP
+4000
+8010
+8010
+C07E
+7F80
+0000
+0A00
+0A00
+0400
+0400
+ENDCHAR
+STARTCHAR uniFB58
+ENCODING 64344
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 0 -5
+BITMAP
+10
+08
+08
+08
+F0
+00
+50
+50
+20
+20
+ENDCHAR
+STARTCHAR uniFB59
+ENCODING 64345
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 9 0 -5
+BITMAP
+10
+10
+10
+FC
+00
+28
+28
+10
+10
+ENDCHAR
+STARTCHAR uniFB5A
+ENCODING 64346
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 12 1 -7
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0500
+0500
+0000
+0500
+0500
+ENDCHAR
+STARTCHAR uniFB5B
+ENCODING 64347
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 11 1 -7
+BITMAP
+4000
+8010
+8010
+C07E
+7F80
+0000
+0500
+0500
+0000
+0500
+0500
+ENDCHAR
+STARTCHAR uniFB5C
+ENCODING 64348
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -6
+BITMAP
+10
+08
+08
+08
+F0
+00
+50
+50
+00
+50
+50
+ENDCHAR
+STARTCHAR uniFB5D
+ENCODING 64349
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 -6
+BITMAP
+10
+10
+10
+FC
+00
+28
+28
+00
+28
+28
+ENDCHAR
+STARTCHAR uniFB5E
+ENCODING 64350
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 11 0 -1
+BITMAP
+0200
+0200
+0000
+0200
+0200
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uniFB5F
+ENCODING 64351
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 1 -1
+BITMAP
+0100
+0100
+0000
+0100
+0100
+0000
+4000
+8010
+8010
+C07E
+7F80
+ENDCHAR
+STARTCHAR uniFB60
+ENCODING 64352
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 0
+BITMAP
+20
+20
+00
+20
+20
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFB61
+ENCODING 64353
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 0 0
+BITMAP
+10
+10
+00
+10
+10
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFB62
+ENCODING 64354
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 -1
+BITMAP
+0500
+0500
+0000
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uniFB63
+ENCODING 64355
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 11 1 -1
+BITMAP
+0500
+0500
+0000
+0500
+0500
+0000
+4000
+8010
+8010
+C07E
+7F80
+ENDCHAR
+STARTCHAR uniFB64
+ENCODING 64356
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 0
+BITMAP
+28
+28
+00
+28
+28
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFB65
+ENCODING 64357
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 0 0
+BITMAP
+28
+28
+00
+28
+28
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFB66
+ENCODING 64358
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 9 1 -1
+BITMAP
+0400
+0400
+0700
+0708
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uniFB67
+ENCODING 64359
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 9 1 -1
+BITMAP
+0400
+0400
+0700
+0700
+4000
+8010
+8010
+C07E
+7F80
+ENDCHAR
+STARTCHAR uniFB68
+ENCODING 64360
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 0
+BITMAP
+20
+20
+38
+38
+00
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFB69
+ENCODING 64361
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 0 0
+BITMAP
+20
+20
+38
+38
+00
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFB6A
+ENCODING 64362
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 14 1 0
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uniFB6B
+ENCODING 64363
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 14 1 -1
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+ENDCHAR
+STARTCHAR uniFB6C
+ENCODING 64364
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 13 0 0
+BITMAP
+20
+20
+50
+50
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uniFB6D
+ENCODING 64365
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 12 0 0
+BITMAP
+10
+10
+28
+28
+00
+00
+18
+24
+24
+18
+18
+E7
+ENDCHAR
+STARTCHAR uniFB6E
+ENCODING 64366
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 15 1 0
+BITMAP
+0028
+0028
+0000
+0028
+0028
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uniFB6F
+ENCODING 64367
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 15 1 -1
+BITMAP
+0028
+0028
+0000
+0028
+0028
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+ENDCHAR
+STARTCHAR uniFB70
+ENCODING 64368
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 14 0 0
+BITMAP
+50
+50
+00
+50
+50
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uniFB71
+ENCODING 64369
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 14 0 0
+BITMAP
+28
+28
+00
+00
+28
+28
+00
+00
+18
+24
+24
+18
+18
+E7
+ENDCHAR
+STARTCHAR uniFB72
+ENCODING 64370
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4800
+8800
+8000
+8800
+4800
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB73
+ENCODING 64371
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3A00
+4200
+49C0
+8800
+8000
+8800
+4800
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB80
+ENCODING 64372
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 0 -6
+BITMAP
+3800
+4600
+0100
+FF80
+0000
+0800
+0800
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 64373
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 10 10 0 -6
+BITMAP
+3800
+4600
+0100
+FFC0
+0000
+0800
+0800
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uniFB76
+ENCODING 64374
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+8A00
+8A00
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB77
+ENCODING 64375
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3A00
+4200
+41C0
+8A00
+8A00
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB80
+ENCODING 64376
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 7 0 -3
+BITMAP
+3800
+4600
+0100
+FF80
+0000
+1400
+1400
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 64377
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 10 7 0 -3
+BITMAP
+3800
+4600
+0100
+FFC0
+0000
+1400
+1400
+ENDCHAR
+STARTCHAR uniFB7A
+ENCODING 64378
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+9400
+9400
+8800
+4800
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB7B
+ENCODING 64379
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3A00
+4200
+41C0
+9400
+9400
+8800
+4800
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB80
+ENCODING 64380
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 9 0 -5
+BITMAP
+3800
+4600
+0100
+FF80
+0000
+1400
+1400
+0800
+0800
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 64381
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 10 9 0 -5
+BITMAP
+3800
+4600
+0100
+FFC0
+0000
+1400
+1400
+0800
+0800
+ENDCHAR
+STARTCHAR uniFB7E
+ENCODING 64382
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4A00
+8A00
+8000
+8A00
+4A00
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB7F
+ENCODING 64383
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3A00
+4200
+55C0
+9400
+8000
+9400
+5400
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFB80
+ENCODING 64384
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 10 0 -6
+BITMAP
+3800
+4600
+0100
+FF80
+0000
+1400
+1400
+0000
+1400
+1400
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 64385
+SWIDTH 1200 0
+DWIDTH 20 0
+BBX 10 10 0 -6
+BITMAP
+3800
+4600
+0100
+FFC0
+0000
+1400
+1400
+0000
+1400
+1400
+ENDCHAR
+STARTCHAR uniFB82
+ENCODING 64386
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 1 -3
+BITMAP
+10
+10
+08
+08
+98
+60
+00
+50
+50
+ENDCHAR
+STARTCHAR uniFB83
+ENCODING 64387
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 10 1 -3
+BITMAP
+10
+10
+08
+08
+08
+98
+66
+00
+50
+50
+ENDCHAR
+STARTCHAR uniFB84
+ENCODING 64388
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 0
+BITMAP
+50
+50
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uniFB85
+ENCODING 64389
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 1 0
+BITMAP
+50
+50
+00
+00
+10
+10
+08
+08
+08
+98
+66
+ENDCHAR
+STARTCHAR uniFB86
+ENCODING 64390
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+20
+20
+50
+50
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uniFB87
+ENCODING 64391
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 13 1 0
+BITMAP
+20
+20
+50
+50
+00
+00
+10
+10
+08
+08
+08
+98
+66
+ENDCHAR
+STARTCHAR uniFB88
+ENCODING 64392
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 12 1 0
+BITMAP
+80
+80
+E0
+E0
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uniFB89
+ENCODING 64393
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 13 1 0
+BITMAP
+20
+20
+38
+38
+00
+00
+10
+10
+08
+08
+08
+98
+66
+ENDCHAR
+STARTCHAR uniFB8A
+ENCODING 64394
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -4
+BITMAP
+08
+08
+14
+14
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFB8B
+ENCODING 64395
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 14 1 -5
+BITMAP
+08
+08
+14
+14
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFB8C
+ENCODING 64396
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 14 1 -4
+BITMAP
+20
+20
+38
+38
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFB8D
+ENCODING 64397
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 14 1 -5
+BITMAP
+20
+20
+38
+38
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFB8E
+ENCODING 64398
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 11 1 -1
+BITMAP
+0008
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uniFB8F
+ENCODING 64399
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 10 1 0
+BITMAP
+0008
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
+ENDCHAR
+STARTCHAR uniFEDB
+ENCODING 64400
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 0
+BITMAP
+01
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uniFEDC
+ENCODING 64401
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 0 0
+BITMAP
+0080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uniFB92
+ENCODING 64402
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 14 1 -1
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uniFB93
+ENCODING 64403
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 13 1 0
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
+ENDCHAR
+STARTCHAR uniFB94
+ENCODING 64404
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 0
+BITMAP
+01
+06
+18
+21
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uniFB95
+ENCODING 64405
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 0
+BITMAP
+0080
+0300
+0C00
+1080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uniFB96
+ENCODING 64406
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 20 1 -7
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+8060
+7F80
+0000
+0400
+0400
+0000
+0400
+0400
+ENDCHAR
+STARTCHAR uniFB97
+ENCODING 64407
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 20 1 -7
+BITMAP
+0008
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
+0000
+0000
+0080
+0080
+0000
+0080
+0080
+ENDCHAR
+STARTCHAR uniFB98
+ENCODING 64408
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 19 0 -6
+BITMAP
+01
+06
+18
+21
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+00
+10
+10
+00
+10
+10
+ENDCHAR
+STARTCHAR uniFB99
+ENCODING 64409
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 19 0 -6
+BITMAP
+0080
+0300
+0C00
+1080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+0000
+0800
+0800
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uniFB9A
+ENCODING 64410
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 16 1 -1
+BITMAP
+0020
+00A0
+0088
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+0080
+4060
+8010
+8010
+8060
+7F80
+ENDCHAR
+STARTCHAR uniFB9B
+ENCODING 64411
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 15 1 0
+BITMAP
+0020
+00A0
+0088
+0030
+00C0
+0108
+0030
+00C0
+0100
+0100
+4080
+8060
+8010
+8010
+7FFE
+ENDCHAR
+STARTCHAR uniFB9C
+ENCODING 64412
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 15 0 0
+BITMAP
+04
+14
+11
+06
+18
+21
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uniFB9D
+ENCODING 64413
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 0 0
+BITMAP
+0200
+0A00
+0880
+0300
+0C00
+1080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uniFB9E
+ENCODING 64414
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 7 1 -2
+BITMAP
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uniFB9F
+ENCODING 64415
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 7 1 -4
+BITMAP
+0200
+0200
+4180
+8100
+8100
+8200
+7C00
+ENDCHAR
+STARTCHAR uniFBA0
+ENCODING 64416
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 13 1 -2
+BITMAP
+20
+20
+38
+38
+00
+00
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uniFBA1
+ENCODING 64417
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 14 1 -4
+BITMAP
+2000
+2000
+3800
+3800
+0000
+0000
+0000
+0200
+0200
+4180
+8100
+8100
+8200
+7C00
+ENDCHAR
+STARTCHAR uniFBA2
+ENCODING 64418
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 5 11 0 0
+BITMAP
+20
+20
+38
+38
+00
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFBA3
+ENCODING 64419
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 0 0
+BITMAP
+20
+20
+38
+38
+00
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFBA4
+ENCODING 64420
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 12 1 0
+BITMAP
+30
+40
+30
+40
+00
+00
+20
+30
+50
+88
+88
+70
+ENDCHAR
+STARTCHAR uniFBA5
+ENCODING 64421
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 0
+BITMAP
+30
+40
+30
+40
+00
+10
+30
+50
+90
+90
+70
+0C
+ENDCHAR
+STARTCHAR uniFBA6
+ENCODING 64422
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 6 1 0
+BITMAP
+20
+30
+50
+88
+88
+70
+ENDCHAR
+STARTCHAR uniFBA7
+ENCODING 64423
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 4 1 0
+BITMAP
+18
+3C
+46
+83
+ENDCHAR
+STARTCHAR uniFBA8
+ENCODING 64424
+SWIDTH 180 0
+DWIDTH 3 0
+BBX 3 10 0 -4
+BITMAP
+20
+20
+20
+20
+20
+C0
+00
+20
+40
+60
+ENDCHAR
+STARTCHAR uniFBA9
+ENCODING 64425
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 7 0 -5
+BITMAP
+40
+CC
+30
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uniFBAA
+ENCODING 64426
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 6 1 -1
+BITMAP
+38
+4E
+49
+59
+26
+C0
+ENDCHAR
+STARTCHAR uniFBAB
+ENCODING 64427
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 6 1 -1
+BITMAP
+3800
+4E00
+4900
+5900
+27C0
+C000
+ENDCHAR
+STARTCHAR uniFBAC
+ENCODING 64428
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 5 0 0
+BITMAP
+1C00
+2700
+2480
+2C80
+D300
+ENDCHAR
+STARTCHAR uniFBAD
+ENCODING 64429
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 5 0 0
+BITMAP
+1C00
+2700
+2480
+2C80
+D3C0
+ENDCHAR
+STARTCHAR uniFBAE
+ENCODING 64430
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 8 1 -4
+BITMAP
+0200
+0500
+0500
+1800
+6000
+8000
+8000
+7FF8
+ENDCHAR
+STARTCHAR uniFBAF
+ENCODING 64431
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 11 8 1 -7
+BITMAP
+0300
+0400
+0400
+1800
+6000
+8000
+8000
+7FE0
+ENDCHAR
+STARTCHAR uniFBB0
+ENCODING 64432
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 13 11 1 -4
+BITMAP
+3000
+4000
+3000
+4200
+0500
+0500
+1800
+6000
+8000
+8000
+7FF8
+ENDCHAR
+STARTCHAR uniFBB1
+ENCODING 64433
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 11 11 1 -7
+BITMAP
+3000
+4000
+3000
+4300
+0400
+0400
+1800
+6000
+8000
+8000
+7FE0
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 64467
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 0
+BITMAP
+0400
+0400
+0A00
+0A00
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+ENDCHAR
+STARTCHAR uniFBD4
+ENCODING 64468
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 1 0
+BITMAP
+0800
+0800
+1400
+1400
+0000
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7FE0
+ENDCHAR
+STARTCHAR uniFBD5
+ENCODING 64469
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 0 0
+BITMAP
+0800
+0800
+0200
+0A00
+08C0
+0300
+0C00
+3000
+4000
+4000
+3000
+0C00
+0200
+0100
+FE00
+ENDCHAR
+STARTCHAR uniFBD6
+ENCODING 64470
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 15 0 0
+BITMAP
+0800
+0800
+0200
+0A00
+08C0
+0300
+0C00
+3000
+4000
+4000
+2000
+1800
+0400
+0200
+FFE0
+ENDCHAR
+STARTCHAR uniFBD7
+ENCODING 64471
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+04
+0A
+04
+0A
+10
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uniFBD8
+ENCODING 64472
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
+BITMAP
+0400
+0A00
+0400
+0A00
+1000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFBD9
+ENCODING 64473
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 -3
+BITMAP
+11
+0A
+04
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uniFBDA
+ENCODING 64474
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 13 1 -4
+BITMAP
+1100
+0A00
+0400
+0000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFBDB
+ENCODING 64475
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+04
+04
+04
+04
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uniFBDC
+ENCODING 64476
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
+BITMAP
+0400
+0400
+0400
+0400
+0000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFBDD
+ENCODING 64477
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 14 0 -3
+BITMAP
+1180
+2A00
+1180
+2A00
+4000
+0000
+0400
+0A00
+0A00
+0E00
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFBDE
+ENCODING 64478
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+04
+04
+0A
+0A
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uniFBDF
+ENCODING 64479
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
+BITMAP
+0400
+0400
+0A00
+0A00
+0000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFBE0
+ENCODING 64480
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 8 0 -3
+BITMAP
+04
+0A
+0A
+0E
+02
+3E
+84
+78
+ENDCHAR
+STARTCHAR uniFBE1
+ENCODING 64481
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 8 1 -4
+BITMAP
+0400
+0A00
+0A00
+0780
+0200
+3E00
+8400
+7800
+ENDCHAR
+STARTCHAR uniFBE2
+ENCODING 64482
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 13 0 -3
+BITMAP
+04
+0A
+11
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uniFBE3
+ENCODING 64483
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 13 1 -4
+BITMAP
+0400
+0A00
+1100
+0000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFBE4
+ENCODING 64484
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 -8
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+0000
+0800
+0800
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uniFBE5
+ENCODING 64485
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 1 -9
+BITMAP
+41E0
+8200
+8180
+8040
+4180
+3E00
+0000
+0C00
+0000
+0C00
+ENDCHAR
+STARTCHAR uniFBE6
+ENCODING 64486
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 11 0 -6
+BITMAP
+10
+08
+08
+08
+F0
+00
+10
+10
+00
+10
+10
+ENDCHAR
+STARTCHAR uniFBE7
+ENCODING 64487
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 -6
+BITMAP
+10
+10
+10
+FC
+00
+10
+10
+00
+10
+10
+ENDCHAR
+STARTCHAR uniFBE8
+ENCODING 64488
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 5 0 0
+BITMAP
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFBE9
+ENCODING 64489
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 4 0 0
+BITMAP
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFBFC
+ENCODING 64508
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 8 1 -2
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFBFD
+ENCODING 64509
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 6 1 -5
+BITMAP
+41E0
+8200
+8180
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFBFE
+ENCODING 64510
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 8 0 -3
+BITMAP
+10
+08
+08
+08
+F0
+00
+50
+50
+ENDCHAR
+STARTCHAR uniFBFF
+ENCODING 64511
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 7 0 -3
+BITMAP
+10
+10
+10
+FC
+00
+28
+28
+ENDCHAR
+STARTCHAR 0xFE70
+ENCODING 65136
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 4 1 10
+BITMAP
+30
+C0
+30
+C0
+ENDCHAR
+STARTCHAR 0xFE71
+ENCODING 65137
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 10 0 4
+BITMAP
+0C00
+3000
+0C00
+3000
+0000
+0000
+0000
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR 0x064C
+ENCODING 65138
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 4 1 11
+BITMAP
+18
+58
+D0
+60
+ENDCHAR
+STARTCHAR 0xFE74
+ENCODING 65140
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 4 1 -6
+BITMAP
+30
+C0
+30
+C0
+ENDCHAR
+STARTCHAR 0xFE76
+ENCODING 65142
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 2 1 10
+BITMAP
+30
+C0
+ENDCHAR
+STARTCHAR 0xFE77
+ENCODING 65143
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 8 0 4
+BITMAP
+0C00
+3000
+0000
+0000
+0000
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR 0xFE78
+ENCODING 65144
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 5 1 11
+BITMAP
+20
+50
+20
+50
+80
+ENDCHAR
+STARTCHAR 0xFE79
+ENCODING 65145
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 12 0 4
+BITMAP
+0800
+1400
+0800
+1400
+2000
+0000
+0000
+0000
+0000
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR 0xFE7A
+ENCODING 65146
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 3 1 -4
+BITMAP
+10
+60
+80
+ENDCHAR
+STARTCHAR 0xFE7B
+ENCODING 65147
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 9 0 -4
+BITMAP
+FF80
+0000
+0000
+0000
+0000
+0000
+0800
+3000
+4000
+ENDCHAR
+STARTCHAR 0x0651
+ENCODING 65148
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 3 1 12
+BITMAP
+08
+A8
+D0
+ENDCHAR
+STARTCHAR 0xFE7D
+ENCODING 65149
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 9 11 0 4
+BITMAP
+0200
+2A00
+3400
+0000
+0000
+0000
+0000
+0000
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR 0xFE7E
+ENCODING 65150
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 4 1 10
+BITMAP
+40
+A0
+A0
+C0
+ENDCHAR
+STARTCHAR 0xFE7F
+ENCODING 65151
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 10 0 4
+BITMAP
+1000
+2800
+2800
+3000
+0000
+0000
+0000
+0000
+0000
+FF80
+ENDCHAR
+STARTCHAR uniFE80
+ENCODING 65152
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 6 1 0
+BITMAP
+70
+80
+80
+70
+C0
+80
+ENDCHAR
+STARTCHAR uniFE81
+ENCODING 65153
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 6 14 0 0
+BITMAP
+04
+78
+80
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uniFE82
+ENCODING 65154
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 14 0 0
+BITMAP
+04
+78
+80
+00
+20
+30
+20
+20
+20
+20
+20
+20
+20
+18
+ENDCHAR
+STARTCHAR uniFE83
+ENCODING 65155
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 3 16 1 0
+BITMAP
+60
+80
+60
+80
+00
+00
+40
+60
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR uniFE84
+ENCODING 65156
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 16 1 0
+BITMAP
+60
+80
+60
+80
+00
+00
+40
+60
+40
+40
+40
+40
+40
+40
+40
+30
+ENDCHAR
+STARTCHAR uniFE85
+ENCODING 65157
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 0 -3
+BITMAP
+06
+08
+06
+08
+00
+00
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uniFE86
+ENCODING 65158
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -4
+BITMAP
+0600
+0800
+0600
+0800
+0000
+0000
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFE87
+ENCODING 65159
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 16 1 -6
+BITMAP
+40
+60
+40
+40
+40
+40
+40
+40
+40
+40
+00
+00
+60
+80
+60
+80
+ENDCHAR
+STARTCHAR uniFE88
+ENCODING 65160
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 16 1 -6
+BITMAP
+40
+60
+40
+40
+40
+40
+40
+40
+40
+30
+00
+00
+60
+80
+60
+80
+ENDCHAR
+STARTCHAR uniFE89
+ENCODING 65161
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 13 0 -2
+BITMAP
+1800
+2000
+1800
+2000
+0000
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFE8A
+ENCODING 65162
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 12 1 -5
+BITMAP
+0C00
+1000
+0C00
+1000
+0000
+0000
+41E0
+8200
+8180
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFE8B
+ENCODING 65163
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 4 11 0 0
+BITMAP
+30
+40
+30
+40
+00
+00
+20
+10
+10
+10
+E0
+ENDCHAR
+STARTCHAR uniFE8C
+ENCODING 65164
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 0
+BITMAP
+18
+20
+18
+20
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFE8D
+ENCODING 65165
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 2 10 2 0
+BITMAP
+80
+C0
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uniFE8E
+ENCODING 65166
+SWIDTH 300 0
+DWIDTH 5 0
+BBX 3 10 2 0
+BITMAP
+80
+C0
+80
+80
+80
+80
+80
+80
+80
+60
+ENDCHAR
+STARTCHAR uniFE8F
+ENCODING 65167
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 9 0 -4
+BITMAP
+0008
+4008
+8008
+8008
+C030
+7FC0
+0000
+0200
+0200
+ENDCHAR
+STARTCHAR uniFE90
+ENCODING 65168
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 8 1 -4
+BITMAP
+4000
+8010
+8010
+C07E
+7F80
+0000
+0400
+0400
+ENDCHAR
+STARTCHAR uniFE91
+ENCODING 65169
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 8 0 -3
+BITMAP
+10
+08
+08
+08
+F0
+00
+20
+20
+ENDCHAR
+STARTCHAR uniFE92
+ENCODING 65170
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 7 0 -3
+BITMAP
+10
+10
+10
+FC
+00
+10
+10
+ENDCHAR
+STARTCHAR uniFE93
+ENCODING 65171
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 5 10 1 0
+BITMAP
+50
+50
+00
+00
+20
+30
+50
+98
+88
+78
+ENDCHAR
+STARTCHAR uniFE94
+ENCODING 65172
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 11 1 0
+BITMAP
+28
+28
+00
+00
+10
+70
+90
+D0
+70
+10
+0C
+ENDCHAR
+STARTCHAR uniFE95
+ENCODING 65173
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 8 0 -1
+BITMAP
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uniFE96
+ENCODING 65174
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 8 1 -1
+BITMAP
+0500
+0500
+0000
+4000
+8010
+8010
+C07E
+7F80
+ENDCHAR
+STARTCHAR uniFE97
+ENCODING 65175
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 8 0 0
+BITMAP
+28
+28
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFE98
+ENCODING 65176
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 8 0 0
+BITMAP
+28
+28
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFE99
+ENCODING 65177
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 10 1 -1
+BITMAP
+0200
+0200
+0500
+0500
+0008
+4008
+8008
+8008
+C030
+7FC0
+ENDCHAR
+STARTCHAR uniFE9A
+ENCODING 65178
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 15 10 1 -1
+BITMAP
+0200
+0200
+0500
+0500
+0000
+4000
+8010
+8010
+C07E
+7F80
+ENDCHAR
+STARTCHAR uniFE9B
+ENCODING 65179
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 0 0
+BITMAP
+10
+10
+28
+28
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFE9C
+ENCODING 65180
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 10 0 0
+BITMAP
+10
+10
+28
+28
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFE9D
+ENCODING 65181
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+8800
+8800
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFE9E
+ENCODING 65182
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3A00
+4200
+41C0
+8800
+8800
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 65183
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 8 0 -4
+BITMAP
+3800
+4600
+0100
+FF80
+0000
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 65184
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 8 0 -4
+BITMAP
+3800
+4600
+0100
+FFC0
+0000
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uniFEA1
+ENCODING 65185
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFEA2
+ENCODING 65186
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 11 1 -6
+BITMAP
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 65187
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 4 0 0
+BITMAP
+3800
+4600
+0100
+FF80
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 65188
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 4 0 0
+BITMAP
+3800
+4600
+0100
+FFC0
+ENDCHAR
+STARTCHAR uniFEA5
+ENCODING 65189
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 -6
+BITMAP
+0800
+0800
+0000
+0000
+7000
+8F00
+3800
+4000
+4000
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uniFEA6
+ENCODING 65190
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 15 1 -6
+BITMAP
+0800
+0800
+0000
+0000
+7000
+8F00
+3A00
+4200
+41C0
+8000
+8000
+8000
+4000
+60C0
+1F00
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 65191
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 8 0 0
+BITMAP
+0800
+0800
+0000
+0000
+3800
+4600
+0100
+FF80
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 65192
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 8 1 0
+BITMAP
+0800
+0800
+0000
+0000
+3800
+4600
+0100
+FFC0
+ENDCHAR
+STARTCHAR uniFEA9
+ENCODING 65193
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 6 1 0
+BITMAP
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uniFEAA
+ENCODING 65194
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 7 1 0
+BITMAP
+10
+10
+08
+08
+08
+98
+66
+ENDCHAR
+STARTCHAR uniFEAB
+ENCODING 65195
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 10 1 0
+BITMAP
+20
+20
+00
+00
+10
+10
+08
+08
+98
+60
+ENDCHAR
+STARTCHAR uniFEAC
+ENCODING 65196
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 11 1 0
+BITMAP
+20
+20
+00
+00
+10
+10
+08
+08
+08
+98
+66
+ENDCHAR
+STARTCHAR uniFEAD
+ENCODING 65197
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 8 1 -4
+BITMAP
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFEAE
+ENCODING 65198
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 8 1 -5
+BITMAP
+08
+0C
+07
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFEAF
+ENCODING 65199
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 12 1 -4
+BITMAP
+08
+08
+00
+00
+08
+08
+04
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFEB0
+ENCODING 65200
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -5
+BITMAP
+08
+08
+00
+00
+08
+0C
+07
+04
+04
+0C
+18
+F0
+ENDCHAR
+STARTCHAR uniFEB1
+ENCODING 65201
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 8 1 -5
+BITMAP
+0112
+0112
+40EC
+8080
+8080
+8080
+4300
+3C00
+ENDCHAR
+STARTCHAR uniFEB2
+ENCODING 65202
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 8 1 -5
+BITMAP
+011200
+011200
+40FF80
+808000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uniFEB3
+ENCODING 65203
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 3 0 0
+BITMAP
+1120
+1120
+FFE0
+ENDCHAR
+STARTCHAR uniFEB4
+ENCODING 65204
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 3 0 0
+BITMAP
+1120
+1120
+FFF8
+ENDCHAR
+STARTCHAR uniFEB5
+ENCODING 65205
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 15 14 1 -5
+BITMAP
+0010
+0010
+0028
+0028
+0000
+0000
+0112
+0112
+40EC
+8080
+8080
+8080
+4300
+3C00
+ENDCHAR
+STARTCHAR uniFEB6
+ENCODING 65206
+SWIDTH 1020 0
+DWIDTH 17 0
+BBX 17 14 1 -5
+BITMAP
+001000
+001000
+002800
+002800
+000000
+000000
+011200
+011200
+40FF80
+808000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uniFEB7
+ENCODING 65207
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 9 0 0
+BITMAP
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFE0
+ENDCHAR
+STARTCHAR uniFEB8
+ENCODING 65208
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 9 0 0
+BITMAP
+0100
+0100
+0280
+0280
+0000
+0000
+1120
+1120
+FFF8
+ENDCHAR
+STARTCHAR uniFEB9
+ENCODING 65209
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 9 1 -5
+BITMAP
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uniFEBA
+ENCODING 65210
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 9 1 -5
+BITMAP
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uniFEBB
+ENCODING 65211
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 4 0 0
+BITMAP
+0070
+2188
+2208
+FFF0
+ENDCHAR
+STARTCHAR uniFEBC
+ENCODING 65212
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 4 0 0
+BITMAP
+00E0
+2310
+2410
+FFF8
+ENDCHAR
+STARTCHAR uniFEB9
+ENCODING 65213
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 17 12 1 -5
+BITMAP
+000800
+000800
+000000
+000700
+001880
+012080
+40FF00
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uniFEBA
+ENCODING 65214
+SWIDTH 1080 0
+DWIDTH 18 0
+BBX 18 12 1 -5
+BITMAP
+000800
+000800
+000000
+000700
+001880
+012080
+40FFC0
+80C000
+808000
+808000
+430000
+3C0000
+ENDCHAR
+STARTCHAR uniFEBB
+ENCODING 65215
+SWIDTH 840 0
+DWIDTH 14 0
+BBX 13 7 0 0
+BITMAP
+0080
+0080
+0000
+0070
+2188
+2208
+FFF0
+ENDCHAR
+STARTCHAR uniFEBC
+ENCODING 65216
+SWIDTH 780 0
+DWIDTH 13 0
+BBX 13 7 0 0
+BITMAP
+0100
+0100
+0000
+00E0
+2310
+2410
+FFF8
+ENDCHAR
+STARTCHAR uniFEC1
+ENCODING 65217
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
+BITMAP
+20
+30
+20
+20
+20
+20
+2E
+31
+21
+FE
+ENDCHAR
+STARTCHAR uniFEC2
+ENCODING 65218
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 10 1 0
+BITMAP
+2000
+3000
+2000
+2000
+2000
+2000
+2E00
+3100
+2100
+FF80
+ENDCHAR
+STARTCHAR uniFEC3
+ENCODING 65219
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 10 0 0
+BITMAP
+40
+60
+40
+40
+40
+40
+5C
+62
+42
+FC
+ENDCHAR
+STARTCHAR uniFEC4
+ENCODING 65220
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 0 0
+BITMAP
+2000
+3000
+2000
+2000
+2000
+2000
+2E00
+3100
+2100
+FFC0
+ENDCHAR
+STARTCHAR uniFEC5
+ENCODING 65221
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 1 0
+BITMAP
+20
+30
+20
+26
+20
+20
+2E
+31
+21
+FE
+ENDCHAR
+STARTCHAR uniFEC6
+ENCODING 65222
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 1 0
+BITMAP
+2000
+3000
+2000
+2600
+2000
+2000
+2E00
+3100
+2100
+FFC0
+ENDCHAR
+STARTCHAR uniFEC7
+ENCODING 65223
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 10 0 0
+BITMAP
+20
+30
+20
+26
+20
+20
+2E
+31
+21
+FE
+ENDCHAR
+STARTCHAR uniFEC8
+ENCODING 65224
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 10 10 0 0
+BITMAP
+2000
+3000
+2000
+2600
+2000
+2000
+2E00
+3100
+2100
+FFC0
+ENDCHAR
+STARTCHAR uniFEC9
+ENCODING 65225
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 12 1 -7
+BITMAP
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFECA
+ENCODING 65226
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 11 1 -6
+BITMAP
+3800
+6C00
+1000
+3800
+4780
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFECB
+ENCODING 65227
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 5 0 0
+BITMAP
+1C
+20
+40
+22
+FC
+ENDCHAR
+STARTCHAR uniFECC
+ENCODING 65228
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 5 0 0
+BITMAP
+38
+6C
+10
+38
+C6
+ENDCHAR
+STARTCHAR uniFECD
+ENCODING 65229
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 16 1 -7
+BITMAP
+2000
+2000
+0000
+0000
+3800
+4000
+8000
+4C00
+3000
+4000
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFECE
+ENCODING 65230
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 15 1 -6
+BITMAP
+1000
+1000
+0000
+0000
+3800
+6C00
+1000
+3800
+4780
+4000
+8000
+8000
+8000
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFECF
+ENCODING 65231
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 9 0 0
+BITMAP
+10
+10
+00
+00
+1C
+20
+40
+22
+FC
+ENDCHAR
+STARTCHAR uniFED0
+ENCODING 65232
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 9 0 0
+BITMAP
+08
+08
+00
+00
+1C
+36
+08
+1C
+E3
+ENDCHAR
+STARTCHAR uniFED1
+ENCODING 65233
+SWIDTH 900 0
+DWIDTH 15 0
+BBX 14 12 1 0
+BITMAP
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+4038
+3FC0
+ENDCHAR
+STARTCHAR uniFED2
+ENCODING 65234
+SWIDTH 960 0
+DWIDTH 16 0
+BBX 16 12 1 -1
+BITMAP
+0010
+0010
+0000
+0000
+0018
+002C
+0024
+802C
+8014
+8004
+403B
+3FC0
+ENDCHAR
+STARTCHAR uniFED3
+ENCODING 65235
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 11 0 0
+BITMAP
+20
+20
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uniFED4
+ENCODING 65236
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 0
+BITMAP
+10
+10
+00
+00
+18
+24
+24
+18
+18
+E7
+ENDCHAR
+STARTCHAR uniFED5
+ENCODING 65237
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 14 1 -3
+BITMAP
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+4380
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uniFED6
+ENCODING 65238
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 14 1 -5
+BITMAP
+0500
+0500
+0000
+0000
+0300
+0580
+0480
+0480
+43E0
+8080
+8080
+8100
+4200
+3C00
+ENDCHAR
+STARTCHAR uniFED7
+ENCODING 65239
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 5 11 0 0
+BITMAP
+50
+50
+00
+00
+30
+58
+48
+58
+28
+08
+F0
+ENDCHAR
+STARTCHAR uniFED8
+ENCODING 65240
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 0
+BITMAP
+28
+28
+00
+00
+18
+24
+24
+18
+18
+E7
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 65241
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 10 1 0
+BITMAP
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7F00
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 65242
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 1 0
+BITMAP
+0080
+00C0
+0080
+0480
+0C80
+0480
+8C80
+8080
+C080
+7FE0
+ENDCHAR
+STARTCHAR uniFEDB
+ENCODING 65243
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 10 0 0
+BITMAP
+01
+06
+18
+20
+20
+10
+0C
+02
+02
+FC
+ENDCHAR
+STARTCHAR uniFEDC
+ENCODING 65244
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 10 0 0
+BITMAP
+0080
+0300
+0C00
+1000
+1000
+0800
+0600
+0100
+0100
+FFE0
+ENDCHAR
+STARTCHAR uniFEDD
+ENCODING 65245
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 8 12 1 -2
+BITMAP
+02
+03
+02
+02
+02
+02
+02
+42
+82
+82
+84
+78
+ENDCHAR
+STARTCHAR uniFEDE
+ENCODING 65246
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 14 1 -4
+BITMAP
+0200
+0300
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+4380
+8200
+8200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFEDF
+ENCODING 65247
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 10 0 0
+BITMAP
+20
+30
+20
+20
+20
+20
+20
+20
+20
+C0
+ENDCHAR
+STARTCHAR uniFEE0
+ENCODING 65248
+SWIDTH 240 0
+DWIDTH 4 0
+BBX 4 10 0 0
+BITMAP
+20
+30
+20
+20
+20
+20
+20
+20
+20
+F0
+ENDCHAR
+STARTCHAR uniFEE1
+ENCODING 65249
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 13 1 -9
+BITMAP
+40
+B0
+08
+7C
+80
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uniFEE2
+ENCODING 65250
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 7 13 1 -9
+BITMAP
+40
+B0
+08
+7E
+80
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uniFEE3
+ENCODING 65251
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 7 4 0 0
+BITMAP
+0C
+12
+32
+EC
+ENDCHAR
+STARTCHAR uniFEE4
+ENCODING 65252
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 4 0 0
+BITMAP
+0C00
+1200
+3300
+ED80
+ENDCHAR
+STARTCHAR uniFEE5
+ENCODING 65253
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 8 10 1 -2
+BITMAP
+10
+10
+00
+02
+02
+41
+81
+81
+82
+7C
+ENDCHAR
+STARTCHAR uniFEE6
+ENCODING 65254
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 9 10 1 -4
+BITMAP
+1000
+1000
+0000
+0200
+0200
+4180
+8100
+8100
+8200
+7C00
+ENDCHAR
+STARTCHAR uniFEE7
+ENCODING 65255
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 9 0 0
+BITMAP
+20
+20
+00
+00
+10
+08
+08
+08
+F0
+ENDCHAR
+STARTCHAR uniFEE8
+ENCODING 65256
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 8 0 0
+BITMAP
+10
+10
+00
+00
+10
+10
+10
+FC
+ENDCHAR
+STARTCHAR uniFEE9
+ENCODING 65257
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 4 6 1 0
+BITMAP
+20
+30
+50
+90
+90
+60
+ENDCHAR
+STARTCHAR uniFEEA
+ENCODING 65258
+SWIDTH 420 0
+DWIDTH 7 0
+BBX 6 7 1 0
+BITMAP
+10
+30
+50
+90
+90
+70
+0C
+ENDCHAR
+STARTCHAR uniFEEB
+ENCODING 65259
+SWIDTH 480 0
+DWIDTH 8 0
+BBX 8 7 0 0
+BITMAP
+10
+18
+2C
+56
+52
+31
+CE
+ENDCHAR
+STARTCHAR uniFEEC
+ENCODING 65260
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 11 0 -5
+BITMAP
+18
+28
+28
+28
+30
+FC
+30
+28
+28
+28
+18
+ENDCHAR
+STARTCHAR uniFEED
+ENCODING 65261
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 8 0 -3
+BITMAP
+04
+0A
+0A
+0E
+02
+02
+84
+78
+ENDCHAR
+STARTCHAR uniFEEE
+ENCODING 65262
+SWIDTH 600 0
+DWIDTH 10 0
+BBX 9 8 1 -4
+BITMAP
+0400
+0A00
+0A00
+0780
+0200
+0200
+8400
+7800
+ENDCHAR
+STARTCHAR uniFEEF
+ENCODING 65263
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 8 0 -2
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFEF0
+ENCODING 65264
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 6 1 -5
+BITMAP
+41E0
+8200
+8180
+8040
+4180
+3E00
+ENDCHAR
+STARTCHAR uniFEF1
+ENCODING 65265
+SWIDTH 720 0
+DWIDTH 12 0
+BBX 11 11 1 -5
+BITMAP
+01E0
+0200
+4200
+8180
+8040
+8040
+4180
+3E00
+0000
+2800
+2800
+ENDCHAR
+STARTCHAR uniFEF2
+ENCODING 65266
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 11 9 1 -8
+BITMAP
+41E0
+8200
+8180
+8040
+4180
+3E00
+0000
+2800
+2800
+ENDCHAR
+STARTCHAR uniFEF3
+ENCODING 65267
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 5 8 0 -3
+BITMAP
+10
+08
+08
+08
+F0
+00
+50
+50
+ENDCHAR
+STARTCHAR uniFEF4
+ENCODING 65268
+SWIDTH 360 0
+DWIDTH 6 0
+BBX 6 7 0 -3
+BITMAP
+10
+10
+10
+FC
+00
+28
+28
+ENDCHAR
+STARTCHAR uniFEF5
+ENCODING 65269
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 14 1 0
+BITMAP
+04
+78
+80
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
+ENDCHAR
+STARTCHAR uniFEF6
+ENCODING 65270
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 15 1 -1
+BITMAP
+0400
+7800
+8000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
+ENDCHAR
+STARTCHAR uniFEF7
+ENCODING 65271
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 15 1 0
+BITMAP
+60
+80
+60
+80
+00
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
+ENDCHAR
+STARTCHAR uniFEF8
+ENCODING 65272
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 16 1 -1
+BITMAP
+6000
+8000
+6000
+8000
+0000
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
+ENDCHAR
+STARTCHAR uniFEF9
+ENCODING 65273
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 16 1 -6
+BITMAP
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
+00
+00
+60
+80
+60
+80
+ENDCHAR
+STARTCHAR uniFEFA
+ENCODING 65274
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 17 1 -7
+BITMAP
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
+0000
+0000
+6000
+8000
+6000
+8000
+ENDCHAR
+STARTCHAR uniFEFB
+ENCODING 65275
+SWIDTH 540 0
+DWIDTH 9 0
+BBX 7 10 1 0
+BITMAP
+C4
+E6
+24
+14
+14
+08
+0C
+14
+24
+38
+ENDCHAR
+STARTCHAR uniFEFC
+ENCODING 65276
+SWIDTH 660 0
+DWIDTH 11 0
+BBX 10 11 1 -1
+BITMAP
+0200
+6300
+7200
+1200
+0A00
+0A00
+0A00
+0D00
+0900
+30C0
+E000
+ENDCHAR
+ENDFONT
Index: xc/extras/fonts/ClearlyU/cudevnag12.bdf
diff -u /dev/null xc/extras/fonts/ClearlyU/cudevnag12.bdf:1.2
--- /dev/null	Thu Feb 27 12:20:29 2003
+++ xc/extras/fonts/ClearlyU/cudevnag12.bdf	Fri Dec 13 23:00:04 2002
@@ -0,0 +1,4085 @@
+STARTFONT 2.1
+COMMENT 
+COMMENT Id: cudevnag12.bdf,v 1.1 2002/11/22 22:46:31 mleisher Exp $
+COMMENT 
+COMMENT Copyright 2002 Computing Research Labs, New Mexico State University
+COMMENT 
+COMMENT Permission is hereby granted, free of charge, to any person
+COMMENT obtaining a copy of this software and associated documentation
+COMMENT files (the "Software"), to deal in the Software without
+COMMENT restriction, including without limitation the rights to use,
+COMMENT copy, modify, merge, publish, distribute, sublicense, and/or
+COMMENT sell copies of the Software, and to permit persons to whom the
+COMMENT Software is furnished to do so, subject to the following
+COMMENT conditions:
+COMMENT 
+COMMENT The above copyright notice and this permission notice shall be
+COMMENT included in all copies or substantial portions of the Software.
+COMMENT 
+COMMENT THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+COMMENT EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+COMMENT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+COMMENT NONINFRINGEMENT.  IN NO EVENT SHALL THE COMPUTING RESEARCH LAB
+COMMENT OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY CLAIM, DAMAGES
+COMMENT OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+COMMENT OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+COMMENT SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+COMMENT 
+COMMENT This font contains glyphs to support text encoded in the Devanagari
+COMMENT section of Unicode.  Many glyphs (not characters) needed are stored
+COMMENT in the PUA area starting at E900.
+COMMENT 
+FONT -MUTT-ClearlyU Devanagari-Medium-R-Normal--15-120-90-90-P-104-FontSpecific-0
+SIZE 12 90 90
+FONTBOUNDINGBOX 25 25 -6 -7
+STARTPROPERTIES 17
+POINT_SIZE 120
+PIXEL_SIZE 15
+RESOLUTION_X 90
+RESOLUTION_Y 90
+FONT_ASCENT 12
+FONT_DESCENT 3
+AVERAGE_WIDTH 104
+SPACING "P"
+FOUNDRY "MUTT"
+FAMILY_NAME "ClearlyU Devanagari"
+WEIGHT_NAME "Medium"
+SLANT "R"
+SETWIDTH_NAME "Normal"
+ADD_STYLE_NAME ""
+CHARSET_REGISTRY "FontSpecific"
+CHARSET_ENCODING "0"
+_XMBDFED_INFO "Edited with xmbdfed 4.4."
+ENDPROPERTIES
+CHARS 217
+STARTCHAR uni0901
+ENCODING 2304
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 4 0 13
+BITMAP
+20
+A4
+8C
+78
+ENDCHAR
+STARTCHAR uni0902
+ENCODING 2305
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 1 2 0 14
+BITMAP
+80
+80
+ENDCHAR
+STARTCHAR uni0903
+ENCODING 2306
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 3 9 2 1
+BITMAP
+40
+E0
+40
+00
+00
+00
+40
+E0
+40
+ENDCHAR
+STARTCHAR uni0905
+ENCODING 2308
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 15 12 0 -1
+BITMAP
+78FE
+0420
+0220
+0420
+3C20
+83E0
+8120
+4120
+2320
+1E20
+0020
+0020
+ENDCHAR
+STARTCHAR uni0906
+ENCODING 2309
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 12 0 -1
+BITMAP
+78FFC0
+042100
+022100
+042100
+3C2100
+83E100
+822100
+422100
+262100
+1C2100
+002100
+002100
+ENDCHAR
+STARTCHAR uni0907
+ENCODING 2310
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 13 0 -2
+BITMAP
+FFC0
+0400
+7C00
+4000
+4000
+3800
+0400
+0400
+3C00
+3C00
+0400
+0200
+0100
+ENDCHAR
+STARTCHAR uni0908
+ENCODING 2311
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 18 0 -2
+BITMAP
+0C00
+1200
+1000
+0800
+0400
+FFC0
+0400
+7C00
+4000
+4000
+3800
+0400
+0400
+3C00
+3C00
+0400
+0200
+0100
+ENDCHAR
+STARTCHAR uni0909
+ENCODING 2312
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 16 11 0 0
+BITMAP
+FFFF
+0100
+0100
+0100
+1E00
+8300
+8080
+4080
+4080
+3180
+0F00
+ENDCHAR
+STARTCHAR uni090A
+ENCODING 2313
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 16 11 0 0
+BITMAP
+FFFF
+0100
+0100
+0100
+1E00
+83B0
+80C8
+4088
+4088
+3190
+0F00
+ENDCHAR
+STARTCHAR uni090B
+ENCODING 2314
+SWIDTH 1133 0
+DWIDTH 17 0
+BBX 17 12 0 -1
+BITMAP
+FFFF80
+010000
+010000
+391000
+453800
+03F000
+031000
+0D0800
+311000
+012000
+012000
+001C00
+ENDCHAR
+STARTCHAR uni090C
+ENCODING 2315
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 13 0 -2
+BITMAP
+FFFE
+0040
+0040
+0040
+78E0
+C590
+8308
+8008
+4008
+4070
+2080
+1080
+0078
+ENDCHAR
+STARTCHAR uni090D
+ENCODING 2316
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 21 0 -5
+BITMAP
+0420
+0460
+03C0
+0000
+0000
+FFF0
+4100
+4100
+4100
+4100
+4100
+4100
+4600
+2000
+1000
+0C00
+0200
+0180
+0040
+0040
+0080
+ENDCHAR
+STARTCHAR uni090E
+ENCODING 2317
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 21 0 -5
+BITMAP
+4000
+4000
+3E00
+0100
+0100
+FFF0
+4100
+4100
+4100
+4100
+4100
+4100
+4600
+2000
+1000
+0C00
+0200
+0180
+0040
+0040
+0080
+ENDCHAR
+STARTCHAR uni090F
+ENCODING 2318
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 16 0 -5
+BITMAP
+FFF0
+4100
+4100
+4100
+4100
+4100
+4100
+4600
+2000
+1000
+0C00
+0200
+0180
+0040
+0040
+0080
+ENDCHAR
+STARTCHAR uni0910
+ENCODING 2319
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 21 0 -5
+BITMAP
+6000
+1800
+0400
+0200
+0100
+FFF0
+4100
+4100
+4100
+4100
+4100
+4100
+4600
+2000
+1000
+0C00
+0200
+0180
+0040
+0040
+0080
+ENDCHAR
+STARTCHAR uni0911
+ENCODING 2320
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 16 0 -1
+BITMAP
+001080
+001180
+000F00
+000000
+78FFC0
+042100
+022100
+042100
+3C2100
+83E100
+812100
+412100
+232100
+1E2100
+002100
+002100
+ENDCHAR
+STARTCHAR uni0912
+ENCODING 2321
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 17 0 -1
+BITMAP
+004000
+004000
+003E00
+000100
+000100
+78FFC0
+042100
+022100
+042100
+3C2100
+83E100
+822100
+422100
+262100
+1C2100
+002100
+002100
+ENDCHAR
+STARTCHAR uni0913
+ENCODING 2322
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 17 0 -1
+BITMAP
+006000
+001800
+000400
+000200
+000100
+78FFC0
+042100
+022100
+042100
+3C2100
+83E100
+822100
+422100
+262100
+1C2100
+002100
+002100
+ENDCHAR
+STARTCHAR uni0914
+ENCODING 2323
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 18 0 -1
+BITMAP
+003000
+000800
+00C400
+003A00
+000700
+000100
+78FFC0
+042100
+022100
+042100
+3C2100
+83E100
+822100
+422100
+262100
+1C2100
+002100
+002100
+ENDCHAR
+STARTCHAR uni0915
+ENCODING 2324
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0400
+0400
+7400
+8DC0
+8620
+8C20
+7420
+0420
+0440
+0400
+ENDCHAR
+STARTCHAR uni0916
+ENCODING 2325
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+1020
+1020
+13A0
+B660
+E460
+44E0
+43A0
+2020
+1060
+0FA0
+ENDCHAR
+STARTCHAR uni0917
+ENCODING 2326
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+2100
+2100
+2100
+2100
+2100
+A100
+6100
+2100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0918
+ENCODING 2327
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 11 0 0
+BITMAP
+FFF8
+4080
+4080
+3C80
+3080
+2080
+2180
+1E80
+0080
+0080
+0080
+ENDCHAR
+STARTCHAR uni0919
+ENCODING 2328
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 10 0 1
+BITMAP
+FFF8
+0200
+3E00
+2000
+2020
+1E20
+8100
+8100
+4100
+3E00
+ENDCHAR
+STARTCHAR uni091A
+ENCODING 2329
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 11 0 0
+BITMAP
+FFF8
+0080
+0080
+0080
+7F80
+0880
+1080
+1180
+0E80
+0080
+0080
+ENDCHAR
+STARTCHAR uni091B
+ENCODING 2330
+SWIDTH 1066 0
+DWIDTH 16 0
+BBX 16 12 0 -1
+BITMAP
+FFFF
+0020
+0020
+3870
+40C8
+4088
+3E48
+1838
+1018
+1018
+1864
+0F84
+ENDCHAR
+STARTCHAR uni091C
+ENCODING 2331
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0040
+0040
+0040
+8FC0
+8440
+4240
+4240
+2240
+1C40
+0040
+ENDCHAR
+STARTCHAR uni091D
+ENCODING 2332
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 12 0 -1
+BITMAP
+FFFE
+0420
+7C20
+4020
+4020
+3FE0
+0420
+0420
+3C20
+3C20
+0420
+0200
+ENDCHAR
+STARTCHAR uni091E
+ENCODING 2333
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 11 0 0
+BITMAP
+FFF8
+0080
+1880
+2480
+0780
+8480
+4C80
+3880
+0080
+0080
+0080
+ENDCHAR
+STARTCHAR uni091F
+ENCODING 2334
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+0200
+0200
+3E00
+6000
+C000
+8000
+8000
+8100
+4300
+3E00
+ENDCHAR
+STARTCHAR uni0920
+ENCODING 2335
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+0200
+0200
+1E00
+3100
+6080
+4080
+4080
+4080
+2180
+1F00
+ENDCHAR
+STARTCHAR uni0921
+ENCODING 2336
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 10 0 1
+BITMAP
+FFF0
+0200
+3E00
+2000
+1000
+0E00
+8100
+8080
+4080
+3F00
+ENDCHAR
+STARTCHAR uni0922
+ENCODING 2337
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+0200
+0200
+7E00
+C000
+8000
+8600
+8D00
+4900
+2900
+1E00
+ENDCHAR
+STARTCHAR uni0923
+ENCODING 2338
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+4440
+4440
+4440
+4440
+4440
+4440
+2440
+1840
+0040
+0040
+ENDCHAR
+STARTCHAR uni0924
+ENCODING 2339
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 12 0 -1
+BITMAP
+FFF0
+0100
+0100
+0100
+7F00
+C100
+8100
+8100
+4100
+4100
+2100
+1000
+ENDCHAR
+STARTCHAR uni0925
+ENCODING 2340
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 11 0 0
+BITMAP
+67F0
+D100
+8900
+7900
+3100
+E100
+4100
+2100
+1F00
+0100
+0100
+ENDCHAR
+STARTCHAR uni0926
+ENCODING 2341
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+0400
+0400
+7C00
+8000
+8000
+8600
+4600
+3E00
+0200
+0100
+ENDCHAR
+STARTCHAR uni0927
+ENCODING 2342
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 11 0 0
+BITMAP
+47F0
+8100
+8100
+7900
+6100
+4100
+4300
+3D00
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0928
+ENCODING 2343
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+0100
+0100
+0100
+FF00
+C100
+4100
+2100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0929
+ENCODING 2344
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+0100
+0100
+0100
+FF00
+C100
+4100
+2100
+0100
+0900
+0900
+ENDCHAR
+STARTCHAR uni092A
+ENCODING 2345
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+4200
+4200
+4200
+4200
+4200
+4600
+3A00
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni092B
+ENCODING 2346
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+4200
+4200
+42E0
+4310
+4610
+3A10
+0210
+0220
+0200
+0200
+ENDCHAR
+STARTCHAR uni092C
+ENCODING 2347
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+0200
+0200
+7A00
+E600
+9600
+8E00
+7A00
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni092D
+ENCODING 2348
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 11 0 0
+BITMAP
+C7F0
+A100
+9100
+7100
+1100
+FF00
+6100
+2100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni092E
+ENCODING 2349
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+2100
+2100
+2100
+2100
+FF00
+6100
+2100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni092F
+ENCODING 2350
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+1100
+1100
+2100
+C100
+8100
+4300
+3D00
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0930
+ENCODING 2351
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 11 12 0 -1
+BITMAP
+FFE0
+0400
+0400
+0400
+2C00
+3800
+1000
+1000
+0800
+0800
+0400
+0200
+ENDCHAR
+STARTCHAR uni0931
+ENCODING 2352
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 11 12 0 -1
+BITMAP
+FFE0
+0400
+0400
+0400
+2C00
+3800
+1000
+1000
+0800
+2800
+2400
+0200
+ENDCHAR
+STARTCHAR uni0932
+ENCODING 2353
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+0020
+0020
+0020
+78E0
+8520
+8220
+8020
+4020
+4020
+2020
+ENDCHAR
+STARTCHAR uni0933
+ENCODING 2354
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0020
+0020
+0020
+7860
+C490
+8108
+8208
+8308
+4498
+3870
+ENDCHAR
+STARTCHAR uni0934
+ENCODING 2355
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 15 0 -4
+BITMAP
+FFFC
+0020
+0020
+0020
+7860
+C490
+8108
+8208
+8308
+4498
+3870
+0000
+0000
+0200
+0200
+ENDCHAR
+STARTCHAR uni0935
+ENCODING 2356
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+0200
+0200
+7A00
+8600
+8600
+8600
+7A00
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni0936
+ENCODING 2357
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+1440
+2240
+2240
+2240
+1E40
+2240
+5C40
+3840
+0440
+0440
+ENDCHAR
+STARTCHAR uni0937
+ENCODING 2358
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+6200
+5200
+5200
+4A00
+4A00
+2600
+1E00
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni0938
+ENCODING 2359
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 12 0 -1
+BITMAP
+FFF8
+1080
+1080
+1080
+B180
+FE80
+4080
+4080
+2080
+2080
+1080
+0800
+ENDCHAR
+STARTCHAR uni0939
+ENCODING 2360
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 14 0 -3
+BITMAP
+FFE0
+0200
+0200
+1E00
+2000
+1000
+1E00
+3100
+2100
+2200
+2000
+1000
+0800
+0600
+ENDCHAR
+STARTCHAR uni093C
+ENCODING 2363
+SWIDTH 66 0
+DWIDTH 1 0
+BBX 1 2 0 -2
+BITMAP
+80
+80
+ENDCHAR
+STARTCHAR uni093D
+ENCODING 2364
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 7 12 1 -1
+BITMAP
+3E
+60
+40
+40
+20
+10
+88
+88
+84
+84
+4C
+38
+ENDCHAR
+STARTCHAR uni093E
+ENCODING 2365
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 11 0 0
+BITMAP
+FC
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR uni093F
+ENCODING 2366
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 9 16 0 0
+BITMAP
+3C00
+4300
+4080
+4000
+4000
+FC00
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+ENDCHAR
+STARTCHAR uni0940
+ENCODING 2367
+SWIDTH 333 0
+DWIDTH 5 0
+BBX 12 16 -5 0
+BITMAP
+7800
+8400
+8200
+8100
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0941
+ENCODING 2368
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 8 4 0 -4
+BITMAP
+0E
+89
+61
+1F
+ENDCHAR
+STARTCHAR uni0942
+ENCODING 2369
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 5 0 -5
+BITMAP
+E0
+98
+84
+42
+30
+ENDCHAR
+STARTCHAR uni0943
+ENCODING 2370
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 4 0 -4
+BITMAP
+70
+C0
+80
+78
+ENDCHAR
+STARTCHAR uni0944
+ENCODING 2371
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 7 0 -7
+BITMAP
+70
+80
+80
+78
+80
+80
+7C
+ENDCHAR
+STARTCHAR uni0945
+ENCODING 2372
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 3 0 13
+BITMAP
+84
+44
+38
+ENDCHAR
+STARTCHAR uni0946
+ENCODING 2373
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 5 0 10
+BITMAP
+80
+80
+7C
+02
+02
+ENDCHAR
+STARTCHAR uni0947
+ENCODING 2374
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 5 0 11
+BITMAP
+E0
+10
+08
+04
+02
+ENDCHAR
+STARTCHAR uni0948
+ENCODING 2375
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 8 6 0 11
+BITMAP
+30
+18
+E4
+7A
+06
+01
+ENDCHAR
+STARTCHAR uni0949
+ENCODING 2376
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 15 -1 0
+BITMAP
+84
+44
+38
+00
+7E
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni094A
+ENCODING 2377
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 16 -5 0
+BITMAP
+8000
+8000
+7C00
+0200
+0200
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni094B
+ENCODING 2378
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 16 -5 0
+BITMAP
+E000
+1000
+0800
+0400
+0200
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni094C
+ENCODING 2379
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 17 -6 0
+BITMAP
+3000
+1800
+E400
+7A00
+0600
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni094D
+ENCODING 2380
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 3 0 -3
+BITMAP
+E0
+10
+08
+ENDCHAR
+STARTCHAR uni0950
+ENCODING 2383
+SWIDTH 1066 0
+DWIDTH 16 0
+BBX 15 13 1 -1
+BITMAP
+0010
+0092
+7882
+0446
+023C
+0400
+080C
+1E12
+8132
+81AC
+4140
+2300
+1E00
+ENDCHAR
+STARTCHAR uni0951
+ENCODING 2384
+SWIDTH 66 0
+DWIDTH 1 0
+BBX 1 4 0 11
+BITMAP
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni0952
+ENCODING 2385
+SWIDTH 266 0
+DWIDTH 4 0
+BBX 4 4 0 11
+BITMAP
+80
+40
+20
+10
+ENDCHAR
+STARTCHAR uni0953
+ENCODING 2386
+SWIDTH 266 0
+DWIDTH 4 0
+BBX 4 4 0 11
+BITMAP
+10
+20
+40
+80
+ENDCHAR
+STARTCHAR uni0958
+ENCODING 2391
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0400
+0400
+7400
+8DC0
+8620
+8C20
+7420
+0420
+2440
+2400
+ENDCHAR
+STARTCHAR uni0959
+ENCODING 2392
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 15 0 -4
+BITMAP
+FFFC
+1020
+1020
+13A0
+B660
+E460
+44E0
+43A0
+2020
+1060
+0FA0
+0000
+0000
+0100
+0100
+ENDCHAR
+STARTCHAR uni095A
+ENCODING 2393
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+2100
+2100
+2100
+2100
+2100
+A100
+6100
+2100
+0900
+0900
+ENDCHAR
+STARTCHAR uni095B
+ENCODING 2394
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 15 0 -4
+BITMAP
+FFFC
+0040
+0040
+0040
+8FC0
+8440
+4240
+4240
+2240
+1C40
+0040
+0000
+0000
+0200
+0200
+ENDCHAR
+STARTCHAR uni095C
+ENCODING 2395
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 15 0 -4
+BITMAP
+FFF0
+0200
+3E00
+2000
+2000
+1E00
+8100
+8100
+4100
+3E00
+0000
+0000
+0000
+0400
+0400
+ENDCHAR
+STARTCHAR uni095D
+ENCODING 2396
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 15 0 -4
+BITMAP
+FFE0
+0200
+0200
+7E00
+C000
+8000
+8600
+8D00
+4900
+2900
+1E00
+0000
+0000
+0800
+0800
+ENDCHAR
+STARTCHAR uni095E
+ENCODING 2397
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+4200
+4200
+42C0
+4320
+4610
+3A10
+0210
+0210
+1220
+1200
+ENDCHAR
+STARTCHAR uni095F
+ENCODING 2398
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 12 15 0 -4
+BITMAP
+FFF0
+1100
+1100
+2100
+C100
+8100
+4300
+3D00
+0100
+0100
+0100
+0000
+0000
+1000
+1000
+ENDCHAR
+STARTCHAR uni0960
+ENCODING 2399
+SWIDTH 1133 0
+DWIDTH 17 0
+BBX 17 14 0 -3
+BITMAP
+FFFF80
+010000
+010000
+391000
+453800
+03F000
+030800
+0D0800
+311000
+012400
+012800
+001200
+001400
+000800
+ENDCHAR
+STARTCHAR uni0961
+ENCODING 2400
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 15 0 -4
+BITMAP
+FFFE
+0040
+0040
+0040
+78E0
+C590
+8308
+8008
+4070
+40C0
+2080
+1070
+00C0
+0080
+0078
+ENDCHAR
+STARTCHAR uni0962
+ENCODING 2401
+SWIDTH 533 0
+DWIDTH 8 0
+BBX 8 5 0 -5
+BITMAP
+6C
+92
+82
+44
+03
+ENDCHAR
+STARTCHAR uni0963
+ENCODING 2402
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 7 0 -7
+BITMAP
+6C
+92
+84
+48
+06
+08
+06
+ENDCHAR
+STARTCHAR uni0964
+ENCODING 2403
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 1 11 7 -1
+BITMAP
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+80
+ENDCHAR
+STARTCHAR uni0965
+ENCODING 2404
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 5 11 5 -1
+BITMAP
+88
+88
+88
+88
+88
+88
+88
+88
+88
+88
+88
+ENDCHAR
+STARTCHAR uni0966
+ENCODING 2405
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 7 0 2
+BITMAP
+70
+C8
+84
+84
+84
+4C
+38
+ENDCHAR
+STARTCHAR uni0967
+ENCODING 2406
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 5 15 1 -4
+BITMAP
+60
+D0
+88
+88
+78
+08
+10
+20
+40
+C0
+40
+20
+10
+38
+08
+ENDCHAR
+STARTCHAR uni0968
+ENCODING 2407
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 8 12 1 -2
+BITMAP
+FC
+02
+01
+01
+61
+7E
+38
+10
+08
+04
+02
+02
+ENDCHAR
+STARTCHAR uni0969
+ENCODING 2408
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 7 13 1 -2
+BITMAP
+F0
+08
+08
+08
+78
+04
+04
+04
+78
+78
+08
+04
+02
+ENDCHAR
+STARTCHAR uni096A
+ENCODING 2409
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 10 10 1 1
+BITMAP
+8040
+40C0
+2180
+1300
+0E00
+0C00
+1A00
+1200
+1600
+0C00
+ENDCHAR
+STARTCHAR uni096B
+ENCODING 2410
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 9 12 1 -1
+BITMAP
+8000
+8000
+8600
+8600
+4600
+3C00
+0200
+0200
+0100
+0100
+0080
+0080
+ENDCHAR
+STARTCHAR uni096C
+ENCODING 2411
+SWIDTH 533 0
+DWIDTH 8 0
+BBX 6 13 2 -2
+BITMAP
+70
+80
+80
+80
+78
+40
+40
+40
+3C
+3C
+20
+40
+80
+ENDCHAR
+STARTCHAR uni096D
+ENCODING 2412
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 10 11 1 0
+BITMAP
+8000
+8000
+8300
+8680
+4440
+4440
+42C0
+21C0
+2040
+1880
+0700
+ENDCHAR
+STARTCHAR uni096E
+ENCODING 2413
+SWIDTH 533 0
+DWIDTH 8 0
+BBX 7 11 1 0
+BITMAP
+02
+04
+08
+10
+20
+40
+80
+80
+86
+4C
+38
+ENDCHAR
+STARTCHAR uni096F
+ENCODING 2414
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 9 14 1 -3
+BITMAP
+7000
+C800
+8800
+9800
+7000
+2000
+2000
+1000
+0800
+0400
+0200
+0100
+0380
+0100
+ENDCHAR
+STARTCHAR uni0970
+ENCODING 2415
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 5 5 3 5
+BITMAP
+70
+88
+88
+88
+70
+ENDCHAR
+STARTCHAR uni0000
+ENCODING 59648
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 13 0 -2
+BITMAP
+31FE
+6840
+4440
+4CC0
+29C0
+7E40
+C040
+8040
+8440
+8E40
+7E40
+0400
+0200
+ENDCHAR
+STARTCHAR uni0001
+ENCODING 59649
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 11 0 0
+BITMAP
+FFF8
+0100
+0100
+7F00
+3100
+0900
+0500
+6500
+7900
+1100
+0900
+ENDCHAR
+STARTCHAR uni0002
+ENCODING 59650
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+0040
+0040
+0040
+FFC0
+1040
+2040
+2040
+2040
+1040
+0840
+ENDCHAR
+STARTCHAR uni0003
+ENCODING 59651
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+0200
+0200
+3A00
+4600
+0600
+0A00
+1200
+2200
+0200
+0200
+ENDCHAR
+STARTCHAR uni0004
+ENCODING 59652
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 12 0 -1
+BITMAP
+FFFE
+1840
+2440
+2440
+1840
+6740
+00C0
+7C40
+18C0
+10C0
+1140
+0E00
+ENDCHAR
+STARTCHAR uni0005
+ENCODING 59653
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+1840
+2440
+2440
+1840
+6740
+00C0
+01C0
+0240
+0440
+0040
+ENDCHAR
+STARTCHAR uni0006
+ENCODING 59654
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+1840
+2440
+2440
+1840
+6740
+08C0
+08C0
+08C0
+0740
+0040
+ENDCHAR
+STARTCHAR uni0007
+ENCODING 59655
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0400
+0400
+7400
+8DC0
+8620
+8C20
+7420
+1420
+6440
+8400
+ENDCHAR
+STARTCHAR uni0008
+ENCODING 59656
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 11 0 0
+BITMAP
+FFFFC0
+000800
+000800
+000800
+8FF800
+840800
+820800
+421800
+232800
+1E4800
+008800
+ENDCHAR
+STARTCHAR uni0009
+ENCODING 59657
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 11 0 0
+BITMAP
+FFFFC0
+000800
+000800
+000800
+8FF800
+840800
+82C800
+429800
+232800
+1E4800
+008800
+ENDCHAR
+STARTCHAR uni000A
+ENCODING 59658
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+4200
+4200
+42C0
+4320
+4210
+3E10
+0A10
+1210
+2220
+4200
+ENDCHAR
+STARTCHAR uni000B
+ENCODING 59659
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 11 0 0
+BITMAP
+FFFE
+4200
+4200
+42C0
+4320
+4210
+3E10
+8A10
+9210
+2220
+4200
+ENDCHAR
+STARTCHAR uni000C
+ENCODING 59660
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+4200
+4200
+4200
+4200
+4200
+3E00
+0A00
+1200
+2200
+4200
+ENDCHAR
+STARTCHAR uni000D
+ENCODING 59661
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 12 0 -1
+BITMAP
+FFFC
+1040
+1040
+1040
+B0C0
+FFC0
+40C0
+4140
+2240
+2440
+1040
+0800
+ENDCHAR
+STARTCHAR uni000E
+ENCODING 59662
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 12 0 -1
+BITMAP
+FFF0
+0200
+0200
+0200
+2700
+3C80
+1080
+1180
+0800
+0400
+0200
+0100
+ENDCHAR
+STARTCHAR uni000F
+ENCODING 59663
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0400
+0400
+0400
+2D80
+1F60
+1210
+11C8
+0800
+0400
+0200
+ENDCHAR
+STARTCHAR uni0015
+ENCODING 59669
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 11 0 0
+BITMAP
+FFC0
+0400
+0400
+7400
+8DC0
+8600
+8C00
+7400
+0400
+0400
+0400
+ENDCHAR
+STARTCHAR uni0016
+ENCODING 59670
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 11 0 0
+BITMAP
+FFC0
+1000
+1000
+1380
+B640
+E440
+44C0
+4380
+2000
+1040
+0F80
+ENDCHAR
+STARTCHAR uni0017
+ENCODING 59671
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 9 0 2
+BITMAP
+FE
+20
+20
+20
+20
+20
+A0
+60
+20
+ENDCHAR
+STARTCHAR uni0018
+ENCODING 59672
+SWIDTH 533 0
+DWIDTH 8 0
+BBX 8 8 0 3
+BITMAP
+FF
+40
+40
+3C
+30
+20
+21
+1E
+ENDCHAR
+STARTCHAR uni0019
+ENCODING 59673
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 10 0 1
+BITMAP
+FFF8
+0200
+3E00
+2000
+2020
+1E20
+8100
+8100
+4100
+3E00
+ENDCHAR
+STARTCHAR uni001A
+ENCODING 59674
+SWIDTH 533 0
+DWIDTH 8 0
+BBX 8 9 0 2
+BITMAP
+FF
+00
+00
+00
+7F
+08
+10
+11
+0E
+ENDCHAR
+STARTCHAR uni001B
+ENCODING 59675
+SWIDTH 1066 0
+DWIDTH 16 0
+BBX 16 12 0 -1
+BITMAP
+FFFF
+0020
+0020
+3870
+40C8
+4088
+3E48
+1838
+1018
+1018
+1864
+0F84
+ENDCHAR
+STARTCHAR uni001C
+ENCODING 59676
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 10 0 1
+BITMAP
+FF80
+0000
+0000
+0000
+8F80
+8400
+4200
+4200
+2200
+1C00
+ENDCHAR
+STARTCHAR uni001D
+ENCODING 59677
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 12 0 -1
+BITMAP
+FFC0
+0400
+7C00
+4000
+4000
+3FC0
+0400
+0400
+3C00
+3C00
+0400
+0200
+ENDCHAR
+STARTCHAR uni001E
+ENCODING 59678
+SWIDTH 533 0
+DWIDTH 8 0
+BBX 8 8 0 3
+BITMAP
+FF
+00
+18
+24
+07
+84
+4C
+38
+ENDCHAR
+STARTCHAR uni001F
+ENCODING 59679
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+0200
+0200
+3E00
+6000
+C000
+8000
+8000
+8100
+4300
+3E00
+ENDCHAR
+STARTCHAR uni0020
+ENCODING 59680
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 11 0 0
+BITMAP
+FFF0
+0200
+0200
+1E00
+3100
+6080
+4080
+4080
+4080
+2180
+1F00
+ENDCHAR
+STARTCHAR uni0021
+ENCODING 59681
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 10 0 1
+BITMAP
+FFF0
+0200
+3E00
+2000
+1000
+0E00
+8100
+8080
+4080
+3F00
+ENDCHAR
+STARTCHAR uni0022
+ENCODING 59682
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+0200
+0200
+7E00
+C000
+8000
+8600
+8D00
+4900
+2900
+1E00
+ENDCHAR
+STARTCHAR uni0023
+ENCODING 59683
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 9 0 2
+BITMAP
+FF80
+4400
+4400
+4400
+4400
+4400
+4400
+2400
+1800
+ENDCHAR
+STARTCHAR uni0024
+ENCODING 59684
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 12 0 -1
+BITMAP
+FE
+00
+00
+00
+7E
+C0
+80
+80
+40
+40
+20
+10
+ENDCHAR
+STARTCHAR uni0025
+ENCODING 59685
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 9 0 2
+BITMAP
+66
+D0
+88
+78
+30
+E0
+40
+20
+1E
+ENDCHAR
+STARTCHAR uni0026
+ENCODING 59686
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+0400
+0400
+7C00
+8000
+8000
+8600
+4600
+3E00
+0200
+0100
+ENDCHAR
+STARTCHAR uni0027
+ENCODING 59687
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 8 0 3
+BITMAP
+46
+80
+80
+78
+60
+40
+42
+3C
+ENDCHAR
+STARTCHAR uni0028
+ENCODING 59688
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 8 0 3
+BITMAP
+FE
+00
+00
+00
+FE
+C0
+40
+20
+ENDCHAR
+STARTCHAR uni0029
+ENCODING 59689
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 11 0 0
+BITMAP
+FE
+00
+00
+00
+FE
+C0
+40
+20
+00
+08
+08
+ENDCHAR
+STARTCHAR uni002A
+ENCODING 59690
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 8 0 3
+BITMAP
+FC
+40
+40
+40
+40
+40
+44
+38
+ENDCHAR
+STARTCHAR uni002B
+ENCODING 59691
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 11 0 0
+BITMAP
+FFE0
+4200
+4200
+42E0
+4300
+4600
+3A00
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni002C
+ENCODING 59692
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 8 0 3
+BITMAP
+FC
+00
+00
+78
+E4
+94
+8C
+78
+ENDCHAR
+STARTCHAR uni002D
+ENCODING 59693
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 8 0 3
+BITMAP
+C6
+A0
+90
+70
+10
+FE
+60
+20
+ENDCHAR
+STARTCHAR uni002E
+ENCODING 59694
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 8 0 3
+BITMAP
+FE
+20
+20
+20
+20
+FE
+60
+20
+ENDCHAR
+STARTCHAR uni002F
+ENCODING 59695
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 8 0 3
+BITMAP
+FE
+10
+10
+20
+C0
+80
+42
+3C
+ENDCHAR
+STARTCHAR uni0030
+ENCODING 59696
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 12 0 -1
+BITMAP
+FFE0
+0400
+0400
+0400
+2C00
+3800
+1000
+1000
+0800
+0800
+0400
+0200
+ENDCHAR
+STARTCHAR uni0031
+ENCODING 59697
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 12 0 -1
+BITMAP
+FFE0
+0400
+0400
+0400
+2C00
+3800
+1000
+1000
+0800
+2800
+2400
+0200
+ENDCHAR
+STARTCHAR uni0032
+ENCODING 59698
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 10 11 0 0
+BITMAP
+FFC0
+0000
+0000
+0000
+78C0
+8500
+8200
+8000
+4000
+4000
+2000
+ENDCHAR
+STARTCHAR uni0033
+ENCODING 59699
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 11 0 0
+BITMAP
+FFF8
+0000
+0000
+0000
+7860
+C490
+8108
+8208
+8308
+4498
+3870
+ENDCHAR
+STARTCHAR uni0034
+ENCODING 59700
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 15 0 -4
+BITMAP
+FFF8
+0000
+0000
+0000
+7860
+C490
+8108
+8208
+8308
+4498
+3870
+0000
+0000
+0200
+0200
+ENDCHAR
+STARTCHAR uni0035
+ENCODING 59701
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 8 0 3
+BITMAP
+FC
+00
+00
+78
+84
+84
+84
+78
+ENDCHAR
+STARTCHAR uni0036
+ENCODING 59702
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 11 0 0
+BITMAP
+FF80
+1400
+2200
+2200
+2200
+1E00
+2200
+5C00
+3800
+0400
+0400
+ENDCHAR
+STARTCHAR uni0037
+ENCODING 59703
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 8 0 3
+BITMAP
+FC
+60
+50
+50
+48
+48
+24
+1C
+ENDCHAR
+STARTCHAR uni0038
+ENCODING 59704
+SWIDTH 533 0
+DWIDTH 8 0
+BBX 8 12 0 -1
+BITMAP
+FF
+10
+10
+10
+B1
+FE
+40
+40
+20
+20
+10
+08
+ENDCHAR
+STARTCHAR uni0039
+ENCODING 59705
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 14 0 -3
+BITMAP
+FFE0
+0200
+0200
+1E00
+2000
+1000
+1E00
+3100
+2100
+2200
+2000
+1000
+0800
+0600
+ENDCHAR
+STARTCHAR uni0040
+ENCODING 59712
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 11 0 0
+BITMAP
+FFC0
+0400
+7580
+8E40
+8C40
+7480
+8F80
+8C40
+7440
+0480
+0400
+ENDCHAR
+STARTCHAR uni0041
+ENCODING 59713
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 12 0 -1
+BITMAP
+FFFE
+0040
+0040
+0040
+FFDC
+3062
+2042
+2042
+2042
+1044
+0840
+0400
+ENDCHAR
+STARTCHAR uni0042
+ENCODING 59714
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 16 0 -5
+BITMAP
+FFFC
+0100
+3F00
+2000
+2020
+1E20
+8100
+8100
+4100
+3E00
+0400
+3500
+4E80
+4C80
+3480
+0400
+ENDCHAR
+STARTCHAR uni0043
+ENCODING 59715
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 16 0 -5
+BITMAP
+FFFC
+0100
+3F00
+2000
+2020
+1E20
+8100
+8100
+4100
+3F00
+6100
+CD00
+9300
+5300
+4D00
+2100
+ENDCHAR
+STARTCHAR uni0044
+ENCODING 59716
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 16 0 -5
+BITMAP
+FFFC
+0100
+3F00
+2000
+2020
+1E20
+8100
+8100
+4100
+3F00
+1100
+1100
+3100
+3100
+1100
+0100
+ENDCHAR
+STARTCHAR uni0045
+ENCODING 59717
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 16 0 -5
+BITMAP
+FFFC
+0200
+3E00
+2000
+2020
+1E20
+8100
+8100
+4100
+7E00
+4200
+4200
+3A00
+2200
+1E00
+0200
+ENDCHAR
+STARTCHAR uni0046
+ENCODING 59718
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0040
+1840
+47C0
+2440
+1840
+0040
+47C0
+4440
+2240
+1C40
+ENDCHAR
+STARTCHAR uni0047
+ENCODING 59719
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 13 0 -2
+BITMAP
+FFFC
+0080
+0080
+0F80
+1000
+1000
+30C0
+50C0
+4FC0
+2040
+1840
+10C0
+0F40
+ENDCHAR
+STARTCHAR uni0048
+ENCODING 59720
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 14 0 -3
+BITMAP
+FFE0
+0400
+0400
+3C00
+4000
+2000
+3C00
+4000
+4000
+4300
+3F00
+0300
+0100
+0080
+ENDCHAR
+STARTCHAR uni0049
+ENCODING 59721
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 13 0 -2
+BITMAP
+FFFC
+0080
+0080
+0F80
+1000
+1000
+10C0
+50C0
+4FC0
+4040
+3860
+1080
+0F00
+ENDCHAR
+STARTCHAR uni004A
+ENCODING 59722
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 14 0 -3
+BITMAP
+FFE0
+0400
+0400
+7C00
+8000
+8000
+8600
+8600
+7E00
+1E00
+3300
+2A80
+2600
+1C00
+ENDCHAR
+STARTCHAR uni004B
+ENCODING 59723
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 13 0 -2
+BITMAP
+FFF8
+0080
+0080
+0F80
+1000
+1000
+1180
+9180
+4F80
+4080
+4080
+FF80
+C080
+ENDCHAR
+STARTCHAR uni004C
+ENCODING 59724
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 12 0 -1
+BITMAP
+FFFC
+0440
+0440
+7C40
+8040
+8040
+8C40
+8C40
+7C40
+0440
+0FC0
+0C40
+ENDCHAR
+STARTCHAR uni004D
+ENCODING 59725
+SWIDTH 1000 0
+DWIDTH 15 0
+BBX 15 12 0 -1
+BITMAP
+FFFE
+0220
+0220
+3E20
+4020
+4020
+4620
+4620
+3E20
+0420
+0260
+01C0
+ENDCHAR
+STARTCHAR uni004E
+ENCODING 59726
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 14 0 -3
+BITMAP
+FFE0
+0400
+0400
+7C00
+8000
+8000
+8600
+8600
+7E00
+1E00
+2300
+2280
+2200
+1C00
+ENDCHAR
+STARTCHAR uni004F
+ENCODING 59727
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 17 0 -6
+BITMAP
+FFF0
+0200
+0200
+7E00
+C000
+8000
+8080
+C180
+7F00
+0200
+0200
+7E00
+C000
+8000
+8080
+C180
+7F00
+ENDCHAR
+STARTCHAR uni0050
+ENCODING 59728
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 17 0 -6
+BITMAP
+FFF0
+0200
+0200
+7E00
+C000
+8000
+8100
+C300
+7E00
+0200
+3E00
+6200
+C100
+8100
+8100
+4300
+3E00
+ENDCHAR
+STARTCHAR uni0051
+ENCODING 59729
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 16 0 -5
+BITMAP
+FFF0
+0200
+0200
+3E00
+6100
+C100
+8100
+8300
+7E00
+0200
+3E00
+6100
+C100
+8100
+8300
+7E00
+ENDCHAR
+STARTCHAR uni0052
+ENCODING 59730
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 16 0 -5
+BITMAP
+FFFC
+0100
+3F00
+2000
+2000
+1E00
+8100
+8100
+4100
+3F00
+1100
+1100
+3100
+3100
+1100
+0100
+ENDCHAR
+STARTCHAR uni0053
+ENCODING 59731
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 18 0 -7
+BITMAP
+FFF0
+0100
+0100
+3F00
+2000
+3C00
+8600
+8200
+4600
+3E00
+0200
+3E00
+2000
+3C00
+8600
+8200
+4600
+3C00
+ENDCHAR
+STARTCHAR uni0054
+ENCODING 59732
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 18 0 -7
+BITMAP
+FFF0
+0100
+0100
+3F00
+2000
+3C00
+8600
+8200
+4600
+3E00
+0200
+3E00
+4000
+8000
+9C00
+A200
+6200
+3C00
+ENDCHAR
+STARTCHAR uni0055
+ENCODING 59733
+SWIDTH 933 0
+DWIDTH 14 0
+BBX 14 11 0 0
+BITMAP
+FFFC
+0080
+0080
+7880
+6480
+2380
+0E80
+3880
+3080
+1080
+0080
+ENDCHAR
+STARTCHAR uni0056
+ENCODING 59734
+SWIDTH 1066 0
+DWIDTH 16 0
+BBX 16 15 0 -4
+BITMAP
+FFFF
+0210
+0210
+3E10
+4010
+2010
+3C10
+6210
+4110
+43F0
+4310
+2010
+1000
+0C00
+0300
+ENDCHAR
+STARTCHAR uni0057
+ENCODING 59735
+SWIDTH 1066 0
+DWIDTH 16 0
+BBX 16 15 0 -4
+BITMAP
+FFFF
+0210
+0210
+3E10
+4010
+2010
+3C10
+6210
+4110
+4130
+4250
+2190
+1000
+0C00
+0300
+ENDCHAR
+STARTCHAR uni0058
+ENCODING 59736
+SWIDTH 1266 0
+DWIDTH 19 0
+BBX 19 15 0 -4
+BITMAP
+FFFFE0
+000200
+000200
+003E00
+004000
+002000
+003C00
+006200
+004100
+3BC100
+464200
+422000
+401000
+200C00
+180300
+ENDCHAR
+STARTCHAR uni0059
+ENCODING 59737
+SWIDTH 1066 0
+DWIDTH 16 0
+BBX 16 15 0 -4
+BITMAP
+FFFF
+0010
+0010
+01F0
+0200
+0100
+01E0
+0310
+0208
+0208
+3E10
+6300
+4280
+4660
+3C18
+ENDCHAR
+STARTCHAR uni005A
+ENCODING 59738
+SWIDTH 1200 0
+DWIDTH 18 0
+BBX 18 11 0 0
+BITMAP
+FFFFC0
+100800
+100800
+10E800
+B01800
+FE1800
+402800
+404800
+208800
+100800
+080800
+ENDCHAR
+STARTCHAR uni0070
+ENCODING 59760
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 13 0 -2
+BITMAP
+3180
+6800
+4400
+4C80
+2980
+7E00
+C000
+8000
+8400
+8E00
+7E00
+0400
+0200
+ENDCHAR
+STARTCHAR uni0071
+ENCODING 59761
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 11 0 0
+BITMAP
+FFF8
+0100
+0100
+7F00
+3100
+0900
+0500
+6500
+7900
+1100
+0900
+ENDCHAR
+STARTCHAR uni0072
+ENCODING 59762
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 11 0 0
+BITMAP
+FF80
+0000
+0000
+0000
+FF80
+1000
+2000
+2000
+2000
+1000
+0800
+ENDCHAR
+STARTCHAR uni0073
+ENCODING 59763
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 9 0 2
+BITMAP
+FC
+00
+00
+78
+84
+04
+08
+30
+40
+ENDCHAR
+STARTCHAR uni0074
+ENCODING 59764
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 12 0 -1
+BITMAP
+FF80
+1800
+2400
+2400
+1800
+6700
+0080
+7C00
+1880
+1080
+1100
+0E00
+ENDCHAR
+STARTCHAR uni0075
+ENCODING 59765
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 10 0 1
+BITMAP
+FF80
+1800
+2400
+2400
+1800
+6700
+0080
+0180
+0200
+0400
+ENDCHAR
+STARTCHAR uni0076
+ENCODING 59766
+SWIDTH 600 0
+DWIDTH 9 0
+BBX 9 10 0 1
+BITMAP
+FF80
+1800
+2400
+2400
+1800
+6700
+0880
+0880
+0880
+0700
+ENDCHAR
+STARTCHAR uni007B
+ENCODING 59771
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 4 7 0 10
+BITMAP
+60
+90
+A0
+A0
+80
+40
+20
+ENDCHAR
+STARTCHAR uni007C
+ENCODING 59772
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 16 0 -5
+BITMAP
+FFE0
+0200
+0200
+3E00
+4000
+2000
+3C00
+6200
+4100
+4100
+4200
+2000
+1000
+2C00
+4300
+8000
+ENDCHAR
+STARTCHAR uni007D
+ENCODING 59773
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 8 7 0 4
+BITMAP
+FF
+00
+00
+00
+00
+43
+3C
+ENDCHAR
+STARTCHAR uni007E
+ENCODING 59774
+SWIDTH 266 0
+DWIDTH 4 0
+BBX 4 7 0 10
+BITMAP
+60
+90
+80
+80
+80
+40
+20
+ENDCHAR
+STARTCHAR uni007F
+ENCODING 59775
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 5 5 0 -5
+BITMAP
+20
+30
+68
+C0
+80
+ENDCHAR
+STARTCHAR uni0080
+ENCODING 59776
+SWIDTH 466 0
+DWIDTH 7 0
+BBX 7 15 -1 0
+BITMAP
+B4
+44
+38
+00
+7E
+20
+20
+20
+20
+20
+20
+20
+20
+20
+20
+ENDCHAR
+STARTCHAR uni0081
+ENCODING 59777
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 14 0 0
+BITMAP
+60
+00
+00
+FC
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR uni0082
+ENCODING 59778
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 17 0 0
+BITMAP
+60
+90
+80
+80
+80
+40
+FC
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR uni0083
+ENCODING 59779
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 6 17 0 0
+BITMAP
+60
+90
+A0
+A0
+80
+40
+FC
+40
+40
+40
+40
+40
+40
+40
+40
+40
+40
+ENDCHAR
+STARTCHAR uni0084
+ENCODING 59780
+SWIDTH 400 0
+DWIDTH 6 0
+BBX 9 18 0 0
+BITMAP
+0080
+0080
+3C00
+4300
+4080
+4000
+4000
+FC00
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+ENDCHAR
+STARTCHAR uni0085
+ENCODING 59781
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 17 0 0
+BITMAP
+0070
+3C80
+4380
+4080
+4000
+4000
+FC00
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+ENDCHAR
+STARTCHAR uni0086
+ENCODING 59782
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 17 0 0
+BITMAP
+0070
+3C80
+43A0
+40A0
+4000
+4000
+FC00
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+4000
+ENDCHAR
+STARTCHAR uni0087
+ENCODING 59783
+SWIDTH 333 0
+DWIDTH 5 0
+BBX 12 16 -5 0
+BITMAP
+7800
+8440
+8240
+8100
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0088
+ENCODING 59784
+SWIDTH 333 0
+DWIDTH 5 0
+BBX 12 16 -5 0
+BITMAP
+78C0
+8520
+8300
+8100
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0089
+ENCODING 59785
+SWIDTH 333 0
+DWIDTH 5 0
+BBX 12 16 -5 0
+BITMAP
+78C0
+8520
+8340
+8140
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni008A
+ENCODING 59786
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 6 4 0 13
+BITMAP
+10
+94
+44
+38
+ENDCHAR
+STARTCHAR uni008B
+ENCODING 59787
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 7 6 0 11
+BITMAP
+02
+E2
+10
+08
+04
+02
+ENDCHAR
+STARTCHAR uni008C
+ENCODING 59788
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 5 0 11
+BITMAP
+E180
+1240
+0A00
+0600
+0200
+ENDCHAR
+STARTCHAR uni008D
+ENCODING 59789
+SWIDTH 666 0
+DWIDTH 10 0
+BBX 10 5 0 11
+BITMAP
+E180
+1240
+0A80
+0680
+0200
+ENDCHAR
+STARTCHAR uni008E
+ENCODING 59790
+SWIDTH 0 0
+DWIDTH 0 0
+BBX 8 6 0 11
+BITMAP
+31
+19
+E4
+7A
+06
+01
+ENDCHAR
+STARTCHAR uni008F
+ENCODING 59791
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 6 0 11
+BITMAP
+3000
+1830
+E448
+7A40
+0640
+0140
+ENDCHAR
+STARTCHAR uni0090
+ENCODING 59792
+SWIDTH 866 0
+DWIDTH 13 0
+BBX 13 6 0 11
+BITMAP
+3000
+1830
+E448
+7A50
+0650
+0140
+ENDCHAR
+STARTCHAR uni0091
+ENCODING 59793
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 17 -5 0
+BITMAP
+0200
+E200
+1000
+0800
+0400
+0200
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni0092
+ENCODING 59794
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 16 -5 0
+BITMAP
+E180
+1240
+0A00
+0600
+0200
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni0093
+ENCODING 59795
+SWIDTH 733 0
+DWIDTH 11 0
+BBX 11 16 -5 0
+BITMAP
+E180
+1240
+0A80
+0680
+0200
+07E0
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+0200
+ENDCHAR
+STARTCHAR uni0094
+ENCODING 59796
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 17 -6 0
+BITMAP
+3100
+1900
+E400
+7A00
+0600
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+STARTCHAR uni0095
+ENCODING 59797
+SWIDTH 800 0
+DWIDTH 12 0
+BBX 12 18 -6 0
+BITMAP
+0200
+3200
+18C0
+E520
+7B00
+0700
+0100
+03F0
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+0100
+ENDCHAR
+ENDFONT
Index: xc/extras/freetype2/ChangeLog
diff -u xc/extras/freetype2/ChangeLog:1.1.1.5 xc/extras/freetype2/ChangeLog:1.1.1.8
--- xc/extras/freetype2/ChangeLog:1.1.1.5	Mon Jan 14 11:51:55 2002
+++ xc/extras/freetype2/ChangeLog	Thu Jun 20 04:15:57 2002
@@ -1,17 +1,1650 @@
+2002-06-11  David Turner  <david@freetype.org>
+
+        * builds/win32/ftdebug.c: added a missing #endif
+
+        * src/sfnt/ttload.c, src/bdf/bdflib.c: removing compiler warnings
+
+        * src/type42/t42objs.c: removed the bug that prevented un-hinted
+        outlines to be loaded
+
+2002-06-08  Juliusz Chroboczek  <jch@pps.jussieu.fr>
+
+	* include/freetype/internal/ftobjs.h, src/autohint/ahglyph.c,
+	src/base/ftobjs.c, src/sfnt/ttcmap0.c, src/smooth/ftgrays.c: Don't
+	use `setjmp', `longjmp', and `jmp_buf' but `ft_setjmp', `ft_longjmp',
+	and `ft_jmp_buf'.
+	Removed direct references to <stdio.h> and <setjmp.h> when
+	appropriate, to eventually replace them with a
+	FT_CONFIG_STANDARD_LIBRARY_H.  Useful for the XFree86 Font Server
+	backend based on FT2.
+
+	* src/base/fttype1.c (FT_Has_PS_Glyph_Names): Fix return value.
+
+2002-06-08  David Turner  <david@freetype.org>
+
+	* src/pcf/pcfdriver.c (pcf_cmap_char_next): Fixed a bug that caused
+	the function to return invalid values.
+
+	* src/cache/ftccache.i: Removing a typo that prevented
+	the source's compilation.
+
+	* src/cache/ftccache.c (ftc_node_hash_unlink): Fixed a
+	bug that caused nasty memory overwrites.  The hash table's
+	buckets array wasn't correctly resized when shrinked.
+
+2002-06-08  Detlef Würkner  <TetiSoft@apg.lahn.de>
+
+	* builds/amiga/smakefile, builds/amiga/makefile: Updated.
+
+2002-06-08  Werner Lemberg  <wl@gnu.org>
+
+	* src/cache/ftccache.c (ftc_node_hash_unlink, ftc_node_hash_link)
+	[FTC_CACHE_USE_LINEAR_HASHING]: Fix returned error code.
+	Fix debugging messages.
+	* src/cache/ftccache.i (GEN_CACHE_LOOKUP): Move declaration of
+	`family' and `hash' up to make it compilable with g++.
+
+	* src/type42/t42error.h: New file.
+	* src/type42/t42drivr.c, src/type42/t42objs.c,
+	src/type42/t42parse.c: Use t42 error codes.
+	* src/type42/rules.mk: Updated.
+
+	* src/base/ftnames.c: Include FT_INTERNAL_STREAM_H.
+
+2002-06-08  David Turner  <david@freetype.org>
+
+	* src/cache/ftccmap.c: GEN_CACHE_FAMILY_COMPARE,
+	GEN_CACHE_NODE_COMPARE, GEN_CACHE_LOOKUP) [FTC_CACHE_USE_INLINE]:
+	New macros.
+	(ftc_cmap_cache_lookup) [!FTC_CACHE_USE_INLINE]: Typedef to
+	ftc_cache_lookup.
+	(FTC_CMapCache_Lookup): Updated.
+
+	Adding various experimental optimizations to the cache manager.
+
+	* include/freetype/cache/ftccache.h (FTC_CACHE_USE_INLINE,
+	FTC_CACHE_USE_LINEAR_HASHING): New options.
+	(FTC_CacheRec) [FTC_CACHE_USE_LINEAR_HASHING]: New elements `p',
+	`mask', and `slack'.
+
+	* src/cache/ftccache.c (FTC_HASH_MAX_LOAD, FTC_HASH_MIN_LOAD,
+	FTC_HASH_SUB_LOAD) [FTC_CACHE_USE_LINEAR_HASHING,
+	FTC_HASH_INITIAL_SIZE]: New macros.
+	(ftc_node_mru_link, ftc_node_mru_up): Optimized.
+	(ftc_node_hash_unlink, ftc_node_hash_link)
+	[FTC_CACHE_USE_LINEAR_HASHING]: New variants.
+	(FTC_PRIMES_MIN, FTC_PRIMES_MAX, ftc_primes, ftc_prime_closest,
+	FTC_CACHE_RESIZE_TEST, ftc_cache_resize)
+	[!FTC_CACHE_USE_LINEAR_HASHING]: Define it conditionally.
+	(ftc_cache_init, ftc_cache_clear) [FTC_CACHE_USE_LINEAR_HASHING]:
+	Updated.
+	(ftc_cache_lookup) [FTC_CACHE_USE_LINEAR_HASHING]: Implement it.
+
+	* src/cache/ftccache.i: New file.
+
+	* src/cache/ftcsbits.c (GEN_CACHE_FAMILY_COMPARE,
+	GEN_CACHE_NODE_COMPARE, GEN_CACHE_LOOKUP) [FTC_CACHE_USE_INLINE]:
+	New macros.
+	(ftc_sbit_cache_lookup) [!FTC_CACHE_USE_INLINE]: Typedef to
+	ftc_cache_lookup.
+	(FTC_SBitCache_Lookup): Updated.
+
+	* src/type42/t42parse.c: Removing duplicate function.
+
+2002-06-07  Graham Asher  <graham.asher@btinternet.com>
+
+	* src/base/ftobjs.c (FT_Render_Glyph_Internal): Changed definition
+	from FT_EXPORT_DEF to FT_BASE_DEF.
+
+2002-06-07  David Turner  <david@freetype.org>
+
+	Fixed the bug that prevented the correct display of fonts with
+	"ftview".
+
+	* src/type42/t42drivr.c: Split into...
+	* src/type42/t42drivr.h, src/type42/t42parse.c,
+	src/type42/t42parse.h, src/type42/t42objs.h, src/type42/t42objs.c,
+	src/type42/type42.c: New files.
+
+	(t42_get_glyph_name, t42_get_ps_name, t42_get_name_index): Use
+	`face->type1'.
+
+	(Get_Interface): Renamed to...
+	(T42_Get_Interface): This.
+	Updated.
+	(T42_Open_Face, T42_Face_Done): Updated.
+	(T42_Face_Init): Add new cmap support.
+	Updated.
+	(T42_Driver_Init, T42_Driver_Done, T42_Size_Init, T42_Size_Done,
+	T42_GlyphSlot_Init, T42_GlyphSlot_Done): Updated.
+	(Get_Char_Index, Get_Next_Char): Renamed to...
+	(T42_CMap_CharIndex, T42_CMap_CharNext): This.
+	Updated.
+	(T42_Char_Size, T42_Pixel_Size): Renamed to...
+	(T42_Size_SetChars, T42_Size_SetPixels): This.
+	(T42_Load_Glyph): Renamed to...
+	(T42_GlyphSlot_Load): This.
+
+	(t42_init_loader, t42_done_loader): Renamed to...
+	(t42_loader_init, t42_loader_done): This.
+	(T42_New_Parser, T42_Finalize_Parser): Renamed to...
+	(t42_parser_init, t42_parser_done): This.
+	(parse_dict): Renamed to...
+	(t42_parse_dict): This.
+	(is_alpha, is_space, hexval): Renamed to...
+	(t42_is_alpha, t42_is_space, t42_hexval): This.
+	(parse_font_name, parse_font_bbox, parse_font_matrix,
+	parse_encoding, parse_sfnts, parse_charstrings, parse_dict):
+	Renamed to...
+	(t42_parse_font_name, t42_parse_font_bbox, t42_parse_font_matrix,
+	t42_parse_encoding, t42_parse_sfnts, t42_parse_charstrings,
+	t42_parse_dict): This.
+	Updated.
+
+	(t42_keywords): Updated.
+
+	* src/type42/Jamfile, src/type42/descrip.mms: Updated.
+
+2002-06-03  Werner Lemberg  <wl@gnu.org>
+
+	Add 8bpp support to BDF driver.
+
+	* src/bdf/bdflib.c (_bdf_parse_start): Handle 8bpp.
+	* src/bdf/bdfdrivr.c (BDF_Glyph_Load): Ditto.
+	* src/bdf/README: Updated.
+
+2002-06-02  Detlef Würkner  <TetiSoft@apg.lahn.de>
+
+	* src/pfr/pfrload.c (pfr_phy_font_done): Free `blue_values' array.
+
+2002-05-29  Detlef Würkner  <TetiSoft@apg.lahn.de>
+
+	* src/bdf/bdflib.c (_bdf_readstream): Allocate `buf' dynamically.
+	(_bdf_parse_glyphs): Use correct size for allocating
+	`font->unencoded'.
+	(bdf_load_font): Free array conditionally.
+	Return proper error code in case of failure.
+	* src/bdf/bdfdrivr.c (BDF_Face_Init): Make it more robust against
+	unusual fonts.
+
+2002-05-29  Werner Lemberg  <wl@gnu.org>
+
+	* src/bdf/descrip.mms, src/type42/descrip.mms: New files.
+	* descrip.mms (all): Updated.
+
+	* src/bdf/bdflib.c (_bdf_parse_glyphs): Fix typo which prevented
+	compilation.
+	* src/pshglob.c (psh_blues_scale_zones): Fix compiler warning.
+
+2002-05-28  Detlef Würkner  <TetiSoft@apg.lahn.de>
+
+	* builds/amiga/makefile, builds/amiga/smakefile,
+	amiga/include/freetype/config/ftmodule.h: Updated to include
+	support for BDF and Type42 drivers.
+
+	* docs/modules.txt: Updated.
+
+2005-05-28  David Turner  <david@freetype.org>
+
+	* docs/CHANGES: Updating file for next release (2.1.1).
+
+	* src/bdf/bdflib.c: Removing compiler warnings.
+
+	* include/freetype/ftxf86.h, src/base/ftxf86.c: New files.
+	They provide a new API (FT_Get_X11_Font_Format) to retrieve an
+	X11-compatible string describing the font format of a given face.
+	This was put in a new optional base source file, corresponding to a
+	new public header (named FT_XFREE86_H since this function should
+	only be used within the XFree86 font server IMO).
+
+	* include/freetype/config/ftheader.h (FT_XFREE86_H): New macro (not
+	documented yet).
+
+	* src/base/fttype1.c: New file, provoding two new API functions
+	(FT_Get_PS_Font_Info and FT_Has_PS_Glyph_Names).
+	* include/freetype/t1tables.h: Updated.
+
+	* src/base/Jamfile, src/base/rules.mk, src/base/descrip.mms:
+	Updating build control files for the new files "ftxf86.c" and
+	"fttype1.c" in src/base.
+
+	* src/pshinter/pshglob.c (psh_blues_scale_zones): Fixed a bug that
+	prevented family blue zones substitution from hapenning correctly.
+
+	* include/freetype/ftbdf.h FT_Get_BDF_Charset_ID): Adding
+	documentation comment.
+
+2002-05-28  Werner Lemberg  <wl@gnu.org>
+
+	* src/base/ftnames.c (FT_Get_Sfnt_Name): Don't use FT_STREAM_READ_AT
+	but FT_STREAM_READ.
+	Declare `stream' variable.
+
+	* src/bdf/bdflib.c (_bdf_parse_glyphs): Replace floating point math
+	with calls to `FT_MulDiv'.
+
+2002-05-28  David Turner  <david@freetype.org>
+
+	Fixing the SFNT name table loader to support various buggy fonts.
+	It now ignores empty name entries, entries with invalid pointer
+	Offsets and certain fonts containing tables with broken
+	"storageOffset" fields.
+
+	Name strings are now loaded on demand, which reduces the memory
+	requirements for a given FT_Face tremendously (for example, the name
+	table of Arial.ttf is about 10Kb and contains 70 names).
+
+	This is a temporary fix.  The whole name table loader and interface
+	will be rewritten in a much more cleanly way shortly, once CSEH have
+	been introduced in the sources.
+
+	* include/freetype/internal/tttypes.h (TT_NameEntryRec): Change
+	type of `stringOffset' to FT_ULong.
+	(TT_NameTableRec): Change type of `numNameRecords' and
+	`storageOffset' to FT_UInt.
+	Replace `storage' with `stream'.
+	* src/base/ftnames.c (FT_Get_Sfnt_Name): Load name on demand.
+	* src/sfnt/sfdriver.c (get_sfnt_postscript_name): Ditto.
+	Make code more robust.
+	* src/sfnt/sfobjs.c (TT_NameEntry_ConvertFunc): New typedef.
+	(tt_face_get_name): Use it.
+	Make code more robust.
+	* src/sfnt/ttload.c (TT_Load_Names): Use `static' for arrays.
+	Handle invalid `storageOffset' data better.
+	Set length fields to zero for invalid or ignored data.
+	Remove code within FT_DEBUG_LEVEL_TRACE.
+	(TT_Free_Names): Updated.
+
+2002-05-24  Tim Mooney  <enchanter@users.sourceforge.net>
+
+	* builds/unix/ft-munmap.m4: New file, extracted FT_MUNMAP_DECL and
+	FT_MUNMAP_PARAM from aclocal.m4 into here, so aclocal.m4 can be
+	rebuilt from sources.  Set macro serial to 1, and use third argument
+	to AC_DEFINE for our two custom symbols, so ftconfig.in could one day
+	be rebuilt with autoheader (not recommended now, ftconfig.in is a
+	custom source file)
+
+2002-05-22  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/config/ftheader.h (FT_BEZIER_H): Removed.
+	(FT_BDF_H): New macro for accessing `ftbdf.h'.
+
+	* src/type42/t42drivr.c (hexval): Fix typo.
+
+2002-05-21  Martin Muskens  <mmuskens@aurelon.com>
+
+	* src/psaux/psobjs.c (T1Radix): New function.
+	(t1_toint): Use it to handle numbers in radix format.
+
+	* src/psaux/t1decode.c (T1_Decoder_Parse_Charstrings): Add dummy
+	for undocumented, obsolete opcode 15.
+
+2002-05-21  David Turner  <david@freetype.org>
+
+	* src/bdf/bdflib.c: Removed compiler warning, and changed all tables
+	to the "static const" storage specifier (instead of simply
+	`static').
+
+	* src/type42/t42drivr.c (hexval): Use more efficient code.
+	Removing compiler warnings.
+	* src/bdf/bdfdrivr.c: Removing compiler warnings.
+
+	* include/freetype/internal/ftbdf.h, src/base/ftbdf.c,
+	src/base/descrip.mms, src/base/Jamfile, src/base/rules.mk
+	(FT_Get_BDF_Charset_ID): New API to retrieve BDF-specific strings
+	from a face.  This is much cleaner than accessing the internal types
+	"BDF_Public_Face" defined in FT_INTERNAL_BDF_TYPES_H.
+
+2002-05-21  Werner Lemberg  <wl@gnu.org>
+
+	* src/bdf/README: Mention Microsoft's SBIT tool.
+
+	* src/cff/cffdrivr.c, src/cid/cidriver.c, src/pcf/pcfdriver.c,
+	src/truetype/ttdriver.c, src/type1/t1driver.c,
+	src/winfonts/winfnt.c, src/type42/t42drivr.c, src/bdf/bdfdrivr.c
+	[FT_CONFIG_OPTION_DYNAMIC_DRIVERS]: Completely removed.  It has
+	been never used.
+
+2002-05-21  Roberto Alameda  <ojancano@geekmail.de>.
+
+	* src/type42/t42drivr.c: s/T42_ENCODING_TYPE_/T1_ENCODING_TYPE_/.
+	(parse_font_matrix): Remove unnecessary code.
+	(parse_sfnts): Initialize some variables.
+	(t42_driver_class) [TT_CONFIG_OPTION_BYTECODE_INTERPRETER]: Use
+	ft_module_driver_has_hinter conditionally.
+	Moved some type 42 specific structure definitions to...
+	* include/freetype/internal/t42types.h: New file.
+	* include/freetype/internal/internal.h (FT_INTERNAL_T42_TYPES_H):
+	New macro.
+
+2002-05-20  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/cache/ftcsbits.h (FTC_SBit): Added a new field
+	`num_grays' for specifying the number of used gray levels.
+	* src/cache/ftcsbits.c (ftc_sbit_node_load): Initialize it.
+
+2002-05-19  Werner Lemberg  <wl@gnu.org>
+
+	Adding a driver for BDF fonts written by Francesco Zappa Nardelli
+	<Francesco.Zappa.Nardelli@ens.fr>.  Heavily modified by me to
+	better adapt it to FreeType, removing unneeded stuff.  Additionally,
+	it now supports Mark Leisher's BDF extension for anti-aliased
+	bitmap glyphs with 2 and 4 bpp.
+
+	* src/bdf/*: New driver.
+	* include/freetype/internal/bdftypes.h: New file.
+	* include/freetype/internal/fttrace.h: Added BDF driver components.
+	* include/freetype/fterrdef.h: Added error codes for BDF driver.
+	* include/freetype/config/ftmodule.h, src/Jamfile: Updated.
+	* include/freetype/internal/internal.h (FT_INTERNAL_BDF_TYPES_H):
+	New macro.
+
+	* include/freetype/config/ftstdlib.h (ft_sprintf): New alias for
+	sprintf.
+
+2002-05-18  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/internal/fttrace.h: Added Type 42 driver
+	component.
+	* src/type42/t42drivr.c: Use it.
+
+	* include/freetype/internal/internal.h (FT_INTERNAL_PCF_TYPES_H):
+	New macro.
+
+2002-05-17  Werner Lemberg  <wl@gnu.org>
+
+	* src/type42/Jamfile: New file.
+
+2002-05-14  Werner Lemberg  <wl@gnu.org>
+
+	Adding a driver for Type42 fonts written by Roberto Alameda
+	<ojancano@geekmail.de>.
+
+	* src/type42/*: New driver.
+	* include/freetype/config/ftmodule.h, src/Jamfile: Updated.
+	* include/freetype/config/ftstdlib.h (ft_xdigit, ft_memcmp,
+	ft_atoi): New aliases for xdigit, memcmp, and atoi, respectively.
+
+2002-05-12  Owen Taylor  <otaylor@redhat.com>
+
+	* src/sfnt/ttload.c (TT_LookUp_Table): Protect against tables
+	with a zero length value.
+
+2002-05-12  Michael Pfeiffer  <michael.pfeiffer@utanet.at>
+
+	* builds/beos/beos.mk: Include `link-std.mk'.
+
+2002-05-12  Werner Lemberg  <wl@gnu.org>
+
+	* src/type1/t1load.h (T1_Loader): Renamed to...
+	(T1_LoaderRec): This.
+	(T1_Loader): Now pointer to T1_LoaderRec.
+	* src/type1/t1load.c: Updated.
+
+	* include/freetype/internal/t1types.h, src/type1/t1load.c,
+	src/type1/t1objs.c:
+	s/T1_ENCODING_TYPE_EXPORT/T1_ENCODING_TYPE_EXPERT/.
+
+2002-05-06  Werner Lemberg  <wl@gnu.org>
+
+	* README: Add a note regarding libttf vs. libfreetype.
+
+2002-05-05  Werner Lemberg  <wl@gnu.org>
+
+	FreeType 2 can now be built in an external directory with the
+	configure script also.
+
+	* builds/freetype.mk (INCLUDES): Add `OBJ_DIR'.
+
+	* builds/unix/detect.mk (have_mk): New variable to test for
+	external build.
+	(unix-def.mk): Defined according to value of `have_mk'.
+	* builds/unix/unix.mk (have_mk): New variable to test for
+	external build.
+	Select include paths for unix-def.mk and unix-cc.mk according
+	to value of `have_mk'.
+	* builds/unix/unix-def.in (OBJ_BUILD): New variable.
+	(DISTCLEAN): Use it.
+	* builds/unix/unix-cc.in (LIBTOOL): Define default value only
+	if not yet defined.
+	* builds/unix/install.mk (install): Use `OBJ_BUILD' for installing
+	freetype-config.
+
+	* configure: Don't depend on bash features.
+	(ft2_dir, abs_curr_dir, abs_ft2_dir): New variables (code
+	partially taken from Autoconf).
+	Build a dummy Makefile if not building in source tree.
+
+	* docs/INSTALL: Document it.
+
+2002-05-04  David Turner  <david@freetype.org>
+
+	* src/truetype/ttgload.c (TT_Load_Glyph): Finally fixing the last
+	bug that prevented FreeType 2.x and FreeType 1.x to produce
+	bit-by-bit identical monochrome glyph bitmaps with native TrueType
+	hinting.  The culprit was a single-bit flag that wasn't set
+	correctly by the TrueType glyph loader.
+
+	* src/otlayout/otlayout.h, src/otlayout/otlbase.c,
+	src/otlayout/otlbase.h, src/otlayout/otlconf.h,
+	src/otlayout/otlgdef.c, src/otlayout/otlgdef.h,
+	src/otlayout/otlgpos.c, src/otlayout/otlgpos.h,
+	src/otlayout/otlgsub.c, src/otlayout/otlgsub.h,
+	src/otlayout/otljstf.c, src/otlayout/otljstf.h,
+	src/otlayout/otltable.c, src/otlayout/otltable.h,
+	src/otlayout/otltags.h: New OpenType Layout source files.  The
+	module is still incomplete.
+
+2002-05-02  Werner Lemberg  <wl@gnu.org>
+
+	* src/sfnt/ttcmap0.c (tt_cmap4_char_index): Fix serious typo
+	(0xFFFU -> 0xFFFFU).
+
+2002-05-01  Werner Lemberg  <wl@gnu.org>
+
+	* docs/INSTALL: Fix URL of makepp.
+
+2002-05-01  David Turner  <david@freetype.org>
+
+	* src/sfnt/sfobjs.c (tt_face_get_name): Fixing a bug that caused
+	FreeType to crash when certain broken fonts (e.g. "hya6gb.ttf")
+	were opened.
+
+	* src/sfnt/ttload.c (TT_Load_Names): Applied a small work-around to
+	manage fonts containing a broken name table (e.g. "hya6gb.ttf").
+
+	* src/sfnt/ttcmap0.c (tt_cmap4_validate): Fixed over-restrictive
+	validation test.  The charmap validator now accepts overlapping
+	ranges in format 4 charmaps.
+
+	* src/sfnt/ttcmap0.c (tt_cmap4_char_index): Switched to a binary
+	search algorithm.  Certain fonts contain more than 170 distinct
+	segments!
+
+	* include/freetype/config/ftstdlib.h: Adding an alias for the `exit'
+	function.  This will be used in the near future to panic in case of
+	unexpected exception (which shouldn't happen in theory).
+
+	* include/freetype/internal/fthash.h, src/base/fthash.c: Adding a
+	generic implementation of dynamic hash tables using a linear
+	algorithm (to get rid of `stalls' during resizes).  This will be
+	used in the future in at least three parts of the library: the cache
+	sub-system, the object sub-system, and the memory debugger.
+
+	* include/freetype/internal/ftcore.h: Added this header file to
+	group all new definitions related to exception handling and memory
+	management.  It is very likely that this file will disappear or be
+	renamed in the future.
+
+	* include/freetype/internal/ftobject.h, include/freetype/ftsysmem.h:
+	Adding comments to better explain the object sub-system as well as
+	the new memory manager interface.
+
+2002-04-30  Wenlin Institute (Tom Bishop)  <wenlin@wenlin.com>
+
+	* src/base/ftmac.c (p2c_str): Removed.
+	(file_spec_from_path) [TARGET_API_MAC_CARBON]: Added support for
+	OS X.
+	(is_dfont) [TARGET_API_MAC_CARBON]: Define only for OS X.
+	Handle `nameLen' <= 6 also.
+	(parse_fond): Remove unused variable `name_table'.
+	Use functionality of old p2c_str directly.
+	Add safety checks.
+	(read_lwfn): Initialize `size_p'.
+	Check for size_p == NULL.
+	(new_memory_stream, open_face_from_buffer): Updated to FreeType 2.1.
+	(FT_New_Face_From_LWFN): Remove unused variable `memory'.
+	Remove some dead code.
+	(FT_New_Face_From_SFNT): Remove unused variable `stream'.
+	(FT_New_Face_From_dfont) [TARGET_API_MAC_CARBON]: Define only for
+	OS X.
+	(FT_New_Face_From_FOND): Remove unused variable `error'.
+	(ResourceForkSize): New function.
+	(FT_New_Face): Use it.
+	Handle empty resource forks.
+	Conditionalize some code for OS X.
+	Add code to call normal loader as a fallback.
+
+2002-04-30  Werner Lemberg  <wl@gnu.org>
+
+	`interface' is reserved on the Mac.
+
+	* include/freetype/ftoutln.h, include/freetype/internal/sfnt.h,
+	src/base/ftoutln.c: s/interface/func_interface/.
+	* src/base/ftbbox.c (FT_Outline_Get_BBox):
+	s/interface/bbox_interface/.
+	* src/cff/cffdrivr.c: s/interface/module_interface/.
+	* src/cff/cffload.c, src/cff/cffload.h:
+	s/interface/psnames_interface/.
+	* src/cid/cidriver.c: s/interface/cid_interface/.
+	* src/sfnt/sfdriver.c: s/interface/module_interface/.
+	* src/smooth/ftgrays.c: s/interface/func_interface/.
+	* src/truetype/ttdriver.c: s/interface/tt_interface/.
+	* src/type1/t1driver.c: s/interface/t1_interface/.
+
+	Some more variable renames to avoid troubles on the Mac.
+
+	* src/raster/ftraster.c:
+	s/Unknown|Ascending|Descending|Flat/\1_State/.
+	* src/smooth/ftgrays.c: s/TScan/TCoord/.
+
+	Other changes for the Mac.
+
+	* include/freetype/config/ftconfig.h: Define FT_MACINTOSH for
+	Mac platforms.
+	* src/base/ftobjs.c: s/macintosh/FT_MACINTOSH/.
+
+	* src/raster/ftrend1.c (ft_raster1_render): Make `pitch' always
+	an even number.
+
+2002-04-29  Jouk Jansen  <joukj@hrem.stm.tudelft.nl>
+
+	* descrip.mms (all): Add pfr driver.
+
+2002-04-28  Werner Lemberg  <wl@gnu.org>
+
+	* src/pfr/pfrerror.h: New file.
+	* include/freetype/ftmoderr.h: Add PFR error codes.
+	* src/pfr/pfrgload.c: Include pfrerror.h.
+	Use PCF error codes.
+	(pfr_extra_item_load_stem_snaps): Fix debug message.
+	* src/pfr/pfrgload.c: Include pfrerror.h.
+	Use PCF error codes.
+	(pfr_extra_item_load_bitmap_info, pfr_glyph_load_simple,
+	pfr_glyph_load_compound): Fix debug message.
+	* src/pfr/pfrobjs.c: Include pfrerror.h.
+	Use PCF error codes.
+	(pfr_face_init): Return PFR_Err_Unknown_File_Format.
+	* src/pfr/rules.mk (PFR_DRV_H): Include pfrerror.h.
+
+	* src/pcf/pcfdriver.c (PCF_Face_Init) [!FT_CONFIG_OPTION_USE_CMAPS]:
+	`root' -> `face->root'.
+	* src/sfnt/ttcmap0.c (TT_Build_CMaps) [!FT_CONFIG_OPTION_USE_CMAPS]:
+	Removed.
+	* src/sfnt/ttcmap0.c: Declare TT_Build_CMaps only for
+	FT_CONFIG_OPTION_USE_CMAPS.
+
+2002-04-27  Werner Lemberg  <wl@gnu.org>
+
+	* src/cache/ftccache.c (ftc_cache_lookup),
+	src/cache/ftccmap.c (ftc_cmap_family_init),
+	src/cache/ftcmanag.c (ftc_family_table_alloc),
+	src/cache/ftcsbits.c (FTC_SBit_Cache_Lookup): Use FTC_Err_*.
+	src/cache/ftcimage.c (FTC_Image_Cache_Lookup): Use FTC_Err_*.
+	(FTC_ImageCache_Lookup): Fix handling of invalid arguments.
+
+2002-04-22  Werner Lemberg  <wl@gnu.org>
+
+	* builds/unix/configure.ac: Set `version_info' to 9:1:3 (FT2
+	version 2.0.9 has 9:0:3).
+	* builds/unix/configure: Regenerated (using autoconf 2.53).
+
+2002-04-19  Werner Lemberg  <wl@gnu.org>
+
+	* src/pfr/pfrload.c (pfr_extra_items_farse): Fix debug message.
+	(pfr_phy_font_load): s/size/Size/ for local variable to avoid
+	compiler warning.
+	* src/pfr/pfrobjs.c (pfr_face_init): Fix debug message.
+	(pfr_slot_load): Remove redundant local variable.
+
+2002-04-19  David Turner  <david@freetype.org>
+
+	Adding a PFR font driver to the FreeType sources.  Note that it
+	doesn't support embedded bitmaps or kerning tables yet.
+
+	src/pfr/*: New files.
+
+	* include/freetype/config/ftmodule.h,
+	include/freetype/internal/fttrace.h, src/Jamefile: Updated.
+
+	* src/type1/t1gload.h (T1_Load_Glyph), src/type1/t1gload.c
+	(T1_Load_Glyph): Fixed incorrect parameter sign-ness in callback
+	function.
+
+	* include/freetype/internal/ftmemory.h (FT_MEM_ZERO, FT_ZERO): New
+	macros.
+
+	* include/freetype/internal/ftstream.h (FT_NEXT_OFF3, FT_NEXT_UOFF3,
+	FT_NEXT_OFF3_LE, FT_NEXT_UOFF3_LE): New macros to parse in-memory
+	24-bit integers.
+
+2002-04-18  David Turner  <david@freetype.org>
+
+	* src/base/ftobjs.c, builds/win32/ftdebug.c,
+	builds/amiga/src/base/ftdebug.c: Version 2.1.0 couldn't be linked
+	against applications in Win32 and Amiga builds due to changes to
+	"src/base/ftdebug.c" that were not properly propagated to
+	"builds/win32" and "builds/amiga".  This has been fixed.
+
+	* include/freetype/internal/ftobject.h,
+	include/freetype/internal/ftexcept.h, include/freetype/ftsysmem.h,
+	include/freetype/ftsysio.h, src/base/ftsysmem.c, src/base/ftsysio.c:
+	New experimental files.
+
+2002-04-17  David Turner  <david@freetype.org>
+
+
+	* Version 2.1.0 released.
+	=========================
+
+
+2002-04-17  Michael Jansson  <mjan@em2-solutions.com>
+
+	* src/type1/t1gload.c (T1_Compute_Max_Advance): Fixed a small bug
+	that prevented the function to return the correct value.
+
+2002-04-16  Francesco Zappa Nardelli  <Francesco.Zappa.Nardelli@ens.fr>
+
+	* src/pcf/pcfread (pcf_get_accell): Fix parsing of accelerator
+	tables.
+
+2002-04-15  David Turner  <david@freetype.org>
+
+	* docs/FTL.txt: Formatting.
+
+	* include/freetype/config/ftoption.h: Reduce the size of the
+	render pool from 32kByte to 16kByte.
+
+	* src/pcf/pcfread.c (pcf_seek_to_table_type): Remove compiler
+	warning.
+
+	* include/freetype/config/ftoption.h (FT_MAX_EXTENSIONS): Removed.
+
+	* docs/CHANGES: Preparing 2.1.0 release.
+
+2002-04-13  Werner LEMBERG  <wl@gnu.org>
+
+	* src/cff/cffgload.c (CFF_Parse_CharStrings): s/rand/Rand/ to avoid
+	compiler warning.
+
+2002-04-12  David Turner  <david@freetype.org>
+
+	* README.UNX: Updated the Unix-specific quick-compilation guide to
+	warn about the GNU Make requirement at compile time.
+
+	* include/freetype/config/ftstdlib.h,
+	include/freetype/config/ftconfig.h,
+	include/freetype/config/ftheader.h,
+	include/freetype/internal/ftmemory.h,
+	include/freetype/internal/ftobjs.h,
+
+	src/autohint/ahoptim.c,
+
+	src/base/ftdbgmem.c, src/base/ftdebug.c, src/base/ftmac.c,
+	src/base/ftobjs.c, src/base/ftsystem.c,
+
+	src/cache/ftcimage.c, src/cache/ftcsbits.c,
+
+	src/cff/cffdriver.c, src/cff/cffload.c, src/cff/cffobjs.c,
+
+	src/cid/cidload.c, src/cid/cidparse.c, src/cid/cidriver.c,
+
+	src/pcf/pcfdriver.c, src/pcf/pcfread.c,
+
+	src/psaux/t1cmap.c, src/psaux/t1decode.c,
+
+	src/pshinter/pshalgo1.c, src/pshinter/pshalgo2.c,
+	src/pshinter/pshrec.c,
+
+	src/psnames/psmodule.c,
+
+	src/raster/ftraster.c,
+
+	src/sfnt/sfdriver.c, src/sfnt/ttload.c,
+
+	src/smooth/ftgrays.c,
+
+	src/type1/t1afm.c, src/type1/t1driver.c, src/type1/t1gload.c,
+	src/type1/t1load.c, src/type1/t1objs.c, src/type1/t1parse.c,
+
+	builds/unix/ftconfig.in, builds/vms/ftconfig.h,
+
+	builds/amiga/src/base/ftdebug.c:
+
+	Added the new configuration file "ftstdlib.h" used to define
+	aliases for all ISO C library functions used by the engine
+	(e.g. strlen, qsort, setjmp, etc.).
+
+	This eases the porting of FreeType 2 to environments like
+	XFree86 modules/extensions.
+
+	Also removed many #include <string.h>, #include <stdlib.h>, etc.
+	from the engine's sources where they are not needed.
+
+	* src/sfnt/ttpost.c: Use macro name for psnames.h.
+
+2002-04-12  Vincent Caron  <v.caron@zerodeux.net>
+
+	* configure, builds/detect.mk: Updated the build system to print
+	a warning message in case GNU Make isn't used to build the library.
+
+2002-04-11  David Turner  <david@freetype.org>
+
+	* README, docs/CHANGES, Jamfile.in: Updates for the 2.1.0 release.
+
+	* docs/FTL.txt: Updated license text to provide a preferred
+	disclaimer and adjust copyright dates/extents.
+
+	* include/freetype/cache/ftcglyph.h: Removing obsolete (and
+	confusing) comment.
+
+	* Jamfile.in: New file.
+
+2002-04-11  Maxim Shemanarev  <mcseemagg@yahoo.com>
+
+	* src/smooth/ftgrays.c (gray_hline): Minor optimization.
+
+2002-04-02  Werner Lemberg  <wl@gnu.org>
+
+	Fixes from the stable branch:
+
+	* include/freetype/config/ftoption.h (FT_CONFIG_OPTION_OLD_CALCS):
+	Removed.
+	[FT_CONFIG_OPTION_OLD_CALCS]: Removed.
+	* include/freetype/internal/ftcalc.h, src/base/ftcalc.c
+	[FT_CONFIG_OPTION_OLD_CALCS]: Removed.
+
+	* src/base/fttrigon.c (FT_Vector_Length): Change algorithm to match
+	output of FreeType 1.
+
+	* src/pshinter/pshglob.c (psh_globals_scale_widths): Fixed a small
+	bug that created un-even stem widths when hinting Postscript fonts.
+
+	* src/type1/t1driver.c, src/type1/t1parse.c: 16bit fixes.
+
+2002-04-01  Werner Lemberg  <wl@gnu.org>
+
+	* src/truetype/ttgload.c: 16bit fixes.
+	(TT_Load_Simple_Glyph): Improve debug messages.
+	(load_truetype_glyph): Remove dead code.
+	* src/truetype/ttinterp.c: 16bit fixes.
+	* src/truetype/ttobjs.c: Ditto.
+
+	* include/freetype/ftsnames.h, include/freetype/internal/sfnt.h,
+	src/cff/cffload.h, src/psaux/psobjs.h, src/truetype/ttinterp.[ch],
+	src/sfnt/ttpost.h: s/index/idx/.
+
+2002-03-31  Yao Zhang  <yaoz@vidar.niaaa.nih.gov>
+
+	* src/truetype/ttobjs.c (TT_Size_Init): Fix typo.
+
+2002-03-31  Werner Lemberg  <wl@gnu.org>
+
+	* src/otlayout/otlcommn.c, src/otlayout/otlcommn.h: s/index/idx/.
+	* src/psaux/t1cmap.c: Ditto.
+	* src/sfnt/ttcmap0.c: Ditto.
+
+	* include/freetype/internal/tttypes.h,
+	include/freetype/internal/sfnt.h (TT_Goto_Table_Func): Renamed to ...
+	(TT_Loader_GotoTableFunc): This.
+	* src/psaux/t1decode.c (T1_Decoder_Parse_Charstrings): Fix debug
+	messages.
+	* src/psnames/psmodule.c (psnames_interface)
+	[!FT_CONFIG_OPTION_ADOBE_GLYPH_LIST]: Fix typo.
+	* src/sfnt/sfdriver.c (get_sfnt_table): 16bit fix.
+	* src/sfnt/ttcmap.c: 16bit fixes (0xFFFF -> 0xFFFFU).
+	* src/sfnt/ttcmap0.c: 16bit fixes.
+	(TT_Build_CMaps): Simplify debug messages.
+	(tt_cmap12_char_next): Fix offset.
+	* src/sfnt/ttload.c (TT_Load_Names, TT_Load_CMap): Fix debug
+	messages.
+	(TT_Load_OS2): 16bit fix.
+
+2002-03-30  David Turner  <david@freetype.org>
+
+	* include/freetype/internal/tttypes.h: Adding comments to some of
+	the TT_FaceRec fields.
+
+	* src/sfnt/ttcmap0.c (TT_Build_CMaps): Removed compiler warnings.
+
+	* src/sfnt/sfobjs.c (tt_name_entry_ascii_from_{utf16,ucs4,other}:
+	New functions.
+	(tt_face_get_name): Use them to properly extract an ascii font name.
+
+2002-03-30  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/t1tables.h (t1_blend_max): Fix typo.
+	* src/base/ftstream.c: Simplify FT_ERROR calls.
+	* src/cff/cffdrivr.c (cff_get_glyph_name): Fix debug message.
+
+	* src/cff/cffobjs.c (CFF_Driver_Init, CFF_Driver_Done)
+	[TT_CONFIG_OPTION_EXTEND_ENGINE]: Removed.
+	* src/cff/sfobjs.c (SFNT_Load_Face)
+	[TT_CONFIG_OPTION_EXTEND_ENGINE]: Ditto.
+	* src/truetype/ttobjs.c (TT_Init_Driver, TT_Done_Driver)
+	[TT_CONFIG_OPTION_EXTEND_ENGINE]: Ditto.
+
+	* src/truetype/ttdriver.c, src/truetype/ttobjs.c,
+	src/truetype/ttobjs.h: Renaming driver functions to the
+	FT_<Subject>_<Action> scheme:
+
+	  TT_Init_Driver => TT_Driver_Init
+	  TT_Done_Driver => TT_Driver_Done
+	  TT_Init_Face   => TT_Face_Init
+	  TT_Done_Face   => TT_Face_Done
+	  TT_Init_Size   => TT_Size_Init
+	  TT_Done_Size   => TT_Size_Done
+	  TT_Reset_Size  => TT_Size_Reset
+
+2002-03-29  Werner Lemberg  <wl@gnu.org>
+
+	* builds/vms/ftconfig.h: Rename LOCAL_DEF and LOCAL_FUNC to
+	FT_LOCAL and FT_LOCAL_DEF, respectively, as with other ftconfig.h
+	files.
+	* builds/unix/ftconfig.in: Add argument to FT_LOCAL and
+	FT_LOCAL_DEF.
+	* src/truetype/ttinterp.c: s/FT_Assert/FT_ASSERT/.
+	* builds/unix/configure.ac: Temporarily deactivate creation of
+	../../Jamfile.
+	* builds/unix/configure: Updated.
+
+2002-03-28  KUSANO Takayuki  <AE5T-KSN@asahi-net.or.jp>
+
+	* src/sfnt/sfdriver.c (get_sfnt_postscript_name): Fix serious typos.
+
+2002-03-28  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/internal/psaux.h (PSAux_ServiceRec): Fix
+	compiler warnings.
+	* include/freetype/internal/t1types.h (T1_FaceRec): Use `const' for
+	some members.
+	* src/base/ftapi.c (FT_New_Memory_Stream): Fix typos.
+	* src/psaux/t1cmap.c (t1_cmap_std_init, t1_cmap_unicode_init): Add
+	cast.
+	(t1_cmap_{standard,expert,custom,unicode}_class_rec): Use
+	`FT_CALLBACK_TABLE_DEF'.
+	* src/psaux/t1cmap.h: Updated.
+	* src/sfnt/ttcmap0.c (TT_Build_CMaps): Use `ft_encoding_none'
+	instead of zero.
+	* src/type1/t1objs.c (T1_Face_Init): Use casts.
+
+2002-03-26  David Turner  <david@freetype.org>
+
+	* src/sfnt/sfdriver.c, src/sfnt/sfobjs.c, src/sfnt/ttcmap0.c:
+	Fixed a small bug in the FT_CMaps support code.
+
+2002-03-25  David Turner  <david@freetype.org>
+
+	* src/truetype/ttinterp.c (Norm): Replaced with...
+	(TT_VecLen): This.
+	(TT_MulFix14, TT_DotFix14): New functions.
+	(Project, Dual_Project, Free_Project, Compute_Point_Displacement,
+	Ins_SHPIX, Ins_MIAP, Ins_MIRP): Use them.
+	[FT_CONFIG_OPTION_OLD_CALCS]: Removed all code.
+
+2002-03-22  David Turner  <david@freetype.org>
+
+	* src/base/ftobjs.c, src/sfnt/ttcmap0.c, src/type1/t1objs.c:
+	Various fixes to make the FT_CMaps support work correctly (more
+	tests are still needed).
+
+	* include/freetype/internal/ftobjs.h, src/sfnt/Jamfile,
+	src/sfnt/rules.mk, src/sfnt/sfnt.c, src/sfnt/sfobjs.c,
+	src/sfnt/ttload.c, src/sfnt/ttcmap0.c, src/sfnt/ttcmap0.h: Updated
+	the SFNT charmap support to use FT_CMaps.
+
+	* include/freetype/fterrdef.h: New file.
+	* include/freetype/fterrors.h: Include it.  It contains all error
+	codes.
+	* include/freetype/config/ftheader.h (FT_ERROR_DEFINITIONS_H): New
+	macro.
+
+	* include/freetype/internal/ftmemory.h, and a lot of other files:
+	Changed the names of memory macros.  Examples:
+
+	  MEM_Set   => FT_MEM_SET
+	  MEM_Copy  => FT_MEM_COPY
+	  MEM_Move  => FT_MEM_MOVE
+
+	  ALLOC     => FT_ALLOC
+	  FREE      => FT_FREE
+	  REALLOC   = >FT_REALLOC
+
+	FT_NEW was introduced to allocate a new object from a _typed_
+	pointer.
+
+	Note that ALLOC_ARRAY and REALLOC_ARRAY have been replaced by
+	FT_NEW_ARRAY and FT_RENEW_ARRAY which take _typed_ pointer
+	arguments.
+
+	This results in _lots_ of sources being changed, but makes the code
+	more generic and less error-prone.
+
+	* include/freetype/internal/ftstream.h, src/base/ftstream.c,
+	src/cff/cffload.c, src/pcf/pcfread.c, src/sfnt/ttcmap.c,
+	src/sfnt/ttcmap0.c, src/sfnt/ttload.c, src/sfnt/ttpost.c,
+	src/sfnt/ttsbit.c, src/truetype/ttgload.c, src/truetype/ttpload.c,
+	src/winfonts/winfnt.c: Changed the definitions of stream macros.
+	Examples:
+
+	  NEXT_Byte     => FT_NEXT_BYTE
+	  NEXT_Short    => FT_NEXT_SHORT
+	  NEXT_UShortLE => FT_NEXT_USHORT_LE
+	  READ_Short    => FT_READ_SHORT
+	  GET_Long      => FT_GET_LONG
+	  etc.
+
+	Also introduced the FT_PEEK_XXXX functions.
+
+	* src/cff/cffobjs.c (CFF_Build_Unicode_Charmap): Removed commented
+	out function.
+	(find_encoding): Removed.
+	(CFF_Face_Init): Remove charmap support.
+
+	* include/freetype/config/ftoption.h (FT_CONFIG_OPTION_USE_CMAPS,
+	TT_CONFIG_CMAP_FORMAT{0,2,4,6,8,10,12}): New macros to fine-tune
+	support of cmaps.
+
+2002-03-21  David Turner  <david@freetype.org>
+
+	* src/base/ftobjs.c, src/pcf/pcfdriver.c, src/pcf/pcfread.c: Updated
+	to new FT_CMap definitions.
+
+	* src/psaux/t1cmap.h, src/psaux/t1cmap.c, src/type1/t1cmap.h,
+	src/type1/t1cmap.c: Updating and moving the Type 1 FT_CMap support
+	from "src/type1" to "src/psaux" since it is going to be shared by
+	the Type 1 and CID font drivers.
+
+	* src/psaux/Jamfile, src/psaux/psaux.c, src/psaux/psauxmod.c,
+	src/psaux/rules.mk, include/freetype/internal/psaux.h: Added support
+	for Type 1 FT_CMaps.
+
+2002-03-20  David Turner  <david@freetype.org>
+
+	* src/base/ftgloadr.c (FT_GlyphLoader_CheckSubGlyphs): Fixed a
+	memory allocation bug that was due to un-careful renaming of the
+	FT_SubGlyph type.
+
+	* src/base/ftdbgmem.c (ft_mem_table_destroy): Fixed a small bug that
+	caused the library to crash with Electric Fence when memory
+	debugging is used.
+
+	* Renaming stream macros.  Examples:
+
+	  FILE_Skip    => FT_STREAM_SKIP
+	  FILE_Read    => FT_STREAM_READ
+	  ACCESS_Frame => FT_FRAME_ENTER
+	  FORGET_Frame => FT_FRAME_EXIT
+	  etc.
+
+	* src/sfnt/sfdriver.c (get_sfnt_postscript_name): Fixed memory leak.
+
+	* include/freetype/internal/ftobjs.h: Changing the definition of
+	FT_CMap_CharNextFunc slightly.
+
+	* src/cff/*.c: Updating CFF type definitions.
+
+2002-03-14  David Turner  <david@freetype.org>
+
+	* include/freetype/internal/autohint.h, src/autohint/ahmodule.c,
+	src/base/ftapi.c, src/base/ftobjs.c: Updating the type definitions
+	for the auto-hinter module.
+
+	  FT_AutoHinter_Interface  => FT_AutoHinter_ServiceRec
+	  FT_AutoHinter_Interface* => FT_AutoHinter_Service
+	  etc.
+
+	  FT_AutoHinter_Get_Global_Func  => FT_AutoHinter_GlobalGetFunc
+	  FT_AutoHinter_Done_Global_Func => FT_AutoHinter_GlobalDoneFunc
+	  etc.
+
+	* ahloader.h [_STANDALONE_]: Removed all conditional code.
+
+	* include/freetype/internal/cfftypes.h, src/cff/*.c: Updating the
+	type definitions of the CFF font driver.
+
+	  CFF_Font  => CFF_FontRec
+	  CFF_Font* => CFF_Font
+	  etc.
+
+	* include/freetype/internal/fnttypes.h, src/winfonts/*.c: Updating
+	type definitions of the Windows FNT font driver.
+
+	* include/freetype/internal/ftdriver.h,
+	include/freetype/internal/ftobjs.h, src/base/ftapi.c,
+	src/base/ftobjs.c, src/cff/cffdrivr.c, src/cff/cffdrivr.h,
+	src/cid/cidriver.c, src/cid/cidriver.h, src/pcf/pcfdriver.c,
+	src/pcf/pcfdriver.h, src/truetype/ttdriver.c,
+	src/truetype/ttdriver.h, src/type1/t1driver.c, src/type1/t1driver.h,
+	src/winfonts/winfnt.c, src/winfonts/winfnt.h: Updating type
+	definitions for font drivers.
+
+	  FTDriver_initFace      => FT_Face_InitFunc
+	  FTDriver_initGlyphSlot => FT_Slot_InitFunc
+	  etc.
+
+	* src/cid/cidobjs.c (CID_Face_Init): Remove dead code.
+
+	* include/freetype/internal/ftobjs.h, src/base/ftobjs.c: Updated a
+	few face method definitions:
+
+	  FT_PSName_Requester     => FT_Face_GetPostscriptNameFunc
+	  FT_Glyph_Name_Requester => FT_Face_GetGlyphNameFunc
+	  FT_Name_Index_Requester => FT_Face_GetGlyphNameIndexFunc
+
+	* src/base/ftapi.c: New file.  It contains backwards compatibility
+	functions.
+
+	* include/freetype/internal/psaux.h, src/cid/cidload.c,
+	src/cidtoken.h, src/psaux/psobjs.c, src/psaux/psobjs.h,
+	src/psaux/t1decode.c, stc/type1/t1load.c, src/type1/t1tokens.h:
+	Updated common PostScript type definitions.
+	Renamed all enumeration values like to uppercase variants:
+
+	  t1_token_any      => T1_TOKEN_TYPE_ANY
+	  t1_field_cid_info => T1_FIELD_LOCATION_CID_INFO
+	  etc.
+
+	* include/freetype/internal/psglobals.h: Removed.
+	* include/freetype/internal/pshints.h, src/pshinter/pshglob.h:
+	Updated.
+
+	* include/freetype/internal/tttypes.h,
+	include/freetype/internal/sfnt.h, src/base/ftnames.c,
+	src/cff/cffdrivr.c, src/sfnt/*.c, src/truetype/*.c: Updated
+	SFNT/TrueType type definitions.
+
+	* include/freetype/freetype.h, include/freetype/internal/ftgloadr.h:
+	Updating type defintiions for the glyph loader.
+
+2002-03-13  Antoine Leca  <antoine@oriolnet.com>
+
+	* include/freetype/config/ftoption.h: Changed the automatic
+	detection of Microsoft C compilers to automatically support 64-bit
+	integers only since revision 9.00 (i.e. >= Visual C++ 2.0).
+
+2002-03-08  Werner Lemberg  <wl@gnu.org>
+
+	* src/base/ftutil.c (FT_Realloc): Use MEM_Set instead of memset.
+
+2002-03-07  Werner Lemberg  <wl@gnu.org>
+
+	* src/base/ftdbgmem.c (ft_mem_table_resize, ft_mem_table_new,
+	ft_mem_table_set, ft_mem_debug_alloc, ft_mem_debug_free,
+	ft_mem_debug_realloc, ft_mem_debug_done, FT_Alloc_Debug,
+	FT_Realloc_Debug, FT_Free_Debug): Fix compiler warnings.
+	* src/base/ftcalc.c (FT_MulFix): Ditto.
+	* src/cff/cffdrivr.c (cff_get_name_index): Ditto.
+	* src/cff/cffobjs.c (CFF_Size_Get_Global_Funcs, CFF_Size_Init,
+	CFF_GlyphSlot_Init): Ditto.
+	* src/cid/cidobjs.c (CID_GlyphSlot_Init,
+	CID_Size_Get_Globals_Funcs): Ditto.
+	* src/type1/t1objs.c (T1_Size_Get_Globals_Funcs, T1_GlyphSlot_Init):
+	Ditto.
+	* src/pshinter/pshmod.c (pshinter_interface): Use `static const'.
+	* src/winfonts/winfnt.c (FNT_Get_Next_Char): Remove unused
+	variables.
+
+	* include/freetype/internal/psaux.h (T1_Builder_Funcs): Renamed
+	to...
+	(T1_Builder_FuncsRec): This.
+	(T1_Builder_Funcs): New typedef.
+	(PSAux_Interface): Remove compiler warnings.
+	* src/psaux/psauxmod.c (t1_builder_funcs), src/psaux/psobjs.h
+	(t1_builder_funcs): Updated.
+
+	* src/pshinter/pshglob.h (PSH_Blue_Align): Replaced with ...
+	(PSH_BLUE_ALIGN_{NONE,TOP,BOT}): New defines.
+	(PSH_AlignmentRec): Updated.
+
+	* include/freetype/internal/ftstream.h (GET_Char, GET_Byte): Fix
+	typo.
+	* include/freetype/internal/ftgloadr.h (FT_SubGlyph): Ditto.
+	* src/base/ftstream (FT_Get_Char): Rename to...
+	(FT_Stream_Get_Char): This.
+
+	* src/base/ftnames.c (FT_Get_Sfnt_Name): s/index/idx/ -- `index' is
+	a built-in function in gcc, causing warning messages with gcc 3.0.
+	* src/autohint/ahglyph.c (ah_outline_load): Ditto.
+	* src/autohint/ahglobal.c (ah_hinter_compute_blues): Ditto.
+	* src/cache/ftcmanag.c (ftc_family_table_alloc,
+	ftc_family_table_free, FTC_Manager_Done, FTC_Manager_Register_Cache):
+	Ditto.
+	* src/cff/cffload.c (cff_new_index, cff_done_index,
+	cff_explicit_index, CFF_Access_Element, CFF_Forget_Element,
+	CFF_Get_Name, CFF_Get_String, CFF_Load_SubFont, CFF_Load_Font,
+	CFF_Done_Font): Ditto.
+	* src/psaux/psobjs.c (PS_Table_Add, PS_Parser_LoadField): Ditto.
+	* src/psaux/t1decode.c (T1_Decoder_Parse_Charstrings): Ditto.
+	* src/pshinter/pshrec.c (ps_mask_test_bit, ps_mask_clear_bit,
+	ps_mask_set_bit, ps_dimension_add_t1stem, ps_hints_t1stem3,
+	* src/pshinter/pshalgo1.c (psh1_hint_table_record,
+	psh1_hint_table_record_mask, psh1_hint_table_activate_mask): Ditto.
+	* src/pshinter/pshalgo2.c (psh2_hint_table_record,
+	psh2_hint_table_record_mask, psh2_hint_table_activate_mask): Ditto.
+	* src/sfnt/ttpost.c (Load_Format_20, Load_Format_25,
+	TT_Get_PS_Name): Ditto.
+	* src/truetype/ttgload.c (TT_Get_Metrics, Get_HMetrics,
+	load_truetype_glyph): Ditto.
+	* src/type1/t1load.c (parse_subrs, T1_Open_Face): Ditto.
+	* src/type1/t1afm.c (T1_Get_Kerning): Ditto.
+	* include/freetype/cache/ftcmanag.h (ftc_family_table_free): Ditto.
+
+2002-03-06  David Turner  <david@freetype.org>
+
+	* src/type1/t1objs.c (T1_Face_Init), src/cid/cidobjs.c
+	(CID_Face_Init): Fixed another bug related to the
+	ascender/descender/text height of Postscript fonts.
+
+	* src/pshinter/pshalgo2.c (print_zone): Renamed to ...
+	(psh2_print_zone): This.
+	* src/pshinter/pshalgo1.c (print_zone): Renamed to ...
+	(psh1_print_zone): This.
+
+	* include/freetype/freetype.h, include/freetype/internal/ftobjs.h,
+	src/base/ftobjs.c: Adding the new FT_Library_Version API to return
+	the library's current version in dynamic links.
+	* src/base/ftinit.c (FT_Init_FreeType): Updated.
+
+2002-03-06  Werner Lemberg  <wl@gnu.org>
+
+	* src/pshinter/pshglob.h (PSH_DimensionRec): s/std/stdw/.
+	* src/pshinter/pshglob.c (psh_global_scale_widths,
+	psh_dimension_snap_width, psh_globals_destroy, psh_globals_new):
+	Ditto.
+
+2002-03-05  David Turner  <david@freetype.org>
+
+	* src/type1/t1objs.c (T1_Face_Init), src/cff/cffobjs.c
+	(CFF_Face_Init), src/cid/cidobjs.c (CID_Face_Init): Removing the bug
+	that returned global BBox values in 16.16 fixed format (instead of
+	integer font units).
+
+	* src/cid/cidriver.c (cid_get_postscript_name): Fixed a bug that
+	caused the CID driver to return Postscript font names with a leading
+	slash ("/") as in "/MOEKai-Regular".
+
+	* src/sfnt/ttload.c (TT_Load_Names), src/sfnt/sfobjs.c (Get_Name),
+	src/sfnt/sfdriver.c (get_sfnt_postscript_name): Fixed the loader so
+	that it accepts broken fonts like "foxjump.ttf", which made FreeType
+	crash when trying to load them.
+
+	Also improved the name table parser to be able to load
+	Windows-encoded entries before Macintosh or Unicode ones, since it
+	seems some fonts don't have reliable values here anyway.
+
+	* include/freetype/internal/psnames.h: Add typedef for
+	`PSNames_Service'.
+
+2002-03-05  Werner Lemberg  <wl@gnu.org>
+
+	* builds/unix/aclocal.m4, builds/unix/ltmain.sh: Update to libtool
+	1.4.2.
+	Apply a small patch for AIX to make shared libraries work (this
+	patch is already in the CVS version of libtool).
+
+	* builds/unix/config.sub, builds/unix/config.guess: Updated to
+	recent versions.
+
+	* builds/unix/configure.ac: Fix typo
+	(AC_CONFIG_FILE->AC_CONFIG_FILES).
+
+	* builds/unix/configure: Regenerated.
+
+2002-02-28  David Turner  <david@freetype.org>
+
+	* include/freetype/ftconfig.h: Changed `FT_LOCAL xxxx' to
+	`FT_LOCAL( xxxx )' everywhere in the source.  The same goes for
+	`FT_LOCAL_DEF xxxx' which is translated to `FT_LOCAL_DEF( xxxxx )'.
+
+	* include/freetype/freetype.h (FREETYPE_MINOR, FREETYPE_PATCH):
+	Changing version to 2.1.0 to indicate an unstable branch.
+	Added the declarations of FT_Get_First_Char and FT_Get_Next_Char.
+
+	* src/base/ftobjs.c: Implement FT_Get_First_Char and
+	FT_Get_Next_Char.
+
+	* include/freetype/t1tables.h: Renaming structure types.  This
+
+	  typedef  T1_Struct_
+	  {
+	  } T1_Struct;
+
+	becomes
+
+	  typedef  PS_StructRec_
+	  {
+	  } PS_StructRec, *PS_Struct;
+
+	  typedef PS_StructRec  T1_Struct;  /* backwards-compatibility */
+
+	Hence, we increase the coherency of the source code by effectively
+	using the `Rec' prefix for structure types.
+
+2002-02-27  David Turner  <david@freetype.org>
+
+	* src/sfnt/ttload.c (TT_Load_Names): Simplifying and securing the
+	names table loader.  Invalid individual name entries are now handled
+	correctly.  This allows the loading of very buggy fonts like
+	"foxjump.ttf" without allocating tons of memory and causing crashes.
+
+	* src/otlayout/otlcommon.h, src/otlayout/otlcommon.c: Adding (still
+	experimental) code for OpenType Layout tables validation and
+	parsing.
+
+	* src/type1/t1cmap.h, src/type1/t1cmap.c: Adding (still
+	experimental) code for Type 1 charmap processing.
+
+	* src/sfnt/ttcmap0.c: New file.  It contains a new, still
+	experimental SFNT charmap processing support.
+
+	* include/freetype/internal/ftobjs.h: Adding validation support as
+	well as internal charmap object definitions (FT_CMap != FT_CharMap).
+
+2002-02-24  David Turner  <david@freetype.org>
+
+	* Renaming stream functions to the FT_<Subject>_<Action> scheme:
+
+	  FT_Seek_Stream    => FT_Stream_Seek
+	  FT_Skip_Stream    => FT_Stream_Skip
+	  FT_Read_Stream    => FT_Stream_Read
+	  FT_Read_Stream_At => FT_Stream_Read_At
+	  FT_Access_Frame   => FT_Stream_Enter_Frame
+	  FT_Forget_Frame   => FT_Stream_Exit_Frame
+	  FT_Extract_Frame  => FT_Stream_Extract_Frame
+	  FT_Release_Frame  => FT_Stream_Release_Frame
+	  FT_Get_XXXX       => FT_Stream_Get_XXXX
+	  FT_Read_XXXX      => FT_Stream_Read_XXXX
+
+	  FT_New_Stream( filename, stream ) =>
+	    FT_Stream_Open( stream, filename )
+
+	    (The function doesn't create the FT_Stream structure, it simply
+	    initializes it for reading.)
+
+	  FT_New_Memory_Stream( library, FT_Byte*  base, size, stream ) =>
+	    FT_Stream_Open_Memory( stream, const FT_Byte* base, size )
+
+	  FT_Done_Stream  => FT_Stream_Close
+	  FT_Stream_IO    => FT_Stream_IOFunc
+	  FT_Stream_Close => FT_Stream_CloseFunc
+
+	  ft_close_stream => ft_ansi_stream_close (in base/ftsystem.c only)
+	  ft_io_stream    => ft_ansi_stream_io    (in base/ftsystem.c only)
+
+	* src/base/ftutil.c: New file.  Contains all memory and list
+	management code (previously in "ftobjs.c" and "ftlist.c",
+	respectively).
+
+	* include/freetype/internal/ftobjs.h: Moving all code related to
+	glyph loaders to ...
+	* include/freetype/"internal/ftgloadr.h: This new file.
+	"FT_GlyphLoader" is now a pointer to the structure
+	"FT_GlyphLoaderRec".
+	(ft_glyph_own_bitmap): Renamed to ...
+	(FT_GLYPH_OWN_BITMAP): This.
+	* src/base/ftobjs.c: Moving all code related to glyph loaders
+	to ...
+	* src/base/ftgloadr.c: This new file.
+
+2002-02-22  Werner Lemberg  <wl@gnu.org>
+
+	* include/freetype/internal/ftdebug.h (FT_Trace): Remove comma in
+	enum to avoid compiler warnings.
+
+2002-02-21  David Turner  <david@freetype.org>
+
+	Modified the debug sub-system initialization.  Trace levels can now
+	be specified within the "FT2_DEBUG" environment variable.  See the
+	comments within "ftdebug.c" for more details.
+
+	* src/base/ftdebug.c: (FT_SetTraceLevel): Removed.
+	(ft_debug_init): New function.
+	(ft_debug_dummy): Removed.
+	Updated to changes in ftdebug.h
+
+	* include/freetype/internal/ftdebug.h: Always define
+	FT_DEBUG_LEVEL_ERROR if FT_DEBUG_LEVEL_TRACE is defined.
+	(FT_Assert): Renamed to ...
+	(FT_ASSERT): This.
+	Some stuff from ftdebug.h has been moved to ...
+
+	* include/freetype/internal/fttrace.h: New file, to define the trace
+	levels used for debugging.  It is used both to define enums and
+	toggle names for FT2_DEBUG.
+
+	* include/freetype/internal/internal.h: Updated.
+
+	* src/base/ftobjs.c, src/base/ftstream.c: Updated.
+
+	* include/freetype/internal/ftextend.h, src/base/ftextend.c:
+	Removed.  Both files are now completely obsolete.
+	* src/base/Jamfile, src/base/rules.mk: Updated.
+
+	* include/freetype/fterrors.h: Adding "#undef FT_ERR_CAT" and
+	`#undef FT_ERR_XCAT" to avoid warnings with certain compilers (like
+	LCC).
+
+	* src/pshinter/pshalgo2.c (print_zone): Renamed to ...
+	(psh2_print_zone): This to avoid errors during compilation of debug
+	library.
+
+	* src/smooth/ftgrays.c (FT_COMPONENT): Change definition to as
+	`trace_smooth'.
+
+2002-02-20  David Turner  <david@freetype.org>
+
+	* README: Adding "devel@freetype.org" address for bug reports.
+
+2002-02-20  Werner Lemberg  <wl@gnu.org>
+
+	* builds/unix/install.mk (check): New dummy target.
+	(.PHONY): Add it.
+
+2002-02-19  Werner Lemberg  <wl@gnu.org>
+
+	* builds/freetype.mk (FT_CFLAGS): Use $(INCLUDE_FLAGS) first.
+
+	* src/cache/ftccache.c (ftc_cache_resize): Mark `error' as unused
+	to avoid compiler warning.
+	* src/cff/cffload.c (CFF_Get_String): Ditto.
+	* src/cff/cffobjs.c (CFF_StrCopy): Ditto.
+	* src/psaux/psobjs.c (PS_Table_Done): Ditto.
+	* src/pcf/pcfread.c (pcf_seek_to_table_type): Ditto.
+	* src/sfnt/sfdriver.c (get_sfnt_postscript_name): Ditto.
+	(pcf_get_bitmaps): The same for `sizebitmaps'.
+	* src/psaux/t1decode.c (T1_Decode_Parse_Charstrings): The same for
+	`orig_y'.
+	(t1operator_seac): Comment out more dead code.
+	* src/pshinter/pshalgo2.c (ps2_hints_apply): Add `DEBUG_HINTER'
+	conditional.
+	* src/truetype/ttgload.c (TT_Process_Simple_Glyph,
+	load_truetype_glyph): Add `TT_CONFIG_OPTION_BYTECODE_INTERPRETER'
+	conditional.
+
+2002-02-18  Werner Lemberg  <wl@gnu.org>
+
+	* src/autohint/ahglyph.c (ah_outline_link_segments): Remove unused
+	variables.
+	* src/autohint/ahhint.c (ah_align_serif_edge): Use FT_UNUSED instead
+	of UNUSED.
+	* src/autohint/ahmodule.c (ft_autohinter_reset): Ditto.
+	* src/pshinter/pshrec.c (ps_mask_table_merge): Fix typo in variable
+	swapping code.
+	* src/pshinter/pshglob.h (PSH_Blue_Align): Add PSH_BLUE_ALIGN_NONE.
+	* src/pshinter/pshglob.c (psh_blues_snap_stem): Use it.
+	* src/pshinter/pshalgo1.c (psh1_hint_table_optimize): Ditto.
+	* src/pshinter/pshalgo2.c (psh2_hint_align): Ditto.
+	* include/freetype/internal/ftobjs.h (UNUSED): Removed.
+
+2002-02-10  Roberto Alameda  <ojancano@geekmail.de>
+
+	Add support for ISOLatin1 PS encoding.
+
+	* include/freetype/freetype.h (ft_encoding_latin_1): New tag
+	(`lat1').
+	* include/freetype/internal/t1types.h (T1_Encoding_Type): Add
+	`t1_encoding_isolatin1'.
+	* src/type1/t1driver.c (Get_Char_Index, Get_Next_Char): Handle
+	ft_encoding_latin_1.
+	* src/type1/t1load.c (parse_encoding): Handle `ISOLatin1Encoding'.
+	* src/type1/t1objs.c (T1_Face_Init): Handle `t1_encoding_isolatin1'.
+
+2002-02-09  Werner Lemberg  <wl@gnu.org>
+
+	* README: Fix typo.
+	* docs/CHANGES: Minor fixes.
+
+
+	* Version 2.0.8 released.
+	=========================
+
+
+2002-02-08  David Turner  <david@freetype.org>
+
+	* docs/CHANGES: Updating for 2.0.8.
+
+	* include/freetype/freetype.h: Setting `PATCH_LEVEL' to 8 and
+	removing `FT_Get_Next_Char' from the API (temporarily).
+
+	* include/freetype/freetype.h: Adding comments to FT_Get_Next_Char;
+	note that this function might temporarily be removed for the 2.0.8
+	release.
+
+2002-02-07  David Turner  <david@freetype.org>
+
+	* src/pcf/pcfread.c (pcf_load_font): Removed immature support of
+	the AVERAGE_WIDTH property.
+
+2002-02-06  David Turner  <david@freetype.org>
+
+	* src/sfnt/sfobjs.c (SFNT_Load_Face): Since many fonts embedded in
+	PDF documents do not include 'cmap', 'post' and 'name' tables, the
+	SFNT face loader has been changed to not immediately report an
+	error if these are not present.
+
+	Note that the specification _requires_ these tables, but Adobe
+	seems to ignore it completely.
+
+	* src/sfnt/ttcmap.c: Removing compiler warnings.
+
+	* src/pcf/pcfread.c (pcf_read_TOC): Use FT_UInt.
+	(pcf_parse_metric, pcf_parse_compressed_metric): Removed.  Code
+	is now in ...
+	(pcf_get_metric): Here.
+	(pcfSeekToType): Renamed to ...
+	(pcf_seek_to_table_type): This.
+	Use FT_Int.
+	(pcfHasType): Renamed to ...
+	(pcf_has_table_type): This.
+	Use FT_Int.
+	(find_property): Renamed to ...
+	(pcf_find_property): This.
+	Use FT_Int.
+	(pcf_get_bitmaps, pcf_get_encodings): Handle invalid PCF fonts
+	better (delaying format checks out of FT_Access_Frame ..
+	FT_Forget_Frame blocks to avoid leaving the stream in an incorrect
+	state when encountering an invalid PCF font).
+
+	* src/pcf/pcfdriver.c (PCF_Done_Face): Renamed to ...
+	(PCF_Face_Done): This.
+	(PCF_Init_Face): Renamed to ...
+	(PCF_Face_Init): This.
+	(PCF_Get_Char_Index): Renamed to ...
+	(PCF_Char_Get_Index): This.
+	(PCF_Get_Next_Char): Renamed to ...
+	(PCF_Char_Get_Next): This.
+	(pcf_driver_class): Updated.
+
+	* src/pcf/pcf.h (PCF_Done_Face): Removed.
+
+2002-02-06  Detlef Würkner  <TetiSoft@apg.lahn.de>
+
+	* src/pcf/pcfdriver.c (FT_Done_Face): Fixed small memory leak.
+
+	* src/pcf/pcfread.c (pcf_load_font): Now handles the "AVERAGE_WIDTH"
+	property to return correct character pixel (width/height) pairs for
+	embedded bitmaps.
+
+2002-02-04  Keith Packard  <keithp@keithp.com>
+
+	Adding the function `FT_Get_Next_Char', doing the obvious thing
+	w.r.t. the selected charmap.
+
+	* include/freetype/freetype.h: Add prototype.
+	* include/freetype/internal/ftdriver.h: Add `FTDriver_getNextChar'
+	typedef.
+	(FT_Driver_Class): Use it.
+	* include/freetype/internal/psnames.h: Add `PS_Next_Unicode_Func'
+	typedef.
+	(PSNames_Interface): Use it.
+	* include/freetype/internal/tttypes.h: Add `TT_CharNext_Func'
+	typedef.
+	(TT_CMapTable): Use it.
+
+	* src/base/ftobjs.c (FT_Get_Next_Char): New function, implementing
+	high-level API.
+	* src/cff/cffdrivr.c (cff_get_next_char): New function.
+	(cff_driver_class): Add it.
+	* src/cid/cidriver.c (Cid_Get_Next_Char): New function.
+	(t1cid_driver_class): Add it.
+	* src/pcf/pcfdriver.c (PCF_Get_Next_Char): New function.
+	(pcf_driver_class): Add it.
+	* src/psnames/psmodule.c (PS_Next_Unicode): New function.
+	(psnames_interface): Add it.
+	* src/sfnt/ttcmap.c (code_to_next0, code_to_next2, code_to_next4,
+	code_to_next6, code_to_next_8_12, code_to_next_10): New auxiliary
+	functions.
+	(TT_CharMap_Load): Use them.
+	* src/truetype/ttdriver.c (Get_Next_Char): New function.
+	(tt_driver_class): Add it.
+	* src/type1/t1driver.c (Get_Next_Char): New function.
+	(t1_driver_class): Add it.
+	* src/winfnt/winfnt.c (FNT_Get_Next_Char): New function.
+	(winfnt_driver_class): Add it.
+
+	* src/pcf/pcfread.c (pcf_load_font): For now, report Unicode for
+	Unicode and Latin 1 encodings.
+
+2002-02-02  Keith Packard  <keithp@keithp.com>
+
+	* builds/unix/freetype-config.in: Add missing `fi'.
+
+
+	* Version 2.0.7 released.
+	=========================
+
+
+2002-02-01  David Turner  <david@freetype.org>
+
+	* include/freetype/freetype.h: Increasing FREETYPE_PATCH to 7
+	for the new release.
+
+2002-01-31  David Turner  <david@freetype.org>
+
+	* README, README.UNX, docs/CHANGES: Updating documentation for the
+	2.0.7 release.
+
+2002-01-30  David Turner  <david@freetype.org>
+
+	* INSTALL: Moved to ...
+	* docs/INSTALL: Here to avoid conflicts with the "install" script on
+	Windows, where the filesystem doesn't preserve case.
+
+2002-01-29  David Turner  <david@freetype.org>
+
+	* configure: Fixed the script.  It previously didn't accept more
+	than one argument correctly.  For example, when typing:
+
+	  ./configure --disable-shared --disable-nls
+
+	the "--disable-nls" was incorrectly sent to the "make" program.
+
+2002-01-29  Werner Lemberg  <wl@gnu.org>
+
+	* README.UNX: Fix typo.
+	* builds/unix/install.mk (uninstall): Fix library name for libtool.
+
+2002-01-28  Francesco Zappa Nardelli  <Francesco.Zappa.Nardelli@ens.fr>
+
+	* src/pcf/pcfdriver.c (PCF_Done_Face): Fix incorrect destruction of
+	the face object (face->toc.tables, face->root.family_name,
+	face->root.available_size, face->charset_encoding,
+	face->charset_registry are now freed).  Thanks to Niels Moseley.
+
+2002-01-28  Roberto Alameda  <ojancano@geekmail.de>
+
+	* src/type1/t1load.c (parse_encoding): Set `loader->num_chars'.
+
+2002-01-28  Werner Lemberg  <wl@gnu.org>
+
+	* src/type1/t1load.c (parse_subrs, parse_charstrings): Use copy
+	of `base' string for decrypting to not modify the original data.
+	Based on a patch by Jakub Bogusz <qboosh@pld.org.pl>.
+
+2002-01-27  Giuliano Pochini  <pochini@shiny.it>
+
+	* src/smooth/ftgrays.c (gray_render_scanline): Fix bug which caused
+	bad rendering of thin lines (less than one pixel thick).
+
+2002-01-25  Werner Lemberg  <wl@gnu.org>
+
+	* src/cff/cffdrivr.c (cff_get_name_index): Make last patch work
+	actually.
+
+2002-01-25  Martin Zinser  <zinser@decus.de>
+
+	* src/cache/ftccache.c (ftc_node_done, ftc_node_destroy): Fix
+	compilation warnings.
+	* src/base/descrip.mms (OBJS): Add `ftmm.obj'.
+	* src/cache/descrip.mms (ftcache.obj): Dependencies added.
+
+2002-01-25  WANG Yi  <wangyi@founder.com.cn>
+
+	* src/cff/cffdrivr.c (cff_get_name_index): Fix deallocation bug.
+
+2002-01-21  Antoine Leca  <Antoine-Freetype@Leca-Marti.org>
+
+	* docs/PATENTS: Typo fixed (thanks to Detlef "Hawkeye" Würkner) in
+	the URL for the online resource.
+
+2002-01-18  Ian Brown  <ian.brown@printsoft.de>
+
+	* builds/win32/ftdebug.c: New file.
+	* builds/win32/visualc/freetype.dsp: Updated.
+
+2002-01-18  Detlef Würkner  <TetiSoft@apg.lahn.de>
+
+	* builds/amiga/src/base/ftsystem.c: Updated for AmigaOS 3.9.
+	* builds/amiga/README: Updated.
+
+2002-01-18  Ian Brown  <ian.brown@printsoft.de>
+
+	* builds/win32/visualc/freetype.dsp: Updated.
+
+2002-01-13  Werner Lemberg  <wl@gnu.org>
+
+	* builds/unix/freetype2.a4: The script was still buggy.
+	* builds/unix/freetype-config.in: Make it really work for any install
+	prefix.
+
+2002-01-10  Werner Lemberg  <wl@gnu.org>
+
+	* builds/unix/freetype2.a4: Fix some serious bugs.
+
+2002-01-09  David Turner  <david@freetype.org>
+
+	* builds/unix/configure.ac: Build top-level Jamfile.
+
+2002-01-09  Maxim Shemanarev  <mcseemagg@yahoo.com>
+
+	* src/smooth/ftgrays.c (gray_render_line): Small optimization to
+	the smooth anti-aliased renderer that deals with vertical segments.
+	This results in a 5-7% speedup in rendering speed.
+
+2002-01-08  David Turner  <david@freetype.org>
+
+	Added some wrapper scripts to make the installation more
+	Unix-friendly.
+
+	* configure, install: New files.
+
+	* INSTALL, README.UNX: Updated installation documentation to use the
+	new 'configure' and 'install' scripts.
+
 2002-01-07  David Turner  <david@freetype.org>
 
-        * docs/BUGS, docs/CHANGES: updating documentation for 2.0.6 release
 
-        * src/tools/docmaker.py: fixed HTML quoting in sources
+	* Version 2.0.6 released.
+	=========================
 
-        * include/freetype/config/ftoption.h: setting default options for
-        a release build (debugging off, bytecode interpreter off)
 
-        * src/base/ftobjs.c, src/base/ftoutln.c, src/cache/ftccmap.c,
-        src/cff/cffload.c, src/cff/cffobjs.c, src/pshinter/pshalgo2.c,
-        src/sfnt/ttload.c, src/sfnt/ttsbit.c: removing small compiler
-        warnings (in pedantic compilation modes)
+	* docs/BUGS, docs/CHANGES: Updating documentation for 2.0.6 release.
 
+	* src/tools/docmaker.py: Fixed HTML quoting in sources.
+	(html_format): Replaced with ...
+	(html_quote): New function.
+	(html_quote0): New function.
+	(DocCode::dump_html: Small improvement.
+	(DocParagraph::dump, DocBlock::html): Use html_quote0 and html_quote.
+
+	* include/freetype/config/ftoption.h: Setting default options for
+	a release build (debugging off, bytecode interpreter off).
+
+	* src/base/ftobjs.c, src/base/ftoutln.c, src/cache/ftccmap.c,
+	src/cff/cffload.c, src/cff/cffobjs.c, src/pshinter/pshalgo2.c,
+	src/sfnt/ttload.c, src/sfnt/ttsbit.c: Removing small compiler
+	warnings (in pedantic compilation modes).
 
 2002-01-05  David Turner  <david@freetype.org>
 
@@ -118,7 +1751,7 @@
 
 	* src/cff/cffgload.c (CFF_Parse_CharStrings), src/psaux/t1decode.c
 	(T1_Decoder_Parse_Charstrings), src/pshinter/pshalgo2.c (*), Fixed a
-	bug where the X and Y axis where inversed in the postscript hinter. 
+	bug where the X and Y axis where inversed in the postscript hinter.
 	This caused problem when displaying on non-square surfaces.
 
 	* src/pshinter/pshalgo2.c: s/vertical/dimension/.
Index: xc/extras/freetype2/INSTALL
diff -u xc/extras/freetype2/INSTALL:1.1.1.4 xc/extras/freetype2/INSTALL:removed
--- xc/extras/freetype2/INSTALL:1.1.1.4	Mon Jan 14 11:51:55 2002
+++ xc/extras/freetype2/INSTALL	Thu Feb 27 12:20:30 2003
@@ -1,153 +0,0 @@
-In order to build the library, read the `BUILD' document in the `docs'
-directory.  This is only a quick starter.
-
-
-I. From the command line
-------------------------
-
-  There  are two ways  to quickly  build FreeType  2 from  the command
-  line.
-
-  The first, and favorite one, is to use the "Jam" build tool.  Jam is
-  a highly  portable replacement for  Make whose control files  do not
-  depend on the current platform or compiler toolset.
-
-  For more information, please see:
-
-    http://www.freetype.org/jam/index.html
-
-  The second one is to use "GNU Make" (and NO OTHER MAKE TOOL).
-
-
-  1. Building FT2 with "Jam"
-  --------------------------
-
-    Once you've  got *our version* of  the Jam tool  installed on your
-    system, simply go to the top-level FT2 directory, then type
-
-      "jam"
-
-    on the command line.  This will  build the library and place it in
-    the "objs" directory.
-
-    By default,  a static  library is built.   On Unix systems,  it is
-    possible to  build a shared library through  the "libtool" script.
-    You need to have libtool  installed on your system, then re-define
-    a few environment variables before invoking Jam, as in
-
-       export CC="libtool --mode=compile cc"
-       export LINK="libtool --mode=link cc"
-       jam
-
-    In  later releases  of  FT2, building  shared  libraries with  Jam
-    should become automatic.
-
-
-  2. Building FT2 with "GNU Make"
-  -------------------------------
-
-  You need  to have  GNU Make (version  3.78.1 or newer)  installed on
-  your system to compile the library from the command line.  This will
-  _NOT_ work with other make tools (including BSD make)!
-
-  [Well, this is not  really correct.  Recently, a perl implementation
-  of make called `makepp' has appeared which can also build FreeType 2
-  successfully on Unix platforms.  See http://LNC.usc.edu/~holt/makepp
-  for more details.]
-
-  - Go to the `freetype2' directory.
-
-  - Unix (any C compiler should work):
-
-      - make setup (don't worry, this will invoke a configure script)
-      - make
-      - make install
-
-    Alternatively,  you can  pass parameters  to the  configure script
-    within the CFG variable, as in:
-
-      - make setup CFG="--prefix=/usr"
-      - make
-      - make install
-
-    If the  configure script isn't run,  try to add `unix' as a target
-    on the command line, e.g.:
-
-      - make setup unix CFG="--prefix=/opt/experimental"
-
-
-  - Windows:
-
-    We provide a  version of GNU Make for Win32  on the FreeType site.
-    See http://www.freetype.org/download.html for details.
-
-    - gcc (Mingw, _not_ CygWin):
-
-        - make setup
-        - make
-
-
-    - Visual C++:
-
-        - make setup visualc
-        - make
-
-
-    - other compilers:
-
-        - make setup bcc32    -> Borland C++ 32 bits
-        - make setup intelc   -> Intel C++
-        - make setup watcom   -> Watcom C++
-        - make setup lcc      -> Win32-LCC
-
-
-II. In your own environment (IDE)
----------------------------------
-
-  You need to add  the directories "freetype2/include" to your include
-  path when compiling the library.
-
-  FreeType  2 is  made  of several  components;  each one  of them  is
-  located   in  a  subdirectory   of  "freetype2/src".   For  example,
-  `freetype2/src/truetype/' contains the TrueType font driver.
-
-  DO NOT COMPILE ALL C FILES!  Rather, compile the following ones:
-
-    -- base components (required)
-
-      src/base/ftsystem.c
-      src/base/ftinit.c
-      src/base/ftdebug.c
-      src/base/ftbase.c
-      src/base/ftglyph.c
-      src/base/ftbbox.c
-      src/base/ftmm.c
-
-      src/base/ftmac.c        -- only on the Macintosh
-
-    -- other components are optional
-
-      src/autohint/autohint.c -- auto hinting module
-      src/cache/ftcache.c     -- cache sub-system (in beta)
-      src/sfnt/sfnt.c         -- SFNT files support
-                                 (TrueType & OpenType)
-      src/cff/cff.c           -- CFF/OpenType font driver
-      src/psnames/psnames.c   -- Postscript glyph names support
-      src/psaux/psaux.c       -- Postscript Type 1 parsing
-      src/truetype/truetype.c -- TrueType font driver
-      src/type1/type1.c       -- Type 1 font driver
-      src/cid/type1cid.c      -- Type 1 CID-keyed font driver
-      src/winfonts/winfonts.c -- Windows FONT / FNT font driver
-
-    Note:
-
-       `truetype.c' needs `sfnt.c' and `psnames.c'
-       `type1.c'    needs `psaux.c' and `psnames.c'
-       `type1cid.c' needs `psaux.c' and `psnames.c'
-       `cff.c'      needs `sfnt.c', `psaux.c', and `psnames.c'
-
-       etc.
-
-For more information, please consult "docs/BUILD".
-
---- end of INSTALL --
Index: xc/extras/freetype2/Jamfile.in
diff -u /dev/null xc/extras/freetype2/Jamfile.in:1.1.1.2
--- /dev/null	Thu Feb 27 12:20:30 2003
+++ xc/extras/freetype2/Jamfile.in	Thu Jun 20 04:15:57 2002
@@ -0,0 +1,61 @@
+# FreeType 2 top Jamfile (c) 2001, 2002 David Turner
+#
+
+# We need to invoke a SubDir rule if the FT2 source directory top is not the
+# current directory.  This allows us to build FreeType 2 as part of a larger
+# project easily.
+#
+if $(FT2_TOP) != $(DOT)
+{
+  SubDir  FT2_TOP ;
+}
+
+FT2_INCLUDE = [ FT2_SubDir include ] ;
+FT2_SRC     = [ FT2_SubDir src ] ;
+
+FT2_LIB     = $(LIBPREFIX)freetype ;
+
+
+# We don't support libtool just yet.  It seems that this is not
+# so simple with Jam, but I'll study this topic later.
+#
+
+# used only when trying to debug the hinter(s)
+#
+if $(DEBUG_HINTER)
+{
+  CCFLAGS += -DDEBUG_HINTER ;
+}
+
+
+# We need "freetype2/include" in the current include path in order to
+# compile any part of FreeType 2.
+#
+SubDirHdr  += $(FT2_INCLUDE) ;
+
+# Uncomment the following line if you want to build individual source files
+# for each FreeType 2 module.
+#
+# FT2_MULTI = true ;
+
+# The file <freetype/config/ftheader.h> is used to define macros that are
+# later used in #include statements.  It needs to be parsed in order to
+# record these definitions.
+#
+HDRMACRO  [ FT2_SubDir  include freetype config ftheader.h ] ;
+HDRMACRO  [ FT2_SubDir  include freetype internal internal.h ] ;
+
+# Now include the Jamfile in "freetype2/src", used to drive the compilation
+# of each FreeType 2 component and/or module.
+#
+SubInclude  FT2_TOP src ;
+
+
+# tests files (hinter debugging)
+#
+if $(DEBUG_HINTER)
+{
+  SubInclude FT2_TOP tests ;
+}
+
+# end of top Jamfile
Index: xc/extras/freetype2/README
diff -u xc/extras/freetype2/README:1.1.1.4 xc/extras/freetype2/README:1.1.1.7
--- xc/extras/freetype2/README:1.1.1.4	Mon Jan 14 11:51:55 2002
+++ xc/extras/freetype2/README	Thu Jun 20 04:15:57 2002
@@ -1,27 +1,41 @@
 
-  Special note to Unix users
-  ==========================
+  Special notes to Unix users
+  ===========================
 
   Please   read  the  file   "README.UNX",  it   contains  important
   information  regarding  the   installation  of  FreeType  on  Unix
   systems, especially GNU based operating systems like GNU/Linux.
 
+  FreeType 2's library is called `libfreetype', FreeType 1's library
+  is called `libttf'.  They are *not* compatible!
 
-  FreeType 2.0.6
+
+  FreeType 2.1.1
   ==============
 
   Please   read  the  docs/CHANGES   file,  it   contains  IMPORTANT
   INFORMATION.
 
-  Read  the   files  "INSTALL"  or   "docs/BUILD"  for  installation
+  Read  the  files "docs/INSTALL"  or  "docs/BUILD" for installation
   instructions.
 
   Note  that the  FreeType 2  documentation  is now  available as  a
   separate package from our sites.  See:
+
+    ftp://ftp.freetype.org/pub/freetype2/ftdocs-2.1.1.tar.bz2
+    ftp://ftp.freetype.org/pub/freetype2/ftdocs-2.1.1.tar.gz
+    ftp://ftp.freetype.org/pub/freetype2/ftdoc211.zip
+
+
+  Reports
+  =======
+
+  Please  report  bugs  by  e-mail to  `devel@freetype.org'.   Don't
+  forget to send  a detailed explanation of the  problem -- there is
+  nothing worse  than receiving a  terse message that only  says "it
+  doesn't work".
+
 
-    ftp://ftp.freetype.org/pub/freetype2/ftdocs-2.0.6.tar.bz2
-    ftp://ftp.freetype.org/pub/freetype2/ftdocs-2.0.6.tar.gz
-    ftp://ftp.freetype.org/pub/freetype2/ftdoc206.zip
 
   Enjoy!
 
Index: xc/extras/freetype2/README.UNX
diff -u xc/extras/freetype2/README.UNX:1.1.1.1 xc/extras/freetype2/README.UNX:1.1.1.3
--- xc/extras/freetype2/README.UNX:1.1.1.1	Mon Jan 14 11:51:55 2002
+++ xc/extras/freetype2/README.UNX	Thu Jun 20 04:15:57 2002
@@ -7,23 +7,24 @@
   perform a few special steps to ensure that everything goes well.
 
 
+
   I. Enable the TrueType bytecode hinter if you need it
   -----------------------------------------------------
 
     The  TrueType  bytecode  interpreter  is disabled  in  all  public
     releases  of  the  FreeType  packages  for  patents  reasons  (see
     http://www.freetype.org/patents.html for more details).
-    
+
     However, many Linux distributions do enable the interpreter in the
     FreeType packages (DEB/RPM/etc.) they produce for their platforms.
     If you are using TrueType  fonts on your system, you most probably
     want to enable it manually by doing the following:
-    
+
       - open the file "include/freetype/config/ftoption.h"
-      
+
       - locate a line that says:
-      
-          #undef TT_CONFIG_OPTION_BYTECODE_ITNERPRETER
+
+          #undef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
 
       - change it to:
 
@@ -32,64 +33,100 @@
     of course, this must be done _before_ compiling the library
 
 
+
   II. Determine the correct installation path
-  -------------------------------------------
-  
+  --------------------------------------------
+
     By  default,  the  source  package  will install  the  library  in
     "/usr/local".   However, many Unix  distributions now  install the
     library in  "/usr", since FreeType  is becoming a  critical system
     component.
 
     If FreeType is already installed on your system, type
-    
+
       freetype-config --prefix
-       
+
     on the command line.  This  should return the installation path to
     use below  (e.g. "/usr"  or "/usr/local").  Otherwise,  simply use
-    "/usr".
+    "/usr" (or what you think is adequate for your installation).
+
+
+
+  III. Ensure that you are using GNU Make
+  ---------------------------------------
+
+    The FreeType build system  _exclusively_ works with GNU Make.  You
+    will  not be  able to  compile the  library with  the instructions
+    below using any other alternative (including BSD Make).
+
+    Trying  to compile  the library  with a  different Make  tool will
+    print a message like:
+
+      Sorry, GNU make is required to build FreeType2.
+
+    and the build  process will be aborted.  If  this happens, install
+    GNU Make on your system,  and use the GNUMAKE environment variable
+    to name it.
+
 
-    Then, to build and install the library, type:
-    
-      make setup unix CFG="--prefix=<yourprefix>"
+
+  IV. Build and install the library
+  ---------------------------------
+
+    The following  should work  on all Unix  systems where  the `make'
+    command invokes GNU Make:
+
+      ./configure --prefix=<yourprefix>
       make
-      make install            (as root)
-    
+      make install           (as root)
+
     where "<yourprefix>"  must be replaced  by the prefix  returned by
     the "freetype-config" command.
 
+    When using a different command to invoke GNU Make, use the GNUMAKE
+    variable.  For example,  if `gmake' is the command  to use on your
+    system, do something like:
+
+       GNUMAKE=gmake ./configure --prefix=<yourprefix>
+       gmake
+       gmake install            (as root)
+
+    If  this  still  doesn't   work,  read  the  detailed  compilation
+    procedure available in the file "docs/BUILD" for troubleshooting.
+
+
+  V. Take care of XFree86 version 4
+  ---------------------------------
 
-  III. Take care of XFree86 version 4
-  -----------------------------------
-  
     Certain recent Linux distributions will install _several_ versions
     of FreeType on your system.   For example, on a fresh Mandrake 8.1
     system, you can find the following files:
-    
+
       /usr/lib/libfreetype.so             which links to
       /usr/lib/libfreetype.6.1.0.so
-    
+
     and
-    
+
       /usr/X11R6/lib/libfreetype.so       which links to
       /usr/X11R6/lib/libfreetype.6.0.so
-    
+
     Note that these  files correspond to two distinct  versions of the
     library!   It seems  that  this  surprising issue  is  due to  the
     install  scripts  of recent  XFree86  servers  (from 4.1.0)  which
     irremediably install  their own (dated) version of  the library in
     "/usr/X11R6/lib".
-    
+
     In certain _rare_  cases you may experience minor  problems if you
     install this release  of the library in "/usr"  only, namely, that
     certain  applications will  not  benefit from  the  bug fixes  and
     rendering improvements you'd expect.
-    
+
     There are two good ways to deal with this situation:
-    
+
       - Install  the library  _twice_, in  "/usr" and  in "/usr/X11R6"
         (you  have to do  that each  time you  install a  new FreeType
         release though).
-      
+
       - Change the link in /usr/X11R6/lib/libfreetype.so to point to
 
           /usr/lib/libfreetype.so,
Index: xc/extras/freetype2/configure
diff -u /dev/null xc/extras/freetype2/configure:1.1.1.2
--- /dev/null	Thu Feb 27 12:20:30 2003
+++ xc/extras/freetype2/configure	Thu Jun 20 04:15:57 2002
@@ -0,0 +1,60 @@
+#!/bin/sh
+#
+# Call the 'configure' script located in 'builds/unix'.
+#
+# This should re-generate the following files:
+#
+#   config.mk
+#   Jamfile
+#   install
+#
+
+if test "x$GNUMAKE" = x; then
+  GNUMAKE=make
+fi
+
+if test -z "`$GNUMAKE -v 2>/dev/null | grep GNU`"; then
+  echo "Sorry, GNU make is required to build FreeType2." >&2
+  echo "Please try \`GNUMAKE=<GNU make command name> $0'." >&2
+  exit 1
+fi
+
+# Uh, oh.  This is taken from autoconf.  They know what they are doing...
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  ft_expr=expr
+else
+  ft_expr=false
+fi
+
+ft2_dir=`(dirname "$0") 2>/dev/null ||
+$ft_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+         X"$0" : 'X\(//\)[^/]' \| \
+         X"$0" : 'X\(//\)$' \| \
+         X"$0" : 'X\(/\)' \| \
+         .     : '\(.\)' 2>/dev/null ||
+echo X"$0" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+         /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+         /^X\(\/\/\)$/{ s//\1/; q; }
+         /^X\(\/\).*/{ s//\1/; q; }
+         s/.*/./; q'`
+
+abs_curr_dir=`pwd`
+abs_ft2_dir=`cd "$ft2_dir" && pwd`
+
+# build a dummy Makefile if we are not building in the source tree
+
+if test "$abs_curr_dir" != "$abs_ft2_dir"; then
+  echo "OBJ_DIR=$abs_curr_dir"          > Makefile
+  echo "TOP=$abs_ft2_dir"              >> Makefile
+  echo "OBJ_BUILD=$abs_curr_dir"       >> Makefile
+  echo "LIBTOOL=$abs_curr_dir/libtool" >> Makefile
+  echo "include $abs_ft2_dir/Makefile" >> Makefile
+fi
+
+# call make
+
+CFG="$@" $GNUMAKE setup unix
+
+# eof
Index: xc/extras/freetype2/descrip.mms
diff -u xc/extras/freetype2/descrip.mms:1.1.1.2 xc/extras/freetype2/descrip.mms:1.1.1.3
--- xc/extras/freetype2/descrip.mms:1.1.1.2	Mon Jan 14 11:51:55 2002
+++ xc/extras/freetype2/descrip.mms	Thu Jun 20 04:15:58 2002
@@ -36,6 +36,8 @@
         $(MMS)$(MMSQUALIFIERS)
         set default [-.base]
         $(MMS)$(MMSQUALIFIERS)
+        set default [-.bdf]
+        $(MMS)$(MMSQUALIFIERS)
         set default [-.cache]
         $(MMS)$(MMSQUALIFIERS)
         set default [-.cff]
@@ -44,6 +46,8 @@
         $(MMS)$(MMSQUALIFIERS)
         set default [-.pcf]
         $(MMS)$(MMSQUALIFIERS)
+        set default [-.pfr]
+        $(MMS)$(MMSQUALIFIERS)
         set default [-.psaux]
         $(MMS)$(MMSQUALIFIERS)
         set default [-.pshinter]
@@ -59,6 +63,8 @@
         set default [-.truetype]
         $(MMS)$(MMSQUALIFIERS)
         set default [-.type1]
+        $(MMS)$(MMSQUALIFIERS)
+        set default [-.type42]
         $(MMS)$(MMSQUALIFIERS)
         set default [-.winfonts]
         $(MMS)$(MMSQUALIFIERS)
Index: xc/extras/freetype2/install
diff -u /dev/null xc/extras/freetype2/install:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:30 2003
+++ xc/extras/freetype2/install	Thu Feb 14 19:33:16 2002
@@ -0,0 +1,2 @@
+#! /bin/sh
+make install
Index: xc/extras/freetype2/builds/detect.mk
diff -u xc/extras/freetype2/builds/detect.mk:1.1.1.3 xc/extras/freetype2/builds/detect.mk:1.1.1.4
--- xc/extras/freetype2/builds/detect.mk:1.1.1.3	Sun Sep  9 22:55:42 2001
+++ xc/extras/freetype2/builds/detect.mk	Thu Jun 20 04:15:58 2002
@@ -127,7 +127,7 @@
 	@echo "If this does not correspond to your system or settings please remove the file"
 	@echo "\`$(CONFIG_MK)' from this directory then read the INSTALL file for help."
 	@echo ""
-	@echo "Otherwise, simply type \`make' again to build the library."
+	@echo "Otherwise, simply type \`$(MAKE)' again to build the library."
 	@echo ""
 	@$(COPY) $(CONFIG_RULES) $(CONFIG_MK)
 
Index: xc/extras/freetype2/builds/freetype.mk
diff -u xc/extras/freetype2/builds/freetype.mk:1.1.1.3 xc/extras/freetype2/builds/freetype.mk:1.1.1.4
--- xc/extras/freetype2/builds/freetype.mk:1.1.1.3	Sun Sep  9 22:55:42 2001
+++ xc/extras/freetype2/builds/freetype.mk	Thu Jun 20 04:15:58 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -130,7 +130,7 @@
 #                 in the `freetype/builds/<system>' directory, as these
 #                 files will override the default sources.
 #
-INCLUDES := $(BUILD) $(TOP)$(SEP)include
+INCLUDES := $(OBJ_DIR) $(BUILD) $(TOP)$(SEP)include
 
 INCLUDE_FLAGS = $(INCLUDES:%=$I%)
 
@@ -139,7 +139,10 @@
 # least the paths for the `base' and `builds/<system>' directories;
 # debug/optimization/warning flags + ansi compliance if needed.
 #
-FT_CFLAGS  = $(CFLAGS) $(INCLUDE_FLAGS)
+# $(INCLUDE_FLAGS) should come before $(CFLAGS) to avoid problems with
+# old FreeType versions.
+#
+FT_CFLAGS  = $(INCLUDE_FLAGS) $(CFLAGS)
 FT_CC      = $(CC) $(FT_CFLAGS)
 FT_COMPILE = $(CC) $(ANSIFLAGS) $(FT_CFLAGS)
 
@@ -273,7 +276,7 @@
 # The Dos command shell does not support very long list of arguments, so
 # we are stuck with wildcards.
 #
-# Don't break the command lines with; this prevents the "del" command from
+# Don't break the command lines with \; this prevents the "del" command from
 # working correctly on Win9x.
 #
 clean_project_dos:
Index: xc/extras/freetype2/builds/amiga/README
diff -u xc/extras/freetype2/builds/amiga/README:1.1.1.2 xc/extras/freetype2/builds/amiga/README:1.1.1.3
--- xc/extras/freetype2/builds/amiga/README:1.1.1.2	Mon Jan 14 11:51:56 2002
+++ xc/extras/freetype2/builds/amiga/README	Thu Feb 14 19:33:16 2002
@@ -1,9 +1,8 @@
-The makefile is for ppc-morphos-gcc-2.95.3-bin.tgz (gcc 2.95.3 hosted
-on 68k-Amiga producing MorphOS-PPC-binaries from
-http://www.morphos.de). To use it, type "make assign", then "make",
+The makefile is  for ppc-morphos-gcc-2.95.3-bin.tgz (gcc 2.95.3 hosted
+on       68k-Amiga      producing       MorphOS-PPC-binaries      from
+http://www.morphos.de).  To  use it, type "make  assign", then "make";
 it produces a link library libft2_ppc.a.
 
-
 The smakefile is a makefile for Amiga SAS/C 6.58 (no longer available,
 latest sold version was 6.50, updates  can be found in Aminet).  It is
 based on the version found  in the sourcecode of ttf.library 0.83b for
@@ -11,8 +10,8 @@
 http://ragriffi.home.sprynet.com).
 
 You will  also need  the latest include  files and amiga.lib  from the
-Amiga Developer  CD V2.1  (or newer, I  hope...) for AmigaOS  3.5, the
-generated code should work under AmigaOS 2.04 (V37) and up.
+Amiga  web   site  (http://www.amiga.com/3.9/download/NDK3.9.lha)  for
+AmigaOS 3.9; the generated code should work under AmigaOS 2.04 and up.
 
 To use it, call "smake  assign" and then "smake" from the builds/amiga
 directory.  The results are:
@@ -72,7 +71,7 @@
   ft2_680x0.lib as link library.
 
 
-To adopt to other compilers:
+To adapt to other compilers:
 
 - The standard ANSI  C maximum length of 31  significant characters in
   identifiers is not enough for FreeType2.  Check if your compiler has
Index: xc/extras/freetype2/builds/amiga/makefile
diff -u xc/extras/freetype2/builds/amiga/makefile:1.1.1.1 xc/extras/freetype2/builds/amiga/makefile:1.1.1.2
--- xc/extras/freetype2/builds/amiga/makefile:1.1.1.1	Mon Jan 14 11:51:55 2002
+++ xc/extras/freetype2/builds/amiga/makefile	Thu Jun 20 04:15:58 2002
@@ -11,15 +11,18 @@
 # Your programs source code should start with this
 # (uncomment the parts you do not need to keep the program small):
 # ---8<---
-#define FT_USE_AUTOHINT	// autohinter
-#define FT_USE_RASTER	// monochrome rasterizer
-#define FT_USE_SMOOTH	// anti-aliasing rasterizer
-#define FT_USE_TT	// truetype font driver
-#define FT_USE_T1	// type1 font driver
-#define FT_USE_T1CID	// cid-keyed type1 font driver
-#define FT_USE_CFF	// opentype font driver
-#define FT_USE_PCF	// pcf bitmap font driver
-#define FT_USE_WINFNT	// windows .fnt|.fon bitmap font driver
+#define FT_USE_AUTOHINT // autohinter
+#define FT_USE_RASTER   // monochrome rasterizer
+#define FT_USE_SMOOTH   // anti-aliasing rasterizer
+#define FT_USE_TT       // truetype font driver
+#define FT_USE_T1       // type1 font driver
+#define FT_USE_T42      // type42 font driver
+#define FT_USE_T1CID    // cid-keyed type1 font driver
+#define FT_USE_CFF      // opentype font driver
+#define FT_USE_BDF      // bdf bitmap font driver
+#define FT_USE_PCF      // pcf bitmap font driver
+#define FT_USE_PFR      // pfr font driver
+#define FT_USE_WINFNT   // windows .fnt|.fon bitmap font driver
 #include "FT:src/base/ftinit.c"
 # ---8<---
 #
@@ -151,15 +154,21 @@
 	$(CC) -c $(CFLAGS) -o $@ $<
 
 #
+# FreeType2 library Type42 font driver
+#
+type42.ppc.o: $(FTSRC)/type42/type42.c
+	$(CC) -c $(CFLAGS) -o $@ $<
+
+#
 # FreeType2 library CID-keyed Type1 font driver
 #
 type1cid.ppc.o: $(FTSRC)/cid/type1cid.c
 	$(CC) -c $(CFLAGS) -o $@ $<
 
 #
-# FreeType2 library Windows FNT/FON bitmap font driver
+# FreeType2 library BDF bitmap font driver
 #
-winfnt.ppc.o: $(FTSRC)/winfonts/winfnt.c
+bdf.ppc.o: $(FTSRC)/bdf/bdf.c
 	$(CC) -c $(CFLAGS) -o $@ $<
 
 #
@@ -168,6 +177,18 @@
 pcf.ppc.o: $(FTSRC)/pcf/pcf.c
 	$(CC) -c $(CFLAGS) -o $@ $<
 
+#
+# FreeType2 library PFR font driver
+#
+pfr.ppc.o: $(FTSRC)/pfr/pfr.c
+	$(CC) -c $(CFLAGS) -o $@ $<
+
+#
+# FreeType2 library Windows FNT/FON bitmap font driver
+#
+winfnt.ppc.o: $(FTSRC)/winfonts/winfnt.c
+	$(CC) -c $(CFLAGS) -o $@ $<
+
 BASEPPC = ftbase.ppc.o ftglyph.ppc.o ftbbox.ppc.o ftmm.ppc.o ftsynth.ppc.o
 
 DEBUGPPC = ftdebug.ppc.o ftdebugpure.ppc.o
@@ -178,7 +199,8 @@
 
 RASTERPPC = raster.ppc.o smooth.ppc.o
 
-FONTDPPC = cff.ppc.o type1.ppc.o type1cid.ppc.o truetype.ppc.o winfnt.ppc.o pcf.ppc.o
+FONTDPPC = cff.ppc.o type1.ppc.o type42.ppc.o type1cid.ppc.o truetype.ppc.o\
+	   bdf.ppc.o pcf.ppc.o pfr.ppc.o winfnt.ppc.o
 
 libft2_ppc.a:    $(BASEPPC) $(AHINTPPC) $(PSPPC) $(RASTERPPC) sfnt.ppc.o ftcache.ppc.o $(FONTDPPC)
 	$(AR) $@ $(BASEPPC) $(AHINTPPC) $(PSPPC) $(RASTERPPC) sfnt.ppc.o ftcache.ppc.o $(FONTDPPC)
Index: xc/extras/freetype2/builds/amiga/smakefile
diff -u xc/extras/freetype2/builds/amiga/smakefile:1.1.1.2 xc/extras/freetype2/builds/amiga/smakefile:1.1.1.3
--- xc/extras/freetype2/builds/amiga/smakefile:1.1.1.2	Mon Jan 14 11:51:56 2002
+++ xc/extras/freetype2/builds/amiga/smakefile	Thu Jun 20 04:15:58 2002
@@ -9,15 +9,18 @@
 # Your programs source code should start with this
 # (uncomment the parts you do not need to keep the program small):
 # ---8<---
-#define FT_USE_AUTOHINT	// autohinter
-#define FT_USE_RASTER	// monochrome rasterizer
-#define FT_USE_SMOOTH	// anti-aliasing rasterizer
-#define FT_USE_TT	// truetype font driver
-#define FT_USE_T1	// type1 font driver
-#define FT_USE_T1CID	// cid-keyed type1 font driver
-#define FT_USE_CFF	// opentype font driver
-#define FT_USE_PCF	// pcf bitmap font driver
-#define FT_USE_WINFNT	// windows .fnt|.fon bitmap font driver
+#define FT_USE_AUTOHINT // autohinter
+#define FT_USE_RASTER   // monochrome rasterizer
+#define FT_USE_SMOOTH   // anti-aliasing rasterizer
+#define FT_USE_TT       // truetype font driver
+#define FT_USE_T1       // type1 font driver
+#define FT_USE_T42      // type42 font driver
+#define FT_USE_T1CID    // cid-keyed type1 font driver
+#define FT_USE_CFF      // opentype font driver
+#define FT_USE_BDF      // bdf bitmap font driver
+#define FT_USE_PCF      // pcf bitmap font driver
+#define FT_USE_PFR      // pfr font driver
+#define FT_USE_WINFNT   // windows .fnt|.fon bitmap font driver
 #include "FT:src/base/ftinit.c"
 # ---8<---
 #
@@ -47,23 +50,12 @@
 
 OBJCACHE = ftcache.o
 
-OBJOT = cff.o
-
-OBJT1 = type1.o
-
-OBJT1C = type1cid.o
-
-OBJTT = truetype.o
-
-OBJWINFNT = winfnt.o
-
-OBJPCF = pcf.o
-
 OBJPS = $(OBJPSAUX) $(OBJPSNAM) $(OBJPSHINT)
 
 OBJRASTER = $(OBJRAST) $(OBJSMOOTH)
 
-OBJFONTD = $(OBJOT) $(OBJT1) $(OBJT1C) $(OBJTT) $(OBJWINFNT) $(OBJPCF)
+OBJFONTD = cff.o type1.o type42.o type1cid.o\
+	   truetype.o winfnt.o bdf.o pcf.o pfr.o
 
 CORE = FT:src/
 
@@ -203,6 +195,12 @@
 	sc $(SCFLAGS) objname=$@ $<
 
 #
+# FreeType2 library Type42 font driver
+#
+type42.o: $(CORE)type42/type42.c
+	sc $(SCFLAGS) objname=$@ $<
+
+#
 # freetype library CID-keyed Type1 font driver
 #
 type1cid.o: $(CORE)cid/type1cid.c
@@ -214,13 +212,25 @@
 #	sc $(SCFLAGS) objname=$@ $<
 
 #
-# freetype library Windows FNT/FON bitmap font driver
+# freetype library BDF bitmap font driver
 #
-winfnt.o: $(CORE)winfonts/winfnt.c
+bdf.o: $(CORE)bdf/bdf.c
 	sc $(SCFLAGS) objname=$@ $<
 
 #
 # freetype library PCF bitmap font driver
 #
 pcf.o: $(CORE)pcf/pcf.c
+	sc $(SCFLAGS) objname=$@ $<
+
+#
+# freetype library PFR font driver
+#
+pfr.o: $(CORE)pfr/pfr.c
+	sc $(SCFLAGS) objname=$@ $<
+
+#
+# freetype library Windows FNT/FON bitmap font driver
+#
+winfnt.o: $(CORE)winfonts/winfnt.c
 	sc $(SCFLAGS) objname=$@ $<
Index: xc/extras/freetype2/builds/amiga/include/freetype/config/ftmodule.h
diff -u xc/extras/freetype2/builds/amiga/include/freetype/config/ftmodule.h:1.1.1.2 xc/extras/freetype2/builds/amiga/include/freetype/config/ftmodule.h:1.1.1.3
--- xc/extras/freetype2/builds/amiga/include/freetype/config/ftmodule.h:1.1.1.2	Mon Jan 14 11:51:56 2002
+++ xc/extras/freetype2/builds/amiga/include/freetype/config/ftmodule.h	Thu Jun 20 04:15:58 2002
@@ -7,9 +7,12 @@
 //#define FT_USE_SMOOTH         // anti-aliasing rasterizer
 //#define FT_USE_TT             // truetype font driver
 //#define FT_USE_T1             // type1 font driver
-//#define FT_USE_T1CID          // cid-keyed type1 font driver  // no cmap support, useless
-//#define FT_USE_CFF            // opentype font driver         // does not work with TektonPro
+//#define FT_USE_T42            // type42 font driver           // yet unstable
+//#define FT_USE_T1CID          // cid-keyed type1 font driver  // no cmap support
+//#define FT_USE_CFF            // opentype font driver
+//#define FT_USE_BDF            // bdf bitmap font driver
 //#define FT_USE_PCF            // pcf bitmap font driver
+//#define FT_USE_PFR            // pfr font driver
 //#define FT_USE_WINFNT         // windows .fnt|.fon bitmap font driver
 #include "FT:src/base/ftinit.c"
 */
@@ -17,6 +20,10 @@
 // TetiSoft: make sure that needed support modules are built in.
 // Dependencies can be found by searching for FT_Get_Module.
 
+#ifdef FT_USE_T42
+#define FT_USE_TT
+#endif
+
 #ifdef FT_USE_TT
 #define FT_USE_SFNT
 #endif
@@ -65,10 +72,18 @@
 FT_USE_MODULE(t1cid_driver_class)
 #endif
 
+#ifdef FT_USE_BDF
+FT_USE_MODULE(bdf_driver_class)
+#endif
+
 #ifdef FT_USE_PCF
 FT_USE_MODULE(pcf_driver_class)
 #endif
 
+#ifdef FT_USE_PFR
+FT_USE_MODULE(pfr_driver_class)
+#endif
+
 #ifdef FT_USE_PSAUX
 FT_USE_MODULE(psaux_module_class)
 #endif
@@ -95,6 +110,10 @@
 
 #ifdef FT_USE_T1
 FT_USE_MODULE(t1_driver_class)
+#endif
+
+#ifdef FT_USE_T42
+FT_USE_MODULE(t42_driver_class)
 #endif
 
 #ifdef FT_USE_WINFNT
Index: xc/extras/freetype2/builds/amiga/src/base/ftdebug.c
diff -u xc/extras/freetype2/builds/amiga/src/base/ftdebug.c:1.1.1.1 xc/extras/freetype2/builds/amiga/src/base/ftdebug.c:1.1.1.2
--- xc/extras/freetype2/builds/amiga/src/base/ftdebug.c:1.1.1.1	Sun Dec 16 12:49:13 2001
+++ xc/extras/freetype2/builds/amiga/src/base/ftdebug.c	Thu Jun 20 04:15:58 2002
@@ -58,7 +58,6 @@
 
 #include <stdarg.h>
 #include <stdlib.h>
-#include <string.h>
 
 
   FT_EXPORT_DEF( void )
@@ -89,35 +88,98 @@
   }
 
 
-#ifdef FT_DEBUG_LEVEL_TRACE
 
-  FT_EXPORT_DEF( void )
-  FT_SetTraceLevel( FT_Trace  component,
-                    char      level )
-  {
-    if ( component >= trace_max )
-      return;
+  /* since I don't know wether "getenv" is available on the Amiga */
+  /* I prefer to simply disable this code for now in all builds   */
+  /*                                                              */
 
-    /* if component is `trace_any', change _all_ levels at once */
-    if ( component == trace_any )
-    {
-      int  n;
+/* #ifdef FT_DEBUG_LEVEL_TRACE */
+#if 0
 
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    const char*  ft2_debug = getenv( "FT2_DEBUG" );
+    
 
-      for ( n = trace_any; n < trace_max; n++ )
-        ft_trace_levels[n] = level;
+    if ( ft2_debug )
+    {
+      const char*  p = ft2_debug;
+      const char*  q;
+      
+
+      for ( ; *p; p++ )
+      {
+        /* skip leading whitespace and separators */
+        if ( *p == ' ' || *p == '\t' || *p == ':' || *p == ';' || *p == '=' )
+          continue;
+          
+        /* read toggle name, followed by '=' */
+        q = p;
+        while ( *p && *p != '=' )
+          p++;
+          
+        if ( *p == '=' && p > q )
+        {
+          int  n, i, len = p - q;
+          int  level = -1, found = -1;
+          
+
+          for ( n = 0; n < trace_count; n++ )
+          {
+            const char*  toggle = ft_trace_toggles[n];
+            
+
+            for ( i = 0; i < len; i++ )
+            {
+              if ( toggle[i] != q[i] )
+                break;
+            }
+            
+            if ( i == len && toggle[i] == 0 )
+            {
+              found = n;
+              break;
+            }
+          }
+          
+          /* read level */
+          p++;
+          if ( *p )
+          {
+            level = *p++ - '0';
+            if ( level < 0 || level > 6 )
+              level = -1;
+          }
+          
+          if ( found >= 0 && level >= 0 )
+          {
+            if ( found == trace_any )
+            {
+              /* special case for "any" */
+              for ( n = 0; n < trace_count; n++ )
+                ft_trace_levels[n] = level;
+            }
+            else
+              ft_trace_levels[found] = level;
+          }
+        }
+      }
     }
-    else        /* otherwise, only change individual component */
-      ft_trace_levels[component] = level;
   }
 
-#endif /* FT_DEBUG_LEVEL_TRACE */
 
-#endif /* FT_DEBUG_LEVEL_TRACE || FT_DEBUG_LEVEL_ERROR */
+#else  /* !FT_DEBUG_LEVEL_TRACE */
+
+
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    /* nothing */
+  }
 
 
-  /* ANSI C doesn't allow empty files, so we insert a dummy symbol */
-  extern const int  ft_debug_dummy;
+#endif /* !FT_DEBUG_LEVEL_TRACE */
 
 
 /* END */
Index: xc/extras/freetype2/builds/amiga/src/base/ftsystem.c
diff -u xc/extras/freetype2/builds/amiga/src/base/ftsystem.c:1.1.1.2 xc/extras/freetype2/builds/amiga/src/base/ftsystem.c:1.1.1.4
--- xc/extras/freetype2/builds/amiga/src/base/ftsystem.c:1.1.1.2	Mon Jan 14 11:51:56 2002
+++ xc/extras/freetype2/builds/amiga/src/base/ftsystem.c	Thu Jun 20 04:15:58 2002
@@ -1,16 +1,48 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsystem.c                                                             */
+/*                                                                         */
+/*    Amiga-specific FreeType low-level system interface (body).           */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file contains the Amiga interface used by FreeType to access     */
+  /* low-level, i.e. memory management, i/o access as well as thread       */
+  /* synchronisation.                                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+// Maintained by Detlef Würkner <TetiSoft@apg.lahn.de>
+
 // TetiSoft: Modified to avoid fopen() fclose() fread() fseek() ftell()
 // malloc() realloc() and free() which can't be used in an amiga
 // shared run-time library linked with libinit.o
 
+#include <exec/memory.h>
+
 #ifdef __GNUC__
 // Avoid warnings "struct X declared inside parameter list"
-#include <exec/memory.h>
 #include <exec/devices.h>
 #include <exec/io.h>
 #include <exec/semaphores.h>
 #include <dos/exall.h>
 #endif
 
+// Necessary with OS3.9 includes
+#define __USE_SYSBASE
+
 #include <proto/exec.h>
 #include <proto/dos.h>
 
@@ -18,80 +50,63 @@
 /* TetiSoft: Missing in alib_protos.h, see amiga.lib autodoc
  * (These amiga.lib functions work under AmigaOS V33 and up)
  */
-extern APTR __asm AsmCreatePool(register __d0 ULONG memFlags,
-                                register __d1 ULONG puddleSize,
-                                register __d2 ULONG threshSize,
-                                register __a6 struct ExecBase *SysBase);
-
-extern VOID __asm AsmDeletePool(register __a0 APTR poolHeader,
-                                register __a6 struct ExecBase *SysBase);
-
-extern APTR __asm AsmAllocPooled(register __a0 APTR poolHeader,
-                                 register __d0 ULONG memSize,
-                                 register __a6 struct ExecBase *SysBase);
-
-extern VOID __asm AsmFreePooled(register __a0 APTR poolHeader,
-                                register __a1 APTR memory,
-                                register __d0 ULONG memSize,
-                                register __a6 struct ExecBase *SysBase);
+extern APTR __asm
+AsmCreatePool( register __d0 ULONG             memFlags,
+               register __d1 ULONG             puddleSize,
+               register __d2 ULONG             threshSize,
+               register __a6 struct ExecBase*  SysBase );
+
+extern VOID __asm
+AsmDeletePool( register __a0 APTR              poolHeader,
+               register __a6 struct ExecBase*  SysBase );
+
+extern APTR __asm
+AsmAllocPooled( register __a0 APTR              poolHeader,
+                register __d0 ULONG             memSize,
+                register __a6 struct ExecBase*  SysBase );
+
+extern VOID __asm
+AsmFreePooled( register __a0 APTR              poolHeader,
+               register __a1 APTR              memory,
+               register __d0 ULONG             memSize,
+               register __a6 struct ExecBase*  SysBase);
 #endif
 
 
 // TetiSoft: C implementation of AllocVecPooled (see autodoc exec/AllocPooled)
-APTR AllocVecPooled(APTR poolHeader, ULONG memSize)
+APTR
+AllocVecPooled( APTR   poolHeader,
+                ULONG  memSize )
 {
-        ULONG newSize = memSize + sizeof(ULONG);
+  ULONG  newSize = memSize + sizeof ( ULONG );
 #ifdef __GNUC__
-        ULONG *mem = AllocPooled(poolHeader, newSize);
+  ULONG  *mem = AllocPooled( poolHeader, newSize );
 #else
-        ULONG *mem = AsmAllocPooled(poolHeader, newSize, SysBase);
+  ULONG  *mem = AsmAllocPooled( poolHeader, newSize, SysBase );
 #endif
 
-        if (!mem)
-                return NULL;
-        *mem = newSize;
-        return mem + 1;
+  if ( !mem )
+    return NULL;
+  *mem = newSize;
+  return mem + 1;
 }
 
+
 // TetiSoft: C implementation of FreeVecPooled (see autodoc exec/AllocPooled)
-void FreeVecPooled(APTR poolHeader, APTR memory)
+void
+FreeVecPooled( APTR  poolHeader,
+               APTR  memory )
 {
-        ULONG *realmem = (ULONG *)memory - 1;
+  ULONG  *realmem = (ULONG *)memory - 1;
 
 #ifdef __GNUC__
-        FreePooled(poolHeader, realmem, *realmem);
+  FreePooled( poolHeader, realmem, *realmem );
 #else
-        AsmFreePooled(poolHeader, realmem, *realmem, SysBase);
+ AsmFreePooled( poolHeader, realmem, *realmem, SysBase );
 #endif
 }
 
-/***************************************************************************/
-/*                                                                         */
-/*  ftsystem.c                                                             */
-/*                                                                         */
-/*    ANSI-specific FreeType low-level system interface (body).            */
-/*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
-/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
-/*                                                                         */
-/*  This file is part of the FreeType project, and may only be used,       */
-/*  modified, and distributed under the terms of the FreeType project      */
-/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
-/*  this file you indicate that you have read the license and              */
-/*  understand and accept it fully.                                        */
-/*                                                                         */
-/***************************************************************************/
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* This file contains the default interface used by FreeType to access   */
-  /* low-level, i.e. memory management, i/o access as well as thread       */
-  /* synchronisation.  It can be replaced by user-specific routines if     */
-  /* necessary.                                                            */
-  /*                                                                       */
-  /*************************************************************************/
 
-
 #include <ft2build.h>
 #include FT_CONFIG_CONFIG_H
 #include FT_INTERNAL_DEBUG_H
@@ -199,9 +214,9 @@
   /*    The memory release function.                                       */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    memory  :: A pointer to the memory object.                         */
+  /*    memory :: A pointer to the memory object.                          */
   /*                                                                       */
-  /*    block   :: The address of block in memory to be freed.             */
+  /*    block  :: The address of block in memory to be freed.              */
   /*                                                                       */
   FT_CALLBACK_DEF( void )
   ft_free( FT_Memory  memory,
@@ -233,7 +248,7 @@
 
   /* We use the macro STREAM_FILE for convenience to extract the       */
   /* system-specific stream handle from a given FreeType stream object */
-//#define STREAM_FILE( stream )  ( (FILE*)stream->descriptor.pointer )
+// #define STREAM_FILE( stream )  ( (FILE*)stream->descriptor.pointer )
 #define STREAM_FILE( stream )  ( (BPTR)stream->descriptor.pointer )     // TetiSoft
 
 
@@ -303,22 +318,22 @@
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Error )
-  FT_New_Stream( const char*  filepathname,
-                 FT_Stream    astream )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname )
   {
-//  FILE*  file;
-    BPTR   file;                // TetiSoft
-    struct FileInfoBlock *fib;  // TetiSoft
+//  FILE*                  file;
+    BPTR                   file; // TetiSoft
+    struct FileInfoBlock*  fib;  // TetiSoft
 
 
-    if ( !astream )
+    if ( !stream )
       return FT_Err_Invalid_Stream_Handle;
 
 //  file = fopen( filepathname, "rb" );
     file = Open( filepathname, MODE_OLDFILE );  // TetiSoft
     if ( !file )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
 
       return FT_Err_Cannot_Open_Resource;
@@ -331,52 +346,51 @@
     if ( !fib )
     {
       Close ( file );
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
 
       return FT_Err_Cannot_Open_Resource;
     }
-    if (!( ExamineFH ( file, fib )))
+    if ( !( ExamineFH( file, fib ) ) )
     {
-      FreeDosObject(DOS_FIB, fib);
+      FreeDosObject( DOS_FIB, fib );
       Close ( file );
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
 
       return FT_Err_Cannot_Open_Resource;
     }
-    astream->size = fib->fib_Size;
-    FreeDosObject(DOS_FIB, fib);
+    stream->size = fib->fib_Size;
+    FreeDosObject( DOS_FIB, fib );
 
-//  astream->descriptor.pointer = file;
-    astream->descriptor.pointer = (void *)file;
+//  stream->descriptor.pointer = file;
+    stream->descriptor.pointer = (void *)file;
 
-    astream->pathname.pointer   = (char*)filepathname;
-    astream->pos                = 0;
+    stream->pathname.pointer   = (char*)filepathname;
+    stream->pos                = 0;
 
-    astream->read  = ft_io_stream;
-    astream->close = ft_close_stream;
+    stream->read  = ft_io_stream;
+    stream->close = ft_close_stream;
 
-    FT_TRACE1(( "FT_New_Stream:" ));
+    FT_TRACE1(( "FT_Stream_Open:" ));
     FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
-                filepathname, astream->size ));
+                filepathname, stream->size ));
 
     return FT_Err_Ok;
   }
 
 
-
 #ifdef FT_DEBUG_MEMORY
 
   extern FT_Int
   ft_mem_debug_init( FT_Memory  memory );
-  
+
   extern void
   ft_mem_debug_done( FT_Memory  memory );
-  
-#endif  
-      
 
+#endif
+
+
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Memory )
@@ -389,15 +403,15 @@
     memory = (FT_Memory)AllocVec( sizeof ( *memory ), MEMF_PUBLIC );
     if ( memory )
     {
-//    memory->user    = 0;
+//    memory->user = 0;
 #ifdef __GNUC__
-      memory->user    = CreatePool ( MEMF_PUBLIC, 2048, 2048 );
+      memory->user = CreatePool( MEMF_PUBLIC, 2048, 2048 );
 #else
-      memory->user    = AsmCreatePool ( MEMF_PUBLIC, 2048, 2048, SysBase );
+      memory->user = AsmCreatePool( MEMF_PUBLIC, 2048, 2048, SysBase );
 #endif
       if ( memory->user == NULL )
       {
-        FreeVec ( memory );
+        FreeVec( memory );
         memory = NULL;
       }
       else
@@ -407,7 +421,7 @@
         memory->free    = ft_free;
 #ifdef FT_DEBUG_MEMORY
         ft_mem_debug_init( memory );
-#endif    
+#endif
       }
     }
 
@@ -422,7 +436,7 @@
   {
 #ifdef FT_DEBUG_MEMORY
     ft_mem_debug_done( memory );
-#endif  
+#endif
 
 #ifdef __GNUC__
     DeletePool( memory->user );
Index: xc/extras/freetype2/builds/beos/beos.mk
diff -u xc/extras/freetype2/builds/beos/beos.mk:1.1.1.1 xc/extras/freetype2/builds/beos/beos.mk:1.1.1.2
--- xc/extras/freetype2/builds/beos/beos.mk:1.1.1.1	Sun Sep  9 22:55:42 2001
+++ xc/extras/freetype2/builds/beos/beos.mk	Thu Jun 20 04:15:58 2002
@@ -2,7 +2,7 @@
 # FreeType 2 configuration rules for a BeOS system
 #
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -13,6 +13,7 @@
 
 include $(TOP)/builds/compiler/ansi-cc.mk
 include $(TOP)/builds/beos/beos-def.mk
+include $(TOP)/builds/link_std.mk
 
 # EOF
 
Index: xc/extras/freetype2/builds/unix/aclocal.m4
diff -u xc/extras/freetype2/builds/unix/aclocal.m4:1.1.1.2 xc/extras/freetype2/builds/unix/aclocal.m4:1.1.1.3
--- xc/extras/freetype2/builds/unix/aclocal.m4:1.1.1.2	Sun Sep  9 22:55:48 2001
+++ xc/extras/freetype2/builds/unix/aclocal.m4	Tue Mar 26 23:35:39 2002
@@ -51,6 +51,7 @@
 ## the same distribution terms that you use for the rest of that program.
 
 # serial 46 AC_PROG_LIBTOOL
+
 AC_DEFUN([AC_PROG_LIBTOOL],
 [AC_REQUIRE([AC_LIBTOOL_SETUP])dnl
 
@@ -176,9 +177,30 @@
 
 ])
 
+# AC_LIBTOOL_HEADER_ASSERT
+# ------------------------
+AC_DEFUN([AC_LIBTOOL_HEADER_ASSERT],
+[AC_CACHE_CHECK([whether $CC supports assert without backlinking],
+    [lt_cv_func_assert_works],
+    [case $host in
+    *-*-solaris*)
+      if test "$GCC" = yes && test "$with_gnu_ld" != yes; then
+        case `$CC --version 2>/dev/null` in
+        [[12]].*) lt_cv_func_assert_works=no ;;
+        *)        lt_cv_func_assert_works=yes ;;
+        esac
+      fi
+      ;;
+    esac])
+
+if test "x$lt_cv_func_assert_works" = xyes; then
+  AC_CHECK_HEADERS(assert.h)
+fi
+])# AC_LIBTOOL_HEADER_ASSERT
+
 # _LT_AC_CHECK_DLFCN
 # --------------------
-AC_DEFUN(_LT_AC_CHECK_DLFCN,
+AC_DEFUN([_LT_AC_CHECK_DLFCN],
 [AC_CHECK_HEADERS(dlfcn.h)
 ])# _LT_AC_CHECK_DLFCN
 
@@ -196,10 +218,10 @@
 # [They come from Ultrix.  What could be older than Ultrix?!! ;)]
 
 # Character class describing NM global symbol codes.
-[symcode='[BCDEGRST]']
+symcode='[[BCDEGRST]]'
 
 # Regexp to match symbols that can be accessed directly from C.
-[sympat='\([_A-Za-z][_A-Za-z0-9]*\)']
+sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
 
 # Transform the above into a raw symbol and a C symbol.
 symxfrm='\1 \2\3 \3'
@@ -207,25 +229,29 @@
 # Transform an extracted symbol line into a proper C declaration
 lt_cv_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern char \1;/p'"
 
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+
 # Define system-specific variables.
 case $host_os in
 aix*)
-  [symcode='[BCDT]']
+  symcode='[[BCDT]]'
   ;;
 cygwin* | mingw* | pw32*)
-  [symcode='[ABCDGISTW]']
+  symcode='[[ABCDGISTW]]'
   ;;
 hpux*) # Its linker distinguishes data from code symbols
   lt_cv_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern char \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+  lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
   ;;
 irix*)
-  [symcode='[BCDEGRST]']
+  symcode='[[BCDEGRST]]'
   ;;
 solaris* | sysv5*)
-  [symcode='[BDT]']
+  symcode='[[BDT]]'
   ;;
 sysv4)
-  [symcode='[DFNSTU]']
+  symcode='[[DFNSTU]]'
   ;;
 esac
 
@@ -239,14 +265,14 @@
 
 # If we're using GNU nm, then use its standard symbol codes.
 if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then
-  [symcode='[ABCDGISTW]']
+  symcode='[[ABCDGISTW]]'
 fi
 
 # Try without a prefix undercore, then with it.
 for ac_symprfx in "" "_"; do
 
   # Write the raw and C identifiers.
-[lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ 	]\($symcode$symcode*\)[ 	][ 	]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'"]
+lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ 	]]\($symcode$symcode*\)[[ 	]][[ 	]]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'"
 
   # Check to see that the pipe works correctly.
   pipe_works=no
@@ -288,23 +314,23 @@
 
 	  cat <<EOF >> conftest.$ac_ext
 #if defined (__STDC__) && __STDC__
-# define lt_ptr_t void *
+# define lt_ptr void *
 #else
-# define lt_ptr_t char *
+# define lt_ptr char *
 # define const
 #endif
 
 /* The mapping between symbol names and symbols. */
 const struct {
   const char *name;
-  lt_ptr_t address;
+  lt_ptr address;
 }
-[lt_preloaded_symbols[] =]
+lt_preloaded_symbols[[]] =
 {
 EOF
-	  sed "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" >> conftest.$ac_ext
+	  sed "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr) \&\2},/" < "$nlist" >> conftest.$ac_ext
 	  cat <<\EOF >> conftest.$ac_ext
-  {0, (lt_ptr_t) 0}
+  {0, (lt_ptr) 0}
 };
 
 #ifdef __cplusplus
@@ -348,10 +374,13 @@
 global_symbol_pipe="$lt_cv_sys_global_symbol_pipe"
 if test -z "$lt_cv_sys_global_symbol_pipe"; then
   global_symbol_to_cdecl=
+  global_symbol_to_c_name_address=
 else
   global_symbol_to_cdecl="$lt_cv_global_symbol_to_cdecl"
+  global_symbol_to_c_name_address="$lt_cv_global_symbol_to_c_name_address"
 fi
-if test -z "$global_symbol_pipe$global_symbol_to_cdecl"; then
+if test -z "$global_symbol_pipe$global_symbol_to_cdec$global_symbol_to_c_name_address";
+then
   AC_MSG_RESULT(failed)
 else
   AC_MSG_RESULT(ok)
@@ -369,16 +398,17 @@
     *-DOS) lt_cv_sys_path_separator=';' ;;
     *)     lt_cv_sys_path_separator=':' ;;
   esac
+  PATH_SEPARATOR=$lt_cv_sys_path_separator
 fi
 ])# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR
 
 # _LT_AC_PROG_ECHO_BACKSLASH
 # --------------------------
 # Add some code to the start of the generated configure script which
-# will find an echo command which doesn;t interpret backslashes.
+# will find an echo command which doesn't interpret backslashes.
 AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],
 [ifdef([AC_DIVERSION_NOTICE], [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
-                              [AC_DIVERT_PUSH(NOTICE)])
+			      [AC_DIVERT_PUSH(NOTICE)])
 _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR
 
 # Check that we are running under the correct shell.
@@ -444,7 +474,7 @@
   #
   # So, first we look for a working echo in the user's PATH.
 
-  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   for dir in $PATH /usr/ucb; do
     if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
        test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
@@ -533,7 +563,7 @@
 # _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
 #                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
 # ------------------------------------------------------------------
-AC_DEFUN(_LT_AC_TRY_DLOPEN_SELF,
+AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],
 [if test "$cross_compiling" = yes; then :
   [$4]
 else
@@ -620,7 +650,7 @@
 
 # AC_LIBTOOL_DLOPEN_SELF
 # -------------------
-AC_DEFUN(AC_LIBTOOL_DLOPEN_SELF,
+AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],
 [if test "x$enable_dlopen" != xyes; then
   enable_dlopen=unknown
   enable_dlopen_self=unknown
@@ -642,16 +672,22 @@
    ;;
 
   *)
-    AC_CHECK_LIB(dl, dlopen,  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
-      [AC_CHECK_FUNC(dlopen, lt_cv_dlopen="dlopen",
-        [AC_CHECK_FUNC(shl_load, lt_cv_dlopen="shl_load",
-          [AC_CHECK_LIB(svld, dlopen,
-	    [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
-            [AC_CHECK_LIB(dld, shl_load,
-              [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])
+    AC_CHECK_FUNC([shl_load],
+          [lt_cv_dlopen="shl_load"],
+      [AC_CHECK_LIB([dld], [shl_load],
+            [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],
+	[AC_CHECK_FUNC([dlopen],
+	      [lt_cv_dlopen="dlopen"],
+	  [AC_CHECK_LIB([dl], [dlopen],
+	        [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
+	    [AC_CHECK_LIB([svld], [dlopen],
+	          [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
+	      [AC_CHECK_LIB([dld], [dld_link],
+	            [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])
+	      ])
 	    ])
-          ])
-        ])
+	  ])
+	])
       ])
     ;;
   esac
@@ -714,10 +750,10 @@
 # Sed substitution that helps us do robust quoting.  It backslashifies
 # metacharacters that are still active within double-quoted strings.
 Xsed='sed -e s/^X//'
-[sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']
+sed_quote_subst='s/\([[\\"\\`$\\\\]]\)/\\\1/g'
 
 # Same as above, but do not quote variable references.
-[double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']
+double_quote_subst='s/\([[\\"\\`\\\\]]\)/\\\1/g'
 
 # Sed substitution to delay expansion of an escaped shell variable in a
 # double_quote_subst'ed string.
@@ -786,8 +822,15 @@
 old_postuninstall_cmds=
 
 if test -n "$RANLIB"; then
+  case $host_os in
+  openbsd*)
+    old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds"
+    ;;
+  *)
+    old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
+    ;;
+  esac
   old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
-  old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
 fi
 
 # Allow CC to be a program name with arguments.
@@ -813,7 +856,7 @@
 
 ## FIXME: this should be a separate macro
 ##
-AC_ARG_WITH(pic, 
+AC_ARG_WITH(pic,
 [  --with-pic              try to use only PIC/non-PIC objects [default=use both]],
 pic_mode="$withval", pic_mode=default)
 test -z "$pic_mode" && pic_mode=default
@@ -841,7 +884,7 @@
       # libC (AIX C++ library), which obviously doesn't included in libraries
       # list by gcc. This cause undefined symbols with -static flags.
       # This hack allows C programs to be linked with "-static -ldl", but
-      # we not sure about C++ programs.
+      # not sure about C++ programs.
       lt_cv_prog_cc_static="$lt_cv_prog_cc_static ${lt_cv_prog_cc_wl}-lC"
       ;;
     amigaos*)
@@ -876,13 +919,13 @@
     # PORTME Check for PIC flags for the system compiler.
     case $host_os in
     aix3* | aix4* | aix5*)
+      lt_cv_prog_cc_wl='-Wl,'
       # All AIX code is PIC.
       if test "$host_cpu" = ia64; then
-        # AIX 5 now supports IA64 processor
-        lt_cv_prog_cc_static='-Bstatic'
-        lt_cv_prog_cc_wl='-Wl,'
+	# AIX 5 now supports IA64 processor
+	lt_cv_prog_cc_static='-Bstatic'
       else
-        lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp'
+	lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp'
       fi
       ;;
 
@@ -938,9 +981,9 @@
       lt_cv_prog_cc_pic='-KPIC'
       lt_cv_prog_cc_static='-Bstatic'
       if test "x$host_vendor" = xsni; then
-        lt_cv_prog_cc_wl='-LD'
+	lt_cv_prog_cc_wl='-LD'
       else
-        lt_cv_prog_cc_wl='-Wl,'
+	lt_cv_prog_cc_wl='-Wl,'
       fi
       ;;
 
@@ -1009,7 +1052,7 @@
 # Check for any special shared library compilation flags.
 if test -n "$lt_cv_prog_cc_shlib"; then
   AC_MSG_WARN([\`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries])
-  if echo "$old_CC $old_CFLAGS " | [egrep -e "[ 	]$lt_cv_prog_cc_shlib[ 	]"] >/dev/null; then :
+  if echo "$old_CC $old_CFLAGS " | egrep -e "[[ 	]]$lt_cv_prog_cc_shlib[[ 	]]" >/dev/null; then :
   else
    AC_MSG_WARN([add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure])
     lt_cv_prog_cc_can_build_shared=no
@@ -1091,6 +1134,8 @@
   lt_cv_compiler_o_lo=no
   save_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS -c -o conftest.lo"
+  save_objext="$ac_objext"
+  ac_objext=lo
   AC_TRY_COMPILE([], [int some_variable = 0;], [dnl
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
@@ -1100,10 +1145,11 @@
       lt_cv_compiler_o_lo=yes
     fi
   ])
+  ac_objext="$save_objext"
   CFLAGS="$save_CFLAGS"
   ])
   compiler_o_lo=$lt_cv_compiler_o_lo
-  AC_MSG_RESULT([$compiler_c_lo])
+  AC_MSG_RESULT([$compiler_o_lo])
 else
   compiler_o_lo=no
 fi
@@ -1208,7 +1254,7 @@
 extract_expsyms_cmds=
 
 case $host_os in
-cygwin* | mingw* | pw32* )
+cygwin* | mingw* | pw32*)
   # FIXME: the MSVC++ port hasn't been tested in a loooong time
   # When not using gcc, we currently assume that we are using
   # Microsoft Visual C++.
@@ -1216,7 +1262,9 @@
     with_gnu_ld=no
   fi
   ;;
-
+openbsd*)
+  with_gnu_ld=no
+  ;;
 esac
 
 ld_shlibs=yes
@@ -1303,7 +1351,7 @@
     # can override, but on older systems we have to supply one (in ltdll.c)
     if test "x$lt_cv_need_dllmain" = "xyes"; then
       ltdll_obj='$output_objdir/$soname-ltdll.'"$ac_objext "
-      ltdll_cmds='test -f $output_objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < [$]0 > $output_objdir/$soname-ltdll.c~
+      ltdll_cmds='test -f $output_objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < $''0 > $output_objdir/$soname-ltdll.c~
 	test -f $output_objdir/$soname-ltdll.$ac_objext || (cd $output_objdir && $CC -c $soname-ltdll.c)~'
     else
       ltdll_obj=
@@ -1316,24 +1364,24 @@
     # Be careful not to strip the DATA tag left be newer dlltools.
     export_symbols_cmds="$ltdll_cmds"'
       $DLLTOOL --export-all --exclude-symbols '$dll_exclude_symbols' --output-def $output_objdir/$soname-def '$ltdll_obj'$libobjs $convenience~
-      [sed -e "1,/EXPORTS/d" -e "s/ @ [0-9]*//" -e "s/ *;.*$//"] < $output_objdir/$soname-def > $export_symbols'
+      sed -e "1,/EXPORTS/d" -e "s/ @ [[0-9]]*//" -e "s/ *;.*$//" < $output_objdir/$soname-def > $export_symbols'
 
     # If the export-symbols file already is a .def file (1st line
     # is EXPORTS), use it as is.
     # If DATA tags from a recent dlltool are present, honour them!
     archive_expsym_cmds='if test "x`head -1 $export_symbols`" = xEXPORTS; then
-        cp $export_symbols $output_objdir/$soname-def;
+	cp $export_symbols $output_objdir/$soname-def;
       else
-        echo EXPORTS > $output_objdir/$soname-def;
-        _lt_hint=1;
-        cat $export_symbols | while read symbol; do
-         set dummy \$symbol;
-         case \[$]# in
-           2) echo "   \[$]2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;;
-           *) echo "     \[$]2 @ \$_lt_hint \[$]3 ; " >> $output_objdir/$soname-def;;
-         esac;
-         _lt_hint=`expr 1 + \$_lt_hint`;
-        done;
+	echo EXPORTS > $output_objdir/$soname-def;
+	_lt_hint=1;
+	cat $export_symbols | while read symbol; do
+	 set dummy \$symbol;
+	 case \[$]# in
+	   2) echo "   \[$]2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;;
+	   *) echo "     \[$]2 @ \$_lt_hint \[$]3 ; " >> $output_objdir/$soname-def;;
+	 esac;
+	 _lt_hint=`expr 1 + \$_lt_hint`;
+	done;
       fi~
       '"$ltdll_cmds"'
       $CC -Wl,--base-file,$output_objdir/$soname-base '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~
@@ -1428,80 +1476,96 @@
     ;;
 
   aix4* | aix5*)
+    if test "$host_cpu" = ia64; then
+      # On IA64, the linker does run time linking by default, so we don't
+      # have to do anything special.
+      aix_use_runtimelinking=no
+      exp_sym_flag='-Bexport'
+      no_entry_flag=""
+    else
+      aix_use_runtimelinking=no
+
+      # Test if we are trying to use run time linking or normal
+      # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+      # need to do runtime linking.
+      case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
+	for ld_flag in $LDFLAGS; do
+	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+	    aix_use_runtimelinking=yes
+	    break
+	  fi
+	done
+      esac
+
+      exp_sym_flag='-bexport'
+      no_entry_flag='-bnoentry'
+    fi
+
     # When large executables or shared objects are built, AIX ld can
     # have problems creating the table of contents.  If linking a library
     # or program results in "error TOC overflow" add -mminimal-toc to
     # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
     # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
 
+    hardcode_direct=yes
     archive_cmds=''
     hardcode_libdir_separator=':'
     if test "$GCC" = yes; then
-      collect2name=`${CC} -print-prog-name=collect2`
-      if test -f "$collect2name" && \
-	 strings "$collect2name" | grep resolve_lib_name >/dev/null
-      then
-	# We have reworked collect2
-	hardcode_direct=yes
-      else
-        # We have old collect2
-        hardcode_direct=unsupported
-        # It fails to find uninstalled libraries when the uninstalled
-        # path is not listed in the libpath.  Setting hardcode_minus_L
-        # to unsupported forces relinking
-        hardcode_minus_L=yes
-        hardcode_libdir_flag_spec='-L$libdir'
-        hardcode_libdir_separator=
-      fi
+      case $host_os in aix4.[[012]]|aix4.[[012]].*)
+	collect2name=`${CC} -print-prog-name=collect2`
+	if test -f "$collect2name" && \
+	  strings "$collect2name" | grep resolve_lib_name >/dev/null
+	then
+	  # We have reworked collect2
+	  hardcode_direct=yes
+	else
+	  # We have old collect2
+	  hardcode_direct=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  hardcode_minus_L=yes
+	  hardcode_libdir_flag_spec='-L$libdir'
+	  hardcode_libdir_separator=
+	fi
+      esac
+
       shared_flag='-shared'
     else
+      # not using gcc
       if test "$host_cpu" = ia64; then
-        shared_flag='-G'
+	shared_flag='${wl}-G'
       else
-        shared_flag='${wl}-bM:SRE'
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag='${wl}-G'
+	else
+	  shared_flag='${wl}-bM:SRE'
+	fi
       fi
-      hardcode_direct=yes
     fi
 
-    if test "$host_cpu" = ia64; then
-      # On IA64, the linker does run time linking by default, so we don't
-      # have to do anything special.
-      aix_use_runtimelinking=no
-      exp_sym_flag='-Bexport'
-      no_entry_flag=""
-    else
-      # Test if we are trying to use run time linking, or normal AIX style linking.
-      # If -brtl is somewhere in LDFLAGS, we need to do run time linking.
-      aix_use_runtimelinking=no
-      for ld_flag in $LDFLAGS; do
-        if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl" ); then
-          aix_use_runtimelinking=yes
-          break
-        fi
-      done
-      exp_sym_flag='-bexport'
-      no_entry_flag='-bnoentry'
-    fi
     # It seems that -bexpall can do strange things, so it is better to
     # generate a list of symbols to export.
     always_export_symbols=yes
     if test "$aix_use_runtimelinking" = yes; then
+      # Warning - without using the other runtime loading flags (-brtl),
+      # -berok will link without error, but may produce a broken library.
+      allow_undefined_flag='-berok'
       hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:/usr/lib:/lib'
-      allow_undefined_flag=' -Wl,-G'
-      archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
+      archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
     else
       if test "$host_cpu" = ia64; then
-        hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
-       allow_undefined_flag="-znodefs"
-        archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname ${wl}-h$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
+	hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+	allow_undefined_flag="-z nodefs"
+	archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname ${wl}-h$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
       else
-        hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib'
-        # Warning - without using the other run time loading flags, -berok will
-        #           link without error, but may produce a broken library.
-        allow_undefined_flag='${wl}-berok"
-        # This is a bit strange, but is similar to how AIX traditionally builds
-        # it's shared libraries.
-        archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"' ~$AR -crlo $objdir/$libname$release.a $objdir/$soname'
+	hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib'
+	# Warning - without using the other run time loading flags,
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag='${wl}-berok'
+	# This is a bit strange, but is similar to how AIX traditionally builds
+	# it's shared libraries.
+	archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"' ~$AR -crlo $output_objdir/$libname$release.a $output_objdir/$soname'
       fi
     fi
     ;;
@@ -1533,11 +1597,18 @@
     ;;
 
   darwin* | rhapsody*)
-    allow_undefined_flag='-undefined suppress'
+    case "$host_os" in
+    rhapsody* | darwin1.[[012]])
+      allow_undefined_flag='-undefined suppress'
+      ;;
+    *) # Darwin 1.3 on
+      allow_undefined_flag='-flat_namespace -undefined suppress'
+      ;;
+    esac
     # FIXME: Relying on posixy $() will cause problems for
     #        cross-compilation, but unfortunately the echo tests do not
     #        yet detect zsh echo's removal of \ escapes.
-    archive_cmds='$CC $(test .$module = .yes && echo -bundle || echo -dynamiclib) $allow_undefined_flag -o $lib $libobjs $deplibs$linkopts -install_name $rpath/$soname $(test -n "$verstring" -a x$verstring != x0.0 && echo $verstring)'
+    archive_cmds='$nonopt $(test "x$module" = xyes && echo -bundle || echo -dynamiclib) $allow_undefined_flag -o $lib $libobjs $deplibs$linker_flags -install_name $rpath/$soname $verstring'
     # We need to add '_' to the symbols in $export_symbols first
     #archive_expsym_cmds="$archive_cmds"' && strip -s $export_symbols'
     hardcode_direct=yes
@@ -1612,7 +1683,7 @@
     ;;
 
   newsos6)
-    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
     hardcode_direct=yes
     hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
     hardcode_libdir_separator=:
@@ -1620,10 +1691,24 @@
     ;;
 
   openbsd*)
-    archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-    hardcode_libdir_flag_spec='-R$libdir'
     hardcode_direct=yes
     hardcode_shlibpath_var=no
+    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+      archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+      export_dynamic_flag_spec='${wl}-E'
+    else
+      case "$host_os" in
+      openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_libdir_flag_spec='-R$libdir'
+        ;;
+      *)
+        archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $linker_flags'
+        hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+        ;;
+      esac
+    fi
     ;;
 
   os2*)
@@ -1668,10 +1753,39 @@
     hardcode_shlibpath_var=no
     runpath_var=LD_RUN_PATH
     hardcode_runpath_var=yes
+    export_dynamic_flag_spec='${wl}-Bexport'
     ;;
 
   solaris*)
+    # gcc --version < 3.0 without binutils cannot create self contained
+    # shared libraries reliably, requiring libgcc.a to resolve some of
+    # the object symbols generated in some cases.  Libraries that use
+    # assert need libgcc.a to resolve __eprintf, for example.  Linking
+    # a copy of libgcc.a into every shared library to guarantee resolving
+    # such symbols causes other problems:  According to Tim Van Holder
+    # <tim.van.holder@pandora.be>, C++ libraries end up with a separate
+    # (to the application) exception stack for one thing.
     no_undefined_flag=' -z defs'
+    if test "$GCC" = yes; then
+      case `$CC --version 2>/dev/null` in
+      [[12]].*)
+	cat <<EOF 1>&2
+
+*** Warning: Releases of GCC earlier than version 3.0 cannot reliably
+*** create self contained shared libraries on Solaris systems, without
+*** introducing a dependency on libgcc.a.  Therefore, libtool is disabling
+*** -no-undefined support, which will at least allow you to build shared
+*** libraries.  However, you may find that when you link such libraries
+*** into an application without using GCC, you have to manually add
+*** \`gcc --print-libgcc-file-name\` to the link command.  We urge you to
+*** upgrade to a newer version of GCC.  Another option is to rebuild your
+*** current GCC to use the GNU linker from GNU binutils 2.9.1 or newer.
+
+EOF
+        no_undefined_flag=
+	;;
+      esac
+    fi
     # $CC -shared without GNU ld will not create a library from C++
     # object files and a static libstdc++, better avoid it by now
     archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
@@ -1680,7 +1794,7 @@
     hardcode_libdir_flag_spec='-R$libdir'
     hardcode_shlibpath_var=no
     case $host_os in
-    [solaris2.[0-5] | solaris2.[0-5].*]) ;;
+    solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
     *) # Supported since Solaris 2.6 (maybe 2.5.1?)
       whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;;
     esac
@@ -1703,7 +1817,7 @@
 
   sysv4)
     if test "x$host_vendor" = xsno; then
-      archive_cmds='$LD -G -Bsymbolic -h $soname -o $lib $libobjs $deplibs $linkopts'
+      archive_cmds='$LD -G -Bsymbolic -h $soname -o $lib $libobjs $deplibs $linker_flags'
       hardcode_direct=yes # is this really true???
     else
       archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
@@ -1872,22 +1986,24 @@
     # depend on `.', always an invalid library.  This was fixed in
     # development snapshots of GCC prior to 3.0.
     case $host_os in
-      [ aix4 | aix4.[01] | aix4.[01].*)]
-      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
-           echo ' yes '
-           echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
-        :
-      else
-        can_build_shared=no
-      fi
-      ;;
+      aix4 | aix4.[[01]] | aix4.[[01]].*)
+	if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	     echo ' yes '
+	     echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
+	  :
+	else
+	  can_build_shared=no
+	fi
+	;;
     esac
-    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
-    # soname into executable. Probably we can add versioning support to
-    # collect2, so additional links can be useful in future.
+    # AIX (on Power*) has no versioning support, so currently we can
+    # not hardcode correct soname into executable. Probably we can
+    # add versioning support to collect2, so additional links can
+    # be useful in future.
     if test "$aix_use_runtimelinking" = yes; then
-      # If using run time linking (on AIX 4.2 or later) use lib<name>.so instead of
-      # lib<name>.a to let people know that these are not typical AIX shared libraries.
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
       library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
     else
       # We preserve .a as extension for shared libraries through AIX4.2
@@ -1896,14 +2012,13 @@
       soname_spec='${libname}${release}.so$major'
     fi
     shlibpath_var=LIBPATH
-    deplibs_check_method=pass_all
   fi
   ;;
 
 amigaos*)
   library_names_spec='$libname.ixlibrary $libname.a'
   # Create ${libname}_ixlibrary.a entries in /sys/libs.
-  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | [$Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\'']`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "(cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a)"; (cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a) || exit 1; done'
+  finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "(cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a)"; (cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a) || exit 1; done'
   ;;
 
 beos*)
@@ -1934,7 +2049,7 @@
   case $GCC,$host_os in
   yes,cygwin*)
     library_names_spec='$libname.dll.a'
-    soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | [sed -e 's/[.]/-/g']`${versuffix}.dll'
+    soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll'
     postinstall_cmds='dlpath=`bash 2>&1 -c '\''. $dir/${file}i;echo \$dlname'\''`~
       dldir=$destdir/`dirname \$dlpath`~
       test -d \$dldir || mkdir -p \$dldir~
@@ -1944,14 +2059,14 @@
        $rm \$dlpath'
     ;;
   yes,mingw*)
-    library_names_spec='${libname}`echo ${release} | [sed -e 's/[.]/-/g']`${versuffix}.dll'
+    library_names_spec='${libname}`echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll'
     sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | sed -e "s/^libraries://" -e "s/;/ /g"`
     ;;
   yes,pw32*)
     library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll'
     ;;
   *)
-    library_names_spec='${libname}`echo ${release} | [sed -e 's/[.]/-/g']`${versuffix}.dll $libname.lib'
+    library_names_spec='${libname}`echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll $libname.lib'
     ;;
   esac
   dynamic_linker='Win32 ld.exe'
@@ -2109,9 +2224,19 @@
 
 openbsd*)
   version_type=sunos
-  if test "$with_gnu_ld" = yes; then
-    need_lib_prefix=no
-    need_version=no
+  need_lib_prefix=no
+  need_version=no
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case "$host_os" in
+    openbsd2.[[89]] | openbsd2.[[89]].*)
+      shlibpath_overrides_runpath=no
+      ;;
+    *)
+      shlibpath_overrides_runpath=yes
+      ;;
+    esac
+  else
+    shlibpath_overrides_runpath=yes
   fi
   library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
@@ -2228,6 +2353,41 @@
 ##
 ## END FIXME
 
+## FIXME: this should be a separate macro
+##
+AC_MSG_CHECKING([whether to build shared libraries])
+test "$can_build_shared" = "no" && enable_shared=no
+
+# On AIX, shared libraries and static libraries use the same namespace, and
+# are all built from PIC.
+case "$host_os" in
+aix3*)
+  test "$enable_shared" = yes && enable_static=no
+  if test -n "$RANLIB"; then
+    archive_cmds="$archive_cmds~\$RANLIB \$lib"
+    postinstall_cmds='$RANLIB $lib'
+  fi
+  ;;
+
+aix4*)
+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+    test "$enable_shared" = yes && enable_static=no
+  fi
+  ;;
+esac
+AC_MSG_RESULT([$enable_shared])
+##
+## END FIXME
+
+## FIXME: this should be a separate macro
+##
+AC_MSG_CHECKING([whether to build static libraries])
+# Make sure either enable_shared or enable_static is yes.
+test "$enable_shared" = yes || enable_static=yes
+AC_MSG_RESULT([$enable_static])
+##
+## END FIXME
+
 if test "$hardcode_action" = relink; then
   # Fast installation is not supported
   enable_fast_install=no
@@ -2327,6 +2487,7 @@
     old_striplib striplib file_magic_cmd export_symbols_cmds \
     deplibs_check_method allow_undefined_flag no_undefined_flag \
     finish_cmds finish_eval global_symbol_pipe global_symbol_to_cdecl \
+    global_symbol_to_c_name_address \
     hardcode_libdir_flag_spec hardcode_libdir_separator  \
     sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
     compiler_c_o compiler_o_lo need_locks exclude_expsyms include_expsyms; do
@@ -2393,12 +2554,12 @@
 # Whether or not to build shared libraries.
 build_libtool_libs=$enable_shared
 
-# Whether or not to add -lc for building shared libraries.
-build_libtool_need_lc=$need_lc
-
 # Whether or not to build static libraries.
 build_old_libs=$enable_static
 
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$need_lc
+
 # Whether or not to optimize for fast installation.
 fast_install=$enable_fast_install
 
@@ -2564,6 +2725,9 @@
 # Transform the output of nm in a proper C declaration
 global_symbol_to_cdecl=$lt_global_symbol_to_cdecl
 
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_global_symbol_to_c_name_address
+
 # This is the shared library runtime path variable.
 runpath_var=$runpath_var
 
@@ -2686,9 +2850,9 @@
 #   return TRUE;
 # }
 # /* ltdll.c ends here */
-        # This is a source program that is used to create import libraries
-        # on Windows for dlls which lack them. Don't remove nor modify the
-        # starting and closing comments
+	# This is a source program that is used to create import libraries
+	# on Windows for dlls which lack them. Don't remove nor modify the
+	# starting and closing comments
 # /* impgen.c starts here */
 # /*   Copyright (C) 1999-2000 Free Software Foundation, Inc.
 #
@@ -3045,6 +3209,7 @@
 AC_REQUIRE([AC_PROG_CC])dnl
 AC_REQUIRE([AC_CANONICAL_HOST])dnl
 AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+AC_REQUIRE([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR])dnl
 ac_prog=ld
 if test "$GCC" = yes; then
   # Check if gcc -print-prog-name=ld gives a path.
@@ -3058,8 +3223,8 @@
   esac
   case $ac_prog in
     # Accept absolute paths.
-    [[\\/]* | [A-Za-z]:[\\/]*)]
-      [re_direlt='/[^/][^/]*/\.\./']
+    [[\\/]]* | [[A-Za-z]]:[[\\/]]*)
+      re_direlt='/[[^/]][[^/]]*/\.\./'
       # Canonicalize the path of ld
       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
@@ -3083,7 +3248,7 @@
 fi
 AC_CACHE_VAL(lt_cv_path_LD,
 [if test -z "$LD"; then
-  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH; do
     test -z "$ac_dir" && ac_dir=.
     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
@@ -3147,7 +3312,7 @@
 # `unknown' -- same as none, but documents that we really don't know.
 # 'pass_all' -- all dependencies passed with no checks.
 # 'test_compile' -- check by making test program.
-# ['file_magic [regex]'] -- check by looking for files in library path
+# 'file_magic [[regex]]' -- check by looking for files in library path
 # which responds to the $file_magic_cmd with a given egrep regex.
 # If you have `file' or equivalent on your system and you're not sure
 # whether `pass_all' will *always* work, you probably want this one.
@@ -3162,7 +3327,7 @@
   ;;
 
 bsdi4*)
-  [lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)']
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
   lt_cv_file_magic_cmd='/usr/bin/file -L'
   lt_cv_file_magic_test_file=/shlib/libc.so
   ;;
@@ -3176,7 +3341,7 @@
   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
   lt_cv_file_magic_cmd='/usr/bin/file -L'
   case "$host_os" in
-  rhapsody* | darwin1.[012])
+  rhapsody* | darwin1.[[012]])
     lt_cv_file_magic_test_file=`echo /System/Library/Frameworks/System.framework/Versions/*/System | head -1`
     ;;
   *) # Darwin 1.3 on
@@ -3191,7 +3356,7 @@
     i*86 )
       # Not sure whether the presence of OpenBSD here was a mistake.
       # Let's accept both of them until this is cleared up.
-      [lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library']
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[[3-9]]86 (compact )?demand paged shared library'
       lt_cv_file_magic_cmd=/usr/bin/file
       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
       ;;
@@ -3206,7 +3371,7 @@
   ;;
 
 hpux10.20*|hpux11*)
-  [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library']
+  lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'
   lt_cv_file_magic_cmd=/usr/bin/file
   lt_cv_file_magic_test_file=/usr/lib/libc.sl
   ;;
@@ -3225,7 +3390,7 @@
     *) libmagic=never-match;;
     esac
     # this will be overridden with pass_all, but let us keep it just in case
-    [lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"]
+    lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[[1234]] dynamic lib MIPS - version 1"
     ;;
   esac
   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
@@ -3235,29 +3400,39 @@
 # This must be Linux ELF.
 linux-gnu*)
   case $host_cpu in
-  alpha* | i*86 | powerpc* | sparc* | ia64* )
+  alpha* | hppa* | i*86 | powerpc* | sparc* | ia64* )
     lt_cv_deplibs_check_method=pass_all ;;
   *)
     # glibc up to 2.1.1 does not perform some relocations on ARM
-    [lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;;]
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;;
   esac
   lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
   ;;
 
 netbsd*)
   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
-    [lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$']
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/\.]]+\.so\.[[0-9]]+\.[[0-9]]+$'
   else
-    [lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$']
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/\.]]+\.so$'
   fi
   ;;
 
 newos6*)
-  [lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)']
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
   lt_cv_file_magic_cmd=/usr/bin/file
   lt_cv_file_magic_test_file=/usr/lib/libnls.so
   ;;
 
+openbsd*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object'
+  else
+    lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library'
+  fi
+  ;;
+
 osf3* | osf4* | osf5*)
   # this will be overridden with pass_all, but let us keep it just in case
   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
@@ -3274,14 +3449,14 @@
   lt_cv_file_magic_test_file=/lib/libc.so
   ;;
 
-[sysv5uw[78]* | sysv4*uw2*)]
+sysv5uw[[78]]* | sysv4*uw2*)
   lt_cv_deplibs_check_method=pass_all
   ;;
 
 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
   case $host_vendor in
   motorola)
-    [lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]']
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
     ;;
   ncr)
@@ -3289,11 +3464,11 @@
     ;;
   sequent)
     lt_cv_file_magic_cmd='/bin/file'
-    [lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )']
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
     ;;
   sni)
     lt_cv_file_magic_cmd='/bin/file'
-    [lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"]
+    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
     lt_cv_file_magic_test_file=/lib/libc.so
     ;;
   esac
@@ -3307,13 +3482,14 @@
 
 # AC_PROG_NM - find the path to a BSD-compatible name lister
 AC_DEFUN([AC_PROG_NM],
-[AC_MSG_CHECKING([for BSD-compatible nm])
+[AC_REQUIRE([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR])dnl
+AC_MSG_CHECKING([for BSD-compatible nm])
 AC_CACHE_VAL(lt_cv_path_NM,
 [if test -n "$NM"; then
   # Let the user override the test.
   lt_cv_path_NM="$NM"
 else
-  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
     test -z "$ac_dir" && ac_dir=.
     tmp_nm=$ac_dir/${ac_tool_prefix}nm
Index: xc/extras/freetype2/builds/unix/config.guess
diff -u xc/extras/freetype2/builds/unix/config.guess:1.1.1.3 xc/extras/freetype2/builds/unix/config.guess:1.1.1.4
--- xc/extras/freetype2/builds/unix/config.guess:1.1.1.3	Sun Sep  9 22:55:49 2001
+++ xc/extras/freetype2/builds/unix/config.guess	Tue Mar 26 23:35:39 2002
@@ -1,9 +1,9 @@
 #! /bin/sh
 # Attempt to guess a canonical system name.
-#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
-#   Free Software Foundation, Inc.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002 Free Software Foundation, Inc.
 
-timestamp='2001-04-20'
+timestamp='2002-03-04'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
@@ -24,8 +24,9 @@
 # configuration script generated by Autoconf, you may include it under
 # the same distribution terms that you use for the rest of that program.
 
-# Written by Per Bothner <bothner@cygnus.com>.
-# Please send patches to <config-patches@gnu.org>.
+# Originally written by Per Bothner <per@bothner.com>.
+# Please send patches to <config-patches@gnu.org>.  Submit a context
+# diff and a properly formatted ChangeLog entry.
 #
 # This script attempts to guess a canonical system name similar to
 # config.sub.  If it succeeds, it prints the system name on stdout, and
@@ -52,7 +53,7 @@
 GNU config.guess ($timestamp)
 
 Originally written by Per Bothner.
-Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 99, 2000
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
@@ -95,25 +96,25 @@
 # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
 # use `HOST_CC' if defined, but it is deprecated.
 
-case $CC_FOR_BUILD,$HOST_CC,$CC in
- ,,)    echo "int dummy(){}" > $dummy.c
+set_cc_for_build='case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int dummy(){}" > $dummy.c ;
 	for c in cc gcc c89 ; do
-	  ($c $dummy.c -c -o $dummy.o) >/dev/null 2>&1
+	  ($c $dummy.c -c -o $dummy.o) >/dev/null 2>&1 ;
 	  if test $? = 0 ; then
-	     CC_FOR_BUILD="$c"; break
-	  fi
-	done
-	rm -f $dummy.c $dummy.o $dummy.rel
+	     CC_FOR_BUILD="$c"; break ;
+	  fi ;
+	done ;
+	rm -f $dummy.c $dummy.o $dummy.rel ;
 	if test x"$CC_FOR_BUILD" = x ; then
-	  CC_FOR_BUILD=no_compiler_found
+	  CC_FOR_BUILD=no_compiler_found ;
 	fi
 	;;
  ,,*)   CC_FOR_BUILD=$CC ;;
  ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
-esac
+esac'
 
 # This is needed to find uname on a Pyramid OSx when run in the BSD universe.
-# (ghazi@noc.rutgers.edu 8/24/94.)
+# (ghazi@noc.rutgers.edu 1994-08-24)
 if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
 	PATH=$PATH:/.attbin ; export PATH
 fi
@@ -127,29 +128,30 @@
 
 case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
     *:NetBSD:*:*)
-	# Netbsd (nbsd) targets should (where applicable) match one or
+	# NetBSD (nbsd) targets should (where applicable) match one or
 	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
 	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
 	# switched to ELF, *-*-netbsd* would select the old
 	# object file format.  This provides both forward
 	# compatibility and a consistent mechanism for selecting the
 	# object file format.
-	# Determine the machine/vendor (is the vendor relevant).
-	case "${UNAME_MACHINE}" in
-	    amiga) machine=m68k-unknown ;;
-	    arm32) machine=arm-unknown ;;
-	    atari*) machine=m68k-atari ;;
-	    sun3*) machine=m68k-sun ;;
-	    mac68k) machine=m68k-apple ;;
-	    macppc) machine=powerpc-apple ;;
-	    hp3[0-9][05]) machine=m68k-hp ;;
-	    ibmrt|romp-ibm) machine=romp-ibm ;;
-	    *) machine=${UNAME_MACHINE}-unknown ;;
+	#
+	# Note: NetBSD doesn't particularly care about the vendor
+	# portion of the name.  We always set it to "unknown".
+	sysctl="sysctl -n hw.machine_arch"
+	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
+	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
+	case "${UNAME_MACHINE_ARCH}" in
+	    arm*) machine=arm-unknown ;;
+	    sh3el) machine=shl-unknown ;;
+	    sh3eb) machine=sh-unknown ;;
+	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
 	esac
 	# The Operating System including object format, if it has switched
 	# to ELF recently, or will in the future.
-	case "${UNAME_MACHINE}" in
-	    i386|sparc|amiga|arm*|hp300|mvme68k|vax|atari|luna68k|mac68k|news68k|next68k|pc532|sun3*|x68k)
+	case "${UNAME_MACHINE_ARCH}" in
+	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+		eval $set_cc_for_build
 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
 			| grep __ELF__ >/dev/null
 		then
@@ -171,6 +173,45 @@
 	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
 	echo "${machine}-${os}${release}"
 	exit 0 ;;
+    amiga:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    arc:OpenBSD:*:*)
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    hp300:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mac68k:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    macppc:OpenBSD:*:*)
+	echo powerpc-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mvme68k:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mvme88k:OpenBSD:*:*)
+	echo m88k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    mvmeppc:OpenBSD:*:*)
+	echo powerpc-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    pmax:OpenBSD:*:*)
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    sgi:OpenBSD:*:*)
+	echo mipseb-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    sun3:OpenBSD:*:*)
+	echo m68k-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    wgrisc:OpenBSD:*:*)
+	echo mipsel-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
+    *:OpenBSD:*:*)
+	echo ${UNAME_MACHINE}-unknown-openbsd${UNAME_RELEASE}
+	exit 0 ;;
     alpha:OSF1:*:*)
 	if test $UNAME_RELEASE = "V4.0"; then
 		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
@@ -204,6 +245,7 @@
 	jsr \$26,exit
 	.end main
 EOF
+	eval $set_cc_for_build
 	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
 	if test "$?" = 0 ; then
 		case `./$dummy` in
@@ -225,6 +267,9 @@
 			2-307)
 				UNAME_MACHINE="alphaev67"
 				;;
+			2-1307)
+				UNAME_MACHINE="alphaev68"
+				;;
 		esac
 	fi
 	rm -f $dummy.s $dummy
@@ -242,30 +287,12 @@
     Amiga*:UNIX_System_V:4.0:*)
 	echo m68k-unknown-sysv4
 	exit 0;;
-    amiga:OpenBSD:*:*)
-	echo m68k-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
     *:[Aa]miga[Oo][Ss]:*:*)
 	echo ${UNAME_MACHINE}-unknown-amigaos
-	exit 0 ;;
-    arc64:OpenBSD:*:*)
-	echo mips64el-unknown-openbsd${UNAME_RELEASE}
 	exit 0 ;;
-    arc:OpenBSD:*:*)
-	echo mipsel-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
-    hkmips:OpenBSD:*:*)
-	echo mips-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
-    pmax:OpenBSD:*:*)
-	echo mipsel-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
-    sgi:OpenBSD:*:*)
-	echo mips-unknown-openbsd${UNAME_RELEASE}
+    *:[Mm]orph[Oo][Ss]:*:*)
+	echo ${UNAME_MACHINE}-unknown-morphos
 	exit 0 ;;
-    wgrisc:OpenBSD:*:*)
-	echo mipsel-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
     *:OS/390:*:*)
 	echo i370-ibm-openedition
 	exit 0 ;;
@@ -314,7 +341,7 @@
 	echo m68k-sun-sunos${UNAME_RELEASE}
 	exit 0 ;;
     sun*:*:4.2BSD:*)
-	UNAME_RELEASE=`(head -1 /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
 	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
 	case "`/bin/arch`" in
 	    sun3)
@@ -328,9 +355,6 @@
     aushp:SunOS:*:*)
 	echo sparc-auspex-sunos${UNAME_RELEASE}
 	exit 0 ;;
-    atari*:OpenBSD:*:*)
-	echo m68k-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
     # The situation for MiNT is a little confusing.  The machine name
     # can be virtually everything (everything which is not
     # "atarist" or "atariste" at least should have a processor
@@ -357,18 +381,6 @@
     *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
         echo m68k-unknown-mint${UNAME_RELEASE}
         exit 0 ;;
-    sun3*:OpenBSD:*:*)
-	echo m68k-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
-    mac68k:OpenBSD:*:*)
-	echo m68k-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
-    mvme68k:OpenBSD:*:*)
-	echo m68k-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
-    mvme88k:OpenBSD:*:*)
-	echo m88k-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
     powerpc:machten:*:*)
 	echo powerpc-apple-machten${UNAME_RELEASE}
 	exit 0 ;;
@@ -385,6 +397,7 @@
 	echo clipper-intergraph-clix${UNAME_RELEASE}
 	exit 0 ;;
     mips:*:*:UMIPS | mips:*:*:RISCos)
+	eval $set_cc_for_build
 	sed 's/^	//' << EOF >$dummy.c
 #ifdef __cplusplus
 #include <stdio.h>  /* for printf() prototype */
@@ -475,6 +488,7 @@
 	exit 0 ;;
     *:AIX:2:3)
 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		eval $set_cc_for_build
 		sed 's/^		//' << EOF >$dummy.c
 		#include <sys/systemcfg.h>
 
@@ -496,7 +510,7 @@
 	fi
 	exit 0 ;;
     *:AIX:*:[45])
-	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | head -1 | awk '{ print $1 }'`
+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
 	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
 		IBM_ARCH=rs6000
 	else
@@ -536,10 +550,8 @@
 	    9000/31? )            HP_ARCH=m68000 ;;
 	    9000/[34]?? )         HP_ARCH=m68k ;;
 	    9000/[678][0-9][0-9])
-              case "${HPUX_REV}" in
-                11.[0-9][0-9])
-                  if [ -x /usr/bin/getconf ]; then
-                    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+		if [ -x /usr/bin/getconf ]; then
+		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
                     sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
                     case "${sc_cpu_version}" in
                       523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
@@ -548,12 +560,13 @@
                         case "${sc_kernel_bits}" in
                           32) HP_ARCH="hppa2.0n" ;;
                           64) HP_ARCH="hppa2.0w" ;;
+			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
                         esac ;;
                     esac
-                  fi ;;
-              esac
-              if [ "${HP_ARCH}" = "" ]; then
-              sed 's/^              //' << EOF >$dummy.c
+		fi
+		if [ "${HP_ARCH}" = "" ]; then
+		    eval $set_cc_for_build
+		    sed 's/^              //' << EOF >$dummy.c
 
               #define _HPUX_SOURCE
               #include <stdlib.h>
@@ -586,10 +599,10 @@
                   exit (0);
               }
 EOF
-	(CCOPTS= $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null ) && HP_ARCH=`./$dummy`
-	if test -z "$HP_ARCH"; then HP_ARCH=hppa; fi
-	rm -f $dummy.c $dummy
-	fi ;;
+		    (CCOPTS= $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null) && HP_ARCH=`./$dummy`
+		    if test -z "$HP_ARCH"; then HP_ARCH=hppa; fi
+		    rm -f $dummy.c $dummy
+		fi ;;
 	esac
 	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
 	exit 0 ;;
@@ -598,6 +611,7 @@
 	echo ia64-hp-hpux${HPUX_REV}
 	exit 0 ;;
     3050*:HI-UX:*:*)
+	eval $set_cc_for_build
 	sed 's/^	//' << EOF >$dummy.c
 	#include <unistd.h>
 	int
@@ -633,7 +647,7 @@
     9000/8??:4.3bsd:*:*)
 	echo hppa1.0-hp-bsd
 	exit 0 ;;
-    *9??*:MPE/iX:*:*)
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
 	echo hppa1.0-hp-mpeix
 	exit 0 ;;
     hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
@@ -652,9 +666,6 @@
     parisc*:Lites*:*:*)
 	echo hppa1.1-hp-lites
 	exit 0 ;;
-    hppa*:OpenBSD:*:*)
-	echo hppa-unknown-openbsd
-	exit 0 ;;
     C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
 	echo c1-convex-bsd
         exit 0 ;;
@@ -673,16 +684,14 @@
     C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
 	echo c4-convex-bsd
         exit 0 ;;
-    CRAY*X-MP:*:*:*)
-	echo xmp-cray-unicos
-        exit 0 ;;
     CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos${UNAME_RELEASE}
+	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
     CRAY*[A-Z]90:*:*:*)
 	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
 	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+	      -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
     CRAY*TS:*:*:*)
 	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
@@ -696,18 +705,12 @@
     CRAY*SV1:*:*:*)
 	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
 	exit 0 ;;
-    CRAY-2:*:*:*)
-	echo cray2-cray-unicos
-        exit 0 ;;
     F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
 	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
         FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
         FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
         echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
         exit 0 ;;
-    hp300:OpenBSD:*:*)
-	echo m68k-unknown-openbsd${UNAME_RELEASE}
-	exit 0 ;;
     i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
 	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
 	exit 0 ;;
@@ -720,9 +723,6 @@
     *:FreeBSD:*:*)
 	echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
 	exit 0 ;;
-    *:OpenBSD:*:*)
-	echo ${UNAME_MACHINE}-unknown-openbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
-	exit 0 ;;
     i*:CYGWIN*:*)
 	echo ${UNAME_MACHINE}-pc-cygwin
 	exit 0 ;;
@@ -732,6 +732,9 @@
     i*:PW*:*)
 	echo ${UNAME_MACHINE}-pc-pw32
 	exit 0 ;;
+    x86:Interix*:3*)
+	echo i386-pc-interix3
+	exit 0 ;;
     i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
 	# How do we know it's Interix rather than the generic POSIX subsystem?
 	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
@@ -763,97 +766,43 @@
 	echo ${UNAME_MACHINE}-unknown-linux-gnu
 	exit 0 ;;
     mips:Linux:*:*)
-	cat >$dummy.c <<EOF
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-int main (int argc, char *argv[]) {
-#else
-int main (argc, argv) int argc; char *argv[]; {
-#endif
-#ifdef __MIPSEB__
-  printf ("%s-unknown-linux-gnu\n", argv[1]);
-#endif
-#ifdef __MIPSEL__
-  printf ("%sel-unknown-linux-gnu\n", argv[1]);
-#endif
-  return 0;
-}
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#undef CPU
+	#undef mips
+	#undef mipsel
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) 
+	CPU=mipsel 
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) 
+	CPU=mips
+	#else
+	CPU=
+	#endif
+	#endif 
 EOF
-	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm -f $dummy.c $dummy && exit 0
-	rm -f $dummy.c $dummy
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=`
+	rm -f $dummy.c
+	test x"${CPU}" != x && echo "${CPU}-pc-linux-gnu" && exit 0
 	;;
     ppc:Linux:*:*)
-	# Determine Lib Version
-	cat >$dummy.c <<EOF
-#include <features.h>
-#if defined(__GLIBC__)
-extern char __libc_version[];
-extern char __libc_release[];
-#endif
-main(argc, argv)
-     int argc;
-     char *argv[];
-{
-#if defined(__GLIBC__)
-  printf("%s %s\n", __libc_version, __libc_release);
-#else
-  printf("unknown\n");
-#endif
-  return 0;
-}
-EOF
-	LIBC=""
-	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null
-	if test "$?" = 0 ; then
-		./$dummy | grep 1\.99 > /dev/null
-		if test "$?" = 0 ; then LIBC="libc1" ; fi
-	fi
-	rm -f $dummy.c $dummy
-	echo powerpc-unknown-linux-gnu${LIBC}
+	echo powerpc-unknown-linux-gnu
 	exit 0 ;;
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-gnu
+	exit 0 ;;
     alpha:Linux:*:*)
-	cat <<EOF >$dummy.s
-	  .data
-	  \$Lformat:
-		.byte 37,100,45,37,120,10,0	# "%d-%x\n"
-	   .text
-		.globl main
-		.align 4
-		.ent main
-	    main:
-		.frame \$30,16,\$26,0
-		ldgp \$29,0(\$27)
-		.prologue 1
-		.long 0x47e03d80 # implver \$0
-		lda \$2,-1
-		.long 0x47e20c21 # amask \$2,\$1
-		lda \$16,\$Lformat
-		mov \$0,\$17
-		not \$1,\$18
-		jsr \$26,printf
-		ldgp \$29,0(\$26)
-		mov 0,\$16
-		jsr \$26,exit
-		.end main
-EOF
-	LIBC=""
-	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
-	if test "$?" = 0 ; then
-		case `./$dummy` in
-		0-0)	UNAME_MACHINE="alpha" ;;
-		1-0)	UNAME_MACHINE="alphaev5" ;;
-		1-1)    UNAME_MACHINE="alphaev56" ;;
-		1-101)	UNAME_MACHINE="alphapca56" ;;
-		2-303)	UNAME_MACHINE="alphaev6" ;;
-		2-307)	UNAME_MACHINE="alphaev67" ;;
-		esac
-		objdump --private-headers $dummy | \
-		  grep ld.so.1 > /dev/null
-		if test "$?" = 0 ; then
-			LIBC="libc1"
-		fi
-	fi
-	rm -f $dummy.s $dummy
+	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+	  EV5)   UNAME_MACHINE=alphaev5 ;;
+	  EV56)  UNAME_MACHINE=alphaev56 ;;
+	  PCA56) UNAME_MACHINE=alphapca56 ;;
+	  PCA57) UNAME_MACHINE=alphapca56 ;;
+	  EV6)   UNAME_MACHINE=alphaev6 ;;
+	  EV67)  UNAME_MACHINE=alphaev67 ;;
+	  EV68*) UNAME_MACHINE=alphaev68 ;;
+        esac
+	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
+	if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
 	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
 	exit 0 ;;
     parisc:Linux:*:* | hppa:Linux:*:*)
@@ -883,71 +832,60 @@
 	# The BFD linker knows what the default object file format is, so
 	# first see if it will tell us. cd to the root directory to prevent
 	# problems with other programs or directories called `ld' in the path.
-	ld_supported_emulations=`cd /; ld --help 2>&1 \
-			 | sed -ne '/supported emulations:/!d
+	# Set LC_ALL=C to ensure ld outputs messages in English.
+	ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
+			 | sed -ne '/supported targets:/!d
 				    s/[ 	][ 	]*/ /g
-				    s/.*supported emulations: *//
+				    s/.*supported targets: *//
 				    s/ .*//
 				    p'`
-        case "$ld_supported_emulations" in
-	  i*86linux)
-		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
-		exit 0
-		;;
-	  elf_i*86)
+        case "$ld_supported_targets" in
+	  elf32-i386)
 		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
 		;;
-	  i*86coff)
+	  a.out-i386-linux)
+		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
+		exit 0 ;;		
+	  coff-i386)
 		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
-		exit 0
-		;;
-	esac
-	# Either a pre-BFD a.out linker (linux-gnuoldld)
-	# or one that does not give us useful --help.
-	# GCC wants to distinguish between linux-gnuoldld and linux-gnuaout.
-	# If ld does not provide *any* "supported emulations:"
-	# that means it is gnuoldld.
-	test -z "$ld_supported_emulations" && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0
-	case "${UNAME_MACHINE}" in
-	i*86)
-	  VENDOR=pc;
-	  ;;
-	*)
-	  VENDOR=unknown;
-	  ;;
+		exit 0 ;;
+	  "")
+		# Either a pre-BFD a.out linker (linux-gnuoldld) or
+		# one that does not give us useful --help.
+		echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
+		exit 0 ;;
 	esac
 	# Determine whether the default compiler is a.out or elf
-	cat >$dummy.c <<EOF
-#include <features.h>
-#ifdef __cplusplus
-#include <stdio.h>  /* for printf() prototype */
-	int main (int argc, char *argv[]) {
-#else
-	int main (argc, argv) int argc; char *argv[]; {
-#endif
-#ifdef __ELF__
-# ifdef __GLIBC__
-#  if __GLIBC__ >= 2
-    printf ("%s-${VENDOR}-linux-gnu\n", argv[1]);
-#  else
-    printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
-#  endif
-# else
-   printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
-# endif
-#else
-  printf ("%s-${VENDOR}-linux-gnuaout\n", argv[1]);
-#endif
-  return 0;
-}
+	eval $set_cc_for_build
+	sed 's/^	//' << EOF >$dummy.c
+	#include <features.h>
+	#ifdef __ELF__
+	# ifdef __GLIBC__
+	#  if __GLIBC__ >= 2
+	LIBC=gnu
+	#  else
+	LIBC=gnulibc1
+	#  endif
+	# else
+	LIBC=gnulibc1
+	# endif
+	#else
+	#ifdef __INTEL_COMPILER
+	LIBC=gnu
+	#else
+	LIBC=gnuaout
+	#endif
+	#endif
 EOF
-	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm -f $dummy.c $dummy && exit 0
-	rm -f $dummy.c $dummy
+	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=`
+	rm -f $dummy.c
+	test x"${LIBC}" != x && echo "${UNAME_MACHINE}-pc-linux-${LIBC}" && exit 0
 	test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0
 	;;
-# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
-# are messed up and put the nodename in both sysname and nodename.
     i*86:DYNIX/ptx:4*:*)
+	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+	# earlier versions are messed up and put the nodename in both
+	# sysname and nodename.
 	echo i386-sequent-sysv4
 	exit 0 ;;
     i*86:UNIX_SV:4.2MP:2.*)
@@ -966,14 +904,13 @@
 		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
 	fi
 	exit 0 ;;
-    i*86:*:5:7*)
-        # Fixed at (any) Pentium or better
-        UNAME_MACHINE=i586
-        if [ ${UNAME_SYSTEM} = "UnixWare" ] ; then
-	    echo ${UNAME_MACHINE}-sco-sysv${UNAME_RELEASE}uw${UNAME_VERSION}
-	else
-	    echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
-	fi
+    i*86:*:5:[78]*)
+	case `/bin/uname -X | grep "^Machine"` in
+	    *486*)	     UNAME_MACHINE=i486 ;;
+	    *Pentium)	     UNAME_MACHINE=i586 ;;
+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+	esac
+	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
 	exit 0 ;;
     i*86:*:3.2:*)
 	if test -f /usr/options/cb.name; then
@@ -1021,7 +958,7 @@
 	exit 0 ;;
     M68*:*:R3V[567]*:*)
 	test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
-    3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
+    3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0)
 	OS_REL=''
 	test -r /etc/.relid \
 	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
@@ -1067,8 +1004,8 @@
 		echo ns32k-sni-sysv
 	fi
 	exit 0 ;;
-    PENTIUM:CPunix:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
-                           # says <Richard.M.Bartel@ccMail.Census.GOV>
+    PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+                      # says <Richard.M.Bartel@ccMail.Census.GOV>
         echo i586-unisys-sysv4
         exit 0 ;;
     *:UNIX_System_V:4*:FTX*)
@@ -1080,6 +1017,10 @@
 	# From seanf@swdc.stratus.com.
 	echo i860-stratus-sysv4
 	exit 0 ;;
+    *:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo hppa1.1-stratus-vos
+	exit 0 ;;
     mc68*:A/UX:*:*)
 	echo m68k-apple-aux${UNAME_RELEASE}
 	exit 0 ;;
@@ -1120,13 +1061,15 @@
     *:procnto*:*:* | *:QNX:[0123456789]*:*)
 	if test "${UNAME_MACHINE}" = "x86pc"; then
 		UNAME_MACHINE=pc
+		echo i386-${UNAME_MACHINE}-nto-qnx
+	else
+		echo `uname -p`-${UNAME_MACHINE}-nto-qnx
 	fi
-	echo `uname -p`-${UNAME_MACHINE}-nto-qnx
 	exit 0 ;;
     *:QNX:*:4*)
 	echo i386-pc-qnx
 	exit 0 ;;
-    NSR-[KW]:NONSTOP_KERNEL:*:*)
+    NSR-[GKLNPTVW]:NONSTOP_KERNEL:*:*)
 	echo nsr-tandem-nsk${UNAME_RELEASE}
 	exit 0 ;;
     *:NonStop-UX:*:*)
@@ -1172,11 +1115,18 @@
     *:ITS:*:*)
 	echo pdp10-unknown-its
 	exit 0 ;;
+    i*86:XTS-300:*:STOP)
+	echo ${UNAME_MACHINE}-unknown-stop
+	exit 0 ;;
+    i*86:atheos:*:*)
+	echo ${UNAME_MACHINE}-unknown-atheos
+	exit 0 ;;
 esac
 
 #echo '(No uname command or uname output not recognized.)' 1>&2
 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
 
+eval $set_cc_for_build
 cat >$dummy.c <<EOF
 #ifdef _SEQUENT_
 # include <sys/types.h>
Index: xc/extras/freetype2/builds/unix/config.sub
diff -u xc/extras/freetype2/builds/unix/config.sub:1.1.1.3 xc/extras/freetype2/builds/unix/config.sub:1.1.1.4
--- xc/extras/freetype2/builds/unix/config.sub:1.1.1.3	Sun Sep  9 22:55:49 2001
+++ xc/extras/freetype2/builds/unix/config.sub	Tue Mar 26 23:35:39 2002
@@ -1,9 +1,9 @@
 #! /bin/sh
 # Configuration validation subroutine script.
-#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
-#   Free Software Foundation, Inc.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002 Free Software Foundation, Inc.
 
-timestamp='2001-04-20'
+timestamp='2002-03-04'
 
 # This file is (in principle) common to ALL GNU software.
 # The presence of a machine in this file suggests that SOME GNU software
@@ -29,7 +29,8 @@
 # configuration script generated by Autoconf, you may include it under
 # the same distribution terms that you use for the rest of that program.
 
-# Please send patches to <config-patches@gnu.org>.
+# Please send patches to <config-patches@gnu.org>.  Submit a context
+# diff and a properly formatted ChangeLog entry.
 #
 # Configuration subroutine to validate and canonicalize a configuration type.
 # Supply the specified configuration type as an argument.
@@ -117,7 +118,7 @@
 # Here we must recognize all the valid KERNEL-OS combinations.
 maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
 case $maybe_os in
-  nto-qnx* | linux-gnu* | storm-chaos* | os2-emx*)
+  nto-qnx* | linux-gnu* | storm-chaos* | os2-emx* | windows32-* | rtmk-nova*)
     os=-$maybe_os
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
     ;;
@@ -157,6 +158,14 @@
 		os=-vxworks
 		basic_machine=$1
 		;;
+	-chorusos*)
+		os=-chorusos
+		basic_machine=$1
+		;;
+ 	-chorusrdb)
+ 		os=-chorusrdb
+		basic_machine=$1
+ 		;;
 	-hiux*)
 		os=-hiuxwe2
 		;;
@@ -215,26 +224,36 @@
 case $basic_machine in
 	# Recognize the basic CPU types without company name.
 	# Some are omitted here because they have special meanings below.
-	tahoe | i860 | ia64 | m32r | m68k | m68000 | m88k | ns32k | arc \
-	        | arm | arme[lb] | arm[bl]e | armv[2345] | armv[345][lb] | strongarm | xscale \
-		| pyramid | mn10200 | mn10300 | tron | a29k \
-		| 580 | i960 | h8300 \
-		| x86 | ppcbe | mipsbe | mipsle | shbe | shle \
-		| hppa | hppa1.0 | hppa1.1 | hppa2.0 | hppa2.0w | hppa2.0n \
-		| hppa64 \
-		| alpha | alphaev[4-8] | alphaev56 | alphapca5[67] \
-		| alphaev6[78] \
-		| we32k | ns16k | clipper | i370 | sh | sh[34] \
-		| powerpc | powerpcle \
-		| 1750a | dsp16xx | pdp10 | pdp11 \
-		| mips16 | mips64 | mipsel | mips64el \
-		| mips64orion | mips64orionel | mipstx39 | mipstx39el \
-		| mips64vr4300 | mips64vr4300el | mips64vr4100 | mips64vr4100el \
-		| mips64vr5000 | miprs64vr5000el | mcore | s390 | s390x \
-		| sparc | sparclet | sparclite | sparc64 | sparcv9 | sparcv9b \
-		| v850 | c4x \
-		| thumb | d10v | d30v | fr30 | avr | openrisc | tic80 \
-		| pj | pjl | h8500)
+	1750a | 580 \
+	| a29k \
+	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
+	| c4x | clipper \
+	| d10v | d30v | dsp16xx \
+	| fr30 \
+	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+	| i370 | i860 | i960 | ia64 \
+	| m32r | m68000 | m68k | m88k | mcore \
+	| mips | mips16 | mips64 | mips64el | mips64orion | mips64orionel \
+	| mips64vr4100 | mips64vr4100el | mips64vr4300 \
+	| mips64vr4300el | mips64vr5000 | mips64vr5000el \
+	| mipsbe | mipseb | mipsel | mipsle | mipstx39 | mipstx39el \
+	| mipsisa32 \
+	| mn10200 | mn10300 \
+	| ns16k | ns32k \
+	| openrisc | or32 \
+	| pdp10 | pdp11 | pj | pjl \
+	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+	| pyramid \
+	| sh | sh[34] | sh[34]eb | shbe | shle | sh64 \
+	| sparc | sparc64 | sparc86x | sparclet | sparclite | sparcv9 | sparcv9b \
+	| strongarm \
+	| tahoe | thumb | tic80 | tron \
+	| v850 | v850e \
+	| we32k \
+	| x86 | xscale | xstormy16 | xtensa \
+	| z8k)
 		basic_machine=$basic_machine-unknown
 		;;
 	m6811 | m68hc11 | m6812 | m68hc12)
@@ -242,7 +261,7 @@
 		basic_machine=$basic_machine-unknown
 		os=-none
 		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | w65)
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
 		;;
 
 	# We use `pc' rather than `unknown'
@@ -257,31 +276,45 @@
 		exit 1
 		;;
 	# Recognize the basic CPU types with company name.
-	# FIXME: clean up the formatting here.
-	vax-* | tahoe-* | i*86-* | i860-* | ia64-* | m32r-* | m68k-* | m68000-* \
-	      | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | c[123]* \
-	      | arm-*  | armbe-* | armle-* | armv*-* | strongarm-* | xscale-* \
-	      | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
-	      | power-* | none-* | 580-* | cray2-* | h8300-* | h8500-* | i960-* \
-	      | xmp-* | ymp-* \
-	      | x86-* | ppcbe-* | mipsbe-* | mipsle-* | shbe-* | shle-* \
-	      | hppa-* | hppa1.0-* | hppa1.1-* | hppa2.0-* | hppa2.0w-* \
-	      | hppa2.0n-* | hppa64-* \
-	      | alpha-* | alphaev[4-8]-* | alphaev56-* | alphapca5[67]-* \
-	      | alphaev6[78]-* \
-	      | we32k-* | cydra-* | ns16k-* | pn-* | np1-* | xps100-* \
-	      | clipper-* | orion-* \
-	      | sparclite-* | pdp10-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
-	      | sparc64-* | sparcv9-* | sparcv9b-* | sparc86x-* \
-	      | mips16-* | mips64-* | mipsel-* \
-	      | mips64el-* | mips64orion-* | mips64orionel-* \
-	      | mips64vr4100-* | mips64vr4100el-* | mips64vr4300-* | mips64vr4300el-* \
-	      | mipstx39-* | mipstx39el-* | mcore-* \
-	      | f30[01]-* | f700-* | s390-* | s390x-* | sv1-* | t3e-* \
-	      | [cjt]90-* \
-	      | m88110-* | m680[01234]0-* | m683?2-* | m68360-* | z8k-* | d10v-* \
-	      | thumb-* | v850-* | d30v-* | tic30-* | tic80-* | c30-* | fr30-* \
-	      | bs2000-* | tic54x-* | c54x-* | x86_64-* | pj-* | pjl-*)
+	580-* \
+	| a29k-* \
+	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+	| arm-*  | armbe-* | armle-* | armv*-* \
+	| avr-* \
+	| bs2000-* \
+	| c[123]* | c30-* | [cjt]90-* | c54x-* \
+	| clipper-* | cydra-* \
+	| d10v-* | d30v-* \
+	| elxsi-* \
+	| f30[01]-* | f700-* | fr30-* | fx80-* \
+	| h8300-* | h8500-* \
+	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+	| i*86-* | i860-* | i960-* | ia64-* \
+	| m32r-* \
+	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+	| m88110-* | m88k-* | mcore-* \
+	| mips-* | mips16-* | mips64-* | mips64el-* | mips64orion-* \
+	| mips64orionel-* | mips64vr4100-* | mips64vr4100el-* \
+	| mips64vr4300-* | mips64vr4300el-* | mipsbe-* | mipseb-* \
+	| mipsle-* | mipsel-* | mipstx39-* | mipstx39el-* \
+	| none-* | np1-* | ns16k-* | ns32k-* \
+	| orion-* \
+	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+	| pyramid-* \
+	| romp-* | rs6000-* \
+	| sh-* | sh[34]-* | sh[34]eb-* | shbe-* | shle-* | sh64-* \
+	| sparc-* | sparc64-* | sparc86x-* | sparclet-* | sparclite-* \
+	| sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \
+	| tahoe-* | thumb-* | tic30-* | tic54x-* | tic80-* | tron-* \
+	| v850-* | v850e-* | vax-* \
+	| we32k-* \
+	| x86-* | x86_64-* | xps100-* | xscale-* | xstormy16-* \
+	| xtensa-* \
+	| ymp-* \
+	| z8k-*)
 		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
@@ -344,6 +377,10 @@
 		basic_machine=ns32k-sequent
 		os=-dynix
 		;;
+	c90)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
 	convex-c1)
 		basic_machine=c1-convex
 		os=-bsd
@@ -364,18 +401,10 @@
 		basic_machine=c38-convex
 		os=-bsd
 		;;
-	cray | ymp)
-		basic_machine=ymp-cray
+	cray | j90)
+		basic_machine=j90-cray
 		os=-unicos
 		;;
-	cray2)
-		basic_machine=cray2-cray
-		os=-unicos
-		;;
-	[cjt]90)
-		basic_machine=${basic_machine}-cray
-		os=-unicos
-		;;
 	crds | unos)
 		basic_machine=m68k-crds
 		;;
@@ -388,6 +417,14 @@
 	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
 		basic_machine=mips-dec
 		;;
+	decsystem10* | dec10*)
+		basic_machine=pdp10-dec
+		os=-tops10
+		;;
+	decsystem20* | dec20*)
+		basic_machine=pdp10-dec
+		os=-tops20
+		;;
 	delta | 3300 | motorola-3300 | motorola-delta \
 	      | 3300-motorola | delta-motorola)
 		basic_machine=m68k-motorola
@@ -568,14 +605,6 @@
 		basic_machine=m68k-atari
 		os=-mint
 		;;
-	mipsel*-linux*)
-		basic_machine=mipsel-unknown
-		os=-linux-gnu
-		;;
-	mips*-linux*)
-		basic_machine=mips-unknown
-		os=-linux-gnu
-		;;
 	mips3*-*)
 		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
 		;;
@@ -590,6 +619,10 @@
 		basic_machine=m68k-rom68k
 		os=-coff
 		;;
+	morphos)
+		basic_machine=powerpc-unknown
+		os=-morphos
+		;;
 	msdos)
 		basic_machine=i386-pc
 		os=-msdos
@@ -669,6 +702,10 @@
 		basic_machine=hppa1.1-oki
 		os=-proelf
 		;;
+	or32 | or32-*)
+		basic_machine=or32-unknown
+		os=-coff
+		;;
 	OSE68000 | ose68000)
 		basic_machine=m68000-ericsson
 		os=-ose
@@ -694,7 +731,7 @@
         pc532 | pc532-*)
 		basic_machine=ns32k-pc532
 		;;
-	pentium | p5 | k5 | k6 | nexgen)
+	pentium | p5 | k5 | k6 | nexgen | viac3)
 		basic_machine=i586-pc
 		;;
 	pentiumpro | p6 | 6x86 | athlon)
@@ -703,7 +740,7 @@
 	pentiumii | pentium2)
 		basic_machine=i686-pc
 		;;
-	pentium-* | p5-* | k5-* | k6-* | nexgen-*)
+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
 		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	pentiumpro-* | p6-* | 6x86-* | athlon-*)
@@ -727,6 +764,16 @@
 	ppcle-* | powerpclittle-*)
 		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
+	ppc64)	basic_machine=powerpc64-unknown
+	        ;;
+	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+		basic_machine=powerpc64le-unknown
+	        ;;
+	ppc64le-* | powerpc64little-*)
+		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
 	ps2)
 		basic_machine=i386-ibm
 		;;
@@ -744,6 +791,12 @@
 	rtpc | rtpc-*)
 		basic_machine=romp-ibm
 		;;
+	s390 | s390-*)
+		basic_machine=s390-ibm
+		;;
+	s390x | s390x-*)
+		basic_machine=s390x-ibm
+		;;
 	sa29200)
 		basic_machine=a29k-amd
 		os=-udi
@@ -755,7 +808,7 @@
 		basic_machine=sh-hitachi
 		os=-hms
 		;;
-	sparclite-wrs)
+	sparclite-wrs | simso-wrs)
 		basic_machine=sparclite-wrs
 		os=-vxworks
 		;;
@@ -813,7 +866,7 @@
 	sun386 | sun386i | roadrunner)
 		basic_machine=i386-sun
 		;;
-	sv1)
+        sv1)
 		basic_machine=sv1-cray
 		os=-unicos
 		;;
@@ -821,8 +874,16 @@
 		basic_machine=i386-sequent
 		os=-dynix
 		;;
+	t3d)
+		basic_machine=alpha-cray
+		os=-unicos
+		;;
 	t3e)
-		basic_machine=t3e-cray
+		basic_machine=alphaev5-cray
+		os=-unicos
+		;;
+	t90)
+		basic_machine=t90-cray
 		os=-unicos
 		;;
 	tic54x | c54x*)
@@ -835,6 +896,10 @@
 	tx39el)
 		basic_machine=mipstx39el-unknown
 		;;
+	toad1)
+		basic_machine=pdp10-xkl
+		os=-tops20
+		;;
 	tower | tower-32)
 		basic_machine=m68k-ncr
 		;;
@@ -881,13 +946,17 @@
 		basic_machine=hppa1.1-winbond
 		os=-proelf
 		;;
-	xmp)
-		basic_machine=xmp-cray
-		os=-unicos
+	windows32)
+		basic_machine=i386-pc
+		os=-windows32-msvcrt
 		;;
         xps | xps100)
 		basic_machine=xps100-honeywell
 		;;
+	ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
 	z8k-*-coff)
 		basic_machine=z8k-unknown
 		os=-sim
@@ -908,13 +977,6 @@
 	op60c)
 		basic_machine=hppa1.1-oki
 		;;
-	mips)
-		if [ x$os = x-linux-gnu ]; then
-			basic_machine=mips-unknown
-		else
-			basic_machine=mips-mips
-		fi
-		;;
 	romp)
 		basic_machine=romp-ibm
 		;;
@@ -934,9 +996,12 @@
 	we32k)
 		basic_machine=we32k-att
 		;;
-	sh3 | sh4)
+	sh3 | sh4 | sh3eb | sh4eb)
 		basic_machine=sh-unknown
 		;;
+	sh64)
+		basic_machine=sh64-unknown
+		;;
 	sparc | sparcv9 | sparcv9b)
 		basic_machine=sparc-sun
 		;;
@@ -1018,11 +1083,14 @@
 	      | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
 	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
 	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -chorusos* | -chorusrdb* \
 	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
 	      | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
 	      | -interix* | -uwin* | -rhapsody* | -darwin* | -opened* \
 	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
-	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* | -os2*)
+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+	      | -morphos* | -superux* | -rtmk* | -rtmk-nova*)
 	# Remember, each alternative MUST END IN *, to match a version number.
 		;;
 	-qnx*)
@@ -1074,12 +1142,18 @@
 	-acis*)
 		os=-aos
 		;;
+	-atheos*)
+		os=-atheos
+		;;
 	-386bsd)
 		os=-bsd
 		;;
 	-ctix* | -uts*)
 		os=-sysv
 		;;
+	-nova*)
+		os=-rtmk-nova
+		;;
 	-ns2 )
 	        os=-nextstep2
 		;;
@@ -1154,6 +1228,7 @@
 	arm*-semi)
 		os=-aout
 		;;
+	# This must come before the *-dec entry.
 	pdp10-*)
 		os=-tops20
 		;;
@@ -1184,6 +1259,9 @@
 	mips*-*)
 		os=-elf
 		;;
+	or32-*)
+		os=-coff
+		;;
 	*-tti)	# must be before sparc entry or we get the wrong os.
 		os=-sysv3
 		;;
@@ -1345,6 +1423,9 @@
 				;;
 			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
 				vendor=atari
+				;;
+			-vos*)
+				vendor=stratus
 				;;
 		esac
 		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
Index: xc/extras/freetype2/builds/unix/configure
diff -u xc/extras/freetype2/builds/unix/configure:1.1.1.4 xc/extras/freetype2/builds/unix/configure:1.1.1.6
--- xc/extras/freetype2/builds/unix/configure:1.1.1.4	Mon Jan 14 11:52:00 2002
+++ xc/extras/freetype2/builds/unix/configure	Thu Jun 20 04:16:02 2002
@@ -1,8 +1,8 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by Autoconf 2.52.
+# Generated by GNU Autoconf 2.53.
 #
-# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
+# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
 # Free Software Foundation, Inc.
 # This configure script is free software; the Free Software Foundation
 # gives unlimited permission to copy, distribute and modify it.
@@ -15,8 +15,10 @@
     *-DOS) lt_cv_sys_path_separator=';' ;;
     *)     lt_cv_sys_path_separator=':' ;;
   esac
+  PATH_SEPARATOR=$lt_cv_sys_path_separator
 fi
 
+
 # Check that we are running under the correct shell.
 SHELL=${CONFIG_SHELL-/bin/sh}
 
@@ -80,7 +82,7 @@
   #
   # So, first we look for a working echo in the user's PATH.
 
-  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR}"
+  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   for dir in $PATH /usr/ucb; do
     if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
        test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
@@ -162,19 +164,19 @@
    ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo"
 fi
 
-# Avoid depending upon Character Ranges.
-as_cr_letters='abcdefghijklmnopqrstuvwxyz'
-as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-as_cr_Letters=$as_cr_letters$as_cr_LETTERS
-as_cr_digits='0123456789'
-as_cr_alnum=$as_cr_Letters$as_cr_digits
 
-# Sed expression to map a string onto a valid variable name.
-as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
 
-# Sed expression to map a string onto a valid CPP name.
-as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
 
+
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
 # Be Bourne compatible
 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
   emulate sh
@@ -183,8 +185,165 @@
   set -o posix
 fi
 
+# NLS nuisances.
+# Support unset when possible.
+if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+(set +x; test -n "`(LANG=C; export LANG) 2>&1`") &&
+    { $as_unset LANG || test "${LANG+set}" != set; } ||
+      { LANG=C; export LANG; }
+(set +x; test -n "`(LC_ALL=C; export LC_ALL) 2>&1`") &&
+    { $as_unset LC_ALL || test "${LC_ALL+set}" != set; } ||
+      { LC_ALL=C; export LC_ALL; }
+(set +x; test -n "`(LC_TIME=C; export LC_TIME) 2>&1`") &&
+    { $as_unset LC_TIME || test "${LC_TIME+set}" != set; } ||
+      { LC_TIME=C; export LC_TIME; }
+(set +x; test -n "`(LC_CTYPE=C; export LC_CTYPE) 2>&1`") &&
+    { $as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set; } ||
+      { LC_CTYPE=C; export LC_CTYPE; }
+(set +x; test -n "`(LANGUAGE=C; export LANGUAGE) 2>&1`") &&
+    { $as_unset LANGUAGE || test "${LANGUAGE+set}" != set; } ||
+      { LANGUAGE=C; export LANGUAGE; }
+(set +x; test -n "`(LC_COLLATE=C; export LC_COLLATE) 2>&1`") &&
+    { $as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set; } ||
+      { LC_COLLATE=C; export LC_COLLATE; }
+(set +x; test -n "`(LC_NUMERIC=C; export LC_NUMERIC) 2>&1`") &&
+    { $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set; } ||
+      { LC_NUMERIC=C; export LC_NUMERIC; }
+(set +x; test -n "`(LC_MESSAGES=C; export LC_MESSAGES) 2>&1`") &&
+    { $as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set; } ||
+      { LC_MESSAGES=C; export LC_MESSAGES; }
+
+
 # Name of the executable.
-as_me=`echo "$0" |sed 's,.*[\\/],,'`
+as_me=`(basename "$0") 2>/dev/null ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)$' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\/\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conftest.sh
+  echo  "exit 0"   >>conftest.sh
+  chmod +x conftest.sh
+  if (PATH=".;."; conftest.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conftest.sh
+fi
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+  # Find who we are.  Look in the path if we contain no path at all
+  # relative or not.
+  case $0 in
+    *[\\/]* ) as_myself=$0 ;;
+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+       ;;
+  esac
+  # We did not find ourselves, most probably we were run as `sh COMMAND'
+  # in which case we are not to be found in the path.
+  if test "x$as_myself" = x; then
+    as_myself=$0
+  fi
+  if test ! -f "$as_myself"; then
+    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+   { (exit 1); exit 1; }; }
+  fi
+  case $CONFIG_SHELL in
+  '')
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for as_base in sh bash ksh sh5; do
+	 case $as_dir in
+	 /*)
+	   if ("$as_dir/$as_base" -c '
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+	     CONFIG_SHELL=$as_dir/$as_base
+	     export CONFIG_SHELL
+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+	   fi;;
+	 esac
+       done
+done
+;;
+  esac
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line before each line; the second 'sed' does the real
+  # work.  The second script uses 'N' to pair each line-number line
+  # with the numbered line, and appends trailing '-' during
+  # substitution so that $LINENO is not a special case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+  sed '=' <$as_myself |
+    sed '
+      N
+      s,$,-,
+      : loop
+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      t loop
+      s,-$,,
+      s,^['$as_cr_digits']*\n,,
+    ' >$as_me.lineno &&
+  chmod +x $as_me.lineno ||
+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensible to this).
+  . ./$as_me.lineno
+  # Exit status is that of the last command.
+  exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T='	' ;;
+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
 
 if expr a : '\(a\)' >/dev/null 2>&1; then
   as_expr=expr
@@ -212,22 +371,12 @@
 
 as_executable_p="test -f"
 
-# Support unset when possible.
-if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
-  as_unset=unset
-else
-  as_unset=false
-fi
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
 
-# NLS nuisances.
-$as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; }
-$as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; }
-$as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; }
-$as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; }
-$as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; }
-$as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; }
-$as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; }
-$as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; }
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
+
 
 # IFS
 # We need space, tab and new line, in precisely that order.
@@ -236,8 +385,9 @@
 IFS=" 	$as_nl"
 
 # CDPATH.
-$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; }
+$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=$PATH_SEPARATOR; export CDPATH; }
 
+
 # Name of the host.
 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 # so uname gets run too.
@@ -251,7 +401,8 @@
 ac_default_prefix=/usr/local
 cross_compiling=no
 subdirs=
-MFLAGS= MAKEFLAGS=
+MFLAGS=
+MAKEFLAGS=
 SHELL=${CONFIG_SHELL-/bin/sh}
 
 # Maximum number of lines to put in a shell here document.
@@ -259,6 +410,13 @@
 # only ac_max_sed_lines should be used.
 : ${ac_max_here_lines=38}
 
+# Identity of this package.
+PACKAGE_NAME=
+PACKAGE_TARNAME=
+PACKAGE_VERSION=
+PACKAGE_STRING=
+PACKAGE_BUGREPORT=
+
 ac_unique_file="ftconfig.in"
 # Factoring default headers for most tests.
 ac_includes_default="\
@@ -297,6 +455,7 @@
 # include <unistd.h>
 #endif"
 
+
 # Initialize some variables set by options.
 ac_init_help=
 ac_init_version=false
@@ -335,13 +494,6 @@
 infodir='${prefix}/info'
 mandir='${prefix}/man'
 
-# Identity of this package.
-PACKAGE_NAME=
-PACKAGE_TARNAME=
-PACKAGE_VERSION=
-PACKAGE_STRING=
-PACKAGE_BUGREPORT=
-
 ac_prev=
 for ac_option
 do
@@ -474,7 +626,7 @@
     with_fp=no ;;
 
   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
-  | --no-cr | --no-c)
+  | --no-cr | --no-c | -n)
     no_create=yes ;;
 
   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
@@ -653,7 +805,7 @@
   eval ac_val=$`echo $ac_var`
   case $ac_val in
     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
-    *)  { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2
+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
    { (exit 1); exit 1; }; };;
   esac
 done
@@ -665,18 +817,19 @@
   eval ac_val=$`echo $ac_var`
   case $ac_val in
     [\\/$]* | ?:[\\/]* ) ;;
-    *)  { echo "$as_me: error: expected an absolute path for --$ac_var: $ac_val" >&2
+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
    { (exit 1); exit 1; }; };;
   esac
 done
 
 # There might be people who depend on the old broken behavior: `$host'
 # used to hold the argument of --host etc.
+# FIXME: To remove some day.
 build=$build_alias
 host=$host_alias
 target=$target_alias
 
-# FIXME: should be removed in autoconf 3.0.
+# FIXME: To remove some day.
 if test "x$host_alias" != x; then
   if test "x$build_alias" = x; then
     cross_compiling=maybe
@@ -692,13 +845,23 @@
 
 test "$silent" = yes && exec 6>/dev/null
 
+
 # Find the source files, if location was not specified.
 if test -z "$srcdir"; then
   ac_srcdir_defaulted=yes
   # Try the directory containing this script, then its parent.
-  ac_prog=$0
-  ac_confdir=`echo "$ac_prog" | sed 's%[\\/][^\\/][^\\/]*$%%'`
-  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
+  ac_confdir=`(dirname "$0") 2>/dev/null ||
+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+         X"$0" : 'X\(//\)[^/]' \| \
+         X"$0" : 'X\(//\)$' \| \
+         X"$0" : 'X\(/\)' \| \
+         .     : '\(.\)' 2>/dev/null ||
+echo X"$0" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
   srcdir=$ac_confdir
   if test ! -r $srcdir/$ac_unique_file; then
     srcdir=..
@@ -708,10 +871,10 @@
 fi
 if test ! -r $srcdir/$ac_unique_file; then
   if test "$ac_srcdir_defaulted" = yes; then
-    { echo "$as_me: error: cannot find sources in $ac_confdir or .." >&2
+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
    { (exit 1); exit 1; }; }
   else
-    { echo "$as_me: error: cannot find sources in $srcdir" >&2
+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
    { (exit 1); exit 1; }; }
   fi
 fi
@@ -755,7 +918,7 @@
 if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
-  cat <<EOF
+  cat <<_ACEOF
 \`configure' configures this package to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
@@ -776,9 +939,9 @@
   -n, --no-create         do not create output files
       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 
-EOF
+_ACEOF
 
-  cat <<EOF
+  cat <<_ACEOF
 Installation directories:
   --prefix=PREFIX         install architecture-independent files in PREFIX
                           [$ac_default_prefix]
@@ -805,20 +968,20 @@
   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
   --infodir=DIR          info documentation [PREFIX/info]
   --mandir=DIR           man documentation [PREFIX/man]
-EOF
+_ACEOF
 
-  cat <<\EOF
+  cat <<\_ACEOF
 
 System types:
   --build=BUILD     configure for building on BUILD [guessed]
-  --host=HOST       build programs to run on HOST [BUILD]
+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
   --target=TARGET   configure for building compilers for TARGET [HOST]
-EOF
+_ACEOF
 fi
 
 if test -n "$ac_init_help"; then
 
-  cat <<\EOF
+  cat <<\_ACEOF
 
 Optional Features:
   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
@@ -846,40 +1009,60 @@
 Use these variables to override the choices made by `configure' or to help
 it to find libraries and programs with nonstandard names/locations.
 
-EOF
+_ACEOF
 fi
 
 if test "$ac_init_help" = "recursive"; then
   # If there are subdirs, report their specific --help.
   ac_popdir=`pwd`
-  for ac_subdir in : $ac_subdirs_all; do test "x$ac_subdir" = x: && continue
-    cd $ac_subdir
-    # A "../" for each directory in /$ac_subdir.
-    ac_dots=`echo $ac_subdir |
-             sed 's,^\./,,;s,[^/]$,&/,;s,[^/]*/,../,g'`
-
-    case $srcdir in
-    .) # No --srcdir option.  We are building in place.
-      ac_sub_srcdir=$srcdir ;;
-    [\\/]* | ?:[\\/]* ) # Absolute path.
-      ac_sub_srcdir=$srcdir/$ac_subdir ;;
-    *) # Relative path.
-      ac_sub_srcdir=$ac_dots$srcdir/$ac_subdir ;;
-    esac
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d $ac_dir || continue
+    ac_builddir=.
+
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
+  *) # Relative path.
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
+# absolute.
+ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
+ac_abs_top_builddir=`cd "$ac_dir" && cd $ac_top_builddir && pwd`
+ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
+ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
 
+    cd $ac_dir
     # Check for guested configure; otherwise get Cygnus style configure.
-    if test -f $ac_sub_srcdir/configure.gnu; then
+    if test -f $ac_srcdir/configure.gnu; then
       echo
-      $SHELL $ac_sub_srcdir/configure.gnu  --help=recursive
-    elif test -f $ac_sub_srcdir/configure; then
+      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+    elif test -f $ac_srcdir/configure; then
       echo
-      $SHELL $ac_sub_srcdir/configure  --help=recursive
-    elif test -f $ac_sub_srcdir/configure.ac ||
-           test -f $ac_sub_srcdir/configure.in; then
+      $SHELL $ac_srcdir/configure  --help=recursive
+    elif test -f $ac_srcdir/configure.ac ||
+           test -f $ac_srcdir/configure.in; then
       echo
       $ac_configure --help
     else
-      echo "$as_me: WARNING: no configuration information is in $ac_subdir" >&2
+      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
     fi
     cd $ac_popdir
   done
@@ -887,31 +1070,31 @@
 
 test -n "$ac_init_help" && exit 0
 if $ac_init_version; then
-  cat <<\EOF
+  cat <<\_ACEOF
 
-Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
+Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
-EOF
+_ACEOF
   exit 0
 fi
 exec 5>config.log
-cat >&5 <<EOF
+cat >&5 <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
 It was created by $as_me, which was
-generated by GNU Autoconf 2.52.  Invocation command line was
+generated by GNU Autoconf 2.53.  Invocation command line was
 
   $ $0 $@
 
-EOF
+_ACEOF
 {
 cat <<_ASUNAME
-## ---------- ##
-## Platform.  ##
-## ---------- ##
+## --------- ##
+## Platform. ##
+## --------- ##
 
 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
 uname -m = `(uname -m) 2>/dev/null || echo unknown`
@@ -930,17 +1113,27 @@
 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
 
-PATH = $PATH
-
 _ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  echo "PATH: $as_dir"
+done
+
 } >&5
 
-cat >&5 <<EOF
-## ------------ ##
-## Core tests.  ##
-## ------------ ##
+cat >&5 <<_ACEOF
 
-EOF
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
 
 # Keep a trace of the command line.
 # Strip out --no-create and --no-recursion so they do not pile up.
@@ -951,15 +1144,17 @@
 do
   case $ac_arg in
   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
-  | --no-cr | --no-c) ;;
+  | --no-cr | --no-c | -n ) continue ;;
   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
-  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    continue ;;
   *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
-    ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
-    ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
-    ac_sep=" " ;;
-  *) ac_configure_args="$ac_configure_args$ac_sep$ac_arg"
-     ac_sep=" " ;;
+    ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+  esac
+  case " $ac_configure_args " in
+    *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+    *) ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+       ac_sep=" " ;;
   esac
   # Get rid of the leading space.
 done
@@ -967,14 +1162,19 @@
 # When interrupted or exit'd, cleanup temporary files, and complete
 # config.log.  We remove comments because anyway the quotes in there
 # would cause problems or look ugly.
+# WARNING: Be sure not to use single quotes in there, as some shells,
+# such as our DU 5.0 friend, will then `close' the trap.
 trap 'exit_status=$?
   # Save into config.log some information that might help in debugging.
-  echo >&5
-  echo "## ----------------- ##" >&5
-  echo "## Cache variables.  ##" >&5
-  echo "## ----------------- ##" >&5
-  echo >&5
-  # The following way of writing the cache mishandles newlines in values,
+  {
+    echo
+    cat <<\_ASBOX
+## ---------------- ##
+## Cache variables. ##
+## ---------------- ##
+_ASBOX
+    echo
+    # The following way of writing the cache mishandles newlines in values,
 {
   (set) 2>&1 |
     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
@@ -988,21 +1188,24 @@
         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
       ;;
     esac;
-} >&5
-  sed "/^$/d" confdefs.h >conftest.log
-  if test -s conftest.log; then
-    echo >&5
-    echo "## ------------ ##" >&5
-    echo "## confdefs.h.  ##" >&5
-    echo "## ------------ ##" >&5
-    echo >&5
-    cat conftest.log >&5
-  fi
-  (echo; echo) >&5
-  test "$ac_signal" != 0 &&
-    echo "$as_me: caught signal $ac_signal" >&5
-  echo "$as_me: exit $exit_status" >&5
-  rm -rf conftest* confdefs* core core.* *.core conf$$* $ac_clean_files &&
+}
+    echo
+    if test -s confdefs.h; then
+      cat <<\_ASBOX
+## ----------- ##
+## confdefs.h. ##
+## ----------- ##
+_ASBOX
+      echo
+      sed "/^$/d" confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      echo "$as_me: caught signal $ac_signal"
+    echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core core.* *.core &&
+  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
     exit $exit_status
      ' 0
 for ac_signal in 1 2 13 15; do
@@ -1015,6 +1218,33 @@
 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 echo >confdefs.h
 
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+
 # Let the site file select an alternate cache file if it wants to.
 # Prefer explicitly selected file to automatically selected ones.
 if test -z "$CONFIG_SITE"; then
@@ -1026,9 +1256,9 @@
 fi
 for ac_site_file in $CONFIG_SITE; do
   if test -r "$ac_site_file"; then
-    { echo "$as_me:1029: loading site script $ac_site_file" >&5
+    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
 echo "$as_me: loading site script $ac_site_file" >&6;}
-    cat "$ac_site_file" >&5
+    sed 's/^/| /' "$ac_site_file" >&5
     . "$ac_site_file"
   fi
 done
@@ -1037,7 +1267,7 @@
   # Some versions of bash will fail to source /dev/null (special
   # files actually), so we avoid doing that.
   if test -f "$cache_file"; then
-    { echo "$as_me:1040: loading cache $cache_file" >&5
+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
 echo "$as_me: loading cache $cache_file" >&6;}
     case $cache_file in
       [\\/]* | ?:[\\/]* ) . $cache_file;;
@@ -1045,7 +1275,7 @@
     esac
   fi
 else
-  { echo "$as_me:1048: creating cache $cache_file" >&5
+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
 echo "$as_me: creating cache $cache_file" >&6;}
   >$cache_file
 fi
@@ -1061,42 +1291,42 @@
   eval ac_new_val="\$ac_env_${ac_var}_value"
   case $ac_old_set,$ac_new_set in
     set,)
-      { echo "$as_me:1064: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
       ac_cache_corrupted=: ;;
     ,set)
-      { echo "$as_me:1068: error: \`$ac_var' was not set in the previous run" >&5
+      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
       ac_cache_corrupted=: ;;
     ,);;
     *)
       if test "x$ac_old_val" != "x$ac_new_val"; then
-        { echo "$as_me:1074: error: \`$ac_var' has changed since the previous run:" >&5
+        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-        { echo "$as_me:1076:   former value:  $ac_old_val" >&5
+        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
 echo "$as_me:   former value:  $ac_old_val" >&2;}
-        { echo "$as_me:1078:   current value: $ac_new_val" >&5
+        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
 echo "$as_me:   current value: $ac_new_val" >&2;}
         ac_cache_corrupted=:
       fi;;
   esac
-  # Pass precious variables to config.status.  It doesn't matter if
-  # we pass some twice (in addition to the command line arguments).
+  # Pass precious variables to config.status.
   if test "$ac_new_set" = set; then
     case $ac_new_val in
     *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
-      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"`
-      ac_configure_args="$ac_configure_args '$ac_arg'"
-      ;;
-    *) ac_configure_args="$ac_configure_args $ac_var=$ac_new_val"
-       ;;
+      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
     esac
   fi
 done
 if $ac_cache_corrupted; then
-  { echo "$as_me:1097: error: changes in the environment can compromise the build" >&5
+  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
-  { { echo "$as_me:1099: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
+  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
    { (exit 1); exit 1; }; }
 fi
@@ -1107,33 +1337,33 @@
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
-case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
-  *c*,-n*) ECHO_N= ECHO_C='
-' ECHO_T='	' ;;
-  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
-  *)      ECHO_N= ECHO_C='\c' ECHO_T= ;;
-esac
-echo "#! $SHELL" >conftest.sh
-echo  "exit 0"   >>conftest.sh
-chmod +x conftest.sh
-if { (echo "$as_me:1119: PATH=\".;.\"; conftest.sh") >&5
-  (PATH=".;."; conftest.sh) 2>&5
-  ac_status=$?
-  echo "$as_me:1122: \$? = $ac_status" >&5
-  (exit $ac_status); }; then
-  ac_path_separator=';'
-else
-  ac_path_separator=:
-fi
-PATH_SEPARATOR="$ac_path_separator"
-rm -f conftest.sh
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 ac_config_headers="$ac_config_headers ftconfig.h:ftconfig.in"
+
 
-version_info='8:0:2'
+version_info='9:1:3'
 
 ft_version=`echo $version_info | tr : .`
 
+
 ac_aux_dir=
 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
   if test -f $ac_dir/install-sh; then
@@ -1151,7 +1381,7 @@
   fi
 done
 if test -z "$ac_aux_dir"; then
-  { { echo "$as_me:1154: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
    { (exit 1); exit 1; }; }
 fi
@@ -1161,11 +1391,11 @@
 
 # Make sure we can run config.sub.
 $ac_config_sub sun4 >/dev/null 2>&1 ||
-  { { echo "$as_me:1164: error: cannot run $ac_config_sub" >&5
+  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
    { (exit 1); exit 1; }; }
 
-echo "$as_me:1168: checking build system type" >&5
+echo "$as_me:$LINENO: checking build system type" >&5
 echo $ECHO_N "checking build system type... $ECHO_C" >&6
 if test "${ac_cv_build+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1174,26 +1404,24 @@
 test -z "$ac_cv_build_alias" &&
   ac_cv_build_alias=`$ac_config_guess`
 test -z "$ac_cv_build_alias" &&
-  { { echo "$as_me:1177: error: cannot guess build type; you must specify one" >&5
+  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
    { (exit 1); exit 1; }; }
 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
-  { { echo "$as_me:1181: error: $ac_config_sub $ac_cv_build_alias failed." >&5
-echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed." >&2;}
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
    { (exit 1); exit 1; }; }
 
 fi
-echo "$as_me:1186: result: $ac_cv_build" >&5
+echo "$as_me:$LINENO: result: $ac_cv_build" >&5
 echo "${ECHO_T}$ac_cv_build" >&6
 build=$ac_cv_build
 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 
-test -z "$build_alias" &&
-  build_alias=$ac_cv_build
 
-echo "$as_me:1196: checking host system type" >&5
+echo "$as_me:$LINENO: checking host system type" >&5
 echo $ECHO_N "checking host system type... $ECHO_C" >&6
 if test "${ac_cv_host+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1202,22 +1430,20 @@
 test -z "$ac_cv_host_alias" &&
   ac_cv_host_alias=$ac_cv_build_alias
 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
-  { { echo "$as_me:1205: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
    { (exit 1); exit 1; }; }
 
 fi
-echo "$as_me:1210: result: $ac_cv_host" >&5
+echo "$as_me:$LINENO: result: $ac_cv_host" >&5
 echo "${ECHO_T}$ac_cv_host" >&6
 host=$ac_cv_host
 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 
-test -z "$host_alias" &&
-  host_alias=$ac_cv_host
 
-echo "$as_me:1220: checking target system type" >&5
+echo "$as_me:$LINENO: checking target system type" >&5
 echo $ECHO_N "checking target system type... $ECHO_C" >&6
 if test "${ac_cv_target+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1226,26 +1452,25 @@
 test "x$ac_cv_target_alias" = "x" &&
   ac_cv_target_alias=$ac_cv_host_alias
 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
-  { { echo "$as_me:1229: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
    { (exit 1); exit 1; }; }
 
 fi
-echo "$as_me:1234: result: $ac_cv_target" >&5
+echo "$as_me:$LINENO: result: $ac_cv_target" >&5
 echo "${ECHO_T}$ac_cv_target" >&6
 target=$ac_cv_target
 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 
+
 # The aliases save the names the user supplied, while $host etc.
 # will get canonicalized.
 test -n "$target_alias" &&
   test "$program_prefix$program_suffix$program_transform_name" = \
     NONENONEs,x,x, &&
   program_prefix=${target_alias}-
-test -z "$target_alias" &&
-  target_alias=$ac_cv_target
 
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
@@ -1255,7 +1480,7 @@
 if test -n "$ac_tool_prefix"; then
   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
 set dummy ${ac_tool_prefix}gcc; ac_word=$2
-echo "$as_me:1258: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_CC+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1263,25 +1488,28 @@
   if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_CC="${ac_tool_prefix}gcc"
-echo "$as_me:1273: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
 done
 
 fi
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:1281: result: $CC" >&5
+  echo "$as_me:$LINENO: result: $CC" >&5
 echo "${ECHO_T}$CC" >&6
 else
-  echo "$as_me:1284: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -1290,7 +1518,7 @@
   ac_ct_CC=$CC
   # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
-echo "$as_me:1293: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1298,25 +1526,28 @@
   if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_ac_ct_CC="gcc"
-echo "$as_me:1308: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
 done
 
 fi
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
-  echo "$as_me:1316: result: $ac_ct_CC" >&5
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 echo "${ECHO_T}$ac_ct_CC" >&6
 else
-  echo "$as_me:1319: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -1329,7 +1560,7 @@
   if test -n "$ac_tool_prefix"; then
   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
 set dummy ${ac_tool_prefix}cc; ac_word=$2
-echo "$as_me:1332: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_CC+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1337,25 +1568,28 @@
   if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_CC="${ac_tool_prefix}cc"
-echo "$as_me:1347: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
 done
 
 fi
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:1355: result: $CC" >&5
+  echo "$as_me:$LINENO: result: $CC" >&5
 echo "${ECHO_T}$CC" >&6
 else
-  echo "$as_me:1358: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -1364,7 +1598,7 @@
   ac_ct_CC=$CC
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
-echo "$as_me:1367: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1372,25 +1606,28 @@
   if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_ac_ct_CC="cc"
-echo "$as_me:1382: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
 done
 
 fi
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
-  echo "$as_me:1390: result: $ac_ct_CC" >&5
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 echo "${ECHO_T}$ac_ct_CC" >&6
 else
-  echo "$as_me:1393: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -1403,7 +1640,7 @@
 if test -z "$CC"; then
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
-echo "$as_me:1406: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_CC+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1412,20 +1649,23 @@
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
   ac_prog_rejected=no
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
-  ac_prog_rejected=yes
-  continue
-fi
-ac_cv_prog_CC="cc"
-echo "$as_me:1426: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
 if test $ac_prog_rejected = yes; then
   # We found a bogon in the path, so make sure we never use it.
@@ -1436,7 +1676,7 @@
     # However, it has the same basename, so the bogon will be chosen
     # first if we set CC to just the basename; use the full file name.
     shift
-    set dummy "$ac_dir/$ac_word" ${1+"$@"}
+    set dummy "$as_dir/$ac_word" ${1+"$@"}
     shift
     ac_cv_prog_CC="$@"
   fi
@@ -1445,10 +1685,10 @@
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:1448: result: $CC" >&5
+  echo "$as_me:$LINENO: result: $CC" >&5
 echo "${ECHO_T}$CC" >&6
 else
-  echo "$as_me:1451: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -1459,7 +1699,7 @@
   do
     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-echo "$as_me:1462: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_CC+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1467,25 +1707,28 @@
   if test -n "$CC"; then
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
-echo "$as_me:1477: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
 fi
 fi
 CC=$ac_cv_prog_CC
 if test -n "$CC"; then
-  echo "$as_me:1485: result: $CC" >&5
+  echo "$as_me:$LINENO: result: $CC" >&5
 echo "${ECHO_T}$CC" >&6
 else
-  echo "$as_me:1488: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -1498,7 +1741,7 @@
 do
   # Extract the first word of "$ac_prog", so it can be a program name with args.
 set dummy $ac_prog; ac_word=$2
-echo "$as_me:1501: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -1506,25 +1749,28 @@
   if test -n "$ac_ct_CC"; then
   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_ac_ct_CC="$ac_prog"
-echo "$as_me:1516: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
 fi
 fi
 ac_ct_CC=$ac_cv_prog_ac_ct_CC
 if test -n "$ac_ct_CC"; then
-  echo "$as_me:1524: result: $ac_ct_CC" >&5
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 echo "${ECHO_T}$ac_ct_CC" >&6
 else
-  echo "$as_me:1527: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -1535,35 +1781,42 @@
 fi
 
 fi
+
 
-test -z "$CC" && { { echo "$as_me:1539: error: no acceptable cc found in \$PATH" >&5
-echo "$as_me: error: no acceptable cc found in \$PATH" >&2;}
+test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH" >&5
+echo "$as_me: error: no acceptable C compiler found in \$PATH" >&2;}
    { (exit 1); exit 1; }; }
 
 # Provide some information about the compiler.
-echo "$as_me:1544:" \
+echo "$as_me:$LINENO:" \
      "checking for C compiler version" >&5
 ac_compiler=`set X $ac_compile; echo $2`
-{ (eval echo "$as_me:1547: \"$ac_compiler --version </dev/null >&5\"") >&5
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
   (eval $ac_compiler --version </dev/null >&5) 2>&5
   ac_status=$?
-  echo "$as_me:1550: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
-{ (eval echo "$as_me:1552: \"$ac_compiler -v </dev/null >&5\"") >&5
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
   (eval $ac_compiler -v </dev/null >&5) 2>&5
   ac_status=$?
-  echo "$as_me:1555: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
-{ (eval echo "$as_me:1557: \"$ac_compiler -V </dev/null >&5\"") >&5
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
   (eval $ac_compiler -V </dev/null >&5) 2>&5
   ac_status=$?
-  echo "$as_me:1560: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
 
 cat >conftest.$ac_ext <<_ACEOF
-#line 1564 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -1577,22 +1830,26 @@
 # Try to create an executable without -o first, disregard a.out.
 # It will help us diagnose broken compilers, and finding out an intuition
 # of exeext.
-echo "$as_me:1580: checking for C compiler default output" >&5
+echo "$as_me:$LINENO: checking for C compiler default output" >&5
 echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-if { (eval echo "$as_me:1583: \"$ac_link_default\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
   (eval $ac_link_default) 2>&5
   ac_status=$?
-  echo "$as_me:1586: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
   # Find the output, starting from the most likely.  This scheme is
 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
 # resort.
-for ac_file in `ls a.exe conftest.exe 2>/dev/null;
+
+# Be careful to initialize this variable, since it used to be cached.
+# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+ac_cv_exeext=
+for ac_file in `ls a_out.exe a.exe conftest.exe 2>/dev/null;
                 ls a.out conftest 2>/dev/null;
                 ls a.* conftest.* 2>/dev/null`; do
   case $ac_file in
-    *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;;
+    *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb | *.xSYM ) ;;
     a.out ) # We found the default executable, but exeext='' is most
             # certainly right.
             break;;
@@ -1606,34 +1863,34 @@
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-{ { echo "$as_me:1609: error: C compiler cannot create executables" >&5
+{ { echo "$as_me:$LINENO: error: C compiler cannot create executables" >&5
 echo "$as_me: error: C compiler cannot create executables" >&2;}
    { (exit 77); exit 77; }; }
 fi
 
 ac_exeext=$ac_cv_exeext
-echo "$as_me:1615: result: $ac_file" >&5
+echo "$as_me:$LINENO: result: $ac_file" >&5
 echo "${ECHO_T}$ac_file" >&6
 
 # Check the compiler produces executables we can run.  If not, either
 # the compiler is broken, or we cross compile.
-echo "$as_me:1620: checking whether the C compiler works" >&5
+echo "$as_me:$LINENO: checking whether the C compiler works" >&5
 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
 # If not cross compiling, check that we can run a simple program.
 if test "$cross_compiling" != yes; then
   if { ac_try='./$ac_file'
-  { (eval echo "$as_me:1626: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:1629: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
     cross_compiling=no
   else
     if test "$cross_compiling" = maybe; then
 	cross_compiling=yes
     else
-	{ { echo "$as_me:1636: error: cannot run C compiled programs.
+	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
 If you meant to cross compile, use \`--host'." >&5
 echo "$as_me: error: cannot run C compiled programs.
 If you meant to cross compile, use \`--host'." >&2;}
@@ -1641,24 +1898,24 @@
     fi
   fi
 fi
-echo "$as_me:1644: result: yes" >&5
+echo "$as_me:$LINENO: result: yes" >&5
 echo "${ECHO_T}yes" >&6
 
 rm -f a.out a.exe conftest$ac_cv_exeext
 ac_clean_files=$ac_clean_files_save
 # Check the compiler produces executables we can run.  If not, either
 # the compiler is broken, or we cross compile.
-echo "$as_me:1651: checking whether we are cross compiling" >&5
+echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
-echo "$as_me:1653: result: $cross_compiling" >&5
+echo "$as_me:$LINENO: result: $cross_compiling" >&5
 echo "${ECHO_T}$cross_compiling" >&6
 
-echo "$as_me:1656: checking for executable suffix" >&5
-echo $ECHO_N "checking for executable suffix... $ECHO_C" >&6
-if { (eval echo "$as_me:1658: \"$ac_link\"") >&5
+echo "$as_me:$LINENO: checking for suffix of executables" >&5
+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:1661: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
   # If both `conftest.exe' and `conftest' are `present' (well, observable)
 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
@@ -1674,27 +1931,33 @@
   esac
 done
 else
-  { { echo "$as_me:1677: error: cannot compute EXEEXT: cannot compile and link" >&5
-echo "$as_me: error: cannot compute EXEEXT: cannot compile and link" >&2;}
+  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link" >&5
+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link" >&2;}
    { (exit 1); exit 1; }; }
 fi
 
 rm -f conftest$ac_cv_exeext
-echo "$as_me:1683: result: $ac_cv_exeext" >&5
+echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
 echo "${ECHO_T}$ac_cv_exeext" >&6
 
 rm -f conftest.$ac_ext
 EXEEXT=$ac_cv_exeext
 ac_exeext=$EXEEXT
-echo "$as_me:1689: checking for object suffix" >&5
-echo $ECHO_N "checking for object suffix... $ECHO_C" >&6
+echo "$as_me:$LINENO: checking for suffix of object files" >&5
+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
 if test "${ac_cv_objext+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 1695 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -1704,10 +1967,10 @@
 }
 _ACEOF
 rm -f conftest.o conftest.obj
-if { (eval echo "$as_me:1707: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:1710: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
   case $ac_file in
@@ -1719,26 +1982,32 @@
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-{ { echo "$as_me:1722: error: cannot compute OBJEXT: cannot compile" >&5
-echo "$as_me: error: cannot compute OBJEXT: cannot compile" >&2;}
+{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile" >&5
+echo "$as_me: error: cannot compute suffix of object files: cannot compile" >&2;}
    { (exit 1); exit 1; }; }
 fi
 
 rm -f conftest.$ac_cv_objext conftest.$ac_ext
 fi
-echo "$as_me:1729: result: $ac_cv_objext" >&5
+echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
 echo "${ECHO_T}$ac_cv_objext" >&6
 OBJEXT=$ac_cv_objext
 ac_objext=$OBJEXT
-echo "$as_me:1733: checking whether we are using the GNU C compiler" >&5
+echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
 if test "${ac_cv_c_compiler_gnu+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 1739 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -1751,16 +2020,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1754: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:1757: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:1760: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:1763: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_compiler_gnu=yes
 else
@@ -1772,21 +2041,27 @@
 ac_cv_c_compiler_gnu=$ac_compiler_gnu
 
 fi
-echo "$as_me:1775: result: $ac_cv_c_compiler_gnu" >&5
+echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
 GCC=`test $ac_compiler_gnu = yes && echo yes`
 ac_test_CFLAGS=${CFLAGS+set}
 ac_save_CFLAGS=$CFLAGS
 CFLAGS="-g"
-echo "$as_me:1781: checking whether $CC accepts -g" >&5
+echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
 if test "${ac_cv_prog_cc_g+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 1787 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -1796,16 +2071,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1799: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:1802: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:1805: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:1808: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_prog_cc_g=yes
 else
@@ -1815,7 +2090,7 @@
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:1818: result: $ac_cv_prog_cc_g" >&5
+echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
 if test "$ac_test_CFLAGS" = set; then
   CFLAGS=$ac_save_CFLAGS
@@ -1842,16 +2117,16 @@
 #endif
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1845: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:1848: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:1851: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:1854: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   for ac_declaration in \
    ''\
@@ -1863,10 +2138,16 @@
    'void exit (int);'
 do
   cat >conftest.$ac_ext <<_ACEOF
-#line 1866 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 $ac_declaration
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -1876,16 +2157,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1879: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:1882: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:1885: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:1888: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   :
 else
@@ -1895,9 +2176,15 @@
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
   cat >conftest.$ac_ext <<_ACEOF
-#line 1898 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_declaration
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -1907,16 +2194,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:1910: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:1913: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:1916: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:1919: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   break
 else
@@ -1948,7 +2235,7 @@
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
-echo "$as_me:1951: checking how to run the C preprocessor" >&5
+echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
@@ -1969,18 +2256,18 @@
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp. "Syntax error" is here to catch this case.
   cat >conftest.$ac_ext <<_ACEOF
-#line 1972 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <assert.h>
                      Syntax error
 _ACEOF
-if { (eval echo "$as_me:1977: \"$ac_cpp conftest.$ac_ext\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:1983: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -2003,17 +2290,17 @@
   # OK, works on sane cases.  Now check whether non-existent headers
   # can be detected and how.
   cat >conftest.$ac_ext <<_ACEOF
-#line 2006 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <ac_nonexistent.h>
 _ACEOF
-if { (eval echo "$as_me:2010: \"$ac_cpp conftest.$ac_ext\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:2016: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -2050,7 +2337,7 @@
 else
   ac_cv_prog_CPP=$CPP
 fi
-echo "$as_me:2053: result: $CPP" >&5
+echo "$as_me:$LINENO: result: $CPP" >&5
 echo "${ECHO_T}$CPP" >&6
 ac_preproc_ok=false
 for ac_c_preproc_warn_flag in '' yes
@@ -2060,18 +2347,18 @@
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp. "Syntax error" is here to catch this case.
   cat >conftest.$ac_ext <<_ACEOF
-#line 2063 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <assert.h>
                      Syntax error
 _ACEOF
-if { (eval echo "$as_me:2068: \"$ac_cpp conftest.$ac_ext\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:2074: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -2094,17 +2381,17 @@
   # OK, works on sane cases.  Now check whether non-existent headers
   # can be detected and how.
   cat >conftest.$ac_ext <<_ACEOF
-#line 2097 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <ac_nonexistent.h>
 _ACEOF
-if { (eval echo "$as_me:2101: \"$ac_cpp conftest.$ac_ext\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:2107: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -2132,7 +2419,7 @@
 if $ac_preproc_ok; then
   :
 else
-  { { echo "$as_me:2135: error: C preprocessor \"$CPP\" fails sanity check" >&5
+  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check" >&5
 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check" >&2;}
    { (exit 1); exit 1; }; }
 fi
@@ -2143,6 +2430,7 @@
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
+
 if test "x$CC" = xgcc; then
   XX_CFLAGS="-Wall"
   XX_ANSIFLAGS="-pedantic -ansi"
@@ -2160,9 +2448,11 @@
   esac
 fi
 
+
+
 # Extract the first word of "rm", so it can be a program name with args.
 set dummy rm; ac_word=$2
-echo "$as_me:2165: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_RMF+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -2170,31 +2460,34 @@
   if test -n "$RMF"; then
   ac_cv_prog_RMF="$RMF" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_RMF="rm -f"
-echo "$as_me:2180: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RMF="rm -f"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
 fi
 fi
 RMF=$ac_cv_prog_RMF
 if test -n "$RMF"; then
-  echo "$as_me:2188: result: $RMF" >&5
+  echo "$as_me:$LINENO: result: $RMF" >&5
 echo "${ECHO_T}$RMF" >&6
 else
-  echo "$as_me:2191: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
 # Extract the first word of "rmdir", so it can be a program name with args.
 set dummy rmdir; ac_word=$2
-echo "$as_me:2197: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_RMDIR+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -2202,28 +2495,32 @@
   if test -n "$RMDIR"; then
   ac_cv_prog_RMDIR="$RMDIR" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_RMDIR="rmdir"
-echo "$as_me:2212: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RMDIR="rmdir"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
 fi
 fi
 RMDIR=$ac_cv_prog_RMDIR
 if test -n "$RMDIR"; then
-  echo "$as_me:2220: result: $RMDIR" >&5
+  echo "$as_me:$LINENO: result: $RMDIR" >&5
 echo "${ECHO_T}$RMDIR" >&6
 else
-  echo "$as_me:2223: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
+
 # Find a good install program.  We prefer a C program (faster),
 # so one script is as good as another.  But avoid the broken or
 # incompatible versions:
@@ -2236,46 +2533,51 @@
 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
-echo "$as_me:2239: checking for a BSD compatible install" >&5
-echo $ECHO_N "checking for a BSD compatible install... $ECHO_C" >&6
+echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
 if test -z "$INSTALL"; then
 if test "${ac_cv_path_install+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
-    ac_save_IFS=$IFS; IFS=$ac_path_separator
-  for ac_dir in $PATH; do
-    IFS=$ac_save_IFS
-    # Account for people who put trailing slashes in PATH elements.
-    case $ac_dir/ in
-    / | ./ | .// | /cC/* \
-    | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* \
-    | /usr/ucb/* ) ;;
-    *)
-      # OSF1 and SCO ODT 3.0 have their own names for install.
-      # Don't use installbsd from OSF since it installs stuff as root
-      # by default.
-      for ac_prog in ginstall scoinst install; do
-        if $as_executable_p "$ac_dir/$ac_prog"; then
-	  if test $ac_prog = install &&
-            grep dspmsg "$ac_dir/$ac_prog" >/dev/null 2>&1; then
-	    # AIX install.  It has an incompatible calling convention.
-	    :
-	  elif test $ac_prog = install &&
-	    grep pwplus "$ac_dir/$ac_prog" >/dev/null 2>&1; then
-	    # program-specific install script used by HP pwplus--don't use.
-	    :
-	  else
-	    ac_cv_path_install="$ac_dir/$ac_prog -c"
-	    break 2
-	  fi
-	fi
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in
+  ./ | .// | /cC/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+          if test $ac_prog = install &&
+            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+            # AIX install.  It has an incompatible calling convention.
+            :
+          elif test $ac_prog = install &&
+            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+            # program-specific install script used by HP pwplus--don't use.
+            :
+          else
+            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+            break 3
+          fi
+        fi
       done
-      ;;
-    esac
-  done
-
-fi
-  if test "${ac_cv_path_install+set}" = set; then
+    done
+    ;;
+esac
+done
+
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
     INSTALL=$ac_cv_path_install
   else
     # As a last resort, use the slow shell script.  We don't cache a
@@ -2285,7 +2587,7 @@
     INSTALL=$ac_install_sh
   fi
 fi
-echo "$as_me:2288: result: $INSTALL" >&5
+echo "$as_me:$LINENO: result: $INSTALL" >&5
 echo "${ECHO_T}$INSTALL" >&6
 
 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
@@ -2302,14 +2604,16 @@
   */*)
     INSTALL="`pwd`/$INSTALL" ;;
 esac
+
 
-echo "$as_me:2306: checking for ANSI C header files" >&5
+
+echo "$as_me:$LINENO: checking for ANSI C header files" >&5
 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
 if test "${ac_cv_header_stdc+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 2312 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 #include <stdarg.h>
@@ -2317,13 +2621,13 @@
 #include <float.h>
 
 _ACEOF
-if { (eval echo "$as_me:2320: \"$ac_cpp conftest.$ac_ext\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:2326: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -2345,7 +2649,7 @@
 if test $ac_cv_header_stdc = yes; then
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
   cat >conftest.$ac_ext <<_ACEOF
-#line 2348 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <string.h>
 
@@ -2363,7 +2667,7 @@
 if test $ac_cv_header_stdc = yes; then
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
   cat >conftest.$ac_ext <<_ACEOF
-#line 2366 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 
@@ -2384,7 +2688,7 @@
   :
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 2387 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <ctype.h>
 #if ((' ' & 0x0FF) == 0x020)
@@ -2410,57 +2714,156 @@
 }
 _ACEOF
 rm -f conftest$ac_exeext
-if { (eval echo "$as_me:2413: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:2416: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:2418: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2421: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   :
 else
   echo "$as_me: program exited with status $ac_status" >&5
 echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
+( exit $ac_status )
 ac_cv_header_stdc=no
 fi
 rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 fi
 fi
 fi
-echo "$as_me:2434: result: $ac_cv_header_stdc" >&5
+echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
 echo "${ECHO_T}$ac_cv_header_stdc" >&6
 if test $ac_cv_header_stdc = yes; then
 
-cat >>confdefs.h <<\EOF
+cat >>confdefs.h <<\_ACEOF
 #define STDC_HEADERS 1
-EOF
+_ACEOF
 
 fi
 
-for ac_header in fcntl.h unistd.h
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+
+
+
+
+
+
+
+
+
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+                  inttypes.h stdint.h unistd.h
 do
 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-echo "$as_me:2447: checking for $ac_header" >&5
+echo "$as_me:$LINENO: checking for $ac_header" >&5
 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 if eval "test \"\${$as_ac_Header+set}\" = set"; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 2453 "configure"
+#line $LINENO "configure"
+#include "confdefs.h"
+$ac_includes_default
+
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_Header=yes"
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+eval "$as_ac_Header=no"
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+
+
+for ac_header in fcntl.h unistd.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
 #include "confdefs.h"
+$ac_includes_default
 #include <$ac_header>
 _ACEOF
-if { (eval echo "$as_me:2457: \"$ac_cpp conftest.$ac_ext\"") >&5
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+ac_header_compiler=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
+#include <$ac_header>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:2463: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -2471,25 +2874,53 @@
   ac_cpp_err=yes
 fi
 if test -z "$ac_cpp_err"; then
-  eval "$as_ac_Header=yes"
+  ac_header_preproc=yes
 else
   echo "$as_me: failed program was:" >&5
   cat conftest.$ac_ext >&5
-  eval "$as_ac_Header=no"
+  ac_header_preproc=no
 fi
 rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc in
+  yes:no )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+  no:yes )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=$ac_header_preproc"
 fi
-echo "$as_me:2482: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
 if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<EOF
+  cat >>confdefs.h <<_ACEOF
 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-EOF
+_ACEOF
 
 fi
+
 done
+
 
-echo "$as_me:2492: checking for $CC option to accept ANSI C" >&5
+echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
 if test "${ac_cv_prog_cc_stdc+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -2497,7 +2928,7 @@
   ac_cv_prog_cc_stdc=no
 ac_save_CC=$CC
 cat >conftest.$ac_ext <<_ACEOF
-#line 2500 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 #include <stdarg.h>
 #include <stdio.h>
@@ -2527,6 +2958,12 @@
 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
 int argc;
 char **argv;
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -2546,16 +2983,16 @@
 do
   CC="$ac_save_CC $ac_arg"
   rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2549: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2552: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2555: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2558: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_prog_cc_stdc=$ac_arg
 break
@@ -2572,23 +3009,29 @@
 
 case "x$ac_cv_prog_cc_stdc" in
   x|xno)
-    echo "$as_me:2575: result: none needed" >&5
+    echo "$as_me:$LINENO: result: none needed" >&5
 echo "${ECHO_T}none needed" >&6 ;;
   *)
-    echo "$as_me:2578: result: $ac_cv_prog_cc_stdc" >&5
+    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
     CC="$CC $ac_cv_prog_cc_stdc" ;;
 esac
 
-echo "$as_me:2583: checking for an ANSI C-conforming const" >&5
+echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
 echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
 if test "${ac_cv_c_const+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 2589 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -2644,16 +3087,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2647: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2650: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2653: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2656: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_c_const=yes
 else
@@ -2663,72 +3106,31 @@
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:2666: result: $ac_cv_c_const" >&5
+echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
 echo "${ECHO_T}$ac_cv_c_const" >&6
 if test $ac_cv_c_const = no; then
 
-cat >>confdefs.h <<\EOF
+cat >>confdefs.h <<\_ACEOF
 #define const
-EOF
-
-fi
-
-# On IRIX 5.3, sys/types and inttypes.h are conflicting.
-
-for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
-                  inttypes.h stdint.h unistd.h
-do
-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-echo "$as_me:2682: checking for $ac_header" >&5
-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
-if eval "test \"\${$as_ac_Header+set}\" = set"; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  cat >conftest.$ac_ext <<_ACEOF
-#line 2688 "configure"
-#include "confdefs.h"
-$ac_includes_default
-#include <$ac_header>
 _ACEOF
-rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2694: \"$ac_compile\"") >&5
-  (eval $ac_compile) 2>&5
-  ac_status=$?
-  echo "$as_me:2697: \$? = $ac_status" >&5
-  (exit $ac_status); } &&
-         { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2700: \"$ac_try\"") >&5
-  (eval $ac_try) 2>&5
-  ac_status=$?
-  echo "$as_me:2703: \$? = $ac_status" >&5
-  (exit $ac_status); }; }; then
-  eval "$as_ac_Header=yes"
-else
-  echo "$as_me: failed program was:" >&5
-cat conftest.$ac_ext >&5
-eval "$as_ac_Header=no"
-fi
-rm -f conftest.$ac_objext conftest.$ac_ext
-fi
-echo "$as_me:2713: result: `eval echo '${'$as_ac_Header'}'`" >&5
-echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
-if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<EOF
-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-EOF
 
 fi
-done
 
-echo "$as_me:2723: checking for int" >&5
+echo "$as_me:$LINENO: checking for int" >&5
 echo $ECHO_N "checking for int... $ECHO_C" >&6
 if test "${ac_cv_type_int+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 2729 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -2741,16 +3143,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2744: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2747: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2750: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2753: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_type_int=yes
 else
@@ -2760,188 +3162,306 @@
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:2763: result: $ac_cv_type_int" >&5
+echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5
 echo "${ECHO_T}$ac_cv_type_int" >&6
 
-echo "$as_me:2766: checking size of int" >&5
+echo "$as_me:$LINENO: checking size of int" >&5
 echo $ECHO_N "checking size of int... $ECHO_C" >&6
 if test "${ac_cv_sizeof_int+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   if test "$ac_cv_type_int" = yes; then
+  # The cast to unsigned long works around a bug in the HP C Compiler
+  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+  # This bug is HP SR number 8606223364.
   if test "$cross_compiling" = yes; then
   # Depending upon the size, compute the lo and hi bounds.
 cat >conftest.$ac_ext <<_ACEOF
-#line 2775 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (int)) >= 0)]
+static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2787: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2790: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2793: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2796: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_lo=0 ac_mid=0
   while :; do
     cat >conftest.$ac_ext <<_ACEOF
-#line 2801 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (int)) <= $ac_mid)]
+static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2813: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2816: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2819: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2822: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_hi=$ac_mid; break
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_lo=`expr $ac_mid + 1`; ac_mid=`expr 2 '*' $ac_mid + 1`
+ac_lo=`expr $ac_mid + 1`
+                    if test $ac_lo -le $ac_mid; then
+                      ac_lo= ac_hi=
+                      break
+                    fi
+                    ac_mid=`expr 2 '*' $ac_mid + 1`
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
   done
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_hi=-1 ac_mid=-1
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
+$ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
+int
+main ()
+{
+static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)];
+test_array [0] = 0
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_hi=-1 ac_mid=-1
   while :; do
     cat >conftest.$ac_ext <<_ACEOF
-#line 2838 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (int)) >= $ac_mid)]
+static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2850: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2853: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2856: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2859: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_lo=$ac_mid; break
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_hi=`expr $ac_mid - 1`; ac_mid=`expr 2 '*' $ac_mid`
+ac_hi=`expr '(' $ac_mid ')' - 1`
+                       if test $ac_mid -le $ac_hi; then
+                         ac_lo= ac_hi=
+                         break
+                       fi
+                       ac_mid=`expr 2 '*' $ac_mid`
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
   done
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+ac_lo= ac_hi=
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 # Binary search between lo and hi bounds.
 while test "x$ac_lo" != "x$ac_hi"; do
   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
   cat >conftest.$ac_ext <<_ACEOF
-#line 2875 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (int)) <= $ac_mid)]
+static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2887: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2890: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2893: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2896: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_hi=$ac_mid
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_lo=`expr $ac_mid + 1`
+ac_lo=`expr '(' $ac_mid ')' + 1`
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 done
-ac_cv_sizeof_int=$ac_lo
+case $ac_lo in
+?*) ac_cv_sizeof_int=$ac_lo;;
+'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77" >&5
+echo "$as_me: error: cannot compute sizeof (int), 77" >&2;}
+   { (exit 1); exit 1; }; } ;;
+esac
 else
   if test "$cross_compiling" = yes; then
-  { { echo "$as_me:2909: error: cannot run test program while cross compiling" >&5
+  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 echo "$as_me: error: cannot run test program while cross compiling" >&2;}
    { (exit 1); exit 1; }; }
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 2914 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+long longval () { return (long) (sizeof (int)); }
+unsigned long ulongval () { return (long) (sizeof (int)); }
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-FILE *f = fopen ("conftest.val", "w");
-if (!f)
-  exit (1);
-fprintf (f, "%d", (sizeof (int)));
-fclose (f);
+
+  FILE *f = fopen ("conftest.val", "w");
+  if (! f)
+    exit (1);
+  if (((long) (sizeof (int))) < 0)
+    {
+      long i = longval ();
+      if (i != ((long) (sizeof (int))))
+	exit (1);
+      fprintf (f, "%ld\n", i);
+    }
+  else
+    {
+      unsigned long i = ulongval ();
+      if (i != ((long) (sizeof (int))))
+	exit (1);
+      fprintf (f, "%lu\n", i);
+    }
+  exit (ferror (f) || fclose (f) != 0);
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest$ac_exeext
-if { (eval echo "$as_me:2930: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:2933: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:2935: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2938: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_sizeof_int=`cat conftest.val`
 else
   echo "$as_me: program exited with status $ac_status" >&5
 echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
+( exit $ac_status )
+{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77" >&5
+echo "$as_me: error: cannot compute sizeof (int), 77" >&2;}
+   { (exit 1); exit 1; }; }
 fi
 rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 fi
@@ -2951,21 +3471,28 @@
   ac_cv_sizeof_int=0
 fi
 fi
-echo "$as_me:2954: result: $ac_cv_sizeof_int" >&5
+echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5
 echo "${ECHO_T}$ac_cv_sizeof_int" >&6
-cat >>confdefs.h <<EOF
+cat >>confdefs.h <<_ACEOF
 #define SIZEOF_INT $ac_cv_sizeof_int
-EOF
+_ACEOF
+
 
-echo "$as_me:2960: checking for long" >&5
+echo "$as_me:$LINENO: checking for long" >&5
 echo $ECHO_N "checking for long... $ECHO_C" >&6
 if test "${ac_cv_type_long+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 2966 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -2978,16 +3505,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:2981: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:2984: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:2987: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:2990: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_type_long=yes
 else
@@ -2997,188 +3524,306 @@
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 fi
-echo "$as_me:3000: result: $ac_cv_type_long" >&5
+echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5
 echo "${ECHO_T}$ac_cv_type_long" >&6
 
-echo "$as_me:3003: checking size of long" >&5
+echo "$as_me:$LINENO: checking size of long" >&5
 echo $ECHO_N "checking size of long... $ECHO_C" >&6
 if test "${ac_cv_sizeof_long+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   if test "$ac_cv_type_long" = yes; then
+  # The cast to unsigned long works around a bug in the HP C Compiler
+  # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+  # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
+  # This bug is HP SR number 8606223364.
   if test "$cross_compiling" = yes; then
   # Depending upon the size, compute the lo and hi bounds.
 cat >conftest.$ac_ext <<_ACEOF
-#line 3012 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (long)) >= 0)]
+static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:3024: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:3027: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:3030: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3033: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_lo=0 ac_mid=0
   while :; do
     cat >conftest.$ac_ext <<_ACEOF
-#line 3038 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (long)) <= $ac_mid)]
+static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:3050: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:3053: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:3056: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3059: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_hi=$ac_mid; break
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_lo=`expr $ac_mid + 1`; ac_mid=`expr 2 '*' $ac_mid + 1`
+ac_lo=`expr $ac_mid + 1`
+                    if test $ac_lo -le $ac_mid; then
+                      ac_lo= ac_hi=
+                      break
+                    fi
+                    ac_mid=`expr 2 '*' $ac_mid + 1`
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
   done
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_hi=-1 ac_mid=-1
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
+$ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
+int
+main ()
+{
+static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];
+test_array [0] = 0
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_hi=-1 ac_mid=-1
   while :; do
     cat >conftest.$ac_ext <<_ACEOF
-#line 3075 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (long)) >= $ac_mid)]
+static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:3087: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:3090: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:3093: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3096: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_lo=$ac_mid; break
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_hi=`expr $ac_mid - 1`; ac_mid=`expr 2 '*' $ac_mid`
+ac_hi=`expr '(' $ac_mid ')' - 1`
+                       if test $ac_mid -le $ac_hi; then
+                         ac_lo= ac_hi=
+                         break
+                       fi
+                       ac_mid=`expr 2 '*' $ac_mid`
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
   done
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+ac_lo= ac_hi=
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
 # Binary search between lo and hi bounds.
 while test "x$ac_lo" != "x$ac_hi"; do
   ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`
   cat >conftest.$ac_ext <<_ACEOF
-#line 3112 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-int _array_ [1 - 2 * !((sizeof (long)) <= $ac_mid)]
+static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];
+test_array [0] = 0
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:3124: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:3127: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:3130: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3133: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_hi=$ac_mid
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_lo=`expr $ac_mid + 1`
+ac_lo=`expr '(' $ac_mid ')' + 1`
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 done
-ac_cv_sizeof_long=$ac_lo
+case $ac_lo in
+?*) ac_cv_sizeof_long=$ac_lo;;
+'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77" >&5
+echo "$as_me: error: cannot compute sizeof (long), 77" >&2;}
+   { (exit 1); exit 1; }; } ;;
+esac
 else
   if test "$cross_compiling" = yes; then
-  { { echo "$as_me:3146: error: cannot run test program while cross compiling" >&5
+  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling" >&5
 echo "$as_me: error: cannot run test program while cross compiling" >&2;}
    { (exit 1); exit 1; }; }
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 3151 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+long longval () { return (long) (sizeof (long)); }
+unsigned long ulongval () { return (long) (sizeof (long)); }
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-FILE *f = fopen ("conftest.val", "w");
-if (!f)
-  exit (1);
-fprintf (f, "%d", (sizeof (long)));
-fclose (f);
+
+  FILE *f = fopen ("conftest.val", "w");
+  if (! f)
+    exit (1);
+  if (((long) (sizeof (long))) < 0)
+    {
+      long i = longval ();
+      if (i != ((long) (sizeof (long))))
+	exit (1);
+      fprintf (f, "%ld\n", i);
+    }
+  else
+    {
+      unsigned long i = ulongval ();
+      if (i != ((long) (sizeof (long))))
+	exit (1);
+      fprintf (f, "%lu\n", i);
+    }
+  exit (ferror (f) || fclose (f) != 0);
+
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest$ac_exeext
-if { (eval echo "$as_me:3167: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:3170: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:3172: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3175: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_sizeof_long=`cat conftest.val`
 else
   echo "$as_me: program exited with status $ac_status" >&5
 echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
+( exit $ac_status )
+{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77" >&5
+echo "$as_me: error: cannot compute sizeof (long), 77" >&2;}
+   { (exit 1); exit 1; }; }
 fi
 rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 fi
@@ -3188,32 +3833,75 @@
   ac_cv_sizeof_long=0
 fi
 fi
-echo "$as_me:3191: result: $ac_cv_sizeof_long" >&5
+echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5
 echo "${ECHO_T}$ac_cv_sizeof_long" >&6
-cat >>confdefs.h <<EOF
+cat >>confdefs.h <<_ACEOF
 #define SIZEOF_LONG $ac_cv_sizeof_long
-EOF
+_ACEOF
+
+
+
 
+
+
 for ac_header in stdlib.h unistd.h
 do
 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-echo "$as_me:3200: checking for $ac_header" >&5
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 if eval "test \"\${$as_ac_Header+set}\" = set"; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-#line 3206 "configure"
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
 #include "confdefs.h"
+$ac_includes_default
 #include <$ac_header>
 _ACEOF
-if { (eval echo "$as_me:3210: \"$ac_cpp conftest.$ac_ext\"") >&5
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+ac_header_compiler=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
+#include <$ac_header>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:3216: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -3224,34 +3912,62 @@
   ac_cpp_err=yes
 fi
 if test -z "$ac_cpp_err"; then
-  eval "$as_ac_Header=yes"
+  ac_header_preproc=yes
 else
   echo "$as_me: failed program was:" >&5
   cat conftest.$ac_ext >&5
-  eval "$as_ac_Header=no"
+  ac_header_preproc=no
 fi
 rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc in
+  yes:no )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+  no:yes )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=$ac_header_preproc"
 fi
-echo "$as_me:3235: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
 if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<EOF
+  cat >>confdefs.h <<_ACEOF
 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-EOF
+_ACEOF
 
 fi
+
 done
 
+
 for ac_func in getpagesize
 do
 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:3248: checking for $ac_func" >&5
+echo "$as_me:$LINENO: checking for $ac_func" >&5
 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 if eval "test \"\${$as_ac_var+set}\" = set"; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 3254 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func (); below.  */
@@ -3265,6 +3981,12 @@
 char $ac_func ();
 char (*f) ();
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -3282,16 +4004,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:3285: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:3288: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:3291: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3294: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   eval "$as_ac_var=yes"
 else
@@ -3301,17 +4023,17 @@
 fi
 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:3304: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<EOF
+  cat >>confdefs.h <<_ACEOF
 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-EOF
+_ACEOF
 
 fi
 done
 
-echo "$as_me:3314: checking for working mmap" >&5
+echo "$as_me:$LINENO: checking for working mmap" >&5
 echo $ECHO_N "checking for working mmap... $ECHO_C" >&6
 if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -3320,9 +4042,12 @@
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 3323 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 $ac_includes_default
+/* malloc might have been renamed as rpl_malloc. */
+#undef malloc
+
 /* Thanks to Mike Haertel and Jim Avera for this test.
    Here is a matrix of mmap possibilities:
 	mmap private not fixed
@@ -3338,7 +4063,7 @@
    VM page cache was not coherent with the file system buffer cache
    like early versions of FreeBSD and possibly contemporary NetBSD.)
    For shared mappings, we should conversely verify that changes get
-   propogated back to all the places they're supposed to be.
+   propagated back to all the places they're supposed to be.
 
    Grep wants private fixed already mapped.
    The main things grep needs to know about mmap are:
@@ -3447,33 +4172,34 @@
 }
 _ACEOF
 rm -f conftest$ac_exeext
-if { (eval echo "$as_me:3450: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:3453: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
-  { (eval echo "$as_me:3455: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3458: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_func_mmap_fixed_mapped=yes
 else
   echo "$as_me: program exited with status $ac_status" >&5
 echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
+( exit $ac_status )
 ac_cv_func_mmap_fixed_mapped=no
 fi
 rm -f core core.* *.core conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 fi
 fi
-echo "$as_me:3470: result: $ac_cv_func_mmap_fixed_mapped" >&5
+echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5
 echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6
 if test $ac_cv_func_mmap_fixed_mapped = yes; then
 
-cat >>confdefs.h <<\EOF
+cat >>confdefs.h <<\_ACEOF
 #define HAVE_MMAP 1
-EOF
+_ACEOF
 
 fi
 rm -f conftest.mmap
@@ -3483,19 +4209,25 @@
 else
   FTSYS_SRC='$(BUILD)/ftsystem.c'
 
-  echo "$as_me:3486: checking whether munmap must be declared" >&5
+  echo "$as_me:$LINENO: checking whether munmap must be declared" >&5
 echo $ECHO_N "checking whether munmap must be declared... $ECHO_C" >&6
 if test "${ft_cv_munmap_decl+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 3492 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <sys/mman.h>
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -3505,16 +4237,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:3508: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:3511: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:3514: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3517: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ft_cv_munmap_decl=no
 else
@@ -3525,23 +4257,29 @@
 rm -f conftest.$ac_objext conftest.$ac_ext
 fi
 
-echo "$as_me:3528: result: $ft_cv_munmap_decl" >&5
+echo "$as_me:$LINENO: result: $ft_cv_munmap_decl" >&5
 echo "${ECHO_T}$ft_cv_munmap_decl" >&6
 if test $ft_cv_munmap_decl = yes; then
-	cat >>confdefs.h <<\EOF
+	cat >>confdefs.h <<\_ACEOF
 #define NEED_MUNMAP_DECL 1
-EOF
+_ACEOF
 
 fi
-  echo "$as_me:3536: checking for munmap's first parameter type" >&5
+  echo "$as_me:$LINENO: checking for munmap's first parameter type" >&5
 echo $ECHO_N "checking for munmap's first parameter type... $ECHO_C" >&6
 cat >conftest.$ac_ext <<_ACEOF
-#line 3539 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
 #include <unistd.h>
 #include <sys/mman.h>
 int munmap(void *, size_t);
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -3551,42 +4289,45 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:3554: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:3557: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:3560: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3563: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
-  echo "$as_me:3565: result: void *" >&5
-echo "${ECHO_T}void *" >&6;cat >>confdefs.h <<\EOF
+  echo "$as_me:$LINENO: result: void *" >&5
+echo "${ECHO_T}void *" >&6;cat >>confdefs.h <<\_ACEOF
 #define MUNMAP_USES_VOIDP 1
-EOF
+_ACEOF
 
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-echo "$as_me:3573: result: char *" >&5
+echo "$as_me:$LINENO: result: char *" >&5
 echo "${ECHO_T}char *" >&6
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
 
 fi
 
+
+
+
 for ac_func in memcpy memmove
 do
 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
-echo "$as_me:3583: checking for $ac_func" >&5
+echo "$as_me:$LINENO: checking for $ac_func" >&5
 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
 if eval "test \"\${$as_ac_var+set}\" = set"; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 3589 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func (); below.  */
@@ -3600,6 +4341,12 @@
 char $ac_func ();
 char (*f) ();
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -3617,16 +4364,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:3620: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:3623: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:3626: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:3629: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   eval "$as_ac_var=yes"
 else
@@ -3636,16 +4383,17 @@
 fi
 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:3639: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
 if test `eval echo '${'$as_ac_var'}'` = yes; then
-  cat >>confdefs.h <<EOF
+  cat >>confdefs.h <<_ACEOF
 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
-EOF
+_ACEOF
 
 fi
 done
 
+
 # Check whether --enable-shared or --disable-shared was given.
 if test "${enable_shared+set}" = set; then
   enableval="$enable_shared"
@@ -3712,6 +4460,17 @@
 else
   enable_fast_install=yes
 fi;
+# Find the correct PATH separator.  Usually this is `:', but
+# DJGPP uses `;' like DOS.
+if test "X${PATH_SEPARATOR+set}" != Xset; then
+  UNAME=${UNAME-`uname 2>/dev/null`}
+  case X$UNAME in
+    *-DOS) lt_cv_sys_path_separator=';' ;;
+    *)     lt_cv_sys_path_separator=':' ;;
+  esac
+  PATH_SEPARATOR=$lt_cv_sys_path_separator
+fi
+
 
 # Check whether --with-gnu-ld or --without-gnu-ld was given.
 if test "${with_gnu_ld+set}" = set; then
@@ -3723,7 +4482,7 @@
 ac_prog=ld
 if test "$GCC" = yes; then
   # Check if gcc -print-prog-name=ld gives a path.
-  echo "$as_me:3726: checking for ld used by GCC" >&5
+  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
 echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
   case $host in
   *-*-mingw*)
@@ -3753,17 +4512,17 @@
     ;;
   esac
 elif test "$with_gnu_ld" = yes; then
-  echo "$as_me:3756: checking for GNU ld" >&5
+  echo "$as_me:$LINENO: checking for GNU ld" >&5
 echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
 else
-  echo "$as_me:3759: checking for non-GNU ld" >&5
+  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
 echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
 fi
 if test "${lt_cv_path_LD+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   if test -z "$LD"; then
-  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH; do
     test -z "$ac_dir" && ac_dir=.
     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
@@ -3786,16 +4545,16 @@
 
 LD="$lt_cv_path_LD"
 if test -n "$LD"; then
-  echo "$as_me:3789: result: $LD" >&5
+  echo "$as_me:$LINENO: result: $LD" >&5
 echo "${ECHO_T}$LD" >&6
 else
-  echo "$as_me:3792: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
-test -z "$LD" && { { echo "$as_me:3795: error: no acceptable ld found in \$PATH" >&5
+test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
 echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
    { (exit 1); exit 1; }; }
-echo "$as_me:3798: checking if the linker ($LD) is GNU ld" >&5
+echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
 echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
 if test "${lt_cv_prog_gnu_ld+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -3807,23 +4566,24 @@
   lt_cv_prog_gnu_ld=no
 fi
 fi
-echo "$as_me:3810: result: $lt_cv_prog_gnu_ld" >&5
+echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
 echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
 with_gnu_ld=$lt_cv_prog_gnu_ld
 
-echo "$as_me:3814: checking for $LD option to reload object files" >&5
+
+echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
 echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
 if test "${lt_cv_ld_reload_flag+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   lt_cv_ld_reload_flag='-r'
 fi
-echo "$as_me:3821: result: $lt_cv_ld_reload_flag" >&5
+echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
 echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
 reload_flag=$lt_cv_ld_reload_flag
 test -n "$reload_flag" && reload_flag=" $reload_flag"
 
-echo "$as_me:3826: checking for BSD-compatible nm" >&5
+echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
 echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
 if test "${lt_cv_path_NM+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -3832,7 +4592,7 @@
   # Let the user override the test.
   lt_cv_path_NM="$NM"
 else
-  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
     test -z "$ac_dir" && ac_dir=.
     tmp_nm=$ac_dir/${ac_tool_prefix}nm
@@ -3859,21 +4619,21 @@
 fi
 
 NM="$lt_cv_path_NM"
-echo "$as_me:3862: result: $NM" >&5
+echo "$as_me:$LINENO: result: $NM" >&5
 echo "${ECHO_T}$NM" >&6
 
-echo "$as_me:3865: checking whether ln -s works" >&5
+echo "$as_me:$LINENO: checking whether ln -s works" >&5
 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
 LN_S=$as_ln_s
 if test "$LN_S" = "ln -s"; then
-  echo "$as_me:3869: result: yes" >&5
+  echo "$as_me:$LINENO: result: yes" >&5
 echo "${ECHO_T}yes" >&6
 else
-  echo "$as_me:3872: result: no, using $LN_S" >&5
+  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
 echo "${ECHO_T}no, using $LN_S" >&6
 fi
 
-echo "$as_me:3876: checking how to recognise dependant libraries" >&5
+echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
 echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
 if test "${lt_cv_deplibs_check_method+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -3887,7 +4647,7 @@
 # `unknown' -- same as none, but documents that we really don't know.
 # 'pass_all' -- all dependencies passed with no checks.
 # 'test_compile' -- check by making test program.
-# ['file_magic [regex]'] -- check by looking for files in library path
+# 'file_magic [[regex]]' -- check by looking for files in library path
 # which responds to the $file_magic_cmd with a given egrep regex.
 # If you have `file' or equivalent on your system and you're not sure
 # whether `pass_all' will *always* work, you probably want this one.
@@ -3916,7 +4676,7 @@
   lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
   lt_cv_file_magic_cmd='/usr/bin/file -L'
   case "$host_os" in
-  rhapsody* | darwin1.012)
+  rhapsody* | darwin1.[012])
     lt_cv_file_magic_test_file=`echo /System/Library/Frameworks/System.framework/Versions/*/System | head -1`
     ;;
   *) # Darwin 1.3 on
@@ -3975,7 +4735,7 @@
 # This must be Linux ELF.
 linux-gnu*)
   case $host_cpu in
-  alpha* | i*86 | powerpc* | sparc* | ia64* )
+  alpha* | hppa* | i*86 | powerpc* | sparc* | ia64* )
     lt_cv_deplibs_check_method=pass_all ;;
   *)
     # glibc up to 2.1.1 does not perform some relocations on ARM
@@ -3998,6 +4758,16 @@
   lt_cv_file_magic_test_file=/usr/lib/libnls.so
   ;;
 
+openbsd*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
+  else
+    lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library'
+  fi
+  ;;
+
 osf3* | osf4* | osf5*)
   # this will be overridden with pass_all, but let us keep it just in case
   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
@@ -4041,13 +4811,19 @@
 esac
 
 fi
-echo "$as_me:4044: result: $lt_cv_deplibs_check_method" >&5
+echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
 echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
 file_magic_cmd=$lt_cv_file_magic_cmd
 deplibs_check_method=$lt_cv_deplibs_check_method
 
+
+
+
+
+
+
 # Check for command to grab the raw symbol name followed by C symbol from nm.
-echo "$as_me:4050: checking command to parse $NM output" >&5
+echo "$as_me:$LINENO: checking command to parse $NM output" >&5
 echo $ECHO_N "checking command to parse $NM output... $ECHO_C" >&6
 if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4068,6 +4844,9 @@
 # Transform an extracted symbol line into a proper C declaration
 lt_cv_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern char \1;/p'"
 
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+
 # Define system-specific variables.
 case $host_os in
 aix*)
@@ -4078,6 +4857,7 @@
   ;;
 hpux*) # Its linker distinguishes data from code symbols
   lt_cv_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern char \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+  lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
   ;;
 irix*)
   symcode='[BCDEGRST]'
@@ -4124,17 +4904,17 @@
 int main(){nm_test_var='a';nm_test_func();return(0);}
 EOF
 
-  if { (eval echo "$as_me:4127: \"$ac_compile\"") >&5
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:4130: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
     # Now try to grab the symbols.
     nlist=conftest.nm
-    if { (eval echo "$as_me:4134: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
+    if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
   (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5
   ac_status=$?
-  echo "$as_me:4137: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && test -s "$nlist"; then
       # Try sorting and uniquifying the output.
       if sort "$nlist" | uniq > "$nlist"T; then
@@ -4157,23 +4937,23 @@
 
 	  cat <<EOF >> conftest.$ac_ext
 #if defined (__STDC__) && __STDC__
-# define lt_ptr_t void *
+# define lt_ptr void *
 #else
-# define lt_ptr_t char *
+# define lt_ptr char *
 # define const
 #endif
 
 /* The mapping between symbol names and symbols. */
 const struct {
   const char *name;
-  lt_ptr_t address;
+  lt_ptr address;
 }
 lt_preloaded_symbols[] =
 {
 EOF
-	  sed "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" >> conftest.$ac_ext
+	  sed "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr) \&\2},/" < "$nlist" >> conftest.$ac_ext
 	  cat <<\EOF >> conftest.$ac_ext
-  {0, (lt_ptr_t) 0}
+  {0, (lt_ptr) 0}
 };
 
 #ifdef __cplusplus
@@ -4186,10 +4966,10 @@
 	  save_CFLAGS="$CFLAGS"
 	  LIBS="conftstm.$ac_objext"
 	  CFLAGS="$CFLAGS$no_builtin_flag"
-	  if { (eval echo "$as_me:4189: \"$ac_link\"") >&5
+	  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:4192: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && test -s conftest; then
 	    pipe_works=yes
 	  fi
@@ -4223,37 +5003,79 @@
 global_symbol_pipe="$lt_cv_sys_global_symbol_pipe"
 if test -z "$lt_cv_sys_global_symbol_pipe"; then
   global_symbol_to_cdecl=
+  global_symbol_to_c_name_address=
 else
   global_symbol_to_cdecl="$lt_cv_global_symbol_to_cdecl"
+  global_symbol_to_c_name_address="$lt_cv_global_symbol_to_c_name_address"
 fi
-if test -z "$global_symbol_pipe$global_symbol_to_cdecl"; then
-  echo "$as_me:4230: result: failed" >&5
+if test -z "$global_symbol_pipe$global_symbol_to_cdec$global_symbol_to_c_name_address";
+then
+  echo "$as_me:$LINENO: result: failed" >&5
 echo "${ECHO_T}failed" >&6
 else
-  echo "$as_me:4233: result: ok" >&5
+  echo "$as_me:$LINENO: result: ok" >&5
 echo "${ECHO_T}ok" >&6
 fi
 
+
 for ac_header in dlfcn.h
 do
 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
-echo "$as_me:4240: checking for $ac_header" >&5
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 if eval "test \"\${$as_ac_Header+set}\" = set"; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-#line 4246 "configure"
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
 #include "confdefs.h"
+$ac_includes_default
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+ac_header_compiler=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
 #include <$ac_header>
 _ACEOF
-if { (eval echo "$as_me:4250: \"$ac_cpp conftest.$ac_ext\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
   (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
   ac_status=$?
   egrep -v '^ *\+' conftest.er1 >conftest.err
   rm -f conftest.er1
   cat conftest.err >&5
-  echo "$as_me:4256: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } >/dev/null; then
   if test -s conftest.err; then
     ac_cpp_err=$ac_c_preproc_warn_flag
@@ -4264,29 +5086,60 @@
   ac_cpp_err=yes
 fi
 if test -z "$ac_cpp_err"; then
-  eval "$as_ac_Header=yes"
+  ac_header_preproc=yes
 else
   echo "$as_me: failed program was:" >&5
   cat conftest.$ac_ext >&5
-  eval "$as_ac_Header=no"
+  ac_header_preproc=no
 fi
 rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc in
+  yes:no )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+  no:yes )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;};;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=$ac_header_preproc"
 fi
-echo "$as_me:4275: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
 if test `eval echo '${'$as_ac_Header'}'` = yes; then
-  cat >>confdefs.h <<EOF
+  cat >>confdefs.h <<_ACEOF
 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
-EOF
+_ACEOF
 
 fi
+
 done
 
+
+
+
+
 # Only perform the check for file, if the check method requires it
 case $deplibs_check_method in
 file_magic*)
   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
-    echo "$as_me:4289: checking for ${ac_tool_prefix}file" >&5
+    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
 echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4341,16 +5194,16 @@
 
 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
 if test -n "$MAGIC_CMD"; then
-  echo "$as_me:4344: result: $MAGIC_CMD" >&5
+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
 echo "${ECHO_T}$MAGIC_CMD" >&6
 else
-  echo "$as_me:4347: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
 if test -z "$lt_cv_path_MAGIC_CMD"; then
   if test -n "$ac_tool_prefix"; then
-    echo "$as_me:4353: checking for file" >&5
+    echo "$as_me:$LINENO: checking for file" >&5
 echo $ECHO_N "checking for file... $ECHO_C" >&6
 if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4405,10 +5258,10 @@
 
 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
 if test -n "$MAGIC_CMD"; then
-  echo "$as_me:4408: result: $MAGIC_CMD" >&5
+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
 echo "${ECHO_T}$MAGIC_CMD" >&6
 else
-  echo "$as_me:4411: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -4424,7 +5277,7 @@
 if test -n "$ac_tool_prefix"; then
   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
-echo "$as_me:4427: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_RANLIB+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4432,25 +5285,28 @@
   if test -n "$RANLIB"; then
   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
-echo "$as_me:4442: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
 fi
 fi
 RANLIB=$ac_cv_prog_RANLIB
 if test -n "$RANLIB"; then
-  echo "$as_me:4450: result: $RANLIB" >&5
+  echo "$as_me:$LINENO: result: $RANLIB" >&5
 echo "${ECHO_T}$RANLIB" >&6
 else
-  echo "$as_me:4453: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -4459,7 +5315,7 @@
   ac_ct_RANLIB=$RANLIB
   # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
-echo "$as_me:4462: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4467,26 +5323,29 @@
   if test -n "$ac_ct_RANLIB"; then
   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_ac_ct_RANLIB="ranlib"
-echo "$as_me:4477: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
   test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
 fi
 fi
 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
 if test -n "$ac_ct_RANLIB"; then
-  echo "$as_me:4486: result: $ac_ct_RANLIB" >&5
+  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
 echo "${ECHO_T}$ac_ct_RANLIB" >&6
 else
-  echo "$as_me:4489: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -4498,7 +5357,7 @@
 if test -n "$ac_tool_prefix"; then
   # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
 set dummy ${ac_tool_prefix}strip; ac_word=$2
-echo "$as_me:4501: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_STRIP+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4506,25 +5365,28 @@
   if test -n "$STRIP"; then
   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_STRIP="${ac_tool_prefix}strip"
-echo "$as_me:4516: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
 fi
 fi
 STRIP=$ac_cv_prog_STRIP
 if test -n "$STRIP"; then
-  echo "$as_me:4524: result: $STRIP" >&5
+  echo "$as_me:$LINENO: result: $STRIP" >&5
 echo "${ECHO_T}$STRIP" >&6
 else
-  echo "$as_me:4527: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -4533,7 +5395,7 @@
   ac_ct_STRIP=$STRIP
   # Extract the first word of "strip", so it can be a program name with args.
 set dummy strip; ac_word=$2
-echo "$as_me:4536: checking for $ac_word" >&5
+echo "$as_me:$LINENO: checking for $ac_word" >&5
 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4541,26 +5403,29 @@
   if test -n "$ac_ct_STRIP"; then
   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
 else
-  ac_save_IFS=$IFS; IFS=$ac_path_separator
-ac_dummy="$PATH"
-for ac_dir in $ac_dummy; do
-  IFS=$ac_save_IFS
-  test -z "$ac_dir" && ac_dir=.
-  $as_executable_p "$ac_dir/$ac_word" || continue
-ac_cv_prog_ac_ct_STRIP="strip"
-echo "$as_me:4551: found $ac_dir/$ac_word" >&5
-break
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
 done
+done
 
   test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
 fi
 fi
 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
 if test -n "$ac_ct_STRIP"; then
-  echo "$as_me:4560: result: $ac_ct_STRIP" >&5
+  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
 echo "${ECHO_T}$ac_ct_STRIP" >&6
 else
-  echo "$as_me:4563: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 
@@ -4569,6 +5434,7 @@
   STRIP="$ac_cv_prog_STRIP"
 fi
 
+
 enable_dlopen=no
 enable_win32_dll=no
 
@@ -4584,11 +5450,11 @@
 case $host in
 *-*-irix6*)
   # Find out which ABI we are using.
-  echo '#line 4587 "configure"' > conftest.$ac_ext
-  if { (eval echo "$as_me:4588: \"$ac_compile\"") >&5
+  echo '#line 5453 "configure"' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:4591: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
     case `/usr/bin/file conftest.$ac_objext` in
     *32-bit*)
@@ -4609,12 +5475,13 @@
   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
   SAVE_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS -belf"
-  echo "$as_me:4612: checking whether the C compiler needs -belf" >&5
+  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
 echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
 if test "${lt_cv_cc_needs_belf+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
 
+
      ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -4622,9 +5489,15 @@
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
      cat >conftest.$ac_ext <<_ACEOF
-#line 4625 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -4634,16 +5507,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:4637: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:4640: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:4643: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:4646: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   lt_cv_cc_needs_belf=yes
 else
@@ -4659,7 +5532,7 @@
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 fi
-echo "$as_me:4662: result: $lt_cv_cc_needs_belf" >&5
+echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
 echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
@@ -4667,6 +5540,7 @@
   fi
   ;;
 
+
 esac
 
 # Sed substitution that helps us do robust quoting.  It backslashifies
@@ -4744,8 +5618,15 @@
 old_postuninstall_cmds=
 
 if test -n "$RANLIB"; then
+  case $host_os in
+  openbsd*)
+    old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds"
+    ;;
+  *)
+    old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
+    ;;
+  esac
   old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
-  old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
 fi
 
 # Allow CC to be a program name with arguments.
@@ -4754,7 +5635,7 @@
 
 ## FIXME: this should be a separate macro
 ##
-echo "$as_me:4757: checking for objdir" >&5
+echo "$as_me:$LINENO: checking for objdir" >&5
 echo $ECHO_N "checking for objdir... $ECHO_C" >&6
 rm -f .libs 2>/dev/null
 mkdir .libs 2>/dev/null
@@ -4765,11 +5646,12 @@
   objdir=_libs
 fi
 rmdir .libs 2>/dev/null
-echo "$as_me:4768: result: $objdir" >&5
+echo "$as_me:$LINENO: result: $objdir" >&5
 echo "${ECHO_T}$objdir" >&6
 ##
 ## END FIXME
 
+
 ## FIXME: this should be a separate macro
 ##
 
@@ -4785,7 +5667,7 @@
 # We assume here that the value for lt_cv_prog_cc_pic will not be cached
 # in isolation, and that seeing it set (from the cache) indicates that
 # the associated values are set (in the cache) correctly too.
-echo "$as_me:4788: checking for $compiler option to produce PIC" >&5
+echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
 echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6
 if test "${lt_cv_prog_cc_pic+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4808,7 +5690,7 @@
       # libC (AIX C++ library), which obviously doesn't included in libraries
       # list by gcc. This cause undefined symbols with -static flags.
       # This hack allows C programs to be linked with "-static -ldl", but
-      # we not sure about C++ programs.
+      # not sure about C++ programs.
       lt_cv_prog_cc_static="$lt_cv_prog_cc_static ${lt_cv_prog_cc_wl}-lC"
       ;;
     amigaos*)
@@ -4843,13 +5725,13 @@
     # PORTME Check for PIC flags for the system compiler.
     case $host_os in
     aix3* | aix4* | aix5*)
+      lt_cv_prog_cc_wl='-Wl,'
       # All AIX code is PIC.
       if test "$host_cpu" = ia64; then
-        # AIX 5 now supports IA64 processor
-        lt_cv_prog_cc_static='-Bstatic'
-        lt_cv_prog_cc_wl='-Wl,'
+	# AIX 5 now supports IA64 processor
+	lt_cv_prog_cc_static='-Bstatic'
       else
-        lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp'
+	lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp'
       fi
       ;;
 
@@ -4905,9 +5787,9 @@
       lt_cv_prog_cc_pic='-KPIC'
       lt_cv_prog_cc_static='-Bstatic'
       if test "x$host_vendor" = xsni; then
-        lt_cv_prog_cc_wl='-LD'
+	lt_cv_prog_cc_wl='-LD'
       else
-        lt_cv_prog_cc_wl='-Wl,'
+	lt_cv_prog_cc_wl='-Wl,'
       fi
       ;;
 
@@ -4932,14 +5814,14 @@
 fi
 
 if test -z "$lt_cv_prog_cc_pic"; then
-  echo "$as_me:4935: result: none" >&5
+  echo "$as_me:$LINENO: result: none" >&5
 echo "${ECHO_T}none" >&6
 else
-  echo "$as_me:4938: result: $lt_cv_prog_cc_pic" >&5
+  echo "$as_me:$LINENO: result: $lt_cv_prog_cc_pic" >&5
 echo "${ECHO_T}$lt_cv_prog_cc_pic" >&6
 
   # Check to make sure the pic_flag actually works.
-  echo "$as_me:4942: checking if $compiler PIC flag $lt_cv_prog_cc_pic works" >&5
+  echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_cv_prog_cc_pic works" >&5
 echo $ECHO_N "checking if $compiler PIC flag $lt_cv_prog_cc_pic works... $ECHO_C" >&6
   if test "${lt_cv_prog_cc_pic_works+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -4947,9 +5829,15 @@
       save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS $lt_cv_prog_cc_pic -DPIC"
     cat >conftest.$ac_ext <<_ACEOF
-#line 4950 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -4959,16 +5847,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:4962: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:4965: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:4968: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:4971: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
         case $host_os in
       hpux9* | hpux10* | hpux11*)
@@ -4997,6 +5885,7 @@
 
 fi
 
+
   if test "X$lt_cv_prog_cc_pic_works" = Xno; then
     lt_cv_prog_cc_pic=
     lt_cv_prog_cc_can_build_shared=no
@@ -5004,7 +5893,7 @@
     lt_cv_prog_cc_pic=" $lt_cv_prog_cc_pic"
   fi
 
-  echo "$as_me:5007: result: $lt_cv_prog_cc_pic_works" >&5
+  echo "$as_me:$LINENO: result: $lt_cv_prog_cc_pic_works" >&5
 echo "${ECHO_T}$lt_cv_prog_cc_pic_works" >&6
 fi
 ##
@@ -5012,11 +5901,11 @@
 
 # Check for any special shared library compilation flags.
 if test -n "$lt_cv_prog_cc_shlib"; then
-  { echo "$as_me:5015: WARNING: \`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries" >&5
+  { echo "$as_me:$LINENO: WARNING: \`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries" >&5
 echo "$as_me: WARNING: \`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries" >&2;}
   if echo "$old_CC $old_CFLAGS " | egrep -e "[ 	]$lt_cv_prog_cc_shlib[ 	]" >/dev/null; then :
   else
-   { echo "$as_me:5019: WARNING: add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&5
+   { echo "$as_me:$LINENO: WARNING: add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&5
 echo "$as_me: WARNING: add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure" >&2;}
     lt_cv_prog_cc_can_build_shared=no
   fi
@@ -5024,7 +5913,7 @@
 
 ## FIXME: this should be a separate macro
 ##
-echo "$as_me:5027: checking if $compiler static flag $lt_cv_prog_cc_static works" >&5
+echo "$as_me:$LINENO: checking if $compiler static flag $lt_cv_prog_cc_static works" >&5
 echo $ECHO_N "checking if $compiler static flag $lt_cv_prog_cc_static works... $ECHO_C" >&6
 if test "${lt_cv_prog_cc_static_works+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -5033,9 +5922,15 @@
   save_LDFLAGS="$LDFLAGS"
   LDFLAGS="$LDFLAGS $lt_cv_prog_cc_static"
   cat >conftest.$ac_ext <<_ACEOF
-#line 5036 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -5045,16 +5940,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:5048: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:5051: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:5054: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:5057: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   lt_cv_prog_cc_static_works=yes
 else
@@ -5066,9 +5961,10 @@
 
 fi
 
+
 # Belt *and* braces to stop my trousers falling down:
 test "X$lt_cv_prog_cc_static_works" = Xno && lt_cv_prog_cc_static=
-echo "$as_me:5071: result: $lt_cv_prog_cc_static_works" >&5
+echo "$as_me:$LINENO: result: $lt_cv_prog_cc_static_works" >&5
 echo "${ECHO_T}$lt_cv_prog_cc_static_works" >&6
 
 pic_flag="$lt_cv_prog_cc_pic"
@@ -5080,10 +5976,11 @@
 ##
 ## END FIXME
 
+
 ## FIXME: this should be a separate macro
 ##
 # Check to see if options -o and -c are simultaneously supported by compiler
-echo "$as_me:5086: checking if $compiler supports -c -o file.$ac_objext" >&5
+echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
 echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
 if test "${lt_cv_compiler_c_o+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -5103,7 +6000,7 @@
 save_CFLAGS="$CFLAGS"
 CFLAGS="$CFLAGS -o out/conftest2.$ac_objext"
 compiler_c_o=no
-if { (eval echo configure:5106: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.$ac_objext; then
+if { (eval echo configure:6003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.$ac_objext; then
   # The compiler can only warn and ignore the option if not recognized
   # So say no if there are warnings
   if test -s out/conftest.err; then
@@ -5127,12 +6024,12 @@
 fi
 
 compiler_c_o=$lt_cv_compiler_c_o
-echo "$as_me:5130: result: $compiler_c_o" >&5
+echo "$as_me:$LINENO: result: $compiler_c_o" >&5
 echo "${ECHO_T}$compiler_c_o" >&6
 
 if test x"$compiler_c_o" = x"yes"; then
   # Check to see if we can write to a .lo
-  echo "$as_me:5135: checking if $compiler supports -c -o file.lo" >&5
+  echo "$as_me:$LINENO: checking if $compiler supports -c -o file.lo" >&5
 echo $ECHO_N "checking if $compiler supports -c -o file.lo... $ECHO_C" >&6
   if test "${lt_cv_compiler_o_lo+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -5141,10 +6038,18 @@
   lt_cv_compiler_o_lo=no
   save_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS -c -o conftest.lo"
+  save_objext="$ac_objext"
+  ac_objext=lo
   cat >conftest.$ac_ext <<_ACEOF
-#line 5145 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -5154,16 +6059,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5157: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:5160: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:5163: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:5166: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
       # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
@@ -5178,13 +6083,14 @@
 cat conftest.$ac_ext >&5
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
+  ac_objext="$save_objext"
   CFLAGS="$save_CFLAGS"
 
 fi
 
   compiler_o_lo=$lt_cv_compiler_o_lo
-  echo "$as_me:5186: result: $compiler_c_lo" >&5
-echo "${ECHO_T}$compiler_c_lo" >&6
+  echo "$as_me:$LINENO: result: $compiler_o_lo" >&5
+echo "${ECHO_T}$compiler_o_lo" >&6
 else
   compiler_o_lo=no
 fi
@@ -5197,7 +6103,7 @@
 hard_links="nottested"
 if test "$compiler_c_o" = no && test "$need_locks" != no; then
   # do not overwrite the value of need_locks provided by the user
-  echo "$as_me:5200: checking if we can lock with hard links" >&5
+  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
 echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6
   hard_links=yes
   $rm conftest*
@@ -5205,10 +6111,10 @@
   touch conftest.a
   ln conftest.a conftest.b 2>&5 || hard_links=no
   ln conftest.a conftest.b 2>/dev/null && hard_links=no
-  echo "$as_me:5208: result: $hard_links" >&5
+  echo "$as_me:$LINENO: result: $hard_links" >&5
 echo "${ECHO_T}$hard_links" >&6
   if test "$hard_links" = no; then
-    { echo "$as_me:5211: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
 echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
     need_locks=warn
   fi
@@ -5222,16 +6128,22 @@
 ##
 if test "$GCC" = yes; then
   # Check to see if options -fno-rtti -fno-exceptions are supported by compiler
-  echo "$as_me:5225: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+  echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
 echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6
   echo "int some_variable = 0;" > conftest.$ac_ext
   save_CFLAGS="$CFLAGS"
   CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -c conftest.$ac_ext"
   compiler_rtti_exceptions=no
   cat >conftest.$ac_ext <<_ACEOF
-#line 5232 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -5241,16 +6153,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext
-if { (eval echo "$as_me:5244: \"$ac_compile\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:5247: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest.$ac_objext'
-  { (eval echo "$as_me:5250: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:5253: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
       # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
@@ -5266,7 +6178,7 @@
 fi
 rm -f conftest.$ac_objext conftest.$ac_ext
   CFLAGS="$save_CFLAGS"
-  echo "$as_me:5269: result: $compiler_rtti_exceptions" >&5
+  echo "$as_me:$LINENO: result: $compiler_rtti_exceptions" >&5
 echo "${ECHO_T}$compiler_rtti_exceptions" >&6
 
   if test "$compiler_rtti_exceptions" = "yes"; then
@@ -5281,7 +6193,7 @@
 ## FIXME: this should be a separate macro
 ##
 # See if the linker supports building shared libraries.
-echo "$as_me:5284: checking whether the linker ($LD) supports shared libraries" >&5
+echo "$as_me:$LINENO: checking whether the linker ($LD) supports shared libraries" >&5
 echo $ECHO_N "checking whether the linker ($LD) supports shared libraries... $ECHO_C" >&6
 
 allow_undefined_flag=
@@ -5323,7 +6235,7 @@
 extract_expsyms_cmds=
 
 case $host_os in
-cygwin* | mingw* | pw32* )
+cygwin* | mingw* | pw32*)
   # FIXME: the MSVC++ port hasn't been tested in a loooong time
   # When not using gcc, we currently assume that we are using
   # Microsoft Visual C++.
@@ -5331,7 +6243,9 @@
     with_gnu_ld=no
   fi
   ;;
-
+openbsd*)
+  with_gnu_ld=no
+  ;;
 esac
 
 ld_shlibs=yes
@@ -5418,7 +6332,7 @@
     # can override, but on older systems we have to supply one (in ltdll.c)
     if test "x$lt_cv_need_dllmain" = "xyes"; then
       ltdll_obj='$output_objdir/$soname-ltdll.'"$ac_objext "
-      ltdll_cmds='test -f $output_objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < [$]0 > $output_objdir/$soname-ltdll.c~
+      ltdll_cmds='test -f $output_objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < $''0 > $output_objdir/$soname-ltdll.c~
 	test -f $output_objdir/$soname-ltdll.$ac_objext || (cd $output_objdir && $CC -c $soname-ltdll.c)~'
     else
       ltdll_obj=
@@ -5437,18 +6351,18 @@
     # is EXPORTS), use it as is.
     # If DATA tags from a recent dlltool are present, honour them!
     archive_expsym_cmds='if test "x`head -1 $export_symbols`" = xEXPORTS; then
-        cp $export_symbols $output_objdir/$soname-def;
+	cp $export_symbols $output_objdir/$soname-def;
       else
-        echo EXPORTS > $output_objdir/$soname-def;
-        _lt_hint=1;
-        cat $export_symbols | while read symbol; do
-         set dummy \$symbol;
-         case \$# in
-           2) echo "   \$2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;;
-           *) echo "     \$2 @ \$_lt_hint \$3 ; " >> $output_objdir/$soname-def;;
-         esac;
-         _lt_hint=`expr 1 + \$_lt_hint`;
-        done;
+	echo EXPORTS > $output_objdir/$soname-def;
+	_lt_hint=1;
+	cat $export_symbols | while read symbol; do
+	 set dummy \$symbol;
+	 case \$# in
+	   2) echo "   \$2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;;
+	   *) echo "     \$2 @ \$_lt_hint \$3 ; " >> $output_objdir/$soname-def;;
+	 esac;
+	 _lt_hint=`expr 1 + \$_lt_hint`;
+	done;
       fi~
       '"$ltdll_cmds"'
       $CC -Wl,--base-file,$output_objdir/$soname-base '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~
@@ -5543,80 +6457,96 @@
     ;;
 
   aix4* | aix5*)
+    if test "$host_cpu" = ia64; then
+      # On IA64, the linker does run time linking by default, so we don't
+      # have to do anything special.
+      aix_use_runtimelinking=no
+      exp_sym_flag='-Bexport'
+      no_entry_flag=""
+    else
+      aix_use_runtimelinking=no
+
+      # Test if we are trying to use run time linking or normal
+      # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+      # need to do runtime linking.
+      case $host_os in aix4.[23]|aix4.[23].*|aix5*)
+	for ld_flag in $LDFLAGS; do
+	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+	    aix_use_runtimelinking=yes
+	    break
+	  fi
+	done
+      esac
+
+      exp_sym_flag='-bexport'
+      no_entry_flag='-bnoentry'
+    fi
+
     # When large executables or shared objects are built, AIX ld can
     # have problems creating the table of contents.  If linking a library
     # or program results in "error TOC overflow" add -mminimal-toc to
     # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
     # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
 
+    hardcode_direct=yes
     archive_cmds=''
     hardcode_libdir_separator=':'
     if test "$GCC" = yes; then
-      collect2name=`${CC} -print-prog-name=collect2`
-      if test -f "$collect2name" && \
-	 strings "$collect2name" | grep resolve_lib_name >/dev/null
-      then
-	# We have reworked collect2
-	hardcode_direct=yes
-      else
-        # We have old collect2
-        hardcode_direct=unsupported
-        # It fails to find uninstalled libraries when the uninstalled
-        # path is not listed in the libpath.  Setting hardcode_minus_L
-        # to unsupported forces relinking
-        hardcode_minus_L=yes
-        hardcode_libdir_flag_spec='-L$libdir'
-        hardcode_libdir_separator=
-      fi
+      case $host_os in aix4.[012]|aix4.[012].*)
+	collect2name=`${CC} -print-prog-name=collect2`
+	if test -f "$collect2name" && \
+	  strings "$collect2name" | grep resolve_lib_name >/dev/null
+	then
+	  # We have reworked collect2
+	  hardcode_direct=yes
+	else
+	  # We have old collect2
+	  hardcode_direct=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  hardcode_minus_L=yes
+	  hardcode_libdir_flag_spec='-L$libdir'
+	  hardcode_libdir_separator=
+	fi
+      esac
+
       shared_flag='-shared'
     else
+      # not using gcc
       if test "$host_cpu" = ia64; then
-        shared_flag='-G'
+	shared_flag='${wl}-G'
       else
-        shared_flag='${wl}-bM:SRE'
+	if test "$aix_use_runtimelinking" = yes; then
+	  shared_flag='${wl}-G'
+	else
+	  shared_flag='${wl}-bM:SRE'
+	fi
       fi
-      hardcode_direct=yes
     fi
 
-    if test "$host_cpu" = ia64; then
-      # On IA64, the linker does run time linking by default, so we don't
-      # have to do anything special.
-      aix_use_runtimelinking=no
-      exp_sym_flag='-Bexport'
-      no_entry_flag=""
-    else
-      # Test if we are trying to use run time linking, or normal AIX style linking.
-      # If -brtl is somewhere in LDFLAGS, we need to do run time linking.
-      aix_use_runtimelinking=no
-      for ld_flag in $LDFLAGS; do
-        if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl" ); then
-          aix_use_runtimelinking=yes
-          break
-        fi
-      done
-      exp_sym_flag='-bexport'
-      no_entry_flag='-bnoentry'
-    fi
     # It seems that -bexpall can do strange things, so it is better to
     # generate a list of symbols to export.
     always_export_symbols=yes
     if test "$aix_use_runtimelinking" = yes; then
+      # Warning - without using the other runtime loading flags (-brtl),
+      # -berok will link without error, but may produce a broken library.
+      allow_undefined_flag='-berok'
       hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:/usr/lib:/lib'
-      allow_undefined_flag=' -Wl,-G'
-      archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
+      archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
     else
       if test "$host_cpu" = ia64; then
-        hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
-       allow_undefined_flag="-znodefs"
-        archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname ${wl}-h$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
+	hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+	allow_undefined_flag="-z nodefs"
+	archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname ${wl}-h$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
       else
-        hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib'
-        # Warning - without using the other run time loading flags, -berok will
-        #           link without error, but may produce a broken library.
-        allow_undefined_flag='${wl}-berok"
-        # This is a bit strange, but is similar to how AIX traditionally builds
-        # it's shared libraries.
-        archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"' ~$AR -crlo $objdir/$libname$release.a $objdir/$soname'
+	hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib'
+	# Warning - without using the other run time loading flags,
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag='${wl}-berok'
+	# This is a bit strange, but is similar to how AIX traditionally builds
+	# it's shared libraries.
+	archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"' ~$AR -crlo $output_objdir/$libname$release.a $output_objdir/$soname'
       fi
     fi
     ;;
@@ -5648,11 +6578,18 @@
     ;;
 
   darwin* | rhapsody*)
-    allow_undefined_flag='-undefined suppress'
+    case "$host_os" in
+    rhapsody* | darwin1.[012])
+      allow_undefined_flag='-undefined suppress'
+      ;;
+    *) # Darwin 1.3 on
+      allow_undefined_flag='-flat_namespace -undefined suppress'
+      ;;
+    esac
     # FIXME: Relying on posixy $() will cause problems for
     #        cross-compilation, but unfortunately the echo tests do not
     #        yet detect zsh echo's removal of \ escapes.
-    archive_cmds='$CC $(test .$module = .yes && echo -bundle || echo -dynamiclib) $allow_undefined_flag -o $lib $libobjs $deplibs$linkopts -install_name $rpath/$soname $(test -n "$verstring" -a x$verstring != x0.0 && echo $verstring)'
+    archive_cmds='$nonopt $(test "x$module" = xyes && echo -bundle || echo -dynamiclib) $allow_undefined_flag -o $lib $libobjs $deplibs$linker_flags -install_name $rpath/$soname $verstring'
     # We need to add '_' to the symbols in $export_symbols first
     #archive_expsym_cmds="$archive_cmds"' && strip -s $export_symbols'
     hardcode_direct=yes
@@ -5727,7 +6664,7 @@
     ;;
 
   newsos6)
-    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linkopts'
+    archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
     hardcode_direct=yes
     hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
     hardcode_libdir_separator=:
@@ -5735,10 +6672,24 @@
     ;;
 
   openbsd*)
-    archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
-    hardcode_libdir_flag_spec='-R$libdir'
     hardcode_direct=yes
     hardcode_shlibpath_var=no
+    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+      archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+      export_dynamic_flag_spec='${wl}-E'
+    else
+      case "$host_os" in
+      openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_libdir_flag_spec='-R$libdir'
+        ;;
+      *)
+        archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $linker_flags'
+        hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+        ;;
+      esac
+    fi
     ;;
 
   os2*)
@@ -5783,10 +6734,39 @@
     hardcode_shlibpath_var=no
     runpath_var=LD_RUN_PATH
     hardcode_runpath_var=yes
+    export_dynamic_flag_spec='${wl}-Bexport'
     ;;
 
   solaris*)
+    # gcc --version < 3.0 without binutils cannot create self contained
+    # shared libraries reliably, requiring libgcc.a to resolve some of
+    # the object symbols generated in some cases.  Libraries that use
+    # assert need libgcc.a to resolve __eprintf, for example.  Linking
+    # a copy of libgcc.a into every shared library to guarantee resolving
+    # such symbols causes other problems:  According to Tim Van Holder
+    # <tim.van.holder@pandora.be>, C++ libraries end up with a separate
+    # (to the application) exception stack for one thing.
     no_undefined_flag=' -z defs'
+    if test "$GCC" = yes; then
+      case `$CC --version 2>/dev/null` in
+      [12].*)
+	cat <<EOF 1>&2
+
+*** Warning: Releases of GCC earlier than version 3.0 cannot reliably
+*** create self contained shared libraries on Solaris systems, without
+*** introducing a dependency on libgcc.a.  Therefore, libtool is disabling
+*** -no-undefined support, which will at least allow you to build shared
+*** libraries.  However, you may find that when you link such libraries
+*** into an application without using GCC, you have to manually add
+*** \`gcc --print-libgcc-file-name\` to the link command.  We urge you to
+*** upgrade to a newer version of GCC.  Another option is to rebuild your
+*** current GCC to use the GNU linker from GNU binutils 2.9.1 or newer.
+
+EOF
+        no_undefined_flag=
+	;;
+      esac
+    fi
     # $CC -shared without GNU ld will not create a library from C++
     # object files and a static libstdc++, better avoid it by now
     archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
@@ -5818,7 +6798,7 @@
 
   sysv4)
     if test "x$host_vendor" = xsno; then
-      archive_cmds='$LD -G -Bsymbolic -h $soname -o $lib $libobjs $deplibs $linkopts'
+      archive_cmds='$LD -G -Bsymbolic -h $soname -o $lib $libobjs $deplibs $linker_flags'
       hardcode_direct=yes # is this really true???
     else
       archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
@@ -5893,7 +6873,7 @@
     ;;
   esac
 fi
-echo "$as_me:5896: result: $ld_shlibs" >&5
+echo "$as_me:$LINENO: result: $ld_shlibs" >&5
 echo "${ECHO_T}$ld_shlibs" >&6
 test "$ld_shlibs" = no && can_build_shared=no
 ##
@@ -5902,7 +6882,7 @@
 ## FIXME: this should be a separate macro
 ##
 # Check hardcoding attributes.
-echo "$as_me:5905: checking how to hardcode library paths into programs" >&5
+echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5
 echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6
 hardcode_action=
 if test -n "$hardcode_libdir_flag_spec" || \
@@ -5926,7 +6906,7 @@
   # directories.
   hardcode_action=unsupported
 fi
-echo "$as_me:5929: result: $hardcode_action" >&5
+echo "$as_me:$LINENO: result: $hardcode_action" >&5
 echo "${ECHO_T}$hardcode_action" >&6
 ##
 ## END FIXME
@@ -5935,15 +6915,15 @@
 ##
 striplib=
 old_striplib=
-echo "$as_me:5938: checking whether stripping libraries is possible" >&5
+echo "$as_me:$LINENO: checking whether stripping libraries is possible" >&5
 echo $ECHO_N "checking whether stripping libraries is possible... $ECHO_C" >&6
 if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then
   test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
   test -z "$striplib" && striplib="$STRIP --strip-unneeded"
-  echo "$as_me:5943: result: yes" >&5
+  echo "$as_me:$LINENO: result: yes" >&5
 echo "${ECHO_T}yes" >&6
 else
-  echo "$as_me:5946: result: no" >&5
+  echo "$as_me:$LINENO: result: no" >&5
 echo "${ECHO_T}no" >&6
 fi
 ##
@@ -5955,7 +6935,7 @@
 ## FIXME: this should be a separate macro
 ##
 # PORTME Fill in your ld.so characteristics
-echo "$as_me:5958: checking dynamic linker characteristics" >&5
+echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5
 echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6
 library_names_spec=
 libname_spec='lib$name'
@@ -5994,22 +6974,24 @@
     # depend on `.', always an invalid library.  This was fixed in
     # development snapshots of GCC prior to 3.0.
     case $host_os in
-       aix4 | aix4.[01] | aix4.[01].*)
-      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
-           echo ' yes '
-           echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
-        :
-      else
-        can_build_shared=no
-      fi
-      ;;
+      aix4 | aix4.[01] | aix4.[01].*)
+	if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	     echo ' yes '
+	     echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then
+	  :
+	else
+	  can_build_shared=no
+	fi
+	;;
     esac
-    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
-    # soname into executable. Probably we can add versioning support to
-    # collect2, so additional links can be useful in future.
+    # AIX (on Power*) has no versioning support, so currently we can
+    # not hardcode correct soname into executable. Probably we can
+    # add versioning support to collect2, so additional links can
+    # be useful in future.
     if test "$aix_use_runtimelinking" = yes; then
-      # If using run time linking (on AIX 4.2 or later) use lib<name>.so instead of
-      # lib<name>.a to let people know that these are not typical AIX shared libraries.
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
       library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'
     else
       # We preserve .a as extension for shared libraries through AIX4.2
@@ -6018,7 +7000,6 @@
       soname_spec='${libname}${release}.so$major'
     fi
     shlibpath_var=LIBPATH
-    deplibs_check_method=pass_all
   fi
   ;;
 
@@ -6231,9 +7212,19 @@
 
 openbsd*)
   version_type=sunos
-  if test "$with_gnu_ld" = yes; then
-    need_lib_prefix=no
-    need_version=no
+  need_lib_prefix=no
+  need_version=no
+  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case "$host_os" in
+    openbsd2.[89] | openbsd2.[89].*)
+      shlibpath_overrides_runpath=no
+      ;;
+    *)
+      shlibpath_overrides_runpath=yes
+      ;;
+    esac
+  else
+    shlibpath_overrides_runpath=yes
   fi
   library_names_spec='${libname}${release}.so$versuffix ${libname}.so$versuffix'
   finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
@@ -6337,7 +7328,7 @@
   dynamic_linker=no
   ;;
 esac
-echo "$as_me:6340: result: $dynamic_linker" >&5
+echo "$as_me:$LINENO: result: $dynamic_linker" >&5
 echo "${ECHO_T}$dynamic_linker" >&6
 test "$dynamic_linker" = no && can_build_shared=no
 ##
@@ -6346,13 +7337,52 @@
 ## FIXME: this should be a separate macro
 ##
 # Report the final consequences.
-echo "$as_me:6349: checking if libtool supports shared libraries" >&5
+echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5
 echo $ECHO_N "checking if libtool supports shared libraries... $ECHO_C" >&6
-echo "$as_me:6351: result: $can_build_shared" >&5
+echo "$as_me:$LINENO: result: $can_build_shared" >&5
 echo "${ECHO_T}$can_build_shared" >&6
 ##
 ## END FIXME
 
+## FIXME: this should be a separate macro
+##
+echo "$as_me:$LINENO: checking whether to build shared libraries" >&5
+echo $ECHO_N "checking whether to build shared libraries... $ECHO_C" >&6
+test "$can_build_shared" = "no" && enable_shared=no
+
+# On AIX, shared libraries and static libraries use the same namespace, and
+# are all built from PIC.
+case "$host_os" in
+aix3*)
+  test "$enable_shared" = yes && enable_static=no
+  if test -n "$RANLIB"; then
+    archive_cmds="$archive_cmds~\$RANLIB \$lib"
+    postinstall_cmds='$RANLIB $lib'
+  fi
+  ;;
+
+aix4*)
+  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+    test "$enable_shared" = yes && enable_static=no
+  fi
+  ;;
+esac
+echo "$as_me:$LINENO: result: $enable_shared" >&5
+echo "${ECHO_T}$enable_shared" >&6
+##
+## END FIXME
+
+## FIXME: this should be a separate macro
+##
+echo "$as_me:$LINENO: checking whether to build static libraries" >&5
+echo $ECHO_N "checking whether to build static libraries... $ECHO_C" >&6
+# Make sure either enable_shared or enable_static is yes.
+test "$enable_shared" = yes || enable_static=yes
+echo "$as_me:$LINENO: result: $enable_static" >&5
+echo "${ECHO_T}$enable_static" >&6
+##
+## END FIXME
+
 if test "$hardcode_action" = relink; then
   # Fast installation is not supported
   enable_fast_install=no
@@ -6388,15 +7418,82 @@
    ;;
 
   *)
-    echo "$as_me:6391: checking for dlopen in -ldl" >&5
-echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6
-if test "${ac_cv_lib_dl_dlopen+set}" = set; then
+    echo "$as_me:$LINENO: checking for shl_load" >&5
+echo $ECHO_N "checking for shl_load... $ECHO_C" >&6
+if test "${ac_cv_func_shl_load+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+#include "confdefs.h"
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char shl_load (); below.  */
+#include <assert.h>
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char shl_load ();
+char (*f) ();
+
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
+int
+main ()
+{
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_shl_load) || defined (__stub___shl_load)
+choke me
+#else
+f = shl_load;
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+         { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_func_shl_load=yes
+else
+  echo "$as_me: failed program was:" >&5
+cat conftest.$ac_ext >&5
+ac_cv_func_shl_load=no
+fi
+rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_func_shl_load" >&5
+echo "${ECHO_T}$ac_cv_func_shl_load" >&6
+if test $ac_cv_func_shl_load = yes; then
+  lt_cv_dlopen="shl_load"
+else
+  echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5
+echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6
+if test "${ac_cv_lib_dld_shl_load+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   ac_check_lib_save_LIBS=$LIBS
-LIBS="-ldl  $LIBS"
+LIBS="-ldld  $LIBS"
 cat >conftest.$ac_ext <<_ACEOF
-#line 6399 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
 /* Override any gcc2 internal prototype to avoid an error.  */
@@ -6405,48 +7502,54 @@
 #endif
 /* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
-char dlopen ();
+char shl_load ();
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-dlopen ();
+shl_load ();
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6418: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:6421: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:6424: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:6427: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
-  ac_cv_lib_dl_dlopen=yes
+  ac_cv_lib_dld_shl_load=yes
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_cv_lib_dl_dlopen=no
+ac_cv_lib_dld_shl_load=no
 fi
 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:6438: result: $ac_cv_lib_dl_dlopen" >&5
-echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
-if test $ac_cv_lib_dl_dlopen = yes; then
-  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5
+echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6
+if test $ac_cv_lib_dld_shl_load = yes; then
+  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"
 else
-  echo "$as_me:6443: checking for dlopen" >&5
+  echo "$as_me:$LINENO: checking for dlopen" >&5
 echo $ECHO_N "checking for dlopen... $ECHO_C" >&6
 if test "${ac_cv_func_dlopen+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   cat >conftest.$ac_ext <<_ACEOF
-#line 6449 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char dlopen (); below.  */
@@ -6460,6 +7563,12 @@
 char dlopen ();
 char (*f) ();
 
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -6477,16 +7586,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6480: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:6483: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:6486: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:6489: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_func_dlopen=yes
 else
@@ -6496,73 +7605,70 @@
 fi
 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 fi
-echo "$as_me:6499: result: $ac_cv_func_dlopen" >&5
+echo "$as_me:$LINENO: result: $ac_cv_func_dlopen" >&5
 echo "${ECHO_T}$ac_cv_func_dlopen" >&6
 if test $ac_cv_func_dlopen = yes; then
   lt_cv_dlopen="dlopen"
 else
-  echo "$as_me:6504: checking for shl_load" >&5
-echo $ECHO_N "checking for shl_load... $ECHO_C" >&6
-if test "${ac_cv_func_shl_load+set}" = set; then
+  echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
+echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6
+if test "${ac_cv_lib_dl_dlopen+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
-  cat >conftest.$ac_ext <<_ACEOF
-#line 6510 "configure"
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
 #include "confdefs.h"
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char shl_load (); below.  */
-#include <assert.h>
+
 /* Override any gcc2 internal prototype to avoid an error.  */
 #ifdef __cplusplus
 extern "C"
 #endif
 /* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
-char shl_load ();
-char (*f) ();
-
+char dlopen ();
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined (__stub_shl_load) || defined (__stub___shl_load)
-choke me
-#else
-f = shl_load;
-#endif
-
+dlopen ();
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6541: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:6544: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:6547: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:6550: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
-  ac_cv_func_shl_load=yes
+  ac_cv_lib_dl_dlopen=yes
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_cv_func_shl_load=no
+ac_cv_lib_dl_dlopen=no
 fi
 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:6560: result: $ac_cv_func_shl_load" >&5
-echo "${ECHO_T}$ac_cv_func_shl_load" >&6
-if test $ac_cv_func_shl_load = yes; then
-  lt_cv_dlopen="shl_load"
+echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
+echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
+if test $ac_cv_lib_dl_dlopen = yes; then
+  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
 else
-  echo "$as_me:6565: checking for dlopen in -lsvld" >&5
+  echo "$as_me:$LINENO: checking for dlopen in -lsvld" >&5
 echo $ECHO_N "checking for dlopen in -lsvld... $ECHO_C" >&6
 if test "${ac_cv_lib_svld_dlopen+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -6570,7 +7676,7 @@
   ac_check_lib_save_LIBS=$LIBS
 LIBS="-lsvld  $LIBS"
 cat >conftest.$ac_ext <<_ACEOF
-#line 6573 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
 /* Override any gcc2 internal prototype to avoid an error.  */
@@ -6580,6 +7686,12 @@
 /* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
 char dlopen ();
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
@@ -6589,16 +7701,16 @@
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6592: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:6595: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:6598: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:6601: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
   ac_cv_lib_svld_dlopen=yes
 else
@@ -6609,20 +7721,20 @@
 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:6612: result: $ac_cv_lib_svld_dlopen" >&5
+echo "$as_me:$LINENO: result: $ac_cv_lib_svld_dlopen" >&5
 echo "${ECHO_T}$ac_cv_lib_svld_dlopen" >&6
 if test $ac_cv_lib_svld_dlopen = yes; then
   lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
 else
-  echo "$as_me:6617: checking for shl_load in -ldld" >&5
-echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6
-if test "${ac_cv_lib_dld_shl_load+set}" = set; then
+  echo "$as_me:$LINENO: checking for dld_link in -ldld" >&5
+echo $ECHO_N "checking for dld_link in -ldld... $ECHO_C" >&6
+if test "${ac_cv_lib_dld_dld_link+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
 else
   ac_check_lib_save_LIBS=$LIBS
 LIBS="-ldld  $LIBS"
 cat >conftest.$ac_ext <<_ACEOF
-#line 6625 "configure"
+#line $LINENO "configure"
 #include "confdefs.h"
 
 /* Override any gcc2 internal prototype to avoid an error.  */
@@ -6631,48 +7743,61 @@
 #endif
 /* We use char because int might match the return type of a gcc2
    builtin and then its argument prototype would still apply.  */
-char shl_load ();
+char dld_link ();
+#ifdef F77_DUMMY_MAIN
+#  ifdef __cplusplus
+     extern "C"
+#  endif
+   int F77_DUMMY_MAIN() { return 1; }
+#endif
 int
 main ()
 {
-shl_load ();
+dld_link ();
   ;
   return 0;
 }
 _ACEOF
 rm -f conftest.$ac_objext conftest$ac_exeext
-if { (eval echo "$as_me:6644: \"$ac_link\"") >&5
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:6647: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } &&
          { ac_try='test -s conftest$ac_exeext'
-  { (eval echo "$as_me:6650: \"$ac_try\"") >&5
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
   (eval $ac_try) 2>&5
   ac_status=$?
-  echo "$as_me:6653: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
-  ac_cv_lib_dld_shl_load=yes
+  ac_cv_lib_dld_dld_link=yes
 else
   echo "$as_me: failed program was:" >&5
 cat conftest.$ac_ext >&5
-ac_cv_lib_dld_shl_load=no
+ac_cv_lib_dld_dld_link=no
 fi
 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
 LIBS=$ac_check_lib_save_LIBS
 fi
-echo "$as_me:6664: result: $ac_cv_lib_dld_shl_load" >&5
-echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6
-if test $ac_cv_lib_dld_shl_load = yes; then
+echo "$as_me:$LINENO: result: $ac_cv_lib_dld_dld_link" >&5
+echo "${ECHO_T}$ac_cv_lib_dld_dld_link" >&6
+if test $ac_cv_lib_dld_dld_link = yes; then
   lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"
 fi
 
+
+fi
+
+
 fi
 
+
 fi
 
+
 fi
 
+
 fi
 
     ;;
@@ -6695,7 +7820,7 @@
     save_LIBS="$LIBS"
     LIBS="$lt_cv_dlopen_libs $LIBS"
 
-    echo "$as_me:6698: checking whether a program can dlopen itself" >&5
+    echo "$as_me:$LINENO: checking whether a program can dlopen itself" >&5
 echo $ECHO_N "checking whether a program can dlopen itself... $ECHO_C" >&6
 if test "${lt_cv_dlopen_self+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -6706,7 +7831,7 @@
     lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 6709 "configure"
+#line 7834 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -6767,10 +7892,10 @@
     exit (status);
 }
 EOF
-  if { (eval echo "$as_me:6770: \"$ac_link\"") >&5
+  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:6773: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
     (./conftest; exit; ) 2>/dev/null
     lt_status=$?
@@ -6786,13 +7911,14 @@
 fi
 rm -fr conftest*
 
+
 fi
-echo "$as_me:6790: result: $lt_cv_dlopen_self" >&5
+echo "$as_me:$LINENO: result: $lt_cv_dlopen_self" >&5
 echo "${ECHO_T}$lt_cv_dlopen_self" >&6
 
     if test "x$lt_cv_dlopen_self" = xyes; then
       LDFLAGS="$LDFLAGS $link_static_flag"
-      echo "$as_me:6795: checking whether a statically linked program can dlopen itself" >&5
+      echo "$as_me:$LINENO: checking whether a statically linked program can dlopen itself" >&5
 echo $ECHO_N "checking whether a statically linked program can dlopen itself... $ECHO_C" >&6
 if test "${lt_cv_dlopen_self_static+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -6803,7 +7929,7 @@
     lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext <<EOF
-#line 6806 "configure"
+#line 7932 "configure"
 #include "confdefs.h"
 
 #if HAVE_DLFCN_H
@@ -6864,10 +7990,10 @@
     exit (status);
 }
 EOF
-  if { (eval echo "$as_me:6867: \"$ac_link\"") >&5
+  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
   (eval $ac_link) 2>&5
   ac_status=$?
-  echo "$as_me:6870: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
     (./conftest; exit; ) 2>/dev/null
     lt_status=$?
@@ -6883,8 +8009,9 @@
 fi
 rm -fr conftest*
 
+
 fi
-echo "$as_me:6887: result: $lt_cv_dlopen_self_static" >&5
+echo "$as_me:$LINENO: result: $lt_cv_dlopen_self_static" >&5
 echo "${ECHO_T}$lt_cv_dlopen_self_static" >&6
     fi
 
@@ -6905,6 +8032,7 @@
   esac
 fi
 
+
 ## FIXME: this should be a separate macro
 ##
 if test "$enable_shared" = yes && test "$GCC" = yes; then
@@ -6916,7 +8044,7 @@
     # Test whether the compiler implicitly links with -lc since on some
     # systems, -lgcc has to come before -lc. If gcc already passes -lc
     # to ld, don't add -lc before -lgcc.
-    echo "$as_me:6919: checking whether -lc should be explicitly linked in" >&5
+    echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5
 echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6
     if test "${lt_cv_archive_cmds_need_lc+set}" = set; then
   echo $ECHO_N "(cached) $ECHO_C" >&6
@@ -6924,10 +8052,10 @@
   $rm conftest*
     echo 'static int dummy;' > conftest.$ac_ext
 
-    if { (eval echo "$as_me:6927: \"$ac_compile\"") >&5
+    if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
-  echo "$as_me:6930: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
       soname=conftest
       lib=conftest
@@ -6941,10 +8069,10 @@
       libname=conftest
       save_allow_undefined_flag=$allow_undefined_flag
       allow_undefined_flag=
-      if { (eval echo "$as_me:6944: \"$archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5
+      if { (eval echo "$as_me:$LINENO: \"$archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1\"") >&5
   (eval $archive_cmds 2\>\&1 \| grep \" -lc \" \>/dev/null 2\>\&1) 2>&5
   ac_status=$?
-  echo "$as_me:6947: \$? = $ac_status" >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }
       then
 	lt_cv_archive_cmds_need_lc=no
@@ -6957,7 +8085,7 @@
     fi
 fi
 
-    echo "$as_me:6960: result: $lt_cv_archive_cmds_need_lc" >&5
+    echo "$as_me:$LINENO: result: $lt_cv_archive_cmds_need_lc" >&5
 echo "${ECHO_T}$lt_cv_archive_cmds_need_lc" >&6
     ;;
   esac
@@ -7002,6 +8130,7 @@
     old_striplib striplib file_magic_cmd export_symbols_cmds \
     deplibs_check_method allow_undefined_flag no_undefined_flag \
     finish_cmds finish_eval global_symbol_pipe global_symbol_to_cdecl \
+    global_symbol_to_c_name_address \
     hardcode_libdir_flag_spec hardcode_libdir_separator  \
     sys_lib_search_path_spec sys_lib_dlsearch_path_spec \
     compiler_c_o compiler_o_lo need_locks exclude_expsyms include_expsyms; do
@@ -7068,12 +8197,12 @@
 # Whether or not to build shared libraries.
 build_libtool_libs=$enable_shared
 
-# Whether or not to add -lc for building shared libraries.
-build_libtool_need_lc=$need_lc
-
 # Whether or not to build static libraries.
 build_old_libs=$enable_static
 
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$need_lc
+
 # Whether or not to optimize for fast installation.
 fast_install=$enable_fast_install
 
@@ -7239,6 +8368,9 @@
 # Transform the output of nm in a proper C declaration
 global_symbol_to_cdecl=$lt_global_symbol_to_cdecl
 
+# Transform the output of nm in a C name address pair
+global_symbol_to_c_name_address=$lt_global_symbol_to_c_name_address
+
 # This is the shared library runtime path variable.
 runpath_var=$runpath_var
 
@@ -7361,9 +8493,9 @@
 #   return TRUE;
 # }
 # /* ltdll.c ends here */
-        # This is a source program that is used to create import libraries
-        # on Windows for dlls which lack them. Don't remove nor modify the
-        # starting and closing comments
+	# This is a source program that is used to create import libraries
+	# on Windows for dlls which lack them. Don't remove nor modify the
+	# starting and closing comments
 # /* impgen.c starts here */
 # /*   Copyright (C) 1999-2000 Free Software Foundation, Inc.
 #
@@ -7516,6 +8648,10 @@
 ##
 ## END FIXME
 
+
+
+
+
 # This can be used to rebuild libtool when needed
 LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"
 
@@ -7524,8 +8660,12 @@
 
 # Prevent multiple expansion
 
+
+
 ac_config_files="$ac_config_files unix-cc.mk:unix-cc.in unix-def.mk:unix-def.in freetype-config"
 
+
+
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
 # tests run on this system so they can be shared between configure
@@ -7602,25 +8742,29 @@
 
 DEFS=-DHAVE_CONFIG_H
 
+
 : ${CONFIG_STATUS=./config.status}
 ac_clean_files_save=$ac_clean_files
 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ echo "$as_me:7608: creating $CONFIG_STATUS" >&5
+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
 echo "$as_me: creating $CONFIG_STATUS" >&6;}
 cat >$CONFIG_STATUS <<_ACEOF
 #! $SHELL
-# Generated automatically by configure.
+# Generated by $as_me.
 # Run this file to recreate the current configuration.
 # Compiler output produced by configure, useful for debugging
 # configure, is in config.log if it exists.
 
 debug=false
 SHELL=\${CONFIG_SHELL-$SHELL}
-ac_cs_invocation="\$0 \$@"
-
 _ACEOF
 
 cat >>$CONFIG_STATUS <<\_ACEOF
+
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
 # Be Bourne compatible
 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
   emulate sh
@@ -7629,9 +8773,168 @@
   set -o posix
 fi
 
+# NLS nuisances.
+# Support unset when possible.
+if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+(set +x; test -n "`(LANG=C; export LANG) 2>&1`") &&
+    { $as_unset LANG || test "${LANG+set}" != set; } ||
+      { LANG=C; export LANG; }
+(set +x; test -n "`(LC_ALL=C; export LC_ALL) 2>&1`") &&
+    { $as_unset LC_ALL || test "${LC_ALL+set}" != set; } ||
+      { LC_ALL=C; export LC_ALL; }
+(set +x; test -n "`(LC_TIME=C; export LC_TIME) 2>&1`") &&
+    { $as_unset LC_TIME || test "${LC_TIME+set}" != set; } ||
+      { LC_TIME=C; export LC_TIME; }
+(set +x; test -n "`(LC_CTYPE=C; export LC_CTYPE) 2>&1`") &&
+    { $as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set; } ||
+      { LC_CTYPE=C; export LC_CTYPE; }
+(set +x; test -n "`(LANGUAGE=C; export LANGUAGE) 2>&1`") &&
+    { $as_unset LANGUAGE || test "${LANGUAGE+set}" != set; } ||
+      { LANGUAGE=C; export LANGUAGE; }
+(set +x; test -n "`(LC_COLLATE=C; export LC_COLLATE) 2>&1`") &&
+    { $as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set; } ||
+      { LC_COLLATE=C; export LC_COLLATE; }
+(set +x; test -n "`(LC_NUMERIC=C; export LC_NUMERIC) 2>&1`") &&
+    { $as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set; } ||
+      { LC_NUMERIC=C; export LC_NUMERIC; }
+(set +x; test -n "`(LC_MESSAGES=C; export LC_MESSAGES) 2>&1`") &&
+    { $as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set; } ||
+      { LC_MESSAGES=C; export LC_MESSAGES; }
+
+
 # Name of the executable.
-as_me=`echo "$0" |sed 's,.*[\\/],,'`
+as_me=`(basename "$0") 2>/dev/null ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)$' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\/\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conftest.sh
+  echo  "exit 0"   >>conftest.sh
+  chmod +x conftest.sh
+  if (PATH=".;."; conftest.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conftest.sh
+fi
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+  # Find who we are.  Look in the path if we contain no path at all
+  # relative or not.
+  case $0 in
+    *[\\/]* ) as_myself=$0 ;;
+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+       ;;
+  esac
+  # We did not find ourselves, most probably we were run as `sh COMMAND'
+  # in which case we are not to be found in the path.
+  if test "x$as_myself" = x; then
+    as_myself=$0
+  fi
+  if test ! -f "$as_myself"; then
+    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+   { (exit 1); exit 1; }; }
+  fi
+  case $CONFIG_SHELL in
+  '')
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for as_base in sh bash ksh sh5; do
+	 case $as_dir in
+	 /*)
+	   if ("$as_dir/$as_base" -c '
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+	     CONFIG_SHELL=$as_dir/$as_base
+	     export CONFIG_SHELL
+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+	   fi;;
+	 esac
+       done
+done
+;;
+  esac
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line before each line; the second 'sed' does the real
+  # work.  The second script uses 'N' to pair each line-number line
+  # with the numbered line, and appends trailing '-' during
+  # substitution so that $LINENO is not a special case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+  sed '=' <$as_myself |
+    sed '
+      N
+      s,$,-,
+      : loop
+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      t loop
+      s,-$,,
+      s,^['$as_cr_digits']*\n,,
+    ' >$as_me.lineno &&
+  chmod +x $as_me.lineno ||
+    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
+   { (exit 1); exit 1; }; }
 
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensible to this).
+  . ./$as_me.lineno
+  # Exit status is that of the last command.
+  exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T='	' ;;
+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
 if expr a : '\(a\)' >/dev/null 2>&1; then
   as_expr=expr
 else
@@ -7658,23 +8961,13 @@
 
 as_executable_p="test -f"
 
-# Support unset when possible.
-if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
-  as_unset=unset
-else
-  as_unset=false
-fi
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
 
-# NLS nuisances.
-$as_unset LANG || test "${LANG+set}" != set || { LANG=C; export LANG; }
-$as_unset LC_ALL || test "${LC_ALL+set}" != set || { LC_ALL=C; export LC_ALL; }
-$as_unset LC_TIME || test "${LC_TIME+set}" != set || { LC_TIME=C; export LC_TIME; }
-$as_unset LC_CTYPE || test "${LC_CTYPE+set}" != set || { LC_CTYPE=C; export LC_CTYPE; }
-$as_unset LANGUAGE || test "${LANGUAGE+set}" != set || { LANGUAGE=C; export LANGUAGE; }
-$as_unset LC_COLLATE || test "${LC_COLLATE+set}" != set || { LC_COLLATE=C; export LC_COLLATE; }
-$as_unset LC_NUMERIC || test "${LC_NUMERIC+set}" != set || { LC_NUMERIC=C; export LC_NUMERIC; }
-$as_unset LC_MESSAGES || test "${LC_MESSAGES+set}" != set || { LC_MESSAGES=C; export LC_MESSAGES; }
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
 
+
 # IFS
 # We need space, tab and new line, in precisely that order.
 as_nl='
@@ -7682,10 +8975,34 @@
 IFS=" 	$as_nl"
 
 # CDPATH.
-$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=:; export CDPATH; }
+$as_unset CDPATH || test "${CDPATH+set}" != set || { CDPATH=$PATH_SEPARATOR; export CDPATH; }
 
 exec 6>&1
 
+# Open the log real soon, to keep \$[0] and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.  Logging --version etc. is OK.
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+} >&5
+cat >&5 <<_CSEOF
+
+This file was extended by $as_me, which was
+generated by GNU Autoconf 2.53.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+_CSEOF
+echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+echo >&5
 _ACEOF
 
 # Files that config.status was made for.
@@ -7705,7 +9022,7 @@
   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
 fi
 
-cat >>$CONFIG_STATUS <<\EOF
+cat >>$CONFIG_STATUS <<\_ACEOF
 
 ac_cs_usage="\
 \`$as_me' instantiates files from templates according to the
@@ -7729,12 +9046,12 @@
 $config_headers
 
 Report bugs to <bug-autoconf@gnu.org>."
-EOF
+_ACEOF
 
-cat >>$CONFIG_STATUS <<EOF
+cat >>$CONFIG_STATUS <<_ACEOF
 ac_cs_version="\\
 config.status
-configured by $0, generated by GNU Autoconf 2.52,
+configured by $0, generated by GNU Autoconf 2.53,
   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
 
 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
@@ -7743,9 +9060,9 @@
 gives unlimited permission to copy, distribute and modify it."
 srcdir=$srcdir
 INSTALL="$INSTALL"
-EOF
+_ACEOF
 
-cat >>$CONFIG_STATUS <<\EOF
+cat >>$CONFIG_STATUS <<\_ACEOF
 # If no file are specified by the user, then we need to provide default
 # value.  By we need to know if files were specified by the user.
 ac_need_defaults=:
@@ -7767,18 +9084,18 @@
 
   case $1 in
   # Handling of the options.
-EOF
-cat >>$CONFIG_STATUS <<EOF
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
     echo "running $SHELL $0 " $ac_configure_args " --no-create --no-recursion"
     exec $SHELL $0 $ac_configure_args --no-create --no-recursion ;;
-EOF
-cat >>$CONFIG_STATUS <<\EOF
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
   --version | --vers* | -V )
     echo "$ac_cs_version"; exit 0 ;;
   --he | --h)
     # Conflict between --help and --header
-    { { echo "$as_me:7781: error: ambiguous option: $1
+    { { echo "$as_me:$LINENO: error: ambiguous option: $1
 Try \`$0 --help' for more information." >&5
 echo "$as_me: error: ambiguous option: $1
 Try \`$0 --help' for more information." >&2;}
@@ -7797,7 +9114,7 @@
     ac_need_defaults=false;;
 
   # This is an error.
-  -*) { { echo "$as_me:7800: error: unrecognized option: $1
+  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
 Try \`$0 --help' for more information." >&5
 echo "$as_me: error: unrecognized option: $1
 Try \`$0 --help' for more information." >&2;}
@@ -7809,25 +9126,13 @@
   shift
 done
 
-exec 5>>config.log
-cat >&5 << _ACEOF
+_ACEOF
 
-## ----------------------- ##
-## Running config.status.  ##
-## ----------------------- ##
 
-This file was extended by $as_me 2.52, executed with
-  CONFIG_FILES    = $CONFIG_FILES
-  CONFIG_HEADERS  = $CONFIG_HEADERS
-  CONFIG_LINKS    = $CONFIG_LINKS
-  CONFIG_COMMANDS = $CONFIG_COMMANDS
-  > $ac_cs_invocation
-on `(hostname || uname -n) 2>/dev/null | sed 1q`
 
-_ACEOF
-EOF
+
 
-cat >>$CONFIG_STATUS <<\EOF
+cat >>$CONFIG_STATUS <<\_ACEOF
 for ac_config_target in $ac_config_targets
 do
   case "$ac_config_target" in
@@ -7836,7 +9141,7 @@
   "unix-def.mk" ) CONFIG_FILES="$CONFIG_FILES unix-def.mk:unix-def.in" ;;
   "freetype-config" ) CONFIG_FILES="$CONFIG_FILES freetype-config" ;;
   "ftconfig.h" ) CONFIG_HEADERS="$CONFIG_HEADERS ftconfig.h:ftconfig.in" ;;
-  *) { { echo "$as_me:7839: error: invalid argument: $ac_config_target" >&5
+  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
    { (exit 1); exit 1; }; };;
   esac
@@ -7873,9 +9178,9 @@
    { (exit 1); exit 1; }
 }
 
-EOF
+_ACEOF
 
-cat >>$CONFIG_STATUS <<EOF
+cat >>$CONFIG_STATUS <<_ACEOF
 
 #
 # CONFIG_FILES section.
@@ -7888,6 +9193,12 @@
   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
 s,@SHELL@,$SHELL,;t t
+s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
 s,@exec_prefix@,$exec_prefix,;t t
 s,@prefix@,$prefix,;t t
 s,@program_transform_name@,$program_transform_name,;t t
@@ -7903,19 +9214,13 @@
 s,@oldincludedir@,$oldincludedir,;t t
 s,@infodir@,$infodir,;t t
 s,@mandir@,$mandir,;t t
-s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
-s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
-s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
-s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
-s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
 s,@build_alias@,$build_alias,;t t
 s,@host_alias@,$host_alias,;t t
 s,@target_alias@,$target_alias,;t t
+s,@DEFS@,$DEFS,;t t
 s,@ECHO_C@,$ECHO_C,;t t
 s,@ECHO_N@,$ECHO_N,;t t
 s,@ECHO_T@,$ECHO_T,;t t
-s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
-s,@DEFS@,$DEFS,;t t
 s,@LIBS@,$LIBS,;t t
 s,@version_info@,$version_info,;t t
 s,@ft_version@,$ft_version,;t t
@@ -7956,9 +9261,9 @@
 s,@LIBTOOL@,$LIBTOOL,;t t
 CEOF
 
-EOF
+_ACEOF
 
-  cat >>$CONFIG_STATUS <<\EOF
+  cat >>$CONFIG_STATUS <<\_ACEOF
   # Split the substitutions into bite-sized pieces for seds with
   # small command number limits, like on Digital OSF/1 and HP-UX.
   ac_max_sed_lines=48
@@ -7997,8 +9302,8 @@
   fi
 fi # test -n "$CONFIG_FILES"
 
-EOF
-cat >>$CONFIG_STATUS <<\EOF
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
   case $ac_file in
@@ -8012,7 +9317,8 @@
   esac
 
   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
-  ac_dir=`$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
          X"$ac_file" : 'X\(//\)[^/]' \| \
          X"$ac_file" : 'X\(//\)$' \| \
          X"$ac_file" : 'X\(/\)' \| \
@@ -8023,8 +9329,7 @@
   	  /^X\(\/\/\)$/{ s//\1/; q; }
   	  /^X\(\/\).*/{ s//\1/; q; }
   	  s/.*/./; q'`
-  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
-    { case "$ac_dir" in
+  { case "$ac_dir" in
   [\\/]* | ?:[\\/]* ) as_incr_dir=;;
   *)                      as_incr_dir=.;;
 esac
@@ -8035,48 +9340,68 @@
     ?:) as_incr_dir=$as_mkdir_dir ;;
     *)
       as_incr_dir=$as_incr_dir/$as_mkdir_dir
-      test -d "$as_incr_dir" || mkdir "$as_incr_dir"
+      test -d "$as_incr_dir" ||
+        mkdir "$as_incr_dir" ||
+	{ { echo "$as_me:$LINENO: error: cannot create \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create \"$ac_dir\"" >&2;}
+   { (exit 1); exit 1; }; }
     ;;
   esac
 done; }
 
-    ac_dir_suffix="/`echo $ac_dir|sed 's,^\./,,'`"
-    # A "../" for each directory in $ac_dir_suffix.
-    ac_dots=`echo "$ac_dir_suffix" | sed 's,/[^/]*,../,g'`
-  else
-    ac_dir_suffix= ac_dots=
-  fi
+  ac_builddir=.
 
-  case $srcdir in
-  .)  ac_srcdir=.
-      if test -z "$ac_dots"; then
-         ac_top_srcdir=.
-      else
-         ac_top_srcdir=`echo $ac_dots | sed 's,/$,,'`
-      fi ;;
-  [\\/]* | ?:[\\/]* )
-      ac_srcdir=$srcdir$ac_dir_suffix;
-      ac_top_srcdir=$srcdir ;;
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
   *) # Relative path.
-    ac_srcdir=$ac_dots$srcdir$ac_dir_suffix
-    ac_top_srcdir=$ac_dots$srcdir ;;
-  esac
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
+# absolute.
+ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
+ac_abs_top_builddir=`cd "$ac_dir" && cd $ac_top_builddir && pwd`
+ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
+ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
 
+
   case $INSTALL in
   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
-  *) ac_INSTALL=$ac_dots$INSTALL ;;
+  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
   esac
 
   if test x"$ac_file" != x-; then
-    { echo "$as_me:8071: creating $ac_file" >&5
+    { echo "$as_me:$LINENO: creating $ac_file" >&5
 echo "$as_me: creating $ac_file" >&6;}
     rm -f "$ac_file"
   fi
   # Let's still pretend it is `configure' which instantiates (i.e., don't
   # use $as_me), people would be surprised to read:
-  #    /* config.h.  Generated automatically by config.status.  */
-  configure_input="Generated automatically from `echo $ac_file_in |
-                                                 sed 's,.*/,,'` by configure."
+  #    /* config.h.  Generated by config.status.  */
+  if test x"$ac_file" = x-; then
+    configure_input=
+  else
+    configure_input="$ac_file.  "
+  fi
+  configure_input=$configure_input"Generated from `echo $ac_file_in |
+                                     sed 's,.*/,,'` by configure."
 
   # First look for the input files in the build tree, otherwise in the
   # src tree.
@@ -8086,7 +9411,7 @@
       -) echo $tmp/stdin ;;
       [\\/$]*)
          # Absolute (can't be DOS-style, as IFS=:)
-         test -f "$f" || { { echo "$as_me:8089: error: cannot find input file: $f" >&5
+         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 echo "$as_me: error: cannot find input file: $f" >&2;}
    { (exit 1); exit 1; }; }
          echo $f;;
@@ -8099,23 +9424,29 @@
            echo $srcdir/$f
          else
            # /dev/null tree
-           { { echo "$as_me:8102: error: cannot find input file: $f" >&5
+           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 echo "$as_me: error: cannot find input file: $f" >&2;}
    { (exit 1); exit 1; }; }
          fi;;
       esac
     done` || { (exit 1); exit 1; }
-EOF
-cat >>$CONFIG_STATUS <<EOF
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
   sed "$ac_vpsub
 $extrasub
-EOF
-cat >>$CONFIG_STATUS <<\EOF
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
 :t
 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
 s,@configure_input@,$configure_input,;t t
 s,@srcdir@,$ac_srcdir,;t t
+s,@abs_srcdir@,$ac_abs_srcdir,;t t
 s,@top_srcdir@,$ac_top_srcdir,;t t
+s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+s,@builddir@,$ac_builddir,;t t
+s,@abs_builddir@,$ac_abs_builddir,;t t
+s,@top_builddir@,$ac_top_builddir,;t t
+s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
 s,@INSTALL@,$ac_INSTALL,;t t
 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
   rm -f $tmp/stdin
@@ -8127,8 +9458,8 @@
   fi
 
 done
-EOF
-cat >>$CONFIG_STATUS <<\EOF
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
 
 #
 # CONFIG_HEADER section.
@@ -8160,7 +9491,7 @@
   * )   ac_file_in=$ac_file.in ;;
   esac
 
-  test x"$ac_file" != x- && { echo "$as_me:8163: creating $ac_file" >&5
+  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
 echo "$as_me: creating $ac_file" >&6;}
 
   # First look for the input files in the build tree, otherwise in the
@@ -8171,7 +9502,7 @@
       -) echo $tmp/stdin ;;
       [\\/$]*)
          # Absolute (can't be DOS-style, as IFS=:)
-         test -f "$f" || { { echo "$as_me:8174: error: cannot find input file: $f" >&5
+         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 echo "$as_me: error: cannot find input file: $f" >&2;}
    { (exit 1); exit 1; }; }
          echo $f;;
@@ -8184,7 +9515,7 @@
            echo $srcdir/$f
          else
            # /dev/null tree
-           { { echo "$as_me:8187: error: cannot find input file: $f" >&5
+           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
 echo "$as_me: error: cannot find input file: $f" >&2;}
    { (exit 1); exit 1; }; }
          fi;;
@@ -8193,7 +9524,7 @@
   # Remove the trailing spaces.
   sed 's/[ 	]*$//' $ac_file_inputs >$tmp/in
 
-EOF
+_ACEOF
 
 # Transform confdefs.h into two sed scripts, `conftest.defines' and
 # `conftest.undefs', that substitutes the proper values into
@@ -8209,16 +9540,16 @@
 # `end' is used to avoid that the second main sed command (meant for
 # 0-ary CPP macros) applies to n-ary macro definitions.
 # See the Autoconf documentation for `clear'.
-cat >confdef2sed.sed <<\EOF
+cat >confdef2sed.sed <<\_ACEOF
 s/[\\&,]/\\&/g
 s,[\\$`],\\&,g
 t clear
 : clear
-s,^[ 	]*#[ 	]*define[ 	][ 	]*\(\([^ 	(][^ 	(]*\)([^)]*)\)[ 	]*\(.*\)$,${ac_dA}\2${ac_dB}\1${ac_dC}\3${ac_dD},gp
+s,^[ 	]*#[ 	]*define[ 	][ 	]*\([^ 	(][^ 	(]*\)\(([^)]*)\)[ 	]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
 t end
 s,^[ 	]*#[ 	]*define[ 	][ 	]*\([^ 	][^ 	]*\)[ 	]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
 : end
-EOF
+_ACEOF
 # If some macros were called several times there might be several times
 # the same #defines, which is useless.  Nevertheless, we may not want to
 # sort them, since we want the *last* AC-DEFINE to be honored.
@@ -8229,9 +9560,9 @@
 # This sed command replaces #undef with comments.  This is necessary, for
 # example, in the case of _POSIX_SOURCE, which is predefined and required
 # on some systems where configure will not decide to define it.
-cat >>conftest.undefs <<\EOF
+cat >>conftest.undefs <<\_ACEOF
 s,^[ 	]*#[ 	]*undef[ 	][ 	]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
-EOF
+_ACEOF
 
 # Break up conftest.defines because some shells have a limit on the size
 # of here documents, and old seds have small limits too (100 cmds).
@@ -8288,23 +9619,24 @@
 done
 rm -f conftest.undefs
 
-cat >>$CONFIG_STATUS <<\EOF
+cat >>$CONFIG_STATUS <<\_ACEOF
   # Let's still pretend it is `configure' which instantiates (i.e., don't
   # use $as_me), people would be surprised to read:
-  #    /* config.h.  Generated automatically by config.status.  */
+  #    /* config.h.  Generated by config.status.  */
   if test x"$ac_file" = x-; then
-    echo "/* Generated automatically by configure.  */" >$tmp/config.h
+    echo "/* Generated by configure.  */" >$tmp/config.h
   else
-    echo "/* $ac_file.  Generated automatically by configure.  */" >$tmp/config.h
+    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
   fi
   cat $tmp/in >>$tmp/config.h
   rm -f $tmp/in
   if test x"$ac_file" != x-; then
     if cmp -s $ac_file $tmp/config.h 2>/dev/null; then
-      { echo "$as_me:8304: $ac_file is unchanged" >&5
+      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
 echo "$as_me: $ac_file is unchanged" >&6;}
     else
-      ac_dir=`$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
          X"$ac_file" : 'X\(//\)[^/]' \| \
          X"$ac_file" : 'X\(//\)$' \| \
          X"$ac_file" : 'X\(/\)' \| \
@@ -8315,8 +9647,7 @@
   	  /^X\(\/\/\)$/{ s//\1/; q; }
   	  /^X\(\/\).*/{ s//\1/; q; }
   	  s/.*/./; q'`
-      if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
-        { case "$ac_dir" in
+      { case "$ac_dir" in
   [\\/]* | ?:[\\/]* ) as_incr_dir=;;
   *)                      as_incr_dir=.;;
 esac
@@ -8327,12 +9658,15 @@
     ?:) as_incr_dir=$as_mkdir_dir ;;
     *)
       as_incr_dir=$as_incr_dir/$as_mkdir_dir
-      test -d "$as_incr_dir" || mkdir "$as_incr_dir"
+      test -d "$as_incr_dir" ||
+        mkdir "$as_incr_dir" ||
+	{ { echo "$as_me:$LINENO: error: cannot create \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create \"$ac_dir\"" >&2;}
+   { (exit 1); exit 1; }; }
     ;;
   esac
 done; }
 
-      fi
       rm -f $ac_file
       mv $tmp/config.h $ac_file
     fi
@@ -8341,15 +9675,16 @@
     rm -f $tmp/config.h
   fi
 done
-EOF
+_ACEOF
 
-cat >>$CONFIG_STATUS <<\EOF
+cat >>$CONFIG_STATUS <<\_ACEOF
 
 { (exit 0); exit 0; }
-EOF
+_ACEOF
 chmod +x $CONFIG_STATUS
 ac_clean_files=$ac_clean_files_save
 
+
 # configure is writing to config.log, and then calls config.status.
 # config.status does its own redirection, appending to config.log.
 # Unfortunately, on DOS this fails, as config.log is still kept open
@@ -8367,4 +9702,5 @@
   # would make configure fail if this is the last instruction.
   $ac_cs_success || { (exit 1); exit 1; }
 fi
+
 
Index: xc/extras/freetype2/builds/unix/configure.ac
diff -u xc/extras/freetype2/builds/unix/configure.ac:1.1.1.2 xc/extras/freetype2/builds/unix/configure.ac:1.1.1.5
--- xc/extras/freetype2/builds/unix/configure.ac:1.1.1.2	Mon Jan 14 11:52:00 2002
+++ xc/extras/freetype2/builds/unix/configure.ac	Thu Jun 20 04:16:02 2002
@@ -9,7 +9,7 @@
 dnl configuration file -- stay in 8.3 limit
 AC_CONFIG_HEADER(ftconfig.h:ftconfig.in)
 
-version_info='8:0:2'
+version_info='9:1:3'
 AC_SUBST(version_info)
 ft_version=`echo $version_info | tr : .`
 AC_SUBST(ft_version)
@@ -86,6 +86,11 @@
 dnl and 'builds/unix/unix-cc.mk' that will be used by the build system
 dnl
 AC_CONFIG_FILES([unix-cc.mk:unix-cc.in unix-def.mk:unix-def.in freetype-config])
+
+dnl re-generate the Jamfile to use libtool now
+dnl
+dnl AC_CONFIG_FILES([../../Jamfile:../../Jamfile.in])
+
 AC_OUTPUT
 
 dnl end of configure.ac
Index: xc/extras/freetype2/builds/unix/detect.mk
diff -u xc/extras/freetype2/builds/unix/detect.mk:1.1.1.3 xc/extras/freetype2/builds/unix/detect.mk:1.1.1.4
--- xc/extras/freetype2/builds/unix/detect.mk:1.1.1.3	Sun Sep  9 22:55:51 2001
+++ xc/extras/freetype2/builds/unix/detect.mk	Thu Jun 20 04:16:02 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -72,8 +72,15 @@
 
   setup: std_setup
 
-  unix-def.mk: $(TOP)/builds/unix/unix-def.in
-	  cd builds/unix; ./configure $(CFG)
+  have_mk := $(strip $(wildcard $(OBJ_DIR)/Makefile))
+  ifneq ($(have_mk),)
+    # we are building FT2 not in the src tree
+    unix-def.mk: $(TOP)/builds/unix/unix-def.in
+	    $(TOP)/builds/unix/configure $(CFG)
+  else
+    unix-def.mk: $(TOP)/builds/unix/unix-def.in
+	    cd builds/unix; ./configure $(CFG)
+  endif
 
 endif   # test PLATFORM unix
 
Index: xc/extras/freetype2/builds/unix/freetype-config.in
diff -u xc/extras/freetype2/builds/unix/freetype-config.in:1.1.1.3 xc/extras/freetype2/builds/unix/freetype-config.in:1.1.1.4
--- xc/extras/freetype2/builds/unix/freetype-config.in:1.1.1.3	Mon Jan 14 11:52:00 2002
+++ xc/extras/freetype2/builds/unix/freetype-config.in	Thu Feb 14 19:33:20 2002
@@ -18,11 +18,11 @@
   exit $1
 }
 
-if test $# -eq 0; then
+if test $# -eq 0 ; then
   usage 1 1>&2
 fi
 
-while test $# -gt 0; do
+while test $# -gt 0 ; do
   case "$1" in
   -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
   *) optarg= ;;
@@ -65,25 +65,29 @@
 done
 
 if test "$local_prefix" = "yes" ; then
-    if test "$exec_prefix_set" != "yes"; then
+    if test "$exec_prefix_set" != "yes" ; then
       exec_prefix=$prefix
     fi
 fi
 
-if test "$echo_prefix" = "yes"; then
+if test "$echo_prefix" = "yes" ; then
  echo $prefix
 fi
 
-if test "$echo_exec_prefix" = "yes"; then
+if test "$echo_exec_prefix" = "yes" ; then
  echo $exec_prefix
 fi
 
-if test "$echo_cflags" = "yes"; then
+if test "$echo_cflags" = "yes" ; then
  cflags="-I@includedir@/freetype2"
- echo $cflags $includes
+ if test "@includedir@" != "/usr/include" ; then
+  echo -I@includedir@ $cflags
+ else
+  echo $cflags
+ fi
 fi
 
-if test "$echo_libs" = "yes"; then
+if test "$echo_libs" = "yes" ; then
  libs="-lfreetype"
  if test "@libdir@" != "/usr/lib" ; then
   echo -L@libdir@ $libs
@@ -92,7 +96,7 @@
  fi
 fi
 
-if test "$echo_libtool" = "yes"; then
+if test "$echo_libtool" = "yes" ; then
  convlib="libfreetype.la"
  echo @libdir@/$convlib
 fi
Index: xc/extras/freetype2/builds/unix/freetype2.m4
diff -u xc/extras/freetype2/builds/unix/freetype2.m4:1.1.1.1 xc/extras/freetype2/builds/unix/freetype2.m4:1.1.1.2
--- xc/extras/freetype2/builds/unix/freetype2.m4:1.1.1.1	Mon Jan 14 11:52:00 2002
+++ xc/extras/freetype2/builds/unix/freetype2.m4	Thu Feb 14 19:33:20 2002
@@ -1,23 +1,25 @@
 # Configure paths for FreeType2
 # Marcelo Magallon 2001-10-26, based on gtk.m4 by Owen Taylor
 
-dnl AM_CHECK_FT2([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
+dnl AC_CHECK_FT2([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
 dnl Test for FreeType2, and define FT2_CFLAGS and FT2_LIBS
 dnl
 AC_DEFUN(AC_CHECK_FT2,
 [dnl
 dnl Get the cflags and libraries from the freetype-config script
 dnl
-AC_ARG_WITH(freetype-prefix,
-[  --with-ft-prefix=PFX      Prefix where FreeType is installed (optional)],
+AC_ARG_WITH(ft-prefix,
+[  --with-ft-prefix=PREFIX
+                          Prefix where FreeType is installed (optional)],
             ft_config_prefix="$withval", ft_config_prefix="")
-AC_ARG_WITH(freetype-exec-prefix,
-[  --with-ft-exec-prefix=PFX Exec prefix where FreeType is installed (optional)],
+AC_ARG_WITH(ft-exec-prefix,
+[  --with-ft-exec-prefix=PREFIX
+                          Exec prefix where FreeType is installed (optional)],
             ft_config_exec_prefix="$withval", ft_config_exec_prefix="")
 AC_ARG_ENABLE(freetypetest,
-[  --disable-freetypetest    Do not try to compile and run
-                            a test FreeType program],
-            [], enable_fttest=yes)
+[  --disable-freetypetest  Do not try to compile and run
+                          a test FreeType program],
+              [], enable_fttest=yes)
 
 if test x$ft_config_exec_prefix != x ; then
   ft_config_args="$ft_config_args --exec-prefix=$ft_config_exec_prefix"
@@ -53,8 +55,8 @@
          sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
   ft_min_micro_version=`echo $min_ft_version | \
          sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
-  if test "x$enable_fttest" = "xyes" ; then
-    ft_config_is_lt=no
+  if test x$enable_fttest = xyes ; then
+    ft_config_is_lt=""
     if test $ft_config_major_version -lt $ft_min_major_version ; then
       ft_config_is_lt=yes
     else
@@ -70,8 +72,8 @@
         fi
       fi
     fi
-    if test "x$ft_config_is_lt" = "xyes" ; then
-      ifelse([$3], , :, [$3])
+    if test x$ft_config_is_lt = xyes ; then
+      no_ft=yes
     else
       ac_save_CFLAGS="$CFLAGS"
       ac_save_LIBS="$LIBS"
@@ -106,9 +108,9 @@
       CFLAGS="$ac_save_CFLAGS"
       LIBS="$ac_save_LIBS"
     fi             # test $ft_config_version -lt $ft_min_version
-  fi               # test "x$enable_fttest" = "xyes"
+  fi               # test x$enable_fttest = xyes
 fi                 # test "$FT2_CONFIG" = "no"
-if test "x$no_ft" = x ; then
+if test x$no_ft = x ; then
    AC_MSG_RESULT(yes)
    ifelse([$2], , :, [$2])
 else
@@ -119,10 +121,18 @@
      echo "*** your path, or set the FT2_CONFIG environment variable to the"
      echo "*** full path to freetype-config."
    else
-     echo "*** The FreeType test program failed to run.  If your system uses"
-     echo "*** shared libraries and they are installed outside the normal"
-     echo "*** system library path, make sure the variable LD_LIBRARY_PATH"
-     echo "*** (or whatever is appropiate for your system) is correctly set."
+     if test x$ft_config_is_lt = xyes ; then
+       echo "*** Your installed version of the FreeType 2 library is too old."
+       echo "*** If you have different versions of FreeType 2, make sure that"
+       echo "*** correct values for --with-ft-prefix or --with-ft-exec-prefix"
+       echo "*** are used, or set the FT2_CONFIG environment variable to the"
+       echo "*** full path to freetype-config."
+     else
+       echo "*** The FreeType test program failed to run.  If your system uses"
+       echo "*** shared libraries and they are installed outside the normal"
+       echo "*** system library path, make sure the variable LD_LIBRARY_PATH"
+       echo "*** (or whatever is appropiate for your system) is correctly set."
+     fi
    fi
    FT2_CFLAGS=""
    FT2_LIBS=""
Index: xc/extras/freetype2/builds/unix/ft-munmap.m4
diff -u /dev/null xc/extras/freetype2/builds/unix/ft-munmap.m4:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:36 2003
+++ xc/extras/freetype2/builds/unix/ft-munmap.m4	Thu Jun 20 04:16:03 2002
@@ -0,0 +1,31 @@
+## FreeType specific autoconf tests
+
+# serial 1 FT_MUNMAP_DECL
+
+AC_DEFUN(FT_MUNMAP_DECL,
+[AC_MSG_CHECKING([whether munmap must be declared])
+AC_CACHE_VAL(ft_cv_munmap_decl,
+[AC_TRY_COMPILE([
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <sys/mman.h>],
+[char *(*pfn) = (char *(*))munmap],
+ft_cv_munmap_decl=no,
+ft_cv_munmap_decl=yes)])
+AC_MSG_RESULT($ft_cv_munmap_decl)
+if test $ft_cv_munmap_decl = yes; then
+  AC_DEFINE(NEED_MUNMAP_DECL,,
+  [Define to 1 if munmap() is not defined in <sys/mman.h>])
+fi])
+
+AC_DEFUN(FT_MUNMAP_PARAM,
+[AC_MSG_CHECKING([for munmap's first parameter type])
+AC_TRY_COMPILE([
+#include <unistd.h>
+#include <sys/mman.h>
+int munmap(void *, size_t);],,
+  AC_MSG_RESULT([void *]);AC_DEFINE(MUNMAP_USES_VOIDP,,
+    [Define to 1 if the first argument of munmap is of type void *]),
+  AC_MSG_RESULT([char *]))
+])
Index: xc/extras/freetype2/builds/unix/ftconfig.in
diff -u xc/extras/freetype2/builds/unix/ftconfig.in:1.1.1.4 xc/extras/freetype2/builds/unix/ftconfig.in:1.1.1.5
--- xc/extras/freetype2/builds/unix/ftconfig.in:1.1.1.4	Sun Dec 16 12:49:17 2001
+++ xc/extras/freetype2/builds/unix/ftconfig.in	Thu Jun 20 04:16:03 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    UNIX-specific configuration file (specification only).               */
 /*                                                                         */
-/*  Copyright 1996-2000 by                                                 */
+/*  Copyright 1996-2000, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -39,6 +39,7 @@
 
 #include <ft2build.h>
 #include FT_CONFIG_OPTIONS_H
+#include FT_CONFIG_STANDARD_LIBRARY_H
 
 
 FT_BEGIN_HEADER
@@ -62,7 +63,6 @@
 #define SIZEOF_INT   2
 #define SIZEOF_LONG  2
 
-
 #define FT_SIZEOF_INT   SIZEOF_INT
 #define FT_SIZEOF_LONG  SIZEOF_LONG
 
@@ -71,8 +71,8 @@
 #define FT_ALIGNMENT  8
 
 
-  /* UNUSED is a macro used to indicate that a given parameter is not used */
-  /* -- this is only used to get rid of unpleasant compiler warnings       */
+  /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
+  /* used -- this is only used to get rid of unpleasant compiler warnings */
 #ifndef FT_UNUSED
 #define FT_UNUSED( arg )  ( (arg) = (arg) )
 #endif
@@ -141,17 +141,17 @@
 
 #ifdef FT_MAKE_OPTION_SINGLE_OBJECT
 
-#define FT_LOCAL      static
-#define FT_LOCAL_DEF  static
+#define FT_LOCAL( x )      static  x
+#define FT_LOCAL_DEF( x )  static  x
 
 #else
 
 #ifdef __cplusplus
-#define FT_LOCAL      extern "C"
-#define FT_LOCAL_DEF  extern "C"
+#define FT_LOCAL( x )      extern "C"  x
+#define FT_LOCAL_DEF( x )  extern "C"  x
 #else
-#define FT_LOCAL      extern
-#define FT_LOCAL_DEF  extern
+#define FT_LOCAL( x )      extern  x
+#define FT_LOCAL_DEF( x )  extern  x
 #endif
 
 #endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
@@ -236,9 +236,9 @@
   /*                                                                 */
 #ifndef FT_CALLBACK_DEF
 #ifdef __cplusplus
-#define FT_CALLBACK_DEF( x )  extern "C" x
+#define FT_CALLBACK_DEF( x )  extern "C"  x
 #else
-#define FT_CALLBACK_DEF( x )  static x
+#define FT_CALLBACK_DEF( x )  static  x
 #endif
 #endif /* FT_CALLBACK_DEF */
 
Index: xc/extras/freetype2/builds/unix/ftsystem.c
diff -u xc/extras/freetype2/builds/unix/ftsystem.c:1.1.1.5 xc/extras/freetype2/builds/unix/ftsystem.c:1.1.1.6
--- xc/extras/freetype2/builds/unix/ftsystem.c:1.1.1.5	Mon Jan 14 11:52:00 2002
+++ xc/extras/freetype2/builds/unix/ftsystem.c	Thu Jun 20 04:16:03 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Unix-specific FreeType low-level system interface (body).            */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -144,9 +144,9 @@
   /*    The memory release function.                                       */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    memory  :: A pointer to the memory object.                         */
+  /*    memory :: A pointer to the memory object.                          */
   /*                                                                       */
-  /*    block   :: The address of block in memory to be freed.             */
+  /*    block  :: The address of block in memory to be freed.              */
   /*                                                                       */
   FT_CALLBACK_DEF( void )
   ft_free( FT_Memory  memory,
@@ -204,8 +204,8 @@
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Error )
-  FT_New_Stream( const char*  filepathname,
-                 FT_Stream    stream )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname )
   {
     int          file;
     struct stat  stat_buf;
@@ -218,7 +218,7 @@
     file = open( filepathname, O_RDONLY );
     if ( file < 0 )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
       return FT_Err_Cannot_Open_Resource;
     }
@@ -230,15 +230,15 @@
     /*                                                     */
 #ifdef F_SETFD
 #ifdef FD_CLOEXEC
-    (void) fcntl( file, F_SETFD, FD_CLOEXEC );
+    (void)fcntl( file, F_SETFD, FD_CLOEXEC );
 #else
-    (void) fcntl( file, F_SETFD, 1 );
+    (void)fcntl( file, F_SETFD, 1 );
 #endif /* FD_CLOEXEC */
 #endif /* F_SETFD */
 
     if ( fstat( file, &stat_buf ) < 0 )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not `fstat' file `%s'\n", filepathname ));
       goto Fail_Map;
     }
@@ -254,7 +254,7 @@
 
     if ( (long)stream->base == -1 )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));
       goto Fail_Map;
     }
@@ -267,7 +267,7 @@
     stream->close = ft_close_stream;
     stream->read  = 0;
 
-    FT_TRACE1(( "FT_New_Stream:" ));
+    FT_TRACE1(( "FT_Stream_Open:" ));
     FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
                 filepathname, stream->size ));
 
@@ -288,13 +288,13 @@
 
   extern FT_Int
   ft_mem_debug_init( FT_Memory  memory );
-  
+
   extern void
   ft_mem_debug_done( FT_Memory  memory );
-  
-#endif  
-      
 
+#endif
+
+
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Memory )
@@ -312,7 +312,7 @@
       memory->free    = ft_free;
 #ifdef FT_DEBUG_MEMORY
       ft_mem_debug_init( memory );
-#endif    
+#endif
     }
 
     return memory;
@@ -326,7 +326,7 @@
   {
 #ifdef FT_DEBUG_MEMORY
     ft_mem_debug_done( memory );
-#endif  
+#endif
     memory->free( memory, memory );
   }
 
Index: xc/extras/freetype2/builds/unix/install.mk
diff -u xc/extras/freetype2/builds/unix/install.mk:1.1.1.2 xc/extras/freetype2/builds/unix/install.mk:1.1.1.4
--- xc/extras/freetype2/builds/unix/install.mk:1.1.1.2	Tue May 15 23:45:48 2001
+++ xc/extras/freetype2/builds/unix/install.mk	Thu Jun 20 04:16:03 2002
@@ -13,7 +13,7 @@
 # fully.
 
 
-.PHONY: install uninstall
+.PHONY: install uninstall check
 
 # Unix installation and deinstallation targets.
 install: $(PROJECT_LIBRARY)
@@ -36,12 +36,12 @@
           $(INSTALL_DATA) $$P $(includedir)/freetype2/freetype/cache ; \
         done
 	$(INSTALL_DATA) $(BUILD)/ft2unix.h $(includedir)/ft2build.h
-	$(INSTALL_SCRIPT) -m 755 $(BUILD)/freetype-config \
+	$(INSTALL_SCRIPT) -m 755 $(OBJ_BUILD)/freetype-config \
           $(bindir)/freetype-config
 
 
 uninstall:
-	-$(LIBTOOL) --mode=uninstall $(RM) $(libdir)/$(PROJECT_LIBRARY)
+	-$(LIBTOOL) --mode=uninstall $(RM) $(libdir)/$(LIBRARY).$A
 	-$(DELETE) $(includedir)/freetype2/freetype/cache/*
 	-$(DELDIR) $(includedir)/freetype2/freetype/cache
 	-$(DELETE) $(includedir)/freetype2/freetype/config/*
@@ -53,6 +53,10 @@
 	-$(DELDIR) $(includedir)/freetype2
 	-$(DELETE) $(includedir)/ft2build.h
 	-$(DELETE) $(bindir)/freetype-config
+
+
+check:
+	@echo There is no validation suite for this package.
 
 
 .PHONY: clean_project_unix distclean_project_unix
Index: xc/extras/freetype2/builds/unix/ltmain.sh
diff -u xc/extras/freetype2/builds/unix/ltmain.sh:1.1.1.2 xc/extras/freetype2/builds/unix/ltmain.sh:1.1.1.3
--- xc/extras/freetype2/builds/unix/ltmain.sh:1.1.1.2	Sun Sep  9 22:55:53 2001
+++ xc/extras/freetype2/builds/unix/ltmain.sh	Tue Mar 26 23:35:43 2002
@@ -55,8 +55,8 @@
 # Constants.
 PROGRAM=ltmain.sh
 PACKAGE=libtool
-VERSION=1.4
-TIMESTAMP=" (1.920 2001/04/24 23:26:18)"
+VERSION=1.4.2
+TIMESTAMP=" (1.922.2.53 2001/09/11 03:18:52)"
 
 default_mode=
 help="Try \`$progname --help' for more information."
@@ -84,6 +84,9 @@
   save_LANG="$LANG"; LANG=C; export LANG
 fi
 
+# Make sure IFS has a sensible default
+: ${IFS=" 	"}
+
 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
   echo "$modename: not configured to build any kind of library" 1>&2
   echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
@@ -202,6 +205,11 @@
   exit 1
 fi
 
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
 if test -z "$show_help"; then
 
   # Infer the operation mode.
@@ -329,7 +337,7 @@
       -Wc,*)
 	args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 	lastarg=
-	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS=','
+	save_ifs="$IFS"; IFS=','
 	for arg in $args; do
 	  IFS="$save_ifs"
 
@@ -615,6 +623,10 @@
 	# Now arrange that obj and lo_libobj become the same file
 	$show "(cd $xdir && $LN_S $baseobj $libobj)"
 	if $run eval '(cd $xdir && $LN_S $baseobj $libobj)'; then
+	  # Unlock the critical section if it was locked
+	  if test "$need_locks" != no; then
+	    $run $rm "$lockfile"
+	  fi
 	  exit 0
 	else
 	  error=$?
@@ -1031,6 +1043,17 @@
 	    # These systems don't actually have a C library (as such)
 	    test "X$arg" = "X-lc" && continue
 	    ;;
+	  *-*-openbsd*)
+	    # Do not include libc due to us having libc/libc_r.
+	    test "X$arg" = "X-lc" && continue
+	    ;;
+	  esac
+	 elif test "X$arg" = "X-lc_r"; then
+	  case $host in
+	  *-*-openbsd*)
+	    # Do not include libc_r directly, use -pthread flag.
+	    continue
+	    ;;
 	  esac
 	fi
 	deplibs="$deplibs $arg"
@@ -1122,7 +1145,7 @@
       -Wc,*)
 	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
 	arg=
-	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS=','
+	save_ifs="$IFS"; IFS=','
 	for flag in $args; do
 	  IFS="$save_ifs"
 	  case $flag in
@@ -1140,7 +1163,7 @@
       -Wl,*)
 	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
 	arg=
-	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS=','
+	save_ifs="$IFS"; IFS=','
 	for flag in $args; do
 	  IFS="$save_ifs"
 	  case $flag in
@@ -1750,7 +1773,7 @@
 	    if test -f "$output_objdir/$soname-def"; then :
 	    else
 	      $show "extracting exported symbol list from \`$soname'"
-	      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	      save_ifs="$IFS"; IFS='~'
 	      eval cmds=\"$extract_expsyms_cmds\"
 	      for cmd in $cmds; do
 		IFS="$save_ifs"
@@ -1763,7 +1786,7 @@
 	    # Create $newlib
 	    if test -f "$output_objdir/$newlib"; then :; else
 	      $show "generating import library for \`$soname'"
-	      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	      save_ifs="$IFS"; IFS='~'
 	      eval cmds=\"$old_archive_from_expsyms_cmds\"
 	      for cmd in $cmds; do
 		IFS="$save_ifs"
@@ -1911,17 +1934,17 @@
 	      echo "*** Therefore, libtool will create a static module, that should work "
 	      echo "*** as long as the dlopening application is linked with the -dlopen flag."
 	      if test -z "$global_symbol_pipe"; then
-	        echo
-	        echo "*** However, this would only work if libtool was able to extract symbol"
-	        echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
-	        echo "*** not find such a program.  So, this module is probably useless."
-	        echo "*** \`nm' from GNU binutils and a full rebuild may help."
+		echo
+		echo "*** However, this would only work if libtool was able to extract symbol"
+		echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+		echo "*** not find such a program.  So, this module is probably useless."
+		echo "*** \`nm' from GNU binutils and a full rebuild may help."
 	      fi
 	      if test "$build_old_libs" = no; then
-	        build_libtool_libs=module
-	        build_old_libs=yes
+		build_libtool_libs=module
+		build_old_libs=yes
 	      else
-	        build_libtool_libs=no
+		build_libtool_libs=no
 	      fi
 	    fi
 	  else
@@ -2175,7 +2198,7 @@
       else
 
 	# Parse the version information argument.
-	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS=':'
+	save_ifs="$IFS"; IFS=':'
 	set dummy $vinfo 0 0 0
 	IFS="$save_ifs"
 
@@ -2312,6 +2335,16 @@
 	if test -z "$vinfo" && test -n "$release"; then
 	  major=
 	  verstring="0.0"
+	  case $version_type in
+	  darwin)
+	    # we can't check for "0.0" in archive_cmds due to quoting
+	    # problems, so we reset it completely
+	    verstring=""
+	    ;;
+	  *)
+	    verstring="0.0"
+	    ;;
+	  esac
 	  if test "$need_version" = no; then
 	    versuffix=
 	  else
@@ -2408,6 +2441,9 @@
 	  *-*-netbsd*)
 	    # Don't link with libc until the a.out ld.so is fixed.
 	    ;;
+	  *-*-openbsd*)
+	    # Do not include libc due to us having libc/libc_r.
+	    ;;
 	  *)
 	    # Add libc to deplibs on all other systems if necessary.
 	    if test $build_libtool_need_lc = "yes"; then
@@ -2784,7 +2820,7 @@
 	    export_symbols="$output_objdir/$libname.exp"
 	    $run $rm $export_symbols
 	    eval cmds=\"$export_symbols_cmds\"
-	    IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	    save_ifs="$IFS"; IFS='~'
 	    for cmd in $cmds; do
 	      IFS="$save_ifs"
 	      $show "$cmd"
@@ -2860,7 +2896,7 @@
 	else
 	  eval cmds=\"$archive_cmds\"
 	fi
-	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	save_ifs="$IFS"; IFS='~'
 	for cmd in $cmds; do
 	  IFS="$save_ifs"
 	  $show "$cmd"
@@ -2988,7 +3024,7 @@
 
       output="$obj"
       eval cmds=\"$reload_cmds\"
-      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+      save_ifs="$IFS"; IFS='~'
       for cmd in $cmds; do
 	IFS="$save_ifs"
 	$show "$cmd"
@@ -3024,7 +3060,7 @@
 	reload_objs="$libobjs $reload_conv_objs"
 	output="$libobj"
 	eval cmds=\"$reload_cmds\"
-	IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	save_ifs="$IFS"; IFS='~'
 	for cmd in $cmds; do
 	  IFS="$save_ifs"
 	  $show "$cmd"
@@ -3287,27 +3323,25 @@
 #undef lt_preloaded_symbols
 
 #if defined (__STDC__) && __STDC__
-# define lt_ptr_t void *
+# define lt_ptr void *
 #else
-# define lt_ptr_t char *
+# define lt_ptr char *
 # define const
 #endif
 
 /* The mapping between symbol names and symbols. */
 const struct {
   const char *name;
-  lt_ptr_t address;
+  lt_ptr address;
 }
 lt_preloaded_symbols[] =
 {\
 "
 
-	    sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
-		-e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
-		  < "$nlist" >> "$output_objdir/$dlsyms"
+	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
 
 	    $echo >> "$output_objdir/$dlsyms" "\
-  {0, (lt_ptr_t) 0}
+  {0, (lt_ptr) 0}
 };
 
 /* This works around a problem in FreeBSD linker */
@@ -3618,8 +3652,9 @@
 
     # relink executable if necessary
     if test -n \"\$relink_command\"; then
-      if (eval \$relink_command); then :
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
       else
+	$echo \"\$relink_command_output\" >&2
 	$rm \"\$progdir/\$file\"
 	exit 1
       fi
@@ -3790,7 +3825,7 @@
 
 	eval cmds=\"$old_archive_cmds\"
       fi
-      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+      save_ifs="$IFS"; IFS='~'
       for cmd in $cmds; do
 	IFS="$save_ifs"
 	$show "$cmd"
@@ -4165,7 +4200,7 @@
 	  # Do each command in the postinstall commands.
 	  lib="$destdir/$realname"
 	  eval cmds=\"$postinstall_cmds\"
-	  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	  save_ifs="$IFS"; IFS='~'
 	  for cmd in $cmds; do
 	    IFS="$save_ifs"
 	    $show "$cmd"
@@ -4352,7 +4387,7 @@
 
       # Do each command in the postinstall commands.
       eval cmds=\"$old_postinstall_cmds\"
-      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+      save_ifs="$IFS"; IFS='~'
       for cmd in $cmds; do
 	IFS="$save_ifs"
 	$show "$cmd"
@@ -4368,11 +4403,10 @@
     if test -n "$current_libdirs"; then
       # Maybe just do a dry run.
       test -n "$run" && current_libdirs=" -n$current_libdirs"
-      exec $SHELL $0 --finish$current_libdirs
-      exit 1
+      exec_cmd='$SHELL $0 --finish$current_libdirs'
+    else
+      exit 0
     fi
-
-    exit 0
     ;;
 
   # libtool finish mode
@@ -4391,7 +4425,7 @@
 	if test -n "$finish_cmds"; then
 	  # Do each command in the finish commands.
 	  eval cmds=\"$finish_cmds\"
-	  IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	  save_ifs="$IFS"; IFS='~'
 	  for cmd in $cmds; do
 	    IFS="$save_ifs"
 	    $show "$cmd"
@@ -4575,11 +4609,8 @@
 	LANG="$save_LANG"; export LANG
       fi
 
-      # Now actually exec the command.
-      eval "exec \$cmd$args"
-
-      $echo "$modename: cannot exec \$cmd$args"
-      exit 1
+      # Now prepare to actually exec the command.
+      exec_cmd='"$cmd"$args'
     else
       # Display what would be done.
       if test -n "$shlibpath_var"; then
@@ -4641,14 +4672,14 @@
 
       # Don't error if the file doesn't exist and rm -f was used.
       if (test -L "$file") >/dev/null 2>&1 \
-        || (test -h "$file") >/dev/null 2>&1 \
+	|| (test -h "$file") >/dev/null 2>&1 \
 	|| test -f "$file"; then
-        :
+	:
       elif test -d "$file"; then
-        exit_status=1
+	exit_status=1
 	continue
       elif test "$rmforce" = yes; then
-        continue
+	continue
       fi
 
       rmfiles="$file"
@@ -4670,7 +4701,7 @@
 	    if test -n "$library_names"; then
 	      # Do each command in the postuninstall commands.
 	      eval cmds=\"$postuninstall_cmds\"
-	      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	      save_ifs="$IFS"; IFS='~'
 	      for cmd in $cmds; do
 		IFS="$save_ifs"
 		$show "$cmd"
@@ -4685,7 +4716,7 @@
 	    if test -n "$old_library"; then
 	      # Do each command in the old_postuninstall commands.
 	      eval cmds=\"$old_postuninstall_cmds\"
-	      IFS="${IFS= 	}"; save_ifs="$IFS"; IFS='~'
+	      save_ifs="$IFS"; IFS='~'
 	      for cmd in $cmds; do
 		IFS="$save_ifs"
 		$show "$cmd"
@@ -4744,10 +4775,17 @@
     ;;
   esac
 
-  $echo "$modename: invalid operation mode \`$mode'" 1>&2
-  $echo "$generic_help" 1>&2
-  exit 1
+  if test -z "$exec_cmd"; then
+    $echo "$modename: invalid operation mode \`$mode'" 1>&2
+    $echo "$generic_help" 1>&2
+    exit 1
+  fi
 fi # test -z "$show_help"
+
+if test -n "$exec_cmd"; then
+  eval exec $exec_cmd
+  exit 1
+fi
 
 # We need to display help for each of the modes.
 case $mode in
Index: xc/extras/freetype2/builds/unix/unix-cc.in
diff -u xc/extras/freetype2/builds/unix/unix-cc.in:1.1.1.1 xc/extras/freetype2/builds/unix/unix-cc.in:1.1.1.2
--- xc/extras/freetype2/builds/unix/unix-cc.in:1.1.1.1	Fri Dec  8 16:26:09 2000
+++ xc/extras/freetype2/builds/unix/unix-cc.in	Thu Jun 20 04:16:04 2002
@@ -3,7 +3,9 @@
 
 CC      := @CC@
 
-LIBTOOL := $(BUILD)/libtool
+ifndef LIBTOOL
+  LIBTOOL := $(BUILD)/libtool
+endif
 
 
 # The object file extension (for standard and static libraries).  This can be
Index: xc/extras/freetype2/builds/unix/unix-def.in
diff -u xc/extras/freetype2/builds/unix/unix-def.in:1.1.1.2 xc/extras/freetype2/builds/unix/unix-def.in:1.1.1.3
--- xc/extras/freetype2/builds/unix/unix-def.in:1.1.1.2	Tue May 15 23:45:49 2001
+++ xc/extras/freetype2/builds/unix/unix-def.in	Thu Jun 20 04:16:04 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,12 +18,17 @@
 endif
 TOP := $(shell cd $(TOP); pwd)
 
-DELETE        := @RMF@
-DELDIR        := @RMDIR@
-SEP           := /
-HOSTSEP       := $(SEP)
-BUILD         := $(TOP)/builds/unix
-PLATFORM      := unix
+DELETE   := @RMF@
+DELDIR   := @RMDIR@
+SEP      := /
+HOSTSEP  := $(SEP)
+BUILD    := $(TOP)/builds/unix
+PLATFORM := unix
+
+# this is used for `make distclean' and `make install'
+ifndef OBJ_BUILD
+  OBJ_BUILD := $(BUILD)
+endif
 
 # don't use `:=' here since the path stuff will be included after this file
 #
@@ -35,14 +40,15 @@
 INSTALL_SCRIPT  := @INSTALL_SCRIPT@
 MKINSTALLDIRS   := $(BUILD)/mkinstalldirs
 
-DISTCLEAN += $(BUILD)/config.cache    \
-             $(BUILD)/config.log      \
-             $(BUILD)/config.status   \
-             $(BUILD)/unix-def.mk     \
-             $(BUILD)/unix-cc.mk      \
-             $(BUILD)/ftconfig.h      \
-             $(BUILD)/freetype-config \
-             $(LIBTOOL)
+DISTCLEAN += $(OBJ_BUILD)/config.cache    \
+             $(OBJ_BUILD)/config.log      \
+             $(OBJ_BUILD)/config.status   \
+             $(OBJ_BUILD)/unix-def.mk     \
+             $(OBJ_BUILD)/unix-cc.mk      \
+             $(OBJ_BUILD)/ftconfig.h      \
+             $(OBJ_BUILD)/freetype-config \
+             $(LIBTOOL)                   \
+             $(OBJ_BUILD)/Makefile
 
 
 # Standard installation variables.
Index: xc/extras/freetype2/builds/unix/unix.mk
diff -u xc/extras/freetype2/builds/unix/unix.mk:1.1.1.2 xc/extras/freetype2/builds/unix/unix.mk:1.1.1.3
--- xc/extras/freetype2/builds/unix/unix.mk:1.1.1.2	Tue May 15 23:45:49 2001
+++ xc/extras/freetype2/builds/unix/unix.mk	Thu Jun 20 04:16:04 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -12,9 +12,15 @@
 # indicate that you have read the license and understand and accept it
 # fully.
 
-
-include $(TOP)/builds/unix/unix-def.mk
-include $(TOP)/builds/unix/unix-cc.mk
+have_mk := $(strip $(wildcard $(TOP)/builds/unix/unix-def.mk))
+ifneq ($(have_mk),)
+  include $(TOP)/builds/unix/unix-def.mk
+  include $(TOP)/builds/unix/unix-cc.mk
+else
+  # we are building FT2 not in the src tree
+  include $(OBJ_DIR)/unix-def.mk
+  include $(OBJ_DIR)/unix-cc.mk
+endif
 
 ifdef BUILD_PROJECT
 
Index: xc/extras/freetype2/builds/vms/descrip.mms
diff -u xc/extras/freetype2/builds/vms/descrip.mms:1.1.1.1 xc/extras/freetype2/builds/vms/descrip.mms:1.1.1.2
--- xc/extras/freetype2/builds/vms/descrip.mms:1.1.1.1	Tue May 15 23:45:46 2001
+++ xc/extras/freetype2/builds/vms/descrip.mms	Thu Feb 14 19:33:22 2002
@@ -18,7 +18,7 @@
 OBJS=ftsystem.obj
 
 all : $(OBJS)
-	library/create [--.lib]freetype.olb $(OBJS)
+        library/create [--.lib]freetype.olb $(OBJS)
 
 ftsystem.obj : ftsystem.c ftconfig.h
 
Index: xc/extras/freetype2/builds/vms/ftconfig.h
diff -u xc/extras/freetype2/builds/vms/ftconfig.h:1.1.1.2 xc/extras/freetype2/builds/vms/ftconfig.h:1.1.1.3
--- xc/extras/freetype2/builds/vms/ftconfig.h:1.1.1.2	Sun Dec 16 12:49:19 2001
+++ xc/extras/freetype2/builds/vms/ftconfig.h	Thu Jun 20 04:16:04 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    VMS-specific configuration file (specification only).                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -41,6 +41,7 @@
   /* Include the header file containing all developer build options */
 #include <ft2build.h>
 #include FT_CONFIG_OPTIONS_H
+#include FT_CONFIG_STANDARD_LIBRARY_H
 
 FT_BEGIN_HEADER
 
@@ -62,17 +63,16 @@
 #define SIZEOF_INT   4
 #define SIZEOF_LONG  4
 
+#define FT_SIZEOF_INT   4
+#define FT_SIZEOF_LONG  4
 
-#define FT_SIZEOF_INT  4
-#define FT_SIZEOF_LONG 4
 
-
   /* Preferred alignment of data */
 #define FT_ALIGNMENT  8
 
 
-  /* UNUSED is a macro used to indicate that a given parameter is not used */
-  /* -- this is only used to get rid of unpleasant compiler warnings       */
+  /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
+  /* used -- this is only used to get rid of unpleasant compiler warnings */
 #ifndef FT_UNUSED
 #define FT_UNUSED( arg )  ( (arg) = (arg) )
 #endif
@@ -120,7 +120,6 @@
 
 #else
 
-
   /*************************************************************************/
   /*                                                                       */
   /* Many compilers provide the non-ANSI `long long' 64-bit type.  You can */
@@ -137,22 +136,23 @@
 #define FT_INT64   long long
 
 #endif /* FTCALC_USE_LONG_LONG */
+
 #endif /* FT_SIZEOF_LONG == 8 */
 
 
 #ifdef FT_MAKE_OPTION_SINGLE_OBJECT
 
-#define LOCAL_DEF   static
-#define LOCAL_FUNC  static
+#define FT_LOCAL( x )      static  x
+#define FT_LOCAL_DEF( x )  static  x
 
 #else
 
 #ifdef __cplusplus
-#define LOCAL_DEF   extern "C"
-#define LOCAL_FUNC  extern "C"
+#define FT_LOCAL( x )      extern "C"  x
+#define FT_LOCAL_DEF( x )  extern "C"  x
 #else
-#define LOCAL_DEF   extern
-#define LOCAL_FUNC  extern
+#define FT_LOCAL( x )      extern  x
+#define FT_LOCAL_DEF( x )  x
 #endif
 
 #endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
@@ -218,13 +218,13 @@
   /*                                                                 */
 #ifdef __cplusplus
 
-#define FT_CALLBACK_DEF( x )        extern "C" x
+#define FT_CALLBACK_DEF( x )        extern "C"  x
 #define FT_CALLBACK_TABLE           extern "C"
 #define FT_CALLBACK_TABLE_DEF       extern "C"
 
 #else
 
-#define FT_CALLBACK_DEF( x )        static x
+#define FT_CALLBACK_DEF( x )        static  x
 #define FT_CALLBACK_TABLE           extern
 #define FT_CALLBACK_TABLE_DEF
 
Index: xc/extras/freetype2/builds/vms/ftsystem.c
diff -u xc/extras/freetype2/builds/vms/ftsystem.c:1.1.1.4 xc/extras/freetype2/builds/vms/ftsystem.c:1.1.1.5
--- xc/extras/freetype2/builds/vms/ftsystem.c:1.1.1.4	Mon Jan 14 11:52:01 2002
+++ xc/extras/freetype2/builds/vms/ftsystem.c	Thu Jun 20 04:16:04 2002
@@ -2,9 +2,9 @@
 /*                                                                         */
 /*  ftsystem.c                                                             */
 /*                                                                         */
-/*    Unix-specific FreeType low-level system interface (body).            */
+/*    VMS-specific FreeType low-level system interface (body).             */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -144,9 +144,9 @@
   /*    The memory release function.                                       */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    memory  :: A pointer to the memory object.                         */
+  /*    memory :: A pointer to the memory object.                          */
   /*                                                                       */
-  /*    block   :: The address of block in memory to be freed.             */
+  /*    block  :: The address of block in memory to be freed.              */
   /*                                                                       */
   FT_CALLBACK_DEF( void )
   ft_free( FT_Memory  memory,
@@ -204,8 +204,8 @@
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Error )
-  FT_New_Stream( const char*  filepathname,
-                 FT_Stream    stream )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname )
   {
     int          file;
     struct stat  stat_buf;
@@ -218,14 +218,14 @@
     file = open( filepathname, O_RDONLY );
     if ( file < 0 )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
       return FT_Err_Cannot_Open_Resource;
     }
 
     if ( fstat( file, &stat_buf ) < 0 )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not `fstat' file `%s'\n", filepathname ));
       goto Fail_Map;
     }
@@ -241,7 +241,7 @@
 
     if ( (long)stream->base == -1 )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));
       goto Fail_Map;
     }
@@ -254,7 +254,7 @@
     stream->close = ft_close_stream;
     stream->read  = 0;
 
-    FT_TRACE1(( "FT_New_Stream:" ));
+    FT_TRACE1(( "FT_Stream_Open:" ));
     FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
                 filepathname, stream->size ));
 
@@ -275,13 +275,13 @@
 
   extern FT_Int
   ft_mem_debug_init( FT_Memory  memory );
-  
+
   extern void
   ft_mem_debug_done( FT_Memory  memory );
-  
-#endif  
-      
 
+#endif
+
+
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Memory )
@@ -299,7 +299,7 @@
       memory->free    = ft_free;
 #ifdef FT_DEBUG_MEMORY
       ft_mem_debug_init( memory );
-#endif    
+#endif
     }
 
     return memory;
@@ -313,7 +313,7 @@
   {
 #ifdef FT_DEBUG_MEMORY
     ft_mem_debug_done( memory );
-#endif  
+#endif
     memory->free( memory, memory );
   }
 
Index: xc/extras/freetype2/builds/win32/ftdebug.c
diff -u /dev/null xc/extras/freetype2/builds/win32/ftdebug.c:1.1.1.2
--- /dev/null	Thu Feb 27 12:20:38 2003
+++ xc/extras/freetype2/builds/win32/ftdebug.c	Thu Jun 20 04:16:04 2002
@@ -0,0 +1,211 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftdebug.c                                                              */
+/*                                                                         */
+/*    Debugging and logging component for Win32 (body).                    */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This component contains various macros and functions used to ease the */
+  /* debugging of the FreeType engine.  Its main purpose is in assertion   */
+  /* checking, tracing, and error detection.                               */
+  /*                                                                       */
+  /* There are now three debugging modes:                                  */
+  /*                                                                       */
+  /* - trace mode                                                          */
+  /*                                                                       */
+  /*   Error and trace messages are sent to the log file (which can be the */
+  /*   standard error output).                                             */
+  /*                                                                       */
+  /* - error mode                                                          */
+  /*                                                                       */
+  /*   Only error messages are generated.                                  */
+  /*                                                                       */
+  /* - release mode:                                                       */
+  /*                                                                       */
+  /*   No error message is sent or generated.  The code is free from any   */
+  /*   debugging parts.                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+
+
+#ifdef FT_DEBUG_LEVEL_ERROR
+
+
+#  include <stdarg.h>
+#  include <stdlib.h>
+#  include <string.h>
+
+#  include <windows.h>
+
+
+  FT_EXPORT_DEF( void )
+  FT_Message( const char*  fmt, ... )
+  {
+    static char buf[8192];
+    va_list     ap;
+
+
+    va_start( ap, fmt );
+    vsprintf( buf, fmt, ap );
+    OutputDebugStringA( buf );
+    va_end( ap );
+  }
+
+
+  FT_EXPORT_DEF( void )
+  FT_Panic( const char*  fmt, ... )
+  {
+    static char buf[8192];
+    va_list     ap;
+
+
+    va_start( ap, fmt );
+    vsprintf( buf, fmt, ap );
+    OutputDebugStringA( buf );
+    va_end( ap );
+
+    exit( EXIT_FAILURE );
+  }
+
+
+#  ifdef FT_DEBUG_LEVEL_TRACE
+
+
+  /* array of trace levels, initialized to 0 */
+  int  ft_trace_levels[trace_count];
+
+  /* define array of trace toggle names */
+#    define FT_TRACE_DEF( x )  #x ,
+
+  static const char*  ft_trace_toggles[trace_count + 1] =
+  {
+#    include FT_INTERNAL_TRACE_H
+    NULL
+  };
+
+#    undef FT_TRACE_DEF
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Initialize the tracing sub-system.  This is done by retrieving the    */
+  /* value of the "FT2_DEBUG" environment variable.  It must be a list of  */
+  /* toggles, separated by spaces, `;' or `:'.  Example:                   */
+  /*                                                                       */
+  /*    "any=3 memory=6 stream=5"                                          */
+  /*                                                                       */
+  /* This will request that all levels be set to 3, except the trace level */
+  /* for the memory and stream components which are set to 6 and 5,        */
+  /* respectively.                                                         */
+  /*                                                                       */
+  /* See the file <freetype/internal/fttrace.h> for details of the         */
+  /* available toggle names.                                               */
+  /*                                                                       */
+  /* The level must be between 0 and 6; 0 means quiet (except for serious  */
+  /* runtime errors), and 6 means _very_ verbose.                          */
+  /*                                                                       */
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    const char*  ft2_debug = getenv( "FT2_DEBUG" );
+
+
+    if ( ft2_debug )
+    {
+      const char*  p = ft2_debug;
+      const char*  q;
+
+
+      for ( ; *p; p++ )
+      {
+        /* skip leading whitespace and separators */
+        if ( *p == ' ' || *p == '\t' || *p == ':' || *p == ';' || *p == '=' )
+          continue;
+
+        /* read toggle name, followed by '=' */
+        q = p;
+        while ( *p && *p != '=' )
+          p++;
+
+        if ( *p == '=' && p > q )
+        {
+          int  n, i, len = p - q;
+          int  level = -1, found = -1;
+
+
+          for ( n = 0; n < trace_count; n++ )
+          {
+            const char*  toggle = ft_trace_toggles[n];
+
+
+            for ( i = 0; i < len; i++ )
+            {
+              if ( toggle[i] != q[i] )
+                break;
+            }
+
+            if ( i == len && toggle[i] == 0 )
+            {
+              found = n;
+              break;
+            }
+          }
+
+          /* read level */
+          p++;
+          if ( *p )
+          {
+            level = *p++ - '0';
+            if ( level < 0 || level > 6 )
+              level = -1;
+          }
+
+          if ( found >= 0 && level >= 0 )
+          {
+            if ( found == trace_any )
+            {
+              /* special case for "any" */
+              for ( n = 0; n < trace_count; n++ )
+                ft_trace_levels[n] = level;
+            }
+            else
+              ft_trace_levels[found] = level;
+          }
+        }
+      }
+    }
+  }
+
+
+#  else  /* !FT_DEBUG_LEVEL_TRACE */
+
+
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    /* nothing */
+  }
+
+
+#  endif /* !FT_DEBUG_LEVEL_TRACE */
+
+#endif /* FT_DEBUG_LEVEL_ERROR */
+
+/* END */
Index: xc/extras/freetype2/builds/win32/visualc/freetype.dsp
diff -u xc/extras/freetype2/builds/win32/visualc/freetype.dsp:1.1.1.2 xc/extras/freetype2/builds/win32/visualc/freetype.dsp:1.1.1.4
--- xc/extras/freetype2/builds/win32/visualc/freetype.dsp:1.1.1.2	Sun Sep  9 22:55:53 2001
+++ xc/extras/freetype2/builds/win32/visualc/freetype.dsp	Thu Jun 20 04:16:04 2002
@@ -4,7 +4,7 @@
 
 # TARGTYPE "Win32 (x86) Static Library" 0x0104
 
-CFG=freetype - Win32 Debug Multithreaded
+CFG=freetype - Win32 Debug Singlethreaded
 !MESSAGE This is not a valid makefile. To build this project using NMAKE,
 !MESSAGE use the Export Makefile command and run
 !MESSAGE 
@@ -13,7 +13,7 @@
 !MESSAGE You can specify a configuration when running NMAKE
 !MESSAGE by defining the macro CFG on the command line. For example:
 !MESSAGE 
-!MESSAGE NMAKE /f "freetype.mak" CFG="freetype - Win32 Debug Multithreaded"
+!MESSAGE NMAKE /f "freetype.mak" CFG="freetype - Win32 Debug Singlethreaded"
 !MESSAGE 
 !MESSAGE Possible choices for configuration are:
 !MESSAGE 
@@ -21,12 +21,14 @@
 !MESSAGE "freetype - Win32 Debug" (based on "Win32 (x86) Static Library")
 !MESSAGE "freetype - Win32 Debug Multithreaded" (based on "Win32 (x86) Static Library")
 !MESSAGE "freetype - Win32 Release Multithreaded" (based on "Win32 (x86) Static Library")
+!MESSAGE "freetype - Win32 Release Singlethreaded" (based on "Win32 (x86) Static Library")
+!MESSAGE "freetype - Win32 Debug Singlethreaded" (based on "Win32 (x86) Static Library")
 !MESSAGE 
 
 # Begin Project
 # PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""$/DEV/freetype", KAOAAAAA"
-# PROP Scc_LocalPath "."
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
 CPP=cl.exe
 RSC=rc.exe
 
@@ -43,8 +45,8 @@
 # PROP Intermediate_Dir "..\..\..\objs\release"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /Za /W4 /GX /O2 /I "..\..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /FD /c
-# SUBTRACT CPP /YX
+# ADD CPP /MD /Za /W4 /GX /Zi /O2 /I "..\..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /FD /c
+# SUBTRACT CPP /nologo /YX
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
 # ADD RSC /l 0x409 /d "NDEBUG"
 BSC32=bscmake.exe
@@ -52,7 +54,7 @@
 # ADD BSC32 /nologo
 LIB32=link.exe -lib
 # ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"..\..\..\objs\freetype204.lib"
+# ADD LIB32 /nologo /out:"..\..\..\objs\freetype211.lib"
 
 !ELSEIF  "$(CFG)" == "freetype - Win32 Debug"
 
@@ -67,8 +69,8 @@
 # PROP Intermediate_Dir "..\..\..\objs\debug"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /Za /W4 /Gm /GX /ZI /Od /I "..\..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_DEBUG_LEVEL_ERROR" /D "FT_DEBUG_LEVEL_TRACE" /FD /GZ /c
-# SUBTRACT CPP /X /YX
+# ADD CPP /MDd /Za /W4 /GX /Zi /Od /I "..\..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_DEBUG_LEVEL_ERROR" /D "FT_DEBUG_LEVEL_TRACE" /FD /GZ /c
+# SUBTRACT CPP /nologo /X /YX
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe
@@ -76,7 +78,7 @@
 # ADD BSC32 /nologo
 LIB32=link.exe -lib
 # ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo /out:"..\..\..\objs\freetype204_D.lib"
+# ADD LIB32 /nologo /out:"..\..\..\objs\freetype211_D.lib"
 
 !ELSEIF  "$(CFG)" == "freetype - Win32 Debug Multithreaded"
 
@@ -92,8 +94,8 @@
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /Za /W3 /Gm /GX /ZI /Od /I "..\freetype\include\\" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_FLAT_COMPILE" /YX /FD /GZ /c
 # SUBTRACT BASE CPP /X
-# ADD CPP /nologo /MTd /Za /W4 /Gm /GX /ZI /Od /I "..\..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_DEBUG_LEVEL_ERROR" /D "FT_DEBUG_LEVEL_TRACE" /FD /GZ /c
-# SUBTRACT CPP /X /YX
+# ADD CPP /MTd /Za /W4 /GX /Zi /Od /I "..\..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_DEBUG_LEVEL_ERROR" /D "FT_DEBUG_LEVEL_TRACE" /FD /GZ /c
+# SUBTRACT CPP /nologo /X /YX
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe
@@ -101,7 +103,7 @@
 # ADD BSC32 /nologo
 LIB32=link.exe -lib
 # ADD BASE LIB32 /nologo /out:"lib\freetype200b8_D.lib"
-# ADD LIB32 /nologo /out:"..\..\..\objs\freetype204MT_D.lib"
+# ADD LIB32 /nologo /out:"..\..\..\objs\freetype211MT_D.lib"
 
 !ELSEIF  "$(CFG)" == "freetype - Win32 Release Multithreaded"
 
@@ -116,8 +118,8 @@
 # PROP Intermediate_Dir "..\..\..\objs\release_mt"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /Za /W3 /GX /O2 /I "..\freetype\include\\" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_FLAT_COMPILE" /YX /FD /c
-# ADD CPP /nologo /MT /Za /W4 /GX /O2 /I "..\..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /FD /c
-# SUBTRACT CPP /YX
+# ADD CPP /MT /Za /W4 /GX /Zi /O2 /I "..\..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /FD /c
+# SUBTRACT CPP /nologo /YX
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
 # ADD RSC /l 0x409 /d "NDEBUG"
 BSC32=bscmake.exe
@@ -125,8 +127,59 @@
 # ADD BSC32 /nologo
 LIB32=link.exe -lib
 # ADD BASE LIB32 /nologo /out:"lib\freetype200b8.lib"
-# ADD LIB32 /nologo /out:"..\..\..\objs\freetype204MT.lib"
+# ADD LIB32 /nologo /out:"..\..\..\objs\freetype211MT.lib"
 
+!ELSEIF  "$(CFG)" == "freetype - Win32 Release Singlethreaded"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "freetype___Win32_Release_Singlethreaded"
+# PROP BASE Intermediate_Dir "freetype___Win32_Release_Singlethreaded"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\..\objs\release_st"
+# PROP Intermediate_Dir "..\..\..\objs\release_st"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /Za /W4 /GX /Zi /O2 /I "..\..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /FD /c
+# SUBTRACT BASE CPP /YX
+# ADD CPP /Za /W4 /GX /Zi /O2 /I "..\..\..\include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /FD /c
+# SUBTRACT CPP /nologo /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo /out:"..\..\..\objs\freetype206.lib"
+# ADD LIB32 /out:"..\..\..\objs\freetype211ST.lib"
+# SUBTRACT LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "freetype - Win32 Debug Singlethreaded"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "freetype___Win32_Debug_Singlethreaded"
+# PROP BASE Intermediate_Dir "freetype___Win32_Debug_Singlethreaded"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\..\..\objs\debug_st"
+# PROP Intermediate_Dir "..\..\..\objs\debug_st"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /Za /W4 /Gm /GX /Zi /Od /I "..\..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_DEBUG_LEVEL_ERROR" /D "FT_DEBUG_LEVEL_TRACE" /FD /GZ /c
+# SUBTRACT BASE CPP /X /YX
+# ADD CPP /Za /W4 /GX /Zi /Od /I "..\..\..\include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "FT_DEBUG_LEVEL_ERROR" /D "FT_DEBUG_LEVEL_TRACE" /FD /GZ /c
+# SUBTRACT CPP /nologo /X /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo /out:"..\..\..\objs\freetype206_D.lib"
+# ADD LIB32 /nologo /out:"..\..\..\objs\freetype211ST_D.lib"
+
 !ENDIF 
 
 # Begin Target
@@ -135,104 +188,149 @@
 # Name "freetype - Win32 Debug"
 # Name "freetype - Win32 Debug Multithreaded"
 # Name "freetype - Win32 Release Multithreaded"
+# Name "freetype - Win32 Release Singlethreaded"
+# Name "freetype - Win32 Debug Singlethreaded"
 # Begin Group "Source Files"
 
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 # Begin Source File
 
 SOURCE=..\..\..\src\autohint\autohint.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\src\bdf\bdf.c
+# SUBTRACT CPP /Fr
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\src\cff\cff.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\base\ftbase.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
-SOURCE=..\..\..\src\base\ftdebug.c
+SOURCE=..\..\..\src\cache\ftcache.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
+SOURCE=..\ftdebug.c
+# ADD CPP /Ze
+# SUBTRACT CPP /Fr
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\src\base\ftglyph.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\base\ftinit.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\base\ftmm.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\base\ftsystem.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\pcf\pcf.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\psaux\psaux.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\src\pshinter\pshinter.c
+# SUBTRACT CPP /Fr
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\src\psnames\psmodule.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\raster\raster.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\sfnt\sfnt.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\smooth\smooth.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\truetype\truetype.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\type1\type1.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\cid\type1cid.c
+# SUBTRACT CPP /Fr
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\src\type42\type42.c
+# SUBTRACT CPP /Fr
 # End Source File
 # Begin Source File
 
 SOURCE=..\..\..\src\winfonts\winfnt.c
+# SUBTRACT CPP /Fr
 # End Source File
 # End Group
 # Begin Group "Header Files"
 
 # PROP Default_Filter "h;hpp;hxx;hm;inl"
 # Begin Source File
+
+SOURCE=..\..\..\include\ft2build.h
+# End Source File
+# Begin Source File
 
-SOURCE=.\include\freetype\freetype.h
+SOURCE=..\..\..\include\freetype\config\ftconfig.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\include\freetype\config\ftconfig.h
+SOURCE=..\..\..\include\freetype\config\ftheader.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\include\freetype\fterrors.h
+SOURCE=..\..\..\include\freetype\config\ftmodule.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\include\freetype\config\ftoption.h
+SOURCE=..\..\..\include\freetype\config\ftoption.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\include\freetype\fttypes.h
+SOURCE=..\..\..\include\freetype\config\ftstdlib.h
 # End Source File
 # End Group
 # End Target
Index: xc/extras/freetype2/docs/BUGS
diff -u xc/extras/freetype2/docs/BUGS:1.1.1.2 xc/extras/freetype2/docs/BUGS:1.1.1.3
--- xc/extras/freetype2/docs/BUGS:1.1.1.2	Mon Jan 14 11:52:02 2002
+++ xc/extras/freetype2/docs/BUGS	Thu Feb 14 19:33:22 2002
@@ -7,7 +7,7 @@
 "Date" is the date when the bug was first reported or entered in this
 document.  Dates are in _European_ format, i.e day/month/year.
 
-"Opened By" is the name of the person who first spotted the bug. Note that
+"Opened By" is the name of the person who first spotted the bug.  Note that
 we can use abbreviations here, like:
 
   "David" for David Turner
@@ -20,8 +20,8 @@
 
 
 
-I. Opened bugs
-==============
+I. Open bugs
+============
 
 
 Identifier                 Date       Opened by                Reproduceable
@@ -36,8 +36,8 @@
 
 
 
-II. Table of closed bugs
-========================
+II. Closed bugs
+===============
 
 
 Identifier                Date         Closed by                Closure date
@@ -58,9 +58,10 @@
 III. Bug descriptions
 =====================
 
---- START OF OPENED BUGS ---
 
+--- START OF OPEN BUGS ---
 
+
 NO-CID-CMAPS
 
   Not exactly a bug, but the CFF font driver doesn't build a Unicode charmap
@@ -81,7 +82,7 @@
   Some of this has been fixed in 2.0.6; there was a bug in the TrueType
   loader that prevented it from loading composites correctly.  However,
   there are still _subtle_ differences between FT1 and FT2 when it comes to
-  monochrome TrueType-hinted glyphs (the major differences are gone though !!)
+  monochrome TrueType-hinted glyphs (the major differences are gone though).
 
 
 
@@ -142,8 +143,9 @@
     for "load_flag", some other way to set preferences is probably needed.
 
 
+
+--- END OF OPEN BUGS ---
 
---- END OF OPENED BUGS ---
 
 
 BAD-TTNAMEID.H
@@ -170,6 +172,7 @@
   FreeType followed the most recent TrueType/OpenType specification here.
 
 
+
 AUTOHINT-SBITS
 
   When trying to load a glyph, with the auto-hinter activated (i.e., when
@@ -186,6 +189,7 @@
   further release like FreeType 2.1.
 
 
+
 BAD-T1-CHARMAP
 
   Type1 driver doesn't read "cacute" and "lslash" characters from iso8859-2
@@ -196,6 +200,7 @@
   table of glyph names in 'src/psaux/pstables.h'.)
 
 
+
 BAD-UNIXXXX-NAMES
 
   Glyph names like uniXXXX are not recognized as they should be.  It seems
@@ -206,6 +211,7 @@
   any Postscript font that use this convention, unfortunately.)
 
 
+
 GLYPH_TO_BITMAP-BUG
 
   Calling FT_Glyph_To_Bitmap() sometimes modifies the original glyph
@@ -225,45 +231,45 @@
 TT-GLYPH-CRASH
 
   The library crashed when trying to load certain glyphs from an
-  automatically generated TrueType file (tt1095m_.ttf submitted by
-  Scott Long).
+  automatically generated TrueType file (tt1095m_.ttf submitted by Scott
+  Long).
   
-  It turned out that the font contained invalid glyph data (i.e. was broken),
-  but the TrueType glyph loader in FreeType wasn't paranoid enough, which
-  resulted in nasty memory overwrites all over the place.
+  It turned out that the font contained invalid glyph data (i.e. was
+  broken), but the TrueType glyph loader in FreeType wasn't paranoid enough,
+  which resulted in nasty memory overwrites all over the place.
 
 
 
 T1-FONT-CRASH
 
-  The library crashed when trying to load the "Stalingrad Regular" face
-  from the "sadn.pfb" font file provided by Anthony Fok (and the Gnome-Print
-  team I believe).
+  The library crashed when trying to load the "Stalingrad Regular" face from
+  the "sadn.pfb" font file provided by Anthony Fok (and the Gnome-Print team
+  I believe).
   
   This was due to the fact that the font missed a full font name entry,
-  though boasted a family name and postscript name. The Type 1 face loader
-  didn't check for these pathetic cases and seg-faulted..
+  though boasted a family name and postscript name.  The Type 1 face loader
+  didn't check for these pathetic cases and seg-faulted.
 
 
 
 BAD-ADVANCES
 
   All scalable font drivers returned un-fitted glyph advances when
-  FT_LOAD_DEFAULT was used, which was incorrect. This problem was pretty
-  old but hadn't been spotted because all test programs actually
-  explicitely or implicitely (i.e. through the cache) rounded the advance
-  widths of glyphs..
+  FT_LOAD_DEFAULT was used, which was incorrect.  This problem was pretty
+  old but hadn't been spotted because all test programs actually explicitly
+  or implicitly (i.e. through the cache) rounded the advance widths of
+  glyphs.
   
-  This resulted in poor rendering of a number of client applications
-  however (it's strange to see they took so long to notice the devel team ?)
+  This resulted in poor rendering of a number of client applications however
+  (it is strange to see they took so long to notify the FreeType team).
 
 
 
 GLYPH-TO-BITMAP-BUG
 
-  the FT_Glyph_ToBitmap did incorrectly modify the source glyph in certain
-  cases, which resulted in random behaviour and bad text rendering. This was
-  spotted to bugs in both the monochrome and smooth rasterizer..
+  FT_Glyph_To_Bitmap() did incorrectly modify the source glyph in certain
+  cases, which resulted in random behaviour and bad text rendering.  This
+  was spotted to bugs in both the monochrome and smooth rasterizer.
 
 
 === end of file ===
Index: xc/extras/freetype2/docs/CHANGES
diff -u xc/extras/freetype2/docs/CHANGES:1.1.1.3 xc/extras/freetype2/docs/CHANGES:1.1.1.6
--- xc/extras/freetype2/docs/CHANGES:1.1.1.3	Mon Jan 14 11:52:02 2002
+++ xc/extras/freetype2/docs/CHANGES	Thu Jun 20 04:16:05 2002
@@ -1,3 +1,329 @@
+LATEST CHANGES BETWEEN 2.1.1 and 2.1.0
+
+  I. IMPORTANT BUG FIXES
+
+    - The `version_info' returned by `freetype-config' in 2.1.0 returned an
+      invalid value. It now returns 9:1:3 (2.0.9 returned 9:0:3).
+
+    - Version 2.1.0 couldn't be linked against applications on Win32 and
+      Amiga systems due to a new debug function that wasn't properly
+      propagated to the system-specific directory in `builds'.
+
+    - Various MacOS and Mac OS X specific fixes.
+
+    - Fixed a bug in the TrueType charmap validation routines that made
+      version 2.1.0 too restrictive -- many popular fonts have been
+      rejected.
+
+    - There was still a very small difference between the monochrome glyph
+      bitmaps produced by FreeType 1.x and FreeType 2.x with the bytecode
+      interpreter enabled.  This was caused by an invalid flag setting in
+      the TrueType glyph loader, making the rasterizer change its drop-out
+      control mode.  Now theresults should _really_ be completely identical.
+
+    - The TrueType name table loader has been improved to support many
+      popular though buggy Asian fonts.  It now ignores empty name entries,
+      invalid pointer offsets and a few other incorrect subtleties.
+      Moreover, name strings are now loaded on demand, which reduces the
+      memory load of many faces (e.g. the ARIAL.TTF font file contains a
+      10kByte name table with 70 names).
+
+    - Fixed a bug in the Postscript hinter that prevented family blues
+      substitution to happen correctly.
+
+
+  II. NEW FEATURES
+
+    - Three new font drivers in this release:
+
+      * A BDF font driver, contributed by Franco Narda Zapelli, heavily
+        modified by Werner Lemberg.  It also supports anti-aliased bitmaps
+        (using a slightly extended BDF format).
+
+      * A Type42 font driver, contributed by Roberto Alameda.  It is
+        still experimental but seems to work relatively well.
+
+      * A PFR font driver, contributed by David Turner himself.  It doesn't
+        support PFR hinting -- note that BitStream has at least two patents
+        on this format!
+
+
+  III. MISCELLANEOUS
+
+    - The cache sub-system has been optimized in important ways.  Cache hits
+      are now significantly faster.  For example, using the CMap cache is
+      about twice faster than calling FT_Get_Char_Index on most platforms. 
+      Similarly, using an SBit cache is about five times faster than loading
+      the bitmaps from a bitmap file, and 300 to 500 times faster than
+      generating them from a scalable format.
+
+      Note that you should recompile your sources if you designed a custom
+      cache class for the FT2 Cache subsystem, since the changes performed
+      are source, but not binary, compatible.
+
+
+========================================================================
+
+LATEST CHANGES BETWEEN 2.1.0 and 2.0.9
+
+  I. IMPORTANT BUG FIXES
+
+    - The TrueType bytecode interpreter has been fixed to produce
+      _exactly_ the same output as FreeType 1.x.  Previous differences
+      were due to slightly distinct fixed-point computation routines
+      used to perform dot products and vector length measurements.
+
+      It seems that native TrueType hinting is _extremely_ sensitive
+      to rounding errors.  The required vector computation routines have
+      been optimized and placed within the "ttinterp.c" file.
+
+    - Fixed the parsing of accelerator tables in the PCF font driver.
+
+    - Fixed the Type1 glyph loader routine used to compute the font's
+      maximum advance width.
+
+  II. NEW FEATURES
+
+    - The `configure' script used on Unix systems has been modified to
+      check that GNU Make is being used to build the library.  Otherwise,
+      it will display a message proposing to use the GNUMAKE environment
+      variable to name it.
+
+      The Unix-specific file README.UNX has been modified accordingly.
+
+
+  III. MISCELLANEOUS
+
+    - The FreeType License in `docs/FTL.txt' has been updated to include
+      a proposed preferred disclaimer.  If you are using FreeType in your
+      products, you are encouraged (but not mandated) to use the following
+      text in your documentation:
+
+      """
+        Portions of this software are copyright © 1996-2002 The FreeType
+        Project (www.freetype.org).  All rights reserved.
+      """
+
+    - The default size of the render pool has been reduced to 16kByte.
+      This shouldn't result in any noticeable performance penalty, unless
+      you are using the engine as-is to render very large and complex
+      glyphs.
+
+    - The FreeType 2 redesign has begun.  More information can be found
+      at this URL:
+
+        http://www.freetype.org/freetype2/redesign.html
+
+      The following internal changes have been performed within the sources
+      of this release:
+
+        - Many internal types have been renamed to increase consistency.
+          The following should be true, except for public types:
+
+            * All structure types have a name ending in "Rec" (short for
+              `record').
+
+            * A pointer-to-structure type has the same name as the
+              structure, _without_ the "Rec" suffix.
+
+                Example:
+
+                  typedef struct FooRec_
+                  {
+                    ...
+
+                  } FooRec, *Foo;
+
+        - Many internal macros have been renamed to increase consistency.
+          The following should be true:
+
+            * All macros have a name beginning with "FT_".  This required
+              a few changes like
+
+                ALLOC   => FT_ALLOC
+                FREE    => FT_FREE
+                REALLOC => FT_REALLOC
+
+            * All macros are completely UPPERCASE.  This required a few
+              changes like:
+
+                READ_Short  => FT_READ_SHORT
+                NEXT_Short  => FT_NEXT_SHORT
+                GET_ULongLE => FT_GET_ULONG_LE
+                MEM_Set     => FT_MEM_SET
+                MEM_Copy    => FT_MEM_COPY
+                etc.
+
+            * Whenever possible, all macro names follow the
+              FT_<OBJECT>_<METHOD> pattern.  For example
+
+                ACCESS_Frame   => FT_FRAME_ENTER
+                FORGET_Frame   => FT_FRAME_EXIT
+                EXTRACT_Frame  => FT_FRAME_EXTRACT
+                RELEASE_Frame  => FT_FRAME_RELEASE
+
+                FILE_Pos       => FT_STREAM_POS
+                FILE_Seek      => FT_STREAM_SEEK
+                FILE_Read      => FT_STREAM_READ
+                FILE_ReadAt    => FT_STREAM_READ_AT
+                READ_Fields    => FT_STREAM_READ_FIELDS
+
+        - Many internal functions have been renamed to follow the
+          FT_<Object>_<Method> pattern.  For example:
+
+            FT_Seek_Stream       => FT_Stream_Seek
+            FT_Read_Stream_At    => FT_Stream_ReadAt
+            FT_Done_Stream       => FT_Stream_Close
+            FT_New_Stream        => FT_Stream_Open
+            FT_New_Memory_Stream => FT_Stream_OpenMemory
+            FT_Extract_Frame     => FT_Stream_ExtractFrame
+
+          Note that method names do not contain "_".
+
+        - The FT_ALLOC_ARRAY and FT_REALLOC_ARRAY have been replaced
+          with FT_NEW_ARRAY and FT_RENEW_ARRAY which do not take a type
+          as the fourth argument.  Instead, the array element type size
+          is computed automatically from the type of the target pointer
+          used.
+
+        - A new object class, FT_CMap, has been introduced.  These
+          internal objects are used to model character maps.  This eases
+          the support of additional charmap types within the engine.
+
+        - A new configuration file named "ftstdlib.h" has been added
+          to `include/freetype/config'.  It is used to define aliases
+          for _every_ routine of the ISO C library that the font engine
+          uses.  Each aliases has a "ft_" prefix (e.g. "ft_strlen" is an
+          alias for "strlen").
+
+          This is used to ease the porting of FreeType 2 to exotic runtime
+          environments where the ISO C Library isn't available (e.g.
+          XFree86 extension modules).
+
+      More details are available in the "ChangeLog" file.
+
+
+============================================================================
+
+LATEST CHANGES BETWEEN 2.0.9 and 2.0.8
+
+  I. IMPORTANT BUG FIXES
+
+    - Certain fonts like "foxjump.ttf" contain broken name tables with
+      invalid entries and wild offsets.  This caused FreeType to crash when
+      trying to load them.
+
+      The SFNT `name' table loader has been fixed to be able to support
+      these strange fonts.
+
+      Moreover, the code in charge of processing this table has been changed
+      to always favour Windows-formatted entries over other ones.  Hence, a
+      font that works on Windows but not on the Mac will load cleanly in
+      FreeType and report accurate values for Family & PostScript names.
+
+    - The CID font driver has been fixed.  It unfortunately returned a
+      Postscript Font name with a leading slash, as in
+      "/MunhwaGothic-Regular".
+
+    - FreeType 2 should now compile fine on AIX 4.3.3 as a shared library.
+
+    - A bug in the Postscript hinter has been found and fixed, removing
+      un-even stem widths at small pixel sizes (like 14-17).
+
+      This improves the quality of a certain number of Postscript fonts.
+
+
+  II. NEW FEATURES
+
+    - A new function named `FT_Library_Version' has been added to return
+      the current library's major, minor, and patch version numbers.  This
+      is important since the macros FREETYPE_MAJOR, FREETYPE_MINOR, and
+      FREETYPE_PATCH cannot be used when the library is dynamically linked
+      by a program.
+
+    - Two new APIs have been added: `FT_Get_First_Char' and
+      `FT_Get_Next_Char'.
+
+      Together, these can be used to iterate efficiently over the currently
+      selected charmap of a given face.  Read the API reference for more
+      details.
+
+
+  III. MISCELLANEOUS
+
+    - The FreeType sources are under heavy internal re-factoring.  As a
+      consequence, we have created a branch named "STABLE" on the CVS to
+      hold all future releases/fixes in the 2.0.x family.
+
+      The HEAD branch now contains the re-factored sources and shouldn't be
+      used for testing or packaging new releases.  In case you would like
+      to access the 2.0.9 sources from our CVS repository, use the tag
+      `VER-2-0-9'.
+
+
+============================================================================
+
+LATEST CHANGES BETWEEN 2.0.8 and 2.0.7
+
+  I. IMPORTANT BUG FIXES
+
+    - There was a small but nasty bug in "freetype-config.in" which
+      caused the "freetype-config" script to fail on Unix.
+
+      This didn't prevent the installation of the library or even
+      its execution, but caused problems when trying to compile many
+      Unix packages that depend on it.
+
+    - Some TrueType or OpenType fonts embedded in PDF documents do
+      not have a 'cmap', 'post' and 'name' as is required by the
+      specification.  FreeType no longer refuses to load such fonts.
+
+    - various fixes to the PCF font driver
+
+
+============================================================================
+
+LATEST CHANGES BETWEEN 2.0.7 and 2.0.6
+
+  I. IMPORTANT BUG FIXES
+
+    - Fixed two bugs in the Type 1 font driver.  The first one resulted in a
+      memory leak in subtle cases.  The other one caused FreeType to crash
+      when trying to load ".gsf" files (Ghostscript so-called Postscript
+      fonts).
+
+      (This made _many_ KDE applications crash on certain systems.  FreeType
+       _is_ becoming a critical system component on Linux :-)
+
+    - Fixed a memory leak in the CFF font driver.
+
+    - Fixed a memory leak in the PCF font driver.
+
+    - Fixed the Visual C++ project file "builds/win32/visualc/freetype.dsp"
+      since it didn't include the Postscript hinter component, causing
+      errors at build time.
+
+    - Fixed a small rendering bug in the anti-aliased renderer that only
+      occurred when trying to draw thin (less than 1 pixel) strokes.
+
+    - Fixed "builds/unix/freetype2.a4" which is used to generate a valid
+      "freetype2.m4" for use with autoconf.
+
+    - Fixed the OpenVMS Makefiles.
+
+
+  II. MISCELLANEOUS
+
+    - Added "configure" and "install" scripts to the top-level directory.
+      A GNU-style installation is thus now easily possible with
+
+          ./configure  <options>
+          make
+          make install
+
+
+============================================================================
+
 LATEST CHANGES BETWEEN 2.0.6 and 2.0.5
 
   I. IMPORTANT BUG FIXES
@@ -24,16 +350,15 @@
 
     - "glnames.py" still contained a bug that made FreeType return invalid
       names for certain glyphs.
-
 
-    - the library crashed when loading certain Type 1 fonts like "sadn.pfb"
+    - The library crashed when loading certain Type 1 fonts like "sadn.pfb"
       ("Stalingrad Normal"), which appear to contain pathetic font info
-      dictionaries..
+      dictionaries.
 
-    - the TrueType glyph loader is now much more paranoid and checks everything
-      when loading a given glyph image. This was necessary to avoid problems
-      (crashes and/or memory overwrites) with broken fonts that came from a
-      really buggy automatic font converter..
+    - The TrueType glyph loader is now much more paranoid and checks everything
+      when loading a given glyph image.  This was necessary to avoid
+      problems (crashes and/or memory overwrites) with broken fonts that
+      came from a really buggy automatic font converter.
 
 
   II. IMPORTANT UPDATES AND NEW FEATURES
@@ -68,7 +393,7 @@
       run any program using FreeType.  When the library is exited, a summary
       of memory footprints and possible leaks will be displayed.
 
-      This works transparently with _any_ program that uses FreeType. 
+      This works transparently with _any_ program that uses FreeType.
       However, you will need a lot of memory to use this (allocated blocks
       are never released to the heap to detect double deletes easily).
 
@@ -76,23 +401,22 @@
   III. MISCELLANEOUS
 
     - We are aware of subtle differences between the output of FreeType
-      versions 1 and 2 when it comes to monochrome TrueType-hinted glyphs. 
+      versions 1 and 2 when it comes to monochrome TrueType-hinted glyphs.
       These are most probably due to small differences in the monochrome
       rasterizers and will be worked out in an upcoming release.
 
-
     - We have decided to fork the sources in a "stable" branch, and an
       "unstable" one, since FreeType is becoming a critical component of
       many Unix systems.
-      
-      The next bug-fix releases of the library will be named 2.0.7,
-      2.0.8, etc.. while the "2.1" branch will contain a version of the
-      sources where we'll start major reworking of the library's internals,
-      in order to produce FreeType 2.2.0 (or even 3.0) in a more distant
+
+      The next bug-fix releases of the library will be named 2.0.7, 2.0.8,
+      etc., while the "2.1" branch will contain a version of the sources
+      where we will start major reworking of the library's internals, in
+      order to produce FreeType 2.2.0 (or even 3.0) in a more distant
       future.
-      
+
       We also hope that this scheme will allow much more frequent releases
-      than in the past
+      than in the past.
 
 
 ============================================================================
Index: xc/extras/freetype2/docs/FTL.txt
diff -u xc/extras/freetype2/docs/FTL.txt:1.1.1.2 xc/extras/freetype2/docs/FTL.txt:1.1.1.3
--- xc/extras/freetype2/docs/FTL.txt:1.1.1.2	Mon Jan 14 11:52:03 2002
+++ xc/extras/freetype2/docs/FTL.txt	Thu Jun 20 04:16:05 2002
@@ -1,9 +1,9 @@
                     The FreeType Project LICENSE
                     ----------------------------
 
-                            2000-Feb-08
+                            2002-Apr-11
 
-                       Copyright 1996-2000 by
+                       Copyright 1996-2002 by
           David Turner, Robert Wilhelm, and Werner Lemberg
 
 
@@ -41,6 +41,16 @@
   software, with  or without modifications,  in commercial products.
   We  disclaim  all warranties  covering  The  FreeType Project  and
   assume no liability related to The FreeType Project.
+
+
+  Finally,  many  people  asked  us  for  a  preferred  form  for  a
+  credit/disclaimer to use in compliance with this license.  We thus
+  encourage you to use the following text:
+
+   """  
+    Portions of this software are copyright © 1996-2002 The FreeType
+    Project (www.freetype.org).  All rights reserved.
+   """
 
 
 Legal Terms
Index: xc/extras/freetype2/docs/INSTALL
diff -u /dev/null xc/extras/freetype2/docs/INSTALL:1.1.1.2
--- /dev/null	Thu Feb 27 12:20:39 2003
+++ xc/extras/freetype2/docs/INSTALL	Thu Jun 20 04:16:06 2002
@@ -0,0 +1,185 @@
+In order to build the library, read the `BUILD' document in the `docs'
+directory.  This is only a quick starter.
+
+
+I. Unix systems
+---------------
+
+  If you have GNU Make installed, simply type
+
+    ./configure
+    make
+    make install
+
+  on the command line to configure, build and install FreeType on your
+  system.  Note that the default installation path is "/usr/local".
+
+  Please read the file  README.UNX, it contains _critical_ information
+  regarding the installation of FreeType on many Unix systems.
+
+
+II. From the command line
+-------------------------
+
+  If  you are  not using  Unix, there  are two  ways to  quickly build
+  FreeType 2 from the command line.
+
+  The first, and favorite one, is to use the "Jam" build tool.  Jam is
+  a highly  portable replacement for  Make whose control files  do not
+  depend on the current platform or compiler toolset.
+
+  For more information, please see:
+
+    http://www.freetype.org/jam/index.html
+
+  The second one is to use "GNU Make" (and NO OTHER MAKE TOOL).
+
+
+  1. Building FT2 with "Jam"
+  --------------------------
+
+    Once you've  got *our version* of  the Jam tool  installed on your
+    system, simply go to the top-level FT2 directory, then type
+
+      "jam"
+
+    on the command line.  This will  build the library and place it in
+    the "objs" directory.
+
+    By default,  a static  library is built.   On Unix systems,  it is
+    possible to  build a shared library through  the "libtool" script.
+    You need to have libtool  installed on your system, then re-define
+    a few environment variables before invoking Jam, as in
+
+       export CC="libtool --mode=compile cc"
+       export LINK="libtool --mode=link cc"
+       jam
+
+    In  later releases  of  FT2, building  shared  libraries with  Jam
+    should become automatic on Unix systems.
+
+
+  2. Building FT2 with "GNU Make"
+  -------------------------------
+
+  You need  to have  GNU Make (version  3.78.1 or newer)  installed on
+  your system to compile the library from the command line.  This will
+  _NOT_ work with other make tools (including BSD make)!
+
+  [Well, this is not  really correct.  Recently, a perl implementation
+  of make called `makepp' has appeared which can also build FreeType 2
+  successfully on  Unix platforms.   See http://makepp.sourceforge.net
+  for more details.]
+
+  - Go to the `freetype2' directory.
+
+  - Unix (any C compiler should work):
+
+      - make setup (don't worry, this will invoke a configure script)
+      - make
+      - make install
+
+    Alternatively,  you can  pass parameters  to the  configure script
+    within the CFG variable, as in:
+
+      - make setup CFG="--prefix=/usr"
+      - make
+      - make install
+
+    If the  configure script isn't run,  try to add `unix' as a target
+    on the command line, e.g.:
+
+      - make setup unix CFG="--prefix=/opt/experimental"
+
+
+  - Windows:
+
+    We provide a  version of GNU Make for Win32  on the FreeType site.
+    See http://www.freetype.org/download.html for details.
+
+    - gcc (Mingw, _not_ CygWin):
+
+        - make setup
+        - make
+
+
+    - Visual C++:
+
+        - make setup visualc
+        - make
+
+
+    - other compilers:
+
+        - make setup bcc32    -> Borland C++ 32 bits
+        - make setup intelc   -> Intel C++
+        - make setup watcom   -> Watcom C++
+        - make setup lcc      -> Win32-LCC
+
+
+  If you want  to build FreeType 2 in another  directory, you must set
+  two environment  variables, `OJB_DIR'  and `TOP'.  The  former gives
+  the  directory where  the object  files  and the  library should  be
+  created (this directory must exist), the latter the top directory of
+  the FreeType 2 source tree.  Example:
+
+    OBJ_DIR=~/freetype2.compiled TOP=~/freetype2 \
+      make -f$TOP/Makefile setup ansi
+    OBJ_DIR=~/freetype2.compiled TOP=~/freetype2 \
+      make -f$TOP/Makefile
+
+  On  Unix boxes,  calling  `configure' from  the  build directory  is
+  sufficient;  it  will  build  a  small   Makefile  which  calls  the
+  FreeType 2 Makefile with the necessary parameters.
+
+
+III. In your own environment (IDE)
+----------------------------------
+
+  You need to add  the directories "freetype2/include" to your include
+  path when compiling the library.
+
+  FreeType  2 is  made  of several  components;  each one  of them  is
+  located   in  a  subdirectory   of  "freetype2/src".   For  example,
+  `freetype2/src/truetype/' contains the TrueType font driver.
+
+  DO NOT COMPILE ALL C FILES!  Rather, compile the following ones:
+
+    -- base components (required)
+
+      src/base/ftsystem.c
+      src/base/ftinit.c
+      src/base/ftdebug.c
+      src/base/ftbase.c
+      src/base/ftglyph.c
+      src/base/ftbbox.c
+      src/base/ftmm.c
+
+      src/base/ftmac.c        -- only on the Macintosh
+
+    -- other components are optional
+
+      src/autohint/autohint.c -- auto hinting module
+      src/cache/ftcache.c     -- cache sub-system (in beta)
+      src/sfnt/sfnt.c         -- SFNT files support
+                                 (TrueType & OpenType)
+      src/cff/cff.c           -- CFF/OpenType font driver
+      src/psnames/psnames.c   -- Postscript glyph names support
+      src/psaux/psaux.c       -- Postscript Type 1 parsing
+      src/truetype/truetype.c -- TrueType font driver
+      src/type1/type1.c       -- Type 1 font driver
+      src/cid/type1cid.c      -- Type 1 CID-keyed font driver
+      src/winfonts/winfonts.c -- Windows FONT / FNT font driver
+
+    Note:
+
+       `truetype.c' needs `sfnt.c' and `psnames.c'
+       `type1.c'    needs `psaux.c' and `psnames.c'
+       `type1cid.c' needs `psaux.c' and `psnames.c'
+       `cff.c'      needs `sfnt.c', `psaux.c', and `psnames.c'
+
+       etc.
+
+For more information, please consult "docs/BUILD".
+
+--- end of INSTALL --
Index: xc/extras/freetype2/docs/PATENTS
diff -u xc/extras/freetype2/docs/PATENTS:1.1.1.1 xc/extras/freetype2/docs/PATENTS:1.1.1.2
--- xc/extras/freetype2/docs/PATENTS:1.1.1.1	Sun Sep  9 22:55:42 2001
+++ xc/extras/freetype2/docs/PATENTS	Thu Feb 14 19:33:23 2002
@@ -12,7 +12,7 @@
 FOR  MORE DETAILS,  WE STRONGLY  ADVISE YOU  TO GO  TO  THE FREETYPE
 PATENTS PAGE AT THE FOLLOWING WEB ADDRESS:
 
-                http://www.freetype.org/patents.htm
+                http://www.freetype.org/patents.html
 
 WE WILL NOT PLACE INFORMATION IN THIS FILE AS THE SITUATION IS STILL
 UNDETERMINED FOR NOW.  AT THE  TIME THESE LINES ARE WRITTEN, WE HAVE
Index: xc/extras/freetype2/docs/modules.txt
diff -u xc/extras/freetype2/docs/modules.txt:1.1.1.1 xc/extras/freetype2/docs/modules.txt:1.1.1.2
--- xc/extras/freetype2/docs/modules.txt:1.1.1.1	Mon Jan 14 11:52:03 2002
+++ xc/extras/freetype2/docs/modules.txt	Thu Jun 20 04:16:06 2002
@@ -9,5 +9,6 @@
   cid          psaux, pshinter, psnames
   truetype     sfnt
   type1        psaux, pshinter, psnames
+  type42       truetype
   psaux        psnames
   sfnt         psnames
Index: xc/extras/freetype2/include/freetype/freetype.h
diff -u xc/extras/freetype2/include/freetype/freetype.h:1.1.1.5 xc/extras/freetype2/include/freetype/freetype.h:1.1.1.8
--- xc/extras/freetype2/include/freetype/freetype.h:1.1.1.5	Mon Jan 14 11:52:04 2002
+++ xc/extras/freetype2/include/freetype/freetype.h	Thu Jun 20 04:16:06 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType high-level API and common types (specification only).       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -34,8 +34,8 @@
   /* drivers.  It starts at 2.0.                                           */
   /*                                                                       */
 #define FREETYPE_MAJOR 2
-#define FREETYPE_MINOR 0
-#define FREETYPE_PATCH 5
+#define FREETYPE_MINOR 1
+#define FREETYPE_PATCH 0
 
 
 #include <ft2build.h>
@@ -106,6 +106,7 @@
   /*                                                                       */
   /*    FT_Init_FreeType                                                   */
   /*    FT_Done_FreeType                                                   */
+  /*    FT_Library_Version                                                 */
   /*                                                                       */
   /*    FT_New_Face                                                        */
   /*    FT_Done_Face                                                       */
@@ -395,6 +396,7 @@
 
     FT_ENC_TAG( ft_encoding_symbol,  's', 'y', 'm', 'b' ),
     FT_ENC_TAG( ft_encoding_unicode, 'u', 'n', 'i', 'c' ),
+    FT_ENC_TAG( ft_encoding_latin_1, 'l', 'a', 't', '1' ),
     FT_ENC_TAG( ft_encoding_latin_2, 'l', 'a', 't', '2' ),
     FT_ENC_TAG( ft_encoding_sjis,    's', 'j', 'i', 's' ),
     FT_ENC_TAG( ft_encoding_gb2312,  'g', 'b', ' ', ' ' ),
@@ -1132,7 +1134,7 @@
   /*    The subglyph implementation is not part of the high-level API,     */
   /*    hence the forward structure declaration.                           */
   /*                                                                       */
-  typedef struct FT_SubGlyph_  FT_SubGlyph;
+  typedef struct FT_SubGlyphRec_*  FT_SubGlyph;
 
 
   /*************************************************************************/
@@ -1297,7 +1299,7 @@
     FT_Outline        outline;
 
     FT_UInt           num_subglyphs;
-    FT_SubGlyph*      subglyphs;
+    FT_SubGlyph       subglyphs;
 
     void*             control_data;
     long              control_len;
@@ -1340,6 +1342,42 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    FT_Library_Version                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the version of the FreeType library being used.  This is    */
+  /*    useful when dynamically linking to the library, since one cannot   */
+  /*    use the macros FT_FREETYPE_MAJOR, FT_FREETYPE_MINOR, and           */
+  /*    FT_FREETYPE_PATCH.                                                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A source library handle.                                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amajor :: The major version number.                                */
+  /*                                                                       */
+  /*    aminor :: The minor version number.                                */
+  /*                                                                       */
+  /*    apatch :: The patch version number.                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The reason why this function takes a 'library' argument is because */
+  /*    certain programs implement library initialization in a custom way  */
+  /*    that doesn't use `FT_Init_FreeType'.                               */
+  /*                                                                       */
+  /*    In such cases it can happen that the library version is not known  */
+  /*    until the library object has been created.                         */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Library_Version( FT_Library   library,
+                      FT_Int      *amajor,
+                      FT_Int      *aminor,
+                      FT_Int      *apatch );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    FT_Done_FreeType                                                   */
   /*                                                                       */
   /* <Description>                                                         */
@@ -2394,6 +2432,89 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    FT_Get_First_Char                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to return the first character code in the    */
+  /*    current charmap of a given face.  It will also return the          */
+  /*    corresponding glyph index.                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: A handle to the source face object.                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    agindex :: Glyph index of first character code.  0 if charmap is   */
+  /*               empty.                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The charmap's first character code.                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should use this function with @FT_Get_Next_Char to be able to  */
+  /*    parse all character codes available in a given charmap.  The code  */
+  /*    should look like this:                                             */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      FT_ULong  charcode;                                              */
+  /*      FT_UInt   gindex;                                                */
+  /*                                                                       */
+  /*                                                                       */
+  /*      charcode = FT_Get_First_Char( face, &gindex );                   */
+  /*      while ( gindex != 0 )                                            */
+  /*      {                                                                */
+  /*        ... do something with (charcode,gindex) pair ...               */
+  /*                                                                       */
+  /*        charcode = FT_Get_Next_Char( face, charcode, &gindex );        */
+  /*      }                                                                */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Note that `*agindex' will be set to 0 if the charmap is empty.     */
+  /*    The result itself can be 0 in two cases: if the charmap is empty   */
+  /*    or when the value 0 is the first valid character code.             */
+  /*                                                                       */
+  FT_EXPORT( FT_ULong )
+  FT_Get_First_Char( FT_Face   face,
+                     FT_UInt  *agindex );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Next_Char                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to return the next character code in the     */
+  /*    current charmap of a given face following the value 'char_code',   */
+  /*    as well as the corresponding glyph index.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face      :: A handle to the source face object.                   */
+  /*    char_code :: The starting character code.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    agindex   :: Glyph index of first character code.  0 if charmap    */
+  /*                 is empty.                                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The charmap's next character code.                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should use this function with @FT_Get_First_Char to walk       */
+  /*    through all character codes available in a given charmap.  See     */
+  /*    the note for this function for a simple code example.              */
+  /*                                                                       */
+  /*    Note that `*agindex' will be set to 0 when there are no more codes */
+  /*    in the charmap.                                                    */
+  /*                                                                       */
+  FT_EXPORT( FT_ULong )
+  FT_Get_Next_Char( FT_Face    face,
+                    FT_ULong   char_code,
+                    FT_UInt   *agindex );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    FT_Get_Name_Index                                                  */
   /*                                                                       */
   /* <Description>                                                         */
@@ -2613,7 +2734,6 @@
 
 
   /* */
-
 
 FT_END_HEADER
 
Index: xc/extras/freetype2/include/freetype/ftbdf.h
diff -u /dev/null xc/extras/freetype2/include/freetype/ftbdf.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:42 2003
+++ xc/extras/freetype2/include/freetype/ftbdf.h	Thu Jun 20 04:16:06 2002
@@ -0,0 +1,84 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbdf.h                                                                */
+/*                                                                         */
+/*    FreeType API for accessing BDF-specific strings (specification).     */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTBDF_H__
+#define __FTBDF_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    bdf_fonts                                                          */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    BDF Fonts                                                          */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    BDF-specific APIs                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of BDF-specific functions.   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_BDF_Charset_ID
+  *
+  * @description:
+  *    Retrieves a BDF font character set identity, according to
+  *    the BDF specification.
+  *
+  * @input:
+  *    face ::
+  *       handle to input face
+  *
+  * @output:
+  *    acharset_encoding ::
+  *       Charset encoding, as a C string, owned by the face.
+  *
+  *    acharset_registry ::
+  *       Charset registry, as a C string, owned by the face.
+  *
+  * @return:
+  *   FreeType rror code.  0 means success.
+  *
+  * @note:
+  *   This function only works with BDF faces, returning an error otherwise.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_BDF_Charset_ID( FT_Face       face,
+                         const char*  *acharset_encoding,
+                         const char*  *acharset_registry );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FTBDF_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/include/freetype/fterrdef.h
diff -u /dev/null xc/extras/freetype2/include/freetype/fterrdef.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:42 2003
+++ xc/extras/freetype2/include/freetype/fterrdef.h	Thu Jun 20 04:16:07 2002
@@ -0,0 +1,229 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fterrdef.h                                                             */
+/*                                                                         */
+/*    FreeType error codes (specification).                                */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                LIST OF ERROR CODES/MESSAGES             *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+  /* You need to define both FT_ERRORDEF_ and FT_NOERRORDEF_ before */
+  /* including this file.                                           */
+
+
+  /* generic errors */
+
+  FT_NOERRORDEF_( Ok,                                        0x00, \
+                  "no error" )
+
+  FT_ERRORDEF_( Cannot_Open_Resource,                        0x01, \
+                "cannot open resource" )
+  FT_ERRORDEF_( Unknown_File_Format,                         0x02, \
+                "unknown file format" )
+  FT_ERRORDEF_( Invalid_File_Format,                         0x03, \
+                "broken file" )
+  FT_ERRORDEF_( Invalid_Version,                             0x04, \
+                "invalid FreeType version" )
+  FT_ERRORDEF_( Lower_Module_Version,                        0x05, \
+                "module version is too low" )
+  FT_ERRORDEF_( Invalid_Argument,                            0x06, \
+                "invalid argument" )
+  FT_ERRORDEF_( Unimplemented_Feature,                       0x07, \
+                "unimplemented feature" )
+  FT_ERRORDEF_( Invalid_Table,                               0x08, \
+                "broken table" )
+  FT_ERRORDEF_( Invalid_Offset,                              0x09, \
+                "broken offset within table" )
+
+  /* glyph/character errors */
+
+  FT_ERRORDEF_( Invalid_Glyph_Index,                         0x10, \
+                "invalid glyph index" )
+  FT_ERRORDEF_( Invalid_Character_Code,                      0x11, \
+                "invalid character code" )
+  FT_ERRORDEF_( Invalid_Glyph_Format,                        0x12, \
+                "unsupported glyph image format" )
+  FT_ERRORDEF_( Cannot_Render_Glyph,                         0x13, \
+                "cannot render this glyph format" )
+  FT_ERRORDEF_( Invalid_Outline,                             0x14, \
+                "invalid outline" )
+  FT_ERRORDEF_( Invalid_Composite,                           0x15, \
+                "invalid composite glyph" )
+  FT_ERRORDEF_( Too_Many_Hints,                              0x16, \
+                "too many hints" )
+  FT_ERRORDEF_( Invalid_Pixel_Size,                          0x17, \
+                "invalid pixel size" )
+
+  /* handle errors */
+
+  FT_ERRORDEF_( Invalid_Handle,                              0x20, \
+                "invalid object handle" )
+  FT_ERRORDEF_( Invalid_Library_Handle,                      0x21, \
+                "invalid library handle" )
+  FT_ERRORDEF_( Invalid_Driver_Handle,                       0x22, \
+                "invalid module handle" )
+  FT_ERRORDEF_( Invalid_Face_Handle,                         0x23, \
+                "invalid face handle" )
+  FT_ERRORDEF_( Invalid_Size_Handle,                         0x24, \
+                "invalid size handle" )
+  FT_ERRORDEF_( Invalid_Slot_Handle,                         0x25, \
+                "invalid glyph slot handle" )
+  FT_ERRORDEF_( Invalid_CharMap_Handle,                      0x26, \
+                "invalid charmap handle" )
+  FT_ERRORDEF_( Invalid_Cache_Handle,                        0x27, \
+                "invalid cache manager handle" )
+  FT_ERRORDEF_( Invalid_Stream_Handle,                       0x28, \
+                "invalid stream handle" )
+
+  /* driver errors */
+
+  FT_ERRORDEF_( Too_Many_Drivers,                            0x30, \
+                "too many modules" )
+  FT_ERRORDEF_( Too_Many_Extensions,                         0x31, \
+                "too many extensions" )
+
+  /* memory errors */
+
+  FT_ERRORDEF_( Out_Of_Memory,                               0x40, \
+                "out of memory" )
+  FT_ERRORDEF_( Unlisted_Object,                             0x41, \
+                "unlisted object" )
+
+  /* stream errors */
+
+  FT_ERRORDEF_( Cannot_Open_Stream,                          0x51, \
+                "cannot open stream" )
+  FT_ERRORDEF_( Invalid_Stream_Seek,                         0x52, \
+                "invalid stream seek" )
+  FT_ERRORDEF_( Invalid_Stream_Skip,                         0x53, \
+                "invalid stream skip" )
+  FT_ERRORDEF_( Invalid_Stream_Read,                         0x54, \
+                "invalid stream read" )
+  FT_ERRORDEF_( Invalid_Stream_Operation,                    0x55, \
+                "invalid stream operation" )
+  FT_ERRORDEF_( Invalid_Frame_Operation,                     0x56, \
+                "invalid frame operation" )
+  FT_ERRORDEF_( Nested_Frame_Access,                         0x57, \
+                "nested frame access" )
+  FT_ERRORDEF_( Invalid_Frame_Read,                          0x58, \
+                "invalid frame read" )
+
+  /* raster errors */
+
+  FT_ERRORDEF_( Raster_Uninitialized,                        0x60, \
+                "raster uninitialized" )
+  FT_ERRORDEF_( Raster_Corrupted,                            0x61, \
+                "raster corrupted" )
+  FT_ERRORDEF_( Raster_Overflow,                             0x62, \
+                "raster overflow" )
+  FT_ERRORDEF_( Raster_Negative_Height,                      0x63, \
+                "negative height while rastering" )
+
+  /* cache errors */
+
+  FT_ERRORDEF_( Too_Many_Caches,                             0x70, \
+                "too many registered caches" )
+
+  /* TrueType and SFNT errors */
+
+  FT_ERRORDEF_( Invalid_Opcode,                              0x80, \
+                "invalid opcode" )
+  FT_ERRORDEF_( Too_Few_Arguments,                           0x81, \
+                "too few arguments" )
+  FT_ERRORDEF_( Stack_Overflow,                              0x82, \
+                "stack overflow" )
+  FT_ERRORDEF_( Code_Overflow,                               0x83, \
+                "code overflow" )
+  FT_ERRORDEF_( Bad_Argument,                                0x84, \
+                "bad argument" )
+  FT_ERRORDEF_( Divide_By_Zero,                              0x85, \
+                "division by zero" )
+  FT_ERRORDEF_( Invalid_Reference,                           0x86, \
+                "invalid reference" )
+  FT_ERRORDEF_( Debug_OpCode,                                0x87, \
+                "found debug opcode" )
+  FT_ERRORDEF_( ENDF_In_Exec_Stream,                         0x88, \
+                "found ENDF opcode in execution stream" )
+  FT_ERRORDEF_( Nested_DEFS,                                 0x89, \
+                "nested DEFS" )
+  FT_ERRORDEF_( Invalid_CodeRange,                           0x8A, \
+                "invalid code range" )
+  FT_ERRORDEF_( Execution_Too_Long,                          0x8B, \
+                "execution context too long" )
+  FT_ERRORDEF_( Too_Many_Function_Defs,                      0x8C, \
+                "too many function definitions" )
+  FT_ERRORDEF_( Too_Many_Instruction_Defs,                   0x8D, \
+                "too many instruction definitions" )
+  FT_ERRORDEF_( Table_Missing,                               0x8E, \
+                "SFNT font table missing" )
+  FT_ERRORDEF_( Horiz_Header_Missing,                        0x8F, \
+                "horizontal header (hhea) table missing" )
+  FT_ERRORDEF_( Locations_Missing,                           0x90, \
+                "locations (loca) table missing" )
+  FT_ERRORDEF_( Name_Table_Missing,                          0x91, \
+                "name table missing" )
+  FT_ERRORDEF_( CMap_Table_Missing,                          0x92, \
+                "character map (cmap) table missing" )
+  FT_ERRORDEF_( Hmtx_Table_Missing,                          0x93, \
+                "horizontal metrics (hmtx) table missing" )
+  FT_ERRORDEF_( Post_Table_Missing,                          0x94, \
+                "PostScript (post) table missing" )
+  FT_ERRORDEF_( Invalid_Horiz_Metrics,                       0x95, \
+                "invalid horizontal metrics" )
+  FT_ERRORDEF_( Invalid_CharMap_Format,                      0x96, \
+                "invalid character map (cmap) format" )
+  FT_ERRORDEF_( Invalid_PPem,                                0x97, \
+                "invalid ppem value" )
+  FT_ERRORDEF_( Invalid_Vert_Metrics,                        0x98, \
+                "invalid vertical metrics" )
+  FT_ERRORDEF_( Could_Not_Find_Context,                      0x99, \
+                "could not find context" )
+  FT_ERRORDEF_( Invalid_Post_Table_Format,                   0x9A, \
+                "invalid PostScript (post) table format" )
+  FT_ERRORDEF_( Invalid_Post_Table,                          0x9B, \
+                "invalid PostScript (post) table" )
+
+  /* CFF, CID, and Type 1 errors */
+
+  FT_ERRORDEF_( Syntax_Error,                                0xA0, \
+                "opcode syntax error" )
+  FT_ERRORDEF_( Stack_Underflow,                             0xA1, \
+                "argument stack underflow" )
+
+  /* BDF errors */
+
+  FT_ERRORDEF_( Missing_Startfont_Field,                     0xB0, \
+                "`STARTFONT' field missing" )
+  FT_ERRORDEF_( Missing_Font_Field,                          0xB1, \
+                "`FONT' field missing" )
+  FT_ERRORDEF_( Missing_Size_Field,                          0xB2, \
+                "`SIZE' field missing" )
+  FT_ERRORDEF_( Missing_Chars_Field,                         0xB3, \
+                "`CHARS' field missing" )
+  FT_ERRORDEF_( Missing_Startchar_Field,                     0xB4, \
+                "`STARTCHAR' field missing" )
+  FT_ERRORDEF_( Missing_Encoding_Field,                      0xB5, \
+                "`ENCODING' field missing" )
+  FT_ERRORDEF_( Missing_Bbx_Field,                           0xB6, \
+                "`BBX' field missing" )
+
+
+/* END */
Index: xc/extras/freetype2/include/freetype/fterrors.h
diff -u xc/extras/freetype2/include/freetype/fterrors.h:1.1.1.4 xc/extras/freetype2/include/freetype/fterrors.h:1.1.1.6
--- xc/extras/freetype2/include/freetype/fterrors.h:1.1.1.4	Sun Dec 16 12:49:21 2001
+++ xc/extras/freetype2/include/freetype/fterrors.h	Thu Jun 20 04:16:07 2002
@@ -2,9 +2,9 @@
 /*                                                                         */
 /*  fterrors.h                                                             */
 /*                                                                         */
-/*    FreeType error codes (specification).                                */
+/*    FreeType error code handling (specification).                        */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -18,16 +18,16 @@
 
   /*************************************************************************/
   /*                                                                       */
-  /* This special header file is used to define the FT2 enumeration        */
-  /* constants.  It can also be used to generate error message strings     */
-  /* with a small macro trick explained below.                             */
+  /* This special header file is used to define the handling of FT2        */
+  /* enumeration constants.  It can also be used to generate error message */
+  /* strings with a small macro trick explained below.                     */
   /*                                                                       */
   /* I - Error Formats                                                     */
   /* -----------------                                                     */
   /*                                                                       */
   /*   Since release 2.1, the error constants have changed.  The lower     */
   /*   byte of the error value gives the "generic" error code, while the   */
-  /*   higher byte indicates in which module the error occured.            */
+  /*   higher byte indicates in which module the error occurred.           */
   /*                                                                       */
   /*   You can use the macro FT_ERROR_BASE(x) macro to extract the generic */
   /*   error code from an FT_Error value.                                  */
@@ -71,9 +71,9 @@
   /*                                                                       */
   /*     {                                                                 */
   /*       #undef __FTERRORS_H__                                           */
-  /*       #define FT_ERRORDEF( e, v, s )   { e, s },                      */
-  /*       #define FT_ERROR_START_LIST      {                              */
-  /*       #define FT_ERROR_END_LIST        { 0, 0 } };                    */
+  /*       #define FT_ERRORDEF( e, v, s )  { e, s },                       */
+  /*       #define FT_ERROR_START_LIST     {                               */
+  /*       #define FT_ERROR_END_LIST       { 0, 0 } };                     */
   /*                                                                       */
   /*       const struct                                                    */
   /*       {                                                               */
@@ -105,6 +105,10 @@
 
 
 #undef  FT_NEED_EXTERN_C
+
+#undef  FT_ERR_XCAT
+#undef  FT_ERR_CAT
+
 #define FT_ERR_XCAT( x, y )  x ## y
 #define FT_ERR_CAT( x, y )   FT_ERR_XCAT( x, y )
 
@@ -159,196 +163,15 @@
           FT_ERRORDEF( FT_ERR_CAT( FT_ERR_PREFIX, e ), v, s )
 
 
-  /*******************************************************************/
-  /*******************************************************************/
-  /*****                                                         *****/
-  /*****                LIST OF ERROR CODES/MESSAGES             *****/
-  /*****                                                         *****/
-  /*******************************************************************/
-  /*******************************************************************/
-
-
 #ifdef FT_ERROR_START_LIST
   FT_ERROR_START_LIST
 #endif
 
 
-  /* generic errors */
+  /* no include the error codes */
+#include FT_ERROR_DEFINITIONS_H
 
-  FT_NOERRORDEF_( Ok,                                        0x00, \
-                  "no error" )
 
-  FT_ERRORDEF_( Cannot_Open_Resource,                        0x01, \
-               "cannot open resource" )
-  FT_ERRORDEF_( Unknown_File_Format,                         0x02, \
-               "unknown file format" )
-  FT_ERRORDEF_( Invalid_File_Format,                         0x03, \
-               "broken file" )
-  FT_ERRORDEF_( Invalid_Version,                             0x04, \
-               "invalid FreeType version" )
-  FT_ERRORDEF_( Lower_Module_Version,                        0x05, \
-               "module version is too low" )
-  FT_ERRORDEF_( Invalid_Argument,                            0x06, \
-               "invalid argument" )
-  FT_ERRORDEF_( Unimplemented_Feature,                       0x07, \
-               "unimplemented feature" )
-
-  /* glyph/character errors */
-
-  FT_ERRORDEF_( Invalid_Glyph_Index,                         0x10, \
-               "invalid glyph index" )
-  FT_ERRORDEF_( Invalid_Character_Code,                      0x11, \
-               "invalid character code" )
-  FT_ERRORDEF_( Invalid_Glyph_Format,                        0x12, \
-               "unsupported glyph image format" )
-  FT_ERRORDEF_( Cannot_Render_Glyph,                         0x13, \
-               "cannot render this glyph format" )
-  FT_ERRORDEF_( Invalid_Outline,                             0x14, \
-               "invalid outline" )
-  FT_ERRORDEF_( Invalid_Composite,                           0x15, \
-               "invalid composite glyph" )
-  FT_ERRORDEF_( Too_Many_Hints,                              0x16, \
-               "too many hints" )
-  FT_ERRORDEF_( Invalid_Pixel_Size,                          0x17, \
-               "invalid pixel size" )
-
-  /* handle errors */
-
-  FT_ERRORDEF_( Invalid_Handle,                              0x20, \
-               "invalid object handle" )
-  FT_ERRORDEF_( Invalid_Library_Handle,                      0x21, \
-               "invalid library handle" )
-  FT_ERRORDEF_( Invalid_Driver_Handle,                       0x22, \
-               "invalid module handle" )
-  FT_ERRORDEF_( Invalid_Face_Handle,                         0x23, \
-               "invalid face handle" )
-  FT_ERRORDEF_( Invalid_Size_Handle,                         0x24, \
-               "invalid size handle" )
-  FT_ERRORDEF_( Invalid_Slot_Handle,                         0x25, \
-               "invalid glyph slot handle" )
-  FT_ERRORDEF_( Invalid_CharMap_Handle,                      0x26, \
-               "invalid charmap handle" )
-  FT_ERRORDEF_( Invalid_Cache_Handle,                        0x27, \
-               "invalid cache manager handle" )
-  FT_ERRORDEF_( Invalid_Stream_Handle,                       0x28, \
-               "invalid stream handle" )
-
-  /* driver errors */
-
-  FT_ERRORDEF_( Too_Many_Drivers,                            0x30, \
-               "too many modules" )
-  FT_ERRORDEF_( Too_Many_Extensions,                         0x31, \
-               "too many extensions" )
-
-  /* memory errors */
-
-  FT_ERRORDEF_( Out_Of_Memory,                               0x40, \
-               "out of memory" )
-  FT_ERRORDEF_( Unlisted_Object,                             0x41, \
-               "unlisted object" )
-
-  /* stream errors */
-
-  FT_ERRORDEF_( Cannot_Open_Stream,                          0x51, \
-               "cannot open stream" )
-  FT_ERRORDEF_( Invalid_Stream_Seek,                         0x52, \
-               "invalid stream seek" )
-  FT_ERRORDEF_( Invalid_Stream_Skip,                         0x53, \
-               "invalid stream skip" )
-  FT_ERRORDEF_( Invalid_Stream_Read,                         0x54, \
-               "invalid stream read" )
-  FT_ERRORDEF_( Invalid_Stream_Operation,                    0x55, \
-               "invalid stream operation" )
-  FT_ERRORDEF_( Invalid_Frame_Operation,                     0x56, \
-               "invalid frame operation" )
-  FT_ERRORDEF_( Nested_Frame_Access,                         0x57, \
-               "nested frame access" )
-  FT_ERRORDEF_( Invalid_Frame_Read,                          0x58, \
-               "invalid frame read" )
-
-  /* raster errors */
-
-  FT_ERRORDEF_( Raster_Uninitialized,                        0x60, \
-               "raster uninitialized" )
-  FT_ERRORDEF_( Raster_Corrupted,                            0x61, \
-               "raster corrupted" )
-  FT_ERRORDEF_( Raster_Overflow,                             0x62, \
-               "raster overflow" )
-  FT_ERRORDEF_( Raster_Negative_Height,                      0x63, \
-               "negative height while rastering" )
-
-  /* cache errors */
-
-  FT_ERRORDEF_( Too_Many_Caches,                             0x70, \
-               "too many registered caches" )
-
-  /* TrueType and SFNT errors */
-
-  FT_ERRORDEF_( Invalid_Opcode,                              0x80, \
-               "invalid opcode" )
-  FT_ERRORDEF_( Too_Few_Arguments,                           0x81, \
-               "too few arguments" )
-  FT_ERRORDEF_( Stack_Overflow,                              0x82, \
-               "stack overflow" )
-  FT_ERRORDEF_( Code_Overflow,                               0x83, \
-               "code overflow" )
-  FT_ERRORDEF_( Bad_Argument,                                0x84, \
-               "bad argument" )
-  FT_ERRORDEF_( Divide_By_Zero,                              0x85, \
-               "division by zero" )
-  FT_ERRORDEF_( Invalid_Reference,                           0x86, \
-               "invalid reference" )
-  FT_ERRORDEF_( Debug_OpCode,                                0x87, \
-               "found debug opcode" )
-  FT_ERRORDEF_( ENDF_In_Exec_Stream,                         0x88, \
-               "found ENDF opcode in execution stream" )
-  FT_ERRORDEF_( Nested_DEFS,                                 0x89, \
-               "nested DEFS" )
-  FT_ERRORDEF_( Invalid_CodeRange,                           0x8A, \
-               "invalid code range" )
-  FT_ERRORDEF_( Execution_Too_Long,                          0x8B, \
-               "execution context too long" )
-  FT_ERRORDEF_( Too_Many_Function_Defs,                      0x8C, \
-               "too many function definitions" )
-  FT_ERRORDEF_( Too_Many_Instruction_Defs,                   0x8D, \
-               "too many instruction definitions" )
-  FT_ERRORDEF_( Table_Missing,                               0x8E, \
-               "SFNT font table missing" )
-  FT_ERRORDEF_( Horiz_Header_Missing,                        0x8F, \
-               "horizontal header (hhea) table missing" )
-  FT_ERRORDEF_( Locations_Missing,                           0x90, \
-               "locations (loca) table missing" )
-  FT_ERRORDEF_( Name_Table_Missing,                          0x91, \
-               "name table missing" )
-  FT_ERRORDEF_( CMap_Table_Missing,                          0x92, \
-               "character map (cmap) table missing" )
-  FT_ERRORDEF_( Hmtx_Table_Missing,                          0x93, \
-               "horizontal metrics (hmtx) table missing" )
-  FT_ERRORDEF_( Post_Table_Missing,                          0x94, \
-               "PostScript (post) table missing" )
-  FT_ERRORDEF_( Invalid_Horiz_Metrics,                       0x95, \
-               "invalid horizontal metrics" )
-  FT_ERRORDEF_( Invalid_CharMap_Format,                      0x96, \
-               "invalid character map (cmap) format" )
-  FT_ERRORDEF_( Invalid_PPem,                                0x97, \
-               "invalid ppem value" )
-  FT_ERRORDEF_( Invalid_Vert_Metrics,                        0x98, \
-               "invalid vertical metrics" )
-  FT_ERRORDEF_( Could_Not_Find_Context,                      0x99, \
-               "could not find context" )
-  FT_ERRORDEF_( Invalid_Post_Table_Format,                   0x9A, \
-               "invalid PostScript (post) table format" )
-  FT_ERRORDEF_( Invalid_Post_Table,                          0x9B, \
-               "invalid PostScript (post) table" )
-
-  /* CFF, CID, and Type 1 errors */
-
-  FT_ERRORDEF_( Syntax_Error,                                0xA0, \
-               "opcode syntax error" )
-  FT_ERRORDEF_( Stack_Underflow,                             0xA1, \
-               "argument stack underflow" )
-
-
 #ifdef FT_ERROR_END_LIST
   FT_ERROR_END_LIST
 #endif
@@ -379,5 +202,6 @@
 #undef FT_ERR_CONCAT
 
 #endif /* __FTERRORS_H__ */
+
 
 /* END */
Index: xc/extras/freetype2/include/freetype/ftimage.h
diff -u xc/extras/freetype2/include/freetype/ftimage.h:1.1.1.5 xc/extras/freetype2/include/freetype/ftimage.h:1.1.1.6
--- xc/extras/freetype2/include/freetype/ftimage.h:1.1.1.5	Mon Jan 14 11:52:04 2002
+++ xc/extras/freetype2/include/freetype/ftimage.h	Thu Feb 14 19:33:25 2002
@@ -892,10 +892,10 @@
   /*    user        :: User-supplied data that is passed to each drawing   */
   /*                   callback.                                           */
   /*                                                                       */
-  /*    clip_box    :: an optional clipping box. It is only used in        */
-  /*                   direct rendering mode. Note that coordinates        */
-  /*                   here should be expressed in _integer_ pixels        */
-  /*                   (and not 26.6 fixed-point units)                    */
+  /*    clip_box    :: An optional clipping box.  It is only used in       */
+  /*                   direct rendering mode.  Note that coordinates here  */
+  /*                   should be expressed in _integer_ pixels (and not in */
+  /*                   26.6 fixed-point units).                            */
   /*                                                                       */
   /* <Note>                                                                */
   /*    An anti-aliased glyph bitmap is drawn if the ft_raster_flag_aa bit */
Index: xc/extras/freetype2/include/freetype/ftmoderr.h
diff -u xc/extras/freetype2/include/freetype/ftmoderr.h:1.1.1.1 xc/extras/freetype2/include/freetype/ftmoderr.h:1.1.1.2
--- xc/extras/freetype2/include/freetype/ftmoderr.h:1.1.1.1	Sun Sep  9 22:55:55 2001
+++ xc/extras/freetype2/include/freetype/ftmoderr.h	Thu Jun 20 04:16:07 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType module error offsets (specification).                       */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -116,6 +116,7 @@
   FT_MODERRDEF( TrueType, 0xB00, "TrueType module" )
   FT_MODERRDEF( Type1,    0xC00, "Type 1 module" )
   FT_MODERRDEF( Winfonts, 0xD00, "Windows FON/FNT module" )
+  FT_MODERRDEF( PFR,      0xE00, "PFR module" )
 
 
 #ifdef FT_MODERR_END_LIST
Index: xc/extras/freetype2/include/freetype/ftoutln.h
diff -u xc/extras/freetype2/include/freetype/ftoutln.h:1.1.1.4 xc/extras/freetype2/include/freetype/ftoutln.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/ftoutln.h:1.1.1.4	Mon Jan 14 11:52:04 2002
+++ xc/extras/freetype2/include/freetype/ftoutln.h	Thu Jun 20 04:16:07 2002
@@ -5,7 +5,7 @@
 /*    Support for the FT_Outline type used to store glyph shapes of        */
 /*    most scalable font formats (specification).                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -83,22 +83,24 @@
   /*    of new contours in the outline.                                    */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    outline   :: A pointer to the source target.                       */
+  /*    outline        :: A pointer to the source target.                  */
   /*                                                                       */
-  /*    interface :: A table of `emitters', i.e,. function pointers called */
-  /*                 during decomposition to indicate path operations.     */
+  /*    func_interface :: A table of `emitters', i.e,. function pointers   */
+  /*                      called during decomposition to indicate path     */
+  /*                      operations.                                      */
   /*                                                                       */
   /* <InOut>                                                               */
-  /*    user      :: A typeless pointer which is passed to each emitter    */
-  /*                 during the decomposition.  It can be used to store    */
-  /*                 the state during the decomposition.                   */
+  /*    user           :: A typeless pointer which is passed to each       */
+  /*                      emitter during the decomposition.  It can be     */
+  /*                      used to store the state during the               */
+  /*                      decomposition.                                   */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means sucess.                              */
   /*                                                                       */
   FT_EXPORT( FT_Error )
   FT_Outline_Decompose( FT_Outline*              outline,
-                        const FT_Outline_Funcs*  interface,
+                        const FT_Outline_Funcs*  func_interface,
                         void*                    user );
 
 
Index: xc/extras/freetype2/include/freetype/ftsnames.h
diff -u xc/extras/freetype2/include/freetype/ftsnames.h:1.1.1.2 xc/extras/freetype2/include/freetype/ftsnames.h:1.1.1.3
--- xc/extras/freetype2/include/freetype/ftsnames.h:1.1.1.2	Sun Dec 16 12:49:22 2001
+++ xc/extras/freetype2/include/freetype/ftsnames.h	Thu Jun 20 04:16:07 2002
@@ -7,7 +7,7 @@
 /*                                                                         */
 /*    This is _not_ used to retrieve glyph names!                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -128,7 +128,7 @@
   /* <Input>                                                               */
   /*    face  :: A handle to the source face.                              */
   /*                                                                       */
-  /*    index :: The index of the `name' string.                           */
+  /*    idx   :: The index of the `name' string.                           */
   /*                                                                       */
   /* <Output>                                                              */
   /*    aname :: The indexed FT_SfntName structure.                        */
@@ -146,7 +146,7 @@
   /*                                                                       */
   FT_EXPORT( FT_Error )
   FT_Get_Sfnt_Name( FT_Face       face,
-                    FT_UInt       index,
+                    FT_UInt       idx,
                     FT_SfntName  *aname );
 
 
Index: xc/extras/freetype2/include/freetype/ftsysio.h
diff -u /dev/null xc/extras/freetype2/include/freetype/ftsysio.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:42 2003
+++ xc/extras/freetype2/include/freetype/ftsysio.h	Thu Jun 20 04:16:07 2002
@@ -0,0 +1,184 @@
+#ifndef __FT_SYSTEM_IO_H__
+#define __FT_SYSTEM_IO_H__
+
+ /********************************************************************
+  *
+  *  designing custom streams is a bit different now
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  */
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECT_H
+
+FT_BEGIN_HEADER
+
+ /********************************************************************
+  *
+  * @type: FT_Stream
+  *
+  * @description:
+  *   handle to an input stream object. These are also @FT_Object handles
+  */
+  typedef struct FT_StreamRec_*    FT_Stream;
+
+
+ /********************************************************************
+  *
+  * @type: FT_Stream_Class
+  *
+  * @description:
+  *   opaque handle to a @FT_Stream_ClassRec class structure describing
+  *   the methods of input streams
+  */
+  typedef const struct FT_Stream_ClassRec_*   FT_Stream_Class;
+
+
+ /********************************************************************
+  *
+  * @functype: FT_Stream_ReadFunc
+  *
+  * @description:
+  *   a method used to read bytes from an input stream into memory
+  *
+  * @input:
+  *   stream  :: target stream handle
+  *   buffer  :: target buffer address
+  *   size    :: number of bytes to read
+  *
+  * @return:
+  *   number of bytes effectively read. Must be <= 'size'.
+  */
+  typedef FT_ULong  (*FT_Stream_ReadFunc)( FT_Stream   stream,
+                                           FT_Byte*    buffer,
+                                           FT_ULong    size );
+
+
+ /********************************************************************
+  *
+  * @functype: FT_Stream_SeekFunc
+  *
+  * @description:
+  *   a method used to seek to a new position within a stream
+  *
+  * @input:
+  *   stream  :: target stream handle
+  *   pos     :: new read position, from start of stream
+  *
+  * @return:
+  *   error code. 0 means success
+  */
+  typedef FT_Error  (*FT_Stream_SeekFunc)( FT_Stream   stream,
+                                           FT_ULong    pos );
+
+ /********************************************************************
+  *
+  * @struct: FT_Stream_ClassRec
+  *
+  * @description:
+  *   a structure used to describe an input stream class
+  *
+  * @input:
+  *   clazz       :: root @FT_ClassRec fields
+  *   stream_read :: stream byte read method
+  *   stream_seek :: stream seek method
+  */
+  typedef struct FT_Stream_ClassRec_
+  {
+    FT_ClassRec          clazz;
+    FT_Stream_ReadFunc   stream_read;
+    FT_Stream_SeekFunc   stream_seek;
+
+  } FT_Stream_ClassRec;
+
+ /* */
+
+#define  FT_STREAM_CLASS(x)        ((FT_Stream_Class)(x))
+#define  FT_STREAM_CLASS__READ(x)  FT_STREAM_CLASS(x)->stream_read
+#define  FT_STREAM_CLASS__SEEK(x)  FT_STREAM_CLASS(x)->stream_seek;
+
+ /********************************************************************
+  *
+  * @struct: FT_StreamRec
+  *
+  * @description:
+  *   the input stream object structure. See @FT_Stream_ClassRec for
+  *   its class descriptor
+  *
+  * @fields:
+  *   object      :: root @FT_ObjectRec fields
+  *   size        :: size of stream in bytes (0 if unknown)
+  *   pos         :: current position within stream
+  *   base        :: for memory-based streams, the address of the stream's
+  *                  first data byte in memory. NULL otherwise
+  *
+  *   cursor      :: the current cursor position within an input stream
+  *                  frame. Only valid within a FT_FRAME_ENTER .. FT_FRAME_EXIT
+  *                  block; NULL otherwise
+  *
+  *   limit       :: the current frame limit within a FT_FRAME_ENTER ..
+  *                  FT_FRAME_EXIT block. NULL otherwise
+  */
+  typedef struct FT_StreamRec_
+  {
+    FT_ObjectRec        object;
+    FT_ULong            size;
+    FT_ULong            pos;
+    const FT_Byte*      base;
+    const FT_Byte*      cursor;
+    const FT_Byte*      limit;
+
+  } FT_StreamRec;
+
+ /* some useful macros */
+#define  FT_STREAM(x)    ((FT_Stream)(x))
+#define  FT_STREAM_P(x)  ((FT_Stream*)(x))
+
+#define  FT_STREAM__READ(x)  FT_STREAM_CLASS__READ(FT_OBJECT__CLASS(x))
+#define  FT_STREAM__SEEK(x)  FT_STREAM_CLASS__SEEK(FT_OBJECT__CLASS(x))
+
+#define  FT_STREAM_IS_BASED(x)  ( FT_STREAM(x)->base != NULL )
+
+ /* */
+
+ /* create new memory-based stream */
+  FT_BASE( FT_Error )   ft_stream_new_memory( const FT_Byte*  stream_base,
+                                              FT_ULong        stream_size,
+                                              FT_Memory       memory,
+                                              FT_Stream      *astream );
+
+  FT_BASE( FT_Error )   ft_stream_new_iso( const char*  pathanme,
+                                           FT_Memory    memory,
+                                           FT_Stream   *astream );
+
+
+ /* handle to default stream class implementation for a given build */
+ /* this is used by "FT_New_Face"                                   */
+ /*                                                                 */
+  FT_APIVAR( FT_Type )   ft_stream_default_type;
+
+FT_END_HEADER
+
+#endif /* __FT_SYSTEM_STREAM_H__ */
Index: xc/extras/freetype2/include/freetype/ftsysmem.h
diff -u /dev/null xc/extras/freetype2/include/freetype/ftsysmem.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:42 2003
+++ xc/extras/freetype2/include/freetype/ftsysmem.h	Thu Jun 20 04:16:08 2002
@@ -0,0 +1,192 @@
+#ifndef __FT_SYSTEM_MEMORY_H__
+#define __FT_SYSTEM_MEMORY_H__
+
+#include <ft2build.h>
+
+FT_BEGIN_HEADER
+
+ /***********************************************************************
+  *
+  * @type: FT_Memory
+  *
+  * @description:
+  *   opaque handle to a memory manager handle. Note that since FreeType
+  *   2.2, the memory manager structure FT_MemoryRec is hidden to client
+  *   applications.
+  *
+  *   however, you can still define custom allocators easily using the
+  *   @ft_memory_new API
+  */
+  typedef struct FT_MemoryRec_*   FT_Memory;
+
+
+ /***********************************************************************
+  *
+  * @functype: FT_Memory_AllocFunc
+  *
+  * @description:
+  *   a function used to allocate a block of memory.
+  *
+  * @input:
+  *   size     :: size of blocks in bytes. Always > 0 !!
+  *   mem_data :: memory-manager specific optional argument
+  *               (see @ft_memory_new)
+  *
+  * @return:
+  *   address of new block. NULL in case of memory exhaustion
+  */
+  typedef FT_Pointer  (*FT_Memory_AllocFunc)( FT_ULong   size,
+                                              FT_Pointer mem_data );
+
+
+ /***********************************************************************
+  *
+  * @functype: FT_Memory_FreeFunc
+  *
+  * @description:
+  *   a function used to release a block of memory created through
+  *   @FT_Memory_AllocFunc or @FT_Memory_ReallocFunc
+  *
+  * @input:
+  *   block    :: address of target memory block. cannot be NULL !!
+  *   mem_data :: memory-manager specific optional argument
+  *               (see @ft_memory_new)
+  */
+  typedef void        (*FT_Memory_FreeFunc) ( FT_Pointer  block,
+                                              FT_Pointer  mem_data );
+
+
+ /***********************************************************************
+  *
+  * @functype: FT_Memory_ReallocFunc
+  *
+  * @description:
+  *   a function used to reallocate a memory block.
+  *
+  * @input:
+  *   block    :: address of target memory block. cannot be NULL !!
+  *   new_size :: new requested size in bytes
+  *   cur_size :: current block size in bytes
+  *   mem_data :: memory-manager specific optional argument
+  *               (see @ft_memory_new)
+  */
+  typedef FT_Pointer  (*FT_Memory_ReallocFunc)( FT_Pointer   block,
+                                                FT_ULong     new_size,
+                                                FT_ULong     cur_size,
+                                                FT_Pointer   mem_data );
+
+
+ /***********************************************************************
+  *
+  * @functype: FT_Memory_CreateFunc
+  *
+  * @description:
+  *   a function used to create a @FT_Memory object to model a
+  *   memory manager
+  *
+  * @input:
+  *   size      :: size of memory manager structure in bytes
+  *   init_data :: optional initialisation argument
+  *
+  * @output:
+  *   amem_data :: memory-manager specific argument to block management
+  *                routines.
+  *
+  * @return:
+  *   handle to new memory manager object. NULL in case of failure
+  */
+  typedef FT_Pointer  (*FT_Memory_CreateFunc)( FT_UInt     size,
+                                               FT_Pointer  init_data,
+                                               FT_Pointer *amem_data );
+
+
+ /***********************************************************************
+  *
+  * @functype: FT_Memory_DestroyFunc
+  *
+  * @description:
+  *   a function used to destroy a given @FT_Memory manager
+  *
+  * @input:
+  *   memory   :: target memory manager handle
+  *   mem_data :: option manager-specific argument
+  */
+  typedef void        (*FT_Memory_DestroyFunc)( FT_Memory  memory,
+                                                FT_Pointer mem_data );
+
+
+ /***********************************************************************
+  *
+  * @struct: FT_Memory_FuncsRec
+  *
+  * @description:
+  *   a function used to hold all methods of a given memory manager
+  *   implementation.
+  *
+  * @fields:
+  *   mem_alloc   :: block allocation routine
+  *   mem_free    :: block release routine
+  *   mem_realloc :: block re-allocation routine
+  *   mem_create  :: manager creation routine
+  *   mem_destroy :: manager destruction routine
+  */
+  typedef struct FT_Memory_FuncsRec_
+  {
+    FT_Memory_AllocFunc     mem_alloc;
+    FT_Memory_FreeFunc      mem_free;
+    FT_Memory_ReallocFunc   mem_realloc;
+    FT_Memory_CreateFunc    mem_create;
+    FT_Memory_DestroyFunc   mem_destroy;
+
+  } FT_Memory_FuncsRec, *FT_Memory_Funcs;
+
+
+ /***********************************************************************
+  *
+  * @type: FT_Memory_Funcs
+  *
+  * @description:
+  *   a pointer to a constant @FT_Memory_FuncsRec structure used to
+  *   describe a given memory manager implementation.
+  */
+  typedef const FT_Memory_FuncsRec*  FT_Memory_Funcs;
+
+
+ /***********************************************************************
+  *
+  * @function: ft_memory_new
+  *
+  * @description:
+  *   create a new memory manager, given a set of memory methods
+  *
+  * @input:
+  *   mem_funcs     :: handle to memory manager implementation descriptor
+  *   mem_init_data :: optional initialisation argument, passed to
+  *                    @FT_Memory_CreateFunc
+  *
+  * @return:
+  *   new memory manager handle. NULL in case of failure
+  */
+  FT_BASE( FT_Memory )
+  ft_memory_new( FT_Memory_Funcs  mem_funcs,
+                 FT_Pointer       mem_init_data );
+
+
+ /***********************************************************************
+  *
+  * @function: ft_memory_destroy
+  *
+  * @description:
+  *   destroy a given memory manager
+  *
+  * @input:
+  *   memory :: handle to target memory manager
+  */
+  FT_BASE( void )
+  ft_memory_destroy( FT_Memory  memory );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __FT_SYSTEM_MEMORY_H__ */
Index: xc/extras/freetype2/include/freetype/ftsystem.h
diff -u xc/extras/freetype2/include/freetype/ftsystem.h:1.1.1.4 xc/extras/freetype2/include/freetype/ftsystem.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/ftsystem.h:1.1.1.4	Sun Dec 16 12:49:22 2001
+++ xc/extras/freetype2/include/freetype/ftsystem.h	Thu Jun 20 04:16:08 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType low-level system interface definition (specification).      */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -25,6 +25,7 @@
 
 FT_BEGIN_HEADER
 
+
   /*************************************************************************/
   /*                                                                       */
   /* <Section>                                                             */
@@ -197,7 +198,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* @functype:                                                            */
-  /*    FT_Stream_IO                                                       */
+  /*    FT_Stream_IoFunc                                                   */
   /*                                                                       */
   /* @description:                                                         */
   /*    A function used to seek and read data from a given input stream.   */
@@ -219,16 +220,16 @@
   /*    with a `count' of 0.                                               */
   /*                                                                       */
   typedef unsigned long
-  (*FT_Stream_IO)( FT_Stream       stream,
-                   unsigned long   offset,
-                   unsigned char*  buffer,
-                   unsigned long   count );
+  (*FT_Stream_IoFunc)( FT_Stream       stream,
+                       unsigned long   offset,
+                       unsigned char*  buffer,
+                       unsigned long   count );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* @functype:                                                            */
-  /*    FT_Stream_Close                                                    */
+  /*    FT_Stream_CloseFunc                                                */
   /*                                                                       */
   /* @description:                                                         */
   /*    A function used to close a given input stream.                     */
@@ -237,7 +238,7 @@
   /*   stream :: A handle to the target stream.                            */
   /*                                                                       */
   typedef void
-  (*FT_Stream_Close)( FT_Stream  stream );
+  (*FT_Stream_CloseFunc)( FT_Stream  stream );
 
 
   /*************************************************************************/
@@ -281,18 +282,18 @@
   /*                                                                       */
   struct  FT_StreamRec_
   {
-    unsigned char*   base;
-    unsigned long    size;
-    unsigned long    pos;
-
-    FT_StreamDesc    descriptor;
-    FT_StreamDesc    pathname;
-    FT_Stream_IO     read;
-    FT_Stream_Close  close;
-
-    FT_Memory        memory;
-    unsigned char*   cursor;
-    unsigned char*   limit;
+    unsigned char*       base;
+    unsigned long        size;
+    unsigned long        pos;
+
+    FT_StreamDesc        descriptor;
+    FT_StreamDesc        pathname;
+    FT_Stream_IoFunc     read;
+    FT_Stream_CloseFunc  close;
+
+    FT_Memory            memory;
+    unsigned char*       cursor;
+    unsigned char*       limit;
   };
 
 
Index: xc/extras/freetype2/include/freetype/ftxf86.h
diff -u /dev/null xc/extras/freetype2/include/freetype/ftxf86.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:42 2003
+++ xc/extras/freetype2/include/freetype/ftxf86.h	Thu Jun 20 04:16:08 2002
@@ -0,0 +1,53 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftxf86.h                                                               */
+/*                                                                         */
+/*    Support functions for X11.                                           */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTXF86_H__
+#define __FTXF86_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+  /* this comment is intentionally disabled for now, to prevent this       */
+  /* function from appearing in the API Reference.                         */
+
+  /*@***********************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_X11_Font_Format                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a string describing the format of a given face as an X11    */
+  /*    FONT_PROPERTY.  It should only be used by the FreeType 2 font      */
+  /*    backend of the XFree86 font server.                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: Input face handle.                                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Font format string.  NULL in case of error.                        */
+  /*                                                                       */
+  FT_EXPORT_DEF( const char* )
+  FT_Get_X11_Font_Format( FT_Face  face );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FTXF86_H__ */
Index: xc/extras/freetype2/include/freetype/t1tables.h
diff -u xc/extras/freetype2/include/freetype/t1tables.h:1.1.1.4 xc/extras/freetype2/include/freetype/t1tables.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/t1tables.h:1.1.1.4	Sun Dec 16 12:49:22 2001
+++ xc/extras/freetype2/include/freetype/t1tables.h	Thu Jun 20 04:16:08 2002
@@ -5,7 +5,7 @@
 /*    Basic Type 1/Type 2 tables definitions and interface (specification  */
 /*    only).                                                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -46,21 +46,21 @@
   /*************************************************************************/
 
 
-  /* Note that we separate font data in T1_FontInfo and T1_Private */
-  /* structures in order to support Multiple Master fonts.         */
+  /* Note that we separate font data in PS_FontInfoRec and PS_PrivateRec */
+  /* structures in order to support Multiple Master fonts.               */
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    T1_FontInfo                                                        */
+  /*    PS_FontInfoRec                                                     */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used to model a Type1/Type2 FontInfo dictionary.  Note */
   /*    that for Multiple Master fonts, each instance has its own          */
   /*    FontInfo.                                                          */
   /*                                                                       */
-  typedef struct  T1_FontInfo
+  typedef struct  PS_FontInfoRec
   {
     FT_String*  version;
     FT_String*  notice;
@@ -72,20 +72,33 @@
     FT_Short    underline_position;
     FT_UShort   underline_thickness;
 
-  } T1_FontInfo;
+  } PS_FontInfoRec, *PS_FontInfo;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    T1_Private                                                         */
+  /*    T1_FontInfo                                                        */
   /*                                                                       */
   /* <Description>                                                         */
-  /*    A structure used to model a Type1/Type2 FontInfo dictionary.  Note */
+  /*    This type is equivalent to @PS_FontInfoRec.  It is deprecated but  */
+  /*    kept to maintain source compatibility between various versions of  */
+  /*    FreeType.                                                          */
+  /*                                                                       */
+  typedef PS_FontInfoRec  T1_FontInfo;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_PrivateRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a Type1/Type2 private dictionary.  Note  */
   /*    that for Multiple Master fonts, each instance has its own Private  */
-  /*    dict.                                                              */
+  /*    dictionary.                                                        */
   /*                                                                       */
-  typedef struct  T1_Private
+  typedef struct  PS_PrivateRec_
   {
     FT_Int     unique_id;
     FT_Int     lenIV;
@@ -120,8 +133,21 @@
     FT_Long    password;
 
     FT_Short   min_feature[2];
+
+  } PS_PrivateRec, *PS_Private;
 
-  } T1_Private;
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    T1_Private                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This type is equivalent to @PS_PrivateRec.  It is deprecated but    */
+  /*   kept to maintain source compatibility between various versions of   */
+  /*   FreeType.                                                           */
+  /*                                                                       */
+  typedef PS_PrivateRec  T1_Private;
 
 
   /*************************************************************************/
@@ -137,29 +163,47 @@
   typedef enum
   {
     /*# required fields in a FontInfo blend dictionary */
-    t1_blend_underline_position = 0,
-    t1_blend_underline_thickness,
-    t1_blend_italic_angle,
+    T1_BLEND_UNDERLINE_POSITION = 0,
+    T1_BLEND_UNDERLINE_THICKNESS,
+    T1_BLEND_ITALIC_ANGLE,
 
     /*# required fields in a Private blend dictionary */
-    t1_blend_blue_values,
-    t1_blend_other_blues,
-    t1_blend_standard_width,
-    t1_blend_standard_height,
-    t1_blend_stem_snap_widths,
-    t1_blend_stem_snap_heights,
-    t1_blend_blue_scale,
-    t1_blend_blue_shift,
-    t1_blend_family_blues,
-    t1_blend_family_other_blues,
-    t1_blend_force_bold,
+    T1_BLEND_BLUE_VALUES,
+    T1_BLEND_OTHER_BLUES,
+    T1_BLEND_STANDARD_WIDTH,
+    T1_BLEND_STANDARD_HEIGHT,
+    T1_BLEND_STEM_SNAP_WIDTHS,
+    T1_BLEND_STEM_SNAP_HEIGHTS,
+    T1_BLEND_BLUE_SCALE,
+    T1_BLEND_BLUE_SHIFT,
+    T1_BLEND_FAMILY_BLUES,
+    T1_BLEND_FAMILY_OTHER_BLUES,
+    T1_BLEND_FORCE_BOLD,
 
     /*# never remove */
-    t1_blend_max
+    T1_BLEND_MAX
 
   } T1_Blend_Flags;
 
 
+  /*# backwards compatible definitions */
+#define t1_blend_underline_position   T1_BLEND_UNDERLINE_POSITION
+#define t1_blend_underline_thickness  T1_BLEND_UNDERLINE_THICKNESS
+#define t1_blend_italic_angle         T1_BLEND_ITALIC_ANGLE
+#define t1_blend_blue_values          T1_BLEND_BLUE_VALUES
+#define t1_blend_other_blues          T1_BLEND_OTHER_BLUES
+#define t1_blend_standard_widths      T1_BLEND_STANDARD_WIDTH
+#define t1_blend_standard_height      T1_BLEND_STANDARD_HEIGHT
+#define t1_blend_stem_snap_widths     T1_BLEND_STEM_SNAP_WIDTHS
+#define t1_blend_stem_snap_heights    T1_BLEND_STEM_SNAP_HEIGHTS
+#define t1_blend_blue_scale           T1_BLEND_BLUE_SCALE
+#define t1_blend_blue_shift           T1_BLEND_BLUE_SHIFT
+#define t1_blend_family_blues         T1_BLEND_FAMILY_BLUES
+#define t1_blend_family_other_blues   T1_BLEND_FAMILY_OTHER_BLUES
+#define t1_blend_force_bold           T1_BLEND_FORCE_BOLD
+#define t1_blend_max                  T1_BLEND_MAX
+
+
   /* maximum number of Multiple Masters designs, as defined in the spec */
 #define T1_MAX_MM_DESIGNS     16
 
@@ -171,88 +215,170 @@
 
 
   /* this structure is used to store the BlendDesignMap entry for an axis */
-  typedef struct  T1_DesignMap_
+  typedef struct  PS_DesignMap_
   {
     FT_Byte    num_points;
     FT_Fixed*  design_points;
     FT_Fixed*  blend_points;
+
+  } PS_DesignMapRec, *PS_DesignMap;
 
-  } T1_DesignMap;
+  /* backwards-compatible definition */
+  typedef PS_DesignMapRec  T1_DesignMap;
 
 
-  typedef struct  T1_Blend_
+  typedef struct  PS_BlendRec_
   {
-    FT_UInt       num_designs;
-    FT_UInt       num_axis;
+    FT_UInt          num_designs;
+    FT_UInt          num_axis;
 
-    FT_String*    axis_names[T1_MAX_MM_AXIS];
-    FT_Fixed*     design_pos[T1_MAX_MM_DESIGNS];
-    T1_DesignMap  design_map[T1_MAX_MM_AXIS];
+    FT_String*       axis_names[T1_MAX_MM_AXIS];
+    FT_Fixed*        design_pos[T1_MAX_MM_DESIGNS];
+    PS_DesignMapRec  design_map[T1_MAX_MM_AXIS];
 
-    FT_Fixed*     weight_vector;
-    FT_Fixed*     default_weight_vector;
+    FT_Fixed*        weight_vector;
+    FT_Fixed*        default_weight_vector;
 
-    T1_FontInfo*  font_infos[T1_MAX_MM_DESIGNS + 1];
-    T1_Private*   privates  [T1_MAX_MM_DESIGNS + 1];
+    PS_FontInfo      font_infos[T1_MAX_MM_DESIGNS + 1];
+    PS_Private       privates  [T1_MAX_MM_DESIGNS + 1];
 
-    FT_ULong      blend_bitflags;
+    FT_ULong         blend_bitflags;
 
-  } T1_Blend;
+  } PS_BlendRec, *PS_Blend;
 
 
-  typedef struct  CID_FontDict_
+  /* backwards-compatible definition */
+  typedef PS_BlendRec  T1_Blend;
+
+
+  typedef struct  CID_FaceDictRec_
   {
-    T1_Private  private_dict;
+    PS_PrivateRec  private_dict;
+
+    FT_UInt        len_buildchar;
+    FT_Fixed       forcebold_threshold;
+    FT_Pos         stroke_width;
+    FT_Fixed       expansion_factor;
 
-    FT_UInt     len_buildchar;
-    FT_Fixed    forcebold_threshold;
-    FT_Pos      stroke_width;
-    FT_Fixed    expansion_factor;
+    FT_Byte        paint_type;
+    FT_Byte        font_type;
+    FT_Matrix      font_matrix;
+    FT_Vector      font_offset;
 
-    FT_Byte     paint_type;
-    FT_Byte     font_type;
-    FT_Matrix   font_matrix;
-    FT_Vector   font_offset;
+    FT_UInt        num_subrs;
+    FT_ULong       subrmap_offset;
+    FT_Int         sd_bytes;
 
-    FT_UInt     num_subrs;
-    FT_ULong    subrmap_offset;
-    FT_Int      sd_bytes;
+  } CID_FaceDictRec, *CID_FaceDict;
 
-  } CID_FontDict;
 
+  /* backwards-compatible definition */
+  typedef CID_FaceDictRec  CID_FontDict;
 
-  typedef struct  CID_Info_
+
+  typedef struct  CID_FaceInfoRec_
   {
-    FT_String*     cid_font_name;
-    FT_Fixed       cid_version;
-    FT_Int         cid_font_type;
+    FT_String*      cid_font_name;
+    FT_Fixed        cid_version;
+    FT_Int          cid_font_type;
 
-    FT_String*     registry;
-    FT_String*     ordering;
-    FT_Int         supplement;
+    FT_String*      registry;
+    FT_String*      ordering;
+    FT_Int          supplement;
 
-    T1_FontInfo    font_info;
-    FT_BBox        font_bbox;
-    FT_ULong       uid_base;
+    PS_FontInfoRec  font_info;
+    FT_BBox         font_bbox;
+    FT_ULong        uid_base;
 
-    FT_Int         num_xuid;
-    FT_ULong       xuid[16];
+    FT_Int          num_xuid;
+    FT_ULong        xuid[16];
 
+    FT_ULong        cidmap_offset;
+    FT_Int          fd_bytes;
+    FT_Int          gd_bytes;
+    FT_ULong        cid_count;
 
-    FT_ULong       cidmap_offset;
-    FT_Int         fd_bytes;
-    FT_Int         gd_bytes;
-    FT_ULong       cid_count;
+    FT_Int          num_dicts;
+    CID_FaceDict    font_dicts;
 
-    FT_Int         num_dicts;
-    CID_FontDict*  font_dicts;
+    FT_ULong        data_offset;
 
-    FT_ULong       data_offset;
+  } CID_FaceInfoRec, *CID_FaceInfo;
 
-  } CID_Info;
 
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_Info                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This type is equivalent to @CID_FaceInfoRec. It is deprecated but   */
+  /*   kept to maintain source compatibility between various versions of   */
+  /*   FreeType.                                                           */
+  /*                                                                       */
+  typedef CID_FaceInfoRec  CID_Info;
 
   /* */
+
+
+ /************************************************************************
+  *
+  * @function:
+  *    FT_Has_PS_Glyph_Names
+  *
+  * @description:
+  *    Return true if a given face provides reliable Postscript glyph
+  *    names.  This is similar to using the @FT_HAS_GLYPH_NAMES macro,
+  *    except that certain fonts (mostly TrueType) contain incorrect
+  *    glyph name tables.
+  *
+  *    When this function returns true, the caller is sure that the glyph
+  *    names returned by @FT_Get_Glyph_Name are reliable.
+  *
+  * @input:
+  *    face ::
+  *       face handle
+  *
+  * @return:
+  *    Boolean.  True if glyph names are reliable.
+  */
+  FT_EXPORT( FT_Int )
+  FT_Has_PS_Glyph_Names( FT_Face  face );
+
+
+ /************************************************************************
+  *
+  * @function:
+  *    FT_Get_PS_Font_Info
+  *
+  * @description:
+  *    Retrieve the @PS_FontInfoRec structure corresponding to a given
+  *    Postscript font.
+  *
+  * @input:
+  *    face ::
+  *       Postscript face handle.
+  *
+  * @output:
+  *    afont_info ::
+  *       Output font info structure pointer.
+  *
+  * @return:
+  *    FreeType error code.  0 means success.
+  *
+  * @note:
+  *    The string pointers within the font info structure are owned by
+  *    the face and don't need to be freed by the caller.
+  *
+  *    If the font's format is not Postscript-based, this function will
+  *    return the @FT_Err_Invalid_Argument error code.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PS_Font_Info( FT_Face          face,
+                       PS_FontInfoRec  *afont_info );
+
+ /* */
+
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/cache/ftccache.h
diff -u xc/extras/freetype2/include/freetype/cache/ftccache.h:1.1.1.1 xc/extras/freetype2/include/freetype/cache/ftccache.h:1.1.1.2
--- xc/extras/freetype2/include/freetype/cache/ftccache.h:1.1.1.1	Mon Jan 14 11:52:05 2002
+++ xc/extras/freetype2/include/freetype/cache/ftccache.h	Thu Jun 20 04:16:08 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType internal cache interface (specification).                   */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -20,6 +20,13 @@
 #define __FTCCACHE_H__
 
 
+/* define to allow cache lookup inlining */
+#define  FTC_CACHE_USE_INLINE
+
+/* define to use linear hash table */
+#define  FTC_CACHE_USE_LINEAR_HASHING
+
+
 FT_BEGIN_HEADER
 
   /* handle to cache object */
@@ -174,8 +181,14 @@
     FT_UInt              cache_index;  /* in manager's table         */
     FT_Pointer           cache_data;   /* used by cache node methods */
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+    FT_UFast             p;
+    FT_UFast             mask;
+    FT_Long              slack;
+#else
     FT_UFast             nodes;
     FT_UFast             size;
+#endif
     FTC_Node*            buckets;
 
     FT_LruList_ClassRec  family_class;
@@ -289,7 +302,6 @@
                     FTC_Node  *anode );
 
  /* */
-
 
 FT_END_HEADER
 
Index: xc/extras/freetype2/include/freetype/cache/ftcglyph.h
diff -u xc/extras/freetype2/include/freetype/cache/ftcglyph.h:1.1.1.4 xc/extras/freetype2/include/freetype/cache/ftcglyph.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/cache/ftcglyph.h:1.1.1.4	Mon Jan 14 11:52:06 2002
+++ xc/extras/freetype2/include/freetype/cache/ftcglyph.h	Thu Jun 20 04:16:08 2002
@@ -24,14 +24,6 @@
   /*            For example, see `ftcimage.h' and `ftcimage.c' which       */
   /*            implement a FT_Glyph cache based on this code.             */
   /*                                                                       */
-  /*  NOTE: For now, each glyph set is implemented as a static hash table. */
-  /*        It would be interesting to experiment with dynamic hashes to   */
-  /*        see whether this improves performance or not (I don't know why */
-  /*        but something tells me it won't).                              */
-  /*                                                                       */
-  /*        In all cases, this change should not affect any derived glyph  */
-  /*        cache class.                                                   */
-  /*                                                                       */
   /*************************************************************************/
 
 
Index: xc/extras/freetype2/include/freetype/cache/ftcmanag.h
diff -u xc/extras/freetype2/include/freetype/cache/ftcmanag.h:1.1.1.5 xc/extras/freetype2/include/freetype/cache/ftcmanag.h:1.1.1.6
--- xc/extras/freetype2/include/freetype/cache/ftcmanag.h:1.1.1.5	Mon Jan 14 11:52:06 2002
+++ xc/extras/freetype2/include/freetype/cache/ftcmanag.h	Thu Jun 20 04:16:09 2002
@@ -118,7 +118,7 @@
 
   FT_EXPORT( void )
   ftc_family_table_free( FTC_FamilyTable  table,
-                         FT_UInt          index );
+                         FT_UInt          idx );
 
 
   /*************************************************************************/
Index: xc/extras/freetype2/include/freetype/cache/ftcsbits.h
diff -u xc/extras/freetype2/include/freetype/cache/ftcsbits.h:1.1.1.4 xc/extras/freetype2/include/freetype/cache/ftcsbits.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/cache/ftcsbits.h:1.1.1.4	Mon Jan 14 11:52:06 2002
+++ xc/extras/freetype2/include/freetype/cache/ftcsbits.h	Thu Jun 20 04:16:09 2002
@@ -57,28 +57,30 @@
   /*    A very compact structure used to describe a small glyph bitmap.    */
   /*                                                                       */
   /* <Fields>                                                              */
-  /*    width    :: The bitmap width in pixels.                            */
+  /*    width     :: The bitmap width in pixels.                           */
   /*                                                                       */
-  /*    height   :: The bitmap height in pixels.                           */
+  /*    height    :: The bitmap height in pixels.                          */
   /*                                                                       */
-  /*    left     :: The horizontal distance from the pen position to the   */
-  /*                left bitmap border (a.k.a. `left side bearing', or     */
-  /*                `lsb').                                                */
+  /*    left      :: The horizontal distance from the pen position to the  */
+  /*                 left bitmap border (a.k.a. `left side bearing', or    */
+  /*                 `lsb').                                               */
   /*                                                                       */
-  /*    top      :: The vertical distance from the pen position (on the    */
-  /*                baseline) to the upper bitmap border (a.k.a. `top side */
-  /*                bearing').  The distance is positive for upwards       */
-  /*                Y coordinates.                                         */
+  /*    top       :: The vertical distance from the pen position (on the   */
+  /*                 baseline) to the upper bitmap border (a.k.a. `top     */
+  /*                 side bearing').  The distance is positive for upwards */
+  /*                 Y coordinates.                                        */
   /*                                                                       */
-  /*    format   :: The format of the glyph bitmap (monochrome or gray).   */
+  /*    format    :: The format of the glyph bitmap (monochrome or gray).  */
   /*                                                                       */
-  /*    pitch    :: The number of bytes per bitmap line.  May be positive  */
-  /*                or negative.                                           */
+  /*    num_grays :: The number of gray levels.                            */
   /*                                                                       */
-  /*    xadvance :: The horizontal advance width in pixels.                */
+  /*    pitch     :: The number of bytes per bitmap line.  May be positive */
+  /*                 or negative.                                          */
   /*                                                                       */
-  /*    yadvance :: The vertical advance height in pixels.                 */
+  /*    xadvance  :: The horizontal advance width in pixels.               */
   /*                                                                       */
+  /*    yadvance  :: The vertical advance height in pixels.                */
+  /*                                                                       */
   /*    buffer   :: A pointer to the bitmap pixels.                        */
   /*                                                                       */
   typedef struct  FTC_SBitRec_
@@ -89,6 +91,7 @@
     FT_Char   top;
 
     FT_Byte   format;
+    FT_Short  num_grays;    /* XXX: Should be FT_Byte.  See ftcsbits.c */
     FT_Char   pitch;
     FT_Char   xadvance;
     FT_Char   yadvance;
Index: xc/extras/freetype2/include/freetype/config/ftconfig.h
diff -u xc/extras/freetype2/include/freetype/config/ftconfig.h:1.1.1.4 xc/extras/freetype2/include/freetype/config/ftconfig.h:1.4
--- xc/extras/freetype2/include/freetype/config/ftconfig.h:1.1.1.4	Sun Dec 16 12:49:23 2001
+++ xc/extras/freetype2/include/freetype/config/ftconfig.h	Tue Jan  7 13:41:00 2003
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    ANSI-specific configuration file (specification only).               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -41,8 +41,8 @@
 
 #include <ft2build.h>
 #include FT_CONFIG_OPTIONS_H
+#include FT_CONFIG_STANDARD_LIBRARY_H
 
-
 FT_BEGIN_HEADER
 
 
@@ -58,24 +58,21 @@
   /*************************************************************************/
 
 
-  /* We use <limits.h> values to know the sizes of the types.  */
-#include <limits.h>
-
   /* The number of bytes in an `int' type.  */
-#if   UINT_MAX == 0xFFFFFFFFUL
+#if   FT_UINT_MAX == 0xFFFFFFFFUL
 #define FT_SIZEOF_INT  4
-#elif UINT_MAX == 0xFFFFU
+#elif FT_UINT_MAX == 0xFFFFU
 #define FT_SIZEOF_INT  2
-#elif UINT_MAX > 0xFFFFFFFFU && UINT_MAX == 0xFFFFFFFFFFFFFFFFU
+#elif FT_UINT_MAX > 0xFFFFFFFFU && FT_UINT_MAX == 0xFFFFFFFFFFFFFFFFU
 #define FT_SIZEOF_INT  8
 #else
 #error "Unsupported number of bytes in `int' type!"
 #endif
 
   /* The number of bytes in a `long' type.  */
-#if   ULONG_MAX == 0xFFFFFFFFUL
+#if   FT_ULONG_MAX == 0xFFFFFFFFUL
 #define FT_SIZEOF_LONG  4
-#elif ULONG_MAX > 0xFFFFFFFFU && ULONG_MAX == 0xFFFFFFFFFFFFFFFFU
+#elif FT_ULONG_MAX > 0xFFFFFFFFU && FT_ULONG_MAX == 0xFFFFFFFFFFFFFFFFU
 #define FT_SIZEOF_LONG  8
 #else
 #error "Unsupported number of bytes in `long' type!"
@@ -86,8 +83,8 @@
 #define FT_ALIGNMENT  8
 
 
-  /* UNUSED is a macro used to indicate that a given parameter is not used */
-  /* -- this is only used to get rid of unpleasant compiler warnings       */
+  /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
+  /* used -- this is only used to get rid of unpleasant compiler warnings */
 #ifndef FT_UNUSED
 #define FT_UNUSED( arg )  ( (arg) = (arg) )
 #endif
@@ -106,6 +103,19 @@
 
   /*************************************************************************/
   /*                                                                       */
+  /* Mac support                                                           */
+  /*                                                                       */
+  /*   This is the only necessary change, so it is defined here instead    */
+  /*   providing a new configuration file.                                 */
+  /*                                                                       */
+#if ( defined( __APPLE__ ) && !defined ( DARWIN_NO_CARBON ) ) || \
+    ( defined( __MWERKS__ ) && defined( macintosh ) )
+#define FT_MACINTOSH 1
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
   /* IntN types                                                            */
   /*                                                                       */
   /*   Used to guarantee the size of some specific integers.               */
@@ -130,18 +140,17 @@
   /* now, lookup for an integer type that is at least 32 bits */
 #if FT_SIZEOF_INT >= 4
 
-  typedef int           FT_Fast;
-  typedef unsigned int  FT_UFast;
+  typedef int            FT_Fast;
+  typedef unsigned int   FT_UFast;
 
 #elif FT_SIZEOF_LONG >= 4
 
-  typedef long          FT_Fast;
-  typedef unsigned long FT_UFast;
+  typedef long           FT_Fast;
+  typedef unsigned long  FT_UFast;
 
 #endif
 
 
-
   /* determine whether we have a 64-bit int type for platforms without */
   /* Autoconf                                                          */
 #if FT_SIZEOF_LONG == 8
@@ -150,7 +159,7 @@
 #define FT_LONG64
 #define FT_INT64  long
 
-#elif defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
+#elif defined( _MSC_VER ) && _MSC_VER >= 900  /* Visual C++ (and Intel C++) */
 
   /* this compiler provides the __int64 type */
 #define FT_LONG64
@@ -180,7 +189,7 @@
 #define FT_LONG64
 #define FT_INT64  long long int
 
-#endif /* !FT_LONG64 */
+#endif /* FT_SIZEOF_LONG == 8 */
 
 
   /*************************************************************************/
@@ -205,17 +214,17 @@
 
 #ifdef FT_MAKE_OPTION_SINGLE_OBJECT
 
-#define FT_LOCAL      static
-#define FT_LOCAL_DEF  static
+#define FT_LOCAL( x )      static  x
+#define FT_LOCAL_DEF( x )  static  x
 
 #else
 
 #ifdef __cplusplus
-#define FT_LOCAL      extern "C"
-#define FT_LOCAL_DEF  extern "C"
+#define FT_LOCAL( x )      extern "C"  x
+#define FT_LOCAL_DEF( x )  extern "C"  x
 #else
-#define FT_LOCAL      extern
-#define FT_LOCAL_DEF  extern
+#define FT_LOCAL( x )      extern  x
+#define FT_LOCAL_DEF( x )  x
 #endif
 
 #endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
@@ -300,9 +309,9 @@
   /*                                                                 */
 #ifndef FT_CALLBACK_DEF
 #ifdef __cplusplus
-#define FT_CALLBACK_DEF( x )  extern "C" x
+#define FT_CALLBACK_DEF( x )  extern "C"  x
 #else
-#define FT_CALLBACK_DEF( x )  static x
+#define FT_CALLBACK_DEF( x )  static  x
 #endif
 #endif /* FT_CALLBACK_DEF */
 
Index: xc/extras/freetype2/include/freetype/config/ftheader.h
diff -u xc/extras/freetype2/include/freetype/config/ftheader.h:1.1.1.4 xc/extras/freetype2/include/freetype/config/ftheader.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/config/ftheader.h:1.1.1.4	Mon Jan 14 11:52:06 2002
+++ xc/extras/freetype2/include/freetype/config/ftheader.h	Thu Jun 20 04:16:09 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Build macros of the FreeType 2 library.                              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -111,6 +111,20 @@
   /*************************************************************************/
   /*                                                                       */
   /* @macro:                                                               */
+  /*    FT_CONFIG_STANDARD_LIBRARY_H                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    FreeType 2 configuration data.                                     */
+  /*                                                                       */
+#ifndef FT_CONFIG_STANDARD_LIBRARY_H
+#define FT_CONFIG_STANDARD_LIBRARY_H  <freetype/config/ftstdlib.h>
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
   /*    FT_CONFIG_OPTIONS_H                                                */
   /*                                                                       */
   /* @description:                                                         */
@@ -338,38 +352,38 @@
   /*************************************************************************/
   /*                                                                       */
   /* @macro:                                                               */
-  /*    FT_GLYPH_H                                                         */
+  /*    FT_BDF_H                                                           */
   /*                                                                       */
   /* @description:                                                         */
   /*    A macro used in #include statements to name the file containing    */
-  /*    the API of the optional glyph management component.                */
+  /*    the definitions of an API to access BDF-specific strings from a    */
+  /*    face.                                                              */
   /*                                                                       */
-#define FT_GLYPH_H  <freetype/ftglyph.h>
+#define FT_BDF_H  <freetype/ftbdf.h>
 
 
   /*************************************************************************/
   /*                                                                       */
   /* @macro:                                                               */
-  /*    FT_BBOX_H                                                          */
+  /*    FT_GLYPH_H                                                         */
   /*                                                                       */
   /* @description:                                                         */
   /*    A macro used in #include statements to name the file containing    */
-  /*    the API of the optional exact bounding box computation routines.   */
+  /*    the API of the optional glyph management component.                */
   /*                                                                       */
-#define FT_BBOX_H  <freetype/ftbbox.h>
+#define FT_GLYPH_H  <freetype/ftglyph.h>
 
 
   /*************************************************************************/
   /*                                                                       */
   /* @macro:                                                               */
-  /*    FT_BEZIER_H                                                        */
+  /*    FT_BBOX_H                                                          */
   /*                                                                       */
   /* @description:                                                         */
   /*    A macro used in #include statements to name the file containing    */
-  /*    a small useful API to handle bezier arcs.  Note that you _must_    */
-  /*    include FT_FREETYPE_H or FT_IMAGE_H before this header.            */
+  /*    the API of the optional exact bounding box computation routines.   */
   /*                                                                       */
-#define FT_BEZIER_H  <freetype/ftbezier.h>
+#define FT_BBOX_H  <freetype/ftbbox.h>
 
 
   /*************************************************************************/
@@ -474,12 +488,15 @@
 
 #define FT_TRIGONOMETRY_H          <freetype/fttrigon.h>
 #define FT_SYNTHESIS_H             <freetype/ftsynth.h>
+#define FT_ERROR_DEFINITIONS_H     <freetype/fterrdef.h>
 
 #define FT_CACHE_MANAGER_H         <freetype/cache/ftcmanag.h>
 
 #define FT_CACHE_INTERNAL_LRU_H    <freetype/cache/ftlru.h>
 #define FT_CACHE_INTERNAL_GLYPH_H  <freetype/cache/ftcglyph.h>
 #define FT_CACHE_INTERNAL_CACHE_H  <freetype/cache/ftccache.h>
+
+#define FT_XFREE86_H               <freetype/ftxf86.h>
 
   /* now include internal headers definitions from <freetype/internal/...> */
 
Index: xc/extras/freetype2/include/freetype/config/ftmodule.h
diff -u xc/extras/freetype2/include/freetype/config/ftmodule.h:1.1.1.3 xc/extras/freetype2/include/freetype/config/ftmodule.h:1.1.1.4
--- xc/extras/freetype2/include/freetype/config/ftmodule.h:1.1.1.3	Mon Jan 14 11:52:06 2002
+++ xc/extras/freetype2/include/freetype/config/ftmodule.h	Thu Jun 20 04:16:09 2002
@@ -2,6 +2,7 @@
 FT_USE_MODULE(cff_driver_class)
 FT_USE_MODULE(t1cid_driver_class)
 FT_USE_MODULE(pcf_driver_class)
+FT_USE_MODULE(bdf_driver_class)
 FT_USE_MODULE(psaux_module_class)
 FT_USE_MODULE(psnames_module_class)
 FT_USE_MODULE(pshinter_module_class)
@@ -10,5 +11,6 @@
 FT_USE_MODULE(ft_smooth_renderer_class)
 FT_USE_MODULE(tt_driver_class)
 FT_USE_MODULE(t1_driver_class)
+FT_USE_MODULE(t42_driver_class)
+FT_USE_MODULE(pfr_driver_class)
 FT_USE_MODULE(winfnt_driver_class)
-
Index: xc/extras/freetype2/include/freetype/config/ftoption.h
diff -u xc/extras/freetype2/include/freetype/config/ftoption.h:1.4 xc/extras/freetype2/include/freetype/config/ftoption.h:1.5
--- xc/extras/freetype2/include/freetype/config/ftoption.h:1.4	Mon Jan 14 12:00:59 2002
+++ xc/extras/freetype2/include/freetype/config/ftoption.h	Thu Jun 20 04:25:26 2002
@@ -1,11 +1,11 @@
-/* $XFree86: xc/extras/freetype2/include/freetype/config/ftoption.h,v 1.4 2002/01/14 17:00:59 keithp Exp $ */
+/* $XFree86: xc/extras/freetype2/include/freetype/config/ftoption.h,v 1.5 2002/06/20 08:25:26 keithp Exp $ */
 /***************************************************************************/
 /*                                                                         */
 /*  ftoption.h                                                             */
 /*                                                                         */
 /*    User-selectable configuration macros (specification only).           */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -79,6 +79,15 @@
 
   /*************************************************************************/
   /*                                                                       */
+  /* CMap support                                                          */
+  /*                                                                       */
+  /*   Define this if you want generic cmap support.                       */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_USE_CMAPS
+
+
+  /*************************************************************************/
+  /*                                                                       */
   /* Convenience functions support                                         */
   /*                                                                       */
   /*   Some functions of the FreeType 2 API are provided as a convenience  */
@@ -235,7 +244,6 @@
 #undef FT_EXPORT
 #undef FT_EXPORT_DEF
 
-
   /*************************************************************************/
   /*                                                                       */
   /* Debug level                                                           */
@@ -271,22 +279,12 @@
 
   /*************************************************************************/
   /*                                                                       */
-  /* Computation Algorithms                                                */
-  /*                                                                       */
-  /*   Used for debugging, this configuration macro should disappear       */
-  /*   soon.                                                               */
-  /*                                                                       */
-#undef FT_CONFIG_OPTION_OLD_CALCS
-
-
-  /*************************************************************************/
-  /*                                                                       */
   /* The size in bytes of the render pool used by the scan-line converter  */
   /* to do all of its work.                                                */
   /*                                                                       */
   /* This must be greater than 4kByte.                                     */
   /*                                                                       */
-#define FT_RENDER_POOL_SIZE  32768L
+#define FT_RENDER_POOL_SIZE  16384L
 
 
   /*************************************************************************/
@@ -300,20 +298,7 @@
 
 
   /*************************************************************************/
-  /*                                                                       */
-  /* FT_MAX_EXTENSIONS                                                     */
-  /*                                                                       */
-  /*   The maximum number of extensions that can be registered in a single */
-  /*   font driver.  8 is the default.                                     */
-  /*                                                                       */
-  /*   If you don't know what this means, you certainly do not need to     */
-  /*   change this value.                                                  */
-  /*                                                                       */
-#define FT_MAX_EXTENSIONS  8
-
-
   /*************************************************************************/
-  /*************************************************************************/
   /****                                                                 ****/
   /****        S F N T   D R I V E R    C O N F I G U R A T I O N       ****/
   /****                                                                 ****/
@@ -357,6 +342,21 @@
   /* `freetype/ftnames.h'.                                                 */
   /*                                                                       */
 #define TT_CONFIG_OPTION_SFNT_NAMES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TrueType CMap support                                                 */
+  /*                                                                       */
+  /*   Here you can fine-tune which TrueType CMap table format shall be    */
+  /*   supported.                                                          */
+#define TT_CONFIG_CMAP_FORMAT_0
+#define TT_CONFIG_CMAP_FORMAT_2
+#define TT_CONFIG_CMAP_FORMAT_4
+#define TT_CONFIG_CMAP_FORMAT_6
+#define TT_CONFIG_CMAP_FORMAT_8
+#define TT_CONFIG_CMAP_FORMAT_10
+#define TT_CONFIG_CMAP_FORMAT_12
 
 
   /*************************************************************************/
Index: xc/extras/freetype2/include/freetype/config/ftstdlib.h
diff -u /dev/null xc/extras/freetype2/include/freetype/config/ftstdlib.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/config/ftstdlib.h	Thu Jun 20 04:16:09 2002
@@ -0,0 +1,140 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstdlib.h                                                             */
+/*                                                                         */
+/*    ANSI-specific library and header configuration file (specification   */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to group all #includes to the ANSI C library that   */
+  /* FreeType normally requires.  It also defines macros to rename the     */
+  /* standard functions within the FreeType source code.                   */
+  /*                                                                       */
+  /* Load a file which defines __FTSTDLIB_H__ before this one to override  */
+  /* it.                                                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTSTDLIB_H__
+#define __FTSTDLIB_H__
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                           integer limits                           */
+  /*                                                                    */
+  /* UINT_MAX and ULONG_MAX are used to automatically compute the size  */
+  /* of `int' and `long' in bytes at compile-time.  So far, this works  */
+  /* for all platforms the library has been tested on.                  */
+  /*                                                                    */
+  /* Note that on the extremely rare platforms that do not provide      */
+  /* integer types that are _exactly_ 16 and 32 bits wide (e.g. some    */
+  /* old Crays where `int' is 36 bits), we do not make any guarantee    */
+  /* about the correct behaviour of FT2 with all fonts.                 */
+  /*                                                                    */
+  /* In these case, "ftconfig.h" will refuse to compile anyway with a   */
+  /* message like "couldn't find 32-bit type" or something similar.     */
+  /*                                                                    */
+  /* IMPORTANT NOTE: We do not define aliases for heap management and   */
+  /*                 i/o routines (i.e. malloc/free/fopen/fread/...)    */
+  /*                 since these functions should all be encapsulated   */
+  /*                 by platform-specific implementations of            */
+  /*                 "ftsystem.c".                                      */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <limits.h>
+
+#define FT_UINT_MAX   UINT_MAX
+#define FT_ULONG_MAX  ULONG_MAX
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                 character and string processing                    */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <ctype.h>
+
+#define ft_isalnum  isalnum
+#define ft_isupper  isupper
+#define ft_islower  islower
+#define ft_xdigit   isxdigit
+
+
+#include <string.h>
+
+#define ft_strlen   strlen
+#define ft_strcmp   strcmp
+#define ft_strncmp  strncmp
+#define ft_memcpy   memcpy
+#define ft_strcpy   strcpy
+#define ft_strncpy  strncpy
+#define ft_memset   memset
+#define ft_memmove  memmove
+#define ft_memcmp   memcmp
+
+#include <stdio.h>
+
+#define ft_sprintf  sprintf
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                             sorting                                */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <stdlib.h>
+
+#define ft_qsort  qsort
+#define ft_exit   exit    /* only used to exit from unhandled exceptions */
+
+#define ft_atoi   atoi
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                         execution control                          */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <setjmp.h>
+
+#define ft_jmp_buf  jmp_buf   /* note: this cannot be a typedef since */
+                              /*       jmp_buf is defined as a macro  */
+                              /*       on certain platforms           */
+
+#define ft_setjmp   setjmp    /* same thing here */
+#define ft_longjmp  longjmp   /* "               */
+
+
+  /* the following is only used for debugging purposes, i.e. when */
+  /* FT_DEBUG_LEVEL_ERROR or FT_DEBUG_LEVEL_TRACE are defined     */
+  /*                                                              */
+#include <stdarg.h>
+
+
+#endif /* __FTSTDLIB_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/include/freetype/internal/autohint.h
diff -u xc/extras/freetype2/include/freetype/internal/autohint.h:1.1.1.3 xc/extras/freetype2/include/freetype/internal/autohint.h:1.1.1.4
--- xc/extras/freetype2/include/freetype/internal/autohint.h:1.1.1.3	Sun Dec 16 12:49:23 2001
+++ xc/extras/freetype2/include/freetype/internal/autohint.h	Thu Jun 20 04:16:09 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    High-level `autohint' module-specific interface (specification).     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -83,13 +83,13 @@
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    FT_AutoHinter_Get_Global_Func                                      */
+  /*    FT_AutoHinter_GlobalGetFunc                                        */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Retrieves the global hints computed for a given face object the    */
   /*    resulting data is dissociated from the face and will survive a     */
-  /*    call to FT_Done_Face(). It must be discarded through the API       */
-  /*    FT_AutoHinter_Done_Global_Func().                                  */
+  /*    call to FT_Done_Face().  It must be discarded through the API      */
+  /*    FT_AutoHinter_GlobalDoneFunc().                                    */
   /*                                                                       */
   /* <Input>                                                               */
   /*    hinter        :: A handle to the source auto-hinter.               */
@@ -102,20 +102,20 @@
   /*    global_len    :: The size in bytes of the global hints.            */
   /*                                                                       */
   typedef void
-  (*FT_AutoHinter_Get_Global_Func)( FT_AutoHinter  hinter,
-                                    FT_Face        face,
-                                    void**         global_hints,
-                                    long*          global_len );
+  (*FT_AutoHinter_GlobalGetFunc)( FT_AutoHinter  hinter,
+                                  FT_Face        face,
+                                  void**         global_hints,
+                                  long*          global_len );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    FT_AutoHinter_Done_Global_Func                                     */
+  /*    FT_AutoHinter_GlobalDoneFunc                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Discards the global hints retrieved through                        */
-  /*    FT_AutoHinter_Get_Global_Func().  This is the only way these hints */
+  /*    FT_AutoHinter_GlobalGetFunc().  This is the only way these hints   */
   /*    are freed from memory.                                             */
   /*                                                                       */
   /* <Input>                                                               */
@@ -124,14 +124,14 @@
   /*    global :: A pointer to retrieved global hints to discard.          */
   /*                                                                       */
   typedef void
-  (*FT_AutoHinter_Done_Global_Func)( FT_AutoHinter  hinter,
-                                     void*          global );
+  (*FT_AutoHinter_GlobalDoneFunc)( FT_AutoHinter  hinter,
+                                   void*          global );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    FT_AutoHinter_Reset_Func                                           */
+  /*    FT_AutoHinter_GlobalResetFunc                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This function is used to recompute the global metrics in a given   */
@@ -144,14 +144,14 @@
   /*    face   :: A handle to the face.                                    */
   /*                                                                       */
   typedef void
-  (*FT_AutoHinter_Reset_Func)( FT_AutoHinter  hinter,
-                               FT_Face        face );
+  (*FT_AutoHinter_GlobalResetFunc)( FT_AutoHinter  hinter,
+                                    FT_Face        face );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    FT_AutoHinter_Load_Func                                            */
+  /*    FT_AutoHinter_GlyphLoadFunc                                        */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This function is used to load, scale, and automatically hint a     */
@@ -159,7 +159,9 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face        :: A handle to the face.                               */
+  /*                                                                       */
   /*    glyph_index :: The glyph index.                                    */
+  /*                                                                       */
   /*    load_flags  :: The load flags.                                     */
   /*                                                                       */
   /* <Note>                                                                */
@@ -170,30 +172,29 @@
   /*    FT_LOAD_NO_SCALE set.                                              */
   /*                                                                       */
   typedef FT_Error
-  (*FT_AutoHinter_Load_Func)( FT_AutoHinter  hinter,
-                              FT_GlyphSlot   slot,
-                              FT_Size        size,
-                              FT_UInt        glyph_index,
-                              FT_ULong       load_flags );
+  (*FT_AutoHinter_GlyphLoadFunc)( FT_AutoHinter  hinter,
+                                  FT_GlyphSlot   slot,
+                                  FT_Size        size,
+                                  FT_UInt        glyph_index,
+                                  FT_ULong       load_flags );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    FT_AutoHinter_Interface                                            */
+  /*    FT_AutoHinter_ServiceRec                                           */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The auto-hinter module's interface.                                */
   /*                                                                       */
-  typedef struct  FT_AutoHinter_Interface
+  typedef struct  FT_AutoHinter_ServiceRec_
   {
-    FT_AutoHinter_Reset_Func        reset_face;
-    FT_AutoHinter_Load_Func         load_glyph;
-
-    FT_AutoHinter_Get_Global_Func   get_global_hints;
-    FT_AutoHinter_Done_Global_Func  done_global_hints;
+    FT_AutoHinter_GlobalResetFunc  reset_face;
+    FT_AutoHinter_GlobalGetFunc    get_global_hints;
+    FT_AutoHinter_GlobalDoneFunc   done_global_hints;
+    FT_AutoHinter_GlyphLoadFunc    load_glyph;
 
-  } FT_AutoHinter_Interface;
+  } FT_AutoHinter_ServiceRec, *FT_AutoHinter_Service;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/bdftypes.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/bdftypes.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/internal/bdftypes.h	Thu Jun 20 04:16:09 2002
@@ -0,0 +1,53 @@
+/*  bdftypes.h
+
+  FreeType font driver for bdf fonts
+
+  Copyright (C) 2001, 2002 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef __BDFTYPES_H__
+#define __BDFTYPES_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  BDF_Public_FaceRec_
+  {
+    FT_FaceRec  root;
+
+    char*       charset_encoding;
+    char*       charset_registry;
+
+  } BDF_Public_FaceRec, *BDF_Public_Face;
+
+
+FT_END_HEADER
+
+
+#endif  /* __BDFTYPES_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/include/freetype/internal/cfftypes.h
diff -u xc/extras/freetype2/include/freetype/internal/cfftypes.h:1.1.1.3 xc/extras/freetype2/include/freetype/internal/cfftypes.h:1.1.1.4
--- xc/extras/freetype2/include/freetype/internal/cfftypes.h:1.1.1.3	Mon Jan 14 11:52:06 2002
+++ xc/extras/freetype2/include/freetype/internal/cfftypes.h	Thu Jun 20 04:16:09 2002
@@ -5,7 +5,7 @@
 /*    Basic OpenType/CFF type definitions and interface (specification     */
 /*    only).                                                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -31,7 +31,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    CFF_Index                                                          */
+  /*    CFF_IndexRec                                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used to model a CFF Index table.                       */
@@ -50,7 +50,7 @@
   /*                                                                       */
   /*    bytes       :: If the index is loaded in memory, its bytes.        */
   /*                                                                       */
-  typedef struct  CFF_Index_
+  typedef struct  CFF_IndexRec_
   {
     FT_Stream  stream;
     FT_UInt    count;
@@ -60,10 +60,10 @@
     FT_ULong*  offsets;
     FT_Byte*   bytes;
 
-  } CFF_Index;
+  } CFF_IndexRec, *CFF_Index;
 
 
-  typedef struct  CFF_Encoding_
+  typedef struct  CFF_EncodingRec_
   {
     FT_UInt     format;
     FT_ULong    offset;
@@ -71,10 +71,10 @@
     FT_UShort*  sids;
     FT_UShort*  codes;
 
-  } CFF_Encoding;
+  } CFF_EncodingRec, *CFF_Encoding;
 
 
-  typedef struct  CFF_Charset_
+  typedef struct  CFF_CharsetRec_
   {
 
     FT_UInt     format;
@@ -82,10 +82,10 @@
 
     FT_UShort*  sids;
 
-  } CFF_Charset;
+  } CFF_CharsetRec, *CFF_Charset;
 
 
-  typedef struct  CFF_Font_Dict_
+  typedef struct  CFF_FontRecDictRec_
   {
     FT_UInt    version;
     FT_UInt    notice;
@@ -129,10 +129,10 @@
     FT_ULong   cid_fd_select_offset;
     FT_UInt    cid_font_name;
 
-  } CFF_Font_Dict;
+  } CFF_FontRecDictRec, *CFF_FontRecDict;
 
 
-  typedef struct  CFF_Private_
+  typedef struct  CFF_PrivateRec_
   {
     FT_Byte   num_blue_values;
     FT_Byte   num_other_blues;
@@ -164,10 +164,10 @@
     FT_Pos    default_width;
     FT_Pos    nominal_width;
 
-  } CFF_Private;
+  } CFF_PrivateRec, *CFF_Private;
 
 
-  typedef struct  CFF_FD_Select_
+  typedef struct  CFF_FDSelectRec_
   {
     FT_Byte   format;
     FT_UInt   range_count;
@@ -181,67 +181,67 @@
     FT_UInt   cache_count;
     FT_Byte   cache_fd;
 
-  } CFF_FD_Select;
+  } CFF_FDSelectRec, *CFF_FDSelect;
 
 
-  /* A SubFont packs a font dict and a private dict together. They are */
-  /* needed to support CID-keyed CFF fonts.                            */
-  typedef struct  CFF_SubFont_
+  /* A SubFont packs a font dict and a private dict together.  They are */
+  /* needed to support CID-keyed CFF fonts.                             */
+  typedef struct  CFF_SubFontRec_
   {
-    CFF_Font_Dict  font_dict;
-    CFF_Private    private_dict;
+    CFF_FontRecDictRec  font_dict;
+    CFF_PrivateRec      private_dict;
 
-    CFF_Index      local_subrs_index;
-    FT_UInt        num_local_subrs;
-    FT_Byte**      local_subrs;
+    CFF_IndexRec        local_subrs_index;
+    FT_UInt             num_local_subrs;
+    FT_Byte**           local_subrs;
 
-  } CFF_SubFont;
+  } CFF_SubFontRec, *CFF_SubFont;
 
 
   /* maximum number of sub-fonts in a CID-keyed file */
 #define CFF_MAX_CID_FONTS  16
 
 
-  typedef struct  CFF_Font_
+  typedef struct  CFF_FontRec_
   {
-    FT_Stream      stream;
-    FT_Memory      memory;
-    FT_UInt        num_faces;
-    FT_UInt        num_glyphs;
+    FT_Stream        stream;
+    FT_Memory        memory;
+    FT_UInt          num_faces;
+    FT_UInt          num_glyphs;
 
-    FT_Byte        version_major;
-    FT_Byte        version_minor;
-    FT_Byte        header_size;
-    FT_Byte        absolute_offsize;
+    FT_Byte          version_major;
+    FT_Byte          version_minor;
+    FT_Byte          header_size;
+    FT_Byte          absolute_offsize;
 
 
-    CFF_Index      name_index;
-    CFF_Index      top_dict_index;
-    CFF_Index      string_index;
-    CFF_Index      global_subrs_index;
+    CFF_IndexRec     name_index;
+    CFF_IndexRec     top_dict_index;
+    CFF_IndexRec     string_index;
+    CFF_IndexRec     global_subrs_index;
 
-    CFF_Encoding   encoding;
-    CFF_Charset    charset;
+    CFF_EncodingRec  encoding;
+    CFF_CharsetRec   charset;
 
-    CFF_Index      charstrings_index;
-    CFF_Index      font_dict_index;
-    CFF_Index      private_index;
-    CFF_Index      local_subrs_index;
+    CFF_IndexRec     charstrings_index;
+    CFF_IndexRec     font_dict_index;
+    CFF_IndexRec     private_index;
+    CFF_IndexRec     local_subrs_index;
 
-    FT_String*     font_name;
-    FT_UInt        num_global_subrs;
-    FT_Byte**      global_subrs;
+    FT_String*       font_name;
+    FT_UInt          num_global_subrs;
+    FT_Byte**        global_subrs;
 
-    CFF_SubFont    top_font;
-    FT_UInt        num_subfonts;
-    CFF_SubFont*   subfonts[CFF_MAX_CID_FONTS];
+    CFF_SubFontRec   top_font;
+    FT_UInt          num_subfonts;
+    CFF_SubFont      subfonts[CFF_MAX_CID_FONTS];
 
-    CFF_FD_Select  fd_select;
+    CFF_FDSelectRec  fd_select;
 
     /* interface to PostScript hinter */
-    void*          pshinter;
+    void*            pshinter;
 
-  } CFF_Font;
+  } CFF_FontRec, *CFF_Font;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/fnttypes.h
diff -u xc/extras/freetype2/include/freetype/internal/fnttypes.h:1.1.1.3 xc/extras/freetype2/include/freetype/internal/fnttypes.h:1.1.1.4
--- xc/extras/freetype2/include/freetype/internal/fnttypes.h:1.1.1.3	Sun Dec 16 12:49:23 2001
+++ xc/extras/freetype2/include/freetype/internal/fnttypes.h	Thu Jun 20 04:16:09 2002
@@ -5,7 +5,7 @@
 /*    Basic Windows FNT/FON type definitions and interface (specification  */
 /*    only).                                                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -28,26 +28,26 @@
 FT_BEGIN_HEADER
 
 
-  typedef struct  WinMZ_Header_
+  typedef struct  WinMZ_HeaderRec_
   {
     FT_UShort  magic;
     /* skipped content */
     FT_UShort  lfanew;
 
-  } WinMZ_Header;
+  } WinMZ_HeaderRec;
 
 
-  typedef struct  WinNE_Header_
+  typedef struct  WinNE_HeaderRec_
   {
     FT_UShort  magic;
     /* skipped content */
     FT_UShort  resource_tab_offset;
     FT_UShort  rname_tab_offset;
 
-  } WinNE_Header;
+  } WinNE_HeaderRec;
 
 
-  typedef struct  WinNameInfo_
+  typedef struct  WinNameInfoRec_
   {
     FT_UShort  offset;
     FT_UShort  length;
@@ -56,22 +56,22 @@
     FT_UShort  handle;
     FT_UShort  usage;
 
-  } WinNameInfo;
+  } WinNameInfoRec;
 
 
-  typedef struct  WinResourceInfo_
+  typedef struct  WinResourceInfoRec_
   {
     FT_UShort  type_id;
     FT_UShort  count;
 
-  } WinResourceInfo;
+  } WinResourceInfoRec;
 
 
 #define WINFNT_MZ_MAGIC  0x5A4D
 #define WINFNT_NE_MAGIC  0x454E
 
 
-  typedef struct  WinFNT_Header_
+  typedef struct  WinFNT_HeaderRec_
   {
     FT_UShort  version;
     FT_ULong   file_size;
@@ -110,26 +110,26 @@
     FT_UShort  color_table_offset;
     FT_Byte    reserved2[4];
 
-  } WinFNT_Header;
+  } WinFNT_HeaderRec, *WinFNT_Header;
 
 
-  typedef struct  FNT_Font_
+  typedef struct  FNT_FontRec_
   {
-    FT_ULong       offset;
-    FT_Int         size_shift;
+    FT_ULong          offset;
+    FT_Int            size_shift;
 
-    WinFNT_Header  header;
+    WinFNT_HeaderRec  header;
 
-    FT_Byte*       fnt_frame;
-    FT_ULong       fnt_size;
+    FT_Byte*          fnt_frame;
+    FT_ULong          fnt_size;
 
-  } FNT_Font;
+  } FNT_FontRec, *FNT_Font;
 
 
   typedef struct  FNT_SizeRec_
   {
     FT_SizeRec  root;
-    FNT_Font*   font;
+    FNT_Font    font;
 
   } FNT_SizeRec, *FNT_Size;
 
@@ -139,7 +139,7 @@
     FT_FaceRec     root;
 
     FT_UInt        num_fonts;
-    FNT_Font*      fonts;
+    FNT_Font       fonts;
 
     FT_CharMap     charmap_handle;
     FT_CharMapRec  charmap;  /* a single charmap per face */
Index: xc/extras/freetype2/include/freetype/internal/ftcalc.h
diff -u xc/extras/freetype2/include/freetype/internal/ftcalc.h:1.1.1.4 xc/extras/freetype2/include/freetype/internal/ftcalc.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/internal/ftcalc.h:1.1.1.4	Sun Dec 16 12:49:23 2001
+++ xc/extras/freetype2/include/freetype/internal/ftcalc.h	Thu Jun 20 04:16:09 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Arithmetic computations (specification).                             */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,163 +27,9 @@
 FT_BEGIN_HEADER
 
 
-/* OLD 64-bits internal API */
-
-#ifdef FT_CONFIG_OPTION_OLD_CALCS
-
-#ifdef FT_LONG64
-
-  typedef FT_INT64  FT_Int64;
-
-#define ADD_64( x, y, z )  z = (x) + (y)
-#define MUL_64( x, y, z )  z = (FT_Int64)(x) * (y)
-#define DIV_64( x, y )     ( (x) / (y) )
-
-#define SQRT_64( z )  FT_Sqrt64( z )
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_Sqrt64                                                          */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Computes the square root of a 64-bit value.  That sounds stupid,   */
-  /*    but it is needed to obtain maximal accuracy in the TrueType        */
-  /*    bytecode interpreter.                                              */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    l :: A 64-bit integer.                                             */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The 32-bit square-root.                                            */
-  /*                                                                       */
-  FT_EXPORT( FT_Int32 )
-  FT_Sqrt64( FT_Int64  l );
-
-
-#else /* !FT_LONG64 */
-
-
-  typedef struct  FT_Int64_
-  {
-    FT_UInt32  lo;
-    FT_UInt32  hi;
-
-  } FT_Int64;
-
-
-#define ADD_64( x, y, z )  FT_Add64( &x, &y, &z )
-#define MUL_64( x, y, z )  FT_MulTo64( x, y, &z )
-#define DIV_64( x, y )     FT_Div64by32( &x, y )
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_Add64                                                           */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Add two Int64 values.                                              */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    x :: A pointer to the first value to be added.                     */
-  /*    y :: A pointer to the second value to be added.                    */
-  /*                                                                       */
-  /* <Output>                                                              */
-  /*    z :: A pointer to the result of `x + y'.                           */
-  /*                                                                       */
-  /* <Note>                                                                */
-  /*    Will be wrapped by the ADD_64() macro.                             */
-  /*                                                                       */
-  FT_EXPORT( void )
-  FT_Add64( FT_Int64*  x,
-            FT_Int64*  y,
-            FT_Int64  *z );
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_MulTo64                                                         */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Multiplies two Int32 integers.  Returns an Int64 integer.          */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    x :: The first multiplier.                                         */
-  /*    y :: The second multiplier.                                        */
-  /*                                                                       */
-  /* <Output>                                                              */
-  /*    z :: A pointer to the result of `x * y'.                           */
-  /*                                                                       */
-  /* <Note>                                                                */
-  /*    Will be wrapped by the MUL_64() macro.                             */
-  /*                                                                       */
-  FT_EXPORT( void )
-  FT_MulTo64( FT_Int32   x,
-              FT_Int32   y,
-              FT_Int64  *z );
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_Div64by32                                                       */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Divides an Int64 value by an Int32 value.  Returns an Int32        */
-  /*    integer.                                                           */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    x :: A pointer to the dividend.                                    */
-  /*    y :: The divisor.                                                  */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The result of `x / y'.                                             */
-  /*                                                                       */
-  /* <Note>                                                                */
-  /*    Will be wrapped by the DIV_64() macro.                             */
-  /*                                                                       */
-  FT_EXPORT( FT_Int32 )
-  FT_Div64by32( FT_Int64*  x,
-                FT_Int32   y );
-
-
-#define SQRT_64( z )  FT_Sqrt64( &z )
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_Sqrt64                                                          */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Computes the square root of a 64-bits value.  That sounds stupid,  */
-  /*    but it is needed to obtain maximal accuracy in the TrueType        */
-  /*    bytecode interpreter.                                              */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    z :: A pointer to a 64-bit integer.                                */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The 32-bit square-root.                                            */
-  /*                                                                       */
-  FT_EXPORT( FT_Int32 )
-  FT_Sqrt64( FT_Int64*  x );
-
-
-#endif /* !FT_LONG64 */
-
-#endif /* FT_CONFIG_OPTION_OLD_CALCS */
-
-
-
   FT_EXPORT( FT_Int32 )  FT_SqrtFixed( FT_Int32  x );
 
 
-#ifndef FT_CONFIG_OPTION_OLD_CALCS
-
 #define SQRT_32( x )  FT_Sqrt32( x )
 
 
@@ -204,9 +50,6 @@
   /*                                                                       */
   FT_EXPORT( FT_Int32 )
   FT_Sqrt32( FT_Int32  x );
-
-
-#endif /* !FT_CONFIG_OPTION_OLD_CALCS */
 
 
   /*************************************************************************/
Index: xc/extras/freetype2/include/freetype/internal/ftcore.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/ftcore.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/internal/ftcore.h	Thu Jun 20 04:16:09 2002
@@ -0,0 +1,185 @@
+#ifndef __FT_CORE_H__
+#define __FT_CORE_H__
+
+#include <ft2build.h>
+#include FT_TYPES_H
+#include FT_SYSTEM_MEMORY_H
+
+FT_BEGIN_HEADER
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                  C L E A N U P   S T A C K                     *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+
+ /************************************************************************
+  *
+  * @functype: FT_CleanupFunc
+  *
+  * @description:
+  *   a function used to cleanup a given item on the cleanup stack
+  *
+  * @input:
+  *   item      :: target item pointer
+  *   item_data :: optional argument to cleanup routine
+  */
+  typedef void  (*FT_CleanupFunc)( FT_Pointer  item,
+                                   FT_Pointer  item_data );
+
+
+
+ /************************************************************************
+  *
+  * @type: FT_XHandler
+  *
+  * @description:
+  *   handle to an exception-handler structure for the FreeType
+  *   exception sub-system
+  *
+  * @note:
+  *   exception handlers are allocated on the stack within a
+  *   @FT_XTRY macro. Do not try to access them directly.
+  */
+  typedef struct FT_XHandlerRec_*  FT_XHandler;
+
+
+/* the size of a cleanup chunk in bytes is FT_CLEANUP_CHUNK_SIZE*12 + 4 */
+/* this must be a small power of 2 whenever possible..                  */
+/*                                                                      */
+/* with a value of 5, we have a byte size of 64 bytes per chunk..       */
+/*                                                                      */
+#define  FT_CLEANUP_CHUNK_SIZE   5
+
+
+
+  typedef struct FT_CleanupItemRec_
+  {
+    FT_Pointer      item;
+    FT_CleanupFunc  item_func;
+    FT_Pointer      item_data;
+
+  } FT_CleanupItemRec;
+
+
+  typedef struct FT_CleanupChunkRec_*   FT_CleanupChunk;
+
+  typedef struct FT_CleanupChunkRec_
+  {
+    FT_CleanupChunk    link;
+    FT_CleanupItemRec  items[ FT_CLEANUP_CHUNK_SIZE ];
+
+  } FT_CleanupChunkRec;
+
+
+  typedef struct FT_CleanupStackRec_
+  {
+    FT_CleanupItem     top;
+    FT_CleanupItem     limit;
+    FT_CleanupChunk    chunk;
+    FT_CleanupChunkRec chunk_0;  /* avoids stupid dynamic allocation */
+    FT_Memory          memory;
+
+  } FT_CleanupStackRec, *FT_CleanupStack;
+
+
+  FT_BASE( void )
+  ft_cleanup_stack_push( FT_CleanupStack  stack,
+                         FT_Pointer       item,
+                         FT_CleanupFunc   item_func,
+                         FT_Pointer       item_data );
+
+  FT_BASE( void )
+  ft_cleanup_stack_pop( FT_CleanupStack   stack,
+                        FT_Int            destroy );
+
+  FT_BASE( FT_CleanupItem )
+  ft_cleanup_stack_peek( FT_CleanupStack  stack );
+
+  FT_BASE( void )
+  ft_cleanup_throw( FT_CleanupStack  stack,
+                    FT_Error         error );
+
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                 M E M O R Y   M A N A G E R                    *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+  typedef struct FT_MemoryRec_
+  {
+    FT_Memory_AllocFunc     mem_alloc;   /* shortcut to funcs->mem_alloc */
+    FT_Memory_FreeFunc      mem_free;    /* shortcut to funcs->mem_free  */
+    FT_Pointer              mem_data;
+    const FT_Memory_Funcs   mem_funcs;
+
+    FT_CleanupStackRec      cleanup_stack;
+    FT_Pointer              meta_class;
+
+  } FT_MemoryRec;
+
+
+#define  FT_MEMORY(x)  ((FT_Memory)(x))
+#define  FT_MEMORY__ALLOC(x)       FT_MEMORY(x)->mem_alloc
+#define  FT_MEMORY__FREE(x)        FT_MEMORY(x)->mem_free
+#define  FT_MEMORY__REALLOC(x)     FT_MEMORY(x)->mem_funcs->mem_realloc
+#define  FT_MEMORY__CLEANUP(x)     (&FT_MEMORY(x)->cleanup_stack)
+#define  FT_MEMORY__META_CLASS(x)  ((FT_MetaClass)(FT_MEMORY(x)->meta_class))
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****             E X C E P T I O N   H A N D L I N G                *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+
+ /************************************************************************
+  *
+  * @struct: FT_XHandlerRec
+  *
+  * @description:
+  *   exception handler structure
+  *
+  * @fields:
+  *   previous   :: previous handler in chain.
+  *   jum_buffer :: processor state used by setjmp/longjmp to implement
+  *                 exception control transfer
+  *   error      :: exception error code
+  *   mark       :: top of cleanup stack when @FT_XTRY is used
+  */
+  typedef struct FT_XHandlerRec_
+  {
+    FT_XHandler        previous;
+    ft_jmp_buf         jump_buffer;
+    volatile FT_Error  error;
+    FT_Pointer         mark;
+
+  } FT_XHandlerRec;
+
+  FT_BASE( void )
+  ft_xhandler_enter( FT_XHandler  xhandler,
+                     FT_Memory    memory );
+
+  FT_BASE( void )
+  ft_xhandler_exit( FT_XHandler  xhandler );
+
+
+
+
+
+
+
+
+FT_END_HEADER
+
+#endif /* __FT_CORE_H__ */
Index: xc/extras/freetype2/include/freetype/internal/ftdebug.h
diff -u xc/extras/freetype2/include/freetype/internal/ftdebug.h:1.5 xc/extras/freetype2/include/freetype/internal/ftdebug.h:1.7
--- xc/extras/freetype2/include/freetype/internal/ftdebug.h:1.5	Mon Jan 14 12:00:59 2002
+++ xc/extras/freetype2/include/freetype/internal/ftdebug.h	Thu Jun 20 04:25:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Debugging and logging component (specification).                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -14,8 +14,8 @@
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
-/* $XFree86: xc/extras/freetype2/include/freetype/internal/ftdebug.h,v 1.5 2002/01/14 17:00:59 keithp Exp $ */
 
+
 #ifndef __FTDEBUG_H__
 #define __FTDEBUG_H__
 
@@ -27,99 +27,47 @@
 FT_BEGIN_HEADER
 
 
+  /* force the definition of FT_DEBUG_LEVEL_ERROR if FT_DEBUG_LEVEL_TRACE */
+  /* is already defined; this simplifies the following #ifdefs            */
+  /*                                                                      */
 #ifdef FT_DEBUG_LEVEL_TRACE
+#undef  FT_DEBUG_LEVEL_ERROR
+#define FT_DEBUG_LEVEL_ERROR
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define the trace enums as well as the trace levels array when they    */
+  /* are needed.                                                           */
+  /*                                                                       */
+  /*************************************************************************/
 
+#ifdef FT_DEBUG_LEVEL_TRACE
 
-  /* note that not all levels are used currently */
+#define FT_TRACE_DEF( x )  trace_ ## x ,
 
-  typedef enum  FT_Trace_
+  /* defining the enumeration */ 
+  typedef enum
   {
-    /* the first level must always be `trace_any' */
-    trace_any = 0,
+#include FT_INTERNAL_TRACE_H  
+    trace_count
 
-    /* base components */
-    trace_aaraster,  /* anti-aliasing raster    (ftgrays.c)  */
-    trace_calc,      /* calculations            (ftcalc.c)   */
-    trace_extend,    /* extension manager       (ftextend.c) */
-    trace_glyph,     /* glyph manager           (ftglyph.c)  */
-    trace_io,        /* i/o monitoring          (ftsystem.c) */
-    trace_init,      /* initialization          (ftinit.c)   */
-    trace_list,      /* list manager            (ftlist.c)   */
-    trace_memory,    /* memory manager          (ftobjs.c)   */
-    trace_mm,        /* MM interface            (ftmm.c)     */
-    trace_objs,      /* base objects            (ftobjs.c)   */
-    trace_outline,   /* outline management      (ftoutln.c)  */
-    trace_raster,    /* rasterizer              (ftraster.c) */
-    trace_stream,    /* stream manager          (ftstream.c) */
-
-    /* Cache sub-system */
-    trace_cache,
-
-    /* SFNT driver components */
-    trace_sfobjs,    /* SFNT object handler     (sfobjs.c)   */
-    trace_ttcmap,    /* charmap handler         (ttcmap.c)   */
-    trace_ttload,    /* basic TrueType tables   (ttload.c)   */
-    trace_ttpost,    /* PS table processing     (ttpost.c)   */
-    trace_ttsbit,    /* TrueType sbit handling  (ttsbit.c)   */
-
-    /* TrueType driver components */
-    trace_ttdriver,  /* TT font driver          (ttdriver.c) */
-    trace_ttgload,   /* TT glyph loader         (ttgload.c)  */
-    trace_ttinterp,  /* bytecode interpreter    (ttinterp.c) */
-    trace_ttobjs,    /* TT objects manager      (ttobjs.c)   */
-    trace_ttpload,   /* TT data/program loader  (ttpload.c)  */
-
-    /* Type 1 driver components */
-    trace_t1driver,
-    trace_t1gload,
-    trace_t1hint,
-    trace_t1load,
-    trace_t1objs,
-    trace_t1parse,
-
-    /* PostScript helper module `psaux' */
-    trace_t1decode,
-    trace_psobjs,
-
-    /* PostScript hinting module `pshinter' */
-    trace_pshrec,
-    trace_pshalgo1,
-    trace_pshalgo2,
-
-    /* Type 2 driver components */
-    trace_cffdriver,
-    trace_cffgload,
-    trace_cffload,
-    trace_cffobjs,
-    trace_cffparse,
-
-    /* CID driver components */
-    trace_cidafm,
-    trace_ciddriver,
-    trace_cidgload,
-    trace_cidload,
-    trace_cidobjs,
-    trace_cidparse,
-
-    /* Windows fonts component */
-    trace_winfnt,
-
-    /* PCF fonts component */
-    trace_pcfdriver,
-    trace_pcfread,
+  } FT_Trace;
 
-    /* the last level must always be `trace_max' */
-    trace_max
 
-  } FT_Trace;
+  /* defining the array of trace levels, provided by `src/base/ftdebug.c' */
+  extern int  ft_trace_levels[trace_count];
 
+#undef FT_TRACE_DEF
 
-  /* declared in ftdebug.c */
-  extern char  ft_trace_levels[trace_max];
+#endif /* FT_DEBUG_LEVEL_TRACE */
 
 
   /*************************************************************************/
   /*                                                                       */
+  /* Define the FT_TRACE macro                                             */
+  /*                                                                       */
   /* IMPORTANT!                                                            */
   /*                                                                       */
   /* Each component must define the macro FT_COMPONENT to a valid FT_Trace */
@@ -127,6 +75,7 @@
   /*                                                                       */
   /*************************************************************************/
 
+#ifdef FT_DEBUG_LEVEL_TRACE
 
 #define FT_TRACE( level, varformat )                      \
           do                                              \
@@ -135,62 +84,57 @@
               FT_Message varformat;                       \
           } while ( 0 )
 
+#else /* !FT_DEBUG_LEVEL_TRACE */
+
+#define FT_TRACE( level, varformat )  do ; while ( 0 )      /* nothing */
+
+#endif /* !FT_DEBUG_LEVEL_TRACE */
 
+
   /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_SetTraceLevel                                                   */
   /*                                                                       */
-  /* <Description>                                                         */
-  /*    Sets the trace level for debugging.                                */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    component :: The component which should be traced.  See above for  */
-  /*                 a complete list.  If set to `trace_any', all          */
-  /*                 components will be traced.                            */
+  /* You need two opening resp. closing parentheses!                       */
   /*                                                                       */
-  /*    level     :: The tracing level.                                    */
+  /* Example: FT_TRACE0(( "Value is %i", foo ))                            */
   /*                                                                       */
-  FT_EXPORT( void )
-  FT_SetTraceLevel( FT_Trace  component,
-                    char      level );
-
-
-#elif defined( FT_DEBUG_LEVEL_ERROR )
-
+  /*************************************************************************/
 
-#define FT_TRACE( level, varformat )  do ; while ( 0 )      /* nothing */
+#define FT_TRACE0( varformat )  FT_TRACE( 0, varformat )
+#define FT_TRACE1( varformat )  FT_TRACE( 1, varformat )
+#define FT_TRACE2( varformat )  FT_TRACE( 2, varformat )
+#define FT_TRACE3( varformat )  FT_TRACE( 3, varformat )
+#define FT_TRACE4( varformat )  FT_TRACE( 4, varformat )
+#define FT_TRACE5( varformat )  FT_TRACE( 5, varformat )
+#define FT_TRACE6( varformat )  FT_TRACE( 6, varformat )
+#define FT_TRACE7( varformat )  FT_TRACE( 7, varformat )
 
 
-#else  /* release mode */
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Define the FT_ERROR macro                                            */
+  /*                                                                       */
+  /*************************************************************************/
 
+#ifdef FT_DEBUG_LEVEL_ERROR
 
-#define FT_Assert( condition )        do ; while ( 0 )      /* nothing */
+#define FT_ERROR( varformat )  FT_Message  varformat
 
-#define FT_TRACE( level, varformat )  do ; while ( 0 )      /* nothing */
-#define FT_ERROR( varformat )         do ; while ( 0 )      /* nothing */
+#else  /* !FT_DEBUG_LEVEL_ERROR */
 
+#define FT_ERROR( varformat )  do ; while ( 0 )      /* nothing */
 
-#endif /* FT_DEBUG_LEVEL_TRACE, FT_DEBUG_LEVEL_ERROR */
+#endif /* !FT_DEBUG_LEVEL_ERROR */
 
 
   /*************************************************************************/
-  /*                                                                       */
-  /* Define macros and functions that are common to the debug and trace    */
-  /* modes.                                                                */
   /*                                                                       */
-  /* You need vprintf() to be able to compile ftdebug.c.                   */
+  /* Define the FT_ASSERT macro                                            */
   /*                                                                       */
   /*************************************************************************/
-
-
-#if defined( FT_DEBUG_LEVEL_TRACE ) || defined( FT_DEBUG_LEVEL_ERROR )
 
+#ifdef FT_DEBUG_LEVEL_ERROR
 
-#include <stdio.h>  /* for vprintf() */
-
-
-#define FT_Assert( condition )                                      \
+#define FT_ASSERT( condition )                                      \
           do                                                        \
           {                                                         \
             if ( !( condition ) )                                   \
@@ -198,6 +142,23 @@
                         __LINE__, __FILE__ );                       \
           } while ( 0 )
 
+#else /* !FT_DEBUG_LEVEL_ERROR */
+
+#define FT_ASSERT( condition )  do ; while ( 0 )
+
+#endif /* !FT_DEBUG_LEVEL_ERROR */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Define 'FT_Message' and 'FT_Panic' when needed                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifdef FT_DEBUG_LEVEL_ERROR
+
+#include "stdio.h"  /* for vprintf() */
+
   /* print a message */
   FT_EXPORT( void )
   FT_Message( const char*  fmt, ... );
@@ -206,28 +167,11 @@
   FT_EXPORT( void )
   FT_Panic( const char*  fmt, ... );
 
-#define FT_ERROR( varformat )  FT_Message varformat
+#endif /* FT_DEBUG_LEVEL_ERROR */
 
 
-#endif /* FT_DEBUG_LEVEL_TRACE || FT_DEBUG_LEVEL_ERROR */
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* You need two opening resp. closing parentheses!                       */
-  /*                                                                       */
-  /* Example: FT_TRACE0(( "Value is %i", foo ))                            */
-  /*                                                                       */
-  /*************************************************************************/
-
-#define FT_TRACE0( varformat )  FT_TRACE( 0, varformat )
-#define FT_TRACE1( varformat )  FT_TRACE( 1, varformat )
-#define FT_TRACE2( varformat )  FT_TRACE( 2, varformat )
-#define FT_TRACE3( varformat )  FT_TRACE( 3, varformat )
-#define FT_TRACE4( varformat )  FT_TRACE( 4, varformat )
-#define FT_TRACE5( varformat )  FT_TRACE( 5, varformat )
-#define FT_TRACE6( varformat )  FT_TRACE( 6, varformat )
-#define FT_TRACE7( varformat )  FT_TRACE( 7, varformat )
+  FT_BASE( void )
+  ft_debug_init( void );
 
 
 #if defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
Index: xc/extras/freetype2/include/freetype/internal/ftdriver.h
diff -u xc/extras/freetype2/include/freetype/internal/ftdriver.h:1.1.1.3 xc/extras/freetype2/include/freetype/internal/ftdriver.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/internal/ftdriver.h:1.1.1.3	Sun Dec 16 12:49:23 2001
+++ xc/extras/freetype2/include/freetype/internal/ftdriver.h	Thu Jun 20 04:16:09 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType font driver interface (specification).                      */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -28,77 +28,81 @@
 
 
   typedef FT_Error
-  (*FTDriver_initFace)( FT_Stream      stream,
-                        FT_Face        face,
-                        FT_Int         typeface_index,
-                        FT_Int         num_params,
-                        FT_Parameter*  parameters );
+  (*FT_Face_InitFunc)( FT_Stream      stream,
+                       FT_Face        face,
+                       FT_Int         typeface_index,
+                       FT_Int         num_params,
+                       FT_Parameter*  parameters );
 
   typedef void
-  (*FTDriver_doneFace)( FT_Face  face );
+  (*FT_Face_DoneFunc)( FT_Face  face );
 
 
   typedef FT_Error
-  (*FTDriver_initSize)( FT_Size  size );
+  (*FT_Size_InitFunc)( FT_Size  size );
 
   typedef void
-  (*FTDriver_doneSize)( FT_Size  size );
+  (*FT_Size_DoneFunc)( FT_Size  size );
 
 
   typedef FT_Error
-  (*FTDriver_initGlyphSlot)( FT_GlyphSlot  slot );
+  (*FT_Slot_InitFunc)( FT_GlyphSlot  slot );
 
   typedef void
-  (*FTDriver_doneGlyphSlot)( FT_GlyphSlot  slot );
+  (*FT_Slot_DoneFunc)( FT_GlyphSlot  slot );
 
 
   typedef FT_Error
-  (*FTDriver_setCharSizes)( FT_Size     size,
-                            FT_F26Dot6  char_width,
-                            FT_F26Dot6  char_height,
-                            FT_UInt     horz_resolution,
-                            FT_UInt     vert_resolution );
+  (*FT_Size_ResetPointsFunc)( FT_Size     size,
+                              FT_F26Dot6  char_width,
+                              FT_F26Dot6  char_height,
+                              FT_UInt     horz_resolution,
+                              FT_UInt     vert_resolution );
 
   typedef FT_Error
-  (*FTDriver_setPixelSizes)( FT_Size  size,
-                             FT_UInt  pixel_width,
-                             FT_UInt  pixel_height );
+  (*FT_Size_ResetPixelsFunc)( FT_Size  size,
+                              FT_UInt  pixel_width,
+                              FT_UInt  pixel_height );
 
   typedef FT_Error
-  (*FTDriver_loadGlyph)( FT_GlyphSlot  slot,
-                         FT_Size       size,
-                         FT_UInt       glyph_index,
-                         FT_Int        load_flags );
+  (*FT_Slot_LoadFunc)( FT_GlyphSlot  slot,
+                       FT_Size       size,
+                       FT_UInt       glyph_index,
+                       FT_Int        load_flags );
 
 
   typedef FT_UInt
-  (*FTDriver_getCharIndex)( FT_CharMap  charmap,
-                            FT_Long     charcode );
+  (*FT_CharMap_CharIndexFunc)( FT_CharMap  charmap,
+                               FT_Long     charcode );
 
+  typedef FT_Long
+  (*FT_CharMap_CharNextFunc)( FT_CharMap  charmap,
+                              FT_Long     charcode );
+
   typedef FT_Error
-  (*FTDriver_getKerning)( FT_Face      face,
-                          FT_UInt      left_glyph,
-                          FT_UInt      right_glyph,
-                          FT_Vector*   kerning );
+  (*FT_Face_GetKerningFunc)( FT_Face     face,
+                             FT_UInt     left_glyph,
+                             FT_UInt     right_glyph,
+                             FT_Vector*  kerning );
 
 
   typedef FT_Error
-  (*FTDriver_attachFile)( FT_Face    face,
-                          FT_Stream  stream );
+  (*FT_Face_AttachFunc)( FT_Face    face,
+                         FT_Stream  stream );
 
 
   typedef FT_Error
-  (*FTDriver_getAdvances)( FT_Face     face,
-                           FT_UInt     first,
-                           FT_UInt     count,
-                           FT_Bool     vertical,
-                           FT_UShort*  advances );
+  (*FT_Face_GetAdvancesFunc)( FT_Face     face,
+                              FT_UInt     first,
+                              FT_UInt     count,
+                              FT_Bool     vertical,
+                              FT_UShort*  advances );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    FT_Driver_Class                                                    */
+  /*    FT_Driver_ClassRec                                                 */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The font driver class.  This structure mostly contains pointers to */
@@ -161,35 +165,35 @@
   /*    Most function pointers, with the exception of `load_glyph' and     */
   /*    `get_char_index' can be set to 0 to indicate a default behaviour.  */
   /*                                                                       */
-  typedef struct  FT_Driver_Class_
+  typedef struct  FT_Driver_ClassRec_
   {
-    FT_Module_Class         root;
-
-    FT_Int                  face_object_size;
-    FT_Int                  size_object_size;
-    FT_Int                  slot_object_size;
+    FT_Module_Class           root;
 
-    FTDriver_initFace       init_face;
-    FTDriver_doneFace       done_face;
+    FT_Int                    face_object_size;
+    FT_Int                    size_object_size;
+    FT_Int                    slot_object_size;
 
-    FTDriver_initSize       init_size;
-    FTDriver_doneSize       done_size;
+    FT_Face_InitFunc          init_face;
+    FT_Face_DoneFunc          done_face;
 
-    FTDriver_initGlyphSlot  init_slot;
-    FTDriver_doneGlyphSlot  done_slot;
+    FT_Size_InitFunc          init_size;
+    FT_Size_DoneFunc          done_size;
 
-    FTDriver_setCharSizes   set_char_sizes;
-    FTDriver_setPixelSizes  set_pixel_sizes;
+    FT_Slot_InitFunc          init_slot;
+    FT_Slot_DoneFunc          done_slot;
 
-    FTDriver_loadGlyph      load_glyph;
-    FTDriver_getCharIndex   get_char_index;
+    FT_Size_ResetPointsFunc   set_char_sizes;
+    FT_Size_ResetPixelsFunc   set_pixel_sizes;
 
-    FTDriver_getKerning     get_kerning;
-    FTDriver_attachFile     attach_file;
+    FT_Slot_LoadFunc          load_glyph;
+    FT_CharMap_CharIndexFunc  get_char_index;
 
-    FTDriver_getAdvances    get_advances;
+    FT_Face_GetKerningFunc    get_kerning;
+    FT_Face_AttachFunc        attach_file;
+    FT_Face_GetAdvancesFunc   get_advances;
+    FT_CharMap_CharNextFunc   get_next_char;
 
-  } FT_Driver_Class;
+  } FT_Driver_ClassRec, *FT_Driver_Class;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/ftexcept.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/ftexcept.h:1.2
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/internal/ftexcept.h	Fri Oct 25 11:01:04 2002
@@ -0,0 +1,79 @@
+#ifndef __FT_EXCEPT_H__
+#define __FT_EXCEPT_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+
+FT_BEGIN_HEADER
+
+
+
+ /* I can't find a better place for this for now */
+
+
+/* the size of a cleanup chunk in bytes is FT_CLEANUP_CHUNK_SIZE*12 + 4 */
+/* this must be a small power of 2 whenever possible..                  */
+/*                                                                      */
+/* with a value of 5, we have a byte size of 64 bytes per chunk..       */
+/*                                                                      */
+#define  FT_CLEANUP_CHUNK_SIZE   5
+
+
+
+  typedef struct FT_CleanupItemRec_
+  {
+    FT_Pointer      item;
+    FT_CleanupFunc  item_func;
+    FT_Pointer      item_data;
+
+  } FT_CleanupItemRec;
+
+  typedef struct FT_CleanupChunkRec_*   FT_CleanupChunk;
+  
+  typedef struct FT_CleanupChunkRec_
+  {
+    FT_CleanupChunk    link;
+    FT_CleanupItemRec  items[ FT_CLEANUP_CHUNK_SIZE ];
+
+  } FT_CleanupChunkRec;
+
+
+  typedef struct FT_CleanupStackRec_
+  {
+    FT_CleanupItem     top;
+    FT_CleanupItem     limit;
+    FT_CleanupChunk    chunk;
+    FT_CleanupChunkRec chunk_0;  /* avoids stupid dynamic allocation */
+    FT_Memory          memory;
+
+  } FT_CleanupStackRec, *FT_CleanupStack;
+
+
+  FT_BASE( void )
+  ft_cleanup_stack_push( FT_CleanupStack  stack,
+                         FT_Pointer       item,
+                         FT_CleanupFunc   item_func,
+                         FT_Pointer       item_data );
+
+  FT_BASE( void )
+  ft_cleanup_stack_pop( FT_CleanupStack   stack,
+                        FT_Int            destroy );
+
+  FT_BASE( FT_CleanupItem )
+  ft_cleanup_stack_peek( FT_CleanupStack  stack );
+
+  FT_BASE( void )
+  ft_xhandler_enter( FT_XHandler  xhandler,
+                     FT_Memory    memory );                         
+
+  FT_BASE( void )
+  ft_xhandler_exit( FT_XHandler  xhandler );
+
+
+  FT_BASE( void )
+  ft_cleanup_throw( FT_CleanupStack  stack,
+                    FT_Error         error );
+
+FT_END_HEADER
+
+#endif /* __FT_EXCEPT_H__ */
Index: xc/extras/freetype2/include/freetype/internal/ftgloadr.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/ftgloadr.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/internal/ftgloadr.h	Thu Jun 20 04:16:09 2002
@@ -0,0 +1,153 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgloadr.h                                                             */
+/*                                                                         */
+/*    The FreeType glyph loader (specification).                           */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTGLOADR_H__
+#define __FTGLOADR_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_GlyphLoader                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The glyph loader is an internal object used to load several glyphs */
+  /*    together (for example, in the case of composites).                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The glyph loader implementation is not part of the high-level API, */
+  /*    hence the forward structure declaration.                           */
+  /*                                                                       */
+  typedef struct FT_GlyphLoaderRec_*  FT_GlyphLoader ;
+
+
+#define FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS          1
+#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES      2
+#define FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID        4
+#define FT_SUBGLYPH_FLAG_SCALE                   8
+#define FT_SUBGLYPH_FLAG_XY_SCALE             0x40
+#define FT_SUBGLYPH_FLAG_2X2                  0x80
+#define FT_SUBGLYPH_FLAG_USE_MY_METRICS      0x200
+
+
+  enum
+  {
+    FT_GLYPH_OWN_BITMAP = 1
+  };
+
+
+  typedef struct  FT_SubGlyphRec_
+  {
+    FT_Int     index;
+    FT_UShort  flags;
+    FT_Int     arg1;
+    FT_Int     arg2;
+    FT_Matrix  transform;
+    
+  } FT_SubGlyphRec;
+
+
+  typedef struct  FT_GlyphLoadRec_
+  {
+    FT_Outline   outline;       /* outline             */
+    FT_Vector*   extra_points;  /* extra points table  */
+    FT_UInt      num_subglyphs; /* number of subglyphs */
+    FT_SubGlyph  subglyphs;     /* subglyphs           */
+
+  } FT_GlyphLoadRec, *FT_GlyphLoad;
+
+
+  typedef struct  FT_GlyphLoaderRec_
+  {
+    FT_Memory        memory;
+    FT_UInt          max_points;
+    FT_UInt          max_contours;
+    FT_UInt          max_subglyphs;
+    FT_Bool          use_extra;
+
+    FT_GlyphLoadRec  base;
+    FT_GlyphLoadRec  current;
+
+    void*            other;            /* for possible future extension? */
+
+  } FT_GlyphLoaderRec;
+
+
+  /* create new empty glyph loader */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_New( FT_Memory        memory,
+                      FT_GlyphLoader  *aloader );
+
+  /* add an extra points table to a glyph loader */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CreateExtra( FT_GlyphLoader  loader );
+
+  /* destroy a glyph loader */
+  FT_BASE( void )
+  FT_GlyphLoader_Done( FT_GlyphLoader  loader );
+
+  /* reset a glyph loader (frees everything int it) */
+  FT_BASE( void )
+  FT_GlyphLoader_Reset( FT_GlyphLoader  loader );
+
+  /* rewind a glyph loader */
+  FT_BASE( void )
+  FT_GlyphLoader_Rewind( FT_GlyphLoader  loader );
+
+  /* check that there is enough room to add 'n_points' and 'n_contours' */
+  /* to the glyph loader                                                */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CheckPoints( FT_GlyphLoader  loader,
+                              FT_UInt         n_points,
+                              FT_UInt         n_contours );
+
+  /* check that there is enough room to add 'n_subs' sub-glyphs to */
+  /* a glyph loader                                                */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader  loader,
+                                 FT_UInt         n_subs );
+
+  /* prepare a glyph loader, i.e. empty the current glyph */
+  FT_BASE( void )
+  FT_GlyphLoader_Prepare( FT_GlyphLoader  loader );
+
+  /* add the current glyph to the base glyph */
+  FT_BASE( void )
+  FT_GlyphLoader_Add( FT_GlyphLoader  loader );
+
+  /* copy points from one glyph loader to another */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CopyPoints( FT_GlyphLoader  target,
+                             FT_GlyphLoader  source );
+
+ /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTGLOADR_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/include/freetype/internal/fthash.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/fthash.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/internal/fthash.h	Thu Jun 20 04:16:09 2002
@@ -0,0 +1,484 @@
+/******************************************************************
+ *
+ *  fthash.h  - fast dynamic hash tables
+ *
+ *  Copyright 2002 by
+ *  David Turner, Robert Wilhelm, and Werner Lemberg
+ *
+ *  This file is part of the FreeType project, and may only be used,
+ *  modified, and distributed under the terms of the FreeType project
+ *  license, LICENSE.TXT.  By continuing to use, modify, or distribute
+ *  this file you indicate that you have read the license and
+ *  understand and accept it fully.
+ *
+ *
+ *  This header is used to define dynamic hash tables as described
+ *  by the article "Main-Memory Linear Hashing - Some Enhancements
+ *  of Larson's Algorithm" by Mikael Petterson.
+ *
+ *  Basically, linear hashing prevents big "stalls" during
+ *  resizes of the buckets array by only splitting one bucket
+ *  at a time. This ensures excellent response time even when
+ *  the table is frequently resized..
+ *
+ *
+ *  Note that the use of the FT_Hash type is rather unusual in order
+ *  to be as generic and efficient as possible. See the comments in the
+ *  following definitions for more details.
+ */
+
+#ifndef __FT_HASH_H__
+#define __FT_HASH_H__
+
+#include <ft2build.h>
+#include FT_TYPES_H
+
+FT_BEGIN_HEADER
+
+ /***********************************************************
+  *
+  * @type: FT_Hash
+  *
+  * @description:
+  *   handle to a @FT_HashRec structure used to model a
+  *   dynamic hash table
+  */
+  typedef struct FT_HashRec_*      FT_Hash;
+
+
+ /***********************************************************
+  *
+  * @type: FT_HashNode
+  *
+  * @description:
+  *   handle to a @FT_HashNodeRec structure used to model a
+  *   single node of a hash table
+  */
+  typedef struct FT_HashNodeRec_*  FT_HashNode;
+
+
+ /***********************************************************
+  *
+  * @type: FT_Hash_CompareFunc
+  *
+  * @description:
+  *   a function used to compare two nodes of the hash table
+  *
+  * @input:
+  *   node1 :: handle to first node
+  *   node2 :: handle to second node
+  *
+  * @return:
+  *   1 iff the 'keys' in 'node1' and 'node2' are identical.
+  *   0 otherwise.
+  */
+  typedef FT_Int  (*FT_Hash_CompareFunc)( const FT_HashNode  node1,
+                                          const FT_HashNode  node2 );
+
+
+ /***********************************************************
+  *
+  * @struct: FT_HashRec
+  *
+  * @description:
+  *   a structure used to model a dynamic hash table.
+  *
+  * @fields:
+  *   memory       :: memory manager used to allocate
+  *                   the buckets array and the hash nodes
+  *
+  *   buckets      :: array of hash buckets
+  *
+  *   node_size    :: size of node in bytes
+  *   node_compare :: a function used to compare two nodes
+  *   node_hash    :: a function used to compute the hash
+  *                   value of a given node
+  *   p            ::
+  *   mask         ::
+  *   slack        ::
+  *
+  * @note:
+  *   'p', 'mask' and 'slack' are control values managed by
+  *   the hash table. Do not try to interpret them directly.
+  *
+  *   You can grab the hash table size by calling
+  *   '@ft_hash_get_size'.
+  */
+  typedef struct FT_HashRec_
+  {
+    FT_Memory            memory;
+    FT_HashNode*         buckets;
+    FT_UInt              p;
+    FT_UInt              mask;  /* really maxp-1 */
+    FT_UInt              slack;
+
+
+    FT_UInt              node_size;
+    FT_Hash_CompareFunc  node_compare;
+    FT_Hash_ComputeFunc  node_hash;
+
+  } FT_HashRec, *FT_Hash;
+
+
+ /***********************************************************
+  *
+  * @struct: FT_HashNodeRec
+  *
+  * @description:
+  *   a structure used to model the root fields of a dynamic
+  *   hash table node.
+  *
+  *   it's up to client applications to "sub-class" this
+  *   structure to add relevant (key,value) definitions
+  *
+  * @fields:
+  *   link :: pointer to next node in bucket's collision list
+  *   hash :: 32-bit hash value for this node
+  *
+  * @note:
+  *   it's up to client applications to "sub-class" this structure
+  *   to add relevant (key,value) type definitions. For example,
+  *   if we want to build a "string -> int" mapping, we could use
+  *   something like:
+  *
+  *   {
+  *     typedef struct MyNodeRec_
+  *     {
+  *       FT_HashNodeRec  hnode;
+  *       const char*     key;
+  *       int             value;
+  *
+  *     } MyNodeRec, *MyNode;
+  *   }
+  *
+  */
+  typedef struct FT_HashNodeRec_
+  {
+    FT_HashNode  link;
+    FT_UInt32    hash;
+
+  } FT_HashNodeRec;
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_init
+  *
+  * @description:
+  *   initialize a dynamic hash table
+  *
+  * @input:
+  *   table   :: handle to target hash table structure
+  *   compare :: node comparison function
+  *   memory  :: memory manager handle used to allocate the
+  *              buckets array within the hash table
+  *
+  * @note:
+  *   the node comparison function should only compare node _keys_
+  *   and ignore values !! with good hashing computation (which the
+  *   user must perform itself), the comparison function should be
+  *   pretty selfom called.
+  *
+  *   here is a simple example:
+  *
+  *   {
+  *     static int my_compare( const MyNode  node1,
+  *                            const MyNode  node2 )
+  *     {
+  *       // compare keys of 'node1' and 'node2'
+  *       return strcmp( node1->key, node2->key );
+  *     }
+  *
+  *     ....
+  *
+  *     ft_hash_init( &hash, (FT_Hash_CompareFunc) my_compare, memory );
+  *     ....
+  *   }
+  */
+  FT_BASE( void )
+  ft_hash_init( FT_Hash              table,
+                FT_Hash_CompareFunc  compare,
+                FT_Memory            memory );
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_lookup
+  *
+  * @description:
+  *   search a hash table to find a node corresponding to a given
+  *   key.
+  *
+  * @input:
+  *   table   :: handle to target hash table structure
+  *   keynode :: handle to a reference hash node that will be
+  *              only used for key comparisons with the table's
+  *              elements
+  *
+  * @return:
+  *   a pointer-to-hash-node value, which must be used as followed:
+  *
+  *   - if '*result' is NULL, the key wasn't found in the hash
+  *     table. The value of 'result' can be used to add new elements
+  *     through @ft_hash_add however..
+  *
+  *   - if '*result' is not NULL, it's a handle to the first table
+  *     node that corresponds to the search key. The value of 'result'
+  *     can be used to remove this element through @ft_hash_remove
+  *
+  * @note:
+  *   here is an example:
+  *
+  *   {
+  *     // maps a string to an integer with a hash table
+  *     // returns -1 in case of failure
+  *     //
+  *     int  my_lookup( FT_Hash      table,
+  *                     const char*  key )
+  *     {
+  *       MyNode*    pnode;
+  *       MyNodeRec  noderec;
+  *
+  *       // set-up key node. It's 'hash' and 'key' fields must
+  *       // be set correctly.. we ignore 'link' and 'value'
+  *       //
+  *       noderec.hnode.hash = strhash( key );
+  *       noderec.key        = key;
+  *
+  *       // perform search - return value
+  *       //
+  *       pnode = (MyNode) ft_hash_lookup( table, &noderec );
+  *       if ( *pnode )
+  *       {
+  *         // we found it
+  *         return (*pnode)->value;
+  *       }
+  *       return -1;
+  *     }
+  *   }
+  */
+  FT_BASE_DEF( FT_HashNode* )
+  ft_hash_lookup( FT_Hash      table,
+                  FT_HashNode  keynode )
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_add
+  *
+  * @description:
+  *   add a new node to a dynamic hash table. the user must
+  *   call @ft_hash_lookup and allocate a new node before calling
+  *   this function.
+  *
+  * @input:
+  *   table    :: hash table handle
+  *   pnode    :: pointer-to-hash-node value returned by @ft_hash_lookup
+  *   new_node :: handle to new hash node. All its fields must be correctly
+  *               set, including 'hash'.
+  *
+  * @note:
+  *   this function should always be used _after_ a call to @ft_hash_lookup
+  *   that returns a pointer to a NULL  handle. Here's an example:
+  *
+  *   {
+  *     // sets the value corresponding to a given string key
+  *     //
+  *     void  my_set( FT_Hash      table,
+  *                   const char*  key,
+  *                   int          value )
+  *     {
+  *       MyNode*    pnode;
+  *       MyNodeRec  noderec;
+  *       MyNode     node;
+  *
+  *       // set-up key node. It's 'hash' and 'key' fields must
+  *       // be set correctly..
+  *       noderec.hnode.hash = strhash( key );
+  *       noderec.key        = key;
+  *
+  *       // perform search - return value
+  *       pnode = (MyNode) ft_hash_lookup( table, &noderec );
+  *       if ( *pnode )
+  *       {
+  *         // we found it, simply replace the value in the node
+  *         (*pnode)->value = value;
+  *         return;
+  *       }
+  *
+  *       // allocate a new node - and set it up
+  *       node = (MyNode) malloc( sizeof(*node) );
+  *       node->hnode.hash = noderec.hnode.hash;
+  *       node->key        = key;
+  *       node->value      = value;
+  *
+  *       // add it to the hash table
+  *       ft_hash_add( table, pnode, node );
+  *     }
+  */
+  FT_BASE( void )
+  ft_hash_add( FT_Hash       table,
+               FT_HashNode*  pnode,
+               FT_HashNode   new_node );
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_remove
+  *
+  * @description:
+  *   try to remove the node corresponding to a given key from
+  *   a hash table. This must be called after @ft_hash_lookup
+  *
+  * @input:
+  *   table   :: hash table handle
+  *   pnode   :: pointer-to-hash-node value returned by @ft_hash_lookup
+  *
+  * @note:
+  *   this function doesn't free the node itself !! Here's an example:
+  *
+  *   {
+  *     // sets the value corresponding to a given string key
+  *     //
+  *     void  my_remove( FT_Hash      table,
+  *                      const char*  key )
+  *     {
+  *       MyNodeRec  noderec;
+  *       MyNode     node;
+  *
+  *       noderec.hnode.hash = strhash(key);
+  *       noderec.key        = key;
+  *       node               = &noderec;
+  *
+  *       pnode = ft_hash_lookup( table, &noderec );
+  *       node  = *pnode;
+  *       if ( node != NULL )
+  *       {
+  *         ft_hash_remove( table, pnode );
+  *         free( node );
+  *       }
+  *     }
+  *   }
+  */
+  FT_BASE( void )
+  ft_hash_remove( FT_Hash       table,
+                  FT_HashNode*  pnode );
+
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_get_size
+  *
+  * @description:
+  *   return the number of elements in a given hash table
+  *
+  * @input:
+  *   table   :: handle to target hash table structure
+  *
+  * @return:
+  *   number of elements. 0 if empty
+  */
+  FT_BASE( FT_UInt )
+  ft_hash_get_size( FT_Hash  table );
+
+
+
+ /****************************************************************
+  *
+  * @functype: FT_Hash_ForeachFunc
+  *
+  * @description:
+  *   a function used to iterate over all elements of a given
+  *   hash table
+  *
+  * @input:
+  *   node :: handle to target @FT_HashNodeRec node structure
+  *   data :: optional argument to iteration routine
+  *
+  * @also:  @ft_hash_foreach
+  */
+  typedef void  (*FT_Hash_ForeachFunc)( const FT_HashNode  node,
+                                        const FT_Pointer   data );
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_foreach
+  *
+  * @description:
+  *   parse over all elements in a hash table
+  *
+  * @input:
+  *   table        :: handle to target hash table structure
+  *   foreach_func :: iteration routine called for each element
+  *   foreach_data :: optional argument to the iteration routine
+  *
+  * @note:
+  *   this function is often used to release all elements from a
+  *   hash table. See the example given for @ft_hash_done
+  */
+  FT_BASE( void )
+  ft_hash_foreach( FT_Hash              table,
+                   FT_Hash_ForeachFunc  foreach_func,
+                   const FT_Pointer     foreach_data );
+
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_done
+  *
+  * @description:
+  *   finalize a given hash table
+  *
+  * @input:
+  *   table     :: handle to target hash table structure
+  *   node_func :: optional iteration function pointer. this
+  *                can be used to destroy all nodes explicitely
+  *   node_data :: optional argument to the node iterator
+  *
+  * @note:
+  *   this function simply frees the hash table's buckets.
+  *   you probably will need to call @ft_hash_foreach to
+  *   destroy all its elements before @ft_hash_done, as in
+  *   the following example:
+  *
+  *   {
+  *     static void  my_node_clear( const MyNode  node )
+  *     {
+  *       free( node );
+  *     }
+  *
+  *     static void  my_done( FT_Hash  table )
+  *     {
+  *       ft_hash_done( table, (FT_Hash_ForeachFunc) my_node_clear, NULL );
+  *     }
+  *   }
+  */
+  FT_BASE( void )
+  ft_hash_done( FT_Hash              table,
+                FT_Hash_ForeachFunc  item_func,
+                const FT_Pointer     item_data );
+
+ /* */
+
+ /* compute bucket index from hash value in a dynamic hash table */
+ /* this is only used to break encapsulation to speed lookups in */
+ /* the FreeType cache manager !!                                */
+ /*                                                              */
+
+#define  FT_HASH_COMPUTE_INDEX(_table,_hash,_index)                  \
+             {                                                       \
+               FT_UInt  _mask  = (_table)->mask;                     \
+               FT_UInt  _hash0 = (_hash);                            \
+                                                                     \
+               (_index) = (FT_UInt)( (_hash0) & _mask ) );           \
+               if ( (_index) < (_table)->p )                         \
+                 (_index) = (FT_uInt)( (_hash0) & ( 2*_mask+1 ) );   \
+             }
+
+
+FT_END_HEADER
+
+#endif /* __FT_HASH_H__ */
Index: xc/extras/freetype2/include/freetype/internal/ftmemory.h
diff -u xc/extras/freetype2/include/freetype/internal/ftmemory.h:1.1.1.4 xc/extras/freetype2/include/freetype/internal/ftmemory.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/internal/ftmemory.h:1.1.1.4	Mon Jan 14 11:52:06 2002
+++ xc/extras/freetype2/include/freetype/internal/ftmemory.h	Thu Jun 20 04:16:10 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    The FreeType memory management macros (specification).               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -172,92 +172,120 @@
            void**     P );
 
 
-  /* This `#include' is needed by the MEM_xxx() macros; it should be */
-  /* available on all platforms we know of.                          */
-#include <string.h>
+#define FT_MEM_SET( dest, byte, count )     ft_memset( dest, byte, count )
 
-#define MEM_Set( dest, byte, count )     memset( dest, byte, count )
+#define FT_MEM_COPY( dest, source, count )  ft_memcpy( dest, source, count )
 
-#define MEM_Copy( dest, source, count )  memcpy( dest, source, count )
+#define FT_MEM_MOVE( dest, source, count )  ft_memmove( dest, source, count )
 
-#define MEM_Move( dest, source, count )  memmove( dest, source, count )
 
+#define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
 
+#define FT_ZERO( p )                FT_MEM_ZERO( p, sizeof ( *(p) ) )
+
+
   /*************************************************************************/
-  /*                                                                       */
-  /* We now support closures to produce completely reentrant code.  This   */
-  /* means the allocation functions now takes an additional argument       */
-  /* (`memory').  It is a handle to a given memory object, responsible for */
-  /* all low-level operations, including memory management and             */
-  /* synchronisation.                                                      */
   /*                                                                       */
-  /* In order to keep our code readable and use the same macros in the     */
-  /* font drivers and the rest of the library, MEM_Alloc(), ALLOC(), and   */
-  /* ALLOC_ARRAY() now use an implicit variable, `memory'.  It must be     */
-  /* defined at all locations where a memory operation is queried.         */
+  /* We first define FT_MEM_ALLOC, FT_MEM_REALLOC, and FT_MEM_FREE.  All   */
+  /* macros use an _implicit_ `memory' parameter to access the current     */
+  /* memory allocator.                                                     */
   /*                                                                       */
 
 #ifdef FT_DEBUG_MEMORY
 
-#define MEM_Alloc( _pointer_, _size_ )                               \
+#define FT_MEM_ALLOC( _pointer_, _size_ )                            \
           FT_Alloc_Debug( memory, _size_,                            \
                           (void**)&(_pointer_), __FILE__, __LINE__ )
-
-#define MEM_Alloc_Array( _pointer_, _count_, _type_ )    \
-          FT_Alloc_Debug( memory, (_count_)*sizeof ( _type_ ), \
-                          (void**)&(_pointer_), __FILE__, __LINE__ )
 
-#define MEM_Realloc( _pointer_, _current_, _size_ )                    \
+#define FT_MEM_REALLOC( _pointer_, _current_, _size_ )                 \
           FT_Realloc_Debug( memory, _current_, _size_,                 \
                             (void**)&(_pointer_), __FILE__, __LINE__ )
 
-#define MEM_Realloc_Array( _pointer_, _current_, _new_, _type_ )       \
-          FT_Realloc_Debug( memory, (_current_)*sizeof ( _type_ ),     \
-                            (_new_)*sizeof ( _type_ ),                 \
-                            (void**)&(_pointer_), __FILE__, __LINE__ )
-
-#define MEM_Free( _pointer_ )                                               \
+#define FT_MEM_FREE( _pointer_ )                                            \
           FT_Free_Debug( memory, (void**)&(_pointer_), __FILE__, __LINE__ )
-  
+
+
 #else  /* !FT_DEBUG_MEMORY */
+
 
-#define MEM_Alloc( _pointer_, _size_ )                     \
+#define FT_MEM_ALLOC( _pointer_, _size_ )                  \
           FT_Alloc( memory, _size_, (void**)&(_pointer_) )
 
-#define MEM_Alloc_Array( _pointer_, _count_, _type_ )    \
-          FT_Alloc( memory, (_count_)*sizeof ( _type_ ), \
-                    (void**)&(_pointer_) )
+#define FT_MEM_FREE( _pointer_ )                  \
+          FT_Free( memory, (void**)&(_pointer_) )
 
-#define MEM_Realloc( _pointer_, _current_, _size_ )                     \
+#define FT_MEM_REALLOC( _pointer_, _current_, _size_ )                  \
           FT_Realloc( memory, _current_, _size_, (void**)&(_pointer_) )
 
-#define MEM_Realloc_Array( _pointer_, _current_, _new_, _type_ )        \
-          FT_Realloc( memory, (_current_)*sizeof ( _type_ ),            \
-                      (_new_)*sizeof ( _type_ ), (void**)&(_pointer_) )
-
-#define MEM_Free( _pointer_ )                     \
-          FT_Free( memory, (void**)&(_pointer_) )
 
 #endif /* !FT_DEBUG_MEMORY */
 
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The following functions macros expect that their pointer argument is  */
+  /* _typed_ in order to automatically compute array element sizes.        */
+  /*                                                                       */
+
+#define FT_MEM_NEW( _pointer_ )                               \
+          FT_MEM_ALLOC( _pointer_, sizeof ( *(_pointer_) ) )
+
+#define FT_MEM_NEW_ARRAY( _pointer_, _count_ )                           \
+          FT_MEM_ALLOC( _pointer_, (_count_) * sizeof ( *(_pointer_) ) )
+
+#define FT_MEM_RENEW_ARRAY( _pointer_, _old_, _new_ )                    \
+          FT_MEM_REALLOC( _pointer_, (_old_) * sizeof ( *(_pointer_) ),  \
+                                     (_new_) * sizeof ( *(_pointer_) ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* the following macros are obsolete but kept for compatibility reasons  */
+  /*                                                                       */
+
+#define FT_MEM_ALLOC_ARRAY( _pointer_, _count_, _type_ )           \
+          FT_MEM_ALLOC( _pointer_, (_count_) * sizeof ( _type_ ) )
+
+#define FT_MEM_REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ )    \
+          FT_MEM_REALLOC( _pointer_, (_old_) * sizeof ( _type ),   \
+                                     (_new_) * sizeof ( _type_ ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The following macros are variants of their FT_MEM_XXXX equivalents;   */
+  /* they are used to set an _implicit_ `error' variable and return TRUE   */
+  /* if an error occured (i.e. if 'error != 0').                           */
+  /*                                                                       */
+
+#define FT_ALLOC( _pointer_, _size_ )                       \
+          FT_SET_ERROR( FT_MEM_ALLOC( _pointer_, _size_ ) )
+
+#define FT_REALLOC( _pointer_, _current_, _size_ )                       \
+          FT_SET_ERROR( FT_MEM_REALLOC( _pointer_, _current_, _size_ ) )
+
+#define FT_FREE( _pointer_ )       \
+          FT_MEM_FREE( _pointer_ )
+
+#define FT_NEW( _pointer_ )  \
+          FT_SET_ERROR( FT_MEM_NEW( _pointer_ ) )
+
+#define FT_NEW_ARRAY( _pointer_, _count_ )  \
+          FT_SET_ERROR( FT_MEM_NEW_ARRAY( _pointer_, _count_ ) )
 
-#define ALLOC( _pointer_, _size_ )                       \
-          FT_SET_ERROR( MEM_Alloc( _pointer_, _size_ ) )
+#define FT_RENEW_ARRAY( _pointer_, _old_, _new_ )   \
+          FT_SET_ERROR( FT_MEM_RENEW_ARRAY( _pointer_, _old_, _new_ ) )
 
-#define REALLOC( _pointer_, _current_, _size_ )                       \
-          FT_SET_ERROR( MEM_Realloc( _pointer_, _current_, _size_ ) )
+#define FT_ALLOC_ARRAY( _pointer_, _count_, _type_ )                    \
+          FT_SET_ERROR( FT_MEM_ALLOC( _pointer_,                        \
+                                      (_count_) * sizeof ( _type_ ) ) )
 
-#define ALLOC_ARRAY( _pointer_, _count_, _type_ )                  \
-          FT_SET_ERROR( MEM_Alloc( _pointer_,                      \
-                                   (_count_)*sizeof ( _type_ ) ) )
-
-#define REALLOC_ARRAY( _pointer_, _current_, _count_, _type_ )       \
-          FT_SET_ERROR( MEM_Realloc( _pointer_,                      \
-                                     (_current_)*sizeof ( _type_ ),  \
-                                     (_count_)*sizeof ( _type_ ) ) )
+#define FT_REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ )             \
+          FT_SET_ERROR( FT_MEM_REALLOC( _pointer_,                      \
+                                        (_old_) * sizeof ( _type_ ),    \
+                                        (_new_) * sizeof ( _type_ ) ) )
 
-#define FREE( _pointer_ )       \
-          MEM_Free( _pointer_ )
+ /* */
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/ftobject.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/ftobject.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/internal/ftobject.h	Thu Jun 20 04:16:10 2002
@@ -0,0 +1,443 @@
+#ifndef __FT_OBJECT_H__
+#define __FT_OBJECT_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+ /**************************************************************
+  *
+  * @type: FT_Object
+  *
+  * @description:
+  *   handle to a FreeType Object. See @FT_ObjectRec
+  */
+  typedef struct FT_ObjectRec_*        FT_Object;
+
+
+ /**************************************************************
+  *
+  * @type: FT_Class
+  *
+  * @description:
+  *   handle to a constant class handle to a FreeType Object.
+  *
+  *   Note that a class is itself a @FT_Object and are dynamically
+  *   allocated on the heap.
+  *
+  * @also:
+  *  @FT_ClassRec, @FT_Object, @FT_ObjectRec, @FT_Type, @FT_TypeRec
+  */
+  typedef const struct FT_ClassRec_*   FT_Class;
+
+
+ /**************************************************************
+  *
+  * @type: FT_Type
+  *
+  * @description:
+  *   handle to a constant structure (of type @FT_TypeRec) used
+  *   to describe a given @FT_Class type to the FreeType object
+  *   sub-system.
+  */
+  typedef const struct FT_TypeRec_*    FT_Type;
+
+
+
+ /**************************************************************
+  *
+  * @struct: FT_ObjectRec
+  *
+  * @description:
+  *   a structure describing the root fields of all @FT_Object
+  *   class instances in FreeType
+  *
+  * @fields:
+  *   clazz     :: handle to the object's class
+  *   ref_count :: object's reference count. Starts at 1
+  */
+  typedef struct FT_ObjectRec_
+  {
+    FT_Class  clazz;
+    FT_Int    ref_count;
+
+  } FT_ObjectRec;
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT (x)
+  *
+  * @description:
+  *   a useful macro to type-cast anything to a @FT_Object
+  *   handle. No check performed..
+  */
+#define  FT_OBJECT(x)    ((FT_Object)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT_P (x)
+  *
+  * @description:
+  *   a useful macro to type-cast anything to a pointer to
+  *   @FT_Object handle.
+  */
+#define  FT_OBJECT_P(x)  ((FT_Object*)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__CLASS (obj)
+  *
+  * @description:
+  *   a useful macro to return the class of any object
+  */
+#define  FT_OBJECT__CLASS(x)      FT_OBJECT(x)->clazz
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__REF_COUNT (obj)
+  *
+  * @description:
+  *   a useful macro to return the reference count of any object
+  */
+#define  FT_OBJECT__REF_COUNT(x)  FT_OBJECT(x)->ref_count
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__MEMORY (obj)
+  *
+  * @description:
+  *   a useful macro to return a handle to the memory manager
+  *   used to allocate a given object
+  */
+#define  FT_OBJECT__MEMORY(x)     FT_CLASS__MEMORY(FT_OBJECT(x)->clazz)
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__LIBRARY (obj)
+  *
+  * @description:
+  *   a useful macro to return a handle to the library handle
+  *   that owns the object
+  */
+#define  FT_OBJECT__LIBRARY(x)    FT_CLASS__LIBRARY(FT_OBJECT(x)->clazz)
+
+
+ /**************************************************************
+  *
+  * @functype: FT_Object_InitFunc
+  *
+  * @description:
+  *   a function used to initialize a new object
+  *
+  * @input:
+  *   object    :: target object handle
+  *   init_data :: optional pointer to initialization data
+  *
+  * @throws: any
+  *
+  *   the object is _assumed_ to be reachable from the cleanup
+  *   stack when the constructor is called. This means that
+  *   any exception can be thrown safely in it.
+  */
+  typedef void  (*FT_Object_InitFunc)( FT_Object   object,
+                                       FT_Pointer  init_data );
+
+ /**************************************************************
+  *
+  * @functype: FT_Object_DoneFunc
+  *
+  * @description:
+  *   a function used to finalize a given object
+  *
+  * @input:
+  *   object    :: handle to target object
+  *
+  * @throws: *never* !!
+  */
+  typedef void  (*FT_Object_DoneFunc)( FT_Object   object );
+
+
+ /**************************************************************
+  *
+  * @struct: FT_ClassRec
+  *
+  * @description:
+  *   a structure used to describe a given object class within
+  *   FreeType
+  *
+  * @fields:
+  *   object   :: root @FT_ObjectRec fields, since each class is
+  *               itself an object. (it's an instance of the
+  *               "metaclass", a special object of the FreeType
+  *               object sub-system.)
+  *
+  *   magic    :: a 32-bit magic number used for decoding
+  *   type     :: the @FT_Type descriptor of this class
+  *   memory   :: the current memory manager handle
+  *   library  :: the current library handle
+  *   info     :: an opaque pointer to class-specific information
+  *               managed by the FreeType object sub-system
+  *
+  *   obj_size :: size of class instances in bytes
+  *   obj_init :: class instance constructor
+  *   obj_done :: class instance destructor
+  */
+  typedef struct FT_ClassRec_
+  {
+    FT_ObjectRec        object;
+    FT_UInt32           magic;
+    FT_Type             type;
+    FT_Memory           memory;
+    FT_Library          library;
+    FT_Pointer          info;
+
+    FT_UInt             obj_size;
+    FT_Object_InitFunc  obj_init;
+    FT_Object_DoneFunc  obj_done;
+
+  } FT_ClassRec;
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS (x)
+  *
+  * @description:
+  *   a useful macro to convert anything to a class handle
+  *   without checks
+  */
+#define  FT_CLASS(x)    ((FT_Class)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS_P (x)
+  *
+  * @description:
+  *   a useful macro to convert anything to a pointer to a class
+  *   handle without checks
+  */
+#define  FT_CLASS_P(x)  ((FT_Class*)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS__MEMORY (clazz)
+  *
+  * @description:
+  *   a useful macro to return the memory manager handle of a
+  *   given class
+  */
+#define  FT_CLASS__MEMORY(x)   FT_CLASS(x)->memory
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS__LIBRARY (clazz)
+  *
+  * @description:
+  *   a useful macro to return the library handle of a
+  *   given class
+  */
+#define  FT_CLASS__LIBRARY(x)  FT_CLASS(x)->library
+
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS__TYPE (clazz)
+  *
+  * @description:
+  *   a useful macro to return the type of a given class
+  *   given class
+  */
+#define  FT_CLASS__TYPE(x)     FT_CLASS(x)->type
+
+ /* */
+#define  FT_CLASS__INFO(x)     FT_CLASS(x)->info
+#define  FT_CLASS__MAGIC(x)    FT_CLASS(x)->magic
+
+
+ /**************************************************************
+  *
+  * @struct: FT_TypeRec
+  *
+  * @description:
+  *   a structure used to describe a given class to the FreeType
+  *   object sub-system.
+  *
+  * @fields:
+  *   name       :: class name. only used for debugging
+  *   super      :: type of super-class. NULL if none
+  *
+  *   class_size :: size of class structure in bytes
+  *   class_init :: class constructor
+  *   class_done :: class finalizer
+  *
+  *   obj_size   :: instance size in bytes
+  *   obj_init   :: instance constructor. can be NULL
+  *   obj_done   :: instance destructor. can be NULL
+  *
+  * @note:
+  *   if 'obj_init' is NULL, the class will use it's parent
+  *   constructor.
+  *
+  *   if 'obj_done' is NULL, the class will use it's parent
+  *   finalizer.
+  *
+  *   the object sub-system allocates a new class, copies
+  *   the content of its super-class into the new structure,
+  *   _then_ calls 'clazz_init'.
+  */
+  typedef struct FT_TypeRec_
+  {
+    const char*         name;
+    FT_Type             super;
+
+    FT_UInt             class_size;
+    FT_Object_InitFunc  class_init;
+    FT_Object_DoneFunc  class_done;
+
+    FT_UInt             obj_size;
+    FT_Object_InitFunc  obj_init;
+    FT_Object_DoneFunc  obj_done;
+
+  } FT_TypeRec;
+
+
+ /**************************************************************
+  *
+  * @macro: FT_TYPE (x)
+  *
+  * @description:
+  *   a useful macro to convert anything to a class type handle
+  *   without checks
+  */
+#define  FT_TYPE(x)  ((FT_Type)(x))
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_check
+  *
+  * @description:
+  *   checks that a handle points to a valid @FT_Object
+  *
+  * @input:
+  *   obj :: handle/pointer
+  *
+  * @return:
+  *   1 iff the handle points to a valid object. 0 otherwise
+  */
+  FT_BASE_DEF( FT_Int )
+  ft_object_check( FT_Pointer  obj );
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_is_a
+  *
+  * @description:
+  *   checks that a handle points to a valid @FT_Object that
+  *   is an instance of a given class (or of any of its sub-classes)
+  *
+  * @input:
+  *   obj   :: handle/pointer
+  *   clazz :: class handle to check
+  *
+  * @return:
+  *   1 iff the handle points to a valid 'clazz' instance. 0
+  *   otherwise.
+  */
+  FT_BASE_DEF( FT_Int )
+  ft_object_is_a( FT_Pointer  obj,
+                  FT_Class    clazz );
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_new
+  *
+  * @description:
+  *   create a new object (class instance)
+  *
+  * @input:
+  *   clazz     :: object's class pointer
+  *   init_data :: optional pointer to initialization data
+  *
+  * @return:
+  *   handle to new object. Cannot be NULL !
+  */
+  FT_BASE_DEF( FT_Object )
+  ft_object_new( FT_Class    clazz,
+                 FT_Pointer  init_data );
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_create
+  *
+  * @description:
+  *   a variation of @ft_object_new that should be used when
+  *   creating a new object that is owned by another object
+  *   which is reachable from the cleanup stack.
+  *
+  *   this function is a bit more akward to use but completely
+  *   avoids push/pop pairs during object construction and is
+  *   therefore faster.
+  *
+  * @output:
+  *   pobject   :: new object handle
+  *
+  * @input:
+  *   clazz     :: object's class pointer
+  *   init_data :: optional pointer to initialization data
+  *   push      :: boolean. If true, the new object is pushed
+  *                on top of the cleanup stack.
+  */
+  FT_BASE_DEF( void )
+  ft_object_create( FT_Object  *pobject,
+                    FT_Class    clazz,
+                    FT_Pointer  init_data );
+
+ /* */
+
+  FT_BASE_DEF( FT_Class )
+  ft_class_find_by_type( FT_Type    type,
+                         FT_Memory  memory );
+
+  FT_BASE_DEF( FT_Class )
+  ft_class_find_by_name( FT_CString  class_name,
+                         FT_Memory   memory );
+
+  FT_BASE_DEF( FT_Object )
+  ft_object_new_from_type( FT_Type     type,
+                           FT_Pointer  data,
+                           FT_Memory   memory );
+
+  FT_BASE_DEF( void )
+  ft_object_create_from_type( FT_Object  *pobject,
+                              FT_Type     type,
+                              FT_Pointer  init_data,
+                              FT_Memory   memory );
+
+  FT_BASE_DEF( void )
+  ft_object_push( FT_Object  object );
+
+  FT_BASE_DEF( void )
+  ft_object_pop( FT_Object  object );
+
+  FT_BASE_DEF( void )
+  ft_object_pop_destroy( FT_Object  object );
+
+
+FT_END_HEADER
+
+#endif /* __FT_OBJECT_H__ */
Index: xc/extras/freetype2/include/freetype/internal/ftobjs.h
diff -u xc/extras/freetype2/include/freetype/internal/ftobjs.h:1.1.1.4 xc/extras/freetype2/include/freetype/internal/ftobjs.h:1.1.1.6
--- xc/extras/freetype2/include/freetype/internal/ftobjs.h:1.1.1.4	Mon Jan 14 11:52:07 2002
+++ xc/extras/freetype2/include/freetype/internal/ftobjs.h	Thu Jun 20 04:16:10 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    The FreeType private base classes (specification).                   */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -26,11 +26,12 @@
 #ifndef __FTOBJS_H__
 #define __FTOBJS_H__
 
-
 #include <ft2build.h>
+#include FT_CONFIG_STANDARD_LIBRARY_H   /* for ft_setjmp and ft_longjmp */
 #include FT_RENDER_H
 #include FT_SIZES_H
 #include FT_INTERNAL_MEMORY_H
+#include FT_INTERNAL_GLYPH_LOADER_H
 #include FT_INTERNAL_DRIVER_H
 #include FT_INTERNAL_AUTOHINT_H
 
@@ -54,10 +55,6 @@
 #define NULL  (void*)0
 #endif
 
-#ifndef UNUSED
-#define UNUSED( arg )  ( (arg)=(arg) )
-#endif
-
 
   /*************************************************************************/
   /*                                                                       */
@@ -78,22 +75,187 @@
 
 
   /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                    V A L I D A T I O N                          ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* handle to a validation object */
+  typedef struct FT_ValidatorRec_*  FT_Validator;
+
+
+  /*************************************************************************/
   /*                                                                       */
-  /* <Struct>                                                              */
-  /*    FT_GlyphLoader                                                     */
+  /* There are three distinct validation levels defined here:              */
   /*                                                                       */
-  /* <Description>                                                         */
-  /*    The glyph loader is an internal object used to load several glyphs */
-  /*    together (for example, in the case of composites).                 */
+  /* FT_VALIDATE_DEFAULT ::                                                */
+  /*   A table that passes this validation level can be used reliably by   */
+  /*   FreeType.  It generally means that all offsets have been checked to */
+  /*   prevent out-of-bound reads, array counts are correct, etc.          */
   /*                                                                       */
-  /* <Note>                                                                */
-  /*    The glyph loader implementation is not part of the high-level API, */
-  /*    hence the forward structure declaration.                           */
+  /* FT_VALIDATE_TIGHT ::                                                  */
+  /*   A table that passes this validation level can be used reliably and  */
+  /*   doesn't contain invalid data.  For example, a charmap table that    */
+  /*   returns invalid glyph indices will not pass, even though it can     */
+  /*   be used with FreeType in default mode (the library will simply      */
+  /*   return an error later when trying to load the glyph).               */
+  /*                                                                       */
+  /*   It also check that fields that must be a multiple of 2, 4, or 8     */
+  /*   dont' have incorrect values, etc.                                   */
   /*                                                                       */
-  typedef struct FT_GlyphLoader_  FT_GlyphLoader;
+  /* FT_VALIDATE_PARANOID ::                                               */
+  /*   Only for font debugging.  Checks that a table follows the           */
+  /*   specification by 100%.  Very few fonts will be able to pass this    */
+  /*   level anyway but it can be useful for certain tools like font       */
+  /*   editors/converters.                                                 */
+  /*                                                                       */
+  typedef enum  FT_ValidationLevel_
+  {
+    FT_VALIDATE_DEFAULT = 0,
+    FT_VALIDATE_TIGHT,
+    FT_VALIDATE_PARANOID
+
+  } FT_ValidationLevel;
+
+
+  /* validator structure */
+  typedef struct  FT_ValidatorRec_
+  {
+    const FT_Byte*      base;        /* address of table in memory       */
+    const FT_Byte*      limit;       /* `base' + sizeof(table) in memory */
+    FT_ValidationLevel  level;       /* validation level                 */
+    FT_Error            error;       /* error returned. 0 means success  */
+
+    ft_jmp_buf          jump_buffer; /* used for exception handling      */
+
+  } FT_ValidatorRec;
+
+
+#define FT_VALIDATOR( x )  ((FT_Validator)( x ))
+
+
+  FT_BASE( void )
+  ft_validator_init( FT_Validator        valid,
+                     const FT_Byte*      base,
+                     const FT_Byte*      limit,
+                     FT_ValidationLevel  level );
+
+  FT_BASE( FT_Int )
+  ft_validator_run( FT_Validator  valid );
+
+  /* Sets the error field in a validator, then calls `longjmp' to return */
+  /* to high-level caller.  Using `setjmp/longjmp' avoids many stupid    */
+  /* error checks within the validation routines.                        */
+  /*                                                                     */
+  FT_BASE( void )
+  ft_validator_error( FT_Validator  valid,
+                      FT_Error      error );
+
+
+  /* Calls ft_validate_error.  Assumes that the `valid' local variable */
+  /* holds a pointer to the current validator object.                  */
+  /*                                                                   */
+#define FT_INVALID( _error )  ft_validator_error( valid, _error )
+
+  /* called when a broken table is detected */
+#define FT_INVALID_TOO_SHORT  FT_INVALID( FT_Err_Invalid_Table )
+
+  /* called when an invalid offset is detected */
+#define FT_INVALID_OFFSET     FT_INVALID( FT_Err_Invalid_Offset )
+
+  /* called when an invalid format/value is detected */
+#define FT_INVALID_FORMAT     FT_INVALID( FT_Err_Invalid_Table )
 
+  /* called when an invalid glyph index is detected */
+#define FT_INVALID_GLYPH_ID   FT_INVALID( FT_Err_Invalid_Glyph_Index )
 
+  /* called when an invalid field value is detected */
+#define FT_INVALID_DATA       FT_INVALID( FT_Err_Invalid_Table )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                       C H A R M A P S                           ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
   /*************************************************************************/
+  /*************************************************************************/
+
+  /* handle to internal charmap object */
+  typedef struct FT_CMapRec_*              FT_CMap;
+
+  /* handle to charmap class structure */
+  typedef const struct FT_CMap_ClassRec_*  FT_CMap_Class;
+
+  /* internal charmap object structure */
+  typedef struct  FT_CMapRec_
+  {
+    FT_CharMapRec  charmap;
+    FT_CMap_Class  clazz;
+
+  } FT_CMapRec;
+
+  /* typecase any pointer to a charmap handle */
+#define FT_CMAP( x )              ((FT_CMap)( x ))
+
+  /* obvious macros */
+#define FT_CMAP_PLATFORM_ID( x )  FT_CMAP( x )->charmap.platform_id
+#define FT_CMAP_ENCODING_ID( x )  FT_CMAP( x )->charmap.encoding_id
+#define FT_CMAP_ENCODING( x )     FT_CMAP( x )->charmap.encoding
+#define FT_CMAP_FACE( x )         FT_CMAP( x )->charmap.face
+
+
+  /* class method definitions */
+  typedef FT_Error
+  (*FT_CMap_InitFunc)( FT_CMap     cmap,
+                       FT_Pointer  init_data );
+
+  typedef void
+  (*FT_CMap_DoneFunc)( FT_CMap  cmap );
+
+  typedef FT_UInt
+  (*FT_CMap_CharIndexFunc)( FT_CMap    cmap,
+                            FT_UInt32  char_code );
+
+  typedef FT_UInt
+  (*FT_CMap_CharNextFunc)( FT_CMap     cmap,
+                           FT_UInt32  *achar_code );
+
+
+  typedef struct  FT_CMap_ClassRec_
+  {
+    FT_UInt                size;
+    FT_CMap_InitFunc       init;
+    FT_CMap_DoneFunc       done;
+    FT_CMap_CharIndexFunc  char_index;
+    FT_CMap_CharNextFunc   char_next;
+
+  } FT_CMap_ClassRec;
+
+
+  /* create a new charmap and add it to charmap->face */
+  FT_BASE( FT_Error )
+  FT_CMap_New( FT_CMap_Class  clazz,
+               FT_Pointer     init_data,
+               FT_CharMap     charmap,
+               FT_CMap       *acmap );
+
+  /* destroy a charmap (don't remove it from face's list though) */
+  FT_BASE( void )
+  FT_CMap_Done( FT_CMap  cmap );
+
+
+  /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
   /*    FT_Face_InternalRec                                                */
@@ -175,12 +337,12 @@
   /*                                                                       */
   typedef struct  FT_Slot_InternalRec_
   {
-    FT_GlyphLoader*  loader;
-    FT_Bool          glyph_transformed;
-    FT_Matrix        glyph_matrix;
-    FT_Vector        glyph_delta;
-    void*            glyph_hints;
-  
+    FT_GlyphLoader  loader;
+    FT_Bool         glyph_transformed;
+    FT_Matrix       glyph_matrix;
+    FT_Vector       glyph_delta;
+    void*           glyph_hints;
+
   } FT_GlyphSlot_InternalRec;
 
 
@@ -225,11 +387,12 @@
 
 
   /* typecast an object to a FT_Module */
-#define FT_MODULE( x )          ((FT_Module)(x))
-#define FT_MODULE_CLASS( x )    FT_MODULE(x)->clazz
-#define FT_MODULE_LIBRARY( x )  FT_MODULE(x)->library
-#define FT_MODULE_MEMORY( x )   FT_MODULE(x)->memory
+#define FT_MODULE( x )          ((FT_Module)( x ))
+#define FT_MODULE_CLASS( x )    FT_MODULE( x )->clazz
+#define FT_MODULE_LIBRARY( x )  FT_MODULE( x )->library
+#define FT_MODULE_MEMORY( x )   FT_MODULE( x )->memory
 
+
 #define FT_MODULE_IS_DRIVER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
                                     ft_module_font_driver )
 
@@ -242,13 +405,13 @@
 #define FT_MODULE_IS_STYLER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
                                     ft_module_styler )
 
-#define FT_DRIVER_IS_SCALABLE( x )  ( FT_MODULE_CLASS(x)->module_flags & \
+#define FT_DRIVER_IS_SCALABLE( x )  ( FT_MODULE_CLASS( x )->module_flags & \
                                       ft_module_driver_scalable )
 
-#define FT_DRIVER_USES_OUTLINES( x )  !( FT_MODULE_CLASS(x)->module_flags & \
+#define FT_DRIVER_USES_OUTLINES( x )  !( FT_MODULE_CLASS( x )->module_flags & \
                                          ft_module_driver_no_outlines )
 
-#define FT_DRIVER_HAS_HINTER( x )  ( FT_MODULE_CLASS(x)->module_flags & \
+#define FT_DRIVER_HAS_HINTER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
                                      ft_module_driver_has_hinter )
 
 
@@ -299,6 +462,7 @@
 #define FT_FACE_DRIVER( x )   FT_FACE( x )->driver
 #define FT_FACE_LIBRARY( x )  FT_FACE_DRIVER( x )->root.library
 #define FT_FACE_MEMORY( x )   FT_FACE( x )->memory
+#define FT_FACE_STREAM( x )   FT_FACE( x )->stream
 
 #define FT_SIZE_FACE( x )     FT_SIZE( x )->face
 #define FT_SLOT_FACE( x )     FT_SLOT( x )->face
@@ -354,106 +518,6 @@
   /*************************************************************************/
   /****                                                                 ****/
   /****                                                                 ****/
-  /****                   G L Y P H   L O A D E R                       ****/
-  /****                                                                 ****/
-  /****                                                                 ****/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-
-
-#define FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS          1
-#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES      2
-#define FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID        4
-#define FT_SUBGLYPH_FLAG_SCALE                   8
-#define FT_SUBGLYPH_FLAG_XY_SCALE             0x40
-#define FT_SUBGLYPH_FLAG_2X2                  0x80
-#define FT_SUBGLYPH_FLAG_USE_MY_METRICS      0x200
-
-
-  enum
-  {
-    ft_glyph_own_bitmap = 1
-  };
-
-
-  struct  FT_SubGlyph_
-  {
-    FT_Int     index;
-    FT_UShort  flags;
-    FT_Int     arg1;
-    FT_Int     arg2;
-    FT_Matrix  transform;
-  };
-
-
-  typedef struct  FT_GlyphLoad_
-  {
-    FT_Outline    outline;       /* outline             */
-    FT_UInt       num_subglyphs; /* number of subglyphs */
-    FT_SubGlyph*  subglyphs;     /* subglyphs           */
-    FT_Vector*    extra_points;  /* extra points table  */
-
-  } FT_GlyphLoad;
-
-
-  struct  FT_GlyphLoader_
-  {
-    FT_Memory     memory;
-    FT_UInt       max_points;
-    FT_UInt       max_contours;
-    FT_UInt       max_subglyphs;
-    FT_Bool       use_extra;
-
-    FT_GlyphLoad  base;
-    FT_GlyphLoad  current;
-
-    void*         other;            /* for possible future extension? */
-
-  };
-
-
-  FT_BASE( FT_Error )
-  FT_GlyphLoader_New( FT_Memory         memory,
-                      FT_GlyphLoader*  *aloader );
-
-  FT_BASE( FT_Error )
-  FT_GlyphLoader_Create_Extra( FT_GlyphLoader*  loader );
-
-  FT_BASE( void )
-  FT_GlyphLoader_Done( FT_GlyphLoader*  loader );
-
-  FT_BASE( void )
-  FT_GlyphLoader_Reset( FT_GlyphLoader*  loader );
-
-  FT_BASE( void )
-  FT_GlyphLoader_Rewind( FT_GlyphLoader*  loader );
-
-  FT_BASE( FT_Error )
-  FT_GlyphLoader_Check_Points( FT_GlyphLoader*  loader,
-                               FT_UInt          n_points,
-                               FT_UInt          n_contours );
-
-  FT_BASE( FT_Error )
-  FT_GlyphLoader_Check_Subglyphs( FT_GlyphLoader*  loader,
-                                  FT_UInt          n_subs );
-
-  FT_BASE( void )
-  FT_GlyphLoader_Prepare( FT_GlyphLoader*  loader );
-
-  FT_BASE( void )
-  FT_GlyphLoader_Add( FT_GlyphLoader*  loader );
-
-  FT_BASE( FT_Error )
-  FT_GlyphLoader_Copy_Points( FT_GlyphLoader*  target,
-                              FT_GlyphLoader*  source );
-
-
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-  /****                                                                 ****/
-  /****                                                                 ****/
   /****                        R E N D E R E R S                        ****/
   /****                                                                 ****/
   /****                                                                 ****/
@@ -531,13 +595,13 @@
   /*                                                                       */
   typedef struct  FT_DriverRec_
   {
-    FT_ModuleRec      root;
-    FT_Driver_Class*  clazz;
+    FT_ModuleRec     root;
+    FT_Driver_Class  clazz;
 
-    FT_ListRec        faces_list;
-    void*             extensions;
+    FT_ListRec       faces_list;
+    void*            extensions;
 
-    FT_GlyphLoader*   glyph_loader;
+    FT_GlyphLoader   glyph_loader;
 
   } FT_DriverRec;
 
@@ -555,8 +619,8 @@
   /*************************************************************************/
 
 
-#define FT_DEBUG_HOOK_TRUETYPE   0
-#define FT_DEBUG_HOOK_TYPE1      1
+#define FT_DEBUG_HOOK_TRUETYPE  0
+#define FT_DEBUG_HOOK_TYPE1     1
 
 
   /*************************************************************************/
@@ -609,6 +673,10 @@
 
     FT_Generic         generic;
 
+    FT_Int             version_major;
+    FT_Int             version_minor;
+    FT_Int             version_patch;
+
     FT_UInt            num_modules;
     FT_Module          modules[FT_MAX_MODULES];  /* module objects  */
 
@@ -617,7 +685,7 @@
     FT_Module          auto_hinter;
 
     FT_Byte*           raster_pool;      /* scan-line conversion */
-                                          /* render pool          */
+                                         /* render pool          */
     FT_ULong           raster_pool_size; /* size of render pool in bytes */
 
     FT_DebugHook_Func  debug_hooks[4];
@@ -636,57 +704,20 @@
                             FT_UInt       render_mode );
 
   typedef const char*
-  (*FT_PSName_Requester)( FT_Face  face );
+  (*FT_Face_GetPostscriptNameFunc)( FT_Face  face );
 
   typedef FT_Error
-  (*FT_Glyph_Name_Requester)( FT_Face     face,
-                              FT_UInt     glyph_index,
-                              FT_Pointer  buffer,
-                              FT_UInt     buffer_max );
+  (*FT_Face_GetGlyphNameFunc)( FT_Face     face,
+                               FT_UInt     glyph_index,
+                               FT_Pointer  buffer,
+                               FT_UInt     buffer_max );
 
   typedef FT_UInt
-  (*FT_Name_Index_Requester)( FT_Face     face,
-                              FT_String*  glyph_name );
+  (*FT_Face_GetGlyphNameIndexFunc)( FT_Face     face,
+                                    FT_String*  glyph_name );
 
 
 #ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_New_Stream                                                      */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Creates a new stream object.                                       */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    filepathname :: The name of the stream (usually a file) to be      */
-  /*                    opened.                                            */
-  /*                                                                       */
-  /*    stream       :: A pointer to the stream object.                    */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    FreeType error code.  0 means success.                             */
-  /*                                                                       */
-  FT_EXPORT( FT_Error )
-  FT_New_Stream( const char*  filepathname,
-                 FT_Stream    astream );
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    FT_Done_Stream                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Closes and destroys a stream object.                               */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    stream :: The stream to be closed and destroyed.                   */
-  /*                                                                       */
-  FT_EXPORT( void )
-  FT_Done_Stream( FT_Stream  stream );
-
 
   /*************************************************************************/
   /*                                                                       */
Index: xc/extras/freetype2/include/freetype/internal/ftstream.h
diff -u xc/extras/freetype2/include/freetype/internal/ftstream.h:1.1.1.5 xc/extras/freetype2/include/freetype/internal/ftstream.h:1.1.1.6
--- xc/extras/freetype2/include/freetype/internal/ftstream.h:1.1.1.5	Mon Jan 14 11:52:07 2002
+++ xc/extras/freetype2/include/freetype/internal/ftstream.h	Thu Jun 20 04:16:10 2002
@@ -2,9 +2,9 @@
 /*                                                                         */
 /*  ftstream.h                                                             */
 /*                                                                         */
-/*    Stream handling(specification).                                      */
+/*    Stream handling (specification).                                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,10 +27,14 @@
 FT_BEGIN_HEADER
 
 
-  /* format of an 8-bit frame_op value = [ xxxxx | e | s ] */
-  /* s is set to 1 if the value is signed,                 */
-  /* e is set to 1 if the value is little-endian           */
-  /* xxxxx is a command                                    */
+  /* format of an 8-bit frame_op value:           */
+  /*                                              */
+  /* bit  76543210                                */
+  /*      xxxxxxes                                */
+  /*                                              */
+  /* s is set to 1 if the value is signed.        */
+  /* e is set to 1 if the value is little-endian. */
+  /* xxx is a command.                            */
 
 #define FT_FRAME_OP_SHIFT         2
 #define FT_FRAME_OP_SIGNED        1
@@ -40,13 +44,13 @@
 #define FT_MAKE_FRAME_OP( command, little, sign ) \
           ( ( command << FT_FRAME_OP_SHIFT ) | ( little << 1 ) | sign )
 
-#define FT_FRAME_OP_END   0
-#define FT_FRAME_OP_START 1  /* start a new frame     */
-#define FT_FRAME_OP_BYTE  2  /* read 1-byte value     */
-#define FT_FRAME_OP_SHORT 3  /* read 2-byte value     */
-#define FT_FRAME_OP_LONG  4  /* read 4-byte value     */
-#define FT_FRAME_OP_OFF3  5  /* read 3-byte value     */
-#define FT_FRAME_OP_BYTES 6  /* read a bytes sequence */
+#define FT_FRAME_OP_END    0
+#define FT_FRAME_OP_START  1  /* start a new frame     */
+#define FT_FRAME_OP_BYTE   2  /* read 1-byte value     */
+#define FT_FRAME_OP_SHORT  3  /* read 2-byte value     */
+#define FT_FRAME_OP_LONG   4  /* read 4-byte value     */
+#define FT_FRAME_OP_OFF3   5  /* read 3-byte value     */
+#define FT_FRAME_OP_BYTES  6  /* read a bytes sequence */
 
 
   typedef enum  FT_Frame_Op_
@@ -80,9 +84,9 @@
 
   typedef struct  FT_Frame_Field_
   {
-    FT_Byte      value;
-    FT_Byte      size;
-    FT_UShort    offset;
+    FT_Byte    value;
+    FT_Byte    size;
+    FT_UShort  offset;
 
   } FT_Frame_Field;
 
@@ -90,6 +94,7 @@
   /* Construct an FT_Frame_Field out of a structure type and a field name. */
   /* The structure type must be set in the FT_STRUCTURE macro before       */
   /* calling the FT_FRAME_START() macro.                                   */
+  /*                                                                       */
 #define FT_FIELD_SIZE( f ) \
           (FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f )
 
@@ -115,6 +120,8 @@
 #define FT_FRAME_ULONG( f )      FT_FRAME_FIELD( ft_frame_ulong_be, f )
 #define FT_FRAME_SHORT( f )      FT_FRAME_FIELD( ft_frame_short_be, f )
 #define FT_FRAME_USHORT( f )     FT_FRAME_FIELD( ft_frame_ushort_be, f )
+#define FT_FRAME_OFF3( f )       FT_FRAME_FIELD( ft_frame_off3_be, f )
+#define FT_FRAME_UOFF3( f )      FT_FRAME_FIELD( ft_frame_uoff3_be, f )
 #define FT_FRAME_BYTE( f )       FT_FRAME_FIELD( ft_frame_byte, f )
 #define FT_FRAME_CHAR( f )       FT_FRAME_FIELD( ft_frame_schar, f )
 
@@ -122,6 +129,8 @@
 #define FT_FRAME_ULONG_LE( f )   FT_FRAME_FIELD( ft_frame_ulong_le, f )
 #define FT_FRAME_SHORT_LE( f )   FT_FRAME_FIELD( ft_frame_short_le, f )
 #define FT_FRAME_USHORT_LE( f )  FT_FRAME_FIELD( ft_frame_ushort_le, f )
+#define FT_FRAME_OFF3_LE( f )    FT_FRAME_FIELD( ft_frame_off3_le, f )
+#define FT_FRAME_UOFF3_LE( f )   FT_FRAME_FIELD( ft_frame_uoff3_le, f )
 
 #define FT_FRAME_SKIP_LONG       { ft_frame_long_be, 0, 0 }
 #define FT_FRAME_SKIP_SHORT      { ft_frame_short_be, 0, 0 }
@@ -137,117 +146,122 @@
 #define FT_FRAME_SKIP_BYTES( count )  { ft_frame_skip, count, 0 }
 
 
-
   /*************************************************************************/
   /*                                                                       */
-  /* integer extraction macros -- the `buffer' parameter must ALWAYS be of */
+  /* Integer extraction macros -- the `buffer' parameter must ALWAYS be of */
   /* type `char*' or equivalent (1-byte elements).                         */
   /*                                                                       */
+
+#define FT_BYTE_( p, i )  ( ((const FT_Byte*)(p))[(i)] )
+#define FT_INT8_( p, i )  ( ((const FT_Char*)(p))[(i)] )
+
+#define FT_INT16( x )   ( (FT_Int16)(x)  )
+#define FT_UINT16( x )  ( (FT_UInt16)(x) )
+#define FT_INT32( x )   ( (FT_Int32)(x)  )
+#define FT_UINT32( x )  ( (FT_UInt32)(x) )
+
+#define FT_BYTE_I16( p, i, s )  ( FT_INT16(  FT_BYTE_( p, i ) ) << (s) )
+#define FT_BYTE_U16( p, i, s )  ( FT_UINT16( FT_BYTE_( p, i ) ) << (s) )
+#define FT_BYTE_I32( p, i, s )  ( FT_INT32(  FT_BYTE_( p, i ) ) << (s) )
+#define FT_BYTE_U32( p, i, s )  ( FT_UINT32( FT_BYTE_( p, i ) ) << (s) )
+
+#define FT_INT8_I16( p, i, s )  ( FT_INT16(  FT_INT8_( p, i ) ) << (s) )
+#define FT_INT8_U16( p, i, s )  ( FT_UINT16( FT_INT8_( p, i ) ) << (s) )
+#define FT_INT8_I32( p, i, s )  ( FT_INT32(  FT_INT8_( p, i ) ) << (s) )
+#define FT_INT8_U32( p, i, s )  ( FT_UINT32( FT_INT8_( p, i ) ) << (s) )
+
+
+#define FT_PEEK_SHORT( p )  FT_INT16( FT_INT8_I16( p, 0, 8) | \
+                                      FT_BYTE_I16( p, 1, 0) )
+
+#define FT_PEEK_USHORT( p )  FT_UINT16( FT_BYTE_U16( p, 0, 8 ) | \
+                                        FT_BYTE_U16( p, 1, 0 ) )
+
+#define FT_PEEK_LONG( p )  FT_INT32( FT_INT8_I32( p, 0, 24 ) | \
+                                     FT_BYTE_I32( p, 1, 16 ) | \
+                                     FT_BYTE_I32( p, 2,  8 ) | \
+                                     FT_BYTE_I32( p, 3,  0 ) )
+
+#define FT_PEEK_ULONG( p )  FT_UINT32( FT_BYTE_U32( p, 0, 24 ) | \
+                                       FT_BYTE_U32( p, 1, 16 ) | \
+                                       FT_BYTE_U32( p, 2,  8 ) | \
+                                       FT_BYTE_U32( p, 3,  0 ) )
 
-#define FT_GET_SHORT_BE( p )                                   \
-          ((FT_Int16)( ( (FT_Int16)(FT_Char)(p)[0] <<  8 ) |   \
-                         (FT_Int16)(FT_Byte)(p)[1]         ) )
-
-#define FT_GET_USHORT_BE( p )                                   \
-          ((FT_Int16)( ( (FT_UInt16)(FT_Byte)(p)[0] <<  8 ) |   \
-                         (FT_UInt16)(FT_Byte)(p)[1]         ) )
-
-#define FT_GET_OFF3_BE( p )                                      \
-          ( (FT_Int32) ( ( (FT_Int32)(FT_Char)(p)[0] << 16 ) |   \
-                         ( (FT_Int32)(FT_Byte)(p)[1] <<  8 ) |   \
-                           (FT_Int32)(FT_Byte)(p)[2]         ) )
-
-#define FT_GET_UOFF3_BE( p )                                      \
-          ( (FT_Int32) ( ( (FT_UInt32)(FT_Byte)(p)[0] << 16 ) |   \
-                         ( (FT_UInt32)(FT_Byte)(p)[1] <<  8 ) |   \
-                           (FT_UInt32)(FT_Byte)(p)[2]         ) )
-
-#define FT_GET_LONG_BE( p )                                      \
-          ( (FT_Int32) ( ( (FT_Int32)(FT_Char)(p)[0] << 24 ) |   \
-                         ( (FT_Int32)(FT_Byte)(p)[1] << 16 ) |   \
-                         ( (FT_Int32)(FT_Byte)(p)[2] <<  8 ) |   \
-                           (FT_Int32)(FT_Byte)(p)[3]         ) )
-
-#define FT_GET_ULONG_BE( p )                                      \
-          ( (FT_Int32) ( ( (FT_UInt32)(FT_Byte)(p)[0] << 24 ) |   \
-                         ( (FT_UInt32)(FT_Byte)(p)[1] << 16 ) |   \
-                         ( (FT_UInt32)(FT_Byte)(p)[2] <<  8 ) |   \
-                           (FT_UInt32)(FT_Byte)(p)[3]         ) )
-
-#define FT_GET_SHORT_LE( p )                                   \
-          ((FT_Int16)( ( (FT_Int16)(FT_Char)(p)[1] <<  8 ) |   \
-                         (FT_Int16)(FT_Byte)(p)[0]         ) )
-
-#define FT_GET_USHORT_LE( p )                                   \
-          ((FT_Int16)( ( (FT_UInt16)(FT_Byte)(p)[1] <<  8 ) |   \
-                         (FT_UInt16)(FT_Byte)(p)[0]         ) )
-
-#define FT_GET_OFF3_LE( p )                                      \
-          ( (FT_Int32) ( ( (FT_Int32)(FT_Char)(p)[2] << 16 ) |   \
-                         ( (FT_Int32)(FT_Byte)(p)[1] <<  8 ) |   \
-                           (FT_Int32)(FT_Byte)(p)[0]         ) )
-
-#define FT_GET_UOFF3_LE( p )                                      \
-          ( (FT_Int32) ( ( (FT_UInt32)(FT_Byte)(p)[2] << 16 ) |   \
-                         ( (FT_UInt32)(FT_Byte)(p)[1] <<  8 ) |   \
-                           (FT_UInt32)(FT_Byte)(p)[0]         ) )
-
-#define FT_GET_LONG_LE( p )                                      \
-          ( (FT_Int32) ( ( (FT_Int32)(FT_Char)(p)[3] << 24 ) |   \
-                         ( (FT_Int32)(FT_Byte)(p)[2] << 16 ) |   \
-                         ( (FT_Int32)(FT_Byte)(p)[1] <<  8 ) |   \
-                           (FT_Int32)(FT_Byte)(p)[0]         ) )
-
-#define FT_GET_ULONG_LE( p )                                      \
-          ( (FT_Int32) ( ( (FT_UInt32)(FT_Byte)(p)[3] << 24 ) |   \
-                         ( (FT_UInt32)(FT_Byte)(p)[2] << 16 ) |   \
-                         ( (FT_UInt32)(FT_Byte)(p)[1] <<  8 ) |   \
-                           (FT_UInt32)(FT_Byte)(p)[0]         ) )
+#define FT_PEEK_OFF3( p )  FT_INT32( FT_INT8_I32( p, 0, 16 ) | \
+                                     FT_BYTE_I32( p, 1,  8 ) | \
+                                     FT_BYTE_I32( p, 2,  0 ) )
 
+#define FT_PEEK_UOFF3( p )  FT_UINT32( FT_BYTE_U32( p, 0, 16 ) | \
+                                       FT_BYTE_U32( p, 1,  8 ) | \
+                                       FT_BYTE_U32( p, 2,  0 ) )
 
-#define NEXT_Char( buffer )          \
+#define FT_PEEK_SHORT_LE( p )  FT_INT16( FT_INT8_I16( p, 1, 8 ) | \
+                                         FT_BYTE_I16( p, 0, 0 ) )
+
+#define FT_PEEK_USHORT_LE( p )  FT_UINT16( FT_BYTE_U16( p, 1, 8 ) |  \
+                                           FT_BYTE_U16( p, 0, 0 ) )
+
+#define FT_PEEK_LONG_LE( p )  FT_INT32( FT_INT8_I32( p, 3, 24 ) | \
+                                        FT_BYTE_I32( p, 2, 16 ) | \
+                                        FT_BYTE_I32( p, 1,  8 ) | \
+                                        FT_BYTE_I32( p, 0,  0 ) )
+
+#define FT_PEEK_ULONG_LE( p )  FT_UINT32( FT_BYTE_U32( p, 3, 24 ) | \
+                                          FT_BYTE_U32( p, 2, 16 ) | \
+                                          FT_BYTE_U32( p, 1,  8 ) | \
+                                          FT_BYTE_U32( p, 0,  0 ) )
+
+#define FT_PEEK_OFF3_LE( p )  FT_INT32( FT_INT8_I32( p, 2, 16 ) | \
+                                        FT_BYTE_I32( p, 1,  8 ) | \
+                                        FT_BYTE_I32( p, 0,  0 ) )
+
+#define FT_PEEK_UOFF3_LE( p )  FT_UINT32( FT_BYTE_U32( p, 2, 16 ) | \
+                                          FT_BYTE_U32( p, 1,  8 ) | \
+                                          FT_BYTE_U32( p, 0,  0 ) )
+
+
+#define FT_NEXT_CHAR( buffer )       \
           ( (signed char)*buffer++ )
 
-#define NEXT_Byte( buffer )            \
+#define FT_NEXT_BYTE( buffer )         \
           ( (unsigned char)*buffer++ )
-
-#define NEXT_Short( buffer )                                        \
-          ( (short)( buffer += 2, FT_GET_SHORT_BE( buffer - 2 ) ) )
 
-#define NEXT_UShort( buffer )                                                 \
-          ( (unsigned short)( buffer += 2, FT_GET_USHORT_BE( buffer - 2 ) ) )
+#define FT_NEXT_SHORT( buffer )                                   \
+          ( (short)( buffer += 2, FT_PEEK_SHORT( buffer - 2 ) ) )
 
-#define NEXT_Offset( buffer )                                     \
-          ( (long)( buffer += 3, FT_GET_OFF3_BE( buffer - 3 ) ) )
+#define FT_NEXT_USHORT( buffer )                                            \
+          ( (unsigned short)( buffer += 2, FT_PEEK_USHORT( buffer - 2 ) ) )
 
-#define NEXT_UOffset( buffer )                                              \
-          ( (unsigned long)( buffer += 3, FT_GET_UOFF3_BE( buffer - 3 ) ) )
+#define FT_NEXT_OFF3( buffer )                                  \
+          ( (long)( buffer += 3, FT_PEEK_OFF3( buffer - 3 ) ) )
 
-#define NEXT_Long( buffer )                                       \
-          ( (long)( buffer += 4, FT_GET_LONG_BE( buffer - 4 ) ) )
+#define FT_NEXT_UOFF3( buffer )                                           \
+          ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3( buffer - 3 ) ) )
 
-#define NEXT_ULong( buffer )                                                \
-          ( (unsigned long)( buffer += 4, FT_GET_ULONG_BE( buffer - 4 ) ) )
+#define FT_NEXT_LONG( buffer )                                  \
+          ( (long)( buffer += 4, FT_PEEK_LONG( buffer - 4 ) ) )
 
+#define FT_NEXT_ULONG( buffer )                                           \
+          ( (unsigned long)( buffer += 4, FT_PEEK_ULONG( buffer - 4 ) ) )
 
-#define NEXT_ShortLE( buffer )                                      \
-          ( (short)( buffer += 2, FT_GET_SHORT_LE( buffer - 2 ) ) )
 
-#define NEXT_UShortLE( buffer )                                               \
-          ( (unsigned short)( buffer += 2, FT_GET_USHORT_LE( buffer - 2 ) ) )
+#define FT_NEXT_SHORT_LE( buffer )                                   \
+          ( (short)( buffer += 2, FT_PEEK_SHORT_LE( buffer - 2 ) ) )
 
-#define NEXT_OffsetLE( buffer )                                   \
-          ( (long)( buffer += 3, FT_GET_OFF3_LE( buffer - 3 ) ) )
+#define FT_NEXT_USHORT_LE( buffer )                                            \
+          ( (unsigned short)( buffer += 2, FT_PEEK_USHORT_LE( buffer - 2 ) ) )
 
-#define NEXT_UOffsetLE( buffer )                                            \
-          ( (unsigned long)( buffer += 3, FT_GET_UOFF3_LE( buffer - 3 ) ) )
+#define FT_NEXT_OFF3_LE( buffer )                                  \
+          ( (long)( buffer += 3, FT_PEEK_OFF3_LE( buffer - 3 ) ) )
 
+#define FT_NEXT_UOFF3_LE( buffer )                                           \
+          ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3_LE( buffer - 3 ) ) )
 
-#define NEXT_LongLE( buffer )                                     \
-          ( (long)( buffer += 4, FT_GET_LONG_LE( buffer - 4 ) ) )
+#define FT_NEXT_LONG_LE( buffer )                                  \
+          ( (long)( buffer += 4, FT_PEEK_LONG_LE( buffer - 4 ) ) )
 
-#define NEXT_ULongLE( buffer )                                              \
-          ( (unsigned long)( buffer += 4, FT_GET_ULONG_LE( buffer - 4 ) ) )
+#define FT_NEXT_ULONG_LE( buffer )                                           \
+          ( (unsigned long)( buffer += 4, FT_PEEK_ULONG_LE( buffer - 4 ) ) )
 
 
   /*************************************************************************/
@@ -256,176 +270,223 @@
   /*                                                                       */
 #define FT_GET_MACRO( func, type )        ( (type)func( stream ) )
 
-#define GET_Char()      FT_GET_MACRO( FT_Get_Char, FT_Char )
-#define GET_Byte()      FT_GET_MACRO( FT_Get_Char, FT_Byte )
-#define GET_Short()     FT_GET_MACRO( FT_Get_Short, FT_Short )
-#define GET_UShort()    FT_GET_MACRO( FT_Get_Short, FT_UShort )
-#define GET_Offset()    FT_GET_MACRO( FT_Get_Offset, FT_Long )
-#define GET_UOffset()   FT_GET_MACRO( FT_Get_Offset, FT_ULong )
-#define GET_Long()      FT_GET_MACRO( FT_Get_Long, FT_Long )
-#define GET_ULong()     FT_GET_MACRO( FT_Get_Long, FT_ULong )
-#define GET_Tag4()      FT_GET_MACRO( FT_Get_Long, FT_ULong )
-
-#define GET_ShortLE()   FT_GET_MACRO( FT_Get_ShortLE, FT_Short )
-#define GET_UShortLE()  FT_GET_MACRO( FT_Get_ShortLE, FT_UShort )
-#define GET_LongLE()    FT_GET_MACRO( FT_Get_LongLE, FT_Long )
-#define GET_ULongLE()   FT_GET_MACRO( FT_Get_LongLE, FT_ULong )
+#define FT_GET_CHAR()       FT_GET_MACRO( FT_Stream_GetChar, FT_Char )
+#define FT_GET_BYTE()       FT_GET_MACRO( FT_Stream_GetChar, FT_Byte )
+#define FT_GET_SHORT()      FT_GET_MACRO( FT_Stream_GetShort, FT_Short )
+#define FT_GET_USHORT()     FT_GET_MACRO( FT_Stream_GetShort, FT_UShort )
+#define FT_GET_OFF3()       FT_GET_MACRO( FT_Stream_GetOffset, FT_Long )
+#define FT_GET_UOFF3()      FT_GET_MACRO( FT_Stream_GetOffset, FT_ULong )
+#define FT_GET_LONG()       FT_GET_MACRO( FT_Stream_GetLong, FT_Long )
+#define FT_GET_ULONG()      FT_GET_MACRO( FT_Stream_GetLong, FT_ULong )
+#define FT_GET_TAG4()       FT_GET_MACRO( FT_Stream_GetLong, FT_ULong )
+
+#define FT_GET_SHORT_LE()   FT_GET_MACRO( FT_Stream_GetShortLE, FT_Short )
+#define FT_GET_USHORT_LE()  FT_GET_MACRO( FT_Stream_GetShortLE, FT_UShort )
+#define FT_GET_LONG_LE()    FT_GET_MACRO( FT_Stream_GetLongLE, FT_Long )
+#define FT_GET_ULONG_LE()   FT_GET_MACRO( FT_Stream_GetLongLE, FT_ULong )
 
 #define FT_READ_MACRO( func, type, var )        \
           ( var = (type)func( stream, &error ), \
             error != FT_Err_Ok )
+
+#define FT_READ_BYTE( var )       FT_READ_MACRO( FT_Stream_ReadChar, FT_Byte, var )
+#define FT_READ_CHAR( var )       FT_READ_MACRO( FT_Stream_ReadChar, FT_Char, var )
+#define FT_READ_SHORT( var )      FT_READ_MACRO( FT_Stream_ReadShort, FT_Short, var )
+#define FT_READ_USHORT( var )     FT_READ_MACRO( FT_Stream_ReadShort, FT_UShort, var )
+#define FT_READ_OFF3( var )       FT_READ_MACRO( FT_Stream_ReadOffset, FT_Long, var )
+#define FT_READ_UOFF3( var )      FT_READ_MACRO( FT_Stream_ReadOffset, FT_ULong, var )
+#define FT_READ_LONG( var )       FT_READ_MACRO( FT_Stream_ReadLong, FT_Long, var )
+#define FT_READ_ULONG( var )      FT_READ_MACRO( FT_Stream_ReadLong, FT_ULong, var )
+
+#define FT_READ_SHORT_LE( var )   FT_READ_MACRO( FT_Stream_ReadShortLE, FT_Short, var )
+#define FT_READ_USHORT_LE( var )  FT_READ_MACRO( FT_Stream_ReadShortLE, FT_UShort, var )
+#define FT_READ_LONG_LE( var )    FT_READ_MACRO( FT_Stream_ReadLongLE, FT_Long, var )
+#define FT_READ_ULONG_LE( var )   FT_READ_MACRO( FT_Stream_ReadLongLE, FT_ULong, var )
+
 
-#define READ_Byte( var )      FT_READ_MACRO( FT_Read_Char, FT_Byte, var )
-#define READ_Char( var )      FT_READ_MACRO( FT_Read_Char, FT_Char, var )
-#define READ_Short( var )     FT_READ_MACRO( FT_Read_Short, FT_Short, var )
-#define READ_UShort( var )    FT_READ_MACRO( FT_Read_Short, FT_UShort, var )
-#define READ_Offset( var )    FT_READ_MACRO( FT_Read_Offset, FT_Long, var )
-#define READ_UOffset( var )   FT_READ_MACRO( FT_Read_Offset, FT_ULong, var )
-#define READ_Long( var )      FT_READ_MACRO( FT_Read_Long, FT_Long, var )
-#define READ_ULong( var )     FT_READ_MACRO( FT_Read_Long, FT_ULong, var )
-
-#define READ_ShortLE( var )   FT_READ_MACRO( FT_Read_ShortLE, FT_Short, var )
-#define READ_UShortLE( var )  FT_READ_MACRO( FT_Read_ShortLE, FT_UShort, var )
-#define READ_LongLE( var )    FT_READ_MACRO( FT_Read_LongLE, FT_Long, var )
-#define READ_ULongLE( var )   FT_READ_MACRO( FT_Read_LongLE, FT_ULong, var )
+#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
 
+  /* initialize a stream for reading a regular system stream */
+  FT_EXPORT( FT_Error )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname );
 
+#endif /* FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */
+
+
+  /* initialize a stream for reading in-memory data */
+  FT_BASE( void )
+  FT_Stream_OpenMemory( FT_Stream       stream,
+                        const FT_Byte*  base,
+                        FT_ULong        size );
+
+  /* close a stream (does not destroy the stream structure) */
   FT_BASE( void )
-  FT_New_Memory_Stream( FT_Library  library,
-                        FT_Byte*    base,
-                        FT_ULong    size,
-                        FT_Stream   stream );
+  FT_Stream_Close( FT_Stream  stream );
+
 
+  /* seek within a stream. position is relative to start of stream */
   FT_BASE( FT_Error )
-  FT_Seek_Stream( FT_Stream  stream,
+  FT_Stream_Seek( FT_Stream  stream,
                   FT_ULong   pos );
 
+  /* skip bytes in a stream */
   FT_BASE( FT_Error )
-  FT_Skip_Stream( FT_Stream  stream,
+  FT_Stream_Skip( FT_Stream  stream,
                   FT_Long    distance );
 
+  /* return current stream position */
   FT_BASE( FT_Long )
   FT_Stream_Pos( FT_Stream  stream );
-
 
+  /* read bytes from a stream into a user-allocated buffer, returns an */
+  /* error if not all bytes could be read.                             */
   FT_BASE( FT_Error )
-  FT_Read_Stream( FT_Stream  stream,
+  FT_Stream_Read( FT_Stream  stream,
                   FT_Byte*   buffer,
                   FT_ULong   count );
 
+  /* read bytes from a stream at a given position */
   FT_BASE( FT_Error )
-  FT_Read_Stream_At( FT_Stream  stream,
-                     FT_ULong   pos,
-                     FT_Byte*   buffer,
-                     FT_ULong   count );
-
+  FT_Stream_ReadAt( FT_Stream  stream,
+                    FT_ULong   pos,
+                    FT_Byte*   buffer,
+                    FT_ULong   count );
+
+  /* Enter a frame of `count' consecutive bytes in a stream.  Returns an */
+  /* error if the frame could not be read/accessed.  The caller can use  */
+  /* the FT_Stream_Get_XXX functions to retrieve frame data without      */
+  /* error checks.                                                       */
+  /*                                                                     */
+  /* You must _always_ call FT_Stream_ExitFrame() once you have entered  */
+  /* a stream frame!                                                     */
+  /*                                                                     */
   FT_BASE( FT_Error )
-  FT_Access_Frame( FT_Stream  stream,
-                   FT_ULong   count );
+  FT_Stream_EnterFrame( FT_Stream  stream,
+                        FT_ULong   count );
 
+  /* exit a stream frame */
   FT_BASE( void )
-  FT_Forget_Frame( FT_Stream  stream );
+  FT_Stream_ExitFrame( FT_Stream  stream );
 
+  /* Extract a stream frame.  If the stream is disk-based, a heap block */
+  /* is allocated and the frame bytes are read into it.  If the stream  */
+  /* is memory-based, this function simply set a pointer to the data.   */
+  /*                                                                    */
+  /* Useful to optimize access to memory-based streams transparently.   */
+  /*                                                                    */
+  /* All extracted frames must be `freed` with a call to the function   */
+  /* FT_Stream_ReleaseFrame().                                          */
+  /*                                                                    */
   FT_BASE( FT_Error )
-  FT_Extract_Frame( FT_Stream  stream,
-                    FT_ULong   count,
-                    FT_Byte**  pbytes );
+  FT_Stream_ExtractFrame( FT_Stream  stream,
+                          FT_ULong   count,
+                          FT_Byte**  pbytes );
 
+  /* release an extract frame (see FT_Stream_ExtractFrame) */
   FT_BASE( void )
-  FT_Release_Frame( FT_Stream  stream,
-                    FT_Byte**  pbytes );
-
+  FT_Stream_ReleaseFrame( FT_Stream  stream,
+                          FT_Byte**  pbytes );
+             
+  /* read a byte from an entered frame */
   FT_BASE( FT_Char )
-  FT_Get_Char( FT_Stream  stream );
+  FT_Stream_GetChar( FT_Stream  stream );
 
+  /* read a 16-bit big-endian integer from an entered frame */
   FT_BASE( FT_Short )
-  FT_Get_Short( FT_Stream  stream );
+  FT_Stream_GetShort( FT_Stream  stream );
 
+  /* read a 24-bit big-endian integer from an entered frame */
   FT_BASE( FT_Long )
-  FT_Get_Offset( FT_Stream  stream );
+  FT_Stream_GetOffset( FT_Stream  stream );
 
+  /* read a 32-bit big-endian integer from an entered frame */
   FT_BASE( FT_Long )
-  FT_Get_Long( FT_Stream  stream );
+  FT_Stream_GetLong( FT_Stream  stream );
 
+  /* read a 16-bit little-endian integer from an entered frame */
   FT_BASE( FT_Short )
-  FT_Get_ShortLE( FT_Stream  stream );
+  FT_Stream_GetShortLE( FT_Stream  stream );
 
+  /* read a 32-bit little-endian integer from an entered frame */
   FT_BASE( FT_Long )
-  FT_Get_LongLE( FT_Stream  stream );
+  FT_Stream_GetLongLE( FT_Stream  stream );
 
 
+  /* read a byte from a stream */
   FT_BASE( FT_Char )
-  FT_Read_Char( FT_Stream  stream,
-                FT_Error*  error );
+  FT_Stream_ReadChar( FT_Stream  stream,
+                      FT_Error*  error );
 
+  /* read a 16-bit big-endian integer from a stream */
   FT_BASE( FT_Short )
-  FT_Read_Short( FT_Stream  stream,
-                 FT_Error*  error );
+  FT_Stream_ReadShort( FT_Stream  stream,
+                       FT_Error*  error );
 
+  /* read a 24-bit big-endian integer from a stream */
   FT_BASE( FT_Long )
-  FT_Read_Offset( FT_Stream  stream,
-                  FT_Error*  error );
+  FT_Stream_ReadOffset( FT_Stream  stream,
+                        FT_Error*  error );
 
+  /* read a 32-bit big-endian integer from a stream */
   FT_BASE( FT_Long )
-  FT_Read_Long( FT_Stream  stream,
-                FT_Error*  error );
+  FT_Stream_ReadLong( FT_Stream  stream,
+                      FT_Error*  error );
 
+  /* read a 16-bit little-endian integer from a stream */
   FT_BASE( FT_Short )
-  FT_Read_ShortLE( FT_Stream  stream,
-                   FT_Error*  error );
+  FT_Stream_ReadShortLE( FT_Stream  stream,
+                         FT_Error*  error );
 
+  /* read a 32-bit little-endian integer from a stream */
   FT_BASE( FT_Long )
-  FT_Read_LongLE( FT_Stream  stream,
-                  FT_Error*  error );
+  FT_Stream_ReadLongLE( FT_Stream  stream,
+                        FT_Error*  error );
 
+  /* Read a structure from a stream.  The structure must be described */
+  /* by an array of FT_Frame_Field records.                           */
   FT_BASE( FT_Error )
-  FT_Read_Fields( FT_Stream              stream,
-                  const FT_Frame_Field*  fields,
-                  void*                  structure );
-
-
-#define USE_Stream( resource, stream )                       \
-          FT_SET_ERROR( FT_Open_Stream( resource, stream ) )
-
-#define DONE_Stream( stream )      \
-          FT_Done_Stream( stream )
+  FT_Stream_ReadFields( FT_Stream              stream,
+                        const FT_Frame_Field*  fields,
+                        void*                  structure );
 
 
-#define ACCESS_Frame( size )                              \
-          FT_SET_ERROR( FT_Access_Frame( stream, size ) )
-
-#define FORGET_Frame()              \
-          FT_Forget_Frame( stream )
-
-#define EXTRACT_Frame( size, bytes )                              \
-          FT_SET_ERROR( FT_Extract_Frame( stream, size,           \
-                                          (FT_Byte**)&(bytes) ) )
-
-#define RELEASE_Frame( bytes )                            \
-          FT_Release_Frame( stream, (FT_Byte**)&(bytes) )
-
-#define FILE_Seek( position )                                \
-          FT_SET_ERROR( FT_Seek_Stream( stream, position ) )
+#define FT_STREAM_POS()           \
+          FT_Stream_Pos( stream )
 
-#define FILE_Skip( distance )                                \
-          FT_SET_ERROR( FT_Skip_Stream( stream, distance ) )
+#define FT_STREAM_SEEK( position )                           \
+          FT_SET_ERROR( FT_Stream_Seek( stream, position ) )
 
-#define FILE_Pos()                \
-          FT_Stream_Pos( stream )
+#define FT_STREAM_SKIP( distance )                           \
+          FT_SET_ERROR( FT_Stream_Skip( stream, distance ) )
 
-#define FILE_Read( buffer, count )                        \
-          FT_SET_ERROR( FT_Read_Stream( stream,           \
+#define FT_STREAM_READ( buffer, count )                   \
+          FT_SET_ERROR( FT_Stream_Read( stream,           \
                                         (FT_Byte*)buffer, \
                                         count ) )
 
-#define FILE_Read_At( position, buffer, count )              \
-          FT_SET_ERROR( FT_Read_Stream_At( stream,           \
+#define FT_STREAM_READ_AT( position, buffer, count )         \
+          FT_SET_ERROR( FT_Stream_ReadAt( stream,            \
                                            position,         \
                                            (FT_Byte*)buffer, \
                                            count ) )
+
+#define FT_STREAM_READ_FIELDS( fields, object )                          \
+          FT_SET_ERROR( FT_Stream_ReadFields( stream, fields, object ) )
+
+
+#define FT_FRAME_ENTER( size )                                 \
+          FT_SET_ERROR( FT_Stream_EnterFrame( stream, size ) )
+
+#define FT_FRAME_EXIT()                 \
+          FT_Stream_ExitFrame( stream )
+
+#define FT_FRAME_EXTRACT( size, bytes )                                 \
+          FT_SET_ERROR( FT_Stream_ExtractFrame( stream, size,           \
+                                                (FT_Byte**)&(bytes) ) )
 
-#define READ_Fields( fields, object )  \
-        ( ( error = FT_Read_Fields( stream, fields, object ) ) != FT_Err_Ok )
+#define FT_FRAME_RELEASE( bytes )                               \
+          FT_Stream_ReleaseFrame( stream, (FT_Byte**)&(bytes) )
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/fttrace.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/fttrace.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:43 2003
+++ xc/extras/freetype2/include/freetype/internal/fttrace.h	Thu Jun 20 04:16:10 2002
@@ -0,0 +1,106 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttrace.h                                                              */
+/*                                                                         */
+/*    Tracing handling (specification only).                               */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+/* definitions of trace levels for FreeType 2 */
+
+/* the first level must always be `trace_any' */
+FT_TRACE_DEF( any )
+
+/* base components */
+FT_TRACE_DEF( calc )      /* calculations            (ftcalc.c)   */
+FT_TRACE_DEF( memory )    /* memory manager          (ftobjs.c)   */
+FT_TRACE_DEF( stream )    /* stream manager          (ftstream.c) */
+FT_TRACE_DEF( io )        /* i/o interface           (ftsystem.c) */
+FT_TRACE_DEF( list )      /* list management         (ftlist.c)   */
+FT_TRACE_DEF( init )      /* initialization          (ftinit.c)   */
+FT_TRACE_DEF( objs )      /* base objects            (ftobjs.c)   */
+FT_TRACE_DEF( outline )   /* outline management      (ftoutln.c)  */
+FT_TRACE_DEF( glyph )     /* glyph management        (ftglyph.c)  */
+
+FT_TRACE_DEF( raster )    /* monochrome rasterizer   (ftraster.c) */
+FT_TRACE_DEF( smooth )    /* anti-aliasing raster    (ftgrays.c)  */
+FT_TRACE_DEF( mm )        /* MM interface            (ftmm.c)     */
+
+/* Cache sub-system */
+FT_TRACE_DEF( cache )     /* cache sub-system        (ftcache.c, etc..) */
+
+/* SFNT driver components */
+FT_TRACE_DEF( sfobjs )    /*  SFNT object handler     (sfobjs.c)   */
+FT_TRACE_DEF( ttcmap )    /* charmap handler         (ttcmap.c)    */
+FT_TRACE_DEF( ttload )    /* basic TrueType tables   (ttload.c)    */
+FT_TRACE_DEF( ttpost )    /* PS table processing     (ttpost.c)   */
+FT_TRACE_DEF( ttsbit )    /* TrueType sbit handling  (ttsbit.c)   */
+
+/* TrueType driver components */
+FT_TRACE_DEF( ttdriver )  /* TT font driver          (ttdriver.c) */
+FT_TRACE_DEF( ttgload )   /* TT glyph loader         (ttgload.c)  */
+FT_TRACE_DEF( ttinterp )  /* bytecode interpreter    (ttinterp.c) */
+FT_TRACE_DEF( ttobjs )    /* TT objects manager      (ttobjs.c)   */
+FT_TRACE_DEF( ttpload )   /* TT data/program loader  (ttpload.c)  */
+
+/* Type 1 driver components */
+FT_TRACE_DEF( t1driver )
+FT_TRACE_DEF( t1gload )
+FT_TRACE_DEF( t1hint )
+FT_TRACE_DEF( t1load )
+FT_TRACE_DEF( t1objs )
+FT_TRACE_DEF( t1parse )
+
+/* PostScript helper module `psaux' */
+FT_TRACE_DEF( t1decode )
+FT_TRACE_DEF( psobjs )
+
+/* PostScript hinting module `pshinter' */
+FT_TRACE_DEF( pshrec )
+FT_TRACE_DEF( pshalgo1 )
+FT_TRACE_DEF( pshalgo2 )
+
+/* Type 2 driver components */
+FT_TRACE_DEF( cffdriver )
+FT_TRACE_DEF( cffgload )
+FT_TRACE_DEF( cffload )
+FT_TRACE_DEF( cffobjs )
+FT_TRACE_DEF( cffparse )
+
+/* Type 42 driver component */
+FT_TRACE_DEF( t42 )
+
+/* CID driver components */
+FT_TRACE_DEF( cidafm )
+FT_TRACE_DEF( ciddriver )
+FT_TRACE_DEF( cidgload )
+FT_TRACE_DEF( cidload )
+FT_TRACE_DEF( cidobjs )
+FT_TRACE_DEF( cidparse )
+
+/* Windows fonts component */
+FT_TRACE_DEF( winfnt )
+
+/* PCF fonts components */
+FT_TRACE_DEF( pcfdriver )
+FT_TRACE_DEF( pcfread )
+
+/* BDF fonts component */
+FT_TRACE_DEF( bdfdriver )
+FT_TRACE_DEF( bdflib )
+
+/* PFR fonts component */
+FT_TRACE_DEF( pfr )
+
+
+/* END */
Index: xc/extras/freetype2/include/freetype/internal/internal.h
diff -u xc/extras/freetype2/include/freetype/internal/internal.h:1.7 xc/extras/freetype2/include/freetype/internal/internal.h:1.8
--- xc/extras/freetype2/include/freetype/internal/internal.h:1.7	Mon Jan 14 12:00:59 2002
+++ xc/extras/freetype2/include/freetype/internal/internal.h	Thu Jun 20 04:25:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Internal header files (specification only).                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -14,7 +14,7 @@
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
-/* $XFree86: xc/extras/freetype2/include/freetype/internal/internal.h,v 1.7 2002/01/14 17:00:59 keithp Exp $ */
+/* $XFree86: xc/extras/freetype2/include/freetype/internal/internal.h,v 1.8 2002/06/20 08:25:27 keithp Exp $ */
 
   /*************************************************************************/
   /*                                                                       */
@@ -32,13 +32,17 @@
 #define FT_INTERNAL_CALC_H                <freetype/internal/ftcalc.h>
 #define FT_INTERNAL_DRIVER_H              <freetype/internal/ftdriver.h>
 #define FT_INTERNAL_EXTEND_H              <freetype/internal/ftextend.h>
-
+#define FT_INTERNAL_TRACE_H               <freetype/internal/fttrace.h>
+#define FT_INTERNAL_GLYPH_LOADER_H        <freetype/internal/ftgloadr.h>
 #define FT_INTERNAL_SFNT_H                <freetype/internal/sfnt.h>
 
 #define FT_INTERNAL_TRUETYPE_TYPES_H      <freetype/internal/tttypes.h>
 #define FT_INTERNAL_TYPE1_TYPES_H         <freetype/internal/t1types.h>
+#define FT_INTERNAL_TYPE42_TYPES_H        <freetype/internal/t42types.h>
 #define FT_INTERNAL_CFF_TYPES_H           <freetype/internal/cfftypes.h>
 #define FT_INTERNAL_FNT_TYPES_H           <freetype/internal/fnttypes.h>
+#define FT_INTERNAL_BDF_TYPES_H           <freetype/internal/bdftypes.h>
+#define FT_INTERNAL_PCF_TYPES_H           <freetype/internal/pcftypes.h>
 
 #define FT_INTERNAL_POSTSCRIPT_NAMES_H    <freetype/internal/psnames.h>
 #define FT_INTERNAL_POSTSCRIPT_AUX_H      <freetype/internal/psaux.h>
Index: xc/extras/freetype2/include/freetype/internal/psaux.h
diff -u xc/extras/freetype2/include/freetype/internal/psaux.h:1.1.1.4 xc/extras/freetype2/include/freetype/internal/psaux.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/internal/psaux.h:1.1.1.4	Mon Jan 14 11:52:07 2002
+++ xc/extras/freetype2/include/freetype/internal/psaux.h	Thu Jun 20 04:16:10 2002
@@ -5,7 +5,7 @@
 /*    Auxiliary functions and data structures related to PostScript fonts  */
 /*    (specification).                                                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -38,13 +38,14 @@
   /*************************************************************************/
 
 
-  typedef struct PS_Table_  PS_Table;
+  typedef struct PS_TableRec_*              PS_Table;
+  typedef const struct PS_Table_FuncsRec_*  PS_Table_Funcs;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    PS_Table_Funcs                                                     */
+  /*    PS_Table_FuncsRec                                                  */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A set of function pointers to manage PS_Table objects.             */
@@ -58,32 +59,32 @@
   /*                                                                       */
   /*    table_release :: Releases table data, then finalizes it.           */
   /*                                                                       */
-  typedef struct  PS_Table_Funcs_
+  typedef struct  PS_Table_FuncsRec_
   {
     FT_Error
-    (*init)( PS_Table*  table,
+    (*init)( PS_Table   table,
              FT_Int     count,
              FT_Memory  memory );
 
     void
-    (*done)( PS_Table*  table );
+    (*done)( PS_Table  table );
 
     FT_Error
-    (*add)( PS_Table*  table,
+    (*add)( PS_Table   table,
             FT_Int     index,
             void*      object,
             FT_Int     length );
 
     void
-    (*release)( PS_Table*  table );
+    (*release)( PS_Table  table );
 
-  } PS_Table_Funcs;
+  } PS_Table_FuncsRec;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    PS_Table                                                           */
+  /*    PS_TableRec                                                        */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A PS_Table is a simple object used to store an array of objects in */
@@ -112,22 +113,22 @@
   /*                                                                       */
   /*    funcs     :: A table of method pointers for this object.           */
   /*                                                                       */
-  struct  PS_Table_
+  typedef struct  PS_TableRec_
   {
-    FT_Byte*        block;          /* current memory block           */
-    FT_Offset       cursor;         /* current cursor in memory block */
-    FT_Offset       capacity;       /* current size of memory block   */
-    FT_Long         init;
-
-    FT_Int          max_elems;
-    FT_Int          num_elems;
-    FT_Byte**       elements;       /* addresses of table elements */
-    FT_Int*         lengths;        /* lengths of table elements   */
+    FT_Byte*           block;          /* current memory block           */
+    FT_Offset          cursor;         /* current cursor in memory block */
+    FT_Offset          capacity;       /* current size of memory block   */
+    FT_Long            init;
+
+    FT_Int             max_elems;
+    FT_Int             num_elems;
+    FT_Byte**          elements;       /* addresses of table elements */
+    FT_Int*            lengths;        /* lengths of table elements   */
 
-    FT_Memory       memory;
-    PS_Table_Funcs  funcs;
+    FT_Memory          memory;
+    PS_Table_FuncsRec  funcs;
 
-  };
+  } PS_TableRec;
 
 
   /*************************************************************************/
@@ -137,82 +138,88 @@
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
+
+  typedef struct PS_ParserRec_*  PS_Parser;
 
-  typedef struct T1_Parser_  T1_Parser;
+  typedef struct T1_TokenRec_*   T1_Token;
+  
+  typedef struct T1_FieldRec_*   T1_Field;
 
+  
   /* simple enumeration type used to identify token types */
-  typedef enum  T1_Token_Type_
+  typedef enum  T1_TokenType_
   {
-    t1_token_none = 0,
-    t1_token_any,
-    t1_token_string,
-    t1_token_array,
+    T1_TOKEN_TYPE_NONE = 0,
+    T1_TOKEN_TYPE_ANY,
+    T1_TOKEN_TYPE_STRING,
+    T1_TOKEN_TYPE_ARRAY,
 
     /* do not remove */
-    t1_token_max
+    T1_TOKEN_TYPE_MAX
 
-  } T1_Token_Type;
+  } T1_TokenType;
 
 
   /* a simple structure used to identify tokens */
-  typedef struct  T1_Token_
+  typedef struct  T1_TokenRec_
   {
-    FT_Byte*       start;   /* first character of token in input stream */
-    FT_Byte*       limit;   /* first character after the token          */
-    T1_Token_Type  type;    /* type of token                            */
+    FT_Byte*      start;   /* first character of token in input stream */
+    FT_Byte*      limit;   /* first character after the token          */
+    T1_TokenType  type;    /* type of token                            */
 
-  } T1_Token;
+  } T1_TokenRec;
 
 
   /* enumeration type used to identify object fields */
-  typedef enum  T1_Field_Type_
+  typedef enum  T1_FieldType_
   {
-    t1_field_none = 0,
-    t1_field_bool,
-    t1_field_integer,
-    t1_field_fixed,
-    t1_field_string,
-    t1_field_integer_array,
-    t1_field_fixed_array,
-    t1_field_callback,
+    T1_FIELD_TYPE_NONE = 0,
+    T1_FIELD_TYPE_BOOL,
+    T1_FIELD_TYPE_INTEGER,
+    T1_FIELD_TYPE_FIXED,
+    T1_FIELD_TYPE_STRING,
+    T1_FIELD_TYPE_INTEGER_ARRAY,
+    T1_FIELD_TYPE_FIXED_ARRAY,
+    T1_FIELD_TYPE_CALLBACK,
 
     /* do not remove */
-    t1_field_max
+    T1_FIELD_TYPE_MAX
+
+  } T1_FieldType;
 
-  } T1_Field_Type;
 
-  typedef enum  T1_Field_Location_
+  typedef enum  T1_FieldLocation_
   {
-    t1_field_cid_info,
-    t1_field_font_dict,
-    t1_field_font_info,
-    t1_field_private,
+    T1_FIELD_LOCATION_CID_INFO,
+    T1_FIELD_LOCATION_FONT_DICT,
+    T1_FIELD_LOCATION_FONT_INFO,
+    T1_FIELD_LOCATION_PRIVATE,
 
     /* do not remove */
-    t1_field_location_max
+    T1_FIELD_LOCATION_MAX
 
-  } T1_Field_Location;
+  } T1_FieldLocation;
 
 
   typedef void
-  (*T1_Field_Parser)( FT_Face     face,
-                      FT_Pointer  parser );
+  (*T1_Field_ParseFunc)( FT_Face     face,
+                         FT_Pointer  parser );
 
 
   /* structure type used to model object fields */
-  typedef struct  T1_Field_
+  typedef struct  T1_FieldRec_
   {
-    const char*        ident;        /* field identifier               */
-    T1_Field_Location  location;
-    T1_Field_Type      type;         /* type of field                  */
-    T1_Field_Parser    reader;
-    FT_UInt            offset;       /* offset of field in object      */
-    FT_Byte            size;         /* size of field in bytes         */
-    FT_UInt            array_max;    /* maximal number of elements for */
-                                     /* array                          */
-    FT_UInt            count_offset; /* offset of element count for    */
-                                     /* arrays                         */
-  } T1_Field;
+    const char*         ident;        /* field identifier               */
+    T1_FieldLocation    location;
+    T1_FieldType        type;         /* type of field                  */
+    T1_Field_ParseFunc  reader;
+    FT_UInt             offset;       /* offset of field in object      */
+    FT_Byte             size;         /* size of field in bytes         */
+    FT_UInt             array_max;    /* maximal number of elements for */
+                                      /* array                          */
+    FT_UInt             count_offset; /* offset of element count for    */
+                                      /* arrays                         */
+  } T1_FieldRec;
 
 
 #define T1_NEW_SIMPLE_FIELD( _ident, _type, _fname ) \
@@ -224,12 +231,12 @@
             0, 0                                     \
           },
 
-#define T1_NEW_CALLBACK_FIELD( _ident, _reader ) \
-          {                                      \
-            _ident, T1CODE, t1_field_callback,   \
-            (T1_Field_Parser)_reader,            \
-            0, 0,                                \
-            0, 0                                 \
+#define T1_NEW_CALLBACK_FIELD( _ident, _reader )    \
+          {                                         \
+            _ident, T1CODE, T1_FIELD_TYPE_CALLBACK, \
+            (T1_Field_ParseFunc)_reader,            \
+            0, 0,                                   \
+            0, 0                                    \
           },
 
 #define T1_NEW_TABLE_FIELD( _ident, _type, _fname, _max ) \
@@ -252,40 +259,38 @@
           },
 
 
-#define T1_FIELD_BOOL( _ident, _fname )                           \
-          T1_NEW_SIMPLE_FIELD( _ident, t1_field_bool, _fname )
+#define T1_FIELD_TYPE_BOOL( _ident, _fname )                        \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BOOL, _fname )
 
-#define T1_FIELD_NUM( _ident, _fname )                            \
-          T1_NEW_SIMPLE_FIELD( _ident, t1_field_integer, _fname )
+#define T1_FIELD_NUM( _ident, _fname )                                 \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER, _fname )
 
-#define T1_FIELD_FIXED( _ident, _fname )                          \
-          T1_NEW_SIMPLE_FIELD( _ident, t1_field_fixed, _fname )
+#define T1_FIELD_FIXED( _ident, _fname )                             \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED, _fname )
 
-#define T1_FIELD_STRING( _ident, _fname )                         \
-          T1_NEW_SIMPLE_FIELD( _ident, t1_field_string, _fname )
+#define T1_FIELD_STRING( _ident, _fname )                             \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_STRING, _fname )
 
-#define T1_FIELD_NUM_TABLE( _ident, _fname, _fmax )               \
-          T1_NEW_TABLE_FIELD( _ident, t1_field_integer_array,     \
-                               _fname, _fmax )
+#define T1_FIELD_NUM_TABLE( _ident, _fname, _fmax )                \
+          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
+                              _fname, _fmax )
 
-#define T1_FIELD_FIXED_TABLE( _ident, _fname, _fmax )             \
-          T1_NEW_TABLE_FIELD( _ident, t1_field_fixed_array,       \
-                               _fname, _fmax )
+#define T1_FIELD_FIXED_TABLE( _ident, _fname, _fmax )            \
+          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
+                              _fname, _fmax )
 
-#define T1_FIELD_NUM_TABLE2( _ident, _fname, _fmax )              \
-          T1_NEW_TABLE_FIELD2( _ident, t1_field_integer_array,    \
-                                _fname, _fmax )
+#define T1_FIELD_NUM_TABLE2( _ident, _fname, _fmax )                \
+          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
+                               _fname, _fmax )
 
 #define T1_FIELD_FIXED_TABLE2( _ident, _fname, _fmax )            \
-          T1_NEW_TABLE_FIELD2( _ident, t1_field_fixed_array,      \
-                                _fname, _fmax )
+          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
+                               _fname, _fmax )
 
-#define T1_FIELD_CALLBACK( _ident, _name )                        \
+#define T1_FIELD_CALLBACK( _ident, _name )       \
           T1_NEW_CALLBACK_FIELD( _ident, _name )
 
 
-
-
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
@@ -294,70 +299,72 @@
   /*************************************************************************/
   /*************************************************************************/
 
-  typedef struct  T1_Parser_Funcs_
+  typedef const struct PS_Parser_FuncsRec_*  PS_Parser_Funcs;
+
+  typedef struct  PS_Parser_FuncsRec_
   {
     void
-    (*init)( T1_Parser*  parser,
-             FT_Byte*    base,
-             FT_Byte*    limit,
-             FT_Memory   memory );
+    (*init)( PS_Parser  parser,
+             FT_Byte*   base,
+             FT_Byte*   limit,
+             FT_Memory  memory );
 
     void
-    (*done)( T1_Parser*  parser );
+    (*done)( PS_Parser  parser );
 
     void
-    (*skip_spaces)( T1_Parser*  parser );
+    (*skip_spaces)( PS_Parser  parser );
     void
-    (*skip_alpha)( T1_Parser*  parser );
+    (*skip_alpha)( PS_Parser  parser );
 
     FT_Long
-    (*to_int)( T1_Parser*  parser );
+    (*to_int)( PS_Parser  parser );
     FT_Fixed
-    (*to_fixed)( T1_Parser*  parser,
-                 FT_Int      power_ten );
+    (*to_fixed)( PS_Parser  parser,
+                 FT_Int     power_ten );
     FT_Int
-    (*to_coord_array)( T1_Parser*  parser,
-                       FT_Int      max_coords,
-                       FT_Short*   coords );
+    (*to_coord_array)( PS_Parser  parser,
+                       FT_Int     max_coords,
+                       FT_Short*  coords );
     FT_Int
-    (*to_fixed_array)( T1_Parser*  parser,
-                       FT_Int      max_values,
-                       FT_Fixed*   values,
-                       FT_Int      power_ten );
+    (*to_fixed_array)( PS_Parser  parser,
+                       FT_Int     max_values,
+                       FT_Fixed*  values,
+                       FT_Int     power_ten );
 
     void
-    (*to_token)( T1_Parser*  parser,
-                 T1_Token*   token );
-    void
-    (*to_token_array)( T1_Parser*  parser,
-                       T1_Token*   tokens,
-                       FT_UInt     max_tokens,
-                       FT_Int*     pnum_tokens );
+    (*to_token)( PS_Parser  parser,
+                 T1_Token   token );
+    void
+    (*to_token_array)( PS_Parser  parser,
+                       T1_Token   tokens,
+                       FT_UInt    max_tokens,
+                       FT_Int*    pnum_tokens );
 
     FT_Error
-    (*load_field)( T1_Parser*       parser,
-                   const T1_Field*  field,
-                   void**           objects,
-                   FT_UInt          max_objects,
-                   FT_ULong*        pflags );
+    (*load_field)( PS_Parser       parser,
+                   const T1_Field  field,
+                   void**          objects,
+                   FT_UInt         max_objects,
+                   FT_ULong*       pflags );
 
     FT_Error
-    (*load_field_table)( T1_Parser*       parser,
-                         const T1_Field*  field,
-                         void**           objects,
-                         FT_UInt          max_objects,
-                         FT_ULong*        pflags );
+    (*load_field_table)( PS_Parser       parser,
+                         const T1_Field  field,
+                         void**          objects,
+                         FT_UInt         max_objects,
+                         FT_ULong*       pflags );
 
-  } T1_Parser_Funcs;
+  } PS_Parser_FuncsRec;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    T1_Parser                                                          */
+  /*    PS_ParserRec                                                       */
   /*                                                                       */
   /* <Description>                                                         */
-  /*    A T1_Parser is an object used to parse a Type 1 font very quickly. */
+  /*    A PS_Parser is an object used to parse a Type 1 font very quickly. */
   /*                                                                       */
   /* <Fields>                                                              */
   /*    cursor :: The current position in the text.                        */
@@ -372,19 +379,19 @@
   /*                                                                       */
   /*    funcs  :: A table of functions for the parser.                     */
   /*                                                                       */
-  struct T1_Parser_
+  typedef struct  PS_ParserRec_
   {
-    FT_Byte*         cursor;
-    FT_Byte*         base;
-    FT_Byte*         limit;
-    FT_Error         error;
-    FT_Memory        memory;
-
-    T1_Parser_Funcs  funcs;
-  };
+    FT_Byte*   cursor;
+    FT_Byte*   base;
+    FT_Byte*   limit;
+    FT_Error   error;
+    FT_Memory  memory;
+
+    PS_Parser_FuncsRec  funcs;
+    
+  } PS_ParserRec;
 
 
-
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
@@ -394,47 +401,49 @@
   /*************************************************************************/
 
 
-  typedef struct T1_Builder_  T1_Builder;
+  typedef struct T1_BuilderRec_*  T1_Builder;
 
 
   typedef FT_Error
-  (*T1_Builder_Check_Points_Func)( T1_Builder*  builder,
-                                  FT_Int       count );
+  (*T1_Builder_Check_Points_Func)( T1_Builder  builder,
+                                   FT_Int      count );
 
   typedef void
-  (*T1_Builder_Add_Point_Func)( T1_Builder*  builder,
-                                FT_Pos       x,
-                                FT_Pos       y,
-                                FT_Byte      flag );
+  (*T1_Builder_Add_Point_Func)( T1_Builder  builder,
+                                FT_Pos      x,
+                                FT_Pos      y,
+                                FT_Byte     flag );
 
   typedef FT_Error
-  (*T1_Builder_Add_Point1_Func)( T1_Builder*  builder,
-                                 FT_Pos       x,
-                                 FT_Pos       y );
+  (*T1_Builder_Add_Point1_Func)( T1_Builder  builder,
+                                 FT_Pos      x,
+                                 FT_Pos      y );
 
   typedef FT_Error
-  (*T1_Builder_Add_Contour_Func)( T1_Builder*  builder );
+  (*T1_Builder_Add_Contour_Func)( T1_Builder  builder );
 
   typedef FT_Error
-  (*T1_Builder_Start_Point_Func)( T1_Builder*  builder,
-                                  FT_Pos       x,
-                                  FT_Pos       y );
+  (*T1_Builder_Start_Point_Func)( T1_Builder  builder,
+                                  FT_Pos      x,
+                                  FT_Pos      y );
 
   typedef void
-  (*T1_Builder_Close_Contour_Func)( T1_Builder*  builder );
+  (*T1_Builder_Close_Contour_Func)( T1_Builder  builder );
+
 
+  typedef const struct T1_Builder_FuncsRec_*  T1_Builder_Funcs;
 
-  typedef struct  T1_Builder_Funcs_
+  typedef struct  T1_Builder_FuncsRec_
   {
     void
-    (*init)( T1_Builder*   builder,
+    (*init)( T1_Builder    builder,
              FT_Face       face,
              FT_Size       size,
              FT_GlyphSlot  slot,
              FT_Bool       hinting );
 
     void
-    (*done)( T1_Builder*   builder );
+    (*done)( T1_Builder   builder );
 
     T1_Builder_Check_Points_Func   check_points;
     T1_Builder_Add_Point_Func      add_point;
@@ -443,14 +452,13 @@
     T1_Builder_Start_Point_Func    start_point;
     T1_Builder_Close_Contour_Func  close_contour;
 
-  } T1_Builder_Funcs;
+  } T1_Builder_FuncsRec;
 
 
-
   /*************************************************************************/
   /*                                                                       */
   /* <Structure>                                                           */
-  /*    T1_Builder                                                         */
+  /*    T1_BuilderRec                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*     A structure used during glyph loading to store its outline.       */
@@ -503,40 +511,41 @@
   /*                                                                       */
   /*    funcs        :: An array of function pointers for the builder.     */
   /*                                                                       */
-  struct  T1_Builder_
+  typedef struct  T1_BuilderRec_
   {
-    FT_Memory         memory;
-    FT_Face           face;
-    FT_GlyphSlot      glyph;
-    FT_GlyphLoader*   loader;
-    FT_Outline*       base;
-    FT_Outline*       current;
-
-    FT_Vector         last;
-
-    FT_Fixed          scale_x;
-    FT_Fixed          scale_y;
-
-    FT_Pos            pos_x;
-    FT_Pos            pos_y;
-
-    FT_Vector         left_bearing;
-    FT_Vector         advance;
-
-    FT_BBox           bbox;          /* bounding box */
-    FT_Bool           path_begun;
-    FT_Bool           load_points;
-    FT_Bool           no_recurse;
-    FT_Bool           shift;
-
-    FT_Error          error;         /* only used for memory errors */
-    FT_Bool           metrics_only;
-
-    void*             hints_funcs;    /* hinter-specific */
-    void*             hints_globals;  /* hinter-specific */
-
-    T1_Builder_Funcs  funcs;      
-  };
+    FT_Memory       memory;
+    FT_Face         face;
+    FT_GlyphSlot    glyph;
+    FT_GlyphLoader  loader;
+    FT_Outline*     base;
+    FT_Outline*     current;
+
+    FT_Vector       last;
+
+    FT_Fixed        scale_x;
+    FT_Fixed        scale_y;
+
+    FT_Pos          pos_x;
+    FT_Pos          pos_y;
+
+    FT_Vector       left_bearing;
+    FT_Vector       advance;
+
+    FT_BBox         bbox;          /* bounding box */
+    FT_Bool         path_begun;
+    FT_Bool         load_points;
+    FT_Bool         no_recurse;
+    FT_Bool         shift;
+
+    FT_Error        error;         /* only used for memory errors */
+    FT_Bool         metrics_only;
+
+    void*           hints_funcs;    /* hinter-specific */
+    void*           hints_globals;  /* hinter-specific */
+
+    T1_Builder_FuncsRec  funcs;
+    
+  } T1_BuilderRec;
 
 
   /*************************************************************************/
@@ -567,57 +576,58 @@
 #endif /* 0 */
 
 
-  typedef struct  T1_Decoder_Zone_
+  typedef struct  T1_Decoder_ZoneRec_
   {
     FT_Byte*  cursor;
     FT_Byte*  base;
     FT_Byte*  limit;
 
-  } T1_Decoder_Zone;
+  } T1_Decoder_ZoneRec, *T1_Decoder_Zone;
 
 
-  typedef struct T1_Decoder_        T1_Decoder;
-  typedef struct T1_Decoder_Funcs_  T1_Decoder_Funcs;
+  typedef struct T1_DecoderRec_*              T1_Decoder;
+  typedef const struct T1_Decoder_FuncsRec_*  T1_Decoder_Funcs;
 
 
   typedef FT_Error
-  (*T1_Decoder_Callback)( T1_Decoder*  decoder,
-                          FT_UInt      glyph_index );
+  (*T1_Decoder_Callback)( T1_Decoder  decoder,
+                          FT_UInt     glyph_index );
 
 
-  struct  T1_Decoder_Funcs_
+  typedef struct  T1_Decoder_FuncsRec_
   {
     FT_Error
-    (*init) ( T1_Decoder*          decoder,
-              FT_Face              face,
-              FT_Size              size,
-              FT_GlyphSlot         slot,
-              FT_Byte**            glyph_names,
-              T1_Blend*            blend,
-              FT_Bool              hinting,
-              T1_Decoder_Callback  callback );
+    (*init)( T1_Decoder           decoder,
+             FT_Face              face,
+             FT_Size              size,
+             FT_GlyphSlot         slot,
+             FT_Byte**            glyph_names,
+             PS_Blend             blend,
+             FT_Bool              hinting,
+             T1_Decoder_Callback  callback );
 
     void
-    (*done) ( T1_Decoder*  decoder );
+    (*done)( T1_Decoder  decoder );
 
     FT_Error
-    (*parse_charstrings)( T1_Decoder*  decoder,
-                          FT_Byte*     base,
-                          FT_UInt      len );
-  };
+    (*parse_charstrings)( T1_Decoder  decoder,
+                          FT_Byte*    base,
+                          FT_UInt     len );
+                          
+  } T1_Decoder_FuncsRec;
 
 
-  struct  T1_Decoder_
+  typedef struct  T1_DecoderRec_
   {
-    T1_Builder           builder;
+    T1_BuilderRec        builder;
 
     FT_Long              stack[T1_MAX_CHARSTRINGS_OPERANDS];
     FT_Long*             top;
 
-    T1_Decoder_Zone      zones[T1_MAX_SUBRS_CALLS + 1];
-    T1_Decoder_Zone*     zone;
+    T1_Decoder_ZoneRec   zones[T1_MAX_SUBRS_CALLS + 1];
+    T1_Decoder_Zone      zone;
 
-    PSNames_Interface*   psnames;      /* for seac */
+    PSNames_Service      psnames;      /* for seac */
     FT_UInt              num_glyphs;
     FT_Byte**            glyph_names;
 
@@ -633,35 +643,61 @@
     FT_Int               num_flex_vectors;
     FT_Vector            flex_vectors[7];
 
-    T1_Blend*            blend;       /* for multiple master support */
+    PS_Blend             blend;       /* for multiple master support */
 
     T1_Decoder_Callback  parse_callback;
-    T1_Decoder_Funcs     funcs;
-  };
+    T1_Decoder_FuncsRec  funcs;
+    
+  } T1_DecoderRec;
 
 
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
+  /*****                     TYPE1 CHARMAPS                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef const struct T1_CMap_ClassesRec_*  T1_CMap_Classes;
+
+  typedef struct T1_CMap_ClassesRec_
+  {
+    FT_CMap_Class  standard;
+    FT_CMap_Class  expert;
+    FT_CMap_Class  custom;
+    FT_CMap_Class  unicode;
+  
+  } T1_CMap_ClassesRec;
+  
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
   /*****                        PSAux Module Interface                 *****/
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
 
-  typedef struct  PSAux_Interface_
+  typedef struct  PSAux_ServiceRec_
   {
-    const PS_Table_Funcs*    ps_table_funcs;
-    const T1_Parser_Funcs*   t1_parser_funcs;
-    const T1_Builder_Funcs*  t1_builder_funcs;
-    const T1_Decoder_Funcs*  t1_decoder_funcs;
+    /* don't use `PS_Table_Funcs' and friends to avoid compiler warnings */
+    const PS_Table_FuncsRec*    ps_table_funcs;
+    const PS_Parser_FuncsRec*   ps_parser_funcs;
+    const T1_Builder_FuncsRec*  t1_builder_funcs;
+    const T1_Decoder_FuncsRec*  t1_decoder_funcs;
 
     void
     (*t1_decrypt)( FT_Byte*   buffer,
                    FT_Offset  length,
                    FT_UShort  seed );
+
+    T1_CMap_Classes  t1_cmap_classes;
 
-  } PSAux_Interface;
+  } PSAux_ServiceRec, *PSAux_Service;
 
+  /* backwards-compatible type definition */
+  typedef PSAux_ServiceRec   PSAux_Interface;
 
 FT_END_HEADER
 
Index: xc/extras/freetype2/include/freetype/internal/pshints.h
diff -u xc/extras/freetype2/include/freetype/internal/pshints.h:1.1.1.1 xc/extras/freetype2/include/freetype/internal/pshints.h:1.1.1.2
--- xc/extras/freetype2/include/freetype/internal/pshints.h:1.1.1.1	Mon Jan 14 11:52:07 2002
+++ xc/extras/freetype2/include/freetype/internal/pshints.h	Thu Jun 20 04:16:10 2002
@@ -6,7 +6,7 @@
 /*    recorders (specification only).  These are used to support native    */
 /*    T1/T2 hints in the "type1", "cid" and "cff" font drivers.            */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -25,7 +25,6 @@
 #include <ft2build.h>
 #include FT_FREETYPE_H
 #include FT_TYPE1_TABLES_H
-#include FT_INTERNAL_POSTSCRIPT_GLOBALS_H
 
 
 FT_BEGIN_HEADER
@@ -57,7 +56,7 @@
   (*PSH_Globals_DestroyFunc)( PSH_Globals  globals );
 
 
-  typedef struct PSH_Globals_FuncsRec_
+  typedef struct  PSH_Globals_FuncsRec_
   {
     PSH_Globals_NewFunc       create;
     PSH_Globals_SetScaleFunc  set_scale;
@@ -99,7 +98,7 @@
   /*      strange happened (e.g. memory shortage).                         */
   /*                                                                       */
   /*    The hints accumulated in the object can later be used by the       */
-  /*    Postscript hinter.                                                 */
+  /*    PostScript hinter.                                                 */
   /*                                                                       */
   typedef struct T1_HintsRec_*  T1_Hints;
 
@@ -216,6 +215,7 @@
   /*                                                                       */
   /* @input:                                                               */
   /*    hints     :: A handle to the Type 1 hints recorder.                */
+  /*                                                                       */
   /*    end_point :: The index of the last point in the input glyph in     */
   /*                 which the previously defined hints apply.             */
   /*                                                                       */
@@ -606,8 +606,10 @@
     PSH_Globals_Funcs  (*get_globals_funcs)( FT_Module  module );
     T1_Hints_Funcs     (*get_t1_funcs)     ( FT_Module  module );
     T2_Hints_Funcs     (*get_t2_funcs)     ( FT_Module  module );
+
+  } PSHinter_Interface;
 
-  } PSHinter_Interface, *PSHinter_InterfacePtr;
+  typedef PSHinter_Interface*  PSHinter_Service;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/psnames.h
diff -u xc/extras/freetype2/include/freetype/internal/psnames.h:1.1.1.3 xc/extras/freetype2/include/freetype/internal/psnames.h:1.1.1.5
--- xc/extras/freetype2/include/freetype/internal/psnames.h:1.1.1.3	Sun Dec 16 12:49:24 2001
+++ xc/extras/freetype2/include/freetype/internal/psnames.h	Thu Jun 20 04:16:10 2002
@@ -5,7 +5,7 @@
 /*    High-level interface for the `PSNames' module (in charge of          */
 /*    various functions related to Postscript glyph names conversion).     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -166,6 +166,10 @@
   (*PS_Lookup_Unicode_Func)( PS_Unicodes*  unicodes,
                              FT_UInt       unicode );
 
+  typedef FT_ULong
+  (*PS_Next_Unicode_Func)( PS_Unicodes*  unicodes,
+                           FT_ULong      unicode );
+
 
   /*************************************************************************/
   /*                                                                       */
@@ -221,7 +225,12 @@
     const unsigned short*      adobe_std_encoding;
     const unsigned short*      adobe_expert_encoding;
 
+    PS_Next_Unicode_Func       next_unicode;
+
   } PSNames_Interface;
+
+
+  typedef PSNames_Interface*  PSNames_Service;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/sfnt.h
diff -u xc/extras/freetype2/include/freetype/internal/sfnt.h:1.1.1.3 xc/extras/freetype2/include/freetype/internal/sfnt.h:1.1.1.4
--- xc/extras/freetype2/include/freetype/internal/sfnt.h:1.1.1.3	Sun Dec 16 12:49:24 2001
+++ xc/extras/freetype2/include/freetype/internal/sfnt.h	Thu Jun 20 04:16:10 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    High-level `sfnt' driver interface (specification).                  */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -127,13 +127,13 @@
 
   typedef FT_Module_Interface
   (*SFNT_Get_Interface_Func)( FT_Module    module,
-                              const char*  interface );
+                              const char*  func_interface );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    TT_Load_SFNT_Header_Func                                           */
+  /*    TT_Load_SFNT_HeaderRec_Func                                        */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Loads the header of a SFNT font file.  Supports collections.       */
@@ -162,10 +162,10 @@
   /*    values of `search_range', `entry_selector', and `range_shift'.     */
   /*                                                                       */
   typedef FT_Error
-  (*TT_Load_SFNT_Header_Func)( TT_Face       face,
-                               FT_Stream     stream,
-                               FT_Long       face_index,
-                               SFNT_Header*  sfnt );
+  (*TT_Load_SFNT_HeaderRec_Func)( TT_Face      face,
+                                  FT_Stream    stream,
+                                  FT_Long      face_index,
+                                  SFNT_Header  sfnt );
 
 
   /*************************************************************************/
@@ -192,9 +192,9 @@
   /*    TT_Load_Format_Tag().                                              */
   /*                                                                       */
   typedef FT_Error
-  (*TT_Load_Directory_Func)( TT_Face       face,
-                             FT_Stream     stream,
-                             SFNT_Header*  sfnt );
+  (*TT_Load_Directory_Func)( TT_Face      face,
+                             FT_Stream    stream,
+                             SFNT_Header  sfnt );
 
 
   /*************************************************************************/
@@ -278,13 +278,13 @@
   /*    The `map.buffer' field is always freed before the glyph is loaded. */
   /*                                                                       */
   typedef FT_Error
-  (*TT_Load_SBit_Image_Func)( TT_Face           face,
-                              FT_ULong          strike_index,
-                              FT_UInt           glyph_index,
-                              FT_UInt           load_flags,
-                              FT_Stream         stream,
-                              FT_Bitmap        *amap,
-                              TT_SBit_Metrics  *ametrics );
+  (*TT_Load_SBit_Image_Func)( TT_Face              face,
+                              FT_ULong             strike_index,
+                              FT_UInt              glyph_index,
+                              FT_UInt              load_flags,
+                              FT_Stream            stream,
+                              FT_Bitmap           *amap,
+                              TT_SBit_MetricsRec  *ametrics );
 
 
   /*************************************************************************/
@@ -326,7 +326,7 @@
   /*    Gets the PostScript glyph name of a glyph.                         */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    index  :: The glyph index.                                         */
+  /*    idx  :: The glyph index.                                           */
   /*                                                                       */
   /*    PSname :: The address of a string pointer.  Will be NULL in case   */
   /*              of error, otherwise it is a pointer to the glyph name.   */
@@ -338,7 +338,7 @@
   /*                                                                       */
   typedef FT_Error
   (*TT_Get_PS_Name_Func)( TT_Face      face,
-                          FT_UInt      index,
+                          FT_UInt      idx,
                           FT_String**  PSname );
 
 
@@ -391,9 +391,9 @@
   /*    released.                                                          */
   /*                                                                       */
   typedef FT_Error
-  (*TT_CharMap_Load_Func)( TT_Face        face,
-                           TT_CMapTable*  cmap,
-                           FT_Stream      input );
+  (*TT_CharMap_Load_Func)( TT_Face       face,
+                           TT_CMapTable  cmap,
+                           FT_Stream     input );
 
 
   /*************************************************************************/
@@ -413,8 +413,8 @@
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
   typedef FT_Error
-  (*TT_CharMap_Free_Func)( TT_Face        face,
-                           TT_CMapTable*  cmap );
+  (*TT_CharMap_Free_Func)( TT_Face       face,
+                           TT_CMapTable  cmap );
 
 
   /*************************************************************************/
@@ -471,55 +471,59 @@
   /*                                                                       */
   typedef struct  SFNT_Interface_
   {
-    TT_Goto_Table_Func        goto_table;
+    TT_Loader_GotoTableFunc      goto_table;
 
-    TT_Init_Face_Func         init_face;
-    TT_Load_Face_Func         load_face;
-    TT_Done_Face_Func         done_face;
-    SFNT_Get_Interface_Func   get_interface;
-
-    TT_Load_Any_Func          load_any;
-    TT_Load_SFNT_Header_Func  load_sfnt_header;
-    TT_Load_Directory_Func    load_directory;
+    TT_Init_Face_Func            init_face;
+    TT_Load_Face_Func            load_face;
+    TT_Done_Face_Func            done_face;
+    SFNT_Get_Interface_Func      get_interface;
+
+    TT_Load_Any_Func             load_any;
+    TT_Load_SFNT_HeaderRec_Func  load_sfnt_header;
+    TT_Load_Directory_Func       load_directory;
 
     /* these functions are called by `load_face' but they can also  */
     /* be called from external modules, if there is a need to do so */
-    TT_Load_Table_Func        load_header;
-    TT_Load_Metrics_Func      load_metrics;
-    TT_Load_Table_Func        load_charmaps;
-    TT_Load_Table_Func        load_max_profile;
-    TT_Load_Table_Func        load_os2;
-    TT_Load_Table_Func        load_psnames;
+    TT_Load_Table_Func           load_header;
+    TT_Load_Metrics_Func         load_metrics;
+    TT_Load_Table_Func           load_charmaps;
+    TT_Load_Table_Func           load_max_profile;
+    TT_Load_Table_Func           load_os2;
+    TT_Load_Table_Func           load_psnames;
 
-    TT_Load_Table_Func        load_names;
-    TT_Free_Table_Func        free_names;
+    TT_Load_Table_Func           load_names;
+    TT_Free_Table_Func           free_names;
 
     /* optional tables */
-    TT_Load_Table_Func        load_hdmx;
-    TT_Free_Table_Func        free_hdmx;
+    TT_Load_Table_Func           load_hdmx;
+    TT_Free_Table_Func           free_hdmx;
 
-    TT_Load_Table_Func        load_kerning;
-    TT_Load_Table_Func        load_gasp;
-    TT_Load_Table_Func        load_pclt;
+    TT_Load_Table_Func           load_kerning;
+    TT_Load_Table_Func           load_gasp;
+    TT_Load_Table_Func           load_pclt;
 
     /* see `ttload.h' */
-    TT_Load_Table_Func        load_bitmap_header;
+    TT_Load_Table_Func           load_bitmap_header;
 
     /* see `ttsbit.h' */
-    TT_Set_SBit_Strike_Func   set_sbit_strike;
-    TT_Load_Table_Func        load_sbits;
-    TT_Load_SBit_Image_Func   load_sbit_image;
-    TT_Free_Table_Func        free_sbits;
+    TT_Set_SBit_Strike_Func      set_sbit_strike;
+    TT_Load_Table_Func           load_sbits;
+    TT_Load_SBit_Image_Func      load_sbit_image;
+    TT_Free_Table_Func           free_sbits;
 
     /* see `ttpost.h' */
-    TT_Get_PS_Name_Func       get_psname;
-    TT_Free_Table_Func        free_psnames;
+    TT_Get_PS_Name_Func          get_psname;
+    TT_Free_Table_Func           free_psnames;
 
     /* see `ttcmap.h' */
-    TT_CharMap_Load_Func      load_charmap;
-    TT_CharMap_Free_Func      free_charmap;
+    TT_CharMap_Load_Func         load_charmap;
+    TT_CharMap_Free_Func         free_charmap;
 
   } SFNT_Interface;
+
+
+  /* transitional */
+  typedef SFNT_Interface*   SFNT_Service;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/include/freetype/internal/t1types.h
diff -u xc/extras/freetype2/include/freetype/internal/t1types.h:1.1.1.4 xc/extras/freetype2/include/freetype/internal/t1types.h:1.1.1.7
--- xc/extras/freetype2/include/freetype/internal/t1types.h:1.1.1.4	Mon Jan 14 11:52:07 2002
+++ xc/extras/freetype2/include/freetype/internal/t1types.h	Thu Jun 20 04:16:10 2002
@@ -5,7 +5,7 @@
 /*    Basic Type1/Type2 type definitions and interface (specification      */
 /*    only).                                                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -21,7 +21,7 @@
 #define __T1TYPES_H__
 
 
-#include<ft2build.h>
+#include <ft2build.h>
 #include FT_TYPE1_TABLES_H
 #include FT_INTERNAL_POSTSCRIPT_NAMES_H
 #include FT_INTERNAL_POSTSCRIPT_HINTS_H
@@ -46,7 +46,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    T1_Encoding                                                        */
+  /*    T1_EncodingRec                                                     */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure modeling a custom encoding.                            */
@@ -63,7 +63,7 @@
   /*                                                                       */
   /*    char_name  :: An array of corresponding glyph names.               */
   /*                                                                       */
-  typedef struct  T1_Encoding_
+  typedef struct  T1_EncodingRecRec_
   {
     FT_Int       num_chars;
     FT_Int       code_first;
@@ -72,32 +72,28 @@
     FT_UShort*   char_index;
     FT_String**  char_name;
 
-  } T1_Encoding;
+  } T1_EncodingRec, *T1_Encoding;
 
 
   typedef enum  T1_EncodingType_
   {
-    t1_encoding_none = 0,
-    t1_encoding_array,
-    t1_encoding_standard,
-    t1_encoding_expert
+    T1_ENCODING_TYPE_NONE = 0,
+    T1_ENCODING_TYPE_ARRAY,
+    T1_ENCODING_TYPE_STANDARD,
+    T1_ENCODING_TYPE_ISOLATIN1,
+    T1_ENCODING_TYPE_EXPERT
 
   } T1_EncodingType;
 
 
-  typedef struct  T1_Font_
+  typedef struct  T1_FontRec_
   {
-    /* font info dictionary */
-    T1_FontInfo      font_info;
+    PS_FontInfoRec   font_info;         /* font info dictionary */
+    PS_PrivateRec    private_dict;      /* private dictionary   */
+    FT_String*       font_name;         /* top-level dictionary */
 
-    /* private dictionary */
-    T1_Private       private_dict;
-
-    /* top-level dictionary */
-    FT_String*       font_name;
-
     T1_EncodingType  encoding_type;
-    T1_Encoding      encoding;
+    T1_EncodingRec   encoding;
 
     FT_Byte*         subrs_block;
     FT_Byte*         charstrings_block;
@@ -121,15 +117,15 @@
 
     FT_Int           stroke_width;
 
-  } T1_Font;
+  } T1_FontRec, *T1_Font;
 
 
-  typedef struct  CID_Subrs_
+  typedef struct  CID_SubrsRec_
   {
     FT_UInt    num_subrs;
     FT_Byte**  code;
 
-  } CID_Subrs;
+  } CID_SubrsRec, *CID_Subrs;
 
 
   /*************************************************************************/
@@ -163,34 +159,34 @@
   typedef struct  T1_FaceRec_
   {
     FT_FaceRec     root;
-    T1_Font        type1;
-    void*          psnames;
-    void*          psaux;
-    void*          afm_data;
+    T1_FontRec     type1;
+    const void*    psnames;
+    const void*    psaux;
+    const void*    afm_data;
     FT_CharMapRec  charmaprecs[2];
     FT_CharMap     charmaps[2];
     PS_Unicodes    unicode_map;
 
     /* support for Multiple Masters fonts */
-    T1_Blend*      blend;
+    PS_Blend       blend;
     
     /* since FT 2.1 - interface to PostScript hinter */
-    void*          pshinter;
+    const void*    pshinter;
 
   } T1_FaceRec;
 
 
   typedef struct  CID_FaceRec_
   {
-    FT_FaceRec  root;
-    void*       psnames;
-    void*       psaux;
-    CID_Info    cid;
-    void*       afm_data;
-    CID_Subrs*  subrs;
+    FT_FaceRec       root;
+    void*            psnames;
+    void*            psaux;
+    CID_FaceInfoRec  cid;
+    void*            afm_data;
+    CID_Subrs        subrs;
     
     /* since FT 2.1 - interface to PostScript hinter */
-    void*       pshinter;
+    void*            pshinter;
 
   } CID_FaceRec;
 
Index: xc/extras/freetype2/include/freetype/internal/t42types.h
diff -u /dev/null xc/extras/freetype2/include/freetype/internal/t42types.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:44 2003
+++ xc/extras/freetype2/include/freetype/internal/t42types.h	Thu Jun 20 04:16:10 2002
@@ -0,0 +1,85 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42types.h                                                             */
+/*                                                                         */
+/*    Type 42 font data types (specification only).                        */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42TYPES_H__
+#define __T42TYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPE1_TABLES_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  T42_FontRec_ 
+  {
+    /* font info dictionary */
+    PS_FontInfoRec   font_info; 
+
+    /* top-level dictionary */
+    FT_String*       font_name;
+
+    T1_EncodingType  encoding_type; 
+    T1_EncodingRec   encoding;
+
+    FT_Byte*         charstrings_block;
+    FT_Byte*         glyph_names_block;
+
+    FT_Int           num_glyphs;
+    FT_String**      glyph_names;       /* array of glyph names       */
+    FT_Byte**        charstrings;       /* array of glyph charstrings */
+    FT_Int*          charstrings_len;
+
+    FT_Byte          paint_type;
+    FT_Byte          font_type;
+    FT_Matrix        font_matrix; /* From FontMatrix field: a, b, c, d */
+    FT_Vector        font_offset; /* From FontMatrix field: tx, ty */
+    FT_BBox          font_bbox;
+
+    FT_Int           stroke_width;  
+
+  } T42_FontRec, *T42_Font;
+
+
+  typedef struct  T42_FaceRec_
+  {
+    FT_FaceRec     root;
+    T42_FontRec    type42;
+    const void*    psnames;
+    const void*    psaux;
+    const void*    afm_data;
+    FT_Byte*       ttf_data;
+    FT_ULong       ttf_size;
+    FT_Face        ttf_face;
+    FT_CharMapRec  charmaprecs[2];
+    FT_CharMap     charmaps[2];
+    PS_Unicodes    unicode_map;
+
+  } T42_FaceRec, *T42_Face;
+
+
+FT_END_HEADER
+
+#endif /* __T1TYPES_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/include/freetype/internal/tttypes.h
diff -u xc/extras/freetype2/include/freetype/internal/tttypes.h:1.1.1.5 xc/extras/freetype2/include/freetype/internal/tttypes.h:1.1.1.7
--- xc/extras/freetype2/include/freetype/internal/tttypes.h:1.1.1.5	Mon Jan 14 11:52:08 2002
+++ xc/extras/freetype2/include/freetype/internal/tttypes.h	Thu Jun 20 04:16:11 2002
@@ -5,7 +5,7 @@
 /*    Basic SFNT/TrueType type definitions and interface (specification    */
 /*    only).                                                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -45,7 +45,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TTC_Header                                                         */
+  /*    TTC_HeaderRec                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    TrueType collection header.  This table contains the offsets of    */
@@ -63,20 +63,20 @@
   /*                                                                       */
   /*    offsets :: The offsets of the font headers, one per face.          */
   /*                                                                       */
-  typedef struct  TTC_Header_
+  typedef struct  TTC_HeaderRec_
   {
     FT_ULong   tag;
     FT_Fixed   version;
     FT_Long    count;
     FT_ULong*  offsets;
 
-  } TTC_Header;
+  } TTC_HeaderRec;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    SFNT_Header                                                        */
+  /*    SFNT_HeaderRec                                                     */
   /*                                                                       */
   /* <Description>                                                         */
   /*    SFNT file format header.                                           */
@@ -86,13 +86,13 @@
   /*                                                                       */
   /*    num_tables     :: The number of tables in file.                    */
   /*                                                                       */
-  /*    search_range   :: Must be 16*(max power of 2 <= num_tables).       */
+  /*    search_range   :: Must be `16 * (max power of 2 <= num_tables)'.   */
   /*                                                                       */
-  /*    entry_selector :: Must be log2 of search_range/16.                 */
+  /*    entry_selector :: Must be log2 of `search_range / 16'.             */
   /*                                                                       */
-  /*    range_shift    :: Must be num_tables*16 - search_range.            */
+  /*    range_shift    :: Must be `num_tables * 16 - search_range'.        */
   /*                                                                       */
-  typedef struct  SFNT_Header_
+  typedef struct  SFNT_HeaderRec_
   {
     FT_ULong   format_tag;
     FT_UShort  num_tables;
@@ -100,13 +100,13 @@
     FT_UShort  entry_selector;
     FT_UShort  range_shift;
 
-  } SFNT_Header;
+  } SFNT_HeaderRec, *SFNT_Header;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_TableDir                                                        */
+  /*    TT_TableDirRec                                                     */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This structure models a TrueType table directory.  It is used to   */
@@ -126,7 +126,7 @@
   /* <Note>                                                                */
   /*    This structure is only used during font opening.                   */
   /*                                                                       */
-  typedef struct  TT_TableDir_
+  typedef struct  TT_TableDirRec_
   {
     FT_Fixed   version;        /* should be 0x10000 */
     FT_UShort  numTables;      /* number of tables  */
@@ -135,13 +135,13 @@
     FT_UShort  entrySelector;  /* for a dichotomy search in the   */
     FT_UShort  rangeShift;     /* directory.  We ignore them.     */
 
-  } TT_TableDir;
+  } TT_TableDirRec;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_Table                                                           */
+  /*    TT_TableRec                                                        */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This structure describes a given table of a TrueType font.         */
@@ -156,20 +156,20 @@
   /*                                                                       */
   /*    Length   :: The table length (in bytes).                           */
   /*                                                                       */
-  typedef struct  TT_Table_
+  typedef struct  TT_TableRec_
   {
     FT_ULong  Tag;        /*        table type */
     FT_ULong  CheckSum;   /*    table checksum */
     FT_ULong  Offset;     /* table file offset */
     FT_ULong  Length;     /*      table length */
 
-  } TT_Table;
+  } TT_TableRec, *TT_Table;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_CMapDir                                                         */
+  /*    TT_CMapDirRec                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This structure describes the directory of the `cmap' table,        */
@@ -183,18 +183,18 @@
   /* <Note>                                                                */
   /*    This structure is only used during font loading.                   */
   /*                                                                       */
-  typedef struct  TT_CMapDir_
+  typedef struct  TT_CMapDirRec_
   {
     FT_UShort  tableVersionNumber;
     FT_UShort  numCMaps;
 
-  } TT_CMapDir;
+  } TT_CMapDirRec, *TT_CMapDir;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_CMapDirEntry                                                    */
+  /*    TT_CMapDirEntryRec                                                 */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This structure describes a charmap in a TrueType font.             */
@@ -212,19 +212,19 @@
   /* <Note>                                                                */
   /*    This structure is only used during font loading.                   */
   /*                                                                       */
-  typedef struct  TT_CMapDirEntry_
+  typedef struct  TT_CMapDirEntryRec_
   {
     FT_UShort  platformID;
     FT_UShort  platformEncodingID;
     FT_Long    offset;
 
-  } TT_CMapDirEntry;
+  } TT_CMapDirEntryRec, *TT_CMapDirEntry;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_LongMetrics                                                     */
+  /*    TT_LongMetricsRec                                                  */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure modeling the long metrics of the `hmtx' and `vmtx'     */
@@ -235,17 +235,18 @@
   /*                                                                       */
   /*    bearing :: The left-side or top-side bearing for the glyph.        */
   /*                                                                       */
-  typedef struct  TT_LongMetrics_
+  typedef struct  TT_LongMetricsRec_
   {
     FT_UShort  advance;
     FT_Short   bearing;
 
-  } TT_LongMetrics;
+  } TT_LongMetricsRec, *TT_LongMetrics;
 
 
   /*************************************************************************/
   /*                                                                       */
-  /* <Type> TT_ShortMetrics                                                */
+  /* <Type>                                                                */
+  /*    TT_ShortMetrics                                                    */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A simple type to model the short metrics of the `hmtx' and `vmtx'  */
@@ -257,7 +258,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_NameRec                                                         */
+  /*    TT_NameEntryRec                                                    */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure modeling TrueType name records.  Name records are used */
@@ -281,27 +282,27 @@
   /*    string       :: A pointer to the string's bytes.  Note that these  */
   /*                    are usually UTF-16 encoded characters.             */
   /*                                                                       */
-  typedef struct  TT_NameRec_
+  typedef struct  TT_NameEntryRec_
   {
     FT_UShort  platformID;
     FT_UShort  encodingID;
     FT_UShort  languageID;
     FT_UShort  nameID;
     FT_UShort  stringLength;
-    FT_UShort  stringOffset;
+    FT_ULong   stringOffset;
 
     /* this last field is not defined in the spec */
     /* but used by the FreeType engine            */
 
     FT_Byte*   string;
 
-  } TT_NameRec;
+  } TT_NameEntryRec, *TT_NameEntry;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_NameTable                                                       */
+  /*    TT_NameTableRec                                                    */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure modeling the TrueType name table.                      */
@@ -316,17 +317,17 @@
   /*                                                                       */
   /*    names          :: An array of name records.                        */
   /*                                                                       */
-  /*    storage        :: The names storage area.                          */
+  /*    stream         :: the file's input stream.                         */
   /*                                                                       */
-  typedef struct  TT_NameTable_
+  typedef struct  TT_NameTableRec_
   {
-    FT_UShort    format;
-    FT_UShort    numNameRecords;
-    FT_UShort    storageOffset;
-    TT_NameRec*  names;
-    FT_Byte*     storage;
+    FT_UShort         format;
+    FT_UInt           numNameRecords;
+    FT_UInt           storageOffset;
+    TT_NameEntryRec*  names;
+    FT_Stream         stream;
 
-  } TT_NameTable;
+  } TT_NameTableRec, *TT_NameTable;
 
 
   /*************************************************************************/
@@ -345,7 +346,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_GaspRange                                                       */
+  /*    TT_GaspRangeRec                                                    */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A tiny structure used to model a gasp range according to the       */
@@ -357,12 +358,12 @@
   /*    gaspFlag :: A flag describing the grid-fitting and anti-aliasing   */
   /*                modes to be used.                                      */
   /*                                                                       */
-  typedef struct  TT_GaspRange_
+  typedef struct  TT_GaspRangeRec_
   {
     FT_UShort  maxPPEM;
     FT_UShort  gaspFlag;
 
-  } TT_GaspRange;
+  } TT_GaspRangeRec, *TT_GaspRange;
 
 
 #define TT_GASP_GRIDFIT  0x01
@@ -372,7 +373,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_Gasp                                                            */
+  /*    TT_GaspRec                                                         */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure modeling the TrueType `gasp' table used to specify     */
@@ -387,17 +388,17 @@
   /*                                                                       */
   typedef struct  TT_Gasp_
   {
-    FT_UShort      version;
-    FT_UShort      numRanges;
-    TT_GaspRange*  gaspRanges;
+    FT_UShort     version;
+    FT_UShort     numRanges;
+    TT_GaspRange  gaspRanges;
 
-  } TT_Gasp;
+  } TT_GaspRec;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_HdmxRec                                                         */
+  /*    TT_HdmxEntryRec                                                    */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A small structure used to model the pre-computed widths of a given */
@@ -410,19 +411,19 @@
   /*                                                                       */
   /*    widths    :: An array of widths.  Note: These are 8-bit bytes.     */
   /*                                                                       */
-  typedef struct  TT_HdmxRec_
+  typedef struct  TT_HdmxEntryRec_
   {
     FT_Byte   ppem;
     FT_Byte   max_width;
     FT_Byte*  widths;
 
-  } TT_HdmxRec;
+  } TT_HdmxEntryRec, *TT_HdmxEntry;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_Hdmx                                                            */
+  /*    TT_HdmxRec                                                         */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used to model the `hdmx' table, which contains         */
@@ -435,19 +436,19 @@
   /*                                                                       */
   /*    records     :: An array of hdmx records.                           */
   /*                                                                       */
-  typedef struct  TT_Hdmx_
+  typedef struct  TT_HdmxRec_
   {
-    FT_UShort    version;
-    FT_Short     num_records;
-    TT_HdmxRec*  records;
+    FT_UShort     version;
+    FT_Short      num_records;
+    TT_HdmxEntry  records;
 
-  } TT_Hdmx;
+  } TT_HdmxRec, *TT_Hdmx;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_Kern_0_Pair                                                     */
+  /*    TT_Kern0_PairRec                                                   */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used to model a kerning pair for the kerning table     */
@@ -462,13 +463,13 @@
   /*    value :: The kerning distance.  A positive value spaces the        */
   /*             glyphs, a negative one makes them closer.                 */
   /*                                                                       */
-  typedef struct  TT_Kern_0_Pair_
+  typedef struct  TT_Kern0_PairRec_
   {
     FT_UShort  left;   /* index of left  glyph in pair */
     FT_UShort  right;  /* index of right glyph in pair */
     FT_FWord   value;  /* kerning value                */
 
-  } TT_Kern_0_Pair;
+  } TT_Kern0_PairRec, *TT_Kern0_Pair;
 
 
   /*************************************************************************/
@@ -487,7 +488,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_SBit_Metrics                                                    */
+  /*    TT_SBit_MetricsRec                                                 */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used to hold the big metrics of a given glyph bitmap   */
@@ -511,7 +512,7 @@
   /*                                                                       */
   /*    vertAdvance  :: The vertical advance.                              */
   /*                                                                       */
-  typedef struct  TT_SBit_Metrics_
+  typedef struct  TT_SBit_MetricsRec_
   {
     FT_Byte  height;
     FT_Byte  width;
@@ -524,13 +525,13 @@
     FT_Char  vertBearingY;
     FT_Byte  vertAdvance;
 
-  } TT_SBit_Metrics;
+  } TT_SBit_MetricsRec, *TT_SBit_Metrics;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_SBit_Small_Metrics                                              */
+  /*    TT_SBit_SmallMetricsRec                                            */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used to hold the small metrics of a given glyph bitmap */
@@ -557,13 +558,13 @@
     FT_Char  bearingY;
     FT_Byte  advance;
 
-  } TT_SBit_Small_Metrics;
+  } TT_SBit_SmallMetricsRec, *TT_SBit_SmallMetrics;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_SBit_Line_Metrics                                               */
+  /*    TT_SBit_LineMetricsRec                                             */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used to describe the text line metrics of a given      */
@@ -611,7 +612,7 @@
   /*    pads                    :: Unused (to make the size of the record  */
   /*                               a multiple of 32 bits.                  */
   /*                                                                       */
-  typedef struct  TT_SBit_Line_Metrics_
+  typedef struct  TT_SBit_LineMetricsRec_
   {
     FT_Char  ascender;
     FT_Char  descender;
@@ -625,13 +626,13 @@
     FT_Char  min_after_BL;
     FT_Char  pads[2];
 
-  } TT_SBit_Line_Metrics;
+  } TT_SBit_LineMetricsRec, *TT_SBit_LineMetrics;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_SBit_Range                                                      */
+  /*    TT_SBit_RangeRec                                                   */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A TrueType/OpenType subIndexTable as defined in the `EBLC'         */
@@ -665,31 +666,31 @@
   /*    table_offset  :: The offset of the index table in the `EBLC'       */
   /*                     table.  Only used during strike loading.          */
   /*                                                                       */
-  typedef struct  TT_SBit_Range
+  typedef struct  TT_SBit_RangeRec
   {
-    FT_UShort        first_glyph;
-    FT_UShort        last_glyph;
+    FT_UShort           first_glyph;
+    FT_UShort           last_glyph;
 
-    FT_UShort        index_format;
-    FT_UShort        image_format;
-    FT_ULong         image_offset;
+    FT_UShort           index_format;
+    FT_UShort           image_format;
+    FT_ULong            image_offset;
 
-    FT_ULong         image_size;
-    TT_SBit_Metrics  metrics;
-    FT_ULong         num_glyphs;
+    FT_ULong            image_size;
+    TT_SBit_MetricsRec  metrics;
+    FT_ULong            num_glyphs;
 
-    FT_ULong*        glyph_offsets;
-    FT_UShort*       glyph_codes;
+    FT_ULong*           glyph_offsets;
+    FT_UShort*          glyph_codes;
 
-    FT_ULong         table_offset;
+    FT_ULong            table_offset;
 
-  } TT_SBit_Range;
+  } TT_SBit_RangeRec, *TT_SBit_Range;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_SBit_Strike                                                     */
+  /*    TT_SBit_StrikeRec                                                  */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used describe a given bitmap strike in the `EBLC'      */
@@ -729,33 +730,33 @@
   /*                         http://fonts.apple.com/                       */
   /*                                TTRefMan/RM06/Chap6bloc.html           */
   /*                                                                       */
-  typedef struct  TT_SBit_Strike_
+  typedef struct  TT_SBit_StrikeRec_
   {
-    FT_Int                num_ranges;
-    TT_SBit_Range*        sbit_ranges;
-    FT_ULong              ranges_offset;
+    FT_Int                  num_ranges;
+    TT_SBit_Range           sbit_ranges;
+    FT_ULong                ranges_offset;
 
-    FT_ULong              color_ref;
+    FT_ULong                color_ref;
 
-    TT_SBit_Line_Metrics  hori;
-    TT_SBit_Line_Metrics  vert;
+    TT_SBit_LineMetricsRec  hori;
+    TT_SBit_LineMetricsRec  vert;
 
-    FT_UShort             start_glyph;
-    FT_UShort             end_glyph;
+    FT_UShort               start_glyph;
+    FT_UShort               end_glyph;
 
-    FT_Byte               x_ppem;
-    FT_Byte               y_ppem;
+    FT_Byte                 x_ppem;
+    FT_Byte                 y_ppem;
 
-    FT_Byte               bit_depth;
-    FT_Char               flags;
+    FT_Byte                 bit_depth;
+    FT_Char                 flags;
 
-  } TT_SBit_Strike;
+  } TT_SBit_StrikeRec, *TT_SBit_Strike;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_SBit_Component                                                  */
+  /*    TT_SBit_ComponentRec                                               */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A simple structure to describe a compound sbit element.            */
@@ -767,19 +768,19 @@
   /*                                                                       */
   /*    y_offset   :: The element's top bearing.                           */
   /*                                                                       */
-  typedef struct  TT_SBit_Component_
+  typedef struct  TT_SBit_ComponentRec_
   {
     FT_UShort  glyph_code;
     FT_Char    x_offset;
     FT_Char    y_offset;
 
-  } TT_SBit_Component;
+  } TT_SBit_ComponentRec, *TT_SBit_Component;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_SBit_Scale                                                      */
+  /*    TT_SBit_ScaleRec                                                   */
   /*                                                                       */
   /* <Description>                                                         */
   /*    A structure used describe a given bitmap scaling table, as defined */
@@ -798,18 +799,18 @@
   /*                                                                       */
   /*    y_ppem_substitute :: Substitution y_ppem value.                    */
   /*                                                                       */
-  typedef struct  TT_SBit_Scale_
+  typedef struct  TT_SBit_ScaleRec_
   {
-    TT_SBit_Line_Metrics  hori;
-    TT_SBit_Line_Metrics  vert;
+    TT_SBit_LineMetricsRec  hori;
+    TT_SBit_LineMetricsRec  vert;
 
-    FT_Byte               x_ppem;
-    FT_Byte               y_ppem;
+    FT_Byte                 x_ppem;
+    FT_Byte                 y_ppem;
 
-    FT_Byte               x_ppem_substitute;
-    FT_Byte               y_ppem_substitute;
+    FT_Byte                 x_ppem_substitute;
+    FT_Byte                 y_ppem_substitute;
 
-  } TT_SBit_Scale;
+  } TT_SBit_ScaleRec, *TT_SBit_Scale;
 
 
   /*************************************************************************/
@@ -828,7 +829,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_Post_20                                                         */
+  /*    TT_Post_20Rec                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Postscript names sub-table, format 2.0.  Stores the PS name of     */
@@ -843,20 +844,20 @@
   /*                                                                       */
   /*    glyph_names   :: The PS names not in Mac Encoding.                 */
   /*                                                                       */
-  typedef struct  TT_Post_20_
+  typedef struct  TT_Post_20Rec_
   {
     FT_UShort   num_glyphs;
     FT_UShort   num_names;
     FT_UShort*  glyph_indices;
     FT_Char**   glyph_names;
 
-  } TT_Post_20;
+  } TT_Post_20Rec, *TT_Post_20;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_Post_25                                                         */
+  /*    TT_Post_25Rec                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Postscript names sub-table, format 2.5.  Stores the PS name of     */
@@ -873,13 +874,13 @@
     FT_UShort  num_glyphs;
     FT_Char*   offsets;
 
-  } TT_Post_25;
+  } TT_Post_25Rec, *TT_Post_25;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Struct>                                                              */
-  /*    TT_Post_Names                                                      */
+  /*    TT_Post_NamesRec                                                   */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Postscript names table, either format 2.0 or 2.5.                  */
@@ -891,18 +892,18 @@
   /*                                                                       */
   /*    format_25 :: The sub-table used for format 2.5.                    */
   /*                                                                       */
-  typedef struct  TT_Post_Names_
+  typedef struct  TT_Post_NamesRec_
   {
-    FT_Bool       loaded;
+    FT_Bool  loaded;
 
     union
     {
-      TT_Post_20  format_20;
-      TT_Post_25  format_25;
+      TT_Post_20Rec  format_20;
+      TT_Post_25Rec  format_25;
 
     } names;
 
-  } TT_Post_Names;
+  } TT_Post_NamesRec, *TT_Post_Names;
 
 
   /*************************************************************************/
@@ -926,34 +927,32 @@
 
     FT_Byte*  glyphIdArray;
 
-  } TT_CMap0;
+  } TT_CMap0Rec, *TT_CMap0;
 
 
   /* format 2 */
 
-  typedef struct  TT_CMap2SubHeader_
+  typedef struct  TT_CMap2SubHeaderRec_
   {
     FT_UShort  firstCode;      /* first valid low byte         */
     FT_UShort  entryCount;     /* number of valid low bytes    */
     FT_Short   idDelta;        /* delta value to glyphIndex    */
     FT_UShort  idRangeOffset;  /* offset from here to 1st code */
 
-  } TT_CMap2SubHeader;
+  } TT_CMap2SubHeaderRec, *TT_CMap2SubHeader;
 
 
-  typedef struct  TT_CMap2_
+  typedef struct  TT_CMap2Rec_
   {
     FT_ULong            language;     /* for Mac fonts (originally ushort) */
 
-    FT_UShort*          subHeaderKeys;
-    /* high byte mapping table            */
-    /* value = subHeader index * 8        */
-
-    TT_CMap2SubHeader*  subHeaders;
+    FT_UShort*          subHeaderKeys;  /* high byte mapping table     */
+                                        /* value = subHeader index * 8 */
+    TT_CMap2SubHeader   subHeaders;
     FT_UShort*          glyphIdArray;
     FT_UShort           numGlyphId;   /* control value */
 
-  } TT_CMap2;
+  } TT_CMap2Rec, *TT_CMap2;
 
 
   /* format 4 */
@@ -965,25 +964,25 @@
     FT_Short   idDelta;
     FT_UShort  idRangeOffset;
 
-  } TT_CMap4Segment;
+  } TT_CMap4SegmentRec, *TT_CMap4Segment;
 
 
-  typedef struct  TT_CMap4_
+  typedef struct  TT_CMap4Rec_
   {
-    FT_ULong          language;       /* for Mac fonts (originally ushort) */
+    FT_ULong         language;       /* for Mac fonts (originally ushort) */
 
-    FT_UShort         segCountX2;     /* number of segments * 2            */
-    FT_UShort         searchRange;    /* these parameters can be used      */
-    FT_UShort         entrySelector;  /* for a binary search               */
-    FT_UShort         rangeShift;
+    FT_UShort        segCountX2;     /* number of segments * 2            */
+    FT_UShort        searchRange;    /* these parameters can be used      */
+    FT_UShort        entrySelector;  /* for a binary search               */
+    FT_UShort        rangeShift;
 
-    TT_CMap4Segment*  segments;
-    FT_UShort*        glyphIdArray;
-    FT_UShort         numGlyphId;    /* control value */
+    TT_CMap4Segment  segments;
+    FT_UShort*       glyphIdArray;
+    FT_UShort        numGlyphId;     /* control value */
 
-    TT_CMap4Segment*  last_segment;  /* last used segment; this is a small  */
+    TT_CMap4Segment  last_segment;   /* last used segment; this is a small  */
                                      /* cache to potentially increase speed */
-  } TT_CMap4;
+  } TT_CMap4Rec, *TT_CMap4;
 
 
   /* format 6 */
@@ -997,18 +996,18 @@
 
     FT_UShort*  glyphIdArray;
 
-  } TT_CMap6;
+  } TT_CMap6Rec, *TT_CMap6;
 
 
   /* auxiliary table for format 8 and 12 */
 
-  typedef struct  TT_CMapGroup_
+  typedef struct  TT_CMapGroupRec_
   {
     FT_ULong  startCharCode;
     FT_ULong  endCharCode;
     FT_ULong  startGlyphID;
 
-  } TT_CMapGroup;
+  } TT_CMapGroupRec, *TT_CMapGroup;
 
 
   /* FreeType handles format 8 and 12 identically.  It is not necessary to
@@ -1016,21 +1015,21 @@
      for input character codes -- converting Unicode surrogates to 32bit
      character codes must be done by the application.                      */
 
-  typedef struct  TT_CMap8_12_
+  typedef struct  TT_CMap8_12Rec_
   {
-    FT_ULong       language;        /* for Mac fonts */
+    FT_ULong      language;        /* for Mac fonts */
 
-    FT_ULong       nGroups;
-    TT_CMapGroup*  groups;
+    FT_ULong      nGroups;
+    TT_CMapGroup  groups;
 
-    TT_CMapGroup*  last_group;      /* last used group; this is a small    */
-                                    /* cache to potentially increase speed */
-  } TT_CMap8_12;
+    TT_CMapGroup  last_group;      /* last used group; this is a small    */
+                                   /* cache to potentially increase speed */
+  } TT_CMap8_12Rec, *TT_CMap8_12;
 
 
   /* format 10 */
 
-  typedef struct  TT_CMap10_
+  typedef struct  TT_CMap10Rec_
   {
     FT_ULong    language;           /* for Mac fonts */
 
@@ -1039,19 +1038,23 @@
 
     FT_UShort*  glyphs;
 
-  } TT_CMap10;
+  } TT_CMap10Rec, *TT_CMap10;
 
 
-  typedef struct TT_CMapTable_  TT_CMapTable;
+  typedef struct TT_CMapTableRec_*  TT_CMapTable;
 
 
   typedef FT_UInt
-  (*TT_CharMap_Func)( TT_CMapTable*  charmap,
-                      FT_ULong       char_code );
+  (*TT_CharMap_Func)( TT_CMapTable  charmap,
+                      FT_ULong      char_code );
+
+  typedef FT_ULong
+  (*TT_CharNext_Func)( TT_CMapTable  charmap,
+                       FT_ULong      char_code );
 
 
   /* charmap table */
-  struct  TT_CMapTable_
+  typedef struct  TT_CMapTableRec_
   {
     FT_UShort  platformID;
     FT_UShort  platformEncodingID;
@@ -1063,16 +1066,18 @@
 
     union
     {
-      TT_CMap0     cmap0;
-      TT_CMap2     cmap2;
-      TT_CMap4     cmap4;
-      TT_CMap6     cmap6;
-      TT_CMap8_12  cmap8_12;
-      TT_CMap10    cmap10;
+      TT_CMap0Rec     cmap0;
+      TT_CMap2Rec     cmap2;
+      TT_CMap4Rec     cmap4;
+      TT_CMap6Rec     cmap6;
+      TT_CMap8_12Rec  cmap8_12;
+      TT_CMap10Rec    cmap10;
     } c;
+
+    TT_CharMap_Func   get_index;
+    TT_CharNext_Func  get_next_char;
 
-    TT_CharMap_Func  get_index;
-  };
+  } TT_CMapTableRec;
 
 
   /*************************************************************************/
@@ -1090,8 +1095,8 @@
   /*                                                                       */
   typedef struct  TT_CharMapRec_
   {
-    FT_CharMapRec  root;
-    TT_CMapTable   cmap;
+    FT_CharMapRec    root;
+    TT_CMapTableRec  cmap;
 
   } TT_CharMapRec;
 
@@ -1115,7 +1120,7 @@
   /* following formats: TTF, OpenType-TT, and OpenType-CFF.                */
   /*                                                                       */
   /* Note, however, that the classes TT_Size, TT_GlyphSlot, and TT_CharMap */
-  /* are not shared between font drivers, and are thus defined normally in */
+  /* are not shared between font drivers, and are thus defined in          */
   /* `ttobjs.h'.                                                           */
   /*                                                                       */
   /*************************************************************************/
@@ -1154,13 +1159,13 @@
   (*TT_Interpreter)( void*  exec_context );
 
   /* forward declaration */
-  typedef struct TT_Loader_  TT_Loader;
+  typedef struct TT_LoaderRec_*  TT_Loader;
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    TT_Goto_Table_Func                                                 */
+  /*    TT_Loader_GotoTableFunc                                            */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Seeks a stream to the start of a given TrueType table.             */
@@ -1183,16 +1188,16 @@
   /*    The stream cursor must be at the font file's origin.               */
   /*                                                                       */
   typedef FT_Error
-  (*TT_Goto_Table_Func)( TT_Face    face,
-                         FT_ULong   tag,
-                         FT_Stream  stream,
-                         FT_ULong*  length );
+  (*TT_Loader_GotoTableFunc)( TT_Face    face,
+                              FT_ULong   tag,
+                              FT_Stream  stream,
+                              FT_ULong*  length );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    TT_Access_Glyph_Frame_Func                                         */
+  /*    TT_Loader_StartGlyphFunc                                           */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Seeks a stream to the start of a given glyph element, and opens a  */
@@ -1212,22 +1217,22 @@
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
   /* <Note>                                                                */
-  /*    This function is normally equivalent to FILE_Seek(offset)          */
-  /*    followed by ACCESS_Frame(byte_count) with the loader's stream, but */
-  /*    alternative formats (e.g. compressed ones) might use something     */
+  /*    This function is normally equivalent to FT_STREAM_SEEK(offset)     */
+  /*    followed by FT_FRAME_ENTER(byte_count) with the loader's stream,   */
+  /*    but alternative formats (e.g. compressed ones) might use something */
   /*    different.                                                         */
   /*                                                                       */
   typedef FT_Error
-  (*TT_Access_Glyph_Frame_Func)( TT_Loader*  loader,
-                                 FT_UInt     glyph_index,
-                                 FT_ULong    offset,
-                                 FT_UInt     byte_count );
+  (*TT_Loader_StartGlyphFunc)( TT_Loader  loader,
+                               FT_UInt    glyph_index,
+                               FT_ULong   offset,
+                               FT_UInt    byte_count );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    TT_Load_Glyph_Element_Func                                         */
+  /*    TT_Loader_ReadGlyphFunc                                            */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Reads one glyph element (its header, a simple glyph, or a          */
@@ -1240,13 +1245,13 @@
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
   typedef FT_Error
-  (*TT_Load_Glyph_Element_Func)( TT_Loader*  loader );
+  (*TT_Loader_ReadGlyphFunc)( TT_Loader  loader );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <FuncType>                                                            */
-  /*    TT_Forget_Glyph_Frame_Func                                         */
+  /*    TT_Loader_EndGlyphFunc                                             */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Closes the current loader stream frame for the glyph.              */
@@ -1255,10 +1260,9 @@
   /*    loader :: The current TrueType glyph loader object.                */
   /*                                                                       */
   typedef void
-  (*TT_Forget_Glyph_Frame_Func)( TT_Loader*  loader );
+  (*TT_Loader_EndGlyphFunc)( TT_Loader  loader );
 
 
-
   /*************************************************************************/
   /*                                                                       */
   /*                         TrueType Face Type                            */
@@ -1329,6 +1333,12 @@
   /*                            not loaded by the driver on face opening.  */
   /*                            See the `ttpost' module for more details.  */
   /*                                                                       */
+  /*    cmap_table           :: Address of the face's `cmap' SFNT table    */
+  /*                            in memory (it's an extracted frame).       */
+  /*                                                                       */
+  /*    cmap_size            :: The size in bytes of the `cmap_table'      */
+  /*                            described above.                           */
+  /*                                                                       */
   /*    num_charmaps         :: The number of character mappings in the    */
   /*                            font.                                      */
   /*                                                                       */
@@ -1344,16 +1354,24 @@
   /*                            its tag.  It defaults to TT_Goto_Face but  */
   /*                            can be different for strange formats (e.g. */
   /*                            Type 42).                                  */
-  /*                                                                       */
-  /*    access_glyph_frame   :: XXX                                        */
-  /*                                                                       */
-  /*    read_glyph_header    :: XXX                                        */
   /*                                                                       */
-  /*    read_simple_glyph    :: XXX                                        */
+  /*    access_glyph_frame   :: A function used to access the frame of a   */
+  /*                            given glyph within the face's font file.   */
   /*                                                                       */
-  /*    read_composite_glyph :: XXX                                        */
+  /*    forget_glyph_frame   :: A function used to forget the frame of a   */
+  /*                            given glyph when all data has been loaded. */
   /*                                                                       */
-  /*    forget_glyph_frame   :: XXX                                        */
+  /*    read_glyph_header    :: A function used to read a glyph header.    */
+  /*                            It must be called between an `access' and  */
+  /*                            `forget'.                                  */
+  /*                                                                       */
+  /*    read_simple_glyph    :: A function used to read a simple glyph.    */
+  /*                            It must be called after the header was     */
+  /*                            read, and before the `forget'.             */
+  /*                                                                       */
+  /*    read_composite_glyph :: A function used to read a composite glyph. */
+  /*                            It must be called after the header was     */
+  /*                            read, and before the `forget'.             */
   /*                                                                       */
   /*    sfnt                 :: A pointer to the SFNT `driver' interface.  */
   /*                                                                       */
@@ -1368,7 +1386,7 @@
   /*                            table (`gasp').  This table is optional in */
   /*                            TrueType/OpenType fonts.                   */
   /*                                                                       */
-  /*    pclt                 :: XXX                                        */
+  /*    pclt                 :: The `pclt' SFNT table.                     */
   /*                                                                       */
   /*    num_sbit_strikes     :: The number of sbit strikes, i.e., bitmap   */
   /*                            sizes, embedded in this font.              */
@@ -1425,65 +1443,71 @@
   /*    num_kern_pairs       :: The number of kerning pairs present in the */
   /*                            font file.  The engine only loads the      */
   /*                            first horizontal format 0 kern table it    */
-  /*                            finds in the font file.  You should use    */
-  /*                            the `ttxkern' structures if you want to    */
-  /*                            access other kerning tables.  Ignored      */
-  /*                            for Type 2 fonts.                          */
+  /*                            finds in the font file.  Ignored for       */
+  /*                            Type 2 fonts.                              */
   /*                                                                       */
   /*    kern_table_index     :: The index of the kerning table in the font */
-  /*                            kerning directory.  Only used by the       */
-  /*                            ttxkern extension to avoid data            */
-  /*                            duplication.  Ignored for Type 2 fonts.    */
+  /*                            kerning directory.  Ignored for Type 2     */
+  /*                            fonts.                                     */
   /*                                                                       */
   /*    interpreter          :: A pointer to the TrueType bytecode         */
   /*                            interpreters field is also used to hook    */
   /*                            the debugger in `ttdebug'.                 */
   /*                                                                       */
-  /*    extra                :: XXX                                        */
+  /*    extra                :: Reserved for third-party font drivers.     */
   /*                                                                       */
   typedef struct  TT_FaceRec_
   {
-    FT_FaceRec         root;
+    FT_FaceRec            root;
+
+    TTC_HeaderRec         ttc_header;
 
-    TTC_Header         ttc_header;
+    FT_ULong              format_tag;
+    FT_UShort             num_tables;
+    TT_Table              dir_tables;
 
-    FT_ULong           format_tag;
-    FT_UShort          num_tables;
-    TT_Table*          dir_tables;
+    TT_Header             header;       /* TrueType header table          */
+    TT_HoriHeader         horizontal;   /* TrueType horizontal header     */
 
-    TT_Header          header;       /* TrueType header table          */
-    TT_HoriHeader      horizontal;   /* TrueType horizontal header     */
+    TT_MaxProfile         max_profile;
+    FT_ULong              max_components;
 
-    TT_MaxProfile      max_profile;
-    FT_ULong           max_components;
+    FT_Bool               vertical_info;
+    TT_VertHeader         vertical;     /* TT Vertical header, if present */
 
-    FT_Bool            vertical_info;
-    TT_VertHeader      vertical;     /* TT Vertical header, if present */
+    FT_UShort             num_names;    /* number of name records  */
+    TT_NameTableRec       name_table;   /* name table              */
 
-    FT_UShort          num_names;    /* number of name records  */
-    TT_NameTable       name_table;   /* name table              */
+    TT_OS2                os2;          /* TrueType OS/2 table            */
+    TT_Postscript         postscript;   /* TrueType Postscript table      */
 
-    TT_OS2             os2;          /* TrueType OS/2 table            */
-    TT_Postscript      postscript;   /* TrueType Postscript table      */
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
 
-    FT_Int             num_charmaps;
-    TT_CharMap         charmaps;     /* array of TT_CharMapRec */
+    FT_Byte*              cmap_table;   /* extracted 'cmap' table */
+    FT_ULong              cmap_size;
 
-    TT_Goto_Table_Func          goto_table;
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
 
-    TT_Access_Glyph_Frame_Func  access_glyph_frame;
-    TT_Load_Glyph_Element_Func  read_glyph_header;
-    TT_Load_Glyph_Element_Func  read_simple_glyph;
-    TT_Load_Glyph_Element_Func  read_composite_glyph;
-    TT_Forget_Glyph_Frame_Func  forget_glyph_frame;
+    FT_Int                num_charmaps;
+    TT_CharMap            charmaps;     /* array of TT_CharMapRec */
 
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+    TT_Loader_GotoTableFunc   goto_table;
+
+    TT_Loader_StartGlyphFunc  access_glyph_frame;
+    TT_Loader_EndGlyphFunc    forget_glyph_frame;
+    TT_Loader_ReadGlyphFunc   read_glyph_header;
+    TT_Loader_ReadGlyphFunc   read_simple_glyph;
+    TT_Loader_ReadGlyphFunc   read_composite_glyph;
+
     /* a typeless pointer to the SFNT_Interface table used to load     */
     /* the basic TrueType tables in the face object                    */
-    void*              sfnt;
+    void*                 sfnt;
 
     /* a typeless pointer to the PSNames_Interface table used to       */
     /* handle glyph names <-> unicode & Mac values                     */
-    void*              psnames;
+    void*                 psnames;
 
     /***********************************************************************/
     /*                                                                     */
@@ -1492,23 +1516,23 @@
     /***********************************************************************/
 
     /* horizontal device metrics */
-    TT_Hdmx            hdmx;
+    TT_HdmxRec            hdmx;
 
     /* grid-fitting and scaling table */
-    TT_Gasp            gasp;                 /* the `gasp' table */
+    TT_GaspRec            gasp;                 /* the `gasp' table */
 
     /* PCL 5 table */
-    TT_PCLT            pclt;
+    TT_PCLT               pclt;
 
     /* embedded bitmaps support */
-    FT_Int             num_sbit_strikes;
-    TT_SBit_Strike*    sbit_strikes;
+    FT_Int                num_sbit_strikes;
+    TT_SBit_Strike        sbit_strikes;
 
-    FT_Int             num_sbit_scales;
-    TT_SBit_Scale*     sbit_scales;
+    FT_Int                num_sbit_scales;
+    TT_SBit_Scale         sbit_scales;
 
     /* postscript names table */
-    TT_Post_Names      postscript_names;
+    TT_Post_NamesRec      postscript_names;
 
 
     /***********************************************************************/
@@ -1518,29 +1542,29 @@
     /***********************************************************************/
 
     /* the glyph locations */
-    FT_UShort          num_locations;
-    FT_Long*           glyph_locations;
+    FT_UShort             num_locations;
+    FT_Long*              glyph_locations;
 
     /* the font program, if any */
-    FT_ULong           font_program_size;
-    FT_Byte*           font_program;
+    FT_ULong              font_program_size;
+    FT_Byte*              font_program;
 
     /* the cvt program, if any */
-    FT_ULong           cvt_program_size;
-    FT_Byte*           cvt_program;
+    FT_ULong              cvt_program_size;
+    FT_Byte*              cvt_program;
 
     /* the original, unscaled, control value table */
-    FT_ULong           cvt_size;
-    FT_Short*          cvt;
+    FT_ULong              cvt_size;
+    FT_Short*             cvt;
 
     /* the format 0 kerning table, if any */
-    FT_Int             num_kern_pairs;
-    FT_Int             kern_table_index;
-    TT_Kern_0_Pair*    kern_pairs;
+    FT_Int                num_kern_pairs;
+    FT_Int                kern_table_index;
+    TT_Kern0_Pair         kern_pairs;
 
     /* A pointer to the bytecode interpreter to use.  This is also */
     /* used to hook the debugger for the `ttdebug' utility.        */
-    TT_Interpreter     interpreter;
+    TT_Interpreter        interpreter;
 
 
     /***********************************************************************/
@@ -1550,7 +1574,7 @@
     /*                                                                     */
     /***********************************************************************/
 
-    FT_Generic      extra;
+    FT_Generic            extra;
 
   } TT_FaceRec;
 
@@ -1558,7 +1582,7 @@
   /*************************************************************************/
   /*                                                                       */
   /*  <Struct>                                                             */
-  /*     TT_GlyphZone                                                      */
+  /*     TT_GlyphZoneRec                                                   */
   /*                                                                       */
   /*  <Description>                                                        */
   /*     A glyph zone is used to load, scale and hint glyph outline        */
@@ -1584,7 +1608,7 @@
   /*                                                                       */
   /*     contours     :: The contours end points.                          */
   /*                                                                       */
-  typedef struct  TT_GlyphZone_
+  typedef struct  TT_GlyphZoneRec_
   {
     FT_Memory   memory;
     FT_UShort   max_points;
@@ -1598,19 +1622,19 @@
     FT_Byte*    tags;       /* current touch flags         */
     FT_UShort*  contours;   /* contour end points          */
 
-  } TT_GlyphZone;
+  } TT_GlyphZoneRec, *TT_GlyphZone;
 
 
   /* handle to execution context */
   typedef struct TT_ExecContextRec_*  TT_ExecContext;
 
   /* glyph loader structure */
-  struct  TT_Loader_
+  typedef struct  TT_LoaderRec_
   {
     FT_Face          face;
     FT_Size          size;
     FT_GlyphSlot     glyph;
-    FT_GlyphLoader*  gloader;
+    FT_GlyphLoader   gloader;
 
     FT_ULong         load_flags;
     FT_UInt          glyph_index;
@@ -1631,8 +1655,8 @@
     FT_ULong         glyf_offset;
 
     /* the zone where we load our glyphs */
-    TT_GlyphZone     base;
-    TT_GlyphZone     zone;
+    TT_GlyphZoneRec  base;
+    TT_GlyphZoneRec  zone;
 
     TT_ExecContext   exec;
     FT_Byte*         instructions;
@@ -1640,7 +1664,8 @@
 
     /* for possible extensibility in other formats */
     void*            other;
-  };
+
+  } TT_LoaderRec;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/Jamfile
diff -u xc/extras/freetype2/src/Jamfile:1.1.1.2 xc/extras/freetype2/src/Jamfile:1.1.1.3
--- xc/extras/freetype2/src/Jamfile:1.1.1.2	Mon Jan 14 11:52:08 2002
+++ xc/extras/freetype2/src/Jamfile	Thu Jun 20 04:16:11 2002
@@ -1,4 +1,4 @@
-# FreeType 2 src Jamfile (c) 2001 David Turner
+# FreeType 2 src Jamfile (c) 2001, 2002 David Turner
 #
 
 SubDir  FT2_TOP src ;
@@ -14,20 +14,23 @@
 #
 HDRMACRO  [ FT2_SubDir  include internal internal.h ] ;
 
-SubInclude  FT2_TOP src pshinter ;
 SubInclude  FT2_TOP src autohint ;
 SubInclude  FT2_TOP src base ;
+SubInclude  FT2_TOP src bdf ;
 SubInclude  FT2_TOP src cache ;
 SubInclude  FT2_TOP src cff ;
 SubInclude  FT2_TOP src cid ;
 SubInclude  FT2_TOP src pcf ;
+SubInclude  FT2_TOP src pfr ;
 SubInclude  FT2_TOP src psaux ;
+SubInclude  FT2_TOP src pshinter ;
 SubInclude  FT2_TOP src psnames ;
 SubInclude  FT2_TOP src raster ;
 SubInclude  FT2_TOP src sfnt ;
 SubInclude  FT2_TOP src smooth ;
 SubInclude  FT2_TOP src truetype ;
 SubInclude  FT2_TOP src type1 ;
+SubInclude  FT2_TOP src type42 ;
 SubInclude  FT2_TOP src winfonts ;
 
 # end of src Jamfile
Index: xc/extras/freetype2/src/autohint/ahangles.c
diff -u xc/extras/freetype2/src/autohint/ahangles.c:1.1.1.3 xc/extras/freetype2/src/autohint/ahangles.c:1.1.1.4
--- xc/extras/freetype2/src/autohint/ahangles.c:1.1.1.3	Sun Dec 16 12:49:25 2001
+++ xc/extras/freetype2/src/autohint/ahangles.c	Thu Jun 20 04:16:11 2002
@@ -5,7 +5,7 @@
 /*    A routine used to compute vector angles with limited accuracy        */
 /*    and very high speed (body).                                          */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -64,7 +64,7 @@
   };
 
 
-  FT_LOCAL_DEF AH_Angle
+  FT_LOCAL_DEF( AH_Angle )
   ah_angle( FT_Vector*  v )
   {
     FT_Pos    dx, dy;
Index: xc/extras/freetype2/src/autohint/ahangles.h
diff -u xc/extras/freetype2/src/autohint/ahangles.h:1.1.1.3 xc/extras/freetype2/src/autohint/ahangles.h:1.1.1.4
--- xc/extras/freetype2/src/autohint/ahangles.h:1.1.1.3	Sun Dec 16 12:49:25 2001
+++ xc/extras/freetype2/src/autohint/ahangles.h	Thu Jun 20 04:16:11 2002
@@ -5,7 +5,7 @@
 /*    A routine used to compute vector angles with limited accuracy        */
 /*    and very high speed (specification).                                 */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -47,7 +47,7 @@
   const AH_Angle  ah_arctan[1L << AH_ATAN_BITS];
 
 
-  FT_LOCAL AH_Angle
+  FT_LOCAL( AH_Angle )
   ah_angle( FT_Vector*  v );
 
 
Index: xc/extras/freetype2/src/autohint/ahglobal.c
diff -u xc/extras/freetype2/src/autohint/ahglobal.c:1.1.1.4 xc/extras/freetype2/src/autohint/ahglobal.c:1.1.1.5
--- xc/extras/freetype2/src/autohint/ahglobal.c:1.1.1.4	Sun Dec 16 12:49:25 2001
+++ xc/extras/freetype2/src/autohint/ahglobal.c	Thu Jun 20 04:16:11 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Routines used to compute global metrics automatically (body).        */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -158,7 +158,7 @@
         /* segment; we first need to find in which contour the extremum */
         /* lies, then see its previous and next points                  */
         {
-          FT_Int  index = (FT_Int)( extremum - points );
+          FT_Int  idx = (FT_Int)( extremum - points );
           FT_Int  n;
           FT_Int  first, last, prev, next, end;
           FT_Pos  dist;
@@ -170,7 +170,7 @@
           for ( n = 0; n < glyph->outline.n_contours; n++ )
           {
             end = glyph->outline.contours[n];
-            if ( end >= index )
+            if ( end >= idx )
             {
               last = end;
               break;
@@ -185,7 +185,7 @@
           /* now look for the previous and next points that are not on the */
           /* same Y coordinate.  Threshold the `closeness'...              */
 
-          prev = index;
+          prev = idx;
           next = prev;
 
           do
@@ -199,7 +199,7 @@
             if ( dist < -5 || dist > 5 )
               break;
 
-          } while ( prev != index );
+          } while ( prev != idx );
 
           do
           {
@@ -212,7 +212,7 @@
             if ( dist < -5 || dist > 5 )
               break;
 
-          } while ( next != index );
+          } while ( next != idx );
 
           /* now, set the `round' flag depending on the segment's kind */
           round = FT_BOOL(
@@ -384,7 +384,7 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   ah_hinter_compute_globals( AH_Hinter*  hinter )
   {
     return ah_hinter_compute_widths( hinter ) ||
Index: xc/extras/freetype2/src/autohint/ahglobal.h
diff -u xc/extras/freetype2/src/autohint/ahglobal.h:1.1.1.3 xc/extras/freetype2/src/autohint/ahglobal.h:1.1.1.4
--- xc/extras/freetype2/src/autohint/ahglobal.h:1.1.1.3	Sun Dec 16 12:49:25 2001
+++ xc/extras/freetype2/src/autohint/ahglobal.h	Thu Jun 20 04:16:11 2002
@@ -5,7 +5,7 @@
 /*    Routines used to compute global metrics automatically                */
 /*    (specification).                                                     */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -37,8 +37,8 @@
 
 
   /* compute global metrics automatically */
-  FT_LOCAL
-  FT_Error  ah_hinter_compute_globals( AH_Hinter*  hinter );
+  FT_LOCAL( FT_Error )
+  ah_hinter_compute_globals( AH_Hinter*  hinter );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/autohint/ahglyph.c
diff -u xc/extras/freetype2/src/autohint/ahglyph.c:1.1.1.5 xc/extras/freetype2/src/autohint/ahglyph.c:1.1.1.6
--- xc/extras/freetype2/src/autohint/ahglyph.c:1.1.1.5	Mon Jan 14 11:52:08 2002
+++ xc/extras/freetype2/src/autohint/ahglyph.c	Thu Jun 20 04:16:11 2002
@@ -5,7 +5,7 @@
 /*    Routines used to load and analyze a given glyph before hinting       */
 /*    (body).                                                              */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -26,11 +26,11 @@
 #include "ahglobal.h"
 #include "aherrors.h"
 
-#include <stdio.h>
-
 
 #ifdef AH_DEBUG
 
+#include <stdio.h>
+
   void
   ah_dump_edges( AH_Outline*  outline )
   {
@@ -39,6 +39,7 @@
     AH_Segment*  segments;
     FT_Int       dimension;
 
+
     edges      = outline->horz_edges;
     edge_limit = edges + outline->num_hedges;
     segments   = outline->horz_segments;
@@ -299,7 +300,7 @@
   /* <Description>                                                         */
   /*    Creates a new and empty AH_Outline object.                         */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   ah_outline_new( FT_Memory     memory,
                   AH_Outline**  aoutline )
   {
@@ -307,7 +308,7 @@
     AH_Outline*  outline;
 
 
-    if ( !ALLOC( outline, sizeof ( *outline ) ) )
+    if ( !FT_NEW( outline ) )
     {
       outline->memory = memory;
       *aoutline = outline;
@@ -325,18 +326,18 @@
   /* <Description>                                                         */
   /*    Destroys a given AH_Outline object.                                */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_outline_done( AH_Outline*  outline )
   {
     FT_Memory memory = outline->memory;
 
 
-    FREE( outline->horz_edges );
-    FREE( outline->horz_segments );
-    FREE( outline->contours );
-    FREE( outline->points );
+    FT_FREE( outline->horz_edges );
+    FT_FREE( outline->horz_segments );
+    FT_FREE( outline->contours );
+    FT_FREE( outline->points );
 
-    FREE( outline );
+    FT_FREE( outline );
   }
 
 
@@ -349,9 +350,9 @@
   /*    Saves the content of a given AH_Outline object into a face's glyph */
   /*    slot.                                                              */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_outline_save( AH_Outline*  outline,
-                   AH_Loader*   gloader )
+                   AH_Loader    gloader )
   {
     AH_Point*   point       = outline->points;
     AH_Point*   point_limit = point + outline->num_points;
@@ -384,7 +385,7 @@
   /*    Loads an unscaled outline from a glyph slot into an AH_Outline     */
   /*    object.                                                            */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   ah_outline_load( AH_Outline*  outline,
                    FT_Face      face )
   {
@@ -408,8 +409,9 @@
       FT_Int  new_contours = ( num_contours + 3 ) & -4;
 
 
-      if ( REALLOC_ARRAY( outline->contours, outline->max_contours,
-                          new_contours, AH_Point* ) )
+      if ( FT_RENEW_ARRAY( outline->contours,
+                           outline->max_contours,
+                           new_contours ) )
         goto Exit;
 
       outline->max_contours = new_contours;
@@ -425,12 +427,9 @@
       FT_Int  max  = outline->max_points;
 
 
-      if ( REALLOC_ARRAY( outline->points,
-                          max, news, AH_Point )            ||
-           REALLOC_ARRAY( outline->horz_edges,
-                          max * 2, news * 2, AH_Edge )     ||
-           REALLOC_ARRAY( outline->horz_segments,
-                          max * 2, news * 2, AH_Segment ) )
+      if ( FT_RENEW_ARRAY( outline->points,        max,     news     ) ||
+           FT_RENEW_ARRAY( outline->horz_edges,    max * 2, news * 2 ) ||
+           FT_RENEW_ARRAY( outline->horz_segments, max * 2, news * 2 ) )
         goto Exit;
 
       /* readjust some pointers */
@@ -552,13 +551,13 @@
         AH_Point**  contour       = outline->contours;
         AH_Point**  contour_limit = contour + outline->num_contours;
         short*      end           = source->contours;
-        short       index         = 0;
+        short       idx           = 0;
 
 
         for ( ; contour < contour_limit; contour++, end++ )
         {
-          contour[0] = points + index;
-          index      = (short)( end[0] + 1 );
+          contour[0] = points + idx;
+          idx        = (short)( end[0] + 1 );
         }
       }
 
@@ -622,7 +621,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_setup_uv( AH_Outline*  outline,
                AH_UV        source )
   {
@@ -676,7 +675,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_outline_compute_segments( AH_Outline*  outline )
   {
     int           dimension;
@@ -816,7 +815,7 @@
             segment_dir = point->out_dir;
 
             /* clear all segment fields */
-            MEM_Set( segment, 0, sizeof ( *segment ) );
+            FT_MEM_SET( segment, 0, sizeof ( *segment ) );
 
             segment->dir      = segment_dir;
             segment->flags    = ah_edge_normal;
@@ -878,7 +877,7 @@
         if ( min_point )
         {
           /* clear all segment fields */
-          MEM_Set( segment, 0, sizeof ( *segment ) );
+          FT_MEM_SET( segment, 0, sizeof ( *segment ) );
 
           segment->dir   = segment_dir;
           segment->flags = ah_edge_normal;
@@ -894,7 +893,7 @@
         if ( max_point )
         {
           /* clear all segment fields */
-          MEM_Set( segment, 0, sizeof ( *segment ) );
+          FT_MEM_SET( segment, 0, sizeof ( *segment ) );
 
           segment->dir   = segment_dir;
           segment->flags = ah_edge_normal;
@@ -918,7 +917,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_outline_link_segments( AH_Outline*  outline )
   {
     AH_Segment*  segments;
@@ -976,11 +975,7 @@
               FT_Pos  min = seg1->min_coord;
               FT_Pos  max = seg1->max_coord;
               FT_Pos  len, dist, score;
-              FT_Pos  size1, size2;
-
 
-              size1 = max - min;
-              size2 = seg2->max_coord - seg2->min_coord;
 
               if ( min < seg2->min_coord )
                 min = seg2->min_coord;
@@ -1121,7 +1116,7 @@
           edge_limit++;
 
           /* clear all edge fields */
-          MEM_Set( edge, 0, sizeof ( *edge ) );
+          FT_MEM_SET( edge, 0, sizeof ( *edge ) );
 
           /* add the segment to the new edge's list */
           edge->first    = seg;
@@ -1290,7 +1285,7 @@
   /* <Description>                                                         */
   /*    Performs feature detection on a given AH_Outline object.           */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_outline_detect_features( AH_Outline*  outline )
   {
     ah_outline_compute_segments( outline );
@@ -1308,7 +1303,7 @@
   /*    Computes the `blue edges' in a given outline (i.e. those that must */
   /*    be snapped to a blue zone edge (top or bottom).                    */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_outline_compute_blue_edges( AH_Outline*       outline,
                                  AH_Face_Globals*  face_globals )
   {
@@ -1442,7 +1437,7 @@
   /*    the contents of the detected edges (basically change the `blue     */
   /*    edge' pointer from `design units' to `scaled ones').               */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_outline_scale_blue_edges( AH_Outline*       outline,
                                AH_Face_Globals*  globals )
   {
Index: xc/extras/freetype2/src/autohint/ahglyph.h
diff -u xc/extras/freetype2/src/autohint/ahglyph.h:1.1.1.3 xc/extras/freetype2/src/autohint/ahglyph.h:1.1.1.4
--- xc/extras/freetype2/src/autohint/ahglyph.h:1.1.1.3	Sun Dec 16 12:49:25 2001
+++ xc/extras/freetype2/src/autohint/ahglyph.h	Thu Jun 20 04:16:11 2002
@@ -5,7 +5,7 @@
 /*    Routines used to load and analyze a given glyph before hinting       */
 /*    (specification).                                                     */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -45,43 +45,43 @@
   } AH_UV;
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_setup_uv( AH_Outline*  outline,
                AH_UV        source );
 
 
   /* AH_Outline functions - they should be typically called in this order */
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   ah_outline_new( FT_Memory     memory,
                   AH_Outline**  aoutline );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   ah_outline_load( AH_Outline*  outline,
                    FT_Face      face );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_outline_compute_segments( AH_Outline*  outline );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_outline_link_segments( AH_Outline*  outline );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_outline_detect_features( AH_Outline*  outline );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_outline_compute_blue_edges( AH_Outline*       outline,
                                  AH_Face_Globals*  globals );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_outline_scale_blue_edges( AH_Outline*       outline,
                                AH_Face_Globals*  globals );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_outline_save( AH_Outline*  outline,
-                   AH_Loader*   loader );
+                   AH_Loader    loader );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_outline_done( AH_Outline*  outline );
 
 
Index: xc/extras/freetype2/src/autohint/ahhint.c
diff -u xc/extras/freetype2/src/autohint/ahhint.c:1.1.1.5 xc/extras/freetype2/src/autohint/ahhint.c:1.1.1.7
--- xc/extras/freetype2/src/autohint/ahhint.c:1.1.1.5	Mon Jan 14 11:52:08 2002
+++ xc/extras/freetype2/src/autohint/ahhint.c	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Glyph hinter (body).                                                 */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -158,7 +158,7 @@
     FT_Pos  dist;
     FT_Pos  sign = 1;
 
-    UNUSED( hinter );
+    FT_UNUSED( hinter );
 
 
     dist = serif->opos - base->opos;
@@ -378,7 +378,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_hinter_hint_edges( AH_Hinter*  hinter,
                         FT_Bool     no_horz_edges,
                         FT_Bool     no_vert_edges )
@@ -388,7 +388,7 @@
     ah_debug_disable_vert = no_vert_edges;
 #else
     FT_UNUSED( no_horz_edges );
-    FT_UNUSED( no_vert_edges );    
+    FT_UNUSED( no_vert_edges );
 #endif
     /* AH_Interpolate_Blue_Edges( hinter ); -- doesn't seem to help      */
     /* reduce the problem of the disappearing eye in the `e' of Times... */
@@ -807,7 +807,7 @@
 #endif /* !AH_OPTION_NO_WEAK_INTERPOLATION */
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_hinter_align_points( AH_Hinter*  hinter )
   {
     ah_hinter_align_edge_points( hinter );
@@ -896,7 +896,7 @@
 
 
   /* finalize a hinter object */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_hinter_done( AH_Hinter*  hinter )
   {
     if ( hinter )
@@ -913,13 +913,13 @@
       hinter->globals = 0;
       hinter->face    = 0;
 
-      FREE( hinter );
+      FT_FREE( hinter );
     }
   }
 
 
   /* create a new empty hinter object */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   ah_hinter_new( FT_Library   library,
                  AH_Hinter**  ahinter )
   {
@@ -931,7 +931,7 @@
     *ahinter = 0;
 
     /* allocate object */
-    if ( ALLOC( hinter, sizeof ( *hinter ) ) )
+    if ( FT_NEW( hinter ) )
       goto Exit;
 
     hinter->memory = memory;
@@ -955,7 +955,7 @@
 
 
   /* create a face's autohint globals */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   ah_hinter_new_face_globals( AH_Hinter*   hinter,
                               FT_Face      face,
                               AH_Globals*  globals )
@@ -965,7 +965,7 @@
     AH_Face_Globals*  face_globals;
 
 
-    if ( ALLOC( face_globals, sizeof ( *face_globals ) ) )
+    if ( FT_NEW( face_globals ) )
       goto Exit;
 
     hinter->face    = face;
@@ -987,14 +987,14 @@
 
 
   /* discard a face's autohint globals */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_hinter_done_face_globals( AH_Face_Globals*  globals )
   {
     FT_Face    face   = globals->face;
     FT_Memory  memory = face->memory;
 
 
-    FREE( globals );
+    FT_FREE( globals );
   }
 
 
@@ -1011,7 +1011,7 @@
     FT_Fixed          y_scale  = face->size->metrics.y_scale;
     FT_Error          error;
     AH_Outline*       outline  = hinter->glyph;
-    AH_Loader*        gloader  = hinter->loader;
+    AH_Loader         gloader  = hinter->loader;
     FT_Bool           no_horz_hints = FT_BOOL(
                         ( load_flags & AH_HINT_NO_HORZ_EDGES ) != 0 );
     FT_Bool           no_vert_hints = FT_BOOL(
@@ -1067,14 +1067,14 @@
       if ( error )
         goto Exit;
 
-      MEM_Copy( gloader->current.extra_points, slot->outline.points,
-                slot->outline.n_points * sizeof ( FT_Vector ) );
+      FT_MEM_COPY( gloader->current.extra_points, slot->outline.points,
+                   slot->outline.n_points * sizeof ( FT_Vector ) );
 
-      MEM_Copy( gloader->current.outline.contours, slot->outline.contours,
-                slot->outline.n_contours * sizeof ( short ) );
+      FT_MEM_COPY( gloader->current.outline.contours, slot->outline.contours,
+                   slot->outline.n_contours * sizeof ( short ) );
 
-      MEM_Copy( gloader->current.outline.tags, slot->outline.tags,
-                slot->outline.n_points * sizeof ( char ) );
+      FT_MEM_COPY( gloader->current.outline.tags, slot->outline.tags,
+                   slot->outline.n_points * sizeof ( char ) );
 
       gloader->current.outline.n_points   = slot->outline.n_points;
       gloader->current.outline.n_contours = slot->outline.n_contours;
@@ -1139,9 +1139,9 @@
 
     case ft_glyph_format_composite:
       {
-        FT_UInt       nn, num_subglyphs = slot->num_subglyphs;
-        FT_UInt       num_base_subgs, start_point;
-        FT_SubGlyph*  subglyph;
+        FT_UInt      nn, num_subglyphs = slot->num_subglyphs;
+        FT_UInt      num_base_subgs, start_point;
+        FT_SubGlyph  subglyph;
 
 
         start_point   = gloader->base.outline.n_points;
@@ -1151,8 +1151,8 @@
         if ( error )
           goto Exit;
 
-        MEM_Copy( gloader->current.subglyphs, slot->subglyphs,
-                  num_subglyphs * sizeof ( FT_SubGlyph ) );
+        FT_MEM_COPY( gloader->current.subglyphs, slot->subglyphs,
+                     num_subglyphs * sizeof ( FT_SubGlyph ) );
 
         gloader->current.num_subglyphs = num_subglyphs;
         num_base_subgs = gloader->base.num_subglyphs;
@@ -1327,7 +1327,7 @@
 
 
   /* load and hint a given glyph */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   ah_hinter_load_glyph( AH_Hinter*    hinter,
                         FT_GlyphSlot  slot,
                         FT_Size       size,
@@ -1381,7 +1381,7 @@
 
 
   /* retrieve a face's autohint globals for client applications */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_hinter_get_global_hints( AH_Hinter*  hinter,
                               FT_Face     face,
                               void**      global_hints,
@@ -1393,7 +1393,7 @@
 
 
     /* allocate new master globals */
-    if ( ALLOC( globals, sizeof ( *globals ) ) )
+    if ( FT_NEW( globals ) )
       goto Fail;
 
     /* compute face globals if needed */
@@ -1411,21 +1411,21 @@
     return;
 
   Fail:
-    FREE( globals );
+    FT_FREE( globals );
 
     *global_hints = 0;
     *global_len   = 0;
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   ah_hinter_done_global_hints( AH_Hinter*  hinter,
                                void*       global_hints )
   {
     FT_Memory  memory = hinter->memory;
 
 
-    FREE( global_hints );
+    FT_FREE( global_hints );
   }
 
 
Index: xc/extras/freetype2/src/autohint/ahhint.h
diff -u xc/extras/freetype2/src/autohint/ahhint.h:1.1.1.3 xc/extras/freetype2/src/autohint/ahhint.h:1.1.1.4
--- xc/extras/freetype2/src/autohint/ahhint.h:1.1.1.3	Sun Dec 16 12:49:25 2001
+++ xc/extras/freetype2/src/autohint/ahhint.h	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Glyph hinter (declaration).                                          */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -37,12 +37,12 @@
 
 
   /* create a new empty hinter object */
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   ah_hinter_new( FT_Library   library,
                  AH_Hinter**  ahinter );
 
   /* Load a hinted glyph in the hinter */
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   ah_hinter_load_glyph( AH_Hinter*    hinter,
                         FT_GlyphSlot  slot,
                         FT_Size       size,
@@ -50,19 +50,19 @@
                         FT_Int        load_flags );
 
   /* finalize a hinter object */
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_hinter_done( AH_Hinter*  hinter );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_hinter_done_face_globals( AH_Face_Globals*  globals );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_hinter_get_global_hints( AH_Hinter*  hinter,
                               FT_Face     face,
                               void**      global_hints,
                               long*       global_len );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   ah_hinter_done_global_hints( AH_Hinter*  hinter,
                                void*       global_hints );
 
Index: xc/extras/freetype2/src/autohint/ahloader.h
diff -u xc/extras/freetype2/src/autohint/ahloader.h:1.1.1.3 xc/extras/freetype2/src/autohint/ahloader.h:1.2
--- xc/extras/freetype2/src/autohint/ahloader.h:1.1.1.3	Sun Dec 16 12:49:25 2001
+++ xc/extras/freetype2/src/autohint/ahloader.h	Sat Jan 11 22:55:45 2003
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Glyph loader for the auto-hinting module (declaration only).         */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -17,18 +17,14 @@
 /*  Note that this license is compatible with the FreeType license.        */
 /*                                                                         */
 /***************************************************************************/
+/* $XFree86: xc/extras/freetype2/src/autohint/ahloader.h,v 1.2 2003/01/12 03:55:45 tsi Exp $ */
 
 
   /*************************************************************************/
   /*                                                                       */
-  /* This defines the AH_GlyphLoader type in two different ways:           */
+  /* This defines the AH_GlyphLoader type; it is simply a typedef to       */
+  /* FT_GlyphLoader.                                                       */
   /*                                                                       */
-  /* - If the module is compiled within FreeType 2, the type is simply a   */
-  /*   typedef to FT_GlyphLoader.                                          */
-  /*                                                                       */
-  /* - If the module is compiled as a standalone object, AH_GlyphLoader    */
-  /*   has its own implementation.                                         */
-  /*                                                                       */
   /*************************************************************************/
 
 
@@ -40,89 +36,22 @@
 
 
 FT_BEGIN_HEADER
-
-
-#ifdef _STANDALONE_
-
-  typedef struct  AH_GlyphLoad_
-  {
-    FT_Outline    outline;       /* outline             */
-    FT_UInt       num_subglyphs; /* number of subglyphs */
-    FT_SubGlyph*  subglyphs;     /* subglyphs           */
-    FT_Vector*    extra_points;  /* extra points table  */
-
-  } AH_GlyphLoad;
-
-
-  struct  AH_GlyphLoader_
-  {
-    FT_Memory     memory;
-    FT_UInt       max_points;
-    FT_UInt       max_contours;
-    FT_UInt       max_subglyphs;
-    FT_Bool       use_extra;
-
-    AH_GlyphLoad  base;
-    AH_GlyphLoad  current;
-
-    void*         other;        /* for possible future extensions */
-  };
-
-
-  FT_LOCAL FT_Error
-  AH_GlyphLoader_New( FT_Memory         memory,
-                      AH_GlyphLoader**  aloader );
-
-  FT_LOCAL FT_Error
-  AH_GlyphLoader_Create_Extra( AH_GlyphLoader*  loader );
-
-  FT_LOCAL void
-  AH_GlyphLoader_Done( AH_GlyphLoader*  loader );
-
-  FT_LOCAL void
-  AH_GlyphLoader_Reset( AH_GlyphLoader*  loader );
-
-  FT_LOCAL void
-  AH_GlyphLoader_Rewind( AH_GlyphLoader*  loader );
-
-  FT_LOCAL FT_Error
-  AH_GlyphLoader_Check_Points( AH_GlyphLoader*  loader,
-                               FT_UInt          n_points,
-                               FT_UInt          n_contours );
-
-  FT_LOCAL FT_Error
-  AH_GlyphLoader_Check_Subglyphs( AH_GlyphLoader*  loader,
-                                  FT_UInt          n_subs );
-
-  FT_LOCAL void
-  AH_GlyphLoader_Prepare( AH_GlyphLoader*  loader );
-
-  FT_LOCAL void
-  AH_GlyphLoader_Add( AH_GlyphLoader*  loader );
-
-  FT_LOCAL FT_Error
-  AH_GlyphLoader_Copy_Points( AH_GlyphLoader*  target,
-                              FT_GlyphLoader*  source );
-
-#else /* _STANDALONE */
-
-#include FT_INTERNAL_OBJECTS_H
 
-  #define AH_Load    FT_GlyphLoad
-  #define AH_Loader  FT_GlyphLoader
+#include FT_INTERNAL_GLYPH_LOADER_H
 
-  #define ah_loader_new              FT_GlyphLoader_New
-  #define ah_loader_done             FT_GlyphLoader_Done
-  #define ah_loader_reset            FT_GlyphLoader_Reset
-  #define ah_loader_rewind           FT_GlyphLoader_Rewind
-  #define ah_loader_create_extra     FT_GlyphLoader_Create_Extra
-  #define ah_loader_check_points     FT_GlyphLoader_Check_Points
-  #define ah_loader_check_subglyphs  FT_GlyphLoader_Check_Subglyphs
-  #define ah_loader_prepare          FT_GlyphLoader_Prepare
-  #define ah_loader_add              FT_GlyphLoader_Add
-  #define ah_loader_copy_points      FT_GlyphLoader_Copy_Points
+#define AH_Load    FT_GlyphLoad
+#define AH_Loader  FT_GlyphLoader
 
-#endif /* _STANDALONE_ */
+#define ah_loader_new              FT_GlyphLoader_New
+#define ah_loader_done             FT_GlyphLoader_Done
+#define ah_loader_reset            FT_GlyphLoader_Reset
+#define ah_loader_rewind           FT_GlyphLoader_Rewind
+#define ah_loader_create_extra     FT_GlyphLoader_CreateExtra
+#define ah_loader_check_points     FT_GlyphLoader_CheckPoints
+#define ah_loader_check_subglyphs  FT_GlyphLoader_CheckSubGlyphs
+#define ah_loader_prepare          FT_GlyphLoader_Prepare
+#define ah_loader_add              FT_GlyphLoader_Add
+#define ah_loader_copy_points      FT_GlyphLoader_CopyPoints
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/autohint/ahmodule.c
diff -u xc/extras/freetype2/src/autohint/ahmodule.c:1.1.1.5 xc/extras/freetype2/src/autohint/ahmodule.c:1.1.1.6
--- xc/extras/freetype2/src/autohint/ahmodule.c:1.1.1.5	Mon Jan 14 11:52:08 2002
+++ xc/extras/freetype2/src/autohint/ahmodule.c	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Auto-hinting module implementation (declaration).                    */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -25,7 +25,7 @@
 
 
 #ifdef  DEBUG_HINTER
-   extern AH_Hinter*  ah_debug_hinter = NULL;
+   extern AH_Hinter*  ah_debug_hinter       = NULL;
    extern FT_Bool     ah_debug_disable_horz = 0;
    extern FT_Bool     ah_debug_disable_vert = 0;
 #endif
@@ -43,6 +43,7 @@
   {
     FT_Error  error;
 
+
     error = ah_hinter_new( module->root.library, &module->hinter );
 #ifdef DEBUG_HINTER
     if ( !error )
@@ -64,11 +65,11 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  ft_autohinter_load( FT_AutoHinter  module,
-                      FT_GlyphSlot   slot,
-                      FT_Size        size,
-                      FT_UInt        glyph_index,
-                      FT_ULong       load_flags )
+  ft_autohinter_load_glyph( FT_AutoHinter  module,
+                            FT_GlyphSlot   slot,
+                            FT_Size        size,
+                            FT_UInt        glyph_index,
+                            FT_ULong       load_flags )
   {
     return ah_hinter_load_glyph( module->hinter,
                                  slot, size, glyph_index, load_flags );
@@ -76,10 +77,10 @@
 
 
   FT_CALLBACK_DEF( void )
-  ft_autohinter_reset( FT_AutoHinter  module,
-                       FT_Face        face )
+  ft_autohinter_reset_globals( FT_AutoHinter  module,
+                               FT_Face        face )
   {
-    UNUSED( module );
+    FT_UNUSED( module );
 
     if ( face->autohint.data )
       ah_hinter_done_face_globals( (AH_Face_Globals*)(face->autohint.data) );
@@ -106,12 +107,12 @@
 
 
   FT_CALLBACK_TABLE_DEF
-  const FT_AutoHinter_Interface  autohinter_interface =
+  const FT_AutoHinter_ServiceRec  ft_autohinter_service =
   {
-    ft_autohinter_reset,
-    ft_autohinter_load,
+    ft_autohinter_reset_globals,
     ft_autohinter_get_globals,
-    ft_autohinter_done_globals
+    ft_autohinter_done_globals,
+    ft_autohinter_load_glyph
   };
 
 
@@ -125,7 +126,7 @@
     0x10000L,   /* version 1.0 of the autohinter  */
     0x20000L,   /* requires FreeType 2.0 or above */
 
-    (const void*)&autohinter_interface,
+    (const void*) &ft_autohinter_service,
 
     (FT_Module_Constructor)ft_autohinter_init,
     (FT_Module_Destructor) ft_autohinter_done,
Index: xc/extras/freetype2/src/autohint/ahoptim.c
diff -u xc/extras/freetype2/src/autohint/ahoptim.c:1.1.1.3 xc/extras/freetype2/src/autohint/ahoptim.c:1.1.1.4
--- xc/extras/freetype2/src/autohint/ahoptim.c:1.1.1.3	Sun Dec 16 12:49:26 2001
+++ xc/extras/freetype2/src/autohint/ahoptim.c	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType auto hinting outline optimization (body).                   */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -32,11 +32,11 @@
 
 
 #include <ft2build.h>
-#include FT_INTERNAL_OBJECTS_H        /* for ALLOC_ARRAY() and FREE() */
+#include FT_INTERNAL_OBJECTS_H       /* for FT_ALLOC_ARRAY() and FT_FREE() */
 #include "ahoptim.h"
 
 
-  /* define this macro to use brute force optimisation -- this is slow,  */
+  /* define this macro to use brute force optimization -- this is slow,  */
   /* but a good way to perfect the distortion function `by hand' through */
   /* tweaking                                                            */
 #define AH_BRUTE_FORCE
@@ -61,10 +61,10 @@
 
 #include <stdarg.h>
 #include <stdlib.h>
-#include <string.h>
 
 #define FLOAT( x )  ( (float)( (x) / 64.0 ) )
 
+
   static void
   optim_log( const char*  fmt, ... )
   {
@@ -220,7 +220,7 @@
         AH_Stem*  stem;
 
 
-        if ( ALLOC_ARRAY( stems, num_stems, AH_Stem ) )
+        if ( FT_NEW_ARRAY( stems, num_stems ) )
           goto Exit;
 
         stem = stems;
@@ -409,7 +409,7 @@
 
 
         /* allocate table of springs */
-        if ( ALLOC_ARRAY( springs, num_springs, AH_Spring ) )
+        if ( FT_NEW_ARRAY( springs, num_springs ) )
           goto Exit;
 
         /* fill the springs table */
@@ -796,11 +796,11 @@
       FT_Memory  memory = optimizer->memory;
 
 
-      FREE( optimizer->horz_stems );
-      FREE( optimizer->vert_stems );
-      FREE( optimizer->horz_springs );
-      FREE( optimizer->vert_springs );
-      FREE( optimizer->positions );
+      FT_FREE( optimizer->horz_stems );
+      FT_FREE( optimizer->vert_stems );
+      FT_FREE( optimizer->horz_springs );
+      FT_FREE( optimizer->vert_springs );
+      FT_FREE( optimizer->positions );
     }
   }
 
@@ -814,7 +814,7 @@
     FT_Error  error;
 
 
-    MEM_Set( optimizer, 0, sizeof ( *optimizer ) );
+    FT_MEM_SET( optimizer, 0, sizeof ( *optimizer ) );
     optimizer->outline = outline;
     optimizer->memory  = memory;
 
@@ -834,8 +834,7 @@
       if ( max_stems < optimizer->num_vstems )
         max_stems = optimizer->num_vstems;
 
-      if ( ALLOC_ARRAY( optimizer->positions,
-                        max_stems * AH_MAX_CONFIGS, FT_Pos ) )
+      if ( FT_NEW_ARRAY( optimizer->positions, max_stems * AH_MAX_CONFIGS ) )
         goto Fail;
 
       optimizer->num_configs = 0;
Index: xc/extras/freetype2/src/autohint/ahtypes.h
diff -u xc/extras/freetype2/src/autohint/ahtypes.h:1.1.1.4 xc/extras/freetype2/src/autohint/ahtypes.h:1.1.1.5
--- xc/extras/freetype2/src/autohint/ahtypes.h:1.1.1.4	Mon Jan 14 11:52:09 2002
+++ xc/extras/freetype2/src/autohint/ahtypes.h	Thu Jun 20 04:16:12 2002
@@ -5,7 +5,7 @@
 /*    General types and definitions for the auto-hint module               */
 /*    (specification only).                                                */
 /*                                                                         */
-/*  Copyright 2000-2001 Catharon Productions Inc.                          */
+/*  Copyright 2000-2001, 2002 Catharon Productions Inc.                    */
 /*  Author: David Turner                                                   */
 /*                                                                         */
 /*  This file is part of the Catharon Typography Project and shall only    */
@@ -207,7 +207,7 @@
   /*                                                                       */
   /*    prev      :: The previous point in same contour.                   */
   /*                                                                       */
-  struct AH_Point
+  struct  AH_Point
   {
     AH_Flags      flags;    /* point flags used by hinter */
     FT_Pos        ox, oy;
@@ -420,14 +420,14 @@
   /*                                                                       */
   typedef struct  AH_Globals_
   {
-    FT_Int    num_widths;
-    FT_Int    num_heights;
+    FT_Int  num_widths;
+    FT_Int  num_heights;
 
-    FT_Pos    widths [AH_MAX_WIDTHS];
-    FT_Pos    heights[AH_MAX_HEIGHTS];
+    FT_Pos  widths [AH_MAX_WIDTHS];
+    FT_Pos  heights[AH_MAX_HEIGHTS];
 
-    FT_Pos    blue_refs  [ah_blue_max];
-    FT_Pos    blue_shoots[ah_blue_max];
+    FT_Pos  blue_refs  [ah_blue_max];
+    FT_Pos  blue_shoots[ah_blue_max];
 
   } AH_Globals;
 
@@ -477,7 +477,7 @@
 
     AH_Outline*       glyph;
 
-    AH_Loader*        loader;
+    AH_Loader         loader;
     FT_Vector         pp1;
     FT_Vector         pp2;
 
@@ -488,14 +488,15 @@
   } AH_Hinter;
 
 
-#ifdef    DEBUG_HINTER
-  extern AH_Hinter*   ah_debug_hinter;
-  extern FT_Bool      ah_debug_disable_horz;
-  extern FT_Bool      ah_debug_disable_vert;
+#ifdef  DEBUG_HINTER
+  extern AH_Hinter*  ah_debug_hinter;
+  extern FT_Bool     ah_debug_disable_horz;
+  extern FT_Bool     ah_debug_disable_vert;
 #else
-# define ah_debug_disable_horz   0
-# define ah_debug_disable_vert   0
-#endif  /* DEBUG_HINTER */
+#define ah_debug_disable_horz  0
+#define ah_debug_disable_vert  0
+#endif /* DEBUG_HINTER */
+
 
 FT_END_HEADER
 
Index: xc/extras/freetype2/src/autohint/descrip.mms
diff -u xc/extras/freetype2/src/autohint/descrip.mms:1.1.1.1 xc/extras/freetype2/src/autohint/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/autohint/descrip.mms:1.1.1.1	Tue May 15 23:45:39 2001
+++ xc/extras/freetype2/src/autohint/descrip.mms	Thu Jun 20 04:16:12 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 Catharon Productions Inc.
+# Copyright 2001, 2002 Catharon Productions Inc.
 #
 # This file is part of the Catharon Typography Project and shall only
 # be used, modified, and distributed under the terms of the Catharon
@@ -20,6 +20,6 @@
 OBJS=autohint.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/autohint/rules.mk
diff -u xc/extras/freetype2/src/autohint/rules.mk:1.1.1.3 xc/extras/freetype2/src/autohint/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/autohint/rules.mk:1.1.1.3	Sun Sep  9 22:56:01 2001
+++ xc/extras/freetype2/src/autohint/rules.mk	Thu Jun 20 04:16:12 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2000 Catharon Productions Inc.
+# Copyright 2000, 2001 Catharon Productions Inc.
 # Author: David Turner
 #
 # This file is part of the Catharon Typography Project and shall only
Index: xc/extras/freetype2/src/base/Jamfile
diff -u xc/extras/freetype2/src/base/Jamfile:1.1.1.2 xc/extras/freetype2/src/base/Jamfile:1.1.1.3
--- xc/extras/freetype2/src/base/Jamfile:1.1.1.2	Mon Jan 14 11:52:09 2002
+++ xc/extras/freetype2/src/base/Jamfile	Thu Jun 20 04:16:12 2002
@@ -1,4 +1,4 @@
-# FreeType 2 src/base Jamfile (c) 2001 David Turner
+# FreeType 2 src/base Jamfile (c) 2001, 2002 David Turner
 #
 
 SubDir  FT2_TOP src base ;
@@ -10,8 +10,8 @@
 
   if $(FT2_MULTI)
   {
-    _sources = ftcalc ftextend ftlist ftobjs ftstream ftoutln ftnames fttrigon
-               ftdbgmem ;
+    _sources = ftutil ftdbgmem ftstream ftcalc fttrigon ftgloadr ftoutln
+               ftobjs ftnames ;
   }
   else
   {
@@ -23,8 +23,8 @@
 
 # Add the optional/replaceable files.
 #
-Library  $(FT2_LIB) : ftsystem.c ftinit.c ftglyph.c ftmm.c
-                      ftbbox.c ftdebug.c ;
+Library  $(FT2_LIB) : ftsystem.c ftinit.c   ftglyph.c  ftmm.c     ftbdf.c
+                      ftbbox.c   ftdebug.c  ftxf86.c   fttype1.c  ;
 
 # Add Macintosh-specific file to the library when necessary.
 #
Index: xc/extras/freetype2/src/base/descrip.mms
diff -u xc/extras/freetype2/src/base/descrip.mms:1.1.1.2 xc/extras/freetype2/src/base/descrip.mms:1.1.1.4
--- xc/extras/freetype2/src/base/descrip.mms:1.1.1.2	Mon Jan 14 11:52:09 2002
+++ xc/extras/freetype2/src/base/descrip.mms	Thu Jun 20 04:16:12 2002
@@ -15,9 +15,9 @@
 
 CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.builds.vms],[--.include],[--.src.base])
 
-OBJS=ftbase.obj,ftinit.obj,ftglyph.obj,ftdebug.obj
+OBJS=ftbase.obj,ftinit.obj,ftglyph.obj,ftdebug.obj,ftbdf.obj,ftmm.obj,fttype1.obj,ftxf86.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/base/ftapi.c
diff -u /dev/null xc/extras/freetype2/src/base/ftapi.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:44 2003
+++ xc/extras/freetype2/src/base/ftapi.c	Thu Jun 20 04:16:12 2002
@@ -0,0 +1,121 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftapi.c                                                                */
+/*                                                                         */
+/*    The FreeType compatibility functions (body).                         */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_LIST_H
+#include FT_OUTLINE_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_TRUETYPE_TABLES_H
+#include FT_OUTLINE_H
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                 C O M P A T I B I L I T Y                       ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* backwards compatibility API */
+
+  FT_BASE_DEF( void )
+  FT_New_Memory_Stream( FT_Library  library,
+                        FT_Byte*    base,
+                        FT_ULong    size,
+                        FT_Stream   stream )
+  {
+    FT_UNUSED( library );
+
+    FT_Stream_OpenMemory( stream, base, size );
+  }                        
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Seek_Stream( FT_Stream  stream,
+                  FT_ULong   pos )
+  {
+    return FT_Stream_Seek( stream, pos );
+  }                  
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Skip_Stream( FT_Stream  stream,
+                  FT_Long    distance )
+  {
+    return FT_Stream_Skip( stream, distance );
+  }                  
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Read_Stream( FT_Stream  stream,
+                  FT_Byte*   buffer,
+                  FT_ULong   count )
+  {
+    return FT_Stream_Read( stream, buffer, count );
+  }                  
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Read_Stream_At( FT_Stream  stream,
+                     FT_ULong   pos,
+                     FT_Byte*   buffer,
+                     FT_ULong   count )
+  {
+    return FT_Stream_ReadAt( stream, pos, buffer, count );
+  }                    
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_Extract_Frame( FT_Stream  stream,
+                    FT_ULong   count,
+                    FT_Byte**  pbytes )
+  {
+    return FT_Stream_ExtractFrame( stream, count, pbytes );
+  }                    
+
+
+  FT_BASE_DEF( void )
+  FT_Release_Frame( FT_Stream  stream,
+                    FT_Byte**  pbytes )
+  {
+    FT_Stream_ReleaseFrame( stream, pbytes );
+  }                    
+
+  FT_BASE_DEF( FT_Error )
+  FT_Access_Frame( FT_Stream  stream,
+                   FT_ULong   count )
+  {
+    return FT_Stream_EnterFrame( stream, count );
+  }                   
+
+
+  FT_BASE_DEF( void )
+  FT_Forget_Frame( FT_Stream  stream )
+  {
+    FT_Stream_ExitFrame( stream );
+  }
+                   
+
+/* END */
Index: xc/extras/freetype2/src/base/ftbase.c
diff -u xc/extras/freetype2/src/base/ftbase.c:1.1.1.5 xc/extras/freetype2/src/base/ftbase.c:1.1.1.6
--- xc/extras/freetype2/src/base/ftbase.c:1.1.1.5	Mon Jan 14 11:52:09 2002
+++ xc/extras/freetype2/src/base/ftbase.c	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Single object library component (body only).                         */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -20,17 +20,15 @@
 
 #define  FT_MAKE_OPTION_SINGLE_OBJECT
 
+#include "ftutil.c"
+#include "ftdbgmem.c"
+#include "ftstream.c"
 #include "ftcalc.c"
 #include "fttrigon.c"
-#include "ftobjs.c"
-#include "ftstream.c"
-#include "ftlist.c"
 #include "ftoutln.c"
+#include "ftgloadr.c"
+#include "ftobjs.c"
 #include "ftnames.c"
-#include "ftdbgmem.c"
 
-#if 0
-#include "ftextend.c"
-#endif
 
 /* END */
Index: xc/extras/freetype2/src/base/ftbbox.c
diff -u xc/extras/freetype2/src/base/ftbbox.c:1.1.1.4 xc/extras/freetype2/src/base/ftbbox.c:1.1.1.5
--- xc/extras/freetype2/src/base/ftbbox.c:1.1.1.4	Sun Dec 16 12:49:26 2001
+++ xc/extras/freetype2/src/base/ftbbox.c	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType bbox computation (body).                                    */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used        */
@@ -622,7 +622,7 @@
       /* the two boxes are different, now walk over the outline to */
       /* get the Bezier arc extrema.                               */
 
-      static const FT_Outline_Funcs  interface =
+      static const FT_Outline_Funcs  bbox_interface =
       {
         (FT_Outline_MoveTo_Func) BBox_Move_To,
         (FT_Outline_LineTo_Func) BBox_Move_To,
@@ -637,7 +637,7 @@
 
       user.bbox = bbox;
 
-      error = FT_Outline_Decompose( outline, &interface, &user );
+      error = FT_Outline_Decompose( outline, &bbox_interface, &user );
       if ( error )
         return error;
 
Index: xc/extras/freetype2/src/base/ftbdf.c
diff -u /dev/null xc/extras/freetype2/src/base/ftbdf.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:44 2003
+++ xc/extras/freetype2/src/base/ftbdf.c	Thu Jun 20 04:16:12 2002
@@ -0,0 +1,63 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbdf.c                                                                */
+/*                                                                         */
+/*    FreeType API for accessing BDF-specific strings (body).              */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_BDF_TYPES_H
+#include FT_INTERNAL_OBJECTS_H
+
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_BDF_Charset_ID( FT_Face       face,
+                         const char*  *acharset_encoding,
+                         const char*  *acharset_registry )
+  {
+    FT_Error     error;
+    const char*  encoding = NULL;
+    const char*  registry = NULL;
+    
+
+    error = FT_Err_Invalid_Argument;
+    
+    if ( face != NULL && face->driver != NULL )
+    {
+      FT_Module  driver = (FT_Module) face->driver;
+      
+
+      if ( driver->clazz && driver->clazz->module_name         &&
+           ft_strcmp( driver->clazz->module_name, "bdf" ) == 0 )
+      {
+        BDF_Public_Face  bdf_face = (BDF_Public_Face)face;
+        
+
+        encoding = (const char*) bdf_face->charset_encoding;
+        registry = (const char*) bdf_face->charset_registry;
+        error    = 0;
+      }           
+    }
+  
+    if ( acharset_encoding )
+      *acharset_encoding = encoding;
+    
+    if ( acharset_registry )
+      *acharset_registry = registry;
+    
+    return error;
+  }                         
+
+
+/* END */
Index: xc/extras/freetype2/src/base/ftcalc.c
diff -u xc/extras/freetype2/src/base/ftcalc.c:1.1.1.5 xc/extras/freetype2/src/base/ftcalc.c:1.1.1.6
--- xc/extras/freetype2/src/base/ftcalc.c:1.1.1.5	Mon Jan 14 11:52:09 2002
+++ xc/extras/freetype2/src/base/ftcalc.c	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Arithmetic computations (body).                                      */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -39,7 +39,6 @@
 
 
 /* we need to define a 64-bits data type here */
-#ifndef FT_CONFIG_OPTION_OLD_CALCS
 
 #ifdef FT_LONG64
 
@@ -56,9 +55,7 @@
 
 #endif /* FT_LONG64 */
 
-#endif /* !FT_CONFIG_OPTION_OLD_CALCS */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -70,7 +67,7 @@
 
 
   /* The following three functions are available regardless of whether */
-  /* FT_LONG64 or FT_CONFIG_OPTION_OLD_CALCS is defined.               */
+  /* FT_LONG64 is defined.                                             */
 
   /* documentation is in freetype.h */
 
@@ -102,27 +99,6 @@
   }
 
 
-#ifdef FT_CONFIG_OPTION_OLD_CALCS
-
-  static const FT_Long  ft_square_roots[63] =
-  {
-       1L,    1L,    2L,     3L,     4L,     5L,     8L,    11L,
-      16L,   22L,   32L,    45L,    64L,    90L,   128L,   181L,
-     256L,  362L,  512L,   724L,  1024L,  1448L,  2048L,  2896L,
-    4096L, 5892L, 8192L, 11585L, 16384L, 23170L, 32768L, 46340L,
-
-      65536L,   92681L,  131072L,   185363L,   262144L,   370727L,
-     524288L,  741455L, 1048576L,  1482910L,  2097152L,  2965820L,
-    4194304L, 5931641L, 8388608L, 11863283L, 16777216L, 23726566L,
-
-      33554432L,   47453132L,   67108864L,   94906265L,
-     134217728L,  189812531L,  268435456L,  379625062L,
-     536870912L,  759250125L, 1073741824L, 1518500250L,
-    2147483647L
-  };
-
-#else
-
   /* documentation is in ftcalc.h */
 
   FT_EXPORT_DEF( FT_Int32 )
@@ -152,11 +128,10 @@
     return root;
   }
 
-#endif /* FT_CONFIG_OPTION_OLD_CALCS */
-
 
 #ifdef FT_LONG64
 
+
   /* documentation is in freetype.h */
 
   FT_EXPORT_DEF( FT_Long )
@@ -222,51 +197,6 @@
   }
 
 
-#ifdef FT_CONFIG_OPTION_OLD_CALCS
-
-  /* a helper function for FT_Sqrt64() */
-
-  static int
-  ft_order64( FT_Int64  z )
-  {
-    int  j = 0;
-
-
-    while ( z )
-    {
-      z = (unsigned FT_INT64)z >> 1;
-      j++;
-    }
-    return j - 1;
-  }
-
-
-  /* documentation is in ftcalc.h */
-
-  FT_EXPORT_DEF( FT_Int32 )
-  FT_Sqrt64( FT_Int64  l )
-  {
-    FT_Int64  r, s;
-
-
-    if ( l <= 0 ) return 0;
-    if ( l == 1 ) return 1;
-
-    r = ft_square_roots[ft_order64( l )];
-
-    do
-    {
-      s = r;
-      r = ( r + l / r ) >> 1;
-
-    } while ( r > s || r * r > l );
-
-    return (FT_Int32)r;
-  }
-
-#endif /* FT_CONFIG_OPTION_OLD_CALCS */
-
-
 #else /* FT_LONG64 */
 
 
@@ -427,7 +357,7 @@
            ( ( al * ( ub & 0xFFFF ) + 0x8000 ) >> 16 );
     }
 
-    return ( s < 0 ? -(FT_Long)ua : ua );
+    return ( s < 0 ? -(FT_Long)ua : (FT_Long)ua );
   }
 
 
@@ -498,7 +428,9 @@
 
   /* apparently, the second version of this code is not compiled correctly */
   /* on Mac machines with the MPW C compiler..  tsss, tsss, tss...         */
+
 #if 1
+
   FT_EXPORT_DEF( FT_Int32 )
   FT_Div64by32( FT_Int64*  x,
                 FT_Int32   y )
@@ -550,7 +482,9 @@
 
     return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
   }
-#else
+
+#else /* 0 */
+
   FT_EXPORT_DEF( FT_Int32 )
   FT_Div64by32( FT_Int64*  x,
                 FT_Int32   y )
@@ -582,86 +516,8 @@
 
     return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
   }
-#endif
-
-
-#ifdef FT_CONFIG_OPTION_OLD_CALCS
-
-
-  /* two helper functions for FT_Sqrt64() */
-
-  static void
-  FT_Sub64( FT_Int64*  x,
-            FT_Int64*  y,
-            FT_Int64*  z )
-  {
-    register FT_UInt32  lo, hi;
-
-
-    lo = x->lo - y->lo;
-    hi = x->hi - y->hi - ( (FT_Int32)lo < 0 );
-
-    z->lo = lo;
-    z->hi = hi;
-  }
-
-
-  static int
-  ft_order64( FT_Int64*  z )
-  {
-    FT_UInt32  i;
-    int        j;
-
-
-    i = z->lo;
-    j = 0;
-    if ( z->hi )
-    {
-      i = z->hi;
-      j = 32;
-    }
-
-    while ( i > 0 )
-    {
-      i >>= 1;
-      j++;
-    }
-    return j - 1;
-  }
-
-
-  /* documentation is in ftcalc.h */
-
-  FT_EXPORT_DEF( FT_Int32 )
-  FT_Sqrt64( FT_Int64*  l )
-  {
-    FT_Int64  l2;
-    FT_Int32  r, s;
-
-
-    if ( (FT_Int32)l->hi < 0          ||
-         ( l->hi == 0 && l->lo == 0 ) )
-      return 0;
-
-    s = ft_order64( l );
-    if ( s == 0 )
-      return 1;
-
-    r = ft_square_roots[s];
-    do
-    {
-      s = r;
-      r = ( r + FT_Div64by32( l, r ) ) >> 1;
-      FT_MulTo64( r, r,   &l2 );
-      FT_Sub64  ( l, &l2, &l2 );
-
-    } while ( r > s || (FT_Int32)l2.hi < 0 );
-
-    return r;
-  }
-
 
-#endif /* FT_CONFIG_OPTION_OLD_CALCS */
+#endif /* 0 */
 
 
 #endif /* FT_LONG64 */
Index: xc/extras/freetype2/src/base/ftdbgmem.c
diff -u xc/extras/freetype2/src/base/ftdbgmem.c:1.1.1.1 xc/extras/freetype2/src/base/ftdbgmem.c:1.1.1.2
--- xc/extras/freetype2/src/base/ftdbgmem.c:1.1.1.1	Mon Jan 14 11:52:09 2002
+++ xc/extras/freetype2/src/base/ftdbgmem.c	Thu Jun 20 04:16:12 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Memory debugger (body).                                              */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -30,7 +30,6 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 
   typedef struct FT_MemNodeRec_*   FT_MemNode;
@@ -43,15 +42,15 @@
     FT_Byte*     address;
     FT_Long      size;     /* < 0 if the block was freed */
 
-   const char*  alloc_file_name;
+    const char*  alloc_file_name;
     FT_Long      alloc_line_no;
 
-   const char*  free_file_name;
+    const char*  free_file_name;
     FT_Long      free_line_no;
 
     FT_MemNode   link;
 
- } FT_MemNodeRec;
+  } FT_MemNodeRec;
 
 
   typedef struct  FT_MemTableRec_
@@ -64,16 +63,16 @@
     FT_ULong         alloc_current;
     FT_ULong         alloc_max;
 
-   const char*      file_name;
+    const char*      file_name;
     FT_Long          line_no;
 
     FT_Memory        memory;
-   FT_Pointer       memory_user;
+    FT_Pointer       memory_user;
     FT_Alloc_Func    alloc;
     FT_Free_Func     free;
     FT_Realloc_Func  realloc;
 
- } FT_MemTableRec;
+  } FT_MemTableRec;
 
 
 #define FT_MEM_SIZE_MIN  7
@@ -122,9 +121,7 @@
   };
 
 
-#include <stdarg.h>
 
-
   extern void
   ft_mem_debug_panic( const char*  fmt, ... )
   {
@@ -199,12 +196,13 @@
       FT_ULong     i;
 
 
-      new_buckets = ft_mem_table_alloc( table,
+      new_buckets = (FT_MemNode *)
+                    ft_mem_table_alloc( table,
                                         new_size * sizeof ( FT_MemNode ) );
       if ( new_buckets == NULL )
         return;
 
-      MEM_Set( new_buckets, 0, sizeof ( FT_MemNode ) * new_size );
+      FT_MEM_SET( new_buckets, 0, sizeof ( FT_MemNode ) * new_size );
 
       for ( i = 0; i < table->size; i++ )
       {
@@ -241,11 +239,11 @@
     FT_MemTable  table;
 
 
-    table = memory->alloc( memory, sizeof ( *table ) );
+    table = (FT_MemTable)memory->alloc( memory, sizeof ( *table ) );
     if ( table == NULL )
       goto Exit;
 
-    MEM_Set( table, 0, sizeof ( *table ) );
+    FT_MEM_SET( table, 0, sizeof ( *table ) );
 
     table->size  = FT_MEM_SIZE_MIN;
     table->nodes = 0;
@@ -258,17 +256,18 @@
     table->realloc = memory->realloc;
     table->free    = memory->free;
 
-    table->buckets = memory->alloc( memory,
+    table->buckets = (FT_MemNode *)
+                     memory->alloc( memory,
                                     table->size * sizeof ( FT_MemNode ) );
     if ( table->buckets )
-      MEM_Set( table->buckets, 0, sizeof ( FT_MemNode ) * table->size );
+      FT_MEM_SET( table->buckets, 0, sizeof ( FT_MemNode ) * table->size );
     else
     {
       memory->free( memory, table );
       table = NULL;
     }
 
- Exit:
+  Exit:
     return table;
   }
 
@@ -322,13 +321,14 @@
 
       table->size   = 0;
       table->nodes  = 0;
-      free( table );
 
       printf(
         "FreeType: total memory allocations = %ld\n", table->alloc_total );
       printf(
         "FreeType: maximum memory footprint = %ld\n", table->alloc_max );
 
+      free( table );
+
       if ( leak_count > 0 )
         ft_mem_debug_panic(
           "FreeType: %ld bytes of memory leaked in %ld blocks\n",
@@ -395,7 +395,7 @@
       }
 
       /* we need to create a new node in this table */
-      node = ft_mem_table_alloc( table, sizeof ( *node ) );
+      node = (FT_MemNode)ft_mem_table_alloc( table, sizeof ( *node ) );
       if ( node == NULL )
         ft_mem_debug_panic( "not enough memory to run memory tests" );
 
@@ -449,7 +449,7 @@
 
         /* we simply invert the node's size to indicate that the node */
         /* was freed.  We also change its contents.                   */
-        MEM_Set( address, 0xF3, node->size );
+        FT_MEM_SET( address, 0xF3, node->size );
 
         table->alloc_current -= node->size;
         node->size            = -node->size;
@@ -469,14 +469,14 @@
   ft_mem_debug_alloc( FT_Memory  memory,
                       FT_Long    size )
   {
-    FT_MemTable  table = memory->user;
+    FT_MemTable  table = (FT_MemTable)memory->user;
     FT_Byte*     block;
 
 
     if ( size <= 0 )
       ft_mem_debug_panic( "negative block size allocation (%ld)", size );
 
-    block = ft_mem_table_alloc( table, size );
+    block = (FT_Byte *)ft_mem_table_alloc( table, size );
     if ( block )
       ft_mem_table_set( table, block, (FT_ULong)size );
 
@@ -491,7 +491,7 @@
   ft_mem_debug_free( FT_Memory   memory,
                      FT_Pointer  block )
   {
-    FT_MemTable  table = memory->user;
+    FT_MemTable  table = (FT_MemTable)memory->user;
 
 
     if ( block == NULL )
@@ -513,7 +513,7 @@
                         FT_Long     new_size,
                         FT_Pointer  block )
   {
-    FT_MemTable  table = memory->user;
+    FT_MemTable  table = (FT_MemTable)memory->user;
     FT_MemNode   node, *pnode;
     FT_Pointer   new_block;
 
@@ -544,7 +544,7 @@
         block, file_name, line_no );
 
     if ( node->size != cur_size )
-      ft_mem_debug_panic( "invalid realloc request for %p. cur_size is "
+      ft_mem_debug_panic( "invalid ft_realloc request for %p. cur_size is "
                           "%ld instead of %ld in (%s:%ld)",
                           block, cur_size, node->size, file_name, line_no );
 
@@ -552,7 +552,7 @@
     if ( new_block == NULL )
       return NULL;
 
-    memcpy( new_block, block, cur_size < new_size ? cur_size : new_size );
+    ft_memcpy( new_block, block, cur_size < new_size ? cur_size : new_size );
 
     table->file_name = file_name;
     table->line_no   = line_no;
@@ -589,7 +589,7 @@
   extern void
   ft_mem_debug_done( FT_Memory  memory )
   {
-    FT_MemTable  table = memory->user;
+    FT_MemTable  table = (FT_MemTable)memory->user;
 
 
     if ( table )
@@ -611,7 +611,7 @@
                   const char*  file_name,
                   FT_Long      line_no )
   {
-    FT_MemTable  table = memory->user;
+    FT_MemTable  table = (FT_MemTable)memory->user;
 
 
     if ( table )
@@ -631,7 +631,7 @@
                     const char*  file_name,
                     FT_Long      line_no )
   {
-    FT_MemTable  table = memory->user;
+    FT_MemTable  table = (FT_MemTable)memory->user;
 
 
     if ( table )
@@ -649,7 +649,7 @@
                  const char*  file_name,
                  FT_Long      line_no )
   {
-    FT_MemTable  table = memory->user;
+    FT_MemTable  table = (FT_MemTable)memory->user;
 
 
     if ( table )
@@ -657,7 +657,7 @@
       table->file_name = file_name;
       table->line_no   = line_no;
     }
-    FT_Free( memory, block );
+    FT_Free( memory, (void **)block );
   }
 
 
Index: xc/extras/freetype2/src/base/ftdebug.c
diff -u xc/extras/freetype2/src/base/ftdebug.c:1.1.1.3 xc/extras/freetype2/src/base/ftdebug.c:1.1.1.4
--- xc/extras/freetype2/src/base/ftdebug.c:1.1.1.3	Sun Dec 16 12:49:26 2001
+++ xc/extras/freetype2/src/base/ftdebug.c	Thu Jun 20 04:16:13 2002
@@ -42,22 +42,12 @@
 
 
 #include <ft2build.h>
+#include FT_FREETYPE_H
 #include FT_INTERNAL_DEBUG_H
 
 
-#ifdef FT_DEBUG_LEVEL_TRACE
-  char  ft_trace_levels[trace_max];
-#endif
-
-
-#if defined( FT_DEBUG_LEVEL_ERROR ) || defined( FT_DEBUG_LEVEL_TRACE )
-
-
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
+#if defined( FT_DEBUG_LEVEL_ERROR )
 
-
   FT_EXPORT_DEF( void )
   FT_Message( const char*  fmt, ... )
   {
@@ -83,36 +73,125 @@
     exit( EXIT_FAILURE );
   }
 
+#endif /* FT_DEBUG_LEVEL_ERROR */
 
-#ifdef FT_DEBUG_LEVEL_TRACE
 
-  FT_EXPORT_DEF( void )
-  FT_SetTraceLevel( FT_Trace  component,
-                    char      level )
-  {
-    if ( component >= trace_max )
-      return;
 
-    /* if component is `trace_any', change _all_ levels at once */
-    if ( component == trace_any )
-    {
-      int  n;
+#ifdef FT_DEBUG_LEVEL_TRACE
 
+  /* array of trace levels, initialized to 0 */
+  int  ft_trace_levels[trace_count];
 
-      for ( n = trace_any; n < trace_max; n++ )
-        ft_trace_levels[n] = level;
+  /* define array of trace toggle names */
+#define FT_TRACE_DEF(x)  #x ,
+
+  static const char*  ft_trace_toggles[trace_count + 1] =
+  { 
+#include FT_INTERNAL_TRACE_H
+    NULL
+  };
+
+#undef FT_TRACE_DEF
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Initialize the tracing sub-system.  This is done by retrieving the    */
+  /* value of the "FT2_DEBUG" environment variable.  It must be a list of  */
+  /* toggles, separated by spaces, `;' or `:'.  Example:                   */
+  /*                                                                       */
+  /*    "any=3 memory=6 stream=5"                                          */
+  /*                                                                       */
+  /* This will request that all levels be set to 3, except the trace level */
+  /* for the memory and stream components which are set to 6 and 5,        */
+  /* respectively.                                                         */
+  /*                                                                       */
+  /* See the file <freetype/internal/fttrace.h> for details of the         */
+  /* available toggle names.                                               */
+  /*                                                                       */
+  /* The level must be between 0 and 6; 0 means quiet (except for serious  */
+  /* runtime errors), and 6 means _very_ verbose.                          */
+  /*                                                                       */
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    const char*  ft2_debug = getenv( "FT2_DEBUG" );
+    
+    if ( ft2_debug )
+    {
+      const char*  p = ft2_debug;
+      const char*  q;
+      
+
+      for ( ; *p; p++ )
+      {
+        /* skip leading whitespace and separators */
+        if ( *p == ' ' || *p == '\t' || *p == ':' || *p == ';' || *p == '=' )
+          continue;
+          
+        /* read toggle name, followed by '=' */
+        q = p;
+        while ( *p && *p != '=' )
+          p++;
+          
+        if ( *p == '=' && p > q )
+        {
+          int  n, i, len = p - q;
+          int  level = -1, found = -1;
+          
+
+          for ( n = 0; n < trace_count; n++ )
+          {
+            const char*  toggle = ft_trace_toggles[n];
+            
+
+            for ( i = 0; i < len; i++ )
+            {
+              if ( toggle[i] != q[i] )
+                break;
+            }
+            
+            if ( i == len && toggle[i] == 0 )
+            {
+              found = n;
+              break;
+            }
+          }
+          
+          /* read level */
+          p++;
+          if ( *p )
+          {
+            level = *p++ - '0';
+            if ( level < 0 || level > 6 )
+              level = -1;
+          }
+          
+          if ( found >= 0 && level >= 0 )
+          {
+            if ( found == trace_any )
+            {
+              /* special case for "any" */
+              for ( n = 0; n < trace_count; n++ )
+                ft_trace_levels[n] = level;
+            }
+            else
+              ft_trace_levels[found] = level;
+          }
+        }
+      }
     }
-    else        /* otherwise, only change individual component */
-      ft_trace_levels[component] = level;
   }
-
-#endif /* FT_DEBUG_LEVEL_TRACE */
 
-#endif /* FT_DEBUG_LEVEL_TRACE || FT_DEBUG_LEVEL_ERROR */
+#else  /* !FT_DEBUG_LEVEL_TRACE */
 
+  FT_BASE_DEF( void )
+  ft_debug_init( void )
+  {
+    /* nothing */
+  }
 
-  /* ANSI C doesn't allow empty files, so we insert a dummy symbol */
-  extern const int  ft_debug_dummy;
+#endif /* !FT_DEBUG_LEVEL_TRACE */
 
 
 /* END */
Index: xc/extras/freetype2/src/base/ftexcept.c
diff -u /dev/null xc/extras/freetype2/src/base/ftexcept.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:44 2003
+++ xc/extras/freetype2/src/base/ftexcept.c	Thu Jun 20 04:16:13 2002
@@ -0,0 +1,197 @@
+#include <ft2build.h>
+#include FT_EXCEPT_H
+
+
+  FT_BASE_DEF( void )
+  ft_cleanup_stack_init( FT_CleanupStack  stack,
+                         FT_Memory        memory )
+  {
+    stack->chunk = &stack->chunk_0;
+    stack->top   = stack->chunk->items;
+    stack->limit = stack->top + FT_CLEANUP_CHUNK_SIZE;
+    stack->chunk_0.link = NULL;
+
+    stack->memory = memory;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_cleanup_stack_done( FT_CleanupStack  stack )
+  {
+    FT_Memory        memory = stack->memory;
+    FT_CleanupChunk  chunk, next;
+
+    for (;;)
+    {
+      chunk = stack->chunk;
+      if ( chunk == &stack->chunk_0 )
+        break;
+
+      stack->chunk = chunk->link;
+
+      FT_Free( chunk, memory );
+    }
+
+    stack->memory = NULL;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_cleanup_stack_push( FT_CleanupStack  stack,
+                         FT_Pointer       item,
+                         FT_CleanupFunc   item_func,
+                         FT_Pointer       item_data )
+  {
+    FT_CleanupItem  top;
+
+
+    FT_ASSERT( stack && stack->chunk && stack->top );
+    FT_ASSERT( item  && item_func );
+
+    top = stack->top;
+
+    top->item      = item;
+    top->item_func = item_func;
+    top->item_data = item_data;
+
+    top ++;
+
+    if ( top == stack->limit )
+    {
+      FT_CleanupChunk  chunk;
+
+      chunk = FT_QAlloc( sizeof(*chunk), stack->memory );
+
+      chunk->link  = stack->chunk;
+      stack->chunk = chunk;
+      stack->limit = chunk->items + FT_CLEANUP_CHUNK_SIZE;
+      top          = chunk->items;
+    }
+
+    stack->top = top;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_cleanup_stack_pop( FT_CleanupStack   stack,
+                        FT_Int            destroy )
+  {
+    FT_CleanupItem  top;
+
+
+    FT_ASSERT( stack && stack->chunk && stack->top );
+    top = stack->top;
+
+    if ( top == stack->chunk->items )
+    {
+      FT_CleanupChunk  chunk;
+
+      chunk = stack->chunk;
+
+      if ( chunk == &stack->chunk_0 )
+      {
+        FT_ERROR(( "cleanup.pop: empty cleanup stack !!\n" ));
+        ft_cleanup_throw( stack, FT_Err_EmptyCleanupStack );
+      }
+
+      chunk = chunk->link;
+      FT_QFree( stack->chunk, stack->memory );
+
+      stack->chunk = chunk;
+      stack->limit = chunk->items + FT_CLEANUP_CHUNK_SIZE;
+      top          = stack->limit;
+    }
+
+    top --;
+
+    if ( destroy )
+      top->item_func( top->item, top->item_data );
+
+    top->item      = NULL;
+    top->item_func = NULL;
+    top->item_data = NULL;
+
+    stack->top = top;
+  }
+
+
+
+  FT_BASE_DEF( FT_CleanupItem )
+  ft_cleanup_stack_peek( FT_CleanupStack  stack )
+  {
+    FT_CleanupItem   top;
+    FT_CleanupChunk  chunk;
+
+
+    FT_ASSERT( stack && stack->chunk && stack->top );
+
+    top   = stack->top;
+    chunk = stack->chunk;
+
+    if ( top > chunk->items )
+      top--;
+    else
+    {
+      chunk = chunk->link;
+      top   = NULL;
+      if ( chunk != NULL )
+        top = chunk->items + FT_CLEANUP_CHUNK_SIZE - 1;
+    }
+    return top;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_xhandler_enter( FT_XHandler  xhandler,
+                     FT_Memory    memory )
+  {
+    FT_CleanupStack  stack = FT_MEMORY__CLEANUP(memory);
+
+    xhandler->previous = stack->xhandler;
+    xhandler->cleanup  = stack->top;
+    xhandler->error    = 0;
+    stack->xhandler    = xhandler;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_xhandler_exit( FT_XHandler  xhandler )
+  {
+    FT_CleanupStack  stack = FT_MEMORY__CLEANUP(memory);
+
+    stack->xhandler    = xhandler->previous;
+    xhandler->previous = NULL;
+    xhandler->error    = error;
+    xhandler->cleanup  = NULL;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_cleanup_throw( FT_CleanupStack  stack,
+                    FT_Error         error )
+  {
+    FT_XHandler  xhandler = stack->xhandler;
+
+    if ( xhandler == NULL )
+    {
+      /* no exception handler was registered. this  */
+      /* means that we have an un-handled exception */
+      /* the only thing we can do is _PANIC_ and    */
+      /* halt the current program..                 */
+      /*                                            */
+      FT_ERROR(( "FREETYPE PANIC: An un-handled exception occured. Program aborted" ));
+      ft_exit(1);
+    }
+
+    /* cleanup the stack until we reach the handler's */
+    /* starting stack location..                      */
+
+    xhandler->error = error;
+    longmp( xhandler->jump_buffer, 1 );
+  }                    
\ No newline at end of file
Index: xc/extras/freetype2/src/base/ftgloadr.c
diff -u /dev/null xc/extras/freetype2/src/base/ftgloadr.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:44 2003
+++ xc/extras/freetype2/src/base/ftgloadr.c	Thu Jun 20 04:16:13 2002
@@ -0,0 +1,361 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgloadr.c                                                             */
+/*                                                                         */
+/*    The FreeType glyph loader (body).                                    */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_GLYPH_LOADER_H
+#include FT_INTERNAL_MEMORY_H
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_gloader
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*****                    G L Y P H   L O A D E R                    *****/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The glyph loader is a simple object which is used to load a set of    */
+  /* glyphs easily.  It is critical for the correct loading of composites. */
+  /*                                                                       */
+  /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
+  /*                                                                       */
+  /*   loader.base     Is really the bottom of the stack.  It describes a  */
+  /*                   single glyph image made of the juxtaposition of     */
+  /*                   several glyphs (those `in the stack').              */
+  /*                                                                       */
+  /*   loader.current  Describes the top of the stack, on which a new      */
+  /*                   glyph can be loaded.                                */
+  /*                                                                       */
+  /*   Rewind          Clears the stack.                                   */
+  /*   Prepare         Set up `loader.current' for addition of a new glyph */
+  /*                   image.                                              */
+  /*   Add             Add the `current' glyph image to the `base' one,    */
+  /*                   and prepare for another one.                        */
+  /*                                                                       */
+  /* The glyph loader is now a base object.  Each driver used to           */
+  /* re-implement it in one way or the other, which wasted code and        */
+  /* energy.                                                               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* create a new glyph loader */
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_New( FT_Memory        memory,
+                      FT_GlyphLoader  *aloader )
+  {
+    FT_GlyphLoader  loader;
+    FT_Error        error;
+
+
+    if ( !FT_NEW( loader ) )
+    {
+      loader->memory = memory;
+      *aloader       = loader;
+    }
+    return error;
+  }
+
+
+  /* rewind the glyph loader - reset counters to 0 */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Rewind( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+
+    base->outline.n_points   = 0;
+    base->outline.n_contours = 0;
+    base->num_subglyphs      = 0;
+
+    *current = *base;
+  }
+
+
+  /* reset the glyph loader, frees all allocated tables */
+  /* and starts from zero                               */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Reset( FT_GlyphLoader  loader )
+  {
+    FT_Memory memory = loader->memory;
+
+
+    FT_FREE( loader->base.outline.points );
+    FT_FREE( loader->base.outline.tags );
+    FT_FREE( loader->base.outline.contours );
+    FT_FREE( loader->base.extra_points );
+    FT_FREE( loader->base.subglyphs );
+
+    loader->max_points    = 0;
+    loader->max_contours  = 0;
+    loader->max_subglyphs = 0;
+
+    FT_GlyphLoader_Rewind( loader );
+  }
+
+
+  /* delete a glyph loader */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Done( FT_GlyphLoader  loader )
+  {
+    if ( loader )
+    {
+      FT_Memory memory = loader->memory;
+
+
+      FT_GlyphLoader_Reset( loader );
+      FT_FREE( loader );
+    }
+  }
+
+
+  /* re-adjust the `current' outline fields */
+  static void
+  FT_GlyphLoader_Adjust_Points( FT_GlyphLoader  loader )
+  {
+    FT_Outline*  base    = &loader->base.outline;
+    FT_Outline*  current = &loader->current.outline;
+
+
+    current->points   = base->points   + base->n_points;
+    current->tags     = base->tags     + base->n_points;
+    current->contours = base->contours + base->n_contours;
+
+    /* handle extra points table - if any */
+    if ( loader->use_extra )
+      loader->current.extra_points =
+        loader->base.extra_points + base->n_points;
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CreateExtra( FT_GlyphLoader  loader )
+  {
+    FT_Error   error;
+    FT_Memory  memory = loader->memory;
+
+
+    if ( !FT_NEW_ARRAY( loader->base.extra_points, loader->max_points ) )
+    {
+      loader->use_extra = 1;
+      FT_GlyphLoader_Adjust_Points( loader );
+    }
+    return error;
+  }
+
+
+  /* re-adjust the `current' subglyphs field */
+  static void
+  FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+
+    current->subglyphs = base->subglyphs + base->num_subglyphs;
+  }
+
+
+  /* Ensure that we can add `n_points' and `n_contours' to our glyph. this */
+  /* function reallocates its outline tables if necessary.  Note that it   */
+  /* DOESN'T change the number of points within the loader!                */
+  /*                                                                       */
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CheckPoints( FT_GlyphLoader  loader,
+                               FT_UInt        n_points,
+                               FT_UInt        n_contours )
+  {
+    FT_Memory    memory  = loader->memory;
+    FT_Error     error   = FT_Err_Ok;
+    FT_Outline*  base    = &loader->base.outline;
+    FT_Outline*  current = &loader->current.outline;
+    FT_Bool      adjust  = 1;
+
+    FT_UInt      new_max, old_max;
+
+
+    /* check points & tags */
+    new_max = base->n_points + current->n_points + n_points;
+    old_max = loader->max_points;
+
+    if ( new_max > old_max )
+    {
+      new_max = ( new_max + 7 ) & -8;
+
+      if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
+           FT_RENEW_ARRAY( base->tags,   old_max, new_max ) )
+        goto Exit;
+
+      if ( loader->use_extra &&
+           FT_RENEW_ARRAY( loader->base.extra_points, old_max, new_max ) )
+        goto Exit;
+
+      adjust = 1;
+      loader->max_points = new_max;
+    }
+
+    /* check contours */
+    old_max = loader->max_contours;
+    new_max = base->n_contours + current->n_contours +
+              n_contours;
+    if ( new_max > old_max )
+    {
+      new_max = ( new_max + 3 ) & -4;
+      if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
+        goto Exit;
+
+      adjust = 1;
+      loader->max_contours = new_max;
+    }
+
+    if ( adjust )
+      FT_GlyphLoader_Adjust_Points( loader );
+
+  Exit:
+    return error;
+  }
+
+
+  /* Ensure that we can add `n_subglyphs' to our glyph. this function */
+  /* reallocates its subglyphs table if necessary.  Note that it DOES */
+  /* NOT change the number of subglyphs within the loader!            */
+  /*                                                                  */
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader  loader,
+                                 FT_UInt         n_subs )
+  {
+    FT_Memory     memory = loader->memory;
+    FT_Error      error  = FT_Err_Ok;
+    FT_UInt       new_max, old_max;
+
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+
+    new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
+    old_max = loader->max_subglyphs;
+    if ( new_max > old_max )
+    {
+      new_max = ( new_max + 1 ) & -2;
+      if ( FT_RENEW_ARRAY( base->subglyphs, old_max, new_max ) )
+        goto Exit;
+
+      loader->max_subglyphs = new_max;
+
+      FT_GlyphLoader_Adjust_Subglyphs( loader );
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* prepare loader for the addition of a new glyph on top of the base one */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Prepare( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  current = &loader->current;
+
+
+    current->outline.n_points   = 0;
+    current->outline.n_contours = 0;
+    current->num_subglyphs      = 0;
+
+    FT_GlyphLoader_Adjust_Points   ( loader );
+    FT_GlyphLoader_Adjust_Subglyphs( loader );
+  }
+
+
+  /* add current glyph to the base image - and prepare for another */
+  FT_BASE_DEF( void )
+  FT_GlyphLoader_Add( FT_GlyphLoader  loader )
+  {
+    FT_GlyphLoad  base    = &loader->base;
+    FT_GlyphLoad  current = &loader->current;
+
+    FT_UInt       n_curr_contours = current->outline.n_contours;
+    FT_UInt       n_base_points   = base->outline.n_points;
+    FT_UInt       n;
+
+
+    base->outline.n_points =
+      (short)( base->outline.n_points + current->outline.n_points );
+    base->outline.n_contours =
+      (short)( base->outline.n_contours + current->outline.n_contours );
+
+    base->num_subglyphs += current->num_subglyphs;
+
+    /* adjust contours count in newest outline */
+    for ( n = 0; n < n_curr_contours; n++ )
+      current->outline.contours[n] =
+        (short)( current->outline.contours[n] + n_base_points );
+
+    /* prepare for another new glyph image */
+    FT_GlyphLoader_Prepare( loader );
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_GlyphLoader_CopyPoints( FT_GlyphLoader  target,
+                             FT_GlyphLoader  source )
+  {
+    FT_Error  error;
+    FT_UInt   num_points   = source->base.outline.n_points;
+    FT_UInt   num_contours = source->base.outline.n_contours;
+
+
+    error = FT_GlyphLoader_CheckPoints( target, num_points, num_contours );
+    if ( !error )
+    {
+      FT_Outline*  out = &target->base.outline;
+      FT_Outline*  in  = &source->base.outline;
+
+
+      FT_MEM_COPY( out->points, in->points,
+                   num_points * sizeof ( FT_Vector ) );
+      FT_MEM_COPY( out->tags, in->tags,
+                   num_points * sizeof ( char ) );
+      FT_MEM_COPY( out->contours, in->contours,
+                   num_contours * sizeof ( short ) );
+
+      /* do we need to copy the extra points? */
+      if ( target->use_extra && source->use_extra )
+        FT_MEM_COPY( target->base.extra_points, source->base.extra_points,
+                     num_points * sizeof ( FT_Vector ) );
+
+      out->n_points   = (short)num_points;
+      out->n_contours = (short)num_contours;
+
+      FT_GlyphLoader_Adjust_Points( target );
+    }
+
+    return error;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/base/ftglyph.c
diff -u xc/extras/freetype2/src/base/ftglyph.c:1.1.1.5 xc/extras/freetype2/src/base/ftglyph.c:1.1.1.6
--- xc/extras/freetype2/src/base/ftglyph.c:1.1.1.5	Mon Jan 14 11:52:09 2002
+++ xc/extras/freetype2/src/base/ftglyph.c	Thu Jun 20 04:16:13 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType convenience functions to handle glyphs (body).              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -131,8 +131,8 @@
 
     size = (FT_ULong)( pitch * source->rows );
 
-    if ( !ALLOC( target->buffer, size ) )
-      MEM_Copy( target->buffer, source->buffer, size );
+    if ( !FT_ALLOC( target->buffer, size ) )
+      FT_MEM_COPY( target->buffer, source->buffer, size );
 
     return error;
   }
@@ -158,8 +158,8 @@
     glyph->left   = slot->bitmap_left;
     glyph->top    = slot->bitmap_top;
 
-    if ( slot->flags & ft_glyph_own_bitmap )
-      slot->flags &= ~ft_glyph_own_bitmap;
+    if ( slot->flags & FT_GLYPH_OWN_BITMAP )
+      slot->flags &= ~FT_GLYPH_OWN_BITMAP;
     else
     {
       /* copy the bitmap into a new buffer */
@@ -191,7 +191,7 @@
     FT_Memory  memory = FT_GLYPH(glyph)->library->memory;
 
 
-    FREE( glyph->bitmap.buffer );
+    FT_FREE( glyph->bitmap.buffer );
   }
 
 
@@ -253,13 +253,13 @@
       goto Exit;
 
     /* copy it */
-    MEM_Copy( target->points, source->points,
+    FT_MEM_COPY( target->points, source->points,
               source->n_points * sizeof ( FT_Vector ) );
 
-    MEM_Copy( target->tags, source->tags,
+    FT_MEM_COPY( target->tags, source->tags,
               source->n_points * sizeof ( FT_Byte ) );
 
-    MEM_Copy( target->contours, source->contours,
+    FT_MEM_COPY( target->contours, source->contours,
               source->n_contours * sizeof ( FT_Short ) );
 
     /* copy all flags, except the `ft_outline_owner' one */
@@ -361,7 +361,7 @@
 
      *aglyph = 0;
 
-     if ( !ALLOC( glyph, clazz->glyph_size ) )
+     if ( !FT_ALLOC( glyph, clazz->glyph_size ) )
      {
        glyph->library = library;
        glyph->clazz   = clazz;
@@ -594,7 +594,7 @@
     if ( !clazz || !clazz->glyph_prepare )
       goto Bad;
 
-    MEM_Set( &dummy, 0, sizeof ( dummy ) );
+    FT_MEM_SET( &dummy, 0, sizeof ( dummy ) );
     dummy.library = glyph->library;
     dummy.format  = clazz->glyph_format;
 
@@ -671,7 +671,7 @@
       if ( clazz->glyph_done )
         clazz->glyph_done( glyph );
 
-      FREE( glyph );
+      FT_FREE( glyph );
     }
   }
 
Index: xc/extras/freetype2/src/base/fthash.c
diff -u /dev/null xc/extras/freetype2/src/base/fthash.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/base/fthash.c	Thu Jun 20 04:16:13 2002
@@ -0,0 +1,215 @@
+#include "fthash.h"
+#include FT_INTERNAL_MEMORY_H
+#include FT_INTERNAL_DEBUG_H
+
+#define  FT_HASH_MAX_LOAD  2
+#define  FT_HASH_MIN_LOAD  1
+#define  FT_HASH_SUB_LOAD  (FT_HASH_MAX_LOAD-FT_HASH_MIN_LOAD)
+
+/* this one _must_ be a power of 2 !! */
+#define  FT_HASH_INITIAL_SIZE  8
+
+
+  FT_BASE_DEF( void )
+  ft_hash_done( FT_Hash              table,
+                FT_Hash_ForeachFunc  node_func,
+                const FT_Pointer     node_data )
+  {
+    if ( table )
+    {
+      FT_Memory  memory = table->memory;
+
+      if ( node_func )
+        ft_hash_foreach( table, node_func, node_data );
+
+      FT_FREE( table->buckets );
+      table->p     = 0;
+      table->mask  = 0;
+      table->slack = 0;
+
+      table->compare = NULL;
+    }
+  }
+
+
+  FT_BASE_DEF( FT_UInt )
+  ft_hash_get_size( FT_Hash  table )
+  {
+    FT_UInt  result = 0;
+
+    if ( table )
+      result = (table->p + table->mask + 1)*FT_HASH_MAX_LOAD - table->slack;
+
+    return result;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_hash_init( FT_Hash              table,
+                FT_Hash_CompareFunc  compare,
+                FT_Memory            memory )
+  {
+    hash->memory  = memory;
+    hash->compare = node_compare;
+    hash->p       = 0;
+    hash->mask    = FT_HASH_INITIAL_SIZE-1;
+    hash->slack   = FT_HASH_INITIAL_SIZE*FT_HASH_MAX_LOAD;
+
+    FT_NEW_ARRAY( hash->buckets, FT_HASH_INITIAL_SIZE*2 );
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_hash_foreach( FT_Hash              table,
+                   FT_Hash_ForeachFunc  foreach_func,
+                   const FT_Pointer     foreach_data )
+  {
+    FT_UInt       count = table->p + table->mask + 1;
+    FT_HashNode*  pnode = table->buckets;
+    FT_HashNode   node, next;
+
+    for ( ; count > 0; count--, pnode++ )
+    {
+      node = *pnode;
+      while ( node )
+      {
+        next = node->link;
+        foreach_func( node, foreach_data );
+        node = next;
+      }
+    }
+  }
+
+
+
+  FT_BASE_DEF( FT_HashNode* )
+  ft_hash_lookup( FT_Hash      table,
+                  FT_HashNode  keynode )
+  {
+    FT_UInt    index;
+    FT_UInt23  hash = keynode->hash;
+
+    index = (FT_UInt)(hash & table->mask);
+    if ( index < table->p )
+      index = (FT_UInt)(hash & (2*table->mask+1));
+
+    pnode = &table->buckets[index];
+    for (;;)
+    {
+      node = *pnode;
+      if ( node == NULL )
+        break;
+
+      if ( node->hash == hash && table->compare( node, keynode ) )
+        break;
+
+      pnode = &node->link;
+    }
+
+    return pnode;
+  }
+
+
+
+
+  FT_BASE_DEF( void )
+  ft_hash_add( FT_Hash       table,
+               FT_HashNode*  pnode,
+               FT_HashNode   new_node )
+  {
+    /* add it to the hash table */
+    new_node->link = *pnode;
+    *pnode         = new_node;
+
+    if ( --table->slack < 0 )
+    {
+      FT_UInt       p     = table->p;
+      FT_UInt       mask  = table->mask;
+      FT_HashNode   new_list;
+
+      /* split a single bucket */
+      new_list = NULL;
+      pnode    = table->buckets + p;
+      for (;;)
+      {
+        node = *pnode;
+        if ( node == NULL )
+          break;
+
+        if ( node->hash & mask )
+        {
+          *pnode     = node->link;
+          node->link = new_list;
+          new_list   = node;
+        }
+        else
+          pnode = &node->link;
+      }
+
+      table->buckets[ p + mask + 1 ] = new_list;
+
+      table->slack += FT_HASH_MAX_LOAD;
+
+      if ( p >= mask )
+      {
+        FT_RENEW_ARRAY( hash->buckets, (mask+1)*2, (mask+1)*4 );
+        table->mask = 2*mask + 1;
+        table->p    = 0;
+      }
+      else
+        table->p = p + 1;
+    }
+  }
+
+
+
+  FT_BASE_DEF( FT_Int )
+  ft_hash_remove( FT_Hash      table,
+                  FT_HashNode* pnode )
+  {
+    FT_HashNode  node;
+    FT_UInt      num_buckets;
+
+    FT_ASSERT( pnode != NULL && node != NULL );
+
+    node         = *pnode;
+    *pnode->link = node->link;
+    node->link   = NULL;
+
+    num_buckets = ( table->p + table->mask + 1) ;
+
+    if ( ++ table->slack > num_buckets*FT_HASH_SUB_LOAD )
+    {
+      FT_UInt       p         = table->p;
+      FT_UInt       mask      = table->mask;
+      FT_UInt       old_index = p + mask;
+      FT_HashNode*  pnode;
+      FT_HashNode*  pold;
+
+      if ( old_index < FT_HASH_INITIAL_SIZE )
+        return;
+
+      if ( p == 0 )
+      {
+        table->mask >>= 1;
+        p             = table->mask;
+
+        FT_RENEW_ARRAY( hash->buckets, (mask+1)*2, (mask) );
+      }
+      else
+        p--;
+
+      pnode = table->buckets + p;
+      while ( *pnode )
+        pnode = &(*pnode)->link;
+
+      pold   = table->buckets + old_index;
+      *pnode = *pold;
+      *pold  = NULL;
+
+      table->slack -= FT_HASH_MAX_LOAD;
+      table->p      = p;
+    }
+  }
Index: xc/extras/freetype2/src/base/ftinit.c
diff -u xc/extras/freetype2/src/base/ftinit.c:1.1.1.3 xc/extras/freetype2/src/base/ftinit.c:1.1.1.5
--- xc/extras/freetype2/src/base/ftinit.c:1.1.1.3	Sun Dec 16 12:49:26 2001
+++ xc/extras/freetype2/src/base/ftinit.c	Thu Jun 20 04:16:13 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType initialization layer (body).                                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -125,7 +125,13 @@
 
     error = FT_New_Library( memory, alibrary );
     if ( !error )
+    {
+      (*alibrary)->version_major = FREETYPE_MAJOR;
+      (*alibrary)->version_minor = FREETYPE_MINOR;
+      (*alibrary)->version_patch = FREETYPE_PATCH;
+
       FT_Add_Default_Modules( *alibrary );
+    }
 
     return error;
   }
Index: xc/extras/freetype2/src/base/ftlist.c
diff -u xc/extras/freetype2/src/base/ftlist.c:1.1.1.3 xc/extras/freetype2/src/base/ftlist.c:1.1.1.4
--- xc/extras/freetype2/src/base/ftlist.c:1.1.1.3	Sun Dec 16 12:49:26 2001
+++ xc/extras/freetype2/src/base/ftlist.c	Thu Jun 20 04:16:13 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Generic list support for FreeType (body).                            */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -205,7 +205,7 @@
       if ( destroy )
         destroy( memory, data, user );
 
-      FREE( cur );
+      FT_FREE( cur );
       cur = next;
     }
 
Index: xc/extras/freetype2/src/base/ftmac.c
diff -u xc/extras/freetype2/src/base/ftmac.c:1.1.1.4 xc/extras/freetype2/src/base/ftmac.c:1.2
--- xc/extras/freetype2/src/base/ftmac.c:1.1.1.4	Mon Jan 14 11:52:10 2002
+++ xc/extras/freetype2/src/base/ftmac.c	Wed Jan  1 17:08:40 2003
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Mac FOND support.  Written by just@letterror.com.                    */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -19,36 +19,38 @@
   /*
     Notes
 
-    Mac suitcase files can (and often do!) contain multiple fonts. To
+    Mac suitcase files can (and often do!) contain multiple fonts.  To
     support this I use the face_index argument of FT_(Open|New)_Face()
     functions, and pretend the suitcase file is a collection.
-    Warning: although the FOND driver sets face->num_faces field to the
+
+    Warning: Although the FOND driver sets face->num_faces field to the
     number of available fonts, but the Type 1 driver sets it to 1 anyway.
     So this field is currently not reliable, and I don't see a clean way
-    to  resolve that. The face_index argument translates to
+    to  resolve that.  The face_index argument translates to
+
       Get1IndResource( 'FOND', face_index + 1 );
+
     so clients should figure out the resource index of the FOND.
     (I'll try to provide some example code for this at some point.)
 
-
     The Mac FOND support works roughly like this:
 
     - Check whether the offered stream points to a Mac suitcase file.
       This is done by checking the file type: it has to be 'FFIL' or 'tfil'.
       The stream that gets passed to our init_face() routine is a stdio
       stream, which isn't usable for us, since the FOND resources live
-      in the resource fork. So we just grab the stream->pathname field.
+      in the resource fork.  So we just grab the stream->pathname field.
 
     - Read the FOND resource into memory, then check whether there is
-      a TrueType font and/or (!) a Type 1 font available.
+      a TrueType font and/or(!) a Type 1 font available.
 
     - If there is a Type 1 font available (as a separate 'LWFN' file),
       read its data into memory, massage it slightly so it becomes
       PFB data, wrap it into a memory stream, load the Type 1 driver
       and delegate the rest of the work to it by calling FT_Open_Face().
       (XXX TODO: after this has been done, the kerning data from the FOND
-      resource should be appended to the face: on the Mac there are usually
-      no AFM files available. However, this is tricky since we need to map
+      resource should be appended to the face: On the Mac there are usually
+      no AFM files available.  However, this is tricky since we need to map
       Mac char codes to ps glyph names to glyph ID's...)
 
     - If there is a TrueType font (an 'sfnt' resource), read it into
@@ -63,13 +65,16 @@
 #include "truetype/ttobjs.h"
 #include "type1/t1objs.h"
 
+#ifdef __GNUC__
+#include <Carbon/Carbon.h>
+#else
 #include <Resources.h>
 #include <Fonts.h>
 #include <Errors.h>
 #include <Files.h>
 #include <TextUtils.h>
+#endif
 
-#include <ctype.h>  /* for isupper() and isalnum() */
 
 #include FT_MAC_H
 
@@ -81,41 +86,42 @@
 #define PREFER_LWFN 1
 #endif
 
-
-  /* Quick'n'dirty Pascal string to C string converter.
-     Warning: this call is not thread safe! Use with caution. */
-  static char*
-  p2c_str( unsigned char*  pstr )
-  {
-    static char  cstr[256];
-
-
-    strncpy( cstr, (char*)pstr + 1, pstr[0] );
-    cstr[pstr[0]] = '\0';
-    return cstr;
-  }
-
-
   /* Given a pathname, fill in a file spec. */
   static int
   file_spec_from_path( const char*  pathname,
                        FSSpec*      spec )
   {
+#if TARGET_API_MAC_CARBON
+
+    OSErr  e;
+    FSRef  ref;
+
+
+    e = FSPathMakeRef( (UInt8 *)pathname, &ref, false /* not a directory */ );
+    if ( e == noErr )
+      e = FSGetCatalogInfo( &ref, kFSCatInfoNone, NULL, NULL, spec, NULL );
+
+    return ( e == noErr ) ? 0 : (-1);
+
+#else
+
     Str255    p_path;
     FT_ULong  path_len;
 
 
     /* convert path to a pascal string */
-    path_len = strlen( pathname );
+    path_len = ft_strlen( pathname );
     if ( path_len > 255 )
       return -1;
     p_path[0] = (unsigned char)path_len;
-    strncpy( (char*)p_path + 1, pathname, path_len );
+    ft_strncpy( (char*)p_path + 1, pathname, path_len );
 
     if ( FSMakeFSSpec( 0, 0, p_path, spec ) != noErr )
       return -1;
     else
       return 0;
+
+#endif
   }
 
 
@@ -133,24 +139,21 @@
   }
 
 
+#if TARGET_API_MAC_CARBON
+
   /* is this a Mac OS X .dfont file */
   static Boolean
   is_dfont( FSSpec*  spec )
   {
-    int nameLen = spec->name[0];
+    int  nameLen = spec->name[0];
 
 
-    if ( spec->name[nameLen - 5] == '.' &&
-         spec->name[nameLen - 4] == 'd' &&
-         spec->name[nameLen - 3] == 'f' &&
-         spec->name[nameLen - 2] == 'o' &&
-         spec->name[nameLen - 1] == 'n' &&
-         spec->name[nameLen    ] == 't'  )
-      return true;
-    else
-      return false;
+    return nameLen >= 6                                   &&
+           !memcmp( spec->name + nameLen - 5, ".dfont", 6 );
   }
 
+#endif
+
 
   /* Given a PostScript font name, create the Macintosh LWFN file name. */
   static void
@@ -172,7 +175,7 @@
           max = 3;
         count = 0;
       }
-      if ( count < max && ( isalnum( *q ) || *q == '_' ) )
+      if ( count < max && ( ft_isalnum( *q ) || *q == '_' ) )
       {
         *++p = *q;
         lwfn_file_name[0]++;
@@ -194,12 +197,12 @@
     FCBPBRec  pb;
     OSErr     error;
 
+
     pb.ioNamePtr = file_name;
     pb.ioVRefNum = 0;
     pb.ioRefNum  = ref_num;
     pb.ioFCBIndx = 0;
 
-
     error = PBGetFCBInfoSync( &pb );
     if ( error == noErr )
     {
@@ -281,7 +284,6 @@
       unsigned char*  p = (unsigned char*)fond_data;
       StyleTable*     style;
       unsigned short  string_count;
-      unsigned char*  name_table = 0;
       char            ps_name[256];
       unsigned char*  names[64];
       int             i;
@@ -299,16 +301,43 @@
         p += names[i][0];
         p++;
       }
-      strcpy( ps_name, p2c_str( names[0] ) );  /* Family name */
 
-      if ( style->indexes[0] > 1 )
       {
-        unsigned char*  suffixes = names[style->indexes[0] - 1];
+        size_t  ps_name_len = (size_t)names[0][0];
 
 
-        for ( i = 1; i <= suffixes[0]; i++ )
-          strcat( ps_name, p2c_str( names[suffixes[i] - 1] ) );
+        if ( ps_name_len != 0 )
+        {
+          memcpy(ps_name, names[0] + 1, ps_name_len);
+          ps_name[ps_name_len] = 0;
+        }
+        if ( style->indexes[0] > 1 )
+        {
+          unsigned char*  suffixes = names[style->indexes[0] - 1];
+
+
+          for ( i = 1; i < suffixes[0]; i++ )
+          {
+            unsigned char*  s;
+            size_t          j = suffixes[i] - 1;
+
+
+            if ( j < string_count && ( s = names[j] ) != NULL )
+            {
+              size_t  s_len = (size_t)s[0];
+
+
+              if ( s_len != 0 && ps_name_len + s_len < sizeof ( ps_name ) )
+              {
+                memcpy( ps_name + ps_name_len, s + 1, s_len );
+                ps_name_len += s_len;
+                ps_name[ps_name_len] = 0;
+              }
+            }
+          }
+        }
       }
+
       create_lwfn_name( ps_name, lwfn_file_name );
     }
   }
@@ -327,7 +356,7 @@
   {
     FT_Error       error = FT_Err_Ok;
     short          res_ref, res_id;
-    unsigned char  *buffer, *p, *size_p;
+    unsigned char  *buffer, *p, *size_p = NULL;
     FT_ULong       total_size = 0;
     FT_ULong       post_size, pfb_chunk_size;
     Handle         post_data;
@@ -341,7 +370,7 @@
 
     /* First pass: load all POST resources, and determine the size of
        the output buffer. */
-    res_id = 501;
+    res_id    = 501;
     last_code = -1;
 
     for (;;)
@@ -364,14 +393,14 @@
       last_code = code;
     }
 
-    if ( ALLOC( buffer, (FT_Long)total_size ) )
+    if ( FT_ALLOC( buffer, (FT_Long)total_size ) )
       goto Error;
 
     /* Second pass: append all POST data to the buffer, add PFB fields.
        Glue all consecutive chunks of the same type together. */
-    p = buffer;
-    res_id = 501;
-    last_code = -1;
+    p              = buffer;
+    res_id         = 501;
+    last_code      = -1;
     pfb_chunk_size = 0;
 
     for (;;)
@@ -388,10 +417,13 @@
         if ( last_code != -1 )
         {
           /* we're done adding a chunk, fill in the size field */
-          *size_p++ = (FT_Byte)(   pfb_chunk_size         & 0xFF );
-          *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8  ) & 0xFF );
-          *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );
-          *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );
+          if ( size_p != NULL )
+          {
+            *size_p++ = (FT_Byte)(   pfb_chunk_size         & 0xFF );
+            *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8  ) & 0xFF );
+            *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );
+            *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );
+          }
           pfb_chunk_size = 0;
         }
 
@@ -410,7 +442,7 @@
         }
       }
 
-      memcpy( p, *post_data + 2, post_size );
+      ft_memcpy( p, *post_data + 2, post_size );
       pfb_chunk_size += post_size;
       p += post_size;
       last_code = code;
@@ -433,7 +465,7 @@
     FT_Memory  memory = stream->memory;
 
 
-    FREE( stream->base );
+    FT_FREE( stream->base );
 
     stream->size  = 0;
     stream->base  = 0;
@@ -443,39 +475,36 @@
 
   /* Create a new memory stream from a buffer and a size. */
   static FT_Error
-  new_memory_stream( FT_Library       library,
-                     FT_Byte*         base,
-                     FT_ULong         size,
-                     FT_Stream_Close  close,
-                     FT_Stream*       astream )
+  new_memory_stream( FT_Library           library,
+                     FT_Byte*             base,
+                     FT_ULong             size,
+                     FT_Stream_CloseFunc  close,
+                     FT_Stream           *astream )
   {
-      FT_Error   error;
-      FT_Memory  memory;
-      FT_Stream  stream;
+    FT_Error   error;
+    FT_Memory  memory;
+    FT_Stream  stream;
 
 
-      if ( !library )
-        return FT_Err_Invalid_Library_Handle;
+    if ( !library )
+      return FT_Err_Invalid_Library_Handle;
 
-      if ( !base )
-        return FT_Err_Invalid_Argument;
+    if ( !base )
+      return FT_Err_Invalid_Argument;
 
-      *astream = 0;
-      memory = library->memory;
-      if ( ALLOC( stream, sizeof ( *stream ) ) )
-        goto Exit;
+    *astream = 0;
+    memory = library->memory;
+    if ( FT_NEW( stream ) )
+      goto Exit;
 
-      FT_New_Memory_Stream( library,
-                            base,
-                            size,
-                            stream );
+    FT_Stream_OpenMemory( stream, base, size );
 
-      stream->close = close;
+    stream->close = close;
 
-      *astream = stream;
+    *astream = stream;
 
-    Exit:
-      return error;
+  Exit:
+    return error;
   }
 
 
@@ -486,7 +515,7 @@
                          FT_ULong    size,
                          FT_Long     face_index,
                          char*       driver_name,
-                         FT_Face*    aface )
+                         FT_Face    *aface )
   {
     FT_Open_Args  args;
     FT_Error      error;
@@ -501,7 +530,7 @@
                                &stream );
     if ( error )
     {
-      FREE( base );
+      FT_FREE( base );
       return error;
     }
 
@@ -518,9 +547,10 @@
       (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
     else
     {
-      FT_Done_Stream( stream );
-      FREE( stream );
+      FT_Stream_CloseFunc( stream );
+      FT_FREE( stream );
     }
+
     return error;
   }
 
@@ -530,35 +560,17 @@
   FT_New_Face_From_LWFN( FT_Library  library,
                          FSSpec*     spec,
                          FT_Long     face_index,
-                         FT_Face*    aface )
+                         FT_Face    *aface )
   {
-    FT_Byte*   pfb_data;
-    FT_ULong   pfb_size;
-    FT_Error   error;
-    FT_Memory  memory = library->memory;
+    FT_Byte*  pfb_data;
+    FT_ULong  pfb_size;
+    FT_Error  error;
 
 
     error = read_lwfn( library->memory, spec, &pfb_data, &pfb_size );
     if ( error )
       return error;
 
-#if 0
-    {
-      FILE*  f;
-      char*  path;
-
-
-      path = p2c_str( spec->name );
-      strcat( path, ".PFB" );
-      f = fopen( path, "wb" );
-      if ( f )
-      {
-        fwrite( pfb_data, 1, pfb_size, f );
-        fclose( f );
-      }
-    }
-#endif
-
     return open_face_from_buffer( library,
                                   pfb_data,
                                   pfb_size,
@@ -573,12 +585,11 @@
   FT_New_Face_From_SFNT( FT_Library  library,
                          short       sfnt_id,
                          FT_Long     face_index,
-                         FT_Face*    aface )
+                         FT_Face    *aface )
   {
     Handle     sfnt = NULL;
     FT_Byte*   sfnt_data;
     size_t     sfnt_size;
-    FT_Stream  stream = NULL;
     FT_Error   error = 0;
     FT_Memory  memory = library->memory;
 
@@ -588,14 +599,14 @@
       return FT_Err_Invalid_Handle;
 
     sfnt_size = (FT_ULong)GetHandleSize( sfnt );
-    if ( ALLOC( sfnt_data, (FT_Long)sfnt_size ) )
+    if ( FT_ALLOC( sfnt_data, (FT_Long)sfnt_size ) )
     {
       ReleaseResource( sfnt );
       return error;
     }
 
     HLock( sfnt );
-    memcpy( sfnt_data, *sfnt, sfnt_size );
+    ft_memcpy( sfnt_data, *sfnt, sfnt_size );
     HUnlock( sfnt );
     ReleaseResource( sfnt );
 
@@ -613,7 +624,7 @@
   FT_New_Face_From_Suitcase( FT_Library  library,
                              FSSpec*     spec,
                              FT_Long     face_index,
-                             FT_Face*    aface )
+                             FT_Face    *aface )
   {
     FT_Error  error = FT_Err_Ok;
     short     res_ref, res_index;
@@ -649,6 +660,8 @@
   }
 
 
+#if TARGET_API_MAC_CARBON
+
   /* Create a new FT_Face from a file spec to a suitcase file. */
   static FT_Error
   FT_New_Face_From_dfont( FT_Library  library,
@@ -695,8 +708,10 @@
     return error;
   }
 
+#endif
+
 
-  /* documentation in ftmac.h */
+  /* documentation is in ftmac.h */
 
   FT_EXPORT_DEF( FT_Error )
   FT_New_Face_From_FOND( FT_Library  library,
@@ -704,13 +719,12 @@
                          FT_Long     face_index,
                          FT_Face    *aface )
   {
-    short     sfnt_id, have_sfnt, have_lwfn = 0;
-    Str255    lwfn_file_name;
-    short     fond_id;
-    OSType    fond_type;
-    Str255    fond_name;
-    FSSpec    lwfn_spec;
-    FT_Error  error = FT_Err_Unknown_File_Format;
+    short   sfnt_id, have_sfnt, have_lwfn = 0;
+    Str255  lwfn_file_name;
+    short   fond_id;
+    OSType  fond_type;
+    Str255  fond_name;
+    FSSpec  lwfn_spec;
 
 
     GetResInfo( fond, &fond_id, &fond_type, fond_name );
@@ -744,7 +758,7 @@
   }
 
 
-  /* documentation in ftmac.h */
+  /* documentation is in ftmac.h */
 
   FT_EXPORT_DEF( FT_Error )
   FT_GetFile_From_Mac_Name( char*     fontName,
@@ -793,18 +807,18 @@
                                                &style, &size );
           if ( stat2 == 0 && size == 0 )
           {
-            char fullName[256];
+            char  fullName[256];
 
 
             /* build up a complete face name */
-            strcpy( fullName, famName );
+            ft_strcpy( fullName, famName );
             if ( style & bold )
               strcat( fullName, " Bold" );
             if ( style & italic )
               strcat( fullName, " Italic" );
 
             /* compare with the name we are looking for */
-            if ( strcmp( fullName, fontName ) == 0 )
+            if ( ft_strcmp( fullName, fontName ) == 0 )
             {
               /* found it! */
               the_font = font;
@@ -830,6 +844,25 @@
   }
 
 
+  static long
+  ResourceForkSize(FSSpec*  spec)
+  {
+    long   len;
+    short  refNum;
+    OSErr  e;
+
+
+    e = FSpOpenRF( spec, fsRdPerm, &refNum ); /* I.M. Files 2-155 */
+    if ( e == noErr )
+    {
+      e = GetEOF( refNum, &len );
+      FSClose( refNum );
+    }
+
+    return ( e == noErr ) ? len : 0;
+  }
+
+
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
@@ -859,20 +892,31 @@
     if ( file_spec_from_path( pathname, &spec ) )
       return FT_Err_Invalid_Argument;
 
-    file_type = get_file_type( &spec );
-    if ( file_type == 'FFIL' || file_type == 'tfil' )
-      return FT_New_Face_From_Suitcase( library, &spec, face_index, aface );
-    else if ( file_type == 'LWFN' )
-      return FT_New_Face_From_LWFN( library, &spec, face_index, aface );
-    else if ( is_dfont( &spec ) )
-      return FT_New_Face_From_dfont( library, &spec, face_index, aface );
-    else  /* let it fall through to normal loader (.ttf, .otf, etc.) */
+    /* Regardless of type, don't try to use the resource fork if it is */
+    /* empty.  Some TTF fonts have type `FFIL', for example, but they  */
+    /* only have data forks.                                           */
+
+    if ( ResourceForkSize( &spec ) != 0 )
     {
-      args.flags    = ft_open_pathname;
-      args.pathname = (char*)pathname;
+      file_type = get_file_type( &spec );
+      if ( file_type == 'FFIL' || file_type == 'tfil' )
+        return FT_New_Face_From_Suitcase( library, &spec, face_index, aface );
 
-      return FT_Open_Face( library, &args, face_index, aface );
+      if ( file_type == 'LWFN' )
+        return FT_New_Face_From_LWFN( library, &spec, face_index, aface );
     }
+
+#if TARGET_API_MAC_CARBON
+
+    if ( is_dfont( &spec ) )
+      return FT_New_Face_From_dfont( library, &spec, face_index, aface );
+
+#endif
+
+    /* let it fall through to normal loader (.ttf, .otf, etc.) */
+    args.flags    = ft_open_pathname;
+    args.pathname = (char*)pathname;
+    return FT_Open_Face( library, &args, face_index, aface );
   }
 
 
Index: xc/extras/freetype2/src/base/ftnames.c
diff -u xc/extras/freetype2/src/base/ftnames.c:1.1.1.3 xc/extras/freetype2/src/base/ftnames.c:1.1.1.4
--- xc/extras/freetype2/src/base/ftnames.c:1.1.1.3	Sun Dec 16 12:49:26 2001
+++ xc/extras/freetype2/src/base/ftnames.c	Thu Jun 20 04:16:13 2002
@@ -7,7 +7,7 @@
 /*                                                                         */
 /*    This is _not_ used to retrieve glyph names!                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -22,6 +22,7 @@
 #include <ft2build.h>
 #include FT_SFNT_NAMES_H
 #include FT_INTERNAL_TRUETYPE_TYPES_H
+#include FT_INTERNAL_STREAM_H
 
 
 #ifdef TT_CONFIG_OPTION_SFNT_NAMES
@@ -40,7 +41,7 @@
 
   FT_EXPORT_DEF( FT_Error )
   FT_Get_Sfnt_Name( FT_Face       face,
-                    FT_UInt       index,
+                    FT_UInt       idx,
                     FT_SfntName  *aname )
   {
     FT_Error  error = FT_Err_Invalid_Argument;
@@ -51,17 +52,33 @@
       TT_Face  ttface = (TT_Face)face;
 
 
-      if ( index < (FT_UInt)ttface->num_names )
+      if ( idx < (FT_UInt)ttface->num_names )
       {
-        TT_NameRec*  name = ttface->name_table.names + index;
+        TT_NameEntryRec*  entry = ttface->name_table.names + idx;
 
 
-        aname->platform_id = name->platformID;
-        aname->encoding_id = name->encodingID;
-        aname->language_id = name->languageID;
-        aname->name_id     = name->nameID;
-        aname->string      = (FT_Byte*)name->string;
-        aname->string_len  = name->stringLength;
+        /* load name on demand */
+        if ( entry->stringLength > 0 && entry->string == NULL )
+        {
+          FT_Memory  memory = face->memory;
+          FT_Stream  stream = face->stream;
+
+
+          if ( FT_NEW_ARRAY  ( entry->string, entry->stringLength ) ||
+               FT_STREAM_SEEK( entry->stringOffset )                ||
+               FT_STREAM_READ( entry->string, entry->stringLength ) )
+          {
+            FT_FREE( entry->string );
+            entry->stringLength = 0;
+          }
+        }
+
+        aname->platform_id = entry->platformID;
+        aname->encoding_id = entry->encodingID;
+        aname->language_id = entry->languageID;
+        aname->name_id     = entry->nameID;
+        aname->string      = (FT_Byte*)entry->string;
+        aname->string_len  = entry->stringLength;
 
         error = FT_Err_Ok;
       }
Index: xc/extras/freetype2/src/base/ftobject.c
diff -u /dev/null xc/extras/freetype2/src/base/ftobject.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/base/ftobject.c	Thu Jun 20 04:16:13 2002
@@ -0,0 +1,302 @@
+#include "ftobject.c"
+
+#define  FT_MAGIC_DEATH   0xDEADdead
+#define  FT_MAGIC_CLASS   0x12345678
+
+#define  FT_OBJECT_CHECK(o)                                  \
+           ( FT_OBJECT(o)              != NULL            && \
+             FT_OBJECT(o)->clazz       != NULL            && \
+             FT_OBJECT(o)->ref_count   >= 1               && \
+             FT_OBJECT(o)->clazz->magic == FT_MAGIC_CLASS )
+
+
+ /*******************************************************************/
+ /*******************************************************************/
+ /*****                                                         *****/
+ /*****                                                         *****/
+ /*****                  M E T A - C L A S S                    *****/
+ /*****                                                         *****/
+ /*****                                                         *****/
+ /*******************************************************************/
+ /*******************************************************************/
+
+ /* we use a dynamic hash table to map types to classes */
+ /* this structure defines the layout of each node of   */
+ /* this table                                          */
+  typedef struct FT_ClassHNodeRec_
+  {
+    FT_HashNodeRec  hnode;
+    FT_Type         ctype;
+    FT_Class        clazz;
+
+  } FT_ClassHNodeRec, *FT_ClassHNode;
+
+
+ /* the meta class contains a type -> class mapping */
+ /* and owns all class objects..                    */
+ /*                                                 */
+  typedef struct FT_MetaClassRec_
+  {
+    FT_ClassRec  clazz;
+    FT_HashRec   type_to_class;
+
+  } FT_MetaClassRec, *FT_MetaClass;
+
+ /* forward declaration */
+  static const FT_TypeRec  ft_meta_class_type;
+
+
+ /* destroy a given class */
+  static void
+  ft_class_hnode_destroy( FT_ClassHNode  node )
+  {
+    FT_Clazz   clazz  = node->clazz;
+    FT_Memory  memory = clazz->memory;
+    FT_Type    ctype  = clazz->type;
+
+    if ( ctype->class_done )
+      ctype->class_done( clazz );
+
+    FT_FREE( clazz );
+
+    node->clazz = NULL;
+    node->type  = NULL;
+
+    FT_FREE( node );
+  }
+
+
+  static FT_Int
+  ft_class_hnode_compare( const FT_ClassHNode  node1,
+                          const FT_ClassHNode  node2 )
+  {
+    return ( node1->type == node2->type );
+  }
+
+
+  static void
+  ft_metaclass_done( FT_MetaClass  meta )
+  {
+    /* clear all objects */
+    ft_hash_done( &meta->type_to_class,
+                  (FT_Hash_ForeachFunc) ft_class_destroy,
+                   NULL );
+
+    meta->clazz->object.clazz    = NULL;
+    meta->clazz->object.ref_count = 0;
+    meta->clazz->magic            = FT_MAGIC_DEATH;
+  }
+
+
+  static void
+  ft_metaclass_init( FT_MetaClass  meta,
+                     FT_Library    library )
+  {
+    FT_ClassRec*  clazz = meta->clazz;
+
+    /* the meta-class is its OWN class !! */
+    clazz->object.clazz     = (FT_Class) clazz;
+    clazz->object.ref_count = 1;
+    clazz->magic            = FT_MAGIC_CLASS;
+    clazz->library          = library;
+    clazz->memory           = library->memory;
+    clazz->type             = &ft_metaclass_type;
+    clazz->info             = NULL;
+
+    clazz->obj_size         = sizeof( FT_ClassRec );
+    clazz->obj_init         = NULL;
+    clazz->obj_done         = NULL;
+
+    ft_hash_init( &meta->type_to_class,
+                  (FT_Hash_CompareFunc) ft_class_hnode_compare,
+                  library->memory );
+  }
+
+
+ /* find or create the class corresponding to a given type */
+  static FT_Class
+  ft_metaclass_get_class( FT_MetaClass  meta,
+                          FT_Type       ctype )
+  {
+    FT_ClassHNodeRec   keynode, *node, **pnode;
+    FT_Memory          memory;
+
+    keynode.hnode.hash = (FT_UInt32)( ctype >> 2 );
+    keynode.type       = type;
+
+    pnode = (FT_ClassHNode) ft_hash_lookup( &meta->type_to_class,
+                                            &noderec );
+    node  = *pnode;
+    if ( node != NULL )
+      return node->clazz;
+
+    memory = FT_CLASS__MEMORY(meta);
+    node   = FT_MEM_SAFE_ALLOC( sizeof(*node) );
+    if ( node != NULL )
+    {
+      FT_ClassRec*  clazz;
+
+      clazz = FT_MEM_SAFE_ALLOC( ctype->class_size );
+      if ( clazz == NULL )
+      {
+        FT_FREE( node );
+        FT_XTHROW( FT_Err_Out_Of_Memory );
+      }
+    }
+  }
+
+
+  static const FT_TypeRec  ft_meta_class_type =
+  {
+    "FT2.MetaClass",
+    NULL,
+
+    sizeof( FT_MetaClassRec ),
+    (FT_Object_InitFunc)  ft_metaclass_init,
+    (FT_Object_DoneFunc)  ft_metaclass_done,
+
+    sizeof( FT_ClassRec ),
+    (FT_Object_InitFunc)  ft_class_init,
+    (FT_Object_DoneFunc)  ft_class_done
+  };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  FT_BASE_DEF( FT_Int )
+  ft_object_check( FT_Pointer  obj )
+  {
+    return FT_OBJECT_CHECK(obj);
+  }
+
+
+  FT_BASE_DEF( FT_Int )
+  ft_object_is_a( FT_Pointer  obj,
+                  FT_Class    clazz )
+  {
+    if ( FT_OBJECT_CHECK(obj) )
+    {
+      FT_Object  o = FT_OBJECT(obj);
+      FT_Class   c = FT_OBJECT__CLASS(obj);
+
+      do
+      {
+        if ( c == clazz )
+          return 1;
+
+        c = c->super;
+      }
+      while ( c == NULL );
+
+      return (clazz == NULL);
+    }
+  }
+
+
+ /* the cleanup routine for all objects */
+  static void
+  ft_object_cleanup( FT_Object  object )
+  {
+    FT_Memory  memory = FT_OBJECT__MEMORY(object);
+    FT_Class   clazz  = FT_OBJECT__CLASS(object);
+
+    if ( clazz->obj_done )
+      clazz->obj_done( object );
+
+    FT_FREE( object );
+  }
+
+
+  FT_BASE_DEF( FT_Object )
+  ft_object_new( FT_Class    clazz,
+                 FT_Pointer  init_data )
+  {
+    FT_Memory  memory;
+    FT_Object  obj;
+
+
+    FT_ASSERT_IS_CLASS(clazz);
+
+    memory         = FT_CLASS__MEMORY(clazz);
+    obj            = ft_mem_alloc( clazz->obj_size, memory );
+    obj->clazz     = clazz;
+    obj->ref_count = 1;
+
+    if ( clazz->obj_init )
+    {
+      FT_CleanupStack  stack = FT_MEMORY__CLEANUP(memory);
+
+
+      ft_cleanup_push( stack, obj, (FT_CleanupFunc) ft_object_cleanup, NULL );
+
+      clazz->obj_init( obj, init_data );
+
+      ft_cleanup_pop( stack, obj, 0 );
+    }
+    return obj;
+  }
+
+
+
+  FT_BASE_DEF( void )
+  ft_object_create( FT_Object  *pobject,
+                    FT_Class    clazz,
+                    FT_Pointer  init_data )
+  {
+    FT_Memory  memory;
+    FT_Object  obj;
+
+    FT_ASSERT_IS_CLASS(clazz);
+
+    memory         = FT_CLASS__MEMORY(memory);
+    obj            = ft_mem_alloc( clazz->obj_size, memory );
+    obj->clazz     = clazz;
+    obj->ref_count = 1;
+    *pobject       = obj;
+
+    if ( clazz->obj_init )
+      clazz->obj_init( obj, init_data );
+  }
+
+
+  FT_BASE_DEF( FT_Class )
+  ft_class_find_by_type( FT_Type    type,
+                         FT_Memory  memory )
+  {
+  }
+
+
+  FT_BASE_DEF( FT_Class )
+  ft_class_find_by_name( FT_CString  class_name,
+                         FT_Memory   memory );
+
+  FT_BASE_DEF( FT_Object )
+  ft_object_new_from_type( FT_Type     type,
+                           FT_Pointer  data,
+                           FT_Memory   memory );
+
+  FT_BASE_DEF( void )
+  ft_object_create_from_type( FT_Object  *pobject,
+                              FT_Type     type,
+                              FT_Pointer  init_data,
+                              FT_Memory   memory );
+
+  FT_BASE_DEF( void )
+  ft_object_push( FT_Object  object );
+
+  FT_BASE_DEF( void )
+  ft_object_pop( FT_Object  object );
+
+  FT_BASE_DEF( void )
+  ft_object_pop_destroy( FT_Object  object );
+
Index: xc/extras/freetype2/src/base/ftobjs.c
diff -u xc/extras/freetype2/src/base/ftobjs.c:1.1.1.5 xc/extras/freetype2/src/base/ftobjs.c:1.1.1.8
--- xc/extras/freetype2/src/base/ftobjs.c:1.1.1.5	Mon Jan 14 11:52:10 2002
+++ xc/extras/freetype2/src/base/ftobjs.c	Thu Jun 20 04:16:14 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    The FreeType private base classes (body).                            */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -25,121 +25,37 @@
 #include FT_TRUETYPE_TABLES_H
 #include FT_OUTLINE_H
 
-#include <string.h>     /* for strcmp() */
 
-
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-  /****                                                                 ****/
-  /****                                                                 ****/
-  /****                           M E M O R Y                           ****/
-  /****                                                                 ****/
-  /****                                                                 ****/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
-  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
-  /* messages during execution.                                            */
-  /*                                                                       */
-#undef  FT_COMPONENT
-#define FT_COMPONENT  trace_memory
-
-
-  /* documentation is in ftmemory.h */
-
-  FT_BASE_DEF( FT_Error )
-  FT_Alloc( FT_Memory  memory,
-            FT_Long    size,
-            void*     *P )
+  FT_BASE_DEF( void )
+  ft_validator_init( FT_Validator        valid,
+                     const FT_Byte*      base,
+                     const FT_Byte*      limit,
+                     FT_ValidationLevel  level )
   {
-    FT_Assert( P != 0 );
-
-    if ( size > 0 )
-    {
-      *P = memory->alloc( memory, size );
-      if ( !*P )
-      {
-        FT_ERROR(( "FT_Alloc:" ));
-        FT_ERROR(( " Out of memory? (%ld requested)\n",
-                   size ));
-
-        return FT_Err_Out_Of_Memory;
-      }
-      MEM_Set( *P, 0, size );
-    }
-    else
-      *P = NULL;
-
-    FT_TRACE7(( "FT_Alloc:" ));
-    FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
-                size, *P, P ));
-
-    return FT_Err_Ok;
+    valid->base  = base;
+    valid->limit = limit;
+    valid->level = level;
+    valid->error = 0;
   }
 
-
-  /* documentation is in ftmemory.h */
 
-  FT_BASE_DEF( FT_Error )
-  FT_Realloc( FT_Memory  memory,
-              FT_Long    current,
-              FT_Long    size,
-              void**     P )
+  FT_BASE_DEF( FT_Int )
+  ft_validator_run( FT_Validator  valid )
   {
-    void*  Q;
-
-
-    FT_Assert( P != 0 );
-
-    /* if the original pointer is NULL, call FT_Alloc() */
-    if ( !*P )
-      return FT_Alloc( memory, size, P );
+    int  result;
 
-    /* if the new block if zero-sized, clear the current one */
-    if ( size <= 0 )
-    {
-      FT_Free( memory, P );
-      return FT_Err_Ok;
-    }
-
-    Q = memory->realloc( memory, current, size, *P );
-    if ( !Q )
-      goto Fail;
-
-    if ( size > current )
-      memset( (char*)Q + current, 0, size - current );
-
-    *P = Q;
-    return FT_Err_Ok;
 
-  Fail:
-    FT_ERROR(( "FT_Realloc:" ));
-    FT_ERROR(( " Failed (current %ld, requested %ld)\n",
-               current, size ));
-    return FT_Err_Out_Of_Memory;
+    result = ft_setjmp( valid->jump_buffer );
+    return result;
   }
 
 
-  /* documentation is in ftmemory.h */
-
   FT_BASE_DEF( void )
-  FT_Free( FT_Memory  memory,
-           void**     P )
+  ft_validator_error( FT_Validator  valid,
+                      FT_Error      error )
   {
-    FT_TRACE7(( "FT_Free:" ));
-    FT_TRACE7(( " Freeing block 0x%08p, ref 0x%08p\n",
-                P, P ? *P : (void*)0 ));
-
-    if ( P && *P )
-    {
-      memory->free( memory, *P );
-      *P = 0;
-    }
+    valid->error = error;
+    ft_longjmp( valid->jump_buffer, 1 );
   }
 
 
@@ -156,19 +72,10 @@
   /*************************************************************************/
 
 
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    ft_new_input_stream                                                */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Creates a new input stream object from an FT_Open_Args structure.  */
-  /*                                                                       */
-  /* <Note>                                                                */
-  /*    The function expects a valid `astream' parameter.                  */
-  /*                                                                       */
+  /* create a new input stream from a FT_Open_Args structure */
+  /*                                                         */
   static FT_Error
-  ft_new_input_stream( FT_Library     library,
+  ft_input_stream_new( FT_Library     library,
                        FT_Open_Args*  args,
                        FT_Stream*     astream )
   {
@@ -185,37 +92,41 @@
 
     *astream = 0;
     memory   = library->memory;
-    if ( ALLOC( stream, sizeof ( *stream ) ) )
+
+    if ( FT_NEW( stream ) )
       goto Exit;
 
     stream->memory = memory;
 
-    /* now, look at the stream flags */
     if ( args->flags & ft_open_memory )
     {
-      error = 0;
-      FT_New_Memory_Stream( library,
-                            (FT_Byte*)args->memory_base,
-                            args->memory_size,
-                            stream );
+      /* create a memory-based stream */
+      FT_Stream_OpenMemory( stream,
+                            (const FT_Byte*)args->memory_base,
+                            args->memory_size );
     }
     else if ( args->flags & ft_open_pathname )
     {
-      error = FT_New_Stream( args->pathname, stream );
+      /* create a normal system stream */
+      error = FT_Stream_Open( stream, args->pathname );
       stream->pathname.pointer = args->pathname;
     }
     else if ( ( args->flags & ft_open_stream ) && args->stream )
     {
+      /* use an existing, user-provided stream */
+
       /* in this case, we do not need to allocate a new stream object */
       /* since the caller is responsible for closing it himself       */
-      FREE( stream );
+      FT_FREE( stream );
       stream = args->stream;
     }
     else
       error = FT_Err_Invalid_Argument;
 
     if ( error )
-      FREE( stream );
+      FT_FREE( stream );
+    else
+      stream->memory = memory;  /* just to be certain */
 
     *astream = stream;
 
@@ -224,37 +135,20 @@
   }
 
 
-  /* documentation is in ftobjs.h */
-
-  FT_EXPORT_DEF( void )
-  FT_Done_Stream( FT_Stream  stream )
-  {
-    if ( stream && stream->close )
-    {
-      stream->close( stream );
-      stream->close = 0;
-    }
-  }
-
-
   static void
-  ft_done_stream( FT_Stream*  astream,
-                  FT_Int      external )
+  ft_input_stream_free( FT_Stream  stream,
+                        FT_Int     external )
   {
-    FT_Stream  stream = *astream;
-
-
-    if ( stream->close )
-      stream->close( stream );
-
-    if ( !external )
+    if ( stream )
     {
       FT_Memory  memory = stream->memory;
 
 
-      FREE( stream );
+      FT_Stream_Close( stream );
+
+      if ( !external )
+        FT_FREE( stream );
     }
-    *astream = 0;
   }
 
 
@@ -267,343 +161,6 @@
   /*************************************************************************/
   /****                                                                 ****/
   /****                                                                 ****/
-  /****                     G L Y P H   L O A D E R                     ****/
-  /****                                                                 ****/
-  /****                                                                 ****/
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* The glyph loader is a simple object which is used to load a set of    */
-  /* glyphs easily.  It is critical for the correct loading of composites. */
-  /*                                                                       */
-  /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
-  /*                                                                       */
-  /*   loader.base     Is really the bottom of the stack.  It describes a  */
-  /*                   single glyph image made of the juxtaposition of     */
-  /*                   several glyphs (those `in the stack').              */
-  /*                                                                       */
-  /*   loader.current  Describes the top of the stack, on which a new      */
-  /*                   glyph can be loaded.                                */
-  /*                                                                       */
-  /*   Rewind          Clears the stack.                                   */
-  /*   Prepare         Set up `loader.current' for addition of a new glyph */
-  /*                   image.                                              */
-  /*   Add             Add the `current' glyph image to the `base' one,    */
-  /*                   and prepare for another one.                        */
-  /*                                                                       */
-  /* The glyph loader is now a base object.  Each driver used to           */
-  /* re-implement it in one way or the other, which wasted code and        */
-  /* energy.                                                               */
-  /*                                                                       */
-  /*************************************************************************/
-
-
-  /* create a new glyph loader */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_New( FT_Memory         memory,
-                      FT_GlyphLoader*  *aloader )
-  {
-    FT_GlyphLoader*  loader;
-    FT_Error         error;
-
-
-    if ( !ALLOC( loader, sizeof ( *loader ) ) )
-    {
-      loader->memory = memory;
-      *aloader       = loader;
-    }
-    return error;
-  }
-
-
-  /* rewind the glyph loader - reset counters to 0 */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Rewind( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    base->outline.n_points   = 0;
-    base->outline.n_contours = 0;
-    base->num_subglyphs      = 0;
-
-    *current = *base;
-  }
-
-
-  /* reset the glyph loader, frees all allocated tables */
-  /* and starts from zero                               */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Reset( FT_GlyphLoader*  loader )
-  {
-    FT_Memory memory = loader->memory;
-
-
-    FREE( loader->base.outline.points );
-    FREE( loader->base.outline.tags );
-    FREE( loader->base.outline.contours );
-    FREE( loader->base.extra_points );
-    FREE( loader->base.subglyphs );
-
-    loader->max_points    = 0;
-    loader->max_contours  = 0;
-    loader->max_subglyphs = 0;
-
-    FT_GlyphLoader_Rewind( loader );
-  }
-
-
-  /* delete a glyph loader */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Done( FT_GlyphLoader*  loader )
-  {
-    if ( loader )
-    {
-      FT_Memory memory = loader->memory;
-
-
-      FT_GlyphLoader_Reset( loader );
-      FREE( loader );
-    }
-  }
-
-
-  /* re-adjust the `current' outline fields */
-  static void
-  FT_GlyphLoader_Adjust_Points( FT_GlyphLoader*  loader )
-  {
-    FT_Outline*  base    = &loader->base.outline;
-    FT_Outline*  current = &loader->current.outline;
-
-
-    current->points   = base->points   + base->n_points;
-    current->tags     = base->tags     + base->n_points;
-    current->contours = base->contours + base->n_contours;
-
-    /* handle extra points table - if any */
-    if ( loader->use_extra )
-      loader->current.extra_points =
-        loader->base.extra_points + base->n_points;
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Create_Extra( FT_GlyphLoader*  loader )
-  {
-    FT_Error   error;
-    FT_Memory  memory = loader->memory;
-
-
-    if ( !ALLOC_ARRAY( loader->base.extra_points,
-                       loader->max_points, FT_Vector ) )
-    {
-      loader->use_extra = 1;
-      FT_GlyphLoader_Adjust_Points( loader );
-    }
-    return error;
-  }
-
-
-  /* re-adjust the `current' subglyphs field */
-  static void
-  FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad* base    = &loader->base;
-    FT_GlyphLoad* current = &loader->current;
-
-
-    current->subglyphs = base->subglyphs + base->num_subglyphs;
-  }
-
-
-  /* Ensure that we can add `n_points' and `n_contours' to our glyph. this */
-  /* function reallocates its outline tables if necessary.  Note that it   */
-  /* DOESN'T change the number of points within the loader!                */
-  /*                                                                       */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Check_Points( FT_GlyphLoader*  loader,
-                               FT_UInt          n_points,
-                               FT_UInt          n_contours )
-  {
-    FT_Memory    memory  = loader->memory;
-    FT_Error     error   = FT_Err_Ok;
-    FT_Outline*  base    = &loader->base.outline;
-    FT_Outline*  current = &loader->current.outline;
-    FT_Bool      adjust  = 1;
-
-    FT_UInt      new_max, old_max;
-
-
-    /* check points & tags */
-    new_max = base->n_points + current->n_points + n_points;
-    old_max = loader->max_points;
-
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 7 ) & -8;
-
-      if ( REALLOC_ARRAY( base->points, old_max, new_max, FT_Vector ) ||
-           REALLOC_ARRAY( base->tags,   old_max, new_max, FT_Byte   ) )
-       goto Exit;
-
-      if ( loader->use_extra &&
-           REALLOC_ARRAY( loader->base.extra_points, old_max,
-                          new_max, FT_Vector ) )
-       goto Exit;
-
-      adjust = 1;
-      loader->max_points = new_max;
-    }
-
-    /* check contours */
-    old_max = loader->max_contours;
-    new_max = base->n_contours + current->n_contours +
-              n_contours;
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 3 ) & -4;
-      if ( REALLOC_ARRAY( base->contours, old_max, new_max, FT_Short ) )
-        goto Exit;
-
-      adjust = 1;
-      loader->max_contours = new_max;
-    }
-
-    if ( adjust )
-      FT_GlyphLoader_Adjust_Points( loader );
-
-  Exit:
-    return error;
-  }
-
-
-  /* Ensure that we can add `n_subglyphs' to our glyph. this function */
-  /* reallocates its subglyphs table if necessary.  Note that it DOES */
-  /* NOT change the number of subglyphs within the loader!            */
-  /*                                                                  */
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Check_Subglyphs( FT_GlyphLoader*  loader,
-                                  FT_UInt          n_subs )
-  {
-    FT_Memory  memory = loader->memory;
-    FT_Error   error  = FT_Err_Ok;
-    FT_UInt    new_max, old_max;
-
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
-    old_max = loader->max_subglyphs;
-    if ( new_max > old_max )
-    {
-      new_max = ( new_max + 1 ) & -2;
-      if ( REALLOC_ARRAY( base->subglyphs, old_max, new_max, FT_SubGlyph ) )
-        goto Exit;
-
-      loader->max_subglyphs = new_max;
-
-      FT_GlyphLoader_Adjust_Subglyphs( loader );
-    }
-
-  Exit:
-    return error;
-  }
-
-
-  /* prepare loader for the addition of a new glyph on top of the base one */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Prepare( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad*  current = &loader->current;
-
-
-    current->outline.n_points   = 0;
-    current->outline.n_contours = 0;
-    current->num_subglyphs      = 0;
-
-    FT_GlyphLoader_Adjust_Points   ( loader );
-    FT_GlyphLoader_Adjust_Subglyphs( loader );
-  }
-
-
-  /* add current glyph to the base image - and prepare for another */
-  FT_BASE_DEF( void )
-  FT_GlyphLoader_Add( FT_GlyphLoader*  loader )
-  {
-    FT_GlyphLoad*  base    = &loader->base;
-    FT_GlyphLoad*  current = &loader->current;
-
-    FT_UInt        n_curr_contours = current->outline.n_contours;
-    FT_UInt        n_base_points   = base->outline.n_points;
-    FT_UInt        n;
-
-
-    base->outline.n_points =
-      (short)( base->outline.n_points + current->outline.n_points );
-    base->outline.n_contours =
-      (short)( base->outline.n_contours + current->outline.n_contours );
-
-    base->num_subglyphs += current->num_subglyphs;
-
-    /* adjust contours count in newest outline */
-    for ( n = 0; n < n_curr_contours; n++ )
-      current->outline.contours[n] =
-        (short)( current->outline.contours[n] + n_base_points );
-
-    /* prepare for another new glyph image */
-    FT_GlyphLoader_Prepare( loader );
-  }
-
-
-  FT_BASE_DEF( FT_Error )
-  FT_GlyphLoader_Copy_Points( FT_GlyphLoader*  target,
-                              FT_GlyphLoader*  source )
-  {
-    FT_Error  error;
-    FT_UInt   num_points   = source->base.outline.n_points;
-    FT_UInt   num_contours = source->base.outline.n_contours;
-
-
-    error = FT_GlyphLoader_Check_Points( target, num_points, num_contours );
-    if ( !error )
-    {
-      FT_Outline*  out = &target->base.outline;
-      FT_Outline*  in  = &source->base.outline;
-
-
-      MEM_Copy( out->points, in->points,
-                num_points * sizeof ( FT_Vector ) );
-      MEM_Copy( out->tags, in->tags,
-                num_points * sizeof ( char ) );
-      MEM_Copy( out->contours, in->contours,
-                num_contours * sizeof ( short ) );
-
-      /* do we need to copy the extra points? */
-      if ( target->use_extra && source->use_extra )
-        MEM_Copy( target->base.extra_points, source->base.extra_points,
-                  num_points * sizeof ( FT_Vector ) );
-
-      out->n_points   = (short)num_points;
-      out->n_contours = (short)num_contours;
-
-      FT_GlyphLoader_Adjust_Points( target );
-    }
-
-    return error;
-  }
-
-
-  /*************************************************************************/
-  /*************************************************************************/
-  /*************************************************************************/
-  /****                                                                 ****/
-  /****                                                                 ****/
   /****               FACE, SIZE & GLYPH SLOT OBJECTS                   ****/
   /****                                                                 ****/
   /****                                                                 ****/
@@ -616,7 +173,7 @@
   ft_glyphslot_init( FT_GlyphSlot  slot )
   {
     FT_Driver         driver = slot->face->driver;
-    FT_Driver_Class*  clazz  = driver->clazz;
+    FT_Driver_Class   clazz  = driver->clazz;
     FT_Memory         memory = driver->root.memory;
     FT_Error          error  = FT_Err_Ok;
     FT_Slot_Internal  internal;
@@ -624,7 +181,7 @@
 
     slot->library = driver->root.library;
 
-    if ( ALLOC( internal, sizeof ( *internal ) ) )
+    if ( FT_NEW( internal ) )
       goto Exit;
 
     slot->internal = internal;
@@ -644,19 +201,19 @@
   ft_glyphslot_clear( FT_GlyphSlot  slot )
   {
     /* free bitmap if needed */
-    if ( slot->flags & ft_glyph_own_bitmap )
+    if ( slot->flags & FT_GLYPH_OWN_BITMAP )
     {
       FT_Memory  memory = FT_FACE_MEMORY( slot->face );
 
 
-      FREE( slot->bitmap.buffer );
-      slot->flags &= ~ft_glyph_own_bitmap;
+      FT_FREE( slot->bitmap.buffer );
+      slot->flags &= ~FT_GLYPH_OWN_BITMAP;
     }
 
     /* clear all public fields in the glyph slot */
-    MEM_Set( &slot->metrics, 0, sizeof ( slot->metrics ) );
-    MEM_Set( &slot->outline, 0, sizeof ( slot->outline ) );
-    MEM_Set( &slot->bitmap,  0, sizeof ( slot->bitmap )  );
+    FT_MEM_SET( &slot->metrics, 0, sizeof ( slot->metrics ) );
+    FT_MEM_SET( &slot->outline, 0, sizeof ( slot->outline ) );
+    FT_MEM_SET( &slot->bitmap,  0, sizeof ( slot->bitmap )  );
 
     slot->bitmap_left   = 0;
     slot->bitmap_top    = 0;
@@ -676,7 +233,7 @@
   ft_glyphslot_done( FT_GlyphSlot  slot )
   {
     FT_Driver         driver = slot->face->driver;
-    FT_Driver_Class*  clazz  = driver->clazz;
+    FT_Driver_Class   clazz  = driver->clazz;
     FT_Memory         memory = driver->root.memory;
 
 
@@ -684,8 +241,8 @@
       clazz->done_slot( slot );
 
     /* free bitmap buffer if needed */
-    if ( slot->flags & ft_glyph_own_bitmap )
-      FREE( slot->bitmap.buffer );
+    if ( slot->flags & FT_GLYPH_OWN_BITMAP )
+      FT_FREE( slot->bitmap.buffer );
 
     /* free glyph loader */
     if ( FT_DRIVER_USES_OUTLINES( driver ) )
@@ -694,7 +251,7 @@
       slot->internal->loader = 0;
     }
 
-    FREE( slot->internal );
+    FT_FREE( slot->internal );
   }
 
 
@@ -706,7 +263,7 @@
   {
     FT_Error          error;
     FT_Driver         driver;
-    FT_Driver_Class*  clazz;
+    FT_Driver_Class   clazz;
     FT_Memory         memory;
     FT_GlyphSlot      slot;
 
@@ -721,7 +278,7 @@
     memory = driver->root.memory;
 
     FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" ));
-    if ( !ALLOC( slot, clazz->slot_object_size ) )
+    if ( !FT_ALLOC( slot, clazz->slot_object_size ) )
     {
       slot->face = face;
 
@@ -729,7 +286,7 @@
       if ( error )
       {
         ft_glyphslot_done( slot );
-        FREE( slot );
+        FT_FREE( slot );
         goto Exit;
       }
 
@@ -749,10 +306,10 @@
   {
     if ( slot )
     {
-      FT_Driver         driver = slot->face->driver;
-      FT_Memory         memory = driver->root.memory;
-      FT_GlyphSlot*     parent;
-      FT_GlyphSlot      cur;
+      FT_Driver      driver = slot->face->driver;
+      FT_Memory      memory = driver->root.memory;
+      FT_GlyphSlot*  parent;
+      FT_GlyphSlot   cur;
 
 
       /* Remove slot from its parent face's list */
@@ -765,7 +322,7 @@
         {
           *parent = cur->next;
           ft_glyphslot_done( slot );
-          FREE( slot );
+          FT_FREE( slot );
           break;
         }
         cur = cur->next;
@@ -882,7 +439,7 @@
 
     if ( autohint )
     {
-      FT_AutoHinter_Interface*  hinting;
+      FT_AutoHinter_Service  hinting;
 
 
       /* try to load embedded bitmaps first if available            */
@@ -901,7 +458,7 @@
       }
 
       /* load auto-hinted outline */
-      hinting = (FT_AutoHinter_Interface*)hinter->clazz->module_interface;
+      hinting = (FT_AutoHinter_Service)hinter->clazz->module_interface;
 
       error   = hinting->load_glyph( (FT_AutoHinter)hinter,
                                      slot, face->size,
@@ -941,6 +498,7 @@
       FT_UInt           EM      = face->units_per_EM;
       FT_Size_Metrics*  metrics = &face->size->metrics;
 
+
       slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance,
                                            (FT_Long)metrics->x_ppem << 16, EM );
 
@@ -1022,8 +580,8 @@
     if ( driver->clazz->done_size )
       driver->clazz->done_size( size );
 
-    FREE( size->internal );
-    FREE( size );
+    FT_FREE( size->internal );
+    FT_FREE( size );
   }
 
 
@@ -1033,45 +591,71 @@
                 FT_Face    face,
                 FT_Driver  driver )
   {
-    FT_Driver_Class*  clazz = driver->clazz;
+    FT_Driver_Class  clazz = driver->clazz;
 
 
     /* discard auto-hinting data */
     if ( face->autohint.finalizer )
       face->autohint.finalizer( face->autohint.data );
 
-    /* Discard glyph slots for this face                            */
+    /* Discard glyph slots for this face.                           */
     /* Beware!  FT_Done_GlyphSlot() changes the field `face->glyph' */
     while ( face->glyph )
       FT_Done_GlyphSlot( face->glyph );
 
-    /* Discard all sizes for this face */
+    /* discard all sizes for this face */
     FT_List_Finalize( &face->sizes_list,
                      (FT_List_Destructor)destroy_size,
                      memory,
                      driver );
     face->size = 0;
 
-    /* Now discard client data */
+    /* now discard client data */
     if ( face->generic.finalizer )
       face->generic.finalizer( face );
 
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+    /* discard charmaps */
+    {
+      FT_Int  n;
+
+
+      for ( n = 0; n < face->num_charmaps; n++ )
+      {
+        FT_CMap  cmap = FT_CMAP( face->charmaps[n] );
+
+
+        FT_CMap_Done( cmap );
+
+        face->charmaps[n] = NULL;
+      }
+
+      FT_FREE( face->charmaps );
+      face->num_charmaps = 0;
+    }
+
+#endif /* FT_CONFIG_OPTION_USE_CMAPS */
+
+
     /* finalize format-specific stuff */
     if ( clazz->done_face )
       clazz->done_face( face );
 
     /* close the stream for this face if needed */
-    ft_done_stream(
-      &face->stream,
+    ft_input_stream_free(
+      face->stream,
       ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
 
+    face->stream = 0;
+
     /* get rid of it */
     if ( face->internal )
     {
-      FREE( face->internal->postscript_name );
-      FREE( face->internal );
+      FT_FREE( face->internal->postscript_name );
+      FT_FREE( face->internal );
     }
-    FREE( face );
+    FT_FREE( face );
   }
 
 
@@ -1106,7 +690,7 @@
              FT_Face*       aface )
   {
     FT_Memory         memory;
-    FT_Driver_Class*  clazz;
+    FT_Driver_Class  clazz;
     FT_Face           face = 0;
     FT_Error          error;
     FT_Face_Internal  internal;
@@ -1116,10 +700,10 @@
     memory = driver->root.memory;
 
     /* allocate the face object and perform basic initialization */
-    if ( ALLOC( face, clazz->face_object_size ) )
+    if ( FT_ALLOC( face, clazz->face_object_size ) )
       goto Fail;
 
-    if ( ALLOC( internal, sizeof ( *internal ) ) )
+    if ( FT_NEW( internal ) )
       goto Fail;
 
     face->internal = internal;
@@ -1142,8 +726,8 @@
     if ( error )
     {
       clazz->done_face( face );
-      FREE( face->internal );
-      FREE( face );
+      FT_FREE( face->internal );
+      FT_FREE( face );
       *aface = 0;
     }
 
@@ -1152,9 +736,9 @@
 
 
   /* there's a Mac-specific extended implementation of FT_New_Face() */
-  /* in src/mac/ftmac.c                                              */
+  /* in src/base/ftmac.c                                             */
 
-#ifndef macintosh
+#ifndef FT_MACINTOSH
 
   /* documentation is in freetype.h */
 
@@ -1177,7 +761,7 @@
     return FT_Open_Face( library, &args, face_index, aface );
   }
 
-#endif  /* !macintosh */
+#endif  /* !FT_MACINTOSH */
 
 
   /* documentation is in freetype.h */
@@ -1222,7 +806,7 @@
 
 
     /* test for valid `library' delayed to */
-    /* ft_new_input_stream()               */
+    /* ft_input_stream_new()               */
 
     if ( !aface || !args )
       return FT_Err_Invalid_Argument;
@@ -1233,7 +817,7 @@
                                args->stream                     );
 
     /* create input stream */
-    error = ft_new_input_stream( library, args, &stream );
+    error = ft_input_stream_new( library, args, &stream );
     if ( error )
       goto Exit;
 
@@ -1266,7 +850,7 @@
       else
         error = FT_Err_Invalid_Handle;
 
-      ft_done_stream( &stream, external_stream );
+      ft_input_stream_free( stream, external_stream );
       goto Fail;
     }
     else
@@ -1307,7 +891,7 @@
       error = FT_Err_Unknown_File_Format;
 
   Fail2:
-      ft_done_stream( &stream, external_stream );
+      ft_input_stream_free( stream, external_stream );
       goto Fail;
     }
 
@@ -1319,7 +903,7 @@
       face->face_flags |= FT_FACE_FLAG_EXTERNAL_STREAM;
 
     /* add the face object to its driver's list */
-    if ( ALLOC( node, sizeof ( *node ) ) )
+    if ( FT_NEW( node ) )
       goto Fail;
 
     node->data = face;
@@ -1413,10 +997,10 @@
     FT_Error   error;
     FT_Driver  driver;
 
-    FT_Driver_Class*  clazz;
+    FT_Driver_Class  clazz;
 
 
-    /* test for valid `parameters' delayed to ft_new_input_stream() */
+    /* test for valid `parameters' delayed to ft_input_stream_new() */
 
     if ( !face )
       return FT_Err_Invalid_Face_Handle;
@@ -1425,7 +1009,7 @@
     if ( !driver )
       return FT_Err_Invalid_Driver_Handle;
 
-    error = ft_new_input_stream( driver->root.library, parameters, &stream );
+    error = ft_input_stream_new( driver->root.library, parameters, &stream );
     if ( error )
       goto Exit;
 
@@ -1438,7 +1022,7 @@
       error = clazz->attach_file( face, stream );
 
     /* close the attached stream */
-    ft_done_stream( &stream,
+    ft_input_stream_free( stream,
                     (FT_Bool)( parameters->stream &&
                                ( parameters->flags & ft_open_stream ) ) );
 
@@ -1470,7 +1054,7 @@
       {
         /* remove face object from the driver's list */
         FT_List_Remove( &driver->faces_list, node );
-        FREE( node );
+        FT_FREE( node );
 
         /* now destroy the object proper */
         destroy_face( memory, face, driver );
@@ -1487,13 +1071,13 @@
   FT_New_Size( FT_Face   face,
                FT_Size  *asize )
   {
-    FT_Error          error;
-    FT_Memory         memory;
-    FT_Driver         driver;
-    FT_Driver_Class*  clazz;
+    FT_Error         error;
+    FT_Memory        memory;
+    FT_Driver        driver;
+    FT_Driver_Class  clazz;
 
-    FT_Size           size = 0;
-    FT_ListNode       node = 0;
+    FT_Size          size = 0;
+    FT_ListNode      node = 0;
 
 
     if ( !face )
@@ -1512,8 +1096,7 @@
     memory = face->memory;
 
     /* Allocate new size object and perform basic initialisation */
-    if ( ALLOC( size, clazz->size_object_size ) ||
-         ALLOC( node, sizeof ( FT_ListNodeRec ) ) )
+    if ( FT_ALLOC( size, clazz->size_object_size ) || FT_NEW( node ) )
       goto Exit;
 
     size->face = face;
@@ -1535,8 +1118,8 @@
   Exit:
     if ( error )
     {
-      FREE( node );
-      FREE( size );
+      FT_FREE( node );
+      FT_FREE( size );
     }
 
     return error;
@@ -1573,7 +1156,7 @@
     if ( node )
     {
       FT_List_Remove( &face->sizes_list, node );
-      FREE( node );
+      FT_FREE( node );
 
       if ( face->size == size )
       {
@@ -1622,7 +1205,7 @@
   {
     FT_Error          error = FT_Err_Ok;
     FT_Driver         driver;
-    FT_Driver_Class*  clazz;
+    FT_Driver_Class   clazz;
     FT_Size_Metrics*  metrics;
     FT_Long           dim_x, dim_y;
 
@@ -1691,7 +1274,7 @@
   {
     FT_Error          error = FT_Err_Ok;
     FT_Driver         driver;
-    FT_Driver_Class*  clazz;
+    FT_Driver_Class   clazz;
     FT_Size_Metrics*  metrics = &face->size->metrics;
 
 
@@ -1848,17 +1431,107 @@
   }
 
 
+  FT_BASE_DEF( void )
+  FT_CMap_Done( FT_CMap  cmap )
+  {
+    if ( cmap )
+    {
+      FT_CMap_Class  clazz  = cmap->clazz;
+      FT_Face        face   = cmap->charmap.face;
+      FT_Memory      memory = FT_FACE_MEMORY(face);
+
+
+      if ( clazz->done )
+        clazz->done( cmap );
+
+      FT_FREE( cmap );
+    }
+  }
+
+
+  FT_BASE_DEF( FT_Error )
+  FT_CMap_New( FT_CMap_Class   clazz,
+               FT_Pointer      init_data,
+               FT_CharMap      charmap,
+               FT_CMap        *acmap )
+  {
+    FT_Error   error = 0;
+    FT_Face    face;
+    FT_Memory  memory;
+    FT_CMap    cmap;
+
+
+    if ( clazz == NULL || charmap == NULL || charmap->face == NULL )
+      return FT_Err_Invalid_Argument;
+
+    face   = charmap->face;
+    memory = FT_FACE_MEMORY(face);
+
+    if ( !FT_ALLOC( cmap, clazz->size ) )
+    {
+      cmap->charmap = *charmap;
+      cmap->clazz   = clazz;
+
+      if ( clazz->init )
+      {
+        error = clazz->init( cmap, init_data );
+        if ( error )
+          goto Fail;
+      }
+
+      /* add it to our list of charmaps */
+      if ( FT_RENEW_ARRAY( face->charmaps,
+                           face->num_charmaps,
+                           face->num_charmaps+1 ) )
+        goto Fail;
+
+      face->charmaps[face->num_charmaps++] = (FT_CharMap)cmap;
+    }
+
+  Exit:
+    if ( acmap )
+      *acmap = cmap;
+
+    return error;
+
+  Fail:
+    FT_CMap_Done( cmap );
+    cmap = NULL;
+    goto Exit;
+  }
+
+
   /* documentation is in freetype.h */
 
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+  FT_EXPORT_DEF( FT_UInt )
+  FT_Get_Char_Index( FT_Face   face,
+                     FT_ULong  charcode )
+  {
+    FT_UInt  result = 0;
+
+
+    if ( face && face->charmap )
+    {
+      FT_CMap  cmap = FT_CMAP( face->charmap );
+
+
+      result = cmap->clazz->char_index( cmap, charcode );
+    }
+    return  result;
+  }
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
   FT_EXPORT_DEF( FT_UInt )
   FT_Get_Char_Index( FT_Face   face,
                      FT_ULong  charcode )
   {
-    FT_UInt    result;
+    FT_UInt    result = 0;
     FT_Driver  driver;
 
 
-    result = 0;
     if ( face && face->charmap )
     {
       driver = face->driver;
@@ -1867,9 +1540,97 @@
     return result;
   }
 
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
 
+
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( FT_ULong )
+  FT_Get_First_Char( FT_Face   face,
+                     FT_UInt  *agindex )
+  {
+    FT_ULong  result = 0;
+    FT_UInt   gindex = 0;
+
+
+    if ( face && face->charmap )
+    {
+      gindex = FT_Get_Char_Index( face, 0 );
+      if ( gindex == 0 )
+        result = FT_Get_Next_Char( face, 0, &gindex );
+    }
+
+    if ( agindex  )
+      *agindex = gindex;
+
+    return result;
+  }
+
   /* documentation is in freetype.h */
 
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+  FT_EXPORT_DEF( FT_ULong )
+  FT_Get_Next_Char( FT_Face   face,
+                    FT_ULong  charcode,
+                    FT_UInt  *agindex )
+  {
+    FT_ULong  result = 0;
+    FT_UInt   gindex = 0;
+
+
+    if ( face && face->charmap )
+    {
+      FT_UInt32  code = (FT_UInt32)charcode;
+      FT_CMap    cmap = FT_CMAP( face->charmap );
+
+
+      gindex = cmap->clazz->char_next( cmap, &code );
+      result = ( gindex == 0 ) ? 0 : code;
+    }
+
+    if ( agindex )
+      *agindex = gindex;
+
+    return result;
+  }
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+  FT_EXPORT_DEF( FT_ULong )
+  FT_Get_Next_Char( FT_Face   face,
+                    FT_ULong  charcode,
+                    FT_UInt  *agindex )
+  {
+    FT_ULong   result = 0;
+    FT_UInt    gindex = 0;
+    FT_Driver  driver;
+
+
+    if ( face && face->charmap )
+    {
+      driver = face->driver;
+      result = driver->clazz->get_next_char( face->charmap, charcode );
+      if ( result != 0 )
+      {
+        gindex = driver->clazz->get_char_index( face->charmap, result );
+        if ( gindex == 0 )
+          result = 0;
+      }
+    }
+
+    if ( agindex )
+      *agindex = gindex;
+
+    return result;
+  }
+
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+
+  /* documentation is in freetype.h */
+
   FT_EXPORT_DEF( FT_UInt )
   FT_Get_Name_Index( FT_Face     face,
                      FT_String*  glyph_name )
@@ -1886,10 +1647,10 @@
 
       if ( clazz->get_interface )
       {
-        FT_Name_Index_Requester  requester;
+        FT_Face_GetGlyphNameIndexFunc  requester;
 
 
-        requester = (FT_Name_Index_Requester)clazz->get_interface(
+        requester = (FT_Face_GetGlyphNameIndexFunc)clazz->get_interface(
                       FT_MODULE( driver ), "name_index" );
         if ( requester )
           result = requester( face, glyph_name );
@@ -1920,16 +1681,16 @@
          FT_HAS_GLYPH_NAMES( face )              )
     {
       /* now, lookup for glyph name */
-      FT_Driver        driver = face->driver;
-      FT_Module_Class* clazz  = FT_MODULE_CLASS( driver );
+      FT_Driver         driver = face->driver;
+      FT_Module_Class*  clazz  = FT_MODULE_CLASS( driver );
 
 
       if ( clazz->get_interface )
       {
-        FT_Glyph_Name_Requester  requester;
+        FT_Face_GetGlyphNameFunc  requester;
 
 
-        requester = (FT_Glyph_Name_Requester)clazz->get_interface(
+        requester = (FT_Face_GetGlyphNameFunc)clazz->get_interface(
                       FT_MODULE( driver ), "glyph_name" );
         if ( requester )
           error = requester( face, glyph_index, buffer, buffer_max );
@@ -1954,17 +1715,17 @@
     result = face->internal->postscript_name;
     if ( !result )
     {
-      /* now, lookup for glyph name */
+      /* now, look up glyph name */
       FT_Driver         driver = face->driver;
       FT_Module_Class*  clazz  = FT_MODULE_CLASS( driver );
 
 
       if ( clazz->get_interface )
       {
-        FT_PSName_Requester  requester;
+        FT_Face_GetPostscriptNameFunc  requester;
 
 
-        requester = (FT_PSName_Requester)clazz->get_interface(
+        requester = (FT_Face_GetPostscriptNameFunc)clazz->get_interface(
                       FT_MODULE( driver ), "postscript_name" );
         if ( requester )
           result = requester( face );
@@ -2039,8 +1800,8 @@
                       FT_Glyph_Format  format,
                       FT_ListNode*     node )
   {
-    FT_ListNode   cur;
-    FT_Renderer   result = 0;
+    FT_ListNode  cur;
+    FT_Renderer  result = 0;
 
 
     if ( !library )
@@ -2111,7 +1872,7 @@
     FT_ListNode  node;
 
 
-    if ( ALLOC( node, sizeof ( *node ) ) )
+    if ( FT_NEW( node ) )
       goto Exit;
 
     {
@@ -2143,7 +1904,7 @@
 
   Fail:
     if ( error )
-      FREE( node );
+      FT_FREE( node );
 
   Exit:
     return error;
@@ -2170,7 +1931,7 @@
 
       /* remove from list */
       FT_List_Remove( &library->renderers, node );
-      FREE( node );
+      FT_FREE( node );
 
       ft_set_current_renderer( library );
     }
@@ -2185,7 +1946,7 @@
   {
     /* test for valid `library' delayed to FT_Lookup_Renderer() */
 
-    return  FT_Lookup_Renderer( library, format, 0 );
+    return FT_Lookup_Renderer( library, format, 0 );
   }
 
 
@@ -2237,7 +1998,7 @@
   }
 
 
-  FT_EXPORT_DEF( FT_Error )
+  FT_BASE_DEF( FT_Error )
   FT_Render_Glyph_Internal( FT_Library    library,
                             FT_GlyphSlot  slot,
                             FT_UInt       render_mode )
@@ -2302,7 +2063,7 @@
   FT_Render_Glyph( FT_GlyphSlot  slot,
                    FT_UInt       render_mode )
   {
-    FT_Library   library;
+    FT_Library  library;
 
 
     if ( !slot )
@@ -2370,7 +2131,7 @@
       clazz->module_done( module );
 
     /* discard it */
-    FREE( module );
+    FT_FREE( module );
   }
 
 
@@ -2403,7 +2164,7 @@
     for ( nn = 0; nn < library->num_modules; nn++ )
     {
       module = library->modules[nn];
-      if ( strcmp( module->clazz->module_name, clazz->module_name ) == 0 )
+      if ( ft_strcmp( module->clazz->module_name, clazz->module_name ) == 0 )
       {
         /* this installed module has the same name, compare their versions */
         if ( clazz->module_version <= module->clazz->module_version )
@@ -2426,7 +2187,7 @@
     }
 
     /* allocate module object */
-    if ( ALLOC( module,clazz->module_size ) )
+    if ( FT_ALLOC( module,clazz->module_size ) )
       goto Exit;
 
     /* base initialization */
@@ -2452,10 +2213,10 @@
     if ( FT_MODULE_IS_DRIVER( module ) )
     {
       /* allocate glyph loader if needed */
-      FT_Driver   driver = FT_DRIVER( module );
+      FT_Driver  driver = FT_DRIVER( module );
 
 
-      driver->clazz = (FT_Driver_Class*)module->clazz;
+      driver->clazz = (FT_Driver_Class)module->clazz;
       if ( FT_DRIVER_USES_OUTLINES( driver ) )
       {
         error = FT_GlyphLoader_New( memory, &driver->glyph_loader );
@@ -2496,7 +2257,7 @@
         renderer->clazz->raster_class->raster_done( renderer->raster );
     }
 
-    FREE( module );
+    FT_FREE( module );
     goto Exit;
   }
 
@@ -2519,7 +2280,7 @@
     limit = cur + library->num_modules;
 
     for ( ; cur < limit; cur++ )
-      if ( strcmp( cur[0]->clazz->module_name, module_name ) == 0 )
+      if ( ft_strcmp( cur[0]->clazz->module_name, module_name ) == 0 )
       {
         result = cur[0];
         break;
@@ -2614,15 +2375,20 @@
     if ( !memory )
       return FT_Err_Invalid_Argument;
 
+#ifdef FT_DEBUG_LEVEL_ERROR
+    /* init debugging support */
+    ft_debug_init();
+#endif
+
     /* first of all, allocate the library object */
-    if ( ALLOC( library, sizeof ( *library ) ) )
+    if ( FT_NEW( library ) )
       return error;
 
     library->memory = memory;
 
     /* allocate the render pool */
     library->raster_pool_size = FT_RENDER_POOL_SIZE;
-    if ( ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) )
+    if ( FT_ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) )
       goto Fail;
 
     /* That's ok now */
@@ -2631,11 +2397,42 @@
     return FT_Err_Ok;
 
   Fail:
-    FREE( library );
+    FT_FREE( library );
     return error;
   }
 
 
+  /* documentation is in freetype.h */
+
+  FT_EXPORT_DEF( void )
+  FT_Library_Version( FT_Library   library,
+                      FT_Int      *amajor,
+                      FT_Int      *aminor,
+                      FT_Int      *apatch )
+  {
+    FT_Int  major = 0;
+    FT_Int  minor = 0;
+    FT_Int  patch = 0;
+
+
+    if ( library )
+    {
+      major = library->version_major;
+      minor = library->version_minor;
+      patch = library->version_patch;
+    }
+
+    if ( *amajor )
+      *amajor = major;
+
+    if ( *aminor )
+      *aminor = minor;
+
+    if ( *apatch )
+      *apatch = patch;
+  }
+
+
   /* documentation is in ftmodule.h */
 
   FT_EXPORT_DEF( FT_Error )
@@ -2677,10 +2474,10 @@
 #endif
 
     /* Destroy raster objects */
-    FREE( library->raster_pool );
+    FT_FREE( library->raster_pool );
     library->raster_pool_size = 0;
 
-    FREE( library );
+    FT_FREE( library );
     return FT_Err_Ok;
   }
 
Index: xc/extras/freetype2/src/base/ftoutln.c
diff -u xc/extras/freetype2/src/base/ftoutln.c:1.1.1.5 xc/extras/freetype2/src/base/ftoutln.c:1.1.1.6
--- xc/extras/freetype2/src/base/ftoutln.c:1.1.1.5	Mon Jan 14 11:52:10 2002
+++ xc/extras/freetype2/src/base/ftoutln.c	Thu Jun 20 04:16:14 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType outline management (body).                                  */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -46,7 +46,7 @@
 
   FT_EXPORT_DEF( FT_Error )
   FT_Outline_Decompose( FT_Outline*              outline,
-                        const FT_Outline_Funcs*  interface,
+                        const FT_Outline_Funcs*  func_interface,
                         void*                    user )
   {
 #undef SCALED
@@ -70,11 +70,11 @@
     FT_Pos   delta;
 
 
-    if ( !outline || !interface )
+    if ( !outline || !func_interface )
       return FT_Err_Invalid_Argument;
 
-    shift = interface->shift;
-    delta = interface->delta;
+    shift = func_interface->shift;
+    delta = func_interface->delta;
     first = 0;
 
     for ( n = 0; n < outline->n_contours; n++ )
@@ -125,7 +125,7 @@
         tags--;
       }
 
-      error = interface->move_to( &v_start, user );
+      error = func_interface->move_to( &v_start, user );
       if ( error )
         goto Exit;
 
@@ -145,7 +145,7 @@
             vec.x = SCALED( point->x );
             vec.y = SCALED( point->y );
 
-            error = interface->line_to( &vec, user );
+            error = func_interface->line_to( &vec, user );
             if ( error )
               goto Exit;
             continue;
@@ -171,7 +171,7 @@
 
             if ( tag == FT_Curve_Tag_On )
             {
-              error = interface->conic_to( &v_control, &vec, user );
+              error = func_interface->conic_to( &v_control, &vec, user );
               if ( error )
                 goto Exit;
               continue;
@@ -183,7 +183,7 @@
             v_middle.x = ( v_control.x + vec.x ) / 2;
             v_middle.y = ( v_control.y + vec.y ) / 2;
 
-            error = interface->conic_to( &v_control, &v_middle, user );
+            error = func_interface->conic_to( &v_control, &v_middle, user );
             if ( error )
               goto Exit;
 
@@ -191,7 +191,7 @@
             goto Do_Conic;
           }
 
-          error = interface->conic_to( &v_control, &v_start, user );
+          error = func_interface->conic_to( &v_control, &v_start, user );
           goto Close;
 
         default:  /* FT_Curve_Tag_Cubic */
@@ -217,20 +217,20 @@
               vec.x = SCALED( point->x );
               vec.y = SCALED( point->y );
 
-              error = interface->cubic_to( &vec1, &vec2, &vec, user );
+              error = func_interface->cubic_to( &vec1, &vec2, &vec, user );
               if ( error )
                 goto Exit;
               continue;
             }
 
-            error = interface->cubic_to( &vec1, &vec2, &v_start, user );
+            error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );
             goto Close;
           }
         }
       }
 
       /* close the contour with a line segment */
-      error = interface->line_to( &v_start, user );
+      error = func_interface->line_to( &v_start, user );
 
     Close:
       if ( error )
@@ -263,9 +263,9 @@
 
     *anoutline = null_outline;
 
-    if ( ALLOC_ARRAY( anoutline->points,   numPoints * 2L, FT_Pos    ) ||
-         ALLOC_ARRAY( anoutline->tags,     numPoints,      FT_Byte   ) ||
-         ALLOC_ARRAY( anoutline->contours, numContours,    FT_UShort ) )
+    if ( FT_NEW_ARRAY( anoutline->points,   numPoints * 2L ) ||
+         FT_NEW_ARRAY( anoutline->tags,     numPoints      ) ||
+         FT_NEW_ARRAY( anoutline->contours, numContours    ) )
       goto Fail;
 
     anoutline->n_points    = (FT_UShort)numPoints;
@@ -357,14 +357,14 @@
          source->n_contours != target->n_contours )
       return FT_Err_Invalid_Argument;
 
-    MEM_Copy( target->points, source->points,
-              source->n_points * sizeof ( FT_Vector ) );
+    FT_MEM_COPY( target->points, source->points,
+                 source->n_points * sizeof ( FT_Vector ) );
 
-    MEM_Copy( target->tags, source->tags,
-              source->n_points * sizeof ( FT_Byte ) );
+    FT_MEM_COPY( target->tags, source->tags,
+                 source->n_points * sizeof ( FT_Byte ) );
 
-    MEM_Copy( target->contours, source->contours,
-              source->n_contours * sizeof ( FT_Short ) );
+    FT_MEM_COPY( target->contours, source->contours,
+                 source->n_contours * sizeof ( FT_Short ) );
 
     /* copy all flags, except the `ft_outline_owner' one */
     is_owner      = target->flags & ft_outline_owner;
@@ -385,9 +385,9 @@
     {
       if ( outline->flags & ft_outline_owner )
       {
-        FREE( outline->points   );
-        FREE( outline->tags     );
-        FREE( outline->contours );
+        FT_FREE( outline->points   );
+        FT_FREE( outline->tags     );
+        FT_FREE( outline->contours );
       }
       *outline = null_outline;
 
Index: xc/extras/freetype2/src/base/ftstream.c
diff -u xc/extras/freetype2/src/base/ftstream.c:1.1.1.3 xc/extras/freetype2/src/base/ftstream.c:1.1.1.4
--- xc/extras/freetype2/src/base/ftstream.c:1.1.1.3	Sun Dec 16 12:49:27 2001
+++ xc/extras/freetype2/src/base/ftstream.c	Thu Jun 20 04:16:14 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    I/O stream support (body).                                           */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -32,13 +32,11 @@
 
 
   FT_BASE_DEF( void )
-  FT_New_Memory_Stream( FT_Library  library,
-                        FT_Byte*    base,
-                        FT_ULong    size,
-                        FT_Stream   stream )
+  FT_Stream_OpenMemory( FT_Stream       stream,
+                        const FT_Byte*  base,
+                        FT_ULong        size )
   {
-    stream->memory = library->memory;
-    stream->base   = base;
+    stream->base   = (FT_Byte*) base;
     stream->size   = size;
     stream->pos    = 0;
     stream->cursor = 0;
@@ -47,11 +45,22 @@
   }
 
 
+  FT_BASE_DEF( void )
+  FT_Stream_Close( FT_Stream  stream )
+  {
+    if ( stream && stream->close )
+    {
+      stream->close( stream );
+      stream->close = NULL;
+    }
+  }
+
+
   FT_BASE_DEF( FT_Error )
-  FT_Seek_Stream( FT_Stream  stream,
+  FT_Stream_Seek( FT_Stream  stream,
                   FT_ULong   pos )
   {
-    FT_Error  error;
+    FT_Error  error = FT_Err_Ok;
 
 
     stream->pos = pos;
@@ -60,37 +69,30 @@
     {
       if ( stream->read( stream, pos, 0, 0 ) )
       {
-        FT_ERROR(( "FT_Seek_Stream:" ));
-        FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+        FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                    pos, stream->size ));
 
         error = FT_Err_Invalid_Stream_Operation;
       }
-      else
-        error = FT_Err_Ok;
     }
     /* note that seeking to the first position after the file is valid */
     else if ( pos > stream->size )
     {
-      FT_ERROR(( "FT_Seek_Stream:" ));
-      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+      FT_ERROR(( "FT_Stream_Seek: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                  pos, stream->size ));
 
       error = FT_Err_Invalid_Stream_Operation;
     }
 
-    else
-      error = FT_Err_Ok;
-
     return error;
   }
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Skip_Stream( FT_Stream  stream,
+  FT_Stream_Skip( FT_Stream  stream,
                   FT_Long    distance )
   {
-    return FT_Seek_Stream( stream, (FT_ULong)( stream->pos + distance ) );
+    return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
   }
 
 
@@ -102,19 +104,19 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Stream( FT_Stream  stream,
+  FT_Stream_Read( FT_Stream  stream,
                   FT_Byte*   buffer,
                   FT_ULong   count )
   {
-    return FT_Read_Stream_At( stream, stream->pos, buffer, count );
+    return FT_Stream_ReadAt( stream, stream->pos, buffer, count );
   }
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Stream_At( FT_Stream  stream,
-                     FT_ULong   pos,
-                     FT_Byte*   buffer,
-                     FT_ULong   count )
+  FT_Stream_ReadAt( FT_Stream  stream,
+                    FT_ULong   pos,
+                    FT_Byte*   buffer,
+                    FT_ULong   count )
   {
     FT_Error  error = FT_Err_Ok;
     FT_ULong  read_bytes;
@@ -122,8 +124,7 @@
 
     if ( pos >= stream->size )
     {
-      FT_ERROR(( "FT_Read_Stream_At:" ));
-      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+      FT_ERROR(( "FT_Stream_ReadAt: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                  pos, stream->size ));
 
       return FT_Err_Invalid_Stream_Operation;
@@ -137,14 +138,14 @@
       if ( read_bytes > count )
         read_bytes = count;
 
-      MEM_Copy( buffer, stream->base + pos, read_bytes );
+      FT_MEM_COPY( buffer, stream->base + pos, read_bytes );
     }
 
     stream->pos = pos + read_bytes;
 
     if ( read_bytes < count )
     {
-      FT_ERROR(( "FT_Read_Stream_At:" ));
+      FT_ERROR(( "FT_Stream_ReadAt:" ));
       FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
                  count, read_bytes ));
 
@@ -156,19 +157,19 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Extract_Frame( FT_Stream  stream,
-                    FT_ULong   count,
-                    FT_Byte**  pbytes )
+  FT_Stream_ExtractFrame( FT_Stream  stream,
+                          FT_ULong   count,
+                          FT_Byte**  pbytes )
   {
     FT_Error  error;
 
 
-    error = FT_Access_Frame( stream, count );
+    error = FT_Stream_EnterFrame( stream, count );
     if ( !error )
     {
       *pbytes = (FT_Byte*)stream->cursor;
 
-      /* equivalent to FT_Forget_Frame(), with no memory block release */
+      /* equivalent to FT_Stream_ExitFrame(), with no memory block release */
       stream->cursor = 0;
       stream->limit  = 0;
     }
@@ -178,30 +179,30 @@
 
 
   FT_BASE_DEF( void )
-  FT_Release_Frame( FT_Stream  stream,
-                    FT_Byte**  pbytes )
+  FT_Stream_ReleaseFrame( FT_Stream  stream,
+                          FT_Byte**  pbytes )
   {
     if ( stream->read )
     {
       FT_Memory  memory = stream->memory;
 
 
-      FREE( *pbytes );
+      FT_FREE( *pbytes );
     }
     *pbytes = 0;
   }
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Access_Frame( FT_Stream  stream,
-                   FT_ULong   count )
+  FT_Stream_EnterFrame( FT_Stream  stream,
+                        FT_ULong   count )
   {
     FT_Error  error = FT_Err_Ok;
     FT_ULong  read_bytes;
 
 
     /* check for nested frame access */
-    FT_Assert( stream && stream->cursor == 0 );
+    FT_ASSERT( stream && stream->cursor == 0 );
 
     if ( stream->read )
     {
@@ -209,7 +210,7 @@
       FT_Memory  memory = stream->memory;
 
 
-      if ( ALLOC( stream->base, count ) )
+      if ( FT_ALLOC( stream->base, count ) )
         goto Exit;
 
       /* read it */
@@ -217,11 +218,11 @@
                                  stream->base, count );
       if ( read_bytes < count )
       {
-        FT_ERROR(( "FT_Access_Frame:" ));
+        FT_ERROR(( "FT_Stream_EnterFrame:" ));
         FT_ERROR(( " invalid read; expected %lu bytes, got %lu\n",
                    count, read_bytes ));
 
-        FREE( stream->base );
+        FT_FREE( stream->base );
         error = FT_Err_Invalid_Stream_Operation;
       }
       stream->cursor = stream->base;
@@ -234,7 +235,7 @@
       if ( stream->pos >= stream->size        ||
            stream->pos + count > stream->size )
       {
-        FT_ERROR(( "FT_Access_Frame:" ));
+        FT_ERROR(( "FT_Stream_EnterFrame:" ));
         FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
                    stream->pos, count, stream->size ));
 
@@ -254,7 +255,7 @@
 
 
   FT_BASE_DEF( void )
-  FT_Forget_Frame( FT_Stream  stream )
+  FT_Stream_ExitFrame( FT_Stream  stream )
   {
     /* IMPORTANT: The assertion stream->cursor != 0 was removed, given    */
     /*            that it is possible to access a frame of length 0 in    */
@@ -263,16 +264,16 @@
     /*                                                                    */
     /*  In this case, the loader code handles the 0-length table          */
     /*  gracefully; however, stream.cursor is really set to 0 by the      */
-    /*  FT_Access_Frame() call, and this is not an error.                 */
+    /*  FT_Stream_EnterFrame() call, and this is not an error.            */
     /*                                                                    */
-    FT_Assert( stream );
+    FT_ASSERT( stream );
 
     if ( stream->read )
     {
       FT_Memory  memory = stream->memory;
 
 
-      FREE( stream->base );
+      FT_FREE( stream->base );
     }
     stream->cursor = 0;
     stream->limit  = 0;
@@ -280,12 +281,12 @@
 
 
   FT_BASE_DEF( FT_Char )
-  FT_Get_Char( FT_Stream  stream )
+  FT_Stream_GetChar( FT_Stream  stream )
   {
     FT_Char  result;
 
 
-    FT_Assert( stream && stream->cursor );
+    FT_ASSERT( stream && stream->cursor );
 
     result = 0;
     if ( stream->cursor < stream->limit )
@@ -296,18 +297,18 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Get_Short( FT_Stream  stream )
+  FT_Stream_GetShort( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Short  result;
 
 
-    FT_Assert( stream && stream->cursor );
+    FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 1 < stream->limit )
-      result       = NEXT_Short( p );
+      result       = FT_NEXT_SHORT( p );
     stream->cursor = p;
 
     return result;
@@ -315,18 +316,18 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Get_ShortLE( FT_Stream  stream )
+  FT_Stream_GetShortLE( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Short  result;
 
 
-    FT_Assert( stream && stream->cursor );
+    FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 1 < stream->limit )
-      result       = NEXT_ShortLE( p );
+      result       = FT_NEXT_SHORT_LE( p );
     stream->cursor = p;
 
     return result;
@@ -334,67 +335,67 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Get_Offset( FT_Stream  stream )
+  FT_Stream_GetOffset( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Long   result;
 
 
-    FT_Assert( stream && stream->cursor );
+    FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 2 < stream->limit )
-      result       = NEXT_Offset( p );
+      result       = FT_NEXT_OFF3( p );
     stream->cursor = p;
     return result;
   }
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Get_Long( FT_Stream  stream )
+  FT_Stream_GetLong( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Long   result;
 
 
-    FT_Assert( stream && stream->cursor );
+    FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 3 < stream->limit )
-      result       = NEXT_Long( p );
+      result       = FT_NEXT_LONG( p );
     stream->cursor = p;
     return result;
   }
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Get_LongLE( FT_Stream  stream )
+  FT_Stream_GetLongLE( FT_Stream  stream )
   {
     FT_Byte*  p;
     FT_Long   result;
 
 
-    FT_Assert( stream && stream->cursor );
+    FT_ASSERT( stream && stream->cursor );
 
     result         = 0;
     p              = stream->cursor;
     if ( p + 3 < stream->limit )
-      result       = NEXT_LongLE( p );
+      result       = FT_NEXT_LONG_LE( p );
     stream->cursor = p;
     return result;
   }
 
 
   FT_BASE_DEF( FT_Char )
-  FT_Read_Char( FT_Stream  stream,
-                FT_Error*  error )
+  FT_Stream_ReadChar( FT_Stream  stream,
+                      FT_Error*  error )
   {
     FT_Byte  result = 0;
 
 
-    FT_Assert( stream );
+    FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
@@ -416,8 +417,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Char:" ));
-    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+    FT_ERROR(( "FT_Stream_ReadChar: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
     return 0;
@@ -425,15 +425,15 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Read_Short( FT_Stream  stream,
-                 FT_Error*  error )
+  FT_Stream_ReadShort( FT_Stream  stream,
+                       FT_Error*  error )
   {
     FT_Byte   reads[2];
     FT_Byte*  p = 0;
     FT_Short  result = 0;
 
 
-    FT_Assert( stream );
+    FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
@@ -452,7 +452,7 @@
       }
 
       if ( p )
-        result = NEXT_Short( p );
+        result = FT_NEXT_SHORT( p );
     }
     else
       goto Fail;
@@ -463,7 +463,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Short:" ));
+    FT_ERROR(( "FT_Stream_ReadShort:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
@@ -472,15 +472,15 @@
 
 
   FT_BASE_DEF( FT_Short )
-  FT_Read_ShortLE( FT_Stream  stream,
-                   FT_Error*  error )
+  FT_Stream_ReadShortLE( FT_Stream  stream,
+                         FT_Error*  error )
   {
     FT_Byte   reads[2];
     FT_Byte*  p = 0;
     FT_Short  result = 0;
 
 
-    FT_Assert( stream );
+    FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
@@ -499,7 +499,7 @@
       }
 
       if ( p )
-        result = NEXT_ShortLE( p );
+        result = FT_NEXT_SHORT_LE( p );
     }
     else
       goto Fail;
@@ -510,7 +510,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Short:" ));
+    FT_ERROR(( "FT_Stream_ReadShortLE:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
@@ -519,15 +519,15 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Read_Offset( FT_Stream  stream,
-                  FT_Error*  error )
+  FT_Stream_ReadOffset( FT_Stream  stream,
+                        FT_Error*  error )
   {
     FT_Byte   reads[3];
     FT_Byte*  p = 0;
     FT_Long   result = 0;
 
 
-    FT_Assert( stream );
+    FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
@@ -546,7 +546,7 @@
       }
 
       if ( p )
-        result = NEXT_Offset( p );
+        result = FT_NEXT_OFF3( p );
     }
     else
       goto Fail;
@@ -557,7 +557,7 @@
 
   Fail:
     *error = FT_Err_Invalid_Stream_Operation;
-    FT_ERROR(( "FT_Read_Offset:" ));
+    FT_ERROR(( "FT_Stream_ReadOffset:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
 
@@ -566,15 +566,15 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Read_Long( FT_Stream  stream,
-                FT_Error*  error )
+  FT_Stream_ReadLong( FT_Stream  stream,
+                      FT_Error*  error )
   {
     FT_Byte   reads[4];
     FT_Byte*  p = 0;
     FT_Long   result = 0;
 
 
-    FT_Assert( stream );
+    FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
@@ -593,7 +593,7 @@
       }
 
       if ( p )
-        result = NEXT_Long( p );
+        result = FT_NEXT_LONG( p );
     }
     else
       goto Fail;
@@ -603,8 +603,7 @@
     return result;
 
   Fail:
-    FT_ERROR(( "FT_Read_Long:" ));
-    FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+    FT_ERROR(( "FT_Stream_ReadLong: invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
     *error = FT_Err_Invalid_Stream_Operation;
 
@@ -613,15 +612,15 @@
 
 
   FT_BASE_DEF( FT_Long )
-  FT_Read_LongLE( FT_Stream  stream,
-                  FT_Error*  error )
+  FT_Stream_ReadLongLE( FT_Stream  stream,
+                        FT_Error*  error )
   {
     FT_Byte   reads[4];
     FT_Byte*  p = 0;
     FT_Long   result = 0;
 
 
-    FT_Assert( stream );
+    FT_ASSERT( stream );
 
     *error = FT_Err_Ok;
 
@@ -640,7 +639,7 @@
       }
 
       if ( p )
-        result = NEXT_LongLE( p );
+        result = FT_NEXT_LONG_LE( p );
     }
     else
       goto Fail;
@@ -650,7 +649,7 @@
     return result;
 
   Fail:
-    FT_ERROR(( "FT_Read_Long:" ));
+    FT_ERROR(( "FT_Stream_ReadLongLE:" ));
     FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
                stream->pos, stream->size ));
     *error = FT_Err_Invalid_Stream_Operation;
@@ -660,9 +659,9 @@
 
 
   FT_BASE_DEF( FT_Error )
-  FT_Read_Fields( FT_Stream              stream,
-                  const FT_Frame_Field*  fields,
-                  void*                  structure )
+  FT_Stream_ReadFields( FT_Stream              stream,
+                        const FT_Frame_Field*  fields,
+                        void*                  structure )
   {
     FT_Error  error;
     FT_Bool   frame_accessed = 0;
@@ -683,7 +682,7 @@
       switch ( fields->value )
       {
       case ft_frame_start:  /* access a new frame */
-        error = FT_Access_Frame( stream, fields->offset );
+        error = FT_Stream_EnterFrame( stream, fields->offset );
         if ( error )
           goto Exit;
 
@@ -707,7 +706,7 @@
           if ( fields->value == ft_frame_bytes )
           {
             p = (FT_Byte*)structure + fields->offset;
-            MEM_Copy( p, cursor, len );
+            FT_MEM_COPY( p, cursor, len );
           }
           cursor += len;
           fields++;
@@ -716,43 +715,43 @@
 
       case ft_frame_byte:
       case ft_frame_schar:  /* read a single byte */
-        value = NEXT_Byte(cursor);
+        value = FT_NEXT_BYTE(cursor);
         sign_shift = 24;
         break;
 
       case ft_frame_short_be:
       case ft_frame_ushort_be:  /* read a 2-byte big-endian short */
-        value = NEXT_UShort(cursor);
+        value = FT_NEXT_USHORT(cursor);
         sign_shift = 16;
         break;
 
       case ft_frame_short_le:
       case ft_frame_ushort_le:  /* read a 2-byte little-endian short */
-        value = NEXT_UShortLE(cursor);
+        value = FT_NEXT_USHORT_LE(cursor);
         sign_shift = 16;
         break;
 
       case ft_frame_long_be:
       case ft_frame_ulong_be:  /* read a 4-byte big-endian long */
-        value = NEXT_ULong(cursor);
+        value = FT_NEXT_ULONG(cursor);
         sign_shift = 0;
         break;
 
       case ft_frame_long_le:
       case ft_frame_ulong_le:  /* read a 4-byte little-endian long */
-        value = NEXT_ULongLE(cursor);
+        value = FT_NEXT_ULONG_LE(cursor);
         sign_shift = 0;
         break;
 
       case ft_frame_off3_be:
       case ft_frame_uoff3_be:  /* read a 3-byte big-endian long */
-        value = NEXT_UOffset(cursor);
+        value = FT_NEXT_UOFF3(cursor);
         sign_shift = 8;
         break;
 
       case ft_frame_off3_le:
       case ft_frame_uoff3_le:  /* read a 3-byte little-endian long */
-        value = NEXT_UOffsetLE(cursor);
+        value = FT_NEXT_UOFF3_LE(cursor);
         sign_shift = 8;
         break;
 
@@ -795,7 +794,7 @@
   Exit:
     /* close the frame if it was opened by this read */
     if ( frame_accessed )
-      FT_Forget_Frame( stream );
+      FT_Stream_ExitFrame( stream );
 
     return error;
   }
Index: xc/extras/freetype2/src/base/ftsysio.c
diff -u /dev/null xc/extras/freetype2/src/base/ftsysio.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/base/ftsysio.c	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,131 @@
+#include <ft2build.h>
+#include FT_SYSTEM_STREAM_H
+
+#include <stdio.h>
+
+ /* the ISO/ANSI standard stream object */
+  typedef struct FT_StdStreamRec_
+  {
+    FT_StreamRec  stream;
+    FILE*         file;
+    const char*   pathname;
+  
+  } FT_StdStreamRec, *FT_StdStream;
+
+
+
+ /* read bytes from a standard stream */
+  static FT_ULong
+  ft_std_stream_read( FT_StdStream   stream,
+                      FT_Byte*       buffer,
+                      FT_ULong       size )
+  {
+    long   read_bytes;
+    
+    read_bytes = fread( buffer, 1, size, stream->file );
+    if ( read_bytes < 0 )
+      read_bytes = 0;
+      
+    return (FT_ULong) read_bytes;
+  }
+
+
+ /* seek the standard stream to a new position */
+  static FT_Error
+  ft_std_stream_seek( FT_StdStream   stream,
+                      FT_ULong       pos )
+  {
+    return ( fseek( stream->file, pos, SEEK_SET ) < 0 )
+         ? FT_Err_Stream_Seek
+         : FT_Err_Ok;
+  }
+  
+  
+ /* close a standard stream */  
+  static void
+  ft_std_stream_done( FT_StdStream  stream )
+  {
+    fclose( stream->file );
+    stream->file     = NULL;
+    stream->pathname = NULL;
+  }
+
+
+ /* open a standard stream from a given pathname */
+  static void
+  ft_std_stream_init( FT_StdStream  stream,
+                      const char*   pathname )
+  {
+    FT_ASSERT( pathname != NULL );
+
+    stream->file = fopen( pathname, "rb" );
+    if ( stream->file == NULL )
+    {
+      FT_ERROR(( "iso.stream.init: could not open '%s'\n", pathname ));
+      FT_XTHROW( FT_Err_Stream_Open );
+    }
+    
+    /* compute total size in bytes */
+    fseek( file, 0, SEEK_END );
+    FT_STREAM__SIZE(stream) = ftell( file );
+    fseek( file, 0, SEEK_SET );
+    
+    stream->pathname = pathname;
+    stream->pos      = 0;
+    
+    FT_TRACE1(( "iso.stream.init: opened '%s' (%ld bytes) succesfully\n",
+                 pathname, FT_STREAM__SIZE(stream) ));
+  }                 
+
+
+  static void
+  ft_std_stream_class_init( FT_ClassRec*  _clazz )
+  {
+    FT_StreamClassRec*  clazz = FT_STREAM_CLASS(_clazz);
+    
+    clazz->stream_read = (FT_Stream_ReadFunc) ft_std_stream_read;
+    clazz->stream_seek = (FT_Stream_SeekFunc) ft_std_stream_seek;
+  }
+
+
+  static const FT_TypeRec  ft_std_stream_type;
+  {
+    "StreamClass",
+    NULL,
+    
+    sizeof( FT_ClassRec ),
+    ft_stream_class_init,
+    NULL,
+    
+    sizeof( FT_StdStreamRec ),
+    ft_std_stream_init,
+    ft_std_stream_done,
+    NULL,
+  };
+  
+
+
+  FT_EXPORT_DEF( FT_Stream )
+  ft_std_stream_new( FT_Memory    memory,
+                     const char*  pathname )
+  {
+    FT_Class  clazz;
+    
+    clazz = ft_class_from_type( memory, &ft_std_stream_type );
+    
+    return (FT_Stream) ft_object_new( clazz, pathname );
+  }                     
+
+
+  FT_EXPORT_DEF( void )
+  ft_std_stream_create( FT_Memory    memory,
+                        const char*  pathname,
+                        FT_Stream*   astream )
+  {
+    FT_Class  clazz;
+    
+    clazz = ft_class_from_type( memory, &ft_std_stream_type );
+    
+    ft_object_create( clazz, pathname, FT_OBJECT_P(astream) );
+  }                        
+
Index: xc/extras/freetype2/src/base/ftsysmem.c
diff -u /dev/null xc/extras/freetype2/src/base/ftsysmem.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/base/ftsysmem.c	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,30 @@
+#include <ft2build.h>
+#include FT_SYSTEM_MEMORY_H
+
+  static FT_Memory
+  ft_memory_new_default( FT_ULong  size )
+  {
+    return (FT_Memory) ft_malloc( size );
+  }
+  
+  static void
+  ft_memory_destroy_default( FT_Memory  memory )
+  {
+    ft_free( memory );
+  }
+
+  
+ /* notice that in normal builds, we use the ISO C library functions */
+ /* 'malloc', 'free' and 'realloc' directly..                        */
+ /*                                                                  */
+  static const FT_Memory_FuncsRec  ft_memory_funcs_default_rec = 
+  {
+    (FT_Memory_CreateFunc)  ft_memory_new_iso,
+    (FT_Memory_DestroyFunc) ft_memory_destroy_iso,
+    (FT_Memory_AllocFunc)   ft_malloc,
+    (FT_Memory_FreeFunc)    ft_free,
+    (FT_Memory_ReallocFunc) ft_realloc
+  };
+  
+  FT_APIVAR_DEF( const FT_Memory_Funcs )
+  ft_memory_funcs_default = &ft_memory_funcs_defaults_rec;
Index: xc/extras/freetype2/src/base/ftsystem.c
diff -u xc/extras/freetype2/src/base/ftsystem.c:1.1.1.5 xc/extras/freetype2/src/base/ftsystem.c:1.1.1.6
--- xc/extras/freetype2/src/base/ftsystem.c:1.1.1.5	Mon Jan 14 11:52:10 2002
+++ xc/extras/freetype2/src/base/ftsystem.c	Thu Jun 20 04:16:14 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    ANSI-specific FreeType low-level system interface (body).            */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -34,7 +34,6 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 
   /*************************************************************************/
@@ -158,7 +157,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    ft_close_stream                                                    */
+  /*    ft_ansi_stream_close                                               */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The function to close a stream.                                    */
@@ -167,7 +166,7 @@
   /*    stream :: A pointer to the stream object.                          */
   /*                                                                       */
   FT_CALLBACK_DEF( void )
-  ft_close_stream( FT_Stream  stream )
+  ft_ansi_stream_close( FT_Stream  stream )
   {
     fclose( STREAM_FILE( stream ) );
 
@@ -180,7 +179,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    ft_io_stream                                                       */
+  /*    ft_ansi_stream_io                                                  */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The function to open a stream.                                     */
@@ -198,10 +197,10 @@
   /*    The number of bytes actually read.                                 */
   /*                                                                       */
   FT_CALLBACK_DEF( unsigned long )
-  ft_io_stream( FT_Stream       stream,
-                unsigned long   offset,
-                unsigned char*  buffer,
-                unsigned long   count )
+  ft_ansi_stream_io( FT_Stream       stream,
+                     unsigned long   offset,
+                     unsigned char*  buffer,
+                     unsigned long   count )
   {
     FILE*  file;
 
@@ -217,55 +216,54 @@
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Error )
-  FT_New_Stream( const char*  filepathname,
-                 FT_Stream    astream )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname )
   {
     FILE*  file;
 
 
-    if ( !astream )
+    if ( !stream )
       return FT_Err_Invalid_Stream_Handle;
 
     file = fopen( filepathname, "rb" );
     if ( !file )
     {
-      FT_ERROR(( "FT_New_Stream:" ));
+      FT_ERROR(( "FT_Stream_Open:" ));
       FT_ERROR(( " could not open `%s'\n", filepathname ));
 
       return FT_Err_Cannot_Open_Resource;
     }
 
     fseek( file, 0, SEEK_END );
-    astream->size = ftell( file );
+    stream->size = ftell( file );
     fseek( file, 0, SEEK_SET );
 
-    astream->descriptor.pointer = file;
-    astream->pathname.pointer   = (char*)filepathname;
-    astream->pos                = 0;
+    stream->descriptor.pointer = file;
+    stream->pathname.pointer   = (char*)filepathname;
+    stream->pos                = 0;
 
-    astream->read  = ft_io_stream;
-    astream->close = ft_close_stream;
+    stream->read  = ft_ansi_stream_io;
+    stream->close = ft_ansi_stream_close;
 
-    FT_TRACE1(( "FT_New_Stream:" ));
+    FT_TRACE1(( "FT_Stream_Open:" ));
     FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
-                filepathname, astream->size ));
+                filepathname, stream->size ));
 
     return FT_Err_Ok;
   }
 
 
-
 #ifdef FT_DEBUG_MEMORY
 
   extern FT_Int
   ft_mem_debug_init( FT_Memory  memory );
-  
+
   extern void
   ft_mem_debug_done( FT_Memory  memory );
-  
-#endif  
-      
-      
+
+#endif
+
+
   /* documentation is in ftobjs.h */
 
   FT_EXPORT_DEF( FT_Memory )
@@ -283,7 +281,7 @@
       memory->free    = ft_free;
 #ifdef FT_DEBUG_MEMORY
       ft_mem_debug_init( memory );
-#endif    
+#endif
     }
 
     return memory;
@@ -297,7 +295,7 @@
   {
 #ifdef FT_DEBUG_MEMORY
     ft_mem_debug_done( memory );
-#endif  
+#endif
     memory->free( memory, memory );
   }
 
Index: xc/extras/freetype2/src/base/fttrigon.c
diff -u xc/extras/freetype2/src/base/fttrigon.c:1.1.1.3 xc/extras/freetype2/src/base/fttrigon.c:1.1.1.4
--- xc/extras/freetype2/src/base/fttrigon.c:1.1.1.3	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/base/fttrigon.c	Thu Jun 20 04:16:14 2002
@@ -417,7 +417,11 @@
     ft_trig_pseudo_polarize( &v );
 
     v.x = ft_trig_downscale( v.x );
-    return ( shift >= 0 ) ? ( v.x >> shift ) : ( v.x << -shift );
+
+    if ( shift > 0 )
+      return ( v.x + ( 1 << ( shift - 1 ) ) ) >> shift;
+
+    return v.x << -shift;
   }
 
 
Index: xc/extras/freetype2/src/base/fttype1.c
diff -u /dev/null xc/extras/freetype2/src/base/fttype1.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/base/fttype1.c	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,100 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttype1.c                                                              */
+/*                                                                         */
+/*    FreeType utility file for PS names support (body).                   */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_OBJECTS_H
+
+
+  /* Cast a FT_Face to a T1_Face if necessary.                           */
+  /* This implementation sucks, but a lot of things should change in the */
+  /* future anyway...                                                    */
+  /*                                                                     */
+  static T1_Face
+  t1_face_check_cast( FT_Face  face )
+  {
+    FT_Module  driver;
+    T1_Face    result = NULL;
+
+
+    if ( face && face->driver != NULL )
+    {
+      driver = (FT_Module)face->driver;
+
+      if ( driver->clazz && driver->clazz->module_name &&
+           ft_strcmp( driver->clazz->module_name, "type1" ) == 0 )
+      {
+        /* correct typecast! */
+        result = (T1_Face)face;
+      }
+    }
+    return result;
+  }
+
+
+  /* documentation is in t1tables.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_Get_PS_Font_Info( FT_Face          face,
+                       PS_FontInfoRec*  afont_info )
+  {
+    FT_Error  error   = FT_Err_Invalid_Argument;
+    T1_Face   t1_face = t1_face_check_cast( face );
+
+
+    if ( t1_face != NULL )
+    {
+      *afont_info = t1_face->type1.font_info;
+      error       = FT_Err_Ok;
+    }
+
+    return error;
+  }
+
+
+  /* XXX: Bad hack, but I didn't want to change several drivers here. */
+
+  /* documentation is in t1tables.h */
+
+  FT_EXPORT_DEF( FT_Int )
+  FT_Has_PS_Glyph_Names( FT_Face  face )
+  {
+    FT_Int       result = 0;
+    const char*  driver_name;
+
+
+    if ( face && face->driver && face->driver->root.clazz )
+    {
+      /* Currently, only the type1 and cff drivers provide reliable */
+      /* glyph names...                                             */
+
+      /* We could probably hack the TrueType driver to recognize    */
+      /* certain cases where the glyph names are most certainly     */
+      /* correct (e.g. using a 20 or 22 format `post' table), but   */
+      /* this will probably happen later...                         */
+
+      driver_name = face->driver->root.clazz->module_name;
+      result      = ( ft_strcmp( driver_name, "type1" ) == 0 ||
+                      ft_strcmp( driver_name, "cff"   ) == 0 );
+    }
+
+    return result;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/base/ftutil.c
diff -u /dev/null xc/extras/freetype2/src/base/ftutil.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/base/ftutil.c	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,330 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftutil.c                                                               */
+/*                                                                         */
+/*    FreeType utility file for memory and list management (body).         */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_LIST_H
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_memory
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*****               M E M O R Y   M A N A G E M E N T               *****/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* documentation is in ftmemory.h */
+
+  FT_BASE_DEF( FT_Error )
+  FT_Alloc( FT_Memory  memory,
+            FT_Long    size,
+            void*     *P )
+  {
+    FT_ASSERT( P != 0 );
+
+    if ( size > 0 )
+    {
+      *P = memory->alloc( memory, size );
+      if ( !*P )
+      {
+        FT_ERROR(( "FT_Alloc:" ));
+        FT_ERROR(( " Out of memory? (%ld requested)\n",
+                   size ));
+
+        return FT_Err_Out_Of_Memory;
+      }
+      FT_MEM_SET( *P, 0, size );
+    }
+    else
+      *P = NULL;
+
+    FT_TRACE7(( "FT_Alloc:" ));
+    FT_TRACE7(( " size = %ld, block = 0x%08p, ref = 0x%08p\n",
+                size, *P, P ));
+
+    return FT_Err_Ok;
+  }
+
+
+  /* documentation is in ftmemory.h */
+
+  FT_BASE_DEF( FT_Error )
+  FT_Realloc( FT_Memory  memory,
+              FT_Long    current,
+              FT_Long    size,
+              void**     P )
+  {
+    void*  Q;
+
+
+    FT_ASSERT( P != 0 );
+
+    /* if the original pointer is NULL, call FT_Alloc() */
+    if ( !*P )
+      return FT_Alloc( memory, size, P );
+
+    /* if the new block if zero-sized, clear the current one */
+    if ( size <= 0 )
+    {
+      FT_Free( memory, P );
+      return FT_Err_Ok;
+    }
+
+    Q = memory->realloc( memory, current, size, *P );
+    if ( !Q )
+      goto Fail;
+
+    if ( size > current )
+      FT_MEM_SET( (char*)Q + current, 0, size - current );
+
+    *P = Q;
+    return FT_Err_Ok;
+
+  Fail:
+    FT_ERROR(( "FT_Realloc:" ));
+    FT_ERROR(( " Failed (current %ld, requested %ld)\n",
+               current, size ));
+    return FT_Err_Out_Of_Memory;
+  }
+
+
+  /* documentation is in ftmemory.h */
+
+  FT_BASE_DEF( void )
+  FT_Free( FT_Memory  memory,
+           void**     P )
+  {
+    FT_TRACE7(( "FT_Free:" ));
+    FT_TRACE7(( " Freeing block 0x%08p, ref 0x%08p\n",
+                P, P ? *P : (void*)0 ));
+
+    if ( P && *P )
+    {
+      memory->free( memory, *P );
+      *P = 0;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*****            D O U B L Y   L I N K E D   L I S T S              *****/
+  /*****                                                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_list
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( FT_ListNode )
+  FT_List_Find( FT_List  list,
+                void*    data )
+  {
+    FT_ListNode  cur;
+
+
+    cur = list->head;
+    while ( cur )
+    {
+      if ( cur->data == data )
+        return cur;
+
+      cur = cur->next;
+    }
+
+    return (FT_ListNode)0;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Add( FT_List      list,
+               FT_ListNode  node )
+  {
+    FT_ListNode  before = list->tail;
+
+
+    node->next = 0;
+    node->prev = before;
+
+    if ( before )
+      before->next = node;
+    else
+      list->head = node;
+
+    list->tail = node;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Insert( FT_List      list,
+                  FT_ListNode  node )
+  {
+    FT_ListNode  after = list->head;
+
+
+    node->next = after;
+    node->prev = 0;
+
+    if ( !after )
+      list->tail = node;
+    else
+      after->prev = node;
+
+    list->head = node;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Remove( FT_List      list,
+                  FT_ListNode  node )
+  {
+    FT_ListNode  before, after;
+
+
+    before = node->prev;
+    after  = node->next;
+
+    if ( before )
+      before->next = after;
+    else
+      list->head = after;
+
+    if ( after )
+      after->prev = before;
+    else
+      list->tail = before;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Up( FT_List      list,
+              FT_ListNode  node )
+  {
+    FT_ListNode  before, after;
+
+
+    before = node->prev;
+    after  = node->next;
+
+    /* check whether we are already on top of the list */
+    if ( !before )
+      return;
+
+    before->next = after;
+
+    if ( after )
+      after->prev = before;
+    else
+      list->tail = before;
+
+    node->prev       = 0;
+    node->next       = list->head;
+    list->head->prev = node;
+    list->head       = node;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( FT_Error )
+  FT_List_Iterate( FT_List            list,
+                   FT_List_Iterator   iterator,
+                   void*              user )
+  {
+    FT_ListNode  cur   = list->head;
+    FT_Error     error = FT_Err_Ok;
+
+
+    while ( cur )
+    {
+      FT_ListNode  next = cur->next;
+
+
+      error = iterator( cur, user );
+      if ( error )
+        break;
+
+      cur = next;
+    }
+
+    return error;
+  }
+
+
+  /* documentation is in ftlist.h */
+
+  FT_EXPORT_DEF( void )
+  FT_List_Finalize( FT_List             list,
+                    FT_List_Destructor  destroy,
+                    FT_Memory           memory,
+                    void*               user )
+  {
+    FT_ListNode  cur;
+
+
+    cur = list->head;
+    while ( cur )
+    {
+      FT_ListNode  next = cur->next;
+      void*        data = cur->data;
+
+
+      if ( destroy )
+        destroy( memory, data, user );
+
+      FT_FREE( cur );
+      cur = next;
+    }
+
+    list->head = 0;
+    list->tail = 0;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/base/ftxf86.c
diff -u /dev/null xc/extras/freetype2/src/base/ftxf86.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/base/ftxf86.c	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,80 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftxf86.c                                                               */
+/*                                                                         */
+/*    FreeType utility file for X11 support (body).                        */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_XFREE86_H
+#include FT_INTERNAL_OBJECTS_H
+
+  /* XXX: This really is a sad hack, but I didn't want to change every     */
+  /*      driver just to support this at the moment, since other important */
+  /*      changes are coming anyway.                                       */
+
+  typedef struct  FT_FontFormatRec_
+  {
+    const char*  driver_name;
+    const char*  format_name;
+
+  } FT_FontFormatRec;
+
+
+  FT_EXPORT_DEF( const char* )
+  FT_Get_X11_Font_Format( FT_Face  face )
+  {
+    static const FT_FontFormatRec  font_formats[] =
+    {
+      { "type1",    "Type 1" },
+      { "truetype", "TrueType" },
+      { "bdf",      "BDF" },
+      { "pcf",      "PCF" },
+      { "type42",   "Type 42" },
+      { "cidtype1", "CID Type 1" },
+      { "cff",      "CFF" },
+      { "pfr",      "PFR" },
+      { "winfonts",   "Windows FNT" }
+    };
+
+    const char*  result = NULL;
+
+
+    if ( face && face->driver )
+    {
+      FT_Module  driver = (FT_Module)face->driver;
+
+
+      if ( driver->clazz && driver->clazz->module_name )
+      {
+        FT_Int  n;
+        FT_Int  count = sizeof( font_formats ) / sizeof ( font_formats[0] );
+
+
+        result = driver->clazz->module_name;
+
+        for ( n = 0; n < count; n++ )
+          if ( ft_strcmp( result, font_formats[n].driver_name ) == 0 )
+          {
+            result = font_formats[n].format_name;
+            break;
+          }
+      }
+    }
+
+    return result;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/base/rules.mk
diff -u xc/extras/freetype2/src/base/rules.mk:1.1.1.3 xc/extras/freetype2/src/base/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/base/rules.mk:1.1.1.3	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/base/rules.mk	Thu Jun 20 04:16:14 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -34,11 +34,12 @@
 #
 BASE_SRC := $(BASE_)ftcalc.c   \
             $(BASE_)fttrigon.c \
-            $(BASE_)ftextend.c \
-            $(BASE_)ftlist.c   \
-            $(BASE_)ftobjs.c   \
+            $(BASE_)ftutil.c   \
             $(BASE_)ftstream.c \
+            $(BASE_)ftgloadr.c \
             $(BASE_)ftoutln.c  \
+            $(BASE_)ftobjs.c   \
+            $(BASE_)ftapi.c    \
             $(BASE_)ftnames.c  \
             $(BASE_)ftdbgmem.c
 
@@ -50,6 +51,9 @@
 #
 BASE_EXT_SRC := $(BASE_)ftglyph.c \
                 $(BASE_)ftmm.c    \
+                $(BASE_)ftbdf.c   \
+                $(BASE_)fttype1.c \
+                $(BASE_)ftxf86.c  \
                 $(BASE_)ftbbox.c
 
 # Default extensions objects
Index: xc/extras/freetype2/src/bdf/Jamfile
diff -u /dev/null xc/extras/freetype2/src/bdf/Jamfile:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/Jamfile	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,23 @@
+# FreeType 2 src/bdf Jamfile (c) 2002 David Turner
+#
+
+SubDir  FT2_TOP src bdf ;
+
+SubDirHdrs  [ FT2_SubDir  src bdf ] ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = bdfdrivr bdflib ;
+  }
+  else
+  {
+    _sources = bdf ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/bdf Jamfile
Index: xc/extras/freetype2/src/bdf/README
diff -u /dev/null xc/extras/freetype2/src/bdf/README:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/README	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,148 @@
+                  FreeType font driver for BDF fonts
+
+                       Francesco Zappa Nardelli
+                  <francesco.zappa.nardelli@ens.fr>
+
+
+Introduction
+************
+
+BDF (Bitmap Distribution Format) is a bitmap font format defined by Adobe,
+which is intended to be easily understood by both humans and computers. 
+This code implements a BDF driver for the FreeType library, following the
+Adobe Specification V 2.2.  The specification of the BDF font format is
+available from Adobe's web site:
+
+  http://partners.adobe.com/asn/developer/PDFS/TN/5005.BDF_Spec.pdf
+
+Many good bitmap fonts in bdf format come with XFree86 (www.XFree86.org). 
+They do not define vertical metrics, because the X Consortium BDF
+specification has removed them.
+
+
+Encodings
+*********
+
+The variety of encodings that accompanies bdf fonts appears to encompass the
+small set defined in freetype.h.  On the other hand, two properties that
+specify encoding and registry are usually defined in bdf fonts.
+
+I decided to make these two properties directly accessible, leaving to the
+client application the work of interpreting them.  For instance:
+
+
+  #include FT_INTERNAL_BDF_TYPES_H
+
+  FT_Face          face;
+  BDF_Public_Face  bdfface;
+
+
+  FT_New_Face( library, ..., &face );
+
+  bdfface = (BDF_Public_Face)face;
+  
+  if ( ( bdfface->charset_registry == "ISO10646" ) && 
+       ( bdfface->charset_encoding == "1" )        )
+    [..]
+
+
+Thus the driver always exports `ft_encoding_none' as face->charmap.encoding. 
+FT_Get_Char_Index's behavior is unmodified, that is, it converts the ULong
+value given as argument into the corresponding glyph number.
+
+If the two properties are not available, Adobe Standard Encoding should be
+assumed.
+
+
+Anti-Aliased Bitmaps
+********************
+
+The driver supports an extension to the BDF format as used in Mark Leisher's
+xmbdfed bitmap font editor.  Microsoft's SBIT tool expects bitmap fonts in
+that format for adding anti-aliased them to TrueType fonts.  It introduces a
+fourth field to the `SIZE' keyword which gives the bpp value (bits per
+pixel) of the glyph data in the font.  Possible values are 1 (the default),
+2 (four gray levels), 4 (16 gray levels), and 8 (256 gray levels).  The
+driver returns either a bitmap with 1 bit per pixel or a pixmap with 8bits
+per pixel (using 4, 16, and 256 gray levels, respectively).
+
+
+Known problems
+**************
+
+- A font is entirely loaded into memory.  Obviously, this is not the Right
+  Thing(TM).  If you have big fonts I suggest you convert them into PCF
+  format (using the bdftopcf utility): the PCF font drive of FreeType can
+  perform incremental glyph loading.
+
+When I have some time, I will implement on-demand glyph parsing.
+
+- Except for encodings properties, client applications have no visibility of
+  the PCF_Face object.  This means that applications cannot directly access
+  font tables and must trust FreeType.
+
+- Currently, glyph names are ignored.
+
+  I plan to give full visibility of the BDF_Face object in an upcoming
+  revision of the driver, thus implementing also glyph names.
+
+- As I have never seen a BDF font that defines vertical metrics, vertical
+  metrics are (parsed and) discarded.  If you own a BDF font that defines
+  vertical metrics, please let me know (I will implement them in 5-10
+  minutes).
+
+
+License
+*******
+
+Copyright (C) 2001-2002 by Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*** Portions of the driver (that is, bdflib.c and bdf.h):
+
+Copyright 2000 Computing Research Labs, New Mexico State University
+Copyright 2001-2002 Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY 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.
+
+
+Credits
+*******
+
+This driver is based on excellent Mark Leisher's bdf library.  If you
+find something good in this driver you should probably thank him, not
+me.
Index: xc/extras/freetype2/src/bdf/bdf.c
diff -u /dev/null xc/extras/freetype2/src/bdf/bdf.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/bdf.c	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,34 @@
+/*  bdf.c
+
+    FreeType font driver for bdf files
+
+    Copyright (C) 2001, 2002 by
+    Francesco Zappa Nardelli 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include <ft2build.h>
+#include "bdflib.c"
+#include "bdfdrivr.c"
+
+
+/* END */
Index: xc/extras/freetype2/src/bdf/bdf.h
diff -u /dev/null xc/extras/freetype2/src/bdf/bdf.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/bdf.h	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,295 @@
+/*
+ * Copyright 2000 Computing Research Labs, New Mexico State University
+ * Copyright 2001, 2002 Francesco Zappa Nardelli
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY 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.
+ */
+
+
+#ifndef __BDF_H__
+#define __BDF_H__
+
+
+/*
+ * Based on bdf.h,v 1.16 2000/03/16 20:08:51 mleisher
+ */
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+
+
+FT_BEGIN_HEADER
+
+
+/* Imported from bdfP.h */
+
+#define _bdf_glyph_modified( map, e )                 \
+          ( (map)[(e) >> 5] & ( 1 << ( (e) & 31 ) ) )
+#define _bdf_set_glyph_modified( map, e )              \
+          ( (map)[(e) >> 5] |= ( 1 << ( (e) & 31 ) ) )
+#define _bdf_clear_glyph_modified( map, e )             \
+          ( (map)[(e) >> 5] &= ~( 1 << ( (e) & 31 ) ) )
+
+/* end of bdfP.h */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font options macros and types.                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define BDF_CORRECT_METRICS  0x01 /* Correct invalid metrics when loading. */
+#define BDF_KEEP_COMMENTS    0x02 /* Preserve the font comments.           */
+#define BDF_KEEP_UNENCODED   0x04 /* Keep the unencoded glyphs.            */
+#define BDF_PROPORTIONAL     0x08 /* Font has proportional spacing.        */
+#define BDF_MONOWIDTH        0x10 /* Font has mono width.                  */
+#define BDF_CHARCELL         0x20 /* Font has charcell spacing.            */
+
+#define BDF_ALL_SPACING  ( BDF_PROPORTIONAL | \
+                           BDF_MONOWIDTH    | \
+                           BDF_CHARCELL     )
+
+#define BDF_DEFAULT_LOAD_OPTIONS  ( BDF_CORRECT_METRICS | \
+                                    BDF_KEEP_COMMENTS   | \
+                                    BDF_KEEP_UNENCODED  | \
+                                    BDF_PROPORTIONAL    )
+
+
+  typedef struct  bdf_options_t_
+  {
+    int            correct_metrics;
+    int            keep_unencoded;
+    int            keep_comments;
+    int            font_spacing;
+
+  } bdf_options_t;
+
+
+  /* Callback function type for unknown configuration options. */
+  typedef int
+  (*bdf_options_callback_t)( bdf_options_t*  opts,
+                             char**          params,
+                             unsigned long   nparams,
+                             void*           client_data );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font property macros and types.                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define BDF_ATOM      1
+#define BDF_INTEGER   2
+#define BDF_CARDINAL  3
+
+
+  /* This structure represents a particular property of a font. */
+  /* There are a set of defaults and each font has their own.   */
+  typedef struct  bdf_property_t_
+  {
+    char*  name;         /* Name of the property.   */
+    int    format;       /* Format of the property. */
+    int    builtin;      /* A builtin property.     */
+    union
+    {
+      char*          atom;
+      long           int32;
+      unsigned long  card32;
+
+    } value;             /* Value of the property.  */
+
+  } bdf_property_t;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font metric and glyph types.                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  typedef struct  bdf_bbx_t_
+  {
+    unsigned short  width;
+    unsigned short  height;
+
+    short           x_offset;
+    short           y_offset;
+
+    short           ascent;
+    short           descent;
+
+  } bdf_bbx_t;
+
+
+  typedef struct  bdf_glyph_t_
+  {
+    char*           name;        /* Glyph name.                          */
+    long            encoding;    /* Glyph encoding.                      */
+    unsigned short  swidth;      /* Scalable width.                      */
+    unsigned short  dwidth;      /* Device width.                        */
+    bdf_bbx_t       bbx;         /* Glyph bounding box.                  */
+    unsigned char*  bitmap;      /* Glyph bitmap.                        */
+    unsigned long   bpr;         /* Number of bytes used per row.        */
+    unsigned short  bytes;       /* Number of bytes used for the bitmap. */
+
+  } bdf_glyph_t;
+
+
+  typedef struct  _hashnode_
+  {
+    char*  key;
+    void*  data;
+  
+  } _hashnode, *hashnode;
+
+
+  typedef struct  hashtable_
+  {
+    int        limit;
+    int        size;
+    int        used;
+    hashnode*  table;
+
+  } hashtable;
+
+
+  typedef struct  bdf_glyphlist_t_
+  {
+    unsigned short  pad;          /* Pad to 4-byte boundary.              */
+    unsigned short  bpp;          /* Bits per pixel.                      */
+    long            start;        /* Beginning encoding value of glyphs.  */
+    long            end;          /* Ending encoding value of glyphs.     */
+    bdf_glyph_t*    glyphs;       /* Glyphs themselves.                   */
+    unsigned long   glyphs_size;  /* Glyph structures allocated.          */
+    unsigned long   glyphs_used;  /* Glyph structures used.               */
+    bdf_bbx_t       bbx;          /* Overall bounding box of glyphs.      */
+
+  } bdf_glyphlist_t;
+
+
+  typedef struct  bdf_font_t_
+  {
+    char*            name;           /* Name of the font.                   */
+    bdf_bbx_t        bbx;            /* Font bounding box.                  */
+
+    long             point_size;     /* Point size of the font.             */
+    unsigned long    resolution_x;   /* Font horizontal resolution.         */
+    unsigned long    resolution_y;   /* Font vertical resolution.           */
+
+    int              spacing;        /* Font spacing value.                 */
+
+    unsigned short   monowidth;      /* Logical width for monowidth font.   */
+
+    long             default_glyph;  /* Encoding of the default glyph.      */
+
+    long             font_ascent;    /* Font ascent.                        */
+    long             font_descent;   /* Font descent.                       */
+
+    unsigned long    glyphs_size;    /* Glyph structures allocated.         */
+    unsigned long    glyphs_used;    /* Glyph structures used.              */
+    bdf_glyph_t*     glyphs;         /* Glyphs themselves.                  */
+
+    unsigned long    unencoded_size; /* Unencoded glyph struct. allocated.  */
+    unsigned long    unencoded_used; /* Unencoded glyph struct. used.       */
+    bdf_glyph_t*     unencoded;      /* Unencoded glyphs themselves.        */
+
+    unsigned long    props_size;     /* Font properties allocated.          */
+    unsigned long    props_used;     /* Font properties used.               */
+    bdf_property_t*  props;          /* Font properties themselves.         */
+
+    char*            comments;       /* Font comments.                      */
+    unsigned long    comments_len;   /* Length of comment string.           */
+
+    bdf_glyphlist_t  overflow;       /* Storage used for glyph insertion.   */
+
+    void*            internal;       /* Internal data for the font.         */
+
+    unsigned long    nmod[2048];     /* Bitmap indicating modified glyphs.  */
+    unsigned long    umod[2048];     /* Bitmap indicating modified          */
+                                     /* unencoded glyphs.                   */
+    unsigned short   modified;       /* Boolean indicating font modified.   */
+    unsigned short   bpp;            /* Bits per pixel.                     */
+
+    FT_Memory        memory;
+
+    bdf_property_t*  user_props;
+    unsigned long    nuser_props;
+    hashtable        proptbl;
+
+  } bdf_font_t;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Types for load/save callbacks.                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Error codes. */
+#define BDF_MISSING_START       -1
+#define BDF_MISSING_FONTNAME    -2
+#define BDF_MISSING_SIZE        -3
+#define BDF_MISSING_CHARS       -4
+#define BDF_MISSING_STARTCHAR   -5
+#define BDF_MISSING_ENCODING    -6
+#define BDF_MISSING_BBX         -7
+
+#define BDF_OUT_OF_MEMORY      -20
+
+#define BDF_INVALID_LINE      -100
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font API.                                                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+  FT_LOCAL( FT_Error )
+  bdf_load_font( FT_Stream       stream,
+                 FT_Memory       memory,
+                 bdf_options_t*  opts,
+                 bdf_font_t*    *font );
+
+  FT_LOCAL( void )
+  bdf_free_font( bdf_font_t*  font );
+
+  FT_LOCAL( bdf_property_t * )
+  bdf_get_property( char*        name,
+                    bdf_font_t*  font );
+
+  FT_LOCAL( bdf_property_t * )
+  bdf_get_font_property( bdf_font_t*  font,
+                         char*        name );
+
+
+FT_END_HEADER
+
+
+#endif /* __BDF_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/bdf/bdfdrivr.c
diff -u /dev/null xc/extras/freetype2/src/bdf/bdfdrivr.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/bdfdrivr.c	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,545 @@
+/*  bdfdrivr.c
+
+    FreeType font driver for bdf files
+
+    Copyright (C) 2001-2002 by
+    Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include <ft2build.h>
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+
+#include "bdf.h"
+#include "bdfdrivr.h"
+
+#include "bdferror.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_bdfdriver
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Face_Done( BDF_Face  face )
+  {
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+
+    bdf_free_font( face->bdffont );
+
+    FT_FREE( face->en_table );
+
+    FT_FREE( face->charset_encoding );
+    FT_FREE( face->charset_registry );
+    FT_FREE( face->root.family_name );
+
+    FT_FREE( face->root.available_sizes );
+
+    FT_FREE( face->bdffont );
+
+    FT_TRACE4(( "BDF_Face_Done: done face\n" ));
+
+    return BDF_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  BDF_Face_Init( FT_Stream      stream,
+                 BDF_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    FT_Error       error  = BDF_Err_Ok;
+    FT_Memory      memory = FT_FACE_MEMORY( face );
+
+    bdf_font_t*    font;
+    bdf_options_t  options;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+
+
+    if ( FT_STREAM_SEEK( 0 ) )
+      goto Exit;
+
+    options.correct_metrics = 1;   /* FZ XXX: options semantics */
+    options.keep_unencoded  = 1;
+    options.keep_comments   = 0;
+    options.font_spacing    = BDF_PROPORTIONAL;
+
+    error = bdf_load_font( stream, memory, &options, &font );
+    if ( error == BDF_Err_Missing_Startfont_Field )
+    {
+      FT_TRACE2(( "[not a valid BDF file]\n" ));
+      goto Fail;
+    }
+    else if ( error )
+      goto Exit;
+
+    /* we have a bdf font: let's construct the face object */
+    face->bdffont = font;
+    {
+      FT_Face          root = FT_FACE( face );
+      bdf_property_t*  prop = NULL;
+
+
+      FT_TRACE4(( "number of glyphs: %d (%d)\n",
+                  font->glyphs_size,
+                  font->glyphs_used ));
+      FT_TRACE4(( "number of unencoded glyphs: %d (%d)\n",
+                  font->unencoded_size,
+                  font->unencoded_used ));
+
+      root->num_faces  = 1;
+      root->face_index = 0;
+      root->face_flags = FT_FACE_FLAG_FIXED_SIZES |
+                         FT_FACE_FLAG_HORIZONTAL  |
+                         FT_FACE_FLAG_FAST_GLYPHS;
+
+      prop = bdf_get_font_property( font, (char *)"SPACING" );
+      if ( prop != NULL )
+        if ( prop->format == BDF_ATOM )
+          if ( prop->value.atom != NULL )
+            if ( ( *(prop->value.atom) == 'M' ) ||
+                 ( *(prop->value.atom) == 'C' ) )
+              root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      /* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL   */
+      /* FZ XXX: I need a font to implement this */
+
+      root->style_flags = 0;
+      prop = bdf_get_font_property( font, (char *)"SLANT" );
+      if ( prop != NULL )
+        if ( prop->format == BDF_ATOM )
+          if ( prop->value.atom != NULL )
+            if ( ( *(prop->value.atom) == 'O' ) ||
+                 ( *(prop->value.atom) == 'I' ) )
+              root->style_flags |= FT_STYLE_FLAG_ITALIC;
+
+      prop = bdf_get_font_property( font, (char *)"WEIGHT_NAME" );
+      if ( prop != NULL )
+        if ( prop->format == BDF_ATOM )
+          if ( prop->value.atom != NULL )
+            if ( *(prop->value.atom) == 'B' )
+              root->style_flags |= FT_STYLE_FLAG_BOLD;
+
+      prop = bdf_get_font_property( font, (char *)"FAMILY_NAME" );
+      if ( ( prop != NULL ) && ( prop->value.atom != NULL ) )
+      {
+        int  l = ft_strlen( prop->value.atom ) + 1;
+
+
+        if ( FT_NEW_ARRAY( root->family_name, l ) )
+          goto Exit;
+        ft_strcpy( root->family_name, prop->value.atom );
+      }
+      else
+        root->family_name = 0;
+
+      root->style_name = (char *)"Regular";
+      if ( root->style_flags & FT_STYLE_FLAG_BOLD )
+      {
+        if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+          root->style_name = (char *)"Bold Italic";
+        else
+          root->style_name = (char *)"Bold";
+      }
+      else if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+        root->style_name = (char *)"Italic";
+
+      root->num_glyphs = font->glyphs_size;     /* unencoded included */
+
+      root->num_fixed_sizes = 1;
+      if ( FT_NEW_ARRAY( root->available_sizes, 1 ) )
+        goto Exit;
+
+      prop = bdf_get_font_property( font, (char *)"PIXEL_SIZE" );
+      if ( prop != NULL )
+      {
+        bdf_property_t  *xres = 0, *yres = 0;
+
+
+        xres = bdf_get_font_property( font, (char *)"RESOLUTION_X" );
+        yres = bdf_get_font_property( font, (char *)"RESOLUTION_Y" );
+        if ( ( xres != NULL ) && ( yres != NULL ) )
+        {
+          FT_TRACE4(( "PIXEL_SIZE: %d  RESOLUTION_X: %d  RESOLUTION_Y: %d\n",
+                      prop->value.int32,
+                      xres->value.int32,
+                      yres->value.int32 ));
+          root->available_sizes->width =
+            (FT_Short)( prop->value.int32 * 75 / xres->value.int32 );
+             
+          root->available_sizes->height =
+            (FT_Short)( prop->value.int32 * 75 / yres->value.int32 );
+        }
+      }
+      else
+      {
+        /* some fonts have broken SIZE declaration (jiskan24.bdf) */
+        FT_ERROR(( "BDF_Face_Init: reading size\n" ));
+        root->available_sizes->width  = (FT_Short)font->point_size ;
+        root->available_sizes->height = (FT_Short)font->point_size ;
+      }
+
+      /* encoding table */
+      {
+        bdf_glyph_t*   cur = font->glyphs;
+        unsigned long  n;
+
+
+        if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
+          goto Exit;
+
+        for ( n = 0; n < font->glyphs_size; n++ )
+        {
+          (face->en_table[n]).enc = cur[n].encoding;
+          FT_TRACE4(( "idx %d, val 0x%lX\n", n, cur[n].encoding ));
+          (face->en_table[n]).glyph = (FT_Short)n;
+        }
+      }
+
+      /* charmaps */
+      {
+        bdf_property_t  *charset_registry = 0, *charset_encoding = 0;
+
+
+        charset_registry =
+          bdf_get_font_property( font, (char *)"CHARSET_REGISTRY" );
+        charset_encoding =
+          bdf_get_font_property( font, (char *)"CHARSET_ENCODING" );
+        if ( ( charset_registry != NULL ) && ( charset_encoding != NULL ) )
+        {
+          if ( ( charset_registry->format == BDF_ATOM ) &&
+               ( charset_encoding->format == BDF_ATOM ) &&
+               ( charset_registry->value.atom != NULL ) &&
+               ( charset_encoding->value.atom != NULL ) )
+          {
+            if ( FT_NEW_ARRAY( face->charset_encoding,
+                               strlen( charset_encoding->value.atom ) + 1 ) )
+              goto Exit;
+            if (FT_NEW_ARRAY( face->charset_registry,
+                              strlen( charset_registry->value.atom ) + 1 ) )
+              goto Exit;
+            ft_strcpy( face->charset_registry, charset_registry->value.atom );
+            ft_strcpy( face->charset_encoding, charset_encoding->value.atom );
+
+            face->charmap.encoding    = ft_encoding_none;
+            face->charmap.platform_id = 0;
+            face->charmap.encoding_id = 0;
+            face->charmap.face        = root;
+            face->charmap_handle      = &face->charmap;
+
+            root->charmap = face->charmap_handle;
+
+            goto Exit;
+          }
+        }
+
+        /* otherwise assume adobe standard encoding */
+        face->charmap.encoding    = ft_encoding_adobe_standard;
+        face->charmap.platform_id = 7; /* taken from t1objs.c */
+        face->charmap.encoding_id = 0;
+        face->charmap.face        = root;
+        face->charmap_handle      = &face->charmap;
+
+        root->charmap = face->charmap_handle;
+      }
+    }
+
+  Exit:
+    return error;
+
+  Fail:
+    BDF_Face_Done( face );
+    return BDF_Err_Unknown_File_Format;
+  }
+
+
+  static
+  FT_Error  BDF_Set_Pixel_Size( FT_Size  size )
+  {
+    BDF_Face  face = (BDF_Face)FT_SIZE_FACE( size );
+    FT_Face   root = FT_FACE( face );
+
+
+    FT_TRACE4(( "rec %d - pres %d\n",
+                size->metrics.y_ppem, root->available_sizes->height ));
+
+    if ( size->metrics.y_ppem == root->available_sizes->height )
+    {
+      size->metrics.ascender  = face->bdffont->bbx.ascent << 6;
+      size->metrics.descender = face->bdffont->bbx.descent * ( -64 );
+      size->metrics.height    = face->bdffont->bbx.height << 6;
+
+      return BDF_Err_Ok;
+    }
+    else
+      return BDF_Err_Invalid_Pixel_Size;
+  }
+
+
+  static FT_Error
+  BDF_Glyph_Load( FT_GlyphSlot  slot,
+                  FT_Size       size,
+                  FT_UInt       glyph_index,
+                  FT_Int        load_flags )
+  {
+    BDF_Face        face   = (BDF_Face)FT_SIZE_FACE( size );
+    FT_Error        error  = BDF_Err_Ok;
+    FT_Bitmap*      bitmap = &slot->bitmap;
+    bdf_glyph_t     glyph;
+    int             bpp    = face->bdffont->bpp;
+    int             i, j, count;
+    unsigned char   *p, *pp;
+
+    FT_Memory       memory = face->bdffont->memory;
+
+    FT_UNUSED( load_flags );
+
+
+    if ( !face )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* slot, bitmap => freetype, glyph => bdflib */
+    glyph = face->bdffont->glyphs[glyph_index];
+
+    bitmap->rows      = glyph.bbx.height;
+    bitmap->width     = glyph.bbx.width;
+
+    if ( bpp == 1 )
+    {
+      bitmap->pixel_mode = ft_pixel_mode_mono;
+      bitmap->pitch      = glyph.bpr;
+
+      if ( FT_NEW_ARRAY( bitmap->buffer, glyph.bytes ) )
+        goto Exit;
+      FT_MEM_COPY( bitmap->buffer, glyph.bitmap, glyph.bytes );
+    }
+    else
+    {
+      /* blow up pixmap to have 8 bits per pixel */
+      bitmap->pixel_mode = ft_pixel_mode_grays;
+      bitmap->pitch      = bitmap->width;
+
+      if ( FT_NEW_ARRAY( bitmap->buffer, bitmap->rows * bitmap->pitch ) )
+        goto Exit;
+
+      switch ( bpp )
+      {
+      case 2:
+        bitmap->num_grays = 4;
+
+        count = 0;
+        p     = glyph.bitmap;
+
+        for ( i = 0; i < bitmap->rows; i++ )
+        {
+          pp = p;
+
+          /* get the full bytes */
+          for ( j = 0; j < ( bitmap->width >> 2 ); j++ )
+          {
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xC0 ) >> 6 );
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x30 ) >> 4 );
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x0C ) >> 2 );
+            bitmap->buffer[count++] = (FT_Byte)(   *pp & 0x03 );
+
+            pp++;
+          }
+
+          /* get remaining pixels (if any) */
+          switch ( bitmap->width & 3 )
+          {
+          case 3:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xC0 ) >> 6 );
+            /* fall through */
+          case 2:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x30 ) >> 4 );
+            /* fall through */
+          case 1:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x0C ) >> 2 );
+            /* fall through */
+          case 0:
+            break;
+          }
+
+          p += glyph.bpr;
+        }
+        break;
+
+      case 4:
+        bitmap->num_grays = 16;
+
+        count = 0;
+        p     = glyph.bitmap;
+
+        for ( i = 0; i < bitmap->rows; i++ )
+        {
+          pp = p;
+
+          /* get the full bytes */
+          for ( j = 0; j < ( bitmap->width >> 1 ); j++ )
+          {
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xF0 ) >> 4 );
+            bitmap->buffer[count++] = (FT_Byte)(   *pp & 0x0F );
+
+            pp++;
+          }
+
+          /* get remaining pixel (if any) */
+          switch ( bitmap->width & 1 )
+          {
+          case 1:
+            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xF0 ) >> 4 );
+            /* fall through */
+          case 0:
+            break;
+          }
+
+          p += glyph.bpr;
+        }
+        break;
+
+      case 8:
+        bitmap->num_grays = 256;
+
+        FT_MEM_COPY( bitmap->buffer, glyph.bitmap,
+                     bitmap->rows * bitmap->pitch );
+        break;
+      }
+    }
+
+    slot->bitmap_left = 0;
+    slot->bitmap_top  = glyph.bbx.ascent;
+
+    /* FZ XXX: TODO: vertical metrics */
+    slot->metrics.horiAdvance  = glyph.dwidth << 6;
+    slot->metrics.horiBearingX = glyph.bbx.x_offset << 6;
+    slot->metrics.horiBearingY = glyph.bbx.y_offset << 6;
+    slot->metrics.width        = bitmap->width << 6;
+    slot->metrics.height       = bitmap->rows << 6;
+
+    slot->linearHoriAdvance = (FT_Fixed)glyph.dwidth << 16;
+    slot->format            = ft_glyph_format_bitmap;
+    slot->flags             = FT_GLYPH_OWN_BITMAP;
+
+  Exit:
+    return error;
+  }
+
+
+  static
+  FT_UInt  BDF_Get_Char_Index( FT_CharMap  charmap,
+                               FT_ULong    char_code )
+  {
+    BDF_Face          face     = (BDF_Face)charmap->face;
+    BDF_encoding_el*  en_table = face->en_table;
+    int               low, high, mid;
+
+
+    FT_TRACE4(( "BDF_Get_Char_Index %ld\n", char_code ));
+
+    low  = 0;
+    high = face->bdffont->glyphs_used - 1;
+
+    while ( low <= high )
+    {
+      mid = ( low + high ) / 2;
+      if ( char_code < en_table[mid].enc )
+        high = mid - 1;
+      else if ( char_code > en_table[mid].enc )
+        low = mid + 1;
+      else
+        return en_table[mid].glyph;
+    }
+
+    return face->bdffont->default_glyph;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  bdf_driver_class =
+  {
+    {
+      ft_module_font_driver,
+      sizeof ( FT_DriverRec ),
+
+      "bdf",
+      0x10000L,
+      0x20000L,
+
+      0,
+
+      (FT_Module_Constructor)0,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    sizeof( BDF_FaceRec ),
+    sizeof( FT_SizeRec ),
+    sizeof( FT_GlyphSlotRec ),
+
+    (FT_Face_InitFunc)        BDF_Face_Init,
+    (FT_Face_DoneFunc)        BDF_Face_Done,
+    (FT_Size_InitFunc)        0,
+    (FT_Size_DoneFunc)        0,
+    (FT_Slot_InitFunc)        0,
+    (FT_Slot_DoneFunc)        0,
+
+    (FT_Size_ResetPointsFunc) BDF_Set_Pixel_Size,
+    (FT_Size_ResetPixelsFunc) BDF_Set_Pixel_Size,
+
+    (FT_Slot_LoadFunc)        BDF_Glyph_Load,
+
+#ifndef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharIndexFunc)0,
+#else
+    (FT_CharMap_CharIndexFunc)BDF_Get_Char_Index,
+#endif
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0,
+
+#ifndef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharNextFunc) 0, /* BDF_Char_Get_Next,*/
+#else
+    (FT_CharMap_CharNextFunc) 0
+#endif
+  };
+
+
+/* END */
Index: xc/extras/freetype2/src/bdf/bdfdrivr.h
diff -u /dev/null xc/extras/freetype2/src/bdf/bdfdrivr.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/bdfdrivr.h	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,74 @@
+/*  bdfdrivr.h
+
+    FreeType font driver for bdf fonts
+
+  Copyright (C) 2001, 2002 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __BDFDRIVR_H__
+#define __BDFDRIVR_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+#include "bdf.h"
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  BDF_encoding_el_
+  {
+    FT_ULong  enc;
+    FT_Short  glyph;
+
+  } BDF_encoding_el;
+
+
+  typedef struct  BDF_FaceRec_
+  {
+    FT_FaceRec        root;
+
+    char*             charset_encoding;
+    char*             charset_registry;
+
+    bdf_font_t*       bdffont;
+
+    BDF_encoding_el*  en_table;
+
+    FT_CharMap        charmap_handle;
+    FT_CharMapRec     charmap;  /* a single charmap per face */
+
+  } BDF_FaceRec, *BDF_Face;
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  bdf_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __BDFDRIVR_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/bdf/bdferror.h
diff -u /dev/null xc/extras/freetype2/src/bdf/bdferror.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/bdferror.h	Thu Jun 20 04:16:14 2002
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2001, 2002 Francesco Zappa Nardelli
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY 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.
+ */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to define the BDF error enumeration constants.      */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __BDFERROR_H__
+#define __BDFERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  BDF_Err_
+#define FT_ERR_BASE    FT_Mod_Err_BDF
+
+#include FT_ERRORS_H
+
+#endif /* __BDFERROR_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/bdf/bdflib.c
diff -u /dev/null xc/extras/freetype2/src/bdf/bdflib.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/bdflib.c	Thu Jun 20 04:16:15 2002
@@ -0,0 +1,2429 @@
+/*
+ * Copyright 2000 Computing Research Labs, New Mexico State University
+ * Copyright 2001, 2002 Francesco Zappa Nardelli
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY 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.
+ */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  This file is based on bdf.c,v 1.22 2000/03/16 20:08:50               */
+  /*                                                                       */
+  /*  taken from Mark Leisher's xmbdfed package                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+
+#include FT_FREETYPE_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+
+#include "bdf.h"
+#include "bdferror.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_bdflib
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Default BDF font options.                                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  static const bdf_options_t  _bdf_opts =
+  {
+    1,                /* Correct metrics.               */
+    1,                /* Preserve unencoded glyphs.     */
+    0,                /* Preserve comments.             */
+    BDF_PROPORTIONAL  /* Default spacing.               */
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Builtin BDF font properties.                                          */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* List of most properties that might appear in a font.  Doesn't include */
+  /* the RAW_* and AXIS_* properties in X11R6 polymorphic fonts.           */
+
+  static const bdf_property_t  _bdf_properties[] =
+  {
+    { (char *)"ADD_STYLE_NAME",          BDF_ATOM,     1, { 0 } },
+    { (char *)"AVERAGE_WIDTH",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"AVG_CAPITAL_WIDTH",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"AVG_LOWERCASE_WIDTH",     BDF_INTEGER,  1, { 0 } },
+    { (char *)"CAP_HEIGHT",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"CHARSET_COLLECTIONS",     BDF_ATOM,     1, { 0 } },
+    { (char *)"CHARSET_ENCODING",        BDF_ATOM,     1, { 0 } },
+    { (char *)"CHARSET_REGISTRY",        BDF_ATOM,     1, { 0 } },
+    { (char *)"COMMENT",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"COPYRIGHT",               BDF_ATOM,     1, { 0 } },
+    { (char *)"DEFAULT_CHAR",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"DESTINATION",             BDF_CARDINAL, 1, { 0 } },
+    { (char *)"DEVICE_FONT_NAME",        BDF_ATOM,     1, { 0 } },
+    { (char *)"END_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"FACE_NAME",               BDF_ATOM,     1, { 0 } },
+    { (char *)"FAMILY_NAME",             BDF_ATOM,     1, { 0 } },
+    { (char *)"FIGURE_WIDTH",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"FONT",                    BDF_ATOM,     1, { 0 } },
+    { (char *)"FONTNAME_REGISTRY",       BDF_ATOM,     1, { 0 } },
+    { (char *)"FONT_ASCENT",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"FONT_DESCENT",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"FOUNDRY",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"FULL_NAME",               BDF_ATOM,     1, { 0 } },
+    { (char *)"ITALIC_ANGLE",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"MAX_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"MIN_SPACE",               BDF_INTEGER,  1, { 0 } },
+    { (char *)"NORM_SPACE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"NOTICE",                  BDF_ATOM,     1, { 0 } },
+    { (char *)"PIXEL_SIZE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"POINT_SIZE",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"QUAD_WIDTH",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_ASCENT",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVERAGE_WIDTH",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVG_CAPITAL_WIDTH",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_AVG_LOWERCASE_WIDTH", BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_CAP_HEIGHT",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_DESCENT",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_END_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_FIGURE_WIDTH",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_MAX_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_MIN_SPACE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_NORM_SPACE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_PIXEL_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_POINT_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_PIXELSIZE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_POINTSIZE",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_QUAD_WIDTH",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SMALL_CAP_SIZE",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_STRIKEOUT_ASCENT",    BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_STRIKEOUT_DESCENT",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_SIZE",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_X",         BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUBSCRIPT_Y",         BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_SIZE",    BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_X",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_SUPERSCRIPT_Y",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_UNDERLINE_POSITION",  BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_UNDERLINE_THICKNESS", BDF_INTEGER,  1, { 0 } },
+    { (char *)"RAW_X_HEIGHT",            BDF_INTEGER,  1, { 0 } },
+    { (char *)"RELATIVE_SETWIDTH",       BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RELATIVE_WEIGHT",         BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RESOLUTION",              BDF_INTEGER,  1, { 0 } },
+    { (char *)"RESOLUTION_X",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"RESOLUTION_Y",            BDF_CARDINAL, 1, { 0 } },
+    { (char *)"SETWIDTH_NAME",           BDF_ATOM,     1, { 0 } },
+    { (char *)"SLANT",                   BDF_ATOM,     1, { 0 } },
+    { (char *)"SMALL_CAP_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"SPACING",                 BDF_ATOM,     1, { 0 } },
+    { (char *)"STRIKEOUT_ASCENT",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"STRIKEOUT_DESCENT",       BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_SIZE",          BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_X",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUBSCRIPT_Y",             BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_SIZE",        BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_X",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"SUPERSCRIPT_Y",           BDF_INTEGER,  1, { 0 } },
+    { (char *)"UNDERLINE_POSITION",      BDF_INTEGER,  1, { 0 } },
+    { (char *)"UNDERLINE_THICKNESS",     BDF_INTEGER,  1, { 0 } },
+    { (char *)"WEIGHT",                  BDF_CARDINAL, 1, { 0 } },
+    { (char *)"WEIGHT_NAME",             BDF_ATOM,     1, { 0 } },
+    { (char *)"X_HEIGHT",                BDF_INTEGER,  1, { 0 } },
+    { (char *)"_MULE_BASELINE_OFFSET",   BDF_INTEGER,  1, { 0 } },
+    { (char *)"_MULE_RELATIVE_COMPOSE",  BDF_INTEGER,  1, { 0 } },
+  };
+
+  static unsigned long
+  _num_bdf_properties = sizeof ( _bdf_properties ) /
+                        sizeof ( _bdf_properties[0] );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Hash table utilities for the properties.                              */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* XXX: Replace this with FreeType's hash functions */
+
+
+#define INITIAL_HT_SIZE  241
+
+  typedef void
+  (*hash_free_func)( hashnode  node );
+
+  static hashnode*
+  hash_bucket( char*       key,
+               hashtable*  ht )
+  {
+    char*          kp  = key;
+    unsigned long  res = 0;
+    hashnode*      bp  = ht->table, *ndp;
+
+
+    /* Mocklisp hash function. */
+    while ( *kp )
+      res = ( res << 5 ) - res + *kp++;
+
+    ndp = bp + ( res % ht->size );
+    while ( *ndp )
+    {
+      kp = (*ndp)->key;
+      if ( kp[0] == key[0] && ft_strcmp( kp, key ) == 0 )
+        break;
+      ndp--;
+      if ( ndp < bp )
+        ndp = bp + ( ht->size - 1 );
+    }
+
+    return ndp;
+  }
+
+
+  static FT_Error
+  hash_rehash( hashtable*  ht,
+               FT_Memory   memory )
+  {
+    hashnode*  obp = ht->table, *bp, *nbp;
+    int        i, sz = ht->size;
+    FT_Error   error = BDF_Err_Ok;
+
+
+    ht->size <<= 1;
+    ht->limit  = ht->size / 3;
+
+    if ( FT_NEW_ARRAY( ht->table, ht->size ) )
+      goto Exit;
+    FT_MEM_SET( ht->table, 0, sizeof ( hashnode ) * ht->size );
+
+    for ( i = 0, bp = obp; i < sz; i++, bp++ )
+    {
+      if ( *bp )
+      {
+        nbp = hash_bucket( (*bp)->key, ht );
+        *nbp = *bp;
+      }
+    }
+    FT_FREE( obp );
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  hash_init( hashtable*  ht,
+             FT_Memory   memory )
+  {
+    int       sz = INITIAL_HT_SIZE;
+    FT_Error  error = BDF_Err_Ok;
+
+
+    ht->size  = sz;
+    ht->limit = sz / 3;
+    ht->used  = 0;
+
+    if ( FT_NEW_ARRAY( ht->table, sz ) )
+      goto Exit;
+    FT_MEM_SET( ht->table, 0, sizeof ( hashnode ) * sz );
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  hash_free( hashtable*  ht,
+             FT_Memory   memory )
+  {
+    if ( ht != 0 )
+    {
+      int        i, sz = ht->size;
+      hashnode*  bp = ht->table;
+
+
+      for ( i = 0; i < sz; i++, bp++ )
+        FT_FREE( *bp );
+
+      FT_FREE( ht->table );
+    }
+  }
+
+
+  static FT_Error
+  hash_insert( char*       key,
+               void*       data,
+               hashtable*  ht,
+               FT_Memory   memory )
+  {
+    hashnode  nn, *bp = hash_bucket( key, ht );
+    FT_Error  error = BDF_Err_Ok;
+
+
+    nn = *bp;
+    if ( !nn )
+    {
+      if ( FT_NEW( nn ) )
+        goto Exit;
+      *bp = nn;
+
+      nn->key  = key;
+      nn->data = data;
+
+      if ( ht->used >= ht->limit )
+      {
+        error = hash_rehash( ht, memory );
+        if ( error )
+          goto Exit;
+      }
+      ht->used++;
+    }
+    else
+      nn->data = data;
+
+  Exit:
+    return error;
+  }
+
+
+  static hashnode
+  hash_lookup( char*       key,
+               hashtable*  ht )
+  {
+    hashnode *np = hash_bucket( key, ht );
+
+
+    return *np;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Utility types and functions.                                          */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Function type for parsing lines of a BDF font. */
+
+  typedef FT_Error
+  (*_bdf_line_func_t)( char*          line,
+                       unsigned long  linelen,
+                       unsigned long  lineno,
+                       void*          call_data,
+                       void*          client_data );
+
+
+  /* List structure for splitting lines into fields. */
+
+  typedef struct  _bdf_list_t_
+  {
+    char**         field;
+    unsigned long  size;
+    unsigned long  used;
+
+  } _bdf_list_t;
+
+
+  /* Structure used while loading BDF fonts. */
+
+  typedef struct  _bdf_parse_t_
+  {
+    unsigned long   flags;
+    unsigned long   cnt;
+    unsigned long   row;
+
+    short           minlb;
+    short           maxlb;
+    short           maxrb;
+    short           maxas;
+    short           maxds;
+
+    short           rbearing;
+
+    char*           glyph_name;
+    long            glyph_enc;
+
+    bdf_font_t*     font;
+    bdf_options_t*  opts;
+
+    unsigned long   have[2048];
+    _bdf_list_t     list;
+
+    FT_Memory       memory;
+
+  } _bdf_parse_t;
+
+
+#define setsbit( m, cc )  ( m[(cc) >> 3] |= (FT_Byte)( 1 << ( (cc) & 7 ) ) )
+#define sbitset( m, cc )  ( m[(cc) >> 3]  & ( 1 << ( (cc) & 7 ) ) )
+
+
+  /* An empty string for empty fields. */
+
+  static char  empty[1] = { 0 };   /* XXX eliminate this */
+
+
+  /* Assume the line is NULL-terminated and that the `list' parameter */
+  /* was initialized the first time it was used.                      */
+
+  static FT_Error
+  _bdf_split( char*          separators,
+              char*          line,
+              unsigned long  linelen,
+              _bdf_list_t*   list,
+              FT_Memory      memory )
+  {
+    int       mult, final_empty;
+    char      *sp, *ep, *end;
+    char      seps[32];
+    FT_Error  error = BDF_Err_Ok;
+
+
+    /* Initialize the list. */
+    list->used = 0;
+
+    /* If the line is empty, then simply return. */
+    if ( linelen == 0 || line[0] == 0 )
+      goto Exit;
+
+    /* In the original code, if the `separators' parameter is NULL or */
+    /* empty, the list is split into individual bytes.  We don't need */
+    /* this, so an error is signaled.                                 */
+    if ( separators == 0 || *separators == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* Prepare the separator bitmap. */
+    FT_MEM_SET( seps, 0, 32 );
+
+    /* If the very last character of the separator string is a plus, then */
+    /* set the `mult' flag to indicate that multiple separators should be */
+    /* collapsed into one.                                                */
+    for ( mult = 0, sp = separators; sp && *sp; sp++ )
+    {
+      if ( *sp == '+' && *( sp + 1 ) == 0 )
+        mult = 1;
+      else
+        setsbit( seps, *sp );
+    }
+
+    /* Break the line up into fields. */
+    for ( final_empty = 0, sp = ep = line, end = sp + linelen;
+          sp < end && *sp; )
+    {
+      /* Collect everything that is not a separator. */
+      for ( ; *ep && !sbitset( seps, *ep ); ep++ )
+        ;
+
+      /* Resize the list if necessary. */
+      if ( list->used == list->size )
+      {
+        if ( list->size == 0 )
+        {
+          if ( FT_NEW_ARRAY( list->field, 5 ) )
+            goto Exit;
+        }
+        else
+        {
+          if ( FT_RENEW_ARRAY ( list->field ,
+                                list->size,
+                                list->size + 5 ) )
+            goto Exit;
+        }
+
+        list->size += 5;
+      }
+
+      /* Assign the field appropriately. */
+      list->field[list->used++] = ( ep > sp ) ? sp : empty;
+
+      sp = ep;
+
+      if ( mult )
+      {
+        /* If multiple separators should be collapsed, do it now by */
+        /* setting all the separator characters to 0.               */
+        for ( ; *ep && sbitset( seps, *ep ); ep++ )
+          *ep = 0;
+      }
+      else if ( *ep != 0 )
+        /* Don't collapse multiple separators by making them 0, so just */
+        /* make the one encountered 0.                                  */
+        *ep++ = 0;
+
+      final_empty = ( ep > sp && *ep == 0 );
+      sp = ep;
+    }
+
+    /* Finally, NULL-terminate the list. */
+    if ( list->used + final_empty + 1 >= list->size )
+    {
+      if ( list->used == list->size )
+      {
+        if ( list->size == 0 )
+        {
+          if ( FT_NEW_ARRAY( list->field, 5 ) )
+            goto Exit;
+        }
+        else
+        {
+          if ( FT_RENEW_ARRAY( list->field,
+                               list->size,
+                               list->size + 5 ) )
+            goto Exit;
+        }
+
+        list->size += 5;
+      }
+    }
+
+    if ( final_empty )
+      list->field[list->used++] = empty;
+
+    if ( list->used == list->size )
+    {
+      if ( list->size == 0 )
+      {
+        if ( FT_NEW_ARRAY( list->field, 5 ) )
+          goto Exit;
+      }
+      else
+      {
+        if ( FT_RENEW_ARRAY( list->field,
+                             list->size,
+                             list->size + 5 ) )
+          goto Exit;
+      }
+
+      list->size += 5;
+    }
+
+    list->field[list->used] = 0;
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  _bdf_shift( unsigned long  n,
+              _bdf_list_t*   list )
+  {
+    unsigned long  i, u;
+
+
+    if ( list == 0 || list->used == 0 || n == 0 )
+      return;
+
+    if ( n >= list->used )
+    {
+      list->used = 0;
+      return;
+    }
+
+    for ( u = n, i = 0; u < list->used; i++, u++ )
+      list->field[i] = list->field[u];
+    list->used -= n;
+  }
+
+
+  static char *
+  _bdf_join( int             c,
+             unsigned long*  len,
+             _bdf_list_t*    list )
+  {
+    unsigned long  i, j;
+    char           *fp, *dp;
+
+
+    if ( list == 0 || list->used == 0 )
+      return 0;
+
+    *len = 0;
+
+    dp = list->field[0];
+    for ( i = j = 0; i < list->used; i++ )
+    {
+      fp = list->field[i];
+      while ( *fp )
+        dp[j++] = *fp++;
+
+      if ( i + 1 < list->used )
+        dp[j++] = (char)c;
+    }
+    dp[j] = 0;
+
+    *len = j;
+    return dp;
+  }
+
+
+  /* High speed file reader that passes each line to a callback. */
+  static FT_Error
+  bdf_internal_readstream( FT_Stream  stream,
+                           char*      buffer,
+                           int        count,
+                           int       *read_bytes )
+  {
+    int            rbytes;
+    unsigned long  pos   = stream->pos;
+    FT_Error       error = BDF_Err_Ok;
+
+
+    if ( pos > stream->size )
+    {
+      FT_ERROR(( "bdf_internal_readstream:" ));
+      FT_ERROR(( " invalid i/o; pos = 0x%lx, size = 0x%lx\n",
+                 pos, stream->size ));
+      error = BDF_Err_Invalid_Stream_Operation;
+      goto Exit;
+    }
+
+    if ( stream->read )
+      rbytes = stream->read( stream, pos,
+                             (unsigned char *)buffer, count );
+    else
+    {
+      rbytes = stream->size - pos;
+      if ( rbytes > count )
+        rbytes = count;
+
+      FT_MEM_COPY( buffer, stream->base + pos, rbytes );
+    }
+
+    stream->pos = pos + rbytes;
+
+    *read_bytes = rbytes;
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  _bdf_readstream( FT_Stream         stream,
+                   _bdf_line_func_t  callback,
+                   void*             client_data,
+                   unsigned long    *lno )
+  {
+    _bdf_line_func_t  cb;
+    unsigned long     lineno;
+    int               n, res, done, refill, bytes, hold;
+    char              *ls, *le, *pp, *pe, *hp;
+    char              *buf = 0;
+    FT_Memory         memory = stream->memory;
+    FT_Error          error = BDF_Err_Ok;
+
+
+    if ( callback == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( FT_NEW_ARRAY( buf, 65536L ) )
+      goto Exit;
+
+    cb     = callback;
+    lineno = 1;
+    buf[0] = 0;
+
+    res = done = 0;
+    pp = ls = le = buf;
+
+    bytes = 65536L;
+
+    while ( !done )
+    {
+      error = bdf_internal_readstream( stream, pp, bytes, &n );
+      if ( error )
+        goto Exit;
+
+      if ( n == 0 )
+        break;
+
+      /* Determine the new end of the buffer pages. */
+      pe = pp + n;
+
+      for ( refill = 0; done == 0 && refill == 0; )
+      {
+        while ( le < pe && *le != '\n' && *le != '\r' )
+          le++;
+
+        if ( le == pe )
+        {
+          /* Hit the end of the last page in the buffer.  Need to find */
+          /* out how many pages to shift and how many pages need to be */
+          /* read in.  Adjust the line start and end pointers down to  */
+          /* point to the right places in the pages.                   */
+
+          pp  = buf + ( ( ( ls - buf ) >> 13 ) << 13 );
+          n   = pp - buf;
+          ls -= n;
+          le -= n;
+          n   = pe - pp;
+
+          FT_MEM_COPY( buf, pp, n );
+
+          pp     = buf + n;
+          bytes  = 65536L - n;
+          refill = 1;
+        }
+        else
+        {
+          /* Temporarily NULL-terminate the line. */
+          hp   = le;
+          hold = *le;
+          *le  = 0;
+
+          /* XXX: Use encoding independent value for 0x1a */
+          if ( *ls != '#' && *ls != 0x1a                          &&
+               le > ls                                            &&
+               ( error = (*cb)( ls, le - ls, lineno, (void *)&cb,
+                                client_data ) ) != BDF_Err_Ok     )
+            done = 1;
+          else
+          {
+            ls = ++le;
+            /* Handle the case of DOS crlf sequences. */
+            if ( le < pe && hold == '\n' && *le =='\r' )
+              ls = ++le;
+          }
+
+          /* Increment the line number. */
+          lineno++;
+
+          /* Restore the character at the end of the line. */
+          *hp = (char)hold;
+        }
+      }
+    }
+
+    *lno             = lineno;
+
+  Exit:
+    FT_FREE( buf );
+    return error;
+  }
+
+
+  /* XXX: make this work with EBCDIC also */
+
+  static const unsigned char  a2i[128] =
+  {
+    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, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 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, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 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
+  };
+
+  static const unsigned char  odigits[32] =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0x00,
+  };
+
+  static const unsigned char  ddigits[32] =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  };
+
+  static const unsigned char  hdigits[32] =
+  {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
+    0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  };
+
+
+#define isdigok( m, d )  (m[(d) >> 3] & ( 1 << ( (d) & 7 ) ) )
+
+
+  /* Routine to convert an ASCII string into an unsigned long integer. */
+  static unsigned long
+  _bdf_atoul( char*   s,
+              char**  end,
+              int     base )
+  {
+    unsigned long         v;
+    const unsigned char*  dmap;
+
+
+    if ( s == 0 || *s == 0 )
+      return 0;
+
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
+
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
+    }
+
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = v * base + a2i[(int)*s];
+
+    if ( end != 0 )
+      *end = s;
+
+    return v;
+  }
+
+
+  /* Routine to convert an ASCII string into an signed long integer. */
+  static long
+  _bdf_atol( char*   s,
+             char**  end,
+             int     base )
+  {
+    long                  v, neg;
+    const unsigned char*  dmap;
+
+
+    if ( s == 0 || *s == 0 )
+      return 0;
+
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
+
+    /* Check for a minus sign. */
+    neg = 0;
+    if ( *s == '-' )
+    {
+      s++;
+      neg = 1;
+    }
+
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
+    }
+
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = v * base + a2i[(int)*s];
+
+    if ( end != 0 )
+      *end = s;
+
+    return ( !neg ) ? v : -v;
+  }
+
+
+  /* Routine to convert an ASCII string into an signed short integer. */
+  static short
+  _bdf_atos( char*   s,
+             char**  end,
+             int     base )
+  {
+    short                 v, neg;
+    const unsigned char*  dmap;
+
+
+    if ( s == 0 || *s == 0 )
+      return 0;
+
+    /* Make sure the radix is something recognizable.  Default to 10. */
+    switch ( base )
+    {
+    case 8:
+      dmap = odigits;
+      break;
+    case 16:
+      dmap = hdigits;
+      break;
+    default:
+      base = 10;
+      dmap = ddigits;
+      break;
+    }
+
+    /* Check for a minus. */
+    neg = 0;
+    if ( *s == '-' )
+    {
+      s++;
+      neg = 1;
+    }
+
+    /* Check for the special hex prefix. */
+    if ( *s == '0'                                  &&
+         ( *( s + 1 ) == 'x' || *( s + 1 ) == 'X' ) )
+    {
+      base = 16;
+      dmap = hdigits;
+      s   += 2;
+    }
+
+    for ( v = 0; isdigok( dmap, *s ); s++ )
+      v = (short)( v * base + a2i[(int)*s] );
+
+    if ( end != 0 )
+      *end = s;
+
+    return (short)( ( !neg ) ? v : -v );
+  }
+
+
+  /* Routine to compare two glyphs by encoding so they can be sorted. */
+  static int
+  by_encoding( const void*  a,
+               const void*  b )
+  {
+    bdf_glyph_t  *c1, *c2;
+
+
+    c1 = (bdf_glyph_t *)a;
+    c2 = (bdf_glyph_t *)b;
+
+    if ( c1->encoding < c2->encoding )
+      return -1;
+    else if ( c1->encoding > c2->encoding )
+      return 1;
+
+    return 0;
+  }
+
+
+  static FT_Error
+  bdf_create_property( char*        name,
+                       int          format,
+                       bdf_font_t*  font )
+  {
+    unsigned long    n;
+    bdf_property_t*  p;
+    FT_Memory        memory = font->memory;
+    FT_Error         error = BDF_Err_Ok;
+
+
+    /* First check to see if the property has      */
+    /* already been added or not.  If it has, then */
+    /* simply ignore it.                           */
+    if ( hash_lookup( name, &(font->proptbl) ) )
+      goto Exit;
+
+    if ( font->nuser_props == 0 )
+    {
+      if ( FT_NEW_ARRAY( font->user_props, 1 ) )
+        goto Exit;
+    }
+    else
+    {
+      if ( FT_RENEW_ARRAY( font->user_props,
+                           font->nuser_props,
+                           font->nuser_props + 1 ) )
+        goto Exit;
+    }
+
+    p = font->user_props + font->nuser_props;
+    FT_MEM_SET( p, 0, sizeof ( bdf_property_t ) );
+
+    n = (unsigned long)( ft_strlen( name ) + 1 );
+    if ( FT_NEW_ARRAY( p->name, n ) )
+      goto Exit;
+
+    FT_MEM_COPY( (char *)p->name, name, n );
+
+    p->format  = format;
+    p->builtin = 0;
+
+    n = _num_bdf_properties + font->nuser_props;
+
+    error = hash_insert( p->name, (void *)n, &(font->proptbl), memory );
+    if ( error )
+      goto Exit;
+
+    font->nuser_props++;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( bdf_property_t * )
+  bdf_get_property( char*        name,
+                    bdf_font_t*  font )
+  {
+    hashnode       hn;
+    unsigned long  propid;
+
+
+    if ( name == 0 || *name == 0 )
+      return 0;
+
+    if ( ( hn = hash_lookup( name, &(font->proptbl) ) ) == 0 )
+      return 0;
+
+    propid = (unsigned long)hn->data;
+    if ( propid >= _num_bdf_properties )
+      return font->user_props + ( propid - _num_bdf_properties );
+
+    return (bdf_property_t*)_bdf_properties + propid;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* BDF font file parsing flags and functions.                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Parse flags. */
+
+#define _BDF_START      0x0001
+#define _BDF_FONT_NAME  0x0002
+#define _BDF_SIZE       0x0004
+#define _BDF_FONT_BBX   0x0008
+#define _BDF_PROPS      0x0010
+#define _BDF_GLYPHS     0x0020
+#define _BDF_GLYPH      0x0040
+#define _BDF_ENCODING   0x0080
+#define _BDF_SWIDTH     0x0100
+#define _BDF_DWIDTH     0x0200
+#define _BDF_BBX        0x0400
+#define _BDF_BITMAP     0x0800
+
+#define _BDF_SWIDTH_ADJ  0x1000
+
+#define _BDF_GLYPH_BITS ( _BDF_GLYPH    | \
+                          _BDF_ENCODING | \
+                          _BDF_SWIDTH   | \
+                          _BDF_DWIDTH   | \
+                          _BDF_BBX      | \
+                          _BDF_BITMAP   )
+
+#define _BDF_GLYPH_WIDTH_CHECK   0x40000000L
+#define _BDF_GLYPH_HEIGHT_CHECK  0x80000000L
+
+
+  /* Auto correction messages. */
+#define ACMSG1   "FONT_ASCENT property missing.  " \
+                 "Added \"FONT_ASCENT %hd\".\n"
+#define ACMSG2   "FONT_DESCENT property missing.  " \
+                 "Added \"FONT_DESCENT %hd\".\n"
+#define ACMSG3   "Font width != actual width.  Old: %hd New: %hd.\n"
+#define ACMSG4   "Font left bearing != actual left bearing.  " \
+                 "Old: %hd New: %hd.\n"
+#define ACMSG5   "Font ascent != actual ascent.  Old: %hd New: %hd.\n"
+#define ACMSG6   "Font descent != actual descent.  Old: %hd New: %hd.\n"
+#define ACMSG7   "Font height != actual height. Old: %hd New: %hd.\n"
+#define ACMSG8   "Glyph scalable width (SWIDTH) adjustments made.\n"
+#define ACMSG9   "SWIDTH field missing at line %ld.  Set automatically.\n"
+#define ACMSG10  "DWIDTH field missing at line %ld.  Set to glyph width.\n"
+#define ACMSG11  "SIZE bits per pixel field adjusted to %hd.\n"
+#define ACMSG12  "Duplicate encoding %ld (%s) changed to unencoded.\n"
+#define ACMSG13  "Glyph %ld extra rows removed.\n"
+#define ACMSG14  "Glyph %ld extra columns removed.\n"
+#define ACMSG15  "Incorrect glyph count: %ld indicated but %ld found.\n"
+
+  /* Error messages. */
+#define ERRMSG1  "[line %ld] Missing \"%s\" line.\n"
+#define ERRMSG2  "[line %ld] Font header corrupted or missing fields.\n"
+#define ERRMSG3  "[line %ld] Font glyphs corrupted or missing fields.\n"
+
+
+  static FT_Error
+  _bdf_add_comment( bdf_font_t*    font,
+                    char*          comment,
+                    unsigned long  len )
+  {
+    char*      cp;
+    FT_Memory  memory = font->memory;
+    FT_Error   error = BDF_Err_Ok;
+
+
+    if ( font->comments_len == 0 )
+    {
+      if ( FT_NEW_ARRAY( font->comments, len + 1 ) )
+        goto Exit;
+    }
+    else
+    {
+      if ( FT_RENEW_ARRAY( font->comments,
+                           font->comments_len,
+                           font->comments_len + len + 1 ) )
+        goto Exit;
+    }
+
+    cp = font->comments + font->comments_len;
+    FT_MEM_COPY( cp, comment, len );
+    cp   += len;
+    *cp++ = '\n';
+    font->comments_len += len + 1;
+
+  Exit:
+    return error;
+  }
+
+
+  /* Set the spacing from the font name if it exists, or set it to the */
+  /* default specified in the options.                                 */
+  static FT_Error
+  _bdf_set_default_spacing( bdf_font_t*     font,
+                            bdf_options_t*  opts )
+  {
+    unsigned long  len;
+    char           name[128];
+    _bdf_list_t    list;
+    FT_Memory      memory;
+    FT_Error       error = BDF_Err_Ok;
+
+
+    if ( font == 0 || font->name == 0 || font->name[0] == 0 )
+    {
+      error = BDF_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    memory = font->memory;
+
+    font->spacing = opts->font_spacing;
+
+    len = (unsigned long)( ft_strlen( font->name ) + 1 );
+    FT_MEM_COPY( name, font->name, len );
+
+    list.size = list.used = 0;
+
+    error = _bdf_split( (char *)"-", name, len, &list, memory );
+    if ( error )
+      goto Exit;
+
+    if ( list.used == 15 )
+    {
+      switch ( list.field[11][0] )
+      {
+      case 'C':
+      case 'c':
+        font->spacing = BDF_CHARCELL;
+        break;
+      case 'M':
+      case 'm':
+        font->spacing = BDF_MONOWIDTH;
+        break;
+      case 'P':
+      case 'p':
+        font->spacing = BDF_PROPORTIONAL;
+        break;
+      }
+    }
+
+    FT_FREE( list.field );
+
+  Exit:
+    return error;
+  }
+
+
+  /* Determine whether the property is an atom or not.  If it is, then */
+  /* clean it up so the double quotes are removed if they exist.       */
+  static int
+  _bdf_is_atom( char*          line,
+                unsigned long  linelen,
+                char**         name,
+                char**         value,
+                bdf_font_t*    font )
+  {
+    int              hold;
+    char             *sp, *ep;
+    bdf_property_t*  p;
+
+
+    *name = sp = ep = line;
+
+    while ( *ep && *ep != ' ' && *ep != '\t' )
+      ep++;
+
+    hold = -1;
+    if ( *ep )
+    {
+      hold = *ep;
+      *ep  = 0;
+    }
+
+    p = bdf_get_property( sp, font );
+
+    /* Restore the character that was saved before any return can happen. */
+    if ( hold != -1 )
+      *ep = (char)hold;
+
+    /* If the property exists and is not an atom, just return here. */
+    if ( p && p->format != BDF_ATOM )
+      return 0;
+
+    /* The property is an atom.  Trim all leading and trailing whitespace */
+    /* and double quotes for the atom value.                              */
+    sp = ep;
+    ep = line + linelen;
+
+    /* Trim the leading whitespace if it exists. */
+    *sp++ = 0;
+    while ( *sp                           &&
+            ( *sp == ' ' || *sp == '\t' ) )
+      sp++;
+
+    /* Trim the leading double quote if it exists. */
+    if ( *sp == '"' )
+      sp++;
+    *value = sp;
+
+    /* Trim the trailing whitespace if it exists. */
+    while ( ep > sp                                       &&
+            ( *( ep - 1 ) == ' ' || *( ep - 1 ) == '\t' ) )
+      *--ep = 0;
+
+    /* Trim the trailing double quote if it exists. */
+    if ( ep > sp && *( ep - 1 ) == '"' )
+      *--ep = 0;
+
+    return 1;
+  }
+
+
+  static FT_Error
+  _bdf_add_property( bdf_font_t*  font,
+                     char*        name,
+                     char*        value )
+  {
+    unsigned long   propid;
+    hashnode        hn;
+    int             len;
+    bdf_property_t  *prop, *fp;
+    FT_Memory       memory = font->memory;
+    FT_Error        error = BDF_Err_Ok;
+
+
+    /* First, check to see if the property already exists in the font. */
+    if ( ( hn = hash_lookup( name, (hashtable *)font->internal ) ) != 0 )
+    {
+      /* The property already exists in the font, so simply replace */
+      /* the value of the property with the current value.          */
+      fp = font->props + (unsigned long)hn->data;
+
+      switch ( fp->format )
+      {
+      case BDF_ATOM:
+        /* Delete the current atom if it exists. */
+        FT_FREE( fp->value.atom );
+
+        if ( value == 0 )
+          len = 1;
+        else
+          len = ft_strlen( value ) + 1;
+
+        if ( len > 1 )
+        {
+          if ( FT_NEW_ARRAY( fp->value.atom, len ) )
+            goto Exit;
+          FT_MEM_COPY( fp->value.atom, value, len );
+        }
+        else
+          fp->value.atom = 0;
+        break;
+
+      case BDF_INTEGER:
+        fp->value.int32 = _bdf_atol( value, 0, 10 );
+        break;
+
+      case BDF_CARDINAL:
+        fp->value.card32 = _bdf_atoul( value, 0, 10 );
+        break;
+
+      default:
+        ;
+      }
+
+      goto Exit;
+    }
+
+    /* See whether this property type exists yet or not. */
+    /* If not, create it.                                */
+    hn = hash_lookup( name, &(font->proptbl) );
+    if ( hn == 0 )
+    {
+      error = bdf_create_property( name, BDF_ATOM, font );
+      if ( error )
+        goto Exit;
+      hn = hash_lookup( name, &(font->proptbl) );
+    }
+
+    /* Allocate another property if this is overflow. */
+    if ( font->props_used == font->props_size )
+    {
+      if ( font->props_size == 0 )
+      {
+        if ( FT_NEW_ARRAY( font->props, 1 ) )
+          goto Exit;
+      }
+      else
+      {
+        if ( FT_RENEW_ARRAY( font->props,
+                             font->props_size,
+                             font->props_size + 1 ) )
+          goto Exit;
+      }
+
+      fp = font->props + font->props_size;
+      FT_MEM_SET( fp, 0, sizeof ( bdf_property_t ) );
+      font->props_size++;
+    }
+
+    propid = (unsigned long)hn->data;
+    if ( propid >= _num_bdf_properties )
+      prop = font->user_props + ( propid - _num_bdf_properties );
+    else
+      prop = (bdf_property_t*)_bdf_properties + propid;
+
+    fp = font->props + font->props_used;
+
+    fp->name    = prop->name;
+    fp->format  = prop->format;
+    fp->builtin = prop->builtin;
+
+    switch ( prop->format )
+    {
+    case BDF_ATOM:
+      if ( value == 0 )
+        len = 1;
+      else
+        len = ft_strlen( value ) + 1;
+
+      if ( len > 1 )
+      {
+        if ( FT_NEW_ARRAY( fp->value.atom, len ) )
+          goto Exit;
+        FT_MEM_COPY( fp->value.atom, value, len );
+      }
+      else
+        fp->value.atom = 0;
+      break;
+
+    case BDF_INTEGER:
+      fp->value.int32 = _bdf_atol( value, 0, 10 );
+      break;
+
+    case BDF_CARDINAL:
+      fp->value.card32 = _bdf_atoul( value, 0, 10 );
+      break;
+    }
+
+    /* If the property happens to be a comment, then it doesn't need */
+    /* to be added to the internal hash table.                       */
+    if ( ft_memcmp( name, "COMMENT", 7 ) != 0 ) {
+      /* Add the property to the font property table. */
+      error = hash_insert( fp->name,
+                           (void *)font->props_used,
+                           (hashtable *)font->internal,
+                           memory );
+      if ( error )
+        goto Exit;
+    }
+
+    font->props_used++;
+
+    /* Some special cases need to be handled here.  The DEFAULT_CHAR       */
+    /* property needs to be located if it exists in the property list, the */
+    /* FONT_ASCENT and FONT_DESCENT need to be assigned if they are        */
+    /* present, and the SPACING property should override the default       */
+    /* spacing.                                                            */
+    if ( ft_memcmp( name, "DEFAULT_CHAR", 12 ) == 0 )
+      font->default_glyph = fp->value.int32;
+    else if ( ft_memcmp( name, "FONT_ASCENT", 11 ) == 0 )
+      font->font_ascent = fp->value.int32;
+    else if ( ft_memcmp( name, "FONT_DESCENT", 12 ) == 0 )
+      font->font_descent = fp->value.int32;
+    else if ( ft_memcmp( name, "SPACING", 7 ) == 0 )
+    {
+      if ( fp->value.atom[0] == 'p' || fp->value.atom[0] == 'P' )
+        font->spacing = BDF_PROPORTIONAL;
+      else if ( fp->value.atom[0] == 'm' || fp->value.atom[0] == 'M' )
+        font->spacing = BDF_MONOWIDTH;
+      else if ( fp->value.atom[0] == 'c' || fp->value.atom[0] == 'C' )
+        font->spacing = BDF_CHARCELL;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  static const unsigned char nibble_mask[8] =
+  {
+    0xFF, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE
+  };
+
+
+  /* Actually parse the glyph info and bitmaps. */
+  static FT_Error
+  _bdf_parse_glyphs( char*          line,
+                     unsigned long  linelen,
+                     unsigned long  lineno,
+                     void*          call_data,
+                     void*          client_data )
+  {
+    int                c, mask_index;
+    char*              s;
+    unsigned char*     bp;
+    unsigned long      i, slen, nibbles;
+
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    bdf_glyph_t*       glyph;
+    bdf_font_t*        font;
+
+    FT_Memory          memory;
+    FT_Error           error = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );        /* only used in debug mode */
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    font   = p->font;
+    memory = font->memory;
+
+    /* Check for a comment. */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
+      linelen -= 7;
+
+      s = line + 7;
+      if ( *s != 0 )
+      {
+        s++;
+        linelen--;
+      }
+      error = _bdf_add_comment( p->font, s, linelen );
+      goto Exit;
+    }
+
+    /* The very first thing expected is the number of glyphs. */
+    if ( !( p->flags & _BDF_GLYPHS ) )
+    {
+      if ( ft_memcmp( line, "CHARS", 5 ) != 0 )
+      {
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "CHARS" ));
+        error = BDF_Err_Missing_Chars_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->cnt = font->glyphs_size = _bdf_atoul( p->list.field[1], 0, 10 );
+
+      /* Make sure the number of glyphs is non-zero. */
+      if ( p->cnt == 0 )
+        font->glyphs_size = 64;
+
+      if ( FT_NEW_ARRAY( font->glyphs, font->glyphs_size ) )
+        goto Exit;
+
+      p->flags |= _BDF_GLYPHS;
+
+      goto Exit;
+    }
+
+    /* Check for the ENDFONT field. */
+    if ( ft_memcmp( line, "ENDFONT", 7 ) == 0 )
+    {
+      /* Sort the glyphs by encoding. */
+      ft_qsort( (char *)font->glyphs,
+                font->glyphs_used,
+                sizeof ( bdf_glyph_t ),
+                by_encoding );
+
+      p->flags &= ~_BDF_START;
+
+      goto Exit;
+    }
+
+    /* Check for the ENDCHAR field. */
+    if ( ft_memcmp( line, "ENDCHAR", 7 ) == 0 )
+    {
+      p->glyph_enc = 0;
+      p->flags    &= ~_BDF_GLYPH_BITS;
+
+      goto Exit;
+    }
+
+    /* Check to see whether a glyph is being scanned but should be */
+    /* ignored because it is an unencoded glyph.                   */
+    if ( ( p->flags & _BDF_GLYPH )     &&
+         p->glyph_enc            == -1 &&
+         p->opts->keep_unencoded == 0  )
+      goto Exit;
+
+    /* Check for the STARTCHAR field. */
+    if ( ft_memcmp( line, "STARTCHAR", 9 ) == 0 )
+    {
+      /* Set the character name in the parse info first until the */
+      /* encoding can be checked for an unencoded character.      */
+      FT_FREE( p->glyph_name );
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list,memory );
+      if ( error )
+        goto Exit;
+      _bdf_shift( 1, &p->list );
+
+      s = _bdf_join( ' ', &slen, &p->list );
+
+      if ( FT_NEW_ARRAY( p->glyph_name, slen + 1 ) )
+        goto Exit;
+      FT_MEM_COPY( p->glyph_name, s, slen + 1 );
+
+      p->flags |= _BDF_GLYPH;
+
+      goto Exit;
+    }
+
+    /* Check for the ENCODING field. */
+    if ( ft_memcmp( line, "ENCODING", 8 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_GLYPH ) )
+      {
+        /* Missing STARTCHAR field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "STARTCHAR" ));
+        error = BDF_Err_Missing_Startchar_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->glyph_enc = _bdf_atol( p->list.field[1], 0, 10 );
+
+      /* Check to see whether this encoding has already been encountered. */
+      /* If it has then change it to unencoded so it gets added if        */
+      /* indicated.                                                       */
+      if ( p->glyph_enc >= 0 )
+      {
+        if ( _bdf_glyph_modified( p->have, p->glyph_enc ) )
+        {
+          /* Emit a message saying a glyph has been moved to the */
+          /* unencoded area.                                     */
+          FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG12,
+                      p->glyph_enc, p->glyph_name ));
+          p->glyph_enc = -1;
+          font->modified = 1;
+        }
+        else
+          _bdf_set_glyph_modified( p->have, p->glyph_enc );
+      }
+
+      if ( p->glyph_enc >= 0 )
+      {
+        /* Make sure there are enough glyphs allocated in case the */
+        /* number of characters happen to be wrong.                */
+        if ( font->glyphs_used == font->glyphs_size )
+        {
+          if ( FT_RENEW_ARRAY( font->glyphs,
+                               font->glyphs_size,
+                               font->glyphs_size + 64 ) )
+            goto Exit;
+          FT_MEM_SET( font->glyphs + font->glyphs_size,
+                      0,
+                      sizeof ( bdf_glyph_t ) * 64 ); /* FZ inutile */
+          font->glyphs_size += 64;
+        }
+
+        glyph           = font->glyphs + font->glyphs_used++;
+        glyph->name     = p->glyph_name;
+        glyph->encoding = p->glyph_enc;
+
+        /* Reset the initial glyph info. */
+        p->glyph_name = 0;
+      }
+      else
+      {
+        /* Unencoded glyph.  Check to see whether it should */
+        /* be added or not.                                 */
+        if ( p->opts->keep_unencoded != 0 )
+        {
+          /* Allocate the next unencoded glyph. */
+          if ( font->unencoded_used == font->unencoded_size )
+          {
+            if ( font->unencoded_size == 0 )
+            {
+              if ( FT_NEW_ARRAY( font->unencoded, 4 ) )
+                goto Exit;
+            }
+            else
+            {
+              if ( FT_RENEW_ARRAY( font->unencoded ,
+                                   font->unencoded_size,
+                                   font->unencoded_size + 4 ) )
+                goto Exit;
+            }
+            font->unencoded_size += 4;
+          }
+
+          glyph           = font->unencoded + font->unencoded_used;
+          glyph->name     = p->glyph_name;
+          glyph->encoding = font->unencoded_used++;
+        }
+        else
+          /* Free up the glyph name if the unencoded shouldn't be */
+          /* kept.                                                */
+          FT_FREE( p->glyph_name );
+
+        p->glyph_name = 0;
+      }
+
+      /* Clear the flags that might be added when width and height are */
+      /* checked for consistency.                                      */
+      p->flags &= ~( _BDF_GLYPH_WIDTH_CHECK | _BDF_GLYPH_HEIGHT_CHECK );
+
+      p->flags |= _BDF_ENCODING;
+
+      goto Exit;
+    }
+
+    /* Point at the glyph being constructed. */
+    if ( p->glyph_enc == -1 )
+      glyph = font->unencoded + ( font->unencoded_used - 1 );
+    else
+      glyph = font->glyphs + ( font->glyphs_used - 1 );
+
+    /* Check to see whether a bitmap is being constructed. */
+    if ( p->flags & _BDF_BITMAP )
+    {
+      /* If there are more rows than are specified in the glyph metrics, */
+      /* ignore the remaining lines.                                     */
+      if ( p->row >= (unsigned long)glyph->bbx.height )
+      {
+        if ( !( p->flags & _BDF_GLYPH_HEIGHT_CHECK ) )
+        {
+          FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG13, glyph->encoding ));
+          p->flags |= _BDF_GLYPH_HEIGHT_CHECK;
+          font->modified = 1;
+        }
+
+        goto Exit;
+      }
+
+      /* Only collect the number of nibbles indicated by the glyph     */
+      /* metrics.  If there are more columns, they are simply ignored. */
+      nibbles = glyph->bpr << 1;
+      bp      = glyph->bitmap + p->row * glyph->bpr;
+
+      for ( i = 0, *bp = 0; i < nibbles; i++ )
+      {
+        c = line[i];
+        *bp = (FT_Byte)( ( *bp << 4 ) + a2i[c] );
+        if ( i + 1 < nibbles && ( i & 1 ) )
+          *++bp = 0;
+      }
+
+      /* Remove possible garbage at the right. */
+      mask_index = ( glyph->bbx.width * p->font->bpp ) & 7;
+      *bp &= nibble_mask[mask_index];
+
+      /* If any line has extra columns, indicate they have been removed. */
+      if ( ( line[nibbles] == '0' || a2i[(int)line[nibbles]] != 0 ) &&
+           !( p->flags & _BDF_GLYPH_WIDTH_CHECK )                   )
+      {
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG14, glyph->encoding ));
+        p->flags       |= _BDF_GLYPH_WIDTH_CHECK;
+        font->modified  = 1;
+      }
+
+      p->row++;
+      goto Exit;
+    }
+
+    /* Expect the SWIDTH (scalable width) field next. */
+    if ( ft_memcmp( line, "SWIDTH", 6 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_ENCODING ) )
+      {
+        /* Missing ENCODING field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "ENCODING" ));
+        error = BDF_Err_Missing_Encoding_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      glyph->swidth = (unsigned short)_bdf_atoul( p->list.field[1], 0, 10 );
+      p->flags |= _BDF_SWIDTH;
+
+      goto Exit;
+    }
+
+    /* Expect the DWIDTH (scalable width) field next. */
+    if ( ft_memcmp( line, "DWIDTH", 6 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list,memory );
+      if ( error )
+        goto Exit;
+      glyph->dwidth = (unsigned short)_bdf_atoul( p->list.field[1], 0, 10 );
+
+      if ( !( p->flags & _BDF_SWIDTH ) )
+      {
+        /* Missing SWIDTH field.  Emit an auto correction message and set */
+        /* the scalable width from the device width.                      */
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG9, lineno ));
+
+        glyph->swidth = (unsigned short)FT_MulDiv(
+                          glyph->dwidth, 72000L,
+                          (FT_Long)( font->point_size *
+                                     font->resolution_x ) );
+      }
+
+      p->flags |= _BDF_DWIDTH;
+      goto Exit;
+    }
+
+    /* Expect the BBX field next. */
+    if ( ft_memcmp( line, "BBX", 3 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+
+      glyph->bbx.width    = _bdf_atos( p->list.field[1], 0, 10 );
+      glyph->bbx.height   = _bdf_atos( p->list.field[2], 0, 10 );
+      glyph->bbx.x_offset = _bdf_atos( p->list.field[3], 0, 10 );
+      glyph->bbx.y_offset = _bdf_atos( p->list.field[4], 0, 10 );
+
+      /* Generate the ascent and descent of the character. */
+      glyph->bbx.ascent  = (short)( glyph->bbx.height + glyph->bbx.y_offset );
+      glyph->bbx.descent = (short)( -glyph->bbx.y_offset );
+
+      /* Determine the overall font bounding box as the characters are */
+      /* loaded so corrections can be done later if indicated.         */
+      p->maxas    = (FT_Short) MAX( glyph->bbx.ascent, p->maxas );
+      p->maxds    = (FT_Short) MAX( glyph->bbx.descent, p->maxds );
+
+      p->rbearing = (short)( glyph->bbx.width + glyph->bbx.x_offset );
+
+      p->maxrb    = (FT_Short) MAX( p->rbearing, p->maxrb );
+      p->minlb    = (FT_Short) MIN( glyph->bbx.x_offset, p->minlb );
+      p->maxlb    = (FT_Short) MAX( glyph->bbx.x_offset, p->maxlb );
+
+      if ( !( p->flags & _BDF_DWIDTH ) )
+      {
+        /* Missing DWIDTH field.  Emit an auto correction message and set */
+        /* the device width to the glyph width.                           */
+        FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG10, lineno ));
+        glyph->dwidth = glyph->bbx.width;
+      }
+
+      /* If the BDF_CORRECT_METRICS flag is set, then adjust the SWIDTH */
+      /* value if necessary.                                            */
+      if ( p->opts->correct_metrics != 0 )
+      {
+        /* Determine the point size of the glyph. */
+        unsigned short  sw = (unsigned short)FT_MulDiv(
+                               glyph->dwidth, 72000L,
+                               (FT_Long)( font->point_size *
+                                          font->resolution_x ) );
+
+
+        if ( sw != glyph->swidth )
+        {
+          glyph->swidth = sw;
+
+          if ( p->glyph_enc == -1 )
+            _bdf_set_glyph_modified( font->umod,
+                                     font->unencoded_used - 1 );
+          else
+            _bdf_set_glyph_modified( font->nmod, glyph->encoding );
+
+          p->flags       |= _BDF_SWIDTH_ADJ;
+          font->modified  = 1;
+        }
+      }
+
+      p->flags |= _BDF_BBX;
+      goto Exit;
+    }
+
+    /* And finally, gather up the bitmap. */
+    if ( ft_memcmp( line, "BITMAP", 6 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_BBX ) )
+      {
+        /* Missing BBX field. */
+        FT_ERROR(( "_bdf_parse_glyphs: " ERRMSG1, lineno, "BBX" ));
+        error = BDF_Err_Missing_Bbx_Field;
+        goto Exit;
+      }
+
+      /* Allocate enough space for the bitmap. */
+      glyph->bpr   = ( glyph->bbx.width * p->font->bpp + 7 ) >> 3;
+      glyph->bytes = (unsigned short)( glyph->bpr * glyph->bbx.height );
+
+      if ( FT_NEW_ARRAY( glyph->bitmap, glyph->bytes ) )
+        goto Exit;
+
+      p->row    = 0;
+      p->flags |= _BDF_BITMAP;
+
+      goto Exit;
+    }
+
+    error = BDF_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
+  }
+
+
+  /* Load the font properties. */
+  static FT_Error
+  _bdf_parse_properties( char*          line,
+                         unsigned long  linelen,
+                         unsigned long  lineno,
+                         void*          call_data,
+                         void*          client_data )
+  {
+    unsigned long      vlen;
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    char*              name;
+    char*              value;
+    char               nbuf[128];
+    FT_Memory          memory;
+    FT_Error           error = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    memory = p->font->memory;
+
+    /* Check for the end of the properties. */
+    if ( ft_memcmp( line, "ENDPROPERTIES", 13 ) == 0 )
+    {
+      /* If the FONT_ASCENT or FONT_DESCENT properties have not been      */
+      /* encountered yet, then make sure they are added as properties and */
+      /* make sure they are set from the font bounding box info.          */
+      /*                                                                  */
+      /* This is *always* done regardless of the options, because X11     */
+      /* requires these two fields to compile fonts.                      */
+      if ( bdf_get_font_property( p->font, (char *)"FONT_ASCENT" ) == 0 )
+      {
+        p->font->font_ascent = p->font->bbx.ascent;
+        ft_sprintf( nbuf, "%hd", p->font->bbx.ascent );
+        error = _bdf_add_property( p->font, (char *)"FONT_ASCENT", nbuf );
+        if ( error )
+          goto Exit;
+
+        FT_TRACE2(( "_bdf_parse_properties: " ACMSG1, p->font->bbx.ascent ));
+        p->font->modified = 1;
+      }
+
+      if ( bdf_get_font_property( p->font, (char *)"FONT_DESCENT" ) == 0 )
+      {
+        p->font->font_descent = p->font->bbx.descent;
+        ft_sprintf( nbuf, "%hd", p->font->bbx.descent );
+        error = _bdf_add_property( p->font, (char *)"FONT_DESCENT", nbuf );
+        if ( error )
+          goto Exit;
+
+        FT_TRACE2(( "_bdf_parse_properties: " ACMSG2, p->font->bbx.descent ));
+        p->font->modified = 1;
+      }
+
+      p->flags &= ~_BDF_PROPS;
+      *next     = _bdf_parse_glyphs;
+
+      goto Exit;
+    }
+
+    /* Ignore the _XFREE86_GLYPH_RANGES properties. */
+    if ( ft_memcmp( line, "_XFREE86_GLYPH_RANGES", 21 ) == 0 )
+      goto Exit;
+
+    /* Handle COMMENT fields and properties in a special way to preserve */
+    /* the spacing.                                                      */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
+      name = value = line;
+      value += 7;
+      if ( *value )
+        *value++ = 0;
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+    else if ( _bdf_is_atom( line, linelen, &name, &value, p->font ) )
+    {
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+    else
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      name = p->list.field[0];
+
+      _bdf_shift( 1, &p->list );
+      value = _bdf_join( ' ', &vlen, &p->list );
+
+      error = _bdf_add_property( p->font, name, value );
+      if ( error )
+        goto Exit;
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  /* Load the font header. */
+  static FT_Error
+  _bdf_parse_start( char*          line,
+                    unsigned long  linelen,
+                    unsigned long  lineno,
+                    void*          call_data,
+                    void*          client_data )
+  {
+    unsigned long      slen;
+    _bdf_line_func_t*  next;
+    _bdf_parse_t*      p;
+    bdf_font_t*        font;
+    char               *s;
+
+    FT_Memory          memory = NULL;
+    FT_Error           error  = BDF_Err_Ok;
+
+    FT_UNUSED( lineno );            /* only used in debug mode */
+
+
+    next = (_bdf_line_func_t *)call_data;
+    p    = (_bdf_parse_t *)    client_data;
+
+    if ( p->font )
+      memory = p->font->memory;
+
+    /* Check for a comment.  This is done to handle those fonts that have */
+    /* comments before the STARTFONT line for some reason.                */
+    if ( ft_memcmp( line, "COMMENT", 7 ) == 0 )
+    {
+      if ( p->opts->keep_comments != 0 && p->font != 0 )
+      {
+        linelen -= 7;
+
+        s = line + 7;
+        if ( *s != 0 )
+        {
+          s++;
+          linelen--;
+        }
+
+        error = _bdf_add_comment( p->font, s, linelen );
+        if ( error )
+          goto Exit;
+        /* here font is not defined! */
+      }
+
+      goto Exit;
+    }
+
+    if ( !( p->flags & _BDF_START ) )
+    {
+      memory = p->memory;
+
+      if ( ft_memcmp( line, "STARTFONT", 9 ) != 0 )
+      {
+        /* No STARTFONT field is a good indication of a problem. */
+        error = BDF_Err_Missing_Startfont_Field;
+        goto Exit;
+      }
+
+      p->flags = _BDF_START;
+      font = p->font = 0;
+
+      if ( FT_NEW( font ) )
+        goto Exit;
+      p->font = font;
+
+      font->memory = p->memory;
+      p->memory    = 0;
+
+      { /* setup */
+        unsigned long    i;
+        bdf_property_t*  prop;
+
+
+        error = hash_init( &(font->proptbl), memory );
+        if ( error )
+          goto Exit;
+        for ( i = 0, prop = (bdf_property_t*)_bdf_properties;
+              i < _num_bdf_properties; i++, prop++ )
+        {
+          error = hash_insert( prop->name, (void *)i,
+                               &(font->proptbl), memory );
+          if ( error )
+            goto Exit;
+        }
+      }
+
+      if ( FT_ALLOC( p->font->internal, sizeof ( hashtable ) ) )
+        goto Exit;
+      error = hash_init( (hashtable *)p->font->internal,memory );
+      if ( error )
+        goto Exit;
+      p->font->spacing       = p->opts->font_spacing;
+      p->font->default_glyph = -1;
+
+      goto Exit;
+    }
+
+    /* Check for the start of the properties. */
+    if ( ft_memcmp( line, "STARTPROPERTIES", 15 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+      p->cnt = p->font->props_size = _bdf_atoul( p->list.field[1], 0, 10 );
+
+      if ( FT_NEW_ARRAY( p->font->props, p->cnt ) )
+        goto Exit;
+
+      p->flags |= _BDF_PROPS;
+      *next     = _bdf_parse_properties;
+
+      goto Exit;
+    }
+
+    /* Check for the FONTBOUNDINGBOX field. */
+    if ( ft_memcmp( line, "FONTBOUNDINGBOX", 15 ) == 0 )
+    {
+      if ( !(p->flags & _BDF_SIZE ) )
+      {
+        /* Missing the SIZE field. */
+        FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "SIZE" ));
+        error = BDF_Err_Missing_Size_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list , memory );
+      if ( error )
+        goto Exit;
+
+      p->font->bbx.width  = _bdf_atos( p->list.field[1], 0, 10 );
+      p->font->bbx.height = _bdf_atos( p->list.field[2], 0, 10 );
+
+      p->font->bbx.x_offset = _bdf_atos( p->list.field[3], 0, 10 );
+      p->font->bbx.y_offset = _bdf_atos( p->list.field[4], 0, 10 );
+
+      p->font->bbx.ascent  = (short)( p->font->bbx.height +
+                                      p->font->bbx.y_offset );
+
+      p->font->bbx.descent = (short)( -p->font->bbx.y_offset );
+
+      p->flags |= _BDF_FONT_BBX;
+
+      goto Exit;
+    }
+
+    /* The next thing to check for is the FONT field. */
+    if ( ft_memcmp( line, "FONT", 4 ) == 0 )
+    {
+      error = _bdf_split( (char *)" +", line, linelen, &p->list , memory );
+      if ( error )
+        goto Exit;
+      _bdf_shift( 1, &p->list );
+
+      s = _bdf_join( ' ', &slen, &p->list );
+      if ( FT_NEW_ARRAY( p->font->name, slen + 1 ) )
+        goto Exit;
+      FT_MEM_COPY( p->font->name, s, slen + 1 );
+
+      /* If the font name is an XLFD name, set the spacing to the one in  */
+      /* the font name.  If there is no spacing fall back on the default. */
+      error = _bdf_set_default_spacing( p->font, p->opts );
+      if ( error )
+        goto Exit;
+
+      p->flags |= _BDF_FONT_NAME;
+
+      goto Exit;
+    }
+
+    /* Check for the SIZE field. */
+    if ( ft_memcmp( line, "SIZE", 4 ) == 0 )
+    {
+      if ( !( p->flags & _BDF_FONT_NAME ) )
+      {
+        /* Missing the FONT field. */
+        FT_ERROR(( "_bdf_parse_start: " ERRMSG1, lineno, "FONT" ));
+        error = BDF_Err_Missing_Font_Field;
+        goto Exit;
+      }
+
+      error = _bdf_split( (char *)" +", line, linelen, &p->list, memory );
+      if ( error )
+        goto Exit;
+
+      p->font->point_size   = _bdf_atoul( p->list.field[1], 0, 10 );
+      p->font->resolution_x = _bdf_atoul( p->list.field[2], 0, 10 );
+      p->font->resolution_y = _bdf_atoul( p->list.field[3], 0, 10 );
+
+      /* Check for the bits per pixel field. */
+      if ( p->list.used == 5 )
+      {
+        unsigned short bitcount, i, shift;
+
+
+        p->font->bpp = (unsigned short)_bdf_atos( p->list.field[4], 0, 10 );
+
+        /* Only values 1, 2, 4, 8 are allowed. */
+        shift = p->font->bpp;
+        bitcount = 0;
+        for ( i = 0; shift > 0; i++ )
+        {
+          if ( shift & 1 )
+            bitcount = i;
+          shift >>= 1;
+        }
+
+        shift = (FT_UShort)(( bitcount > 3 ) ? 8 : ( 1 << bitcount ));
+
+        if ( p->font->bpp > shift || p->font->bpp != shift )
+        {
+          /* select next higher value */
+          p->font->bpp = (FT_UShort)(shift << 1);
+          FT_TRACE2(( "_bdf_parse_start: " ACMSG11, p->font->bpp ));
+        }
+      }
+      else
+        p->font->bpp = 1;
+
+      p->flags |= _BDF_SIZE;
+
+      goto Exit;
+    }
+
+    error = BDF_Err_Invalid_File_Format;
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* API.                                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  bdf_load_font( FT_Stream       stream,
+                 FT_Memory       extmemory,
+                 bdf_options_t*  opts,
+                 bdf_font_t*    *font )
+  {
+    unsigned long  lineno;
+    _bdf_parse_t   p;
+
+    FT_Memory      memory = NULL;
+    FT_Error       error  = BDF_Err_Ok;
+
+
+    FT_MEM_SET( &p, 0, sizeof ( _bdf_parse_t ) );
+
+    p.opts   = (bdf_options_t*)( ( opts != 0 ) ? opts : &_bdf_opts );
+    p.minlb  = 32767;
+    p.memory = extmemory;  /* only during font creation */
+
+    error = _bdf_readstream( stream, _bdf_parse_start,
+                             (void *)&p, &lineno );
+    if ( error )
+      goto Exit;
+
+    if ( p.font != 0 )
+    {
+      /* If the font is not proportional, set the font's monowidth */
+      /* field to the width of the font bounding box.              */
+      memory = p.font->memory;
+
+      if ( p.font->spacing != BDF_PROPORTIONAL )
+        p.font->monowidth = p.font->bbx.width;
+
+      /* If the number of glyphs loaded is not that of the original count, */
+      /* indicate the difference.                                          */
+      if ( p.cnt != p.font->glyphs_used + p.font->unencoded_used )
+      {
+        FT_TRACE2(( "bdf_load_font: " ACMSG15, p.cnt,
+                    p.font->glyphs_used + p.font->unencoded_used ));
+        p.font->modified = 1;
+      }
+
+      /* Once the font has been loaded, adjust the overall font metrics if */
+      /* necessary.                                                        */
+      if ( p.opts->correct_metrics != 0 &&
+           ( p.font->glyphs_used > 0 || p.font->unencoded_used > 0 ) )
+      {
+        if ( p.maxrb - p.minlb != p.font->bbx.width )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG3,
+                      p.font->bbx.width, p.maxrb - p.minlb ));
+          p.font->bbx.width = (unsigned short)( p.maxrb - p.minlb );
+          p.font->modified  = 1;
+        }
+
+        if ( p.font->bbx.x_offset != p.minlb )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG4,
+                      p.font->bbx.x_offset, p.minlb ));
+          p.font->bbx.x_offset = p.minlb;
+          p.font->modified     = 1;
+        }
+
+        if ( p.font->bbx.ascent != p.maxas )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG5,
+                      p.font->bbx.ascent, p.maxas ));
+          p.font->bbx.ascent = p.maxas;
+          p.font->modified   = 1;
+        }
+
+        if ( p.font->bbx.descent != p.maxds )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG6,
+                      p.font->bbx.descent, p.maxds ));
+          p.font->bbx.descent  = p.maxds;
+          p.font->bbx.y_offset = (short)( -p.maxds );
+          p.font->modified     = 1;
+        }
+
+        if ( p.maxas + p.maxds != p.font->bbx.height )
+        {
+          FT_TRACE2(( "bdf_load_font: " ACMSG7,
+                      p.font->bbx.height, p.maxas + p.maxds ));
+          p.font->bbx.height = (unsigned short)( p.maxas + p.maxds );
+        }
+
+        if ( p.flags & _BDF_SWIDTH_ADJ )
+          FT_TRACE2(( "bdf_load_font: " ACMSG8 ));
+      }
+    }
+
+    if ( p.flags & _BDF_START )
+    {
+      {
+        /* The ENDFONT field was never reached or did not exist. */
+        if ( !( p.flags & _BDF_GLYPHS ) )
+          /* Error happened while parsing header. */
+          FT_ERROR(( "bdf_load_font: " ERRMSG2, lineno ));
+        else
+          /* Error happened when parsing glyphs. */
+          FT_ERROR(( "bdf_load_font: " ERRMSG3, lineno ));
+      }
+    }
+
+    /* Free up the list used during the parsing. */
+    if ( memory != NULL )
+      FT_FREE( p.list.field );
+
+    if ( p.font != 0 )
+    {
+      /* Make sure the comments are NULL terminated if they exist. */
+      memory = p.font->memory;
+
+      if ( p.font->comments_len > 0 ) {
+        if ( FT_RENEW_ARRAY( p.font->comments,
+                             p.font->comments_len,
+                             p.font->comments_len + 1 ) )
+          goto Exit;
+
+        p.font->comments[p.font->comments_len] = 0;
+      }
+    }
+    else if ( error == BDF_Err_Ok )
+      error = BDF_Err_Invalid_File_Format;
+
+    *font = p.font;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  bdf_free_font( bdf_font_t*  font )
+  {
+    bdf_property_t*  prop;
+    unsigned long    i;
+    bdf_glyph_t*     glyphs;
+    FT_Memory        memory;
+
+
+    if ( font == 0 )
+      return;
+
+    memory = font->memory;
+
+    FT_FREE( font->name );
+
+    /* Free up the internal hash table of property names. */
+    if ( font->internal )
+    {
+      hash_free( (hashtable *)font->internal, memory );
+      FT_FREE( font->internal );
+    }
+
+    /* Free up the comment info. */
+    FT_FREE( font->comments );
+
+    /* Free up the properties. */
+    for ( i = 0; i < font->props_size; i++ )
+    {
+      if ( font->props[i].format == BDF_ATOM )
+        FT_FREE( font->props[i].value.atom );
+    }
+
+    FT_FREE( font->props );
+
+    /* Free up the character info. */
+    for ( i = 0, glyphs = font->glyphs;
+          i < font->glyphs_used; i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    for ( i = 0, glyphs = font->unencoded; i < font->unencoded_used;
+          i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    FT_FREE( font->glyphs );
+    FT_FREE( font->unencoded );
+
+    /* Free up the overflow storage if it was used. */
+    for ( i = 0, glyphs = font->overflow.glyphs;
+          i < font->overflow.glyphs_used; i++, glyphs++ )
+    {
+      FT_FREE( glyphs->name );
+      FT_FREE( glyphs->bitmap );
+    }
+
+    FT_FREE( font->overflow.glyphs );
+
+    /* bdf_cleanup */
+    hash_free( &(font->proptbl), memory );
+
+    /* Free up the user defined properties. */
+    for (prop = font->user_props, i = 0;
+         i < font->nuser_props; i++, prop++ )
+    {
+      FT_FREE( prop->name );
+      if ( prop->format == BDF_ATOM )
+        FT_FREE( prop->value.atom );
+    }
+
+    FT_FREE( font->user_props );
+
+    /* FREE( font ); */ /* XXX Fixme */
+  }
+
+
+  FT_LOCAL_DEF( bdf_property_t * )
+  bdf_get_font_property( bdf_font_t*  font,
+                         char*        name )
+  {
+    hashnode  hn;
+
+
+    if ( font == 0 || font->props_size == 0 || name == 0 || *name == 0 )
+      return 0;
+
+    hn = hash_lookup( name, (hashtable *)font->internal );
+
+    return hn ? ( font->props + (unsigned long)hn->data ) : 0;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/bdf/descrip.mms
diff -u /dev/null xc/extras/freetype2/src/bdf/descrip.mms:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/descrip.mms	Thu Jun 20 04:16:15 2002
@@ -0,0 +1,23 @@
+#
+# FreeType 2 BDF driver compilation rules for VMS
+#
+
+
+# Copyright 2002 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.bdf])
+
+OBJS=bdf.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
Index: xc/extras/freetype2/src/bdf/module.mk
diff -u /dev/null xc/extras/freetype2/src/bdf/module.mk:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/module.mk	Thu Jun 20 04:16:15 2002
@@ -0,0 +1,31 @@
+#
+# FreeType 2 BDF module definition
+#
+
+# Copyright 2001, 2002 by
+# Francesco Zappa Nardelli
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+make_module_list: add_bdf_driver
+
+add_bdf_driver:
+	$(OPEN_DRIVER)bdf_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)bdf    $(ECHO_DRIVER_DESC)bdf bitmap fonts$(ECHO_DRIVER_DONE)
+
Index: xc/extras/freetype2/src/bdf/rules.mk
diff -u /dev/null xc/extras/freetype2/src/bdf/rules.mk:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/bdf/rules.mk	Thu Jun 20 04:16:15 2002
@@ -0,0 +1,79 @@
+#
+# FreeType 2 bdf driver configuration rules
+#
+
+
+# Copyright (C) 2001, 2002 by
+# Francesco Zappa Nardelli
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+
+
+# bdf driver directory
+#
+BDF_DIR  := $(SRC_)bdf
+BDF_DIR_ := $(BDF_DIR)$(SEP)
+
+
+BDF_COMPILE := $(FT_COMPILE) $I$(BDF_DIR)
+
+
+# bdf driver sources (i.e., C files)
+#
+BDF_DRV_SRC := $(BDF_DIR_)bdflib.c $(BDF_DIR_)bdfdrivr.c
+
+
+# bdf driver headers
+#
+BDF_DRV_H := $(BDF_DIR_)bdf.h \
+             $(BDF_DIR_)bdfdrivr.h
+
+# bdf driver object(s)
+#
+#   BDF_DRV_OBJ_M is used during `multi' builds
+#   BDF_DRV_OBJ_S is used during `single' builds
+#
+BDF_DRV_OBJ_M := $(BDF_DRV_SRC:$(BDF_DIR_)%.c=$(OBJ_)%.$O)
+BDF_DRV_OBJ_S := $(OBJ_)bdf.$O
+
+# bdf driver source file for single build
+#
+BDF_DRV_SRC_S := $(BDF_DIR_)bdf.c
+
+
+# bdf driver - single object
+#
+$(BDF_DRV_OBJ_S): $(BDF_DRV_SRC_S) $(BDF_DRV_SRC) $(FREETYPE_H) $(BDF_DRV_H)
+	$(BDF_COMPILE) $T$@ $(BDF_DRV_SRC_S)
+
+
+# bdf driver - multiple objects
+#
+$(OBJ_)%.$O: $(BDF_DIR_)%.c $(FREETYPE_H) $(BDF_DRV_H)
+	$(BDF_COMPILE) $T$@ $<
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(BDF_DRV_OBJ_S)
+DRV_OBJS_M += $(BDF_DRV_OBJ_M)
+
+# EOF
Index: xc/extras/freetype2/src/cache/descrip.mms
diff -u xc/extras/freetype2/src/cache/descrip.mms:1.1.1.1 xc/extras/freetype2/src/cache/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/cache/descrip.mms:1.1.1.1	Tue May 15 23:45:37 2001
+++ xc/extras/freetype2/src/cache/descrip.mms	Thu Jun 20 04:16:15 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,9 @@
 OBJS=ftcache.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+ftcache.obj : ftcache.c ftlru.c ftcmanag.c ftccache.c ftcglyph.c ftcimage.c \
+              ftcsbits.c ftccmap.c 
 
 # EOF
Index: xc/extras/freetype2/src/cache/ftccache.c
diff -u xc/extras/freetype2/src/cache/ftccache.c:1.1.1.1 xc/extras/freetype2/src/cache/ftccache.c:1.1.1.3
--- xc/extras/freetype2/src/cache/ftccache.c:1.1.1.1	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cache/ftccache.c	Thu Jun 20 04:16:15 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    The FreeType internal cache interface (body).                        */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -24,6 +24,17 @@
 #include "ftcerror.h"
 
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+
+#define FTC_HASH_MAX_LOAD  2
+#define FTC_HASH_MIN_LOAD  1
+#define FTC_HASH_SUB_LOAD  ( FTC_HASH_MAX_LOAD - FTC_HASH_MIN_LOAD )
+
+/* this one _must_ be a power of 2! */
+#define FTC_HASH_INITIAL_SIZE  8
+
+#endif /* FTC_CACHE_USE_LINEAR_HASHING */
+
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
@@ -44,7 +55,7 @@
     family = entry->family;
 
     /* remove from parent set table - eventually destroy the set */
-    if ( --family->num_nodes <= 0 )
+    if ( --family->num_nodes == 0 )
       FT_LruList_Remove( cache->families, (FT_LruNode) family );
   }
 
@@ -59,14 +70,21 @@
 
     if ( first )
     {
-      node->mru_prev = first->mru_prev;
+      FTC_Node  last = first->mru_prev;
+
+
+      FT_ASSERT( last->mru_next == first );
+
+      node->mru_prev = last;
       node->mru_next = first;
 
-      first->mru_prev->mru_next = node;
-      first->mru_prev           = node;
+      last->mru_next  = node;
+      first->mru_prev = node;
     }
     else
     {
+      FT_ASSERT( manager->num_nodes == 0 );
+
       node->mru_next = node;
       node->mru_prev = node;
     }
@@ -81,21 +99,25 @@
   ftc_node_mru_unlink( FTC_Node     node,
                        FTC_Manager  manager )
   {
+    FTC_Node  first = manager->nodes_list;
     FTC_Node  prev  = node->mru_prev;
     FTC_Node  next  = node->mru_next;
-    FTC_Node  first = manager->nodes_list;
 
 
-    prev->mru_next = next;
+    FT_ASSERT( first != NULL && manager->num_nodes > 0 );
+    FT_ASSERT( next->mru_prev == node );
+    FT_ASSERT( prev->mru_next == node );
+
     next->mru_prev = prev;
+    prev->mru_next = next;
 
-    if ( node->mru_next == first )
+    if ( node == first )
     {
       /* this is the last node in the list; update its head pointer */
-      if ( node == first )
+      if ( node == next )
         manager->nodes_list = NULL;
       else
-        first->mru_prev = prev;
+        manager->nodes_list = next;
     }
 
     node->mru_next = NULL;
@@ -113,12 +135,108 @@
 
 
     if ( node != first )
+    {
+      FTC_Node  prev = node->mru_prev;
+      FTC_Node  next = node->mru_next;
+      FTC_Node  last;
+
+
+      prev->mru_next = next;
+      next->mru_prev = prev;
+
+      last            = first->mru_prev;
+      node->mru_next  = first;
+      node->mru_prev  = last;
+      first->mru_prev = node;
+      last->mru_next  = node;
+
+      manager->nodes_list = node;
+    }
+  }
+
+
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+
+  /* remove a node from its cache's hash table */
+  static FT_Error
+  ftc_node_hash_unlink( FTC_Node   node,
+                        FTC_Cache  cache )
+  {
+    FT_Error   error = 0;
+    FTC_Node  *pnode;
+    FT_UInt    index, num_buckets;
+
+  
+    index = (FT_UInt)( node->hash & cache->mask );
+    if ( index < cache->p )
+      index = (FT_UInt)( node->hash & ( 2 * cache->mask + 1 ) );
+
+    pnode = cache->buckets + index;
+
+    for (;;)
+    {
+      if ( *pnode == NULL )
+      {
+        FT_ERROR(( "ftc_node_hash_unlink: unknown node!\n" ));
+        return FT_Err_Ok;
+      }
+
+      if ( *pnode == node )
+      {
+        *pnode     = node->link;
+        node->link = NULL;
+        break;
+      }
+
+      pnode = &(*pnode)->link;
+    }
+
+    num_buckets = ( cache->p + cache->mask + 1 );
+
+    if ( ++cache->slack > (FT_Long)num_buckets * FTC_HASH_SUB_LOAD )
     {
-      ftc_node_mru_unlink( node, manager );
-      ftc_node_mru_link( node, manager );
+      FT_UInt    p         = cache->p;
+      FT_UInt    mask      = cache->mask;
+      FT_UInt    old_index = p + mask;
+      FTC_Node*  pold;
+
+
+      FT_ASSERT( old_index >= FTC_HASH_INITIAL_SIZE );
+
+      if ( p == 0 )
+      {
+        FT_Memory  memory = cache->memory;
+
+
+        cache->mask >>= 1;
+        p             = cache->mask;
+
+        if ( FT_RENEW_ARRAY( cache->buckets, ( mask + 1 ) * 2, (mask+1) ) )
+        {
+          FT_ERROR(( "ftc_node_hash_unlink: couldn't shunk buckets!\n" ));
+          goto Exit;
+        }
+      }
+      else
+        p--;
+
+      pnode = cache->buckets + p;
+      while ( *pnode )
+        pnode = &(*pnode)->link;
+
+      pold   = cache->buckets + old_index;
+      *pnode = *pold;
+      *pold  = NULL;
+
+      cache->slack -= FTC_HASH_MAX_LOAD;
+      cache->p      = p;
     }
+
+  Exit:
+    return error;
   }
 
+#else /* !FTC_CACHE_USE_LINEAR_HASHING */
 
   /* remove a node from its cache's hash table */
   static void
@@ -149,8 +267,87 @@
     }
   }
 
+#endif /* !FTC_CACHE_USE_LINEAR_HASHING */
+
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+
   /* add a node to the "top" of its cache's hash table */
+  static FT_Error
+  ftc_node_hash_link( FTC_Node   node,
+                      FTC_Cache  cache )
+  {
+    FTC_Node  *pnode;
+    FT_UInt    index;
+    FT_Error   error = 0;
+
+
+    index = (FT_UInt)( node->hash & cache->mask );
+    if ( index < cache->p )
+      index = (FT_UInt)( node->hash & (2 * cache->mask + 1 ) );
+
+    pnode = cache->buckets + index;
+
+    node->link = *pnode;
+    *pnode     = node;
+
+    if ( --cache->slack < 0 )
+    {
+      FT_UInt    p     = cache->p;
+      FT_UInt    mask  = cache->mask;
+      FTC_Node   new_list;
+
+
+      /* split a single bucket */
+      new_list = NULL;
+      pnode    = cache->buckets + p;
+
+      for (;;)
+      {
+        node = *pnode;
+        if ( node == NULL )
+          break;
+
+        if ( node->hash & ( mask + 1 ) )
+        {
+          *pnode     = node->link;
+          node->link = new_list;
+          new_list   = node;
+        }
+        else
+          pnode = &node->link;
+      }
+
+      cache->buckets[p + mask + 1] = new_list;
+
+      cache->slack += FTC_HASH_MAX_LOAD;
+
+      if ( p >= mask )
+      {
+        FT_Memory  memory = cache->memory;
+
+
+        if ( FT_RENEW_ARRAY( cache->buckets,
+                             ( mask + 1 ) * 2, ( mask + 1 ) * 4 ) )
+        {
+          FT_ERROR(( "ftc_node_hash_link: couldn't expand buckets!\n" ));
+          goto Exit;
+        }
+
+        cache->mask = 2 * mask + 1;
+        cache->p    = 0;
+      }
+      else
+        cache->p = p + 1;
+    }
+
+  Exit:
+    return error;
+  }
+
+#else /* !FTC_CACHE_USE_LINEAR_HASHING */
+
+  /* add a node to the "top" of its cache's hash table */
   static void
   ftc_node_hash_link( FTC_Node   node,
                       FTC_Cache  cache )
@@ -164,6 +361,9 @@
     cache->nodes++;
   }
 
+#endif /* !FTC_CACHE_USE_LINEAR_HASHING */
+
+
 
   /* remove a node from the cache manager */
   FT_EXPORT_DEF( void )
@@ -210,10 +410,10 @@
     if ( clazz->node_done )
       clazz->node_done( node, cache );
 
-    FREE( node );
+    FT_FREE( node );
 
     /* check, just in case of general corruption :-) */
-    if ( manager->num_nodes <= 0 )
+    if ( manager->num_nodes == 0 )
       FT_ERROR(( "ftc_node_destroy: invalid cache node count! = %d\n",
                   manager->num_nodes ));
   }
@@ -276,6 +476,12 @@
   /*************************************************************************/
   /*************************************************************************/
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+
+  /* nothing */
+
+#else /* !FTC_CACHE_USE_LINEAR_HASHING */
+
 #define FTC_PRIMES_MIN  7
 #define FTC_PRIMES_MAX  13845163
 
@@ -355,13 +561,13 @@
 
       /* no need to report an error; we'll simply keep using the same */
       /* buckets number / size                                        */
-      if ( ALLOC_ARRAY( new_buckets, new_size, FTC_Node ) )
+      if ( FT_NEW_ARRAY( new_buckets, new_size ) )
         return;
 
       for ( i = 0; i < cache->size; i++ )
       {
-        FTC_Node   node, next, *pnode;
-        FT_UFast   hash;
+        FTC_Node  node, next, *pnode;
+        FT_UFast  hash;
 
 
         node = cache->buckets[i];
@@ -379,13 +585,17 @@
       }
 
       if ( cache->buckets )
-        FREE( cache->buckets );
+        FT_FREE( cache->buckets );
 
       cache->buckets = new_buckets;
       cache->size    = new_size;
+
+      FT_UNUSED( error );
     }
   }
 
+#endif /* !FTC_CACHE_USE_LINEAR_HASHING */
+
 
   FT_EXPORT_DEF( FT_Error )
   ftc_cache_init( FTC_Cache  cache )
@@ -395,12 +605,25 @@
     FT_Error         error;
 
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+
+    cache->p     = 0;
+    cache->mask  = FTC_HASH_INITIAL_SIZE - 1;
+    cache->slack = FTC_HASH_INITIAL_SIZE * FTC_HASH_MAX_LOAD;
+
+    if ( FT_NEW_ARRAY( cache->buckets, FTC_HASH_INITIAL_SIZE * 2 ) )
+      goto Exit;
+
+#else /* !FTC_CACHE_USE_LINEAR_HASHING */
+
     cache->nodes = 0;
     cache->size  = FTC_PRIMES_MIN;
 
-    if ( ALLOC_ARRAY( cache->buckets, cache->size, FTC_Node ) )
+    if ( FT_NEW_ARRAY( cache->buckets, cache->size ) )
       goto Exit;
 
+#endif /* !FTC_CACHE_USE_LINEAR_HASHING */
+
     /* now, initialize the lru list of families for this cache */
     if ( clazz->family_size > 0 )
     {
@@ -423,7 +646,7 @@
                               memory,
                               &cache->families );
       if ( error )
-        FREE( cache->buckets );
+        FT_FREE( cache->buckets );
     }
 
   Exit:
@@ -440,9 +663,15 @@
       FTC_Cache_Class  clazz   = cache->clazz;
       FTC_Manager      manager = cache->manager;
       FT_UFast         i;
+      FT_UInt          count;
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+      count = cache->p + cache->mask + 1;
+#else
+      count = cache->size;
+#endif
 
-      for ( i = 0; i < cache->size; i++ )
+      for ( i = 0; i < count; i++ )
       {
         FTC_Node  *pnode = cache->buckets + i, next, node = *pnode;
 
@@ -461,14 +690,17 @@
           if ( clazz->node_done )
             clazz->node_done( node, cache );
 
-          FREE( node );
+          FT_FREE( node );
           node = next;
         }
         cache->buckets[i] = NULL;
       }
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+      cache->p = 0;
+#else
       cache->nodes = 0;
-
+#endif
       /* destroy the families */
       if ( cache->families )
         FT_LruList_Reset( cache->families );
@@ -486,8 +718,13 @@
 
       ftc_cache_clear( cache );
 
-      FREE( cache->buckets );
+      FT_FREE( cache->buckets );
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+      cache->mask  = 0;
+      cache->slack = 0;
+#else
       cache->size = 0;
+#endif
 
       if ( cache->families )
       {
@@ -506,11 +743,10 @@
                     FTC_Query   query,
                     FTC_Node   *anode )
   {
-    FT_Error    error;
+    FT_Error    error = FT_Err_Ok;
     FT_LruNode  lru;
 
 
-    /* some argument checks are delayed to ftc_glyph_cache_lookup */
     if ( !cache || !query || !anode )
       return FTC_Err_Invalid_Argument;
 
@@ -519,20 +755,85 @@
     query->hash   = 0;
     query->family = NULL;
 
+#if 1
+
+    /* XXX: we break encapsulation for the sake of speed! */
+    {
+      /* first of all, find the relevant family */
+      FT_LruList              list    = cache->families;
+      FT_LruNode              fam, *pfam;
+      FT_LruNode_CompareFunc  compare = list->clazz->node_compare;
+
+      pfam = &list->nodes;
+      for (;;)
+      {
+        fam = *pfam;
+        if ( fam == NULL )
+        {
+          error = FT_LruList_Lookup( list, query, &lru );
+          if ( error )
+            goto Exit;
+
+          goto Skip;
+        }
+
+        if ( compare( fam, query, list->data ) )
+          break;
+
+        pfam = &fam->next;
+      }
+
+      FT_ASSERT( fam != NULL );
+
+      /* move to top of list when needed */
+      if ( fam != list->nodes )
+      {
+        *pfam       = fam->next;
+        fam->next   = list->nodes;
+        list->nodes = fam;
+      }
+
+      lru = fam;
+
+    Skip:
+      ;
+    }
+
+#else
+
     error = FT_LruList_Lookup( cache->families, query, &lru );
     if ( !error )
+
+#endif
     {
       FTC_Family  family = (FTC_Family) lru;
       FT_UFast    hash    = query->hash;
-      FTC_Node*   bucket  = cache->buckets + (hash % cache->size);
+      FTC_Node*   bucket;
+
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+
+      FT_UInt  index;
 
 
+      index = hash & cache->mask;
+      if ( index < cache->p )
+        index = hash & ( cache->mask * 2 + 1 );
+
+      bucket  = cache->buckets + index;
+
+#else
+
+      bucket  = cache->buckets + (hash % cache->size);
+
+#endif
+
+
       if ( query->family     != family                        ||
            family->fam_index >= cache->manager->families.size )
       {
         FT_ERROR((
           "ftc_cache_lookup: invalid query (bad 'family' field)\n" ));
-        return FT_Err_Invalid_Argument;
+        return FTC_Err_Invalid_Argument;
       }
 
       if ( *bucket )
@@ -550,7 +851,8 @@
           if ( node == NULL )
             break;
 
-          if ( (FT_UInt)node->fam_index == family->fam_index &&
+          if ( node->hash == hash                            &&
+               (FT_UInt)node->fam_index == family->fam_index &&
                compare( node, query, cache ) )
           {
             /* move to head of bucket list */
@@ -569,7 +871,7 @@
             goto Exit;
           }
 
-          pnode = &(*pnode)->link;
+          pnode = &node->link;
         }
       }
 
@@ -581,7 +883,7 @@
         FTC_Node         node;
 
 
-        if ( ALLOC( node, clazz->node_size ) )
+        if ( FT_ALLOC( node, clazz->node_size ) )
           goto Exit;
 
         node->fam_index = (FT_UShort) family->fam_index;
@@ -591,11 +893,22 @@
         error = clazz->node_init( node, query, cache );
         if ( error )
         {
-          FREE( node );
+          FT_FREE( node );
           goto Exit;
         }
 
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+        error = ftc_node_hash_link( node, cache );
+        if ( error )
+        {
+          clazz->node_done( node, cache );
+          FT_FREE( node );
+          goto Exit;
+        }
+#else
         ftc_node_hash_link( node, cache );
+#endif
+
         ftc_node_mru_link( node, cache->manager );
 
         cache->manager->cur_weight += clazz->node_weight( node, cache );
@@ -608,9 +921,11 @@
           node->ref_count--;
         }
 
+#ifndef FTC_CACHE_USE_LINEAR_HASHING
         /* try to resize the hash table if appropriate */
         if ( FTC_CACHE_RESIZE_TEST( cache ) )
           ftc_cache_resize( cache );
+#endif
 
         *anode = node;
       }
Index: xc/extras/freetype2/src/cache/ftccache.i
diff -u /dev/null xc/extras/freetype2/src/cache/ftccache.i:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:45 2003
+++ xc/extras/freetype2/src/cache/ftccache.i	Thu Jun 20 04:16:15 2002
@@ -0,0 +1,171 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftccache.i                                                             */
+/*                                                                         */
+/*    FreeType template for generic cache.                                 */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef GEN_CACHE_FAMILY_COMPARE
+#error "GEN_CACHE_FAMILY_COMPARE not defined in template instantiation"
+#endif
+
+#ifndef GEN_CACHE_NODE_COMPARE
+#error "GEN_CACHE_NODE_COMPARE not defined in template instantiation"
+#endif
+
+
+  static FT_Error
+  GEN_CACHE_LOOKUP( FTC_Cache   cache,
+                    FTC_Query   query,
+                    FTC_Node   *anode )
+  {
+    FT_LruNode  lru;
+    FTC_Family  family;
+    FT_UFast    hash;
+
+
+    query->hash   = 0;
+    query->family = NULL;
+
+    /* XXX: we break encapsulation for the sake of speed! */
+    {
+      /* first of all, find the relevant family */
+      FT_LruList  list  = cache->families;
+      FT_LruNode  fam, *pfam;
+
+
+      pfam = &list->nodes;
+      for (;;)
+      {
+        fam = *pfam;
+        if ( fam == NULL )
+          goto Normal;
+
+        if ( GEN_CACHE_FAMILY_COMPARE( fam, query, list->data ) )
+          break;
+
+        pfam = &fam->next;
+      }
+
+      FT_ASSERT( fam != NULL );
+
+      /* move to top of list when needed */
+      if ( fam != list->nodes )
+      {
+        *pfam       = fam->next;
+        fam->next   = list->nodes;
+        list->nodes = fam;
+      }
+
+      lru = fam;
+    }
+
+    {
+      FTC_Node  node, *pnode, *bucket;
+
+
+      family = (FTC_Family)lru;
+      hash   = query->hash;
+
+#ifdef FTC_CACHE_USE_LINEAR_HASHING
+      {
+        FT_UInt  index;
+
+
+        index = hash & cache->mask;
+        if ( index < cache->p )
+          index = hash & ( cache->mask * 2 + 1 );
+
+        bucket  = cache->buckets + index;
+      }
+#else
+      bucket  = cache->buckets + ( hash % cache->size );
+#endif
+
+#ifdef FT_DEBUG_LEVEL_ERROR
+      if ( query->family     != family                        ||
+           family->fam_index >= cache->manager->families.size )
+      {
+        FT_ERROR((
+          "ftc_cache_lookup: invalid query (bad 'family' field)\n" ));
+        return FTC_Err_Invalid_Argument;
+      }
+#endif
+
+      pnode = bucket;
+
+      for ( ;; )
+      {
+        node = *pnode;
+        if ( node == NULL )
+          goto Normal;
+
+        if ( node->hash == hash                            &&
+             (FT_UInt)node->fam_index == family->fam_index &&
+             GEN_CACHE_NODE_COMPARE( node, query, cache )  )
+        {
+          /* we place the following out of the loop to make it */
+          /* as small as possible...                           */
+          goto Found;
+        }
+
+        pnode = &node->link;
+      }
+
+  Normal:
+      return ftc_cache_lookup( cache, query, anode );
+
+  Found:
+      /* move to head of bucket list */
+      if ( pnode != bucket )
+      {
+        *pnode     = node->link;
+        node->link = *bucket;
+        *bucket    = node;
+      }
+
+      /* move to head of MRU list */
+      if ( node != cache->manager->nodes_list )
+      {
+        /* XXX: again, this is an inlined version of ftc_node_mru_up */
+        FTC_Manager  manager = cache->manager;
+        FTC_Node     first   = manager->nodes_list;
+        FTC_Node     prev = node->mru_prev;
+        FTC_Node     next = node->mru_next;
+        FTC_Node     last;
+
+
+        prev->mru_next = next;
+        next->mru_prev = prev;
+
+        last            = first->mru_prev;
+        node->mru_next  = first;
+        node->mru_prev  = last;
+        first->mru_prev = node;
+        last->mru_next  = node;
+
+        manager->nodes_list = node;
+      }
+
+      *anode = node;
+      return 0;
+    }
+  }
+
+#undef GEN_CACHE_NODE_COMPARE
+#undef GEN_CACHE_FAMILY_COMPARE
+#undef GEN_CACHE_LOOKUP
+
+
+/* END */
Index: xc/extras/freetype2/src/cache/ftccmap.c
diff -u xc/extras/freetype2/src/cache/ftccmap.c:1.1.1.1 xc/extras/freetype2/src/cache/ftccmap.c:1.1.1.3
--- xc/extras/freetype2/src/cache/ftccmap.c:1.1.1.1	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cache/ftccmap.c	Thu Jun 20 04:16:15 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType CharMap cache (body)                                        */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -32,7 +32,7 @@
   /* codes to equivalent glyph indices.                                    */
   /*                                                                       */
   /* For now, the implementation is very basic: Each node maps a range of  */
-  /* 128 consecutive character codes to their correspondingglyph indices.  */
+  /* 128 consecutive character codes to their corresponding glyph indices. */
   /*                                                                       */
   /* We could do more complex things, but I don't think it is really very  */
   /* useful.                                                               */
@@ -130,7 +130,7 @@
   FT_CALLBACK_DEF( FT_ULong )
   ftc_cmap_node_weight( FTC_CMapNode  cnode )
   {
-    FT_UNUSED(cnode);
+    FT_UNUSED( cnode );
     
     return sizeof ( *cnode );
   }
@@ -177,27 +177,27 @@
     if ( !error )
     {
       FT_UInt      count = face->num_charmaps;
-      FT_UInt      index = count;
+      FT_UInt      idx   = count;
       FT_CharMap*  cur   = face->charmaps;
 
 
       switch ( desc->type )
       {
       case FTC_CMAP_BY_INDEX:
-        index = desc->u.index;
-        hash  = index * 33;
+        idx  = desc->u.index;
+        hash = idx * 33;
         break;
 
       case FTC_CMAP_BY_ENCODING:
-        for ( index = 0; index < count; index++, cur++ )
+        for ( idx = 0; idx < count; idx++, cur++ )
           if ( cur[0]->encoding == desc->u.encoding )
             break;
 
-        hash = index * 67;
+        hash = idx * 67;
         break;
 
       case FTC_CMAP_BY_ID:
-        for ( index = 0; index < count; index++, cur++ )
+        for ( idx = 0; idx < count; idx++, cur++ )
         {
           if ( (FT_UInt)cur[0]->platform_id == desc->u.id.platform &&
                (FT_UInt)cur[0]->encoding_id == desc->u.id.encoding )
@@ -212,11 +212,11 @@
         ;
       }
 
-      if ( index >= count )
+      if ( idx >= count )
         goto Bad_Descriptor;
 
       /* compute hash value, both in family and query */
-      cfam->index               = index;
+      cfam->index               = idx;
       cfam->hash                = hash ^ FTC_FACE_ID_HASH( desc->face_id );
       FTC_QUERY( cquery )->hash = FTC_CMAP_HASH( cfam, cquery );
 
@@ -228,7 +228,7 @@
 
   Bad_Descriptor:
     FT_ERROR(( "ftp_cmap_family_init: invalid charmap descriptor\n" ));
-    return FT_Err_Invalid_Argument;
+    return FTC_Err_Invalid_Argument;
   }
 
 
@@ -318,6 +318,25 @@
   }
 
 
+#ifdef FTC_CACHE_USE_INLINE
+
+#define GEN_CACHE_FAMILY_COMPARE( f, q, c ) \
+          ftc_cmap_family_compare( (FTC_CMapFamily)(f), (FTC_CMapQuery)(q) )
+
+#define GEN_CACHE_NODE_COMPARE( n, q, c ) \
+          ftc_cmap_node_compare( (FTC_CMapNode)(n), (FTC_CMapQuery)(q) )
+
+#define GEN_CACHE_LOOKUP  ftc_cmap_cache_lookup
+
+#include "ftccache.i"
+
+#else  /* !FTC_CACHE_USE_INLINE */
+
+#define ftc_cmap_cache_lookup  ftc_cache_lookup
+
+#endif /* !FTC_CACHE_USE_INLINE */
+
+
   /* documentation is in ftccmap.h */
 
   FT_EXPORT_DEF( FT_UInt )
@@ -340,14 +359,16 @@
     cquery.desc      = desc;
     cquery.char_code = char_code;
 
-    error = ftc_cache_lookup( FTC_CACHE( cache ),
-                              FTC_QUERY( &cquery ),
-                              (FTC_Node*)&node );
+    error = ftc_cmap_cache_lookup( FTC_CACHE( cache ),
+                                   FTC_QUERY( &cquery ),
+                                   (FTC_Node*)&node );
     if ( !error )
     {
       FT_UInt  offset = (FT_UInt)( char_code - node->first );
 
 
+      FT_ASSERT( offset < FTC_CMAP_INDICES_MAX );
+
       gindex = node->indices[offset];
       if ( gindex == FTC_CMAP_UNKNOWN )
       {
@@ -375,7 +396,7 @@
 
           /* perform lookup */
           gindex                = FT_Get_Char_Index( face, char_code );
-          node->indices[offset] = (FT_UInt16) gindex;
+          node->indices[offset] = (FT_UInt16)gindex;
 
           /* restore old charmap */
           FT_Set_Charmap( face, old );
Index: xc/extras/freetype2/src/cache/ftcimage.c
diff -u xc/extras/freetype2/src/cache/ftcimage.c:1.1.1.5 xc/extras/freetype2/src/cache/ftcimage.c:1.1.1.7
--- xc/extras/freetype2/src/cache/ftcimage.c:1.1.1.5	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cache/ftcimage.c	Thu Jun 20 04:16:15 2002
@@ -24,10 +24,7 @@
 
 #include "ftcerror.h"
 
-#include <string.h>     /* memcmp() */
-#include <stdlib.h>     /* labs()   */
 
-
   /* the FT_Glyph image node type */
   typedef struct  FTC_ImageNodeRec_
   {
@@ -326,12 +323,10 @@
     FTC_ImageNode      node;
     FT_Error           error;
 
-
-    /* some argument checks are delayed to ftc_glyph_cache_lookup */
-    if ( aglyph )
-      *aglyph = NULL;
 
-    *aglyph = NULL;
+    /* some argument checks are delayed to ftc_cache_lookup */
+    if ( !aglyph )
+      return FTC_Err_Invalid_Argument;
 
     if ( anode )
       *anode  = NULL;
@@ -377,7 +372,7 @@
 
 
     if ( !desc )
-      return FT_Err_Invalid_Argument;
+      return FTC_Err_Invalid_Argument;
 
     desc0.font = desc->font;
     desc0.type = (FT_UInt32)desc->image_type;
Index: xc/extras/freetype2/src/cache/ftcmanag.c
diff -u xc/extras/freetype2/src/cache/ftcmanag.c:1.1.1.5 xc/extras/freetype2/src/cache/ftcmanag.c:1.1.1.6
--- xc/extras/freetype2/src/cache/ftcmanag.c:1.1.1.5	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cache/ftcmanag.c	Thu Jun 20 04:16:15 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType Cache Manager (body).                                       */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -336,7 +336,7 @@
   ftc_family_table_done( FTC_FamilyTable  table,
                          FT_Memory        memory )
   {
-    FREE( table->entries );
+    FT_FREE( table->entries );
     table->free  = 0;
     table->count = 0;
     table->size  = 0;
@@ -356,7 +356,7 @@
     if ( table->free == FTC_FAMILY_ENTRY_NONE && table->count >= table->size )
     {
       FT_UInt  old_size = table->size;
-      FT_UInt  new_size, index;
+      FT_UInt  new_size, idx;
 
 
       if ( old_size == 0 )
@@ -370,8 +370,7 @@
           new_size = 65534;
       }
 
-      if ( REALLOC_ARRAY( table->entries, old_size, new_size,
-                          FTC_FamilyEntryRec ) )
+      if ( FT_RENEW_ARRAY( table->entries, old_size, new_size ) )
         return error;
 
       table->size = new_size;
@@ -379,14 +378,14 @@
       entry       = table->entries + old_size;
       table->free = old_size;
 
-      for ( index = old_size; index + 1 < new_size; index++, entry++ )
+      for ( idx = old_size; idx + 1 < new_size; idx++, entry++ )
       {
-        entry->link  = index + 1;
-        entry->index = index;
+        entry->link  = idx + 1;
+        entry->index = idx;
       }
 
       entry->link  = FTC_FAMILY_ENTRY_NONE;
-      entry->index = index;
+      entry->index = idx;
     }
 
     if ( table->free != FTC_FAMILY_ENTRY_NONE )
@@ -401,7 +400,7 @@
     else
     {
       FT_ERROR(( "ftc_family_table_alloc: internal bug!" ));
-      return FT_Err_Invalid_Argument;
+      return FTC_Err_Invalid_Argument;
     }
 
     entry->link = FTC_FAMILY_ENTRY_NONE;
@@ -414,12 +413,12 @@
 
   FT_EXPORT_DEF( void )
   ftc_family_table_free( FTC_FamilyTable  table,
-                         FT_UInt          index )
+                         FT_UInt          idx )
   {
     /* simply add it to the linked list of free entries */
-    if ( index < table->count )
+    if ( idx < table->count )
     {
-      FTC_FamilyEntry  entry = table->entries + index;
+      FTC_FamilyEntry  entry = table->entries + idx;
 
 
       if ( entry->link != FTC_FAMILY_ENTRY_NONE )
@@ -464,7 +463,7 @@
 
     memory = library->memory;
 
-    if ( ALLOC( manager, sizeof ( *manager ) ) )
+    if ( FT_NEW( manager ) )
       goto Exit;
 
     if ( max_faces == 0 )
@@ -508,7 +507,7 @@
     {
       FT_LruList_Destroy( manager->faces_list );
       FT_LruList_Destroy( manager->sizes_list );
-      FREE( manager );
+      FT_FREE( manager );
     }
 
     return error;
@@ -521,7 +520,7 @@
   FTC_Manager_Done( FTC_Manager  manager )
   {
     FT_Memory  memory;
-    FT_UInt    index;
+    FT_UInt    idx;
 
 
     if ( !manager || !manager->library )
@@ -530,16 +529,16 @@
     memory = manager->library->memory;
 
     /* now discard all caches */
-    for (index = 0; index < FTC_MAX_CACHES; index++ )
+    for (idx = 0; idx < FTC_MAX_CACHES; idx++ )
     {
-      FTC_Cache  cache = manager->caches[index];
+      FTC_Cache  cache = manager->caches[idx];
 
 
       if ( cache )
       {
         cache->clazz->cache_done( cache );
-        FREE( cache );
-        manager->caches[index] = 0;
+        FT_FREE( cache );
+        manager->caches[idx] = 0;
       }
     }
 
@@ -553,7 +552,7 @@
     FT_LruList_Destroy( manager->sizes_list );
     manager->sizes_list = 0;
 
-    FREE( manager );
+    FT_FREE( manager );
   }
 
 
@@ -697,18 +696,18 @@
     if ( manager && clazz && acache )
     {
       FT_Memory  memory = manager->library->memory;
-      FT_UInt    index  = 0;
+      FT_UInt    idx  = 0;
 
 
       /* check for an empty cache slot in the manager's table */
-      for ( index = 0; index < FTC_MAX_CACHES; index++ )
+      for ( idx = 0; idx < FTC_MAX_CACHES; idx++ )
       {
-        if ( manager->caches[index] == 0 )
+        if ( manager->caches[idx] == 0 )
           break;
       }
 
       /* return an error if there are too many registered caches */
-      if ( index >= FTC_MAX_CACHES )
+      if ( idx >= FTC_MAX_CACHES )
       {
         error = FTC_Err_Too_Many_Caches;
         FT_ERROR(( "FTC_Manager_Register_Cache:" ));
@@ -716,7 +715,7 @@
         goto Exit;
       }
 
-      if ( !ALLOC( cache, clazz->cache_size ) )
+      if ( !FT_ALLOC( cache, clazz->cache_size ) )
       {
         cache->manager = manager;
         cache->memory  = memory;
@@ -724,7 +723,7 @@
 
         /* THIS IS VERY IMPORTANT!  IT WILL WRETCH THE MANAGER */
         /* IF IT IS NOT SET CORRECTLY                          */
-        cache->cache_index = index;
+        cache->cache_index = idx;
 
         if ( clazz->cache_init )
         {
@@ -734,12 +733,12 @@
             if ( clazz->cache_done )
               clazz->cache_done( cache );
 
-            FREE( cache );
+            FT_FREE( cache );
             goto Exit;
           }
         }
 
-        manager->caches[index] = cache;
+        manager->caches[idx] = cache;
       }
     }
 
Index: xc/extras/freetype2/src/cache/ftcsbits.c
diff -u xc/extras/freetype2/src/cache/ftcsbits.c:1.1.1.5 xc/extras/freetype2/src/cache/ftcsbits.c:1.1.1.6
--- xc/extras/freetype2/src/cache/ftcsbits.c:1.1.1.5	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cache/ftcsbits.c	Thu Jun 20 04:16:15 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType sbits manager (body).                                       */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -26,9 +26,7 @@
 
 #include "ftcerror.h"
 
-#include <string.h>         /* memcmp() */
 
-
 #define FTC_SBIT_ITEMS_PER_NODE  16
 
 
@@ -65,8 +63,8 @@
     FTC_ImageDesc       desc;
 
   } FTC_SBitFamilyRec;
- 
-  
+
+
 #define FTC_SBIT_FAMILY( x )         ( (FTC_SBitFamily)( x ) )
 #define FTC_SBIT_FAMILY_MEMORY( x )  FTC_GLYPH_FAMILY_MEMORY( &( x )->cset )
 
@@ -95,8 +93,8 @@
 
     size = (FT_ULong)( pitch * bitmap->rows );
 
-    if ( !ALLOC( sbit->buffer, size ) )
-      MEM_Copy( sbit->buffer, bitmap->buffer, size );
+    if ( !FT_ALLOC( sbit->buffer, size ) )
+      FT_MEM_COPY( sbit->buffer, bitmap->buffer, size );
 
     return error;
   }
@@ -112,7 +110,7 @@
 
 
     for ( ; count > 0; sbit++, count-- )
-      FREE( sbit->buffer );
+      FT_FREE( sbit->buffer );
 
     ftc_glyph_node_done( FTC_GLYPH_NODE( snode ), cache );
   }
@@ -215,19 +213,26 @@
              CHECK_CHAR( xadvance )          &&
              CHECK_CHAR( yadvance )          )
         {
-          sbit->width    = (FT_Byte)bitmap->width;
-          sbit->height   = (FT_Byte)bitmap->rows;
-          sbit->pitch    = (FT_Char)bitmap->pitch;
-          sbit->left     = (FT_Char)slot->bitmap_left;
-          sbit->top      = (FT_Char)slot->bitmap_top;
-          sbit->xadvance = (FT_Char)xadvance;
-          sbit->yadvance = (FT_Char)yadvance;
-          sbit->format   = (FT_Byte)bitmap->pixel_mode;
+          sbit->width     = (FT_Byte)bitmap->width;
+          sbit->height    = (FT_Byte)bitmap->rows;
+          sbit->pitch     = (FT_Char)bitmap->pitch;
+          sbit->left      = (FT_Char)slot->bitmap_left;
+          sbit->top       = (FT_Char)slot->bitmap_top;
+          sbit->xadvance  = (FT_Char)xadvance;
+          sbit->yadvance  = (FT_Char)yadvance;
+          sbit->format    = (FT_Byte)bitmap->pixel_mode;
+          /* XXX: Fixme: We don't handle the number of gray levels      */
+          /*             consistently -- we say num_grays == 1 for      */
+          /*             monochrome but num_grays == 256 for gray.  It  */
+          /*             would be better to make this variable hold the */
+          /*             highest possible value so that it fits into    */
+          /*             a single byte.                                 */
+          sbit->num_grays = bitmap->num_grays;
 
-          /* grab the bitmap when possible - this is a hack !! */
-          if ( slot->flags & ft_glyph_own_bitmap )
+          /* grab the bitmap when possible - this is a hack! */
+          if ( slot->flags & FT_GLYPH_OWN_BITMAP )
           {
-            slot->flags &= ~ft_glyph_own_bitmap;
+            slot->flags &= ~FT_GLYPH_OWN_BITMAP;
             sbit->buffer = bitmap->buffer;
           }
           else
@@ -457,6 +462,23 @@
 
   /* documentation is in ftcsbits.h */
 
+#ifdef FTC_CACHE_USE_INLINE
+
+#define GEN_CACHE_FAMILY_COMPARE( f, q, c ) \
+          ftc_sbit_family_compare( (FTC_SBitFamily)(f), (FTC_SBitQuery)(q) )
+
+#define GEN_CACHE_NODE_COMPARE( n, q, c ) \
+          ftc_sbit_node_compare( (FTC_SBitNode)(n), (FTC_SBitQuery)(q), c )
+
+#define GEN_CACHE_LOOKUP  ftc_sbit_cache_lookup
+#include "ftccache.i"
+
+#else  /* !FTC_CACHE_USE_INLINE */
+
+#define ftc_sbit_cache_lookup  ftc_cache_lookup
+
+#endif /* !FTC_CACHE_USE_INLINE */
+
   FT_EXPORT_DEF( FT_Error )
   FTC_SBitCache_Lookup( FTC_SBitCache   cache,
                         FTC_ImageDesc*  desc,
@@ -481,9 +503,9 @@
     squery.gquery.gindex = gindex;
     squery.desc          = *desc;
 
-    error = ftc_cache_lookup( FTC_CACHE( cache ),
-                              FTC_QUERY( &squery ),
-                              (FTC_Node*)&node );
+    error = ftc_sbit_cache_lookup( FTC_CACHE( cache ),
+                                   FTC_QUERY( &squery ),
+                                   (FTC_Node*)&node );
     if ( !error )
     {
       *ansbit = node->sbits + ( gindex - FTC_GLYPH_NODE( node )->item_start );
@@ -515,11 +537,11 @@
                          FTC_SBit        *ansbit )
   {
     FTC_ImageDesc  desc0;
-    
 
+
     if ( !desc )
-      return FT_Err_Invalid_Argument;
-      
+      return FTC_Err_Invalid_Argument;
+
     desc0.font = desc->font;
     desc0.type = (FT_UInt32)desc->image_type;
 
Index: xc/extras/freetype2/src/cache/ftlru.c
diff -u xc/extras/freetype2/src/cache/ftlru.c:1.1.1.5 xc/extras/freetype2/src/cache/ftlru.c:1.1.1.6
--- xc/extras/freetype2/src/cache/ftlru.c:1.1.1.5	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cache/ftlru.c	Thu Jun 20 04:16:16 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Simple LRU list-cache (body).                                        */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -40,7 +40,7 @@
       return FTC_Err_Invalid_Argument;
 
     *alist = NULL;
-    if ( !ALLOC( list, clazz->list_size ) )
+    if ( !FT_ALLOC( list, clazz->list_size ) )
     {
       /* initialize common fields */
       list->clazz      = clazz;
@@ -56,7 +56,7 @@
           if ( clazz->list_done )
             clazz->list_done( list );
 
-          FREE( list );
+          FT_FREE( list );
         }
       }
 
@@ -85,7 +85,7 @@
     if ( clazz->list_done )
       clazz->list_done( list );
 
-    FREE( list );
+    FT_FREE( list );
   }
 
 
@@ -112,7 +112,7 @@
       if ( clazz->node_done )
         clazz->node_done( node, list->data );
 
-      FREE( node );
+      FT_FREE( node );
       node = next;
     }
 
@@ -233,20 +233,20 @@
         *plast = NULL;
         list->num_nodes--;
 
-        FREE( last );
+        FT_FREE( last );
         goto Exit;
       }
     }
 
     /* otherwise, simply allocate a new node */
-    if ( ALLOC( node, clazz->node_size ) )
+    if ( FT_ALLOC( node, clazz->node_size ) )
       goto Exit;
 
     node->key = key;
     error = clazz->node_init( node, key, list->data );
     if ( error )
     {
-      FREE( node );
+      FT_FREE( node );
       goto Exit;
     }
 
@@ -286,7 +286,7 @@
         if ( clazz->node_done )
           clazz->node_done( node, list->data );
 
-        FREE( node );
+        FT_FREE( node );
         list->num_nodes--;
         break;
       }
@@ -327,7 +327,7 @@
         if ( clazz->node_done )
           clazz->node_done( node, list );
 
-        FREE( node );
+        FT_FREE( node );
       }
       else
         pnode = &(*pnode)->next;
Index: xc/extras/freetype2/src/cache/rules.mk
diff -u xc/extras/freetype2/src/cache/rules.mk:1.1.1.4 xc/extras/freetype2/src/cache/rules.mk:1.1.1.5
--- xc/extras/freetype2/src/cache/rules.mk:1.1.1.4	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cache/rules.mk	Thu Jun 20 04:16:16 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2000 by
+# Copyright 2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/cff/cffdrivr.c
diff -u xc/extras/freetype2/src/cff/cffdrivr.c:1.1.1.4 xc/extras/freetype2/src/cff/cffdrivr.c:1.1.1.7
--- xc/extras/freetype2/src/cff/cffdrivr.c:1.1.1.4	Mon Jan 14 11:52:11 2002
+++ xc/extras/freetype2/src/cff/cffdrivr.c	Thu Jun 20 04:16:16 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType font driver implementation (body).                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -22,6 +22,7 @@
 #include FT_INTERNAL_STREAM_H
 #include FT_INTERNAL_SFNT_H
 #include FT_TRUETYPE_IDS_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
 
 #include "cffdrivr.h"
 #include "cffgload.h"
@@ -96,7 +97,7 @@
                FT_UInt     right_glyph,
                FT_Vector*  kerning )
   {
-    TT_Kern_0_Pair*  pair;
+    TT_Kern0_Pair  pair;
 
 
     if ( !face )
@@ -227,21 +228,22 @@
                       FT_Pointer  buffer,
                       FT_UInt     buffer_max )
   {
-    CFF_Font*           font   = (CFF_Font*)face->extra.data;
-    FT_Memory           memory = FT_FACE_MEMORY(face);
-    FT_String*          gname;
-    FT_UShort           sid;
-    PSNames_Interface*  psnames;
-    FT_Error            error;
+    CFF_Font         font   = (CFF_Font)face->extra.data;
+    FT_Memory        memory = FT_FACE_MEMORY( face );
+    FT_String*       gname;
+    FT_UShort        sid;
+    PSNames_Service  psnames;
+    FT_Error         error;
 
-    psnames = (PSNames_Interface*)FT_Get_Module_Interface(
+
+    psnames = (PSNames_Service)FT_Get_Module_Interface(
                 face->root.driver->root.library, "psnames" );
 
     if ( !psnames )
     {
-      FT_ERROR(( "CFF_Init_Face:" ));
+      FT_ERROR(( "cff_get_glyph_name:" ));
       FT_ERROR(( " cannot open CFF & CEF fonts\n" ));
-      FT_ERROR(( "             " ));
+      FT_ERROR(( "                   " ));
       FT_ERROR(( " without the `PSNames' module\n" ));
       error = CFF_Err_Unknown_File_Format;
       goto Exit;
@@ -255,17 +257,17 @@
 
     if ( buffer_max > 0 )
     {
-      FT_UInt  len = strlen( gname );
+      FT_UInt  len = ft_strlen( gname );
 
 
       if ( len >= buffer_max )
         len = buffer_max - 1;
 
-      MEM_Copy( buffer, gname, len );
+      FT_MEM_COPY( buffer, gname, len );
       ((FT_Byte*)buffer)[len] = 0;
     }
 
-    FREE ( gname );
+    FT_FREE ( gname );
     error = CFF_Err_Ok;
 
     Exit:
@@ -292,9 +294,9 @@
   cff_get_char_index( TT_CharMap  charmap,
                       FT_Long     charcode )
   {
-    FT_Error       error;
-    CFF_Face       face;
-    TT_CMapTable*  cmap;
+    FT_Error      error;
+    CFF_Face      face;
+    TT_CMapTable  cmap;
 
 
     cmap = &charmap->cmap;
@@ -303,7 +305,7 @@
     /* Load table if needed */
     if ( !cmap->loaded )
     {
-      SFNT_Interface*  sfnt = (SFNT_Interface*)face->sfnt;
+      SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
 
 
       error = sfnt->load_charmap( face, cmap, face->root.stream );
@@ -320,6 +322,51 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    cff_get_next_char                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return the next encoded charcode.                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Char code.  0 means `no encoded chars above the given one'.        */
+  /*                                                                       */
+  static FT_Long
+  cff_get_next_char( TT_CharMap  charmap,
+                     FT_Long     charcode )
+  {
+    FT_Error      error;
+    CFF_Face      face;
+    TT_CMapTable  cmap;
+
+
+    cmap = &charmap->cmap;
+    face = (CFF_Face)charmap->root.face;
+
+    /* Load table if needed */
+    if ( !cmap->loaded )
+    {
+      SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
+
+
+      error = sfnt->load_charmap( face, cmap, face->root.stream );
+      if ( error )
+        return 0;
+
+      cmap->loaded = TRUE;
+    }
+
+    return ( cmap->get_next_char ? cmap->get_next_char( cmap, charcode )
+                                 : 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    cff_get_name_index                                                 */
   /*                                                                       */
   /* <Description>                                                         */
@@ -338,18 +385,20 @@
   cff_get_name_index( CFF_Face    face,
                       FT_String*  glyph_name )
   {
-    CFF_Font*           cff;
-    CFF_Charset*        charset;
-    PSNames_Interface*  psnames;
-    FT_String*          name;
-    FT_UShort           sid;
-    FT_UInt             i;
+    CFF_Font         cff;
+    CFF_Charset      charset;
+    PSNames_Service  psnames;
+    FT_Memory        memory = FT_FACE_MEMORY( face );
+    FT_String*       name;
+    FT_UShort        sid;
+    FT_UInt          i;
+    FT_Int           result;
 
 
-    cff     = face->extra.data;
+    cff     = (CFF_FontRec *)face->extra.data;
     charset = &cff->charset;
 
-    psnames = (PSNames_Interface*)FT_Get_Module_Interface(
+    psnames = (PSNames_Service)FT_Get_Module_Interface(
                 face->root.driver->root.library, "psnames" );
 
     for ( i = 0; i < cff->num_glyphs; i++ )
@@ -360,8 +409,13 @@
         name = CFF_Get_Name( &cff->string_index, sid - 391 );
       else
         name = (FT_String *)psnames->adobe_std_strings( sid );
+
+      result = ft_strcmp( glyph_name, name );
 
-      if ( !strcmp( glyph_name, name ) )
+      if ( sid > 390 )
+        FT_FREE( name );
+
+      if ( !result )
         return i;
     }
 
@@ -383,16 +437,17 @@
 
   static FT_Module_Interface
   cff_get_interface( CFF_Driver   driver,
-                     const char*  interface )
+                     const char*  module_interface )
   {
     FT_Module  sfnt;
 
+
 #ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
 
-    if ( strcmp( (const char*)interface, "glyph_name" ) == 0 )
+    if ( ft_strcmp( (const char*)module_interface, "glyph_name" ) == 0 )
       return (FT_Module_Interface)cff_get_glyph_name;
 
-    if ( strcmp( (const char*)interface, "name_index" ) == 0 )
+    if ( ft_strcmp( (const char*)module_interface, "name_index" ) == 0 )
       return (FT_Module_Interface)cff_get_name_index;
 
 #endif
@@ -400,14 +455,14 @@
     /* we simply pass our request to the `sfnt' module */
     sfnt = FT_Get_Module( driver->root.root.library, "sfnt" );
 
-    return sfnt ? sfnt->clazz->get_interface( sfnt, interface ) : 0;
+    return sfnt ? sfnt->clazz->get_interface( sfnt, module_interface ) : 0;
   }
 
 
   /* The FT_DriverInterface structure is defined in ftdriver.h. */
 
   FT_CALLBACK_TABLE_DEF
-  const FT_Driver_Class  cff_driver_class =
+  const FT_Driver_ClassRec  cff_driver_class =
   {
     /* begin with the FT_Module_Class fields */
     {
@@ -432,55 +487,25 @@
     sizeof( FT_SizeRec ),
     sizeof( CFF_GlyphSlotRec ),
 
-    (FTDriver_initFace)     CFF_Face_Init,
-    (FTDriver_doneFace)     CFF_Face_Done,
-    (FTDriver_initSize)     CFF_Size_Init,
-    (FTDriver_doneSize)     CFF_Size_Done,
-    (FTDriver_initGlyphSlot)CFF_GlyphSlot_Init,
-    (FTDriver_doneGlyphSlot)CFF_GlyphSlot_Done,
-
-    (FTDriver_setCharSizes) CFF_Size_Reset,
-    (FTDriver_setPixelSizes)CFF_Size_Reset,
-
-    (FTDriver_loadGlyph)    Load_Glyph,
-    (FTDriver_getCharIndex) cff_get_char_index,
-
-    (FTDriver_getKerning)   Get_Kerning,
-    (FTDriver_attachFile)   0,
-    (FTDriver_getAdvances)  0
+    (FT_Face_InitFunc)        CFF_Face_Init,
+    (FT_Face_DoneFunc)        CFF_Face_Done,
+    (FT_Size_InitFunc)        CFF_Size_Init,
+    (FT_Size_DoneFunc)        CFF_Size_Done,
+    (FT_Slot_InitFunc)        CFF_GlyphSlot_Init,
+    (FT_Slot_DoneFunc)        CFF_GlyphSlot_Done,
+
+    (FT_Size_ResetPointsFunc) CFF_Size_Reset,
+    (FT_Size_ResetPixelsFunc) CFF_Size_Reset,
+
+    (FT_Slot_LoadFunc)        Load_Glyph,
+    (FT_CharMap_CharIndexFunc)cff_get_char_index,
+
+    (FT_Face_GetKerningFunc)  Get_Kerning,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0,
+    
+    (FT_CharMap_CharNextFunc) cff_get_next_char
   };
-
-
-#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    getDriverClass                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    This function is used when compiling the TrueType driver as a      */
-  /*    shared library (`.DLL' or `.so').  It will be used by the          */
-  /*    high-level library of FreeType to retrieve the address of the      */
-  /*    driver's generic interface.                                        */
-  /*                                                                       */
-  /*    It shouldn't be implemented in a static build, as each driver must */
-  /*    have the same function as an exported entry point.                 */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The address of the TrueType's driver generic interface.  The       */
-  /*    format-specific interface can then be retrieved through the method */
-  /*    interface->get_format_interface.                                   */
-  /*                                                                       */
-  FT_EXPORT_DEF( const FT_Driver_Class* )
-  getDriverClass( void )
-  {
-    return &cff_driver_class;
-  }
-
-
-#endif /* CONFIG_OPTION_DYNAMIC_DRIVERS */
 
 
 /* END */
Index: xc/extras/freetype2/src/cff/cffdrivr.h
diff -u xc/extras/freetype2/src/cff/cffdrivr.h:1.1.1.2 xc/extras/freetype2/src/cff/cffdrivr.h:1.1.1.3
--- xc/extras/freetype2/src/cff/cffdrivr.h:1.1.1.2	Sun Dec 16 12:49:28 2001
+++ xc/extras/freetype2/src/cff/cffdrivr.h	Thu Jun 20 04:16:16 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    High-level OpenType driver interface (specification).                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -28,7 +28,7 @@
 
 
   FT_CALLBACK_TABLE
-  const FT_Driver_Class  cff_driver_class;
+  const FT_Driver_ClassRec  cff_driver_class;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/cff/cffgload.c
diff -u xc/extras/freetype2/src/cff/cffgload.c:1.1.1.4 xc/extras/freetype2/src/cff/cffgload.c:1.1.1.5
--- xc/extras/freetype2/src/cff/cffgload.c:1.1.1.4	Mon Jan 14 11:52:12 2002
+++ xc/extras/freetype2/src/cff/cffgload.c	Thu Jun 20 04:16:16 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType Glyph Loader (body).                                        */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -238,7 +238,7 @@
 
     if ( glyph )
     {
-      FT_GlyphLoader*  loader = glyph->root.internal->loader;
+      FT_GlyphLoader  loader = glyph->root.internal->loader;
 
 
       builder->loader  = loader;
@@ -248,7 +248,7 @@
 
       builder->hints_globals = 0;
       builder->hints_funcs   = 0;
-            
+
       if ( hinting && size )
       {
         builder->hints_globals = size->internal;
@@ -345,18 +345,18 @@
   /*                                                                       */
   /*    slot    :: The current glyph object.                               */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CFF_Init_Decoder( CFF_Decoder*   decoder,
                     TT_Face        face,
                     CFF_Size       size,
                     CFF_GlyphSlot  slot,
                     FT_Bool        hinting )
   {
-    CFF_Font*  cff = (CFF_Font*)face->extra.data;
+    CFF_Font  cff = (CFF_Font)face->extra.data;
 
 
     /* clear everything */
-    MEM_Set( decoder, 0, sizeof ( *decoder ) );
+    FT_MEM_SET( decoder, 0, sizeof ( *decoder ) );
 
     /* initialize builder */
     CFF_Builder_Init( &decoder->builder, face, size, slot, hinting );
@@ -369,12 +369,12 @@
 
 
   /* this function is used to select the locals subrs array */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CFF_Prepare_Decoder( CFF_Decoder*  decoder,
                        FT_UInt       glyph_index )
   {
-    CFF_Font*     cff = (CFF_Font*)decoder->builder.face->extra.data;
-    CFF_SubFont*  sub = &cff->top_font;
+    CFF_Font     cff = (CFF_Font)decoder->builder.face->extra.data;
+    CFF_SubFont  sub = &cff->top_font;
 
 
     /* manage CID fonts */
@@ -400,7 +400,7 @@
   check_points( CFF_Builder*  builder,
                 FT_Int        count )
   {
-    return FT_GlyphLoader_Check_Points( builder->loader, count, 0 );
+    return FT_GlyphLoader_CheckPoints( builder->loader, count, 0 );
   }
 
 
@@ -426,6 +426,7 @@
 
       builder->last = *point;
     }
+
     outline->n_points++;
   }
 
@@ -461,7 +462,7 @@
       return CFF_Err_Ok;
     }
 
-    error = FT_GlyphLoader_Check_Points( builder->loader, 0, 1 );
+    error = FT_GlyphLoader_CheckPoints( builder->loader, 0, 1 );
     if ( !error )
     {
       if ( outline->n_contours > 0 )
@@ -492,6 +493,7 @@
       if ( !error )
         error = add_point1( builder, x, y );
     }
+
     return error;
   }
 
@@ -502,6 +504,7 @@
   {
     FT_Outline*  outline = builder->current;
 
+
     /* XXXX: We must not include the last point in the path if it */
     /*       is located on the first point.                       */
     if ( outline->n_points > 1 )
@@ -518,8 +521,8 @@
         p1    = outline->points + first;
       }
 
-      /* `delete' last point only if it coincides with the first */
-      /* point and it is not a control point (which can happen). */
+      /* `delete' last point only if it coincides with the first    */
+      /* point and if it is not a control point (which can happen). */
       if ( p1->x == p2->x && p1->y == p2->y )
         if ( *control == FT_Curve_Tag_On )
           outline->n_points--;
@@ -532,8 +535,8 @@
 
 
   static FT_Int
-  cff_lookup_glyph_by_stdcharcode( CFF_Font*  cff,
-                                   FT_Int     charcode )
+  cff_lookup_glyph_by_stdcharcode( CFF_Font  cff,
+                                   FT_Int    charcode )
   {
     FT_UInt    n;
     FT_UShort  glyph_sid;
@@ -567,7 +570,7 @@
     FT_Int       bchar_index, achar_index, n_base_points;
     FT_Outline*  base = decoder->builder.base;
     TT_Face      face = decoder->builder.face;
-    CFF_Font*    cff  = (CFF_Font*)(face->extra.data);
+    CFF_Font     cff  = (CFF_Font)(face->extra.data);
     FT_Vector    left_bearing, advance;
     FT_Byte*     charstring;
     FT_ULong     charstring_len;
@@ -587,13 +590,13 @@
     /* accent character and return the array of subglyphs.         */
     if ( decoder->builder.no_recurse )
     {
-      FT_GlyphSlot     glyph  = (FT_GlyphSlot)decoder->builder.glyph;
-      FT_GlyphLoader*  loader = glyph->internal->loader;
-      FT_SubGlyph*     subg;
+      FT_GlyphSlot    glyph  = (FT_GlyphSlot)decoder->builder.glyph;
+      FT_GlyphLoader  loader = glyph->internal->loader;
+      FT_SubGlyph     subg;
 
 
       /* reallocate subglyph array if necessary */
-      error = FT_GlyphLoader_Check_Subglyphs( loader, 2 );
+      error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
       if ( error )
         goto Exit;
 
@@ -699,7 +702,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Parse_CharStrings( CFF_Decoder*  decoder,
                          FT_Byte*      charstring_base,
                          FT_Int        charstring_len )
@@ -1091,7 +1094,7 @@
         case cff_op_hintmask:
         case cff_op_cntrmask:
           FT_TRACE4(( op == cff_op_hintmask ? " hintmask" : " cntrmask" ));
-  
+
           /* implement vstem when needed --                        */
           /* the specification doesn't say it, but this also works */
           /* with the 'cntrmask' operator                          */
@@ -1103,7 +1106,7 @@
                              0,
                              num_args / 2,
                              args );
-          
+
             decoder->num_hints += num_args / 2;
           }
 
@@ -1124,15 +1127,13 @@
           {
             FT_UInt maskbyte;
 
+
             FT_TRACE4(( " " ));
 
             for ( maskbyte = 0;
                   maskbyte < (FT_UInt)(( decoder->num_hints + 7 ) >> 3);
                   maskbyte++, ip++ )
-            {
               FT_TRACE4(( "%02X", *ip ));
-            }
-
           }
 #else
           ip += ( decoder->num_hints + 7 ) >> 3;
@@ -1723,16 +1724,16 @@
 
         case cff_op_random:
           {
-            FT_Fixed  rand;
+            FT_Fixed  Rand;
 
 
             FT_TRACE4(( " rand" ));
 
-            rand = seed;
-            if ( rand >= 0x8000 )
-              rand++;
+            Rand = seed;
+            if ( Rand >= 0x8000 )
+              Rand++;
 
-            args[0] = rand;
+            args[0] = Rand;
             seed    = FT_MulFix( seed, 0x10000L - seed );
             if ( seed == 0 )
               seed += 0x2873;
@@ -1793,16 +1794,16 @@
 
         case cff_op_index:
           {
-            FT_Int  index = args[0] >> 16;
+            FT_Int  idx = args[0] >> 16;
 
 
             FT_TRACE4(( " index" ));
 
-            if ( index < 0 )
-              index = 0;
-            else if ( index > num_args - 2 )
-              index = num_args - 2;
-            args[0] = args[-( index + 1 )];
+            if ( idx < 0 )
+              idx = 0;
+            else if ( idx > num_args - 2 )
+              idx = num_args - 2;
+            args[0] = args[-( idx + 1 )];
             args++;
           }
           break;
@@ -1810,7 +1811,7 @@
         case cff_op_roll:
           {
             FT_Int  count = (FT_Int)( args[0] >> 16 );
-            FT_Int  index = (FT_Int)( args[1] >> 16 );
+            FT_Int  idx   = (FT_Int)( args[1] >> 16 );
 
 
             FT_TRACE4(( " roll" ));
@@ -1822,9 +1823,9 @@
             if ( args < stack )
               goto Stack_Underflow;
 
-            if ( index >= 0 )
+            if ( idx >= 0 )
             {
-              while ( index > 0 )
+              while ( idx > 0 )
               {
                 FT_Fixed  tmp = args[count - 1];
                 FT_Int    i;
@@ -1833,12 +1834,12 @@
                 for ( i = count - 2; i >= 0; i-- )
                   args[i + 1] = args[i];
                 args[0] = tmp;
-                index--;
+                idx--;
               }
             }
             else
             {
-              while ( index < 0 )
+              while ( idx < 0 )
               {
                 FT_Fixed  tmp = args[0];
                 FT_Int    i;
@@ -1847,7 +1848,7 @@
                 for ( i = 0; i < count - 1; i++ )
                   args[i] = args[i + 1];
                 args[count - 1] = tmp;
-                index++;
+                idx++;
               }
             }
             args += count;
@@ -1863,27 +1864,27 @@
 
         case cff_op_put:
           {
-            FT_Fixed  val   = args[0];
-            FT_Int    index = (FT_Int)( args[1] >> 16 );
+            FT_Fixed  val = args[0];
+            FT_Int    idx = (FT_Int)( args[1] >> 16 );
 
 
             FT_TRACE4(( " put" ));
 
-            if ( index >= 0 && index < decoder->len_buildchar )
-              decoder->buildchar[index] = val;
+            if ( idx >= 0 && idx < decoder->len_buildchar )
+              decoder->buildchar[idx] = val;
           }
           break;
 
         case cff_op_get:
           {
-            FT_Int   index = (FT_Int)( args[0] >> 16 );
-            FT_Fixed val   = 0;
+            FT_Int    idx = (FT_Int)( args[0] >> 16 );
+            FT_Fixed  val = 0;
 
 
             FT_TRACE4(( " get" ));
 
-            if ( index >= 0 && index < decoder->len_buildchar )
-              val = decoder->buildchar[index];
+            if ( idx >= 0 && idx < decoder->len_buildchar )
+              val = decoder->buildchar[idx];
 
             args[0] = val;
             args++;
@@ -1956,13 +1957,13 @@
 
         case cff_op_callsubr:
           {
-            FT_UInt  index = (FT_UInt)( ( args[0] >> 16 ) +
-                                        decoder->locals_bias );
+            FT_UInt  idx = (FT_UInt)( ( args[0] >> 16 ) +
+                                      decoder->locals_bias );
 
 
-            FT_TRACE4(( " callsubr(%d)", index ));
+            FT_TRACE4(( " callsubr(%d)", idx ));
 
-            if ( index >= decoder->num_locals )
+            if ( idx >= decoder->num_locals )
             {
               FT_ERROR(( "CFF_Parse_CharStrings:" ));
               FT_ERROR(( "  invalid local subr index\n" ));
@@ -1978,8 +1979,8 @@
             zone->cursor = ip;  /* save current instruction pointer */
 
             zone++;
-            zone->base   = decoder->locals[index];
-            zone->limit  = decoder->locals[index + 1];
+            zone->base   = decoder->locals[idx];
+            zone->limit  = decoder->locals[idx + 1];
             zone->cursor = zone->base;
 
             if ( !zone->base )
@@ -1996,13 +1997,13 @@
 
         case cff_op_callgsubr:
           {
-            FT_UInt  index = (FT_UInt)( ( args[0] >> 16 ) +
-                                        decoder->globals_bias );
+            FT_UInt  idx = (FT_UInt)( ( args[0] >> 16 ) +
+                                      decoder->globals_bias );
 
 
-            FT_TRACE4(( " callgsubr(%d)", index ));
+            FT_TRACE4(( " callgsubr(%d)", idx ));
 
-            if ( index >= decoder->num_globals )
+            if ( idx >= decoder->num_globals )
             {
               FT_ERROR(( "CFF_Parse_CharStrings:" ));
               FT_ERROR(( " invalid global subr index\n" ));
@@ -2018,8 +2019,8 @@
             zone->cursor = ip;  /* save current instruction pointer */
 
             zone++;
-            zone->base   = decoder->globals[index];
-            zone->limit  = decoder->globals[index+1];
+            zone->base   = decoder->globals[idx];
+            zone->limit  = decoder->globals[idx + 1];
             zone->cursor = zone->base;
 
             if ( !zone->base )
@@ -2108,14 +2109,14 @@
 #if 0 /* unused until we support pure CFF fonts */
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Compute_Max_Advance( TT_Face  face,
                            FT_Int*  max_advance )
   {
     FT_Error     error = 0;
     CFF_Decoder  decoder;
     FT_Int       glyph_index;
-    CFF_Font*    cff = (CFF_Font*)face->other;
+    CFF_Font     cff = (CFF_Font)face->other;
 
 
     *max_advance = 0;
@@ -2175,7 +2176,7 @@
   /*************************************************************************/
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Load_Glyph( CFF_GlyphSlot  glyph,
                   CFF_Size       size,
                   FT_Int         glyph_index,
@@ -2185,7 +2186,7 @@
     CFF_Decoder  decoder;
     TT_Face      face = (TT_Face)glyph->root.face;
     FT_Bool      hinting;
-    CFF_Font*    cff = (CFF_Font*)face->extra.data;
+    CFF_Font     cff = (CFF_Font)face->extra.data;
 
     FT_Matrix    font_matrix;
     FT_Vector    font_offset;
@@ -2225,7 +2226,7 @@
                                   &charstring, &charstring_len );
       if ( !error )
       {
-        CFF_Index csindex = cff->charstrings_index;
+        CFF_IndexRec csindex = cff->charstrings_index;
 
 
         CFF_Prepare_Decoder( &decoder, glyph_index );
@@ -2329,8 +2330,8 @@
 
           if ( hinting )
           {
-            metrics->horiAdvance = ( metrics->horiAdvance + 32 ) & -64;
-            metrics->vertAdvance = ( metrics->vertAdvance + 32 ) & -64;
+            metrics->horiAdvance  = ( metrics->horiAdvance + 32 ) & -64;
+            metrics->vertAdvance  = ( metrics->vertAdvance + 32 ) & -64;
 
             metrics->vertBearingX = ( metrics->vertBearingX + 32 ) & -64;
             metrics->vertBearingY = ( metrics->vertBearingY + 32 ) & -64;
Index: xc/extras/freetype2/src/cff/cffgload.h
diff -u xc/extras/freetype2/src/cff/cffgload.h:1.1.1.3 xc/extras/freetype2/src/cff/cffgload.h:1.1.1.4
--- xc/extras/freetype2/src/cff/cffgload.h:1.1.1.3	Mon Jan 14 11:52:12 2002
+++ xc/extras/freetype2/src/cff/cffgload.h	Thu Jun 20 04:16:16 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType Glyph Loader (specification).                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -41,79 +41,81 @@
   /*     A structure used during glyph loading to store its outline.       */
   /*                                                                       */
   /* <Fields>                                                              */
-  /*    memory       :: The current memory object.                         */
+  /*    memory        :: The current memory object.                        */
   /*                                                                       */
-  /*    face         :: The current face object.                           */
+  /*    face          :: The current face object.                          */
   /*                                                                       */
-  /*    glyph        :: The current glyph slot.                            */
+  /*    glyph         :: The current glyph slot.                           */
   /*                                                                       */
-  /*    current      :: The current glyph outline.                         */
+  /*    loader        :: The current glyph loader.                         */
   /*                                                                       */
-  /*    base         :: The base glyph outline.                            */
+  /*    base          :: The base glyph outline.                           */
   /*                                                                       */
-  /*    max_points   :: maximum points in builder outline                  */
+  /*    current       :: The current glyph outline.                        */
   /*                                                                       */
-  /*    max_contours :: Maximal number of contours in builder outline.     */
+  /*    last          :: The last point position.                          */
   /*                                                                       */
-  /*    last         :: The last point position.                           */
+  /*    scale_x       :: The horizontal scale (FUnits to sub-pixels).      */
   /*                                                                       */
-  /*    scale_x      :: The horizontal scale (FUnits to sub-pixels).       */
+  /*    scale_y       :: The vertical scale (FUnits to sub-pixels).        */
   /*                                                                       */
-  /*    scale_y      :: The vertical scale (FUnits to sub-pixels).         */
+  /*    pos_x         :: The horizontal translation (if composite glyph).  */
   /*                                                                       */
-  /*    pos_x        :: The horizontal translation (if composite glyph).   */
+  /*    pos_y         :: The vertical translation (if composite glyph).    */
   /*                                                                       */
-  /*    pos_y        :: The vertical translation (if composite glyph).     */
+  /*    left_bearing  :: The left side bearing point.                      */
   /*                                                                       */
-  /*    left_bearing :: The left side bearing point.                       */
+  /*    advance       :: The horizontal advance vector.                    */
   /*                                                                       */
-  /*    advance      :: The horizontal advance vector.                     */
+  /*    bbox          :: Unused.                                           */
   /*                                                                       */
-  /*    bbox         :: Unused.                                            */
+  /*    path_begun    :: A flag which indicates that a new path has begun. */
   /*                                                                       */
-  /*    path_begun   :: A flag which indicates that a new path has begun.  */
+  /*    load_points   :: If this flag is not set, no points are loaded.    */
   /*                                                                       */
-  /*    load_points  :: If this flag is not set, no points are loaded.     */
+  /*    no_recurse    :: Set but not used.                                 */
   /*                                                                       */
-  /*    no_recurse   :: Set but not used.                                  */
+  /*    error         :: An error code that is only used to report memory  */
+  /*                     allocation problems.                              */
   /*                                                                       */
-  /*    error        :: An error code that is only used to report memory   */
-  /*                    allocation problems.                               */
+  /*    metrics_only  :: A boolean indicating that we only want to compute */
+  /*                     the metrics of a given glyph, not load all of its */
+  /*                     points.                                           */
   /*                                                                       */
-  /*    metrics_only :: A boolean indicating that we only want to compute  */
-  /*                    the metrics of a given glyph, not load all of its  */
-  /*                    points.                                            */
+  /*    hints_funcs   :: Auxiliary pointer for hinting.                    */
   /*                                                                       */
+  /*    hints_globals :: Auxiliary pointer for hinting.                    */
+  /*                                                                       */
   typedef struct  CFF_Builder_
   {
-    FT_Memory         memory;
-    TT_Face           face;
-    CFF_GlyphSlot     glyph;
-    FT_GlyphLoader*   loader;
-    FT_Outline*       base;
-    FT_Outline*       current;
-
-    FT_Vector         last;
-
-    FT_Fixed          scale_x;
-    FT_Fixed          scale_y;
-
-    FT_Pos            pos_x;
-    FT_Pos            pos_y;
-
-    FT_Vector         left_bearing;
-    FT_Vector         advance;
-
-    FT_BBox           bbox;          /* bounding box */
-    FT_Bool           path_begun;
-    FT_Bool           load_points;
-    FT_Bool           no_recurse;
+    FT_Memory       memory;
+    TT_Face         face;
+    CFF_GlyphSlot   glyph;
+    FT_GlyphLoader  loader;
+    FT_Outline*     base;
+    FT_Outline*     current;
+
+    FT_Vector       last;
+
+    FT_Fixed        scale_x;
+    FT_Fixed        scale_y;
+
+    FT_Pos          pos_x;
+    FT_Pos          pos_y;
+
+    FT_Vector       left_bearing;
+    FT_Vector       advance;
+
+    FT_BBox         bbox;          /* bounding box */
+    FT_Bool         path_begun;
+    FT_Bool         load_points;
+    FT_Bool         no_recurse;
 
-    FT_Error          error;         /* only used for memory errors */
-    FT_Bool           metrics_only;
+    FT_Error        error;         /* only used for memory errors */
+    FT_Bool         metrics_only;
 
-    void*             hints_funcs;    /* hinter-specific */
-    void*             hints_globals;  /* hinter-specific */
+    void*           hints_funcs;    /* hinter-specific */
+    void*           hints_globals;  /* hinter-specific */
 
   } CFF_Builder;
 
@@ -132,7 +134,7 @@
   typedef struct  CFF_Decoder_
   {
     CFF_Builder        builder;
-    CFF_Font*          cff;
+    CFF_Font           cff;
 
     FT_Fixed           stack[CFF_MAX_OPERANDS + 1];
     FT_Fixed*          top;
@@ -167,32 +169,32 @@
   } CFF_Decoder;
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CFF_Init_Decoder( CFF_Decoder*   decoder,
                     TT_Face        face,
                     CFF_Size       size,
                     CFF_GlyphSlot  slot,
                     FT_Bool        hinting );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CFF_Prepare_Decoder( CFF_Decoder*  decoder,
                        FT_UInt       glyph_index );
 
 #if 0  /* unused until we support pure CFF fonts */
 
   /* Compute the maximum advance width of a font through quick parsing */
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Compute_Max_Advance( TT_Face  face,
                            FT_Int*  max_advance );
 
 #endif /* 0 */
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Parse_CharStrings( CFF_Decoder*  decoder,
                          FT_Byte*      charstring_base,
                          FT_Int        charstring_len );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Load_Glyph( CFF_GlyphSlot  glyph,
                   CFF_Size       size,
                   FT_Int         glyph_index,
Index: xc/extras/freetype2/src/cff/cffload.c
diff -u xc/extras/freetype2/src/cff/cffload.c:1.1.1.4 xc/extras/freetype2/src/cff/cffload.c:1.1.1.5
--- xc/extras/freetype2/src/cff/cffload.c:1.1.1.4	Mon Jan 14 11:52:12 2002
+++ xc/extras/freetype2/src/cff/cffload.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType and CFF data/program tables loader (body).                  */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -1046,7 +1046,7 @@
 #endif
 
 
-  FT_LOCAL_DEF FT_UShort
+  FT_LOCAL_DEF( FT_UShort )
   CFF_Get_Standard_Encoding( FT_UInt  charcode )
   {
     return  (FT_UShort)(charcode < 256 ? cff_standard_encoding[charcode] : 0);
@@ -1082,19 +1082,19 @@
 
 
   static FT_Error
-  cff_new_index( CFF_Index*  index,
-                 FT_Stream   stream,
-                 FT_Bool     load )
+  cff_new_index( CFF_Index  idx,
+                 FT_Stream  stream,
+                 FT_Bool    load )
   {
     FT_Error   error;
     FT_Memory  memory = stream->memory;
     FT_UShort  count;
 
 
-    MEM_Set( index, 0, sizeof ( *index ) );
+    FT_MEM_SET( idx, 0, sizeof ( *idx ) );
 
-    index->stream = stream;
-    if ( !READ_UShort( count ) &&
+    idx->stream = stream;
+    if ( !FT_READ_USHORT( count ) &&
          count > 0             )
     {
       FT_Byte*   p;
@@ -1105,19 +1105,19 @@
 
       /* there is at least one element; read the offset size,           */
       /* then access the offset table to compute the index's total size */
-      if ( READ_Byte( offsize ) )
+      if ( FT_READ_BYTE( offsize ) )
         goto Exit;
 
-      index->stream   = stream;
-      index->count    = count;
-      index->off_size = offsize;
-      data_size       = (FT_ULong)( count + 1 ) * offsize;
+      idx->stream   = stream;
+      idx->count    = count;
+      idx->off_size = offsize;
+      data_size     = (FT_ULong)( count + 1 ) * offsize;
 
-      if ( ALLOC_ARRAY( index->offsets, count + 1, FT_ULong ) ||
-           ACCESS_Frame( data_size )                          )
+      if ( FT_NEW_ARRAY( idx->offsets, count + 1 ) ||
+           FT_FRAME_ENTER( data_size )             )
         goto Exit;
 
-      poff = index->offsets;
+      poff = idx->offsets;
       p    = (FT_Byte*)stream->cursor;
 
       for ( ; (FT_Short)count >= 0; count-- )
@@ -1127,73 +1127,73 @@
         p += offsize;
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
-      index->data_offset = FILE_Pos();
-      data_size          = poff[-1] - 1;
+      idx->data_offset = FT_STREAM_POS();
+      data_size        = poff[-1] - 1;
 
       if ( load )
       {
         /* load the data */
-        if ( EXTRACT_Frame( data_size, index->bytes ) )
+        if ( FT_FRAME_EXTRACT( data_size, idx->bytes ) )
           goto Exit;
       }
       else
       {
         /* skip the data */
-        if ( FILE_Skip( data_size ) )
+        if ( FT_STREAM_SKIP( data_size ) )
           goto Exit;
       }
     }
 
   Exit:
     if ( error )
-      FREE( index->offsets );
+      FT_FREE( idx->offsets );
 
     return error;
   }
 
 
   static void
-  cff_done_index( CFF_Index*  index )
+  cff_done_index( CFF_Index  idx )
   {
-    if ( index->stream )
+    if ( idx->stream )
     {
-      FT_Stream  stream = index->stream;
+      FT_Stream  stream = idx->stream;
       FT_Memory  memory = stream->memory;
 
 
-      if ( index->bytes )
-        RELEASE_Frame( index->bytes );
+      if ( idx->bytes )
+        FT_FRAME_RELEASE( idx->bytes );
 
-      FREE( index->offsets );
-      MEM_Set( index, 0, sizeof ( *index ) );
+      FT_FREE( idx->offsets );
+      FT_MEM_SET( idx, 0, sizeof ( *idx ) );
     }
   }
 
 
   static FT_Error
-  cff_explicit_index( CFF_Index*  index,
+  cff_explicit_index( CFF_Index   idx,
                       FT_Byte***  table )
   {
     FT_Error   error  = 0;
-    FT_Memory  memory = index->stream->memory;
+    FT_Memory  memory = idx->stream->memory;
     FT_UInt    n, offset, old_offset;
     FT_Byte**  t;
 
 
     *table = 0;
 
-    if ( index->count > 0 && !ALLOC_ARRAY( t, index->count + 1, FT_Byte* ) )
+    if ( idx->count > 0 && !FT_NEW_ARRAY( t, idx->count + 1 ) )
     {
       old_offset = 1;
-      for ( n = 0; n <= index->count; n++ )
+      for ( n = 0; n <= idx->count; n++ )
       {
-        offset = index->offsets[n];
+        offset = idx->offsets[n];
         if ( !offset )
           offset = old_offset;
 
-        t[n] = index->bytes + offset - 1;
+        t[n] = idx->bytes + offset - 1;
 
         old_offset = offset;
       }
@@ -1204,30 +1204,30 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
-  CFF_Access_Element( CFF_Index*  index,
-                      FT_UInt     element,
-                      FT_Byte**   pbytes,
-                      FT_ULong*   pbyte_len )
+  FT_LOCAL_DEF( FT_Error )
+  CFF_Access_Element( CFF_Index  idx,
+                      FT_UInt    element,
+                      FT_Byte**  pbytes,
+                      FT_ULong*  pbyte_len )
   {
     FT_Error  error = 0;
 
 
-    if ( index && index->count > element )
+    if ( idx && idx->count > element )
     {
       /* compute start and end offsets */
       FT_ULong  off1, off2 = 0;
 
 
-      off1 = index->offsets[element];
+      off1 = idx->offsets[element];
       if ( off1 )
       {
         do
         {
           element++;
-          off2 = index->offsets[element];
+          off2 = idx->offsets[element];
 
-        } while ( off2 == 0 && element < index->count );
+        } while ( off2 == 0 && element < idx->count );
 
         if ( !off2 )
           off1 = 0;
@@ -1238,19 +1238,19 @@
       {
         *pbyte_len = off2 - off1;
 
-        if ( index->bytes )
+        if ( idx->bytes )
         {
           /* this index was completely loaded in memory, that's easy */
-          *pbytes = index->bytes + off1 - 1;
+          *pbytes = idx->bytes + off1 - 1;
         }
         else
         {
           /* this index is still on disk/file, access it through a frame */
-          FT_Stream  stream = index->stream;
+          FT_Stream  stream = idx->stream;
 
 
-          if ( FILE_Seek( index->data_offset + off1 - 1 ) ||
-               EXTRACT_Frame( off2 - off1, *pbytes )      )
+          if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
+               FT_FRAME_EXTRACT( off2 - off1, *pbytes )      )
             goto Exit;
         }
       }
@@ -1269,75 +1269,77 @@
   }
 
 
-  FT_LOCAL_DEF void
-  CFF_Forget_Element( CFF_Index*  index,
-                      FT_Byte**   pbytes )
+  FT_LOCAL_DEF( void )
+  CFF_Forget_Element( CFF_Index  idx,
+                      FT_Byte**  pbytes )
   {
-    if ( index->bytes == 0 )
+    if ( idx->bytes == 0 )
     {
-      FT_Stream  stream = index->stream;
+      FT_Stream  stream = idx->stream;
 
 
-      RELEASE_Frame( *pbytes );
+      FT_FRAME_RELEASE( *pbytes );
     }
   }
 
 
-  FT_LOCAL_DEF FT_String*
-  CFF_Get_Name( CFF_Index*  index,
-                FT_UInt     element )
+  FT_LOCAL_DEF( FT_String* )
+  CFF_Get_Name( CFF_Index  idx,
+                FT_UInt    element )
   {
-    FT_Memory   memory = index->stream->memory;
+    FT_Memory   memory = idx->stream->memory;
     FT_Byte*    bytes;
     FT_ULong    byte_len;
     FT_Error    error;
     FT_String*  name = 0;
 
 
-    error = CFF_Access_Element( index, element, &bytes, &byte_len );
+    error = CFF_Access_Element( idx, element, &bytes, &byte_len );
     if ( error )
       goto Exit;
 
-    if ( !ALLOC( name, byte_len + 1 ) )
+    if ( !FT_ALLOC( name, byte_len + 1 ) )
     {
-      MEM_Copy( name, bytes, byte_len );
+      FT_MEM_COPY( name, bytes, byte_len );
       name[byte_len] = 0;
     }
-    CFF_Forget_Element( index, &bytes );
+    CFF_Forget_Element( idx, &bytes );
 
   Exit:
     return name;
   }
 
 
-  FT_LOCAL_DEF FT_String*
-  CFF_Get_String( CFF_Index*          index,
-                  FT_UInt             sid,
-                  PSNames_Interface*  interface )
+  FT_LOCAL_DEF( FT_String* )
+  CFF_Get_String( CFF_Index        idx,
+                  FT_UInt          sid,
+                  PSNames_Service  psnames_interface )
   {
     /* if it is not a standard string, return it */
     if ( sid > 390 )
-      return CFF_Get_Name( index, sid - 391 );
+      return CFF_Get_Name( idx, sid - 391 );
 
     /* that's a standard string, fetch a copy from the PSName module */
     {
       FT_String*   name       = 0;
-      const char*  adobe_name = interface->adobe_std_strings( sid );
+      const char*  adobe_name = psnames_interface->adobe_std_strings( sid );
       FT_UInt      len;
 
 
       if ( adobe_name )
       {
-        FT_Memory memory = index->stream->memory;
-        FT_Error  error;
+        FT_Memory  memory = idx->stream->memory;
+        FT_Error   error;
 
 
-        len = (FT_UInt)strlen( adobe_name );
-        if ( !ALLOC( name, len + 1 ) )
+        len = (FT_UInt)ft_strlen( adobe_name );
+        if ( !FT_ALLOC( name, len + 1 ) )
         {
-          MEM_Copy( name, adobe_name, len );
+          FT_MEM_COPY( name, adobe_name, len );
           name[len] = 0;
         }
+
+        FT_UNUSED( error );
       }
 
       return name;
@@ -1355,11 +1357,11 @@
 
 
   static void
-  CFF_Done_FD_Select( CFF_FD_Select*  select,
-                      FT_Stream       stream )
+  CFF_Done_FD_Select( CFF_FDSelect  select,
+                      FT_Stream     stream )
   {
     if ( select->data )
-      RELEASE_Frame( select->data );
+      FT_FRAME_RELEASE( select->data );
 
     select->data_size   = 0;
     select->format      = 0;
@@ -1368,10 +1370,10 @@
 
 
   static FT_Error
-  CFF_Load_FD_Select( CFF_FD_Select*  select,
-                      FT_UInt         num_glyphs,
-                      FT_Stream       stream,
-                      FT_ULong        offset )
+  CFF_Load_FD_Select( CFF_FDSelect  select,
+                      FT_UInt       num_glyphs,
+                      FT_Stream     stream,
+                      FT_ULong      offset )
   {
     FT_Error  error;
     FT_Byte   format;
@@ -1379,7 +1381,7 @@
 
 
     /* read format */
-    if ( FILE_Seek( offset ) || READ_Byte( format ) )
+    if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) )
       goto Exit;
 
     select->format      = format;
@@ -1392,13 +1394,13 @@
       goto Load_Data;
 
     case 3:     /* format 3, a tad more complex */
-      if ( READ_UShort( num_ranges ) )
+      if ( FT_READ_USHORT( num_ranges ) )
         goto Exit;
 
       select->data_size = num_ranges * 3 + 2;
 
     Load_Data:
-      if ( EXTRACT_Frame( select->data_size, select->data ) )
+      if ( FT_FRAME_EXTRACT( select->data_size, select->data ) )
         goto Exit;
       break;
 
@@ -1411,9 +1413,9 @@
   }
 
 
-  FT_LOCAL_DEF FT_Byte
-  CFF_Get_FD( CFF_FD_Select*  select,
-              FT_UInt         glyph_index )
+  FT_LOCAL_DEF( FT_Byte )
+  CFF_Get_FD( CFF_FDSelect  select,
+              FT_UInt       glyph_index )
   {
     FT_Byte  fd = 0;
 
@@ -1440,14 +1442,14 @@
         FT_UInt   first, limit;
 
 
-        first = NEXT_UShort( p );
+        first = FT_NEXT_USHORT( p );
         do
         {
           if ( glyph_index < first )
             break;
 
           fd2   = *p++;
-          limit = NEXT_UShort( p );
+          limit = FT_NEXT_USHORT( p );
 
           if ( glyph_index < limit )
           {
@@ -1482,14 +1484,14 @@
   /*************************************************************************/
 
   static void
-  CFF_Done_Encoding( CFF_Encoding*  encoding,
-                     FT_Stream      stream )
+  CFF_Done_Encoding( CFF_Encoding  encoding,
+                     FT_Stream     stream )
   {
     FT_Memory  memory = stream->memory;
 
 
-    FREE( encoding->codes );
-    FREE( encoding->sids  );
+    FT_FREE( encoding->codes );
+    FT_FREE( encoding->sids  );
     encoding->format = 0;
     encoding->offset = 0;
     encoding->codes  = 0;
@@ -1498,13 +1500,13 @@
 
 
   static void
-  CFF_Done_Charset( CFF_Charset*  charset,
-                    FT_Stream     stream )
+  CFF_Done_Charset( CFF_Charset  charset,
+                    FT_Stream    stream )
   {
     FT_Memory  memory = stream->memory;
 
 
-    FREE( charset->sids );
+    FT_FREE( charset->sids );
     charset->format = 0;
     charset->offset = 0;
     charset->sids   = 0;
@@ -1512,11 +1514,11 @@
 
 
   static FT_Error
-  CFF_Load_Charset( CFF_Charset*  charset,
-                    FT_UInt       num_glyphs,
-                    FT_Stream     stream,
-                    FT_ULong      base_offset,
-                    FT_ULong      offset )
+  CFF_Load_Charset( CFF_Charset  charset,
+                    FT_UInt      num_glyphs,
+                    FT_Stream    stream,
+                    FT_ULong     base_offset,
+                    FT_ULong     offset )
   {
     FT_Memory  memory     = stream->memory;
     FT_Error   error      = 0;
@@ -1526,8 +1528,8 @@
     charset->offset = base_offset + offset;
 
     /* Get the format of the table. */
-    if ( FILE_Seek( charset->offset ) ||
-         READ_Byte( charset->format ) )
+    if ( FT_STREAM_SEEK( charset->offset ) ||
+         FT_READ_BYTE( charset->format )   )
       goto Exit;
 
     /* If the the offset is greater than 2, we have to parse the */
@@ -1538,7 +1540,7 @@
 
 
       /* Allocate memory for sids. */
-      if ( ALLOC( charset->sids, num_glyphs * sizeof ( FT_UShort ) ) )
+      if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
         goto Exit;
 
       /* assign the .notdef glyph */
@@ -1549,7 +1551,7 @@
       case 0:
         for ( j = 1; j < num_glyphs; j++ )
         {
-          if ( READ_UShort( glyph_sid ) )
+          if ( FT_READ_USHORT( glyph_sid ) )
             goto Exit;
 
           charset->sids[j] = glyph_sid;
@@ -1569,18 +1571,18 @@
           {
 
             /* Read the first glyph sid of the range. */
-            if ( READ_UShort( glyph_sid ) )
+            if ( FT_READ_USHORT( glyph_sid ) )
               goto Exit;
 
             /* Read the number of glyphs in the range.  */
             if ( charset->format == 2 )
             {
-              if ( READ_UShort( nleft ) )
+              if ( FT_READ_USHORT( nleft ) )
                 goto Exit;
             }
             else
             {
-              if ( READ_Byte( nleft ) )
+              if ( FT_READ_BYTE( nleft ) )
                 goto Exit;
             }
 
@@ -1620,12 +1622,12 @@
         }
 
         /* Allocate memory for sids. */
-        if ( ALLOC( charset->sids, num_glyphs * sizeof ( FT_UShort ) ) )
+        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
           goto Exit;
 
         /* Copy the predefined charset into the allocated memory. */
-        MEM_Copy( charset->sids, cff_isoadobe_charset,
-                  num_glyphs * sizeof ( FT_UShort ) );
+        FT_MEM_COPY( charset->sids, cff_isoadobe_charset,
+                     num_glyphs * sizeof ( FT_UShort ) );
 
         break;
 
@@ -1639,12 +1641,12 @@
         }
 
         /* Allocate memory for sids. */
-        if ( ALLOC( charset->sids, num_glyphs * sizeof ( FT_UShort ) ) )
+        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
           goto Exit;
 
         /* Copy the predefined charset into the allocated memory.     */
-        MEM_Copy( charset->sids, cff_expert_charset,
-                  num_glyphs * sizeof ( FT_UShort ) );
+        FT_MEM_COPY( charset->sids, cff_expert_charset,
+                     num_glyphs * sizeof ( FT_UShort ) );
 
         break;
 
@@ -1658,12 +1660,12 @@
         }
 
         /* Allocate memory for sids. */
-        if ( ALLOC( charset->sids, num_glyphs * sizeof ( FT_UShort ) ) )
+        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
           goto Exit;
 
         /* Copy the predefined charset into the allocated memory.     */
-        MEM_Copy( charset->sids, cff_expertsubset_charset,
-                  num_glyphs * sizeof ( FT_UShort ) );
+        FT_MEM_COPY( charset->sids, cff_expertsubset_charset,
+                     num_glyphs * sizeof ( FT_UShort ) );
 
         break;
 
@@ -1680,7 +1682,7 @@
       if ( charset->sids )
       {
         if ( charset->sids )
-          FREE( charset->sids );
+          FT_FREE( charset->sids );
         charset->format = 0;
         charset->offset = 0;
         charset->sids   = 0;
@@ -1691,12 +1693,12 @@
 
 
   static FT_Error
-  CFF_Load_Encoding( CFF_Encoding*  encoding,
-                     CFF_Charset*   charset,
-                     FT_UInt        num_glyphs,
-                     FT_Stream      stream,
-                     FT_ULong       base_offset,
-                     FT_ULong       offset )
+  CFF_Load_Encoding( CFF_Encoding  encoding,
+                     CFF_Charset   charset,
+                     FT_UInt       num_glyphs,
+                     FT_Stream     stream,
+                     FT_ULong      base_offset,
+                     FT_ULong      offset )
   {
     FT_Memory   memory = stream->memory;
     FT_Error    error  = 0;
@@ -1715,8 +1717,8 @@
 
     /* Allocate memory for sids/codes -- there are at most 256 sids/codes */
     /* for an encoding.                                                   */
-    if ( ALLOC( encoding->sids,  256 * sizeof ( FT_UShort ) ) ||
-         ALLOC( encoding->codes, 256 * sizeof ( FT_UShort ) ) )
+    if ( FT_NEW_ARRAY( encoding->sids,  256 ) ||
+         FT_NEW_ARRAY( encoding->codes, 256 ) )
       goto Exit;
 
     /* Zero out the code to gid/sid mappings. */
@@ -1744,9 +1746,9 @@
       encoding->offset = base_offset + offset;
 
       /* we need to parse the table to determine its size */
-      if ( FILE_Seek( encoding->offset ) ||
-           READ_Byte( encoding->format ) ||
-           READ_Byte( count )            )
+      if ( FT_STREAM_SEEK( encoding->offset ) ||
+           FT_READ_BYTE( encoding->format )   ||
+           FT_READ_BYTE( count )              )
         goto Exit;
 
       switch ( encoding->format & 0x7F )
@@ -1754,7 +1756,7 @@
       case 0:
         for ( j = 1; j <= count; j++ )
         {
-          if ( READ_Byte( glyph_code ) )
+          if ( FT_READ_BYTE( glyph_code ) )
             goto Exit;
 
           /* Make sure j is not too big. */
@@ -1781,11 +1783,11 @@
           for ( j = 0;  j < count; j++, i += nleft )
           {
             /* Read the first glyph code of the range. */
-            if ( READ_Byte( glyph_code ) )
+            if ( FT_READ_BYTE( glyph_code ) )
               goto Exit;
 
             /* Read the number of codes in the range. */
-            if ( READ_Byte( nleft ) )
+            if ( FT_READ_BYTE( nleft ) )
               goto Exit;
 
             /* Increment nleft, so we read `nleft + 1' codes/sids. */
@@ -1821,17 +1823,17 @@
 
 
         /* count supplements */
-        if ( READ_Byte( count ) )
+        if ( FT_READ_BYTE( count ) )
           goto Exit;
 
         for ( j = 0; j < count; j++ )
         {
           /* Read supplemental glyph code. */
-          if ( READ_Byte( glyph_code ) )
+          if ( FT_READ_BYTE( glyph_code ) )
             goto Exit;
 
           /* Read the SID associated with this glyph code. */
-          if ( READ_UShort( glyph_sid ) )
+          if ( FT_READ_USHORT( glyph_sid ) )
             goto Exit;
 
           /* Assign code to SID mapping. */
@@ -1864,8 +1866,8 @@
       {
       case 0:
         /* First, copy the code to SID mapping. */
-        MEM_Copy( encoding->sids, cff_standard_encoding,
-                  256 * sizeof ( FT_UShort ) );
+        FT_MEM_COPY( encoding->sids, cff_standard_encoding,
+                     256 * sizeof ( FT_UShort ) );
 
         /* Construct code to GID mapping from code */
         /* to SID mapping and charset.             */
@@ -1895,8 +1897,8 @@
 
       case 1:
         /* First, copy the code to SID mapping. */
-        MEM_Copy( encoding->sids, cff_expert_encoding,
-                  256 * sizeof ( FT_UShort ) );
+        FT_MEM_COPY( encoding->sids, cff_expert_encoding,
+                     256 * sizeof ( FT_UShort ) );
 
         /* Construct code to GID mapping from code to SID mapping */
         /* and charset.                                           */
@@ -1939,10 +1941,10 @@
       if ( encoding->sids || encoding->codes )
       {
         if ( encoding->sids )
-          FREE( encoding->sids );
+          FT_FREE( encoding->sids );
 
         if ( encoding->codes )
-          FREE( encoding->codes );
+          FT_FREE( encoding->codes );
 
         charset->format = 0;
         charset->offset = 0;
@@ -1955,24 +1957,24 @@
 
 
   static FT_Error
-  CFF_Load_SubFont( CFF_SubFont*  font,
-                    CFF_Index*    index,
-                    FT_UInt       font_index,
-                    FT_Stream     stream,
-                    FT_ULong      base_offset )
-  {
-    FT_Error        error;
-    CFF_Parser      parser;
-    FT_Byte*        dict;
-    FT_ULong        dict_len;
-    CFF_Font_Dict*  top  = &font->font_dict;
-    CFF_Private*    priv = &font->private_dict;
+  CFF_Load_SubFont( CFF_SubFont  font,
+                    CFF_Index    idx,
+                    FT_UInt      font_index,
+                    FT_Stream    stream,
+                    FT_ULong     base_offset )
+  {
+    FT_Error         error;
+    CFF_ParserRec    parser;
+    FT_Byte*         dict;
+    FT_ULong         dict_len;
+    CFF_FontRecDict  top  = &font->font_dict;
+    CFF_Private      priv = &font->private_dict;
 
 
     CFF_Parser_Init( &parser, CFF_CODE_TOPDICT, &font->font_dict );
 
     /* set defaults */
-    MEM_Set( top, 0, sizeof ( *top ) );
+    FT_MEM_SET( top, 0, sizeof ( *top ) );
 
     top->underline_position  = -100;
     top->underline_thickness = 50;
@@ -1981,10 +1983,10 @@
     top->font_matrix.yy      = 0x10000L;
     top->cid_count           = 8720;
 
-    error = CFF_Access_Element( index, font_index, &dict, &dict_len ) ||
+    error = CFF_Access_Element( idx, font_index, &dict, &dict_len ) ||
             CFF_Parser_Run( &parser, dict, dict + dict_len );
 
-    CFF_Forget_Element( index, &dict );
+    CFF_Forget_Element( idx, &dict );
 
     if ( error )
       goto Exit;
@@ -1997,7 +1999,7 @@
     if ( top->private_offset && top->private_size )
     {
       /* set defaults */
-      MEM_Set( priv, 0, sizeof ( *priv ) );
+      FT_MEM_SET( priv, 0, sizeof ( *priv ) );
 
       priv->blue_shift       = 7;
       priv->blue_fuzz        = 1;
@@ -2007,14 +2009,14 @@
 
       CFF_Parser_Init( &parser, CFF_CODE_PRIVATE, priv );
 
-      if ( FILE_Seek( base_offset + font->font_dict.private_offset ) ||
-           ACCESS_Frame( font->font_dict.private_size )              )
+      if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
+           FT_FRAME_ENTER( font->font_dict.private_size )                 )
         goto Exit;
 
       error = CFF_Parser_Run( &parser,
                              (FT_Byte*)stream->cursor,
                              (FT_Byte*)stream->limit );
-      FORGET_Frame();
+      FT_FRAME_EXIT();
       if ( error )
         goto Exit;
     }
@@ -2022,8 +2024,8 @@
     /* read the local subrs, if any */
     if ( priv->local_subrs_offset )
     {
-      if ( FILE_Seek( base_offset + top->private_offset +
-                      priv->local_subrs_offset ) )
+      if ( FT_STREAM_SEEK( base_offset + top->private_offset +
+                           priv->local_subrs_offset ) )
         goto Exit;
 
       error = cff_new_index( &font->local_subrs_index, stream, 1 );
@@ -2032,7 +2034,7 @@
 
       font->num_local_subrs = font->local_subrs_index.count;
       error = cff_explicit_index( &font->local_subrs_index,
-                                     &font->local_subrs );
+                                  &font->local_subrs );
       if ( error )
         goto Exit;
     }
@@ -2043,26 +2045,26 @@
 
 
   static void
-  CFF_Done_SubFont( FT_Memory     memory,
-                    CFF_SubFont*  subfont )
+  CFF_Done_SubFont( FT_Memory    memory,
+                    CFF_SubFont  subfont )
   {
     if ( subfont )
     {
       cff_done_index( &subfont->local_subrs_index );
-      FREE( subfont->local_subrs );
+      FT_FREE( subfont->local_subrs );
     }
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Load_Font( FT_Stream  stream,
                  FT_Int     face_index,
-                 CFF_Font*  font )
+                 CFF_Font   font )
   {
     static const FT_Frame_Field  cff_header_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  CFF_Font
+#define FT_STRUCTURE  CFF_FontRec
 
       FT_FRAME_START( 4 ),
         FT_FRAME_BYTE( version_major ),
@@ -2072,21 +2074,21 @@
       FT_FRAME_END
     };
 
-    FT_Error        error;
-    FT_Memory       memory = stream->memory;
-    FT_ULong        base_offset;
-    CFF_Font_Dict*  dict;
+    FT_Error         error;
+    FT_Memory        memory = stream->memory;
+    FT_ULong         base_offset;
+    CFF_FontRecDict  dict;
 
 
-    MEM_Set( font, 0, sizeof ( *font ) );
+    FT_MEM_SET( font, 0, sizeof ( *font ) );
 
     font->stream = stream;
     font->memory = memory;
     dict         = &font->top_font.font_dict;
-    base_offset  = FILE_Pos();
+    base_offset  = FT_STREAM_POS();
 
     /* read CFF font header */
-    if ( READ_Fields( cff_header_fields, font ) )
+    if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
       goto Exit;
 
     /* check format */
@@ -2100,7 +2102,7 @@
     }
 
     /* skip the rest of the header */
-    if ( FILE_Skip( font->header_size - 4 ) )
+    if ( FT_STREAM_SKIP( font->header_size - 4 ) )
       goto Exit;
 
     /* read the name, top dict, string and global subrs index */
@@ -2135,14 +2137,14 @@
     /* now, check for a CID font */
     if ( dict->cid_registry )
     {
-      CFF_Index     fd_index;
-      CFF_SubFont*  sub;
-      FT_UInt       index;
+      CFF_IndexRec  fd_index;
+      CFF_SubFont   sub;
+      FT_UInt       idx;
 
 
       /* this is a CID-keyed font, we must now allocate a table of */
       /* sub-fonts, then load each of them separately              */
-      if ( FILE_Seek( base_offset + dict->cid_fd_array_offset ) )
+      if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )
         goto Exit;
 
       error = cff_new_index( &fd_index, stream, 0 );
@@ -2157,18 +2159,18 @@
 
       /* allocate & read each font dict independently */
       font->num_subfonts = fd_index.count;
-      if ( ALLOC_ARRAY( sub, fd_index.count, CFF_SubFont ) )
+      if ( FT_NEW_ARRAY( sub, fd_index.count ) )
         goto Fail_CID;
 
       /* setup pointer table */
-      for ( index = 0; index < fd_index.count; index++ )
-        font->subfonts[index] = sub + index;
+      for ( idx = 0; idx < fd_index.count; idx++ )
+        font->subfonts[idx] = sub + idx;
 
       /* now load each sub font independently */
-      for ( index = 0; index < fd_index.count; index++ )
+      for ( idx = 0; idx < fd_index.count; idx++ )
       {
-        sub = font->subfonts[index];
-        error = CFF_Load_SubFont( sub, &fd_index, index,
+        sub = font->subfonts[idx];
+        error = CFF_Load_SubFont( sub, &fd_index, idx,
                                   stream, base_offset );
         if ( error )
           goto Fail_CID;
@@ -2197,7 +2199,7 @@
       goto Exit;
     }
 
-    if ( FILE_Seek( base_offset + dict->charstrings_offset ) )
+    if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
       goto Exit;
 
     error = cff_new_index( &font->charstrings_index, stream, 0 );
@@ -2237,11 +2239,11 @@
   }
 
 
-  FT_LOCAL_DEF void
-  CFF_Done_Font( CFF_Font*  font )
+  FT_LOCAL_DEF( void )
+  CFF_Done_Font( CFF_Font  font )
   {
     FT_Memory  memory = font->memory;
-    FT_UInt    index;
+    FT_UInt    idx;
 
 
     cff_done_index( &font->global_subrs_index );
@@ -2254,10 +2256,10 @@
     /* a CID keyed CFF font                                */
     if ( font->num_subfonts > 0 )
     {
-      for ( index = 0; index < font->num_subfonts; index++ )
-        CFF_Done_SubFont( memory, font->subfonts[index] );
+      for ( idx = 0; idx < font->num_subfonts; idx++ )
+        CFF_Done_SubFont( memory, font->subfonts[idx] );
 
-      FREE( font->subfonts );
+      FT_FREE( font->subfonts );
     }
 
     CFF_Done_Encoding( &font->encoding, font->stream );
@@ -2267,8 +2269,8 @@
 
     CFF_Done_FD_Select( &font->fd_select, font->stream );
 
-    FREE( font->global_subrs );
-    FREE( font->font_name );
+    FT_FREE( font->global_subrs );
+    FT_FREE( font->font_name );
   }
 
 
Index: xc/extras/freetype2/src/cff/cffload.h
diff -u xc/extras/freetype2/src/cff/cffload.h:1.1.1.4 xc/extras/freetype2/src/cff/cffload.h:1.1.1.5
--- xc/extras/freetype2/src/cff/cffload.h:1.1.1.4	Mon Jan 14 11:52:12 2002
+++ xc/extras/freetype2/src/cff/cffload.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType & CFF data/program tables loader (specification).           */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,43 +27,43 @@
 
 FT_BEGIN_HEADER
 
-  FT_LOCAL FT_UShort
+  FT_LOCAL( FT_UShort )
   CFF_Get_Standard_Encoding( FT_UInt  charcode );
 
 
-  FT_LOCAL FT_String*
-  CFF_Get_Name( CFF_Index*  index,
-                FT_UInt     element );
+  FT_LOCAL( FT_String* )
+  CFF_Get_Name( CFF_Index  idx,
+                FT_UInt    element );
 
-  FT_LOCAL FT_String*
-  CFF_Get_String( CFF_Index*          index,
-                  FT_UInt             sid,
-                  PSNames_Interface*  interface );
+  FT_LOCAL( FT_String* )
+  CFF_Get_String( CFF_Index        idx,
+                  FT_UInt          sid,
+                  PSNames_Service  psnames_interface );
 
 
-  FT_LOCAL FT_Error
-  CFF_Access_Element( CFF_Index*  index,
-                      FT_UInt     element,
-                      FT_Byte**   pbytes,
-                      FT_ULong*   pbyte_len );
+  FT_LOCAL( FT_Error )
+  CFF_Access_Element( CFF_Index  idx,
+                      FT_UInt    element,
+                      FT_Byte**  pbytes,
+                      FT_ULong*  pbyte_len );
 
-  FT_LOCAL void
-  CFF_Forget_Element( CFF_Index*  index,
-                      FT_Byte**   pbytes );
+  FT_LOCAL( void )
+  CFF_Forget_Element( CFF_Index  idx,
+                      FT_Byte**  pbytes );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Load_Font( FT_Stream  stream,
                  FT_Int     face_index,
-                 CFF_Font*  font );
+                 CFF_Font   font );
 
-  FT_LOCAL void
-  CFF_Done_Font( CFF_Font*  font );
+  FT_LOCAL( void )
+  CFF_Done_Font( CFF_Font  font );
 
 
-  FT_LOCAL FT_Byte
-  CFF_Get_FD( CFF_FD_Select*  select,
-              FT_UInt         glyph_index );
+  FT_LOCAL( FT_Byte )
+  CFF_Get_FD( CFF_FDSelect  select,
+              FT_UInt       glyph_index );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/cff/cffobjs.c
diff -u xc/extras/freetype2/src/cff/cffobjs.c:1.1.1.4 xc/extras/freetype2/src/cff/cffobjs.c:1.1.1.7
--- xc/extras/freetype2/src/cff/cffobjs.c:1.1.1.4	Mon Jan 14 11:52:12 2002
+++ xc/extras/freetype2/src/cff/cffobjs.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType objects manager (body).                                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -31,9 +31,7 @@
 
 #include "cfferrs.h"
 
-#include <string.h>         /* for strlen() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -44,8 +42,6 @@
 #define FT_COMPONENT  trace_cffobjs
 
 
-
-
   /*************************************************************************/
   /*                                                                       */
   /*                            SIZE FUNCTIONS                             */
@@ -59,10 +55,10 @@
   static PSH_Globals_Funcs
   CFF_Size_Get_Globals_Funcs( CFF_Size  size )
   {
-    CFF_Face             face     = (CFF_Face)size->face;
-    CFF_Font*            font     = face->extra.data;
-    PSHinter_Interface*  pshinter = font->pshinter;
-    FT_Module            module;
+    CFF_Face          face     = (CFF_Face)size->face;
+    CFF_Font          font     = (CFF_FontRec *)face->extra.data;
+    PSHinter_Service  pshinter = (PSHinter_Service)font->pshinter;
+    FT_Module         module;
 
 
     module = FT_Get_Module( size->face->driver->root.library,
@@ -73,7 +69,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CFF_Size_Done( CFF_Size  size )
   {
     if ( size->internal )
@@ -90,7 +86,7 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Size_Init( CFF_Size  size )
   {
     FT_Error           error = 0;
@@ -99,13 +95,13 @@
 
     if ( funcs )
     {
-      PSH_Globals   globals;
-      CFF_Face      face    = (CFF_Face)size->face;
-      CFF_Font*     font    = face->extra.data;
-      CFF_SubFont*  subfont = &font->top_font;
+      PSH_Globals    globals;
+      CFF_Face       face    = (CFF_Face)size->face;
+      CFF_Font       font    = (CFF_FontRec *)face->extra.data;
+      CFF_SubFont    subfont = &font->top_font;
 
-      CFF_Private*  cpriv   = &subfont->private_dict;
-      T1_Private    priv;
+      CFF_Private    cpriv   = &subfont->private_dict;
+      PS_PrivateRec  priv;
 
 
       /* IMPORTANT: The CFF and Type1 private dictionaries have    */
@@ -116,38 +112,38 @@
         FT_UInt  n, count;
 
 
-        MEM_Set( &priv, 0, sizeof ( priv ) );
+        FT_MEM_SET( &priv, 0, sizeof ( priv ) );
 
         count = priv.num_blue_values = cpriv->num_blue_values;
         for ( n = 0; n < count; n++ )
-          priv.blue_values[n] = (FT_Short) cpriv->blue_values[n];
+          priv.blue_values[n] = (FT_Short)cpriv->blue_values[n];
 
         count = priv.num_other_blues = cpriv->num_other_blues;
         for ( n = 0; n < count; n++ )
-          priv.other_blues[n] = (FT_Short) cpriv->other_blues[n];
+          priv.other_blues[n] = (FT_Short)cpriv->other_blues[n];
 
         count = priv.num_family_blues = cpriv->num_family_blues;
         for ( n = 0; n < count; n++ )
-          priv.family_blues[n] = (FT_Short) cpriv->family_blues[n];
+          priv.family_blues[n] = (FT_Short)cpriv->family_blues[n];
 
         count = priv.num_family_other_blues = cpriv->num_family_other_blues;
         for ( n = 0; n < count; n++ )
-          priv.family_other_blues[n] = (FT_Short) cpriv->family_other_blues[n];
+          priv.family_other_blues[n] = (FT_Short)cpriv->family_other_blues[n];
 
         priv.blue_scale = cpriv->blue_scale;
         priv.blue_shift = cpriv->blue_shift;
         priv.blue_fuzz  = cpriv->blue_fuzz;
 
-        priv.standard_width[0]  = (FT_UShort) cpriv->standard_width;
-        priv.standard_height[0] = (FT_UShort) cpriv->standard_height;
+        priv.standard_width[0]  = (FT_UShort)cpriv->standard_width;
+        priv.standard_height[0] = (FT_UShort)cpriv->standard_height;
 
         count = priv.num_snap_widths = cpriv->num_snap_widths;
         for ( n = 0; n < count; n++ )
-          priv.snap_widths[n] = (FT_Short) cpriv->snap_widths[n];
+          priv.snap_widths[n] = (FT_Short)cpriv->snap_widths[n];
 
         count = priv.num_snap_heights = cpriv->num_snap_heights;
         for ( n = 0; n < count; n++ )
-          priv.snap_heights[n] = (FT_Short) cpriv->snap_heights[n];
+          priv.snap_heights[n] = (FT_Short)cpriv->snap_heights[n];
 
         priv.force_bold     = cpriv->force_bold;
         priv.language_group = cpriv->language_group;
@@ -163,7 +159,7 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Size_Reset( CFF_Size  size )
   {
     PSH_Globals_Funcs  funcs = CFF_Size_Get_Globals_Funcs( size );
@@ -185,19 +181,19 @@
   /*                                                                       */
   /*************************************************************************/
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CFF_GlyphSlot_Done( CFF_GlyphSlot  slot )
   {
     slot->root.internal->glyph_hints = 0;
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_GlyphSlot_Init( CFF_GlyphSlot  slot )
   {
-    CFF_Face             face     = (CFF_Face)slot->root.face;
-    CFF_Font*            font     = face->extra.data;
-    PSHinter_Interface*  pshinter = font->pshinter;
+    CFF_Face          face     = (CFF_Face)slot->root.face;
+    CFF_Font          font     = (CFF_FontRec *)face->extra.data;
+    PSHinter_Service  pshinter = (PSHinter_Service)font->pshinter;
 
 
     if ( pshinter )
@@ -233,239 +229,50 @@
   {
     FT_Error    error;
     FT_String*  result = 0;
-    FT_Int      len = (FT_Int)strlen( source );
+    FT_Int      len = (FT_Int)ft_strlen( source );
 
 
-    if ( !ALLOC( result, len + 1 ) )
+    if ( !FT_ALLOC( result, len + 1 ) )
     {
-      MEM_Copy( result, source, len );
+      FT_MEM_COPY( result, source, len );
       result[len] = 0;
     }
-    return result;
-  }
-
-
-#if 0
-
-  /* this function is used to build a Unicode charmap from the glyph names */
-  /* in a file                                                             */
-  static FT_Error
-  CFF_Build_Unicode_Charmap( CFF_Face            face,
-                             FT_ULong            base_offset,
-                             PSNames_Interface*  psnames )
-  {
-    CFF_Font*       font = (CFF_Font*)face->extra.data;
-    FT_Memory       memory = FT_FACE_MEMORY(face);
-    FT_UInt         n, num_glyphs = face->root.num_glyphs;
-    const char**    glyph_names;
-    FT_Error        error;
-    CFF_Font_Dict*  dict = &font->top_font.font_dict;
-    FT_ULong        charset_offset;
-    FT_Byte         format;
-    FT_Stream       stream = face->root.stream;
-
-
-    charset_offset = dict->charset_offset;
-    if ( !charset_offset )
-    {
-      FT_ERROR(( "CFF_Build_Unicode_Charmap: charset table is missing\n" ));
-      error = CFF_Err_Invalid_File_Format;
-      goto Exit;
-    }
-
-    /* allocate the charmap */
-    if ( ALLOC( face->charmap, ...
-
-    /* seek to charset table and allocate glyph names table */
-    if ( FILE_Seek( base_offset + charset_offset )           ||
-         ALLOC_ARRAY( glyph_names, num_glyphs, const char* ) )
-      goto Exit;
-
-    /* now, read each glyph name and store it in the glyph name table */
-    if ( READ_Byte( format ) )
-      goto Fail;
-
-    switch ( format )
-    {
-    case 0:  /* format 0 - one SID per glyph */
-      {
-        const char**  gname = glyph_names;
-        const char**  limit = gname + num_glyphs;
-
-
-        if ( ACCESS_Frame( num_glyphs * 2 ) )
-          goto Fail;
-
-        for ( ; gname < limit; gname++ )
-          gname[0] = CFF_Get_String( &font->string_index,
-                                     GET_UShort(),
-                                     psnames );
-        FORGET_Frame();
-        break;
-      }
-
-    case 1:  /* format 1 - sequential ranges                    */
-    case 2:  /* format 2 - sequential ranges with 16-bit counts */
-      {
-        const char**  gname = glyph_names;
-        const char**  limit = gname + num_glyphs;
-        FT_UInt       len = 3;
-
-
-        if ( format == 2 )
-          len++;
-
-        while ( gname < limit )
-        {
-          FT_UInt  first;
-          FT_UInt  count;
-
-
-          if ( ACCESS_Frame( len ) )
-            goto Fail;
-
-          first = GET_UShort();
-          if ( format == 3 )
-            count = GET_UShort();
-          else
-            count = GET_Byte();
-
-          FORGET_Frame();
-
-          for ( ; count > 0; count-- )
-          {
-            gname[0] = CFF_Get_String( &font->string_index,
-                                       first,
-                                       psnames );
-            gname++;
-            first++;
-          }
-        }
-        break;
-      }
-
-    default:   /* unknown charset format! */
-      FT_ERROR(( "CFF_Build_Unicode_Charmap: unknown charset format!\n" ));
-      error = CFF_Err_Invalid_File_Format;
-      goto Fail;
-    }
 
-    /* all right, the glyph names were loaded; we now need to create */
-    /* the corresponding unicode charmap                             */
+    FT_UNUSED( error );
 
-  Fail:
-    for ( n = 0; n < num_glyphs; n++ )
-      FREE( glyph_names[n] );
-
-    FREE( glyph_names );
-
-  Exit:
-    return error;
+    return result;
   }
 
-#endif /* 0 */
-
-
-  static FT_Encoding
-  find_encoding( int  platform_id,
-                 int  encoding_id )
-  {
-    typedef struct  TEncoding
-    {
-      int          platform_id;
-      int          encoding_id;
-      FT_Encoding  encoding;
-
-    } TEncoding;
-
-    static
-    const TEncoding  tt_encodings[] =
-    {
-      { TT_PLATFORM_ISO,           -1,                  ft_encoding_unicode },
-
-      { TT_PLATFORM_APPLE_UNICODE, -1,                  ft_encoding_unicode },
-
-      { TT_PLATFORM_MACINTOSH,     TT_MAC_ID_ROMAN,     ft_encoding_apple_roman },
-
-      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_UNICODE_CS, ft_encoding_unicode },
-      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_SJIS,       ft_encoding_sjis },
-      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_GB2312,     ft_encoding_gb2312 },
-      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_BIG_5,      ft_encoding_big5 },
-      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_WANSUNG,    ft_encoding_wansung },
-      { TT_PLATFORM_MICROSOFT,     TT_MS_ID_JOHAB,      ft_encoding_johab }
-    };
-
-    const TEncoding  *cur, *limit;
 
 
-    cur   = tt_encodings;
-    limit = cur + sizeof ( tt_encodings ) / sizeof ( tt_encodings[0] );
-
-    for ( ; cur < limit; cur++ )
-    {
-      if ( cur->platform_id == platform_id )
-      {
-        if ( cur->encoding_id == encoding_id ||
-             cur->encoding_id == -1          )
-          return cur->encoding;
-      }
-    }
-
-    return ft_encoding_none;
-  }
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    CFF_Face_Init                                                      */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Initializes a given OpenType face object.                          */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    stream     :: The source font stream.                              */
-  /*                                                                       */
-  /*    face_index :: The index of the font face in the resource.          */
-  /*                                                                       */
-  /*    num_params :: Number of additional generic parameters.  Ignored.   */
-  /*                                                                       */
-  /*    params     :: Additional generic parameters.  Ignored.             */
-  /*                                                                       */
-  /* <InOut>                                                               */
-  /*    face       :: The newly built face object.                         */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    FreeType error code.  0 means success.                             */
-  /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Face_Init( FT_Stream      stream,
                  CFF_Face       face,
                  FT_Int         face_index,
                  FT_Int         num_params,
                  FT_Parameter*  params )
   {
-    FT_Error             error;
-    SFNT_Interface*      sfnt;
-    PSNames_Interface*   psnames;
-    PSHinter_Interface*  pshinter;
-    FT_Bool              pure_cff    = 1;
-    FT_Bool              sfnt_format = 0;
+    FT_Error          error;
+    SFNT_Service      sfnt;
+    PSNames_Service   psnames;
+    PSHinter_Service  pshinter;
+    FT_Bool           pure_cff    = 1;
+    FT_Bool           sfnt_format = 0;
 
 
-    sfnt = (SFNT_Interface*)FT_Get_Module_Interface(
+    sfnt = (SFNT_Service)FT_Get_Module_Interface(
              face->root.driver->root.library, "sfnt" );
     if ( !sfnt )
       goto Bad_Format;
 
-    psnames = (PSNames_Interface*)FT_Get_Module_Interface(
+    psnames = (PSNames_Service)FT_Get_Module_Interface(
                 face->root.driver->root.library, "psnames" );
 
-    pshinter = (PSHinter_Interface*)FT_Get_Module_Interface(
+    pshinter = (PSHinter_Service)FT_Get_Module_Interface(
                  face->root.driver->root.library, "pshinter" );
 
     /* create input stream from resource */
-    if ( FILE_Seek( 0 ) )
+    if ( FT_STREAM_SEEK( 0 ) )
       goto Exit;
 
     /* check that we have a valid OpenType file */
@@ -517,20 +324,20 @@
     else
     {
       /* rewind to start of file; we are going to load a pure-CFF font */
-      if ( FILE_Seek( 0 ) )
+      if ( FT_STREAM_SEEK( 0 ) )
         goto Exit;
       error = CFF_Err_Ok;
     }
 
     /* now load and parse the CFF table in the file */
     {
-      CFF_Font*  cff;
+      CFF_Font   cff;
       FT_Memory  memory = face->root.memory;
       FT_Face    root;
       FT_UInt    flags;
 
 
-      if ( ALLOC( cff, sizeof ( *cff ) ) )
+      if ( FT_NEW( cff ) )
         goto Exit;
 
       face->extra.data = cff;
@@ -548,7 +355,7 @@
 
       if ( pure_cff )
       {
-        CFF_Font_Dict*  dict = &cff->top_font.font_dict;
+        CFF_FontRecDict  dict = &cff->top_font.font_dict;
 
 
         /* we need the `PSNames' module for pure-CFF and CEF formats */
@@ -556,7 +363,7 @@
         {
           FT_ERROR(( "CFF_Face_Init:" ));
           FT_ERROR(( " cannot open CFF & CEF fonts\n" ));
-          FT_ERROR(( "             " ));
+          FT_ERROR(( "              " ));
           FT_ERROR(( " without the `PSNames' module\n" ));
           goto Bad_Format;
         }
@@ -571,9 +378,14 @@
           root->num_glyphs = cff->charstrings_index.count;
 
         /* set global bbox, as well as EM size */
-        root->bbox      = dict->font_bbox;
-        root->ascender  = (FT_Short)( root->bbox.yMax >> 16 );
-        root->descender = (FT_Short)( root->bbox.yMin >> 16 );
+        root->bbox.xMin =   dict->font_bbox.xMin             >> 16;
+        root->bbox.yMin =   dict->font_bbox.yMin             >> 16;
+        root->bbox.xMax = ( dict->font_bbox.xMax + 0xFFFFU ) >> 16;
+        root->bbox.yMax = ( dict->font_bbox.yMax + 0xFFFFU ) >> 16;
+
+
+        root->ascender  = (FT_Short)( root->bbox.yMax );
+        root->descender = (FT_Short)( root->bbox.yMin );
         root->height    = (FT_Short)(
           ( ( root->ascender - root->descender ) * 12 ) / 10 );
 
@@ -632,48 +444,8 @@
           flags |= FT_STYLE_FLAG_BOLD;
 
         root->style_flags = flags;
-
-        /* set the charmaps if any */
-        if ( sfnt_format )
-        {
-          /*****************************************************************/
-          /*                                                               */
-          /* Polish the charmaps.                                          */
-          /*                                                               */
-          /*   Try to set the charmap encoding according to the platform & */
-          /*   encoding ID of each charmap.                                */
-          /*                                                               */
-          TT_CharMap  charmap;
-          FT_Int      n;
-
-
-          charmap            = face->charmaps;
-          root->num_charmaps = face->num_charmaps;
-
-          /* allocate table of pointers */
-          if ( ALLOC_ARRAY( root->charmaps, root->num_charmaps, FT_CharMap ) )
-            goto Exit;
-
-          for ( n = 0; n < root->num_charmaps; n++, charmap++ )
-          {
-            FT_Int  platform = charmap->cmap.platformID;
-            FT_Int  encoding = charmap->cmap.platformEncodingID;
-
-
-            charmap->root.face        = (FT_Face)face;
-            charmap->root.platform_id = (FT_UShort)platform;
-            charmap->root.encoding_id = (FT_UShort)encoding;
-            charmap->root.encoding    = find_encoding( platform, encoding );
-
-            /* now, set root->charmap with a unicode charmap */
-            /* wherever available                            */
-            if ( !root->charmap                                &&
-                 charmap->root.encoding == ft_encoding_unicode )
-              root->charmap = (FT_CharMap)charmap;
-
-            root->charmaps[n] = (FT_CharMap)charmap;
-          }
-        }
+        
+        /* XXX: no charmaps for pure CFF fonts currently! */
       }
     }
 
@@ -686,98 +458,42 @@
   }
 
 
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    CFF_Face_Done                                                      */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Finalizes a given face object.                                     */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    face :: A pointer to the face object to destroy.                   */
-  /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CFF_Face_Done( CFF_Face  face )
   {
-    FT_Memory        memory = face->root.memory;
-    SFNT_Interface*  sfnt   = (SFNT_Interface*)face->sfnt;
+    FT_Memory     memory = face->root.memory;
+    SFNT_Service  sfnt   = (SFNT_Service)face->sfnt;
 
 
     if ( sfnt )
       sfnt->done_face( face );
 
     {
-      CFF_Font*  cff = (CFF_Font*)face->extra.data;
+      CFF_Font  cff = (CFF_Font)face->extra.data;
 
 
       if ( cff )
       {
         CFF_Done_Font( cff );
-        FREE( face->extra.data );
+        FT_FREE( face->extra.data );
       }
     }
   }
 
 
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    CFF_Driver_Init                                                    */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Initializes a given OpenType driver object.                        */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    driver :: A handle to the target driver object.                    */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    FreeType error code.  0 means success.                             */
-  /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CFF_Driver_Init( CFF_Driver  driver )
   {
-    /* init extension registry if needed */
-
-#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
-
-    return TT_Init_Extensions( driver );
-
-#else
-
     FT_UNUSED( driver );
 
     return CFF_Err_Ok;
-
-#endif
   }
 
 
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    CFF_Driver_Done                                                    */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    Finalizes a given OpenType driver.                                 */
-  /*                                                                       */
-  /* <Input>                                                               */
-  /*    driver :: A handle to the target OpenType driver.                  */
-  /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CFF_Driver_Done( CFF_Driver  driver )
   {
-    /* destroy extensions registry if needed */
-
-#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
-
-    TT_Done_Extensions( driver );
-
-#else
-
     FT_UNUSED( driver );
-
-#endif
   }
 
 
Index: xc/extras/freetype2/src/cff/cffobjs.h
diff -u xc/extras/freetype2/src/cff/cffobjs.h:1.1.1.4 xc/extras/freetype2/src/cff/cffobjs.h:1.1.1.5
--- xc/extras/freetype2/src/cff/cffobjs.h:1.1.1.4	Mon Jan 14 11:52:12 2002
+++ xc/extras/freetype2/src/cff/cffobjs.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType objects manager (specification).                            */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -109,33 +109,34 @@
   } CFF_DriverRec;
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Size_Init( CFF_Size  size );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CFF_Size_Done( CFF_Size  size );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Size_Reset( CFF_Size  size );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CFF_GlyphSlot_Done( CFF_GlyphSlot  slot );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_GlyphSlot_Init( CFF_GlyphSlot   slot );
 
+
   /*************************************************************************/
   /*                                                                       */
   /* Face functions                                                        */
   /*                                                                       */
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Face_Init( FT_Stream      stream,
                  CFF_Face       face,
                  FT_Int         face_index,
                  FT_Int         num_params,
                  FT_Parameter*  params );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CFF_Face_Done( CFF_Face  face );
 
 
@@ -143,10 +144,10 @@
   /*                                                                       */
   /* Driver functions                                                      */
   /*                                                                       */
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CFF_Driver_Init( CFF_Driver  driver );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CFF_Driver_Done( CFF_Driver  driver );
 
 
Index: xc/extras/freetype2/src/cff/cffparse.c
diff -u xc/extras/freetype2/src/cff/cffparse.c:1.1.1.3 xc/extras/freetype2/src/cff/cffparse.c:1.1.1.4
--- xc/extras/freetype2/src/cff/cffparse.c:1.1.1.3	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cff/cffparse.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CFF token stream parser (body)                                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -48,7 +48,7 @@
 
 
   /* now generate handlers for the most simple fields */
-  typedef FT_Error  (*CFF_Field_Reader)( CFF_Parser*  parser );
+  typedef FT_Error  (*CFF_Field_Reader)( CFF_Parser  parser );
 
   typedef struct  CFF_Field_Handler_
   {
@@ -63,12 +63,12 @@
   } CFF_Field_Handler;
 
 
-  FT_LOCAL_DEF void
-  CFF_Parser_Init( CFF_Parser*  parser,
-                   FT_UInt      code,
-                   void*        object )
+  FT_LOCAL_DEF( void )
+  CFF_Parser_Init( CFF_Parser  parser,
+                   FT_UInt     code,
+                   void*       object )
   {
-    MEM_Set( parser, 0, sizeof ( *parser ) );
+    FT_MEM_SET( parser, 0, sizeof ( *parser ) );
 
     parser->top         = parser->stack;
     parser->object_code = code;
@@ -311,15 +311,15 @@
   }
 
   static FT_Error
-  cff_parse_font_matrix( CFF_Parser*  parser )
+  cff_parse_font_matrix( CFF_Parser  parser )
   {
-    CFF_Font_Dict*  dict   = (CFF_Font_Dict*)parser->object;
-    FT_Matrix*      matrix = &dict->font_matrix;
-    FT_Vector*      offset = &dict->font_offset;
-    FT_UShort*      upm    = &dict->units_per_em;
-    FT_Byte**       data   = parser->stack;
-    FT_Error        error;
-    FT_Fixed        temp;
+    CFF_FontRecDict  dict   = (CFF_FontRecDict)parser->object;
+    FT_Matrix*       matrix = &dict->font_matrix;
+    FT_Vector*       offset = &dict->font_offset;
+    FT_UShort*       upm    = &dict->units_per_em;
+    FT_Byte**        data   = parser->stack;
+    FT_Error         error;
+    FT_Fixed         temp;
 
 
     error = CFF_Err_Stack_Underflow;
@@ -359,12 +359,12 @@
 
 
   static FT_Error
-  cff_parse_font_bbox( CFF_Parser*  parser )
+  cff_parse_font_bbox( CFF_Parser  parser )
   {
-    CFF_Font_Dict*  dict = (CFF_Font_Dict*)parser->object;
-    FT_BBox*        bbox = &dict->font_bbox;
-    FT_Byte**       data = parser->stack;
-    FT_Error        error;
+    CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
+    FT_BBox*         bbox = &dict->font_bbox;
+    FT_Byte**        data = parser->stack;
+    FT_Error         error;
 
 
     error = CFF_Err_Stack_Underflow;
@@ -383,11 +383,11 @@
 
 
   static FT_Error
-  cff_parse_private_dict( CFF_Parser*  parser )
+  cff_parse_private_dict( CFF_Parser  parser )
   {
-    CFF_Font_Dict*  dict = (CFF_Font_Dict*)parser->object;
-    FT_Byte**       data = parser->stack;
-    FT_Error        error;
+    CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
+    FT_Byte**        data = parser->stack;
+    FT_Error         error;
 
 
     error = CFF_Err_Stack_Underflow;
@@ -404,11 +404,11 @@
 
 
   static FT_Error
-  cff_parse_cid_ros( CFF_Parser*  parser )
+  cff_parse_cid_ros( CFF_Parser  parser )
   {
-    CFF_Font_Dict*  dict = (CFF_Font_Dict*)parser->object;
-    FT_Byte**       data = parser->stack;
-    FT_Error        error;
+    CFF_FontRecDict  dict = (CFF_FontRecDict)parser->object;
+    FT_Byte**        data = parser->stack;
+    FT_Error         error;
 
 
     error = CFF_Err_Stack_Underflow;
@@ -479,10 +479,10 @@
   };
 
 
-  FT_LOCAL_DEF FT_Error
-  CFF_Parser_Run( CFF_Parser*  parser,
-                  FT_Byte*     start,
-                  FT_Byte*     limit )
+  FT_LOCAL_DEF( FT_Error )
+  CFF_Parser_Run( CFF_Parser  parser,
+                  FT_Byte*    start,
+                  FT_Byte*    limit )
   {
     FT_Byte*  p     = start;
     FT_Error  error = CFF_Err_Ok;
Index: xc/extras/freetype2/src/cff/cffparse.h
diff -u xc/extras/freetype2/src/cff/cffparse.h:1.1.1.2 xc/extras/freetype2/src/cff/cffparse.h:1.1.1.3
--- xc/extras/freetype2/src/cff/cffparse.h:1.1.1.2	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cff/cffparse.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CFF token stream parser (specification)                              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -34,7 +34,7 @@
 #define CFF_CODE_PRIVATE  0x2000
 
 
-  typedef struct  CFF_Parser_
+  typedef struct  CFF_ParserRec_
   {
     FT_Byte*   start;
     FT_Byte*   limit;
@@ -46,18 +46,18 @@
     FT_UInt    object_code;
     void*      object;
 
-  } CFF_Parser;
+  } CFF_ParserRec, *CFF_Parser;
 
 
-  FT_LOCAL void
-  CFF_Parser_Init( CFF_Parser*  parser,
-                   FT_UInt      code,
-                   void*        object );
-
-  FT_LOCAL FT_Error
-  CFF_Parser_Run( CFF_Parser*  parser,
-                  FT_Byte*     start,
-                  FT_Byte*     limit );
+  FT_LOCAL( void )
+  CFF_Parser_Init( CFF_Parser  parser,
+                   FT_UInt     code,
+                   void*       object );
+
+  FT_LOCAL( FT_Error )
+  CFF_Parser_Run( CFF_Parser  parser,
+                  FT_Byte*    start,
+                  FT_Byte*    limit );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/cff/cfftoken.h
diff -u xc/extras/freetype2/src/cff/cfftoken.h:1.1.1.2 xc/extras/freetype2/src/cff/cfftoken.h:1.1.1.3
--- xc/extras/freetype2/src/cff/cfftoken.h:1.1.1.2	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cff/cfftoken.h	Thu Jun 20 04:16:17 2002
@@ -2,9 +2,9 @@
 /*                                                                         */
 /*  cfftoken.h                                                             */
 /*                                                                         */
-/*    CFF token definitions                                                */
+/*    CFF token definitions (specification only).                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -17,10 +17,10 @@
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  CFF_Font_Dict
+#define FT_STRUCTURE  CFF_FontRecDictRec
 
 #undef  CFFCODE
-#define CFFCODE        CFFCODE_TOPDICT
+#define CFFCODE       CFFCODE_TOPDICT
 
   CFF_FIELD_STRING  ( 0,     version )
   CFF_FIELD_STRING  ( 1,     notice )
@@ -68,7 +68,7 @@
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  CFF_Private
+#define FT_STRUCTURE  CFF_PrivateRec
 #undef  CFFCODE
 #define CFFCODE       CFFCODE_PRIVATE
 
Index: xc/extras/freetype2/src/cff/descrip.mms
diff -u xc/extras/freetype2/src/cff/descrip.mms:1.1.1.1 xc/extras/freetype2/src/cff/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/cff/descrip.mms:1.1.1.1	Tue May 15 23:45:32 2001
+++ xc/extras/freetype2/src/cff/descrip.mms	Thu Jun 20 04:16:17 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,6 @@
 OBJS=cff.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/cff/rules.mk
diff -u xc/extras/freetype2/src/cff/rules.mk:1.1.1.3 xc/extras/freetype2/src/cff/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/cff/rules.mk:1.1.1.3	Sun Sep  9 22:56:03 2001
+++ xc/extras/freetype2/src/cff/rules.mk	Thu Jun 20 04:16:17 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/cid/cidgload.c
diff -u xc/extras/freetype2/src/cid/cidgload.c:1.1.1.5 xc/extras/freetype2/src/cid/cidgload.c:1.1.1.6
--- xc/extras/freetype2/src/cid/cidgload.c:1.1.1.5	Mon Jan 14 11:52:12 2002
+++ xc/extras/freetype2/src/cid/cidgload.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID-keyed Type1 Glyph Loader (body).                                 */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -37,23 +37,23 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  cid_load_glyph( T1_Decoder*  decoder,
-                  FT_UInt      glyph_index )
+  cid_load_glyph( T1_Decoder  decoder,
+                  FT_UInt     glyph_index )
   {
-    CID_Face   face = (CID_Face)decoder->builder.face;
-    CID_Info*  cid  = &face->cid;
-    FT_Byte*   p;
-    FT_UInt    entry_len = cid->fd_bytes + cid->gd_bytes;
-    FT_UInt    fd_select;
-    FT_ULong   off1, glyph_len;
-    FT_Stream  stream = face->root.stream;
-    FT_Error   error  = 0;
+    CID_Face      face = (CID_Face)decoder->builder.face;
+    CID_FaceInfo  cid  = &face->cid;
+    FT_Byte*      p;
+    FT_UInt       entry_len = cid->fd_bytes + cid->gd_bytes;
+    FT_UInt       fd_select;
+    FT_ULong      off1, glyph_len;
+    FT_Stream     stream = face->root.stream;
+    FT_Error      error  = 0;
 
 
     /* read the CID font dict index and charstring offset from the CIDMap */
-    if ( FILE_Seek( cid->data_offset + cid->cidmap_offset +
-                    glyph_index * entry_len )               ||
-         ACCESS_Frame( 2 * entry_len )                      )
+    if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
+                         glyph_index * entry_len )               ||
+         FT_FRAME_ENTER( 2 * entry_len )                         )
       goto Exit;
 
     p = (FT_Byte*)stream->cursor;
@@ -62,16 +62,16 @@
     p        += cid->fd_bytes;
     glyph_len = cid_get_offset( &p, (FT_Byte)cid->gd_bytes ) - off1;
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     /* now, if the glyph is not empty, set up the subrs array, and parse */
     /* the charstrings                                                   */
     if ( glyph_len > 0 )
     {
-      CID_FontDict*  dict;
-      CID_Subrs*     cid_subrs = face->subrs + fd_select;
-      FT_Byte*       charstring;
-      FT_Memory      memory = face->root.memory;
+      CID_FaceDict  dict;
+      CID_Subrs     cid_subrs = face->subrs + fd_select;
+      FT_Byte*      charstring;
+      FT_Memory     memory = face->root.memory;
 
 
       /* setup subrs */
@@ -89,12 +89,13 @@
       /* the charstrings are encoded (stupid!)  */
       /* load the charstrings, then execute it  */
 
-      if ( ALLOC( charstring, glyph_len ) )
+      if ( FT_ALLOC( charstring, glyph_len ) )
         goto Exit;
 
-      if ( !FILE_Read_At( cid->data_offset + off1, charstring, glyph_len ) )
+      if ( !FT_STREAM_READ_AT( cid->data_offset + off1,
+                               charstring, glyph_len ) )
       {
-        FT_Int cs_offset;
+        FT_Int  cs_offset;
 
 
         /* Adjustment for seed bytes. */
@@ -109,7 +110,7 @@
                                                   glyph_len  - cs_offset  );
       }
 
-      FREE( charstring );
+      FT_FREE( charstring );
     }
 
   Exit:
@@ -138,15 +139,15 @@
   /*************************************************************************/
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CID_Compute_Max_Advance( CID_Face  face,
                            FT_Int*   max_advance )
   {
-    FT_Error    error;
-    T1_Decoder  decoder;
-    FT_Int      glyph_index;
+    FT_Error       error;
+    T1_DecoderRec  decoder;
+    FT_Int         glyph_index;
 
-    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
 
 
     *max_advance = 0;
@@ -201,20 +202,20 @@
   /*************************************************************************/
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CID_Load_Glyph( CID_GlyphSlot  glyph,
                   CID_Size       size,
                   FT_Int         glyph_index,
                   FT_Int         load_flags )
   {
-    FT_Error    error;
-    T1_Decoder  decoder;
-    CID_Face    face = (CID_Face)glyph->root.face;
-    FT_Bool     hinting;
-
-    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;
-    FT_Matrix         font_matrix;
-    FT_Vector         font_offset;
+    FT_Error       error;
+    T1_DecoderRec  decoder;
+    CID_Face       face = (CID_Face)glyph->root.face;
+    FT_Bool        hinting;
+
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
+    FT_Matrix      font_matrix;
+    FT_Vector      font_offset;
 
 
     if ( load_flags & FT_LOAD_NO_RECURSE )
Index: xc/extras/freetype2/src/cid/cidgload.h
diff -u xc/extras/freetype2/src/cid/cidgload.h:1.1.1.3 xc/extras/freetype2/src/cid/cidgload.h:1.1.1.4
--- xc/extras/freetype2/src/cid/cidgload.h:1.1.1.3	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cid/cidgload.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    OpenType Glyph Loader (specification).                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -30,13 +30,13 @@
 #if 0
 
   /* Compute the maximum advance width of a font through quick parsing */
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_Compute_Max_Advance( CID_Face  face,
                            FT_Int*   max_advance );
 
 #endif /* 0 */
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_Load_Glyph( CID_GlyphSlot  glyph,
                   CID_Size       size,
                   FT_Int         glyph_index,
Index: xc/extras/freetype2/src/cid/cidload.c
diff -u xc/extras/freetype2/src/cid/cidload.c:1.1.1.5 xc/extras/freetype2/src/cid/cidload.c:1.1.1.6
--- xc/extras/freetype2/src/cid/cidload.c:1.1.1.5	Mon Jan 14 11:52:13 2002
+++ xc/extras/freetype2/src/cid/cidload.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID-keyed Type1 font loader (body).                                  */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -26,10 +26,7 @@
 
 #include "ciderrs.h"
 
-#include <stdio.h>
-#include <ctype.h>  /* for isspace(), isalnum() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -41,7 +38,7 @@
 
 
   /* read a single offset */
-  FT_LOCAL_DEF FT_Long
+  FT_LOCAL_DEF( FT_Long )
   cid_get_offset( FT_Byte**  start,
                   FT_Byte    offsize )
   {
@@ -60,7 +57,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   cid_decrypt( FT_Byte*   buffer,
                FT_Offset  length,
                FT_UShort  seed )
@@ -88,19 +85,19 @@
 
 
   static FT_Error
-  cid_load_keyword( CID_Face         face,
-                    CID_Loader*      loader,
-                    const T1_Field*  keyword )
-  {
-    FT_Error     error;
-    CID_Parser*  parser = &loader->parser;
-    FT_Byte*     object;
-    void*        dummy_object;
-    CID_Info*    cid = &face->cid;
+  cid_load_keyword( CID_Face        face,
+                    CID_Loader*     loader,
+                    const T1_Field  keyword )
+  {
+    FT_Error      error;
+    CID_Parser*   parser = &loader->parser;
+    FT_Byte*      object;
+    void*         dummy_object;
+    CID_FaceInfo  cid = &face->cid;
 
 
     /* if the keyword has a dedicated callback, call it */
-    if ( keyword->type == t1_field_callback )
+    if ( keyword->type == T1_FIELD_TYPE_CALLBACK )
     {
       keyword->reader( (FT_Face)face, parser );
       error = parser->root.error;
@@ -110,17 +107,17 @@
     /* we must now compute the address of our target object */
     switch ( keyword->location )
     {
-    case t1_field_cid_info:
+    case T1_FIELD_LOCATION_CID_INFO:
       object = (FT_Byte*)cid;
       break;
 
-    case t1_field_font_info:
+    case T1_FIELD_LOCATION_FONT_INFO:
       object = (FT_Byte*)&cid->font_info;
       break;
 
     default:
       {
-        CID_FontDict*  dict;
+        CID_FaceDict  dict;
 
 
         if ( parser->num_dict < 0 )
@@ -134,7 +131,7 @@
         dict = cid->font_dicts + parser->num_dict;
         switch ( keyword->location )
         {
-        case t1_field_private:
+        case T1_FIELD_LOCATION_PRIVATE:
           object = (FT_Byte*)&dict->private_dict;
           break;
 
@@ -147,8 +144,8 @@
     dummy_object = object;
 
     /* now, load the keyword data in the object's field(s) */
-    if ( keyword->type == t1_field_integer_array ||
-         keyword->type == t1_field_fixed_array   )
+    if ( keyword->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
+         keyword->type == T1_FIELD_TYPE_FIXED_ARRAY   )
       error = CID_Load_Field_Table( &loader->parser, keyword,
                                     &dummy_object );
     else
@@ -181,12 +178,12 @@
   parse_font_matrix( CID_Face     face,
                      CID_Parser*  parser )
   {
-    FT_Matrix*     matrix;
-    FT_Vector*     offset;
-    CID_FontDict*  dict;
-    FT_Face        root = (FT_Face)&face->root;
-    FT_Fixed       temp[6];
-    FT_Fixed       temp_scale;
+    FT_Matrix*    matrix;
+    FT_Vector*    offset;
+    CID_FaceDict  dict;
+    FT_Face       root = (FT_Face)&face->root;
+    FT_Fixed      temp[6];
+    FT_Fixed      temp_scale;
 
 
     if ( parser->num_dict >= 0 )
@@ -235,10 +232,10 @@
   parse_fd_array( CID_Face     face,
                   CID_Parser*  parser )
   {
-    CID_Info*  cid    = &face->cid;
-    FT_Memory  memory = face->root.memory;
-    FT_Error   error  = CID_Err_Ok;
-    FT_Long    num_dicts;
+    CID_FaceInfo  cid    = &face->cid;
+    FT_Memory     memory = face->root.memory;
+    FT_Error      error  = CID_Err_Ok;
+    FT_Long       num_dicts;
 
 
     num_dicts = CID_ToInt( parser );
@@ -248,7 +245,7 @@
       FT_Int  n;
 
 
-      if ( ALLOC_ARRAY( cid->font_dicts, num_dicts, CID_FontDict ) )
+      if ( FT_NEW_ARRAY( cid->font_dicts, num_dicts ) )
         goto Exit;
 
       cid->num_dicts = (FT_UInt)num_dicts;
@@ -256,7 +253,7 @@
       /* don't forget to set a few defaults */
       for ( n = 0; n < cid->num_dicts; n++ )
       {
-        CID_FontDict*  dict = cid->font_dicts + n;
+        CID_FaceDict  dict = cid->font_dicts + n;
 
 
         /* default value for lenIV */
@@ -270,7 +267,7 @@
 
 
   static
-  const T1_Field  cid_field_records[] =
+  const T1_FieldRec  cid_field_records[] =
   {
 
 #include "cidtoken.h"
@@ -278,16 +275,16 @@
     T1_FIELD_CALLBACK( "FontBBox", parse_font_bbox )
     T1_FIELD_CALLBACK( "FDArray", parse_fd_array )
     T1_FIELD_CALLBACK( "FontMatrix", parse_font_matrix )
-    { 0, t1_field_cid_info, t1_field_none, 0, 0, 0, 0, 0 }
+    { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0 }
   };
 
 
   static int
   is_alpha( char  c )
   {
-    return ( isalnum( (int)c ) ||
-             c == '.'          ||
-             c == '_'          );
+    return ( ft_isalnum( (int)c ) ||
+             c == '.'             ||
+             c == '_'             );
   }
 
 
@@ -313,7 +310,7 @@
       {
         /* look for `%ADOBeginFontDict' */
         if ( *cur == '%' && cur + 20 < limit &&
-             strncmp( (char*)cur, "%ADOBeginFontDict", 17 ) == 0 )
+             ft_strncmp( (char*)cur, "%ADOBeginFontDict", 17 ) == 0 )
         {
           cur += 17;
 
@@ -339,7 +336,7 @@
           if ( len > 0 && len < 22 )
           {
             /* now compare the immediate name to the keyword table */
-            const T1_Field*  keyword = cid_field_records;
+            T1_Field  keyword = (T1_Field) cid_field_records;
 
 
             for (;;)
@@ -352,7 +349,7 @@
                 break;
 
               if ( cur[0] == name[0]                          &&
-                   len == (FT_Int)strlen( (const char*)name ) )
+                   len == (FT_Int)ft_strlen( (const char*)name ) )
               {
                 FT_Int  n;
 
@@ -390,27 +387,27 @@
   static FT_Error
   cid_read_subrs( CID_Face  face )
   {
-    CID_Info*   cid    = &face->cid;
-    FT_Memory   memory = face->root.memory;
-    FT_Stream   stream = face->root.stream;
-    FT_Error    error;
-    FT_Int      n;
-    CID_Subrs*  subr;
-    FT_UInt     max_offsets = 0;
-    FT_ULong*   offsets = 0;
+    CID_FaceInfo  cid    = &face->cid;
+    FT_Memory     memory = face->root.memory;
+    FT_Stream     stream = face->root.stream;
+    FT_Error      error;
+    FT_Int        n;
+    CID_Subrs     subr;
+    FT_UInt       max_offsets = 0;
+    FT_ULong*     offsets = 0;
 
 
-    if ( ALLOC_ARRAY( face->subrs, cid->num_dicts, CID_Subrs ) )
+    if ( FT_NEW_ARRAY( face->subrs, cid->num_dicts ) )
       goto Exit;
 
     subr = face->subrs;
     for ( n = 0; n < cid->num_dicts; n++, subr++ )
     {
-      CID_FontDict*  dict  = cid->font_dicts + n;
-      FT_Int         lenIV = dict->private_dict.lenIV;
-      FT_UInt        count, num_subrs = dict->num_subrs;
-      FT_ULong       data_len;
-      FT_Byte*       p;
+      CID_FaceDict  dict  = cid->font_dicts + n;
+      FT_Int        lenIV = dict->private_dict.lenIV;
+      FT_UInt       count, num_subrs = dict->num_subrs;
+      FT_ULong      data_len;
+      FT_Byte*      p;
 
 
       /* reallocate offsets array if needed */
@@ -419,33 +416,33 @@
         FT_UInt  new_max = ( num_subrs + 1 + 3 ) & -4;
 
 
-        if ( REALLOC_ARRAY( offsets, max_offsets, new_max, FT_ULong ) )
+        if ( FT_RENEW_ARRAY( offsets, max_offsets, new_max ) )
           goto Fail;
 
         max_offsets = new_max;
       }
 
       /* read the subrmap's offsets */
-      if ( FILE_Seek( cid->data_offset + dict->subrmap_offset ) ||
-           ACCESS_Frame( ( num_subrs + 1 ) * dict->sd_bytes )   )
+      if ( FT_STREAM_SEEK( cid->data_offset + dict->subrmap_offset ) ||
+           FT_FRAME_ENTER( ( num_subrs + 1 ) * dict->sd_bytes )   )
         goto Fail;
 
       p = (FT_Byte*)stream->cursor;
       for ( count = 0; count <= num_subrs; count++ )
         offsets[count] = cid_get_offset( &p, (FT_Byte)dict->sd_bytes );
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       /* now, compute the size of subrs charstrings, */
       /* allocate, and read them                     */
       data_len = offsets[num_subrs] - offsets[0];
 
-      if ( ALLOC_ARRAY( subr->code, num_subrs + 1, FT_Byte* ) ||
-           ALLOC( subr->code[0], data_len )                   )
+      if ( FT_NEW_ARRAY( subr->code, num_subrs + 1 ) ||
+               FT_ALLOC( subr->code[0], data_len )   )
         goto Fail;
 
-      if ( FILE_Seek( cid->data_offset + offsets[0] ) ||
-           FILE_Read( subr->code[0], data_len )  )
+      if ( FT_STREAM_SEEK( cid->data_offset + offsets[0] ) ||
+           FT_STREAM_READ( subr->code[0], data_len )  )
         goto Fail;
 
       /* set up pointers */
@@ -475,7 +472,7 @@
     }
 
   Exit:
-    FREE( offsets );
+    FT_FREE( offsets );
     return error;
 
   Fail:
@@ -484,11 +481,11 @@
       for ( n = 0; n < cid->num_dicts; n++ )
       {
         if ( face->subrs[n].code )
-          FREE( face->subrs[n].code[0] );
+          FT_FREE( face->subrs[n].code[0] );
 
-        FREE( face->subrs[n].code );
+        FT_FREE( face->subrs[n].code );
       }
-      FREE( face->subrs );
+      FT_FREE( face->subrs );
     }
     goto Exit;
   }
@@ -500,7 +497,7 @@
   {
     FT_UNUSED( face );
 
-    MEM_Set( loader, 0, sizeof ( *loader ) );
+    FT_MEM_SET( loader, 0, sizeof ( *loader ) );
   }
 
 
@@ -515,19 +512,19 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CID_Open_Face( CID_Face  face )
   {
-    CID_Loader  loader;
-    CID_Parser* parser;
-    FT_Error   error;
+    CID_Loader   loader;
+    CID_Parser*  parser;
+    FT_Error     error;
 
 
     t1_init_loader( &loader, face );
 
     parser = &loader.parser;
     error = CID_New_Parser( parser, face->root.stream, face->root.memory,
-                            (PSAux_Interface*)face->psaux );
+                            (PSAux_Service)face->psaux );
     if ( error )
       goto Exit;
 
Index: xc/extras/freetype2/src/cid/cidload.h
diff -u xc/extras/freetype2/src/cid/cidload.h:1.1.1.3 xc/extras/freetype2/src/cid/cidload.h:1.1.1.4
--- xc/extras/freetype2/src/cid/cidload.h:1.1.1.3	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cid/cidload.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID-keyed Type1 font loader (specification).                         */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -36,16 +36,16 @@
   } CID_Loader;
 
 
-  FT_LOCAL FT_Long
+  FT_LOCAL( FT_Long )
   cid_get_offset( FT_Byte**  start,
                   FT_Byte    offsize );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   cid_decrypt( FT_Byte*   buffer,
                FT_Offset  length,
                FT_UShort  seed );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_Open_Face( CID_Face  face );
 
 
Index: xc/extras/freetype2/src/cid/cidobjs.c
diff -u xc/extras/freetype2/src/cid/cidobjs.c:1.1.1.5 xc/extras/freetype2/src/cid/cidobjs.c:1.1.1.7
--- xc/extras/freetype2/src/cid/cidobjs.c:1.1.1.5	Mon Jan 14 11:52:13 2002
+++ xc/extras/freetype2/src/cid/cidobjs.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID objects manager (body).                                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -44,22 +44,22 @@
   /*                                                                       */
   /*************************************************************************/
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CID_GlyphSlot_Done( CID_GlyphSlot  slot )
   {
     slot->root.internal->glyph_hints = 0;
   }
 
 
-  FT_LOCAL_DEF FT_Error
-  CID_GlyphSlot_Init( CID_GlyphSlot   slot )
+  FT_LOCAL_DEF( FT_Error )
+  CID_GlyphSlot_Init( CID_GlyphSlot  slot )
   {
-    CID_Face             face;
-    PSHinter_Interface*  pshinter;
+    CID_Face          face;
+    PSHinter_Service  pshinter;
 
 
-    face     = (CID_Face) slot->root.face;
-    pshinter = face->pshinter;
+    face     = (CID_Face)slot->root.face;
+    pshinter = (PSHinter_Service)face->pshinter;
 
     if ( pshinter )
     {
@@ -92,9 +92,9 @@
   static PSH_Globals_Funcs
   CID_Size_Get_Globals_Funcs( CID_Size  size )
   {
-    CID_Face             face     = (CID_Face)size->root.face;
-    PSHinter_Interface*  pshinter = face->pshinter;
-    FT_Module            module;
+    CID_Face          face     = (CID_Face)size->root.face;
+    PSHinter_Service  pshinter = (PSHinter_Service)face->pshinter;
+    FT_Module         module;
 
 
     module = FT_Get_Module( size->root.face->driver->root.library,
@@ -105,7 +105,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CID_Size_Done( CID_Size  size )
   {
     if ( size->root.internal )
@@ -122,7 +122,7 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CID_Size_Init( CID_Size  size )
   {
     FT_Error           error = 0;
@@ -131,10 +131,10 @@
 
     if ( funcs )
     {
-      PSH_Globals    globals;
-      CID_Face       face = (CID_Face)size->root.face;
-      CID_FontDict*  dict = face->cid.font_dicts + face->root.face_index;
-      T1_Private*    priv = &dict->private_dict;
+      PSH_Globals   globals;
+      CID_Face      face = (CID_Face)size->root.face;
+      CID_FaceDict  dict = face->cid.font_dicts + face->root.face_index;
+      PS_Private    priv = &dict->private_dict;
 
 
       error = funcs->create( size->root.face->memory, priv, &globals );
@@ -146,7 +146,7 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CID_Size_Reset( CID_Size  size )
   {
     PSH_Globals_Funcs  funcs = CID_Size_Get_Globals_Funcs( size );
@@ -162,15 +162,12 @@
   }
 
 
-
-
   /*************************************************************************/
   /*                                                                       */
   /*                           FACE  FUNCTIONS                             */
   /*                                                                       */
   /*************************************************************************/
 
-
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
@@ -182,7 +179,7 @@
   /* <Input>                                                               */
   /*    face :: A pointer to the face object to destroy.                   */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CID_Face_Done( CID_Face  face )
   {
     FT_Memory  memory;
@@ -190,8 +187,8 @@
 
     if ( face )
     {
-      CID_Info*     cid  = &face->cid;
-      T1_FontInfo*  info = &cid->font_info;
+      CID_FaceInfo  cid  = &face->cid;
+      PS_FontInfo   info = &cid->font_info;
 
 
       memory = face->root.memory;
@@ -199,39 +196,39 @@
       /* release subrs */
       if ( face->subrs )
       {
-        FT_Int      n;
+        FT_Int  n;
         
 
         for ( n = 0; n < cid->num_dicts; n++ )
         {
-          CID_Subrs*  subr = face->subrs + n;
+          CID_Subrs  subr = face->subrs + n;
           
 
           if ( subr->code )
           {
-            FREE( subr->code[0] );
-            FREE( subr->code );
+            FT_FREE( subr->code[0] );
+            FT_FREE( subr->code );
           }
         }
 
-        FREE( face->subrs );
+        FT_FREE( face->subrs );
       }
 
       /* release FontInfo strings */
-      FREE( info->version );
-      FREE( info->notice );
-      FREE( info->full_name );
-      FREE( info->family_name );
-      FREE( info->weight );
+      FT_FREE( info->version );
+      FT_FREE( info->notice );
+      FT_FREE( info->full_name );
+      FT_FREE( info->family_name );
+      FT_FREE( info->weight );
 
       /* release font dictionaries */
-      FREE( cid->font_dicts );
+      FT_FREE( cid->font_dicts );
       cid->num_dicts = 0;
 
       /* release other strings */
-      FREE( cid->cid_font_name );
-      FREE( cid->registry );
-      FREE( cid->ordering );
+      FT_FREE( cid->cid_font_name );
+      FT_FREE( cid->registry );
+      FT_FREE( cid->ordering );
 
       face->root.family_name = 0;
       face->root.style_name  = 0;
@@ -262,17 +259,17 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CID_Face_Init( FT_Stream      stream,
                  CID_Face       face,
                  FT_Int         face_index,
                  FT_Int         num_params,
                  FT_Parameter*  params )
   {
-    FT_Error             error;
-    PSNames_Interface*   psnames;
-    PSAux_Interface*     psaux;
-    PSHinter_Interface*  pshinter;
+    FT_Error          error;
+    PSNames_Service   psnames;
+    PSAux_Service     psaux;
+    PSHinter_Service  pshinter;
 
     FT_UNUSED( num_params );
     FT_UNUSED( params );
@@ -282,35 +279,35 @@
 
     face->root.num_faces = 1;
 
-    psnames = (PSNames_Interface*)face->psnames;
+    psnames = (PSNames_Service)face->psnames;
     if ( !psnames )
     {
-      psnames = (PSNames_Interface*)FT_Get_Module_Interface(
+      psnames = (PSNames_Service)FT_Get_Module_Interface(
                   FT_FACE_LIBRARY( face ), "psnames" );
 
       face->psnames = psnames;
     }
 
-    psaux = (PSAux_Interface*)face->psaux;
+    psaux = (PSAux_Service)face->psaux;
     if ( !psaux )
     {
-      psaux = (PSAux_Interface*)FT_Get_Module_Interface(
+      psaux = (PSAux_Service)FT_Get_Module_Interface(
                 FT_FACE_LIBRARY( face ), "psaux" );
 
       face->psaux = psaux;
     }
 
-    pshinter = (PSHinter_Interface*)face->pshinter;
+    pshinter = (PSHinter_Service)face->pshinter;
     if ( !pshinter )
     {
-      pshinter = (PSHinter_Interface*)FT_Get_Module_Interface(
+      pshinter = (PSHinter_Service)FT_Get_Module_Interface(
                    FT_FACE_LIBRARY( face ), "pshinter" );
 
       face->pshinter = pshinter;
     }
 
     /* open the tokenizer; this will also check the font format */
-    if ( FILE_Seek( 0 ) )
+    if ( FT_STREAM_SEEK( 0 ) )
       goto Exit;
 
     error = CID_Open_Face( face );
@@ -381,41 +378,19 @@
         root->num_fixed_sizes = 0;
         root->available_sizes = 0;
 
-        root->bbox = face->cid.font_bbox;
+        root->bbox.xMin =   face->cid.font_bbox.xMin             >> 16;
+        root->bbox.yMin =   face->cid.font_bbox.yMin             >> 16;
+        root->bbox.xMax = ( face->cid.font_bbox.xMax + 0xFFFFU ) >> 16;
+        root->bbox.yMax = ( face->cid.font_bbox.yMax + 0xFFFFU ) >> 16;
+
         if ( !root->units_per_EM )
           root->units_per_EM  = 1000;
 
-        root->ascender  = (FT_Short)( face->cid.font_bbox.yMax >> 16 );
-        root->descender = (FT_Short)( face->cid.font_bbox.yMin >> 16 );
+        root->ascender  = (FT_Short)( root->bbox.yMax );
+        root->descender = (FT_Short)( root->bbox.yMin );
         root->height    = (FT_Short)(
           ( ( root->ascender + root->descender ) * 12 ) / 10 );
 
-
-#if 0
-
-        /* now compute the maximum advance width */
-
-        root->max_advance_width = face->type1.private_dict.standard_width[0];
-
-        /* compute max advance width for proportional fonts */
-        if ( !face->type1.font_info.is_fixed_pitch )
-        {
-          FT_Int  max_advance;
-
-
-          error = CID_Compute_Max_Advance( face, &max_advance );
-
-          /* in case of error, keep the standard width */
-          if ( !error )
-            root->max_advance_width = max_advance;
-          else
-            error = 0;   /* clear error */
-        }
-
-        root->max_advance_height = root->height;
-
-#endif /* 0 */
-
         root->underline_position  = face->cid.font_info.underline_position;
         root->underline_thickness = face->cid.font_info.underline_thickness;
 
@@ -424,74 +399,6 @@
       }
     }
 
-#if 0
-
-    /* charmap support - synthetize unicode charmap when possible */
-    {
-      FT_Face      root    = &face->root;
-      FT_CharMap   charmap = face->charmaprecs;
-
-
-      /* synthesize a Unicode charmap if there is support in the `psnames' */
-      /* module                                                            */
-      if ( face->psnames )
-      {
-        PSNames_Interface*  psnames = (PSNames_Interface*)face->psnames;
-
-
-        if ( psnames->unicode_value )
-        {
-          error = psnames->build_unicodes(
-                             root->memory,
-                             face->type1.num_glyphs,
-                             (const char**)face->type1.glyph_names,
-                             &face->unicode_map );
-          if ( !error )
-          {
-            root->charmap        = charmap;
-            charmap->face        = (FT_Face)face;
-            charmap->encoding    = ft_encoding_unicode;
-            charmap->platform_id = 3;
-            charmap->encoding_id = 1;
-            charmap++;
-          }
-
-          /* simply clear the error in case of failure (which really */
-          /* means that out of memory or no unicode glyph names)     */
-          error = 0;
-        }
-      }
-
-      /* now, support either the standard, expert, or custom encodings */
-      charmap->face        = (FT_Face)face;
-      charmap->platform_id = 7;  /* a new platform id for Adobe fonts? */
-
-      switch ( face->type1.encoding_type )
-      {
-      case t1_encoding_standard:
-        charmap->encoding    = ft_encoding_adobe_standard;
-        charmap->encoding_id = 0;
-        break;
-
-      case t1_encoding_expert:
-        charmap->encoding    = ft_encoding_adobe_expert;
-        charmap->encoding_id = 1;
-        break;
-
-      default:
-        charmap->encoding    = ft_encoding_adobe_custom;
-        charmap->encoding_id = 2;
-        break;
-      }
-
-      root->charmaps     = face->charmaps;
-      root->num_charmaps = charmap - face->charmaprecs + 1;
-      face->charmaps[0]  = &face->charmaprecs[0];
-      face->charmaps[1]  = &face->charmaprecs[1];
-    }
-
-#endif /* 0 */
-
   Exit:
     return error;
   }
@@ -511,7 +418,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   CID_Driver_Init( CID_Driver  driver )
   {
     FT_UNUSED( driver );
@@ -531,7 +438,7 @@
   /* <Input>                                                               */
   /*    driver :: A handle to the target CID driver.                       */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CID_Driver_Done( CID_Driver  driver )
   {
     FT_UNUSED( driver );
Index: xc/extras/freetype2/src/cid/cidobjs.h
diff -u xc/extras/freetype2/src/cid/cidobjs.h:1.1.1.5 xc/extras/freetype2/src/cid/cidobjs.h:1.1.1.6
--- xc/extras/freetype2/src/cid/cidobjs.h:1.1.1.5	Mon Jan 14 11:52:13 2002
+++ xc/extras/freetype2/src/cid/cidobjs.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID objects manager (specification).                                 */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -111,26 +111,26 @@
   } CID_GlyphSlotRec;
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CID_GlyphSlot_Done( CID_GlyphSlot  slot );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_GlyphSlot_Init( CID_GlyphSlot   slot );
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CID_Size_Done( CID_Size  size );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_Size_Init( CID_Size  size );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_Size_Reset( CID_Size  size );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_Face_Init( FT_Stream      stream,
                  CID_Face       face,
                  FT_Int         face_index,
@@ -138,15 +138,15 @@
                  FT_Parameter*  params );
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CID_Face_Done( CID_Face  face );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   CID_Driver_Init( CID_Driver  driver );
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CID_Driver_Done( CID_Driver  driver );
 
 
Index: xc/extras/freetype2/src/cid/cidparse.c
diff -u xc/extras/freetype2/src/cid/cidparse.c:1.1.1.4 xc/extras/freetype2/src/cid/cidparse.c:1.1.1.5
--- xc/extras/freetype2/src/cid/cidparse.c:1.1.1.4	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cid/cidparse.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID-keyed Type1 parser (body).                                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -26,9 +26,7 @@
 
 #include "ciderrs.h"
 
-#include <string.h>     /* for strncmp() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -50,11 +48,11 @@
   /*************************************************************************/
 
 
-  FT_LOCAL_DEF FT_Error
-  CID_New_Parser( CID_Parser*       parser,
-                  FT_Stream         stream,
-                  FT_Memory         memory,
-                  PSAux_Interface*  psaux )
+  FT_LOCAL_DEF( FT_Error )
+  CID_New_Parser( CID_Parser*    parser,
+                  FT_Stream      stream,
+                  FT_Memory      memory,
+                  PSAux_Service  psaux )
   {
     FT_Error  error;
     FT_ULong  base_offset, offset, ps_len;
@@ -62,25 +60,25 @@
     FT_Int    buff_len;
 
 
-    MEM_Set( parser, 0, sizeof ( *parser ) );
-    psaux->t1_parser_funcs->init( &parser->root, 0, 0, memory );
+    FT_MEM_SET( parser, 0, sizeof ( *parser ) );
+    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
 
     parser->stream = stream;
 
-    base_offset = FILE_Pos();
+    base_offset = FT_STREAM_POS();
 
     /* first of all, check the font format in the  header */
-    if ( ACCESS_Frame( 31 ) )
+    if ( FT_FRAME_ENTER( 31 ) )
       goto Exit;
 
-    if ( strncmp( (char *)stream->cursor,
-                  "%!PS-Adobe-3.0 Resource-CIDFont", 31 ) )
+    if ( ft_strncmp( (char *)stream->cursor,
+                     "%!PS-Adobe-3.0 Resource-CIDFont", 31 ) )
     {
       FT_TRACE2(( "[not a valid CID-keyed font]\n" ));
       error = CID_Err_Unknown_File_Format;
     }
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
     if ( error )
       goto Exit;
 
@@ -95,20 +93,20 @@
       /* fill input buffer */
       buff_len -= 256;
       if ( buff_len > 0 )
-        MEM_Move( buffer, limit, buff_len );
+        FT_MEM_MOVE( buffer, limit, buff_len );
 
       p = buffer + buff_len;
 
-      if ( FILE_Read( p, 256 + 10 - buff_len ) )
+      if ( FT_STREAM_READ( p, 256 + 10 - buff_len ) )
         goto Exit;
 
-      top_position = FILE_Pos() - buff_len;
+      top_position = FT_STREAM_POS() - buff_len;
       buff_len = 256 + 10;
 
       /* look for `StartData' */
       for ( p = buffer; p < limit; p++ )
       {
-        if ( p[0] == 'S' && strncmp( (char*)p, "StartData", 9 ) == 0 )
+        if ( p[0] == 'S' && ft_strncmp( (char*)p, "StartData", 9 ) == 0 )
         {
           /* save offset of binary data after `StartData' */
           offset = (FT_ULong)( top_position - ( limit - p ) + 10 );
@@ -123,8 +121,8 @@
     /* section                                                         */
 
     ps_len = offset - base_offset;
-    if ( FILE_Seek( base_offset )                    ||
-         EXTRACT_Frame( ps_len, parser->postscript ) )
+    if ( FT_STREAM_SEEK( base_offset )                    ||
+         FT_FRAME_EXTRACT( ps_len, parser->postscript ) )
       goto Exit;
 
     parser->data_offset    = offset;
@@ -139,7 +137,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   CID_Done_Parser( CID_Parser*  parser )
   {
     /* always free the private dictionary */
@@ -148,7 +146,7 @@
       FT_Stream  stream = parser->stream;
 
 
-      RELEASE_Frame( parser->postscript );
+      FT_FRAME_RELEASE( parser->postscript );
     }
     parser->root.funcs.done( &parser->root );
   }
Index: xc/extras/freetype2/src/cid/cidparse.h
diff -u xc/extras/freetype2/src/cid/cidparse.h:1.1.1.3 xc/extras/freetype2/src/cid/cidparse.h:1.1.1.4
--- xc/extras/freetype2/src/cid/cidparse.h:1.1.1.3	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cid/cidparse.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID-keyed Type1 parser (specification).                              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -39,7 +39,7 @@
   /*    quickly.                                                           */
   /*                                                                       */
   /* <Fields>                                                              */
-  /*    root           :: the root T1_Parser fields                        */
+  /*    root           :: The root PS_ParserRec fields.                    */
   /*                                                                       */
   /*    stream         :: The current input stream.                        */
   /*                                                                       */
@@ -57,27 +57,27 @@
   /*                                                                       */
   typedef struct  CID_Parser_
   {
-    T1_Parser  root;
-    FT_Stream  stream;
+    PS_ParserRec  root;
+    FT_Stream     stream;
 
-    FT_Byte*   postscript;
-    FT_Int     postscript_len;
+    FT_Byte*      postscript;
+    FT_Int        postscript_len;
 
-    FT_ULong   data_offset;
+    FT_ULong      data_offset;
 
-    CID_Info*  cid;
-    FT_Int     num_dict;
+    CID_FaceInfo  cid;
+    FT_Int        num_dict;
 
   } CID_Parser;
 
 
-  FT_LOCAL FT_Error
-  CID_New_Parser( CID_Parser*       parser,
-                  FT_Stream         stream,
-                  FT_Memory         memory,
-                  PSAux_Interface*  psaux );
+  FT_LOCAL( FT_Error )
+  CID_New_Parser( CID_Parser*    parser,
+                  FT_Stream      stream,
+                  FT_Memory      memory,
+                  PSAux_Service  psaux );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   CID_Done_Parser( CID_Parser*  parser );
 
 
@@ -90,21 +90,21 @@
 #define CID_Skip_Spaces( p )  (p)->root.funcs.skip_spaces( &(p)->root )
 #define CID_Skip_Alpha( p )   (p)->root.funcs.skip_alpha ( &(p)->root )
 
-#define CID_ToInt( p )       (p)->root.funcs.to_int( &(p)->root )
-#define CID_ToFixed( p, t )  (p)->root.funcs.to_fixed( &(p)->root, t )
+#define CID_ToInt( p )        (p)->root.funcs.to_int( &(p)->root )
+#define CID_ToFixed( p, t )   (p)->root.funcs.to_fixed( &(p)->root, t )
 
-#define CID_ToCoordArray( p, m, c )    \
+#define CID_ToCoordArray( p, m, c )                          \
           (p)->root.funcs.to_coord_array( &(p)->root, m, c )
-#define CID_ToFixedArray( p, m, f, t ) \
+#define CID_ToFixedArray( p, m, f, t )                          \
           (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
-#define CID_ToToken( p, t )            \
+#define CID_ToToken( p, t )                         \
           (p)->root.funcs.to_token( &(p)->root, t )
-#define CID_ToTokenArray( p, t, m, c ) \
+#define CID_ToTokenArray( p, t, m, c )                          \
           (p)->root.funcs.to_token_array( &(p)->root, t, m, c )
 
-#define CID_Load_Field( p, f, o )       \
+#define CID_Load_Field( p, f, o )                              \
           (p)->root.funcs.load_field( &(p)->root, f, o, 0, 0 )
-#define CID_Load_Field_Table( p, f, o ) \
+#define CID_Load_Field_Table( p, f, o )                              \
           (p)->root.funcs.load_field_table( &(p)->root, f, o, 0, 0 )
 
 
Index: xc/extras/freetype2/src/cid/cidriver.c
diff -u xc/extras/freetype2/src/cid/cidriver.c:1.1.1.5 xc/extras/freetype2/src/cid/cidriver.c:1.1.1.8
--- xc/extras/freetype2/src/cid/cidriver.c:1.1.1.5	Mon Jan 14 11:52:13 2002
+++ xc/extras/freetype2/src/cid/cidriver.c	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID driver interface (body).                                         */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -25,9 +25,7 @@
 
 #include "ciderrs.h"
 
-#include <string.h>         /* for strcmp() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -38,22 +36,27 @@
 #define FT_COMPONENT  trace_ciddriver
 
 
-
   static const char*
   cid_get_postscript_name( CID_Face  face )
   {
-    return (const char*)face->cid.cid_font_name;
+    const char*  result = face->cid.cid_font_name;
+    
+
+    if ( result && result[0] == '/' )
+      result++;
+      
+    return result;
   }
 
 
   static FT_Module_Interface
   CID_Get_Interface( FT_Driver         driver,
-                     const FT_String*  interface )
+                     const FT_String*  cid_interface )
   {
     FT_UNUSED( driver );
-    FT_UNUSED( interface );
+    FT_UNUSED( cid_interface );
 
-    if ( strcmp( (const char*)interface, "postscript_name" ) == 0 )
+    if ( ft_strcmp( (const char*)cid_interface, "postscript_name" ) == 0 )
       return (FT_Module_Interface)cid_get_postscript_name;
 
     return 0;
@@ -81,7 +84,6 @@
     return CID_Err_Ok;
   }
 
-
 #endif /* 0 */
 
 
@@ -105,13 +107,13 @@
   CID_Get_Char_Index( FT_CharMap  charmap,
                       FT_Long     charcode )
   {
-    T1_Face             face;
-    FT_UInt             result = 0;
-    PSNames_Interface*  psnames;
+    T1_Face          face;
+    FT_UInt          result = 0;
+    PSNames_Service  psnames;
 
 
     face = (T1_Face)charmap->face;
-    psnames = (PSNames_Interface*)face->psnames;
+    psnames = (PSNames_Service)face->psnames;
     if ( psnames )
       switch ( charmap->encoding )
       {
@@ -136,7 +138,7 @@
         /*                                                                 */
       case ft_encoding_adobe_custom:
         {
-          T1_Encoding*  encoding = &face->type1.encoding;
+          T1_Encoding  encoding = &face->type1.encoding;
 
 
           if ( charcode >= encoding->code_first &&
@@ -171,7 +173,7 @@
 
 
             if ( gname && gname[0] == glyph_name[0] &&
-                 strcmp( gname, glyph_name ) == 0   )
+                 ft_strcmp( gname, glyph_name ) == 0   )
             {
               result = n;
               break;
@@ -185,8 +187,106 @@
   }
 
 
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Cid_Get_Next_Char                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return the next encoded char after.              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*                                                                       */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next char code.  0 means `no more char codes'.                     */
+  /*                                                                       */
+  static FT_Long
+  CID_Get_Next_Char( FT_CharMap  charmap,
+                     FT_Long     charcode )
+  {
+    T1_Face          face;
+    PSNames_Service  psnames;
+
+
+    face    = (T1_Face)charmap->face;
+    psnames = (PSNames_Service)face->psnames;
+
+    if ( psnames )
+      switch ( charmap->encoding )
+      {
+        /*******************************************************************/
+        /*                                                                 */
+        /* Unicode encoding support                                        */
+        /*                                                                 */
+      case ft_encoding_unicode:
+        /* use the `PSNames' module to synthetize the Unicode charmap */
+        return psnames->next_unicode (&face->unicode_map,
+                                      (FT_ULong)charcode );
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Custom Type 1 encoding                                          */
+        /*                                                                 */
+      case ft_encoding_adobe_custom:
+        {
+          T1_Encoding  encoding = &face->type1.encoding;
+
+
+          charcode++;
+          if ( charcode < encoding->code_first )
+            charcode = encoding->code_first;
+          while ( charcode <= encoding->code_last )
+          {
+            if ( encoding->char_index[charcode] )
+              return charcode;
+            charcode++;
+          }
+        }
+        break;
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Adobe Standard & Expert encoding support                        */
+        /*                                                                 */
+      default:
+        while ( ++charcode < 256 )
+        {
+          FT_UInt      code;
+          FT_Int       n;
+          const char*  glyph_name;
+
+
+          code = psnames->adobe_std_encoding[charcode];
+          if ( charmap->encoding == ft_encoding_adobe_expert )
+            code = psnames->adobe_expert_encoding[charcode];
+
+          glyph_name = psnames->adobe_std_strings( code );
+          if ( !glyph_name )
+            continue;
+
+          for ( n = 0; n < face->type1.num_glyphs; n++ )
+          {
+            const char*  gname = face->type1.glyph_names[n];
+
+
+            if ( gname && gname[0] == glyph_name[0] &&
+                 ft_strcmp( gname, glyph_name ) == 0   )
+            {
+              return charcode;
+            }
+          }
+        }
+      }
+
+    return 0;
+  }
+
+
   FT_CALLBACK_TABLE_DEF
-  const FT_Driver_Class  t1cid_driver_class =
+  const FT_Driver_ClassRec  t1cid_driver_class =
   {
     /* first of all, the FT_Module_Class fields */
     {
@@ -210,58 +310,28 @@
     sizeof( CID_FaceRec ),
     sizeof( CID_SizeRec ),
     sizeof( CID_GlyphSlotRec ),
-
-    (FTDriver_initFace)     CID_Face_Init,
-    (FTDriver_doneFace)     CID_Face_Done,
-
-    (FTDriver_initSize)     CID_Size_Init,
-    (FTDriver_doneSize)     CID_Size_Done,
-    (FTDriver_initGlyphSlot)CID_GlyphSlot_Init,
-    (FTDriver_doneGlyphSlot)CID_GlyphSlot_Done,
-
-    (FTDriver_setCharSizes) CID_Size_Reset,
-    (FTDriver_setPixelSizes)CID_Size_Reset,
 
-    (FTDriver_loadGlyph)    CID_Load_Glyph,
-    (FTDriver_getCharIndex) CID_Get_Char_Index,
+    (FT_Face_InitFunc)        CID_Face_Init,
+    (FT_Face_DoneFunc)        CID_Face_Done,
 
-    (FTDriver_getKerning)   0,
-    (FTDriver_attachFile)   0,
-
-    (FTDriver_getAdvances)  0
+    (FT_Size_InitFunc)        CID_Size_Init,
+    (FT_Size_DoneFunc)        CID_Size_Done,
+    (FT_Slot_InitFunc)        CID_GlyphSlot_Init,
+    (FT_Slot_DoneFunc)        CID_GlyphSlot_Done,
+
+    (FT_Size_ResetPointsFunc) CID_Size_Reset,
+    (FT_Size_ResetPixelsFunc) CID_Size_Reset,
+
+    (FT_Slot_LoadFunc)        CID_Load_Glyph,
+    (FT_CharMap_CharIndexFunc)CID_Get_Char_Index,
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+
+    (FT_Face_GetAdvancesFunc) 0,
+    
+    (FT_CharMap_CharNextFunc) CID_Get_Next_Char
   };
-
-
-#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    getDriverClass                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    This function is used when compiling the TrueType driver as a      */
-  /*    shared library (`.DLL' or `.so').  It will be used by the          */
-  /*    high-level library of FreeType to retrieve the address of the      */
-  /*    driver's generic interface.                                        */
-  /*                                                                       */
-  /*    It shouldn't be implemented in a static build, as each driver must */
-  /*    have the same function as an exported entry point.                 */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The address of the TrueType's driver generic interface.  The       */
-  /*    format-specific interface can then be retrieved through the method */
-  /*    interface->get_format_interface.                                   */
-  /*                                                                       */
-  FT_EXPORT_DEF( const FT_Driver_Class* )
-  getDriverClass( void )
-  {
-    return &t1cid_driver_class;
-  }
-
-
-#endif /* CONFIG_OPTION_DYNAMIC_DRIVERS */
 
 
 /* END */
Index: xc/extras/freetype2/src/cid/cidriver.h
diff -u xc/extras/freetype2/src/cid/cidriver.h:1.1.1.3 xc/extras/freetype2/src/cid/cidriver.h:1.1.1.4
--- xc/extras/freetype2/src/cid/cidriver.h:1.1.1.3	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cid/cidriver.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    High-level CID driver interface (specification).                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -28,7 +28,7 @@
 
 
   FT_CALLBACK_TABLE
-  const  FT_Driver_Class  t1cid_driver_class;
+  const FT_Driver_ClassRec  t1cid_driver_class;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/cid/cidtoken.h
diff -u xc/extras/freetype2/src/cid/cidtoken.h:1.1.1.2 xc/extras/freetype2/src/cid/cidtoken.h:1.1.1.3
--- xc/extras/freetype2/src/cid/cidtoken.h:1.1.1.2	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/cid/cidtoken.h	Thu Jun 20 04:16:17 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    CID token definitions (specification only).                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -17,9 +17,9 @@
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  CID_Info
+#define FT_STRUCTURE  CID_FaceInfoRec
 #undef  T1CODE
-#define T1CODE        t1_field_cid_info
+#define T1CODE        T1_FIELD_LOCATION_CID_INFO
 
   T1_FIELD_STRING( "CIDFontName", cid_font_name )
   T1_FIELD_NUM   ( "CIDFontVersion", cid_version )
@@ -35,25 +35,25 @@
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  T1_FontInfo
+#define FT_STRUCTURE  PS_FontInfoRec
 #undef  T1CODE
-#define T1CODE        t1_field_font_info
+#define T1CODE        T1_FIELD_LOCATION_FONT_INFO
 
-  T1_FIELD_STRING( "version", version )
-  T1_FIELD_STRING( "Notice", notice )
-  T1_FIELD_STRING( "FullName", full_name )
-  T1_FIELD_STRING( "FamilyName", family_name )
-  T1_FIELD_STRING( "Weight", weight )
-  T1_FIELD_FIXED ( "ItalicAngle", italic_angle )
-  T1_FIELD_BOOL  ( "isFixedPitch", is_fixed_pitch )
-  T1_FIELD_NUM   ( "UnderlinePosition", underline_position )
-  T1_FIELD_NUM   ( "UnderlineThickness", underline_thickness )
+  T1_FIELD_STRING   ( "version", version )
+  T1_FIELD_STRING   ( "Notice", notice )
+  T1_FIELD_STRING   ( "FullName", full_name )
+  T1_FIELD_STRING   ( "FamilyName", family_name )
+  T1_FIELD_STRING   ( "Weight", weight )
+  T1_FIELD_FIXED    ( "ItalicAngle", italic_angle )
+  T1_FIELD_TYPE_BOOL( "isFixedPitch", is_fixed_pitch )
+  T1_FIELD_NUM      ( "UnderlinePosition", underline_position )
+  T1_FIELD_NUM      ( "UnderlineThickness", underline_thickness )
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  CID_FontDict
+#define FT_STRUCTURE  CID_FaceDictRec
 #undef  T1CODE
-#define T1CODE        t1_field_font_dict
+#define T1CODE        T1_FIELD_LOCATION_FONT_DICT
 
   T1_FIELD_NUM  ( "PaintType", paint_type )
   T1_FIELD_NUM  ( "FontType", font_type )
@@ -67,9 +67,9 @@
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  T1_Private
+#define FT_STRUCTURE  PS_PrivateRec
 #undef  T1CODE
-#define T1CODE        t1_field_private
+#define T1CODE        T1_FIELD_LOCATION_PRIVATE
 
   T1_FIELD_NUM       ( "UniqueID", unique_id )
   T1_FIELD_NUM       ( "lenIV", lenIV )
Index: xc/extras/freetype2/src/cid/descrip.mms
diff -u xc/extras/freetype2/src/cid/descrip.mms:1.1.1.1 xc/extras/freetype2/src/cid/descrip.mms:1.1.1.2
--- xc/extras/freetype2/src/cid/descrip.mms:1.1.1.1	Tue May 15 23:45:34 2001
+++ xc/extras/freetype2/src/cid/descrip.mms	Thu Feb 14 19:33:33 2002
@@ -18,6 +18,6 @@
 OBJS=type1cid.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/cid/rules.mk
diff -u xc/extras/freetype2/src/cid/rules.mk:1.1.1.3 xc/extras/freetype2/src/cid/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/cid/rules.mk:1.1.1.3	Sun Sep  9 22:56:04 2001
+++ xc/extras/freetype2/src/cid/rules.mk	Thu Jun 20 04:16:17 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/otlayout/otlayout.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlayout.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlayout.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,168 @@
+#ifndef __OT_LAYOUT_H__
+#define __OT_LAYOUT_H__
+
+
+#include "otlconf.h"
+
+OTL_BEGIN_HEADER
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       BASE DATA TYPES                        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  typedef unsigned char     OTL_Byte;
+  typedef const OTL_Byte*   OTL_Bytes;
+
+  typedef int               OTL_Error;
+
+  typedef void*             OTL_Pointer;
+
+  typedef int               OTL_Int;
+  typedef unsigned int      OTL_UInt;
+
+  typedef short             OTL_Int16;
+  typedef unsigned short    OTL_UInt16;
+
+#if OTL_SIZEOF_INT == 4
+
+  typedef int               OTL_Int32;
+  typedef unsigned int      OTL_UInt32;
+
+#elif OTL_SIZEOF_LONG == 4
+
+  typedef long              OTL_Int32;
+  typedef unsigned long     OTL_UInt32;
+
+#else
+#  error "no 32-bits type found"
+#endif
+
+  typedef OTL_UInt32        OTL_Tag;
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       ERROR CODES                            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  typedef enum
+  {
+    OTL_Err_Ok = 0,
+    OTL_Err_InvalidArgument,
+    OTL_Err_InvalidFormat,
+    OTL_Err_InvalidOffset,
+
+  } OTL_Error;
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                        ENUMERATIONS                          *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#define  OTL_MAKE_TAG(c1,c2,c3,c4)         \
+           ( ( (OTL_UInt32)(c1) << 24 ) |  \
+               (OTL_UInt32)(c2) << 16 ) |  \
+               (OTL_UInt32)(c3) <<  8 ) |  \
+               (OTL_UInt32)(c4)         )
+
+  typedef enum OTL_ScriptTag_
+  {
+    OTL_SCRIPT_NONE = 0,
+
+#define OTL_SCRIPT_TAG(c1,c2,c3,c4,s,n)  OTL_SCRIPT_TAG_ ## n = OTL_MAKE_TAG(c1,c2,c3,c4),
+#include "otltags.h"
+
+    OTL_SCRIPT_MAX
+
+  } OTL_ScriptTag;
+
+
+  typedef enum OTL_LangTag_
+  {
+    OTL_LANG_DEFAULT = 0,
+
+#define OTL_LANG_TAG(c1,c2,c3,c4,s,n)  OTL_LANG_TAG_ ## n = OTL_MAKE_TAG(c1,c2,c3,c4),
+#include "otltags.h"
+
+    OTL_LANG_MAX
+
+  } OTL_LangTag;
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       MEMORY READS                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#define  OTL_PEEK_USHORT(p)  ( ((OTL_UInt)((p)[0]) << 8) |  \
+                               ((OTL_UInt)((p)[1])     ) )
+
+#define  OTL_PEEK_ULONG(p)   ( ((OTL_UInt32)((p)[0]) << 24) |  \
+                               ((OTL_UInt32)((p)[1]) << 16) |  \
+                               ((OTL_UInt32)((p)[2]) <<  8) |  \
+                               ((OTL_UInt32)((p)[3])      ) )
+
+#define  OTL_PEEK_SHORT(p)     ((OTL_Int16)OTL_PEEK_USHORT(p))
+
+#define  OTL_PEEK_LONG(p)      ((OTL_Int32)OTL_PEEK_ULONG(p))
+
+#define  OTL_NEXT_USHORT(p)  ( (p) += 2, OTL_PEEK_USHORT((p)-2) )
+#define  OTL_NEXT_ULONG(p)   ( (p) += 4, OTL_PEEK_ULONG((p)-4) )
+
+#define  OTL_NEXT_SHORT(p)   ((OTL_Int16)OTL_NEXT_USHORT(p))
+#define  OTL_NEXT_LONG(p)    ((OTL_Int32)OTL_NEXT_ULONG(p))
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                        VALIDATION                            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  typedef struct OTL_ValidatorRec_*  OTL_Validator;
+
+  typedef struct OTL_ValidatorRec_
+  {
+    OTL_Bytes    limit;
+    OTL_Bytes    base;
+    OTL_Error    error;
+    OTL_jmp_buf  jump_buffer;
+
+  } OTL_ValidatorRec;
+
+  typedef void  (*OTL_ValidateFunc)( OTL_Bytes  table,
+                                     OTL_Valid  valid );
+
+  OTL_API( void )
+  otl_validator_error( OTL_Validator  validator,
+                       OTL_Error      error );
+
+#define  OTL_INVALID(e)  otl_validator_error( valid, e )
+
+#define  OTL_INVALID_TOO_SHORT  OTL_INVALID( OTL_Err_InvalidOffset );
+#define  OTL_INVALID_DATA       OTL_INVALID( OTL_Err_InvalidFormat );
+
+#define  OTL_CHECK(_count)   OTL_BEGIN_STMNT                       \
+                               if ( p + (_count) > valid->limit )  \
+                                 OTL_INVALID_TOO_SHORT;            \
+                             OTL_END_STMNT
+
+ /* */
+
+OTL_END_HEADER
+
+#endif /* __OPENTYPE_LAYOUT_H__ */
Index: xc/extras/freetype2/src/otlayout/otlbase.c
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlbase.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlbase.c	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,181 @@
+#include "otlbase.h"
+#include "otlcommn.h"
+
+  static void
+  otl_base_coord_validate( OTL_Bytes      table,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 4 );
+
+    format = OTL_NEXT_USHORT( p );
+    p += 2;
+
+    switch ( format )
+    {
+      case 1:
+        break;
+
+      case 2:
+        OTL_CHECK( 4 );
+        break;
+
+      case 3:
+        OTL_CHECK( 2 );
+        otl_device_table_validate( table + OTL_PEEK_USHORT( p ) );
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static void
+  otl_base_tag_list_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK(2);
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*4 );
+  }
+
+
+
+  static void
+  otl_base_values_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 4 );
+
+    p    += 2;  /* skip default index */
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+
+    for ( ; count > 0; count-- )
+      otl_base_coord_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_base_minmax_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   min_coord, max_coord, count;
+
+    OTL_CHECK(6);
+    min_coord = OTL_NEXT_USHORT( p );
+    max_coord = OTL_NEXT_USHORT( p );
+    count     = OTL_NEXT_USHORT( p );
+
+    if ( min_coord )
+      otl_base_coord_validate( table + min_coord, valid );
+
+    if ( max_coord )
+      otl_base_coord_validate( table + max_coord, valid );
+
+    OTL_CHECK( count*8 );
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore tag */
+      min_coord = OTL_NEXT_USHORT( p );
+      max_coord = OTL_NEXT_USHORT( p );
+
+      if ( min_coord )
+        otl_base_coord_validate( table + min_coord, valid );
+
+      if ( max_coord )
+        otl_base_coord_validate( table + max_coord, valid );
+    }
+  }
+
+
+  static void
+  otl_base_script_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   values, default_minmax;
+
+    OTL_CHECK(6);
+
+    values         = OTL_NEXT_USHORT( p );
+    default_minmax = OTL_NEXT_USHORT( p );
+    count          = OTL_NEXT_USHORT( p );
+
+    if ( values )
+      otl_base_values_validate( table + values, valid );
+
+    if ( default_minmax )
+      otl_base_minmax_validate( table + default_minmax, valid );
+
+    OTL_CHECK( count*6 );
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore tag */
+      otl_base_minmax_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+
+
+  static void
+  otl_base_script_list_validate( OTL_Bytes      table,
+                                 OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK(2);
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK(count*6);
+
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore script tag */
+      otl_base_script_validate( table + OTL_NEXT_USHORT( p ) );
+    }
+  }
+
+  static void
+  otl_axis_table_validate( OTL_Bytes      table,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   tags;
+
+    OTL_CHECK(4);
+
+    tags = OTL_NEXT_USHORT( p );
+    if ( tags )
+      otl_base_tag_list_validate   ( table + tags );
+
+    otl_base_script_list_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_base_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes p = table;
+
+    OTL_CHECK(6);
+
+    if ( OTL_NEXT_ULONG( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    otl_axis_table_validate( table + OTL_NEXT_USHORT( p ) );
+    otl_axis_table_validate( table + OTL_NEXT_USHORT( p ) );
+  }
\ No newline at end of file
Index: xc/extras/freetype2/src/otlayout/otlbase.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlbase.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlbase.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,14 @@
+#ifndef __OTL_BASE_H__
+#define __OTL_BASE_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( void )
+  otl_base_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_BASE_H__ */
Index: xc/extras/freetype2/src/otlayout/otlcommn.c
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlcommn.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlcommn.c	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,940 @@
+/***************************************************************************/
+/*                                                                         */
+/*  otlcommn.c                                                             */
+/*                                                                         */
+/*    OpenType layout support, common tables (body).                       */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "otlayout.h"
+
+
+ /*************************************************************************/
+ /*************************************************************************/
+ /*****                                                               *****/
+ /*****                       COVERAGE TABLE                          *****/
+ /*****                                                               *****/
+ /*************************************************************************/
+ /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_coverage_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p;
+    OTL_UInt   format;
+
+
+    if ( table + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  count = OTL_NEXT_USHORT( p );
+
+
+        if ( p + count * 2 >= valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        /* XXX: check glyph indices */
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  n, num_ranges = OTL_NEXT_USHORT( p );
+        OTL_UInt  start, end, start_cover, total = 0, last = 0;
+
+
+        if ( p + num_ranges * 6 >= valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        for ( n = 0; n < num_ranges; n++ )
+        {
+          start       = OTL_NEXT_USHORT( p );
+          end         = OTL_NEXT_USHORT( p );
+          start_cover = OTL_NEXT_USHORT( p );
+
+          if ( start > end || start_cover != total )
+            OTL_INVALID_DATA;
+
+          if ( n > 0 && start <= last )
+            OTL_INVALID_DATA;
+
+          total += end - start + 1;
+          last   = end;
+        }
+      }
+      break;
+
+    default:
+      OTL_INVALID_FORMAT;
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_coverage_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p      = table;
+    OTL_UInt   format = OTL_NEXT_USHORT( p );
+    OTL_UInt   count  = OTL_NEXT_USHORT( p );
+    OTL_UInt   result = 0;
+
+
+    switch ( format )
+    {
+    case 1:
+      return count;
+
+    case 2:
+      {
+        OTL_UInt  start, end;
+
+
+        for ( ; count > 0; count-- )
+        {
+          start = OTL_NEXT_USHORT( p );
+          end   = OTL_NEXT_USHORT( p );
+          p    += 2;                    /* skip start_index */
+
+          result += end - start + 1;
+        }
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( OTL_Int )
+  otl_coverage_get_index( OTL_Bytes  table,
+                          OTL_UInt   glyph_index )
+  {
+    OTL_Bytes  p      = table;
+    OTL_UInt   format = OTL_NEXT_USHORT( p );
+    OTL_UInt   count  = OTL_NEXT_USHORT( p );
+
+
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  min = 0, max = count, mid, gindex;
+
+
+        table += 4;
+        while ( min < max )
+        {
+          mid    = ( min + max ) >> 1;
+          p      = table + 2 * mid;
+          gindex = OTL_PEEK_USHORT( p );
+
+          if ( glyph_index == gindex )
+            return (OTL_Int)mid;
+
+          if ( glyph_index < gindex )
+            max = mid;
+          else
+            min = mid + 1;
+        }
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  min = 0, max = count, mid;
+        OTL_UInt  start, end, delta, start_cover;
+
+
+        table += 4;
+        while ( min < max )
+        {
+          mid    = ( min + max ) >> 1;
+          p      = table + 6 * mid;
+          start  = OTL_NEXT_USHORT( p );
+          end    = OTL_NEXT_USHORT( p );
+
+          if ( glyph_index < start )
+            max = mid;
+          else if ( glyph_index > end )
+            min = mid + 1;
+          else
+            return (OTL_Int)( glyph_index + OTL_NEXT_USHORT( p ) - start );
+        }
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    return -1;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  CLASS DEFINITION TABLE                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_class_definition_validate( OTL_Bytes      table,
+                                 OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  count, start = OTL_NEXT_USHORT( p );
+
+
+        if ( p + 2 > valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        count = OTL_NEXT_USHORT( p );
+
+        if ( p + count * 2 > valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        /* XXX: check glyph indices */
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  n, num_ranges = OTL_NEXT_USHORT( p );
+        OTL_UInt  start, end, value, last = 0;
+
+
+        if ( p + num_ranges * 6 > valid->limit )
+          OTL_INVALID_TOO_SHORT;
+
+        for ( n = 0; n < num_ranges; n++ )
+        {
+          start = OTL_NEXT_USHORT( p );
+          end   = OTL_NEXT_USHORT( p );
+          value = OTL_NEXT_USHORT( p );  /* ignored */
+
+          if ( start > end || ( n > 0 && start <= last ) )
+            OTL_INVALID_DATA;
+
+          last = end;
+        }
+      }
+      break;
+
+    default:
+      OTL_INVALID_FORMAT;
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_class_definition_get_value( OTL_Bytes  table,
+                                  OTL_UInt   glyph_index )
+  {
+    OTL_Bytes  p      = table;
+    OTL_UInt   format = OTL_NEXT_USHORT( p );
+
+
+    switch ( format )
+    {
+    case 1:
+      {
+        OTL_UInt  start = OTL_NEXT_USHORT( p );
+        OTL_UInt  count = OTL_NEXT_USHORT( p );
+        OTL_UInt  idx   = (OTL_UInt)( glyph_index - start );
+
+
+        if ( idx < count )
+        {
+          p += 2 * idx;
+          return OTL_PEEK_USHORT( p );
+        }
+      }
+      break;
+
+    case 2:
+      {
+        OTL_UInt  count = OTL_NEXT_USHORT( p );
+        OTL_UInt  min = 0, max = count, mid, gindex;
+
+
+        table += 4;
+        while ( min < max )
+        {
+          mid   = ( min + max ) >> 1;
+          p     = table + 6 * mid;
+          start = OTL_NEXT_USHORT( p );
+          end   = OTL_NEXT_USHORT( p );
+
+          if ( glyph_index < start )
+            max = mid;
+          else if ( glyph_index > end )
+            min = mid + 1;
+          else
+            return OTL_PEEK_USHORT( p );
+        }
+      }
+      break;
+
+    default:
+      ;
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      DEVICE TABLE                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_device_table_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   start, end, count, format, count;
+
+
+    if ( p + 8 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    start  = OTL_NEXT_USHORT( p );
+    end    = OTL_NEXT_USHORT( p );
+    format = OTL_NEXT_USHORT( p );
+
+    if ( format < 1 || format > 3 || end < start )
+      OTL_INVALID_DATA;
+
+    count = (OTL_UInt)( end - start + 1 );
+
+    if ( p + ( ( 1 << format ) * count ) / 8 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_start( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_end( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 2;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Int )
+  otl_device_table_get_delta( OTL_Bytes  table,
+                              OTL_UInt   size )
+  {
+    OTL_Bytes  p = table;
+    OTL_Int    result = 0;
+    OTL_UInt   start, end, format, idx, value;
+
+
+    start  = OTL_NEXT_USHORT( p );
+    end    = OTL_NEXT_USHORT( p );
+    format = OTL_NEXT_USHORT( p );
+
+    if ( size >= start && size <= end )
+    {
+      /* we could do that with clever bit operations, but a switch is */
+      /* much simpler to understand and maintain                      */
+      /*                                                              */
+      switch ( format )
+      {
+      case 1:
+        idx    = (OTL_UInt)( ( size - start ) * 2 );
+        p     += idx / 16;
+        value  = OTL_PEEK_USHORT( p );
+        shift  = idx & 15;
+        result = (OTL_Short)( value << shift ) >> ( 14 - shift );
+
+        break;
+
+      case 2:
+        idx    = (OTL_UInt)( ( size - start ) * 4 );
+        p     += idx / 16;
+        value  = OTL_PEEK_USHORT( p );
+        shift  = idx & 15;
+        result = (OTL_Short)( value << shift ) >> ( 12 - shift );
+
+        break;
+
+      case 3:
+        idx    = (OTL_UInt)( ( size - start ) * 8 );
+        p     += idx / 16;
+        value  = OTL_PEEK_USHORT( p );
+        shift  = idx & 15;
+        result = (OTL_Short)( value << shift ) >> ( 8 - shift );
+
+        break;
+
+      default:
+        ;
+      }
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      LOOKUP LISTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_lookup_validate( OTL_Bytes      table,
+                       OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   num_tables;
+
+
+    if ( table + 6 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    p += 4;
+    num_tables = OTL_NEXT_USHORT( p );
+
+    if ( p + num_tables * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_tables > 0; num_tables-- )
+    {
+      offset = OTL_NEXT_USHORT( p );
+
+      if ( table + offset >= valid->limit )
+        OTL_INVALID_OFFSET;
+    }
+
+    /* XXX: check sub-tables? */
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 4;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_get_table( OTL_Bytes  table,
+                        OTL_UInt   idx )
+  {
+    OTL_Bytes  p, result = NULL;
+    OTL_UInt   count;
+
+
+    p     = table + 4;
+    count = OTL_NEXT_USHORT( p );
+    if ( idx < count )
+    {
+      p     += idx * 2;
+      result = table + OTL_PEEK_USHORT( p );
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      LOOKUP LISTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_lookup_list_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table, q;
+    OTL_UInt   num_lookups, offset;
+
+
+    if ( p + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    num_lookups = OTL_NEXT_USHORT( p );
+
+    if ( p + num_lookups * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_lookups > 0; num_lookups-- )
+    {
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_lookup_validate( table + offset, valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_list_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_lookup( OTL_Bytes  table,
+                              OTL_UInt   idx )
+  {
+    OTL_Bytes  p, result = 0;
+    OTL_UInt   count;
+
+
+    p     = table;
+    count = OTL_NEXT_USHORT( p );
+    if ( idx < count )
+    {
+      p     += idx * 2;
+      result = table + OTL_PEEK_USHORT( p );
+    }
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_table( OTL_Bytes  table,
+                             OTL_UInt   lookup_index,
+                             OTL_UInt   table_index )
+  {
+    OTL_Bytes  result = NULL;
+
+
+    result = otl_lookup_list_get_lookup( table, lookup_index );
+    if ( result )
+      result = otl_lookup_get_table( result, table_index );
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_lookup_list_foreach( OTL_Bytes        table,
+                           OTL_ForeachFunc  func,
+                           OTL_Pointer      func_data )
+  {
+    OTL_Bytes  p     = table;
+    OTL_UInt   count = OTL_NEXT_USHORT( p );
+
+
+    for ( ; count > 0; count-- )
+      func( table + OTL_NEXT_USHORT( p ), func_data );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURES                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_feature_validate( OTL_Bytes      table,
+                        OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   feat_params, num_lookups;
+
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    feat_params = OTL_NEXT_USHORT( p );  /* ignored */
+    num_lookups = OTL_NEXT_USHORT( p );
+
+    if ( p + num_lookups * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    /* XXX: check lookup indices */
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 4;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_lookups( OTL_Bytes  table,
+                           OTL_UInt   start,
+                           OTL_UInt   count,
+                           OTL_UInt  *lookups )
+  {
+    OTL_Bytes  p;
+    OTL_UInt   num_features, result = 0;
+
+
+    p            = table + 4;
+    num_features = OTL_NEXT_USHORT( p );
+
+    p += start * 2;
+
+    for ( ; count > 0 && start < num_features; count--, start++ )
+    {
+      lookups[0] = OTL_NEXT_USHORT(p);
+      lookups++;
+      result++;
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURE LIST                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCALDEF( void )
+  otl_feature_list_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   num_features, offset;
+
+
+    if ( table + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    num_features = OTL_NEXT_USHORT( p );
+
+    if ( p + num_features * 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_features > 0; num_features-- )
+    {
+      p     += 4;                       /* skip tag */
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_feature_table_validate( table + offset, valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_list_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_feature_list_get_feature( OTL_Bytes  table,
+                                OTL_UInt   idx )
+  {
+    OTL_Bytes  p, result = NULL;
+    OTL_UInt   count;
+
+
+    p     = table;
+    count = OTL_NEXT_USHORT( p );
+
+    if ( idx < count )
+    {
+      p     += idx * 2;
+      result = table + OTL_PEEK_USHORT( p );
+    }
+
+    return result;
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_feature_list_foreach( OTL_Bytes        table,
+                            OTL_ForeachFunc  func,
+                            OTL_Pointer      func_data )
+  {
+    OTL_Bytes  p;
+    OTL_UInt   count;
+
+
+    p = table;
+    count = OTL_NEXT_USHORT( p );
+
+    for ( ; count > 0; count-- )
+      func( table + OTL_NEXT_USHORT( p ), func_data );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       LANGUAGE SYSTEM                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_lang_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   lookup_order;
+    OTL_UInt   req_feature;
+    OTL_UInt   num_features;
+
+
+    if ( table + 6 >= valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    lookup_order = OTL_NEXT_USHORT( p );
+    req_feature  = OTL_NEXT_USHORT( p );
+    num_features = OTL_NEXT_USHORT( p );
+
+    /* XXX: check req_feature if not 0xFFFFU */
+
+    if ( p + 2 * num_features >= valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    /* XXX: check features indices! */
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lang_get_count( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 4;
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lang_get_req_feature( OTL_Bytes  table )
+  {
+    OTL_Bytes  p = table + 2;
+
+
+    return OTL_PEEK_USHORT( p );
+  }
+
+
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lang_get_features( OTL_Bytes  table,
+                         OTL_UInt   start,
+                         OTL_UInt   count,
+                         OTL_UInt  *features )
+  {
+    OTL_Bytes  p            = table + 4;
+    OTL_UInt   num_features = OTL_NEXT_USHORT( p );
+    OTL_UInt   result       = 0;
+
+
+    p += start * 2;
+
+    for ( ; count > 0 && start < num_features; start++, count-- )
+    {
+      features[0] = OTL_NEXT_USHORT( p );
+      features++;
+      result++;
+    }
+
+    return result;
+  }
+
+
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           SCRIPTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_script_validate( OTL_Bytes      table,
+                       OTL_Validator  valid )
+  {
+    OTL_UInt   default_lang;
+    OTL_Bytes  p = table;
+
+
+    if ( table + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    default_lang = OTL_NEXT_USHORT( p );
+    num_langs    = OTL_NEXT_USHORT( p );
+
+    if ( default_lang != 0 )
+    {
+      if ( table + default_lang >= valid->limit )
+        OTL_INVALID_OFFSET;
+    }
+
+    if ( p + num_langs * 6 >= valid->limit )
+      OTL_INVALID_OFFSET;
+
+    for ( ; num_langs > 0; num_langs-- )
+    {
+      OTL_UInt  offset;
+
+
+      p     += 4;  /* skip tag */
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_lang_validate( table + offset, valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_script_list_validate( OTL_Bytes      list,
+                            OTL_Validator  valid )
+  {
+    OTL_UInt   num_scripts;
+    OTL_Bytes  p = list;
+
+
+    if ( list + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    num_scripts = OTL_NEXT_USHORT( p );
+
+    if ( p + num_scripts * 6 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; num_scripts > 0; num_scripts-- )
+    {
+      OTL_UInt  offset;
+
+
+      p     += 4;                       /* skip tag */
+      offset = OTL_NEXT_USHORT( p );
+
+      otl_script_table_validate( list + offset, valid );
+    }
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                         LOOKUP LISTS                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  otl_lookup_table_validate( OTL_Bytes          table,
+                             OTL_UInt           type_count,
+                             OTL_ValidateFunc*  type_funcs,
+                             OTL_Validator      valid )
+  {
+    OTL_Bytes         p = table;
+    OTL_UInt          lookup_type, lookup_flag, count;
+    OTL_ValidateFunc  validate;
+
+    OTL_CHECK( 6 );
+    lookup_type = OTL_NEXT_USHORT( p );
+    lookup_flag = OTL_NEXT_USHORT( p );
+    count       = OTL_NEXT_USHORT( p );
+
+    if ( lookup_type == 0 || lookup_type >= type_count )
+      OTL_INVALID_DATA;
+
+    validate = type_funcs[ lookup_type - 1 ];
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_lookup_list_validate( OTL_Bytes          table,
+                            OTL_UInt           type_count,
+                            OTL_ValidateFunc*  type_funcs,
+                            OTL_Validator      valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_lookup_table_validate( table + OTL_NEXT_USHORT( p ),
+                                 type_count, type_funcs, valid );
+  }
+
+/* END */
Index: xc/extras/freetype2/src/otlayout/otlcommn.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlcommn.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlcommn.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,277 @@
+/***************************************************************************/
+/*                                                                         */
+/*  otlcommn.h                                                             */
+/*                                                                         */
+/*    OpenType layout support, common tables (specification).              */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __OTLCOMMN_H__
+#define __OTLCOMMN_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       COVERAGE TABLE                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate coverage table */
+  OTL_LOCALDEF( void )
+  otl_coverage_validate( OTL_Bytes      base,
+                         OTL_Validator  valid );
+
+  /* return number of covered glyphs */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_coverage_get_count( OTL_Bytes  base );
+
+  /* Return the coverage index corresponding to a glyph glyph index. */
+  /* Return -1 if the glyph isn't covered.                           */
+  OTL_LOCALDEF( OTL_Int )
+  otl_coverage_get_index( OTL_Bytes  base,
+                          OTL_UInt   glyph_index );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  CLASS DEFINITION TABLE                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate class definition table */
+  OTL_LOCALDEF( void )
+  otl_class_definition_validate( OTL_Bytes      table,
+                                 OTL_Validator  valid );
+
+  /* return class value for a given glyph index */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_class_definition_get_value( OTL_Bytes  table,
+                                  OTL_UInt   glyph_index );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      DEVICE TABLE                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate a device table */
+  OTL_LOCALDEF( void )
+  otl_device_table_validate( OTL_Bytes      table,
+                             OTL_Validator  valid );
+
+  /* return a device table's first size */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_start( OTL_Bytes  table );
+
+  /* return a device table's last size */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_device_table_get_end( OTL_Bytes  table );
+
+  /* return pixel adjustment for a given size */
+  OTL_LOCALDEF( OTL_Int )
+  otl_device_table_get_delta( OTL_Bytes  table,
+                              OTL_UInt   size );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           LOOKUPS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate lookup table */
+  OTL_LOCALDEF( void )
+  otl_lookup_validate( OTL_Bytes      table,
+                       OTL_Validator  valid );
+
+  /* return number of sub-tables in a lookup */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_get_count( OTL_Bytes  table );
+
+
+  /* return lookup sub-table */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_get_table( OTL_Bytes  table,
+                        OTL_UInt   idx );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      LOOKUP LISTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate lookup list */
+  OTL_LOCALDEF( void )
+  otl_lookup_list_validate( OTL_Bytes      table,
+                            OTL_Validator  valid );
+
+  /* return number of lookups in list */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_lookup_list_get_count( OTL_Bytes  table );
+
+  /* return a given lookup from a list */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_lookup( OTL_Bytes  table,
+                              OTL_UInt   idx );
+
+  /* return lookup sub-table from a list */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_lookup_list_get_table( OTL_Bytes  table,
+                             OTL_UInt   lookup_index,
+                             OTL_UInt   table_index );
+
+  /* iterate over lookup list */
+  OTL_LOCALDEF( void )
+  otl_lookup_list_foreach( OTL_Bytes        table,
+                           OTL_ForeachFunc  func,
+                           OTL_Pointer      func_data );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURES                               *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate feature table */
+  OTL_LOCALDEF( void )
+  otl_feature_validate( OTL_Bytes      table,
+                        OTL_Validator  valid );
+
+  /* return feature's lookup count */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_count( OTL_Bytes  table );
+
+  /* get several lookups indices from a feature. returns the number of */
+  /* lookups grabbed                                                   */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_get_lookups( OTL_Bytes  table,
+                           OTL_UInt   start,
+                           OTL_UInt   count,
+                           OTL_UInt  *lookups );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        FEATURE LIST                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* validate a feature list */
+  OTL_LOCALDEF( void )
+  otl_feature_list_validate( OTL_Bytes      table,
+                             OTL_Validator  valid );
+
+  /* return number of features in list */
+  OTL_LOCALDEF( OTL_UInt )
+  otl_feature_list_get_count( OTL_Bytes  table );
+
+
+  /* return a given feature from a list */
+  OTL_LOCALDEF( OTL_Bytes )
+  otl_feature_list_get_feature( OTL_Bytes  table,
+                                OTL_UInt   idx );
+
+  /* iterate over all features in a list */
+  OTL_LOCALDEF( void )
+  otl_feature_list_foreach( OTL_Bytes        table,
+                            OTL_ForeachFunc  func,
+                            OTL_Pointer      func_data );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       LANGUAGE SYSTEM                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCAL( void )
+  otl_lang_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+
+  OTL_LOCAL( OTL_UInt )
+  otl_lang_get_req_feature( OTL_Bytes  table );
+
+
+  OTL_LOCAL( OTL_UInt )
+  otl_lang_get_count( OTL_Bytes  table );
+
+
+  OTL_LOCAL( OTL_UInt )
+  otl_lang_get_features( OTL_Bytes  table,
+                         OTL_UInt   start,
+                         OTL_UInt   count,
+                         OTL_UInt  *features );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           SCRIPTS                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCAL( void )
+  otl_script_list_validate( OTL_Bytes          list,
+                            OTL_Validator      valid );
+
+  OTL_LOCAL( OTL_Bytes )
+  otl_script_list_get_script( OTL_Bytes  table );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                         LOOKUP LISTS                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  OTL_LOCAL( void )
+  otl_lookup_list_validate( OTL_Bytes          list,
+                            OTL_UInt           type_count,
+                            OTL_ValidateFunc*  type_funcs,
+                            OTL_Validator      valid );
+
+ /* */
+
+OTL_END_HEADER
+
+#endif /* __OTLCOMMN_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/otlayout/otlconf.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlconf.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlconf.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,73 @@
+#ifndef __OT_LAYOUT_CONFIG_H__
+#define __OT_LAYOUT_CONFIG_H__
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                    CONFIGURATION MACROS                      *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifdef __cplusplus
+#  define OTL_BEGIN_HEADER  extern "C" {
+#else
+#  define OTL_BEGIN_HEADER  /* nothing */
+#endif
+
+#ifdef __cplusplus
+#  define OTL_END_HEADER   }
+#else
+#  define OTL_END_HEADER   /* nothing */
+#endif
+
+#ifndef OTL_API
+#  ifdef __cplusplus
+#    define  OTL_API( x )   extern "C"
+#  else
+#    define  OTL_API( x )   extern x
+#  endif
+#endif
+
+#ifndef OTL_APIDEF
+#  define  OTL_APIDEF( x )  x
+#endif
+
+#ifndef OTL_LOCAL
+#  define OTL_LOCAL( x )   extern x
+#endif
+
+#ifndef OTL_LOCALDEF
+#  define OTL_LOCALDEF( x )  x
+#endif
+
+#define  OTL_BEGIN_STMNT  do {
+#define  OTL_END_STMNT    } while (0)
+#define  OTL_DUMMY_STMNT  do { } while (0)
+
+#define  OTL_UNUSED( x )       (x)=(x)
+#define  OTL_UNUSED_CONST(x)  (void)(x)
+
+
+#include <limits.h>
+#if UINT_MAX == 0xFFFFU
+#  define OTL_SIZEOF_INT  2
+#elif UINT_MAX == 0xFFFFFFFFU
+#  define OTL_SIZEOF_INT  4
+#elif UINT_MAX > 0xFFFFFFFFU && UINT_MAX == 0xFFFFFFFFFFFFFFFFU
+#  define OTL_SIZEOF_INT  8
+#else
+#  error  "unsupported number of bytes in 'int' type!"
+#endif
+
+#if ULONG_MAX == 0xFFFFFFFFU
+#  define  OTL_SIZEOF_LONG  4
+#elif ULONG_MAX > 0xFFFFFFFFU && ULONG_MAX == 0xFFFFFFFFFFFFFFFFU
+#  define  OTL_SIZEOF_LONG  8
+#else
+#  error  "unsupported number of bytes in 'long' type!"
+#endif
+
+/* */
+
+#endif /* __OT_LAYOUT_CONFIG_H__ */
Index: xc/extras/freetype2/src/otlayout/otlgdef.c
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlgdef.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlgdef.c	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,175 @@
+#include "otlgdef.h"
+#include "otlcommn.h"
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                      ATTACHMENTS LIST                        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_attach_point_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    if ( p + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    count = OTL_NEXT_USHORT( p );
+    if ( table + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+  }
+
+
+  static void
+  otl_attach_list_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_Bytes  coverage;
+    OTL_UInt   count;
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    coverage = table + OTL_NEXT_USHORT( p );
+    count    = OTL_NEXT_USHORT( p );
+
+    otl_coverage_validate( coverage, valid );
+    if ( count != otl_coverage_get_count( coverage ) )
+      OTL_INVALID_DATA;
+
+    if ( p + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; count > 0; count-- )
+      otl_attach_point_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                      LIGATURE CARETS                         *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_caret_value_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+      case 2:
+        break;
+
+      case 3:
+        {
+          OTL_Bytes  device;
+
+          p += 2;
+          if ( p + 2 > valid->limit )
+            OTL_INVALID_TOO_SHORT;
+
+          otl_device_table_validate( table + OTL_PEEK_USHORT( p ) );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static void
+  otl_ligature_glyph_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    if ( p + 2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    count = OTL_NEXT_USHORT( p );
+
+    if ( p + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; count > 0; count-- )
+      otl_caret_value_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+  static void
+  otl_ligature_caret_list_validate( OTL_Bytes      table,
+                                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_Bytes  coverage;
+    OTL_UInt   count;
+
+    if ( p + 4 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    coverage = table + OTL_NEXT_USHORT( p );
+    count    = OTL_NEXT_USHORT( p );
+
+    otl_coverage_validate( coverage, valid );
+    if ( count != otl_coverage_get_count( coverage ) )
+      OTL_INVALID_DATA;
+
+    if ( p + count*2 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    for ( ; count > 0; count-- )
+      otl_ligature_glyph_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         GDEF TABLE                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  OTL_APIDEF( void )
+  otl_gdef_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+
+    if ( p + 12 > valid->limit )
+      OTL_INVALID_TOO_SHORT;
+
+    /* check format */
+    if ( OTL_NEXT_ULONG( p ) != 0x00010000UL )
+      OTL_INVALID_FORMAT;
+
+    /* validate class definition table */
+    otl_class_definition_validate( table + OTL_NEXT_USHORT( p ) );
+
+    /* validate attachment point list */
+    otl_attach_list_validate( table + OTL_NEXT_USHORT( p ) );
+
+    /* validate ligature caret list */
+    otl_ligature_caret_list_validate( table + OTL_NEXT_USHORT( p ) );
+
+    /* validate mark attach class */
+    otl_class_definition_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
Index: xc/extras/freetype2/src/otlayout/otlgdef.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlgdef.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlgdef.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,14 @@
+#ifndef __OTL_GDEF_H__
+#define __OTL_GDEF_H__
+
+#include "otltable.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_API( void )
+  otl_gdef_validate( OTL_Bytes  table,
+                     OTL_Valid  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_GDEF_H__ */
Index: xc/extras/freetype2/src/otlayout/otlgpos.c
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlgpos.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlgpos.c	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,980 @@
+#include "otlgpos.h"
+#include "otlcommn.h"
+
+ /* forward declaration */
+  static OTL_ValidateFunc  otl_gpos_validate_funcs[];
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         VALUE RECORDS                        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static OTL_UInt
+  otl_value_length( OTL_UInt  format )
+  {
+    FT_UInt  count;
+
+    count = (( format & 0xAA ) >> 1) + ( format & 0x55 );
+    count = (( count  & 0xCC ) >> 2) + ( count  & 0x33 );
+    count = (( count  & 0xF0 ) >> 4) + ( count  & 0x0F );
+
+    return count;
+  }
+
+
+  static void
+  otl_value_validate( OTL_Bytes      table,
+                      OTL_Bytes      pos_table,
+                      OTL_UInt       format,
+                      OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, device;
+
+    if ( format >= 0x100U )
+      OTL_INVALID_DATA;
+
+    for ( count = 4; count > 0; count-- )
+    {
+      if ( format & 1 )
+      {
+        OTL_CHECK( 2 );
+        p += 2;
+      }
+
+      format >>= 1;
+    }
+
+    for ( count = 4; count > 0; count-- )
+    {
+      if ( format & 1 )
+      {
+        OTL_CHECK( 2 );
+        device = OTL_NEXT_USHORT( p );
+        if ( device )
+          otl_device_table_validate( pos_table + device, valid );
+      }
+      format >>= 1;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                          ANCHORS                             *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_anchor_validate( OTL_Bytes      table,
+                       OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 6 );
+    format = OTL_NEXT_USHORT( p );
+    p += 4;
+
+    switch ( format )
+    {
+      case 1:
+        break;
+
+      case 2:
+        OTL_CHECK( 2 );  /* anchor point */
+        break;
+
+      case 3:
+        {
+          OTL_UInt  x_device, y_device;
+
+          OTL_CHECK( 4 );
+          x_device = OTL_NEXT_USHORT( p );
+          y_device = OTL_NEXT_USHORT( p );
+
+          if ( x_device )
+            otl_device_table_validate( table + x_device, valid );
+
+          if ( y_device )
+            otl_device_table_validate( table + y_device, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                           MARK ARRAY                         *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_mark_array_validate( OTL_Bytes      table,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count * 4 );
+    for ( ; count > 0; count-- )
+    {
+      p += 2;  /* ignore class index */
+      otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 1                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gpos_lookup1_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          FT_UInt  coverage, value_format;
+
+          OTL_CHECK( 4 );
+          coverage     = OTL_NEXT_USHORT( p );
+          value_format = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+          otl_value_validate( p, table, value_format, valid );
+        }
+        break;
+
+      case 2:
+        {
+          FT_UInt  coverage, value_format, count, len;
+
+          OTL_CHECK( 6 );
+          coverage     = OTL_NEXT_USHORT( p );
+          value_format = OTL_NEXT_USHORT( p );
+          count        = OTL_NEXT_USHORT( p );
+          len          = otl_value_length( value_format );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count * len );
+          for ( ; count > 0; count-- )
+          {
+            otl_value_validate( p, table, value_format, valid );
+            p += len;
+          }
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 2                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static otl_gpos_pairset_validate( OTL_Bytes      table,
+                                    OTL_Bytes      pos_table,
+                                    OTL_UInt       format1,
+                                    OTL_UInt       format2,
+                                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   len1, len2, count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+    len1  = otl_value_length( format1 );
+    len2  = otl_value_length( format2 );
+
+    OTL_CHECK( count * (len1+len2+2) );
+    for ( ; count > 0; count-- )
+    {
+      p += 2;  /* ignore glyph id */
+      otl_value_validate( p, pos_table, format1, valid );
+      p += len1;
+
+      otl_value_validate( p, pos_table, format2, valid );
+      p += len2;
+    }
+  }
+
+  static void
+  otl_gpos_lookup2_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, value1, value2, count;
+
+          OTL_CHECK( 8 );
+          coverage = OTL_NEXT_USHORT( p );
+          value1   = OTL_NEXT_USHORT( p );
+          value2   = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+          {
+            otl_gpos_pairset_validate( table + OTL_NEXT_USHORT( p ),
+                                       table, value1, value2, valid );
+          }
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, value1, value2, class1, class2, count1, count2;
+          OTL_UInt  len1, len2;
+
+          OTL_CHECK( 14 );
+          coverage = OTL_NEXT_USHORT( p );
+          value1   = OTL_NEXT_USHORT( p );
+          value2   = OTL_NEXT_USHORT( p );
+          class1   = OTL_NEXT_USHORT( p );
+          class2   = OTL_NEXT_USHORT( p );
+          count1   = OTL_NEXT_USHORT( p );
+          count2   = OTL_NEXT_USHORT( p );
+
+          len1 = otl_value_length( value1 );
+          len2 = otl_value_length( value2 );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count1*count2*(len1+len2) );
+          for ( ; count1 > 0; count1-- )
+          {
+            for ( ; count2 > 0; count2-- )
+            {
+              otl_value_validate( p, table, value1, valid );
+              p += len1;
+
+              otl_value_validate( p, table, value2, valid );
+              p += len2;
+            }
+          }
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 3                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gpos_lookup3_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count, anchor1, anchor2;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*4 );
+          for ( ; count > 0; count-- )
+          {
+            anchor1 = OTL_NEXT_USHORT( p );
+            anchor2 = OTL_NEXT_USHORT( p );
+
+            if ( anchor1 )
+              otl_anchor_validate( table + anchor1, valid );
+
+            if ( anchor2 )
+              otl_anchor_validate( table + anchor2, valid );
+          }
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 4                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_base_array_validate( OTL_Bytes      table,
+                           OTL_UInt       class_count,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*class_count*2 );
+    for ( ; count > 0; count-- )
+      for ( count2 = class_count; count2 > 0; count2-- )
+        otl_anchor_validate( table + OTL_NEXT_USHORT( p ) );
+  }
+
+
+  static void
+  otl_gpos_lookup4_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  mark_coverage, base_coverage, class_count;
+          OTL_UInt  mark_array, base_array;
+
+          OTL_CHECK( 10 );
+          mark_coverage = OTL_NEXT_USHORT( p );
+          base_coverage = OTL_NEXT_USHORT( p );
+          class_count   = OTL_NEXT_USHORT( p );
+          mark_array    = OTL_NEXT_USHORT( p );
+          base_array    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + mark_coverage, valid );
+          otl_coverage_validate( table + base_coverage, valid );
+
+          otl_mark_array_validate( table + mark_array, valid );
+          otl_base_array_validate( table, class_count, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 5                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_liga_attach_validate( OTL_Bytes      table,
+                            OTL_UInt       class_count,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*class_count*2 );
+    for ( ; count > 0; count-- )
+      for ( count2 = class_count; class_count > 0; class_count-- )
+        otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_liga_array_validate( OTL_Bytes      table,
+                           OTL_UInt       class_count,
+                           OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_liga_attach_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup5_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  mark_coverage, lig_coverage, class_count;
+          OTL_UInt  mar_array, lig_array;
+
+          OTL_CHECK( 10 );
+          mark_coverage = OTL_NEXT_USHORT( p );
+          liga_coverage = OTL_NEXT_USHORT( p );
+          class_count   = OTL_NEXT_USHORT( p );
+          mark_array    = OTL_NEXT_USHORT( p );
+          liga_array    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + mark_coverage, valid );
+          otl_coverage_validate( table + liga_coverage, valid );
+
+          otl_mark_array_validate( table + mark_array, valid );
+          otl_liga_array_validate( table + liga_array, class_count, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 6                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  static void
+  otl_mark2_array_validate( OTL_Bytes      table,
+                            OTL_UInt       class_count,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, count2;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*class_count*2 );
+    for ( ; count > 0; count-- )
+      for ( count2 = class_count; class_count > 0; class_count-- )
+        otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup6_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage1, coverage2, class_count, array1, array2;
+
+          OTL_CHECK( 10 );
+          coverage1   = OTL_NEXT_USHORT( p );
+          coverage2   = OTL_NEXT_USHORT( p );
+          class_count = OTL_NEXT_USHORT( p );
+          array1      = OTL_NEXT_USHORT( p );
+          array2      = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage1, valid );
+          otl_coverage_validate( table + coverage2, valid );
+
+          otl_mark_array_validate( table + array1, valid );
+          otl_mark2_array_validate( table + array2, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 7                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_pos_rule_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   glyph_count, pos_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    pos_count   = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
+
+    /* XXX: check glyph indices and pos lookups */
+  }
+
+
+  static void
+  otl_pos_rule_set_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
+  }
+
+
+
+  static void
+  otl_pos_class_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   glyph_count, pos_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    pos_count   = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
+
+    /* XXX: check glyph indices and pos lookups */
+  }
+
+
+  static void
+  otl_pos_class_set_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup7_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, class_def, count;
+
+          OTL_CHECK( 6 );
+          coverage  = OTL_NEXT_USHORT( p );
+          class_def = OTL_NEXT_USHORT( p );
+          count     = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate        ( table + coverage, valid );
+          otl_class_definition_validate( table + class_def, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  glyph_count, pos_count;
+
+          OTL_CHECK( 4 );
+          glyph_count = OTL_NEXT_USHORT( p );
+          pos_count   = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( glyph_count*2 + pos_count*4 );
+          for ( ; glyph_count > 0; glyph_count )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          /* XXX: check pos lookups */
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 8                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_chain_pos_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, pos_count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( back_count*2 + 2 );
+    p += back_count*2;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( input_count*2 );
+    p += (input_count-1)*2;
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( ahead_count*2 + 2 );
+    p += ahead_count*2;
+
+    pos_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( pos_count*4 );
+  }
+
+
+  static void
+  otl_chain_pos_rule_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_pos_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+
+  static void
+  otl_chain_pos_class_rule_validate( OTL_Bytes      table,
+                                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, pos_count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( back_count*2 + 2 );
+    p += back_count*2;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( input_count*2 );
+    p += (input_count-1)*2;
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( ahead_count*2 + 2 );
+    p += ahead_count*2;
+
+    pos_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( pos_count*4 );
+  }
+
+
+  static void
+  otl_chain_pos_class_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_pos_class_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gpos_lookup8_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_chain_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ),
+                                             valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, back_class, input_class, ahead_class, count;
+
+          OTL_CHECK( 10 );
+          coverage    = OTL_NEXT_USHORT( p );
+          back_class  = OTL_NEXT_USHORT( p );
+          input_class = OTL_NEXT_USHORT( p );
+          ahead_class = OTL_NEXT_USHORT( p );
+          count       = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          otl_class_definition_validate( table + back_class,  valid );
+          otl_class_definition_validate( table + input_class, valid );
+          otl_class_definition_validate( table + ahead_class, valid );
+
+          OTL_CHECK( count*2 );
+          for ( ; count > 0; count-- )
+            otl_chain_pos_class_set_validate( table + OTL_NEXT_USHORT( p ),
+                                              valid );
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  back_count, input_count, ahead_count, pos_count, count;
+
+          OTL_CHECK( 2 );
+          back_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*back_count+2 );
+          for ( count = back_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          input_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*input_count+2 );
+          for ( count = input_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          ahead_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*ahead_count+2 );
+          for ( count = ahead_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          pos_count = OTL_NEXT_USHORT( p );
+          OTL_CHECK( pos_count*4 );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GPOS LOOKUP TYPE 9                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gpos_lookup9_validate( OTL_Bytes  table,
+                             OTL_Valid  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch (format)
+    {
+      case 1:
+        {
+          OTL_UInt          lookup_type, lookup_offset;
+          OTL_ValidateFunc  validate;
+
+          OTL_CHECK( 6 );
+          lookup_type   = OTL_NEXT_USHORT( p );
+          lookup_offset = OTL_NEXT_ULONG( p );
+
+          if ( lookup_type == 0 || lookup_type >= 9 )
+            OTL_INVALID_DATA;
+
+          validate = otl_gpos_validate_funcs[ lookup_type-1 ];
+          validate( table + lookup_offset, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+  static OTL_ValidateFunc  otl_gpos_validate_funcs[ 9 ] =
+  {
+    otl_gpos_lookup1_validate,
+    otl_gpos_lookup2_validate,
+    otl_gpos_lookup3_validate,
+    otl_gpos_lookup4_validate,
+    otl_gpos_lookup5_validate,
+    otl_gpos_lookup6_validate,
+    otl_gpos_lookup7_validate,
+    otl_gpos_lookup8_validate,
+    otl_gpos_lookup9_validate,
+  };
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         GPOS TABLE                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_gpos_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   scripts, features, lookups;
+
+    OTL_CHECK( 10 );
+
+    if ( OTL_NEXT_USHORT( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    scripts  = OTL_NEXT_USHORT( p );
+    features = OTL_NEXT_USHORT( p );
+    lookups  = OTL_NEXT_USHORT( p );
+
+    otl_script_list_validate ( table + scripts, valid );
+    otl_feature_list_validate( table + features, valid );
+
+    otl_lookup_list_validate( table + lookups, 9, otl_gpos_validate_funcs,
+                              valid );
+  }
+  
\ No newline at end of file
Index: xc/extras/freetype2/src/otlayout/otlgpos.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlgpos.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlgpos.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,14 @@
+#ifndef __OTL_GPOS_H__
+#define __OTL_GPOS_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( void )
+  otl_gpos_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_GPOS_H__ */
Index: xc/extras/freetype2/src/otlayout/otlgsub.c
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlgsub.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlgsub.c	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,654 @@
+#include "otlgsub.h"
+#include "otlcommn.h"
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 1                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gsub_lookup1_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 2                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_seq_validate( OTL_Bytes      table,
+                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    /* check glyph indices */
+  }
+
+
+  static void
+  otl_gsub_lookup2_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, seq_count;
+
+          OTL_CHECK( 4 );
+          coverage  = OTL_NEXT_USHORT( p );
+          seq_count = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( seq_count*2 );
+          for ( ; seq_count > 0; seq_count-- )
+            otl_seq_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 3                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_alternate_set_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    /* XXX: check glyph indices */
+  }
+
+
+  static void
+  otl_gsub_lookup3_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_alternate_set_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 4                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_ligature_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_UInt  glyph_id, count;
+
+    OTL_CHECK( 4 );
+    glyph_id = OTL_NEXT_USHORT( p );
+    count    = OTL_NEXT_USHORT( p );
+
+    if ( count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( 2*(count-1) );
+    /* XXX: check glyph indices */
+  }
+
+
+  static void
+  otl_ligature_set_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_ligature_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gsub_lookup4_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_ligature_set_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 5                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  static void
+  otl_sub_rule_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   glyph_count, subst_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    subst_count = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + substcount*4 );
+
+    /* XXX: check glyph indices and subst lookups */
+  }
+
+
+  static void
+  otl_sub_rule_set_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_sub_class_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_UInt  glyph_count, subst_count;
+
+    OTL_CHECK( 4 );
+    glyph_count = OTL_NEXT_USHORT( p );
+    subst_count = OTL_NEXT_USHORT( p );
+
+    if ( glyph_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( (glyph_count-1)*2 + substcount*4 );
+
+    /* XXX: check glyph indices and subst lookups */
+  }
+
+
+  static void
+  otl_sub_class_rule_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_sub_class_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gsub_lookup5_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_sub_rule_set_validate( table + coverage, valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, class_def, count;
+
+          OTL_CHECK( 6 );
+          coverage  = OTL_NEXT_USHORT( p );
+          class_def = OTL_NEXT_USHORT( p );
+          count     = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate        ( table + coverage, valid );
+          otl_class_definition_validate( table + class_def, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_sub_class_rule_set_validate( table + coveragen valid );
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  glyph_count, subst_count, count;
+
+          OTL_CHECK( 4 );
+          glyph_count = OTL_NEXT_USHORT( p );
+          subst_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*glyph_count + 4*subst_count );
+          for ( count = glyph_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 6                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  static void
+  otl_chain_sub_rule_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, subst_count, count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*back_count+2 );
+    p += 2*back_count;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( 2*input_count );
+    p += 2*(input_count-1);
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 2*ahead_count + 2 );
+    p += 2*ahead_count;
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 4*count );
+
+    /* XXX: check glyph indices and subst lookups */
+  }
+
+
+  static void
+  otl_chain_sub_rule_set_validate( OTL_Bytes      table,
+                                   OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_chain_sub_class_rule_validate( OTL_Bytes      table,
+                                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   back_count, input_count, ahead_count, subst_count, count;
+
+    OTL_CHECK( 2 );
+    back_count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*back_count+2 );
+    p += 2*back_count;
+
+    input_count = OTL_NEXT_USHORT( p );
+    if ( input_count == 0 )
+      OTL_INVALID_DATA;
+
+    OTL_CHECK( 2*input_count );
+    p += 2*(input_count-1);
+
+    ahead_count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 2*ahead_count + 2 );
+    p += 2*ahead_count;
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( 4*count );
+
+    /* XXX: check class indices and subst lookups */
+  }
+
+
+
+  static void
+  otl_chain_sub_class_set_validate( OTL_Bytes      table,
+                                    OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( 2*count );
+    for ( ; count > 0; count-- )
+      otl_chain_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_gsub_lookup6_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt  coverage, count;
+
+          OTL_CHECK( 4 );
+          coverage = OTL_NEXT_USHORT( p );
+          count    = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_chain_sub_rule_set_validate( table + coverage, valid );
+        }
+        break;
+
+      case 2:
+        {
+          OTL_UInt  coverage, back_class, input_class, ahead_class, count;
+
+          OTL_CHECK( 10 );
+          coverage    = OTL_NEXT_USHORT( p );
+          back_class  = OTL_NEXT_USHORT( p );
+          input_class = OTL_NEXT_USHORT( p );
+          ahead_class = OTL_NEXT_USHORT( p );
+          count       = OTL_NEXT_USHORT( p );
+
+          otl_coverage_validate( table + coverage, valid );
+
+          otl_class_definition_validate( table + back_class,  valid );
+          otl_class_definition_validate( table + input_class, valid );
+          otl_class_definition_validate( table + ahead_class, valid );
+
+          OTL_CHECK( 2*count );
+          for ( ; count > 0; count-- )
+            otl_chain_sub_class_set( table + OTL_NEXT_USHORT( p ), valid );
+        }
+        break;
+
+      case 3:
+        {
+          OTL_UInt  back_count, input_count, ahead_count, subst_count, count;
+
+          OTL_CHECK( 2 );
+          back_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*back_count+2 );
+          for ( count = back_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          input_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*input_count+2 );
+          for ( count = input_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          ahead_count = OTL_NEXT_USHORT( p );
+
+          OTL_CHECK( 2*ahead_count+2 );
+          for ( count = ahead_count; count > 0; count-- )
+            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
+
+          subst_count = OTL_NEXT_USHORT( p );
+          OTL_CHECK( subst_count*4 );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                 GSUB LOOKUP TYPE 6                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+  static void
+  otl_gsub_lookup7_validate( OTL_Bytes      table,
+                             OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   format, coverage;
+
+    OTL_CHECK( 2 );
+    format = OTL_NEXT_USHORT( p );
+    switch ( format )
+    {
+      case 1:
+        {
+          OTL_UInt          lookup_type, lookup_offset;
+          OTL_ValidateFunc  validate;
+
+          OTL_CHECK( 6 );
+          lookup_type   = OTL_NEXT_USHORT( p );
+          lookup_offset = OTL_NEXT_ULONG( p );
+
+          if ( lookup_type == 0 || lookup_type >= 7 )
+            OTL_INVALID_DATA;
+
+          validate = otl_gsub_validate_funcs[ lookup_type-1 ];
+          validate( table + lookup_offset, valid );
+        }
+        break;
+
+      default:
+        OTL_INVALID_DATA;
+    }
+  }
+
+
+  static const OTL_ValidateFunc  otl_gsub_validate_funcs[ 7 ] =
+  {
+    otl_gsub_lookup1_validate,
+    otl_gsub_lookup2_validate,
+    otl_gsub_lookup3_validate,
+    otl_gsub_lookup4_validate,
+    otl_gsub_lookup5_validate,
+    otl_gsub_lookup6_validate
+  };
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                         GSUB TABLE                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+  OTL_LOCALDEF( void )
+  otl_gsub_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   scripts, features, lookups;
+
+    OTL_CHECK( 10 );
+
+    if ( OTL_NEXT_USHORT( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    scripts  = OTL_NEXT_USHORT( p );
+    features = OTL_NEXT_USHORT( p );
+    lookups  = OTL_NEXT_USHORT( p );
+
+    otl_script_list_validate ( table + scripts, valid );
+    otl_feature_list_validate( table + features, valid );
+
+    otl_lookup_list_validate( table + lookups, 7, otl_gsub_validate_funcs,
+                              valid );
+  }
Index: xc/extras/freetype2/src/otlayout/otlgsub.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otlgsub.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otlgsub.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,14 @@
+#ifndef __OTL_GSUB_H__
+#define __OTL_GSUB_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( void )
+  otl_gsub_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_GSUB_H__ */
Index: xc/extras/freetype2/src/otlayout/otljstf.c
diff -u /dev/null xc/extras/freetype2/src/otlayout/otljstf.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otljstf.c	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,189 @@
+#include "otljstf.h"
+#include "otlcommn.h"
+#include "otlgpos.h"
+
+  static void
+  otl_jstf_extender_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+  }
+
+
+  static void
+  otl_jstf_gsub_mods_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*2 );
+
+    /* XXX: check GSUB lookup indices */
+  }
+
+
+  static void
+  otl_jstf_gpos_mods_validate( OTL_Bytes      table,
+                               OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*2 );
+
+    /* XXX: check GPOS lookup indices */
+  }
+
+
+  static void
+  otl_jstf_max_validate( OTL_Bytes      table,
+                         OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_gpos_subtable_check( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_jstf_priority_validate( OTL_Bytes      table,
+                              OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   offset;
+
+    OTL_CHECK( 20 );
+
+    /* shrinkage GSUB enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    /* shrinkage GPOS enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    /* shrinkage JSTF max */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_max_validate( table + val, valid );
+
+    /* extension GSUB enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gsub_mods_validate( table + val, valid );
+
+    /* extension GPOS enable/disable */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_gpos_mods_validate( table + val, valid );
+
+    /* extension JSTF max */
+    val = OTL_NEXT_USHORT( p );
+    if ( val )
+      otl_jstf_max_validate( table + val, valid );
+  }
+
+  static void
+  otl_jstf_lang_validate( OTL_Bytes      table,
+                          OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 2 );
+
+    count = OTL_NEXT_USHORT( p );
+
+    OTL_CHECK( count*2 );
+    for ( ; count > 0; count-- )
+      otl_jstf_priority_validate( table + OTL_NEXT_USHORT( p ), valid );
+  }
+
+
+  static void
+  otl_jstf_script_validate( OTL_Bytes      table,
+                            OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count, extender, default_lang;
+
+    OTL_CHECK( 6 );
+    extender     = OTL_NEXT_USHORT( p );
+    default_lang = OTL_NEXT_USHORT( p );
+    count        = OTL_NEXT_USHORT( p );
+
+    if ( extender )
+      otl_jstf_extender_validate( table + extender, valid );
+
+    if ( default_lang )
+      otl_jstf_lang_validate( table + default_lang, valid );
+
+    OTL_CHECK( 6*count );
+
+    for ( ; count > 0; count-- )
+    {
+      p += 4;  /* ignore tag */
+      otl_jstf_lang_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+
+
+  OTL_LOCALDEF( void )
+  otl_jstf_validate( OTL_Bytes      table,
+                     OTL_Validator  valid )
+  {
+    OTL_Bytes  p = table;
+    OTL_UInt   count;
+
+    OTL_CHECK( 4 );
+
+    if ( OTL_NEXT_ULONG( p ) != 0x10000UL )
+      OTL_INVALID_DATA;
+
+    count = OTL_NEXT_USHORT( p );
+    OTL_CHECK( count*6 );
+
+    for ( ; count > 0; count++ )
+    {
+      p += 4;  /* ignore tag */
+      otl_jstf_script_validate( table + OTL_NEXT_USHORT( p ), valid );
+    }
+  }
+  
\ No newline at end of file
Index: xc/extras/freetype2/src/otlayout/otljstf.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otljstf.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otljstf.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,14 @@
+#ifndef __OTL_JSTF_H__
+#define __OTL_JSTF_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  OTL_LOCAL( void )
+  otl_jstf_validate( OTL_Bytes      table,
+                     OTL_Validator  valid );
+
+OTL_END_HEADER
+
+#endif /* __OTL_JSTF_H__ */
\ No newline at end of file
Index: xc/extras/freetype2/src/otlayout/otltable.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otltable.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otltable.h	Thu Jun 20 04:16:17 2002
@@ -0,0 +1,60 @@
+#ifndef __OTL_TABLE_H__
+#define __OTL_TABLE_H__
+
+#include "otlayout.h"
+
+OTL_BEGIN_HEADER
+
+  typedef struct OTL_TableRec_*    OTL_Table;
+
+  typedef enum
+  {
+    OTL_TABLE_TYPE_GDEF = 1,
+    OTL_TABLE_TYPE_GSUB,
+    OTL_TABLE_TYPE_GPOS,
+    OTL_TABLE_TYPE_BASE,
+    OTL_TABLE_TYPE_JSTF
+
+  } OTL_TableType;
+
+
+ /* this may become a private structure later */
+  typedef struct OTL_TableRec_
+  {
+    OTL_TableType  type;
+    OTL_Bytes      base;
+    OTL_Bytes      limit;
+
+    OTL_Tag        script_tag;
+    OTL_Tag        lang_tag;
+
+    OTL_UInt       lookup_count;
+    OTL_Byte*      lookup_flags;
+
+    OTL_UInt       feature_count;
+    OTL_Tag        feature_tags;
+    OTL_Byte*      feature_flags;
+
+  } OTL_TableRec;
+
+
+  OTL_API( OTL_Error )
+  otl_table_validate( OTL_Bytes      table,
+                      OTL_Size       size,
+                      OTL_TableType  type,
+                      OTL_Size      *abyte_size );
+
+  OTL_API( void )
+  otl_table_init( OTL_Table      table,
+                  OTL_TableType  type,
+                  OTL_Bytes      base,
+                  OTL_Size       size );
+
+  OTL_API( void )
+  otl_table_set_script( OTL_Table      table,
+                        OTL_ScriptTag  script,
+                        OTL_LangTag    language );
+
+OTL_END_HEADER
+
+#endif /* __OTL_TABLE_H__ */
Index: xc/extras/freetype2/src/otlayout/otltags.h
diff -u /dev/null xc/extras/freetype2/src/otlayout/otltags.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/otlayout/otltags.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,86 @@
+/* this file may be included several times by other parts of */
+/* the OpenType Layout library.. don't add #ifdef .. #endif  */
+/* delimiters to it...                                       */
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       SCRIPT TAGS                            *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifndef OTL_SCRIPT_TAG
+#define OTL_SCRIPT_TAG(c1,c2,c3,c4,s,n)  /* void */
+#endif
+
+OTL_SCRIPT_TAG( 'a','r','a','b', "Arabic", ARABIC )
+OTL_SCRIPT_TAG( 'a','r','m','n', "Armenian", ARMENIAN )
+OTL_SCRIPT_TAG( 'b','e','n','g', "Bengali", BENGALI )
+OTL_SCRIPT_TAG( 'b','o','p','o', "Bopomofo", BOPOMOFO )
+OTL_SCRIPT_TAG( 'b','r','a','i', "Braille", BRAILLE )
+OTL_SCRIPT_TAG( 'c','a','n','s', "Canadian Syllabic", CANADIAN )
+OTL_SCRIPT_TAG( 'c','h','e','r', "Cherokee", CHEROKEE )
+OTL_SCRIPT_TAG( 'h','a','n','i', "CJK Ideographic", CJK )
+OTL_SCRIPT_TAG( 'c','y','r','l', "Cyrillic", CYRILLIC )
+OTL_SCRIPT_TAG( 'd','e','v','a', "Devanagari", DEVANAGARI )
+OTL_SCRIPT_TAG( 'e','t','h','i', "Ethiopic", ETHIOPIC )
+OTL_SCRIPT_TAG( 'g','e','o','r', "Georgian", GEORGIAN )
+OTL_SCRIPT_TAG( 'g','r','e','k', "Greek", GREEK )
+OTL_SCRIPT_TAG( 'g','u','j','r', "Gujarati", GUJARATI )
+OTL_SCRIPT_TAG( 'g','u','r','u', "Gurmukhi", GURMUKHI )
+OTL_SCRIPT_TAG( 'j','a','m','o', "Hangul Jamo", JAMO )
+OTL_SCRIPT_TAG( 'h','a','n','g', "Hangul", HANGUL )
+OTL_SCRIPT_TAG( 'h','e','b','r', "Hebrew", HEBREW )
+OTL_SCRIPT_TAG( 'h','i','r','a', "Hiragana", HIRAGANA )
+OTL_SCRIPT_TAG( 'k','n','d','a', "Kannada", KANNADA )
+OTL_SCRIPT_TAG( 'k','a','n','a', "Katakana", KATAKANA )
+OTL_SCRIPT_TAG( 'k','h','m','r', "Khmer", KHMER )
+OTL_SCRIPT_TAG( 'l','a','o',' ', "Lao", LAO )
+OTL_SCRIPT_TAG( 'l','a','t','n', "Latin", LATIN )
+OTL_SCRIPT_TAG( 'm','l','y','m', "Malayalam", MALAYALAM )
+OTL_SCRIPT_TAG( 'm','o','n','g', "Mongolian", MONGOLIAN )
+OTL_SCRIPT_TAG( 'm','y','m','r', "Myanmar", MYANMAR )
+OTL_SCRIPT_TAG( 'o','g','a','m', "Ogham", OGHAM )
+OTL_SCRIPT_TAG( 'o','r','y','a', "Oriya", ORIYA )
+OTL_SCRIPT_TAG( 'r','u','n','r', "Runic", RUNIC )
+OTL_SCRIPT_TAG( 's','i','n','h', "Sinhala", SINHALA )
+OTL_SCRIPT_TAG( 's','y','r','c', "Syriac", SYRIAC )
+OTL_SCRIPT_TAG( 't','a','m','l', "Tamil", TAMIL )
+OTL_SCRIPT_TAG( 't','e','l','u', "Telugu", TELUGU )
+OTL_SCRIPT_TAG( 't','h','a','a', "Thaana", THAANA )
+OTL_SCRIPT_TAG( 't','h','a','i', "Thai", THAI )
+OTL_SCRIPT_TAG( 't','i','b','t', "Tibetan", TIBETAN )
+OTL_SCRIPT_TAG( 'y','i',' ',' ', "Yi", YI )
+
+#undef OTL_SCRIPT_TAG
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       LANGUAGE TAGS                          *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifndef OTL_LANG_TAG
+#define OTL_LANG_TAG(c1,c2,c3,c4,s,n)  /* void */
+#endif
+
+#undef OTL_LANG_TAG
+
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****                       FEATURE TAGS                           *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+#ifndef OTL_FEATURE_TAG
+#define OTL_FEATURE_TAG(c1,c2,c3,c4,s,n)  /* void */
+#endif
+
+#undef OTL_FEATURE_TAG
+
Index: xc/extras/freetype2/src/pcf/descrip.mms
diff -u xc/extras/freetype2/src/pcf/descrip.mms:1.1.1.1 xc/extras/freetype2/src/pcf/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/pcf/descrip.mms:1.1.1.1	Tue May 15 23:45:34 2001
+++ xc/extras/freetype2/src/pcf/descrip.mms	Thu Jun 20 04:16:18 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright (C) 2001 by
+# Copyright (C) 2001, 2002 by
 # Francesco Zappa Nardelli
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -30,6 +30,6 @@
 OBJS=pcf.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/pcf/pcf.h
diff -u xc/extras/freetype2/src/pcf/pcf.h:1.1.1.3 xc/extras/freetype2/src/pcf/pcf.h:1.1.1.5
--- xc/extras/freetype2/src/pcf/pcf.h:1.1.1.3	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/pcf/pcf.h	Thu Jun 20 04:16:18 2002
@@ -2,7 +2,7 @@
 
   FreeType font driver for pcf fonts
 
-  Copyright (C) 2000-2001 by
+  Copyright (C) 2000-2001, 2002 by
   Francesco Zappa Nardelli
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -54,7 +54,7 @@
   } PCF_TocRec, *PCF_Toc;
 
 
-  typedef struct  PCF_ParseProperty_
+  typedef struct  PCF_ParsePropertyRec_
   {
     FT_Long  name;
     FT_Byte  isString;
@@ -63,7 +63,7 @@
   } PCF_ParsePropertyRec, *PCF_ParseProperty;
 
 
-  typedef struct  PCF_Property_
+  typedef struct  PCF_PropertyRec_
   {
     FT_String*  name;
     FT_Byte     isString;
@@ -79,7 +79,7 @@
   } PCF_PropertyRec, *PCF_Property;
 
 
-  typedef struct  PCF_Compressed_Metric_
+  typedef struct  PCF_Compressed_MetricRec_
   {
     FT_Byte  leftSideBearing;
     FT_Byte  rightSideBearing;
@@ -90,7 +90,7 @@
   } PCF_Compressed_MetricRec, *PCF_Compressed_Metric;
 
 
-  typedef struct  PCF_Metric_
+  typedef struct  PCF_MetricRec_
   {
     FT_Short  leftSideBearing;
     FT_Short  rightSideBearing;
@@ -123,7 +123,7 @@
   } PCF_AccelRec, *PCF_Accel;
 
 
-  typedef struct  PCD_Encoding_
+  typedef struct  PCD_EncodingRec_
   {
     FT_Long   enc;
     FT_Short  glyph;
@@ -159,11 +159,6 @@
   } PCF_FaceRec, *PCF_Face;
 
 
-  /* XXX hack */
-  FT_LOCAL FT_Error
-  PCF_Done_Face( PCF_Face  face );
-
-
   /* macros for pcf font format */
 
 #define LSBFirst  0
@@ -226,7 +221,7 @@
 
 #define GLYPHPADOPTIONS  4 /* I'm not sure about this */
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   pcf_load_font( FT_Stream,
                  PCF_Face );
 
Index: xc/extras/freetype2/src/pcf/pcfdriver.c
diff -u xc/extras/freetype2/src/pcf/pcfdriver.c:1.2 xc/extras/freetype2/src/pcf/pcfdriver.c:1.4
--- xc/extras/freetype2/src/pcf/pcfdriver.c:1.2	Sun Dec 16 13:08:34 2001
+++ xc/extras/freetype2/src/pcf/pcfdriver.c	Thu Jun 20 04:25:27 2002
@@ -2,7 +2,7 @@
 
     FreeType font driver for pcf files
 
-    Copyright (C) 2000-2001 by
+    Copyright (C) 2000-2001, 2002 by
     Francesco Zappa Nardelli
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -37,7 +37,205 @@
 
 #include "pcferror.h"
 
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pcfread
+
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+  typedef struct  PCF_CMapRec_
+  {
+    FT_CMapRec    cmap;
+    FT_UInt       num_encodings;
+    PCF_Encoding  encodings;
+
+  } PCF_CMapRec, *PCF_CMap;
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  pcf_cmap_init( PCF_CMap  cmap )
+  {
+    PCF_Face  face = (PCF_Face)FT_CMAP_FACE( cmap );
+
+
+    cmap->num_encodings = (FT_UInt)face->nencodings;
+    cmap->encodings     = face->encodings;
+
+    return FT_Err_Ok;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  pcf_cmap_done( PCF_CMap  cmap )
+  {
+    cmap->encodings     = NULL;
+    cmap->num_encodings = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pcf_cmap_char_index( PCF_CMap   cmap,
+                       FT_UInt32  charcode )
+  {
+    PCF_Encoding  encodings = cmap->encodings;
+    FT_UInt       min, max, mid;
+    FT_UInt       result = 0;
+
+
+    min = 0;
+    max = cmap->num_encodings;
+
+    while ( min < max )
+    {
+      FT_UInt32  code;
+
+
+      mid  = ( min + max ) >> 1;
+      code = encodings[mid].enc;
+
+      if ( charcode == code )
+      {
+        result = encodings[mid].glyph;
+        break;
+      }
+
+      if ( charcode < code )
+        max = mid;
+      else
+        min = mid + 1;
+    }
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pcf_cmap_char_next( PCF_CMap    cmap,
+                      FT_UInt32  *acharcode )
+  {
+    PCF_Encoding  encodings = cmap->encodings;
+    FT_UInt       min, max, mid;
+    FT_UInt32     charcode = *acharcode + 1;
+    FT_UInt       result   = 0;
+
+
+    min = 0;
+    max = cmap->num_encodings;
+
+    while ( min < max )
+    {
+      FT_UInt32  code;
+
+
+      mid  = ( min + max ) >> 1;
+      code = encodings[mid].enc;
+
+      if ( charcode == code )
+      {
+        result = encodings[mid].glyph;
+        goto Exit;
+      }
+
+      if ( charcode < code )
+        max = mid;
+      else
+        min = mid + 1;
+    }
 
+    charcode = 0;
+    if ( min < cmap->num_encodings )
+    {
+      charcode = encodings[min].enc;
+      result   = encodings[min].glyph;
+    }
+
+  Exit:
+    *acharcode = charcode;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec  pcf_cmap_class =
+  {
+    sizeof( PCF_CMapRec ),
+    (FT_CMap_InitFunc)     pcf_cmap_init,
+    (FT_CMap_DoneFunc)     pcf_cmap_done,
+    (FT_CMap_CharIndexFunc)pcf_cmap_char_index,
+    (FT_CMap_CharNextFunc) pcf_cmap_char_next
+  };
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+  static FT_UInt
+  PCF_Char_Get_Index( FT_CharMap  charmap,
+                      FT_Long     char_code )
+  {
+    PCF_Face      face     = (PCF_Face)charmap->face;
+    PCF_Encoding  en_table = face->encodings;
+    int           low, high, mid;
+
+
+    FT_TRACE4(( "get_char_index %ld\n", char_code ));
+
+    low = 0;
+    high = face->nencodings - 1;
+    while ( low <= high )
+    {
+      mid = ( low + high ) / 2;
+      if ( char_code < en_table[mid].enc )
+        high = mid - 1;
+      else if ( char_code > en_table[mid].enc )
+        low = mid + 1;
+      else
+        return en_table[mid].glyph;
+    }
+
+    return 0;
+  }
+
+
+  static FT_Long
+  PCF_Char_Get_Next( FT_CharMap  charmap,
+                     FT_Long     char_code )
+  {
+    PCF_Face      face     = (PCF_Face)charmap->face;
+    PCF_Encoding  en_table = face->encodings;
+    int           low, high, mid;
+
+
+    FT_TRACE4(( "get_next_char %ld\n", char_code ));
+
+    char_code++;
+    low  = 0;
+    high = face->nencodings - 1;
+
+    while ( low <= high )
+    {
+      mid = ( low + high ) / 2;
+      if ( char_code < en_table[mid].enc )
+        high = mid - 1;
+      else if ( char_code > en_table[mid].enc )
+        low = mid + 1;
+      else
+        return char_code;
+    }
+
+    if ( high < 0 )
+      high = 0;
+
+    while ( high < face->nencodings )
+    {
+      if ( en_table[high].enc >= char_code )
+        return en_table[high].enc;
+      high++;
+    }
+
+    return 0;
+  }
+
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -48,33 +246,47 @@
 #define FT_COMPONENT  trace_pcfdriver
 
 
-  FT_LOCAL_DEF FT_Error
-  PCF_Done_Face( PCF_Face  face )
+  FT_CALLBACK_DEF( FT_Error )
+  PCF_Face_Done( PCF_Face  face )
   {
-    FT_Memory    memory = FT_FACE_MEMORY( face );
-    PCF_Property tmp    = face->properties;
-    int i;
+    FT_Memory  memory = FT_FACE_MEMORY( face );
 
 
-    FREE( face->encodings );
-    FREE( face->metrics );
+    FT_FREE( face->encodings );
+    FT_FREE( face->metrics );
 
-    for ( i = 0; i < face->nprops; i++ )
+    /* free properties */
     {
-      FREE( tmp->name );
-      if ( tmp->isString )
-        FREE( tmp->value );
+      PCF_Property  prop = face->properties;
+      FT_Int        i;
+
+
+      for ( i = 0; i < face->nprops; i++ )
+      {
+        prop = &face->properties[i];
+
+        FT_FREE( prop->name );
+        if ( prop->isString )
+          FT_FREE( prop->value );
+      }
+
+      FT_FREE( face->properties );
     }
-    FREE( face->properties );
 
+    FT_FREE( face->toc.tables );
+    FT_FREE( face->root.family_name );
+    FT_FREE( face->root.available_sizes );
+    FT_FREE( face->charset_encoding );
+    FT_FREE( face->charset_registry );
+
     FT_TRACE4(( "DONE_FACE!!!\n" ));
 
     return PCF_Err_Ok;
   }
 
 
-  static FT_Error
-  PCF_Init_Face( FT_Stream      stream,
+  FT_CALLBACK_DEF( FT_Error )
+  PCF_Face_Init( FT_Stream      stream,
                  PCF_Face       face,
                  FT_Int         face_index,
                  FT_Int         num_params,
@@ -91,13 +303,77 @@
     if ( error )
       goto Fail;
 
-    return PCF_Err_Ok;
+    /* set-up charmap */
+    {
+      FT_String  *charset_registry, *charset_encoding;
+      FT_Bool     unicode_charmap  = 0;
+
+
+      charset_registry = face->charset_registry;
+      charset_encoding = face->charset_encoding;
+
+      if ( ( charset_registry != NULL ) &&
+           ( charset_encoding != NULL ) )
+      {
+        if ( !ft_strcmp( face->charset_registry, "ISO10646" )     ||
+             ( !ft_strcmp( face->charset_registry, "ISO8859" ) &&
+               !ft_strcmp( face->charset_encoding, "1" )       )  )
+          unicode_charmap = 1;
+      }
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+      {
+        FT_CharMapRec  charmap;
+
+
+        charmap.face        = FT_FACE( face );
+        charmap.encoding    = ft_encoding_none;
+        charmap.platform_id = 0;
+        charmap.encoding_id = 0;
+
+        if ( unicode_charmap )
+        {
+          charmap.encoding    = ft_encoding_unicode;
+          charmap.platform_id = 3;
+          charmap.encoding_id = 1;
+        }
+
+        error = FT_CMap_New( &pcf_cmap_class, NULL, &charmap, NULL );
+      }
 
+#else  /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+      /* XXX: charmaps.  For now, report unicode for Unicode and Latin 1 */
+      face->root.charmaps     = &face->charmap_handle;
+      face->root.num_charmaps = 1;
+
+      face->charmap.encoding    = ft_encoding_none;
+      face->charmap.platform_id = 0;
+      face->charmap.encoding_id = 0;
+
+      if ( unicode_charmap )
+      {
+        face->charmap.encoding    = ft_encoding_unicode;
+        face->charmap.platform_id = 3;
+        face->charmap.encoding_id = 1;
+      }
+
+      face->charmap.face   = &face->root;
+      face->charmap_handle = &face->charmap;
+      face->root.charmap   = face->charmap_handle;
+
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+    }
+
+  Exit:
+    return error;
+
   Fail:
     FT_TRACE2(( "[not a valid PCF file]\n" ));
-    PCF_Done_Face( face );
-
-    return PCF_Err_Unknown_File_Format; /* error */
+    error = PCF_Err_Unknown_File_Format;  /* error */
+    goto Exit;
   }
 
 
@@ -112,13 +388,13 @@
 
     if ( size->metrics.y_ppem == face->root.available_sizes->height )
     {
-      size->metrics.ascender  = face->accel.fontAscent << 6;
-      size->metrics.descender = face->accel.fontDescent * (-64);
+      size->metrics.ascender    = face->accel.fontAscent << 6;
+      size->metrics.descender   = face->accel.fontDescent * (-64);
 #if 0
-      size->metrics.height    = face->accel.maxbounds.ascent << 6;
+      size->metrics.height      = face->accel.maxbounds.ascent << 6;
 #endif
-      size->metrics.height    = size->metrics.ascender -
-                                size->metrics.descender;
+      size->metrics.height      = size->metrics.ascender -
+                                  size->metrics.descender;
 
       size->metrics.max_advance = face->accel.maxbounds.characterWidth << 6;
 
@@ -133,20 +409,19 @@
 
 
   static FT_Error
-  PCF_Load_Glyph( FT_GlyphSlot  slot,
+  PCF_Glyph_Load( FT_GlyphSlot  slot,
                   FT_Size       size,
                   FT_UInt       glyph_index,
                   FT_Int        load_flags )
   {
     PCF_Face    face   = (PCF_Face)FT_SIZE_FACE( size );
+    FT_Stream   stream = face->root.stream;
     FT_Error    error  = PCF_Err_Ok;
-    FT_Memory   memory = FT_FACE(face)->memory;
+    FT_Memory   memory = FT_FACE( face )->memory;
     FT_Bitmap*  bitmap = &slot->bitmap;
     PCF_Metric  metric;
     int         bytes;
 
-    FT_Stream   stream = face->root.stream;
-
     FT_UNUSED( load_flags );
 
 
@@ -195,11 +470,11 @@
     /* XXX: to do: are there cases that need repadding the bitmap? */
     bytes = bitmap->pitch * bitmap->rows;
 
-    if ( ALLOC( bitmap->buffer, bytes ) )
+    if ( FT_ALLOC( bitmap->buffer, bytes ) )
       goto Exit;
 
-    if ( FILE_Seek( metric->bits )        ||
-         FILE_Read( bitmap->buffer, bytes ) )
+    if ( FT_STREAM_SEEK( metric->bits )          ||
+         FT_STREAM_READ( bitmap->buffer, bytes ) )
       goto Exit;
 
     if ( PCF_BIT_ORDER( face->bitmapsFormat ) != MSBFirst )
@@ -234,7 +509,7 @@
 
     slot->linearHoriAdvance = (FT_Fixed)bitmap->width << 16;
     slot->format            = ft_glyph_format_bitmap;
-    slot->flags             = ft_glyph_own_bitmap;
+    slot->flags             = FT_GLYPH_OWN_BITMAP;
 
     FT_TRACE4(( " --- ok\n" ));
 
@@ -243,36 +518,8 @@
   }
 
 
-  static FT_UInt
-  PCF_Get_Char_Index( FT_CharMap  charmap,
-                      FT_Long     char_code )
-  {
-    PCF_Face      face     = (PCF_Face)charmap->face;
-    PCF_Encoding  en_table = face->encodings;
-    int           low, high, mid;
-
-
-    FT_TRACE4(( "get_char_index %ld\n", char_code ));
-
-    low = 0;
-    high = face->nencodings - 1;
-    while ( low <= high )
-    {
-      mid = ( low + high ) / 2;
-      if ( char_code < en_table[mid].enc )
-        high = mid - 1;
-      else if ( char_code > en_table[mid].enc )
-        low = mid + 1;
-      else
-        return en_table[mid].glyph;
-    }
-
-    return 0;
-  }
-
-
   FT_CALLBACK_TABLE_DEF
-  const FT_Driver_Class  pcf_driver_class =
+  const FT_Driver_ClassRec  pcf_driver_class =
   {
     {
       ft_module_font_driver,
@@ -292,56 +539,35 @@
     sizeof( PCF_FaceRec ),
     sizeof( FT_SizeRec ),
     sizeof( FT_GlyphSlotRec ),
-
-    (FTDriver_initFace)     PCF_Init_Face,
-    (FTDriver_doneFace)     PCF_Done_Face,
-    (FTDriver_initSize)     0,
-    (FTDriver_doneSize)     0,
-    (FTDriver_initGlyphSlot)0,
-    (FTDriver_doneGlyphSlot)0,
-
-    (FTDriver_setCharSizes) PCF_Set_Pixel_Size,
-    (FTDriver_setPixelSizes)PCF_Set_Pixel_Size,
-
-    (FTDriver_loadGlyph)    PCF_Load_Glyph,
-    (FTDriver_getCharIndex) PCF_Get_Char_Index,
-
-    (FTDriver_getKerning)   0,
-    (FTDriver_attachFile)   0,
-    (FTDriver_getAdvances)  0
-  };
-
-
-#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
-
 
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    getDriverClass                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    This function is used when compiling the TrueType driver as a      */
-  /*    shared library (`.DLL' or `.so').  It will be used by the          */
-  /*    high-level library of FreeType to retrieve the address of the      */
-  /*    driver's generic interface.                                        */
-  /*                                                                       */
-  /*    It shouldn't be implemented in a static build, as each driver must */
-  /*    have the same function as an exported entry point.                 */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The address of the TrueType's driver generic interface.  The       */
-  /*    format-specific interface can then be retrieved through the method */
-  /*    interface->get_format_interface.                                   */
-  /*                                                                       */
-  FT_EXPORT_DEF( const FT_Driver_Class* )
-  getDriverClass( void )
-  {
-    return &pcf_driver_class;
-  }
-
+    (FT_Face_InitFunc)        PCF_Face_Init,
+    (FT_Face_DoneFunc)        PCF_Face_Done,
+    (FT_Size_InitFunc)        0,
+    (FT_Size_DoneFunc)        0,
+    (FT_Slot_InitFunc)        0,
+    (FT_Slot_DoneFunc)        0,
+
+    (FT_Size_ResetPointsFunc) PCF_Set_Pixel_Size,
+    (FT_Size_ResetPixelsFunc) PCF_Set_Pixel_Size,
+
+    (FT_Slot_LoadFunc)        PCF_Glyph_Load,
+
+#ifndef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharIndexFunc)PCF_Char_Get_Index,
+#else
+    (FT_CharMap_CharIndexFunc)0,
+#endif
 
-#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0,
+
+#ifndef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharNextFunc) PCF_Char_Get_Next,
+#else
+    (FT_CharMap_CharNextFunc) 0
+#endif
+  };
 
 
 /* END */
Index: xc/extras/freetype2/src/pcf/pcfdriver.h
diff -u xc/extras/freetype2/src/pcf/pcfdriver.h:1.1.1.2 xc/extras/freetype2/src/pcf/pcfdriver.h:1.1.1.3
--- xc/extras/freetype2/src/pcf/pcfdriver.h:1.1.1.2	Sun Dec 16 12:49:29 2001
+++ xc/extras/freetype2/src/pcf/pcfdriver.h	Thu Jun 20 04:16:18 2002
@@ -2,7 +2,7 @@
 
     FreeType font driver for pcf fonts
 
-  Copyright 2000-2001 by
+  Copyright 2000-2001, 2002 by
   Francesco Zappa Nardelli
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -33,7 +33,7 @@
 
 FT_BEGIN_HEADER
 
-  FT_EXPORT_VAR( const FT_Driver_Class )  pcf_driver_class;
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  pcf_driver_class;
 
 FT_END_HEADER
 
Index: xc/extras/freetype2/src/pcf/pcfread.c
diff -u xc/extras/freetype2/src/pcf/pcfread.c:1.1.1.4 xc/extras/freetype2/src/pcf/pcfread.c:1.1.1.6
--- xc/extras/freetype2/src/pcf/pcfread.c:1.1.1.4	Mon Jan 14 11:52:13 2002
+++ xc/extras/freetype2/src/pcf/pcfread.c	Thu Jun 20 04:16:18 2002
@@ -2,7 +2,7 @@
 
     FreeType font driver for pcf fonts
 
-  Copyright 2000-2001 by
+  Copyright 2000-2001, 2002 by
   Francesco Zappa Nardelli
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -36,9 +36,7 @@
 
 #include "pcferror.h"
 
-#include <string.h>     /* strlen(), strcpy() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -94,24 +92,24 @@
     PCF_Toc    toc = &face->toc;
     PCF_Table  tables;
 
-    FT_Memory     memory = FT_FACE(face)->memory;
-    unsigned int  n;
+    FT_Memory  memory = FT_FACE(face)->memory;
+    FT_UInt    n;
 
 
-    if ( FILE_Seek ( 0 )                   ||
-         READ_Fields ( pcf_toc_header, toc ) )
+    if ( FT_STREAM_SEEK ( 0 )                          ||
+         FT_STREAM_READ_FIELDS ( pcf_toc_header, toc ) )
       return PCF_Err_Cannot_Open_Resource;
 
     if ( toc->version != PCF_FILE_VERSION )
       return PCF_Err_Invalid_File_Format;
 
-    if ( ALLOC( face->toc.tables, toc->count * sizeof ( PCF_TableRec ) ) )
+    if ( FT_NEW_ARRAY( face->toc.tables, toc->count ) )
       return PCF_Err_Out_Of_Memory;
 
     tables = face->toc.tables;
     for ( n = 0; n < toc->count; n++ )
     {
-      if ( READ_Fields( pcf_table_header, tables ) )
+      if ( FT_STREAM_READ_FIELDS( pcf_table_header, tables ) )
         goto Exit;
       tables++;
     }
@@ -119,8 +117,8 @@
 #if defined( FT_DEBUG_LEVEL_TRACE )
 
     {
-      unsigned int  i, j;
-      const char    *name = "?";
+      FT_UInt      i, j;
+      const char*  name = "?";
 
 
       FT_TRACE4(( "Tables count: %ld\n", face->toc.count ));
@@ -128,8 +126,9 @@
       for ( i = 0; i < toc->count; i++ )
       {
         for( j = 0; j < sizeof ( tableNames ) / sizeof ( tableNames[0] ); j++ )
-          if ( tables[i].type == (unsigned int)( 1 << j ) )
+          if ( tables[i].type == (FT_UInt)( 1 << j ) )
             name = tableNames[j];
+
         FT_TRACE4(( "Table %d: type=%-6s format=0x%04lX "
                     "size=0x%06lX (%8ld) offset=0x%04lX\n",
                     i, name,
@@ -144,7 +143,7 @@
     return PCF_Err_Ok;
 
   Exit:
-    FREE( face->toc.tables );
+    FT_FREE( face->toc.tables );
     return error;
   }
 
@@ -200,79 +199,58 @@
 
 
   static FT_Error
-  pcf_parse_metric( FT_Stream              stream,
-                    const FT_Frame_Field*  header,
-                    PCF_Metric             metric )
+  pcf_get_metric( FT_Stream   stream,
+                  FT_ULong    format,
+                  PCF_Metric  metric )
   {
     FT_Error  error = PCF_Err_Ok;
 
-
-    if ( READ_Fields( header, metric ) )
-      return error;
-
-    return PCF_Err_Ok;
-  }
-
-
-  static FT_Error
-  pcf_parse_compressed_metric( FT_Stream   stream,
-                               PCF_Metric  metric )
-  {
-    PCF_Compressed_MetricRec  compr_metric;
-    FT_Error                  error = PCF_Err_Ok;
-
 
-    if ( READ_Fields( pcf_compressed_metric_header, &compr_metric ) )
-      return error;
+    if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+    {
+      const FT_Frame_Field*  fields;
 
-    metric->leftSideBearing =
-      (FT_Short)( compr_metric.leftSideBearing - 0x80 );
-    metric->rightSideBearing =
-      (FT_Short)( compr_metric.rightSideBearing - 0x80 );
-    metric->characterWidth =
-      (FT_Short)( compr_metric.characterWidth - 0x80 );
-    metric->ascent =
-      (FT_Short)( compr_metric.ascent - 0x80 );
-    metric->descent =
-      (FT_Short)( compr_metric.descent - 0x80 );
-    metric->attributes = 0;
 
-    return PCF_Err_Ok;
-  }
+      /* parsing normal metrics */
+      fields = PCF_BYTE_ORDER( format ) == MSBFirst
+               ? pcf_metric_msb_header
+               : pcf_metric_header;
 
+      /* the following sets 'error' but doesn't return in case of failure */
+      (void)FT_STREAM_READ_FIELDS( fields, metric );
+    }
+    else
+    {
+      PCF_Compressed_MetricRec  compr;
 
-  static FT_Error
-  pcf_get_metric( FT_Stream   stream,
-                  FT_ULong    format,
-                  PCF_Metric  metric )
-  {
-    FT_Error error = PCF_Err_Ok;
 
+      /* parsing compressed metrics */
+      if ( FT_STREAM_READ_FIELDS( pcf_compressed_metric_header, &compr ) )
+        goto Exit;
 
-    if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
-    {
-      if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-        error = pcf_parse_metric( stream, pcf_metric_msb_header, metric );
-      else
-        error = pcf_parse_metric( stream, pcf_metric_header, metric );
+      metric->leftSideBearing  = (FT_Short)( compr.leftSideBearing  - 0x80 );
+      metric->rightSideBearing = (FT_Short)( compr.rightSideBearing - 0x80 );
+      metric->characterWidth   = (FT_Short)( compr.characterWidth   - 0x80 );
+      metric->ascent           = (FT_Short)( compr.ascent           - 0x80 );
+      metric->descent          = (FT_Short)( compr.descent          - 0x80 );
+      metric->attributes       = 0;
     }
-    else
-      error = pcf_parse_compressed_metric( stream, metric );
 
+  Exit:
     return error;
   }
 
 
   static FT_Error
-  pcfSeekToType( FT_Stream  stream,
-                 PCF_Table  tables,
-                 int        ntables,
-                 FT_ULong   type,
-                 FT_ULong*  formatp,
-                 FT_ULong*  sizep )
+  pcf_seek_to_table_type( FT_Stream  stream,
+                          PCF_Table  tables,
+                          FT_Int     ntables,
+                          FT_ULong   type,
+                          FT_ULong  *aformat,
+                          FT_ULong  *asize )
   {
-    FT_Error error;
-    int      i;
+    FT_Error  error = 0;
+    FT_Int    i;
 
 
     for ( i = 0; i < ntables; i++ )
@@ -280,10 +258,13 @@
       {
         if ( stream->pos > tables[i].offset )
           return PCF_Err_Invalid_Stream_Skip;
-        if ( FILE_Skip( tables[i].offset - stream->pos ) )
+
+        if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) )
           return PCF_Err_Invalid_Stream_Skip;
-        *sizep   = tables[i].size;  /* unused - to be removed */
-        *formatp = tables[i].format;
+
+        *asize   = tables[i].size;  /* unused - to be removed */
+        *aformat = tables[i].format;
+
         return PCF_Err_Ok;
       }
 
@@ -292,11 +273,11 @@
 
 
   static FT_Bool
-  pcfHasType( PCF_Table  tables,
-              int        ntables,
-              FT_ULong   type )
+  pcf_has_table_type( PCF_Table  tables,
+                      FT_Int     ntables,
+                      FT_ULong   type )
   {
-    int i;
+    FT_Int  i;
 
 
     for ( i = 0; i < ntables; i++ )
@@ -336,8 +317,8 @@
 
 
   static PCF_Property
-  find_property( PCF_Face          face,
-                 const FT_String*  prop )
+  pcf_find_property( PCF_Face          face,
+                     const FT_String*  prop )
   {
     PCF_Property  properties = face->properties;
     FT_Bool       found      = 0;
@@ -346,7 +327,7 @@
 
     for ( i = 0 ; i < face->nprops && !found; i++ )
     {
-      if ( !strcmp( properties[i].name, prop ) )
+      if ( !ft_strcmp( properties[i].name, prop ) )
         found = 1;
     }
 
@@ -363,7 +344,7 @@
   {
     PCF_ParseProperty  props      = 0;
     PCF_Property       properties = 0;
-    int                nprops, i;
+    FT_Int             nprops, i;
     FT_ULong           format, size;
     FT_Error           error;
     FT_Memory          memory     = FT_FACE(face)->memory;
@@ -371,16 +352,16 @@
     FT_String*         strings    = 0;
 
 
-    error = pcfSeekToType( stream,
-                           face->toc.tables,
-                           face->toc.count,
-                           PCF_PROPERTIES,
-                           &format,
-                           &size );
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_PROPERTIES,
+                                    &format,
+                                    &size );
     if ( error )
       goto Bail;
 
-    if ( READ_ULongLE( format ) )
+    if ( FT_READ_ULONG_LE( format ) )
       goto Bail;
 
     FT_TRACE4(( "get_prop: format = %ld\n", format ));
@@ -389,27 +370,27 @@
       goto Bail;
 
     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-      (void)READ_ULong( nprops );
+      (void)FT_READ_ULONG( nprops );
     else
-      (void)READ_ULongLE( nprops );
+      (void)FT_READ_ULONG_LE( nprops );
     if ( error )
       goto Bail;
 
     FT_TRACE4(( "get_prop: nprop = %d\n", nprops ));
 
-    if ( ALLOC( props, nprops * sizeof ( PCF_ParsePropertyRec ) ) )
+    if ( FT_NEW_ARRAY( props, nprops ) )
       goto Bail;
 
     for ( i = 0; i < nprops; i++ )
     {
       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       {
-        if ( READ_Fields( pcf_property_msb_header, props + i ) )
+        if ( FT_STREAM_READ_FIELDS( pcf_property_msb_header, props + i ) )
           goto Bail;
       }
       else
       {
-        if ( READ_Fields( pcf_property_header, props + i ) )
+        if ( FT_STREAM_READ_FIELDS( pcf_property_header, props + i ) )
           goto Bail;
       }
     }
@@ -422,46 +403,44 @@
     if ( nprops & 3 )
     {
       i = 4 - ( nprops & 3 );
-      FT_Skip_Stream( stream, i );
+      FT_Stream_Skip( stream, i );
     }
 
     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-      (void)READ_ULong( string_size );
+      (void)FT_READ_ULONG( string_size );
     else
-      (void)READ_ULongLE( string_size );
+      (void)FT_READ_ULONG_LE( string_size );
     if ( error )
       goto Bail;
 
     FT_TRACE4(( "get_prop: string_size = %ld\n", string_size ));
 
-    if ( ALLOC( strings, string_size * sizeof ( char ) ) )
+    if ( FT_NEW_ARRAY( strings, string_size ) )
       goto Bail;
 
-    error = FT_Read_Stream( stream, (FT_Byte*)strings, string_size );
+    error = FT_Stream_Read( stream, (FT_Byte*)strings, string_size );
     if ( error )
       goto Bail;
 
-    if ( ALLOC( properties, nprops * sizeof ( PCF_PropertyRec ) ) )
+    if ( FT_NEW_ARRAY( properties, nprops ) )
       goto Bail;
 
     for ( i = 0; i < nprops; i++ )
     {
       /* XXX: make atom */
-      if ( ALLOC( properties[i].name,
-                     ( strlen( strings + props[i].name ) + 1 ) *
-                       sizeof ( char ) ) )
+      if ( FT_NEW_ARRAY( properties[i].name,
+                         ft_strlen( strings + props[i].name ) + 1 ) )
         goto Bail;
-      strcpy( properties[i].name,strings + props[i].name );
+      ft_strcpy( properties[i].name,strings + props[i].name );
 
       properties[i].isString = props[i].isString;
 
       if ( props[i].isString )
       {
-        if ( ALLOC( properties[i].value.atom,
-                       ( strlen( strings + props[i].value ) + 1 ) *
-                         sizeof ( char ) ) )
+        if ( FT_NEW_ARRAY( properties[i].value.atom,
+                           ft_strlen( strings + props[i].value ) + 1 ) )
           goto Bail;
-        strcpy( properties[i].value.atom, strings + props[i].value );
+        ft_strcpy( properties[i].value.atom, strings + props[i].value );
       }
       else
         properties[i].value.integer = props[i].value;
@@ -470,14 +449,14 @@
     face->properties = properties;
     face->nprops = nprops;
 
-    FREE( props );
-    FREE( strings );
+    FT_FREE( props );
+    FT_FREE( strings );
 
     return PCF_Err_Ok;
 
   Bail:
-    FREE( props );
-    FREE( strings );
+    FT_FREE( props );
+    FT_FREE( strings );
 
     return error;
   }
@@ -496,41 +475,41 @@
     int         nmetrics = -1;
 
 
-    error = pcfSeekToType( stream,
-                           face->toc.tables,
-                           face->toc.count,
-                           PCF_METRICS,
-                           &format,
-                           &size );
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_METRICS,
+                                    &format,
+                                    &size );
     if ( error )
       return error;
 
-    error = READ_ULongLE( format );
+    error = FT_READ_ULONG_LE( format );
 
-    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )   &&
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )     &&
          !PCF_FORMAT_MATCH( format, PCF_COMPRESSED_METRICS ) )
       return PCF_Err_Invalid_File_Format;
 
     if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
     {
       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-        (void)READ_ULong( nmetrics );
+        (void)FT_READ_ULONG( nmetrics );
       else
-        (void)READ_ULongLE( nmetrics );
+        (void)FT_READ_ULONG_LE( nmetrics );
     }
     else
     {
       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-        (void)READ_UShort( nmetrics );
+        (void)FT_READ_USHORT( nmetrics );
       else
-        (void)READ_UShortLE( nmetrics );
+        (void)FT_READ_USHORT_LE( nmetrics );
     }
     if ( error || nmetrics == -1 )
       return PCF_Err_Invalid_File_Format;
 
     face->nmetrics = nmetrics;
 
-    if ( ALLOC( face->metrics, nmetrics * sizeof ( PCF_MetricRec ) ) )
+    if ( FT_NEW_ARRAY( face->metrics, nmetrics ) )
       return PCF_Err_Out_Of_Memory;
 
     metrics = face->metrics;
@@ -555,7 +534,7 @@
     }
 
     if ( error )
-      FREE( face->metrics );
+      FT_FREE( face->metrics );
     return error;
   }
 
@@ -573,55 +552,54 @@
     char*      bitmaps;
 
 
-    error = pcfSeekToType( stream,
-                           face->toc.tables,
-                           face->toc.count,
-                           PCF_BITMAPS,
-                           &format,
-                           &size );
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_BITMAPS,
+                                    &format,
+                                    &size );
     if ( error )
       return error;
 
-    error = FT_Access_Frame( stream, 8 );
+    error = FT_Stream_EnterFrame( stream, 8 );
     if ( error )
       return error;
-    format = GET_ULongLE();
-    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
-      return PCF_Err_Invalid_File_Format;
 
+    format = FT_GET_ULONG_LE();
     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-      nbitmaps  = GET_ULong();
+      nbitmaps  = FT_GET_ULONG();
     else
-      nbitmaps  = GET_ULongLE();
-    FT_Forget_Frame( stream );
+      nbitmaps  = FT_GET_ULONG_LE();
+
+    FT_Stream_ExitFrame( stream );
+
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+      return PCF_Err_Invalid_File_Format;
+
     if ( nbitmaps != face->nmetrics )
       return PCF_Err_Invalid_File_Format;
 
-    if ( ALLOC( offsets, nbitmaps * sizeof ( FT_ULong ) ) )
+    if ( FT_NEW_ARRAY( offsets, nbitmaps ) )
       return error;
 
-    if ( error )
-      goto Bail;
     for ( i = 0; i < nbitmaps; i++ )
     {
       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-        (void)READ_Long( offsets[i] );
+        (void)FT_READ_LONG( offsets[i] );
       else
-        (void)READ_LongLE( offsets[i] );
+        (void)FT_READ_LONG_LE( offsets[i] );
 
       FT_TRACE4(( "bitmap %d is at offset %ld\n", i, offsets[i] ));
     }
     if ( error )
       goto Bail;
 
-    if ( error )
-      goto Bail;
     for ( i = 0; i < GLYPHPADOPTIONS; i++ )
     {
       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-        (void)READ_Long( bitmapSizes[i] );
+        (void)FT_READ_LONG( bitmapSizes[i] );
       else
-        (void)READ_LongLE( bitmapSizes[i] );
+        (void)FT_READ_LONG_LE( bitmapSizes[i] );
       if ( error )
         goto Bail;
 
@@ -635,17 +613,19 @@
                 PCF_GLYPH_PAD_INDEX( format ) ));
     FT_TRACE4(( "bitmap size = %d\n", sizebitmaps ));
 
+    FT_UNUSED( sizebitmaps );       /* only used for debugging */
+
     for ( i = 0; i < nbitmaps; i++ )
       face->metrics[i].bits = stream->pos + offsets[i];
 
     face->bitmapsFormat = format;
 
-    FREE ( offsets );
+    FT_FREE ( offsets );
     return error;
 
   Bail:
-    FREE ( offsets );
-    FREE ( bitmaps );
+    FT_FREE ( offsets );
+    FT_FREE ( bitmaps );
     return error;
   }
 
@@ -664,59 +644,61 @@
     PCF_Encoding  tmpEncoding, encoding = 0;
 
 
-    error = pcfSeekToType( stream,
-                           face->toc.tables,
-                           face->toc.count,
-                           PCF_BDF_ENCODINGS,
-                           &format,
-                           &size );
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    PCF_BDF_ENCODINGS,
+                                    &format,
+                                    &size );
     if ( error )
       return error;
 
-    error = FT_Access_Frame( stream, 14 );
+    error = FT_Stream_EnterFrame( stream, 14 );
     if ( error )
       return error;
-    format = GET_ULongLE();
-    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
-      return PCF_Err_Invalid_File_Format;
+
+    format = FT_GET_ULONG_LE();
 
     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
     {
-      firstCol          = GET_Short();
-      lastCol           = GET_Short();
-      firstRow          = GET_Short();
-      lastRow           = GET_Short();
-      face->defaultChar = GET_Short();
+      firstCol          = FT_GET_SHORT();
+      lastCol           = FT_GET_SHORT();
+      firstRow          = FT_GET_SHORT();
+      lastRow           = FT_GET_SHORT();
+      face->defaultChar = FT_GET_SHORT();
     }
     else
     {
-      firstCol          = GET_ShortLE();
-      lastCol           = GET_ShortLE();
-      firstRow          = GET_ShortLE();
-      lastRow           = GET_ShortLE();
-      face->defaultChar = GET_ShortLE();
+      firstCol          = FT_GET_SHORT_LE();
+      lastCol           = FT_GET_SHORT_LE();
+      firstRow          = FT_GET_SHORT_LE();
+      lastRow           = FT_GET_SHORT_LE();
+      face->defaultChar = FT_GET_SHORT_LE();
     }
 
-    FT_Forget_Frame( stream );
+    FT_Stream_ExitFrame( stream );
 
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
+      return PCF_Err_Invalid_File_Format;
+
     FT_TRACE4(( "enc: firstCol %d, lastCol %d, firstRow %d, lastRow %d\n",
                 firstCol, lastCol, firstRow, lastRow ));
 
     nencoding = ( lastCol - firstCol + 1 ) * ( lastRow - firstRow + 1 );
 
-    if ( ALLOC( tmpEncoding, nencoding * sizeof ( PCF_EncodingRec ) ) )
+    if ( FT_NEW_ARRAY( tmpEncoding, nencoding ) )
       return PCF_Err_Out_Of_Memory;
 
-    error = FT_Access_Frame( stream, 2 * nencoding );
+    error = FT_Stream_EnterFrame( stream, 2 * nencoding );
     if ( error )
       goto Bail;
 
     for ( i = 0, j = 0 ; i < nencoding; i++ )
     {
       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
-        encodingOffset = GET_Short();
+        encodingOffset = FT_GET_SHORT();
       else
-        encodingOffset = GET_ShortLE();
+        encodingOffset = FT_GET_SHORT_LE();
 
       if ( encodingOffset != -1 )
       {
@@ -732,9 +714,10 @@
       FT_TRACE4(( "enc n. %d ; Uni %ld ; Glyph %d\n",
                   i, tmpEncoding[j - 1].enc, encodingOffset ));
     }
-    FT_Forget_Frame( stream );
+    FT_Stream_ExitFrame( stream );
 
-    if ( ALLOC( encoding, (--j) * sizeof ( PCF_EncodingRec ) ) )
+    j--;
+    if ( FT_NEW_ARRAY( encoding, j ) )
       goto Bail;
 
     for ( i = 0; i < j; i++ )
@@ -745,13 +728,13 @@
 
     face->nencodings = j;
     face->encodings  = encoding;
-    FREE( tmpEncoding );
+    FT_FREE( tmpEncoding );
 
     return error;
 
   Bail:
-    FREE( encoding );
-    FREE( tmpEncoding );
+    FT_FREE( encoding );
+    FT_FREE( tmpEncoding );
     return error;
   }
 
@@ -810,44 +793,55 @@
     PCF_Accel  accel = &face->accel;
 
 
-    error = pcfSeekToType( stream,
-                           face->toc.tables,
-                           face->toc.count,
-                           type,
-                           &format,
-                           &size );
+    error = pcf_seek_to_table_type( stream,
+                                    face->toc.tables,
+                                    face->toc.count,
+                                    type,
+                                    &format,
+                                    &size );
     if ( error )
       goto Bail;
 
-    error = READ_ULongLE( format );
-    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )  &&
+    error = FT_READ_ULONG_LE( format );
+
+    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )    &&
          !PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
       goto Bail;
 
     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
     {
-      if ( READ_Fields( pcf_accel_msb_header, accel ) )
+      if ( FT_STREAM_READ_FIELDS( pcf_accel_msb_header, accel ) )
         goto Bail;
     }
     else
     {
-      if ( READ_Fields( pcf_accel_header, accel ) )
+      if ( FT_STREAM_READ_FIELDS( pcf_accel_header, accel ) )
         goto Bail;
     }
 
-    error = pcf_get_metric( stream, format, &(accel->minbounds) );
+    error = pcf_get_metric( stream,
+                            format & ( ~PCF_FORMAT_MASK ),
+                            &(accel->minbounds) );
     if ( error )
       goto Bail;
-    error = pcf_get_metric( stream, format, &(accel->maxbounds) );
+
+    error = pcf_get_metric( stream,
+                            format & ( ~PCF_FORMAT_MASK ),
+                            &(accel->maxbounds) );
     if ( error )
       goto Bail;
 
     if ( PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
     {
-      error = pcf_get_metric( stream, format, &(accel->ink_minbounds) );
+      error = pcf_get_metric( stream,
+                              format & ( ~PCF_FORMAT_MASK ),
+                              &(accel->ink_minbounds) );
       if ( error )
         goto Bail;
-      error = pcf_get_metric( stream, format, &(accel->ink_maxbounds) );
+
+      error = pcf_get_metric( stream,
+                              format & ( ~PCF_FORMAT_MASK ),
+                              &(accel->ink_maxbounds) );
       if ( error )
         goto Bail;
     }
@@ -863,7 +857,7 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   pcf_load_font( FT_Stream  stream,
                  PCF_Face   face )
   {
@@ -874,44 +868,44 @@
 
     error = pcf_read_TOC( stream, face );
     if ( error )
-      return error;
+      goto Exit;
 
     error = pcf_get_properties( stream, face );
     if ( error )
-      return error;;
+      goto Exit;
 
     /* Use the old accelerators if no BDF accelerators are in the file. */
-    hasBDFAccelerators = pcfHasType( face->toc.tables,
-                                     face->toc.count,
-                                     PCF_BDF_ACCELERATORS );
+    hasBDFAccelerators = pcf_has_table_type( face->toc.tables,
+                                             face->toc.count,
+                                             PCF_BDF_ACCELERATORS );
     if ( !hasBDFAccelerators )
     {
       error = pcf_get_accel( stream, face, PCF_ACCELERATORS );
       if ( error )
-        goto Bail;
+        goto Exit;
     }
 
     /* metrics */
     error = pcf_get_metrics( stream, face );
     if ( error )
-      goto Bail;
+      goto Exit;
 
     /* bitmaps */
     error = pcf_get_bitmaps( stream, face );
     if ( error )
-      goto Bail;
+      goto Exit;
 
     /* encodings */
     error = pcf_get_encodings( stream, face );
     if ( error )
-      goto Bail;
+      goto Exit;
 
     /* BDF style accelerators (i.e. bounds based on encoded glyphs) */
     if ( hasBDFAccelerators )
     {
       error = pcf_get_accel( stream, face, PCF_BDF_ACCELERATORS );
       if ( error )
-        goto Bail;
+        goto Exit;
     }
 
     /* XXX: TO DO: inkmetrics and glyph_names are missing */
@@ -933,14 +927,14 @@
         root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
 
       root->style_flags = 0;
-      prop = find_property( face, "SLANT" );
+      prop = pcf_find_property( face, "SLANT" );
       if ( prop != NULL )
         if ( prop->isString )
           if ( ( *(prop->value.atom) == 'O' ) ||
                ( *(prop->value.atom) == 'I' ) )
             root->style_flags |= FT_STYLE_FLAG_ITALIC;
 
-      prop = find_property( face, "WEIGHT_NAME" );
+      prop = pcf_find_property( face, "WEIGHT_NAME" );
       if ( prop != NULL )
         if ( prop->isString )
           if ( *(prop->value.atom) == 'B' )
@@ -957,17 +951,17 @@
       else if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
         root->style_name = (char *)"Italic";
 
-      prop = find_property( face, "FAMILY_NAME" );
+      prop = pcf_find_property( face, "FAMILY_NAME" );
       if ( prop != NULL )
       {
         if ( prop->isString )
         {
-          int  l = strlen( prop->value.atom ) + 1;
+          int  l = ft_strlen( prop->value.atom ) + 1;
 
 
-          if ( ALLOC( root->family_name, l * sizeof ( char ) ) )
-            goto Bail;
-          strcpy( root->family_name, prop->value.atom );
+          if ( FT_NEW_ARRAY( root->family_name, l ) )
+            goto Exit;
+          ft_strcpy( root->family_name, prop->value.atom );
         }
       }
       else
@@ -976,37 +970,39 @@
       root->num_glyphs = face->nmetrics;
 
       root->num_fixed_sizes = 1;
-      if ( ALLOC_ARRAY( root->available_sizes, 1, FT_Bitmap_Size ) )
-        goto Bail;
+      if ( FT_NEW_ARRAY( root->available_sizes, 1 ) )
+        goto Exit;
 
-      prop = find_property( face, "PIXEL_SIZE" );
+      prop = pcf_find_property( face, "PIXEL_SIZE" );
       if ( prop != NULL )
       {
+        root->available_sizes->height =
         root->available_sizes->width  = (FT_Short)( prop->value.integer );
-        root->available_sizes->height = (FT_Short)( prop->value.integer );
-        
+
         size_set = 1;
       }
-      else 
+      else
       {
-        prop = find_property( face, "POINT_SIZE" );
+        prop = pcf_find_property( face, "POINT_SIZE" );
         if ( prop != NULL )
         {
-          PCF_Property  xres = 0, yres = 0;
+          PCF_Property  xres, yres, avgw;
+
 
+          xres = pcf_find_property( face, "RESOLUTION_X" );
+          yres = pcf_find_property( face, "RESOLUTION_Y" );
+          avgw = pcf_find_property( face, "AVERAGE_WIDTH" );
 
-          xres = find_property( face, "RESOLUTION_X" );
-          yres = find_property( face, "RESOLUTION_Y" );
-              
-          if ( ( xres != NULL ) && ( yres != NULL ) )
+          if ( ( yres != NULL ) && ( xres != NULL ) )
           {
-            root->available_sizes->width =
-              (FT_Short)( prop->value.integer *  
-                          xres->value.integer / 720 );
             root->available_sizes->height =
-              (FT_Short)( prop->value.integer *  
-                          yres->value.integer / 720 ); 
-                  
+              (FT_Short)( prop->value.integer *
+                          yres->value.integer / 720 );
+
+              root->available_sizes->width =
+                (FT_Short)( prop->value.integer *
+                            xres->value.integer / 720 );
+
             size_set = 1;
           }
         }
@@ -1014,23 +1010,17 @@
 
       if (size_set == 0 )
       {
-#if 0
-        printf( "PCF Warning: Pixel Size undefined, assuming 12\n");
-#endif
         root->available_sizes->width  = 12;
         root->available_sizes->height = 12;
       }
 
-      /* XXX: charmaps */
-      root->charmaps     = &face->charmap_handle;
-      root->num_charmaps = 1;
-
+      /* set-up charset */
       {
         PCF_Property  charset_registry = 0, charset_encoding = 0;
 
 
-        charset_registry = find_property( face, "CHARSET_REGISTRY" );
-        charset_encoding = find_property( face, "CHARSET_ENCODING" );
+        charset_registry = pcf_find_property( face, "CHARSET_REGISTRY" );
+        charset_encoding = pcf_find_property( face, "CHARSET_ENCODING" );
 
         if ( ( charset_registry != NULL ) &&
              ( charset_encoding != NULL ) )
@@ -1038,45 +1028,30 @@
           if ( ( charset_registry->isString ) &&
                ( charset_encoding->isString ) )
           {
-            if ( ALLOC( face->charset_encoding,
-                        ( strlen( charset_encoding->value.atom ) + 1 ) *
-                          sizeof ( char ) ) )
-              goto Bail;
-            if ( ALLOC( face->charset_registry,
-                        ( strlen( charset_registry->value.atom ) + 1 ) *
-                          sizeof ( char ) ) )
-              goto Bail;
-            strcpy( face->charset_registry, charset_registry->value.atom );
-            strcpy( face->charset_encoding, charset_encoding->value.atom );
-
-#if 0
-            if ( !strcmp( charset_registry, "ISO10646" ) )
-            {
-              face->charmap.encoding    = ft_encoding_unicode;
-              face->charmap.platform_id = 3;
-              face->charmap.encoding_id = 1;
-              face->charmap.face        = root;
-              face->charmap_handle
+            if ( FT_NEW_ARRAY( face->charset_encoding,
+                               ft_strlen( charset_encoding->value.atom ) + 1 ) )
+              goto Exit;
+
+            if ( FT_NEW_ARRAY( face->charset_registry,
+                               ft_strlen( charset_registry->value.atom ) + 1 ) )
+              goto Exit;
 
-              return PCF_Err_Ok;
-            }
-#endif
+            ft_strcpy( face->charset_registry, charset_registry->value.atom );
+            ft_strcpy( face->charset_encoding, charset_encoding->value.atom );
           }
         }
       }
+    }
 
-      face->charmap.encoding    = ft_encoding_none;
-      face->charmap.platform_id = 0;
-      face->charmap.encoding_id = 0;
-      face->charmap.face        = root;
-      face->charmap_handle      = &face->charmap;
-      root->charmap             = face->charmap_handle;
+  Exit:
+    if ( error )
+    {
+      /* this is done to respect the behaviour of the original */
+      /* PCF font driver.                                      */
+      error = PCF_Err_Invalid_File_Format;
     }
-    return PCF_Err_Ok;
 
-  Bail:
-    PCF_Done_Face( face );
-    return PCF_Err_Invalid_File_Format;
+    return error;
   }
 
 
Index: xc/extras/freetype2/src/pcf/pcfutil.c
diff -u xc/extras/freetype2/src/pcf/pcfutil.c:1.3 xc/extras/freetype2/src/pcf/pcfutil.c:1.4
--- xc/extras/freetype2/src/pcf/pcfutil.c:1.3	Sun Dec 16 13:01:54 2001
+++ xc/extras/freetype2/src/pcf/pcfutil.c	Mon Dec 16 22:28:26 2002
@@ -23,7 +23,7 @@
 in this Software without prior written authorization from The Open Group.
 
 */
-/* $XFree86: xc/extras/freetype2/src/pcf/pcfutil.c,v 1.3 2001/12/16 18:01:54 keithp Exp $ */
+/* $XFree86: xc/extras/freetype2/src/pcf/pcfutil.c,v 1.4 2002/12/17 03:28:26 dawes Exp $ */
 
 /*
  * Author:  Keith Packard, MIT X Consortium
@@ -76,7 +76,7 @@
    *  Invert bit order within each BYTE of an array.
    */
 
-  void
+  static void
   BitOrderInvert( unsigned char*  buf,
                   int             nbytes )
   {
@@ -92,7 +92,7 @@
    *  Invert byte order within each 16-bits of an array.
    */
 
-  void
+  static void
   TwoByteSwap( unsigned char*  buf,
                int             nbytes )
   {
@@ -111,7 +111,7 @@
    *  Invert byte order within each 32-bits of an array.
    */
 
-  void
+  static void
   FourByteSwap( unsigned char*  buf,
                 int             nbytes )
   {
@@ -135,7 +135,7 @@
    *  Repad a bitmap.
    */
 
-  int
+  static int
   RepadBitmap( char*         pSrc,
                char*         pDst,
                unsigned int  srcPad,
Index: xc/extras/freetype2/src/pcf/pcfutil.h
diff -u xc/extras/freetype2/src/pcf/pcfutil.h:1.1.1.2 xc/extras/freetype2/src/pcf/pcfutil.h:1.2
--- xc/extras/freetype2/src/pcf/pcfutil.h:1.1.1.2	Sun Dec 16 12:49:30 2001
+++ xc/extras/freetype2/src/pcf/pcfutil.h	Wed Dec 18 10:39:36 2002
@@ -32,19 +32,19 @@
 #include <ft2build.h>
 
 
-  void
+  static void
   BitOrderInvert( unsigned char*  buf,
                   int             nbytes);
 
-  void
+  static void
   TwoByteSwap( unsigned char*  buf,
                int             nbytes);
 
-  void
+  static void
   FourByteSwap( unsigned char*  buf,
                 int             nbytes);
 
-  int
+  static int
   RepadBitmap( char*           pSrc,
                char*           pDst,
                unsigned int    srcPad,
Index: xc/extras/freetype2/src/pcf/rules.mk
diff -u xc/extras/freetype2/src/pcf/rules.mk:1.1.1.2 xc/extras/freetype2/src/pcf/rules.mk:1.1.1.3
--- xc/extras/freetype2/src/pcf/rules.mk:1.1.1.2	Sun Sep  9 22:56:04 2001
+++ xc/extras/freetype2/src/pcf/rules.mk	Thu Jun 20 04:16:18 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright (C) 2000 by
+# Copyright (C) 2000, 2001 by
 # Francesco Zappa Nardelli
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
Index: xc/extras/freetype2/src/pfr/Jamfile
diff -u /dev/null xc/extras/freetype2/src/pfr/Jamfile:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/Jamfile	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,23 @@
+# FreeType 2 src/pfr Jamfile (c) 2002 David Turner
+#
+
+SubDir  FT2_TOP src pfr ;
+
+SubDirHdrs  [ FT2_SubDir  src pfr ] ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = pfrdrivr  pfrgload  pfrload  pfrobjs pfrcmap ;
+  }
+  else
+  {
+    _sources = pfr ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/pfr Jamfile
Index: xc/extras/freetype2/src/pfr/descrip.mms
diff -u /dev/null xc/extras/freetype2/src/pfr/descrip.mms:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/descrip.mms	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,23 @@
+#
+# FreeType 2 PFR driver compilation rules for VMS
+#
+
+
+# Copyright 2002 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.pfr])
+
+OBJS=pfr.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
Index: xc/extras/freetype2/src/pfr/module.mk
diff -u /dev/null xc/extras/freetype2/src/pfr/module.mk:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/module.mk	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,22 @@
+#
+# FreeType 2 PFR module definition
+#
+
+
+# Copyright 2002 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_pfr_driver
+
+add_pfr_driver:
+	$(OPEN_DRIVER)pfr_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)pfr       $(ECHO_DRIVER_DESC)PFR/TrueDoc font files with extension *.pfr$(ECHO_DRIVER_DONE)
+
+# EOF
Index: xc/extras/freetype2/src/pfr/pfr.c
diff -u /dev/null xc/extras/freetype2/src/pfr/pfr.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfr.c	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,28 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfr.c                                                                  */
+/*                                                                         */
+/*    FreeType PFR driver component.                                       */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include <ft2build.h>
+
+#include "pfrload.c"
+#include "pfrgload.c"
+#include "pfrcmap.c"
+#include "pfrobjs.c"
+#include "pfrdrivr.c"
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrcmap.c
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrcmap.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfrcmap.c	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,152 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrcmap.c                                                              */
+/*                                                                         */
+/*    FreeType PFR cmap handling (body).                                   */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "pfrcmap.h" 
+#include "pfrobjs.h"
+#include FT_INTERNAL_DEBUG_H
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_cmap_init( PFR_CMap  cmap )
+  {
+    PFR_Face  face = (PFR_Face)FT_CMAP_FACE( cmap );
+
+
+    cmap->num_chars = face->phy_font.num_chars;
+    cmap->chars     = face->phy_font.chars;
+    
+    /* just for safety, check that the character entries are correctly */
+    /* sorted in increasing character code order                       */
+    {
+      FT_UInt  n;
+      
+
+      for ( n = 1; n < cmap->num_chars; n++ )
+      {
+        if ( cmap->chars[n - 1].char_code >= cmap->chars[n].char_code )
+          FT_ASSERT( 0 );
+      }
+    }
+    
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  pfr_cmap_done( PFR_CMap  cmap )
+  {
+    cmap->chars     = NULL;
+    cmap->num_chars = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pfr_cmap_char_index( PFR_CMap   cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_UInt   min = 0;
+    FT_UInt   max = cmap->num_chars;
+    FT_UInt   mid;
+    PFR_Char  gchar;
+
+
+    while ( min < max )
+    {
+      mid   = min + ( max - min ) / 2;
+      gchar = cmap->chars + mid;
+
+      if ( gchar->char_code == char_code )
+        return mid;
+
+      if ( gchar->char_code < char_code )
+        min = mid + 1;
+      else
+        max = mid;
+    }
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  pfr_cmap_char_next( PFR_CMap    cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+  Restart:
+    {
+      FT_UInt   min = 0;
+      FT_UInt   max = cmap->num_chars;
+      FT_UInt   mid;
+      PFR_Char  gchar;
+
+
+      while ( min < max )
+      {
+        mid   = min + ( ( max - min ) >> 1 );
+        gchar = cmap->chars + mid;
+
+        if ( gchar->char_code == char_code )
+        {
+          result = mid;
+          if ( result != 0 )
+            goto Exit;
+
+          char_code++;
+          goto Restart;
+        }
+
+        if ( gchar->char_code < char_code )
+          min = mid+1;
+        else
+          max = mid;
+      }
+
+      /* we didn't find it, but we have a pair just above it */
+      char_code = 0;
+
+      if ( min < cmap->num_chars )
+      {
+        gchar  = cmap->chars + min;
+        result = min;
+        if ( result != 0 )
+          char_code = gchar->char_code;
+      }
+    }
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  pfr_cmap_class_rec =
+  {
+    sizeof ( PFR_CMapRec ),
+
+    (FT_CMap_InitFunc)     pfr_cmap_init,
+    (FT_CMap_DoneFunc)     pfr_cmap_done,
+    (FT_CMap_CharIndexFunc)pfr_cmap_char_index,
+    (FT_CMap_CharNextFunc) pfr_cmap_char_next
+  };
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrcmap.h
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrcmap.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfrcmap.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,46 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrcmap.h                                                              */
+/*                                                                         */
+/*    FreeType PFR cmap handling (specification).                          */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PFRCMAP_H__
+#define __PFRCMAP_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include "pfrtypes.h"
+
+
+FT_BEGIN_HEADER
+
+  typedef struct  PFR_CMapRec_
+  {
+    FT_CMapRec  cmap;
+    FT_UInt     num_chars;
+    PFR_Char    chars;
+  
+  } PFR_CMapRec, *PFR_CMap;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec  pfr_cmap_class_rec;
+
+FT_END_HEADER
+
+
+#endif /* __PFRCMAP_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrdrivr.c
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrdrivr.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfrdrivr.c	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,70 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrdrivr.c                                                             */
+/*                                                                         */
+/*    FreeType PFR driver interface (body).                                */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include "pfrdrivr.h"
+#include "pfrobjs.h"
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_ClassRec  pfr_driver_class =
+  {
+    {
+      ft_module_font_driver      |
+      ft_module_driver_scalable,
+
+      sizeof( FT_DriverRec ),
+
+      "pfr",
+      0x10000L,
+      0x20000L,
+
+      0,   /* format interface */
+
+      (FT_Module_Constructor)NULL,
+      (FT_Module_Destructor) NULL,
+      (FT_Module_Requester)  NULL
+    },
+
+    sizeof( PFR_FaceRec ),
+    sizeof( PFR_SizeRec ),
+    sizeof( PFR_SlotRec ),
+
+    (FT_Face_InitFunc)        pfr_face_init,
+    (FT_Face_DoneFunc)        pfr_face_done,
+    (FT_Size_InitFunc)        NULL,
+    (FT_Size_DoneFunc)        NULL,
+    (FT_Slot_InitFunc)        pfr_slot_init,
+    (FT_Slot_DoneFunc)        pfr_slot_done,
+
+    (FT_Size_ResetPointsFunc) NULL,
+    (FT_Size_ResetPixelsFunc) NULL,
+    (FT_Slot_LoadFunc)        pfr_slot_load,
+    (FT_CharMap_CharIndexFunc)NULL,
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0,
+
+    (FT_CharMap_CharNextFunc) NULL
+  };
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrdrivr.h
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrdrivr.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfrdrivr.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,39 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrdrivr.h                                                             */
+/*                                                                         */
+/*    High-level Type PFR driver interface (specification).                */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PFRDRIVR_H__
+#define __PFRDRIVR_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  pfr_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __PFRDRIVR_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrerror.h
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrerror.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfrerror.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrerror.h                                                             */
+/*                                                                         */
+/*    PFR error codes (specification only).                                */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to define the PFR error enumeration constants.      */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __PFRERROR_H__
+#define __PFRERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  PFR_Err_
+#define FT_ERR_BASE    FT_Mod_Err_PFR
+
+#include FT_ERRORS_H
+
+#endif /* __PFRERROR_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrgload.c
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrgload.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfrgload.c	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,793 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrgload.c                                                             */
+/*                                                                         */
+/*    FreeType PFR glyph loader (body).                                    */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "pfrgload.h"
+#include "pfrload.h"            /* for macro definitions */
+#include FT_INTERNAL_DEBUG_H
+
+#include "pfrerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pfr
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      PFR GLYPH BUILDER                        *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( void )
+  pfr_glyph_init( PFR_Glyph       glyph,
+                  FT_GlyphLoader  loader )
+  {
+    FT_ZERO( glyph );
+
+    glyph->loader     = loader;
+    glyph->path_begun = 0;
+
+    FT_GlyphLoader_Rewind( loader );
+  }
+
+
+  FT_LOCAL_DEF( void )
+  pfr_glyph_done( PFR_Glyph  glyph )
+  {
+    FT_Memory  memory = glyph->loader->memory;
+
+
+    FT_FREE( glyph->x_control );
+    glyph->y_control = NULL;
+
+    glyph->max_xy_control = 0;
+    glyph->num_x_control  = 0;
+    glyph->num_y_control  = 0;
+
+    FT_FREE( glyph->subs );
+
+    glyph->max_subs = 0;
+    glyph->num_subs = 0;
+
+    glyph->loader     = NULL;
+    glyph->path_begun = 0;
+  }
+
+
+  /* close current contour, if any */
+  static void
+  pfr_glyph_close_contour( PFR_Glyph  glyph )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Outline*     outline = &loader->current.outline;
+    FT_Int          last, first;
+
+
+    if ( !glyph->path_begun )
+      return;
+
+    /* compute first and last point indices in current glyph outline */
+    last  = outline->n_points - 1;
+    first = 0;
+    if ( outline->n_contours > 0 )
+      first = outline->contours[outline->n_contours - 1];
+
+    /* if the last point falls on the same location than the first one */
+    /* we need to delete it                                            */
+    if ( last > first )
+    {
+      FT_Vector*  p1 = outline->points + first;
+      FT_Vector*  p2 = outline->points + last;
+
+
+      if ( p1->x == p2->x && p1->y == p2->y )
+      {
+        outline->n_points--;
+        last--;
+      }
+    }
+
+    /* don't add empty contours */
+    if ( last >= first )
+      outline->contours[outline->n_contours++] = (short)last;
+
+    glyph->path_begun = 0;
+  }
+
+
+  /* reset glyph to start the loading of a new glyph */
+  static void
+  pfr_glyph_start( PFR_Glyph  glyph )
+  {
+    glyph->path_begun = 0;
+  }
+
+
+  static FT_Error
+  pfr_glyph_line_to( PFR_Glyph   glyph,
+                     FT_Vector*  to )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Outline*     outline = &loader->current.outline;
+    FT_Error        error;
+
+
+    /* check that we have begun a new path */
+    FT_ASSERT( glyph->path_begun != 0 );
+
+    error = FT_GlyphLoader_CheckPoints( loader, 1, 0 );
+    if ( !error )
+    {
+      FT_UInt  n = outline->n_points;
+
+
+      outline->points[n] = *to;
+      outline->tags  [n] = FT_Curve_Tag_On;
+
+      outline->n_points++;
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  pfr_glyph_curve_to( PFR_Glyph   glyph,
+                      FT_Vector*  control1,
+                      FT_Vector*  control2,
+                      FT_Vector*  to )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Outline*     outline = &loader->current.outline;
+    FT_Error        error;
+
+
+    /* check that we have begun a new path */
+    FT_ASSERT( glyph->path_begun != 0 );
+
+    error = FT_GlyphLoader_CheckPoints( loader, 3, 0 );
+    if ( !error )
+    {
+      FT_Vector*  vec = outline->points         + outline->n_points;
+      FT_Byte*    tag = (FT_Byte*)outline->tags + outline->n_points;
+
+
+      vec[0] = *control1;
+      vec[1] = *control2;
+      vec[2] = *to;
+      tag[0] = FT_Curve_Tag_Cubic;
+      tag[1] = FT_Curve_Tag_Cubic;
+      tag[2] = FT_Curve_Tag_On;
+
+      outline->n_points = (FT_Short)( outline->n_points + 3 );
+    }
+
+    return error;
+  }
+
+
+  static FT_Error
+  pfr_glyph_move_to( PFR_Glyph   glyph,
+                     FT_Vector*  to )
+  {
+    FT_GlyphLoader  loader  = glyph->loader;
+    FT_Error        error;
+
+
+    /* close current contour if any */
+    pfr_glyph_close_contour( glyph );
+
+    /* indicate that a new contour has started */
+    glyph->path_begun = 1;
+
+    /* check that there is room for a new contour and a new point */
+    error = FT_GlyphLoader_CheckPoints( loader, 1, 1 );
+    if ( !error )
+      /* add new start point */
+      error = pfr_glyph_line_to( glyph, to );
+
+    return error;
+  }
+
+
+  static void
+  pfr_glyph_end( PFR_Glyph  glyph )
+  {
+    /* close current contour if any */
+    pfr_glyph_close_contour( glyph );
+
+    /* merge the current glyph into the stack */
+    FT_GlyphLoader_Add( glyph->loader );
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      PFR GLYPH LOADER                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* load a simple glyph */
+  static FT_Error
+  pfr_glyph_load_simple( PFR_Glyph  glyph,
+                         FT_Byte*   p,
+                         FT_Byte*   limit )
+  {
+    FT_Error   error  = 0;
+    FT_Memory  memory = glyph->loader->memory;
+    FT_UInt    flags, x_count, y_count, i, count, mask;
+    FT_Int     x;
+
+
+    PFR_CHECK( 1 );
+    flags = PFR_NEXT_BYTE( p );
+
+    /* test for composite glyphs */
+    FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) == 0 );
+
+    x_count = 0;
+    y_count = 0;
+
+    if ( flags & PFR_GLYPH_1BYTE_XYCOUNT )
+    {
+      PFR_CHECK( 1 );
+      count   = PFR_NEXT_BYTE( p );
+      x_count = ( count & 15 );
+      y_count = ( count >> 4 );
+    }
+    else
+    {
+      if ( flags & PFR_GLYPH_XCOUNT )
+      {
+        PFR_CHECK( 1 );
+        x_count = PFR_NEXT_BYTE( p );
+      }
+
+      if ( flags & PFR_GLYPH_YCOUNT )
+      {
+        PFR_CHECK( 1 );
+        y_count = PFR_NEXT_BYTE( p );
+      }
+    }
+
+    count = x_count + y_count;
+
+    /* re-allocate array when necessary */
+    if ( count > glyph->max_xy_control )
+    {
+      FT_UInt  new_max = ( count + 7 ) & -8;
+
+
+      if ( FT_RENEW_ARRAY( glyph->x_control,
+                           glyph->max_xy_control,
+                           new_max ) )
+        goto Exit;
+
+      glyph->max_xy_control = new_max;
+    }
+
+    glyph->y_control = glyph->x_control + x_count;
+
+    mask  = 0;
+    x     = 0;
+
+    for ( i = 0; i < count; i++ )
+    {
+      if ( ( i & 7 ) == 0 )
+      {
+        PFR_CHECK( 1 );
+        mask = PFR_NEXT_BYTE( p );
+      }
+      
+      if ( mask & 1 )
+      {
+        PFR_CHECK( 2 );
+        x = PFR_NEXT_SHORT( p );
+      }
+      else
+      {
+        PFR_CHECK( 1 );
+        x += PFR_NEXT_BYTE( p );
+      }
+      
+      glyph->x_control[i] = x;
+
+      mask >>= 1;
+    }
+
+    /* XXX: for now we ignore the secondary stroke and edge definitions */
+    /*      since we don't want to support native PFR hinting           */
+    /*                                                                  */
+    if ( flags & PFR_GLYPH_EXTRA_ITEMS )
+    {
+      error = pfr_extra_items_skip( &p, limit );
+      if ( error )
+        goto Exit;
+    }
+
+    pfr_glyph_start( glyph );
+
+    /* now load a simple glyph */
+    {
+      FT_Vector   pos[4];
+      FT_Vector*  cur;
+
+
+      pos[0].x = pos[0].y = 0;
+      pos[3]   = pos[0];
+
+      for (;;)
+      {
+        FT_Int  format, args_format = 0, args_count, n;
+
+
+        /***************************************************************/
+        /*  read instruction                                           */
+        /*                                                             */
+        PFR_CHECK( 1 );
+        format = PFR_NEXT_BYTE( p );
+
+        switch ( format >> 4 )
+        {
+        case 0:                             /* end glyph */
+          FT_TRACE6(( "- end glyph" ));
+          args_count = 0;
+          break;
+
+        case 1:                             /* general line operation */
+          FT_TRACE6(( "- general line" ));
+          goto Line1;
+
+        case 4:                             /* move to inside contour  */
+          FT_TRACE6(( "- move to inside" ));
+          goto Line1;
+
+        case 5:                             /* move to outside contour */
+          FT_TRACE6(( "- move to outside" ));
+        Line1:
+          args_format = format & 15;
+          args_count  = 1;
+          break;
+
+        case 2:                             /* horizontal line to */
+          FT_TRACE6(( "- horizontal line to cx.%d", format & 15 ));
+          pos[0].y   = pos[3].y;
+          pos[0].x   = glyph->x_control[format & 15];
+          pos[3]     = pos[0];
+          args_count = 0;
+          break;
+
+        case 3:                             /* vertical line to */
+          FT_TRACE6(( "- vertical line to cy.%d", format & 15 ));
+          pos[0].x   = pos[3].x;
+          pos[0].y   = glyph->y_control[format & 15];
+          pos[3] = pos[0];
+          args_count = 0;
+          break;
+
+        case 6:                             /* horizontal to vertical curve */
+          FT_TRACE6(( "- hv curve " ));
+          args_format  = 0xB8E;
+          args_count   = 3;
+          break;
+
+        case 7:                             /* vertical to horizontal curve */
+          FT_TRACE6(( "- vh curve" ));
+          args_format = 0xE2B;
+          args_count  = 3;
+          break;
+
+        default:                            /* general curve to */
+          FT_TRACE6(( "- general curve" ));
+          args_count  = 4;
+          args_format = format & 15;
+        }
+
+        /***********************************************************/
+        /*  now read arguments                                     */
+        /*                                                         */
+        cur = pos;
+        for ( n = 0; n < args_count; n++ )
+        {
+          FT_Int  index, delta;
+
+
+          /* read the X argument */
+          switch ( args_format & 3 )
+          {
+          case 0:                           /* 8-bit index */
+            PFR_CHECK( 1 );
+            index  = PFR_NEXT_BYTE( p );
+            cur->x = glyph->x_control[index];
+            FT_TRACE7(( " cx#%d", index ));
+            break;
+
+          case 1:                           /* 16-bit value */
+            PFR_CHECK( 2 );
+            cur->x = PFR_NEXT_SHORT( p );
+            FT_TRACE7(( " x.%d", cur->x ));
+            break;
+
+          case 2:                           /* 8-bit delta */
+            PFR_CHECK( 1 );
+            delta  = PFR_NEXT_INT8( p );
+            cur->x = pos[3].x + delta;
+            FT_TRACE7(( " dx.%d", delta ));
+            break;
+
+          default:
+            FT_TRACE7(( " |" ));
+            cur->x = pos[3].x;
+          }
+
+          /* read the Y argument */
+          switch ( ( args_format >> 2 ) & 3 )
+          {
+          case 0:                           /* 8-bit index */
+            PFR_CHECK( 1 );
+            index  = PFR_NEXT_BYTE( p );
+            cur->y = glyph->y_control[index];
+            FT_TRACE7(( " cy#%d", index ));
+            break;
+
+          case 1:                           /* 16-bit absolute value */
+            PFR_CHECK( 2 );
+            cur->y = PFR_NEXT_SHORT( p );
+            FT_TRACE7(( " y.%d", cur->y ));
+            break;
+
+          case 2:                           /* 8-bit delta */
+            PFR_CHECK( 1 );
+            delta  = PFR_NEXT_INT8( p );
+            cur->y = pos[3].y + delta;
+            FT_TRACE7(( " dy.%d", delta ));
+            break;
+
+          default:
+            FT_TRACE7(( " -" ));
+            cur->y = pos[3].y;
+          }
+
+          /* read the additional format flag for the general curve */
+          if ( n == 0 && args_count == 4 )
+          {
+            PFR_CHECK( 1 );
+            args_format = PFR_NEXT_BYTE( p );
+            args_count--;
+          }
+          else
+            args_format >>= 4;
+
+          /* save the previous point */
+          pos[3] = cur[0];
+          cur++;
+        }
+
+        FT_TRACE7(( "\n" ));
+
+        /***********************************************************/
+        /*  finally, execute instruction                           */
+        /*                                                         */
+        switch ( format >> 4 )
+        {
+        case 0:                             /* end glyph => EXIT */
+          pfr_glyph_end( glyph );
+          goto Exit;
+
+        case 1:                             /* line operations */
+        case 2:
+        case 3:
+          error = pfr_glyph_line_to( glyph, pos );
+          goto Test_Error;
+
+        case 4:                             /* move to inside contour  */
+        case 5:                             /* move to outside contour */
+          error = pfr_glyph_move_to( glyph, pos );
+          goto Test_Error;
+
+        default:                            /* curve operations */
+          error = pfr_glyph_curve_to( glyph, pos, pos + 1, pos + 2 );
+
+        Test_Error:  /* test error condition */
+          if ( error )
+            goto Exit;
+        }
+      } /* for (;;) */
+    }
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_glyph_load_simple: invalid glyph data\n" ));
+    goto Exit;
+  }
+
+
+  /* load a composite/compound glyph */
+  static FT_Error
+  pfr_glyph_load_compound( PFR_Glyph  glyph,
+                           FT_Byte*   p,
+                           FT_Byte*   limit )
+  {
+    FT_Error        error  = 0;
+    FT_GlyphLoader  loader = glyph->loader;
+    FT_Memory       memory = loader->memory;
+    PFR_SubGlyph    subglyph;
+    FT_UInt         flags, i, count, org_count;
+    FT_Int          x_pos, y_pos;
+
+
+    PFR_CHECK( 1 );
+    flags = PFR_NEXT_BYTE( p );
+
+    /* test for composite glyphs */
+    FT_ASSERT( ( flags & PFR_GLYPH_IS_COMPOUND ) != 0 );
+
+    count = flags & 0x3F;
+
+    /* ignore extra items when present */
+    /*                                 */
+    if ( flags & PFR_GLYPH_EXTRA_ITEMS )
+    {
+      error = pfr_extra_items_skip( &p, limit );
+      if (error) goto Exit;
+    }
+
+    /* we can't rely on the FT_GlyphLoader to load sub-glyphs, because   */
+    /* the PFR format is dumb, using direct file offsets to point to the */
+    /* sub-glyphs (instead of glyph indices).  Sigh.                     */
+    /*                                                                   */
+    /* For now, we load the list of sub-glyphs into a different array    */
+    /* but this will prevent us from using the auto-hinter at its best   */
+    /* quality.                                                          */
+    /*                                                                   */
+    org_count = glyph->num_subs;
+
+    if ( org_count + count > glyph->max_subs )
+    {
+      FT_UInt  new_max = ( org_count + count + 3 ) & -4;
+
+
+      if ( FT_RENEW_ARRAY( glyph->subs, glyph->max_subs, new_max ) )
+        goto Exit;
+
+      glyph->max_subs = new_max;
+    }
+
+    subglyph = glyph->subs + org_count;
+    x_pos    = 0;
+    y_pos    = 0;
+
+    for ( i = 0; i < count; i++, subglyph++ )
+    {
+      FT_UInt  format;
+
+
+      PFR_CHECK( 1 );
+      format = PFR_NEXT_BYTE( p );
+
+      /* read scale when available */
+      subglyph->x_scale = 0x10000L;
+      if ( format & PFR_SUBGLYPH_XSCALE )
+      {
+        PFR_CHECK( 2 );
+        subglyph->x_scale = PFR_NEXT_SHORT( p ) << 4;
+      }
+
+      subglyph->y_scale = 0x10000L;
+      if ( format & PFR_SUBGLYPH_YSCALE )
+      {
+        PFR_CHECK( 2 );
+        subglyph->y_scale = PFR_NEXT_SHORT( p ) << 4;
+      }
+
+      /* read offset */
+      switch ( format & 3 )
+      {
+      case 1:
+        PFR_CHECK( 2 );
+        x_pos = PFR_NEXT_SHORT( p );
+        break;
+
+      case 2:
+        PFR_CHECK( 1 );
+        x_pos += PFR_NEXT_INT8( p );
+        break;
+
+      default:
+        ;
+      }
+
+      switch ( ( format >> 2 ) & 3 )
+      {
+      case 1:
+        PFR_CHECK( 2 );
+        y_pos = PFR_NEXT_SHORT( p );
+        break;
+
+      case 2:
+        PFR_CHECK( 1 );
+        y_pos += PFR_NEXT_INT8( p );
+        break;
+
+      default:
+        ;
+      }
+      
+      subglyph->x_delta = x_pos;
+      subglyph->y_delta = y_pos;
+
+      /* read glyph position and size now */
+      if ( format & PFR_SUBGLYPH_2BYTE_SIZE )
+      {
+        PFR_CHECK( 2 );
+        subglyph->gps_size = PFR_NEXT_USHORT( p );
+      }
+      else
+      {
+        PFR_CHECK( 1 );
+        subglyph->gps_size = PFR_NEXT_BYTE( p );
+      }
+
+      if ( format & PFR_SUBGLYPH_3BYTE_OFFSET )
+      {
+        PFR_CHECK( 3 );
+        subglyph->gps_offset = PFR_NEXT_LONG( p );
+      }
+      else
+      {
+        PFR_CHECK( 2 );
+        subglyph->gps_offset = PFR_NEXT_USHORT( p );
+      }
+
+      glyph->num_subs++;
+    }
+
+  Exit:
+    return error;
+
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_glyph_load_compound: invalid glyph data\n" ));
+    goto Exit;
+  }
+
+
+  static FT_Error
+  pfr_glyph_load_rec( PFR_Glyph  glyph,
+                      FT_Stream  stream,
+                      FT_ULong   gps_offset,
+                      FT_ULong   offset,
+                      FT_ULong   size )
+  {
+    FT_Error  error;
+    FT_Byte*  p;
+    FT_Byte*  limit;
+
+
+    if ( FT_STREAM_SEEK( gps_offset + offset ) ||
+         FT_FRAME_ENTER( size )                )
+      goto Exit;
+
+    p     = (FT_Byte*)stream->cursor;
+    limit = p + size;
+
+    if ( size > 0 && *p & PFR_GLYPH_IS_COMPOUND )
+    {
+      FT_Int          n, old_count, count;
+      FT_GlyphLoader  loader = glyph->loader;
+      FT_Outline*     base   = &loader->base.outline;
+
+
+      old_count = glyph->num_subs;
+
+      /* this is a compound glyph - load it */
+      error = pfr_glyph_load_compound( glyph, p, limit );
+
+      FT_FRAME_EXIT();
+
+      if ( error )
+        goto Exit;
+
+      count = glyph->num_subs - old_count;
+
+      /* now, load each individual glyph */
+      for ( n = 0; n < count; n++ )
+      {
+        FT_Int        i, old_points, num_points;
+        PFR_SubGlyph  subglyph;
+
+
+        subglyph   = glyph->subs + old_count + n;
+        old_points = base->n_points;
+
+        error = pfr_glyph_load_rec( glyph, stream, gps_offset,
+                                    subglyph->gps_offset,
+                                    subglyph->gps_size );
+        if ( error )
+          goto Exit;
+
+        /* note that `glyph->subs' might have been re-allocated */
+        subglyph   = glyph->subs + old_count + n;
+        num_points = base->n_points - old_points;
+
+        /* translate and eventually scale the new glyph points */
+        if ( subglyph->x_scale != 0x10000L || subglyph->y_scale != 0x10000L )
+        {
+          FT_Vector*  vec = base->points + old_points;
+
+
+          for ( i = 0; i < num_points; i++, vec++ )
+          {
+            vec->x = FT_MulFix( vec->x, subglyph->x_scale ) +
+                       subglyph->x_delta;
+            vec->y = FT_MulFix( vec->y, subglyph->y_scale ) +
+                       subglyph->y_delta;
+          }
+        }
+        else
+        {
+          FT_Vector*  vec = loader->base.outline.points + old_points;
+
+
+          for ( i = 0; i < num_points; i++, vec++ )
+          {
+            vec->x += subglyph->x_delta;
+            vec->y += subglyph->y_delta;
+          }
+        }
+
+        /* proceed to next sub-glyph */
+      }
+    }
+    else
+    {
+      /* load a simple glyph */
+      error = pfr_glyph_load_simple( glyph, p, limit );
+
+      FT_FRAME_EXIT();
+    }
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_glyph_load( PFR_Glyph  glyph,
+                  FT_Stream  stream,
+                  FT_ULong   gps_offset,
+                  FT_ULong   offset,
+                  FT_ULong   size )
+  {
+    /* initialize glyph loader */
+    FT_GlyphLoader_Rewind( glyph->loader );
+
+    /* load the glyph, recursively when needed */
+    return pfr_glyph_load_rec( glyph, stream, gps_offset, offset, size );
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrgload.h
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrgload.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:47 2003
+++ xc/extras/freetype2/src/pfr/pfrgload.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,46 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrgload.h                                                             */
+/*                                                                         */
+/*    FreeType PFR glyph loader (specification).                           */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PFRGLOAD_H__
+#define __PFRGLOAD_H__
+
+#include "pfrtypes.h"
+
+FT_BEGIN_HEADER
+
+
+  FT_LOCAL( void )
+  pfr_glyph_init( PFR_Glyph       glyph,
+                  FT_GlyphLoader  loader );
+
+  FT_LOCAL( void )
+  pfr_glyph_done( PFR_Glyph  glyph );
+
+
+  FT_LOCAL( FT_Error )
+  pfr_glyph_load( PFR_Glyph  glyph,
+                  FT_Stream  stream,
+                  FT_ULong   gps_offset,
+                  FT_ULong   offset,
+                  FT_ULong   size );
+
+
+FT_END_HEADER
+
+
+#endif /* __PFRGLOAD_H__ */
Index: xc/extras/freetype2/src/pfr/pfrload.c
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrload.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/pfr/pfrload.c	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,692 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrload.c                                                              */
+/*                                                                         */
+/*    FreeType PFR loader (body).                                          */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "pfrload.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+
+#include "pfrerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pfr
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          EXTRA ITEMS                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_extra_items_skip( FT_Byte*  *pp,
+                        FT_Byte*   limit )
+  {
+    return pfr_extra_items_parse( pp, limit, NULL, NULL );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_extra_items_parse( FT_Byte*       *pp,
+                         FT_Byte*        limit,
+                         PFR_ExtraItem   item_list,
+                         FT_Pointer      item_data )
+  {
+    FT_Error  error = 0;
+    FT_Byte*  p     = *pp;
+    FT_UInt   num_items, item_type, item_size;
+    
+
+    PFR_CHECK( 1 );
+    num_items = PFR_NEXT_BYTE( p );
+
+    for ( ; num_items > 0; num_items-- )
+    {
+      PFR_CHECK( 2 );
+      item_size = PFR_NEXT_BYTE( p );
+      item_type = PFR_NEXT_BYTE( p );
+      
+      PFR_CHECK( item_size );
+
+      if ( item_list )
+      {      
+        PFR_ExtraItem  extra = item_list;
+        
+
+        for ( extra = item_list; extra->parser != NULL; extra++ )
+        {
+          if ( extra->type == item_type )
+          {
+            error = extra->parser( p, p + item_size, item_data );
+            if ( error ) goto Exit;
+            
+            break;
+          }
+        }
+      }
+      
+      p += item_size;
+    }
+
+  Exit:
+    *pp = p;
+    return error;
+    
+  Too_Short:
+    FT_ERROR(( "pfr_extra_items_parse: invalid extra items table\n" ));
+    error = PFR_Err_Invalid_Table;
+    goto Exit;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          PFR HEADER                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+   static const FT_Frame_Field  pfr_header_fields[] =
+   {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  PFR_HeaderRec
+
+     FT_FRAME_START( 58 ),
+       FT_FRAME_ULONG ( signature ),
+       FT_FRAME_USHORT( version ),
+       FT_FRAME_USHORT( signature2 ),
+       FT_FRAME_USHORT( header_size ),
+
+       FT_FRAME_USHORT( log_dir_size ),
+       FT_FRAME_USHORT( log_dir_offset ),
+
+       FT_FRAME_USHORT( log_font_max_size ),
+       FT_FRAME_UOFF3 ( log_font_section_size ),
+       FT_FRAME_UOFF3 ( log_font_section_offset ),
+
+       FT_FRAME_USHORT( phy_font_max_size ),
+       FT_FRAME_UOFF3 ( phy_font_section_size ),
+       FT_FRAME_UOFF3 ( phy_font_section_offset ),
+
+       FT_FRAME_USHORT( gps_max_size ),
+       FT_FRAME_UOFF3 ( gps_section_size ),
+       FT_FRAME_UOFF3 ( gps_section_offset ),
+
+       FT_FRAME_BYTE  ( max_blue_values ),
+       FT_FRAME_BYTE  ( max_x_orus ),
+       FT_FRAME_BYTE  ( max_y_orus ),
+
+       FT_FRAME_BYTE  ( phy_font_max_size_high ),
+       FT_FRAME_BYTE  ( color_flags ),
+
+       FT_FRAME_UOFF3 ( bct_max_size ),
+       FT_FRAME_UOFF3 ( bct_set_max_size ),
+       FT_FRAME_UOFF3 ( phy_bct_set_max_size ),
+
+       FT_FRAME_USHORT( num_phy_fonts ),
+       FT_FRAME_BYTE  ( max_vert_stem_snap ),
+       FT_FRAME_BYTE  ( max_horz_stem_snap ),
+       FT_FRAME_USHORT( max_chars ),
+     FT_FRAME_END
+   };
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_header_load( PFR_Header  header,
+                   FT_Stream   stream )
+  {
+    FT_Error   error;
+
+
+    /* read header directly */
+    if ( !FT_STREAM_SEEK( 0 )                                &&
+         !FT_STREAM_READ_FIELDS( pfr_header_fields, header ) )
+    {
+      /* make a few adjustments to the header */
+      header->phy_font_max_size +=
+        (FT_UInt32)header->phy_font_max_size_high << 16;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Bool )
+  pfr_header_check( PFR_Header  header )
+  {
+    FT_Bool  result = 1;
+
+
+    /* check signature and header size */
+    if ( header->signature  != 0x50465230L ||   /* "PFR0" */
+         header->version     > 4           ||
+         header->header_size < 58          ||
+         header->signature2 != 0x0d0a      )    /* CR/LF  */
+    {
+      result = 0;
+    }
+    return  result;
+  }
+
+
+  /***********************************************************************/
+  /***********************************************************************/
+  /*****                                                             *****/
+  /*****                    PFR LOGICAL FONTS                        *****/
+  /*****                                                             *****/
+  /***********************************************************************/
+  /***********************************************************************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_log_font_count( FT_Stream  stream,
+                      FT_UInt32  section_offset,
+                      FT_UInt   *acount )
+  {
+    FT_Error   error;
+    FT_UInt    count;
+    FT_UInt    result = 0;
+    
+
+    if ( FT_STREAM_SEEK( section_offset ) || FT_READ_USHORT( count ) )
+      goto Exit;
+    
+    result = count;
+    
+  Exit:
+    *acount = result;
+    return error;
+  }                      
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_log_font_load( PFR_LogFont  log_font,
+                     FT_Stream    stream,
+                     FT_UInt      index,
+                     FT_UInt32    section_offset,
+                     FT_Bool      size_increment )
+  {
+    FT_UInt    num_log_fonts;
+    FT_UInt    flags;
+    FT_UInt32  offset;
+    FT_UInt32  size;
+    FT_Error   error;
+
+
+    if ( FT_STREAM_SEEK( section_offset ) ||
+         FT_READ_USHORT( num_log_fonts )  )
+      goto Exit;
+
+    if ( index >= num_log_fonts )
+      return PFR_Err_Invalid_Argument;
+
+    if ( FT_STREAM_SKIP( index * 5 ) ||
+         FT_READ_USHORT( size )      ||
+         FT_READ_UOFF3 ( offset )    )
+      goto Exit;
+
+    /* save logical font size and offset */
+    log_font->size   = size;
+    log_font->offset = offset;
+
+    /* now, check the rest of the table before loading it */
+    {
+      FT_Byte*  p;
+      FT_Byte*  limit;
+      FT_UInt   local;
+      
+
+      if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
+        goto Exit;
+
+      p     = stream->cursor;
+      limit = p + size;
+      
+      PFR_CHECK(13);
+      
+      log_font->matrix[0] = PFR_NEXT_LONG( p );
+      log_font->matrix[1] = PFR_NEXT_LONG( p );
+      log_font->matrix[2] = PFR_NEXT_LONG( p );
+      log_font->matrix[3] = PFR_NEXT_LONG( p );
+      
+      flags = PFR_NEXT_BYTE( p );
+      
+      local = 0;
+      if ( flags & PFR_LOG_STROKE )
+      {
+        local++;
+        if ( flags & PFR_LOG_2BYTE_STROKE )
+          local++;
+          
+        if ( (flags & PFR_LINE_JOIN_MASK) == PFR_LINE_JOIN_MITER )
+          local += 3;
+      }
+      if ( flags & PFR_LOG_BOLD )
+      {
+        local++;
+        if ( flags & PFR_LOG_2BYTE_BOLD )
+          local++;
+      }
+
+      PFR_CHECK( local );
+
+      if ( flags & PFR_LOG_STROKE )
+      {
+        log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE )
+                                     ? PFR_NEXT_SHORT( p )
+                                     : PFR_NEXT_BYTE( p );
+  
+        if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )
+          log_font->miter_limit = PFR_NEXT_LONG( p );
+      }
+  
+      if ( flags & PFR_LOG_BOLD )
+      {
+        log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD )
+                                   ? PFR_NEXT_SHORT( p )
+                                   : PFR_NEXT_BYTE( p );
+      }
+  
+      if ( flags & PFR_LOG_EXTRA_ITEMS )
+      {
+        error = pfr_extra_items_skip( &p, limit );
+        if (error) goto Fail;
+      }
+
+      PFR_CHECK(5);
+      log_font->phys_size   = PFR_NEXT_USHORT( p );
+      log_font->phys_offset = PFR_NEXT_ULONG( p );
+      if ( size_increment )
+      {
+        PFR_CHECK( 1 );
+        log_font->phys_size += (FT_UInt32)PFR_NEXT_BYTE( p ) << 16;
+      }
+    }
+
+  Fail:
+    FT_FRAME_EXIT();
+
+  Exit:
+    return error;
+  
+  Too_Short:
+    FT_ERROR(( "pfr_log_font_load: invalid logical font table\n" ));
+    error = PFR_Err_Invalid_Table;
+    goto Fail;
+  }
+
+
+  /***********************************************************************/
+  /***********************************************************************/
+  /*****                                                             *****/
+  /*****                    PFR PHYSICAL FONTS                       *****/
+  /*****                                                             *****/
+  /***********************************************************************/
+  /***********************************************************************/
+
+
+  /* load bitmap strikes lists */
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_extra_item_load_bitmap_info( FT_Byte*     p,
+                                   FT_Byte*     limit,
+                                   PFR_PhyFont  phy_font )
+  {
+    FT_Memory   memory = phy_font->memory;
+    PFR_Strike  strike;
+    FT_UInt     flags0;
+    FT_UInt     n, count, size1;
+    FT_Error    error = 0;
+
+ 
+    PFR_CHECK( 5 );
+
+    p += 3;  /* skip bctSize */
+    flags0 = PFR_NEXT_BYTE( p );
+    count  = PFR_NEXT_BYTE( p );
+
+    /* re-allocate when needed */
+    if ( phy_font->num_strikes + count > phy_font->max_strikes )
+    {
+      FT_UInt  new_max = (phy_font->num_strikes + count + 3) & -4;
+      
+      if ( FT_RENEW_ARRAY( phy_font->strikes,
+                           phy_font->num_strikes,
+                           new_max ) )
+        goto Exit;
+        
+      phy_font->max_strikes = new_max;
+    }
+
+    size1 = 1 + 1 + 1 + 2 + 2 + 1;
+    if ( flags0 & PFR_STRIKE_2BYTE_XPPM )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_2BYTE_YPPM )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_3BYTE_SIZE )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
+      size1++;
+
+    if ( flags0 & PFR_STRIKE_2BYTE_COUNT )
+      size1++;
+
+    strike = phy_font->strikes + phy_font->num_strikes;
+
+    PFR_CHECK( count * size1 );
+
+    for ( n = 0; n < count; n++, strike++ )
+    {
+      strike->x_ppm       = ( flags0 & PFR_STRIKE_2BYTE_XPPM )
+                            ? PFR_NEXT_USHORT( p )
+                            : PFR_NEXT_BYTE( p );
+
+      strike->y_ppm       = ( flags0 & PFR_STRIKE_2BYTE_YPPM )
+                            ? PFR_NEXT_USHORT( p )
+                            : PFR_NEXT_BYTE( p );
+
+      strike->flags       = PFR_NEXT_BYTE( p );
+
+      strike->bct_size    = ( flags0 & PFR_STRIKE_3BYTE_SIZE )
+                            ? PFR_NEXT_ULONG( p )
+                            : PFR_NEXT_USHORT( p );
+
+      strike->bct_offset  = ( flags0 & PFR_STRIKE_3BYTE_OFFSET )
+                            ? PFR_NEXT_ULONG( p )
+                            : PFR_NEXT_USHORT( p );
+
+      strike->num_bitmaps = ( flags0 & PFR_STRIKE_2BYTE_COUNT )
+                            ? PFR_NEXT_USHORT( p )
+                            : PFR_NEXT_BYTE( p );
+    }
+
+    phy_font->num_strikes += count;
+    
+  Exit:
+    return error;
+    
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_extra_item_load_bitmap_info: invalid bitmap info table\n" ));
+    goto Exit;
+  }                                  
+
+
+  /* load font ID, i.e. name */
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_extra_item_load_font_id( FT_Byte*     p,
+                               FT_Byte*     limit,
+                               PFR_PhyFont  phy_font )
+  {
+    FT_Error   error  = 0;
+    FT_Memory  memory = phy_font->memory;
+    FT_UInt    len    = (FT_UInt)( limit - p );
+    
+
+    if ( phy_font->font_id != NULL )
+      goto Exit;
+    
+    if ( FT_ALLOC( phy_font->font_id, len+1 ) )
+      goto Exit;
+
+    /* copy font ID name, and terminate it for safety */
+    FT_MEM_COPY( phy_font->font_id, p, len );
+    phy_font->font_id[len] = 0;
+    
+  Exit:
+    return error;
+  }
+
+
+  /* load stem snap tables */
+  FT_CALLBACK_DEF( FT_Error )
+  pfr_extra_item_load_stem_snaps( FT_Byte*     p,
+                                  FT_Byte*     limit,
+                                  PFR_PhyFont  phy_font )
+  {
+    FT_UInt    count, num_vert, num_horz;
+    FT_Int*    snaps;
+    FT_Error   error  = 0;
+    FT_Memory  memory = phy_font->memory;
+
+
+    if ( phy_font->vertical.stem_snaps != NULL )
+      goto Exit;
+    
+    PFR_CHECK( 1 );
+    count = PFR_NEXT_BYTE( p );
+    
+    num_vert = count & 15;
+    num_horz = count >> 4;
+    count    = num_vert + num_horz;
+    
+    PFR_CHECK( count * 2 );
+    
+    if ( FT_NEW_ARRAY( snaps, count ) )
+      goto Exit;
+    
+    phy_font->vertical.stem_snaps = snaps;
+    phy_font->horizontal.stem_snaps = snaps + num_vert;
+    
+    for ( ; count > 0; count--, snaps++ )
+      *snaps = FT_NEXT_SHORT( p );
+    
+  Exit:
+    return error;
+  
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_exta_item_load_stem_snaps: invalid stem snaps table\n" ));
+    goto Exit;
+  }                                 
+
+
+  static const PFR_ExtraItemRec  pfr_phy_font_extra_items[] =
+  {
+    { 1, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_bitmap_info },
+    { 2, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_font_id },
+    { 3, (PFR_ExtraItem_ParseFunc) pfr_extra_item_load_stem_snaps },
+    { 0, NULL }
+  };
+
+
+  FT_LOCAL_DEF( void )
+  pfr_phy_font_done( PFR_PhyFont  phy_font,
+                     FT_Memory    memory )
+  {
+    if ( phy_font->font_id )
+      FT_FREE( phy_font->font_id );
+
+    FT_FREE( phy_font->vertical.stem_snaps );
+    phy_font->vertical.num_stem_snaps = 0;
+
+    phy_font->horizontal.stem_snaps     = NULL;
+    phy_font->horizontal.num_stem_snaps = 0;
+
+    FT_FREE( phy_font->strikes );
+    phy_font->num_strikes = 0;
+    phy_font->max_strikes = 0;
+  
+    FT_FREE( phy_font->chars );
+    phy_font->num_chars    = 0;
+    phy_font->chars_offset = 0;
+
+    FT_FREE( phy_font->blue_values );
+    phy_font->num_blue_values = 0;
+  }
+  
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_phy_font_load( PFR_PhyFont  phy_font,
+                     FT_Stream    stream,
+                     FT_UInt32    offset,
+                     FT_UInt32    size )
+  {
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
+    FT_UInt    flags, num_aux;
+    FT_Byte*   p;
+    FT_Byte*   limit;
+
+
+    phy_font->memory = memory;
+    phy_font->offset = offset;
+
+    if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( size ) )
+      goto Exit;
+
+    p     = stream->cursor;
+    limit = p + size;
+
+    PFR_CHECK( 15 );
+    phy_font->font_ref_number    = PFR_NEXT_USHORT( p );
+    phy_font->outline_resolution = PFR_NEXT_USHORT( p );
+    phy_font->metrics_resolution = PFR_NEXT_USHORT( p );
+    phy_font->bbox.xMin          = PFR_NEXT_SHORT( p );
+    phy_font->bbox.yMin          = PFR_NEXT_SHORT( p );
+    phy_font->bbox.xMax          = PFR_NEXT_SHORT( p );
+    phy_font->bbox.yMax          = PFR_NEXT_SHORT( p );
+    phy_font->flags      = flags = PFR_NEXT_BYTE( p );
+
+    /* get the standard advance for non-proprotional fonts */
+    if ( !(flags & PFR_PHY_PROPORTIONAL) )
+    {
+      PFR_CHECK( 2 );
+      phy_font->standard_advance = PFR_NEXT_SHORT( p );
+    }
+
+    /* load the extra items when present */
+    if ( flags & PFR_PHY_EXTRA_ITEMS )
+    {
+      error =  pfr_extra_items_parse( &p, limit,
+                                      pfr_phy_font_extra_items, phy_font );
+        
+      if ( error )
+        goto Fail;
+    }
+    
+    /* skip the aux bytes */
+    PFR_CHECK( 3 );
+    num_aux = PFR_NEXT_ULONG( p );
+    
+    PFR_CHECK( num_aux );
+    p += num_aux;
+
+    /* read the blue values */
+    {
+      FT_UInt  n, count;
+
+      PFR_CHECK( 1 );
+      phy_font->num_blue_values = count = PFR_NEXT_BYTE( p );
+
+      PFR_CHECK( count * 2 );
+      
+      if ( FT_NEW_ARRAY( phy_font->blue_values, count ) )
+        goto Fail;
+
+      for ( n = 0; n < count; n++ )
+        phy_font->blue_values[n] = PFR_NEXT_SHORT( p );
+    }
+
+    PFR_CHECK( 8 );
+    phy_font->blue_fuzz  = PFR_NEXT_BYTE( p );
+    phy_font->blue_scale = PFR_NEXT_BYTE( p );
+
+    phy_font->vertical.standard   = PFR_NEXT_USHORT( p );
+    phy_font->horizontal.standard = PFR_NEXT_USHORT( p );
+
+    /* read the character descriptors */
+    {
+      FT_UInt  n, count, Size;
+
+
+      phy_font->num_chars    = count = PFR_NEXT_USHORT( p );
+      phy_font->chars_offset = offset + ( p - stream->cursor );
+
+      if ( FT_NEW_ARRAY( phy_font->chars, count ) )
+        goto Fail;
+
+      Size = 1 + 1 + 2;
+      if ( flags & PFR_PHY_2BYTE_CHARCODE )
+        Size += 1;
+      
+      if ( flags & PFR_PHY_PROPORTIONAL )
+        Size += 2;
+      
+      if ( flags & PFR_PHY_ASCII_CODE )
+        Size += 1;
+        
+      if ( flags & PFR_PHY_2BYTE_GPS_SIZE )
+        Size += 1;
+        
+      if ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
+        Size += 1;
+      
+      PFR_CHECK( count * Size );
+
+      for ( n = 0; n < count; n++ )
+      {
+        PFR_Char  cur = &phy_font->chars[n];
+
+
+        cur->char_code = ( flags & PFR_PHY_2BYTE_CHARCODE )
+                         ? PFR_NEXT_USHORT( p )
+                         : PFR_NEXT_BYTE( p );
+
+        cur->advance   = ( flags & PFR_PHY_PROPORTIONAL )
+                         ? PFR_NEXT_SHORT( p )
+                         : phy_font->standard_advance;
+
+#if 0
+        cur->ascii     = ( flags & PFR_PHY_ASCII_CODE )
+                         ? PFR_NEXT_BYTE( p )
+                         : 0;
+#else
+        if ( flags & PFR_PHY_ASCII_CODE )
+          p += 1;
+#endif
+        cur->gps_size  = ( flags & PFR_PHY_2BYTE_GPS_SIZE )
+                         ? PFR_NEXT_USHORT( p )
+                         : PFR_NEXT_BYTE( p );
+
+        cur->gps_offset = ( flags & PFR_PHY_3BYTE_GPS_OFFSET )
+                          ? PFR_NEXT_ULONG( p )
+                          : PFR_NEXT_USHORT( p );
+      }
+    }
+
+    /* that's it !! */
+  Fail:
+    FT_FRAME_EXIT();
+
+  Exit:
+    return error;
+  
+  Too_Short:
+    error = PFR_Err_Invalid_Table;
+    FT_ERROR(( "pfr_phy_font_load: invalid physical font table\n" ));
+    goto Fail;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrload.h
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrload.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/pfr/pfrload.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,118 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrload.h                                                              */
+/*                                                                         */
+/*    FreeType PFR loader (specification).                                 */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PFRLOAD_H__
+#define __PFRLOAD_H__
+
+#include "pfrobjs.h"
+#include FT_INTERNAL_STREAM_H
+
+
+FT_BEGIN_HEADER
+
+#ifdef PFR_CONFIG_NO_CHECKS
+#define PFR_CHECK( x )  do { } while ( 0 )
+#else
+#define PFR_CHECK( x )  do                       \
+                        {                        \
+                          if ( p + (x) > limit ) \
+                            goto Too_Short;      \
+                        } while ( 0 )
+#endif
+
+#define PFR_NEXT_BYTE( p )    FT_NEXT_BYTE( p )
+#define PFR_NEXT_INT8( p )    FT_NEXT_CHAR( p )
+#define PFR_NEXT_SHORT( p )   FT_NEXT_SHORT( p )
+#define PFR_NEXT_USHORT( p )  FT_NEXT_USHORT( p )
+#define PFR_NEXT_LONG( p )    FT_NEXT_OFF3( p )
+#define PFR_NEXT_ULONG( p )   FT_NEXT_UOFF3( p )
+
+
+ /* handling extra items */
+
+  typedef FT_Error
+  (*PFR_ExtraItem_ParseFunc)( FT_Byte*    p,
+                              FT_Byte*    limit,
+                              FT_Pointer  data );
+
+  typedef struct  PFR_ExtraItemRec_
+  {
+    FT_UInt                  type;
+    PFR_ExtraItem_ParseFunc  parser;
+  
+  } PFR_ExtraItemRec;
+  
+  typedef const struct PFR_ExtraItemRec_*  PFR_ExtraItem;
+ 
+
+  FT_LOCAL( FT_Error )
+  pfr_extra_items_skip( FT_Byte*  *pp,
+                        FT_Byte*  limit );
+
+  FT_LOCAL( FT_Error )
+  pfr_extra_items_parse( FT_Byte*      *pp,
+                         FT_Byte*       limit,
+                         PFR_ExtraItem  item_list,
+                         FT_Pointer     item_data );
+
+
+  /* load a PFR header */
+  FT_LOCAL( FT_Error )
+  pfr_header_load( PFR_Header  header,
+                   FT_Stream   stream );
+
+  /* check a PFR header */
+  FT_LOCAL( FT_Bool )
+  pfr_header_check( PFR_Header  header );
+
+
+  /* return number of logical fonts in this file */
+  FT_LOCAL( FT_Error )
+  pfr_log_font_count( FT_Stream   stream,
+                      FT_UInt32   log_section_offset,
+                      FT_UInt    *acount );
+
+  /* load a pfr logical font entry */
+  FT_LOCAL( FT_Error )
+  pfr_log_font_load( PFR_LogFont  log_font,
+                     FT_Stream    stream,
+                     FT_UInt      face_index,
+                     FT_UInt32    section_offset,
+                     FT_Bool      size_increment );
+
+
+  /* load a physical font entry */
+  FT_LOCAL( FT_Error )
+  pfr_phy_font_load( PFR_PhyFont  phy_font,
+                     FT_Stream    stream,
+                     FT_UInt32    offset,
+                     FT_UInt32    size );
+
+  /* finalize a physical font */
+  FT_LOCAL( void )
+  pfr_phy_font_done( PFR_PhyFont  phy_font,
+                     FT_Memory    memory );
+
+  /* */
+ 
+FT_END_HEADER
+
+#endif /* __PFRLOAD_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrobjs.c
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrobjs.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/pfr/pfrobjs.c	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,314 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrobjs.c                                                              */
+/*                                                                         */
+/*    FreeType PFR object methods (body).                                  */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "pfrobjs.h"
+#include "pfrload.h"
+#include "pfrgload.h"
+#include "pfrcmap.h"
+#include FT_OUTLINE_H
+#include FT_INTERNAL_DEBUG_H
+
+#include "pfrerror.h"
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_pfr
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                     FACE OBJECT METHODS                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  pfr_face_done( PFR_Face  face )
+  {
+    /* finalize the physical font record */
+    pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) );
+
+    /* no need to finalize the logical font or the header */
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_face_init( FT_Stream  stream,
+                 PFR_Face   face,
+                 FT_Int     face_index )
+  {
+    FT_Error  error;
+
+
+    /* load the header and check it */
+    error = pfr_header_load( &face->header, stream );
+    if ( error )
+      goto Exit;
+
+    if ( !pfr_header_check( &face->header ) )
+    {
+      FT_TRACE4(( "pfr_face_init: not a valid PFR font\n" ));
+      error = PFR_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* check face index */
+    {
+      FT_UInt  num_faces;
+
+
+      error = pfr_log_font_count( stream,
+                                  face->header.log_dir_offset,
+                                  &num_faces );
+      if ( error )
+        goto Exit;
+
+      face->root.num_faces = num_faces;
+    }
+
+    if ( face_index < 0 )
+      goto Exit;
+
+    if ( face_index >= face->root.num_faces )
+    {
+      FT_ERROR(( "pfr_face_init: invalid face index\n" ));
+      error = PFR_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* load the face */
+    error = pfr_log_font_load(
+               &face->log_font, stream, face_index,
+               face->header.log_dir_offset,
+               FT_BOOL( face->header.phy_font_max_size_high != 0 ) );
+    if ( error )
+      goto Exit;
+
+    /* now load the physical font descriptor */
+     error = pfr_phy_font_load( &face->phy_font, stream,
+                                 face->log_font.phys_offset,
+                                 face->log_font.phys_size );
+     if ( error )
+       goto Exit;
+
+     /* now, set-up all root face fields */
+     {
+       FT_Face      root     = FT_FACE( face );
+       PFR_PhyFont  phy_font = &face->phy_font;
+
+
+       root->face_index = face_index;
+       root->num_glyphs = phy_font->num_chars;
+       root->face_flags = FT_FACE_FLAG_SCALABLE;
+
+       if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 )
+         root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+       if ( phy_font->flags & PFR_PHY_VERTICAL )
+         root->face_flags |= FT_FACE_FLAG_HORIZONTAL;
+       else
+         root->face_flags |= FT_FACE_FLAG_VERTICAL;
+
+       /* XXX: kerning and embedded bitmap support isn't there yet */
+
+       root->family_name = phy_font->font_id;
+       root->style_name  = NULL;  /* no style name in font file */
+
+       root->num_fixed_sizes = 0;
+       root->available_sizes = 0;
+
+       root->bbox         = phy_font->bbox;
+       root->units_per_EM = (FT_UShort)phy_font->outline_resolution;
+       root->ascender     = (FT_Short) phy_font->bbox.yMax;
+       root->descender    = (FT_Short) phy_font->bbox.yMin;
+       root->height       = (FT_Short)
+                              ( ( ( root->ascender - root->descender ) * 12 )
+                                / 10 );
+
+       /* now compute maximum advance width */
+       if ( ( phy_font->flags & PFR_PHY_PROPORTIONAL ) == 0 )
+         root->max_advance_width = (FT_Short)phy_font->standard_advance;
+       else
+       {
+         FT_Int    max = 0;
+         FT_UInt   count = phy_font->num_chars;
+         PFR_Char  gchar = phy_font->chars;
+
+
+         for ( ; count > 0; count--, gchar++ )
+         {
+           if ( max < gchar->advance )
+             max = gchar->advance;
+         }
+
+         root->max_advance_width = (FT_Short)max;
+       }
+
+       root->max_advance_height = root->height;
+
+       root->underline_position  = (FT_Short)( - root->units_per_EM / 10 );
+       root->underline_thickness = (FT_Short)(   root->units_per_EM / 30 );
+
+       /* create charmap */
+       {
+         FT_CharMapRec  charmap;
+         
+
+         charmap.face        = root;
+         charmap.platform_id = 3;
+         charmap.encoding_id = 1;
+         charmap.encoding    = ft_encoding_unicode;
+         
+         FT_CMap_New( &pfr_cmap_class_rec, NULL, &charmap, NULL );
+       }
+     }
+
+  Exit:
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    SLOT OBJECT METHOD                         *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_slot_init( PFR_Slot  slot )
+  {
+    FT_GlyphLoader  loader = slot->root.internal->loader;
+
+    pfr_glyph_init( &slot->glyph, loader );
+
+    return 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  pfr_slot_done( PFR_Slot  slot )
+  {
+    pfr_glyph_done( &slot->glyph );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  pfr_slot_load( PFR_Slot  slot,
+                 PFR_Size  size,
+                 FT_UInt   gindex,
+                 FT_Int    load_flags )
+  {
+    FT_Error     error;
+    PFR_Face     face    = (PFR_Face)slot->root.face;
+    PFR_Char     gchar   = face->phy_font.chars + gindex;
+    FT_Outline*  outline = &slot->root.outline;
+    FT_ULong     gps_offset;
+
+
+    /* check that the glyph index is correct */
+    FT_ASSERT( gindex < face->phy_font.num_chars );
+
+    slot->root.format   = ft_glyph_format_outline;
+    outline->n_points   = 0;
+    outline->n_contours = 0;
+    gps_offset          = face->header.gps_section_offset;
+
+    /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */
+    error = pfr_glyph_load( &slot->glyph, face->root.stream,
+                            gps_offset, gchar->gps_offset, gchar->gps_size );
+
+    if ( !error )
+    {
+      FT_BBox            cbox;
+      FT_Glyph_Metrics*  metrics = &slot->root.metrics;
+      FT_Pos             advance;
+      FT_Int             em_metrics, em_outline;
+      FT_Bool            scaling;
+
+
+      scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
+
+      /* copy outline data */
+      *outline = slot->glyph.loader->base.outline;
+
+      outline->flags &= ~ft_outline_owner;
+      outline->flags |= ft_outline_reverse_fill;
+
+      if ( size && size->root.metrics.y_ppem < 24 )
+        outline->flags |= ft_outline_high_precision;
+
+      /* compute the advance vector */
+      metrics->horiAdvance = 0;
+      metrics->vertAdvance = 0;
+
+      advance    = gchar->advance;
+      em_metrics = face->phy_font.metrics_resolution;
+      em_outline = face->phy_font.outline_resolution;
+
+      if ( em_metrics != em_outline )
+        advance = FT_MulDiv( advance, em_outline, em_metrics );
+
+      if ( face->phy_font.flags & PFR_PHY_VERTICAL )
+        metrics->vertAdvance = gchar->advance;
+      else
+        metrics->horiAdvance = gchar->advance;
+
+      slot->root.linearHoriAdvance = metrics->horiAdvance;
+      slot->root.linearVertAdvance = metrics->vertAdvance;
+
+      /* make-up vertical metrics(?) */
+      metrics->vertBearingX = 0;
+      metrics->vertBearingY = 0;
+
+      /* scale when needed */
+      if ( scaling )
+      {
+        FT_Int      n;
+        FT_Fixed    x_scale = size->root.metrics.x_scale;
+        FT_Fixed    y_scale = size->root.metrics.y_scale;
+        FT_Vector*  vec     = outline->points;
+
+
+        /* scale outline points */
+        for ( n = 0; n < outline->n_points; n++, vec++ )
+        {
+          vec->x = FT_MulFix( vec->x, x_scale );
+          vec->y = FT_MulFix( vec->y, y_scale );
+        }
+
+        /* scale the advance */
+        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
+        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
+      }
+
+      /* compute the rest of the metrics */
+      FT_Outline_Get_CBox( outline, &cbox );
+
+      metrics->width        = cbox.xMax - cbox.xMin;
+      metrics->height       = cbox.yMax - cbox.yMin;
+      metrics->horiBearingX = cbox.xMin;
+      metrics->horiBearingY = cbox.yMax - metrics->height;
+    }
+
+    return error;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/pfrobjs.h
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrobjs.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/pfr/pfrobjs.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,84 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrobjs.h                                                              */
+/*                                                                         */
+/*    FreeType PFR object methods (specification).                         */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PFROBJS_H__
+#define __PFROBJS_H__
+
+#include "pfrtypes.h"
+
+
+FT_BEGIN_HEADER
+
+  typedef struct PFR_FaceRec_*  PFR_Face;
+  
+  typedef struct PFR_SizeRec_*  PFR_Size;
+  
+  typedef struct PFR_SlotRec_*  PFR_Slot;
+
+
+  typedef struct  PFR_FaceRec_
+  {
+    FT_FaceRec      root;
+    PFR_HeaderRec   header;
+    PFR_LogFontRec  log_font;
+    PFR_PhyFontRec  phy_font;
+
+  } PFR_FaceRec;
+
+
+  typedef struct  PFR_SizeRec_
+  {
+    FT_SizeRec  root;
+  
+  } PFR_SizeRec;
+
+
+  typedef struct  PFR_SlotRec_
+  {
+    FT_GlyphSlotRec  root;
+    PFR_GlyphRec     glyph;
+    
+  } PFR_SlotRec;
+
+
+  FT_LOCAL( FT_Error )
+  pfr_face_init( FT_Stream  stream,
+                 PFR_Face   face,
+                 FT_Int     face_index );
+
+  FT_LOCAL( void )
+  pfr_face_done( PFR_Face  face );
+
+
+  FT_LOCAL( FT_Error )
+  pfr_slot_init( PFR_Slot  slot );
+
+  FT_LOCAL( void )
+  pfr_slot_done( PFR_Slot  slot );
+
+
+  FT_LOCAL( FT_Error )
+  pfr_slot_load( PFR_Slot  slot,
+                 PFR_Size  size,
+                 FT_UInt   gindex,
+                 FT_Int    load_flags );
+
+
+FT_END_HEADER
+
+#endif /* __PFROBJS_H__ */
Index: xc/extras/freetype2/src/pfr/pfrtypes.h
diff -u /dev/null xc/extras/freetype2/src/pfr/pfrtypes.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/pfr/pfrtypes.h	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,311 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pfrtypes.h                                                             */
+/*                                                                         */
+/*    FreeType PFR data structures (specification only).                   */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PFRTYPES_H__
+#define __PFRTYPES_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+
+FT_BEGIN_HEADER
+
+  /************************************************************************/
+
+  /* the PFR Header structure */
+  typedef struct  PFR_HeaderRec_
+  {
+    FT_UInt32  signature;
+    FT_UInt    version;
+    FT_UInt    signature2;
+    FT_UInt    header_size;
+
+    FT_UInt    log_dir_size;
+    FT_UInt    log_dir_offset;
+
+    FT_UInt    log_font_max_size;
+    FT_UInt32  log_font_section_size;
+    FT_UInt32  log_font_section_offset;
+
+    FT_UInt32  phy_font_max_size;
+    FT_UInt32  phy_font_section_size;
+    FT_UInt32  phy_font_section_offset;
+
+    FT_UInt    gps_max_size;
+    FT_UInt32  gps_section_size;
+    FT_UInt32  gps_section_offset;
+
+    FT_UInt    max_blue_values;
+    FT_UInt    max_x_orus;
+    FT_UInt    max_y_orus;
+    
+    FT_UInt    phy_font_max_size_high;
+    FT_UInt    color_flags;
+    
+    FT_UInt32  bct_max_size;
+    FT_UInt32  bct_set_max_size;        
+    FT_UInt32  phy_bct_set_max_size;
+    
+    FT_UInt    num_phy_fonts;
+    FT_UInt    max_vert_stem_snap;
+    FT_UInt    max_horz_stem_snap;
+    FT_UInt    max_chars;
+  
+  } PFR_HeaderRec, *PFR_Header;
+
+
+  /* used in `color_flags' field of the PFR_Header */
+  typedef enum  PFR_HeaderFlags_
+  {
+    PFR_FLAG_BLACK_PIXEL   = 1,
+    PFR_FLAG_INVERT_BITMAP = 2
+  
+  } PFR_HeaderFlags;
+
+
+  /************************************************************************/
+
+  typedef struct  PFR_LogFontRec_
+  {
+    FT_UInt32  size;
+    FT_UInt32  offset;
+    
+    FT_Int32   matrix[4];
+    FT_UInt    stroke_flags;
+    FT_Int     stroke_thickness;
+    FT_Int     bold_thickness;
+    FT_Int32   miter_limit;
+    
+    FT_UInt32  phys_size;
+    FT_UInt32  phys_offset;
+  
+  } PFR_LogFontRec, *PFR_LogFont;
+
+
+  typedef enum  PFR_LogFlags_
+  {
+    PFR_LOG_EXTRA_ITEMS  = 0x40,
+    PFR_LOG_2BYTE_BOLD   = 0x20,
+    PFR_LOG_BOLD         = 0x10,
+    PFR_LOG_2BYTE_STROKE = 8,
+    PFR_LOG_STROKE       = 4,
+    PFR_LINE_JOIN_MASK   = 3
+    
+  } PFR_LogFlags;
+
+
+  typedef enum  PFR_LineJoinFlags_
+  {
+    PFR_LINE_JOIN_MITER = 0,
+    PFR_LINE_JOIN_ROUND = 1,
+    PFR_LINE_JOIN_BEVEL = 2
+    
+  } PFR_LineJoinFlags;
+
+
+  /************************************************************************/
+
+  typedef enum  PFR_BitmapFlags_
+  {
+    PFR_BITMAP_3BYTE_OFFSET   = 4,
+    PFR_BITMAP_2BYTE_SIZE     = 2,
+    PFR_BITMAP_2BYTE_CHARCODE = 1
+  
+  } PFR_BitmapFlags;
+
+
+  typedef struct  PFR_BitmapCharRec_
+  {
+    FT_UInt    char_code;
+    FT_UInt    gps_size;
+    FT_UInt32  gps_offset;
+  
+  } PFR_BitmapCharRec, *PFR_BitmapChar;
+
+
+  typedef enum  PFR_StrikeFlags_
+  {
+    PFR_STRIKE_2BYTE_COUNT  = 0x10,
+    PFR_STRIKE_3BYTE_OFFSET = 0x08,
+    PFR_STRIKE_3BYTE_SIZE   = 0x04,
+    PFR_STRIKE_2BYTE_YPPM   = 0x02,
+    PFR_STRIKE_2BYTE_XPPM   = 0x01
+
+  } PFR_StrikeFlags;
+
+
+  typedef struct  PFR_StrikeRec_
+  {
+    FT_UInt         x_ppm;
+    FT_UInt         y_ppm;
+    FT_UInt         flags;
+    
+    FT_UInt32       gps_size;
+    FT_UInt32       gps_offset;
+    
+    FT_UInt32       bct_size;
+    FT_UInt32       bct_offset;
+    
+    /* optional */
+    FT_UInt         num_bitmaps;
+    PFR_BitmapChar  bitmaps;
+    
+  } PFR_StrikeRec, *PFR_Strike;
+
+
+  /************************************************************************/
+
+  typedef struct  PFR_CharRec_
+  {
+    FT_UInt    char_code;
+    FT_Int     advance;
+    FT_UInt    gps_size;
+    FT_UInt32  gps_offset;
+  
+  } PFR_CharRec, *PFR_Char;
+
+
+  /************************************************************************/
+
+  typedef struct  PFR_DimensionRec_
+  {
+    FT_UInt  standard;
+    FT_UInt  num_stem_snaps;
+    FT_Int*  stem_snaps;
+  
+  } PFR_DimensionRec, *PFR_Dimension;
+
+
+  /************************************************************************/
+
+  typedef struct  PFR_PhyFontRec_
+  {
+    FT_Memory          memory;
+    FT_UInt32          offset;
+
+    FT_UInt            font_ref_number;
+    FT_UInt            outline_resolution;
+    FT_UInt            metrics_resolution;
+    FT_BBox            bbox;
+    FT_UInt            flags;
+    FT_UInt            standard_advance;
+    
+    PFR_DimensionRec   horizontal;
+    PFR_DimensionRec   vertical;
+
+    FT_String*         font_id;
+
+    FT_UInt            num_strikes;
+    FT_UInt            max_strikes;
+    PFR_StrikeRec*     strikes;
+    
+    FT_UInt            num_blue_values;
+    FT_Int            *blue_values;
+    FT_UInt            blue_fuzz;
+    FT_UInt            blue_scale;
+    
+    FT_UInt            num_chars;
+    FT_UInt32          chars_offset;
+    PFR_Char           chars;
+  
+  } PFR_PhyFontRec, *PFR_PhyFont;
+
+
+  typedef enum  PFR_PhyFlags_
+  {
+    PFR_PHY_EXTRA_ITEMS      = 0x80,
+    PFR_PHY_3BYTE_GPS_OFFSET = 0x20,
+    PFR_PHY_2BYTE_GPS_SIZE   = 0x10,
+    PFR_PHY_ASCII_CODE       = 0x08,
+    PFR_PHY_PROPORTIONAL     = 0x04,
+    PFR_PHY_2BYTE_CHARCODE   = 0x02,
+    PFR_PHY_VERTICAL         = 0x01
+
+  } PFR_PhyFlags;
+
+
+  /************************************************************************/
+
+  typedef enum  PFR_GlyphFlags_
+  {
+    PFR_GLYPH_IS_COMPOUND   = 0x80,
+    PFR_GLYPH_EXTRA_ITEMS   = 0x08,
+    PFR_GLYPH_1BYTE_XYCOUNT = 0x04,
+    PFR_GLYPH_XCOUNT        = 0x02,
+    PFR_GLYPH_YCOUNT        = 0x01
+    
+  } PFR_GlyphFlags;
+
+
+  /* controlled coordinate */
+  typedef struct  PFR_CoordRec_
+  {
+    FT_UInt  org;
+    FT_UInt  cur;
+  
+  } PFR_CoordRec, *PFR_Coord;
+
+
+  typedef struct  PFR_SubGlyphRec_
+  {
+    FT_Fixed   x_scale;
+    FT_Fixed   y_scale;
+    FT_Int     x_delta;
+    FT_Int     y_delta;
+    FT_UInt32  gps_offset;
+    FT_UInt    gps_size;
+  
+  } PFR_SubGlyphRec, *PFR_SubGlyph;
+
+
+  typedef enum  PFR_SubgGlyphFlags_
+  {
+    PFR_SUBGLYPH_3BYTE_OFFSET = 0x80,
+    PFR_SUBGLYPH_2BYTE_SIZE   = 0x40,
+    PFR_SUBGLYPH_YSCALE       = 0x20,
+    PFR_SUBGLYPH_XSCALE       = 0x10
+    
+  } PFR_SubGlyphFlags;
+
+
+  typedef struct  PFR_GlyphRec_
+  {
+    FT_Byte           format;
+    
+    FT_UInt           num_x_control;
+    FT_UInt           num_y_control;
+    FT_UInt           max_xy_control;
+    FT_Pos*           x_control;
+    FT_Pos*           y_control;
+
+
+    FT_UInt           num_subs;
+    FT_UInt           max_subs;
+    PFR_SubGlyphRec*  subs;
+    
+    FT_GlyphLoader    loader;
+    FT_Bool           path_begun;
+    
+  } PFR_GlyphRec, *PFR_Glyph;
+
+
+FT_END_HEADER
+
+#endif /* __PFRTYPES_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/pfr/rules.mk
diff -u /dev/null xc/extras/freetype2/src/pfr/rules.mk:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/pfr/rules.mk	Thu Jun 20 04:16:18 2002
@@ -0,0 +1,71 @@
+#
+# FreeType 2 PFR driver configuration rules
+#
+
+
+# Copyright 2002 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+# pfr driver directory
+#
+PFR_DIR  := $(SRC_)pfr
+PFR_DIR_ := $(PFR_DIR)$(SEP)
+
+
+# compilation flags for the driver
+#
+PFR_COMPILE := $(FT_COMPILE) $I$(PFR_DIR)
+
+
+# pfr driver sources (i.e., C files)
+#
+PFR_DRV_SRC := $(PFR_DIR_)pfrload.c  \
+               $(PFR_DIR_)pfrgload.c \
+               $(PFR_DIR_)pfrcmap.c  \
+               $(PFR_DIR_)pfrdrivr.c \
+               $(PFR_DIR_)pfrobjs.c
+
+# pfr driver headers
+#
+PFR_DRV_H := $(PFR_DRV_SRC:%.c=%.h) \
+             $(PFR_DIR_)pfrerror.h
+
+
+# Pfr driver object(s)
+#
+#   PFR_DRV_OBJ_M is used during `multi' builds
+#   PFR_DRV_OBJ_S is used during `single' builds
+#
+PFR_DRV_OBJ_M := $(PFR_DRV_SRC:$(PFR_DIR_)%.c=$(OBJ_)%.$O)
+PFR_DRV_OBJ_S := $(OBJ_)pfr.$O
+
+# pfr driver source file for single build
+#
+PFR_DRV_SRC_S := $(PFR_DIR_)pfr.c
+
+
+# pfr driver - single object
+#
+$(PFR_DRV_OBJ_S): $(PFR_DRV_SRC_S) $(PFR_DRV_SRC) $(FREETYPE_H) $(PFR_DRV_H)
+	$(PFR_COMPILE) $T$@ $(PFR_DRV_SRC_S)
+
+
+# pfr driver - multiple objects
+#
+$(OBJ_)%.$O: $(PFR_DIR_)%.c $(FREETYPE_H) $(PFR_DRV_H)
+	$(PFR_COMPILE) $T$@ $<
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(PFR_DRV_OBJ_S)
+DRV_OBJS_M += $(PFR_DRV_OBJ_M)
+
+# EOF
Index: xc/extras/freetype2/src/psaux/Jamfile
diff -u xc/extras/freetype2/src/psaux/Jamfile:1.1.1.1 xc/extras/freetype2/src/psaux/Jamfile:1.1.1.2
--- xc/extras/freetype2/src/psaux/Jamfile:1.1.1.1	Sun Sep  9 22:56:04 2001
+++ xc/extras/freetype2/src/psaux/Jamfile	Thu Jun 20 04:16:18 2002
@@ -1,4 +1,4 @@
-# FreeType 2 src/psaux Jamfile (c) 2001 David Turner
+# FreeType 2 src/psaux Jamfile (c) 2001, 2002 David Turner
 #
 
 SubDir  FT2_TOP src psaux ;
@@ -10,7 +10,7 @@
 
   if $(FT2_MULTI)
   {
-    _sources = psauxmod psobjs t1decode ;
+    _sources = psauxmod psobjs t1decode t1cmap ;
   }
   else
   {
Index: xc/extras/freetype2/src/psaux/descrip.mms
diff -u xc/extras/freetype2/src/psaux/descrip.mms:1.1.1.1 xc/extras/freetype2/src/psaux/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/psaux/descrip.mms:1.1.1.1	Tue May 15 23:45:38 2001
+++ xc/extras/freetype2/src/psaux/descrip.mms	Thu Jun 20 04:16:18 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,6 @@
 OBJS=psaux.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/psaux/psaux.c
diff -u xc/extras/freetype2/src/psaux/psaux.c:1.1.1.3 xc/extras/freetype2/src/psaux/psaux.c:1.1.1.4
--- xc/extras/freetype2/src/psaux/psaux.c:1.1.1.3	Sun Dec 16 12:49:30 2001
+++ xc/extras/freetype2/src/psaux/psaux.c	Thu Jun 20 04:16:18 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType auxiliary PostScript driver component (body only).          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -22,6 +22,7 @@
 #include "psobjs.c"
 #include "psauxmod.c"
 #include "t1decode.c"
+#include "t1cmap.c"
 
 
 /* END */
Index: xc/extras/freetype2/src/psaux/psauxmod.c
diff -u xc/extras/freetype2/src/psaux/psauxmod.c:1.1.1.3 xc/extras/freetype2/src/psaux/psauxmod.c:1.1.1.4
--- xc/extras/freetype2/src/psaux/psauxmod.c:1.1.1.3	Sun Dec 16 12:49:30 2001
+++ xc/extras/freetype2/src/psaux/psauxmod.c	Thu Jun 20 04:16:19 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType auxiliary PostScript module implementation (body).          */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -20,10 +20,11 @@
 #include "psauxmod.h"
 #include "psobjs.h"
 #include "t1decode.h"
+#include "t1cmap.h"
 
 
   FT_CALLBACK_TABLE_DEF
-  const PS_Table_Funcs  ps_table_funcs =
+  const PS_Table_FuncsRec  ps_table_funcs =
   {
     PS_Table_New,
     PS_Table_Done,
@@ -33,25 +34,25 @@
 
 
   FT_CALLBACK_TABLE_DEF
-  const T1_Parser_Funcs  t1_parser_funcs =
+  const PS_Parser_FuncsRec  ps_parser_funcs =
   {
-    T1_Init_Parser,
-    T1_Done_Parser,
-    T1_Skip_Spaces,
-    T1_Skip_Alpha,
-    T1_ToInt,
-    T1_ToFixed,
-    T1_ToCoordArray,
-    T1_ToFixedArray,
-    T1_ToToken,
-    T1_ToTokenArray,
-    T1_Load_Field,
-    T1_Load_Field_Table
+    PS_Parser_Init,
+    PS_Parser_Done,
+    PS_Parser_SkipSpaces,
+    PS_Parser_SkipAlpha,
+    PS_Parser_ToInt,
+    PS_Parser_ToFixed,
+    PS_Parser_ToCoordArray,
+    PS_Parser_ToFixedArray,
+    PS_Parser_ToToken,
+    PS_Parser_ToTokenArray,
+    PS_Parser_LoadField,
+    PS_Parser_LoadFieldTable
   };
 
 
   FT_CALLBACK_TABLE_DEF
-  const T1_Builder_Funcs  t1_builder_funcs =
+  const T1_Builder_FuncsRec  t1_builder_funcs =
   {
     T1_Builder_Init,
     T1_Builder_Done,
@@ -65,7 +66,7 @@
 
 
   FT_CALLBACK_TABLE_DEF
-  const T1_Decoder_Funcs  t1_decoder_funcs =
+  const T1_Decoder_FuncsRec  t1_decoder_funcs =
   {
     T1_Decoder_Init,
     T1_Decoder_Done,
@@ -73,15 +74,27 @@
   };
 
 
+  FT_CALLBACK_TABLE_DEF
+  const T1_CMap_ClassesRec  t1_cmap_classes =
+  {
+    &t1_cmap_standard_class_rec,
+    &t1_cmap_expert_class_rec,
+    &t1_cmap_custom_class_rec,
+    &t1_cmap_unicode_class_rec
+  };
+
+
   static
   const PSAux_Interface  psaux_interface =
   {
     &ps_table_funcs,
-    &t1_parser_funcs,
+    &ps_parser_funcs,
     &t1_builder_funcs,
     &t1_decoder_funcs,
 
-    T1_Decrypt
+    T1_Decrypt,
+    
+    (const T1_CMap_ClassesRec*) &t1_cmap_classes,
   };
 
 
Index: xc/extras/freetype2/src/psaux/psobjs.c
diff -u xc/extras/freetype2/src/psaux/psobjs.c:1.1.1.5 xc/extras/freetype2/src/psaux/psobjs.c:1.1.1.6
--- xc/extras/freetype2/src/psaux/psobjs.c:1.1.1.5	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/psaux/psobjs.c	Thu Jun 20 04:16:19 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Auxiliary functions for PostScript fonts (body).                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -53,8 +53,8 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  PS_Table_New( PS_Table*  table,
+  FT_LOCAL_DEF( FT_Error )
+  PS_Table_New( PS_Table   table,
                 FT_Int     count,
                 FT_Memory  memory )
   {
@@ -62,8 +62,8 @@
 
 
     table->memory = memory;
-    if ( ALLOC_ARRAY( table->elements, count, FT_Byte*  ) ||
-         ALLOC_ARRAY( table->lengths, count, FT_Byte* )   )
+    if ( FT_NEW_ARRAY( table->elements, count ) ||
+         FT_NEW_ARRAY( table->lengths,  count ) )
       goto Exit;
 
     table->max_elems = count;
@@ -72,19 +72,20 @@
     table->block     = 0;
     table->capacity  = 0;
     table->cursor    = 0;
-    table->funcs     = ps_table_funcs;
+    
+    *(PS_Table_FuncsRec*)&table->funcs = ps_table_funcs;
 
   Exit:
     if ( error )
-      FREE( table->elements );
+      FT_FREE( table->elements );
 
     return error;
   }
 
 
   static void
-  shift_elements( PS_Table*  table,
-                  FT_Byte*   old_base )
+  shift_elements( PS_Table  table,
+                  FT_Byte*  old_base )
   {
     FT_Long    delta  = (FT_Long)( table->block - old_base );
     FT_Byte**  offset = table->elements;
@@ -100,8 +101,8 @@
 
 
   static FT_Error
-  reallocate_t1_table( PS_Table*  table,
-                       FT_Int     new_size )
+  reallocate_t1_table( PS_Table  table,
+                       FT_Int    new_size )
   {
     FT_Memory  memory   = table->memory;
     FT_Byte*   old_base = table->block;
@@ -109,15 +110,15 @@
 
 
     /* allocate new base block */
-    if ( ALLOC( table->block, new_size ) )
+    if ( FT_ALLOC( table->block, new_size ) )
       return error;
 
     /* copy elements and shift offsets */
     if (old_base )
     {
-      MEM_Copy( table->block, old_base, table->capacity );
+      FT_MEM_COPY( table->block, old_base, table->capacity );
       shift_elements( table, old_base );
-      FREE( old_base );
+      FT_FREE( old_base );
     }
 
     table->capacity = new_size;
@@ -138,7 +139,7 @@
   /*    table  :: The target table.                                        */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    index  :: The index of the object in the table.                    */
+  /*    idx  :: The index of the object in the table.                      */
   /*                                                                       */
   /*    object :: The address of the object to copy in memory.             */
   /*                                                                       */
@@ -148,13 +149,13 @@
   /*    FreeType error code.  0 means success.  An error is returned if a  */
   /*    reallocation fails.                                                */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  PS_Table_Add( PS_Table*  table,
-                FT_Int     index,
-                void*      object,
-                FT_Int     length )
+  FT_LOCAL_DEF( FT_Error )
+  PS_Table_Add( PS_Table  table,
+                FT_Int    idx,
+                void*     object,
+                FT_Int    length )
   {
-    if ( index < 0 || index > table->max_elems )
+    if ( idx < 0 || idx > table->max_elems )
     {
       FT_ERROR(( "PS_Table_Add: invalid index\n" ));
       return PSaux_Err_Invalid_Argument;
@@ -166,8 +167,8 @@
       FT_Error   error;
       FT_Offset  new_size  = table->capacity;
       FT_Long    in_offset;
-      
 
+
       in_offset = (FT_Long)((FT_Byte*)object - table->block);
       if ( (FT_ULong)in_offset >= table->capacity )
         in_offset = -1;
@@ -178,15 +179,15 @@
       error = reallocate_t1_table( table, new_size );
       if ( error )
         return error;
-      
+
       if ( in_offset >= 0 )
         object = table->block + in_offset;
     }
 
     /* add the object to the base block and adjust offset */
-    table->elements[index] = table->block + table->cursor;
-    table->lengths [index] = length;
-    MEM_Copy( table->block + table->cursor, object, length );
+    table->elements[idx] = table->block + table->cursor;
+    table->lengths [idx] = length;
+    FT_MEM_COPY( table->block + table->cursor, object, length );
 
     table->cursor += length;
     return PSaux_Err_Ok;
@@ -199,7 +200,8 @@
   /*    PS_Table_Done                                                      */
   /*                                                                       */
   /* <Description>                                                         */
-  /*    Finalizes a PS_Table (i.e., reallocate it to its current cursor).  */
+  /*    Finalizes a PS_TableRec (i.e., reallocate it to its current        */
+  /*    cursor).                                                           */
   /*                                                                       */
   /* <InOut>                                                               */
   /*    table :: The target table.                                         */
@@ -208,8 +210,8 @@
   /*    This function does NOT release the heap's memory block.  It is up  */
   /*    to the caller to clean it, or reference it in its own structures.  */
   /*                                                                       */
-  FT_LOCAL_DEF void
-  PS_Table_Done( PS_Table*  table )
+  FT_LOCAL_DEF( void )
+  PS_Table_Done( PS_Table  table )
   {
     FT_Memory  memory = table->memory;
     FT_Error   error;
@@ -220,27 +222,29 @@
     if ( !old_base )
       return;
 
-    if ( ALLOC( table->block, table->cursor ) )
+    if ( FT_ALLOC( table->block, table->cursor ) )
       return;
-    MEM_Copy( table->block, old_base, table->cursor );
+    FT_MEM_COPY( table->block, old_base, table->cursor );
     shift_elements( table, old_base );
 
     table->capacity = table->cursor;
-    FREE( old_base );
+    FT_FREE( old_base );
+
+    FT_UNUSED( error );
   }
 
 
-  FT_LOCAL_DEF void
-  PS_Table_Release( PS_Table*  table )
+  FT_LOCAL_DEF( void )
+  PS_Table_Release( PS_Table  table )
   {
     FT_Memory  memory = table->memory;
 
 
     if ( (FT_ULong)table->init == 0xDEADBEEFUL )
     {
-      FREE( table->block );
-      FREE( table->elements );
-      FREE( table->lengths );
+      FT_FREE( table->block );
+      FT_FREE( table->elements );
+      FT_FREE( table->lengths );
       table->init = 0;
     }
   }
@@ -261,8 +265,8 @@
 #define IS_T1_SPACE( c )  ( IS_T1_WHITESPACE( c ) || IS_T1_LINESPACE( c ) )
 
 
-  FT_LOCAL_DEF void
-  T1_Skip_Spaces( T1_Parser*  parser )
+  FT_LOCAL_DEF( void )
+  PS_Parser_SkipSpaces( PS_Parser  parser )
   {
     FT_Byte* cur   = parser->cursor;
     FT_Byte* limit = parser->limit;
@@ -281,8 +285,8 @@
   }
 
 
-  FT_LOCAL_DEF void
-  T1_Skip_Alpha( T1_Parser*  parser )
+  FT_LOCAL_DEF( void )
+  PS_Parser_SkipAlpha( PS_Parser  parser )
   {
     FT_Byte* cur   = parser->cursor;
     FT_Byte* limit = parser->limit;
@@ -301,9 +305,9 @@
   }
 
 
-  FT_LOCAL_DEF void
-  T1_ToToken( T1_Parser*  parser,
-              T1_Token*   token )
+  FT_LOCAL_DEF( void )
+  PS_Parser_ToToken( PS_Parser  parser,
+                     T1_Token   token )
   {
     FT_Byte*  cur;
     FT_Byte*  limit;
@@ -311,12 +315,12 @@
     FT_Int    embed;
 
 
-    token->type  = t1_token_none;
+    token->type  = T1_TOKEN_TYPE_NONE;
     token->start = 0;
     token->limit = 0;
 
     /* first of all, skip space */
-    T1_Skip_Spaces( parser );
+    PS_Parser_SkipSpaces( parser );
 
     cur   = parser->cursor;
     limit = parser->limit;
@@ -327,19 +331,19 @@
       {
         /************* check for strings ***********************/
       case '(':
-        token->type = t1_token_string;
+        token->type = T1_TOKEN_TYPE_STRING;
         ender = ')';
         goto Lookup_Ender;
 
         /************* check for programs/array ****************/
       case '{':
-        token->type = t1_token_array;
+        token->type = T1_TOKEN_TYPE_ARRAY;
         ender = '}';
         goto Lookup_Ender;
 
         /************* check for table/array ******************/
       case '[':
-        token->type = t1_token_array;
+        token->type = T1_TOKEN_TYPE_ARRAY;
         ender = ']';
 
       Lookup_Ender:
@@ -366,7 +370,7 @@
         /* **************** otherwise, it's any token **********/
       default:
         token->start = cur++;
-        token->type  = t1_token_any;
+        token->type  = T1_TOKEN_TYPE_ANY;
         while ( cur < limit && !IS_T1_SPACE( *cur ) )
           cur++;
 
@@ -376,7 +380,7 @@
       if ( !token->limit )
       {
         token->start = 0;
-        token->type  = t1_token_none;
+        token->type  = T1_TOKEN_TYPE_NONE;
       }
 
       parser->cursor = cur;
@@ -384,24 +388,24 @@
   }
 
 
-  FT_LOCAL_DEF void
-  T1_ToTokenArray( T1_Parser*  parser,
-                   T1_Token*   tokens,
-                   FT_UInt     max_tokens,
-                   FT_Int*     pnum_tokens )
+  FT_LOCAL_DEF( void )
+  PS_Parser_ToTokenArray( PS_Parser  parser,
+                          T1_Token   tokens,
+                          FT_UInt    max_tokens,
+                          FT_Int*    pnum_tokens )
   {
-    T1_Token  master;
+    T1_TokenRec  master;
 
 
     *pnum_tokens = -1;
 
-    T1_ToToken( parser, &master );
-    if ( master.type == t1_token_array )
+    PS_Parser_ToToken( parser, &master );
+    if ( master.type == T1_TOKEN_TYPE_ARRAY )
     {
-      FT_Byte*   old_cursor = parser->cursor;
-      FT_Byte*   old_limit  = parser->limit;
-      T1_Token*  cur        = tokens;
-      T1_Token*  limit      = cur + max_tokens;
+      FT_Byte*  old_cursor = parser->cursor;
+      FT_Byte*  old_limit  = parser->limit;
+      T1_Token  cur        = tokens;
+      T1_Token  limit      = cur + max_tokens;
 
 
       parser->cursor = master.start;
@@ -409,10 +413,10 @@
 
       while ( parser->cursor < parser->limit )
       {
-        T1_Token  token;
+        T1_TokenRec  token;
 
 
-        T1_ToToken( parser, &token );
+        PS_Parser_ToToken( parser, &token );
         if ( !token.type )
           break;
 
@@ -431,12 +435,49 @@
 
 
   static FT_Long
+  T1Radix( FT_Long    radixBase,
+           FT_Byte**  cur,
+           FT_Byte*   limit )
+  {
+    FT_Long  result = 0;
+    FT_Byte  radixEndChar0 =
+               (FT_Byte)( radixBase > 10 ? '9' + 1 : '0' + radixBase );
+    FT_Byte  radixEndChar1 =
+               (FT_Byte)( 'A' + radixBase - 10 );
+    FT_Byte  radixEndChar2 =
+               (FT_Byte)( 'a' + radixBase - 10 );
+
+
+    while( *cur < limit )
+    {
+      if ( (*cur)[0] >= '0' && (*cur)[0] < radixEndChar0 )
+        result = result * radixBase + (*cur)[0] - '0';
+
+      else if ( radixBase > 10 &&
+                (*cur)[0] >= 'A' && (*cur)[0] < radixEndChar1 )
+        result = result * radixBase + ( (*cur)[0] - 'A' + 10 );
+
+      else if ( radixBase > 10 &&
+                (*cur)[0] >= 'a' && (*cur)[0] < radixEndChar2 )
+        result = result * radixBase + ( (*cur)[0] - 'a' + 10 );
+
+      else
+        return result;
+
+      (*cur)++;
+    }
+
+    return result;
+  }
+
+
+  static FT_Long
   t1_toint( FT_Byte**  cursor,
             FT_Byte*   limit )
   {
     FT_Long   result = 0;
     FT_Byte*  cur    = *cursor;
-    FT_Byte   c = '\0', d;
+    FT_Byte   c      = '\0', d;
 
 
     for ( ; cur < limit; cur++ )
@@ -459,7 +500,14 @@
       {
         d = (FT_Byte)( cur[0] - '0' );
         if ( d >= 10 )
+        {
+          if ( cur[0] == '#' )
+          {
+            cur++;
+            result = T1Radix( result, &cur, limit );
+          }
           break;
+        }
 
         result = result * 10 + d;
         cur++;
@@ -732,11 +780,11 @@
     }
 
     len = cur - *cursor;
-    if ( cur >= limit || ALLOC( result, len + 1 ) )
+    if ( cur >= limit || FT_ALLOC( result, len + 1 ) )
       return 0;
 
     /* now copy the string */
-    MEM_Copy( result, *cursor, len );
+    FT_MEM_COPY( result, *cursor, len );
     result[len] = '\0';
     *cursor = cur;
     return result;
@@ -780,58 +828,58 @@
 
 
   /* Load a simple field (i.e. non-table) into the current list of objects */
-  FT_LOCAL_DEF FT_Error
-  T1_Load_Field( T1_Parser*       parser,
-                 const T1_Field*  field,
-                 void**           objects,
-                 FT_UInt          max_objects,
-                 FT_ULong*        pflags )
-  {
-    T1_Token  token;
-    FT_Byte*  cur;
-    FT_Byte*  limit;
-    FT_UInt   count;
-    FT_UInt   index;
-    FT_Error  error;
+  FT_LOCAL_DEF( FT_Error )
+  PS_Parser_LoadField( PS_Parser       parser,
+                       const T1_Field  field,
+                       void**          objects,
+                       FT_UInt         max_objects,
+                       FT_ULong*       pflags )
+  {
+    T1_TokenRec  token;
+    FT_Byte*     cur;
+    FT_Byte*     limit;
+    FT_UInt      count;
+    FT_UInt      idx;
+    FT_Error     error;
 
 
-    T1_ToToken( parser, &token );
+    PS_Parser_ToToken( parser, &token );
     if ( !token.type )
       goto Fail;
 
     count = 1;
-    index = 0;
+    idx   = 0;
     cur   = token.start;
     limit = token.limit;
 
-    if ( token.type == t1_token_array )
+    if ( token.type == T1_TOKEN_TYPE_ARRAY )
     {
       /* if this is an array, and we have no blend, an error occurs */
       if ( max_objects == 0 )
         goto Fail;
 
       count = max_objects;
-      index = 1;
+      idx = 1;
     }
 
-    for ( ; count > 0; count--, index++ )
+    for ( ; count > 0; count--, idx++ )
     {
-      FT_Byte*    q = (FT_Byte*)objects[index] + field->offset;
+      FT_Byte*    q = (FT_Byte*)objects[idx] + field->offset;
       FT_Long     val;
       FT_String*  string;
 
 
       switch ( field->type )
       {
-      case t1_field_bool:
+      case T1_FIELD_TYPE_BOOL:
         val = t1_tobool( &cur, limit );
         goto Store_Integer;
 
-      case t1_field_fixed:
+      case T1_FIELD_TYPE_FIXED:
         val = t1_tofixed( &cur, limit, 3 );
         goto Store_Integer;
 
-      case t1_field_integer:
+      case T1_FIELD_TYPE_INTEGER:
         val = t1_toint( &cur, limit );
 
       Store_Integer:
@@ -849,12 +897,12 @@
           *(FT_UInt32*)q = (FT_UInt32)val;
           break;
 
-        default:  /* for 64-bit systems */
+        default:                /* for 64-bit systems */
           *(FT_Long*)q = val;
         }
         break;
 
-      case t1_field_string:
+      case T1_FIELD_TYPE_STRING:
         {
           FT_Memory  memory = parser->memory;
           FT_UInt    len    = (FT_UInt)( limit - cur );
@@ -864,10 +912,10 @@
             /* with synthetic fonts, it's possible to find a field twice */
             break;
 
-          if ( ALLOC( string, len + 1 ) )
+          if ( FT_ALLOC( string, len + 1 ) )
             goto Exit;
 
-          MEM_Copy( string, cur, len );
+          FT_MEM_COPY( string, cur, len );
           string[len] = 0;
 
           *(FT_String**)q = string;
@@ -901,28 +949,29 @@
 #define T1_MAX_TABLE_ELEMENTS  32
 
 
-  FT_LOCAL_DEF FT_Error
-  T1_Load_Field_Table( T1_Parser*       parser,
-                       const T1_Field*  field,
-                       void**           objects,
-                       FT_UInt          max_objects,
-                       FT_ULong*        pflags )
-  {
-    T1_Token   elements[T1_MAX_TABLE_ELEMENTS];
-    T1_Token*  token;
-    FT_Int     num_elements;
-    FT_Error   error = 0;
-    FT_Byte*   old_cursor;
-    FT_Byte*   old_limit;
-    T1_Field   fieldrec = *(T1_Field*)field;
+  FT_LOCAL_DEF( FT_Error )
+  PS_Parser_LoadFieldTable( PS_Parser       parser,
+                            const T1_Field  field,
+                            void**          objects,
+                            FT_UInt         max_objects,
+                            FT_ULong*       pflags )
+  {
+    T1_TokenRec  elements[T1_MAX_TABLE_ELEMENTS];
+    T1_Token     token;
+    FT_Int       num_elements;
+    FT_Error     error = 0;
+    FT_Byte*     old_cursor;
+    FT_Byte*     old_limit;
+    T1_FieldRec  fieldrec = *(T1_Field)field;
 
+
 #if 1
-    fieldrec.type = t1_field_integer;
-    if ( field->type == t1_field_fixed_array )
-      fieldrec.type = t1_field_fixed;
+    fieldrec.type = T1_FIELD_TYPE_INTEGER;
+    if ( field->type == T1_FIELD_TYPE_FIXED_ARRAY )
+      fieldrec.type = T1_FIELD_TYPE_FIXED;
 #endif
 
-    T1_ToTokenArray( parser, elements, 32, &num_elements );
+    PS_Parser_ToTokenArray( parser, elements, 32, &num_elements );
     if ( num_elements < 0 )
       goto Fail;
 
@@ -942,7 +991,7 @@
     {
       parser->cursor = token->start;
       parser->limit  = token->limit;
-      T1_Load_Field( parser, &fieldrec, objects, max_objects, 0 );
+      PS_Parser_LoadField( parser, &fieldrec, objects, max_objects, 0 );
       fieldrec.offset += fieldrec.size;
     }
 
@@ -965,36 +1014,36 @@
   }
 
 
-  FT_LOCAL_DEF FT_Long
-  T1_ToInt( T1_Parser*  parser )
+  FT_LOCAL_DEF( FT_Long )
+  PS_Parser_ToInt( PS_Parser  parser )
   {
     return t1_toint( &parser->cursor, parser->limit );
   }
 
 
-  FT_LOCAL_DEF FT_Fixed
-  T1_ToFixed( T1_Parser*  parser,
-              FT_Int      power_ten )
+  FT_LOCAL_DEF( FT_Fixed )
+  PS_Parser_ToFixed( PS_Parser  parser,
+                     FT_Int     power_ten )
   {
     return t1_tofixed( &parser->cursor, parser->limit, power_ten );
   }
 
 
-  FT_LOCAL_DEF FT_Int
-  T1_ToCoordArray( T1_Parser*  parser,
-                   FT_Int      max_coords,
-                   FT_Short*   coords )
+  FT_LOCAL_DEF( FT_Int )
+  PS_Parser_ToCoordArray( PS_Parser  parser,
+                          FT_Int     max_coords,
+                          FT_Short*  coords )
   {
     return t1_tocoordarray( &parser->cursor, parser->limit,
                             max_coords, coords );
   }
 
 
-  FT_LOCAL_DEF FT_Int
-  T1_ToFixedArray( T1_Parser*  parser,
-                   FT_Int      max_values,
-                   FT_Fixed*   values,
-                   FT_Int      power_ten )
+  FT_LOCAL_DEF( FT_Int )
+  PS_Parser_ToFixedArray( PS_Parser  parser,
+                          FT_Int     max_values,
+                          FT_Fixed*  values,
+                          FT_Int     power_ten )
   {
     return t1_tofixedarray( &parser->cursor, parser->limit,
                             max_values, values, power_ten );
@@ -1003,15 +1052,15 @@
 
 #if 0
 
-  FT_LOCAL_DEF FT_String*
-  T1_ToString( T1_Parser*  parser )
+  FT_LOCAL_DEF( FT_String* )
+  T1_ToString( PS_Parser  parser )
   {
     return t1_tostring( &parser->cursor, parser->limit, parser->memory );
   }
 
 
-  FT_LOCAL_DEF FT_Bool
-  T1_ToBool( T1_Parser*  parser )
+  FT_LOCAL_DEF( FT_Bool )
+  T1_ToBool( PS_Parser  parser )
   {
     return t1_tobool( &parser->cursor, parser->limit );
   }
@@ -1019,23 +1068,23 @@
 #endif /* 0 */
 
 
-  FT_LOCAL_DEF void
-  T1_Init_Parser( T1_Parser*  parser,
-                  FT_Byte*    base,
-                  FT_Byte*    limit,
-                  FT_Memory   memory )
+  FT_LOCAL_DEF( void )
+  PS_Parser_Init( PS_Parser  parser,
+                  FT_Byte*   base,
+                  FT_Byte*   limit,
+                  FT_Memory  memory )
   {
     parser->error  = 0;
     parser->base   = base;
     parser->limit  = limit;
     parser->cursor = base;
     parser->memory = memory;
-    parser->funcs  = t1_parser_funcs;
+    parser->funcs  = ps_parser_funcs;
   }
 
 
-  FT_LOCAL_DEF void
-  T1_Done_Parser( T1_Parser*  parser )
+  FT_LOCAL_DEF( void )
+  PS_Parser_Done( PS_Parser  parser )
   {
     FT_UNUSED( parser );
   }
@@ -1066,9 +1115,11 @@
   /*    size    :: The current size object.                                */
   /*                                                                       */
   /*    glyph   :: The current glyph object.                               */
+  /*                                                                       */
+  /*    hinting :: Whether hinting should be applied.                      */
   /*                                                                       */
-  FT_LOCAL_DEF void
-  T1_Builder_Init( T1_Builder*   builder,
+  FT_LOCAL_DEF( void )
+  T1_Builder_Init( T1_Builder    builder,
                    FT_Face       face,
                    FT_Size       size,
                    FT_GlyphSlot  glyph,
@@ -1083,7 +1134,7 @@
 
     if ( glyph )
     {
-      FT_GlyphLoader*  loader = glyph->internal->loader;
+      FT_GlyphLoader  loader = glyph->internal->loader;
 
 
       builder->loader  = loader;
@@ -1093,7 +1144,7 @@
 
       builder->hints_globals = size->internal;
       builder->hints_funcs   = 0;
-            
+
       if ( hinting )
         builder->hints_funcs = glyph->internal->glyph_hints;
     }
@@ -1129,8 +1180,8 @@
   /* <Input>                                                               */
   /*    builder :: A pointer to the glyph builder to finalize.             */
   /*                                                                       */
-  FT_LOCAL_DEF void
-  T1_Builder_Done( T1_Builder*  builder )
+  FT_LOCAL_DEF( void )
+  T1_Builder_Done( T1_Builder  builder )
   {
     FT_GlyphSlot  glyph = builder->glyph;
 
@@ -1140,21 +1191,21 @@
   }
 
 
-  /* check that there is enough room for `count' more points */
-  FT_LOCAL_DEF FT_Error
-  T1_Builder_Check_Points( T1_Builder*  builder,
-                           FT_Int       count )
+  /* check that there is enough space for `count' more points */
+  FT_LOCAL_DEF( FT_Error )
+  T1_Builder_Check_Points( T1_Builder  builder,
+                           FT_Int      count )
   {
-    return FT_GlyphLoader_Check_Points( builder->loader, count, 0 );
+    return FT_GlyphLoader_CheckPoints( builder->loader, count, 0 );
   }
 
 
   /* add a new point, do not check space */
-  FT_LOCAL_DEF void
-  T1_Builder_Add_Point( T1_Builder*  builder,
-                        FT_Pos       x,
-                        FT_Pos       y,
-                        FT_Byte      flag )
+  FT_LOCAL_DEF( void )
+  T1_Builder_Add_Point( T1_Builder  builder,
+                        FT_Pos      x,
+                        FT_Pos      y,
+                        FT_Byte     flag )
   {
     FT_Outline*  outline = builder->current;
 
@@ -1181,10 +1232,10 @@
 
 
   /* check space for a new on-curve point, then add it */
-  FT_LOCAL_DEF FT_Error
-  T1_Builder_Add_Point1( T1_Builder*  builder,
-                         FT_Pos       x,
-                         FT_Pos       y )
+  FT_LOCAL_DEF( FT_Error )
+  T1_Builder_Add_Point1( T1_Builder  builder,
+                         FT_Pos      x,
+                         FT_Pos      y )
   {
     FT_Error  error;
 
@@ -1198,8 +1249,8 @@
 
 
   /* check room for a new contour, then add it */
-  FT_LOCAL_DEF FT_Error
-  T1_Builder_Add_Contour( T1_Builder*  builder )
+  FT_LOCAL_DEF( FT_Error )
+  T1_Builder_Add_Contour( T1_Builder  builder )
   {
     FT_Outline*  outline = builder->current;
     FT_Error     error;
@@ -1211,7 +1262,7 @@
       return PSaux_Err_Ok;
     }
 
-    error = FT_GlyphLoader_Check_Points( builder->loader, 0, 1 );
+    error = FT_GlyphLoader_CheckPoints( builder->loader, 0, 1 );
     if ( !error )
     {
       if ( outline->n_contours > 0 )
@@ -1226,10 +1277,10 @@
 
 
   /* if a path was begun, add its first on-curve point */
-  FT_LOCAL_DEF FT_Error
-  T1_Builder_Start_Point( T1_Builder*  builder,
-                          FT_Pos       x,
-                          FT_Pos       y )
+  FT_LOCAL_DEF( FT_Error )
+  T1_Builder_Start_Point( T1_Builder  builder,
+                          FT_Pos      x,
+                          FT_Pos      y )
   {
     FT_Error  error = 0;
 
@@ -1247,8 +1298,8 @@
 
 
   /* close the current contour */
-  FT_LOCAL_DEF void
-  T1_Builder_Close_Contour( T1_Builder*  builder )
+  FT_LOCAL_DEF( void )
+  T1_Builder_Close_Contour( T1_Builder  builder )
   {
     FT_Outline*  outline = builder->current;
 
@@ -1290,7 +1341,7 @@
   /*************************************************************************/
   /*************************************************************************/
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_Decrypt( FT_Byte*   buffer,
               FT_Offset  length,
               FT_UShort  seed )
Index: xc/extras/freetype2/src/psaux/psobjs.h
diff -u xc/extras/freetype2/src/psaux/psobjs.h:1.1.1.4 xc/extras/freetype2/src/psaux/psobjs.h:1.1.1.5
--- xc/extras/freetype2/src/psaux/psobjs.h:1.1.1.4	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/psaux/psobjs.h	Thu Jun 20 04:16:19 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Auxiliary functions for PostScript fonts (specification).            */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -37,32 +37,32 @@
 
 
   FT_CALLBACK_TABLE
-  const PS_Table_Funcs  ps_table_funcs;
+  const PS_Table_FuncsRec    ps_table_funcs;
 
   FT_CALLBACK_TABLE
-  const T1_Parser_Funcs  t1_parser_funcs;
+  const PS_Parser_FuncsRec   ps_parser_funcs;
 
   FT_CALLBACK_TABLE
-  const T1_Builder_Funcs  t1_builder_funcs;
+  const T1_Builder_FuncsRec  t1_builder_funcs;
 
 
-  FT_LOCAL FT_Error
-  PS_Table_New( PS_Table*  table,
+  FT_LOCAL( FT_Error )
+  PS_Table_New( PS_Table   table,
                 FT_Int     count,
                 FT_Memory  memory );
 
-  FT_LOCAL FT_Error
-  PS_Table_Add( PS_Table*  table,
-                FT_Int     index,
-                void*      object,
-                FT_Int     length );
+  FT_LOCAL( FT_Error )
+  PS_Table_Add( PS_Table  table,
+                FT_Int    idx,
+                void*     object,
+                FT_Int    length );
 
-  FT_LOCAL void
-  PS_Table_Done( PS_Table*  table );
+  FT_LOCAL( void )
+  PS_Table_Done( PS_Table  table );
 
 
-  FT_LOCAL void
-  PS_Table_Release( PS_Table*  table );
+  FT_LOCAL( void )
+  PS_Table_Release( PS_Table  table );
 
 
   /*************************************************************************/
@@ -74,65 +74,65 @@
   /*************************************************************************/
 
 
-  FT_LOCAL void
-  T1_Skip_Spaces( T1_Parser*  parser );
+  FT_LOCAL( void )
+  PS_Parser_SkipSpaces( PS_Parser  parser );
 
-  FT_LOCAL void
-  T1_Skip_Alpha( T1_Parser*  parser );
+  FT_LOCAL( void )
+  PS_Parser_SkipAlpha( PS_Parser  parser );
 
-  FT_LOCAL void
-  T1_ToToken( T1_Parser*  parser,
-              T1_Token*   token );
-
-  FT_LOCAL void
-  T1_ToTokenArray( T1_Parser*  parser,
-                   T1_Token*   tokens,
-                   FT_UInt     max_tokens,
-                   FT_Int*     pnum_tokens );
-
-  FT_LOCAL FT_Error
-  T1_Load_Field( T1_Parser*       parser,
-                 const T1_Field*  field,
-                 void**           objects,
-                 FT_UInt          max_objects,
-                 FT_ULong*        pflags );
-
-  FT_LOCAL FT_Error
-  T1_Load_Field_Table( T1_Parser*       parser,
-                       const T1_Field*  field,
-                       void**           objects,
-                       FT_UInt          max_objects,
-                       FT_ULong*        pflags );
-
-  FT_LOCAL FT_Long
-  T1_ToInt( T1_Parser*  parser );
-
-
-  FT_LOCAL FT_Fixed
-  T1_ToFixed( T1_Parser*  parser,
-              FT_Int      power_ten );
-
-
-  FT_LOCAL FT_Int
-  T1_ToCoordArray( T1_Parser*  parser,
-                   FT_Int      max_coords,
-                   FT_Short*   coords );
-
-  FT_LOCAL FT_Int
-  T1_ToFixedArray( T1_Parser*  parser,
-                   FT_Int      max_values,
-                   FT_Fixed*   values,
-                   FT_Int      power_ten );
-
-
-  FT_LOCAL void
-  T1_Init_Parser( T1_Parser*  parser,
-                  FT_Byte*    base,
-                  FT_Byte*    limit,
-                  FT_Memory   memory );
+  FT_LOCAL( void )
+  PS_Parser_ToToken( PS_Parser  parser,
+                     T1_Token   token );
+
+  FT_LOCAL( void )
+  PS_Parser_ToTokenArray( PS_Parser  parser,
+                          T1_Token   tokens,
+                          FT_UInt    max_tokens,
+                          FT_Int*    pnum_tokens );
+
+  FT_LOCAL( FT_Error )
+  PS_Parser_LoadField( PS_Parser       parser,
+                       const T1_Field  field,
+                       void**          objects,
+                       FT_UInt         max_objects,
+                       FT_ULong*       pflags );
+
+  FT_LOCAL( FT_Error )
+  PS_Parser_LoadFieldTable( PS_Parser       parser,
+                            const T1_Field  field,
+                            void**          objects,
+                            FT_UInt         max_objects,
+                            FT_ULong*       pflags );
+
+  FT_LOCAL( FT_Long )
+  PS_Parser_ToInt( PS_Parser  parser );
+
+
+  FT_LOCAL( FT_Fixed )
+  PS_Parser_ToFixed( PS_Parser  parser,
+                     FT_Int     power_ten );
+
+
+  FT_LOCAL( FT_Int )
+  PS_Parser_ToCoordArray( PS_Parser  parser,
+                          FT_Int     max_coords,
+                          FT_Short*  coords );
+
+  FT_LOCAL( FT_Int )
+  PS_Parser_ToFixedArray( PS_Parser  parser,
+                          FT_Int     max_values,
+                          FT_Fixed*  values,
+                          FT_Int     power_ten );
+
+
+  FT_LOCAL( void )
+  PS_Parser_Init( PS_Parser  parser,
+                  FT_Byte*   base,
+                  FT_Byte*   limit,
+                  FT_Memory  memory );
 
-  FT_LOCAL void
-  T1_Done_Parser( T1_Parser*  parser );
+  FT_LOCAL( void )
+  PS_Parser_Done( PS_Parser  parser );
 
 
   /*************************************************************************/
@@ -143,43 +143,43 @@
   /*************************************************************************/
   /*************************************************************************/
 
-  FT_LOCAL void
-  T1_Builder_Init( T1_Builder*   builder,
+  FT_LOCAL( void )
+  T1_Builder_Init( T1_Builder    builder,
                    FT_Face       face,
                    FT_Size       size,
                    FT_GlyphSlot  glyph,
                    FT_Bool       hinting );
 
-  FT_LOCAL void
-  T1_Builder_Done( T1_Builder*  builder );
+  FT_LOCAL( void )
+  T1_Builder_Done( T1_Builder  builder );
 
-  FT_LOCAL FT_Error
-  T1_Builder_Check_Points( T1_Builder*  builder,
-                           FT_Int       count );
+  FT_LOCAL( FT_Error )
+  T1_Builder_Check_Points( T1_Builder  builder,
+                           FT_Int      count );
 
-  FT_LOCAL void
-  T1_Builder_Add_Point( T1_Builder*  builder,
-                        FT_Pos       x,
-                        FT_Pos       y,
-                        FT_Byte      flag );
+  FT_LOCAL( void )
+  T1_Builder_Add_Point( T1_Builder  builder,
+                        FT_Pos      x,
+                        FT_Pos      y,
+                        FT_Byte     flag );
 
-  FT_LOCAL FT_Error
-  T1_Builder_Add_Point1( T1_Builder*  builder,
-                         FT_Pos       x,
-                         FT_Pos       y );
+  FT_LOCAL( FT_Error )
+  T1_Builder_Add_Point1( T1_Builder  builder,
+                         FT_Pos      x,
+                         FT_Pos      y );
 
-  FT_LOCAL FT_Error
-  T1_Builder_Add_Contour( T1_Builder*  builder );
+  FT_LOCAL( FT_Error )
+  T1_Builder_Add_Contour( T1_Builder  builder );
 
 
-  FT_LOCAL FT_Error
-  T1_Builder_Start_Point( T1_Builder*  builder,
-                          FT_Pos       x,
-                          FT_Pos       y );
+  FT_LOCAL( FT_Error )
+  T1_Builder_Start_Point( T1_Builder  builder,
+                          FT_Pos      x,
+                          FT_Pos      y );
 
 
-  FT_LOCAL void
-  T1_Builder_Close_Contour( T1_Builder*  builder );
+  FT_LOCAL( void )
+  T1_Builder_Close_Contour( T1_Builder  builder );
 
 
   /*************************************************************************/
@@ -190,7 +190,7 @@
   /*************************************************************************/
   /*************************************************************************/
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_Decrypt( FT_Byte*   buffer,
               FT_Offset  length,
               FT_UShort  seed );
Index: xc/extras/freetype2/src/psaux/rules.mk
diff -u xc/extras/freetype2/src/psaux/rules.mk:1.1.1.3 xc/extras/freetype2/src/psaux/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/psaux/rules.mk:1.1.1.3	Sun Sep  9 22:56:04 2001
+++ xc/extras/freetype2/src/psaux/rules.mk	Thu Jun 20 04:16:19 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -28,6 +28,7 @@
 #
 PSAUX_DRV_SRC := $(PSAUX_DIR_)psobjs.c   \
                  $(PSAUX_DIR_)t1decode.c \
+                 $(PSAUX_DIR_)t1cmap.c   \
                  $(PSAUX_DIR_)psauxmod.c
 
 # PSAUX driver headers
Index: xc/extras/freetype2/src/psaux/t1cmap.c
diff -u /dev/null xc/extras/freetype2/src/psaux/t1cmap.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/psaux/t1cmap.c	Thu Jun 20 04:16:19 2002
@@ -0,0 +1,457 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1cmap.c                                                               */
+/*                                                                         */
+/*    Type 1 character map support (body).                                 */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "t1cmap.h"
+
+#include FT_INTERNAL_DEBUG_H
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****          TYPE1 STANDARD (AND EXPERT) ENCODING CMAPS           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  t1_cmap_std_init( T1_CMapStd  cmap,
+                    FT_Int      is_expert )
+  {
+    T1_Face          face    = (T1_Face)FT_CMAP_FACE( cmap );
+    PSNames_Service  psnames = (PSNames_Service)face->psnames;
+
+
+    cmap->num_glyphs    = face->type1.num_glyphs;
+    cmap->glyph_names   = (const char* const*)face->type1.glyph_names;
+    cmap->sid_to_string = psnames->adobe_std_strings;
+    cmap->code_to_sid   = is_expert ? psnames->adobe_expert_encoding
+                                    : psnames->adobe_std_encoding;
+
+    FT_ASSERT( cmap->code_to_sid != NULL );
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  t1_cmap_std_done( T1_CMapStd  cmap )
+  {
+    cmap->num_glyphs    = 0;
+    cmap->glyph_names   = NULL;
+    cmap->sid_to_string = NULL;
+    cmap->code_to_sid   = NULL;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_std_char_index( T1_CMapStd  cmap,
+                          FT_UInt32   char_code )
+  {
+    FT_UInt  result = 0;
+
+
+    if ( char_code < 256 )
+    {
+      FT_UInt      code, n;
+      const char*  glyph_name;
+
+
+      /* convert character code to Adobe SID string */
+      code       = cmap->code_to_sid[char_code];
+      glyph_name = cmap->sid_to_string( code );
+
+      /* look for the corresponding glyph name */
+      for ( n = 0; n < cmap->num_glyphs; n++ )
+      {
+        const char* gname = cmap->glyph_names[n];
+
+
+        if ( gname && gname[0] == glyph_name[0]  &&
+             ft_strcmp( gname, glyph_name ) == 0 )
+        {
+          result = n;
+          break;
+        }
+      }
+    }
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_std_char_next( T1_CMapStd   cmap,
+                         FT_UInt32   *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+    while ( char_code < 256 )
+    {
+      result = t1_cmap_std_char_index( cmap, char_code );
+      if ( result != 0 )
+        goto Exit;
+
+      char_code++;
+    }
+    char_code = 0;
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_standard_init( T1_CMapStd  cmap )
+  {
+    t1_cmap_std_init( cmap, 0 );
+    return 0;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_standard_class_rec =
+  {
+    sizeof ( T1_CMapStdRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_standard_init,
+    (FT_CMap_DoneFunc)     t1_cmap_std_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_std_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_std_char_next
+  };
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_expert_init( T1_CMapStd  cmap )
+  {
+    t1_cmap_std_init( cmap, 1 );
+    return 0;
+  }
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_expert_class_rec =
+  {
+    sizeof ( T1_CMapStdRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_expert_init,
+    (FT_CMap_DoneFunc)     t1_cmap_std_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_std_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_std_char_next
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    TYPE1 CUSTOM ENCODING CMAP                 *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_custom_init( T1_CMapCustom  cmap )
+  {
+    T1_Face      face     = (T1_Face)FT_CMAP_FACE( cmap );
+    T1_Encoding  encoding = &face->type1.encoding;
+
+
+    cmap->first   = encoding->code_first;
+    cmap->count   = (FT_UInt)( encoding->code_last - cmap->first + 1 );
+    cmap->indices = encoding->char_index;
+
+    FT_ASSERT( cmap->indices != NULL );
+    FT_ASSERT( encoding->code_first <= encoding->code_last );
+
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  t1_cmap_custom_done( T1_CMapCustom  cmap )
+  {
+    cmap->indices = NULL;
+    cmap->first   = 0;
+    cmap->count   = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_custom_char_index( T1_CMapCustom  cmap,
+                             FT_UInt32      char_code )
+  {
+    FT_UInt    result = 0;
+    FT_UInt32  idx;
+
+
+    idx = (FT_UInt32)( char_code - cmap->first );
+    if ( idx < cmap->count )
+      result = cmap->indices[idx];
+
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_custom_char_next( T1_CMapCustom  cmap,
+                            FT_UInt32     *pchar_code )
+  {
+    FT_UInt    result = 0;
+    FT_UInt32  char_code = *pchar_code;
+    FT_UInt32  idx;
+
+
+    ++char_code;
+
+    if ( char_code < cmap->first )
+      char_code = cmap->first;
+
+    idx = (FT_UInt32)( char_code - cmap->first );
+    for ( ; idx < cmap->count; idx++, char_code++ )
+    {
+      result = cmap->indices[idx];
+      if ( result != 0 )
+        goto Exit;
+    }
+
+    char_code = 0;
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_custom_class_rec =
+  {
+    sizeof ( T1_CMapCustomRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_custom_init,
+    (FT_CMap_DoneFunc)     t1_cmap_custom_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_custom_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_custom_char_next
+  };
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****            TYPE1 SYNTHETIC UNICODE ENCODING CMAP              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_CALLBACK_DEF( FT_Int )
+  t1_cmap_uni_pair_compare( const void*  pair1,
+                            const void*  pair2 )
+  {
+    FT_UInt32  u1 = ((T1_CMapUniPair)pair1)->unicode;
+    FT_UInt32  u2 = ((T1_CMapUniPair)pair2)->unicode;
+    
+
+    if ( u1 < u2 )
+      return -1;
+      
+    if ( u1 > u2 )
+      return +1;
+      
+    return 0;
+  }                            
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  t1_cmap_unicode_init( T1_CMapUnicode  cmap )
+  {
+    FT_Error         error;
+    FT_UInt          count;
+    T1_Face          face    = (T1_Face)FT_CMAP_FACE( cmap );
+    FT_Memory        memory  = FT_FACE_MEMORY( face );
+    PSNames_Service  psnames = (PSNames_Service)face->psnames;
+
+
+    cmap->num_pairs = 0;
+    cmap->pairs     = NULL;
+
+    count = face->type1.num_glyphs;
+
+    if ( !FT_NEW_ARRAY( cmap->pairs, count ) )
+    {
+      FT_UInt         n, new_count;
+      T1_CMapUniPair  pair;
+      FT_UInt32       uni_code;
+
+
+      pair = cmap->pairs;
+      for ( n = 0; n < count; n++ )
+      {
+        const char*  gname = face->type1.glyph_names[n];
+
+
+        /* build unsorted pair table by matching glyph names */
+        if ( gname )
+        {
+          uni_code = psnames->unicode_value( gname );
+
+          if ( uni_code != 0 )
+          {
+            pair->unicode = uni_code;
+            pair->gindex  = n;
+            pair++;
+          }
+        }
+      }
+      
+      new_count = (FT_UInt)( pair - cmap->pairs );
+      if ( new_count == 0 )
+      {
+        /* there are no unicode characters in here! */
+        FT_FREE( cmap->pairs );
+        error = FT_Err_Invalid_Argument;
+      }
+      else
+      {
+        /* re-allocate if the new array is much smaller than the original */
+        /* one                                                            */
+        if ( new_count != count && new_count < count / 2 )
+        {
+          (void)FT_RENEW_ARRAY( cmap->pairs, count, new_count );
+          error = 0;
+        }
+
+        /* sort the pairs table to allow efficient binary searches */
+        ft_qsort( cmap->pairs,
+                  new_count,
+                  sizeof ( T1_CMapUniPairRec ),
+                  t1_cmap_uni_pair_compare );
+
+        cmap->num_pairs = new_count;
+      }
+    }
+
+    return error;
+  }
+
+
+  FT_CALLBACK_DEF( void )
+  t1_cmap_unicode_done( T1_CMapUnicode  cmap )
+  {
+    FT_Face    face   = FT_CMAP_FACE(cmap);
+    FT_Memory  memory = FT_FACE_MEMORY(face);
+
+    FT_FREE( cmap->pairs );
+    cmap->num_pairs = 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_unicode_char_index( T1_CMapUnicode  cmap,
+                              FT_UInt32       char_code )
+  {
+    FT_UInt         min = 0;
+    FT_UInt         max = cmap->num_pairs;
+    FT_UInt         mid;
+    T1_CMapUniPair  pair;
+
+
+    while ( min < max )
+    {
+      mid  = min + ( max - min ) / 2;
+      pair = cmap->pairs + mid;
+
+      if ( pair->unicode == char_code )
+        return pair->gindex;
+
+      if ( pair->unicode < char_code )
+        min = mid + 1;
+      else
+        max = mid;
+    }
+    return 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  t1_cmap_unicode_char_next( T1_CMapUnicode  cmap,
+                             FT_UInt32      *pchar_code )
+  {
+    FT_UInt    result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+  Restart:
+    {
+      FT_UInt         min = 0;
+      FT_UInt         max = cmap->num_pairs;
+      FT_UInt         mid;
+      T1_CMapUniPair  pair;
+
+
+      while ( min < max )
+      {
+        mid  = min + ( ( max - min ) >> 1 );
+        pair = cmap->pairs + mid;
+
+        if ( pair->unicode == char_code )
+        {
+          result = pair->gindex;
+          if ( result != 0 )
+            goto Exit;
+
+          char_code++;
+          goto Restart;
+        }
+
+        if ( pair->unicode < char_code )
+          min = mid+1;
+        else
+          max = mid;
+      }
+
+      /* we didn't find it, but we have a pair just above it */
+      char_code = 0;
+
+      if ( min < cmap->num_pairs )
+      {
+        pair   = cmap->pairs + min;
+        result = pair->gindex;
+        if ( result != 0 )
+          char_code = pair->unicode;
+      }
+    }
+
+  Exit:
+    *pchar_code = char_code;
+    return result;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec
+  t1_cmap_unicode_class_rec =
+  {
+    sizeof ( T1_CMapUnicodeRec ),
+
+    (FT_CMap_InitFunc)     t1_cmap_unicode_init,
+    (FT_CMap_DoneFunc)     t1_cmap_unicode_done,
+    (FT_CMap_CharIndexFunc)t1_cmap_unicode_char_index,
+    (FT_CMap_CharNextFunc) t1_cmap_unicode_char_next
+  };
+
+
+/* END */
Index: xc/extras/freetype2/src/psaux/t1cmap.h
diff -u /dev/null xc/extras/freetype2/src/psaux/t1cmap.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:48 2003
+++ xc/extras/freetype2/src/psaux/t1cmap.h	Thu Jun 20 04:16:19 2002
@@ -0,0 +1,124 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1cmap.h                                                               */
+/*                                                                         */
+/*    Type 1 character map support (specification).                        */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T1CMAP_H__
+#define __T1CMAP_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****          TYPE1 STANDARD (AND EXPERT) ENCODING CMAPS           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* standard (and expert) encoding cmaps */
+  typedef struct T1_CMapStdRec_*  T1_CMapStd;
+
+  typedef struct  T1_CMapStdRec_
+  {
+    FT_CMapRec                 cmap;
+
+    const FT_UShort*           code_to_sid;
+    PS_Adobe_Std_Strings_Func  sid_to_string;
+
+    FT_UInt                    num_glyphs;
+    const char* const*         glyph_names;
+    
+  } T1_CMapStdRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_standard_class_rec;
+  
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_expert_class_rec;
+  
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  TYPE1 CUSTOM ENCODING CMAP                   *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct T1_CMapCustomRec_*  T1_CMapCustom;
+  
+  typedef struct  T1_CMapCustomRec_
+  {
+    FT_CMapRec  cmap;
+    FT_UInt     first;
+    FT_UInt     count;
+    FT_UShort*  indices;
+  
+  } T1_CMapCustomRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_custom_class_rec;
+  
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****             TYPE1 SYNTHETIC UNICODE ENCODING CMAP             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* unicode (syntehtic) cmaps */
+  typedef struct T1_CMapUnicodeRec_*  T1_CMapUnicode;
+
+  typedef struct  T1_CMapUniPairRec_
+  {
+    FT_UInt32  unicode;
+    FT_UInt    gindex;
+  
+  } T1_CMapUniPairRec, *T1_CMapUniPair;
+
+
+  typedef struct  T1_CMapUnicodeRec_
+  {
+    FT_CMapRec      cmap;
+    FT_UInt         num_pairs;
+    T1_CMapUniPair  pairs;
+
+  } T1_CMapUnicodeRec;
+
+
+  FT_CALLBACK_TABLE const FT_CMap_ClassRec
+  t1_cmap_unicode_class_rec;
+
+ /* */
+
+ 
+FT_END_HEADER
+
+#endif /* __T1CMAP_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/psaux/t1decode.c
diff -u xc/extras/freetype2/src/psaux/t1decode.c:1.1.1.5 xc/extras/freetype2/src/psaux/t1decode.c:1.1.1.6
--- xc/extras/freetype2/src/psaux/t1decode.c:1.1.1.5	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/psaux/t1decode.c	Thu Jun 20 04:16:19 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    PostScript Type 1 decoding routines (body).                          */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -70,6 +70,7 @@
 
   } T1_Operator;
 
+
   static
   const FT_Int  t1_args_count[op_max] =
   {
@@ -121,12 +122,12 @@
   /*    glyph wasn't found.                                                */
   /*                                                                       */
   static FT_Int
-  t1_lookup_glyph_by_stdcharcode( T1_Decoder*  decoder,
-                                  FT_Int       charcode )
+  t1_lookup_glyph_by_stdcharcode( T1_Decoder  decoder,
+                                  FT_Int      charcode )
   {
-    FT_UInt             n;
-    const FT_String*    glyph_name;
-    PSNames_Interface*  psnames = decoder->psnames;
+    FT_UInt           n;
+    const FT_String*  glyph_name;
+    PSNames_Service   psnames = decoder->psnames;
 
 
     /* check range of standard char code */
@@ -141,8 +142,8 @@
       FT_String*  name = (FT_String*)decoder->glyph_names[n];
 
 
-      if ( name && name[0] == glyph_name[0] &&
-           strcmp( name,glyph_name ) == 0 )
+      if ( name && name[0] == glyph_name[0]  &&
+           ft_strcmp( name,glyph_name ) == 0 )
         return n;
     }
 
@@ -175,16 +176,19 @@
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
   static FT_Error
-  t1operator_seac( T1_Decoder*  decoder,
-                   FT_Pos       asb,
-                   FT_Pos       adx,
-                   FT_Pos       ady,
-                   FT_Int       bchar,
-                   FT_Int       achar )
+  t1operator_seac( T1_Decoder  decoder,
+                   FT_Pos      asb,
+                   FT_Pos      adx,
+                   FT_Pos      ady,
+                   FT_Int      bchar,
+                   FT_Int      achar )
   {
     FT_Error     error;
-    FT_Int       bchar_index, achar_index, n_base_points;
+    FT_Int       bchar_index, achar_index;
+#if 0
+    FT_Int       n_base_points;
     FT_Outline*  base = decoder->builder.base;
+#endif
     FT_Vector    left_bearing, advance;
 
 
@@ -214,13 +218,13 @@
     /* accent character and return the array of subglyphs.         */
     if ( decoder->builder.no_recurse )
     {
-      FT_GlyphSlot     glyph  = (FT_GlyphSlot)decoder->builder.glyph;
-      FT_GlyphLoader*  loader = glyph->internal->loader;
-      FT_SubGlyph*     subg;
+      FT_GlyphSlot    glyph  = (FT_GlyphSlot)decoder->builder.glyph;
+      FT_GlyphLoader  loader = glyph->internal->loader;
+      FT_SubGlyph     subg;
 
 
       /* reallocate subglyph array if necessary */
-      error = FT_GlyphLoader_Check_Subglyphs( loader, 2 );
+      error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
       if ( error )
         goto Exit;
 
@@ -258,7 +262,9 @@
     if ( error )
       goto Exit;
 
+#if 0
     n_base_points = base->n_points;
+#endif
 
     /* save the left bearing and width of the base character */
     /* as they will be erased by the next load.              */
@@ -284,8 +290,8 @@
     decoder->builder.left_bearing = left_bearing;
     decoder->builder.advance      = advance;
 
-    /* XXX: old code doesn't work with postscript hinter */
-#if 0    
+    /* XXX: old code doesn't work with PostScript hinter */
+#if 0
     /* Finally, move the accent */
     if ( decoder->builder.load_points )
     {
@@ -297,7 +303,7 @@
 
       FT_Outline_Translate( &dummy, adx - asb, ady );
     }
-#else    
+#else
     decoder->builder.pos_x = 0;
     decoder->builder.pos_y = 0;
 #endif
@@ -325,19 +331,19 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  T1_Decoder_Parse_Charstrings( T1_Decoder*  decoder,
-                                FT_Byte*     charstring_base,
-                                FT_UInt      charstring_len )
+  FT_LOCAL_DEF( FT_Error )
+  T1_Decoder_Parse_Charstrings( T1_Decoder  decoder,
+                                FT_Byte*    charstring_base,
+                                FT_UInt     charstring_len )
   {
-    FT_Error          error;
-    T1_Decoder_Zone*  zone;
-    FT_Byte*          ip;
-    FT_Byte*          limit;
-    T1_Builder*       builder = &decoder->builder;
-    FT_Pos            x, y, orig_x, orig_y;
+    FT_Error         error;
+    T1_Decoder_Zone  zone;
+    FT_Byte*         ip;
+    FT_Byte*         limit;
+    T1_Builder       builder = &decoder->builder;
+    FT_Pos           x, y, orig_x, orig_y;
 
-    T1_Hints_Funcs    hinter;
+    T1_Hints_Funcs   hinter;
 
 
     /* we don't want to touch the source code -- use macro trick */
@@ -355,7 +361,7 @@
 
     builder->path_begun  = 0;
 
-    hinter = (T1_Hints_Funcs) builder->hints_funcs;
+    hinter = (T1_Hints_Funcs)builder->hints_funcs;
 
     zone->base           = charstring_base;
     limit = zone->limit  = charstring_base + charstring_len;
@@ -426,6 +432,10 @@
         op = op_endchar;
         break;
 
+      case 15:          /* undocumented, obsolete operator */
+        op = op_none;
+        break;
+
       case 21:
         op = op_rmoveto;
         break;
@@ -443,7 +453,7 @@
       case 12:
         if ( ip > limit )
         {
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                      "invalid escape (12+EOF)\n" ));
           goto Syntax_Error;
         }
@@ -479,7 +489,7 @@
           break;
 
         default:
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                      "invalid escape (12+%d)\n",
                      ip[-1] ));
           goto Syntax_Error;
@@ -489,7 +499,7 @@
       case 255:    /* four bytes integer */
         if ( ip + 4 > limit )
         {
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                      "unexpected EOF in integer\n" ));
           goto Syntax_Error;
         }
@@ -510,7 +520,7 @@
           {
             if ( ++ip > limit )
             {
-              FT_ERROR(( "T1_Decoder_Parse_CharStrings: " ));
+              FT_ERROR(( "T1_Decoder_Parse_Charstrings: " ));
               FT_ERROR(( "unexpected EOF in integer\n" ));
               goto Syntax_Error;
             }
@@ -523,7 +533,7 @@
         }
         else
         {
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                      "invalid byte (%d)\n", ip[-1] ));
           goto Syntax_Error;
         }
@@ -538,7 +548,7 @@
       {
         if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS )
         {
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: stack overflow!\n" ));
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: stack overflow!\n" ));
           goto Syntax_Error;
         }
 
@@ -570,20 +580,21 @@
 
         case 2:                     /* add flex vectors */
           {
-            FT_Int  index;
+            FT_Int  idx;
 
+
             if ( top[0] != 0 )
               goto Unexpected_OtherSubr;
 
             /* note that we should not add a point for index 0; */
             /* this will move our current position to the flex  */
             /* point without adding any point to the outline    */
-            index = decoder->num_flex_vectors++;
-            if ( index > 0 && index < 7 )
+            idx = decoder->num_flex_vectors++;
+            if ( idx > 0 && idx < 7 )
               add_point( builder,
                          x,
                          y,
-                         (FT_Byte)( index == 3 || index == 6 ) );
+                         (FT_Byte)( idx == 3 || idx == 6 ) );
           }
           break;
 
@@ -594,7 +605,7 @@
           if ( decoder->flex_state       == 0 ||
                decoder->num_flex_vectors != 7 )
           {
-            FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+            FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                        "unexpected flex end\n" ));
             goto Syntax_Error;
           }
@@ -605,7 +616,7 @@
                ip[2] != 12 || ip[3] != 17 || /* pop */
                ip[4] != 12 || ip[5] != 33 )  /* setcurpoint */
           {
-            FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+            FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                        "invalid flex charstring\n" ));
             goto Syntax_Error;
           }
@@ -621,22 +632,22 @@
           /* eat the following `pop' */
           if ( ip + 2 > limit )
           {
-            FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+            FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                        "invalid escape (12+%d)\n", ip[-1] ));
             goto Syntax_Error;
           }
 
           if ( ip[0] != 12 || ip[1] != 17 )
           {
-            FT_ERROR(( "T1_Decoder_Parse_CharStrings: " ));
+            FT_ERROR(( "T1_Decoder_Parse_Charstrings: " ));
             FT_ERROR(( "`pop' expected, found (%d %d)\n", ip[0], ip[1] ));
             goto Syntax_Error;
           }
           ip += 2;
-          
+
           if ( hinter )
             hinter->reset( hinter->hints, builder->current->n_points );
-            
+
           break;
 
         case 12:
@@ -651,15 +662,15 @@
         case 17:
         case 18:                    /* multiple masters */
           {
-            T1_Blend*  blend = decoder->blend;
-            FT_UInt    num_points, nn, mm;
-            FT_Long*   delta;
-            FT_Long*   values;
+            PS_Blend  blend = decoder->blend;
+            FT_UInt   num_points, nn, mm;
+            FT_Long*  delta;
+            FT_Long*  values;
 
 
             if ( !blend )
             {
-              FT_ERROR(( "T1_Decoder_Parse_CharStrings: " ));
+              FT_ERROR(( "T1_Decoder_Parse_Charstrings: " ));
               FT_ERROR(( "unexpected multiple masters operator!\n" ));
               goto Syntax_Error;
             }
@@ -667,12 +678,12 @@
             num_points = top[1] - 13 + ( top[1] == 18 );
             if ( top[0] != (FT_Int)( num_points * blend->num_designs ) )
             {
-              FT_ERROR(( "T1_Decoder_Parse_CharStrings: " ));
+              FT_ERROR(( "T1_Decoder_Parse_Charstrings: " ));
               FT_ERROR(( "incorrect number of mm arguments\n" ));
               goto Syntax_Error;
             }
 
-            top -= blend->num_designs*num_points;
+            top -= blend->num_designs * num_points;
             if ( top < decoder->stack )
               goto Stack_Underflow;
 
@@ -709,7 +720,7 @@
 
         default:
         Unexpected_OtherSubr:
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                      "invalid othersubr [%d %d]!\n", top[0], top[1] ));
           goto Syntax_Error;
         }
@@ -731,19 +742,19 @@
           FT_TRACE4(( " endchar" ));
 
           close_contour( builder );
-          
+
           /* close hints recording session */
           if ( hinter )
           {
             if (hinter->close( hinter->hints, builder->current->n_points ))
               goto Syntax_Error;
-            
+
             /* apply hints to the loaded glyph outline now */
             hinter->apply( hinter->hints,
                            builder->current,
                            (PSH_Globals)builder->hints_globals );
           }
-          
+
           /* add current outline to the glyph slot */
           FT_GlyphLoader_Add( builder->loader );
 
@@ -761,6 +772,8 @@
           orig_x = builder->last.x = x = builder->pos_x + top[0];
           orig_y = builder->last.y = y = builder->pos_y;
 
+          FT_UNUSED( orig_y );
+
           /* the `metrics_only' indicates that we only want to compute */
           /* the glyph's metrics (lsb + advance width), not load the   */
           /* rest of it; so exit immediately                           */
@@ -919,29 +932,29 @@
           }
           else
           {
-            FT_ERROR(( "T1_Decoder_Parse_CharStrings: division by 0\n" ));
+            FT_ERROR(( "T1_Decoder_Parse_Charstrings: division by 0\n" ));
             goto Syntax_Error;
           }
           break;
 
         case op_callsubr:
           {
-            FT_Int  index;
+            FT_Int  idx;
 
 
             FT_TRACE4(( " callsubr" ));
 
-            index = top[0];
-            if ( index < 0 || index >= (FT_Int)decoder->num_subrs )
+            idx = top[0];
+            if ( idx < 0 || idx >= (FT_Int)decoder->num_subrs )
             {
-              FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+              FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                          "invalid subrs index\n" ));
               goto Syntax_Error;
             }
 
             if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS )
             {
-              FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+              FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                          "too many nested subrs\n" ));
               goto Syntax_Error;
             }
@@ -953,23 +966,23 @@
             /* The Type 1 driver stores subroutines without the seed bytes. */
             /* The CID driver stores subroutines with seed bytes.  This     */
             /* case is taken care of when decoder->subrs_len == 0.          */
-            zone->base = decoder->subrs[index];
+            zone->base = decoder->subrs[idx];
 
             if ( decoder->subrs_len )
-              zone->limit = zone->base + decoder->subrs_len[index];
+              zone->limit = zone->base + decoder->subrs_len[idx];
             else
             {
               /* We are using subroutines from a CID font.  We must adjust */
               /* for the seed bytes.                                       */
               zone->base  += ( decoder->lenIV >= 0 ? decoder->lenIV : 0 );
-              zone->limit  = decoder->subrs[index + 1];
+              zone->limit  = decoder->subrs[idx + 1];
             }
 
             zone->cursor = zone->base;
 
             if ( !zone->base )
             {
-              FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+              FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                          "invoking empty subrs!\n" ));
               goto Syntax_Error;
             }
@@ -992,7 +1005,7 @@
 
           if ( zone <= decoder->zones )
           {
-            FT_ERROR(( "T1_Decoder_Parse_CharStrings: unexpected return\n" ));
+            FT_ERROR(( "T1_Decoder_Parse_Charstrings: unexpected return\n" ));
             goto Syntax_Error;
           }
 
@@ -1009,7 +1022,7 @@
 
         case op_hstem:
           FT_TRACE4(( " hstem" ));
-          
+
           /* record horizontal hint */
           if ( hinter )
           {
@@ -1025,7 +1038,7 @@
           /* record horizontal counter-controlled hints */
           if ( hinter )
             hinter->stem3( hinter->hints, 1, top );
-                           
+
           break;
 
         case op_vstem:
@@ -1047,7 +1060,8 @@
           if ( hinter )
           {
             FT_Pos  dx = orig_x;
-            
+
+
             top[0] += dx;
             top[2] += dx;
             top[4] += dx;
@@ -1058,12 +1072,12 @@
         case op_setcurrentpoint:
           FT_TRACE4(( " setcurrentpoint" ));
 
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: " ));
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: " ));
           FT_ERROR(( "unexpected `setcurrentpoint'\n" ));
           goto Syntax_Error;
 
         default:
-          FT_ERROR(( "T1_Decoder_Parse_CharStrings: "
+          FT_ERROR(( "T1_Decoder_Parse_Charstrings: "
                      "unhandled opcode %d\n", op ));
           goto Syntax_Error;
         }
@@ -1090,34 +1104,34 @@
 
 
   /* parse a single Type 1 glyph */
-  FT_LOCAL_DEF FT_Error
-  T1_Decoder_Parse_Glyph( T1_Decoder*  decoder,
-                          FT_UInt      glyph )
+  FT_LOCAL_DEF( FT_Error )
+  T1_Decoder_Parse_Glyph( T1_Decoder  decoder,
+                          FT_UInt     glyph )
   {
     return decoder->parse_callback( decoder, glyph );
   }
 
 
-  /* initialise T1 decoder */
-  FT_LOCAL_DEF FT_Error
-  T1_Decoder_Init( T1_Decoder*          decoder,
+  /* initialize T1 decoder */
+  FT_LOCAL_DEF( FT_Error )
+  T1_Decoder_Init( T1_Decoder           decoder,
                    FT_Face              face,
                    FT_Size              size,
                    FT_GlyphSlot         slot,
                    FT_Byte**            glyph_names,
-                   T1_Blend*            blend,
+                   PS_Blend             blend,
                    FT_Bool              hinting,
                    T1_Decoder_Callback  parse_callback )
   {
-    MEM_Set( decoder, 0, sizeof ( *decoder ) );
+    FT_MEM_SET( decoder, 0, sizeof ( *decoder ) );
 
     /* retrieve PSNames interface from list of current modules */
     {
-      PSNames_Interface*  psnames = 0;
+      PSNames_Service  psnames = 0;
 
 
-      psnames = (PSNames_Interface*)FT_Get_Module_Interface(
-                   FT_FACE_LIBRARY(face), "psnames" );
+      psnames = (PSNames_Service)FT_Get_Module_Interface(
+                  FT_FACE_LIBRARY(face), "psnames" );
       if ( !psnames )
       {
         FT_ERROR(( "T1_Decoder_Init: " ));
@@ -1127,6 +1141,7 @@
 
       decoder->psnames = psnames;
     }
+
     T1_Builder_Init( &decoder->builder, face, size, slot, hinting );
 
     decoder->num_glyphs     = face->num_glyphs;
@@ -1134,15 +1149,15 @@
     decoder->blend          = blend;
     decoder->parse_callback = parse_callback;
 
-    decoder->funcs       = t1_decoder_funcs;
+    decoder->funcs          = t1_decoder_funcs;
 
     return 0;
   }
 
 
   /* finalize T1 decoder */
-  FT_LOCAL_DEF void
-  T1_Decoder_Done( T1_Decoder*  decoder )
+  FT_LOCAL_DEF( void )
+  T1_Decoder_Done( T1_Decoder  decoder )
   {
     T1_Builder_Done( &decoder->builder );
   }
Index: xc/extras/freetype2/src/psaux/t1decode.h
diff -u xc/extras/freetype2/src/psaux/t1decode.h:1.1.1.4 xc/extras/freetype2/src/psaux/t1decode.h:1.1.1.5
--- xc/extras/freetype2/src/psaux/t1decode.h:1.1.1.4	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/psaux/t1decode.h	Thu Jun 20 04:16:19 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    PostScript Type 1 decoding routines (specification).                 */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -30,30 +30,30 @@
 
 
   FT_CALLBACK_TABLE
-  const T1_Decoder_Funcs  t1_decoder_funcs;
+  const T1_Decoder_FuncsRec  t1_decoder_funcs;
 
 
-  FT_LOCAL FT_Error
-  T1_Decoder_Parse_Glyph( T1_Decoder*  decoder,
-                          FT_UInt      glyph_index );
+  FT_LOCAL( FT_Error )
+  T1_Decoder_Parse_Glyph( T1_Decoder  decoder,
+                          FT_UInt     glyph_index );
 
-  FT_LOCAL FT_Error
-  T1_Decoder_Parse_Charstrings( T1_Decoder*  decoder,
-                                FT_Byte*     base,
-                                FT_UInt      len );
+  FT_LOCAL( FT_Error )
+  T1_Decoder_Parse_Charstrings( T1_Decoder  decoder,
+                                FT_Byte*    base,
+                                FT_UInt     len );
 
-  FT_LOCAL FT_Error
-  T1_Decoder_Init( T1_Decoder*          decoder,
+  FT_LOCAL( FT_Error )
+  T1_Decoder_Init( T1_Decoder           decoder,
                    FT_Face              face,
                    FT_Size              size,
                    FT_GlyphSlot         slot,
                    FT_Byte**            glyph_names,
-                   T1_Blend*            blend,
+                   PS_Blend             blend,
                    FT_Bool              hinting,
                    T1_Decoder_Callback  parse_glyph );
 
-  FT_LOCAL void
-  T1_Decoder_Done( T1_Decoder*  decoder );
+  FT_LOCAL( void )
+  T1_Decoder_Done( T1_Decoder  decoder );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/pshinter/descrip.mms
diff -u xc/extras/freetype2/src/pshinter/descrip.mms:1.1.1.1 xc/extras/freetype2/src/pshinter/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/pshinter/descrip.mms:1.1.1.1	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/pshinter/descrip.mms	Thu Jun 20 04:16:19 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -20,4 +20,4 @@
 all : $(OBJS)
         library [--.lib]freetype.olb $(OBJS)
 
-# EOF
\ No newline at end of file
+# EOF
Index: xc/extras/freetype2/src/pshinter/pshalgo1.c
diff -u xc/extras/freetype2/src/pshinter/pshalgo1.c:1.1.1.1 xc/extras/freetype2/src/pshinter/pshalgo1.c:1.1.1.3
--- xc/extras/freetype2/src/pshinter/pshalgo1.c:1.1.1.1	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/pshinter/pshalgo1.c	Thu Jun 20 04:16:19 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    PostScript hinting algorithm 1 (body).                               */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used        */
@@ -53,12 +53,12 @@
   psh1_hint_table_done( PSH1_Hint_Table  table,
                         FT_Memory        memory )
   {
-    FREE( table->zones );
+    FT_FREE( table->zones );
     table->num_zones = 0;
     table->zone      = 0;
 
-    FREE( table->sort );
-    FREE( table->hints );
+    FT_FREE( table->sort );
+    FT_FREE( table->hints );
     table->num_hints   = 0;
     table->max_hints   = 0;
     table->sort_global = 0;
@@ -84,14 +84,14 @@
   /* internal function used to record a new hint */
   static void
   psh1_hint_table_record( PSH1_Hint_Table  table,
-                          FT_UInt          index )
+                          FT_UInt          idx )
   {
-    PSH1_Hint  hint = table->hints + index;
+    PSH1_Hint  hint = table->hints + idx;
 
 
-    if ( index >= table->max_hints )
+    if ( idx >= table->max_hints )
     {
-      FT_ERROR(( "%s.activate: invalid hint index %d\n", index ));
+      FT_ERROR(( "%s.activate: invalid hint index %d\n", idx ));
       return;
     }
 
@@ -136,7 +136,7 @@
   {
     FT_Int    mask = 0, val = 0;
     FT_Byte*  cursor = hint_mask->bytes;
-    FT_UInt   index, limit;
+    FT_UInt   idx, limit;
 
 
     limit = hint_mask->num_bits;
@@ -145,7 +145,7 @@
       FT_ERROR(( "%s.activate_mask: invalid bit count (%d instead of %d)\n",
                  "ps.fitter", hint_mask->num_bits, table->max_hints ));
 
-    for ( index = 0; index < limit; index++ )
+    for ( idx = 0; idx < limit; idx++ )
     {
       if ( mask == 0 )
       {
@@ -154,7 +154,7 @@
       }
 
       if ( val & mask )
-        psh1_hint_table_record( table, index );
+        psh1_hint_table_record( table, idx );
 
       mask >>= 1;
     }
@@ -176,9 +176,9 @@
 
 
     /* allocate our tables */
-    if ( ALLOC_ARRAY( table->sort,  2 * count,     PSH1_Hint    ) ||
-         ALLOC_ARRAY( table->hints,     count,     PSH1_HintRec ) ||
-         ALLOC_ARRAY( table->zones, 2 * count + 1, PSH1_ZoneRec ) )
+    if ( FT_NEW_ARRAY( table->sort,  2 * count     ) ||
+         FT_NEW_ARRAY( table->hints,     count     ) ||
+         FT_NEW_ARRAY( table->zones, 2 * count + 1 ) )
       goto Exit;
 
     table->max_hints   = count;
@@ -238,7 +238,7 @@
   {
     FT_Int    mask = 0, val = 0;
     FT_Byte*  cursor = hint_mask->bytes;
-    FT_UInt   index, limit, count;
+    FT_UInt   idx, limit, count;
 
 
     limit = hint_mask->num_bits;
@@ -246,7 +246,7 @@
 
     psh1_hint_table_deactivate( table );
 
-    for ( index = 0; index < limit; index++ )
+    for ( idx = 0; idx < limit; idx++ )
     {
       if ( mask == 0 )
       {
@@ -256,7 +256,7 @@
 
       if ( val & mask )
       {
-        PSH1_Hint  hint = &table->hints[index];
+        PSH1_Hint  hint = &table->hints[idx];
 
 
         if ( !psh1_hint_is_active( hint ) )
@@ -356,7 +356,7 @@
 #endif
 
 
-  FT_LOCAL_DEF  FT_Error
+  FT_LOCAL_DEF( FT_Error )
   psh1_hint_table_optimize( PSH1_Hint_Table  table,
                             PSH_Globals      globals,
                             FT_Outline*      outline,
@@ -415,7 +415,7 @@
           hint->cur_len = fit_len;
 
           /* check blue zones for horizontal stems */
-          align.align     = 0;
+          align.align     = PSH_BLUE_ALIGN_NONE;
           align.align_bot = align.align_top = 0;
           if ( !vertical )
           {
@@ -498,7 +498,7 @@
 #include <stdio.h>
 
   static void
-  print_zone( PSH1_Zone  zone )
+  psh1_print_zone( PSH1_Zone  zone )
   {
     printf( "zone [scale,delta,min,max] = [%.3f,%.3f,%d,%d]\n",
              zone->scale / 65536.0,
@@ -508,7 +508,7 @@
   }
 
 #else
-#define print_zone( x )  do { } while ( 0 )
+#define psh1_print_zone( x )  do { } while ( 0 )
 #endif
 
   /* setup interpolation zones once the hints have been grid-fitted */
@@ -549,7 +549,7 @@
     zone->min   = PSH1_ZONE_MIN;
     zone->max   = hint->org_pos;
 
-    print_zone( zone );
+    psh1_print_zone( zone );
 
     zone++;
 
@@ -570,7 +570,7 @@
         zone->max   = hint->org_pos + hint->org_len;
         zone->delta = hint->cur_pos - FT_MulFix( zone->min, scale2 );
 
-        print_zone( zone );
+        psh1_print_zone( zone );
 
         zone++;
       }
@@ -593,7 +593,7 @@
       zone->delta = hint->cur_pos + hint->cur_len -
                     FT_MulFix( zone->min, scale2 );
 
-      print_zone( zone );
+      psh1_print_zone( zone );
 
       zone++;
 
@@ -607,7 +607,7 @@
     zone->delta = hint->cur_pos + hint->cur_len -
                   FT_MulFix( zone->min, scale );
 
-    print_zone( zone );
+    psh1_print_zone( zone );
 
     zone++;
 
@@ -757,7 +757,7 @@
 
 
       /* initialize hints table */
-      memset( &hints, 0, sizeof ( hints ) );
+      ft_memset( &hints, 0, sizeof ( hints ) );
       error = psh1_hint_table_init( &hints,
                                     &dim->hints,
                                     &dim->masks,
Index: xc/extras/freetype2/src/pshinter/pshalgo2.c
diff -u xc/extras/freetype2/src/pshinter/pshalgo2.c:1.1.1.1 xc/extras/freetype2/src/pshinter/pshalgo2.c:1.1.1.4
--- xc/extras/freetype2/src/pshinter/pshalgo2.c:1.1.1.1	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/pshinter/pshalgo2.c	Thu Jun 20 04:16:19 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    PostScript hinting algorithm 2 (body).                               */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used        */
@@ -54,12 +54,12 @@
   psh2_hint_table_done( PSH2_Hint_Table  table,
                         FT_Memory        memory )
   {
-    FREE( table->zones );
+    FT_FREE( table->zones );
     table->num_zones = 0;
     table->zone      = 0;
 
-    FREE( table->sort );
-    FREE( table->hints );
+    FT_FREE( table->sort );
+    FT_FREE( table->hints );
     table->num_hints   = 0;
     table->max_hints   = 0;
     table->sort_global = 0;
@@ -85,14 +85,14 @@
   /* internal function used to record a new hint */
   static void
   psh2_hint_table_record( PSH2_Hint_Table  table,
-                          FT_UInt          index )
+                          FT_UInt          idx )
   {
-    PSH2_Hint  hint = table->hints + index;
+    PSH2_Hint  hint = table->hints + idx;
 
 
-    if ( index >= table->max_hints )
+    if ( idx >= table->max_hints )
     {
-      FT_ERROR(( "%s.activate: invalid hint index %d\n", index ));
+      FT_ERROR(( "%s.activate: invalid hint index %d\n", idx ));
       return;
     }
 
@@ -137,12 +137,12 @@
   {
     FT_Int    mask = 0, val = 0;
     FT_Byte*  cursor = hint_mask->bytes;
-    FT_UInt   index, limit;
+    FT_UInt   idx, limit;
 
 
     limit = hint_mask->num_bits;
 
-    for ( index = 0; index < limit; index++ )
+    for ( idx = 0; idx < limit; idx++ )
     {
       if ( mask == 0 )
       {
@@ -151,7 +151,7 @@
       }
 
       if ( val & mask )
-        psh2_hint_table_record( table, index );
+        psh2_hint_table_record( table, idx );
 
       mask >>= 1;
     }
@@ -173,9 +173,9 @@
 
 
     /* allocate our tables */
-    if ( ALLOC_ARRAY( table->sort,  2 * count,     PSH2_Hint    ) ||
-         ALLOC_ARRAY( table->hints,     count,     PSH2_HintRec ) ||
-         ALLOC_ARRAY( table->zones, 2 * count + 1, PSH2_ZoneRec ) )
+    if ( FT_NEW_ARRAY( table->sort,  2 * count     ) ||
+         FT_NEW_ARRAY( table->hints,     count     ) ||
+         FT_NEW_ARRAY( table->zones, 2 * count + 1 ) )
       goto Exit;
 
     table->max_hints   = count;
@@ -235,7 +235,7 @@
   {
     FT_Int    mask = 0, val = 0;
     FT_Byte*  cursor = hint_mask->bytes;
-    FT_UInt   index, limit, count;
+    FT_UInt   idx, limit, count;
 
 
     limit = hint_mask->num_bits;
@@ -243,7 +243,7 @@
 
     psh2_hint_table_deactivate( table );
 
-    for ( index = 0; index < limit; index++ )
+    for ( idx = 0; idx < limit; idx++ )
     {
       if ( mask == 0 )
       {
@@ -253,7 +253,7 @@
 
       if ( val & mask )
       {
-        PSH2_Hint  hint = &table->hints[index];
+        PSH2_Hint  hint = &table->hints[idx];
 
 
         if ( !psh2_hint_is_active( hint ) )
@@ -387,7 +387,7 @@
       hint->cur_len = fit_len;
 
       /* check blue zones for horizontal stems */
-      align.align = 0;
+      align.align = PSH_BLUE_ALIGN_NONE;
       align.align_bot = align.align_top = 0;
 
       if ( dimension == 1 )
@@ -523,7 +523,7 @@
 #include <stdio.h>
 
   static void
-  print_zone( PSH2_Zone  zone )
+  psh2_print_zone( PSH2_Zone  zone )
   {
     printf( "zone [scale,delta,min,max] = [%.3f,%.3f,%d,%d]\n",
              zone->scale/65536.0,
@@ -534,7 +534,7 @@
 
 #else
 
-#define print_zone( x )   do { } while ( 0 )
+#define psh2_print_zone( x )   do { } while ( 0 )
 
 #endif
 
@@ -576,7 +576,7 @@
     zone->min   = PSH2_ZONE_MIN;
     zone->max   = hint->org_pos;
 
-    print_zone( zone );
+    psh2_print_zone( zone );
 
     zone++;
 
@@ -597,7 +597,7 @@
         zone->max   = hint->org_pos + hint->org_len;
         zone->delta = hint->cur_pos - FT_MulFix( zone->min, scale2 );
 
-        print_zone( zone );
+        psh2_print_zone( zone );
 
         zone++;
       }
@@ -620,7 +620,7 @@
       zone->delta = hint->cur_pos + hint->cur_len -
                     FT_MulFix( zone->min, scale2 );
 
-      print_zone( zone );
+      psh2_print_zone( zone );
 
       zone++;
 
@@ -634,7 +634,7 @@
     zone->delta = hint->cur_pos + hint->cur_len -
                   FT_MulFix( zone->min, scale );
 
-    print_zone( zone );
+    psh2_print_zone( zone );
 
     zone++;
 
@@ -814,8 +814,8 @@
     psh2_hint_table_done( &glyph->hint_tables[1], memory );
     psh2_hint_table_done( &glyph->hint_tables[0], memory );
 
-    FREE( glyph->points );
-    FREE( glyph->contours );
+    FT_FREE( glyph->points );
+    FT_FREE( glyph->contours );
 
     glyph->num_points   = 0;
     glyph->num_contours = 0;
@@ -861,15 +861,13 @@
 
 
     /* clear all fields */
-    memset( glyph, 0, sizeof ( *glyph ) );
+    ft_memset( glyph, 0, sizeof ( *glyph ) );
 
     memory = globals->memory;
 
     /* allocate and setup points + contours arrays */
-    if ( ALLOC_ARRAY( glyph->points,   outline->n_points,
-                      PSH2_PointRec   )                     ||
-         ALLOC_ARRAY( glyph->contours, outline->n_contours,
-                      PSH2_ContourRec )                     )
+    if ( FT_NEW_ARRAY( glyph->points,   outline->n_points   ) ||
+         FT_NEW_ARRAY( glyph->contours, outline->n_contours ) )
       goto Exit;
 
     glyph->num_points   = outline->n_points;
@@ -1044,7 +1042,7 @@
         vec[n].y = point->cur_u;
 
       if ( psh2_point_is_strong( point ) )
-        tags[n] |= (char)((dimension == 0) ? 32 : 64);
+        tags[n] |= (char)( ( dimension == 0 ) ? 32 : 64 );
 
 #ifdef DEBUG_HINTER
       if ( dimension == 0 )
@@ -1500,19 +1498,22 @@
     PSH2_GlyphRec  glyphrec;
     PSH2_Glyph     glyph = &glyphrec;
     FT_Error       error;
+#ifdef DEBUG_HINTER
     FT_Memory      memory;
+#endif
     FT_Int         dimension;
 
-    memory = globals->memory;
 
 #ifdef DEBUG_HINTER
+    memory = globals->memory;
+
     if ( ps2_debug_glyph )
     {
       psh2_glyph_done( ps2_debug_glyph );
-      FREE( ps2_debug_glyph );
+      FT_FREE( ps2_debug_glyph );
     }
 
-    if ( ALLOC( glyph, sizeof ( *glyph ) ) )
+    if ( FT_NEW( glyph ) )
       return error;
 
     ps2_debug_glyph = glyph;
Index: xc/extras/freetype2/src/pshinter/pshglob.c
diff -u xc/extras/freetype2/src/pshinter/pshglob.c:1.1.1.1 xc/extras/freetype2/src/pshinter/pshglob.c:1.1.1.3
--- xc/extras/freetype2/src/pshinter/pshglob.c:1.1.1.1	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/pshinter/pshglob.c	Thu Jun 20 04:16:20 2002
@@ -5,7 +5,7 @@
 /*    PostScript hinter global hinting management (body).                  */
 /*    Inspired by the new auto-hinter module.                              */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used        */
@@ -42,22 +42,44 @@
                             FT_UInt      direction )
   {
     PSH_Dimension  dim   = &globals->dimension[direction];
-    PSH_Widths     std   = &dim->std;
-    FT_UInt        count = std->count;
-    PSH_Width      width = std->widths;
+    PSH_Widths     stdw  = &dim->stdw;
+    FT_UInt        count = stdw->count;
+    PSH_Width      width = stdw->widths;
+    PSH_Width      stand = width;               /* standard width/height */
     FT_Fixed       scale = dim->scale_mult;
 
 
-    for ( ; count > 0; count--, width++ )
+    if ( count > 0 )
     {
       width->cur = FT_MulFix( width->org, scale );
       width->fit = FT_RoundFix( width->cur );
+
+      width++;
+      count--;
+
+      for ( ; count > 0; count--, width++ )
+      {
+        FT_Pos  w, dist;
+
+
+        w    = FT_MulFix( width->org, scale );
+        dist = w - stand->cur;
+
+        if ( dist < 0 )
+          dist = -dist;
+
+        if ( dist < 128 )
+          w = stand->cur;
+
+        width->cur = w;
+        width->fit = FT_RoundFix( w );
+      }
     }
   }
 
 
   /* org_width is is font units, result in device pixels, 26.6 format */
-  FT_LOCAL_DEF FT_Pos
+  FT_LOCAL_DEF( FT_Pos )
   psh_dimension_snap_width( PSH_Dimension  dimension,
                             FT_Int         org_width )
   {
@@ -67,13 +89,13 @@
     FT_Pos   reference = width;
 
 
-    for ( n = 0; n < dimension->std.count; n++ )
+    for ( n = 0; n < dimension->stdw.count; n++ )
     {
       FT_Pos  w;
       FT_Pos  dist;
 
 
-      w = dimension->std.widths[n].cur;
+      w = dimension->stdw.widths[n].cur;
       dist = width - w;
       if ( dist < 0 )
         dist = -dist;
@@ -466,7 +488,14 @@
 
         for ( ; count2 > 0; count2--, zone2++ )
         {
-          if ( FT_MulFix( zone1->org_ref - zone2->org_ref, scale ) < 64 )
+          FT_Pos  Delta;
+
+
+          Delta = zone1->org_ref - zone2->org_ref;
+          if ( Delta < 0 )
+            Delta = -Delta;
+
+          if ( FT_MulFix( Delta, scale ) < 64 )
           {
             zone1->cur_top    = zone2->cur_top;
             zone1->cur_bottom = zone2->cur_bottom;
@@ -480,7 +509,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   psh_blues_snap_stem( PSH_Blues      blues,
                        FT_Int         stem_top,
                        FT_Int         stem_bot,
@@ -493,7 +522,7 @@
     FT_Int          no_shoots;
 
 
-    alignment->align = 0;
+    alignment->align = PSH_BLUE_ALIGN_NONE;
 
     no_shoots = blues->no_overshoots;
 
@@ -560,15 +589,15 @@
 
 
       memory = globals->memory;
-      globals->dimension[0].std.count = 0;
-      globals->dimension[1].std.count = 0;
+      globals->dimension[0].stdw.count = 0;
+      globals->dimension[1].stdw.count = 0;
 
       globals->blues.normal_top.count    = 0;
       globals->blues.normal_bottom.count = 0;
       globals->blues.family_top.count    = 0;
       globals->blues.family_bottom.count = 0;
 
-      FREE( globals );
+      FT_FREE( globals );
 
 #ifdef DEBUG_HINTER
       ps_debug_globals = 0;
@@ -586,7 +615,7 @@
     FT_Error     error;
 
 
-    if ( !ALLOC( globals, sizeof ( *globals ) ) )
+    if ( !FT_NEW( globals ) )
     {
       FT_UInt    count;
       FT_Short*  read;
@@ -597,7 +626,7 @@
       /* copy standard widths */
       {
         PSH_Dimension  dim   = &globals->dimension[1];
-        PSH_Width      write = dim->std.widths;
+        PSH_Width      write = dim->stdw.widths;
 
 
         write->org = priv->standard_width[1];
@@ -611,13 +640,13 @@
           read++;
         }
 
-        dim->std.count = write - dim->std.widths;
+        dim->stdw.count = write - dim->stdw.widths;
       }
 
       /* copy standard heights */
       {
         PSH_Dimension  dim = &globals->dimension[0];
-        PSH_Width      write = dim->std.widths;
+        PSH_Width      write = dim->stdw.widths;
 
 
         write->org = priv->standard_height[1];
@@ -631,7 +660,7 @@
           read++;
         }
 
-        dim->std.count = write - dim->std.widths;
+        dim->stdw.count = write - dim->stdw.widths;
       }
 
       /* copy blue zones */
@@ -701,7 +730,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   psh_globals_funcs_init( PSH_Globals_FuncsRec*  funcs )
   {
     funcs->create    = psh_globals_new;
Index: xc/extras/freetype2/src/pshinter/pshglob.h
diff -u xc/extras/freetype2/src/pshinter/pshglob.h:1.1.1.1 xc/extras/freetype2/src/pshinter/pshglob.h:1.1.1.3
--- xc/extras/freetype2/src/pshinter/pshglob.h:1.1.1.1	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/pshinter/pshglob.h	Thu Jun 20 04:16:20 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    PostScript hinter global hinting management.                         */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -21,7 +21,6 @@
 
 
 #include FT_FREETYPE_H
-#include FT_INTERNAL_POSTSCRIPT_GLOBALS_H
 #include FT_INTERNAL_POSTSCRIPT_HINTS_H
 
 
@@ -82,7 +81,7 @@
 
   typedef struct  PSH_DimensionRec_
   {
-    PSH_WidthsRec  std;
+    PSH_WidthsRec  stdw;
     FT_Fixed       scale_mult;
     FT_Fixed       scale_delta;
 
@@ -141,35 +140,32 @@
   } PSH_GlobalsRec;
 
 
-  typedef enum
-  {
-    PSH_BLUE_ALIGN_TOP = 1,
-    PSH_BLUE_ALIGN_BOT = 2
-
-  } PSH_Blue_Align;
+#define PSH_BLUE_ALIGN_NONE  0
+#define PSH_BLUE_ALIGN_TOP   1
+#define PSH_BLUE_ALIGN_BOT   2
 
 
   typedef struct  PSH_AlignmentRec_
   {
-    PSH_Blue_Align  align;
-    FT_Pos          align_top;
-    FT_Pos          align_bot;
+    int     align;
+    FT_Pos  align_top;
+    FT_Pos  align_bot;
 
   } PSH_AlignmentRec, *PSH_Alignment;
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   psh_globals_funcs_init( PSH_Globals_FuncsRec*  funcs );
 
 
   /* snap a stem width to fitter coordinates.  `org_width' is in font */
   /* units.  The result is in device pixels (26.6 format).            */
-  FT_LOCAL FT_Pos
+  FT_LOCAL( FT_Pos )
   psh_dimension_snap_width( PSH_Dimension  dimension,
                             FT_Int         org_width );
 
   /* snap a stem to one or two blue zones */
-  FT_LOCAL void
+  FT_LOCAL( void )
   psh_blues_snap_stem( PSH_Blues      blues,
                        FT_Int         stem_top,
                        FT_Int         stem_bot,
Index: xc/extras/freetype2/src/pshinter/pshmod.c
diff -u xc/extras/freetype2/src/pshinter/pshmod.c:1.1.1.1 xc/extras/freetype2/src/pshinter/pshmod.c:1.1.1.3
--- xc/extras/freetype2/src/pshinter/pshmod.c:1.1.1.1	Mon Jan 14 11:52:14 2002
+++ xc/extras/freetype2/src/pshinter/pshmod.c	Thu Jun 20 04:16:20 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType PostScript hinter module implementation (body).             */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -91,8 +91,8 @@
   }
 
 
-  FT_CALLBACK_DEF( PSHinter_Interface )
-  pshinter_interface =
+  static
+  const PSHinter_Interface  pshinter_interface =
   {
     pshinter_get_globals_funcs,
     pshinter_get_t1_funcs,
Index: xc/extras/freetype2/src/pshinter/pshrec.c
diff -u xc/extras/freetype2/src/pshinter/pshrec.c:1.1.1.1 xc/extras/freetype2/src/pshinter/pshrec.c:1.1.1.2
--- xc/extras/freetype2/src/pshinter/pshrec.c:1.1.1.1	Mon Jan 14 11:52:15 2002
+++ xc/extras/freetype2/src/pshinter/pshrec.c	Thu Jun 20 04:16:20 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType PostScript hints recorder (body).                           */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -46,7 +46,7 @@
   ps_hint_table_done( PS_Hint_Table  table,
                       FT_Memory      memory )
   {
-    FREE( table->hints );
+    FT_FREE( table->hints );
     table->num_hints = 0;
     table->max_hints = 0;
   }
@@ -67,7 +67,7 @@
     {
       /* try to grow the table */
       new_max = ( new_max + 7 ) & -8;
-      if ( !REALLOC_ARRAY( table->hints, old_max, new_max, PS_HintRec ) )
+      if ( !FT_RENEW_ARRAY( table->hints, old_max, new_max ) )
         table->max_hints = new_max;
     }
     return error;
@@ -120,7 +120,7 @@
   ps_mask_done( PS_Mask    mask,
                 FT_Memory  memory )
   {
-    FREE( mask->bytes );
+    FT_FREE( mask->bytes );
     mask->num_bits  = 0;
     mask->max_bits  = 0;
     mask->end_point = 0;
@@ -141,7 +141,7 @@
     if ( new_max > old_max )
     {
       new_max = ( new_max + 7 ) & -8;
-      if ( !REALLOC_ARRAY( mask->bytes, old_max, new_max, FT_Byte ) )
+      if ( !FT_RENEW_ARRAY( mask->bytes, old_max, new_max ) )
         mask->max_bits = new_max * 8;
     }
     return error;
@@ -151,55 +151,55 @@
   /* test a bit value in a given mask */
   static FT_Int
   ps_mask_test_bit( PS_Mask  mask,
-                    FT_Int   index )
+                    FT_Int   idx )
   {
-    if ( (FT_UInt)index >= mask->num_bits )
+    if ( (FT_UInt)idx >= mask->num_bits )
       return 0;
 
-    return mask->bytes[index >> 3] & ( 0x80 >> ( index & 7 ) );
+    return mask->bytes[idx >> 3] & ( 0x80 >> ( idx & 7 ) );
   }
 
 
   /* clear a given bit */
   static void
   ps_mask_clear_bit( PS_Mask  mask,
-                     FT_Int   index )
+                     FT_Int   idx )
   {
     FT_Byte*  p;
 
 
-    if ( (FT_UInt)index >= mask->num_bits )
+    if ( (FT_UInt)idx >= mask->num_bits )
       return;
 
-    p    = mask->bytes + ( index >> 3 );
-    p[0] = (FT_Byte)( p[0] & ~( 0x80 >> ( index & 7 ) ) );
+    p    = mask->bytes + ( idx >> 3 );
+    p[0] = (FT_Byte)( p[0] & ~( 0x80 >> ( idx & 7 ) ) );
   }
 
 
   /* set a given bit, possibly grow the mask */
   static FT_Error
   ps_mask_set_bit( PS_Mask    mask,
-                   FT_Int     index,
+                   FT_Int     idx,
                    FT_Memory  memory )
   {
     FT_Error  error = 0;
     FT_Byte*  p;
 
 
-    if ( index < 0 )
+    if ( idx < 0 )
       goto Exit;
 
-    if ( (FT_UInt)index >= mask->num_bits )
+    if ( (FT_UInt)idx >= mask->num_bits )
     {
-      error = ps_mask_ensure( mask, index + 1, memory );
+      error = ps_mask_ensure( mask, idx + 1, memory );
       if ( error )
         goto Exit;
 
-      mask->num_bits = index + 1;
+      mask->num_bits = idx + 1;
     }
 
-    p    = mask->bytes + ( index >> 3 );
-    p[0] = (FT_Byte)( p[0] | ( 0x80 >> ( index & 7 ) ) );
+    p    = mask->bytes + ( idx >> 3 );
+    p[0] = (FT_Byte)( p[0] | ( 0x80 >> ( idx & 7 ) ) );
 
   Exit:
     return error;
@@ -218,7 +218,7 @@
     for ( ; count > 0; count--, mask++ )
       ps_mask_done( mask, memory );
 
-    FREE( table->masks );
+    FT_FREE( table->masks );
     table->num_masks = 0;
     table->max_masks = 0;
   }
@@ -238,7 +238,7 @@
     if ( new_max > old_max )
     {
       new_max = ( new_max + 7 ) & -8;
-      if ( !REALLOC_ARRAY( table->masks, old_max, new_max, PS_MaskRec ) )
+      if ( !FT_RENEW_ARRAY( table->masks, old_max, new_max ) )
         table->max_masks = new_max;
     }
     return error;
@@ -414,7 +414,7 @@
     {
       temp   = index1;
       index1 = index2;
-      index2 = index1;
+      index2 = temp;
     }
 
     if ( index1 < index2 && index1 >= 0 && index2 < (FT_Int)table->num_masks )
@@ -472,7 +472,7 @@
         PS_MaskRec  dummy = *mask2;
 
 
-        memmove( mask2, mask2 + 1, delta * sizeof ( PS_MaskRec ) );
+        ft_memmove( mask2, mask2 + 1, delta * sizeof ( PS_MaskRec ) );
 
         mask2[delta] = dummy;
       }
@@ -554,7 +554,7 @@
   /* set a bit at a given index in the current hint mask */
   static FT_Error
   ps_dimension_set_mask_bit( PS_Dimension  dim,
-                             FT_UInt       index,
+                             FT_UInt       idx,
                              FT_Memory     memory )
   {
     PS_Mask  mask;
@@ -566,7 +566,7 @@
     if ( error )
       goto Exit;
 
-    error = ps_mask_set_bit( mask, index, memory );
+    error = ps_mask_set_bit( mask, idx, memory );
 
   Exit:
     return error;
@@ -665,19 +665,19 @@
     /* now, lookup stem in the current hints table */
     {
       PS_Mask  mask;
-      FT_UInt  index;
+      FT_UInt  idx;
       FT_UInt  max   = dim->hints.num_hints;
       PS_Hint  hint  = dim->hints.hints;
 
 
-      for ( index = 0; index < max; index++, hint++ )
+      for ( idx = 0; idx < max; idx++, hint++ )
       {
         if ( hint->pos == pos && hint->len == len )
           break;
       }
 
       /* we need to create a new hint in the table */
-      if ( index >= max )
+      if ( idx >= max )
       {
         error = ps_hint_table_alloc( &dim->hints, memory, &hint );
         if ( error )
@@ -693,12 +693,12 @@
       if ( error )
         goto Exit;
 
-      error = ps_mask_set_bit( mask, index, memory );
+      error = ps_mask_set_bit( mask, idx, memory );
       if ( error )
         goto Exit;
 
       if ( aindex )
-        *aindex = (FT_Int)index;
+        *aindex = (FT_Int)idx;
     }
 
   Exit:
@@ -779,7 +779,7 @@
 
 
   /* destroy hints */
-  FT_LOCAL void
+  FT_LOCAL( void )
   ps_hints_done( PS_Hints  hints )
   {
     FT_Memory  memory = hints->memory;
@@ -793,11 +793,11 @@
   }
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   ps_hints_init( PS_Hints   hints,
                  FT_Memory  memory )
   {
-    memset( hints, 0, sizeof ( *hints ) );
+    ft_memset( hints, 0, sizeof ( *hints ) );
     hints->memory = memory;
     return 0;
   }
@@ -898,7 +898,7 @@
       PS_Dimension  dim;
       FT_Memory     memory = hints->memory;
       FT_Int        count;
-      FT_Int        index[3];
+      FT_Int        idx[3];
 
 
       /* limit "dimension" to 0..1 */
@@ -918,14 +918,14 @@
         for ( count = 0; count < 3; count++, stems += 2 )
         {
           error = ps_dimension_add_t1stem( dim, stems[0], stems[1],
-                                           memory, &index[count] );
+                                           memory, &idx[count] );
           if ( error )
             goto Fail;
         }
 
         /* now, add the hints to the counters table */
-        error = ps_dimension_add_counter( dim, index[0], index[1],
-                                          index[2], memory );
+        error = ps_dimension_add_counter( dim, idx[0], idx[1], idx[2],
+                                          memory );
         if ( error )
           goto Fail;
       }
@@ -1129,10 +1129,10 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   t1_hints_funcs_init( T1_Hints_FuncsRec*  funcs )
   {
-    memset( (char*)funcs, 0, sizeof ( *funcs ) );
+    ft_memset( (char*)funcs, 0, sizeof ( *funcs ) );
 
     funcs->open  = (T1_Hints_OpenFunc)    t1_hints_open;
     funcs->close = (T1_Hints_CloseFunc)   ps_hints_close;
@@ -1194,10 +1194,10 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   t2_hints_funcs_init( T2_Hints_FuncsRec*  funcs )
   {
-    memset( funcs, 0, sizeof ( *funcs ) );
+    ft_memset( funcs, 0, sizeof ( *funcs ) );
 
     funcs->open    = (T2_Hints_OpenFunc)   t2_hints_open;
     funcs->close   = (T2_Hints_CloseFunc)  ps_hints_close;
Index: xc/extras/freetype2/src/pshinter/pshrec.h
diff -u xc/extras/freetype2/src/pshinter/pshrec.h:1.1.1.1 xc/extras/freetype2/src/pshinter/pshrec.h:1.1.1.2
--- xc/extras/freetype2/src/pshinter/pshrec.h:1.1.1.1	Mon Jan 14 11:52:15 2002
+++ xc/extras/freetype2/src/pshinter/pshrec.h	Thu Jun 20 04:16:20 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Postscript (Type1/Type2) hints recorder (specification).             */
 /*                                                                         */
-/*  Copyright 2001 by                                                      */
+/*  Copyright 2001, 2002 by                                                */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -145,20 +145,20 @@
   /* */
 
   /* initialize hints recorder */
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   ps_hints_init( PS_Hints   hints,
                  FT_Memory  memory );
 
   /* finalize hints recorder */
-  FT_LOCAL void
+  FT_LOCAL( void )
   ps_hints_done( PS_Hints  hints );
 
   /* initialize Type1 hints recorder interface */
-  FT_LOCAL void
+  FT_LOCAL( void )
   t1_hints_funcs_init( T1_Hints_FuncsRec*  funcs );
 
   /* initialize Type2 hints recorder interface */
-  FT_LOCAL void
+  FT_LOCAL( void )
   t2_hints_funcs_init( T2_Hints_FuncsRec*  funcs );
 
 
Index: xc/extras/freetype2/src/psnames/descrip.mms
diff -u xc/extras/freetype2/src/psnames/descrip.mms:1.1.1.1 xc/extras/freetype2/src/psnames/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/psnames/descrip.mms:1.1.1.1	Tue May 15 23:45:43 2001
+++ xc/extras/freetype2/src/psnames/descrip.mms	Thu Jun 20 04:16:20 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,6 @@
 OBJS=psnames.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/psnames/psmodule.c
diff -u xc/extras/freetype2/src/psnames/psmodule.c:1.1.1.5 xc/extras/freetype2/src/psnames/psmodule.c:1.1.1.7
--- xc/extras/freetype2/src/psnames/psmodule.c:1.1.1.5	Mon Jan 14 11:52:15 2002
+++ xc/extras/freetype2/src/psnames/psmodule.c	Thu Jun 20 04:16:20 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    PSNames module implementation (body).                                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -25,10 +25,7 @@
 
 #include "psnamerr.h"
 
-#include <stdlib.h>     /* for qsort()             */
-#include <string.h>     /* for strcmp(), strncpy() */
 
-
 #ifndef FT_CONFIG_OPTION_NO_POSTSCRIPT_NAMES
 
 
@@ -106,7 +103,7 @@
 
       if ( *p && len < 64 )
       {
-        strncpy( temp, glyph_name, len );
+        ft_strncpy( temp, glyph_name, len );
         temp[len]  = 0;
         glyph_name = temp;
       }
@@ -118,7 +115,7 @@
       const char*  name = sid_standard_names[n];
 
 
-      if ( first == name[0] && strcmp( glyph_name, name ) == 0 )
+      if ( first == name[0] && ft_strcmp( glyph_name, name ) == 0 )
         return ps_names_to_unicode[n];
     }
 
@@ -127,7 +124,7 @@
   }
 
 
-  /* qsort callback to sort the unicode map */
+  /* ft_qsort callback to sort the unicode map */
   FT_CALLBACK_DEF( int )
   compare_uni_maps( const void*  a,
                     const void*  b )
@@ -154,7 +151,7 @@
     table->num_maps = 0;
     table->maps     = 0;
 
-    if ( !ALLOC_ARRAY( table->maps, num_glyphs, PS_UniMap ) )
+    if ( !FT_NEW_ARRAY( table->maps, num_glyphs ) )
     {
       FT_UInt     n;
       FT_UInt     count;
@@ -185,20 +182,20 @@
       /* now, compress the table a bit */
       count = (FT_UInt)( map - table->maps );
 
-      if ( count > 0 && REALLOC( table->maps,
-                                 num_glyphs * sizeof ( PS_UniMap ),
-                                 count * sizeof ( PS_UniMap ) ) )
+      if ( count > 0 && FT_REALLOC( table->maps,
+                                    num_glyphs * sizeof ( PS_UniMap ),
+                                    count * sizeof ( PS_UniMap ) ) )
         count = 0;
 
       if ( count == 0 )
       {
-        FREE( table->maps );
+        FT_FREE( table->maps );
         if ( !error )
           error = PSnames_Err_Invalid_Argument;  /* no unicode chars here! */
       }
       else
         /* sort the table in increasing order of unicode values */
-        qsort( table->maps, count, sizeof ( PS_UniMap ), compare_uni_maps );
+        ft_qsort( table->maps, count, sizeof ( PS_UniMap ), compare_uni_maps );
 
       table->num_maps = count;
     }
@@ -238,6 +235,48 @@
   }
 
 
+  static FT_ULong
+  PS_Next_Unicode( PS_Unicodes*  table,
+                   FT_ULong      unicode )
+  {
+    PS_UniMap  *min, *max, *mid;
+
+
+    unicode++;
+    /* perform a binary search on the table */
+
+    min = table->maps;
+    max = min + table->num_maps - 1;
+
+    while ( min <= max )
+    {
+      mid = min + ( max - min ) / 2;
+      if ( mid->unicode == unicode )
+        return unicode;
+
+      if ( min == max )
+        break;
+
+      if ( mid->unicode < unicode )
+        min = mid + 1;
+      else
+        max = mid - 1;
+    }
+
+    if ( max < table->maps )
+      max = table->maps;
+    
+    while ( max < table->maps + table->num_maps )
+    {
+      if ( unicode < max->unicode )
+        return max->unicode;
+      max++;
+    }
+
+    return 0;
+  }
+
+
 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
 
 
@@ -279,7 +318,14 @@
     (PS_Adobe_Std_Strings_Func)PS_Standard_Strings,
 
     t1_standard_encoding,
-    t1_expert_encoding
+    t1_expert_encoding,
+
+#ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+    (PS_Next_Unicode_Func)     PS_Next_Unicode
+#else
+    0
+#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
+
   };
 
 
Index: xc/extras/freetype2/src/psnames/rules.mk
diff -u xc/extras/freetype2/src/psnames/rules.mk:1.1.1.3 xc/extras/freetype2/src/psnames/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/psnames/rules.mk:1.1.1.3	Sun Sep  9 22:56:05 2001
+++ xc/extras/freetype2/src/psnames/rules.mk	Thu Jun 20 04:16:20 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/raster/descrip.mms
diff -u xc/extras/freetype2/src/raster/descrip.mms:1.1.1.1 xc/extras/freetype2/src/raster/descrip.mms:1.1.1.2
--- xc/extras/freetype2/src/raster/descrip.mms:1.1.1.1	Tue May 15 23:45:42 2001
+++ xc/extras/freetype2/src/raster/descrip.mms	Thu Feb 14 19:33:36 2002
@@ -18,6 +18,6 @@
 OBJS=raster.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/raster/ftraster.c
diff -u xc/extras/freetype2/src/raster/ftraster.c:1.1.1.5 xc/extras/freetype2/src/raster/ftraster.c:1.1.1.6
--- xc/extras/freetype2/src/raster/ftraster.c:1.1.1.5	Mon Jan 14 11:52:16 2002
+++ xc/extras/freetype2/src/raster/ftraster.c	Thu Jun 20 04:16:21 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    The FreeType glyph rasterizer (body).                                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -186,8 +186,8 @@
 #endif /* _STANDALONE_ */
 
 
-#ifndef MEM_Set
-#define MEM_Set( d, s, c )  memset( d, s, c )
+#ifndef FT_MEM_SET
+#define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
 #endif
 
 
@@ -271,10 +271,10 @@
   /* States of each line, arc, and profile */
   typedef enum  TStates_
   {
-    Unknown,
-    Ascending,
-    Descending,
-    Flat
+    Unknown_State,
+    Ascending_State,
+    Descending_State,
+    Flat_State
 
   } TStates;
 
@@ -579,12 +579,12 @@
 
     switch ( aState )
     {
-    case Ascending:
+    case Ascending_State:
       ras.cProfile->flow = Flow_Up;
       FT_TRACE6(( "New ascending profile = %lx\n", (long)ras.cProfile ));
       break;
 
-    case Descending:
+    case Descending_State:
       ras.cProfile->flow = Flow_Down;
       FT_TRACE6(( "New descending profile = %lx\n", (long)ras.cProfile ));
       break;
@@ -1265,34 +1265,34 @@
 
     switch ( ras.state )
     {
-    case Unknown:
+    case Unknown_State:
       if ( y > ras.lastY )
       {
-        if ( New_Profile( RAS_VARS Ascending ) )
+        if ( New_Profile( RAS_VARS Ascending_State ) )
           return FAILURE;
       }
       else
       {
         if ( y < ras.lastY )
-          if ( New_Profile( RAS_VARS Descending ) )
+          if ( New_Profile( RAS_VARS Descending_State ) )
             return FAILURE;
       }
       break;
 
-    case Ascending:
+    case Ascending_State:
       if ( y < ras.lastY )
       {
-        if ( End_Profile( RAS_VAR )             ||
-             New_Profile( RAS_VARS Descending ) )
+        if ( End_Profile( RAS_VAR )                   ||
+             New_Profile( RAS_VARS Descending_State ) )
           return FAILURE;
       }
       break;
 
-    case Descending:
+    case Descending_State:
       if ( y > ras.lastY )
       {
-        if ( End_Profile( RAS_VAR )            ||
-             New_Profile( RAS_VARS Ascending ) )
+        if ( End_Profile( RAS_VAR )                  ||
+             New_Profile( RAS_VARS Ascending_State ) )
           return FAILURE;
       }
       break;
@@ -1305,13 +1305,13 @@
 
     switch ( ras.state )
     {
-    case Ascending:
+    case Ascending_State:
       if ( Line_Up( RAS_VARS ras.lastX, ras.lastY,
                     x, y, ras.minY, ras.maxY ) )
         return FAILURE;
       break;
 
-    case Descending:
+    case Descending_State:
       if ( Line_Down( RAS_VARS ras.lastX, ras.lastY,
                       x, y, ras.minY, ras.maxY ) )
         return FAILURE;
@@ -1402,11 +1402,11 @@
       {
         /* the arc is y-monotonous, either ascending or descending */
         /* detect a change of direction                            */
-        state_bez = y1 < y3 ? Ascending : Descending;
+        state_bez = y1 < y3 ? Ascending_State : Descending_State;
         if ( ras.state != state_bez )
         {
           /* finalize current profile if any */
-          if ( ras.state != Unknown   &&
+          if ( ras.state != Unknown_State   &&
                End_Profile( RAS_VAR ) )
             goto Fail;
 
@@ -1416,7 +1416,7 @@
         }
 
         /* now call the appropriate routine */
-        if ( state_bez == Ascending )
+        if ( state_bez == Ascending_State )
         {
           if ( Bezier_Up( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) )
             goto Fail;
@@ -1529,12 +1529,12 @@
       }
       else
       {
-        state_bez = ( y1 <= y4 ) ? Ascending : Descending;
+        state_bez = ( y1 <= y4 ) ? Ascending_State : Descending_State;
 
         /* detect a change of direction */
         if ( ras.state != state_bez )
         {
-          if ( ras.state != Unknown   &&
+          if ( ras.state != Unknown_State   &&
                End_Profile( RAS_VAR ) )
             goto Fail;
 
@@ -1543,7 +1543,7 @@
         }
 
         /* compute intersections */
-        if ( state_bez == Ascending )
+        if ( state_bez == Ascending_State )
         {
           if ( Bezier_Up( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) )
             goto Fail;
@@ -1838,7 +1838,7 @@
 
     for ( i = 0; i < ras.outline.n_contours; i++ )
     {
-      ras.state    = Unknown;
+      ras.state    = Unknown_State;
       ras.gProfile = NULL;
 
       if ( Decompose_Curve( RAS_VARS (unsigned short)start,
@@ -2965,7 +2965,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   Render_Glyph( RAS_ARG )
   {
     FT_Error  error;
@@ -3028,7 +3028,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   Render_Gray_Glyph( RAS_ARG )
   {
     Long      pixel_width;
@@ -3086,17 +3086,17 @@
     return Raster_Err_Ok;
   }
 
-#else /* FT_RASTER_OPTION_ANTI_ALIASING */
+#else /* !FT_RASTER_OPTION_ANTI_ALIASING */
 
-  FT_LOCAL_DEF
-  FT_Error  Render_Gray_Glyph( RAS_ARG )
+  FT_LOCAL_DEF( FT_Error )
+  Render_Gray_Glyph( RAS_ARG )
   {
     FT_UNUSED_RASTER;
 
     return Raster_Err_Cannot_Render_Glyph;
   }
 
-#endif /* FT_RASTER_OPTION_ANTI_ALIASING */
+#endif /* !FT_RASTER_OPTION_ANTI_ALIASING */
 
 
   static void
@@ -3146,7 +3146,7 @@
 
 
      *araster = &the_raster;
-     MEM_Set( &the_raster, sizeof ( the_raster ), 0 );
+     FT_MEM_SET( &the_raster, sizeof ( the_raster ), 0 );
      ft_black_init( &the_raster );
 
      return 0;
@@ -3173,7 +3173,7 @@
 
 
     *araster = 0;
-    if ( !ALLOC( raster, sizeof ( *raster ) ) )
+    if ( !FT_NEW( raster ) )
     {
       raster->memory = memory;
       ft_black_init( raster );
@@ -3189,7 +3189,7 @@
   ft_black_done( TRaster_Instance*  raster )
   {
     FT_Memory  memory = (FT_Memory)raster->memory;
-    FREE( raster );
+    FT_FREE( raster );
   }
 
 
@@ -3211,9 +3211,9 @@
 
 
   static void
-  ft_black_set_mode( TRaster_Instance* raster,
-                     unsigned long     mode,
-                     const char*       palette )
+  ft_black_set_mode( TRaster_Instance*  raster,
+                     unsigned long      mode,
+                     const char*        palette )
   {
 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
 
Index: xc/extras/freetype2/src/raster/ftrend1.c
diff -u xc/extras/freetype2/src/raster/ftrend1.c:1.1.1.5 xc/extras/freetype2/src/raster/ftrend1.c:1.1.1.6
--- xc/extras/freetype2/src/raster/ftrend1.c:1.1.1.5	Mon Jan 14 11:52:16 2002
+++ xc/extras/freetype2/src/raster/ftrend1.c	Thu Jun 20 04:16:21 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    The FreeType glyph rasterizer interface (body).                      */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -86,7 +86,7 @@
                        FT_GlyphSlot  slot,
                        FT_BBox*      cbox )
   {
-    MEM_Set( cbox, 0, sizeof ( *cbox ) );
+    FT_MEM_SET( cbox, 0, sizeof ( *cbox ) );
 
     if ( slot->format == render->glyph_format )
       FT_Outline_Get_CBox( &slot->outline, cbox );
@@ -151,10 +151,10 @@
     memory = render->root.memory;
 
     /* release old bitmap buffer */
-    if ( slot->flags & ft_glyph_own_bitmap )
+    if ( slot->flags & FT_GLYPH_OWN_BITMAP )
     {
-      FREE( bitmap->buffer );
-      slot->flags &= ~ft_glyph_own_bitmap;
+      FT_FREE( bitmap->buffer );
+      slot->flags &= ~FT_GLYPH_OWN_BITMAP;
     }
 
     /* allocate new one, depends on pixel format */
@@ -167,7 +167,7 @@
     }
     else
     {
-      pitch = ( width + 7 ) >> 3;
+      pitch = ( ( width + 15 ) >> 4 ) << 1;
       bitmap->pixel_mode = ft_pixel_mode_mono;
     }
 
@@ -175,10 +175,10 @@
     bitmap->rows  = height;
     bitmap->pitch = pitch;
 
-    if ( ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
+    if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
       goto Exit;
 
-    slot->flags |= ft_glyph_own_bitmap;
+    slot->flags |= FT_GLYPH_OWN_BITMAP;
 
     /* translate outline to render it into the bitmap */
     FT_Outline_Translate( outline, -cbox.xMin, -cbox.yMin );
Index: xc/extras/freetype2/src/raster/rules.mk
diff -u xc/extras/freetype2/src/raster/rules.mk:1.1.1.3 xc/extras/freetype2/src/raster/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/raster/rules.mk:1.1.1.3	Sun Sep  9 22:56:06 2001
+++ xc/extras/freetype2/src/raster/rules.mk	Thu Jun 20 04:16:21 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/sfnt/Jamfile
diff -u xc/extras/freetype2/src/sfnt/Jamfile:1.1.1.1 xc/extras/freetype2/src/sfnt/Jamfile:1.1.1.2
--- xc/extras/freetype2/src/sfnt/Jamfile:1.1.1.1	Sun Sep  9 22:56:06 2001
+++ xc/extras/freetype2/src/sfnt/Jamfile	Thu Jun 20 04:16:21 2002
@@ -1,4 +1,4 @@
-# FreeType 2 src/sfnt Jamfile (c) 2001 David Turner
+# FreeType 2 src/sfnt Jamfile (c) 2001, 2002 David Turner
 #
 
 SubDir  FT2_TOP src sfnt ;
@@ -10,7 +10,7 @@
 
   if $(FT2_MULTI)
   {
-    _sources = sfobjs sfdriver ttcmap ttpost ttload ttsbit ;
+    _sources = sfobjs sfdriver ttcmap ttcmap0 ttpost ttload ttsbit ;
   }
   else
   {
Index: xc/extras/freetype2/src/sfnt/descrip.mms
diff -u xc/extras/freetype2/src/sfnt/descrip.mms:1.1.1.1 xc/extras/freetype2/src/sfnt/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/sfnt/descrip.mms:1.1.1.1	Tue May 15 23:45:36 2001
+++ xc/extras/freetype2/src/sfnt/descrip.mms	Thu Jun 20 04:16:21 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,6 @@
 OBJS=sfnt.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/sfnt/rules.mk
diff -u xc/extras/freetype2/src/sfnt/rules.mk:1.1.1.3 xc/extras/freetype2/src/sfnt/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/sfnt/rules.mk:1.1.1.3	Sun Sep  9 22:56:06 2001
+++ xc/extras/freetype2/src/sfnt/rules.mk	Thu Jun 20 04:16:21 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -28,6 +28,7 @@
 #
 SFNT_DRV_SRC := $(SFNT_DIR_)ttload.c   \
                 $(SFNT_DIR_)ttcmap.c   \
+                $(SFNT_DIR_)ttcmap0.c  \
                 $(SFNT_DIR_)ttsbit.c   \
                 $(SFNT_DIR_)ttpost.c   \
                 $(SFNT_DIR_)sfobjs.c   \
Index: xc/extras/freetype2/src/sfnt/sfdriver.c
diff -u xc/extras/freetype2/src/sfnt/sfdriver.c:1.1.1.5 xc/extras/freetype2/src/sfnt/sfdriver.c:1.1.1.8
--- xc/extras/freetype2/src/sfnt/sfdriver.c:1.1.1.5	Mon Jan 14 11:52:22 2002
+++ xc/extras/freetype2/src/sfnt/sfdriver.c	Thu Jun 20 04:16:21 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    High-level SFNT driver interface (body).                             */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -33,9 +33,7 @@
 #include "ttpost.h"
 #endif
 
-#include <string.h>     /* for strcmp() */
 
-
   static void*
   get_sfnt_table( TT_Face      face,
                   FT_Sfnt_Tag  tag )
@@ -58,7 +56,7 @@
       break;
 
     case ft_sfnt_os2:
-      table = face->os2.version == 0xFFFF ? 0 : &face->os2;
+      table = face->os2.version == 0xFFFFU ? 0 : &face->os2;
       break;
 
     case ft_sfnt_post:
@@ -97,13 +95,13 @@
     error = TT_Get_PS_Name( face, glyph_index, &gname );
     if ( !error && buffer_max > 0 )
     {
-      FT_UInt  len = (FT_UInt)( strlen( gname ) );
+      FT_UInt  len = (FT_UInt)( ft_strlen( gname ) );
 
 
       if ( len >= buffer_max )
         len = buffer_max - 1;
 
-      MEM_Copy( buffer, gname, len );
+      FT_MEM_COPY( buffer, gname, len );
       ((FT_Byte*)buffer)[len] = 0;
     }
 
@@ -114,49 +112,107 @@
   static const char*
   get_sfnt_postscript_name( TT_Face  face )
   {
-    FT_Int  n;
+    FT_Int       n, found_win, found_apple;
+    const char*  result = NULL;
 
 
     /* shouldn't happen, but just in case to avoid memory leaks */
     if ( face->root.internal->postscript_name )
       return face->root.internal->postscript_name;
+
+    /* scan the name table to see whether we have a Postscript name here, */
+    /* either in Macintosh or Windows platform encodings                  */
+    found_win   = -1;
+    found_apple = -1;
 
-    /* scan the name table to see if we have a Postscript name here, either */
-    /* in Macintosh or Windows platform encodings..                         */
     for ( n = 0; n < face->num_names; n++ )
     {
-      TT_NameRec*  name = face->name_table.names + n;
+      TT_NameEntryRec*  name = face->name_table.names + n;
 
 
-      if ( name->nameID == 6 )
+      if ( name->nameID == 6 && name->stringLength > 0 )
       {
-        if ( ( name->platformID == 3 &&
-               name->encodingID == 1 &&
-               name->languageID == 0x409 ) ||
-
-             ( name->platformID == 1 &&
-               name->encodingID == 0 &&
-               name->languageID == 0     ) )
+        if ( name->platformID == 3     &&
+             name->encodingID == 1     &&
+             name->languageID == 0x409 )
+          found_win = n;
+
+        if ( name->platformID == 1 &&
+             name->encodingID == 0 &&
+             name->languageID == 0 )
+          found_apple = n;
+      }
+    }
+
+    if ( found_win != -1 )
+    {
+      FT_Memory         memory = face->root.memory;
+      TT_NameEntryRec*  name   = face->name_table.names + found_win;
+      FT_UInt           len    = name->stringLength / 2;
+      FT_Error          error;
+
+
+      if ( !FT_ALLOC( result, name->stringLength + 1 ) )
+      {
+        FT_Stream   stream = face->name_table.stream;
+        FT_String*  r      = (FT_String*)result;
+        FT_Byte*    p      = (FT_Byte*)name->string;
+
+
+        if ( FT_STREAM_SEEK( name->stringOffset ) ||
+             FT_FRAME_ENTER( name->stringLength ) )
+        {
+          FT_FREE( result );
+          name->stringLength = 0;
+          name->stringOffset = 0;
+          FT_FREE( name->string );
+
+          goto Exit;
+        }
+
+        p = (FT_Byte*)stream->cursor;
+
+        for ( ; len > 0; len--, p += 2 )
         {
-          FT_UInt     len = name->stringLength;
-          FT_Error    error;
-          FT_Memory   memory = face->root.memory;
-          FT_String*  result;
+          if ( p[0] == 0 && p[1] >= 32 && p[1] < 128 )
+            *r++ = p[1];
+        }
+        *r = '\0';
 
+        FT_FRAME_EXIT();
+      }
+      goto Exit;
+    }
 
-          if ( !ALLOC( result, len + 1 ) )
-          {
-            memcpy( result, name->string, len );
-            result[len] = '\0';
-
-            face->root.internal->postscript_name = result;
-          }
-          return result;
+    if ( found_apple != -1 )
+    {
+      FT_Memory         memory = face->root.memory;
+      TT_NameEntryRec*  name   = face->name_table.names + found_apple;
+      FT_UInt           len    = name->stringLength;
+      FT_Error          error;
+
+
+      if ( !FT_ALLOC( result, len + 1 ) )
+      {
+        FT_Stream  stream = face->name_table.stream;
+
+
+        if ( FT_STREAM_SEEK( name->stringOffset ) ||
+             FT_STREAM_READ( result, len )        )
+        {
+          name->stringOffset = 0;
+          name->stringLength = 0;
+          FT_FREE( name->string );
+          FT_FREE( result );
+          goto Exit;
         }
+        ((char*)result)[len] = '\0';
       }
     }
 
-    return NULL;
+  Exit:
+    face->root.internal->postscript_name = result;
+    return result;
   }
 
 
@@ -165,19 +221,19 @@
 
   FT_CALLBACK_DEF( FT_Module_Interface )
   SFNT_Get_Interface( FT_Module    module,
-                      const char*  interface )
+                      const char*  module_interface )
   {
     FT_UNUSED( module );
 
-    if ( strcmp( interface, "get_sfnt" ) == 0 )
+    if ( ft_strcmp( module_interface, "get_sfnt" ) == 0 )
       return (FT_Module_Interface)get_sfnt_table;
 
 #ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
-    if ( strcmp( interface, "glyph_name" ) == 0 )
+    if ( ft_strcmp( module_interface, "glyph_name" ) == 0 )
       return (FT_Module_Interface)get_sfnt_glyph_name;
 #endif
 
-    if ( strcmp( interface, "postscript_name" ) == 0 )
+    if ( ft_strcmp( module_interface, "postscript_name" ) == 0 )
       return (FT_Module_Interface)get_sfnt_postscript_name;
 
     return 0;
@@ -195,7 +251,7 @@
     SFNT_Get_Interface,
 
     TT_Load_Any,
-    TT_Load_SFNT_Header,
+    TT_Load_SFNT_HeaderRec,
     TT_Load_Directory,
 
     TT_Load_Header,
Index: xc/extras/freetype2/src/sfnt/sfnt.c
diff -u xc/extras/freetype2/src/sfnt/sfnt.c:1.1.1.3 xc/extras/freetype2/src/sfnt/sfnt.c:1.1.1.4
--- xc/extras/freetype2/src/sfnt/sfnt.c:1.1.1.3	Sun Dec 16 12:49:32 2001
+++ xc/extras/freetype2/src/sfnt/sfnt.c	Thu Jun 20 04:16:21 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Single object library component.                                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -21,6 +21,7 @@
 #include <ft2build.h>
 #include "ttload.c"
 #include "ttcmap.c"
+#include "ttcmap0.c"
 #include "sfobjs.c"
 #include "sfdriver.c"
 
Index: xc/extras/freetype2/src/sfnt/sfobjs.c
diff -u xc/extras/freetype2/src/sfnt/sfobjs.c:1.1.1.5 xc/extras/freetype2/src/sfnt/sfobjs.c:1.1.1.8
--- xc/extras/freetype2/src/sfnt/sfobjs.c:1.1.1.5	Mon Jan 14 11:52:22 2002
+++ xc/extras/freetype2/src/sfnt/sfobjs.c	Thu Jun 20 04:16:21 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    SFNT object management (base).                                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -19,6 +19,7 @@
 #include <ft2build.h>
 #include "sfobjs.h"
 #include "ttload.h"
+#include "ttcmap0.h"
 #include FT_INTERNAL_SFNT_H
 #include FT_INTERNAL_POSTSCRIPT_NAMES_H
 #include FT_TRUETYPE_IDS_H
@@ -37,10 +38,105 @@
 #define FT_COMPONENT  trace_sfobjs
 
 
+
+  /* convert a UTF-16 name entry to ASCII */
+  static FT_String*
+  tt_name_entry_ascii_from_utf16( TT_NameEntry  entry,
+                                  FT_Memory     memory )
+  {
+    FT_String*  string;
+    FT_UInt     len, code, n;
+    FT_Byte*    read = (FT_Byte*)entry->string;
+
+
+    len = (FT_UInt)entry->stringLength / 2;
+
+    if ( FT_MEM_NEW_ARRAY( string, len + 1 ) )
+      return NULL;
+
+    for ( n = 0; n < len; n++ )
+    {
+      code = FT_NEXT_USHORT( read );
+      if ( code < 32 || code > 127 )
+        code = '?';
+
+      string[n] = (char)code;
+    }
+
+    string[len] = 0;
+
+    return string;
+  }
+
+
+  /* convert a UCS-4 name entry to ASCII */
+  static FT_String*
+  tt_name_entry_ascii_from_ucs4( TT_NameEntry  entry,
+                                 FT_Memory     memory )
+  {
+    FT_String*  string;
+    FT_UInt     len, code, n;
+    FT_Byte*    read = (FT_Byte*)entry->string;
+
+
+    len = (FT_UInt)entry->stringLength / 4;
+
+    if ( FT_MEM_NEW_ARRAY( string, len + 1 ) )
+      return NULL;
+
+    for ( n = 0; n < len; n++ )
+    {
+      code = FT_NEXT_ULONG( read );
+      if ( code < 32 || code > 127 )
+        code = '?';
+
+      string[n] = (char)code;
+    }
+
+    string[len] = 0;
+
+    return string;
+  }
+
+
+  /* convert an Apple Roman or symbol name entry to ASCII */
+  static FT_String*
+  tt_name_entry_ascii_from_other( TT_NameEntry  entry,
+                                  FT_Memory     memory )
+  {
+    FT_String*  string;
+    FT_UInt     len, code, n;
+    FT_Byte*    read = (FT_Byte*)entry->string;
+
+
+    len = (FT_UInt)entry->stringLength;
+
+    if ( FT_MEM_NEW_ARRAY( string, len + 1 ) )
+      return NULL;
+
+    for ( n = 0; n < len; n++ )
+    {
+      code = *read++;
+      if ( code < 32 || code > 127 )
+        code = '?';
+
+      string[n] = (char)code;
+    }
+
+    string[len] = 0;
+
+    return string;
+  }
+
+
+  typedef FT_String*  (*TT_NameEntry_ConvertFunc)( TT_NameEntry  entry,
+                                                   FT_Memory     memory );
+
+
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    Get_Name                                                           */
+  /*    tt_face_get_name                                                   */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Returns a given ENGLISH name record in ASCII.                      */
@@ -54,83 +150,140 @@
   /*    Character string.  NULL if no name is present.                     */
   /*                                                                       */
   static FT_String*
-  Get_Name( TT_Face    face,
-            FT_UShort  nameid )
+  tt_face_get_name( TT_Face    face,
+                    FT_UShort  nameid )
   {
-    FT_Memory    memory = face->root.memory;
-    FT_UShort    n;
-    TT_NameRec*  rec;
-    FT_Bool      wide_chars = 1;
+    FT_Memory         memory = face->root.memory;
+    FT_String*        result = NULL;
+    FT_UShort         n;
+    TT_NameEntryRec*  rec;
+    FT_Int            found_apple   = -1;
+    FT_Int            found_win     = -1;
+    FT_Int            found_unicode = -1;
 
+    TT_NameEntry_ConvertFunc  convert;
 
+
     rec = face->name_table.names;
-    for ( n = 0; n < face->name_table.numNameRecords; n++, rec++ )
+    for ( n = 0; n < face->num_names; n++, rec++ )
     {
-      if ( rec->nameID == nameid )
+      /* According to the OpenType 1.3 specification, only Microsoft or  */
+      /* Apple platform IDs might be used in the `name' table.  The      */
+      /* `Unicode' platform is reserved for the `cmap' table, and the    */
+      /* `Iso' one is deprecated.                                        */
+      /*                                                                 */
+      /* However, the Apple TrueType specification doesn't say the same  */
+      /* thing and goes to suggest that all Unicode `name' table entries */
+      /* should be coded in UTF-16 (in big-endian format I suppose).     */
+      /*                                                                 */
+      if ( rec->nameID == nameid && rec->stringLength > 0 )
       {
-        /* found the name -- now create an ASCII string from it */
-        FT_Bool  found = 0;
-
-
-        /* test for Microsoft English language */
-        if ( rec->platformID == TT_PLATFORM_MICROSOFT &&
-             rec->encodingID <= TT_MS_ID_UNICODE_CS   &&
-             ( rec->languageID & 0x3FF ) == 0x009     )
-          found = 1;
-
-        /* test for Apple Unicode encoding */
-        else if ( rec->platformID == TT_PLATFORM_APPLE_UNICODE )
-          found = 1;
-
-        /* test for Apple Roman */
-        else if ( rec->platformID == TT_PLATFORM_MACINTOSH &&
-                  rec->languageID == TT_MAC_ID_ROMAN       )
-        {
-          found      = 1;
-          wide_chars = 0;
-        }
-
-        /* found a Unicode name */
-        if ( found )
+        switch ( rec->platformID )
         {
-          FT_String*  string;
-          FT_UInt     len;
-
-
-          if ( wide_chars )
+        case TT_PLATFORM_APPLE_UNICODE:
+        case TT_PLATFORM_ISO:
+          /* there is `languageID' to check there.  We should use this */
+          /* field only as a last solution when nothing else is        */
+          /* available.                                                */
+          /*                                                           */
+          found_unicode = n;
+          break;
+
+        case TT_PLATFORM_MACINTOSH:
+          if ( rec->languageID == TT_MAC_LANGID_ENGLISH )
+            found_apple = n;
+
+          break;
+
+        case TT_PLATFORM_MICROSOFT:
+          /* we only take a non-English name when there is nothing */
+          /* else available in the font                            */
+          /*                                                       */
+          if ( found_win == -1 || ( rec->languageID & 0x3FF ) == 0x009 )
           {
-            FT_UInt   m;
+            switch ( rec->encodingID )
+            {
+            case TT_MS_ID_SYMBOL_CS:
+            case TT_MS_ID_UNICODE_CS:
+            case TT_MS_ID_UCS_4:
+              found_win = n;
+              break;
+
+            default:
+              ;
+            }
+          }
+          break;
 
+        default:
+          ;
+        }
+      }
+    }
 
-            len = (FT_UInt)rec->stringLength / 2;
-            if ( MEM_Alloc( string, len + 1 ) )
-              return NULL;
+    /* some fonts contain invalid Unicode or Macintosh formatted entries; */
+    /* we will thus favor names encoded in Windows formats if available   */
+    /*                                                                    */
+    convert = NULL;
+    if ( found_win >= 0 )
+    {
+      rec = face->name_table.names + found_win;
+      switch ( rec->encodingID )
+      {
+      case TT_MS_ID_UNICODE_CS:
+      case TT_MS_ID_SYMBOL_CS:
+        convert = tt_name_entry_ascii_from_utf16;
+        break;
+
+      case TT_MS_ID_UCS_4:
+        convert = tt_name_entry_ascii_from_ucs4;
+        break;
 
-            for ( m = 0; m < len; m ++ )
-              string[m] = rec->string[2 * m + 1];
-          }
-          else
-          {
-            len = rec->stringLength;
-            if ( MEM_Alloc( string, len + 1 ) )
-              return NULL;
+      default:
+        ;
+      }
+    }
+    else if ( found_apple >= 0 )
+    {
+      rec     = face->name_table.names + found_apple;
+      convert = tt_name_entry_ascii_from_other;
+    }
+    else if ( found_unicode >= 0 )
+    {
+      rec     = face->name_table.names + found_unicode;
+      convert = tt_name_entry_ascii_from_utf16;
+    }
 
-            MEM_Copy( string, rec->string, len );
-          }
+    if ( rec && convert )
+    {
+      if ( rec->string == NULL )
+      {
+        FT_Error   error;
+        FT_Stream  stream = face->name_table.stream;
+
 
-          string[len] = '\0';
-          return string;
+        if ( FT_NEW_ARRAY  ( rec->string, rec->stringLength ) ||
+             FT_STREAM_SEEK( rec->stringOffset )              ||
+             FT_STREAM_READ( rec->string, rec->stringLength ) )
+        {
+          FT_FREE( rec->string );
+          rec->stringLength = 0;
+          result            = NULL;
+          goto Exit;
         }
       }
+
+      result = convert( rec, memory );
     }
 
-    return NULL;
+  Exit:
+    return result;
   }
 
 
   static FT_Encoding
-  find_encoding( int  platform_id,
-                 int  encoding_id )
+  sfnt_find_encoding( int  platform_id,
+                      int  encoding_id )
   {
     typedef struct  TEncoding
     {
@@ -179,26 +332,27 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   SFNT_Init_Face( FT_Stream      stream,
                   TT_Face        face,
                   FT_Int         face_index,
                   FT_Int         num_params,
                   FT_Parameter*  params )
   {
-    FT_Error            error;
-    FT_Library          library = face->root.driver->root.library;
-    SFNT_Interface*     sfnt;
-    SFNT_Header         sfnt_header;
+    FT_Error         error;
+    FT_Library       library = face->root.driver->root.library;
+    SFNT_Service     sfnt;
+    SFNT_HeaderRec   sfnt_header;
 
     /* for now, parameters are unused */
     FT_UNUSED( num_params );
     FT_UNUSED( params );
 
-    sfnt = (SFNT_Interface*)face->sfnt;
+
+    sfnt = (SFNT_Service)face->sfnt;
     if ( !sfnt )
     {
-      sfnt = (SFNT_Interface*)FT_Get_Module_Interface( library, "sfnt" );
+      sfnt = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );
       if ( !sfnt )
       {
         error = SFNT_Err_Invalid_File_Format;
@@ -211,8 +365,8 @@
 
     if ( !face->psnames )
     {
-      face->psnames = (PSNames_Interface*)
-                       FT_Get_Module_Interface( library, "psnames" );
+      face->psnames = (PSNames_Service)
+                        FT_Get_Module_Interface( library, "psnames" );
     }
 
     /* check that we have a valid TrueType file */
@@ -242,18 +396,18 @@
                       != SFNT_Err_Ok )
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   SFNT_Load_Face( FT_Stream      stream,
                   TT_Face        face,
                   FT_Int         face_index,
                   FT_Int         num_params,
                   FT_Parameter*  params )
   {
-    FT_Error         error;
-    FT_Bool          has_outline;
-    FT_Bool          is_apple_sbit;
+    FT_Error      error;
+    FT_Bool       has_outline;
+    FT_Bool       is_apple_sbit;
 
-    SFNT_Interface*  sfnt = (SFNT_Interface*)face->sfnt;
+    SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
 
     FT_UNUSED( face_index );
     FT_UNUSED( num_params );
@@ -296,11 +450,11 @@
     if ( !is_apple_sbit && LOAD_( header ) )
       goto Exit;
 
-    /* load other tables */
-    if ( LOAD_( max_profile ) ||
-         LOAD_( charmaps )    )
-      goto Exit;
-      
+    /* the following tables are often not present in embedded TrueType */
+    /* fonts within PDF documents, so don't check for them.            */
+    (void)LOAD_( max_profile );
+    (void)LOAD_( charmaps );
+
     /* the following tables are optional in PCL fonts -- */
     /* don't check for errors                            */
     (void)LOAD_( names );
@@ -337,6 +491,7 @@
       else
         goto Exit;
     }
+
 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
 
     if ( LOAD_( hdmx )    ||
@@ -345,21 +500,17 @@
          LOAD_( pclt )    )
       goto Exit;
 
-#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
-    if ( ( error = TT_Extension_Create( face ) ) != SFNT_Err_Ok )
-      goto Exit;
-#endif
+    face->root.family_name = tt_face_get_name( face,
+                                               TT_NAME_ID_FONT_FAMILY );
+    face->root.style_name  = tt_face_get_name( face,
+                                               TT_NAME_ID_FONT_SUBFAMILY );
 
-    face->root.family_name = Get_Name( face, TT_NAME_ID_FONT_FAMILY );
-    face->root.style_name  = Get_Name( face, TT_NAME_ID_FONT_SUBFAMILY );
-
     /* now set up root fields */
     {
-      FT_Face     root = &face->root;
-      FT_Int      flags = 0;
-      TT_CharMap  charmap;
-      FT_Int      n;
-      FT_Memory   memory;
+      FT_Face    root = &face->root;
+      FT_Int     flags = 0;
+      FT_Int     n;
+      FT_Memory  memory;
 
 
       memory = root->memory;
@@ -427,33 +578,70 @@
       /*   Try to set the charmap encoding according to the platform &     */
       /*   encoding ID of each charmap.                                    */
       /*                                                                   */
-      charmap            = face->charmaps;
-      root->num_charmaps = face->num_charmaps;
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
 
-      /* allocate table of pointers */
-      if ( ALLOC_ARRAY( root->charmaps, root->num_charmaps, FT_CharMap ) )
-        goto Exit;
+      TT_Build_CMaps( face );  /* ignore errors */
+
 
-      for ( n = 0; n < root->num_charmaps; n++, charmap++ )
+      /* set the encoding fields */
       {
-        FT_Int  platform = charmap->cmap.platformID;
-        FT_Int  encoding = charmap->cmap.platformEncodingID;
+        FT_Int  m;
 
 
-        charmap->root.face        = (FT_Face)face;
-        charmap->root.platform_id = (FT_UShort)platform;
-        charmap->root.encoding_id = (FT_UShort)encoding;
-        charmap->root.encoding    = find_encoding( platform, encoding );
+        for ( m = 0; m < root->num_charmaps; m++ )
+        {
+          FT_CharMap  charmap = root->charmaps[m];
+
 
-        /* now, set root->charmap with a unicode charmap */
-        /* wherever available                            */
-        if ( !root->charmap                                &&
-             charmap->root.encoding == ft_encoding_unicode )
-          root->charmap = (FT_CharMap)charmap;
+          charmap->encoding = sfnt_find_encoding( charmap->platform_id,
+                                                  charmap->encoding_id );
 
-        root->charmaps[n] = (FT_CharMap)charmap;
+          if ( root->charmap     == NULL &&
+               charmap->encoding == ft_encoding_unicode )
+          {
+            /* set 'root->charmap' to the first Unicode encoding we find */
+            root->charmap = charmap;
+          }
+        }
       }
 
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+      {
+        TT_CharMap  charmap = face->charmaps;
+
+
+        charmap            = face->charmaps;
+        root->num_charmaps = face->num_charmaps;
+
+        /* allocate table of pointers */
+        if ( FT_NEW_ARRAY( root->charmaps, root->num_charmaps ) )
+          goto Exit;
+
+        for ( n = 0; n < root->num_charmaps; n++, charmap++ )
+        {
+          FT_Int  platform = charmap->cmap.platformID;
+          FT_Int  encoding = charmap->cmap.platformEncodingID;
+
+
+          charmap->root.face        = (FT_Face)face;
+          charmap->root.platform_id = (FT_UShort)platform;
+          charmap->root.encoding_id = (FT_UShort)encoding;
+          charmap->root.encoding    = sfnt_find_encoding( platform, encoding );
+
+          /* now, set root->charmap with a unicode charmap */
+          /* wherever available                            */
+          if ( !root->charmap                                &&
+               charmap->root.encoding == ft_encoding_unicode )
+            root->charmap = (FT_CharMap)charmap;
+
+          root->charmaps[n] = (FT_CharMap)charmap;
+        }
+      }
+
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+
 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
 
       if ( face->num_sbit_strikes )
@@ -461,7 +649,8 @@
         root->face_flags |= FT_FACE_FLAG_FIXED_SIZES;
 
 #if 0
-        /* I don't know criteria whether layout is horizontal or vertical */
+        /* XXX: I don't know criteria whether layout is horizontal */
+        /*      or vertical.                                       */
         if ( has_outline.... )
         {
           ...
@@ -470,9 +659,7 @@
 #endif
         root->num_fixed_sizes = face->num_sbit_strikes;
 
-        if ( ALLOC_ARRAY( root->available_sizes,
-                          face->num_sbit_strikes,
-                          FT_Bitmap_Size ) )
+        if ( FT_NEW_ARRAY( root->available_sizes, face->num_sbit_strikes ) )
           goto Exit;
 
         for ( n = 0 ; n < face->num_sbit_strikes ; n++ )
@@ -591,11 +778,11 @@
 #undef LOAD_
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   SFNT_Done_Face( TT_Face  face )
   {
-    FT_Memory        memory = face->root.memory;
-    SFNT_Interface*  sfnt   = (SFNT_Interface*)face->sfnt;
+    FT_Memory     memory = face->root.memory;
+    SFNT_Service  sfnt   = (SFNT_Service)face->sfnt;
 
 
     if ( sfnt )
@@ -610,17 +797,30 @@
     }
 
     /* freeing the kerning table */
-    FREE( face->kern_pairs );
+    FT_FREE( face->kern_pairs );
     face->num_kern_pairs = 0;
 
     /* freeing the collection table */
-    FREE( face->ttc_header.offsets );
+    FT_FREE( face->ttc_header.offsets );
     face->ttc_header.count = 0;
 
     /* freeing table directory */
-    FREE( face->dir_tables );
+    FT_FREE( face->dir_tables );
     face->num_tables = 0;
 
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+    {
+      FT_Stream  stream = FT_FACE_STREAM( face );
+
+
+      /* simply release the 'cmap' table frame */
+      FT_FRAME_RELEASE( face->cmap_table );
+      face->cmap_size = 0;
+    }
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
     /* freeing the character mapping tables */
     if ( sfnt && sfnt->load_charmaps )
     {
@@ -631,27 +831,29 @@
         sfnt->free_charmap( face, &face->charmaps[n].cmap );
     }
 
-    FREE( face->charmaps );
+    FT_FREE( face->charmaps );
     face->num_charmaps = 0;
 
-    FREE( face->root.charmaps );
+    FT_FREE( face->root.charmaps );
     face->root.num_charmaps = 0;
     face->root.charmap      = 0;
 
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
     /* freeing the horizontal metrics */
-    FREE( face->horizontal.long_metrics );
-    FREE( face->horizontal.short_metrics );
+    FT_FREE( face->horizontal.long_metrics );
+    FT_FREE( face->horizontal.short_metrics );
 
     /* freeing the vertical ones, if any */
     if ( face->vertical_info )
     {
-      FREE( face->vertical.long_metrics  );
-      FREE( face->vertical.short_metrics );
+      FT_FREE( face->vertical.long_metrics  );
+      FT_FREE( face->vertical.short_metrics );
       face->vertical_info = 0;
     }
 
     /* freeing the gasp table */
-    FREE( face->gasp.gaspRanges );
+    FT_FREE( face->gasp.gaspRanges );
     face->gasp.numRanges = 0;
 
     /* freeing the name table */
@@ -661,13 +863,13 @@
     sfnt->free_hdmx( face );
 
     /* freeing family and style name */
-    FREE( face->root.family_name );
-    FREE( face->root.style_name );
+    FT_FREE( face->root.family_name );
+    FT_FREE( face->root.style_name );
 
     /* freeing sbit size table */
     face->root.num_fixed_sizes = 0;
     if ( face->root.available_sizes )
-      FREE( face->root.available_sizes );
+      FT_FREE( face->root.available_sizes );
 
     face->sfnt = 0;
   }
Index: xc/extras/freetype2/src/sfnt/sfobjs.h
diff -u xc/extras/freetype2/src/sfnt/sfobjs.h:1.1.1.3 xc/extras/freetype2/src/sfnt/sfobjs.h:1.1.1.4
--- xc/extras/freetype2/src/sfnt/sfobjs.h:1.1.1.3	Sun Dec 16 12:49:32 2001
+++ xc/extras/freetype2/src/sfnt/sfobjs.h	Thu Jun 20 04:16:21 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    SFNT object management (specification).                              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -28,21 +28,21 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   SFNT_Init_Face( FT_Stream      stream,
                   TT_Face        face,
                   FT_Int         face_index,
                   FT_Int         num_params,
                   FT_Parameter*  params );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   SFNT_Load_Face( FT_Stream      stream,
                   TT_Face        face,
                   FT_Int         face_index,
                   FT_Int         num_params,
                   FT_Parameter*  params );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   SFNT_Done_Face( TT_Face  face );
 
 
Index: xc/extras/freetype2/src/sfnt/ttcmap.c
diff -u xc/extras/freetype2/src/sfnt/ttcmap.c:1.1.1.4 xc/extras/freetype2/src/sfnt/ttcmap.c:1.1.1.6
--- xc/extras/freetype2/src/sfnt/ttcmap.c:1.1.1.4	Sun Dec 16 12:49:32 2001
+++ xc/extras/freetype2/src/sfnt/ttcmap.c	Thu Jun 20 04:16:21 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType character mapping table (cmap) support (body).              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -35,28 +35,52 @@
 
 
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index0( TT_CMapTable*  charmap,
-                  FT_ULong       char_code );
+  code_to_index0( TT_CMapTable  charmap,
+                  FT_ULong      char_code );
 
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next0( TT_CMapTable  charmap,
+                 FT_ULong      char_code );
+
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index2( TT_CMapTable*  charmap,
-                  FT_ULong       char_code );
+  code_to_index2( TT_CMapTable  charmap,
+                  FT_ULong      char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next2( TT_CMapTable  charmap,
+                 FT_ULong      char_code );
 
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index4( TT_CMapTable*  charmap,
-                  FT_ULong       char_code );
+  code_to_index4( TT_CMapTable  charmap,
+                  FT_ULong      char_code );
 
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next4( TT_CMapTable  charmap,
+                 FT_ULong      char_code );
+
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index6( TT_CMapTable*  charmap,
-                  FT_ULong       char_code );
+  code_to_index6( TT_CMapTable  charmap,
+                  FT_ULong      char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next6( TT_CMapTable  charmap,
+                 FT_ULong      char_code );
 
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index8_12( TT_CMapTable*  charmap,
-                     FT_ULong       char_code );
+  code_to_index8_12( TT_CMapTable  charmap,
+                     FT_ULong      char_code );
 
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next8_12( TT_CMapTable  charmap,
+                    FT_ULong      char_code );
+
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index10( TT_CMapTable*  charmap,
-                   FT_ULong       char_code );
+  code_to_index10( TT_CMapTable  charmap,
+                   FT_ULong      char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next10( TT_CMapTable  charmap,
+                  FT_ULong      char_code );
 
 
   /*************************************************************************/
@@ -69,6 +93,7 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the parent face object.                      */
+  /*                                                                       */
   /*    stream :: A handle to the current stream object.                   */
   /*                                                                       */
   /* <InOut>                                                               */
@@ -82,28 +107,28 @@
   /*    opened).  In case of error, all partially allocated tables are     */
   /*    released.                                                          */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_CharMap_Load( TT_Face        face,
-                   TT_CMapTable*  cmap,
-                   FT_Stream      stream )
-  {
-    FT_Error      error;
-    FT_Memory     memory;
-    FT_UShort     num_SH, num_Seg, i;
-    FT_ULong      j, n;
-
-    FT_UShort     u, l;
-
-    TT_CMap0*     cmap0;
-    TT_CMap2*     cmap2;
-    TT_CMap4*     cmap4;
-    TT_CMap6*     cmap6;
-    TT_CMap8_12*  cmap8_12;
-    TT_CMap10*    cmap10;
-
-    TT_CMap2SubHeader*  cmap2sub;
-    TT_CMap4Segment*    segments;
-    TT_CMapGroup*       groups;
+  FT_LOCAL_DEF( FT_Error )
+  TT_CharMap_Load( TT_Face       face,
+                   TT_CMapTable  cmap,
+                   FT_Stream     stream )
+  {
+    FT_Error     error;
+    FT_Memory    memory;
+    FT_UShort    num_SH, num_Seg, i;
+    FT_ULong     j, n;
+
+    FT_UShort    u, l;
+
+    TT_CMap0     cmap0;
+    TT_CMap2     cmap2;
+    TT_CMap4     cmap4;
+    TT_CMap6     cmap6;
+    TT_CMap8_12  cmap8_12;
+    TT_CMap10    cmap10;
+
+    TT_CMap2SubHeader  cmap2sub;
+    TT_CMap4Segment    segments;
+    TT_CMapGroup       groups;
 
 
     if ( cmap->loaded )
@@ -111,7 +136,7 @@
 
     memory = stream->memory;
 
-    if ( FILE_Seek( cmap->offset ) )
+    if ( FT_STREAM_SEEK( cmap->offset ) )
       return error;
 
     switch ( cmap->format )
@@ -119,12 +144,13 @@
     case 0:
       cmap0 = &cmap->c.cmap0;
 
-      if ( READ_UShort( cmap0->language )         ||
-           ALLOC( cmap0->glyphIdArray, 256L )     ||
-           FILE_Read( cmap0->glyphIdArray, 256L ) )
+      if ( FT_READ_USHORT( cmap0->language )           ||
+           FT_ALLOC( cmap0->glyphIdArray, 256L )       ||
+           FT_STREAM_READ( cmap0->glyphIdArray, 256L ) )
         goto Fail;
 
-      cmap->get_index = code_to_index0;
+      cmap->get_index     = code_to_index0;
+      cmap->get_next_char = code_to_next0;
       break;
 
     case 2:
@@ -133,34 +159,32 @@
 
       /* allocate subheader keys */
 
-      if ( ALLOC_ARRAY( cmap2->subHeaderKeys, 256, FT_UShort ) ||
-           ACCESS_Frame( 2L + 512L )                           )
+      if ( FT_NEW_ARRAY( cmap2->subHeaderKeys, 256 ) ||
+           FT_FRAME_ENTER( 2L + 512L )               )
         goto Fail;
 
-      cmap2->language = GET_UShort();
+      cmap2->language = FT_GET_USHORT();
 
       for ( i = 0; i < 256; i++ )
       {
-        u = (FT_UShort)( GET_UShort() / 8 );
+        u = (FT_UShort)( FT_GET_USHORT() / 8 );
         cmap2->subHeaderKeys[i] = u;
 
         if ( num_SH < u )
           num_SH = u;
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       /* load subheaders */
 
       cmap2->numGlyphId = l = (FT_UShort)(
-        ( ( cmap->length - 2L * ( 256 + 3 ) - num_SH * 8L ) & 0xFFFF ) / 2 );
+        ( ( cmap->length - 2L * ( 256 + 3 ) - num_SH * 8L ) & 0xFFFFU ) / 2 );
 
-      if ( ALLOC_ARRAY( cmap2->subHeaders,
-                        num_SH + 1,
-                        TT_CMap2SubHeader )    ||
-           ACCESS_Frame( ( num_SH + 1 ) * 8L ) )
+      if ( FT_NEW_ARRAY( cmap2->subHeaders, num_SH + 1 ) ||
+           FT_FRAME_ENTER( ( num_SH + 1 ) * 8L )         )
       {
-        FREE( cmap2->subHeaderKeys );
+        FT_FREE( cmap2->subHeaderKeys );
         goto Fail;
       }
 
@@ -168,34 +192,35 @@
 
       for ( i = 0; i <= num_SH; i++ )
       {
-        cmap2sub->firstCode     = GET_UShort();
-        cmap2sub->entryCount    = GET_UShort();
-        cmap2sub->idDelta       = GET_Short();
+        cmap2sub->firstCode     = FT_GET_USHORT();
+        cmap2sub->entryCount    = FT_GET_USHORT();
+        cmap2sub->idDelta       = FT_GET_SHORT();
         /* we apply the location offset immediately */
         cmap2sub->idRangeOffset = (FT_UShort)(
-          GET_UShort() - ( num_SH - i ) * 8 - 2 );
+          FT_GET_USHORT() - ( num_SH - i ) * 8 - 2 );
 
         cmap2sub++;
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       /* load glyph IDs */
 
-      if ( ALLOC_ARRAY( cmap2->glyphIdArray, l, FT_UShort ) ||
-           ACCESS_Frame( l * 2L )                           )
+      if ( FT_NEW_ARRAY( cmap2->glyphIdArray, l ) ||
+           FT_FRAME_ENTER( l * 2L )               )
       {
-        FREE( cmap2->subHeaders );
-        FREE( cmap2->subHeaderKeys );
+        FT_FREE( cmap2->subHeaders );
+        FT_FREE( cmap2->subHeaderKeys );
         goto Fail;
       }
 
       for ( i = 0; i < l; i++ )
-        cmap2->glyphIdArray[i] = GET_UShort();
+        cmap2->glyphIdArray[i] = FT_GET_USHORT();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       cmap->get_index = code_to_index2;
+      cmap->get_next_char = code_to_next2;
       break;
 
     case 4:
@@ -203,157 +228,159 @@
 
       /* load header */
 
-      if ( ACCESS_Frame( 10L ) )
+      if ( FT_FRAME_ENTER( 10L ) )
         goto Fail;
 
-      cmap4->language      = GET_UShort();
-      cmap4->segCountX2    = GET_UShort();
-      cmap4->searchRange   = GET_UShort();
-      cmap4->entrySelector = GET_UShort();
-      cmap4->rangeShift    = GET_UShort();
+      cmap4->language      = FT_GET_USHORT();
+      cmap4->segCountX2    = FT_GET_USHORT();
+      cmap4->searchRange   = FT_GET_USHORT();
+      cmap4->entrySelector = FT_GET_USHORT();
+      cmap4->rangeShift    = FT_GET_USHORT();
 
       num_Seg = (FT_UShort)( cmap4->segCountX2 / 2 );
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       /* load segments */
 
-      if ( ALLOC_ARRAY( cmap4->segments,
-                        num_Seg,
-                        TT_CMap4Segment )           ||
-           ACCESS_Frame( ( num_Seg * 4 + 1 ) * 2L ) )
+      if ( FT_NEW_ARRAY( cmap4->segments, num_Seg )   ||
+           FT_FRAME_ENTER( ( num_Seg * 4 + 1 ) * 2L ) )
         goto Fail;
 
       segments = cmap4->segments;
 
       for ( i = 0; i < num_Seg; i++ )
-        segments[i].endCount      = GET_UShort();
+        segments[i].endCount = FT_GET_USHORT();
 
-      (void)GET_UShort();
+      (void)FT_GET_USHORT();
 
       for ( i = 0; i < num_Seg; i++ )
-        segments[i].startCount    = GET_UShort();
+        segments[i].startCount = FT_GET_USHORT();
 
       for ( i = 0; i < num_Seg; i++ )
-        segments[i].idDelta       = GET_Short();
+        segments[i].idDelta = FT_GET_SHORT();
 
       for ( i = 0; i < num_Seg; i++ )
-        segments[i].idRangeOffset = GET_UShort();
+        segments[i].idRangeOffset = FT_GET_USHORT();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       cmap4->numGlyphId = l = (FT_UShort)(
-        ( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFF ) / 2 );
+        ( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFFU ) / 2 );
 
       /* load IDs */
 
-      if ( ALLOC_ARRAY( cmap4->glyphIdArray, l, FT_UShort ) ||
-           ACCESS_Frame( l * 2L )                           )
+      if ( FT_NEW_ARRAY( cmap4->glyphIdArray, l ) ||
+           FT_FRAME_ENTER( l * 2L )               )
       {
-        FREE( cmap4->segments );
+        FT_FREE( cmap4->segments );
         goto Fail;
       }
 
       for ( i = 0; i < l; i++ )
-        cmap4->glyphIdArray[i] = GET_UShort();
+        cmap4->glyphIdArray[i] = FT_GET_USHORT();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       cmap4->last_segment = cmap4->segments;
 
-      cmap->get_index = code_to_index4;
+      cmap->get_index     = code_to_index4;
+      cmap->get_next_char = code_to_next4;
       break;
 
     case 6:
       cmap6 = &cmap->c.cmap6;
 
-      if ( ACCESS_Frame( 6L ) )
+      if ( FT_FRAME_ENTER( 6L ) )
         goto Fail;
 
-      cmap6->language   = GET_UShort();
-      cmap6->firstCode  = GET_UShort();
-      cmap6->entryCount = GET_UShort();
+      cmap6->language   = FT_GET_USHORT();
+      cmap6->firstCode  = FT_GET_USHORT();
+      cmap6->entryCount = FT_GET_USHORT();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       l = cmap6->entryCount;
 
-      if ( ALLOC_ARRAY( cmap6->glyphIdArray, l, FT_Short ) ||
-           ACCESS_Frame( l * 2L )                          )
+      if ( FT_NEW_ARRAY( cmap6->glyphIdArray, l ) ||
+           FT_FRAME_ENTER( l * 2L )               )
         goto Fail;
 
       for ( i = 0; i < l; i++ )
-        cmap6->glyphIdArray[i] = GET_UShort();
+        cmap6->glyphIdArray[i] = FT_GET_USHORT();
 
-      FORGET_Frame();
-      cmap->get_index = code_to_index6;
+      FT_FRAME_EXIT();
+      cmap->get_index     = code_to_index6;
+      cmap->get_next_char = code_to_next6;
       break;
 
     case 8:
     case 12:
       cmap8_12 = &cmap->c.cmap8_12;
 
-      if ( ACCESS_Frame( 8L ) )
+      if ( FT_FRAME_ENTER( 8L ) )
         goto Fail;
 
-      cmap->length       = GET_ULong();
-      cmap8_12->language = GET_ULong();
+      cmap->length       = FT_GET_ULONG();
+      cmap8_12->language = FT_GET_ULONG();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       if ( cmap->format == 8 )
-        if ( FILE_Skip( 8192L ) )
+        if ( FT_STREAM_SKIP( 8192L ) )
           goto Fail;
 
-      if ( READ_ULong( cmap8_12->nGroups ) )
+      if ( FT_READ_ULONG( cmap8_12->nGroups ) )
         goto Fail;
 
       n = cmap8_12->nGroups;
 
-      if ( ALLOC_ARRAY( cmap8_12->groups, n, TT_CMapGroup ) ||
-           ACCESS_Frame( n * 3 * 4L )                       )
+      if ( FT_NEW_ARRAY( cmap8_12->groups, n ) ||
+           FT_FRAME_ENTER( n * 3 * 4L )        )
         goto Fail;
 
       groups = cmap8_12->groups;
 
       for ( j = 0; j < n; j++ )
       {
-        groups[j].startCharCode = GET_ULong();
-        groups[j].endCharCode   = GET_ULong();
-        groups[j].startGlyphID  = GET_ULong();
+        groups[j].startCharCode = FT_GET_ULONG();
+        groups[j].endCharCode   = FT_GET_ULONG();
+        groups[j].startGlyphID  = FT_GET_ULONG();
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       cmap8_12->last_group = cmap8_12->groups;
 
-      cmap->get_index = code_to_index8_12;
+      cmap->get_index     = code_to_index8_12;
+      cmap->get_next_char = code_to_next8_12;
       break;
 
     case 10:
       cmap10 = &cmap->c.cmap10;
 
-      if ( ACCESS_Frame( 16L ) )
+      if ( FT_FRAME_ENTER( 16L ) )
         goto Fail;
 
-      cmap->length          = GET_ULong();
-      cmap10->language      = GET_ULong();
-      cmap10->startCharCode = GET_ULong();
-      cmap10->numChars      = GET_ULong();
+      cmap->length          = FT_GET_ULONG();
+      cmap10->language      = FT_GET_ULONG();
+      cmap10->startCharCode = FT_GET_ULONG();
+      cmap10->numChars      = FT_GET_ULONG();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       n = cmap10->numChars;
 
-      if ( ALLOC_ARRAY( cmap10->glyphs, n, FT_Short ) ||
-           ACCESS_Frame( n * 2L )                     )
+      if ( FT_NEW_ARRAY( cmap10->glyphs, n ) ||
+           FT_FRAME_ENTER( n * 2L )          )
         goto Fail;
 
       for ( j = 0; j < n; j++ )
-        cmap10->glyphs[j] = GET_UShort();
+        cmap10->glyphs[j] = FT_GET_USHORT();
 
-      FORGET_Frame();
-      cmap->get_index = code_to_index10;
+      FT_FRAME_EXIT();
+      cmap->get_index     = code_to_index10;
+      cmap->get_next_char = code_to_next10;
       break;
 
     default:   /* corrupt character mapping table */
@@ -379,14 +406,15 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face :: A handle to the parent face object.                        */
+  /*                                                                       */
   /*    cmap :: A handle to a cmap object.                                 */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_CharMap_Free( TT_Face        face,
-                   TT_CMapTable*  cmap )
+  FT_LOCAL_DEF( FT_Error )
+  TT_CharMap_Free( TT_Face       face,
+                   TT_CMapTable  cmap )
   {
     FT_Memory  memory;
 
@@ -399,34 +427,34 @@
     switch ( cmap->format )
     {
     case 0:
-      FREE( cmap->c.cmap0.glyphIdArray );
+      FT_FREE( cmap->c.cmap0.glyphIdArray );
       break;
 
     case 2:
-      FREE( cmap->c.cmap2.subHeaderKeys );
-      FREE( cmap->c.cmap2.subHeaders );
-      FREE( cmap->c.cmap2.glyphIdArray );
+      FT_FREE( cmap->c.cmap2.subHeaderKeys );
+      FT_FREE( cmap->c.cmap2.subHeaders );
+      FT_FREE( cmap->c.cmap2.glyphIdArray );
       break;
 
     case 4:
-      FREE( cmap->c.cmap4.segments );
-      FREE( cmap->c.cmap4.glyphIdArray );
+      FT_FREE( cmap->c.cmap4.segments );
+      FT_FREE( cmap->c.cmap4.glyphIdArray );
       cmap->c.cmap4.segCountX2 = 0;
       break;
 
     case 6:
-      FREE( cmap->c.cmap6.glyphIdArray );
+      FT_FREE( cmap->c.cmap6.glyphIdArray );
       cmap->c.cmap6.entryCount = 0;
       break;
 
     case 8:
     case 12:
-      FREE( cmap->c.cmap8_12.groups );
+      FT_FREE( cmap->c.cmap8_12.groups );
       cmap->c.cmap8_12.nGroups = 0;
       break;
 
     case 10:
-      FREE( cmap->c.cmap10.glyphs );
+      FT_FREE( cmap->c.cmap10.glyphs );
       cmap->c.cmap10.numChars = 0;
       break;
 
@@ -452,16 +480,17 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
   /*    cmap0    :: A pointer to a cmap table in format 0.                 */
   /*                                                                       */
   /* <Return>                                                              */
   /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
   /*                                                                       */
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index0( TT_CMapTable*  cmap,
-                  FT_ULong       charCode )
+  code_to_index0( TT_CMapTable  cmap,
+                  FT_ULong      charCode )
   {
-    TT_CMap0*  cmap0 = &cmap->c.cmap0;
+    TT_CMap0  cmap0 = &cmap->c.cmap0;
 
 
     return ( charCode <= 0xFF ? cmap0->glyphIdArray[charCode] : 0 );
@@ -471,6 +500,38 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    code_to_next0                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finds the next encoded character after the given one.  Uses        */
+  /*    format 0. `charCode' must be in the range 0x00-0xFF (otherwise 0   */
+  /*    is returned).                                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
+  /*    cmap0    :: A pointer to a cmap table in format 0.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next char code.  0 if no higher one is encoded.                    */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next0( TT_CMapTable  cmap,
+                 FT_ULong      charCode )
+  {
+    TT_CMap0  cmap0 = &cmap->c.cmap0;
+
+
+    while ( ++charCode <= 0xFF )
+      if ( cmap0->glyphIdArray[charCode] )
+        return ( charCode );
+    return ( 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    code_to_index2                                                     */
   /*                                                                       */
   /* <Description>                                                         */
@@ -478,20 +539,21 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
   /*    cmap2    :: A pointer to a cmap table in format 2.                 */
   /*                                                                       */
   /* <Return>                                                              */
   /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
   /*                                                                       */
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index2( TT_CMapTable*  cmap,
-                  FT_ULong       charCode )
+  code_to_index2( TT_CMapTable  cmap,
+                  FT_ULong      charCode )
   {
-    FT_UInt             result, index1, offset;
-    FT_UInt             char_lo;
-    FT_ULong            char_hi;
-    TT_CMap2SubHeader*  sh2;
-    TT_CMap2*           cmap2;
+    FT_UInt            result, index1, offset;
+    FT_UInt            char_lo;
+    FT_ULong           char_hi;
+    TT_CMap2SubHeader  sh2;
+    TT_CMap2           cmap2;
 
 
     cmap2   = &cmap->c.cmap2;
@@ -525,7 +587,7 @@
       {
         result = cmap2->glyphIdArray[offset];
         if ( result )
-          result = ( result + sh2->idDelta ) & 0xFFFF;
+          result = ( result + sh2->idDelta ) & 0xFFFFU;
       }
     }
 
@@ -536,6 +598,90 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    code_to_next2                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 2.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
+  /*    cmap2    :: A pointer to a cmap table in format 2.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next2( TT_CMapTable  cmap,
+                 FT_ULong      charCode )
+  {
+    FT_UInt            index1, offset;
+    FT_UInt            char_lo;
+    FT_ULong           char_hi;
+    TT_CMap2SubHeader  sh2;
+    TT_CMap2           cmap2;
+
+
+    cmap2 = &cmap->c.cmap2;
+    charCode++;
+
+    /*
+     * This is relatively simplistic -- look for a subHeader containing
+     * glyphs and then walk to the first glyph in that subHeader.
+     */
+    while ( charCode < 0x10000 )
+    {
+      char_lo = (FT_UInt)( charCode & 0xFF );
+      char_hi = charCode >> 8;
+  
+      if ( char_hi == 0 )
+      {
+        /* an 8-bit character code -- we use the subHeader 0 in this case */
+        /* to test whether the character code is in the charmap           */
+        index1 = cmap2->subHeaderKeys[char_lo];
+        if ( index1 != 0 )
+        {
+          charCode++;
+          continue;
+        }
+      }
+      else
+      {
+        /* a 16-bit character code */
+        index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
+        if ( index1 == 0 )
+        {
+          charCode = ( char_hi + 1 ) << 8;
+          continue;
+        }
+      }
+  
+      sh2      = cmap2->subHeaders + index1;
+      char_lo -= sh2->firstCode;
+  
+      if ( char_lo > (FT_UInt)sh2->entryCount )
+      {
+        charCode = ( char_hi + 1 ) << 8;
+        continue;
+      }
+      
+      offset = sh2->idRangeOffset / 2 + char_lo;
+      if ( offset >= (FT_UInt)cmap2->numGlyphId ||
+           cmap2->glyphIdArray[offset] == 0     )
+      {
+        charCode++;
+        continue;
+      }
+      
+      return charCode;
+    }
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    code_to_index4                                                     */
   /*                                                                       */
   /* <Description>                                                         */
@@ -543,18 +689,19 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
   /*    cmap4    :: A pointer to a cmap table in format 4.                 */
   /*                                                                       */
   /* <Return>                                                              */
   /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
   /*                                                                       */
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index4( TT_CMapTable*  cmap,
-                  FT_ULong       charCode )
+  code_to_index4( TT_CMapTable  cmap,
+                  FT_ULong      charCode )
   {
-    FT_UInt          result, index1, segCount;
-    TT_CMap4*        cmap4;
-    TT_CMap4Segment  *seg4, *limit;
+    FT_UInt             result, index1, segCount;
+    TT_CMap4            cmap4;
+    TT_CMap4SegmentRec  *seg4, *limit;
 
 
     cmap4    = &cmap->c.cmap4;
@@ -599,7 +746,7 @@
     /* directly                                                  */
 
     if ( seg4->idRangeOffset == 0 )
-      result = ( charCode + seg4->idDelta ) & 0xFFFF;
+      result = ( charCode + seg4->idDelta ) & 0xFFFFU;
     else
     {
       /* otherwise, we must use the glyphIdArray to do it */
@@ -610,7 +757,7 @@
 
       if ( index1 < (FT_UInt)cmap4->numGlyphId &&
            cmap4->glyphIdArray[index1] != 0    )
-        result = ( cmap4->glyphIdArray[index1] + seg4->idDelta ) & 0xFFFF;
+        result = ( cmap4->glyphIdArray[index1] + seg4->idDelta ) & 0xFFFFU;
     }
 
     return result;
@@ -620,6 +767,74 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    code_to_next4                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 4.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
+  /*    cmap     :: A pointer to a cmap table in format 4.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next4( TT_CMapTable  cmap,
+                 FT_ULong      charCode )
+  {
+    FT_UInt             index1, segCount;
+    TT_CMap4            cmap4;
+    TT_CMap4SegmentRec  *seg4, *limit;
+
+
+    cmap4    = &cmap->c.cmap4;
+    segCount = cmap4->segCountX2 / 2;
+    limit    = cmap4->segments + segCount;
+
+    charCode++;
+
+    for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
+    {
+      /* The ranges are sorted in increasing order.  If we are out of */
+      /* the range here, the char code isn't in the charmap, so exit. */
+
+      if ( charCode <= (FT_UInt)seg4->endCount )
+        goto Found;
+    }
+    return 0;
+
+  Found:
+    if ( charCode < (FT_ULong) seg4->startCount )
+      charCode = seg4->startCount;
+
+    /* if the idRangeOffset is 0, all chars in the map exist */
+
+    if ( seg4->idRangeOffset == 0 )
+      return ( charCode );
+    
+    while ( charCode <= (FT_UInt) seg4->endCount )
+    {
+      /* otherwise, we must use the glyphIdArray to do it */
+      index1 = (FT_UInt)( seg4->idRangeOffset / 2
+                          + ( charCode - seg4->startCount )
+                          + ( seg4 - cmap4->segments )
+                          - segCount );
+
+      if ( index1 < (FT_UInt)cmap4->numGlyphId &&
+           cmap4->glyphIdArray[index1] != 0    )
+        return ( charCode );
+      charCode++;
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    code_to_index6                                                     */
   /*                                                                       */
   /* <Description>                                                         */
@@ -627,17 +842,18 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
   /*    cmap6    :: A pointer to a cmap table in format 6.                 */
   /*                                                                       */
   /* <Return>                                                              */
   /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
   /*                                                                       */
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index6( TT_CMapTable*  cmap,
-                  FT_ULong       charCode )
+  code_to_index6( TT_CMapTable  cmap,
+                  FT_ULong      charCode )
   {
-    TT_CMap6*  cmap6;
-    FT_UInt    result = 0;
+    TT_CMap6  cmap6;
+    FT_UInt   result = 0;
 
 
     cmap6     = &cmap->c.cmap6;
@@ -653,6 +869,49 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    code_to_next6                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 6.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
+  /*    cmap     :: A pointer to a cmap table in format 6.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next6( TT_CMapTable  cmap,
+                 FT_ULong      charCode )
+  {
+    TT_CMap6  cmap6;
+
+
+    charCode++;
+    
+    cmap6 = &cmap->c.cmap6;
+    
+    if ( charCode < (FT_ULong) cmap6->firstCode )
+      charCode = cmap6->firstCode;
+    
+    charCode -= cmap6->firstCode;
+
+    while ( charCode < (FT_UInt)cmap6->entryCount )
+    {
+      if ( cmap6->glyphIdArray[charCode] != 0 )
+        return charCode + cmap6->firstCode;
+      charCode++;
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    code_to_index8_12                                                  */
   /*                                                                       */
   /* <Description>                                                         */
@@ -661,17 +920,18 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
   /*    cmap8_12 :: A pointer to a cmap table in format 8 or 12.           */
   /*                                                                       */
   /* <Return>                                                              */
   /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
   /*                                                                       */
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index8_12( TT_CMapTable*  cmap,
-                     FT_ULong       charCode )
+  code_to_index8_12( TT_CMapTable  cmap,
+                     FT_ULong      charCode )
   {
-    TT_CMap8_12*  cmap8_12;
-    TT_CMapGroup  *group, *limit;
+    TT_CMap8_12      cmap8_12;
+    TT_CMapGroupRec  *group, *limit;
 
 
     cmap8_12 = &cmap->c.cmap8_12;
@@ -718,6 +978,52 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
+  /*    code_to_next8_12                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 8 or 12.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
+  /*    cmap     :: A pointer to a cmap table in format 8 or 12.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next8_12( TT_CMapTable  cmap,
+                    FT_ULong      charCode )
+  {
+    TT_CMap8_12      cmap8_12;
+    TT_CMapGroupRec  *group, *limit;
+
+
+    charCode++;
+    cmap8_12 = &cmap->c.cmap8_12;
+    limit    = cmap8_12->groups + cmap8_12->nGroups;
+
+    for ( group = cmap8_12->groups; group < limit; group++ )
+    {
+      /* the ranges are sorted in increasing order.  If we are out of */
+      /* the range here, the char code isn't in the charmap, so exit. */
+
+      if ( charCode <= group->endCharCode )
+        goto Found;
+    }
+    return 0;
+
+  Found:
+    if ( charCode < group->startCharCode )
+      charCode = group->startCharCode;
+    
+    return charCode;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
   /*    code_to_index10                                                    */
   /*                                                                       */
   /* <Description>                                                         */
@@ -726,17 +1032,18 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
   /*    cmap10   :: A pointer to a cmap table in format 10.                */
   /*                                                                       */
   /* <Return>                                                              */
   /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
   /*                                                                       */
   FT_CALLBACK_DEF( FT_UInt )
-  code_to_index10( TT_CMapTable*  cmap,
-                   FT_ULong       charCode )
+  code_to_index10( TT_CMapTable  cmap,
+                   FT_ULong      charCode )
   {
-    TT_CMap10*  cmap10;
-    FT_UInt     result = 0;
+    TT_CMap10  cmap10;
+    FT_UInt    result = 0;
 
 
     cmap10    = &cmap->c.cmap10;
@@ -750,6 +1057,52 @@
       result = cmap10->glyphs[charCode];
 
     return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_next10                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 10.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*                                                                       */
+  /*    cmap     :: A pointer to a cmap table in format 10.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next10( TT_CMapTable  cmap,
+                  FT_ULong      charCode )
+  {
+    TT_CMap10  cmap10;
+
+
+    charCode++;
+    cmap10 = &cmap->c.cmap10;
+    
+    if ( charCode < cmap10->startCharCode )
+      charCode = cmap10->startCharCode;
+    
+    charCode -= cmap10->startCharCode;
+
+    /* the overflow trick for comparison works here also since the number */
+    /* of glyphs (even if numChars is specified as ULong in the specs) in */
+    /* an OpenType font is limited to 64k                                 */
+
+    while ( charCode < cmap10->numChars )
+    {
+      if ( cmap10->glyphs[charCode] )
+        return ( charCode + cmap10->startCharCode );
+      charCode++;
+    }
+
+    return 0;
   }
 
 
Index: xc/extras/freetype2/src/sfnt/ttcmap.c.save
diff -u /dev/null xc/extras/freetype2/src/sfnt/ttcmap.c.save:1.2
--- /dev/null	Thu Feb 27 12:20:49 2003
+++ xc/extras/freetype2/src/sfnt/ttcmap.c.save	Fri Oct 25 11:01:04 2002
@@ -0,0 +1,1099 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttcmap.c                                                               */
+/*                                                                         */
+/*    TrueType character mapping table (cmap) support (body).              */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include "ttload.h"
+#include "ttcmap.h"
+
+#include "sferrors.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_ttcmap
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index0( TT_CMapTable*  charmap,
+                  FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next0( TT_CMapTable*  charmap,
+                 FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index2( TT_CMapTable*  charmap,
+                  FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next2( TT_CMapTable*  charmap,
+                 FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index4( TT_CMapTable*  charmap,
+                  FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next4( TT_CMapTable*  charmap,
+                 FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index6( TT_CMapTable*  charmap,
+                  FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next6( TT_CMapTable*  charmap,
+                 FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index8_12( TT_CMapTable*  charmap,
+                     FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next8_12( TT_CMapTable*  charmap,
+                    FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index10( TT_CMapTable*  charmap,
+                   FT_ULong       char_code );
+
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next10( TT_CMapTable*  charmap,
+                  FT_ULong       char_code );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_CharMap_Load                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads a given TrueType character map into memory.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the parent face object.                      */
+  /*    stream :: A handle to the current stream object.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    table  :: A pointer to a cmap object.                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The function assumes that the stream is already in use (i.e.,      */
+  /*    opened).  In case of error, all partially allocated tables are     */
+  /*    released.                                                          */
+  /*                                                                       */
+  FT_LOCAL_DEF FT_Error
+  TT_CharMap_Load( TT_Face        face,
+                   TT_CMapTable*  cmap,
+                   FT_Stream      stream )
+  {
+    FT_Error      error;
+    FT_Memory     memory;
+    FT_UShort     num_SH, num_Seg, i;
+    FT_ULong      j, n;
+
+    FT_UShort     u, l;
+
+    TT_CMap0*     cmap0;
+    TT_CMap2*     cmap2;
+    TT_CMap4*     cmap4;
+    TT_CMap6*     cmap6;
+    TT_CMap8_12*  cmap8_12;
+    TT_CMap10*    cmap10;
+
+    TT_CMap2SubHeader*  cmap2sub;
+    TT_CMap4Segment*    segments;
+    TT_CMapGroup*       groups;
+
+
+    if ( cmap->loaded )
+      return SFNT_Err_Ok;
+
+    memory = stream->memory;
+
+    if ( FILE_Seek( cmap->offset ) )
+      return error;
+
+    switch ( cmap->format )
+    {
+    case 0:
+      cmap0 = &cmap->c.cmap0;
+
+      if ( READ_UShort( cmap0->language )         ||
+           ALLOC( cmap0->glyphIdArray, 256L )     ||
+           FILE_Read( cmap0->glyphIdArray, 256L ) )
+        goto Fail;
+
+      cmap->get_index = code_to_index0;
+      cmap->get_next_char = code_to_next0;
+      break;
+
+    case 2:
+      num_SH = 0;
+      cmap2  = &cmap->c.cmap2;
+
+      /* allocate subheader keys */
+
+      if ( ALLOC_ARRAY( cmap2->subHeaderKeys, 256, FT_UShort ) ||
+           ACCESS_Frame( 2L + 512L )                           )
+        goto Fail;
+
+      cmap2->language = GET_UShort();
+
+      for ( i = 0; i < 256; i++ )
+      {
+        u = (FT_UShort)( GET_UShort() / 8 );
+        cmap2->subHeaderKeys[i] = u;
+
+        if ( num_SH < u )
+          num_SH = u;
+      }
+
+      FORGET_Frame();
+
+      /* load subheaders */
+
+      cmap2->numGlyphId = l = (FT_UShort)(
+        ( ( cmap->length - 2L * ( 256 + 3 ) - num_SH * 8L ) & 0xFFFF ) / 2 );
+
+      if ( ALLOC_ARRAY( cmap2->subHeaders,
+                        num_SH + 1,
+                        TT_CMap2SubHeader )    ||
+           ACCESS_Frame( ( num_SH + 1 ) * 8L ) )
+      {
+        FREE( cmap2->subHeaderKeys );
+        goto Fail;
+      }
+
+      cmap2sub = cmap2->subHeaders;
+
+      for ( i = 0; i <= num_SH; i++ )
+      {
+        cmap2sub->firstCode     = GET_UShort();
+        cmap2sub->entryCount    = GET_UShort();
+        cmap2sub->idDelta       = GET_Short();
+        /* we apply the location offset immediately */
+        cmap2sub->idRangeOffset = (FT_UShort)(
+          GET_UShort() - ( num_SH - i ) * 8 - 2 );
+
+        cmap2sub++;
+      }
+
+      FORGET_Frame();
+
+      /* load glyph IDs */
+
+      if ( ALLOC_ARRAY( cmap2->glyphIdArray, l, FT_UShort ) ||
+           ACCESS_Frame( l * 2L )                           )
+      {
+        FREE( cmap2->subHeaders );
+        FREE( cmap2->subHeaderKeys );
+        goto Fail;
+      }
+
+      for ( i = 0; i < l; i++ )
+        cmap2->glyphIdArray[i] = GET_UShort();
+
+      FORGET_Frame();
+
+      cmap->get_index = code_to_index2;
+      cmap->get_next_char = code_to_next2;
+      break;
+
+    case 4:
+      cmap4 = &cmap->c.cmap4;
+
+      /* load header */
+
+      if ( ACCESS_Frame( 10L ) )
+        goto Fail;
+
+      cmap4->language      = GET_UShort();
+      cmap4->segCountX2    = GET_UShort();
+      cmap4->searchRange   = GET_UShort();
+      cmap4->entrySelector = GET_UShort();
+      cmap4->rangeShift    = GET_UShort();
+
+      num_Seg = (FT_UShort)( cmap4->segCountX2 / 2 );
+
+      FORGET_Frame();
+
+      /* load segments */
+
+      if ( ALLOC_ARRAY( cmap4->segments,
+                        num_Seg,
+                        TT_CMap4Segment )           ||
+           ACCESS_Frame( ( num_Seg * 4 + 1 ) * 2L ) )
+        goto Fail;
+
+      segments = cmap4->segments;
+
+      for ( i = 0; i < num_Seg; i++ )
+        segments[i].endCount      = GET_UShort();
+
+      (void)GET_UShort();
+
+      for ( i = 0; i < num_Seg; i++ )
+        segments[i].startCount    = GET_UShort();
+
+      for ( i = 0; i < num_Seg; i++ )
+        segments[i].idDelta       = GET_Short();
+
+      for ( i = 0; i < num_Seg; i++ )
+        segments[i].idRangeOffset = GET_UShort();
+
+      FORGET_Frame();
+
+      cmap4->numGlyphId = l = (FT_UShort)(
+        ( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFF ) / 2 );
+
+      /* load IDs */
+
+      if ( ALLOC_ARRAY( cmap4->glyphIdArray, l, FT_UShort ) ||
+           ACCESS_Frame( l * 2L )                           )
+      {
+        FREE( cmap4->segments );
+        goto Fail;
+      }
+
+      for ( i = 0; i < l; i++ )
+        cmap4->glyphIdArray[i] = GET_UShort();
+
+      FORGET_Frame();
+
+      cmap4->last_segment = cmap4->segments;
+
+      cmap->get_index = code_to_index4;
+      cmap->get_next_char = code_to_next4;
+      break;
+
+    case 6:
+      cmap6 = &cmap->c.cmap6;
+
+      if ( ACCESS_Frame( 6L ) )
+        goto Fail;
+
+      cmap6->language   = GET_UShort();
+      cmap6->firstCode  = GET_UShort();
+      cmap6->entryCount = GET_UShort();
+
+      FORGET_Frame();
+
+      l = cmap6->entryCount;
+
+      if ( ALLOC_ARRAY( cmap6->glyphIdArray, l, FT_Short ) ||
+           ACCESS_Frame( l * 2L )                          )
+        goto Fail;
+
+      for ( i = 0; i < l; i++ )
+        cmap6->glyphIdArray[i] = GET_UShort();
+
+      FORGET_Frame();
+      cmap->get_index = code_to_index6;
+      cmap->get_next_char = code_to_next6;
+      break;
+
+    case 8:
+    case 12:
+      cmap8_12 = &cmap->c.cmap8_12;
+
+      if ( ACCESS_Frame( 8L ) )
+        goto Fail;
+
+      cmap->length       = GET_ULong();
+      cmap8_12->language = GET_ULong();
+
+      FORGET_Frame();
+
+      if ( cmap->format == 8 )
+        if ( FILE_Skip( 8192L ) )
+          goto Fail;
+
+      if ( READ_ULong( cmap8_12->nGroups ) )
+        goto Fail;
+
+      n = cmap8_12->nGroups;
+
+      if ( ALLOC_ARRAY( cmap8_12->groups, n, TT_CMapGroup ) ||
+           ACCESS_Frame( n * 3 * 4L )                       )
+        goto Fail;
+
+      groups = cmap8_12->groups;
+
+      for ( j = 0; j < n; j++ )
+      {
+        groups[j].startCharCode = GET_ULong();
+        groups[j].endCharCode   = GET_ULong();
+        groups[j].startGlyphID  = GET_ULong();
+      }
+
+      FORGET_Frame();
+
+      cmap8_12->last_group = cmap8_12->groups;
+
+      cmap->get_index = code_to_index8_12;
+      cmap->get_next_char = code_to_next8_12;
+      break;
+
+    case 10:
+      cmap10 = &cmap->c.cmap10;
+
+      if ( ACCESS_Frame( 16L ) )
+        goto Fail;
+
+      cmap->length          = GET_ULong();
+      cmap10->language      = GET_ULong();
+      cmap10->startCharCode = GET_ULong();
+      cmap10->numChars      = GET_ULong();
+
+      FORGET_Frame();
+
+      n = cmap10->numChars;
+
+      if ( ALLOC_ARRAY( cmap10->glyphs, n, FT_Short ) ||
+           ACCESS_Frame( n * 2L )                     )
+        goto Fail;
+
+      for ( j = 0; j < n; j++ )
+        cmap10->glyphs[j] = GET_UShort();
+
+      FORGET_Frame();
+      cmap->get_index = code_to_index10;
+      cmap->get_next_char = code_to_next10;
+      break;
+
+    default:   /* corrupt character mapping table */
+      return SFNT_Err_Invalid_CharMap_Format;
+
+    }
+
+    return SFNT_Err_Ok;
+
+  Fail:
+    TT_CharMap_Free( face, cmap );
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    TT_CharMap_Free                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a character mapping table.                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the parent face object.                        */
+  /*    cmap :: A handle to a cmap object.                                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF FT_Error
+  TT_CharMap_Free( TT_Face        face,
+                   TT_CMapTable*  cmap )
+  {
+    FT_Memory  memory;
+
+
+    if ( !cmap )
+      return SFNT_Err_Ok;
+
+    memory = face->root.driver->root.memory;
+
+    switch ( cmap->format )
+    {
+    case 0:
+      FREE( cmap->c.cmap0.glyphIdArray );
+      break;
+
+    case 2:
+      FREE( cmap->c.cmap2.subHeaderKeys );
+      FREE( cmap->c.cmap2.subHeaders );
+      FREE( cmap->c.cmap2.glyphIdArray );
+      break;
+
+    case 4:
+      FREE( cmap->c.cmap4.segments );
+      FREE( cmap->c.cmap4.glyphIdArray );
+      cmap->c.cmap4.segCountX2 = 0;
+      break;
+
+    case 6:
+      FREE( cmap->c.cmap6.glyphIdArray );
+      cmap->c.cmap6.entryCount = 0;
+      break;
+
+    case 8:
+    case 12:
+      FREE( cmap->c.cmap8_12.groups );
+      cmap->c.cmap8_12.nGroups = 0;
+      break;
+
+    case 10:
+      FREE( cmap->c.cmap10.glyphs );
+      cmap->c.cmap10.numChars = 0;
+      break;
+
+    default:
+      /* invalid table format, do nothing */
+      ;
+    }
+
+    cmap->loaded = FALSE;
+    return SFNT_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_index0                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts the character code into a glyph index.  Uses format 0.    */
+  /*    `charCode' must be in the range 0x00-0xFF (otherwise 0 is          */
+  /*    returned).                                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap0    :: A pointer to a cmap table in format 0.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index0( TT_CMapTable*  cmap,
+                  FT_ULong       charCode )
+  {
+    TT_CMap0*  cmap0 = &cmap->c.cmap0;
+
+
+    return ( charCode <= 0xFF ? cmap0->glyphIdArray[charCode] : 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_next0                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finds the next encoded character after the given one.  Uses        */
+  /*    format 0. `charCode' must be in the range 0x00-0xFF (otherwise 0   */
+  /*    is returned).                                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap0    :: A pointer to a cmap table in format 0.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next char code.  0 if no higher one is encoded.                    */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next0( TT_CMapTable*  cmap,
+                 FT_ULong       charCode )
+  {
+    TT_CMap0*  cmap0 = &cmap->c.cmap0;
+
+
+    while ( ++charCode <= 0xFF )
+      if ( cmap0->glyphIdArray[charCode] )
+        return ( charCode );
+    return ( 0 );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_index2                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts the character code into a glyph index.  Uses format 2.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap2    :: A pointer to a cmap table in format 2.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index2( TT_CMapTable*  cmap,
+                  FT_ULong       charCode )
+  {
+    FT_UInt             result, index1, offset;
+    FT_UInt             char_lo;
+    FT_ULong            char_hi;
+    TT_CMap2SubHeader*  sh2;
+    TT_CMap2*           cmap2;
+
+
+    cmap2   = &cmap->c.cmap2;
+    result  = 0;
+    char_lo = (FT_UInt)( charCode & 0xFF );
+    char_hi = charCode >> 8;
+
+    if ( char_hi == 0 )
+    {
+      /* an 8-bit character code -- we use the subHeader 0 in this case */
+      /* to test whether the character code is in the charmap           */
+      index1 = cmap2->subHeaderKeys[char_lo];
+      if ( index1 != 0 )
+        return 0;
+    }
+    else
+    {
+      /* a 16-bit character code */
+      index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
+      if ( index1 == 0 )
+        return 0;
+    }
+
+    sh2      = cmap2->subHeaders + index1;
+    char_lo -= sh2->firstCode;
+
+    if ( char_lo < (FT_UInt)sh2->entryCount )
+    {
+      offset = sh2->idRangeOffset / 2 + char_lo;
+      if ( offset < (FT_UInt)cmap2->numGlyphId )
+      {
+        result = cmap2->glyphIdArray[offset];
+        if ( result )
+          result = ( result + sh2->idDelta ) & 0xFFFF;
+      }
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_next2                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 2.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap2    :: A pointer to a cmap table in format 2.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next2( TT_CMapTable*  cmap,
+                 FT_ULong       charCode )
+  {
+    FT_UInt             index1, offset;
+    FT_UInt             char_lo;
+    FT_ULong            char_hi;
+    TT_CMap2SubHeader*  sh2;
+    TT_CMap2*           cmap2;
+
+
+    cmap2 = &cmap->c.cmap2;
+    charCode++;
+
+    /*
+     * This is relatively simplistic -- look for a subHeader containing
+     * glyphs and then walk to the first glyph in that subHeader.
+     */
+    while ( charCode < 0x10000 )
+    {
+      char_lo = (FT_UInt)( charCode & 0xFF );
+      char_hi = charCode >> 8;
+  
+      if ( char_hi == 0 )
+      {
+        /* an 8-bit character code -- we use the subHeader 0 in this case */
+        /* to test whether the character code is in the charmap           */
+        index1 = cmap2->subHeaderKeys[char_lo];
+        if ( index1 != 0 )
+        {
+          charCode++;
+          continue;
+        }
+      }
+      else
+      {
+        /* a 16-bit character code */
+        index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
+        if ( index1 == 0 )
+        {
+          charCode = ( char_hi + 1 ) << 8;
+          continue;
+        }
+      }
+  
+      sh2      = cmap2->subHeaders + index1;
+      char_lo -= sh2->firstCode;
+  
+      if ( char_lo > (FT_UInt)sh2->entryCount )
+      {
+        charCode = ( char_hi + 1 ) << 8;
+        continue;
+      }
+      
+      offset = sh2->idRangeOffset / 2 + char_lo;
+      if ( offset >= (FT_UInt)cmap2->numGlyphId ||
+           cmap2->glyphIdArray[offset] == 0     )
+      {
+        charCode++;
+        continue;
+      }
+      
+      return charCode;
+    }
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_index4                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts the character code into a glyph index.  Uses format 4.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap4    :: A pointer to a cmap table in format 4.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index4( TT_CMapTable*  cmap,
+                  FT_ULong       charCode )
+  {
+    FT_UInt          result, index1, segCount;
+    TT_CMap4*        cmap4;
+    TT_CMap4Segment  *seg4, *limit;
+
+
+    cmap4    = &cmap->c.cmap4;
+    result   = 0;
+    segCount = cmap4->segCountX2 / 2;
+    limit    = cmap4->segments + segCount;
+
+    /* first, check against the last used segment */
+
+    seg4 = cmap4->last_segment;
+
+    /* the following is equivalent to performing two tests, as in         */
+    /*                                                                    */
+    /*  if ( charCode >= seg4->startCount && charCode <= seg4->endCount ) */
+    /*                                                                    */
+    /* This is a bit strange, but it is faster, and the idea behind the   */
+    /* cache is to significantly speed up charcode to glyph index         */
+    /* conversion.                                                        */
+
+    if ( (FT_ULong)( charCode       - seg4->startCount ) <
+         (FT_ULong)( seg4->endCount - seg4->startCount ) )
+      goto Found1;
+
+    for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
+    {
+      /* the ranges are sorted in increasing order.  If we are out of */
+      /* the range here, the char code isn't in the charmap, so exit. */
+
+      if ( charCode > (FT_UInt)seg4->endCount )
+        continue;
+
+      if ( charCode >= (FT_UInt)seg4->startCount )
+        goto Found;
+    }
+    return 0;
+
+  Found:
+    cmap4->last_segment = seg4;
+
+  Found1:
+    /* if the idRangeOffset is 0, we can compute the glyph index */
+    /* directly                                                  */
+
+    if ( seg4->idRangeOffset == 0 )
+      result = ( charCode + seg4->idDelta ) & 0xFFFF;
+    else
+    {
+      /* otherwise, we must use the glyphIdArray to do it */
+      index1 = (FT_UInt)( seg4->idRangeOffset / 2
+                          + ( charCode - seg4->startCount )
+                          + ( seg4 - cmap4->segments )
+                          - segCount );
+
+      if ( index1 < (FT_UInt)cmap4->numGlyphId &&
+           cmap4->glyphIdArray[index1] != 0    )
+        result = ( cmap4->glyphIdArray[index1] + seg4->idDelta ) & 0xFFFF;
+    }
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_next4                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 4.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap     :: A pointer to a cmap table in format 4.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next4( TT_CMapTable*  cmap,
+                 FT_ULong       charCode )
+  {
+    FT_UInt          index1, segCount;
+    TT_CMap4*        cmap4;
+    TT_CMap4Segment  *seg4, *limit;
+
+
+    cmap4    = &cmap->c.cmap4;
+    segCount = cmap4->segCountX2 / 2;
+    limit    = cmap4->segments + segCount;
+
+    charCode++;
+
+    for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
+    {
+      /* The ranges are sorted in increasing order.  If we are out of */
+      /* the range here, the char code isn't in the charmap, so exit. */
+
+      if ( charCode <= (FT_UInt)seg4->endCount )
+        goto Found;
+    }
+    return 0;
+
+  Found:
+    if ( charCode < (FT_ULong) seg4->startCount )
+      charCode = seg4->startCount;
+
+    /* if the idRangeOffset is 0, all chars in the map exist */
+
+    if ( seg4->idRangeOffset == 0 )
+      return ( charCode );
+    
+    while ( charCode <= (FT_UInt) seg4->endCount )
+    {
+      /* otherwise, we must use the glyphIdArray to do it */
+      index1 = (FT_UInt)( seg4->idRangeOffset / 2
+                          + ( charCode - seg4->startCount )
+                          + ( seg4 - cmap4->segments )
+                          - segCount );
+
+      if ( index1 < (FT_UInt)cmap4->numGlyphId &&
+           cmap4->glyphIdArray[index1] != 0    )
+        return ( charCode );
+      charCode++;
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_index6                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts the character code into a glyph index.  Uses format 6.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap6    :: A pointer to a cmap table in format 6.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index6( TT_CMapTable*  cmap,
+                  FT_ULong       charCode )
+  {
+    TT_CMap6*  cmap6;
+    FT_UInt    result = 0;
+
+
+    cmap6     = &cmap->c.cmap6;
+    charCode -= cmap6->firstCode;
+
+    if ( charCode < (FT_UInt)cmap6->entryCount )
+      result = cmap6->glyphIdArray[charCode];
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_next6                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 6.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap     :: A pointer to a cmap table in format 6.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next6( TT_CMapTable*  cmap,
+                 FT_ULong       charCode )
+  {
+    TT_CMap6*  cmap6;
+
+
+    charCode++;
+    
+    cmap6 = &cmap->c.cmap6;
+    
+    if ( charCode < (FT_ULong) cmap6->firstCode )
+      charCode = cmap6->firstCode;
+    
+    charCode -= cmap6->firstCode;
+
+    while ( charCode < (FT_UInt)cmap6->entryCount )
+    {
+      if ( cmap6->glyphIdArray[charCode] != 0 )
+        return charCode + cmap6->firstCode;
+      charCode++;
+    }
+
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_index8_12                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts the (possibly 32bit) character code into a glyph index.   */
+  /*    Uses format 8 or 12.                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap8_12 :: A pointer to a cmap table in format 8 or 12.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index8_12( TT_CMapTable*  cmap,
+                     FT_ULong       charCode )
+  {
+    TT_CMap8_12*  cmap8_12;
+    TT_CMapGroup  *group, *limit;
+
+
+    cmap8_12 = &cmap->c.cmap8_12;
+    limit    = cmap8_12->groups + cmap8_12->nGroups;
+
+    /* first, check against the last used group */
+
+    group = cmap8_12->last_group;
+
+    /* the following is equivalent to performing two tests, as in       */
+    /*                                                                  */
+    /*  if ( charCode >= group->startCharCode &&                        */
+    /*       charCode <= group->endCharCode   )                         */
+    /*                                                                  */
+    /* This is a bit strange, but it is faster, and the idea behind the */
+    /* cache is to significantly speed up charcode to glyph index       */
+    /* conversion.                                                      */
+
+    if ( (FT_ULong)( charCode           - group->startCharCode ) <
+         (FT_ULong)( group->endCharCode - group->startCharCode ) )
+      goto Found1;
+
+    for ( group = cmap8_12->groups; group < limit; group++ )
+    {
+      /* the ranges are sorted in increasing order.  If we are out of */
+      /* the range here, the char code isn't in the charmap, so exit. */
+
+      if ( charCode > group->endCharCode )
+        continue;
+
+      if ( charCode >= group->startCharCode )
+        goto Found;
+    }
+    return 0;
+
+  Found:
+    cmap8_12->last_group = group;
+
+  Found1:
+    return group->startGlyphID + (FT_UInt)( charCode - group->startCharCode );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_next8_12                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 8 or 12.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap     :: A pointer to a cmap table in format 8 or 12.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next8_12( TT_CMapTable*  cmap,
+                    FT_ULong       charCode )
+  {
+    TT_CMap8_12*  cmap8_12;
+    TT_CMapGroup  *group, *limit;
+
+
+    charCode++;
+    cmap8_12 = &cmap->c.cmap8_12;
+    limit    = cmap8_12->groups + cmap8_12->nGroups;
+
+    for ( group = cmap8_12->groups; group < limit; group++ )
+    {
+      /* the ranges are sorted in increasing order.  If we are out of */
+      /* the range here, the char code isn't in the charmap, so exit. */
+
+      if ( charCode <= group->endCharCode )
+        goto Found;
+    }
+    return 0;
+
+  Found:
+    if ( charCode < group->startCharCode )
+      charCode = group->startCharCode;
+    
+    return charCode;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_index10                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts the (possibly 32bit) character code into a glyph index.   */
+  /*    Uses format 10.                                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap10   :: A pointer to a cmap table in format 10.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_UInt )
+  code_to_index10( TT_CMapTable*  cmap,
+                   FT_ULong       charCode )
+  {
+    TT_CMap10*  cmap10;
+    FT_UInt     result = 0;
+
+
+    cmap10    = &cmap->c.cmap10;
+    charCode -= cmap10->startCharCode;
+
+    /* the overflow trick for comparison works here also since the number */
+    /* of glyphs (even if numChars is specified as ULong in the specs) in */
+    /* an OpenType font is limited to 64k                                 */
+
+    if ( charCode < cmap10->numChars )
+      result = cmap10->glyphs[charCode];
+
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    code_to_next10                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Find the next encoded character.  Uses format 10.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charCode :: The wanted character code.                             */
+  /*    cmap     :: A pointer to a cmap table in format 10.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next encoded character.  0 if none exists.                         */
+  /*                                                                       */
+  FT_CALLBACK_DEF( FT_ULong )
+  code_to_next10( TT_CMapTable*  cmap,
+                  FT_ULong       charCode )
+  {
+    TT_CMap10*  cmap10;
+
+
+    charCode++;
+    cmap10 = &cmap->c.cmap10;
+    
+    if ( charCode < cmap10->startCharCode )
+      charCode = cmap10->startCharCode;
+    
+    charCode -= cmap10->startCharCode;
+
+    /* the overflow trick for comparison works here also since the number */
+    /* of glyphs (even if numChars is specified as ULong in the specs) in */
+    /* an OpenType font is limited to 64k                                 */
+
+    while ( charCode < cmap10->numChars )
+    {
+      if ( cmap10->glyphs[charCode] )
+        return ( charCode + cmap10->startCharCode );
+      charCode++;
+    }
+
+    return 0;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/sfnt/ttcmap.h
diff -u xc/extras/freetype2/src/sfnt/ttcmap.h:1.1.1.3 xc/extras/freetype2/src/sfnt/ttcmap.h:1.1.1.4
--- xc/extras/freetype2/src/sfnt/ttcmap.h:1.1.1.3	Sun Dec 16 12:49:32 2001
+++ xc/extras/freetype2/src/sfnt/ttcmap.h	Thu Jun 20 04:16:22 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType character mapping table (cmap) support (specification).     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,14 +27,14 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL FT_Error
-  TT_CharMap_Load( TT_Face        face,
-                   TT_CMapTable*  cmap,
-                   FT_Stream      input );
-
-  FT_LOCAL FT_Error
-  TT_CharMap_Free( TT_Face        face,
-                   TT_CMapTable*  cmap );
+  FT_LOCAL( FT_Error )
+  TT_CharMap_Load( TT_Face       face,
+                   TT_CMapTable  cmap,
+                   FT_Stream     input );
+
+  FT_LOCAL( FT_Error )
+  TT_CharMap_Free( TT_Face       face,
+                   TT_CMapTable  cmap );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/sfnt/ttcmap0.c
diff -u /dev/null xc/extras/freetype2/src/sfnt/ttcmap0.c:1.2
--- /dev/null	Thu Feb 27 12:20:49 2003
+++ xc/extras/freetype2/src/sfnt/ttcmap0.c	Mon Jul  1 00:53:14 2002
@@ -0,0 +1,1750 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttcmap0.c                                                              */
+/*                                                                         */
+/*    TrueType new character mapping table (cmap) support (body).          */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_STREAM_H
+#include "ttload.h"
+#include "ttcmap0.h"
+
+#include "sferrors.h"
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_ttcmap
+
+
+#define TT_PEEK_SHORT   FT_PEEK_SHORT
+#define TT_PEEK_USHORT  FT_PEEK_USHORT
+#define TT_PEEK_LONG    FT_PEEK_LONG
+#define TT_PEEK_ULONG   FT_PEEK_ULONG
+
+#define TT_NEXT_SHORT   FT_NEXT_SHORT
+#define TT_NEXT_USHORT  FT_NEXT_USHORT
+#define TT_NEXT_LONG    FT_NEXT_LONG
+#define TT_NEXT_ULONG   FT_NEXT_ULONG
+
+
+  FT_CALLBACK_DEF( FT_Error )
+  tt_cmap_init( TT_CMap   cmap,
+                FT_Byte*  table )
+  {
+    cmap->data = table;
+    return 0;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           FORMAT 0                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET         TYPE          DESCRIPTION                */
+  /*                                                                       */
+  /*   format      0              USHORT        must be 0                  */
+  /*   length      2              USHORT        table length in bytes      */
+  /*   language    4              USHORT        Mac language code          */
+  /*   glyph_ids   6              BYTE[256]     array of glyph indices     */
+  /*               262                                                     */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_0
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap0_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p      = table + 2;
+    FT_UInt   length = TT_NEXT_USHORT( p );
+
+
+    if ( table + length > valid->limit || length < 262 )
+      FT_INVALID_TOO_SHORT;
+
+    /* check glyph indices whenever necessary */
+    if ( valid->level >= FT_VALIDATE_TIGHT )
+    {
+      FT_UInt  n, idx;
+
+
+      p = table + 6;
+      for ( n = 0; n < 256; n++ )
+      {
+        idx = *p++;
+        if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
+          FT_INVALID_GLYPH_ID;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap0_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table = cmap->data;
+
+
+    return char_code < 256 ? table[6 + char_code] : 0;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap0_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table    = cmap->data;
+    FT_UInt32  charcode = *pchar_code;
+    FT_UInt32  result   = 0;
+    FT_UInt    gindex   = 0;
+
+
+    table += 6;  /* go to glyph ids */
+    while ( ++charcode < 256 )
+    {
+      gindex = table[charcode];
+      if ( gindex != 0 )
+      {
+        result = charcode;
+        break;
+      }
+    }
+
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap0_class_rec =
+  {
+    {
+      sizeof( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap0_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap0_char_next
+    },
+    0,
+    (TT_CMap_ValidateFunc)   tt_cmap0_validate
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_0 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 2                             *****/
+  /*****                                                               *****/
+  /***** This is used for certain CJK encodings that encode text in a  *****/
+  /***** mixed 8/16 bits encoding along the following lines:           *****/
+  /*****                                                               *****/
+  /***** * Certain byte values correspond to an 8-bit character code   *****/
+  /*****   (typically in the range 0..127 for ASCII compatibility).    *****/
+  /*****                                                               *****/
+  /***** * Certain byte values signal the first byte of a 2-byte       *****/
+  /*****   character code (but these values are also valid as the      *****/
+  /*****   second byte of a 2-byte character).                         *****/
+  /*****                                                               *****/
+  /***** The following charmap lookup and iteration functions all      *****/
+  /***** assume that the value "charcode" correspond to following:     *****/
+  /*****                                                               *****/
+  /*****   - For one byte characters, "charcode" is simply the         *****/
+  /*****     character code.                                           *****/
+  /*****                                                               *****/
+  /*****   - For two byte characters, "charcode" is the 2-byte         *****/
+  /*****     character code in big endian format.  More exactly:       *****/
+  /*****                                                               *****/
+  /*****       (charcode >> 8)    is the first byte value              *****/
+  /*****       (charcode & 0xFF)  is the second byte value             *****/
+  /*****                                                               *****/
+  /***** Note that not all values of "charcode" are valid according    *****/
+  /***** to these rules, and the function moderately check the         *****/
+  /***** arguments.                                                    *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET         TYPE            DESCRIPTION              */
+  /*                                                                       */
+  /*   format      0              USHORT          must be 2                */
+  /*   length      2              USHORT          table length in bytes    */
+  /*   language    4              USHORT          Mac language code        */
+  /*   keys        6              USHORT[256]     sub-header keys          */
+  /*   subs        518            SUBHEAD[NSUBS]  sub-headers array        */
+  /*   glyph_ids   518+NSUB*8     USHORT[]        glyph id array           */
+  /*                                                                       */
+  /* The `keys' table is used to map charcode high-bytes to sub-headers.   */
+  /* The value of `NSUBS' is the number of sub-headers defined in the      */
+  /* table and is computed by finding the maximum of the `keys' table.     */
+  /*                                                                       */
+  /* Note that for any n, `keys[n]' is a byte offset within the `subs'     */
+  /* table, i.e., it is the corresponding sub-header index multiplied      */
+  /* by 8.                                                                 */
+  /*                                                                       */
+  /* Each sub-header has the following format:                             */
+  /*                                                                       */
+  /*   NAME        OFFSET      TYPE            DESCRIPTION                 */
+  /*                                                                       */
+  /*   first       0           USHORT          first valid low-byte        */
+  /*   count       2           USHORT          number of valid low-bytes   */
+  /*   delta       4           SHORT           see below                   */
+  /*   offset      6           USHORT          see below                   */
+  /*                                                                       */
+  /* A sub-header defines, for each high-byte, the range of valid          */
+  /* low-bytes within the charmap.  Note that the range defined by `first' */
+  /* and `count' must be completely included in the interval [0..255]      */
+  /* according to the specification.                                       */
+  /*                                                                       */
+  /* If a character code is contained within a given sub-header, then      */
+  /* mapping it to a glyph index is done as follows:                       */
+  /*                                                                       */
+  /* * The value of `offset' is read.  This is a _byte_ distance from the  */
+  /*   location of the `offset' field itself into a slice of the           */
+  /*   `glyph_ids' table.  Let's call it `slice' (it's a USHORT[] too).    */
+  /*                                                                       */
+  /* * The value `slice[char.lo - first]' is read.  If it is 0, there is   */
+  /*   no glyph for the charcode.  Otherwise, the value of `delta' is      */
+  /*   added to it (modulo 65536) to form a new glyph index.               */
+  /*                                                                       */
+  /* It is up to the validation routine to check that all offsets fall     */
+  /* within the glyph ids table (and not within the `subs' table itself or */
+  /* outside of the CMap).                                                 */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_2
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap2_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p      = table + 2;           /* skip format */
+    FT_UInt   length = TT_PEEK_USHORT( p );
+    FT_UInt   n, max_subs;
+    FT_Byte*  keys;                         /* keys table */
+    FT_Byte*  subs;                         /* sub-headers */
+    FT_Byte*  glyph_ids;                    /* glyph id array */
+
+
+    if ( table + length > valid->limit || length < 6 + 512 )
+      FT_INVALID_TOO_SHORT;
+
+    keys = table + 6;
+
+    /* parse keys to compute sub-headers count */
+    p        = keys;
+    max_subs = 0;
+    for ( n = 0; n < 256; n++ )
+    {
+      FT_UInt  idx = TT_NEXT_USHORT( p );
+
+
+      /* value must be multiple of 8 */
+      if ( valid->level >= FT_VALIDATE_PARANOID && ( idx & 7 ) != 0 )
+        FT_INVALID_DATA;
+
+      idx >>= 3;
+
+      if ( idx > max_subs )
+        max_subs = idx;
+    }
+
+    FT_ASSERT( p == table + 518 );
+
+    subs      = p;
+    glyph_ids = subs + (max_subs + 1) * 8;
+    if ( glyph_ids > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    /* parse sub-headers */
+    for ( n = 0; n <= max_subs; n++ )
+    {
+      FT_UInt   first_code, code_count, offset;
+      FT_Int    delta;
+      FT_Byte*  ids;
+
+
+      first_code = TT_NEXT_USHORT( p );
+      code_count = TT_NEXT_USHORT( p );
+      delta      = TT_NEXT_SHORT( p );
+      offset     = TT_NEXT_USHORT( p );
+
+      /* check range within 0..255 */
+      if ( valid->level >= FT_VALIDATE_PARANOID )
+      {
+        if ( first_code >= 256 || first_code + code_count > 256 )
+          FT_INVALID_DATA;
+      }
+
+      /* check offset */
+      if ( offset != 0 )
+      {
+        ids = p - 2 + offset;
+        if ( ids < glyph_ids || ids + code_count*2 > table + length )
+          FT_INVALID_OFFSET;
+
+        /* check glyph ids */
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          FT_Byte*  limit = p + code_count * 2;
+          FT_UInt   idx;
+
+
+          for ( ; p < limit; )
+          {
+            idx = TT_NEXT_USHORT( p );
+            if ( idx != 0 )
+            {
+              idx = ( idx + delta ) & 0xFFFFU;
+              if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
+                FT_INVALID_GLYPH_ID;
+            }
+          }
+        }
+      }
+    }
+  }
+
+
+  /* return sub header corresponding to a given character code */
+  /* NULL on invalid charcode                                  */
+  static FT_Byte*
+  tt_cmap2_get_subheader( FT_Byte*   table,
+                          FT_UInt32  char_code )
+  {
+    FT_Byte*  result = NULL;
+
+
+    if ( char_code < 0x10000UL )
+    {
+      FT_UInt   char_lo = (FT_UInt)( char_code & 0xFF );
+      FT_UInt   char_hi = (FT_UInt)( char_code >> 8 );
+      FT_Byte*  p       = table + 6;    /* keys table */
+      FT_Byte*  subs    = table + 518;  /* subheaders table */
+      FT_Byte*  sub;
+
+
+      if ( char_hi == 0 )
+      {
+        /* an 8-bit character code -- we use subHeader 0 in this case */
+        /* to test whether the character code is in the charmap       */
+        /*                                                            */
+        sub = subs;  /* jump to first sub-header */
+
+        /* check that the sub-header for this byte is 0, which */
+        /* indicates that it's really a valid one-byte value   */
+        /* Otherwise, return 0                                 */
+        /*                                                     */
+        p += char_lo * 2;
+        if ( TT_PEEK_USHORT( p ) != 0 )
+          goto Exit;
+      }
+      else
+      {
+        /* a 16-bit character code */
+        p  += char_hi * 2;                          /* jump to key entry  */
+        sub = subs + ( TT_PEEK_USHORT( p ) & -8 );  /* jump to sub-header */
+
+        /* check that the hi byte isn't a valid one-byte value */
+        if ( sub == subs )
+          goto Exit;
+      }
+      result = sub;
+    }
+  Exit:
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap2_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table   = cmap->data;
+    FT_UInt   result  = 0;
+    FT_Byte*  subheader;
+
+
+    subheader = tt_cmap2_get_subheader( table, char_code );
+    if ( subheader )
+    {
+      FT_Byte*  p   = subheader;
+      FT_UInt   idx = (FT_UInt)(char_code & 0xFF);
+      FT_UInt   start, count;
+      FT_Int    delta;
+      FT_UInt   offset;
+
+
+      start  = TT_NEXT_USHORT( p );
+      count  = TT_NEXT_USHORT( p );
+      delta  = TT_NEXT_SHORT ( p );
+      offset = TT_PEEK_USHORT( p );
+
+      idx -= start;
+      if ( idx < count && offset != 0 )
+      {
+        p  += offset + 2 * idx;
+        idx = TT_PEEK_USHORT( p );
+
+        if ( idx != 0 )
+          result = (FT_UInt)( idx + delta ) & 0xFFFFU;
+      }
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap2_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pcharcode )
+  {
+    FT_Byte*   table    = cmap->data;
+    FT_UInt    gindex   = 0;
+    FT_UInt32  result   = 0;
+    FT_UInt32  charcode = *pcharcode + 1;
+    FT_Byte*   subheader;
+
+
+    while ( charcode < 0x10000UL )
+    {
+      subheader = tt_cmap2_get_subheader( table, charcode );
+      if ( subheader )
+      {
+        FT_Byte*  p       = subheader;
+        FT_UInt   start   = TT_NEXT_USHORT( p );
+        FT_UInt   count   = TT_NEXT_USHORT( p );
+        FT_Int    delta   = TT_NEXT_SHORT ( p );
+        FT_UInt   offset  = TT_PEEK_USHORT( p );
+        FT_UInt   char_lo = (FT_UInt)( charcode & 0xFF );
+        FT_UInt   pos, idx;
+
+
+        if ( offset == 0 )
+          goto Next_SubHeader;
+
+        if ( char_lo < start )
+        {
+          char_lo = start;
+          pos     = 0;
+        }
+        else
+          pos = (FT_UInt)( char_lo - start );
+
+        p       += offset + pos * 2;
+        charcode = ( charcode & -256 ) + char_lo;
+
+        for ( ; pos < count; pos++, charcode++ )
+        {
+          idx = TT_NEXT_USHORT( p );
+
+          if ( idx != 0 )
+          {
+            gindex = ( idx + delta ) & 0xFFFFU;
+            if ( gindex != 0 )
+            {
+              result = charcode;
+              goto Exit;
+            }
+          }
+        }
+      }
+
+      /* jump to next sub-header, i.e. higher byte value */
+    Next_SubHeader:
+      charcode = ( charcode & -256 ) + 256;
+    }
+
+  Exit:
+    *pcharcode = result;
+
+    return gindex;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap2_class_rec =
+  {
+    {
+      sizeof( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap2_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap2_char_next
+    },
+    2,
+    (TT_CMap_ValidateFunc)   tt_cmap2_validate
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_2 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                           FORMAT 4                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME          OFFSET         TYPE              DESCRIPTION          */
+  /*                                                                       */
+  /*   format        0              USHORT            must be 4            */
+  /*   length        2              USHORT            table length         */
+  /*                                                  in bytes             */
+  /*   language      4              USHORT            Mac language code    */
+  /*                                                                       */
+  /*   segCountX2    6              USHORT            2*NUM_SEGS           */
+  /*   searchRange   8              USHORT            2*(1 << LOG_SEGS)    */
+  /*   entrySelector 10             USHORT            LOG_SEGS             */
+  /*   rangeShift    12             USHORT            segCountX2 -         */
+  /*                                                    searchRange        */
+  /*                                                                       */
+  /*   endCount      14             USHORT[NUM_SEGS]  end charcode for     */
+  /*                                                  each segment; last   */
+  /*                                                  is 0xFFFF            */
+  /*                                                                       */
+  /*   pad           14+NUM_SEGS*2  USHORT            padding              */
+  /*                                                                       */
+  /*   startCount    16+NUM_SEGS*2  USHORT[NUM_SEGS]  first charcode for   */
+  /*                                                  each segment         */
+  /*                                                                       */
+  /*   idDelta       16+NUM_SEGS*4  SHORT[NUM_SEGS]   delta for each       */
+  /*                                                  segment              */
+  /*   idOffset      16+NUM_SEGS*6  SHORT[NUM_SEGS]   range offset for     */
+  /*                                                  each segment; can be */
+  /*                                                  zero                 */
+  /*                                                                       */
+  /*   glyphIds      16+NUM_SEGS*8  USHORT[]          array of glyph id    */
+  /*                                                  ranges               */
+  /*                                                                       */
+  /* Character codes are modelled by a series of ordered (increasing)      */
+  /* intervals called segments.  Each segment has start and end codes,     */
+  /* provided by the `startCount' and `endCount' arrays.  Segments must    */
+  /* not be overlapping and the last segment should always contain the     */
+  /* `0xFFFF' endCount.                                                    */
+  /*                                                                       */
+  /* The fields `searchRange', `entrySelector' and `rangeShift' are better */
+  /* ignored (they are traces of over-engineering in the TrueType          */
+  /* specification).                                                       */
+  /*                                                                       */
+  /* Each segment also has a signed `delta', as well as an optional offset */
+  /* within the `glyphIds' table.                                          */
+  /*                                                                       */
+  /* If a segment's idOffset is 0, the glyph index corresponding to any    */
+  /* charcode within the segment is obtained by adding the value of        */
+  /* `idDelta' directly to the charcode, modulo 65536.                     */
+  /*                                                                       */
+  /* Otherwise, a glyph index is taken from the glyph ids sub-array for    */
+  /* the segment, and the value of `idDelta' is added to it.               */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_4
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap4_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p      = table + 2;               /* skip format */
+    FT_UInt   length = TT_NEXT_USHORT( p );
+    FT_Byte   *ends, *starts, *offsets, *deltas, *glyph_ids;
+    FT_UInt   num_segs;
+
+
+    if ( table + length > valid->limit || length < 16 )
+      FT_INVALID_TOO_SHORT;
+
+    p        = table + 6;
+    num_segs = TT_NEXT_USHORT( p );   /* read segCountX2 */
+
+    if ( valid->level >= FT_VALIDATE_PARANOID )
+    {
+      /* check that we have an even value here */
+      if ( num_segs & 1 )
+        FT_INVALID_DATA;
+    }
+
+    num_segs /= 2;
+
+    /* check the search parameters - even though we never use them */
+    /*                                                             */
+    if ( valid->level >= FT_VALIDATE_PARANOID )
+    {
+      /* check the values of 'searchRange', 'entrySelector', 'rangeShift' */
+      FT_UInt  search_range   = TT_NEXT_USHORT( p );
+      FT_UInt  entry_selector = TT_NEXT_USHORT( p );
+      FT_UInt  range_shift    = TT_NEXT_USHORT( p );
+
+
+      if ( ( search_range | range_shift ) & 1 )  /* must be even values */
+        FT_INVALID_DATA;
+
+      search_range /= 2;
+      range_shift  /= 2;
+
+      /* `search range' is the greatest power of 2 that is <= num_segs */
+
+      if ( search_range                > num_segs                 ||
+           search_range * 2            < num_segs                 ||
+           search_range + range_shift != num_segs                 ||
+           search_range               != ( 1U << entry_selector ) )
+        FT_INVALID_DATA;
+    }
+
+    ends      = table   + 14;
+    starts    = table   + 16 + num_segs * 2;
+    deltas    = starts  + num_segs * 2;
+    offsets   = deltas  + num_segs * 2;
+    glyph_ids = offsets + num_segs * 2;
+
+    if ( glyph_ids > table + length )
+      FT_INVALID_TOO_SHORT;
+
+    /* check last segment, its end count must be FFFF */
+    if ( valid->level >= FT_VALIDATE_PARANOID )
+    {
+      p = ends + ( num_segs - 1 ) * 2;
+      if ( TT_PEEK_USHORT( p ) != 0xFFFFU )
+        FT_INVALID_DATA;
+    }
+
+    /* check that segments are sorted in increasing order and do not */
+    /* overlap; check also the offsets                               */
+    {
+      FT_UInt  start, end, last = 0, offset, n;
+      FT_Int   delta;
+
+
+      for ( n = 0; n < num_segs; n++ )
+      {
+        p = starts + n * 2;
+        start = TT_PEEK_USHORT( p );
+        p = ends + n * 2;
+        end = TT_PEEK_USHORT( p );
+        p = deltas + n * 2;
+        delta = TT_PEEK_SHORT( p );
+        p = offsets + n * 2;
+        offset = TT_PEEK_USHORT( p );
+
+        if ( start > end )
+          FT_INVALID_DATA;
+
+        /* this test should be performed at default validation level;  */
+        /* unfortunately, some popular Asian fonts present overlapping */
+        /* ranges in their charmaps                                    */
+        /*                                                             */
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          if ( n > 0 && start <= last )
+            FT_INVALID_DATA;
+        }
+
+        if ( offset )
+        {
+          p += offset;  /* start of glyph id array */
+
+          /* check that we point within the glyph ids table only */
+          if ( p < glyph_ids                                ||
+               p + ( end - start + 1 ) * 2 > table + length )
+            FT_INVALID_DATA;
+
+          /* check glyph indices within the segment range */
+          if ( valid->level >= FT_VALIDATE_TIGHT )
+          {
+            FT_UInt  idx;
+
+
+            for ( ; start < end; )
+            {
+              idx = FT_NEXT_USHORT( p );
+              if ( idx != 0 )
+              {
+                idx = (FT_UInt)( idx + delta ) & 0xFFFFU;
+
+                if ( idx >= TT_VALID_GLYPH_COUNT( valid ) )
+                  FT_INVALID_GLYPH_ID;
+              }
+            }
+          }
+        }
+
+        last = end;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap4_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table  = cmap->data;
+    FT_UInt   result = 0;
+
+
+    if ( char_code < 0x10000UL )
+    {
+      FT_UInt   idx, num_segs2;
+      FT_Int    delta;
+      FT_UInt   code = (FT_UInt)char_code;
+      FT_Byte*  p;
+
+
+      p         = table + 6;
+      num_segs2 = TT_PEEK_USHORT( p ) & -2;  /* be paranoid! */
+
+#if 1
+      /* Some fonts have more than 170 segments in their charmaps! */
+      /* We changed this function to use a more efficient binary   */
+      /* search for improving performance                          */
+      {
+        FT_UInt  min = 0;
+        FT_UInt  max = num_segs2 >> 1;
+        FT_UInt  mid, start, end, offset;
+
+
+        while ( min < max )
+        {
+          mid   = ( min + max ) >> 1;
+          p     = table + 14 + mid * 2;
+          end   = TT_NEXT_USHORT( p );
+          p    += num_segs2;
+          start = TT_PEEK_USHORT( p);
+
+          if ( code < start )
+            max = mid;
+
+          else if ( code > end )
+            min = mid + 1;
+
+          else
+          {
+            /* we found the segment */
+            idx = code;
+
+            p += num_segs2;
+            delta = TT_PEEK_SHORT( p );
+
+            p += num_segs2;
+            offset = TT_PEEK_USHORT( p );
+
+            if ( offset != 0 )
+            {
+              p  += offset + 2 * ( idx - start );
+              idx = TT_PEEK_USHORT( p );
+            }
+
+            if ( idx != 0 )
+              result = (FT_UInt)( idx + delta ) & 0xFFFFU;
+
+            goto Exit;
+          }
+        }
+      }
+
+#else /* 0 - old code */
+
+      {
+        FT_UInt   n;
+        FT_Byte*  q;
+
+
+        p = table + 14;               /* ends table   */
+        q = table + 16 + num_segs2;   /* starts table */
+
+
+        for ( n = 0; n < num_segs2; n += 2 )
+        {
+          FT_UInt  end   = TT_NEXT_USHORT( p );
+          FT_UInt  start = TT_NEXT_USHORT( q );
+          FT_UInt  offset;
+
+
+          if ( code < start )
+            break;
+
+          if ( code <= end )
+          {
+            idx = code;
+
+            p = q + num_segs2 - 2;
+            delta = TT_PEEK_SHORT( p );
+            p += num_segs2;
+            offset = TT_PEEK_USHORT( p );
+
+            if ( offset != 0 )
+            {
+              p  += offset + 2 * ( idx - start );
+              idx = TT_PEEK_USHORT( p );
+            }
+
+            if ( idx != 0 )
+              result = (FT_UInt)( idx + delta ) & 0xFFFFU;
+          }
+        }
+      }
+
+#endif /* 0 */
+
+    }
+
+  Exit:
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap4_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table     = cmap->data;
+    FT_UInt32  result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+    FT_UInt    gindex    = 0;
+    FT_Byte*   p;
+    FT_Byte*   q;
+    FT_UInt    code, num_segs2;
+
+
+    if ( char_code >= 0x10000UL )
+      goto Exit;
+
+    code      = (FT_UInt)char_code;
+    p         = table + 6;
+    num_segs2 = TT_PEEK_USHORT(p) & -2;  /* ensure even-ness */
+
+    for (;;)
+    {
+      FT_UInt  offset, n;
+      FT_Int   delta;
+
+
+      p = table + 14;              /* ends table  */
+      q = table + 16 + num_segs2;  /* starts table */
+
+      for ( n = 0; n < num_segs2; n += 2 )
+      {
+        FT_UInt  end   = TT_NEXT_USHORT( p );
+        FT_UInt  start = TT_NEXT_USHORT( q );
+
+
+        if ( code < start )
+          code = start;
+
+        if ( code <= end )
+        {
+          p = q + num_segs2 - 2;
+          delta = TT_PEEK_SHORT( p );
+          p += num_segs2;
+          offset = TT_PEEK_USHORT( p );
+
+          if ( offset != 0 )
+          {
+            /* parse the glyph ids array for non-0 index */
+            p += offset + ( code - start ) * 2;
+            while ( code <= end )
+            {
+              gindex = TT_NEXT_USHORT( p );
+              if ( gindex != 0 )
+              {
+                gindex = (FT_UInt)( gindex + delta ) & 0xFFFFU;
+                if ( gindex != 0 )
+                  break;
+              }
+              code++;
+            }
+          }
+          else
+            gindex = (FT_UInt)( code + delta ) & 0xFFFFU;
+
+          if ( gindex == 0 )
+            break;
+
+          result = code;
+          goto Exit;
+        }
+      }
+
+      /* loop to next trial charcode */
+      if ( code >= 0xFFFFU )
+        break;
+
+      code++;
+    }
+    return result;
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap4_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap4_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap4_char_next
+    },
+    4,
+    (TT_CMap_ValidateFunc)   tt_cmap4_validate
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_4 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 6                             *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET          TYPE             DESCRIPTION            */
+  /*                                                                       */
+  /*   format       0              USHORT           must be 4              */
+  /*   length       2              USHORT           table length in bytes  */
+  /*   language     4              USHORT           Mac language code      */
+  /*                                                                       */
+  /*   first        6              USHORT           first segment code     */
+  /*   count        8              USHORT           segment size in chars  */
+  /*   glyphIds     10             USHORT[count]    glyph ids              */
+  /*                                                                       */
+  /* A very simplified segment mapping.                                    */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_6
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap6_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*  p;
+    FT_UInt   length, start, count;
+
+
+    if ( table + 10 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    p      = table + 2;
+    length = TT_NEXT_USHORT( p );
+
+    p      = table + 6;             /* skip language */
+    start  = TT_NEXT_USHORT( p );
+    count  = TT_NEXT_USHORT( p );
+
+    if ( table + length > valid->limit || length < 10 + count * 2 )
+      FT_INVALID_TOO_SHORT;
+
+    /* check glyph indices */
+    if ( valid->level >= FT_VALIDATE_TIGHT )
+    {
+      FT_UInt  gindex;
+
+
+      for ( ; count > 0; count-- )
+      {
+        gindex = TT_NEXT_USHORT( p );
+        if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
+          FT_INVALID_GLYPH_ID;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap6_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*  table  = cmap->data;
+    FT_UInt   result = 0;
+    FT_Byte*  p      = table + 6;
+    FT_UInt   start  = TT_NEXT_USHORT( p );
+    FT_UInt   count  = TT_NEXT_USHORT( p );
+    FT_UInt   idx    = (FT_UInt)( char_code - start );
+
+
+    if ( idx < count )
+    {
+      p += 2 * idx;
+      result = TT_PEEK_USHORT( p );
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap6_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table     = cmap->data;
+    FT_UInt32  result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+    FT_UInt    gindex    = 0;
+
+    FT_Byte*   p         = table + 6;
+    FT_UInt    start     = TT_NEXT_USHORT( p );
+    FT_UInt    count     = TT_NEXT_USHORT( p );
+    FT_UInt    idx;
+
+
+    if ( char_code >= 0x10000UL )
+      goto Exit;
+
+    if ( char_code < start )
+      char_code = start;
+
+    idx = (FT_UInt)( char_code - start );
+    p  += 2 * idx;
+
+    for ( ; idx < count; idx++ )
+    {
+      gindex = TT_NEXT_USHORT( p );
+      if ( gindex != 0 )
+      {
+        result = char_code;
+        break;
+      }
+      char_code++;
+    }
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap6_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap6_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap6_char_next
+    },
+    6,
+    (TT_CMap_ValidateFunc)   tt_cmap6_validate
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_6 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 8                             *****/
+  /*****                                                               *****/
+  /***** It's hard to completely understand what the OpenType spec     *****/
+  /***** says about this format, but here is my conclusion.            *****/
+  /*****                                                               *****/
+  /***** The purpose of this format is to easily map UTF-16 text to    *****/
+  /***** glyph indices.  Basically, the `char_code' must be in one of  *****/
+  /***** the following formats:                                        *****/
+  /*****                                                               *****/
+  /*****   - A 16-bit value that isn't part of the Unicode Surrogates  *****/
+  /*****     Area (i.e. U+D800-U+DFFF).                                *****/
+  /*****                                                               *****/
+  /*****   - A 32-bit value, made of two surrogate values, i.e.. if    *****/
+  /*****     `char_code = (char_hi << 16) | char_lo', then both        *****/
+  /*****     `char_hi' and `char_lo' must be in the Surrogates Area.   *****/
+  /*****      Area.                                                    *****/
+  /*****                                                               *****/
+  /***** The 'is32' table embedded in the charmap indicates whether a  *****/
+  /***** given 16-bit value is in the surrogates area or not.          *****/
+  /*****                                                               *****/
+  /***** So, for any given `char_code', we can assert the following:   *****/
+  /*****                                                               *****/
+  /*****   If `char_hi == 0' then we must have `is32[char_lo] == 0'.   *****/
+  /*****                                                               *****/
+  /*****   If `char_hi != 0' then we must have both                    *****/
+  /*****   `is32[char_hi] != 0' and `is32[char_lo] != 0'.              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET         TYPE        DESCRIPTION                  */
+  /*                                                                       */
+  /*   format      0              USHORT      must be 8                    */
+  /*   reseved     2              USHORT      reserved                     */
+  /*   length      4              ULONG       length in bytes              */
+  /*   language    8              ULONG       Mac language code            */
+  /*   is32        12             BYTE[8192]  32-bitness bitmap            */
+  /*   count       8204           ULONG       number of groups             */
+  /*                                                                       */
+  /* This header is followed by 'count' groups of the following format:    */
+  /*                                                                       */
+  /*   start       0              ULONG       first charcode               */
+  /*   end         4              ULONG       last charcode                */
+  /*   startId     8              ULONG       start glyph id for the group */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_8
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap8_validate( FT_Byte*      table,
+                     FT_Validator  valid )
+  {
+    FT_Byte*   p = table + 4;
+    FT_Byte*   is32;
+    FT_UInt32  length;
+    FT_UInt32  num_groups;
+
+
+    if ( table + 16 + 8192 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    length = TT_NEXT_ULONG( p );
+    if ( table + length > valid->limit || length < 8208 )
+      FT_INVALID_TOO_SHORT;
+
+    is32       = table + 12;
+    p          = is32  + 8192;          /* skip `is32' array */
+    num_groups = TT_NEXT_ULONG( p );
+
+    if ( p + num_groups * 12 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    /* check groups, they must be in increasing order */
+    {
+      FT_UInt32  n, start, end, start_id, count, last = 0;
+
+
+      for ( n = 0; n < num_groups; n++ )
+      {
+        FT_UInt   hi, lo;
+
+
+        start    = TT_NEXT_ULONG( p );
+        end      = TT_NEXT_ULONG( p );
+        start_id = TT_NEXT_ULONG( p );
+
+        if ( start > end )
+          FT_INVALID_DATA;
+
+        if ( n > 0 && start <= last )
+          FT_INVALID_DATA;
+
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
+            FT_INVALID_GLYPH_ID;
+
+          count = (FT_UInt32)( end - start + 1 );
+
+          if ( start & ~0xFFFFU )
+          {
+            /* start_hi != 0; check that is32[i] is 1 for each i in */
+            /* the `hi' and `lo' of the range [start..end]          */
+            for ( ; count > 0; count--, start++ )
+            {
+              hi = (FT_UInt)( start >> 16 );
+              lo = (FT_UInt)( start & 0xFFFFU );
+
+              if ( (is32[hi >> 3] & ( 0x80 >> ( hi & 7 ) ) ) == 0 )
+                FT_INVALID_DATA;
+
+              if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) == 0 )
+                FT_INVALID_DATA;
+            }
+          }
+          else
+          {
+            /* start_hi == 0; check that is32[i] is 0 for each i in */
+            /* the range [start..end]                               */
+
+            /* end_hi cannot be != 0! */
+            if ( end & ~0xFFFFU )
+              FT_INVALID_DATA;
+
+            for ( ; count > 0; count--, start++ )
+            {
+              lo = (FT_UInt)( start & 0xFFFFU );
+
+              if ( (is32[lo >> 3] & ( 0x80 >> ( lo & 7 ) ) ) != 0 )
+                FT_INVALID_DATA;
+            }
+          }
+        }
+
+        last = end;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap8_char_index( TT_CMap    cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_Byte*   table      = cmap->data;
+    FT_UInt    result     = 0;
+    FT_Byte*   p          = table + 8204;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        break;
+
+      if ( char_code <= end )
+      {
+        result = start_id + char_code - start;
+        break;
+      }
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap8_char_next( TT_CMap     cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_UInt32  result     = 0;
+    FT_UInt32  char_code  = *pchar_code + 1;
+    FT_UInt    gindex     = 0;
+    FT_Byte*   table      = cmap->data;
+    FT_Byte*   p          = table + 8204;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    p = table + 8208;
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        char_code = start;
+
+      if ( char_code <= end )
+      {
+        gindex = (FT_UInt)( char_code - start + start_id );
+        if ( gindex != 0 )
+        {
+          result = char_code;
+          goto Exit;
+        }
+      }
+    }
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap8_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap8_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap8_char_next
+    },
+    8,
+    (TT_CMap_ValidateFunc)   tt_cmap8_validate
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_8 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 10                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME      OFFSET  TYPE               DESCRIPTION                    */
+  /*                                                                       */
+  /*   format     0      USHORT             must be 10                     */
+  /*   reserved   2      USHORT             reserved                       */
+  /*   length     4      ULONG              length in bytes                */
+  /*   language   8      ULONG              Mac language code              */
+  /*                                                                       */
+  /*   start     12      ULONG              first char in range            */
+  /*   count     16      ULONG              number of chars in range       */
+  /*   glyphIds  20      USHORT[count]      glyph indices covered          */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_10
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap10_validate( FT_Byte*      table,
+                      FT_Validator  valid )
+  {
+    FT_Byte*  p = table + 4;
+    FT_ULong  length, start, count;
+
+
+    if ( table + 20 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    length = TT_NEXT_ULONG( p );
+    p      = table + 12;
+    start  = TT_NEXT_ULONG( p );
+    count  = TT_NEXT_ULONG( p );
+
+    if ( table + length > valid->limit || length < 20 + count * 2 )
+      FT_INVALID_TOO_SHORT;
+
+    /* check glyph indices */
+    if ( valid->level >= FT_VALIDATE_TIGHT )
+    {
+      FT_UInt  gindex;
+
+
+      for ( ; count > 0; count-- )
+      {
+        gindex = TT_NEXT_USHORT( p );
+        if ( gindex >= TT_VALID_GLYPH_COUNT( valid ) )
+          FT_INVALID_GLYPH_ID;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap10_char_index( TT_CMap    cmap,
+                        FT_UInt32  char_code )
+  {
+    FT_Byte*   table  = cmap->data;
+    FT_UInt    result = 0;
+    FT_Byte*   p      = table + 12;
+    FT_UInt32  start  = TT_NEXT_ULONG( p );
+    FT_UInt32  count  = TT_NEXT_ULONG( p );
+    FT_UInt32  idx    = (FT_ULong)( char_code - start );
+
+
+    if ( idx < count )
+    {
+      p     += 2 * idx;
+      result = TT_PEEK_USHORT( p );
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap10_char_next( TT_CMap     cmap,
+                       FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table     = cmap->data;
+    FT_UInt32  result    = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+    FT_UInt    gindex    = 0;
+    FT_Byte*   p         = table + 12;
+    FT_UInt32  start     = TT_NEXT_ULONG( p );
+    FT_UInt32  count     = TT_NEXT_ULONG( p );
+    FT_UInt32  idx;
+
+
+    if ( char_code < start )
+      char_code = start;
+
+    idx = (FT_UInt32)( char_code - start );
+    p  += 2 * idx;
+
+    for ( ; idx < count; idx++ )
+    {
+      gindex = TT_NEXT_USHORT( p );
+      if ( gindex != 0 )
+      {
+        result = char_code;
+        break;
+      }
+      char_code++;
+    }
+
+    *pchar_code = char_code;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap10_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap10_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap10_char_next
+    },
+    10,
+    (TT_CMap_ValidateFunc)   tt_cmap10_validate
+  };
+
+#endif /* TT_CONFIG_CMAP_FORMAT_10 */
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                          FORMAT 12                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TABLE OVERVIEW                                                        */
+  /* --------------                                                        */
+  /*                                                                       */
+  /*   NAME        OFFSET     TYPE       DESCRIPTION                       */
+  /*                                                                       */
+  /*   format      0          USHORT     must be 12                        */
+  /*   reserved    2          USHORT     reserved                          */
+  /*   length      4          ULONG      length in bytes                   */
+  /*   language    8          ULONG      Mac language code                 */
+  /*   count       12         ULONG      number of groups                  */
+  /*               16                                                      */
+  /*                                                                       */
+  /* This header is followed by `count' groups of the following format:    */
+  /*                                                                       */
+  /*   start       0          ULONG      first charcode                    */
+  /*   end         4          ULONG      last charcode                     */
+  /*   startId     8          ULONG      start glyph id for the group      */
+  /*                                                                       */
+
+#ifdef TT_CONFIG_CMAP_FORMAT_12
+
+  FT_CALLBACK_DEF( void )
+  tt_cmap12_validate( FT_Byte*      table,
+                      FT_Validator  valid )
+  {
+    FT_Byte*   p;
+    FT_ULong   length;
+    FT_ULong   num_groups;
+
+
+    if ( table + 16 > valid->limit )
+      FT_INVALID_TOO_SHORT;
+
+    p      = table + 4;
+    length = TT_NEXT_ULONG( p );
+
+    p          = table + 12;
+    num_groups = TT_NEXT_ULONG( p );
+
+    if ( table + length > valid->limit || length < 16 + 12 * num_groups )
+      FT_INVALID_TOO_SHORT;
+
+    /* check groups, they must be in increasing order */
+    {
+      FT_ULong  n, start, end, start_id, last = 0;
+
+
+      for ( n = 0; n < num_groups; n++ )
+      {
+        start    = TT_NEXT_ULONG( p );
+        end      = TT_NEXT_ULONG( p );
+        start_id = TT_NEXT_ULONG( p );
+
+        if ( start > end )
+          FT_INVALID_DATA;
+
+        if ( n > 0 && start <= last )
+          FT_INVALID_DATA;
+
+        if ( valid->level >= FT_VALIDATE_TIGHT )
+        {
+          if ( start_id + end - start >= TT_VALID_GLYPH_COUNT( valid ) )
+            FT_INVALID_GLYPH_ID;
+        }
+
+        last = end;
+      }
+    }
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap12_char_index( TT_CMap    cmap,
+                        FT_UInt32  char_code )
+  {
+    FT_UInt    result     = 0;
+    FT_Byte*   table      = cmap->data;
+    FT_Byte*   p          = table + 12;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        break;
+
+      if ( char_code <= end )
+      {
+        result = start_id + char_code - start;
+        break;
+      }
+    }
+    return result;
+  }
+
+
+  FT_CALLBACK_DEF( FT_UInt )
+  tt_cmap12_char_next( TT_CMap     cmap,
+                       FT_UInt32  *pchar_code )
+  {
+    FT_Byte*   table      = cmap->data;
+    FT_UInt32  result     = 0;
+    FT_UInt32  char_code  = *pchar_code + 1;
+    FT_UInt    gindex     = 0;
+    FT_Byte*   p          = table + 12;
+    FT_UInt32  num_groups = TT_NEXT_ULONG( p );
+    FT_UInt32  start, end, start_id;
+
+
+    p = table + 16;
+
+    for ( ; num_groups > 0; num_groups-- )
+    {
+      start    = TT_NEXT_ULONG( p );
+      end      = TT_NEXT_ULONG( p );
+      start_id = TT_NEXT_ULONG( p );
+
+      if ( char_code < start )
+        char_code = start;
+
+      if ( char_code <= end )
+      {
+        gindex = (FT_UInt)(char_code - start + start_id);
+        if ( gindex != 0 )
+        {
+          result = char_code;
+          goto Exit;
+        }
+      }
+    }
+
+  Exit:
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const TT_CMap_ClassRec  tt_cmap12_class_rec =
+  {
+    {
+      sizeof ( TT_CMapRec ),
+
+      (FT_CMap_InitFunc)     tt_cmap_init,
+      (FT_CMap_DoneFunc)     NULL,
+      (FT_CMap_CharIndexFunc)tt_cmap12_char_index,
+      (FT_CMap_CharNextFunc) tt_cmap12_char_next
+    },
+    12,
+    (TT_CMap_ValidateFunc)   tt_cmap12_validate
+  };
+
+
+#endif /* TT_CONFIG_CMAP_FORMAT_12 */
+
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+  static const TT_CMap_Class  tt_cmap_classes[] =
+  {
+#ifdef TT_CONFIG_CMAP_FORMAT_0
+    &tt_cmap0_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_2
+    &tt_cmap2_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_4
+    &tt_cmap4_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_6
+    &tt_cmap6_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_8
+    &tt_cmap8_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_10
+    &tt_cmap10_class_rec,
+#endif
+
+#ifdef TT_CONFIG_CMAP_FORMAT_12
+    &tt_cmap12_class_rec,
+#endif
+
+    NULL,
+  };
+
+
+  /* parse the `cmap' table and build the corresponding TT_CMap objects */
+  /* in the current face                                                */
+  /*                                                                    */
+  FT_LOCAL_DEF( FT_Error )
+  TT_Build_CMaps( TT_Face  face )
+  {
+    FT_Byte*           table = face->cmap_table;
+    FT_Byte*           limit = table + face->cmap_size;
+    volatile FT_UInt   num_cmaps;
+    volatile FT_Byte*  p     = table;
+
+
+    if ( p + 4 > limit )
+      return FT_Err_Invalid_Table;
+
+    /* only recognize format 0 */
+    if ( TT_NEXT_USHORT( p ) != 0 )
+    {
+      p -= 2;
+      FT_ERROR(( "TT_Build_CMaps: unsupported `cmap' table format = %d\n",
+                 TT_PEEK_USHORT( p ) ));
+      return FT_Err_Invalid_Table;
+    }
+
+    num_cmaps = TT_NEXT_USHORT( p );
+
+    for ( ; num_cmaps > 0 && p + 8 <= limit; num_cmaps-- )
+    {
+      FT_CharMapRec  charmap;
+      FT_UInt32      offset;
+
+
+      charmap.platform_id = TT_NEXT_USHORT( p );
+      charmap.encoding_id = TT_NEXT_USHORT( p );
+      charmap.face        = FT_FACE( face );
+      charmap.encoding    = ft_encoding_none;  /* will be filled later */
+      offset              = TT_NEXT_ULONG( p );
+
+      if ( offset && table + offset + 2 < limit )
+      {
+        FT_Byte*                       cmap   = table + offset;
+        FT_UInt                        format = TT_PEEK_USHORT( cmap );
+        volatile const TT_CMap_Class*  pclazz = tt_cmap_classes;
+        TT_CMap_Class                  clazz;
+
+
+        for ( ; *pclazz; pclazz++ )
+        {
+          clazz = *pclazz;
+          if ( clazz->format == format )
+          {
+            volatile TT_ValidatorRec  valid;
+
+
+            ft_validator_init( FT_VALIDATOR( &valid ), cmap, limit,
+                               FT_VALIDATE_DEFAULT );
+
+            valid.num_glyphs = face->root.num_glyphs;
+
+            if ( ft_setjmp( FT_VALIDATOR( &valid )->jump_buffer ) == 0 )
+            {
+              /* validate this cmap sub-table */
+              clazz->validate( cmap, FT_VALIDATOR( &valid ) );
+            }
+
+            if ( valid.validator.error == 0 )
+              (void)FT_CMap_New( (FT_CMap_Class)clazz, cmap, &charmap, NULL );
+            else
+            {
+              FT_ERROR(( "TT_Build_CMaps:" ));
+              FT_ERROR(( " broken cmap sub-table ignored!\n" ));
+            }
+          }
+        }
+      }
+    }
+
+    return 0;
+  }
+
+#endif /* FT_CONFIG_OPTION_USE_CMAPS */
+
+
+/* END */
Index: xc/extras/freetype2/src/sfnt/ttcmap0.h
diff -u /dev/null xc/extras/freetype2/src/sfnt/ttcmap0.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:49 2003
+++ xc/extras/freetype2/src/sfnt/ttcmap0.h	Thu Jun 20 04:16:22 2002
@@ -0,0 +1,78 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttcmap0.h                                                              */
+/*                                                                         */
+/*    TrueType new character mapping table (cmap) support (specification). */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __TTCMAP0_H__
+#define __TTCMAP0_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+#include FT_INTERNAL_OBJECTS_H
+
+
+FT_BEGIN_HEADER
+
+  typedef struct  TT_CMapRec_
+  {
+    FT_CMapRec  cmap;
+    FT_Byte*    data;           /* pointer to in-memory cmap table */
+
+  } TT_CMapRec, *TT_CMap;
+
+  typedef const struct TT_CMap_ClassRec_*  TT_CMap_Class;
+
+
+  typedef FT_Error
+  (*TT_CMap_ValidateFunc)( FT_Byte*      data,
+                           FT_Validator  valid );
+
+  typedef struct  TT_CMap_ClassRec_
+  {
+    FT_CMap_ClassRec      clazz;
+    FT_UInt               format;
+    TT_CMap_ValidateFunc  validate;
+
+  } TT_CMap_ClassRec;
+
+
+  typedef struct  TT_ValidatorRec_
+  {
+    FT_ValidatorRec  validator;
+    FT_UInt          num_glyphs;
+    
+  } TT_ValidatorRec, *TT_Validator;
+
+
+#define TT_VALIDATOR( x )          ((TT_Validator)( x ))
+#define TT_VALID_GLYPH_COUNT( x )  TT_VALIDATOR( x )->num_glyphs
+
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+  FT_LOCAL( FT_Error )
+  TT_Build_CMaps( TT_Face  face );
+
+#endif
+
+
+FT_END_HEADER
+
+#endif /* __TTCMAP0_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/sfnt/ttload.c
diff -u xc/extras/freetype2/src/sfnt/ttload.c:1.1.1.5 xc/extras/freetype2/src/sfnt/ttload.c:1.1.1.8
--- xc/extras/freetype2/src/sfnt/ttload.c:1.1.1.5	Mon Jan 14 11:52:22 2002
+++ xc/extras/freetype2/src/sfnt/ttload.c	Thu Jun 20 04:16:22 2002
@@ -5,7 +5,7 @@
 /*    Load the basic TrueType tables, i.e., tables that can be either in   */
 /*    TTF or OTF fonts (body).                                             */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -26,7 +26,6 @@
 
 #include "sferrors.h"
 
-#include <stdlib.h>  /* for qsort */
 
   /*************************************************************************/
   /*                                                                       */
@@ -48,17 +47,18 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face :: A face object handle.                                      */
+  /*                                                                       */
   /*    tag  :: The searched tag.                                          */
   /*                                                                       */
   /* <Return>                                                              */
   /*    A pointer to the table directory entry.  0 if not found.           */
   /*                                                                       */
-  FT_LOCAL_DEF TT_Table*
+  FT_LOCAL_DEF( TT_Table  )
   TT_LookUp_Table( TT_Face   face,
                    FT_ULong  tag  )
   {
-    TT_Table*  entry;
-    TT_Table*  limit;
+    TT_Table  entry;
+    TT_Table  limit;
 
 
     FT_TRACE3(( "TT_LookUp_Table: %08p, `%c%c%c%c' -- ",
@@ -73,7 +73,9 @@
 
     for ( ; entry < limit; entry++ )
     {
-      if ( entry->Tag == tag )
+      /* For compatibility with Windows, we consider 0-length */
+      /* tables the same as missing tables.                   */
+      if ( entry->Tag == tag && entry->Length != 0 )
       {
         FT_TRACE3(( "found table.\n" ));
         return entry;
@@ -95,7 +97,9 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A face object handle.                                    */
+  /*                                                                       */
   /*    tag    :: The searched tag.                                        */
+  /*                                                                       */
   /*    stream :: The stream to seek when the table is found.              */
   /*                                                                       */
   /* <Output>                                                              */
@@ -104,14 +108,14 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Goto_Table( TT_Face    face,
                  FT_ULong   tag,
                  FT_Stream  stream,
                  FT_ULong*  length )
   {
-    TT_Table*  table;
-    FT_Error   error;
+    TT_Table  table;
+    FT_Error  error;
 
 
     table = TT_LookUp_Table( face, tag );
@@ -120,7 +124,7 @@
       if ( length )
         *length = table->Length;
 
-      if ( FILE_Seek( table->Offset ) )
+      if ( FT_STREAM_SEEK( table->Offset ) )
        goto Exit;
     }
     else
@@ -134,14 +138,16 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Load_SFNT_Header                                                */
+  /*    TT_Load_SFNT_HeaderRec                                             */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Loads the header of a SFNT font file.  Supports collections.       */
   /*                                                                       */
   /* <Input>                                                               */
   /*    face       :: A handle to the target face object.                  */
+  /*                                                                       */
   /*    stream     :: The input stream.                                    */
+  /*                                                                       */
   /*    face_index :: If the font is a collection, the number of the font  */
   /*                  in the collection, ignored otherwise.                */
   /*                                                                       */
@@ -159,11 +165,11 @@
   /*    The header will be checked whether it is valid by looking at the   */
   /*    values of `search_range', `entry_selector', and `range_shift'.     */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_Load_SFNT_Header( TT_Face       face,
-                       FT_Stream     stream,
-                       FT_Long       face_index,
-                       SFNT_Header*  sfnt )
+  FT_LOCAL_DEF( FT_Error )
+  TT_Load_SFNT_HeaderRec( TT_Face       face,
+                          FT_Stream     stream,
+                          FT_Long       face_index,
+                          SFNT_Header   sfnt )
   {
     FT_Error   error;
     FT_ULong   format_tag;
@@ -172,7 +178,7 @@
     const FT_Frame_Field  sfnt_header_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  SFNT_Header
+#define FT_STRUCTURE  SFNT_HeaderRec
 
       FT_FRAME_START( 8 ),
         FT_FRAME_USHORT( num_tables ),
@@ -185,27 +191,29 @@
     const FT_Frame_Field  ttc_header_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TTC_Header
+#define FT_STRUCTURE  TTC_HeaderRec
 
       FT_FRAME_START( 8 ),
         FT_FRAME_LONG( version ),
         FT_FRAME_LONG( count   ),
-      FT_FRAME_END };
+      FT_FRAME_END
+    };
 
 
-    FT_TRACE2(( "TT_Load_SFNT_Header: %08p, %ld\n",
+    FT_TRACE2(( "TT_Load_SFNT_HeaderRec: %08p, %ld\n",
                 face, face_index ));
 
-    face->ttc_header.tag      = 0;
-    face->ttc_header.version  = 0;
-    face->ttc_header.count    = 0;
+    face->ttc_header.tag     = 0;
+    face->ttc_header.version = 0;
+    face->ttc_header.count   = 0;
 
     face->num_tables = 0;
 
     /* first of all, read the first 4 bytes.  If it is `ttcf', then the */
     /* file is a TrueType collection, otherwise it can be any other     */
     /* kind of font.                                                    */
-    if ( READ_ULong( format_tag ) )
+    /*                                                                  */
+    if ( FT_READ_ULONG( format_tag ) )
       goto Exit;
 
     if ( format_tag == TTAG_ttcf )
@@ -213,24 +221,22 @@
       FT_Int  n;
 
 
-      FT_TRACE3(( "TT_Load_SFNT_Header: file is a collection\n" ));
+      FT_TRACE3(( "TT_Load_SFNT_HeaderRec: file is a collection\n" ));
 
-      /* it's a TrueType collection, i.e. a file containing several */
-      /* font files.  Read the font directory now                   */
-      if ( READ_Fields( ttc_header_fields, &face->ttc_header ) )
+      /* It is a TrueType collection, i.e. a file containing several */
+      /* font files.  Read the font directory now                    */
+      if ( FT_STREAM_READ_FIELDS( ttc_header_fields, &face->ttc_header ) )
         goto Exit;
 
       /* now read the offsets of each font in the file */
-      if ( ALLOC_ARRAY( face->ttc_header.offsets,
-                        face->ttc_header.count,
-                        FT_ULong )                     ||
-           ACCESS_Frame( face->ttc_header.count * 4L ) )
+      if ( FT_NEW_ARRAY( face->ttc_header.offsets, face->ttc_header.count ) ||
+           FT_FRAME_ENTER( face->ttc_header.count * 4L )                    )
         goto Exit;
 
       for ( n = 0; n < face->ttc_header.count; n++ )
-        face->ttc_header.offsets[n] = GET_ULong();
+        face->ttc_header.offsets[n] = FT_GET_ULONG();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       /* check face index */
       if ( face_index >= face->ttc_header.count )
@@ -240,14 +246,14 @@
       }
 
       /* seek to the appropriate TrueType file, then read tag */
-      if ( FILE_Seek( face->ttc_header.offsets[face_index] ) ||
-           READ_Long( format_tag )                           )
+      if ( FT_STREAM_SEEK( face->ttc_header.offsets[face_index] ) ||
+           FT_READ_LONG( format_tag )                             )
         goto Exit;
     }
 
     /* the format tag was read, now check the rest of the header */
     sfnt->format_tag = format_tag;
-    if ( READ_Fields( sfnt_header_fields, sfnt ) )
+    if ( FT_STREAM_READ_FIELDS( sfnt_header_fields, sfnt ) )
       goto Exit;
 
     /* now, check the values of `num_tables', `seach_range', etc. */
@@ -263,7 +269,7 @@
            entry_selector > num_tables      ||
            entry_selector * 2 <= num_tables )
       {
-        FT_TRACE2(( "TT_Load_SFNT_Header: file is not SFNT!\n" ));
+        FT_TRACE2(( "TT_Load_SFNT_HeaderRec: file is not SFNT!\n" ));
         error = SFNT_Err_Unknown_File_Format;
       }
     }
@@ -286,6 +292,7 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    stream :: The input stream.                                        */
+  /*                                                                       */
   /*    sfnt   :: The SFNT directory header.                               */
   /*                                                                       */
   /* <Return>                                                              */
@@ -294,15 +301,15 @@
   /* <Note>                                                                */
   /*    The stream cursor must be at the font file's origin.               */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_Load_Directory( TT_Face       face,
-                     FT_Stream     stream,
-                     SFNT_Header*  sfnt )
+  FT_LOCAL_DEF( FT_Error )
+  TT_Load_Directory( TT_Face      face,
+                     FT_Stream    stream,
+                     SFNT_Header  sfnt )
   {
-    FT_Error   error;
-    FT_Memory  memory = stream->memory;
+    FT_Error     error;
+    FT_Memory    memory = stream->memory;
 
-    TT_Table *entry, *limit;
+    TT_TableRec  *entry, *limit;
 
 
     FT_TRACE2(( "TT_Load_Directory: %08p\n", face ));
@@ -312,12 +319,10 @@
 
     face->num_tables = sfnt->num_tables;
 
-    if ( ALLOC_ARRAY( face->dir_tables,
-                      face->num_tables,
-                      TT_Table ) )
+    if ( FT_NEW_ARRAY( face->dir_tables, face->num_tables ) )
       goto Exit;
 
-    if ( ACCESS_Frame( face->num_tables * 16L ) )
+    if ( FT_FRAME_ENTER( face->num_tables * 16L ) )
       goto Exit;
 
     entry = face->dir_tables;
@@ -325,10 +330,10 @@
 
     for ( ; entry < limit; entry++ )
     {                    /* loop through the tables and get all entries */
-      entry->Tag      = GET_Tag4();
-      entry->CheckSum = GET_ULong();
-      entry->Offset   = GET_Long();
-      entry->Length   = GET_Long();
+      entry->Tag      = FT_GET_TAG4();
+      entry->CheckSum = FT_GET_ULONG();
+      entry->Offset   = FT_GET_LONG();
+      entry->Length   = FT_GET_LONG();
 
       FT_TRACE2(( "  %c%c%c%c  -  %08lx  -  %08lx\n",
                   (FT_Char)( entry->Tag >> 24 ),
@@ -339,7 +344,7 @@
                   entry->Length ));
     }
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     FT_TRACE2(( "Directory loaded\n\n" ));
 
@@ -388,7 +393,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Any( TT_Face    face,
                FT_ULong   tag,
                FT_Long    offset,
@@ -397,7 +402,7 @@
   {
     FT_Error   error;
     FT_Stream  stream;
-    TT_Table*  table;
+    TT_Table   table;
     FT_ULong   size;
 
 
@@ -430,7 +435,7 @@
 
     stream = face->root.stream;
     /* the `if' is syntactic sugar for picky compilers */
-    if ( FILE_Read_At( offset, buffer, size ) )
+    if ( FT_STREAM_READ_AT( offset, buffer, size ) )
       goto Exit;
 
   Exit:
@@ -448,6 +453,7 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: The input stream.                                        */
   /*                                                                       */
   /* <Return>                                                              */
@@ -507,7 +513,7 @@
 
     header = &face->header;
 
-    if ( READ_Fields( header_fields, header ) )
+    if ( FT_STREAM_READ_FIELDS( header_fields, header ) )
       goto Exit;
 
     FT_TRACE2(( "    Units per EM: %8u\n", header->Units_Per_EM ));
@@ -519,7 +525,7 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Header( TT_Face    face,
                   FT_Stream  stream )
   {
@@ -529,7 +535,7 @@
 
 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Bitmap_Header( TT_Face    face,
                          FT_Stream  stream )
   {
@@ -549,12 +555,13 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: The input stream.                                        */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_MaxProfile( TT_Face    face,
                       FT_Stream  stream )
   {
@@ -598,7 +605,7 @@
     if ( error )
       goto Exit;
 
-    if ( READ_Fields( maxp_fields, maxProfile ) )
+    if ( FT_STREAM_READ_FIELDS( maxp_fields, maxProfile ) )
       goto Exit;
 
     maxProfile->maxPoints             = 0;
@@ -617,7 +624,7 @@
 
     if ( maxProfile->version >= 0x10000L )
     {
-      if ( READ_Fields( maxp_fields_extra, maxProfile ) )
+      if ( FT_STREAM_READ_FIELDS( maxp_fields_extra, maxProfile ) )
         goto Exit;
 
       /* XXX: an adjustment that is necessary to load certain */
@@ -649,8 +656,8 @@
 
       /* We also increase maxPoints and maxContours in order to support */
       /* some broken fonts.                                             */
-      face->root.internal->max_points   += (FT_UShort) 8;
-      face->root.internal->max_contours += (FT_Short)  4;
+      face->root.internal->max_points   += (FT_UShort)8;
+      face->root.internal->max_contours += (FT_Short) 4;
     }
 
     FT_TRACE2(( "MAXP loaded.\n" ));
@@ -670,7 +677,9 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face     :: A handle to the target face object.                    */
+  /*                                                                       */
   /*    stream   :: The input stream.                                      */
+  /*                                                                       */
   /*    vertical :: A boolean flag.  If set, load vertical metrics.        */
   /*                                                                       */
   /* <Return>                                                              */
@@ -687,7 +696,7 @@
     FT_ULong   table_len;
     FT_Long    num_shorts, num_longs, num_shorts_checked;
 
-    TT_LongMetrics**   longs;
+    TT_LongMetrics *   longs;
     TT_ShortMetrics**  shorts;
 
 
@@ -698,6 +707,7 @@
     if ( vertical )
     {
       /* The table is optional, quit silently if it wasn't found       */
+      /*                                                               */
       /* XXX: Some fonts have a valid vertical header with a non-null  */
       /*      `number_of_VMetrics' fields, but no corresponding `vmtx' */
       /*      table to get the metrics from (e.g. mingliu).            */
@@ -715,7 +725,7 @@
       }
 
       num_longs = face->vertical.number_Of_VMetrics;
-      longs     = (TT_LongMetrics**)&face->vertical.long_metrics;
+      longs     = (TT_LongMetrics *)&face->vertical.long_metrics;
       shorts    = (TT_ShortMetrics**)&face->vertical.short_metrics;
     }
     else
@@ -729,7 +739,7 @@
       }
 
       num_longs = face->horizontal.number_Of_HMetrics;
-      longs     = (TT_LongMetrics**)&face->horizontal.long_metrics;
+      longs     = (TT_LongMetrics *)&face->horizontal.long_metrics;
       shorts    = (TT_ShortMetrics**)&face->horizontal.short_metrics;
     }
 
@@ -749,22 +759,22 @@
       goto Exit;
     }
 
-    if ( ALLOC_ARRAY( *longs,  num_longs,  TT_LongMetrics )  ||
-         ALLOC_ARRAY( *shorts, num_shorts, TT_ShortMetrics ) )
+    if ( FT_NEW_ARRAY( *longs,  num_longs  ) ||
+         FT_NEW_ARRAY( *shorts, num_shorts ) )
       goto Exit;
 
-    if ( ACCESS_Frame( table_len ) )
+    if ( FT_FRAME_ENTER( table_len ) )
       goto Exit;
 
     {
-      TT_LongMetrics*  cur   = *longs;
-      TT_LongMetrics*  limit = cur + num_longs;
+      TT_LongMetrics  cur   = *longs;
+      TT_LongMetrics  limit = cur + num_longs;
 
 
       for ( ; cur < limit; cur++ )
       {
-        cur->advance = GET_UShort();
-        cur->bearing = GET_Short();
+        cur->advance = FT_GET_USHORT();
+        cur->bearing = FT_GET_SHORT();
       }
     }
 
@@ -775,7 +785,7 @@
 
 
       for ( ; cur < limit; cur++ )
-        *cur = GET_Short();
+        *cur = FT_GET_SHORT();
 
       /* we fill up the missing left side bearings with the     */
       /* last valid value.  Since this will occur for buggy CJK */
@@ -791,7 +801,7 @@
       }
     }
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     FT_TRACE2(( "loaded\n" ));
 
@@ -810,13 +820,15 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face     :: A handle to the target face object.                    */
+  /*                                                                       */
   /*    stream   :: The input stream.                                      */
+  /*                                                                       */
   /*    vertical :: A boolean flag.  If set, load vertical metrics.        */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Metrics_Header( TT_Face    face,
                           FT_Stream  stream,
                           FT_Bool    vertical )
@@ -883,7 +895,7 @@
       header = &face->horizontal;
     }
 
-    if ( READ_Fields( metrics_header_fields, header ) )
+    if ( FT_STREAM_READ_FIELDS( metrics_header_fields, header ) )
       goto Exit;
 
     header->long_metrics  = NULL;
@@ -910,27 +922,27 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: The input stream.                                        */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Names( TT_Face    face,
                  FT_Stream  stream )
   {
-    FT_Error   error;
-    FT_Memory  memory = stream->memory;
-
-    FT_ULong   table_pos, table_len;
-    FT_ULong   storageSize;
+    FT_Error      error;
+    FT_Memory     memory = stream->memory;
+    FT_ULong      table_pos, table_len;
+    FT_ULong      storage_start, storage_limit;
+    FT_UInt       count;
+    TT_NameTable  table;
 
-    TT_NameTable*  names;
-
-    const FT_Frame_Field  name_table_fields[] =
+    static const FT_Frame_Field  name_table_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_NameTable
+#define FT_STRUCTURE  TT_NameTableRec
 
       FT_FRAME_START( 6 ),
         FT_FRAME_USHORT( format ),
@@ -939,10 +951,10 @@
       FT_FRAME_END
     };
 
-    const FT_Frame_Field  name_record_fields[] =
+    static const FT_Frame_Field  name_record_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_NameRec
+#define FT_STRUCTURE  TT_NameEntryRec
 
       /* no FT_FRAME_START */
         FT_FRAME_USHORT( platformID ),
@@ -955,6 +967,9 @@
     };
 
 
+    table         = &face->name_table;
+    table->stream = stream;
+
     FT_TRACE2(( "Names " ));
 
     error = face->goto_table( face, TTAG_name, stream, &table_len );
@@ -966,104 +981,75 @@
       goto Exit;
     }
 
-    table_pos = FILE_Pos();
+    table_pos = FT_STREAM_POS();
 
-    names = &face->name_table;
 
-    if ( READ_Fields( name_table_fields, names ) )
+    if ( FT_STREAM_READ_FIELDS( name_table_fields, table ) )
       goto Exit;
 
-    /* Allocate the array of name records. */
-    if ( ALLOC_ARRAY( names->names,
-                      names->numNameRecords,
-                      TT_NameRec )                   ||
-         ACCESS_Frame( names->numNameRecords * 12L ) )
-      goto Exit;
+    /* Some popular asian fonts have an invalid `storageOffset' value   */
+    /* (it should be at least "6 + 12*num_names").  However, the string */
+    /* offsets, computed as "storageOffset + entry->stringOffset", are  */
+    /* valid pointers within the name table...                          */
+    /*                                                                  */
+    /* We thus can't check `storageOffset' right now.                   */
+    /*                                                                  */
+    storage_start = table_pos + 6 + 12*table->numNameRecords;
+    storage_limit = table_pos + table_len;
 
-    /* Load the name records and determine how much storage is needed */
-    /* to hold the strings themselves.                                */
+    if ( storage_start > storage_limit )
     {
-      TT_NameRec*  cur   = names->names;
-      TT_NameRec*  limit = cur + names->numNameRecords;
-
-
-      storageSize = 0;
-
-      for ( ; cur < limit; cur ++ )
-      {
-        FT_ULong  upper;
-
-
-        if ( READ_Fields( name_record_fields, cur ) )
-          break;
-
-        upper = (FT_ULong)( cur->stringOffset + cur->stringLength );
-        if ( upper > storageSize )
-          storageSize = upper;
-      }
+      FT_ERROR(( "TT_Load_Names: invalid `name' table\n" ));
+      error = SFNT_Err_Name_Table_Missing;
+      goto Exit;
     }
 
-    FORGET_Frame();
-
-    if ( storageSize > 0 )
-    {
-      /* allocate the name storage area in memory, then read it */
-      if ( ALLOC( names->storage, storageSize )               ||
-           FILE_Read_At( table_pos + names->storageOffset,
-                         names->storage, storageSize ) )
-        goto Exit;
-
-      /* Go through and assign the string pointers to the name records. */
-      {
-        TT_NameRec*  cur   = names->names;
-        TT_NameRec*  limit = cur + names->numNameRecords;
+    /* Allocate the array of name records. */
+    count                 = table->numNameRecords;
+    table->numNameRecords = 0;
 
+    if ( FT_NEW_ARRAY( table->names, count ) ||
+         FT_FRAME_ENTER( count * 12 )        )
+      goto Exit;
 
-        for ( ; cur < limit; cur++ )
-          cur->string = names->storage + cur->stringOffset;
-      }
+    /* Load the name records and determine how much storage is needed */
+    /* to hold the strings themselves.                                */
+    {
+      TT_NameEntryRec*  entry = table->names;
 
-#ifdef FT_DEBUG_LEVEL_TRACE
 
-      /* Print Name Record Table in case of debugging */
+      for ( ; count > 0; count-- )
       {
-        TT_NameRec*  cur   = names->names;
-        TT_NameRec*  limit = cur + names->numNameRecords;
-
+        if ( FT_STREAM_READ_FIELDS( name_record_fields, entry ) )
+          continue;
 
-        for ( ; cur < limit; cur++ )
+        /* check that the name is not empty */
+        if ( entry->stringLength == 0 )
+          continue;
+
+        /* check that the name string is within the table */
+        entry->stringOffset += table_pos + table->storageOffset;
+        if ( entry->stringOffset                       < storage_start ||
+             entry->stringOffset + entry->stringLength > storage_limit )
         {
-          FT_UInt  j;
-
-
-          FT_TRACE3(( "%d %d %x %d\n  ",
-                       cur->platformID,
-                       cur->encodingID,
-                       cur->languageID,
-                       cur->nameID ));
-
-          /* I know that M$ encoded strings are Unicode,            */
-          /* but this works reasonable well for debugging purposes. */
-          if ( cur->string )
-            for ( j = 0; j < (FT_UInt)cur->stringLength; j++ )
-            {
-              FT_Char  c = *( cur->string + j );
-
-
-              if ( (FT_Byte)c < 128 )
-                FT_TRACE3(( "%c", c ));
-            }
+          /* invalid entry - ignore it */
+          entry->stringOffset = 0;
+          entry->stringLength = 0;
+          continue;
         }
-      }
-      FT_TRACE3(( "\n" ));
 
-#endif /* FT_DEBUG_LEVEL_TRACE */
+        entry++;
+      }
 
+      table->numNameRecords = entry - table->names;
     }
+
+    FT_FRAME_EXIT();
+
     FT_TRACE2(( "loaded\n" ));
 
     /* everything went well, update face->num_names */
-    face->num_names = names->numNameRecords;
+    face->num_names = (FT_UShort) table->numNameRecords;
 
   Exit:
     return error;
@@ -1081,22 +1067,27 @@
   /* <Input>                                                               */
   /*    face :: A handle to the target face object.                        */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   TT_Free_Names( TT_Face  face )
   {
-    FT_Memory      memory = face->root.driver->root.memory;
-    TT_NameTable*  names  = &face->name_table;
+    FT_Memory     memory = face->root.driver->root.memory;
+    TT_NameTable  table  = &face->name_table;
+    TT_NameEntry  entry  = table->names;
+    FT_UInt       count  = table->numNameRecords;
 
 
-    /* free strings table */
-    FREE( names->names );
+    for ( ; count > 0; count--, entry++ )
+    {
+      FT_FREE( entry->string );
+      entry->stringLength = 0;
+    }
 
-    /* free strings storage */
-    FREE( names->storage );
+    /* free strings table */
+    FT_FREE( table->names );
 
-    names->numNameRecords = 0;
-    names->format         = 0;
-    names->storageOffset  = 0;
+    table->numNameRecords = 0;
+    table->format         = 0;
+    table->storageOffset  = 0;
   }
 
 
@@ -1111,24 +1102,57 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: A handle to the input stream.                            */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_CMap( TT_Face    face,
                 FT_Stream  stream )
   {
-    FT_Error    error;
-    FT_Memory   memory = stream->memory;
-    FT_Long     table_start;
-    TT_CMapDir  cmap_dir;
+    FT_Error  error;
+
+
+    error = face->goto_table( face, TTAG_cmap, stream, &face->cmap_size );
+    if ( error )
+    {
+      FT_TRACE2(( "No `cmap' table in font !\n" ));
+      error = SFNT_Err_CMap_Table_Missing;
+      goto Exit;
+    }
+
+    if ( !FT_FRAME_EXTRACT( face->cmap_size, face->cmap_table ) )
+      FT_TRACE2(( "`cmap' table loaded\n" ));
+    else
+    {
+      FT_ERROR(( "`cmap' table is too short!\n" ));
+      face->cmap_size = 0;
+    }
+
+  Exit:
+    return error;
+  }
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+  FT_LOCAL_DEF( FT_Error )
+  TT_Load_CMap( TT_Face    face,
+                FT_Stream  stream )
+  {
+    FT_Error       error;
+    FT_Memory      memory = stream->memory;
+    FT_Long        table_start;
+    TT_CMapDirRec  cmap_dir;
 
     const FT_Frame_Field  cmap_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_CMapDir
+#define FT_STRUCTURE  TT_CMapDirRec
 
       FT_FRAME_START( 4 ),
         FT_FRAME_USHORT( tableVersionNumber ),
@@ -1139,7 +1163,7 @@
     const FT_Frame_Field  cmap_rec_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_CMapTable
+#define FT_STRUCTURE  TT_CMapTableRec
 
       FT_FRAME_START( 4 ),
         FT_FRAME_USHORT( format ),
@@ -1157,15 +1181,13 @@
       goto Exit;
     }
 
-    table_start = FILE_Pos();
+    table_start = FT_STREAM_POS();
 
-    if ( READ_Fields( cmap_fields, &cmap_dir ) )
+    if ( FT_STREAM_READ_FIELDS( cmap_fields, &cmap_dir ) )
       goto Exit;
 
     /* reserve space in face table for cmap tables */
-    if ( ALLOC_ARRAY( face->charmaps,
-                      cmap_dir.numCMaps,
-                      TT_CharMapRec ) )
+    if ( FT_NEW_ARRAY( face->charmaps, cmap_dir.numCMaps ) )
       goto Exit;
 
     face->num_charmaps = cmap_dir.numCMaps;
@@ -1175,36 +1197,36 @@
 
 
       /* read the header of each charmap first */
-      if ( ACCESS_Frame( face->num_charmaps * 8L ) )
+      if ( FT_FRAME_ENTER( face->num_charmaps * 8L ) )
         goto Exit;
 
       for ( ; charmap < limit; charmap++ )
       {
-        TT_CMapTable*  cmap;
+        TT_CMapTable  cmap;
 
 
         charmap->root.face = (FT_Face)face;
         cmap               = &charmap->cmap;
 
         cmap->loaded             = FALSE;
-        cmap->platformID         = GET_UShort();
-        cmap->platformEncodingID = GET_UShort();
-        cmap->offset             = (FT_ULong)GET_Long();
+        cmap->platformID         = FT_GET_USHORT();
+        cmap->platformEncodingID = FT_GET_USHORT();
+        cmap->offset             = (FT_ULong)FT_GET_LONG();
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       /* now read the rest of each table */
       for ( charmap = face->charmaps; charmap < limit; charmap++ )
       {
-        TT_CMapTable* cmap = &charmap->cmap;
+        TT_CMapTable  cmap = &charmap->cmap;
 
 
-        if ( FILE_Seek( table_start + (FT_Long)cmap->offset ) ||
-             READ_Fields( cmap_rec_fields, cmap )             )
+        if ( FT_STREAM_SEEK( table_start + (FT_Long)cmap->offset ) ||
+             FT_STREAM_READ_FIELDS( cmap_rec_fields, cmap )        )
           goto Exit;
 
-        cmap->offset = FILE_Pos();
+        cmap->offset = FT_STREAM_POS();
       }
     }
 
@@ -1214,6 +1236,8 @@
     return error;
   }
 
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
 
   /*************************************************************************/
   /*                                                                       */
@@ -1225,12 +1249,13 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: A handle to the input stream.                            */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_OS2( TT_Face    face,
                FT_Stream  stream )
   {
@@ -1318,14 +1343,14 @@
     if ( error )
     {
       FT_TRACE2(( "is missing!\n" ));
-      face->os2.version = 0xFFFF;
+      face->os2.version = 0xFFFFU;
       error = SFNT_Err_Ok;
       goto Exit;
     }
 
     os2 = &face->os2;
 
-    if ( READ_Fields( os2_fields, os2 ) )
+    if ( FT_STREAM_READ_FIELDS( os2_fields, os2 ) )
       goto Exit;
 
     os2->ulCodePageRange1 = 0;
@@ -1339,13 +1364,13 @@
     if ( os2->version >= 0x0001 )
     {
       /* only version 1 tables */
-      if ( READ_Fields( os2_fields_extra, os2 ) )
+      if ( FT_STREAM_READ_FIELDS( os2_fields_extra, os2 ) )
         goto Exit;
 
       if ( os2->version >= 0x0002 )
       {
         /* only version 2 tables */
-        if ( READ_Fields( os2_fields_extra2, os2 ) )
+        if ( FT_STREAM_READ_FIELDS( os2_fields_extra2, os2 ) )
           goto Exit;
       }
     }
@@ -1367,12 +1392,13 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: A handle to the input stream.                            */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_PostScript( TT_Face    face,
                       FT_Stream  stream )
   {
@@ -1404,7 +1430,7 @@
     if ( error )
       return SFNT_Err_Post_Table_Missing;
 
-    if ( READ_Fields( post_fields, post ) )
+    if ( FT_STREAM_READ_FIELDS( post_fields, post ) )
       return error;
 
     /* we don't load the glyph names, we do that in another */
@@ -1425,12 +1451,13 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: A handle to the input stream.                            */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_PCLT( TT_Face    face,
                 FT_Stream  stream )
   {
@@ -1472,7 +1499,7 @@
       return SFNT_Err_Ok;
     }
 
-    if ( READ_Fields( pclt_fields, pclt ) )
+    if ( FT_STREAM_READ_FIELDS( pclt_fields, pclt ) )
       goto Exit;
 
     FT_TRACE2(( "loaded\n" ));
@@ -1492,12 +1519,13 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: The input stream.                                        */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Gasp( TT_Face    face,
                 FT_Stream  stream )
   {
@@ -1505,7 +1533,7 @@
     FT_Memory  memory = stream->memory;
 
     FT_UInt        j,num_ranges;
-    TT_GaspRange*  gaspranges;
+    TT_GaspRange   gaspranges;
 
 
     FT_TRACE2(( "TT_Load_Gasp: %08p\n", face ));
@@ -1515,27 +1543,27 @@
     if ( error )
       return SFNT_Err_Ok;
 
-    if ( ACCESS_Frame( 4L ) )
+    if ( FT_FRAME_ENTER( 4L ) )
       goto Exit;
 
-    face->gasp.version   = GET_UShort();
-    face->gasp.numRanges = GET_UShort();
+    face->gasp.version   = FT_GET_USHORT();
+    face->gasp.numRanges = FT_GET_USHORT();
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     num_ranges = face->gasp.numRanges;
     FT_TRACE3(( "number of ranges = %d\n", num_ranges ));
 
-    if ( ALLOC_ARRAY( gaspranges, num_ranges, TT_GaspRange ) ||
-         ACCESS_Frame( num_ranges * 4L )                     )
+    if ( FT_NEW_ARRAY( gaspranges, num_ranges ) ||
+         FT_FRAME_ENTER( num_ranges * 4L )      )
       goto Exit;
 
     face->gasp.gaspRanges = gaspranges;
 
     for ( j = 0; j < num_ranges; j++ )
     {
-      gaspranges[j].maxPPEM  = GET_UShort();
-      gaspranges[j].gaspFlag = GET_UShort();
+      gaspranges[j].maxPPEM  = FT_GET_USHORT();
+      gaspranges[j].gaspFlag = FT_GET_USHORT();
 
       FT_TRACE3(( " [max:%d flag:%d]",
                     gaspranges[j].maxPPEM,
@@ -1543,7 +1571,7 @@
     }
     FT_TRACE3(( "\n" ));
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
     FT_TRACE2(( "GASP loaded\n" ));
 
   Exit:
@@ -1569,12 +1597,13 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: The input stream.                                        */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Kern( TT_Face    face,
                 FT_Stream  stream )
   {
@@ -1589,13 +1618,13 @@
     if ( error )
       return SFNT_Err_Ok;
 
-    if ( ACCESS_Frame( 4L ) )
+    if ( FT_FRAME_ENTER( 4L ) )
       goto Exit;
 
-    (void)GET_UShort();         /* version */
-    num_tables = GET_UShort();
+    (void)FT_GET_USHORT();         /* version */
+    num_tables = FT_GET_USHORT();
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     for ( n = 0; n < num_tables; n++ )
     {
@@ -1603,47 +1632,47 @@
       FT_UInt  length;
 
 
-      if ( ACCESS_Frame( 6L ) )
+      if ( FT_FRAME_ENTER( 6L ) )
         goto Exit;
 
-      (void)GET_UShort();           /* version                 */
-      length   = GET_UShort() - 6;  /* substract header length */
-      coverage = GET_UShort();
+      (void)FT_GET_USHORT();           /* version                 */
+      length   = FT_GET_USHORT() - 6;  /* substract header length */
+      coverage = FT_GET_USHORT();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       if ( coverage == 0x0001 )
       {
-        FT_UInt          num_pairs;
-        TT_Kern_0_Pair*  pair;
-        TT_Kern_0_Pair*  limit;
+        FT_UInt        num_pairs;
+        TT_Kern0_Pair  pair;
+        TT_Kern0_Pair  limit;
 
 
         /* found a horizontal format 0 kerning table! */
-        if ( ACCESS_Frame( 8L ) )
+        if ( FT_FRAME_ENTER( 8L ) )
           goto Exit;
 
-        num_pairs = GET_UShort();
+        num_pairs = FT_GET_USHORT();
 
         /* skip the rest */
 
-        FORGET_Frame();
+        FT_FRAME_EXIT();
 
         /* allocate array of kerning pairs */
-        if ( ALLOC_ARRAY( face->kern_pairs, num_pairs, TT_Kern_0_Pair ) ||
-             ACCESS_Frame( 6L * num_pairs )                             )
+        if ( FT_NEW_ARRAY( face->kern_pairs, num_pairs ) ||
+             FT_FRAME_ENTER( 6L * num_pairs )            )
           goto Exit;
 
         pair  = face->kern_pairs;
         limit = pair + num_pairs;
         for ( ; pair < limit; pair++ )
         {
-          pair->left  = GET_UShort();
-          pair->right = GET_UShort();
-          pair->value = GET_UShort();
+          pair->left  = FT_GET_USHORT();
+          pair->right = FT_GET_USHORT();
+          pair->value = FT_GET_USHORT();
         }
 
-        FORGET_Frame();
+        FT_FRAME_EXIT();
 
         face->num_kern_pairs   = num_pairs;
         face->kern_table_index = n;
@@ -1651,8 +1680,8 @@
         /* ensure that the kerning pair table is sorted (yes, some */
         /* fonts have unsorted tables!)                            */
         {
-          FT_UInt          i;
-          TT_Kern_0_Pair*  pair0;
+          FT_UInt        i;
+          TT_Kern0_Pair  pair0;
 
 
           pair0 = face->kern_pairs;
@@ -1661,8 +1690,8 @@
           {
             if ( tt_kern_pair_compare( pair0, pair0 + 1 ) != -1 )
             {
-              qsort( (void*)face->kern_pairs, (int)num_pairs,
-                     sizeof ( TT_Kern_0_Pair ), tt_kern_pair_compare );
+              ft_qsort( (void*)face->kern_pairs, (int)num_pairs,
+                        sizeof ( TT_Kern0_PairRec ), tt_kern_pair_compare );
               break;
             }
           }
@@ -1671,7 +1700,7 @@
         goto Exit;
       }
 
-      if ( FILE_Skip( length ) )
+      if ( FT_STREAM_SKIP( length ) )
         goto Exit;
     }
 
@@ -1688,12 +1717,13 @@
 #undef  TT_KERN_INDEX
 #define TT_KERN_INDEX( g1, g2 )  ( ( (FT_ULong)g1 << 16 ) | g2 )
 
+
   FT_CALLBACK_DEF( int )
   tt_kern_pair_compare( const void*  a,
                         const void*  b )
   {
-    TT_Kern_0_Pair*  pair1 = (TT_Kern_0_Pair*)a;
-    TT_Kern_0_Pair*  pair2 = (TT_Kern_0_Pair*)b;
+    TT_Kern0_Pair  pair1 = (TT_Kern0_Pair)a;
+    TT_Kern0_Pair  pair2 = (TT_Kern0_Pair)b;
 
     FT_ULong  index1 = TT_KERN_INDEX( pair1->left, pair1->right );
     FT_ULong  index2 = TT_KERN_INDEX( pair2->left, pair2->right );
@@ -1703,6 +1733,7 @@
            ( index1 > index2 ?  1 : 0 ));
   }
 
+
 #undef TT_KERN_INDEX
 
 
@@ -1716,21 +1747,22 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
   /*    stream :: A handle to the input stream.                            */
   /*                                                                       */
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Hdmx( TT_Face    face,
                 FT_Stream  stream )
   {
-    FT_Error  error;
-    FT_Memory memory = stream->memory;
+    FT_Error   error;
+    FT_Memory  memory = stream->memory;
 
-    TT_Hdmx*  hdmx = &face->hdmx;
-    FT_Long   num_glyphs;
-    FT_Long   record_size;
+    TT_Hdmx    hdmx = &face->hdmx;
+    FT_Long    num_glyphs;
+    FT_Long    record_size;
 
 
     hdmx->version     = 0;
@@ -1742,43 +1774,43 @@
     if ( error )
       return SFNT_Err_Ok;
 
-    if ( ACCESS_Frame( 8L ) )
+    if ( FT_FRAME_ENTER( 8L ) )
       goto Exit;
 
-    hdmx->version     = GET_UShort();
-    hdmx->num_records = GET_Short();
-    record_size       = GET_Long();
+    hdmx->version     = FT_GET_USHORT();
+    hdmx->num_records = FT_GET_SHORT();
+    record_size       = FT_GET_LONG();
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     /* Only recognize format 0 */
     if ( hdmx->version != 0 )
       goto Exit;
 
-    if ( ALLOC_ARRAY( hdmx->records, hdmx->num_records, TT_HdmxRec ) )
+    if ( FT_NEW_ARRAY( hdmx->records, hdmx->num_records ) )
       goto Exit;
 
     num_glyphs   = face->root.num_glyphs;
     record_size -= num_glyphs + 2;
 
     {
-      TT_HdmxRec*  cur   = hdmx->records;
-      TT_HdmxRec*  limit = cur + hdmx->num_records;
+      TT_HdmxEntry  cur   = hdmx->records;
+      TT_HdmxEntry  limit = cur + hdmx->num_records;
 
 
       for ( ; cur < limit; cur++ )
       {
         /* read record */
-        if ( READ_Byte( cur->ppem      ) ||
-             READ_Byte( cur->max_width ) )
+        if ( FT_READ_BYTE( cur->ppem      ) ||
+             FT_READ_BYTE( cur->max_width ) )
           goto Exit;
 
-        if ( ALLOC( cur->widths, num_glyphs )     ||
-             FILE_Read( cur->widths, num_glyphs ) )
+        if ( FT_ALLOC( cur->widths, num_glyphs )       ||
+             FT_STREAM_READ( cur->widths, num_glyphs ) )
           goto Exit;
 
         /* skip padding bytes */
-        if ( record_size > 0 && FILE_Skip( record_size ) )
+        if ( record_size > 0 && FT_STREAM_SKIP( record_size ) )
             goto Exit;
       }
     }
@@ -1799,7 +1831,7 @@
   /* <Input>                                                               */
   /*    face :: A handle to the target face object.                        */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   TT_Free_Hdmx( TT_Face  face )
   {
     if ( face )
@@ -1809,9 +1841,9 @@
 
 
       for ( n = 0; n < face->hdmx.num_records; n++ )
-        FREE( face->hdmx.records[n].widths );
+        FT_FREE( face->hdmx.records[n].widths );
 
-      FREE( face->hdmx.records );
+      FT_FREE( face->hdmx.records );
       face->hdmx.num_records = 0;
     }
   }
Index: xc/extras/freetype2/src/sfnt/ttload.h
diff -u xc/extras/freetype2/src/sfnt/ttload.h:1.1.1.3 xc/extras/freetype2/src/sfnt/ttload.h:1.1.1.4
--- xc/extras/freetype2/src/sfnt/ttload.h:1.1.1.3	Sun Dec 16 12:49:32 2001
+++ xc/extras/freetype2/src/sfnt/ttload.h	Thu Jun 20 04:16:22 2002
@@ -5,7 +5,7 @@
 /*    Load the basic TrueType tables, i.e., tables that can be either in   */
 /*    TTF or OTF fonts (specification).                                    */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -29,29 +29,29 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL TT_Table*
+  FT_LOCAL( TT_Table  )
   TT_LookUp_Table( TT_Face   face,
                    FT_ULong  tag );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Goto_Table( TT_Face    face,
                  FT_ULong   tag,
                  FT_Stream  stream,
                  FT_ULong*  length );
 
 
-  FT_LOCAL FT_Error
-  TT_Load_SFNT_Header( TT_Face       face,
-                       FT_Stream     stream,
-                       FT_Long       face_index,
-                       SFNT_Header*  sfnt );
+  FT_LOCAL( FT_Error )
+  TT_Load_SFNT_HeaderRec( TT_Face       face,
+                          FT_Stream     stream,
+                          FT_Long       face_index,
+                          SFNT_Header   sfnt );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Directory( TT_Face       face,
                      FT_Stream     stream,
-                     SFNT_Header*  sfnt );
+                     SFNT_Header   sfnt );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Any( TT_Face    face,
                FT_ULong   tag,
                FT_Long    offset,
@@ -59,70 +59,70 @@
                FT_ULong*  length );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Header( TT_Face    face,
                   FT_Stream  stream );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Metrics_Header( TT_Face    face,
                           FT_Stream  stream,
                           FT_Bool    vertical );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_CMap( TT_Face    face,
                 FT_Stream  stream );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_MaxProfile( TT_Face    face,
                       FT_Stream  stream );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Names( TT_Face    face,
                  FT_Stream  stream );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_OS2( TT_Face    face,
                FT_Stream  stream );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_PostScript( TT_Face    face,
                       FT_Stream  stream );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Hdmx( TT_Face    face,
                 FT_Stream  stream );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_PCLT( TT_Face    face,
                 FT_Stream  stream );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   TT_Free_Names( TT_Face  face );
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   TT_Free_Hdmx ( TT_Face  face );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Kern( TT_Face    face,
                 FT_Stream  stream );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Gasp( TT_Face    face,
                 FT_Stream  stream );
 
 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Bitmap_Header( TT_Face    face,
                          FT_Stream  stream );
 
Index: xc/extras/freetype2/src/sfnt/ttpost.c
diff -u xc/extras/freetype2/src/sfnt/ttpost.c:1.1.1.4 xc/extras/freetype2/src/sfnt/ttpost.c:1.1.1.5
--- xc/extras/freetype2/src/sfnt/ttpost.c:1.1.1.4	Sun Dec 16 12:49:32 2001
+++ xc/extras/freetype2/src/sfnt/ttpost.c	Thu Jun 20 04:16:22 2002
@@ -5,7 +5,7 @@
 /*    Postcript name table processing for TrueType and OpenType fonts      */
 /*    (body).                                                              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -33,6 +33,7 @@
 
 #include "sferrors.h"
 
+
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -49,7 +50,7 @@
 #ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
 
 
-#include <freetype/internal/psnames.h>
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
 
 #define MAC_NAME( x )  ( (FT_String*)psnames->macintosh_name( x ) )
 
@@ -155,17 +156,17 @@
   Load_Format_20( TT_Face    face,
                   FT_Stream  stream )
   {
-    FT_Memory  memory = stream->memory;
-    FT_Error   error;
+    FT_Memory   memory = stream->memory;
+    FT_Error    error;
 
-    FT_Int     num_glyphs;
-    FT_UShort  num_names;
+    FT_Int      num_glyphs;
+    FT_UShort   num_names;
 
-    FT_UShort* glyph_indices = 0;
-    FT_Char**  name_strings  = 0;
+    FT_UShort*  glyph_indices = 0;
+    FT_Char**   name_strings  = 0;
 
 
-    if ( READ_UShort( num_glyphs ) )
+    if ( FT_READ_USHORT( num_glyphs ) )
       goto Exit;
 
     /* UNDOCUMENTED!  The number of glyphs in this table can be smaller */
@@ -185,14 +186,14 @@
       FT_Int  n;
 
 
-      if ( ALLOC_ARRAY ( glyph_indices, num_glyphs, FT_UShort ) ||
-           ACCESS_Frame( num_glyphs * 2L )                      )
+      if ( FT_NEW_ARRAY ( glyph_indices, num_glyphs ) ||
+           FT_FRAME_ENTER( num_glyphs * 2L )          )
         goto Fail;
 
       for ( n = 0; n < num_glyphs; n++ )
-        glyph_indices[n] = GET_UShort();
+        glyph_indices[n] = FT_GET_USHORT();
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
     }
 
     /* compute number of names stored in table */
@@ -204,15 +205,15 @@
 
       for ( n = 0; n < num_glyphs; n++ )
       {
-        FT_Int  index;
+        FT_Int  idx;
 
 
-        index = glyph_indices[n];
-        if ( index >= 258 )
+        idx = glyph_indices[n];
+        if ( idx >= 258 )
         {
-          index -= 257;
-          if ( index > num_names )
-            num_names = (FT_UShort)index;
+          idx -= 257;
+          if ( idx > num_names )
+            num_names = (FT_UShort)idx;
         }
       }
     }
@@ -222,7 +223,7 @@
       FT_UShort  n;
 
 
-      if ( ALLOC_ARRAY( name_strings, num_names, FT_Char* ) )
+      if ( FT_NEW_ARRAY( name_strings, num_names ) )
         goto Fail;
 
       for ( n = 0; n < num_names; n++ )
@@ -230,9 +231,9 @@
         FT_UInt  len;
 
 
-        if ( READ_Byte  ( len )                               ||
-             ALLOC_ARRAY( name_strings[n], len + 1, FT_Char ) ||
-             FILE_Read  ( name_strings[n], len )              )
+        if ( FT_READ_BYTE  ( len )                    ||
+             FT_NEW_ARRAY( name_strings[n], len + 1 ) ||
+             FT_STREAM_READ  ( name_strings[n], len ) )
           goto Fail1;
 
         name_strings[n][len] = '\0';
@@ -241,7 +242,7 @@
 
     /* all right, set table fields and exit successfuly */
     {
-      TT_Post_20*  table = &face->postscript_names.names.format_20;
+      TT_Post_20  table = &face->postscript_names.names.format_20;
 
 
       table->num_glyphs    = (FT_UShort)num_glyphs;
@@ -251,19 +252,18 @@
     }
     return SFNT_Err_Ok;
 
-
   Fail1:
     {
       FT_UShort  n;
 
 
       for ( n = 0; n < num_names; n++ )
-        FREE( name_strings[n] );
+        FT_FREE( name_strings[n] );
     }
 
   Fail:
-    FREE( name_strings );
-    FREE( glyph_indices );
+    FT_FREE( name_strings );
+    FT_FREE( glyph_indices );
 
   Exit:
     return error;
@@ -282,7 +282,7 @@
 
 
     /* UNDOCUMENTED!  This value appears only in the Apple TT specs. */
-    if ( READ_UShort( num_glyphs ) )
+    if ( FT_READ_USHORT( num_glyphs ) )
       goto Exit;
 
     /* check the number of glyphs */
@@ -292,8 +292,8 @@
       goto Exit;
     }
 
-    if ( ALLOC    ( offset_table, num_glyphs ) ||
-         FILE_Read( offset_table, num_glyphs ) )
+    if ( FT_ALLOC( offset_table, num_glyphs )       ||
+         FT_STREAM_READ( offset_table, num_glyphs ) )
       goto Fail;
 
     /* now check the offset table */
@@ -303,10 +303,10 @@
 
       for ( n = 0; n < num_glyphs; n++ )
       {
-        FT_Long  index = (FT_Long)n + offset_table[n];
+        FT_Long  idx = (FT_Long)n + offset_table[n];
 
 
-        if ( index < 0 || index > num_glyphs )
+        if ( idx < 0 || idx > num_glyphs )
         {
           error = SFNT_Err_Invalid_File_Format;
           goto Fail;
@@ -316,7 +316,7 @@
 
     /* OK, set table fields and exit successfuly */
     {
-      TT_Post_25*  table = &face->postscript_names.names.format_25;
+      TT_Post_25  table = &face->postscript_names.names.format_25;
 
 
       table->num_glyphs = (FT_UShort)num_glyphs;
@@ -326,7 +326,7 @@
     return SFNT_Err_Ok;
 
   Fail:
-    FREE( offset_table );
+    FT_FREE( offset_table );
 
   Exit:
     return error;
@@ -352,7 +352,7 @@
     format = face->postscript.FormatType;
 
     /* go to beginning of subtable */
-    if ( FILE_Skip( 32 ) )
+    if ( FT_STREAM_SKIP( 32 ) )
       goto Exit;
 
     /* now read postscript table */
@@ -377,11 +377,11 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   TT_Free_Post_Names( TT_Face  face )
   {
-    FT_Memory       memory = face->root.memory;
-    TT_Post_Names*  names  = &face->postscript_names;
+    FT_Memory      memory = face->root.memory;
+    TT_Post_Names  names  = &face->postscript_names;
 
 
     if ( names->loaded )
@@ -390,27 +390,27 @@
       {
       case 0x00020000L:
         {
-          TT_Post_20*  table = &names->names.format_20;
-          FT_UShort    n;
+          TT_Post_20  table = &names->names.format_20;
+          FT_UShort   n;
 
 
-          FREE( table->glyph_indices );
+          FT_FREE( table->glyph_indices );
           table->num_glyphs = 0;
 
           for ( n = 0; n < table->num_names; n++ )
-            FREE( table->glyph_names[n] );
+            FT_FREE( table->glyph_names[n] );
 
-          FREE( table->glyph_names );
+          FT_FREE( table->glyph_names );
           table->num_names = 0;
         }
         break;
 
       case 0x00028000L:
         {
-          TT_Post_25*  table = &names->names.format_25;
+          TT_Post_25  table = &names->names.format_25;
 
 
-          FREE( table->offsets );
+          FT_FREE( table->offsets );
           table->num_glyphs = 0;
         }
         break;
@@ -431,7 +431,7 @@
   /* <Input>                                                               */
   /*    face   :: A handle to the parent face.                             */
   /*                                                                       */
-  /*    index  :: The glyph index.                                         */
+  /*    idx    :: The glyph index.                                         */
   /*                                                                       */
   /*    PSname :: The address of a string pointer.  Will be NULL in case   */
   /*              of error, otherwise it is a pointer to the glyph name.   */
@@ -441,27 +441,27 @@
   /* <Output>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Get_PS_Name( TT_Face      face,
-                  FT_UInt      index,
+                  FT_UInt      idx,
                   FT_String**  PSname )
   {
-    FT_Error            error;
-    TT_Post_Names*      names;
+    FT_Error         error;
+    TT_Post_Names    names;
 
 #ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
-    PSNames_Interface*  psnames;
+    PSNames_Service  psnames;
 #endif
 
 
     if ( !face )
       return SFNT_Err_Invalid_Face_Handle;
 
-    if ( index >= (FT_UInt)face->root.num_glyphs )
+    if ( idx >= (FT_UInt)face->root.num_glyphs )
       return SFNT_Err_Invalid_Glyph_Index;
 
 #ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
-    psnames = (PSNames_Interface*)face->psnames;
+    psnames = (PSNames_Service)face->psnames;
     if ( !psnames )
       return SFNT_Err_Unimplemented_Feature;
 #endif
@@ -474,13 +474,13 @@
     switch ( face->postscript.FormatType )
     {
     case 0x00010000L:
-      if ( index < 258 )                    /* paranoid checking */
-        *PSname = MAC_NAME( index );
+      if ( idx < 258 )                    /* paranoid checking */
+        *PSname = MAC_NAME( idx );
       break;
 
     case 0x00020000L:
       {
-        TT_Post_20*  table = &names->names.format_20;
+        TT_Post_20  table = &names->names.format_20;
 
 
         if ( !names->loaded )
@@ -490,9 +490,9 @@
             break;
         }
 
-        if ( index < (FT_UInt)table->num_glyphs )
+        if ( idx < (FT_UInt)table->num_glyphs )
         {
-          FT_UShort  name_index = table->glyph_indices[index];
+          FT_UShort  name_index = table->glyph_indices[idx];
 
 
           if ( name_index < 258 )
@@ -505,7 +505,7 @@
 
     case 0x00028000L:
       {
-        TT_Post_25*  table = &names->names.format_25;
+        TT_Post_25  table = &names->names.format_25;
 
 
         if ( !names->loaded )
@@ -515,10 +515,10 @@
             break;
         }
 
-        if ( index < (FT_UInt)table->num_glyphs )    /* paranoid checking */
+        if ( idx < (FT_UInt)table->num_glyphs )    /* paranoid checking */
         {
-          index  += table->offsets[index];
-          *PSname = MAC_NAME( index );
+          idx    += table->offsets[idx];
+          *PSname = MAC_NAME( idx );
         }
       }
       break;
Index: xc/extras/freetype2/src/sfnt/ttpost.h
diff -u xc/extras/freetype2/src/sfnt/ttpost.h:1.1.1.4 xc/extras/freetype2/src/sfnt/ttpost.h:1.1.1.5
--- xc/extras/freetype2/src/sfnt/ttpost.h:1.1.1.4	Sun Dec 16 12:49:32 2001
+++ xc/extras/freetype2/src/sfnt/ttpost.h	Thu Jun 20 04:16:22 2002
@@ -5,7 +5,7 @@
 /*    Postcript name table processing for TrueType and OpenType fonts      */
 /*    (specification).                                                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -29,12 +29,12 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Get_PS_Name( TT_Face      face,
-                  FT_UInt      index,
+                  FT_UInt      idx,
                   FT_String**  PSname );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   TT_Free_Post_Names( TT_Face  face );
 
 
Index: xc/extras/freetype2/src/sfnt/ttsbit.c
diff -u xc/extras/freetype2/src/sfnt/ttsbit.c:1.1.1.5 xc/extras/freetype2/src/sfnt/ttsbit.c:1.1.1.7
--- xc/extras/freetype2/src/sfnt/ttsbit.c:1.1.1.5	Mon Jan 14 11:52:22 2002
+++ xc/extras/freetype2/src/sfnt/ttsbit.c	Thu Jun 20 04:16:23 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType and OpenType embedded bitmap support (body).                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -131,8 +131,8 @@
             val = (FT_Byte)( acc >> 8 );
             if ( shift )
             {
-              cur[0] |= (FT_Byte)(val >> shift);
-              cur[1] |= (FT_Byte)(val << space);
+              cur[0] |= (FT_Byte)( val >> shift );
+              cur[1] |= (FT_Byte)( val << space );
             }
             else
               cur[0] |= val;
@@ -164,10 +164,10 @@
 
         /* now write remaining bits */
         val     = (FT_Byte)( ( (FT_Byte)( acc >> 8 ) ) & ~( 0xFF >> count ) );
-        cur[0] |= (FT_Byte)(val >> shift);
+        cur[0] |= (FT_Byte)( val >> shift );
 
         if ( count > space )
-          cur[1] |= (FT_Byte)(val << space);
+          cur[1] |= (FT_Byte)( val << space );
 
         acc   <<= count;
         loaded -= count;
@@ -188,7 +188,7 @@
   const FT_Frame_Field  sbit_metrics_fields[] =
   {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_SBit_Metrics
+#define FT_STRUCTURE  TT_SBit_MetricsRec
 
     FT_FRAME_START( 8 ),
       FT_FRAME_BYTE( height ),
@@ -222,16 +222,16 @@
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
   static FT_Error
-  Load_SBit_Const_Metrics( TT_SBit_Range*  range,
-                           FT_Stream       stream )
+  Load_SBit_Const_Metrics( TT_SBit_Range  range,
+                           FT_Stream      stream )
   {
     FT_Error  error;
 
 
-    if ( READ_ULong( range->image_size ) )
+    if ( FT_READ_ULONG( range->image_size ) )
       return error;
 
-    return READ_Fields( sbit_metrics_fields, &range->metrics );
+    return FT_STREAM_READ_FIELDS( sbit_metrics_fields, &range->metrics );
   }
 
 
@@ -254,16 +254,16 @@
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
   static FT_Error
-  Load_SBit_Range_Codes( TT_SBit_Range*  range,
-                         FT_Stream       stream,
-                         FT_Bool         load_offsets )
+  Load_SBit_Range_Codes( TT_SBit_Range  range,
+                         FT_Stream      stream,
+                         FT_Bool        load_offsets )
   {
     FT_Error   error;
     FT_ULong   count, n, size;
     FT_Memory  memory = stream->memory;
 
 
-    if ( READ_ULong( count ) )
+    if ( FT_READ_ULONG( count ) )
       goto Exit;
 
     range->num_glyphs = count;
@@ -271,7 +271,7 @@
     /* Allocate glyph offsets table if needed */
     if ( load_offsets )
     {
-      if ( ALLOC_ARRAY( range->glyph_offsets, count, FT_ULong ) )
+      if ( FT_NEW_ARRAY( range->glyph_offsets, count ) )
         goto Exit;
 
       size = count * 4L;
@@ -280,20 +280,20 @@
       size = count * 2L;
 
     /* Allocate glyph codes table and access frame */
-    if ( ALLOC_ARRAY ( range->glyph_codes, count, FT_UShort ) ||
-         ACCESS_Frame( size )                                 )
+    if ( FT_NEW_ARRAY ( range->glyph_codes, count ) ||
+         FT_FRAME_ENTER( size )                     )
       goto Exit;
 
     for ( n = 0; n < count; n++ )
     {
-      range->glyph_codes[n] = GET_UShort();
+      range->glyph_codes[n] = FT_GET_USHORT();
 
       if ( load_offsets )
         range->glyph_offsets[n] = (FT_ULong)range->image_offset +
-                                  GET_UShort();
+                                  FT_GET_USHORT();
     }
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
   Exit:
     return error;
@@ -317,8 +317,8 @@
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
   static FT_Error
-  Load_SBit_Range( TT_SBit_Range*  range,
-                   FT_Stream       stream )
+  Load_SBit_Range( TT_SBit_Range  range,
+                   FT_Stream      stream )
   {
     FT_Error   error;
     FT_Memory  memory = stream->memory;
@@ -340,16 +340,15 @@
 
         size_elem = large ? 4 : 2;
 
-        if ( ALLOC_ARRAY( range->glyph_offsets,
-                          num_glyphs, FT_ULong )    ||
-             ACCESS_Frame( num_glyphs * size_elem ) )
+        if ( FT_NEW_ARRAY( range->glyph_offsets, num_glyphs ) ||
+             FT_FRAME_ENTER( num_glyphs * size_elem )         )
           goto Exit;
 
         for ( n = 0; n < num_glyphs; n++ )
           range->glyph_offsets[n] = (FT_ULong)( range->image_offset +
-                                                  ( large ? GET_ULong()
-                                                          : GET_UShort() ) );
-        FORGET_Frame();
+                                                ( large ? FT_GET_ULONG()
+                                                        : FT_GET_USHORT() ) );
+        FT_FRAME_EXIT();
       }
       break;
 
@@ -362,8 +361,8 @@
       break;
 
     case 5:
-      error = Load_SBit_Const_Metrics( range, stream ) ||
-              Load_SBit_Range_Codes( range, stream, 0  );
+      error = Load_SBit_Const_Metrics( range, stream )   ||
+              Load_SBit_Range_Codes( range, stream, 0 );
       break;
 
     default:
@@ -391,7 +390,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_SBit_Strikes( TT_Face    face,
                         FT_Stream  stream )
   {
@@ -404,7 +403,7 @@
     const FT_Frame_Field  sbit_line_metrics_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_SBit_Line_Metrics
+#define FT_STRUCTURE  TT_SBit_LineMetricsRec
 
       /* no FT_FRAME_START */
         FT_FRAME_CHAR( ascender ),
@@ -427,7 +426,7 @@
     const FT_Frame_Field  strike_start_fields[] =
     {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_SBit_Strike
+#define FT_STRUCTURE  TT_SBit_StrikeRec
 
       /* no FT_FRAME_START */
         FT_FRAME_ULONG( ranges_offset ),
@@ -459,14 +458,14 @@
     if ( error )
       goto Exit;
 
-    table_base = FILE_Pos();
-    if ( ACCESS_Frame( 8L ) )
+    table_base = FT_STREAM_POS();
+    if ( FT_FRAME_ENTER( 8L ) )
       goto Exit;
 
-    version     = GET_Long();
-    num_strikes = GET_ULong();
+    version     = FT_GET_LONG();
+    num_strikes = FT_GET_ULONG();
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     /* check version number and strike count */
     if ( version     != 0x00020000L ||
@@ -479,69 +478,67 @@
     }
 
     /* allocate the strikes table */
-    if ( ALLOC_ARRAY( face->sbit_strikes, num_strikes, TT_SBit_Strike ) )
+    if ( FT_NEW_ARRAY( face->sbit_strikes, num_strikes ) )
       goto Exit;
 
     face->num_sbit_strikes = num_strikes;
 
     /* now read each strike table separately */
     {
-      TT_SBit_Strike*  strike = face->sbit_strikes;
-      FT_ULong         count  = num_strikes;
+      TT_SBit_Strike  strike = face->sbit_strikes;
+      FT_ULong        count  = num_strikes;
 
 
-      if ( ACCESS_Frame( 48L * num_strikes ) )
+      if ( FT_FRAME_ENTER( 48L * num_strikes ) )
         goto Exit;
 
       while ( count > 0 )
       {
-        if ( READ_Fields( strike_start_fields, strike )             ||
-             READ_Fields( sbit_line_metrics_fields, &strike->hori ) ||
-             READ_Fields( sbit_line_metrics_fields, &strike->vert ) ||
-             READ_Fields( strike_end_fields, strike )               )
+        if ( FT_STREAM_READ_FIELDS( strike_start_fields, strike )             ||
+             FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->hori ) ||
+             FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->vert ) ||
+             FT_STREAM_READ_FIELDS( strike_end_fields, strike )               )
           break;
 
         count--;
         strike++;
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
     }
 
     /* allocate the index ranges for each strike table */
     {
-      TT_SBit_Strike*  strike = face->sbit_strikes;
-      FT_ULong         count  = num_strikes;
+      TT_SBit_Strike  strike = face->sbit_strikes;
+      FT_ULong        count  = num_strikes;
 
 
       while ( count > 0 )
       {
-        TT_SBit_Range*  range;
-        FT_ULong        count2 = strike->num_ranges;
+        TT_SBit_Range  range;
+        FT_ULong       count2 = strike->num_ranges;
 
 
-        if ( ALLOC_ARRAY( strike->sbit_ranges,
-                          strike->num_ranges,
-                          TT_SBit_Range ) )
+        if ( FT_NEW_ARRAY( strike->sbit_ranges, strike->num_ranges ) )
           goto Exit;
 
         /* read each range */
-        if ( FILE_Seek( table_base + strike->ranges_offset ) ||
-             ACCESS_Frame( strike->num_ranges * 8L )         )
+        if ( FT_STREAM_SEEK( table_base + strike->ranges_offset ) ||
+             FT_FRAME_ENTER( strike->num_ranges * 8L )            )
           goto Exit;
 
         range = strike->sbit_ranges;
         while ( count2 > 0 )
         {
-          range->first_glyph  = GET_UShort();
-          range->last_glyph   = GET_UShort();
-          range->table_offset = table_base + strike->ranges_offset
-                                 + GET_ULong();
+          range->first_glyph  = FT_GET_USHORT();
+          range->last_glyph   = FT_GET_USHORT();
+          range->table_offset = table_base + strike->ranges_offset +
+                                  FT_GET_ULONG();
           count2--;
           range++;
         }
 
-        FORGET_Frame();
+        FT_FRAME_EXIT();
 
         /* Now, read each index table */
         count2 = strike->num_ranges;
@@ -549,15 +546,15 @@
         while ( count2 > 0 )
         {
           /* Read the header */
-          if ( FILE_Seek( range->table_offset ) ||
-               ACCESS_Frame( 8L )               )
+          if ( FT_STREAM_SEEK( range->table_offset ) ||
+               FT_FRAME_ENTER( 8L )                  )
             goto Exit;
 
-          range->index_format = GET_UShort();
-          range->image_format = GET_UShort();
-          range->image_offset = GET_ULong();
+          range->index_format = FT_GET_USHORT();
+          range->image_format = FT_GET_USHORT();
+          range->image_offset = FT_GET_ULONG();
 
-          FORGET_Frame();
+          FT_FRAME_EXIT();
 
           error = Load_SBit_Range( range, stream );
           if ( error )
@@ -588,20 +585,20 @@
   /* <Input>                                                               */
   /*    face :: The target face object.                                    */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   TT_Free_SBit_Strikes( TT_Face  face )
   {
-    FT_Memory        memory       = face->root.memory;
-    TT_SBit_Strike*  strike       = face->sbit_strikes;
-    TT_SBit_Strike*  strike_limit = strike + face->num_sbit_strikes;
+    FT_Memory       memory       = face->root.memory;
+    TT_SBit_Strike  strike       = face->sbit_strikes;
+    TT_SBit_Strike  strike_limit = strike + face->num_sbit_strikes;
 
 
     if ( strike )
     {
       for ( ; strike < strike_limit; strike++ )
       {
-        TT_SBit_Range*  range       = strike->sbit_ranges;
-        TT_SBit_Range*  range_limit = range + strike->num_ranges;
+        TT_SBit_Range  range       = strike->sbit_ranges;
+        TT_SBit_Range  range_limit = range + strike->num_ranges;
 
 
         if ( range )
@@ -610,20 +607,20 @@
           {
             /* release the glyph offsets and codes tables */
             /* where appropriate                          */
-            FREE( range->glyph_offsets );
-            FREE( range->glyph_codes );
+            FT_FREE( range->glyph_offsets );
+            FT_FREE( range->glyph_codes );
           }
         }
-        FREE( strike->sbit_ranges );
+        FT_FREE( strike->sbit_ranges );
         strike->num_ranges = 0;
       }
-      FREE( face->sbit_strikes );
+      FT_FREE( face->sbit_strikes );
     }
     face->num_sbit_strikes = 0;
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Set_SBit_Strike( TT_Face    face,
                       FT_Int     x_ppem,
                       FT_Int     y_ppem,
@@ -638,8 +635,8 @@
 
     for ( i = 0; i < face->num_sbit_strikes; i++ )
     {
-      if ( ( face->sbit_strikes[i].y_ppem  == y_ppem )  &&
-           ( ( x_ppem == 0 ) ||
+      if ( ( face->sbit_strikes[i].y_ppem  == y_ppem )    &&
+           ( ( x_ppem == 0 )                            ||
              ( face->sbit_strikes[i].x_ppem == x_ppem ) ) )
       {
         *astrike_index = i;
@@ -675,11 +672,11 @@
   /*                                                                       */
   static FT_Error
   Find_SBit_Range( FT_UInt          glyph_index,
-                   TT_SBit_Strike*  strike,
-                   TT_SBit_Range**  arange,
-                   FT_ULong*        aglyph_offset )
+                   TT_SBit_Strike   strike,
+                   TT_SBit_Range   *arange,
+                   FT_ULong        *aglyph_offset )
   {
-    TT_SBit_Range  *range, *range_limit;
+    TT_SBit_RangeRec  *range, *range_limit;
 
 
     /* check whether the glyph index is within this strike's */
@@ -734,12 +731,12 @@
             }
           }
 
-          /* fall-through */
-          default:
-            goto Fail;
+        /* fall-through */
+        default:
+          goto Fail;
         }
 
-    Found:
+      Found:
         /* return successfully! */
         *arange  = range;
         return 0;
@@ -783,18 +780,18 @@
   /*    glyph.                                                             */
   /*                                                                       */
   static FT_Error
-  Find_SBit_Image( TT_Face           face,
-                   FT_UInt           glyph_index,
-                   FT_ULong          strike_index,
-                   TT_SBit_Range*   *arange,
-                   TT_SBit_Strike*  *astrike,
-                   FT_ULong         *aglyph_offset )
+  Find_SBit_Image( TT_Face          face,
+                   FT_UInt          glyph_index,
+                   FT_ULong         strike_index,
+                   TT_SBit_Range   *arange,
+                   TT_SBit_Strike  *astrike,
+                   FT_ULong        *aglyph_offset )
   {
-    FT_Error         error;
-    TT_SBit_Strike*  strike;
+    FT_Error        error;
+    TT_SBit_Strike  strike;
 
 
-    if ( !face->sbit_strikes                              ||
+    if ( !face->sbit_strikes                                ||
          ( face->num_sbit_strikes <= (FT_Int)strike_index ) )
       goto Fail;
 
@@ -847,9 +844,9 @@
   /*    function exit.                                                     */
   /*                                                                       */
   static FT_Error
-  Load_SBit_Metrics( FT_Stream         stream,
-                     TT_SBit_Range*    range,
-                     TT_SBit_Metrics*  metrics )
+  Load_SBit_Metrics( FT_Stream        stream,
+                     TT_SBit_Range    range,
+                     TT_SBit_Metrics  metrics )
   {
     FT_Error  error = SFNT_Err_Ok;
 
@@ -861,12 +858,12 @@
     case 8:
       /* variable small metrics */
       {
-        TT_SBit_Small_Metrics  smetrics;
+        TT_SBit_SmallMetricsRec  smetrics;
 
         const FT_Frame_Field  sbit_small_metrics_fields[] =
         {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  TT_SBit_Small_Metrics
+#define FT_STRUCTURE  TT_SBit_SmallMetricsRec
 
           FT_FRAME_START( 5 ),
             FT_FRAME_BYTE( height ),
@@ -879,7 +876,7 @@
 
 
         /* read small metrics */
-        if ( READ_Fields( sbit_small_metrics_fields, &smetrics ) )
+        if ( FT_STREAM_READ_FIELDS( sbit_small_metrics_fields, &smetrics ) )
           goto Exit;
 
         /* convert it to a big metrics */
@@ -901,7 +898,7 @@
     case 7:
     case 9:
       /* variable big metrics */
-      if ( READ_Fields( sbit_metrics_fields, metrics ) )
+      if ( FT_STREAM_READ_FIELDS( sbit_metrics_fields, metrics ) )
         goto Exit;
       break;
 
@@ -933,8 +930,8 @@
   /*    metrics :: The corresponding metrics structure.                    */
   /*                                                                       */
   static void
-  Crop_Bitmap( FT_Bitmap*        map,
-               TT_SBit_Metrics*  metrics )
+  Crop_Bitmap( FT_Bitmap*       map,
+               TT_SBit_Metrics  metrics )
   {
     /***********************************************************************/
     /*                                                                     */
@@ -993,8 +990,8 @@
       {
         line = (FT_Byte*)map->buffer;
 
-        MEM_Move( line, line + count * line_len,
-                  ( rows - count ) * line_len );
+        FT_MEM_MOVE( line, line + count * line_len,
+                     ( rows - count ) * line_len );
 
         metrics->height       = (FT_Byte)( metrics->height - count );
         metrics->horiBearingY = (FT_Char)( metrics->horiBearingY - count );
@@ -1124,13 +1121,13 @@
 
 
   static FT_Error
-  Load_SBit_Single( FT_Bitmap*        map,
-                    FT_Int            x_offset,
-                    FT_Int            y_offset,
-                    FT_Int            pix_bits,
-                    FT_UShort         image_format,
-                    TT_SBit_Metrics*  metrics,
-                    FT_Stream         stream )
+  Load_SBit_Single( FT_Bitmap*       map,
+                    FT_Int           x_offset,
+                    FT_Int           y_offset,
+                    FT_Int           pix_bits,
+                    FT_UShort        image_format,
+                    TT_SBit_Metrics  metrics,
+                    FT_Stream        stream )
   {
     FT_Error  error;
 
@@ -1145,11 +1142,11 @@
     }
 
     {
-      FT_Int  glyph_width  = metrics->width;
-      FT_Int  glyph_height = metrics->height;
-      FT_Int  glyph_size;
-      FT_Int  line_bits    = pix_bits * glyph_width;
-      FT_Bool pad_bytes    = 0;
+      FT_Int   glyph_width  = metrics->width;
+      FT_Int   glyph_height = metrics->height;
+      FT_Int   glyph_size;
+      FT_Int   line_bits    = pix_bits * glyph_width;
+      FT_Bool  pad_bytes    = 0;
 
 
       /* compute size of glyph image */
@@ -1163,10 +1160,17 @@
 
           switch ( pix_bits )
           {
-          case 1:  line_length = ( glyph_width + 7 ) >> 3;   break;
-          case 2:  line_length = ( glyph_width + 3 ) >> 2;   break;
-          case 4:  line_length = ( glyph_width + 1 ) >> 1;   break;
-          default: line_length =   glyph_width;
+          case 1:
+            line_length = ( glyph_width + 7 ) >> 3;
+            break;
+          case 2:
+            line_length = ( glyph_width + 3 ) >> 2;
+            break;
+          case 4:
+            line_length = ( glyph_width + 1 ) >> 1;
+            break;
+          default:
+            line_length =   glyph_width;
           }
 
           glyph_size = glyph_height * line_length;
@@ -1186,7 +1190,7 @@
       }
 
       /* Now read data and draw glyph into target pixmap       */
-      if ( ACCESS_Frame( glyph_size ) )
+      if ( FT_FRAME_ENTER( glyph_size ) )
         goto Exit;
 
       /* don't forget to multiply `x_offset' by `map->pix_bits' as */
@@ -1195,7 +1199,7 @@
       blit_sbit( map, (FT_Byte*)stream->cursor, line_bits, pad_bytes,
                  x_offset * pix_bits, y_offset );
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
     }
 
   Exit:
@@ -1204,22 +1208,22 @@
 
 
   static FT_Error
-  Load_SBit_Image( TT_SBit_Strike*   strike,
-                   TT_SBit_Range*    range,
-                   FT_ULong          ebdt_pos,
-                   FT_ULong          glyph_offset,
-                   FT_Bitmap*        map,
-                   FT_Int            x_offset,
-                   FT_Int            y_offset,
-                   FT_Stream         stream,
-                   TT_SBit_Metrics*  metrics )
+  Load_SBit_Image( TT_SBit_Strike   strike,
+                   TT_SBit_Range    range,
+                   FT_ULong         ebdt_pos,
+                   FT_ULong         glyph_offset,
+                   FT_Bitmap*       map,
+                   FT_Int           x_offset,
+                   FT_Int           y_offset,
+                   FT_Stream        stream,
+                   TT_SBit_Metrics  metrics )
   {
     FT_Memory  memory = stream->memory;
     FT_Error   error;
 
 
     /* place stream at beginning of glyph data and read metrics */
-    if ( FILE_Seek( ebdt_pos + glyph_offset ) )
+    if ( FT_STREAM_SEEK( ebdt_pos + glyph_offset ) )
       goto Exit;
 
     error = Load_SBit_Metrics( stream, range, metrics );
@@ -1270,7 +1274,7 @@
       if ( size == 0 )
         goto Exit;     /* exit successfully! */
 
-      if ( ALLOC( map->buffer, size ) )
+      if ( FT_ALLOC( map->buffer, size ) )
         goto Exit;
     }
 
@@ -1285,7 +1289,7 @@
                                range->image_format, metrics, stream );
 
     case 8:  /* compound format */
-      FT_Skip_Stream( stream, 1L );
+      FT_Stream_Skip( stream, 1L );
       /* fallthrough */
 
     case 9:
@@ -1298,37 +1302,37 @@
     /* All right, we have a compound format.  First of all, read */
     /* the array of elements.                                    */
     {
-      TT_SBit_Component*  components;
-      TT_SBit_Component*  comp;
-      FT_UShort           num_components, count;
+      TT_SBit_Component  components;
+      TT_SBit_Component  comp;
+      FT_UShort          num_components, count;
 
 
-      if ( READ_UShort( num_components )                                ||
-           ALLOC_ARRAY( components, num_components, TT_SBit_Component ) )
+      if ( FT_READ_USHORT( num_components )           ||
+           FT_NEW_ARRAY( components, num_components ) )
         goto Exit;
 
       count = num_components;
 
-      if ( ACCESS_Frame( 4L * num_components ) )
+      if ( FT_FRAME_ENTER( 4L * num_components ) )
         goto Fail_Memory;
 
       for ( comp = components; count > 0; count--, comp++ )
       {
-        comp->glyph_code = GET_UShort();
-        comp->x_offset   = GET_Char();
-        comp->y_offset   = GET_Char();
+        comp->glyph_code = FT_GET_USHORT();
+        comp->x_offset   = FT_GET_CHAR();
+        comp->y_offset   = FT_GET_CHAR();
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
 
       /* Now recursively load each element glyph */
       count = num_components;
       comp  = components;
       for ( ; count > 0; count--, comp++ )
       {
-        TT_SBit_Range*   elem_range;
-        TT_SBit_Metrics  elem_metrics;
-        FT_ULong         elem_offset;
+        TT_SBit_Range       elem_range;
+        TT_SBit_MetricsRec  elem_metrics;
+        FT_ULong            elem_offset;
 
 
         /* find the range for this element */
@@ -1354,7 +1358,7 @@
       }
 
     Fail_Memory:
-      FREE( components );
+      FT_FREE( components );
     }
 
   Exit:
@@ -1395,21 +1399,21 @@
   /*  <Note>                                                               */
   /*    The `map.buffer' field is always freed before the glyph is loaded. */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_Load_SBit_Image( TT_Face           face,
-                      FT_ULong          strike_index,
-                      FT_UInt           glyph_index,
-                      FT_UInt           load_flags,
-                      FT_Stream         stream,
-                      FT_Bitmap        *map,
-                      TT_SBit_Metrics  *metrics )
+  FT_LOCAL_DEF( FT_Error )
+  TT_Load_SBit_Image( TT_Face              face,
+                      FT_ULong             strike_index,
+                      FT_UInt              glyph_index,
+                      FT_UInt              load_flags,
+                      FT_Stream            stream,
+                      FT_Bitmap           *map,
+                      TT_SBit_MetricsRec  *metrics )
   {
-    FT_Error         error;
-    FT_Memory        memory = stream->memory;
-    FT_ULong         ebdt_pos, glyph_offset;
+    FT_Error        error;
+    FT_Memory       memory = stream->memory;
+    FT_ULong        ebdt_pos, glyph_offset;
 
-    TT_SBit_Strike*  strike;
-    TT_SBit_Range*   range;
+    TT_SBit_Strike  strike;
+    TT_SBit_Range   range;
 
 
     /* Check whether there is a glyph sbit for the current index */
@@ -1426,11 +1430,11 @@
     if (error)
       goto Exit;
 
-    ebdt_pos = FILE_Pos();
+    ebdt_pos = FT_STREAM_POS();
 
     /* clear the bitmap & load the bitmap */
-    if ( face->root.glyph->flags & ft_glyph_own_bitmap )
-      FREE( map->buffer );
+    if ( face->root.glyph->flags & FT_GLYPH_OWN_BITMAP )
+      FT_FREE( map->buffer );
 
     map->rows = map->pitch = map->width = 0;
 
@@ -1440,7 +1444,7 @@
       goto Exit;
 
     /* the glyph slot owns this bitmap buffer */
-    face->root.glyph->flags |= ft_glyph_own_bitmap;
+    face->root.glyph->flags |= FT_GLYPH_OWN_BITMAP;
 
     /* setup vertical metrics if needed */
     if ( strike->flags & 1 )
Index: xc/extras/freetype2/src/sfnt/ttsbit.h
diff -u xc/extras/freetype2/src/sfnt/ttsbit.h:1.1.1.3 xc/extras/freetype2/src/sfnt/ttsbit.h:1.1.1.4
--- xc/extras/freetype2/src/sfnt/ttsbit.h:1.1.1.3	Sun Dec 16 12:49:33 2001
+++ xc/extras/freetype2/src/sfnt/ttsbit.h	Thu Jun 20 04:16:23 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType and OpenType embedded bitmap support (specification).       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,28 +27,28 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_SBit_Strikes( TT_Face    face,
                         FT_Stream  stream );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   TT_Free_SBit_Strikes( TT_Face  face );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Set_SBit_Strike( TT_Face    face,
                       FT_Int     x_ppem,
                       FT_Int     y_ppem,
                       FT_ULong  *astrike_index );
 
-  FT_LOCAL FT_Error
-  TT_Load_SBit_Image( TT_Face           face,
-                      FT_ULong          strike_index,
-                      FT_UInt           glyph_index,
-                      FT_UInt           load_flags,
-                      FT_Stream         stream,
-                      FT_Bitmap        *map,
-                      TT_SBit_Metrics  *metrics );
+  FT_LOCAL( FT_Error )
+  TT_Load_SBit_Image( TT_Face              face,
+                      FT_ULong             strike_index,
+                      FT_UInt              glyph_index,
+                      FT_UInt              load_flags,
+                      FT_Stream            stream,
+                      FT_Bitmap           *map,
+                      TT_SBit_MetricsRec  *metrics );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/smooth/descrip.mms
diff -u xc/extras/freetype2/src/smooth/descrip.mms:1.1.1.1 xc/extras/freetype2/src/smooth/descrip.mms:1.1.1.2
--- xc/extras/freetype2/src/smooth/descrip.mms:1.1.1.1	Tue May 15 23:45:43 2001
+++ xc/extras/freetype2/src/smooth/descrip.mms	Thu Feb 14 19:33:38 2002
@@ -18,6 +18,6 @@
 OBJS=smooth.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/smooth/ftgrays.c
diff -u xc/extras/freetype2/src/smooth/ftgrays.c:1.1.1.5 xc/extras/freetype2/src/smooth/ftgrays.c:1.1.1.7
--- xc/extras/freetype2/src/smooth/ftgrays.c:1.1.1.5	Mon Jan 14 11:52:23 2002
+++ xc/extras/freetype2/src/smooth/ftgrays.c	Thu Jun 20 04:16:23 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    A new `perfect' anti-aliasing renderer (body).                       */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -17,73 +17,70 @@
 
   /*************************************************************************/
   /*                                                                       */
-  /*  This file can be compiled without the rest of the FreeType engine,   */
-  /*  by defining the _STANDALONE_ macro when compiling it.  You also need */
-  /*  to put the files `ftgrays.h' and `ftimage.h' into the current        */
-  /*  compilation directory.  Typically, you could do something like       */
+  /* This file can be compiled without the rest of the FreeType engine, by */
+  /* defining the _STANDALONE_ macro when compiling it.  You also need to  */
+  /* put the files `ftgrays.h' and `ftimage.h' into the current            */
+  /* compilation directory.  Typically, you could do something like        */
   /*                                                                       */
-  /*  - copy `src/base/ftgrays.c' to your current directory                */
+  /* - copy `src/base/ftgrays.c' to your current directory                 */
   /*                                                                       */
-  /*  - copy `include/freetype/ftimage.h' and                              */
-  /*    `include/freetype/ftgrays.h' to the same directory                 */
+  /* - copy `include/freetype/ftimage.h' and `include/freetype/ftgrays.h'  */
+  /*   to the same directory                                               */
   /*                                                                       */
-  /*  - compile `ftgrays' with the _STANDALONE_ macro defined, as in       */
+  /* - compile `ftgrays' with the _STANDALONE_ macro defined, as in        */
   /*                                                                       */
-  /*      cc -c -D_STANDALONE_ ftgrays.c                                   */
+  /*     cc -c -D_STANDALONE_ ftgrays.c                                    */
   /*                                                                       */
-  /*  The renderer can be initialized with a call to                       */
-  /*  `ft_gray_raster.gray_raster_new'; an anti-aliased bitmap can be      */
-  /*  generated with a call to `ft_gray_raster.gray_raster_render'.        */
+  /* The renderer can be initialized with a call to                        */
+  /* `ft_gray_raster.gray_raster_new'; an anti-aliased bitmap can be       */
+  /* generated with a call to `ft_gray_raster.gray_raster_render'.         */
   /*                                                                       */
-  /*  See the comments and documentation in the file `ftimage.h' for       */
-  /*  more details on how the raster works.                                */
+  /* See the comments and documentation in the file `ftimage.h' for more   */
+  /* details on how the raster works.                                      */
   /*                                                                       */
   /*************************************************************************/
 
   /*************************************************************************/
   /*                                                                       */
-  /*  This is a new anti-aliasing scan-converter for FreeType 2.  The      */
-  /*  algorithm used here is _very_ different from the one in the standard */
-  /*  `ftraster' module.  Actually, `ftgrays' computes the _exact_         */
-  /*  coverage of the outline on each pixel cell.                          */
-  /*                                                                       */
-  /*  It is based on ideas that I initially found in Raph Levien's         */
-  /*  excellent LibArt graphics library (see http://www.levien.com/libart  */
-  /*  for more information, though the web pages do not tell anything      */
-  /*  about the renderer; you'll have to dive into the source code to      */
-  /*  understand how it works).                                            */
-  /*                                                                       */
-  /*  Note, however, that this is a _very_ different implementation        */
-  /*  compared to Raph's.  Coverage information is stored in a very        */
-  /*  different way, and I don't use sorted vector paths.  Also, it        */
-  /*  doesn't use floating point values.                                   */
-  /*                                                                       */
-  /*  This renderer has the following advantages:                          */
-  /*                                                                       */
-  /*  - It doesn't need an intermediate bitmap.  Instead, one can supply   */
-  /*    a callback function that will be called by the renderer to draw    */
-  /*    gray spans on any target surface.  You can thus do direct          */
-  /*    composition on any kind of bitmap, provided that you give the      */
-  /*    renderer the right callback.                                       */
-  /*                                                                       */
-  /*  - A perfect anti-aliaser, i.e., it computes the _exact_ coverage on  */
-  /*    each pixel cell                                                    */
+  /* This is a new anti-aliasing scan-converter for FreeType 2.  The       */
+  /* algorithm used here is _very_ different from the one in the standard  */
+  /* `ftraster' module.  Actually, `ftgrays' computes the _exact_          */
+  /* coverage of the outline on each pixel cell.                           */
+  /*                                                                       */
+  /* It is based on ideas that I initially found in Raph Levien's          */
+  /* excellent LibArt graphics library (see http://www.levien.com/libart   */
+  /* for more information, though the web pages do not tell anything       */
+  /* about the renderer; you'll have to dive into the source code to       */
+  /* understand how it works).                                             */
+  /*                                                                       */
+  /* Note, however, that this is a _very_ different implementation         */
+  /* compared to Raph's.  Coverage information is stored in a very         */
+  /* different way, and I don't use sorted vector paths.  Also, it doesn't */
+  /* use floating point values.                                            */
+  /*                                                                       */
+  /* This renderer has the following advantages:                           */
+  /*                                                                       */
+  /* - It doesn't need an intermediate bitmap.  Instead, one can supply a  */
+  /*   callback function that will be called by the renderer to draw gray  */
+  /*   spans on any target surface.  You can thus do direct composition on */
+  /*   any kind of bitmap, provided that you give the renderer the right   */
+  /*   callback.                                                           */
+  /*                                                                       */
+  /* - A perfect anti-aliaser, i.e., it computes the _exact_ coverage on   */
+  /*   each pixel cell.                                                    */
   /*                                                                       */
-  /*  - It performs a single pass on the outline (the `standard' FT2       */
-  /*    renderer makes two passes).                                        */
+  /* - It performs a single pass on the outline (the `standard' FT2        */
+  /*   renderer makes two passes).                                         */
   /*                                                                       */
-  /*  - It can easily be modified to render to _any_ number of gray levels */
-  /*    cheaply.                                                           */
+  /* - It can easily be modified to render to _any_ number of gray levels  */
+  /*   cheaply.                                                            */
   /*                                                                       */
-  /*  - For small (< 20) pixel sizes, it is faster than the standard       */
-  /*    renderer.                                                          */
+  /* - For small (< 20) pixel sizes, it is faster than the standard        */
+  /*   renderer.                                                           */
   /*                                                                       */
   /*************************************************************************/
 
 
-#include <string.h>             /* for memcpy() */
-#include <setjmp.h>
-
 
 /* experimental support for gamma correction within the rasterizer */
 #define xxxGRAYS_USE_GAMMA
@@ -96,14 +93,24 @@
   /* messages during execution.                                            */
   /*                                                                       */
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_aaraster
+#define FT_COMPONENT  trace_smooth
 
 
 #define ErrRaster_MemoryOverflow   -4
 
+
 #ifdef _STANDALONE_
 
+#include <string.h>             /* for ft_memcpy() */
+#include <setjmp.h>
+#include <limits.h>
+#define FT_UINT_MAX  UINT_MAX
 
+#define  ft_setjmp   setjmp
+#define  ft_longjmp  longjmp
+#define  ft_jmp_buf  jmp_buf
+
+
 #define ErrRaster_Invalid_Mode     -2
 #define ErrRaster_Invalid_Outline  -1
 
@@ -145,8 +152,8 @@
 #endif /* _STANDALONE_ */
 
 
-#ifndef MEM_Set
-#define  MEM_Set( d, s, c )  memset( d, s, c )
+#ifndef FT_MEM_SET
+#define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
 #endif
 
   /* define this to dump debugging information */
@@ -203,7 +210,7 @@
   /* increases the number of cells available in the render pool but slows  */
   /* down the rendering a bit.  It is useful if you have a really tiny     */
   /* render pool.                                                          */
-#define xxxGRAYS_COMPACT
+#undef  GRAYS_COMPACT
 
 
   /*************************************************************************/
@@ -215,8 +222,8 @@
   /* need to define them to "float" or "double" when experimenting with   */
   /* new algorithms                                                       */
 
-  typedef int   TScan;   /* integer scanline/pixel coordinate */
-  typedef long  TPos;    /* sub-pixel coordinate              */
+  typedef int   TCoord;   /* integer scanline/pixel coordinate */
+  typedef long  TPos;     /* sub-pixel coordinate              */
 
   /* determine the type used to store cell areas.  This normally takes at */
   /* least PIXEL_BYTES*2 + 1.  On 16-bit systems, we need to use `long'   */
@@ -229,9 +236,7 @@
 #else /* PIXEL_BITS >= 8 */
 
   /* approximately determine the size of integers using an ANSI-C header */
-#include <limits.h>
-
-#if UINT_MAX == 0xFFFFU
+#if FT_UINT_MAX == 0xFFFFU
   typedef long  TArea;
 #else
   typedef int  TArea;
@@ -259,10 +264,10 @@
 
   typedef struct  TCell_
   {
-    TScan  x;
-    TScan  y;
-    int    cover;
-    TArea  area;
+    TCoord  x;
+    TCoord  y;
+    int     cover;
+    TArea   area;
 
   } TCell, *PCell;
 
@@ -271,22 +276,22 @@
 
   typedef struct  TRaster_
   {
-    PCell  cells;
-    int    max_cells;
-    int    num_cells;
-
-    TScan  min_ex, max_ex;
-    TScan  min_ey, max_ey;
-
-    TArea  area;
-    int    cover;
-    int    invalid;
-
-    TScan  ex, ey;
-    TScan  cx, cy;
-    TPos   x,  y;
+    PCell   cells;
+    int     max_cells;
+    int     num_cells;
+
+    TCoord  min_ex, max_ex;
+    TCoord  min_ey, max_ey;
+
+    TArea   area;
+    int     cover;
+    int     invalid;
+
+    TCoord  ex, ey;
+    TCoord  cx, cy;
+    TPos    x,  y;
 
-    TScan  last_ey;
+    TCoord  last_ey;
 
     FT_Vector   bez_stack[32 * 3 + 1];
     int         lev_stack[32];
@@ -307,8 +312,8 @@
     int  conic_level;
     int  cubic_level;
 
-    void*    memory;
-    jmp_buf  jump_buffer;
+    void*       memory;
+    ft_jmp_buf  jump_buffer;
 
 #ifdef GRAYS_USE_GAMMA
     FT_Byte  gamma[257];
@@ -391,7 +396,7 @@
     if ( !ras.invalid && ( ras.area | ras.cover ) )
     {
       if ( ras.num_cells >= ras.max_cells )
-        longjmp( ras.jump_buffer, 1 );
+        ft_longjmp( ras.jump_buffer, 1 );
 
       cell        = ras.cells + ras.num_cells++;
       cell->x     = ras.ex - ras.min_ex;
@@ -407,8 +412,8 @@
   /* Set the current cell to a new position.                               */
   /*                                                                       */
   static void
-  gray_set_cell( RAS_ARG_ TScan  ex,
-                          TScan  ey )
+  gray_set_cell( RAS_ARG_ TCoord  ex,
+                          TCoord  ey )
   {
     int  invalid, record, clean;
 
@@ -464,8 +469,8 @@
   /* Start a new contour at a given cell.                                  */
   /*                                                                       */
   static void
-  gray_start_cell( RAS_ARG_  TScan  ex,
-                             TScan  ey )
+  gray_start_cell( RAS_ARG_  TCoord  ex,
+                             TCoord  ey )
   {
     if ( ex < ras.min_ex )
       ex = ras.min_ex - 1;
@@ -486,15 +491,15 @@
   /* Render a scanline as one or more cells.                               */
   /*                                                                       */
   static void
-  gray_render_scanline( RAS_ARG_  TScan  ey,
-                                  TPos   x1,
-                                  TScan  y1,
-                                  TPos   x2,
-                                  TScan  y2 )
-  {
-    TScan  ex1, ex2, fx1, fx2, delta;
-    long   p, first, dx;
-    int    incr, lift, mod, rem;
+  gray_render_scanline( RAS_ARG_  TCoord  ey,
+                                  TPos    x1,
+                                  TCoord  y1,
+                                  TPos    x2,
+                                  TCoord  y2 )
+  {
+    TCoord  ex1, ex2, fx1, fx2, delta;
+    long    p, first, dx;
+    int     incr, lift, mod, rem;
 
 
     dx = x2 - x1;
@@ -553,7 +558,7 @@
 
     if ( ex1 != ex2 )
     {
-      p     = ONE_PIXEL * ( y2 - y1 );
+      p     = ONE_PIXEL * ( y2 - y1 + delta );
       lift  = p / dx;
       rem   = p % dx;
       if ( rem < 0 )
@@ -596,9 +601,9 @@
   gray_render_line( RAS_ARG_ TPos  to_x,
                              TPos  to_y )
   {
-    TScan  ey1, ey2, fy1, fy2;
-    TPos   dx, dy, x, x2;
-    int    p, rem, mod, lift, delta, first, incr;
+    TCoord  ey1, ey2, fy1, fy2;
+    TPos    dx, dy, x, x2;
+    int     p, rem, mod, lift, delta, first, incr;
 
 
     ey1 = TRUNC( ras.last_ey );
@@ -614,7 +619,7 @@
 
     /* perform vertical clipping */
     {
-      TScan  min, max;
+      TCoord  min, max;
 
 
       min = ey1;
@@ -635,6 +640,46 @@
       goto End;
     }
 
+    /* vertical line - avoid calling gray_render_scanline */
+    incr = 1;
+
+    if ( dx == 0 )
+    {
+      TCoord  ex     = TRUNC( ras.x );
+      TCoord  two_fx = ( ras.x - SUBPIXELS( ex ) ) << 1;
+      TPos    area;
+
+
+      first = ONE_PIXEL;
+      if ( dy < 0 )
+      {
+        first = 0;
+        incr  = -1;
+      }
+
+      delta      = first - fy1;
+      ras.area  += (TArea)two_fx * delta;
+      ras.cover += delta;
+      ey1       += incr;
+
+      gray_set_cell( raster, ex, ey1 );
+
+      delta = first + first - ONE_PIXEL;
+      area  = (TArea)two_fx * delta;
+      while( ey1 != ey2 )
+      {
+        ras.area  += area;
+        ras.cover += delta;
+        ey1       += incr;
+        gray_set_cell( raster, ex, ey1 );
+      }
+
+      delta      = fy2 - ONE_PIXEL + first;
+      ras.area  += (TArea)two_fx * delta;
+      ras.cover += delta;
+      goto End;
+    }
+
     /* ok, we have to render several scanlines */
     p     = ( ONE_PIXEL - fy1 ) * dx;
     first = ONE_PIXEL;
@@ -1248,7 +1293,7 @@
 
       if ( coverage )
 #if 1
-        MEM_Set( p + spans->x, (unsigned char)coverage, spans->len );
+        FT_MEM_SET( p + spans->x, (unsigned char)coverage, spans->len );
 #else /* 1 */
       {
         q     = p + spans->x;
@@ -1292,10 +1337,10 @@
 
 
   static void
-  gray_hline( RAS_ARG_ TScan  x,
-                       TScan  y,
-                       TPos   area,
-                       int    acount )
+  gray_hline( RAS_ARG_ TCoord  x,
+                       TCoord  y,
+                       TPos    area,
+                       int     acount )
   {
     FT_Span*   span;
     int        count;
@@ -1309,13 +1354,12 @@
     /*                                                           */
     coverage = area >> ( PIXEL_BITS * 2 + 1 - 8);  /* use range 0..256 */
 
+    if ( coverage < 0 )
+      coverage = -coverage;
+
     if ( ras.outline.flags & ft_outline_even_odd_fill )
     {
-      if ( coverage < 0 )
-        coverage = -coverage;
-
-      while ( coverage >= 512 )
-        coverage -= 512;
+      coverage &= 511;
 
       if ( coverage > 256 )
         coverage = 512 - coverage;
@@ -1325,13 +1369,11 @@
     else
     {
       /* normal non-zero winding rule */
-      if ( coverage < 0 )
-        coverage = -coverage;
-
       if ( coverage >= 256 )
         coverage = 255;
     }
 
+
     y += ras.min_ey;
     x += ras.min_ex;
 
@@ -1394,12 +1436,13 @@
   static void
   gray_sweep( RAS_ARG_ FT_Bitmap*  target )
   {
-    TScan  x, y, cover;
-    TArea  area;
-    PCell  start, cur, limit;
+    TCoord  x, y, cover;
+    TArea   area;
+    PCell   start, cur, limit;
 
     FT_UNUSED( target );
 
+
     if ( ras.num_cells == 0 )
       return;
 
@@ -1507,21 +1550,23 @@
   /*    of new contours in the outline.                                    */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    outline   :: A pointer to the source target.                       */
-  /*                                                                       */
-  /*    interface :: A table of `emitters', i.e,. function pointers called */
-  /*                 during decomposition to indicate path operations.     */
+  /*    outline        :: A pointer to the source target.                  */
   /*                                                                       */
-  /*    user      :: A typeless pointer which is passed to each emitter    */
-  /*                 during the decomposition.  It can be used to store    */
-  /*                 the state during the decomposition.                   */
+  /*    func_interface :: A table of `emitters', i.e,. function pointers   */
+  /*                      called during decomposition to indicate path     */
+  /*                      operations.                                      */
+  /*                                                                       */
+  /*    user           :: A typeless pointer which is passed to each       */
+  /*                      emitter during the decomposition.  It can be     */
+  /*                      used to store the state during the               */
+  /*                      decomposition.                                   */
   /*                                                                       */
   /* <Return>                                                              */
   /*    Error code.  0 means sucess.                                       */
   /*                                                                       */
   static
   int  FT_Outline_Decompose( FT_Outline*              outline,
-                             const FT_Outline_Funcs*  interface,
+                             const FT_Outline_Funcs*  func_interface,
                              void*                    user )
   {
 #undef SCALED
@@ -1545,8 +1590,8 @@
     char    tag;       /* current point's state           */
 
 #if 0
-    int     shift = interface->shift;
-    FT_Pos  delta = interface->delta;
+    int     shift = func_interface->shift;
+    FT_Pos  delta = func_interface->delta;
 #endif
 
 
@@ -1600,7 +1645,7 @@
         tags--;
       }
 
-      error = interface->move_to( &v_start, user );
+      error = func_interface->move_to( &v_start, user );
       if ( error )
         goto Exit;
 
@@ -1620,7 +1665,7 @@
             vec.x = SCALED( point->x );
             vec.y = SCALED( point->y );
 
-            error = interface->line_to( &vec, user );
+            error = func_interface->line_to( &vec, user );
             if ( error )
               goto Exit;
             continue;
@@ -1647,7 +1692,7 @@
 
               if ( tag == FT_Curve_Tag_On )
               {
-                error = interface->conic_to( &v_control, &vec, user );
+                error = func_interface->conic_to( &v_control, &vec, user );
                 if ( error )
                   goto Exit;
                 continue;
@@ -1659,7 +1704,7 @@
               v_middle.x = ( v_control.x + vec.x ) / 2;
               v_middle.y = ( v_control.y + vec.y ) / 2;
 
-              error = interface->conic_to( &v_control, &v_middle, user );
+              error = func_interface->conic_to( &v_control, &v_middle, user );
               if ( error )
                 goto Exit;
 
@@ -1667,7 +1712,7 @@
               goto Do_Conic;
             }
 
-            error = interface->conic_to( &v_control, &v_start, user );
+            error = func_interface->conic_to( &v_control, &v_start, user );
             goto Close;
           }
 
@@ -1694,20 +1739,20 @@
               vec.x = SCALED( point->x );
               vec.y = SCALED( point->y );
 
-              error = interface->cubic_to( &vec1, &vec2, &vec, user );
+              error = func_interface->cubic_to( &vec1, &vec2, &vec, user );
               if ( error )
                 goto Exit;
               continue;
             }
 
-            error = interface->cubic_to( &vec1, &vec2, &v_start, user );
+            error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );
             goto Close;
           }
         }
       }
 
       /* close the contour with a line segment */
-      error = interface->line_to( &v_start, user );
+      error = func_interface->line_to( &v_start, user );
 
    Close:
       if ( error )
@@ -1739,7 +1784,7 @@
   gray_convert_glyph_inner( RAS_ARG )
   {
     static
-    const FT_Outline_Funcs  interface =
+    const FT_Outline_Funcs  func_interface =
     {
       (FT_Outline_MoveTo_Func) gray_move_to,
       (FT_Outline_LineTo_Func) gray_line_to,
@@ -1751,9 +1796,9 @@
 
     volatile int  error = 0;
 
-    if ( setjmp( ras.jump_buffer ) == 0 )
+    if ( ft_setjmp( ras.jump_buffer ) == 0 )
     {
-      error = FT_Outline_Decompose( &ras.outline, &interface, &ras );
+      error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
       gray_record_cell( RAS_VAR );
     }
     else
@@ -1844,7 +1889,7 @@
 #if 1
         error = gray_convert_glyph_inner( RAS_VAR );
 #else
-        error = FT_Outline_Decompose( outline, &interface, &ras ) ||
+        error = FT_Outline_Decompose( outline, &func_interface, &ras ) ||
                 gray_record_cell( RAS_VAR );
 #endif
 
@@ -2017,7 +2062,7 @@
 
 
     *araster = (FT_Raster)&the_raster;
-    MEM_Set( &the_raster, 0, sizeof ( the_raster ) );
+    FT_MEM_SET( &the_raster, 0, sizeof ( the_raster ) );
 
 #ifdef GRAYS_USE_GAMMA
     grays_init_gamma( (PRaster)*araster );
@@ -2045,7 +2090,7 @@
 
 
     *araster = 0;
-    if ( !ALLOC( raster, sizeof ( TRaster ) ) )
+    if ( !FT_ALLOC( raster, sizeof ( TRaster ) ) )
     {
       raster->memory = memory;
       *araster = (FT_Raster)raster;
@@ -2065,7 +2110,7 @@
     FT_Memory  memory = (FT_Memory)((PRaster)raster)->memory;
 
 
-    FREE( raster );
+    FT_FREE( raster );
   }
 
 #endif /* _STANDALONE_ */
@@ -2090,11 +2135,11 @@
   {
     ft_glyph_format_outline,
 
-    (FT_Raster_New_Func)      gray_raster_new,
-    (FT_Raster_Reset_Func)    gray_raster_reset,
-    (FT_Raster_Set_Mode_Func) 0,
-    (FT_Raster_Render_Func)   gray_raster_render,
-    (FT_Raster_Done_Func)     gray_raster_done
+    (FT_Raster_New_Func)     gray_raster_new,
+    (FT_Raster_Reset_Func)   gray_raster_reset,
+    (FT_Raster_Set_Mode_Func)0,
+    (FT_Raster_Render_Func)  gray_raster_render,
+    (FT_Raster_Done_Func)    gray_raster_done
   };
 
 
Index: xc/extras/freetype2/src/smooth/ftsmooth.c
diff -u xc/extras/freetype2/src/smooth/ftsmooth.c:1.1.1.5 xc/extras/freetype2/src/smooth/ftsmooth.c:1.1.1.6
--- xc/extras/freetype2/src/smooth/ftsmooth.c:1.1.1.5	Mon Jan 14 11:52:23 2002
+++ xc/extras/freetype2/src/smooth/ftsmooth.c	Thu Jun 20 04:16:23 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Anti-aliasing renderer interface (body).                             */
 /*                                                                         */
-/*  Copyright 2000-2001 by                                                 */
+/*  Copyright 2000-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -85,7 +85,7 @@
                       FT_GlyphSlot  slot,
                       FT_BBox*      cbox )
   {
-    MEM_Set( cbox, 0, sizeof ( *cbox ) );
+    FT_MEM_SET( cbox, 0, sizeof ( *cbox ) );
 
     if ( slot->format == render->glyph_format )
       FT_Outline_Get_CBox( &slot->outline, cbox );
@@ -140,10 +140,10 @@
     memory = render->root.memory;
 
     /* release old bitmap buffer */
-    if ( slot->flags & ft_glyph_own_bitmap )
+    if ( slot->flags & FT_GLYPH_OWN_BITMAP )
     {
-      FREE( bitmap->buffer );
-      slot->flags &= ~ft_glyph_own_bitmap;
+      FT_FREE( bitmap->buffer );
+      slot->flags &= ~FT_GLYPH_OWN_BITMAP;
     }
 
     /* allocate new one, depends on pixel format */
@@ -154,10 +154,10 @@
     bitmap->rows       = height;
     bitmap->pitch      = pitch;
 
-    if ( ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
+    if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
       goto Exit;
 
-    slot->flags |= ft_glyph_own_bitmap;
+    slot->flags |= FT_GLYPH_OWN_BITMAP;
 
     /* translate outline to render it into the bitmap */
     FT_Outline_Translate( outline, -cbox.xMin, -cbox.yMin );
Index: xc/extras/freetype2/src/smooth/rules.mk
diff -u xc/extras/freetype2/src/smooth/rules.mk:1.1.1.3 xc/extras/freetype2/src/smooth/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/smooth/rules.mk:1.1.1.3	Sun Sep  9 22:56:08 2001
+++ xc/extras/freetype2/src/smooth/rules.mk	Thu Jun 20 04:16:23 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/tools/cordic.py
diff -u xc/extras/freetype2/src/tools/cordic.py:1.2 xc/extras/freetype2/src/tools/cordic.py:1.3
--- xc/extras/freetype2/src/tools/cordic.py:1.2	Sat Oct 27 23:32:21 2001
+++ xc/extras/freetype2/src/tools/cordic.py	Thu Jun 20 04:25:28 2002
@@ -1,4 +1,3 @@
-# $XFree86: xc/extras/freetype2/src/tools/cordic.py,v 1.2 2001/10/28 03:32:21 tsi Exp $
 # compute arctangent table for CORDIC computations in fttrigon.c
 import sys, math
 
@@ -76,4 +75,4 @@
 print "shrink factor 2  = " + repr( shrink * (2.0**32) )
 print "expansion factor = " + repr(1/shrink)
 print ""
-
+   
\ No newline at end of file
Index: xc/extras/freetype2/src/truetype/descrip.mms
diff -u xc/extras/freetype2/src/truetype/descrip.mms:1.1.1.1 xc/extras/freetype2/src/truetype/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/truetype/descrip.mms:1.1.1.1	Tue May 15 23:45:40 2001
+++ xc/extras/freetype2/src/truetype/descrip.mms	Thu Jun 20 04:16:24 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,6 @@
 OBJS=truetype.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/truetype/rules.mk
diff -u xc/extras/freetype2/src/truetype/rules.mk:1.1.1.3 xc/extras/freetype2/src/truetype/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/truetype/rules.mk:1.1.1.3	Sun Sep  9 22:56:09 2001
+++ xc/extras/freetype2/src/truetype/rules.mk	Thu Jun 20 04:16:24 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/truetype/ttdriver.c
diff -u xc/extras/freetype2/src/truetype/ttdriver.c:1.1.1.5 xc/extras/freetype2/src/truetype/ttdriver.c:1.1.1.7
--- xc/extras/freetype2/src/truetype/ttdriver.c:1.1.1.5	Mon Jan 14 11:52:24 2002
+++ xc/extras/freetype2/src/truetype/ttdriver.c	Thu Jun 20 04:16:24 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType font driver implementation (body).                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -94,7 +94,7 @@
                FT_UInt     right_glyph,
                FT_Vector*  kerning )
   {
-    TT_Kern_0_Pair*  pair;
+    TT_Kern0_Pair  pair;
 
 
     if ( !face )
@@ -222,7 +222,7 @@
     size->strike_index    = 0xFFFF;
 #endif
 
-    return TT_Reset_Size( size );
+    return TT_Size_Reset( size );
   }
 
 
@@ -261,7 +261,7 @@
     size->strike_index    = 0xFFFF;
 #endif
 
-    return TT_Reset_Size( size );
+    return TT_Size_Reset( size );
   }
 
 
@@ -319,7 +319,7 @@
 
       if ( !size->ttmetrics.valid )
       {
-        if ( FT_SET_ERROR( TT_Reset_Size( size ) ) )
+        if ( FT_SET_ERROR( TT_Size_Reset( size ) ) )
           return error;
       }
     }
@@ -365,9 +365,9 @@
   Get_Char_Index( TT_CharMap  charmap,
                   FT_Long     charcode )
   {
-    FT_Error       error;
-    TT_Face        face;
-    TT_CMapTable*  cmap;
+    FT_Error      error;
+    TT_Face       face;
+    TT_CMapTable  cmap;
 
 
     cmap = &charmap->cmap;
@@ -376,7 +376,7 @@
     /* Load table if needed */
     if ( !cmap->loaded )
     {
-      SFNT_Interface*  sfnt = (SFNT_Interface*)face->sfnt;
+      SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
 
 
       error = sfnt->load_charmap( face, cmap, face->root.stream );
@@ -394,6 +394,53 @@
 
 
   /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Next_Char                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return the next encoded char.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next char code.  0 means `no more encoded characters'.             */
+  /*                                                                       */
+  static FT_UInt
+  Get_Next_Char( TT_CharMap  charmap,
+                 FT_Long     charcode )
+  {
+    FT_Error      error;
+    TT_Face       face;
+    TT_CMapTable  cmap;
+
+
+    cmap = &charmap->cmap;
+    face = (TT_Face)charmap->root.face;
+
+    /* Load table if needed */
+    if ( !cmap->loaded )
+    {
+      SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
+
+
+      error = sfnt->load_charmap( face, cmap, face->root.stream );
+      if ( error )
+        return 0;
+
+      cmap->loaded = TRUE;
+    }
+
+    if ( cmap->get_next_char )
+      return cmap->get_next_char ( cmap, charcode );
+    else
+      return 0;
+  }
+
+
+  /*************************************************************************/
   /*************************************************************************/
   /*************************************************************************/
   /****                                                                 ****/
@@ -408,19 +455,19 @@
 
   static FT_Module_Interface
   tt_get_interface( TT_Driver    driver,
-                    const char*  interface )
+                    const char*  tt_interface )
   {
-    FT_Module        sfntd = FT_Get_Module( driver->root.root.library,
-                                            "sfnt" );
-    SFNT_Interface*  sfnt;
+    FT_Module     sfntd = FT_Get_Module( driver->root.root.library,
+                                         "sfnt" );
+    SFNT_Service  sfnt;
 
 
     /* only return the default interface from the SFNT module */
     if ( sfntd )
     {
-      sfnt = (SFNT_Interface*)( sfntd->clazz->module_interface );
+      sfnt = (SFNT_Service)( sfntd->clazz->module_interface );
       if ( sfnt )
-        return sfnt->get_interface( FT_MODULE( driver ), interface );
+        return sfnt->get_interface( FT_MODULE( driver ), tt_interface );
     }
 
     return 0;
@@ -430,7 +477,7 @@
   /* The FT_DriverInterface structure is defined in ftdriver.h. */
 
   FT_CALLBACK_TABLE_DEF
-  const FT_Driver_Class  tt_driver_class =
+  const FT_Driver_ClassRec  tt_driver_class =
   {
     {
       ft_module_font_driver     |
@@ -449,8 +496,8 @@
 
       (void*)0,        /* driver specific interface */
 
-      (FT_Module_Constructor)TT_Init_Driver,
-      (FT_Module_Destructor) TT_Done_Driver,
+      (FT_Module_Constructor)TT_Driver_Init,
+      (FT_Module_Destructor) TT_Driver_Done,
       (FT_Module_Requester)  tt_get_interface,
     },
 
@@ -459,54 +506,24 @@
     sizeof ( FT_GlyphSlotRec ),
 
 
-    (FTDriver_initFace)     TT_Init_Face,
-    (FTDriver_doneFace)     TT_Done_Face,
-    (FTDriver_initSize)     TT_Init_Size,
-    (FTDriver_doneSize)     TT_Done_Size,
-    (FTDriver_initGlyphSlot)0,
-    (FTDriver_doneGlyphSlot)0,
-
-    (FTDriver_setCharSizes) Set_Char_Sizes,
-    (FTDriver_setPixelSizes)Set_Pixel_Sizes,
-    (FTDriver_loadGlyph)    Load_Glyph,
-    (FTDriver_getCharIndex) Get_Char_Index,
-
-    (FTDriver_getKerning)   Get_Kerning,
-    (FTDriver_attachFile)   0,
-    (FTDriver_getAdvances)  0
+    (FT_Face_InitFunc)        TT_Face_Init,
+    (FT_Face_DoneFunc)        TT_Face_Done,
+    (FT_Size_InitFunc)        TT_Size_Init,
+    (FT_Size_DoneFunc)        TT_Size_Done,
+    (FT_Slot_InitFunc)        0,
+    (FT_Slot_DoneFunc)        0,
+
+    (FT_Size_ResetPointsFunc) Set_Char_Sizes,
+    (FT_Size_ResetPixelsFunc) Set_Pixel_Sizes,
+    (FT_Slot_LoadFunc)        Load_Glyph,
+    (FT_CharMap_CharIndexFunc)Get_Char_Index,
+
+    (FT_Face_GetKerningFunc)  Get_Kerning,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0,
+    
+    (FT_CharMap_CharNextFunc) Get_Next_Char
   };
-
-
-#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    getDriverClass                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    This function is used when compiling the TrueType driver as a      */
-  /*    shared library (`.DLL' or `.so').  It will be used by the          */
-  /*    high-level library of FreeType to retrieve the address of the      */
-  /*    driver's generic interface.                                        */
-  /*                                                                       */
-  /*    It shouldn't be implemented in a static build, as each driver must */
-  /*    have the same function as an exported entry point.                 */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The address of the TrueType's driver generic interface.  The       */
-  /*    format-specific interface can then be retrieved through the method */
-  /*    interface->get_format_interface.                                   */
-  /*                                                                       */
-  FT_EXPORT_DEF( const FT_Driver_Class* )
-  getDriverClass( void )
-  {
-    return &tt_driver_class;
-  }
-
-
-#endif /* CONFIG_OPTION_DYNAMIC_DRIVERS */
 
 
 /* END */
Index: xc/extras/freetype2/src/truetype/ttdriver.c.save
diff -u /dev/null xc/extras/freetype2/src/truetype/ttdriver.c.save:1.2
--- /dev/null	Thu Feb 27 12:20:50 2003
+++ xc/extras/freetype2/src/truetype/ttdriver.c.save	Fri Oct 25 11:01:05 2002
@@ -0,0 +1,560 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttdriver.c                                                             */
+/*                                                                         */
+/*    TrueType font driver implementation (body).                          */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_SFNT_H
+#include FT_TRUETYPE_IDS_H
+
+#include "ttdriver.h"
+#include "ttgload.h"
+
+#include "tterrors.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_ttdriver
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                          F A C E S                              ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#undef  PAIR_TAG
+#define PAIR_TAG( left, right )  ( ( (FT_ULong)left << 16 ) | \
+                                     (FT_ULong)right        )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Kerning                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to return the kerning vector between two      */
+  /*    glyphs of the same face.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to the source face object.                 */
+  /*                                                                       */
+  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
+  /*                                                                       */
+  /*    right_glyph :: The index of the right glyph in the kern pair.      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    kerning     :: The kerning vector.  This is in font units for      */
+  /*                   scalable formats, and in pixels for fixed-sizes     */
+  /*                   formats.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
+  /*    supported by this function.  Other layouts, or more sophisticated  */
+  /*    kernings, are out of scope of this method (the basic driver        */
+  /*    interface is meant to be simple).                                  */
+  /*                                                                       */
+  /*    They can be implemented by format-specific interfaces.             */
+  /*                                                                       */
+  static FT_Error
+  Get_Kerning( TT_Face     face,
+               FT_UInt     left_glyph,
+               FT_UInt     right_glyph,
+               FT_Vector*  kerning )
+  {
+    TT_Kern_0_Pair*  pair;
+
+
+    if ( !face )
+      return TT_Err_Invalid_Face_Handle;
+
+    kerning->x = 0;
+    kerning->y = 0;
+
+    if ( face->kern_pairs )
+    {
+      /* there are some kerning pairs in this font file! */
+      FT_ULong  search_tag = PAIR_TAG( left_glyph, right_glyph );
+      FT_Long   left, right;
+
+
+      left  = 0;
+      right = face->num_kern_pairs - 1;
+
+      while ( left <= right )
+      {
+        FT_Int    middle = left + ( ( right - left ) >> 1 );
+        FT_ULong  cur_pair;
+
+
+        pair     = face->kern_pairs + middle;
+        cur_pair = PAIR_TAG( pair->left, pair->right );
+
+        if ( cur_pair == search_tag )
+          goto Found;
+
+        if ( cur_pair < search_tag )
+          left = middle + 1;
+        else
+          right = middle - 1;
+      }
+    }
+
+  Exit:
+    return TT_Err_Ok;
+
+  Found:
+    kerning->x = pair->value;
+    goto Exit;
+  }
+
+
+#undef PAIR_TAG
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                           S I Z E S                             ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Set_Char_Sizes                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to reset a size's character sizes (horizontal */
+  /*    and vertical) expressed in fractional points.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    char_width      :: The character width expressed in 26.6           */
+  /*                       fractional points.                              */
+  /*                                                                       */
+  /*    char_height     :: The character height expressed in 26.6          */
+  /*                       fractional points.                              */
+  /*                                                                       */
+  /*    horz_resolution :: The horizontal resolution of the output device. */
+  /*                                                                       */
+  /*    vert_resolution :: The vertical resolution of the output device.   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size            :: A handle to the target size object.             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Set_Char_Sizes( TT_Size     size,
+                  FT_F26Dot6  char_width,
+                  FT_F26Dot6  char_height,
+                  FT_UInt     horz_resolution,
+                  FT_UInt     vert_resolution )
+  {
+    FT_Size_Metrics*  metrics = &size->root.metrics;
+    TT_Face           face    = (TT_Face)size->root.face;
+    FT_Long           dim_x, dim_y;
+
+
+    /* This bit flag, when set, indicates that the pixel size must be */
+    /* truncated to an integer.  Nearly all TrueType fonts have this  */
+    /* bit set, as hinting won't work really well otherwise.          */
+    /*                                                                */
+    /* However, for those rare fonts who do not set it, we override   */
+    /* the default computations performed by the base layer.  I       */
+    /* really don't know whether this is useful, but hey, that's the  */
+    /* spec :-)                                                       */
+    /*                                                                */
+    if ( ( face->header.Flags & 8 ) == 0 )
+    {
+      /* Compute pixel sizes in 26.6 units */
+      dim_x = ( char_width  * horz_resolution + 36 ) / 72;
+      dim_y = ( char_height * vert_resolution + 36 ) / 72;
+
+      metrics->x_scale = FT_DivFix( dim_x, face->root.units_per_EM );
+      metrics->y_scale = FT_DivFix( dim_y, face->root.units_per_EM );
+
+      metrics->x_ppem  = (FT_UShort)( dim_x >> 6 );
+      metrics->y_ppem  = (FT_UShort)( dim_y >> 6 );
+    }
+
+    size->ttmetrics.valid = FALSE;
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+    size->strike_index    = 0xFFFF;
+#endif
+
+    return TT_Reset_Size( size );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Set_Pixel_Sizes                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to reset a size's character sizes (horizontal */
+  /*    and vertical) expressed in integer pixels.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    pixel_width  :: The character width expressed in integer pixels.   */
+  /*                                                                       */
+  /*    pixel_height :: The character height expressed in integer pixels.  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size         :: A handle to the target size object.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Set_Pixel_Sizes( TT_Size  size,
+                   FT_UInt  pixel_width,
+                   FT_UInt  pixel_height )
+  {
+    FT_UNUSED( pixel_width );
+    FT_UNUSED( pixel_height );
+
+    /* many things have been pre-computed by the base layer */
+
+    size->ttmetrics.valid = FALSE;
+#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+    size->strike_index    = 0xFFFF;
+#endif
+
+    return TT_Reset_Size( size );
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Load_Glyph                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to load a glyph within a given glyph slot.    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    slot        :: A handle to the target slot object where the glyph  */
+  /*                   will be loaded.                                     */
+  /*                                                                       */
+  /*    size        :: A handle to the source face size at which the glyph */
+  /*                   must be scaled, loaded, etc.                        */
+  /*                                                                       */
+  /*    glyph_index :: The index of the glyph in the font file.            */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   FTLOAD_??? constants can be used to control the     */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  static FT_Error
+  Load_Glyph( TT_GlyphSlot  slot,
+              TT_Size       size,
+              FT_UShort     glyph_index,
+              FT_UInt       load_flags )
+  {
+    FT_Error  error;
+
+
+    if ( !slot )
+      return TT_Err_Invalid_Slot_Handle;
+
+    /* check whether we want a scaled outline or bitmap */
+    if ( !size )
+      load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
+
+    if ( load_flags & FT_LOAD_NO_SCALE )
+      size = NULL;
+
+    /* reset the size object if necessary */
+    if ( size )
+    {
+      /* these two object must have the same parent */
+      if ( size->root.face != slot->face )
+        return TT_Err_Invalid_Face_Handle;
+
+      if ( !size->ttmetrics.valid )
+      {
+        if ( FT_SET_ERROR( TT_Reset_Size( size ) ) )
+          return error;
+      }
+    }
+
+    /* now load the glyph outline if necessary */
+    error = TT_Load_Glyph( size, slot, glyph_index, load_flags );
+
+    /* force drop-out mode to 2 - irrelevant now */
+    /* slot->outline.dropout_mode = 2; */
+
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****             C H A R A C T E R   M A P P I N G S                 ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Char_Index                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return a given character code's glyph index.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index.  0 means `undefined character code'.                  */
+  /*                                                                       */
+  static FT_UInt
+  Get_Char_Index( TT_CharMap  charmap,
+                  FT_Long     charcode )
+  {
+    FT_Error       error;
+    TT_Face        face;
+    TT_CMapTable*  cmap;
+
+
+    cmap = &charmap->cmap;
+    face = (TT_Face)charmap->root.face;
+
+    /* Load table if needed */
+    if ( !cmap->loaded )
+    {
+      SFNT_Interface*  sfnt = (SFNT_Interface*)face->sfnt;
+
+
+      error = sfnt->load_charmap( face, cmap, face->root.stream );
+      if ( error )
+        return 0;
+
+      cmap->loaded = TRUE;
+    }
+
+    if ( cmap->get_index )
+      return cmap->get_index( cmap, charcode );
+    else
+      return 0;
+  }
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Next_Char                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return the next encoded char.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next char code.  0 means `no more encoded characters'.             */
+  /*                                                                       */
+  static FT_UInt
+  Get_Next_Char( TT_CharMap  charmap,
+                 FT_Long     charcode )
+  {
+    FT_Error       error;
+    TT_Face        face;
+    TT_CMapTable*  cmap;
+
+
+    cmap = &charmap->cmap;
+    face = (TT_Face)charmap->root.face;
+
+    /* Load table if needed */
+    if ( !cmap->loaded )
+    {
+      SFNT_Interface*  sfnt = (SFNT_Interface*)face->sfnt;
+
+
+      error = sfnt->load_charmap( face, cmap, face->root.stream );
+      if ( error )
+        return 0;
+
+      cmap->loaded = TRUE;
+    }
+
+    if ( cmap->get_next_char )
+      return cmap->get_next_char ( cmap, charcode );
+    else
+      return 0;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                D R I V E R  I N T E R F A C E                   ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  static FT_Module_Interface
+  tt_get_interface( TT_Driver    driver,
+                    const char*  interface )
+  {
+    FT_Module        sfntd = FT_Get_Module( driver->root.root.library,
+                                            "sfnt" );
+    SFNT_Interface*  sfnt;
+
+
+    /* only return the default interface from the SFNT module */
+    if ( sfntd )
+    {
+      sfnt = (SFNT_Interface*)( sfntd->clazz->module_interface );
+      if ( sfnt )
+        return sfnt->get_interface( FT_MODULE( driver ), interface );
+    }
+
+    return 0;
+  }
+
+
+  /* The FT_DriverInterface structure is defined in ftdriver.h. */
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_Class  tt_driver_class =
+  {
+    {
+      ft_module_font_driver     |
+      ft_module_driver_scalable |
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      ft_module_driver_has_hinter,
+#else
+      0,
+#endif
+
+      sizeof ( TT_DriverRec ),
+
+      "truetype",      /* driver name                           */
+      0x10000L,        /* driver version == 1.0                 */
+      0x20000L,        /* driver requires FreeType 2.0 or above */
+
+      (void*)0,        /* driver specific interface */
+
+      (FT_Module_Constructor)TT_Init_Driver,
+      (FT_Module_Destructor) TT_Done_Driver,
+      (FT_Module_Requester)  tt_get_interface,
+    },
+
+    sizeof ( TT_FaceRec ),
+    sizeof ( TT_SizeRec ),
+    sizeof ( FT_GlyphSlotRec ),
+
+
+    (FTDriver_initFace)     TT_Init_Face,
+    (FTDriver_doneFace)     TT_Done_Face,
+    (FTDriver_initSize)     TT_Init_Size,
+    (FTDriver_doneSize)     TT_Done_Size,
+    (FTDriver_initGlyphSlot)0,
+    (FTDriver_doneGlyphSlot)0,
+
+    (FTDriver_setCharSizes) Set_Char_Sizes,
+    (FTDriver_setPixelSizes)Set_Pixel_Sizes,
+    (FTDriver_loadGlyph)    Load_Glyph,
+    (FTDriver_getCharIndex) Get_Char_Index,
+
+    (FTDriver_getKerning)   Get_Kerning,
+    (FTDriver_attachFile)   0,
+    (FTDriver_getAdvances)  0,
+    
+    (FTDriver_getNextChar)  Get_Next_Char
+  };
+
+
+#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    getDriverClass                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used when compiling the TrueType driver as a      */
+  /*    shared library (`.DLL' or `.so').  It will be used by the          */
+  /*    high-level library of FreeType to retrieve the address of the      */
+  /*    driver's generic interface.                                        */
+  /*                                                                       */
+  /*    It shouldn't be implemented in a static build, as each driver must */
+  /*    have the same function as an exported entry point.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of the TrueType's driver generic interface.  The       */
+  /*    format-specific interface can then be retrieved through the method */
+  /*    interface->get_format_interface.                                   */
+  /*                                                                       */
+  FT_EXPORT_DEF( const FT_Driver_Class* )
+  getDriverClass( void )
+  {
+    return &tt_driver_class;
+  }
+
+
+#endif /* CONFIG_OPTION_DYNAMIC_DRIVERS */
+
+
+/* END */
Index: xc/extras/freetype2/src/truetype/ttdriver.h
diff -u xc/extras/freetype2/src/truetype/ttdriver.h:1.1.1.3 xc/extras/freetype2/src/truetype/ttdriver.h:1.1.1.4
--- xc/extras/freetype2/src/truetype/ttdriver.h:1.1.1.3	Sun Dec 16 12:49:34 2001
+++ xc/extras/freetype2/src/truetype/ttdriver.h	Thu Jun 20 04:16:24 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    High-level TrueType driver interface (specification).                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,7 +27,7 @@
 FT_BEGIN_HEADER
 
 
-  FT_EXPORT_VAR( const FT_Driver_Class )  tt_driver_class;
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  tt_driver_class;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/truetype/ttgload.c
diff -u xc/extras/freetype2/src/truetype/ttgload.c:1.8 xc/extras/freetype2/src/truetype/ttgload.c:1.9
--- xc/extras/freetype2/src/truetype/ttgload.c:1.8	Mon Jan 14 12:01:00 2002
+++ xc/extras/freetype2/src/truetype/ttgload.c	Thu Jun 20 04:25:29 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType Glyph Loader (body).                                        */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -14,7 +14,7 @@
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
-/* $XFree86: xc/extras/freetype2/src/truetype/ttgload.c,v 1.8 2002/01/14 17:01:00 keithp Exp $ */
+/* $XFree86: xc/extras/freetype2/src/truetype/ttgload.c,v 1.9 2002/06/20 08:25:29 keithp Exp $ */
 
 #include <ft2build.h>
 #include FT_INTERNAL_DEBUG_H
@@ -70,7 +70,7 @@
   /*    header  :: A pointer to either the horizontal or vertical metrics  */
   /*               structure.                                              */
   /*                                                                       */
-  /*    index   :: The glyph index.                                        */
+  /*    idx     :: The glyph index.                                        */
   /*                                                                       */
   /* <Output>                                                              */
   /*    bearing :: The bearing, either left side or top side.              */
@@ -81,26 +81,26 @@
   /*    This function will much probably move to another component in the  */
   /*    near future, but I haven't decided which yet.                      */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   TT_Get_Metrics( TT_HoriHeader*  header,
-                  FT_UInt         index,
+                  FT_UInt         idx,
                   FT_Short*       bearing,
                   FT_UShort*      advance )
   {
-    TT_LongMetrics*  longs_m;
-    FT_UShort        k = header->number_Of_HMetrics;
+    TT_LongMetrics  longs_m;
+    FT_UShort       k = header->number_Of_HMetrics;
 
 
-    if ( index < (FT_UInt)k )
+    if ( idx < (FT_UInt)k )
     {
-      longs_m  = (TT_LongMetrics*)header->long_metrics + index;
+      longs_m  = (TT_LongMetrics )header->long_metrics + idx;
       *bearing = longs_m->bearing;
       *advance = longs_m->advance;
     }
     else
     {
-      *bearing = ((TT_ShortMetrics*)header->short_metrics)[index - k];
-      *advance = ((TT_LongMetrics*)header->long_metrics)[k - 1].advance;
+      *bearing = ((TT_ShortMetrics*)header->short_metrics)[idx - k];
+      *advance = ((TT_LongMetrics )header->long_metrics)[k - 1].advance;
     }
   }
 
@@ -113,12 +113,12 @@
   /*                                                                       */
   static void
   Get_HMetrics( TT_Face     face,
-                FT_UInt     index,
+                FT_UInt     idx,
                 FT_Bool     check,
                 FT_Short*   lsb,
                 FT_UShort*  aw )
   {
-    TT_Get_Metrics( &face->horizontal, index, lsb, aw );
+    TT_Get_Metrics( &face->horizontal, idx, lsb, aw );
 
     if ( check && face->postscript.isFixedPitch )
       *aw = face->horizontal.advance_Width_Max;
@@ -127,8 +127,8 @@
 
   /*************************************************************************/
   /*                                                                       */
-  /*    Returns the advance width table for a given pixel size if it is    */
-  /*    found in the font's `hdmx' table (if any).                         */
+  /* Returns the advance width table for a given pixel size if it is found */
+  /* in the font's `hdmx' table (if any).                                  */
   /*                                                                       */
   static FT_Byte*
   Get_Advance_Widths( TT_Face    face,
@@ -136,6 +136,7 @@
   {
     FT_UShort  n;
 
+
     for ( n = 0; n < face->hdmx.num_records; n++ )
       if ( face->hdmx.records[n].ppem == ppem )
         return face->hdmx.records[n].widths;
@@ -145,15 +146,15 @@
 
 
 #define cur_to_org( n, zone ) \
-          MEM_Copy( (zone)->org, (zone)->cur, (n) * sizeof ( FT_Vector ) )
+          FT_MEM_COPY( (zone)->org, (zone)->cur, (n) * sizeof ( FT_Vector ) )
 
 #define org_to_cur( n, zone ) \
-          MEM_Copy( (zone)->cur, (zone)->org, (n) * sizeof ( FT_Vector ) )
+          FT_MEM_COPY( (zone)->cur, (zone)->org, (n) * sizeof ( FT_Vector ) )
 
 
   /*************************************************************************/
   /*                                                                       */
-  /*    Translates an array of coordinates.                                */
+  /* Translates an array of coordinates.                                   */
   /*                                                                       */
   static void
   translate_array( FT_UInt     n,
@@ -175,10 +176,10 @@
 
 
   static void
-  tt_prepare_zone( TT_GlyphZone*  zone,
-                   FT_GlyphLoad*  load,
-                   FT_UInt        start_point,
-                   FT_UInt        start_contour )
+  tt_prepare_zone( TT_GlyphZone  zone,
+                   FT_GlyphLoad  load,
+                   FT_UInt       start_point,
+                   FT_UInt       start_contour )
   {
     zone->n_points   = (FT_UShort)( load->outline.n_points - start_point );
     zone->n_contours = (FT_Short) ( load->outline.n_contours - start_contour );
@@ -195,17 +196,17 @@
 
   /*************************************************************************/
   /*                                                                       */
-  /*  The following functions are used by default with TrueType fonts.     */
-  /*  However, they can be replaced by alternatives if we need to support  */
-  /*  TrueType-compressed formats (like MicroType) in the future.          */
+  /* The following functions are used by default with TrueType fonts.      */
+  /* However, they can be replaced by alternatives if we need to support   */
+  /* TrueType-compressed formats (like MicroType) in the future.           */
   /*                                                                       */
   /*************************************************************************/
 
   FT_CALLBACK_DEF( FT_Error )
-  TT_Access_Glyph_Frame( TT_Loader*  loader,
-                         FT_UInt     glyph_index,
-                         FT_ULong    offset,
-                         FT_UInt     byte_count )
+  TT_Access_Glyph_Frame( TT_Loader  loader,
+                         FT_UInt    glyph_index,
+                         FT_ULong   offset,
+                         FT_UInt    byte_count )
   {
     FT_Error   error;
     FT_Stream  stream = loader->stream;
@@ -217,7 +218,7 @@
     FT_TRACE5(( "Glyph %ld\n", glyph_index ));
 
     /* the following line sets the `error' variable through macros! */
-    if ( FILE_Seek( offset ) || ACCESS_Frame( byte_count ) )
+    if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( byte_count ) )
       return error;
 
     return TT_Err_Ok;
@@ -225,31 +226,31 @@
 
 
   FT_CALLBACK_DEF( void )
-  TT_Forget_Glyph_Frame( TT_Loader*  loader )
+  TT_Forget_Glyph_Frame( TT_Loader  loader )
   {
     FT_Stream  stream = loader->stream;
 
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
   }
 
 
   FT_CALLBACK_DEF( FT_Error )
-  TT_Load_Glyph_Header( TT_Loader*  loader )
+  TT_Load_Glyph_Header( TT_Loader  loader )
   {
-    FT_Stream   stream   = loader->stream;
-    FT_Int      byte_len = loader->byte_len - 10;
+    FT_Stream  stream   = loader->stream;
+    FT_Int     byte_len = loader->byte_len - 10;
 
 
     if ( byte_len < 0 )
       return TT_Err_Invalid_Outline;
 
-    loader->n_contours = GET_Short();
+    loader->n_contours = FT_GET_SHORT();
 
-    loader->bbox.xMin = GET_Short();
-    loader->bbox.yMin = GET_Short();
-    loader->bbox.xMax = GET_Short();
-    loader->bbox.yMax = GET_Short();
+    loader->bbox.xMin = FT_GET_SHORT();
+    loader->bbox.yMin = FT_GET_SHORT();
+    loader->bbox.xMax = FT_GET_SHORT();
+    loader->bbox.yMax = FT_GET_SHORT();
 
     FT_TRACE5(( "  # of contours: %d\n", loader->n_contours ));
     FT_TRACE5(( "  xMin: %4d  xMax: %4d\n", loader->bbox.xMin,
@@ -263,18 +264,18 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  TT_Load_Simple_Glyph( TT_Loader*  load )
+  TT_Load_Simple_Glyph( TT_Loader  load )
   {
-    FT_Error         error;
-    FT_Stream        stream     = load->stream;
-    FT_GlyphLoader*  gloader    = load->gloader;
-    FT_Int           n_contours = load->n_contours;
-    FT_Outline*      outline;
-    TT_Face          face    = (TT_Face)load->face;
-    TT_GlyphSlot     slot    = (TT_GlyphSlot)load->glyph;
-    FT_UShort        n_ins;
-    FT_Int           n, n_points;
-    FT_Int           byte_len = load->byte_len;
+    FT_Error        error;
+    FT_Stream       stream     = load->stream;
+    FT_GlyphLoader  gloader    = load->gloader;
+    FT_Int          n_contours = load->n_contours;
+    FT_Outline*     outline;
+    TT_Face         face       = (TT_Face)load->face;
+    TT_GlyphSlot    slot       = (TT_GlyphSlot)load->glyph;
+    FT_UShort       n_ins;
+    FT_Int          n, n_points;
+    FT_Int          byte_len   = load->byte_len;
 
 
     /* reading the contours endpoints & number of points */
@@ -289,13 +290,13 @@
         goto Invalid_Outline;
 
       for ( ; cur < limit; cur++ )
-        cur[0] = GET_UShort();
+        cur[0] = FT_GET_USHORT();
 
       n_points = 0;
       if ( n_contours > 0 )
         n_points = cur[-1] + 1;
 
-      error = FT_GlyphLoader_Check_Points( gloader, n_points + 2, 0 );
+      error = FT_GlyphLoader_CheckPoints( gloader, n_points + 2, 0 );
       if ( error )
         goto Fail;
 
@@ -311,13 +312,13 @@
     slot->control_len  = 0;
     slot->control_data = 0;
 
-    n_ins = GET_UShort();
+    n_ins = FT_GET_USHORT();
 
     FT_TRACE5(( "  Instructions size: %d\n", n_ins ));
 
     if ( n_ins > face->max_profile.maxSizeOfInstructions )
     {
-      FT_TRACE0(( "ERROR: Too many instructions!\n" ));
+      FT_TRACE0(( "TT_Load_Simple_Glyph: Too many instructions!\n" ));
       error = TT_Err_Too_Many_Hints;
       goto Fail;
     }
@@ -325,7 +326,7 @@
     byte_len -= n_ins;
     if ( byte_len < 0 )
     {
-      FT_TRACE0(( "ERROR: Instruction count mismatch!\n" ));
+      FT_TRACE0(( "TT_Load_Simple_Glyph: Instruction count mismatch!\n" ));
       error = TT_Err_Too_Many_Hints;
       goto Fail;
     }
@@ -339,7 +340,7 @@
       slot->control_len  = n_ins;
       slot->control_data = load->instructions;
 
-      MEM_Copy( load->instructions, stream->cursor, n_ins );
+      FT_MEM_COPY( load->instructions, stream->cursor, n_ins );
     }
 
 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
@@ -358,13 +359,13 @@
         if ( --byte_len < 0 )
           goto Invalid_Outline;
 
-        *flag++ = c = GET_Byte();
+        *flag++ = c = FT_GET_BYTE();
         if ( c & 8 )
         {
           if ( --byte_len < 0 )
             goto Invalid_Outline;
 
-          count = GET_Byte();
+          count = FT_GET_BYTE();
           if ( flag + count > limit )
             goto Invalid_Outline;
 
@@ -407,12 +408,12 @@
 
         if ( *flag & 2 )
         {
-          y = GET_Byte();
+          y = FT_GET_BYTE();
           if ( ( *flag & 16 ) == 0 )
             y = -y;
         }
         else if ( ( *flag & 16 ) == 0 )
-          y = GET_Short();
+          y = FT_GET_SHORT();
 
         x     += y;
         vec->x = x;
@@ -435,12 +436,12 @@
 
         if ( *flag & 4 )
         {
-          y = GET_Byte();
+          y = FT_GET_BYTE();
           if ( ( *flag & 32 ) == 0 )
             y = -y;
         }
         else if ( ( *flag & 32 ) == 0 )
-          y = GET_Short();
+          y = FT_GET_SHORT();
 
         x     += y;
         vec->y = x;
@@ -466,14 +467,14 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  TT_Load_Composite_Glyph( TT_Loader*  loader )
+  TT_Load_Composite_Glyph( TT_Loader  loader )
   {
-    FT_Error         error;
-    FT_Stream        stream  = loader->stream;
-    FT_GlyphLoader*  gloader = loader->gloader;
-    FT_SubGlyph*     subglyph;
-    FT_UInt          num_subglyphs;
-    FT_Int           byte_len = loader->byte_len;
+    FT_Error        error;
+    FT_Stream       stream  = loader->stream;
+    FT_GlyphLoader  gloader = loader->gloader;
+    FT_SubGlyph     subglyph;
+    FT_UInt         num_subglyphs;
+    FT_Int          byte_len = loader->byte_len;
 
 
     num_subglyphs = 0;
@@ -484,7 +485,7 @@
 
 
       /* check that we can load a new subglyph */
-      error = FT_GlyphLoader_Check_Subglyphs( gloader, num_subglyphs + 1 );
+      error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs + 1 );
       if ( error )
         goto Fail;
 
@@ -497,8 +498,8 @@
 
       subglyph->arg1 = subglyph->arg2 = 0;
 
-      subglyph->flags = GET_UShort();
-      subglyph->index = GET_UShort();
+      subglyph->flags = FT_GET_USHORT();
+      subglyph->index = FT_GET_USHORT();
 
       /* check space */
       byte_len -= 2;
@@ -517,13 +518,13 @@
       /* read arguments */
       if ( subglyph->flags & ARGS_ARE_WORDS )
       {
-        subglyph->arg1 = GET_Short();
-        subglyph->arg2 = GET_Short();
+        subglyph->arg1 = FT_GET_SHORT();
+        subglyph->arg2 = FT_GET_SHORT();
       }
       else
       {
-        subglyph->arg1 = GET_Char();
-        subglyph->arg2 = GET_Char();
+        subglyph->arg1 = FT_GET_CHAR();
+        subglyph->arg2 = FT_GET_CHAR();
       }
 
       /* read transform */
@@ -532,20 +533,20 @@
 
       if ( subglyph->flags & WE_HAVE_A_SCALE )
       {
-        xx = (FT_Fixed)GET_Short() << 2;
+        xx = (FT_Fixed)FT_GET_SHORT() << 2;
         yy = xx;
       }
       else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
       {
-        xx = (FT_Fixed)GET_Short() << 2;
-        yy = (FT_Fixed)GET_Short() << 2;
+        xx = (FT_Fixed)FT_GET_SHORT() << 2;
+        yy = (FT_Fixed)FT_GET_SHORT() << 2;
       }
       else if ( subglyph->flags & WE_HAVE_A_2X2 )
       {
-        xx = (FT_Fixed)GET_Short() << 2;
-        xy = (FT_Fixed)GET_Short() << 2;
-        yx = (FT_Fixed)GET_Short() << 2;
-        yy = (FT_Fixed)GET_Short() << 2;
+        xx = (FT_Fixed)FT_GET_SHORT() << 2;
+        xy = (FT_Fixed)FT_GET_SHORT() << 2;
+        yx = (FT_Fixed)FT_GET_SHORT() << 2;
+        yy = (FT_Fixed)FT_GET_SHORT() << 2;
       }
 
       subglyph->transform.xx = xx;
@@ -561,11 +562,11 @@
 
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     {
-      /* we must undo the ACCESS_Frame in order to point to the */
+      /* we must undo the FT_FRAME_ENTER in order to point to the */
       /* composite instructions, if we find some.               */
       /* we will process them later...                          */
       /*                                                        */
-      loader->ins_pos = (FT_ULong)( FILE_Pos() +
+      loader->ins_pos = (FT_ULong)( FT_STREAM_POS() +
                                     stream->cursor - stream->limit );
     }
 #endif
@@ -581,7 +582,7 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   TT_Init_Glyph_Loading( TT_Face  face )
   {
     face->access_glyph_frame   = TT_Access_Glyph_Frame;
@@ -603,20 +604,24 @@
   /*    interpretation.                                                    */
   /*                                                                       */
   static FT_Error
-  TT_Process_Simple_Glyph( TT_Loader*  load,
-                           FT_Bool     debug )
+  TT_Process_Simple_Glyph( TT_Loader  load,
+                           FT_Bool    debug )
   {
-    FT_GlyphLoader*  gloader  = load->gloader;
-    FT_Outline*      outline  = &gloader->current.outline;
-    FT_UInt          n_points = outline->n_points;
-    FT_UInt          n_ins;
-    TT_GlyphZone*    zone     = &load->zone;
-    FT_Error         error    = TT_Err_Ok;
+    FT_GlyphLoader  gloader  = load->gloader;
+    FT_Outline*     outline  = &gloader->current.outline;
+    FT_UInt         n_points = outline->n_points;
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+    FT_UInt         n_ins;
+#endif
+    TT_GlyphZone    zone     = &load->zone;
+    FT_Error        error    = TT_Err_Ok;
 
     FT_UNUSED( debug );  /* used by truetype interpreter only */
 
 
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     n_ins = load->glyph->control_len;
+#endif
 
     /* add shadow points */
 
@@ -733,34 +738,34 @@
   /*    TT_Loader object.                                                  */
   /*                                                                       */
   static FT_Error
-  load_truetype_glyph( TT_Loader*  loader,
-                       FT_UInt     glyph_index )
+  load_truetype_glyph( TT_Loader  loader,
+                       FT_UInt    glyph_index )
   {
 
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
-    FT_Stream        stream = loader->stream;
+    FT_Stream       stream = loader->stream;
 #endif
 
-    FT_Error         error;
-    TT_Face          face   = (TT_Face)loader->face;
-    FT_ULong         offset;
-    FT_Int           contours_count;
-    FT_UInt          index, num_points, count;
-    FT_Fixed         x_scale, y_scale;
-    FT_GlyphLoader*  gloader = loader->gloader;
-    FT_Bool          opened_frame = 0;
+    FT_Error        error;
+    TT_Face         face   = (TT_Face)loader->face;
+    FT_ULong        offset;
+    FT_Int          contours_count;
+    FT_UInt         idx, num_points, count;
+    FT_Fixed        x_scale, y_scale;
+    FT_GlyphLoader  gloader = loader->gloader;
+    FT_Bool         opened_frame = 0;
 
 
     /* check glyph index */
-    index = glyph_index;
-    if ( index >= (FT_UInt)face->root.num_glyphs )
+    idx = glyph_index;
+    if ( idx >= (FT_UInt)face->root.num_glyphs )
     {
       error = TT_Err_Invalid_Glyph_Index;
       goto Exit;
     }
 
     loader->glyph_index = glyph_index;
-    num_points   = 0;
+    num_points          = 0;
 
     x_scale = 0x10000L;
     y_scale = 0x10000L;
@@ -776,9 +781,9 @@
       FT_UShort  advance_width;
 
 
-      Get_HMetrics( face, index,
-                    (FT_Bool)!(loader->load_flags &
-                                FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH),
+      Get_HMetrics( face, idx,
+                    (FT_Bool)!( loader->load_flags &
+                                FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ),
                     &left_bearing,
                     &advance_width );
 
@@ -792,11 +797,11 @@
       }
     }
 
-    offset = face->glyph_locations[index];
+    offset = face->glyph_locations[idx];
     count  = 0;
 
-    if ( index < (FT_UInt)face->num_locations - 1 )
-       count = face->glyph_locations[index + 1] - offset;
+    if ( idx < (FT_UInt)face->num_locations - 1 )
+       count = face->glyph_locations[idx + 1] - offset;
 
     if ( count == 0 )
     {
@@ -826,16 +831,6 @@
 
     loader->byte_len = (FT_Int)count;
 
-#if 0
-    /* temporary hack */
-    if ( count < 10 )
-    {
-      /* This glyph is corrupted -- it does not have a complete header */
-      error = TT_Err_Invalid_Outline;
-      goto Fail;
-    }
-#endif
-
     offset = loader->glyf_offset + offset;
 
     /* access glyph frame */
@@ -874,7 +869,7 @@
     if ( contours_count >= 0 )
     {
       /* check that we can add the contours to the glyph */
-      error = FT_GlyphLoader_Check_Points( gloader, 0, contours_count );
+      error = FT_GlyphLoader_CheckPoints( gloader, 0, contours_count );
       if ( error )
         goto Fail;
 
@@ -885,7 +880,7 @@
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
 
       {
-        TT_Size size = (TT_Size)loader->size;
+        TT_Size  size = (TT_Size)loader->size;
 
 
         error = TT_Process_Simple_Glyph( loader,
@@ -915,19 +910,26 @@
     else
     {
       TT_GlyphSlot  glyph = (TT_GlyphSlot)loader->glyph;
-      FT_UInt       start_point, start_contour;
+      FT_UInt       start_point;
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      FT_UInt       start_contour;
       FT_ULong      ins_pos;  /* position of composite instructions, if any */
+#endif
 
 
       /* for each subglyph, read composite header */
       start_point   = gloader->base.outline.n_points;
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
       start_contour = gloader->base.outline.n_contours;
+#endif
 
       error = face->read_composite_glyph( loader );
       if ( error )
         goto Fail;
 
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
       ins_pos = loader->ins_pos;
+#endif
       face->forget_glyph_frame( loader );
       opened_frame = 0;
 
@@ -940,9 +942,9 @@
         /* set up remaining glyph fields */
         FT_GlyphLoader_Add( gloader );
 
-        glyph->num_subglyphs  = gloader->base.num_subglyphs;
-        glyph->format         = ft_glyph_format_composite;
-        glyph->subglyphs      = gloader->base.subglyphs;
+        glyph->num_subglyphs = gloader->base.num_subglyphs;
+        glyph->format        = ft_glyph_format_composite;
+        glyph->subglyphs     = gloader->base.subglyphs;
 
         goto Exit;
       }
@@ -953,11 +955,11 @@
 
       /* Now, read each subglyph independently. */
       {
-        FT_Int        n, num_base_points, num_new_points;
-        FT_SubGlyph*  subglyph = 0;
+        FT_Int       n, num_base_points, num_new_points;
+        FT_SubGlyph  subglyph       = 0;
 
-        FT_UInt num_subglyphs  = gloader->current.num_subglyphs;
-        FT_UInt num_base_subgs = gloader->base.num_subglyphs;
+        FT_UInt      num_subglyphs  = gloader->current.num_subglyphs;
+        FT_UInt      num_base_subgs = gloader->base.num_subglyphs;
 
 
         FT_GlyphLoader_Add( gloader );
@@ -1087,23 +1089,23 @@
 
         if ( num_subglyphs > 0               &&
              loader->exec                    &&
-             ins_pos         > 0             &&
+             ins_pos > 0                     &&
              subglyph->flags & WE_HAVE_INSTR )
         {
           FT_UShort       n_ins;
           TT_ExecContext  exec = loader->exec;
-          TT_GlyphZone*   pts;
+          TT_GlyphZone    pts;
           FT_Vector*      pp1;
 
 
           /* read size of instructions */
-          if ( FILE_Seek( ins_pos ) ||
-               READ_UShort( n_ins ) )
+          if ( FT_STREAM_SEEK( ins_pos ) ||
+               FT_READ_USHORT( n_ins ) )
             goto Fail;
           FT_TRACE5(( "  Instructions size = %d\n", n_ins ));
 
           /* in some fonts? */
-          if ( n_ins == 0xFFFF )
+          if ( n_ins == 0xFFFFU )
             n_ins = 0;
 
           /* check it */
@@ -1116,7 +1118,7 @@
           }
 
           /* read the instructions */
-          if ( FILE_Read( exec->glyphIns, n_ins ) )
+          if ( FT_STREAM_READ( exec->glyphIns, n_ins ) )
             goto Fail;
 
           glyph->control_data = exec->glyphIns;
@@ -1199,7 +1201,7 @@
 
 
   static void
-  compute_glyph_metrics( TT_Loader*  loader,
+  compute_glyph_metrics( TT_Loader   loader,
                          FT_UInt     glyph_index )
   {
     FT_BBox       bbox;
@@ -1218,7 +1220,7 @@
       glyph->outline.flags &= ~ft_outline_single_pass;
 
       /* copy outline to our glyph slot */
-      FT_GlyphLoader_Copy_Points( glyph->internal->loader, loader->gloader );
+      FT_GlyphLoader_CopyPoints( glyph->internal->loader, loader->gloader );
       glyph->outline = glyph->internal->loader->base.outline;
 
       /* translate array so that (0,0) is the glyph's origin */
@@ -1249,7 +1251,7 @@
       /* `advance_Width_Max' field!  It is used, to my knowledge,       */
       /* exclusively in the X-TrueType font server.                     */
       /*                                                                */
-      if ( face->postscript.isFixedPitch                                    &&
+      if ( face->postscript.isFixedPitch                                     &&
            ( loader->load_flags & FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ) == 0 )
         advance = face->horizontal.advance_Width_Max;
 
@@ -1274,9 +1276,9 @@
       FT_Short   top_bearing;    /* vertical top side bearing (EM units) */
       FT_UShort  advance_height; /* vertical advance height   (EM units) */
 
-      FT_Pos  left;     /* scaled vertical left side bearing         */
-      FT_Pos  top;      /* scaled vertical top side bearing          */
-      FT_Pos  advance;  /* scaled vertical advance height            */
+      FT_Pos     left;     /* scaled vertical left side bearing */
+      FT_Pos     top;      /* scaled vertical top side bearing  */
+      FT_Pos     advance;  /* scaled vertical advance height    */
 
 
       /* Get the unscaled `tsb' and `ah' */
@@ -1305,7 +1307,7 @@
         /*        here with:                                   */
         /*             ascender - descender + linegap          */
         /*                                                     */
-        if ( face->os2.version != 0xFFFF )
+        if ( face->os2.version != 0xFFFFU )
         {
           top_bearing    = (FT_Short)( face->os2.sTypoLineGap / 2 );
           advance_height = (FT_UShort)( face->os2.sTypoAscender -
@@ -1364,8 +1366,8 @@
     if ( !face->postscript.isFixedPitch && size &&
          IS_HINTED( loader->load_flags )        )
     {
-      FT_Byte* widths = Get_Advance_Widths( face,
-                                            size->root.metrics.x_ppem );
+      FT_Byte*  widths = Get_Advance_Widths( face,
+                                             size->root.metrics.x_ppem );
 
 
       if ( widths )
@@ -1405,21 +1407,21 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Glyph( TT_Size       size,
                  TT_GlyphSlot  glyph,
                  FT_UShort     glyph_index,
                  FT_UInt       load_flags )
   {
-    SFNT_Interface*  sfnt;
-    TT_Face          face;
-    FT_Stream        stream;
-    FT_Error         error;
-    TT_Loader        loader;
+    SFNT_Service  sfnt;
+    TT_Face       face;
+    FT_Stream     stream;
+    FT_Error      error;
+    TT_LoaderRec  loader;
 
 
     face   = (TT_Face)glyph->face;
-    sfnt   = (SFNT_Interface*)face->sfnt;
+    sfnt   = (SFNT_Service)face->sfnt;
     stream = face->root.stream;
     error  = 0;
 
@@ -1441,12 +1443,12 @@
     /* XXX: The convention should be emphasized in     */
     /*      the documents because it can be confusing. */
     if ( size                                    &&
-         size->strike_index != 0xFFFF            &&
+         size->strike_index != 0xFFFFU           &&
          sfnt->load_sbits                        &&
          ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
 
     {
-      TT_SBit_Metrics  metrics;
+      TT_SBit_MetricsRec  metrics;
 
 
       error = sfnt->load_sbit_image( face,
@@ -1504,11 +1506,11 @@
       goto Exit;
     }
 
-    MEM_Set( &loader, 0, sizeof ( loader ) );
+    FT_MEM_SET( &loader, 0, sizeof ( loader ) );
 
     /* update the glyph zone bounds */
     {
-      FT_GlyphLoader*  gloader = FT_FACE_DRIVER(face)->glyph_loader;
+      FT_GlyphLoader  gloader = FT_FACE_DRIVER(face)->glyph_loader;
 
 
       loader.gloader = gloader;
@@ -1541,9 +1543,6 @@
     /* clear all outline flags, except the `owner' one */
     glyph->outline.flags = 0;
 
-    if ( size && size->root.metrics.y_ppem < 24 )
-      glyph->outline.flags |= ft_outline_high_precision;
-
     /* let's initialize the rest of our loader now */
 
     loader.load_flags    = load_flags;
@@ -1553,7 +1552,7 @@
     loader.glyph  = (FT_GlyphSlot)glyph;
     loader.stream = stream;
 
-    loader.glyf_offset  = FILE_Pos();
+    loader.glyf_offset  = FT_STREAM_POS();
 
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
 
@@ -1567,6 +1566,7 @@
     /* Main loading loop */
     glyph->format        = ft_glyph_format_outline;
     glyph->num_subglyphs = 0;
+
     error = load_truetype_glyph( &loader, glyph_index );
     if ( !error )
       compute_glyph_metrics( &loader, glyph_index );
@@ -1577,6 +1577,13 @@
       TT_Done_Context( loader.exec );
 
 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
+
+    /* Set the `high precision' bit flag.                           */
+    /* This is _critical_ to get correct output for monochrome      */
+    /* TrueType glyphs at all sizes using the bytecode interpreter. */
+    /*                                                              */
+    if ( size && size->root.metrics.y_ppem < 24 )
+      glyph->outline.flags |= ft_outline_high_precision;
 
   Exit:
     return error;
Index: xc/extras/freetype2/src/truetype/ttgload.h
diff -u xc/extras/freetype2/src/truetype/ttgload.h:1.1.1.3 xc/extras/freetype2/src/truetype/ttgload.h:1.1.1.4
--- xc/extras/freetype2/src/truetype/ttgload.h:1.1.1.3	Sun Dec 16 12:49:35 2001
+++ xc/extras/freetype2/src/truetype/ttgload.h	Thu Jun 20 04:16:25 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType Glyph Loader (specification).                               */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -31,16 +31,16 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   TT_Get_Metrics( TT_HoriHeader*  header,
                   FT_UInt         index,
                   FT_Short*       bearing,
                   FT_UShort*      advance );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   TT_Init_Glyph_Loading( TT_Face  face );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Glyph( TT_Size       size,
                  TT_GlyphSlot  glyph,
                  FT_UShort     glyph_index,
Index: xc/extras/freetype2/src/truetype/ttinterp.c
diff -u xc/extras/freetype2/src/truetype/ttinterp.c:1.1.1.4 xc/extras/freetype2/src/truetype/ttinterp.c:1.1.1.5
--- xc/extras/freetype2/src/truetype/ttinterp.c:1.1.1.4	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/truetype/ttinterp.c	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType bytecode interpreter (body).                                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -256,7 +256,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Goto_CodeRange( TT_ExecContext  exec,
                      FT_Int          range,
                      FT_Long         IP )
@@ -264,17 +264,17 @@
     TT_CodeRange*  coderange;
 
 
-    FT_Assert( range >= 1 && range <= 3 );
+    FT_ASSERT( range >= 1 && range <= 3 );
 
     coderange = &exec->codeRangeTable[range - 1];
 
-    FT_Assert( coderange->base != NULL );
+    FT_ASSERT( coderange->base != NULL );
 
     /* NOTE: Because the last instruction of a program may be a CALL */
     /*       which will return to the first byte *after* the code    */
     /*       range, we test for IP <= Size instead of IP < Size.     */
     /*                                                               */
-    FT_Assert( (FT_ULong)IP <= coderange->size );
+    FT_ASSERT( (FT_ULong)IP <= coderange->size );
 
     exec->code     = coderange->base;
     exec->codeSize = coderange->size;
@@ -306,13 +306,13 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Set_CodeRange( TT_ExecContext  exec,
                     FT_Int          range,
                     void*           base,
                     FT_Long         length )
   {
-    FT_Assert( range >= 1 && range <= 3 );
+    FT_ASSERT( range >= 1 && range <= 3 );
 
     exec->codeRangeTable[range - 1].base = (FT_Byte*)base;
     exec->codeRangeTable[range - 1].size = length;
@@ -341,11 +341,11 @@
   /* <Note>                                                                */
   /*    Does not set the Error variable.                                   */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Clear_CodeRange( TT_ExecContext  exec,
                       FT_Int          range )
   {
-    FT_Assert( range >= 1 && range <= 3 );
+    FT_ASSERT( range >= 1 && range <= 3 );
 
     exec->codeRangeTable[range - 1].base = NULL;
     exec->codeRangeTable[range - 1].size = 0;
@@ -380,12 +380,12 @@
   /* <Note>                                                                */
   /*    Only the glyph loader and debugger should call this function.      */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Destroy_Context( TT_ExecContext  exec,
                       FT_Memory       memory )
   {
     /* free composite load stack */
-    FREE( exec->loadStack );
+    FT_FREE( exec->loadStack );
     exec->loadSize = 0;
 
     /* points zone */
@@ -393,22 +393,22 @@
     exec->maxContours = 0;
 
     /* free stack */
-    FREE( exec->stack );
+    FT_FREE( exec->stack );
     exec->stackSize = 0;
 
     /* free call stack */
-    FREE( exec->callStack );
+    FT_FREE( exec->callStack );
     exec->callSize = 0;
     exec->callTop  = 0;
 
     /* free glyph code range */
-    FREE( exec->glyphIns );
+    FT_FREE( exec->glyphIns );
     exec->glyphSize = 0;
 
     exec->size = NULL;
     exec->face = NULL;
 
-    FREE( exec );
+    FT_FREE( exec );
     return TT_Err_Ok;
   }
 
@@ -446,7 +446,7 @@
     exec->memory   = memory;
     exec->callSize = 32;
 
-    if ( ALLOC_ARRAY( exec->callStack, exec->callSize, TT_CallRec ) )
+    if ( FT_NEW_ARRAY( exec->callStack, exec->callSize ) )
       goto Fail_Memory;
 
     /* all values in the context are set to 0 already, but this is */
@@ -512,8 +512,8 @@
 
     if ( *size < new_max )
     {
-      FREE( *buff );
-      if ( ALLOC( *buff, new_max * multiplier ) )
+      FT_FREE( *buff );
+      if ( FT_ALLOC( *buff, new_max * multiplier ) )
         return error;
       *size = new_max;
     }
@@ -544,7 +544,7 @@
   /* <Note>                                                                */
   /*    Only the glyph loader and debugger should call this function.      */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Context( TT_ExecContext  exec,
                    TT_Face         face,
                    TT_Size         size )
@@ -647,7 +647,7 @@
   /* <Note>                                                                */
   /*    Only the glyph loader and debugger should call this function.      */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Save_Context( TT_ExecContext  exec,
                    TT_Size         size )
   {
@@ -694,7 +694,7 @@
   /* <Note>                                                                */
   /*    Only the glyph loader and debugger should call this function.      */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Run_Context( TT_ExecContext  exec,
                   FT_Bool         debug )
   {
@@ -776,7 +776,7 @@
 
 
       /* allocate object */
-      if ( ALLOC( exec, sizeof ( *exec ) ) )
+      if ( FT_NEW( exec ) )
         goto Exit;
 
       /* initialize it */
@@ -792,7 +792,7 @@
     return driver->context;
 
   Fail:
-    FREE( exec );
+    FT_FREE( exec );
 
     return 0;
   }
@@ -815,7 +815,7 @@
   /* <Note>                                                                */
   /*    Only the glyph loader and debugger should call this function.      */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Done_Context( TT_ExecContext  exec )
   {
     /* Nothing at all for now */
@@ -825,40 +825,7 @@
   }
 
 
- /* return length of given vector */
-#ifdef FT_CONFIG_OPTION_OLD_CALCS
 
-  static FT_F26Dot6
-  Norm( FT_F26Dot6  X,
-        FT_F26Dot6  Y )
-  {
-    TT_INT64  T1, T2;
-
-
-    MUL_64( X, X, T1 );
-    MUL_64( Y, Y, T2 );
-
-    ADD_64( T1, T2, T1 );
-
-    return (FT_F26Dot6)SQRT_64( T1 );
-  }
-
-#else  /* !FT_CONFIG_OPTION_OLD_CALCS */
-
-  static FT_F26Dot6
-  Norm( FT_F26Dot6  X,
-        FT_F26Dot6  Y )
-  {
-    FT_Vector  v;
-
-    v.x = X;
-    v.y = Y;
-    return FT_Vector_Length( &v );
-  }
-
-#endif /* FT_CONFIG_OPTION_OLD_CALCS */
-
-
   /*************************************************************************/
   /*                                                                       */
   /* Before an opcode is executed, the interpreter verifies that there are */
@@ -1201,6 +1168,167 @@
 #define NULL_Vector  (FT_Vector*)&Null_Vector
 
 
+  /* compute (a*b)/2^14 with maximal accuracy and rounding */
+  static FT_Int32
+  TT_MulFix14( FT_Int32  a,
+               FT_Int    b )
+  {
+    FT_Int32   m, s, hi;
+    FT_UInt32  l, lo;
+    
+
+    /* compute ax*bx as 64-bit value */
+    l  = (FT_UInt32)( ( a & 0xFFFFU ) * b );
+    m  = ( a >> 16 ) * b;
+    
+    lo = l + (FT_UInt32)( m << 16 );
+    hi = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo < l );
+    
+    /* divide the result by 2^14 with rounding */
+    s   = hi >> 31;
+    l   = lo + (FT_UInt32)s;
+    hi += s + ( l < lo );
+    lo  = l;
+
+    l   = lo + 0x2000U;
+    hi += (l < lo);
+    
+    return ( hi << 18 ) | ( l >> 14 );
+  }
+
+
+  /* compute (ax*bx+ay*by)/2^14 with maximal accuracy and rounding */
+  static FT_Int32
+  TT_DotFix14( FT_Int32  ax,
+               FT_Int32  ay,
+               FT_Int    bx,
+               FT_Int    by )
+  {
+    FT_Int32   m, s, hi1, hi2, hi;
+    FT_UInt32  l, lo1, lo2, lo;
+    
+
+    /* compute ax*bx as 64-bit value */
+    l = (FT_UInt32)( ( ax & 0xFFFFU ) * bx );
+    m = ( ax >> 16 ) * bx;
+    
+    lo1 = l + (FT_UInt32)( m << 16 );
+    hi1 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo1 < l );
+    
+    /* compute ay*by as 64-bit value */
+    l = (FT_UInt32)( ( ay & 0xFFFFU ) * by );
+    m = ( ay >> 16 ) * by;
+    
+    lo2 = l + (FT_UInt32)( m << 16 );
+    hi2 = ( m >> 16 ) + ( (FT_Int32)l >> 31 ) + ( lo2 < l );
+    
+    /* add them */
+    lo = lo1 + lo2;
+    hi = hi1 + hi2 + ( lo < lo1 );
+    
+    /* divide the result by 2^14 with rounding */
+    s   = hi >> 31;
+    l   = lo + (FT_UInt32)s;
+    hi += s + ( l < lo );
+    lo  = l;
+
+    l   = lo + 0x2000U;
+    hi += ( l < lo );
+    
+    return ( hi << 18 ) | ( l >> 14 );
+  }
+
+
+  /* return length of given vector */
+
+#if 0
+
+  static FT_Int32
+  TT_VecLen( FT_Int32  x,
+             FT_Int32  y )
+  {
+    FT_Int32   m, hi1, hi2, hi;
+    FT_UInt32  l, lo1, lo2, lo;
+
+    
+    /* compute x*x as 64-bit value */
+    lo = (FT_UInt32)( x & 0xFFFFU );
+    hi = x >> 16;
+    
+    l  = lo * lo;
+    m  = hi * lo;
+    hi = hi * hi;
+    
+    lo1 = l + (FT_UInt32)( m << 17 );
+    hi1 = hi + ( m >> 15 ) + ( lo1 < l );
+    
+    /* compute y*y as 64-bit value */
+    lo = (FT_UInt32)( y & 0xFFFFU );
+    hi = y >> 16;
+    
+    l  = lo * lo;
+    m  = hi * lo;
+    hi = hi * hi;
+    
+    lo2 = l + (FT_UInt32)( m << 17 );
+    hi2 = hi + ( m >> 15 ) + ( lo2 < l );
+    
+    /* add them to get 'x*x+y*y' as 64-bit value */
+    lo = lo1 + lo2;
+    hi = hi1 + hi2 + ( lo < lo1 );
+    
+    /* compute the square root of this value */
+    {
+      FT_UInt32  root, rem, test_div;
+      FT_Int     count;
+
+
+      root = 0;
+
+      {
+        rem   = 0;
+        count = 32;
+        do
+        {
+          rem      = ( rem << 2 ) | ( (FT_UInt32)hi >> 30 );
+          hi       = (  hi << 2 ) | (            lo >> 30 );
+          lo     <<= 2;
+          root   <<= 1;
+          test_div = ( root << 1 ) + 1;
+
+          if ( rem >= test_div )
+          {
+            rem  -= test_div;
+            root += 1;
+          }
+        } while ( --count );
+      }
+      
+      return (FT_Int32)root;
+    }
+  }
+
+#else
+ 
+  /* this version uses FT_Vector_Length which computes the same value */
+  /* much, much faster..                                              */
+  /*                                                                  */
+  static FT_F26Dot6
+  TT_VecLen( FT_F26Dot6  X,
+             FT_F26Dot6  Y )
+  {
+    FT_Vector  v;
+
+
+    v.x = X;
+    v.y = Y;
+
+    return FT_Vector_Length( &v );
+  }
+  
+#endif
+
+
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
@@ -1231,7 +1359,7 @@
 
       x = TT_MULDIV( CUR.GS.projVector.x, CUR.tt_metrics.x_ratio, 0x4000 );
       y = TT_MULDIV( CUR.GS.projVector.y, CUR.tt_metrics.y_ratio, 0x4000 );
-      CUR.tt_metrics.ratio = Norm( x, y );
+      CUR.tt_metrics.ratio = TT_VecLen( x, y );
     }
 
     return CUR.tt_metrics.ratio;
@@ -1253,48 +1381,48 @@
 
 
   FT_CALLBACK_DEF( FT_F26Dot6 )
-  Read_CVT( EXEC_OP_ FT_ULong  index )
+  Read_CVT( EXEC_OP_ FT_ULong  idx )
   {
-    return CUR.cvt[index];
+    return CUR.cvt[idx];
   }
 
 
   FT_CALLBACK_DEF( FT_F26Dot6 )
-  Read_CVT_Stretched( EXEC_OP_ FT_ULong  index )
+  Read_CVT_Stretched( EXEC_OP_ FT_ULong  idx )
   {
-    return TT_MULFIX( CUR.cvt[index], CURRENT_Ratio() );
+    return TT_MULFIX( CUR.cvt[idx], CURRENT_Ratio() );
   }
 
 
   FT_CALLBACK_DEF( void )
-  Write_CVT( EXEC_OP_ FT_ULong    index,
+  Write_CVT( EXEC_OP_ FT_ULong    idx,
                       FT_F26Dot6  value )
   {
-    CUR.cvt[index] = value;
+    CUR.cvt[idx] = value;
   }
 
 
   FT_CALLBACK_DEF( void )
-  Write_CVT_Stretched( EXEC_OP_ FT_ULong    index,
+  Write_CVT_Stretched( EXEC_OP_ FT_ULong    idx,
                                 FT_F26Dot6  value )
   {
-    CUR.cvt[index] = FT_DivFix( value, CURRENT_Ratio() );
+    CUR.cvt[idx] = FT_DivFix( value, CURRENT_Ratio() );
   }
 
 
   FT_CALLBACK_DEF( void )
-  Move_CVT( EXEC_OP_ FT_ULong    index,
+  Move_CVT( EXEC_OP_ FT_ULong    idx,
                      FT_F26Dot6  value )
   {
-    CUR.cvt[index] += value;
+    CUR.cvt[idx] += value;
   }
 
 
   FT_CALLBACK_DEF( void )
-  Move_CVT_Stretched( EXEC_OP_ FT_ULong    index,
+  Move_CVT_Stretched( EXEC_OP_ FT_ULong    idx,
                                FT_F26Dot6  value )
   {
-    CUR.cvt[index] += FT_DivFix( value, CURRENT_Ratio() );
+    CUR.cvt[idx] += FT_DivFix( value, CURRENT_Ratio() );
   }
 
 
@@ -1397,11 +1525,11 @@
   /*    zone     :: The affected glyph zone.                               */
   /*                                                                       */
   static void
-  Direct_Move( EXEC_OP_ TT_GlyphZone*  zone,
-                        FT_UShort      point,
-                        FT_F26Dot6     distance )
+  Direct_Move( EXEC_OP_ TT_GlyphZone  zone,
+                        FT_UShort     point,
+                        FT_F26Dot6    distance )
   {
-    FT_F26Dot6 v;
+    FT_F26Dot6  v;
 
 
     v = CUR.GS.freeVector.x;
@@ -1459,9 +1587,9 @@
 
 
   static void
-  Direct_Move_X( EXEC_OP_ TT_GlyphZone*  zone,
-                          FT_UShort      point,
-                          FT_F26Dot6     distance )
+  Direct_Move_X( EXEC_OP_ TT_GlyphZone  zone,
+                          FT_UShort     point,
+                          FT_F26Dot6    distance )
   {
     FT_UNUSED_EXEC;
 
@@ -1471,9 +1599,9 @@
 
 
   static void
-  Direct_Move_Y( EXEC_OP_ TT_GlyphZone*  zone,
-                          FT_UShort      point,
-                          FT_F26Dot6     distance )
+  Direct_Move_Y( EXEC_OP_ TT_GlyphZone  zone,
+                          FT_UShort     point,
+                          FT_F26Dot6    distance )
   {
     FT_UNUSED_EXEC;
 
@@ -1982,8 +2110,10 @@
   Project( EXEC_OP_ FT_Vector*  v1,
                     FT_Vector*  v2 )
   {
-    return TT_MULDIV( v1->x - v2->x, CUR.GS.projVector.x, 0x4000 ) +
-           TT_MULDIV( v1->y - v2->y, CUR.GS.projVector.y, 0x4000 );
+    return TT_DotFix14( v1->x - v2->x,
+                        v1->y - v2->y,
+                        CUR.GS.projVector.x,
+                        CUR.GS.projVector.y );
   }
 
 
@@ -2007,8 +2137,10 @@
   Dual_Project( EXEC_OP_ FT_Vector*  v1,
                          FT_Vector*  v2 )
   {
-    return TT_MULDIV( v1->x - v2->x, CUR.GS.dualVector.x, 0x4000 ) +
-           TT_MULDIV( v1->y - v2->y, CUR.GS.dualVector.y, 0x4000 );
+    return TT_DotFix14( v1->x - v2->x,
+                        v1->y - v2->y,
+                        CUR.GS.dualVector.x,
+                        CUR.GS.dualVector.y );
   }
 
 
@@ -2032,8 +2164,10 @@
   Free_Project( EXEC_OP_ FT_Vector*  v1,
                          FT_Vector*  v2 )
   {
-    return TT_MULDIV( v1->x - v2->x, CUR.GS.freeVector.x, 0x4000 ) +
-           TT_MULDIV( v1->y - v2->y, CUR.GS.freeVector.y, 0x4000 );
+    return TT_DotFix14( v1->x - v2->x,
+                        v1->y - v2->y,
+                        CUR.GS.freeVector.x,
+                        CUR.GS.freeVector.y );
   }
 
 
@@ -2188,7 +2322,6 @@
   /*    R is undefined.                                                    */
   /*                                                                       */
 
-#ifdef FT_CONFIG_OPTION_OLD_CALCS
 
   static FT_Bool
   Normalize( EXEC_OP_ FT_F26Dot6      Vx,
@@ -2206,7 +2339,7 @@
       Vx *= 0x100;
       Vy *= 0x100;
 
-      W = Norm( Vx, Vy );
+      W = TT_VecLen( Vx, Vy );
 
       if ( W == 0 )
       {
@@ -2221,7 +2354,7 @@
       return SUCCESS;
     }
 
-    W = Norm( Vx, Vy );
+    W = TT_VecLen( Vx, Vy );
 
     Vx = FT_MulDiv( Vx, 0x4000L, W );
     Vy = FT_MulDiv( Vy, 0x4000L, W );
@@ -2284,30 +2417,6 @@
     return SUCCESS;
   }
 
-#else
-
-  static FT_Bool
-  Normalize( EXEC_OP_ FT_F26Dot6      Vx,
-                      FT_F26Dot6      Vy,
-                      FT_UnitVector*  R )
-  {
-    FT_Vector  v;
-    FT_Angle   angle;
-
-    FT_UNUSED_EXEC;
-
-    angle = FT_Atan2( Vx, Vy );
-
-    FT_Vector_Unit( &v, angle );
-
-    R->x = (short)(v.x >> 2);
-    R->y = (short)(v.y >> 2);
-
-    return SUCCESS;
-  }
-
-#endif /* FT_CONFIG_OPTION_OLD_CALCS */
-
 
   /*************************************************************************/
   /*                                                                       */
@@ -3846,9 +3955,9 @@
 
     K = CUR.stack[CUR.args - L];
 
-    MEM_Move( &CUR.stack[CUR.args - L    ],
-              &CUR.stack[CUR.args - L + 1],
-              ( L - 1 ) * sizeof ( FT_Long ) );
+    FT_MEM_MOVE( &CUR.stack[CUR.args - L    ],
+                 &CUR.stack[CUR.args - L + 1],
+                 ( L - 1 ) * sizeof ( FT_Long ) );
 
     CUR.stack[CUR.args - 1] = K;
   }
@@ -4981,14 +5090,14 @@
 
 
   static FT_Bool
-  Compute_Point_Displacement( EXEC_OP_ FT_F26Dot6*    x,
-                                       FT_F26Dot6*    y,
-                                       TT_GlyphZone*  zone,
-                                       FT_UShort*     refp )
-  {
-    TT_GlyphZone  zp;
-    FT_UShort     p;
-    FT_F26Dot6    d;
+  Compute_Point_Displacement( EXEC_OP_ FT_F26Dot6*   x,
+                                       FT_F26Dot6*   y,
+                                       TT_GlyphZone  zone,
+                                       FT_UShort*    refp )
+  {
+    TT_GlyphZoneRec  zp;
+    FT_UShort        p;
+    FT_F26Dot6       d;
 
 
     if ( CUR.opcode & 1 )
@@ -5016,8 +5125,8 @@
 
 #ifdef NO_APPLE_PATENT
 
-    *x = TT_MULDIV( d, CUR.GS.freeVector.x, 0x4000 );
-    *y = TT_MULDIV( d, CUR.GS.freeVector.y, 0x4000 );
+    *x = TT_MulFix14( d, CUR.GS.freeVector.x );
+    *y = TT_MulFix14( d, CUR.GS.freeVector.y );
 
 #else
 
@@ -5065,12 +5174,12 @@
   static void
   Ins_SHP( INS_ARG )
   {
-    TT_GlyphZone  zp;
-    FT_UShort     refp;
+    TT_GlyphZoneRec  zp;
+    FT_UShort        refp;
 
-    FT_F26Dot6    dx,
-                  dy;
-    FT_UShort     point;
+    FT_F26Dot6       dx,
+                     dy;
+    FT_UShort        point;
 
     FT_UNUSED_ARG;
 
@@ -5118,13 +5227,13 @@
   static void
   Ins_SHC( INS_ARG )
   {
-    TT_GlyphZone zp;
-    FT_UShort    refp;
-    FT_F26Dot6   dx,
-                 dy;
+    TT_GlyphZoneRec zp;
+    FT_UShort       refp;
+    FT_F26Dot6      dx,
+                    dy;
 
-    FT_Short     contour;
-    FT_UShort    first_point, last_point, i;
+    FT_Short        contour;
+    FT_UShort       first_point, last_point, i;
 
 
     contour = (FT_UShort)args[0];
@@ -5174,12 +5283,12 @@
   static void
   Ins_SHZ( INS_ARG )
   {
-    TT_GlyphZone zp;
-    FT_UShort    refp;
-    FT_F26Dot6   dx,
-                 dy;
+    TT_GlyphZoneRec zp;
+    FT_UShort       refp;
+    FT_F26Dot6      dx,
+                    dy;
 
-    FT_UShort    last_point, i;
+    FT_UShort       last_point, i;
 
 
     if ( BOUNDS( args[0], 2 ) )
@@ -5225,12 +5334,8 @@
       return;
     }
 
-    dx = TT_MULDIV( args[0],
-                    (FT_Long)CUR.GS.freeVector.x,
-                    0x4000 );
-    dy = TT_MULDIV( args[0],
-                    (FT_Long)CUR.GS.freeVector.y,
-                    0x4000 );
+    dx = TT_MulFix14( args[0], CUR.GS.freeVector.x );
+    dy = TT_MulFix14( args[0], CUR.GS.freeVector.y );
 
     while ( CUR.GS.loop > 0 )
     {
@@ -5393,11 +5498,9 @@
 
     if ( CUR.GS.gep0 == 0 )   /* If in twilight zone */
     {
-      CUR.zp0.org[point].x = TT_MULDIV( CUR.GS.freeVector.x,
-                                        distance, 0x4000 );
-      CUR.zp0.org[point].y = TT_MULDIV( CUR.GS.freeVector.y,
-                                        distance, 0x4000 );
-      CUR.zp0.cur[point] = CUR.zp0.org[point];
+      CUR.zp0.org[point].x = TT_MulFix14( distance, CUR.GS.freeVector.x );
+      CUR.zp0.org[point].y = TT_MulFix14( distance, CUR.GS.freeVector.y ),
+      CUR.zp0.cur[point]   = CUR.zp0.org[point];
     }
 
     org_dist = CUR_Func_project( CUR.zp0.cur + point, NULL_Vector );
@@ -5550,14 +5653,10 @@
     if ( CUR.GS.gep1 == 0 )
     {
       CUR.zp1.org[point].x = CUR.zp0.org[CUR.GS.rp0].x +
-                             TT_MULDIV( cvt_dist,
-                                        CUR.GS.freeVector.x,
-                                        0x4000 );
+                             TT_MulFix14( cvt_dist, CUR.GS.freeVector.x );
 
       CUR.zp1.org[point].y = CUR.zp0.org[CUR.GS.rp0].y +
-                             TT_MULDIV( cvt_dist,
-                                        CUR.GS.freeVector.y,
-                                        0x4000 );
+                             TT_MulFix14( cvt_dist, CUR.GS.freeVector.y );
 
       CUR.zp1.cur[point] = CUR.zp1.org[point];
     }
Index: xc/extras/freetype2/src/truetype/ttinterp.h
diff -u xc/extras/freetype2/src/truetype/ttinterp.h:1.1.1.3 xc/extras/freetype2/src/truetype/ttinterp.h:1.1.1.4
--- xc/extras/freetype2/src/truetype/ttinterp.h:1.1.1.3	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/truetype/ttinterp.h	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType bytecode interpreter (specification).                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -73,9 +73,9 @@
 
   /* Point displacement along the freedom vector routine */
   typedef void
-  (*TT_Move_Func)( EXEC_OP_ TT_GlyphZone*  zone,
-                            FT_UShort      point,
-                            FT_F26Dot6     distance );
+  (*TT_Move_Func)( EXEC_OP_ TT_GlyphZone  zone,
+                            FT_UShort     point,
+                            FT_F26Dot6    distance );
 
   /* Distance projection along one of the projection vectors */
   typedef FT_F26Dot6
@@ -84,12 +84,12 @@
 
   /* reading a cvt value.  Take care of non-square pixels if necessary */
   typedef FT_F26Dot6
-  (*TT_Get_CVT_Func)( EXEC_OP_ FT_ULong  index );
+  (*TT_Get_CVT_Func)( EXEC_OP_ FT_ULong  idx );
 
   /* setting or moving a cvt value.  Take care of non-square pixels  */
   /* if necessary                                                    */
   typedef void
-  (*TT_Set_CVT_Func)( EXEC_OP_ FT_ULong    index,
+  (*TT_Set_CVT_Func)( EXEC_OP_ FT_ULong    idx,
                                FT_F26Dot6  value );
 
 
@@ -114,90 +114,90 @@
   /*                                                                       */
   typedef struct  TT_ExecContextRec_
   {
-    TT_Face         face;
-    TT_Size         size;
-    FT_Memory       memory;
+    TT_Face            face;
+    TT_Size            size;
+    FT_Memory          memory;
 
     /* instructions state */
 
-    FT_Error        error;      /* last execution error */
+    FT_Error           error;      /* last execution error */
 
-    FT_Long         top;        /* top of exec. stack   */
+    FT_Long            top;        /* top of exec. stack   */
 
-    FT_UInt         stackSize;  /* size of exec. stack  */
-    FT_Long*        stack;      /* current exec. stack  */
+    FT_UInt            stackSize;  /* size of exec. stack  */
+    FT_Long*           stack;      /* current exec. stack  */
 
-    FT_Long         args;
-    FT_UInt         new_top;    /* new top after exec.  */
+    FT_Long            args;
+    FT_UInt            new_top;    /* new top after exec.  */
 
-    TT_GlyphZone    zp0,        /* zone records */
-                    zp1,
-                    zp2,
-                    pts,
-                    twilight;
+    TT_GlyphZoneRec    zp0,        /* zone records */
+                       zp1,
+                       zp2,
+                       pts,
+                       twilight;
 
-    FT_Size_Metrics  metrics;
-    TT_Size_Metrics  tt_metrics; /* size metrics */
+    FT_Size_Metrics    metrics;
+    TT_Size_Metrics    tt_metrics; /* size metrics */
 
-    TT_GraphicsState  GS;         /* current graphics state */
+    TT_GraphicsState   GS;         /* current graphics state */
 
-    FT_Int          curRange;  /* current code range number   */
-    FT_Byte*        code;      /* current code range          */
-    FT_Long         IP;        /* current instruction pointer */
-    FT_Long         codeSize;  /* size of current range       */
+    FT_Int             curRange;  /* current code range number   */
+    FT_Byte*           code;      /* current code range          */
+    FT_Long            IP;        /* current instruction pointer */
+    FT_Long            codeSize;  /* size of current range       */
 
-    FT_Byte         opcode;    /* current opcode              */
-    FT_Int          length;    /* length of current opcode    */
+    FT_Byte            opcode;    /* current opcode              */
+    FT_Int             length;    /* length of current opcode    */
 
-    FT_Bool         step_ins;  /* true if the interpreter must */
-                               /* increment IP after ins. exec */
-    FT_Long         cvtSize;
-    FT_Long*        cvt;
+    FT_Bool            step_ins;  /* true if the interpreter must */
+                                  /* increment IP after ins. exec */
+    FT_Long            cvtSize;
+    FT_Long*           cvt;
 
-    FT_UInt         glyphSize; /* glyph instructions buffer size */
-    FT_Byte*        glyphIns;  /* glyph instructions buffer */
+    FT_UInt            glyphSize; /* glyph instructions buffer size */
+    FT_Byte*           glyphIns;  /* glyph instructions buffer */
 
-    FT_UInt         numFDefs;  /* number of function defs         */
-    FT_UInt         maxFDefs;  /* maximum number of function defs */
-    TT_DefArray     FDefs;     /* table of FDefs entries          */
+    FT_UInt            numFDefs;  /* number of function defs         */
+    FT_UInt            maxFDefs;  /* maximum number of function defs */
+    TT_DefArray        FDefs;     /* table of FDefs entries          */
 
-    FT_UInt         numIDefs;  /* number of instruction defs */
-    FT_UInt         maxIDefs;  /* maximum number of ins defs */
-    TT_DefArray     IDefs;     /* table of IDefs entries     */
+    FT_UInt            numIDefs;  /* number of instruction defs */
+    FT_UInt            maxIDefs;  /* maximum number of ins defs */
+    TT_DefArray        IDefs;     /* table of IDefs entries     */
 
-    FT_UInt         maxFunc;   /* maximum function index     */
-    FT_UInt         maxIns;    /* maximum instruction index  */
+    FT_UInt            maxFunc;   /* maximum function index     */
+    FT_UInt            maxIns;    /* maximum instruction index  */
 
-    FT_Int          callTop,    /* top of call stack during execution */
-                    callSize;   /* size of call stack */
-    TT_CallStack    callStack;  /* call stack */
+    FT_Int             callTop,    /* top of call stack during execution */
+                       callSize;   /* size of call stack */
+    TT_CallStack       callStack;  /* call stack */
 
-    FT_UShort       maxPoints;    /* capacity of this context's `pts' */
-    FT_Short        maxContours;  /* record, expressed in points and  */
-                                  /* contours.                        */
+    FT_UShort          maxPoints;    /* capacity of this context's `pts' */
+    FT_Short           maxContours;  /* record, expressed in points and  */
+                                     /* contours.                        */
 
     TT_CodeRangeTable  codeRangeTable;  /* table of valid code ranges */
                                         /* useful for the debugger   */
 
-    FT_UShort       storeSize;  /* size of current storage */
-    FT_Long*        storage;    /* storage area            */
+    FT_UShort          storeSize;  /* size of current storage */
+    FT_Long*           storage;    /* storage area            */
 
-    FT_F26Dot6      period;     /* values used for the */
-    FT_F26Dot6      phase;      /* `SuperRounding'     */
-    FT_F26Dot6      threshold;
+    FT_F26Dot6         period;     /* values used for the */
+    FT_F26Dot6         phase;      /* `SuperRounding'     */
+    FT_F26Dot6         threshold;
 
 #if 0
     /* this seems to be unused */
-    FT_Int          cur_ppem;       /* ppem along the current proj vector */
+    FT_Int             cur_ppem;   /* ppem along the current proj vector */
 #endif
 
-    FT_Bool         instruction_trap;  /* If `True', the interpreter will */
-                                       /* exit after each instruction     */
+    FT_Bool            instruction_trap; /* If `True', the interpreter will */
+                                         /* exit after each instruction     */
 
-    TT_GraphicsState  default_GS;      /* graphics state resulting from    */
-                                       /* the prep program                 */
-    FT_Bool          is_composite;     /* true if the glyph is composite   */
-    FT_Bool          pedantic_hinting; /* true for pedantic interpretation */
+    TT_GraphicsState   default_GS;       /* graphics state resulting from   */
+                                         /* the prep program                */
+    FT_Bool            is_composite;     /* true if the glyph is composite  */
+    FT_Bool            pedantic_hinting; /* true if pedantic interpretation */
 
     /* latest interpreter additions */
 
@@ -224,18 +224,18 @@
   extern const TT_GraphicsState  tt_default_graphics_state;
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Goto_CodeRange( TT_ExecContext  exec,
                      FT_Int          range,
                      FT_Long         IP );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Set_CodeRange( TT_ExecContext  exec,
                     FT_Int          range,
                     void*           base,
                     FT_Long         length );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Clear_CodeRange( TT_ExecContext  exec,
                       FT_Int          range );
 
@@ -263,23 +263,23 @@
   TT_New_Context( TT_Face  face );
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Done_Context( TT_ExecContext  exec );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Destroy_Context( TT_ExecContext  exec,
                       FT_Memory       memory );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Context( TT_ExecContext  exec,
                    TT_Face         face,
                    TT_Size         size );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Save_Context( TT_ExecContext  exec,
                    TT_Size         ins );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Run_Context( TT_ExecContext  exec,
                   FT_Bool         debug );
 
Index: xc/extras/freetype2/src/truetype/ttobjs.c
diff -u xc/extras/freetype2/src/truetype/ttobjs.c:1.1.1.4 xc/extras/freetype2/src/truetype/ttobjs.c:1.1.1.5
--- xc/extras/freetype2/src/truetype/ttobjs.c:1.1.1.4	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/truetype/ttobjs.c	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Objects manager (body).                                              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -65,16 +65,16 @@
   /* <Input>                                                               */
   /*    zone :: A pointer to the target glyph zone.                        */
   /*                                                                       */
-  FT_LOCAL_DEF void
-  TT_Done_GlyphZone( TT_GlyphZone*  zone )
+  FT_LOCAL_DEF( void )
+  TT_Done_GlyphZone( TT_GlyphZone  zone )
   {
     FT_Memory  memory = zone->memory;
 
 
-    FREE( zone->contours );
-    FREE( zone->tags );
-    FREE( zone->cur );
-    FREE( zone->org );
+    FT_FREE( zone->contours );
+    FT_FREE( zone->tags );
+    FT_FREE( zone->cur );
+    FT_FREE( zone->org );
 
     zone->max_points   = zone->n_points   = 0;
     zone->max_contours = zone->n_contours = 0;
@@ -102,11 +102,11 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_New_GlyphZone( FT_Memory      memory,
-                    FT_UShort      maxPoints,
-                    FT_Short       maxContours,
-                    TT_GlyphZone*  zone )
+  FT_LOCAL_DEF( FT_Error )
+  TT_New_GlyphZone( FT_Memory     memory,
+                    FT_UShort     maxPoints,
+                    FT_Short      maxContours,
+                    TT_GlyphZone  zone )
   {
     FT_Error  error;
 
@@ -114,13 +114,13 @@
     if ( maxPoints > 0 )
       maxPoints += 2;
 
-    MEM_Set( zone, 0, sizeof ( *zone ) );
+    FT_MEM_SET( zone, 0, sizeof ( *zone ) );
     zone->memory = memory;
 
-    if ( ALLOC_ARRAY( zone->org,      maxPoints * 2, FT_F26Dot6 ) ||
-         ALLOC_ARRAY( zone->cur,      maxPoints * 2, FT_F26Dot6 ) ||
-         ALLOC_ARRAY( zone->tags,     maxPoints,     FT_Byte    ) ||
-         ALLOC_ARRAY( zone->contours, maxContours,   FT_UShort  ) )
+    if ( FT_NEW_ARRAY( zone->org,      maxPoints * 2 ) ||
+         FT_NEW_ARRAY( zone->cur,      maxPoints * 2 ) ||
+         FT_NEW_ARRAY( zone->tags,     maxPoints     ) ||
+         FT_NEW_ARRAY( zone->contours, maxContours   ) )
     {
       TT_Done_GlyphZone( zone );
     }
@@ -133,7 +133,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Init_Face                                                       */
+  /*    TT_Face_Init                                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Initializes a given TrueType face object.                          */
@@ -153,25 +153,25 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_Init_Face( FT_Stream      stream,
+  FT_LOCAL_DEF( FT_Error )
+  TT_Face_Init( FT_Stream      stream,
                 TT_Face        face,
                 FT_Int         face_index,
                 FT_Int         num_params,
                 FT_Parameter*  params )
   {
-    FT_Error         error;
-    FT_Library       library;
-    SFNT_Interface*  sfnt;
+    FT_Error      error;
+    FT_Library    library;
+    SFNT_Service  sfnt;
 
 
     library = face->root.driver->root.library;
-    sfnt    = (SFNT_Interface*)FT_Get_Module_Interface( library, "sfnt" );
+    sfnt    = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );
     if ( !sfnt )
       goto Bad_Format;
 
     /* create input stream from resource */
-    if ( FILE_Seek( 0 ) )
+    if ( FT_STREAM_SEEK( 0 ) )
       goto Exit;
 
     /* check that we have a valid TrueType file */
@@ -216,7 +216,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Done_Face                                                       */
+  /*    TT_Face_Done                                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Finalizes a given face object.                                     */
@@ -224,13 +224,13 @@
   /* <Input>                                                               */
   /*    face :: A pointer to the face object to destroy.                   */
   /*                                                                       */
-  FT_LOCAL_DEF void
-  TT_Done_Face( TT_Face  face )
+  FT_LOCAL_DEF( void )
+  TT_Face_Done( TT_Face  face )
   {
-    FT_Memory  memory = face->root.memory;
-    FT_Stream  stream = face->root.stream;
+    FT_Memory     memory = face->root.memory;
+    FT_Stream     stream = face->root.stream;
 
-    SFNT_Interface*  sfnt = (SFNT_Interface*)face->sfnt;
+    SFNT_Service  sfnt   = (SFNT_Service)face->sfnt;
 
 
     /* for `extended TrueType formats' (i.e. compressed versions) */
@@ -241,16 +241,16 @@
       sfnt->done_face( face );
 
     /* freeing the locations table */
-    FREE( face->glyph_locations );
+    FT_FREE( face->glyph_locations );
     face->num_locations = 0;
 
     /* freeing the CVT */
-    FREE( face->cvt );
+    FT_FREE( face->cvt );
     face->cvt_size = 0;
 
     /* freeing the programs */
-    RELEASE_Frame( face->font_program );
-    RELEASE_Frame( face->cvt_program );
+    FT_FRAME_RELEASE( face->font_program );
+    FT_FRAME_RELEASE( face->cvt_program );
     face->font_program_size = 0;
     face->cvt_program_size  = 0;
   }
@@ -266,7 +266,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Init_Size                                                       */
+  /*    TT_Size_Init                                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Initializes a new TrueType size object.                            */
@@ -277,8 +277,8 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_Init_Size( TT_Size  size )
+  FT_LOCAL_DEF( FT_Error )
+  TT_Size_Init( TT_Size  size )
   {
     FT_Error  error = TT_Err_Ok;
 
@@ -326,20 +326,11 @@
     }
 
     /* allocate function defs, instruction defs, cvt, and storage area */
-    if ( ALLOC_ARRAY( size->function_defs,
-                      size->max_function_defs,
-                      TT_DefRecord )                ||
-
-         ALLOC_ARRAY( size->instruction_defs,
-                      size->max_instruction_defs,
-                      TT_DefRecord )                ||
-
-         ALLOC_ARRAY( size->cvt,
-                      size->cvt_size, FT_Long )     ||
+    if ( FT_NEW_ARRAY( size->function_defs,    size->max_function_defs    ) ||
+         FT_NEW_ARRAY( size->instruction_defs, size->max_instruction_defs ) ||
+         FT_NEW_ARRAY( size->cvt,              size->cvt_size             ) ||
+         FT_NEW_ARRAY( size->storage,          size->storage_size         ) )
 
-         ALLOC_ARRAY( size->storage,
-                      size->storage_size, FT_Long ) )
-
       goto Fail_Memory;
 
     /* reserve twilight zone */
@@ -445,7 +436,7 @@
 
   Fail_Memory:
 
-    TT_Done_Size( size );
+    TT_Size_Done( size );
     return error;
 
 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
@@ -456,7 +447,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Done_Size                                                       */
+  /*    TT_Size_Done                                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    The TrueType size object finalizer.                                */
@@ -464,8 +455,8 @@
   /* <Input>                                                               */
   /*    size :: A handle to the target size object.                        */
   /*                                                                       */
-  FT_LOCAL_DEF void
-  TT_Done_Size( TT_Size  size )
+  FT_LOCAL_DEF( void )
+  TT_Size_Done( TT_Size  size )
   {
 
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
@@ -480,18 +471,18 @@
       size->debug   = FALSE;
     }
 
-    FREE( size->cvt );
+    FT_FREE( size->cvt );
     size->cvt_size = 0;
 
     /* free storage area */
-    FREE( size->storage );
+    FT_FREE( size->storage );
     size->storage_size = 0;
 
     /* twilight zone */
     TT_Done_GlyphZone( &size->twilight );
 
-    FREE( size->function_defs );
-    FREE( size->instruction_defs );
+    FT_FREE( size->function_defs );
+    FT_FREE( size->instruction_defs );
 
     size->num_function_defs    = 0;
     size->max_function_defs    = 0;
@@ -522,8 +513,8 @@
   static FT_Error
   Reset_Outline_Size( TT_Size  size )
   {
-    TT_Face   face;
-    FT_Error  error = TT_Err_Ok;
+    TT_Face           face;
+    FT_Error          error = TT_Err_Ok;
 
     FT_Size_Metrics*  metrics;
 
@@ -570,7 +561,7 @@
 
 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
     /* set to `invalid' by default */
-    size->strike_index = 0xFFFF;
+    size->strike_index = 0xFFFFU;
 #endif
 
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
@@ -679,16 +670,16 @@
     FT_ULong          strike_index;
     FT_Size_Metrics*  metrics;
     FT_Size_Metrics*  sbit_metrics;
-    SFNT_Interface*   sfnt;
+    SFNT_Service      sfnt;
 
 
     metrics = &size->root.metrics;
 
-    if ( size->strike_index != 0xFFFF )
+    if ( size->strike_index != 0xFFFFU )
       return TT_Err_Ok;
 
     face = (TT_Face)size->root.face;
-    sfnt = (SFNT_Interface*)face->sfnt;
+    sfnt = (SFNT_Service)face->sfnt;
 
     sbit_metrics = &size->strike_metrics;
 
@@ -698,7 +689,7 @@
 
     if ( !error )
     {
-      TT_SBit_Strike*  strike = face->sbit_strikes + strike_index;
+      TT_SBit_Strike  strike = face->sbit_strikes + strike_index;
 
 
       sbit_metrics->x_ppem      = metrics->x_ppem;
@@ -728,7 +719,7 @@
     }
     else
     {
-      size->strike_index = 0xFFFF;
+      size->strike_index = 0xFFFFU;
 
       sbit_metrics->x_ppem      = 0;
       sbit_metrics->y_ppem      = 0;
@@ -747,7 +738,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Reset_Size                                                      */
+  /*    TT_Size_Reset                                                      */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Resets a TrueType size when resolutions and character dimensions   */
@@ -756,8 +747,8 @@
   /* <Input>                                                               */
   /*    size :: A handle to the target size object.                        */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_Reset_Size( TT_Size  size )
+  FT_LOCAL_DEF( FT_Error )
+  TT_Size_Reset( TT_Size  size )
   {
     FT_Face   face;
     FT_Error  error = TT_Err_Ok;
@@ -778,7 +769,7 @@
 
     if ( face->face_flags & FT_FACE_FLAG_FIXED_SIZES )
     {
-      if ( size->strike_index == 0xFFFF )
+      if ( size->strike_index == 0xFFFFU )
         error = Reset_SBit_Size( size );
 
       if ( !error && !( face->face_flags & FT_FACE_FLAG_SCALABLE ) )
@@ -797,7 +788,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Init_Driver                                                     */
+  /*    TT_Driver_Init                                                     */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Initializes a given TrueType driver object.                        */
@@ -808,22 +799,15 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
-  TT_Init_Driver( TT_Driver  driver )
+  FT_LOCAL_DEF( FT_Error )
+  TT_Driver_Init( TT_Driver  driver )
   {
     FT_Error  error;
 
 
     /* set `extra' in glyph loader */
-    error = FT_GlyphLoader_Create_Extra( FT_DRIVER( driver )->glyph_loader );
+    error = FT_GlyphLoader_CreateExtra( FT_DRIVER( driver )->glyph_loader );
 
-    /* init extension registry if needed */
-
-#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
-    if ( !error )
-      return TT_Init_Extensions( driver );
-#endif
-
     return error;
   }
 
@@ -831,7 +815,7 @@
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
-  /*    TT_Done_Driver                                                     */
+  /*    TT_Driver_Done                                                     */
   /*                                                                       */
   /* <Description>                                                         */
   /*    Finalizes a given TrueType driver.                                 */
@@ -839,17 +823,9 @@
   /* <Input>                                                               */
   /*    driver :: A handle to the target TrueType driver.                  */
   /*                                                                       */
-  FT_LOCAL_DEF void
-  TT_Done_Driver( TT_Driver  driver )
+  FT_LOCAL_DEF( void )
+  TT_Driver_Done( TT_Driver  driver )
   {
-    /* destroy extensions registry if needed */
-
-#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
-
-    TT_Done_Extensions( driver );
-
-#endif
-
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
 
     /* destroy the execution context */
Index: xc/extras/freetype2/src/truetype/ttobjs.h
diff -u xc/extras/freetype2/src/truetype/ttobjs.h:1.1.1.4 xc/extras/freetype2/src/truetype/ttobjs.h:1.1.1.5
--- xc/extras/freetype2/src/truetype/ttobjs.h:1.1.1.4	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/truetype/ttobjs.h	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Objects manager (specification).                                     */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -107,14 +107,14 @@
 
 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
 
-  FT_LOCAL void
-  TT_Done_GlyphZone( TT_GlyphZone*  zone );
+  FT_LOCAL( void )
+  TT_Done_GlyphZone( TT_GlyphZone  zone );
 
-  FT_LOCAL FT_Error
-  TT_New_GlyphZone( FT_Memory      memory,
-                    FT_UShort      maxPoints,
-                    FT_Short       maxContours,
-                    TT_GlyphZone*  zone );
+  FT_LOCAL( FT_Error )
+  TT_New_GlyphZone( FT_Memory     memory,
+                    FT_UShort     maxPoints,
+                    FT_Short      maxContours,
+                    TT_GlyphZone  zone );
 
 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
 
@@ -192,27 +192,27 @@
   /*                                                                       */
   typedef struct  TT_SubglyphRec_
   {
-    FT_Long       index;        /* subglyph index; initialized with -1 */
-    FT_Bool       is_scaled;    /* is the subglyph scaled?             */
-    FT_Bool       is_hinted;    /* should it be hinted?                */
-    FT_Bool       preserve_pps; /* preserve phantom points?            */
+    FT_Long          index;        /* subglyph index; initialized with -1 */
+    FT_Bool          is_scaled;    /* is the subglyph scaled?             */
+    FT_Bool          is_hinted;    /* should it be hinted?                */
+    FT_Bool          preserve_pps; /* preserve phantom points?            */
 
-    FT_Long       file_offset;
+    FT_Long          file_offset;
 
-    FT_BBox       bbox;
-    FT_Pos        left_bearing;
-    FT_Pos        advance;
+    FT_BBox          bbox;
+    FT_Pos           left_bearing;
+    FT_Pos           advance;
 
-    TT_GlyphZone  zone;
+    TT_GlyphZoneRec  zone;
 
-    FT_Long       arg1;         /* first argument                      */
-    FT_Long       arg2;         /* second argument                     */
+    FT_Long          arg1;         /* first argument                      */
+    FT_Long          arg2;         /* second argument                     */
 
-    FT_UShort     element_flag; /* current load element flag           */
+    FT_UShort        element_flag; /* current load element flag           */
 
-    TT_Transform  transform;    /* transformation matrix               */
+    TT_Transform     transform;    /* transformation matrix               */
 
-    FT_Vector     pp1, pp2;     /* phantom points                      */
+    FT_Vector        pp1, pp2;     /* phantom points                      */
 
   } TT_SubGlyphRec, *TT_SubGlyph_Stack;
 
@@ -343,7 +343,7 @@
     FT_UShort          storage_size; /* The storage area is now part of */
     FT_Long*           storage;      /* the instance                    */
 
-    TT_GlyphZone       twilight;     /* The instance's twilight zone    */
+    TT_GlyphZoneRec    twilight;     /* The instance's twilight zone    */
 
     /* debugging variables */
 
@@ -365,11 +365,11 @@
   /*                                                                       */
   typedef struct  TT_DriverRec_
   {
-    FT_DriverRec    root;
-    TT_ExecContext  context;  /* execution context        */
-    TT_GlyphZone    zone;     /* glyph loader points zone */
+    FT_DriverRec     root;
+    TT_ExecContext   context;  /* execution context        */
+    TT_GlyphZoneRec  zone;     /* glyph loader points zone */
 
-    void*           extension_component;
+    void*            extension_component;
 
   } TT_DriverRec;
 
@@ -378,40 +378,40 @@
   /*                                                                       */
   /* Face functions                                                        */
   /*                                                                       */
-  FT_LOCAL FT_Error
-  TT_Init_Face( FT_Stream      stream,
+  FT_LOCAL( FT_Error )
+  TT_Face_Init( FT_Stream      stream,
                 TT_Face        face,
                 FT_Int         face_index,
                 FT_Int         num_params,
                 FT_Parameter*  params );
 
-  FT_LOCAL void
-  TT_Done_Face( TT_Face  face );
+  FT_LOCAL( void )
+  TT_Face_Done( TT_Face  face );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* Size functions                                                        */
   /*                                                                       */
-  FT_LOCAL FT_Error
-  TT_Init_Size( TT_Size  size );
+  FT_LOCAL( FT_Error )
+  TT_Size_Init( TT_Size  size );
 
-  FT_LOCAL void
-  TT_Done_Size( TT_Size  size );
+  FT_LOCAL( void )
+  TT_Size_Done( TT_Size  size );
 
-  FT_LOCAL FT_Error
-  TT_Reset_Size( TT_Size  size );
+  FT_LOCAL( FT_Error )
+  TT_Size_Reset( TT_Size  size );
 
 
   /*************************************************************************/
   /*                                                                       */
   /* Driver functions                                                      */
   /*                                                                       */
-  FT_LOCAL FT_Error
-  TT_Init_Driver( TT_Driver  driver );
+  FT_LOCAL( FT_Error )
+  TT_Driver_Init( TT_Driver  driver );
 
-  FT_LOCAL void
-  TT_Done_Driver( TT_Driver  driver );
+  FT_LOCAL( void )
+  TT_Driver_Done( TT_Driver  driver );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/truetype/ttpload.c
diff -u xc/extras/freetype2/src/truetype/ttpload.c:1.1.1.4 xc/extras/freetype2/src/truetype/ttpload.c:1.1.1.5
--- xc/extras/freetype2/src/truetype/ttpload.c:1.1.1.4	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/truetype/ttpload.c	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType glyph data/program tables loader (body).                    */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -54,7 +54,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Locations( TT_Face    face,
                      FT_Stream  stream )
   {
@@ -80,12 +80,10 @@
 
       FT_TRACE2(( "(32bit offsets): %12d ", face->num_locations ));
 
-      if ( ALLOC_ARRAY( face->glyph_locations,
-                        face->num_locations,
-                        FT_Long ) )
+      if ( FT_NEW_ARRAY( face->glyph_locations, face->num_locations ) )
         goto Exit;
 
-      if ( ACCESS_Frame( face->num_locations * 4L ) )
+      if ( FT_FRAME_ENTER( face->num_locations * 4L ) )
         goto Exit;
 
       {
@@ -94,10 +92,10 @@
 
 
         for ( ; loc < limit; loc++ )
-          *loc = GET_Long();
+          *loc = FT_GET_LONG();
       }
 
-      FORGET_Frame();
+      FT_FRAME_EXIT();
     }
     else
     {
@@ -105,12 +103,10 @@
 
       FT_TRACE2(( "(16bit offsets): %12d ", face->num_locations ));
 
-      if ( ALLOC_ARRAY( face->glyph_locations,
-                        face->num_locations,
-                        FT_Long ) )
+      if ( FT_NEW_ARRAY( face->glyph_locations, face->num_locations ) )
         goto Exit;
 
-      if ( ACCESS_Frame( face->num_locations * 2L ) )
+      if ( FT_FRAME_ENTER( face->num_locations * 2L ) )
         goto Exit;
       {
         FT_Long*  loc   = face->glyph_locations;
@@ -118,9 +114,9 @@
 
 
         for ( ; loc < limit; loc++ )
-          *loc = (FT_Long)( (FT_ULong)GET_UShort() * 2 );
+          *loc = (FT_Long)( (FT_ULong)FT_GET_USHORT() * 2 );
       }
-      FORGET_Frame();
+      FT_FRAME_EXIT();
     }
 
     FT_TRACE2(( "loaded\n" ));
@@ -147,7 +143,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_CVT( TT_Face    face,
                FT_Stream  stream )
   {
@@ -172,12 +168,10 @@
 
     face->cvt_size = table_len / 2;
 
-    if ( ALLOC_ARRAY( face->cvt,
-                      face->cvt_size,
-                      FT_Short ) )
+    if ( FT_NEW_ARRAY( face->cvt, face->cvt_size ) )
       goto Exit;
 
-    if ( ACCESS_Frame( face->cvt_size * 2L ) )
+    if ( FT_FRAME_ENTER( face->cvt_size * 2L ) )
       goto Exit;
 
     {
@@ -186,10 +180,10 @@
 
 
       for ( ; cur <  limit; cur++ )
-        *cur = GET_Short();
+        *cur = FT_GET_SHORT();
     }
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
     FT_TRACE2(( "loaded\n" ));
 
   Exit:
@@ -214,7 +208,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   TT_Load_Programs( TT_Face    face,
                     FT_Stream  stream )
   {
@@ -236,7 +230,7 @@
     else
     {
       face->font_program_size = table_len;
-      if ( EXTRACT_Frame( table_len, face->font_program ) )
+      if ( FT_FRAME_EXTRACT( table_len, face->font_program ) )
         goto Exit;
 
       FT_TRACE2(( "loaded, %12d bytes\n", face->font_program_size ));
@@ -256,7 +250,7 @@
     else
     {
       face->cvt_program_size = table_len;
-      if ( EXTRACT_Frame( table_len, face->cvt_program ) )
+      if ( FT_FRAME_EXTRACT( table_len, face->cvt_program ) )
         goto Exit;
 
       FT_TRACE2(( "loaded, %12d bytes\n", face->cvt_program_size ));
Index: xc/extras/freetype2/src/truetype/ttpload.h
diff -u xc/extras/freetype2/src/truetype/ttpload.h:1.1.1.3 xc/extras/freetype2/src/truetype/ttpload.h:1.1.1.4
--- xc/extras/freetype2/src/truetype/ttpload.h:1.1.1.3	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/truetype/ttpload.h	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    TrueType glyph data/program tables loader (specification).           */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,15 +27,15 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Locations( TT_Face    face,
                      FT_Stream  stream );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_CVT( TT_Face    face,
                FT_Stream  stream );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   TT_Load_Programs( TT_Face    face,
                     FT_Stream  stream );
 
Index: xc/extras/freetype2/src/type1/descrip.mms
diff -u xc/extras/freetype2/src/type1/descrip.mms:1.1.1.1 xc/extras/freetype2/src/type1/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/type1/descrip.mms:1.1.1.1	Tue May 15 23:45:38 2001
+++ xc/extras/freetype2/src/type1/descrip.mms	Thu Jun 20 04:16:26 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,6 @@
 OBJS=type1.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/type1/rules.mk
diff -u xc/extras/freetype2/src/type1/rules.mk:1.1.1.3 xc/extras/freetype2/src/type1/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/type1/rules.mk:1.1.1.3	Sun Sep  9 22:56:11 2001
+++ xc/extras/freetype2/src/type1/rules.mk	Thu Jun 20 04:16:26 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/type1/t1afm.c
diff -u xc/extras/freetype2/src/type1/t1afm.c:1.1.1.4 xc/extras/freetype2/src/type1/t1afm.c:1.1.1.5
--- xc/extras/freetype2/src/type1/t1afm.c:1.1.1.4	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/type1/t1afm.c	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    AFM support for Type 1 fonts (body).                                 */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -20,9 +20,6 @@
 #include "t1afm.h"
 #include FT_INTERNAL_STREAM_H
 #include FT_INTERNAL_TYPE1_TYPES_H
-#include <stdlib.h>  /* for qsort()   */
-#include <string.h>  /* for strcmp()  */
-#include <ctype.h>   /* for isalnum() */
 
 
   /*************************************************************************/
@@ -35,29 +32,29 @@
 #define FT_COMPONENT  trace_t1afm
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_Done_AFM( FT_Memory  memory,
                T1_AFM*    afm )
   {
-    FREE( afm->kern_pairs );
+    FT_FREE( afm->kern_pairs );
     afm->num_pairs = 0;
-    FREE( afm );
+    FT_FREE( afm );
   }
 
 
 #undef  IS_KERN_PAIR
 #define IS_KERN_PAIR( p )  ( p[0] == 'K' && p[1] == 'P' )
 
-#define IS_ALPHANUM( c )  ( isalnum( c ) || \
-                            c == '_'     || \
-                            c == '.'     )
+#define IS_ALPHANUM( c )  ( ft_isalnum( c ) || \
+                            c == '_'        || \
+                            c == '.'        )
 
 
   /* read a glyph name and return the equivalent glyph index */
   static FT_UInt
   afm_atoindex( FT_Byte**  start,
                 FT_Byte*   limit,
-                T1_Font*   type1 )
+                T1_Font    type1 )
   {
     FT_Byte*  p = *start;
     FT_Int    len;
@@ -83,7 +80,7 @@
 
 
       /* copy glyph name to intermediate array */
-      MEM_Copy( temp, *start, len );
+      FT_MEM_COPY( temp, *start, len );
       temp[len] = 0;
 
       /* lookup glyph name in face array */
@@ -92,7 +89,7 @@
         char*  gname = (char*)type1->glyph_names[n];
 
 
-        if ( gname && gname[0] == temp[0] && strcmp( gname, temp ) == 0 )
+        if ( gname && gname[0] == temp[0] && ft_strcmp( gname, temp ) == 0 )
         {
           result = n;
           break;
@@ -156,7 +153,7 @@
 
 
   /* parse an AFM file -- for now, only read the kerning pairs */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Read_AFM( FT_Face    t1_face,
                FT_Stream  stream )
   {
@@ -167,11 +164,11 @@
     FT_Byte*       p;
     FT_Int         count = 0;
     T1_Kern_Pair*  pair;
-    T1_Font*       type1 = &((T1_Face)t1_face)->type1;
+    T1_Font        type1 = &((T1_Face)t1_face)->type1;
     T1_AFM*        afm   = 0;
 
 
-    if ( ACCESS_Frame( stream->size ) )
+    if ( FT_FRAME_ENTER( stream->size ) )
       return error;
 
     start = (FT_Byte*)stream->cursor;
@@ -192,8 +189,7 @@
       goto Exit;
 
     /* allocate the pairs */
-    if ( ALLOC( afm, sizeof ( *afm ) )                       ||
-         ALLOC_ARRAY( afm->kern_pairs, count, T1_Kern_Pair ) )
+    if ( FT_NEW( afm ) || FT_NEW_ARRAY( afm->kern_pairs, count ) )
       goto Exit;
 
     /* now, read each kern pair */
@@ -230,28 +226,28 @@
     }
 
     /* now, sort the kern pairs according to their glyph indices */
-    qsort( afm->kern_pairs, count, sizeof ( T1_Kern_Pair ),
-           compare_kern_pairs );
+    ft_qsort( afm->kern_pairs, count, sizeof ( T1_Kern_Pair ),
+              compare_kern_pairs );
 
   Exit:
     if ( error )
-      FREE( afm );
+      FT_FREE( afm );
 
-    FORGET_Frame();
+    FT_FRAME_EXIT();
 
     return error;
   }
 
 
   /* find the kerning for a given glyph pair */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_Get_Kerning( T1_AFM*     afm,
                   FT_UInt     glyph1,
                   FT_UInt     glyph2,
                   FT_Vector*  kerning )
   {
     T1_Kern_Pair  *min, *mid, *max;
-    FT_ULong      index = KERN_INDEX( glyph1, glyph2 );
+    FT_ULong      idx = KERN_INDEX( glyph1, glyph2 );
 
 
     /* simple binary search */
@@ -266,13 +262,13 @@
       mid  = min + ( max - min ) / 2;
       midi = KERN_INDEX( mid->glyph1, mid->glyph2 );
 
-      if ( midi == index )
+      if ( midi == idx )
       {
         *kerning = mid->kerning;
         return;
       }
 
-      if ( midi < index )
+      if ( midi < idx )
         min = mid + 1;
       else
         max = mid - 1;
Index: xc/extras/freetype2/src/type1/t1afm.h
diff -u xc/extras/freetype2/src/type1/t1afm.h:1.1.1.3 xc/extras/freetype2/src/type1/t1afm.h:1.1.1.4
--- xc/extras/freetype2/src/type1/t1afm.h:1.1.1.3	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/type1/t1afm.h	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    AFM support for Type 1 fonts (specification).                        */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -43,15 +43,15 @@
   } T1_AFM;
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Read_AFM( FT_Face    face,
                FT_Stream  stream );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_Done_AFM( FT_Memory  memory,
                T1_AFM*    afm );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_Get_Kerning( T1_AFM*     afm,
                   FT_UInt     glyph1,
                   FT_UInt     glyph2,
Index: xc/extras/freetype2/src/type1/t1driver.c
diff -u xc/extras/freetype2/src/type1/t1driver.c:1.1.1.5 xc/extras/freetype2/src/type1/t1driver.c:1.1.1.8
--- xc/extras/freetype2/src/type1/t1driver.c:1.1.1.5	Mon Jan 14 11:52:26 2002
+++ xc/extras/freetype2/src/type1/t1driver.c	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 driver interface (body).                                      */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -31,9 +31,7 @@
 #include FT_INTERNAL_STREAM_H
 #include FT_INTERNAL_POSTSCRIPT_NAMES_H
 
-#include <string.h>     /* for strcmp() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -57,13 +55,13 @@
 
     if ( buffer_max > 0 )
     {
-      FT_UInt  len = (FT_UInt)( strlen( gname ) );
+      FT_UInt  len = (FT_UInt)( ft_strlen( gname ) );
 
 
       if (len >= buffer_max)
         len = buffer_max - 1;
 
-      MEM_Copy( buffer, gname, len );
+      FT_MEM_COPY( buffer, gname, len );
       ((FT_Byte*)buffer)[len] = 0;
     }
 
@@ -100,7 +98,7 @@
     {
       gname = face->type1.glyph_names[i];
 
-      if ( !strcmp( glyph_name, gname ) )
+      if ( !ft_strcmp( glyph_name, gname ) )
         return (FT_UInt)i;
     }
 
@@ -109,7 +107,7 @@
 
 
   static const char*
-  t1_get_ps_name( T1_Face    face )
+  t1_get_ps_name( T1_Face  face )
   {
     return (const char*) face->type1.font_name;
   }
@@ -130,11 +128,11 @@
   /*     PostScript name of a given glyph index).                          */
   /*                                                                       */
   /* <InOut>                                                               */
-  /*    driver    :: A handle to a driver object.                          */
+  /*    driver       :: A handle to a driver object.                       */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    interface :: A string designing the interface.  Examples are       */
-  /*                 `sfnt', `post_names', `charmaps', etc.                */
+  /*    t1_interface :: A string designing the interface.  Examples are    */
+  /*                    `sfnt', `post_names', `charmaps', etc.             */
   /*                                                                       */
   /* <Return>                                                              */
   /*    A typeless pointer to the extension's interface (normally a table  */
@@ -144,28 +142,28 @@
   /*                                                                       */
   static FT_Module_Interface
   Get_Interface( FT_Driver         driver,
-                 const FT_String*  interface )
+                 const FT_String*  t1_interface )
   {
     FT_UNUSED( driver );
-    FT_UNUSED( interface );
+    FT_UNUSED( t1_interface );
 
-    if ( strcmp( (const char*)interface, "glyph_name" ) == 0 )
+    if ( ft_strcmp( (const char*)t1_interface, "glyph_name" ) == 0 )
       return (FT_Module_Interface)t1_get_glyph_name;
 
-    if ( strcmp( (const char*)interface, "name_index" ) == 0 )
+    if ( ft_strcmp( (const char*)t1_interface, "name_index" ) == 0 )
       return (FT_Module_Interface)t1_get_name_index;
 
-    if ( strcmp( (const char*)interface, "postscript_name" ) == 0 )
+    if ( ft_strcmp( (const char*)t1_interface, "postscript_name" ) == 0 )
       return (FT_Module_Interface)t1_get_ps_name;
 
 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
-    if ( strcmp( (const char*)interface, "get_mm" ) == 0 )
+    if ( ft_strcmp( (const char*)t1_interface, "get_mm" ) == 0 )
       return (FT_Module_Interface)T1_Get_Multi_Master;
 
-    if ( strcmp( (const char*)interface, "set_mm_design") == 0 )
+    if ( ft_strcmp( (const char*)t1_interface, "set_mm_design") == 0 )
       return (FT_Module_Interface)T1_Set_MM_Design;
 
-    if ( strcmp( (const char*)interface, "set_mm_blend") == 0 )
+    if ( ft_strcmp( (const char*)t1_interface, "set_mm_blend") == 0 )
       return (FT_Module_Interface)T1_Set_MM_Blend;
 #endif
     return 0;
@@ -239,6 +237,7 @@
   /*                                                                       */
   /* <Input>                                                               */
   /*    charmap  :: A handle to the source charmap object.                 */
+  /*                                                                       */
   /*    charcode :: The character code.                                    */
   /*                                                                       */
   /* <Return>                                                              */
@@ -248,13 +247,13 @@
   Get_Char_Index( FT_CharMap  charmap,
                   FT_Long     charcode )
   {
-    T1_Face             face;
-    FT_UInt             result = 0;
-    PSNames_Interface*  psnames;
+    T1_Face          face;
+    FT_UInt          result = 0;
+    PSNames_Service  psnames;
 
 
     face    = (T1_Face)charmap->face;
-    psnames = (PSNames_Interface*)face->psnames;
+    psnames = (PSNames_Service)face->psnames;
     if ( psnames )
       switch ( charmap->encoding )
       {
@@ -269,17 +268,35 @@
 
         /* the function returns 0xFFFF if the Unicode charcode has */
         /* no corresponding glyph                                  */
-        if ( result == 0xFFFF )
+        if ( result == 0xFFFFU )
           result = 0;
         goto Exit;
 
         /*******************************************************************/
         /*                                                                 */
+        /* ISOLatin1 encoding support                                      */
+        /*                                                                 */
+      case ft_encoding_latin_1:
+        /* ISOLatin1 is the first page of Unicode */
+        if ( charcode < 256 && psnames->unicode_value )
+        {
+          result = psnames->lookup_unicode( &face->unicode_map,
+                                            (FT_ULong)charcode );
+
+          /* the function returns 0xFFFF if the Unicode charcode has */
+          /* no corresponding glyph                                  */
+          if ( result == 0xFFFFU )
+            result = 0;
+        }
+        goto Exit;
+
+        /*******************************************************************/
+        /*                                                                 */
         /* Custom Type 1 encoding                                          */
         /*                                                                 */
       case ft_encoding_adobe_custom:
         {
-          T1_Encoding*  encoding = &face->type1.encoding;
+          T1_Encoding  encoding = &face->type1.encoding;
 
 
           if ( charcode >= encoding->code_first &&
@@ -314,7 +331,7 @@
 
 
             if ( gname && gname[0] == glyph_name[0] &&
-                 strcmp( gname, glyph_name ) == 0   )
+                 ft_strcmp( gname, glyph_name ) == 0   )
             {
               result = n;
               break;
@@ -327,14 +344,126 @@
   }
 
 
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Next_Char                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return the next encoded char.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*                                                                       */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next char code.  0 means `no more char codes'.                     */
+  /*                                                                       */
+  static FT_Long
+  Get_Next_Char( FT_CharMap  charmap,
+                 FT_Long     charcode )
+  {
+    T1_Face          face;
+    PSNames_Service  psnames;
+
+
+    face    = (T1_Face)charmap->face;
+    psnames = (PSNames_Service)face->psnames;
+
+    if ( psnames )
+      switch ( charmap->encoding )
+      {
+        /*******************************************************************/
+        /*                                                                 */
+        /* Unicode encoding support                                        */
+        /*                                                                 */
+      case ft_encoding_unicode:
+        /* use the `PSNames' module to synthetize the Unicode charmap */
+        return psnames->next_unicode( &face->unicode_map,
+                                      (FT_ULong)charcode );
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* ISOLatin1 encoding support                                      */
+        /*                                                                 */
+      case ft_encoding_latin_1:
+        {
+          FT_Long  code;
+
+
+          /* use the `PSNames' module to synthetize the Unicode charmap */
+          code = psnames->next_unicode( &face->unicode_map,
+                                        (FT_ULong)charcode );
+          if ( code < 256 )
+            return code;
+          break;
+        }
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Custom Type 1 encoding                                          */
+        /*                                                                 */
+      case ft_encoding_adobe_custom:
+        {
+          T1_Encoding  encoding = &face->type1.encoding;
+
+
+          charcode++;
+          if ( charcode < encoding->code_first )
+            charcode = encoding->code_first;
+          while ( charcode <= encoding->code_last  )
+          {
+            if ( encoding->char_index[charcode] )
+              return charcode;
+            charcode++;
+          }
+        }
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Adobe Standard & Expert encoding support                        */
+        /*                                                                 */
+      default:
+        while ( ++charcode < 256 )
+        {
+          FT_UInt      code;
+          FT_Int       n;
+          const char*  glyph_name;
+
+
+          code = psnames->adobe_std_encoding[charcode];
+          if ( charmap->encoding == ft_encoding_adobe_expert )
+            code = psnames->adobe_expert_encoding[charcode];
+
+          glyph_name = psnames->adobe_std_strings( code );
+          if ( !glyph_name )
+            continue;
+
+          for ( n = 0; n < face->type1.num_glyphs; n++ )
+          {
+            const char*  gname = face->type1.glyph_names[n];
+
+
+            if ( gname && gname[0] == glyph_name[0]  &&
+                 ft_strcmp( gname, glyph_name ) == 0 )
+              return charcode;
+          }
+        }
+      }
+
+    return 0;
+  }
+
+
   FT_CALLBACK_TABLE_DEF
-  const FT_Driver_Class  t1_driver_class =
+  const FT_Driver_ClassRec  t1_driver_class =
   {
     {
       ft_module_font_driver      |
-      ft_module_driver_scalable  | 
+      ft_module_driver_scalable  |
       ft_module_driver_has_hinter,
-      
+
       sizeof( FT_DriverRec ),
 
       "type1",
@@ -352,59 +481,29 @@
     sizeof( T1_SizeRec ),
     sizeof( T1_GlyphSlotRec ),
 
-    (FTDriver_initFace)     T1_Face_Init,
-    (FTDriver_doneFace)     T1_Face_Done,
-    (FTDriver_initSize)     T1_Size_Init,
-    (FTDriver_doneSize)     T1_Size_Done,
-    (FTDriver_initGlyphSlot)T1_GlyphSlot_Init,
-    (FTDriver_doneGlyphSlot)T1_GlyphSlot_Done,
-
-    (FTDriver_setCharSizes) T1_Size_Reset,
-    (FTDriver_setPixelSizes)T1_Size_Reset,
-    (FTDriver_loadGlyph)    T1_Load_Glyph,
-    (FTDriver_getCharIndex) Get_Char_Index,
+    (FT_Face_InitFunc)        T1_Face_Init,
+    (FT_Face_DoneFunc)        T1_Face_Done,
+    (FT_Size_InitFunc)        T1_Size_Init,
+    (FT_Size_DoneFunc)        T1_Size_Done,
+    (FT_Slot_InitFunc)        T1_GlyphSlot_Init,
+    (FT_Slot_DoneFunc)        T1_GlyphSlot_Done,
+
+    (FT_Size_ResetPointsFunc) T1_Size_Reset,
+    (FT_Size_ResetPixelsFunc) T1_Size_Reset,
+    (FT_Slot_LoadFunc)        T1_Load_Glyph,
+    (FT_CharMap_CharIndexFunc)Get_Char_Index,
 
 #ifdef T1_CONFIG_OPTION_NO_AFM
-    (FTDriver_getKerning)   0,
-    (FTDriver_attachFile)   0,
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
 #else
-    (FTDriver_getKerning)   Get_Kerning,
-    (FTDriver_attachFile)   T1_Read_AFM,
+    (FT_Face_GetKerningFunc)  Get_Kerning,
+    (FT_Face_AttachFunc)      T1_Read_AFM,
 #endif
-    (FTDriver_getAdvances)  0
-  };
-
+    (FT_Face_GetAdvancesFunc) 0,
 
-#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    getDriverClass                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    This function is used when compiling the TrueType driver as a      */
-  /*    shared library (`.DLL' or `.so').  It will be used by the          */
-  /*    high-level library of FreeType to retrieve the address of the      */
-  /*    driver's generic interface.                                        */
-  /*                                                                       */
-  /*    It shouldn't be implemented in a static build, as each driver must */
-  /*    have the same function as an exported entry point.                 */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The address of the TrueType's driver generic interface.  The       */
-  /*    format-specific interface can then be retrieved through the method */
-  /*    interface->get_format_interface.                                   */
-  /*                                                                       */
-  FT_EXPORT_DEF( const FT_Driver_Class* )
-  getDriverClass( void )
-  {
-    return &t1_driver_class;
-  }
-
-
-#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
+    (FT_CharMap_CharNextFunc) Get_Next_Char
+  };
 
 
 /* END */
Index: xc/extras/freetype2/src/type1/t1driver.c.save
diff -u /dev/null xc/extras/freetype2/src/type1/t1driver.c.save:1.2
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type1/t1driver.c.save	Fri Oct 25 11:01:05 2002
@@ -0,0 +1,541 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1driver.c                                                             */
+/*                                                                         */
+/*    Type 1 driver interface (body).                                      */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include "t1driver.h"
+#include "t1gload.h"
+#include "t1load.h"
+
+#include "t1errors.h"
+
+#ifndef T1_CONFIG_OPTION_NO_AFM
+#include "t1afm.h"
+#endif
+
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
+
+#include <string.h>     /* for strcmp() */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_t1driver
+
+
+  static FT_Error
+  t1_get_glyph_name( T1_Face     face,
+                     FT_UInt     glyph_index,
+                     FT_Pointer  buffer,
+                     FT_UInt     buffer_max )
+  {
+    FT_String*  gname;
+
+
+    gname = face->type1.glyph_names[glyph_index];
+
+    if ( buffer_max > 0 )
+    {
+      FT_UInt  len = (FT_UInt)( strlen( gname ) );
+
+
+      if (len >= buffer_max)
+        len = buffer_max - 1;
+
+      MEM_Copy( buffer, gname, len );
+      ((FT_Byte*)buffer)[len] = 0;
+    }
+
+    return T1_Err_Ok;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    t1_get_name_index                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses the Type 1 font's `glyph_names' table to find a given glyph   */
+  /*    name's glyph index.                                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to the source face object.                  */
+  /*                                                                       */
+  /*    glyph_name :: The glyph name.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index.  0 means `undefined character code'.                  */
+  /*                                                                       */
+  static FT_UInt
+  t1_get_name_index( T1_Face     face,
+                     FT_String*  glyph_name )
+  {
+    FT_Int      i;
+    FT_String*  gname;
+
+
+    for ( i = 0; i < face->type1.num_glyphs; i++ )
+    {
+      gname = face->type1.glyph_names[i];
+
+      if ( !strcmp( glyph_name, gname ) )
+        return (FT_UInt)i;
+    }
+
+    return 0;
+  }
+
+
+  static const char*
+  t1_get_ps_name( T1_Face    face )
+  {
+    return (const char*) face->type1.font_name;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Interface                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Each driver can provide one or more extensions to the base         */
+  /*    FreeType API.  These can be used to access format specific         */
+  /*    features (e.g., all TrueType/OpenType resources share a common     */
+  /*    file structure and common tables which can be accessed through the */
+  /*    `sfnt' interface), or more simply generic ones (e.g., the          */
+  /*    `postscript names' interface which can be used to retrieve the     */
+  /*     PostScript name of a given glyph index).                          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    driver    :: A handle to a driver object.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    interface :: A string designing the interface.  Examples are       */
+  /*                 `sfnt', `post_names', `charmaps', etc.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A typeless pointer to the extension's interface (normally a table  */
+  /*    of function pointers).  Returns NULL if the requested extension    */
+  /*    isn't available (i.e., wasn't compiled in the driver at build      */
+  /*    time).                                                             */
+  /*                                                                       */
+  static FT_Module_Interface
+  Get_Interface( FT_Driver         driver,
+                 const FT_String*  interface )
+  {
+    FT_UNUSED( driver );
+    FT_UNUSED( interface );
+
+    if ( strcmp( (const char*)interface, "glyph_name" ) == 0 )
+      return (FT_Module_Interface)t1_get_glyph_name;
+
+    if ( strcmp( (const char*)interface, "name_index" ) == 0 )
+      return (FT_Module_Interface)t1_get_name_index;
+
+    if ( strcmp( (const char*)interface, "postscript_name" ) == 0 )
+      return (FT_Module_Interface)t1_get_ps_name;
+
+#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
+    if ( strcmp( (const char*)interface, "get_mm" ) == 0 )
+      return (FT_Module_Interface)T1_Get_Multi_Master;
+
+    if ( strcmp( (const char*)interface, "set_mm_design") == 0 )
+      return (FT_Module_Interface)T1_Set_MM_Design;
+
+    if ( strcmp( (const char*)interface, "set_mm_blend") == 0 )
+      return (FT_Module_Interface)T1_Set_MM_Blend;
+#endif
+    return 0;
+  }
+
+
+#ifndef T1_CONFIG_OPTION_NO_AFM
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Kerning                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A driver method used to return the kerning vector between two      */
+  /*    glyphs of the same face.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to the source face object.                 */
+  /*                                                                       */
+  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
+  /*                                                                       */
+  /*    right_glyph :: The index of the right glyph in the kern pair.      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    kerning     :: The kerning vector.  This is in font units for      */
+  /*                   scalable formats, and in pixels for fixed-sizes     */
+  /*                   formats.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
+  /*    supported by this function.  Other layouts, or more sophisticated  */
+  /*    kernings are out of scope of this method (the basic driver         */
+  /*    interface is meant to be simple).                                  */
+  /*                                                                       */
+  /*    They can be implemented by format-specific interfaces.             */
+  /*                                                                       */
+  static FT_Error
+  Get_Kerning( T1_Face     face,
+               FT_UInt     left_glyph,
+               FT_UInt     right_glyph,
+               FT_Vector*  kerning )
+  {
+    T1_AFM*  afm;
+
+
+    kerning->x = 0;
+    kerning->y = 0;
+
+    afm = (T1_AFM*)face->afm_data;
+    if ( afm )
+      T1_Get_Kerning( afm, left_glyph, right_glyph, kerning );
+
+    return T1_Err_Ok;
+  }
+
+
+#endif /* T1_CONFIG_OPTION_NO_AFM */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Char_Index                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return a given character code's glyph index.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Glyph index.  0 means `undefined character code'.                  */
+  /*                                                                       */
+  static FT_UInt
+  Get_Char_Index( FT_CharMap  charmap,
+                  FT_Long     charcode )
+  {
+    T1_Face             face;
+    FT_UInt             result = 0;
+    PSNames_Interface*  psnames;
+
+
+    face    = (T1_Face)charmap->face;
+    psnames = (PSNames_Interface*)face->psnames;
+    if ( psnames )
+      switch ( charmap->encoding )
+      {
+        /*******************************************************************/
+        /*                                                                 */
+        /* Unicode encoding support                                        */
+        /*                                                                 */
+      case ft_encoding_unicode:
+        /* use the `PSNames' module to synthetize the Unicode charmap */
+        result = psnames->lookup_unicode( &face->unicode_map,
+                                          (FT_ULong)charcode );
+
+        /* the function returns 0xFFFF if the Unicode charcode has */
+        /* no corresponding glyph                                  */
+        if ( result == 0xFFFF )
+          result = 0;
+        goto Exit;
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* ISOLatin1 encoding support                                      */
+        /*                                                                 */
+      case ft_encoding_latin_1:
+        /* ISOLatin1 is the first page of Unicode */
+        if ( charcode < 256 && psnames->unicode_value )
+        {
+          result = psnames->lookup_unicode( &face->unicode_map,
+                                            (FT_ULong)charcode );
+
+          /* the function returns 0xFFFF if the Unicode charcode has */
+          /* no corresponding glyph                                  */
+          if ( result == 0xFFFF )
+            result = 0;
+        }
+        goto Exit;
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Custom Type 1 encoding                                          */
+        /*                                                                 */
+      case ft_encoding_adobe_custom:
+        {
+          T1_Encoding*  encoding = &face->type1.encoding;
+
+
+          if ( charcode >= encoding->code_first &&
+               charcode <= encoding->code_last  )
+            result = encoding->char_index[charcode];
+          goto Exit;
+        }
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Adobe Standard & Expert encoding support                        */
+        /*                                                                 */
+      default:
+        if ( charcode < 256 )
+        {
+          FT_UInt      code;
+          FT_Int       n;
+          const char*  glyph_name;
+
+
+          code = psnames->adobe_std_encoding[charcode];
+          if ( charmap->encoding == ft_encoding_adobe_expert )
+            code = psnames->adobe_expert_encoding[charcode];
+
+          glyph_name = psnames->adobe_std_strings( code );
+          if ( !glyph_name )
+            break;
+
+          for ( n = 0; n < face->type1.num_glyphs; n++ )
+          {
+            const char*  gname = face->type1.glyph_names[n];
+
+
+            if ( gname && gname[0] == glyph_name[0] &&
+                 strcmp( gname, glyph_name ) == 0   )
+            {
+              result = n;
+              break;
+            }
+          }
+        }
+      }
+  Exit:
+    return result;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    Get_Next_Char                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Uses a charmap to return the next encoded char.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap  :: A handle to the source charmap object.                 */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Next char code.  0 means `no more char codes'.                     */
+  /*                                                                       */
+  static FT_Long
+  Get_Next_Char( FT_CharMap  charmap,
+                 FT_Long     charcode )
+  {
+    T1_Face             face;
+    PSNames_Interface*  psnames;
+
+
+    face    = (T1_Face)charmap->face;
+    psnames = (PSNames_Interface*)face->psnames;
+
+    if ( psnames )
+      switch ( charmap->encoding )
+      {
+        /*******************************************************************/
+        /*                                                                 */
+        /* Unicode encoding support                                        */
+        /*                                                                 */
+      case ft_encoding_unicode:
+        /* use the `PSNames' module to synthetize the Unicode charmap */
+        return psnames->next_unicode( &face->unicode_map,
+                                      (FT_ULong)charcode );
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* ISOLatin1 encoding support                                      */
+        /*                                                                 */
+      case ft_encoding_latin_1:
+        {
+          FT_Long code;
+
+
+          /* use the `PSNames' module to synthetize the Unicode charmap */
+          code = psnames->next_unicode( &face->unicode_map,
+                                        (FT_ULong)charcode );
+          if ( code < 256 )
+            return code;
+          break;
+        }
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Custom Type 1 encoding                                          */
+        /*                                                                 */
+      case ft_encoding_adobe_custom:
+        {
+          T1_Encoding*  encoding = &face->type1.encoding;
+
+
+          charcode++;
+          if ( charcode < encoding->code_first )
+            charcode = encoding->code_first;
+          while ( charcode <= encoding->code_last  )
+          {
+            if ( encoding->char_index[charcode] )
+              return charcode;
+            charcode++;
+          }
+        }
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Adobe Standard & Expert encoding support                        */
+        /*                                                                 */
+      default:
+        while ( ++charcode < 256 )
+        {
+          FT_UInt      code;
+          FT_Int       n;
+          const char*  glyph_name;
+
+
+          code = psnames->adobe_std_encoding[charcode];
+          if ( charmap->encoding == ft_encoding_adobe_expert )
+            code = psnames->adobe_expert_encoding[charcode];
+
+          glyph_name = psnames->adobe_std_strings( code );
+          if ( !glyph_name )
+            continue;
+
+          for ( n = 0; n < face->type1.num_glyphs; n++ )
+          {
+            const char*  gname = face->type1.glyph_names[n];
+
+
+            if ( gname && gname[0] == glyph_name[0] &&
+                 strcmp( gname, glyph_name ) == 0   )
+              return charcode;
+          }
+        }
+      }
+
+    return 0;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_Class  t1_driver_class =
+  {
+    {
+      ft_module_font_driver      |
+      ft_module_driver_scalable  |
+      ft_module_driver_has_hinter,
+
+      sizeof( FT_DriverRec ),
+
+      "type1",
+      0x10000L,
+      0x20000L,
+
+      0,   /* format interface */
+
+      (FT_Module_Constructor)T1_Driver_Init,
+      (FT_Module_Destructor) T1_Driver_Done,
+      (FT_Module_Requester)  Get_Interface,
+    },
+
+    sizeof( T1_FaceRec ),
+    sizeof( T1_SizeRec ),
+    sizeof( T1_GlyphSlotRec ),
+
+    (FTDriver_initFace)     T1_Face_Init,
+    (FTDriver_doneFace)     T1_Face_Done,
+    (FTDriver_initSize)     T1_Size_Init,
+    (FTDriver_doneSize)     T1_Size_Done,
+    (FTDriver_initGlyphSlot)T1_GlyphSlot_Init,
+    (FTDriver_doneGlyphSlot)T1_GlyphSlot_Done,
+
+    (FTDriver_setCharSizes) T1_Size_Reset,
+    (FTDriver_setPixelSizes)T1_Size_Reset,
+    (FTDriver_loadGlyph)    T1_Load_Glyph,
+    (FTDriver_getCharIndex) Get_Char_Index,
+
+#ifdef T1_CONFIG_OPTION_NO_AFM
+    (FTDriver_getKerning)   0,
+    (FTDriver_attachFile)   0,
+#else
+    (FTDriver_getKerning)   Get_Kerning,
+    (FTDriver_attachFile)   T1_Read_AFM,
+#endif
+    (FTDriver_getAdvances)  0,
+
+    (FTDriver_getNextChar)  Get_Next_Char
+  };
+
+
+#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    getDriverClass                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used when compiling the TrueType driver as a      */
+  /*    shared library (`.DLL' or `.so').  It will be used by the          */
+  /*    high-level library of FreeType to retrieve the address of the      */
+  /*    driver's generic interface.                                        */
+  /*                                                                       */
+  /*    It shouldn't be implemented in a static build, as each driver must */
+  /*    have the same function as an exported entry point.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of the TrueType's driver generic interface.  The       */
+  /*    format-specific interface can then be retrieved through the method */
+  /*    interface->get_format_interface.                                   */
+  /*                                                                       */
+  FT_EXPORT_DEF( const FT_Driver_Class* )
+  getDriverClass( void )
+  {
+    return &t1_driver_class;
+  }
+
+
+#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
+
+
+/* END */
Index: xc/extras/freetype2/src/type1/t1driver.h
diff -u xc/extras/freetype2/src/type1/t1driver.h:1.1.1.3 xc/extras/freetype2/src/type1/t1driver.h:1.1.1.4
--- xc/extras/freetype2/src/type1/t1driver.h:1.1.1.3	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/type1/t1driver.h	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    High-level Type 1 driver interface (specification).                  */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,7 +27,7 @@
 FT_BEGIN_HEADER
 
 
-  FT_EXPORT_VAR( const FT_Driver_Class )  t1_driver_class;
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  t1_driver_class;
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/type1/t1gload.c
diff -u xc/extras/freetype2/src/type1/t1gload.c:1.1.1.5 xc/extras/freetype2/src/type1/t1gload.c:1.1.1.6
--- xc/extras/freetype2/src/type1/t1gload.c:1.1.1.5	Mon Jan 14 11:52:26 2002
+++ xc/extras/freetype2/src/type1/t1gload.c	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 Glyph Loader (body).                                          */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -25,9 +25,7 @@
 
 #include "t1errors.h"
 
-#include <string.h>     /* for strcmp() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -56,11 +54,11 @@
 
 
   FT_CALLBACK_DEF( FT_Error )
-  T1_Parse_Glyph( T1_Decoder*  decoder,
-                  FT_UInt      glyph_index )
+  T1_Parse_Glyph( T1_Decoder  decoder,
+                  FT_UInt     glyph_index )
   {
-    T1_Face   face  = (T1_Face)decoder->builder.face;
-    T1_Font*  type1 = &face->type1;
+    T1_Face  face  = (T1_Face)decoder->builder.face;
+    T1_Font  type1 = &face->type1;
 
 
     decoder->font_matrix = type1->font_matrix;
@@ -73,15 +71,15 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Compute_Max_Advance( T1_Face  face,
                           FT_Int*  max_advance )
   {
-    FT_Error          error;
-    T1_Decoder        decoder;
-    FT_Int            glyph_index;
-    T1_Font*          type1 = &face->type1;
-    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;
+    FT_Error       error;
+    T1_DecoderRec  decoder;
+    FT_Int         glyph_index;
+    T1_Font        type1 = &face->type1;
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
 
 
     *max_advance = 0;
@@ -105,16 +103,20 @@
     decoder.subrs     = type1->subrs;
     decoder.subrs_len = type1->subrs_len;
 
+    *max_advance = 0;
+
     /* for each glyph, parse the glyph charstring and extract */
     /* the advance width                                      */
     for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ )
     {
       /* now get load the unscaled outline */
       error = T1_Parse_Glyph( &decoder, glyph_index );
+      if ( glyph_index == 0 || decoder.builder.advance.x > *max_advance )
+        *max_advance = decoder.builder.advance.x;
+        
       /* ignore the error if one occured - skip to next glyph */
     }
 
-    *max_advance = decoder.builder.advance.x;
     return T1_Err_Ok;
   }
 
@@ -136,22 +138,23 @@
   /*************************************************************************/
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Load_Glyph( T1_GlyphSlot  glyph,
                  T1_Size       size,
-                 FT_Int        glyph_index,
+                 FT_UInt       glyph_index,
                  FT_Int        load_flags )
   {
     FT_Error                error;
-    T1_Decoder              decoder;
+    T1_DecoderRec           decoder;
     T1_Face                 face = (T1_Face)glyph->root.face;
     FT_Bool                 hinting;
-    T1_Font*                type1         = &face->type1;
-    PSAux_Interface*        psaux         = (PSAux_Interface*)face->psaux;
-    const T1_Decoder_Funcs* decoder_funcs = psaux->t1_decoder_funcs;
+    T1_Font                 type1         = &face->type1;
+    PSAux_Service           psaux         = (PSAux_Service)face->psaux;
+    const T1_Decoder_Funcs  decoder_funcs = psaux->t1_decoder_funcs;
 
     FT_Matrix               font_matrix;
     FT_Vector               font_offset;
+
 
     if ( load_flags & FT_LOAD_NO_RECURSE )
       load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
Index: xc/extras/freetype2/src/type1/t1gload.h
diff -u xc/extras/freetype2/src/type1/t1gload.h:1.1.1.3 xc/extras/freetype2/src/type1/t1gload.h:1.1.1.4
--- xc/extras/freetype2/src/type1/t1gload.h:1.1.1.3	Sun Dec 16 12:49:36 2001
+++ xc/extras/freetype2/src/type1/t1gload.h	Thu Jun 20 04:16:26 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 Glyph Loader (specification).                                 */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,14 +27,14 @@
 FT_BEGIN_HEADER
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Compute_Max_Advance( T1_Face  face,
                           FT_Int*  max_advance );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Load_Glyph( T1_GlyphSlot  glyph,
                  T1_Size       size,
-                 FT_Int        glyph_index,
+                 FT_UInt       glyph_index,
                  FT_Int        load_flags );
 
 
Index: xc/extras/freetype2/src/type1/t1load.c
diff -u xc/extras/freetype2/src/type1/t1load.c:1.1.1.5 xc/extras/freetype2/src/type1/t1load.c:1.1.1.8
--- xc/extras/freetype2/src/type1/t1load.c:1.1.1.5	Mon Jan 14 11:52:27 2002
+++ xc/extras/freetype2/src/type1/t1load.c	Thu Jun 20 04:16:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 font loader (body).                                           */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -68,11 +68,8 @@
 #include FT_INTERNAL_TYPE1_TYPES_H
 
 #include "t1load.h"
-
 #include "t1errors.h"
 
-#include <string.h>     /* for strncmp(), strcmp() */
-#include <ctype.h>      /* for isalnum()           */
 
 
   /*************************************************************************/
@@ -101,7 +98,7 @@
                      FT_UInt  num_designs,
                      FT_UInt  num_axis )
   {
-    T1_Blend*  blend;
+    PS_Blend   blend;
     FT_Memory  memory = face->root.memory;
     FT_Error   error  = 0;
 
@@ -109,7 +106,7 @@
     blend = face->blend;
     if ( !blend )
     {
-      if ( ALLOC( blend, sizeof ( *blend ) ) )
+      if ( FT_NEW( blend ) )
         goto Exit;
 
       face->blend = blend;
@@ -124,9 +121,9 @@
 
 
         /* allocate the blend `private' and `font_info' dictionaries */
-        if ( ALLOC_ARRAY( blend->font_infos[1], num_designs, T1_FontInfo )  ||
-             ALLOC_ARRAY( blend->privates[1], num_designs, T1_Private )     ||
-             ALLOC_ARRAY( blend->weight_vector, num_designs * 2, FT_Fixed ) )
+        if ( FT_NEW_ARRAY( blend->font_infos[1], num_designs     ) ||
+             FT_NEW_ARRAY( blend->privates[1], num_designs       ) ||
+             FT_NEW_ARRAY( blend->weight_vector, num_designs * 2 ) )
           goto Exit;
 
         blend->default_weight_vector = blend->weight_vector + num_designs;
@@ -163,8 +160,7 @@
       FT_UInt  n;
 
 
-      if ( ALLOC_ARRAY( blend->design_pos[0],
-                        num_designs * num_axis, FT_Fixed ) )
+      if ( FT_NEW_ARRAY( blend->design_pos[0], num_designs * num_axis ) )
         goto Exit;
 
       for ( n = 1; n < num_designs; n++ )
@@ -180,13 +176,13 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Get_Multi_Master( T1_Face           face,
                        FT_Multi_Master*  master )
   {
-    T1_Blend*  blend = face->blend;
-    FT_UInt    n;
-    FT_Error   error;
+    PS_Blend  blend = face->blend;
+    FT_UInt   n;
+    FT_Error  error;
 
 
     error = T1_Err_Invalid_Argument;
@@ -198,8 +194,8 @@
 
       for ( n = 0; n < blend->num_axis; n++ )
       {
-        FT_MM_Axis*    axis = master->axis + n;
-        T1_DesignMap*  map = blend->design_map + n;
+        FT_MM_Axis*   axis = master->axis + n;
+        PS_DesignMap  map = blend->design_map + n;
 
 
         axis->name    = blend->axis_names[n];
@@ -212,14 +208,14 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Set_MM_Blend( T1_Face    face,
                    FT_UInt    num_coords,
                    FT_Fixed*  coords )
   {
-    T1_Blend*  blend = face->blend;
-    FT_Error   error;
-    FT_UInt    n, m;
+    PS_Blend  blend = face->blend;
+    FT_Error  error;
+    FT_UInt   n, m;
 
 
     error = T1_Err_Invalid_Argument;
@@ -258,14 +254,14 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Set_MM_Design( T1_Face   face,
                     FT_UInt   num_coords,
                     FT_Long*  coords )
   {
-    T1_Blend*  blend = face->blend;
-    FT_Error   error;
-    FT_UInt    n, p;
+    PS_Blend  blend = face->blend;
+    FT_Error  error;
+    FT_UInt   n, p;
 
 
     error = T1_Err_Invalid_Argument;
@@ -277,13 +273,14 @@
 
       for ( n = 0; n < blend->num_axis; n++ )
       {
-        FT_Long        design  = coords[n];
-        FT_Fixed       the_blend;
-        T1_DesignMap*  map     = blend->design_map + n;
-        FT_Fixed*      designs = map->design_points;
-        FT_Fixed*      blends  = map->blend_points;
-        FT_Int         before  = -1, after = -1;
+        FT_Long       design  = coords[n];
+        FT_Fixed      the_blend;
+        PS_DesignMap  map     = blend->design_map + n;
+        FT_Fixed*     designs = map->design_points;
+        FT_Fixed*     blends  = map->blend_points;
+        FT_Int        before  = -1, after = -1;
 
+
         for ( p = 0; p < (FT_UInt)map->num_points; p++ )
         {
           FT_Fixed  p_design = designs[p];
@@ -328,11 +325,11 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_Done_Blend( T1_Face  face )
   {
     FT_Memory  memory = face->root.memory;
-    T1_Blend*  blend  = face->blend;
+    PS_Blend   blend  = face->blend;
 
 
     if ( blend )
@@ -343,13 +340,13 @@
 
 
       /* release design pos table */
-      FREE( blend->design_pos[0] );
+      FT_FREE( blend->design_pos[0] );
       for ( n = 1; n < num_designs; n++ )
         blend->design_pos[n] = 0;
 
       /* release blend `private' and `font info' dictionaries */
-      FREE( blend->privates[1] );
-      FREE( blend->font_infos[1] );
+      FT_FREE( blend->privates[1] );
+      FT_FREE( blend->font_infos[1] );
 
       for ( n = 0; n < num_designs; n++ )
       {
@@ -358,37 +355,37 @@
       }
 
       /* release weight vectors */
-      FREE( blend->weight_vector );
+      FT_FREE( blend->weight_vector );
       blend->default_weight_vector = 0;
 
       /* release axis names */
       for ( n = 0; n < num_axis; n++ )
-        FREE( blend->axis_names[n] );
+        FT_FREE( blend->axis_names[n] );
 
       /* release design map */
       for ( n = 0; n < num_axis; n++ )
       {
-        T1_DesignMap*  dmap = blend->design_map + n;
+        PS_DesignMap  dmap = blend->design_map + n;
 
 
-        FREE( dmap->design_points );
+        FT_FREE( dmap->design_points );
         dmap->num_points = 0;
       }
 
-      FREE( face->blend );
+      FT_FREE( face->blend );
     }
   }
 
 
   static void
-  parse_blend_axis_types( T1_Face     face,
-                          T1_Loader*  loader )
+  parse_blend_axis_types( T1_Face    face,
+                          T1_Loader  loader )
   {
-    T1_Token   axis_tokens[ T1_MAX_MM_AXIS ];
-    FT_Int     n, num_axis;
-    FT_Error   error = 0;
-    T1_Blend*  blend;
-    FT_Memory  memory;
+    T1_TokenRec  axis_tokens[ T1_MAX_MM_AXIS ];
+    FT_Int       n, num_axis;
+    FT_Error     error = 0;
+    PS_Blend     blend;
+    FT_Memory    memory;
 
 
     /* take an array of objects */
@@ -413,12 +410,13 @@
     /* each token is an immediate containing the name of the axis */
     for ( n = 0; n < num_axis; n++ )
     {
-      T1_Token*  token = axis_tokens + n;
-      FT_Byte*   name;
-      FT_Int     len;
+      T1_Token  token = axis_tokens + n;
+      FT_Byte*  name;
+      FT_Int    len;
+
 
       /* skip first slash, if any */
-      if (token->start[0] == '/')
+      if ( token->start[0] == '/' )
         token->start++;
 
       len = (FT_Int)( token->limit - token->start );
@@ -428,11 +426,11 @@
         goto Exit;
       }
 
-      if ( ALLOC( blend->axis_names[n], len + 1 ) )
+      if ( FT_ALLOC( blend->axis_names[n], len + 1 ) )
         goto Exit;
 
       name = (FT_Byte*)blend->axis_names[n];
-      MEM_Copy( name, token->start, len );
+      FT_MEM_COPY( name, token->start, len );
       name[len] = 0;
     }
 
@@ -442,16 +440,16 @@
 
 
   static void
-  parse_blend_design_positions( T1_Face     face,
-                                T1_Loader*  loader )
+  parse_blend_design_positions( T1_Face    face,
+                                T1_Loader  loader )
   {
-    T1_Token       design_tokens[ T1_MAX_MM_DESIGNS ];
-    FT_Int         num_designs;
-    FT_Int         num_axis;
-    T1_ParserRec*  parser = &loader->parser;
+    T1_TokenRec  design_tokens[ T1_MAX_MM_DESIGNS ];
+    FT_Int       num_designs;
+    FT_Int       num_axis;
+    T1_Parser    parser = &loader->parser;
 
-    FT_Error       error = 0;
-    T1_Blend*      blend;
+    FT_Error     error = 0;
+    PS_Blend     blend;
 
 
     /* get the array of design tokens - compute number of designs */
@@ -476,9 +474,9 @@
 
       for ( n = 0; n < (FT_UInt)num_designs; n++ )
       {
-        T1_Token   axis_tokens[ T1_MAX_MM_DESIGNS ];
-        T1_Token*  token;
-        FT_Int     axis, n_axis;
+        T1_TokenRec  axis_tokens[ T1_MAX_MM_DESIGNS ];
+        T1_Token     token;
+        FT_Int       axis, n_axis;
 
 
         /* read axis/coordinates tokens */
@@ -505,7 +503,7 @@
         /* now, read each axis token into the design position */
         for ( axis = 0; axis < n_axis; axis++ )
         {
-          T1_Token*  token2 = axis_tokens + axis;
+          T1_Token  token2 = axis_tokens + axis;
 
 
           parser->root.cursor = token2->start;
@@ -524,17 +522,17 @@
 
 
   static void
-  parse_blend_design_map( T1_Face     face,
-                          T1_Loader*  loader )
+  parse_blend_design_map( T1_Face    face,
+                          T1_Loader  loader )
   {
-    FT_Error       error  = 0;
-    T1_ParserRec*  parser = &loader->parser;
-    T1_Blend*      blend;
-    T1_Token       axis_tokens[ T1_MAX_MM_AXIS ];
-    FT_Int         n, num_axis;
-    FT_Byte*       old_cursor;
-    FT_Byte*       old_limit;
-    FT_Memory      memory = face->root.memory;
+    FT_Error     error  = 0;
+    T1_Parser    parser = &loader->parser;
+    PS_Blend     blend;
+    T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];
+    FT_Int       n, num_axis;
+    FT_Byte*     old_cursor;
+    FT_Byte*     old_limit;
+    FT_Memory    memory = face->root.memory;
 
 
     T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &num_axis );
@@ -556,8 +554,8 @@
     /* now, read each axis design map */
     for ( n = 0; n < num_axis; n++ )
     {
-      T1_DesignMap* map = blend->design_map + n;
-      T1_Token*     token;
+      PS_DesignMap  map = blend->design_map + n;
+      T1_Token      token;
       FT_Int        p, num_points;
 
 
@@ -584,7 +582,7 @@
       }
 
       /* allocate design map data */
-      if ( ALLOC_ARRAY( map->design_points, num_points * 2, FT_Fixed ) )
+      if ( FT_NEW_ARRAY( map->design_points, num_points * 2 ) )
         goto Exit;
       map->blend_points = map->design_points + num_points;
       map->num_points   = (FT_Byte)num_points;
@@ -605,16 +603,16 @@
 
 
   static void
-  parse_weight_vector( T1_Face     face,
-                       T1_Loader*  loader )
+  parse_weight_vector( T1_Face    face,
+                       T1_Loader  loader )
   {
-    FT_Error       error  = 0;
-    T1_ParserRec*  parser = &loader->parser;
-    T1_Blend*      blend  = face->blend;
-    T1_Token       master;
-    FT_UInt        n;
-    FT_Byte*       old_cursor;
-    FT_Byte*       old_limit;
+    FT_Error     error  = 0;
+    T1_Parser    parser = &loader->parser;
+    PS_Blend     blend  = face->blend;
+    T1_TokenRec  master;
+    FT_UInt      n;
+    FT_Byte*     old_cursor;
+    FT_Byte*     old_limit;
 
 
     if ( !blend || blend->num_designs == 0 )
@@ -625,7 +623,7 @@
     }
 
     T1_ToToken( parser, &master );
-    if ( master.type != t1_token_array )
+    if ( master.type != T1_TOKEN_TYPE_ARRAY )
     {
       FT_ERROR(( "parse_weight_vector: incorrect format!\n" ));
       error = T1_Err_Invalid_File_Format;
@@ -657,10 +655,10 @@
   /* of spec!); we detect it and terminate the parsing                 */
   /*                                                                   */
   static void
-  parse_shared_dict( T1_Face     face,
-                     T1_Loader*  loader )
+  parse_shared_dict( T1_Face    face,
+                     T1_Loader  loader )
   {
-    T1_ParserRec*  parser = &loader->parser;
+    T1_Parser  parser = &loader->parser;
 
     FT_UNUSED( face );
 
@@ -684,25 +682,25 @@
   /*************************************************************************/
   /*                                                                       */
   /* First of all, define the token field static variables.  This is a set */
-  /* of T1_Field variables used later.                                     */
+  /* of T1_FieldRec variables used later.                                  */
   /*                                                                       */
   /*************************************************************************/
 
 
   static FT_Error
-  t1_load_keyword( T1_Face     face,
-                   T1_Loader*  loader,
-                   T1_Field*   field )
-  {
-    FT_Error   error;
-    void*      dummy_object;
-    void**     objects;
-    FT_UInt    max_objects;
-    T1_Blend*  blend = face->blend;
+  t1_load_keyword( T1_Face    face,
+                   T1_Loader  loader,
+                   T1_Field   field )
+  {
+    FT_Error  error;
+    void*     dummy_object;
+    void**    objects;
+    FT_UInt   max_objects;
+    PS_Blend  blend = face->blend;
 
 
     /* if the keyword has a dedicated callback, call it */
-    if ( field->type == t1_field_callback )
+    if ( field->type == T1_FIELD_TYPE_CALLBACK )
     {
       field->reader( (FT_Face)face, loader );
       error = loader->parser.root.error;
@@ -713,7 +711,7 @@
     /* we are now going to take care of it                              */
     switch ( field->location )
     {
-    case t1_field_font_info:
+    case T1_FIELD_LOCATION_FONT_INFO:
       dummy_object = &face->type1.font_info;
       objects      = &dummy_object;
       max_objects  = 0;
@@ -725,7 +723,7 @@
       }
       break;
 
-    case t1_field_private:
+    case T1_FIELD_LOCATION_PRIVATE:
       dummy_object = &face->type1.private_dict;
       objects      = &dummy_object;
       max_objects  = 0;
@@ -743,8 +741,8 @@
       max_objects  = 0;
     }
 
-    if ( field->type == t1_field_integer_array ||
-         field->type == t1_field_fixed_array   )
+    if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
+         field->type == T1_FIELD_TYPE_FIXED_ARRAY   )
       error = T1_Load_Field_Table( &loader->parser, field,
                                    objects, max_objects, 0 );
     else
@@ -769,14 +767,18 @@
     /* Note: we must accept "+" as a valid character, as it is used in */
     /*       embedded type1 fonts in PDF documents.                    */
     /*                                                                 */
-    return ( isalnum( c ) || c == '.' || c == '_' || c == '-' || c == '+' );
+    return ( ft_isalnum( c ) ||
+             c == '.'        ||
+             c == '_'        ||
+             c == '-'        ||
+             c == '+'        );
   }
 
 
   static int
-  read_binary_data( T1_ParserRec*  parser,
-                    FT_Int*        size,
-                    FT_Byte**      base )
+  read_binary_data( T1_Parser  parser,
+                    FT_Int*    size,
+                    FT_Byte**  base )
   {
     FT_Byte*  cur;
     FT_Byte*  limit = parser->root.limit;
@@ -816,16 +818,16 @@
   /* dictionaries                                   */
 
   static void
-  parse_font_name( T1_Face     face,
-                   T1_Loader*  loader )
+  parse_font_name( T1_Face    face,
+                   T1_Loader  loader )
   {
-    T1_ParserRec*  parser = &loader->parser;
-    FT_Error       error;
-    FT_Memory      memory = parser->root.memory;
-    FT_Int         len;
-    FT_Byte*       cur;
-    FT_Byte*       cur2;
-    FT_Byte*       limit;
+    T1_Parser  parser = &loader->parser;
+    FT_Error   error;
+    FT_Memory  memory = parser->root.memory;
+    FT_Int     len;
+    FT_Byte*   cur;
+    FT_Byte*   cur2;
+    FT_Byte*   limit;
 
 
     if ( face->type1.font_name )
@@ -848,13 +850,13 @@
     len = (FT_Int)( cur2 - cur );
     if ( len > 0 )
     {
-      if ( ALLOC( face->type1.font_name, len + 1 ) )
+      if ( FT_ALLOC( face->type1.font_name, len + 1 ) )
       {
         parser->root.error = error;
         return;
       }
 
-      MEM_Copy( face->type1.font_name, cur, len );
+      FT_MEM_COPY( face->type1.font_name, cur, len );
       face->type1.font_name[len] = '\0';
     }
     parser->root.cursor = cur2;
@@ -862,12 +864,12 @@
 
 
   static void
-  parse_font_bbox( T1_Face     face,
-                   T1_Loader*  loader )
+  parse_font_bbox( T1_Face    face,
+                   T1_Loader  loader )
   {
-    T1_ParserRec*  parser = &loader->parser;
-    FT_Fixed       temp[4];
-    FT_BBox*       bbox   = &face->type1.font_bbox;
+    T1_Parser  parser = &loader->parser;
+    FT_Fixed   temp[4];
+    FT_BBox*   bbox   = &face->type1.font_bbox;
 
 
     (void)T1_ToFixedArray( parser, 4, temp, 0 );
@@ -879,19 +881,19 @@
 
 
   static void
-  parse_font_matrix( T1_Face     face,
-                     T1_Loader*  loader )
+  parse_font_matrix( T1_Face    face,
+                     T1_Loader  loader )
   {
-    T1_ParserRec*  parser = &loader->parser;
-    FT_Matrix*     matrix = &face->type1.font_matrix;
-    FT_Vector*     offset = &face->type1.font_offset;
-    FT_Face        root   = (FT_Face)&face->root;
-    FT_Fixed       temp[6];
-    FT_Fixed       temp_scale;
+    T1_Parser   parser = &loader->parser;
+    FT_Matrix*  matrix = &face->type1.font_matrix;
+    FT_Vector*  offset = &face->type1.font_offset;
+    FT_Face     root   = (FT_Face)&face->root;
+    FT_Fixed    temp[6];
+    FT_Fixed    temp_scale;
 
 
     if ( matrix->xx || matrix->yx )
-      /*  with synthetic fonts, it's possible we get here twice  */
+      /* with synthetic fonts, it's possible we get here twice  */
       return;
 
     (void)T1_ToFixedArray( parser, 6, temp, 3 );
@@ -928,14 +930,14 @@
 
 
   static void
-  parse_encoding( T1_Face     face,
-                  T1_Loader*  loader )
+  parse_encoding( T1_Face    face,
+                  T1_Loader  loader )
   {
-    T1_ParserRec*  parser = &loader->parser;
+    T1_Parser      parser = &loader->parser;
     FT_Byte*       cur    = parser->root.cursor;
     FT_Byte*       limit  = parser->root.limit;
 
-    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;
+    PSAux_Service  psaux  = (PSAux_Service)face->psaux;
 
 
     /* skip whitespace */
@@ -954,11 +956,11 @@
     /* and we must load it now                             */
     if ( (FT_Byte)( *cur - '0' ) < 10 )
     {
-      T1_Encoding*  encode     = &face->type1.encoding;
-      FT_Int        count, n;
-      PS_Table*     char_table = &loader->encoding_table;
-      FT_Memory     memory     = parser->root.memory;
-      FT_Error      error;
+      T1_Encoding  encode     = &face->type1.encoding;
+      FT_Int       count, n;
+      PS_Table     char_table = &loader->encoding_table;
+      FT_Memory    memory     = parser->root.memory;
+      FT_Error     error;
 
 
       if ( encode->char_index )
@@ -971,17 +973,17 @@
         return;
 
       /* we use a T1_Table to store our charnames */
-      encode->num_chars = count;
-      if ( ALLOC_ARRAY( encode->char_index, count, FT_Short   ) ||
-           ALLOC_ARRAY( encode->char_name,  count, FT_String* ) ||
-           ( error = psaux->ps_table_funcs->init(
-                       char_table, count, memory ) ) != 0       )
+      loader->num_chars = encode->num_chars = count;
+      if ( FT_NEW_ARRAY( encode->char_index, count ) ||
+           FT_NEW_ARRAY( encode->char_name,  count ) ||
+           FT_SET_ERROR( psaux->ps_table_funcs->init(
+                           char_table, count, memory ) ) )
       {
         parser->root.error = error;
         return;
       }
 
-      /* We need to `zero' out encoding_table.elements          */
+      /* We need to `zero' out encoding_table.elements */
       for ( n = 0; n < count; n++ )
       {
         char*  notdef = (char *)".notdef";
@@ -1017,10 +1019,10 @@
         /* we stop when we encounter a `def' */
         if ( c == 'd' && cur + 3 < limit )
         {
-          if ( cur[1] == 'e' &&
-               cur[2] == 'f' &&
-               is_space(cur[-1]) &&
-               is_space(cur[3]) )
+          if ( cur[1] == 'e'       &&
+               cur[2] == 'f'       &&
+               is_space( cur[-1] ) &&
+               is_space( cur[3] )  )
           {
             FT_TRACE6(( "encoding end\n" ));
             break;
@@ -1035,7 +1037,7 @@
 
           parser->root.cursor = cur;
           charcode = T1_ToInt( parser );
-          cur = parser->root.cursor;
+          cur      = parser->root.cursor;
 
           /* skip whitespace */
           while ( cur < limit && is_space( *cur ) )
@@ -1067,20 +1069,24 @@
           cur++;
       }
 
-      face->type1.encoding_type = t1_encoding_array;
+      face->type1.encoding_type = T1_ENCODING_TYPE_ARRAY;
       parser->root.cursor       = cur;
     }
-    /* Otherwise, we should have either `StandardEncoding' or */
-    /* `ExpertEncoding'                                       */
+    /* Otherwise, we should have either `StandardEncoding', */
+    /* `ExpertEncoding', or `ISOLatin1Encoding'             */
     else
     {
-      if ( cur + 17 < limit &&
-           strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )
-        face->type1.encoding_type = t1_encoding_standard;
-
-      else if ( cur + 15 < limit &&
-                strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )
-        face->type1.encoding_type = t1_encoding_expert;
+      if ( cur + 17 < limit                                            &&
+           ft_strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_STANDARD;
+
+      else if ( cur + 15 < limit                                          &&
+                ft_strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_EXPERT;
+
+      else if ( cur + 18 < limit                                             &&
+                ft_strncmp( (const char*)cur, "ISOLatin1Encoding", 17 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_ISOLATIN1;
 
       else
       {
@@ -1092,16 +1098,16 @@
 
 
   static void
-  parse_subrs( T1_Face     face,
-               T1_Loader*  loader )
+  parse_subrs( T1_Face    face,
+               T1_Loader  loader )
   {
-    T1_ParserRec*  parser = &loader->parser;
-    PS_Table*      table  = &loader->subrs;
+    T1_Parser      parser = &loader->parser;
+    PS_Table       table  = &loader->subrs;
     FT_Memory      memory = parser->root.memory;
     FT_Error       error;
     FT_Int         n;
 
-    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;
+    PSAux_Service  psaux  = (PSAux_Service)face->psaux;
 
 
     if ( loader->num_subrs )
@@ -1126,19 +1132,18 @@
     /*                                                       */
     /*   `index' + binary data                               */
     /*                                                       */
-
     for ( n = 0; n < loader->num_subrs; n++ )
     {
-      FT_Int    index, size;
+      FT_Int    idx, size;
       FT_Byte*  base;
 
 
       /* If the next token isn't `dup', we are also done.  This */
       /* happens when there are `holes' in the Subrs array.     */
-      if ( strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
+      if ( ft_strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
         break;
 
-      index = T1_ToInt( parser );
+      idx = T1_ToInt( parser );
 
       if ( !read_binary_data( parser, &size, &base ) )
         return;
@@ -1151,7 +1156,7 @@
       T1_Skip_Alpha( parser );    /* `NP' or `I' or `noaccess' */
       T1_Skip_Spaces( parser );
 
-      if ( strncmp( (char*)parser->root.cursor, "put", 3 ) == 0 )
+      if ( ft_strncmp( (char*)parser->root.cursor, "put", 3 ) == 0 )
       {
         T1_Skip_Alpha( parser );  /* skip `put' */
         T1_Skip_Spaces( parser );
@@ -1164,12 +1169,21 @@
       /*                                                         */
       if ( face->type1.private_dict.lenIV >= 0 )
       {
-        psaux->t1_decrypt( base, size, 4330 );
+        FT_Byte*  temp;
+
+
+        /* t1_decrypt() shouldn't write to base -- make temporary copy */
+        if ( FT_ALLOC( temp, size ) )
+          goto Fail;
+        FT_MEM_COPY( temp, base, size );
+        psaux->t1_decrypt( temp, size, 4330 );
         size -= face->type1.private_dict.lenIV;
-        base += face->type1.private_dict.lenIV;
+        error = T1_Add_Table( table, idx,
+                              temp + face->type1.private_dict.lenIV, size );
+        FT_FREE( temp );
       }
-
-      error = T1_Add_Table( table, index, base, size );
+      else
+        error = T1_Add_Table( table, idx, base, size );
       if ( error )
         goto Fail;
     }
@@ -1181,23 +1195,23 @@
 
 
   static void
-  parse_charstrings( T1_Face     face,
-                     T1_Loader*  loader )
+  parse_charstrings( T1_Face    face,
+                     T1_Loader  loader )
   {
-    T1_ParserRec*  parser     = &loader->parser;
-    PS_Table*      code_table = &loader->charstrings;
-    PS_Table*      name_table = &loader->glyph_names;
-    PS_Table*      swap_table = &loader->swap_table;
-    FT_Memory      memory     = parser->root.memory;
+    T1_Parser      parser       = &loader->parser;
+    PS_Table       code_table   = &loader->charstrings;
+    PS_Table       name_table   = &loader->glyph_names;
+    PS_Table       swap_table   = &loader->swap_table;
+    FT_Memory      memory       = parser->root.memory;
     FT_Error       error;
 
-    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;
+    PSAux_Service  psaux        = (PSAux_Service)face->psaux;
 
-    FT_Byte*    cur;
-    FT_Byte*    limit = parser->root.limit;
-    FT_Int      n;
-    FT_UInt     notdef_index = 0;
-    FT_Byte     notdef_found = 0;
+    FT_Byte*       cur;
+    FT_Byte*       limit        = parser->root.limit;
+    FT_Int         n;
+    FT_UInt        notdef_index = 0;
+    FT_Byte        notdef_found = 0;
 
 
     if ( loader->num_glyphs )
@@ -1231,8 +1245,8 @@
     if ( error )
       goto Fail;
 
-
     n = 0;
+
     for (;;)
     {
       FT_Int    size;
@@ -1283,8 +1297,8 @@
         name_table->elements[n][len] = '\0';
 
         /* record index of /.notdef              */
-        if ( strcmp( (const char*)".notdef",
-                     (const char*)(name_table->elements[n]) ) == 0 )
+        if ( ft_strcmp( (const char*)".notdef",
+                        (const char*)(name_table->elements[n]) ) == 0 )
         {
           notdef_index = n;
           notdef_found = 1;
@@ -1296,12 +1310,21 @@
 
         if ( face->type1.private_dict.lenIV >= 0 )
         {
-          psaux->t1_decrypt( base, size, 4330 );
+          FT_Byte*  temp;
+
+
+          /* t1_decrypt() shouldn't write to base -- make temporary copy */
+          if ( FT_ALLOC( temp, size ) )
+            goto Fail;
+          FT_MEM_COPY( temp, base, size );
+          psaux->t1_decrypt( temp, size, 4330 );
           size -= face->type1.private_dict.lenIV;
-          base += face->type1.private_dict.lenIV;
+          error = T1_Add_Table( code_table, n,
+                                temp + face->type1.private_dict.lenIV, size );
+          FT_FREE( temp );
         }
-
-        error = T1_Add_Table( code_table, n, base, size );
+        else
+          error = T1_Add_Table( code_table, n, base, size );
         if ( error )
           goto Fail;
 
@@ -1314,8 +1337,8 @@
     loader->num_glyphs = n;
 
     /* if /.notdef is found but does not occupy index 0, do our magic.      */
-    if ( strcmp( (const char*)".notdef",
-                 (const char*)name_table->elements[0] ) &&
+    if ( ft_strcmp( (const char*)".notdef",
+                    (const char*)name_table->elements[0] ) &&
          notdef_found                                      )
     {
       /* Swap glyph in index 0 with /.notdef glyph.  First, add index 0    */
@@ -1379,11 +1402,10 @@
     }
     else if ( !notdef_found )
     {
-
-      /* notdef_index is already 0, or /.notdef is undefined in  */
-      /* charstrings dictionary. Worry about /.notdef undefined. */
-      /* We take index 0 and add it to the end of the table(s)   */
-      /* and add our own /.notdef glyph to index 0.              */
+      /* notdef_index is already 0, or /.notdef is undefined in   */
+      /* charstrings dictionary.  Worry about /.notdef undefined. */
+      /* We take index 0 and add it to the end of the table(s)    */
+      /* and add our own /.notdef glyph to index 0.               */
 
       /* 0 333 hsbw endchar                                      */
       FT_Byte  notdef_glyph[] = {0x8B, 0xF7, 0xE1, 0x0D, 0x0E};
@@ -1425,10 +1447,8 @@
 
       /* we added a glyph. */
       loader->num_glyphs = n + 1;
-
     }
 
-
     return;
 
   Fail:
@@ -1437,7 +1457,7 @@
 
 
   static
-  const T1_Field  t1_keywords[] =
+  const T1_FieldRec  t1_keywords[] =
   {
 
 #include "t1tokens.h"
@@ -1458,17 +1478,17 @@
     T1_FIELD_CALLBACK( "shareddict", parse_shared_dict )
 #endif
 
-    { 0, t1_field_cid_info, t1_field_none, 0, 0, 0, 0, 0 }
+    { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0 }
   };
 
 
   static FT_Error
-  parse_dict( T1_Face     face,
-              T1_Loader*  loader,
-              FT_Byte*    base,
-              FT_Long     size )
+  parse_dict( T1_Face    face,
+              T1_Loader  loader,
+              FT_Byte*   base,
+              FT_Long    size )
   {
-    T1_ParserRec*  parser = &loader->parser;
+    T1_Parser  parser = &loader->parser;
 
 
     parser->root.cursor = base;
@@ -1483,8 +1503,8 @@
       for ( ; cur < limit; cur++ )
       {
         /* look for `FontDirectory', which causes problems on some fonts */
-        if ( *cur == 'F' && cur + 25 < limit                 &&
-             strncmp( (char*)cur, "FontDirectory", 13 ) == 0 )
+        if ( *cur == 'F' && cur + 25 < limit                    &&
+             ft_strncmp( (char*)cur, "FontDirectory", 13 ) == 0 )
         {
           FT_Byte*  cur2;
 
@@ -1494,13 +1514,13 @@
           cur2 = cur;
 
           /* lookup the `known' keyword */
-          while ( cur < limit && *cur != 'k'        &&
-                  strncmp( (char*)cur, "known", 5 ) )
+          while ( cur < limit && *cur != 'k'           &&
+                  ft_strncmp( (char*)cur, "known", 5 ) )
             cur++;
 
           if ( cur < limit )
           {
-            T1_Token  token;
+            T1_TokenRec  token;
 
 
             /* skip the `known' keyword and the token following it */
@@ -1509,7 +1529,7 @@
             T1_ToToken( &loader->parser, &token );
 
             /* if the last token was an array, skip it! */
-            if ( token.type == t1_token_array )
+            if ( token.type == T1_TOKEN_TYPE_ARRAY )
               cur2 = parser->root.cursor;
           }
           cur = cur2;
@@ -1531,7 +1551,7 @@
           {
             {
               /* now, compare the immediate name to the keyword table */
-              T1_Field*  keyword = (T1_Field*)t1_keywords;
+              T1_Field  keyword = (T1_Field)t1_keywords;
 
 
               for (;;)
@@ -1543,8 +1563,8 @@
                 if ( !name )
                   break;
 
-                if ( cur[0] == name[0]                          &&
-                     len == (FT_Int)strlen( (const char*)name ) )
+                if ( cur[0] == name[0]                             &&
+                     len == (FT_Int)ft_strlen( (const char*)name ) )
                 {
                   FT_Int  n;
 
@@ -1580,12 +1600,12 @@
 
 
   static void
-  t1_init_loader( T1_Loader*  loader,
-                  T1_Face     face )
+  t1_init_loader( T1_Loader  loader,
+                  T1_Face    face )
   {
     FT_UNUSED( face );
 
-    MEM_Set( loader, 0, sizeof ( *loader ) );
+    FT_MEM_SET( loader, 0, sizeof ( *loader ) );
     loader->num_glyphs = 0;
     loader->num_chars  = 0;
 
@@ -1600,9 +1620,9 @@
 
 
   static void
-  t1_done_loader( T1_Loader*  loader )
+  t1_done_loader( T1_Loader  loader )
   {
-    T1_ParserRec*  parser = &loader->parser;
+    T1_Parser  parser = &loader->parser;
 
 
     /* finalize tables */
@@ -1617,15 +1637,15 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Open_Face( T1_Face  face )
   {
-    T1_Loader      loader;
-    T1_ParserRec*  parser;
-    T1_Font*       type1 = &face->type1;
+    T1_LoaderRec   loader;
+    T1_Parser      parser;
+    T1_Font        type1 = &face->type1;
     FT_Error       error;
 
-    PSAux_Interface*  psaux = (PSAux_Interface*)face->psaux;
+    PSAux_Service  psaux = (PSAux_Service)face->psaux;
 
 
     t1_init_loader( &loader, face );
@@ -1634,10 +1654,10 @@
     type1->private_dict.lenIV = 4;
 
     parser = &loader.parser;
-    error = T1_New_Parser( parser,
-                           face->root.stream,
-                           face->root.memory,
-                           psaux );
+    error  = T1_New_Parser( parser,
+                            face->root.stream,
+                            face->root.memory,
+                            psaux );
     if ( error )
       goto Exit;
 
@@ -1685,11 +1705,10 @@
     loader.glyph_names.block    = 0;
     loader.glyph_names.elements = 0;
 
-    /* we must now build type1.encoding when we have a custom */
-    /* array..                                                */
-    if ( type1->encoding_type == t1_encoding_array )
+    /* we must now build type1.encoding when we have a custom array */
+    if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
     {
-      FT_Int    charcode, index, min_char, max_char;
+      FT_Int    charcode, idx, min_char, max_char;
       FT_Byte*  char_name;
       FT_Byte*  glyph_name;
 
@@ -1710,22 +1729,22 @@
 
         char_name = loader.encoding_table.elements[charcode];
         if ( char_name )
-          for ( index = 0; index < type1->num_glyphs; index++ )
+          for ( idx = 0; idx < type1->num_glyphs; idx++ )
           {
-            glyph_name = (FT_Byte*)type1->glyph_names[index];
-            if ( strcmp( (const char*)char_name,
-                         (const char*)glyph_name ) == 0 )
+            glyph_name = (FT_Byte*)type1->glyph_names[idx];
+            if ( ft_strcmp( (const char*)char_name,
+                            (const char*)glyph_name ) == 0 )
             {
-              type1->encoding.char_index[charcode] = (FT_UShort)index;
+              type1->encoding.char_index[charcode] = (FT_UShort)idx;
               type1->encoding.char_name [charcode] = (char*)glyph_name;
 
               /* Change min/max encoded char only if glyph name is */
               /* not /.notdef                                      */
-              if ( strcmp( (const char*)".notdef",
-                           (const char*)glyph_name ) != 0 )
+              if ( ft_strcmp( (const char*)".notdef",
+                              (const char*)glyph_name ) != 0 )
               {
-                if (charcode < min_char) min_char = charcode;
-                if (charcode > max_char) max_char = charcode;
+                if ( charcode < min_char ) min_char = charcode;
+                if ( charcode > max_char ) max_char = charcode;
               }
               break;
             }
@@ -1734,7 +1753,7 @@
       type1->encoding.code_first = min_char;
       type1->encoding.code_last  = max_char;
       type1->encoding.num_chars  = loader.num_chars;
-   }
+    }
 
   Exit:
     t1_done_loader( &loader );
Index: xc/extras/freetype2/src/type1/t1load.h
diff -u xc/extras/freetype2/src/type1/t1load.h:1.1.1.4 xc/extras/freetype2/src/type1/t1load.h:1.1.1.5
--- xc/extras/freetype2/src/type1/t1load.h:1.1.1.4	Sun Dec 16 12:49:37 2001
+++ xc/extras/freetype2/src/type1/t1load.h	Thu Jun 20 04:16:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 font loader (specification).                                  */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -36,41 +36,41 @@
     T1_ParserRec  parser;          /* parser used to read the stream */
 
     FT_Int        num_chars;       /* number of characters in encoding */
-    PS_Table      encoding_table;  /* PS_Table used to store the       */
+    PS_TableRec   encoding_table;  /* PS_Table used to store the       */
                                    /* encoding character names         */
 
     FT_Int        num_glyphs;
-    PS_Table      glyph_names;
-    PS_Table      charstrings;
-    PS_Table      swap_table;      /* For moving .notdef glyph to index 0. */
+    PS_TableRec   glyph_names;
+    PS_TableRec   charstrings;
+    PS_TableRec   swap_table;      /* For moving .notdef glyph to index 0. */
 
     FT_Int        num_subrs;
-    PS_Table      subrs;
+    PS_TableRec   subrs;
     FT_Bool       fontdata;
 
-  } T1_Loader;
+  } T1_LoaderRec, *T1_Loader;
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Open_Face( T1_Face  face );
 
 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Get_Multi_Master( T1_Face           face,
                        FT_Multi_Master*  master );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Set_MM_Blend( T1_Face    face,
                    FT_UInt    num_coords,
                    FT_Fixed*  coords );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Set_MM_Design( T1_Face   face,
                     FT_UInt   num_coords,
                     FT_Long*  coords );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_Done_Blend( T1_Face  face );
 
 #endif /* !T1_CONFIG_OPTION_NO_MM_SUPPORT */
Index: xc/extras/freetype2/src/type1/t1objs.c
diff -u xc/extras/freetype2/src/type1/t1objs.c:1.1.1.5 xc/extras/freetype2/src/type1/t1objs.c:1.1.1.8
--- xc/extras/freetype2/src/type1/t1objs.c:1.1.1.5	Mon Jan 14 11:52:27 2002
+++ xc/extras/freetype2/src/type1/t1objs.c	Thu Jun 20 04:16:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 objects manager (body).                                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -20,8 +20,6 @@
 #include FT_INTERNAL_DEBUG_H
 #include FT_INTERNAL_STREAM_H
 
-#include <string.h>         /* strcmp() */
-
 #include "t1gload.h"
 #include "t1load.h"
 
@@ -58,10 +56,10 @@
   static PSH_Globals_Funcs
   T1_Size_Get_Globals_Funcs( T1_Size  size )
   {
-    T1_Face              face     = (T1_Face) size->root.face;
-    PSHinter_Interface*  pshinter = face->pshinter;
-    FT_Module            module;
-    
+    T1_Face           face     = (T1_Face)size->root.face;
+    PSHinter_Service  pshinter = (PSHinter_Service)face->pshinter;
+    FT_Module         module;
+
 
     module = FT_Get_Module( size->root.face->driver->root.library,
                             "pshinter" );
@@ -71,14 +69,14 @@
   }
 
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_Size_Done( T1_Size  size )
   {
     if ( size->root.internal )
     {
       PSH_Globals_Funcs  funcs;
-    
 
+
       funcs = T1_Size_Get_Globals_Funcs( size );
       if ( funcs )
         funcs->destroy( (PSH_Globals)size->root.internal );
@@ -88,36 +86,36 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Size_Init( T1_Size  size )
   {
     FT_Error           error = 0;
     PSH_Globals_Funcs  funcs = T1_Size_Get_Globals_Funcs( size );
-    
+
 
     if ( funcs )
     {
       PSH_Globals  globals;
       T1_Face      face = (T1_Face)size->root.face;
-      
 
-      error = funcs->create( size->root.face->memory, 
+
+      error = funcs->create( size->root.face->memory,
                              &face->type1.private_dict, &globals );
       if ( !error )
         size->root.internal = (FT_Size_Internal)(void*)globals;
     }
-    
+
     return error;
   }
 
 
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Size_Reset( T1_Size  size )
   {
     PSH_Globals_Funcs  funcs = T1_Size_Get_Globals_Funcs( size );
     FT_Error           error = 0;
 
-    
+
     if ( funcs )
       error = funcs->set_scale( (PSH_Globals)size->root.internal,
                                  size->root.metrics.x_scale,
@@ -133,38 +131,41 @@
   /*                                                                       */
   /*************************************************************************/
 
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_GlyphSlot_Done( T1_GlyphSlot  slot )
   {
     slot->root.internal->glyph_hints = 0;
   }
 
 
-  FT_LOCAL_DEF FT_Error
-  T1_GlyphSlot_Init( T1_GlyphSlot   slot )
-  {  
-    T1_Face              face;
-    PSHinter_Interface*  pshinter;
-    
-    face     = (T1_Face) slot->root.face;
-    pshinter = face->pshinter;
-    if (pshinter)
+  FT_LOCAL_DEF( FT_Error )
+  T1_GlyphSlot_Init( T1_GlyphSlot  slot )
+  {
+    T1_Face           face;
+    PSHinter_Service  pshinter;
+
+
+    face     = (T1_Face)slot->root.face;
+    pshinter = (PSHinter_Service)face->pshinter;
+
+    if ( pshinter )
     {
       FT_Module  module;
-      
+
+
       module = FT_Get_Module( slot->root.face->driver->root.library, "pshinter" );
       if (module)
       {
         T1_Hints_Funcs  funcs;
-        
+
         funcs = pshinter->get_t1_funcs( module );
         slot->root.internal->glyph_hints = (void*)funcs;
       }
     }
     return 0;
   }
-  
-  
+
+
   /*************************************************************************/
   /*                                                                       */
   /*                            FACE  FUNCTIONS                            */
@@ -183,11 +184,11 @@
   /* <Input>                                                               */
   /*    face :: A typeless pointer to the face object to destroy.          */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_Face_Done( T1_Face  face )
   {
     FT_Memory  memory;
-    T1_Font*   type1 = &face->type1;
+    T1_Font    type1 = &face->type1;
 
 
     if ( face )
@@ -202,31 +203,31 @@
 
       /* release font info strings */
       {
-        T1_FontInfo*  info = &type1->font_info;
+        PS_FontInfo  info = &type1->font_info;
 
 
-        FREE( info->version );
-        FREE( info->notice );
-        FREE( info->full_name );
-        FREE( info->family_name );
-        FREE( info->weight );
+        FT_FREE( info->version );
+        FT_FREE( info->notice );
+        FT_FREE( info->full_name );
+        FT_FREE( info->family_name );
+        FT_FREE( info->weight );
       }
 
       /* release top dictionary */
-      FREE( type1->charstrings_len );
-      FREE( type1->charstrings );
-      FREE( type1->glyph_names );
-
-      FREE( type1->subrs );
-      FREE( type1->subrs_len );
-
-      FREE( type1->subrs_block );
-      FREE( type1->charstrings_block );
-      FREE( type1->glyph_names_block );
-
-      FREE( type1->encoding.char_index );
-      FREE( type1->encoding.char_name );
-      FREE( type1->font_name );
+      FT_FREE( type1->charstrings_len );
+      FT_FREE( type1->charstrings );
+      FT_FREE( type1->glyph_names );
+
+      FT_FREE( type1->subrs );
+      FT_FREE( type1->subrs_len );
+
+      FT_FREE( type1->subrs_block );
+      FT_FREE( type1->charstrings_block );
+      FT_FREE( type1->glyph_names_block );
+
+      FT_FREE( type1->encoding.char_index );
+      FT_FREE( type1->encoding.char_name );
+      FT_FREE( type1->font_name );
 
 #ifndef T1_CONFIG_OPTION_NO_AFM
       /* release afm data if present */
@@ -235,7 +236,7 @@
 #endif
 
       /* release unicode map, if any */
-      FREE( face->unicode_map.maps );
+      FT_FREE( face->unicode_map.maps );
       face->unicode_map.num_maps = 0;
 
       face->root.family_name = 0;
@@ -267,17 +268,17 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Face_Init( FT_Stream      stream,
                 T1_Face        face,
                 FT_Int         face_index,
                 FT_Int         num_params,
                 FT_Parameter*  params )
   {
-    FT_Error             error;
-    PSNames_Interface*   psnames;
-    PSAux_Interface*     psaux;
-    PSHinter_Interface*  pshinter;
+    FT_Error          error;
+    PSNames_Service   psnames;
+    PSAux_Service     psaux;
+    PSHinter_Service  pshinter;
 
     FT_UNUSED( num_params );
     FT_UNUSED( params );
@@ -286,33 +287,18 @@
 
 
     face->root.num_faces = 1;
-
-    psnames = (PSNames_Interface*)face->psnames;
-    if ( !psnames )
-    {
-      psnames = (PSNames_Interface*)
-                FT_Get_Module_Interface( FT_FACE_LIBRARY( face ), "psnames" );
-
-      face->psnames = psnames;
-    }
-
-    psaux = (PSAux_Interface*)face->psaux;
-    if ( !psaux )
-    {
-      psaux = (PSAux_Interface*)
-              FT_Get_Module_Interface( FT_FACE_LIBRARY( face ), "psaux" );
 
-      face->psaux = psaux;
-    }
-    
-    pshinter = (PSHinter_Interface*)face->pshinter;
-    if ( !pshinter )
-    {
-      pshinter = (PSHinter_Interface*)
-                 FT_Get_Module_Interface( FT_FACE_LIBRARY( face ), "pshinter" );
-
-      face->pshinter = pshinter;
-    }
+    face->psnames = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                             "psnames" );
+    psnames = (PSNames_Service)face->psnames;
+
+    face->psaux = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                           "psaux" );
+    psaux = (PSAux_Service)face->psaux;
+
+    face->pshinter = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                              "pshinter" );
+    pshinter = (PSHinter_Service)face->pshinter;
 
     /* open the tokenizer, this will also check the font format */
     error = T1_Open_Face( face );
@@ -339,14 +325,11 @@
       FT_Face  root = (FT_Face)&face->root;
 
 
-      root->num_glyphs   = face->type1.num_glyphs;
-      root->num_charmaps = 1;
-
+      root->num_glyphs = face->type1.num_glyphs;
       root->face_index = face_index;
-      root->face_flags = FT_FACE_FLAG_SCALABLE;
 
+      root->face_flags = FT_FACE_FLAG_SCALABLE;
       root->face_flags |= FT_FACE_FLAG_HORIZONTAL;
-
       root->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
 
       if ( face->type1.font_info.is_fixed_pitch )
@@ -365,6 +348,7 @@
         char*  full   = face->type1.font_info.full_name;
         char*  family = root->family_name;
 
+
         if ( full )
         {
           while ( *family && *full == *family )
@@ -372,7 +356,7 @@
             family++;
             full++;
           }
-  
+
           root->style_name = ( *full == ' ' ? full + 1
                                             : (char *)"Regular" );
         }
@@ -395,8 +379,8 @@
         root->style_flags |= FT_STYLE_FLAG_ITALIC;
       if ( face->type1.font_info.weight )
       {
-        if ( !strcmp( face->type1.font_info.weight, "Bold"  ) ||
-             !strcmp( face->type1.font_info.weight, "Black" ) )
+        if ( !ft_strcmp( face->type1.font_info.weight, "Bold"  ) ||
+             !ft_strcmp( face->type1.font_info.weight, "Black" ) )
           root->style_flags |= FT_STYLE_FLAG_BOLD;
       }
 
@@ -404,20 +388,23 @@
       root->num_fixed_sizes = 0;
       root->available_sizes = 0;
 
-      root->bbox = face->type1.font_bbox;
+      root->bbox.xMin =   face->type1.font_bbox.xMin             >> 16;
+      root->bbox.yMin =   face->type1.font_bbox.yMin             >> 16;
+      root->bbox.xMax = ( face->type1.font_bbox.xMax + 0xFFFFU ) >> 16;
+      root->bbox.yMax = ( face->type1.font_bbox.yMax + 0xFFFFU ) >> 16;
 
       /* Set units_per_EM if we didn't set it in parse_font_matrix. */
       if ( !root->units_per_EM )
         root->units_per_EM = 1000;
 
-      root->ascender  = (FT_Short)( face->type1.font_bbox.yMax >> 16 );
-      root->descender = (FT_Short)( face->type1.font_bbox.yMin >> 16 );
+      root->ascender  = (FT_Short)( root->bbox.yMax );
+      root->descender = (FT_Short)( root->bbox.yMin );
       root->height    = (FT_Short)(
                           ( ( root->ascender - root->descender ) * 12 ) / 10 );
 
       /* now compute the maximum advance width */
       root->max_advance_width =
-        (FT_Short)( face->type1.font_bbox.xMax >> 16 );
+        (FT_Short)( root->bbox.xMax );
       {
         FT_Int  max_advance;
 
@@ -440,6 +427,69 @@
       root->internal->max_contours = 0;
     }
 
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+    {
+      FT_Face  root = &face->root;
+
+
+      if ( psnames && psaux )
+      {
+        FT_CharMapRec    charmap;
+        T1_CMap_Classes  cmap_classes = psaux->t1_cmap_classes;
+        FT_CMap_Class    clazz;
+
+
+        charmap.face = root;
+
+        /* first of all, try to synthetize a Unicode charmap */
+        charmap.platform_id = 3;
+        charmap.encoding_id = 1;
+        charmap.encoding    = ft_encoding_unicode;
+
+        FT_CMap_New( cmap_classes->unicode, NULL, &charmap, NULL );
+
+        /* now, generate an Adobe Standard encoding when appropriate */
+        charmap.platform_id = 7;
+        clazz               = NULL;
+
+        switch ( face->type1.encoding_type )
+        {
+        case T1_ENCODING_TYPE_STANDARD:
+          charmap.encoding    = ft_encoding_adobe_standard;
+          charmap.encoding_id = 0;
+          clazz               = cmap_classes->standard;
+          break;
+
+        case T1_ENCODING_TYPE_EXPERT:
+          charmap.encoding    = ft_encoding_adobe_expert;
+          charmap.encoding_id = 1;
+          clazz               = cmap_classes->expert;
+          break;
+
+        case T1_ENCODING_TYPE_ARRAY:
+          charmap.encoding    = ft_encoding_adobe_custom;
+          charmap.encoding_id = 2;
+          clazz               = cmap_classes->custom;
+          break;
+
+        case T1_ENCODING_TYPE_ISOLATIN1:
+          charmap.encoding    = ft_encoding_latin_1;
+          charmap.encoding_id = 3;
+          clazz               = cmap_classes->unicode;
+          break;
+
+        default:
+          ;
+        }
+
+        if ( clazz )
+          FT_CMap_New( clazz, NULL, &charmap, NULL );
+      }
+    }
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
     /* charmap support -- synthetize unicode charmap if possible */
     {
       FT_Face     root    = &face->root;
@@ -479,20 +529,30 @@
 
       switch ( face->type1.encoding_type )
       {
-      case t1_encoding_standard:
+      case T1_ENCODING_TYPE_STANDARD:
         charmap->encoding    = ft_encoding_adobe_standard;
         charmap->encoding_id = 0;
         break;
 
-      case t1_encoding_expert:
+      case T1_ENCODING_TYPE_EXPERT:
         charmap->encoding    = ft_encoding_adobe_expert;
         charmap->encoding_id = 1;
         break;
 
-      default:
+      case T1_ENCODING_TYPE_ARRAY:
         charmap->encoding    = ft_encoding_adobe_custom;
         charmap->encoding_id = 2;
         break;
+
+      case T1_ENCODING_TYPE_ISOLATIN1:
+        charmap->encoding    = ft_encoding_latin_1;
+        charmap->encoding_id = 3;
+        break;
+
+      default:
+        FT_ERROR(( "T1_Face_Init: invalid encoding\n" ));
+        error = T1_Err_Invalid_File_Format;
+        goto Exit;
       }
 
       root->charmaps     = face->charmaps;
@@ -501,6 +561,8 @@
       face->charmaps[1]  = &face->charmaprecs[1];
     }
 
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
   Exit:
     return error;
   }
@@ -520,7 +582,7 @@
   /* <Return>                                                              */
   /*    FreeType error code.  0 means success.                             */
   /*                                                                       */
-  FT_LOCAL_DEF FT_Error
+  FT_LOCAL_DEF( FT_Error )
   T1_Driver_Init( T1_Driver  driver )
   {
     FT_UNUSED( driver );
@@ -538,9 +600,9 @@
   /*    Finalizes a given Type 1 driver.                                   */
   /*                                                                       */
   /* <Input>                                                               */
-  /*    driver  :: A handle to the target Type 1 driver.                   */
+  /*    driver :: A handle to the target Type 1 driver.                    */
   /*                                                                       */
-  FT_LOCAL_DEF void
+  FT_LOCAL_DEF( void )
   T1_Driver_Done( T1_Driver  driver )
   {
     FT_UNUSED( driver );
Index: xc/extras/freetype2/src/type1/t1objs.h
diff -u xc/extras/freetype2/src/type1/t1objs.h:1.1.1.5 xc/extras/freetype2/src/type1/t1objs.h:1.1.1.6
--- xc/extras/freetype2/src/type1/t1objs.h:1.1.1.5	Mon Jan 14 11:52:27 2002
+++ xc/extras/freetype2/src/type1/t1objs.h	Thu Jun 20 04:16:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 objects manager (specification).                              */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -105,13 +105,13 @@
   } T1_SizeRec;
 
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_Size_Done( T1_Size  size );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Size_Reset( T1_Size  size );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Size_Init( T1_Size  size );
 
 
@@ -139,26 +139,26 @@
   } T1_GlyphSlotRec;
 
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Face_Init( FT_Stream      stream,
                 T1_Face        face,
                 FT_Int         face_index,
                 FT_Int         num_params,
                 FT_Parameter*  params );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_Face_Done( T1_Face  face );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_GlyphSlot_Init( T1_GlyphSlot  slot );
   
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_GlyphSlot_Done( T1_GlyphSlot  slot );
 
-  FT_LOCAL FT_Error
+  FT_LOCAL( FT_Error )
   T1_Driver_Init( T1_Driver  driver );
 
-  FT_LOCAL void
+  FT_LOCAL( void )
   T1_Driver_Done( T1_Driver  driver );
 
 
Index: xc/extras/freetype2/src/type1/t1parse.c
diff -u xc/extras/freetype2/src/type1/t1parse.c:1.1.1.4 xc/extras/freetype2/src/type1/t1parse.c:1.1.1.5
--- xc/extras/freetype2/src/type1/t1parse.c:1.1.1.4	Sun Dec 16 12:49:37 2001
+++ xc/extras/freetype2/src/type1/t1parse.c	Thu Jun 20 04:16:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 parser (body).                                                */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -43,9 +43,7 @@
 
 #include "t1errors.h"
 
-#include <string.h>     /* for strncmp() */
 
-
   /*************************************************************************/
   /*                                                                       */
   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
@@ -106,9 +104,9 @@
 
     *tag  = 0;
     *size = 0;
-    if ( !READ_Fields( pfb_tag_fields, &head ) )
+    if ( !FT_STREAM_READ_FIELDS( pfb_tag_fields, &head ) )
     {
-      if ( head.tag == 0x8001 || head.tag == 0x8002 )
+      if ( head.tag == 0x8001U || head.tag == 0x8002U )
       {
         *tag  = head.tag;
         *size = head.size;
@@ -118,18 +116,18 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
-  T1_New_Parser( T1_ParserRec*     parser,
-                 FT_Stream         stream,
-                 FT_Memory         memory,
-                 PSAux_Interface*  psaux )
+  FT_LOCAL_DEF( FT_Error )
+  T1_New_Parser( T1_Parser      parser,
+                 FT_Stream      stream,
+                 FT_Memory      memory,
+                 PSAux_Service  psaux )
   {
     FT_Error   error;
     FT_UShort  tag;
     FT_Long    size;
 
 
-    psaux->t1_parser_funcs->init( &parser->root,0, 0, memory );
+    psaux->ps_parser_funcs->init( &parser->root,0, 0, memory );
 
     parser->stream       = stream;
     parser->base_len     = 0;
@@ -158,18 +156,18 @@
 
     /* try to compute the size of the base dictionary;   */
     /* look for a Postscript binary file tag, i.e 0x8001 */
-    if ( FILE_Seek( 0L ) )
+    if ( FT_STREAM_SEEK( 0L ) )
       goto Exit;
 
     error = read_pfb_tag( stream, &tag, &size );
     if ( error )
       goto Exit;
 
-    if ( tag != 0x8001 )
+    if ( tag != 0x8001U )
     {
       /* assume that this is a PFA file for now; an error will */
       /* be produced later when more things are checked        */
-      if ( FILE_Seek( 0L ) )
+      if ( FT_STREAM_SEEK( 0L ) )
         goto Exit;
       size = stream->size;
     }
@@ -187,14 +185,14 @@
       parser->in_memory = 1;
 
       /* check that the `size' field is valid */
-      if ( FILE_Skip( size ) )
+      if ( FT_STREAM_SKIP( size ) )
         goto Exit;
     }
     else
     {
       /* read segment in memory */
-      if ( ALLOC( parser->base_dict, size )     ||
-           FILE_Read( parser->base_dict, size ) )
+      if ( FT_ALLOC( parser->base_dict, size )     ||
+           FT_STREAM_READ( parser->base_dict, size ) )
         goto Exit;
       parser->base_len = size;
     }
@@ -202,11 +200,11 @@
     /* Now check font format; we must see `%!PS-AdobeFont-1' */
     /* or `%!FontType'                                       */
     {
-      if ( size <= 16                                    ||
-           ( strncmp( (const char*)parser->base_dict,
-                      "%!PS-AdobeFont-1", 16 )        &&
-             strncmp( (const char*)parser->base_dict,
-                      "%!FontType", 10 )              )  )
+      if ( size <= 16                                       ||
+           ( ft_strncmp( (const char*)parser->base_dict,
+                         "%!PS-AdobeFont-1", 16 )        &&
+             ft_strncmp( (const char*)parser->base_dict,
+                         "%!FontType", 10 )              )  )
       {
         FT_TRACE2(( "[not a Type1 font]\n" ));
         error = T1_Err_Unknown_File_Format;
@@ -221,24 +219,24 @@
 
   Exit:
     if ( error && !parser->in_memory )
-      FREE( parser->base_dict );
+      FT_FREE( parser->base_dict );
 
     return error;
   }
 
 
-  FT_LOCAL_DEF void
-  T1_Finalize_Parser( T1_ParserRec*  parser )
+  FT_LOCAL_DEF( void )
+  T1_Finalize_Parser( T1_Parser  parser )
   {
-    FT_Memory   memory = parser->root.memory;
+    FT_Memory  memory = parser->root.memory;
 
 
     /* always free the private dictionary */
-    FREE( parser->private_dict );
+    FT_FREE( parser->private_dict );
 
     /* free the base dictionary only when we have a disk stream */
     if ( !parser->in_memory )
-      FREE( parser->base_dict );
+      FT_FREE( parser->base_dict );
 
     parser->root.funcs.done( &parser->root );
   }
@@ -267,9 +265,9 @@
   }
 
 
-  FT_LOCAL_DEF FT_Error
-  T1_Get_Private_Dict( T1_ParserRec*     parser,
-                       PSAux_Interface*  psaux )
+  FT_LOCAL_DEF( FT_Error )
+  T1_Get_Private_Dict( T1_Parser      parser,
+                       PSAux_Service  psaux )
   {
     FT_Stream  stream = parser->stream;
     FT_Memory  memory = parser->root.memory;
@@ -283,7 +281,7 @@
       /* made of several segments.  We thus first read the number of   */
       /* segments to compute the total size of the private dictionary  */
       /* then re-read them into memory.                                */
-      FT_Long    start_pos = FILE_Pos();
+      FT_Long    start_pos = FT_STREAM_POS();
       FT_UShort  tag;
 
 
@@ -294,12 +292,12 @@
         if ( error )
           goto Fail;
 
-        if ( tag != 0x8002 )
+        if ( tag != 0x8002U )
           break;
 
         parser->private_len += size;
 
-        if ( FILE_Skip( size ) )
+        if ( FT_STREAM_SKIP( size ) )
           goto Fail;
       }
 
@@ -313,21 +311,21 @@
         goto Fail;
       }
 
-      if ( FILE_Seek( start_pos )                             ||
-           ALLOC( parser->private_dict, parser->private_len ) )
+      if ( FT_STREAM_SEEK( start_pos )                             ||
+           FT_ALLOC( parser->private_dict, parser->private_len ) )
         goto Fail;
 
       parser->private_len = 0;
       for (;;)
       {
         error = read_pfb_tag( stream, &tag, &size );
-        if ( error || tag != 0x8002 )
+        if ( error || tag != 0x8002U )
         {
           error = T1_Err_Ok;
           break;
         }
 
-        if ( FILE_Read( parser->private_dict + parser->private_len, size ) )
+        if ( FT_STREAM_READ( parser->private_dict + parser->private_len, size ) )
           goto Fail;
 
         parser->private_len += size;
@@ -384,7 +382,7 @@
       if ( parser->in_memory )
       {
         /* note that we allocate one more byte to put a terminating `0' */
-        if ( ALLOC( parser->private_dict, size + 1 ) )
+        if ( FT_ALLOC( parser->private_dict, size + 1 ) )
           goto Fail;
         parser->private_len = size;
       }
@@ -408,7 +406,7 @@
              hexa_value( cur[2] ) | hexa_value( cur[3] ) ) < 0 )
 
         /* binary encoding -- `simply' copy the private dict */
-        MEM_Copy( parser->private_dict, cur, size );
+        FT_MEM_COPY( parser->private_dict, cur, size );
 
       else
       {
@@ -449,7 +447,7 @@
 
     /* we now decrypt the encoded binary private dictionary */
     psaux->t1_decrypt( parser->private_dict, parser->private_len, 55665U );
-    parser->root.base = parser->private_dict;
+    parser->root.base   = parser->private_dict;
     parser->root.cursor = parser->private_dict;
     parser->root.limit  = parser->root.cursor + parser->private_len;
 
Index: xc/extras/freetype2/src/type1/t1parse.h
diff -u xc/extras/freetype2/src/type1/t1parse.h:1.1.1.3 xc/extras/freetype2/src/type1/t1parse.h:1.1.1.4
--- xc/extras/freetype2/src/type1/t1parse.h:1.1.1.3	Sun Dec 16 12:49:37 2001
+++ xc/extras/freetype2/src/type1/t1parse.h	Thu Jun 20 04:16:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 parser (specification).                                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -34,7 +34,7 @@
   /*    T1_ParserRec                                                       */
   /*                                                                       */
   /* <Description>                                                         */
-  /*    A T1_ParserRec is an object used to parse a Type 1 fonts very      */
+  /*    A PS_ParserRec is an object used to parse a Type 1 fonts very      */
   /*    quickly.                                                           */
   /*                                                                       */
   /* <Fields>                                                              */
@@ -60,20 +60,20 @@
   /*                                                                       */
   typedef struct  T1_ParserRec_
   {
-    T1_Parser  root;
-    FT_Stream  stream;
+    PS_ParserRec  root;
+    FT_Stream     stream;
 
-    FT_Byte*   base_dict;
-    FT_Int     base_len;
+    FT_Byte*      base_dict;
+    FT_Int        base_len;
 
-    FT_Byte*   private_dict;
-    FT_Int     private_len;
+    FT_Byte*      private_dict;
+    FT_Int        private_len;
 
-    FT_Byte    in_pfb;
-    FT_Byte    in_memory;
-    FT_Byte    single_block;
+    FT_Byte       in_pfb;
+    FT_Byte       in_memory;
+    FT_Byte       single_block;
 
-  } T1_ParserRec;
+  } T1_ParserRec, *T1_Parser;
 
 
 #define T1_Add_Table( p, i, o, l )  (p)->funcs.add( (p), i, o, l )
@@ -97,33 +97,34 @@
 #define T1_ToInt( p )       (p)->root.funcs.to_int( &(p)->root )
 #define T1_ToFixed( p, t )  (p)->root.funcs.to_fixed( &(p)->root, t )
 
-#define T1_ToCoordArray( p, m, c )    \
+#define T1_ToCoordArray( p, m, c )                           \
           (p)->root.funcs.to_coord_array( &(p)->root, m, c )
-#define T1_ToFixedArray( p, m, f, t ) \
+#define T1_ToFixedArray( p, m, f, t )                           \
           (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
-#define T1_ToToken( p, t )            \
+#define T1_ToToken( p, t )                          \
           (p)->root.funcs.to_token( &(p)->root, t )
-#define T1_ToTokenArray( p, t, m, c ) \
+#define T1_ToTokenArray( p, t, m, c )                           \
           (p)->root.funcs.to_token_array( &(p)->root, t, m, c )
 
-#define T1_Load_Field( p, f, o, m, pf )       \
+#define T1_Load_Field( p, f, o, m, pf )                         \
           (p)->root.funcs.load_field( &(p)->root, f, o, m, pf )
-#define T1_Load_Field_Table( p, f, o, m, pf ) \
+
+#define T1_Load_Field_Table( p, f, o, m, pf )                         \
           (p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf )
 
 
-  FT_LOCAL FT_Error
-  T1_New_Parser( T1_ParserRec*     parser,
-                 FT_Stream         stream,
-                 FT_Memory         memory,
-                 PSAux_Interface*  psaux );
-
-  FT_LOCAL FT_Error
-  T1_Get_Private_Dict( T1_ParserRec*     parser,
-                       PSAux_Interface*  psaux );
+  FT_LOCAL( FT_Error )
+  T1_New_Parser( T1_Parser      parser,
+                 FT_Stream      stream,
+                 FT_Memory      memory,
+                 PSAux_Service  psaux );
+
+  FT_LOCAL( FT_Error )
+  T1_Get_Private_Dict( T1_Parser      parser,
+                       PSAux_Service  psaux );
 
-  FT_LOCAL void
-  T1_Finalize_Parser( T1_ParserRec*  parser );
+  FT_LOCAL( void )
+  T1_Finalize_Parser( T1_Parser  parser );
 
 
 FT_END_HEADER
Index: xc/extras/freetype2/src/type1/t1tokens.h
diff -u xc/extras/freetype2/src/type1/t1tokens.h:1.1.1.2 xc/extras/freetype2/src/type1/t1tokens.h:1.1.1.3
--- xc/extras/freetype2/src/type1/t1tokens.h:1.1.1.2	Sun Dec 16 12:49:37 2001
+++ xc/extras/freetype2/src/type1/t1tokens.h	Thu Jun 20 04:16:27 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    Type 1 tokenizer (specification).                                    */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -17,26 +17,26 @@
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  T1_FontInfo
+#define FT_STRUCTURE  PS_FontInfoRec
 #undef  T1CODE
-#define T1CODE        t1_field_font_info
+#define T1CODE        T1_FIELD_LOCATION_FONT_INFO
 
-  T1_FIELD_STRING( "version", version )
-  T1_FIELD_STRING( "Notice", notice )
-  T1_FIELD_STRING( "FullName", full_name )
-  T1_FIELD_STRING( "FamilyName", family_name )
-  T1_FIELD_STRING( "Weight", weight )
-
-  T1_FIELD_NUM   ( "ItalicAngle", italic_angle )
-  T1_FIELD_BOOL  ( "isFixedPitch", is_fixed_pitch )
-  T1_FIELD_NUM   ( "UnderlinePosition", underline_position )
-  T1_FIELD_NUM   ( "UnderlineThickness", underline_thickness )
+  T1_FIELD_STRING   ( "version", version )
+  T1_FIELD_STRING   ( "Notice", notice )
+  T1_FIELD_STRING   ( "FullName", full_name )
+  T1_FIELD_STRING   ( "FamilyName", family_name )
+  T1_FIELD_STRING   ( "Weight", weight )
+
+  T1_FIELD_NUM      ( "ItalicAngle", italic_angle )
+  T1_FIELD_TYPE_BOOL( "isFixedPitch", is_fixed_pitch )
+  T1_FIELD_NUM      ( "UnderlinePosition", underline_position )
+  T1_FIELD_NUM      ( "UnderlineThickness", underline_thickness )
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  T1_Private
+#define FT_STRUCTURE  PS_PrivateRec
 #undef  T1CODE
-#define T1CODE        t1_field_private
+#define T1CODE        T1_FIELD_LOCATION_PRIVATE
 
   T1_FIELD_NUM       ( "UniqueID", unique_id )
   T1_FIELD_NUM       ( "lenIV", lenIV )
@@ -61,9 +61,9 @@
 
 
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  T1_Font
+#define FT_STRUCTURE  T1_FontRec
 #undef  T1CODE
-#define T1CODE        t1_field_font_dict
+#define T1CODE        T1_FIELD_LOCATION_FONT_DICT
 
   T1_FIELD_NUM( "PaintType", paint_type )
   T1_FIELD_NUM( "FontType", font_type )
Index: xc/extras/freetype2/src/type42/Jamfile
diff -u /dev/null xc/extras/freetype2/src/type42/Jamfile:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/Jamfile	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,23 @@
+# FreeType 2 src/type42 Jamfile (c) 2002 David Turner
+#
+
+SubDir  FT2_TOP src type42 ;
+
+SubDirHdrs  [ FT2_SubDir  src type42 ] ;
+
+{
+  local  _sources ;
+
+  if $(FT2_MULTI)
+  {
+    _sources = t42objs t42parse t42drivr ;
+  }
+  else
+  {
+    _sources = type42 ;
+  }
+
+  Library  $(FT2_LIB) : $(_sources).c ;
+}
+
+# end of src/type42 Jamfile
Index: xc/extras/freetype2/src/type42/descrip.mms
diff -u /dev/null xc/extras/freetype2/src/type42/descrip.mms:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/descrip.mms	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,23 @@
+#
+# FreeType 2 Type 42 driver compilation rules for VMS
+#
+
+
+# Copyright 2002 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.type42])
+
+OBJS=type42.obj
+
+all : $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
+
+# EOF
Index: xc/extras/freetype2/src/type42/module.mk
diff -u /dev/null xc/extras/freetype2/src/type42/module.mk:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/module.mk	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,22 @@
+#
+# FreeType 2 Type42 module definition
+#
+
+
+# Copyright 2002 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+make_module_list: add_type42_driver
+
+add_type42_driver:
+	$(OPEN_DRIVER)t42_driver_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)type42     $(ECHO_DRIVER_DESC)Type 42 font files with no known extension$(ECHO_DRIVER_DONE)
+
+# EOF
Index: xc/extras/freetype2/src/type42/rules.mk
diff -u /dev/null xc/extras/freetype2/src/type42/rules.mk:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/rules.mk	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,69 @@
+#
+# FreeType 2 Type42 driver configuration rules
+#
+
+
+# Copyright 2002 by
+# David Turner, Robert Wilhelm, and Werner Lemberg.
+#
+# This file is part of the FreeType project, and may only be used, modified,
+# and distributed under the terms of the FreeType project license,
+# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
+# indicate that you have read the license and understand and accept it
+# fully.
+
+
+# Type42 driver directory
+#
+T42_DIR  := $(SRC_)type42
+T42_DIR_ := $(T42_DIR)$(SEP)
+
+
+# compilation flags for the driver
+#
+T42_COMPILE := $(FT_COMPILE) $I$(T42_DIR)
+
+
+# Type42 driver source
+#
+T42_DRV_SRC := $(T42_DIR_)t42objs.c  \
+               $(T42_DIR_)t42parse.c \
+               $(T42_DIR_)t42drivr.c
+
+# Type42 driver headers
+#
+T42_DRV_H := $(T42_DRV_SRC:%.c=%.h) \
+             $(T42_DIR_)t42error.h
+
+
+# Type42 driver object(s)
+#
+#   T42_DRV_OBJ_M is used during `multi' builds
+#   T42_DRV_OBJ_S is used during `single' builds
+#
+T42_DRV_OBJ_M := $(T42_DRV_SRC:$(T42_DIR_)%.c=$(OBJ_)%.$O)
+T42_DRV_OBJ_S := $(OBJ_)type42.$O
+
+# Type42 driver source file for single build
+#
+T42_DRV_SRC_S := $(T42_DIR_)type42.c
+
+
+# Type42 driver - single object
+#
+$(T42_DRV_OBJ_S): $(T42_DRV_SRC_S) $(T42_DRV_SRC) $(FREETYPE_H) $(T42_DRV_H)
+	$(T42_COMPILE) $T$@ $(T42_DRV_SRC_S)
+
+
+# Type42 driver - multiple objects
+#
+$(OBJ_)%.$O: $(T42_DIR_)%.c $(FREETYPE_H) $(T42_DRV_H)
+	$(T42_COMPILE) $T$@ $<
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(T42_DRV_OBJ_S)
+DRV_OBJS_M += $(T42_DRV_OBJ_M)
+
+# EOF
Index: xc/extras/freetype2/src/type42/t42drivr.c
diff -u /dev/null xc/extras/freetype2/src/type42/t42drivr.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/t42drivr.c	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,151 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42drivr.c                                                             */
+/*                                                                         */
+/*    High-level Type 42 driver interface (body).                          */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "t42drivr.h"
+#include "t42objs.h"
+#include "t42error.h"
+#include FT_INTERNAL_DEBUG_H
+
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_t42
+
+
+  static FT_Error
+  t42_get_glyph_name( T42_Face    face,
+                      FT_UInt     glyph_index,
+                      FT_Pointer  buffer,
+                      FT_UInt     buffer_max )
+  {
+    FT_String*  gname;
+
+
+    gname = face->type1.glyph_names[glyph_index];
+
+    if ( buffer_max > 0 )
+    {
+      FT_UInt  len = (FT_UInt)( ft_strlen( gname ) );
+
+  
+      if ( len >= buffer_max )
+        len = buffer_max - 1;
+        
+      FT_MEM_COPY( buffer, gname, len );
+      ((FT_Byte*)buffer)[len] = 0;
+    }
+
+    return T42_Err_Ok;
+  }
+
+
+  static const char*
+  t42_get_ps_name( T42_Face  face )
+  {
+    return (const char*)face->type1.font_name;
+  }
+
+
+  static FT_UInt
+  t42_get_name_index( T42_Face    face,
+                      FT_String*  glyph_name )
+  {
+    FT_Int      i;
+    FT_String*  gname;
+
+
+    for ( i = 0; i < face->type1.num_glyphs; i++ )
+    {
+      gname = face->type1.glyph_names[i];
+
+      if ( !ft_strcmp( glyph_name, gname ) )
+        return ft_atoi( (const char *)face->type1.charstrings[i] );
+    }
+
+    return 0;
+  }
+
+
+  static FT_Module_Interface
+  T42_Get_Interface( FT_Driver         driver,
+                     const FT_String*  t42_interface )
+  {
+    FT_UNUSED( driver );
+
+    /* Any additional interface are defined here */
+    if (ft_strcmp( (const char*)t42_interface, "glyph_name" ) == 0 )
+      return (FT_Module_Interface)t42_get_glyph_name;
+
+    if ( ft_strcmp( (const char*)t42_interface, "name_index" ) == 0 )
+      return (FT_Module_Interface)t42_get_name_index;
+
+    if ( ft_strcmp( (const char*)t42_interface, "postscript_name" ) == 0 )
+      return (FT_Module_Interface)t42_get_ps_name;
+
+    return 0;
+  }
+
+
+  const FT_Driver_ClassRec  t42_driver_class =
+  {
+    {
+      ft_module_font_driver      |
+      ft_module_driver_scalable  |
+#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
+      ft_module_driver_has_hinter,
+#else
+      0,
+#endif
+
+      sizeof ( T42_DriverRec ),
+
+      "type42",
+      0x10000L,
+      0x20000L,
+
+      0,    /* format interface */
+
+      (FT_Module_Constructor)T42_Driver_Init,
+      (FT_Module_Destructor) T42_Driver_Done,
+      (FT_Module_Requester)  T42_Get_Interface,
+    },
+
+    sizeof ( T42_FaceRec ),
+    sizeof ( T42_SizeRec ),
+    sizeof ( T42_GlyphSlotRec ),
+
+    (FT_Face_InitFunc)        T42_Face_Init,
+    (FT_Face_DoneFunc)        T42_Face_Done,
+    (FT_Size_InitFunc)        T42_Size_Init,
+    (FT_Size_DoneFunc)        T42_Size_Done,
+    (FT_Slot_InitFunc)        T42_GlyphSlot_Init,
+    (FT_Slot_DoneFunc)        T42_GlyphSlot_Done,
+
+    (FT_Size_ResetPointsFunc) T42_Size_SetChars,
+    (FT_Size_ResetPixelsFunc) T42_Size_SetPixels,
+    (FT_Slot_LoadFunc)        T42_GlyphSlot_Load,
+    (FT_CharMap_CharIndexFunc)T42_CMap_CharIndex,
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+
+    (FT_Face_GetAdvancesFunc) 0,
+
+    (FT_CharMap_CharNextFunc) T42_CMap_CharNext,
+  };
+
+
+/* END */
Index: xc/extras/freetype2/src/type42/t42drivr.h
diff -u /dev/null xc/extras/freetype2/src/type42/t42drivr.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/t42drivr.h	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,38 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42drivr.h                                                             */
+/*                                                                         */
+/*    High-level Type 42 driver interface (specification).                 */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42DRIVR_H__
+#define __T42DRIVR_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  t42_driver_class;
+
+
+FT_END_HEADER
+
+
+#endif /* __T42DRIVR_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/type42/t42error.h
diff -u /dev/null xc/extras/freetype2/src/type42/t42error.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/t42error.h	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42error.h                                                             */
+/*                                                                         */
+/*    Type 42 error codes (specification only).                            */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to define the Type 42 error enumeration constants.  */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifndef __T42ERROR_H__
+#define __T42ERROR_H__
+
+#include FT_MODULE_ERRORS_H
+
+#undef __FTERRORS_H__
+
+#define FT_ERR_PREFIX  T42_Err_
+#define FT_ERR_BASE    FT_Mod_Err_T42
+
+#include FT_ERRORS_H
+
+#endif /* __T42ERROR_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/type42/t42objs.c
diff -u /dev/null xc/extras/freetype2/src/type42/t42objs.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/t42objs.c	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,932 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42objs.c                                                              */
+/*                                                                         */
+/*    Type 42 objects manager (body).                                      */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "t42objs.h"
+#include "t42parse.h"
+#include "t42error.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_LIST_H
+
+
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_t42
+
+
+  static FT_Error
+  T42_Open_Face( T42_Face  face )
+  {
+    T42_LoaderRec  loader;
+    T42_Parser     parser;
+    T1_Font        type1 = &face->type1;
+    FT_Memory      memory = face->root.memory;
+    FT_Error       error;
+
+    PSAux_Service  psaux  = (PSAux_Service)face->psaux;
+
+
+    t42_loader_init( &loader, face );
+
+    parser = &loader.parser;
+
+    if ( FT_ALLOC( face->ttf_data, 12 ) )
+      goto Exit;
+
+    error = t42_parser_init( parser,
+                             face->root.stream,
+                             memory,
+                             psaux);
+    if ( error )
+      goto Exit;
+
+    error = t42_parse_dict( face, &loader, parser->base_dict, parser->base_len );
+
+    if ( type1->font_type != 42 )
+    {
+      error = T42_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* now, propagate the charstrings and glyphnames tables */
+    /* to the Type1 data                                    */
+    type1->num_glyphs = loader.num_glyphs;
+
+    if ( !loader.charstrings.init ) {
+      FT_ERROR(( "T42_Open_Face: no charstrings array in face!\n" ));
+      error = T42_Err_Invalid_File_Format;
+    }
+
+    loader.charstrings.init  = 0;
+    type1->charstrings_block = loader.charstrings.block;
+    type1->charstrings       = loader.charstrings.elements;
+    type1->charstrings_len   = loader.charstrings.lengths;
+
+    /* we copy the glyph names `block' and `elements' fields; */
+    /* the `lengths' field must be released later             */
+    type1->glyph_names_block    = loader.glyph_names.block;
+    type1->glyph_names          = (FT_String**)loader.glyph_names.elements;
+    loader.glyph_names.block    = 0;
+    loader.glyph_names.elements = 0;
+
+    /* we must now build type1.encoding when we have a custom array */
+    if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
+    {
+      FT_Int    charcode, idx, min_char, max_char;
+      FT_Byte*  char_name;
+      FT_Byte*  glyph_name;
+
+
+      /* OK, we do the following: for each element in the encoding   */
+      /* table, look up the index of the glyph having the same name  */
+      /* as defined in the CharStrings array.                        */
+      /* The index is then stored in type1.encoding.char_index, and  */
+      /* the name in type1.encoding.char_name                        */
+
+      min_char = +32000;
+      max_char = -32000;
+
+      charcode = 0;
+      for ( ; charcode < loader.encoding_table.max_elems; charcode++ )
+      {
+        type1->encoding.char_index[charcode] = 0;
+        type1->encoding.char_name [charcode] = (char *)".notdef";
+
+        char_name = loader.encoding_table.elements[charcode];
+        if ( char_name )
+          for ( idx = 0; idx < type1->num_glyphs; idx++ )
+          {
+            glyph_name = (FT_Byte*)type1->glyph_names[idx];
+            if ( ft_strcmp( (const char*)char_name,
+                            (const char*)glyph_name ) == 0 )
+            {
+              type1->encoding.char_index[charcode] = (FT_UShort)idx;
+              type1->encoding.char_name [charcode] = (char*)glyph_name;
+
+              /* Change min/max encoded char only if glyph name is */
+              /* not /.notdef                                      */
+              if ( ft_strcmp( (const char*)".notdef",
+                              (const char*)glyph_name ) != 0 )
+              {
+                if ( charcode < min_char ) min_char = charcode;
+                if ( charcode > max_char ) max_char = charcode;
+              }
+              break;
+            }
+          }
+      }
+      type1->encoding.code_first = min_char;
+      type1->encoding.code_last  = max_char;
+      type1->encoding.num_chars  = loader.num_chars;
+    }
+
+  Exit:
+    t42_loader_done( &loader );
+    return error;
+  }
+
+
+  /***************** Driver Functions *************/
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Face_Init( FT_Stream      stream,
+                 T42_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params)
+  {
+    FT_Error          error;
+    PSNames_Service   psnames;
+    PSAux_Service     psaux;
+    FT_Face           root    = (FT_Face)&face->root;
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+    FT_UNUSED( stream );
+
+
+    face->ttf_face       = NULL;
+    face->root.num_faces = 1;
+
+    face->psnames = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                             "psnames" );
+    psnames = (PSNames_Service)face->psnames;
+
+    face->psaux = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
+                                           "psaux" );
+    psaux = (PSAux_Service)face->psaux;
+
+    /* open the tokenizer, this will also check the font format */
+    error = T42_Open_Face( face );
+    if ( error )
+      goto Exit;
+
+    /* if we just wanted to check the format, leave successfully now */
+    if ( face_index < 0 )
+      goto Exit;
+
+    /* check the face index */
+    if ( face_index != 0 )
+    {
+      FT_ERROR(( "T42_Face_Init: invalid face index\n" ));
+      error = T42_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    /* Now, load the font program into the face object */
+
+    /* Init the face object fields */
+    /* Now set up root face fields */
+
+    root->num_glyphs   = face->type1.num_glyphs;
+    root->num_charmaps = 0;
+    root->face_index   = face_index;
+
+    root->face_flags  = FT_FACE_FLAG_SCALABLE;
+    root->face_flags |= FT_FACE_FLAG_HORIZONTAL;
+    root->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
+
+    if ( face->type1.font_info.is_fixed_pitch )
+      root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+    /* XXX: TODO -- add kerning with .afm support */
+
+    /* get style name -- be careful, some broken fonts only */
+    /* have a `/FontName' dictionary entry!                 */
+    root->family_name = face->type1.font_info.family_name;
+    if ( root->family_name )
+    {
+      char*  full   = face->type1.font_info.full_name;
+      char*  family = root->family_name;
+
+
+      if ( full )
+      {
+        while ( *family && *full == *family )
+        {
+          family++;
+          full++;
+        }
+
+        root->style_name = ( *full == ' ' ? full + 1
+                                          : (char *)"Regular" );
+      }
+      else
+        root->style_name = (char *)"Regular";
+    }
+    else
+    {
+      /* do we have a `/FontName'? */
+      if ( face->type1.font_name )
+      {
+        root->family_name = face->type1.font_name;
+        root->style_name  = (char *)"Regular";
+      }
+    }
+
+    /* no embedded bitmap support */
+    root->num_fixed_sizes = 0;
+    root->available_sizes = 0;
+
+    /* Load the TTF font embedded in the T42 font */
+    error = FT_New_Memory_Face( FT_FACE_LIBRARY( face ),
+                                face->ttf_data,
+                                face->ttf_size,
+                                0,
+                                &face->ttf_face );
+    if ( error )
+      goto Exit;
+
+    FT_Done_Size( face->ttf_face->size );
+
+    /* Ignore info in FontInfo dictionary and use the info from the  */
+    /* loaded TTF font.  The PostScript interpreter also ignores it. */
+    root->bbox         = face->ttf_face->bbox;
+    root->units_per_EM = face->ttf_face->units_per_EM;
+
+    root->ascender  = face->ttf_face->ascender;
+    root->descender = face->ttf_face->descender;
+    root->height    = face->ttf_face->height;
+
+    root->max_advance_width  = face->ttf_face->max_advance_width;
+    root->max_advance_height = face->ttf_face->max_advance_height;
+
+    root->underline_position  = face->type1.font_info.underline_position;
+    root->underline_thickness = face->type1.font_info.underline_thickness;
+
+    root->internal->max_points   = 0;
+    root->internal->max_contours = 0;
+
+    /* compute style flags */
+    root->style_flags = 0;
+    if ( face->type1.font_info.italic_angle )
+      root->style_flags |= FT_STYLE_FLAG_ITALIC;
+
+    if ( face->ttf_face->style_flags & FT_STYLE_FLAG_BOLD )
+      root->style_flags |= FT_STYLE_FLAG_BOLD;
+
+    if ( face->ttf_face->face_flags & FT_FACE_FLAG_VERTICAL )
+      root->face_flags |= FT_FACE_FLAG_VERTICAL;
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+    {
+      if ( psnames && psaux )
+      {
+        FT_CharMapRec    charmap;
+        T1_CMap_Classes  cmap_classes = psaux->t1_cmap_classes;
+        FT_CMap_Class    clazz;
+
+
+        charmap.face = root;
+
+        /* first of all, try to synthetize a Unicode charmap */
+        charmap.platform_id = 3;
+        charmap.encoding_id = 1;
+        charmap.encoding    = ft_encoding_unicode;
+
+        FT_CMap_New( cmap_classes->unicode, NULL, &charmap, NULL );
+
+        /* now, generate an Adobe Standard encoding when appropriate */
+        charmap.platform_id = 7;
+        clazz               = NULL;
+
+        switch ( face->type1.encoding_type )
+        {
+        case T1_ENCODING_TYPE_STANDARD:
+          charmap.encoding    = ft_encoding_adobe_standard;
+          charmap.encoding_id = 0;
+          clazz               = cmap_classes->standard;
+          break;
+
+        case T1_ENCODING_TYPE_EXPERT:
+          charmap.encoding    = ft_encoding_adobe_expert;
+          charmap.encoding_id = 1;
+          clazz               = cmap_classes->expert;
+          break;
+
+        case T1_ENCODING_TYPE_ARRAY:
+          charmap.encoding    = ft_encoding_adobe_custom;
+          charmap.encoding_id = 2;
+          clazz               = cmap_classes->custom;
+          break;
+
+        case T1_ENCODING_TYPE_ISOLATIN1:
+          charmap.encoding    = ft_encoding_latin_1;
+          charmap.encoding_id = 3;
+          clazz               = cmap_classes->unicode;
+          break;
+
+        default:
+          ;
+        }
+
+        if ( clazz )
+          FT_CMap_New( clazz, NULL, &charmap, NULL );
+
+        /* Select default charmap */
+        if (root->num_charmaps)
+          root->charmap = root->charmaps[0];
+      }
+    }
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+    /* charmap support -- synthetize unicode charmap if possible */
+    {
+      FT_CharMap  charmap = face->charmaprecs;
+
+      
+      /* synthesize a Unicode charmap if there is support in the `PSNames' */
+      /* module                                                            */
+      if ( psnames && psnames->unicode_value )
+      {
+        error = psnames->build_unicodes( root->memory,
+                                         face->type1.num_glyphs,
+                                         (const char**)face->type1.glyph_names,
+                                         &face->unicode_map );
+        if ( !error )
+        {
+          root->charmap        = charmap;
+          charmap->face        = (FT_Face)face;
+          charmap->encoding    = ft_encoding_unicode;
+          charmap->platform_id = 3;
+          charmap->encoding_id = 1;
+          charmap++;
+        }
+        
+        /* XXX: Is the following code correct?  It is used in t1objs.c */
+        
+        /* simply clear the error in case of failure (which really) */
+        /* means that out of memory or no unicode glyph names       */
+        error = T42_Err_Ok;
+      }
+      
+      /* now, support either the standard, expert, or custom encoding */
+      charmap->face        = (FT_Face)face;
+      charmap->platform_id = 7;  /* a new platform id for Adobe fonts? */
+      
+      switch ( face->type1.encoding_type )
+      {
+      case T1_ENCODING_TYPE_STANDARD:
+        charmap->encoding    = ft_encoding_adobe_standard;
+        charmap->encoding_id = 0;
+        break;
+        
+      case T1_ENCODING_TYPE_EXPERT:
+        charmap->encoding    = ft_encoding_adobe_expert;
+        charmap->encoding_id = 1;
+        break;
+        
+      case T1_ENCODING_TYPE_ARRAY:
+        charmap->encoding    = ft_encoding_adobe_custom;
+        charmap->encoding_id = 2;
+        break;
+        
+      case T1_ENCODING_TYPE_ISOLATIN1:
+        charmap->encoding    = ft_encoding_latin_1;
+        charmap->encoding_id = 3;
+        break;
+        
+      default:
+        FT_ERROR(( "T42_Face_Init: invalid encoding\n" ));
+        error = T42_Err_Invalid_File_Format;
+        goto Exit;
+      }
+      
+      root->charmaps     = face->charmaps;
+      root->num_charmaps = charmap - face->charmaprecs + 1;
+      face->charmaps[0]  = &face->charmaprecs[0];
+      face->charmaps[1]  = &face->charmaprecs[1];
+    }
+
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+  Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_Face_Done( T42_Face  face )
+  {
+    T1_Font      type1;
+    PS_FontInfo  info;
+    FT_Memory    memory;
+
+
+    if ( face )
+    {
+      type1  = &face->type1;
+      info   = &type1->font_info;
+      memory = face->root.memory;
+
+      /* delete internal ttf face prior to freeing face->ttf_data */
+      if ( face->ttf_face )
+        FT_Done_Face( face->ttf_face );
+
+      /* release font info strings */
+      FT_FREE( info->version );
+      FT_FREE( info->notice );
+      FT_FREE( info->full_name );
+      FT_FREE( info->family_name );
+      FT_FREE( info->weight );
+
+      /* release top dictionary */
+      FT_FREE( type1->charstrings_len );
+      FT_FREE( type1->charstrings );
+      FT_FREE( type1->glyph_names );
+
+      FT_FREE( type1->charstrings_block );
+      FT_FREE( type1->glyph_names_block );
+
+      FT_FREE( type1->encoding.char_index );
+      FT_FREE( type1->encoding.char_name );
+      FT_FREE( type1->font_name );
+
+      FT_FREE( face->ttf_data );
+
+#if 0
+      /* release afm data if present */
+      if ( face->afm_data )
+        T1_Done_AFM( memory, (T1_AFM*)face->afm_data );
+#endif
+
+      /* release unicode map, if any */
+      FT_FREE( face->unicode_map.maps );
+      face->unicode_map.num_maps = 0;
+
+      face->root.family_name = 0;
+      face->root.style_name  = 0;
+    }
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    T42_Driver_Init                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a given Type 42 driver object.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    driver :: A handle to the target driver object.                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_LOCAL_DEF( FT_Error )
+  T42_Driver_Init( T42_Driver  driver )
+  {
+    FT_Module  ttmodule;
+
+
+    ttmodule = FT_Get_Module( FT_MODULE(driver)->library, "truetype" );
+    driver->ttclazz = (FT_Driver_Class)ttmodule->clazz;
+
+    return T42_Err_Ok;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_Driver_Done( T42_Driver  driver )
+  {
+    FT_UNUSED( driver );
+  }
+
+
+  FT_LOCAL_DEF( FT_UInt )
+  T42_CMap_CharIndex( FT_CharMap  charmap,
+                      FT_Long     charcode )
+  {
+    T42_Face         face;
+    FT_UInt          result = 0;
+    PSNames_Service  psnames;
+
+
+    face    = (T42_Face)charmap->face;
+    psnames = (PSNames_Service)face->psnames;
+    if (!psnames )
+      goto Exit;
+
+    switch ( charmap->encoding )
+    {
+      /*******************************************************************/
+      /*                                                                 */
+      /* Unicode encoding support                                        */
+      /*                                                                 */
+    case ft_encoding_unicode:
+      /* if this charmap is used, we ignore the encoding of the font and */
+      /* use the `PSNames' module to synthetize the Unicode charmap      */
+      result = psnames->lookup_unicode( &face->unicode_map,
+                                        (FT_ULong)charcode );
+
+      /* the function returns 0xFFFF if the Unicode charcode has */
+      /* no corresponding glyph                                  */
+      if ( result == 0xFFFFU )
+        result = 0;
+
+      /* The result returned is the index (position)in the CharStrings */
+      /* array.  This must be used now to get the value associated to  */
+      /* that glyph_name, which is the real index within the truetype  */
+      /* structure.                                                    */
+      result = ft_atoi( (const char*)face->type1.charstrings[result] );
+      goto Exit;
+
+      /*******************************************************************/
+      /*                                                                 */
+      /* ISOLatin1 encoding support                                      */
+      /*                                                                 */
+    case ft_encoding_latin_1:
+      /* ISOLatin1 is the first page of Unicode */
+      if ( charcode < 256 && psnames->unicode_value )
+      {
+        result = psnames->lookup_unicode( &face->unicode_map,
+                                          (FT_ULong)charcode );
+
+        /* the function returns 0xFFFF if the Unicode charcode has */
+        /* no corresponding glyph                                  */
+        if ( result == 0xFFFFU )
+          result = 0;
+      }
+      goto Exit;
+
+      /*******************************************************************/
+      /*                                                                 */
+      /* Custom Type 1 encoding                                          */
+      /*                                                                 */
+    case ft_encoding_adobe_custom:
+      {
+        T1_Encoding  encoding = &face->type1.encoding;
+
+
+        if ( charcode >= encoding->code_first &&
+             charcode <= encoding->code_last  )
+        {
+          FT_UInt idx = encoding->char_index[charcode];
+
+
+          result = ft_atoi( (const char *)face->type1.charstrings[idx] );
+        }
+        goto Exit;
+      }
+
+      /*******************************************************************/
+      /*                                                                 */
+      /* Adobe Standard & Expert encoding support                        */
+      /*                                                                 */
+    default:
+      if ( charcode < 256 )
+      {
+        FT_UInt      code;
+        FT_Int       n;
+        const char*  glyph_name;
+
+
+        code = psnames->adobe_std_encoding[charcode];
+        if ( charmap->encoding == ft_encoding_adobe_expert )
+          code = psnames->adobe_expert_encoding[charcode];
+
+        glyph_name = psnames->adobe_std_strings( code );
+        if ( !glyph_name )
+          break;
+
+        for ( n = 0; n < face->type1.num_glyphs; n++ )
+        {
+          const char*  gname = face->type1.glyph_names[n];
+
+          if ( gname && ( ft_strcmp( gname, glyph_name ) == 0 ) )
+          {
+            result = ft_atoi( (const char *)face->type1.charstrings[n] );
+            break;
+          }
+        }
+      }
+    }
+
+  Exit:
+    return result;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Size_Init( T42_Size  size )
+  {
+    FT_Face   face = size->root.face;
+    T42_Face  t42face = (T42_Face)face;
+    FT_Size   ttsize;
+    FT_Error  error   = T42_Err_Ok;
+
+
+    error = FT_New_Size( t42face->ttf_face, &ttsize );
+    size->ttsize = ttsize;
+
+    FT_Activate_Size( ttsize );
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_Size_Done( T42_Size  size )
+  {
+    FT_Face      face    = size->root.face;
+    T42_Face     t42face = (T42_Face)face;
+    FT_ListNode  node;
+
+
+    node = FT_List_Find( &t42face->ttf_face->sizes_list, size->ttsize );
+    if ( node )
+    {
+      FT_Done_Size( size->ttsize );
+      size->ttsize = NULL;
+    }
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_GlyphSlot_Init( T42_GlyphSlot  slot )
+  {
+    FT_Face       face    = slot->root.face;
+    T42_Face      t42face = (T42_Face)face;
+    FT_GlyphSlot  ttslot;
+    FT_Error      error   = T42_Err_Ok;
+
+
+    if ( face->glyph == NULL )
+    {
+      /* First glyph slot for this face */
+      slot->ttslot = t42face->ttf_face->glyph;
+    }
+    else
+    {
+      error = FT_New_GlyphSlot( t42face->ttf_face, &ttslot );
+      slot->ttslot = ttslot;
+    }
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  T42_GlyphSlot_Done( T42_GlyphSlot slot )
+  {
+    FT_Face       face    = slot->root.face;
+    T42_Face      t42face = (T42_Face)face;
+    FT_GlyphSlot  cur     = t42face->ttf_face->glyph;
+
+
+    while ( cur )
+    {
+      if ( cur == slot->ttslot )
+      {
+        FT_Done_GlyphSlot( slot->ttslot );
+        break;
+      }
+
+      cur = cur->next;
+    }
+  }
+
+
+  static void
+  t42_check_size_change( FT_Face  face )
+  {
+    FT_Face  tt_face = ((T42_Face)face)->ttf_face;
+    FT_Size  tt_size = ((T42_Size)face->size)->ttsize;
+    
+    if ( tt_face->size != tt_size )
+      FT_Activate_Size( tt_size );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Size_SetChars( T42_Size    size,
+                     FT_F26Dot6  char_width,
+                     FT_F26Dot6  char_height,
+                     FT_UInt     horz_resolution,
+                     FT_UInt     vert_resolution )
+  {
+    FT_Face   face    = size->root.face;
+    T42_Face  t42face = (T42_Face)face;
+
+
+    t42_check_size_change( t42face->ttf_face );
+    
+    return FT_Set_Char_Size( t42face->ttf_face,
+                             char_width,
+                             char_height,
+                             horz_resolution,
+                             vert_resolution );
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_Size_SetPixels( T42_Size  size,
+                      FT_UInt   pixel_width,
+                      FT_UInt   pixel_height )
+  {
+    FT_Face   face    = size->root.face;
+    T42_Face  t42face = (T42_Face)face;
+
+
+
+    t42_check_size_change( t42face->ttf_face );
+    
+    return FT_Set_Pixel_Sizes( t42face->ttf_face,
+                               pixel_width,
+                               pixel_height );
+  }
+
+
+  static void
+  ft_glyphslot_clear( FT_GlyphSlot  slot )
+  {
+    /* free bitmap if needed */
+    if ( slot->flags & FT_GLYPH_OWN_BITMAP )
+    {
+      FT_Memory  memory = FT_FACE_MEMORY( slot->face );
+
+
+      FT_FREE( slot->bitmap.buffer );
+      slot->flags &= ~FT_GLYPH_OWN_BITMAP;
+    }
+
+    /* clear all public fields in the glyph slot */
+    FT_ZERO( &slot->metrics );
+    FT_ZERO( &slot->outline );
+    FT_ZERO( &slot->bitmap );
+
+    slot->bitmap_left   = 0;
+    slot->bitmap_top    = 0;
+    slot->num_subglyphs = 0;
+    slot->subglyphs     = 0;
+    slot->control_data  = 0;
+    slot->control_len   = 0;
+    slot->other         = 0;
+    slot->format        = ft_glyph_format_none;
+
+    slot->linearHoriAdvance = 0;
+    slot->linearVertAdvance = 0;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  T42_GlyphSlot_Load( FT_GlyphSlot  glyph,
+                      FT_Size       size,
+                      FT_Int        glyph_index,
+                      FT_Int        load_flags )
+  {
+    FT_Error         error;
+    T42_GlyphSlot    t42slot = (T42_GlyphSlot)glyph;
+    T42_Size         t42size = (T42_Size)size;
+    FT_Face          tt_face = ((T42_Face) glyph->face)->ttf_face;
+    FT_Driver_Class  ttclazz = ((T42_Driver)glyph->face->driver)->ttclazz;
+
+    t42_check_size_change( tt_face );
+
+    ft_glyphslot_clear( t42slot->ttslot );
+    error = ttclazz->load_glyph( t42slot->ttslot,
+                                 t42size->ttsize,
+                                 glyph_index,
+                                 load_flags | FT_LOAD_NO_BITMAP );
+
+    if ( !error )
+    {
+      glyph->metrics = t42slot->ttslot->metrics;
+
+      glyph->linearHoriAdvance = t42slot->ttslot->linearHoriAdvance;
+      glyph->linearVertAdvance = t42slot->ttslot->linearVertAdvance;
+
+      glyph->format  = t42slot->ttslot->format;
+      glyph->outline = t42slot->ttslot->outline;
+
+      glyph->bitmap      = t42slot->ttslot->bitmap;
+      glyph->bitmap_left = t42slot->ttslot->bitmap_left;
+      glyph->bitmap_top  = t42slot->ttslot->bitmap_top;
+      
+      glyph->num_subglyphs = t42slot->ttslot->num_subglyphs;
+      glyph->subglyphs     = t42slot->ttslot->subglyphs;
+      
+      glyph->control_data  = t42slot->ttslot->control_data;
+      glyph->control_len   = t42slot->ttslot->control_len;
+    }
+
+    return error;
+  }
+
+
+
+  FT_LOCAL_DEF( FT_Long )
+  T42_CMap_CharNext( FT_CharMap  charmap,
+                     FT_Long     charcode )
+  {
+    T42_Face         face;
+    PSNames_Service  psnames;
+
+
+    face    = (T42_Face)charmap->face;
+    psnames = (PSNames_Service)face->psnames;
+
+    if ( psnames )
+      switch ( charmap->encoding )
+      {
+        /*******************************************************************/
+        /*                                                                 */
+        /* Unicode encoding support                                        */
+        /*                                                                 */
+      case ft_encoding_unicode:
+        /* use the `PSNames' module to synthetize the Unicode charmap */
+        return psnames->next_unicode( &face->unicode_map,
+                                      (FT_ULong)charcode );
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* ISOLatin1 encoding support                                      */
+        /*                                                                 */
+      case ft_encoding_latin_1:
+        {
+          FT_ULong code;
+
+
+          /* use the `PSNames' module to synthetize the Unicode charmap */
+          code = psnames->next_unicode( &face->unicode_map,
+                                        (FT_ULong)charcode );
+          if ( code < 256 )
+            return code;
+          break;
+        }
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Custom Type 1 encoding                                          */
+        /*                                                                 */
+      case ft_encoding_adobe_custom:
+        {
+          T1_Encoding  encoding = &face->type1.encoding;
+
+
+          charcode++;
+          if ( charcode < encoding->code_first )
+            charcode = encoding->code_first;
+          while ( charcode <= encoding->code_last  ) {
+            if ( encoding->char_index[charcode] )
+              return charcode;
+            charcode++;
+          }
+        }
+
+
+        /*******************************************************************/
+        /*                                                                 */
+        /* Adobe Standard & Expert encoding support                        */
+        /*                                                                 */
+      default:
+        while ( ++charcode < 256 )
+        {
+          FT_UInt      code;
+          FT_Int       n;
+          const char*  glyph_name;
+
+
+          code = psnames->adobe_std_encoding[charcode];
+          if ( charmap->encoding == ft_encoding_adobe_expert )
+            code = psnames->adobe_expert_encoding[charcode];
+
+          glyph_name = psnames->adobe_std_strings( code );
+          if ( !glyph_name )
+            continue;
+
+          for ( n = 0; n < face->type1.num_glyphs; n++ )
+          {
+            const char*  gname = face->type1.glyph_names[n];
+
+
+            if ( gname && gname[0] == glyph_name[0]  &&
+                 ft_strcmp( gname, glyph_name ) == 0 )
+              return charcode;
+          }
+        }
+      }
+
+    return 0;
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/type42/t42objs.h
diff -u /dev/null xc/extras/freetype2/src/type42/t42objs.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/t42objs.h	Thu Jun 20 04:16:27 2002
@@ -0,0 +1,153 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42objs.h                                                              */
+/*                                                                         */
+/*    Type 42 objects manager (specification).                             */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42OBJS_H__
+#define __T42OBJS_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPE1_TABLES_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DRIVER_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+  /* Type42 face */
+  typedef struct  T42_FaceRec_
+  {
+    FT_FaceRec     root;
+    T1_FontRec     type1;
+    const void*    psnames;
+    const void*    psaux;
+    const void*    afm_data;
+
+    FT_CharMapRec  charmaprecs[2];
+    FT_CharMap     charmaps[2];
+    PS_Unicodes    unicode_map;
+
+    FT_Byte*       ttf_data;
+    FT_ULong       ttf_size;
+    FT_Face        ttf_face;
+
+  } T42_FaceRec, *T42_Face;
+
+
+  /* Type42 size */
+  typedef struct  T42_SizeRec_
+  {
+    FT_SizeRec  root;
+    FT_Size     ttsize;
+
+  } T42_SizeRec, *T42_Size;
+
+
+  /* Type42 slot */
+  typedef struct  T42_GlyphSlotRec_
+  {
+    FT_GlyphSlotRec  root;
+    FT_GlyphSlot     ttslot;
+
+  } T42_GlyphSlotRec, *T42_GlyphSlot;
+
+
+  /* Type 42 driver */
+  typedef struct  T42_DriverRec_
+  {
+    FT_DriverRec     root;
+    FT_Driver_Class  ttclazz;
+    void*            extension_component;
+
+  } T42_DriverRec, *T42_Driver;
+
+
+  /* */
+
+
+  FT_LOCAL( FT_Error )
+  T42_Face_Init( FT_Stream      stream,
+                 T42_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params );
+
+
+  FT_LOCAL( void )
+  T42_Face_Done( T42_Face  face );
+
+
+  FT_LOCAL( FT_Error )
+  T42_Size_Init( T42_Size  size );
+
+
+  FT_LOCAL( FT_Error )
+  T42_Size_SetChars( T42_Size    size,
+                     FT_F26Dot6  char_width,
+                     FT_F26Dot6  char_height,
+                     FT_UInt     horz_resolution,
+                     FT_UInt     vert_resolution );
+
+  FT_LOCAL( FT_Error )
+  T42_Size_SetPixels( T42_Size  size,
+                      FT_UInt   pixel_width,
+                      FT_UInt   pixel_height );
+
+  FT_LOCAL( void )
+  T42_Size_Done( T42_Size  size );
+
+
+  FT_LOCAL( FT_Error )
+  T42_GlyphSlot_Init( T42_GlyphSlot  slot );
+
+
+  FT_LOCAL( FT_Error )
+  T42_GlyphSlot_Load( FT_GlyphSlot  glyph,
+                      FT_Size       size,
+                      FT_Int        glyph_index,
+                      FT_Int        load_flags );
+
+  FT_LOCAL( void )
+  T42_GlyphSlot_Done( T42_GlyphSlot slot );
+
+
+  FT_LOCAL( FT_UInt )
+  T42_CMap_CharIndex( FT_CharMap  charmap,
+                      FT_Long     charcode );
+
+  FT_LOCAL( FT_Long )
+  T42_CMap_CharNext( FT_CharMap  charmap,
+                     FT_Long     charcode );
+
+
+  FT_LOCAL( FT_Error )
+  T42_Driver_Init( T42_Driver  driver );
+
+  FT_LOCAL( void )
+  T42_Driver_Done( T42_Driver  driver );
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __T42OBJS_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/type42/t42parse.c
diff -u /dev/null xc/extras/freetype2/src/type42/t42parse.c:1.2
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/t42parse.c	Wed Sep 18 13:11:39 2002
@@ -0,0 +1,995 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42parse.c                                                             */
+/*                                                                         */
+/*    Type 42 font parser (body).                                          */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+/* $XFree86: xc/extras/freetype2/src/type42/t42parse.c,v 1.2 2002/09/18 17:11:39 tsi Exp $ */
+
+#include "t42parse.h"
+#include "t42error.h"
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_LIST_H
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_t42
+
+
+  static void
+  t42_parse_font_name( T42_Face    face,
+                       T42_Loader  loader );
+                       
+  static void
+  t42_parse_font_bbox( T42_Face    face,
+                       T42_Loader  loader );
+                       
+  static void
+  t42_parse_font_matrix( T42_Face    face,
+                         T42_Loader  loader );
+  static void
+  t42_parse_encoding( T42_Face    face,
+                      T42_Loader  loader );
+                      
+  static void
+  t42_parse_charstrings( T42_Face    face,
+                         T42_Loader  loader );
+                         
+  static void
+  t42_parse_sfnts( T42_Face    face,
+                   T42_Loader  loader );
+
+
+  static const
+  T1_FieldRec  t42_keywords[] = {
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  T1_FontInfo
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_INFO
+
+    T1_FIELD_STRING   ( "version",            version )
+    T1_FIELD_STRING   ( "Notice",             notice )
+    T1_FIELD_STRING   ( "FullName",           full_name )
+    T1_FIELD_STRING   ( "FamilyName",         family_name )
+    T1_FIELD_STRING   ( "Weight",             weight )
+    T1_FIELD_NUM      ( "ItalicAngle",        italic_angle )
+    T1_FIELD_TYPE_BOOL( "isFixedPitch",       is_fixed_pitch )
+    T1_FIELD_NUM      ( "UnderlinePosition",  underline_position )
+    T1_FIELD_NUM      ( "UnderlineThickness", underline_thickness )
+
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  T1_FontRec
+#undef  T1CODE
+#define T1CODE        T1_FIELD_LOCATION_FONT_DICT
+
+    T1_FIELD_NUM( "PaintType",   paint_type )
+    T1_FIELD_NUM( "FontType",    font_type )
+    T1_FIELD_NUM( "StrokeWidth", stroke_width )
+
+    T1_FIELD_CALLBACK( "FontName",    t42_parse_font_name )
+    T1_FIELD_CALLBACK( "FontBBox",    t42_parse_font_bbox )
+    T1_FIELD_CALLBACK( "FontMatrix",  t42_parse_font_matrix )
+    T1_FIELD_CALLBACK( "Encoding",    t42_parse_encoding )
+    T1_FIELD_CALLBACK( "CharStrings", t42_parse_charstrings )
+    T1_FIELD_CALLBACK( "sfnts",       t42_parse_sfnts )
+
+    { 0, T1_FIELD_LOCATION_CID_INFO, T1_FIELD_TYPE_NONE, 0, 0, 0, 0, 0 }
+  };
+
+
+#define T1_Add_Table( p, i, o, l )  (p)->funcs.add( (p), i, o, l )
+#define T1_Done_Table( p )          \
+          do                        \
+          {                         \
+            if ( (p)->funcs.done )  \
+              (p)->funcs.done( p ); \
+          } while ( 0 )
+#define T1_Release_Table( p )          \
+          do                           \
+          {                            \
+            if ( (p)->funcs.release )  \
+              (p)->funcs.release( p ); \
+          } while ( 0 )
+
+#define T1_Skip_Spaces( p )  (p)->root.funcs.skip_spaces( &(p)->root )
+#define T1_Skip_Alpha( p )   (p)->root.funcs.skip_alpha ( &(p)->root )
+
+#define T1_ToInt( p )       (p)->root.funcs.to_int( &(p)->root )
+#define T1_ToFixed( p, t )  (p)->root.funcs.to_fixed( &(p)->root, t )
+
+#define T1_ToCoordArray( p, m, c )                           \
+          (p)->root.funcs.to_coord_array( &(p)->root, m, c )
+#define T1_ToFixedArray( p, m, f, t )                           \
+          (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t )
+#define T1_ToToken( p, t )                          \
+          (p)->root.funcs.to_token( &(p)->root, t )
+#define T1_ToTokenArray( p, t, m, c )                           \
+          (p)->root.funcs.to_token_array( &(p)->root, t, m, c )
+
+#define T1_Load_Field( p, f, o, m, pf )                         \
+          (p)->root.funcs.load_field( &(p)->root, f, o, m, pf )
+#define T1_Load_Field_Table( p, f, o, m, pf )                         \
+          (p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf )
+
+
+  /********************* Parsing Functions ******************/
+
+  FT_LOCAL_DEF( FT_Error )
+  t42_parser_init( T42_Parser     parser,
+                   FT_Stream      stream,
+                   FT_Memory      memory,
+                   PSAux_Service  psaux )
+  {
+    FT_Error  error = T42_Err_Ok;
+    FT_Long   size;
+
+
+    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );
+
+    parser->stream    = stream;
+    parser->base_len  = 0;
+    parser->base_dict = 0;
+    parser->in_memory = 0;
+
+    /*******************************************************************/
+    /*                                                                 */
+    /* Here a short summary of what is going on:                       */
+    /*                                                                 */
+    /*   When creating a new Type 42 parser, we try to locate and load */
+    /*   the base dictionary, loading the whole font into memory.      */
+    /*                                                                 */
+    /*   When `loading' the base dictionary, we only setup pointers in */
+    /*   the case of a memory-based stream.  Otherwise, we allocate    */
+    /*   and load the base dictionary in it.                           */
+    /*                                                                 */
+    /*   parser->in_memory is set if we have a memory stream.          */
+    /*                                                                 */
+
+    if ( FT_STREAM_SEEK( 0L ) )
+      goto Exit;
+
+    size = stream->size;
+
+    /* now, try to load `size' bytes of the `base' dictionary we */
+    /* found previously                                          */
+
+    /* if it is a memory-based resource, set up pointers */
+    if ( !stream->read )
+    {
+      parser->base_dict = (FT_Byte*)stream->base + stream->pos;
+      parser->base_len  = size;
+      parser->in_memory = 1;
+
+      /* check that the `size' field is valid */
+      if ( FT_STREAM_SKIP( size ) )
+        goto Exit;
+    }
+    else
+    {
+      /* read segment in memory */
+      if ( FT_ALLOC( parser->base_dict, size )       ||
+           FT_STREAM_READ( parser->base_dict, size ) )
+        goto Exit;
+
+      parser->base_len = size;
+    }
+
+    /* Now check font format; we must see `%!PS-TrueTypeFont' */
+    if (size <= 17                                    ||
+        ( ft_strncmp( (const char*)parser->base_dict,
+                      "%!PS-TrueTypeFont", 17) )      )
+      error = T42_Err_Unknown_File_Format;
+    else
+    {
+      parser->root.base   = parser->base_dict;
+      parser->root.cursor = parser->base_dict;
+      parser->root.limit  = parser->root.cursor + parser->base_len;
+    }
+
+  Exit:
+    if ( error && !parser->in_memory )
+      FT_FREE( parser->base_dict );
+
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t42_parser_done( T42_Parser  parser )
+  {
+    FT_Memory  memory = parser->root.memory;
+
+
+    /* free the base dictionary only when we have a disk stream */
+    if ( !parser->in_memory )
+      FT_FREE( parser->base_dict );
+
+    parser->root.funcs.done( &parser->root );
+  }
+
+
+  static int
+  t42_is_alpha( FT_Byte  c )
+  {
+    /* Note: we must accept "+" as a valid character, as it is used in */
+    /*       embedded type1 fonts in PDF documents.                    */
+    /*                                                                 */
+    return ( ft_isalnum( c ) ||
+             c == '.'        ||
+             c == '_'        ||
+             c == '-'        ||
+             c == '+'        );
+  }
+
+
+  static int
+  t42_is_space( FT_Byte  c )
+  {
+    return ( c == ' ' || c == '\t' || c == '\r' || c == '\n' );
+  }
+
+
+  static void
+  t42_parse_font_name( T42_Face    face,
+                       T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_Error    error;
+    FT_Memory   memory = parser->root.memory;
+    FT_Int      len;
+    FT_Byte*    cur;
+    FT_Byte*    cur2;
+    FT_Byte*    limit;
+
+
+    T1_Skip_Spaces( parser );
+
+    cur   = parser->root.cursor;
+    limit = parser->root.limit;
+
+    if ( cur >= limit - 1              ||
+         ( *cur != '/' && *cur != '(') )
+      return;
+
+    cur++;
+    cur2 = cur;
+    while ( cur2 < limit && t42_is_alpha( *cur2 ) )
+      cur2++;
+
+    len = (FT_Int)( cur2 - cur );
+    if ( len > 0 )
+    {
+      if ( FT_ALLOC( face->type1.font_name, len + 1 ) )
+      {
+        parser->root.error = error;
+        return;
+      }
+
+      FT_MEM_COPY( face->type1.font_name, cur, len );
+      face->type1.font_name[len] = '\0';
+    }
+    parser->root.cursor = cur2;
+  }
+
+
+  static void
+  t42_parse_font_bbox( T42_Face   face,
+                       T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_BBox*    bbox   = &face->type1.font_bbox;
+
+    bbox->xMin = T1_ToInt( parser );
+    bbox->yMin = T1_ToInt( parser );
+    bbox->xMax = T1_ToInt( parser );
+    bbox->yMax = T1_ToInt( parser );
+  }
+
+
+  static void
+  t42_parse_font_matrix( T42_Face    face,
+                         T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_Matrix*  matrix = &face->type1.font_matrix;
+    FT_Vector*  offset = &face->type1.font_offset;
+    FT_Face     root   = (FT_Face)&face->root;
+    FT_Fixed    temp[6];
+    FT_Fixed    temp_scale;
+
+
+    (void)T1_ToFixedArray( parser, 6, temp, 3 );
+
+    temp_scale = ABS( temp[3] );
+
+    /* Set Units per EM based on FontMatrix values.  We set the value to */
+    /* 1000 / temp_scale, because temp_scale was already multiplied by   */
+    /* 1000 (in t1_tofixed, from psobjs.c).                              */
+
+    root->units_per_EM = (FT_UShort)( FT_DivFix( 1000 * 0x10000L,
+                                                 temp_scale ) >> 16 );
+
+    /* we need to scale the values by 1.0/temp_scale */
+    if ( temp_scale != 0x10000L ) {
+      temp[0] = FT_DivFix( temp[0], temp_scale );
+      temp[1] = FT_DivFix( temp[1], temp_scale );
+      temp[2] = FT_DivFix( temp[2], temp_scale );
+      temp[4] = FT_DivFix( temp[4], temp_scale );
+      temp[5] = FT_DivFix( temp[5], temp_scale );
+      temp[3] = 0x10000L;
+    }
+
+    matrix->xx = temp[0];
+    matrix->yx = temp[1];
+    matrix->xy = temp[2];
+    matrix->yy = temp[3];
+
+    /* note that the offsets must be expressed in integer font units */
+    offset->x  = temp[4] >> 16;
+    offset->y  = temp[5] >> 16;
+  }
+
+
+  static void
+  t42_parse_encoding( T42_Face    face,
+                      T42_Loader  loader )
+  {
+    T42_Parser     parser = &loader->parser;
+    FT_Byte*       cur    = parser->root.cursor;
+    FT_Byte*       limit  = parser->root.limit;
+
+    PSAux_Service  psaux  = (PSAux_Service)face->psaux;
+
+
+    /* skip whitespace */
+    while ( t42_is_space( *cur ) )
+    {
+      cur++;
+      if ( cur >= limit )
+      {
+        FT_ERROR(( "t42_parse_encoding: out of bounds!\n" ));
+        parser->root.error = T42_Err_Invalid_File_Format;
+        return;
+      }
+    }
+
+    /* if we have a number, then the encoding is an array, */
+    /* and we must load it now                             */
+    if ( (FT_Byte)( *cur - '0' ) < 10 )
+    {
+      T1_Encoding  encode     = &face->type1.encoding;
+      FT_Int       count, n;
+      PS_Table     char_table = &loader->encoding_table;
+      FT_Memory    memory     = parser->root.memory;
+      FT_Error     error;
+
+
+      /* read the number of entries in the encoding, should be 256 */
+      count = T1_ToInt( parser );
+      if ( parser->root.error )
+        return;
+
+      /* we use a T1_Table to store our charnames */
+      loader->num_chars = encode->num_chars = count;
+      if ( FT_NEW_ARRAY( encode->char_index, count ) ||
+           FT_NEW_ARRAY( encode->char_name,  count ) ||
+           FT_SET_ERROR( psaux->ps_table_funcs->init(
+                           char_table, count, memory ) ) )
+      {
+        parser->root.error = error;
+        return;
+      }
+
+      /* We need to `zero' out encoding_table.elements */
+      for ( n = 0; n < count; n++ )
+      {
+        char*  notdef = (char *)".notdef";
+
+
+        T1_Add_Table( char_table, n, notdef, 8 );
+      }
+
+      /* Now, we will need to read a record of the form         */
+      /* ... charcode /charname ... for each entry in our table */
+      /*                                                        */
+      /* We simply look for a number followed by an immediate   */
+      /* name.  Note that this ignores correctly the sequence   */
+      /* that is often seen in type1 fonts:                     */
+      /*                                                        */
+      /*   0 1 255 { 1 index exch /.notdef put } for dup        */
+      /*                                                        */
+      /* used to clean the encoding array before anything else. */
+      /*                                                        */
+      /* We stop when we encounter a `def'.                     */
+
+      cur   = parser->root.cursor;
+      limit = parser->root.limit;
+      n     = 0;
+
+      for ( ; cur < limit; )
+      {
+        FT_Byte  c;
+
+
+        c = *cur;
+
+        /* we stop when we encounter a `def' */
+        if ( c == 'd' && cur + 3 < limit )
+        {
+          if ( cur[1] == 'e'       &&
+               cur[2] == 'f'       &&
+               t42_is_space( cur[-1] ) &&
+               t42_is_space( cur[3] )  )
+          {
+            FT_TRACE6(( "encoding end\n" ));
+            break;
+          }
+        }
+
+        /* otherwise, we must find a number before anything else */
+        if ( (FT_Byte)( c - '0' ) < 10 )
+        {
+          FT_Int  charcode;
+
+
+          parser->root.cursor = cur;
+          charcode = T1_ToInt( parser );
+          cur      = parser->root.cursor;
+
+          /* skip whitespace */
+          while ( cur < limit && t42_is_space( *cur ) )
+            cur++;
+
+          if ( cur < limit && *cur == '/' )
+          {
+            /* bingo, we have an immediate name -- it must be a */
+            /* character name                                   */
+            FT_Byte*  cur2 = cur + 1;
+            FT_Int    len;
+
+
+            while ( cur2 < limit && t42_is_alpha( *cur2 ) )
+              cur2++;
+
+            len = (FT_Int)( cur2 - cur - 1 );
+
+            parser->root.error = T1_Add_Table( char_table, charcode,
+                                               cur + 1, len + 1 );
+            char_table->elements[charcode][len] = '\0';
+            if ( parser->root.error )
+              return;
+
+            cur = cur2;
+          }
+        }
+        else
+          cur++;
+      }
+
+      face->type1.encoding_type  = T1_ENCODING_TYPE_ARRAY;
+      parser->root.cursor        = cur;
+    }
+    /* Otherwise, we should have either `StandardEncoding', */
+    /* `ExpertEncoding', or `ISOLatin1Encoding'             */
+    else
+    {
+      if ( cur + 17 < limit                                            &&
+           ft_strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_STANDARD;
+
+      else if ( cur + 15 < limit                                          &&
+                ft_strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_EXPERT;
+
+      else if ( cur + 18 < limit                                             &&
+                ft_strncmp( (const char*)cur, "ISOLatin1Encoding", 17 ) == 0 )
+        face->type1.encoding_type = T1_ENCODING_TYPE_ISOLATIN1;
+
+      else {
+        FT_ERROR(( "t42_parse_encoding: invalid token!\n" ));
+        parser->root.error = T42_Err_Invalid_File_Format;
+      }
+    }
+  }
+
+
+  static FT_UInt
+  t42_hexval( FT_Byte  v )
+  {
+    FT_UInt  d;
+    
+    d = (FT_UInt)( v - 'A' );
+    if ( d < 6 )
+    {
+      d += 10;
+      goto Exit;
+    }
+      
+    d = (FT_UInt)( v - 'a' );
+    if ( d < 6 )
+    {
+      d += 10;
+      goto Exit;
+    }
+      
+    d = (FT_UInt)( v - '0' );
+    if ( d < 10 )
+      goto Exit;
+      
+    d = 0;
+ 
+  Exit:         
+    return d;
+  }
+
+
+  static void
+  t42_parse_sfnts( T42_Face    face,
+                   T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_Memory   memory = parser->root.memory;
+    FT_Byte*    cur    = parser->root.cursor;
+    FT_Byte*    limit  = parser->root.limit;
+    FT_Error    error;
+    FT_Int      num_tables = 0, status;
+    FT_ULong    count, ttf_size = 0, string_size = 0;
+    FT_Bool     in_string  = 0;
+    FT_Byte     v = 0;
+
+
+    /* The format is `/sfnts [ <...> <...> ... ] def' */
+
+    while ( t42_is_space( *cur ) )
+      cur++;
+
+    if (*cur++ == '[')
+    {
+      status = 0;
+      count = 0;
+    }
+    else
+    {
+      FT_ERROR(( "t42_parse_sfnts: can't find begin of sfnts vector!\n" ));
+      error = T42_Err_Invalid_File_Format;
+      goto Fail;
+    }
+
+    while ( cur < limit - 2 )
+    {
+      while ( t42_is_space( *cur ) )
+        cur++;
+
+      switch ( *cur )
+      {
+      case ']':
+        parser->root.cursor = cur++;
+        return;
+
+      case '<':
+        in_string   = 1;
+        string_size = 0;
+        cur++;
+        continue;
+
+      case '>':
+        if ( !in_string )
+        {
+          FT_ERROR(( "t42_parse_sfnts: found unpaired `>'!\n" ));
+          error = T42_Err_Invalid_File_Format;
+          goto Fail;
+        }
+
+        /* A string can have, as a last byte,         */
+        /* a zero byte for padding.  If so, ignore it */
+        if ( ( v == 0 ) && ( string_size % 2 == 1 ) )
+          count--;
+        in_string = 0;
+        cur++;
+        continue;
+
+      case '%':
+        if ( !in_string )
+        {
+          /* Comment found; skip till end of line */
+          while ( *cur != '\n' )
+            cur++;
+          continue;
+        }
+        else
+        {
+          FT_ERROR(( "t42_parse_sfnts: found `%' in string!\n" ));
+          error = T42_Err_Invalid_File_Format;
+          goto Fail;
+        }
+
+      default:
+        if ( !ft_xdigit( *cur ) || !ft_xdigit( *(cur + 1) ) )
+        {
+          FT_ERROR(( "t42_parse_sfnts: found non-hex characters in string" ));
+          error = T42_Err_Invalid_File_Format;
+          goto Fail;
+        }
+
+        v = (FT_Byte)( 16 * t42_hexval( *cur ) + t42_hexval( *(cur + 1) ) );
+	cur++;
+	cur++;
+        string_size++;
+      }
+
+      switch ( status )
+      {
+      case 0: /* The '[' was read, so load offset table, 12 bytes */
+        if ( count < 12 )
+        {
+          face->ttf_data[count++] = v;
+          continue;
+        }
+        else
+        {
+          num_tables = 16 * face->ttf_data[4] + face->ttf_data[5];
+          status     = 1;
+          ttf_size   = 12 + 16 * num_tables;
+
+          if ( FT_REALLOC( face->ttf_data, 12, ttf_size ) )
+            goto Fail;
+        }
+        /* No break, fall-through */
+
+      case 1: /* The offset table is read; read now the table directory */
+        if ( count < ttf_size )
+        {
+          face->ttf_data[count++] = v;
+          continue;
+        }
+        else
+        {
+          int      i;
+          FT_ULong len;
+
+
+          for ( i = 0; i < num_tables; i++ )
+          {
+            FT_Byte*  p = face->ttf_data + 12 + 16*i + 12;
+            
+            len = FT_PEEK_ULONG( p );
+
+            /* Pad to a 4-byte boundary length */
+            ttf_size += ( len + 3 ) & ~3;
+          }
+
+          status         = 2;
+          face->ttf_size = ttf_size;
+
+          if ( FT_REALLOC( face->ttf_data, 12 + 16 * num_tables,
+                           ttf_size + 1 ) )
+            goto Fail;
+        }
+        /* No break, fall-through */
+
+      case 2: /* We are reading normal tables; just swallow them */
+        face->ttf_data[count++] = v;
+
+      }
+    }
+
+    /* If control reaches this point, the format was not valid */
+    error = T42_Err_Invalid_File_Format;
+
+  Fail:
+    parser->root.error = error;
+  }
+
+
+  static void
+  t42_parse_charstrings( T42_Face    face,
+                         T42_Loader  loader )
+  {
+    T42_Parser     parser     = &loader->parser;
+    PS_Table       code_table = &loader->charstrings;
+    PS_Table       name_table = &loader->glyph_names;
+    FT_Memory      memory     = parser->root.memory;
+    FT_Error       error;
+
+    PSAux_Service  psaux      = (PSAux_Service)face->psaux;
+
+    FT_Byte*       cur;
+    FT_Byte*       limit      = parser->root.limit;
+    FT_Int         n;
+
+
+    loader->num_glyphs = T1_ToInt( parser );
+    if ( parser->root.error )
+      return;
+
+    /* initialize tables */
+
+    error = psaux->ps_table_funcs->init( code_table,
+                                         loader->num_glyphs,
+                                         memory );
+    if ( error )
+      goto Fail;
+
+    error = psaux->ps_table_funcs->init( name_table,
+                                         loader->num_glyphs,
+                                         memory );
+    if ( error )
+      goto Fail;
+
+    n = 0;
+
+    for (;;)
+    {
+      /* the format is simple:                    */
+      /*   `/glyphname' + index + def             */
+      /*                                          */
+      /* note that we stop when we find an `end'  */
+      /*                                          */
+      T1_Skip_Spaces( parser );
+
+      cur = parser->root.cursor;
+      if ( cur >= limit )
+        break;
+
+      /* we stop when we find an `end' keyword */
+      if ( *cur   == 'e'   &&
+           cur + 3 < limit &&
+           cur[1] == 'n'   &&
+           cur[2] == 'd'   )
+        break;
+
+      if ( *cur != '/' )
+        T1_Skip_Alpha( parser );
+      else
+      {
+        FT_Byte*  cur2 = cur + 1;
+        FT_Int    len;
+
+
+        while ( cur2 < limit && t42_is_alpha( *cur2 ) )
+          cur2++;
+        len = (FT_Int)( cur2 - cur - 1 );
+
+        error = T1_Add_Table( name_table, n, cur + 1, len + 1 );
+        if ( error )
+          goto Fail;
+
+        /* add a trailing zero to the name table */
+        name_table->elements[n][len] = '\0';
+
+        parser->root.cursor = cur2;
+        T1_Skip_Spaces( parser );
+
+        cur2 = cur = parser->root.cursor;
+        if ( cur >= limit )
+          break;
+
+        while ( cur2 < limit && t42_is_alpha( *cur2 ) )
+          cur2++;
+        len = (FT_Int)( cur2 - cur );
+
+        error = T1_Add_Table( code_table, n, cur, len + 1 );
+        if ( error )
+          goto Fail;
+
+        code_table->elements[n][len] = '\0';
+
+        n++;
+        if ( n >= loader->num_glyphs )
+          break;
+      }
+    }
+
+    /* Index 0 must be a .notdef element */
+    if ( ft_strcmp( (char *)name_table->elements[0], ".notdef" ) )
+    {
+      FT_ERROR(( "t42_parse_charstrings: Index 0 is not `.notdef'!\n" ));
+      error = T42_Err_Invalid_File_Format;
+      goto Fail;
+    }
+
+    loader->num_glyphs = n;
+    return;
+
+  Fail:
+    parser->root.error = error;
+  }
+
+
+  static FT_Error
+  t42_load_keyword( T42_Face    face,
+                    T42_Loader  loader,
+                    T1_Field    field )
+  {
+    FT_Error  error;
+    void*     dummy_object;
+    void**    objects;
+    FT_UInt   max_objects = 0;
+
+
+    /* if the keyword has a dedicated callback, call it */
+    if ( field->type == T1_FIELD_TYPE_CALLBACK ) {
+      field->reader( (FT_Face)face, loader );
+      error = loader->parser.root.error;
+      goto Exit;
+    }
+
+    /* now, the keyword is either a simple field, or a table of fields; */
+    /* we are now going to take care of it                              */
+    switch ( field->location )
+    {
+    case T1_FIELD_LOCATION_FONT_INFO:
+      dummy_object = &face->type1.font_info;
+      objects      = &dummy_object;
+      break;
+
+    default:
+      dummy_object = &face->type1;
+      objects      = &dummy_object;
+    }
+
+    if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
+         field->type == T1_FIELD_TYPE_FIXED_ARRAY   )
+      error = T1_Load_Field_Table( &loader->parser, field,
+                                   objects, max_objects, 0 );
+    else
+      error = T1_Load_Field( &loader->parser, field,
+                             objects, max_objects, 0 );
+
+   Exit:
+    return error;
+  }
+
+
+  FT_LOCAL_DEF( FT_Error )
+  t42_parse_dict( T42_Face    face,
+                  T42_Loader  loader,
+                  FT_Byte*    base,
+                  FT_Long     size )
+  {
+    T42_Parser  parser = &loader->parser;
+    FT_Byte*    cur    = base;
+    FT_Byte*    limit  = cur + size;
+    FT_UInt     n_keywords = sizeof ( t42_keywords ) / 
+                             sizeof ( t42_keywords[0] );
+
+
+    parser->root.cursor = base;
+    parser->root.limit  = base + size;
+    parser->root.error  = 0;
+
+    for ( ; cur < limit; cur++ )
+    {
+      /* look for `FontDirectory', which causes problems on some fonts */
+      if ( *cur == 'F' && cur + 25 < limit                    &&
+           ft_strncmp( (char*)cur, "FontDirectory", 13 ) == 0 )
+      {
+        FT_Byte*  cur2;
+
+
+        /* skip the `FontDirectory' keyword */
+        cur += 13;
+        cur2 = cur;
+
+        /* lookup the `known' keyword */
+        while ( cur < limit && *cur != 'k'           &&
+                ft_strncmp( (char*)cur, "known", 5 ) )
+          cur++;
+
+        if ( cur < limit )
+        {
+          T1_TokenRec  token;
+
+
+          /* skip the `known' keyword and the token following it */
+          cur += 5;
+          loader->parser.root.cursor = cur;
+          T1_ToToken( &loader->parser, &token );
+
+          /* if the last token was an array, skip it! */
+          if ( token.type == T1_TOKEN_TYPE_ARRAY )
+            cur2 = parser->root.cursor;
+        }
+        cur = cur2;
+      }
+      /* look for immediates */
+      else if ( *cur == '/' && cur + 2 < limit )
+      {
+        FT_Byte*  cur2;
+        FT_UInt    i, len;
+
+
+        cur++;
+        cur2 = cur;
+        while ( cur2 < limit && t42_is_alpha( *cur2 ) )
+          cur2++;
+
+        len  = (FT_UInt)( cur2 - cur );
+        if ( len > 0 && len < 22 ) /* XXX What shall it this 22? */
+        {
+          /* now, compare the immediate name to the keyword table */
+
+          /* Loop through all known keywords */
+          for ( i = 0; i < n_keywords; i++ )
+          {
+            T1_Field  keyword = (T1_Field)&t42_keywords[i];
+            FT_Byte   *name   = (FT_Byte*)keyword->ident;
+
+
+            if ( !name )
+              continue;
+
+            if ( ( len == ft_strlen( (const char *)name ) ) &&
+                 ( ft_memcmp( cur, name, len ) == 0 )       )
+            {
+              /* we found it -- run the parsing callback! */
+              parser->root.cursor = cur2;
+              T1_Skip_Spaces( parser );
+              parser->root.error = t42_load_keyword(face,
+                                                    loader,
+                                                    keyword );
+              if ( parser->root.error )
+                return parser->root.error;
+              cur = parser->root.cursor;
+              break;
+            }
+          }
+        }
+      }
+    }
+    return parser->root.error;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t42_loader_init( T42_Loader  loader,
+                   T42_Face    face )
+  {
+    FT_UNUSED( face );
+
+    FT_MEM_SET( loader, 0, sizeof ( *loader ) );
+    loader->num_glyphs = 0;
+    loader->num_chars  = 0;
+
+    /* initialize the tables -- simply set their `init' field to 0 */
+    loader->encoding_table.init = 0;
+    loader->charstrings.init    = 0;
+    loader->glyph_names.init    = 0;
+  }
+
+
+  FT_LOCAL_DEF( void )
+  t42_loader_done( T42_Loader  loader )
+  {
+    T42_Parser  parser = &loader->parser;
+
+
+    /* finalize tables */
+    T1_Release_Table( &loader->encoding_table );
+    T1_Release_Table( &loader->charstrings );
+    T1_Release_Table( &loader->glyph_names );
+
+    /* finalize parser */
+    t42_parser_done( parser );
+  }
+
+
+/* END */
Index: xc/extras/freetype2/src/type42/t42parse.h
diff -u /dev/null xc/extras/freetype2/src/type42/t42parse.h:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/t42parse.h	Thu Jun 20 04:16:28 2002
@@ -0,0 +1,89 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42parse.h                                                             */
+/*                                                                         */
+/*    Type 42 font parser (specification).                                 */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42PARSE_H__
+#define __T42PARSE_H__
+
+
+#include "t42objs.h"
+#include FT_INTERNAL_POSTSCRIPT_AUX_H
+
+
+FT_BEGIN_HEADER
+
+  typedef struct  T42_ParserRec_
+  {
+    PS_ParserRec  root;
+    FT_Stream     stream;
+
+    FT_Byte*      base_dict;
+    FT_Int        base_len;
+
+    FT_Byte       in_memory;
+
+  } T42_ParserRec, *T42_Parser;
+
+
+  typedef struct  T42_Loader_
+  {
+    T42_ParserRec  parser;          /* parser used to read the stream */
+
+    FT_Int         num_chars;       /* number of characters in encoding */
+    PS_TableRec    encoding_table;  /* PS_Table used to store the       */
+                                    /* encoding character names         */
+
+    FT_Int         num_glyphs;
+    PS_TableRec    glyph_names;
+    PS_TableRec    charstrings;
+
+  } T42_LoaderRec, *T42_Loader;
+
+
+  FT_LOCAL( FT_Error )
+  t42_parser_init( T42_Parser     parser,
+                   FT_Stream      stream,
+                   FT_Memory      memory,
+                   PSAux_Service  psaux );
+
+  FT_LOCAL( void )
+  t42_parser_done( T42_Parser  parser );
+
+
+  FT_LOCAL( FT_Error )
+  t42_parse_dict( T42_Face    face,
+                  T42_Loader  loader,
+                  FT_Byte*    base,
+                  FT_Long     size );
+
+
+  FT_LOCAL( void )
+  t42_loader_init( T42_Loader  loader,
+                   T42_Face    face );
+
+  FT_LOCAL( void )
+  t42_loader_done( T42_Loader  loader );
+
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __T42PARSE_H__ */
+
+
+/* END */
Index: xc/extras/freetype2/src/type42/type42.c
diff -u /dev/null xc/extras/freetype2/src/type42/type42.c:1.1.1.1
--- /dev/null	Thu Feb 27 12:20:52 2003
+++ xc/extras/freetype2/src/type42/type42.c	Thu Jun 20 04:16:28 2002
@@ -0,0 +1,25 @@
+/***************************************************************************/
+/*                                                                         */
+/*  type42.c                                                               */
+/*                                                                         */
+/*    FreeType Type 42 driver component.                                   */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+#define FT_MAKE_OPTION_SINGLE_OBJECT
+
+#include <ft2build.h>
+#include "t42objs.c"
+#include "t42parse.c"
+#include "t42drivr.c"
+
+/* END */
Index: xc/extras/freetype2/src/winfonts/descrip.mms
diff -u xc/extras/freetype2/src/winfonts/descrip.mms:1.1.1.1 xc/extras/freetype2/src/winfonts/descrip.mms:1.1.1.3
--- xc/extras/freetype2/src/winfonts/descrip.mms:1.1.1.1	Tue May 15 23:45:43 2001
+++ xc/extras/freetype2/src/winfonts/descrip.mms	Thu Jun 20 04:16:28 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 2001 by
+# Copyright 2001, 2002 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
@@ -18,6 +18,6 @@
 OBJS=winfnt.obj
 
 all : $(OBJS)
-	library [--.lib]freetype.olb $(OBJS)
+        library [--.lib]freetype.olb $(OBJS)
 
 # EOF
Index: xc/extras/freetype2/src/winfonts/rules.mk
diff -u xc/extras/freetype2/src/winfonts/rules.mk:1.1.1.3 xc/extras/freetype2/src/winfonts/rules.mk:1.1.1.4
--- xc/extras/freetype2/src/winfonts/rules.mk:1.1.1.3	Sun Sep  9 22:56:12 2001
+++ xc/extras/freetype2/src/winfonts/rules.mk	Thu Jun 20 04:16:28 2002
@@ -3,7 +3,7 @@
 #
 
 
-# Copyright 1996-2000 by
+# Copyright 1996-2000, 2001 by
 # David Turner, Robert Wilhelm, and Werner Lemberg.
 #
 # This file is part of the FreeType project, and may only be used, modified,
Index: xc/extras/freetype2/src/winfonts/winfnt.c
diff -u xc/extras/freetype2/src/winfonts/winfnt.c:1.1.1.4 xc/extras/freetype2/src/winfonts/winfnt.c:1.1.1.6
--- xc/extras/freetype2/src/winfonts/winfnt.c:1.1.1.4	Sun Dec 16 12:49:37 2001
+++ xc/extras/freetype2/src/winfonts/winfnt.c	Thu Jun 20 04:16:28 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType font driver for Windows FNT/FON files                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -41,7 +41,7 @@
   const FT_Frame_Field  winmz_header_fields[] =
   {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  WinMZ_Header
+#define FT_STRUCTURE  WinMZ_HeaderRec
 
     FT_FRAME_START( 64 ),
       FT_FRAME_USHORT_LE ( magic ),
@@ -54,7 +54,7 @@
   const FT_Frame_Field  winne_header_fields[] =
   {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  WinNE_Header
+#define FT_STRUCTURE  WinNE_HeaderRec
 
     FT_FRAME_START( 40 ),
       FT_FRAME_USHORT_LE ( magic ),
@@ -68,7 +68,7 @@
   const FT_Frame_Field  winfnt_header_fields[] =
   {
 #undef  FT_STRUCTURE
-#define FT_STRUCTURE  WinFNT_Header
+#define FT_STRUCTURE  WinFNT_HeaderRec
 
     FT_FRAME_START( 134 ),
       FT_FRAME_USHORT_LE( version ),
@@ -112,11 +112,11 @@
 
 
   static void
-  fnt_font_done( FNT_Font*  font,
+  fnt_font_done( FNT_Font   font,
                  FT_Stream  stream )
   {
     if ( font->fnt_frame )
-      RELEASE_Frame( font->fnt_frame );
+      FT_FRAME_RELEASE( font->fnt_frame );
 
     font->fnt_size  = 0;
     font->fnt_frame = 0;
@@ -124,16 +124,16 @@
 
 
   static FT_Error
-  fnt_font_load( FNT_Font*  font,
+  fnt_font_load( FNT_Font   font,
                  FT_Stream  stream )
   {
-    FT_Error        error;
-    WinFNT_Header*  header = &font->header;
+    FT_Error       error;
+    WinFNT_Header  header = &font->header;
 
 
     /* first of all, read the FNT header */
-    if ( FILE_Seek( font->offset )                   ||
-         READ_Fields( winfnt_header_fields, header ) )
+    if ( FT_STREAM_SEEK( font->offset )                   ||
+         FT_STREAM_READ_FIELDS( winfnt_header_fields, header ) )
       goto Exit;
 
     /* check header */
@@ -157,8 +157,8 @@
       header->pixel_width = header->pixel_height;
 
     /* this is a FNT file/table, we now extract its frame */
-    if ( FILE_Seek( font->offset )                           ||
-         EXTRACT_Frame( header->file_size, font->fnt_frame ) )
+    if ( FT_STREAM_SEEK( font->offset )                         ||
+         FT_FRAME_EXTRACT( header->file_size, font->fnt_frame ) )
       goto Exit;
 
   Exit:
@@ -169,16 +169,16 @@
   static void
   fnt_face_done_fonts( FNT_Face  face )
   {
-    FT_Memory  memory = FT_FACE(face)->memory;
-    FT_Stream  stream = FT_FACE(face)->stream;
-    FNT_Font*  cur    = face->fonts;
-    FNT_Font*  limit  = cur + face->num_fonts;
+    FT_Memory  memory = FT_FACE( face )->memory;
+    FT_Stream  stream = FT_FACE( face )->stream;
+    FNT_Font   cur    = face->fonts;
+    FNT_Font   limit  = cur + face->num_fonts;
 
 
     for ( ; cur < limit; cur++ )
       fnt_font_done( cur, stream );
 
-    FREE( face->fonts );
+    FT_FREE( face->fonts );
     face->num_fonts = 0;
   }
 
@@ -186,29 +186,29 @@
   static FT_Error
   fnt_face_get_dll_fonts( FNT_Face  face )
   {
-    FT_Error      error;
-    FT_Stream     stream = FT_FACE(face)->stream;
-    FT_Memory     memory = FT_FACE(face)->memory;
-    WinMZ_Header  mz_header;
+    FT_Error         error;
+    FT_Stream        stream = FT_FACE( face )->stream;
+    FT_Memory        memory = FT_FACE( face )->memory;
+    WinMZ_HeaderRec  mz_header;
 
 
     face->fonts     = 0;
     face->num_fonts = 0;
 
     /* does it begin with a MZ header? */
-    if ( FILE_Seek( 0 )                                 ||
-         READ_Fields( winmz_header_fields, &mz_header ) )
+    if ( FT_STREAM_SEEK( 0 )                                 ||
+         FT_STREAM_READ_FIELDS( winmz_header_fields, &mz_header ) )
       goto Exit;
 
     error = FNT_Err_Unknown_File_Format;
     if ( mz_header.magic == WINFNT_MZ_MAGIC )
     {
       /* yes, now look for a NE header in the file */
-      WinNE_Header  ne_header;
+      WinNE_HeaderRec  ne_header;
 
 
-      if ( FILE_Seek( mz_header.lfanew )                  ||
-           READ_Fields( winne_header_fields, &ne_header ) )
+      if ( FT_STREAM_SEEK( mz_header.lfanew )                  ||
+           FT_STREAM_READ_FIELDS( winne_header_fields, &ne_header ) )
         goto Exit;
 
       error = FNT_Err_Unknown_File_Format;
@@ -223,35 +223,35 @@
         FT_ULong   font_offset = 0;
 
 
-        if ( FILE_Seek( res_offset ) ||
-             ACCESS_Frame( ne_header.rname_tab_offset -
-                           ne_header.resource_tab_offset ) )
+        if ( FT_STREAM_SEEK( res_offset ) ||
+             FT_FRAME_ENTER( ne_header.rname_tab_offset -
+                             ne_header.resource_tab_offset ) )
           goto Exit;
 
-        size_shift = GET_UShortLE();
+        size_shift = FT_GET_USHORT_LE();
 
         for (;;)
         {
           FT_UShort  type_id, count;
 
 
-          type_id = GET_UShortLE();
+          type_id = FT_GET_USHORT_LE();
           if ( !type_id )
             break;
 
-          count = GET_UShortLE();
+          count = FT_GET_USHORT_LE();
 
           if ( type_id == 0x8008 )
           {
             font_count  = count;
-            font_offset = (FT_ULong)( FILE_Pos() + 4 +
+            font_offset = (FT_ULong)( FT_STREAM_POS() + 4 +
                                       ( stream->cursor - stream->limit ) );
             break;
           }
 
           stream->cursor += 4 + count * 12;
         }
-        FORGET_Frame();
+        FT_FRAME_EXIT();
 
         if ( !font_count || !font_offset )
         {
@@ -260,35 +260,35 @@
           goto Exit;
         }
 
-        if ( FILE_Seek( font_offset )                         ||
-             ALLOC_ARRAY( face->fonts, font_count, FNT_Font ) )
+        if ( FT_STREAM_SEEK( font_offset )           ||
+             FT_NEW_ARRAY( face->fonts, font_count ) )
           goto Exit;
 
         face->num_fonts = font_count;
 
-        if ( ACCESS_Frame( (FT_Long)font_count * 12 ) )
+        if ( FT_FRAME_ENTER( (FT_Long)font_count * 12 ) )
           goto Exit;
 
         /* now read the offset and position of each FNT font */
         {
-          FNT_Font*  cur   = face->fonts;
-          FNT_Font*  limit = cur + font_count;
+          FNT_Font  cur   = face->fonts;
+          FNT_Font  limit = cur + font_count;
 
 
           for ( ; cur < limit; cur++ )
           {
-            cur->offset     = (FT_ULong)GET_UShortLE() << size_shift;
-            cur->fnt_size   = (FT_ULong)GET_UShortLE() << size_shift;
+            cur->offset     = (FT_ULong)FT_GET_USHORT_LE() << size_shift;
+            cur->fnt_size   = (FT_ULong)FT_GET_USHORT_LE() << size_shift;
             cur->size_shift = size_shift;
             stream->cursor += 8;
           }
         }
-        FORGET_Frame();
+        FT_FRAME_EXIT();
 
         /* finally, try to load each font there */
         {
-          FNT_Font*  cur   = face->fonts;
-          FNT_Font*  limit = cur + font_count;
+          FNT_Font  cur   = face->fonts;
+          FNT_Font  limit = cur + font_count;
 
 
           for ( ; cur < limit; cur++ )
@@ -310,6 +310,141 @@
   }
 
 
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+
+  typedef struct  FNT_CMapRec_
+  {
+    FT_CMapRec  cmap;
+    FT_UInt32   first;
+    FT_UInt32   count;
+
+  } FNT_CMapRec, *FNT_CMap;
+
+
+  static FT_Error
+  fnt_cmap_init( FNT_CMap  cmap )
+  {
+    FNT_Face  face = (FNT_Face)FT_CMAP_FACE( cmap );
+    FNT_Font  font = face->fonts;
+
+
+    cmap->first = (FT_UInt32)  font->header.first_char;
+    cmap->count = (FT_UInt32)( font->header.last_char - cmap->first + 1 );
+
+    return 0;
+  }
+
+
+  static FT_UInt
+  fnt_cmap_char_index( FNT_CMap   cmap,
+                       FT_UInt32  char_code )
+  {
+    FT_UInt  gindex = 0;
+
+
+    char_code -= cmap->first;
+    if ( char_code < cmap->count )
+      gindex = char_code + 1;
+
+    return gindex;
+  }
+
+
+  static FT_UInt
+  fnt_cmap_char_next( FNT_CMap    cmap,
+                      FT_UInt32  *pchar_code )
+  {
+    FT_UInt    gindex = 0;
+    FT_UInt32  result = 0;
+    FT_UInt32  char_code = *pchar_code + 1;
+
+
+    if ( char_code <= cmap->first )
+    {
+      result = cmap->first;
+      gindex = 1;
+    }
+    else
+    {
+      char_code -= cmap->first;
+      if ( char_code < cmap->count )
+      {
+        result = cmap->first + char_code;
+        gindex = char_code + 1;
+      }
+    }
+
+    *pchar_code = result;
+    return gindex;
+  }
+
+
+  static FT_CMap_ClassRec  fnt_cmap_class_rec =
+  {
+    sizeof ( FNT_CMapRec ),
+
+    (FT_CMap_InitFunc)     fnt_cmap_init,
+    (FT_CMap_DoneFunc)     NULL,
+    (FT_CMap_CharIndexFunc)fnt_cmap_char_index,
+    (FT_CMap_CharNextFunc) fnt_cmap_char_next
+  };
+
+  static FT_CMap_Class  fnt_cmap_class = &fnt_cmap_class_rec;
+
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+
+  static FT_UInt
+  FNT_Get_Char_Index( FT_CharMap  charmap,
+                      FT_Long     char_code )
+  {
+    FT_Long  result = char_code;
+
+
+    if ( charmap )
+    {
+      FNT_Font  font  = ((FNT_Face)charmap->face)->fonts;
+      FT_Long   first = font->header.first_char;
+      FT_Long   count = font->header.last_char - first + 1;
+
+
+      char_code -= first;
+      if ( char_code < count )
+        result = char_code + 1;
+      else
+        result = 0;
+    }
+
+    return result;
+  }
+
+
+  static FT_Long
+  FNT_Get_Next_Char( FT_CharMap  charmap,
+                     FT_Long     char_code )
+  {
+    char_code++;
+    if ( charmap )
+    {
+      FNT_Font  font  = ((FNT_Face)charmap->face)->fonts;
+      FT_Long   first = font->header.first_char;
+
+
+      if ( char_code < first )
+        char_code = first;
+      if ( char_code <= font->header.last_char )
+        return char_code;
+    }
+    else
+      return char_code;
+    return 0;
+  }
+
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
+
   static void
   FNT_Face_Done( FNT_Face  face )
   {
@@ -318,7 +453,7 @@
 
     fnt_face_done_fonts( face );
 
-    FREE( face->root.available_sizes );
+    FT_FREE( face->root.available_sizes );
     face->root.num_fixed_sizes = 0;
   }
 
@@ -343,9 +478,10 @@
     if ( error )
     {
       /* this didn't work, now try to load a single FNT font */
-      FNT_Font*  font;
+      FNT_Font  font;
+
 
-      if ( ALLOC( face->fonts, sizeof ( *face->fonts ) ) )
+      if ( FT_NEW( face->fonts ) )
         goto Exit;
 
       face->num_fonts = 1;
@@ -362,10 +498,10 @@
     /* all right, one or more fonts were loaded; we now need to */
     /* fill the root FT_Face fields with relevant information   */
     {
-      FT_Face    root  = FT_FACE( face );
-      FNT_Font*  fonts = face->fonts;
-      FNT_Font*  limit = fonts + face->num_fonts;
-      FNT_Font*  cur;
+      FT_Face   root  = FT_FACE( face );
+      FNT_Font  fonts = face->fonts;
+      FNT_Font  limit = fonts + face->num_fonts;
+      FNT_Font  cur;
 
 
       root->num_faces  = 1;
@@ -382,8 +518,7 @@
         root->style_flags |= FT_STYLE_FLAG_BOLD;
 
       /* Setup the `fixed_sizes' array */
-      if ( ALLOC_ARRAY( root->available_sizes, face->num_fonts,
-                        FT_Bitmap_Size ) )
+      if ( FT_NEW_ARRAY( root->available_sizes, face->num_fonts ) )
         goto Fail;
 
       root->num_fixed_sizes = face->num_fonts;
@@ -399,6 +534,25 @@
         }
       }
 
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+
+      {
+        FT_CharMapRec  charmap;
+
+        charmap.encoding    = ft_encoding_unicode;
+        charmap.platform_id = 3;
+        charmap.encoding_id = 1;
+        charmap.face        = root;
+
+        error = FT_CMap_New( fnt_cmap_class,
+                             NULL,
+                             &charmap,
+                             NULL );
+        if (error) goto Fail;
+      }
+
+#else /* !FT_CONFIG_OPTION_USE_CMAPS */
+
       /* Setup the `charmaps' array */
       root->charmaps     = &face->charmap_handle;
       root->num_charmaps = 1;
@@ -412,6 +566,8 @@
 
       root->charmap = face->charmap_handle;
 
+#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
+
       /* setup remaining flags */
       root->num_glyphs = fonts->header.last_char -
                          fonts->header.first_char + 1;
@@ -444,9 +600,9 @@
   FNT_Size_Set_Pixels( FNT_Size  size )
   {
     /* look up a font corresponding to the current pixel size */
-    FNT_Face   face  = (FNT_Face)FT_SIZE_FACE( size );
-    FNT_Font*  cur   = face->fonts;
-    FNT_Font*  limit = cur + face->num_fonts;
+    FNT_Face  face  = (FNT_Face)FT_SIZE_FACE( size );
+    FNT_Font  cur   = face->fonts;
+    FNT_Font  limit = cur + face->num_fonts;
 
 
     size->font = 0;
@@ -470,38 +626,13 @@
   }
 
 
-  static FT_UInt
-  FNT_Get_Char_Index( FT_CharMap  charmap,
-                      FT_Long     char_code )
-  {
-    FT_Long  result = char_code;
-
-
-    if ( charmap )
-    {
-      FNT_Font*  font  = ((FNT_Face)charmap->face)->fonts;
-      FT_Long    first = font->header.first_char;
-      FT_Long    count = font->header.last_char - first + 1;
-
-
-      char_code -= first;
-      if ( char_code < count )
-        result = char_code + 1;
-      else
-        result = 0;
-    }
-
-    return result;
-  }
-
-
   static FT_Error
   FNT_Load_Glyph( FT_GlyphSlot  slot,
                   FNT_Size      size,
                   FT_UInt       glyph_index,
                   FT_Int        load_flags )
   {
-    FNT_Font*   font  = size->font;
+    FNT_Font    font  = size->font;
     FT_Error    error = 0;
     FT_Byte*    p;
     FT_Int      len;
@@ -530,12 +661,12 @@
     /* jump to glyph entry */
     p = font->fnt_frame + 118 + len * glyph_index;
 
-    bitmap->width = NEXT_ShortLE(p);
+    bitmap->width = FT_NEXT_SHORT_LE( p );
 
     if ( new_format )
-      offset = NEXT_ULongLE(p);
+      offset = FT_NEXT_ULONG_LE( p );
     else
-      offset = NEXT_UShortLE(p);
+      offset = FT_NEXT_USHORT_LE( p );
 
     /* jump to glyph data */
     p = font->fnt_frame + /* font->header.bits_offset */ + offset;
@@ -552,7 +683,7 @@
       bitmap->rows       = font->header.pixel_height;
       bitmap->pixel_mode = ft_pixel_mode_mono;
 
-      if ( ALLOC( bitmap->buffer, pitch * bitmap->rows ) )
+      if ( FT_ALLOC( bitmap->buffer, pitch * bitmap->rows ) )
         goto Exit;
 
       column = (FT_Byte*)bitmap->buffer;
@@ -567,7 +698,7 @@
       }
     }
 
-    slot->flags       = ft_glyph_own_bitmap;
+    slot->flags       = FT_GLYPH_OWN_BITMAP;
     slot->bitmap_left = 0;
     slot->bitmap_top  = font->header.ascent;
     slot->format      = ft_glyph_format_bitmap;
@@ -586,7 +717,7 @@
 
 
   FT_CALLBACK_TABLE_DEF
-  const FT_Driver_Class  winfnt_driver_class =
+  const FT_Driver_ClassRec  winfnt_driver_class =
   {
     {
       ft_module_font_driver,
@@ -607,55 +738,34 @@
     sizeof( FNT_SizeRec ),
     sizeof( FT_GlyphSlotRec ),
 
-    (FTDriver_initFace)     FNT_Face_Init,
-    (FTDriver_doneFace)     FNT_Face_Done,
-    (FTDriver_initSize)     0,
-    (FTDriver_doneSize)     0,
-    (FTDriver_initGlyphSlot)0,
-    (FTDriver_doneGlyphSlot)0,
-
-    (FTDriver_setCharSizes) FNT_Size_Set_Pixels,
-    (FTDriver_setPixelSizes)FNT_Size_Set_Pixels,
-
-    (FTDriver_loadGlyph)    FNT_Load_Glyph,
-    (FTDriver_getCharIndex) FNT_Get_Char_Index,
-
-    (FTDriver_getKerning)   0,
-    (FTDriver_attachFile)   0,
-    (FTDriver_getAdvances)  0
+    (FT_Face_InitFunc)        FNT_Face_Init,
+    (FT_Face_DoneFunc)        FNT_Face_Done,
+    (FT_Size_InitFunc)        0,
+    (FT_Size_DoneFunc)        0,
+    (FT_Slot_InitFunc)        0,
+    (FT_Slot_DoneFunc)        0,
+
+    (FT_Size_ResetPointsFunc) FNT_Size_Set_Pixels,
+    (FT_Size_ResetPixelsFunc) FNT_Size_Set_Pixels,
+    (FT_Slot_LoadFunc)        FNT_Load_Glyph,
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharIndexFunc)0,
+#else
+    (FT_CharMap_CharIndexFunc)FNT_Get_Char_Index,
+#endif
+    
+
+    (FT_Face_GetKerningFunc)  0,
+    (FT_Face_AttachFunc)      0,
+    (FT_Face_GetAdvancesFunc) 0,
+
+#ifdef FT_CONFIG_OPTION_USE_CMAPS
+    (FT_CharMap_CharNextFunc) 0
+#else
+    (FT_CharMap_CharNextFunc) FNT_Get_Next_Char
+#endif    
   };
-
-
-#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
-
-
-  /*************************************************************************/
-  /*                                                                       */
-  /* <Function>                                                            */
-  /*    getDriverClass                                                     */
-  /*                                                                       */
-  /* <Description>                                                         */
-  /*    This function is used when compiling the TrueType driver as a      */
-  /*    shared library (`.DLL' or `.so').  It will be used by the          */
-  /*    high-level library of FreeType to retrieve the address of the      */
-  /*    driver's generic interface.                                        */
-  /*                                                                       */
-  /*    It shouldn't be implemented in a static build, as each driver must */
-  /*    have the same function as an exported entry point.                 */
-  /*                                                                       */
-  /* <Return>                                                              */
-  /*    The address of the TrueType's driver generic interface.  The       */
-  /*    format-specific interface can then be retrieved through the method */
-  /*    interface->get_format_interface.                                   */
-  /*                                                                       */
-  FT_EXPORT_DEF( const FT_Driver_Class* )
-  getDriverClass( void )
-  {
-    return &winfnt_driver_class;
-  }
-
-
-#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
 
 
 /* END */
Index: xc/extras/freetype2/src/winfonts/winfnt.c.save
diff -u /dev/null xc/extras/freetype2/src/winfonts/winfnt.c.save:1.2
--- /dev/null	Thu Feb 27 12:20:53 2003
+++ xc/extras/freetype2/src/winfonts/winfnt.c.save	Fri Oct 25 11:01:06 2002
@@ -0,0 +1,684 @@
+/***************************************************************************/
+/*                                                                         */
+/*  winfnt.c                                                               */
+/*                                                                         */
+/*    FreeType font driver for Windows FNT/FON files                       */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DEBUG_H
+#include FT_INTERNAL_STREAM_H
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_FNT_TYPES_H
+
+#include "winfnt.h"
+
+#include "fnterrs.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_winfnt
+
+
+  static
+  const FT_Frame_Field  winmz_header_fields[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  WinMZ_Header
+
+    FT_FRAME_START( 64 ),
+      FT_FRAME_USHORT_LE ( magic ),
+      FT_FRAME_SKIP_BYTES( 29 * 2 ),
+      FT_FRAME_ULONG_LE  ( lfanew ),
+    FT_FRAME_END
+  };
+
+  static
+  const FT_Frame_Field  winne_header_fields[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  WinNE_Header
+
+    FT_FRAME_START( 40 ),
+      FT_FRAME_USHORT_LE ( magic ),
+      FT_FRAME_SKIP_BYTES( 34 ),
+      FT_FRAME_USHORT_LE ( resource_tab_offset ),
+      FT_FRAME_USHORT_LE ( rname_tab_offset ),
+    FT_FRAME_END
+  };
+
+  static
+  const FT_Frame_Field  winfnt_header_fields[] =
+  {
+#undef  FT_STRUCTURE
+#define FT_STRUCTURE  WinFNT_Header
+
+    FT_FRAME_START( 134 ),
+      FT_FRAME_USHORT_LE( version ),
+      FT_FRAME_ULONG_LE ( file_size ),
+      FT_FRAME_BYTES    ( copyright, 60 ),
+      FT_FRAME_USHORT_LE( file_type ),
+      FT_FRAME_USHORT_LE( nominal_point_size ),
+      FT_FRAME_USHORT_LE( vertical_resolution ),
+      FT_FRAME_USHORT_LE( horizontal_resolution ),
+      FT_FRAME_USHORT_LE( ascent ),
+      FT_FRAME_USHORT_LE( internal_leading ),
+      FT_FRAME_USHORT_LE( external_leading ),
+      FT_FRAME_BYTE     ( italic ),
+      FT_FRAME_BYTE     ( underline ),
+      FT_FRAME_BYTE     ( strike_out ),
+      FT_FRAME_USHORT_LE( weight ),
+      FT_FRAME_BYTE     ( charset ),
+      FT_FRAME_USHORT_LE( pixel_width ),
+      FT_FRAME_USHORT_LE( pixel_height ),
+      FT_FRAME_BYTE     ( pitch_and_family ),
+      FT_FRAME_USHORT_LE( avg_width ),
+      FT_FRAME_USHORT_LE( max_width ),
+      FT_FRAME_BYTE     ( first_char ),
+      FT_FRAME_BYTE     ( last_char ),
+      FT_FRAME_BYTE     ( default_char ),
+      FT_FRAME_BYTE     ( break_char ),
+      FT_FRAME_USHORT_LE( bytes_per_row ),
+      FT_FRAME_ULONG_LE ( device_offset ),
+      FT_FRAME_ULONG_LE ( face_name_offset ),
+      FT_FRAME_ULONG_LE ( bits_pointer ),
+      FT_FRAME_ULONG_LE ( bits_offset ),
+      FT_FRAME_BYTE     ( reserved ),
+      FT_FRAME_ULONG_LE ( flags ),
+      FT_FRAME_USHORT_LE( A_space ),
+      FT_FRAME_USHORT_LE( B_space ),
+      FT_FRAME_USHORT_LE( C_space ),
+      FT_FRAME_USHORT_LE( color_table_offset ),
+      FT_FRAME_BYTES    ( reserved, 4 ),
+    FT_FRAME_END
+  };
+
+
+  static void
+  fnt_font_done( FNT_Font*  font,
+                 FT_Stream  stream )
+  {
+    if ( font->fnt_frame )
+      RELEASE_Frame( font->fnt_frame );
+
+    font->fnt_size  = 0;
+    font->fnt_frame = 0;
+  }
+
+
+  static FT_Error
+  fnt_font_load( FNT_Font*  font,
+                 FT_Stream  stream )
+  {
+    FT_Error        error;
+    WinFNT_Header*  header = &font->header;
+
+
+    /* first of all, read the FNT header */
+    if ( FILE_Seek( font->offset )                   ||
+         READ_Fields( winfnt_header_fields, header ) )
+      goto Exit;
+
+    /* check header */
+    if ( header->version != 0x200 &&
+         header->version != 0x300 )
+    {
+      FT_TRACE2(( "[not a valid FNT file]\n" ));
+      error = FNT_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    if ( header->file_type & 1 )
+    {
+      FT_TRACE2(( "[can't handle vector FNT fonts]\n" ));
+      error = FNT_Err_Unknown_File_Format;
+      goto Exit;
+    }
+
+    /* small fixup -- some fonts have the `pixel_width' field set to 0 */
+    if ( header->pixel_width == 0 )
+      header->pixel_width = header->pixel_height;
+
+    /* this is a FNT file/table, we now extract its frame */
+    if ( FILE_Seek( font->offset )                           ||
+         EXTRACT_Frame( header->file_size, font->fnt_frame ) )
+      goto Exit;
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  fnt_face_done_fonts( FNT_Face  face )
+  {
+    FT_Memory  memory = FT_FACE(face)->memory;
+    FT_Stream  stream = FT_FACE(face)->stream;
+    FNT_Font*  cur    = face->fonts;
+    FNT_Font*  limit  = cur + face->num_fonts;
+
+
+    for ( ; cur < limit; cur++ )
+      fnt_font_done( cur, stream );
+
+    FREE( face->fonts );
+    face->num_fonts = 0;
+  }
+
+
+  static FT_Error
+  fnt_face_get_dll_fonts( FNT_Face  face )
+  {
+    FT_Error      error;
+    FT_Stream     stream = FT_FACE(face)->stream;
+    FT_Memory     memory = FT_FACE(face)->memory;
+    WinMZ_Header  mz_header;
+
+
+    face->fonts     = 0;
+    face->num_fonts = 0;
+
+    /* does it begin with a MZ header? */
+    if ( FILE_Seek( 0 )                                 ||
+         READ_Fields( winmz_header_fields, &mz_header ) )
+      goto Exit;
+
+    error = FNT_Err_Unknown_File_Format;
+    if ( mz_header.magic == WINFNT_MZ_MAGIC )
+    {
+      /* yes, now look for a NE header in the file */
+      WinNE_Header  ne_header;
+
+
+      if ( FILE_Seek( mz_header.lfanew )                  ||
+           READ_Fields( winne_header_fields, &ne_header ) )
+        goto Exit;
+
+      error = FNT_Err_Unknown_File_Format;
+      if ( ne_header.magic == WINFNT_NE_MAGIC )
+      {
+        /* good, now look in the resource table for each FNT resource */
+        FT_ULong   res_offset = mz_header.lfanew +
+                                ne_header.resource_tab_offset;
+
+        FT_UShort  size_shift;
+        FT_UShort  font_count  = 0;
+        FT_ULong   font_offset = 0;
+
+
+        if ( FILE_Seek( res_offset ) ||
+             ACCESS_Frame( ne_header.rname_tab_offset -
+                           ne_header.resource_tab_offset ) )
+          goto Exit;
+
+        size_shift = GET_UShortLE();
+
+        for (;;)
+        {
+          FT_UShort  type_id, count;
+
+
+          type_id = GET_UShortLE();
+          if ( !type_id )
+            break;
+
+          count = GET_UShortLE();
+
+          if ( type_id == 0x8008 )
+          {
+            font_count  = count;
+            font_offset = (FT_ULong)( FILE_Pos() + 4 +
+                                      ( stream->cursor - stream->limit ) );
+            break;
+          }
+
+          stream->cursor += 4 + count * 12;
+        }
+        FORGET_Frame();
+
+        if ( !font_count || !font_offset )
+        {
+          FT_TRACE2(( "this file doesn't contain any FNT resources!\n" ));
+          error = FNT_Err_Unknown_File_Format;
+          goto Exit;
+        }
+
+        if ( FILE_Seek( font_offset )                         ||
+             ALLOC_ARRAY( face->fonts, font_count, FNT_Font ) )
+          goto Exit;
+
+        face->num_fonts = font_count;
+
+        if ( ACCESS_Frame( (FT_Long)font_count * 12 ) )
+          goto Exit;
+
+        /* now read the offset and position of each FNT font */
+        {
+          FNT_Font*  cur   = face->fonts;
+          FNT_Font*  limit = cur + font_count;
+
+
+          for ( ; cur < limit; cur++ )
+          {
+            cur->offset     = (FT_ULong)GET_UShortLE() << size_shift;
+            cur->fnt_size   = (FT_ULong)GET_UShortLE() << size_shift;
+            cur->size_shift = size_shift;
+            stream->cursor += 8;
+          }
+        }
+        FORGET_Frame();
+
+        /* finally, try to load each font there */
+        {
+          FNT_Font*  cur   = face->fonts;
+          FNT_Font*  limit = cur + font_count;
+
+
+          for ( ; cur < limit; cur++ )
+          {
+            error = fnt_font_load( cur, stream );
+            if ( error )
+              goto Fail;
+          }
+        }
+      }
+    }
+
+  Fail:
+    if ( error )
+      fnt_face_done_fonts( face );
+
+  Exit:
+    return error;
+  }
+
+
+  static void
+  FNT_Face_Done( FNT_Face  face )
+  {
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+
+    fnt_face_done_fonts( face );
+
+    FREE( face->root.available_sizes );
+    face->root.num_fixed_sizes = 0;
+  }
+
+
+  static FT_Error
+  FNT_Face_Init( FT_Stream      stream,
+                 FNT_Face       face,
+                 FT_Int         face_index,
+                 FT_Int         num_params,
+                 FT_Parameter*  params )
+  {
+    FT_Error   error;
+    FT_Memory  memory = FT_FACE_MEMORY( face );
+
+    FT_UNUSED( num_params );
+    FT_UNUSED( params );
+    FT_UNUSED( face_index );
+
+
+    /* try to load several fonts from a DLL */
+    error = fnt_face_get_dll_fonts( face );
+    if ( error )
+    {
+      /* this didn't work, now try to load a single FNT font */
+      FNT_Font*  font;
+
+      if ( ALLOC( face->fonts, sizeof ( *face->fonts ) ) )
+        goto Exit;
+
+      face->num_fonts = 1;
+      font            = face->fonts;
+
+      font->offset   = 0;
+      font->fnt_size = stream->size;
+
+      error = fnt_font_load( font, stream );
+      if ( error )
+        goto Fail;
+    }
+
+    /* all right, one or more fonts were loaded; we now need to */
+    /* fill the root FT_Face fields with relevant information   */
+    {
+      FT_Face    root  = FT_FACE( face );
+      FNT_Font*  fonts = face->fonts;
+      FNT_Font*  limit = fonts + face->num_fonts;
+      FNT_Font*  cur;
+
+
+      root->num_faces  = 1;
+      root->face_flags = FT_FACE_FLAG_FIXED_SIZES |
+                         FT_FACE_FLAG_HORIZONTAL;
+
+      if ( fonts->header.avg_width == fonts->header.max_width )
+        root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
+
+      if ( fonts->header.italic )
+        root->style_flags |= FT_STYLE_FLAG_ITALIC;
+
+      if ( fonts->header.weight >= 800 )
+        root->style_flags |= FT_STYLE_FLAG_BOLD;
+
+      /* Setup the `fixed_sizes' array */
+      if ( ALLOC_ARRAY( root->available_sizes, face->num_fonts,
+                        FT_Bitmap_Size ) )
+        goto Fail;
+
+      root->num_fixed_sizes = face->num_fonts;
+
+      {
+        FT_Bitmap_Size*  size = root->available_sizes;
+
+
+        for ( cur = fonts; cur < limit; cur++, size++ )
+        {
+          size->width  = cur->header.pixel_width;
+          size->height = cur->header.pixel_height;
+        }
+      }
+
+      /* Setup the `charmaps' array */
+      root->charmaps     = &face->charmap_handle;
+      root->num_charmaps = 1;
+
+      face->charmap.encoding    = ft_encoding_unicode;
+      face->charmap.platform_id = 3;
+      face->charmap.encoding_id = 1;
+      face->charmap.face        = root;
+
+      face->charmap_handle = &face->charmap;
+
+      root->charmap = face->charmap_handle;
+
+      /* setup remaining flags */
+      root->num_glyphs = fonts->header.last_char -
+                         fonts->header.first_char + 1;
+
+      root->family_name = (FT_String*)fonts->fnt_frame +
+                          fonts->header.face_name_offset;
+      root->style_name  = (char *)"Regular";
+
+      if ( root->style_flags & FT_STYLE_FLAG_BOLD )
+      {
+        if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+          root->style_name = (char *)"Bold Italic";
+        else
+          root->style_name = (char *)"Bold";
+      }
+      else if ( root->style_flags & FT_STYLE_FLAG_ITALIC )
+        root->style_name = (char *)"Italic";
+    }
+
+  Fail:
+    if ( error )
+      FNT_Face_Done( face );
+
+  Exit:
+    return error;
+  }
+
+
+  static FT_Error
+  FNT_Size_Set_Pixels( FNT_Size  size )
+  {
+    /* look up a font corresponding to the current pixel size */
+    FNT_Face   face  = (FNT_Face)FT_SIZE_FACE( size );
+    FNT_Font*  cur   = face->fonts;
+    FNT_Font*  limit = cur + face->num_fonts;
+
+
+    size->font = 0;
+    for ( ; cur < limit; cur++ )
+    {
+      /* we only compare the character height, as fonts used some strange */
+      /* values                                                           */
+      if ( cur->header.pixel_height == size->root.metrics.y_ppem )
+      {
+        size->font = cur;
+
+        size->root.metrics.ascender  = cur->header.ascent * 64;
+        size->root.metrics.descender = ( cur->header.pixel_height -
+                                           cur->header.ascent ) * 64;
+        size->root.metrics.height    = cur->header.pixel_height * 64;
+        break;
+      }
+    }
+
+    return ( size->font ? FNT_Err_Ok : FNT_Err_Invalid_Pixel_Size );
+  }
+
+
+  static FT_UInt
+  FNT_Get_Char_Index( FT_CharMap  charmap,
+                      FT_Long     char_code )
+  {
+    FT_Long  result = char_code;
+
+
+    if ( charmap )
+    {
+      FNT_Font*  font  = ((FNT_Face)charmap->face)->fonts;
+      FT_Long    first = font->header.first_char;
+      FT_Long    count = font->header.last_char - first + 1;
+
+
+      char_code -= first;
+      if ( char_code < count )
+        result = char_code + 1;
+      else
+        result = 0;
+    }
+
+    return result;
+  }
+
+  static FT_Long
+  FNT_Get_Next_Char( FT_CharMap  charmap,
+                     FT_Long     char_code )
+  {
+    char_code++;
+    if ( charmap )
+    {
+      FNT_Font*  font  = ((FNT_Face)charmap->face)->fonts;
+      FT_Long    first = font->header.first_char;
+
+
+      if ( char_code < first )
+        char_code = first;
+      if ( char_code <= font->header.last_char )
+        return char_code;
+    }
+    else
+      return char_code;
+    return 0;
+  }
+
+
+  static FT_Error
+  FNT_Load_Glyph( FT_GlyphSlot  slot,
+                  FNT_Size      size,
+                  FT_UInt       glyph_index,
+                  FT_Int        load_flags )
+  {
+    FNT_Font*   font  = size->font;
+    FT_Error    error = 0;
+    FT_Byte*    p;
+    FT_Int      len;
+    FT_Bitmap*  bitmap = &slot->bitmap;
+    FT_ULong    offset;
+    FT_Bool     new_format;
+
+    FT_UNUSED( slot );
+    FT_UNUSED( load_flags );
+
+
+    if ( !font )
+    {
+      error = FNT_Err_Invalid_Argument;
+      goto Exit;
+    }
+
+    if ( glyph_index > 0 )
+      glyph_index--;
+    else
+      glyph_index = font->header.default_char - font->header.first_char;
+
+    new_format = FT_BOOL( font->header.version == 0x300 );
+    len        = new_format ? 6 : 4;
+
+    /* jump to glyph entry */
+    p = font->fnt_frame + 118 + len * glyph_index;
+
+    bitmap->width = NEXT_ShortLE(p);
+
+    if ( new_format )
+      offset = NEXT_ULongLE(p);
+    else
+      offset = NEXT_UShortLE(p);
+
+    /* jump to glyph data */
+    p = font->fnt_frame + /* font->header.bits_offset */ + offset;
+
+    /* allocate and build bitmap */
+    {
+      FT_Memory  memory = FT_FACE_MEMORY( slot->face );
+      FT_Int     pitch  = ( bitmap->width + 7 ) >> 3;
+      FT_Byte*   column;
+      FT_Byte*   write;
+
+
+      bitmap->pitch      = pitch;
+      bitmap->rows       = font->header.pixel_height;
+      bitmap->pixel_mode = ft_pixel_mode_mono;
+
+      if ( ALLOC( bitmap->buffer, pitch * bitmap->rows ) )
+        goto Exit;
+
+      column = (FT_Byte*)bitmap->buffer;
+
+      for ( ; pitch > 0; pitch--, column++ )
+      {
+        FT_Byte*  limit = p + bitmap->rows;
+
+
+        for ( write = column; p < limit; p++, write += bitmap->pitch )
+          write[0] = p[0];
+      }
+    }
+
+    slot->flags       = ft_glyph_own_bitmap;
+    slot->bitmap_left = 0;
+    slot->bitmap_top  = font->header.ascent;
+    slot->format      = ft_glyph_format_bitmap;
+
+    /* now set up metrics */
+    slot->metrics.horiAdvance  = bitmap->width << 6;
+    slot->metrics.horiBearingX = 0;
+    slot->metrics.horiBearingY = slot->bitmap_top << 6;
+
+    slot->linearHoriAdvance    = (FT_Fixed)bitmap->width << 16;
+    slot->format               = ft_glyph_format_bitmap;
+
+  Exit:
+    return error;
+  }
+
+
+  FT_CALLBACK_TABLE_DEF
+  const FT_Driver_Class  winfnt_driver_class =
+  {
+    {
+      ft_module_font_driver,
+      sizeof ( FT_DriverRec ),
+
+      "winfonts",
+      0x10000L,
+      0x20000L,
+
+      0,
+
+      (FT_Module_Constructor)0,
+      (FT_Module_Destructor) 0,
+      (FT_Module_Requester)  0
+    },
+
+    sizeof( FNT_FaceRec ),
+    sizeof( FNT_SizeRec ),
+    sizeof( FT_GlyphSlotRec ),
+
+    (FTDriver_initFace)     FNT_Face_Init,
+    (FTDriver_doneFace)     FNT_Face_Done,
+    (FTDriver_initSize)     0,
+    (FTDriver_doneSize)     0,
+    (FTDriver_initGlyphSlot)0,
+    (FTDriver_doneGlyphSlot)0,
+
+    (FTDriver_setCharSizes) FNT_Size_Set_Pixels,
+    (FTDriver_setPixelSizes)FNT_Size_Set_Pixels,
+
+    (FTDriver_loadGlyph)    FNT_Load_Glyph,
+    (FTDriver_getCharIndex) FNT_Get_Char_Index,
+
+    (FTDriver_getKerning)   0,
+    (FTDriver_attachFile)   0,
+    (FTDriver_getAdvances)  0,
+
+    (FTDriver_getNextChar)  FNT_Get_Next_Char
+  };
+
+
+#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    getDriverClass                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used when compiling the TrueType driver as a      */
+  /*    shared library (`.DLL' or `.so').  It will be used by the          */
+  /*    high-level library of FreeType to retrieve the address of the      */
+  /*    driver's generic interface.                                        */
+  /*                                                                       */
+  /*    It shouldn't be implemented in a static build, as each driver must */
+  /*    have the same function as an exported entry point.                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The address of the TrueType's driver generic interface.  The       */
+  /*    format-specific interface can then be retrieved through the method */
+  /*    interface->get_format_interface.                                   */
+  /*                                                                       */
+  FT_EXPORT_DEF( const FT_Driver_Class* )
+  getDriverClass( void )
+  {
+    return &winfnt_driver_class;
+  }
+
+
+#endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */
+
+
+/* END */
Index: xc/extras/freetype2/src/winfonts/winfnt.h
diff -u xc/extras/freetype2/src/winfonts/winfnt.h:1.1.1.3 xc/extras/freetype2/src/winfonts/winfnt.h:1.1.1.4
--- xc/extras/freetype2/src/winfonts/winfnt.h:1.1.1.3	Sun Dec 16 12:49:37 2001
+++ xc/extras/freetype2/src/winfonts/winfnt.h	Thu Jun 20 04:16:28 2002
@@ -4,7 +4,7 @@
 /*                                                                         */
 /*    FreeType font driver for Windows FNT/FON files                       */
 /*                                                                         */
-/*  Copyright 1996-2001 by                                                 */
+/*  Copyright 1996-2001, 2002 by                                           */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
@@ -27,7 +27,7 @@
 FT_BEGIN_HEADER
 
 
-  FT_EXPORT_VAR( const FT_Driver_Class )  winfnt_driver_class;
+  FT_EXPORT_VAR( const FT_Driver_ClassRec )  winfnt_driver_class;
 
 
 FT_END_HEADER
Index: xc/extras/ogl-sample/main/doc/man/mangl/GNUmakefile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/GNUmakefile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/GNUmakefile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/GNUmakefile:1.3	Mon Jan 14 17:13:00 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/GNUmakefile	Fri Feb 22 16:32:34 2002
@@ -32,8 +32,6 @@
 # published by SGI, but has not been independently verified as being
 # compliant with the OpenGL(R) version 1.2.1 Specification.
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/GNUmakefile#9 $
 
 COMMONPREF = standard
 include $(ROOT)/usr/include/make/commondefs
Index: xc/extras/ogl-sample/main/doc/man/mangl/template
diff -u xc/extras/ogl-sample/main/doc/man/mangl/template:1.3 xc/extras/ogl-sample/main/doc/man/mangl/template:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/template:1.3	Mon Jan 14 17:13:00 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/template	Fri Feb 22 16:32:34 2002
@@ -33,8 +33,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
-_C_ $Header$
 _C_
 _C_ _define(_filters,tbl|eqn)_C_
 _C_	 eqn is automatically replaced with neqn for nroff
Index: xc/extras/ogl-sample/main/doc/man/mangl/ftn/Distfile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/ftn/Distfile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/ftn/Distfile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/ftn/Distfile:1.3	Mon Jan 14 17:13:14 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/ftn/Distfile	Fri Feb 22 16:32:34 2002
@@ -1,6 +1,4 @@
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/ftn/Distfile#5 $
 #
 
 DISTDIR_SI = /xc/doc/man/GL/gl_ftn
Index: xc/extras/ogl-sample/main/doc/man/mangl/ftn/GNUmakefile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/ftn/GNUmakefile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/ftn/GNUmakefile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/ftn/GNUmakefile:1.3	Mon Jan 14 17:13:14 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/ftn/GNUmakefile	Fri Feb 22 16:32:34 2002
@@ -32,8 +32,6 @@
 # published by SGI, but has not been independently verified as being
 # compliant with the OpenGL(R) version 1.2.1 Specification.
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/ftn/GNUmakefile#9 $
 
 # NOTES:
 # - The file "lor-c.mn" contains the source for the List of Routines section
Index: xc/extras/ogl-sample/main/doc/man/mangl/html/Distfile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/html/Distfile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/html/Distfile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/html/Distfile:1.3	Mon Jan 14 17:13:18 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/html/Distfile	Fri Feb 22 16:32:35 2002
@@ -1,6 +1,4 @@
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/html/Distfile#4 $
 #
 
 DISTDIR_SI = /xc/doc/hardcopy/GL/html/gl
Index: xc/extras/ogl-sample/main/doc/man/mangl/html/GNUmakefile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/html/GNUmakefile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/html/GNUmakefile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/html/GNUmakefile:1.3	Mon Jan 14 17:13:18 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/html/GNUmakefile	Fri Feb 22 16:32:35 2002
@@ -32,8 +32,6 @@
 # published by SGI, but has not been independently verified as being
 # compliant with the OpenGL(R) version 1.2.1 Specification.
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/html/GNUmakefile#9 $
 
 COMMONPREF = standard
 include $(ROOT)/usr/include/make/commondefs
Index: xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/Distfile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/Distfile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/Distfile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/Distfile:1.3	Mon Jan 14 17:13:21 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/Distfile	Fri Feb 22 16:32:35 2002
@@ -1,6 +1,4 @@
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/html_ftn/Distfile#4 $
 #
 
 DISTDIR_SI = /xc/doc/hardcopy/GL/html/gl_ftn
Index: xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/GNUmakefile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/GNUmakefile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/GNUmakefile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/GNUmakefile:1.3	Mon Jan 14 17:13:21 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/html_ftn/GNUmakefile	Fri Feb 22 16:32:35 2002
@@ -32,8 +32,6 @@
 # published by SGI, but has not been independently verified as being
 # compliant with the OpenGL(R) version 1.2.1 Specification.
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/html_ftn/GNUmakefile#9 $
 
 COMMONPREF = standard
 include $(ROOT)/usr/include/make/commondefs
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/Distfile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/Distfile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/Distfile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/Distfile:1.3	Mon Jan 14 17:13:28 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/Distfile	Fri Feb 22 16:32:36 2002
@@ -1,6 +1,4 @@
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/standard/Distfile#5 $
 #
 
 DISTDIR_SI = /xc/doc/man/GL/gl
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/GNUmakefile
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/GNUmakefile:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/GNUmakefile:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/GNUmakefile:1.3	Mon Jan 14 17:13:28 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/GNUmakefile	Fri Feb 22 16:32:36 2002
@@ -32,8 +32,6 @@
 # published by SGI, but has not been independently verified as being
 # compliant with the OpenGL(R) version 1.2.1 Specification.
 #
-# $Date$ $Revision$
-# $Header: //depot/main/doc/man/mangl/standard/GNUmakefile#11 $
 
 # NOTES:
 # - The file "lor-c.mn" contains the source for the List of Routines section
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/accum.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/accum.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/accum.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/accum.gl:1.3	Mon Jan 14 17:13:28 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/accum.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/activetextureARB.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/activetextureARB.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/activetextureARB.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/activetextureARB.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/activetextureARB.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/alphafunc.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/alphafunc.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/alphafunc.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/alphafunc.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/alphafunc.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/aretexturesresident.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/aretexturesresident.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/aretexturesresident.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/aretexturesresident.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/aretexturesresident.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/arrayelement.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/arrayelement.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/arrayelement.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/arrayelement.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/arrayelement.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_
 _C_ Anything on a line after _C_ is ignored
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/begin.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/begin.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/begin.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/begin.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/begin.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/bindtexture.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/bindtexture.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/bindtexture.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/bindtexture.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/bindtexture.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/bitmap.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/bitmap.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/bitmap.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/bitmap.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/bitmap.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/blendcolor.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/blendcolor.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/blendcolor.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/blendcolor.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/blendcolor.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/blendequation.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/blendequation.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/blendequation.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/blendequation.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/blendequation.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/blendfunc.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/blendfunc.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/blendfunc.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/blendfunc.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/blendfunc.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/calllist.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/calllist.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/calllist.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/calllist.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/calllist.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _header(CallList,execute a display list)
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/calllists.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/calllists.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/calllists.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/calllists.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/calllists.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _header(CallLists,execute a list of display lists)
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/clear.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/clear.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/clear.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/clear.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/clear.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/clearaccum.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/clearaccum.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/clearaccum.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/clearaccum.gl:1.3	Mon Jan 14 17:13:29 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/clearaccum.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/clearcolor.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/clearcolor.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/clearcolor.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/clearcolor.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/clearcolor.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/cleardepth.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/cleardepth.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/cleardepth.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/cleardepth.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/cleardepth.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/clearindex.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/clearindex.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/clearindex.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/clearindex.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/clearindex.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/clearstencil.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/clearstencil.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/clearstencil.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/clearstencil.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/clearstencil.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/clientactivetextureARB.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/clientactivetextureARB.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/clientactivetextureARB.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/clientactivetextureARB.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/clientactivetextureARB.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/clipplane.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/clipplane.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/clipplane.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/clipplane.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/clipplane.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/color.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/color.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/color.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/color.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/color.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/colormask.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/colormask.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/colormask.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/colormask.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/colormask.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/colormaterial.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/colormaterial.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/colormaterial.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/colormaterial.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/colormaterial.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/colorpointer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/colorpointer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/colorpointer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/colorpointer.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/colorpointer.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/colorsubtable.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/colorsubtable.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/colorsubtable.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/colorsubtable.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/colorsubtable.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/colortable.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/colortable.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/colortable.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/colortable.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/colortable.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/colortableparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/colortableparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/colortableparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/colortableparameter.gl:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/colortableparameter.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl | eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/const.awk
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/const.awk:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/const.awk:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/const.awk:1.3	Mon Jan 14 17:13:30 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/const.awk	Fri Feb 22 16:32:36 2002
@@ -30,8 +30,6 @@
 # published by SGI, but has not been independently verified as being
 # compliant with the OpenGL(R) version 1.2.1 Specification.
 #
-# $Date$ $Revision$
-# $Header$
 
 # compare manpages to gl.h
 #
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter1d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter1d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter1d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter1d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter1d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter2d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter2d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter2d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter2d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionfilter2d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionparameter.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/convolutionparameter.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolorsubtable.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolorsubtable.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolorsubtable.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolorsubtable.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolorsubtable.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolortable.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolortable.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolortable.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolortable.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copycolortable.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl | eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter1d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter1d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter1d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter1d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter1d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter2d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter2d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter2d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter2d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copyconvolutionfilter2d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copypixels.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copypixels.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copypixels.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copypixels.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copypixels.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage1d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage1d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage1d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage1d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage1d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage2d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage2d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage2d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage2d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copyteximage2d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage1d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage1d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage1d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage1d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage1d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage2d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage2d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage2d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage2d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage2d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage3d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage3d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage3d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage3d.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/copytexsubimage3d.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/cullface.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/cullface.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/cullface.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/cullface.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/cullface.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/deletelists.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/deletelists.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/deletelists.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/deletelists.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/deletelists.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _header(DeleteLists,delete a contiguous group of display lists)
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/deletetextures.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/deletetextures.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/deletetextures.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/deletetextures.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/deletetextures.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/depthfunc.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/depthfunc.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/depthfunc.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/depthfunc.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/depthfunc.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/depthmask.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/depthmask.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/depthmask.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/depthmask.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/depthmask.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/depthrange.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/depthrange.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/depthrange.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/depthrange.gl:1.3	Mon Jan 14 17:13:31 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/depthrange.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/drawarrays.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/drawarrays.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/drawarrays.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/drawarrays.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/drawarrays.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/drawbuffer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/drawbuffer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/drawbuffer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/drawbuffer.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/drawbuffer.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/drawelements.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/drawelements.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/drawelements.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/drawelements.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/drawelements.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/drawpixels.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/drawpixels.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/drawpixels.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/drawpixels.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/drawpixels.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/drawrangeelements.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/drawrangeelements.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/drawrangeelements.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/drawrangeelements.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/drawrangeelements.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflag.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflag.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflag.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflag.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflag.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflagpointer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflagpointer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflagpointer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflagpointer.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/edgeflagpointer.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/enable.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/enable.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/enable.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/enable.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/enable.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/enableclientstate.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/enableclientstate.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/enableclientstate.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/enableclientstate.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/enableclientstate.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/evalcoord.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/evalcoord.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/evalcoord.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/evalcoord.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/evalcoord.gl	Fri Feb 22 16:32:36 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/evalmesh.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/evalmesh.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/evalmesh.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/evalmesh.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/evalmesh.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/evalpoint.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/evalpoint.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/evalpoint.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/evalpoint.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/evalpoint.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/feedbackbuffer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/feedbackbuffer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/feedbackbuffer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/feedbackbuffer.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/feedbackbuffer.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/finish.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/finish.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/finish.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/finish.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/finish.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/flush.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/flush.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/flush.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/flush.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/flush.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/fog.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/fog.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/fog.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/fog.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/fog.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/frontface.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/frontface.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/frontface.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/frontface.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/frontface.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/frustum.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/frustum.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/frustum.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/frustum.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/frustum.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/genlists.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/genlists.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/genlists.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/genlists.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/genlists.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/gentextures.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/gentextures.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/gentextures.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/gentextures.gl:1.3	Mon Jan 14 17:13:32 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/gentextures.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/get.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/get.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/get.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/get.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/get.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getclipplane.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getclipplane.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getclipplane.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getclipplane.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getclipplane.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortable.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortable.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortable.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortable.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortable.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortableparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortableparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortableparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortableparameter.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getcolortableparameter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl | eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionfilter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionfilter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionfilter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionfilter.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionfilter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionparameter.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getconvolutionparameter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/geterror.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/geterror.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/geterror.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/geterror.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/geterror.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogram.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogram.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogram.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogram.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogram.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogramparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogramparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogramparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogramparameter.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/gethistogramparameter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getlight.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getlight.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getlight.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getlight.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getlight.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getmap.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getmap.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getmap.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getmap.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getmap.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getmaterial.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getmaterial.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getmaterial.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getmaterial.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getmaterial.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmax.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmax.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmax.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmax.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmax.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmaxparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmaxparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmaxparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmaxparameter.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getminmaxparameter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getpixelmap.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getpixelmap.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getpixelmap.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getpixelmap.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getpixelmap.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getpointerv.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getpointerv.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getpointerv.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getpointerv.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getpointerv.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getpolygonstipple.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getpolygonstipple.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getpolygonstipple.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getpolygonstipple.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getpolygonstipple.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getseparablefilter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getseparablefilter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getseparablefilter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getseparablefilter.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getseparablefilter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getstring.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getstring.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getstring.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getstring.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getstring.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexenv.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexenv.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexenv.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexenv.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexenv.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexgen.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexgen.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexgen.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexgen.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexgen.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/getteximage.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/getteximage.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/getteximage.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/getteximage.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/getteximage.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexlevelparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexlevelparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexlevelparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexlevelparameter.gl:1.3	Mon Jan 14 17:13:33 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexlevelparameter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexparameter.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/gettexparameter.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/hint.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/hint.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/hint.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/hint.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/hint.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/histogram.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/histogram.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/histogram.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/histogram.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/histogram.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/index.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/index.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/index.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/index.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/index.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/indexmask.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/indexmask.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/indexmask.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/indexmask.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/indexmask.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/indexpointer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/indexpointer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/indexpointer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/indexpointer.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/indexpointer.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/initnames.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/initnames.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/initnames.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/initnames.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/initnames.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _header(InitNames,initialize the name stack)
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/interleavedarrays.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/interleavedarrays.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/interleavedarrays.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/interleavedarrays.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/interleavedarrays.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/isenabled.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/isenabled.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/isenabled.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/isenabled.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/isenabled.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/islist.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/islist.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/islist.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/islist.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/islist.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/istexture.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/istexture.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/istexture.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/istexture.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/istexture.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/light.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/light.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/light.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/light.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/light.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/lightmodel.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/lightmodel.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/lightmodel.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/lightmodel.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/lightmodel.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/linestipple.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/linestipple.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/linestipple.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/linestipple.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/linestipple.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/linewidth.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/linewidth.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/linewidth.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/linewidth.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/linewidth.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/listbase.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/listbase.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/listbase.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/listbase.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/listbase.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/loadidentity.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/loadidentity.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/loadidentity.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/loadidentity.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/loadidentity.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/loadmatrix.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/loadmatrix.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/loadmatrix.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/loadmatrix.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/loadmatrix.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/loadname.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/loadname.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/loadname.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/loadname.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/loadname.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/logicop.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/logicop.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/logicop.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/logicop.gl:1.3	Mon Jan 14 17:13:34 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/logicop.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/map1.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/map1.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/map1.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/map1.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/map1.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/map2.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/map2.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/map2.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/map2.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/map2.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/mapgrid.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/mapgrid.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/mapgrid.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/mapgrid.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/mapgrid.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/material.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/material.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/material.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/material.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/material.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/matrixmode.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/matrixmode.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/matrixmode.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/matrixmode.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/matrixmode.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/minmax.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/minmax.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/minmax.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/minmax.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/minmax.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/multitexcoordARB.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/multitexcoordARB.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/multitexcoordARB.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/multitexcoordARB.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/multitexcoordARB.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/multmatrix.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/multmatrix.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/multmatrix.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/multmatrix.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/multmatrix.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/newlist.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/newlist.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/newlist.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/newlist.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/newlist.gl	Fri Feb 22 16:32:37 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _header(NewList,create or replace a display list)
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/normal.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/normal.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/normal.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/normal.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/normal.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/normalpointer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/normalpointer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/normalpointer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/normalpointer.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/normalpointer.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/ortho.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/ortho.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/ortho.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/ortho.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/ortho.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/passthrough.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/passthrough.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/passthrough.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/passthrough.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/passthrough.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelmap.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelmap.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelmap.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelmap.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelmap.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelstore.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelstore.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelstore.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelstore.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelstore.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pixeltransfer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pixeltransfer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pixeltransfer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pixeltransfer.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pixeltransfer.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelzoom.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelzoom.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelzoom.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelzoom.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pixelzoom.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pointsize.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pointsize.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pointsize.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pointsize.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pointsize.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonmode.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonmode.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonmode.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonmode.gl:1.3	Mon Jan 14 17:13:35 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonmode.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonoffset.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonoffset.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonoffset.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonoffset.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonoffset.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonstipple.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonstipple.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonstipple.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonstipple.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/polygonstipple.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/prioritizetextures.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/prioritizetextures.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/prioritizetextures.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/prioritizetextures.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/prioritizetextures.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pushattrib.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pushattrib.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pushattrib.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pushattrib.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pushattrib.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pushclientattrib.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pushclientattrib.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pushclientattrib.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pushclientattrib.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pushclientattrib.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn|tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pushmatrix.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pushmatrix.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pushmatrix.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pushmatrix.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pushmatrix.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _header(PushMatrix,push and pop the current matrix stack)
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/pushname.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/pushname.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/pushname.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/pushname.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/pushname.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _header(PushName,push and pop the name stack)
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/rasterpos.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/rasterpos.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/rasterpos.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/rasterpos.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/rasterpos.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/readbuffer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/readbuffer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/readbuffer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/readbuffer.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/readbuffer.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/readpixels.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/readpixels.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/readpixels.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/readpixels.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/readpixels.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/rect.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/rect.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/rect.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/rect.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/rect.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/rendermode.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/rendermode.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/rendermode.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/rendermode.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/rendermode.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/resethistogram.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/resethistogram.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/resethistogram.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/resethistogram.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/resethistogram.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/resetminmax.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/resetminmax.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/resetminmax.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/resetminmax.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/resetminmax.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/rotate.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/rotate.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/rotate.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/rotate.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/rotate.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/scale.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/scale.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/scale.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/scale.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/scale.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/scissor.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/scissor.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/scissor.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/scissor.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/scissor.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/selectbuffer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/selectbuffer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/selectbuffer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/selectbuffer.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/selectbuffer.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/separablefilter2d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/separablefilter2d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/separablefilter2d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/separablefilter2d.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/separablefilter2d.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/shademodel.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/shademodel.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/shademodel.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/shademodel.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/shademodel.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilfunc.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilfunc.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilfunc.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilfunc.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilfunc.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilmask.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilmask.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilmask.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilmask.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilmask.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilop.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilop.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilop.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilop.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/stencilop.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoord.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoord.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoord.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoord.gl:1.3	Mon Jan 14 17:13:36 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoord.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoordpointer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoordpointer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoordpointer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoordpointer.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texcoordpointer.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texenv.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texenv.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texenv.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texenv.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texenv.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texgen.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texgen.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texgen.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texgen.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texgen.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage1d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage1d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage1d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage1d.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage1d.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage2d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage2d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage2d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage2d.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage2d.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage3d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage3d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage3d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage3d.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/teximage3d.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texparameter.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texparameter.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texparameter.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texparameter.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texparameter.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage1d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage1d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage1d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage1d.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage1d.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage2d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage2d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage2d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage2d.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage2d.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage3d.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage3d.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage3d.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage3d.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/texsubimage3d.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/translate.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/translate.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/translate.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/translate.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/translate.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/vertex.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/vertex.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/vertex.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/vertex.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/vertex.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,tbl|eqn)_C_
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/vertexpointer.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/vertexpointer.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/vertexpointer.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/vertexpointer.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/vertexpointer.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _C_ A real line follows.
Index: xc/extras/ogl-sample/main/doc/man/mangl/standard/viewport.gl
diff -u xc/extras/ogl-sample/main/doc/man/mangl/standard/viewport.gl:1.3 xc/extras/ogl-sample/main/doc/man/mangl/standard/viewport.gl:1.4
--- xc/extras/ogl-sample/main/doc/man/mangl/standard/viewport.gl:1.3	Mon Jan 14 17:13:37 2002
+++ xc/extras/ogl-sample/main/doc/man/mangl/standard/viewport.gl	Fri Feb 22 16:32:38 2002
@@ -30,7 +30,6 @@
 _C_ published by SGI, but has not been independently verified as being
 _C_ compliant with the OpenGL(R) version 1.2.1 Specification.
 _C_
-_C_ $Date$ $Revision$
 _C_ The first character in this file must be an '_'!
 _C_ Anything on a line after _C_ is ignored
 _define(_filters,eqn)_C_
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/interface/insurfeval.cc
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/interface/insurfeval.cc:1.1.1.1 xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/interface/insurfeval.cc:1.2
--- xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/interface/insurfeval.cc:1.1.1.1	Mon Jan 15 16:48:20 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/interface/insurfeval.cc	Sat Jan 11 22:55:45 2003
@@ -36,6 +36,7 @@
 /*
 ** $Header: //depot/main/gfx/lib/glu/libnurbs/interface/insurfeval.cc#4 $
 */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/interface/insurfeval.cc,v 1.2 2003/01/12 03:55:45 tsi Exp $ */
 
 #include "gluos.h"
 #include <stdlib.h>
@@ -609,9 +610,9 @@
 
 
 
-  #ifdef DEBUG
+#ifdef DEBUG
   printf("vertex(%f,%f,%f)\n", retPoint[0],retPoint[1],retPoint[2]);
-  #endif
+#endif
   
 
 
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/mymath.h
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/mymath.h:1.2 xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/mymath.h:1.3
--- xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/mymath.h:1.2	Sun Feb 18 15:01:01 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/mymath.h	Fri May 31 12:36:49 2002
@@ -35,19 +35,23 @@
 /*
  * mymath.h
  *
- * $Date$ $Revision$
- * $Header: //depot/main/gfx/lib/glu/libnurbs/internals/mymath.h#4 $
+ * Date Revision
+ * Header: //depot/main/gfx/lib/glu/libnurbs/internals/mymath.h#4 
  */
 
 
 
-/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/mymath.h,v 1.2 2001/02/18 20:01:01 dawes Exp $ */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/mymath.h,v 1.3 2002/05/31 16:36:49 dawes Exp $ */
 
 #ifndef __glumymath_h_
 #define __glumymath_h_
 
 #ifdef GLBUILD
 #define sqrtf		gl_fsqrt
+#endif
+
+#ifdef __UNIXOS2__
+#define sqrtf		sqrt
 #endif
 
 #if GLBUILD | STANDALONE
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/simplemath.h
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/simplemath.h:1.1.1.1 xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/simplemath.h:1.2
--- xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/simplemath.h:1.1.1.1	Mon Jan 15 16:48:38 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/simplemath.h	Wed Nov 20 18:00:36 2002
@@ -31,12 +31,12 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/simplemath.h,v 1.2 2002/11/20 23:00:36 dawes Exp $ */
 
 /*
  * simplemath.h
  *
- * $Date$ $Revision$
- * $Header: //depot/main/gfx/lib/glu/libnurbs/internals/simplemath.h#4 $
+ * Header: //depot/main/gfx/lib/glu/libnurbs/internals/simplemath.h#4 $
  */
 
 #ifndef __glusimplemath_h_
@@ -50,6 +50,9 @@
 inline REAL 
 min( REAL x, REAL y ) { return ( x > y ) ? y : x; }
 
+#ifdef _SCO_DS
+#define abs __gluabs
+#endif
 inline REAL 
 abs( REAL x ) { return ( x < 0.0 ) ? -x : x; }
 
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/slicer.cc
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/slicer.cc:1.1.1.1 xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/slicer.cc:1.2
--- xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/slicer.cc:1.1.1.1	Mon Jan 15 16:48:40 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/slicer.cc	Sat Jan 11 22:55:45 2003
@@ -31,6 +31,7 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/slicer.cc,v 1.2 2003/01/12 03:55:45 tsi Exp $ */
 
 /*
  * slicer.c++
@@ -60,7 +61,7 @@
 /*USE_OPTTT is initiated in trimvertex.h*/
 
 #ifdef USE_OPTTT
-	#include <GL/gl.h>
+#	include <GL/gl.h>
 #endif
 
 //#define USE_READ_FLAG //whether to use new or old tesselator
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc:1.1.1.1 xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc:1.2
--- xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc:1.1.1.1	Mon Jan 15 16:48:59 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc	Wed Jan 23 12:06:18 2002
@@ -31,12 +31,15 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date$ $Revision$
+** Date Revision
 */
 /*
-** $Header: //depot/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc#3 $
+** Header: //depot/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc#3 
 */
 
+
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/nurbtess/quicksort.cc,v 1.2 2002/01/23 17:06:18 dawes Exp $ */
+
 #include <stdlib.h>
 #include <stdio.h>
 
@@ -58,7 +61,6 @@
 	       int (*comp) (void *, void *))
 {
   int i, last;
-  void swap(void *v[], int , int);
   if(left >= right) /*do nothing if array contains */
     return;         /*fewer than two elements*/
   
@@ -72,7 +74,7 @@
   quicksort(v, last+1, right, comp);
 }
 
-void swap(void *v[], int i, int j)
+static void swap(void *v[], int i, int j)
 {
   void *temp;
   temp = v[i];
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libtess/normal.c
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libtess/normal.c:1.2 xc/extras/ogl-sample/main/gfx/lib/glu/libtess/normal.c:1.3
--- xc/extras/ogl-sample/main/gfx/lib/glu/libtess/normal.c:1.2	Sat Oct 27 23:32:22 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libtess/normal.c	Fri Feb 22 16:32:49 2002
@@ -1,4 +1,4 @@
-/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libtess/normal.c,v 1.2 2001/10/28 03:32:22 tsi Exp $ */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libtess/normal.c,v 1.3 2002/02/22 21:32:49 dawes Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
 ** made subject to an alternative license as permitted in the SGI Free
@@ -36,8 +36,6 @@
 /*
 ** Author: Eric Veach, July 1994.
 **
-** $Date$ $Revision$
-** $Header: //depot/main/gfx/lib/glu/libtess/normal.c#5 $
 */
 
 #include "gluos.h"
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libtess/sweep.c
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libtess/sweep.c:1.2 xc/extras/ogl-sample/main/gfx/lib/glu/libtess/sweep.c:1.3
--- xc/extras/ogl-sample/main/gfx/lib/glu/libtess/sweep.c:1.2	Sat Oct 27 23:32:22 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libtess/sweep.c	Fri Feb 22 16:32:49 2002
@@ -35,10 +35,8 @@
 /*
 ** Author: Eric Veach, July 1994.
 **
-** $Date$ $Revision$
-** $Header: //depot/main/gfx/lib/glu/libtess/sweep.c#5 $
 */
-/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libtess/sweep.c,v 1.2 2001/10/28 03:32:22 tsi Exp $ */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libtess/sweep.c,v 1.3 2002/02/22 21:32:49 dawes Exp $ */
 
 #include "gluos.h"
 #include <assert.h>
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libutil/mipmap.c
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libutil/mipmap.c:1.4 xc/extras/ogl-sample/main/gfx/lib/glu/libutil/mipmap.c:1.5
--- xc/extras/ogl-sample/main/gfx/lib/glu/libutil/mipmap.c:1.4	Sat Oct 27 23:32:23 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libutil/mipmap.c	Fri Feb 22 16:32:49 2002
@@ -31,10 +31,8 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date$ $Revision$
-** $Header: //depot/main/gfx/lib/glu/libutil/mipmap.c#15 $
 */
-/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libutil/mipmap.c,v 1.4 2001/10/28 03:32:23 tsi Exp $ */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libutil/mipmap.c,v 1.5 2002/02/22 21:32:49 dawes Exp $ */
 
 #include "gluos.h"
 #include <assert.h>
Index: xc/extras/ogl-sample/main/gfx/lib/glu/libutil/project.c
diff -u xc/extras/ogl-sample/main/gfx/lib/glu/libutil/project.c:1.2 xc/extras/ogl-sample/main/gfx/lib/glu/libutil/project.c:1.3
--- xc/extras/ogl-sample/main/gfx/lib/glu/libutil/project.c:1.2	Sat Oct 27 23:32:24 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glu/libutil/project.c	Fri Feb 22 16:32:49 2002
@@ -1,4 +1,4 @@
-/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libutil/project.c,v 1.2 2001/10/28 03:32:24 tsi Exp $ */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glu/libutil/project.c,v 1.3 2002/02/22 21:32:49 dawes Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
 ** made subject to an alternative license as permitted in the SGI Free
@@ -32,8 +32,6 @@
 ** published by SGI, but has not been independently verified as being
 ** compliant with the OpenGL(R) version 1.2.1 Specification.
 **
-** $Date$ $Revision$
-** $Header: //depot/main/gfx/lib/glu/libutil/project.c#6 $
 */
 
 #include "gluos.h"
Index: xc/extras/ogl-sample/main/gfx/lib/glw/GLwDrawA.h
diff -u xc/extras/ogl-sample/main/gfx/lib/glw/GLwDrawA.h:1.3 xc/extras/ogl-sample/main/gfx/lib/glw/GLwDrawA.h:1.4
--- xc/extras/ogl-sample/main/gfx/lib/glw/GLwDrawA.h:1.3	Wed May  2 09:37:45 2001
+++ xc/extras/ogl-sample/main/gfx/lib/glw/GLwDrawA.h	Fri May 31 12:36:50 2002
@@ -39,7 +39,7 @@
 ** tree and for generating both Motif(TM) 1.2 and 2.x versions of the widgets
 ** in the same library.
 */
-/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glw/GLwDrawA.h,v 1.3 2001/05/02 13:37:45 dawes Exp $ */
+/* $XFree86: xc/extras/ogl-sample/main/gfx/lib/glw/GLwDrawA.h,v 1.4 2002/05/31 16:36:50 dawes Exp $ */
 
 #ifndef _GLwDrawA_h
 #define _GLwDrawA_h
@@ -151,6 +151,7 @@
 #  define _GLwMDrawingAreaRec		_GLwM1DrawingAreaRec
 */
 #  define glwMDrawingAreaWidgetClass	glwM1DrawingAreaWidgetClass
+#  define glwMDrawingAreaClassRec	glwM1DrawingAreaClassRec
 #  define GLwCreateMDrawingArea		GLwCreateM1DrawingArea
 #elif XmVERSION == 2
 /*
@@ -158,6 +159,7 @@
 #  define _GLwMDrawingAreaRec		_GLwM2DrawingAreaRec
 */
 #  define glwMDrawingAreaWidgetClass	glwM2DrawingAreaWidgetClass
+#  define glwMDrawingAreaClassRec	glwM2DrawingAreaClassRec
 #  define GLwCreateMDrawingArea		GLwCreateM2DrawingArea
 #else
 #error "Sorry, unknown Motif version."
Index: xc/extras/x86emu/include/x86emu.h
diff -u xc/extras/x86emu/include/x86emu.h:1.2 xc/extras/x86emu/include/x86emu.h:1.3
--- xc/extras/x86emu/include/x86emu.h:1.2	Tue Nov 21 18:10:25 2000
+++ xc/extras/x86emu/include/x86emu.h	Mon Sep 16 14:05:17 2002
@@ -37,7 +37,7 @@
 *               include this header
 *
 ****************************************************************************/
-/* $XFree86: xc/extras/x86emu/include/x86emu.h,v 1.2 2000/11/21 23:10:25 tsi Exp $ */
+/* $XFree86: xc/extras/x86emu/include/x86emu.h,v 1.3 2002/09/16 18:05:17 eich Exp $ */
 
 #ifndef __X86EMU_X86EMU_H
 #define __X86EMU_X86EMU_H
@@ -56,7 +56,7 @@
 
 /*---------------------- Macros and type definitions ----------------------*/
 
-#pragma	pack(1)
+/*  #pragma	pack(1) */  /* Don't pack structs with function pointers! */
 
 /****************************************************************************
 REMARKS:
@@ -130,7 +130,7 @@
 extern void X86API wrw(u32 addr, u16 val);
 extern void X86API wrl(u32 addr, u32 val);
  
-#pragma	pack()
+/*  #pragma	pack() */
 
 /*--------------------- type definitions -----------------------------------*/
 
Index: xc/extras/x86emu/include/x86emu/regs.h
diff -u xc/extras/x86emu/include/x86emu/regs.h:1.3 xc/extras/x86emu/include/x86emu/regs.h:1.4
--- xc/extras/x86emu/include/x86emu/regs.h:1.3	Sat Oct 27 23:32:25 2001
+++ xc/extras/x86emu/include/x86emu/regs.h	Mon Sep 16 14:05:18 2002
@@ -35,7 +35,7 @@
 * Description:  Header file for x86 register definitions.
 *
 ****************************************************************************/
-/* $XFree86: xc/extras/x86emu/include/x86emu/regs.h,v 1.3 2001/10/28 03:32:25 tsi Exp $ */
+/* $XFree86: xc/extras/x86emu/include/x86emu/regs.h,v 1.4 2002/09/16 18:05:18 eich Exp $ */
 
 #ifndef __X86EMU_REGS_H
 #define __X86EMU_REGS_H
@@ -320,7 +320,7 @@
 
 extern    X86EMU_sysEnv	_X86EMU_env;
 #define   M             _X86EMU_env
-		
+
 /*-------------------------- Function Prototypes --------------------------*/
 
 /* Function to log information at runtime */
Index: xc/extras/x86emu/include/x86emu/types.h
diff -u xc/extras/x86emu/include/x86emu/types.h:1.4 xc/extras/x86emu/include/x86emu/types.h:1.5
--- xc/extras/x86emu/include/x86emu/types.h:1.4	Tue Sep 26 11:56:44 2000
+++ xc/extras/x86emu/include/x86emu/types.h	Tue Jul 23 10:22:45 2002
@@ -36,7 +36,7 @@
 *
 ****************************************************************************/
 
-/* $XFree86: xc/extras/x86emu/include/x86emu/types.h,v 1.4 2000/09/26 15:56:44 tsi Exp $ */
+/* $XFree86: xc/extras/x86emu/include/x86emu/types.h,v 1.5 2002/07/23 14:22:45 tsi Exp $ */
 
 #ifndef __X86EMU_TYPES_H
 #define __X86EMU_TYPES_H
@@ -63,20 +63,35 @@
 /*---------------------- Macros and type definitions ----------------------*/
 
 /* Currently only for Linux/32bit */
+#undef  __HAS_LONG_LONG__
 #if defined(__GNUC__) && !defined(NO_LONG_LONG)
 #define __HAS_LONG_LONG__
 #endif
 
+/* Taken from Xmd.h */
+#undef NUM32
+#if defined(__alpha) || defined(__alpha__) || \
+    defined(__ia64__) || defined(ia64) || \
+    defined(__sparc64__) || \
+    defined(__s390x__) || \
+    (defined(__hppa__) && defined(__LP64)) || \
+    defined(__x86_64__) || defined(x86_64) || \
+    (defined(__sgi) && (_MIPS_SZLONG == 64))
+#define NUM32 int
+#else
+#define NUM32 long
+#endif
+
 typedef unsigned char 		u8;
 typedef unsigned short 		u16;
-typedef unsigned int 		u32;
+typedef unsigned NUM32 		u32;
 #ifdef __HAS_LONG_LONG__
 typedef unsigned long long 	u64;
 #endif
 
 typedef char 				s8;
 typedef short 				s16;
-typedef int 				s32;
+typedef NUM32 				s32;
 #ifdef __HAS_LONG_LONG__
 typedef long long 			s64;
 #endif
@@ -85,5 +100,7 @@
 typedef int 				sint;
 
 typedef u16 X86EMU_pioAddr;
+
+#undef NUM32
 
 #endif	/* __X86EMU_TYPES_H */
Index: xc/extras/x86emu/src/x86emu/decode.c
diff -u xc/extras/x86emu/src/x86emu/decode.c:1.9 xc/extras/x86emu/src/x86emu/decode.c:1.11
--- xc/extras/x86emu/src/x86emu/decode.c:1.9	Sat Jan  6 15:19:03 2001
+++ xc/extras/x86emu/src/x86emu/decode.c	Tue Jul 23 16:20:43 2002
@@ -37,7 +37,7 @@
 *
 ****************************************************************************/
 
-/* $XFree86: xc/extras/x86emu/src/x86emu/decode.c,v 1.9 2001/01/06 20:19:03 tsi Exp $ */
+/* $XFree86: xc/extras/x86emu/src/x86emu/decode.c,v 1.11 2002/07/23 20:20:43 tsi Exp $ */
 
 #include "x86emu/x86emui.h"
 
@@ -709,6 +709,99 @@
 	return NULL;                /* NOT REACHED OR REACHED ON ERROR */
 }
 
+/*
+ *
+ * return offset from the SIB Byte
+ */
+u32 decode_sib_address(int sib, int mod)
+{
+    u32 base = 0, i = 0, scale = 1;
+
+    switch(sib & 0x07) {
+    case 0:
+	DECODE_PRINTF("[EAX]");
+	base = M.x86.R_EAX;
+	break;
+    case 1:
+	DECODE_PRINTF("[ECX]");
+	base = M.x86.R_ECX;
+	break;
+    case 2:
+	DECODE_PRINTF("[EDX]");
+	base = M.x86.R_EDX;
+	break;
+    case 3:
+	DECODE_PRINTF("[EBX]");
+	base = M.x86.R_EBX;
+	break;
+    case 4:
+	DECODE_PRINTF("[ESP]");
+	base = M.x86.R_ESP;
+	M.x86.mode |= SYSMODE_SEG_DS_SS;
+	break;
+    case 5:
+	if (mod == 0) {
+	    base = fetch_long_imm();
+	    DECODE_PRINTF2("%08x", base);
+	} else {
+	    DECODE_PRINTF("[EBP]");
+	    base = M.x86.R_ESP;
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	}
+	break;
+    case 6:
+	DECODE_PRINTF("[ESI]");
+	base = M.x86.R_ESI;
+	break;
+    case 7:
+	DECODE_PRINTF("[EDI]");
+	base = M.x86.R_EDI;
+	break;
+    }
+    switch ((sib >> 3) & 0x07) {
+    case 0:
+	DECODE_PRINTF("[EAX");
+	i = M.x86.R_EAX;
+	break;
+    case 1:
+	DECODE_PRINTF("[ECX");
+	i = M.x86.R_ECX;
+	break;
+    case 2:
+	DECODE_PRINTF("[EDX");
+	i = M.x86.R_EDX;
+	break;
+    case 3:
+	DECODE_PRINTF("[EBX");
+	i = M.x86.R_EBX;
+	break;
+    case 4:
+	i = 0;
+	break;
+    case 5:
+	DECODE_PRINTF("[EBP");
+	i = M.x86.R_EBP;
+	break;
+    case 6:
+	DECODE_PRINTF("[ESI");
+	i = M.x86.R_ESI;
+	break;
+    case 7:
+	DECODE_PRINTF("[EDI");
+	i = M.x86.R_EDI;
+	break;
+    }
+    scale = 1 << ((sib >> 6) & 0x03);
+    if (((sib >> 3) & 0x07) != 4) {
+	if (scale == 1) {
+	    DECODE_PRINTF("]");
+	} else {
+	    DECODE_PRINTF2("*%d]", scale);
+	}
+    }
+    return base + (i * scale);
+}
+
 /****************************************************************************
 PARAMETERS:
 rm	- RM value to decode
@@ -729,13 +822,44 @@
 		if a SS access is needed, set this bit.  Otherwise, DS access
 		occurs (unless any of the segment override bits are set).
 ****************************************************************************/
-unsigned decode_rm00_address(
+u32 decode_rm00_address(
 	int rm)
 {
-	unsigned offset;
+    u32 offset;
+    int sib;
 
+    if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
 	switch (rm) {
-      case 0:
+	  case 0:
+		DECODE_PRINTF("[EAX]");
+		return M.x86.R_EAX;
+	  case 1:
+		DECODE_PRINTF("[ECX]");
+		return M.x86.R_ECX;
+	  case 2:
+		DECODE_PRINTF("[EDX]");
+		return M.x86.R_EDX;
+	  case 3:
+		DECODE_PRINTF("[EBX]");
+		return M.x86.R_EBX;
+	  case 4:
+		sib = fetch_byte_imm();
+		return decode_sib_address(sib, 0);
+	  case 5:
+		offset = fetch_long_imm();
+		DECODE_PRINTF2("[%08x]", offset);
+		return offset;
+	  case 6:
+		DECODE_PRINTF("[ESI]");
+		return M.x86.R_ESI;
+	  case 7:
+		DECODE_PRINTF("[EDI]");
+		return M.x86.R_EDI;
+	}
+	HALT_SYS();
+    } else {
+	switch (rm) {
+	  case 0:
 		DECODE_PRINTF("[BX+SI]");
 		return M.x86.R_BX + M.x86.R_SI;
 	  case 1:
@@ -764,6 +888,7 @@
 		return M.x86.R_BX;
 	}
 	HALT_SYS();
+    }
     return 0;
 }
 
@@ -778,12 +903,49 @@
 Return the offset given by mod=01 addressing.  Also enables the
 decoding of instructions.
 ****************************************************************************/
-unsigned decode_rm01_address(
+u32 decode_rm01_address(
 	int rm)
 {
-	int displacement = (s8)fetch_byte_imm();
+    int displacement = 0;
+    int sib;
+
+    /* Fetch disp8 if no SIB byte */
+    if (!((M.x86.mode & SYSMODE_PREFIX_ADDR) && (rm == 4)))
+	displacement = (s8)fetch_byte_imm();
+
+    if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
 	switch (rm) {
-      case 0:
+	  case 0:
+		DECODE_PRINTF2("%d[EAX]", displacement);
+		return M.x86.R_EAX + displacement;
+	  case 1:
+		DECODE_PRINTF2("%d[ECX]", displacement);
+		return M.x86.R_ECX + displacement;
+	  case 2:
+		DECODE_PRINTF2("%d[EDX]", displacement);
+		return M.x86.R_EDX + displacement;
+	  case 3:
+		DECODE_PRINTF2("%d[EBX]", displacement);
+		return M.x86.R_EBX + displacement;
+	  case 4:
+		sib = fetch_byte_imm();
+		displacement = (s8)fetch_byte_imm();
+		DECODE_PRINTF2("%d", displacement);
+		return decode_sib_address(sib, 1) + displacement;
+	  case 5:
+		DECODE_PRINTF2("%d[EBP]", displacement);
+		return M.x86.R_EBP + displacement;
+	  case 6:
+		DECODE_PRINTF2("%d[ESI]", displacement);
+		return M.x86.R_ESI + displacement;
+	  case 7:
+		DECODE_PRINTF2("%d[EDI]", displacement);
+		return M.x86.R_EDI + displacement;
+	}
+	HALT_SYS();
+    } else {
+	switch (rm) {
+	  case 0:
 		DECODE_PRINTF2("%d[BX+SI]", displacement);
 		return M.x86.R_BX + M.x86.R_SI + displacement;
 	  case 1:
@@ -812,6 +974,7 @@
 		return M.x86.R_BX + displacement;
 	}
 	HALT_SYS();
+    }
     return 0;                   /* SHOULD NOT HAPPEN */
 }
 
@@ -826,12 +989,56 @@
 Return the offset given by mod=10 addressing.  Also enables the
 decoding of instructions.
 ****************************************************************************/
-unsigned decode_rm10_address(
+u32 decode_rm10_address(
 	int rm)
 {
-	unsigned displacement = (u16)fetch_word_imm();
-	switch (rm) {
-      case 0:
+    u32 displacement = 0;
+    int sib;
+
+    /* Fetch disp16 if 16-bit addr mode */
+    if (!(M.x86.mode & SYSMODE_PREFIX_ADDR))
+	displacement = (u16)fetch_word_imm();
+    else {
+	/* Fetch disp32 if no SIB byte */
+	if (rm != 4)
+	    displacement = (u32)fetch_long_imm();
+    }
+
+    if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
+      switch (rm) {
+	  case 0:
+		DECODE_PRINTF2("%08x[EAX]", displacement);
+		return M.x86.R_EAX + displacement;
+	  case 1:
+		DECODE_PRINTF2("%08x[ECX]", displacement);
+		return M.x86.R_ECX + displacement;
+	  case 2:
+		DECODE_PRINTF2("%08x[EDX]", displacement);
+		M.x86.mode |= SYSMODE_SEG_DS_SS;
+		return M.x86.R_EDX + displacement;
+	  case 3:
+		DECODE_PRINTF2("%08x[EBX]", displacement);
+		return M.x86.R_EBX + displacement;
+	  case 4:
+		sib = fetch_byte_imm();
+		displacement = (u32)fetch_long_imm();
+		DECODE_PRINTF2("%08x", displacement);
+		return decode_sib_address(sib, 2) + displacement;
+		break;
+	  case 5:
+		DECODE_PRINTF2("%08x[EBP]", displacement);
+		return M.x86.R_EBP + displacement;
+	  case 6:
+		DECODE_PRINTF2("%08x[ESI]", displacement);
+		return M.x86.R_ESI + displacement;
+	  case 7:
+		DECODE_PRINTF2("%08x[EDI]", displacement);
+		return M.x86.R_EDI + displacement;
+	}
+	HALT_SYS();
+    } else {
+      switch (rm) {
+	  case 0:
 		DECODE_PRINTF2("%04x[BX+SI]", displacement);
 		return M.x86.R_BX + M.x86.R_SI + displacement;
 	  case 1:
@@ -860,6 +1067,7 @@
 		return M.x86.R_BX + displacement;
 	}
 	HALT_SYS();
+    }
     return 0;
     /*NOTREACHED */
 }
Index: xc/extras/x86emu/src/x86emu/ops.c
diff -u xc/extras/x86emu/src/x86emu/ops.c:1.6 xc/extras/x86emu/src/x86emu/ops.c:1.7
--- xc/extras/x86emu/src/x86emu/ops.c:1.6	Sat Jan  6 15:19:03 2001
+++ xc/extras/x86emu/src/x86emu/ops.c	Mon Jul 15 12:49:10 2002
@@ -70,7 +70,7 @@
 *
 ****************************************************************************/
 
-/* $XFree86: xc/extras/x86emu/src/x86emu/ops.c,v 1.6 2001/01/06 20:19:03 tsi Exp $ */
+/* $XFree86: xc/extras/x86emu/src/x86emu/ops.c,v 1.7 2002/07/15 16:49:10 dawes Exp $ */
 
 #include "x86emu/x86emui.h"
 
@@ -83,7 +83,7 @@
 REMARKS:
 Handles illegal opcodes.
 ****************************************************************************/
-void x86emuOp_illegal_op(
+static void x86emuOp_illegal_op(
     u8 op1)
 {
     START_OF_INSTR();
@@ -99,7 +99,7 @@
 REMARKS:
 Handles opcode 0x00
 ****************************************************************************/
-void x86emuOp_add_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_add_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -157,7 +157,7 @@
 REMARKS:
 Handles opcode 0x01
 ****************************************************************************/
-void x86emuOp_add_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_add_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -277,7 +277,7 @@
 REMARKS:
 Handles opcode 0x02
 ****************************************************************************/
-void x86emuOp_add_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_add_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -332,7 +332,7 @@
 REMARKS:
 Handles opcode 0x03
 ****************************************************************************/
-void x86emuOp_add_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_add_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -446,7 +446,7 @@
 REMARKS:
 Handles opcode 0x04
 ****************************************************************************/
-void x86emuOp_add_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_add_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -464,7 +464,7 @@
 REMARKS:
 Handles opcode 0x05
 ****************************************************************************/
-void x86emuOp_add_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_add_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -491,7 +491,7 @@
 REMARKS:
 Handles opcode 0x06
 ****************************************************************************/
-void x86emuOp_push_ES(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_ES(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("PUSH\tES\n");
@@ -505,7 +505,7 @@
 REMARKS:
 Handles opcode 0x07
 ****************************************************************************/
-void x86emuOp_pop_ES(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_ES(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("POP\tES\n");
@@ -519,7 +519,7 @@
 REMARKS:
 Handles opcode 0x08
 ****************************************************************************/
-void x86emuOp_or_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_or_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -577,7 +577,7 @@
 REMARKS:
 Handles opcode 0x09
 ****************************************************************************/
-void x86emuOp_or_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_or_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -697,7 +697,7 @@
 REMARKS:
 Handles opcode 0x0a
 ****************************************************************************/
-void x86emuOp_or_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_or_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -752,7 +752,7 @@
 REMARKS:
 Handles opcode 0x0b
 ****************************************************************************/
-void x86emuOp_or_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_or_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -866,7 +866,7 @@
 REMARKS:
 Handles opcode 0x0c
 ****************************************************************************/
-void x86emuOp_or_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_or_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -884,7 +884,7 @@
 REMARKS:
 Handles opcode 0x0d
 ****************************************************************************/
-void x86emuOp_or_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_or_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -911,7 +911,7 @@
 REMARKS:
 Handles opcode 0x0e
 ****************************************************************************/
-void x86emuOp_push_CS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_CS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("PUSH\tCS\n");
@@ -925,7 +925,7 @@
 REMARKS:
 Handles opcode 0x0f. Escape for two-byte opcode (286 or better)
 ****************************************************************************/
-void x86emuOp_two_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_two_byte(u8 X86EMU_UNUSED(op1))
 {
     u8 op2 = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
     INC_DECODED_INST_LEN(1);
@@ -936,7 +936,7 @@
 REMARKS:
 Handles opcode 0x10
 ****************************************************************************/
-void x86emuOp_adc_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_adc_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -994,7 +994,7 @@
 REMARKS:
 Handles opcode 0x11
 ****************************************************************************/
-void x86emuOp_adc_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_adc_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -1114,7 +1114,7 @@
 REMARKS:
 Handles opcode 0x12
 ****************************************************************************/
-void x86emuOp_adc_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_adc_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -1169,7 +1169,7 @@
 REMARKS:
 Handles opcode 0x13
 ****************************************************************************/
-void x86emuOp_adc_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_adc_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -1283,7 +1283,7 @@
 REMARKS:
 Handles opcode 0x14
 ****************************************************************************/
-void x86emuOp_adc_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_adc_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -1301,7 +1301,7 @@
 REMARKS:
 Handles opcode 0x15
 ****************************************************************************/
-void x86emuOp_adc_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_adc_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -1328,7 +1328,7 @@
 REMARKS:
 Handles opcode 0x16
 ****************************************************************************/
-void x86emuOp_push_SS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_SS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("PUSH\tSS\n");
@@ -1342,7 +1342,7 @@
 REMARKS:
 Handles opcode 0x17
 ****************************************************************************/
-void x86emuOp_pop_SS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_SS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("POP\tSS\n");
@@ -1356,7 +1356,7 @@
 REMARKS:
 Handles opcode 0x18
 ****************************************************************************/
-void x86emuOp_sbb_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sbb_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -1414,7 +1414,7 @@
 REMARKS:
 Handles opcode 0x19
 ****************************************************************************/
-void x86emuOp_sbb_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sbb_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -1534,7 +1534,7 @@
 REMARKS:
 Handles opcode 0x1a
 ****************************************************************************/
-void x86emuOp_sbb_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sbb_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -1589,7 +1589,7 @@
 REMARKS:
 Handles opcode 0x1b
 ****************************************************************************/
-void x86emuOp_sbb_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sbb_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -1703,7 +1703,7 @@
 REMARKS:
 Handles opcode 0x1c
 ****************************************************************************/
-void x86emuOp_sbb_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sbb_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -1721,7 +1721,7 @@
 REMARKS:
 Handles opcode 0x1d
 ****************************************************************************/
-void x86emuOp_sbb_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sbb_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -1748,7 +1748,7 @@
 REMARKS:
 Handles opcode 0x1e
 ****************************************************************************/
-void x86emuOp_push_DS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_DS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("PUSH\tDS\n");
@@ -1762,7 +1762,7 @@
 REMARKS:
 Handles opcode 0x1f
 ****************************************************************************/
-void x86emuOp_pop_DS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_DS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("POP\tDS\n");
@@ -1776,7 +1776,7 @@
 REMARKS:
 Handles opcode 0x20
 ****************************************************************************/
-void x86emuOp_and_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_and_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -1838,7 +1838,7 @@
 REMARKS:
 Handles opcode 0x21
 ****************************************************************************/
-void x86emuOp_and_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_and_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -1958,7 +1958,7 @@
 REMARKS:
 Handles opcode 0x22
 ****************************************************************************/
-void x86emuOp_and_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_and_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -2013,7 +2013,7 @@
 REMARKS:
 Handles opcode 0x23
 ****************************************************************************/
-void x86emuOp_and_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_and_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -2128,7 +2128,7 @@
 REMARKS:
 Handles opcode 0x24
 ****************************************************************************/
-void x86emuOp_and_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_and_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -2146,7 +2146,7 @@
 REMARKS:
 Handles opcode 0x25
 ****************************************************************************/
-void x86emuOp_and_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_and_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -2173,7 +2173,7 @@
 REMARKS:
 Handles opcode 0x26
 ****************************************************************************/
-void x86emuOp_segovr_ES(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_segovr_ES(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("ES:\n");
@@ -2190,7 +2190,7 @@
 REMARKS:
 Handles opcode 0x27
 ****************************************************************************/
-void x86emuOp_daa(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_daa(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("DAA\n");
@@ -2204,7 +2204,7 @@
 REMARKS:
 Handles opcode 0x28
 ****************************************************************************/
-void x86emuOp_sub_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sub_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -2262,7 +2262,7 @@
 REMARKS:
 Handles opcode 0x29
 ****************************************************************************/
-void x86emuOp_sub_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sub_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -2382,7 +2382,7 @@
 REMARKS:
 Handles opcode 0x2a
 ****************************************************************************/
-void x86emuOp_sub_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sub_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -2437,7 +2437,7 @@
 REMARKS:
 Handles opcode 0x2b
 ****************************************************************************/
-void x86emuOp_sub_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sub_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -2551,7 +2551,7 @@
 REMARKS:
 Handles opcode 0x2c
 ****************************************************************************/
-void x86emuOp_sub_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sub_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -2569,7 +2569,7 @@
 REMARKS:
 Handles opcode 0x2d
 ****************************************************************************/
-void x86emuOp_sub_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sub_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -2596,7 +2596,7 @@
 REMARKS:
 Handles opcode 0x2e
 ****************************************************************************/
-void x86emuOp_segovr_CS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_segovr_CS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("CS:\n");
@@ -2610,7 +2610,7 @@
 REMARKS:
 Handles opcode 0x2f
 ****************************************************************************/
-void x86emuOp_das(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_das(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("DAS\n");
@@ -2624,7 +2624,7 @@
 REMARKS:
 Handles opcode 0x30
 ****************************************************************************/
-void x86emuOp_xor_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xor_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -2682,7 +2682,7 @@
 REMARKS:
 Handles opcode 0x31
 ****************************************************************************/
-void x86emuOp_xor_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xor_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -2802,7 +2802,7 @@
 REMARKS:
 Handles opcode 0x32
 ****************************************************************************/
-void x86emuOp_xor_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xor_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -2857,7 +2857,7 @@
 REMARKS:
 Handles opcode 0x33
 ****************************************************************************/
-void x86emuOp_xor_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xor_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -2971,7 +2971,7 @@
 REMARKS:
 Handles opcode 0x34
 ****************************************************************************/
-void x86emuOp_xor_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xor_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -2989,7 +2989,7 @@
 REMARKS:
 Handles opcode 0x35
 ****************************************************************************/
-void x86emuOp_xor_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xor_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -3016,7 +3016,7 @@
 REMARKS:
 Handles opcode 0x36
 ****************************************************************************/
-void x86emuOp_segovr_SS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_segovr_SS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("SS:\n");
@@ -3030,7 +3030,7 @@
 REMARKS:
 Handles opcode 0x37
 ****************************************************************************/
-void x86emuOp_aaa(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_aaa(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("AAA\n");
@@ -3044,7 +3044,7 @@
 REMARKS:
 Handles opcode 0x38
 ****************************************************************************/
-void x86emuOp_cmp_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmp_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -3099,7 +3099,7 @@
 REMARKS:
 Handles opcode 0x39
 ****************************************************************************/
-void x86emuOp_cmp_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmp_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -3213,7 +3213,7 @@
 REMARKS:
 Handles opcode 0x3a
 ****************************************************************************/
-void x86emuOp_cmp_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmp_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -3268,7 +3268,7 @@
 REMARKS:
 Handles opcode 0x3b
 ****************************************************************************/
-void x86emuOp_cmp_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmp_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -3382,7 +3382,7 @@
 REMARKS:
 Handles opcode 0x3c
 ****************************************************************************/
-void x86emuOp_cmp_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmp_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 srcval;
 
@@ -3400,7 +3400,7 @@
 REMARKS:
 Handles opcode 0x3d
 ****************************************************************************/
-void x86emuOp_cmp_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmp_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -3427,7 +3427,7 @@
 REMARKS:
 Handles opcode 0x3e
 ****************************************************************************/
-void x86emuOp_segovr_DS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_segovr_DS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("DS:\n");
@@ -3441,7 +3441,7 @@
 REMARKS:
 Handles opcode 0x3f
 ****************************************************************************/
-void x86emuOp_aas(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_aas(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("AAS\n");
@@ -3455,7 +3455,7 @@
 REMARKS:
 Handles opcode 0x40
 ****************************************************************************/
-void x86emuOp_inc_AX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3477,7 +3477,7 @@
 REMARKS:
 Handles opcode 0x41
 ****************************************************************************/
-void x86emuOp_inc_CX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3499,7 +3499,7 @@
 REMARKS:
 Handles opcode 0x42
 ****************************************************************************/
-void x86emuOp_inc_DX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3521,7 +3521,7 @@
 REMARKS:
 Handles opcode 0x43
 ****************************************************************************/
-void x86emuOp_inc_BX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3543,7 +3543,7 @@
 REMARKS:
 Handles opcode 0x44
 ****************************************************************************/
-void x86emuOp_inc_SP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3565,7 +3565,7 @@
 REMARKS:
 Handles opcode 0x45
 ****************************************************************************/
-void x86emuOp_inc_BP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3587,7 +3587,7 @@
 REMARKS:
 Handles opcode 0x46
 ****************************************************************************/
-void x86emuOp_inc_SI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3609,7 +3609,7 @@
 REMARKS:
 Handles opcode 0x47
 ****************************************************************************/
-void x86emuOp_inc_DI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_inc_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3631,7 +3631,7 @@
 REMARKS:
 Handles opcode 0x48
 ****************************************************************************/
-void x86emuOp_dec_AX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3653,7 +3653,7 @@
 REMARKS:
 Handles opcode 0x49
 ****************************************************************************/
-void x86emuOp_dec_CX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3675,7 +3675,7 @@
 REMARKS:
 Handles opcode 0x4a
 ****************************************************************************/
-void x86emuOp_dec_DX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3697,7 +3697,7 @@
 REMARKS:
 Handles opcode 0x4b
 ****************************************************************************/
-void x86emuOp_dec_BX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3719,7 +3719,7 @@
 REMARKS:
 Handles opcode 0x4c
 ****************************************************************************/
-void x86emuOp_dec_SP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3741,7 +3741,7 @@
 REMARKS:
 Handles opcode 0x4d
 ****************************************************************************/
-void x86emuOp_dec_BP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3763,7 +3763,7 @@
 REMARKS:
 Handles opcode 0x4e
 ****************************************************************************/
-void x86emuOp_dec_SI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3785,7 +3785,7 @@
 REMARKS:
 Handles opcode 0x4f
 ****************************************************************************/
-void x86emuOp_dec_DI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_dec_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3807,7 +3807,7 @@
 REMARKS:
 Handles opcode 0x50
 ****************************************************************************/
-void x86emuOp_push_AX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3829,7 +3829,7 @@
 REMARKS:
 Handles opcode 0x51
 ****************************************************************************/
-void x86emuOp_push_CX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3851,7 +3851,7 @@
 REMARKS:
 Handles opcode 0x52
 ****************************************************************************/
-void x86emuOp_push_DX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3873,7 +3873,7 @@
 REMARKS:
 Handles opcode 0x53
 ****************************************************************************/
-void x86emuOp_push_BX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3895,7 +3895,7 @@
 REMARKS:
 Handles opcode 0x54
 ****************************************************************************/
-void x86emuOp_push_SP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3921,7 +3921,7 @@
 REMARKS:
 Handles opcode 0x55
 ****************************************************************************/
-void x86emuOp_push_BP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3943,7 +3943,7 @@
 REMARKS:
 Handles opcode 0x56
 ****************************************************************************/
-void x86emuOp_push_SI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3965,7 +3965,7 @@
 REMARKS:
 Handles opcode 0x57
 ****************************************************************************/
-void x86emuOp_push_DI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -3987,7 +3987,7 @@
 REMARKS:
 Handles opcode 0x58
 ****************************************************************************/
-void x86emuOp_pop_AX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4009,7 +4009,7 @@
 REMARKS:
 Handles opcode 0x59
 ****************************************************************************/
-void x86emuOp_pop_CX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4031,7 +4031,7 @@
 REMARKS:
 Handles opcode 0x5a
 ****************************************************************************/
-void x86emuOp_pop_DX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4053,7 +4053,7 @@
 REMARKS:
 Handles opcode 0x5b
 ****************************************************************************/
-void x86emuOp_pop_BX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4075,7 +4075,7 @@
 REMARKS:
 Handles opcode 0x5c
 ****************************************************************************/
-void x86emuOp_pop_SP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4097,7 +4097,7 @@
 REMARKS:
 Handles opcode 0x5d
 ****************************************************************************/
-void x86emuOp_pop_BP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4119,7 +4119,7 @@
 REMARKS:
 Handles opcode 0x5e
 ****************************************************************************/
-void x86emuOp_pop_SI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4141,7 +4141,7 @@
 REMARKS:
 Handles opcode 0x5f
 ****************************************************************************/
-void x86emuOp_pop_DI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4163,7 +4163,7 @@
 REMARKS:
 Handles opcode 0x60
 ****************************************************************************/
-void x86emuOp_push_all(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_all(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4203,7 +4203,7 @@
 REMARKS:
 Handles opcode 0x61
 ****************************************************************************/
-void x86emuOp_pop_all(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_all(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4242,7 +4242,7 @@
 REMARKS:
 Handles opcode 0x64
 ****************************************************************************/
-void x86emuOp_segovr_FS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_segovr_FS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("FS:\n");
@@ -4259,7 +4259,7 @@
 REMARKS:
 Handles opcode 0x65
 ****************************************************************************/
-void x86emuOp_segovr_GS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_segovr_GS(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("GS:\n");
@@ -4276,7 +4276,7 @@
 REMARKS:
 Handles opcode 0x66 - prefix for 32-bit register
 ****************************************************************************/
-void x86emuOp_prefix_data(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_prefix_data(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("DATA:\n");
@@ -4290,7 +4290,7 @@
 REMARKS:
 Handles opcode 0x67 - prefix for 32-bit address
 ****************************************************************************/
-void x86emuOp_prefix_addr(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_prefix_addr(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("ADDR:\n");
@@ -4304,7 +4304,7 @@
 REMARKS:
 Handles opcode 0x68
 ****************************************************************************/
-void x86emuOp_push_word_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_word_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 imm;
 
@@ -4329,7 +4329,7 @@
 REMARKS:
 Handles opcode 0x69
 ****************************************************************************/
-void x86emuOp_imul_word_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_imul_word_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -4530,7 +4530,7 @@
 REMARKS:
 Handles opcode 0x6a
 ****************************************************************************/
-void x86emuOp_push_byte_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_push_byte_IMM(u8 X86EMU_UNUSED(op1))
 {
     s16 imm;
 
@@ -4547,7 +4547,7 @@
 REMARKS:
 Handles opcode 0x6b
 ****************************************************************************/
-void x86emuOp_imul_byte_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_imul_byte_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -4741,7 +4741,7 @@
 REMARKS:
 Handles opcode 0x6c
 ****************************************************************************/
-void x86emuOp_ins_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_ins_byte(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("INSB\n");
@@ -4755,7 +4755,7 @@
 REMARKS:
 Handles opcode 0x6d
 ****************************************************************************/
-void x86emuOp_ins_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_ins_word(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4774,7 +4774,7 @@
 REMARKS:
 Handles opcode 0x6e
 ****************************************************************************/
-void x86emuOp_outs_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_outs_byte(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("OUTSB\n");
@@ -4788,7 +4788,7 @@
 REMARKS:
 Handles opcode 0x6f
 ****************************************************************************/
-void x86emuOp_outs_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_outs_word(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -4807,7 +4807,7 @@
 REMARKS:
 Handles opcode 0x70
 ****************************************************************************/
-void x86emuOp_jump_near_O(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_O(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4829,7 +4829,7 @@
 REMARKS:
 Handles opcode 0x71
 ****************************************************************************/
-void x86emuOp_jump_near_NO(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NO(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4851,7 +4851,7 @@
 REMARKS:
 Handles opcode 0x72
 ****************************************************************************/
-void x86emuOp_jump_near_B(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_B(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4873,7 +4873,7 @@
 REMARKS:
 Handles opcode 0x73
 ****************************************************************************/
-void x86emuOp_jump_near_NB(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NB(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4895,7 +4895,7 @@
 REMARKS:
 Handles opcode 0x74
 ****************************************************************************/
-void x86emuOp_jump_near_Z(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_Z(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4917,7 +4917,7 @@
 REMARKS:
 Handles opcode 0x75
 ****************************************************************************/
-void x86emuOp_jump_near_NZ(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NZ(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4939,7 +4939,7 @@
 REMARKS:
 Handles opcode 0x76
 ****************************************************************************/
-void x86emuOp_jump_near_BE(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_BE(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4962,7 +4962,7 @@
 REMARKS:
 Handles opcode 0x77
 ****************************************************************************/
-void x86emuOp_jump_near_NBE(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NBE(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -4985,7 +4985,7 @@
 REMARKS:
 Handles opcode 0x78
 ****************************************************************************/
-void x86emuOp_jump_near_S(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_S(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5007,7 +5007,7 @@
 REMARKS:
 Handles opcode 0x79
 ****************************************************************************/
-void x86emuOp_jump_near_NS(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NS(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5029,7 +5029,7 @@
 REMARKS:
 Handles opcode 0x7a
 ****************************************************************************/
-void x86emuOp_jump_near_P(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_P(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5051,7 +5051,7 @@
 REMARKS:
 Handles opcode 0x7b
 ****************************************************************************/
-void x86emuOp_jump_near_NP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NP(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5073,7 +5073,7 @@
 REMARKS:
 Handles opcode 0x7c
 ****************************************************************************/
-void x86emuOp_jump_near_L(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_L(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5098,7 +5098,7 @@
 REMARKS:
 Handles opcode 0x7d
 ****************************************************************************/
-void x86emuOp_jump_near_NL(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NL(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5124,7 +5124,7 @@
 REMARKS:
 Handles opcode 0x7e
 ****************************************************************************/
-void x86emuOp_jump_near_LE(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_LE(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5150,7 +5150,7 @@
 REMARKS:
 Handles opcode 0x7f
 ****************************************************************************/
-void x86emuOp_jump_near_NLE(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_NLE(u8 X86EMU_UNUSED(op1))
 {
     s8 offset;
     u16 target;
@@ -5188,7 +5188,7 @@
 REMARKS:
 Handles opcode 0x80
 ****************************************************************************/
-void x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg;
@@ -5320,7 +5320,7 @@
 REMARKS:
 Handles opcode 0x81
 ****************************************************************************/
-void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -5507,7 +5507,7 @@
 REMARKS:
 Handles opcode 0x82
 ****************************************************************************/
-void x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg;
@@ -5635,7 +5635,7 @@
 REMARKS:
 Handles opcode 0x83
 ****************************************************************************/
-void x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -5800,7 +5800,7 @@
 REMARKS:
 Handles opcode 0x84
 ****************************************************************************/
-void x86emuOp_test_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_test_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -5855,7 +5855,7 @@
 REMARKS:
 Handles opcode 0x85
 ****************************************************************************/
-void x86emuOp_test_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_test_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -5969,7 +5969,7 @@
 REMARKS:
 Handles opcode 0x86
 ****************************************************************************/
-void x86emuOp_xchg_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -6036,7 +6036,7 @@
 REMARKS:
 Handles opcode 0x87
 ****************************************************************************/
-void x86emuOp_xchg_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -6174,7 +6174,7 @@
 REMARKS:
 Handles opcode 0x88
 ****************************************************************************/
-void x86emuOp_mov_byte_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -6225,10 +6225,10 @@
 REMARKS:
 Handles opcode 0x89
 ****************************************************************************/
-void x86emuOp_mov_word_RM_R(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_RM_R(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
-    uint destoffset;
+    u32 destoffset;
 
     START_OF_INSTR();
     DECODE_PRINTF("MOV\t");
@@ -6327,7 +6327,7 @@
 REMARKS:
 Handles opcode 0x8a
 ****************************************************************************/
-void x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg, *srcreg;
@@ -6382,7 +6382,7 @@
 REMARKS:
 Handles opcode 0x8b
 ****************************************************************************/
-void x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -6496,7 +6496,7 @@
 REMARKS:
 Handles opcode 0x8c
 ****************************************************************************/
-void x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u16 *destreg, *srcreg;
@@ -6551,7 +6551,7 @@
 REMARKS:
 Handles opcode 0x8d
 ****************************************************************************/
-void x86emuOp_lea_word_R_M(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_lea_word_R_M(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u16 *srcreg;
@@ -6603,7 +6603,7 @@
 REMARKS:
 Handles opcode 0x8e
 ****************************************************************************/
-void x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u16 *destreg, *srcreg;
@@ -6664,7 +6664,7 @@
 REMARKS:
 Handles opcode 0x8f
 ****************************************************************************/
-void x86emuOp_pop_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pop_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -6760,7 +6760,7 @@
 REMARKS:
 Handles opcode 0x90
 ****************************************************************************/
-void x86emuOp_nop(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_nop(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("NOP\n");
@@ -6773,7 +6773,7 @@
 REMARKS:
 Handles opcode 0x91
 ****************************************************************************/
-void x86emuOp_xchg_word_AX_CX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_AX_CX(u8 X86EMU_UNUSED(op1))
 {
     u32 tmp;
 
@@ -6801,7 +6801,7 @@
 REMARKS:
 Handles opcode 0x92
 ****************************************************************************/
-void x86emuOp_xchg_word_AX_DX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_AX_DX(u8 X86EMU_UNUSED(op1))
 {
     u32 tmp;
 
@@ -6829,7 +6829,7 @@
 REMARKS:
 Handles opcode 0x93
 ****************************************************************************/
-void x86emuOp_xchg_word_AX_BX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_AX_BX(u8 X86EMU_UNUSED(op1))
 {
     u32 tmp;
 
@@ -6857,7 +6857,7 @@
 REMARKS:
 Handles opcode 0x94
 ****************************************************************************/
-void x86emuOp_xchg_word_AX_SP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_AX_SP(u8 X86EMU_UNUSED(op1))
 {
     u32 tmp;
 
@@ -6885,7 +6885,7 @@
 REMARKS:
 Handles opcode 0x95
 ****************************************************************************/
-void x86emuOp_xchg_word_AX_BP(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_AX_BP(u8 X86EMU_UNUSED(op1))
 {
     u32 tmp;
 
@@ -6913,7 +6913,7 @@
 REMARKS:
 Handles opcode 0x96
 ****************************************************************************/
-void x86emuOp_xchg_word_AX_SI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_AX_SI(u8 X86EMU_UNUSED(op1))
 {
     u32 tmp;
 
@@ -6941,7 +6941,7 @@
 REMARKS:
 Handles opcode 0x97
 ****************************************************************************/
-void x86emuOp_xchg_word_AX_DI(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xchg_word_AX_DI(u8 X86EMU_UNUSED(op1))
 {
     u32 tmp;
 
@@ -6969,7 +6969,7 @@
 REMARKS:
 Handles opcode 0x98
 ****************************************************************************/
-void x86emuOp_cbw(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cbw(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -6999,7 +6999,7 @@
 REMARKS:
 Handles opcode 0x99
 ****************************************************************************/
-void x86emuOp_cwd(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cwd(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -7030,7 +7030,7 @@
 REMARKS:
 Handles opcode 0x9a
 ****************************************************************************/
-void x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 farseg, faroff;
 
@@ -7061,7 +7061,7 @@
 REMARKS:
 Handles opcode 0x9b
 ****************************************************************************/
-void x86emuOp_wait(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_wait(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("WAIT");
@@ -7075,7 +7075,7 @@
 REMARKS:
 Handles opcode 0x9c
 ****************************************************************************/
-void x86emuOp_pushf_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_pushf_word(u8 X86EMU_UNUSED(op1))
 {
     u32 flags;
 
@@ -7102,7 +7102,7 @@
 REMARKS:
 Handles opcode 0x9d
 ****************************************************************************/
-void x86emuOp_popf_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_popf_word(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -7124,7 +7124,7 @@
 REMARKS:
 Handles opcode 0x9e
 ****************************************************************************/
-void x86emuOp_sahf(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sahf(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("SAHF\n");
@@ -7141,7 +7141,7 @@
 REMARKS:
 Handles opcode 0x9f
 ****************************************************************************/
-void x86emuOp_lahf(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_lahf(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("LAHF\n");
@@ -7158,7 +7158,7 @@
 REMARKS:
 Handles opcode 0xa0
 ****************************************************************************/
-void x86emuOp_mov_AL_M_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_AL_M_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 offset;
 
@@ -7176,7 +7176,7 @@
 REMARKS:
 Handles opcode 0xa1
 ****************************************************************************/
-void x86emuOp_mov_AX_M_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_AX_M_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 offset;
 
@@ -7201,7 +7201,7 @@
 REMARKS:
 Handles opcode 0xa2
 ****************************************************************************/
-void x86emuOp_mov_M_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_M_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 offset;
 
@@ -7219,7 +7219,7 @@
 REMARKS:
 Handles opcode 0xa3
 ****************************************************************************/
-void x86emuOp_mov_M_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_M_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 offset;
 
@@ -7244,7 +7244,7 @@
 REMARKS:
 Handles opcode 0xa4
 ****************************************************************************/
-void x86emuOp_movs_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_movs_byte(u8 X86EMU_UNUSED(op1))
 {
     u8  val;
     u32 count;
@@ -7279,7 +7279,7 @@
 REMARKS:
 Handles opcode 0xa5
 ****************************************************************************/
-void x86emuOp_movs_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_movs_word(u8 X86EMU_UNUSED(op1))
 {
     u32 val;
     int inc;
@@ -7327,7 +7327,7 @@
 REMARKS:
 Handles opcode 0xa6
 ****************************************************************************/
-void x86emuOp_cmps_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmps_byte(u8 X86EMU_UNUSED(op1))
 {
     s8 val1, val2;
     int inc;
@@ -7383,7 +7383,7 @@
 REMARKS:
 Handles opcode 0xa7
 ****************************************************************************/
-void x86emuOp_cmps_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmps_word(u8 X86EMU_UNUSED(op1))
 {
     u32 val1,val2;
     int inc;
@@ -7464,7 +7464,7 @@
 REMARKS:
 Handles opcode 0xa8
 ****************************************************************************/
-void x86emuOp_test_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_test_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     int imm;
 
@@ -7482,7 +7482,7 @@
 REMARKS:
 Handles opcode 0xa9
 ****************************************************************************/
-void x86emuOp_test_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_test_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -7509,7 +7509,7 @@
 REMARKS:
 Handles opcode 0xaa
 ****************************************************************************/
-void x86emuOp_stos_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_stos_byte(u8 X86EMU_UNUSED(op1))
 {
     int inc;
 
@@ -7541,7 +7541,7 @@
 REMARKS:
 Handles opcode 0xab
 ****************************************************************************/
-void x86emuOp_stos_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_stos_word(u8 X86EMU_UNUSED(op1))
 {
     int inc;
     u32 count;
@@ -7585,7 +7585,7 @@
 REMARKS:
 Handles opcode 0xac
 ****************************************************************************/
-void x86emuOp_lods_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_lods_byte(u8 X86EMU_UNUSED(op1))
 {
     int inc;
 
@@ -7617,7 +7617,7 @@
 REMARKS:
 Handles opcode 0xad
 ****************************************************************************/
-void x86emuOp_lods_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_lods_word(u8 X86EMU_UNUSED(op1))
 {
     int inc;
     u32 count;
@@ -7661,7 +7661,7 @@
 REMARKS:
 Handles opcode 0xae
 ****************************************************************************/
-void x86emuOp_scas_byte(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_scas_byte(u8 X86EMU_UNUSED(op1))
 {
     s8 val2;
     int inc;
@@ -7710,7 +7710,7 @@
 REMARKS:
 Handles opcode 0xaf
 ****************************************************************************/
-void x86emuOp_scas_word(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_scas_word(u8 X86EMU_UNUSED(op1))
 {
     int inc;
     u32 val;
@@ -7782,7 +7782,7 @@
 REMARKS:
 Handles opcode 0xb0
 ****************************************************************************/
-void x86emuOp_mov_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7800,7 +7800,7 @@
 REMARKS:
 Handles opcode 0xb1
 ****************************************************************************/
-void x86emuOp_mov_byte_CL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_CL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7818,7 +7818,7 @@
 REMARKS:
 Handles opcode 0xb2
 ****************************************************************************/
-void x86emuOp_mov_byte_DL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_DL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7836,7 +7836,7 @@
 REMARKS:
 Handles opcode 0xb3
 ****************************************************************************/
-void x86emuOp_mov_byte_BL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_BL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7854,7 +7854,7 @@
 REMARKS:
 Handles opcode 0xb4
 ****************************************************************************/
-void x86emuOp_mov_byte_AH_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_AH_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7872,7 +7872,7 @@
 REMARKS:
 Handles opcode 0xb5
 ****************************************************************************/
-void x86emuOp_mov_byte_CH_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_CH_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7890,7 +7890,7 @@
 REMARKS:
 Handles opcode 0xb6
 ****************************************************************************/
-void x86emuOp_mov_byte_DH_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_DH_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7908,7 +7908,7 @@
 REMARKS:
 Handles opcode 0xb7
 ****************************************************************************/
-void x86emuOp_mov_byte_BH_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_BH_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 imm;
 
@@ -7926,7 +7926,7 @@
 REMARKS:
 Handles opcode 0xb8
 ****************************************************************************/
-void x86emuOp_mov_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -7953,7 +7953,7 @@
 REMARKS:
 Handles opcode 0xb9
 ****************************************************************************/
-void x86emuOp_mov_word_CX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_CX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -7980,7 +7980,7 @@
 REMARKS:
 Handles opcode 0xba
 ****************************************************************************/
-void x86emuOp_mov_word_DX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_DX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -8007,7 +8007,7 @@
 REMARKS:
 Handles opcode 0xbb
 ****************************************************************************/
-void x86emuOp_mov_word_BX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_BX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -8034,7 +8034,7 @@
 REMARKS:
 Handles opcode 0xbc
 ****************************************************************************/
-void x86emuOp_mov_word_SP_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_SP_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -8061,7 +8061,7 @@
 REMARKS:
 Handles opcode 0xbd
 ****************************************************************************/
-void x86emuOp_mov_word_BP_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_BP_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -8088,7 +8088,7 @@
 REMARKS:
 Handles opcode 0xbe
 ****************************************************************************/
-void x86emuOp_mov_word_SI_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_SI_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -8115,7 +8115,7 @@
 REMARKS:
 Handles opcode 0xbf
 ****************************************************************************/
-void x86emuOp_mov_word_DI_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_DI_IMM(u8 X86EMU_UNUSED(op1))
 {
     u32 srcval;
 
@@ -8155,7 +8155,7 @@
 REMARKS:
 Handles opcode 0xc0
 ****************************************************************************/
-void x86emuOp_opcC0_byte_RM_MEM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcC0_byte_RM_MEM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg;
@@ -8281,7 +8281,7 @@
 REMARKS:
 Handles opcode 0xc1
 ****************************************************************************/
-void x86emuOp_opcC1_word_RM_MEM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcC1_word_RM_MEM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -8435,7 +8435,7 @@
 REMARKS:
 Handles opcode 0xc2
 ****************************************************************************/
-void x86emuOp_ret_near_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_ret_near_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 imm;
 
@@ -8455,7 +8455,7 @@
 REMARKS:
 Handles opcode 0xc3
 ****************************************************************************/
-void x86emuOp_ret_near(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_ret_near(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("RET\n");
@@ -8470,7 +8470,7 @@
 REMARKS:
 Handles opcode 0xc4
 ****************************************************************************/
-void x86emuOp_les_R_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_les_R_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rh, rl;
     u16 *dstreg;
@@ -8519,7 +8519,7 @@
 REMARKS:
 Handles opcode 0xc5
 ****************************************************************************/
-void x86emuOp_lds_R_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_lds_R_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rh, rl;
     u16 *dstreg;
@@ -8568,7 +8568,7 @@
 REMARKS:
 Handles opcode 0xc6
 ****************************************************************************/
-void x86emuOp_mov_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg;
@@ -8623,7 +8623,7 @@
 REMARKS:
 Handles opcode 0xc7
 ****************************************************************************/
-void x86emuOp_mov_word_RM_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_mov_word_RM_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -8729,7 +8729,7 @@
 REMARKS:
 Handles opcode 0xc8
 ****************************************************************************/
-void x86emuOp_enter(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_enter(u8 X86EMU_UNUSED(op1))
 {
     u16 local,frame_pointer;
     u8  nesting;
@@ -8760,7 +8760,7 @@
 REMARKS:
 Handles opcode 0xc9
 ****************************************************************************/
-void x86emuOp_leave(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_leave(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("LEAVE\n");
@@ -8775,7 +8775,7 @@
 REMARKS:
 Handles opcode 0xca
 ****************************************************************************/
-void x86emuOp_ret_far_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_ret_far_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 imm;
 
@@ -8796,7 +8796,7 @@
 REMARKS:
 Handles opcode 0xcb
 ****************************************************************************/
-void x86emuOp_ret_far(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_ret_far(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("RETF\n");
@@ -8812,7 +8812,7 @@
 REMARKS:
 Handles opcode 0xcc
 ****************************************************************************/
-void x86emuOp_int3(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_int3(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("INT 3\n");
@@ -8836,7 +8836,7 @@
 REMARKS:
 Handles opcode 0xcd
 ****************************************************************************/
-void x86emuOp_int_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_int_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 intnum;
 
@@ -8864,7 +8864,7 @@
 REMARKS:
 Handles opcode 0xce
 ****************************************************************************/
-void x86emuOp_into(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_into(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("INTO\n");
@@ -8890,7 +8890,7 @@
 REMARKS:
 Handles opcode 0xcf
 ****************************************************************************/
-void x86emuOp_iret(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_iret(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("IRET\n");
@@ -8908,7 +8908,7 @@
 REMARKS:
 Handles opcode 0xd0
 ****************************************************************************/
-void x86emuOp_opcD0_byte_RM_1(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcD0_byte_RM_1(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg;
@@ -9002,7 +9002,7 @@
 REMARKS:
 Handles opcode 0xd1
 ****************************************************************************/
-void x86emuOp_opcD1_word_RM_1(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcD1_word_RM_1(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -9150,7 +9150,7 @@
 REMARKS:
 Handles opcode 0xd2
 ****************************************************************************/
-void x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg;
@@ -9246,7 +9246,7 @@
 REMARKS:
 Handles opcode 0xd3
 ****************************************************************************/
-void x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -9392,7 +9392,7 @@
 REMARKS:
 Handles opcode 0xd4
 ****************************************************************************/
-void x86emuOp_aam(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_aam(u8 X86EMU_UNUSED(op1))
 {
     u8 a;
 
@@ -9415,7 +9415,7 @@
 REMARKS:
 Handles opcode 0xd5
 ****************************************************************************/
-void x86emuOp_aad(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_aad(u8 X86EMU_UNUSED(op1))
 {
     u8 a;
 
@@ -9434,7 +9434,7 @@
 REMARKS:
 Handles opcode 0xd7
 ****************************************************************************/
-void x86emuOp_xlat(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_xlat(u8 X86EMU_UNUSED(op1))
 {
     u16 addr;
 
@@ -9453,7 +9453,7 @@
 REMARKS:
 Handles opcode 0xe0
 ****************************************************************************/
-void x86emuOp_loopne(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_loopne(u8 X86EMU_UNUSED(op1))
 {
     s16 ip;
 
@@ -9474,7 +9474,7 @@
 REMARKS:
 Handles opcode 0xe1
 ****************************************************************************/
-void x86emuOp_loope(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_loope(u8 X86EMU_UNUSED(op1))
 {
     s16 ip;
 
@@ -9495,7 +9495,7 @@
 REMARKS:
 Handles opcode 0xe2
 ****************************************************************************/
-void x86emuOp_loop(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_loop(u8 X86EMU_UNUSED(op1))
 {
     s16 ip;
 
@@ -9516,7 +9516,7 @@
 REMARKS:
 Handles opcode 0xe3
 ****************************************************************************/
-void x86emuOp_jcxz(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jcxz(u8 X86EMU_UNUSED(op1))
 {
     u16 target;
     s8  offset;
@@ -9538,7 +9538,7 @@
 REMARKS:
 Handles opcode 0xe4
 ****************************************************************************/
-void x86emuOp_in_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_in_byte_AL_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 port;
 
@@ -9556,7 +9556,7 @@
 REMARKS:
 Handles opcode 0xe5
 ****************************************************************************/
-void x86emuOp_in_word_AX_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_in_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 {
     u8 port;
 
@@ -9582,7 +9582,7 @@
 REMARKS:
 Handles opcode 0xe6
 ****************************************************************************/
-void x86emuOp_out_byte_IMM_AL(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_out_byte_IMM_AL(u8 X86EMU_UNUSED(op1))
 {
     u8 port;
 
@@ -9600,7 +9600,7 @@
 REMARKS:
 Handles opcode 0xe7
 ****************************************************************************/
-void x86emuOp_out_word_IMM_AX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_out_word_IMM_AX(u8 X86EMU_UNUSED(op1))
 {
     u8 port;
 
@@ -9626,7 +9626,7 @@
 REMARKS:
 Handles opcode 0xe8
 ****************************************************************************/
-void x86emuOp_call_near_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_call_near_IMM(u8 X86EMU_UNUSED(op1))
 {
     s16 ip;
 
@@ -9647,7 +9647,7 @@
 REMARKS:
 Handles opcode 0xe9
 ****************************************************************************/
-void x86emuOp_jump_near_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_near_IMM(u8 X86EMU_UNUSED(op1))
 {
     int ip;
 
@@ -9666,7 +9666,7 @@
 REMARKS:
 Handles opcode 0xea
 ****************************************************************************/
-void x86emuOp_jump_far_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_far_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 cs, ip;
 
@@ -9687,7 +9687,7 @@
 REMARKS:
 Handles opcode 0xeb
 ****************************************************************************/
-void x86emuOp_jump_byte_IMM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_jump_byte_IMM(u8 X86EMU_UNUSED(op1))
 {
     u16 target;
     s8 offset;
@@ -9707,7 +9707,7 @@
 REMARKS:
 Handles opcode 0xec
 ****************************************************************************/
-void x86emuOp_in_byte_AL_DX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_in_byte_AL_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("IN\tAL,DX\n");
@@ -9721,7 +9721,7 @@
 REMARKS:
 Handles opcode 0xed
 ****************************************************************************/
-void x86emuOp_in_word_AX_DX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_in_word_AX_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -9743,7 +9743,7 @@
 REMARKS:
 Handles opcode 0xee
 ****************************************************************************/
-void x86emuOp_out_byte_DX_AL(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_out_byte_DX_AL(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("OUT\tDX,AL\n");
@@ -9757,7 +9757,7 @@
 REMARKS:
 Handles opcode 0xef
 ****************************************************************************/
-void x86emuOp_out_word_DX_AX(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_out_word_DX_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
@@ -9779,7 +9779,7 @@
 REMARKS:
 Handles opcode 0xf0
 ****************************************************************************/
-void x86emuOp_lock(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_lock(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("LOCK:\n");
@@ -9794,7 +9794,7 @@
 REMARKS:
 Handles opcode 0xf2
 ****************************************************************************/
-void x86emuOp_repne(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_repne(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("REPNE\n");
@@ -9808,7 +9808,7 @@
 REMARKS:
 Handles opcode 0xf3
 ****************************************************************************/
-void x86emuOp_repe(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_repe(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("REPE\n");
@@ -9822,7 +9822,7 @@
 REMARKS:
 Handles opcode 0xf4
 ****************************************************************************/
-void x86emuOp_halt(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_halt(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     DECODE_PRINTF("HALT\n");
@@ -9836,7 +9836,7 @@
 REMARKS:
 Handles opcode 0xf5
 ****************************************************************************/
-void x86emuOp_cmc(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cmc(u8 X86EMU_UNUSED(op1))
 {
     /* complement the carry flag. */
     START_OF_INSTR();
@@ -9851,7 +9851,7 @@
 REMARKS:
 Handles opcode 0xf6
 ****************************************************************************/
-void x86emuOp_opcF6_byte_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcF6_byte_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     u8 *destreg;
@@ -10135,7 +10135,7 @@
 REMARKS:
 Handles opcode 0xf7
 ****************************************************************************/
-void x86emuOp_opcF7_word_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcF7_word_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -10790,7 +10790,7 @@
 REMARKS:
 Handles opcode 0xf8
 ****************************************************************************/
-void x86emuOp_clc(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_clc(u8 X86EMU_UNUSED(op1))
 {
     /* clear the carry flag. */
     START_OF_INSTR();
@@ -10805,7 +10805,7 @@
 REMARKS:
 Handles opcode 0xf9
 ****************************************************************************/
-void x86emuOp_stc(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_stc(u8 X86EMU_UNUSED(op1))
 {
     /* set the carry flag. */
     START_OF_INSTR();
@@ -10820,7 +10820,7 @@
 REMARKS:
 Handles opcode 0xfa
 ****************************************************************************/
-void x86emuOp_cli(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cli(u8 X86EMU_UNUSED(op1))
 {
     /* clear interrupts. */
     START_OF_INSTR();
@@ -10835,7 +10835,7 @@
 REMARKS:
 Handles opcode 0xfb
 ****************************************************************************/
-void x86emuOp_sti(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_sti(u8 X86EMU_UNUSED(op1))
 {
     /* enable  interrupts. */
     START_OF_INSTR();
@@ -10850,7 +10850,7 @@
 REMARKS:
 Handles opcode 0xfc
 ****************************************************************************/
-void x86emuOp_cld(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_cld(u8 X86EMU_UNUSED(op1))
 {
     /* clear interrupts. */
     START_OF_INSTR();
@@ -10865,7 +10865,7 @@
 REMARKS:
 Handles opcode 0xfd
 ****************************************************************************/
-void x86emuOp_std(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_std(u8 X86EMU_UNUSED(op1))
 {
     /* clear interrupts. */
     START_OF_INSTR();
@@ -10880,7 +10880,7 @@
 REMARKS:
 Handles opcode 0xfe
 ****************************************************************************/
-void x86emuOp_opcFE_byte_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcFE_byte_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rh, rl;
     u8 destval;
@@ -10997,7 +10997,7 @@
 REMARKS:
 Handles opcode 0xff
 ****************************************************************************/
-void x86emuOp_opcFF_word_RM(u8 X86EMU_UNUSED(op1))
+static void x86emuOp_opcFF_word_RM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rh, rl;
     uint destoffset = 0;
Index: xc/extras/x86emu/src/x86emu/ops2.c
diff -u xc/extras/x86emu/src/x86emu/ops2.c:1.4 xc/extras/x86emu/src/x86emu/ops2.c:1.5
--- xc/extras/x86emu/src/x86emu/ops2.c:1.4	Thu Nov 16 14:44:50 2000
+++ xc/extras/x86emu/src/x86emu/ops2.c	Mon Jul 15 12:49:10 2002
@@ -37,7 +37,7 @@
 *               instructions.
 *
 ****************************************************************************/
-/* $XFree86: xc/extras/x86emu/src/x86emu/ops2.c,v 1.4 2000/11/16 19:44:50 eich Exp $ */
+/* $XFree86: xc/extras/x86emu/src/x86emu/ops2.c,v 1.5 2002/07/15 16:49:10 dawes Exp $ */
 
 #include "x86emu/x86emui.h"
 
@@ -50,7 +50,7 @@
 REMARKS:
 Handles illegal opcodes.
 ****************************************************************************/
-void x86emuOp2_illegal_op(
+static void x86emuOp2_illegal_op(
 	u8 op2)
 {
 	START_OF_INSTR();
@@ -68,7 +68,7 @@
 REMARKS:
 Handles opcode 0x0f,0x80-0x8F
 ****************************************************************************/
-void x86emuOp2_long_jump(u8 op2)
+static void x86emuOp2_long_jump(u8 op2)
 {
     s32 target;
     char *name = 0;
@@ -159,7 +159,7 @@
 REMARKS:
 Handles opcode 0x0f,0x90-0x9F
 ****************************************************************************/
-void x86emuOp2_set_byte(u8 op2)
+static void x86emuOp2_set_byte(u8 op2)
 {
     int mod, rl, rh;
     uint destoffset;
@@ -268,7 +268,7 @@
 REMARKS:
 Handles opcode 0x0f,0xa0
 ****************************************************************************/
-void x86emuOp2_push_FS(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_push_FS(u8 X86EMU_UNUSED(op2))
 {
     START_OF_INSTR();
     DECODE_PRINTF("PUSH\tFS\n");
@@ -282,7 +282,7 @@
 REMARKS:
 Handles opcode 0x0f,0xa1
 ****************************************************************************/
-void x86emuOp2_pop_FS(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_pop_FS(u8 X86EMU_UNUSED(op2))
 {
     START_OF_INSTR();
     DECODE_PRINTF("POP\tFS\n");
@@ -296,7 +296,7 @@
 REMARKS:
 Handles opcode 0x0f,0xa3
 ****************************************************************************/
-void x86emuOp2_bt_R(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_bt_R(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -417,7 +417,7 @@
 REMARKS:
 Handles opcode 0x0f,0xa4
 ****************************************************************************/
-void x86emuOp2_shld_IMM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_shld_IMM(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -554,7 +554,7 @@
 REMARKS:
 Handles opcode 0x0f,0xa5
 ****************************************************************************/
-void x86emuOp2_shld_CL(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_shld_CL(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -674,7 +674,7 @@
 REMARKS:
 Handles opcode 0x0f,0xa8
 ****************************************************************************/
-void x86emuOp2_push_GS(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_push_GS(u8 X86EMU_UNUSED(op2))
 {
     START_OF_INSTR();
     DECODE_PRINTF("PUSH\tGS\n");
@@ -688,7 +688,7 @@
 REMARKS:
 Handles opcode 0x0f,0xa9
 ****************************************************************************/
-void x86emuOp2_pop_GS(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_pop_GS(u8 X86EMU_UNUSED(op2))
 {
     START_OF_INSTR();
     DECODE_PRINTF("POP\tGS\n");
@@ -698,11 +698,12 @@
     END_OF_INSTR();
 }
 
+#if 0
 /****************************************************************************
 REMARKS:
 Handles opcode 0x0f,0xaa
 ****************************************************************************/
-void x86emuOp2_bts_R(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_bts_R(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -836,12 +837,13 @@
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
+#endif
 
 /****************************************************************************
 REMARKS:
 Handles opcode 0x0f,0xac
 ****************************************************************************/
-void x86emuOp2_shrd_IMM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_shrd_IMM(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -978,7 +980,7 @@
 REMARKS:
 Handles opcode 0x0f,0xad
 ****************************************************************************/
-void x86emuOp2_shrd_CL(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_shrd_CL(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint destoffset;
@@ -1098,7 +1100,7 @@
 REMARKS:
 Handles opcode 0x0f,0xaf
 ****************************************************************************/
-void x86emuOp2_imul_R_RM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_imul_R_RM(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -1275,7 +1277,7 @@
 REMARKS:
 Handles opcode 0x0f,0xb2
 ****************************************************************************/
-void x86emuOp2_lss_R_IMM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_lss_R_IMM(u8 X86EMU_UNUSED(op2))
 {
 	int mod, rh, rl;
     u16 *dstreg;
@@ -1324,7 +1326,7 @@
 REMARKS:
 Handles opcode 0x0f,0xb3
 ****************************************************************************/
-void x86emuOp2_btr_R(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_btr_R(u8 X86EMU_UNUSED(op2))
 {
 	int mod, rl, rh;
 	uint srcoffset;
@@ -1463,7 +1465,7 @@
 REMARKS:
 Handles opcode 0x0f,0xb4
 ****************************************************************************/
-void x86emuOp2_lfs_R_IMM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_lfs_R_IMM(u8 X86EMU_UNUSED(op2))
 {
 	int mod, rh, rl;
     u16 *dstreg;
@@ -1512,7 +1514,7 @@
 REMARKS:
 Handles opcode 0x0f,0xb5
 ****************************************************************************/
-void x86emuOp2_lgs_R_IMM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_lgs_R_IMM(u8 X86EMU_UNUSED(op2))
 {
 	int mod, rh, rl;
     u16 *dstreg;
@@ -1561,7 +1563,7 @@
 REMARKS:
 Handles opcode 0x0f,0xb6
 ****************************************************************************/
-void x86emuOp2_movzx_byte_R_RM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_movzx_byte_R_RM(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -1677,7 +1679,7 @@
 REMARKS:
 Handles opcode 0x0f,0xb7
 ****************************************************************************/
-void x86emuOp2_movzx_word_R_RM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_movzx_word_R_RM(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -1733,7 +1735,7 @@
 REMARKS:
 Handles opcode 0x0f,0xba
 ****************************************************************************/
-void x86emuOp2_btX_I(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_btX_I(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -1983,7 +1985,7 @@
 REMARKS:
 Handles opcode 0x0f,0xbb
 ****************************************************************************/
-void x86emuOp2_btc_R(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_btc_R(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -2122,7 +2124,7 @@
 REMARKS:
 Handles opcode 0x0f,0xbc
 ****************************************************************************/
-void x86emuOp2_bsf(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_bsf(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -2238,7 +2240,7 @@
 REMARKS:
 Handles opcode 0x0f,0xbd
 ****************************************************************************/
-void x86emuOp2_bsr(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_bsr(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -2354,7 +2356,7 @@
 REMARKS:
 Handles opcode 0x0f,0xbe
 ****************************************************************************/
-void x86emuOp2_movsx_byte_R_RM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_movsx_byte_R_RM(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
@@ -2470,7 +2472,7 @@
 REMARKS:
 Handles opcode 0x0f,0xbf
 ****************************************************************************/
-void x86emuOp2_movsx_word_R_RM(u8 X86EMU_UNUSED(op2))
+static void x86emuOp2_movsx_word_R_RM(u8 X86EMU_UNUSED(op2))
 {
     int mod, rl, rh;
     uint srcoffset;
Index: xc/extras/x86emu/src/x86emu/sys.c
diff -u xc/extras/x86emu/src/x86emu/sys.c:1.5 xc/extras/x86emu/src/x86emu/sys.c:1.7
--- xc/extras/x86emu/src/x86emu/sys.c:1.5	Wed Aug 23 18:10:01 2000
+++ xc/extras/x86emu/src/x86emu/sys.c	Tue Dec 24 12:42:58 2002
@@ -39,9 +39,10 @@
 *				user library.
 *
 ****************************************************************************/
-/* $XFree86: xc/extras/x86emu/src/x86emu/sys.c,v 1.5 2000/08/23 22:10:01 tsi Exp $ */
+/* $XFree86: xc/extras/x86emu/src/x86emu/sys.c,v 1.7 2002/12/24 17:42:58 tsi Exp $ */
 
 #include "x86emu.h"
+#include "x86emu/x86emui.h"
 #include "x86emu/regs.h"
 #include "x86emu/debug.h"
 #include "x86emu/prim_ops.h"
@@ -69,7 +70,7 @@
  * packed structures to talk about such things with.
  */
 
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
+#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
 struct __una_u64 { unsigned long  x __attribute__((packed)); };
 struct __una_u32 { unsigned int   x __attribute__((packed)); };
 struct __una_u16 { unsigned short x __attribute__((packed)); };
@@ -77,7 +78,7 @@
 
 static __inline__ unsigned long ldq_u(unsigned long * r11)
 {
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
+#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
 	const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
 	return ptr->x;
 #else
@@ -96,7 +97,7 @@
 
 static __inline__ unsigned long ldl_u(unsigned int * r11)
 {
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
+#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
 	const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
 	return ptr->x;
 #else
@@ -115,7 +116,7 @@
 
 static __inline__ unsigned long ldw_u(unsigned short * r11)
 {
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
+#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
 	const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
 	return ptr->x;
 #else
@@ -138,7 +139,7 @@
 
 static __inline__ void stq_u(unsigned long r5, unsigned long * r11)
 {
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
+#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
 	struct __una_u64 *ptr = (struct __una_u64 *) r11;
 	ptr->x = r5;
 #else
@@ -163,7 +164,7 @@
 
 static __inline__ void stl_u(unsigned long r5, unsigned int * r11)
 {
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
+#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
 	struct __una_u32 *ptr = (struct __una_u32 *) r11;
 	ptr->x = r5;
 #else
@@ -188,7 +189,7 @@
 
 static __inline__ void stw_u(unsigned long r5, unsigned short * r11)
 {
-#if __GNUC__ > 2 || __GNUC_MINOR__ >= 91
+#if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
 	struct __una_u16 *ptr = (struct __una_u16 *) r11;
 	ptr->x = r5;
 #else
@@ -522,7 +523,7 @@
 void X86EMU_setupMemFuncs(
 	X86EMU_memFuncs *funcs)
 {
-	sys_rdb = funcs->rdb;
+    sys_rdb = funcs->rdb;
     sys_rdw = funcs->rdw;
     sys_rdl = funcs->rdl;
     sys_wrb = funcs->wrb;
Index: xc/extras/x86emu/src/x86emu/x86emu/decode.h
diff -u xc/extras/x86emu/src/x86emu/x86emu/decode.h:1.1.1.1 xc/extras/x86emu/src/x86emu/x86emu/decode.h:1.3
--- xc/extras/x86emu/src/x86emu/x86emu/decode.h:1.1.1.1	Sat Jan 22 23:23:53 2000
+++ xc/extras/x86emu/src/x86emu/x86emu/decode.h	Mon Jul 22 21:51:03 2002
@@ -35,6 +35,7 @@
 * Description:  Header file for instruction decoding logic.
 *
 ****************************************************************************/
+/* $XFree86: xc/extras/x86emu/src/x86emu/x86emu/decode.h,v 1.3 2002/07/23 01:51:03 tsi Exp $ */
 
 #ifndef __X86EMU_DECODE_H
 #define __X86EMU_DECODE_H
@@ -76,9 +77,10 @@
 u16* 	decode_rm_word_register(int reg);
 u32* 	decode_rm_long_register(int reg);
 u16* 	decode_rm_seg_register(int reg);
-unsigned decode_rm00_address(int rm);
-unsigned decode_rm01_address(int rm);
-unsigned decode_rm10_address(int rm);
+u32	decode_rm00_address(int rm);
+u32	decode_rm01_address(int rm);
+u32	decode_rm10_address(int rm);
+u32	decode_sib_address(int sib, int mod);
 
 #ifdef  __cplusplus
 }                       			/* End of "C" linkage for C++   	*/